<mediawiki xmlns="http://www.mediawiki.org/xml/export-0.8/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mediawiki.org/xml/export-0.8/ http://www.mediawiki.org/xml/export-0.8.xsd" version="0.8" xml:lang="en">
  <siteinfo>
    <sitename>cppreference.com</sitename>
    <base>http://en.cppreference.com/w/Main_Page</base>
    <generator>MediaWiki 1.21.2</generator>
    <case>case-sensitive</case>
    <namespaces>
      <namespace key="-2" case="case-sensitive">Media</namespace>
      <namespace key="-1" case="first-letter">Special</namespace>
      <namespace key="0" case="case-sensitive" />
      <namespace key="1" case="case-sensitive">Talk</namespace>
      <namespace key="2" case="first-letter">User</namespace>
      <namespace key="3" case="first-letter">User talk</namespace>
      <namespace key="4" case="case-sensitive">Cppreference</namespace>
      <namespace key="5" case="case-sensitive">Cppreference talk</namespace>
      <namespace key="6" case="case-sensitive">File</namespace>
      <namespace key="7" case="case-sensitive">File talk</namespace>
      <namespace key="8" case="first-letter">MediaWiki</namespace>
      <namespace key="9" case="first-letter">MediaWiki talk</namespace>
      <namespace key="10" case="case-sensitive">Template</namespace>
      <namespace key="11" case="case-sensitive">Template talk</namespace>
      <namespace key="12" case="case-sensitive">Help</namespace>
      <namespace key="13" case="case-sensitive">Help talk</namespace>
      <namespace key="14" case="case-sensitive">Category</namespace>
      <namespace key="15" case="case-sensitive">Category talk</namespace>
    </namespaces>
  </siteinfo>
  <page>
    <title>Main Page</title>
    <ns>0</ns>
    <id>1</id>
    <revision>
      <id>72021</id>
      <parentid>72020</parentid>
      <timestamp>2014-07-08T20:55:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>color</comment>
      <text xml:space="preserve" bytes="6885">{{fmbox | class=noprint | style=background: #efe; |  text=[http://cppcon.org '''CppCon 2014''']  &lt;br/&gt;
It's the annual, week-long face-to-face gathering for the entire C++ community. [http://cppcon.org/registration Register now!]
}}
{{fmbox | class=noprint | style=background: #f0f0f0; |  text=We are thinking about adding a way to automatically hide information that is not relevant to a user-selected standand revision. [[Talk:Main_Page#RFC:_Integration_of_standards_revision_gadget | Thoughts and suggestions are welcome.]]
}}
{{title|C and C++ reference}}
{| class=&quot;mainpagetable&quot; cellspacing=0 style=&quot;width:100%; white-space:nowrap;&quot;
|- class=&quot;row rowtop&quot;
| colspan=3 |
[[cpp|&lt;span style=&quot;font-size: 2em;&quot;&gt;C++ reference&lt;/span&gt;&lt;br/&gt;
&lt;span style=&quot;font-size: 0.8em;&quot;&gt;C++98, C++03, C++11, C++14&lt;/span&gt;
]]
|- class=&quot;row&quot;
|
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/ascii | ASCII chart]]&lt;br/&gt;
[[cpp/compiler_support | Compiler support]]
&lt;/div&gt;
'''[[cpp/language | Language]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/preprocessor | Preprocessor]]&lt;br&gt;
[[cpp/keyword | Keywords]]&lt;br&gt;
[[cpp/language/operator_precedence | Operator precedence]]&lt;br&gt;
[[cpp/language/escape | Escape sequences]]&lt;br&gt;
[[cpp/language/types | Fundamental types]]
&lt;/div&gt;

'''[[cpp/header | Headers]]'''

'''[[cpp/concept | Concepts]]'''

'''[[cpp/utility | Utilities library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/types | Type support]]&lt;br/&gt;
[[cpp/memory | Dynamic memory management]]&lt;br/&gt;
[[cpp/error | Error handling]]&lt;br/&gt;
[[cpp/utility/program | Program utilities]]&lt;br/&gt;
[[cpp/chrono | Date and time]]&lt;br/&gt;
{{ltt|cpp/utility/bitset}}&lt;br/&gt;
[[cpp/utility/functional | Function objects]]&lt;br/&gt;
{{ltt|cpp/utility/pair}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;
{{ltt|cpp/utility/tuple}} {{mark c++11}}&lt;br/&gt;
{{ltt|cpp/utility/integer_sequence}} {{mark c++14}}
&lt;/div&gt;

|

'''[[cpp/string | Strings library]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/string/basic_string}}&lt;br&gt;
[[cpp/string/byte | Null-terminated byte strings]]&lt;br&gt;
[[cpp/string/multibyte | Null-terminated multibyte strings]]&lt;br&gt;
[[cpp/string/wide | Null-terminated wide strings]]
&lt;/div&gt;

'''[[cpp/container | Containers library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/container/array}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/vector}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;
{{ltt|cpp/container/deque}}&lt;br&gt;
{{ltt|cpp/container/list}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;{{ltt|cpp/container/forward_list}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/set}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;{{ltt|cpp/container/multiset}}&lt;br&gt;
{{ltt|cpp/container/map}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;{{ltt|cpp/container/multimap}}&lt;br&gt;
{{ltt|cpp/container/unordered_set}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_multiset}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_map}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_multimap}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/stack}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;{{ltt|cpp/container/queue}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;{{ltt|cpp/container/priority_queue}}
&lt;/div&gt;

'''[[cpp/algorithm | Algorithms library]]'''

'''[[cpp/iterator | Iterators library]]'''

'''[[cpp/numeric | Numerics library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/numeric/math | Common mathematical functions]]&lt;br&gt;
[[cpp/numeric/complex | Complex numbers]]&lt;br&gt;
[[cpp/numeric/random | Pseudo-random number generation]]
&lt;/div&gt;

|

'''[[cpp/io | Input/output library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/io/basic_streambuf}}&lt;br&gt;
{{ltt|cpp/io/basic_filebuf}}&lt;br&gt;
{{ltt|cpp/io/basic_stringbuf}}&lt;br&gt;
{{ltt|cpp/io/ios_base}}&lt;br&gt;
{{ltt|cpp/io/basic_ios}}&lt;br&gt;
{{ltt|cpp/io/basic_istream}}&lt;br&gt;
{{ltt|cpp/io/basic_ostream}}&lt;br&gt;
{{ltt|cpp/io/basic_iostream}}&lt;br&gt;
{{ltt|cpp/io/basic_ifstream}}&lt;br&gt;
{{ltt|cpp/io/basic_ofstream}}&lt;br&gt;
{{ltt|cpp/io/basic_fstream}}&lt;br&gt;
{{ltt|cpp/io/basic_istringstream}}&lt;br&gt;
{{ltt|cpp/io/basic_ostringstream}}&lt;br&gt;
{{ltt|cpp/io/basic_stringstream}}&lt;br&gt;
[[cpp/io/manip | I/O manipulators]]&lt;br&gt;
[[cpp/io/c | C-style I/O ]]
&lt;/div&gt;

'''[[cpp/locale | Localizations library]]'''

'''[[cpp/regex | Regular expressions library]]''' {{mark c++11}}

'''[[cpp/atomic | Atomic operations library]]''' {{mark c++11}}

'''[[cpp/thread | Thread support library]]''' {{mark c++11}}

|- class=&quot;row&quot;
| colspan=3 | '''[[cpp/experimental | Experimental standard libraries]]'''&lt;br&gt;
'''[[cpp/experimental/lib_extensions | Standard library extensions]]'''&amp;nbsp;&amp;nbsp;{{mark since libfund_ts}}
&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/experimental/optional}}&lt;br&gt;
{{ltt|cpp/experimental/any}}&lt;br&gt;
{{ltt|cpp/experimental/basic_string_view}}&lt;br&gt;
[[cpp/experimental/memory | Polymorphic allocator library]]
&lt;/div&gt;
'''[[cpp/experimental/fs | Filesystem library]]'''&amp;nbsp;&amp;nbsp;{{mark since fs_ts}}
|- class=&quot;row rowbottom&quot;
| colspan=3 | [[cpp/links|External Links]]&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;[[cpp/links/libs|Non-ANSI/ISO Libraries]]
|-
| &lt;span style=&quot;margin:12px;&quot;&gt;&lt;/span&gt;
|- class=&quot;row rowtop&quot;
| colspan=3 |
[[c|&lt;span style=&quot;font-size: 2em;&quot;&gt;C reference&lt;/span&gt;&lt;br/&gt;
&lt;span style=&quot;font-size: 0.8em;&quot;&gt;C89, C99, C11&lt;/span&gt;
]]
|- class=&quot;row&quot;
|
&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/language/ascii | ASCII chart]]
&lt;/div&gt;
'''[[c/language | Language]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/preprocessor | Preprocessor]]&lt;br&gt;
[[c/keyword | Keywords]]&lt;br&gt;
[[c/language/operator_precedence | Operator precedence]]&lt;br&gt;
[[cpp/language/escape | Escape sequences]]
&lt;/div&gt;

'''[[c/header | Headers]]'''

'''[[c/types | Type support]]'''

|

'''[[c/memory | Dynamic memory management]]'''

'''[[c/error | Error handling]]'''

'''[[c/program | Program utilities]]'''

'''[[c/chrono | Date and time utilities]]'''

'''[[c/string | Strings library]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/string/byte | NULL-terminated byte strings]]&lt;br&gt;
[[c/string/multibyte | NULL-terminated multibyte strings]]&lt;br&gt;
[[c/string/wide | NULL-terminated wide strings]]
&lt;/div&gt;

'''[[c/algorithm | Algorithms]]'''

|

'''[[c/numeric | Numerics]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/numeric/math | Mathematical functions]]&lt;br&gt;
[[c/numeric/fenv | Floating-point environment]] {{mark c99}}&lt;br&gt;
[[c/numeric/random | Pseudo-random number generation]]&lt;br&gt;
[[c/numeric/complex | Complex number arithmetic]] {{mark c99}}&lt;br&gt;
[[c/numeric/tgmath | Type-generic math]] {{mark c99}}

&lt;/div&gt;

'''[[c/io | Input/output support]]'''

'''[[c/locale | Localization support]]'''

'''[[c/atomic | Atomic operations library]]''' {{mark c11}}

'''[[c/thread | Thread support library]]''' {{mark c11}}
|- class=&quot;row rowbottom&quot;
| colspan=3 | [[c/links|External Links]]&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;[[c/links/libs|Non-ANSI/ISO Libraries]]
|-
|}

{| class=&quot;mainpagetable&quot; cellspacing=0 style=&quot;padding: 2em 2em; width: 100%; box-sizing: border-box; -moz-box-sizing: border-box; -webkit-box-sizing: border-box;&quot;
|- class=&quot;row rowtop&quot;
| &lt;span style=&quot;font-size: 1.5em;&quot;&gt;News&lt;/span&gt;
|- class=&quot;row rowbottom&quot;
| {{news}}
|}

[[ar:]]
[[cs:]]
[[de:]]
[[es:]]
[[fr:]]
[[it:]]
[[ja:]]
[[ko:]]
[[pl:]]
[[pt:]]
[[ru:]]
[[tr:]]
[[zh:]]</text>
      <sha1>9443vumhsmg1vjzidsj0cqpd9c5h4xw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c</title>
    <ns>0</ns>
    <id>5742</id>
    <revision>
      <id>67636</id>
      <parentid>63917</parentid>
      <timestamp>2014-02-14T23:47:13Z</timestamp>
      <contributor>
        <username>Samy</username>
        <id>2858</id>
      </contributor>
      <minor/>
      <comment>added link to cs translation</comment>
      <text xml:space="preserve" bytes="1542">{{title|1=C reference}}
{| cellpadding=&quot;5&quot; style=&quot;font-size: 120%;&quot; 
|- valign=&quot;top&quot;
| 

'''[[Cppreference:FAQ|FAQ]]'''

'''[[c/language | Language]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/preprocessor | Preprocessor]]&lt;br&gt;
[[c/keyword | Keywords]]&lt;br&gt;
[[c/language/operator_precedence | Operator precedence]]&lt;br&gt;
[[cpp/language/escape | Escape sequences]]&lt;br&gt;
[[c/language/ascii | ASCII chart]]
&lt;/div&gt;

'''[[c/header | Headers]]'''

'''[[c/types | Type support]]'''

'''[[c/memory | Dynamic memory&lt;br/&gt; management]]'''

|

'''[[c/error | Error handling]]'''

'''[[c/program | Program utilities]]'''

'''[[c/chrono | Date and time utilities]]'''

'''[[c/string | Strings library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/string/byte | Null-terminated byte strings]]&lt;br&gt;
[[c/string/multibyte | Null-terminated multibyte strings]]&lt;br&gt;
[[c/string/wide | Null-terminated wide strings]]
&lt;/div&gt;

'''[[c/algorithm | Algorithms]]'''

'''[[c/io | Input/output support]]'''

|

'''[[c/numeric | Numerics]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[c/numeric/math | Mathematical functions]]&lt;br&gt;
[[c/numeric/fenv | Floating-point environment]]&lt;br&gt;
[[c/numeric/random | Pseudo-random number generation]]&lt;br&gt;
[[c/numeric/complex| Complex number arithmetic]]&lt;br/&gt;
[[c/numeric/tgmath | Type-generic math]]
&lt;/div&gt;

'''[[c/locale | Localization support]]'''

'''[[c/atomic | Atomic operations library]]''' {{mark since c11}}

'''[[c/thread | Thread support library]]''' {{mark since c11}}
|}

[[cs:c]]
[[de:c]]
[[es:c]]
[[fr:c]]
[[it:c]]
[[ja:c]]
[[ko:c]]
[[pt:c]]
[[ru:c]]
[[zh:c]]</text>
      <sha1>b7a6tang5bfemrwy299lhy58gkmj96n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/algorithm</title>
    <ns>0</ns>
    <id>5966</id>
    <revision>
      <id>71028</id>
      <parentid>70991</parentid>
      <timestamp>2014-06-04T20:05:02Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="417">{{title|Algorithms}}
{{c/algorithm/navbar}}

{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc inc | c/algorithm/dsc qsort}}
{{dsc inc | c/algorithm/dsc bsearch}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/algorithm |Algorithms library}}
{{dsc end}}

[[de:c/algorithm]]
[[es:c/algorithm]]
[[fr:c/algorithm]]
[[it:c/algorithm]]
[[ja:c/algorithm]]
[[pt:c/algorithm]]
[[ru:c/algorithm]]
[[zh:c/algorithm]]</text>
      <sha1>jphd2bk6eeuru3rb8kzffxwkoi2lgou</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/algorithm/bsearch</title>
    <ns>0</ns>
    <id>6121</id>
    <revision>
      <id>65048</id>
      <parentid>56340</parentid>
      <timestamp>2013-08-30T14:45:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>spacing</comment>
      <text xml:space="preserve" bytes="2292">{{c/title|bsearch}}
{{c/algorithm/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl |
void* bsearch( const void* key, const void* ptr, size_t count, size_t size,
               int (*comp)(const void*, const void*) );
}}
{{dcl end}}

Finds an element equal to element pointed to by {{tt|key}} in a sorted array pointed to by {{tt|ptr}}. The array contains {{tt|count}} elements of {{tt|size}} bytes. The elements are compared using function pointed to by {{tt|comp}}. 

The behavior is undefined if the array is not already sorted in ascending order according to the same criteria that {{tt|comp}} uses.

If the array contains several elements that {{tt|comp}} would indicate as equal to the element searched for, then it is undefined which element the function will return as the result.

===Parameters===
{{par begin}}
{{par | key | pointer to the element to search for}}
{{par | ptr | pointer to the array to examine}}
{{par | count | number of element in the array}}
{{par | size | size of each element in the array in bytes}}
{{par ccmp | comp | {{tt|key}} is passed as the first argument, an element from the array as the second.}}
{{par end}}

===Return value===
Pointer to the found element or {{lc|NULL}} if such element has not been found.

===Example===
{{example
 |
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

struct data {
    int nr;
    char const *value;
} dat[] = {
    {1, &quot;Foo&quot;}, {2, &quot;Bar&quot;}, {3, &quot;Hello&quot;}, {4, &quot;World&quot;}
};

int data_cmp(void const *lhs, void const *rhs) 
{
    struct data const *const l = lhs;
    struct data const *const r = rhs;
    return l-&gt;nr - r-&gt;nr;
}

int main(void) 
{
    struct data key = { .nr = 3 };
    struct data const *res = bsearch(&amp;key, dat, sizeof(dat)/sizeof(dat[0]),
                                   sizeof(dat[0]), data_cmp);
    if (!res) {
        printf(&quot;No %d not found\n&quot;, key.nr);
    } else {
        printf(&quot;No %d: %s\n&quot;, res-&gt;nr, res-&gt;value);
    }
}
 | output=
No 3: Hello
}}

===See also===
{{dsc begin}}
{{dsc inc | c/algorithm/dsc qsort}}
{{dsc see cpp | cpp/algorithm/bsearch}}
{{dsc end}}

[[de:c/algorithm/bsearch]]
[[es:c/algorithm/bsearch]]
[[fr:c/algorithm/bsearch]]
[[it:c/algorithm/bsearch]]
[[ja:c/algorithm/bsearch]]
[[pt:c/algorithm/bsearch]]
[[ru:c/algorithm/bsearch]]
[[zh:c/algorithm/bsearch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/algorithm/qsort</title>
    <ns>0</ns>
    <id>6120</id>
    <revision>
      <id>66505</id>
      <parentid>56343</parentid>
      <timestamp>2013-11-27T16:31:36Z</timestamp>
      <contributor>
        <username>Seishun</username>
        <id>2538</id>
      </contributor>
      <comment>Fixed function signature</comment>
      <text xml:space="preserve" bytes="1648">{{c/title|qsort}}
{{c/algorithm/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl |
void qsort( void *ptr, size_t count, size_t size,
            int (*comp)(const void *, const void *) );
}}
{{dcl end}}

Sorts the given array pointed to by {{tt|ptr}} in ascending order. The array contains {{tt|count}} elements of {{tt|size}} bytes. Function pointed to by {{tt|comp}} is used for object comparison.

If {{tt|comp}} indicates two elements as equivalent, their order is undefined.

===Parameters===
{{par begin}}
{{par | ptr | pointer to the array to sort}}
{{par | count | number of element in the array}}
{{par | size | size of each element in the array in bytes}}
{{par ccmp | comp }}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | The following code sorts an array of integers using {{tt|qsort()}}
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int compare_ints(const void* a, const void* b)
{
    const int *arg1 = a;
    const int *arg2 = b;

    return *arg1 - *arg2;
}
 
int main(void)
{
    int i;
    int ints[] = { -2, 99, 0, -743, 2, 3, 4 };
    int size = sizeof ints / sizeof *ints;
 
    qsort(ints, size, sizeof(int), compare_ints);
 
    for (i = 0; i &lt; size; i++) {
        printf(&quot;%d &quot;, ints[i]);
    }

    printf(&quot;\n&quot;);

    return EXIT_SUCCESS;
}
 | output=
-743 -2 0 2 3 4 99
}}

===See also===
{{dsc begin}}
{{dsc inc | c/algorithm/dsc bsearch}}
{{dsc see cpp | cpp/algorithm/qsort}}
{{dsc end}}

[[de:c/algorithm/qsort]]
[[es:c/algorithm/qsort]]
[[fr:c/algorithm/qsort]]
[[it:c/algorithm/qsort]]
[[ja:c/algorithm/qsort]]
[[pt:c/algorithm/qsort]]
[[ru:c/algorithm/qsort]]
[[zh:c/algorithm/qsort]]</text>
      <sha1>n0qotwlu0nf2vxg08qyqa0ml45j6aom</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/align/alignas</title>
    <ns>0</ns>
    <id>13712</id>
    <revision>
      <id>72394</id>
      <parentid>72391</parentid>
      <timestamp>2014-08-19T13:39:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72391 by [[Special:Contributions/94.176.102.31|94.176.102.31]] ([[User talk:94.176.102.31|talk]]) _Alignas is a keyword</comment>
      <text xml:space="preserve" bytes="2119">{{title|alignas}}
{{c/align/alignas/navbar}}

Specifies the alignment requirement of a type or an object.

{{todo|this is a copy of the C++ reference page with minor modifications, it needs to be re-written for C}}

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|alignas(}} {{spar|constant-expression}} {{ttb|)}} | notes={{mark since c11}}}}
{{sdsc | {{ttb|alignas(}} {{spar|type-name}} {{ttb|)}} | notes={{mark since c11}}}}
{{sdsc end}}

===Explanation===

The {{c|alignas}} macro may be applied to the declaration of a variable or to the definition of a struct, union or enum.

When used in form {{c|alignas(constant-expression)}}, and {{spar|constant-expression}} is an integral constant expression that evaluates to a positive value, the declared entity will have its alignment requirement set to exactly the result of the {{spar|constant-expression}}, except if it would weaken the natural alignment requirement of the type.

When used in form {{c|alignas(type-name)}}, it is exactly equivalent to {{c|alignas(alignof(type-name))}}, that is, the alignment requirement of the declared entity will be equal the alignment requirement of {{spar|type-name}}.

===Notes===
{{c|alignas(0)}} has no effect.

When multiple {{c|alignas}} macros are applied to the same variable, the strictest one is used.

As of the ISO C11 standard, the C language has the {{c|_Alignas}} keyword and defines in the header {{c|&lt;stdalign.h&gt;}} the preprocessor macro {{c|alignas}} which expands to the keyword.

===Keywords===

{{ltt|c/keyword/_Alignas}}

===Example===

{{example
 |code=
#include &lt;stdio.h&gt;
#include &lt;stdalign.h&gt;

alignas(16) char a,b;
char c;

int main(void)
{
    printf(&quot;%p\n&quot;, (void*)&amp;a);
    printf(&quot;%p\n&quot;, (void*)&amp;b);
    printf(&quot;%p\n&quot;, (void*)&amp;c);
}
 | p=true
 | output=
0x601040
0x601030
0x601031
}}

===See also===
{{dsc begin}}
{{dsc inc | c/align/dsc alignof}}
{{dsc see cpp | cpp/language/alignas | alignas specifier}}
{{dsc end}}

[[de:c/align/alignas]]
[[es:c/align/alignas]]
[[fr:c/align/alignas]]
[[it:c/align/alignas]]
[[ja:c/align/alignas]]
[[pt:c/align/alignas]]
[[ru:c/align/alignas]]
[[zh:c/align/alignas]]</text>
      <sha1>ta7s0yt31ihqa09f8hm4rstsuzjrr62</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/align/alignof</title>
    <ns>0</ns>
    <id>13713</id>
    <revision>
      <id>72393</id>
      <parentid>72392</parentid>
      <timestamp>2014-08-19T13:38:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72392 by [[Special:Contributions/94.176.102.31|94.176.102.31]] ([[User talk:94.176.102.31|talk]]) _Alignof is a keyword</comment>
      <text xml:space="preserve" bytes="1872">{{title|alignof {{mark since c11}}}}
{{c/align/alignof/navbar}}

Queries alignment requirements of a type.

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|alignof(}} {{spar|type-name}} {{ttb|)}}}}
{{sdsc end}}

===Expanded value===
a value of type {{lc|size_t}}.

===Explanation===
Returns {{rlp|object#Alignment|the alignment}}, in bytes, required for any instance of the type indicated by [[c/language/type#Type_naming|type-name]], which is either complete type or array type. 

If the type is array type, alignment requirement of the element type is returned.

The types {{c|char}}, {{c|signed char}}, and {{c|unsigned char}} have the weakest (smallest) alignment supported by the implementation.

===Keywords===
{{ltt|c/keyword/_Alignof}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdalign.h&gt;
 
struct foo
{
    int f2;
    float f1;
    char c;
};

int array_a[5];
double array_b[10];
 
int main(void)
{
    printf(&quot;alignment of char:         %zu\n&quot;, alignof(char));
    printf(&quot;alignment of pointer:      %zu\n&quot;, alignof(int*));
    printf(&quot;alignment of struct foo:   %zu\n&quot;, alignof(struct foo));
    printf(&quot;alignment of array_a:      %zu\n&quot;, alignof(array_a));
    printf(&quot;alignment of array_b:      %zu\n&quot;, alignof(array_b));
}
 | p=true
 | output=
alignment of char:         1
alignment of pointer:      8
alignment of struct foo:   4
alignment of array_a:      4
alignment of array_b:      8
}}

===See also===
{{dsc begin}}
{{dsc | [[c/language/object#Alignment | alignment requirement ]] | restricts the addresses at which an object may be allocated }}
{{dsc inc | c/align/dsc alignas}}
{{dsc see cpp | cpp/language/alignof | alignof operator}}
{{dsc end}}

[[de:c/align/alignof]]
[[es:c/align/alignof]]
[[fr:c/align/alignof]]
[[it:c/align/alignof]]
[[ja:c/align/alignof]]
[[pt:c/align/alignof]]
[[ru:c/align/alignof]]
[[zh:c/align/alignof]]</text>
      <sha1>5jqoj7u0hupes4jq85514jt5djz0fu5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic</title>
    <ns>0</ns>
    <id>6532</id>
    <revision>
      <id>71022</id>
      <parentid>71008</parentid>
      <timestamp>2014-06-04T19:38:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="4038">{{title|Atomic operations library}}
{{c/atomic/navbar}}

If the macro constant {{tt|__STDC_NO_ATOMICS__}}{{mark c11}} is defined by the compiler, the header {{tt|&lt;stdatomic.h&gt;}}, the keyword {{c|_Atomic}}, and all of the names listed here are not provided.

===Types===
{{dsc begin}}
{{dsc header | stdatomic.h}}
{{dsc inc | c/atomic/dsc memory_order}}
{{dsc inc | c/atomic/dsc atomic_flag}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc header | stdatomic.h}}
{{dsc inc | c/atomic/dsc ATOMIC_LOCK_FREE_consts}}
{{dsc inc | c/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc inc | c/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc inc | c/atomic/dsc kill_dependency}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc header | stdatomic.h}}
{{dsc inc | c/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | c/atomic/dsc atomic_flag_clear}}
{{dsc inc | c/atomic/dsc atomic_init}}
{{dsc inc | c/atomic/dsc atomic_is_lock_free}}
{{dsc inc | c/atomic/dsc atomic_store}}
{{dsc inc | c/atomic/dsc atomic_load}}
{{dsc inc | c/atomic/dsc atomic_exchange}}
{{dsc inc | c/atomic/dsc atomic_compare_exchange}}
{{dsc inc | c/atomic/dsc atomic_fetch_add}}
{{dsc inc | c/atomic/dsc atomic_fetch_sub}}
{{dsc inc | c/atomic/dsc atomic_fetch_or}}
{{dsc inc | c/atomic/dsc atomic_fetch_xor}}
{{dsc inc | c/atomic/dsc atomic_fetch_and}}
{{dsc inc | c/atomic/dsc atomic_thread_fence}}
{{dsc inc | c/atomic/dsc atomic_signal_fence}}
{{dsc end}}

===Types===
{{todo|description}}
{{dsc begin}}
{{dsc hitem | Typedef name | Full type name }}
{{dsc | {{tt|atomic_bool}} | {{c|_Atomic _Bool}} }}
{{dsc | {{tt|atomic_char}} | {{c|_Atomic char}} }}
{{dsc | {{tt|atomic_schar}} | {{c|_Atomic signed char}} }}
{{dsc | {{tt|atomic_uchar}} | {{c|_Atomic unsigned char}} }}
{{dsc | {{tt|atomic_short}} | {{c|_Atomic short}} }}
{{dsc | {{tt|atomic_ushort}} | {{c|_Atomic unsigned short}} }}
{{dsc | {{tt|atomic_int}} | {{c|_Atomic int}} }}
{{dsc | {{tt|atomic_uint}} | {{c|_Atomic unsigned int}} }}
{{dsc | {{tt|atomic_long}} | {{c|_Atomic long}} }}
{{dsc | {{tt|atomic_ulong}} | {{c|_Atomic unsigned long}} }}
{{dsc | {{tt|atomic_llong}} | {{c|_Atomic long long}} }}
{{dsc | {{tt|atomic_ullong}} | {{c|_Atomic unsigned long long}} }}
{{dsc | {{tt|atomic_char16_t}} | {{c|_Atomic char16_t}} }}
{{dsc | {{tt|atomic_char32_t}} | {{c|_Atomic char32_t}} }}
{{dsc | {{tt|atomic_wchar_t}} | {{c|_Atomic wchar_t}} }}
{{dsc | {{tt|atomic_int_least8_t}} | {{c|_Atomic int_least8_t}} }}
{{dsc | {{tt|atomic_uint_least8_t}} | {{c|_Atomic uint_least8_t}} }}
{{dsc | {{tt|atomic_int_least16_t}} | {{c|_Atomic int_least16_t}} }}
{{dsc | {{tt|atomic_uint_least16_t}} | {{c|_Atomic uint_least16_t}} }}
{{dsc | {{tt|atomic_int_least32_t}} | {{c|_Atomic int_least32_t}} }}
{{dsc | {{tt|atomic_uint_least32_t}} | {{c|_Atomic uint_least32_t}} }}
{{dsc | {{tt|atomic_int_least64_t}} | {{c|_Atomic int_least64_t}} }}
{{dsc | {{tt|atomic_uint_least64_t}} | {{c|_Atomic uint_least64_t}} }}
{{dsc | {{tt|atomic_int_fast8_t}} | {{c|_Atomic int_fast8_t}} }}
{{dsc | {{tt|atomic_uint_fast8_t}} | {{c|_Atomic uint_fast8_t}} }}
{{dsc | {{tt|atomic_int_fast16_t}} | {{c|_Atomic int_fast16_t}} }}
{{dsc | {{tt|atomic_uint_fast16_t}} | {{c|_Atomic uint_fast16_t}} }}
{{dsc | {{tt|atomic_int_fast32_t}} | {{c|_Atomic int_fast32_t}} }}
{{dsc | {{tt|atomic_uint_fast32_t}} | {{c|_Atomic uint_fast32_t}} }}
{{dsc | {{tt|atomic_int_fast64_t}} | {{c|_Atomic int_fast64_t}} }}
{{dsc | {{tt|atomic_uint_fast64_t}} | {{c|_Atomic uint_fast64_t}} }}
{{dsc | {{tt|atomic_intptr_t}} | {{c|_Atomic intptr_t}} }}
{{dsc | {{tt|atomic_uintptr_t}} | {{c|_Atomic uintptr_t}} }}
{{dsc | {{tt|atomic_size_t}} | {{c|_Atomic size_t}} }}
{{dsc | {{tt|atomic_ptrdiff_t}} | {{c|_Atomic ptrdiff_t}} }}
{{dsc | {{tt|atomic_intmax_t}} | {{c|_Atomic intmax_t}} }}
{{dsc | {{tt|atomic_uintmax_t}} | {{c|_Atomic uintmax_t}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/atomic |Atomic operations library}}
{{dsc end}}

[[de:c/atomic]]
[[es:c/atomic]]
[[fr:c/atomic]]
[[it:c/atomic]]
[[ja:c/atomic]]
[[pt:c/atomic]]
[[ru:c/atomic]]
[[zh:c/atomic]]</text>
      <sha1>jd484nf5z54wq0zjcilz178ugcjzk0v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/ATOMIC FLAG INIT</title>
    <ns>0</ns>
    <id>9267</id>
    <revision>
      <id>63519</id>
      <parentid>56347</parentid>
      <timestamp>2013-07-10T01:35:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="652">{{c/title|ATOMIC_FLAG_FREE}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
#define ATOMIC_FLAG_INIT /* unspecified */
}}

Expands to an expression that can be used to initialize {{lc|atomic_flag}} type. The value {{tt|atomic_flag}} that is not initialized using this macro is undefined.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc end}}

[[de:c/atomic/ATOMIC FLAG INIT]]
[[es:c/atomic/ATOMIC FLAG INIT]]
[[fr:c/atomic/ATOMIC FLAG INIT]]
[[it:c/atomic/ATOMIC FLAG INIT]]
[[ja:c/atomic/ATOMIC FLAG INIT]]
[[pt:c/atomic/ATOMIC FLAG INIT]]
[[ru:c/atomic/ATOMIC FLAG INIT]]
[[zh:c/atomic/ATOMIC FLAG INIT]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/ATOMIC LOCK FREE consts</title>
    <ns>0</ns>
    <id>9266</id>
    <revision>
      <id>63520</id>
      <parentid>48815</parentid>
      <timestamp>2013-07-10T01:35:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1432">{{c/title|ATOMIC_*_LOCK_FREE}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
#define ATOMIC_BOOL_LOCK_FREE     /* implementation-defined */
#define ATOMIC_CHAR_LOCK_FREE     /* implementation-defined */
#define ATOMIC_CHAR16_T_LOCK_FREE /* implementation-defined */
#define ATOMIC_CHAR32_T_LOCK_FREE /* implementation-defined */
#define ATOMIC_WCHAR_T_LOCK_FREE  /* implementation-defined */
#define ATOMIC_SHORT_LOCK_FREE    /* implementation-defined */
#define ATOMIC_INT_LOCK_FREE      /* implementation-defined */
#define ATOMIC_LONG_LOCK_FREE     /* implementation-defined */
#define ATOMIC_LLONG_LOCK_FREE    /* implementation-defined */
#define ATOMIC_POINTER_LOCK_FREE  /* implementation-defined */
}}

Expands to either {{tt|0}}, {{tt|1}} or {{tt|2}} which indicate the lock-free property of the corresponding atomic types (both signed and unsigned).

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | {{tt|0}} | The atomic type is never lock-free}}
{{dsc | {{tt|1}} | The atomic type is sometimes lock-free}}
{{dsc | {{tt|2}} | The atomic type is always lock-free}}
{{dsc end}}

[[de:c/atomic/ATOMIC LOCK FREE consts]]
[[es:c/atomic/ATOMIC LOCK FREE consts]]
[[fr:c/atomic/ATOMIC LOCK FREE consts]]
[[it:c/atomic/ATOMIC LOCK FREE consts]]
[[ja:c/atomic/ATOMIC LOCK FREE consts]]
[[pt:c/atomic/ATOMIC LOCK FREE consts]]
[[ru:c/atomic/ATOMIC LOCK FREE consts]]
[[zh:c/atomic/ATOMIC LOCK FREE consts]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/ATOMIC VAR INIT</title>
    <ns>0</ns>
    <id>9268</id>
    <revision>
      <id>63521</id>
      <parentid>56348</parentid>
      <timestamp>2013-07-10T01:35:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1106">{{c/title|ATOMIC_VAR_INIT}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
#define ATOMIC_VAR_INIT(value) /* unspecified */
}}

Expands to an expression that can be used to initialize an atomic variable of the same type as {{tt|value}}. The initial value of atomic object of automatic storage duration that is not initialized using this macro is undefined. The default (zero) initialization of static and thread-local variables produces valid value however.

If this macro is not used for initialization of an atomic variable, any accesses during initialization from another thread, even through an atomic operation, is a data race (it may happen if the address is immediately passed to another thread with a {{lc|memory_order_relaxed}} operation).

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc end}}

[[de:c/atomic/ATOMIC VAR INIT]]
[[es:c/atomic/ATOMIC VAR INIT]]
[[fr:c/atomic/ATOMIC VAR INIT]]
[[it:c/atomic/ATOMIC VAR INIT]]
[[ja:c/atomic/ATOMIC VAR INIT]]
[[pt:c/atomic/ATOMIC VAR INIT]]
[[ru:c/atomic/ATOMIC VAR INIT]]
[[zh:c/atomic/ATOMIC VAR INIT]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic compare exchange</title>
    <ns>0</ns>
    <id>9302</id>
    <revision>
      <id>62484</id>
      <parentid>56351</parentid>
      <timestamp>2013-07-01T23:22:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="3521">{{c/title|atomic_compare_exchange_weak|atomic_compare_exchange_strong|atomic_compare_exchange_weak_explicit|atomic_compare_exchange_strong_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
_Bool atomic_compare_exchange_strong( volatile A* obj,
                                      C* expected, C desired );
}}
{{dcl | since=c11 | num=2 |
_Bool atomic_compare_exchange_weak( volatile A *obj, 
                                    C* expected, C desired );
}}
{{dcl | since=c11 | num=3 |
_Bool atomic_compare_exchange_strong_explicit( volatile A* obj, 
                                               C* expected, C desired,
                                               memory_order succ, 
                                               memory_order fail );
}}
{{dcl | since=c11 | num=4 |
_Bool atomic_compare_exchange_weak_explicit( volatile A *obj, 
                                             C* expected, C desired,
                                             memory_order succ, 
                                             memory_order fail );
}}
{{dcl end}}

Atomically compares the value pointed to by {{tt|obj}} with the value pointed to by {{tt|expected}}, and if those are equal, replaces the former with {{tt|desired}} (performs read-modify-write operation). Otherwise, loads the actual value pointed to by {{tt|obj}} into {{tt|*expected}} (performs load operation).

The memory models for the read-modify-write and load operations are {{tt|succ}} and {{tt|fail}} respectively. The (1-2) versions use {{lc|memory_order_seq_cst}} by default.

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if {{c|1=*obj != *expected}} even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|C}} is the non-atomic type corresponding to {{tt|A}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to test and modify}}
{{par | expected | pointer to the value expected to be found in the atomic object}}
{{par | desired | the value to store in the atomic object if it is as expected}}
{{par | succ | the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. }}
{{par | fail | the memory synchronization ordering for the load operation if the comparison fails. Cannot be {{lc|memory_order_release}} or {{lc|memory_order_acq_rel}} and cannot specify stronger ordering than {{tt|succ}}}}
{{par end}} 

===Return value===
The result of the comparison: {{c|true}} if {{tt|*obj}} was equal to {{tt|*exp}}, {{c|false}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_exchange}}
{{dsc see cpp | cpp/atomic/atomic_compare_exchange | atomic_compare_exchange_weak | atomic_compare_exchange_strong | atomic_compare_exchange_weak_explicit | atomic_compare_exchange_strong_explicit}}
{{dsc end}}

[[de:c/atomic/atomic compare exchange]]
[[es:c/atomic/atomic compare exchange]]
[[fr:c/atomic/atomic compare exchange]]
[[it:c/atomic/atomic compare exchange]]
[[ja:c/atomic/atomic compare exchange]]
[[pt:c/atomic/atomic compare exchange]]
[[ru:c/atomic/atomic compare exchange]]
[[zh:c/atomic/atomic compare exchange]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic exchange</title>
    <ns>0</ns>
    <id>9303</id>
    <revision>
      <id>62485</id>
      <parentid>56352</parentid>
      <timestamp>2013-07-01T23:22:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1609">{{c/title|atomic_exchange|atomic_exchange_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_exchange( volatile A* obj, C desired );
}}
{{dcl | since=c11 | num=2 |
C atomic_exchange_explicit( volatile A* obj, C desired, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with {{tt|desired}} and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}. 

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|C}} is the non-atomic type corresponding to {{tt|A}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | desired | the value to replace the atomic object with}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_compare_exchange}}
{{dsc see cpp | cpp/atomic/atomic_exchange | atomic_exchange | atomic_exchange_explicit}}
{{dsc end}}

[[de:c/atomic/atomic exchange]]
[[es:c/atomic/atomic exchange]]
[[fr:c/atomic/atomic exchange]]
[[it:c/atomic/atomic exchange]]
[[ja:c/atomic/atomic exchange]]
[[pt:c/atomic/atomic exchange]]
[[ru:c/atomic/atomic exchange]]
[[zh:c/atomic/atomic exchange]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic fetch add</title>
    <ns>0</ns>
    <id>9274</id>
    <revision>
      <id>62486</id>
      <parentid>56355</parentid>
      <timestamp>2013-07-01T23:22:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2009">{{c/title|atomic_fetch_add|atomic_fetch_add_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_fetch_add( volatile A* obj, M arg );
}}
{{dcl | since=c11 | num=2 |
C atomic_fetch_add_explicit( volatile A* obj, M arg, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with the result of addition of {{tt|arg}} to the old value of {{tt|obj}}, and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|M}} is either the non-atomic type corresponding to {{tt|A}} if {{tt|A}} is atomic integer type, or {{lc|ptrdiff_t}} if {{tt|A}} is atomic pointer type.

For signed integer types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For pointer types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to add to the value stored in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_fetch_sub}}
{{dsc see cpp | cpp/atomic/atomic_fetch_add | atomic_fetch_add | atomic_fetch_add_explicit}}
{{dsc end}}

[[de:c/atomic/atomic fetch add]]
[[es:c/atomic/atomic fetch add]]
[[fr:c/atomic/atomic fetch add]]
[[it:c/atomic/atomic fetch add]]
[[ja:c/atomic/atomic fetch add]]
[[pt:c/atomic/atomic fetch add]]
[[ru:c/atomic/atomic fetch add]]
[[zh:c/atomic/atomic fetch add]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic fetch and</title>
    <ns>0</ns>
    <id>9270</id>
    <revision>
      <id>62487</id>
      <parentid>56356</parentid>
      <timestamp>2013-07-01T23:22:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1831">{{c/title|atomic_fetch_and|atomic_fetch_and_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_fetch_and( volatile A* obj, M arg );
}}
{{dcl | since=c11 | num=2 |
C atomic_fetch_and_explicity( volatile A* obj, M arg, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with the result of bitwise AND between the old value of {{tt|obj}} and {{tt|arg}}, and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|M}} is either the non-atomic type corresponding to {{tt|A}} if {{tt|A}} is atomic integer type, or {{lc|ptrdiff_t}} if {{tt|A}} is atomic pointer type.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to bitwise AND to the value stored in the atomic object}}
{{par | order | the memory sycnhronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_fetch_or}}
{{dsc inc | c/atomic/dsc atomic_fetch_xor}}
{{dsc see cpp | cpp/atomic/atomic_fetch_and | atomic_fetch_and | atomic_fetch_and_explicit}}
{{dsc end}}

[[de:c/atomic/atomic fetch and]]
[[es:c/atomic/atomic fetch and]]
[[fr:c/atomic/atomic fetch and]]
[[it:c/atomic/atomic fetch and]]
[[ja:c/atomic/atomic fetch and]]
[[pt:c/atomic/atomic fetch and]]
[[ru:c/atomic/atomic fetch and]]
[[zh:c/atomic/atomic fetch and]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic fetch or</title>
    <ns>0</ns>
    <id>9272</id>
    <revision>
      <id>62488</id>
      <parentid>56357</parentid>
      <timestamp>2013-07-01T23:22:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1814">{{c/title|atomic_fetch_or|atomic_fetch_or_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_fetch_or( volatile A* obj, M arg );
}}
{{dcl | since=c11 | num=2 |
C atomic_fetch_or_explicity( volatile A* obj, M arg, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with the result of bitwise OR between the old value of {{tt|obj}} and {{tt|arg}}, and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|M}} is either the non-atomic type corresponding to {{tt|A}} if {{tt|A}} is atomic integer type, or {{lc|ptrdiff_t}} if {{tt|A}} is atomic pointer type.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to bitwise OR to the value stored in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_fetch_or}}
{{dsc inc | c/atomic/dsc atomic_fetch_xor}}
{{dsc see cpp | cpp/atomic/atomic_fetch_or | atomic_fetch_or | atomic_fetch_or_explicit}}
{{dsc end}}

[[de:c/atomic/atomic fetch or]]
[[es:c/atomic/atomic fetch or]]
[[fr:c/atomic/atomic fetch or]]
[[it:c/atomic/atomic fetch or]]
[[ja:c/atomic/atomic fetch or]]
[[pt:c/atomic/atomic fetch or]]
[[ru:c/atomic/atomic fetch or]]
[[zh:c/atomic/atomic fetch or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic fetch sub</title>
    <ns>0</ns>
    <id>9273</id>
    <revision>
      <id>62489</id>
      <parentid>56360</parentid>
      <timestamp>2013-07-01T23:22:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2021">{{c/title|atomic_fetch_sub|atomic_fetch_sub_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_fetch_sub( volatile A* obj, M arg );
}}
{{dcl | since=c11 | num=2 |
C atomic_fetch_sub_explicit( volatile A* obj, M arg, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with the result of subtraction of {{tt|arg}} from the old value of {{tt|obj}}, and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|M}} is either the non-atomic type corresponding to {{tt|A}} if {{tt|A}} is atomic integer type, or {{lc|ptrdiff_t}} if {{tt|A}} is atomic pointer type.

For signed integer types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For pointer types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to subtract from the value stored in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_fetch_add}}
{{dsc see cpp | cpp/atomic/atomic_fetch_sub | atomic_fetch_sub | atomic_fetch_sub_explicit}}
{{dsc end}}

[[de:c/atomic/atomic fetch sub]]
[[es:c/atomic/atomic fetch sub]]
[[fr:c/atomic/atomic fetch sub]]
[[it:c/atomic/atomic fetch sub]]
[[ja:c/atomic/atomic fetch sub]]
[[pt:c/atomic/atomic fetch sub]]
[[ru:c/atomic/atomic fetch sub]]
[[zh:c/atomic/atomic fetch sub]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic fetch xor</title>
    <ns>0</ns>
    <id>9271</id>
    <revision>
      <id>62490</id>
      <parentid>56361</parentid>
      <timestamp>2013-07-01T23:22:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1832">{{c/title|atomic_fetch_xor|atomic_fetch_xor_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_fetch_xor( volatile A* obj, M arg );
}}
{{dcl | since=c11 | num=2 |
C atomic_fetch_xor_explicity( volatile A* obj, M arg, memory_order order );
}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|obj}} with the result of bitwise XOR between the old value of {{tt|obj}} and {{tt|arg}}, and returns the value {{tt|obj}} held previously. The operation is read-modify-write operation. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|M}} is either the non-atomic type corresponding to {{tt|A}} if {{tt|A}} is atomic integer type, or {{lc|ptrdiff_t}} if {{tt|A}} is atomic pointer type.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to bitwise XOR to the value stored in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The value held previously be the atomic object pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_fetch_and}}
{{dsc inc | c/atomic/dsc atomic_fetch_xor}}
{{dsc see cpp | cpp/atomic/atomic_fetch_xor | atomic_fetch_xor | atomic_fetch_xor_explicit}}
{{dsc end}}

[[de:c/atomic/atomic fetch xor]]
[[es:c/atomic/atomic fetch xor]]
[[fr:c/atomic/atomic fetch xor]]
[[it:c/atomic/atomic fetch xor]]
[[ja:c/atomic/atomic fetch xor]]
[[pt:c/atomic/atomic fetch xor]]
[[ru:c/atomic/atomic fetch xor]]
[[zh:c/atomic/atomic fetch xor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic flag</title>
    <ns>0</ns>
    <id>9300</id>
    <revision>
      <id>63522</id>
      <parentid>48880</parentid>
      <timestamp>2013-07-10T01:35:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="549">{{c/title|atomic_flag}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
typedef /* unspecified */ atomic_flag;
}}

{{lc|atomic_flag}} is an atomic boolean type. Unlike other atomic types, it is guaranteed to be lock-free. Unlike {{lc|atomic_bool}}, {{tt|atomic_flag}} does not provide load or store operations.

[[de:c/atomic/atomic flag]]
[[es:c/atomic/atomic flag]]
[[fr:c/atomic/atomic flag]]
[[it:c/atomic/atomic flag]]
[[ja:c/atomic/atomic flag]]
[[pt:c/atomic/atomic flag]]
[[ru:c/atomic/atomic flag]]
[[zh:c/atomic/atomic flag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic flag clear</title>
    <ns>0</ns>
    <id>9275</id>
    <revision>
      <id>62491</id>
      <parentid>56362</parentid>
      <timestamp>2013-07-01T23:22:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1277">{{c/title|atomic_flag_clear|atomic_flag_clear_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
void atomic_flag_clear( volatile atomic_flag* obj );
}}
{{dcl | since=c11 | num=2 |
void atomic_flag_clear_explicit( volatile atomic_flag* obj, memory_order order );
}}
{{dcl end}}

Atomically changes the state of a {{tt|atomic_flag}} pointed to by {{tt|obj}} to clear ({{c|false}}). The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic flag object to modify}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_flag_test_and_set}}
{{dsc see cpp | cpp/atomic/atomic_flag_clear | atomic_flag_clear | atomic_flag_clear_explicit}}
{{dsc end}}

[[de:c/atomic/atomic flag clear]]
[[es:c/atomic/atomic flag clear]]
[[fr:c/atomic/atomic flag clear]]
[[it:c/atomic/atomic flag clear]]
[[ja:c/atomic/atomic flag clear]]
[[pt:c/atomic/atomic flag clear]]
[[ru:c/atomic/atomic flag clear]]
[[zh:c/atomic/atomic flag clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic flag test and set</title>
    <ns>0</ns>
    <id>9276</id>
    <revision>
      <id>62492</id>
      <parentid>56365</parentid>
      <timestamp>2013-07-01T23:22:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1467">{{c/title|atomic_flag_test_and_set|atomic_flag_test_and_set_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
_Bool atomic_flag_test_and_set( volatile atomic_flag* obj );
}}
{{dcl | since=c11 | num=2 |
_Bool atomic_flag_test_and_set_explicit( volatile atomic_flag* obj, memory_order order );
}}
{{dcl end}}

Atomically changes the state of a {{tt|atomic_flag}} pointed to by {{tt|obj}} to set ({{c|true}}) and returns the previous value. The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic flag object to modify}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted}}
{{par end}}

===Return value===
The previous value held by the atomic flag pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_flag_clear}}
{{dsc see cpp | cpp/atomic/atomic_flag_test_and_set | atomic_flag_test_and_set | atomic_flag_test_and_set_explicit}}
{{dsc end}}

[[de:c/atomic/atomic flag test and set]]
[[es:c/atomic/atomic flag test and set]]
[[fr:c/atomic/atomic flag test and set]]
[[it:c/atomic/atomic flag test and set]]
[[ja:c/atomic/atomic flag test and set]]
[[pt:c/atomic/atomic flag test and set]]
[[ru:c/atomic/atomic flag test and set]]
[[zh:c/atomic/atomic flag test and set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic init</title>
    <ns>0</ns>
    <id>9304</id>
    <revision>
      <id>63523</id>
      <parentid>56366</parentid>
      <timestamp>2013-07-10T01:35:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1068">{{c/title|atomic_init}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
void atomic_init( volatile A* obj, C desired );
}}

Initializes the default-constructed atomic object {{tt|object}} with the value {{tt|desired}}. The function is not atomic: concurrent access from another thread, even through an atomic operation, is a data race. 

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|C}} is the non-atomic type corresponding to {{tt|A}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to an atomic object to initialize}}
{{par | desired | the value to initialize atomic object with}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc see cpp | cpp/atomic/atomic_init}}
{{dsc end}}

[[de:c/atomic/atomic init]]
[[es:c/atomic/atomic init]]
[[fr:c/atomic/atomic init]]
[[it:c/atomic/atomic init]]
[[ja:c/atomic/atomic init]]
[[pt:c/atomic/atomic init]]
[[ru:c/atomic/atomic init]]
[[zh:c/atomic/atomic init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic is lock free</title>
    <ns>0</ns>
    <id>9301</id>
    <revision>
      <id>62493</id>
      <parentid>56369</parentid>
      <timestamp>2013-07-01T23:22:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1004">{{c/title|atomic_is_lock_free}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | 
_Bool atomic_is_lock_free( const volatile A* obj );
}}
{{dcl end}}

Determines if the atomic object pointed to by {{tt|obj}} is implemented lock-free.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to inspect}}
{{par end}}

===Return value===
{{c|true}} if the atomic object is lock-free, {{tt|false}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc ATOMIC_LOCK_FREE_consts}}
{{dsc see cpp | cpp/atomic/atomic_is_lock_free}}
{{dsc end}}

[[de:c/atomic/atomic is lock free]]
[[es:c/atomic/atomic is lock free]]
[[fr:c/atomic/atomic is lock free]]
[[it:c/atomic/atomic is lock free]]
[[ja:c/atomic/atomic is lock free]]
[[pt:c/atomic/atomic is lock free]]
[[ru:c/atomic/atomic is lock free]]
[[zh:c/atomic/atomic is lock free]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic load</title>
    <ns>0</ns>
    <id>9305</id>
    <revision>
      <id>62494</id>
      <parentid>56370</parentid>
      <timestamp>2013-07-01T23:22:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1572">{{c/title|atomic_load|atomic_load_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
C atomic_load( volatile A* obj );
}}
{{dcl | since=c11 | num=2 |
C atomic_load_explicit( volatile A* obj, memory_order order );
}}
{{dcl end}}

Atomically loads and returns the current value of the atomic variable pointed to by {{tt|obj}}. The operation is atomic read operation. 

The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}. {{tt|order}} must be one of {{lc|memory_order_relaxed}}, {{lc|memory_order_consume}}, {{lc|memory_order_acquire}} or {{lc|memory_order_seq_cst}}. Otherwise the behavior is undefined.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|C}} is the non-atomic type corresponding to {{tt|A}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to access}}
{{par | order | the memory synchronization ordering for this operation}}
{{par end}}

===Return value===
The current value of the atomic variable pointed to by {{tt|obj}}.

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_store}}
{{dsc see cpp | cpp/atomic/atomic_load | atomic_load | atomic_load_explicit}}
{{dsc end}}

[[de:c/atomic/atomic load]]
[[es:c/atomic/atomic load]]
[[fr:c/atomic/atomic load]]
[[it:c/atomic/atomic load]]
[[ja:c/atomic/atomic load]]
[[pt:c/atomic/atomic load]]
[[ru:c/atomic/atomic load]]
[[zh:c/atomic/atomic load]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic signal fence</title>
    <ns>0</ns>
    <id>9298</id>
    <revision>
      <id>63524</id>
      <parentid>56373</parentid>
      <timestamp>2013-07-10T01:35:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1236">{{c/title|atomic_signal_fence}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
void atomic_signal_fence( memory_order order );
}}

Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by {{tt|order}}, between a thread and a signal handler executed on the same thread. This is equivalent to {{lc|std::atomic_thread_fence}}, except no CPU instructions for memory ordering are issued. Only reordering of the instructions by the compiler is suppressed as {{tt|order}} instructs. For example, writes cannot be moved past a fence with release semantics and reads cannot be moved ahead of a fence with acquire semantics.

===Parameters===
{{par begin}}
{{par | order | the memory ordering executed by this fence}}
{{par end}} 

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_thread_fence}}
{{dsc see cpp | cpp/atomic/atomic_signal_fence}}
{{dsc end}}

[[de:c/atomic/atomic signal fence]]
[[es:c/atomic/atomic signal fence]]
[[fr:c/atomic/atomic signal fence]]
[[it:c/atomic/atomic signal fence]]
[[ja:c/atomic/atomic signal fence]]
[[pt:c/atomic/atomic signal fence]]
[[ru:c/atomic/atomic signal fence]]
[[zh:c/atomic/atomic signal fence]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic store</title>
    <ns>0</ns>
    <id>9306</id>
    <revision>
      <id>70128</id>
      <parentid>62495</parentid>
      <timestamp>2014-05-10T19:14:04Z</timestamp>
      <contributor>
        <ip>5.18.60.105</ip>
      </contributor>
      <text xml:space="preserve" bytes="1529">{{c/title|atomic_store|atomic_store_explicit}}
{{c/atomic/navbar}}
{{dcl begin}}
{{dcl header | stdatomic.h }}
{{dcl | since=c11 | num=1 |
void atomic_store( volatile A* obj , C desired);
}}
{{dcl | since=c11 | num=2 |
void atomic_store_explicit( volatile A* obj, C desired, memory_order order );
}}
{{dcl end}}

Atomically replaces the value of the atomic variable pointed to by {{tt|obj}} with {{tt|desired}}. The operation is atomic write operation. 

The first version orders memory accesses according to {{lc|memory_order_seq_cst}}, the second version orders memory accesses according to {{tt|order}}. {{tt|order}} must be one of {{lc|memory_order_relaxed}}, {{lc|memory_order_release}} or {{lc|memory_order_seq_cst}}. Otherwise the behavior is undefined.

This is a [[todo|generic function]] defined for all atomic object types. {{tt|A}} is the type of an atomic object, {{tt|C}} is the non-atomic type corresponding to {{tt|A}}.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | order | the memory synchronization ordering for this operation}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_load}}
{{dsc see cpp | cpp/atomic/atomic_store | atomic_store | atomic_store_explicit}}
{{dsc end}}

[[de:c/atomic/atomic store]]
[[es:c/atomic/atomic store]]
[[fr:c/atomic/atomic store]]
[[it:c/atomic/atomic store]]
[[ja:c/atomic/atomic store]]
[[pt:c/atomic/atomic store]]
[[ru:c/atomic/atomic store]]
[[zh:c/atomic/atomic store]]</text>
      <sha1>lm7idpuwuqyvzx3zxo4iy78phb8d4lf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/atomic thread fence</title>
    <ns>0</ns>
    <id>9299</id>
    <revision>
      <id>65045</id>
      <parentid>63525</parentid>
      <timestamp>2013-08-30T10:43:50Z</timestamp>
      <contributor>
        <ip>203.97.127.101</ip>
      </contributor>
      <comment>thread, not signal.</comment>
      <text xml:space="preserve" bytes="1131">{{c/title|atomic_thread_fence}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
void atomic_thread_fence( memory_order order );
}}

Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by {{tt|order}}, without an associated atomic operation. For example, all non-atomic and relaxed atomic stores that happen before a {{lc|memory_order_release}} fence in thread A will be synchronized with non-atomic and relaxed atomic loads from the same locations made in thread B after an {{lc|memory_order_acquire}} fence.

===Parameters===
{{par begin}}
{{par | order | the memory ordering executed by this fence}}
{{par end}} 

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/atomic/dsc atomic_signal_fence}}
{{dsc see cpp | cpp/atomic/atomic_thread_fence}}
{{dsc end}}

[[de:c/atomic/atomic thread fence]]
[[es:c/atomic/atomic thread fence]]
[[fr:c/atomic/atomic thread fence]]
[[it:c/atomic/atomic thread fence]]
[[ja:c/atomic/atomic thread fence]]
[[pt:c/atomic/atomic thread fence]]
[[ru:c/atomic/atomic thread fence]]
[[zh:c/atomic/atomic thread fence]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/kill dependency</title>
    <ns>0</ns>
    <id>9383</id>
    <revision>
      <id>63526</id>
      <parentid>48886</parentid>
      <timestamp>2013-07-10T01:35:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="907">{{c/title|kill_dependency}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 |
A kill_dependency(A y);
}}

Informs the compiler that the dependency tree started by an {{lc|memory_order_consume}} atomic load operation does not extend past the return value of {{tt|kill_dependency}}; that is, the argument does not carry a dependency into the return value.

The function is implemented as a macro. {{tt|A}} is the type of {{tt|y}}.

===Parameters===
{{par begin}}
{{par | y | the expression whose return value is to be removed from a dependency tree}}
{{par end}} 

===Return value===
Returns {{tt|y}}, no longer a part of a dependency tree.

[[de:c/atomic/kill dependency]]
[[es:c/atomic/kill dependency]]
[[fr:c/atomic/kill dependency]]
[[it:c/atomic/kill dependency]]
[[ja:c/atomic/kill dependency]]
[[pt:c/atomic/kill dependency]]
[[ru:c/atomic/kill dependency]]
[[zh:c/atomic/kill dependency]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/atomic/memory order</title>
    <ns>0</ns>
    <id>9269</id>
    <revision>
      <id>70167</id>
      <parentid>70166</parentid>
      <timestamp>2014-05-10T22:33:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to c++, todo</comment>
      <text xml:space="preserve" bytes="9754">{{c/title | memory_order}}
{{c/atomic/navbar}}
{{ddcl | header=stdatomic.h | since=c11 | 1=
enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};
}}

{{tt|memory_order}} specifies how non-atomic memory accesses are to be ordered around an atomic operation. The rationale of this is that when several threads simultaneously read and write to several variables on multi-core systems, one thread might ''see'' the values change in different order than another thread has written them. Also, the apparent order of changes may be different across several reader threads. Ensuring that all memory accesses to atomic variables are sequential may hurt performance in some cases. {{tt|std::memory_order}} allows to specify the exact constraints that the compiler must enforce.

It's possible to specify custom memory order for each atomic operation in the library via an additional parameter. The default is {{lc|std::memory_order_seq_cst}}.

===Constants===

{{dsc begin}}
{{dsc header | atomic}}
{{dsc hitem | Value | Explanation }}
{{dsc | {{tt|memory_order_relaxed}} | '''Relaxed''' ordering: there are no constraints on reordering of memory accesses around the atomic variable.}}
{{dsc | {{tt|memory_order_consume}} | '''Consume''' operation: no reads in the current thread dependent on the value currently loaded can be reordered before this load. This ensures that writes to dependent variables in other threads that release the same atomic variable are visible in the current thread. On most platforms, this affects compiler optimization only. }}
{{dsc | {{tt|memory_order_acquire}} | '''Acquire''' operation: no reads in the current thread can be reordered before this load. This ensures that all writes in other threads that release the same atomic variable are visible in the current thread.}}
{{dsc | {{tt|memory_order_release}} | '''Release''' operation: no writes in the current thread can be reordered after this store. This ensures that all writes in the current thread are visible in other threads that acquire the same atomic variable.}}
{{dsc | {{tt|memory_order_acq_rel}} | '''Acquire-release''' operation: no reads in the current thread can be reordered before this load as well as no writes in the current thread can be reordered after this store. The operation is read-modify-write operation. It is ensured that all writes in another threads that release the same atomic variable are visible before the modification and the modification is visible in other threads that acquire the same atomic variable.}}
{{dsc | {{tt|memory_order_seq_cst}} | '''Sequential ordering'''. The operation has the same semantics as acquire-release operation, and additionally has sequentially-consistent operation ordering. }}
{{dsc end}}

{{todo|match the C++ version in the level of detail}}

====Relaxed ordering====
Atomic operations tagged {{lc|memory_order_relaxed}} exhibit the following properties:

* No ordering of other memory accesses is ensured whatsoever. This means that it is not possible to synchronize several threads using the atomic variable.
* Reads and writes to the atomic variable itself are ordered. Once a thread reads a value, a subsequent read by the same thread from the same object can not yield an earlier value.

For example, with {{tt|x}} and {{tt|y}} initially zero,

{{c|1=
// Thread 1:
r1 = atomic_load_explicit(y, memory_order_relaxed);
atomic_store_explicit(x, r1, memory_order_relaxed);
// Thread 2:
r2 = atomic_load_explicit(x, memory_order_relaxed);
atomic_store_explicit(y, 42, memory_order_relaxed);
}}

is allowed to produce {{tt|1=r1 == r2 == 42}}.

====Release-Consume ordering====
If an atomic store is tagged {{lc|memory_order_release}} and an atomic load from the same variable is tagged {{lc|memory_order_consume}}, the operations exhibit the following properties:

* No writes in the writer thread can be reordered after the atomic store
* No reads or writes dependent on the value received from atomic load can be reordered before the atomic load. &quot;Dependent on&quot; means that the address or value is computed from the value of the atomic variable. This form of synchronization between threads is known as &quot;dependency ordering&quot;.
* The synchronization is established only between the threads ''releasing'' and ''consuming'' the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.
* The synchronization is transitive. That is, if we have the following situation:
::* Thread ''A'' releases atomic variable ''a''.
::* Thread ''B'' consumes atomic variable ''a''.
::* Atomic variable ''b'' is dependent on ''a''.
::* Thread ''B'' releases atomic variable ''b''.
::* Thread ''C'' consumes or acquires atomic variable ''b''.
: Then not only ''A'' and ''B'' or ''B'' and ''C'' are synchronized, but ''A'' and ''C'' also. That is, all writes by the thread ''A'' that were launched before the release of ''a'' are guaranteed to be completed once thread ''C'' observes the store to ''b''. 

On all mainstream CPUs, other than DEC Alpha, dependency ordering is automatic, no additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from performing speculative loads on the objects that are involved in the dependency chain)

====Release sequence====
If some atomic is store-released and several other threads perform read-modify-write operations on that atomic, a &quot;release sequence&quot; is formed: all threads that perform the read-modify-writes to the same atomic synchronize with the first thread and each other even if they have no {{tt|memory_order_release}} semantics. This makes single producer - multiple consumers situations possible without imposing unnecessary synchronization between individual consumer threads.

====Release-Acquire ordering====
If an atomic store is tagged {{lc|memory_order_release}} and an atomic load from the same variable is tagged {{lc|memory_order_acquire}}, the operations exhibit the following properties:

* No writes in the writer thread can be reordered after the atomic store
* No reads in the reader thread can be reordered before the atomic load. 
* The synchronization is established only between the threads ''releasing'' and ''acquiring'' the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.
* The synchronization is transitive. That is, if we have the following situation:
::* Thread ''A'' releases atomic variable ''a''.
::* Thread ''B'' consumes atomic variable ''a''.
::* Thread ''B'' releases atomic variable ''b''.
::* Thread ''C'' consumes or acquires atomic variable ''b''.
: Then not only ''A'' and ''B'' or ''B'' and ''C'' are synchronized, but ''A'' and ''C'' also. That is, all writes by the thread ''A'' that were launched before the release of ''a'' are guaranteed to be completed once thread ''C'' observes the store to ''b''. 

On strongly-ordered systems (x86, SPARC, IBM mainframe), release-acquire ordering is automatic. No additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from moving non-atomic stores past the atomic store-relase or perform non-atomic loads earlier than the atomic load-acquire)

====Sequentially-consistent ordering====
If an atomic store is tagged {{lc|memory_order_seq_cst}} and an atomic load from the same variable is tagged {{lc|memory_order_seq_cst}}, then the operations exhibit the following properties:

* No writes in the writer thread can be reordered after the atomic store
* No reads in the reader thread can be reordered before the atomic load.
* The synchronization is established between all atomic operations tagged {{lc|std::memory_order_seq_cst}}. All threads using such atomic operation see the same order of memory accesses.

Sequential ordering is necessary for many multiple producer-multiple consumer situations where all consumers must observe the actions of all producers occurring in the same order. 

Total sequential ordering requires a full memory fence CPU instruction on all multi-core systems. This may become a performance bottleneck since it forces all memory accesses to propagate to every thread.

===Relationship with volatile===
Within a thread of execution, accesses (reads and writes) to all {{c|volatile}} objects are guaranteed to not be reordered relative to each other, but this order is not guaranteed to be observed by another thread, since volatile access does not establish inter-thread synchronization. In addition, volatile accesses are not atomic (concurrent read and write is a data race) and do not order memory (non-volatile memory accesses may be freely reordered around the volatile access). One notable exception is Visual Studio, where every volatile write has release semantics and every volatile read has acquire semantics ([http://msdn.microsoft.com/en-us/library/12a04hfd(v=vs.100).aspx MSDN]), and thus volatiles may be used for inter-thread synchronization. Standard {{c|volatile}} semantics are not applicable to multithreaded programming, although they are sufficient for e.g. communication with a signal handler (see also {{lc|std::atomic_signal_fence}})

===Examples===
{{todo}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/atomic/memory order}}
{{dsc end}}

[[de:c/atomic/memory order]]
[[es:c/atomic/memory order]]
[[fr:c/atomic/memory order]]
[[it:c/atomic/memory order]]
[[ja:c/atomic/memory order]]
[[pt:c/atomic/memory order]]
[[ru:c/atomic/memory order]]
[[zh:c/atomic/memory order]]</text>
      <sha1>k6yxumbikzspy0cli19vu0ucnxlb63n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono</title>
    <ns>0</ns>
    <id>5932</id>
    <revision>
      <id>71557</id>
      <parentid>70989</parentid>
      <timestamp>2014-06-13T12:41:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+missing timespec</comment>
      <text xml:space="preserve" bytes="1058">{{title|Date and time utilities}}
{{c/chrono/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | time.h}}
{{dsc h2 | Time manipulation}}
{{dsc inc | c/chrono/dsc difftime}}
{{dsc inc | c/chrono/dsc time}}
{{dsc inc | c/chrono/dsc clock}}
{{dsc inc | c/chrono/dsc timespec_get}}
{{dsc h2 | Format conversions}}
{{dsc inc | c/chrono/dsc asctime}}
{{dsc inc | c/chrono/dsc ctime}}
{{dsc inc | c/chrono/dsc strftime}}
{{dsc inc | c/chrono/dsc wcsftime}}
{{dsc inc | c/chrono/dsc gmtime}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc inc | c/chrono/dsc mktime}}
{{dsc end}}

===Constants===
{{dsc begin}}
{{dsc inc | c/chrono/dsc CLOCKS_PER_SEC}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | c/chrono/dsc tm}}
{{dsc inc | c/chrono/dsc time_t}}
{{dsc inc | c/chrono/dsc clock_t}}
{{dsc inc | c/chrono/dsc timespec}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/chrono/c |C Date and time utilities }}
{{dsc end}}

[[de:c/chrono]]
[[es:c/chrono]]
[[fr:c/chrono]]
[[it:c/chrono]]
[[ja:c/chrono]]
[[pt:c/chrono]]
[[ru:c/chrono]]
[[zh:c/chrono]]</text>
      <sha1>if9b6lh3yksju2mzpph8fp7kbk0o4ax</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/CLOCKS PER SEC</title>
    <ns>0</ns>
    <id>6158</id>
    <revision>
      <id>64283</id>
      <parentid>64282</parentid>
      <timestamp>2013-08-15T16:20:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-std::</comment>
      <text xml:space="preserve" bytes="815">{{title| CLOCKS_PER_SEC}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
#define CLOCKS_PER_SEC /*implementation defined*/
}}

Expands to an expression (not necessarily a compile-time constant) of type {{lc|clock_t}} equal to the number of clock ticks per second, as returned by {{lc|clock()}}. 

===Notes===
POSIX defines {{tt|CLOCKS_PER_SEC}} as one million, regardless of the actual precision of {{lc|clock}}.

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc clock}}
{{dsc inc | c/chrono/dsc clock_t}}
{{dsc see cpp | cpp/chrono/c/CLOCKS_PER_SEC}}
{{dsc end}}

[[de:c/chrono/CLOCKS PER SEC]]
[[es:c/chrono/CLOCKS PER SEC]]
[[fr:c/chrono/CLOCKS PER SEC]]
[[it:c/chrono/CLOCKS PER SEC]]
[[ja:c/chrono/CLOCKS PER SEC]]
[[pt:c/chrono/CLOCKS PER SEC]]
[[ru:c/chrono/CLOCKS PER SEC]]
[[zh:c/chrono/CLOCKS PER SEC]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/asctime</title>
    <ns>0</ns>
    <id>6167</id>
    <revision>
      <id>71190</id>
      <parentid>65818</parentid>
      <timestamp>2014-06-08T01:17:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2281">{{c/title| asctime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
char* asctime( const tm* time_ptr );
}}

Converts given calendar time {{lc|tm}} to a textual representation.
The resulting string has the following format:

{{source|Www Mmm dd hh:mm:ss yyyy\n}}

*{{tt|Www}} - the day of the week (one of {{tt|Mon}}, {{tt|Tue}}, {{tt|Wed}}, {{tt|Thu}}, {{tt|Fri}}, {{tt|Sat}}, {{tt|Sun}}).
*{{tt|Mmm}} - the month (one of {{tt|Jan}}, {{tt|Feb}}, {{tt|Mar}}, {{tt|Apr}}, {{tt|May}}, {{tt|Jun}}, {{tt|Jul}}, {{tt|Aug}}, {{tt|Sep}}, {{tt|Oct}}, {{tt|Nov}}, {{tt|Dec}}).
*{{tt|dd}} - the day of the month
*{{tt|hh}} - hours
*{{tt|mm}} - minutes
*{{tt|ss}} - seconds 
*{{tt|yyyy}} - years

The function does not support localization.

===Parameters===
{{par begin}}
{{par | time_ptr | pointer to a {{lc|tm}} object specifying the time to print}}
{{par end}}

===Return value===

pointer to a static null-terminated character string holding the textual representation of date and time, followed by a new line character. The string may be shared between {{tt|asctime}} and {{lc|ctime}}, and may be overwritten on each invocation of any of those functions.

===Notes===
This function returns a pointer to static data and is not thread-safe. POSIX marks this function obsolete and recommends {{lc|strftime}} instead.

The behavior is undefined if the output string would be longer than 25 characters, if {{tt|timeptr-&gt;tm_wday}} or {{tt|timeptr-&gt;tm_mon}} are not within the expected ranges, or if {{tt|timeptr-&gt;tm_year}} exceeds {{c|INT_MAX-1990}}.

Some implementations handle {{c|1=timeptr-&gt;tm_mday==0}} as meaning the last day of the preceding month.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;

int main(void)
{
    time_t rawtime;
    struct tm *timeinfo;

    time(&amp;rawtime);
    timeinfo = localtime(&amp;rawtime);
    printf(&quot;%s&quot;, asctime(timeinfo));

    return 0;
}
 | p=true | output=
Wed Oct  9 10:28:03 2013
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc ctime}}
{{dsc inc | c/chrono/dsc strftime}}
{{dsc see cpp | cpp/chrono/c/asctime}}
{{dsc end}}

[[de:c/chrono/asctime]]
[[es:c/chrono/asctime]]
[[fr:c/chrono/asctime]]
[[it:c/chrono/asctime]]
[[ja:c/chrono/asctime]]
[[pt:c/chrono/asctime]]
[[ru:c/chrono/asctime]]
[[zh:c/chrono/asctime]]</text>
      <sha1>780r8q4v5k3ie62wnxiollfa8ff0u2w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/clock</title>
    <ns>0</ns>
    <id>6168</id>
    <revision>
      <id>71642</id>
      <parentid>71187</parentid>
      <timestamp>2014-06-17T14:42:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking for clock()</comment>
      <text xml:space="preserve" bytes="2572">{{c/title| clock}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
clock_t clock();
}}

Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution. To convert result value to seconds divide it by {{lc|CLOCKS_PER_SEC}}. 

Only the difference between two values returned by different calls to {{lc|clock}} is meaningful, as the beginning of the {{lc|clock}} era does not have to coincide with the start of the program. {{lc|clock}} time may advance faster or slower than the wall clock, depending on the execution resources given to the program by the operating system. For example, if the CPU is shared by other processes, {{lc|clock}} time may advance slower than wall clock. On the other hand, if the current process is multithreaded and more than one execution core is available, {{lc|clock}} time may advance faster than wall clock.

===Parameters===
(none)

===Return value===
Processor time used by the program so far or {{c|(clock_t)(-1)}} if that information is unavailable.

===Notes===
On POSIX-compatible systems, &lt;code&gt;[http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html clock_gettime]&lt;/code&gt; with clock id {{c|CLOCK_PROCESS_CPUTIME_ID}} offers better resolution.

The value returned by {{tt|clock()}} may wrap around on some implementations. For example, on a machine with 32-bit  {{lc|clock_t}}, it wraps after 2147 seconds or 36 minutes.

===Example===
{{example
 | This example demonstrates the difference between clock() time and real time
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;

// the function f() does some time-consuming work
void f()
{
    volatile double d=0.0; // we don't want subsequent computation to be optimized out
    for (int n=0; n&lt;10000; ++n)
       for (int m=0; m&lt;10000; ++m)
           d += d*n*m;
}

int main(void)
{
    clock_t t = clock();
    if (t == ((clock_t)-1))
    {
       fprintf(stderr,&quot;clock() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }

    f();
    t = clock() - t;
    printf(&quot;Time used: %f seconds\n&quot;,((float)t)/CLOCKS_PER_SEC);
  
    return 0;
}
 | p=
 | output=
Time used: 1.010000 seconds
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc ctime}}
{{dsc inc | c/chrono/dsc time}}
{{dsc see cpp | cpp/chrono/c/clock}}
{{dsc end}}

[[de:c/chrono/clock]]
[[es:c/chrono/clock]]
[[fr:c/chrono/clock]]
[[it:c/chrono/clock]]
[[ja:c/chrono/clock]]
[[pt:c/chrono/clock]]
[[ru:c/chrono/clock]]
[[zh:c/chrono/clock]]</text>
      <sha1>mt4haveu0a53kixrzsstuk472kie69t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/clock t</title>
    <ns>0</ns>
    <id>6155</id>
    <revision>
      <id>56386</id>
      <parentid>48838</parentid>
      <timestamp>2013-06-01T05:35:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="566">{{c/title|clock_t}}
{{c/chrono/navbar}}
{{ddcl | header=time.h | 1=
typedef /* unspecified */ clock_t;
}}
Arithmetic type capable of representing the process running time of implementation-defined range and precision.

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc clock}}
{{dsc inc | c/chrono/dsc CLOCKS_PER_SEC}}
{{dsc see cpp | cpp/chrono/c/clock_t}}
{{dsc end}}

[[de:c/chrono/clock t]]
[[es:c/chrono/clock t]]
[[fr:c/chrono/clock t]]
[[it:c/chrono/clock t]]
[[ja:c/chrono/clock t]]
[[pt:c/chrono/clock t]]
[[ru:c/chrono/clock t]]
[[zh:c/chrono/clock t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/ctime</title>
    <ns>0</ns>
    <id>6166</id>
    <revision>
      <id>71191</id>
      <parentid>66133</parentid>
      <timestamp>2014-06-08T01:19:22Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2110">{{c/title| ctime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
char* ctime( const time_t* time );
}}

Converts given time since epoch to a calendar local time and then to a textual representation, as if by calling {{c|asctime(localtime(time))}}. The resulting string has the following format:

{{source|Www Mmm dd hh:mm:ss yyyy\n}}

*{{tt|Www}} - the day of the week (one of {{tt|Mon}}, {{tt|Tue}}, {{tt|Wed}}, {{tt|Thu}}, {{tt|Fri}}, {{tt|Sat}}, {{tt|Sun}}).
*{{tt|Mmm}} - the month (one of {{tt|Jan}}, {{tt|Feb}}, {{tt|Mar}}, {{tt|Apr}}, {{tt|May}}, {{tt|Jun}}, {{tt|Jul}}, {{tt|Aug}}, {{tt|Sep}}, {{tt|Oct}}, {{tt|Nov}}, {{tt|Dec}}).
*{{tt|dd}} - the day of the month
*{{tt|hh}} - hours
*{{tt|mm}} - minutes
*{{tt|ss}} - seconds 
*{{tt|yyyy}} - years

The function does not support localization.

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|time_t}} object specifying the time to print}}
{{par end}}

===Return value===

pointer to a static null-terminated character string holding the textual representation of date and time. The string may be shared between {{tt|asctime}} and {{lc|ctime}}, and may be overwritten on each invocation of any of those functions.

===Notes===
This function returns a pointer to static data and is not thread-safe. In addition, it modifies the static {{lc|tm}} object which may be shared with {{lc|gmtime}} and {{lc|localtime}}. POSIX marks this function obsolete and recommends {{lc|strftime}} instead.

The behavior may be undefined for the values of time_t that result in the string longer than 25 characters (e.g. year 10000)

===Example===
{{example
 |
 | code=
#include &lt;time.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    time_t result = time(NULL);
    printf(&quot;%s&quot;, ctime(&amp;result));
}
 | output=
Wed Oct  9 10:33:09 2013
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc asctime}}
{{dsc inc | c/chrono/dsc strftime}}
{{dsc see cpp | cpp/chrono/c/ctime}}
{{dsc end}}

[[de:c/chrono/ctime]]
[[es:c/chrono/ctime]]
[[fr:c/chrono/ctime]]
[[it:c/chrono/ctime]]
[[ja:c/chrono/ctime]]
[[pt:c/chrono/ctime]]
[[ru:c/chrono/ctime]]
[[zh:c/chrono/ctime]]</text>
      <sha1>ojnm0onvvqbmxvqtytpzfro4ol0wzjt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/difftime</title>
    <ns>0</ns>
    <id>6170</id>
    <revision>
      <id>71640</id>
      <parentid>71188</parentid>
      <timestamp>2014-06-17T14:09:09Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output line by deleting decimal point and zeros</comment>
      <text xml:space="preserve" bytes="1582">{{c/title| difftime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
double difftime( time_t time_end, time_t time_beg );
}}

Computes difference between two calendar times as {{lc|time_t}} objects ({{c|time_end - time_beg}}) in seconds. If {{tt|time_end}} refers to time point before {{tt|time_beg}} then the result is negative.

===Parameters===
{{par begin}}
{{par | time_beg, time_end | times to compare}}
{{par end}}

===Return value===
Difference between two times in seconds.

===Notes===
On POSIX systems, {{lc|time_t}} is measured in seconds, and {{tt|difftime}} is equivalent to arithmetic subtraction, but C and C++ allow fractional units for {{tt|time_t}}.

===Example===
{{example
 | The following program computes the number of seconds that have passed since the beginning of the month.
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;

int main(void)
{
    time_t now;
    time(&amp;now);

    struct tm beg;
    beg = *localtime(&amp;now);

    // set beg to the beginning of the month
    beg.tm_hour = 0;
    beg.tm_min = 0;
    beg.tm_sec = 0;
    beg.tm_mday = 1;

    double seconds = difftime(now, mktime(&amp;beg));

    printf(&quot;%.f seconds have passed since the beginning of the month.\n&quot;, seconds);

    return 0;
}
 | output=
1937968 seconds have passed since the beginning of the month.
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/chrono/c/difftime}}
{{dsc end}}

[[de:c/chrono/difftime]]
[[es:c/chrono/difftime]]
[[fr:c/chrono/difftime]]
[[it:c/chrono/difftime]]
[[ja:c/chrono/difftime]]
[[pt:c/chrono/difftime]]
[[ru:c/chrono/difftime]]
[[zh:c/chrono/difftime]]</text>
      <sha1>5eq0r6pfmh8mh36hhg1wjqnedx6t6bw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/gmtime</title>
    <ns>0</ns>
    <id>6163</id>
    <revision>
      <id>71643</id>
      <parentid>71553</parentid>
      <timestamp>2014-06-17T15:07:13Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking for gmtime()</comment>
      <text xml:space="preserve" bytes="1553">{{c/title| gmtime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
tm* gmtime( const time_t* time );
}}

Converts given time since epoch as {{lc|time_t}} value into calendar time, expressed in Coordinated Universal Time (UTC). 

===Parameters===
{{par begin}}
{{par | time | pointer to a time_t object to convert}}
{{par end}}

===Return value===

pointer to a static internal {{lc|tm}} object on success, or {{lc|NULL}} otherwise. The structure may be shared between {{lc|gmtime}}, {{lc|localtime}}, and {{lc|ctime}} and may be overwritten on each invocation.

===Notes===
This function may not be thread-safe.

POSIX requires that this function sets {{lc|errno}} to {{lc|EOVERFLOW}} if it fails because the argument is too large.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    time_t t = time(NULL);
    struct tm *tmptr = gmtime(&amp;t);
    if (tmptr == NULL)
    {
       fprintf(stderr,&quot;gmtime() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }

    printf(&quot;UTC:   %s&quot;, asctime(tmptr));
    printf(&quot;local: %s&quot;, asctime(localtime(&amp;t)));

    return EXIT_SUCCESS;
}
 | output=
UTC:   Wed Oct  9 10:37:39 2013
local: Wed Oct  9 17:37:39 2013
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc see cpp | cpp/chrono/c/gmtime}}
{{dsc end}}

[[de:c/chrono/gmtime]]
[[es:c/chrono/gmtime]]
[[fr:c/chrono/gmtime]]
[[it:c/chrono/gmtime]]
[[ja:c/chrono/gmtime]]
[[pt:c/chrono/gmtime]]
[[ru:c/chrono/gmtime]]
[[zh:c/chrono/gmtime]]</text>
      <sha1>figwj1d5hrmwcrhh9mxsmzs6v5190if</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/localtime</title>
    <ns>0</ns>
    <id>6154</id>
    <revision>
      <id>71644</id>
      <parentid>71195</parentid>
      <timestamp>2014-06-17T15:15:27Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking for localtime()</comment>
      <text xml:space="preserve" bytes="1571">{{c/title| localtime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
tm* localtime( const time_t *time );
}}

Converts given time since epoch as {{lc|time_t}} value into calendar time, expressed in local time. 

===Parameters===
{{par begin}}
{{par | time | pointer to a {{tt|time_t}} object to convert}}
{{par end}}

===Return value===

pointer to a static internal {{lc|tm}} object on success, or {{lc|NULL}} otherwise. The structure may be shared between {{lc|gmtime}}, {{lc|localtime}}, and {{lc|ctime}}, and may be overwritten on each invocation.

===Notes===
This function may not be thread-safe.

POSIX requires that this function sets {{lc|errno}} to {{lc|EOVERFLOW}} if it fails because the argument is too large.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    time_t t = time(NULL);
    printf(&quot;UTC:   %s&quot;, asctime(gmtime(&amp;t)));
    struct tm *tmptr = localtime(&amp;t);
    if (tmptr == NULL)
    {
       fprintf(stderr,&quot;localtime() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }
    printf(&quot;local: %s&quot;, asctime(tmptr));

    return EXIT_SUCCESS;
}
 | output=
UTC:   Wed Oct  9 10:37:39 2013
local: Wed Oct  9 17:37:39 2013
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc gmtime}}
{{dsc see cpp | cpp/chrono/c/localtime}}
{{dsc end}}

[[de:c/chrono/localtime]]
[[es:c/chrono/localtime]]
[[fr:c/chrono/localtime]]
[[it:c/chrono/localtime]]
[[ja:c/chrono/localtime]]
[[pt:c/chrono/localtime]]
[[ru:c/chrono/localtime]]
[[zh:c/chrono/localtime]]</text>
      <sha1>sttm9qkrf30cw8onqlvh1ksr5jnoe95</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/mktime</title>
    <ns>0</ns>
    <id>6162</id>
    <revision>
      <id>71645</id>
      <parentid>71524</parentid>
      <timestamp>2014-06-17T15:25:29Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking for mktime()</comment>
      <text xml:space="preserve" bytes="2170">{{c/title| mktime}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
time_t mktime( tm* time );
}}

Converts local calendar time to a time since epoch as a {{lc|time_t}} object. {{tt|time-&gt;tm_wday}} and {{tt|time-&gt;tm_yday}} are ignored. The values in {{tt|time}} are not checked for being out of range.

A negative value of {{tt|time-&gt;tm_isdst}} causes {{tt|mktime}} to attempt to determine if Daylight Saving Time was in effect.

If the conversion is successful, the {{tt|time}} object is modified. All fields of {{tt|time}} are updated to fit their proper ranges. {{tt|time-&gt;tm_wday}} and {{tt|time-&gt;tm_yday}} are recalculated using information available in other fields.

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|tm}} object specifying local calendar time to convert}}
{{par end}}

===Return value===

time since epoch as a {{lc|time_t}} object on success or {{c|-1}} if {{tt|time}} cannot be represented as a {{lc|time_t}} object.

===Notes===
If the {{lc|tm}} object was obtained from POSIX [http://pubs.opengroup.org/onlinepubs/009695399/functions/strptime.html strptime] or equivalent function, the value of {{tt|tm_isdst}} is indeterminate, and needs to be set explicitly before calling {{tt|mktime}}.

===Example===
{{example
 | Display the time 100 months ago
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    time_t t = time(NULL);
    struct tm *tmptr = localtime(&amp;t);
    printf(&quot;Today is           %s&quot;, asctime(tmptr));
    tmptr-&gt;tm_mon -= 100;
    time_t result = mktime(tmptr);
    if (result == ((time_t)-1))
    {
       fprintf(stderr,&quot;mktime() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }
    printf(&quot;100 months ago was %s&quot;, asctime(tmptr));
}
 | output=
Today is           Wed Oct  9 10:47:25 2013
100 months ago was Thu Jun  9 10:47:25 2005
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc see cpp | cpp/chrono/c/mktime}}
{{dsc end}}

[[de:c/chrono/mktime]]
[[es:c/chrono/mktime]]
[[fr:c/chrono/mktime]]
[[it:c/chrono/mktime]]
[[ja:c/chrono/mktime]]
[[pt:c/chrono/mktime]]
[[ru:c/chrono/mktime]]
[[zh:c/chrono/mktime]]</text>
      <sha1>tk4kwuge1v4mp868dixw0ygcqh9ahrt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/strftime</title>
    <ns>0</ns>
    <id>6165</id>
    <revision>
      <id>71192</id>
      <parentid>65922</parentid>
      <timestamp>2014-06-08T01:21:09Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2473">{{c/title| strftime}}
{{c/chrono/navbar}}
{{dcl begin}}
{{dcl header | time.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
size_t strftime( char          *str, size_t count, 
                 const char          *format, tm          *time );
}}
{{dcl | since=c99 |
size_t strftime( char *restrict str, size_t count, 
                 const char *restrict format, tm *restrict time );
}}
{{dcl rev end}}
{{dcl end}}

Converts the date and time information from a given calendar time {{tt|time}} to a null-terminated multibyte character string {{tt|str}} according to format string {{tt|format}}. Up to {{tt|count}} bytes are written.

===Parameters===
{{par begin}}
{{par | str | pointer to the first element of the char array for output}}
{{par | count | maximum number of bytes to write}}
{{par | format | pointer to a null-terminated multibyte character string specifying the format of conversion. 
{{cpp/chrono/c/strftime format|c}}
}}
{{par end}}

===Return value===
The number of bytes written into the character array pointed to by {{tt|str}} not including the terminating {{c|'\0'}} on success. If {{tt|count}} was reached before the entire string could be stored, {{c|0}} is returned and the contents are undefined.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    char buff[70];
    struct tm my_time = { .tm_year=112, // = year 2012
                          .tm_mon=9,    // = 10th month
                          .tm_mday=9,   // = 9th day
                          .tm_hour=8,   // = 8 hours
                          .tm_min=10,   // = 10 minutes
                          .tm_sec=20    // = 20 secs
    };

    if (strftime(buff, sizeof buff, &quot;%A %c&quot;, &amp;my_time)) {
        puts(buff);
    } else {
        puts(&quot;strftime failed&quot;);
    }

    setlocale(LC_TIME, &quot;el_GR.utf8&quot;);

    if (strftime(buff, sizeof buff, &quot;%A %c&quot;, &amp;my_time)) {
        puts(buff);
    } else {
        puts(&quot;strftime failed&quot;);
    }
}
 | output=
Sunday Sun Oct  9 08:10:20 2012
Κυριακή Κυρ 09 Οκτ 2012 08:10:20 πμ EST
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc asctime}}
{{dsc inc | c/chrono/dsc ctime}}
{{dsc inc | c/chrono/dsc wcsftime}}
{{dsc see cpp | cpp/chrono/c/strftime}}
{{dsc end}}

[[de:c/chrono/strftime]]
[[es:c/chrono/strftime]]
[[fr:c/chrono/strftime]]
[[it:c/chrono/strftime]]
[[ja:c/chrono/strftime]]
[[pt:c/chrono/strftime]]
[[ru:c/chrono/strftime]]
[[zh:c/chrono/strftime]]</text>
      <sha1>elk7h594921gnzy86gkx87vkp3f7qfz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/time</title>
    <ns>0</ns>
    <id>6169</id>
    <revision>
      <id>71641</id>
      <parentid>71189</parentid>
      <timestamp>2014-06-17T14:32:20Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking for time()</comment>
      <text xml:space="preserve" bytes="1774">{{c/title| time}}
{{c/chrono/navbar}}
{{ddcl | header=time.h |
time_t time( time_t *time );
}}

Returns the current calendar time encoded as a {{lc|time_t}} object. 

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|time_t}} object to store the time in or {{lc|NULL}}}}
{{par end}}

===Return value===

Current calendar time encoded as {{lc|time_t}} object on success, {{c|(time_t)(-1)}} on error. If the argument is not {{lc|NULL}}, the return value is equal to the value stored in the object pointed to by the argument.

===Notes===
The encoding of calendar time in {{lc|time_t}} is unspecified, but most systems conform to [http://pubs.opengroup.org/onlinepubs/9699919799/functions/time.html POSIX specification] and return a value of integral type holding the number of seconds since the Epoch. Implementations in which {{lc|time_t}} is a 32-bit signed integer (many historical implementations) fail in the year 2038.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    time_t result = time(NULL);
    if (result == ((time_t)-1))
    {
       fprintf(stderr,&quot;time() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }
    
    printf(&quot;%s&quot;, asctime(localtime(&amp;result)));
    printf(&quot;%d seconds since the Epoch&quot;, (int)result);
    return EXIT_SUCCESS;
}
 | p=true | output=
Wed Oct  9 10:49:31 2013
1381315771 seconds since the Epoch
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc inc | c/chrono/dsc gmtime}}
{{dsc see cpp | cpp/chrono/c/time}}
{{dsc end}}

[[de:c/chrono/time]]
[[es:c/chrono/time]]
[[fr:c/chrono/time]]
[[it:c/chrono/time]]
[[ja:c/chrono/time]]
[[pt:c/chrono/time]]
[[ru:c/chrono/time]]
[[zh:c/chrono/time]]</text>
      <sha1>6hzlyn2ise06a0v8rcfqwawm6t2ytmt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/time t</title>
    <ns>0</ns>
    <id>6156</id>
    <revision>
      <id>71468</id>
      <parentid>71463</parentid>
      <timestamp>2014-06-11T11:15:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fixing undefined behavior in the example</comment>
      <text xml:space="preserve" bytes="1076">{{c/title|time_t}}
{{c/chrono/navbar}}
{{ddcl | header=time.h | 1=
typedef /* unspecified */ time_t;
}}
Arithmetic type capable of representing times.

Although not defined, this is almost always an integral value holding the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC, corresponding to [[enwiki:Unix_time | POSIX time]].

===Example===
{{example
 | Show the start of the epoch.
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
 
int main(void)
{
    time_t epoch = 0;
    printf(&quot;%d seconds since the epoch began\n&quot;, (int)epoch);
    printf(&quot;%s\n&quot;, asctime(localtime(&amp;epoch)));
    
    return 0;
}
 | p=true
 | output=
0 seconds since the epoch began
Thu Jan  1 00:00:00 1970
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc time}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc inc | c/chrono/dsc gmtime}}
{{dsc see cpp | cpp/chrono/c/time_t}}
{{dsc end}}

[[de:c/chrono/time t]]
[[es:c/chrono/time t]]
[[fr:c/chrono/time t]]
[[it:c/chrono/time t]]
[[ja:c/chrono/time t]]
[[pt:c/chrono/time t]]
[[ru:c/chrono/time t]]
[[zh:c/chrono/time t]]</text>
      <sha1>o33os8twguszr219nhnfvbt5q6buphn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/tm</title>
    <ns>0</ns>
    <id>6157</id>
    <revision>
      <id>71475</id>
      <parentid>71469</parentid>
      <timestamp>2014-06-11T14:51:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>actually, that don't even need a variable</comment>
      <text xml:space="preserve" bytes="1895">{{c/title| tm}}
{{c/chrono/navbar}}

Structure holding a calendar date and time broken down into its components.

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_sec | seconds after the minute &amp;ndash; [0, 61]{{mark until c99}} / [0, 60] {{mark since c99}}&lt;ref name=&quot;leapsecond&quot; group=&quot;note&quot;&gt;Range allows for a positive leap second. Two leap seconds in the same minute are not allowed (the C90 range 0..61 was a defect)&lt;/ref&gt;}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_min | minutes after the hour &amp;ndash; [0, 59]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_hour | hours since midnight &amp;ndash; [0, 23]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_mday | day of the month &amp;ndash; [1, 31]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_mon | months since January &amp;ndash; [0, 11]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_year | years since 1900}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_wday | days since Sunday &amp;ndash; [0, 6]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_yday | days since January 1 &amp;ndash; [0, 365]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_isdst | Daylight Saving Time flag. The value is positive if DST is in effect, zero if not and negative if no information is available}}
{{dsc end}}

======Notes======
&lt;references group=&quot;note&quot; /&gt;

===Example===
{{example
 | Show the start of calendar time.
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
 
int main(void)
{
    printf(&quot;%s\n&quot;, asctime(&amp;(struct tm){.tm_mday=1}));
}
 | p=true
 | output=
Sun Jan  1 00:00:00 1900
}}


===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc localtime}}
{{dsc inc | c/chrono/dsc gmtime}}
{{dsc see cpp | cpp/chrono/c/tm}}
{{dsc end}}

[[de:c/chrono/tm]]
[[es:c/chrono/tm]]
[[fr:c/chrono/tm]]
[[it:c/chrono/tm]]
[[ja:c/chrono/tm]]
[[pt:c/chrono/tm]]
[[ru:c/chrono/tm]]
[[zh:c/chrono/tm]]</text>
      <sha1>b1bevt5ygiup3uruyx20qqsvhxui134</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/chrono/wcsftime</title>
    <ns>0</ns>
    <id>6164</id>
    <revision>
      <id>71193</id>
      <parentid>65923</parentid>
      <timestamp>2014-06-08T01:23:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2196">{{c/title| wcsftime}}
{{c/chrono/navbar}}
{{ddcl | header=wchar.h |
size_t wcsftime( wchar_t* str, size_t count, const wchar_t* format, tm* time );
}}

Converts the date and time information from a given calendar time {{tt|time}} to a null-terminated wide character string {{tt|str}} according to format string {{tt|format}}. Up to {{tt|count}} bytes are written.

===Parameters===
{{par begin}}
{{par | str | pointer to the first element of the wchar_t array for output}}
{{par | count | maximum number of wide characters to write}}
{{par | format | pointer to a null-terminated wide character string specifying the format of conversion. 
{{cpp/chrono/c/strftime format|c}}
}}
{{par end}}

===Return value===

number of wide characters written into the wide character array pointed to by {{tt|str}} not including the terminating {{c|L'\0'}} on success. If {{tt|count}} was reached before the entire string could be stored, {{c|0}} is returned and the contents are undefined.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
#include &lt;wchar.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    wchar_t buff[40];
    struct tm my_time = { .tm_year=112, // = year 2012
                          .tm_mon=9,    // = 10th month
                          .tm_mday=9,   // = 9th day
                          .tm_hour=8,   // = 8 hours
                          .tm_min=10,   // = 10 minutes
                          .tm_sec=20    // = 20 secs
    };

    if (wcsftime(buff, sizeof buff, L&quot;%A %c&quot;, &amp;my_time)) {
        printf(&quot;%ls\n&quot;, buff);
    } else {
        puts(&quot;wcsftime failed&quot;);
    }

    setlocale(LC_ALL, &quot;ja_JP.utf8&quot;);

    if (wcsftime(buff, sizeof buff, L&quot;%A %c&quot;, &amp;my_time)) {
        printf(&quot;%ls\n&quot;, buff);
    } else {
        puts(&quot;wcsftime failed&quot;);
    }
}
 | output=
Sunday Sun Oct  9 08:10:20 2012
日曜日 2012年10月09日 08時10分20秒
}}

===See also===
{{dsc begin}}
{{dsc inc | c/chrono/dsc strftime}}
{{dsc see cpp | cpp/chrono/c/wcsftime}}
{{dsc end}}

[[de:c/chrono/wcsftime]]
[[es:c/chrono/wcsftime]]
[[fr:c/chrono/wcsftime]]
[[it:c/chrono/wcsftime]]
[[ja:c/chrono/wcsftime]]
[[pt:c/chrono/wcsftime]]
[[ru:c/chrono/wcsftime]]
[[zh:c/chrono/wcsftime]]</text>
      <sha1>mhdlocgob4nz7vdvwh3u20ge49epwl7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error</title>
    <ns>0</ns>
    <id>6398</id>
    <revision>
      <id>71026</id>
      <parentid>70980</parentid>
      <timestamp>2014-06-04T19:57:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="833">{{title|Error handling}}
{{c/error/navbar}}

===Types===
{{dsc begin}}
{{dsc header | errno.h}}
{{dsc header | stdio.h}}
{{dsc typedef | errno_t | nolink=true | the type of errno value | notes={{mark c11}}}}
{{dsc end}}

===Error numbers===
{{dsc begin}}
{{dsc header | errno.h}}
{{dsc inc | c/error/dsc errno}}
{{dsc inc | c/error/dsc errno_macros}}
{{dsc end}}

===Assertions===
{{dsc begin}}
{{dsc header | assert.h}}
{{dsc inc | c/error/dsc assert}}
{{dsc macro fun | c/error/static_assert | issues a compile-time diagnostic if the value of a constant expression is false | notes={{mark c11}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/error |Error handling}}
{{dsc end}}

[[ar:c/error]]
[[de:c/error]]
[[es:c/error]]
[[fr:c/error]]
[[it:c/error]]
[[ja:c/error]]
[[pt:c/error]]
[[ru:c/error]]
[[zh:c/error]]</text>
      <sha1>027tjq13lsb6bxe0r2nzu7m8tow1p53</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error/ Static assert</title>
    <ns>0</ns>
    <id>13540</id>
    <redirect title="c/keyword/ Static assert" />
    <revision>
      <id>70416</id>
      <timestamp>2014-05-22T13:35:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[c/error/ Static assert]] to [[c/keyword/ Static assert]]: keywords belong to /c/keyword or /c/language</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[c/keyword/ Static assert]]</text>
      <sha1>6a9cpws1hffm3n5vd550jqk22vnyk1z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error/assert</title>
    <ns>0</ns>
    <id>6405</id>
    <revision>
      <id>56407</id>
      <parentid>48850</parentid>
      <timestamp>2013-06-01T05:35:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1624">{{title|assert}}
{{c/error/navbar}}
{{ddcl | header=assert.h | 
#ifdef NDEBUG
#define assert(condition) ((void)0)
#else
#define assert(condition) /*implementation defined*/
#endif
}}

The definition of the macro {{tt|assert}} depends on another macro, {{c|NDEBUG}}, which is not defined by the standard library.

If {{c|NDEBUG}} is defined as a macro name at the point in the source code where {{tt|&lt;assert.h&gt;}} is included, then {{tt|assert}} does nothing.

If {{c|NDEBUG}} is not defined, then {{tt|assert}} checks if its argument (which must have scalar type) compares equal to zero. If it does, {{tt|assert}} outputs implementation-specific diagnostic information on the standard error output and calls {{c|abort()}}. The diagnostic information is required to include the text of {{tt|expression}}, as well as the values of the standard macros {{c|__FILE__}},  {{c|__LINE__}}, and the standard variable {{c|__func__}}.

===Parameters===
{{par begin}}
{{par | condition | expression of scalar type}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;assert.h&gt;

int main (int argc, char **argv)
{
	// Test if 0 is really equivalent to 0
	assert (0 == 0);

	// Test if 1 is different than 0...
	assert (1 == 0);

	return 0;
}
 | output=
example: ex.c:10: int main(int, char**): Assertion `1 == 0' failed.
Aborted
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc abort}}
{{dsc end}}

[[de:c/error/assert]]
[[es:c/error/assert]]
[[fr:c/error/assert]]
[[it:c/error/assert]]
[[ja:c/error/assert]]
[[pt:c/error/assert]]
[[ru:c/error/assert]]
[[zh:c/error/assert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error/errno</title>
    <ns>0</ns>
    <id>6403</id>
    <revision>
      <id>71759</id>
      <parentid>69403</parentid>
      <timestamp>2014-06-23T16:22:15Z</timestamp>
      <contributor>
        <ip>212.18.10.182</ip>
      </contributor>
      <comment>Fix grammar in third sentence (Typically, ...)</comment>
      <text xml:space="preserve" bytes="2212">{{title|errno}}
{{c/error/navbar}}
{{dcl begin}}
{{dcl header | errno.h}}
{{dcl |
#define errno /*implementation-defined*/
}}
{{dcl end}}

{{tt|errno}} is a preprocessor macro that expands to a thread-local modifiable lvalue of type {{c|int}}. Several standard library functions indicate errors by writing positive integers to {{tt|errno}}. Typically, the value of {{tt|errno}} is set to one of the error codes listed in {{tt|&lt;errno.h&gt;}} as macro constants beginning with the letter {{tt|E}} followed by uppercase letters or digits.

The value of {{tt|errno}} is {{c|0}} at program startup, and although library functions are allowed to write positive integers to {{tt|errno}} whether or not an error occurred, library functions never store {{c|0}} in {{tt|errno}}.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;errno.h&gt;
#include &lt;fcntl.h&gt;
#include &lt;unistd.h&gt;
#include &lt;stdlib.h&gt;

int main (int argc, char **argv)
{
	int fd = -1;
	fd = open (&quot;/dev/zer0&quot;, O_RDONLY);

	if (fd == -1)
	{
		/* perror uses errno */
		perror (&quot;Ouuupsss&quot;);
		exit (EXIT_FAILURE);
	}

	close (fd);

	return EXIT_SUCCESS;
}
 | output=
Ouuupsss: No such file or directory
}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
 
void show_errno(void)
{
    if(errno==EDOM)   printf(&quot;domain error&quot;);
    if(errno==EILSEQ) printf(&quot;illegal sequence&quot;);    
    if(errno==ERANGE) printf(&quot;pole or range error&quot;);
    if(errno==0)      printf(&quot;no error&quot;);
    printf(&quot; occurred\n&quot;);
}
 
int main()
{
    printf(&quot;math_errhandling &amp; MATH_ERRNO = %d\n&quot;, math_errhandling &amp; MATH_ERRNO);

    errno = 0;
    acos(+1.1);
    show_errno();
    
    errno = 0;
    log(0.0);
    show_errno();
    
    errno = 0;
    sin(0.0);
    show_errno();

    return 0;
}
 | output=
math_errhandling &amp; MATH_ERRNO = 1
domain error occurred
pole or range error occurred
no error occurred
}}

===See also===
{{dsc begin}}
{{dsc inc | c/error/dsc errno_macros}}
{{dsc inc | c/io/dsc perror}}
{{dsc inc | c/string/byte/dsc strerror}}
{{dsc end}}

[[de:c/error/errno]]
[[es:c/error/errno]]
[[fr:c/error/errno]]
[[it:c/error/errno]]
[[ja:c/error/errno]]
[[pt:c/error/errno]]
[[ru:c/error/errno]]
[[zh:c/error/errno]]</text>
      <sha1>n2k8oaetyo7mbzdddqxd28mlp2nouof</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error/errno macros</title>
    <ns>0</ns>
    <id>6404</id>
    <revision>
      <id>71617</id>
      <parentid>71615</parentid>
      <timestamp>2014-06-17T03:02:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link and seealso c++</comment>
      <text xml:space="preserve" bytes="1884">{{title|Error numbers}}
{{c/error/navbar}}

Each of the macros defined in {{tt|&lt;errno.h&gt;}} expands to an integer constant expression with type {{c|int}} and with a unique positive value. The following constants are defined (the implementation may define more, as long as they begin with {{c|'E'}} followed by digits or uppercase letters)

{{dsc begin}}
{{dsc header | errno.h}}
{{dsc macro const | EDOM             | nolink=true|                     Mathematics argument out of domain of function}}
{{dsc macro const | EILSEQ           | nolink=true| notes={{mark c99}}| Illegal byte sequence}}
{{dsc macro const | ERANGE           | nolink=true|                     Result too large}}
{{dsc end}}

===Notes===
Many additional errno constants are [http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html defined by POSIX] and by the [[cpp/error/errno_macros|C++ standard library]], and individual implementations may define even more, e.g. {{tt|errno(3)}} on Linux or {{tt|intro(2)}} on BSD and OS X.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    errno = 0;
    printf(&quot;log(-1.0) = %f\n&quot;, log(-1.0));
    printf(&quot;%s\n\n&quot;,strerror(errno));
 
    errno = 0;
    printf(&quot;log(0.0)  = %f\n&quot;, log(0.0));
    printf(&quot;%s\n&quot;,strerror(errno));
}
 | p=true
 | output=
log(-1.0) = nan
Numerical argument out of domain

log(0.0)  = -inf
Numerical result out of range
}}

===See also===
{{dsc begin}}
{{dsc inc | c/error/dsc errno}}
{{dsc inc | c/io/dsc perror}}
{{dsc inc | c/string/byte/dsc strerror}}
{{dsc see cpp | cpp/error/errno_macros | Error numbers }}
{{dsc end}}

[[de:c/error/errno macros]]
[[es:c/error/errno macros]]
[[fr:c/error/errno macros]]
[[it:c/error/errno macros]]
[[ja:c/error/errno macros]]
[[pt:c/error/errno macros]]
[[ru:c/error/errno macros]]
[[zh:c/error/errno macros]]</text>
      <sha1>6cfhoezibvbik6gc7chcuf9iz39ngia</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/error/static assert</title>
    <ns>0</ns>
    <id>13541</id>
    <revision>
      <id>70417</id>
      <timestamp>2014-05-22T13:40:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="479">{{title|static_assert}}
{{c/error/navbar}}
{{ddcl | header=assert.h | 
#define static_assert _Static_assert
}}

This convenience macro expands to the keyword [[c/keyword/_Static_assert|_Static_assert]]

===Example===
{{example
|code=
#include &lt;assert.h&gt;
int main(void)
{
    static_assert(2 + 2 == 4, &quot;2+2 isn't 4&quot;);      // well-formed
    static_assert(sizeof(int) &lt; sizeof(char),
                 &quot;this program requires that int is less than char&quot;); // compile-time error
}
}}</text>
      <sha1>le3yh5w6zcnrjkz9woc3jtw7b59v4s8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/header</title>
    <ns>0</ns>
    <id>6313</id>
    <revision>
      <id>71951</id>
      <parentid>71916</parentid>
      <timestamp>2014-07-04T14:33:49Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted link to c/header/align</comment>
      <text xml:space="preserve" bytes="3043">{{title|C Standard Library header files}}
{{c/navbar}}

{{dsc begin}}
{{dsc|{{ttb|&amp;lt;assert.h&amp;gt;}} |[[c/error|Conditionally compiled macro that compares its argument to zero]]}}
{{dsc|{{ttb|&amp;lt;complex.h&amp;gt;}} {{mark since c99}}|[[c/numeric/complex|Complex number arithmetic]] }}
{{dsc|{{ttb|&amp;lt;ctype.h&amp;gt;}} |[[c/string/byte|Functions to determine the type contained in character data]]}}
{{dsc|{{ttb|&amp;lt;errno.h&amp;gt;}} |[[c/error|Macros reporting error conditions]]}}
{{dsc|{{ttb|&amp;lt;fenv.h&amp;gt;}} {{mark since c99}}|[[c/numeric/fenv|Floating-point environment]] }}
{{dsc|{{ttb|&amp;lt;float.h&amp;gt;}} |[[c/types/limits#Limits of floating point types|Limits of float types]]}}
{{dsc|{{ttb|&amp;lt;inttypes.h&amp;gt;}} {{mark since c99}}|[[c/types/integer|Format conversion of integer types]] }}
{{dsc|{{ttb|&amp;lt;iso646.h&amp;gt;}} {{mark since c99}}|[[c/language/operator_alternative | Alternative operator spellings]] }}
{{dsc|{{ttb|&amp;lt;limits.h&amp;gt;}} |[[c/types/limits|Sizes of basic types]]}}
{{dsc|{{ttb|&amp;lt;locale.h&amp;gt;}} |[[c/locale|Localization utilities]]}}
{{dsc|{{ttb|&amp;lt;math.h&amp;gt;}} |[[c/numeric/math|Common mathematics functions]]}}
{{dsc|{{ttb|&amp;lt;setjmp.h&amp;gt;}} |[[c/program|Nonlocal jumps]]}}
{{dsc|{{ttb|&amp;lt;signal.h&amp;gt;}} |[[c/program|Signal handling]]}}
{{dsc|{{ttb|&amp;lt;stdalign.h&amp;gt;}} {{mark since c11}} |[[c/header/align|Type alignment control]]}}
{{dsc|{{ttb|&amp;lt;stdarg.h&amp;gt;}} |[[c/variadic|Variable arguments]]}}
{{dsc|{{ttb|&amp;lt;stdatomic.h&amp;gt;}} {{mark since c11}}|[[c/atomic|Atomic types]] }}
{{dsc|{{ttb|&amp;lt;stdbool.h&amp;gt;}} {{mark since c99}}|[[c/types|Macros supporting type bool]] }}
{{dsc|{{ttb|&amp;lt;stddef.h&amp;gt;}} |Common macro definitions}}
{{dsc|{{ttb|&amp;lt;stdint.h&amp;gt;}} {{mark since c99}}|[[c/types/integer|Fixed-width integer types]] }}
{{dsc|{{ttb|&amp;lt;stdio.h&amp;gt;}} |[[c/io|Input/output]]}}
{{dsc|{{ttb|&amp;lt;stdlib.h&amp;gt;}} |General utilities: [[c/memory|memory management]], [[c/program|program utilities]], [[c/string|string conversions]], [[c/numeric/random|random numbers]] }}
{{dsc|{{ttb|&amp;lt;stdnoreturn.h&amp;gt;}} {{mark since c11}}|Non-returning functions }}
{{dsc|{{ttb|&amp;lt;string.h&amp;gt;}} |[[c/string/byte|String handling]]}}
{{dsc|{{ttb|&amp;lt;tgmath.h&amp;gt;}} {{mark since c99}}|[[c/numeric/tgmath|Type-generic math]] (macros wrapping math.h and complex.h) }}
{{dsc|{{ttb|&amp;lt;threads.h&amp;gt;}} {{mark since c11}}|[[c/thread|Thread library]] }}
{{dsc|{{ttb|&amp;lt;time.h&amp;gt;}} |[[c/chrono|Time/date utilities]]}}
{{dsc|{{ttb|&amp;lt;uchar.h&amp;gt;}} {{mark since c11}}|[[c/string/multibyte|UTF-16 and UTF-32 character utilities]] }}
{{dsc|{{ttb|&amp;lt;wchar.h&amp;gt;}} {{mark since c99}}|[[c/string/wide|Extended multibyte and wide character utilities]] }}
{{dsc|{{ttb|&amp;lt;wctype.h&amp;gt;}} {{mark since c99}}|[[c/string/wide|Wide character classification and mapping utilities]] }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/header |C++ Standard Library header files}}
{{dsc end}}

[[ar:c/header]]
[[de:c/header]]
[[es:c/header]]
[[fr:c/header]]
[[it:c/header]]
[[ja:c/header]]
[[pt:c/header]]
[[ru:c/header]]
[[zh:c/header]]</text>
      <sha1>1sfvnnlpkmqhznxeenvy0evnfalgu3o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/header/align</title>
    <ns>0</ns>
    <id>13710</id>
    <revision>
      <id>71929</id>
      <parentid>71924</parentid>
      <timestamp>2014-07-02T01:17:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>Cubbi moved page [[c/align]] to [[c/header/align]] without leaving a redirect: this looks like a page about a header</comment>
      <text xml:space="preserve" bytes="626">{{title|Type alignment control}}
{{c/align/navbar}}

This header provides four macros for specifying and querying the alignment of types and objects.

{{dsc begin}}
{{dsc header | stdalign.h}}
{{dsc h2 | Macros}}
{{dsc inc | c/align/dsc alignas}}
{{dsc inc | c/align/dsc alignof}}
{{dsc inc | c/align/dsc __alignas_is_defined}}
{{dsc inc | c/align/dsc __alignof_is_defined}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/header/cstdalign | Standard library header &lt;cstdalign&gt;}}
{{dsc end}}

[[de:c/align]]
[[es:c/align]]
[[fr:c/align]]
[[it:c/align]]
[[ja:c/align]]
[[pt:c/align]]
[[ru:c/align]]
[[zh:c/align]]</text>
      <sha1>h2g0uyah6d7j0oyxq3kpw2rsf0rh976</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io</title>
    <ns>0</ns>
    <id>5867</id>
    <revision>
      <id>71030</id>
      <parentid>70999</parentid>
      <timestamp>2014-06-04T20:09:09Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="4058">{{title|File input/output}}
{{c/io/navbar}}
The {{tt|&lt;stdio.h&gt;}} header provides generic file operation support and supplies functions with narrow character input/output capabilities.

The {{tt|&lt;wchar.h&gt;}} header supplies functions with wide character input/output capabilities.  

===Functions===
{{dsc begin}}
{{dsc h2 | File access}}
{{dsc inc | c/io/dsc fopen}}
{{dsc inc | c/io/dsc freopen}}
{{dsc inc | c/io/dsc fclose}}
{{dsc inc | c/io/dsc fflush}}
{{dsc inc | c/io/dsc fwide}}
{{dsc inc | c/io/dsc setbuf}}
{{dsc inc | c/io/dsc setvbuf}}

{{dsc h2 | Direct input/output}}
{{dsc inc | c/io/dsc fread}}
{{dsc inc | c/io/dsc fwrite}}

{{dsc h2 | Unformatted input/output}}
{{dsc h2 | {{small|Narrow character}}}}
{{dsc inc | c/io/dsc fgetc}}
{{dsc inc | c/io/dsc fgets}}
{{dsc inc | c/io/dsc fputc}}
{{dsc inc | c/io/dsc fputs}}
{{dsc inc | c/io/dsc getchar}}
{{dsc inc | c/io/dsc gets}}
{{dsc inc | c/io/dsc putchar}}
{{dsc inc | c/io/dsc puts}}
{{dsc inc | c/io/dsc ungetc}}

{{dsc h2 | {{small|Wide character}}}}
{{dsc inc | c/io/dsc fgetwc}}
{{dsc inc | c/io/dsc fgetws}}
{{dsc inc | c/io/dsc fputwc}}
{{dsc inc | c/io/dsc fputws}}
{{dsc inc | c/io/dsc getwchar}}
{{dsc inc | c/io/dsc putwchar}}
{{dsc inc | c/io/dsc ungetwc}}

{{dsc h2 | Formatted input/output}}
{{dsc h2 | {{small|Narrow character}}}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc inc | c/io/dsc vfscanf}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc inc | c/io/dsc vfprintf}}

{{dsc h2 | {{small|Wide character}}}}
{{dsc inc | c/io/dsc fwscanf}}
{{dsc inc | c/io/dsc vfwscanf}}
{{dsc inc | c/io/dsc fwprintf}}
{{dsc inc | c/io/dsc vfwprintf}}

{{dsc h2 | File positioning}}
{{dsc inc | c/io/dsc ftell}}
{{dsc inc | c/io/dsc fgetpos}}
{{dsc inc | c/io/dsc fseek}}
{{dsc inc | c/io/dsc fsetpos}}
{{dsc inc | c/io/dsc rewind}}

{{dsc h2 | Error handling}}
{{dsc inc | c/io/dsc clearerr}}
{{dsc inc | c/io/dsc feof}}
{{dsc inc | c/io/dsc ferror}}
{{dsc inc | c/io/dsc perror}}

{{dsc h2 | Operations on files}}
{{dsc inc | c/io/dsc remove}}
{{dsc inc | c/io/dsc rename}}
{{dsc inc | c/io/dsc tmpfile}}
{{dsc inc | c/io/dsc tmpnam}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | stdio.h}}
{{dsc hitem | Type | Definition}}
{{dsc | {{lc|FILE}} | type, capable of holding all information needed to control a C I/O stream}}
{{dsc | {{lc|fpos_t}} | type, capable of uniquely specifying a position in a file}}
{{dsc end}}

===Macros===

{{dsc begin}}
{{dsc header | stdio.h}}
{{dsc macro const | stdin | nolink=true| title=stdin&lt;br&gt;stdout&lt;br&gt;stderr | expression of type FILE* associated with the input stream&lt;br&gt;expression of type FILE* associated with the output stream&lt;br&gt;expression of type FILE* associated with the error output stream}}
{{dsc macro const | EOF | nolink=true| integer constant expression of type {{c|int}} and negative value }}
{{dsc macro const | FOPEN_MAX | nolink=true| number of files that can be open simultaneously }}
{{dsc macro const | FILENAME_MAX | nolink=true| size needed for an array of char to hold the longest supported file name}}
{{dsc macro const | BUFSIZ | nolink=true| size of the buffer used by setbuf() }}
{{dsc macro const | _IOFBF| nolink=true| title=_IOFBF&lt;br&gt;_IOLBF&lt;br&gt;_IONBF|argument to setvbuf() indicating fully buffered I/O&lt;br&gt;argument to setvbuf() indicating line buffered I/O&lt;br&gt;argument to setvbuf() indicating unbuffered I/O}}
{{dsc macro const | SEEK_SET | nolink=true| title=SEEK_SET&lt;br&gt;SEEK_CUR&lt;br&gt;SEEK_END | argument to fseek() indicating seeking from beginning of the file&lt;br&gt;argument to fseek() indicating seeking from the current file position&lt;br&gt;argument to fseek() indicating seeking from end of the file}}
{{dsc macro const | TMP_MAX | nolink=true| maximum number of unique filenames that can be generated by tmpnam()}}
{{dsc macro const | L_tmpnam |nolink=true|  size needed for an array of char to hold the result of tmpnam()}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/io/c |C-style file input/output}}
{{dsc end}}

[[de:c/io]]
[[es:c/io]]
[[fr:c/io]]
[[it:c/io]]
[[ja:c/io]]
[[pt:c/io]]
[[ru:c/io]]
[[zh:c/io]]</text>
      <sha1>851urrp37b4jhqfklrrnazmu78gnhow</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/clearerr</title>
    <ns>0</ns>
    <id>6235</id>
    <revision>
      <id>69930</id>
      <parentid>69929</parentid>
      <timestamp>2014-05-02T00:58:38Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output</comment>
      <text xml:space="preserve" bytes="3181">{{c/title | clearerr}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
void clearerr( FILE *stream );
}}

Resets the error flags and the {{tt|EOF}} indicator for the given file stream.

===Parameters===
{{par begin}}
{{par | stream | the file to reset the error flags for }}
{{par end}}

===Return value===
(none)

===Example===
{{example | clearerr resets the EOF indicator
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();
    fputs(&quot;abcde\n&quot;, tmpf);
    rewind(tmpf);
 
    int ch;
    while ((ch=fgetc(tmpf)) != EOF)   /* read/print characters including newline */
          printf(&quot;%c&quot;, ch);
 
    /* Test reason for reaching EOF. */
    if (feof(tmpf))          /* if failure caused by end-of-file condition */
    {
       puts(&quot;End of file reached&quot;);
       clearerr(tmpf);  /* clear eof indicator */
       if (feof(tmpf))
          printf(&quot;EOF indicator set\n&quot;);
       else
          printf(&quot;EOF indicator cleared\n&quot;);
    }
    else if (ferror(tmpf))   /* if failure caused by some other error      */
         {
            perror(&quot;fgetc()&quot;);
            fprintf(stderr,&quot;fgetc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-16);
            clearerr(tmpf);  /* clear error indicator */
            if (ferror(tmpf))
               printf(&quot;error indicator set\n&quot;);
            else
               printf(&quot;error indicator cleared\n&quot;);
            exit(EXIT_FAILURE);
         }
 
    return EXIT_SUCCESS;
}
 | output=
abcde
End of file reached
EOF indicator cleared
}}

===Example===
{{example | clearerr resets error indocator
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();
    fputs(&quot;abcde\n&quot;, tmpf);
    fclose(tmpf);            /* close temporary file to force error */
 
    int ch;
    while ((ch=fgetc(tmpf)) != EOF)   /* read/print characters including newline */
          printf(&quot;%c&quot;, ch);
 
    /* Test reason for reaching EOF. */
    if (feof(tmpf))          /* if failure caused by end-of-file condition */
    {
       puts(&quot;End of file reached&quot;);
       clearerr(tmpf);  /* clear eof indicator */
       if (feof(tmpf))
          printf(&quot;EOF indicator set\n&quot;);
       else
          printf(&quot;EOF indicator cleared\n&quot;);
    }
    else if (ferror(tmpf))   /* if failure caused by some other error      */
         {
            perror(&quot;fgetc()&quot;);
            fprintf(stderr,&quot;fgetc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-16);
            clearerr(tmpf);  /* clear error indicator */
            if (ferror(tmpf))
               printf(&quot;error indicator set\n&quot;);
            else
               printf(&quot;error indicator cleared\n&quot;);
            exit(EXIT_FAILURE);
         }
 
    return EXIT_SUCCESS;
}
 | output=
fgetc(): Bad file descriptor
fgetc() failed in file main.cpp at line # 11
error indicator cleared
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc feof}}
{{dsc inc | c/io/dsc perror}}
{{dsc inc | c/io/dsc ferror}}
{{dsc see cpp | cpp/io/c/clearerr}}
{{dsc end}}

[[de:c/io/clearerr]]
[[es:c/io/clearerr]]
[[fr:c/io/clearerr]]
[[it:c/io/clearerr]]
[[ja:c/io/clearerr]]
[[pt:c/io/clearerr]]
[[ru:c/io/clearerr]]
[[zh:c/io/clearerr]]</text>
      <sha1>l5mylqe5n05l1nawx8tc3yzzu7anxcs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fclose</title>
    <ns>0</ns>
    <id>6199</id>
    <revision>
      <id>69898</id>
      <parentid>69788</parentid>
      <timestamp>2014-05-01T12:00:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1575">{{c/title | fclose}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int fclose( FILE *stream );
}}

Closes the given file stream. Any unwritten buffered data are flushed to the OS. Any unread buffered data are discarded.

Whether or not the operation succeeds, the stream is no longer associated with a file, and the buffer allocated by {{lc|setbuf}} or {{lc|setvbuf}}, if any, is also disassociated and deallocated if automatic allocation was used.

===Parameters===
{{par begin}}
{{par | stream | the file stream to close}}
{{par end}}

===Return value===

{{c|0}} on success, {{lc|EOF}} otherwise

===Example===
{{example | fclose with error checking. Code closes a file which was opened for writing data. 
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE *fp = fopen(&quot;data.txt&quot;,&quot;w&quot;);
    if (fp == NULL)
    {
       perror(&quot;fopen()&quot;);
       fprintf(stderr,&quot;fopen() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
 
    /* Normal processing continues here. */
    int ret_code = fclose(fp);
    if (ret_code == EOF)
    {
      perror(&quot;fclose()&quot;);
      fprintf(stderr,&quot;fclose() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
 
    return EXIT_SUCCESS;
}
 | output=
(none)
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fopen}}
{{dsc inc | c/io/dsc freopen}}
{{dsc see cpp | cpp/io/c/fclose}}
{{dsc end}}

[[de:c/io/fclose]]
[[es:c/io/fclose]]
[[fr:c/io/fclose]]
[[it:c/io/fclose]]
[[ja:c/io/fclose]]
[[pt:c/io/fclose]]
[[ru:c/io/fclose]]
[[zh:c/io/fclose]]</text>
      <sha1>p3hldf4vic068cr3xxcsnrsdrs8yhgm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/feof</title>
    <ns>0</ns>
    <id>6236</id>
    <revision>
      <id>71206</id>
      <parentid>56419</parentid>
      <timestamp>2014-06-08T11:08:31Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1704">{{c/title | feof}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int feof( FILE *stream );
}}

Checks if the end of the given file stream has been reached.

===Parameters===
{{par begin}}
{{par | stream | the file stream to check }}
{{par end}}

===Return value===
nonzero value if the end of the stream has been reached, otherwise {{c|0}}

===Notes===
This function only reports the stream state as reported by the most recent I/O operation, it does not examine the associated data source. For example, if the most recent I/O was a {{lc|fgetc}}, which returned the last byte of a file, {{tt|feof}} returns zero. The next {{lc|fgetc}} fails and changes the stream state to ''end-of-file''. Only then {{tt|feof}} returns non-zero.

In typical usage, input stream processing stops on any error; {{tt|feof}} and {{lc|ferror}} are then used to distinguish between different error conditions.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    FILE* fp = fopen(&quot;test.txt&quot;, &quot;r&quot;);
    if(!fp) {
        perror(&quot;File opening failed&quot;);
        return EXIT_FAILURE;
    }

    int c; // note: int, not char, required to handle EOF
    while ((c = fgetc(fp)) != EOF) { // typical file reading loop
       putchar(c);
    }

    if (ferror(fp))
        puts(&quot;I/O error when reading&quot;);
    else if (feof(fp))
        puts(&quot;End of file reached successfully&quot;);
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc clearerr}}
{{dsc inc | c/io/dsc perror}}
{{dsc inc | c/io/dsc ferror}}
{{dsc see cpp | cpp/io/c/feof}}
{{dsc end}}

[[de:c/io/feof]]
[[es:c/io/feof]]
[[fr:c/io/feof]]
[[it:c/io/feof]]
[[ja:c/io/feof]]
[[pt:c/io/feof]]
[[ru:c/io/feof]]
[[zh:c/io/feof]]</text>
      <sha1>1dnrw3xan8ms19k375aeufj2d90jnpi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/ferror</title>
    <ns>0</ns>
    <id>6237</id>
    <revision>
      <id>69931</id>
      <parentid>69836</parentid>
      <timestamp>2014-05-02T01:03:01Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1463">{{c/title | ferror}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int ferror( FILE *stream );
}}

Checks the given stream for errors.

===Parameters===
{{par begin}}
{{par | stream | the file stream to check }}
{{par end}}

===Return value===
nonzero value if the file stream has errors occurred, {{c|0}} otherwise 

===Example===
{{example | ferror used in error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();
    fputs(&quot;abcde\n&quot;, tmpf); 
    rewind(tmpf);
 
    int ch;
    while ((ch=fgetc(tmpf)) != EOF)   /* read/print characters including newline */
          printf(&quot;%c&quot;, ch);
 
    /* Test reason for reaching EOF. */
    if (feof(tmpf))          /* if failure caused by end-of-file condition */
       puts(&quot;End of file reached successfully&quot;);
    else if (ferror(tmpf))   /* if failure caused by some other error      */
         {
            perror(&quot;fgetc()&quot;);
            fprintf(stderr,&quot;fgetc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-9);
            exit(EXIT_FAILURE);
         }
 
    return EXIT_SUCCESS;
}
 | output=
abcde
End of file reached successfully
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc clearerr}}
{{dsc inc | c/io/dsc feof}}
{{dsc inc | c/io/dsc perror}}
{{dsc see cpp | cpp/io/c/ferror}}
{{dsc end}}

[[de:c/io/ferror]]
[[es:c/io/ferror]]
[[fr:c/io/ferror]]
[[it:c/io/ferror]]
[[ja:c/io/ferror]]
[[pt:c/io/ferror]]
[[ru:c/io/ferror]]
[[zh:c/io/ferror]]</text>
      <sha1>4vqg7tik3t7drghvfptvi71bwtz072v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fflush</title>
    <ns>0</ns>
    <id>6200</id>
    <revision>
      <id>65951</id>
      <parentid>65948</parentid>
      <timestamp>2013-10-16T12:49:56Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="927">{{c/title | fflush}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int fflush( FILE *stream );
}}

Causes the output file stream to be synchronized with the actual contents of the file. 

The behavior is undefined if the given stream is of the input type or if the given stream is of the update type, but the last I/O operation was not an output operation.

If {{tt|stream}} is {{c|NULL}}, all open streams are flushed.

===Parameters===
{{par begin}}
{{par | stream | the file stream to synchronize}}
{{par end}}

===Return value===

Returns zero on success. Otherwise {{lc|EOF}} is returned and the error indicator of the file stream is set.

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fopen}}
{{dsc inc | c/io/dsc fclose}}
{{dsc see cpp | cpp/io/c/fflush}}
{{dsc end}}

[[de:c/io/fflush]]
[[es:c/io/fflush]]
[[fr:c/io/fflush]]
[[it:c/io/fflush]]
[[ja:c/io/fflush]]
[[pt:c/io/fflush]]
[[ru:c/io/fflush]]
[[zh:c/io/fflush]]</text>
      <sha1>jzvwg2ymewq2ho4uuh73stx4lgylkcg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fgetc</title>
    <ns>0</ns>
    <id>6206</id>
    <revision>
      <id>69904</id>
      <parentid>69824</parentid>
      <timestamp>2014-05-01T13:07:06Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1857">{{c/title | fgetc | getc}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl |
int fgetc( FILE *stream );
}}
{{dcl |
int getc( FILE *stream );
}}
{{dcl rev end}}
{{dcl end}}

Reads the next character from the given input stream. {{c|getc()}} may be implemented as a macro. 

===Parameters===
{{par begin}}
{{par | stream | to read the character from }}
{{par end}}

===Return value===
The obtained character on success or {{lc|EOF}} on failure. 

If the failure has been caused by end-of-file condition, additionally sets the ''eof'' indicator (see {{lc|feof()}}) on {{tt|stream}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|ferror()}}) on {{tt|stream}}.

===Example===
{{example | fgetc with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();
    fputs(&quot;abcde\n&quot;, tmpf);
 
    rewind(tmpf);
    
    int ch;
    while ((ch=fgetc(tmpf)) != EOF)   /* read/print characters including newline */
          printf(&quot;%c&quot;, ch);

    /* Test reason for reaching EOF. */
    if (feof(tmpf))          /* if failure caused by end-of-file condition */
       puts(&quot;End of file reached&quot;);
    else if (ferror(tmpf))   /* if failure caused by some other error      */
         {
            perror(&quot;fgetc()&quot;);
            fprintf(stderr,&quot;fgetc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-9);
            exit(EXIT_FAILURE);
         }

    return EXIT_SUCCESS;
}
 | output=
abcde
End of file reached
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc gets}}
{{dsc inc | c/io/dsc fputc}}
{{dsc inc | c/io/dsc ungetc}}
{{dsc see cpp | cpp/io/c/fgetc | fgetc | getc}}
{{dsc end}}

[[de:c/io/fgetc]]
[[es:c/io/fgetc]]
[[fr:c/io/fgetc]]
[[it:c/io/fgetc]]
[[ja:c/io/fgetc]]
[[pt:c/io/fgetc]]
[[ru:c/io/fgetc]]
[[zh:c/io/fgetc]]</text>
      <sha1>4cus3cqxnzjkun6hctbi8mdvbra7589</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fgetpos</title>
    <ns>0</ns>
    <id>6231</id>
    <revision>
      <id>69913</id>
      <parentid>69859</parentid>
      <timestamp>2014-05-01T14:03:39Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="2104">{{c/title | fgetpos}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
int fgetpos( FILE          *stream, fpos_t          *pos );
}}
{{dcl | since=c99 |
int fgetpos( FILE *restrict stream, fpos_t *restrict pos );
}}
{{dcl rev end}}
{{dcl end}}

Obtains the file position indicator for the file stream {{tt|stream}} and stores it in {{tt|pos}}. 

===Parameters===
{{par begin}}
{{par | stream | file stream to examine}}
{{par | pos | pointer to a {{lc|fpos_t}} object to store the file position indicator to}}
{{par end}}

===Return value===
{{c|0}} upon success, nonzero value otherwise.

===Example===
{{example | fgetpos with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    /* Prepare an array of f-p values. */
    #define SIZE 5
    double A[SIZE] = {1.,2.,3.,4.,5.};
    /* Write array to a file. */
    FILE * fp = fopen(&quot;test.bin&quot;, &quot;wb&quot;);
    fwrite(A,sizeof(double),SIZE,fp);
    fclose (fp);
 
    /* Read the f-p values into array B. */
    double B[SIZE];
    fp = fopen(&quot;test.bin&quot;,&quot;rb&quot;);
    fpos_t pos;
    if (fgetpos(fp,&amp;pos) != 0)      /* current position: start of file */
    {
       perror(&quot;fgetpos()&quot;);
       fprintf(stderr,&quot;fgetpos() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }

    int ret_code = fread(B,sizeof(double),1,fp);   /* read one f-p value */
    /* current position: after reading one f-p value */
    printf(&quot;%.1f\n&quot;, B[0]);   /* print one f-p value */
    
    fsetpos(fp,&amp;pos);   /* reset current position to start of file */
    ret_code = fread(B,sizeof(double),1,fp);   /* reread first f-p value */
    printf(&quot;%.1f\n&quot;, B[0]);   /* print one f-p value */
 
    return EXIT_SUCCESS; 
}
 | output=
1.0
1.0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc ftell}}
{{dsc inc | c/io/dsc fseek}}
{{dsc inc | c/io/dsc fsetpos}}
{{dsc see cpp | cpp/io/c/fgetpos}}
{{dsc end}}

[[de:c/io/fgetpos]]
[[es:c/io/fgetpos]]
[[fr:c/io/fgetpos]]
[[it:c/io/fgetpos]]
[[ja:c/io/fgetpos]]
[[pt:c/io/fgetpos]]
[[ru:c/io/fgetpos]]
[[zh:c/io/fgetpos]]</text>
      <sha1>6z5n0uyra51wkv4h8bksiscm3y6vvsz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fgets</title>
    <ns>0</ns>
    <id>6207</id>
    <revision>
      <id>69905</id>
      <parentid>69823</parentid>
      <timestamp>2014-05-01T13:14:33Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="2340">{{c/title | fgets}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
char *fgets( char          *str, int count, FILE          *stream );
}}
{{dcl | since=c99 |
char *fgets( char *restrict str, int count, FILE *restrict stream );
}}
{{dcl rev end}}
{{dcl end}}

Reads at most {{c|count - 1}} characters from the given file stream and stores them in {{tt|str}}. The produced character string is always {{lc|NULL}}-terminated. Parsing stops if end-of-file occurs or a newline character is found, in which case {{tt|str}} will contain that newline character.

===Parameters===
{{par begin}}
{{par | str | string to read the characters to}}
{{par | count | the length of {{tt|str}}}}
{{par | stream | file stream to read the data from}}
{{par end}}

===Return value===
{{tt|str}} on success, {{lc|NULL}} on failure.

If the failure has been caused by end-of-file condition, additionally sets the ''eof'' indicator (see {{lc|feof()}}) on {{tt|stream}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|ferror()}}) on {{tt|stream}}.

===Example===
{{example | fgets with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();
    fputs(&quot;Alan Turing\n&quot;, tmpf);
    fputs(&quot;John von Neumann\n&quot;, tmpf);
    fputs(&quot;Alonzo Church\n&quot;, tmpf);
 
    rewind(tmpf);
    
    char buf[8];
    while (fgets(buf, sizeof buf, tmpf) != NULL)
          printf(&quot;\&quot;%s\&quot;\n&quot;, buf);

    /* Test reason for reaching NULL. */
    if (feof(tmpf))          /* if failure caused by end-of-file condition */
       puts(&quot;End of file reached&quot;);
    else if (ferror(tmpf))   /* if failure caused by some other error      */
         {
            perror(&quot;fgets()&quot;);
            fprintf(stderr,&quot;fgets() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-9);
            exit(EXIT_FAILURE);
         }

    return EXIT_SUCCESS;
}
 | output=
&quot;Alan Tu&quot;
&quot;ring
&quot;
&quot;John vo&quot;
&quot;n Neuma&quot;
&quot;nn
&quot;
&quot;Alonzo &quot;
&quot;Church
&quot;
End of file reached
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc inc | c/io/dsc gets}}
{{dsc inc | c/io/dsc fputs}}
{{dsc see cpp | cpp/io/c/fgets}}
{{dsc end}}

[[de:c/io/fgets]]
[[es:c/io/fgets]]
[[fr:c/io/fgets]]
[[it:c/io/fgets]]
[[ja:c/io/fgets]]
[[pt:c/io/fgets]]
[[ru:c/io/fgets]]
[[zh:c/io/fgets]]</text>
      <sha1>mfvk4xmmvn0lzbiuc5pym3wvx5nvsjc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fgetwc</title>
    <ns>0</ns>
    <id>6215</id>
    <revision>
      <id>66058</id>
      <parentid>66057</parentid>
      <timestamp>2013-10-23T23:59:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1050">{{c/title | fgetwc }}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl rev begin}}
{{dcl |
wint_t fgetwc( FILE *stream );
}}
{{dcl |
wint_t getwc( FILE *stream );
}}
{{dcl rev end}}
{{dcl end}}

Reads the next wide character from the given input stream. {{c|getwc()}} may be implemented as a macro and may evaluate {{tt|stream}} more than once.

===Parameters===
{{par begin}}
{{par | stream | to read the wide character from }}
{{par end}}

===Return value===
The next wide character from the stream or {{c|WEOF}} if an error has occurred or the end of file has been reached. If an encoding error occurred, {{lc|errno}} is set to {{tt|EILSEQ}}.

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fgetc}}
{{dsc inc | c/io/dsc fgetws}}
{{dsc inc | c/io/dsc fputwc}}
{{dsc inc | c/io/dsc ungetwc}}
{{dsc see cpp | cpp/io/c/fgetwc}}
{{dsc end}}

[[de:c/io/fgetwc]]
[[es:c/io/fgetwc]]
[[fr:c/io/fgetwc]]
[[it:c/io/fgetwc]]
[[ja:c/io/fgetwc]]
[[pt:c/io/fgetwc]]
[[ru:c/io/fgetwc]]
[[zh:c/io/fgetwc]]</text>
      <sha1>agz68b0re9xdxgv63xhgt3gonx0by98</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fgetws</title>
    <ns>0</ns>
    <id>6216</id>
    <revision>
      <id>56430</id>
      <parentid>48864</parentid>
      <timestamp>2013-06-01T05:36:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1010">{{c/title | fgetws}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
wchar_t *fgetws( wchar_t *str, int count, FILE *stream );
}}

Reads at most {{c|count - 1}} wide characters from the given file stream and stores them in {{tt|str}}. The produced wide string is always {{lc|NULL}}-terminated. Parsing stops if end-of-file occurs or a newline wide character is found, in which case {{tt|str}} will contain that wide newline character.

===Parameters===
{{par begin}}
{{par | str | wide string to read the characters to}}
{{par | count | the length of {{tt|str}}}}
{{par | stream | file stream to read the data from}}
{{par end}}

===Return value===

{{tt|str}} on success, {{lc|NULL}} on an error

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fwscanf}}
{{dsc inc | c/io/dsc fgetwc}}
{{dsc inc | c/io/dsc fputws}}
{{dsc see cpp | cpp/io/c/fgetws}}
{{dsc end}}

[[de:c/io/fgetws]]
[[es:c/io/fgetws]]
[[fr:c/io/fgetws]]
[[it:c/io/fgetws]]
[[ja:c/io/fgetws]]
[[pt:c/io/fgetws]]
[[ru:c/io/fgetws]]
[[zh:c/io/fgetws]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fopen</title>
    <ns>0</ns>
    <id>6197</id>
    <revision>
      <id>72343</id>
      <parentid>72341</parentid>
      <timestamp>2014-08-13T14:24:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note on file naming</comment>
      <text xml:space="preserve" bytes="2136">{{c/title | fopen}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
FILE *fopen( const char          *filename, const char          *mode );
}}
{{dcl | since=c99 |
FILE *fopen( const char *restrict filename, const char *restrict mode );
}}
{{dcl rev end}}
{{dcl end}}

Opens a file indicated by {{tt|filename}} and returns a file stream associated with that file. {{tt|mode}} is used to determine the file access mode. 

===Parameters===
{{par begin}}
{{par | filename | file name to associate the file stream to}}
{{par | mode | null-terminated character string determining file access mode

{{c/io/file access flags}}}}
{{par end}}

===Return value===
If successful, returns a pointer to the object that controls the opened file stream, with both eof and error bits cleared. The stream is fully buffered unless {{tt|filename}} refers to an interactive device.

On error, returns a {{lc|null pointer}}. [http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html POSIX requires] that {{lc|errno}} is set in this case.

===Notes===
The format of {{tt|filename}} is implementation-defined, and does not necessarily refer to a file (e.g. it may be the console or another device accessible though filesystem API). On platforms that support them, {{tt|filename}} may include absolute or relative filesystem path.

===Example===
{{example | fopen with error checking. Code opens a file for writing data.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE *fp = fopen(&quot;data.txt&quot;,&quot;w&quot;);
    if (fp == NULL)
    {
       perror(&quot;fopen()&quot;);
       fprintf(stderr,&quot;fopen() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       return EXIT_FAILURE;
    }
 
    /* Normal processing continues here. */

    fclose(fp);
    return EXIT_SUCCESS;
}
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fclose}}
{{dsc inc | c/io/dsc fflush}}
{{dsc inc | c/io/dsc freopen}}
{{dsc see cpp | cpp/io/c/fopen}}
{{dsc end}}

[[de:c/io/fopen]]
[[es:c/io/fopen]]
[[fr:c/io/fopen]]
[[it:c/io/fopen]]
[[ja:c/io/fopen]]
[[pt:c/io/fopen]]
[[ru:c/io/fopen]]
[[zh:c/io/fopen]]</text>
      <sha1>648tl8bcsmw4e37kwgnfgbzzstle2ih</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fprintf</title>
    <ns>0</ns>
    <id>6224</id>
    <revision>
      <id>72209</id>
      <parentid>71204</parentid>
      <timestamp>2014-07-23T22:59:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention that POSIX specifies errno</comment>
      <text xml:space="preserve" bytes="3837">{{c/title | printf | fprintf | sprintf | snprintf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin | num=1}}
{{dcl | until=c99 |
​int printf( const char          *format, ... );​
}}
{{dcl | since=c99 |
​int printf( const char *restrict format, ... );​
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c99 |
int fprintf( FILE          *stream, const char          *format, ... );
}}
{{dcl | since=c99 |
int fprintf( FILE *restrict stream, const char *restrict format, ... );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | until=c99 |
int sprintf( char          *buffer, const char          *format, ... );
}}
{{dcl | since=c99 |
int sprintf( char *restrict buffer, const char *restrict format, ... );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c99 |
int snprintf( char *restrict buffer, int buf_size, 
              const char *restrict format, ... );
}}
{{dcl end}}

Loads the data from the given locations, converts them to character string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a character string {{tt|buffer}}.
@4@ Writes the results to a character string {{tt|buffer}}. At most {{tt|buf_size}} - 1 characters are written. The resulting character string will be terminated with a null character, unless {{tt|buf_size}} is zero. 

===Parameters===
{{par begin}}
{{par | stream | output file stream to write to}}
{{par | buffer | pointer to a character string to write to}}
{{par | buf_size | up to buf_size - 1 characters may be written, plus the null terminator}}
{{par | format | pointer to a null-terminated multibyte string specifying how to interpret the data.
{{cpp/io/c/printf format}}
}}
{{par | ... | arguments specifying data to print }}
{{par end}}

===Return value===
@1-3@ number of characters written if successful or negative value if an error occurred.

@4@ number of characters written if successful or negative value if an error occurred. If the resulting string gets truncated due to {{tt|buf_size}} limit, function returns the total number of characters (not including the terminating null-byte) which would have been written, if the limit was not imposed. 

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html POSIX specifies] that {{lc|errno}} is set on error.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;

int main(void)
{
    printf(&quot;Strings:\n&quot;);
    const char* s = &quot;Hello&quot;;
    printf(&quot;\t.%10s.\n\t.%-10s.\n\t.%*s.\n&quot;, s, s, 10, s);

    printf(&quot;Characters:\t%c %%\n&quot;, 65);

    printf(&quot;Integers\n&quot;);
    printf(&quot;Decimal:\t%i %d %.6i %i %.0i %+i %u\n&quot;, 1, 2, 3, 0, 0, 4, -1);
    printf(&quot;Hexadecimal:\t%x %x %X %#x\n&quot;, 5, 10, 10, 6);
    printf(&quot;Octal:\t%o %#o %#o\n&quot;, 10, 10, 4);

    printf(&quot;Floating point\n&quot;);
    printf(&quot;Rounding:\t%f %.0f %.32f\n&quot;, 1.5, 1.5, 1.3);
    printf(&quot;Padding:\t%05.2f %.2f %5.2f\n&quot;, 1.5, 1.5, 1.5);
    printf(&quot;Scientific:\t%E %e\n&quot;, 1.5, 1.5);
    printf(&quot;Hexadecimal:\t%a %A\n&quot;, 1.5, 1.5);
}
 | output=
Strings:
    .     Hello.
    .Hello     .
    .     Hello.
Characters:     A %
Integers
Decimal:        1 2 000003 0  +4 4294967295
Hexadecimal:    5 a A 0x6
Octal:          12 012 04
Floating point
Rounding:       1.500000 2 1.30000000000000004440892098500626
Padding:        01.50 1.50  1.50
Scientific:     1.500000E+00 1.500000e+00
Hexadecimal:    0x1.8p+0 0X1.8P+0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc vfprintf}}
{{dsc inc | c/io/dsc fputs}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc see cpp | cpp/io/c/fprintf | printf | fprintf | sprintf | snprintf}}
{{dsc end}}

[[de:c/io/fprintf]]
[[es:c/io/fprintf]]
[[fr:c/io/fprintf]]
[[it:c/io/fprintf]]
[[ja:c/io/fprintf]]
[[pt:c/io/fprintf]]
[[ru:c/io/fprintf]]
[[zh:c/io/fprintf]]</text>
      <sha1>nezx9zkhzbmuqimqomi6q3c0a6y6uy9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fputc</title>
    <ns>0</ns>
    <id>6208</id>
    <revision>
      <id>69907</id>
      <parentid>69829</parentid>
      <timestamp>2014-05-01T13:19:34Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1653">{{c/title | fputc | putc}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl |
int fputc( int ch, FILE *stream );
}}
{{dcl |
int putc( int ch, FILE *stream );
}}
{{dcl rev end}}
{{dcl end}}

Writes a character {{tt|ch}} to the given output stream {{tt|stream}}. {{c|putc()}} may be implemented as a macro and evaluation {{tt|stream}} more than once, so the corresponding argument should never be an expression with side effects. 

Internally, the character is converted to {{c|unsigned char}} just before being written.

===Parameters===
{{par begin}}
{{par | ch | character to be written}}
{{par end}}

===Return value===
On success, returns the written character.

On failure, returns {{lc|EOF}} and sets the ''error'' indicator (see {{lc|ferror()}}) on {{tt|stream}}.

===Example===
{{example | putc with error checking
|code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    int ret_code = 0;
    for (char c = 'a'; (ret_code != EOF) &amp;&amp; (c != 'z'); c++)
        ret_code = putc(c, stdout);
 
    /* Test whether EOF was reached. */
    if (ret_code == EOF)
       if (ferror(stdout)) 
       {
          perror(&quot;putc()&quot;);
          fprintf(stderr,&quot;putc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-7);
          exit(EXIT_FAILURE);
       }
    putc('\n', stdout);
 
    return EXIT_SUCCESS;
}
|output=
abcdefghijklmnopqrstuvwxy
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc putchar}}
{{dsc see cpp | cpp/io/c/fputc | fputc | putc}}
{{dsc end}}

[[de:c/io/fputc]]
[[es:c/io/fputc]]
[[fr:c/io/fputc]]
[[it:c/io/fputc]]
[[ja:c/io/fputc]]
[[pt:c/io/fputc]]
[[ru:c/io/fputc]]
[[zh:c/io/fputc]]</text>
      <sha1>s9au73ap2o62h1gob2pa16x9zryn0bj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fputs</title>
    <ns>0</ns>
    <id>6209</id>
    <revision>
      <id>69908</id>
      <parentid>69812</parentid>
      <timestamp>2014-05-01T13:27:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1355">{{c/title | fputs}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
int fputs( const char          *str, FILE          *stream );
}}
{{dcl | since=c99 |
int fputs( const char *restrict str, FILE *restrict stream );
}}
{{dcl rev end}}
{{dcl end}}

Writes given null-terminated character string to the given output stream. 

===Parameters===
{{par begin}}
{{par | str | null-terminated character string to be written}}
{{par | stream | output stream}}
{{par end}}

===Return value===
Non-negative integer on success, {{lc|EOF}} on failure.

===Example===
{{example | fputs() with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    int ret_code = fputs(&quot;Hello World&quot;,stdout);
    if ((ret_code == EOF) &amp;&amp; (ferror(stdout)))   /* test whether EOF was reached */
    {
       perror(&quot;fputs()&quot;);
       fprintf(stderr,&quot;fputs() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
    
    return EXIT_SUCCESS;
}
 | output=
Hello World
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc inc | c/io/dsc puts}}
{{dsc inc | c/io/dsc fgets}}
{{dsc see cpp | cpp/io/c/fputs}}
{{dsc end}}

[[de:c/io/fputs]]
[[es:c/io/fputs]]
[[fr:c/io/fputs]]
[[it:c/io/fputs]]
[[ja:c/io/fputs]]
[[pt:c/io/fputs]]
[[ru:c/io/fputs]]
[[zh:c/io/fputs]]</text>
      <sha1>sbc0x4am47citdq6sm6usjglvjbk3wr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fputwc</title>
    <ns>0</ns>
    <id>6217</id>
    <revision>
      <id>66059</id>
      <parentid>56439</parentid>
      <timestamp>2013-10-24T00:00:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1016">{{c/title | fputwc }}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl rev begin}}
{{dcl |
wint_t fputwc( wchar_t ch, FILE *stream );
}}
{{dcl |
wint_t putwc( wchar_t ch, FILE *stream );
}}
{{dcl rev end}}
{{dcl end}}

Writes a wide character {{tt|ch}} to the given output stream {{tt|stream}}. {{c|putwc()}} may be implemented as a macro and may evaluate {{tt|stream}} more than once.

===Parameters===
{{par begin}}
{{par | ch | wide character to be written}}
{{par | stream | the output stream}}
{{par end}}

===Return value===
{{tt|ch}} on success, {{c|WEOF}} on failure. If an encoding error occurs, {{lc|errno}} is set to {{tt|EILSEQ}}.

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fputc}}
{{dsc inc | c/io/dsc fputws}}
{{dsc inc | c/io/dsc fgetwc}}
{{dsc see cpp | cpp/io/c/fputwc}}
{{dsc end}}

[[de:c/io/fputwc]]
[[es:c/io/fputwc]]
[[fr:c/io/fputwc]]
[[it:c/io/fputwc]]
[[ja:c/io/fputwc]]
[[pt:c/io/fputwc]]
[[ru:c/io/fputwc]]
[[zh:c/io/fputwc]]</text>
      <sha1>mwga0m7yst367wnhcq8vfhzbuipnsi3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fputws</title>
    <ns>0</ns>
    <id>6218</id>
    <revision>
      <id>56440</id>
      <parentid>48870</parentid>
      <timestamp>2013-06-01T05:36:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="745">{{c/title | fputws}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
int fputws( const wchar_t *str, FILE *stream );
}}

Writes given null-terminated wide string to the given output stream. 

===Parameters===
{{par begin}}
{{par | str | null-terminated wide string to be written}}
{{par | stream | output stream}}
{{par end}}

===Return value===

non-negative integer on success, {{c|WEOF}} on failure

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fputs}}
{{dsc inc | c/io/dsc fwprintf}}
{{dsc inc | c/io/dsc fputws}}
{{dsc inc | c/io/dsc fgetws}}
{{dsc see cpp | cpp/io/c/fputws}}
{{dsc end}}

[[de:c/io/fputws]]
[[es:c/io/fputws]]
[[fr:c/io/fputws]]
[[it:c/io/fputws]]
[[ja:c/io/fputws]]
[[pt:c/io/fputws]]
[[ru:c/io/fputws]]
[[zh:c/io/fputws]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fread</title>
    <ns>0</ns>
    <id>6204</id>
    <revision>
      <id>69900</id>
      <parentid>69844</parentid>
      <timestamp>2014-05-01T12:32:49Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.  &quot;&lt;&quot; from 7.21.8.1.</comment>
      <text xml:space="preserve" bytes="2056">{{c/title | fread}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
size_t fread( void          *buffer, size_t size, size_t count,
              FILE          *stream );
}}
{{dcl | since=c99 |
size_t fread( void *restrict buffer, size_t size, size_t count, 
              FILE *restrict stream );
}}
{{dcl rev end}}
{{dcl end}}

Reads specified number of objects in the array {{tt|buffer}} from the given input stream {{tt|stream}}. Objects are not interpreted in any way. 

===Parameters===
{{par begin}}
{{par | buffer | pointer to the array where the read objects are stored}}
{{par | size | size of each object in bytes}}
{{par | count | the number of the objects to be read}}
{{par | stream | the stream to read}}
{{par end}}

===Return value===
The number of objects read successfully.

===Example===
{{example| fread with error checking
| code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    /* Prepare an array of f-p values. */
    #define SIZE 5
    double A[SIZE] = {1.,2.,3.,4.,5.};
    /* Write array to a file. */
    FILE * fp = fopen(&quot;test.bin&quot;, &quot;wb&quot;);
    fwrite(A,sizeof(double),SIZE,fp);
    fclose (fp);

    /* Read the f-p values into array B. */
    double B[SIZE];
    fp = fopen(&quot;test.bin&quot;,&quot;rb&quot;);
    int ret_code = fread(B,sizeof(double),SIZE,fp);
    if (ret_code &lt; SIZE)
    {
       if (feof(fp))
          printf(&quot;EOF reached\n&quot;);
       else if (ferror(fp))
            {
              perror(&quot;fread()&quot;);
              fprintf(stderr,&quot;fread() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-8);
              exit(EXIT_FAILURE);
            }
    }
    printf(&quot;%.1f\n&quot;, B[4]);   /* print one f-p value */

    return EXIT_SUCCESS; 
}

| output=
5.0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc inc | c/io/dsc fgets}}
{{dsc inc | c/io/dsc fwrite}}
{{dsc see cpp | cpp/io/c/fread}}
{{dsc end}}

[[de:c/io/fread]]
[[es:c/io/fread]]
[[fr:c/io/fread]]
[[it:c/io/fread]]
[[ja:c/io/fread]]
[[pt:c/io/fread]]
[[ru:c/io/fread]]
[[zh:c/io/fread]]</text>
      <sha1>c4tx6o2wa72ye8s6vd8fjdb9zt37pld</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/freopen</title>
    <ns>0</ns>
    <id>6198</id>
    <revision>
      <id>69897</id>
      <parentid>69869</parentid>
      <timestamp>2014-05-01T11:51:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1769">{{c/title | freopen}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
FILE *freopen( const char          *filename, const char          *mode, 
               FILE          *stream );
}}
{{dcl | since=c99 |
FILE *freopen( const char *restrict filename, const char *restrict mode, 
               FILE *restrict stream );
}}
{{dcl rev end}}
{{dcl end}}

Reassigns an existing file stream {{tt|stream}} to a different file identified by {{tt|filename}} using specified mode. {{tt|mode}} is used to determine the new file access mode. 

===Parameters===
{{par begin}}
{{par | filename | file name to associate the file stream to}}
{{par | mode | null-terminated character string determining new file access mode

{{c/io/file access flags}}}}
{{par | stream | the file stream to modify}}
{{par end}}

===Return value===
{{tt|stream}} on success, {{lc|NULL}} on failure

===Example===
{{example | freopen with error checking. The following code redirects {{tt|stdout}} to a file
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    printf(&quot;stdout is printed to console&quot;);
    if (freopen(&quot;redir.txt&quot;, &quot;w&quot;, stdout) == NULL)
    {
       perror(&quot;freopen()&quot;);
       fprintf(stderr,&quot;freopen() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }
    printf(&quot;stdout is redirected to a file&quot;);
    fclose(stdout);
    return EXIT_SUCCESS;
}
 | output=
stdout is printed to console
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fopen}}
{{dsc inc | c/io/dsc fclose}}
{{dsc see cpp | cpp/io/c/freopen}}
{{dsc end}}

[[de:c/io/freopen]]
[[es:c/io/freopen]]
[[fr:c/io/freopen]]
[[it:c/io/freopen]]
[[ja:c/io/freopen]]
[[pt:c/io/freopen]]
[[ru:c/io/freopen]]
[[zh:c/io/freopen]]</text>
      <sha1>0ni0or9j8o89pdrs03b7b1z2sn4yqrj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fscanf</title>
    <ns>0</ns>
    <id>6222</id>
    <revision>
      <id>66053</id>
      <parentid>62504</parentid>
      <timestamp>2013-10-23T23:55:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="4038">{{c/title | scanf | fscanf | sscanf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin | num=1}}
{{dcl | until=c99 |
​int scanf( const char          *format, ... );​
}}
{{dcl | since=c99 |
​int scanf( const char *restrict format, ... );​
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c99 |
int fscanf( FILE          *stream, const char          *format, ... );
}}
{{dcl | since=c99 |
int fscanf( FILE *restrict stream, const char *restrict format, ... );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | until=c99 |
int sscanf( const char          *buffer, const char          *format, ... );
}}
{{dcl | since=c99 |
int sscanf( const char *restrict buffer, const char *restrict format, ... );
}}
{{dcl rev end}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into given locations.

@1@ reads the data from {{lc|stdin}}
@2@ reads the data from file stream {{tt|stream}}
@3@ reads the data from null-terminated character string {{tt|buffer}}

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated character string to read from}}
{{par | format | pointer to a null-terminated character string specifying how to read the input.
{{cpp/io/c/scanf format}}
}}
{{par | ... | receiving arguments}}
{{par end}}

===Return value===
Number of receiving arguments successfully assigned, or {{lc|EOF}} if read failure occurs before the first receiving argument was assigned.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    // prepare a file, filled with numbers, squares, and factorials
    FILE *fp = fopen(&quot;results.dat&quot;, &quot;w&quot;);
    if (fp == NULL) {
        perror(&quot;couldn't open results.dat for writing: &quot;);
        return EXIT_FAILURE;
    }
    int product = 1;
    for (int i=1; i&lt;=10; ++i) {
        fprintf(fp, &quot;i=%d, i^2=%d, factorial(%d)=%d\n&quot;, i, i*i, i, product*=i);
    }
    fclose(fp);

    // now parse the file with fscanf()
    fp = fopen(&quot;results.dat&quot;, &quot;r&quot;);
    if (fp == NULL) {
        perror(&quot;couldn't open results.dat for reading: &quot;);
        return EXIT_FAILURE;
    }

    int n, sq, fact;
    while (fscanf(fp, &quot;i=%d, i^2=%d, factorial(%*d)=%d &quot;, &amp;n, &amp;sq, &amp;fact) == 3) {
        printf(&quot;factorial(%d) = %d\n&quot;, n, fact);
    }
    fclose(fp);

    // sample string to parse with sscanf()
    char input[] = &quot;25 54.32E-1 Thompson 56789 0123 56ß水&quot;;
    /* parse as follows:
       an integer, a floating-point value, a word,
       two-digit integer (digits 5 and 6)
       a floating-point value (digits 7, 8, 9)
       an integer which isn't stored anywhere
       a string of integers (digits 5 and 6)
       two wide characters, using multibyte to wide conversion */

    int i, j;
    float x, y;
    char str1[10], str2[4];
    wchar_t warr[2];
    setlocale(LC_ALL, &quot;en_US.utf8&quot;);

    int ret = sscanf(input, &quot;%d%f%9s%2d%f%*d %3[0-9]%2lc&quot;,
                     &amp;i, &amp;x, str1, &amp;j, &amp;y, str2, warr);

    printf(&quot;Converted %d fields:\ni = %d\nx = %f\nstr1 = %s\n&quot;
                      &quot;j = %d\ny = %f\nstr2 = %s\n&quot;
                      &quot;warr[0] = U+%x warr[1] = U+%x\n&quot;,
                      ret, i, x, str1, j, y, str2, warr[0], warr[1]);
    return EXIT_SUCCESS;
}
 | output=
factorial(1) = 1
factorial(2) = 2
factorial(3) = 6
factorial(4) = 24
factorial(5) = 120
factorial(6) = 720
factorial(7) = 5040
factorial(8) = 40320
factorial(9) = 362880
factorial(10) = 3628800
Converted 7 fields:
i = 25
x = 5.432000
str1 = Thompson
j = 56
y = 789.000000
str2 = 56
warr[0] = U+df warr[1] = U+6c34
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc vfscanf}}
{{dsc inc | c/io/dsc fgets}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc see cpp | cpp/io/c/fscanf | scanf | fscanf | sscanf}}
{{dsc end}}

[[de:c/io/fscanf]]
[[es:c/io/fscanf]]
[[fr:c/io/fscanf]]
[[it:c/io/fscanf]]
[[ja:c/io/fscanf]]
[[pt:c/io/fscanf]]
[[ru:c/io/fscanf]]
[[zh:c/io/fscanf]]</text>
      <sha1>oq6sodc1b4bl7j2cktvib6lcuupzqhg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fseek</title>
    <ns>0</ns>
    <id>6232</id>
    <revision>
      <id>69914</id>
      <parentid>69864</parentid>
      <timestamp>2014-05-01T14:17:53Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.  ferror inserted, from 7.21.9.2(2)</comment>
      <text xml:space="preserve" bytes="2398">{{c/title | fseek }}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int fseek( FILE *stream, long offset, int origin );
}}

Sets the file position indicator for the file stream {{tt|stream}} to the value pointed to by {{tt|offset}}. This function can be used to set the indicator beyond the actual end of the file, however, negative position values are not accepted. 

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par | offset | number of characters to shift the position relative to origin}} 
{{par | origin | position to which {{tt|offset}} is added. It can have one of the following values: {{lc|SEEK_SET}}, {{lc|SEEK_CUR}}, {{lc|SEEK_END}}}} 
{{par end}}

===Return value===

{{c|0}} upon success, nonzero value otherwise. Associated {{lc|EOF}} flag is cleared for the stream and the effect of any {{lc|ungetc}} is undone. 

===Notes===
For text streams, the only valid values of {{tt|offset}} are {{c|0}} (applicable to any {{tt|origin}}) and a value returned by an earlier call to {{lc|ftell}} (only applicable to {{tt|SEEK_SET}}).

===Example===
{{example | fseek with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    /* Prepare an array of f-p values. */
    #define SIZE 5
    double A[SIZE] = {1.,2.,3.,4.,5.};
    /* Write array to a file. */
    FILE * fp = fopen(&quot;test.bin&quot;, &quot;wb&quot;);
    fwrite(A,sizeof(double),SIZE,fp);
    fclose (fp);
 
    /* Read the f-p values into array B. */
    double B[SIZE];
    fp = fopen(&quot;test.bin&quot;,&quot;rb&quot;);
    
    /* Set the file position indicator in front of third f-p value. */
    if (fseek(fp,sizeof(double)*2L,SEEK_SET) != 0)
    {
       if (ferror(fp))
       {
          perror(&quot;fseek()&quot;);
          fprintf(stderr,&quot;fseek() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-5);
          exit(EXIT_FAILURE);
       }
    }

    int ret_code = fread(B,sizeof(double),1,fp);   /* read one f-p value  */
    printf(&quot;%.1f\n&quot;, B[0]);                        /* print one f-p value */
 
    fclose(fp);
    return EXIT_SUCCESS;
}
 | output=
3.0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fsetpos}}
{{dsc inc | c/io/dsc fgetpos}}
{{dsc inc | c/io/dsc ftell}}
{{dsc inc | c/io/dsc rewind}}
{{dsc see cpp | cpp/io/c/fseek}}
{{dsc end}}

[[de:c/io/fseek]]
[[es:c/io/fseek]]
[[fr:c/io/fseek]]
[[it:c/io/fseek]]
[[ja:c/io/fseek]]
[[pt:c/io/fseek]]
[[ru:c/io/fseek]]
[[zh:c/io/fseek]]</text>
      <sha1>rvgi2dfk3gg4p78gik1wbgvjr85tfht</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fsetpos</title>
    <ns>0</ns>
    <id>6233</id>
    <revision>
      <id>69923</id>
      <parentid>69922</parentid>
      <timestamp>2014-05-01T15:21:53Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="2197">{{c/title | fsetpos}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int fsetpos( FILE *stream, const fpos_t *pos );
}}

Sets the file position indicator for the file stream {{tt|stream}} to the value pointed to by {{tt|pos}}. 

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par | pos | pointer to a {{lc|fpos_t}} object to use as new value of file position indicator}}
{{par end}}

===Return value===

{{c|0}} upon success, nonzero value otherwise.

===Example===
{{example | fsetpos with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    /* Prepare an array of f-p values. */
    #define SIZE 5
    double A[SIZE] = {1.,2.,3.,4.,5.};
    /* Write array to a file. */
    FILE * fp = fopen(&quot;test.bin&quot;, &quot;wb&quot;);
    fwrite(A,sizeof(double),SIZE,fp);
    fclose (fp);
 
    /* Read the f-p values into array B. */
    double B[SIZE];
    fp = fopen(&quot;test.bin&quot;,&quot;rb&quot;);
    fpos_t pos;
    if (fgetpos(fp,&amp;pos) != 0)      /* current position: start of file */
    {
       perror(&quot;fgetpos()&quot;);
       fprintf(stderr,&quot;fgetpos() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }

    int ret_code = fread(B,sizeof(double),1,fp);   /* read one f-p value */
    /* current position: after reading one f-p value */
    printf(&quot;%.1f\n&quot;, B[0]);   /* print one f-p value */
    
    if (fsetpos(fp,&amp;pos) != 0)   /* reset current position to start of file */
    {
       if (ferror(fp))
       {
          perror(&quot;fsetpos()&quot;);
          fprintf(stderr,&quot;fsetpos() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-5);
          exit(EXIT_FAILURE);
       }
    }

    ret_code = fread(B,sizeof(double),1,fp);   /* reread first f-p value */
    printf(&quot;%.1f\n&quot;, B[0]);                    /* print one f-p value    */
    fclose(fp);
 
    return EXIT_SUCCESS; 
}
 | output=
1.0
1.0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fgetpos}}
{{dsc inc | c/io/dsc ftell}}
{{dsc inc | c/io/dsc fseek}}
{{dsc see cpp | cpp/io/c/fsetpos}}
{{dsc end}}

[[de:c/io/fsetpos]]
[[es:c/io/fsetpos]]
[[fr:c/io/fsetpos]]
[[it:c/io/fsetpos]]
[[ja:c/io/fsetpos]]
[[pt:c/io/fsetpos]]
[[ru:c/io/fsetpos]]
[[zh:c/io/fsetpos]]</text>
      <sha1>axzd9j1rjcyhyp9oiw0lw46331t1y1f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/ftell</title>
    <ns>0</ns>
    <id>6230</id>
    <revision>
      <id>69912</id>
      <parentid>69849</parentid>
      <timestamp>2014-05-01T13:54:35Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.  &quot;-1L&quot; from 7.21.9.4.</comment>
      <text xml:space="preserve" bytes="2189">{{c/title | ftell}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
long ftell( FILE *stream );
}}

Returns the file position indicator for the file stream {{tt|stream}}. 

If the stream is open in binary mode, the value obtained by this function is the number of bytes from the beginning of the file.

If the stream is open in text mode, the value returned by this function is unspecified and is only meaningful as the input to {{lc|fseek()}}.

===Parameters===
{{par begin}}
{{par | stream | file stream to examine}}
{{par end}}

===Return value===
File position indicator on success or {{lc|EOF}} if failure occurs.

On error, the {{c|errno}} variable is set to implementation-defined positive value.

===Example===
{{example | ftell with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    /* Prepare an array of f-p values. */
    #define SIZE 5
    double A[SIZE] = {1.,2.,3.,4.,5.};
    /* Write array to a file. */
    FILE * fp = fopen(&quot;test.bin&quot;, &quot;wb&quot;);
    fwrite(A,sizeof(double),SIZE,fp);
    fclose (fp);
 
    /* Read the f-p values into array B. */
    double B[SIZE];
    fp = fopen(&quot;test.bin&quot;,&quot;rb&quot;);
    long int pos = ftell(fp);   /* position indicator at start of file */
    if (pos == -1L)
    {
       perror(&quot;ftell()&quot;);
       fprintf(stderr,&quot;ftell() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
    printf(&quot;%ld\n&quot;, pos);

    int ret_code = fread(B,sizeof(double),1,fp);   /* read one f-p value */
    pos = ftell(fp);   /* position indicator after reading one f-p value */
    if (pos == -1L)
    {
       perror(&quot;ftell()&quot;);
       fprintf(stderr,&quot;ftell() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
    printf(&quot;%ld\n&quot;, pos);
    printf(&quot;%.1f\n&quot;, B[0]);   /* print one f-p value */
 
    return EXIT_SUCCESS; 
}
 | output=
0
8
1.0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fgetpos}}
{{dsc inc | c/io/dsc fseek}}
{{dsc inc | c/io/dsc fsetpos}}
{{dsc see cpp | cpp/io/c/ftell}}
{{dsc end}}

[[de:c/io/ftell]]
[[es:c/io/ftell]]
[[fr:c/io/ftell]]
[[it:c/io/ftell]]
[[ja:c/io/ftell]]
[[pt:c/io/ftell]]
[[ru:c/io/ftell]]
[[zh:c/io/ftell]]</text>
      <sha1>rxffaazona2x9srjp0rjfkehfy5wlo1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fwide</title>
    <ns>0</ns>
    <id>6201</id>
    <revision>
      <id>56453</id>
      <parentid>48907</parentid>
      <timestamp>2013-06-01T05:36:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1006">{{c/title | fwide}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
int fwide( FILE *stream, int mode );
}}

If {{tt|mode &gt; 0}}, attempts to make {{tt|stream}} wide-oriented. If {{tt|mode &lt; 0}}, attempts to make {{tt|stream}} byte-oriented. If {{c|1=mode==0}}, only queries the current orientation of the stream.

===Parameters===
{{par begin}}
{{par | stream | pointer to the C I/O stream to modify or query}}
{{par | mode | integer value greater than zero to set the stream wide, less than zero to set the stream narrow, or zero to query only }}
{{par end}}

===Return value===

An integer greater than zero if the stream is wide-oriented after this call, less than zero if the stream is byte-oriented after this call, and zero if the stream has no orientation.

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fopen}}
{{dsc see cpp | cpp/io/c/fwide}}
{{dsc end}}

[[de:c/io/fwide]]
[[es:c/io/fwide]]
[[fr:c/io/fwide]]
[[it:c/io/fwide]]
[[ja:c/io/fwide]]
[[pt:c/io/fwide]]
[[ru:c/io/fwide]]
[[zh:c/io/fwide]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fwprintf</title>
    <ns>0</ns>
    <id>6228</id>
    <revision>
      <id>72319</id>
      <parentid>66976</parentid>
      <timestamp>2014-08-08T02:51:26Z</timestamp>
      <contributor>
        <ip>77.200.200.247</ip>
      </contributor>
      <text xml:space="preserve" bytes="1150">{{c/title | wprintf | fwprintf | swprintf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | num=1 |
int wprintf( const wchar_t* format, ... );
}}
{{dcl | num=2 |
int fwprintf( FILE *stream, const wchar_t* format, ... );
}}
{{dcl | num=3 |
int swprintf( wchar_t *buffer, size_t maxlen, const wchar_t* format, ... );
}}
{{dcl end}}

Loads the data from the given locations, converts them to wide string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a wide string {{tt|buffer}}.

===Parameters===
{{todo}}

===Return value===
Number of wide characters written if successful or negative value if an error occurred.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc vfwprintf}}
{{dsc inc | c/io/dsc fputws}}
{{dsc see cpp | cpp/io/c/fwprintf | wprintf | fwprintf | swprintf}}
{{dsc end}}

[[de:c/io/fwprintf]]
[[es:c/io/fwprintf]]
[[fr:c/io/fwprintf]]
[[it:c/io/fwprintf]]
[[ja:c/io/fwprintf]]
[[pt:c/io/fwprintf]]
[[ru:c/io/fwprintf]]
[[zh:c/io/fwprintf]]</text>
      <sha1>7o83f0mjsy0jyfvntkf9u5ag08ucevf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fwrite</title>
    <ns>0</ns>
    <id>6205</id>
    <revision>
      <id>72115</id>
      <parentid>71202</parentid>
      <timestamp>2014-07-16T17:53:55Z</timestamp>
      <contributor>
        <username>Lishyguy</username>
        <id>3240</id>
      </contributor>
      <comment>Added &quot;stream&quot; to the parameter list</comment>
      <text xml:space="preserve" bytes="2053">{{c/title | fwrite}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
size_t fwrite( const void *buffer, size_t size, size_t count,
               FILE *stream );
}}
{{dcl | since=c99 |
size_t fwrite( const void *restrict buffer, size_t size, size_t count, 
               FILE *restrict stream );
}}
{{dcl rev end}}
{{dcl end}}

Writes {{tt|count}} of objects in the given array {{tt|buffer}} to the output stream {{tt|stream}}. Objects are not interpreted in any way. 

===Parameters===
{{par begin}}
{{par | buffer | pointer to the first object object in the array to be written}}
{{par | size | size of each object}}
{{par | count | the number of the objects to be written}}
{{par | stream | pointer to the output stream}}
{{par end}}

===Return value===
The number of objects written successfully.

===Example===
{{example| fwrite with error checking
| code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    // write buffer to file
    FILE *f1;
    char buffer[] = { 'x' , 'y' , 'z' };
    f1 = fopen(&quot;file.bin&quot;, &quot;wb&quot;);
    int ret_code = fwrite(buffer, sizeof(char), sizeof(buffer), f1);
    if (ret_code &lt; (int)sizeof(buffer))
       if (ferror(f1))
       {
          perror(&quot;fwrite()&quot;);
          fprintf(stderr,&quot;fwrite() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-5);
          exit(EXIT_FAILURE);
       }
    fclose(f1);

    // read the same data and print it to the standard output
    FILE *f2;
    char rbuf[10];
    f2 = fopen(&quot;file.bin&quot;, &quot;rb&quot;);
    const char* res = fgets(rbuf, sizeof(rbuf), f2);
    fclose(f2);

    if (res) { // points to rbuf on read success, NULL on failure
        puts(res);
    }

    return EXIT_SUCCESS;
}
| output=
xyz
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc inc | c/io/dsc fputs}}
{{dsc inc | c/io/dsc fread}}
{{dsc see cpp | cpp/io/c/fwrite}}
{{dsc end}}

[[de:c/io/fwrite]]
[[es:c/io/fwrite]]
[[fr:c/io/fwrite]]
[[it:c/io/fwrite]]
[[ja:c/io/fwrite]]
[[pt:c/io/fwrite]]
[[ru:c/io/fwrite]]
[[zh:c/io/fwrite]]</text>
      <sha1>0c9vt6s2b55fkqm5in5v88j0ptx0xgm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/fwscanf</title>
    <ns>0</ns>
    <id>6226</id>
    <revision>
      <id>62506</id>
      <parentid>56458</parentid>
      <timestamp>2013-07-01T23:22:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1446">{{c/title | wscanf | fwscanf | swscanf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | num=1 | since=c99 |
int wscanf( const wchar_t* format, ... );
}}
{{dcl | num=2 | since=c99 |
int fwscanf( FILE *stream, const wchar_t* format, ... );
}}
{{dcl | num=3 | since=c99 |
int swscanf( const wchar_t* buffer, const wchar_t* format, ... );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into given locations.

@1@ Reads the data from {{lc|stdin}}.
@2@ Reads the data from file stream {{tt|stream}}.
@3@ Reads the data from null-terminated wide string {{tt|buffer}}.

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated wide string to read from}}
{{par | format | pointer to a null-terminated wide string specifying how to read the input. {{todo}}
}}
{{par | ... | receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs before the first receiving argument was assigned.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc vfwscanf}}
{{dsc see cpp | cpp/io/c/fwscanf | wscanf | fwscanf | swscanf}}
{{dsc end}}

[[de:c/io/fwscanf]]
[[es:c/io/fwscanf]]
[[fr:c/io/fwscanf]]
[[it:c/io/fwscanf]]
[[ja:c/io/fwscanf]]
[[pt:c/io/fwscanf]]
[[ru:c/io/fwscanf]]
[[zh:c/io/fwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/getc</title>
    <ns>0</ns>
    <id>6481</id>
    <redirect title="c/io/fgetc" />
    <revision>
      <id>25651</id>
      <timestamp>2012-04-23T20:53:37Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fgetc]]</comment>
      <text xml:space="preserve" bytes="24">#redirect [[c/io/fgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/getchar</title>
    <ns>0</ns>
    <id>6210</id>
    <revision>
      <id>69909</id>
      <parentid>69826</parentid>
      <timestamp>2014-05-01T13:35:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1508">{{c/title| getchar}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int getchar();
}}
Reads the next character from {{lc|stdin}}.

Equivalent to {{c|getc(stdin)}}.

===Parameters===
(none)

===Return value===
The obtained character on success or {{lc|EOF}} on failure. 

If the failure has been caused by end-of-file condition, additionally sets the ''eof'' indicator (see {{lc|feof()}}) on {{lc|stdin}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|ferror()}}) on {{lc|stdin}}.

===Example===
{{example | getchar with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{ 
    int ch;
    while ((ch=getchar()) != EOF)   /* read/print &quot;abcde&quot; from stdin */
          printf(&quot;%c&quot;, ch);
 
    /* Test reason for reaching EOF. */
    if (feof(stdin))          /* if failure caused by end-of-file condition */
       puts(&quot;End of file reached&quot;);
    else if (ferror(stdin))   /* if failure caused by some other error      */
         {
            perror(&quot;getchar()&quot;);
            fprintf(stderr,&quot;getchar() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-9);
            exit(EXIT_FAILURE);
         }
 
    return EXIT_SUCCESS;
}
 | output=
abcde
End of file reached
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fgetc}}
{{dsc see cpp | cpp/io/c/getchar}}
{{dsc end}}

[[de:c/io/getchar]]
[[es:c/io/getchar]]
[[fr:c/io/getchar]]
[[it:c/io/getchar]]
[[ja:c/io/getchar]]
[[pt:c/io/getchar]]
[[ru:c/io/getchar]]
[[zh:c/io/getchar]]</text>
      <sha1>1wv7tuseiit0nml00rqztxehp4x2u2q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/gets</title>
    <ns>0</ns>
    <id>6211</id>
    <revision>
      <id>66060</id>
      <parentid>65795</parentid>
      <timestamp>2013-10-24T00:01:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2538">{{c/title | gets | gets_s}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h }}
{{dcl rev begin}}
{{dcl | until=c11 |
char *gets( char *str );
}}
{{dcl | since=c11 | notes={{mark optional}} |
char *gets_s( char *str, rsize_t n );
}}
{{dcl rev end}}
{{dcl end}}

@1@ Reads {{lc|stdin}} into the character array pointed to by {{tt|str}} until a newline character is found or end-of-file occurs. A null character is written immediately after the last character read into the array.

@2@ Reads at most {{c|n-1}} characters from {{lc|stdin}} into the array pointed to by {{tt|str}} until new-line character, end-of-file condition, or read error. A null character is written immediately after the last character read into the array, or to {{c|str[0]}} if no characters were read.

@@ If {{tt|n}} is zero or is greater than {{c|RSIZE_MAX}}, a null character is written to {{c|str[0]}} but the function reads and discards characters from {{lc|stdin}} until new-line character, end-of-file condition, or read error.

@@ If {{tt|n-1}} characters have been read, continues reading and discarding the characters from {{lc|stdin}} until new-line character, end-of-file condition, or read error.

@@ The {{tt|gets_s}} function is an extension and is optional. It is guaranteed to be present only if {{c|__STDC_LIB_EXT1__}} is defined.

===Parameters===
{{par begin}}
{{par | str | character string to be written}}
{{par end}}

===Return value===
{{tt|str}} on success, {{lc|NULL}} on failure.

If the failure has been caused by end of file condition, additionally sets the ''eof'' indicator (see {{lc|feof()}}) on {{lc|stdin}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|ferror()}}) on {{lc|stdin}}.

===Notes===
The {{tt|gets()}} function does not perform bounds checking, therefore this function is extremely vulnerable to buffer-overflow attacks. It cannot be used safely (unless the program runs in an environment which restricts what can appear on {{tt|stdin}}). For this reason, the function has been deprecated in the third corrigendum to the C99 standard and removed altogether in the C11 standard. {{lc|fgets()}} and {{tt|gets_s()}} are the recommended replacements.

Never use {{tt|gets()}}.

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc inc | c/io/dsc fgets}}
{{dsc inc | c/io/dsc fputs}}
{{dsc see cpp | cpp/io/c/gets}}
{{dsc end}}

[[de:c/io/gets]]
[[es:c/io/gets]]
[[fr:c/io/gets]]
[[it:c/io/gets]]
[[ja:c/io/gets]]
[[pt:c/io/gets]]
[[ru:c/io/gets]]
[[zh:c/io/gets]]</text>
      <sha1>17vufczgcqg1yxpfh30fqnxn3w9nwqs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/getwc</title>
    <ns>0</ns>
    <id>6482</id>
    <redirect title="c/io/fgetwc" />
    <revision>
      <id>25652</id>
      <timestamp>2012-04-23T20:53:49Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fgetwc]]</comment>
      <text xml:space="preserve" bytes="25">#redirect [[c/io/fgetwc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/getwchar</title>
    <ns>0</ns>
    <id>6219</id>
    <revision>
      <id>56463</id>
      <parentid>48913</parentid>
      <timestamp>2013-06-01T05:36:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="582">{{c/title| getwchar}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
wint_t getwchar();
}}
Reads the next wide character from {{lc|stdin}}.

===Parameters===
(none)

===Return value===

the obtained wide character or {{c|WEOF}} if an error has occurred or the end of file reached

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc getchar}}
{{dsc inc | c/io/dsc fgetwc}}
{{dsc see cpp | cpp/io/c/getwchar}}
{{dsc end}}

[[de:c/io/getwchar]]
[[es:c/io/getwchar]]
[[fr:c/io/getwchar]]
[[it:c/io/getwchar]]
[[ja:c/io/getwchar]]
[[pt:c/io/getwchar]]
[[ru:c/io/getwchar]]
[[zh:c/io/getwchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/perror</title>
    <ns>0</ns>
    <id>6238</id>
    <revision>
      <id>71207</id>
      <parentid>65381</parentid>
      <timestamp>2014-06-08T11:11:46Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1148">{{c/title | perror}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
void perror( const char *s );
}}

Prints to {{lc|stderr}} the contents of the null-terminated character string pointed to by {{tt|s}} (unless {{tt|s}} is a null pointer), followed by the two characters {{c|&quot;: &quot;}}, followed by the implementation-defined error message describing the error code currently stored in the system variable {{lc|errno}} (identical to the output of {{c|strerror(errno)}}), followed by {{c|'\n'}}.

===Parameters===
{{par begin}}
{{par | s | pointer to a null-terminated string with explanatory message}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;

int main(void)
{
    FILE* f = fopen(&quot;non_existent&quot;, &quot;r&quot;);
    if (f == NULL) {
        perror(&quot;open()&quot;);
    } else {
        fclose(f);
    }
}
 | output=
open(): No such file or directory
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strerror}}
{{dsc see cpp | cpp/io/c/perror}}
{{dsc end}}

[[de:c/io/perror]]
[[es:c/io/perror]]
[[fr:c/io/perror]]
[[it:c/io/perror]]
[[ja:c/io/perror]]
[[pt:c/io/perror]]
[[ru:c/io/perror]]
[[zh:c/io/perror]]</text>
      <sha1>5f4s10dbcpo29731a8n88oxsbm7m5dk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/printf</title>
    <ns>0</ns>
    <id>6493</id>
    <redirect title="c/io/fprintf" />
    <revision>
      <id>25664</id>
      <timestamp>2012-04-23T20:55:34Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fprintf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/putc</title>
    <ns>0</ns>
    <id>6483</id>
    <redirect title="c/io/fputc" />
    <revision>
      <id>25653</id>
      <timestamp>2012-04-23T20:54:00Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fputc]]</comment>
      <text xml:space="preserve" bytes="24">#redirect [[c/io/fputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/putchar</title>
    <ns>0</ns>
    <id>6212</id>
    <revision>
      <id>71203</id>
      <parentid>69828</parentid>
      <timestamp>2014-06-08T10:58:42Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1508">{{c/title| putchar}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int putchar( int ch );
}}

Writes a character {{tt|ch}} to {{tt|stdout}}. Internally, the character is converted to {{c|unsigned char}} just before being written.

Equivalent to {{c|putc(ch, stdout)}}.

===Parameters===
{{par begin}}
{{par | ch | character to be written}}
{{par end}}

===Return value===
On success, returns the written character.

On failure, returns {{lc|EOF}} and sets the ''error'' indicator (see {{lc|ferror()}}) on {{lc|stdout}}.

===Example===
{{example | putchar with error checking
|code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    int ret_code = 0;
    for (char c = 'a'; (ret_code != EOF) &amp;&amp; (c != 'z'); c++)
        ret_code = putchar(c);
 
    /* Test whether EOF was reached. */
    if (ret_code == EOF)
       if (ferror(stdout)) 
       {
          fprintf(stderr,&quot;putchar() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-6);
          perror(&quot;putchar()&quot;);
          exit(EXIT_FAILURE);
       }
    putchar('\n');

    // putchar return value is not equal to the argument
    int r = 0x1070;
    printf(&quot;\n0x%x\n&quot;, r);
    r = putchar(r);
    printf(&quot;\n0x%x\n&quot;, r);
}
|output=
abcdefghijklmnopqrstuvwxy

0x1070
p
0x70
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fputc}}
{{dsc see cpp | cpp/io/c/putchar}}
{{dsc end}}

[[de:c/io/putchar]]
[[es:c/io/putchar]]
[[fr:c/io/putchar]]
[[it:c/io/putchar]]
[[ja:c/io/putchar]]
[[pt:c/io/putchar]]
[[ru:c/io/putchar]]
[[zh:c/io/putchar]]</text>
      <sha1>tjjmmlfx9xtenunf1hah18pruhhl57l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/puts</title>
    <ns>0</ns>
    <id>6213</id>
    <revision>
      <id>69910</id>
      <parentid>69813</parentid>
      <timestamp>2014-05-01T13:39:45Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1047">{{c/title| puts}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int puts( const char *str );
}}
Writes character string {{tt|str}} and a newline to {{tt|stdout}}

===Parameters===
{{par begin}}
{{par | str | character string to be written}}
{{par end}}

===Return value===

non-negative number on success or {{lc|EOF}} otherwise

===Example===
{{example | puts() with error checking
| code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    int ret_code = puts(&quot;Hello World&quot;);
    if ((ret_code == EOF) &amp;&amp; (ferror(stdout)))   /* test whether EOF was reached */
    {
       perror(&quot;puts()&quot;);
       fprintf(stderr,&quot;puts() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
    
    return EXIT_SUCCESS;
}
| output=
Hello World
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fputs}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc see cpp | cpp/io/c/puts}}
{{dsc end}}

[[de:c/io/puts]]
[[es:c/io/puts]]
[[fr:c/io/puts]]
[[it:c/io/puts]]
[[ja:c/io/puts]]
[[pt:c/io/puts]]
[[ru:c/io/puts]]
[[zh:c/io/puts]]</text>
      <sha1>86j0gpbx5he9d5zn2w0at0e4eoq2ova</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/putwc</title>
    <ns>0</ns>
    <id>6484</id>
    <redirect title="c/io/fputwc" />
    <revision>
      <id>25654</id>
      <timestamp>2012-04-23T20:54:19Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fputwc]]</comment>
      <text xml:space="preserve" bytes="25">#redirect [[c/io/fputwc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/putwchar</title>
    <ns>0</ns>
    <id>6220</id>
    <revision>
      <id>56469</id>
      <parentid>48917</parentid>
      <timestamp>2013-06-01T05:36:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="610">{{c/title| putwchar}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
wint_t putwchar( wchar_t ch );
}}
Writes a wide character {{tt|ch}} to {{tt|stdout}}

===Parameters===
{{par begin}}
{{par | ch | wide character to be written}}
{{par end}}

===Return value===

{{tt|ch}} on success, {{c|WEOF}} on failure.

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc putchar}}
{{dsc inc | c/io/dsc fputwc}}
{{dsc see cpp | cpp/io/c/putwchar}}
{{dsc end}}

[[de:c/io/putwchar]]
[[es:c/io/putwchar]]
[[fr:c/io/putwchar]]
[[it:c/io/putwchar]]
[[ja:c/io/putwchar]]
[[pt:c/io/putwchar]]
[[ru:c/io/putwchar]]
[[zh:c/io/putwchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/remove</title>
    <ns>0</ns>
    <id>6239</id>
    <revision>
      <id>69941</id>
      <parentid>69939</parentid>
      <timestamp>2014-05-02T12:22:21Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>minor change to Example comment.</comment>
      <text xml:space="preserve" bytes="1886">{{c/title | remove}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int remove( const char *fname );
}}

Deletes the file identified by character string pointed to by {{tt|fname}}.

===Parameters===
{{par begin}}
{{par | fname | pointer to a null-terminated string containing the path identifying the file to delete}}
{{par end}}

===Return value===
{{c|0}} upon success or non-zero value on error.

===Example===
{{example | remove with error checking. Code removes an existing file, then tries to remove a nonexisting file.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    const char* file_name = &quot;C:\\file.txt&quot;;
    
    FILE *fp = fopen(file_name,&quot;w&quot;);
    if (fp == NULL)
    {
      perror(&quot;fopen()&quot;);
      fprintf(stderr,&quot;fopen() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
 
    /* Normal processing continues here. */
    fclose(fp);
    
    system(&quot;ls&quot;);

    /* Remove an existing file. */
    int ret_code = remove(file_name);
    if (ret_code != 0)
    {
      perror(&quot;remove()&quot;);
      fprintf(stderr,&quot;remove() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
    
    system(&quot;ls&quot;);
    
    /* Try removing a nonexisting file. */
    ret_code = remove(file_name);
    if (ret_code != 0)
    {
      perror(&quot;remove()&quot;);
      fprintf(stderr,&quot;remove() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
    
    return EXIT_SUCCESS;
}
 | output=
remove(): No such file or directory
remove() failed in file main.cpp at line # 33
C:\file.txt
a.out
main.cpp
a.out
main.cpp
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc rename}}
{{dsc see cpp | cpp/io/c/remove}}
{{dsc end}}

[[de:c/io/remove]]
[[es:c/io/remove]]
[[fr:c/io/remove]]
[[it:c/io/remove]]
[[ja:c/io/remove]]
[[pt:c/io/remove]]
[[ru:c/io/remove]]
[[zh:c/io/remove]]</text>
      <sha1>1u3rhj840ry5otxfbeytcwg2bqhqo0f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/rename</title>
    <ns>0</ns>
    <id>6240</id>
    <revision>
      <id>69942</id>
      <parentid>69940</parentid>
      <timestamp>2014-05-02T12:23:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>minor change to Example comment.</comment>
      <text xml:space="preserve" bytes="2072">{{c/title | rename}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int rename( const char *old_filename, const char *new_filename );
}}

Changes the filename of a file. The file is identified by character string pointed to by {{tt|old_filename}}. The new filename is identified by character string pointed to by {{tt|new_filename}}.

===Parameters===
{{par begin}}
{{par | old_filename | pointer to a null-terminated string containing the path identifying the file to rename}}
{{par | new_filename | pointer to a null-terminated string containing the new path of the file}}
{{par end}}

===Return value===
{{c|0}} upon success or non-zero value on error.

===Example===
{{example | rename with error checking. Code renames a file.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    const char* old_file_name = &quot;C:\\file.txt&quot;;
    const char* new_file_name = &quot;C:\\data.txt&quot;;
    
    FILE *fp = fopen(old_file_name,&quot;w&quot;);
    if (fp == NULL)
    {
      perror(&quot;fopen()&quot;);
      fprintf(stderr,&quot;fopen() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
 
    /* Normal processing continues here. */
    fclose(fp);
    
    system(&quot;ls&quot;);
    
    /* Rename file. */
    int ret_code = rename(old_file_name,new_file_name);
    if (ret_code != 0)
    {
      perror(&quot;rename()&quot;);
      fprintf(stderr,&quot;rename() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
    
    system(&quot;ls&quot;);
    
    /* Remove file. */
    ret_code = remove(new_file_name);
    if (ret_code != 0)
    {
      perror(&quot;remove()&quot;);
      fprintf(stderr,&quot;remove() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
    
    return EXIT_SUCCESS;
}
 | output=
C:\file.txt
a.out
main.cpp
C:\data.txt
a.out
main.cpp
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc remove}}
{{dsc see cpp | cpp/io/c/rename}}
{{dsc end}}

[[de:c/io/rename]]
[[es:c/io/rename]]
[[fr:c/io/rename]]
[[it:c/io/rename]]
[[ja:c/io/rename]]
[[pt:c/io/rename]]
[[ru:c/io/rename]]
[[zh:c/io/rename]]</text>
      <sha1>izjmgagqrucwwzpzpjj7ioxld5z2kjs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/rewind</title>
    <ns>0</ns>
    <id>6234</id>
    <revision>
      <id>71205</id>
      <parentid>66670</parentid>
      <timestamp>2014-06-08T11:06:00Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1211">{{c/title | rewind }}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
void rewind( FILE *stream );
}}

Moves the file position indicator to the beginning of the given file stream. 

The function is equivalent to {{c|fseek(stream, 0, SEEK_SET);}}, except that end-of-file and error indicators are cleared. 

The function drops any effects from previous calls to {{lc|ungetc}}.

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par end}}

===Return value===
(none)

===Example===
{{example | This example shows how to read a file twice
|code=
#include &lt;stdio.h&gt;

char str[20];

int main(void)
{
    FILE *f;
    char ch;

    f = fopen(&quot;file.txt&quot;, &quot;w&quot;);
    for (ch = '0'; ch &lt;= '9'; ch++) {
        fputc(ch, f);
    }
    fclose(f);

    f = fopen(&quot;file.txt&quot;, &quot;r&quot;);
    fread(str, 1, 10, f);
    puts(str);
    
    rewind(f);
    fread(str, 1, 10, f);
    puts(str);
    fclose(f);

    return 0;
}
| output=
0123456789
0123456789
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fseek}}
{{dsc see cpp | cpp/io/c/rewind}}
{{dsc end}}

[[de:c/io/rewind]]
[[es:c/io/rewind]]
[[fr:c/io/rewind]]
[[it:c/io/rewind]]
[[ja:c/io/rewind]]
[[pt:c/io/rewind]]
[[ru:c/io/rewind]]
[[zh:c/io/rewind]]</text>
      <sha1>7bxrnmg5wd0gfr6egms8i9xx16gmy8v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/scanf</title>
    <ns>0</ns>
    <id>6485</id>
    <redirect title="c/io/fscanf" />
    <revision>
      <id>25655</id>
      <timestamp>2012-04-23T20:54:24Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fscanf]]</comment>
      <text xml:space="preserve" bytes="25">#redirect [[c/io/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/setbuf</title>
    <ns>0</ns>
    <id>6202</id>
    <revision>
      <id>69874</id>
      <parentid>63896</parentid>
      <timestamp>2014-04-30T13:23:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1997">{{c/title | setbuf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
void setbuf( FILE          *stream, char          *buffer );
}}
{{dcl | since=c99 |
void setbuf( FILE *restrict stream, char *restrict buffer );
}}
{{dcl rev end}}
{{dcl end}}

Sets the internal buffer to use for stream operations. It should be at least {{tt|BUFSIZ}} characters long. 

If {{tt|buffer}} is not null, equivalent to {{c|setvbuf(stream, buffer, _IOFBF, BUFSIZ)}}

If {{tt|buffer}} is null, equivalent to {{c|setvbuf(stream, NULL, _IONBF, 0)}}, which turns off buffering.

===Parameters===
{{par begin}}
{{par | stream | the file stream to set the buffer to}}
{{par | buffer | pointer to a buffer for the stream to use. If {{lc|NULL}} is supplied, the buffering is turned off}}
{{par end}}

===Return value===
None.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;

int main(void)
{
    int file_size;
    char buffer[BUFSIZ];
    FILE * fp = fopen(&quot;test.txt&quot;,&quot;w+&quot;);
    setbuf(fp,buffer);
  
    /* Exhibit the contents of buffer. */
    fputs (&quot;aaa&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;bbb&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;ccc&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    file_size = ftell(fp);
    printf(&quot;file_size = %d\n&quot;, file_size);
    fflush (fp);              /* flush buffer */
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;ddd&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;eee&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    
    rewind(fp);               /* flush buffer and rewind file */
    char buf[20];
    fgets(buf,sizeof buf,fp);
    printf(&quot;%s\n&quot;, buf);

    fclose(fp);

    return 0;
}
 | output=
aaa
aaabbb
aaabbbccc
file_size = 9
aaabbbccc
dddbbbccc
dddeeeccc
aaabbbcccdddeee
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc setvbuf}}
{{dsc see cpp | cpp/io/c/setbuf}}
{{dsc end}}

[[de:c/io/setbuf]]
[[es:c/io/setbuf]]
[[fr:c/io/setbuf]]
[[it:c/io/setbuf]]
[[ja:c/io/setbuf]]
[[pt:c/io/setbuf]]
[[ru:c/io/setbuf]]
[[zh:c/io/setbuf]]</text>
      <sha1>aqib4g5bpbdez36v9hg8s8milp11n7k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/setvbuf</title>
    <ns>0</ns>
    <id>6203</id>
    <revision>
      <id>69899</id>
      <parentid>69875</parentid>
      <timestamp>2014-05-01T12:14:49Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted error checking</comment>
      <text xml:space="preserve" bytes="2417">{{c/title | setvbuf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
int setvbuf( FILE *         stream, char *         buffer, 
             int mode, size_t size );
}}
{{dcl | since=c99 |
int setvbuf( FILE *restrict stream, char *restrict buffer, 
             int mode, size_t size );
}}
{{dcl rev end}}
{{dcl end}}

Sets the internal buffer of the given file stream {{tt|stream}}. 

===Parameters===
{{par begin}}
{{par | stream | the file stream to set the buffer to}}
{{par | buffer | pointer to a buffer for the stream to use}}
{{par | mode |2= buffering mode to use. It can be one of the following values:

{{cpp/io/c/buffering modes}}
}}
{{par | size | size of the buffer}}
{{par end}}

===Return value===
{{c|0}} on success or nonzero on failure.

===Notes===
This function may only be used after {{tt|stream}} has been associated with an open file, but before any other operation.

{{tt|buffer}} may be null, in which case this call only resizes the internal buffer.

===Example===
{{example | setvbuf with error checking
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    int file_size;
    char buffer[BUFSIZ];
    FILE * fp = fopen(&quot;test.txt&quot;,&quot;w+&quot;);
    if (setvbuf(fp,buffer,_IOFBF,BUFSIZ) != 0)
    {
       perror(&quot;setvbuf()&quot;);
       fprintf(stderr,&quot;setvbuf() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-3);
       exit(EXIT_FAILURE);
    }
  
    /* Exhibit the contents of buffer. */
    fputs (&quot;aaa&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;bbb&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;ccc&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    file_size = ftell(fp);
    printf(&quot;file_size = %d\n&quot;, file_size);
    fflush (fp);              /* flush buffer */
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;ddd&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    fputs (&quot;eee&quot;,fp);
    printf(&quot;%s\n&quot;, buffer);
    
    rewind(fp);               /* flush buffer and rewind file */
    char buf[20];
    fgets(buf,sizeof buf,fp);
    printf(&quot;%s\n&quot;, buf);

    fclose(fp);

    return 0;
}
 | output=
aaa
aaabbb
aaabbbccc
file_size = 9
aaabbbccc
dddbbbccc
dddeeeccc
aaabbbcccdddeee
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc setbuf}}
{{dsc see cpp | cpp/io/c/setvbuf}}
{{dsc end}}

[[de:c/io/setvbuf]]
[[es:c/io/setvbuf]]
[[fr:c/io/setvbuf]]
[[it:c/io/setvbuf]]
[[ja:c/io/setvbuf]]
[[pt:c/io/setvbuf]]
[[ru:c/io/setvbuf]]
[[zh:c/io/setvbuf]]</text>
      <sha1>cncpq5tuy13bpjie3vdwh3e5f5vpk39</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/snprintf</title>
    <ns>0</ns>
    <id>6496</id>
    <redirect title="c/io/fprintf" />
    <revision>
      <id>25667</id>
      <timestamp>2012-04-23T20:55:45Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fprintf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/sprintf</title>
    <ns>0</ns>
    <id>6495</id>
    <redirect title="c/io/fprintf" />
    <revision>
      <id>25666</id>
      <timestamp>2012-04-23T20:55:42Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fprintf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/sscanf</title>
    <ns>0</ns>
    <id>6487</id>
    <redirect title="c/io/fscanf" />
    <revision>
      <id>25657</id>
      <timestamp>2012-04-23T20:54:39Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fscanf]]</comment>
      <text xml:space="preserve" bytes="25">#redirect [[c/io/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/swprintf</title>
    <ns>0</ns>
    <id>6497</id>
    <redirect title="c/io/fwprintf" />
    <revision>
      <id>25668</id>
      <timestamp>2012-04-23T20:55:48Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fwprintf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/fwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/swscanf</title>
    <ns>0</ns>
    <id>6488</id>
    <redirect title="c/io/fwscanf" />
    <revision>
      <id>25658</id>
      <timestamp>2012-04-23T20:54:44Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fwscanf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/fwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/tmpfile</title>
    <ns>0</ns>
    <id>6241</id>
    <revision>
      <id>69943</id>
      <parentid>69933</parentid>
      <timestamp>2014-05-02T12:31:02Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>minor change to Example comment.</comment>
      <text xml:space="preserve" bytes="1245">{{c/title | tmpfile}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
FILE *tmpfile();
}}

Opens a temporary file. The file is opened as binary file for update ({{tt|&quot;wb+}} mode). The filename of the file is guaranteed to be unique within the filesystem.

The file will be closed when the program exits.

===Parameters===
(none)

===Return value===
The associated file stream or {{lc|NULL}} if an error has occurred

===Example===
{{example | tmpfile with error checking. Code opens a temporary file with mode &quot;wb+&quot;.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
int main(void)
{
    FILE* tmpf = tmpfile();   /* mode: &quot;wb+&quot; */
    if (tmpf == NULL)
    {
       perror(&quot;tmpfile()&quot;);
       fprintf(stderr,&quot;tmpfile() failed in file %s at line # %d&quot;, __FILE__,__LINE__-4);
       exit(EXIT_FAILURE);
    }
    fputs(&quot;Hello, world&quot;, tmpf);
    rewind(tmpf);
    char buf[6];
    fgets(buf, sizeof buf, tmpf);
    printf(&quot;%s\n&quot;, buf);

    return EXIT_SUCCESS;
}
 | output=
Hello
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc tmpnam}}
{{dsc see cpp | cpp/io/c/tmpfile}}
{{dsc end}}

[[de:c/io/tmpfile]]
[[es:c/io/tmpfile]]
[[fr:c/io/tmpfile]]
[[it:c/io/tmpfile]]
[[ja:c/io/tmpfile]]
[[pt:c/io/tmpfile]]
[[ru:c/io/tmpfile]]
[[zh:c/io/tmpfile]]</text>
      <sha1>rxxaq46woiqvwyb5no8qkbi3x6tte4x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/tmpnam</title>
    <ns>0</ns>
    <id>6242</id>
    <revision>
      <id>69944</id>
      <parentid>69792</parentid>
      <timestamp>2014-05-02T12:52:35Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>perror should be called immediately after the function being checked for an error; minor change to Example comment. Based on 7.21.4.4(5).</comment>
      <text xml:space="preserve" bytes="2857">{{c/title | tmpnam}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
char *tmpnam( char *filename );
}}

Creates an unique filename and stores it in character string pointed to by {{tt|filename}}. The function is capable of generating up to {{lc|TMP_MAX}} of unique filenames, but some or all of them may be in use in the filesystem and thus not suitable return values. 

{{tt|tmpnam}} is not reentrant and thus not thread-safe.

===Parameters===
{{par begin}}
{{par | filename | pointer to the character string to be used as a result buffer. If {{tt|NULL}} is passed, a pointer to an internal static buffer is returned.}}
{{par end}}

===Return value===
{{tt|filename}} if {{tt|filename}} was not {{lc|NULL}}. Otherwise a pointer to an internal static buffer is returned. If no suitable filename can be generated, {{lc|NULL}} is returned.

===Notes===
Although the names generated by {{tt|tmpnam}} are difficult to guess, it is possible that a file with that name is created by another process between the moment {{tt|tmpnam}} returns and the moment this program attempts to use the returned name to create a file. The standard function {{lc|std::tmpfile}} and the POSIX function [http://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdtemp.html mkstemp] do not have this problem.

POSIX systems additionally define the similarly named function {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tempnam.html tempnam()]}}, which offers the choice of a directory (which defaults to the optionally defined macro {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html P_tmpdir])}}

===Example===
{{example | tmpnam with error checking. Code generates a unique filename.
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    printf(&quot;TMP_MAX  = %d\n&quot;, TMP_MAX);
    printf(&quot;L_tmpnam = %d\n&quot;, L_tmpnam);
    char buffer[L_tmpnam] = {'\0'};
    char * fname = tmpnam(buffer);
    if (fname == NULL)
    {
      perror(&quot;tmpnam()&quot;);
      fprintf(stderr,&quot;tmpnam() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-4);
      exit(EXIT_FAILURE);
    }
    printf(&quot;%s\n&quot;, fname);
    printf(&quot;%s\n&quot;, buffer);
    printf(&quot;\n&quot;);

    /* Argument is a null pointer. */
    char * fn1 = tmpnam(NULL);
    printf(&quot;%s\n&quot;, fn1);
    printf(&quot;%p\n&quot;, fn1);
    /* Subsequent calls to tmpnam modify the same object. */
    char * fn2 = tmpnam(NULL);
    printf(&quot;%s\n&quot;, fn2);
    printf(&quot;%p\n&quot;, fn2);

    exit(EXIT_SUCCESS);
}
 | output=
TMP_MAX  = 238328
L_tmpnam = 20
/tmp/filer8fER3
/tmp/filer8fER3

/tmp/fileurN5sQ
0x7f0f05dc7a10
/tmp/file1Pux4C
0x7f0f05dc7a10
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc tmpfile}}
{{dsc see cpp | cpp/io/c/tmpnam}}
{{dsc end}}

[[de:c/io/tmpnam]]
[[es:c/io/tmpnam]]
[[fr:c/io/tmpnam]]
[[it:c/io/tmpnam]]
[[ja:c/io/tmpnam]]
[[pt:c/io/tmpnam]]
[[ru:c/io/tmpnam]]
[[zh:c/io/tmpnam]]</text>
      <sha1>hhmvwuz5aewogaohk8waslgj18whusi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/ungetc</title>
    <ns>0</ns>
    <id>6214</id>
    <revision>
      <id>69911</id>
      <parentid>69835</parentid>
      <timestamp>2014-05-01T13:45:16Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>perror should be called immediately after the function being checked for an error.</comment>
      <text xml:space="preserve" bytes="1607">{{c/title| ungetc}}
{{c/io/navbar}}
{{ddcl | header=stdio.h |
int ungetc( int ch, FILE *stream );
}}
Puts the character {{tt|ch}} back to the given file stream. 

===Parameters===
{{par begin}}
{{par | ch | character to be put back}}
{{par | stream | file stream to put the character back to}}
{{par end}}

===Return value===

On success {{tt|ch}} is returned.

On failure {{lc|EOF}} is returned and the given stream remains unchanged.

===Example===
{{example | ungetc with error checking
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    FILE* fp = fopen(&quot;test.txt&quot;, &quot;w&quot;);
    fputs(&quot;abc\n&quot;, fp);
    fclose(fp);
    fp = fopen(&quot;test.txt&quot;, &quot;r&quot;);
    
    /* Read  &quot;abc&quot;.  */
    /* Write &quot;abbc&quot;. */
    char ch;
    int ret_code;
    ch=fgetc(fp);   /* read 'a' */
    putchar(ch);
    ch=fgetc(fp);   /* read 'b' */
    putchar(ch);
    
    ret_code = ungetc(ch,fp);   /* push 'b' back to input file */
    /* Test whether EOF was reached. */
    if (ret_code == EOF)
       if (ferror(fp)) 
       {
          perror(&quot;ungetc()&quot;);
          fprintf(stderr,&quot;ungetc() failed in file %s at line # %d\n&quot;, __FILE__,__LINE__-6);
          exit(EXIT_FAILURE);
       }
    
    ch=fgetc(fp);   /* reread 'b' */
    putchar(ch);
    ch=fgetc(fp);   /* read 'c'   */
    putchar(ch);
    
    return EXIT_SUCCESS;
}
 | output=
abbc
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fgetc}}
{{dsc see cpp | cpp/io/c/ungetc}}
{{dsc end}}

[[de:c/io/ungetc]]
[[es:c/io/ungetc]]
[[fr:c/io/ungetc]]
[[it:c/io/ungetc]]
[[ja:c/io/ungetc]]
[[pt:c/io/ungetc]]
[[ru:c/io/ungetc]]
[[zh:c/io/ungetc]]</text>
      <sha1>l220w1tqa17iik3agl8uu0cllf8a8ru</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/ungetwc</title>
    <ns>0</ns>
    <id>6221</id>
    <revision>
      <id>56484</id>
      <parentid>48926</parentid>
      <timestamp>2013-06-01T05:37:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="804">{{c/title| ungetwc}}
{{c/io/navbar}}
{{ddcl | header=wchar.h |
wint_t ungetwc( wint_t ch, FILE *stream );
}}
Puts the wide character {{tt|ch}} back to the given file stream. 
Only one wide character pushback is guaranteed.

===Parameters===
{{par begin}}
{{par | ch | wide character to be put back}}
{{par | stream | file stream to put the wide character back to}}
{{par end}}

===Return value===

On success {{tt|ch}} is returned.

On failure {{c|WEOF}} is returned and the given stream remains unchanged.

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc ungetc}}
{{dsc inc | c/io/dsc fgetwc}}
{{dsc see cpp | cpp/io/c/ungetwc}}
{{dsc end}}

[[de:c/io/ungetwc]]
[[es:c/io/ungetwc]]
[[fr:c/io/ungetwc]]
[[it:c/io/ungetwc]]
[[ja:c/io/ungetwc]]
[[pt:c/io/ungetwc]]
[[ru:c/io/ungetwc]]
[[zh:c/io/ungetwc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vfprintf</title>
    <ns>0</ns>
    <id>6225</id>
    <revision>
      <id>71395</id>
      <parentid>71211</parentid>
      <timestamp>2014-06-10T10:27:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>new comment for the example</comment>
      <text xml:space="preserve" bytes="3304">{{c/title | vprintf | vfprintf | vsprintf | vsnprintf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl rev begin | num=1}}
{{dcl | until=c99 |
​int vprintf( const char          *format, va_list vlist );​
}}
{{dcl | since=c99 |
​int vprintf( const char *restrict format, va_list vlist );​
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c99 |
int vfprintf( FILE          *stream, const char          *format, 
              va_list vlist );
}}
{{dcl | since=c99 |
int vfprintf( FILE *restrict stream, const char *restrict format, 
              va_list vlist );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | until=c99 |
int vsprintf( char          *buffer, const char          *format, 
              va_list vlist );
}}
{{dcl | since=c99 |
int vsprintf( char *restrict buffer, const char *restrict format, 
              va_list vlist );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c99 |
int vsnprintf( char *restrict buffer, int buf_size, 
               const char *restrict format, va_list vlist );
}}
{{dcl end}}

Loads the data from the locations, defined by {{tt|vlist}}, converts them to character string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a character string {{tt|buffer}}.
@4@ Writes the results to a character string {{tt|buffer}}. At most {{tt|buf_size}} characters are written. The resulting character string will be terminated with a null character, unless {{tt|buf_size}} is zero. 

===Parameters===
{{par begin}}
{{par | stream | output file stream to write to}}
{{par | buffer | pointer to a character string to write to}}
{{par | buf_size | maximum number of characters to write}}
{{par | format | pointer to a null-terminated character string specifying how to interpret the data.
{{cpp/io/c/printf format}}
}}
{{par | vlist | variable argument list containing the data to print }}
{{par end}}

===Return value===
@1-3@ The number of characters written if successful or negative value if an error occurred.

@4@ The number of characters written if successful or negative value if an error occurred. If the resulting string gets truncated due to {{tt|buf_size}} limit, function returns the total number of characters (not including the terminating null-byte) which would have been written, if the limit was not imposed. 

===Example===
{{example
 | Write from variables day, month, year to a null-terminated character string.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;
 
void putdate (char *str, const char *format, ...)
{
  va_list args;
  va_start(args,format);
  vsprintf(str,format,args);
  va_end(args);
}
 
int main(void)
{
  int day=20, year=2012;
  char *month=&quot;June&quot;;
  char str[10];
  putdate(str,&quot;%d %s %d&quot;, day,month,year);
  printf(&quot;summer solstice:  %s\n&quot;, str);
 
  return 0;
}
 | p=true
 | output=
summer solstice:  20 June 2012
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fprintf}}
{{dsc inc | c/io/dsc vfscanf}}
{{dsc see cpp | cpp/io/c/vfprintf | vprintf | vfprintf | vsprintf | vsnprintf}}
{{dsc end}}

[[de:c/io/vfprintf]]
[[es:c/io/vfprintf]]
[[fr:c/io/vfprintf]]
[[it:c/io/vfprintf]]
[[ja:c/io/vfprintf]]
[[pt:c/io/vfprintf]]
[[ru:c/io/vfprintf]]
[[zh:c/io/vfprintf]]</text>
      <sha1>1pl0x1eov4l6i2a7qyvbxcg4j7gjqkd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vfscanf</title>
    <ns>0</ns>
    <id>6223</id>
    <revision>
      <id>71396</id>
      <parentid>71209</parentid>
      <timestamp>2014-06-10T10:30:27Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>new comment for the example</comment>
      <text xml:space="preserve" bytes="2103">{{c/title | vscanf | vfscanf | vsscanf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | stdio.h}}
{{dcl | num=1 | since=c99 |
​int vscanf( const char *restrict format, va_list vlist );​
}}
{{dcl | num=2 | since=c99 |
int vfscanf( FILE *restrict stream, const char *restrict format, 
             va_list vlist );
}}
{{dcl | num=3 | since=c99 |
int vsscanf( const char *restrict buffer, const char *restrict format, 
             va_list vlist );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into locations defined by {{tt|vlist}}.

@1@ Reads the data from {{lc|stdin}}
@2@ Reads the data from file stream {{tt|stream}}
@3@ Reads the data from null-terminated character string {{tt|buffer}}

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated character string to read from}}
{{par | format | pointer to a null-terminated character string specifying how to read the input.
{{cpp/io/c/scanf format}}
}}
{{par | vlist | variable argument list containing the receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs.

===Example===
{{example
 | Read from a null-terminated character string to variables day, month, year.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;

void getdate (const char *str, const char *format, ...)
{
  va_list args;
  va_start(args,format);
  vsscanf(str,format,args);
  va_end(args);
}

int main(void)
{
  int day, year;
  char month[10];
  getdate(&quot;20 June 2012&quot;,&quot;%d %s %d&quot;, &amp;day,month,&amp;year);
  printf (&quot;summer solstice in %d:  %s %d&quot;, year,month,day);

  return 0;
}
 | p=true
 | output=
summer solstice in 2012:  June 20
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fscanf}}
{{dsc inc | c/io/dsc vfprintf}}
{{dsc see cpp | cpp/io/c/vfscanf | vscanf | vfscanf | vsscanf}}
{{dsc end}}

[[de:c/io/vfscanf]]
[[es:c/io/vfscanf]]
[[fr:c/io/vfscanf]]
[[it:c/io/vfscanf]]
[[ja:c/io/vfscanf]]
[[pt:c/io/vfscanf]]
[[ru:c/io/vfscanf]]
[[zh:c/io/vfscanf]]</text>
      <sha1>0k9zrimp54nvkqkr10zpl2m5kn1orku</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vfwprintf</title>
    <ns>0</ns>
    <id>6229</id>
    <revision>
      <id>56489</id>
      <parentid>48929</parentid>
      <timestamp>2013-06-01T05:37:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1186">{{c/title | vwprintf | vfwprintf | vswprintf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | num=1 |
int vwprintf( const wchar_t* format, va_list vlist );
}}
{{dcl | num=2 |
int vfwprintf( FILE* stream, const wchar_t* format, va_list vlist );
}}
{{dcl | num=3 |
int vswprintf( const wchar_t* buffer, size_t size, const wchar_t* format, va_list vlist );
}}
{{dcl end}}

Loads the data from locations, defined by {{tt|vlist}}, converts them to wide string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a wide string {{tt|buffer}}.

===Parameters===
{{todo}}

===Return value===
Number of wide characters written if successful or negative value if an error occurred.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fwprintf}}
{{dsc see cpp | cpp/io/c/vfwprintf | vwprintf | vfwprintf | vswprintf}}
{{dsc end}}

[[de:c/io/vfwprintf]]
[[es:c/io/vfwprintf]]
[[fr:c/io/vfwprintf]]
[[it:c/io/vfwprintf]]
[[ja:c/io/vfwprintf]]
[[pt:c/io/vfwprintf]]
[[ru:c/io/vfwprintf]]
[[zh:c/io/vfwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vfwscanf</title>
    <ns>0</ns>
    <id>6227</id>
    <revision>
      <id>62512</id>
      <parentid>56492</parentid>
      <timestamp>2013-07-01T23:23:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1502">{{c/title | vwscanf | vfwscanf | vswscanf}}
{{c/io/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | num=1 | since=c99 |
int vwscanf( const wchar_t* format, va_list vlist );
}}
{{dcl | num=2 | since=c99 |
int vfwscanf( FILE *stream, const wchar_t* format, va_list vlist );
}}
{{dcl | num=3 | since=c99 |
int vswscanf( const wchar_t* buffer, const wchar_t* format, va_list vlist );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into locations defined by {{tt|vlist}}.

@1@ Reads the data from {{lc|stdin}}.
@2@ Reads the data from file stream {{tt|stream}}.
@3@ Reads the data from null-terminated wide string {{tt|buffer}}.

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated wide string to read from}}
{{par | format | pointer to a null-terminated wide string specifying how to read the input. {{todo}}
}}
{{par | vlist | variable argument list containing the receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/io/dsc fwscanf}}
{{dsc see cpp | cpp/io/c/vfwscanf | vwscanf | vfwscanf | vswscanf}}
{{dsc end}}

[[de:c/io/vfwscanf]]
[[es:c/io/vfwscanf]]
[[fr:c/io/vfwscanf]]
[[it:c/io/vfwscanf]]
[[ja:c/io/vfwscanf]]
[[pt:c/io/vfwscanf]]
[[ru:c/io/vfwscanf]]
[[zh:c/io/vfwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vprintf</title>
    <ns>0</ns>
    <id>6498</id>
    <redirect title="c/io/vfprintf" />
    <revision>
      <id>25670</id>
      <parentid>25669</parentid>
      <timestamp>2012-04-23T20:56:03Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfprintf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vscanf</title>
    <ns>0</ns>
    <id>6489</id>
    <redirect title="c/io/vfscanf" />
    <revision>
      <id>25660</id>
      <parentid>25659</parentid>
      <timestamp>2012-04-23T20:55:04Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfscanf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vsnprintf</title>
    <ns>0</ns>
    <id>6500</id>
    <redirect title="c/io/vfprintf" />
    <revision>
      <id>25672</id>
      <timestamp>2012-04-23T20:56:13Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfprintf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vsprintf</title>
    <ns>0</ns>
    <id>6499</id>
    <redirect title="c/io/vfprintf" />
    <revision>
      <id>25671</id>
      <timestamp>2012-04-23T20:56:08Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfprintf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vsscanf</title>
    <ns>0</ns>
    <id>6491</id>
    <redirect title="c/io/vfscanf" />
    <revision>
      <id>25662</id>
      <timestamp>2012-04-23T20:55:21Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfscanf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vswscanf</title>
    <ns>0</ns>
    <id>6492</id>
    <redirect title="c/io/vfwscanf" />
    <revision>
      <id>25663</id>
      <timestamp>2012-04-23T20:55:26Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfwscanf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/vfwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vwprintf</title>
    <ns>0</ns>
    <id>6501</id>
    <redirect title="c/io/vfwprintf" />
    <revision>
      <id>25673</id>
      <timestamp>2012-04-23T20:56:18Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfwprintf]]</comment>
      <text xml:space="preserve" bytes="28">#redirect [[c/io/vfwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/vwscanf</title>
    <ns>0</ns>
    <id>6490</id>
    <redirect title="c/io/vfwscanf" />
    <revision>
      <id>25661</id>
      <timestamp>2012-04-23T20:55:14Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/vfwscanf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/vfwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/wprintf</title>
    <ns>0</ns>
    <id>6494</id>
    <redirect title="c/io/fwprintf" />
    <revision>
      <id>25665</id>
      <timestamp>2012-04-23T20:55:38Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fwprintf]]</comment>
      <text xml:space="preserve" bytes="27">#redirect [[c/io/fwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/io/wscanf</title>
    <ns>0</ns>
    <id>6486</id>
    <redirect title="c/io/fwscanf" />
    <revision>
      <id>25656</id>
      <timestamp>2012-04-23T20:54:32Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/io/fwscanf]]</comment>
      <text xml:space="preserve" bytes="26">#redirect [[c/io/fwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword</title>
    <ns>0</ns>
    <id>6172</id>
    <revision>
      <id>71077</id>
      <parentid>70930</parentid>
      <timestamp>2014-06-05T14:58:35Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="2076">{{title|C keywords}}
{{c/keyword/navbar}}

This is a list of reserved keywords in C. Since they are used by the language, these keywords are not available for re-definition. 

{| class=&quot;wikitable&quot;
|-
|
{{rlt|auto}}&lt;br&gt;
{{rlt|break}}&lt;br&gt;
{{rlt|case}}&lt;br&gt;
{{rlt|char}}&lt;br&gt;
{{rlt|const}}&lt;br&gt;
{{rlt|continue}}&lt;br&gt;
{{rlt|default}}&lt;br&gt;
{{rlt|do}}&lt;br&gt;
{{rlt|double}}&lt;br&gt;
{{rlt|else}}&lt;br&gt;
{{rlt|enum}}&lt;br&gt;
{{rlt|extern}}
|
{{rlt|float}}&lt;br&gt;
{{rlt|for}}&lt;br&gt;
{{rlt|goto}}&lt;br&gt;
{{rlt|if}}&lt;br&gt;
{{rlt|inline}} {{mark since c99}}&lt;br&gt;
{{rlt|int}}&lt;br&gt;
{{rlt|long}}&lt;br&gt;
{{rlt|register}}&lt;br&gt;
{{rlt|restrict}} {{mark since c99}}&lt;br&gt;
{{rlt|return}}&lt;br&gt;
{{rlt|short}}
|
{{rlt|signed}}&lt;br&gt;
{{rlt|sizeof}}&lt;br&gt;
{{rlt|static}}&lt;br&gt;
{{rlt|struct}}&lt;br&gt;
{{rlt|switch}}&lt;br&gt;
{{rlt|typedef}}&lt;br&gt;
{{rlt|union}}&lt;br&gt;
{{rlt|unsigned}}&lt;br&gt;
{{rlt|void}}&lt;br&gt;
{{rlt|volatile}}&lt;br&gt;
{{rlt|while}}
|
{{rlt|_Alignas}} {{mark since c11}}&lt;br&gt;
{{rlt|_Alignof}} {{mark since c11}}&lt;br&gt;
{{rlt|_Atomic}} {{mark since c11}}&lt;br&gt;
{{rlt|_Bool}} {{mark since c99}}&lt;br&gt;
{{rlt|_Complex}} {{mark since c99}}&lt;br&gt;
{{rlt|_Generic}} {{mark since c11}}&lt;br&gt;
{{rlt|_Imaginary}} {{mark since c99}}&lt;br&gt;
{{rlt|_Noreturn}} {{mark since c11}}&lt;br&gt;
{{rlt|_Static_assert}} {{mark since c11}}&lt;br&gt;
{{rlt|_Thread_local}} {{mark since c11}}
|}

Also, each name that contains a double underscore __ or begins with an underscore followed by an uppercase letter is always reserved to the implementation and should not be used as an identifier. Each name that begins with an underscore is reserved to the implementation for use as a name of a global entity; such names may be used as names of local variables, names of data members in a structure, etc.

Note that digraphs {{tt|&lt;%}}, {{tt|%&gt;}}, {{tt|&lt;:}}, {{tt|:&gt;}}, {{tt|%:}}, and {{tt|%:%:}} provide an [[c/language/operator_alternative|alternative way to represent standard tokens]].

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/keyword |C++ keywords}}
{{dsc end}}

[[de:c/keyword]]
[[es:c/keyword]]
[[fr:c/keyword]]
[[it:c/keyword]]
[[ja:c/keyword]]
[[pt:c/keyword]]
[[ru:c/keyword]]
[[zh:c/keyword]]</text>
      <sha1>oot5pqwhaig8crw7f363cfqebd8s64d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/ Bool</title>
    <ns>0</ns>
    <id>13177</id>
    <revision>
      <id>70247</id>
      <parentid>68010</parentid>
      <timestamp>2014-05-12T18:04:24Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="771">{{title|_Bool}}
{{c/language/navbar}}
Implements a Boolean type.

{{todo|needs content}}

===Keywords===

{{ltt|c/keyword/_Bool}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
 
int main(void)
{
    printf(&quot;sizeof(_Bool) = %zu\n&quot;, sizeof(_Bool));

    _Bool b;
    b = 2;
    printf(&quot;b  = %d\n&quot;, b);    // 2 or 1?
    printf(&quot;!b = %d\n&quot;, !b);   // 0
    
    b = 0;
    printf(&quot;!b = %d\n&quot;, !b);   // 1
     
    if (b) printf(&quot;true\n&quot;);   // false
    else   printf(&quot;false\n&quot;);

    return 0;
}
 | p=true
 | output=
sizeof(_Bool) = 1
b  = 1
!b = 0
!b = 1
false
}}

[[de:c/language/sizeof]]
[[es:c/language/sizeof]]
[[fr:c/language/sizeof]]
[[it:c/language/sizeof]]
[[ja:c/language/sizeof]]
[[pt:c/language/sizeof]]
[[ru:c/language/sizeof]]
[[zh:c/language/sizeof]]</text>
      <sha1>2vvyl67njqx00pncoqb48anxx97vck7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/ Complex</title>
    <ns>0</ns>
    <id>13176</id>
    <revision>
      <id>70248</id>
      <parentid>68189</parentid>
      <timestamp>2014-05-12T18:05:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1307">{{title|_Complex}}
{{c/language/navbar}}
Implements a complex-number type.

{{todo|content needed}}
===Keywords===

{{ltt|c/keyword/_Complex}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
 
int main(void)
{
   printf(&quot;sizeof(_Complex float)       = %2zu\n&quot;, sizeof(_Complex float));
   printf(&quot;sizeof(_Complex double)      = %2zu\n&quot;, sizeof(_Complex double));
   printf(&quot;sizeof(_Complex long double) = %2zu\n&quot;, sizeof(_Complex long double));

    /* definition, initialization, and printing of _Complex variable */
    _Complex double z, zc;
    __real__ z = 1.0;  __imag__ z = 2.0;
    printf(&quot;%.1f%+.1fi\n&quot;, __real__ z, __imag__ z);
 
    /* complex assignment */
    zc = z;
    
    /* complex conjugate */
    __imag__ zc = -__imag__ z;
    printf(&quot;%.1f%+.1fi\n&quot;, __real__ zc, __imag__ zc);
    
    /* complex product */
    /* (a+bi)(a-bi) = a^2 + b^2 */
    z = z*zc;
    printf(&quot;%.1f%+.1fi\n&quot;, __real__ z, __imag__ z);
 
    return 0;
}
 | p=true
 | output=
sizeof(_Complex float)       =  8
sizeof(_Complex double)      = 16
sizeof(_Complex long double) = 32
1.0+2.0i
1.0-2.0i
5.0+0.0i
}}

[[de:c/language/sizeof]]
[[es:c/language/sizeof]]
[[fr:c/language/sizeof]]
[[it:c/language/sizeof]]
[[ja:c/language/sizeof]]
[[pt:c/language/sizeof]]
[[ru:c/language/sizeof]]
[[zh:c/language/sizeof]]</text>
      <sha1>51ncdhufuq3ddi88klpvoqpubg7elq4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/ Noreturn</title>
    <ns>0</ns>
    <id>9599</id>
    <revision>
      <id>47505</id>
      <parentid>44689</parentid>
      <timestamp>2013-05-14T13:15:12Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="158">{{c/keyword/title|_Noreturn {{mark since c11}}}}
{{c/keyword/navbar}}

===Usage===
* {{tt|_Noreturn}} [[c/language/function_specifiers | function specifier]].</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/ Static assert</title>
    <ns>0</ns>
    <id>13539</id>
    <revision>
      <id>70419</id>
      <parentid>70415</parentid>
      <timestamp>2014-05-22T13:42:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+todo</comment>
      <text xml:space="preserve" bytes="756">{{title|_Static_assert}}

_Static_assert evaluates a constant expression at compile time. If the expression is equal to 0, the compiler will produce an error message containing the string literal given as the second parameter.

{{todo|write a page on static_assert-declaration, move content from here}}

===Parameters===
{{par begin}}
{{par | condition | constant expression}}
{{par | str | string literal}}
{{par end}}

===Return Value===
(none)

===Example===
{{example
 |
 | code=

#define BUFFER_SIZE 2048

int main (int argc, char **argv)
{
	// Test if math works.
	_Static_assert(2 + 2 == 4, &quot;Whoa dude!&quot;);

        // This will produce an error at compile time.
        _Static_assert(BUFFER_SIZE &lt;= 1024, &quot;BUFFER_SIZE is too big&quot;);

	return 0;
}
}}</text>
      <sha1>jco81mj7ao57hu8zcpqtrq1vxsr8ebf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/ Thread local</title>
    <ns>0</ns>
    <id>9549</id>
    <revision>
      <id>44165</id>
      <parentid>41312</parentid>
      <timestamp>2012-11-03T05:13:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="410">{{c/keyword/title|_Thread_local {{mark since c11}}}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/storage_class_specifiers | thread storage-class specifier]].

[[de:c/keyword/ Thread local]]
[[es:c/keyword/ Thread local]]
[[fr:c/keyword/ Thread local]]
[[it:c/keyword/ Thread local]]
[[ja:c/keyword/ Thread local]]
[[pt:c/keyword/ Thread local]]
[[ru:c/keyword/ Thread local]]
[[zh:c/keyword/ Thread local]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/auto</title>
    <ns>0</ns>
    <id>9415</id>
    <revision>
      <id>44160</id>
      <parentid>41313</parentid>
      <timestamp>2012-11-03T05:12:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="338">{{c/keyword/title|auto}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/storage_class_specifiers | automatic duration storage-class specifier]] with no linkage.

[[de:c/keyword/auto]]
[[es:c/keyword/auto]]
[[fr:c/keyword/auto]]
[[it:c/keyword/auto]]
[[ja:c/keyword/auto]]
[[pt:c/keyword/auto]]
[[ru:c/keyword/auto]]
[[zh:c/keyword/auto]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/break</title>
    <ns>0</ns>
    <id>9416</id>
    <revision>
      <id>44156</id>
      <parentid>40105</parentid>
      <timestamp>2012-11-03T05:12:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="331">{{c/keyword/title | break}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/break | {{tt|break}} statement]]: as the declaration of the statement

[[de:c/keyword/break]]
[[es:c/keyword/break]]
[[fr:c/keyword/break]]
[[it:c/keyword/break]]
[[ja:c/keyword/break]]
[[pt:c/keyword/break]]
[[ru:c/keyword/break]]
[[zh:c/keyword/break]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/case</title>
    <ns>0</ns>
    <id>9417</id>
    <revision>
      <id>44151</id>
      <parentid>40106</parentid>
      <timestamp>2012-11-03T05:09:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="323">{{c/keyword/title|case}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/switch | {{tt|switch}} statement]]: as the declaration of the case labels

[[de:c/keyword/case]]
[[es:c/keyword/case]]
[[fr:c/keyword/case]]
[[it:c/keyword/case]]
[[ja:c/keyword/case]]
[[pt:c/keyword/case]]
[[ru:c/keyword/case]]
[[zh:c/keyword/case]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/char</title>
    <ns>0</ns>
    <id>9418</id>
    <revision>
      <id>44144</id>
      <parentid>40107</parentid>
      <timestamp>2012-11-03T05:08:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="309">{{c/keyword/title|char}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|char}} type]]: as the declaration of the type

[[de:c/keyword/char]]
[[es:c/keyword/char]]
[[fr:c/keyword/char]]
[[it:c/keyword/char]]
[[ja:c/keyword/char]]
[[pt:c/keyword/char]]
[[ru:c/keyword/char]]
[[zh:c/keyword/char]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/const</title>
    <ns>0</ns>
    <id>9419</id>
    <revision>
      <id>44139</id>
      <parentid>40108</parentid>
      <timestamp>2012-11-03T05:07:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="294">{{c/keyword/title|const}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/cv | {{tt|const}} type specifier]]

[[de:c/keyword/const]]
[[es:c/keyword/const]]
[[fr:c/keyword/const]]
[[it:c/keyword/const]]
[[ja:c/keyword/const]]
[[pt:c/keyword/const]]
[[ru:c/keyword/const]]
[[zh:c/keyword/const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/continue</title>
    <ns>0</ns>
    <id>9420</id>
    <revision>
      <id>44134</id>
      <parentid>40109</parentid>
      <timestamp>2012-11-03T05:06:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="362">{{c/keyword/title|continue}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/continue | {{tt|continue}} statement]]: as the declaration of the statement

[[de:c/keyword/continue]]
[[es:c/keyword/continue]]
[[fr:c/keyword/continue]]
[[it:c/keyword/continue]]
[[ja:c/keyword/continue]]
[[pt:c/keyword/continue]]
[[ru:c/keyword/continue]]
[[zh:c/keyword/continue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/default</title>
    <ns>0</ns>
    <id>9421</id>
    <revision>
      <id>44130</id>
      <parentid>40110</parentid>
      <timestamp>2012-11-03T05:05:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="358">{{c/keyword/title|default}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/switch | {{tt|switch}} statement]]: as the declaration of the default case label

[[de:c/keyword/default]]
[[es:c/keyword/default]]
[[fr:c/keyword/default]]
[[it:c/keyword/default]]
[[ja:c/keyword/default]]
[[pt:c/keyword/default]]
[[ru:c/keyword/default]]
[[zh:c/keyword/default]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/do</title>
    <ns>0</ns>
    <id>9422</id>
    <revision>
      <id>44127</id>
      <parentid>40111</parentid>
      <timestamp>2012-11-03T05:04:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="292">{{c/keyword/title|do}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/do | {{tt|do-while}} loop]]: as the declaration of the loop

[[de:c/keyword/do]]
[[es:c/keyword/do]]
[[fr:c/keyword/do]]
[[it:c/keyword/do]]
[[ja:c/keyword/do]]
[[pt:c/keyword/do]]
[[ru:c/keyword/do]]
[[zh:c/keyword/do]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/double</title>
    <ns>0</ns>
    <id>9423</id>
    <revision>
      <id>44122</id>
      <parentid>40112</parentid>
      <timestamp>2012-11-03T05:03:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="329">{{c/keyword/title|double}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|double}} type]]: as the declaration of the type

[[de:c/keyword/double]]
[[es:c/keyword/double]]
[[fr:c/keyword/double]]
[[it:c/keyword/double]]
[[ja:c/keyword/double]]
[[pt:c/keyword/double]]
[[ru:c/keyword/double]]
[[zh:c/keyword/double]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/else</title>
    <ns>0</ns>
    <id>9424</id>
    <revision>
      <id>44120</id>
      <parentid>40113</parentid>
      <timestamp>2012-11-03T05:02:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="323">{{c/keyword/title|else}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/if | {{tt|if}} statement]]: as the declaration of the alternative branch

[[de:c/keyword/else]]
[[es:c/keyword/else]]
[[fr:c/keyword/else]]
[[it:c/keyword/else]]
[[ja:c/keyword/else]]
[[pt:c/keyword/else]]
[[ru:c/keyword/else]]
[[zh:c/keyword/else]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/enum</title>
    <ns>0</ns>
    <id>9425</id>
    <revision>
      <id>47506</id>
      <parentid>44115</parentid>
      <timestamp>2013-05-14T13:21:10Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="295">{{c/keyword/title|enum}}
{{c/keyword/navbar}}

===Usage===

* [[c/language/enum | declaration of an enumeration type]]

[[de:c/keyword/enum]]
[[es:c/keyword/enum]]
[[fr:c/keyword/enum]]
[[it:c/keyword/enum]]
[[ja:c/keyword/enum]]
[[pt:c/keyword/enum]]
[[ru:c/keyword/enum]]
[[zh:c/keyword/enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/extern</title>
    <ns>0</ns>
    <id>9544</id>
    <revision>
      <id>44111</id>
      <parentid>41310</parentid>
      <timestamp>2012-11-03T05:00:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="391">{{c/keyword/title|extern}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/storage_class_specifiers | static duration storage-class specifier]] with either internal or more usually external linkage.

[[de:c/keyword/extern]]
[[es:c/keyword/extern]]
[[fr:c/keyword/extern]]
[[it:c/keyword/extern]]
[[ja:c/keyword/extern]]
[[pt:c/keyword/extern]]
[[ru:c/keyword/extern]]
[[zh:c/keyword/extern]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/float</title>
    <ns>0</ns>
    <id>9426</id>
    <revision>
      <id>44106</id>
      <parentid>40115</parentid>
      <timestamp>2012-11-03T05:00:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="319">{{c/keyword/title|float}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|float}} type]]: as the declaration of the type

[[de:c/keyword/float]]
[[es:c/keyword/float]]
[[fr:c/keyword/float]]
[[it:c/keyword/float]]
[[ja:c/keyword/float]]
[[pt:c/keyword/float]]
[[ru:c/keyword/float]]
[[zh:c/keyword/float]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/for</title>
    <ns>0</ns>
    <id>9427</id>
    <revision>
      <id>47507</id>
      <parentid>44102</parentid>
      <timestamp>2013-05-14T13:21:58Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="297">{{c/keyword/title|for}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/for | {{tt|for}} loop]]: as the declaration of the loop

[[de:c/keyword/for]]
[[es:c/keyword/for]]
[[fr:c/keyword/for]]
[[it:c/keyword/for]]
[[ja:c/keyword/for]]
[[pt:c/keyword/for]]
[[ru:c/keyword/for]]
[[zh:c/keyword/for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/goto</title>
    <ns>0</ns>
    <id>9428</id>
    <revision>
      <id>44098</id>
      <parentid>40117</parentid>
      <timestamp>2012-11-03T04:58:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="318">{{c/keyword/title|goto}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/goto | {{tt|goto}} statement]]: as the declaration of the statement

[[de:c/keyword/goto]]
[[es:c/keyword/goto]]
[[fr:c/keyword/goto]]
[[it:c/keyword/goto]]
[[ja:c/keyword/goto]]
[[pt:c/keyword/goto]]
[[ru:c/keyword/goto]]
[[zh:c/keyword/goto]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/if</title>
    <ns>0</ns>
    <id>8589</id>
    <revision>
      <id>44093</id>
      <parentid>33182</parentid>
      <timestamp>2012-11-03T04:57:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="306">{{c/keyword/title|if}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/if | {{tt|if}} statement]]: as the declaration of the {{tt|if}} statement

[[de:c/keyword/if]]
[[es:c/keyword/if]]
[[fr:c/keyword/if]]
[[it:c/keyword/if]]
[[ja:c/keyword/if]]
[[pt:c/keyword/if]]
[[ru:c/keyword/if]]
[[zh:c/keyword/if]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/inline</title>
    <ns>0</ns>
    <id>9598</id>
    <revision>
      <id>44688</id>
      <parentid>44676</parentid>
      <timestamp>2012-11-12T17:02:07Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="152">{{c/keyword/title|inline {{mark since c99}}}}
{{c/keyword/navbar}}

===Usage===
* {{tt|inline}} [[c/language/function_specifiers | function specifier]].</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/int</title>
    <ns>0</ns>
    <id>9429</id>
    <revision>
      <id>44088</id>
      <parentid>40118</parentid>
      <timestamp>2012-11-03T04:56:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="299">{{c/keyword/title|int}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|int}} type]]: as the declaration of the type

[[de:c/keyword/int]]
[[es:c/keyword/int]]
[[fr:c/keyword/int]]
[[it:c/keyword/int]]
[[ja:c/keyword/int]]
[[pt:c/keyword/int]]
[[ru:c/keyword/int]]
[[zh:c/keyword/int]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/long</title>
    <ns>0</ns>
    <id>9430</id>
    <revision>
      <id>44084</id>
      <parentid>40119</parentid>
      <timestamp>2012-11-03T04:56:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="286">{{c/keyword/title|long}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|long}} type modifier]]

[[de:c/keyword/long]]
[[es:c/keyword/long]]
[[fr:c/keyword/long]]
[[it:c/keyword/long]]
[[ja:c/keyword/long]]
[[pt:c/keyword/long]]
[[ru:c/keyword/long]]
[[zh:c/keyword/long]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/register</title>
    <ns>0</ns>
    <id>9431</id>
    <revision>
      <id>44079</id>
      <parentid>41314</parentid>
      <timestamp>2012-11-03T04:55:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="420">{{c/keyword/title|register}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/storage_class_specifiers | automatic duration storage-class specifier]] with no linkage. Hints that the variable will be used heavily.

[[de:c/keyword/register]]
[[es:c/keyword/register]]
[[fr:c/keyword/register]]
[[it:c/keyword/register]]
[[ja:c/keyword/register]]
[[pt:c/keyword/register]]
[[ru:c/keyword/register]]
[[zh:c/keyword/register]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/restrict</title>
    <ns>0</ns>
    <id>13181</id>
    <revision>
      <id>70240</id>
      <parentid>68008</parentid>
      <timestamp>2014-05-12T17:40:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1813">{{title|Restricted pointer}}
{{c/language/navbar}}

{{todo|needs content}}

===Keywords===

{{ltt|c/keyword/restrict}}

===Example===
{{todo|replace by a concise example}}
To verify the 15% savings in this matrix-vector product, remove &quot;restrict&quot; from function Axb.
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;

/*
#define restrict
*/

// Ax = b
// Arrays A, x, and b could be aliased, so restrict pointers.
void Axb (float * restrict A, float * restrict x, float * restrict b, int n)
         __attribute__ ((noinline));

void Axb (float * restrict A, float * restrict x, float * restrict b, int n)
{
  int i;
  for (i=0; i&lt;n/5; i++)
  {
    b[0] =  A[0]*x[0] +  A[1]*x[1] +  A[2]*x[2] +  A[3]*x[3] +  A[4]*x[4];
    b[1] =  A[5]*x[0] +  A[6]*x[1] +  A[7]*x[2] +  A[8]*x[3] +  A[9]*x[4];
    b[2] = A[10]*x[0] + A[11]*x[1] + A[12]*x[2] + A[13]*x[3] + A[14]*x[4];
    b[3] = A[15]*x[0] + A[16]*x[1] + A[17]*x[2] + A[18]*x[3] + A[19]*x[4];
    b[4] = A[20]*x[0] + A[21]*x[1] + A[22]*x[2] + A[23]*x[3] + A[24]*x[4];
    A += 25;
    b += 5;
  }
}

/*    A    *  x   ==&gt;    b    */
/* 50000x5 * 5x1  ==&gt; 50000x1 */
#define NROW 50000
#define NCOL 5
float A[NROW*NCOL], x[NCOL], b[NROW];

int main(void)
{
    // Initialize matrix A and vector x.
    int i;
    for (i=0; i&lt;NCOL; ++i) x[i] = 1;
    for (i=0; i&lt;NROW*NCOL; ++i) A[i] = i;
 
    clock_t t = clock();   // start clock
    for (i=0; i&lt;10000; ++i)
        Axb(A,x,b,NROW);
    t = clock()-t;         // stop clock
    printf(&quot;Time used: %f seconds\n&quot;, ((float)t)/CLOCKS_PER_SEC);
    
    return 0;
}
 | p=true
 | output=
Time used: 1.880000 seconds
}}

[[de:c/language/union]]
[[es:c/language/union]]
[[fr:c/language/union]]
[[it:c/language/union]]
[[ja:c/language/union]]
[[pt:c/language/union]]
[[ru:c/language/union]]
[[zh:c/language/union]]</text>
      <sha1>duef4f14mwusvv9qogrm9onb7zvlvm4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/return</title>
    <ns>0</ns>
    <id>9432</id>
    <revision>
      <id>44075</id>
      <parentid>40121</parentid>
      <timestamp>2012-11-03T04:52:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="340">{{c/keyword/title|return}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/return | {{tt|return}} statement]]: as the declaration of the statement

[[de:c/keyword/return]]
[[es:c/keyword/return]]
[[fr:c/keyword/return]]
[[it:c/keyword/return]]
[[ja:c/keyword/return]]
[[pt:c/keyword/return]]
[[ru:c/keyword/return]]
[[zh:c/keyword/return]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/short</title>
    <ns>0</ns>
    <id>9433</id>
    <revision>
      <id>44069</id>
      <parentid>40122</parentid>
      <timestamp>2012-11-03T04:50:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="296">{{c/keyword/title|short}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|short}} type modifier]]

[[de:c/keyword/short]]
[[es:c/keyword/short]]
[[fr:c/keyword/short]]
[[it:c/keyword/short]]
[[ja:c/keyword/short]]
[[pt:c/keyword/short]]
[[ru:c/keyword/short]]
[[zh:c/keyword/short]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/signed</title>
    <ns>0</ns>
    <id>9434</id>
    <revision>
      <id>44063</id>
      <parentid>40123</parentid>
      <timestamp>2012-11-03T04:48:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="306">{{c/keyword/title|signed}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/types | {{tt|signed}} type modifier]]

[[de:c/keyword/signed]]
[[es:c/keyword/signed]]
[[fr:c/keyword/signed]]
[[it:c/keyword/signed]]
[[ja:c/keyword/signed]]
[[pt:c/keyword/signed]]
[[ru:c/keyword/signed]]
[[zh:c/keyword/signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/sizeof</title>
    <ns>0</ns>
    <id>9435</id>
    <revision>
      <id>44060</id>
      <parentid>40124</parentid>
      <timestamp>2012-11-03T04:46:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="302">{{c/keyword/title|sizeof}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/sizeof | {{tt|sizeof}} operator]]

[[de:c/keyword/sizeof]]
[[es:c/keyword/sizeof]]
[[fr:c/keyword/sizeof]]
[[it:c/keyword/sizeof]]
[[ja:c/keyword/sizeof]]
[[pt:c/keyword/sizeof]]
[[ru:c/keyword/sizeof]]
[[zh:c/keyword/sizeof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/static</title>
    <ns>0</ns>
    <id>9436</id>
    <revision>
      <id>62427</id>
      <parentid>44052</parentid>
      <timestamp>2013-06-28T12:43:57Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>Linkage of static keyword is different depending on the scope.</comment>
      <text xml:space="preserve" bytes="404">{{c/keyword/title|static}}
{{c/keyword/navbar}}

===Usage===
* [[c/language/storage_class_specifiers | static duration storage-class specifier]] with internal linkage at file scope and no linkage at block scope.

[[de:c/keyword/static]]
[[es:c/keyword/static]]
[[fr:c/keyword/static]]
[[it:c/keyword/static]]
[[ja:c/keyword/static]]
[[pt:c/keyword/static]]
[[ru:c/keyword/static]]
[[zh:c/keyword/static]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/struct</title>
    <ns>0</ns>
    <id>9437</id>
    <revision>
      <id>45809</id>
      <parentid>44047</parentid>
      <timestamp>2013-01-20T17:13:53Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>let's use struct for c</comment>
      <text xml:space="preserve" bytes="311">{{c/keyword/title|struct}}
{{c/keyword/navbar}}

===Usage===

* [[c/language/struct | declaration of a compound type]]

[[de:c/keyword/struct]]
[[es:c/keyword/struct]]
[[fr:c/keyword/struct]]
[[it:c/keyword/struct]]
[[ja:c/keyword/struct]]
[[pt:c/keyword/struct]]
[[ru:c/keyword/struct]]
[[zh:c/keyword/struct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/switch</title>
    <ns>0</ns>
    <id>9438</id>
    <revision>
      <id>44043</id>
      <parentid>40127</parentid>
      <timestamp>2012-11-03T04:41:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="340">{{c/keyword/title|switch}}
{{c/keyword/navbar}}
===Usage===

* [[c/language/switch | {{tt|switch}} statement]]: as the declaration of the statement

[[de:c/keyword/switch]]
[[es:c/keyword/switch]]
[[fr:c/keyword/switch]]
[[it:c/keyword/switch]]
[[ja:c/keyword/switch]]
[[pt:c/keyword/switch]]
[[ru:c/keyword/switch]]
[[zh:c/keyword/switch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/typedef</title>
    <ns>0</ns>
    <id>9439</id>
    <revision>
      <id>44041</id>
      <parentid>40128</parentid>
      <timestamp>2012-11-03T04:39:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="315">{{c/keyword/title|typedef}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/typedef | {{tt|typedef}} declaration]]

[[de:c/keyword/typedef]]
[[es:c/keyword/typedef]]
[[fr:c/keyword/typedef]]
[[it:c/keyword/typedef]]
[[ja:c/keyword/typedef]]
[[pt:c/keyword/typedef]]
[[ru:c/keyword/typedef]]
[[zh:c/keyword/typedef]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/union</title>
    <ns>0</ns>
    <id>9441</id>
    <revision>
      <id>44034</id>
      <parentid>40130</parentid>
      <timestamp>2012-11-03T04:38:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="296">{{c/keyword/title|union}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/union | declaration of a union type]]

[[de:c/keyword/union]]
[[es:c/keyword/union]]
[[fr:c/keyword/union]]
[[it:c/keyword/union]]
[[ja:c/keyword/union]]
[[pt:c/keyword/union]]
[[ru:c/keyword/union]]
[[zh:c/keyword/union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/unsigned</title>
    <ns>0</ns>
    <id>9442</id>
    <revision>
      <id>44030</id>
      <parentid>40131</parentid>
      <timestamp>2012-11-03T04:37:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="325">{{c/keyword/title|unsigned}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/types | {{tt|unsigned}} type modifier]]

[[de:c/keyword/unsigned]]
[[es:c/keyword/unsigned]]
[[fr:c/keyword/unsigned]]
[[it:c/keyword/unsigned]]
[[ja:c/keyword/unsigned]]
[[pt:c/keyword/unsigned]]
[[ru:c/keyword/unsigned]]
[[zh:c/keyword/unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/void</title>
    <ns>0</ns>
    <id>9443</id>
    <revision>
      <id>44027</id>
      <parentid>40132</parentid>
      <timestamp>2012-11-03T04:37:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="285">{{c/keyword/title|void}}
{{c/keyword/navbar}}

===Usage===
* [[c/language/function | {{tt|void}} specifier]]

[[de:c/keyword/void]]
[[es:c/keyword/void]]
[[fr:c/keyword/void]]
[[it:c/keyword/void]]
[[ja:c/keyword/void]]
[[pt:c/keyword/void]]
[[ru:c/keyword/void]]
[[zh:c/keyword/void]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/volatile</title>
    <ns>0</ns>
    <id>9444</id>
    <revision>
      <id>44022</id>
      <parentid>40133</parentid>
      <timestamp>2012-11-03T04:36:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="323">{{c/keyword/title|volatile}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/cv | {{tt|volatile}} type specifier]]

[[de:c/keyword/volatile]]
[[es:c/keyword/volatile]]
[[fr:c/keyword/volatile]]
[[it:c/keyword/volatile]]
[[ja:c/keyword/volatile]]
[[pt:c/keyword/volatile]]
[[ru:c/keyword/volatile]]
[[zh:c/keyword/volatile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/keyword/while</title>
    <ns>0</ns>
    <id>9440</id>
    <revision>
      <id>44017</id>
      <parentid>40129</parentid>
      <timestamp>2012-11-03T04:34:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="422">{{c/keyword/title|while}}
{{c/keyword/navbar}}
===Usage===
* [[c/language/while | {{tt|while}} loop]]: as the declaration of the loop
* [[c/language/do | {{tt|do-while}} loop]]: as the declaration of the terminating condition of the loop

[[de:c/keyword/while]]
[[es:c/keyword/while]]
[[fr:c/keyword/while]]
[[it:c/keyword/while]]
[[ja:c/keyword/while]]
[[pt:c/keyword/while]]
[[ru:c/keyword/while]]
[[zh:c/keyword/while]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language</title>
    <ns>0</ns>
    <id>6037</id>
    <revision>
      <id>71034</id>
      <parentid>70157</parentid>
      <timestamp>2014-06-04T20:22:09Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C++; descriptive name</comment>
      <text xml:space="preserve" bytes="4517">{{title|C language}}
{{c/language/navbar}}
This is a brief reference of available C constructs.

===General topics===

====[[cpp/preprocessor | Preprocessor]]====
====[[cpp/comment | Comments]]====
====[[c/keyword | Keywords]]====
====[[c/language/ascii | ASCII chart]]====

====[[cpp/language/escape | Escape sequences]]====
====[[c/language/history | History of C]]====

===Flow control===

====Conditional execution statements====

Different code paths are executed according to the value of given expression

* {{rl|if}} executes code conditionally
* {{rl|switch}} executes code according to the value of an integral argument

====Iteration statements====

The same code is executed several times

* {{rl|for}} executes loop 
* {{rl|while}} executes loop, checking condition before each iteration
* {{rl|do|do-while}} executes loop, checking condition after each iteration

====Jump statements====

Continue execution at a different location

* {{rl|continue}} skips the remaining part of the enclosing loop body
* {{rl|break}} terminates the enclosing loop
* {{rl|goto}} continues execution in another location
* {{rl|return}} terminates execution of the enclosing function

===Functions===

The same code can be reused at different locations in the program

* {{rl|function | function declaration}} declares a function
* {{rl|inline | inline specifier}} hints the compiler to insert a function's body directly into the calling code

===Types===

* {{rl|types | fundamental types}} defines basic character, integer and floating point types
* {{rl|pointer | pointer types}}, holding a memory location
* {{rl|struct | compound types}} defines types that can hold several data members
* {{rl|enum | enumeration types}} defines types that are able to hold only one of the specified values
* {{rl|union | union types}} defines types that can hold data in several representations
* {{rl|function | function types}} define function call signatures, that is the types of arguments and the return type

====Specifiers====

* {{rl|cv | cv specifiers}} specifies constness and volatility of a type
* {{rl|storage_class_specifiers | storage-class specifiers}} specifies storage duration and linkage of a type
* {{rl|alignas | alignas specifier}} specifies that the storage for the variable should be aligned by specific amount {{mark since c99}}
* {{rl|function_specifiers | function specifiers}} specifies how the compiler should handle a function {{mark since c99}}

====Literals====
Literals are the tokens of a C program that represent constant values, embedded in the source code.

* {{rl|integer_literal|integer literals}} are decimal, octal, or hexadecimal numbers of integer type.
* {{rl|character_literal|character literals}} are individual characters of type {{c|char}}, {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}}.
* {{rl|floating_literal|floating-point literals}} are values of type {{c|float}}, {{c|double}}, or {{c|long double}}
* {{rl|string_literal|string literals}} are sequences of characters, which may be narrow, multibyte, or wide.
* {{rl|bool_literal|boolean literals}} are values of type {{c|bool}}, that is {{c|true}} and {{c|false}} {{mark since c99}}
* {{rl|user_literal|user-defined literals}} are constant values of user-specified type {{mark since c99}}

====Expressions====
An expression is a sequence of operators and operands that specifies a computation. An expression can result in a value and can cause side effects.

* {{rl|eval_order|order of evaluation}} of arguments and subexpressions specifies the order in which intermediate results are obtained.
* {{rl|operators}} allow the use of syntax commonly found in mathematics
{{c/language/operators}}
* {{rl|operator_precedence | operator precedence}} is the order in which operators are bound to their arguments
* {{rl|operator_alternative | alternative representations}} exist for some of the operators

====Utilities====

; Types
* {{rl|typedef | typedef declaration}} creates a synonym for a type
* {{rl|attributes | attributes}} defines additional information about variable {{mark since c99}}
; Casts
* {{rl|implicit_cast | standard conversions}} implicit conversions from one type to another

===Miscellaneous===

* {{rl|main function}}
* {{rl|asm|Inline assembly}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/language |C++ language constructs}}
{{dsc end}}

[[de:c/language]]
[[es:c/language]]
[[fr:c/language]]
[[it:c/language]]
[[ja:c/language]]
[[ko:c/language]]
[[pt:c/language]]
[[ru:c/language]]
[[zh:c/language]]</text>
      <sha1>b6i8lp6pau0dtfqssqim2d51tri1pbe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/ascii</title>
    <ns>0</ns>
    <id>8404</id>
    <revision>
      <id>44007</id>
      <parentid>33184</parentid>
      <timestamp>2012-11-03T04:32:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="399">{{title|ASCII Chart}}
{{c/language/navbar}}
The following chart contains all 128 ASCII decimal '''(dec)''', octal '''(oct)''', hexadecimal '''(hex)''' and character '''(ch)''' codes.

{{cpp/language/ascii}}

[[de:c/language/ascii]]
[[es:c/language/ascii]]
[[fr:c/language/ascii]]
[[it:c/language/ascii]]
[[ja:c/language/ascii]]
[[pt:c/language/ascii]]
[[ru:c/language/ascii]]
[[zh:c/language/ascii]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/break</title>
    <ns>0</ns>
    <id>6044</id>
    <revision>
      <id>67926</id>
      <parentid>67853</parentid>
      <timestamp>2014-03-06T01:27:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C comment</comment>
      <text xml:space="preserve" bytes="1688">{{title|break statement}}
{{c/language/navbar}}
Causes the enclosing {{rlp|for}}, {{rlp|while}} or {{rlp|do|do-while}} loop or {{rlp|switch| switch statement}} to terminate.

Used when it is otherwise awkward to terminate the loop using the condition expression and conditional statements.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|break}} }}
{{sdsc end}}

===Explanation===

After this statement the control is transferred to the statement immediately following the enclosing loop. All automatic storage objects declared in enclosing loop are destroyed before the execution of the first line following the enclosing loop.

===Keywords===

{{ltt|c/keyword/break}}

===Example===
{{example 
 | code=
#include &lt;stdio.h&gt;

int main()
{
    int i = 2;
    switch (i) {
        case 1: printf(&quot;1&quot;);
        case 2: printf(&quot;2&quot;);   /* execution starts at this case label */
        case 3: printf(&quot;3&quot;);
        case 4:
        case 5: printf(&quot;45&quot;);
                break;         /* execution of subsequent cases is terminated */
        case 6: printf(&quot;6&quot;);
    }
 
    printf(&quot;\n&quot;);
 
    /* Compare outputs from these two double for loops. */
    int j,k;
    for (j = 0; j &lt; 2; j++) {
        for (k = 0; k &lt; 5; k++) {
            printf(&quot;%d%d &quot;, j,k);
        }
    }
    printf(&quot;\n&quot;);
    for (j = 0; j &lt; 2; j++) {
        for (k = 0; k &lt; 5; k++) {
            if (k == 2) break;
            printf(&quot;%d%d &quot;, j,k);
        }
    }
}
 | output=
2345
00 01 02 03 04 10 11 12 13 14 
00 01 10 11 
}}

[[de:c/language/break]]
[[es:c/language/break]]
[[fr:c/language/break]]
[[it:c/language/break]]
[[ja:c/language/break]]
[[pt:c/language/break]]
[[ru:c/language/break]]
[[zh:c/language/break]]</text>
      <sha1>olmyutbytg2a8pubrkk054nb0sspxdy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/continue</title>
    <ns>0</ns>
    <id>6043</id>
    <revision>
      <id>70232</id>
      <parentid>48932</parentid>
      <timestamp>2014-05-12T17:03:02Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1575">{{title|continue statement}}
{{c/language/navbar}}
Causes the remaining portion of the enclosing {{rlp|for}}, {{rlp|while}} or {{rlp|do | do-while}} loop body skipped.

Used when it is otherwise awkward to ignore the remaining portion of the loop using conditional statements.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|continue}}}}
{{sdsc end}}

===Explanation===

This statement works as a shortcut to the end of the enclosing loop body. 

In case of {{rlp|while}} or {{rlp|do | do-while}} loops, the next statement executed is the condition check ({{spar|cond_expression}}). In case of {{rlp|for}} loop, the next statements executed are the iteration expression and condition check ({{spar|iteration_expression}}, {{spar|cond_expression}}). After that the loop continues as normal.

===Keywords===

{{ltt|c/keyword/continue}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
 
int main(void) 
{
    for (int i = 0; i &lt; 10; i++) {
        if (i != 5) continue;
        printf(&quot;%d &quot;, i);       //this statement is skipped each time i!=5
    }
 
    printf(&quot;\n&quot;);
 
    for (int j = 0; j &lt; 2; j++) {
        for (int k = 0; k &lt; 5; k++) { //only this loop is affected by continue
            if (k == 3) continue;
            printf(&quot;%d%d &quot;, j, k);    //this statement is skipped each time k==3
        }
    }
}

 | output=
5
00 01 02 04 10 11 12 14
}}

[[de:c/language/continue]]
[[es:c/language/continue]]
[[fr:c/language/continue]]
[[it:c/language/continue]]
[[ja:c/language/continue]]
[[pt:c/language/continue]]
[[ru:c/language/continue]]
[[zh:c/language/continue]]</text>
      <sha1>m44amypmy3pb4an40dqkzai6xqmuh9h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/cv</title>
    <ns>0</ns>
    <id>13172</id>
    <revision>
      <id>70231</id>
      <parentid>68012</parentid>
      <timestamp>2014-05-12T17:00:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="3666">{{title|cv ({{small|const-volatility}}) specifiers and qualifiers}}
{{c/language/navbar}}

{{todo|content needed, possibly merge with restrict (it's crv-specifiers) or split}}

===Keywords===

{{ltt|cpp/keyword/const}}, 
{{ltt|cpp/keyword/volatile}}

===Example===
{{todo|merge/replace with a concise example}}
The keyword &quot;const&quot; turns a variable into a constant.  The constant must be initialized with a value at definition but not assigned a value later.  In this example, the compiler errors are as instructive as the clean code.
{{example
 |code=
#include &lt;stdio.h&gt;

int main(void)
{
    /* The pointer, the target of the pointer, or both may be const. */

    int i = 0;                                   /* A VARIABLE */
    int * ptr                            = &amp;i;
    int const * ptr_to_const             = &amp;i;
    int * const const_ptr                = &amp;i;
    int const * const const_ptr_to_const = &amp;i;
    const int* const c_p_t_c             = &amp;i;   /* also valid */
    
    *ptr = 1;                   /* AOK: modifies the target       */
    ptr  = NULL;                /* AOK: modifies the pointer      */
    *ptr_to_const = 0;          /* NOK: cannot modify the target  */
    ptr_to_const  = NULL;       /* AOK: modifies the pointer      */
    *const_ptr = 0;             /* AOK: modifies the target       */
    const_ptr  = NULL;          /* NOK: cannot modify the pointer */
    *const_ptr_to_const = 0;    /* NOK: cannot modify the target  */
    const_ptr_to_const  = NULL; /* NOK: cannot modify the pointer */
    
    const int j = 0;                             /* A CONSTANT               */
    int const jj = 0;                            /* also valid               */
    int * j_ptr                            = &amp;j; /* NOK: int* &lt;== const int* */
    int const * j_ptr_to_const             = &amp;j;
    int * const j_const_ptr                = &amp;j; /* NOK: int* &lt;== const int* */
    int const * const j_const_ptr_to_const = &amp;j;
    
    *j_ptr = 1;                   /* AOK: modifies the target       */
    j_ptr  = NULL;                /* AOK: modifies the pointer      */
    *j_ptr_to_const = 0;          /* NOK: cannot modify the target  */
    j_ptr_to_const  = NULL;       /* AOK: modifies the pointer      */
    *j_const_ptr = 0;             /* AOK: modifies the target       */
    j_const_ptr  = NULL;          /* NOK: cannot modify the pointer */
    *j_const_ptr_to_const = 0;    /* NOK: cannot modify the target  */
    j_const_ptr_to_const  = NULL; /* NOK: cannot modify the pointer */

    return 0;
}
 |p=true
 |output=
(none)
}}

===Example===
The keyword &quot;volatile&quot; prevents the compiler from optimizing out the do-nothing code of function f, and the run takes about 3 seconds.  Removing the keyword allows optimizing the double for loop, and the function really has nothing to do.
{{example
 |code=
#include &lt;stdio.h&gt;
#include &lt;time.h&gt;
 
/* Function f() performs some time-consuming work. */
void f()
{
    /* Keyword &quot;volatile&quot; tells the compiler not to assume that this function */
    /* is the only part of the system that could change variable d.           */
    volatile double d;
    int m,n;
    for (n=0; n&lt;10000; ++n)
       for (m=0; m&lt;10000; ++m)
           d += d*n*m;
}
 
int main(void)
{
    int i;
    clock_t t = clock();
    for (i=0;i&lt;3;++i) f();
    t = clock() - t;
    printf(&quot;Time used: %f seconds\n&quot;, ((float)t)/CLOCKS_PER_SEC);
    return 0;
}
 |p=true
 |output=
Time used: 3.040000 seconds
}}

[[de:c/language/while]]
[[es:c/language/while]]
[[fr:c/language/while]]
[[it:c/language/while]]
[[ja:c/language/while]]
[[pt:c/language/while]]
[[ru:c/language/while]]
[[zh:c/language/while]]</text>
      <sha1>ncqbnduh7uxjrqypxzbhgx00cdgbqch</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/do</title>
    <ns>0</ns>
    <id>6042</id>
    <revision>
      <id>70234</id>
      <parentid>67669</parentid>
      <timestamp>2014-05-12T17:06:19Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1557">{{title|do-while loop}}
{{c/language/navbar}}
Executes a loop.

Used where code needs to be executed several times while some condition is present. The code is executed at least once.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|do}} {{spar|loop_statement}} {{ttb|while (}} {{spar|cond_expression}} {{ttb|);}} }}
{{sdsc end}}

===Explanation===

{{spar|cond_expression}} shall be an expression, whose result is convertible to {{c|bool}}. It is evaluated after each execution of {{spar|loop_statement}}. The loop continues execution only if the {{spar|cond_expression}} evaluates to {{c|true}}.

If the execution of the loop needs to be terminated at some point, {{rlp|break | break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut.

===Keywords===

{{ltt|c/keyword/do}},
{{ltt|c/keyword/while}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
#define SIZE 8
 
int main(void)
{
    unsigned i = 0, array [SIZE];
 
    do
    {
        array [i] = rand() % 2;
        ++i;
    } while (i &lt; SIZE);
 
    printf(&quot;Array filled!\n&quot;);
 
    i = 0;
    do
    {
        printf(&quot;%d &quot;, array[i]);
        ++i;
    } while (i &lt; SIZE);
 
    printf(&quot;\n&quot;);
 
    return EXIT_SUCCESS;
}
 | output=
Array filled!
1 0 1 1 1 1 0 0
}}

[[de:c/language/do]]
[[es:c/language/do]]
[[fr:c/language/do]]
[[it:c/language/do]]
[[ja:c/language/do]]
[[pt:c/language/do]]
[[ru:c/language/do]]
[[zh:c/language/do]]</text>
      <sha1>h226g9k4vkuyo5lbfx4lbscv16ege7a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/eval order</title>
    <ns>0</ns>
    <id>8452</id>
    <revision>
      <id>71143</id>
      <parentid>71140</parentid>
      <timestamp>2014-06-07T02:31:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use function calls in the intro, like in the C++ page</comment>
      <text xml:space="preserve" bytes="6706">{{title|Order of evaluation}}
{{c/language/navbar}}

Order of evaluation of the operands of any C operator, including the order of evaluation of function arguments in a function-call expression, and the order of evaluation of the subexpressions within any expression is unspecified (except where noted below). The compiler will evaluate them in any order, and may choose another order when the same expression is evaluated again.

There is no concept of left-to-right or right-to-left evaluation in C, which is not to be confused with left-to-right and right-to-left associativity of operators: the expression {{tt|f1() + f2() + f3()}} is parsed as {{tt|(f1() + f2()) + f3()}} due to left-to-right associativity of operator+, but the function call to {{tt|f3}} may be evaluated first, last, or between {{tt|f1()}} or {{tt|f2()}} at run time.

===Definitions===
====Evaluations====
There are two kinds of evaluations performed by the compiler for each expression or subexpression (both of which are optional):
* ''value computation'': calculation of the value that is returned by the expression. This may involve determination of the identity of the object (lvalue evaluation) or reading the value previously assigned to an object (rvalue evaluation) 
* ''side effect'': access (read or write) to an object designated by a volatile glvalue, modification (writing) to an object, modifying a file, modifying the floating-point environment (if supported), or calling a function that does any of those operations.

If no side effects are produced by an expression and the compiler can determine that the value is not used, the expression is not evaluated.

====Ordering====
&quot;sequenced-before&quot; is an asymmetric, transitive, pair-wise relationship between evaluations within the same thread (it may extend across threads if atomic types and memory barriers are involved).

* If a sequence point is present between the subexpressions E1 and E2, then both value computation and side effects of E1 are sequenced before every value computation and side effect of E2
* If evaluation A is sequenced before evaluation B, then evaluation of A will be complete before evaluation of B begins. {{mark since c11}}
* If A is not sequenced before B and B is sequenced before A, then evaluation of B will be complete before evaluation of A begins. {{mark since c11}}
* If A is not sequenced before B and B is not sequenced before A, then two possibilities exist: {{mark since c11}}
** evaluations of A and B are unsequenced: they may be performed in any order and may overlap (within a single thread of execution, the compiler may interleave the CPU instructions that comprise A and B)
** evaluations of A and B are indeterminably-sequenced: they may be performed in any order but may not overlap: either A will be complete before B, or B will be complete before A. The order may be the opposite the next time the same expression is evaluated.

===Rules===
1) There is a sequence point after the evaluation of all function arguments and of the function designator, and before the actual function call.

2) The value computations (but not the side-effects) of the operands to any operator are sequenced before the value computation of the result of the operator (but not its side-effects). {{mark since c11}}

3) There is a sequence point after evaluation of the first (left) operand and before evaluation of the second (right) operand of the following binary operators: {{tt|&amp;&amp;}} (logical AND), {{tt|{{!!}}}} (logical OR), and {{tt|,}} (comma).

4) There is a sequence point after evaluation of the first (left) operand and before evaluation of the second or third operand (whichever is evaluated) of the conditional operator {{tt|?:}}

5) The side effect (modification of the left argument) of the direct assignment operator and of all compound assignment operators is sequenced after the value computation (but not the side effects) of both left and right arguments. {{mark since c11}}

6) The value computation of the postincrement and postdecrement operators is sequenced before its side-effect. {{mark since c11}}

7) There is a sequence point at the end of a full declarator. {{mark since c99}}

8) There is a sequence point after the evaluation of a full expression (an expression that is not a subexpression: typically something that ends with a semicolon or a controlling statement of if/switch/while/do) and before the next full expression.

9) There is a sequence point immediately before the return of a library function. {{mark since c99}}

10) There is a sequence point after the action associated with each conversion specifier in formatted I/O. {{mark since c99}}

11) There are sequence points before and immediately after each call to a comparison function made by the library functions {{lc|qsort}} and {{lc|bsearch}}, as well as between any call to the comparison function and the movement of the associated objects made by {{lc|qsort}} {{mark since c99}}

12) A function call that is not sequenced before or sequenced after another function call is indeterminately sequenced (CPU instructions that constitute different function calls cannot be interleaved, even if the functions are inlined) {{mark since c11}}

13) In initialization list expressions, all evaluations are indeterminately sequenced {{mark since c11}}

14) With respect to an indeterminately-sequenced function call, the operation of compound assignment operators, and both prefix and postfix forms of increment and decrement operators are single evaluations. {{mark since c11}}

===Undefined behavior===

1) If a side effect on a scalar object is unsequenced relative to another side effect on the same scalar object, the behavior is undefined.

{{c|1=
i = ++i + i++; // undefined behavior
i = i++ + 1; // undefined behavior
f(++i, ++i); // undefined behavior
f(i = -1, i = -1); // undefined behavior
}}

2) If a side effect on a scalar object is unsequenced relative to a value computation using the value of the same scalar object, the behavior is undefined.

{{c|1=
f(i, i++); // undefined behavior
a[i] = i++; // undefined bevahior
}}

3) The above rules apply as long as at least one allowable ordering of subexpressions permits such an unsequenced side-effect.

===See also===
[[c/language/operator_precedence|Operator precedence]] which defines how expressions are built from their source code representation.

{{dsc begin}}
{{dsc see cpp | cpp/language/eval_order | Order of evaluation}}
{{dsc end}}


[[de:c/language/eval order]]
[[es:c/language/eval order]]
[[fr:c/language/eval order]]
[[it:c/language/eval order]]
[[ja:c/language/eval order]]
[[pt:c/language/eval order]]
[[ru:c/language/eval order]]
[[zh:c/language/eval order]]</text>
      <sha1>0ktf20k0o3kdkzu38tnenox3dkqckiv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/for</title>
    <ns>0</ns>
    <id>6040</id>
    <revision>
      <id>70236</id>
      <parentid>48935</parentid>
      <timestamp>2014-05-12T17:25:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main to remove compiler errors; random() replaced with rand() to remove a compiler error</comment>
      <text xml:space="preserve" bytes="2410">{{title|for loop}}
{{c/language/navbar}}
Executes a loop.

Used as a shorter equivalent of {{rlp|while|while loop}}.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|for (}} {{spar|init_expression}} {{ttb|;}} {{spar|cond_expression}} {{ttb|;}} {{spar|iteration_expression}} {{ttb|)}} {{spar|loop_statement}} }}
{{sdsc end}}

===Explanation===

Unless there are any {{rlp|continue |continue statements}}, the above syntax produces code equivalent to:

{{sdsc begin}}
{{sdsc | 
{{ttb|{}}&lt;br&gt;
:{{spar|init_expression}} {{ttb|;}} &lt;br&gt;
:{{ttb|while (}} {{spar|cond_exression}} {{ttb|) {}} &lt;br&gt;
::{{spar|loop_statement}} &lt;br&gt;
::{{spar|iteration_expression}} {{ttb|;}} &lt;br&gt;
:{{ttb|} }}
{{ttb|} }}
}}
{{sdsc end}}

The {{spar|init_expression}} is executed before the execution of the loop. The {{spar|cond_expression}} shall evaluate to value, convertible to {{c|bool}}. It is evaluated before each iteration of the loop. The loop continues only if its value is {{c|true}}. The {{spar|loop_statement}} is executed on each iteration, after which {{spar|iteration_expression}} is executed.

If the execution of the loop needs to be terminated at some point, {{rlp|break | break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut. When there are &lt;code&gt;continue&lt;/code&gt;s in the loop body ({{spar|loop_statement}}), then each {{ltt|c/keyword/continue}} passes control to the {{spar|iteration_expression}} instead of passing to the next iteration. This way, at each iteration {{spar|iteration_expression}} is guaranteed to be executed (unless we {{ltt|c/keyword/break}} out of the loop).

===Keywords===

{{ltt|c/keyword/for}}

===Example===
{{example
 | The following example demonstrates the usage of the '''for''' loop in an array manipulation
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

#define SIZE 8

int main(void)
{
    unsigned i = 0, array [SIZE];

    for( ; i &lt; SIZE; ++i)
        array [i] = rand() % 2;

    printf(&quot;Array filled!\n&quot;);

    for (i = 0; i &lt; SIZE; ++i)
        printf(&quot;%d &quot;, array[i]);

    printf(&quot;\n&quot;);

    return EXIT_SUCCESS;
}
 | output=
Array filled!
1 0 1 1 1 1 0 0
}}

[[de:c/language/for]]
[[es:c/language/for]]
[[fr:c/language/for]]
[[it:c/language/for]]
[[ja:c/language/for]]
[[pt:c/language/for]]
[[ru:c/language/for]]
[[zh:c/language/for]]</text>
      <sha1>qtlv3ezbq9bcntznb7th88psbe91zxb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/function specifier</title>
    <ns>0</ns>
    <id>9602</id>
    <redirect title="c/language/function specifiers" />
    <revision>
      <id>44687</id>
      <timestamp>2012-11-12T17:01:39Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>moved [[c/language/function specifier]] to [[c/language/function specifiers]]: More accurate name.</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[c/language/function specifiers]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/function specifiers</title>
    <ns>0</ns>
    <id>9601</id>
    <revision>
      <id>70238</id>
      <parentid>69514</parentid>
      <timestamp>2014-05-12T17:35:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="3601">{{title|Function specifiers}}
{{c/language/navbar}}

Used in the declaration of functions.
{{todo|split into two pages}}

:*{{ttb|inline}} {{mark since c99}} - suggestion to the compiler to &quot;inline&quot; the function, making calls to it as fast as possible.
:*{{ttb|_Noreturn}} {{mark since c11}} - specifies that the function does not return to where it was called from.

===Syntax===
{{sdsc begin}}
{{sdsc  | {{c|inline}} {{spar|function_declaration}} }}
{{sdsc  | {{c|_Noreturn}} {{spar|function_declaration}} }}
{{sdsc end}}

===Explanation===

====inline {{mark since c99}}====
The {{ttb|inline}} keyword is a hint given to the compiler to perform an optimization. The compiler has the freedom to ignore this request.

If the compiler inlines the function, it replaces every call of that function with the actual body (without generating a call).
This avoids extra overhead created by the function call (placing data on stack and retrieving the result) but it may result in a larger executable as the code for the function has to be repeated multiple times.
The result is similar to [[c/preprocessor/replace|function-like macros]].

The function body must be visible in the current translation unit, which makes the {{ttb|inline}} keyword necessary to implement functions inside a header file, i.e. without having a source file that has to be compiled and linked.

===inline Example===
With inlining turned off, run time is about 1.70 seconds. With inlining turned on, run time is less than a second.
{{example
|code=
/*
inline int sum(int a, int b) {
  return (a + b);
}

int c = sum(1, 4);
// If the compiler inlines the function the compiled code will be the same as writing:
int c = 1 + 4;
*/

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;time.h&gt;

/* int sum (int a, int b) __attribute__ ((noinline)); */

static inline
int sum (int a, int b)
{
  return a+b;
}

int main(void)
{
    const int SIZE = 100000;
    int X[SIZE],Y[SIZE],A[SIZE];
    int i,j;
    for (i=0;i&lt;SIZE;++i) {
        X[i] = rand();
        Y[i] = rand();
    }
    
    clock_t t = clock();   /* start clock */
    for (i=0;i&lt;5000;++i) {
        for (j=0;j&lt;SIZE;++j)
            A[j] = sum(X[j],Y[j]);
    }
    t = clock()-t;         /* stop clock  */

    printf(&quot;Time used: %f seconds\n&quot;, ((float)t)/CLOCKS_PER_SEC);
    printf(&quot;%d\n&quot;, A[0]);
    return EXIT_SUCCESS;
}
 | p=true
 | output=
Time used: 0.750000 seconds
-1643747027
}}

====_Noreturn {{mark since c11}}====
The {{ttb|_Noreturn}} keyword states that the function that follows it does not return to the function that it was called from. The compiler will typically generate a warning if a function declared with {{ttb|_Noreturn}} attempts to return a value.

In the example below the {{c|stop_now()}} function is called, which causes the program to immediately terminate (unless the [[c/program/SIG_types | {{tt|SIGABRT}}]] signal is caught).  The code with the {{c|printf()}} and the {{c|return EXIT_SUCCESS;}} after the call to {{c|stop_now()}} is never executed and the execution never returns to the {{c|main()}} function, where {{c|stop_now()}} was called from.

===_Noreturn Example===
{{example
|code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

_Noreturn void stop_now() {
  abort();
}

int main(void)
{
  printf(&quot;Preparing to stop...\n&quot;);

  stop_now();

  printf(&quot;This code is never executed.\n&quot;);

  return EXIT_SUCCESS;

}
 | output=
Preparing to stop...
Abort
}}

===Keywords===
{{ltt|c/keyword/inline}},
{{ltt|c/keyword/_Noreturn}}

===See Also===
[[c/language/storage_class_specifiers | Storage class specifiers]],
[[c/program/abort | abort()]]</text>
      <sha1>7qn36atjoxrcbdr2rkkgiqgzdd6thpc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/goto</title>
    <ns>0</ns>
    <id>6045</id>
    <revision>
      <id>70237</id>
      <parentid>67751</parentid>
      <timestamp>2014-05-12T17:28:13Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2547">{{title|goto statement}}
{{c/language/navbar}}
Transfers control unconditionally to the desired location.

Used when it is otherwise impossible to transfer control to the desired location using conventional constructs.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|goto}} {{spar|label}} }}
{{sdsc | {{spar|label}} {{ttb|:}} }}
{{sdsc end}}

===Explanation===

The goto statement transfers control to the location, specified by {{spar|label}}. The goto statement must be in the same function as the {{spar|label}} it is referring. If goto statement transfers control backwards, all objects, that are not yet initialized at the {{spar|label}} are destructed. It is not allowed to transfer control forwards if doing so would skip initialization of an object.

A label name is an identifier followed by a colon (:) and a statement.  A label name has function scope.

===Keywords===

{{ltt|c/keyword/goto}}

===Example===
{{example
 | code=
/* Using 'goto' in the contexts of the three control structures of structured */
/* programming: sequence, branch, and loop.                                   */

#include &lt;stdio.h&gt;

int main(void)
{
    /* Sequence control structure       */
    /* Exhibits an example of an error. */
/*    goto label_1;
    {  
     int i=888;   error: crosses initialization of 'int i'
     label_1:
     printf(&quot;i = %d\n&quot;, i);
    }
*/
    
    /* Branch control structure                                              */
    /* The break statement is usually used here, but 'goto' can redirect to  */
    /* any location.                                                         */
    int sw = 2;    
    switch (sw)    // integral expression
           { case 1:  printf(&quot;case 1\n&quot;);
                      goto label_2;   // end case 1
             case 2:  printf(&quot;case 2\n&quot;);
                      goto label_2;   // end case 2
             case 3:  printf(&quot;case 3\n&quot;);
                      goto label_2;   // end case 3
           }
    label_2: ;
  
    /* Loop control structure                                    */
    /* Using two 'goto' statements to simulate &quot;while (i&lt;5) {}&quot;. */
    int i = 0;
    top_of_loop:
    if (!(i&lt;5)) goto label_3;
        printf(&quot;i = %d\n&quot;, i);
        ++i;
        goto top_of_loop;
        
    label_3:
    printf(&quot;exit\n&quot;);
    return 0;
}
 | output=
case 2
i = 0
i = 1
i = 2
i = 3
i = 4
exit
}}

[[de:c/language/goto]]
[[es:c/language/goto]]
[[fr:c/language/goto]]
[[it:c/language/goto]]
[[ja:c/language/goto]]
[[pt:c/language/goto]]
[[ru:c/language/goto]]
[[zh:c/language/goto]]</text>
      <sha1>dmfhbq238f2he8s1xcojqc3vixe5s59</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/history</title>
    <ns>0</ns>
    <id>8449</id>
    <revision>
      <id>72407</id>
      <parentid>72108</parentid>
      <timestamp>2014-08-19T21:13:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix typo in 2011 std name</comment>
      <text xml:space="preserve" bytes="4532">{{title|History of C}}
{{c/language/navbar}}

==Early C==
* 1969: B created, based on BCPL, to replace PDP-7 assembler as the system programming language for Unix
:* added operators ++, --, compound assignment, remained a typeless language like BCPL
* 1971: NB (&quot;new B&quot;) created when porting B to PDP-11
:* types (int, char, arrays and pointers), array-to-pointer conversion, compilation to machine code
* 1972: Language renamed to C
:* structs, operators &amp;&amp; and ||, preprocessor, portable I/O
* 1973: Unix re-written in C
:* unsigned, long, unions, enumerations, increased type safety
* 1978: The C Programming Language, 1st edition

==Standard C==
* 1983: ANSI established X3J11 committee
* 1988: The C Programming Language, 2nd edition
* 1989: {{ttb|C89}}, the ANSI C standard published
# codified existing practices
# new features: volatile, enum, signed, void
# From C++: const, function prototypes
* 1990: the ANSI standard accepted as ISO/IEC 9899-1990
* 1995: {{ttb|C95}} (ISO/IEC 9899 AM1)
# multibyte character support (wchar_t and all wide and multibyte character functions, wchar.h, wctype.h, and those added to existing headers and corresponding changes to stream I/O, etc)
# digraphs, iso646.h, 
* 1995: Technical corrigendum 1 (ISO/IEC 9899 TCOR1)
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/tc1.htm 44 small changes]
* 1996: Technical corrigendum 2 (ISO/IEC 9899 TCOR2)
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/tc2.htm 24 small changes]
* 1999: {{ttb|C99}} (ISO/IEC 9899:1999)
# new features: bool, long long, stdint.h, inttypes.h, restrict, compound literals, variable length arrays, flexible array members, designated initializers, fenv.h, variadic macros, complex numbers, __func__, hexadecimal floating point format (%a), monetary formatting in lconv, isblank, concatenation of narrow and wide string literals, trailing comma in enumerations, empty arguments in function-like macros, STDC_* pragmas, va_copy, null return of tmpnam, null pointer in setvbuf, hh and ll lengthspecifiers in printf, snprintf, _Exit, tgmath.h, POSIX-like strftime specifiers
# from C++: inline, mix declarations and code, declarations in the init clause of the for loop, {{ttb|//}} comments, universal character names in source code
# removed implicit functions and implicit int
* 2001: Technical corrigendum 1 (ISO/IEC 9899:1999/Cor.1:2001(E))
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/9899tc1/ 11 defects fixed]
* 2004: Technical corrigendum 2 (ISO/IEC 9899:1999/Cor.2:2004(E))
* 2004: Unicode TR (ISO/IEC TR 19769:2004)
* 2007: Technical corrigendum 3 (ISO/IEC 9899:1999/Cor.3:2007(E)) ([http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf September 7, 2007 draft])
:* deprecated {{lc|gets}}
* 2007: Bounds-checking interfaces TR (ISO/IEC TR 24731-1:2007)
* 2009: Decimal floating-point TR (ISO/IEC TR 24732:2009)
* 2010: Dynamic allocations functions TR (ISO/IEC TR 24731-2:2010)
* 2011: {{ttb|C11}} (ISO/IEC 9899:2011) ([http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf April 12, 2011 draft])
# thread-aware memory model, stdatomic.h, threads.h, type-generic functions, alignas/alignof, noreturn, static assert, analyzability extensions, extensions to complex and imaginary types, anonymous structures and unions, exclusive file open mode. quick_exit
# removed {{lc|gets}}
# from Bounds-checking interfaces TR: bounds-checking interfaces, 
# from Unicode TR: char16_t, char32_t, and uchar.h
* 2012: Technical corrigendum 1 (ISO/IEC 9899:2011/Cor 1:2012)
:* 2 minor bug fixes
* 2013: Secure Coding Rules TS (ISO/IEC TS 17961:2013) ([http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1624.pdf 2012 draft])
===Future development===
* Floating-point extensions TS (ISO/IEC TS 18661, supersedes ISO/IEC TR 24732:2009). 2013/2014 drafts:
:* [http://www.open-std.org/JTC1/sc22/wg14/www/docs/n1778.pdf part 1 (final)]
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1814.pdf part 2 (final)]
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1833.pdf part 3 (PDTS)]
:* [http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1835.pdf part 4 (PDTS)]
:* part 5

===References===
* [http://cm.bell-labs.com/cm/cs/who/dmr/chist.html The Development of the C Language] by Dennis M. Ritchie
* [http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf Rationale for the C99 standard]

[[de:c/language/history]]
[[es:c/language/history]]
[[fr:c/language/history]]
[[it:c/language/history]]
[[ja:c/language/history]]
[[pt:c/language/history]]
[[ru:c/language/history]]
[[zh:c/language/history]]</text>
      <sha1>d78ex2j87sffuomvqcmf6cl6b61jsse</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/if</title>
    <ns>0</ns>
    <id>6038</id>
    <revision>
      <id>70235</id>
      <parentid>67666</parentid>
      <timestamp>2014-05-12T17:08:29Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1333">{{title|if statement}}
{{c/language/navbar}}
Conditionally executes code.

Used where code needs to be executed only if some condition is present.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|if (}} {{spar|expression}} {{ttb|)}} {{spar|statement_true}} }}
{{sdsc | {{ttb|if (}} {{spar|expression}} {{ttb|)}} {{spar|statement_true}} {{ttb|else}} {{spar|statement_false}} }}
{{sdsc end}}

===Explanation===

{{spar|expression}} shall be an expression, convertible to {{c|bool}}.

If it evaluates to {{c|true}}, control is passed to {{spar|statement_true}}, {{spar|statement_false}} (if present) is not executed.

Otherwise, control is passed to {{spar|statement_false}}, {{spar|statement_true}} is not executed.

===Keywords===

{{ltt|c/keyword/if}},
{{ltt|c/keyword/else}}

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
 
int main(void)
{
    int i = 2;
    if (i &gt; 2) {
        printf(&quot;first is true\n&quot;);
    } else {
        printf(&quot;first is false\n&quot;);
    }
 
    i = 3;
    if (i == 3) printf(&quot;i == 3\n&quot;);
 
    if (i != 3) printf(&quot;i != 3 is true\n&quot;);
    else        printf(&quot;i != 3 is false\n&quot;);
}

 | output=
first is false
i == 3
i != 3 is false
}}

[[de:c/language/if]]
[[es:c/language/if]]
[[fr:c/language/if]]
[[it:c/language/if]]
[[ja:c/language/if]]
[[pt:c/language/if]]
[[ru:c/language/if]]
[[zh:c/language/if]]</text>
      <sha1>rx7e41im3yld9t5ixq0w8uz8qig8q9o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/linkage</title>
    <ns>0</ns>
    <id>9548</id>
    <revision>
      <id>43952</id>
      <parentid>41272</parentid>
      <timestamp>2012-11-03T04:21:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="382">{{title|Linkage of identifiers}}
{{c/language/navbar}}

There are three kinds of linkage:
:*{{ttb|external}} -
:*{{ttb|internal}} -
:*{{ttb|none}} -

===Example===

{{todo}}

[[de:c/language/linkage]]
[[es:c/language/linkage]]
[[fr:c/language/linkage]]
[[it:c/language/linkage]]
[[ja:c/language/linkage]]
[[pt:c/language/linkage]]
[[ru:c/language/linkage]]
[[zh:c/language/linkage]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/main function</title>
    <ns>0</ns>
    <id>13522</id>
    <revision>
      <id>72088</id>
      <parentid>72054</parentid>
      <timestamp>2014-07-13T20:57:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>initial cap, period</comment>
      <text xml:space="preserve" bytes="5206">{{title|Main function}}
{{c/language/navbar}}

Every C program contains the definition (not the prototype) of a function called {{ttb|main}}, which is the designated start of the program.

{{sdsc begin}}
{{sdsc|num=1|1=
{{c|int}} {{ttb|main}} {{ttb|(void)}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc|num=2|1=
{{c|int}} {{ttb|main}} {{ttb|(}}{{c|int}} {{spar|argc}}{{ttb|,}} {{c|char}} {{c|*}}{{spar|argv}}{{c|[]}}{{ttb|)}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc|num=3|1=
{{c|int}} {{ttb|main}} {{ttb|(}}{{c|int}} {{spar|argc}}{{ttb|,}} {{c|char}} {{c|*}}{{spar|argv}}{{c|[]}}  {{ttb|,}} {{spar|other_parameters}} {{ttb|)}}  {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc|num=4|1={{c|/* another implementation-defined signature */}}
}}
{{sdsc end}}


===Parameters===
{{par begin}}
{{par | argc | Non-negative value representing the number of arguments passed to the program from the environment in which the program is run.}}
{{par | argv | Pointer to an array of pointers to null-terminated multibyte strings that represent the arguments passed to the program from the execution environment ({{c|argv[0]}} through {{c|argv[argc-1]}}). The value of {{c|argv[argc]}} is guaranteed to be {{c|0}}.}}
{{par | body | The body of the main function}}
{{par | {{spar|other_parameters}} | Implementations may allow additional forms of the main function. A very common extension is passing a third argument of type {{tt|char*[]}} pointing at [http://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html an array of pointers to the execution environment variables].}}
{{par end}}

The names {{tt|argc}} and {{tt|argv}} are arbitrary, as well as the representation of the types of the parameters: {{c|int main(int ac, char** av)}} is equally valid.

===Return value===
If the return statement is used, the return value is used as the argument to the implicit call to {{lc|exit()}} (see below for details). The values zero and {{lc|EXIT_SUCCESS}} indicate successful termination, the value {{lc|EXIT_FAILURE}} indicates unsuccessful termination.

===Explanation===
The {{tt|main}} function is called at program startup, after all objects with static storage duration are initialized. It is the designated entry point to a program that is executed in ''hosted'' environment (that is, with an operating system). The name and type of the entry point to any ''freestanding'' program (boot loaders, OS kernels, etc) are implementation-defined.

The parameters of the two-parameter form of the main function allow arbitrary multibyte character strings to be passed from the execution environment (these are typically known as ''command line arguments''). The pointers {{tt|argv[1] .. argv[argc-1]}} point at the first characters in each of these strings. {{tt|argv[0]}} is the pointer to the initial character of a null-terminated multibyte strings that represents the name used to invoke the program itself (or, if this is not supported by the execution environment, argv[0][0] is guaranteed to be zero). 

If the execution environment cannot distinguish between uppercase and lowercase letters, the command line arguments are converted to lower case.

The strings are modifiable, and any modifications made persist until program termination, although these modifications do not propagate back to the execution environment: they can be used, for example, with {{lc|strtok}}.

The size of the array pointed to by {{tt|argv}} is at least {{tt|argc+1}}, and the last element, {{tt|argv[argc]}}, is guaranteed to be a null pointer.

The {{tt|main}} function has several special properties:
@1@ A prototype for this function cannot be supplied by the program
@2@ If the return type of the main function is compatible to {{c|int}}, then the return from the initial call to main (but not the return from any subsequent, recursive, call) is equivalent to executing the {{lc|exit}} function, with the value that the main function is returning passed as the argument (which then calls the functions registered with {{lc|atexit}}, flushes and closes all streams, and deletes the files created with {{lc|tmpfile}}, and returns control to the execution environment).
@3@ If the return type of the main function is not compatible with {{c|int}} (e.g. {{c|void main(void))}}, the value returned to the execution environment is unspecified
@4@ The body of the main function does not need to contain the {{rlp|return|return statement}}: if control reaches the end of {{tt|main}} without encountering a return statement, the effect is that of executing {{c|return 0;}}.

===Example===
{{example
 | Demonstrates how to inform a program about where to find its input and where to write its results.
Invocation: ./a.out indatafile outdatafile
 | code=
#include &lt;stdio.h&gt;

int main(int argc, char *argv[])
{
    printf(&quot;argc = %d\n&quot;, argc);
    int ndx = 0;
    while (ndx &lt; argc)
    {
          printf(&quot;argv[%d] --&gt; %s\n&quot;, ndx,argv[ndx]);
          ++ndx;
    }
    printf(&quot;argv[argc] = %s\n&quot;, argv[argc]);
    return 0;
}
 | p=true
 | output=
argc = 3
argv[0] --&gt; ./a.out
argv[1] --&gt; indatafile
argv[2] --&gt; outdatafile
argv[argc] = (null)
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/language/main function}}
{{dsc end}}</text>
      <sha1>t80zb6yx0gdgmn5jh0rqpti1wogabuq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator alternative</title>
    <ns>0</ns>
    <id>9975</id>
    <revision>
      <id>72244</id>
      <parentid>72241</parentid>
      <timestamp>2014-07-29T01:42:03Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>confusing comment</comment>
      <text xml:space="preserve" bytes="3289">{{title|Alternative operator representations {{mark since c99}}}}
{{c/language/navbar}}

C source code may be written in any non-ASCII 7-bit character set that includes the [[enwiki:ISO 646|ISO 646:1983]] invariant character set. However, several C operators and punctuators require characters that are outside of the ISO 646 codeset: {{tt|{, }, [, ], #, \, ^, {{!}}, ~}}. To be able to use character encodings where some or all of these symbols do not exist (such as the German [http://de.wikipedia.org/wiki/DIN_66003 DIN 66003]), there are two possibilities: alternative spellings of operators that use these characters or special combinations of two or three ISO 646 compatible characters that are interpreted as if they were a single non-ISO 646 character.

==Alternative spellings==

There are alternative spellings for several operators defined in {{ttb|&lt;iso646.h&gt;}}. 

{{dsc begin}}
{{dsc header | iso646.h}}
{{dsc hitem | Primary | Alternative }}
{{dsc macro const | {{tt|&amp;&amp;}} | {{tt|and}} | nolink=true}}
{{dsc macro const | {{tt|&amp;{{=}}}} | {{tt|and_eq}} | nolink=true}}
{{dsc macro const | {{tt|&amp;}} | {{tt|bitand}} | nolink=true}}
{{dsc macro const | {{tt|&amp;#124;}} | {{tt|bitor}} | nolink=true}}
{{dsc macro const | {{tt|~}} | {{tt|compl}} | nolink=true}}
{{dsc macro const | {{tt|!}} | {{tt|not}} | nolink=true}}
{{dsc macro const | {{tt|!{{=}}}} | {{tt|not_eq}} | nolink=true}}
{{dsc macro const | {{tt|&amp;#124;&amp;#124;}} | {{tt|or}} | nolink=true}}
{{dsc macro const | {{tt|&amp;#124;{{=}}}} | {{tt|or_eq}} | nolink=true}}
{{dsc macro const | {{tt|^}} | {{tt|xor}} | nolink=true}}
{{dsc macro const | {{tt|^{{=}}}} | {{tt|xor_eq}} | nolink=true}}
{{dsc end}}

==Digraphs and trigraphs==

The following combinations of two and three characters (digraphs and trigraphs) are valid substitutions for their respective primary characters:

{| class=&quot;wikitable&quot;
|- style=&quot;text-align: left;&quot;
! Primary
! Digraph
! Trigraph
|-
| {{tt|{}} || {{tt|&lt;%}} || {{tt|??&lt;}}
|-
| {{tt|}}} || {{tt|%&gt;}} || {{tt|??&gt;}}
|-
| {{tt|[}} || {{tt|&lt;:}} || {{tt|??(}}
|-
| {{tt|]}} || {{tt|:&gt;}} || {{tt|??)}}
|-
| {{tt|#}} || {{tt|%:}} || {{tt|??{{=}}}}
|-
| {{tt|\}} || || {{tt|??/}}
|-
| {{tt|^}} || || {{tt|??'}}
|-
| {{tt|&lt;nowiki&gt;|&lt;/nowiki&gt;}} || || {{tt|??!}}
|-
| {{tt|~}} || || {{tt|??-}}
|}

Note that trigraphs (but not digraphs) are {{rlp|translation_phases|parsed before comments and string literals are recognized}}, so a comment such as {{c|// Will the next line be executed?????/}} will effectively comment out the following line, and the string literal such as {{c|&quot;What's going on??!&quot;}} is parsed as {{c|&quot;What's going on{{!}}&quot;}}.

===Example===

{{example
 | The following example demonstrates alternative operator spellings from the {{ttb|&lt;iso646.h&gt;}} header as well as use of digraphs and trigraphs.
The space character in the first command-line argument, argv[1], requires the quotation marks: &quot;, World!&quot;.
 | code=
%:include &lt;stdlib.h&gt;
%:include &lt;stdio.h&gt;
%:include &lt;iso646.h&gt;

int main(int argc, char** argv)
??&lt;
    if (argc &gt; 1 and argv&lt;:1:&gt; not_eq NULL)
    &lt;%
       printf(&quot;Hello%s\n&quot;, argv&lt;:1:&gt;);
    %&gt;

    return EXIT_SUCCESS;
??&gt;
 | p=true
 | output=
Hello, World!
}}

{{dsc begin}}
{{dsc see cpp | cpp/language/operator_alternative | Alternative operator representations}}
{{dsc end}}</text>
      <sha1>i0uuu7q3an4gpnpfs8ef5mgiyyfxiz0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator arithmetic</title>
    <ns>0</ns>
    <id>9564</id>
    <revision>
      <id>41445</id>
      <timestamp>2012-10-26T14:20:36Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>Creating C Arithmetic operators page.</comment>
      <text xml:space="preserve" bytes="1747">{{title|Arithmetic operators}}
{{c/language/navbar}}
Arithmetic operators apply standard mathematical operations to their operands.


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Result
|- style=&quot;text-align:center&quot;
| {{c|1=+}}
| unary plus
| {{c|1=+a}}
| the value of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=-}}
| unary minus
| {{c|1=-a}}
| the negative of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=+}}
| addition
| {{c|1=a + b}}
| the addition of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=-}}
| subtraction
| {{c|1=a - b}}
| the subtraction of '''b''' from '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=*}}
| product
| {{c|1=a * b}}
| the product of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=/}}
| division
| {{c|1=a / b}}
| the division of '''a''' by '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=%}}
| modulo
| {{c|1=a % b}}
| the remainder of '''a''' divided by '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=~}}
| bitwise NOT
| {{c|1=~a}}
| the bitwise NOT of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=&amp;}}
| bitwise AND
| {{c|1=a &amp; b}}
| the bitwise AND of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1={{!}}}}
| bitwise OR
| {{c|1=a {{!}} b}}
| the bitwise OR of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=^}}
| bitwise XOR
| {{c|1=a ^ b}}
| the bitwise XOR of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&lt;&lt;}}
| bitwise left shift
| {{c|1=a &lt;&lt; b}}
| '''a''' left shifted by '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&gt;&gt;}}
| bitwise right shift
| {{c|1=a &gt;&gt; b}}
| '''a''' right shifted by '''b'''
|}

===See Also===

[[c/language/operator_precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator assignment</title>
    <ns>0</ns>
    <id>9562</id>
    <revision>
      <id>41444</id>
      <parentid>41442</parentid>
      <timestamp>2012-10-26T13:58:09Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2235">{{title|Assignment operators}}
{{c/language/navbar}}
Assignment operators are binary operators that modify the variable to their left using the value to their right.


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Description
! Equivalent of
|- style=&quot;text-align:center&quot;
| {{c|1==}}
| basic assignment
| {{c|1=a = b}}
| '''a''' becomes equal to '''b'''
| {{n/a}}
|- style=&quot;text-align:center&quot;
| {{c|1=+=}}
| addition assignment
| {{c|1=a += b}}
| '''a''' becomes equal to the addition of '''a''' and '''b'''
| {{c|1=a = a + b}}
|- style=&quot;text-align:center&quot;
| {{c|1=-=}}
| subtraction assignment
| {{c|1=a -= b}}
| '''a''' becomes equal to the subtraction of '''b''' from '''a'''
| {{c|1=a = a - b}}
|- style=&quot;text-align:center&quot;
| {{c|1=*=}}
| multiplication assignment
| {{c|1=a *= b}}
| '''a''' becomes equal to the product of '''a''' and '''b'''
| {{c|1=a = a * b}}
|- style=&quot;text-align:center&quot;
| {{c|1=/=}}
| division assignment
| {{c|1=a /= b}}
| '''a''' becomes equal to the division of '''a''' by '''b'''
| {{c|1=a = a / b}}
|- style=&quot;text-align:center&quot;
| {{c|1=%=}}
| modulo assignment
| {{c|1=a %= b}}
| '''a''' becomes equal to the remainder of '''a''' divided by '''b'''
| {{c|1=a = a % b}}
|- style=&quot;text-align:center&quot;
| {{c|1=&amp;=}}
| bitwise AND assignment
| {{c|1=a &amp;= b}}
| '''a''' becomes equal to the bitwise AND of '''a''' and '''b'''
| {{c|1=a = a &amp; b}}
|- style=&quot;text-align:center&quot;
| {{c|1={{!}}=}}
| bitwise OR assignment
| {{c|1=a {{!}}= b}}
| '''a''' becomes equal to the bitwise OR of '''a''' and '''b'''
| {{c|1=a = a {{!}} b}}
|- style=&quot;text-align:center&quot;
| {{c|1=^=}}
| bitwise XOR assignment
| {{c|1=a ^= b}}
| '''a''' becomes equal to the bitwise XOR of '''a''' and '''b'''
| {{c|1=a = a ^ b}}
|- style=&quot;text-align:center&quot;
| {{c|1=&lt;&lt;=}}
| bitwise left shift assignment
| {{c|1=a &lt;&lt;= b}}
| '''a''' becomes equal to '''a''' left shifted by '''b'''
| {{c|1=a = a &lt;&lt; b}}
|- style=&quot;text-align:center&quot;
| {{c|1=&gt;&gt;=}}
| bitwise right shift assignment
| {{c|1=a &gt;&gt;= b}}
| '''a''' becomes equal to '''a''' right shifted by '''b'''
| {{c|1=a = a &gt;&gt; b}}
|}

===See Also===

[[c/language/operator_precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator comparison</title>
    <ns>0</ns>
    <id>9566</id>
    <revision>
      <id>41447</id>
      <timestamp>2012-10-26T14:48:44Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>Creating C Comparison operators page.</comment>
      <text xml:space="preserve" bytes="1124">{{title|Comparison operators}}
{{c/language/navbar}}
Comparison operators are binary operators that test a condition and return '''1''' if that condition is logically '''true''' and '''0''' if that condition is '''false'''..


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Description
|- style=&quot;text-align:center&quot;
| {{c|1===}}
| equal to
| {{c|1=a == b}}
| '''a''' is equal to '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=!=}}
| not equal to
| {{c|1=a != b}}
| '''a''' is not equal to '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&lt;}}
| less than
| {{c|1=a &lt; b}}
| '''a''' is less than '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&gt;}}
| greater than
| {{c|1=a &gt; b}}
| '''a''' is greater than '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&lt;=}}
| less than or equal to
| {{c|1=a &lt;= b}}
| '''a''' is less than or equal to '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1=&gt;=}}
| greater than or equal to
| {{c|1=a &gt;= b}}
| '''a''' is greater than or equal to '''b'''
|}

===See Also===

[[c/language/operator_precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator incdec</title>
    <ns>0</ns>
    <id>9563</id>
    <revision>
      <id>46437</id>
      <parentid>41443</parentid>
      <timestamp>2013-03-10T21:17:07Z</timestamp>
      <contributor>
        <ip>77.248.51.142</ip>
      </contributor>
      <comment>top of page postfix and prefix were switched</comment>
      <text xml:space="preserve" bytes="2255">{{title|Increment/decrement operators}}
{{c/language/navbar}}
Increment/decrement operators are unary operators that increment/decrement the value of a variable by 1. 

They can be applied either postfix:

{{c|1=a++
a--}}

or prefix:

{{c|1=++a
--a}}

The returned result of the postfix version of the operator is the original operand, with a side-effect being that the operand is incremented/decremented '''after''' this result is returned.

The returned result of the prefix version of the operator is the incremented/decremented operand.

Therefore, the following lines all result in '''a''' being incremented by 1:

{{c|1=a = a + 1;
a += 1;
a++;
++a;}}

'''But''', the value of '''b''' is not equal to the value of '''c''' after the execution of the following lines:

{{c|1=int a = 1;
int b = a++; // after execution: a equals 2, b equals 1
a = 1;
int c = ++a; // after execution: a equals 2, c equals 2}}

===Example===
{{example
 |
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

int main(void) {

  int a = 1;
  int b = 1;

  // Behaviour of the postfix increment and decrement operators.
  printf(&quot;\n&quot;);
  printf(&quot;original values: a == %d, b == %d\n&quot;, a, b);
  printf(&quot;result of postfix operators: a++ == %d, b-- == %d\n&quot;, a++, b--);
  printf(&quot;after postfix operators applied: a == %d, b == %d\n&quot;, a, b);

  // Reset a and b.
  a = 1;
  b = 1;

  // Behaviour of the prefix increment and decrement operators.
  printf(&quot;\n&quot;);
  printf(&quot;original values: a == %d, b == %d\n&quot;, a, b);
  printf(&quot;result of prefix operators: ++a == %d, --b == %d\n&quot;, ++a, --b);
  printf(&quot;after prefix operators applied: a == %d, b == %d\n&quot;, a, b);

  printf(&quot;\n&quot;);

  return EXIT_SUCCESS;
}
 | output=

original values: a == 1, b == 1
result of postfix operators: a++ == 1, b-- == 1
after postfix operators applied: a == 2, b == 0

original values: a == 1, b == 1
result of prefix operators: ++a == 2, --b == 0
after prefix operators applied: a == 2, b == 0

}}

===Notes===
Because of the side-effects involved, built-in increment and decrement operators must be used with care to avoid undefined behavior due to violations of [[c/language/eval_order|sequencing rules]].

===See Also===

[[c/language/operator precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator logical</title>
    <ns>0</ns>
    <id>9565</id>
    <revision>
      <id>41446</id>
      <timestamp>2012-10-26T14:35:32Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>Creating C Logical operators page.</comment>
      <text xml:space="preserve" bytes="870">{{title|Logical operators}}
{{c/language/navbar}}
Logical operators apply standard boolean algebra operations to their operands.


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Result
|- style=&quot;text-align:center&quot;
| {{c|1=!}}
| logical NOT
| {{c|1=!a}}
| the logical negation of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=&amp;&amp;}}
| logical AND
| {{c|1=a &amp;&amp; b}}
| the logical AND of '''a''' and '''b'''
|- style=&quot;text-align:center&quot;
| {{c|1={{!!}}}}
| logical OR
| {{c|1=a {{!!}} b}}
| the logical OR of '''a''' and '''b'''
|}

===Short-circuit evaluation===
{{ttb|&amp;&amp;}} and {{ttb|{{!!}}}} perform short-circuit evaluation (do not evaluate the second operand if the result is known after evaluating the first).

===See Also===

[[c/language/operator_precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator member access</title>
    <ns>0</ns>
    <id>9567</id>
    <revision>
      <id>41448</id>
      <timestamp>2012-10-26T15:28:11Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <comment>Creating C Operator member access page.</comment>
      <text xml:space="preserve" bytes="1201">{{title|Member access operators}}
{{c/language/navbar}}
Member access operators allow access to the members of their operands.


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Description
|- style=&quot;text-align:center&quot;
| {{c|1=[]}}
| array subscript
| {{c|1=a[b]}}
| access the '''b'''th element of array '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=*}}
| pointer dereference
| {{c|1=*a}}
| dereference the pointer '''a''' to access the data it points to
|- style=&quot;text-align:center&quot;
| {{c|1=&amp;}}
| address of
| {{c|1=&amp;a}}
| the address of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=.}}
| struct member
| {{c|1=a.b}}
| access member '''b''' of struct '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=-&gt;}}
| struct member of pointer to struct
| {{c|1=a-&gt;b}}
| access member '''b''' of struct pointed to by '''a'''
equivalent of first dereferencing the pointer to the struct '''a''' then accessing member '''b''':

{{c|1=(*a).b}}
|}

===See Also===

* [[c/language/operator_precedence | Operator precedence]]
* [[c/language/arrays | Arrays]]
* [[c/language/pointer | Pointers]]
* Keyword: [[c/keyword/struct | struct]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator other</title>
    <ns>0</ns>
    <id>9568</id>
    <revision>
      <id>47508</id>
      <parentid>41452</parentid>
      <timestamp>2013-05-14T13:42:29Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1349">{{title|Other operators}}
{{c/language/navbar}}
A collection of operators that do not fit into any of the other major categories.


{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|- style=&quot;text-align:center&quot;
! Operator
! Operator name
! Example
! Description
|- style=&quot;text-align:center&quot;
| {{c|1=(...)}}
| function call
| {{c|1=f(...)}}
| call the function '''f'''(), with zero or more arguments
|- style=&quot;text-align:center&quot;
| {{c|1=,}}
| comma operator
| {{c|1=a, b}}
| evaluate expression '''a''', disregard its return value and complete any side-effects, then evaluate expression '''b''', returning the type and the result of this evaluation
|- style=&quot;text-align:center&quot;
| {{c|1=(type)}}
| type cast
| {{c|1=(type)a}}
| cast the type of '''a''' to '''type'''
|- style=&quot;text-align:center&quot;
| {{c|1=? :}}
| conditional operator
| {{c|1=a ? b : c}}
| if '''a''' is logically true (does not evaluate to zero) then evaluate expression '''b''', otherwise evaluate expression '''c'''
|- style=&quot;text-align:center&quot;
| {{c|1=sizeof}}
| sizeof operator
| {{c|1=sizeof a}}
| the size in bytes of '''a'''
|- style=&quot;text-align:center&quot;
| {{c|1=_Alignof}} {{mark since c11}}
| _Alignof operator
| {{c|1=_Alignof a}}
| the alignment required of the type of '''a'''
|}

===See Also===

* [[c/language/operator_precedence | Operator precedence]]
{{c/language/operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operator precedence</title>
    <ns>0</ns>
    <id>6317</id>
    <revision>
      <id>71080</id>
      <parentid>70936</parentid>
      <timestamp>2014-06-05T15:09:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="6137">{{title|C Operator Precedence}}
{{c/language/navbar}}

The following table lists the precedence and associativity of C operators. Operators are listed top to bottom, in descending precedence.

{| class=&quot;wikitable&quot;
|-
! style=&quot;text-align: left&quot; | Precedence
! style=&quot;text-align: left&quot; | Operator
! style=&quot;text-align: left&quot; | Description
! style=&quot;text-align: left&quot; | Associativity
|-
! rowspan=6| 1
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;++&lt;/code&gt; &lt;code&gt;--&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Suffix/postfix increment and decrement
| style=&quot;vertical-align: top&quot; rowspan=&quot;6&quot; | Left-to-right
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;()&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Function call
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;[]&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Array subscripting
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;.&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Structure and union member access
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;−&amp;gt;&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Structure and union member access through pointer
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;(''type''){''list''}&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Compound literal{{mark c99}}
|-
! rowspan=8| 2
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;++&lt;/code&gt; &lt;code&gt;--&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Prefix increment and decrement
| style=&quot;vertical-align: top&quot; rowspan=&quot;8&quot; | Right-to-left
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;+&lt;/code&gt; &lt;code&gt;−&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Unary plus and minus
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;!&lt;/code&gt; &lt;code&gt;~&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Logical NOT and bitwise NOT
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;(''type'')&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Type cast
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;*&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Indirection (dereference)
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;&amp;&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Address-of 
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;sizeof&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Size-of
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;_Alignof&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Alignment requirement{{mark c11}}
|-
! 3
| &lt;code&gt;*&lt;/code&gt; &lt;code&gt;/&lt;/code&gt; &lt;code&gt;%&lt;/code&gt;
| Multiplication, division, and remainder
| style=&quot;vertical-align: top&quot; rowspan=&quot;11&quot; | Left-to-right
|-
! 4
| &lt;code&gt;+&lt;/code&gt; &lt;code&gt;−&lt;/code&gt;
| Addition and subtraction
|-
! 5
| &lt;code&gt;&amp;lt;&amp;lt;&lt;/code&gt; &lt;code&gt;&amp;gt;&amp;gt;&lt;/code&gt;
| Bitwise left shift and right shift
|-
! rowspan=2| 6
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;&amp;lt;&lt;/code&gt; &lt;code&gt;&amp;lt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | For relational operators &lt; and ≤ respectively
|-
| style=&quot;border-top-style: none&quot; | &lt;code&gt;&amp;gt;&lt;/code&gt; &lt;code&gt;&amp;gt;=&lt;/code&gt;
| style=&quot;border-top-style: none&quot; | For relational operators &gt; and ≥ respectively
|-
! 7
| &lt;code&gt;==&lt;/code&gt; &lt;code&gt;!=&lt;/code&gt;
| For relational = and ≠ respectively
|-
! 8
| &lt;code&gt;&amp;amp;&lt;/code&gt;
| Bitwise AND
|-
! 9
| &lt;code&gt;^&lt;/code&gt;
| Bitwise XOR (exclusive or)
|-
! 10
| &lt;code&gt;&lt;nowiki&gt;|&lt;/nowiki&gt;&lt;/code&gt;
| Bitwise OR (inclusive or)
|-
! 11
| &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;
| Logical AND
|-
! 12
| &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;
| Logical OR
|-
! 13
| &lt;code&gt;?:&lt;/code&gt;
| Ternary conditional
| style=&quot;vertical-align: top&quot; rowspan=&quot;6&quot; | Right-to-Left
|-
! rowspan=5| 14
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Simple assignment
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;+=&lt;/code&gt; &lt;code&gt;−=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by sum and difference
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;*=&lt;/code&gt; &lt;code&gt;/=&lt;/code&gt; &lt;code&gt;%=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by product, quotient, and remainder
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;&amp;lt;&amp;lt;=&lt;/code&gt; &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by bitwise left shift and right shift
|-
| style=&quot;border-top-style: none&quot; | &lt;code&gt;&amp;amp;=&lt;/code&gt; &lt;code&gt;^=&lt;/code&gt; &lt;code&gt;&lt;nowiki&gt;|&lt;/nowiki&gt;=&lt;/code&gt;
| style=&quot;border-top-style: none&quot; | Assignment by bitwise AND, XOR, and OR
|-
! 15
| &lt;code&gt;,&lt;/code&gt;
| Comma
| Left-to-right
|}

When parsing an expression, an operator which is listed on some row will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it.

Operators that are in the same cell (there may be several rows of operators listed in a cell) have the same precedence and are grouped in the given direction. For example, the expression {{c|1=a=b=c}} is parsed as {{c|1=a=(b=c)}}, and not as {{c|1=(a=b)=c}} because of right-to-left associativity. Note that this does not affect the [[c/language/eval_order|evaluation order]] of the subexpressions a, b, and c.
&lt;references/&gt;

===See Also===
[[c/language/eval_order|Order of evaluation]] of operator arguments at run time.
{{c/language/operators}}
{{dsc begin}}
{{dsc see cpp | cpp/language/operator_precedence | C++ operator precedence}}
{{dsc end}}

[[de:c/language/operator precedence]]
[[es:c/language/operator precedence]]
[[fr:c/language/operator precedence]]
[[it:c/language/operator precedence]]
[[ja:c/language/operator precedence]]
[[pt:c/language/operator precedence]]
[[ru:c/language/operator precedence]]
[[zh:c/language/operator precedence]]</text>
      <sha1>621bpif8xi2z48kwpx8rj8yoexpg6lt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/operators</title>
    <ns>0</ns>
    <id>9561</id>
    <revision>
      <id>41430</id>
      <parentid>41424</parentid>
      <timestamp>2012-10-24T18:01:15Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>Links and navbar</comment>
      <text xml:space="preserve" bytes="258">{{title|Operators}}
{{c/language/navbar}}
{{c/language/operators}}


===See Also===
* [[c/language/eval_order|Order of evaluation]]
* [[c/language/operator precedence | Operator precedence]]
* [[c/language/operator alternative | Alternative operator syntax]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/return</title>
    <ns>0</ns>
    <id>6046</id>
    <revision>
      <id>70241</id>
      <parentid>68014</parentid>
      <timestamp>2014-05-12T17:47:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2385">{{title|return statement}}
{{c/language/navbar}}
Terminates current function and returns specified value to the caller function.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|return}} {{spar|expression}} {{ttb|;}} }}
{{sdsc | num=2 | {{ttb|return}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===

@1@ Evaluates the {{spar|expression}}, terminates the current function and returns the result of the {{spar|expression}} to the caller (the value returned becomes the value of the function call expression). Only valid if the function return type is not {{c|void}}.
@2@ Terminates the current function. Only valid if the function return type is {{c|void}}.

If the type of the {{spar|expression}} is different from the return type of the function, its value is converted as if by assignment to an object whose type is the return type of the function, except that overlap between object representations is permitted:
{{source|1=
struct s { double i; } f(void); // function returning struct s
union { struct { int f1; struct s f2; } u1;
        struct { struct s f3; int f4; } u2; } g;
struct s f(void)
{
    return g.u1.f2;
}
int main(void)
{
// g.u2.f3 = g.u1.f2; // undefined behavior (overlap in assignment)
   g.u2.f3 = f();     // well-defined
}
}}

If the return type is a real floating type, the result may be represented in greater range and precision than implied by the new type.

Reaching the end of a function other than {{c|main}} is equivalent to {{c|return;}}. Reaching the end of the main function is equivalent to {{c|return 0;}}.

===Keywords===

{{ltt|c/keyword/return}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
 
void fa(int i)
{
    if (i == 2)
       return;
    printf(&quot;fa():   %d\n&quot;, i);
} /* implied return; */
 
int fb(int i)
{
    if (i &gt; 4)
       return 4;
    printf(&quot;fb():   %d\n&quot;, i);
    return 2;
}
 
int main(void)
{
    fa(2);           /* returns, does nothing when i==2   */
    fa(1);           /* prints its argument, then returns */
    int i = fb(5);   /* 5&gt;4, so returns 4                 */
    i = fb(i);       /* prints its argument, returns 2    */
    printf(&quot;main(): %d\n&quot;, i);
}
 | output=
fa():   1
fb():   4
main(): 2
}}

[[de:c/language/return]]
[[es:c/language/return]]
[[fr:c/language/return]]
[[it:c/language/return]]
[[ja:c/language/return]]
[[pt:c/language/return]]
[[ru:c/language/return]]
[[zh:c/language/return]]</text>
      <sha1>2ykvsjkdej8nuazllfuty8g5ekp9e29</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/sizeof</title>
    <ns>0</ns>
    <id>13156</id>
    <revision>
      <id>70242</id>
      <parentid>67726</parentid>
      <timestamp>2014-05-12T17:50:00Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="3442">{{title|sizeof operator}}
{{c/language/navbar}}
Queries size of the object or type

Used when actual size of the object must be known

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|sizeof(}} {{spar|type}} {{ttb|)}}}}
{{sdsc | {{ttb|sizeof}} {{spar|expression}} {{ttb|}}}}
{{sdsc end}}

Both versions return a value of type {{lc|size_t}}. 

===Explanation===

1) returns size in bytes of the object representation of {{spar|type}}.

2) returns size in bytes of the object representation of the type of {{spar|expression}}

===Notes===
Depending on the computer architecture, a [[enwiki:Byte|byte]] may consist of 8 ''or more'' bits, the exact number being recorded in {{lc|CHAR_BIT}}.

{{c|sizeof(char)}}, {{c|sizeof(signed char)}}, and {{c|sizeof(unsigned char)}} always return {{c|1}}.

sizeof cannot be used with function types, incomplete types, or bit-field lvalues.

When applied to an operand that has structure or union type, the result is the total number of bytes in such an object, including internal and trailing padding.

{{rev begin}}
{{rev|since=c99|
If the type of {{spar|expression}} is a variable-length array type, {{spar|expression}} is evaluated and the size of the array it evaluates to is calculated at run time. Otherwise, {{spar|expression}} is not evaluated and the result is a compile-time constant.}}
{{rev end}}

===Keywords===

{{ltt|c/keyword/sizeof}}

===Example===
{{example
 | The example output corresponds to a system with 64-bit pointers and 32-bit int.
 | code=
#include &lt;stdio.h&gt;

int main(void)
{
    /* Size (in bytes) of the object representation of the type. */
    printf(&quot;sizeof(float)         = %2zu\n&quot;, sizeof(float));
    printf(&quot;sizeof(double)        = %2zu\n&quot;, sizeof(double));
    printf(&quot;sizeof(long double)   = %2zu\n&quot;, sizeof(long double));

    /* Size (in bytes) of the evaluated expression. */
    printf(&quot;sizeof 1              = %2zu\n&quot;, sizeof 1);        /* without parentheses */
    printf(&quot;sizeof(1.0F)          = %2zu\n&quot;, sizeof(1.0F));    /* with parentheses    */
    printf(&quot;sizeof(1.0F+1.0)      = %2zu\n&quot;, sizeof(1.0F+1.0));
    printf(&quot;sizeof(1.0F+1.0L)     = %2zu\n&quot;, sizeof(1.0F+1.0L));

    printf(&quot;sizeof(char *)        = %2zu\n&quot;, sizeof(char *));
    printf(&quot;sizeof(long double *) = %2zu\n&quot;, sizeof(long double *));

    /* Array */
    printf(&quot;sizeof(float[10])     = %zu\n&quot;, sizeof(float[10]));

    /* Structure */
    struct ints_1 {
        unsigned short int      usi;
        unsigned int             ui;
        unsigned long int       uli;
        unsigned long long int ulli;
    };
    printf(&quot;sizeof(struct ints_1) = %2zu\n&quot;, sizeof(struct ints_1));

    /* Union */
    union ints_2 {
        unsigned short int      usi;
        unsigned int             ui;
        unsigned long int       uli;
        unsigned long long int ulli;
    };
    printf(&quot;sizeof(union ints_2)  = %2zu\n&quot;, sizeof(union ints_2));
}
 | p=true
 | output=
sizeof(float)         =  4
sizeof(double)        =  8
sizeof(long double)   = 16
sizeof 1              =  4
sizeof(1.0F)          =  4
sizeof(1.0F+1.0)      =  8
sizeof(1.0F+1.0L)     = 16
sizeof(char *)        =  8
sizeof(long double *) =  8
sizeof(float[10])     = 40
sizeof(struct ints_1) = 24
sizeof(union ints_2)  =  8
}}

[[de:c/language/sizeof]]
[[es:c/language/sizeof]]
[[fr:c/language/sizeof]]
[[it:c/language/sizeof]]
[[ja:c/language/sizeof]]
[[pt:c/language/sizeof]]
[[ru:c/language/sizeof]]
[[zh:c/language/sizeof]]</text>
      <sha1>89gjmz8j0rc4bogt4fvyfrtd5qc2wb9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/storage class specifiers</title>
    <ns>0</ns>
    <id>9550</id>
    <revision>
      <id>70239</id>
      <parentid>68188</parentid>
      <timestamp>2014-05-12T17:38:07Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="4710">{{title|Storage-class specifiers}}
{{c/language/navbar}}

:*{{ttb|auto}} - automatic duration with no linkage.
:*{{ttb|register}} - automatic duration with no linkage. Also hints to the compiler to place the variable in the processor's register.
:*{{ttb|static}} - static duration with internal linkage at file scope and no linkage at block scope.
:*{{ttb|extern}} - static duration with either internal or more usually external linkage.
:*{{ttb|_Thread_local}} - {{mark since c11}} - thread storage duration.

===Explanation===

====Storage duration====

All variables in a program have one of the following storage durations that determines its lifetime:

:*'''''automatic''''' storage duration. The variable is allocated at the beginning of the enclosing code block and deallocated at the end. This is the default for all variables, except those declared {{tt|static}}, {{tt|extern}} or {{tt|_Thread_local}}.

:*'''''static''''' storage duration. The variable is allocated when the program begins and deallocated when the program ends. Only one instance of the variable can exist. Variables declared with {{tt|static}} or {{tt|extern}} have this storage duration.

:*'''''thread''''' storage duration {{mark since c11}}. The variable is allocated when the thread begins and deallocated when the thread ends. Each thread has its own instance of the variable. Only variables declared {{tt|_Thread_local}} have this storage duration. {{tt|_Thread_local}} can only be declared for variables declared with {{tt|static}} or {{tt|extern}} and cannot be used in a function declaration.

:*'''''allocated''''' storage duration. The variable is allocated and deallocated per request by using [[c/memory|dynamic memory allocation]] functions.

====Linkage====

Linkage refers to the ability of a variable or function to be referred to in other scopes. If a variable or function with the same identifier is declared in several scopes, but cannot be referred to from all of them, then several instances of the variable are generated. The following linkages are recognized:

:*'''''no linkage'''''. The variable can be referred to only from the scope it is in (block scope). All variables with automatic, thread and dynamic storage durations have this linkage, as well as variables declared {{tt|static}} at block scope.

:*'''''internal linkage'''''. The variable can be referred to from all scopes in the current translation unit. All variables which are declared at file scope have this linkage, including variables declared {{tt|static}} at file scope.

:*'''''external linkage'''''. The variable can be referred to from any other translation units in the entire program. All variables which are declared either {{tt|extern}} or {{tt|const}} with no explicit storage-class specifier, but not {{tt|static}}, have this linkage.

===Keywords===

{{ltt|c/keyword/auto}},
{{ltt|c/keyword/register}},
{{ltt|c/keyword/static}},
{{ltt|c/keyword/extern}},
{{ltt|c/keyword/_Thread_local}}

===Example===
Scope, Visibility, Lifetime:
A variable with automatic storage duration is allocated with a high memory address. A variable with static storage duration is allocated with a low memory address; uninitialized variables are separated from initialized variables in memory for a fast internal initialization to zero. A variable with allocated storage duration is allocated memory above variables with static storage duration.
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
/* static storage duration */
int A;       // uninitialized global variable; this system initializes with zero
int B = 9;   // initialized global variable
 
int main(void)
{
    printf(&quot;&amp;A = %p\n&quot;, (void*)&amp;A);
    printf(&quot;&amp;B = %p\n&quot;, (void*)&amp;B);
 
    /* automatic storage duration */
    int A = 1;   // hides global A
    printf(&quot;&amp;A = %p\n&quot;, (void*)&amp;A);

    /* static storage duration */
    static int B=1; // hides global B
    printf(&quot;&amp;B = %p\n&quot;, (void*)&amp;B);
    
    /* allocated storage duration */
    int *ptr_1 = (int*)malloc(sizeof(int));   /* start allocated storage duration */
    printf(&quot;address of int in allocated memory = %p\n&quot;, (void*)ptr_1);
    free(ptr_1);                              /* stop allocated storage duration  */
 
    return 0;
}
 | p=true
 | output=
&amp;A = 0x60103c
&amp;B = 0x601034
&amp;A = 0x7fff3c3153fc
&amp;B = 0x601030
address of int in allocated memory = 0xc4f010
}}

[[de:c/language/storage class specifiers]]
[[es:c/language/storage class specifiers]]
[[fr:c/language/storage class specifiers]]
[[it:c/language/storage class specifiers]]
[[ja:c/language/storage class specifiers]]
[[pt:c/language/storage class specifiers]]
[[ru:c/language/storage class specifiers]]
[[zh:c/language/storage class specifiers]]</text>
      <sha1>kkilp6zhf53whi6mi0150u1skgfov3z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/storage duration</title>
    <ns>0</ns>
    <id>9547</id>
    <revision>
      <id>43932</id>
      <parentid>41309</parentid>
      <timestamp>2012-11-03T04:17:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="3100">{{title|Storage-class specifiers}}
{{c/language/navbar}}

:*{{ttb|auto}} - automatic duration with no linkage.
:*{{ttb|register}} - automatic duration with no linkage. Also hints to the compiler to place the variable in the processor's register.
:*{{ttb|static}} - static duration with internal linkage.
:*{{ttb|extern}} - static duration with either internal or more usually external linkage.
:*{{ttb|_Thread_local}} - {{mark since c11}} - thread storage duration.

===Explanation===

====Storage duration====
All variables in a program have one of the following storage durations that determines its lifetime:

:*'''''automatic''''' storage duration. The variable is allocated at the beginning of the enclosing code block and deallocated at the end. This is the default for all variables, except those declared {{tt|static}}, {{tt|extern}} or {{tt|_Thread_local}}.

:*'''''static''''' storage duration. The variable is allocated when the program begins and deallocated when the program ends. Only one instance of the variable can exist. Variables declared with {{tt|static}} or {{tt|extern}} have this storage duration.

:*'''''thread''''' storage duration {{mark since c11}}. The variable is allocated when the thread begins and deallocated when the thread ends. Each thread has its own instance of the variable. Only variables declared {{tt|_Thread_local}} have this storage duration. {{tt|_Thread_local}} can only be declared for variables declared with {{tt|static}} or {{tt|extern}} and cannot be used in a function declaration.

:*'''''allocated''''' storage duration. The variable is allocated and deallocated per request by using [[c/memory|dynamic memory allocation]] functions.

====Linkage====

Linkage refers to the ability of a variable or function to be referred to in other scopes. If a variable or function with the same identifier is declared in several scopes, but cannot be referred to from all of them, then several instances of the variable are generated. The following linkages are recognized:

:*'''''no linkage'''''. The variable can be referred to only from the scope it is in. All variables with automatic, thread and dynamic storage durations have this linkage.

:*'''''internal linkage'''''. The variable can be referred to from all scopes in the current translation unit. All variables which are declared {{tt|static}} have this linkage.

:*'''''external linkage'''''. The variable can be referred to from any other translation units in the entire program. All variables which are declared either {{tt|extern}} or {{tt|const}} with no explicit storage-class specifier, but not {{tt|static}}, have this linkage.

===Keywords===

{{ltt|c/keyword/auto}},
{{ltt|c/keyword/register}},
{{ltt|c/keyword/static}},
{{ltt|c/keyword/extern}},
{{ltt|c/keyword/_Thread_local}}

===Example===

{{todo}}

[[de:c/language/storage duration]]
[[es:c/language/storage duration]]
[[fr:c/language/storage duration]]
[[it:c/language/storage duration]]
[[ja:c/language/storage duration]]
[[pt:c/language/storage duration]]
[[ru:c/language/storage duration]]
[[zh:c/language/storage duration]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/struct</title>
    <ns>0</ns>
    <id>9822</id>
    <revision>
      <id>72142</id>
      <parentid>70243</parentid>
      <timestamp>2014-07-18T15:32:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention that nested structs, enumerators, and enumerations escape the struct &quot;scope&quot; (C++ programmers get tripped up by that)</comment>
      <text xml:space="preserve" bytes="6868">{{title|Struct declaration}}
{{c/language/navbar}}

A struct is a type consisting of a sequence of members whose storage is allocated in an ordered sequence (as opposed to union, which is a type consisting of a sequence of members whose storage overlaps).

The type specifier for a struct is identical to the [[c/language/union | {{tt|union}}]] type specifier except for the keyword used:

===Syntax===

{{sdsc begin}}
{{sdsc |num=1| {{ttb|struct}} {{spar|name}}{{mark optional}} {{ttb|{ }} {{spar|struct-declaration-list}} {{ttb|} }}
}}
{{sdsc |num=2| {{ttb|struct}} {{spar|name}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|name}} | the name of the struct that's being defined}}
{{par | {{spar|struct-declaration-list}} | any number of variable declarations, {{rlp|bit field}} declarations, and {{rlp|static assert}} declarations. Members of incomplete type and members of function type are not allowed (except for the flexible array member described below)}}
{{par end}}

===Explanation===
Within a struct object, addresses of its elements (and the addresses of the bit field allocation units) increase in order in which the members were defined. A pointer to a struct can be cast to a pointer to its first member (or, if the member is a bit field, to its allocation unit). Likewise, a pointer to the first member of a struct can be cast to a pointer to the enclosing struct. There may be unnamed padding between any two members of a struct or after the last member, but not before the first member. The size of a struct is at least as large as the sum of the sizes of its members.

{{rev begin}}
{{rev|since=c99|
If a struct defines at least one named member, it is allowed to additionally declare its last member with incomplete array type. When an element of the flexible array member is accessed (in an expression that uses operator {{ttb|.}} or {{ttb|-&gt;}} with the flexible array member's name as the right-hand-side operand), then the struct behaves as if the array member had the longest size fitting in the memory allocated for this object. If no additional storage was allocated, it behaves as if an array with 1 element, except that the behavior is undefined if that element is accessed or a pointer one past that element is produced. Initialization, {{c|sizeof}}, and the assignment operator ignore the flexible array member. Structures with flexible array members (or unions whose last member is a structure with flexible array member) cannot appear as array elements or as members of other structures.
{{source|1=
    struct s { int n; double d[]; }; // s.d is a flexible array member 

    struct s t1 = { 0 };         // OK, d is as if double d[1], but UB to access
    struct s t2 = { 1, { 4.2 } }; // error: initialization ignores flexible array

    // if sizeof (double) == 8
    struct s *s1 = malloc(sizeof (struct s) + 64); // as if d was double d[8]
    struct s *s2 = malloc(sizeof (struct s) + 46); // as if d was double d[5]

    s1 = malloc(sizeof (struct s) + 10); // now as if d was double d[1]
    s2 = malloc(sizeof (struct s) + 6);  // same, but UB to access
    double *dp = &amp;(s1-&gt;d[0]);    //  OK
    *dp = 42;                    //  OK
    dp = &amp;(s2-&gt;d[0]);            //  OK
    *dp = 42;                    //  undefined behavior

    *s1 = *s2; // only copies s.n, not any element of s.d
               // except those caught in sizeof (struct s)
}}
}}
{{rev end}}

{{rev begin}}
{{rev|since=c11|
Similar to union, an unnamed member of a struct whose type is a struct without {{spar|name}} is known as ''anonymous struct''. Every member of an anonymous struct is considered to be a member of the enclosing struct or union. This applies recursively if the enclosing struct or union is also anonymous.
{{source|1=
struct v {
   union { // anonymous union
      struct { int i, j; }; // anonymous structure
      struct { long k, l; } w;
   };
   int m;
} v1;

v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid
}}

Similar to union, the behavior of the program is undefined if struct is defined without any named members (including those obtained via anonymous nested structs or unions).
}}
{{rev end}}

{{todo|initialization or link to a page that will talk about initialization}}

===Notes===
Because members of incomplete type are not allowed, and a stuct type is not complete until the end of the definition, a struct cannot have a member of its own type. A pointer to its own type is allowed, and is commonly used to implement nodes in linked lists or trees.

Because a struct declaration does not establish {{rlp|scope}}, nested types, enumerations and enumerators introduced by declarations within {{spar|struct-declaration-list}} are visible in the surrounding scope where the struct is defined.

===Example===
{{example
 | code=
#include &lt;stddef.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    struct car { char *make; char *model; int year; }; // declares the struct type
    // declares and initializes an object of a previously-declared struct type
    struct car c = {.year=1923, .make=&quot;Nash&quot;, .model=&quot;48 Sports Touring Car&quot;};
    printf(&quot;car: %d %s %s\n&quot;, c.year, c.make, c.model);

    // declares a struct type, an object of that type, and a pointer to it
    struct spaceship { char *make; char *model; char *year; }
        ship = {&quot;Incom Corporation&quot;, &quot;T-65 X-wing starfighter&quot;, &quot;128 ABY&quot;},
        *pship = &amp;ship;
    printf(&quot;spaceship: %s %s %s\n&quot;, ship.year, ship.make, ship.model);

    // addresses increase in order of definition
    // padding may be inserted
    struct A { char a; double b; char c;};
    printf(&quot;offset of char a = %zu\noffset of double b = %zu\noffset of char c = %zu\n&quot;
           &quot;sizeof(struct A)=%zu\n&quot;, offsetof(struct A, a), offsetof(struct A, b),
           offsetof(struct A, c), sizeof(struct A));
    struct B { char a; char b; double c;};
    printf(&quot;offset of char a = %zu\noffset of char b = %zu\noffset of double c = %zu\n&quot;
           &quot;sizeof(struct B)=%zu\n&quot;, offsetof(struct B, a), offsetof(struct B, b),
           offsetof(struct B, c), sizeof(struct B));

    // A pointer to a struct can be cast to a pointer to its first member and vice versa
    char* pmake = (char*)&amp;ship;
    pship = (struct spaceship *)pmake;
}
 | p=true
 | output=
car: 1923 Nash 48 Sports Touring Car
spaceship: 128 ABY Incom Corporation T-65 X-wing starfighter
offset of char a = 0
offset of double b = 8
offset of char c = 16
sizeof(struct A)=24
offset of char a = 0
offset of char b = 1
offset of double c = 8
sizeof(struct B)=16
}}

===See also===
{{todo|link to struct/union members}}
{{todo|link to bit fields}}
{{todo|link to initialization}}


[[de:c/language/union]]
[[es:c/language/union]]
[[fr:c/language/union]]
[[it:c/language/union]]
[[ja:c/language/union]]
[[pt:c/language/union]]
[[ru:c/language/union]]
[[zh:c/language/union]]</text>
      <sha1>2rew1fqmutpbedb2ofb89xf9px34exh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/switch</title>
    <ns>0</ns>
    <id>6039</id>
    <revision>
      <id>70233</id>
      <parentid>48942</parentid>
      <timestamp>2014-05-12T17:04:29Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2610">{{title|switch statement}}
{{c/language/navbar}}
Executes code according to value of an integral argument

Used where one or several out of many branches of code need to be executed according to an integral value.

===Syntax===

{{sdsc begin}}
{{sdsc | 1= 
{{ttb|switch (}} {{spar|expression}} {{ttb|) {}}&lt;br&gt;
:{{ttb|case}} {{spar|constant_expression&lt;sub&gt;1&lt;/sub&gt;}} {{ttb|:}}&lt;br&gt;
::{{spar|statement&lt;sub&gt;1&lt;/sub&gt;}} {{mark optional}} &lt;br&gt;     
:{{ttb|case}} {{spar|constant_expression&lt;sub&gt;2&lt;/sub&gt;}} {{ttb|:}}&lt;br&gt;
::{{spar|statement&lt;sub&gt;2&lt;/sub&gt;}} {{mark optional}} &lt;br&gt;
:::... ... ...
:{{ttb|case}} {{spar|constant_expression&lt;sub&gt;n&lt;/sub&gt;}} {{ttb|:}}&lt;br&gt;
::{{spar|statement&lt;sub&gt;n&lt;/sub&gt;}} {{mark optional}} &lt;br&gt;
:{{ttb|default:}} {{spar|default_statement}} {{mark optional}} &lt;br&gt;
{{ttb|} }}
}}
{{sdsc end}}

===Explanation===

{{spar|expression}} shall be an expression, convertible to an integer value.

All {{spar|constant_expression}}s shall be constant expressions, convertible to an integer value, which is unique within this {{tt|switch}} statement

If the {{spar|expression}} evaluates to a value, equal to the value of one of the defined {{spar|constant_expression&lt;sub&gt;i&lt;/sub&gt;}}, the {{spar|statement&lt;sub&gt;i&lt;/sub&gt;}} (if present) and all subsequent statements (including {{spar|default_statement}}, if present) are executed. If the value of the {{spar|expression}} does not match any of the {{spar|constant_expression}}s, the {{spar|default_statement}} is executed if present.

It is useful to note, that if the execution of subsequent statements is undesirable, the {{rlp|break | break statement}} can be used. In that case the execution of the {{tt|switch}} statement terminates. 

===Keywords===

{{ltt|c/keyword/switch}},
{{ltt|c/keyword/case}},
{{ltt|c/keyword/default}}

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;

void func(int x)
{
   printf(&quot;func(%d): &quot;, x);
   switch(x)
   {
      case 1: printf(&quot;case 1, &quot;);

      case 2: printf(&quot;case 2, &quot;);

      case 3: printf(&quot;case 3.\n&quot;); break;

      case 4: printf(&quot;case 4, &quot;);

      case 5: printf(&quot;case 5, &quot;);

      default: printf(&quot;default.\n&quot;);
   }
}


int main(void)
{
   for(int i = 1; i &lt; 10; ++i)  func(i);
}

 | output=
func(1): case 1, case 2, case 3.
func(2): case 2, case 3.
func(3): case 3.
func(4): case 4, case 5, default.
func(5): case 5, default.
func(6): default.
func(7): default.
func(8): default.
func(9): default.

}}

[[de:c/language/switch]]
[[es:c/language/switch]]
[[fr:c/language/switch]]
[[it:c/language/switch]]
[[ja:c/language/switch]]
[[pt:c/language/switch]]
[[ru:c/language/switch]]
[[zh:c/language/switch]]</text>
      <sha1>8uduoild1anitglkl6a92i0qoeare75</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/typedef</title>
    <ns>0</ns>
    <id>13183</id>
    <revision>
      <id>72097</id>
      <parentid>72096</parentid>
      <timestamp>2014-07-14T15:05:54Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected error in see also</comment>
      <text xml:space="preserve" bytes="4275">{{title|Typedef declaration}}
{{c/language/navbar}}

The {{c|typedef}} declaration provides a way to create a synonym that can be used anywhere in place of a (possibly complex) type name.

===Syntax===

{{sdsc begin}}
{{sdsc |
{{ttb|typedef}} {{spar|type-specifier}} {{spar|typedef-name}}{{ttb|;}}
}}
{{sdsc end}}

===Explanation===
{{todo|replace with actual details from C, $6.7.8}}

A type definition is a declaration whose storage-class specifier is {{c|typedef}}. Each declarator in the declaration defines an identifier to be a typedef name that is an alias for the type specified. The type specified can be another typedef name. A {{c|typedef}} declaration does not introduce a new type. Since {{c|typedef}} is a storage-class specifier, a {{c|typedef}} declaration may not use another storage-class specifier (e.g. {{c|static}}).

Objects defined with the same typedef name have a type compatible with the type specified in the {{c|typedef}} declaration.

When a typedef name denotes a variable length array type, the length of the array is fixed when the typedef name is defined, not when the typedef name is used.

===Keywords===
{{ltt|c/keyword/typedef}}

===Example===
Uppercase visually emphasizes the synonyms in the examples.  Uppercase is not required.
{{example
 |code=
#include &lt;stdio.h&gt;

int main(void)
{
    /* Parameterizes a C type.                                                   */
    /* When the program requires a larger f-p format, simply change the typedef. */
    typedef float REAL;
    /* Variables x1 and x2 have the same type.                                   */
    REAL x1;
    float x2;
    printf(&quot;sizeof(x1) = %zu\n&quot;, sizeof(x1));   // 4 bytes
    printf(&quot;sizeof(x2) = %zu\n&quot;, sizeof(x2));   // 4 bytes
    const REAL y = 0.0;
    static REAL z;

//  typedef float REAL;   /* error: redefinition of typedef 'REAL' [-Wpedantic] */
//  typedef double REAL;  /* error: conflicting types for 'REAL'                */

    /* Shortens a lengthy C type name. */
    typedef unsigned long int ULONG;

    /* Provides a name indicating what a variable represents.              */
    /* Both synonyms are floats but represent different physical concepts. */
    typedef float TEMP;
    typedef float WIND_SPEED;

    /* Provides a common C idiom to avoid writing &quot;struct&quot; repeatedly. */
    /* anonymous struct                                                */
    typedef struct {int a; int b;} S, *PS;
    /* Variables ps1 and ps2 have the same type.                       */
    PS ps1;
    S* ps2;

    /* Provides a common C idiom to avoid writing &quot;union&quot; repeatedly. */
    /* anonymous union                                                */
    typedef union {int i; float f;} U, *PU;
    /* Variables pu1 and pu2 have the same type.                      */
    PU pu1;
    U* pu2;

    /* Provides a common C idiom to avoid writing &quot;enum&quot; repeatedly. */
    /* anonymous enum                                                */
    typedef enum {club,diamond,heart,spade} E, *PE;
    /* Variables pe1 and pe2 have the same type.                     */
    PE pe1;
    E* pe2;

    /* typedef with array */
    typedef int ARR_T[10];
    ARR_T a1;
    int a2[10];   /* same as a1 */
    printf(&quot;sizeof(a1) = %zu\n&quot;, sizeof(a1));   // 40 bytes
    printf(&quot;sizeof(a2) = %zu\n&quot;, sizeof(a2));   // 40 bytes

    /* typedef with pointer */
    int i=0;
    typedef int * PTR_TO_INT;
    PTR_TO_INT pi = &amp;i;

    /* typedef with function pointer                                                */
    /* FP is a synonym for a pointer to a function that neither takes nor returns a */
    /* value.                                                                       */
    typedef void (*FP)(void);

    /* error: multiple storage classes in declaration specifiers */
    /* typedef static unsigned int uint;                         */

    return 0;
}
 |p=true
 |output=
sizeof(x1) = 4
sizeof(x2) = 4
sizeof(a1) = 40
sizeof(a2) = 40
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/language/typedef | Typedef declaration}}
{{dsc end}}

[[de:c/keyword/typedef]]
[[es:c/keyword/typedef]]
[[fr:c/keyword/typedef]]
[[it:c/keyword/typedef]]
[[ja:c/keyword/typedef]]
[[pt:c/keyword/typedef]]
[[ru:c/keyword/typedef]]
[[zh:c/keyword/typedef]]</text>
      <sha1>5ye44ruebrm0mix6vp2l1rubsyjdx5p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/types</title>
    <ns>0</ns>
    <id>9384</id>
    <revision>
      <id>43920</id>
      <parentid>39558</parentid>
      <timestamp>2012-11-03T04:16:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="201">{{todo}}

[[de:c/language/types]]
[[es:c/language/types]]
[[fr:c/language/types]]
[[it:c/language/types]]
[[ja:c/language/types]]
[[pt:c/language/types]]
[[ru:c/language/types]]
[[zh:c/language/types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/union</title>
    <ns>0</ns>
    <id>13165</id>
    <revision>
      <id>70245</id>
      <parentid>67909</parentid>
      <timestamp>2014-05-12T17:58:35Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="5376">{{title|Union declaration}}
{{c/language/navbar}}

A union is a type consisting of a sequence of members whose storage overlaps (as opposed to struct, which is a type consisting of a sequence of members whose storage is allocated in an ordered sequence). The value of at most one of the members can be stored in a union at any one time.

The type specifier for a union is identical to the [[c/language/struct | {{tt|struct}}]] type specifier except for the keyword used:

===Syntax===

{{sdsc begin}}
{{sdsc |num=1| {{ttb|union}} {{spar|name}}{{mark optional}} {{ttb|{ }} {{spar|struct-declaration-list}} {{ttb|} }}
}}
{{sdsc |num=2| {{ttb|union}} {{spar|name}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|name}} | the name of the union that's being defined}}
{{par | {{spar|struct-declaration-list}} | any number of variable declarations, bit field declarations, and static assert declarations. Members of incomplete type and members of function type are not allowed.}}
{{par end}}

===Explanation===
The union is only as big as necessary to hold its largest member (additional unnamed trailing padding may also be added). The other members are allocated in the same bytes as part of that largest member. 

A pointer to a union can be cast to a pointer to each of its members (if a union has bit field members, the pointer to a union can be cast to the pointer to the bit field's underlying type). Likewise, a pointer to any member of a union can be cast to a pointer to the enclosing union. 

The value of the bytes that correspond to union members other than the one last stored into is unspecified.

{{rev begin}}
{{rev|since=c11|
Similar to struct, an unnamed member of a union whose type is a union without {{spar|name}} is known as ''anonymous union''. Every member of an anonymous union is considered to be a member of the enclosing struct or union. This applies recursively if the enclosing struct or union is also anonymous.
{{source|1=
struct v {
   union { // anonymous union
      struct { int i, j; }; // anonymous structure
      struct { long k, l; } w;
   };
   int m;
} v1;

v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid
}}

Similar to struct, the behavior of the program is undefined if union is defined without any named members (including those obtained via anonymous nested structs or unions).
}}

{{todo|initialization or link to a page that will talk about initialization}}

===Example===
{{todo|simplify}}
{{example
 | This example exhibits the active member of a union, casting between union and member pointers, and unnamed trailing padding.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdint.h&gt;
#include &lt;stddef.h&gt;

union S {
    int32_t n;       /* occupies 4 bytes */
    uint16_t s[2];   /* occupies 4 bytes */
    uint8_t c;       /* occupies 1 byte  */
}; /* the whole union occupies 4 bytes */

/* padded union */
union pad {          /* occupies 8 bytes */
       char  c[5];   /* occupies 5 bytes */
       float f;      /* occupies 4 bytes */
} p;
 
int main(void)
{
    /* Initialize the first member of s; s.n is now the active member. */
    union S s = {0x12345678};
    printf(&quot;sizeof(union S) = %zu\n&quot;, sizeof(union S));

    /* At this point, reading from s.s or s.c is UB. */
    printf(&quot;s.n = %x\n&quot;, s.n);
    
    /* Assign a value to s.s[0]. */
    s.s[0] = 0x0011;   // s.s is now the active member
    
    /* At this point, reading from n or c is UB, but most compilers define this. */
    printf(&quot;s.c is now %x\n&quot;, s.c);  // 11 or 00, depending on platform
    printf(&quot;s.n is now %x\n&quot;, s.n);  // 12340011 or 00115678

    /* Define a pointer to a union.              */
    /* Initialize the uint8_t member.            */
    /* Print the uint8_t member via the pointer. */
    union S *ps=&amp;s;
    s.c = 0;
    printf(&quot;%x  %x\n&quot;,ps-&gt;c,(*ps).c);
    
    /* A pointer to a union can be cast to a pointer to each of its members. */
    uint8_t *p8 = &amp;s.c;   /* pointer to the uint8_t member */
    p8 = (uint8_t*)ps;    /* cast union pointer to member pointer */

    /* A pointer to any member of a union can be cast to a pointer to the enclosing */
    /* union.                                                                       */
    ps = (union S*)p8;    /* cast member pointer to union pointer */

    /* Union members are allocated memory at the same starting address. */
    printf(&quot;offset of char c[] = %zu\noffset of float f  = %zu\n&quot;,
           offsetof(union pad, c), offsetof(union pad, f));

    /* Union pad has 3 bytes of unnamed trailing padding. */
    printf(&quot;sizeof(union pad) = %lu\n&quot;, sizeof(union pad));   /* 8 bytes */
    printf(&quot;sizeof(p.c)       = %lu\n&quot;, sizeof(p.c));         /* 5 bytes */
    printf(&quot;sizeof(p.f)       = %lu\n&quot;, sizeof(p.f));         /* 4 bytes */
 
    return 0;
}
 | p=true
 | output=
sizeof(union S) = 4
s.n = 12345678
s.c is now 11
s.n is now 12340011
0  0
offset of char c[] = 0
offset of float f  = 0
sizeof(union pad) = 8
sizeof(p.c)       = 5
sizeof(p.f)       = 4
}}

Each member is allocated as if it were the only member of the union, which is why {{tt|s.c}} in the example above aliases the first byte of {{tt|s.s[0]}}.

[[de:c/language/union]]
[[es:c/language/union]]
[[fr:c/language/union]]
[[it:c/language/union]]
[[ja:c/language/union]]
[[pt:c/language/union]]
[[ru:c/language/union]]
[[zh:c/language/union]]</text>
      <sha1>szs1x3658j1e77l75gdrawclcstol81</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/language/while</title>
    <ns>0</ns>
    <id>6041</id>
    <revision>
      <id>70246</id>
      <parentid>67668</parentid>
      <timestamp>2014-05-12T18:02:18Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1490">{{title|while loop}}
{{c/language/navbar}}
Executes a loop.

Used where code needs to be executed several times while some condition is present.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|while (}} {{spar|cond_expression}} {{ttb|)}} {{spar|loop_statement}} }}
{{sdsc end}}

===Explanation===

{{spar|cond_expression}} shall be an expression, whose result is convertible to {{c|bool}}. It is evaluated before each execution of {{spar|loop_statement}}, which is only executed if the {{spar|cond_expression}} evaluates to {{c|true}}.

If the execution of the loop needs to be terminated at some point, {{rlp |break| break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut.

===Keywords===

{{ltt|c/keyword/while}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
 
#define SIZE 8
 
int main(void)
{
    unsigned i = 0, array [SIZE];
 
    while (i &lt; SIZE)
    {
        array [i] = rand() % 2;
        ++i;
    }
 
    printf(&quot;Array filled!\n&quot;);
 
    i = 0;
    while (i &lt; SIZE)
    {
        printf(&quot;%d &quot;, array[i]);
        ++i;
    }
 
    printf(&quot;\n&quot;);
 
    return EXIT_SUCCESS;
}
 | output=
Array filled!
1 0 1 1 1 1 0 0
}}

[[de:c/language/while]]
[[es:c/language/while]]
[[fr:c/language/while]]
[[it:c/language/while]]
[[ja:c/language/while]]
[[pt:c/language/while]]
[[ru:c/language/while]]
[[zh:c/language/while]]</text>
      <sha1>3x09xa0ftogjkrua2pdwmnz8ynhxtho</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/links</title>
    <ns>0</ns>
    <id>9324</id>
    <revision>
      <id>43909</id>
      <parentid>39636</parentid>
      <timestamp>2012-11-03T04:14:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="704">{{title|Useful resources}}
===C FAQs===
*[http://c-faq.com/ C FAQ] - Answers to the frequently asked questions from the Usenet newsgroup comp.lang.c

===C Language and library references===
*[http://www.open-std.org/jtc1/sc22/wg14/ JTC1/SC22/WG14] - the C Standards Committee, includes draft C language standards, proposals, and defect reports

===Related standards===
*[http://pubs.opengroup.org/onlinepubs/9699919799/functions/contents.html POSIX.1-2008] - The operating system API of the Unix-compatible systems

===Might be also useful===
* [[c/links/libs | List of C libraries]]

[[de:c/links]]
[[es:c/links]]
[[fr:c/links]]
[[it:c/links]]
[[ja:c/links]]
[[pt:c/links]]
[[ru:c/links]]
[[zh:c/links]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/links/libs</title>
    <ns>0</ns>
    <id>9325</id>
    <revision>
      <id>67961</id>
      <parentid>67960</parentid>
      <timestamp>2014-03-09T07:16:17Z</timestamp>
      <contributor>
        <ip>204.14.152.34</ip>
      </contributor>
      <comment>Add bstrlib: The Better String library</comment>
      <text xml:space="preserve" bytes="3530">{{title|A list of open source C libraries}}
&lt;div style=&quot;border: 1px solid silver; border-radius: 5px; padding: 0.5em;&quot;&gt;
The objective of this page is to build a comprehensible list of open source C libraries, so that when one needs an implementation of particular functionality, one need not waste time searching on Google.
 
If you know a library that might be useful to others, please add a link to it here. There are no restrictions on what can be included except that it must be possible to download the source of the library.

The page is provided 'as is' - with the hope of being useful, but without any warranties. Outdated, misleading or wrong links might appear here. If you've noticed one of these, it would be great if you fixed the error.
&lt;/div&gt;

==Operating system==
; Access control
*{{lib| acl | http://savannah.nongnu.org/projects/acl/ }}
*{{lib| apparmor | http://apparmor.net/ }}

; Extended attributes
*{{lib| attr | http://savannah.nongnu.org/projects/attr/ }}

==Graphic user interface==

*{{lib|IUP|http://www.tecgraf.puc-rio.br/iup/}}

==Gtk+ widgets==
*{{lib| gtk+ | http://www.gtk.org/ }}
*{{lib| gtkhtml | http://www.gnome.org/projects/evolution/ }}
*{{lib| appmenu-gtk | https://launchpad.net/appmenu-gtk }}
*{{lib| ghex | http://live.gnome.org/Ghex }}
*{{lib| gtkspell | http://gtkspell.sourceforge.net/ }}
*{{lib| gtksourceview | http://projects.gnome.org/gtksourceview/ }}
*{{lib| gtkhotkey | https://launchpad.net/gtkhotkey }}
*{{lib| gucharmap | http://live.gnome.org/Gucharmap }}
*{{lib| goocanvas | http://live.gnome.org/GooCanvas }}

==Audio==
; Codecs
*{{lib| aften | http://aften.sourceforge.net/ }}
*{{lib| faad2 | http://www.audiocoding.com/ }}
*{{lib| wavpack | http://www.wavpack.com }}

; Infrastructure
*{{lib| alsa-lib | http://www.alsa-project.org/ }}
; CD
*{{lib| cdparanoia | http://www.xiph.org/paranoia/ }}

;Speech synthesis
*{{lib| espeak | http://espeak.sourceforge.net/ }}--
*{{lib| flite | http://www.speech.cs.cmu.edu/flite }} --

==Video==
; Codecs
*{{lib| schroedinger | http://diracvideo.org/ }}--
*{{lib| video4linux | http://linuxtv.org/downloads/v4l-utils/ }}--

==Files==
*{{lib| gmime | http://spruce.sourceforge.net/gmime/ }}

==Maths==
*{{lib| gsl | http://www.gnu.org/software/gsl }}

; Integer Multi-Dimensional Interpolation
*{{lib| argyll | http://www.argyllcms.com/ }}

; Linear algebra
*{{lib| atlas | http://math-atlas.sourceforge.net/ }}
*{{lib| blas | http://www.netlib.org/blas/ }}

; Finance
*{{lib| ta-lib | http://sourceforge.net/projects/ta-lib/ }}

; FFT
*{{lib| fftw3 | http://fftw.org }}

; Multiprecision
*{{lib| gmp | http://gmplib.org/ }}

==Graphics==
*{{lib| cairo | http://cairographics.org/ }}
*{{lib| babl | http://gegl.org/babl/ }}

==Interprocess==
*{{lib| dbus-glib | http://www.freedesktop.org/wiki/Software/DBusBindings }}
*{{lib| dbus | http://dbus.freedesktop.org/ }}
*{{lib| dee | https://launchpad.net/dee }}

==Databases==
*{{lib| berkeley db | http://www.oracle.com/technology/software/products/berkeley-db/index.html }}

==Compression==
*{{lib| bzip2 | http://www.bzip.org/ }} 

==libc==
*{{lib| bstrlib | http://bstring.sourceforge.net/ }}
*{{lib| eglibc | http://www.eglibc.org }}

==XML==
*{{lib| expat | http://expat.sourceforge.net }}

==Javascript==
*{{lib| gjs | http://live.gnome.org/Gjs }}

==Concurrency==
*{{lib| pth | http://www.gnu.org/software/pth/ }}--

[[de:c/links/libs]]
[[es:c/links/libs]]
[[fr:c/links/libs]]
[[it:c/links/libs]]
[[ja:c/links/libs]]
[[pt:c/links/libs]]
[[ru:c/links/libs]]
[[zh:c/links/libs]]</text>
      <sha1>gl6mhg5i7prp2969v2ya4lnh5hiy70m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/locale</title>
    <ns>0</ns>
    <id>5924</id>
    <revision>
      <id>71032</id>
      <parentid>71003</parentid>
      <timestamp>2014-06-04T20:13:42Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="506">{{title|Localization support}}
{{c/locale/navbar}}

{{dsc begin}}
{{dsc header | locale.h }}
{{dsc inc | c/locale/dsc setlocale}}
{{dsc inc | c/locale/dsc localeconv}}
{{dsc inc | c/locale/dsc lconv}}
{{dsc h2 | Locale categories}}
{{dsc inc | c/locale/dsc LC_categories}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/locale |Localization library}}
{{dsc end}}

[[de:c/locale]]
[[es:c/locale]]
[[fr:c/locale]]
[[it:c/locale]]
[[ja:c/locale]]
[[pt:c/locale]]
[[ru:c/locale]]
[[zh:c/locale]]</text>
      <sha1>05k4b4ognls6zk79uoyp6783uu0dxw9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/locale/LC categories</title>
    <ns>0</ns>
    <id>6151</id>
    <revision>
      <id>56496</id>
      <parentid>48945</parentid>
      <timestamp>2013-06-01T05:37:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2545">{{title|&lt;small&gt;LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME&lt;/small&gt;}}
{{c/locale/navbar}}
{{dcl begin}}
{{dcl header|locale.h}}
{{dcl |
#define LC_ALL      /*implementation defined*/
}}
{{dcl |
#define LC_COLLATE  /*implementation defined*/
}}
{{dcl |
#define LC_CTYPE    /*implementation defined*/
}}
{{dcl |
#define LC_MONETARY /*implementation defined*/
}}
{{dcl |
#define LC_NUMERIC  /*implementation defined*/
}}
{{dcl |
#define LC_TIME     /*implementation defined*/
}}
{{dcl end}}

Each of the above macro constants expand to integer constant expressions with distinct values that are suitable for use as the first argument of {{lc|setlocale}}.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|LC_ALL}}      | selects the entire C locale}}
{{dsc | {{tt|LC_COLLATE}}  | selects the collation category of the C locale}}
{{dsc | {{tt|LC_CTYPE}}    | selects the character classification category of the C locale}}
{{dsc | {{tt|LC_MONETARY}} | selects the monetary formatting category of the C locale}}
{{dsc | {{tt|LC_NUMERIC}}  | selects the numeric formatting category of the C locale}}
{{dsc | {{tt|LC_TIME}}     | selects the time formatting category of the C locale}}
{{dsc end}}

Additional macro constants, with names that begin with {{tt|LC_}} followed by at least one uppercase letter, may be defined in {{tt|locale.h}}. For example, the POSIX specification requires LC_MESSAGES and the GNU C library additionally defines LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, and LC_IDENTIFICATION.

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
#include &lt;locale.h&gt;
#include &lt;time.h&gt;
#include &lt;wchar.h&gt;

int main()
{
    setlocale(LC_ALL, &quot;en_US.UTF-8&quot;); // the C locale will be the UTF-8 enabled English
    setlocale(LC_NUMERIC, &quot;de_DE&quot;);   // decimal dot will be German
    setlocale(LC_TIME, &quot;ja_JP&quot;);      // date/time formatting will be Japanese
    wchar_t str[100];
    time_t t = time(NULL);
    wcsftime(str, 100, L&quot;%A %c&quot;, localtime(&amp;t));
    wprintf(L&quot;Number: %.2f\nDate: %Ls\n&quot;, 3.14, str);
}
 | output=
Number: 3,14
Date: 月曜日 2011年12月19日 18時04分40秒
}}

===See also===
{{dsc begin}}
{{dsc inc | c/locale/dsc setlocale}}
{{dsc see cpp | cpp/locale/LC_categories | locale categories | nomono=true}}
{{dsc end}}

[[de:c/locale/LC categories]]
[[es:c/locale/LC categories]]
[[fr:c/locale/LC categories]]
[[it:c/locale/LC categories]]
[[ja:c/locale/LC categories]]
[[pt:c/locale/LC categories]]
[[ru:c/locale/LC categories]]
[[zh:c/locale/LC categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/locale/lconv</title>
    <ns>0</ns>
    <id>6149</id>
    <revision>
      <id>56499</id>
      <parentid>48946</parentid>
      <timestamp>2013-06-01T05:37:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="6101">{{c/title | lconv}}
{{c/locale/navbar}}
{{dcl begin}}
{{dcl header | locale.h}}
{{dcl | 1=
struct lconv;
}}
{{dcl end}}

The struct {{tt|lconv}} contains numeric and monetary formatting rules as defined by a C locale. Objects of this struct may be obtained with {{lc|localeconv}}. The members of {{tt|lconv}} are values of type {{c|char}} and of type {{c|char*}}. Each {{c|char*}} member except {{tt|decimal_point}} may be pointing at a null character (that is, at an empty C-string). The members of type {{c|char}} are all non-negative numbers, any of which may be {{lc|CHAR_MAX}} if the corresponding value is not available in the current C locale.

===Member objects===
====Non-monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} decimal_point | the character used as the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} thousands_sep | the character used to separate groups of digits before the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} grouping | a string whose elements indicate the sizes of digit groups}}
{{dsc end}}
====Monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_decimal_point | the character used as the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_thousands_sep | the character used to separate groups of digits before the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_grouping | a string whose elements indicate the sizes of digit groups}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} positive_sign | a string used to indicate non-negative monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} negative_sign | a string used to indicate negative monetary quantity}}
{{dsc end}}
====Local monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} currency_symbol | the symbol used for currency in the current C locale}}
{{dsc mem obj | nolink=true | {{dsc small|char}} frac_digits | the number of digits after the decimal point to display in a monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_cs_precedes | {{c|1}} if currency_symbol is placed before non-negative value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_cs_precedes | {{c|1}} if currency_symbol is placed before negative value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|positive_sign}}, and the non-negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|negative_sign}}, and the negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_sign_posn | indicates the position of {{tt|positive_sign}} in a non-negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_sign_posn | indicates the position of {{tt|negative_sign}} in a negative monetary value}}
{{dsc end}}
====International monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} int_curr_symbol | the string used as international currency name in the current C locale}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_frac_digits | the number of digits after the decimal point to display in an international monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_cs_precedes | {{c|1}} if currency_symbol is placed before non-negative international monetary value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_cs_precedes | {{c|1}} if currency_symbol is placed before negative international monetary value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|positive_sign}}, and the non-negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|negative_sign}}, and the negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_sign_posn | indicates the position of {{tt|positive_sign}} in a non-negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_sign_posn | indicates the position of {{tt|negative_sign}} in a negative international monetary value}}
{{dsc end}}


The characters of the C-strings pointed to by {{tt|grouping}} and {{tt|mon_grouping}} are interpreted according to their numeric values. When the terminating {{c|'\0'}} is encountered, the last value seen is assumed to repeat for the remainder of digits. If {{lc|CHAR_MAX}} is encountered, no further digits are grouped. the typical grouping of three digits at a time is {{c|&quot;\003&quot;}}.

The values of {{tt|p_sep_by_space}}, {{tt|n_sep_by_space}}, {{tt|int_p_sep_by_space}}, {{tt|int_n_sep_by_space}} are interpreted as follows:
{{dsc begin}}
{{dsc|0|no space separates the currency symbol and the value}}
{{dsc|1|sign sticks to the currency symbol, value is separated by a space}}
{{dsc|2|sign sticks to the value. Currency symbol is separated by a space}}
{{dsc end}}

The values of {{tt|p_sign_posn}}, {{tt|n_sign_posn}}, {{tt|int_p_sign_posn}}, {{tt|int_n_sign_posn}} are interpreted as follows:
{{dsc begin}}
{{dsc|0|parentheses around the value and the currency symbol are used to represent the sign}}
{{dsc|1|sign before the value and the currency symbol}}
{{dsc|2|sign after the value and the currency symbol}}
{{dsc|3|sign before the currency symbol}}
{{dsc|4|sign after the currency symbol}}
{{dsc end}}

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/locale/dsc localeconv}}
{{dsc see cpp | cpp/locale/lconv}}
{{dsc end}}

[[de:c/locale/lconv]]
[[es:c/locale/lconv]]
[[fr:c/locale/lconv]]
[[it:c/locale/lconv]]
[[ja:c/locale/lconv]]
[[pt:c/locale/lconv]]
[[ru:c/locale/lconv]]
[[zh:c/locale/lconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/locale/localeconv</title>
    <ns>0</ns>
    <id>6150</id>
    <revision>
      <id>56500</id>
      <parentid>48947</parentid>
      <timestamp>2013-06-01T05:37:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1001">{{c/title|localeconv}}
{{c/locale/navbar}}
{{dcl begin}}
{{dcl header|locale.h}}
{{dcl |
lconv* localeconv();
}}
{{dcl end}}

The {{tt|localeconv}} function obtains a pointer to a static object of type {{lc|lconv}}, which represents numeric and monetary formatting rules of the current C locale.

===Parameters===
(none)

===Return value===
pointer to the current {{lc|lconv}} object. 

===Notes===
Modifying the object references through the returned pointer is undefined behavior.

{{tt|localeconv}} modifies a static object, calling it from different threads without synchronization is undefined behavior.

===Example===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | c/locale/dsc setlocale}}
{{dsc inc | c/locale/dsc lconv}}
{{dsc see cpp | cpp/locale/localeconv}}
{{dsc end}}

[[de:c/locale/localeconv]]
[[es:c/locale/localeconv]]
[[fr:c/locale/localeconv]]
[[it:c/locale/localeconv]]
[[ja:c/locale/localeconv]]
[[pt:c/locale/localeconv]]
[[ru:c/locale/localeconv]]
[[zh:c/locale/localeconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/locale/setlocale</title>
    <ns>0</ns>
    <id>6152</id>
    <revision>
      <id>56503</id>
      <parentid>48948</parentid>
      <timestamp>2013-06-01T05:37:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2493">{{c/title|setlocale}}
{{c/locale/navbar}}
{{dcl begin}}
{{dcl header|locale.h}}
{{dcl |
char* setlocale( int category, const char* locale);
}}
{{dcl end}}

The {{tt|setlocale}} function installs the specified system locale or its portion as the new C locale. The modifications remain in effect and influences the execution of all locale-sensitive C library functions until the next call to {{tt|setlocale}}. If {{tt|locale}} is a null pointer, {{tt|setlocale}} queries the current C locale without modifying it.

===Parameters===
{{par begin}}
{{par | category | locale category identifier, one of the {{rlp|LC_categories|LC_xxx}} macros. May be null.}}
{{par | locale | system-specific locale identifier. Can be {{c|&quot;&quot;}} for the user-preferred locale or {{c|&quot;C&quot;}} for the minimal locale }}
{{par end}}

===Return value===
pointer to a narrow null-terminated string identifying the C locale after applying the changes, if any, or null pointer on failure.

===Notes===
During program startup, the equivalent of {{c|setlocale(LC_ALL, &quot;C&quot;);}} is executed before any user code is run.

Although the return type is {{c|char*}}, modifying the pointed-to characters is undefined behavior.

Because {{tt|setlocale}} modifies global state which affects execution of locale-dependent functions, it is undefined behavior to call it from one thread, while another thread is executing any of the following functions: {{lc|fprintf}}, {{lc|isprint}}, {{lc|iswdigit}}, {{lc|localeconv}}, {{lc|tolower}}, {{lc|fscanf}}, {{lc|ispunct}}, {{lc|iswgraph}}, {{lc|mblen}}, {{lc|toupper}}, {{lc|isalnum}}, {{lc|isspace}}, {{lc|iswlower}}, {{lc|mbstowcs}}, {{lc|towlower}}, {{lc|isalpha}}, {{lc|isupper}}, {{lc|iswprint}}, {{lc|mbtowc}}, {{lc|towupper}}, {{lc|isblank}}, {{lc|iswalnum}}, {{lc|iswpunct}}, {{lc|setlocale}}, {{lc|wcscoll}}, {{lc|iscntrl}}, {{lc|iswalpha}}, {{lc|iswspace}}, {{lc|strcoll}}, {{lc|wcstod}}, {{lc|isdigit}}, {{lc|iswblank}}, {{lc|iswupper}}, {{lc|strerror}}, {{lc|wcstombs}}, {{lc|isgraph}}, {{lc|iswcntrl}}, {{lc|iswxdigit}}, {{lc|strtod}}, {{lc|wcsxfrm}}, {{lc|islower}}, {{lc|iswctype}}, {{lc|isxdigit}}.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/locale/dsc LC_categories}}
{{dsc see cpp | cpp/locale/setlocale}}
{{dsc end}}

[[de:c/locale/setlocale]]
[[es:c/locale/setlocale]]
[[fr:c/locale/setlocale]]
[[it:c/locale/setlocale]]
[[ja:c/locale/setlocale]]
[[pt:c/locale/setlocale]]
[[ru:c/locale/setlocale]]
[[zh:c/locale/setlocale]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory</title>
    <ns>0</ns>
    <id>5743</id>
    <revision>
      <id>71014</id>
      <parentid>70956</parentid>
      <timestamp>2014-06-04T18:56:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>redirect the new seealso to the appropriate C++ library</comment>
      <text xml:space="preserve" bytes="696">{{title|C memory management library}}
{{c/memory/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc fun | c/memory/malloc | allocates memory}}
{{dsc fun | c/memory/calloc | allocates and zeroes memory}}
{{dsc fun | c/memory/realloc | expands previously allocated memory block}}
{{dsc fun | c/memory/free | deallocates previously allocated memory}}
{{dsc fun | c/memory/aligned_alloc | allocates aligned memory |notes={{mark c11}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/memory/c | C memory management library}}
{{dsc end}}

[[de:c/memory]]
[[es:c/memory]]
[[fr:c/memory]]
[[it:c/memory]]
[[ja:c/memory]]
[[pt:c/memory]]
[[ru:c/memory]]
[[zh:c/memory]]</text>
      <sha1>ov7n5zywy166hlpmxmbqk2t7a6ubwow</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory/aligned alloc</title>
    <ns>0</ns>
    <id>13032</id>
    <revision>
      <id>71402</id>
      <parentid>66080</parentid>
      <timestamp>2014-06-10T14:22:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety  s/should/must</comment>
      <text xml:space="preserve" bytes="1704">{{c/title|aligned_alloc}}
{{c/memory/navbar}}
{{ddcl | header=stdlib.h | since=c11 | 
void *aligned_alloc( size_t alignment, size_t size );
}}

Allocate {{tt|size}} bytes of uninitialized storage whose alignment is specified by {{tt|alignment}}. The {{tt|size}} parameter must be an integral multiple of {{tt|alignment}}.

{{tt|aligned_alloc}} is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

A previous call to {{lc|free}} or {{lc|realloc}} that deallocates a region of memory ''synchronizes-with'' a call to {{lc|aligned_alloc}} that allocates the same or a part of the same region of memory. This synchronization occurs after any access to the memory by the deallocating function and before any access to the memory by {{tt|aligned_alloc}}

=== Parameters ===
{{par begin}}
{{par | alignment | specifies the alignment.  Must be a valid alignment supported by the implementation.}}
{{par | size | number of bytes to allocate.  An integral multiple of {{tt|alignment}}}}
{{par end}}

=== Return value ===
Either a null pointer or a pointer to the allocated memory. The pointer must be deallocated with {{lc|free()}}.

=== Notes ===
Passing a {{tt|size}} which is not an integral multiple of {{tt|alignment}} or a {{tt|alignment}} which is not valid or not supported by the implementation is undefined behavior.

E.g., the glibc requires {{tt|alignment}} to be a power of two and a multiple of {{tt|sizeof(void *)}}.

===References===
{{ref std c11}}
{{ref std | section=7.22.3.1 | title=Memory management functions}}
{{ref std end}}

=== See also ===
{{dsc begin}}
{{dsc see cpp | cpp/types/aligned storage}}
{{dsc end}}</text>
      <sha1>26voh13c4ap2yh16j6malxat39dh9z5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory/calloc</title>
    <ns>0</ns>
    <id>5748</id>
    <revision>
      <id>71408</id>
      <parentid>71401</parentid>
      <timestamp>2014-06-10T21:23:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note that all-bits-zero is not zero-initailziation</comment>
      <text xml:space="preserve" bytes="2482">{{c/title|calloc}}
{{c/memory/navbar}}
{{ddcl | header=stdlib.h |
void* calloc( size_t num, size_t size );
}}

Allocates memory for an array of {{tt|num}} objects of size {{tt|size}} and initializes all bits in the allocated storage to zero. 

If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any object type.

If {{tt|size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage)

{{rev begin}}
{{rev|since=c11|
{{tt|calloc}} is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

A previous call to {{lc|free}} or {{lc|realloc}} that deallocates a region of memory ''synchronizes-with'' a call to {{lc|calloc}} that allocates the same or a part of the same region of memory. This synchronization occurs after any access to the memory by the deallocating function and before any access to the memory by {{tt|calloc}}
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | num | number of objects}}
{{par | size | size of each object}}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or {{lc|NULL}} if error has occurred. The pointer must be deallocated with {{lc|free()}}.

===Notes===
Due to the alignment requirements, the number of allocated bytes is not necessarily equal to {{tt|num*size}}.

Initialization to all bits zero does not guarantee that a floating-point or a pointer would be initialized to 0.0 and the null pointer value, respectively (although that is true on all common platforms)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    /* Allocate an array of four integers. */
    /* Initialize all elements to 0.       */
    int *pa = calloc(4,sizeof(int));
    if (pa == NULL) {
       printf(&quot;calloc() failed in file %s at line # %d&quot;, __FILE__,__LINE__);
       exit(1);
    }
 
    /* Print one of the array elements. */
    printf(&quot;pa[3] = %d\n&quot;, pa[3]);
 
    /* Deallocate array pa. */
    free(pa);
    return 0;
}
 | p=true
 | output=
pa[3] = 0
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/memory/c/calloc}}
{{dsc end}}

[[de:c/memory/calloc]]
[[es:c/memory/calloc]]
[[fr:c/memory/calloc]]
[[it:c/memory/calloc]]
[[ja:c/memory/calloc]]
[[pt:c/memory/calloc]]
[[ru:c/memory/calloc]]
[[zh:c/memory/calloc]]</text>
      <sha1>a4k43hrbd4xwp9pecdhpxma89t4ljcd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory/free</title>
    <ns>0</ns>
    <id>5749</id>
    <revision>
      <id>71404</id>
      <parentid>70966</parentid>
      <timestamp>2014-06-10T14:25:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="2769">{{c/title|free}}
{{c/memory/navbar}}
{{ddcl | header=stdlib.h |
void free( void* ptr );
}}

Deallocates the space previously allocated by {{lc|malloc()}}, {{lc|calloc()}} or {{lc|realloc()}}. If {{tt|ptr}} is null-pointer, the function does nothing.

The behavior is undefined if {{tt|ptr}} does not match a pointer returned earlier by {{lc|malloc()}}, {{lc|calloc()}}, {{lc|realloc()}}, or {{lc|aligned_alloc()}}. Also, the behavior is undefined if the memory area referred to by {{tt|ptr}} has already been deallocated, that is, {{tt|free()}} or {{lc|realloc()}} has already been called with {{tt|ptr}} as the argument and no calls to {{lc|malloc()}}, {{lc|calloc()}} or {{lc|realloc()}} resulted in a pointer equal to {{tt|ptr}} afterwards.

{{rev begin}}
{{rev|since=c11|
{{tt|free}} is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

A call to {{lc|free}} that deallocates a region of memory ''synchronizes-with'' a call to any subsequent allocation function that allocates the same or a part of the same region of memory. This synchronization occurs after any access to the memory by the deallocating function and before any access to the memory by the allocation function.
}}
{{rev end}}
===Parameters===
{{par begin}}
{{par | ptr | pointer to the memory to deallocate}}
{{par end}}

===Return value===
(none)

===Example===
{{todo|simplify or make more practical}}
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void) 
{
    /* Allocate an array with 100 integers. */
    int *pa = malloc(100*sizeof(int));
    if (pa == NULL) {        /* check that memory allocation occurred */
       printf(&quot;malloc() failed in file %s at line # %d&quot;, __FILE__,__LINE__);
       printf(&quot;***  PROGRAM TERMINATED  ***&quot;);
       exit(1);
    }
    printf(&quot;starting address of pa:   %p\n&quot;, (void*)pa);

    /* Deallocate array pa. */
    free(pa), pa = NULL;

    /* Allocate an array with 100 doubles. */
    double *pb = malloc(100*sizeof(double));
    if (pb == NULL) {        /* check that memory allocation occurred */
       printf(&quot;malloc() failed in file %s at line # %d&quot;, __FILE__,__LINE__);  
       printf(&quot;***  PROGRAM TERMINATED  ***&quot;);
       exit(1);
    }

    /* Array pb may have the same starting address that array pa had. */
    printf(&quot;starting address of pb:   %p\n&quot;, (void*)pb);

    free(pb);
    return 0;
}
 | p=true
 | output=
starting address of pa:   0x2113010
starting address of pb:   0x2113010
}}
===See also===
{{dsc begin}}
{{dsc see cpp | cpp/memory/c/free}}
{{dsc end}}

[[de:c/memory/free]]
[[es:c/memory/free]]
[[fr:c/memory/free]]
[[it:c/memory/free]]
[[ja:c/memory/free]]
[[pt:c/memory/free]]
[[ru:c/memory/free]]
[[zh:c/memory/free]]</text>
      <sha1>tbgfgsrcwtmwrpgin2qnq7v9jq12uoi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory/malloc</title>
    <ns>0</ns>
    <id>5750</id>
    <revision>
      <id>71400</id>
      <parentid>70963</parentid>
      <timestamp>2014-06-10T14:14:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="2099">{{c/title|malloc}}
{{c/memory/navbar}}
{{ddcl | header=stdlib.h |
void* malloc( size_t size );
}}

Allocates {{tt|size}} bytes of uninitialized storage.

If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any object type.

If {{tt|size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage).

{{rev begin}}
{{rev|since=c11|
{{tt|malloc}} is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

A previous call to {{lc|free}} or {{lc|realloc}} that deallocates a region of memory ''synchronizes-with'' a call to {{lc|malloc}} that allocates the same or a part of the same region of memory. This synchronization occurs after any access to the memory by the deallocating function and before any access to the memory by {{tt|malloc}}
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | size | number of bytes to allocate }}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or null pointer if error has occurred. The pointer must be deallocated with {{lc|free()}}.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;   
#include &lt;stdlib.h&gt; 

int main(void) 
{
    /* Allocate an array of four integers. */
    int *pa = malloc(4*sizeof(int));
    if (pa == NULL) {
       printf(&quot;malloc() failed in file %s at line # %d&quot;, __FILE__,__LINE__);
       exit(1);
    }
    
    /* Initialize array A with values. */
    for (int ndx=0; ndx &lt; 4; ndx++)
        pa[ndx] = ndx;

    /* Print one of the array elements. */
    printf(&quot;pa[3] = %d\n&quot;, pa[3]);
    
    /* Deallocate array pa. */
    free(pa);
    return 0;
}
 | output=
pa[3] = 3
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/memory/c/malloc}}
{{dsc end}}

[[de:c/memory/malloc]]
[[es:c/memory/malloc]]
[[fr:c/memory/malloc]]
[[it:c/memory/malloc]]
[[ja:c/memory/malloc]]
[[pt:c/memory/malloc]]
[[ru:c/memory/malloc]]
[[zh:c/memory/malloc]]</text>
      <sha1>agttn30usnu311ibx5bhr6tyiet3of5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/memory/realloc</title>
    <ns>0</ns>
    <id>5751</id>
    <revision>
      <id>71405</id>
      <parentid>71403</parentid>
      <timestamp>2014-06-10T14:27:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+ realloc-&gt;any synchronization</comment>
      <text xml:space="preserve" bytes="3742">{{c/title|realloc}}
{{c/memory/navbar}}
{{ddcl | header=stdlib.h |
void *realloc( void *ptr, size_t new_size );
}}

Reallocates the given area of memory. It must be previously allocated by {{lc|malloc()}}, {{lc|calloc()}} or {{tt|realloc()}} and not yet freed with {{lc|free}}, otherwise, the results are undefined.

The reallocation is done by either:
@a@ expanding or contracting the existing area pointed to by {{tt|ptr}}, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the area is expanded, the contents of the new part of the array are undefined. 
@b@ allocating a new memory block of size {{tt|new_size}} bytes, copying memory area with size equal the lesser of the new and the old sizes, and freeing the old block.

If there is not enough memory, the old memory block is not freed and null-pointer is returned.

If {{tt|ptr}} is {{lc|NULL}}, the behavior is the same as calling {{lc|malloc}}({{tt|new_size}}).

If {{tt|new_size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage).

{{rev begin}}
{{rev|since=c11|
{{tt|realloc}} is thread-safe: it behaves as though only accessing the memory locations visible through its argument, and not any static storage.

A previous call to {{lc|free}} or {{tt|realloc}} that deallocates a region of memory ''synchronizes-with'' a call to any allocation function, including {{tt|realloc}} that allocates the same or a part of the same region of memory. This synchronization occurs after any access to the memory by the deallocating function and before any access to the memory by {{tt|realloc}}
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | ptr | pointer to the memory area to be reallocated}}
{{par | new_size | new size of the array}}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or {{lc|NULL}} if an error has occurred. The pointer must be deallocated with {{lc|free()}}.

===Example===
{{todo|simplify or make more practical}}
{{example
 |
 | code=
#include &lt;stdio.h&gt;  
#include &lt;stdlib.h&gt;

int main(void) 
{
    /* Allocate array A with 6 integers. */
    int* pa = realloc(NULL, 6*sizeof(int));
    if (!pa) {   /* if realloc() fails, terminate program */
       printf(&quot;realloc() failed in file %s at line %d\n&quot;, __FILE__,__LINE__);
       printf(&quot;***  PROGRAM TERMINATED  *** \n&quot;);
       exit(1);
    }
    printf(&quot;starting address of pa:   %p\n&quot;, (void*)pa);
    
    /* Allocate a single integer to provide a barrier to an expansion of pa. */
    int* pb = malloc(1 * sizeof(int));
    if (!pb) {   /* if malloc() fails, terminate program */
       printf(&quot;malloc() failed in file %s at line %d\n&quot;, __FILE__,__LINE__);
       printf(&quot;***  PROGRAM TERMINATED  *** \n&quot;);
       exit(1);
    }
    
    /* The starting address of array A changes because there is insufficient */
    /* room to expand A from 6 to 7 integers.                                */
    pa = realloc(pa, 7*sizeof(int));
    if (!pa) {   /* if realloc() fails, terminate program */
       printf(&quot;realloc() failed in file %s at line %d\n&quot;, __FILE__,__LINE__);
       printf(&quot;***  PROGRAM TERMINATED  *** \n&quot;);
       exit(1);
    }
    printf(&quot;starting address of pa:   %p\n&quot;, (void*)pa);

    free(pa);
    free(pb);
    return 0;
}
 | p=true
 | output=
starting address of pa:   0x1f82010
starting address of pa:   0x1f82050
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/memory/c/realloc}}
{{dsc end}}

[[de:c/memory/realloc]]
[[es:c/memory/realloc]]
[[fr:c/memory/realloc]]
[[it:c/memory/realloc]]
[[ja:c/memory/realloc]]
[[pt:c/memory/realloc]]
[[ru:c/memory/realloc]]
[[zh:c/memory/realloc]]</text>
      <sha1>a19xtkrjucg3u88bboinb96t7f36vl9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric</title>
    <ns>0</ns>
    <id>6357</id>
    <revision>
      <id>71029</id>
      <parentid>70993</parentid>
      <timestamp>2014-06-04T20:06:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="539">{{title|Numerics}}
{{c/numeric/navbar}}

===[[c/numeric/math | Mathematical functions]]===

===[[c/numeric/fenv | Floating-point environment]]===

===[[c/numeric/random | Pseudo-random number generation]]===

===[[c/numeric/complex | Complex number arithmetic]]===

===[[c/numeric/tgmath | Type-generic math]]===

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric |Numerics library}}
{{dsc end}}

[[de:c/numeric]]
[[es:c/numeric]]
[[fr:c/numeric]]
[[it:c/numeric]]
[[ja:c/numeric]]
[[pt:c/numeric]]
[[ru:c/numeric]]
[[zh:c/numeric]]</text>
      <sha1>8e6izpulskzu4k6450oj53iq786kw70</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex</title>
    <ns>0</ns>
    <id>6518</id>
    <revision>
      <id>71058</id>
      <parentid>70877</parentid>
      <timestamp>2014-06-05T01:27:32Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ See also C++</comment>
      <text xml:space="preserve" bytes="5197">{{title|Complex number arithmetic}}
{{c/numeric/complex/navbar}}

The header {{tt|&lt;complex.h&gt;}} defines macros and declares functions that support complex number arithmetic. Complex values are values of type {{tt|double complex}}, {{tt|float complex}}, {{tt|long double complex}}, 

If the macro constant {{tt|__STDC_IEC_559_COMPLEX__}}{{mark c99}} is defined by the compiler, in addition to the complex types, the imaginary types are also supported: {{tt|double imaginary}}, {{tt|float imaginary}}, and {{tt|long double imaginary}}. When a value of imaginary type is converted to a value of complex type, the resulting complex type has its real component set to zero. When a value of complex type is converted to a value of imaginary type, the real component is discarded.

Standard arithmetic operators {{c|+, -, *, /}} can be used with real, complex, and imaginary types in any combination.

If the macro constant {{tt|__STDC_NO_COMPLEX__}}{{mark c11}} is defined by the compiler, the header {{tt|&lt;complex.h&gt;}} and all of the names listed here are not provided.

If {{c|#pragma STDC CX_LIMITED_RANGE on}} is used, complex multiplication, division, and absolute value may use simplified mathematical formulas, despite the possibility of intermediate overflow.

{{dsc begin}}
{{dsc header | complex.h}}
{{dsc h2 | Types}}
{{dsc inc | c/numeric/complex/dsc imaginary}}
{{dsc inc | c/numeric/complex/dsc complex}}

{{dsc h2 | The imaginary constant}}
{{dsc inc | c/numeric/complex/dsc Imaginary_I}}
{{dsc inc | c/numeric/complex/dsc Complex_I}}
{{dsc inc | c/numeric/complex/dsc I}}

{{dsc h2 | Manipulation}}
{{dsc inc | c/numeric/complex/dsc CMPLX}}
{{dsc inc | c/numeric/complex/dsc creal}}
{{dsc inc | c/numeric/complex/dsc cimag}}
{{dsc inc | c/numeric/complex/dsc cabs}}
{{dsc inc | c/numeric/complex/dsc carg}}
{{dsc inc | c/numeric/complex/dsc conj}}
{{dsc inc | c/numeric/complex/dsc cproj}}

{{dsc h2 | Exponential functions}}
{{dsc inc | c/numeric/complex/dsc cexp}}
{{dsc inc | c/numeric/complex/dsc clog}}

{{dsc h2 | Power functions}}
{{dsc inc | c/numeric/complex/dsc cpow}}
{{dsc inc | c/numeric/complex/dsc csqrt}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | c/numeric/complex/dsc csin}}
{{dsc inc | c/numeric/complex/dsc ccos}}
{{dsc inc | c/numeric/complex/dsc ctan}}
{{dsc inc | c/numeric/complex/dsc casin}}
{{dsc inc | c/numeric/complex/dsc cacos}}
{{dsc inc | c/numeric/complex/dsc catan}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | c/numeric/complex/dsc csinh}}
{{dsc inc | c/numeric/complex/dsc ccosh}}
{{dsc inc | c/numeric/complex/dsc ctanh}}
{{dsc inc | c/numeric/complex/dsc casinh}}
{{dsc inc | c/numeric/complex/dsc cacosh}}
{{dsc inc | c/numeric/complex/dsc catanh}}
{{dsc end}}

===Notes===
Although the C standard names the inverse hyperbolics with &quot;complex arc hyperbolic sine&quot; etc., the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct names are &quot;complex inverse hyperbolic sine&quot; etc. Some authors use &quot;complex area hyperbolic sine&quot; etc.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    #ifdef __STDC_IEC_559_COMPLEX__
           printf(&quot;_STDC_IEC_559_COMPLEX__ defined\n&quot;);
    #else
           printf(&quot;_STDC_IEC_559_COMPLEX__ not defined\n&quot;);
    #endif
    #ifdef __STDC_NO_COMPLEX__
           printf(&quot;__STDC_NO_COMPLEX__ defined\n&quot;);
    #else
           printf(&quot;__STDC_NO_COMPLEX__ not defined\n&quot;);
    #endif
    printf(&quot;\n&quot;);

    printf(&quot;%2zu\n&quot;, sizeof(float complex));           /*  8 */
    printf(&quot;%2zu\n&quot;, sizeof(double complex));          /* 16 */
    printf(&quot;%2zu\n&quot;, sizeof(long double complex));     /* implementation-defined */

    /* Two macros represent the imaginary unit “i”: */
    /*      _Complex_I                              */
    /*      I                                       */
    printf(&quot;%.1f%+.1fi\n&quot;, creal(_Complex_I),cimag(_Complex_I));
    printf(&quot;%.1f%+.1fi\n&quot;, creal(I),cimag(I));
    
    /* The central property of the imaginary unit:  i*i is -1. */
    printf(&quot;%.1f%+.1fi\n&quot;, creal(1.0*_Complex_I*1.0*_Complex_I),
                           cimag(1.0*_Complex_I*1.0*_Complex_I));
    printf(&quot;%.1f%+.1fi\n&quot;, creal(1.0*I*1.0*I),cimag(1.0*I*1.0*I));
 
    /* Use the macros to define complex constants. */
    double complex z1 = 1.0 + 2.0*I;
    double complex z2 = 2.0 + 4.0*_Complex_I;
    
    /* Sum and print. */
    double complex z3 = z1+z2;
    printf(&quot;%.1f%+.1fi\n&quot;, creal(z3),cimag(z3));

    /* When the macro named &quot;I&quot; conflicts in an application, */
    /* define a new macro named &quot;J&quot; or &quot;j&quot;.                  */
    #undef I
    #define J _Complex_I
    z1 = 1.5 + 2.5*J;

    return 0;
}
 | p=true
 | output=
_STDC_IEC_559_COMPLEX__ defined
__STDC_NO_COMPLEX__ not defined

 8
16
32
0.0+1.0i
0.0+1.0i
-1.0+0.0i
-1.0+0.0i
3.0+6.0i
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/complex | Complex number arithmetic}}
{{dsc end}}

[[de:c/numeric/complex]]
[[es:c/numeric/complex]]
[[fr:c/numeric/complex]]
[[it:c/numeric/complex]]
[[ja:c/numeric/complex]]
[[pt:c/numeric/complex]]
[[ru:c/numeric/complex]]
[[zh:c/numeric/complex]]</text>
      <sha1>p5ve70go6zhn3c3dpk4qoxrh69lq0zm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/CMPLX</title>
    <ns>0</ns>
    <id>9381</id>
    <revision>
      <id>71291</id>
      <parentid>71230</parentid>
      <timestamp>2014-06-09T04:21:31Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to I</comment>
      <text xml:space="preserve" bytes="1386">{{c/title|CMPLXF|CMPLX|CMPLXL}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c11 |
float complex       CMPLXF( float real, float imag );
}}
{{dcl | since=c11 |
double complex      CMPLX( double real, double imag );
}}
{{dcl | since=c11 |
long double complex CMPLXL( long double real, long double imag );
}}
{{dcl end}}

Returns a complex number composed of {{tt|real}} as the real part and {{tt|imag}} as the imaginary part. The functions are implemented as macros. 

The returned value is suitable for use as an initializer for variables with static or thread storage duration, but only if {{tt|real}} and {{tt|imag}} are also suitable.

===Parameters===
{{par begin}}
{{par | real | the real part of the complex number to return}}
{{par | imag | the imaginary part of the complex number to return}}
{{par end}}

===Return value===
A complex number composed of {{tt|real}} and {{tt|imag}} as the real and imaginary parts.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc I}}
{{dsc see cpp | cpp/numeric/complex/complex}}
{{dsc end}}

[[de:c/numeric/complex/CMPLX]]
[[es:c/numeric/complex/CMPLX]]
[[fr:c/numeric/complex/CMPLX]]
[[it:c/numeric/complex/CMPLX]]
[[ja:c/numeric/complex/CMPLX]]
[[pt:c/numeric/complex/CMPLX]]
[[ru:c/numeric/complex/CMPLX]]
[[zh:c/numeric/complex/CMPLX]]</text>
      <sha1>rn2jew1jwarxiipf1jernqdrbs9prg3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/Complex I</title>
    <ns>0</ns>
    <id>9356</id>
    <revision>
      <id>70048</id>
      <parentid>70046</parentid>
      <timestamp>2014-05-08T15:00:23Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>explicitly prints _Complex_I</comment>
      <text xml:space="preserve" bytes="1535">{{c/title|Complex_I}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
#define _Complex_I /* unspecified */
}}
{{dcl end}}

The {{tt|_Complex_I}} macro expands to a value of type {{c|const float _Complex}} with the value of the imaginary unit.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    #ifdef __STDC_NO_COMPLEX__
            printf(&quot;__STDC_NO_COMPLEX__ is defined.\n&quot;);
    #else
        printf(&quot;__STDC_NO_COMPLEX__ is undefined.\n&quot;);
    #endif
    
    #ifdef __STDC_IEC_559_COMPLEX__
        printf(&quot;__STDC_IEC_559_COMPLEX__ is defined.\n&quot;);
    #else
        printf(&quot;__STDC_IEC_559_COMPLEX__ is undefined.\n&quot;);
    #endif

    printf(&quot;_Complex_I = %.1f%+.1fi\n&quot;, creal(_Complex_I), cimag(_Complex_I));
    printf(&quot;sizeof(_Complex_I) = %zu\n&quot;, sizeof(_Complex_I));

    double complex z = 1.0 + 2.0*_Complex_I;
    printf(&quot;z = %.1f%+.1fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
__STDC_NO_COMPLEX__ is undefined.
__STDC_IEC_559_COMPLEX__ is defined.
_Complex_I = 0.0+1.0i
sizeof(_Complex_I) = 8
z = 1.0+2.0i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc Imaginary_I}}
{{dsc inc | c/numeric/complex/dsc I}}
{{dsc end}}

[[de:c/numeric/complex/Complex I]]
[[es:c/numeric/complex/Complex I]]
[[fr:c/numeric/complex/Complex I]]
[[it:c/numeric/complex/Complex I]]
[[ja:c/numeric/complex/Complex I]]
[[pt:c/numeric/complex/Complex I]]
[[ru:c/numeric/complex/Complex I]]
[[zh:c/numeric/complex/Complex I]]</text>
      <sha1>mo209b17eby9gvfgix3if78pdo3sjh3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/I</title>
    <ns>0</ns>
    <id>9358</id>
    <revision>
      <id>71234</id>
      <parentid>71226</parentid>
      <timestamp>2014-06-08T20:22:43Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to CMPLX and C++ documentation</comment>
      <text xml:space="preserve" bytes="1856">{{c/title|I&amp;nbsp;}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
#define I /* unspecified */
}}
{{dcl end}}

The {{tt|I}} macro expands to either {{lc|Complex_I}} or {{lc|Imaginary_I}}. If the implementation does not support imaginary types, then the macro always expands to {{lc|Complex_I}}.

{{todo|on what condition imaginary types are supported? The standard seems unclear. Maybe when __STDC_IEC_559_COMPLEX__ is defined?}}

A program may undefine and perhaps then redefine the {{lc|imaginary}} macro.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    #ifdef __STDC_NO_COMPLEX__
            printf(&quot;__STDC_NO_COMPLEX__ is defined.\n&quot;);
    #else
        printf(&quot;__STDC_NO_COMPLEX__ is undefined.\n&quot;);
    #endif
    
    #ifdef __STDC_IEC_559_COMPLEX__
        printf(&quot;__STDC_IEC_559_COMPLEX__ is defined.\n&quot;);
    #else
        printf(&quot;__STDC_IEC_559_COMPLEX__ is undefined.\n&quot;);
    #endif

    printf(&quot;I = %.1f%+.1fi\n&quot;, creal(I), cimag(I));
    printf(&quot;sizeof(I) = %zu\n&quot;, sizeof(I));  
    printf(&quot;sizeof(_Complex_I) = %zu\n&quot;, sizeof(_Complex_I));
    
    double complex z = 1.0 + 2.0*I;
    printf(&quot;z = %.1f%+.1fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
__STDC_NO_COMPLEX__ is undefined.
__STDC_IEC_559_COMPLEX__ is defined.
I = 0.0+1.0i
sizeof(I) = 8
sizeof(_Complex_I) = 8
z = 1.0+2.0i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc Imaginary_I}}
{{dsc inc | c/numeric/complex/dsc Complex_I}}
{{dsc inc | c/numeric/complex/dsc CMPLX}}
{{dsc see cpp | cpp/numeric/complex/operator&quot;&quot;i}}
{{dsc end}}

[[de:c/numeric/complex/I]]
[[es:c/numeric/complex/I]]
[[fr:c/numeric/complex/I]]
[[it:c/numeric/complex/I]]
[[ja:c/numeric/complex/I]]
[[pt:c/numeric/complex/I]]
[[ru:c/numeric/complex/I]]
[[zh:c/numeric/complex/I]]</text>
      <sha1>m0whlyfmjbcpnzfvsgw3881llje2bkw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/Imaginary I</title>
    <ns>0</ns>
    <id>9357</id>
    <revision>
      <id>62516</id>
      <parentid>56511</parentid>
      <timestamp>2013-07-01T23:23:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="892">{{c/title|Imaginary_I}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
#define Imaginary_I /* unspecified */
}}
{{dcl end}}

The {{tt|Imaginary_I}} macro expands to a value of type {{c|const float _Imaginary}} with the value of the imaginary unit. The macro is defined only if the implementation supports imaginary types. 
{{todo|on what condition? The standard seems unclear. Maybe when __STDC_IEC_559_COMPLEX__ is defined?}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc Complex_I}}
{{dsc inc | c/numeric/complex/dsc I}}
{{dsc end}}

[[de:c/numeric/complex/Imaginary I]]
[[es:c/numeric/complex/Imaginary I]]
[[fr:c/numeric/complex/Imaginary I]]
[[it:c/numeric/complex/Imaginary I]]
[[ja:c/numeric/complex/Imaginary I]]
[[pt:c/numeric/complex/Imaginary I]]
[[ru:c/numeric/complex/Imaginary I]]
[[zh:c/numeric/complex/Imaginary I]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cabs</title>
    <ns>0</ns>
    <id>9371</id>
    <revision>
      <id>71272</id>
      <parentid>70170</parentid>
      <timestamp>2014-06-09T03:36:37Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1159">{{c/title|cabsf|cabs|cabsl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float       cabsf( float complex z );
}}
{{dcl | since=c99 |
double      cabs( double complex z );
}}
{{dcl | since=c99 |
long double cabsl( long double complex z );
}}
{{dcl end}}

Computes the complex absolute value of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex absolute value of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    double x = cabs(1.0 + 2.0*I);
    printf(&quot;%f\n&quot;, x);
    
    return 0;
}
 | output=
2.236068
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc carg}}
{{dsc inc | c/numeric/math/dsc abs}}
{{dsc inc | c/numeric/math/dsc fabs}}
{{dsc inc | c/numeric/math/dsc hypot}}
{{dsc see cpp | cpp/numeric/complex/abs}}
{{dsc end}}

[[de:c/numeric/complex/cabs]]
[[es:c/numeric/complex/cabs]]
[[fr:c/numeric/complex/cabs]]
[[it:c/numeric/complex/cabs]]
[[ja:c/numeric/complex/cabs]]
[[pt:c/numeric/complex/cabs]]
[[ru:c/numeric/complex/cabs]]
[[zh:c/numeric/complex/cabs]]</text>
      <sha1>eqg95moo22hmkcdlewucv84rzufh9v3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cacos</title>
    <ns>0</ns>
    <id>9359</id>
    <revision>
      <id>70581</id>
      <parentid>70057</parentid>
      <timestamp>2014-05-25T19:48:43Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1662">{{c/title|cacosf|cacos|cacosl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       cacosf( float complex z );
}}
{{dcl | since=c99 |
double complex      cacos( double complex z );
}}
{{dcl | since=c99 |
long double complex cacosl( long double complex z );
}}
{{dcl end}}

Computes the complex arc cosine of {{tt|z}} with branch cuts outside the interval {{math|[−1,+1]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc cosine of {{tt|z}} in the interval {{math|[0; π]}} along the real axis and in the interval {{math|(−∞; ∞)}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;

    z = ccos(1.0+2.0*I);
    printf(&quot;ccos(1.0+2.0i)            ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = cacos(2.032723-3.051898*I);
    printf(&quot;cacos(2.032723-3.051898i) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}

 | output=
ccos(1.0+2.0i)            ==&gt; 2.032723-3.051898i
cacos(2.032723-3.051898i) ==&gt; 1.000000+2.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc casin}}
{{dsc inc | c/numeric/complex/dsc catan}}
{{dsc inc | c/numeric/complex/dsc ccos}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc see cpp | cpp/numeric/complex/acos}}
{{dsc end}}

[[de:c/numeric/complex/cacos]]
[[es:c/numeric/complex/cacos]]
[[fr:c/numeric/complex/cacos]]
[[it:c/numeric/complex/cacos]]
[[ja:c/numeric/complex/cacos]]
[[pt:c/numeric/complex/cacos]]
[[ru:c/numeric/complex/cacos]]
[[zh:c/numeric/complex/cacos]]</text>
      <sha1>49skj7k9xovtan0n1abcyrp3qeqkvf5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cacosh</title>
    <ns>0</ns>
    <id>9369</id>
    <revision>
      <id>70587</id>
      <parentid>70063</parentid>
      <timestamp>2014-05-25T19:59:15Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1709">{{c/title|cacoshf|cacosh|cacoshl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       cacoshf( float complex z );
}}
{{dcl | since=c99 |
double complex      cacosh( double complex z );
}}
{{dcl | since=c99 |
long double complex cacoshl( long double complex z );
}}
{{dcl end}}

Computes the complex arc hyperbolic cosine of {{tt|z}} with branch cuts outside the values less than 1 along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc hyperbolic cosine of {{tt|z}} in the interval {{math|[0; ∞)}} along the real axis and in the interval {{math|[−iπ; +iπ]}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;
 
    z = ccosh(1.0+2.0*I);
    printf(&quot;ccosh(1.0+2.0*I)             ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    z = cacosh(-0.642148+1.068607*I);
    printf(&quot;cacosh(-0.642148+1.068607*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}
 | output=
ccosh(1.0+2.0*I)             ==&gt; -0.642148+1.068607i
cacosh(-0.642148+1.068607*I) ==&gt; 1.000000+2.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc casinh}}
{{dsc inc | c/numeric/complex/dsc catanh}}
{{dsc inc | c/numeric/complex/dsc ccosh}}
{{dsc inc | c/numeric/math/dsc acosh}}
{{dsc see cpp | cpp/numeric/complex/acosh}}
{{dsc end}}

[[de:c/numeric/complex/cacosh]]
[[es:c/numeric/complex/cacosh]]
[[fr:c/numeric/complex/cacosh]]
[[it:c/numeric/complex/cacosh]]
[[ja:c/numeric/complex/cacosh]]
[[pt:c/numeric/complex/cacosh]]
[[ru:c/numeric/complex/cacosh]]
[[zh:c/numeric/complex/cacosh]]</text>
      <sha1>baxnmdlcak51pqsyffj6o2ztlu1r7lp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/carg</title>
    <ns>0</ns>
    <id>9375</id>
    <revision>
      <id>71281</id>
      <parentid>70053</parentid>
      <timestamp>2014-06-09T03:56:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="2023">{{c/title|cargf|carg|cargl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float       cargf( float complex z );
}}
{{dcl | since=c99 |
double      carg( double complex z );
}}
{{dcl | since=c99 |
long double cargl( long double complex z );
}}
{{dcl end}}

Computes the argument (also called phase angle) of {{tt|z}}, with a branch cut along the negative real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The argument of {{tt|z}} in the interval {{math|(−π; π)}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;

int main(void) 
{
    double complex z;                 /* complex number     */
    double phase;                     /* phase angle        */
    double rtod = 180.0/acos(-1.0);   /* radians to degrees */
    
    z = 0.0+0.0*I;
    phase = carg(z);
    printf(&quot;%9f radians,  %6.1f degrees\n&quot;, phase,phase*rtod);
    
    z = 1.0+1.0*I;
    phase = carg(z);
    printf(&quot;%9f radians,  %6.1f degrees\n&quot;, phase,phase*rtod);
    
    z = -1.0+1.0*I;
    phase = carg(z);
    printf(&quot;%9f radians,  %6.1f degrees\n&quot;, phase,phase*rtod);
    
    z = -1.0-1.0*I;
    phase = carg(z);
    printf(&quot;%9f radians,  %6.1f degrees\n&quot;, phase,phase*rtod);
    
    z = 1.0-1.0*I;
    phase = carg(z);
    printf(&quot;%9f radians,  %6.1f degrees\n&quot;, phase,phase*rtod);
 
    return 0;
}
 | output=
 0.000000 radians,     0.0 degrees
 0.785398 radians,    45.0 degrees
 2.356194 radians,   135.0 degrees
-2.356194 radians,  -135.0 degrees
-0.785398 radians,   -45.0 degrees
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cabs}}
{{dsc inc | c/numeric/math/dsc atan2}}
{{dsc see cpp | cpp/numeric/complex/arg}}
{{dsc end}}

[[de:c/numeric/complex/carg]]
[[es:c/numeric/complex/carg]]
[[fr:c/numeric/complex/carg]]
[[it:c/numeric/complex/carg]]
[[ja:c/numeric/complex/carg]]
[[pt:c/numeric/complex/carg]]
[[ru:c/numeric/complex/carg]]
[[zh:c/numeric/complex/carg]]</text>
      <sha1>m0pledv1kxdbkcne5we8w6kc86lwarp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/casin</title>
    <ns>0</ns>
    <id>9360</id>
    <revision>
      <id>70580</id>
      <parentid>70058</parentid>
      <timestamp>2014-05-25T19:47:34Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1667">{{c/title|casinf|casin|casinl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       casinf( float complex z );
}}
{{dcl | since=c99 |
double complex      casin( double complex z );
}}
{{dcl | since=c99 |
long double complex casinl( long double complex z );
}}
{{dcl end}}

Computes the complex arc sine of {{tt|z}} with branch cuts outside the interval {{math|[−1,+1]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc sine of {{tt|z}} in the interval {{math|(−∞; ∞)}} along the imaginary axis and in the interval {{math|[−π/2; +π/2]}} along the real axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;

    z = csin(1.0+2.0*I);
    printf(&quot;csin(1.0+2.0i)            ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = casin(3.165779+1.959601*I);
    printf(&quot;casin(3.165779+1.959601i) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}

 | output=
csin(1.0+2.0i)            ==&gt; 3.165779+1.959601i
casin(3.165779+1.959601i) ==&gt; 1.000000+2.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cacos}}
{{dsc inc | c/numeric/complex/dsc catan}}
{{dsc inc | c/numeric/complex/dsc csin}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc see cpp | cpp/numeric/complex/asin}}
{{dsc end}}

[[de:c/numeric/complex/casin]]
[[es:c/numeric/complex/casin]]
[[fr:c/numeric/complex/casin]]
[[it:c/numeric/complex/casin]]
[[ja:c/numeric/complex/casin]]
[[pt:c/numeric/complex/casin]]
[[ru:c/numeric/complex/casin]]
[[zh:c/numeric/complex/casin]]</text>
      <sha1>rbflxlcfm619jzcafbq7uevyqswh4nf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/casinh</title>
    <ns>0</ns>
    <id>9370</id>
    <revision>
      <id>70586</id>
      <parentid>70064</parentid>
      <timestamp>2014-05-25T19:57:08Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1733">{{c/title|casinhf|casinh|casinhl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       casinhf( float complex z );
}}
{{dcl | since=c99 |
double complex      casinh( double complex z );
}}
{{dcl | since=c99 |
long double complex casinhl( long double complex z );
}}
{{dcl end}}

Computes the complex arc hyperbolic sine of {{tt|z}} with branch cuts outside the interval {{math|[−i; +i]}} along the imaginary axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc hyperbolic sine of {{tt|z}} in the interval {{math|(−∞; +∞)}} along the real axis and in the interval {{math|[−iπ/2; +iπ/2]}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;
 
    z = csinh(1.0+2.0*I);
    printf(&quot;csinh(1.0+2.0*I)             ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    z = casinh(-0.489056+1.403119*I);
    printf(&quot;casinh(-0.489056+1.403119*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}
 | output=
csinh(1.0+2.0*I)              ==&gt; -0.489056+1.403119i
casinh(-0.489056+1.403119i*I) ==&gt; -1.000000+1.141593i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cacosh}}
{{dsc inc | c/numeric/complex/dsc catanh}}
{{dsc inc | c/numeric/complex/dsc csinh}}
{{dsc inc | c/numeric/math/dsc asinh}}
{{dsc see cpp | cpp/numeric/complex/asinh}}
{{dsc end}}

[[de:c/numeric/complex/casinh]]
[[es:c/numeric/complex/casinh]]
[[fr:c/numeric/complex/casinh]]
[[it:c/numeric/complex/casinh]]
[[ja:c/numeric/complex/casinh]]
[[pt:c/numeric/complex/casinh]]
[[ru:c/numeric/complex/casinh]]
[[zh:c/numeric/complex/casinh]]</text>
      <sha1>hqfuh2e90mfef5scbpyrq0ei6f8y8zk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/catan</title>
    <ns>0</ns>
    <id>9361</id>
    <revision>
      <id>70582</id>
      <parentid>70059</parentid>
      <timestamp>2014-05-25T19:49:39Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1673">{{c/title|catanf|catan|catanl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       catanf( float complex z );
}}
{{dcl | since=c99 |
double complex      catan( double complex z );
}}
{{dcl | since=c99 |
long double complex catanl( long double complex z );
}}
{{dcl end}}

Computes the complex arc tangent of {{tt|z}} with branch cuts outside the interval {{math|[−i,+i]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc tangent of {{tt|z}} in the interval {{math|(−∞; ∞)}} along the imaginary axis and in the interval {{math|[−π/2; +π/2]}} along the real axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;

    z = ctan(1.0+2.0*I);
    printf(&quot;ctan(1.0+2.0i)            ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = catan(0.033813+1.014794*I);
    printf(&quot;catan(0.033813+1.014794i) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}

 | output=
ctan(1.0+2.0i)            ==&gt; 0.033813+1.014794i
catan(0.033813+1.014794i) ==&gt; 1.000004+1.999996i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc casin}}
{{dsc inc | c/numeric/complex/dsc cacos}}
{{dsc inc | c/numeric/complex/dsc ctan}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc see cpp | cpp/numeric/complex/atan}}
{{dsc end}}

[[de:c/numeric/complex/catan]]
[[es:c/numeric/complex/catan]]
[[fr:c/numeric/complex/catan]]
[[it:c/numeric/complex/catan]]
[[ja:c/numeric/complex/catan]]
[[pt:c/numeric/complex/catan]]
[[ru:c/numeric/complex/catan]]
[[zh:c/numeric/complex/catan]]</text>
      <sha1>7kt4cfz5z0zjtelhj6x5qtnrb8awisr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/catanh</title>
    <ns>0</ns>
    <id>9368</id>
    <revision>
      <id>70588</id>
      <parentid>70065</parentid>
      <timestamp>2014-05-25T20:00:32Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1725">{{c/title|catanhf|catanh|catanhl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       catanhf( float complex z );
}}
{{dcl | since=c99 |
double complex      catanh( double complex z );
}}
{{dcl | since=c99 |
long double complex catanhl( long double complex z );
}}
{{dcl end}}

Computes the complex arc hyperbolic tangent of {{tt|z}} with branch cuts outside the interval {{math|[−1; +1]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex arc hyperbolic tangent of {{tt|z}} in the interval {{math|(−∞; +∞)}} along the real axis and in the interval {{math|[−iπ/2; +iπ/2]}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{
    double complex z;
 
    z = ctanh(1.0+2.0*I);
    printf(&quot;ctanh(1.0+2.0*I)            ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    z = catanh(1.166736-0.243458*I);
    printf(&quot;catanh(1.166736-0.243458*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
 
    return 0;
}
 | output=
ctanh(1.0+2.0*I)            ==&gt; 1.166736-0.243458i
catanh(1.166736-0.243458*I) ==&gt; 1.000000-1.141592i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc casinh}}
{{dsc inc | c/numeric/complex/dsc cacosh}}
{{dsc inc | c/numeric/complex/dsc ctanh}}
{{dsc inc | c/numeric/math/dsc atanh}}
{{dsc see cpp | cpp/numeric/complex/atanh}}
{{dsc end}}

[[de:c/numeric/complex/catanh]]
[[es:c/numeric/complex/catanh]]
[[fr:c/numeric/complex/catanh]]
[[it:c/numeric/complex/catanh]]
[[ja:c/numeric/complex/catanh]]
[[pt:c/numeric/complex/catanh]]
[[ru:c/numeric/complex/catanh]]
[[zh:c/numeric/complex/catanh]]</text>
      <sha1>qeg9ematus6j4oszprvc75gi5qif4k6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/ccos</title>
    <ns>0</ns>
    <id>9362</id>
    <revision>
      <id>70578</id>
      <parentid>70060</parentid>
      <timestamp>2014-05-25T19:41:48Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1981">{{c/title|ccosf|ccos|ccosl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       ccosf( float complex z );
}}
{{dcl | since=c99 |
double complex      ccos( double complex z );
}}
{{dcl | since=c99 |
long double complex ccosl( long double complex z );
}}
{{dcl end}}

Computes the complex cosine of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex cosine of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;
 
#define PI acos(-1)
 
int main(void)
{
    double complex z;
    double x;
 
    /* Print familiar values. */
    int ndx;
    printf(&quot;            cos(x)          ccos(z)\n&quot;);
    printf(&quot;           --------    ------------------\n&quot;);
    for (ndx=0;ndx&lt;9;ndx++) {
        x = ndx*0.25*PI;
        z = x+0.0*I;
        z = ccos(z);
        printf(&quot;%.2f*PI   %9f   %9f%+fi\n&quot;, ndx*0.25,cos(x),creal(z),cimag(z));
    }
 
    return 0;
}

 | output=
            cos(x)          ccos(z)
           --------    ------------------
0.00*PI    1.000000    1.000000-0.000000i
0.25*PI    0.707107    0.707107-0.000000i
0.50*PI    0.000000    0.000000-0.000000i
0.75*PI   -0.707107   -0.707107-0.000000i
1.00*PI   -1.000000   -1.000000-0.000000i
1.25*PI   -0.707107   -0.707107+0.000000i
1.50*PI   -0.000000   -0.000000+0.000000i
1.75*PI    0.707107    0.707107+0.000000i
2.00*PI    1.000000    1.000000+0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc csin}}
{{dsc inc | c/numeric/complex/dsc ctan}}
{{dsc inc | c/numeric/complex/dsc cacos}}
{{dsc inc | c/numeric/math/dsc cos}}
{{dsc see cpp | cpp/numeric/complex/cos}}
{{dsc end}}

[[de:c/numeric/complex/ccos]]
[[es:c/numeric/complex/ccos]]
[[fr:c/numeric/complex/ccos]]
[[it:c/numeric/complex/ccos]]
[[ja:c/numeric/complex/ccos]]
[[pt:c/numeric/complex/ccos]]
[[ru:c/numeric/complex/ccos]]
[[zh:c/numeric/complex/ccos]]</text>
      <sha1>o9e4r868x1xo70yzznrs6yp4aweonom</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/ccosh</title>
    <ns>0</ns>
    <id>9367</id>
    <revision>
      <id>70584</id>
      <parentid>70066</parentid>
      <timestamp>2014-05-25T19:54:44Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1793">{{c/title|ccoshf|ccosh|ccoshl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       ccoshf( float complex z );
}}
{{dcl | since=c99 |
double complex      ccosh( double complex z );
}}
{{dcl | since=c99 |
long double complex ccoshl( long double complex z );
}}
{{dcl end}}

Computes the complex hyperbolic cosine of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex hyperbolic cosine of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;
 
#define PI acos(-1)
 
int main(void)
{
    double complex z;

    /* Hyperbolic functions are periodic with respect to the imaginary component. */
    /* The period of cosh is 2*pi*i.                                              */
    z = ccosh(0.0+0.0*PI*I);
    printf(&quot;ccosh(0.0+0*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));

    z = ccosh(0.0 + 2*PI*I);
    printf(&quot;ccosh(0.0+2*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = ccosh(0.0 + 4*PI*I);
    printf(&quot;ccosh(0.0+4*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    return 0;
}
 | output=
ccosh(0.0+0*PI*I) ==&gt; 1.000000+0.000000i
ccosh(0.0+2*PI*I) ==&gt; 1.000000-0.000000i
ccosh(0.0+4*PI*I) ==&gt; 1.000000-0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc csinh}}
{{dsc inc | c/numeric/complex/dsc ctanh}}
{{dsc inc | c/numeric/complex/dsc cacosh}}
{{dsc inc | c/numeric/math/dsc cosh}}
{{dsc see cpp | cpp/numeric/complex/cosh}}
{{dsc end}}

[[de:c/numeric/complex/ccosh]]
[[es:c/numeric/complex/ccosh]]
[[fr:c/numeric/complex/ccosh]]
[[it:c/numeric/complex/ccosh]]
[[ja:c/numeric/complex/ccosh]]
[[pt:c/numeric/complex/ccosh]]
[[ru:c/numeric/complex/ccosh]]
[[zh:c/numeric/complex/ccosh]]</text>
      <sha1>nxc02s4noym2mlpb1gz94b0or41q8oc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cexp</title>
    <ns>0</ns>
    <id>9372</id>
    <revision>
      <id>70634</id>
      <parentid>70171</parentid>
      <timestamp>2014-05-27T04:11:31Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to exp and C++ documentation</comment>
      <text xml:space="preserve" bytes="1154">{{c/title|cexpf|cexp|cexpl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       cexpf( float complex z );
}}
{{dcl | since=c99 |
double complex      cexp( double complex z );
}}
{{dcl | since=c99 |
long double complex cexpl( long double complex z );
}}
{{dcl end}}

Computes the complex base-''e'' exponential of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The base-''e'' exponential of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    double complex z = cexp(1.0 + 2.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
-1.131204+2.471727i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc clog}}
{{dsc inc | c/numeric/math/dsc exp}}
{{dsc see cpp | cpp/numeric/complex/exp}}
{{dsc end}}

[[de:c/numeric/complex/cexp]]
[[es:c/numeric/complex/cexp]]
[[fr:c/numeric/complex/cexp]]
[[it:c/numeric/complex/cexp]]
[[ja:c/numeric/complex/cexp]]
[[pt:c/numeric/complex/cexp]]
[[ru:c/numeric/complex/cexp]]
[[zh:c/numeric/complex/cexp]]</text>
      <sha1>a8f76jkuozennjl4wm4wazmsycmalgh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cimag</title>
    <ns>0</ns>
    <id>9377</id>
    <revision>
      <id>71604</id>
      <parentid>70041</parentid>
      <timestamp>2014-06-14T22:15:30Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C++ documentation</comment>
      <text xml:space="preserve" bytes="1082">{{c/title|cimagf|cimag|cimagl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float       cimagf( float complex z );
}}
{{dcl | since=c99 |
double      cimag( double complex z );
}}
{{dcl | since=c99 |
long double cimagl( long double complex z );
}}
{{dcl end}}

Returns the imaginary part of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The imaginary part of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{    
    double complex z = 1.0 + 2.0*I;
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
1.000000+2.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc creal}}
{{dsc see cpp | cpp/numeric/complex/imag2}}
{{dsc end}}

[[de:c/numeric/complex/cimag]]
[[es:c/numeric/complex/cimag]]
[[fr:c/numeric/complex/cimag]]
[[it:c/numeric/complex/cimag]]
[[ja:c/numeric/complex/cimag]]
[[pt:c/numeric/complex/cimag]]
[[ru:c/numeric/complex/cimag]]
[[zh:c/numeric/complex/cimag]]</text>
      <sha1>2fuptq9ufl4roxovtl4i0rcpwr5kf68</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/clog</title>
    <ns>0</ns>
    <id>9373</id>
    <revision>
      <id>70635</id>
      <parentid>70172</parentid>
      <timestamp>2014-05-27T04:13:58Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to log and C++ documentation</comment>
      <text xml:space="preserve" bytes="1338">{{c/title|clogf|clog|clogl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       clogf( float complex z );
}}
{{dcl | since=c99 |
double complex      clog( double complex z );
}}
{{dcl | since=c99 |
long double complex clogl( long double complex z );
}}
{{dcl end}}

Computes the complex natural (base-''e'') logarithm of {{tt|z}} with branch cut along the negative real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex natural logarithm of {{tt|z}} in the interval {{math|(−∞; +∞)}} along the real axis and in the interval {{math|(−iπ; +iπ)}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{
    double complex z = clog(1.0 + 2.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
0.804719+1.107149i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cexp}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc see cpp | cpp/numeric/complex/log}}
{{dsc end}}

[[de:c/numeric/complex/clog]]
[[es:c/numeric/complex/clog]]
[[fr:c/numeric/complex/clog]]
[[it:c/numeric/complex/clog]]
[[ja:c/numeric/complex/clog]]
[[pt:c/numeric/complex/clog]]
[[ru:c/numeric/complex/clog]]
[[zh:c/numeric/complex/clog]]</text>
      <sha1>btx51nrrkaz5ncmw0qqiwzabqg6pruo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/complex</title>
    <ns>0</ns>
    <id>9354</id>
    <revision>
      <id>62532</id>
      <parentid>56531</parentid>
      <timestamp>2013-07-01T23:27:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="650">{{c/title|complex}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
#define complex _Complex
}}
{{dcl end}}

This macro expands to a type specifier used to identify complex types.

A program may undefine and perhaps then redefine the {{lc|complex}} macro.

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc imaginary}}
{{dsc end}}

[[de:c/numeric/complex/complex]]
[[es:c/numeric/complex/complex]]
[[fr:c/numeric/complex/complex]]
[[it:c/numeric/complex/complex]]
[[ja:c/numeric/complex/complex]]
[[pt:c/numeric/complex/complex]]
[[ru:c/numeric/complex/complex]]
[[zh:c/numeric/complex/complex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/conj</title>
    <ns>0</ns>
    <id>9378</id>
    <revision>
      <id>71704</id>
      <parentid>70054</parentid>
      <timestamp>2014-06-20T20:47:35Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C++ documentation</comment>
      <text xml:space="preserve" bytes="1101">{{c/title|conjf|conj|conjl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       conjf( float complex z );
}}
{{dcl | since=c99 |
double complex      conj( double complex z );
}}
{{dcl | since=c99 |
long double complex conjl( long double complex z );
}}
{{dcl end}}

Computes the complex conjugate of {{tt|z}} by reversing the sign of the imaginary part.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex conjugate of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
 
int main(void)
{ 
    double complex z = conj(1.0 + 2.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
 
    return 0;
}
 | output=
1.000000-2.000000i
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/complex/conj}}
{{dsc end}}

[[de:c/numeric/complex/conj]]
[[es:c/numeric/complex/conj]]
[[fr:c/numeric/complex/conj]]
[[it:c/numeric/complex/conj]]
[[ja:c/numeric/complex/conj]]
[[pt:c/numeric/complex/conj]]
[[ru:c/numeric/complex/conj]]
[[zh:c/numeric/complex/conj]]</text>
      <sha1>3eo91r8f9pfep2v80e9buevw9y6a3yf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cpow</title>
    <ns>0</ns>
    <id>9380</id>
    <revision>
      <id>70854</id>
      <parentid>70173</parentid>
      <timestamp>2014-05-31T03:55:42Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to pow and C++ documentation, -link to cexp</comment>
      <text xml:space="preserve" bytes="1385">{{c/title|cpowf|cpow|cpowl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       cpowf( float complex x, float complex y );
}}
{{dcl | since=c99 |
double complex      cpow( double complex x, double complex y );
}}
{{dcl | since=c99 |
long double complex cpowl( long double complex x, long double complex y );
}}
{{dcl end}}

Computes the complex power function x{{su|p=y}}, with branch cut for the first parameter along the negative real axis.

===Parameters===
{{par begin}}
{{par | x, y | complex argument}}
{{par end}}

===Return value===
The complex power x{{su|p=y}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{    
    double complex z = cpow(1.0+2.0*I,2.0+0.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    z = cpow(1.0+2.0*I,1.0+2.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
-3.000000+4.000000i
-0.222517+0.100709i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc csqrt}}
{{dsc inc | c/numeric/math/dsc pow}}
{{dsc see cpp | cpp/numeric/complex/pow}}
{{dsc end}}

[[de:c/numeric/complex/cpow]]
[[es:c/numeric/complex/cpow]]
[[fr:c/numeric/complex/cpow]]
[[it:c/numeric/complex/cpow]]
[[ja:c/numeric/complex/cpow]]
[[pt:c/numeric/complex/cpow]]
[[ru:c/numeric/complex/cpow]]
[[zh:c/numeric/complex/cpow]]</text>
      <sha1>ifjeca6pq5vbyk7onf1bpac7agr8uiw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/cproj</title>
    <ns>0</ns>
    <id>9379</id>
    <revision>
      <id>71705</id>
      <parentid>70052</parentid>
      <timestamp>2014-06-20T20:48:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C++ documentation</comment>
      <text xml:space="preserve" bytes="1103">{{c/title|cprojf|cproj|cprojl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float       cprojf( float complex z );
}}
{{dcl | since=c99 |
double      cproj( double complex z );
}}
{{dcl | since=c99 |
long double cprojl( long double complex z );
}}
{{dcl end}}

Computes the projection of {{tt|z}} on the Riemann sphere.

{{todo}}

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The projection of {{tt|z}} on the Riemann sphere.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    double complex z = cproj(INFINITY+2.0*I);
    printf(&quot;%.1f%+.1fi\n&quot;, creal(z),cimag(z));
    
    return 0;
}
 | output=
inf+0.0i
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/complex/proj}}
{{dsc end}}

[[de:c/numeric/complex/cproj]]
[[es:c/numeric/complex/cproj]]
[[fr:c/numeric/complex/cproj]]
[[it:c/numeric/complex/cproj]]
[[ja:c/numeric/complex/cproj]]
[[pt:c/numeric/complex/cproj]]
[[ru:c/numeric/complex/cproj]]
[[zh:c/numeric/complex/cproj]]</text>
      <sha1>8uwwk47i2r8tufs90pd3t0moxf9gdwr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/creal</title>
    <ns>0</ns>
    <id>9376</id>
    <revision>
      <id>71605</id>
      <parentid>71603</parentid>
      <timestamp>2014-06-14T22:16:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1071">{{c/title|crealf|creal|creall}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float       crealf( float complex z );
}}
{{dcl | since=c99 |
double      creal( double complex z );
}}
{{dcl | since=c99 |
long double creall( long double complex z );
}}
{{dcl end}}

Returns the real part of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The real part of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{    
    double complex z = 1.0 + 2.0*I;
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
1.000000+2.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cimag}}
{{dsc see cpp| cpp/numeric/complex/real2}}
{{dsc end}}

[[de:c/numeric/complex/creal]]
[[es:c/numeric/complex/creal]]
[[fr:c/numeric/complex/creal]]
[[it:c/numeric/complex/creal]]
[[ja:c/numeric/complex/creal]]
[[pt:c/numeric/complex/creal]]
[[ru:c/numeric/complex/creal]]
[[zh:c/numeric/complex/creal]]</text>
      <sha1>ayu9tsg9eoqz5aeclcfpc3mb633qmpj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/csin</title>
    <ns>0</ns>
    <id>9363</id>
    <revision>
      <id>70577</id>
      <parentid>70061</parentid>
      <timestamp>2014-05-25T19:39:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1967">{{c/title|csinf|csin|csinl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       csinf( float complex z );
}}
{{dcl | since=c99 |
double complex      csin( double complex z );
}}
{{dcl | since=c99 |
long double complex csinl( long double complex z );
}}
{{dcl end}}

Computes the complex sine of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex sine of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;

#define PI acos(-1)
 
int main(void)
{
    double complex z;
    double x;
    
    /* Print familiar values. */
    int ndx;
    printf(&quot;            sin(x)          csin(z)\n&quot;);
    printf(&quot;           --------    ------------------\n&quot;);
    for (ndx=0;ndx&lt;9;ndx++) {
        x = ndx*0.25*PI;
        z = x+0.0*I;
        z = csin(z);
        printf(&quot;%.2f*PI   %9f   %9f%+fi\n&quot;, ndx*0.25,sin(x),creal(z),cimag(z));
    }
 
    return 0;
}

 | output=
sin(x)          csin(z)
           --------    ------------------
0.00*PI    0.000000    0.000000+0.000000i
0.25*PI    0.707107    0.707107+0.000000i
0.50*PI    1.000000    1.000000+0.000000i
0.75*PI    0.707107    0.707107-0.000000i
1.00*PI    0.000000    0.000000-0.000000i
1.25*PI   -0.707107   -0.707107-0.000000i
1.50*PI   -1.000000   -1.000000-0.000000i
1.75*PI   -0.707107   -0.707107+0.000000i
2.00*PI   -0.000000   -0.000000+0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc ccos}}
{{dsc inc | c/numeric/complex/dsc ctan}}
{{dsc inc | c/numeric/complex/dsc casin}}
{{dsc inc | c/numeric/math/dsc sin}}
{{dsc see cpp | cpp/numeric/complex/sin}}
{{dsc end}}

[[de:c/numeric/complex/csin]]
[[es:c/numeric/complex/csin]]
[[fr:c/numeric/complex/csin]]
[[it:c/numeric/complex/csin]]
[[ja:c/numeric/complex/csin]]
[[pt:c/numeric/complex/csin]]
[[ru:c/numeric/complex/csin]]
[[zh:c/numeric/complex/csin]]</text>
      <sha1>olo6v8mleng2sr0n4opmjwmuuz3nglg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/csinh</title>
    <ns>0</ns>
    <id>9366</id>
    <revision>
      <id>70583</id>
      <parentid>70067</parentid>
      <timestamp>2014-05-25T19:53:27Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1789">{{c/title|csinhf|csinh|csinhl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       csinhf( float complex z );
}}
{{dcl | since=c99 |
double complex      csinh( double complex z );
}}
{{dcl | since=c99 |
long double complex csinhl( long double complex z );
}}
{{dcl end}}

Computes the complex hyperbolic sine of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex hyperbolic sine of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;
 
#define PI acos(-1)
 
int main(void)
{
    double complex z;

    /* Hyperbolic functions are periodic with respect to the imaginary component. */
    /* The period of sinh is 2*pi*i.                                              */
    z = csinh(0.0+0.0*PI*I);
    printf(&quot;csinh(0.0+0*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));

    z = csinh(0.0 + 2*PI*I);
    printf(&quot;csinh(0.0+2*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = csinh(0.0 + 4*PI*I);
    printf(&quot;csinh(0.0+4*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    return 0;
}
 | output=
csinh(0.0+0*PI*I) ==&gt; 0.000000+0.000000i
csinh(0.0+2*PI*I) ==&gt; 0.000000-0.000000i
csinh(0.0+4*PI*I) ==&gt; 0.000000-0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc ccosh}}
{{dsc inc | c/numeric/complex/dsc ctanh}}
{{dsc inc | c/numeric/complex/dsc casinh}}
{{dsc inc | c/numeric/math/dsc sinh}}
{{dsc see cpp | cpp/numeric/complex/sinh}}
{{dsc end}}

[[de:c/numeric/complex/csinh]]
[[es:c/numeric/complex/csinh]]
[[fr:c/numeric/complex/csinh]]
[[it:c/numeric/complex/csinh]]
[[ja:c/numeric/complex/csinh]]
[[pt:c/numeric/complex/csinh]]
[[ru:c/numeric/complex/csinh]]
[[zh:c/numeric/complex/csinh]]</text>
      <sha1>a113cmx1pkbbijpaw32ozf0jbjbbm5n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/csqrt</title>
    <ns>0</ns>
    <id>9374</id>
    <revision>
      <id>70636</id>
      <parentid>70056</parentid>
      <timestamp>2014-05-27T04:16:54Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to sqrt and C++ documentation</comment>
      <text xml:space="preserve" bytes="1426">{{c/title|csqrtf|csqrt|csqrtl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       csqrtf( float complex z );
}}
{{dcl | since=c99 |
double complex      csqrt( double complex z );
}}
{{dcl | since=c99 |
long double complex csqrtl( long double complex z );
}}
{{dcl end}}

Computes the complex square root of {{tt|z}} with branch cut along the negative real axis.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex square root of {{tt|z}} in the interval {{math|[0; +∞)}} along the real axis and in the interval {{math|(−∞; +∞)}} along the imaginary axis.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;

int main(void)
{    
    double complex z = csqrt(-1.0 + 0.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    z = csqrt(1.0 + 2.0*I);
    printf(&quot;%f%+fi\n&quot;, creal(z), cimag(z));
    
    return 0;
}
 | output=
0.000000+1.000000i
1.272020+0.786151i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc cpow}}
{{dsc inc | c/numeric/math/dsc sqrt}}
{{dsc see cpp | cpp/numeric/complex/sqrt}}
{{dsc end}}

[[de:c/numeric/complex/csqrt]]
[[es:c/numeric/complex/csqrt]]
[[fr:c/numeric/complex/csqrt]]
[[it:c/numeric/complex/csqrt]]
[[ja:c/numeric/complex/csqrt]]
[[pt:c/numeric/complex/csqrt]]
[[ru:c/numeric/complex/csqrt]]
[[zh:c/numeric/complex/csqrt]]</text>
      <sha1>ju8kwvl3bsxrd0986b65vq26eboyxza</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/ctan</title>
    <ns>0</ns>
    <id>9364</id>
    <revision>
      <id>70579</id>
      <parentid>70062</parentid>
      <timestamp>2014-05-25T19:43:55Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="2071">{{c/title|ctanf|ctan|ctanl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       ctanf( float complex z );
}}
{{dcl | since=c99 |
double complex      ctan( double complex z );
}}
{{dcl | since=c99 |
long double complex ctanl( long double complex z );
}}
{{dcl end}}

Computes the complex tangent of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex tangent of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;
 
#define PI acos(-1)
 
int main(void)
{
    double complex z;
    double x;
 
    /* Print familiar values. */
    int ndx;
    printf(&quot;             tan(x)             ctan(z)\n&quot;);
    printf(&quot;          ------------    ----------------------\n&quot;);
    for (ndx=0;ndx&lt;9;ndx++) {
        x = ndx*0.25*PI;
        z = x+0.0*I;
        z = ctan(z);
        printf(&quot;%.2f*PI   %12g    %12g%+fi\n&quot;, ndx*0.25,tan(x),creal(z),cimag(z));
    }
 
    return 0;
}

 | output=
             tan(x)             ctan(z)
          ------------    ----------------------
0.00*PI              0               0+0.000000i
0.25*PI              1               1+0.000000i
0.50*PI    1.63312e+16     1.63318e+16-0.000000i
0.75*PI             -1              -1+0.000000i
1.00*PI   -1.22465e-16    -1.22461e-16+0.000000i
1.25*PI              1               1+0.000000i
1.50*PI    5.44375e+15     5.44393e+15+0.000000i
1.75*PI             -1              -1+0.000000i
2.00*PI   -2.44929e-16    -2.44921e-16+0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc csin}}
{{dsc inc | c/numeric/complex/dsc ccos}}
{{dsc inc | c/numeric/complex/dsc catan}}
{{dsc inc | c/numeric/math/dsc tan}}
{{dsc see cpp | cpp/numeric/complex/tan}}
{{dsc end}}

[[de:c/numeric/complex/ctan]]
[[es:c/numeric/complex/ctan]]
[[fr:c/numeric/complex/ctan]]
[[it:c/numeric/complex/ctan]]
[[ja:c/numeric/complex/ctan]]
[[pt:c/numeric/complex/ctan]]
[[ru:c/numeric/complex/ctan]]
[[zh:c/numeric/complex/ctan]]</text>
      <sha1>k7vxpgjizuuniubufgtyghmikm1y1sp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/ctanh</title>
    <ns>0</ns>
    <id>9365</id>
    <revision>
      <id>70585</id>
      <parentid>70068</parentid>
      <timestamp>2014-05-25T19:55:41Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1795">{{c/title|ctanhf|ctanh|ctanhl}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
float complex       ctanhf( float complex z );
}}
{{dcl | since=c99 |
double complex      ctanh( double complex z );
}}
{{dcl | since=c99 |
long double complex ctanhl( long double complex z );
}}
{{dcl end}}

Computes the complex hyperbolic tangent of {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex argument}}
{{par end}}

===Return value===
The complex hyperbolic tangent of {{tt|z}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;complex.h&gt;
#include &lt;math.h&gt;
 
#define PI acos(-1)
 
int main(void)
{
    double complex z;

    /* Hyperbolic functions are periodic with respect to the imaginary component. */
    /* The period of tanh is pi*i.                                                */
    z = ctanh(0.0+0.0*PI*I);
    printf(&quot;ctanh(0.0+0*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));

    z = ctanh(0.0 + 1*PI*I);
    printf(&quot;ctanh(0.0+1*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    z = ctanh(0.0 + 2*PI*I);
    printf(&quot;ctanh(0.0+2*PI*I) ==&gt; %f%+fi\n&quot;, creal(z),cimag(z));
    
    return 0;
}
 | output=
ctanh(0.0+0*PI*I) ==&gt; 0.000000+0.000000i
ctanh(0.0+1*PI*I) ==&gt; 0.000000-0.000000i
ctanh(0.0+2*PI*I) ==&gt; 0.000000-0.000000i
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc csinh}}
{{dsc inc | c/numeric/complex/dsc ccosh}}
{{dsc inc | c/numeric/complex/dsc catanh}}
{{dsc inc | c/numeric/math/dsc tanh}}
{{dsc see cpp | cpp/numeric/complex/tanh}}
{{dsc end}}

[[de:c/numeric/complex/ctanh]]
[[es:c/numeric/complex/ctanh]]
[[fr:c/numeric/complex/ctanh]]
[[it:c/numeric/complex/ctanh]]
[[ja:c/numeric/complex/ctanh]]
[[pt:c/numeric/complex/ctanh]]
[[ru:c/numeric/complex/ctanh]]
[[zh:c/numeric/complex/ctanh]]</text>
      <sha1>6ojk8825h9rw01ca2n1ptbvsh6rm3bz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/complex/imaginary</title>
    <ns>0</ns>
    <id>9355</id>
    <revision>
      <id>62542</id>
      <parentid>56545</parentid>
      <timestamp>2013-07-01T23:27:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="861">{{c/title|imaginary}}
{{c/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex.h}}
{{dcl | since=c99 |
#define imaginary _Imaginary
}}
{{dcl end}}

This macro expands to a type specifier used to identify imaginary complex types. The macro is defined only if the implementation supports imaginary types. 
{{todo|on what condition? The standard seems unclear. Maybe when __STDC_IEC_559_COMPLEX__ is defined?}}

A program may undefine and perhaps then redefine the {{lc|imaginary}} macro.

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/complex/dsc complex}}
{{dsc end}}

[[de:c/numeric/complex/imaginary]]
[[es:c/numeric/complex/imaginary]]
[[fr:c/numeric/complex/imaginary]]
[[it:c/numeric/complex/imaginary]]
[[ja:c/numeric/complex/imaginary]]
[[pt:c/numeric/complex/imaginary]]
[[ru:c/numeric/complex/imaginary]]
[[zh:c/numeric/complex/imaginary]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv</title>
    <ns>0</ns>
    <id>6421</id>
    <revision>
      <id>56546</id>
      <parentid>48983</parentid>
      <timestamp>2013-06-01T05:37:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2071">{{title|Floating point environment}}
{{c/numeric/fenv/navbar}}

The floating-point environment is the set of floating-point status flags and control modes supported by the implementation. It is thread-local, each thread inherits the initial state of its floating-point environment from the parent thread. Floating-point operations modify the floating-point status flags to indicate abnormal results or auxiliary information. The state of floating-point control modes affects the outcomes of some floating-point operations.

The floating-point environment access and modification is only meaningful when {{ltt|cpp/preprocessor/impl|#pragma STDC FENV_ACCESS}} is set to {{tt|ON}}. Otherwise the implementation is free to assume that floating-point control modes are always the default ones and that floating-point status flags are never tested or modified. In practice, few current compilers support the {{tt|#pragma}} explicitly, but most compilers allow meaningful access to the floating-point environment anyway.

===Types===
{{dsc begin}}
{{dsc header | fenv.h}}
{{dsc | {{c|fenv_t}}  | The type representing the entire floating-point environment | notes={{mark c99}}}}
{{dsc | {{c|fexcept_t}} | The type representing all floating-point status flags collectively | notes={{mark c99}}}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feclearexcept}}
{{dsc inc | c/numeric/fenv/dsc fetestexcept}}
{{dsc inc | c/numeric/fenv/dsc feraiseexcept}}
{{dsc inc | c/numeric/fenv/dsc feexceptflag}}
{{dsc inc | c/numeric/fenv/dsc feround}}
{{dsc inc | c/numeric/fenv/dsc feenv}}
{{dsc inc | c/numeric/fenv/dsc feholdexcept}}
{{dsc inc | c/numeric/fenv/dsc feupdateenv}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc FE_exceptions}}
{{dsc inc | c/numeric/fenv/dsc FE_round}}
{{dsc inc | c/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

{{todo|FENV_ACCESS}}

[[de:c/numeric/fenv]]
[[es:c/numeric/fenv]]
[[fr:c/numeric/fenv]]
[[it:c/numeric/fenv]]
[[ja:c/numeric/fenv]]
[[pt:c/numeric/fenv]]
[[ru:c/numeric/fenv]]
[[zh:c/numeric/fenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/FE DFL ENV</title>
    <ns>0</ns>
    <id>8619</id>
    <revision>
      <id>69445</id>
      <parentid>62543</parentid>
      <timestamp>2014-04-09T15:18:42Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example using FE_DFL_ENV.  Example restores to the default state the rounding method but not f-p exceptions.</comment>
      <text xml:space="preserve" bytes="2955">{{c/title|FE_DFL_ENV}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
#define FE_DFL_ENV  /*implementation defined*/
}}
{{dcl end}}

The macro constant {{lc|FE_DFL_ENV}} expands to an expression of type {{c|const fenv_t*}}, which points to a full copy of the default floating-point environment, that is, the environment as loaded at program startup.

Additional macros that begin with {{tt|FE_}} followed by uppercase letters, and have the type {{c|const fenv_t*}}, may be supported by an implementation.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

void show_fe_rounding_method(void)
{
    printf(&quot;current rounding method:    &quot;);
    switch (fegetround()) {
           case FE_TONEAREST:  printf (&quot;FE_TONEAREST&quot;);  break;
           case FE_DOWNWARD:   printf (&quot;FE_DOWNWARD&quot;);   break;
           case FE_UPWARD:     printf (&quot;FE_UPWARD&quot;);     break;
           case FE_TOWARDZERO: printf (&quot;FE_TOWARDZERO&quot;); break;
           default:            printf (&quot;unknown&quot;);
    };
    printf(&quot;\n&quot;);
}
 
void show_fe_environment(void)
{
    show_fe_exceptions();
    show_fe_rounding_method();
} 

int main()
{
    /* Show default f-p environment. */
    printf(&quot;On startup:\n&quot;);
    show_fe_environment();
    
    /* Change f-p environment. */
    fesetround(FE_DOWNWARD);     /* change rounding mode                   */
    feraiseexcept(FE_INVALID);   /* some computation with invalid argument */
    printf(&quot;\nBefore restoration:\n&quot;);
    show_fe_environment();
    
    /* Restore default f-p environment. */
    fesetenv(FE_DFL_ENV);
    printf(&quot;\nAfter restoring default environment:\n&quot;);
    show_fe_environment();
    
    return 0;
}
 | output=
On startup:
current exceptions raised:  none
current rounding method:    FE_TONEAREST

Before restoration:
current exceptions raised:  FE_INVALID
current rounding method:    FE_DOWNWARD

After restoring default environment:
current exceptions raised:  FE_INVALID
current rounding method:    FE_TONEAREST
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feenv}}
{{dsc inc | c/numeric/fenv/dsc feupdateenv}}
{{dsc see cpp | cpp/numeric/fenv/FE_DFL_ENV}}
{{dsc end}}

[[de:c/numeric/fenv/FE DFL ENV]]
[[es:c/numeric/fenv/FE DFL ENV]]
[[fr:c/numeric/fenv/FE DFL ENV]]
[[it:c/numeric/fenv/FE DFL ENV]]
[[ja:c/numeric/fenv/FE DFL ENV]]
[[pt:c/numeric/fenv/FE DFL ENV]]
[[ru:c/numeric/fenv/FE DFL ENV]]
[[zh:c/numeric/fenv/FE DFL ENV]]</text>
      <sha1>npuok1eb25bg62xh5ng9ungi75ieuzp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/FE exceptions</title>
    <ns>0</ns>
    <id>8617</id>
    <revision>
      <id>70181</id>
      <parentid>69396</parentid>
      <timestamp>2014-05-11T15:58:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>adjust descriptions, link to math_errhandling and c++</comment>
      <text xml:space="preserve" bytes="4106">{{title|&lt;small&gt;FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW, FE_UNDERFLOW, FE_ALL_EXCEPT&lt;/small&gt;}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
#define FE_DIVBYZERO    /*implementation defined power of 2*/
}}
{{dcl | since=c99 |
#define FE_INEXACT      /*implementation defined power of 2*/
}}
{{dcl | since=c99 |
#define FE_INVALID      /*implementation defined power of 2*/
}}
{{dcl | since=c99 |
#define FE_OVERFLOW     /*implementation defined power of 2*/
}}
{{dcl | since=c99 |
#define FE_UNDERFLOW    /*implementation defined power of 2*/
}}
{{dcl | since=c99 |
#define FE_ALL_EXCEPT  FE_DIVBYZERO {{!}} FE_INEXACT {{!}} \
                       FE_INVALID {{!}} FE_OVERFLOW {{!}}  \
                       FE_UNDERFLOW
}}
{{dcl end}}

All these macro constants (except {{lc|FE_ALL_EXCEPT}}) expand to integer constant expressions that are distinct powers of 2, which uniquely identify all supported floating-point exceptions. Each macro is only defined if it is supported. 

The macro constant {{lc|FE_ALL_EXCEPT}}, which expands to the bitwise OR of all other {{tt|FE_*}}, is always defined and is zero if floating-point exceptions are not supported by the implementation.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FE_DIVBYZERO}} | pole error occurred in an earlier floating-point operation}}
{{dsc | {{tt|FE_INEXACT}}   | inexact result: rounding was necessary to store the result of an earlier floating-point operation}}
{{dsc | {{tt|FE_INVALID}}   | domain error occurred in an earlier floating-point operation}}
{{dsc | {{tt|FE_OVERFLOW}}  | the result of an earlier floating-point operation was too large to be representable}}
{{dsc | {{tt|FE_UNDERFLOW}} | the result of an earlier floating-point operation was subnormal with a loss of precision}}
{{dsc | {{tt|FE_ALL_EXCEPT}} | bitwise OR of all supported floating-point exceptions}}
{{dsc end}}

The implementation may define additional macro constants in {{tt|&lt;fenv.h&gt;}} to identify additional floating-point exceptions. All such constants begin with {{tt|FE_}} followed by at least one uppercase letter.

See [[c/numeric/math/math_errhandling|math_errhandling]] for further details.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
void show_fe_exceptions(void)
{
    printf(&quot;exceptions raised:&quot;);
    if(fetestexcept(FE_DIVBYZERO)) printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))   printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))   printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))  printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW)) printf(&quot; FE_UNDERFLOW&quot;);
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;\n&quot;);
}

int main()
{
    printf(&quot;0.0/0.0 = %f\n&quot;, 0.0/0.0);
    show_fe_exceptions();

    printf(&quot;1.0/0.0 = %f\n&quot;, 1.0/0.0);
    show_fe_exceptions();

    printf(&quot;1.0/10.0 = %f\n&quot;, 1.0/10.0);
    show_fe_exceptions();

    printf(&quot;sqrt(-1) = %f\n&quot;, sqrt(-1));
    show_fe_exceptions();

    printf(&quot;DBL_MAX*2.0 = %f\n&quot;, DBL_MAX*2.0);
    show_fe_exceptions();

    printf(&quot;nextafter(DBL_MIN/pow(2.0,52),0.0) = %.1f\n&quot;,
                      nextafter(DBL_MIN/pow(2.0,52),0.0));
    show_fe_exceptions();
}
 | p=true
 | output=
0.0/0.0 = nan
exceptions raised: FE_INVALID
1.0/0.0 = inf
exceptions raised: FE_DIVBYZERO
1.0/10.0 = 0.100000
exceptions raised: FE_INEXACT
sqrt(-1) = -nan
exceptions raised: FE_INVALID
DBL_MAX*2.0 = inf
exceptions raised: FE_INEXACT FE_OVERFLOW
nextafter(DBL_MIN/pow(2.0,52),0.0) = 0.0
exceptions raised: FE_INEXACT FE_UNDERFLOW
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc math_errhandling}}
{{dsc see cpp | cpp/numeric/fenv/FE_exceptions | floating point exception macros | nomono=true}}
{{dsc end}}

[[de:c/numeric/fenv/FE exceptions]]
[[es:c/numeric/fenv/FE exceptions]]
[[fr:c/numeric/fenv/FE exceptions]]
[[it:c/numeric/fenv/FE exceptions]]
[[ja:c/numeric/fenv/FE exceptions]]
[[pt:c/numeric/fenv/FE exceptions]]
[[ru:c/numeric/fenv/FE exceptions]]
[[zh:c/numeric/fenv/FE exceptions]]</text>
      <sha1>jcc0lnotfpaiiyax7hspal45azaxgis</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/FE round</title>
    <ns>0</ns>
    <id>8618</id>
    <revision>
      <id>72047</id>
      <parentid>69401</parentid>
      <timestamp>2014-07-10T03:09:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+rounding effects, more varied example (this isn't the nearbyint page)</comment>
      <text xml:space="preserve" bytes="4175">{{title|&lt;small&gt;FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO, FE_UPWARD&lt;/small&gt;}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
#define FE_DOWNWARD     /*implementation defined*/
}} 
{{dcl | since=c99 |
#define FE_TONEAREST    /*implementation defined*/
}}
{{dcl | since=c99 |
#define FE_TOWARDZERO   /*implementation defined*/
}}
{{dcl | since=c99 |
#define FE_UPWARD       /*implementation defined*/
}}
{{dcl end}}

Each of these macro constants expands to a nonnegative integer constant expression, which can be used with {{lc|fesetround}} and {{lc|fegetround}} to indicate one of the supported floating-point rounding modes. The implementation may define additional rounding mode constants in {{tt|&lt;fenv.h&gt;}}, which should all begin with {{tt|FE_}} followed by at least one uppercase letter. Each macro is only defined if it is supported.

On most implementations, these macro constants expand to the values equal to the values of {{lc|FLT_ROUNDS}} and {{c|float_round_style}}

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FE_DOWNWARD}}  | rounding towards negative infinity}}
{{dsc | {{tt|FE_TONEAREST}} | rounding towards nearest integer}}
{{dsc | {{tt|FE_TOWARDZERO}} | rounding towards zero}}
{{dsc | {{tt|FE_UPWARD}}  | rounding towards positive infinity}}
{{dsc end}}

Additional rounding modes may be supported by an implementation.

The current rounding mode affects the following:
* results of floating-point arithmetic operators outside of constant expressions
{{source|1=
double x = 1;
x/10; // 0.09999999999999999167332731531132594682276248931884765625
   // or 0.1000000000000000055511151231257827021181583404541015625
}}
* results of standard library [[c/numeric/math|mathematical functions]]
{{source|1=
sqrt(2); // 1.41421356237309492343001693370752036571502685546875
      // or 1.4142135623730951454746218587388284504413604736328125
}}
* floating-point to floating-point implicit conversion and casts
{{source|1=
double d = 1 + DBL_EPSILON;
float f = d; //  1.00000000000000000000000
           // or 1.00000011920928955078125
}}
* string conversions such as {{lc|strtod}} or {{lc|printf}}
{{source|1=
strtof(&quot;0.1&quot;, NULL); // 0.0999999940395355224609375
                  // or 0.100000001490116119384765625
}}
* the library rounding functions {{lc|nearbyint}}, {{lc|rint}}, {{lc|lrint}}
{{source|1=
lrint(2.1); // 2 or 3
}}
The current rounding mode does NOT affect the following:
* floating-point to integer implicit conversion and casts (always towards zero)
* results of floating-point arithmetic operators in constant expressions (always to nearest)
* the library functions {{lc|round}}, {{lc|lround}}, {{lc|ceil}}, {{lc|floor}}, {{lc|trunc}}

As with any [[c/numeric/fenv|floating-point environment]] functionality, rounding is only guaranteed if {{tt|#pragma STDC FENV_ACCESS ON}} is set.

===Example===
{{example
|code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;fenv.h&gt;
#include &lt;math.h&gt;
int main()
{
#pragma STDC FENV_ACCESS ON
    fesetround(FE_DOWNWARD);
    puts(&quot;rounding down: &quot;);
    printf(&quot;           pi = %.22f\n&quot;, acosf(-1));
    printf(&quot;strtof(\&quot;1.1\&quot;) = %.22f\n&quot;, strtof(&quot;1.1&quot;, NULL));
    printf(&quot;    rint(2.1) = %.22f\n\n&quot;, rintf(2.1));
    fesetround(FE_UPWARD);
    puts(&quot;rounding up: &quot;);
    printf(&quot;           pi = %.22f\n&quot;, acosf(-1));
    printf(&quot;strtof(\&quot;1.1\&quot;) = %.22f\n&quot;, strtof(&quot;1.1&quot;, NULL));
    printf(&quot;    rint(2.1) = %.22f\n&quot;, rintf(2.1));
}
|output=
rounding down: 
           pi = 3.1415925025939941406250
strtof(&quot;1.1&quot;) = 1.0999999046325683593750
    rint(2.1) = 2.0000000000000000000000

rounding up: 
           pi = 3.1415927410125732421875
strtof(&quot;1.1&quot;) = 1.1000000238418579101563
    rint(2.1) = 3.0000000000000000000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feround}}
{{dsc see cpp | cpp/numeric/fenv/FE_round | floating point rounding macros | nomono=true}}
{{dsc end}}

[[de:c/numeric/fenv/FE round]]
[[es:c/numeric/fenv/FE round]]
[[fr:c/numeric/fenv/FE round]]
[[it:c/numeric/fenv/FE round]]
[[ja:c/numeric/fenv/FE round]]
[[pt:c/numeric/fenv/FE round]]
[[ru:c/numeric/fenv/FE round]]
[[zh:c/numeric/fenv/FE round]]</text>
      <sha1>8k2lkseaybwew9rso5dt8ffo2bhw0ps</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feclearexcept</title>
    <ns>0</ns>
    <id>8610</id>
    <revision>
      <id>65159</id>
      <parentid>65141</parentid>
      <timestamp>2013-09-03T14:51:20Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>formatting</comment>
      <text xml:space="preserve" bytes="2615">{{c/title|feclearexcept}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
int feclearexcept( int excepts );
}}
{{dcl end}}

Attempts to clear the floating-point exceptions that are listed in the bitmask argument {{tt|excepts}}, which is a bitwise OR of the [[c/numeric/fenv/FE_exceptions|floating point exception macros]].

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to clear}}
{{par end}}

===Return value===
{{c|0}} if all indicated exceptions were successfully cleared or if {{tt|excepts}} is zero. Returns a non-zero value on error.

===Example===
{{example
 |
 | code=
#include &lt;fenv.h&gt;
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;

/*
 * A possible implementation of hypot which makes use of many advanced
 * floating point features.
 */
double hypot_demo(double a, double b) {
  const int range_problem = FE_OVERFLOW {{!}} FE_UNDERFLOW;
  feclearexcept(range_problem);
  // try a fast algorithm
  double result = sqrt(a * a + b * b);
  if (!fetestexcept(range_problem))  // no overflow or underflow
    return result;                   // return the fast result
  // do a more complicated calculation to avoid overflow or underflow
  int a_exponent,b_exponent;
  frexp(a, &amp;a_exponent);
  frexp(b, &amp;b_exponent);

  if (a_exponent - b_exponent &gt; DBL_MAX_EXP)
    return fabs(a) + fabs(b);        // we can ignore the smaller value
  // scale so that fabs(a) is near 1
  double a_scaled = scalbn(a, -a_exponent);
  double b_scaled = scalbn(b, -a_exponent);
  // overflow and underflow is now impossible 
  result = sqrt(a_scaled * a_scaled + b_scaled * b_scaled);
  // undo scaling
  return scalbn(result, a_exponent);
}

int main (int argc, char** argv) {
  // Normal case takes the fast route
  printf(&quot;hypot(%f, %f) = %f\n&quot;, 3.0, 4.0, hypot_demo(3.0, 4.0));
  // Extreme case takes the slow but more accurate route
  printf(&quot;hypot(%e, %e) = %e\n&quot;, DBL_MAX / 2.0, 
                                DBL_MAX / 2.0, 
                                hypot_demo(DBL_MAX / 2.0, DBL_MAX / 2.0));
}
 | output=
hypot(3.000000, 4.000000) = 5.000000
hypot(8.988466e+307, 8.988466e+307) = 1.271161e+308
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc fetestexcept}}
{{dsc see cpp | cpp/numeric/fenv/feclearexcept}}
{{dsc end}}

[[de:c/numeric/fenv/feclearexcept]]
[[es:c/numeric/fenv/feclearexcept]]
[[fr:c/numeric/fenv/feclearexcept]]
[[it:c/numeric/fenv/feclearexcept]]
[[ja:c/numeric/fenv/feclearexcept]]
[[pt:c/numeric/fenv/feclearexcept]]
[[ru:c/numeric/fenv/feclearexcept]]
[[zh:c/numeric/fenv/feclearexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feenv</title>
    <ns>0</ns>
    <id>8614</id>
    <revision>
      <id>69423</id>
      <parentid>69422</parentid>
      <timestamp>2014-04-08T12:58:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>reinserted space and improved alignment in output</comment>
      <text xml:space="preserve" bytes="3951">{{c/title|fegetenv|fesetenv}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 | num=1|
int fegetenv( fenv_t* envp );
}}
{{dcl | since=c99 | num=2|
int fesetenv( const fenv_t* envp );
}}
{{dcl end}}

1) Attempts to store the status of the floating-point environment in the object pointed to by {{tt|envp}}.

2) Attempts to establish the floating-point environment from the object pointed to by {{tt|envp}}. The value of that object must be previously obtained by a call to {{lc|feholdexcept}} or {{tt|fegetenv}} or be a floating-point macro constant. If any of the floating-point status flags are set in {{tt|envp}}, they become set in the environment (and are then testable with {{lc|fetestexcept}}), but the corresponding floating-point exceptions are not raised (execution continues uninterrupted)

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|fenv_t}} which holds the status of the floating-point environment}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

void show_fe_rounding_method(void)
{
    printf(&quot;current rounding method:    &quot;);
    switch (fegetround()) {
           case FE_TONEAREST:  printf (&quot;FE_TONEAREST&quot;);  break;
           case FE_DOWNWARD:   printf (&quot;FE_DOWNWARD&quot;);   break;
           case FE_UPWARD:     printf (&quot;FE_UPWARD&quot;);     break;
           case FE_TOWARDZERO: printf (&quot;FE_TOWARDZERO&quot;); break;
           default:            printf (&quot;unknown&quot;);
    };
    printf(&quot;\n&quot;);
}

void show_fe_environment(void)
{
    show_fe_exceptions();
    show_fe_rounding_method();
}    
 
int main()
{
    fenv_t curr_env;
    int rtn;
    
    /* Show default environment. */
    show_fe_environment();
    printf(&quot;\n&quot;);
 
    /* Perform some computation under default environment. */
    printf(&quot;+11.5 -&gt; %+4.1f\n&quot;, rint(+11.5)); /* midway between two integers */
    printf(&quot;+12.5 -&gt; %+4.1f\n&quot;, rint(+12.5)); /* midway between two integers */
    show_fe_environment();
    printf(&quot;\n&quot;);
 
    /* Save current environment. */
    rtn = fegetenv(&amp;curr_env);
 
    /* Perform some computation with new rounding method. */
    feclearexcept(FE_ALL_EXCEPT);
    fesetround(FE_DOWNWARD);
    printf(&quot;1.0/0.0 = %f\n&quot;, 1.0/0.0);
    printf(&quot;+11.5 -&gt; %+4.1f\n&quot;, rint(+11.5));
    printf(&quot;+12.5 -&gt; %+4.1f\n&quot;, rint(+12.5));
    show_fe_environment();
    printf(&quot;\n&quot;);
 
    /* Restore previous environment. */
    rtn = fesetenv(&amp;curr_env);
    show_fe_environment();
 
    return 0;
}
 | output=
current exceptions raised: none
current rounding method:   FE_TONEAREST

+11.5 -&gt; +12.0
+12.5 -&gt; +12.0
current exceptions raised: FE_INEXACT
current rounding method:   FE_TONEAREST

1.0/0.0 = inf
+11.5 -&gt; +11.0
+12.5 -&gt; +12.0
current exceptions raised: FE_DIVBYZERO FE_INEXACT
current rounding method:   FE_DOWNWARD

current exceptions raised: FE_INEXACT
current rounding method:   FE_TONEAREST
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feholdexcept}}
{{dsc inc | c/numeric/fenv/dsc feupdateenv}}
{{dsc inc | c/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc see cpp | cpp/numeric/fenv/feenv | fegetenv | fesetenv}}
{{dsc end}}

[[de:c/numeric/fenv/feenv]]
[[es:c/numeric/fenv/feenv]]
[[fr:c/numeric/fenv/feenv]]
[[it:c/numeric/fenv/feenv]]
[[ja:c/numeric/fenv/feenv]]
[[pt:c/numeric/fenv/feenv]]
[[ru:c/numeric/fenv/feenv]]
[[zh:c/numeric/fenv/feenv]]</text>
      <sha1>j44mgegslvwks8r7qnuo2hke5qs2t45</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feexceptflag</title>
    <ns>0</ns>
    <id>8598</id>
    <revision>
      <id>69478</id>
      <parentid>69477</parentid>
      <timestamp>2014-04-12T11:47:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output</comment>
      <text xml:space="preserve" bytes="3054">{{c/title|fegetexceptflag|fesetexceptflag}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 | num=1|
int fegetexceptflag( fexcept_t* flagp, int excepts );
}}
{{dcl | since=c99 | num=2|
int fesetexceptflag( const fexcept_t* flagp, int excepts );
}}
{{dcl end}}

1) Attempts to obtain the full contents of the floating-point exception flags that are listed in the bitmask argument {{tt|excepts}}, which is a bitwise OR of the [[c/numeric/fenv/FE_exceptions|floating point exception macros]]. 

2) Attempts to copy the full contents of the floating-point exception flags that are listed in {{tt|excepts}} from {{tt|flagp}} into the floating-point environment. Does not raise any exceptions, only modifies the flags.

The full contents of a floating-point exception flag is not necessarily a boolean value indicating whether the exception is raised or cleared. For example, it may be a struct which includes the boolean status and the address of the code that triggered the exception. These functions obtain all such content and obtain/store it in {{tt|flagp}} in implementation-defined format.

===Parameters===
{{par begin}}
{{par | flagp | pointer to an {{c|fexcept_t}} object where the flags will be stored or read from}}
{{par | excepts | bitmask listing the exception flags to get/set}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

int main()
{
    fexcept_t excepts;
    
    /* Setup a &quot;current&quot; set of exception flags. */
    feraiseexcept(FE_INVALID);
    show_fe_exceptions();
    
    /* Save current exception flags. */
    fegetexceptflag(&amp;excepts,FE_ALL_EXCEPT);
    
    /* Temporarily raise two other exceptions. */
    feclearexcept(FE_ALL_EXCEPT);
    feraiseexcept(FE_OVERFLOW {{!}} FE_INEXACT);
    show_fe_exceptions();
    
    /* Restore previous exception flags. */
    fesetexceptflag(&amp;excepts,FE_ALL_EXCEPT);
    show_fe_exceptions();

    return 0;
}
 | output=
current exceptions raised: FE_INVALID
current exceptions raised: FE_INEXACT FE_OVERFLOW
current exceptions raised: FE_INVALID
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/fenv/feexceptflag | fegetexceptflag | fesetexceptflag}}
{{dsc end}}

[[de:c/numeric/fenv/feexceptflag]]
[[es:c/numeric/fenv/feexceptflag]]
[[fr:c/numeric/fenv/feexceptflag]]
[[it:c/numeric/fenv/feexceptflag]]
[[ja:c/numeric/fenv/feexceptflag]]
[[pt:c/numeric/fenv/feexceptflag]]
[[ru:c/numeric/fenv/feexceptflag]]
[[zh:c/numeric/fenv/feexceptflag]]</text>
      <sha1>m71hmqqq1hn4emgdle6jmj7b408cy0o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fegetenv</title>
    <ns>0</ns>
    <id>8684</id>
    <redirect title="c/numeric/fenv/feenv" />
    <revision>
      <id>36562</id>
      <timestamp>2012-06-25T15:05:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/fenv/feenv]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/numeric/fenv/feenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fegetexceptflag</title>
    <ns>0</ns>
    <id>8687</id>
    <redirect title="c/numeric/fenv/feexceptflag" />
    <revision>
      <id>36565</id>
      <timestamp>2012-06-25T15:05:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/fenv/feexceptflag]]</comment>
      <text xml:space="preserve" bytes="41">#redirect [[c/numeric/fenv/feexceptflag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fegetround</title>
    <ns>0</ns>
    <id>8686</id>
    <redirect title="c/numeric/fenv/feround" />
    <revision>
      <id>36564</id>
      <timestamp>2012-06-25T15:05:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/fenv/feround]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[c/numeric/fenv/feround]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feholdexcept</title>
    <ns>0</ns>
    <id>8615</id>
    <revision>
      <id>69444</id>
      <parentid>62549</parentid>
      <timestamp>2014-04-09T14:06:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example exhibits how a called function can hide f-p exceptions from a caller function.  GCC and clang yield different output.</comment>
      <text xml:space="preserve" bytes="3110">{{c/title|feholdexcept}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
int feholdexcept( fenv_t* envp );
}}
{{dcl end}}

First, saves the current floating-point environment to the object pointed to by {{tt|envp}} (similar to {{lc|fegetenv}}), then clears all floating-point status flags, and then installs the non-stop mode: future floating-point exceptions will not interrupt execution (will not trap), until the floating-point environment is restored by {{lc|feupdateenv}} or {{lc|fesetenv}}.

This function may be used in the beginning of a subroutine that must hide the floating-point exceptions it may raise from the caller. If only some exceptions must be suppressed, while others must be reported, the non-stop mode is usually ended with a call to {{lc|feupdateenv}} after clearing the unwanted exceptions.

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|fenv_t}} where the floating-point environment will be stored}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
#include &lt;float.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

double x2 (double x)   /* times two */
{
    fenv_t curr_excepts;
    
    /* Save and clear current f-p environment. */
    feholdexcept(&amp;curr_excepts);
    
    /* Raise inexact and overflow exceptions. */
    printf(&quot;In x2():  x = %f\n&quot;, x=x*2.0);
    show_fe_exceptions();
    feclearexcept(FE_INEXACT);   /* hide inexact exception from caller */

    /* Merge caller's exceptions (FE_INVALID)        */
    /* with remaining x2's exceptions (FE_OVERFLOW). */
    feupdateenv(&amp;curr_excepts);
    return x;
}

int main()
{    
    feclearexcept(FE_ALL_EXCEPT);
    feraiseexcept(FE_INVALID);   /* some computation with invalid argument */
    show_fe_exceptions();
    printf(&quot;x2(DBL_MAX) = %f\n&quot;, x2(DBL_MAX));
    show_fe_exceptions();
    
    return 0;
}
 | output=
current exceptions raised:  FE_INVALID
In x2():  x = inf
current exceptions raised:  FE_INEXACT FE_OVERFLOW
x2(DBL_MAX) = inf
current exceptions raised:  FE_INVALID FE_OVERFLOW
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feupdateenv}}
{{dsc inc | c/numeric/fenv/dsc feenv}}
{{dsc inc | c/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc see cpp | cpp/numeric/fenv/feholdexcept}}
{{dsc end}}

[[de:c/numeric/fenv/feholdexcept]]
[[es:c/numeric/fenv/feholdexcept]]
[[fr:c/numeric/fenv/feholdexcept]]
[[it:c/numeric/fenv/feholdexcept]]
[[ja:c/numeric/fenv/feholdexcept]]
[[pt:c/numeric/fenv/feholdexcept]]
[[ru:c/numeric/fenv/feholdexcept]]
[[zh:c/numeric/fenv/feholdexcept]]</text>
      <sha1>o8bonb9ynnwq5au50l45efb8hwqtkg9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feraiseexcept</title>
    <ns>0</ns>
    <id>8612</id>
    <revision>
      <id>69562</id>
      <parentid>69476</parentid>
      <timestamp>2014-04-14T06:16:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2291">{{c/title|feraiseexcept}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
int feraiseexcept( int excepts );
}}
{{dcl end}}

Attempts to raise all floating point exceptions listed in {{tt|excepts}} (a bitwise OR of the [[c/numeric/fenv/FE_exceptions|floating point exception macros]]). If one of the exceptions is {{lc|FE_OVERFLOW}} or {{c|FE_UNDERFLOW}}, this function may additionally raise {{lc|FE_INEXACT}}. The order in which the exceptions are raised is unspecified, except that {{lc|FE_OVERFLOW}} and {{c|FE_UNDERFLOW}} are always raised before {{lc|FE_INEXACT}}.

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to raise}}
{{par end}}

===Return value===
{{c|0}} if all listed exceptions were raised, non-zero value otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
 
#pragma STDC FENV_ACCESS ON

void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;\n&quot;);
}

double some_computation(void)
{
    /* Computation reaches a state that causes overflow. */
    int r = feraiseexcept(FE_OVERFLOW {{!}} FE_INEXACT);
    printf(&quot;feraiseexcept() %s\n&quot;, (r?&quot;fails&quot;:&quot;succeeds&quot;));
    return 0.0;
}
 
int main(void)
{
    some_computation();
    show_fe_exceptions();
    
    return 0;
}
 | output=
feraiseexcept() succeeds
current exceptions raised:  FE_INEXACT FE_OVERFLOW
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feclearexcept}}
{{dsc inc | c/numeric/fenv/dsc fetestexcept}}
{{dsc see cpp | cpp/numeric/fenv/feraiseexcept}}
{{dsc end}}

[[de:c/numeric/fenv/feraiseexcept]]
[[es:c/numeric/fenv/feraiseexcept]]
[[fr:c/numeric/fenv/feraiseexcept]]
[[it:c/numeric/fenv/feraiseexcept]]
[[ja:c/numeric/fenv/feraiseexcept]]
[[pt:c/numeric/fenv/feraiseexcept]]
[[ru:c/numeric/fenv/feraiseexcept]]
[[zh:c/numeric/fenv/feraiseexcept]]</text>
      <sha1>jzdquq6m5hadp5inq8p42t1d1lf9fpr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feround</title>
    <ns>0</ns>
    <id>8613</id>
    <revision>
      <id>71776</id>
      <parentid>69410</parentid>
      <timestamp>2014-06-23T22:12:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention FLT_ROUNDS</comment>
      <text xml:space="preserve" bytes="2956">{{c/title|fegetround|fesetround}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 | num=1|
int fesetround( int round );
}}
{{dcl | since=c99 | num=2|
int fegetround();
}}
{{dcl end}}

1) Attempts to establish the floating-point rounding direction equal to the argument argument {{tt|round}}, which is expected to be one of the [[c/numeric/fenv/FE_round|floating point rounding macros]]. 

2) Returns the value of the [[c/numeric/fenv/FE_round|floating point rounding macro]] that corresponds to the current rounding direction. 

===Parameters===
{{par begin}}
{{par | round | rounding direction, one of [[c/numeric/fenv/FE_round|floating point rounding macros]]}}
{{par end}}

===Return value===
1) {{c|0}} on success, non-zero otherwise.

2) the [[c/numeric/fenv/FE_round|floating point rounding macro]] describing the current rounding direction or a negative value if the direction cannot be determined

===Notes===
The current rounding mode, reflecting the effects of the most recent {{tt|fesetround}}, can also be queried with {{lc|FLT_ROUNDS}}

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
 
#pragma STDC FENV_ACCESS ON
void show_fe_current_rounding_method(void)
{
    printf(&quot;current rounding method:  &quot;);
    switch (fegetround()) {
           case FE_TONEAREST:  printf (&quot;FE_TONEAREST&quot;);  break;
           case FE_DOWNWARD:   printf (&quot;FE_DOWNWARD&quot;);   break;
           case FE_UPWARD:     printf (&quot;FE_UPWARD&quot;);     break;
           case FE_TOWARDZERO: printf (&quot;FE_TOWARDZERO&quot;); break;
           default:            printf (&quot;unknown&quot;);
    };
    printf(&quot;\n&quot;);
}
 
int main()
{
    /* Default rounding method */
    show_fe_current_rounding_method();
    printf(&quot;+11.5 -&gt; %+4.1f\n&quot;, rint(+11.5)); /* midway between two integers */
    printf(&quot;+12.5 -&gt; %+4.1f\n&quot;, rint(+12.5)); /* midway between two integers */

    /* Save current rounding method. */
    int curr_method = fegetround();

    /* Temporarily change current rounding method. */
    fesetround(FE_DOWNWARD);
    show_fe_current_rounding_method();
    printf(&quot;+11.5 -&gt; %+4.1f\n&quot;, rint(+11.5));
    printf(&quot;+12.5 -&gt; %+4.1f\n&quot;, rint(+12.5));

    /* Restore default rounding method. */
    fesetround(curr_method);
    show_fe_current_rounding_method(); 
 
    return 0;
}
 | p=true
 | output=
current rounding method:  FE_TONEAREST
+11.5 -&gt; +12.0
+12.5 -&gt; +12.0
current rounding method:  FE_DOWNWARD
+11.5 -&gt; +11.0
+12.5 -&gt; +12.0
current rounding method:  FE_TONEAREST
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc nearbyint}}
{{dsc inc | c/numeric/math/dsc rint}}
{{dsc see cpp | cpp/numeric/fenv/feround | fegetround | fesetround}}
{{dsc end}}

[[de:c/numeric/fenv/feround]]
[[es:c/numeric/fenv/feround]]
[[fr:c/numeric/fenv/feround]]
[[it:c/numeric/fenv/feround]]
[[ja:c/numeric/fenv/feround]]
[[pt:c/numeric/fenv/feround]]
[[ru:c/numeric/fenv/feround]]
[[zh:c/numeric/fenv/feround]]</text>
      <sha1>4fhpe3ymvnmqff2bzdn2fp9r8wjs69h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fesetenv</title>
    <ns>0</ns>
    <id>8683</id>
    <redirect title="c/numeric/fenv/feenv" />
    <revision>
      <id>36561</id>
      <timestamp>2012-06-25T15:05:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/fenv/feenv]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/numeric/fenv/feenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fesetround</title>
    <ns>0</ns>
    <id>8685</id>
    <redirect title="c/numeric/fenv/feround" />
    <revision>
      <id>36563</id>
      <timestamp>2012-06-25T15:05:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/fenv/feround]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[c/numeric/fenv/feround]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/fetestexcept</title>
    <ns>0</ns>
    <id>8611</id>
    <revision>
      <id>69425</id>
      <parentid>69424</parentid>
      <timestamp>2014-04-08T13:36:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix incorrect comment (1/10 raises inexact)</comment>
      <text xml:space="preserve" bytes="2578">{{c/title|fetestexcept}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
int fetestexcept( int excepts );
}}
{{dcl end}}

Determines which of the specified subset of the floating point exceptions are currently set. The argument {{tt|excepts}} is a bitwise OR of the [[c/numeric/fenv/FE_exceptions|floating point exception macros]].

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to test}}
{{par end}}

===Return value===
Bitwise OR of the floating-point exception macros that are both included in {{tt|excepts}} and correspond to floating-point exceptions currently set.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
#include &lt;float.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

int main()
{
    /* Show default set of exception flags. */
    show_fe_exceptions();
    
    /* Perform some computations which raise exceptions. */
    printf(&quot;1.0/0.0     = %f\n&quot;, 1.0/0.0);        /* FE_DIVBYZERO            */
    printf(&quot;1.0/10.0    = %f\n&quot;, 1.0/10.0);       /* FE_INEXACT              */
    printf(&quot;sqrt(-1)    = %f\n&quot;, sqrt(-1));       /* FE_INVALID              */
    printf(&quot;DBL_MAX*2.0 = %f\n&quot;, DBL_MAX*2.0);    /* FE_INEXACT FE_OVERFLOW  */
    printf(&quot;nextafter(DBL_MIN/pow(2.0,52),0.0) = %.1f\n&quot;,
           nextafter(DBL_MIN/pow(2.0,52),0.0));   /* FE_INEXACT FE_UNDERFLOW */
    show_fe_exceptions();

    return 0;
}
 | output=
current exceptions raised:  none
1.0/0.0     = inf
1.0/10.0    = 0.100000
sqrt(-1)    = -nan
DBL_MAX*2.0 = inf
nextafter(DBL_MIN/pow(2.0,52),0.0) = 0.0
current exceptions raised:  FE_DIVBYZERO FE_INEXACT FE_INVALID FE_OVERFLOW FE_UNDERFLOW
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feclearexcept}}
{{dsc see cpp | cpp/numeric/fenv/fetestexcept}}
{{dsc end}}

[[de:c/numeric/fenv/fetestexcept]]
[[es:c/numeric/fenv/fetestexcept]]
[[fr:c/numeric/fenv/fetestexcept]]
[[it:c/numeric/fenv/fetestexcept]]
[[ja:c/numeric/fenv/fetestexcept]]
[[pt:c/numeric/fenv/fetestexcept]]
[[ru:c/numeric/fenv/fetestexcept]]
[[zh:c/numeric/fenv/fetestexcept]]</text>
      <sha1>3pip3xro14gtym7qr615rwkzxyugsrd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/fenv/feupdateenv</title>
    <ns>0</ns>
    <id>8616</id>
    <revision>
      <id>69456</id>
      <parentid>62553</parentid>
      <timestamp>2014-04-09T20:12:13Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example exhibits how a called function can hide f-p exceptions from a caller function. GCC and clang yield different output.</comment>
      <text xml:space="preserve" bytes="2805">{{c/title|feupdatedenv}}
{{c/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | &lt;fenv.h&gt;}}
{{dcl | since=c99 |
int feupdateenv( const fenv_t* envp );
}}
{{dcl end}}

First, remembers the currently raised floating-point exceptions, then restores the floating-point environment from the object pointed to by {{tt|envp}} (similar to {{lc|fesetenv}}), then raises the floating-point exceptions that were saved.

This function may be used to end the non-stop mode established by an earlier call to {{lc|feholdexcept}}.

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|fenv_t}} set by an earlier call to {{lc|feholdexcept}} or {{tt|fegetenv}} or equal to {{lc|FE_DFL_ENV}}}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
#include &lt;float.h&gt;
 
#pragma STDC FENV_ACCESS ON
 
void show_fe_exceptions(void)
{
    printf(&quot;current exceptions raised: &quot;);
    if(fetestexcept(FE_DIVBYZERO))     printf(&quot; FE_DIVBYZERO&quot;);
    if(fetestexcept(FE_INEXACT))       printf(&quot; FE_INEXACT&quot;);
    if(fetestexcept(FE_INVALID))       printf(&quot; FE_INVALID&quot;);
    if(fetestexcept(FE_OVERFLOW))      printf(&quot; FE_OVERFLOW&quot;);
    if(fetestexcept(FE_UNDERFLOW))     printf(&quot; FE_UNDERFLOW&quot;);
    if(fetestexcept(FE_ALL_EXCEPT)==0) printf(&quot; none&quot;);
    printf(&quot;\n&quot;);
}

double x2 (double x)   /* times two */
{
    fenv_t curr_excepts;
    
    /* Save and clear current f-p environment. */
    feholdexcept(&amp;curr_excepts);
    
    /* Raise inexact and overflow exceptions. */
    printf(&quot;In x2():  x = %f\n&quot;, x=x*2.0);
    show_fe_exceptions();
    feclearexcept(FE_INEXACT);   /* hide inexact exception from caller */

    /* Merge caller's exceptions (FE_INVALID)        */
    /* with remaining x2's exceptions (FE_OVERFLOW). */
    feupdateenv(&amp;curr_excepts);
    return x;
}

int main()
{    
    feclearexcept(FE_ALL_EXCEPT);
    feraiseexcept(FE_INVALID);   /* some computation with invalid argument */
    show_fe_exceptions();
    printf(&quot;x2(DBL_MAX) = %f\n&quot;, x2(DBL_MAX));
    show_fe_exceptions();
    
    return 0;
}
 | output=
current exceptions raised:  FE_INVALID
In x2():  x = inf
current exceptions raised:  FE_INEXACT FE_OVERFLOW
x2(DBL_MAX) = inf
current exceptions raised:  FE_INVALID FE_OVERFLOW
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feholdexcept}}
{{dsc inc | c/numeric/fenv/dsc feenv}}
{{dsc inc | c/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc see cpp | cpp/numeric/fenv/feupdateenv}}
{{dsc end}}

[[de:c/numeric/fenv/feupdateenv]]
[[es:c/numeric/fenv/feupdateenv]]
[[fr:c/numeric/fenv/feupdateenv]]
[[it:c/numeric/fenv/feupdateenv]]
[[ja:c/numeric/fenv/feupdateenv]]
[[pt:c/numeric/fenv/feupdateenv]]
[[ru:c/numeric/fenv/feupdateenv]]
[[zh:c/numeric/fenv/feupdateenv]]</text>
      <sha1>8ej1i2kiua8vn9w0rlx4jli5on077ic</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math</title>
    <ns>0</ns>
    <id>5969</id>
    <revision>
      <id>71911</id>
      <parentid>71826</parentid>
      <timestamp>2014-07-01T19:25:17Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>Use new templates</comment>
      <text xml:space="preserve" bytes="4162">{{title|Common mathematical functions}}
{{c/numeric/math/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc inc | c/numeric/math/dsc abs}}
{{dsc inc | c/numeric/math/dsc div}}

{{dsc header | inttypes.h}}
{{dsc inc | c/numeric/math/dsc imaxabs}}
{{dsc inc | c/numeric/math/dsc imaxdiv}}

{{dsc header | math.h}}
{{dsc h2 | Basic operations}}
{{dsc inc | c/numeric/math/dsc fabs}}
{{dsc inc | c/numeric/math/dsc fmod}}
{{dsc inc | c/numeric/math/dsc remainder}}
{{dsc inc | c/numeric/math/dsc remquo}}
{{dsc inc | c/numeric/math/dsc fma}}
{{dsc inc | c/numeric/math/dsc fmax}}
{{dsc inc | c/numeric/math/dsc fmin}}
{{dsc inc | c/numeric/math/dsc fdim}}
{{dsc inc | c/numeric/math/dsc fnan}}

{{dsc h2 | Exponential functions}}
{{dsc inc | c/numeric/math/dsc exp}}
{{dsc inc | c/numeric/math/dsc exp2}}
{{dsc inc | c/numeric/math/dsc expm1}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc inc | c/numeric/math/dsc log10}}
{{dsc inc | c/numeric/math/dsc log2}}
{{dsc inc | c/numeric/math/dsc log1p}}

{{dsc h2 | Power functions}}
{{dsc inc | c/numeric/math/dsc pow}}
{{dsc inc | c/numeric/math/dsc sqrt}}
{{dsc inc | c/numeric/math/dsc cbrt}}
{{dsc inc | c/numeric/math/dsc hypot}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | c/numeric/math/dsc sin}}
{{dsc inc | c/numeric/math/dsc cos}}
{{dsc inc | c/numeric/math/dsc tan}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc inc | c/numeric/math/dsc atan2}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | c/numeric/math/dsc sinh}}
{{dsc inc | c/numeric/math/dsc cosh}}
{{dsc inc | c/numeric/math/dsc tanh}}
{{dsc inc | c/numeric/math/dsc asinh}}
{{dsc inc | c/numeric/math/dsc acosh}}
{{dsc inc | c/numeric/math/dsc atanh}}

{{dsc h2 | Error and gamma functions}}
{{dsc inc | c/numeric/math/dsc erf}}
{{dsc inc | c/numeric/math/dsc erfc}}
{{dsc inc | c/numeric/math/dsc tgamma}}
{{dsc inc | c/numeric/math/dsc lgamma}}

{{dsc h2 | Nearest integer floating-point operations}}
{{dsc inc | c/numeric/math/dsc ceil}}
{{dsc inc | c/numeric/math/dsc floor}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc inc | c/numeric/math/dsc round}}
{{dsc inc | c/numeric/math/dsc nearbyint}}
{{dsc inc | c/numeric/math/dsc rint}}

{{dsc h2 | Floating-point manipulation functions}}
{{dsc inc | c/numeric/math/dsc frexp}}
{{dsc inc | c/numeric/math/dsc ldexp}}
{{dsc inc | c/numeric/math/dsc modf}}
{{dsc inc | c/numeric/math/dsc scalbn}}
{{dsc inc | c/numeric/math/dsc ilogb}}
{{dsc inc | c/numeric/math/dsc logb}}
{{dsc inc | c/numeric/math/dsc nextafter}}
{{dsc inc | c/numeric/math/dsc copysign}}

{{dsc h2 | Classification and comparison}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isfinite}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc inc | c/numeric/math/dsc isnormal}}
{{dsc inc | c/numeric/math/dsc signbit}}
{{dsc inc | c/numeric/math/dsc isgreater}}
{{dsc inc | c/numeric/math/dsc isgreaterequal}}
{{dsc inc | c/numeric/math/dsc isless}}
{{dsc inc | c/numeric/math/dsc islessequal}}
{{dsc inc | c/numeric/math/dsc islessgreater}}
{{dsc inc | c/numeric/math/dsc isunordered}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | stdlib.h }}
{{dsc inc | c/numeric/math/dsc div_t}}
{{dsc inc | c/numeric/math/dsc ldiv_t}}
{{dsc inc | c/numeric/math/dsc lldiv_t}}
{{dsc header | inttypes.h }}
{{dsc inc | c/numeric/math/dsc imaxdiv_t}}
{{dsc header | math.h }}
{{dsc inc | c/numeric/math/dsc float_t}}
{{dsc inc | c/numeric/math/dsc double_t}}
{{dsc end}}

===Macro constants===
{{dsc begin}}
{{dsc header | math.h}}
{{dsc inc | c/numeric/math/dsc HUGE_VAL}}
{{dsc inc | c/numeric/math/dsc INFINITY}}
{{dsc inc | c/numeric/math/dsc NAN}}
{{dsc inc | c/numeric/math/dsc math_errhandling}}
{{dsc h2 | Classification}}
{{dsc inc | c/numeric/math/dsc FP_categories}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/math | Common mathematical functions}}
{{dsc end}}

[[de:c/numeric/math]]
[[es:c/numeric/math]]
[[fr:c/numeric/math]]
[[it:c/numeric/math]]
[[ja:c/numeric/math]]
[[pt:c/numeric/math]]
[[ru:c/numeric/math]]
[[zh:c/numeric/math]]</text>
      <sha1>83irb716nic11ibtar2a2jgcd5la0n4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/FLT EVAL METHOD</title>
    <ns>0</ns>
    <id>9516</id>
    <redirect title="c/types/limits/FLT EVAL METHOD" />
    <revision>
      <id>40415</id>
      <parentid>40401</parentid>
      <timestamp>2012-10-13T08:31:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/types/limits/FLT EVAL METHOD]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[c/types/limits/FLT EVAL METHOD]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/FLT ROUNDS</title>
    <ns>0</ns>
    <id>9518</id>
    <redirect title="c/types/limits/FLT ROUNDS" />
    <revision>
      <id>40414</id>
      <parentid>40405</parentid>
      <timestamp>2012-10-13T08:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/types/limits/FLT ROUNDS]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[c/types/limits/FLT ROUNDS]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/FP categories</title>
    <ns>0</ns>
    <id>6251</id>
    <revision>
      <id>70153</id>
      <parentid>69383</parentid>
      <timestamp>2014-05-10T21:33:49Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2256">{{title|FP_NORMAL, FP_SUBNORMAL, FP_ZERO, FP_INFINITE, FP_NAN}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define FP_NORMAL    /*implementation defined*/
}}
{{dcl | since=c99 |
#define FP_SUBNORMAL /*implementation defined*/
}}
{{dcl | since=c99 |
#define FP_ZERO      /*implementation defined*/
}}
{{dcl | since=c99 |
#define FP_INFINITE  /*implementation defined*/
}}
{{dcl | since=c99 |
#define FP_NAN       /*implementation defined*/
}}
{{dcl end}}

The {{tt|FP_NORMAL}}, {{tt|FP_SUBNORMAL}}, {{tt|FP_ZERO}}, {{tt|FP_INFINITE}}, {{tt|FP_NAN}} macros each represent a distinct category of floating-point numbers. They all expand to an integer constant expression.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FP_NORMAL}} | indicates that the value is ''normal'', i.e. not an infinity, subnormal, not-a-number or zero}}
{{dsc | {{tt|FP_SUBNORMAL}} | indicates that the value is ''subnormal''}}
{{dsc | {{tt|FP_ZERO}} | indicates that the value is positive or negative zero}}
{{dsc | {{tt|FP_INFINITE}} | indicates that the value is not representable by the underlying type (positive or negative infinity)}}
{{dsc | {{tt|FP_NAN}} | indicates that the value is not-a-number (NaN)}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;FP_NAN       = %d\n&quot;, FP_NAN);         /* 0 */
    printf(&quot;FP_INFINITE  = %d\n&quot;, FP_INFINITE);    /* 1 */
    printf(&quot;FP_ZERO      = %d\n&quot;, FP_ZERO);        /* 2 */
    printf(&quot;FP_SUBNORMAL = %d\n&quot;, FP_SUBNORMAL);   /* 3 */
    printf(&quot;FP_NORMAL    = %d\n&quot;, FP_NORMAL);      /* 4 */
 
    return 0;
}
 | p=true
 | output=
FP_NAN       = 0
FP_INFINITE  = 1
FP_ZERO      = 2
FP_SUBNORMAL = 3
FP_NORMAL    = 4
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc see cpp | cpp/numeric/math/FP_categories | ntitle=floating point number categories}}
{{dsc end}}

[[de:c/numeric/math/FP categories]]
[[es:c/numeric/math/FP categories]]
[[fr:c/numeric/math/FP categories]]
[[it:c/numeric/math/FP categories]]
[[ja:c/numeric/math/FP categories]]
[[pt:c/numeric/math/FP categories]]
[[ru:c/numeric/math/FP categories]]
[[zh:c/numeric/math/FP categories]]</text>
      <sha1>k8g4og4oykfwnljve6hdbhq7g352qsy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/HUGE VAL</title>
    <ns>0</ns>
    <id>6252</id>
    <revision>
      <id>70466</id>
      <parentid>70383</parentid>
      <timestamp>2014-05-23T22:21:50Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to INFINITY (C99)</comment>
      <text xml:space="preserve" bytes="1961">{{title|HUGE_VALF|HUGE_VAL|HUGE_VALL}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define HUGE_VALF /*implementation defined*/
}}
{{dcl |
#define HUGE_VAL  /*implementation defined*/
}}
{{dcl | since=c99 |
#define HUGE_VALL /*implementation defined*/
}}
{{dcl end}}

The {{tt|HUGE_VALF}}, {{tt|HUGE_VAL}} and {{tt|HUGE_VALL}} macros expand to positive floating point constant expressions which compare equal to the values returned by floating-point functions and operators in case of overflow (see [[c/numeric/math/math_errhandling|math_errhandling]]).

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|HUGE_VALF}} | Expands to positive {{c|float}} expression that indicates overflow}}
{{dsc | {{tt|HUGE_VAL}} | Expands to positive {{c|double}} expression that indicates overflow, not necessarily representable as a {{c|float}}}}
{{dsc | {{tt|HUGE_VALL}} | Expands to positive {{c|long double}} expression that indicates overflow, not necessarily representable as a {{c|float}} or {{c|double}}}}
{{dsc end}}

On implementations that support floating-point infinities, these macros always expand to the positive infinities of {{c|float}}, {{c|double}}, and {{c|long double}}, respectively.

===Example===
{{todo|example showing how to use this}}
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;HUGE_VALF = %f\n&quot;,  HUGE_VALF);
    printf(&quot;HUGE_VAL  = %f\n&quot;,  HUGE_VAL);
    printf(&quot;HUGE_VALL = %Lf\n&quot;, HUGE_VALL);
}
 | p=true
 | output=
HUGE_VALF = inf
HUGE_VAL  = inf
HUGE_VALL = inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc INFINITY}}}
{{dsc see cpp | cpp/numeric/math/HUGE_VAL}}
{{dsc end}}

[[de:c/numeric/math/HUGE VAL]]
[[es:c/numeric/math/HUGE VAL]]
[[fr:c/numeric/math/HUGE VAL]]
[[it:c/numeric/math/HUGE VAL]]
[[ja:c/numeric/math/HUGE VAL]]
[[pt:c/numeric/math/HUGE VAL]]
[[ru:c/numeric/math/HUGE VAL]]
[[zh:c/numeric/math/HUGE VAL]]</text>
      <sha1>n6kilo1mfjm37ynr7ad1d8jqvpth07l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/INFINITY</title>
    <ns>0</ns>
    <id>13529</id>
    <revision>
      <id>70398</id>
      <parentid>70385</parentid>
      <timestamp>2014-05-21T20:05:44Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link change see also NAN (c++11) to see also INFINITY (c++11)</comment>
      <text xml:space="preserve" bytes="1002">{{title|INFINITY}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define INFINITY /*implementation defined*/
}}
{{dcl end}}

If the implementation supports floating-point infinities, the macro {{tt|INFINITY}} expands to constant expression of type {{c|float}} which evaluates to positive or unsigned infinity.

If the implementation does not support floating-point infinities, the macro {{tt|INFINITY}} expands to a positive value that is guaranteed to overflow a {{c|float}} at compile time, and the use of this macro generates a compiler warning.

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc HUGE_VAL}}
{{dsc see cpp | cpp/numeric/math/INFINITY}}
{{dsc end}}

[[de:c/numeric/math/INFINITY]]
[[es:c/numeric/math/INFINITY]]
[[fr:c/numeric/math/INFINITY]]
[[it:c/numeric/math/INFINITY]]
[[ja:c/numeric/math/INFINITY]]
[[pt:c/numeric/math/INFINITY]]
[[ru:c/numeric/math/INFINITY]]
[[zh:c/numeric/math/INFINITY]]</text>
      <sha1>llvanh0ht5viy1lo1gji9ry8wasjyy8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/NAN</title>
    <ns>0</ns>
    <id>13530</id>
    <revision>
      <id>70543</id>
      <parentid>70372</parentid>
      <timestamp>2014-05-24T22:43:03Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to fnan</comment>
      <text xml:space="preserve" bytes="728">{{title|NAN}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define NAN /*implementation defined*/
}}
{{dcl end}}

The macro {{tt|NAN}} expands to constant expression of type {{c|float}} which evaluates to a quiet not-a-number (QNaN) value. If the implementation does not support QNaNs, this macro constant is not defined. 

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fnan}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc see cpp | cpp/numeric/math/NAN}}
{{dsc end}}

[[de:c/numeric/math/NAN]]
[[es:c/numeric/math/NAN]]
[[fr:c/numeric/math/NAN]]
[[it:c/numeric/math/NAN]]
[[ja:c/numeric/math/NAN]]
[[pt:c/numeric/math/NAN]]
[[ru:c/numeric/math/NAN]]
[[zh:c/numeric/math/NAN]]</text>
      <sha1>lil45h2r9caa5fakt6gx7tjaf0nljvf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/abs</title>
    <ns>0</ns>
    <id>6266</id>
    <revision>
      <id>71225</id>
      <parentid>70538</parentid>
      <timestamp>2014-06-08T18:33:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, -undefined behavior in the example</comment>
      <text xml:space="preserve" bytes="1565">{{c/title|abs|labs|llabs|imaxabs}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl |
int        abs( int n );
}}
{{dcl |
long       labs( long n );
}}
{{dcl | since=c99 |
long long llabs( long long n );
}}
{{dcl header | inttypes.h}}
{{dcl | since=c99 |
intmax_t imaxabs( intmax_t n );
}}
{{dcl end}}

Computes the absolute value of an integer number.  The behavior is undefined if the result cannot be represented by the return type.

===Parameters===
{{par begin}}
{{par | n | integer value}}
{{par end}}

===Return value===
The absolute value of {{tt|n}} (i.e. {{tt|{{!}}n{{!}}}}), if it is representable.

===Notes===
In 2's complement systems, the absolute value of the most-negative value is out of range, e.g. for 32-bit 2's complement type int, INT_MIN is -2147483648, but the would-be result 2147483648 is greater than INT_MAX, which is 2147483647.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;limits.h&gt;

int main(void)
{
    printf(&quot;abs(+3) = %d\n&quot;, abs(+3));
    printf(&quot;abs(-3) = %d\n&quot;, abs(-3));

//  printf(&quot;%+d\n&quot;, abs(INT_MIN)); // undefined behavior on 2's complement systems
}
 | output=
abs(+3) = 3
abs(-3) = 3
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fabs}}
{{dsc inc | c/numeric/complex/dsc cabs}}
{{dsc see cpp | cpp/numeric/math/abs}}
{{dsc end}}

[[de:c/numeric/math/abs]]
[[es:c/numeric/math/abs]]
[[fr:c/numeric/math/abs]]
[[it:c/numeric/math/abs]]
[[ja:c/numeric/math/abs]]
[[pt:c/numeric/math/abs]]
[[ru:c/numeric/math/abs]]
[[zh:c/numeric/math/abs]]</text>
      <sha1>3yg5urxujd8c4hekeawrly9yy70cb6w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/acos</title>
    <ns>0</ns>
    <id>6292</id>
    <revision>
      <id>70775</id>
      <parentid>70518</parentid>
      <timestamp>2014-05-30T03:16:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="2942">{{c/title|acos, acosf, acosl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       acosf( float arg );
}}
{{dcl | num=2 |
double      acos( double arg );
}}
{{dcl | num=3 | since=c99 |
long double acosl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define acos( arg )
}}
{{dcl end}}

@1-3@ Computes the principal value of the arc cosine of {{tt|arg}}.
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|acosl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|acos}} is called. Otherwise, {{tt|acosf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|cacosf}}, {{c|cacos}}, {{c|cacosl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the arc cosine of {{tt|arg}} ({{math|arccos(arg)}}) in the range {{math|[0 ; &amp;pi;]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is outside the range {{tt|[-1.0; 1.0]}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is {{math|+1}}, the value {{tt|+0}} is returned.
* If {{math|{{!}}arg{{!}} &gt; 1}}, a domain error occurs and NaN is returned.
* if the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#include &lt;string.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;acos(-1) = %f\n&quot;, acos(-1));
    printf(&quot;acos(0.0) = %f 2*acos(0.0) = %f\n&quot;, acos(0), 2*acos(0));
    printf(&quot;acos(0.5) = %f 3*acos(0.5) = %f\n&quot;, acos(0), 3*acos(0));
    printf(&quot;acos(1) = %f\n&quot;, acos(1));
    // error handling 
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;acos(1.1) = %f\n&quot;, acos(1.1));
    if(errno == EDOM) perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
}
 | p=true
 | output=
acos(+0.0) = 1.570796
acos(-0.0) = 1.570796
acos(1.0)  = 0.0
acos(NAN)  = nan

acos(1.1)  = nan
Numerical argument out of domain
current exceptions raised:  FE_INVALID
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc inc | c/numeric/math/dsc atan2}}
{{dsc inc | c/numeric/math/dsc cos}}
{{dsc inc | c/numeric/complex/dsc cacos}}
{{dsc see cpp | cpp/numeric/math/acos}}
{{dsc end}}

[[de:c/numeric/math/acos]]
[[es:c/numeric/math/acos]]
[[fr:c/numeric/math/acos]]
[[it:c/numeric/math/acos]]
[[ja:c/numeric/math/acos]]
[[pt:c/numeric/math/acos]]
[[ru:c/numeric/math/acos]]
[[zh:c/numeric/math/acos]]</text>
      <sha1>nidbvpe14tu3ig4g4ca7mfh7dm3xa9k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/acosh</title>
    <ns>0</ns>
    <id>6297</id>
    <revision>
      <id>70782</id>
      <parentid>70603</parentid>
      <timestamp>2014-05-30T03:18:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3371">{{c/title|acosh, acoshf, acoshl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       acoshf( float arg );
}}
{{dcl | num=2 | since=c99 |
double      acosh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double acoshl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define acosh( arg )
}}
{{dcl end}}

@1-3@ Computes the inverse hyperbolic cosine of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|acoshl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|acosh}} is called. Otherwise, {{tt|acoshf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|cacoshf}}, {{c|cacosh}}, {{c|cacoshl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing the area of a hyperbolic sector}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic cosine of {{tt|arg}} ({{math|cosh{{su|p=-1}}(arg)}}, or {{math|arcosh(arg)}}) on the interval {{math|[0, +∞]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the argument is less than 1, a domain error occurs.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is less than 1, {{lc|FE_INVALID}} is raised an NaN is returned
* if the argument is 1, +0 is returned
* if the argument is +∞, +∞ is returned
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard names this function &quot;arc hyperbolic cosine&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic cosine&quot; (used by POSIX) or &quot;area hyperbolic cosine&quot;.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;acosh(1) = %f\nacosh(10) = %f\n&quot;, acosh(1), acosh(10));
    printf(&quot;acosh(DBL_MAX) = %f\nacosh(Inf) = %f\n&quot;, acosh(DBL_MAX), acosh(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;acosh(0.5) = %f\n&quot;, acosh(0.5));
    if(errno == EDOM)         perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
acosh(1) = 0.000000
acosh(10) = 2.993223
acosh(DBL_MAX) = 710.475860
acosh(Inf) = inf
acosh(0.5) = -nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc asinh}}
{{dsc inc | c/numeric/math/dsc atanh}}
{{dsc inc | c/numeric/math/dsc cosh}}
{{dsc inc | c/numeric/complex/dsc cacosh}}
{{dsc see cpp | cpp/numeric/math/acosh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicCosine.html Weisstein, Eric W. &quot;Inverse Hyperbolic Cosine.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/acosh]]
[[es:c/numeric/math/acosh]]
[[fr:c/numeric/math/acosh]]
[[it:c/numeric/math/acosh]]
[[ja:c/numeric/math/acosh]]
[[pt:c/numeric/math/acosh]]
[[ru:c/numeric/math/acosh]]
[[zh:c/numeric/math/acosh]]</text>
      <sha1>ds6uu8o1izoz2rywe4baq2raxcs1s83</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/asin</title>
    <ns>0</ns>
    <id>6291</id>
    <revision>
      <id>70774</id>
      <parentid>70515</parentid>
      <timestamp>2014-05-30T03:16:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3036">{{c/title|asin, asinf, asinl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       asinf( float arg );
}}
{{dcl | num=2 |
double      asin( double arg );
}}
{{dcl | num=3 | since=c99 |
long double asinl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define asin( arg )
}}
{{dcl end}}

@1-3@ Computes the principal values of the arc sine of {{tt|arg}}.
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|asinl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|asin}} is called. Otherwise, {{tt|asinf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|casinf}}, {{c|casin}}, {{c|casinl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the arc sine of {{tt|arg}} ({{math|arcsin(arg)}}) in the range {{math|[-{{mfrac|&amp;pi;|2}} ; +{{mfrac|&amp;pi;|2}}]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is outside the range {{tt|[-1.0; 1.0]}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If {{math|{{!}}arg{{!}} &gt; 1}}, a domain error occurs and NaN is returned.
* if the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#include &lt;string.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;asin( 1.0) = %+f, 2*asin( 1.0)=%+f\n&quot;, asin(1), 2*asin(1));
    printf(&quot;asin(-0.5) = %+f, 6*asin(-0.5)=%+f\n&quot;, asin(-0.5), 6*asin(-0.5));
    // special values
    printf(&quot;asin(0.0) = %1f, asin(-0.0)=%f\n&quot;, asin(+0.0), asin(-0.0));
    // error handling 
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;asin(1.1) = %f\n&quot;, asin(1.1));
    if(errno == EDOM) perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
asin( 1.0) = +1.570796, 2*asin( 1.0)=+3.141593
asin(-0.5) = -0.523599, 6*asin(-0.5)=-3.141593
asin(0.0) = 0.000000, asin(-0.0)=-0.000000
asin(1.1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc inc | c/numeric/math/dsc atan2}}
{{dsc inc | c/numeric/math/dsc sin}}
{{dsc inc | c/numeric/complex/dsc casin}}
{{dsc see cpp | cpp/numeric/math/asin}}
{{dsc end}}

[[de:c/numeric/math/asin]]
[[es:c/numeric/math/asin]]
[[fr:c/numeric/math/asin]]
[[it:c/numeric/math/asin]]
[[ja:c/numeric/math/asin]]
[[pt:c/numeric/math/asin]]
[[ru:c/numeric/math/asin]]
[[zh:c/numeric/math/asin]]</text>
      <sha1>huee3ljxpr92k0u9om4beo901hgmq5f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/asinh</title>
    <ns>0</ns>
    <id>6296</id>
    <revision>
      <id>70781</id>
      <parentid>70596</parentid>
      <timestamp>2014-05-30T03:18:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="2750">{{c/title|asinh, asinhf, asinhl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       asinhf( float arg );
}}
{{dcl | num=2 | since=c99 |
double      asinh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double asinhl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define asinh( arg )
}}
{{dcl end}}

@1-3@ Computes the inverse hyperbolic sine of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|asinhl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|asinh}} is called. Otherwise, {{tt|asinhf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|casinhf}}, {{c|casinh}}, {{c|casinhl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing the area of a hyperbolic sector}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic sine of {{tt|arg}} ({{math|sinh{{su|p=-1}}(arg)}}, or {{math|arsinh(arg)}}), is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned unmodified
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard names this function &quot;arc hyperbolic sine&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic sine&quot; (used by POSIX) or &quot;area hyperbolic sine&quot;.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;asinh(1) = %f\nasinh(-1) = %f\n&quot;, asinh(1), asinh(-1));
    // special values
    printf(&quot;asinh(+0) = %f\nasinh(-0) = %f\n&quot;, asinh(0.0), asinh(-0.0));
}
 | output=
asinh(1) = 0.881374
asinh(-1) = -0.881374
asinh(+0) = 0.000000
asinh(-0) = -0.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc acosh}}
{{dsc inc | c/numeric/math/dsc atanh}}
{{dsc inc | c/numeric/math/dsc sinh}}
{{dsc inc | c/numeric/complex/dsc casinh}}
{{dsc see cpp | cpp/numeric/math/asinh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicSine.html Weisstein, Eric W. &quot;Inverse Hyperbolic Sine.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/asinh]]
[[es:c/numeric/math/asinh]]
[[fr:c/numeric/math/asinh]]
[[it:c/numeric/math/asinh]]
[[ja:c/numeric/math/asinh]]
[[pt:c/numeric/math/asinh]]
[[ru:c/numeric/math/asinh]]
[[zh:c/numeric/math/asinh]]</text>
      <sha1>kmnl52m51x64o1v5xe9sdogpg8sw3bi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/atan</title>
    <ns>0</ns>
    <id>6301</id>
    <revision>
      <id>71594</id>
      <parentid>70776</parentid>
      <timestamp>2014-06-14T04:51:30Z</timestamp>
      <contributor>
        <ip>68.106.218.183</ip>
      </contributor>
      <comment>Arg is not limited to the range [-1.0; 1.0]</comment>
      <text xml:space="preserve" bytes="2764">{{c/title|atan, atanf, atanl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       atanf( float arg );
}}
{{dcl | num=2 |
double      atan( double arg );
}}
{{dcl | num=3 | since=c99 |
long double atanl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl | num=4 | since=c99 |
#define atan( arg )
}}
{{dcl end}}

@1-3@ Computes the principal value of the arc tangent of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|atanl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|atan}} is called. Otherwise, {{tt|atanf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|catanf}}, {{c|catan}}, {{c|catanl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the arc tangent of {{tt|arg}} ({{math|arctan(arg)}}) in the range {{math|[-{{mfrac|&amp;pi;|2}} ; +{{mfrac|&amp;pi;|2}}]}} radians, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If the argument is +∞, +&amp;pi;/2 is returned
* If the argument is -∞, -&amp;pi;/2 is returned
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atan.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;atan(1) = %f, 4*atan(1)=%f\n&quot;, atan(1), 4*atan(1));
    // special values
    printf(&quot;atan(Inf) = %f, 2*atan(Inf) = %f\n&quot;, atan(INFINITY), 2*atan(INFINITY));
    printf(&quot;atan(-0.0) = %+f, atan(+0.0 = %+f\n&quot;, atan(-0.0), atan(0));
}
 | output=
atan(1) = 0.785398, 4*atan(1)=3.141593
atan(Inf) = 1.570796, 2*atan(Inf) = 3.141593
atan(-0.0) = -0.000000, atan(+0.0 = +0.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc atan2}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc inc | c/numeric/math/dsc tan}}
{{dsc inc | c/numeric/complex/dsc catan}}
{{dsc see cpp | cpp/numeric/math/atan}}
{{dsc end}}

[[de:c/numeric/math/atan]]
[[es:c/numeric/math/atan]]
[[fr:c/numeric/math/atan]]
[[it:c/numeric/math/atan]]
[[ja:c/numeric/math/atan]]
[[pt:c/numeric/math/atan]]
[[ru:c/numeric/math/atan]]
[[zh:c/numeric/math/atan]]</text>
      <sha1>0dszvf9uexvme215unjztjf049kiu6b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/atan2</title>
    <ns>0</ns>
    <id>6293</id>
    <revision>
      <id>71267</id>
      <parentid>70777</parentid>
      <timestamp>2014-06-09T03:15:50Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to asin and acos, -link to tan and hypot</comment>
      <text xml:space="preserve" bytes="4627">{{c/title|atan2, atan2f, atan2l}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       atan2f( float y, float x );
}}
{{dcl | num=2 |
double      atan2( double y, double x );
}}
{{dcl | num=3 | since=c99 |
long double atan2l( long double y, long double x );
}}
{{dcl header | tgmath.h}}
{{dcl | num=4 | since=c99 |
#define atan2( arg )
}}
{{dcl end}}

@1-3@ Computes the arc tangent of {{tt|y/x}} using the signs of arguments to determine the correct quadrant.
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|atan2l}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|atan2}} is called. Otherwise, {{tt|atan2f}} is called.

===Parameters===
{{par begin}}
{{par | x, y | floating point value}}
{{par end}}

===Return value===
If no errors occur, the arc tangent of {{tt|y/x}} ({{math|arctan({{mfrac|y|x}})}}) in the range {{math|[-&amp;pi; ; +&amp;pi;]}} radians, is returned.

{{plot | math-atan2.png | left=Y argument | bottom=X argument | right=Return value | size=x240px}}

If a domain error occurs, an implementation-defined value is returned

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|x}} and {{tt|y}} are both zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|x}} and {{tt|y}} are both zero, domain error ''does not'' occur
* If {{tt|x}} and {{tt|y}} are both zero, range error does not occur either
* If {{tt|y}} is zero, pole error does not occur
* If {{tt|y}} is {{tt|±0}} and {{tt|x}} is negative or {{tt|-0}}, {{tt|±&amp;pi;}} is returned
* If {{tt|y}} is {{tt|±0}} and {{tt|x}} is negative or {{tt|+0}}, {{tt|±0}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is finite, {{tt|±&amp;pi;/2}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is {{tt|-∞}}, {{tt|±3&amp;pi;/4}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is {{tt|+∞}}, {{tt|±&amp;pi;/4}} is returned
* If {{tt|x}} is {{tt|±0}} and {{tt|y}} is negative, {{tt|-&amp;pi;/2}} is returned
* If {{tt|x}} is {{tt|±0}} and {{tt|y}} is positive, {{tt|+&amp;pi;/2}} is returned
* If {{tt|x}} is {{tt|-∞}} and {{tt|y}} is finite and positive, {{tt|+&amp;pi;}} is returned
* If {{tt|x}} is {{tt|-∞}} and {{tt|y}} is finite and negative, {{tt|-&amp;pi;}} is returned
* If {{tt|x}} is {{tt|+∞}} and {{tt|y}} is finite and positive, {{tt|+0}} is returned
* If {{tt|x}} is {{tt|+∞}} and {{tt|y}} is finite and negative, {{tt|-0}} is returned
* If either {{tt|x}} is NaN or {{tt|y}} is NaN, NaN is returned

===Notes===
{{c|atan2(y, x)}} is equivalent to {{c|carg(x + I*y)}}.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atan2.html POSIX specifies] that in case of underflow, {{tt|y/x}} is the value returned, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    // normal usage: the signs of the two arguments determine the quadrant
    // atan2(1,1) = +pi/4, Quad I
    printf(&quot;(+1,+1) cartesian is (%f,%f) polar\n&quot;, hypot( 1, 1), atan2( 1, 1));
    // atan2(1, -1) = +3pi/4, Quad II
    printf(&quot;(+1,-1) cartesian is (%f,%f) polar\n&quot;, hypot( 1,-1), atan2( 1,-1));
    // atan2(-1,-1) = -3pi/4, Quad III
    printf(&quot;(-1,-1) cartesian is (%f,%f) polar\n&quot;, hypot(-1,-1), atan2(-1,-1));
    // atan2(-1,-1) = -pi/4, Quad IV
    printf(&quot;(-1,+1) cartesian is (%f,%f) polar\n&quot;, hypot(-1, 1), atan2(-1, 1));

    // special values
    printf(&quot;atan2(0, 0) = %f atan2(0, -0)=%f\n&quot;, atan2(0,0), atan2(0,-0.0));
    printf(&quot;atan2(7, 0) = %f atan2(7, -0)=%f\n&quot;, atan2(7,0), atan2(7,-0.0));
}
 | output=
(+1,+1) cartesian is (1.414214,0.785398) polar
(+1,-1) cartesian is (1.414214,2.356194) polar
(-1,-1) cartesian is (1.414214,-2.356194) polar
(-1,+1) cartesian is (1.414214,-0.785398) polar
atan2(0, 0) = 0.000000 atan2(0, -0)=3.141593
atan2(7, 0) = 1.570796 atan2(7, -0)=1.570796
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc inc | c/numeric/complex/dsc carg}}
{{dsc see cpp | cpp/numeric/math/atan2}}
{{dsc end}}

[[de:c/numeric/math/atan2]]
[[es:c/numeric/math/atan2]]
[[fr:c/numeric/math/atan2]]
[[it:c/numeric/math/atan2]]
[[ja:c/numeric/math/atan2]]
[[pt:c/numeric/math/atan2]]
[[ru:c/numeric/math/atan2]]
[[zh:c/numeric/math/atan2]]</text>
      <sha1>g9avif5pzkte9lhiea8yqgv5fjpui92</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/atanh</title>
    <ns>0</ns>
    <id>6298</id>
    <revision>
      <id>70783</id>
      <parentid>70605</parentid>
      <timestamp>2014-05-30T03:19:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3882">{{c/title|atanh, atanhf, atanhl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       atanhf( float arg );
}}
{{dcl | num=2 | since=c99 |
double      atanh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double atanhl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define atanh( arg )
}}
{{dcl end}}

@1-3@ Computes the inverse hyperbolic tangent of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|atanhl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|atanh}} is called. Otherwise, {{tt|atanhf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|catanhf}}, {{c|catanh}}, {{c|catanhl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing the area of a hyperbolic sector}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic tangent of {{tt|arg}} ({{math|tanh{{su|p=-1}}(arg)}}, or {{math|artanh(arg)}}), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned (with the correct sign).

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the argument is not on the interval {{math|[-1, +1]}}, a range error occurs.

If the argument is ±1, a pole error occurs.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±1, ±∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* if {{math|{{!}}arg{{!}}&gt;1}}, NaN is returned and {{lc|FE_INVALID}} is raised.
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard names this function &quot;arc hyperbolic tangent&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic tangent&quot; (used by POSIX) or &quot;area hyperbolic tangent&quot;.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atanh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, an implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;atanh(0) = %f\natanh(-0) = %f\n&quot;, atanh(0), atanh(-0.0));
    printf(&quot;atanh(0.9) = %f\n&quot;, atanh(0.9));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;atanh(-1) = %f\n&quot;, atanh(-1));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
atanh(0) = 0.000000
atanh(-0) = -0.000000
atanh(0.9) = 1.472219
atanh(-1) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc asinh}}
{{dsc inc | c/numeric/math/dsc acosh}}
{{dsc inc | c/numeric/math/dsc tanh}}
{{dsc inc | c/numeric/complex/dsc catanh}}
{{dsc see cpp | cpp/numeric/math/atanh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicTangent.html Weisstein, Eric W. &quot;Inverse Hyperbolic Tangent.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/atanh]]
[[es:c/numeric/math/atanh]]
[[fr:c/numeric/math/atanh]]
[[it:c/numeric/math/atanh]]
[[ja:c/numeric/math/atanh]]
[[pt:c/numeric/math/atanh]]
[[ru:c/numeric/math/atanh]]
[[zh:c/numeric/math/atanh]]</text>
      <sha1>8kn2yr660vewt9obpwcz9eu7rwxps8d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/cbrt</title>
    <ns>0</ns>
    <id>6285</id>
    <revision>
      <id>70769</id>
      <parentid>70719</parentid>
      <timestamp>2014-05-30T03:14:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="2185">{{c/title|cbrt, cbrtf, cbrtl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       cbrtf( float arg );
}}
{{dcl | num=2 | since=c99 |
double      cbrt( double arg );
}}
{{dcl | num=3 | since=c99 |
long double cbrtl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl | num=4 | since=c99 |
#define cbrt( arg )
}}
{{dcl end}}

@1-3@ Computes the cubic root of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|cbrtl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|cbrt}} is called. Otherwise, {{tt|cbrtf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the cubic root of {{tt|arg}} ({{math|{{mrad|arg|3}}}}), is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned, unchanged
* if the argument is NaN, NaN is returned.

===Notes===
{{c|cbrt(arg)}} is not equivalent to {{c|pow(arg, 1.0/3)}} because {{lc|pow}} cannot raise a negative base to a fractional exponent.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main()
{
    // normal use
    printf(&quot;cbrt(729) = %f\n&quot;, cbrt(729));
    printf(&quot;cbrt(-0.125) = %f\n&quot;, cbrt(-0.125));
    // special values
    printf(&quot;cbrt(-0) = %f\n&quot;, cbrt(-0.0));
    printf(&quot;cbrt(+inf) = %f\n&quot;, cbrt(INFINITY));
}  
 | output=
cbrt(729) = 9.000000
cbrt(-0.125) = -0.500000
cbrt(-0) = -0.000000
cbrt(+inf) = inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc pow}}
{{dsc inc | c/numeric/math/dsc sqrt}}
{{dsc inc | c/numeric/math/dsc hypot}}
{{dsc see cpp | cpp/numeric/math/cbrt}}
{{dsc end}}

[[de:c/numeric/math/cbrt]]
[[es:c/numeric/math/cbrt]]
[[fr:c/numeric/math/cbrt]]
[[it:c/numeric/math/cbrt]]
[[ja:c/numeric/math/cbrt]]
[[pt:c/numeric/math/cbrt]]
[[ru:c/numeric/math/cbrt]]
[[zh:c/numeric/math/cbrt]]</text>
      <sha1>sc0uukfstkbgrbw8ahhhjotqltc6t5e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/ceil</title>
    <ns>0</ns>
    <id>6303</id>
    <revision>
      <id>71873</id>
      <parentid>71847</parentid>
      <timestamp>2014-06-30T16:50:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2973">{{c/title|ceil|ceilf|ceill}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       ceilf( float arg );
}}
{{dcl | num=2|
double      ceil( double arg );
}}
{{dcl | since=c99 | num=3|
long double ceill( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define ceil( arg )
}}
{{dcl end}}

@1-3@ Computes the smallest integer value not less than {{tt|arg}}. 
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|ceill}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|ceil}} is called. Otherwise, {{tt|ceilf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the smallest integer value not less than {{tt|arg}}, that is {{math|⌈arg⌉}}, is returned.

{{plot | left=Return value | bottom=Argument | math-ceil.svg}}

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

This function (for double argument) behaves as if (except for the freedom to not raise {{lc|FE_INEXACT}}) implemented by

{{source|1=#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
double ceil(double x)
{
    double result;
    int save_round = fegetround();
    fesetround(FE_UPWARD);
    result = rint(x); // or nearbyint 
    fesetround(save_round);
    return result;
}
}}

===Example===
{{example |
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
int main(void)
{
    printf(&quot;ceil(+2.4) = %+.1f\n&quot;, ceil(2.4));
    printf(&quot;ceil(-2.4) = %+.1f\n&quot;, ceil(-2.4));
    printf(&quot;ceil(-0.0) = %+.1f\n&quot;, ceil(-0.0));
    printf(&quot;ceil(-Inf) = %+f\n&quot;,   ceil(-INFINITY));
}
 | p=true
 | output=
ceil(+2.4) = +3.0
ceil(-2.4) = -2.0
ceil(-0.0) = -0.0
ceil(-Inf) = -inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc floor}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc inc | c/numeric/math/dsc round}}
{{dsc inc | c/numeric/math/dsc nearbyint}}
{{dsc inc | c/numeric/math/dsc rint}}
{{dsc see cpp | cpp/numeric/math/ceil}}
{{dsc end}}

[[de:c/numeric/math/ceil]]
[[es:c/numeric/math/ceil]]
[[fr:c/numeric/math/ceil]]
[[it:c/numeric/math/ceil]]
[[ja:c/numeric/math/ceil]]
[[pt:c/numeric/math/ceil]]
[[ru:c/numeric/math/ceil]]
[[zh:c/numeric/math/ceil]]</text>
      <sha1>nnqs0jdzvm1hp2dg8pa0lxfejoq69u6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/copysign</title>
    <ns>0</ns>
    <id>6259</id>
    <revision>
      <id>70145</id>
      <parentid>69268</parentid>
      <timestamp>2014-05-10T21:07:58Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1531">{{c/title|copysign}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
float       copysignf( float x, float y );
}}
{{dcl | since=c99 |
double      copysign( double x, double y );
}}
{{dcl | since=c99 |
long double copysignl( long double x, long double y );
}}
{{dcl end}}

Composes a floating point value with the magnitude of {{tt|x}} and the sign of {{tt|y}}. 

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
Floating point value with the magnitude of {{tt|x}} and the sign of {{tt|y}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;copysign(1.0,+2.0)      = %+.1f\n&quot;, copysign(1.0,+2.0));
    printf(&quot;copysign(1.0,-2.0)      = %+.1f\n&quot;, copysign(1.0,-2.0));
    printf(&quot;copysign(INFINITY,-2.0) = %f\n&quot;,    copysign(INFINITY,-2.0));
    printf(&quot;copysign(NAN,-2.0)      = %f\n&quot;,    copysign(NAN,-2.0));
 
    return 0;
}
 | p=true
 | output=
copysign(1.0,+2.0)      = +1.0
copysign(1.0,-2.0)      = -1.0
copysign(INFINITY,-2.0) = -inf
copysign(NAN,-2.0)      = -nan
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fabs}}
{{dsc inc | c/numeric/math/dsc signbit}}
{{dsc see cpp | cpp/numeric/math/copysign}}
{{dsc end}}

[[de:c/numeric/math/copysign]]
[[es:c/numeric/math/copysign]]
[[fr:c/numeric/math/copysign]]
[[it:c/numeric/math/copysign]]
[[ja:c/numeric/math/copysign]]
[[pt:c/numeric/math/copysign]]
[[ru:c/numeric/math/copysign]]
[[zh:c/numeric/math/copysign]]</text>
      <sha1>cicwd73b2mg38hzr7ghh629nczf314b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/cos</title>
    <ns>0</ns>
    <id>6289</id>
    <revision>
      <id>70772</id>
      <parentid>70510</parentid>
      <timestamp>2014-05-30T03:15:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3130">{{c/title|cos, cosf, cosl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1| since=c99 |
float       cosf( float arg );
}}
{{dcl |num=2| 
double      cos( double arg );
}}
{{dcl | num=3| since=c99 |
long double cosl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define cos( arg )
}}
{{dcl end}}

@1-3@ Computes the cosine of {{tt|arg}} (measured in radians).
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|cosl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|cos}} is called. Otherwise, {{tt|cosf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|ccosf}}, {{c|ccos}}, {{c|ccosl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing angle in radians}}
{{par end}}

===Return value===
===Return value===
If no errors occur, the cosine of {{tt|arg}} ({{math|cos(arg)}}) in the range {{math|[-1 ; +1]}}, is returned.

{{rev begin}}
{{rev|until=c++11|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, the result is 1.0
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C, but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/cos.html domain error in POSIX]

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    double pi = acos(-1);
    // typical usage
    printf(&quot;cos(pi/3) = %f\n&quot;, cos(pi/3));
    printf(&quot;cos(pi/2) = %f\n&quot;, cos(pi/2));
    printf(&quot;cos(-3*pi/4) = %f\n&quot;, cos(-3*pi/4));
    // special values
    printf(&quot;cos(+0) = %f\n&quot;, cos(0.0));
    printf(&quot;cos(-0) = %f\n&quot;, cos(-0.0));
    // error handling 
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;cos(INFINITY) = %f\n&quot;, cos(INFINITY));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
cos(pi/3) = 0.500000
cos(pi/2) = 0.000000
cos(-3*pi/4) = -0.707107
cos(+0) = 1.000000
cos(-0) = 1.000000
cos(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc sin}}
{{dsc inc | c/numeric/math/dsc tan}}
{{dsc inc | c/numeric/math/dsc acos}}
{{dsc inc | c/numeric/complex/dsc ccos}}
{{dsc see cpp | cpp/numeric/math/cos}}
{{dsc end}}

[[de:c/numeric/math/cos]]
[[es:c/numeric/math/cos]]
[[fr:c/numeric/math/cos]]
[[it:c/numeric/math/cos]]
[[ja:c/numeric/math/cos]]
[[pt:c/numeric/math/cos]]
[[ru:c/numeric/math/cos]]
[[zh:c/numeric/math/cos]]</text>
      <sha1>p6clealq9lr47gz5o6oh46c8yyr86ve</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/cosh</title>
    <ns>0</ns>
    <id>6302</id>
    <revision>
      <id>70779</id>
      <parentid>70557</parentid>
      <timestamp>2014-05-30T03:18:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="2885">{{c/title|cosh, coshf, coshl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       coshf( float arg );
}}
{{dcl | num=2 |
double      cosh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double coshl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define cosh( arg )
}}
{{dcl end}}

@1-3@ Computes the hyperbolic cosine of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|coshl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|cosh}} is called. Otherwise, {{tt|coshf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|ccoshf}}, {{c|ccosh}}, {{c|ccoshl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing a hyperbolic angle}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic cosine of {{tt|arg}} ({{math|cosh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}+e{{su|p=-arg}}|2}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, 1 is returned
* If the argument is ±∞, +∞ is returned
* if the argument is NaN, NaN is returned

===Notes===
For the IEEE-compatible type {{c|double}}, if {{math|{{!}}arg{{!}} &gt; 710.5}}, then {{tt|cosh(arg)}} overflows.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;cosh(1) = %f\ncosh(-1)= %f\n&quot;, cosh(1), cosh(-1));
    printf(&quot;log(sinh(1) + cosh(1))=%f\n&quot;, log(sinh(1)+cosh(1)));
    // special values
    printf(&quot;cosh(+0) = %f\ncosh(-0) = %f\n&quot;, cosh(0.0), cosh(-0.0));
    // error handling 
    errno=0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;cosh(710.5) = %f\n&quot;, cosh(710.5));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
cosh(1) = 1.543081
cosh(-1)= 1.543081
log(sinh(1) + cosh(1))=1.000000
cosh(+0) = 1.000000
cosh(-0) = 1.000000
cosh(710.5) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc sinh}}
{{dsc inc | c/numeric/math/dsc tanh}}
{{dsc inc | c/numeric/math/dsc acosh}}
{{dsc inc | c/numeric/complex/dsc ccosh}}
{{dsc see cpp | cpp/numeric/math/cosh}}
{{dsc end}}

[[de:c/numeric/math/cosh]]
[[es:c/numeric/math/cosh]]
[[fr:c/numeric/math/cosh]]
[[it:c/numeric/math/cosh]]
[[ja:c/numeric/math/cosh]]
[[pt:c/numeric/math/cosh]]
[[ru:c/numeric/math/cosh]]
[[zh:c/numeric/math/cosh]]</text>
      <sha1>svke76uut14r1af5wukax4fpw4xgjpx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/div</title>
    <ns>0</ns>
    <id>6268</id>
    <revision>
      <id>71695</id>
      <parentid>71390</parentid>
      <timestamp>2014-06-20T20:17:48Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to remainder and remquo</comment>
      <text xml:space="preserve" bytes="3520">{{c/title|div|ldiv|lldiv|imaxdiv}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl |num=1|
div_t     div( int x, int y );
}}
{{dcl |num=2|
ldiv_t    ldiv( long x, long y );
}}
{{dcl | since=c99 |num=3|
lldiv_t   lldiv( long long x, long long y );
}}
{{dcl header | inttypes.h}}
{{dcl | since=c99 |num=4|
imaxdiv_t imaxdiv( intmax_t x, intmax_t y );
}}
{{dcl end}}

Computes both the quotient and the remainder of the division of the numerator {{tt|x}} by the denominator {{tt|y}}

{{rev begin}}
{{rev|until=c99|
Computes quotient and remainder simultaneously. The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that {{c|1=quot * y + rem == x}}.
}}
{{rev|since=c99|
Computes the quotient (the result of the expression {{c|x/y}}) and remainder (the result of the expression {{c|x%y}}) simultaneously.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | x, y | integer values}}
{{par end}}

===Return value===
If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, imaxdiv_t, respectively), returns both as an object of type {{tt|div_t}}, {{tt|ldiv_t}}, {{tt|ldiv_t}}, {{tt|imaxdiv_t}} defined as follows:

{{member | div_t | 2=
{{source|1=
struct div_t { int quot; int rem; };
}}
or
{{source|1=
struct div_t { int rem; int quot; };
}}
}}

{{member | ldiv_t | 2=
{{source|1=
struct ldiv_t { long quot; long rem; };
}}
or
{{source|1=
struct ldiv_t { long rem; long quot; };
}}
}}

{{member | lldiv_t | 2=
{{source|1=
struct lldiv_t { long long quot; long long rem; };
}}
or
{{source|1=
struct lldiv_t { long long rem; long long quot; };
}}
}}

{{member | imaxdiv_t | 2=
{{source|1=
struct imaxdiv_t { intmax_t quot; intmax_t rem; };
}}
or
{{source|1=
struct imaxdiv_t { intmax_t rem; intmax_t quot; };
}}
}}


If either the remainder or the quotient cannot be represented, the behavior is undefined.


===Notes===
Until C99, the rounding direction of the quotient and the sign of the remainder in the built-in division and remainder operators was implementation-defined if either of the operands was negative, but it was well-defined in {{tt|div}} and {{tt|ldiv}}.

On many platforms, a single CPU instruction obtains both the quotient and the remainder, and this function may leverage that, although compilers are generally able to merge nearby / and % where suitable.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;stdlib.h&gt;

// demo only: does not check for buffer overflow
void itoa(int n, int base, char* buf)
{
    div_t dv = {.quot = n};
    char* p = buf;
    do {
        dv = div(dv.quot, base);
        *p++ = &quot;0123456789abcdef&quot;[abs(dv.rem)];
    } while(dv.quot);
    if(n&lt;0) *p++ = '-';
    *p-- = '\0';
    while(buf &lt; p) { char c = *p; *p-- = *buf; *buf++ = c; } // reverse
}

int main(void)
{
    char buf[100];
    itoa(12346, 10, buf);
    printf(&quot;%s\n&quot;, buf);
    itoa(-12346, 10, buf);
    printf(&quot;%s\n&quot;, buf);
    itoa(65535, 16, buf);
    printf(&quot;%s\n&quot;, buf);
}
 | output=
12346
-12346
ffff
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fmod}}
{{dsc inc | c/numeric/math/dsc remainder}}
{{dsc inc | c/numeric/math/dsc remquo}}
{{dsc see cpp | cpp/numeric/math/div}}
{{dsc end}}

[[de:c/numeric/math/div]]
[[es:c/numeric/math/div]]
[[fr:c/numeric/math/div]]
[[it:c/numeric/math/div]]
[[ja:c/numeric/math/div]]
[[pt:c/numeric/math/div]]
[[ru:c/numeric/math/div]]
[[zh:c/numeric/math/div]]</text>
      <sha1>cqifoikaxs1o2ab258dqmltksecvgzp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/erf</title>
    <ns>0</ns>
    <id>6299</id>
    <revision>
      <id>71160</id>
      <parentid>71157</parentid>
      <timestamp>2014-06-07T05:20:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+definition</comment>
      <text xml:space="preserve" bytes="2794">{{c/title|erf, erff, erfl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       erff( float arg );
}}
{{dcl | since=c99 |num=2|
double      erf( double arg );
}}
{{dcl | since=c99 |num=3|
long double erfl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define erf( arg )
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Error function|error function]] of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|erfl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|erf}} is called. Otherwise, {{tt|erff}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, value of the error function of {{tt|arg}}, that is {{math|{{mfrac|2|{{mrad|&amp;pi;}}}}{{minteg|0|arg|{{mexp|-t{{su|p=2}}}}d''t''}}}}, is returned.

If a range error occurs due to underflow, the correct result (after rounding), that is {{math|{{mfrac|2*arg|{{mrad|&amp;pi;}}}}}} is returned

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, ±0 is returned
* If the argument is ±∞, ±1 is returned
* If the argument is NaN, NaN is returned

===Notes===
Underflow is guaranteed if {{c|{{!}}arg{{!}} &lt; DBL_MIN*(sqrt(π)/2)}}

{{math|erf({{mfrac|x|&amp;sigma;{{mrad|2}}}})}} is the probability that a measurement whose errors are subject to a normal distribution with standard deviation {{math|&amp;sigma;}} is less than {{math|x}} away from the mean value.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
double phi(double x1, double x2)
{
    return (erf(x2/sqrt(2)) - erf(x1/sqrt(2)))/2;
}
int main(void)
{
    puts(&quot;normal variate probabilities:&quot;);
    for(int n=-4; n&lt;4; ++n)
        printf(&quot;[%2d:%2d]: %5.2f%%\n&quot;, n, n+1, 100*phi(n, n+1));

    puts(&quot;special values:&quot;);
    printf(&quot;erf(-0) = %f\n&quot;, erf(-0.0));
    printf(&quot;erf(Inf) = %f\n&quot;, erf(INFINITY));
}
 | output=
normal variate probabilities:
[-4:-3]:  0.13%
[-3:-2]:  2.14%
[-2:-1]: 13.59%
[-1: 0]: 34.13%
[ 0: 1]: 34.13%
[ 1: 2]: 13.59%
[ 2: 3]:  2.14%
[ 3: 4]:  0.13%
special values:
erf(-0) = -0.000000
erf(Inf) = 1.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc erfc}}
{{dsc see cpp | cpp/numeric/math/erf}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/Erf.html Weisstein, Eric W. &quot;Erf.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/erf]]
[[es:c/numeric/math/erf]]
[[fr:c/numeric/math/erf]]
[[it:c/numeric/math/erf]]
[[ja:c/numeric/math/erf]]
[[pt:c/numeric/math/erf]]
[[ru:c/numeric/math/erf]]
[[zh:c/numeric/math/erf]]</text>
      <sha1>ps1hbv36bc0y4tn378s52qe2ofw2hgq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/erfc</title>
    <ns>0</ns>
    <id>6300</id>
    <revision>
      <id>71178</id>
      <parentid>71167</parentid>
      <timestamp>2014-06-07T19:17:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missing num=...</comment>
      <text xml:space="preserve" bytes="2873">{{c/title|erfc, erfcf, erfcl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       erfcf( float arg );
}}
{{dcl | since=c99 |num=2|
double      erfc( double arg );
}}
{{dcl | since=c99 |num=3|
long double erfcl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define erfc( arg )
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Complementary error function|complementary error function]] of {{tt|arg}}, that is {{tt|1.0-erf(arg)}}, but without loss of precision for large {{tt|arg}}
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|erfcl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|erfc}} is called. Otherwise, {{tt|erfcf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, value of the complementary error function of {{tt|arg}}, that is {{math|{{mfrac|2|{{mrad|&amp;pi;}}}}{{minteg|arg|∞|{{mexp|-t{{su|p=2}}}}d''t''}}}} or {{math|1-erf(arg)}}, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is +∞, +0 is returned
* If the argument is -∞, 2 is returned
* If the argument is NaN, NaN is returned

===Notes===
For the IEEE-compatible type {{tt|double}}, underflow is guaranteed if {{tt|arg}} &gt; 26.55.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

double normalCDF(double x) // Phi(-∞, x) aka N(x)
{
    return erfc(-x*sqrt(2))/2;
}
int main(void)
{
    puts(&quot;normal cumulative distribution function:&quot;);
    for(double n=0; n&lt;1; n+=0.1)
        printf(&quot;normalCDF(%.2f) %5.2f%%\n&quot;, n, 100*normalCDF(n));

    puts(&quot;special values:&quot;);
    printf(&quot;erfc(-Inf) = %f\n&quot;, erfc(-INFINITY));
    printf(&quot;erfc(Inf) = %f\n&quot;, erfc(INFINITY));
}
|output=
normal cumulative distribution function:
normalCDF(0.00) 50.00%
normalCDF(0.10) 57.93%
normalCDF(0.20) 65.54%
normalCDF(0.30) 72.57%
normalCDF(0.40) 78.81%
normalCDF(0.50) 84.13%
normalCDF(0.60) 88.49%
normalCDF(0.70) 91.92%
normalCDF(0.80) 94.52%
normalCDF(0.90) 96.41%
normalCDF(1.00) 97.72%
special values:
erfc(-Inf) = 2.000000
erfc(Inf) = 0.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc erf}}
{{dsc see cpp | cpp/numeric/math/erfc}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/Erfc.html Weisstein, Eric W. &quot;Erfc.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/erfc]]
[[es:c/numeric/math/erfc]]
[[fr:c/numeric/math/erfc]]
[[it:c/numeric/math/erfc]]
[[ja:c/numeric/math/erfc]]
[[pt:c/numeric/math/erfc]]
[[ru:c/numeric/math/erfc]]
[[zh:c/numeric/math/erfc]]</text>
      <sha1>a6e40frhe13gihy2chs7ao5pktwqqje</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/exp</title>
    <ns>0</ns>
    <id>6282</id>
    <revision>
      <id>70766</id>
      <parentid>70685</parentid>
      <timestamp>2014-05-30T03:12:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath notes</comment>
      <text xml:space="preserve" bytes="3032">{{c/title|exp, expf, expl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       expf( float arg );
}}
{{dcl |num=2|
double      exp( double arg );
}}
{{dcl | since=c99 |num=3|
long double expl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define exp( arg )
}}
{{dcl end}}

@1-3@ Computes the ''e'' (Euler's number, {{tt|2.7182818}}) raised to the given power {{tt|arg}}
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|expl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|exp}} is called. Otherwise, {{tt|expf}} is called. If {{tt|arg}} is complex, then the macro invokes the corresponding complex function ({{c|cexpf}}, {{c|cexp}}, {{c|cexpl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the base-''e'' exponential of {{tt|arg}} ({{math|e{{su|p=arg}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, 1 is returned
* If the argument is -∞, +0 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
For IEEE-compatible type {{c|double}}, overflow is guaranteed if {{math|709.8 &lt; arg}}, and underflow is guaranteed if {{math|arg &lt; -708.4}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;exp(1) = %f\n&quot;, exp(1));
    printf(&quot;FV of $100, continuously compounded at 3%% for 1 year = %f\n&quot;,
            100*exp(0.03));
    // special values
    printf(&quot;exp(-0) = %f\n&quot;, exp(-0.0));
    printf(&quot;exp(-Inf) = %f\n&quot;, exp(-INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;exp(710) = %f\n&quot;, exp(710));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
|p=true
|output=
exp(1) = 2.718282
FV of $100, continuously compounded at 3% for 1 year = 103.045453
exp(-0) = 1.000000
exp(-Inf) = 0.000000
exp(710) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc exp2}}
{{dsc inc | c/numeric/math/dsc expm1}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc inc | c/numeric/complex/dsc cexp}}
{{dsc see cpp | cpp/numeric/math/exp}}
{{dsc end}}

[[de:c/numeric/math/exp]]
[[es:c/numeric/math/exp]]
[[fr:c/numeric/math/exp]]
[[it:c/numeric/math/exp]]
[[ja:c/numeric/math/exp]]
[[pt:c/numeric/math/exp]]
[[ru:c/numeric/math/exp]]
[[zh:c/numeric/math/exp]]</text>
      <sha1>4l12xlu3vj6nyozs0z2ipvo0o4vmt1u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/exp2</title>
    <ns>0</ns>
    <id>6277</id>
    <revision>
      <id>70912</id>
      <parentid>70911</parentid>
      <timestamp>2014-06-02T19:06:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>oops, the whole example was c++.</comment>
      <text xml:space="preserve" bytes="2643">{{c/title|exp2, exp2f, exp2l}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       exp2f( float n );
}}
{{dcl | since=c99 |num=2|
double      exp2( double n );
}}
{{dcl | since=c99 |num=3|
long double exp2l( long double n );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define exp2( n )
}}
{{dcl end}}

@1-3@ Computes 2 raised to the given power {{tt|n}}
@4@ Type-generic macro: If {{tt|n}} has type {{c|long double}}, {{tt|exp2l}} is called. Otherwise, if {{tt|n}} has integer type or the type {{c|double}}, {{tt|exp2}} is called. Otherwise, {{tt|exp2f}} is called.

===Parameters===
{{par begin}}
{{par | n | floating point value}}
{{par end}}

===Return value===
If no errors occur, the base-''2'' exponential of {{tt|n}} ({{math|2{{su|p=n}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, 1 is returned
* If the argument is -∞, +0 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;exp2(4) = %f\n&quot;, exp2(5));
    printf(&quot;exp2(0.5) = %f\n&quot;, exp2(0.5));
    printf(&quot;exp2(-4) = %f\n&quot;, exp2(-4));
    // special values
    printf(&quot;exp2(-9) = %f\n&quot;, exp2(-0.9));
    printf(&quot;exp2(-Inf) = %f\n&quot;, exp2(-INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;exp2(1024) = %f\n&quot;, exp2(1024));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
exp2(4) = 32.000000
exp2(0.5) = 1.414214
exp2(-4) = 0.062500
exp2(-9) = 0.535887
exp2(-Inf) = 0.000000
exp2(1024) = Inf
    errno == ERANGE: Result too large
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc exp}}
{{dsc inc | c/numeric/math/dsc expm1}}
{{dsc inc | c/numeric/math/dsc log2}}
{{dsc see cpp | cpp/numeric/math/exp2}}
{{dsc end}}

[[de:c/numeric/math/exp2]]
[[es:c/numeric/math/exp2]]
[[fr:c/numeric/math/exp2]]
[[it:c/numeric/math/exp2]]
[[ja:c/numeric/math/exp2]]
[[pt:c/numeric/math/exp2]]
[[ru:c/numeric/math/exp2]]
[[zh:c/numeric/math/exp2]]</text>
      <sha1>4ya3kqqgyeqat8607rbz0jawyvxk1pe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/expm1</title>
    <ns>0</ns>
    <id>6278</id>
    <revision>
      <id>70923</id>
      <parentid>70917</parentid>
      <timestamp>2014-06-03T14:54:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+tgmath</comment>
      <text xml:space="preserve" bytes="3499">{{c/title|expm1, expm1f, expm1l}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1 |
float       expm1f( float arg );
}}
{{dcl | since=c99 |num=2 |
double      expm1( double arg );
}}
{{dcl | since=c99 |num=3 |
long double expm1l( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define expm1( arg )
}}
{{dcl end}}

@1-3@ Computes the ''e'' (Euler's number, {{tt|2.7182818}}) raised to the given power {{tt|arg}}, minus {{c|1.0}}. This function is more accurate than the expression {{c|std::exp(arg)-1.0}} if {{tt|arg}} is close to zero.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|expm1l}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|expm1}} is called. Otherwise, {{tt|expm1f}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur {{math|e{{su|p=arg}}-1}} is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned, unmodified
* If the argument is -∞, -1 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
The functions {{tt|expm1}} and {{lc|log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1+x){{su|p=n}}-1}} can be expressed as {{c|expm1(n * log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.

For IEEE-compatible type {{c|double}}, overflow is guaranteed if {{math|709.8 &lt; arg}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;expm1(1) = %f\n&quot;, expm1(1));
    printf(&quot;Interest earned in 2 days on on $100, compounded daily at 1%\n&quot;
           &quot; on a 30/360 calendar = %f\n&quot;,
           100*expm1(2*log1p(0.01/360)));
    printf(&quot;exp(1e-16)-1 = %g, but expm1(1e-16) = %g\n&quot;,
           exp(1e-16)-1, expm1(1e-16));
    // special values
    printf(&quot;expm1(-0) = %f\n&quot;, expm1(-0.0));
    printf(&quot;expm1(-Inf) = %f\n&quot;, expm1(-INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;expm1(710) = %f\n&quot;, expm1(710));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
expm1(1) = 1.718282
Interest earned in 2 days on on $100, compounded daily at 1%
 on a 30/360 calendar = 0.005556
exp(1e-16)-1 = 0, but expm1(1e-16) = 1e-16
expm1(-0) = -0.000000
expm1(-Inf) = -1.000000
expm1(710) = inf
    errno == ERANGE: Result too large
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc exp}}
{{dsc inc | c/numeric/math/dsc exp2}}
{{dsc inc | c/numeric/math/dsc log1p}}
{{dsc see cpp | cpp/numeric/math/expm1}}
{{dsc end}}

[[de:c/numeric/math/expm1]]
[[es:c/numeric/math/expm1]]
[[fr:c/numeric/math/expm1]]
[[it:c/numeric/math/expm1]]
[[ja:c/numeric/math/expm1]]
[[pt:c/numeric/math/expm1]]
[[ru:c/numeric/math/expm1]]
[[zh:c/numeric/math/expm1]]</text>
      <sha1>iqetmgdupvrjg9187xzo3zatn624o7u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fabs</title>
    <ns>0</ns>
    <id>6267</id>
    <revision>
      <id>71303</id>
      <parentid>71238</parentid>
      <timestamp>2014-06-09T04:35:31Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to copysign</comment>
      <text xml:space="preserve" bytes="2232">{{c/title|fabs, fabsf, fabsl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       fabsf( float arg ); 
}}
{{dcl | num=2 |
double      fabs( double arg );
}}
{{dcl | num=3 | since=c99 |
long double fabsl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define fabs( arg )
}}
{{dcl end}}

@1-3@ Computes the absolute value of a floating point value {{tt|arg}}.
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|fabsl}} is called. Otherwise, if the argument has integer type or has type {{c|double}}, {{tt|fabs}} is called. Otherwise, {{tt|fabsf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|cabsf}}, {{c|cabs}}, {{c|cabsl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If successful, returns the absolute value of {{tt|arg}} ({{tt|{{!}}arg{{!}}}}). The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, +0 is returned
* If the argument is ±∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;fabs(+3) = %f\n&quot;, fabs(+3.0));
    printf(&quot;fabs(-3) = %f\n&quot;, fabs(-3.0));
    // special values
    printf(&quot;fabs(-0) = %f\n&quot;, fabs(-0.0));
    printf(&quot;fabs(-Inf) = %f\n&quot;, fabs(-INFINITY));
}
 | output=
fabs(+3) = 3.000000
fabs(-3) = 3.000000
fabs(-0) = 0.000000
fabs(-Inf) = inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc abs}}
{{dsc inc | c/numeric/math/dsc copysign}}
{{dsc inc | c/numeric/math/dsc signbit}}
{{dsc inc | c/numeric/complex/dsc cabs}}
{{dsc see cpp | cpp/numeric/math/fabs}}
{{dsc end}}

[[de:c/numeric/math/fabs]]
[[es:c/numeric/math/fabs]]
[[fr:c/numeric/math/fabs]]
[[it:c/numeric/math/fabs]]
[[ja:c/numeric/math/fabs]]
[[pt:c/numeric/math/fabs]]
[[ru:c/numeric/math/fabs]]
[[zh:c/numeric/math/fabs]]</text>
      <sha1>qedctenql5tmvhuvyqokf8i8onnf2bx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fdim</title>
    <ns>0</ns>
    <id>6275</id>
    <revision>
      <id>71199</id>
      <parentid>71197</parentid>
      <timestamp>2014-06-08T01:53:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-stray tt</comment>
      <text xml:space="preserve" bytes="2577">{{c/title|fdim}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       fdimf( float x, float y );
}}
{{dcl | since=c99 |num=2|
double      fdim( double x, double y );
}}
{{dcl | since=c99 |num=3|
long double fdiml( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define fdim( x, y )
}}
{{dcl end}}

@1-3@ Returns the positive difference between {{c|x}} and {{c|y}}, that is, if {{c|x&gt;y}}, returns {{c|x-y}}, otherwise (if {{c|x≤y}}), returns +0.
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|fdiml}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|fdim}} is called. Otherwise, {{tt|fdimf}} is called.

===Parameters===
{{par begin}}
{{par | x, y | floating point value}}
{{par end}}

===Return value===
If successful, returns the positive difference between x and y.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If either argument is NaN, NaN is returned

===Notes===
Equivalent to {{c|fmax(x-y, 0)}} except for the NaN handling requirements

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;fdim(4, 1) = %f, fdim(1, 4)=%f\n&quot;, fdim(4,1), fdim(1,4));
    printf(&quot;fdim(4,-1) = %f, fdim(1,-4)=%f\n&quot;, fdim(4,-1), fdim(1,-4));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;fdim(1e308, -1e308) = %f\n&quot;, fdim(1e308, -1e308));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
fdim(4, 1) = 3.000000, fdim(1, 4)=0.000000
fdim(4,-1) = 5.000000, fdim(1,-4)=5.000000
fdim(1e308, -1e308) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc abs}}
{{dsc inc | c/numeric/math/dsc fmax}}
{{dsc see cpp | cpp/numeric/math/fdim}}
{{dsc end}}

[[de:c/numeric/math/fdim]]
[[es:c/numeric/math/fdim]]
[[fr:c/numeric/math/fdim]]
[[it:c/numeric/math/fdim]]
[[ja:c/numeric/math/fdim]]
[[pt:c/numeric/math/fdim]]
[[ru:c/numeric/math/fdim]]
[[zh:c/numeric/math/fdim]]</text>
      <sha1>ptq6zq97v5vvyhwsf21h9ue3p8jdfgf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/floor</title>
    <ns>0</ns>
    <id>6304</id>
    <revision>
      <id>71875</id>
      <parentid>69655</parentid>
      <timestamp>2014-06-30T17:03:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="2532">{{c/title|floor|floorf|floorl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       floorf( float arg );
}}
{{dcl |num=2|
double      floor( double arg );
}}
{{dcl | since=c99 |num=3|
long double floorl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define floor( arg )
}}
{{dcl end}}

@1-3@ Computes the largest integer value not greater than {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|floorl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|floor}} is called. Otherwise, {{tt|floorf}} is called.
 
===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the largest integer value not greater than {{tt|arg}}, that is {{math|⌊arg⌋}}, is returned.

{{plot | left=Return value | bottom=Argument | math-floor.svg}}

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

===Example===
{{example |
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
int main(void)
{
    printf(&quot;floor(+2.7) = %+.1f\n&quot;, floor(2.7));
    printf(&quot;floor(-2.7) = %+.1f\n&quot;, floor(-2.7));
    printf(&quot;floor(-0.0) = %+.1f\n&quot;, floor(-0.0));
    printf(&quot;floor(-Inf) = %+f\n&quot;,   floor(-INFINITY));
}
 | p=true
 | output=
floor(+2.7) = +2.0
floor(-2.7) = -3.0
floor(-0.0) = -0.0
floor(-Inf) = -inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc ceil}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc inc | c/numeric/math/dsc round}}
{{dsc see cpp | cpp/numeric/math/floor}}
{{dsc end}}

[[de:c/numeric/math/floor]]
[[es:c/numeric/math/floor]]
[[fr:c/numeric/math/floor]]
[[it:c/numeric/math/floor]]
[[ja:c/numeric/math/floor]]
[[pt:c/numeric/math/floor]]
[[ru:c/numeric/math/floor]]
[[zh:c/numeric/math/floor]]</text>
      <sha1>1cah33uh5myvidkk1egr5569r3zmtzq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fma</title>
    <ns>0</ns>
    <id>6272</id>
    <revision>
      <id>71227</id>
      <parentid>71223</parentid>
      <timestamp>2014-06-08T19:33:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>wikilink for fma/mac</comment>
      <text xml:space="preserve" bytes="5219">{{c/title|fma, fmaf, fmal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       fmaf( float x, float y, float z );
}}
{{dcl | since=c99 |num=2|
double      fma( double x, double y, double z );
}}
{{dcl | since=c99 |num=3|
long double fmal( long double x, long double y, long double z );
}}
{{dcl | since=c99 | num=4 |
#define FP_FAST_FMA  /* implementation-defined */
}}
{{dcl | since=c99 | num=5 |
#define FP_FAST_FMAF /* implementation-defined */
}}
{{dcl | since=c99 | num=6 |
#define FP_FAST_FMAL /* implementation-defined */
}}
{{dcl header | tgmath.h}}
{{dcl |num=7| since=c99 |
#define fma( x, y )
}}
{{dcl end}}

@1-3@ Computes {{c|(x*y) + z}} as if to infinite precision and rounded only once to fit the result type.
@4-6@ If the macro constants {{tt|FP_FAST_FMAF}}, {{tt|FP_FAST_FMA}}, or {{tt|FP_FAST_FMAL}} are defined, the corresponding function {{tt|fmaf}}, {{tt|fma}}, or {{tt|fmal}} evaluates faster (in addition to being more precise) than the expression {{c|x*y+z}} for {{c|float}}, {{c|double}}, and {{c|long double}} arguments, respectively. If defined, these macros evaluate to integer {{c|1}}.
@7@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|fminl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|fmin}} is called. Otherwise, {{tt|fminf}} is called.

===Parameters===
{{par begin}}
{{par | x, y, z | floating point values}}
{{par end}}

===Return value===
If successful, returns the value of {{c|(x*y) + z}} as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation)

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If x is zero and y is infinite or if x is infinite and y is zero, and z is not a NaN, then NaN is returned and {{lc|FE_INVALID}} is raised
* If x is zero and y is infinite or if x is infinite and y is zero, and z is a NaN, then NaN is returned and {{lc|FE_INVALID}} may be raised
* If x*y is an exact infinity and z is an infinity with the opposite sign, NaN is returned and {{lc|FE_INVALID}} is raised
* If x or y are NaN, NaN is returned
* If z is NaN, and x*y aren't 0*Inf or Inf*0, then NaN is returned (without FE_INVALID)

===Notes===
This operation is commonly implemented in hardware as [[enwiki:Multiply%E2%80%93accumulate_operation|fused multiply-add]] CPU instruction. If supported by hardware, the appropriate FP_FAST_FMA* macros are expected to be defined, but many implementations make use of the CPU instruction even when the macros are not defined.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fma.html POSIX specifies] that the situation where the value x*y is invalid and z is a NaN is a domain error.

Due to its infinite intermediate precision, {{tt|fma}} is a common building block of other correctly-rounded mathematical operations, such as {{lc|sqrt}} or even the division (where not provided by the CPU, e.g. Itanium)

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    // demo the difference between fma and built-in operators
    double in = 0.1;
    printf(&quot;0.1 double is %.23f (%a)\n&quot;, in, in);
    printf(&quot;0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3),&quot;
           &quot; or 1.0 if rounded to double\n&quot;);
    double expr_result = 0.1 * 10 - 1;
    printf(&quot;0.1 * 10 - 1 = %g : 1 subtracted after &quot;
           &quot;intermediate rounding to 1.0\n&quot;, expr_result);
    double fma_result = fma(0.1, 10, -1);
    printf(&quot;fma(0.1, 10, -1) = %g (%a)\n&quot;, fma_result, fma_result);

    // fma use in double-double arithmetic
    printf(&quot;\nin double-double arithmetic, 0.1 * 10 is representable as &quot;);
    double high = 0.1 * 10;
    double low = fma(0.1, 10, -high);
    printf(&quot;%g + %g\n\n&quot;, high, low);

    //error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;fma(+Inf, 10, -Inf) = %f\n&quot;, fma(INFINITY, 10, -INFINITY));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
0.1 double is 0.10000000000000000555112 (0x1.999999999999ap-4)
0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3), or 1.0 if rounded to double
0.1 * 10 - 1 = 0 : 1 subtracted after intermediate rounding to 1.0
fma(0.1, 10, -1) = 5.55112e-17 (0x1p-54)

in double-double arithmetic, 0.1 * 10 is representable as 1 + 5.55112e-17

fma(+Inf, 10, -Inf) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc remainder}}
{{dsc inc | c/numeric/math/dsc remquo}}
{{dsc see cpp | cpp/numeric/math/fma}}
{{dsc end}}

[[de:c/numeric/math/fma]]
[[es:c/numeric/math/fma]]
[[fr:c/numeric/math/fma]]
[[it:c/numeric/math/fma]]
[[ja:c/numeric/math/fma]]
[[pt:c/numeric/math/fma]]
[[ru:c/numeric/math/fma]]
[[zh:c/numeric/math/fma]]</text>
      <sha1>4tsj0wiqjaz5sql5n3gn2gic57lytbp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fmax</title>
    <ns>0</ns>
    <id>6273</id>
    <revision>
      <id>71217</id>
      <parentid>70132</parentid>
      <timestamp>2014-06-08T16:00:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, slightly shorter example</comment>
      <text xml:space="preserve" bytes="2276">{{c/title|fmax, fmaxf, fmaxl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       fmaxf( float x, float y );
}}
{{dcl | since=c99 |num=2|
double      fmax( double x, double y );
}}
{{dcl | since=c99 |num=3|
long double fmaxl( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define fmax( x, y )
}}
{{dcl end}}

@1-3@ Returns the larger of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen)
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|fmaxl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|fmax}} is called. Otherwise, {{tt|fmaxf}} is called.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
If successful, returns the larger of two floating point values. The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If one of the two arguments is NaN, the value of the other argument is returned
* Only if both arguments are NaN, NaN is returned

===Notes===
This function is not required to be sensitive to the sign of zero, although some implementations additionally enforce that if one argument is +0 and the other is -0, then +0 is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;fmax(2,1)    = %f\n&quot;, fmax(2,1));
    printf(&quot;fmax(-Inf,0) = %f\n&quot;, fmax(-INFINITY,0));
    printf(&quot;fmax(NaN,-1) = %f\n&quot;, fmax(NAN,-1));
}
 | output=
fmax(2,1)    = 2.000000
fmax(-Inf,0) = 0.000000
fmax(NaN,-1) = -1.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isgreater}}
{{dsc inc | c/numeric/math/dsc fmin}}
{{dsc see cpp | cpp/numeric/math/fmax}}
{{dsc end}}

[[de:c/numeric/math/fmax]]
[[es:c/numeric/math/fmax]]
[[fr:c/numeric/math/fmax]]
[[it:c/numeric/math/fmax]]
[[ja:c/numeric/math/fmax]]
[[pt:c/numeric/math/fmax]]
[[ru:c/numeric/math/fmax]]
[[zh:c/numeric/math/fmax]]</text>
      <sha1>iftdx5i71lyh7y4bkz0mjvxpwxjvko9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fmin</title>
    <ns>0</ns>
    <id>6274</id>
    <revision>
      <id>71216</id>
      <parentid>70133</parentid>
      <timestamp>2014-06-08T15:54:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, slightly shorter example (+0/-0 is unspecified)</comment>
      <text xml:space="preserve" bytes="2281">{{c/title|fmin, fminf, fminl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       fminf( float x, float y );
}}
{{dcl | since=c99 |num=2|
double      fmin( double x, double y );
}}
{{dcl | since=c99 |num=3|
long double fminl( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define fmin( x, y )
}}
{{dcl end}}

@1-3@ Returns the smaller of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen)
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|fminl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|fmin}} is called. Otherwise, {{tt|fminf}} is called.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
If successful, returns the smaller of two floating point values. The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If one of the two arguments is NaN, the value of the other argument is returned
* Only if both arguments are NaN, NaN is returned

===Notes===
This function is not required to be sensitive to the sign of zero, although some implementations additionally enforce that if one argument is +0 and the other is -0, then -0 is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;fmin(2,1)    = %f\n&quot;, fmin(2,1));
    printf(&quot;fmin(-Inf,0) = %f\n&quot;, fmin(-INFINITY,0));
    printf(&quot;fmin(NaN,-1) = %f\n&quot;, fmin(NAN,-1));
}
 | p=true
 | output=
fmin(2,1)    = 1.000000
fmin(-Inf,0) = -inf
fmin(NaN,-1) = -1.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isless}}
{{dsc inc | c/numeric/math/dsc fmax}}
{{dsc see cpp | cpp/numeric/math/fmin}}
{{dsc end}}

[[de:c/numeric/math/fmin]]
[[es:c/numeric/math/fmin]]
[[fr:c/numeric/math/fmin]]
[[it:c/numeric/math/fmin]]
[[ja:c/numeric/math/fmin]]
[[pt:c/numeric/math/fmin]]
[[ru:c/numeric/math/fmin]]
[[zh:c/numeric/math/fmin]]</text>
      <sha1>b68l5zgrzyypp1s04z1is2roztonl5e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fmod</title>
    <ns>0</ns>
    <id>6269</id>
    <revision>
      <id>71786</id>
      <parentid>71785</parentid>
      <timestamp>2014-06-24T01:50:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="4201">{{c/title|fmod|fmodf|fmodl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       fmodf( float x, float y );
}}
{{dcl | num=2 |
double      fmod( double x, double y );
}}
{{dcl | num=3 | since=c99 |
long double fmodl( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define fmod( x, y )
}}
{{dcl end}}

@1-3@ Computes the floating-point remainder of the division operation {{c|x/y}}.
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|fmodl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|fmod}} is called. Otherwise, {{tt|fmodf}} is called.

The floating-point remainder of the division operation {{c|x/y}} calculated by this function is exactly the value {{c|x - n*y}}, where {{tt|n}} is {{c|x/y}} with its fractional part truncated.

The returned value has the same sign as {{tt|x}} and is less or equal to {{tt|y}} in magnitude.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
If successful, returns the floating-point remainder of the division {{c|x/y}} as defined above.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|x}} is ±0 and {{tt|y}} is not zero, ±0 is returned
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±∞ and {{tt|x}} is finite, {{tt|x}} is returned. 
* If either argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fmod.html  POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

{{tt|std::fmod}}, but not {{lc|std::remainder}} is useful for doing silent wrapping of floating-point types to unsigned integer types: {{c|1=(0.0 &lt;= (y = fmod(rint(x), 65536.0 )) ? y : 65536.0 + y)}} is in the range {{tt|[-0.0 .. 65535.0]}}, which corresponds to {{c|unsigned short}}, but {{c|remainder(rint(x), 65536.0}} is in the range {{tt|[-32767.0, +32768.0]}}, which is outside of the range of {{c|signed short}}.

The double version of fmod behaves as if implemented as follows
{{source|1=
double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = remainder(fabs(x), (y = fabs(y)));
    if (signbit(result)) result += y;
    return copysign(result, x);
}
}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;fmod(+5.1, +3.0) = %.1f\n&quot;, fmod(5.1,3));
    printf(&quot;fmod(-5.1, +3.0) = %.1f\n&quot;, fmod(-5.1,3));
    printf(&quot;fmod(+5.1, -3.0) = %.1f\n&quot;, fmod(5.1,-3));
    printf(&quot;fmod(-5.1, -3.0) = %.1f\n&quot;, fmod(-5.1,-3));

    // special values
    printf(&quot;fmod(+0.0, 1.0) = %.1f\n&quot;, fmod(0, 1));
    printf(&quot;fmod(-0.0, 1.0) = %.1f\n&quot;, fmod(-0.0, 1));
    printf(&quot;fmod(+5.1, Inf) = %.1f\n&quot;, fmod(5.1, INFINITY));

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;fmod(+5.1, 0) = %.1f\n&quot;, fmod(5.1, 0));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p = true
 | output=
fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0.0
fmod(-0.0, 1.0) = -0.0
fmod(+5.1, Inf) = 5.1
fmod(+5.1, 0) = nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc div}}
{{dsc inc | c/numeric/math/dsc remainder}}
{{dsc inc | c/numeric/math/dsc remquo}}
{{dsc see cpp | cpp/numeric/math/fmod}}
{{dsc end}}

[[de:c/numeric/math/fmod]]
[[es:c/numeric/math/fmod]]
[[fr:c/numeric/math/fmod]]
[[it:c/numeric/math/fmod]]
[[ja:c/numeric/math/fmod]]
[[pt:c/numeric/math/fmod]]
[[ru:c/numeric/math/fmod]]
[[zh:c/numeric/math/fmod]]</text>
      <sha1>ad4qhgzxqnwqpya2ath82n7hv2to0c6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/fpclassify</title>
    <ns>0</ns>
    <id>6258</id>
    <revision>
      <id>70146</id>
      <parentid>69269</parentid>
      <timestamp>2014-05-10T21:09:24Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2214">{{c/title|fpclassify}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define fpclassify(arg) /* implementation defined */
}}
{{dcl end}}

Categorizes floating point value {{tt|arg}} into the following categories: zero, subnormal, normal, infinite, NAN, or implementation-defined category. The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
One of {{lc|FP_INFINITE}}, {{lc|FP_NAN}}, {{lc|FP_NORMAL}}, {{lc|FP_SUBNORMAL}}, {{lc|FP_ZERO}} or implementation-defined type, specifying the category of {{tt|arg}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;FP_NAN       = %d\n&quot;, FP_NAN);         // 0
    printf(&quot;FP_INFINITE  = %d\n&quot;, FP_INFINITE);    // 1
    printf(&quot;FP_ZERO      = %d\n&quot;, FP_ZERO);        // 2
    printf(&quot;FP_SUBNORMAL = %d\n&quot;, FP_SUBNORMAL);   // 3
    printf(&quot;FP_NORMAL    = %d\n&quot;, FP_NORMAL);      // 4
    printf(&quot;\n&quot;);

    printf(&quot;fpclassify(NAN)         = %d\n&quot;, fpclassify(NAN));           // 0
    printf(&quot;fpclassify(INFINITY)    = %d\n&quot;, fpclassify(INFINITY));      // 1
    printf(&quot;fpclassify(0.0)         = %d\n&quot;, fpclassify(0.0));           // 2
    printf(&quot;fpclassify(DBL_MIN/2.0) = %d\n&quot;, fpclassify(DBL_MIN/2.0));   // 3
    printf(&quot;fpclassify(1.0)         = %d\n&quot;, fpclassify(1.0));           // 4
 
    return 0;
}
 | p=true
 | output=
FP_NAN       = 0
FP_INFINITE  = 1
FP_ZERO      = 2
FP_SUBNORMAL = 3
FP_NORMAL    = 4

fpclassify(NAN)         = 0
fpclassify(INFINITY)    = 1
fpclassify(0.0)         = 2
fpclassify(DBL_MIN/2.0) = 3
fpclassify(1.0)         = 4
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isfinite}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc inc | c/numeric/math/dsc isnormal}}
{{dsc see cpp | cpp/numeric/math/fpclassify}}
{{dsc end}}

[[de:c/numeric/math/fpclassify]]
[[es:c/numeric/math/fpclassify]]
[[fr:c/numeric/math/fpclassify]]
[[it:c/numeric/math/fpclassify]]
[[ja:c/numeric/math/fpclassify]]
[[pt:c/numeric/math/fpclassify]]
[[ru:c/numeric/math/fpclassify]]
[[zh:c/numeric/math/fpclassify]]</text>
      <sha1>nv8pxbv67npn6yo6t8ua2v5169qaa7q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/frexp</title>
    <ns>0</ns>
    <id>6309</id>
    <revision>
      <id>70142</id>
      <parentid>69657</parentid>
      <timestamp>2014-05-10T20:57:50Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2425">{{c/title|frexp}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
float       frexpf( float arg, int* exp );
}}
{{dcl |
double      frexp( double arg, int* exp );
}}
{{dcl | since=c99 |
long double frexpl( long double arg, int* exp );
}}
{{dcl end}}

Decomposes given floating point value {{tt|arg}} to significand and exponent. 

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par | exp | pointer to integer value to store the exponent to}}
{{par end}}

===Return value===
Significand of the given floating point number in the range of {{tt|[0.5; 1)}}. The exponent is put into integer value pointed to by {{tt|exp}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    int exp;
    printf(&quot;frexp(1.0,&amp;exp)       = %+f * 2^&quot;, frexp(1.0,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(+0.0,&amp;exp)      = %+f * 2^&quot;, frexp(+0.0,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(-0.0,&amp;exp)      = %+f * 2^&quot;, frexp(-0.0,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(+INFINITY,&amp;exp) = %+f * 2^&quot;, frexp(+INFINITY,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(-INFINITY,&amp;exp) = %+f * 2^&quot;, frexp(-INFINITY,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(NAN,&amp;exp)       = %+f * 2^&quot;, frexp(NAN,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;\n&quot;);

    printf(&quot;frexp(DBL_MIN,&amp;exp) = %+f * 2^&quot;, frexp(DBL_MIN,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);
    printf(&quot;frexp(DBL_MAX,&amp;exp) = %+f * 2^&quot;, frexp(DBL_MAX,&amp;exp));
    printf(&quot;(%+2d)\n&quot;, exp);

    return 0;
}
 | p=true
 | output=
frexp(1.0,&amp;exp)       = +0.500000 * 2^(+1)
frexp(+0.0,&amp;exp)      = +0.000000 * 2^(+0)
frexp(-0.0,&amp;exp)      = -0.000000 * 2^(+0)
frexp(+INFINITY,&amp;exp) = +inf * 2^(+0)
frexp(-INFINITY,&amp;exp) = -inf * 2^(+0)
frexp(NAN,&amp;exp)       = +nan * 2^(+0)

frexp(DBL_MIN,&amp;exp) = +0.500000 * 2^(-1021)
frexp(DBL_MAX,&amp;exp) = +1.000000 * 2^(+1024)
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc ldexp}}
{{dsc inc | c/numeric/math/dsc logb}}
{{dsc inc | c/numeric/math/dsc ilogb}}
{{dsc inc | c/numeric/math/dsc modf}}
{{dsc see cpp | cpp/numeric/math/frexp}}
{{dsc end}}

[[de:c/numeric/math/frexp]]
[[es:c/numeric/math/frexp]]
[[fr:c/numeric/math/frexp]]
[[it:c/numeric/math/frexp]]
[[ja:c/numeric/math/frexp]]
[[pt:c/numeric/math/frexp]]
[[ru:c/numeric/math/frexp]]
[[zh:c/numeric/math/frexp]]</text>
      <sha1>70qoiwsf6c9cn48l2042my3nrqbxvq8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/hypot</title>
    <ns>0</ns>
    <id>6286</id>
    <revision>
      <id>70768</id>
      <parentid>70630</parentid>
      <timestamp>2014-05-30T03:14:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath notes</comment>
      <text xml:space="preserve" bytes="4160">{{c/title|hypot, hypotf, hypotl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1| since=c99 |
float       hypotf( float x, float y );
}}
{{dcl |num=2| since=c99 |
double      hypot( double x, double y );
}}
{{dcl |num=3| since=c99 |
long double hypotl( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define hypot( x, y )
}}
{{dcl end}}

@1-3@ Computes the square root of the sum of the squares of {{tt|x}} and {{tt|y}}, without undue overflow or underflow at intermediate stages of the computation.
@4@ Type-generic macro: If any argument has type {{c|long double}}, the long double version of the function is called. Otherwise, if any argument has integer type or has type {{c|double}}, the double version of the function is called. Otherwise, the {{c|float}} version of the function is called.

The value computed by this function is the length of the hypotenuse of a right-angled triangle with sides of length {{tt|x}} and {{tt|y}}, or the distance of the point {{tt|(x,y)}} from the origin {{tt|(0,0)}}, or the magnitude of a complex number {{tt|x+''i''y}}.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===
If no errors occur, the hypotenuse of a right-angled triangle, {{math|{{mrad|x{{su|p=2}}+y{{su|p=2}}}}}}, is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{c|hypot(x, y)}}, {{c|hypot(y, x)}}, and {{c|hypot(x, -y)}} are equivalent
* if one of the arguments is ±0, {{tt|hypot}} is equivalent to {{c|fabs}} called with the non-zero argument
* if one of the arguments is ±∞, {{tt|hypot}} returns +∞ even if the other argument is NaN
* otherwise, if any of the arguments is NaN, NaN is returned

===Notes===
Implementations usually guarantee precision of less than 1 ulp (units in the last place): [http://sourceware.org/git/?p=glibc.git;a=blob_plain;f=sysdeps/ieee754/dbl-64/e_hypot.c GNU], [http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/msun/src/e_hypot.c?rev=1.13.4.2;content-type=text%2Fplain BSD], [http://www.open64.net/doc/d5/d3f/hypot_8c-source.html Open64].

{{c|hypot(x, y)}} is equivalent to {{c|cabs(x + I*y)}}.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/hypot.html POSIX specifies] that underflow may only occur when both arguments are subnormal and the correct result is also subnormal (this forbids naive implementations)

{{c|hypot(INFINITY, NAN)}} returns +∞, but {{c|sqrt(INFINITY*INFINITY+NAN*NAN)}} returns NaN.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#include &lt;float.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    // typical usage
    printf(&quot;(1,1) cartesian is (%f,%f) polar\n&quot;, hypot(1,1), atan2(1,1));
    // special values
    printf(&quot;hypot(NAN,INFINITY) = %f\n&quot;, hypot(NAN,INFINITY));
    // error handling 
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;hypot(DBL_MAX,DBL_MAX) = %f\n&quot;, hypot(DBL_MAX,DBL_MAX));
    if(errno == ERANGE)         perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
(1,1) cartesian is (1.414214,0.785398) polar
hypot(NAN,INFINITY) = inf
hypot(DBL_MAX,DBL_MAX) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc pow}}
{{dsc inc | c/numeric/math/dsc sqrt}}
{{dsc inc | c/numeric/math/dsc cbrt}}
{{dsc inc | c/numeric/complex/dsc cabs}}
{{dsc see cpp | cpp/numeric/math/hypot}}
{{dsc end}}

[[de:c/numeric/math/hypot]]
[[es:c/numeric/math/hypot]]
[[fr:c/numeric/math/hypot]]
[[it:c/numeric/math/hypot]]
[[ja:c/numeric/math/hypot]]
[[pt:c/numeric/math/hypot]]
[[ru:c/numeric/math/hypot]]
[[zh:c/numeric/math/hypot]]</text>
      <sha1>fnwn4alqrdmlhlwwipgbdu80yqvc7qh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/ilogb</title>
    <ns>0</ns>
    <id>6262</id>
    <revision>
      <id>72291</id>
      <parentid>72271</parentid>
      <timestamp>2014-08-04T20:55:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-stray word</comment>
      <text xml:space="preserve" bytes="4950">{{c/title|ilogb|ilogbf|ilogbl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1 |
int ilogbf( float arg );
}}
{{dcl | since=c99 | num=2 |
int ilogb( double arg );
}}
{{dcl | since=c99 | num=3 |
int ilogbl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define ilogb( arg )
}}
{{dcl header | math.h}}
{{dcl | since=c99 |  num=5 |
#define FP_ILOGB0 /*implementation-defined*/
}}
{{dcl | since=c99 | num=6 |
#define FP_ILOGBNAN /*implementation-defined*/
}}
{{dcl end}}

@1-3@ Extracts the value of the unbiased exponent from the floating-point argument {{tt|arg}}, and returns it as a signed integer value. 
@4@ Type-generic macros: If {{tt|arg}} has type {{c|long double}}, {{tt|ilogbl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|ilogb}} is called. Otherwise, {{tt|ilogbf}} is called.
@5@ Expands to integer constant expression whose value is either {{lc|INT_MIN}} or {{c|-INT_MAX}}.
@6@ Expands to integer constant expression whose value is either {{lc|INT_MIN}} or {{c|+INT_MAX}}.

Formally, the unbiased exponent is the integral part of {{math|log{{su|b=r}}{{!}}arg{{!}}}} as a signed integral value, for non-zero arg, where {{tt|r}} is {{lc|FLT_RADIX}}.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the unbiased exponent of {{tt|arg}} is returned as a signed int value.

If {{tt|arg}} is zero, {{lc|FP_ILOGB0}} is returned.

If {{tt|arg}} is infinite, {{lc|INT_MAX}} is returned.

If {{tt|arg}} is a NaN, {{lc|FP_ILOGBNAN}} is returned.

If the correct result is greater than {{lc|INT_MAX}} or smaller than {{lc|INT_MIN}}, the return value is unspecified.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

A domain error or range error may occur if {{tt|arg}} is zero, infinite, or NaN.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the correct result is greater than {{lc|INT_MAX}} or smaller than {{lc|INT_MIN}}, {{lc|FE_INVALID}} is raised.
* If {{tt|arg}} is ±0, ±∞, or NaN, {{lc|FE_INVALID}} is raised.
* In all other cases, the result is exact ({{lc|FE_INEXACT}} is never raised) and [[c/numeric/fenv/FE_round|the current rounding mode]] is ignored

===Notes===
If {{tt|arg}} is not zero, infinite, or NaN, the value returned is exactly equivalent to {{c|(int)logb(arg)}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/ilogb.html POSIX requires] that a domain error occurs if {{tt|arg}} is zero, infinite, NaN, or if the correct result is outside of the range of {{c|int}}.

POSIX also requires that, on XSI-conformant systems, the value returned when the correct result is greater than {{lc|INT_MAX}} is {{lc|INT_MAX}} and the value returned when the correct result is less than {{lc|INT_MIN}} is {{lc|INT_MIN}}.

The correct result can be represented as {{c|int}} on all known implementations. For overflow to occur, {{lc|INT_MAX}} must be less than {{c|LDBL_MAX_EXP*log2(FLT_RADIX)}} or {{lc|INT_MIN}} must be greater than {{c|LDBL_MIN_EXP-LDBL_MANT_DIG)*log2(FLT_RADIX)}}.

The value of the exponent returned by {{tt|std::ilogb}} is always 1 less than the exponent retuned by {{lc|frexp}} because of the different normalization requirements: for the exponent {{tt|e}} returned by {{tt|ilogb}}, {{math|{{!}}arg*r{{su|p=-e}}{{!}}}} is between 1 and {{tt|r}} (typically between {{c|1}} and {{c|2}}), but for the exponent {{tt|e}} returned by {{lc|frexp}}, {{math|{{!}}arg*2{{su|p=-e}}{{!}}}} is between {{c|0.5}} and {{c|1}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    printf(&quot;Given the number %.2f or %a in hex,\n&quot;, f, f);

    double f3;
    double f2 = modf(f, &amp;f3);
    printf(&quot;modf() makes %.0f + %.2f\n&quot;, f3, f2);

    int i;
    f2 = frexp(f, &amp;i);
    printf(&quot;frexp() makes %f * 2^%d\n&quot;, f2, i);

    i = ilogb(f);
    printf(&quot;logb()/ilogb() make %f * %d^%d\n&quot;, f/scalbn(1.0, i), FLT_RADIX, i);

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;ilogb(0) = %d\n&quot;, ilogb(0));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
ilogb(0) = -2147483648
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc frexp}}
{{dsc inc | c/numeric/math/dsc logb}}
{{dsc inc | c/numeric/math/dsc scalbn}}
{{dsc see cpp | cpp/numeric/math/ilogb}}
{{dsc end}}

[[de:c/numeric/math/ilogb]]
[[es:c/numeric/math/ilogb]]
[[fr:c/numeric/math/ilogb]]
[[it:c/numeric/math/ilogb]]
[[ja:c/numeric/math/ilogb]]
[[pt:c/numeric/math/ilogb]]
[[ru:c/numeric/math/ilogb]]
[[zh:c/numeric/math/ilogb]]</text>
      <sha1>4fkn84i47aaisj67w9i13cdpcde8w92</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isfinite</title>
    <ns>0</ns>
    <id>6257</id>
    <revision>
      <id>70147</id>
      <parentid>69271</parentid>
      <timestamp>2014-05-10T21:10:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1617">{{c/title|isfinite}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isfinite(arg) /* implementation defined */
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} has finite value i.e. it is normal, subnormal or zero, but not infinite or {{tt|NAN}}. The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
Nonzero integral value if {{tt|arg}} has finite value, {{c|0}} otherwise.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;isfinite(NAN)         = %d\n&quot;, isfinite(NAN));
    printf(&quot;isfinite(INFINITY)    = %d\n&quot;, isfinite(INFINITY));
    printf(&quot;isfinite(0.0)         = %d\n&quot;, isfinite(0.0));
    printf(&quot;isfinite(DBL_MIN/2.0) = %d\n&quot;, isfinite(DBL_MIN/2.0));
    printf(&quot;isfinite(1.0)         = %d\n&quot;, isfinite(1.0));
 
    return 0;
}
 | p=true
 | output=
isfinite(NAN)         = 0
isfinite(INFINITY)    = 0
isfinite(0.0)         = 1
isfinite(DBL_MIN/2.0) = 1
isfinite(1.0)         = 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc inc | c/numeric/math/dsc isnormal}}
{{dsc see cpp | cpp/numeric/math/isfinite}}
{{dsc end}}

[[de:c/numeric/math/isfinite]]
[[es:c/numeric/math/isfinite]]
[[fr:c/numeric/math/isfinite]]
[[it:c/numeric/math/isfinite]]
[[ja:c/numeric/math/isfinite]]
[[pt:c/numeric/math/isfinite]]
[[ru:c/numeric/math/isfinite]]
[[zh:c/numeric/math/isfinite]]</text>
      <sha1>78hbx659xhn4jeiyut97m6u8psvcjl3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isgreater</title>
    <ns>0</ns>
    <id>13542</id>
    <revision>
      <id>70905</id>
      <parentid>70438</parentid>
      <timestamp>2014-06-02T11:24:03Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example; note about exception from 7.12.14.1 of n1570.</comment>
      <text xml:space="preserve" bytes="1603">{{c/title|isgreater}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isgreater(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is greater than the floating-point number ({{tt|y}}), without setting floating-point exceptions. 

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if {{c|x &gt; y}}, {{c|0}} otherwise

===Notes===
The built-in {{c|operator&gt;}} for floating-point numbers may set {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|operator&gt;}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;isgreater(2.0,1.0)      = %d\n&quot;, isgreater(2.0,1.0));
    printf(&quot;isgreater(1.0,2.0)      = %d\n&quot;, isgreater(1.0,2.0));
    printf(&quot;isgreater(INFINITY,1.0) = %d\n&quot;, isgreater(INFINITY,1.0));
    printf(&quot;isgreater(1.0,NAN)      = %d\n&quot;, isgreater(1.0,NAN));
 
    return 0;
}
 | p=true
 | output=
isgreater(2.0,1.0)      = 1
isgreater(1.0,2.0)      = 0
isgreater(INFINITY,1.0) = 1
isgreater(1.0,NAN)      = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isless}}
{{dsc see cpp | cpp/numeric/math/isgreater}}
{{dsc end}}

[[de:c/numeric/math/isgreater]]
[[es:c/numeric/math/isgreater]]
[[fr:c/numeric/math/isgreater]]
[[it:c/numeric/math/isgreater]]
[[ja:c/numeric/math/isgreater]]
[[pt:c/numeric/math/isgreater]]
[[ru:c/numeric/math/isgreater]]
[[zh:c/numeric/math/isgreater]]</text>
      <sha1>ncnrjnqq6y2fbqooesyrk0qbpmhm2dy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isgreaterequal</title>
    <ns>0</ns>
    <id>13543</id>
    <revision>
      <id>70906</id>
      <parentid>70446</parentid>
      <timestamp>2014-06-02T11:32:20Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example; note about exception from 7.12.14.2 of n1570.</comment>
      <text xml:space="preserve" bytes="1853">{{c/title|isgreaterequal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isgreaterequal(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is greater than or equal to the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if {{c|1=x &gt;= y}}, {{c|0}} otherwise

===Notes===
The built-in {{c|1=operator&gt;=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|1=operator&gt;=}}.


===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;isgreaterequal(2.0,1.0)      = %d\n&quot;, isgreaterequal(2.0,1.0));
    printf(&quot;isgreaterequal(1.0,2.0)      = %d\n&quot;, isgreaterequal(1.0,2.0));
    printf(&quot;isgreaterequal(1.0,1.0)      = %d\n&quot;, isgreaterequal(1.0,1.0));
    printf(&quot;isgreaterequal(INFINITY,1.0) = %d\n&quot;, isgreaterequal(INFINITY,1.0));
    printf(&quot;isgreaterequal(1.0,NAN)      = %d\n&quot;, isgreaterequal(1.0,NAN));
 
    return 0;
}
 | p=true
 | output=
isgreaterequal(2.0,1.0)      = 1
isgreaterequal(1.0,2.0)      = 0
isgreaterequal(1.0,1.0)      = 1
isgreaterequal(INFINITY,1.0) = 1
isgreaterequal(1.0,NAN)      = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc islessequal}}
{{dsc see cpp | cpp/numeric/math/isgreaterequal}}
{{dsc end}}

[[de:c/numeric/math/isgreaterequal]]
[[es:c/numeric/math/isgreaterequal]]
[[fr:c/numeric/math/isgreaterequal]]
[[it:c/numeric/math/isgreaterequal]]
[[ja:c/numeric/math/isgreaterequal]]
[[pt:c/numeric/math/isgreaterequal]]
[[ru:c/numeric/math/isgreaterequal]]
[[zh:c/numeric/math/isgreaterequal]]</text>
      <sha1>f5xybrr8tybyoum12ts2hsv18i8od0t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isinf</title>
    <ns>0</ns>
    <id>6256</id>
    <revision>
      <id>70148</id>
      <parentid>69272</parentid>
      <timestamp>2014-05-10T21:27:27Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1484">{{c/title|isinf}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isinf(arg) /* implementation defined */
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is positive or negative infinity. The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
Nonzero integral value if {{tt|arg}} is infinite, {{c|0}} otherwise.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;isinf(NAN)         = %d\n&quot;, isinf(NAN));
    printf(&quot;isinf(INFINITY)    = %d\n&quot;, isinf(INFINITY));
    printf(&quot;isinf(0.0)         = %d\n&quot;, isinf(0.0));
    printf(&quot;isinf(DBL_MIN/2.0) = %d\n&quot;, isinf(DBL_MIN/2.0));
    printf(&quot;isinf(1.0)         = %d\n&quot;, isinf(1.0));
 
    return 0;
}
 | p=true
 | output=
isinf(NAN)         = 0
isinf(INFINITY)    = 1
isinf(0.0)         = 0
isinf(DBL_MIN/2.0) = 0
isinf(1.0)         = 0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isfinite}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc inc | c/numeric/math/dsc isnormal}}
{{dsc see cpp | cpp/numeric/math/isinf}}
{{dsc end}}

[[de:c/numeric/math/isinf]]
[[es:c/numeric/math/isinf]]
[[fr:c/numeric/math/isinf]]
[[it:c/numeric/math/isinf]]
[[ja:c/numeric/math/isinf]]
[[pt:c/numeric/math/isinf]]
[[ru:c/numeric/math/isinf]]
[[zh:c/numeric/math/isinf]]</text>
      <sha1>07m68bf7nqfkstayx47f2m1ws7da6uk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isless</title>
    <ns>0</ns>
    <id>13544</id>
    <revision>
      <id>70907</id>
      <parentid>70447</parentid>
      <timestamp>2014-06-02T11:43:22Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example; note about exception from 7.12.14.3 of n1570.</comment>
      <text xml:space="preserve" bytes="1534">{{c/title|isless}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isless(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if {{c|x &lt; y}}, {{c|0}} otherwise

===Notes===
The built-in {{c|operator&lt;}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|operator&lt;}}.


===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;isless(2.0,1.0)      = %d\n&quot;, isless(2.0,1.0));
    printf(&quot;isless(1.0,2.0)      = %d\n&quot;, isless(1.0,2.0));
    printf(&quot;isless(INFINITY,1.0) = %d\n&quot;, isless(INFINITY,1.0));
    printf(&quot;isless(1.0,NAN)      = %d\n&quot;, isless(1.0,NAN));
 
    return 0;
}
 | p=true
 | output=
isless(2.0,1.0)      = 0
isless(1.0,2.0)      = 1
isless(INFINITY,1.0) = 0
isless(1.0,NAN)      = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isgreater}}
{{dsc see cpp | cpp/numeric/math/isless}}
{{dsc end}}

[[de:c/numeric/math/isless]]
[[es:c/numeric/math/isless]]
[[fr:c/numeric/math/isless]]
[[it:c/numeric/math/isless]]
[[ja:c/numeric/math/isless]]
[[pt:c/numeric/math/isless]]
[[ru:c/numeric/math/isless]]
[[zh:c/numeric/math/isless]]</text>
      <sha1>myzyu7tv5gryzljsnl7oc69v48z2t43</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/islessequal</title>
    <ns>0</ns>
    <id>13545</id>
    <revision>
      <id>70908</id>
      <parentid>70445</parentid>
      <timestamp>2014-06-02T11:49:29Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example; note about exception from 7.12.14.4 of n1570.</comment>
      <text xml:space="preserve" bytes="1775">{{c/title|islessequal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define islessequal(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than or equal to the floating-point number {{tt|y}}, without setting floating-point exceptions. 

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if {{c|1=x &lt;= y}}, {{c|0}} otherwise

===Notes===
The built-in {{c|1=operator&lt;=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|1=operator&lt;=}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;islessequal(2.0,1.0)      = %d\n&quot;, islessequal(2.0,1.0));
    printf(&quot;islessequal(1.0,2.0)      = %d\n&quot;, islessequal(1.0,2.0));
    printf(&quot;islessequal(1.0,1.0)      = %d\n&quot;, islessequal(1.0,1.0));
    printf(&quot;islessequal(INFINITY,1.0) = %d\n&quot;, islessequal(INFINITY,1.0));
    printf(&quot;islessequal(1.0,NAN)      = %d\n&quot;, islessequal(1.0,NAN));
 
    return 0;
}
 | p=true
 | output=
islessequal(2.0,1.0)      = 0
islessequal(1.0,2.0)      = 1
islessequal(1.0,1.0)      = 1
islessequal(INFINITY,1.0) = 0
islessequal(1.0,NAN)      = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isgreaterequal}}
{{dsc see cpp | cpp/numeric/math/islessequal}}
{{dsc end}}

[[de:c/numeric/math/islessequal]]
[[es:c/numeric/math/islessequal]]
[[fr:c/numeric/math/islessequal]]
[[it:c/numeric/math/islessequal]]
[[ja:c/numeric/math/islessequal]]
[[pt:c/numeric/math/islessequal]]
[[ru:c/numeric/math/islessequal]]
[[zh:c/numeric/math/islessequal]]</text>
      <sha1>8uw4xiqhb9w24o2sauj9pa9iw1tg5r6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/islessgreater</title>
    <ns>0</ns>
    <id>13546</id>
    <revision>
      <id>70909</id>
      <parentid>70448</parentid>
      <timestamp>2014-06-02T11:59:29Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example; note about exception from 7.12.14.5 of n1570.</comment>
      <text xml:space="preserve" bytes="1957">{{c/title|islessgreater}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define islessgreater(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than or greater than the floating-point number {{tt|y}}, without setting floating-point exceptions. 

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if {{c|x &lt; y {{!!}} x &gt; y}}, {{c|0}} otherwise

===Notes===
The built-in {{c|operator&lt;}} and {{c|operator&gt;}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of the expression {{c|x &lt; y {{!!}} x &gt; y}}. The macro does not evaluate x and y twice.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;islessgreater(2.0,1.0)      = %d\n&quot;, islessgreater(2.0,1.0));
    printf(&quot;islessgreater(1.0,2.0)      = %d\n&quot;, islessgreater(1.0,2.0));
    printf(&quot;islessgreater(1.0,1.0)      = %d\n&quot;, islessgreater(1.0,1.0));
    printf(&quot;islessgreater(INFINITY,1.0) = %d\n&quot;, islessgreater(INFINITY,1.0));
    printf(&quot;islessgreater(1.0,NAN)      = %d\n&quot;, islessgreater(1.0,NAN));
 
    return 0;
}
 | p=true
 | output=
islessgreater(2.0,1.0)      = 1
islessgreater(1.0,2.0)      = 1
islessgreater(1.0,1.0)      = 0
islessgreater(INFINITY,1.0) = 1
islessgreater(1.0,NAN)      = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isless}}
{{dsc inc | c/numeric/math/dsc isgreater}}
{{dsc see cpp | cpp/numeric/math/islessgreater}}
{{dsc end}}

[[de:c/numeric/math/islessgreater]]
[[es:c/numeric/math/islessgreater]]
[[fr:c/numeric/math/islessgreater]]
[[it:c/numeric/math/islessgreater]]
[[ja:c/numeric/math/islessgreater]]
[[pt:c/numeric/math/islessgreater]]
[[ru:c/numeric/math/islessgreater]]
[[zh:c/numeric/math/islessgreater]]</text>
      <sha1>anojo5mzzlitw67aeoah1wd6flpdxrl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isnan</title>
    <ns>0</ns>
    <id>6255</id>
    <revision>
      <id>70469</id>
      <parentid>70149</parentid>
      <timestamp>2014-05-23T22:28:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to isunordered (C99)</comment>
      <text xml:space="preserve" bytes="1526">{{c/title|isnan}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isnan(arg) /* implementation defined */
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is not-a-number ({{tt|NaN}}). The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
Nonzero integral value if {{tt|arg}} is {{c|NaN}}, {{c|0}} otherwise.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;isnan(NAN)         = %d\n&quot;, isnan(NAN));
    printf(&quot;isnan(INFINITY)    = %d\n&quot;, isnan(INFINITY));
    printf(&quot;isnan(0.0)         = %d\n&quot;, isnan(0.0));
    printf(&quot;isnan(DBL_MIN/2.0) = %d\n&quot;, isnan(DBL_MIN/2.0));
    printf(&quot;isnan(1.0)         = %d\n&quot;, isnan(1.0));
 
    return 0;
}
 | p=true
 | output=
isnan(NAN)         = 1
isnan(INFINITY)    = 0
isnan(0.0)         = 0
isnan(DBL_MIN/2.0) = 0
isnan(1.0)         = 0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isfinite}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc isnormal}}
{{dsc inc | c/numeric/math/dsc isunordered}}
{{dsc see cpp | cpp/numeric/math/isnan}}
{{dsc end}}

[[de:c/numeric/math/isnan]]
[[es:c/numeric/math/isnan]]
[[fr:c/numeric/math/isnan]]
[[it:c/numeric/math/isnan]]
[[ja:c/numeric/math/isnan]]
[[pt:c/numeric/math/isnan]]
[[ru:c/numeric/math/isnan]]
[[zh:c/numeric/math/isnan]]</text>
      <sha1>1shpq108bc9mx32nnc2xlglruanm5bz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isnormal</title>
    <ns>0</ns>
    <id>6254</id>
    <revision>
      <id>70150</id>
      <parentid>69274</parentid>
      <timestamp>2014-05-10T21:29:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1593">{{c/title|isnormal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isnormal(arg) /* implementation defined */
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is normal, i.e. is neither zero, subnormal, infinite, nor {{tt|NaN}}. The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
Nonzero integral value if {{tt|arg}} is normal, {{c|0}} otherwise.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;isnormal(NAN)         = %d\n&quot;, isnormal(NAN));
    printf(&quot;isnormal(INFINITY)    = %d\n&quot;, isnormal(INFINITY));
    printf(&quot;isnormal(0.0)         = %d\n&quot;, isnormal(0.0));
    printf(&quot;isnormal(DBL_MIN/2.0) = %d\n&quot;, isnormal(DBL_MIN/2.0));
    printf(&quot;isnormal(1.0)         = %d\n&quot;, isnormal(1.0));
 
    return 0;
}
 | p=true
 | output=
isnormal(NAN)         = 0
isnormal(INFINITY)    = 0
isnormal(0.0)         = 0
isnormal(DBL_MIN/2.0) = 0
isnormal(1.0)         = 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isfinite}}
{{dsc inc | c/numeric/math/dsc isinf}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc see cpp | cpp/numeric/math/isnormal}}
{{dsc end}}

[[de:c/numeric/math/isnormal]]
[[es:c/numeric/math/isnormal]]
[[fr:c/numeric/math/isnormal]]
[[it:c/numeric/math/isnormal]]
[[ja:c/numeric/math/isnormal]]
[[pt:c/numeric/math/isnormal]]
[[ru:c/numeric/math/isnormal]]
[[zh:c/numeric/math/isnormal]]</text>
      <sha1>p32kwmybn7nmql4frqffefomh3nhiou</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/isunordered</title>
    <ns>0</ns>
    <id>13547</id>
    <revision>
      <id>70866</id>
      <parentid>70449</parentid>
      <timestamp>2014-05-31T12:52:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1499">{{c/title|isunordered}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define isunordered(x, y) /* implementation defined */
}}
{{dcl end}}

Determines if the floating point numbers {{tt|x}} and {{tt|y}} are unordered, that is, one or both are NaN and thus cannot be meaningfully compared with each other.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

Nonzero integral value if either {{tt|x}} or {{tt|y}} is NaN, {{c|0}} otherwise


===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    printf(&quot;isunordered(NAN,1.0) = %d\n&quot;, isunordered(NAN,1.0));
    printf(&quot;isunordered(1.0,NAN) = %d\n&quot;, isunordered(1.0,NAN));
    printf(&quot;isunordered(NAN,NAN) = %d\n&quot;, isunordered(NAN,NAN));
    printf(&quot;isunordered(1.0,0.0) = %d\n&quot;, isunordered(1.0,0.0));
 
    return 0;
}
 | p=true
 | output=
isunordered(NAN,1.0) = 1
isunordered(1.0,NAN) = 1
isunordered(NAN,NAN) = 1
isunordered(1.0,0.0) = 0
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fpclassify}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc see cpp | cpp/numeric/math/isunordered}}
{{dsc end}}

[[de:c/numeric/math/isunordered]]
[[es:c/numeric/math/isunordered]]
[[fr:c/numeric/math/isunordered]]
[[it:c/numeric/math/isunordered]]
[[ja:c/numeric/math/isunordered]]
[[pt:c/numeric/math/isunordered]]
[[ru:c/numeric/math/isunordered]]
[[zh:c/numeric/math/isunordered]]</text>
      <sha1>3noc48225ct4pd612s3b13kdxslijx5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/labs</title>
    <ns>0</ns>
    <id>6502</id>
    <redirect title="c/numeric/math/abs" />
    <revision>
      <id>25674</id>
      <timestamp>2012-04-23T21:01:28Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/abs]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/ldexp</title>
    <ns>0</ns>
    <id>6265</id>
    <revision>
      <id>72073</id>
      <parentid>69567</parentid>
      <timestamp>2014-07-11T21:44:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="3745">{{c/title|ldexp | ldexpf | ldexpl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       ldexpf( float arg, int exp );
}}
{{dcl |num=2|
double      ldexp( double arg, int exp );
}}
{{dcl | since=c99 |num=3|
long double ldexpl( long double arg, int exp );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |num=4|
#define ldexp( arg, exp )
}}
{{dcl end}}

@1-3@ Multiplies a floating point value {{tt|arg}} by the number 2 raised to the {{tt|exp}} power.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|ldexpl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|ldexp}} is called. Otherwise, {{tt|ldexpf}} is called, respectively.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par | exp | integer value}}
{{par end}}

===Return value===
If no errors occur, {{tt|arg}} multiplied by 2 to the power of {{tt|exp}} ({{math|arg&amp;times;2{{su|p=exp}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* Unless a range error occurs, {{lc|FE_INEXACT}} is never raised (the result is exact)
* Unless a range error occurs, the [[c/numeric/fenv/FE_round|current rounding mode]] is ignored
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|exp}} is 0, then {{tt|arg}} is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned

===Notes===
On binary systems (where {{lc|FLT_RADIX}} is {{tt|2}}), {{tt|ldexp}} is equivalent to {{lc|scalbn}}.

The function {{tt|ldexp}} (&quot;load exponent&quot;), together with its dual, {{lc|frexp}}, can be used to manipulate the representation of a floating-point number without direct bit manipulations.

On many implementations, {{tt|ldexp}} is less efficient than multiplication or division by a power of two using arithmetic operators.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;ldexp(7, -4) = %f\n&quot;, ldexp(7, -4));
    printf(&quot;ldexp(1, -1074) = %g (minimum positive subnormal double)\n&quot;,
            ldexp(1, -1074));
    printf(&quot;ldexp(nextafter(1,0), 1024) = %g (largest finite double)\n&quot;,
            ldexp(nextafter(1,0), 1024));
    // special values
    printf(&quot;ldexp(-0, 10) = %f\n&quot;, ldexp(-0.0, 10));
    printf(&quot;ldexp(-Inf, -1) = %f\n&quot;, ldexp(-INFINITY, -1));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;ldexp(1, 1024) = %f\n&quot;, ldexp(1, 1024));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
ldexp(7, -4) = 0.437500
ldexp(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
ldexp(-0, 10) = -0.000000
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc frexp}}
{{dsc inc | c/numeric/math/dsc scalbn}}
{{dsc see cpp | cpp/numeric/math/ldexp}}
{{dsc end}}

[[de:c/numeric/math/ldexp]]
[[es:c/numeric/math/ldexp]]
[[fr:c/numeric/math/ldexp]]
[[it:c/numeric/math/ldexp]]
[[ja:c/numeric/math/ldexp]]
[[pt:c/numeric/math/ldexp]]
[[ru:c/numeric/math/ldexp]]
[[zh:c/numeric/math/ldexp]]</text>
      <sha1>air6gvbynbx3xuddchzg1vhlheie8qx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/ldiv</title>
    <ns>0</ns>
    <id>6504</id>
    <redirect title="c/numeric/math/div" />
    <revision>
      <id>25676</id>
      <timestamp>2012-04-23T21:01:35Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/div]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/lgamma</title>
    <ns>0</ns>
    <id>6311</id>
    <revision>
      <id>71180</id>
      <parentid>69538</parentid>
      <timestamp>2014-06-07T20:20:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="4083">{{c/title|lgamma, lgammaf, lgammal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       lgammaf( float arg );
}}
{{dcl | since=c99 |num=2|
double      lgamma( double arg );
}}
{{dcl | since=c99 |num=3|
long double lgammal( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define lgamma( arg )
}}
{{dcl end}}

@1-3@ Computes the natural logarithm of the absolute value of the [[enwiki:Gamma function|gamma function]] of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|lgammal}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|lgamma}} is called. Otherwise, {{tt|lgammaf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the value of the logarithm of the gamma function of {{tt|arg}}, that is {{math|log{{su|b=e}}{{!}}{{minteg|0|∞|''t''{{su|p=arg-1}} {{mexp|-t}} d''t''}}{{!}}}}, is returned.

If a pole error occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If {{tt|arg}} is zero or is an integer less than zero, a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is 1, +0 is returned
* If the argument is 2, +0 is returned
* If the argument is ±0, +∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is a negative integer, +∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is ±∞, +∞ is returned.
* If the argument is NaN, NaN is returned

===Notes===
If {{tt|arg}} is a natural number, {{c|lgamma(arg)}} is the logarithm of the factorial of {{tt|arg-1}}.

The [http://pubs.opengroup.org/onlinepubs/9699919799/functions/lgamma.html POSIX version of lgamma] is not thread-safe: each execution of the function stores the sign of the gamma function of {{tt|arg}} in the static external variable {{tt|signgam}}. Some implementations provide {{tt|lgamma_r}}, which takes a pointer to user-provided storage for singgam as the second parameter, and is thread-safe.

There is a non-standard function named {{tt|gamma}} in various implementations, but its definition is inconsistent. For example, glibc and 4.2BSD version of {{tt|gamma}} executes {{tt|lgamma}}, but 4.4BSD version of {{tt|gamma}} executes {{tt|tgamma}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;lgamma(10) = %f, log(9!)=%f\n&quot;, lgamma(10), log(2*3*4*5*6*7*8*9));
    double pi = acos(-1);
    printf(&quot;lgamma(0.5) = %f, log(sqrt(pi)) = %f\n&quot;, log(sqrt(pi)), lgamma(0.5));
    // special values
    printf(&quot;lgamma(1) = %f\n&quot;, lgamma(1));
    printf(&quot;lgamma(+Inf) = %f\n&quot;, lgamma(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;lgamma(0) = %f\n&quot;, lgamma(0));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
lgamma(10) = 12.801827, log(9!)=12.801827
lgamma(0.5) = 0.572365, log(sqrt(pi)) = 0.572365
lgamma(1) = 0.000000
lgamma(+Inf) = inf
lgamma(0) = inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc tgamma}}
{{dsc see cpp | cpp/numeric/math/lgamma}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/LogGammaFunction.html Weisstein, Eric W. &quot;Log Gamma Function.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/lgamma]]
[[es:c/numeric/math/lgamma]]
[[fr:c/numeric/math/lgamma]]
[[it:c/numeric/math/lgamma]]
[[ja:c/numeric/math/lgamma]]
[[pt:c/numeric/math/lgamma]]
[[ru:c/numeric/math/lgamma]]
[[zh:c/numeric/math/lgamma]]</text>
      <sha1>r5yer5dv11p6lp134ucx35gxc9xqnfg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/llabs</title>
    <ns>0</ns>
    <id>6503</id>
    <redirect title="c/numeric/math/abs" />
    <revision>
      <id>25675</id>
      <timestamp>2012-04-23T21:01:30Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/abs]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/lldiv</title>
    <ns>0</ns>
    <id>6505</id>
    <redirect title="c/numeric/math/div" />
    <revision>
      <id>25677</id>
      <timestamp>2012-04-23T21:01:36Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/div]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/llrint</title>
    <ns>0</ns>
    <id>6511</id>
    <redirect title="c/numeric/math/rint" />
    <revision>
      <id>25683</id>
      <timestamp>2012-04-23T21:01:55Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/rint]]</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/numeric/math/rint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/llround</title>
    <ns>0</ns>
    <id>6509</id>
    <redirect title="c/numeric/math/round" />
    <revision>
      <id>25681</id>
      <timestamp>2012-04-23T21:01:48Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/round]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/numeric/math/round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/log</title>
    <ns>0</ns>
    <id>6279</id>
    <revision>
      <id>70765</id>
      <parentid>70703</parentid>
      <timestamp>2014-05-30T03:12:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath notes</comment>
      <text xml:space="preserve" bytes="3022">{{c/title|log, logf, logl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       logf( float arg );
}}
{{dcl |num=2|
double      log( double arg );
}}
{{dcl | since=c99 |num=3|
long double logl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define log( arg )
}}
{{dcl end}}

@1-3@ Computes the natural (base ''e'') logarithm of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|logl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|log}} is called. Otherwise, {{tt|logf}} is called. If {{tt|arg}} is complex, then the macro invokes the corresponding complex function ({{c|clogf}}, {{c|clog}}, {{c|clogl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the natural (base-''e'') logarithm of {{tt|arg}} ({{math|ln(arg)}} or {{math|log{{su|b=e}}(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;log(1) = %f\n&quot;, log(1));
    printf(&quot;base-5 logarithm of 125 = %f\n&quot;, log(125)/log(5));
    // special values
    printf(&quot;log(1) = %f\n&quot;, log(1));
    printf(&quot;log(+Inf) = %f\n&quot;, log(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;log(0) = %f\n&quot;, log(0));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
| output=
log(1) = 0.000000
base-5 logarithm of 125 = 3.000000
log(1) = 0.000000
log(+Inf) = inf
log(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc log10}}
{{dsc inc | c/numeric/math/dsc log2}}
{{dsc inc | c/numeric/math/dsc log1p}}
{{dsc inc | c/numeric/math/dsc exp}}
{{dsc inc | c/numeric/complex/dsc clog}}
{{dsc see cpp | cpp/numeric/math/log}}
{{dsc end}}

[[de:c/numeric/math/log]]
[[es:c/numeric/math/log]]
[[fr:c/numeric/math/log]]
[[it:c/numeric/math/log]]
[[ja:c/numeric/math/log]]
[[pt:c/numeric/math/log]]
[[ru:c/numeric/math/log]]
[[zh:c/numeric/math/log]]</text>
      <sha1>srfayz4icmys63iyqq6f95xzxh5cai0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/log10</title>
    <ns>0</ns>
    <id>6280</id>
    <revision>
      <id>71149</id>
      <parentid>70632</parentid>
      <timestamp>2014-06-07T04:16:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="2983">{{c/title|log10, log10f, log10l}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       log10f( float arg );
}}
{{dcl |num=2|
double      log10( double arg );
}}
{{dcl | since=c99 |num=3|
long double log10l( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define log10( arg )
}}
{{dcl end}}

@1-3@ Computes the common (base-''10'') logarithm of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|log10l}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|log10}} is called. Otherwise, {{tt|log10f}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the common (base-''10'') logarithm of {{tt|arg}} ({{math|log{{su|b=10}}(arg)}} or {{math|lg(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;log10(1000) = %f\n&quot;, log10(1000));
    printf(&quot;log10(0.001) = %f\n&quot;, log10(0.001));
    printf(&quot;base-5 logarithm of 125 = %f\n&quot;, log10(125)/log10(5));
    // special values
    printf(&quot;log10(1) = %f\n&quot;, log10(1));
    printf(&quot;log10(+Inf) = %f\n&quot;, log10(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;log10(0) = %f\n&quot;, log10(0));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
log10(1000) = 3.000000
log10(0.001) = -3.000000
base-5 logarithm of 125 = 3.000000
log10(1) = 0.000000
log10(+Inf) = inf
log10(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc inc | c/numeric/math/dsc log2}}
{{dsc inc | c/numeric/math/dsc log1p}}
{{dsc see cpp | cpp/numeric/math/log10}}
{{dsc end}}

[[de:c/numeric/math/log10]]
[[es:c/numeric/math/log10]]
[[fr:c/numeric/math/log10]]
[[it:c/numeric/math/log10]]
[[ja:c/numeric/math/log10]]
[[pt:c/numeric/math/log10]]
[[ru:c/numeric/math/log10]]
[[zh:c/numeric/math/log10]]</text>
      <sha1>48f3zpbmacq6ym6pwgasv19l23j50vj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/log1p</title>
    <ns>0</ns>
    <id>6281</id>
    <revision>
      <id>70928</id>
      <parentid>70925</parentid>
      <timestamp>2014-06-03T15:14:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-std:</comment>
      <text xml:space="preserve" bytes="3686">{{c/title|log1p, log1pf, log1pl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       log1pf( float arg );
}}
{{dcl | since=c99 |num=2|
double      log1p( double arg );
}}
{{dcl | since=c99 |num=3|
long double log1pl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define log1p( arg )
}}
{{dcl end}}

@1-3@ Computes the natural (base {{c|e}}) logarithm of {{c|1+arg}}. This function is more precise than the expression {{c|log(1+arg)}} if {{tt|arg}} is close to zero.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|log1pl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|log1p}} is called. Otherwise, {{tt|log1pf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur {{math|ln(1+arg)}} is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than {{math|-1}}.

Pole error may occur if {{tt|arg}} is {{math|-1}}.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If the argument is -1, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is less than -1, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
The functions {{lc|expm1}} and {{tt|log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1+x){{su|p=n}}-1}} can be expressed as {{c|expm1(n * log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;log1p(0) = %f\n&quot;, log1p(0));
    printf(&quot;Interest earned in 2 days on on $100, compounded daily at 1%\n&quot;
           &quot; on a 30/360 calendar = %f\n&quot;,
           100*expm1(2*log1p(0.01/360)));
    printf(&quot;log(1+1e-16) = %g, but log1p(1e-16) = %g\n&quot;,
           log(1+1e-16), log1p(1e-16));
    // special values
    printf(&quot;log1p(-0) = %f\n&quot;, log1p(-0.0));
    printf(&quot;log1p(+Inf) = %f\n&quot;, log1p(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;log1p(-1) = %f\n&quot;, log1p(-1));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
log1p(0) = 0.000000
Interest earned in 2 days on on $100, compounded daily at 1
 on a 30/360 calendar = 0.005556
log(1+1e-16) = 0, but log1p(1e-16) = 1e-16
log1p(-0) = -0.000000
log1p(+Inf) = Inf
log1p(-1) = -Inf
    errno == ERANGE: Result too large
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc inc | c/numeric/math/dsc log10}}
{{dsc inc | c/numeric/math/dsc log2}}
{{dsc inc | c/numeric/math/dsc expm1}}
{{dsc see cpp | cpp/numeric/math/log1p}}
{{dsc end}}

[[de:c/numeric/math/log1p]]
[[es:c/numeric/math/log1p]]
[[fr:c/numeric/math/log1p]]
[[it:c/numeric/math/log1p]]
[[ja:c/numeric/math/log1p]]
[[pt:c/numeric/math/log1p]]
[[ru:c/numeric/math/log1p]]
[[zh:c/numeric/math/log1p]]</text>
      <sha1>mmmi9h6akos7mx0675swacw4qsj0iux</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/log2</title>
    <ns>0</ns>
    <id>6283</id>
    <revision>
      <id>71152</id>
      <parentid>71150</parentid>
      <timestamp>2014-06-07T04:34:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/cpp/c</comment>
      <text xml:space="preserve" bytes="3270">{{c/title|log2, log2f, log2l}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       log2f( float arg );
}}
{{dcl | since=c99 |num=2|
double      log2( double arg );
}}
{{dcl | since=c99 |num=3|
long double log2l( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define log2( arg )
}}
{{dcl end}}

@1-3@ Computes the base {{c|2}} logarithm of {{c|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|log2l}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|log2}} is called. Otherwise, {{tt|log2f}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the base-''2'' logarithm of {{tt|arg}} ({{math|log{{su|b=2}}(arg)}} or {{math|lb(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
For integer {{tt|arg}}, the binary logarithm can be interpreted as the zero-based index of the most significant 1 bit in the input.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;log2(65536) = %f\n&quot;, log2(65536));
    printf(&quot;log2(0.125) = %f\n&quot;, log2(0.125));
    printf(&quot;log2(0x020f) = %f (highest set bit is in position 9)\n&quot;, log2(0x020f));
    printf(&quot;base-5 logarithm of 125 = %f\n&quot;, log2(125)/log2(5));
    // special values
    printf(&quot;log2(1) = %f\n&quot;, log2(1));
    printf(&quot;log2(+Inf) = %f\n&quot;, log2(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;log2(0) = %f\n&quot;, log2(0));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
log2(65536) = 16.000000
log2(0.125) = -3.000000
log2(0x020f) = 9.041659 (highest set bit is in position 9)
base-5 logarithm of 125 = 3.000000
log2(1) = 0.000000
log2(+Inf) = inf
log2(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc log}}
{{dsc inc | c/numeric/math/dsc log10}}
{{dsc inc | c/numeric/math/dsc log1p}}
{{dsc inc | c/numeric/math/dsc exp2}}
{{dsc see cpp | cpp/numeric/math/log2}}
{{dsc end}}

[[de:c/numeric/math/log2]]
[[es:c/numeric/math/log2]]
[[fr:c/numeric/math/log2]]
[[it:c/numeric/math/log2]]
[[ja:c/numeric/math/log2]]
[[pt:c/numeric/math/log2]]
[[ru:c/numeric/math/log2]]
[[zh:c/numeric/math/log2]]</text>
      <sha1>p6xjchrzppviatb64idkjwgugcchoh0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/logb</title>
    <ns>0</ns>
    <id>6261</id>
    <revision>
      <id>72317</id>
      <parentid>70498</parentid>
      <timestamp>2014-08-07T22:26:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="3891">{{c/title|logb|logbf|logbl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1|
float       logbf( float arg );
}}
{{dcl | since=c99 | num=2|
double      logb( double arg );
}}
{{dcl | since=c99 | num=3|
long double logbl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define logb( arg )
}}
{{dcl end}}

@1-3@ Extracts the value of the unbiased radix-independent exponent from the floating-point argument {{tt|arg}}, and returns it as a floating-point value. 
@4@ Type-generic macros: If {{tt|arg}} has type {{c|long double}}, {{tt|logbl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|logb}} is called. Otherwise, {{tt|logbf}} is called.

Formally, the unbiased exponent is the signed integral part of {{math|log{{su|b=r}}{{!}}arg{{!}}}} (returned by this function as a floating-point value), for non-zero arg, where {{tt|r}} is {{lc|FLT_RADIX}}. If {{tt|arg}} is subnormal, it is treated as though it was normalized.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the unbiased exponent of {{tt|arg}} is returned as a signed floating-point value.

If a domain error occurs, an implementation-defined value is returned

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain or range error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|arg}} is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If {{tt|arg}} is ±∞, +∞ is returned
* If {{tt|arg}} is NaN, NaN is returned.
* In all other cases, the result is exact ({{lc|FE_INEXACT}} is never raised) and [[c/numeric/fenv/FE_round|the current rounding mode]] is ignored

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/logb.html POSIX requires] that a pole error occurs if {{tt|arg}} is ±0.

The value of the exponent returned by {{tt|logb}} is always 1 less than the exponent retuned by {{lc|frexp}} because of the different normalization requirements: for the exponent {{tt|e}} returned by {{tt|logb}}, {{math|{{!}}arg*r{{su|p=-e}}{{!}}}} is between 1 and {{tt|r}} (typically between {{c|1}} and {{c|2}}), but for the exponent {{tt|e}} returned by {{lc|frexp}}, {{math|{{!}}arg*2{{su|p=-e}}{{!}}}} is between {{c|0.5}} and {{c|1}}.

===Example===
{{example | Compares different floating-point decomposition functions
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    printf(&quot;Given the number %.2f or %a in hex,\n&quot;, f, f);

    double f3;
    double f2 = modf(f, &amp;f3);
    printf(&quot;modf() makes %.0f + %.2f\n&quot;, f3, f2);

    int i;
    f2 = frexp(f, &amp;i);
    printf(&quot;frexp() makes %f * 2^%d\n&quot;, f2, i);

    i = logb(f);
    printf(&quot;logb()/logb() make %f * %d^%d\n&quot;, f/scalbn(1.0, i), FLT_RADIX, i);

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;logb(0) = %f\n&quot;, logb(0));
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/logb() make 1.928906 * 2^6
logb(0) = -Inf
    FE_DIVBYZERO raised
}}

===See also===

{{dsc begin}}
{{dsc inc | c/numeric/math/dsc frexp}}
{{dsc inc | c/numeric/math/dsc ilogb}}
{{dsc inc | c/numeric/math/dsc scalbn}}
{{dsc see cpp | cpp/numeric/math/logb}}
{{dsc end}}

[[de:c/numeric/math/logb]]
[[es:c/numeric/math/logb]]
[[fr:c/numeric/math/logb]]
[[it:c/numeric/math/logb]]
[[ja:c/numeric/math/logb]]
[[pt:c/numeric/math/logb]]
[[ru:c/numeric/math/logb]]
[[zh:c/numeric/math/logb]]</text>
      <sha1>jtojz04pv0itsxbge3l8hocukfuhx6q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/lrint</title>
    <ns>0</ns>
    <id>6510</id>
    <redirect title="c/numeric/math/rint" />
    <revision>
      <id>25682</id>
      <timestamp>2012-04-23T21:01:51Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/rint]]</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/numeric/math/rint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/lround</title>
    <ns>0</ns>
    <id>6508</id>
    <redirect title="c/numeric/math/round" />
    <revision>
      <id>25680</id>
      <timestamp>2012-04-23T21:01:45Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/round]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/numeric/math/round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/math errhandling</title>
    <ns>0</ns>
    <id>13524</id>
    <revision>
      <id>70433</id>
      <parentid>70256</parentid>
      <timestamp>2014-05-22T15:23:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>inexact result isn't technically a range error</comment>
      <text xml:space="preserve" bytes="4064">{{title|MATH_ERRNO, MATH_ERREXCEPT, math_errhandling}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define MATH_ERRNO        1
}}
{{dcl | since=c99 |
#define MATH_ERREXCEPT    2
}}
{{dcl | since=c99 |
#define math_errhandling  /*implementation defined*/
}}
{{dcl end}}

The macro constant {{tt|math_errhandling}} expands to an expression of type {{c|int}} that is either equal to {{tt|MATH_ERRNO}}, or equal to {{tt|MATH_ERREXCEPT}}, or equal to their bitwise OR ({{c|MATH_ERRNO {{!}} MATH_ERREXCEPT}}).

The value of {{tt|math_errhandling}} indicates the type of error handling that is performed by the floating-point operators and [[c/numeric/math|functions]]:

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|MATH_ERREXCEPT}} | indicates that floating-point exceptions are used: at least {{lc|FE_DIVBYZERO}}, {{lc|FE_INVALID}}, and {{lc|FE_OVERFLOW}} are defined in {{c|&lt;fenv.h&gt;}}.}}
{{dsc | {{tt|MATH_ERRNO}} | indicates that floating-point operations use the variable {{lc|errno}} to report errors.}}
{{dsc end}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559), {{c|math_errhandling &amp; MATH_ERREXCEPT}} is required to be non-zero.

The following floating-point error conditions are recognized:

{|table class=wikitable
|-
!Condition||Explanation||errno||floating-point exception||Example
|-
|Domain error
|the argument is outside the range in which the operation is mathematically defined (the description of [[c/numeric/math|each function]] lists the required domain errors)
|{{lc|EDOM}}
|{{lc|FE_INVALID}}
|{{c|acos(2)}}
|-
|Pole error
|the mathematical result of the function is exactly infinite or undefined
|{{lc|ERANGE}}
|{{lc|FE_DIVBYZERO}}
|{{c|log(0.0)}}, {{c|1.0/0.0}}
|-
|Range error due to overflow
|the mathematical result is finite, but becomes infinite after rounding, or becomes the largest representable finite value after rounding down
|{{lc|ERANGE}}
|{{lc|FE_OVERFLOW}}
|{{c|pow(DBL_MAX,2)}}
|-
|Range error due to underflow
|the result is non-zero, but becomes zero after rounding, or becomes subnormal with a loss of precision
|{{lc|ERANGE}} or unchanged (implementation-defined)
|{{lc|FE_UNDERFLOW}} or nothing (implementation-defined)
|{{c|DBL_MIN/2}}
|-
|Inexact result
|the result has to be rounded to fit in the destination type
|unchanged
|{{lc|FE_INEXACT}} or nothing (unspecified)
|{{c|sqrt(2)}}, {{c|1.0/10.0}}
|}

===Notes===
Whether {{lc|FE_INEXACT}} is raised by the mathematical library functions is unspecified in general, but may be explicitly specified in the description of the function (e.g. {{lc|rint}} vs {{lc|nearbyint}})

Before C99, floating-point exceptions were not specified, {{c|EDOM}} was required for any domain error, {{c|ERANGE}} was required for overflows and implementation-defined for underflows.

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
#include &lt;fenv.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;MATH_ERRNO is %s\n&quot;, math_errhandling &amp; MATH_ERRNO ? &quot;set&quot; : &quot;not set&quot;);
    printf(&quot;MATH_ERREXCEPT is %s\n&quot;,
           math_errhandling &amp; MATH_ERREXCEPT ? &quot;set&quot; : &quot;not set&quot;);
    feclearexcept(FE_ALL_EXCEPT);
    errno = 0;
    printf(&quot;log(0) = %f\n&quot;, log(0));
    if(errno == ERANGE)
        perror(&quot;errno = ERANGE&quot;);
    if(fetestexcept(FE_DIVBYZERO))
        puts(&quot;FE_DIVBYZERO (pole error) reported&quot;);
}
 | p=true
 | output=
MATH_ERRNO is set
MATH_ERREXCEPT is set
log(0) = -inf
errno = ERANGE: Numerical result out of range
FE_DIVBYZERO (pole error) reported
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc FE_exceptions}}
{{dsc inc | c/error/dsc errno}}
{{dsc see cpp | cpp/numeric/math/math_errhandling}}
{{dsc end}}

[[de:c/numeric/math/math errhandling]]
[[es:c/numeric/math/math errhandling]]
[[fr:c/numeric/math/math errhandling]]
[[it:c/numeric/math/math errhandling]]
[[ja:c/numeric/math/math errhandling]]
[[pt:c/numeric/math/math errhandling]]
[[ru:c/numeric/math/math errhandling]]
[[zh:c/numeric/math/math errhandling]]</text>
      <sha1>5rmlee0fcz1jl2j63om8h0liovxl9li</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/modf</title>
    <ns>0</ns>
    <id>6264</id>
    <revision>
      <id>70143</id>
      <parentid>69661</parentid>
      <timestamp>2014-05-10T20:59:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted return</comment>
      <text xml:space="preserve" bytes="1881">{{c/title|modf}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
float       modff( float arg, float* iptr );
}}
{{dcl |
double      modf( double arg, double* iptr );
}}
{{dcl | since=c99 |
long double modfl( long double arg, long double* iptr );
}}
{{dcl end}}

Decomposes given floating point value {{tt|arg}} into integral and fractional parts, each having the same type and sign as {{tt|arg}}. The integral part (in floating-point format) is stored in the object pointed to by {{tt|iptr}}.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par | iptr | pointer to floating point value to store the integral part to}}
{{par end}}

===Return value===
The fractional part of {{tt|arg}} with the same sign as {{tt|arg}}. The integral part is put into the value pointed to by {{tt|iptr}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
 
int main(void)
{
    double whole,fract;
    fract = modf(+1.5,&amp;whole);
    printf(&quot;%+4.0f   %+f\n&quot;, whole,fract);
    fract = modf(-1.5,&amp;whole);
    printf(&quot;%+4.0f   %+f\n&quot;, whole,fract);
    fract = modf(+INFINITY,&amp;whole);
    printf(&quot;%+4.0f   %+f\n&quot;, whole,fract);
    fract = modf(-INFINITY,&amp;whole);
    printf(&quot;%+4.0f   %+f\n&quot;, whole,fract);
    fract = modf(+NAN,&amp;whole);
    printf(&quot;%+4f   %+f\n&quot;, whole,fract);
    fract = modf(-NAN,&amp;whole);
    printf(&quot;%+4f   %+f\n&quot;, whole,fract);

    return 0;
}
 | p=true
 | output=
  +1   +0.500000
  -1   -0.500000
+inf   +0.000000
-inf   -0.000000
+nan   +nan
-nan   -nan
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc see cpp | cpp/numeric/math/modf}}
{{dsc end}}

[[de:c/numeric/math/modf]]
[[es:c/numeric/math/modf]]
[[fr:c/numeric/math/modf]]
[[it:c/numeric/math/modf]]
[[ja:c/numeric/math/modf]]
[[pt:c/numeric/math/modf]]
[[ru:c/numeric/math/modf]]
[[zh:c/numeric/math/modf]]</text>
      <sha1>ai7vwhhor5y8l7t0kuh8j8rrd74a1ji</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nan</title>
    <ns>0</ns>
    <id>6276</id>
    <revision>
      <id>71186</id>
      <parentid>70700</parentid>
      <timestamp>2014-06-07T22:22:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>make the example illustrate the difference the string makes. -std::. details</comment>
      <text xml:space="preserve" bytes="1921">{{c/title|nan|nanf|nanl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
float       nanf( const char* arg );
}}
{{dcl | since=c99 |
double      nan( const char* arg );
}}
{{dcl | since=c99 |
long double nanl( const char* arg );
}}
{{dcl end}}

Converts the implementation-defined character string {{tt|arg}} into the corresponding quiet NaN value, as if by calling {{lc|strtod}}, {{lc|strtof}}, or {{lc|strtold}}, respectively, as follows:

The call {{c|nan(&quot;string&quot;)}} is equivalent to the call {{c|strtod(&quot;NAN(string)&quot;, (char**)NULL);}}.

The call {{c|nan(&quot;&quot;)}} is equivalent to the call {{c|strtod(&quot;NAN()&quot;, (char**)NULL);}}.

The call {{c|nan(NULL)}} is equivalent to the call {{c|strtod(&quot;NAN&quot;, (char**)NULL);}}.

===Parameters===
{{par begin}}
{{par | arg | narrow character string identifying the contents of a NaN}}
{{par end}}

===Return value===
The quiet NaN value that corresponds to the identifying string {{tt|arg}} or zero if the implementation does not support quiet NaNs. 

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;stdint.h&gt;
#include &lt;inttypes.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    double f1 = nan(&quot;1&quot;);
    uint64_t f1n; memcpy(&amp;f1n, &amp;f1, sizeof f1);
    printf(&quot;nan(\&quot;1\&quot;) = %f (%&quot; PRIx64 &quot;)\n&quot;, f1, f1n);

    double f2 = nan(&quot;2&quot;);
    uint64_t f2n; memcpy(&amp;f2n, &amp;f2, sizeof f2);
    printf(&quot;nan(\&quot;2\&quot;) = %f (%&quot; PRIx64 &quot;)\n&quot;, f2, f2n);
}
 | p=true
 | output=
nan(&quot;1&quot;) = nan (7ff8000000000001)
nan(&quot;2&quot;) = nan (7ff8000000000002)
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc isnan}}
{{dsc inc | c/numeric/math/dsc NAN}}}
{{dsc see cpp | cpp/numeric/math/nan | nanf | nan | nanl }}
{{dsc end}}

[[de:c/numeric/math/nan]]
[[es:c/numeric/math/nan]]
[[fr:c/numeric/math/nan]]
[[it:c/numeric/math/nan]]
[[ja:c/numeric/math/nan]]
[[pt:c/numeric/math/nan]]
[[ru:c/numeric/math/nan]]
[[zh:c/numeric/math/nan]]</text>
      <sha1>02haiusx1fu513yoizziv2bwklp18sl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nanf</title>
    <ns>0</ns>
    <id>6506</id>
    <redirect title="c/numeric/math/nan" />
    <revision>
      <id>25678</id>
      <timestamp>2012-04-23T21:01:40Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/nan]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/nan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nanl</title>
    <ns>0</ns>
    <id>6507</id>
    <redirect title="c/numeric/math/nan" />
    <revision>
      <id>25679</id>
      <timestamp>2012-04-23T21:01:43Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/nan]]</comment>
      <text xml:space="preserve" bytes="32">#redirect [[c/numeric/math/nan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nearbyint</title>
    <ns>0</ns>
    <id>6307</id>
    <revision>
      <id>72064</id>
      <parentid>69573</parentid>
      <timestamp>2014-07-11T04:38:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="3864">{{c/title|nearbyint|nearbyintf|nearbyintl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1|
float       nearbyintf( float arg );
}}
{{dcl | since=c99 |num=2|
double      nearbyint( double arg );
}}
{{dcl | since=c99 |num=3|
long double nearbyintl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define nearbyint( arg )
}}
{{dcl end}}

@1-3@ Rounds the floating-point argument {{tt|arg}} to an integer value in floating-point format, using the [[c/numeric/fenv/FE_round|current rounding mode]].
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|nearbyintl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|nearbyint}} is called. Otherwise, {{tt|nearbyintf}} is called, respectively.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
The nearest integer value to {{tt|arg}}, according to the [[c/numeric/fenv/FE_round|current rounding mode]], is returned.

===Error handling===
This function is not subject to any of the errors specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{lc|FE_INEXACT}} is never raised
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned

===Notes===
The only difference between {{tt|nearbyint}} and {{lc|rint}} is that {{tt|nearbyint}} never raises {{lc|FE_INEXACT}}.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|nearbyint}} never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

If the current rounding mode is {{lc|FE_TONEAREST}}, this function rounds to even in halfway cases (like {{lc|rint}}, but unlike {{lc|round}})

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;

int main(void)
{
#pragma STDC FENV_ACCESS ON
    fesetround(FE_TONEAREST);
    printf(&quot;rounding to nearest:\nnearbyint(+2.3) = %+.1f  &quot;, nearbyint(2.3));
    printf(&quot;nearbyint(+2.5) = %+.1f  &quot;, nearbyint(2.5));
    printf(&quot;nearbyint(+3.5) = %+.1f\n&quot;, nearbyint(3.5));
    printf(&quot;nearbyint(-2.3) = %+.1f  &quot;, nearbyint(-2.3));
    printf(&quot;nearbyint(-2.5) = %+.1f  &quot;, nearbyint(-2.5));
    printf(&quot;nearbyint(-3.5) = %+.1f\n&quot;, nearbyint(-3.5));

    fesetround(FE_DOWNWARD);
    printf(&quot;rounding down: \nnearbyint(+2.3) = %+.1f  &quot;, nearbyint(2.3));
    printf(&quot;nearbyint(+2.5) = %+.1f  &quot;, nearbyint(2.5));
    printf(&quot;nearbyint(+3.5) = %+.1f\n&quot;, nearbyint(3.5));
    printf(&quot;nearbyint(-2.3) = %+.1f  &quot;, nearbyint(-2.3));
    printf(&quot;nearbyint(-2.5) = %+.1f  &quot;, nearbyint(-2.5));
    printf(&quot;nearbyint(-3.5) = %+.1f\n&quot;, nearbyint(-3.5));

    printf(&quot;nearbyint(-0.0) = %+.1f\n&quot;, nearbyint(-0.0));
    printf(&quot;nearbyint(-Inf) = %+.1f\n&quot;, nearbyint(-INFINITY));
}
 | output=
rounding to nearest:
nearbyint(+2.3) = +2.0  nearbyint(+2.5) = +2.0  nearbyint(+3.5) = +4.0
nearbyint(-2.3) = -2.0  nearbyint(-2.5) = -2.0  nearbyint(-3.5) = -4.0
rounding down: 
nearbyint(+2.3) = +2.0  nearbyint(+2.5) = +2.0  nearbyint(+3.5) = +3.0
nearbyint(-2.3) = -3.0  nearbyint(-2.5) = -3.0  nearbyint(-3.5) = -4.0
nearbyint(-0.0) = -0.0
nearbyint(-Inf) = -inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc rint}}
{{dsc inc | c/numeric/math/dsc round}}
{{dsc inc | c/numeric/fenv/dsc feround}}
{{dsc see cpp | cpp/numeric/math/nearbyint}}
{{dsc end}}

[[de:c/numeric/math/nearbyint]]
[[es:c/numeric/math/nearbyint]]
[[fr:c/numeric/math/nearbyint]]
[[it:c/numeric/math/nearbyint]]
[[ja:c/numeric/math/nearbyint]]
[[pt:c/numeric/math/nearbyint]]
[[ru:c/numeric/math/nearbyint]]
[[zh:c/numeric/math/nearbyint]]</text>
      <sha1>4vv5tlbrw4rjpcqhc40llk36e9oc95l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nextafter</title>
    <ns>0</ns>
    <id>6260</id>
    <revision>
      <id>70154</id>
      <parentid>70144</parentid>
      <timestamp>2014-05-10T21:34:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>wrap long line. main doesn't need a return in C (guess it's time to write a /c/language/main_function)</comment>
      <text xml:space="preserve" bytes="3853">{{c/title|nextafter|nexttoward}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1| since=c99 |
float       nextafterf( float from, float to );
}}
{{dcl |num=1| since=c99 |
double      nextafter( double from, double to );
}}
{{dcl |num=1| since=c99 |
long double nextafterl( long double from, long double to );
}}
{{dcl |num=2| since=c99 |
float       nexttowardf( float from, long double to );
}}
{{dcl |num=2| since=c99 |
double      nexttoward( double from, long double to );
}}
{{dcl |num=2| since=c99 |
long double nexttowardl( long double from, long double to );
}}
{{dcl header | tgmath.h}}
{{dcl |num=3| since=c99 |
#define nextafter(from, to)
}}
{{dcl |num=3| since=c99 |
#define nexttoward(from, to)
}}
{{dcl end}}

Returns the next representable value of {{tt|from}} in the direction of {{tt|to}}.

@1@ If {{tt|from}} equals to {{tt|to}}, {{tt|to}} is returned.
@2@ If {{tt|from}} equals to {{tt|to}}, {{tt|to}} is returned, converted from {{c|long double}} to the return type of the function without loss of range or precision.
@3@ Type-generic macro: If any argument has type {{c|long double}}, the long double version of the function is called. Otherwise, if any argument has type {{c|double}}, the double version of the function is called. Otherwise, the {{c|float}} version of the function is called.

If {{tt|from}} is finite, but the result of {{tt|nextafter}} or {{tt|nexttoward}} is infinite, range error occurs and {{lc|FE_OVERFLOW}} and {{lc|FE_INEXACT}} may be raised.

If the result is subnormal or zero and {{tt|from !{{=}} to}}, raises {{lc|FE_UNDERFLOW}} and {{lc|FE_INEXACT}}.

In any case, the returned value is independent of the current rounding mode.

===Parameters===
{{par begin}}
{{par | from, to | floating point values}}
{{par end}}

===Return value===
The next representable value of {{tt|from}} in the direction of {{tt|to}}.

===Example===
{{example |
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
#include &lt;float.h&gt;
#include &lt;fenv.h&gt;

int main(void)
{
    float from1 = 0, to1 = nextafterf(0, 1);
    printf(&quot;The next representable float after %.2f (%a) is %.20g (%a)\n&quot;,
           from1, from1, to1, to1);

    float from2 = 1, to2 = nextafterf(1, 2);
    printf(&quot;The next representable float after %.2f (%a) is %.23f (%a)\n&quot;,
           from2, from2, to2, to2);

    double from3 = nextafter(0.1, 0), to3 = 0.1;
    printf(&quot;The number 0.1 lies between two valid doubles:\n&quot;
           &quot;    %.56f (%a)\nand %.55f  (%a)\n&quot;,
           from3, from3, to3, to3);

    {
        #pragma STDC FENV_ACCESS ON
        feclearexcept(FE_ALL_EXCEPT);
        double from4 = DBL_MAX, to4 = nextafter(DBL_MAX, INFINITY);
        printf(&quot;The next representable double after %.2g (%a) is %.23f (%a)\n&quot;,
               from4, from4, to4, to4);
        if(fetestexcept(FE_OVERFLOW)) puts(&quot;   raised FE_OVERFLOW&quot;);
        if(fetestexcept(FE_INEXACT)) puts(&quot;   raised FE_INEXACT&quot;);
    } // end FENV_ACCESS block
}
 | output=
The next representable float after 0.00 (0x0p+0) is 1.4012984643248170709e-45 (0x1p-149)
The next representable float after 1.00 (0x1p+0) is 1.00000011920928955078125 (0x1.000002p+0)
The number 0.1 lies between two valid doubles:
    0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)
and 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)
The next representable double after 1.8e+308 (0x1.fffffffffffffp+1023) is inf (inf)
   raised FE_OVERFLOW
   raised FE_INEXACT
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/math/nextafter}}
{{dsc end}}

[[de:c/numeric/math/nextafter]]
[[es:c/numeric/math/nextafter]]
[[fr:c/numeric/math/nextafter]]
[[it:c/numeric/math/nextafter]]
[[ja:c/numeric/math/nextafter]]
[[pt:c/numeric/math/nextafter]]
[[ru:c/numeric/math/nextafter]]
[[zh:c/numeric/math/nextafter]]</text>
      <sha1>abv89543t8d3g5lfwiwimrnx1dirhd4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/nexttoward</title>
    <ns>0</ns>
    <id>6513</id>
    <redirect title="c/numeric/math/nextafter" />
    <revision>
      <id>25685</id>
      <timestamp>2012-04-23T21:02:03Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/nextafter]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[c/numeric/math/nextafter]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/pow</title>
    <ns>0</ns>
    <id>6287</id>
    <revision>
      <id>70852</id>
      <parentid>70770</parentid>
      <timestamp>2014-05-31T03:51:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>for symmetry with sqrt, cbrt and hypot: +link to hypot, -link to exp and log</comment>
      <text xml:space="preserve" bytes="5852">{{c/title|pow, powf, powl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1| since=c99 |
float powf( float base, float exponent );
}}
{{dcl |num=2|
double pow( double base, double exponent );
}}
{{dcl |num=3| since=c99 |
long double powl( long double base, long double exponent );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define pow( base, exponent )
}}
{{dcl end}}

@1-3@ Computes the value of {{tt|base}} raised to the power {{tt|exponent}}.
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|powl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|pow}} is called. Otherwise, {{tt|powf}} is called. If at least one argument is complex, then the macro invokes the corresponding complex function ({{c|cpowf}}, {{c|cpow}}, {{c|cpowl}})

===Parameters===
{{par begin}}
{{par | base | base as floating point value}}
{{par | exponent | exponent as floating point value}}
{{par end}}

===Return value===
If no errors occur, {{tt|base}} raised to the power of {{tt|exponent}} ({{math|base{{su|p=exponent}}}}) is returned. 

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error or a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If {{tt|base}} is finite and negative and {{tt|exponent}} is finite and non-integer, a domain error occurs and a range error may occur.

If {{tt|base}} is zero and {{tt|exponent}} is zero, a domain error may occur.

If {{tt|base}} is zero and {{tt|exponent}} is negative, a domain error or a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{c|pow(+0, exponent)}}, where {{tt|exponent}} is a negative odd integer, returns {{tt|+∞}} and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(-0, exponent)}}, where {{tt|exponent}} is a negative odd integer, returns {{tt|-∞}} and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(±0, exponent)}}, where {{tt|exponent}} is negative, finite, and is an even integer or a non-integer, returns +∞ and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(±0, -∞)}} returns +∞ and may raise {{lc|FE_DIVBYZERO}}
* {{c|pow(+0, exponent)}}, where {{tt|exponent}} is a positive odd integer, returns +0
* {{c|pow(-0, exponent)}}, where {{tt|exponent}} is a positive odd integer, returns -0
* {{c|pow(±0, exponent)}}, where {{tt|exponent}} is positive non-integer or a positive even integer, returns +0
* {{c|pow(-1, ±∞)}} returns {{tt|1}}
* {{c|pow(+1, exponent)}} returns {{tt|1}} for any {{tt|exponent}}, even when {{tt|exponent}} is {{tt|NaN}}
* {{c|pow(base, ±0)}} returns {{tt|1}} for any {{tt|base}}, even when {{tt|base}} is {{tt|NaN}}
* {{c|pow(base, exponent)}} returns {{tt|NaN}} and raises {{lc|FE_INVALID}} if {{tt|base}} is finite and negative and {{tt|exponent}} is finite and non-integer.
* {{c|pow(base, -∞)}} returns +∞ for any {{tt|{{!}}base{{!}}&lt;1}}
* {{c|pow(base, -∞)}} returns +0 for any {{tt|{{!}}base{{!}}&gt;1}}
* {{c|pow(base, +∞)}} returns +0 for any {{tt|{{!}}base{{!}}&lt;1}}
* {{c|pow(base, +∞)}} returns +∞ for any {{tt|{{!}}base{{!}}&gt;1}}
* {{c|pow(-∞, exponent)}} returns -0 if {{tt|exponent}} is a negative odd integer
* {{c|pow(-∞, exponent)}} returns +0 if {{tt|exponent}} is a negative non-integer or even integer
* {{c|pow(-∞, exponent)}} returns -∞ if {{tt|exponent}} is a positive odd integer
* {{c|pow(-∞, exponent)}} returns +∞ if {{tt|exponent}} is a positive non-integer or even integer
* {{c|pow(+∞, exponent)}} returns +0 for any negative {{tt|exponent}}
* {{c|pow(+∞, exponent)}} returns +∞ for any positive {{tt|exponent}}
* except where specified above, if any argument is NaN, NaN is returned

===Notes===
Although {{tt|pow}} cannot be used to obtain a root of a negative number, {{lc|cbrt}} is provided for the common case where {{tt|exponent}} is 1/3.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    // typical usage
    printf(&quot;pow(2, 10) = %f\n&quot;, pow(2,10));
    printf(&quot;pow(2, 0.5) = %f\n&quot;, pow(2,0.5));
    printf(&quot;pow(-2, -3) = %f\n&quot;, pow(-2,-3));
    // special values
    printf(&quot;pow(-1, NAN) = %f\n&quot;, pow(-1,NAN));
    printf(&quot;pow(+1, NAN) = %f\n&quot;, pow(+1,NAN));
    printf(&quot;pow(INFINITY, 2) = %f\n&quot;, pow(INFINITY, 2));
    printf(&quot;pow(INFINITY, -1) = %f\n&quot;, pow(INFINITY, -1));
    // error handling 
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;pow(-1, 1/3) = %f\n&quot;, pow(-1, 1.0/3));
    if(errno == EDOM)         perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);

    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;pow(-0, -3) = %f\n&quot;, pow(-0.0, -3));
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
}
 | p=true
 | output=
pow(2, 10) = 1024.000000
pow(2, 0.5) = 1.414214
pow(-2, -3) = -0.125000
pow(-1, NAN) = nan
pow(+1, NAN) = 1.000000
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0.000000
pow(-1, 1/3) = -nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc sqrt}}
{{dsc inc | c/numeric/math/dsc cbrt}}
{{dsc inc | c/numeric/math/dsc hypot}}
{{dsc inc | c/numeric/complex/dsc cpow}}
{{dsc see cpp | cpp/numeric/math/pow}}
{{dsc end}}

[[de:c/numeric/math/pow]]
[[es:c/numeric/math/pow]]
[[fr:c/numeric/math/pow]]
[[it:c/numeric/math/pow]]
[[ja:c/numeric/math/pow]]
[[pt:c/numeric/math/pow]]
[[ru:c/numeric/math/pow]]
[[zh:c/numeric/math/pow]]</text>
      <sha1>4d04ojzelna7q9u8rlvjxq0ezzt8yyt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/remainder</title>
    <ns>0</ns>
    <id>6270</id>
    <revision>
      <id>71793</id>
      <parentid>71790</parentid>
      <timestamp>2014-06-24T02:13:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missing braces</comment>
      <text xml:space="preserve" bytes="4329">{{c/title|remainder|remainderf|remainderl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       remainderf( float x, float y );
}}
{{dcl | since=c99 |num=2|
double      remainder( double x, double y );
}}
{{dcl | since=c99 |num=3|
long double remainderl( long double x, long double y );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define remainder( x, y )
}}
{{dcl end}}

@1-3@ Computes the IEEE remainder of the floating point division operation {{c|x/y}}.
@4@ Type-generic macro: If any argument has type {{c|long double}}, {{tt|remainderl}} is called. Otherwise, if any argument has integer type or has type {{c|double}}, {{tt|remainder}} is called. Otherwise, {{tt|remainderf}} is called.

The IEEE floating-point remainder of the division operation {{c|x/y}} calculated by this function is exactly the value {{c|x - n*y}}, where the value {{tt|n}} is the integral value nearest the exact value {{c|x/y}}. When {{math|{{!}}n-x/y{{!}} {{=}} ½}}, the value {{tt|n}} is chosen to be even.

In contrast to {{lc|fmod()}}, the returned value is not guaranteed to have the same sign as {{tt|x}}.

If the returned value is {{tt|0}}, it will have the same sign as {{tt|x}}.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
If successful, returns the IEEE floating-point remainder of the division {{c|x/y}} as defined above.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result is returned.

If {{tt|y}} is zero, but the domain error does not occur, zero is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* {{lc|FE_INEXACT}} is never raised, the result is always exact.
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If either argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/remainder.html POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

{{lc|fmod}}, but not {{tt|remainder}} is useful for doing silent wrapping of floating-point types to unsigned integer types: {{c|1=(0.0 &lt;= (y = fmod(rint(x), 65536.0)) ? y : 65536.0 + y)}} is in the range {{tt|[-0.0 .. 65535.0]}}, which corresponds to {{c|unsigned short}}, but {{c|remainder(rint(x), 65536.0}} is in the range {{tt|[-32767.0, +32768.0]}}, which is outside of the range of {{c|signed short}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;remainder(+5.1, +3.0) = %.1f\n&quot;, remainder(5.1,3));
    printf(&quot;remainder(-5.1, +3.0) = %.1f\n&quot;, remainder(-5.1,3));
    printf(&quot;remainder(+5.1, -3.0) = %.1f\n&quot;, remainder(5.1,-3));
    printf(&quot;remainder(-5.1, -3.0) = %.1f\n&quot;, remainder(-5.1,-3));

    // special values
    printf(&quot;remainder(-0.0, 1.0) = %.1f\n&quot;, remainder(-0.0, 1));
    printf(&quot;remainder(+5.1, Inf) = %.1f\n&quot;, remainder(5.1, INFINITY));

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;remainder(+5.1, 0) = %.1f\n&quot;, remainder(5.1, 0));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | output=
remainder(+5.1, +3.0) = -0.9
remainder(-5.1, +3.0) = 0.9
remainder(+5.1, -3.0) = -0.9
remainder(-5.1, -3.0) = 0.9
remainder(+0.0, 1.0) = 0.0
remainder(-0.0, 1.0) = -0.0
remainder(+5.1, Inf) = 5.1
remainder(+5.1, 0) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc div}}
{{dsc inc | c/numeric/math/dsc fmod}}
{{dsc inc | c/numeric/math/dsc remquo}}
{{dsc see cpp | cpp/numeric/math/remainder}}
{{dsc end}}

[[de:c/numeric/math/remainder]]
[[es:c/numeric/math/remainder]]
[[fr:c/numeric/math/remainder]]
[[it:c/numeric/math/remainder]]
[[ja:c/numeric/math/remainder]]
[[pt:c/numeric/math/remainder]]
[[ru:c/numeric/math/remainder]]
[[zh:c/numeric/math/remainder]]</text>
      <sha1>42yk0thnjk5uqo19yrlqqued9daccvg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/remquo</title>
    <ns>0</ns>
    <id>6271</id>
    <revision>
      <id>71788</id>
      <parentid>71754</parentid>
      <timestamp>2014-06-24T01:58:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>er, no rounding in underflow</comment>
      <text xml:space="preserve" bytes="5564">{{c/title|remquo|remquof|remquol}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       remquof( float x, float y, int *quo );
}}
{{dcl | since=c99 |num=2|
double      remquo( double x, double y, int *quo );
}}
{{dcl | since=c99 |num=3|
long double remquol( long double x, long double y, int *quo );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define remquo( x, y, quo )
}}
{{dcl end}}

@1-3@ Computes the floating-point remainder of the division operation {{c|x/y}} as the {{lc|remainder()}} function does.  Additionally, the sign and at least the three of the last bits of {{c|x/y}} will be stored in {{c|quo}}, sufficient to determine the octant of the result within a period.
@4@ Type-generic macro: If any non-pointer argument has type {{c|long double}}, {{tt|remquol}} is called. Otherwise, if any non-pointer argument has integer type or has type {{c|double}}, {{tt|remquo}} is called. Otherwise, {{tt|remquof}} is called.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par | quo | pointer to an integer value to store the sign and some bits of {{c|x/y}} }}
{{par end}}

===Return value===
If successful, returns the floating-point remainder of the division {{c|x/y}} as defined in {{lc|remainder}}, and a value whose sign is the sign of {{c|x/y}} and whose magnitude is congruent {{math|modulo 2{{su|p=n}}}} to the magnitude of the integral quotient of {{c|x/y}}, where {{math|n}} is an implementation-defined integer greater than or equal to {{math|3}}.

If {{tt|y}} is zero, the value stored in {{c|*quo}} is unspecified.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result is returned if subnormals are supported.

If {{tt|y}} is zero, but the domain error does not occur, zero is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* {{lc|FE_INEXACT}} is never raised
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If either {{tt|x}} or {{tt|y}} is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/remquo.html POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

This function is useful when implementing periodic functions with the period exactly representable as a floating-point value: when calculating {{math|sin(πx)}} for a very large {{tt|x}}, calling {{lc|sin}} directly may result in a large error, but if the function argument is first reduced with {{tt|remquo}}, he low-order bits of the quotient may be used to determine the sign and the octant of the result within the period, while the remainder may be used to calculate the value with high precision. 

On some platforms this operation is supported by hardware (and, for example, on Intel CPU, {{tt|FPREM1}} leaves exactly 3 bits of precision in the quotient)

===Example===
{{example|code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
double cos_pi_x_naive(double x)
{
    double pi = acos(-1);
    return cos(pi * x);
}
// the period is 2, values are (0;0.5) positive, (0.5;1.5) negative, (1.5,2) positive
double cos_pi_x_smart(double x)
{
    int quadrant;
    double rem = remquo(x, 1, &amp;quadrant);
    quadrant = (unsigned)quadrant % 4; // keep 2 bits to determine quadrant

    double pi = acos(-1);
    switch(quadrant) {
        case 0: return cos(pi * rem);
        case 1: return -cos(pi * rem);
        case 2: return -cos(pi * rem);
        case 3: return cos(pi * rem);
    };
}
int main(void)
{
    printf(&quot;cos(pi * 0.25) = %f\n&quot;, cos_pi_x_naive(0.25));
    printf(&quot;cos(pi * 1.25) = %f\n&quot;, cos_pi_x_naive(1.25));
    printf(&quot;cos(pi * 1000000000000.25) = %f\n&quot;, cos_pi_x_naive(1000000000000.25));
    printf(&quot;cos(pi * 1000000000001.25) = %f\n&quot;, cos_pi_x_naive(1000000000001.25));
    printf(&quot;cos(pi * 1000000000000.25) = %f\n&quot;, cos_pi_x_smart(1000000000000.25));
    printf(&quot;cos(pi * 1000000000001.25) = %f\n&quot;, cos_pi_x_smart(1000000000001.25));
    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    int quo;
    printf(&quot;remquo(+Inf, 1) = %.1f\n&quot;, remquo(INFINITY, 1, &amp;quo));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
|p=true
|output=
cos(pi * 0.25) = 0.707107
cos(pi * 1.25) = -0.707107
cos(pi * 1000000000000.25) = 0.707123
cos(pi * 1000000000001.25) = -0.707117
cos(pi * 1000000000000.25) = 0.707107
cos(pi * 1000000000001.25) = -0.707107 &lt;!-- note: this is exact output from Intel C on Linux, Oracle and GNU C on sparc, and IBM and GNU C compilers on a power platform. Do not replace with the incorrect output obtained from GNU C on Linux --&gt;
remquo(+Inf, 1) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc div}}
{{dsc inc | c/numeric/math/dsc fmod}}
{{dsc inc | c/numeric/math/dsc remainder}}
{{dsc see cpp | cpp/numeric/math/remquo}}
{{dsc end}}

[[de:c/numeric/math/remquo]]
[[es:c/numeric/math/remquo]]
[[fr:c/numeric/math/remquo]]
[[it:c/numeric/math/remquo]]
[[ja:c/numeric/math/remquo]]
[[pt:c/numeric/math/remquo]]
[[ru:c/numeric/math/remquo]]
[[zh:c/numeric/math/remquo]]</text>
      <sha1>t6ive17s55o97tw4m7z06gtmemetdxj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/rint</title>
    <ns>0</ns>
    <id>6310</id>
    <revision>
      <id>72062</id>
      <parentid>72042</parentid>
      <timestamp>2014-07-11T04:31:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>3.5 shows more than 2.7</comment>
      <text xml:space="preserve" bytes="6508">{{c/title|rint, rintf, rintl | lrint, lrintf, lrintl | llrint, llrintf, llrintl }}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float rintf( float arg );
}}
{{dcl | since=c99 |num=2|
double rint( double arg );
}}
{{dcl | since=c99 |num=3|
long double rintl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define rint( arg )
}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=5|
long lrintf( float arg );
}}
{{dcl | since=c99 |num=6|
long lrint( double arg );
}}
{{dcl | since=c99 |num=7|
long lrintl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=8| since=c99 |
#define lrint( arg )
}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=9|
long long llrintf( float arg );
}}
{{dcl | since=c99 |num=10|
long long llrint( double arg );
}}
{{dcl | since=c99 |num=11|
long long llrintl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |since=c99 | num=12|
#define llrint( arg )
}}
{{dcl end}}

@1-3@ Rounds the floating-point argument {{tt|arg}} to an integer value in floating-point format, using the current rounding mode.
@5-7, 9-11@ Rounds the floating-point argument {{tt|arg}} to an integer value in integer format, using the current rounding mode.
@4,8,12@ Type-generic macros: If {{tt|arg}} has type {{c|long double}}, {{tt|rintl}}, {{tt|lrintl}}, {{tt|llrintl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|rint}}, {{tt|lrint}}, {{tt|llrint}} is called. Otherwise, {{tt|rintf}}, {{tt|lrintf}}, {{tt|llrintf}} is called, respectively.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value to {{tt|arg}}, according to the [[cpp/numeric/fenv/FE_round|current rounding mode]], is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the result of {{tt|lrint}} or {{tt|llrint}} is outside the range representable by the return type, a domain error or a range error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
: For the {{tt|rint}} function:
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned
: For {{tt|lrint}} and {{tt|llrint}} functions:
* If {{tt|arg}} is ±∞, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If the result of the rounding is outside the range of the return type, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If {{tt|arg}} is NaN, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/lrint.html POSIX specifies] that all cases where {{tt|lrint}} or {{tt|llrint}} raise {{lc|FE_INEXACT}} are domain errors.

As specified in [[c/numeric/math/math_errhandling|math_errhandling]], {{lc|FE_INEXACT}} may be (but isn't required to be on non-IEEE floating-point platforms) raised by {{tt|rint}} when rounding a non-integer finite value.

The only difference between {{tt|rint}} and {{lc|nearbyint}} is that {{lc|nearbyint}} never raises {{lc|FE_INEXACT}}.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|rint}} never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

If the current rounding mode is...
* {{lc|FE_DOWNWARD}}, then {{tt|rint}} is equivalent to {{lc|floor}}.
* {{lc|FE_UPWARD}}, then {{tt|rint}} is equivalent to {{lc|ceil}}.
* {{lc|FE_TOWARDZERO}}, then {{tt|rint}} is equivalent to {{lc|trunc}}
* {{lc|FE_TONEAREST}}, then {{tt|rint}} differs from {{lc|round}} in that halfway cases are rounded to even rather than away from zero.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
#include &lt;limits.h&gt;

int main(void)
{
#pragma STDC FENV_ACCESS ON
    fesetround(FE_TONEAREST);
    printf(&quot;rounding to nearest:\nrint(+2.3) = %+.1f  &quot;, rint(2.3));
    printf(&quot;rint(+2.5) = %+.1f  &quot;, rint(2.5));
    printf(&quot;rint(+3.5) = %+.1f\n&quot;, rint(3.5));
    printf(&quot;rint(-2.3) = %+.1f  &quot;, rint(-2.3));
    printf(&quot;rint(-2.5) = %+.1f  &quot;, rint(-2.5));
    printf(&quot;rint(-3.5) = %+.1f\n&quot;, rint(-3.5));

    fesetround(FE_DOWNWARD);
    printf(&quot;rounding down: \nrint(+2.3) = %+.1f  &quot;, rint(2.3));
    printf(&quot;rint(+2.5) = %+.1f  &quot;, rint(2.5));
    printf(&quot;rint(+3.5) = %+.1f\n&quot;, rint(3.5));
    printf(&quot;rint(-2.3) = %+.1f  &quot;, rint(-2.3));
    printf(&quot;rint(-2.5) = %+.1f  &quot;, rint(-2.5));
    printf(&quot;rint(-3.5) = %+.1f\n&quot;, rint(-3.5));
    printf(&quot;rounding down with lrint: \nlrint(+2.3) = %ld  &quot;, lrint(2.3));
    printf(&quot;lrint(+2.5) = %ld  &quot;, lrint(2.5));
    printf(&quot;lrint(+3.5) = %ld\n&quot;, lrint(3.5));
    printf(&quot;lrint(-2.3) = %ld  &quot;, lrint(-2.3));
    printf(&quot;lrint(-2.5) = %ld  &quot;, lrint(-2.5));
    printf(&quot;lrint(-3.5) = %ld\n&quot;, lrint(-3.5));

    printf(&quot;lrint(-0.0) = %ld\n&quot;, lrint(-0.0));
    printf(&quot;lrint(-Inf) = %ld\n&quot;, lrint(-INFINITY)); // FE_INVALID raised

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;rint(1.1) = %.1f\n&quot;, rint(1.1));
    if(fetestexcept(FE_INEXACT)) puts(&quot;    FE_INEXACT was raised&quot;);

    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;lrint(LONG_MIN-2048.0) = %ld\n&quot;, lrint(LONG_MIN-2048.0));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID was raised&quot;);
}
 | p=true
 | output=
rounding to nearest:
rint(+2.3) = +2.0  rint(+2.5) = +2.0  rint(+3.5) = +4.0
rint(-2.3) = -2.0  rint(-2.5) = -2.0  rint(-3.5) = -4.0
rounding down: 
rint(+2.3) = +2.0  rint(+2.5) = +2.0  rint(+3.5) = +3.0
rint(-2.3) = -3.0  rint(-2.5) = -3.0  rint(-3.5) = -4.0
rounding down with lrint: 
lrint(+2.3) = 2  lrint(+2.5) = 2  lrint(+3.5) = 3
lrint(-2.3) = -3  lrint(-2.5) = -3  lrint(-3.5) = -4
lrint(-0.0) = 0
lrint(-Inf) = -9223372036854775808
rint(1.1) = 1.0
    FE_INEXACT was raised
lrint(LONG_MIN-2048.0) = -9223372036854775808
    FE_INVALID was raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc inc | c/numeric/math/dsc nearbyint}}
{{dsc inc | c/numeric/fenv/dsc feround}}
{{dsc see cpp | cpp/numeric/math/rint}}
{{dsc end}}

[[de:c/numeric/math/rint]]
[[es:c/numeric/math/rint]]
[[fr:c/numeric/math/rint]]
[[it:c/numeric/math/rint]]
[[ja:c/numeric/math/rint]]
[[pt:c/numeric/math/rint]]
[[ru:c/numeric/math/rint]]
[[zh:c/numeric/math/rint]]</text>
      <sha1>4q1hnt48j5cm5zlla1a96k3mm2yjsp2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/round</title>
    <ns>0</ns>
    <id>6306</id>
    <revision>
      <id>72027</id>
      <parentid>71879</parentid>
      <timestamp>2014-07-09T17:23:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="6248">{{c/title|round, roundf, roundl| lround, lroundf, lroundl | llround, llroundf, llroundl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       roundf( float arg );
}}
{{dcl | since=c99 |num=2|
double      round( double arg );
}}
{{dcl | since=c99 |num=3|
long double roundl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define round( arg )
}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=5|
long      lroundf( float arg );
}}
{{dcl | since=c99 | num=6|
long      lround( double arg );
}}
{{dcl | since=c99 | num=7|
long      lroundl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=8| since=c99 |
#define lround( arg )
}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=9|
long long llroundf( float arg );
}}
{{dcl | since=c99 | num=10|
long long llround( double arg );
}}
{{dcl | since=c99 | num=11|
long long llroundl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |since=c99 | num=12|
#define llround( arg )
}}
{{dcl end}}

@1-3@ Computes the nearest integer value to {{tt|arg}} (in floating-point format), rounding halfway cases away from zero, regardless of the current rounding mode.
@5-7, 9-11@ Computes the nearest integer value to {{tt|arg}} (in integer format), rounding halfway cases away from zero, regardless of the current rounding mode.
@4,8,12@ Type-generic macros: If {{tt|arg}} has type {{c|long double}}, {{tt|roundl}}, {{tt|lroundl}}, {{tt|llroundl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|round}}, {{tt|lround}}, {{tt|llround}} is called. Otherwise, {{tt|roundf}}, {{tt|lroundf}}, {{tt|llroundf}} is called, respectively.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value to {{tt|arg}}, rounding halfway cases away from zero, is returned.

{{plot | left=Return value | bottom=Argument | math-round_away_zero.svg}}

If a domain error occurs, an implementation-defined value is returned

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the result of {{tt|lround}} or {{tt|llround}} is outside the range representable by the return type, a domain error or a range error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
: For the {{tt|round}}, {{tt|roundf}}, and {{tt|roundl}} function:
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned
: For {{tt|lround}} and {{tt|llround}} families of functions:
* {{lc|FE_INEXACT}} is never raised
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If the result of the rounding is outside the range of the return type, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If {{tt|arg}} is NaN, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised by {{tt|round}} when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|round}} never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/lround.html POSIX specifies] that all cases where {{tt|lround}} or {{tt|llround}} raise {{lc|FE_INEXACT}} are domain errors.

The {{c|double}} version of {{tt|round}} behaves as if implemented as follows:
{{source|1=
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    fenv_t save_env;
    feholdexcept(&amp;save_env);
    double result = rint(x);
    if (fetestexcept(FE_INEXACT)) {
        fesetround(FE_TOWARDZERO);
        result = rint(copysign(0.5 + fabs(x), x));
    }
    feupdateenv(&amp;save_env);
    return result;
}
}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;fenv.h&gt;
#include &lt;limits.h&gt;

#pragma STDC FENV_ACCESS ON

int main(void)
{
    // round
    printf(&quot;round(+2.3) = %+.1f  &quot;, round(2.3));
    printf(&quot;round(+2.5) = %+.1f  &quot;, round(2.5));
    printf(&quot;round(+2.7) = %+.1f\n&quot;, round(2.7));
    printf(&quot;round(-2.3) = %+.1f  &quot;, round(-2.3));
    printf(&quot;round(-2.5) = %+.1f  &quot;, round(-2.5));
    printf(&quot;round(-2.7) = %+.1f\n&quot;, round(-2.7));

    printf(&quot;round(-0.0) = %+.1f\n&quot;, round(-0.0));
    printf(&quot;round(-Inf) = %+f\n&quot;,   round(-INFINITY));

    // lround
    printf(&quot;lround(+2.3) = %ld  &quot;, lround(2.3));
    printf(&quot;lround(+2.5) = %ld  &quot;, lround(2.5));
    printf(&quot;lround(+2.7) = %ld\n&quot;, lround(2.7));
    printf(&quot;lround(-2.3) = %ld  &quot;, lround(-2.3));
    printf(&quot;lround(-2.5) = %ld  &quot;, lround(-2.5));
    printf(&quot;lround(-2.7) = %ld\n&quot;, lround(-2.7));

    printf(&quot;lround(-0.0) = %ld\n&quot;, lround(-0.0));
    printf(&quot;lround(-Inf) = %ld\n&quot;, lround(-INFINITY)); // FE_INVALID raised

    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;lround(LONG_MAX+1.5) = %ld\n&quot;, lround(LONG_MAX+1.5));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID was raised&quot;);
}
 | p=true
 | output=
round(+2.3) = +2.0  round(+2.5) = +3.0  round(+2.7) = +3.0
round(-2.3) = -2.0  round(-2.5) = -3.0  round(-2.7) = -3.0
round(-0.0) = -0.0
round(-Inf) = -inf
lround(+2.3) = 2  lround(+2.5) = 3  lround(+2.7) = 3
lround(-2.3) = -2  lround(-2.5) = -3  lround(-2.7) = -3
lround(-0.0) = 0
lround(-Inf) = -9223372036854775808
lround(LONG_MAX+1.5) = -9223372036854775808
    FE_INVALID was raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc floor}}
{{dsc inc | c/numeric/math/dsc ceil}}
{{dsc inc | c/numeric/math/dsc trunc}}
{{dsc see cpp | cpp/numeric/math/round}}
{{dsc end}}

[[de:c/numeric/math/round]]
[[es:c/numeric/math/round]]
[[fr:c/numeric/math/round]]
[[it:c/numeric/math/round]]
[[ja:c/numeric/math/round]]
[[pt:c/numeric/math/round]]
[[ru:c/numeric/math/round]]
[[zh:c/numeric/math/round]]</text>
      <sha1>h8owfdjlskkeh5cbxsiffaokpx7u7w0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/scalbln</title>
    <ns>0</ns>
    <id>6512</id>
    <redirect title="c/numeric/math/scalbn" />
    <revision>
      <id>25684</id>
      <timestamp>2012-04-23T21:02:00Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/numeric/math/scalbn]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[c/numeric/math/scalbn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/scalbn</title>
    <ns>0</ns>
    <id>6263</id>
    <revision>
      <id>72171</id>
      <parentid>72170</parentid>
      <timestamp>2014-07-19T22:57:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="4533">{{c/title| scalbln, scalbnf, scalbnl| scalbln, scalblnf, scalblnl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1 |
float       scalbnf( float arg, int exp );
}}
{{dcl | since=c99 | num=2 |
double      scalbn( double arg, int exp );
}}
{{dcl | since=c99 | num=3 |
long double scalbnl( long double arg, int exp );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define scalbn( arg, exp )
}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=5 |
float       scalblnf( float arg, long exp );
}}
{{dcl | since=c99 | num=6 |
double      scalbln( double arg, long exp );
}}
{{dcl | since=c99 | num=7 |
long double scalblnl( long double arg, long exp );
}}
{{dcl header | tgmath.h}}
{{dcl |num=8| since=c99 |
#define scalbln( arg, exp )
}}
{{dcl end}}

@1-3,5-7@ Multiplies a floating point value {{tt|arg}} by {{lc|FLT_RADIX}} raised to power {{tt|exp}}.
@4,8@ Type-generic macros: If {{tt|arg}} has type {{c|long double}}, {{tt|scalbnl}} or {{tt|scalblnl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|scalbn}} or {{tt|scalbln}} is called. Otherwise, {{tt|scalbnf}} or {{tt|scalblnf}} is called, respectively.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par | exp | integer value}}
{{par end}}

===Return value===
If no errors occur, {{tt|arg}} multiplied by {{lc|FLT_RADIX}} to the power of {{tt|exp}} ({{math|arg&amp;times;FLT_RADIX{{su|p=exp}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* Unless a range error occurs, {{lc|FE_INEXACT}} is never raised (the result is exact)
* Unless a range error occurs, the [[c/numeric/fenv/FE_round|current rounding mode]] is ignored
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|exp}} is 0, then {{tt|arg}} is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned

===Notes===
On binary systems (where {{lc|FLT_RADIX}} is {{tt|2}}), {{tt|scalbn}} is equivalent to {{lc|ldexp}}.

Although {{tt|std::scalbn}} and {{tt|std::scalbln}} are specified to perform the operation efficiently, on many implementations they are less efficient than multiplication or division by a power of two using arithmetic operators.

The {{tt|scalbln}} function is provided because the factor required to scale from the smallest positive floating-point value to the largest finite one may be greater than 32767, the standard-guaranteed {{lc|INT_MAX}}. In particular, for the 80-bit {{tt|long double}}, the factor is 32828.

The GNU implementation does not set {{tt|errno}} regardless of {{tt|math_errhandling}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;scalbn(7, -4) = %f\n&quot;, scalbn(7, -4));
    printf(&quot;scalbn(1, -1074) = %g (minimum positive subnormal double)\n&quot;,
            scalbn(1, -1074));
    printf(&quot;scalbn(nextafter(1,0), 1024) = %g (largest finite double)\n&quot;,
            scalbn(nextafter(1,0), 1024));
    // special values
    printf(&quot;scalbn(-0, 10) = %f\n&quot;, scalbn(-0.0, 10));
    printf(&quot;scalbn(-Inf, -1) = %f\n&quot;, scalbn(-INFINITY, -1));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;scalbn(1, 1024) = %f\n&quot;, scalbn(1, 1024));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
scalbn(7, -4) = 0.437500
scalbn(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
scalbn(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
scalbn(-0, 10) = -0.000000
scalbn(-Inf, -1) = -inf
scalbn(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc frexp}}
{{dsc inc | c/numeric/math/dsc ldexp}}
{{dsc see cpp | cpp/numeric/math/scalbn}}
{{dsc end}}

[[de:c/numeric/math/scalbn]]
[[es:c/numeric/math/scalbn]]
[[fr:c/numeric/math/scalbn]]
[[it:c/numeric/math/scalbn]]
[[ja:c/numeric/math/scalbn]]
[[pt:c/numeric/math/scalbn]]
[[ru:c/numeric/math/scalbn]]
[[zh:c/numeric/math/scalbn]]</text>
      <sha1>nmja5vb634f2fwdpl332wb20b0dguky</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/signbit</title>
    <ns>0</ns>
    <id>6253</id>
    <revision>
      <id>70151</id>
      <parentid>69275</parentid>
      <timestamp>2014-05-10T21:30:46Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1144">{{c/title|signbit}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |
#define signbit(arg) /* implementation defined */
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is negative. The macro returns an integral value.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
Nonzero integral value if {{tt|arg}} is negative, {{c|0}} otherwise

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
 
int main(void)
{
    printf(&quot;signbit(+0.0) = %d\n&quot;, signbit(+0.0));
    printf(&quot;signbit(-0.0) = %d\n&quot;, signbit(-0.0));
 
    return 0;
}
 | p=true
 | output=
signbit(+0.0) = 0
signbit(-0.0) = 128
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc fabs}}
{{dsc inc | c/numeric/math/dsc copysign}}
{{dsc see cpp | cpp/numeric/math/signbit}}
{{dsc end}}

[[de:c/numeric/math/signbit]]
[[es:c/numeric/math/signbit]]
[[fr:c/numeric/math/signbit]]
[[it:c/numeric/math/signbit]]
[[ja:c/numeric/math/signbit]]
[[pt:c/numeric/math/signbit]]
[[ru:c/numeric/math/signbit]]
[[zh:c/numeric/math/signbit]]</text>
      <sha1>0odwcwgrmhez3o3sck9urmyr2fagvbj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/sin</title>
    <ns>0</ns>
    <id>6288</id>
    <revision>
      <id>70771</id>
      <parentid>70462</parentid>
      <timestamp>2014-05-30T03:15:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3324">{{c/title|sin, sinf, sinl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       sinf( float arg );
}}
{{dcl |num=2 |
double      sin( double arg );
}}
{{dcl |num=3 | since=c99 |
long double sinl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define sin( arg )
}}
{{dcl end}}

@1-3@ Computes the sine of {{tt|arg}} (measured in radians)
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|sinl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|sin}} is called. Otherwise, {{tt|sinf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|csinf}}, {{c|csin}}, {{c|csinl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing an angle in radians}}
{{par end}}

===Return value===
If no errors occur, the sine of {{tt|arg}} ({{math|sin(arg)}}) in the range {{math|[-1 ; +1]}}, is returned.

{{rev begin}}
{{rev|until=c99|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C, but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sin.html domain error in POSIX]

POSIX also specifies that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, an implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    double pi = acos(-1);
    // typical usage
    printf(&quot;sin(pi/6) = %f\n&quot;, sin(pi/6));
    printf(&quot;sin(pi/2) = %f\n&quot;, sin(pi/2));
    printf(&quot;sin(-3*pi/4) = %f\n&quot;, sin(-3*pi/4));
    // special values
    printf(&quot;sin(+0) = %f\n&quot;, sin(0.0));
    printf(&quot;sin(-0) = %f\n&quot;, sin(-0.0));
    // error handling 
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;sin(INFINITY) = %f\n&quot;, sin(INFINITY));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
sin(pi/6) = 0.500000
sin(pi/2) = 1.000000
sin(-3*pi/4) = -0.707107
sin(+0) = 0.000000
sin(-0) = -0.000000
sin(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc cos}}
{{dsc inc | c/numeric/math/dsc tan}}
{{dsc inc | c/numeric/math/dsc asin}}
{{dsc inc | c/numeric/complex/dsc csin}}
{{dsc see cpp | cpp/numeric/math/sin}}
{{dsc end}}

[[de:c/numeric/math/sin]]
[[es:c/numeric/math/sin]]
[[fr:c/numeric/math/sin]]
[[it:c/numeric/math/sin]]
[[ja:c/numeric/math/sin]]
[[pt:c/numeric/math/sin]]
[[ru:c/numeric/math/sin]]
[[zh:c/numeric/math/sin]]</text>
      <sha1>6qpxi42lo5q2qmbfg8giml2amt7kp8e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/sinh</title>
    <ns>0</ns>
    <id>6294</id>
    <revision>
      <id>70778</id>
      <parentid>70555</parentid>
      <timestamp>2014-05-30T03:17:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note.. really should have made it a template</comment>
      <text xml:space="preserve" bytes="3104">{{c/title|sinh, sinhf, sinhl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       sinhf( float arg );
}}
{{dcl | num=2 |
double      sinh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double sinhl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define sinh( arg )
}}
{{dcl end}}

@1-3@ Computes hyperbolic sine of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|sinhl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|sinh}} is called. Otherwise, {{tt|sinhf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|csinhf}}, {{c|csinh}}, {{c|csinhl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing a hyperbolic angle}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic sine of {{tt|arg}} ({{math|sinh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}-e{{su|p=-arg}}|2}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned unmodified
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/sinh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;sinh(1) = %f\nsinh(-1)=%f\n&quot;, sinh(1), sinh(-1));
    printf(&quot;log(sinh(1) + cosh(1))=%f\n&quot;, log(sinh(1)+cosh(1)));
    // special values
    printf(&quot;sinh(+0) = %f\nsinh(-0)=%f\n&quot;, sinh(0.0), sinh(-0.0));
    // error handling 
    errno=0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;sinh(710.5) = %f\n&quot;, sinh(710.5));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    if(fetestexcept(FE_OVERFLOW)) puts(&quot;    FE_OVERFLOW raised&quot;);
}
 | p=true
 | output=
sinh(1) = 1.175201
sinh(-1)=-1.175201
log(sinh(1) + cosh(1))=1.000000
sinh(+0) = 0.000000
sinh(-0)=-0.000000
sinh(710.5) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc cosh}}
{{dsc inc | c/numeric/math/dsc tanh}}
{{dsc inc | c/numeric/math/dsc asinh}}
{{dsc inc | c/numeric/complex/dsc csinh}}
{{dsc see cpp | cpp/numeric/math/sinh}}
{{dsc end}}

[[de:c/numeric/math/sinh]]
[[es:c/numeric/math/sinh]]
[[fr:c/numeric/math/sinh]]
[[it:c/numeric/math/sinh]]
[[ja:c/numeric/math/sinh]]
[[pt:c/numeric/math/sinh]]
[[ru:c/numeric/math/sinh]]
[[zh:c/numeric/math/sinh]]</text>
      <sha1>7wjnasp35aaw73qwhi1yj3bikklt1og</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/sqrt</title>
    <ns>0</ns>
    <id>6284</id>
    <revision>
      <id>70767</id>
      <parentid>70626</parentid>
      <timestamp>2014-05-30T03:13:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath notes</comment>
      <text xml:space="preserve" bytes="2804">{{c/title|sqrt, sqrtf, sqrtl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1| since=c99 |
float       sqrtf( float arg );
}}
{{dcl |num=2|
double      sqrt( double arg );
}}
{{dcl |num=3| since=c99 |
long double sqrtl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define sqrt( arg )
}}
{{dcl end}}

@1-3@ Computes square root of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|sqrtl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|sqrt}} is called. Otherwise, {{tt|sqrtf}} is called. If {{tt|arg}} is complex, then the macro invokes the corresponding complex function ({{c|csqrtf}}, {{c|csqrt}}, {{c|csqrtl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, square root of {{tt|arg}} ({{math|{{mrad|arg}}}}), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is less than -0, {{lc|FE_INVALID}} is raised and NaN is returned.
* If the argument is +∞ or ±0, it is returned, unmodified.
* If the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON

int main(void)
{
    // normal use
    printf(&quot;sqrt(100) = %f\n&quot;, sqrt(100));
    printf(&quot;sqrt(2) = %f\n&quot;, sqrt(2));
    printf(&quot;golden ratio = %f\n&quot;, (1+sqrt(5))/2);
    // special values
    printf(&quot;sqrt(-0) = %f\n&quot;, sqrt(-0.0));
    // error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;sqrt(-1.0) = %f\n&quot;, sqrt(-1));
    if(errno = EDOM) perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID was raised&quot;);
}
 | p=true
 | output=
sqrt(100) = 10.000000
sqrt(2) = 1.414214
golden ratio = 1.618034
sqrt(-0) = -0.000000
sqrt(-1.0) = -nan
    errno = EDOM: Numerical argument out of domain
    FE_INVALID was raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc pow}}
{{dsc inc | c/numeric/math/dsc cbrt}}
{{dsc inc | c/numeric/math/dsc hypot}}
{{dsc inc | c/numeric/complex/dsc csqrt}}
{{dsc see cpp | cpp/numeric/math/sqrt}}
{{dsc end}}

[[de:c/numeric/math/sqrt]]
[[es:c/numeric/math/sqrt]]
[[fr:c/numeric/math/sqrt]]
[[it:c/numeric/math/sqrt]]
[[ja:c/numeric/math/sqrt]]
[[pt:c/numeric/math/sqrt]]
[[ru:c/numeric/math/sqrt]]
[[zh:c/numeric/math/sqrt]]</text>
      <sha1>cavttdszr3im2nkykb1drxvu8b9hham</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/tan</title>
    <ns>0</ns>
    <id>6290</id>
    <revision>
      <id>70773</id>
      <parentid>70513</parentid>
      <timestamp>2014-05-30T03:16:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="3225">{{c/title|tan, tanf, tanl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl |num=1 |  since=c99 |
float       tanf( float arg );
}}
{{dcl |num=2 | 
double      tan( double arg );
}}
{{dcl | num=3 | since=c99 |
long double tanl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define tan( arg )
}}
{{dcl end}}

@1-3@ Computes the tangent of {{tt|arg}}  (measured in radians).
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|tanl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|tan}} is called. Otherwise, {{tt|tanf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|ctanf}}, {{c|ctan}}, {{c|ctanl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing angle in radians}}
{{par end}}

===Return value===
If no errors occur, the tangent of {{tt|arg}} ({{math|tan(arg)}}) is returned.

{{rev begin}}
{{rev|until=c++11|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C, but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sin.html domain error in POSIX]

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;

#pragma STDC FENV_ACCESS ON
int main(void)
{
    double pi = acos(-1);
    // typical usage
    printf(&quot;tan  (pi/4) = %+f\n&quot;, tan(  pi/4)); // 45 deg.
    printf(&quot;tan(3*pi/4) = %+f\n&quot;, tan(3*pi/4)); // 135 deg
    printf(&quot;tan(5*pi/4) = %+f\n&quot;, tan(5*pi/4)); // -135 deg
    printf(&quot;tan(7*pi/4) = %+f\n&quot;, tan(7*pi/4)); // -45 deg
    // special values
    printf(&quot;tan(+0) = %f\n&quot;, tan(0.0));
    printf(&quot;tan(-0) = %f\n&quot;, tan(-0.0));
    // error handling 
    feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;tan(INFINITY) = %f\n&quot;, tan(INFINITY));
    if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
tan  (pi/4) = +1.000000
tan(3*pi/4) = -1.000000
tan(5*pi/4) = +1.000000
tan(7*pi/4) = -1.000000
tan(+0) = 0.000000
tan(-0) = -0.000000
tan(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc sin}}
{{dsc inc | c/numeric/math/dsc cos}}
{{dsc inc | c/numeric/math/dsc atan}}
{{dsc inc | c/numeric/complex/dsc ctan}}
{{dsc see cpp | cpp/numeric/math/tan}}
{{dsc end}}

[[de:c/numeric/math/tan]]
[[es:c/numeric/math/tan]]
[[fr:c/numeric/math/tan]]
[[it:c/numeric/math/tan]]
[[ja:c/numeric/math/tan]]
[[pt:c/numeric/math/tan]]
[[ru:c/numeric/math/tan]]
[[zh:c/numeric/math/tan]]</text>
      <sha1>c4i7ubiu73pq8g8d8qu6ihzmowf5ko1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/tanh</title>
    <ns>0</ns>
    <id>6295</id>
    <revision>
      <id>70780</id>
      <parentid>70563</parentid>
      <timestamp>2014-05-30T03:18:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed integer types from tgmath note</comment>
      <text xml:space="preserve" bytes="2689">{{c/title|tanh, tanhf, tanhl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | num=1 | since=c99 |
float       tanhf( float arg );
}}
{{dcl | num=2 |
double      tanh( double arg );
}}
{{dcl | num=3 | since=c99 |
long double tanhl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define tanh( arg )
}}
{{dcl end}}

@1-3@ Computes the hyperbolic tangent of {{tt|arg}}
@4@ Type-generic macro: If the argument has type {{c|long double}}, {{tt|tanhl}} is called. Otherwise, if the argument has integer type or the type {{c|double}}, {{tt|tanh}} is called. Otherwise, {{tt|tanhf}} is called. If the argument is complex, then the macro invokes the corresponding complex function ({{c|ctanhf}}, {{c|ctanh}}, {{c|ctanhl}})

===Parameters===
{{par begin}}
{{par | arg | floating point value representing a hyperbolic angle}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic tangent of {{tt|arg}} ({{math|tanh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}-e{{su|p=-arg}}|e{{su|p=arg}}+e{{su|p=-arg}}}}}}) is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, ±0 is returned
* If the argument is ±∞, ±1 is returned
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tanh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;tanh(1) = %f\ntanh(-1) = %f\n&quot;, tanh(1), tanh(-1));
    printf(&quot;tanh(0.1)*sinh(0.2)-cosh(0.2) = %f\n&quot;, tanh(0.1) * sinh(0.2) - cosh(0.2));
    // special values
    printf(&quot;tanh(+0) = %f\ntanh(-0) = %f\n&quot;, tanh(0.0), tanh(-0.0));
}
 | output=
tanh(1) = 0.761594
tanh(-1) = -0.761594
tanh(0.1)*sinh(0.2)-cosh(0.2) = -1.000000
tanh(+0) = 0.000000
tanh(-0) = -0.000000
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc sinh}}
{{dsc inc | c/numeric/math/dsc cosh}}
{{dsc inc | c/numeric/math/dsc atanh}}
{{dsc inc | c/numeric/complex/dsc ctanh}}
{{dsc see cpp | cpp/numeric/math/tanh}}
{{dsc end}}

[[de:c/numeric/math/tanh]]
[[es:c/numeric/math/tanh]]
[[fr:c/numeric/math/tanh]]
[[it:c/numeric/math/tanh]]
[[ja:c/numeric/math/tanh]]
[[pt:c/numeric/math/tanh]]
[[ru:c/numeric/math/tanh]]
[[zh:c/numeric/math/tanh]]</text>
      <sha1>ppnehxa68nyz7zfn54pddtrnnba7g5t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/tgamma</title>
    <ns>0</ns>
    <id>6308</id>
    <revision>
      <id>71182</id>
      <parentid>69537</parentid>
      <timestamp>2014-06-07T21:45:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, shorter example</comment>
      <text xml:space="preserve" bytes="4412">{{c/title|tgamma, tgammaf, tgammal}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 |num=1|
float       tgammaf( float arg );
}}
{{dcl | since=c99 |num=2|
double      tgamma( double arg );
}}
{{dcl | since=c99 |num=3|
long double tgammal( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define lgamma( arg )
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Gamma function|gamma function]] of {{tt|arg}}.
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|lgammal}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|lgamma}} is called. Otherwise, {{tt|lgammaf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the value of the gamma function of {{tt|arg}}, that is {{math|{{minteg|0|∞|''t''{{su|p=arg-1}} {{mexp|-t}} d''t''}}}}, is returned

If a domain error occurs, an implementation-defined value (NaN where supported) is returned.

If a pole error occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If {{tt|arg}} is zero or is an integer less than zero, a pole error or a domain error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, ±∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is a negative integer, NaN is returned and {{lc|FE_INVALID}} is raised
* If the argument is -∞, NaN is returned and {{lc|FE_INVALID}} is raised
* If the argument is +∞, +∞ is returned.
* If the argument is NaN, NaN is returned

===Notes===
If {{tt|arg}} is a natural number, {{c|tgamma(arg)}} is the factorial of {{tt|arg-1}}. Many implementations calculate the exact integer-domain factorial if the argument is a sufficiently small integer.

For IEEE-compatible type {{c|double}}, overflow happens if {{tt|0 &lt; x &lt; 1/DBL_MAX}} or if {{tt|x &gt; 171.7}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tgamma.html POSIX requires] that a pole error occurs if the argument is zero, but a domain error occurs when the argument is a negative integer. It also specifies that in future, domain errors may be replaced by pole errors for negative integer arguments (in which case the return value in those cases would change from NaN to ±∞).

There is a non-standard function named {{tt|gamma}} in various implementations, but its definition is inconsistent. For example, glibc and 4.2BSD version of {{tt|gamma}} executes {{tt|lgamma}}, but 4.4BSD version of {{tt|gamma}} executes {{tt|tgamma}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;float.h&gt;
#include &lt;errno.h&gt;
#include &lt;fenv.h&gt;
#pragma STDC FENV_ACCESS ON
int main(void)
{
    printf(&quot;tgamma(10) = %f, 9!=%f\n&quot;, tgamma(10), 2*3*4*5*6*7*8*9.0);
    printf(&quot;tgamma(0.5) = %f, sqrt(pi) = %f\n&quot;, sqrt(acos(-1)), tgamma(0.5));
    // special values
    printf(&quot;tgamma(+Inf) = %f\n&quot;, tgamma(INFINITY));
    //error handling
    errno = 0; feclearexcept(FE_ALL_EXCEPT);
    printf(&quot;tgamma(-1) = %f\n&quot;, tgamma(-1));
    if(errno == ERANGE) perror(&quot;    errno == ERANGE&quot;);
    else if(errno == EDOM)   perror(&quot;    errno == EDOM&quot;);
    if(fetestexcept(FE_DIVBYZERO)) puts(&quot;    FE_DIVBYZERO raised&quot;);
    else if(fetestexcept(FE_INVALID)) puts(&quot;    FE_INVALID raised&quot;);
}
 | p=true
 | output=
tgamma(10) = 362880.000000, 9!=362880.000000
tgamma(0.5) = 1.772454, sqrt(pi) = 1.772454
tgamma(+Inf) = inf
tgamma(-1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc lgamma}}
{{dsc see cpp | cpp/numeric/math/tgamma}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/GammaFunction.html Weisstein, Eric W. &quot;Gamma Function.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:c/numeric/math/tgamma]]
[[es:c/numeric/math/tgamma]]
[[fr:c/numeric/math/tgamma]]
[[it:c/numeric/math/tgamma]]
[[ja:c/numeric/math/tgamma]]
[[pt:c/numeric/math/tgamma]]
[[ru:c/numeric/math/tgamma]]
[[zh:c/numeric/math/tgamma]]</text>
      <sha1>1iqsa1bxry2tjrwd9gshxefj5k1c21p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/math/trunc</title>
    <ns>0</ns>
    <id>6305</id>
    <revision>
      <id>71878</id>
      <parentid>69571</parentid>
      <timestamp>2014-06-30T18:08:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+details, shorter example</comment>
      <text xml:space="preserve" bytes="2753">{{c/title|trunc|truncf|truncl}}
{{c/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | math.h}}
{{dcl | since=c99 | num=1|
float       truncf( float arg );
}}
{{dcl | since=c99 | num=2|
double      trunc( double arg );
}}
{{dcl | since=c99 | num=3|
long double truncl( long double arg );
}}
{{dcl header | tgmath.h}}
{{dcl |num=4| since=c99 |
#define trunc( arg )
}}
{{dcl end}}

@1-3@ Computes the nearest integer not greater in magnitude than {{tt|arg}}. 
@4@ Type-generic macro: If {{tt|arg}} has type {{c|long double}}, {{tt|truncl}} is called. Otherwise, if {{tt|arg}} has integer type or the type {{c|double}}, {{tt|trunc}} is called. Otherwise, {{tt|truncf}} is called.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value not greater in magnitude than {{tt|arg}} (in other words, {{tt|arg}} rounded towards zero), is returned.

{{plot | left=Return value | bottom=Argument | math-trunc.svg}}

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[c/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when truncating a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|intmax_t}}), when stored in an integer variable.

The implicit conversion from floating-point to integral types also rounds towards zero, but is limited to the values that can be represented by the target type.

===Example===
{{example |
 | code=
#include &lt;math.h&gt;
#include &lt;stdio.h&gt;
int main(void)
{
    printf(&quot;trunc(+2.7) = %+.1f\n&quot;, trunc(2.7));
    printf(&quot;trunc(-2.7) = %+.1f\n&quot;, trunc(-2.7));
    printf(&quot;trunc(-0.0) = %+.1f\n&quot;, trunc(-0.0));
    printf(&quot;trunc(-Inf) = %+f\n&quot;,   trunc(-INFINITY));
}
 | p=true
 | output=
trunc(+2.7) = +2.0
trunc(-2.7) = -2.0
trunc(-0.0) = -0.0
trunc(-Inf) = -inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/math/dsc floor}}
{{dsc inc | c/numeric/math/dsc ceil}}
{{dsc inc | c/numeric/math/dsc round}}
{{dsc see cpp | cpp/numeric/math/trunc}}
{{dsc end}}

[[de:c/numeric/math/trunc]]
[[es:c/numeric/math/trunc]]
[[fr:c/numeric/math/trunc]]
[[it:c/numeric/math/trunc]]
[[ja:c/numeric/math/trunc]]
[[pt:c/numeric/math/trunc]]
[[ru:c/numeric/math/trunc]]
[[zh:c/numeric/math/trunc]]</text>
      <sha1>gazfn1rgl8dh0rzj1gnt8o7z0jevvv6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/random</title>
    <ns>0</ns>
    <id>6411</id>
    <revision>
      <id>71064</id>
      <parentid>56678</parentid>
      <timestamp>2014-06-05T01:40:48Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ See also C++</comment>
      <text xml:space="preserve" bytes="553">{{title|Pseudo-random number generation}}
{{c/numeric/random/navbar}}

{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc inc | c/numeric/random/dsc rand}}
{{dsc inc | c/numeric/random/dsc srand}}
{{dsc inc | c/numeric/random/dsc RAND_MAX}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/numeric/random | Pseudo-random number generation}}
{{dsc end}}

[[de:c/numeric/random]]
[[es:c/numeric/random]]
[[fr:c/numeric/random]]
[[it:c/numeric/random]]
[[ja:c/numeric/random]]
[[pt:c/numeric/random]]
[[ru:c/numeric/random]]
[[zh:c/numeric/random]]</text>
      <sha1>lqd8chjvwwzoxu8eembpaj84em2tiqq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/random/RAND MAX</title>
    <ns>0</ns>
    <id>6417</id>
    <revision>
      <id>64295</id>
      <parentid>56679</parentid>
      <timestamp>2013-08-15T16:24:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="761">{{title|RAND_MAX}}
{{c/numeric/random/navbar}}
{{ddcl | header=stdlib.h |
#define RAND_MAX /*implementation defined*/
}}

Expands to an integer constant expression equal to the maximum value returned by the function {{lc|rand()}}. This value is implementation dependent. It's guaranteed that this value is at least {{c|32767}}.

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/random/dsc rand}}
{{dsc inc | c/numeric/random/dsc srand}}
{{dsc see cpp | cpp/numeric/random/RAND_MAX}}
{{dsc end}}

[[de:c/numeric/random/RAND MAX]]
[[es:c/numeric/random/RAND MAX]]
[[fr:c/numeric/random/RAND MAX]]
[[it:c/numeric/random/RAND MAX]]
[[ja:c/numeric/random/RAND MAX]]
[[pt:c/numeric/random/RAND MAX]]
[[ru:c/numeric/random/RAND MAX]]
[[zh:c/numeric/random/RAND MAX]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/random/rand</title>
    <ns>0</ns>
    <id>6416</id>
    <revision>
      <id>71059</id>
      <parentid>64296</parentid>
      <timestamp>2014-06-05T01:34:16Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to RAND_MAX</comment>
      <text xml:space="preserve" bytes="1861">{{c/title|rand}}
{{c/numeric/random/navbar}}
{{ddcl | header=stdlib.h | 
int rand();
}}

Returns a pseudo-random integral value between {{c|0}} and {{lc|RAND_MAX}} (0 and {{tt|RAND_MAX}} included).

{{lc|srand()}} seeds the pseudo-random number generator used by {{tt|rand()}}.
If {{tt|rand()}} is used before any calls to {{tt|srand()}}, {{tt|rand()}} behaves as if it was seeded with {{tt|srand(1)}}.
Each time {{tt|rand()}} is seeded with {{tt|srand()}}, it must produce the same sequence of values.

{{tt|rand()}} is not guaranteed to be thread-safe.

===Parameters===
(none)

===Return value===
Pseudo-random integral value between {{c|0}} and {{lc|RAND_MAX}}.

===Notes===
There are no guarantees as to the quality of the random sequence produced.
In the past, some implementations of {{tt|rand()}} have had serious shortcomings in the randomness, distribution and period of the sequence produced (in one well-known example, the low-order bit simply alternated between {{tt|1}} and {{tt|0}} between calls).
{{tt|rand()}} is not recommended for serious random-number generation needs, like cryptography.

===Example===
{{example
 | p=true
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;time.h&gt;

int main(void)
{
    srand(time(0)); //use current time as seed for random generator
    int random_variable = rand();
    printf(&quot;Random value on [0,%d]: %d\n&quot;, RAND_MAX, random_variable);
}
 | output=
Random value on [0 2147483647]: 1373858591
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/random/dsc srand}}
{{dsc inc | c/numeric/random/dsc RAND_MAX}}
{{dsc see cpp | cpp/numeric/random/rand}}
{{dsc end}}

[[de:c/numeric/random/rand]]
[[es:c/numeric/random/rand]]
[[fr:c/numeric/random/rand]]
[[it:c/numeric/random/rand]]
[[ja:c/numeric/random/rand]]
[[pt:c/numeric/random/rand]]
[[ru:c/numeric/random/rand]]
[[zh:c/numeric/random/rand]]</text>
      <sha1>m6gwluqzr0teh26my6lazddfmqhbrsm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/random/srand</title>
    <ns>0</ns>
    <id>6415</id>
    <revision>
      <id>71060</id>
      <parentid>64297</parentid>
      <timestamp>2014-06-05T01:34:52Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to RAND_MAX</comment>
      <text xml:space="preserve" bytes="1945">{{c/title|srand}}
{{c/numeric/random/navbar}}
{{ddcl | header=stdlib.h | 
void srand( unsigned seed );
}}

Seeds the pseudo-random number generator used by {{lc|rand()}} with the value {{tt|seed}}.

If {{tt|rand()}} is used before any calls to {{tt|srand()}}, {{tt|rand()}} behaves as if it was seeded with {{tt|srand(1)}}.
Each time {{tt|rand()}} is seeded with {{tt|srand()}}, it must produce the same sequence of values.

{{tt|srand()}} is not guaranteed to be thread-safe.

===Parameters===
{{par begin}}
{{par | seed | the seed value}}
{{par end}}

===Return value===
(none)

===Notes===
Generally speaking, the pseudo-random number generator should only be seeded once, before any calls to {{tt|rand()}}, and the start of the program.
It should not be repeatedly seeded, or reseeded every time you wish to generate a new batch of pseudo-random numbers.

Standard practice is to use the result of a call to {{c|time(0)}} as the seed.
However, {{tt|time()}} returns a {{lc|time_t}} value, and {{tt|time_t}} is not guaranteed to be an integral type.
In practice, though, every major implementation defines {{tt|time_t}} to be an integral type, and this is also what POSIX requires.

===Example===
{{example
 | p=true
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;time.h&gt;

int main(void)
{
    srand(time(0)); //use current time as seed for random generator
    int random_variable = rand();
    printf(&quot;Random value on [0,%d]: %d\n&quot;, RAND_MAX, random_variable);
}
 | output=
Random value on [0 2147483647]: 1373858591
}}

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/random/dsc rand}}
{{dsc inc | c/numeric/random/dsc RAND_MAX}}
{{dsc see cpp | cpp/numeric/random/srand}}
{{dsc end}}

[[de:c/numeric/random/srand]]
[[es:c/numeric/random/srand]]
[[fr:c/numeric/random/srand]]
[[it:c/numeric/random/srand]]
[[ja:c/numeric/random/srand]]
[[pt:c/numeric/random/srand]]
[[ru:c/numeric/random/srand]]
[[zh:c/numeric/random/srand]]</text>
      <sha1>dzyv7m8kj7okisbkv3lhjnp96nwqzpv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/numeric/tgmath</title>
    <ns>0</ns>
    <id>6422</id>
    <revision>
      <id>70934</id>
      <parentid>70933</parentid>
      <timestamp>2014-06-03T16:29:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>also fix the link (fabs was linking to labs etc)</comment>
      <text xml:space="preserve" bytes="12302">{{title|Type-generic math}}
{{c/numeric/navbar}}

The header {{tt|&lt;tgmath.h&gt;}} includes the headers {{tt|&lt;math.h&gt;}} and {{tt|&lt;complex.h&gt;}} and defines several type-generic macros. These macros determines the actual function to call depending on the types of the parameters.

===Exponential, power, trigonometric and hyperbolic functions {{mark since c99}}===

A type-generic macro {{tt|XXX}} calls either of:
* real function:
:* {{c|float}} variant {{tt|XXXf}}
:* {{c|double}} variant {{tt|XXX}}
:* {{c|long double}} variant {{tt|XXXl}}
* complex function:
:* {{c|float}} variant {{tt|cXXXf}}
:* {{c|double}} variant {{tt|cXXX}}
:* {{c|long double}} variant {{tt|cXXXl}}

An exception to the above rule is {{tt|exp}} (see the table below).

The function to call is determined as follows:

* If any of the parameters is complex, then the complex function is called, otherwise the real function is called.
* If any of the parameters is {{c|long double}}, then the {{c|long double}} variant is called. Otherwise, if any of the parameters is {{c|double}} or integer, then the {{c|double}} variant is called. Otherwise, {{c|float}} variant is called.
* The behavior is undefined if any of the parameters are incompatible with the corresponding argument of the function. {{todo|what's meant by incompatible?}}

The type-generic macros are as follows:

{| class=&quot;wikitable&quot;
|-
! Type-generic macro
! colspan=3 | Real function &lt;br&gt; variants 
! colspan=3 | Complex function &lt;br&gt; variants
|-
! style=&quot;height: 8em;&quot; | &amp;nbsp;
! {{vertical|{{c|float}}}}
! {{vertical|{{c|double}}}} 
! {{vertical|{{c|long double}}}} 
! {{vertical|{{c|float}}}}
! {{vertical|{{c|double}}}} 
! {{vertical|{{c|long double}}}} 
|-
! fabs
| {{ltt|c/numeric/math/fabs|fabsf}}
| {{ltt|c/numeric/math/fabs|fabs}}
| {{ltt|c/numeric/math/fabs|fabsl}}
| {{ltt|c/numeric/complex/cabs|cabsf}}
| {{ltt|c/numeric/complex/cabs|cabs}}
| {{ltt|c/numeric/complex/cabs|cabsl}}
|-
! exp
| {{ltt|c/numeric/math/exp|expf}}
| {{ltt|c/numeric/math/exp|exp}}
| {{ltt|c/numeric/math/exp|expl}}
| {{ltt|c/numeric/complex/cexp|cexpf}}
| {{ltt|c/numeric/complex/cexp|cexp}}
| {{ltt|c/numeric/complex/cexp|cexpl}}
|-
! log
| {{ltt|c/numeric/math/log|logf}}
| {{ltt|c/numeric/math/log|log}}
| {{ltt|c/numeric/math/log|logl}}
| {{ltt|c/numeric/complex/clog|clogf}}
| {{ltt|c/numeric/complex/clog|clog}}
| {{ltt|c/numeric/complex/clog|clogl}}
|-
! pow
| {{ltt|c/numeric/math/pow|powf}}
| {{ltt|c/numeric/math/pow|pow}}
| {{ltt|c/numeric/math/pow|powl}}
| {{ltt|c/numeric/complex/cpow|cpowf}}
| {{ltt|c/numeric/complex/cpow|cpow}}
| {{ltt|c/numeric/complex/cpow|cpowl}}
|-
! sqrt
| {{ltt|c/numeric/math/sqrt|sqrtf}}
| {{ltt|c/numeric/math/sqrt|sqrt}}
| {{ltt|c/numeric/math/sqrt|sqrtl}}
| {{ltt|c/numeric/complex/csqrt|csqrtf}}
| {{ltt|c/numeric/complex/csqrt|csqrt}}
| {{ltt|c/numeric/complex/csqrt|csqrtl}}
|-
! sin
| {{ltt|c/numeric/math/sin|sinf}}
| {{ltt|c/numeric/math/sin|sin}}
| {{ltt|c/numeric/math/sin|sinl}}
| {{ltt|c/numeric/complex/csin|csinf}}
| {{ltt|c/numeric/complex/csin|csin}}
| {{ltt|c/numeric/complex/csin|csinl}}
|-
! cos
| {{ltt|c/numeric/math/cos|cosf}}
| {{ltt|c/numeric/math/cos|cos}}
| {{ltt|c/numeric/math/cos|cosl}}
| {{ltt|c/numeric/complex/ccos|ccosf}}
| {{ltt|c/numeric/complex/ccos|ccos}}
| {{ltt|c/numeric/complex/ccos|ccosl}}
|-
! tan
| {{ltt|c/numeric/math/tan|tanf}}
| {{ltt|c/numeric/math/tan|tan}}
| {{ltt|c/numeric/math/tan|tanl}}
| {{ltt|c/numeric/complex/ctan|ctanf}}
| {{ltt|c/numeric/complex/ctan|ctan}}
| {{ltt|c/numeric/complex/ctan|ctanl}}
|-
! asin
| {{ltt|c/numeric/math/asin|asinf}}
| {{ltt|c/numeric/math/asin|asin}}
| {{ltt|c/numeric/math/asin|asinl}}
| {{ltt|c/numeric/complex/casin|casinf}}
| {{ltt|c/numeric/complex/casin|casin}}
| {{ltt|c/numeric/complex/casin|casinl}}
|-
! acos
| {{ltt|c/numeric/math/acos|acosf}}
| {{ltt|c/numeric/math/acos|acos}}
| {{ltt|c/numeric/math/acos|acosl}}
| {{ltt|c/numeric/complex/cacos|cacosf}}
| {{ltt|c/numeric/complex/cacos|cacos}}
| {{ltt|c/numeric/complex/cacos|cacosl}}
|-
! atan
| {{ltt|c/numeric/math/atan|atanf}}
| {{ltt|c/numeric/math/atan|atan}}
| {{ltt|c/numeric/math/atan|atanl}}
| {{ltt|c/numeric/complex/catan|catanf}}
| {{ltt|c/numeric/complex/catan|catan}}
| {{ltt|c/numeric/complex/catan|catanl}}
|-
! sinh
| {{ltt|c/numeric/math/sinh|sinhf}}
| {{ltt|c/numeric/math/sinh|sinh}}
| {{ltt|c/numeric/math/sinh|sinhl}}
| {{ltt|c/numeric/complex/csinh|csinhf}}
| {{ltt|c/numeric/complex/csinh|csinh}}
| {{ltt|c/numeric/complex/csinh|csinhl}}
|-
! cosh
| {{ltt|c/numeric/math/cosh|coshf}}
| {{ltt|c/numeric/math/cosh|cosh}}
| {{ltt|c/numeric/math/cosh|coshl}}
| {{ltt|c/numeric/complex/ccosh|ccoshf}}
| {{ltt|c/numeric/complex/ccosh|ccosh}}
| {{ltt|c/numeric/complex/ccosh|ccoshl}}
|-
! tanh
| {{ltt|c/numeric/math/tanh|tanhf}}
| {{ltt|c/numeric/math/tanh|tanh}}
| {{ltt|c/numeric/math/tanh|tanhl}}
| {{ltt|c/numeric/complex/ctanh|ctanhf}}
| {{ltt|c/numeric/complex/ctanh|ctanh}}
| {{ltt|c/numeric/complex/ctanh|ctanhl}}
|-
! asinh
| {{ltt|c/numeric/math/asinh|asinhf}}
| {{ltt|c/numeric/math/asinh|asinh}}
| {{ltt|c/numeric/math/asinh|asinhl}}
| {{ltt|c/numeric/complex/casinh|casinhf}}
| {{ltt|c/numeric/complex/casinh|casinh}}
| {{ltt|c/numeric/complex/casinh|casinhl}}
|-
! acosh
| {{ltt|c/numeric/math/acosh|acoshf}}
| {{ltt|c/numeric/math/acosh|acosh}}
| {{ltt|c/numeric/math/acosh|acoshl}}
| {{ltt|c/numeric/complex/cacosh|cacoshf}}
| {{ltt|c/numeric/complex/cacosh|cacosh}}
| {{ltt|c/numeric/complex/cacosh|cacoshl}}
|-
! atanh
| {{ltt|c/numeric/math/atanh|atanhf}}
| {{ltt|c/numeric/math/atanh|atanh}}
| {{ltt|c/numeric/math/atanh|atanhl}}
| {{ltt|c/numeric/complex/catanh|catanhf}}
| {{ltt|c/numeric/complex/catanh|catanh}}
| {{ltt|c/numeric/complex/catanh|catanhl}}
|}

===Miscellaneous functions {{mark since c99}}===

A type-generic macro {{tt|XXX}} calls either of the variants of a real function:
* {{c|float}} variant {{tt|XXXf}}
* {{c|double}} variant {{tt|XXX}}
* {{c|long double}} variant {{tt|XXXl}}

Note, there's no {{tt|modf}} type-generic macro.

The function to call is determined as follows:
* If any of the parameters is {{c|long double}}, then the {{c|long double}} variant is called. Otherwise, if any of the parameters is {{c|double}}, then the {{c|double}} variant is called. Otherwise, {{c|float}} variant is called.
* The behavior is undefined is any of the parameters is incompatible with the corresponding argument of the function. {{todo|what's meant by incompatible?}}

{| class=&quot;wikitable&quot;
|-
! Type-generic macro
! colspan=3 | Real function &lt;br&gt; variants 
|-
! style=&quot;height: 8em;&quot; | &amp;nbsp;
! {{vertical|{{c|float}}}}
! {{vertical|{{c|double}}}} 
! {{vertical|{{c|long double}}}} 
|-
! atan2
| {{ltt|c/numeric/math/atan2|atan2f}}
| {{ltt|c/numeric/math/atan2|atan2}}
| {{ltt|c/numeric/math/atan2|atan2l}}
|-
! cbrt
| {{ltt|c/numeric/math/cbrt|cbrtf}}
| {{ltt|c/numeric/math/cbrt|cbrt}}
| {{ltt|c/numeric/math/cbrt|cbrtl}}
|-
! ceil
| {{ltt|c/numeric/math/ceil|ceilf}}
| {{ltt|c/numeric/math/ceil|ceil}}
| {{ltt|c/numeric/math/ceil|ceill}}
|-
! copysign
| {{ltt|c/numeric/math/copysign|copysignf}}
| {{ltt|c/numeric/math/copysign|copysign}}
| {{ltt|c/numeric/math/copysign|copysignl}}
|-
! erf
| {{ltt|c/numeric/math/erf|erff}}
| {{ltt|c/numeric/math/erf|erf}}
| {{ltt|c/numeric/math/erf|erfl}}
|-
! erfc
| {{ltt|c/numeric/math/erfc|erfcf}}
| {{ltt|c/numeric/math/erfc|erfc}}
| {{ltt|c/numeric/math/erfc|erfcl}}
|-
! exp2
| {{ltt|c/numeric/math/exp2|exp2f}}
| {{ltt|c/numeric/math/exp2|exp2}}
| {{ltt|c/numeric/math/exp2|exp2l}}
|-
! expm1
| {{ltt|c/numeric/math/expm1|expm1f}}
| {{ltt|c/numeric/math/expm1|expm1}}
| {{ltt|c/numeric/math/expm1|expm1l}}
|-
! fdim
| {{ltt|c/numeric/math/fdim|fdimf}}
| {{ltt|c/numeric/math/fdim|fdim}}
| {{ltt|c/numeric/math/fdim|fdiml}}
|-
! floor
| {{ltt|c/numeric/math/floor|floorf}}
| {{ltt|c/numeric/math/floor|floor}}
| {{ltt|c/numeric/math/floor|floorl}}
|-
! fma
| {{ltt|c/numeric/math/fma|fmaf}}
| {{ltt|c/numeric/math/fma|fma}}
| {{ltt|c/numeric/math/fma|fmal}}
|-
! fmax
| {{ltt|c/numeric/math/fmax|fmaxf}}
| {{ltt|c/numeric/math/fmax|fmax}}
| {{ltt|c/numeric/math/fmax|fmaxl}}
|-
! fmin
| {{ltt|c/numeric/math/fmin|fminf}}
| {{ltt|c/numeric/math/fmin|fmin}}
| {{ltt|c/numeric/math/fmin|fminl}}
|-
! fmod
| {{ltt|c/numeric/math/fmod|fmodf}}
| {{ltt|c/numeric/math/fmod|fmod}}
| {{ltt|c/numeric/math/fmod|fmodl}}
|-
! frexp
| {{ltt|c/numeric/math/frexp|frexpf}}
| {{ltt|c/numeric/math/frexp|frexp}}
| {{ltt|c/numeric/math/frexp|frexpl}}
|-
! hypot
| {{ltt|c/numeric/math/hypot|hypotf}}
| {{ltt|c/numeric/math/hypot|hypot}}
| {{ltt|c/numeric/math/hypot|hypotl}}
|-
! ilogb
| {{ltt|c/numeric/math/ilogb|ilogbf}}
| {{ltt|c/numeric/math/ilogb|ilogb}}
| {{ltt|c/numeric/math/ilogb|ilogbl}}
|-
! ldexp
| {{ltt|c/numeric/math/ldexp|ldexpf}}
| {{ltt|c/numeric/math/ldexp|ldexp}}
| {{ltt|c/numeric/math/ldexp|ldexpl}}
|-
! lgamma
| {{ltt|c/numeric/math/lgamma|lgammaf}}
| {{ltt|c/numeric/math/lgamma|lgamma}}
| {{ltt|c/numeric/math/lgamma|lgammal}}
|-
! llrint
| {{ltt|c/numeric/math/rint|llrintf}}
| {{ltt|c/numeric/math/rint|llrint}}
| {{ltt|c/numeric/math/rint|llrintl}}
|-
! llround
| {{ltt|c/numeric/math/round|llroundf}}
| {{ltt|c/numeric/math/round|llround}}
| {{ltt|c/numeric/math/round|llroundl}}
|-
! log10
| {{ltt|c/numeric/math/log10|log10f}}
| {{ltt|c/numeric/math/log10|log10}}
| {{ltt|c/numeric/math/log10|log10l}}
|-
! log1p
| {{ltt|c/numeric/math/log1p|log1pf}}
| {{ltt|c/numeric/math/log1p|log1p}}
| {{ltt|c/numeric/math/log1p|log1pl}}
|-
! log2
| {{ltt|c/numeric/math/log2|log2f}}
| {{ltt|c/numeric/math/log2|log2}}
| {{ltt|c/numeric/math/log2|log2l}}
|-
! logb
| {{ltt|c/numeric/math/logb|logbf}}
| {{ltt|c/numeric/math/logb|logb}}
| {{ltt|c/numeric/math/logb|logbl}}
|-
! lrint
| {{ltt|c/numeric/math/rint|lrintf}}
| {{ltt|c/numeric/math/rint|lrint}}
| {{ltt|c/numeric/math/rint|lrintl}}
|-
! lround
| {{ltt|c/numeric/math/round|lroundf}}
| {{ltt|c/numeric/math/round|lround}}
| {{ltt|c/numeric/math/round|lroundl}}
|-
! nearbyint
| {{ltt|c/numeric/math/nearbyint|nearbyintf}}
| {{ltt|c/numeric/math/nearbyint|nearbyint}}
| {{ltt|c/numeric/math/nearbyint|nearbyintl}}
|-
! nextafter
| {{ltt|c/numeric/math/nextafter|nextafterf}}
| {{ltt|c/numeric/math/nextafter|nextafter}}
| {{ltt|c/numeric/math/nextafter|nextafterl}}
|-
! nexttoward
| {{ltt|c/numeric/math/nextafter|nexttowardf}}
| {{ltt|c/numeric/math/nextafter|nexttoward}}
| {{ltt|c/numeric/math/nextafter|nexttowardl}}
|-
! remainder
| {{ltt|c/numeric/math/remainder|remainderf}}
| {{ltt|c/numeric/math/remainder|remainder}}
| {{ltt|c/numeric/math/remainder|remainderl}}
|-
! remquo
| {{ltt|c/numeric/math/remquo|remquof}}
| {{ltt|c/numeric/math/remquo|remquo}}
| {{ltt|c/numeric/math/remquo|remquol}}
|-
! rint
| {{ltt|c/numeric/math/rint|rintf}}
| {{ltt|c/numeric/math/rint|rint}}
| {{ltt|c/numeric/math/rint|rintl}}
|-
! round
| {{ltt|c/numeric/math/round|roundf}}
| {{ltt|c/numeric/math/round|round}}
| {{ltt|c/numeric/math/round|roundl}}
|-
! scalbln
| {{ltt|c/numeric/math/scalbn|scalblnf}}
| {{ltt|c/numeric/math/scalbn|scalbln}}
| {{ltt|c/numeric/math/scalbn|scalblnl}}
|-
! scalbn
| {{ltt|c/numeric/math/scalbn|scalbnf}}
| {{ltt|c/numeric/math/scalbn|scalbn}}
| {{ltt|c/numeric/math/scalbn|scalbnl}}
|-
! tgamma
| {{ltt|c/numeric/math/tgamma|tgammaf}}
| {{ltt|c/numeric/math/tgamma|tgamma}}
| {{ltt|c/numeric/math/tgamma|tgammal}}
|-
! trunc
| {{ltt|c/numeric/math/trunc|truncf}}
| {{ltt|c/numeric/math/trunc|trunc}}
| {{ltt|c/numeric/math/trunc|truncl}}
|}

=== Example ===
{{example
|code=
#include &lt;stdio.h&gt;
#include &lt;tgmath.h&gt;

int main(void)
{
                            // macro          -&gt; function call
    int i = 1;
    printf(&quot;cos(1) = %f\n&quot;,    cos(i) );   // -&gt; cos(i)

    float f = 0.5;
    printf(&quot;sin(0.5) = %f\n&quot;,  sin(f) );   // -&gt; sinf(f)

    long double ld = 1;
    printf(&quot;acos(1) = %Lf\n&quot;,  acos(ld));  // -&gt; acosl(d)

    double complex dc = 1 + 0.5*I;
    double complex result = sqrt(dc);      // -&gt; csqrt(dc);
    printf(&quot;sqrt(1 + 0.5i) = %f+%fi\n&quot;, creal(result), cimag(result));
}
|output=
cos(1) = 0.540302
sin(0.5) = 0.479426
acos(1) = 0.000000
sqrt(1 + 0.5i) = 1.029086+0.242934i
}}

[[de:c/numeric/tgmath]]
[[es:c/numeric/tgmath]]
[[fr:c/numeric/tgmath]]
[[it:c/numeric/tgmath]]
[[ja:c/numeric/tgmath]]
[[pt:c/numeric/tgmath]]
[[ru:c/numeric/tgmath]]
[[zh:c/numeric/tgmath]]</text>
      <sha1>p3bt6r3j5d9jmbz9ff0sczwkn4jireo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor</title>
    <ns>0</ns>
    <id>12665</id>
    <revision>
      <id>72164</id>
      <parentid>70945</parentid>
      <timestamp>2014-07-19T14:37:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no #warning in C</comment>
      <text xml:space="preserve" bytes="2183">{{title|Preprocessor}}
{{c/preprocessor/navbar}}
The preprocessor is executed at [[c/language/translation_phases|translation phase 4]], before the compilation. The result of preprocessing is single file which is then passed to the actual compiler.

===Directives===

The preprocessing directives control the behavior of the preprocessor. Each directive occupies one line and has the following format:

* {{tt|#}} character
* preprocessing instruction (one of {{tt|define}}, {{tt|undef}}, {{tt|include}}, {{tt|if}}, {{tt|ifdef}}, {{tt|ifndef}}, {{tt|else}}, {{tt|elif}}, {{tt|endif}}, {{tt|line}}, {{tt|error}}, {{tt|pragma}}) &lt;ref&gt;These are the directives defined by the standard. The standard does not define behavior for other directives: they might be ignored, have some useful meaning, or make the program ill-formed. Even if otherwise ignored, they are removed from the source code when the preprocessor is done. A common non-standard extension is the directive {{tt|#warning}} which emits a user-defined message during compilation.&lt;/ref&gt;
* arguments (depends on the instruction)
* line break

The null directive ({{tt|#}} followed by a line break) is allowed and has no effect.

===Capabilities===

The preprocessor has the source file translation capabilities:

* '''{{rl | conditional | conditionally}}''' compile of parts of source file (controlled by directive {{tt|#if}}, {{tt|#ifdef}}, {{tt|#ifndef}}, {{tt|#else}}, {{tt|#elif}} and {{tt|#endif}}).
* '''{{rl | replace}}''' text macros while possibly concatenating or quoting identifiers (controlled by directives {{tt|#define}} and {{tt|#undef}}, and operators {{tt|#}} and {{tt|##}})
* '''{{rl|include}}''' other files (controlled by directive {{tt|#include}})
* cause an '''{{rl|error}}''' (controlled by directive {{tt|#error}})

The following aspects of the preprocessor can be controlled:
* '''{{rl|impl | implementation defined}}''' behavior (controlled by directives {{tt|#pragma}})
* '''{{rl|line | file name and line information}}''' available to the preprocessor (controlled by directives {{tt|#line}})

===Footnotes===
&lt;references/&gt;

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/preprocessor}}
{{dsc end}}</text>
      <sha1>4qm3kcbo75udxqdtjo9zljue3ex7o5w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/conditional</title>
    <ns>0</ns>
    <id>12666</id>
    <revision>
      <id>64456</id>
      <parentid>64359</parentid>
      <timestamp>2013-08-17T21:58:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3614">{{title|Conditional inclusion}}
{{c/preprocessor/navbar}}
The preprocessor supports conditional compilation of parts of source file. This behavior is controlled by {{tt|#if}}, {{tt|#else}}, {{tt|#elif}}, {{tt|#ifdef}}, {{tt|#ifndef}} and {{tt|#endif}} directives.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#if}} {{spar|expression}} }}
{{sdsc | {{ttb|#ifdef}} {{spar|expression}} }}
{{sdsc | {{ttb|#ifndef}} {{spar|expression}} }}
{{sdsc | {{ttb|#elif}} {{spar|expression}} }}
{{sdsc | {{ttb|#else}} }}
{{sdsc | {{ttb|#endif}} }}
{{sdsc end}}

===Explanation===

The conditional preprocessing block starts with {{tt|#if}}, {{tt|#ifdef}} or {{tt|#ifndef}} directive, then optionally includes any number of {{tt|#elif}} directives, then optionally includes at most one {{tt|#else}} directive and is terminated with {{tt|#endif}} directive. Any inner conditional preprocessing blocks are processed separately.

Each of {{tt|#if}}, {{tt|#elif}}, {{tt|#else}}, {{tt|#ifdef}} and {{tt|#ifndef}} directives control code block until first {{tt|#elif}}, {{tt|#else}}, {{tt|#endif}} directive not belonging to any inner conditional preprocessing blocks. 

{{tt|#if}}, {{tt|#ifdef}} and {{tt|#ifndef}}  directives test the specified condition (see below) and if it evaluates to true, compiles the controlled code block. In that case subsequent {{tt|#else}} and {{tt|#elif}} directives are ignored. Otherwise, if the specified condition evaluates false, the controlled code block is skipped and the subsequent {{tt|#else}} or {{tt|#elif}} directive (if any) is processed. In the former case, the code block controlled by the {{tt|#else}} directive is unconditionally compiled. In the latter case, the {{tt|#elif}} directive acts as if it was {{tt|#if}} directive: checks for condition, compiles or skips the controlled code block based on the result, and in the latter case processes subsequent {{tt|#elif}} and {{tt|#else}} directives. The conditional preprocessing block is terminated by {{tt|#endif}} directive.

===Condition evaluation===

===={{tt|#if, #elif}}====

The {{spar|expression}} is a constant expression, using only [[cpp/language#Literals|literals]] and identifiers, defined using {{ltt|c/preprocessor/replace | #define}} directive. Any identifier, which is not literal, non defined using {{ltt|c/preprocessor/replace | #define}} directive, evaluates to ''0''. 

The expression may contain unary operators in form {{tt|defined}}&amp;nbsp;{{spar|identifier}} or  {{tt|defined (}}{{spar|identifier}}{{tt|)}} which return {{c|1}} if the {{spar|identifier}} was defined using {{ltt|c/preprocessor/replace | #define}} directive and ''0'' otherwise. If the {{spar|expression}} evaluates to nonzero value, the controlled code block is included and skipped otherwise. If any used identifier is not a constant, it is replaced with {{c|0}}.

===={{tt|#ifdef, #ifndef}}====

Checks if the identifier was defined using {{ltt|c/preprocessor/replace | #define}} directive. 

{{tt|#ifdef}}&amp;nbsp;{{spar|identifier}} is essentially equivalent to {{tt|#if defined(}}&amp;nbsp;{{spar|identifier}}{{tt|)}}.

{{tt|#ifndef}}&amp;nbsp;{{spar|identifier}} is essentially equivalent to {{tt|#if !defined(}}&amp;nbsp;{{spar|identifier}}{{tt|)}}.

===Example===
{{example|
|code=
#define ABCD 2
#include &lt;iostream&gt;

int main()
{

#ifdef ABCD
    std::cout &lt;&lt; &quot;1: yes\n&quot;;
#else
    std::cout &lt;&lt; &quot;1: no\n&quot;;
#endif

#ifndef ABCD
    std::cout &lt;&lt; &quot;2: no1\n&quot;;
#elif ABCD == 2
    std::cout &lt;&lt; &quot;2: yes\n&quot;;
#else
    std::cout &lt;&lt; &quot;2: no2\n&quot;;
#endif

#if !defined(DCBA) &amp;&amp; (ABCD &lt; 2*4-3)
    std::cout &lt;&lt; &quot;3: yes\n&quot;;
#endif
}
|output=
1: yes
2: yes
3: yes
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/error</title>
    <ns>0</ns>
    <id>12673</id>
    <revision>
      <id>72166</id>
      <parentid>61455</parentid>
      <timestamp>2014-07-19T14:38:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-warning</comment>
      <text xml:space="preserve" bytes="456">{{title|Error directive}}
{{c/preprocessor/navbar}}
Shows given message and renders program ill-formed.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#error}} {{spar|error_message}} }}
{{sdsc end}}

===Explanation===

After encountering {{tt|#error}} directive, diagnostic message {{spar|error_message}} is shown and the program is rendered ill-formed (the compilation is stopped). 

''error_message'' can consist of several words not necessarily in quotes.</text>
      <sha1>gul6zj7tyevymyw1v3zbc2txxs5a2ww</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/impl</title>
    <ns>0</ns>
    <id>12674</id>
    <revision>
      <id>61456</id>
      <timestamp>2013-06-06T00:47:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="2498">{{title|Implementation defined behavior control}}
{{c/preprocessor/navbar}}
Implementation defined behavior is controlled by {{tt|#pragma}} directive.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#pragma}} {{spar|pragma_params}} }}
{{sdsc end}}

===Explanation===

Pragma directive controls implementation-specific behavior of the compiler, such as disabling compiler warnings or changing alignment requirements. Any pragma that is not recognized is ignored.

===Standard pragmas===

The following three pragmas are defined by the language standard:

{{sdsc begin}}
{{sdsc | num = 1 | {{ttb|#pragma STDC FENV_ACCESS }}{{spar|arg}}}}
{{sdsc | num = 2 | {{ttb|#pragma STDC FP_CONTRACT }}{{spar|arg}}}}
{{sdsc | num = 3 | {{ttb|#pragma STDC CX_LIMITED_RANGE }}{{spar|arg}}}}
{{sdsc end}}

where {{spar|arg}} is either {{ttb|ON}} or {{ttb|OFF}} or {{ttb|DEFAULT}}. 

@1@ If set to {{ttb|ON}}, informs the compiler that the program will access or modify [[c/numeric/fenv|floating-point environment]], which means that optimizations that could subvert flag tests and mode changes (e.g., global common subexpression elimination, code motion, and constant folding) are prohibited. The default value is implementation-defined, usually {{ttb|OFF}}.

@2@ Allows ''contracting'' of floating-point expressions, that is optimizations that omit rounding errors and floating-point exceptions that would be observed if the expression was evaluated exactly as written. The default value is implementation-defined, usually {{ttb|ON}}.

@3@ Informs the compiler that multiplication, division, and absolute value of complex numbers may use simplified mathematical formulas, despite the possibility of intermediate overflow. The range of the values passed to those function is expected to be limited. The default value is {{ttb|OFF}}

===External links===

* [http://msdn.microsoft.com/en-us/library/d9x1s805(v=VS.100).aspx C++ pragmas in Visual Studio 2010]
* [http://gcc.gnu.org/onlinedocs/gcc-4.6.2/gcc/Pragmas.html#Pragmas Pragmas] accepted by GCC 4.6.2
* [http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/topic/com.ibm.vacpp7a.doc/compiler/ref/rupragen.htm General Purpose Pragmas] in IBM AIX XL C/C++ V7.0
* [http://download.oracle.com/docs/cd/E19422-01/819-3690/Pragmas_App.html#73499 Appendix B. Pragmas] in Sun Studio 11 C++ User's Guide
* [http://software.intel.com/sites/products/documentation/hpc/compilerpro/en-us/cpp/lin/compiler_c/cref_cls/common/cppref_pragma_ovrvw.htm Intel C++ compiler pragmas]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/include</title>
    <ns>0</ns>
    <id>12667</id>
    <revision>
      <id>61450</id>
      <parentid>61445</parentid>
      <timestamp>2013-06-06T00:39:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/preprocessor/include]] to [[c/preprocessor/include]]</comment>
      <text xml:space="preserve" bytes="985">{{title|Source file inclusion}}
{{c/preprocessor/navbar}}
Includes other source file into current source file at the line immediately after the directive .

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#include &amp;lt;}}{{spar|filename}}{{ttb|&amp;gt;}} }}
{{sdsc | num=2 | {{ttb|#include &quot;}}{{spar|filename}}{{ttb|&quot;}} }}
{{sdsc end}}

===Explanation===

Includes source file, identified by {{spar|filename}} into the current source file at the line immediately after the directive.

The first version of the directive searches only standard include directories. The standard C++ library, as well as standard C library, is implicitly included in standard include directories. The standard include directories can be controlled by the user through compiler options. 

The second version firstly searches the directory where the current file resides and, only if the file is not found, searches the standard include directories.

In the case the file is not found, program is ill-formed.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/line</title>
    <ns>0</ns>
    <id>12675</id>
    <revision>
      <id>61457</id>
      <timestamp>2013-06-06T00:47:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1428">{{title|Filename and line information}}
{{c/preprocessor/navbar}}

Changes the current file name and number in the preprocessor.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#line}} {{spar|lineno}}}}
{{sdsc | num=2 |  {{ttb|#line}} {{spar|lineno}} {{ttb|&quot;}}{{spar|filename}}{{ttb|&quot;}} }}
{{sdsc end}}

===Explanation===

Changes the current preprocessor line number to {{spar|lineno}}. Expansions of the macro {{c|__LINE__}} beyond this point will expand to {{spar|lineno}} plus the number of actual source code lines encountered since.

(2) Also changes the current preprocessor file name to {{spar|filename}}. Expansions of the macro {{c|__FILE__}} from this point will produce {{spar|filename}}.

Any preprocessing tokens (macro constants or expressions) are permitted as arguments to {{tt|#line}} as long as they expand to a valid decimal integer optionally following a valid character string.

===Notes===
This directive is used by some automatic code generation tools which produce C++ source files from a file written in another language. In that case, {{tt|#line}} directives may be inserted in the generated C++ file referencing line numbers and the file name of the original (human-editable) source file.

===Example===
{{example | code=
#include &lt;cassert&gt;
#define FNAME &quot;test.cc&quot;
int main()
{
#line 777 FNAME
        assert(2+2 == 5);
}
 | output=
test: test.cc:777: int main(): Assertion `2+2 == 5' failed.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/preprocessor/replace</title>
    <ns>0</ns>
    <id>12671</id>
    <revision>
      <id>71849</id>
      <parentid>71733</parentid>
      <timestamp>2014-06-28T04:53:10Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ C11 predefined macros, wording</comment>
      <text xml:space="preserve" bytes="8812">{{title|Replacing text macros}}
{{c/preprocessor/navbar}}
The preprocessor supports text macro replacement. Function-like text macro replacement is also supported.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#define}} {{spar|identifier}} {{spar|replacement-list}} }}
{{sdsc | num=2 | {{ttb|#define}} {{spar|identifier}}{{ttb|(}} {{spar|parameters}} {{ttb|)}} {{spar|replacement-list}} }}
{{sdsc | num=3 | {{ttb|#define}} {{spar|identifier}}{{ttb|(}} {{spar|parameters}}{{ttb|, ... )}} {{spar|replacement-list}} |notes={{mark since c99}}}}
{{sdsc | num=4 | {{ttb|#define}} {{spar|identifier}}{{ttb|( ... )}} {{spar|replacement-list}} |notes={{mark since c99}}}}
{{sdsc | num=5 | {{ttb|#undef }} {{spar|identifier}} }}
{{sdsc end}}

===Explanation===

===={{tt|#define}} directives====

The {{tt|#define}} directives define the {{spar|identifier}} as macro, that is instruct the compiler to replace all successive occurrences of {{spar|identifier}} with {{spar|replacement-list}}, which can be optionally additionally processed. If the identifier is already defined as any type of macro, the program is ill-formed unless the definitions are identical. 

=====Object-like macros=====

Object-like macros replace every occurrence of defined {{spar|identifier}} with {{spar|replacement-list}}. Version (1) of the {{tt|#define}} directive behaves exactly like that.

=====Function-like macros=====

Function-like macros replace each occurrence of defined {{spar|identifier}} with {{spar|replacement-list}}, additionally taking a number of arguments, which then replace corresponding occurrences of any of the {{spar|parameters}} in the {{spar|replacement-list}}. The number of arguments must be the same as the number of arguments in macro definition ({{spar|parameters}}) or the program is ill-formed. If the identifier is not in functional-notation, i.e. does not have parentheses after itself, it is not replaced at all.

Version (2) of the {{tt|#define}} directive defines a simple function-like macro.

Version (3) of the {{tt|#define}} directive defines a function-like macro with variable number of arguments. The additional arguments can be accessed using {{tt|__VA_ARGS__}} identifier, which is then replaced with arguments, supplied with the identifier to be replaced.

Version (4) of the {{tt|#define}} directive defines a function-like macro with variable number of arguments, but no regular arguments. The arguments can be accessed only with {{tt|__VA_ARGS__}} identifier, which is then replaced with arguments, supplied with identifier to be replaced.

===={{tt|#}} and {{tt|##}} operators====

In function-like macros, a {{tt|#}} operator before an identifier in the {{spar|replacement-list}} runs the identifier through parameter replacement and encloses the result in quotes, effectively creating a string literal. In addition, the preprocessor adds backslashes to escape the quotes surrounding embedded string literals, if any, and doubles the backslashes within the string as necessary. All leading and trailing whitespace is removed, and any sequence of whitespace in the middle of the text (but not inside embedded string literals) is collapsed to a single space. This operation is called &quot;stringification&quot;. If the result of stringification is not a valid string literal, the behavior is undefined.

A {{tt|##}} operator between any two successive identifiers in the {{spar|replacement-list}} runs parameter replacement on the two identifiers and then concatenates the result. This operation is called &quot;concatenation&quot; or &quot;token pasting&quot;. Only tokens that form a valid token together may be pasted: identifiers that form a longer identifier, digits that form a number, or operators {{tt|+}} and {{tt|{{=}}}} that form a {{tt|+{{=}}}}. A comment cannot be created by pasting {{tt|/}} and {{tt|*}} because comments are removed from text before macro substitution is considered. If the result of concatenation is not a valid token, the behavior is undefined.

===={{tt|#undef}} directive====

The {{tt|#undef}} directive undefines the {{spar|identifier}}, that is cancels previous definition of the {{spar|identifier}} by {{tt|#define}} directive. If the identifier does not have associated macro, the directive is ignored.

===Predefined macros===
The following macro names are predefined in any translation unit.
{{dsc begin}}
{{dsc macro const | __STDC__ | nolink=true | expands to the integer constant {{c|1}}. This macro is intended to indicate a conforming implementation}}
{{dsc macro const | __STDC_VERSION__ | nolink=true | denotes the revision of the standard that is being used | notes={{mark c99}}}}
{{dsc macro const | __STDC_HOSTED__ | nolink=true | expands to the integer constant {{c|1}} if the implementation is hosted (runs under an OS), {{c|0}} if freestanding (runs without an OS) | notes={{mark c99}}}}
{{dsc macro const | __FILE__ | nolink=true | expands to the name of the current file, as a character string literal, can be changed by the {{rlp|line|#line}} directive}}
{{dsc macro const | __LINE__ | nolink=true | expands to the source file line number, an integer constant, can be changed by the {{rlp|line|#line}} directive}}
{{dsc macro const | __DATE__ | nolink=true | expands to the date of translation, a character string literal of the form &quot;Mmm dd yyyy&quot;. The name of the month is as if generated by {{c|asctime()}}}}
{{dsc macro const | __TIME__ | nolink=true | expands to the time of translation, a character string literal of the form &quot;hh:mm:ss&quot;, as in the time generated by {{c|asctime()}}}}
{{dsc end}}

The following additional macro names may be predefined by the implementations.
{{dsc begin}}
{{dsc macro const | __STDC_ISO_10646__ | nolink=true | expands to an integer constant of the form {{tt|yyyymmL}}, if {{c|wchar_t}} uses Unicode, the date indicates the latest revision of Unicode supported| notes={{mark c99}}}}
{{dsc macro const | __STDC_IEC_559__ | nolink=true | expands to {{c|1}} if IEC 60559 is supported | notes={{mark c99}}}}
{{dsc macro const | __STDC_IEC_559_COMPLEX__ | nolink=true | expands to {{c|1}} if IEC 60559 complex arithmetic is supported | notes={{mark c99}}}}
{{dsc macro const | __STDC_UTF_16__ | nolink=true | expands to {{c|1}} if {{c|char16_t}} use UTF-16 encoding | notes={{mark c11}}}}
{{dsc macro const | __STDC_UTF_32__ | nolink=true | expands to {{c|1}} if {{c|char32_t}} use UTF-32 encoding | notes={{mark c11}}}}
{{dsc macro const | __STDC_MB_MIGHT_NEQ_WC__ | nolink=true | expands to {{c|1}} if wide character encoding of the basic character set may not equal their narrow encoding  | notes={{mark c11}}}}
{{dsc macro const | __STDC_ANALYZABLE__ | nolink=true | expands to {{c|1}} if implementation conform to the specifications defined in C11 Annex L | notes={{mark c11}}}}
{{dsc macro const | __STDC_LIB_EXT1__ | nolink=true | expands to an integer constant if implementation support bounds-checking interfaces (an extension defined in C11 Annex K) | notes={{mark c11}}}}
{{dsc macro const | __STDC_NO_ATOMICS__ | nolink=true | expands to {{c|1}} if implementation does not support [[c/atomic|atomic types]] | notes={{mark c11}}}}
{{dsc macro const | __STDC_NO_COMPLEX__ | nolink=true | expands to {{c|1}} if implementation does not support [[c/numeric/complex|complex types]] | notes={{mark c11}}}}
{{dsc macro const | __STDC_NO_THREADS__ | nolink=true | expands to {{c|1}} if implementation does not support [[c/thread|thread]] | notes={{mark c11}}}}
{{dsc macro const | __STDC_NO_VLA__ | nolink=true | expands to {{c|1}} if implementation does not support variable length arrays | notes={{mark c11}}}}
{{dsc end}}

The values of these macros (except for {{tt|__FILE__}} and {{tt|__LINE__}}) remain constant throughout the translation unit. Attempts to redefine or undefine these macros result in undefined behavior.

Note: in the scope of every function body, there is a special function-local predefined variable named {{c|__func__}}{{mark since c99}}, defined as a static character array holding the name of the function in implementation-defined format. It is not a preprocessor macro, but it is used together with {{tt|__FILE__}} and {{tt|__LINE__}}, e.g. by {{lc|assert}}.

===Example===
{{example | code=
#include &lt;stdio.h&gt;

//make function factory and use it
#define FUNCTION(name, a) int fun_##name(int x) { return (a)*x;}

FUNCTION(quadruple, 4)
FUNCTION(double, 2)

#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) puts( #a )

int main(void)
{
    printf(&quot;quadruple(13): %d\n&quot;, fun_quadruple(13) );
    printf(&quot;double(21): %d\n&quot;, fun_double(21) );
    printf(&quot;%d\n&quot;, FUNCTION);
    OUTPUT(million);               //note the lack of quotes
}
| output=
quadruple(13): 52
double(21): 42
34
million
}}
{{dsc begin}}
{{dsc see cpp | cpp/preprocessor/replace | Replacing text macros}}
{{dsc end}}</text>
      <sha1>p9qi85gkj34te4lu0nesk582sh1n0xn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program</title>
    <ns>0</ns>
    <id>5931</id>
    <revision>
      <id>71027</id>
      <parentid>70982</parentid>
      <timestamp>2014-06-04T19:59:38Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="1546">{{title|Program support utilities}}
{{c/program/navbar}}

===Program termination===

The following functions manage program termination and resource cleanup.

{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc inc | c/program/dsc abort}}
{{dsc inc | c/program/dsc exit}}
{{dsc inc | c/program/dsc quick_exit}}
{{dsc inc | c/program/dsc _Exit}}
{{dsc inc | c/program/dsc atexit}}
{{dsc inc | c/program/dsc at_quick_exit}}
{{dsc inc | c/program/dsc EXIT_status}}
{{dsc end}}

===Communicating with the environment===

{{dsc begin}}
{{dsc inc | c/program/dsc system}}
{{dsc inc | c/program/dsc getenv}}
{{dsc end}}

===Signals===

Several functions and macro constants for signal management are provided.

{{dsc begin}}
{{dsc header | signal.h}}
{{dsc inc | c/program/dsc signal}}
{{dsc inc | c/program/dsc raise}}
{{dsc typedef | c/program/sig_atomic_t | the integer type that can be accessed as an atomic entity from an asynchronous signal handler}}
{{dsc inc | c/program/dsc SIG_strategies}}
{{dsc inc | c/program/dsc SIG_ERR}}

{{dsc h2 | Signal types}}
{{dsc inc | c/program/dsc SIG_types}}
{{dsc end}}

===Non-local jumps===

{{dsc begin}}
{{dsc header | setjmp.h}}
{{dsc inc | c/program/dsc setjmp}}
{{dsc inc | c/program/dsc longjmp}}

{{dsc h2 | Types}}
{{dsc inc | c/program/dsc jmp_buf}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/program |Program support utilities}}
{{dsc end}}

[[de:c/program]]
[[es:c/program]]
[[fr:c/program]]
[[it:c/program]]
[[ja:c/program]]
[[pt:c/program]]
[[ru:c/program]]
[[zh:c/program]]</text>
      <sha1>4ieawlgrwuikbkn2xcswo7g6gqfqtev</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/EXIT FAILURE</title>
    <ns>0</ns>
    <id>6340</id>
    <redirect title="c/program/EXIT status" />
    <revision>
      <id>22443</id>
      <timestamp>2012-04-19T20:18:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/program/EXIT status]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[c/program/EXIT_status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/EXIT SUCCESS</title>
    <ns>0</ns>
    <id>6339</id>
    <redirect title="c/program/EXIT status" />
    <revision>
      <id>22441</id>
      <timestamp>2012-04-19T20:17:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/program/EXIT status]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[c/program/EXIT_status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/EXIT status</title>
    <ns>0</ns>
    <id>6186</id>
    <revision>
      <id>69751</id>
      <parentid>69750</parentid>
      <timestamp>2014-04-22T12:15:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output line</comment>
      <text xml:space="preserve" bytes="1520">{{title|EXIT_SUCCESS, EXIT_FAILURE}}
{{c/program/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl |
#define EXIT_SUCCESS /*implementation defined*/
}}
{{dcl |
#define EXIT_FAILURE /*implementation defined*/
}}
{{dcl end}}

The {{tt|EXIT_SUCCESS}} and {{tt|EXIT_FAILURE}} macros expand into integral expressions that can be used as arguments to the {{lc|exit}} function (and, therefore, as the values to return from the [[c/language/main_function|main function]]), and indicate program execution status.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|EXIT_SUCCESS}} | successful execution of a program}}
{{dsc | {{tt|EXIT_FAILURE}} | unsuccessful execution of a program}}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    FILE *fp = fopen(&quot;data.txt&quot;,&quot;r&quot;);
    if (fp == NULL)
    {
       fprintf(stderr,&quot;fopen() failed in file %s at line # %d&quot;, __FILE__,__LINE__);
       exit(EXIT_FAILURE);
    }

    /* Normal processing continues here. */
    fclose(fp);
    printf(&quot;Normal Return\n&quot;);
    
    return EXIT_SUCCESS;
}
 | output=
fopen() failed in file main.cpp at line # 9
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/program/EXIT_status | EXIT_SUCCESS | EXIT_FAILURE}}
{{dsc end}}

[[de:c/program/EXIT status]]
[[es:c/program/EXIT status]]
[[fr:c/program/EXIT status]]
[[it:c/program/EXIT status]]
[[ja:c/program/EXIT status]]
[[pt:c/program/EXIT status]]
[[ru:c/program/EXIT status]]
[[zh:c/program/EXIT status]]</text>
      <sha1>2hzp8qlmfvp8qba306u6eqtx8eenbiy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGABRT</title>
    <ns>0</ns>
    <id>6180</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22431</id>
      <parentid>21515</parentid>
      <timestamp>2012-04-19T20:14:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGFPE</title>
    <ns>0</ns>
    <id>6179</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22432</id>
      <parentid>21514</parentid>
      <timestamp>2012-04-19T20:14:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGILL</title>
    <ns>0</ns>
    <id>6178</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22433</id>
      <parentid>21513</parentid>
      <timestamp>2012-04-19T20:15:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGINT</title>
    <ns>0</ns>
    <id>6177</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22434</id>
      <parentid>22409</parentid>
      <timestamp>2012-04-19T20:15:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGSEGV</title>
    <ns>0</ns>
    <id>6176</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22436</id>
      <parentid>22407</parentid>
      <timestamp>2012-04-19T20:15:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIGTERM</title>
    <ns>0</ns>
    <id>6175</id>
    <redirect title="c/program/SIG types" />
    <revision>
      <id>22438</id>
      <parentid>22406</parentid>
      <timestamp>2012-04-19T20:16:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merged</comment>
      <text xml:space="preserve" bytes="33">#redirect [[c/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIG DFL</title>
    <ns>0</ns>
    <id>6337</id>
    <redirect title="c/program/SIG strategies" />
    <revision>
      <id>22439</id>
      <timestamp>2012-04-19T20:17:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/program/SIG strategies]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[c/program/SIG_strategies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIG ERR</title>
    <ns>0</ns>
    <id>8691</id>
    <revision>
      <id>69698</id>
      <parentid>56689</parentid>
      <timestamp>2014-04-20T11:52:55Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example showing how to use SIG_ERR.</comment>
      <text xml:space="preserve" bytes="1230">{{title|SIG_ERR}}
{{c/program/navbar}}
{{ddcl | header=signal.h |
#define SIG_ERR /* implementation defined */
}}

A value of type {{tt|void (*)(int)}}. When returned by {{lc|signal}}, indicates that an error has occurred.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;signal.h&gt;
 
void signal_handler(int signal)
{
    printf(&quot;Received signal %d\n&quot;, signal);
}
 
int main(void)
{
    /* Install a signal handler. */
    if (signal(SIGTERM, signal_handler) == SIG_ERR)
    {
        printf(&quot;Error while installing a signal handler.\n&quot;);
        exit(EXIT_FAILURE);
    }
 
    printf(&quot;Sending signal %d\n&quot;, SIGTERM);
    if (raise(SIGTERM) != 0)
    {
        printf(&quot;Error while raising the SIGTERM signal.\n&quot;);
        exit(EXIT_FAILURE);
    }
 
    printf(&quot;Exit main()\n&quot;);
    return EXIT_SUCCESS;
}
 | output=
Sending signal 15
Received signal 15
Exit main()
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc signal}}
{{dsc see cpp | cpp/utility/program/SIG_ERR}}
{{dsc end}}

[[de:c/program/SIG ERR]]
[[es:c/program/SIG ERR]]
[[fr:c/program/SIG ERR]]
[[it:c/program/SIG ERR]]
[[ja:c/program/SIG ERR]]
[[pt:c/program/SIG ERR]]
[[ru:c/program/SIG ERR]]
[[zh:c/program/SIG ERR]]</text>
      <sha1>9ar2gxstz39h82sgumpr1l6cenqxbzc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIG IGN</title>
    <ns>0</ns>
    <id>6338</id>
    <redirect title="c/program/SIG strategies" />
    <revision>
      <id>22440</id>
      <timestamp>2012-04-19T20:17:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[c/program/SIG strategies]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[c/program/SIG_strategies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIG strategies</title>
    <ns>0</ns>
    <id>6181</id>
    <revision>
      <id>69700</id>
      <parentid>49064</parentid>
      <timestamp>2014-04-20T12:46:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New examples.</comment>
      <text xml:space="preserve" bytes="1408">{{title|SIG_DFL, SIG_IGN}}
{{c/program/navbar}}
{{dcl begin}}
{{dcl header | signal.h}}
{{dcl |
#define SIG_DFL /*implementation defined*/
}}
{{dcl |
#define SIG_IGN /*implementation defined*/
}}
{{dcl end}}

The {{lc|SIG_DFL}} and {{lc|SIG_IGN}} macros expand into integral expressions that are not equal to an address of any function. The macros define signal handling strategies for {{c|signal()}} function.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|SIG_DFL}} | default signal handling}}
{{dsc | {{tt|SIF_IGN}} | signal is ignored}}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;signal.h&gt;
#include &lt;stdio.h&gt;
 
int main(void)
{
    /* using the default signal handler */
    raise(SIGTERM);
    printf(&quot;Exit main()\n&quot;);   /* never reached */
}
 | output=
(none)
}}

===Example===
{{example
 |
 | code=
#include &lt;signal.h&gt;
#include &lt;stdio.h&gt;
 
int main(void)
{
    /* ignoring the signal */
    signal(SIGTERM, SIG_IGN);
    raise(SIGTERM);
    printf(&quot;Exit main()\n&quot;);
}
 | output=
Exit main()
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/program/SIG_strategies | SIG_DFL | SIG_IGN}}
{{dsc end}}

[[de:c/program/SIG strategies]]
[[es:c/program/SIG strategies]]
[[fr:c/program/SIG strategies]]
[[it:c/program/SIG strategies]]
[[ja:c/program/SIG strategies]]
[[pt:c/program/SIG strategies]]
[[ru:c/program/SIG strategies]]
[[zh:c/program/SIG strategies]]</text>
      <sha1>o4bnxinze46pw8wrsrx9r2oz8oynt3e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/SIG types</title>
    <ns>0</ns>
    <id>6335</id>
    <revision>
      <id>69697</id>
      <parentid>64288</parentid>
      <timestamp>2014-04-20T11:00:28Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>Inserted &quot;expands.&quot;</comment>
      <text xml:space="preserve" bytes="1553">{{title|SIGTERM, SIGSEGV, SIGINT, SIGILL, SIGABRT, SIGFPE}}
{{c/program/navbar}}
{{dcl begin}}
{{dcl header | signal.h}}
{{dcl |
#define SIGTERM /*implementation defined*/
}}
{{dcl |
#define SIGSEGV /*implementation defined*/
}}
{{dcl |
#define SIGINT /*implementation defined*/
}}
{{dcl |
#define SIGILL /*implementation defined*/
}}
{{dcl |
#define SIGABRT /*implementation defined*/
}}
{{dcl |
#define SIGFPE /*implementation defined*/
}}
{{dcl end}}

Each of the above macro constants expands to an integer constant expression with distinct values, which represent different signals sent to the program.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|SIGTERM}}  | termination request, sent to the program}}
{{dsc | {{tt|SIGSEGV}}  | invalid memory access (segmentation fault)}}
{{dsc | {{tt|SIGINT}}  | external interrupt, usually initiated by the user}}
{{dsc | {{tt|SIGILL}}  | invalid program image, such as invalid instruction}}
{{dsc | {{tt|SIGABRT}}  | abnormal termination condition, as is e.g. initiated by {{lc|abort()}}}}
{{dsc | {{tt|SIGFPE}}  | erroneous arithmetic operation such as divide by zero}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc signal}}
{{dsc inc | c/program/dsc raise}}
{{dsc see cpp | cpp/utility/program/SIG_types | signal types | nomono=true}}
{{dsc end}}

[[de:c/program/SIG types]]
[[es:c/program/SIG types]]
[[fr:c/program/SIG types]]
[[it:c/program/SIG types]]
[[ja:c/program/SIG types]]
[[pt:c/program/SIG types]]
[[ru:c/program/SIG types]]
[[zh:c/program/SIG types]]</text>
      <sha1>tkkk2ymbpe8kpkk3lz2ft3tq01yvce5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/ Exit</title>
    <ns>0</ns>
    <id>6189</id>
    <revision>
      <id>69753</id>
      <parentid>64293</parentid>
      <timestamp>2014-04-22T12:47:28Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.22.4.5 of n1570.</comment>
      <text xml:space="preserve" bytes="1522">{{c/title| _Exit}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h | since=c99 |
void _Exit( int exit_code );
}}

Causes normal program termination to occur without completely cleaning the resources.

Destructors of variables with automatic, thread local and static storage durations are not called. Functions passed to {{lc|at_quick_exit()}} or {{lc|atexit()}} are not called. Whether open resources such as files are closed is implementation defined. If {{tt|exit_code}} is {{lc|EXIT_FAILURE}}, an implementation-defined status, indicating ''unsuccessful'' termination, is returned. In other cases implementation-defined status value is returned. 

===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

/* _Exit does not call functions registered with atexit. */
void f1()
{
    puts(&quot;pushed first&quot;);
}
 
void f2()
{
    puts(&quot;pushed second&quot;);
}
 
int main(void)
{
    printf(&quot;Enter main()\n&quot;);
    atexit(f1);
    atexit(f2);
    fflush(stdout);   /* _Exit does not flush unwritten buffered data */
    _Exit(0);
}
 | output=
Enter main()
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc abort}}
{{dsc inc | c/program/dsc exit}}
{{dsc see cpp | cpp/utility/program/_Exit}}
{{dsc end}}

[[de:c/program/ Exit]]
[[es:c/program/ Exit]]
[[fr:c/program/ Exit]]
[[it:c/program/ Exit]]
[[ja:c/program/ Exit]]
[[pt:c/program/ Exit]]
[[ru:c/program/ Exit]]
[[zh:c/program/ Exit]]</text>
      <sha1>betwq82rl849kr3zf355ymyy1iy14yu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/abort</title>
    <ns>0</ns>
    <id>6192</id>
    <revision>
      <id>69747</id>
      <parentid>69744</parentid>
      <timestamp>2014-04-22T12:05:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>combined two lines</comment>
      <text xml:space="preserve" bytes="1370">{{c/title| abort}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h |
void abort();
}}

Causes abnormal program termination unless {{lc|SIGABRT}} is being caught by a signal handler passed to signal and the handler does not return.

Functions passed to {{lc|atexit()}} are not called. Whether open resources such as files are closed is implementation defined. Implementation defined status is returned to the host environment that indicates unsuccessful execution. 

===Parameters===
(none)

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;      /* FILE, fopen, fclose, fprintf */
#include &lt;stdlib.h&gt;     /* abort */

int main(void) 
{
    FILE *fp = fopen(&quot;data.txt&quot;,&quot;r&quot;);
    if (fp == NULL) {
       fprintf(stderr, &quot;error opening file data.txt in function main()\n&quot;);
       abort();
    }

    /* Normal processing continues here. */
    fclose(fp);
    printf(&quot;Normal Return\n&quot;);
    return 0;
}
 | output=
error opening file data.txt in function main()
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc exit}}
{{dsc inc | c/program/dsc atexit}}
{{dsc inc | c/program/dsc quick_exit}}
{{dsc see cpp | cpp/utility/program/abort}}
{{dsc end}}

[[de:c/program/abort]]
[[es:c/program/abort]]
[[fr:c/program/abort]]
[[it:c/program/abort]]
[[ja:c/program/abort]]
[[pt:c/program/abort]]
[[ru:c/program/abort]]
[[zh:c/program/abort]]</text>
      <sha1>ijt43t2a0s8d15cl99mb11rr4uouhf3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/at quick exit</title>
    <ns>0</ns>
    <id>6187</id>
    <revision>
      <id>69746</id>
      <parentid>56695</parentid>
      <timestamp>2014-04-22T11:59:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.22.4.3 of n1570.  GCC yields an error; clang yields a warning.</comment>
      <text xml:space="preserve" bytes="1277">{{c/title| at_quick_exit}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h |
int at_quick_exit( void (*func)() );
}}

Registers the function pointed to by {{tt|func}} to be called on quick program termination (via {{lc|quick_exit}}).

Calling the function from several threads does not induce a data race. The implementation shall support the registration of at least {{c|32}} functions.

===Parameters===
{{par begin}}
{{par | func | pointer to a function to be called on normal program termination}}
{{par end}}

===Return value===
{{c|0}} if the registration succeeds, nonzero value otherwise.

===Example===
{{example
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
 
void f1()
{
    puts(&quot;pushed first&quot;);
    fflush(stdout);
}
 
void f2()
{
    puts(&quot;pushed second&quot;);
}
 
int main(void)
{
    at_quick_exit(f1);
    at_quick_exit(f2);
    quick_exit(0);
}
 | output=
pushed second
pushed first
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc atexit}}
{{dsc see cpp | cpp/utility/program/at_quick_exit}}
{{dsc end}}

[[de:c/program/at quick exit]]
[[es:c/program/at quick exit]]
[[fr:c/program/at quick exit]]
[[it:c/program/at quick exit]]
[[ja:c/program/at quick exit]]
[[pt:c/program/at quick exit]]
[[ru:c/program/at quick exit]]
[[zh:c/program/at quick exit]]</text>
      <sha1>6ntmupv6s298fntlispin0ooi9j8ouo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/atexit</title>
    <ns>0</ns>
    <id>6188</id>
    <revision>
      <id>69749</id>
      <parentid>65704</parentid>
      <timestamp>2014-04-22T12:10:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1450">{{c/title| atexit}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h |
int atexit( void (*func)() );
}}

Registers the function pointed to by {{tt|func}} to be called on normal program termination (via {{lc|std::exit()}} or returning from {{tt|main()}}). The functions will be called in reverse order they were registered, i.e. the function registered last will be executed first.

The same function may be registered more than once.

{{tt|atexit}} is thread-safe: calling the function from several threads does not induce a data race. 

The implementation is guaranteed to support the registration of at least {{c|32}} functions. The exact limit is implementation-defined.

===Parameters===
{{par begin}}
{{par | func | pointer to a function to be called on normal program termination}}
{{par end}}

===Return value===
{{c|0}} if the registration succeeds, nonzero value otherwise.

===Example===
{{example
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;

void f1()
{
    puts(&quot;pushed first&quot;);
}

void f2()
{
    puts(&quot;pushed second&quot;);
}

int main(void)
{
    atexit(f1);
    atexit(f2);
}
 | output=
pushed second
pushed first
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc at_quick_exit}}
{{dsc see cpp | cpp/utility/program/atexit}}
{{dsc end}}

[[de:c/program/atexit]]
[[es:c/program/atexit]]
[[fr:c/program/atexit]]
[[it:c/program/atexit]]
[[ja:c/program/atexit]]
[[pt:c/program/atexit]]
[[ru:c/program/atexit]]
[[zh:c/program/atexit]]</text>
      <sha1>shm10s40abhzow5a4j7togm7hz1je1p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/exit</title>
    <ns>0</ns>
    <id>6191</id>
    <revision>
      <id>72055</id>
      <parentid>72053</parentid>
      <timestamp>2014-07-10T18:28:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+note about main function</comment>
      <text xml:space="preserve" bytes="2279">{{c/title| exit}}
{{c/program/navbar}}

{{dcl begin}}
{{dcl header|stdlib.h}}
{{dcl | until=c11|
void exit( int exit_code );
}}
{{dcl | since=c11|
_Noreturn void exit( int exit_code );
}}
{{dcl end}}

Causes normal program termination to occur.

Several cleanup steps are performed:

* functions passed to {{lc|atexit}} are called, in reverse order of registration
* all C streams are flushed and closed
* files created by {{lc|tmpfile}} are removed
* control is returned to the host environment. If {{tt|exit_code}} is zero or {{lc|EXIT_SUCCESS}}, an implementation-defined status, indicating successful termination is returned. If {{tt|exit_code}} is {{lc|EXIT_FAILURE}}, an implementation-defined status, indicating unsuccessful termination is returned. In other cases implementation-defined status value is returned.

===Notes===
The functions registered with {{lc|at_quick_exit}} are not called.

The behavior is undefined if a program calls {{tt|exit}} more than once, or if it calls {{tt|exit}} and {{lc|quick_exit}}

The behavior is undefined if during a call to a function registered with {{lc|atexit}}, the function exits with {{lc|longjmp}}.

Returning from the [[c/language/main function|the main function]], either by a {{tt|return}} statement or by reaching the end of the function, executes {{tt|exit()}}, passing the argument of the return statement (or {{c|0}} if implicit return was used) as {{tt|exit_code}}.

===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    FILE *fp = fopen(&quot;data.txt&quot;,&quot;r&quot;);
    if (fp == NULL) {
       fprintf(stderr, &quot;error opening file data.txt in function main()\n&quot;);
       exit(1);
    }
    fclose(fp);
    printf(&quot;Normal Return\n&quot;);
}
 | output=
error opening file data.txt in function main()
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc abort}}
{{dsc inc | c/program/dsc atexit}}
{{dsc inc | c/program/dsc quick_exit}}
{{dsc see cpp | cpp/utility/program/exit}}
{{dsc end}}

[[de:c/program/exit]]
[[es:c/program/exit]]
[[fr:c/program/exit]]
[[it:c/program/exit]]
[[ja:c/program/exit]]
[[pt:c/program/exit]]
[[ru:c/program/exit]]
[[zh:c/program/exit]]</text>
      <sha1>akbmg808omid6n7uuxgkt6xyz8zfc0y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/getenv</title>
    <ns>0</ns>
    <id>6184</id>
    <revision>
      <id>69739</id>
      <parentid>49071</parentid>
      <timestamp>2014-04-22T00:36:09Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1892">{{c/title| getenv}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h |
const char *getenv( const char *env_var );
}}

Searches for an environmental variable with name {{tt|env_var}} in the host-specified environment list and returns information associated with it. The set of environmental variables and methods of altering it are implementation-defined. 

===Parameters===
{{par begin}}
{{par | env_var | null-terminated character string identifying the name of the environmental variable to look for }}
{{par end}}

===Return value===
character string identifying the value of the environmental variable or {{lc|NULL}} if such variable is not found.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    char * env_p;
    env_p = getenv (&quot;PATH&quot;);
    if (env_p == NULL)
    { 
       printf(&quot;getenv() failed in file %s at line # %d&quot;, __FILE__,__LINE__);
       exit(1);
    }
    printf(&quot;PATH = %s\n&quot;, env_p);
    
    env_p = getenv (&quot;HOME&quot;);
    printf(&quot;HOME = %s\n&quot;, env_p);
        
    env_p = getenv (&quot;PWD&quot;);
    printf(&quot;PWD = %s\n&quot;, env_p);
    
    env_p = getenv (&quot;LD_LIBRARY_PATH&quot;);
    printf(&quot;LD_LIBRARY_PATH = %s\n&quot;, env_p);
    
    env_p = getenv (&quot;LANG&quot;);
    printf(&quot;LANG = %s\n&quot;, env_p);
    
    env_p = getenv (&quot;LC_ALL&quot;);
    printf(&quot;LC_ALL = %s\n&quot;, env_p);
    
    env_p = getenv (&quot;TZ&quot;);
    printf(&quot;TZ = %s\n&quot;, env_p);

    return 0;
}
 | output=
PATH = /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOME = /home/sandbox
PWD = /tmp/1398126808-1302695176
LD_LIBRARY_PATH = /usr/local/lib
LANG = en_US.UTF-8
LC_ALL = C
TZ = (null)
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/program/getenv}}
{{dsc end}}

[[de:c/program/getenv]]
[[es:c/program/getenv]]
[[fr:c/program/getenv]]
[[it:c/program/getenv]]
[[ja:c/program/getenv]]
[[pt:c/program/getenv]]
[[ru:c/program/getenv]]
[[zh:c/program/getenv]]</text>
      <sha1>okmsppe803sbnk3ifbowy1znrq7rc9q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/jmp buf</title>
    <ns>0</ns>
    <id>8689</id>
    <revision>
      <id>56700</id>
      <parentid>49072</parentid>
      <timestamp>2013-06-01T05:40:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="825">{{c/title|jmp_buf}}
{{c/program/navbar}}
{{ddcl | header=setjmp.h | 
typedef /* unspecified */ jmp_buf;
}}

The {{tt|jmp_buf}} type is an array type suitable for storing information to restore a calling environment. The stored information is sufficient to restore execution at the correct block of the program and invocation of that block. The state of floating-point status flags, or open files, or any other data is not stored in an object of type {{tt|jmp_buf}}.

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc setjmp}}
{{dsc inc | c/program/dsc longjmp}}
{{dsc see cpp | cpp/utility/program/jmp_buf}}
{{dsc end}}

[[de:c/program/jmp buf]]
[[es:c/program/jmp buf]]
[[fr:c/program/jmp buf]]
[[it:c/program/jmp buf]]
[[ja:c/program/jmp buf]]
[[pt:c/program/jmp buf]]
[[ru:c/program/jmp buf]]
[[zh:c/program/jmp buf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/longjmp</title>
    <ns>0</ns>
    <id>6173</id>
    <revision>
      <id>69794</id>
      <parentid>69773</parentid>
      <timestamp>2014-04-25T12:13:47Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>- restriction about throw (previously copy-pasted from C++ documentation)</comment>
      <text xml:space="preserve" bytes="2167">{{c/title| longjmp}}
{{c/program/navbar}}
{{ddcl | header=setjmp.h |
void longjmp( jmp_buf env, int status );
}}

Loads the execution context {{tt|env}} saved by a previous call to {{lc|setjmp}}. This function does not return. Control is transferred to the call site of the macro {{lc|setjmp}} that set up {{tt|env}}. That {{lc|setjmp}} then returns the value, passed as the {{tt|status}}.

If the function that called {{lc|setjmp}} has exited, the behavior is undefined (in other words, only long jumps up the call stack are allowed).

===Parameters===
{{par begin}}
{{par | env | variable referring to the execution state of the program saved by {{lc|setjmp}}}}
{{par | status | the value to return from {{lc|setjmp}}. If it is equal to {{c|0}}, {{c|1}} is used instead}}
{{par end}}

===Return value===
(none)

===Example===
Typical usage:  exception mechanism
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;setjmp.h&gt;
 
static jmp_buf call_env;
 
void f_2(void)
{
    printf(&quot;Enter f_2()\n&quot;);
    
    /* Restore calling environment:                             */
    /*   - &quot;return&quot; to the program state when setjmp was called */
    /*   - setjmp will return second arg of longjmp (1)         */
    longjmp(call_env,1);   /* declare an exception with code 1 */
}
 
void f_1(void)
{
    printf(&quot;Enter f_1()\n&quot;);
    f_2();
    printf(&quot;In f_1()\n&quot;);   /* never executed */
}
 
int main(void)
{
    int rtn;
    if (!(rtn=setjmp(call_env)))  /* save calling environment; return 0 */
    {  /* normal processing here */
       printf(&quot;In main(): %d\n&quot;, rtn);   /* 0 */
       f_1();
    }
    else   /* exception mechanism here */
       /* when longjmp jumps back, setjmp returns second arg of longjmp */
       printf(&quot;In main(): %d\n&quot;, rtn);   /* 1 */
 
    return 0;
}
 | output=
In main(): 0
Enter f_1()
Enter f_2()
In main(): 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc setjmp}}
{{dsc see cpp | cpp/utility/program/longjmp}}
{{dsc end}}

[[de:c/program/longjmp]]
[[es:c/program/longjmp]]
[[fr:c/program/longjmp]]
[[it:c/program/longjmp]]
[[ja:c/program/longjmp]]
[[pt:c/program/longjmp]]
[[ru:c/program/longjmp]]
[[zh:c/program/longjmp]]</text>
      <sha1>8k0rksegyiijd58cj1tyrhg9bormf58</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/quick exit</title>
    <ns>0</ns>
    <id>6190</id>
    <revision>
      <id>69752</id>
      <parentid>63529</parentid>
      <timestamp>2014-04-22T12:29:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.22.4.7 of n1570.  GCC yields an error; clang yields a warning.</comment>
      <text xml:space="preserve" bytes="1221">{{c/title| quick_exit}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h | since=c99 |
void quick_exit( int exit_code );
}}

Causes normal program termination to occur without completely cleaning the resources.

Functions passed to {{lc|at_quick_exit}} are called in reverse order of their registration. After calling the registered functions, calls {{c|_Exit(exit_code)}}

===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
 
void f1()
{
    puts(&quot;pushed first&quot;);
    fflush(stdout);
}
 
void f2()
{
    puts(&quot;pushed second&quot;);
}
 
int main(void)
{
    at_quick_exit(f1);
    at_quick_exit(f2);
    quick_exit(0);
}
 | output=
pushed second
pushed first
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc abort}}
{{dsc inc | c/program/dsc atexit}}
{{dsc inc | c/program/dsc at_quick_exit}}
{{dsc see cpp | cpp/utility/program/quick_exit}}
{{dsc end}}

[[de:c/program/quick exit]]
[[es:c/program/quick exit]]
[[fr:c/program/quick exit]]
[[it:c/program/quick exit]]
[[ja:c/program/quick exit]]
[[pt:c/program/quick exit]]
[[ru:c/program/quick exit]]
[[zh:c/program/quick exit]]</text>
      <sha1>kj9c2mlu79srq6khktgtug18ponb2iq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/raise</title>
    <ns>0</ns>
    <id>6182</id>
    <revision>
      <id>69696</id>
      <parentid>64284</parentid>
      <timestamp>2014-04-20T10:32:33Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1378">{{c/title| raise}}
{{c/program/navbar}}
{{ddcl | header=signal.h |
int raise( int sig );
}}

Sends signal sig to the program. The signal handler, specified using {{lc|signal()}} is invoked.

If the user-defined signal handling strategy is not set using {{lc|signal()}} yet, it is implementation-defined whether the signal will be ignored or default handler will be invoked. 

===Parameters===
{{par begin}}
{{par | sig | the signal to be sent. It can be an implementation-defined value or one of the following values:
{{dsc begin}}
{{dsc inc | c/program/dsc SIG_types}}
{{dsc end}}
}}
{{par end}}

===Return value===
{{c|0}} upon success, non-zero value on failure.

===Example===
{{example
 |
 | code=
#include &lt;signal.h&gt;
#include &lt;stdio.h&gt;
 
void signal_handler(int signal)
{
    printf(&quot;Received signal %d\n&quot;, signal);
}
 
int main(void)
{
    // Install a signal handler.
    signal(SIGTERM, signal_handler);
 
    printf(&quot;Sending signal %d\n&quot;, SIGTERM);
    raise(SIGTERM);
    printf(&quot;Exit main()\n&quot;);
}
 | output=
Sending signal 15
Received signal 15
Exit main()
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc signal}}
{{dsc see cpp | cpp/utility/program/raise}}
{{dsc end}}

[[de:c/program/raise]]
[[es:c/program/raise]]
[[fr:c/program/raise]]
[[it:c/program/raise]]
[[ja:c/program/raise]]
[[pt:c/program/raise]]
[[ru:c/program/raise]]
[[zh:c/program/raise]]</text>
      <sha1>0mw4pa5wwgfe5sk7cj89iokolg686en</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/setjmp</title>
    <ns>0</ns>
    <id>6174</id>
    <revision>
      <id>69793</id>
      <parentid>69755</parentid>
      <timestamp>2014-04-25T12:04:46Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ Environmental limits</comment>
      <text xml:space="preserve" bytes="2433">{{c/title| setjmp}}
{{c/program/navbar}}
{{ddcl | header=setjmp.h | 
#define setjmp(env) /* implementation-defined */
}}

Saves the current execution context into a variable {{tt|env}} of type {{lc|jmp_buf}}. This variable can later be used to restore the current execution context by {{lc|longjmp}} function. That is, when a call to {{lc|longjmp}} function is made, the execution continues at the particular call site that constructed the {{lc|jmp_buf}} variable passed to {{lc|longjmp}}. In that case {{lc|setjmp}} returns the value passed to {{lc|longjmp}}.

The invocation of {{tt|setjmp}} must appear only in one of the following contexts, otherwise the behavior is undefined:
* the entire controlling expression of a selection or iteration statement
* one operand of a relational or equality operator with the other operand an integer constant expression, with the resulting expression being the entire controlling expression of a selection or iteration statement
* the operand of a unary ! operator with the resulting expression being the entire controlling expression of a selection or iteration statement
* the entire expression of an expression statement (possibly cast to {{tt|void}}).

===Parameters===
{{par begin}}
{{par | env | variable to save the execution state of the program to.}}
{{par end}}

===Return value===
{{c|0}} if the macro was called by the original code and the execution context was saved to {{tt|env}}.

Non-zero value if a non-local jump was just performed. The return value in the same as passed to {{lc|longjmp}}.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;setjmp.h&gt;
 
jmp_buf jump_buffer;
 
void a(int count) 
{
    printf(&quot;a(%d) called\n&quot;, count);

    /* Restore calling environment. */
    longjmp(jump_buffer, count+1);  /* setjump() will return count+1 */
}
 
int main(void)
{
    /* Save calling environment. */
    int count = setjmp(jump_buffer);
    if (count != 9)
        a(count);  /* This will cause setjmp() to exit */
}
 | output=
a(0) called
a(1) called
a(2) called
a(3) called
a(4) called
a(5) called
a(6) called
a(7) called
a(8) called
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc longjmp}}
{{dsc see cpp | cpp/utility/program/setjmp}}
{{dsc end}}

[[de:c/program/setjmp]]
[[es:c/program/setjmp]]
[[fr:c/program/setjmp]]
[[it:c/program/setjmp]]
[[ja:c/program/setjmp]]
[[pt:c/program/setjmp]]
[[ru:c/program/setjmp]]
[[zh:c/program/setjmp]]</text>
      <sha1>5jgmf0t3a3qw2x7ofpq83zacnyr4jfp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/sig atomic t</title>
    <ns>0</ns>
    <id>8693</id>
    <revision>
      <id>69720</id>
      <parentid>56709</parentid>
      <timestamp>2014-04-21T14:21:53Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example 7.14 of n1570.</comment>
      <text xml:space="preserve" bytes="1119">{{title|sig_atomic_t}}
{{c/program/navbar}}
{{ddcl | header=signal.h |
typedef /* unspecified */ sig_atomic_t;
}}

An integer type which can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals.

===Example===
{{example
 |
 | p=true
 | code=
#include &lt;signal.h&gt;
#include &lt;stdio.h&gt;

volatile sig_atomic_t gSignalStatus = 0;

void signal_handler(int signal)
{
    gSignalStatus = signal;
}

int main(void)
{
    /* Install a signal handler. */
    signal(SIGINT, signal_handler);

    printf(&quot;SignalValue:   %d\n&quot;, gSignalStatus);
    printf(&quot;Sending signal %d\n&quot;, SIGINT);
    raise(SIGINT);
    printf(&quot;SignalValue:   %d\n&quot;, gSignalStatus);
}
 | output=
SignalValue:   0
Sending signal 2
SignalValue:   2
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc signal}}
{{dsc see cpp | cpp/utility/program/sig_atomic_t}}
{{dsc end}}

[[de:c/program/sig atomic t]]
[[es:c/program/sig atomic t]]
[[fr:c/program/sig atomic t]]
[[it:c/program/sig atomic t]]
[[ja:c/program/sig atomic t]]
[[pt:c/program/sig atomic t]]
[[ru:c/program/sig atomic t]]
[[zh:c/program/sig atomic t]]</text>
      <sha1>dq5vkb00v8ej5fsw2pk825x08wpq72i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/signal</title>
    <ns>0</ns>
    <id>6183</id>
    <revision>
      <id>69680</id>
      <parentid>69679</parentid>
      <timestamp>2014-04-19T15:03:55Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4753">{{c/title| signal}}
{{c/program/navbar}}
{{ddcl | header=signal.h |
void (*signal( int sig, void (*handler) (int))) (int);
}}

Sets the error handler for signal {{tt|sig}}. The signal handler can be set so that default handling will occur, signal is ignored, or an user-defined function is called.

When signal handler is set to a function and a signal occurs, it is implementation defined whether {{c|signal(sig, SIG_DFL)}} will be executed immediately before the start of signal handler. Also, the implementation can prevent some implementation-defined set af signals from occurring while the signal handler runs.

===Parameters===
{{par begin}}
{{par | sig | the signal to set the signal handler to. It can be an implementation-defined value or one of the following values: 
{{dsc begin}}
{{dsc inc | c/program/dsc SIG_types}}
{{dsc end}}
}}
{{par | handler | the signal handler. This must be one of the following: 
*{{lc|SIG_DFL}} macro. The signal handler is set to default signal handler.
*{{lc|SIG_IGN}} macro. The signal is ignored.
*pointer to a function. The signature of the function must be equivalent to the following:
{{ddcl | 
void fun(int sig);}}}}
{{par end}}

===Return value===
Previous signal handler on success or {{lc|SIG_ERR}} on failure (setting a signal handler can be disabled on some implementations).

===Signal handler===
The following limitations are imposed on the user-defined function that is installed as a signal handle

If the user defined function returns when handling {{lc|SIGFPE}}, {{lc|SIGILL}} or {{lc|SIGSEGV}}, the behavior is undefined.

If the signal handler is called as a result of {{lc|abort}} or {{lc|raise}}, the behavior is undefined if the signal handler calls {{lc|raise}}.

If the signal handler is called NOT as a result of {{lc|abort}} or {{lc|raise}}, the behavior is undefined if
* the signal handler calls any function within the standard library, except {{lc|abort}}, {{lc|_Exit}}, {{lc|quick_exit}}, or {{c|signal}} with the first argument not being the number of the signal currently handled. 
* the signal handler refers to any object with static or thread-local{{mark since c11}} storage duration that is not lock-free atomic{{mark since c11}} or {{c|volatile std::sig_atomic_t}}.

On entry to the signal handler, the state of the floating-point environment and the values of all objects is unspecified, except for
* objects of type {{c|volatile sig_atomic_t}}
* objects of lock-free atomic types {{mark since c11}}
* side effects made visible through {{lc|atomic_signal_fence}} {{mark since c11}}

On return from a signal handler, the value of any object modified by the signal handler that is not {{c|volatile sig_atomic_t}} or lock-free atomic{{mark since c11}} is undefined.

The behavior is undefined if {{c|signal}} is used in a multithreaded program. It is not required to be thread-safe.

===Notes===
POSIX requires that {{tt|signal}} is thread-safe, and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04 specifies a list of async-signal-safe library functions] that may be called from any signal handler.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;signal.h&gt;

/* A user-defined signal handler can process one or more signals. */
static void signal_handler(int signo)
{
    switch(signo)
    {
        case SIGABRT : puts(&quot;Process SIGABRT signal here.&quot;); break;
        case SIGFPE  : puts(&quot;Process SIGFPE  signal here.&quot;); break;
        case SIGILL  : puts(&quot;Process SIGILL  signal here.&quot;); break;
        case SIGINT  : puts(&quot;Process SIGINT  signal here.&quot;); break;
        case SIGSEGV : puts(&quot;Process SIGSEGV signal here.&quot;); break;
        case SIGTERM : puts(&quot;Process SIGTERM signal here.&quot;); break;
    }
    
    /* some cleanup here */
    /* exit(signo);      */
}
 
int main(void)
{
    /* Register a user-defined signal handler. */
    signal(SIGABRT, signal_handler);
    signal(SIGFPE,  signal_handler);
    signal(SIGILL,  signal_handler);
    signal(SIGINT,  signal_handler);
    signal(SIGSEGV, signal_handler);
    signal(SIGTERM, signal_handler);

    /* Raise a signal. */
    raise(SIGABRT);
    raise(SIGFPE);
    raise(SIGILL);
    raise(SIGINT);
    raise(SIGSEGV);
    raise(SIGTERM);

    return 0;
}
 | output=
Process SIGABRT signal here.
Process SIGFPE  signal here.
Process SIGILL  signal here.
Process SIGINT  signal here.
Process SIGSEGV signal here.
Process SIGTERM signal here.
}}

===See also===
{{dsc begin}}
{{dsc inc | c/program/dsc raise}}
{{dsc see cpp | cpp/utility/program/signal}}
{{dsc end}}

[[de:c/program/signal]]
[[es:c/program/signal]]
[[fr:c/program/signal]]
[[it:c/program/signal]]
[[ja:c/program/signal]]
[[pt:c/program/signal]]
[[ru:c/program/signal]]
[[zh:c/program/signal]]</text>
      <sha1>5tslctjkk1k79co8ftxuz3znnebt1g7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/program/system</title>
    <ns>0</ns>
    <id>6185</id>
    <revision>
      <id>66486</id>
      <parentid>49079</parentid>
      <timestamp>2013-11-25T19:01:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>same note as in C++</comment>
      <text xml:space="preserve" bytes="1454">{{c/title| system}}
{{c/program/navbar}}
{{ddcl | header=stdlib.h |
int system( const char *command );
}}

Calls the host environment's command processor with command parameter. Returns implementation-defined value (usually the value that the invoked program returns).

If command is {{lc|NULL}} pointer, checks if host environment has a command processor and returns nonzero value only if it the command processor exists.

===Parameters===
{{par begin}}
{{par | command | character string identifying the command to be run in the command processor. If NULL pointer is given, command processor is checked for existence}}
{{par end}}

===Return value===
Implementation-defined value. If {{tt|command}} is {{lc|NULL}} returns nonzero value only if command processor exists.

===Notes===
Related POSIX function [http://pubs.opengroup.org/onlinepubs/9699919799/functions/popen.html popen] makes the output generated by {{tt|command}} available to the caller.

===Example===
In this example there is a system call of the unix command '''ls -l &gt;test.txt''':
{{example
 |
 | code=
#include &lt;stdlib.h&gt;

int main() {
    
    system(&quot;ls -l &gt;test.txt&quot;);

    return 0;
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/program/system}}
{{dsc end}}

[[de:c/program/system]]
[[es:c/program/system]]
[[fr:c/program/system]]
[[it:c/program/system]]
[[ja:c/program/system]]
[[pt:c/program/system]]
[[ru:c/program/system]]
[[zh:c/program/system]]</text>
      <sha1>jwbgqiuaf6y1hi0gsmxkawpampk7k7t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string</title>
    <ns>0</ns>
    <id>5756</id>
    <revision>
      <id>71036</id>
      <parentid>70988</parentid>
      <timestamp>2014-06-04T20:28:15Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="473">{{title|Strings library}}
{{c/string/navbar}}

===[[ c/string/byte | Null-terminated byte string management]]===

===[[ c/string/multibyte | Null-terminated multibyte string management]]===

===[[ c/string/wide | Null-terminated wide string management]]===

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string |Strings library}}
{{dsc end}}

[[de:c/string]]
[[es:c/string]]
[[fr:c/string]]
[[it:c/string]]
[[ja:c/string]]
[[pt:c/string]]
[[ru:c/string]]
[[zh:c/string]]</text>
      <sha1>94l3ud1p4kywajy36sdmggfjhkvyw8u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte</title>
    <ns>0</ns>
    <id>5757</id>
    <revision>
      <id>71106</id>
      <parentid>56715</parentid>
      <timestamp>2014-06-06T11:59:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C++</comment>
      <text xml:space="preserve" bytes="2883">{{title|Null-terminated byte strings}}
{{c/string/byte/navbar}}

A null-terminated byte string (NTBS) is a sequence of nonzero bytes followed by a byte with value zero (the terminating null character). Each byte in a byte string encodes one character of some character set. For example, the character array {{c|{'\x63','\x61','\x74','\0'}}} is an NTBS holding the string {{c|&quot;cat&quot;}} in ASCII encoding.

===Functions===
{{dsc begin}}
{{dsc h2 | Character classification}}
{{dsc header | ctype.h}}
{{dsc inc | c/string/byte/dsc isalnum}}
{{dsc inc | c/string/byte/dsc isalpha}}
{{dsc inc | c/string/byte/dsc islower}}
{{dsc inc | c/string/byte/dsc isupper}}
{{dsc inc | c/string/byte/dsc isdigit}}
{{dsc inc | c/string/byte/dsc isxdigit}}
{{dsc inc | c/string/byte/dsc iscntrl}}
{{dsc inc | c/string/byte/dsc isgraph}}
{{dsc inc | c/string/byte/dsc isspace}}
{{dsc inc | c/string/byte/dsc isblank}}
{{dsc inc | c/string/byte/dsc isprint}}
{{dsc inc | c/string/byte/dsc ispunct}}

{{dsc h2 | Character manipulation}}
{{dsc inc | c/string/byte/dsc tolower}}
{{dsc inc | c/string/byte/dsc toupper}}
{{dsc end}}
{{c/string/character classes}}
{{dsc begin}}

{{dsc h2 | Conversions to numeric formats}}
{{dsc header | stdlib.h}}
{{dsc inc | c/string/byte/dsc atof}}
{{dsc inc | c/string/byte/dsc atoi}}
{{dsc inc | c/string/byte/dsc strtol}}
{{dsc inc | c/string/byte/dsc strtoul}}
{{dsc inc | c/string/byte/dsc strtof}}
{{dsc header  | inttypes.h}}
{{dsc inc | c/string/byte/dsc strtoimax}}

{{dsc h2 | String manipulation}}
{{dsc header | string.h}}
{{dsc inc | c/string/byte/dsc strcpy}}
{{dsc inc | c/string/byte/dsc strncpy}}
{{dsc inc | c/string/byte/dsc strcat}}
{{dsc inc | c/string/byte/dsc strncat}}
{{dsc inc | c/string/byte/dsc strxfrm}}

{{dsc h2 | String examination}}
{{dsc header | string.h}}
{{dsc inc | c/string/byte/dsc strlen}}
{{dsc inc | c/string/byte/dsc strcmp}}
{{dsc inc | c/string/byte/dsc strncmp}}
{{dsc inc | c/string/byte/dsc strcoll}}
{{dsc inc | c/string/byte/dsc strchr}}
{{dsc inc | c/string/byte/dsc strrchr}}
{{dsc inc | c/string/byte/dsc strspn}}
{{dsc inc | c/string/byte/dsc strcspn}}
{{dsc inc | c/string/byte/dsc strpbrk}}
{{dsc inc | c/string/byte/dsc strstr}}
{{dsc inc | c/string/byte/dsc strtok}}

{{dsc h2 | Character array manipulation}}
{{dsc header | string.h}}
{{dsc inc | c/string/byte/dsc memchr}}
{{dsc inc | c/string/byte/dsc memcmp}}
{{dsc inc | c/string/byte/dsc memset}}
{{dsc inc | c/string/byte/dsc memcpy}}
{{dsc inc | c/string/byte/dsc memmove}}

{{dsc h2 | Miscellaneous}}
{{dsc header | string.h}}
{{dsc inc | c/string/byte/dsc strerror}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/byte | Null-terminated byte strings}}
{{dsc end}}

[[de:c/string/byte]]
[[es:c/string/byte]]
[[fr:c/string/byte]]
[[it:c/string/byte]]
[[ja:c/string/byte]]
[[pt:c/string/byte]]
[[ru:c/string/byte]]
[[zh:c/string/byte]]</text>
      <sha1>8kb4a7vr8kqbvww686lou3hyeg6i8kw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/atof</title>
    <ns>0</ns>
    <id>6122</id>
    <revision>
      <id>70081</id>
      <parentid>69637</parentid>
      <timestamp>2014-05-09T12:44:58Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1301">{{c/title| atof}}
{{c/string/byte/navbar}}
{{ddcl | header=stdlib.h |
double atof( const char* str );
}}

Interprets an floating point value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float}}

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par end}}

===Return value===
{{c|double}} value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of the return type, the return value is undefined. If no conversion can be performed, {{c|0.0}} is returned.

===Example===
{{example
 | 
 | code=
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
 
int main(void)
{
    printf(&quot;%g\n&quot;, atof(&quot;  -0.0000000123junk&quot;));
    printf(&quot;%g\n&quot;, atof(&quot;0.012&quot;));
    printf(&quot;%g\n&quot;, atof(&quot;15e16&quot;));
    printf(&quot;%g\n&quot;, atof(&quot;-0x1afp-2&quot;));
    printf(&quot;%g\n&quot;, atof(&quot;inF&quot;));
    printf(&quot;%g\n&quot;, atof(&quot;Nan&quot;));
 
    return 0;
}
 | output=
-1.23e-08
0.012
1.5e+17
-107.75
inf
nan
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strtof}}
{{dsc see cpp | cpp/string/byte/atof}}
{{dsc end}}

[[de:c/string/byte/atof]]
[[es:c/string/byte/atof]]
[[fr:c/string/byte/atof]]
[[it:c/string/byte/atof]]
[[ja:c/string/byte/atof]]
[[pt:c/string/byte/atof]]
[[ru:c/string/byte/atof]]
[[zh:c/string/byte/atof]]</text>
      <sha1>tfc1zgnpdsuqjvpgj5fojmdubwxn5ao</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/atoi</title>
    <ns>0</ns>
    <id>6123</id>
    <revision>
      <id>70082</id>
      <parentid>67054</parentid>
      <timestamp>2014-05-09T12:46:40Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1275">{{c/title| atoi | atol | atoll}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl | 
int       atoi( const char *str );
}}
{{dcl |
long      atol( const char *str );
}}
{{dcl | since=c99 |
long long atoll( const char *str );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int}}

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void)
{
    printf(&quot;%i\n&quot;, atoi(&quot; -123junk&quot;));
}
| output= -123
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strtol}}
{{dsc inc | c/string/byte/dsc strtoul}}
{{dsc see cpp | cpp/string/byte/atoi | atoi | atol | atoll}}
{{dsc end}}

[[de:c/string/byte/atoi]]
[[es:c/string/byte/atoi]]
[[fr:c/string/byte/atoi]]
[[it:c/string/byte/atoi]]
[[ja:c/string/byte/atoi]]
[[pt:c/string/byte/atoi]]
[[ru:c/string/byte/atoi]]
[[zh:c/string/byte/atoi]]</text>
      <sha1>15pc1l3rpsnqqedgohzmmt4uzzx7zqu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isalnum</title>
    <ns>0</ns>
    <id>6060</id>
    <revision>
      <id>69604</id>
      <parentid>69602</parentid>
      <timestamp>2014-04-15T15:26:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>escape the \ in output</comment>
      <text xml:space="preserve" bytes="1670">{{c/title|isalnum}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isalnum( int ch );
}}

Checks if the given character is an alphanumeric character as classified by the current C locale. In the default locale, the following characters are alphanumeric:

* digits ({{tt|0123456789}})
* uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}})
* lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}})

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value if the character is an alphanumeric character, {{tt|0}} otherwise.

===Example===
{{example
 | Demonstrates the use of isalnum() with different locales (OS-specific).
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    unsigned char c = '\xdf'; // German letter ß in ISO-8859-1

    printf(&quot;isalnum('\\xdf') in default C locale returned %d\n&quot;, !!isalnum(c));

    setlocale(LC_CTYPE, &quot;de_DE.iso88591&quot;);
    printf(&quot;isalnum('\\xdf') in ISO-8859-1 locale returned %d\n&quot;, !!isalnum(c));
}
 | output=
isalnum('\xdf') in default C locale returned 0
isalnum('\xdf') in ISO-8859-1 locale returned 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswalnum}}
{{dsc see cpp | cpp/string/byte/isalnum}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isalnum]]
[[es:c/string/byte/isalnum]]
[[fr:c/string/byte/isalnum]]
[[it:c/string/byte/isalnum]]
[[ja:c/string/byte/isalnum]]
[[pt:c/string/byte/isalnum]]
[[ru:c/string/byte/isalnum]]
[[zh:c/string/byte/isalnum]]</text>
      <sha1>agd5y1d19983adv9sg6hqbs4jt4ctzy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isalpha</title>
    <ns>0</ns>
    <id>6059</id>
    <revision>
      <id>69603</id>
      <parentid>69601</parentid>
      <timestamp>2014-04-15T15:25:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>correct example output</comment>
      <text xml:space="preserve" bytes="1908">{{c/title|isalpha}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isalpha( int ch );
}}

Checks if the given character is an alphabetic character, i.e. either an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), or a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}).

In locales other than {{c|&quot;C&quot;}}, an alphabetic character is a character for which {{lc|isupper()}} or {{lc|islower()}} returns {{c|true}} or any other character considered alphabetic by the locale. In any case, {{lc|iscntrl()}}, {{lc|isdigit()}}, {{lc|ispunct()}} and {{lc|isspace()}} will return {{c|false}} for this character.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an alphabetic character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | Demonstrates the use of isalpha() with different locales (OS-specific). 
 | code=
#include &lt;ctype.h&gt;
#include &lt;stdio.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    unsigned char c = '\xdf'; // German letter ß in ISO-8859-1
 
    printf(&quot;isalpha('\\xdf') in default C locale returned %d\n&quot;, !!isalpha(c));
 
    setlocale(LC_CTYPE, &quot;de_DE.iso88591&quot;);
    printf(&quot;isalpha('\\xdf') in ISO-8859-1 locale returned %d\n&quot;, !!isalpha(c));
}
 | output=
isalpha('\xdf') in default C locale returned 0
isalpha('\xdf') in ISO-8859-1 locale returned 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswalpha}}
{{dsc see cpp | cpp/string/byte/isalpha}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isalpha]]
[[es:c/string/byte/isalpha]]
[[fr:c/string/byte/isalpha]]
[[it:c/string/byte/isalpha]]
[[ja:c/string/byte/isalpha]]
[[pt:c/string/byte/isalpha]]
[[ru:c/string/byte/isalpha]]
[[zh:c/string/byte/isalpha]]</text>
      <sha1>j03zlezjtpefm4an2fqe94enmuy90uf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isblank</title>
    <ns>0</ns>
    <id>6051</id>
    <revision>
      <id>69594</id>
      <parentid>69593</parentid>
      <timestamp>2014-04-15T12:44:39Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>emphasize hex</comment>
      <text xml:space="preserve" bytes="1264">{{c/title|isblank}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h | since=c99 |
int isblank( int ch );
}}

Checks if the given character is a blank character in the current C locale. In the default C locale, only space ({{tt|0x20}}) and horizontal tab ({{tt|0x09}}) are classified as blank.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a blank character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;

int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isblank(ndx)) printf(&quot;0x%02x\n&quot;, ndx);
    
    return 0;
}
 | output=
0x09
0x20
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswblank}}
{{dsc see cpp | cpp/string/byte/isblank}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isblank]]
[[es:c/string/byte/isblank]]
[[fr:c/string/byte/isblank]]
[[it:c/string/byte/isblank]]
[[ja:c/string/byte/isblank]]
[[pt:c/string/byte/isblank]]
[[ru:c/string/byte/isblank]]
[[zh:c/string/byte/isblank]]</text>
      <sha1>ppzl416rbdhrctw0iqs4eywkp9chl89</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/iscntrl</title>
    <ns>0</ns>
    <id>6054</id>
    <revision>
      <id>70220</id>
      <parentid>66334</parentid>
      <timestamp>2014-05-12T12:07:30Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example shows an effect with the default locale.</comment>
      <text xml:space="preserve" bytes="1190">{{c/title|iscntrl}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int iscntrl( int ch );
}}

Checks if the given character is a control character, i.e. codes {{tt|0x00-0x1F}} and {{tt|0x7F}}.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a control character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (iscntrl(ndx)) printf(&quot;0x%02x\n&quot;, ndx);

    return 0;
}
 | output=
0x00
0x01
0x02
0x03
.
.
.
0x1f
0x7f
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswcntrl}}
{{dsc see cpp | cpp/string/byte/iscntrl}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/iscntrl]]
[[es:c/string/byte/iscntrl]]
[[fr:c/string/byte/iscntrl]]
[[it:c/string/byte/iscntrl]]
[[ja:c/string/byte/iscntrl]]
[[pt:c/string/byte/iscntrl]]
[[ru:c/string/byte/iscntrl]]
[[zh:c/string/byte/iscntrl]]</text>
      <sha1>6sbtse1xcgpcgisv64104jbs1myk96h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isdigit</title>
    <ns>0</ns>
    <id>6056</id>
    <revision>
      <id>69629</id>
      <parentid>69628</parentid>
      <timestamp>2014-04-16T12:08:58Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>grammar</comment>
      <text xml:space="preserve" bytes="1494">{{c/title|isdigit}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isdigit( int ch );
}}

Checks if the given character is a numeric character ({{tt|0123456789}}).

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|isdigit}} and {{tt|isxdigit}} are the only standard narrow character classification functions that are not affected by the currently installed C locale, although some implementations (e.g. Microsoft in 1252 codepage) may classify additional single-byte characters as digits. 
&lt;!-- ref: C standard, note 224 in $7.11.1.1 --&gt;

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isdigit(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
0123456789
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswdigit}}
{{dsc see cpp | cpp/string/byte/isdigit}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isdigit]]
[[es:c/string/byte/isdigit]]
[[fr:c/string/byte/isdigit]]
[[it:c/string/byte/isdigit]]
[[ja:c/string/byte/isdigit]]
[[pt:c/string/byte/isdigit]]
[[ru:c/string/byte/isdigit]]
[[zh:c/string/byte/isdigit]]</text>
      <sha1>1jd7s9sm80cwaco7bd6c0mzb2a735ap</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isgraph</title>
    <ns>0</ns>
    <id>6053</id>
    <revision>
      <id>69632</id>
      <parentid>69631</parentid>
      <timestamp>2014-04-16T12:39:16Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output with nowiki</comment>
      <text xml:space="preserve" bytes="1611">{{c/title|isgraph}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isgraph( int ch );
}}

Checks if the given character has a graphical representation, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), or a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}), or any graphical character specific to the current C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character has a graphical representation character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isgraph(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
!&quot;#$%&amp;'()*+,-./0123456789:;=&gt;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswgraph}}
{{dsc see cpp | cpp/string/byte/isgraph}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/byte/isgraph]]
[[es:c/string/byte/isgraph]]
[[fr:c/string/byte/isgraph]]
[[it:c/string/byte/isgraph]]
[[ja:c/string/byte/isgraph]]
[[pt:c/string/byte/isgraph]]
[[ru:c/string/byte/isgraph]]
[[zh:c/string/byte/isgraph]]</text>
      <sha1>rn1dng53aaaby5dg0mrqhdp7yvc4l2y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/islower</title>
    <ns>0</ns>
    <id>6058</id>
    <revision>
      <id>70218</id>
      <parentid>66344</parentid>
      <timestamp>2014-05-12T11:59:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example shows an effect with the default locale.</comment>
      <text xml:space="preserve" bytes="1514">{{c/title|islower}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int islower( int ch );
}}

Checks if the given character is classified as a lowercase character according to the current C locale. In the default &quot;C&quot; locale, {{tt|islower}} returns true only for the lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}}).

If {{tt|islower}} returns {{c|true}}, it is guaranteed that {{lc|iscntrl}}, {{lc|isdigit}}, {{lc|ispunct}}, and {{lc|isspace}} return {{c|false}} for the same character in the same C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a lowercase letter, {{tt|0}} ({{c|false}}) otherwise.


===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (islower(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
abcdefghijklmnopqrstuvwxyz
}}

===See also===

{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswlower}}
{{dsc see cpp | cpp/string/byte/islower}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/islower]]
[[es:c/string/byte/islower]]
[[fr:c/string/byte/islower]]
[[it:c/string/byte/islower]]
[[ja:c/string/byte/islower]]
[[pt:c/string/byte/islower]]
[[ru:c/string/byte/islower]]
[[zh:c/string/byte/islower]]</text>
      <sha1>a3wf2zfq1cthp8rst2o6uq9j8oy6sqd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isprint</title>
    <ns>0</ns>
    <id>6050</id>
    <revision>
      <id>70221</id>
      <parentid>66335</parentid>
      <timestamp>2014-05-12T12:22:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example shows an effect with the default locale.</comment>
      <text xml:space="preserve" bytes="1582">{{c/title|isprint}}
{{c/string/byte/navbar}}
{{ddcl | header=cctype |
int isprint( int ch );
}}

Checks if the given character can be printed, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}), or space, or any character classified as printable by the current C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character can be printed, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isprint(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
 !&quot;#$%&amp;'()*+,-./0123456789:;&lt;=&gt;?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswprint}}
{{dsc see cpp | cpp/string/byte/isprint}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/byte/isprint]]
[[es:c/string/byte/isprint]]
[[fr:c/string/byte/isprint]]
[[it:c/string/byte/isprint]]
[[ja:c/string/byte/isprint]]
[[pt:c/string/byte/isprint]]
[[ru:c/string/byte/isprint]]
[[zh:c/string/byte/isprint]]</text>
      <sha1>fgwh313o7bzx27zoyqwsdpl9u1zjrz9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/ispunct</title>
    <ns>0</ns>
    <id>6049</id>
    <revision>
      <id>70222</id>
      <parentid>66331</parentid>
      <timestamp>2014-05-12T12:26:28Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example shows an effect with the default locale.</comment>
      <text xml:space="preserve" bytes="1369">{{c/title|ispunct}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int ispunct( int ch );
}}

Checks if the given character is a punctuation character in the current C locale. The default C locale classifies the characters {{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}} as punctuation.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a punctuation character, {{tt|0}} ({{c|false}}) otherwise.


===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (ispunct(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswpunct}}
{{dsc see cpp | cpp/string/byte/ispunct}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/byte/ispunct]]
[[es:c/string/byte/ispunct]]
[[fr:c/string/byte/ispunct]]
[[it:c/string/byte/ispunct]]
[[ja:c/string/byte/ispunct]]
[[pt:c/string/byte/ispunct]]
[[ru:c/string/byte/ispunct]]
[[zh:c/string/byte/ispunct]]</text>
      <sha1>fuqmkzs5927be6suovonrpvha4he2ov</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isspace</title>
    <ns>0</ns>
    <id>6052</id>
    <revision>
      <id>69633</id>
      <parentid>66336</parentid>
      <timestamp>2014-04-16T12:48:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.4.1.6 of n1570.</comment>
      <text xml:space="preserve" bytes="1318">{{c/title|isspace}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isspace( int ch );
}}

Checks if the given character is a whitespace character, i.e. either space ({{tt|0x20}}), form feed ({{tt|0x0c}}), line feed ({{tt|0x0a}}), carriage return ({{tt|0x0d}}), horizontal tab ({{tt|0x09}}) or vertical tab ({{tt|0x0b}}).

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a whitespace character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isspace(ndx)) printf(&quot;0x%02x\n&quot;, ndx);

    return 0;
}
 | output=
0x09
0x0a
0x0b
0x0c
0x0d
0x20
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswspace}}
{{dsc see cpp | cpp/string/byte/isspace}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/byte/isspace]]
[[es:c/string/byte/isspace]]
[[fr:c/string/byte/isspace]]
[[it:c/string/byte/isspace]]
[[ja:c/string/byte/isspace]]
[[pt:c/string/byte/isspace]]
[[ru:c/string/byte/isspace]]
[[zh:c/string/byte/isspace]]</text>
      <sha1>6gxqpl3gvxcfknqyr7eybgj8445t0w4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isupper</title>
    <ns>0</ns>
    <id>6057</id>
    <revision>
      <id>70219</id>
      <parentid>66341</parentid>
      <timestamp>2014-05-12T12:02:18Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example shows an effect with the default locale.</comment>
      <text xml:space="preserve" bytes="1501">{{c/title|isupper}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isupper( int ch );
}}

Checks if the given character is an uppercase character according to the current C locale. In the default &quot;C&quot; locale, {{tt|isupper}} returns true only for the uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}).

If {{tt|isupper}} returns {{c|true}}, it is guaranteed that {{lc|iscntrl}}, {{lc|isdigit}}, {{lc|ispunct}}, and {{lc|isspace}} return {{c|false}} for the same character in the same C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an uppercase letter, {{tt|0}} ({{c|false}}) otherwise.


===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isupper(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
ABCDEFGHIJKLMNOPQRSTUVWXYZ
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswupper}}
{{dsc see cpp | cpp/string/byte/isupper}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isupper]]
[[es:c/string/byte/isupper]]
[[fr:c/string/byte/isupper]]
[[it:c/string/byte/isupper]]
[[ja:c/string/byte/isupper]]
[[pt:c/string/byte/isupper]]
[[ru:c/string/byte/isupper]]
[[zh:c/string/byte/isupper]]</text>
      <sha1>m24uepupqhdbimvcufc2be12080ywip</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/isxdigit</title>
    <ns>0</ns>
    <id>6055</id>
    <revision>
      <id>69630</id>
      <parentid>66998</parentid>
      <timestamp>2014-04-16T12:15:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.4.1.12 and 6.4.4.1 of n1570.</comment>
      <text xml:space="preserve" bytes="1600">{{c/title|isxdigit}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int isxdigit( int ch );
}}

Checks if the given character is a hexadecimal numeric character ({{tt|0123456789abcdefABCDEF}}) or is classified as a hexadecimal character.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an hexadecimal numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|isdigit}} and {{tt|isxdigit}} are the only standard narrow character classification functions that are not affected by the currently installed C locale. although some implementations (e.g. Microsoft in 1252 codepage) may classify additional single-byte characters as digits. 
&lt;!-- ref: C standard, note 224 in $7.11.1.1 --&gt;

===Example===
{{example
 | code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;limits.h&gt;
 
int main(void)
{
    for (int ndx=0; ndx&lt;=UCHAR_MAX; ndx++)
        if (isxdigit(ndx)) printf(&quot;%c&quot;, ndx);
    printf(&quot;\n&quot;);

    return 0;
}
 | output=
0123456789ABCDEFabcdef
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswxdigit}}
{{dsc see cpp | cpp/string/byte/isxdigit}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/byte/isxdigit]]
[[es:c/string/byte/isxdigit]]
[[fr:c/string/byte/isxdigit]]
[[it:c/string/byte/isxdigit]]
[[ja:c/string/byte/isxdigit]]
[[pt:c/string/byte/isxdigit]]
[[ru:c/string/byte/isxdigit]]
[[zh:c/string/byte/isxdigit]]</text>
      <sha1>hz3s1hphidqioswcgy9e153cchwqoa3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/memchr</title>
    <ns>0</ns>
    <id>6143</id>
    <revision>
      <id>70115</id>
      <parentid>70114</parentid>
      <timestamp>2014-05-09T20:08:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1376">{{c/title| memchr}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
void* memchr( const void* ptr, int ch, size_t count );
}}
{{dcl end}}

Converts {{tt|ch}} to {{c|unsigned char}} and locates the first occurrence of that value in the initial {{tt|count}} characters (each interpreted as {{c|unsigned char}}) of the object pointed to by {{tt|ptr}}. 

===Parameters===
{{par begin}}
{{par | ptr | pointer to the object to be examined}}
{{par | ch | character to search for}}
{{par | count | number of characters to examine}}
{{par end}}

===Return value===
Pointer to the location of the character, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char str[] = &quot;ABCDEFG&quot;;
    char *ps = memchr(str,'D',strlen(str));
    if (ps != NULL)
       printf (&quot;search character found:  %s\n&quot;, ps);
    else
       printf (&quot;search character not found\n&quot;);
    
    return 0;
}
 | output=
search character found:  DEFG
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strchr}}
{{dsc see cpp | cpp/string/byte/memchr}}
{{dsc end}}

[[de:c/string/byte/memchr]]
[[es:c/string/byte/memchr]]
[[fr:c/string/byte/memchr]]
[[it:c/string/byte/memchr]]
[[ja:c/string/byte/memchr]]
[[pt:c/string/byte/memchr]]
[[ru:c/string/byte/memchr]]
[[zh:c/string/byte/memchr]]</text>
      <sha1>mo8upzzvfsct0nellf4m7duchrn3em1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/memcmp</title>
    <ns>0</ns>
    <id>6144</id>
    <revision>
      <id>70103</id>
      <parentid>56741</parentid>
      <timestamp>2014-05-09T19:26:22Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example.</comment>
      <text xml:space="preserve" bytes="1450">{{c/title| memcmp}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
int memcmp( const void* lhs, const void* rhs, size_t count );
}}

Compares the first {{tt|count}} characters of the objects pointed to by {{tt|lhs}} and {{tt|rhs}}. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the memory buffers to compare}}
{{par | count | number of bytes to examine}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char a1[] = {'a', 'b', 'c'};
    char a2[] = {'a', 'b', 'd'};

    printf(&quot;'abc' vs 'abd': %2d\n&quot;, memcmp(a1, a2, sizeof a1));
    printf(&quot;'abd' vs 'abc': %2d\n&quot;, memcmp(a2, a1, sizeof a1));
    printf(&quot;'abc' vs 'abc': %2d\n&quot;, memcmp(a1, a1, sizeof a1));

    return 0;
}
 | output=
'abc' vs 'abd': -1
'abd' vs 'abc':  1
'abc' vs 'abc':  0
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcmp}}
{{dsc inc | c/string/byte/dsc strncmp}}
{{dsc see cpp | cpp/string/byte/memcmp}}
{{dsc end}}

[[de:c/string/byte/memcmp]]
[[es:c/string/byte/memcmp]]
[[fr:c/string/byte/memcmp]]
[[it:c/string/byte/memcmp]]
[[ja:c/string/byte/memcmp]]
[[pt:c/string/byte/memcmp]]
[[ru:c/string/byte/memcmp]]
[[zh:c/string/byte/memcmp]]</text>
      <sha1>87grynti13am2jrqrsxtden4pxbka4z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/memcpy</title>
    <ns>0</ns>
    <id>6146</id>
    <revision>
      <id>70110</id>
      <parentid>70109</parentid>
      <timestamp>2014-05-09T19:50:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-no longer needed comment</comment>
      <text xml:space="preserve" bytes="2346">{{c/title| memcpy}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
void* memcpy( void          *dest, const void          *src, size_t count );
}}
{{dcl | since=c99 |
void* memcpy( void *restrict dest, const void *restrict src, size_t count );
}}
{{dcl end}}

Copies {{tt|count}} characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. If the objects overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

#define LENGTH_STRING 20

int main(void)
{
    char source[LENGTH_STRING] = &quot;Hello, world!&quot;;
    char target[LENGTH_STRING] = &quot;&quot;;
    int integer[LENGTH_STRING / sizeof(int)] = {0};
    printf(&quot;source: %s\n&quot;, source);
    printf(&quot;target: %s\n&quot;, target);
    printf(&quot;integer: &quot;);
    for (unsigned i = 0; i &lt; sizeof(integer) / sizeof(integer[0]); ++i) {
        printf(&quot;%x &quot;, integer[i]);
    }
    printf(&quot;\n========\n&quot;);
    memcpy(target, source, sizeof source);
    memcpy(integer, source, sizeof source);
    printf(&quot;source: %s\ntarget: %s\n&quot;, source, target);
    printf(&quot;source(hex): &quot;);
    for (unsigned i = 0; i &lt; sizeof(source) / sizeof(source[0]); ++i) {
        printf(&quot;%02x &quot;, source[i]);
    }
    printf(&quot;\n&quot;);
    printf(&quot;integer(hex: %s-endian): &quot;, integer[0] == 0x48656c6c ? &quot;big&quot; : &quot;little&quot;);
    for (unsigned i = 0; i &lt; sizeof(integer) / sizeof(integer[0]); ++i) {
        printf(&quot;%08x &quot;, integer[i]);
    }
    printf(&quot;\n&quot;);
}
 | p=true
 | output=
source: Hello, world!
target: 
integer: 0 0 0 0 0 
========
source: Hello, world!
target: Hello, world!
source(hex): 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 21 00 00 00 00 00 00 00 
integer(hex: big-endian): 48656c6c 6f2c2077 6f726c64 21000000 00000000 
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc memmove}}
{{dsc see cpp | cpp/string/byte/memcpy}}
{{dsc end}}

[[de:c/string/byte/memcpy]]
[[es:c/string/byte/memcpy]]
[[fr:c/string/byte/memcpy]]
[[it:c/string/byte/memcpy]]
[[ja:c/string/byte/memcpy]]
[[pt:c/string/byte/memcpy]]
[[ru:c/string/byte/memcpy]]
[[zh:c/string/byte/memcpy]]</text>
      <sha1>pnat4n10z0djcy7y1n9w6gxaao411l2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/memmove</title>
    <ns>0</ns>
    <id>6147</id>
    <revision>
      <id>70106</id>
      <parentid>67174</parentid>
      <timestamp>2014-05-09T19:36:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1304">{{c/title| memmove}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
void* memmove( void* dest, const void* src, size_t count );
}}

Copies {{tt|count}} characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. The objects may overlap: copying takes place as if the characters were copied to a temporary character array and then the characters were copied from the array to {{tt|dest}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char str[] = &quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;;
    puts (str);
    memmove (str+6,str+3,7);
    puts (str);
    return 0;
}
 | output=
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFDEFGHIJNOPQRSTUVWXYZ
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc memcpy}}
{{dsc see cpp | cpp/string/byte/memmove}}
{{dsc end}}

[[de:c/string/byte/memmove]]
[[es:c/string/byte/memmove]]
[[fr:c/string/byte/memmove]]
[[it:c/string/byte/memmove]]
[[ja:c/string/byte/memmove]]
[[pt:c/string/byte/memmove]]
[[ru:c/string/byte/memmove]]
[[zh:c/string/byte/memmove]]</text>
      <sha1>drdsnyw03glexec4it2hl6zyd6flc7o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/memset</title>
    <ns>0</ns>
    <id>6145</id>
    <revision>
      <id>70104</id>
      <parentid>65684</parentid>
      <timestamp>2014-05-09T19:27:46Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1083">{{c/title| memset}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
void* memset( void* dest, int ch, size_t count );
}}

Converts the value {{tt|ch}} to {{c|unsigned char}} and copies it into each of the first {{tt|count}} characters of the object pointed to by {{tt|dest}}. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the object to fill}}
{{par | ch | fill byte}}
{{par | count | number of bytes to fill}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char str[] = &quot;ghghghghghghghghghghgh&quot;;
    puts(str);
    memset(str,'a',5);
    puts(str);
    return 0;
}
 | output=
ghghghghghghghghghghgh
aaaaahghghghghghghghgh
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc memcpy}}
{{dsc see cpp | cpp/string/byte/memset}}
{{dsc end}}

[[de:c/string/byte/memset]]
[[es:c/string/byte/memset]]
[[fr:c/string/byte/memset]]
[[it:c/string/byte/memset]]
[[ja:c/string/byte/memset]]
[[pt:c/string/byte/memset]]
[[ru:c/string/byte/memset]]
[[zh:c/string/byte/memset]]</text>
      <sha1>nlzirko8vcgybabepy43vw8kkvx6ojm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strcat</title>
    <ns>0</ns>
    <id>6129</id>
    <revision>
      <id>70087</id>
      <parentid>65782</parentid>
      <timestamp>2014-05-09T13:24:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1507">{{c/title| strcat}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
char *strcat( char          *dest, const char          *src );
}}
{{dcl | since=c99 |
char *strcat( char *restrict dest, const char *restrict src );
}}
{{dcl end}}

Appends a byte string pointed to by {{tt|src}} to a byte string pointed to by {{tt|dest}}. The resulting byte string is null-terminated. 

The destination byte string must be large enough for the contents of both {{tt|str}} and {{tt|dest}} and the terminating null character.

The behavior is undefined if the strings overlap. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to append to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt; 
#include &lt;stdio.h&gt;

int main(void) 
{
    char str[50] = &quot;Hello &quot;;
    char str2[50] = &quot;World!&quot;;
    strcat(str, str2);
    strcat(str, &quot; ...&quot;);
    strcat(str, &quot; Goodbye World!&quot;);
    puts(str);
}
 | output=
Hello World! ... Goodbye World!
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strncat}}
{{dsc inc | c/string/byte/dsc strcpy}}
{{dsc see cpp | cpp/string/byte/strcat}}
{{dsc end}}

[[de:c/string/byte/strcat]]
[[es:c/string/byte/strcat]]
[[fr:c/string/byte/strcat]]
[[it:c/string/byte/strcat]]
[[ja:c/string/byte/strcat]]
[[pt:c/string/byte/strcat]]
[[ru:c/string/byte/strcat]]
[[zh:c/string/byte/strcat]]</text>
      <sha1>nrc8ujraeqlrgaeg9ixiav22wxac6eb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strchr</title>
    <ns>0</ns>
    <id>6136</id>
    <revision>
      <id>70094</id>
      <parentid>69110</parentid>
      <timestamp>2014-05-09T17:44:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1185">{{c/title| strchr}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
char *strchr( const char *str, int ch );
}}
{{dcl end}}

Finds the first occurrence of the character {{tt|ch}} in the byte string pointed to by {{tt|str}}. 

The terminating null character is considered to be a part of the string.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be analyzed}}
{{par | ch | character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;
 
int main(void)
{
    char str[] = &quot;Hello World&quot;;
    char *ptr = strchr(str, 'W');
    printf(&quot;%s&quot;, ptr);
}
 | output=World
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strrchr}}
{{dsc inc | c/string/byte/dsc strpbrk}}
{{dsc see cpp | cpp/string/byte/strchr}}
{{dsc end}}

[[de:c/string/byte/strchr]]
[[es:c/string/byte/strchr]]
[[fr:c/string/byte/strchr]]
[[it:c/string/byte/strchr]]
[[ja:c/string/byte/strchr]]
[[pt:c/string/byte/strchr]]
[[ru:c/string/byte/strchr]]
[[zh:c/string/byte/strchr]]</text>
      <sha1>419xm1uvwuz7mvna4fnv0yhe0f6duhy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strcmp</title>
    <ns>0</ns>
    <id>6133</id>
    <revision>
      <id>70091</id>
      <parentid>65379</parentid>
      <timestamp>2014-05-09T14:40:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1652">{{c/title| strcmp}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
int strcmp( const char *lhs, const char *rhs );
}}

Compares two null-terminated byte strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

int main(void) 
{
    const char* string = &quot;Hello World!&quot;;

    //Matches
    int a = strcmp(string, &quot;Hello World!&quot;);
    if (a == 0) {
        printf(&quot;Strings are matching.\n&quot;);
    }

    //Greater than
    int b = strcmp(string, &quot;Hello&quot;);
    if (b &gt;= 1) {
        printf(&quot;Left hand side is bigger than right hand side.\n&quot;);
    }

    //less than
    int c = strcmp(string, &quot;Hello there world!&quot;);
    if (c &lt;= -1) {
        printf(&quot;Left hand side is smaller than right hand side.\n&quot;);
    }
}
 | output=
Strings are matching.
Left hand side is bigger than right hand side.
Left hand side is smaller than right hand side.
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strncmp}}
{{dsc inc | c/string/byte/dsc memcmp}}
{{dsc inc | c/string/byte/dsc strcoll}}
{{dsc see cpp | cpp/string/byte/strcmp}}
{{dsc end}}

[[de:c/string/byte/strcmp]]
[[es:c/string/byte/strcmp]]
[[fr:c/string/byte/strcmp]]
[[it:c/string/byte/strcmp]]
[[ja:c/string/byte/strcmp]]
[[pt:c/string/byte/strcmp]]
[[ru:c/string/byte/strcmp]]
[[zh:c/string/byte/strcmp]]</text>
      <sha1>414mziovt6ut31g1km21opjtz56rl0y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strcoll</title>
    <ns>0</ns>
    <id>6135</id>
    <revision>
      <id>70093</id>
      <parentid>56754</parentid>
      <timestamp>2014-05-09T17:42:01Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1646">{{c/title| strcoll}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
int strcoll( const char *lhs, const char *rhs );
}}

Compares two null-terminated byte strings according to the current locale as defined by the {{lc|LC_COLLATE}} category.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;locale.h&gt;

int main(void)
{
    setlocale(LC_COLLATE, &quot;cs_CZ.iso88592&quot;);

    const char* s1 = &quot;hrnec&quot;;
    const char* s2 = &quot;chrt&quot;;

    printf(&quot;In the Czech locale: &quot;);
    if(strcoll(s1, s2) &lt; 0)
         printf(&quot;%s before %s\n&quot;, s1, s2);
    else
         printf(&quot;%s before %s\n&quot;, s2, s1);

    printf(&quot;In lexicographical comparison: &quot;);
    if(strcmp(s1, s2) &lt; 0)
         printf(&quot;%s before %s\n&quot;, s1, s2);
    else
         printf(&quot;%s before %s\n&quot;, s2, s1);
}
 | output=
In the Czech locale: hrnec before chrt
In lexicographical comparison: chrt before hrnec
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcmp}}
{{dsc inc | c/string/byte/dsc strncmp}}
{{dsc inc | c/string/byte/dsc memcmp}}
{{dsc see cpp | cpp/string/byte/strcoll}}
{{dsc end}}

[[de:c/string/byte/strcoll]]
[[es:c/string/byte/strcoll]]
[[fr:c/string/byte/strcoll]]
[[it:c/string/byte/strcoll]]
[[ja:c/string/byte/strcoll]]
[[pt:c/string/byte/strcoll]]
[[ru:c/string/byte/strcoll]]
[[zh:c/string/byte/strcoll]]</text>
      <sha1>7xfjgxxeulv3x9jx60bwtfqlxuo816l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strcpy</title>
    <ns>0</ns>
    <id>6127</id>
    <revision>
      <id>70086</id>
      <parentid>66822</parentid>
      <timestamp>2014-05-09T13:22:51Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1363">{{c/title| strcpy}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
char *strcpy( char          *dest, const char          *src );
}}
{{dcl | since=c99 |
char *strcpy( char *restrict dest, const char *restrict src );
}}
{{dcl end}}

Copies the byte string pointed to by {{tt|src}} to byte string, pointed to by {{tt|dest}}.

If the strings overlap, the behavior is undefined.  Also copies the terminating null-byte.

===Parameters===
{{par begin}}
{{par | dest | pointer to the byte string to copy to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char A[] = &quot;Take the test.&quot;;
    char *B = malloc(strlen(A) + 1);
    strcpy(B, A);
    A[0] = 'M';
    printf(&quot;A = %s\nB = %s&quot;, A, B);

    return 0;
}
 | output=A = Make the test.
B = Take the test.
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strncpy}}
{{dsc inc | c/string/byte/dsc memcpy}}
{{dsc see cpp | cpp/string/byte/strcpy}}
{{dsc end}}

[[de:c/string/byte/strcpy]]
[[es:c/string/byte/strcpy]]
[[fr:c/string/byte/strcpy]]
[[it:c/string/byte/strcpy]]
[[ja:c/string/byte/strcpy]]
[[pt:c/string/byte/strcpy]]
[[ru:c/string/byte/strcpy]]
[[zh:c/string/byte/strcpy]]</text>
      <sha1>nhrk4rcy2br44ucjj4ceed1fpykxk1e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strcspn</title>
    <ns>0</ns>
    <id>6139</id>
    <revision>
      <id>70097</id>
      <parentid>56758</parentid>
      <timestamp>2014-05-09T18:07:20Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>completed the program so that it actually works</comment>
      <text xml:space="preserve" bytes="1324">{{c/title| strcspn}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
size_t strcspn( const char *dest, const char *src );
}}

Returns the length of the maximum initial segment of the byte string pointed to by {{tt|dest}}, that consists of only the characters ''not'' found in byte string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | src | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters not found in the byte string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;
 
int main(void)
{
    char *string_find = &quot;abcdefg**&quot;;
    char *character = &quot;*&quot;;
    printf(&quot;%zu&quot;, strcspn(string_find, character));

    return 0;
}
 | output=
7
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strspn}}
{{dsc inc | c/string/byte/dsc strpbrk}}
{{dsc see cpp | cpp/string/byte/strcspn}}
{{dsc end}}

[[de:c/string/byte/strcspn]]
[[es:c/string/byte/strcspn]]
[[fr:c/string/byte/strcspn]]
[[it:c/string/byte/strcspn]]
[[ja:c/string/byte/strcspn]]
[[pt:c/string/byte/strcspn]]
[[ru:c/string/byte/strcspn]]
[[zh:c/string/byte/strcspn]]</text>
      <sha1>53hrjxx7eb9ikdcyv4wx4vjz2wfbo1h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strerror</title>
    <ns>0</ns>
    <id>6148</id>
    <revision>
      <id>49106</id>
      <parentid>46500</parentid>
      <timestamp>2013-06-01T01:41:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1540">{{c/title| strerror}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
char* strerror( int errnum );
}}

Returns text version of the error code {{tt|errnum}}. {{tt|errnum}} is usually acquired from the {{tt|errno}} variable, however the function accepts any value of type {{c|int}}. The message is locale-specific.

The returned byte string must not be modified by the program, but may be overwritten by a subsequent call to the {{tt|strerror}} function. 

===Parameters===
{{par begin}}
{{par | errnum | integral value referring to a error code}}
{{par end}}

===Return value===
Pointer to a null-terminated byte string corresponding to the error code {{tt|errnum}}.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    FILE *fp;
    char *path = &quot;/path/to/non_existing_file&quot;;

    errno = 0;
    if ((fp = fopen(path, &quot;r&quot;)) == NULL) {
        char *error_str = strerror(errno);
        printf(&quot;Can't open \&quot;%s\&quot;: %s\n&quot;, path, error_str);
    }
    printf(&quot;Error string for EINVAL: %s\n&quot;, strerror(EINVAL));

    return 0;
}
 | output=
Can't open &quot;/path/to/non_existing_file&quot;: No such file or directory
Error string for EINVAL: Invalid argument
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/byte/strerror}}
{{dsc end}}

[[de:c/string/byte/strerror]]
[[es:c/string/byte/strerror]]
[[fr:c/string/byte/strerror]]
[[it:c/string/byte/strerror]]
[[ja:c/string/byte/strerror]]
[[pt:c/string/byte/strerror]]
[[ru:c/string/byte/strerror]]
[[zh:c/string/byte/strerror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strlen</title>
    <ns>0</ns>
    <id>6132</id>
    <revision>
      <id>72212</id>
      <parentid>72211</parentid>
      <timestamp>2014-07-24T04:12:08Z</timestamp>
      <contributor>
        <ip>218.215.188.202</ip>
      </contributor>
      <text xml:space="preserve" bytes="1063">{{c/title| strlen}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
size_t strlen( const char *str );
}}

Returns the length of the given byte string.


The null character is excluded from the length.
===Parameters===
{{par begin}}
{{par |str | pointer to the null-terminated byte string to be examined}}
{{par end}}

===Return value===
The length of the null-terminated string {{tt|str}}.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    const char str[] = &quot;How many characters does this string contain?&quot;;

    printf(&quot;without null character: %zu\n&quot;, strlen(str));
    printf(&quot;with null character: %zu\n&quot;, sizeof(str));

    return 0;
}
 | output=
without null character: 45
with null character: 46
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/byte/strlen}}
{{dsc end}}

[[de:c/string/byte/strlen]]
[[es:c/string/byte/strlen]]
[[fr:c/string/byte/strlen]]
[[it:c/string/byte/strlen]]
[[ja:c/string/byte/strlen]]
[[pt:c/string/byte/strlen]]
[[ru:c/string/byte/strlen]]
[[zh:c/string/byte/strlen]]</text>
      <sha1>a06ja6x6kccdkhe6vi2mw9dmwkzwbgt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strncat</title>
    <ns>0</ns>
    <id>6130</id>
    <revision>
      <id>70088</id>
      <parentid>62619</parentid>
      <timestamp>2014-05-09T13:26:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1689">{{c/title| strncat}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
char *strncat( char          *dest, const char          *src, size_t count );
}}
{{dcl | since=c99 |
char *strncat( char *restrict dest, const char *restrict src, size_t count );
}}
{{dcl end}}

Appends a byte string pointed to by {{tt|src}} to a byte string pointed to by {{tt|dest}}. At most {{tt|count}} characters from {{tt|src}} are copied. The resulting byte string is null-terminated.

The destination byte string must have enough space for the contents of both {{tt|dest}} and {{tt|src}} plus the terminating null character, except that the size of {{tt|src}} is limited to {{tt|count}}.

The behavior is undefined if the strings overlap. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to append to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par | count | maximum number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt; 
#include &lt;stdio.h&gt;

int main(void) 
{
    char str[50] = &quot;Hello &quot;;
    char str2[50] = &quot;World!&quot;;
    strcat(str, str2);
    strncat(str, &quot; Goodbye World!&quot;, 3);
    puts(str);
}
 | output=
Hello World! Go
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcat}}
{{dsc inc | c/string/byte/dsc strcpy}}
{{dsc see cpp | cpp/string/byte/strncat}}
{{dsc end}}

[[de:c/string/byte/strncat]]
[[es:c/string/byte/strncat]]
[[fr:c/string/byte/strncat]]
[[it:c/string/byte/strncat]]
[[ja:c/string/byte/strncat]]
[[pt:c/string/byte/strncat]]
[[ru:c/string/byte/strncat]]
[[zh:c/string/byte/strncat]]</text>
      <sha1>s9x5h3wcsbkxbui3ej917squfls3pvb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strncmp</title>
    <ns>0</ns>
    <id>6134</id>
    <revision>
      <id>70092</id>
      <parentid>62023</parentid>
      <timestamp>2014-05-09T14:43:55Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main; corrected function name to remove the compiler error</comment>
      <text xml:space="preserve" bytes="1875">{{c/title| strncmp}}
{{c/string/byte/navbar}}
{{ddcl | header=string.h |
int strncmp( const char *lhs, const char *rhs, size_t count );
}}

Compares at most {{tt|count}} characters of two null-terminated byte strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par | count | maximum number of characters to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

int main(void) 
{
    const char* string = &quot;Hello World!&quot;;
    const int size = strlen(string);
    //Matches
    int a = strncmp(string, &quot;Hello World!&quot;, 5);
    if (a == 0) {
        printf(&quot;The 5 first char of each string are matching.\n&quot;);
    }
    
    //Greater than
    int b = strncmp(string, &quot;Hello&quot;, size);
    if (b &gt;= 1) {
        printf(&quot;Left hand side is bigger than right hand side.\n&quot;);
    }

    //less than
    int c = strncmp(string, &quot;Hello there world!&quot;, size);
    if (c &lt;= -1) {
        printf(&quot;Left hand side is smaller than right hand side.\n&quot;);
    }
}
 | output=
The 5 first char of each string are matching.
Left hand side is bigger than right hand side.
Left hand side is smaller than right hand side.
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcmp}}
{{dsc inc | c/string/byte/dsc memcmp}}
{{dsc inc | c/string/byte/dsc strcoll}}
{{dsc see cpp | cpp/string/byte/strncmp}}
{{dsc end}}

[[de:c/string/byte/strncmp]]
[[es:c/string/byte/strncmp]]
[[fr:c/string/byte/strncmp]]
[[it:c/string/byte/strncmp]]
[[ja:c/string/byte/strncmp]]
[[pt:c/string/byte/strncmp]]
[[ru:c/string/byte/strncmp]]
[[zh:c/string/byte/strncmp]]</text>
      <sha1>6pmh12qcos61u7nnv3eww6jnmm1yrk1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strncpy</title>
    <ns>0</ns>
    <id>6128</id>
    <revision>
      <id>69938</id>
      <parentid>69937</parentid>
      <timestamp>2014-05-02T11:56:37Z</timestamp>
      <contributor>
        <username>Armin</username>
        <id>3064</id>
      </contributor>
      <text xml:space="preserve" bytes="1992">{{c/title| strncpy}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
char *strncpy( char          *dest, const char          *src, size_t count );
}}
{{dcl | since=c99 |
char *strncpy( char *restrict dest, const char *restrict src, size_t count );
}}
{{dcl end}}

Copies at most {{tt|count}} characters of the byte string pointed to by {{tt|src}} (including the terminating null character) to character array pointed to by {{tt|dest}}. 

If {{tt|count}} is reached before the entire string {{tt|src}} was copied, the resulting character array is not null-terminated.

If, after copying the terminating null character from {{tt|src}}, {{tt|count}} is not reached, additional null characters are written to {{tt|dest}} until the total of {{tt|count}} characters have been written.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the character array to copy to}}
{{par | src | pointer to the byte string to copy from}}
{{par | count | maximum number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void)
{
    char str[] = &quot;Hello, world!&quot;;
    char copy[40] = { 0 };

    /* no buffer overflow */
    strncpy(copy, str, sizeof(copy)-1);
    printf(&quot;%s\n&quot;, copy);

    /* copy partial amount of data */
    strncpy(copy, str, 5);

    /* add manually nullbyte.
     * comment it to see difference */
    copy[5] = '\0';
    printf(&quot;%s\n&quot;, copy);

    return 0;
}
 | output=
Hello, world!
Hello
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcpy}}
{{dsc inc | c/string/byte/dsc memcpy}}
{{dsc see cpp | cpp/string/byte/strncpy}}
{{dsc end}}

[[de:c/string/byte/strncpy]]
[[es:c/string/byte/strncpy]]
[[fr:c/string/byte/strncpy]]
[[it:c/string/byte/strncpy]]
[[ja:c/string/byte/strncpy]]
[[pt:c/string/byte/strncpy]]
[[ru:c/string/byte/strncpy]]
[[zh:c/string/byte/strncpy]]</text>
      <sha1>blzeqeek8g197fo91yqx1q3fspcw7xb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strpbrk</title>
    <ns>0</ns>
    <id>6140</id>
    <revision>
      <id>70098</id>
      <parentid>56764</parentid>
      <timestamp>2014-05-09T18:31:36Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main; deleted a semicolon to remove a compiler error</comment>
      <text xml:space="preserve" bytes="1456">{{c/title| strpbrk}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
char* strpbrk( const char* dest, const char* str );
}}
{{dcl end}}

Finds the first character in byte string pointed to by {{tt|dest}}, that is also in byte string pointed to by {{tt|str}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | str | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
Pointer to the first character in {{tt|dest}}, that is also in {{tt|str}}, or {{lc|NULL}} if no such character exists.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;

int main(void) 
{
    char* input = &quot;hello world friend of mine&quot;;
    char* space = &quot; &quot;;
    char* pos = input;
    int word_counter = 0;

    do {
        pos = strpbrk(pos, space);
        word_counter++;
        pos ? pos++ : pos;
        printf(&quot;%d\n&quot;, word_counter);
    } while (pos != NULL);

    return 0;
}
 | output=
1
2
3
4
5
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcspn}}
{{dsc inc | c/string/byte/dsc strchr}}
{{dsc see cpp | cpp/string/byte/strpbrk}}
{{dsc end}}

[[de:c/string/byte/strpbrk]]
[[es:c/string/byte/strpbrk]]
[[fr:c/string/byte/strpbrk]]
[[it:c/string/byte/strpbrk]]
[[ja:c/string/byte/strpbrk]]
[[pt:c/string/byte/strpbrk]]
[[ru:c/string/byte/strpbrk]]
[[zh:c/string/byte/strpbrk]]</text>
      <sha1>86k3dm0weg6rn9nlxfak7o7y2olrcp2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strrchr</title>
    <ns>0</ns>
    <id>6137</id>
    <revision>
      <id>70095</id>
      <parentid>56765</parentid>
      <timestamp>2014-05-09T17:59:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="1399">{{c/title| strrchr}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
char *strrchr( const char *str, int ch );
}}
{{dcl end}}

Finds the last occurrence of {{tt|ch}} (after conversion to {{c|char}}) in the byte string pointed to by {{tt|str}}. The terminating null character is considered to be a part of the string and can be found if searching for {{c|'\0'}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be analyzed}}
{{par | ch | character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or null pointer if no such character is found.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    char szSomeFileName[] = &quot;foo/bar/foobar.txt&quot;;
    char *pLastSlash = strrchr(szSomeFileName, '/');
    char *pszBaseName = pLastSlash ? pLastSlash + 1 : szSomeFileName;
    printf(&quot;Base Name: %s&quot;, pszBaseName);
}
 | output=
Base Name: foobar.txt
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strchr}}
{{dsc inc | c/string/byte/dsc strpbrk}}
{{dsc see cpp | cpp/string/byte/strrchr}}
{{dsc end}}

[[de:c/string/byte/strrchr]]
[[es:c/string/byte/strrchr]]
[[fr:c/string/byte/strrchr]]
[[it:c/string/byte/strrchr]]
[[ja:c/string/byte/strrchr]]
[[pt:c/string/byte/strrchr]]
[[ru:c/string/byte/strrchr]]
[[zh:c/string/byte/strrchr]]</text>
      <sha1>qtf5dnwymaf8axp72ea1ymkezddfyax</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strspn</title>
    <ns>0</ns>
    <id>6138</id>
    <revision>
      <id>70096</id>
      <parentid>62262</parentid>
      <timestamp>2014-05-09T18:02:46Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>C main; changed format specifier to remove a compiler warning</comment>
      <text xml:space="preserve" bytes="1350">{{c/title| strspn}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
size_t strspn( const char *dest, const char *src );
}}
{{dcl end}}

Returns the length of the maximum initial segment of the byte string pointed to by {{tt|dest}}, that consists of only the characters found in byte string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | src | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters from byte string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

int main(void)
{
    char *string_find = &quot;abcde312$#@&quot;;
    char *low_alpha = &quot;qwertyuiopasdfghjklzxcvbnm&quot;;
    printf(&quot;%zu&quot;, strspn(string_find, low_alpha));
    return 0;
}
 | output=5
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strcspn}}
{{dsc inc | c/string/byte/dsc strpbrk}}
{{dsc see cpp | cpp/string/byte/strspn}}
{{dsc end}}

[[de:c/string/byte/strspn]]
[[es:c/string/byte/strspn]]
[[fr:c/string/byte/strspn]]
[[it:c/string/byte/strspn]]
[[ja:c/string/byte/strspn]]
[[pt:c/string/byte/strspn]]
[[ru:c/string/byte/strspn]]
[[zh:c/string/byte/strspn]]</text>
      <sha1>28nfsxsxzy8cl87rdwp63gxqohvo54i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strstr</title>
    <ns>0</ns>
    <id>6141</id>
    <revision>
      <id>70099</id>
      <parentid>65943</parentid>
      <timestamp>2014-05-09T19:07:59Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>%d replaced with %ld and C main to remove compiler warnings</comment>
      <text xml:space="preserve" bytes="1865">{{c/title| strstr}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl |
char *strstr( const char* str, const char* substr );
}}
{{dcl end}}

Finds the first occurrence of the byte string {{tt|substr}} in the byte string pointed to by {{tt|str}}. The terminating null characters  are not compared.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to examine}}
{{par | substr | pointer to the null-terminated byte string to search for}}
{{par end}}

===Return value===
Pointer to the first character of the found substring in {{tt|str}}, or {{lc|NULL}} if no such substring is found. If {{tt|substr}} points to an empty string, {{tt|str}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;string.h&gt;
#include &lt;stdio.h&gt;

void find_str(char const* str, char const* substr) 
{
    char* pos = strstr(str, substr);
    if(pos) {
        printf(&quot;found the string '%s' in '%s' at position: %ld\n&quot;, substr, str, pos - str);
    } else {
        printf(&quot;the string '%s' was not found in '%s'\n&quot;, substr, str);
    }
}

int main(void) 
{
    char* str = &quot;one two three&quot;;
    find_str(str, &quot;two&quot;);
    find_str(str, &quot;&quot;);
    find_str(str, &quot;nine&quot;);
    find_str(str, &quot;n&quot;);

    return 0;
}

 | output=
found the string 'two' in 'one two three' at position: 4
found the string '' in 'one two three' at position: 0
the string 'nine' was not found in 'one two three'
found the string 'n' in 'one two three' at position: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strchr}}
{{dsc inc | c/string/byte/dsc strrchr}}
{{dsc see cpp | cpp/string/byte/strstr}}
{{dsc end}}

[[de:c/string/byte/strstr]]
[[es:c/string/byte/strstr]]
[[fr:c/string/byte/strstr]]
[[it:c/string/byte/strstr]]
[[ja:c/string/byte/strstr]]
[[pt:c/string/byte/strstr]]
[[ru:c/string/byte/strstr]]
[[zh:c/string/byte/strstr]]</text>
      <sha1>g4qj7wwdqn0v51mic96ejj4r573pd2l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtod</title>
    <ns>0</ns>
    <id>6514</id>
    <redirect title="c/string/byte/strtof" />
    <revision>
      <id>25686</id>
      <timestamp>2012-04-23T21:07:58Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/string/byte/strtof]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtof</title>
    <ns>0</ns>
    <id>6126</id>
    <revision>
      <id>70085</id>
      <parentid>67322</parentid>
      <timestamp>2014-05-09T13:17:56Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2176">{{c/title| strtof | strtod | strtold}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl | since=c99 |
float       strtof( const char *restrict str, char **restrict str_end );           
}}
{{dcl rev begin}}
{{dcl | until=c99 |
double      strtod( const char          *str, char          **str_end );
}}
{{dcl | since=c99 |
double      strtod( const char *restrict str, char **restrict str_end );
}}
{{dcl rev end}}
{{dcl | since=c99 |
long double strtold( const char *restrict str, char **restrict str_end );
}}
{{dcl end}}

Interprets a floating point value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par end}}

===Return value===
Floating point value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|HUGE_VAL}}, {{lc|HUGE_VALF}} or {{lc|HUGE_VALL}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

int main(void) 
{
    char *str = &quot; 111.11 22.22 0X1.BC70A3D70A3D7P+6  1.18973e+4932&quot;;
    char *str_end;
 
    printf(&quot;%f\n&quot;, strtod(str,&amp;str_end));
    printf(&quot;str_end --&gt; [%c]\n&quot;, *str_end);
    printf(&quot;%f\n&quot;, strtod(str_end,&amp;str_end));
    printf(&quot;%g\n&quot;, strtod(str_end,&amp;str_end));
    printf(&quot;%f\n&quot;, strtod(str_end, NULL));
 
    return 0;
}
 | output=
111.110001
str_end --&gt; [ ]
22.219999
111.11
inf
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc atof}}
{{dsc see cpp | cpp/string/byte/strtof | strtof | strtod | strtold}}
{{dsc end}}

[[de:c/string/byte/strtof]]
[[es:c/string/byte/strtof]]
[[fr:c/string/byte/strtof]]
[[it:c/string/byte/strtof]]
[[ja:c/string/byte/strtof]]
[[pt:c/string/byte/strtof]]
[[ru:c/string/byte/strtof]]
[[zh:c/string/byte/strtof]]</text>
      <sha1>t3nnb9ygh2lf5xz5eoqfeg843jz3rdi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtoimax</title>
    <ns>0</ns>
    <id>9913</id>
    <revision>
      <id>69639</id>
      <parentid>62622</parentid>
      <timestamp>2014-04-16T15:22:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>New example based on 7.8.2.3 of n1570.</comment>
      <text xml:space="preserve" bytes="2755">{{c/title| strtoimax| strtoumax}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | inttypes.h}}
{{dcl | since=c99 | 
intmax_t strtoimax( const char *restrict nptr, 
                    char **restrict endptr, int base );
}}
{{dcl | since=c99 |
uintmax_t strtoumax( const char *restrict nptr, 
                     char **restrict endptr, int base );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|nptr}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|endptr}} to point to the character past the last character interpreted. If {{tt|endptr}} is {{lc|NULL}}, it is ignored.

If the {{tt|nptr}} is empty or does not have the expected form, no conversion is performed, and (if {{tt|enptr}} is not {{lc|NULL}}) the value of {{tt|nptr}} is stored in the object pointed to by {{tt|endptr}}.

===Parameters===
{{par begin}}
{{par | nptr | pointer to the null-terminated byte string to be interpreted}}
{{par | endptr | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===

* If successful, an integer value corresponding to the contents of {{tt|str}} is returned.
* If the converted value falls out of range of corresponding return type, a range error occurs (setting [[cpp/error/errno|{{lc|errno}}]] to {{lc|ERANGE}}) and {{lc|INTMAX_MAX}}, {{lc|INTMAX_MIN}}, {{lc|UINTMAX_MAX}} or {{c|0}} is returned, as appropriate.
* If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;inttypes.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;
 
int main(void)
{
    
    char* endptr;
    
    printf(&quot;%ld\n&quot;, strtoimax(&quot; -123junk&quot;,&amp;endptr,10)); /* base 10                    */
    printf(&quot;%ld\n&quot;, strtoimax(&quot;11111111&quot;,&amp;endptr,2));   /* base 2                     */
    printf(&quot;%ld\n&quot;, strtoimax(&quot;XyZ&quot;,&amp;endptr,36));       /* base 36                    */
    printf(&quot;%ld\n&quot;, strtoimax(&quot;010&quot;,&amp;endptr,0));        /* octal auto-detection       */
    printf(&quot;%ld\n&quot;, strtoimax(&quot;10&quot;,&amp;endptr,0));         /* decimal auto-detection     */
    printf(&quot;%ld\n&quot;, strtoimax(&quot;0x10&quot;,&amp;endptr,0));       /* hexadecimal auto-detection */
 
    /* range error             */
    /* LONG_MAX+1 --&gt; LONG_MAX */
    errno = 0;
    printf(&quot;%ld\n&quot;, strtoimax(&quot;9223372036854775808&quot;,&amp;endptr,10));
    printf(&quot;%s\n&quot;, strerror(errno));
    
    return 0;
}
| output=
-123
255
44027
8
10
16
9223372036854775807
Numerical result out of range
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcstoimax}}
{{dsc inc | c/string/byte/dsc strtol}}
{{dsc inc | c/string/byte/dsc strtoul}}
{{dsc see cpp | cpp/string/byte/strtoimax | strtoimax | strtoumax}}
{{dsc end}}</text>
      <sha1>t2ws5iirw11spiplarauzhhiblyg8xe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtok</title>
    <ns>0</ns>
    <id>6142</id>
    <revision>
      <id>70102</id>
      <parentid>65165</parentid>
      <timestamp>2014-05-09T19:17:16Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="3427">{{c/title| strtok}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 | 1=
char *strtok( char          *str, const char          *delim );
}}
{{dcl | since=c99 |1=
char *strtok( char *restrict str, const char *restrict delim );
}}
{{dcl end}}

Finds the next token in a null-terminated byte string pointed to by {{tt|str}}. The separator characters are identified by null-terminated byte string pointed to by {{tt|delim}}.

This function is designed to be called multiples times to obtain successive tokens from the same string.

* If {{c|str !{{=}} NULL}}, the call is treated as the first call to {{tt|strtok}} for this particular string. The function searches for the first character which is ''not'' contained in {{tt|delim}}.
:* If no such character was found, there are no tokens in {{tt|str}} at all, and the function returns a null pointer. 
:* If such character was found, it is the ''beginning of the token''. The function then searches from that point on for the first character that ''is'' contained in {{tt|delim}}. 
::* If no such character was found, {{tt|str}} has only one token, and future calls to {{tt|strtok}} will return a null pointer
::* If such character was found, it is ''replaced'' by the null character {{c|'\0'}} and the pointer to the following character is stored in a static location for subsequent invocations.
:* The function then returns the pointer to the beginning of the token
* If {{c|str {{==}} NULL}}, the call is treated as a subsequent calls to {{tt|strtok}}: the function continues from where it left in previous invocation. The behavior is the same as if the previously stored pointer is passed as {{c|str}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to tokenize}}
{{par | delim | pointer to the null-terminated byte string identifying delimiters}}
{{par end}}

===Return value===
Pointer to the beginning of the next token or {{lc|NULL}} if there are no more tokens.

===Note===
This function is destructive: it writes the {{c|'\0'}} characters in the elements of the string {{tt|str}}. In particular, a string literal cannot be used as the first argument of {{tt|strtok}}.

Each call to this function modifies a static variable: is not thread safe.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;

int main(void) 
{
    char *str = malloc(20);
    char *tok = NULL;
    int len = 0;

    strcpy(str, &quot;This is a string&quot;);
    len = strlen(str);

    printf(&quot;string before strtok(): %s\n&quot;, str);
    tok = strtok(str, &quot; &quot;);
    while (tok) {
        printf(&quot;Token: %s\n&quot;, tok);
        tok = strtok(NULL, &quot; &quot;);
    }

    printf(&quot;Print mangled string after strtok()\n&quot;);
    for (int i = 0; i &lt; len; i++) {
        if (str[i] == '\0') {
            printf(&quot;'\\0'&quot;);
        } else {
            printf(&quot;%c&quot;, str[i]);
        }
    }
    printf(&quot;\n&quot;);
    free(str);

    return 0;
}
 | output=
string before strtok(): This is a string
Token: This
Token: is
Token: a
Token: string
Print mangled string after strtok()
This'\0'is'\0'a'\0'string

}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/byte/strtok}}
{{dsc end}}

[[de:c/string/byte/strtok]]
[[es:c/string/byte/strtok]]
[[fr:c/string/byte/strtok]]
[[it:c/string/byte/strtok]]
[[ja:c/string/byte/strtok]]
[[pt:c/string/byte/strtok]]
[[ru:c/string/byte/strtok]]
[[zh:c/string/byte/strtok]]</text>
      <sha1>gw6nqdlipslx7tub3u3m61rpv3vi7i0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtol</title>
    <ns>0</ns>
    <id>6124</id>
    <revision>
      <id>70083</id>
      <parentid>67321</parentid>
      <timestamp>2014-05-09T12:59:30Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main; hide errno</comment>
      <text xml:space="preserve" bytes="3053">{{c/title| strtol | strtoll}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
long      strtol( const char          *str, char          **str_end, int base );
}}
{{dcl | since=c99 |
long      strtol( const char *restrict str, char **restrict str_end, int base );
}}
{{dcl rev end}}
{{dcl | since=c99 |
long long strtoll( const char *restrict str, char **restrict str_end, int base );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

If the {{tt|str}} is empty or does not have the expected form, no conversion is performed, and (if {{tt|str_end}} is not {{lc|NULL}}) the value of {{tt|str}} is stored in the object pointed to by {{tt|str_end}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
* If successful, an integer value corresponding to the contents of {{tt|str}} is returned.
* If the converted value falls out of range of corresponding return type, a range error occurs (setting {{lc|errno}} to {{lc|ERANGE}}) and {{lc|LONG_MAX}}, {{lc|LONG_MIN}}, {{lc|LLONG_MAX}} or {{lc|LLONG_MIN}} is returned. 
* If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;errno.h&gt;

int main(void)
{
    char str[] = &quot;Is 0xff bigger than 0 or 0x00? The answer is 42.&quot;;
    int i = 0;
    int len = strlen(str);
    char *num;

    while (i &lt; len) {
        long found = strtol(&amp;str[i], &amp;num, 0);

        if (errno) {
            perror(&quot;Error&quot;);
            exit(EXIT_FAILURE);
        } else if (found {{!}}{{!}} num != &amp;str[i]) {
            printf(&quot;Found %li at position %d\n&quot;, found, i);
            i = num - str;
        } else {
            i++;
        }
    }

    /* Base 36 */
    printf(&quot;\n%ld\n&quot;, strtol(&quot;XyZ&quot;,NULL,36));

    /* Overflow (range error) */
    errno = 0;
    printf(&quot;%ld\n&quot;, strtol(&quot;9223372036854775808&quot;,NULL,10));   // LONG_MAX+1 --&gt; LONG_MAX
    printf(&quot;%s\n&quot;,strerror(errno));                           // range error

    return 0;
}
 | output=
Found 255 at position 2
Found 0 at position 19
Found 0 at position 24
Found 42 at position 44

44027
9223372036854775807
Numerical result out of range
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc atoi}}
{{dsc inc | c/string/byte/dsc strtoul}}
{{dsc see cpp | cpp/string/byte/strtol | strtol | strtoll}}
{{dsc end}}

[[de:c/string/byte/strtol]]
[[es:c/string/byte/strtol]]
[[fr:c/string/byte/strtol]]
[[it:c/string/byte/strtol]]
[[ja:c/string/byte/strtol]]
[[pt:c/string/byte/strtol]]
[[ru:c/string/byte/strtol]]
[[zh:c/string/byte/strtol]]</text>
      <sha1>6olo105ndqzf04odrqb9645us10a2dw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtold</title>
    <ns>0</ns>
    <id>6515</id>
    <redirect title="c/string/byte/strtof" />
    <revision>
      <id>25687</id>
      <timestamp>2012-04-23T21:08:00Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/string/byte/strtof]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strtoul</title>
    <ns>0</ns>
    <id>6125</id>
    <revision>
      <id>70084</id>
      <parentid>67320</parentid>
      <timestamp>2014-05-09T13:08:24Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main; hide errno</comment>
      <text xml:space="preserve" bytes="3378">{{c/title| strtoul | strtoull}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl rev begin}}
{{dcl | until=c99 |
unsigned long      strtoul( const char          *str, char          **str_end, 
                            int base );
}}
{{dcl | since=c99 |
unsigned long      strtoul( const char *restrict str, char **restrict str_end, 
                            int base );
}}
{{dcl rev end}}
{{dcl | since=c99 |
unsigned long long strtoull( const char *restrict str, char **restrict str_end,
                             int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|ULONG_MAX}} or {{lc|ULLONG_MAX}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;errno.h&gt;
#include &lt;string.h&gt;

int main(void) 
{
    /* Decimal */
    printf(&quot;%lu\n&quot;, strtoul(&quot;&quot;,NULL,10));        /* empty string           */
    printf(&quot;%lu\n&quot;, strtoul(&quot; +0123&quot;,NULL,10));  /* leading space and zero */
    printf(&quot;%lu\n&quot;, strtoul(&quot;123&quot;,NULL,0));
    
    /* Binary */
    printf(&quot;%lu\n&quot;, strtoul(&quot;1100&quot;, NULL,2));

    /* Octal */
    printf(&quot;%lu\n&quot;, strtoul(&quot;14&quot;,NULL,8));
    printf(&quot;%lu\n&quot;, strtoul(&quot;014&quot;,NULL,0));

    /* Base 13 */
    printf(&quot;%lu\n&quot;, strtoul(&quot;1c&quot;,NULL,13));

    /* Hexadecimal */
    printf(&quot;%lu\n&quot;, strtoul(&quot;FFFFFFFFFFFFFFFF&quot;,NULL,16));
    printf(&quot;%lu\n&quot;, strtoul(&quot;0xFFFFFFFFFFFFFFFF&quot;,NULL,0));

    /* Base 36 */
    printf(&quot;%lu\n&quot;, strtoul(&quot;XyZ&quot;,NULL,36));   /* 44027 */

    /* Overflow, a value too large for type unsigned long int. */
    errno = 0;
   
    printf(&quot;%lu\n&quot;, strtoul(&quot;18446744073709551616&quot;,NULL,10));           
    printf(&quot;%s\n&quot;,strerror(errno));   /* range error */

    /* Underflow. a value too small for type unsigned long int. */
    errno = 0;
    printf(&quot;%lu\n&quot;, strtoul(&quot;-1&quot;,NULL,10));
    printf(&quot;%s\n&quot;,strerror(errno));   /* success */

    /* Using str_end. */
    char *str_end;
    printf(&quot;%lu\n&quot;, strtoul(&quot;  00123 999&quot;,&amp;str_end,10));
    printf(&quot;[%c]\n&quot;, *str_end);
    printf(&quot;%lu\n&quot;, strtoul(str_end,NULL,10)); 
    
    return 0;
}
 | output=
0
123
123
12
12
12
25
18446744073709551615
18446744073709551615
44027
18446744073709551615
Numerical result out of range
18446744073709551615
Success
123
[ ]
999
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc atoi}}
{{dsc inc | c/string/byte/dsc strtol}}
{{dsc see cpp | cpp/string/byte/strtoul}}
{{dsc end}}

[[de:c/string/byte/strtoul]]
[[es:c/string/byte/strtoul]]
[[fr:c/string/byte/strtoul]]
[[it:c/string/byte/strtoul]]
[[ja:c/string/byte/strtoul]]
[[pt:c/string/byte/strtoul]]
[[ru:c/string/byte/strtoul]]
[[zh:c/string/byte/strtoul]]</text>
      <sha1>8mhwmwu44u5bjhir0dozgf7hnh83poc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/strxfrm</title>
    <ns>0</ns>
    <id>6131</id>
    <revision>
      <id>62626</id>
      <parentid>49120</parentid>
      <timestamp>2013-07-01T23:30:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1412">{{c/title|strxfrm}}
{{c/string/byte/navbar}}
{{dcl begin}}
{{dcl header | string.h}}
{{dcl | until=c99 |
size_t strxfrm( const char          *dest, const char          *src, 
                size_t count );
}}
{{dcl | since=c99 |
size_t strxfrm( const char *restrict dest, const char *restrict src, 
                size_t count );
}}
{{dcl end}}

Transforms the null-terminated byte string pointed to by {{tt|src}} according to the current locale and copies the first {{tt|count}} characters of the transformed string to destination, returning its length.
Alternativelly, the function can be used to only retrieve the length, by specifying a null pointer for {{tt|dest}} and {{c|0}} for {{tt|count}}.

===Parameters===
{{par begin}}
{{par| dest | pointer to the byte string to copy the transformed string to}}
{{par| src| pointer to the null-terminated byte string to transform}}
{{par| count | maximum number of characters to transform}}
{{par end}}

===Return value===
The length of the transformed string, not including the terminating null-character.

===Example===
{{example
 | 1=
 | 2=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/byte/strxfrm}}
{{dsc end}}

[[de:c/string/byte/strxfrm]]
[[es:c/string/byte/strxfrm]]
[[fr:c/string/byte/strxfrm]]
[[it:c/string/byte/strxfrm]]
[[ja:c/string/byte/strxfrm]]
[[pt:c/string/byte/strxfrm]]
[[ru:c/string/byte/strxfrm]]
[[zh:c/string/byte/strxfrm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/tolower</title>
    <ns>0</ns>
    <id>6048</id>
    <revision>
      <id>70078</id>
      <parentid>69651</parentid>
      <timestamp>2014-05-09T12:38:06Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2060">{{c/title|tolower}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int tolower( int ch );
}}
Converts the given character to lowercase according to the character conversion rules defined by the currently installed C locale.

In the default &quot;C&quot; locale, the following uppercase letters {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}} are replaced with respective lowercase letters {{tt|abcdefghijklmnopqrstuvwxyz}}.

===Parameters===
{{par begin}}
{{par | ch | character to be converted. If the value of {{tt|ch}} is not representable as {{c|unsigned char}} and does not equal {{c|EOF}}, the behavior is undefined.}}
{{par end}}

===Return value===
Lowercase version of {{tt|ch}} or unmodified {{tt|ch}} if no lowercase version is listed in the current C locale.

===Example===
{{example |
| code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;locale.h&gt;
#include &lt;limits.h&gt;

int main(void)
{
    /* In the default locale: */
    unsigned char l;
    for (unsigned char u=0; u&lt;UCHAR_MAX; u++) {
        l = tolower(u);
        if (l!=u) printf(&quot;%c%c &quot;, u,l);
    }
    printf(&quot;\n\n&quot;);

    unsigned char c = '\xb4'; // the character Ž in ISO-8859-15
                              // but ´ (acute accent) in ISO-8859-1 
    unsigned char c2 = c;   // for printing
    setlocale(LC_ALL, &quot;en_US.iso88591&quot;);
    printf(&quot;in iso8859-1, tolower('0x%x') gives 0x%x\n&quot;, c2, tolower(c));
    setlocale(LC_ALL, &quot;en_US.iso885915&quot;);
    printf(&quot;in iso8859-15, tolower('0x%x') gives 0x%x\n&quot;, c2, tolower(c));
}
| output=
Aa Bb Cc Dd Ee Ff Gg Hh Ii Jj Kk Ll Mm Nn Oo Pp Qq Rr Ss Tt Uu Vv Ww Xx Yy Zz

in iso8859-1, tolower('0xb4') gives 0xb4
in iso8859-15, tolower('0xb4') gives 0xb8
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc toupper}}
{{dsc inc | c/string/wide/dsc towlower}}
{{dsc see cpp | cpp/string/byte/tolower}}
{{dsc end}}

[[de:c/string/byte/tolower]]
[[es:c/string/byte/tolower]]
[[fr:c/string/byte/tolower]]
[[it:c/string/byte/tolower]]
[[ja:c/string/byte/tolower]]
[[pt:c/string/byte/tolower]]
[[ru:c/string/byte/tolower]]
[[zh:c/string/byte/tolower]]</text>
      <sha1>3t2hl3dffgqtt7lkjrr5ml9jdxhqd68</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/byte/toupper</title>
    <ns>0</ns>
    <id>6047</id>
    <revision>
      <id>70079</id>
      <parentid>69653</parentid>
      <timestamp>2014-05-09T12:39:36Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>C main</comment>
      <text xml:space="preserve" bytes="2061">{{c/title|toupper}}
{{c/string/byte/navbar}}
{{ddcl | header=ctype.h |
int toupper( int ch );
}}

Converts the given character to uppercase according to the character conversion rules defined by the currently installed C locale.

In the default &quot;C&quot; locale, the following lowercase letters {{tt|abcdefghijklmnopqrstuvwxyz}} are replaced with respective uppercase letters {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}.

===Parameters===
{{par begin}}
{{par | ch | character to be converted. If the value of {{tt|ch}} is not representable as {{c|unsigned char}} and does not equal {{c|EOF}}, the behavior is undefined.}}
{{par end}}

===Return value===
Uppercase version of {{tt|ch}} or unmodified {{tt|ch}} if no uppercase version is listed in the current C locale.

===Example===
{{example |
| code=
#include &lt;stdio.h&gt;
#include &lt;ctype.h&gt;
#include &lt;locale.h&gt;
#include &lt;limits.h&gt;

int main(void)
{
    /* In the default locale: */
    unsigned char u;
    for (unsigned char l=0; l&lt;UCHAR_MAX; l++) {
        u = toupper(l);
        if (l!=u) printf(&quot;%c%c &quot;, l,u);
    }
    printf(&quot;\n\n&quot;);

    unsigned char c = '\xb8'; // the character Ž in ISO-8859-15
                              // but ´ (acute accent) in ISO-8859-1 
    unsigned char c2 = c;   // for printing
    setlocale(LC_ALL, &quot;en_US.iso88591&quot;);
    printf(&quot;in iso8859-1, toupper('0x%x') gives 0x%x\n&quot;, c2, toupper(c));
    setlocale(LC_ALL, &quot;en_US.iso885915&quot;);
    printf(&quot;in iso8859-15, toupper('0x%x') gives 0x%x\n&quot;, c2, toupper(c));
}
| output=
aA bB cC dD eE fF gG hH iI jJ kK lL mM nN oO pP qQ rR sS tT uU vV wW xX yY zZ 

in iso8859-1, toupper('0xb8') gives 0xb8
in iso8859-15, toupper('0xb8') gives 0xb4
}}
===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc tolower}}
{{dsc inc | c/string/wide/dsc towupper}}
{{dsc see cpp | cpp/string/byte/toupper}}
{{dsc end}}

[[de:c/string/byte/toupper]]
[[es:c/string/byte/toupper]]
[[fr:c/string/byte/toupper]]
[[it:c/string/byte/toupper]]
[[ja:c/string/byte/toupper]]
[[pt:c/string/byte/toupper]]
[[ru:c/string/byte/toupper]]
[[zh:c/string/byte/toupper]]</text>
      <sha1>d076dp3z3tjlr6a06hf9xjdb6ccycje</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte</title>
    <ns>0</ns>
    <id>5758</id>
    <revision>
      <id>72272</id>
      <parentid>71108</parentid>
      <timestamp>2014-08-02T08:46:43Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Macros */ -extra }</comment>
      <text xml:space="preserve" bytes="3875">{{title|Null-terminated multibyte strings}}
{{c/string/multibyte/navbar}}

A null-terminated multibyte string (NTMBS), or &quot;multibyte string&quot;, is a sequence of nonzero bytes followed by a byte with value zero (the terminating null character).

Each character stored in the string may occupy more than one byte. The encoding used to represent characters in a multibyte character string is locale-specific: it may be UTF-8, GB18030, EUC-JP, Shift-JIS, etc. For example, the char array {{c|{'\xe4','\xbd','\xa0','\xe5','\xa5','\xbd','\0'}}} is an NTMBS holding the string {{c|&quot;你好&quot;}} in UTF-8 multibyte encoding: the first three bytes encode the character 你, the next three bytes encode the character 好. The same string encoded in GB18030 is the char array {{c|{'\xc4', '\xe3', '\xba', '\xc3', '\0'}}}, where each of the two characters is encoded as a two-byte sequence.

In some multibyte encodings, any given multibyte character sequence may represent different characters depending on the previous byte sequences, known as &quot;shift sequences&quot;. Such encodings are known as state-dependent: knowledge of the current shift state is required to interpret each character. An NTMBS is only valid if it begins and ends in the initial shift state: if a shift sequence was used, the corresponding unshift sequence has to be present before the terminating null character. Examples of such encodings are BOCU-1 and SCSU.

A multibyte character string is layout-compatible with null-terminated byte string (NTBS), that is, can be stored, copied, and examined using the same facilities, except for calculating the number of characters. If the correct locale is in effect, I/O functions also handle multibyte strings. Multibyte strings can be converted to and from wide strings using the {{c|codecvt}} member functions, {{c|wstring_convert}}, or the following locale-dependent conversion functions:

===Multibyte/wide character conversions===
{{dsc begin}}
{{dsc header | stdlib.h}}
{{dsc inc | c/string/multibyte/dsc mblen}}
{{dsc inc | c/string/multibyte/dsc mbtowc}}
{{dsc inc | c/string/multibyte/dsc wctomb}}
{{dsc inc | c/string/multibyte/dsc mbstowcs}}
{{dsc inc | c/string/multibyte/dsc wcstombs}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/multibyte/dsc mbsinit}}
{{dsc inc | c/string/multibyte/dsc btowc}}
{{dsc inc | c/string/multibyte/dsc wctob}}
{{dsc inc | c/string/multibyte/dsc mbrlen}}
{{dsc inc | c/string/multibyte/dsc mbrtowc}}
{{dsc inc | c/string/multibyte/dsc wcrtomb}}
{{dsc inc | c/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | c/string/multibyte/dsc wcsrtombs}}
{{dsc header | uchar.h}}
{{dsc inc | c/string/multibyte/dsc mbrtoc16}}
{{dsc inc | c/string/multibyte/dsc c16rtomb}}
{{dsc inc | c/string/multibyte/dsc mbrtoc32}}
{{dsc inc | c/string/multibyte/dsc c32rtomb}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/multibyte/dsc mbstate_t}}
{{dsc header | uchar.h}}
{{dsc inc | c/string/multibyte/dsc char16_t}}
{{dsc inc | c/string/multibyte/dsc char32_t}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc header | limits.h}}
{{dsc inc | c/string/multibyte/dsc MB_LEN_MAX}}
{{dsc header | stdlib.h}}
{{dsc inc | c/string/multibyte/dsc MB_CUR_MAX}}
{{dsc header | uchar.h}}
{{dsc macro const | __STDC_UTF_16__ |  nolink=true | indicates that UTF-16 encoding is used by {{lc|mbrtoc16}} and {{lc|c16rtomb}} | notes={{mark c11}}}}
{{dsc macro const | __STDC_UTF_32__ |  nolink=true | indicates that UTF-32 encoding is used by {{lc|mbrtoc32}} and {{lc|c32rtomb}} | notes={{mark c11}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/multibyte | Null-terminated multibyte strings}}
{{dsc end}}

[[de:c/string/multibyte]]
[[es:c/string/multibyte]]
[[fr:c/string/multibyte]]
[[it:c/string/multibyte]]
[[ja:c/string/multibyte]]
[[pt:c/string/multibyte]]
[[ru:c/string/multibyte]]
[[zh:c/string/multibyte]]</text>
      <sha1>n3pn7af9yhm4jjcgbf6izc8201fo41e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/btowc</title>
    <ns>0</ns>
    <id>6111</id>
    <revision>
      <id>56783</id>
      <parentid>49124</parentid>
      <timestamp>2013-06-01T05:41:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1099">{{c/title|btowc}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
wint_t btowc( int c );
}}

Widens a single-byte character {{tt|c}} to its wide character equivalent.

Most multibyte character encodings use single-byte codes to represent the characters from the ASCII character set. This function may be used to convert such characters to {{c|wchar_t}}.

===Parameters===
{{par begin}}
{{par | c | single-byte character to widen}}
{{par end}}

===Return value===

{{c|WEOF}} if {{tt|c}} is {{lc|EOF}}

wide character representation of {{tt|c}} if {{c|(unsigned char)c}} is a valid single-byte character in the initial shift state, {{c|WEOF}} otherwise.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc wctob}}
{{dsc see cpp | cpp/string/multibyte/btowc}}
{{dsc end}}

[[de:c/string/multibyte/btowc]]
[[es:c/string/multibyte/btowc]]
[[fr:c/string/multibyte/btowc]]
[[it:c/string/multibyte/btowc]]
[[ja:c/string/multibyte/btowc]]
[[pt:c/string/multibyte/btowc]]
[[ru:c/string/multibyte/btowc]]
[[zh:c/string/multibyte/btowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/c16rtomb</title>
    <ns>0</ns>
    <id>9392</id>
    <revision>
      <id>63531</id>
      <parentid>56786</parentid>
      <timestamp>2013-07-10T01:35:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2319">{{c/title|c16rtomb}}
{{c/string/multibyte/navbar}}
{{ddcl | header=uchar.h | since=c11 |
size_t c16rtomb( char* s, char16_t c16, mbstate_t* ps );
}}

Converts a 16-bit wide character to narrow multibyte character.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|c16}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|c16rtomb(buf, u'\0', ps)}} for some internal buffer {{tt|buf}}.

If c16 is the null wide character {{c|u'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

If the macro {{c|__STDC_UTF_16__}} is defined, the 16-bit encoding used by this function is UTF-16, otherwise it is implementation-defined. In any case, the multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | c16 | the 16-bit character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. This value may be {{c|0}}, e.g. when processing the first {{c|char16_t}} in a surrogate pair.

On failure (if {{c|c16}} is not a valid 16-bit character), returns {{c|-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbrtoc16}}
{{dsc see cpp | cpp/string/multibyte/c16rtomb}}
{{dsc end}}

[[de:c/string/multibyte/c16rtomb]]
[[es:c/string/multibyte/c16rtomb]]
[[fr:c/string/multibyte/c16rtomb]]
[[it:c/string/multibyte/c16rtomb]]
[[ja:c/string/multibyte/c16rtomb]]
[[pt:c/string/multibyte/c16rtomb]]
[[ru:c/string/multibyte/c16rtomb]]
[[zh:c/string/multibyte/c16rtomb]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/c32rtomb</title>
    <ns>0</ns>
    <id>9393</id>
    <revision>
      <id>63532</id>
      <parentid>56787</parentid>
      <timestamp>2013-07-10T01:35:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2385">{{c/title|c32rtomb}}
{{c/string/multibyte/navbar}}
{{ddcl | header=uchar.h | since=c11 |
size_t c32rtomb( char* s, char32_t c32, mbstate_t* ps );
}}

Converts a 32-bit wide character to its narrow multibyte representation.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|c32}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|c32rtomb(buf, U'\0', ps)}} for some internal buffer {{tt|buf}}.

If {{tt|c32}} is the null wide character {{c|U'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

If the macro {{c|__STDC_UTF_32__}} is defined, the 32-bit encoding used by this function is UTF-32, otherwise it is implementation-defined. In any case, the multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | c32 | the 32-bit character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. This value may be {{c|0}}, e.g. when processing the first {{c|char32_t}} in multi-{{c|char32_t}}-character sequence (does not occur in UTF-32).

On failure (if {{c|c32}} is not a valid 32-bit character), returns {{c|-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbrtoc32}}
{{dsc see cpp | cpp/string/multibyte/c32rtomb}}
{{dsc end}}

[[de:c/string/multibyte/c32rtomb]]
[[es:c/string/multibyte/c32rtomb]]
[[fr:c/string/multibyte/c32rtomb]]
[[it:c/string/multibyte/c32rtomb]]
[[ja:c/string/multibyte/c32rtomb]]
[[pt:c/string/multibyte/c32rtomb]]
[[ru:c/string/multibyte/c32rtomb]]
[[zh:c/string/multibyte/c32rtomb]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mblen</title>
    <ns>0</ns>
    <id>6116</id>
    <revision>
      <id>56790</id>
      <parentid>49127</parentid>
      <timestamp>2013-06-01T05:41:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2099">{{c/title|mblen}}
{{c/string/multibyte/navbar}}
{{ddcl | header=stdlib.h |
int mblen( const char* s, size_t n );
}}

Determines the size, in bytes, of the multibyte character whose first byte is pointed to by {{tt|s}}. 

If {{tt|s}} is a null pointer, resets the global conversion state and determined whether shift sequences are used.

This function is equivalent to the call {{c|mbtowc((wchar_t*)0, s, n)}}, except that conversion state of {{lc|mbtowc}} is unaffected.

===Notes===
Each call to {{tt|mblen}} updates the internal global conversion state (a static object of type {{lc|mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, care must be taken to avoid backtracking or multiple scans. In any case, multiple threads should not call {{tt|mblen}} without synchronization: {{lc|mbrlen}} may be used instead.

===Parameters===
{{par begin}}
{{par | s | pointer to the multibyte character}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte character or {{c|-1}} if the first bytes pointed to by {{tt|s}} do not form a valid multibyte character or {{c|0}} if {{tt|s}} is pointing at the null charcter {{c|'\0'}}.

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbtowc}}
{{dsc inc | c/string/multibyte/dsc mbrlen}}
{{dsc see cpp | cpp/string/multibyte/mblen}}
{{dsc end}}

[[de:c/string/multibyte/mblen]]
[[es:c/string/multibyte/mblen]]
[[fr:c/string/multibyte/mblen]]
[[it:c/string/multibyte/mblen]]
[[ja:c/string/multibyte/mblen]]
[[pt:c/string/multibyte/mblen]]
[[ru:c/string/multibyte/mblen]]
[[zh:c/string/multibyte/mblen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbrlen</title>
    <ns>0</ns>
    <id>6109</id>
    <revision>
      <id>56791</id>
      <parentid>49128</parentid>
      <timestamp>2013-06-01T05:41:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1640">{{c/title|mbrlen}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
size_t mbrlen( const char* s, size_t n, mbstate_t* ps );
}}

Determines the size, in bytes, of the remainder of the multibyte character whose first byte is pointed to by {{tt|s}}, given the current conversion state {{tt|ps}}.

This function is equivalent to the call {{c|mbrtowc(nullptr, s, n, ps?ps:&amp;internal)}} for some hidden object {{tt|internal}} of type {{lc|mbstate_t}}, except that the expression {{tt|ps}} is evaluated only once.

===Parameters===
{{par begin}}
{{par | s | pointer to an element of a multibyte character string}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the variable holding the conversion state}}
{{par end}}

===Return value===
{{c|0}} if the next {{tt|n}} or fewer bytes complete the null character.

The number of bytes (between {{c|1}} and {{c|n}}) that complete a valid multibyte character

{{c|(size_t)-1}} if encoding error occurs

{{c|(size_t)-2}} if the next {{tt|n}} bytes are part of a possibly valid multibyte character, which is still incomplete after examining all {{tt|n}} bytes

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbrtowc}}
{{dsc inc | c/string/multibyte/dsc mblen}}
{{dsc see cpp | cpp/string/multibyte/mbrlen}}
{{dsc end}}

[[de:c/string/multibyte/mbrlen]]
[[es:c/string/multibyte/mbrlen]]
[[fr:c/string/multibyte/mbrlen]]
[[it:c/string/multibyte/mbrlen]]
[[ja:c/string/multibyte/mbrlen]]
[[pt:c/string/multibyte/mbrlen]]
[[ru:c/string/multibyte/mbrlen]]
[[zh:c/string/multibyte/mbrlen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbrtoc16</title>
    <ns>0</ns>
    <id>9391</id>
    <revision>
      <id>63533</id>
      <parentid>56792</parentid>
      <timestamp>2013-07-10T01:35:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3010">{{c/title|mbrtoc16}}
{{c/string/multibyte/navbar}}
{{ddcl | header=uchar.h | since=c11 |
size_t mbrtoc16( char16_t* pc16, const char* s, size_t n, mbstate_t* ps );
}}

Converts a narrow multibyte character to 16-bit character representation (typically, UTF-16).

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding 16-bit character and stores it in {{c|*pc16}} (if {{tt|pc16}} is not null).

If the multibyte character in {{tt|*s}} corresponds to a multi-char16_t sequence (e.g. a surrogate pair in UTF-16), then after the first call to this function, {{tt|*ps}} is updated in such a way that the next call to {{tt|mbrtoc16}} will write out the additional char16_t, without considering {{tt|*s}}.

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pc16}} are ignored and the call is equivalent to {{c|mbrtoc16(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state {{c|*ps}} represents the initial shift state.

If the macro {{c|__STDC_UTF_16__}} is defined, the 16-bit encoding used by this function is UTF-16, otherwise it is implementation-defined.

===Parameters===
{{par begin}}
{{par | pc16 | pointer to the location where the resulting 16-bit character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===

The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|*pc16}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|-3}} if the next {{c|char16_t}} from a multi-{{c|char16_t}} character (e.g. a surrogate pair) has now been written to {{c|*pc16}}. No bytes are processed from the input in this case.
* {{c|-2}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pc16}}.
* {{c|-1}} if encoding error occurs. Nothing is written to {{tt|*pc16}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value if {{c|*ps}} is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc c16rtomb}}
{{dsc see cpp | cpp/string/multibyte/mbrtoc16}}
{{dsc end}}

[[de:c/string/multibyte/mbrtoc16]]
[[es:c/string/multibyte/mbrtoc16]]
[[fr:c/string/multibyte/mbrtoc16]]
[[it:c/string/multibyte/mbrtoc16]]
[[ja:c/string/multibyte/mbrtoc16]]
[[pt:c/string/multibyte/mbrtoc16]]
[[ru:c/string/multibyte/mbrtoc16]]
[[zh:c/string/multibyte/mbrtoc16]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbrtoc32</title>
    <ns>0</ns>
    <id>9394</id>
    <revision>
      <id>63534</id>
      <parentid>56795</parentid>
      <timestamp>2013-07-10T01:35:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2983">{{c/title|mbrtoc32}}
{{c/string/multibyte/navbar}}
{{ddcl | header=cuchar | since=c11 |
size_t mbrtoc32( char32_t* pc32, const char* s, size_t n, mbstate_t* ps );
}}

Converts a narrow multibyte character to its 32-bit character representation (typically, UTF-32).

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding 32-bit character and stores it in {{c|*pc32}} (if {{tt|pc32}} is not null).

If the multibyte character in {{tt|*s}} corresponds to a multi-char32_t sequence (not possible with UTF-32), then after the first call to this function, {{tt|*ps}} is updated in such a way that the next calls to {{tt|mbrtoc32}} will write out the additional char32_t, without considering {{tt|*s}}.

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pc32}} are ignored and the call is equivalent to {{c|mbrtoc32(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state {{c|*ps}} represents the initial shift state.

If the macro {{c|__STDC_UTF_32__}} is defined, the 32-bit encoding used by this function is UTF-32, otherwise it is implementation-defined.

===Parameters===
{{par begin}}
{{par | pc32 | pointer to the location where the resulting 32-bit character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===

The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|*pc32}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|-3}} if the next {{c|char32_t}} from a multi-{{c|char32_t}} character has now been written to {{c|*pc32}}. No bytes are processed from the input in this case.
* {{c|-2}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pc32}}.
* {{c|-1}} if encoding error occurs. Nothing is written to {{tt|*pc32}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value if {{c|*ps}} is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc c32rtomb}}
{{dsc see cpp | cpp/string/multibyte/mbrtoc32}}
{{dsc end}}

[[de:c/string/multibyte/mbrtoc32]]
[[es:c/string/multibyte/mbrtoc32]]
[[fr:c/string/multibyte/mbrtoc32]]
[[it:c/string/multibyte/mbrtoc32]]
[[ja:c/string/multibyte/mbrtoc32]]
[[pt:c/string/multibyte/mbrtoc32]]
[[ru:c/string/multibyte/mbrtoc32]]
[[zh:c/string/multibyte/mbrtoc32]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbrtowc</title>
    <ns>0</ns>
    <id>6108</id>
    <revision>
      <id>56796</id>
      <parentid>49131</parentid>
      <timestamp>2013-06-01T05:41:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2407">{{c/title|mbrtowc}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
size_t mbrtowc( wchar_t* pwc, const char* s, size_t n, mbstate_t* ps );
}}

Converts a narrow multibyte character to a wide character.

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding wide character and stores it in {{c|*pwc}} (if {{tt|pwc}} is not null).

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pwc}} are ignored and call is equivalent to {{c|mbrtowc(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state stored in {{c|*ps}} is the initial shift state.

===Parameters===
{{par begin}}
{{par | pwc | pointer to the location where the resulting wide character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state used when interpreting the multibyte string }}
{{par end}}

===Return value===
The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|pwc}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|(size_t)-2}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pwc}}.
* {{c|(size_t)-1}} if encoding error occurs. Nothing is written to {{tt|*pwc}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value of {{c|*ps}} is left unspecified.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbtowc}}
{{dsc inc | c/string/multibyte/dsc wcrtomb}}
{{dsc see cpp | cpp/string/multibyte/mbrtowc}}
{{dsc end}}

[[de:c/string/multibyte/mbrtowc]]
[[es:c/string/multibyte/mbrtowc]]
[[fr:c/string/multibyte/mbrtowc]]
[[it:c/string/multibyte/mbrtowc]]
[[ja:c/string/multibyte/mbrtowc]]
[[pt:c/string/multibyte/mbrtowc]]
[[ru:c/string/multibyte/mbrtowc]]
[[zh:c/string/multibyte/mbrtowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbsinit</title>
    <ns>0</ns>
    <id>6112</id>
    <revision>
      <id>56797</id>
      <parentid>49132</parentid>
      <timestamp>2013-06-01T05:41:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1184">{{c/title|mbsinit}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
int mbsinit( const mbstate_t* ps);
}}

If {{tt|ps}} is not a null pointer, the {{tt|mbsinit}} function determines whether the pointed-to {{lc|mbstate_t}} object describes the initial conversion state. 

===Notes===
Although a zero-initialized {{lc|mbstate_t}} always represents the initial conversion state, there may be other values of {{lc|mbstate_t}} that also represent the initial conversion state.

===Parameters===
{{par begin}}
{{par | ps | pointer to the mbstate_t object to examine}}
{{par end}}

===Return value===
{{c|0}} if {{tt|ps}} is not a null pointer and does not reporesent the initial conversion state, nonzero value otherwise.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbstate_t}}
{{dsc see cpp | cpp/string/multibyte/mbsinit}}
{{dsc end}}

[[de:c/string/multibyte/mbsinit]]
[[es:c/string/multibyte/mbsinit]]
[[fr:c/string/multibyte/mbsinit]]
[[it:c/string/multibyte/mbsinit]]
[[ja:c/string/multibyte/mbsinit]]
[[pt:c/string/multibyte/mbsinit]]
[[ru:c/string/multibyte/mbsinit]]
[[zh:c/string/multibyte/mbsinit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbsrtowcs</title>
    <ns>0</ns>
    <id>6106</id>
    <revision>
      <id>56800</id>
      <parentid>49133</parentid>
      <timestamp>2013-06-01T05:41:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2529">{{c/title|mbsrtowcs}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
size_t mbsrtowcs( wchar_t* dst, const char** src, size_t len, mbstate_t* ps )
}}

Converts a null-terminated multibyte character sequence, which begins in the conversion state described by {{tt|*ps}}, from the array whose first element is pointed to by {{tt|*src}} to its wide character representation. If {{tt|dst}} is not null, converted characters are stored in the successive elements of the wchar_t array pointed to by {{tt|dst}}. No more than {{tt|len}} wide characters are written to the destination array.

Each multibyte character is converted as if by a call to {{lc|mbrtowc}}. The conversion stops if:

* The multibyte null character was converted and stored. {{tt|src}} is set to {{lc|NULL}} and {{tt|*ps}} represents the initial shift state.
* An invalid multibyte character (according to the current C locale) was encountered. {{tt|src}} is set to point at the beginning  of the first unconverted multibyte character.
* the next wide character to be stored would exceed {{tt|len}}. {{tt|src}} is set to point at the beginning of the first unconverted multibyte character. This condition is not checked if {{c|1=dst==NULL}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to wide character array where the results will be stored}}
{{par | src | pointer to pointer to the first element of a null-terminated multibyte string}}
{{par | len | number of wide characters available in the array pointed to by dst}}
{{par | ps | pointer to the conversion state object}}
{{par end}}

===Return value===
On success, returns the number of wide characters, excluding the terminating {{c|L'\0'}}, written to the character array.. If {{c|1=dst==NULL}}, returns the number of wide characters that would have been written given unlimited length.

On conversion error (if invalid multibyte character was encountered), returns {{c|(size_t)-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbrtowc}}
{{dsc inc | c/string/multibyte/dsc wcsrtombs}}
{{dsc see cpp | cpp/string/multibyte/mbsrtowcs}}
{{dsc end}}

[[de:c/string/multibyte/mbsrtowcs]]
[[es:c/string/multibyte/mbsrtowcs]]
[[fr:c/string/multibyte/mbsrtowcs]]
[[it:c/string/multibyte/mbsrtowcs]]
[[ja:c/string/multibyte/mbsrtowcs]]
[[pt:c/string/multibyte/mbsrtowcs]]
[[ru:c/string/multibyte/mbsrtowcs]]
[[zh:c/string/multibyte/mbsrtowcs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbstate t</title>
    <ns>0</ns>
    <id>6103</id>
    <revision>
      <id>56801</id>
      <parentid>49134</parentid>
      <timestamp>2013-06-01T05:41:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1406">{{c/title|mbstate_t}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
struct mbstate_t;
}}

The type {{tt|mbstate_t}} is a trivial non-array type that can represent any of the conversion states that can occur in an implementation-defined set of supported multibyte character encoding rules. Zero-initialized value of {{tt|mbstate_t}} represents the initial conversion state, although other values of {{tt|mbstate_t}} may exist that also represent the initial conversion state.

Possible implementation of {{tt|mbstate_t}} is a struct type holding an array representing the incomplete multibyte character, an integer counter indicating the number of bytes in the array that have been processed, and a representation of the current shift state.

The following functions should not be called from multiple threads without synchronization with the {{c|mbstate_t*}} argument of {{tt|NULL}} due to possible data races: {{lc|mbrlen}}, {{lc|mbrtowc}}, {{c|mbsrtowc}}, {{lc|mbtowc}}, {{lc|wcrtomb}}, {{c|wcsrtomb}}, {{lc|wctomb}}. 

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbsinit}}
{{dsc end}}

[[de:c/string/multibyte/mbstate t]]
[[es:c/string/multibyte/mbstate t]]
[[fr:c/string/multibyte/mbstate t]]
[[it:c/string/multibyte/mbstate t]]
[[ja:c/string/multibyte/mbstate t]]
[[pt:c/string/multibyte/mbstate t]]
[[ru:c/string/multibyte/mbstate t]]
[[zh:c/string/multibyte/mbstate t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbstowcs</title>
    <ns>0</ns>
    <id>6113</id>
    <revision>
      <id>62627</id>
      <parentid>56802</parentid>
      <timestamp>2013-07-01T23:30:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2492">{{c/title|mbstowcs}}
{{c/string/multibyte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl | until=c99 |
size_t mbstowcs( wchar_t          *dst, const char          *src, size_t len)
}}
{{dcl | since=c99 |
size_t mbstowcs( wchar_t *restrict dst, const char *restrict src, size_t len)
}}
{{dcl end}}

Converts a multibyte character string from the array whose first element is pointed to by {{tt|src}} to its wide character  representation. Converted characters are stored in the successive elements of the array pointed to by {{tt|dst}}. No more than {{tt|len}} wide characters are written to the destination array.

Each character is converted as if by a call to {{lc|mbtowc}}, except that the mbtowc conversion state is unaffected. The conversion stops if:

* The multibyte null character was converted and stored.
* An invalid (in the current C locale) multibyte character was encountered.
* The next wide character to be stored would exceed {{tt|len}}.

===Notes===
In most implementations, this function updates a global static object of type {{lc|mbstate_t}} as it processes through the string, and cannot be called simultaneously by two threads, {{lc|mbsrtowcs}} should be used in such cases.

POSIX specifies a common extension: if {{tt|dst}} is a null pointer, this function returns the number of wide characters that would be written to {{tt|dst}}, if converted. Similar behavior is standard for {{lc|mbsrtowcs}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to wide character array where the wide string will be stored}}
{{par | src | pointer to the first element of a null-terminated multibyte string to convert}}
{{par | len | number of wide characters available in the array pointed to by dst}}
{{par end}}

===Return value===
On success, returns the number of wide characters, excluding the terminating {{c|L'\0'}}, written to the destination array.

On conversion error (if invalid multibyte character was encountered), returns {{c|(size_t)-1}}.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | c/string/multibyte/dsc wcstombs}}
{{dsc see cpp | cpp/string/multibyte/mbstowcs}}
{{dsc end}}

[[de:c/string/multibyte/mbstowcs]]
[[es:c/string/multibyte/mbstowcs]]
[[fr:c/string/multibyte/mbstowcs]]
[[it:c/string/multibyte/mbstowcs]]
[[ja:c/string/multibyte/mbstowcs]]
[[pt:c/string/multibyte/mbstowcs]]
[[ru:c/string/multibyte/mbstowcs]]
[[zh:c/string/multibyte/mbstowcs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/mbtowc</title>
    <ns>0</ns>
    <id>6115</id>
    <revision>
      <id>62628</id>
      <parentid>56805</parentid>
      <timestamp>2013-07-01T23:30:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2247">{{c/title|mbtowc}}
{{c/string/multibyte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl | until=c99 |
int mbtowc( wchar_t          *pwc, const char          *s, size_t n )
}}
{{dcl | since=c99 |
int mbtowc( wchar_t *restrict pwc, const char *restrict s, size_t n )
}}
{{dcl end}}

Converts a multibyte character whose first byte is pointed to by {{tt|s}} to a wide character, written to {{tt|*pwc}} if {{tt|pwc}} is not null.

If {{tt|s}} is a null pointer, resets the global conversion state and determines whether shift sequences are used.

===Notes===
Each call to {{tt|mbtowc}} updates the internal global conversion state (a static object of type {{lc|mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, care must be taken to avoid backtracking or multiple scans. In any case, multiple threads should not call {{tt|mbtowc}} without synchronization: {{lc|mbrtowc}} may be used instead.

===Parameters===
{{par begin}}
{{par | pwc | pointer to the wide character for output }}
{{par | s | pointer to the multibyte character}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte character or {{c|-1}} if the first bytes pointed to by {{tt|s}} do not form a valid multibyte character or {{c|0}} if {{tt|s}} is pointing at the null charcter {{c|'\0'}}.

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbrtowc}}
{{dsc inc | c/string/multibyte/dsc mblen}}
{{dsc see cpp | cpp/string/multibyte/mbtowc}}
{{dsc end}}

[[de:c/string/multibyte/mbtowc]]
[[es:c/string/multibyte/mbtowc]]
[[fr:c/string/multibyte/mbtowc]]
[[it:c/string/multibyte/mbtowc]]
[[ja:c/string/multibyte/mbtowc]]
[[pt:c/string/multibyte/mbtowc]]
[[ru:c/string/multibyte/mbtowc]]
[[zh:c/string/multibyte/mbtowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/wcrtomb</title>
    <ns>0</ns>
    <id>6107</id>
    <revision>
      <id>56806</id>
      <parentid>49137</parentid>
      <timestamp>2013-06-01T05:41:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2050">{{c/title|wcrtomb}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
size_t wcrtomb( char* s, wchar_t wc, mbstate_t* ps);
}}

Converts a wide character to its narrow multibyte representation.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|wc}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|wcrtomb(buf, L'\0', ps)}} for some internal buffer {{tt|buf}}.

If wc is the null wide character {{c|L'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | wc | the wide character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. 

On failure (if {{c|wc}} is not a valid wide character), returns {{c|(size_t)-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc wctomb}}
{{dsc inc | c/string/multibyte/dsc mbrtowc}}
{{dsc see cpp | cpp/string/multibyte/wcrtomb}}
{{dsc end}}

[[de:c/string/multibyte/wcrtomb]]
[[es:c/string/multibyte/wcrtomb]]
[[fr:c/string/multibyte/wcrtomb]]
[[it:c/string/multibyte/wcrtomb]]
[[ja:c/string/multibyte/wcrtomb]]
[[pt:c/string/multibyte/wcrtomb]]
[[ru:c/string/multibyte/wcrtomb]]
[[zh:c/string/multibyte/wcrtomb]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/wcsrtombs</title>
    <ns>0</ns>
    <id>6105</id>
    <revision>
      <id>56809</id>
      <parentid>49138</parentid>
      <timestamp>2013-06-01T05:41:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2484">{{c/title|wcsrtombs}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
size_t wcsrtombs( char* dst, const wchar_t** src, size_t len, mbstate_t* ps )
}}

Converts a sequence of wide characters from the array whose first element is pointed to by {{tt|*src}} to its narrow multibyte representation that begins in the conversion state described by {{tt|*ps}}. If {{tt|dst}} is not null, converted characters are stored in the successive elements of the char array pointed to by {{tt|dst}}. No more than {{tt|len}} bytes are written to the destination array.

Each character is converted as if by a call to {{lc|wcrtomb}}. The conversion stops if:

* The null character was converted and stored. {{tt|src}} is set to {{lc|NULL}} and {{tt|*ps}} represents the initial shift state.
* A {{c|wchar_t}} was found that does not correspond to a valid character in the current C locale. {{tt|src}} is set to point at the first unconverted wide character.
* the next multibyte character to be stored would exceed {{tt|len}}. {{tt|src}} is set to point at the first unconverted wide character. This condition is not checked if {{c|1=dst==NULL}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to narrow character array where the multibyte characters will be stored}}
{{par | src | pointer to pointer to the first element of a null-terminated wide string}}
{{par | len | number of bytes available in the array pointed to by dst}}
{{par | ps | pointer to the conversion state object}}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences, but excluding the terminating {{c|'\0'}}) written to the character array whose first element is pointed to by {{tt|dst}}. If {{c|1=dst==NULL}}, returns the number of bytes that would have been written.

On conversion error (if invalid wide character was encountered), returns {{c|(size_t)-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc wcrtomb}}
{{dsc inc | c/string/multibyte/dsc mbsrtowcs}}
{{dsc see cpp | cpp/string/multibyte/wcsrtombs}}
{{dsc end}}

[[de:c/string/multibyte/wcsrtombs]]
[[es:c/string/multibyte/wcsrtombs]]
[[fr:c/string/multibyte/wcsrtombs]]
[[it:c/string/multibyte/wcsrtombs]]
[[ja:c/string/multibyte/wcsrtombs]]
[[pt:c/string/multibyte/wcsrtombs]]
[[ru:c/string/multibyte/wcsrtombs]]
[[zh:c/string/multibyte/wcsrtombs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/wcstombs</title>
    <ns>0</ns>
    <id>6104</id>
    <revision>
      <id>67379</id>
      <parentid>67319</parentid>
      <timestamp>2014-02-07T00:52:40Z</timestamp>
      <contributor>
        <ip>184.17.73.156</ip>
      </contributor>
      <text xml:space="preserve" bytes="3686">{{c/title|wcstombs}}
{{c/string/multibyte/navbar}}
{{dcl begin}}
{{dcl header | stdlib.h}}
{{dcl | until=c99 |
size_t wcstombs( char          *dst, const wchar_t          *src, size_t len );
}}
{{dcl | since=c99 |
size_t wcstombs( char *restrict dst, const wchar_t *restrict src, size_t len );
}}
{{dcl end}}

Converts a sequence of wide characters from the array whose first element is pointed to by {{tt|src}} to its narrow multibyte representation that begins in the initial shift state. Converted characters are stored in the successive elements of the char array pointed to by {{tt|dst}}. No more than {{tt|len}} bytes are written to the destination array.

Each character is converted as if by a call to {{lc|wctomb}}, except that the wctomb's conversion state is unaffected. The conversion stops if:

* The null character was converted and stored.
* A {{c|wchar_t}} was found that does not correspond to a valid character in the current C locale.
* The next multibyte character to be stored would exceed {{tt|len}}.

===Notes===
In most implementations, this function updates a global static object of type {{lc|mbstate_t}} as it processes through the string, and cannot be called simultaneously by two threads, {{c|wcsrtombs}} should be used in such cases.

POSIX specifies a common extension: if {{tt|dst}} is a null pointer, this function returns the number of bytes that would be written to {{tt|dst}}, if converted. Similar behavior is standard for {{c|wcsrtombs}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to narrow character array where the multibyte character will be stored}}
{{par | src | pointer to the first element of a null-terminated wide string to convert}}
{{par | len | number of bytes available in the array pointed to by dst}}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences, but excluding the terminating {{c|'\0'}}) written to the character array whose first element is pointed to by {{tt|dst}}.

On conversion error (if invalid wide character was encountered), returns {{c|(size_t)-1}}.

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;locale.h&gt;

int main () 
{
    // 4 wide characters
    const wchar_t src[] = L&quot;z\u00df\u6c34\U0001f34c&quot;;
    // they occupy 10 bytes in UTF-8
    char dst[11];

    setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    printf(&quot;wide-character string: '%ls'\n&quot;,src);
    for (size_t ndx=0; ndx &lt; sizeof src/sizeof src[0]; ++ndx)
        printf(&quot;   src[%2zu] = %#8x\n&quot;, ndx, src[ndx]);
    
    int rtn_val = wcstombs(dst, src, sizeof dst);
    printf(&quot;rtn_val = %d\n&quot;, rtn_val);
    if (rtn_val &gt; 0)
        printf(&quot;multibyte string:  '%s'\n&quot;,dst);
    for (size_t ndx=0; ndx&lt;sizeof dst; ++ndx)
        printf(&quot;   dst[%2zu] = %#2x\n&quot;, ndx, (unsigned char)dst[ndx]);
}
 | output=
wide-character string: 'zß水🍌'
   src[ 0] =     0x7a
   src[ 1] =     0xdf
   src[ 2] =   0x6c34
   src[ 3] =  0x1f34c
   src[ 4] =        0
rtn_val = 10
multibyte string:  'zß水🍌'
   dst[ 0] = 0x7a
   dst[ 1] = 0xc3
   dst[ 2] = 0x9f
   dst[ 3] = 0xe6
   dst[ 4] = 0xb0
   dst[ 5] = 0xb4
   dst[ 6] = 0xf0
   dst[ 7] = 0x9f
   dst[ 8] = 0x8d
   dst[ 9] = 0x8c
   dst[10] =  0

}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc wcsrtombs}}
{{dsc inc | c/string/multibyte/dsc mbstowcs}}
{{dsc see cpp | cpp/string/multibyte/wcstombs}}
{{dsc end}}

[[de:c/string/multibyte/wcstombs]]
[[es:c/string/multibyte/wcstombs]]
[[fr:c/string/multibyte/wcstombs]]
[[it:c/string/multibyte/wcstombs]]
[[ja:c/string/multibyte/wcstombs]]
[[pt:c/string/multibyte/wcstombs]]
[[ru:c/string/multibyte/wcstombs]]
[[zh:c/string/multibyte/wcstombs]]</text>
      <sha1>d4pl6pwoy6qm9yx3zmaxd42f6xydqxq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/wctob</title>
    <ns>0</ns>
    <id>6110</id>
    <revision>
      <id>56811</id>
      <parentid>49140</parentid>
      <timestamp>2013-06-01T05:41:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1138">{{c/title|wctob}}
{{c/string/multibyte/navbar}}
{{ddcl | header=wchar.h |
int wctob( wint_t c );
}}

Narrows a wide character {{tt|c}} if its multibyte character equivalent in the initial shift state is a single byte.

This is typically possible for the characters from the ASCII character set, since most multibyte encodings (such as UTF-8) use single bytes to encode those characters.

===Parameters===
{{par begin}}
{{par | c | wide character to narrow}}
{{par end}}

===Return value===

{{lc|EOF}} if {{tt|c}} does not represent a multibyte character with length {{c|1}} in initial shift state.

otherwise, the single-byte representation of {{tt|c}} as {{c|unsigned char}} converted to {{c|int}}

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc btowc}}
{{dsc see cpp | cpp/string/multibyte/wctob}}
{{dsc end}}

[[de:c/string/multibyte/wctob]]
[[es:c/string/multibyte/wctob]]
[[fr:c/string/multibyte/wctob]]
[[it:c/string/multibyte/wctob]]
[[ja:c/string/multibyte/wctob]]
[[pt:c/string/multibyte/wctob]]
[[ru:c/string/multibyte/wctob]]
[[zh:c/string/multibyte/wctob]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/multibyte/wctomb</title>
    <ns>0</ns>
    <id>6114</id>
    <revision>
      <id>67318</id>
      <parentid>67290</parentid>
      <timestamp>2014-02-04T20:03:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2889">{{c/title|wctomb}}
{{c/string/multibyte/navbar}}
{{ddcl | header=stdlib.h |
int wctomb( char* s, wchar_t wc );
}}

Converts a wide character {{tt|wc}} to multibyte encoding and stores it (including any shift sequences) in the char array whose first element is pointed to by {{tt|s}}. No more than {{c|MB_CUR_MAX}} characters are stored.

If {{tt|wc}} is the null character, the null byte is written to {{tt|s}}, preceded by any shift sequences necessary to restore the initial shift state.

If {{tt|s}} is a null pointer, resets the global conversion state and determines whether shift sequences are used.

===Notes===
Each call to {{tt|wctomb}} updates the internal global conversion state (a static object of type {{lc|mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, this function is not reentrant. In any case, multiple threads should not call {{tt|wctomb}} without synchronization: {{lc|wcrtomb}} may be used instead.

===Parameters===
{{par begin}}
{{par | s | pointer to the character array for output}}
{{par | wc | wide character to convert}}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte representation of {{tt|wc}} or  {{c|-1}} if {{tt|wc}} is not a valid character. 

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Example===
{{example
 | 
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;locale.h&gt;

void demo(wchar_t wc)
{
    printf(&quot;State-dependent encoding?   %d\n&quot;, wctomb(NULL, wc));

    char mb[MB_CUR_MAX];
    int len = wctomb(mb,wc);
    printf(&quot;wide char '%lc' -&gt; multibyte char '&quot;, wc);
    for (int idx = 0; idx &lt; len; ++idx)
        printf(&quot;%#2x &quot;, (unsigned char)mb[idx]);
    printf(&quot;'\n&quot;);
}

int main () 
{
    setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    printf(&quot;MB_CUR_MAX = %zu\n&quot;, MB_CUR_MAX);
    demo(L'A');
    demo(L'\u00df');
    demo(L'\U0001d10b');
}
 | output=
MB_CUR_MAX = 6
State-dependent encoding?   0
wide char 'A' -&gt; multibyte char '0x41 '
State-dependent encoding?   0
wide char 'ß' -&gt; multibyte char '0xc3 0x9f '
State-dependent encoding?   0
wide char '𝄋' -&gt; multibyte char '0xf0 0x9d 0x84 0x8b '
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/multibyte/dsc mbtowc}}
{{dsc inc | c/string/multibyte/dsc wcrtomb}}
{{dsc see cpp | cpp/string/multibyte/wctomb}}
{{dsc end}}

[[de:c/string/multibyte/wctomb]]
[[es:c/string/multibyte/wctomb]]
[[fr:c/string/multibyte/wctomb]]
[[it:c/string/multibyte/wctomb]]
[[ja:c/string/multibyte/wctomb]]
[[pt:c/string/multibyte/wctomb]]
[[ru:c/string/multibyte/wctomb]]
[[zh:c/string/multibyte/wctomb]]</text>
      <sha1>ds9vpaf9cwuok2evripnpwtc364qk22</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide</title>
    <ns>0</ns>
    <id>5759</id>
    <revision>
      <id>71110</id>
      <parentid>56815</parentid>
      <timestamp>2014-06-06T12:10:15Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C++</comment>
      <text xml:space="preserve" bytes="3428">{{title|Null-terminated wide strings}}
{{c/string/wide/navbar}}

A null-terminated wide string is a sequence of valid wide characters, ending with a null-character.

===Functions===
{{dsc begin}}
{{dsc h2 | Character classification}}
{{dsc header | wctype.h}}
{{dsc inc | c/string/wide/dsc iswalnum}}
{{dsc inc | c/string/wide/dsc iswalpha}}
{{dsc inc | c/string/wide/dsc iswlower}}
{{dsc inc | c/string/wide/dsc iswupper}}
{{dsc inc | c/string/wide/dsc iswdigit}}
{{dsc inc | c/string/wide/dsc iswxdigit}}
{{dsc inc | c/string/wide/dsc iswcntrl}}
{{dsc inc | c/string/wide/dsc iswgraph}}
{{dsc inc | c/string/wide/dsc iswspace}}
{{dsc inc | c/string/wide/dsc iswblank}}
{{dsc inc | c/string/wide/dsc iswprint}}
{{dsc inc | c/string/wide/dsc iswpunct}}
{{dsc inc | c/string/wide/dsc iswctype}}
{{dsc inc | c/string/wide/dsc wctype}}
{{dsc h2 | Character manipulation}}
{{dsc header | wctype.h}}
{{dsc inc | c/string/wide/dsc towlower}}
{{dsc inc | c/string/wide/dsc towupper}}
{{dsc inc | c/string/wide/dsc towctrans}}
{{dsc inc | c/string/wide/dsc wctrans}}
{{dsc end}}
{{c/string/character classes}}
{{dsc begin}}
{{dsc h2 | Conversions to numeric formats}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/wide/dsc wcstol}}
{{dsc inc | c/string/wide/dsc wcstoul}}
{{dsc inc | c/string/wide/dsc wcstof}}
{{dsc header | inttypes.h}}
{{dsc inc | c/string/wide/dsc wcstoimax}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | String manipulation}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/wide/dsc wcscpy}}
{{dsc inc | c/string/wide/dsc wcsncpy}}
{{dsc inc | c/string/wide/dsc wcscat}}
{{dsc inc | c/string/wide/dsc wcsncat}}
{{dsc inc | c/string/wide/dsc wcsxfrm}}

{{dsc h2 | String examination}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/wide/dsc wcslen}}
{{dsc inc | c/string/wide/dsc wcscmp}}
{{dsc inc | c/string/wide/dsc wcsncmp}}
{{dsc inc | c/string/wide/dsc wcscoll}}
{{dsc inc | c/string/wide/dsc wcschr}}
{{dsc inc | c/string/wide/dsc wcsrchr}}
{{dsc inc | c/string/wide/dsc wcsspn}}
{{dsc inc | c/string/wide/dsc wcscspn}}
{{dsc inc | c/string/wide/dsc wcspbrk}}
{{dsc inc | c/string/wide/dsc wcsstr}}
{{dsc inc | c/string/wide/dsc wcstok}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Wide character array manipulation}}
{{dsc header | wchar.h}}
{{dsc inc | c/string/wide/dsc wmemcpy}}
{{dsc inc | c/string/wide/dsc wmemmove}}
{{dsc inc | c/string/wide/dsc wmemcmp}}
{{dsc inc | c/string/wide/dsc wmemchr}}
{{dsc inc | c/string/wide/dsc wmemset}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | wctype.h}}
{{dsc | {{tt|wctrans_t}} | scalar type that holds locale-specific character mapping }}
{{dsc | {{tt|wctype_t}} | scalar type that holds locale-specific character classification }}
{{dsc | {{tt|wint_t}} | integer type that can hold any valid wide character and at least one more value }}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc header | wchar.h}}
{{dsc macro const | WEOF |  nolink=true | a non-character value of type wint_t used to indicate errors}}
{{dsc macro const | WCHAR_MIN |  nolink=true | the smallest valid value of wchar_t }}
{{dsc macro const | WCHAR_MAX |  nolink=true | the largest valid value of wchar_t }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/wide | Null-terminated wide strings}}
{{dsc end}}

[[de:c/string/wide]]
[[es:c/string/wide]]
[[fr:c/string/wide]]
[[it:c/string/wide]]
[[ja:c/string/wide]]
[[pt:c/string/wide]]
[[ru:c/string/wide]]
[[zh:c/string/wide]]</text>
      <sha1>id8mync8b3trr02sq2cgdwvq2pq6yus</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswalnum</title>
    <ns>0</ns>
    <id>6073</id>
    <revision>
      <id>56818</id>
      <parentid>49143</parentid>
      <timestamp>2013-06-01T05:41:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="989">{{c/title|iswalnum}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswalnum( wint_t ch );
}}

Checks if the given wide character is an alphanumeric character, i.e. either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}) or any alphanumeric character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a alphanumeric character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isalnum}}
{{dsc see cpp | cpp/string/wide/iswalnum}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswalnum]]
[[es:c/string/wide/iswalnum]]
[[fr:c/string/wide/iswalnum]]
[[it:c/string/wide/iswalnum]]
[[ja:c/string/wide/iswalnum]]
[[pt:c/string/wide/iswalnum]]
[[ru:c/string/wide/iswalnum]]
[[zh:c/string/wide/iswalnum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswalpha</title>
    <ns>0</ns>
    <id>6072</id>
    <revision>
      <id>56819</id>
      <parentid>49144</parentid>
      <timestamp>2013-06-01T05:41:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="953">{{c/title|iswalpha}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswalpha( wint_t ch );
}}

Checks if the given wide character is an alphabetic character, i.e. either an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}) or any alphabetic character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a alphabetic character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isalpha}}
{{dsc see cpp | cpp/string/wide/iswalpha}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswalpha]]
[[es:c/string/wide/iswalpha]]
[[fr:c/string/wide/iswalpha]]
[[it:c/string/wide/iswalpha]]
[[ja:c/string/wide/iswalpha]]
[[pt:c/string/wide/iswalpha]]
[[ru:c/string/wide/iswalpha]]
[[zh:c/string/wide/iswalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswblank</title>
    <ns>0</ns>
    <id>6065</id>
    <revision>
      <id>63535</id>
      <parentid>56820</parentid>
      <timestamp>2013-07-10T01:35:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="911">{{c/title|iswblank}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h | since=c99 |
int iswblank( wint_t ch );
}}

Checks if the given wide character is classified as blank character by the current C locale. In the default C locale, only space ({{tt|0x20}}) and horizontal tab ({{tt|0x09}}) are blank characters.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a blank character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isblank}}
{{dsc see cpp | cpp/string/wide/iswblank}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswblank]]
[[es:c/string/wide/iswblank]]
[[fr:c/string/wide/iswblank]]
[[it:c/string/wide/iswblank]]
[[ja:c/string/wide/iswblank]]
[[pt:c/string/wide/iswblank]]
[[ru:c/string/wide/iswblank]]
[[zh:c/string/wide/iswblank]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswcntrl</title>
    <ns>0</ns>
    <id>6068</id>
    <revision>
      <id>56823</id>
      <parentid>49146</parentid>
      <timestamp>2013-06-01T05:41:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="865">{{c/title|iswcntrl}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswcntrl( wint_t ch );
}}

Checks if the given wide character is a control character, i.e. codes {{tt|0x00-0x1F}} and {{tt|0x7F}} and any control characters specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a control character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc iscntrl}}
{{dsc see cpp | cpp/string/wide/iswcntrl}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswcntrl]]
[[es:c/string/wide/iswcntrl]]
[[fr:c/string/wide/iswcntrl]]
[[it:c/string/wide/iswcntrl]]
[[ja:c/string/wide/iswcntrl]]
[[pt:c/string/wide/iswcntrl]]
[[ru:c/string/wide/iswcntrl]]
[[zh:c/string/wide/iswcntrl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswctype</title>
    <ns>0</ns>
    <id>6062</id>
    <revision>
      <id>56824</id>
      <parentid>49147</parentid>
      <timestamp>2013-06-01T05:41:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="865">{{c/title|iswctype}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswctype( wint_t ch, wctype_t desc );
}}

Classifies the wide character {{tt|wc}} using the current C locale's LC_CTYPE category identified by {{tt|desc}}.

===Parameters===
{{par begin}}
{{par | ch | the wide character to classify}}
{{par | desc | the LC_CTYPE category, obtained from a call to {{lc|wctype}}}}
{{par end}}

===Return value===

Non-zero if the character {{tt|ch}} has the property identified by {{tt|desc}} in LC_CTYPE facet of the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wctype}}
{{dsc end}}

[[de:c/string/wide/iswctype]]
[[es:c/string/wide/iswctype]]
[[fr:c/string/wide/iswctype]]
[[it:c/string/wide/iswctype]]
[[ja:c/string/wide/iswctype]]
[[pt:c/string/wide/iswctype]]
[[ru:c/string/wide/iswctype]]
[[zh:c/string/wide/iswctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswdigit</title>
    <ns>0</ns>
    <id>6070</id>
    <revision>
      <id>66601</id>
      <parentid>56825</parentid>
      <timestamp>2013-12-13T08:00:10Z</timestamp>
      <contributor>
        <ip>87.249.142.46</ip>
      </contributor>
      <comment>Wrong name in title and declaration of functions</comment>
      <text xml:space="preserve" bytes="849">{{c/title|iswdigit}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswdigit( wint_t ch );
}}

Checks if the given wide character is a numeric character, i.e. one of {{tt|0123456789}} or any numeric character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an numeric character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isdigit}}
{{dsc see cpp | cpp/string/wide/iswdigit}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/wide/iswdigit]]
[[es:c/string/wide/iswdigit]]
[[fr:c/string/wide/iswdigit]]
[[it:c/string/wide/iswdigit]]
[[ja:c/string/wide/iswdigit]]
[[pt:c/string/wide/iswdigit]]
[[ru:c/string/wide/iswdigit]]
[[zh:c/string/wide/iswdigit]]</text>
      <sha1>bpap8wsojizdx3sa27kn7g8mchbfddm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswgraph</title>
    <ns>0</ns>
    <id>6067</id>
    <revision>
      <id>62275</id>
      <parentid>56828</parentid>
      <timestamp>2013-06-26T03:54:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;i. e.&quot; to &quot;i.e.&quot;</comment>
      <text xml:space="preserve" bytes="1116">{{c/title|iswgraph}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswgraph( wint_t ch );
}}

Checks if the given wide character has a graphical representation, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}) or any graphical character specific to the current C locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character has a graphical representation character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isgraph}}
{{dsc see cpp | cpp/string/wide/iswgraph}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/wide/iswgraph]]
[[es:c/string/wide/iswgraph]]
[[fr:c/string/wide/iswgraph]]
[[it:c/string/wide/iswgraph]]
[[ja:c/string/wide/iswgraph]]
[[pt:c/string/wide/iswgraph]]
[[ru:c/string/wide/iswgraph]]
[[zh:c/string/wide/iswgraph]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswlower</title>
    <ns>0</ns>
    <id>6171</id>
    <revision>
      <id>56829</id>
      <parentid>49150</parentid>
      <timestamp>2013-06-01T05:41:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="863">{{c/title|iswlower}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswlower( wint_t ch );
}}

Checks if the given wide character is a lowercase letter, i.e. one of {{tt|abcdefghijklmnopqrstuvwxyz}} or any lowercase letter specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an lowercase letter, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc islower}}
{{dsc see cpp | cpp/string/wide/iswlower}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswlower]]
[[es:c/string/wide/iswlower]]
[[fr:c/string/wide/iswlower]]
[[it:c/string/wide/iswlower]]
[[ja:c/string/wide/iswlower]]
[[pt:c/string/wide/iswlower]]
[[ru:c/string/wide/iswlower]]
[[zh:c/string/wide/iswlower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswprint</title>
    <ns>0</ns>
    <id>6064</id>
    <revision>
      <id>62276</id>
      <parentid>56830</parentid>
      <timestamp>2013-06-26T03:55:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;i. e.&quot; to &quot;i.e.&quot;</comment>
      <text xml:space="preserve" bytes="1081">{{c/title|iswprint}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswprint( wint_t ch );
}}

Checks if the given wide character can be printed, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}), space or any printable character specific to the current C locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character can be printed, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isprint}}
{{dsc see cpp | cpp/string/wide/iswprint}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/wide/iswprint]]
[[es:c/string/wide/iswprint]]
[[fr:c/string/wide/iswprint]]
[[it:c/string/wide/iswprint]]
[[ja:c/string/wide/iswprint]]
[[pt:c/string/wide/iswprint]]
[[ru:c/string/wide/iswprint]]
[[zh:c/string/wide/iswprint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswpunct</title>
    <ns>0</ns>
    <id>6063</id>
    <revision>
      <id>56833</id>
      <parentid>49152</parentid>
      <timestamp>2013-06-01T05:41:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="930">{{c/title|iswpunct}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswpunct( wint_t ch );
}}

Checks if the given wide character is a punctuation character, i.e. it is one of {{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}} or any punctuation character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a punctuation character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc ispunct}}
{{dsc see cpp | cpp/string/wide/iswpunct}}
{{dsc end}}
{{c/string/character classes}}

[[de:c/string/wide/iswpunct]]
[[es:c/string/wide/iswpunct]]
[[fr:c/string/wide/iswpunct]]
[[it:c/string/wide/iswpunct]]
[[ja:c/string/wide/iswpunct]]
[[pt:c/string/wide/iswpunct]]
[[ru:c/string/wide/iswpunct]]
[[zh:c/string/wide/iswpunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswspace</title>
    <ns>0</ns>
    <id>6066</id>
    <revision>
      <id>56834</id>
      <parentid>49153</parentid>
      <timestamp>2013-06-01T05:41:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="999">{{c/title|iswspace}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswspace( wint_t ch );
}}

Checks if the given wide character is a whitespace character, i.e. either space ({{tt|0x20}}), form feed ({{tt|0x0c}}), line feed ({{tt|0x0a}}), carriage return ({{tt|0x0d}}), horizontal tab ({{tt|0x09}}), vertical tab ({{tt|0x0b}}) or any whitespace character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a whitespace character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isspace}}
{{dsc see cpp | cpp/string/wide/iswspace}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswspace]]
[[es:c/string/wide/iswspace]]
[[fr:c/string/wide/iswspace]]
[[it:c/string/wide/iswspace]]
[[ja:c/string/wide/iswspace]]
[[pt:c/string/wide/iswspace]]
[[ru:c/string/wide/iswspace]]
[[zh:c/string/wide/iswspace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswupper</title>
    <ns>0</ns>
    <id>6071</id>
    <revision>
      <id>56835</id>
      <parentid>49154</parentid>
      <timestamp>2013-06-01T05:41:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="864">{{c/title|iswupper}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswupper( wint_t ch );
}}

Checks if the given wide character is an uppercase letter, i.e. one of {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}} or any uppercase letter specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an uppercase letter, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isupper}}
{{dsc see cpp | cpp/string/wide/iswupper}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswupper]]
[[es:c/string/wide/iswupper]]
[[fr:c/string/wide/iswupper]]
[[it:c/string/wide/iswupper]]
[[ja:c/string/wide/iswupper]]
[[pt:c/string/wide/iswupper]]
[[ru:c/string/wide/iswupper]]
[[zh:c/string/wide/iswupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/iswxdigit</title>
    <ns>0</ns>
    <id>6069</id>
    <revision>
      <id>56838</id>
      <parentid>49155</parentid>
      <timestamp>2013-06-01T05:42:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="909">{{c/title|iswxdigit}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
int iswxdigit( wint_t ch );
}}

Checks if the given wide character is a hexadecimal numeric character, i.e. one of {{tt|0123456789abcdefABCDEF}} or any hexadecimal numeric character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a hexadecimal numeric character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc isxdigit}}
{{dsc see cpp | cpp/string/wide/iswxdigit}}
{{dsc end}}

{{c/string/character classes}}

[[de:c/string/wide/iswxdigit]]
[[es:c/string/wide/iswxdigit]]
[[fr:c/string/wide/iswxdigit]]
[[it:c/string/wide/iswxdigit]]
[[ja:c/string/wide/iswxdigit]]
[[pt:c/string/wide/iswxdigit]]
[[ru:c/string/wide/iswxdigit]]
[[zh:c/string/wide/iswxdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/towctrans</title>
    <ns>0</ns>
    <id>6075</id>
    <revision>
      <id>56839</id>
      <parentid>49156</parentid>
      <timestamp>2013-06-01T05:42:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="915">{{c/title|towctrans}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
wint_t towctrans( wint_t wc, wctrans_t desc );
}}

Maps the wide character {{tt|wc}} using the current C locale's LC_CTYPE mapping category identified by {{tt|desc}}.

===Parameters===
{{par begin}}
{{par | ch | the wide character to map}}
{{par | desc | the LC_CTYPE mapping, obtained from a call to {{lc|wctrans}}}}
{{par end}}

===Return value===
The mapped value of {{tt|ch}} using the mapping identified by {{tt|desc}} in LC_CTYPE facet of the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wctrans}}
{{dsc see cpp | cpp/string/wide/towctrans}}
{{dsc end}}

[[de:c/string/wide/towctrans]]
[[es:c/string/wide/towctrans]]
[[fr:c/string/wide/towctrans]]
[[it:c/string/wide/towctrans]]
[[ja:c/string/wide/towctrans]]
[[pt:c/string/wide/towctrans]]
[[ru:c/string/wide/towctrans]]
[[zh:c/string/wide/towctrans]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/towlower</title>
    <ns>0</ns>
    <id>6077</id>
    <revision>
      <id>56840</id>
      <parentid>49157</parentid>
      <timestamp>2013-06-01T05:42:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1079">{{c/title|towlower}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
wint_t towlower( wint_t ch );
}}
Converts the given wide character to lowercase, if possible.

===Parameters===
{{par begin}}
{{par | ch | wide character to be converted}}
{{par end}}

===Return value===
Lowercase version of {{tt|ch}} or unmodified {{tt|ch}} if no lowercase version is listed in the current C locale.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the Greek uppercase letter 'Σ' has two lowercase forms, depending on the position in a word: 'σ' and 'ς'. A call to {{lc|towlower}} cannot be used to obtain the correct lowercase form in this case. 

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc towupper}}
{{dsc inc | c/string/byte/dsc tolower}}
{{dsc see cpp | cpp/string/wide/towlower}}
{{dsc end}}

[[de:c/string/wide/towlower]]
[[es:c/string/wide/towlower]]
[[fr:c/string/wide/towlower]]
[[it:c/string/wide/towlower]]
[[ja:c/string/wide/towlower]]
[[pt:c/string/wide/towlower]]
[[ru:c/string/wide/towlower]]
[[zh:c/string/wide/towlower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/towupper</title>
    <ns>0</ns>
    <id>6076</id>
    <revision>
      <id>56843</id>
      <parentid>49158</parentid>
      <timestamp>2013-06-01T05:42:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1006">{{c/title|towupper}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
wint_t towupper( wint_t ch );
}}
Converts the given wide character to uppercase, if possible.

===Parameters===
{{par begin}}
{{par | ch | wide character to be converted}}
{{par end}}

===Return value===
Uppercase version of {{tt|ch}} or unmodified {{tt|ch}} if no uppercase version is listed in the current C locale.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the uppercase form of 'ß' is (with some exceptions) the two-character string &quot;SS&quot;, which cannot be obtained by {{lc|towupper}}.

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc towlower}}
{{dsc inc | c/string/byte/dsc toupper}}
{{dsc see cpp | cpp/string/wide/towupper}}
{{dsc end}}

[[de:c/string/wide/towupper]]
[[es:c/string/wide/towupper]]
[[fr:c/string/wide/towupper]]
[[it:c/string/wide/towupper]]
[[ja:c/string/wide/towupper]]
[[pt:c/string/wide/towupper]]
[[ru:c/string/wide/towupper]]
[[zh:c/string/wide/towupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcscat</title>
    <ns>0</ns>
    <id>6080</id>
    <revision>
      <id>56844</id>
      <parentid>49159</parentid>
      <timestamp>2013-06-01T05:42:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="976">{{c/title| wcscat}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t *wcscat( wchar_t *dest, const wchar_t *src );
}}

Appends a wide string pointed to by {{tt|src}} to a wide string pointed to by {{tt|dest}}. The resulting wide string is null-terminated. If the strings overlap, the behavior is undefined. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to append to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcsncat}}
{{dsc inc | c/string/wide/dsc wcscpy}}
{{dsc see cpp | cpp/string/wide/wcscat}}
{{dsc end}}

[[de:c/string/wide/wcscat]]
[[es:c/string/wide/wcscat]]
[[fr:c/string/wide/wcscat]]
[[it:c/string/wide/wcscat]]
[[ja:c/string/wide/wcscat]]
[[pt:c/string/wide/wcscat]]
[[ru:c/string/wide/wcscat]]
[[zh:c/string/wide/wcscat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcschr</title>
    <ns>0</ns>
    <id>6098</id>
    <revision>
      <id>56845</id>
      <parentid>49160</parentid>
      <timestamp>2013-06-01T05:42:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="976">{{c/title| wcschr}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
wchar_t* strchr( const wchar_t* str, wchar_t ch );
}}
{{dcl end}}

Finds the first occurrence of the wide character {{tt|ch}} in the wide string pointed to by {{tt|str}}. 

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be analyzed}}
{{par | ch | wide character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcsrchr}}
{{dsc inc | c/string/wide/dsc wcspbrk}}
{{dsc see cpp | cpp/string/wide/wcschr}}
{{dsc end}}

[[de:c/string/wide/wcschr]]
[[es:c/string/wide/wcschr]]
[[fr:c/string/wide/wcschr]]
[[it:c/string/wide/wcschr]]
[[ja:c/string/wide/wcschr]]
[[pt:c/string/wide/wcschr]]
[[ru:c/string/wide/wcschr]]
[[zh:c/string/wide/wcschr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcscmp</title>
    <ns>0</ns>
    <id>6101</id>
    <revision>
      <id>56848</id>
      <parentid>49161</parentid>
      <timestamp>2013-06-01T05:42:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1004">{{c/title| wcscmp}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
int wcscmp( const wchar_t* lhs, const wchar_t* rhs );
}}

Compares two null-terminated wide strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcsncmp}}
{{dsc inc | c/string/wide/dsc wmemcmp}}
{{dsc inc | c/string/wide/dsc wcscoll}}
{{dsc see cpp | cpp/string/wide/wcscmp}}
{{dsc end}}

[[de:c/string/wide/wcscmp]]
[[es:c/string/wide/wcscmp]]
[[fr:c/string/wide/wcscmp]]
[[it:c/string/wide/wcscmp]]
[[ja:c/string/wide/wcscmp]]
[[pt:c/string/wide/wcscmp]]
[[ru:c/string/wide/wcscmp]]
[[zh:c/string/wide/wcscmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcscoll</title>
    <ns>0</ns>
    <id>6099</id>
    <revision>
      <id>56849</id>
      <parentid>49162</parentid>
      <timestamp>2013-06-01T05:42:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1048">{{c/title| wcscoll}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
int wcscoll( const wchar_t* lhs, const wchar_t* rhs );
}}

Compares two null-terminated wide strings according to the current locale as defined by the {{lc|LC_COLLATE}} category.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscmp}}
{{dsc inc | c/string/wide/dsc wcsncmp}}
{{dsc inc | c/string/wide/dsc wcscmp}}
{{dsc see cpp | cpp/string/wide/wcscoll}}
{{dsc end}}

[[de:c/string/wide/wcscoll]]
[[es:c/string/wide/wcscoll]]
[[fr:c/string/wide/wcscoll]]
[[it:c/string/wide/wcscoll]]
[[ja:c/string/wide/wcscoll]]
[[pt:c/string/wide/wcscoll]]
[[ru:c/string/wide/wcscoll]]
[[zh:c/string/wide/wcscoll]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcscpy</title>
    <ns>0</ns>
    <id>6082</id>
    <revision>
      <id>56850</id>
      <parentid>49163</parentid>
      <timestamp>2013-06-01T05:42:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="978">{{c/title| wcscpy}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t *wcscpy( wchar_t *dest, const wchar_t *src );
}}

Copies the wide string pointed to by {{tt|src}} (including the terminating null wide character) to wide character array pointed to by {{tt|dest}}.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the wide character array to copy to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcsncpy}}
{{dsc inc | c/string/wide/dsc wmemcpy}}
{{dsc see cpp | cpp/string/wide/wcscpy}}
{{dsc end}}

[[de:c/string/wide/wcscpy]]
[[es:c/string/wide/wcscpy]]
[[fr:c/string/wide/wcscpy]]
[[it:c/string/wide/wcscpy]]
[[ja:c/string/wide/wcscpy]]
[[pt:c/string/wide/wcscpy]]
[[ru:c/string/wide/wcscpy]]
[[zh:c/string/wide/wcscpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcscspn</title>
    <ns>0</ns>
    <id>6095</id>
    <revision>
      <id>56853</id>
      <parentid>49164</parentid>
      <timestamp>2013-06-01T05:42:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1141">{{c/title| wcscspn}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
size_t wcscspn( const wchar_t* dest, const wchar_t* src );
}}

Returns the length of the maximum initial segment of the wide string pointed to by {{tt|dest}}, that consists of only the characters ''not'' found in wide string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters not found in the character string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcsspn}}
{{dsc inc | c/string/wide/dsc wcspbrk}}
{{dsc see cpp | cpp/string/wide/wcscspn}}
{{dsc end}}

[[de:c/string/wide/wcscspn]]
[[es:c/string/wide/wcscspn]]
[[fr:c/string/wide/wcscspn]]
[[it:c/string/wide/wcscspn]]
[[ja:c/string/wide/wcscspn]]
[[pt:c/string/wide/wcscspn]]
[[ru:c/string/wide/wcscspn]]
[[zh:c/string/wide/wcscspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcslen</title>
    <ns>0</ns>
    <id>6102</id>
    <revision>
      <id>49165</id>
      <parentid>42437</parentid>
      <timestamp>2013-06-01T01:42:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="799">{{c/title| wcslen}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
size_t wcslen( const wchar_t *str );
}}

Returns the length of a wide string, that is the number of non-null wide characters that precede the terminating null wide character.

===Parameters===
{{par begin}}
{{par |str | pointer to the null-terminated wide string to be examined}}
{{par end}}

===Return value===
The length of the null-terminated wide string {{tt|str}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/wide/wcslen}}
{{dsc end}}

[[de:c/string/wide/wcslen]]
[[es:c/string/wide/wcslen]]
[[fr:c/string/wide/wcslen]]
[[it:c/string/wide/wcslen]]
[[ja:c/string/wide/wcslen]]
[[pt:c/string/wide/wcslen]]
[[ru:c/string/wide/wcslen]]
[[zh:c/string/wide/wcslen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsncat</title>
    <ns>0</ns>
    <id>6079</id>
    <revision>
      <id>56854</id>
      <parentid>49166</parentid>
      <timestamp>2013-06-01T05:42:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1109">{{c/title| wcsncat}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t *wcsncat( wchar_t *dest, const wchar_t *src, size_t count );
}}

Appends a wide string pointed to by {{tt|src}} to a wide string pointed to by {{tt|dest}}. At most {{tt|count}} wide characters are copied. The resulting wide string is null-terminated. If the strings overlap, the behavior is undefined. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to append to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par | count | maximum number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscat}}
{{dsc inc | c/string/wide/dsc wcscpy}}
{{dsc see cpp | cpp/string/wide/wcsncat}}
{{dsc end}}

[[de:c/string/wide/wcsncat]]
[[es:c/string/wide/wcsncat]]
[[fr:c/string/wide/wcsncat]]
[[it:c/string/wide/wcsncat]]
[[ja:c/string/wide/wcsncat]]
[[pt:c/string/wide/wcsncat]]
[[ru:c/string/wide/wcsncat]]
[[zh:c/string/wide/wcsncat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsncmp</title>
    <ns>0</ns>
    <id>6100</id>
    <revision>
      <id>56855</id>
      <parentid>49167</parentid>
      <timestamp>2013-06-01T05:42:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1126">{{c/title| wcsncmp}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
int wcsncmp( const wchar_t* lhs, const wchar_t* rhs, size_t count );
}}

Compares at most {{tt|count}} wide characters of two null-terminated wide strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par | count | maximum number of characters to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscmp}}
{{dsc inc | c/string/wide/dsc wmemcmp}}
{{dsc inc | c/string/wide/dsc wcscoll}}
{{dsc see cpp | cpp/string/wide/wcsncmp}}
{{dsc end}}

[[de:c/string/wide/wcsncmp]]
[[es:c/string/wide/wcsncmp]]
[[fr:c/string/wide/wcsncmp]]
[[it:c/string/wide/wcsncmp]]
[[ja:c/string/wide/wcsncmp]]
[[pt:c/string/wide/wcsncmp]]
[[ru:c/string/wide/wcsncmp]]
[[zh:c/string/wide/wcsncmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsncpy</title>
    <ns>0</ns>
    <id>6081</id>
    <revision>
      <id>56858</id>
      <parentid>49168</parentid>
      <timestamp>2013-06-01T05:42:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1521">{{c/title| wcsncpy}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t* wcsncpy( wchar_t* dest, const wchar_t* src, size_t count );
}}

Copies at most {{tt|count}} characters of the wide string pointed to by {{tt|src}} (including the terminating null wide character) to wide character array pointed to by {{tt|dest}}. 

If {{tt|count}} is reached before the entire string {{tt|src}} was copied, the resulting wide character array is not null-terminated.

If, after copying the terminating null wide character from {{tt|src}}, {{tt|count}} is not reached, additional null wide characters are written to {{tt|dest}} until the total of {{tt|count}} characters have been written.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the wide character array to copy to}}
{{par | src | pointer to the wide string to copy from}}
{{par | count | maximum number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Notes===
In typical usage, {{tt|count}} is the size of the destination array.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscpy}}
{{dsc inc | c/string/wide/dsc wmemcpy}}
{{dsc see cpp | cpp/string/wide/wcsncpy}}
{{dsc end}}

[[de:c/string/wide/wcsncpy]]
[[es:c/string/wide/wcsncpy]]
[[fr:c/string/wide/wcsncpy]]
[[it:c/string/wide/wcsncpy]]
[[ja:c/string/wide/wcsncpy]]
[[pt:c/string/wide/wcsncpy]]
[[ru:c/string/wide/wcsncpy]]
[[zh:c/string/wide/wcsncpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcspbrk</title>
    <ns>0</ns>
    <id>6094</id>
    <revision>
      <id>56859</id>
      <parentid>49169</parentid>
      <timestamp>2013-06-01T05:42:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1098">{{c/title| wcspbrk}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
wchar_t* wcspbrk( const wchar_t* dest, const wchar_t* str );
}}
{{dcl end}}

Finds the first character in wide string pointed to by {{tt|dest}}, that is also in wide string pointed to by {{tt|str}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
Pointer to the first character in {{tt|dest}}, that is also in {{tt|str}}, or {{lc|NULL}} if no such character exists.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscspn}}
{{dsc inc | c/string/wide/dsc wcschr}}
{{dsc see cpp | cpp/string/wide/wcspbrk}}
{{dsc end}}

[[de:c/string/wide/wcspbrk]]
[[es:c/string/wide/wcspbrk]]
[[fr:c/string/wide/wcspbrk]]
[[it:c/string/wide/wcspbrk]]
[[ja:c/string/wide/wcspbrk]]
[[pt:c/string/wide/wcspbrk]]
[[ru:c/string/wide/wcspbrk]]
[[zh:c/string/wide/wcspbrk]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsrchr</title>
    <ns>0</ns>
    <id>6097</id>
    <revision>
      <id>56862</id>
      <parentid>49170</parentid>
      <timestamp>2013-06-01T05:42:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="985">{{c/title| wcsrchr}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
wchar_t* wcsrchr( const wchar_t* str, wchar_t ch );
}}
{{dcl end}}

Finds the last occurrence of the wide character {{tt|ch}} in the wide string pointed to by {{tt|str}}. 

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be analyzed}}
{{par | ch | wide character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcschr}}
{{dsc inc | c/string/wide/dsc wcspbrk}}
{{dsc see cpp | cpp/string/wide/wcsrchr}}
{{dsc end}}

[[de:c/string/wide/wcsrchr]]
[[es:c/string/wide/wcsrchr]]
[[fr:c/string/wide/wcsrchr]]
[[it:c/string/wide/wcsrchr]]
[[ja:c/string/wide/wcsrchr]]
[[pt:c/string/wide/wcsrchr]]
[[ru:c/string/wide/wcsrchr]]
[[zh:c/string/wide/wcsrchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsspn</title>
    <ns>0</ns>
    <id>6096</id>
    <revision>
      <id>56863</id>
      <parentid>49171</parentid>
      <timestamp>2013-06-01T05:42:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1106">{{c/title| wcsspn}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
size_t wcsspn( const wchar_t* dest, const wchar_t* src );
}}

Returns the length of the maximum initial segment of the wide string pointed to by {{tt|dest}}, that consists of only the characters found in wide string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters from wide string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscspn}}
{{dsc inc | c/string/wide/dsc wcspbrk}}
{{dsc see cpp | cpp/string/wide/wcsspn}}
{{dsc end}}

[[de:c/string/wide/wcsspn]]
[[es:c/string/wide/wcsspn]]
[[fr:c/string/wide/wcsspn]]
[[it:c/string/wide/wcsspn]]
[[ja:c/string/wide/wcsspn]]
[[pt:c/string/wide/wcsspn]]
[[ru:c/string/wide/wcsspn]]
[[zh:c/string/wide/wcsspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsstr</title>
    <ns>0</ns>
    <id>6093</id>
    <revision>
      <id>65946</id>
      <parentid>56864</parentid>
      <timestamp>2013-10-16T12:13:56Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="1148">{{c/title| wcsstr}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
wchar_t* wcsstr( const wchar_t* dest, const wchar_t* src );
}}
{{dcl end}}

Finds the first occurrence of the wide string {{tt|src}} in the wide string pointed to by {{tt|dest}}. The terminating null characters are not compared.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to examine}}
{{par | src | pointer to the null-terminated wide string to search for}}
{{par end}}

===Return value===
Pointer to the first character of the found substring in {{tt|dest}}, or {{lc|NULL}} if no such substring is found. If {{tt|src}} points to an empty string, {{tt|dest}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcschr}}
{{dsc inc | c/string/wide/dsc wcsrchr}}
{{dsc see cpp | cpp/string/wide/wcsstr}}
{{dsc end}}

[[de:c/string/wide/wcsstr]]
[[es:c/string/wide/wcsstr]]
[[fr:c/string/wide/wcsstr]]
[[it:c/string/wide/wcsstr]]
[[ja:c/string/wide/wcsstr]]
[[pt:c/string/wide/wcsstr]]
[[ru:c/string/wide/wcsstr]]
[[zh:c/string/wide/wcsstr]]</text>
      <sha1>f6pinhoy5b3i74yhndr0g3tx5fekb7u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstod</title>
    <ns>0</ns>
    <id>6517</id>
    <redirect title="c/string/wide/wcstof" />
    <revision>
      <id>25689</id>
      <timestamp>2012-04-23T21:08:21Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/string/wide/wcstof]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstof</title>
    <ns>0</ns>
    <id>6083</id>
    <revision>
      <id>62630</id>
      <parentid>49173</parentid>
      <timestamp>2013-07-01T23:30:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1543">{{c/title| wcstof | wcstod | wcstold}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | since=c99 |
float       wcstof( const wchar_t* str, wchar_t** str_end );           
}}
{{dcl | 
double      wcstod( const wchar_t* str, wchar_t** str_end );
}}
{{dcl | since=c99 |
long double wcstold( const wchar_t* str, wchar_t** str_end );
}}
{{dcl end}}

Interprets a floating point value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float|wide}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to a wide character.}}
{{par end}}

===Return value===
Floating point value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|HUGE_VAL}}, {{lc|HUGE_VALF}} or {{lc|HUGE_VALL}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/wide/wcstof | wcstof | wcstod | wcstold}}
{{dsc end}}

[[de:c/string/wide/wcstof]]
[[es:c/string/wide/wcstof]]
[[fr:c/string/wide/wcstof]]
[[it:c/string/wide/wcstof]]
[[ja:c/string/wide/wcstof]]
[[pt:c/string/wide/wcstof]]
[[ru:c/string/wide/wcstof]]
[[zh:c/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstoimax</title>
    <ns>0</ns>
    <id>9912</id>
    <revision>
      <id>62631</id>
      <parentid>56867</parentid>
      <timestamp>2013-07-01T23:30:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1537">{{c/title| wcstoimax | wcstoumax}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | inttypes.h}}
{{dcl | since=c99 | 
intmax_t wcstoimax( const wchar_t *restrict nptr, 
                    wchar_t **restrict endptr, int base );
}}
{{dcl | since=c99 |
uintmax_t wcstoumax( const wchar_t *restrict nptr,
                     wchar_t **restrict endptr, int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a wide string pointed to by {{tt|nptr}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|endptr}} to point to the wide character past the last character interpreted. If {{tt|endptr}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | nptr | pointer to the null-terminated wide string to be interpreted}}
{{par | endptr | pointer to a pointer to a wide character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|INTMAX_MAX}}, {{lc|INTMAX_MIN}}, {{lc|UINTMAX_MAX}}, or {{c|0}} is returned, as appropriate. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{todo|example}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/byte/dsc strtoimax}}
{{dsc inc | c/string/wide/dsc wcstol}}
{{dsc inc | c/string/wide/dsc wcstoul}}
{{dsc see cpp | cpp/string/wide/wcstoimax | wcstoimax | wcstoumax}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstok</title>
    <ns>0</ns>
    <id>6092</id>
    <revision>
      <id>49175</id>
      <parentid>42367</parentid>
      <timestamp>2013-06-01T01:42:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1873">{{c/title| wcstok}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | 1=
wchar_t* wcstok( wchar_t* str, const wchar_t* delim );
}}
{{dcl end}}

Finds the next token in a null-terminated wide string pointed to by {{tt|str}}. The separator characters are identified by null-terminated wide string pointed to by {{tt|delim}}.

If {{c|str !{{=}} NULL}}, the function searches for the first wide character which is ''not'' separator. This character is the ''beginning of the token''. Then the function searches for the first separator character. This character is the ''end of the token''. Function terminates and returns {{lc|NULL}} if end of {{tt|str}} is encountered before ''end of the token'' is found. Otherwise, a pointer to ''end of the token'' is saved in a static location for subsequent invocations. This character is then replaced by a NULL-character and the function returns a pointer to the ''beginning of the token''.

If {{c|str {{==}} NULL}}, the function continues from where it left in previous invocation. The behavior is the same as if the previously stored pointer is passed as {{c|str}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to tokenize}}
{{par | delim | pointer to the null-terminated wide string identifying delimiters}}
{{par end}}

===Return value===
Pointer to the beginning of a token if the end of examined string has not been encountered. Otherwise returns {{lc|NULL}}&gt;

===Note===
The function is not thread safe.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/wide/wcstok}}
{{dsc end}}

[[de:c/string/wide/wcstok]]
[[es:c/string/wide/wcstok]]
[[fr:c/string/wide/wcstok]]
[[it:c/string/wide/wcstok]]
[[ja:c/string/wide/wcstok]]
[[pt:c/string/wide/wcstok]]
[[ru:c/string/wide/wcstok]]
[[zh:c/string/wide/wcstok]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstol</title>
    <ns>0</ns>
    <id>6086</id>
    <revision>
      <id>62632</id>
      <parentid>56868</parentid>
      <timestamp>2013-07-01T23:30:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1555">{{c/title| wcstol | wcstoll}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | 
long      wcstol( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl | since=c99 |
long long wcstoll( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl end}}

Interprets an integer value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to wide character}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|LONG_MAX}}, {{lc|LONG_MIN}}, {{lc|LLONG_MAX}} or {{lc|LLONG_MIN}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcstoul}}
{{dsc see cpp | cpp/string/wide/wcstol | wcstol | wcstoll}}
{{dsc end}}

[[de:c/string/wide/wcstol]]
[[es:c/string/wide/wcstol]]
[[fr:c/string/wide/wcstol]]
[[it:c/string/wide/wcstol]]
[[ja:c/string/wide/wcstol]]
[[pt:c/string/wide/wcstol]]
[[ru:c/string/wide/wcstol]]
[[zh:c/string/wide/wcstol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstold</title>
    <ns>0</ns>
    <id>6516</id>
    <redirect title="c/string/wide/wcstof" />
    <revision>
      <id>25688</id>
      <timestamp>2012-04-23T21:08:17Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[c/string/wide/wcstof]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[c/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcstoul</title>
    <ns>0</ns>
    <id>6085</id>
    <revision>
      <id>62633</id>
      <parentid>56869</parentid>
      <timestamp>2013-07-01T23:30:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1576">{{c/title| wcstoul | wcstoull}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl | 
unsigned long      wcstoul( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl | since=c99 |
unsigned long long wcstoull( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to a wide character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|ULONG_MAX}} or {{lc|ULLONG_MAX}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcstol}}
{{dsc see cpp | cpp/string/wide/wcstoul | wcstoul | wcstoull}}
{{dsc end}}

[[de:c/string/wide/wcstoul]]
[[es:c/string/wide/wcstoul]]
[[fr:c/string/wide/wcstoul]]
[[it:c/string/wide/wcstoul]]
[[ja:c/string/wide/wcstoul]]
[[pt:c/string/wide/wcstoul]]
[[ru:c/string/wide/wcstoul]]
[[zh:c/string/wide/wcstoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wcsxfrm</title>
    <ns>0</ns>
    <id>6078</id>
    <revision>
      <id>49178</id>
      <parentid>42345</parentid>
      <timestamp>2013-06-01T01:43:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1265">{{c/title|wcsxfrm}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
size_t strxfrm( const wchar_t* dest, const wchar_t* src, size_t count );
}}
{{dcl end}}

Transforms the null-terminated wide string pointed to by {{tt|src}} according to the current locale and copies the first {{tt|count}} wide characters of the transformed string to destination, returning its length.

Alternatively, the function can be used to only retrieve the length, by specifying a null pointer for {{tt|dest}} and {{c|0}} for {{tt|count}}.

===Parameters===
{{par begin}}
{{par| dest | pointer to the character string to copy the transformed string to}}
{{par| src| pointer to the null-terminated character string to transform}}
{{par| count | maximum number of characters to transform}}
{{par end}}

===Return value===
The length of the transformed wide string, not including the terminating null-character.

===Example===
{{example
 | 1=
 | 2=
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/string/wide/wcsxfrm}}
{{dsc end}}

[[de:c/string/wide/wcsxfrm]]
[[es:c/string/wide/wcsxfrm]]
[[fr:c/string/wide/wcsxfrm]]
[[it:c/string/wide/wcsxfrm]]
[[ja:c/string/wide/wcsxfrm]]
[[pt:c/string/wide/wcsxfrm]]
[[ru:c/string/wide/wcsxfrm]]
[[zh:c/string/wide/wcsxfrm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wctrans</title>
    <ns>0</ns>
    <id>6074</id>
    <revision>
      <id>56872</id>
      <parentid>49179</parentid>
      <timestamp>2013-06-01T05:42:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1340">{{c/title|wctrans}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
wctrans_t wctrans( const char* str );
}}

Constructs a value of type {{c|wctrans_t}} that describes a LC_CTYPE category of wide character mapping. It may be one of the standard mappings, or a locale-specific mapping, such as {{tt|&quot;tojhira&quot;}} or {{tt|&quot;tojkana&quot;}}.

===Parameters===
{{par begin}}
{{par | str | C string holding the name of the desired mapping.
The following values of {{tt|str}} are supported in all C locales:
{{dsc begin}}
{{dsc hitem | Value of {{tt|str}}  | Effect  }}
{{dsc | {{tt|&quot;toupper&quot;}} | identifies the mapping used by {{lc|towupper}} }}
{{dsc | {{tt|&quot;tolower&quot;}} | identifies the mapping used by {{lc|towlower}} }}
{{dsc end}}
}}
{{dsc end}}

===Return value===
{{c|wctrans_t}} object suitable for use with {{lc|towctrans}} to map wide characters according to the named mapping of the current C locale or zero if {{tt|str}} does not name a mapping supported by the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc towctrans}}
{{dsc see cpp | cpp/string/wide/wctrans}}
{{dsc end}}

[[de:c/string/wide/wctrans]]
[[es:c/string/wide/wctrans]]
[[fr:c/string/wide/wctrans]]
[[it:c/string/wide/wctrans]]
[[ja:c/string/wide/wctrans]]
[[pt:c/string/wide/wctrans]]
[[ru:c/string/wide/wctrans]]
[[zh:c/string/wide/wctrans]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wctype</title>
    <ns>0</ns>
    <id>6061</id>
    <revision>
      <id>56873</id>
      <parentid>49180</parentid>
      <timestamp>2013-06-01T05:42:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2031">{{c/title|wctype}}
{{c/string/wide/navbar}}
{{ddcl | header=wctype.h |
wctype_t wctype( const char* str );
}}

Constructs a value of type {{c|wctype_t}} that describes a LC_CTYPE category of wide character classification. It may be one of the standard classification categories, or a locale-specific category, such as {{tt|&quot;jkanji&quot;}}.

===Parameters===
{{par begin}}
{{par | str | C string holding the name of the desired category}}
{{par end}}

The following values of {{tt|str}} are supported in all C locales:
{{dsc begin}}
{{dsc hitem | value of {{tt|str}}  | effect  }}
{{dsc | {{tt|&quot;alnum&quot;}} | identifies the category used by {{lc|iswalnum}} }}
{{dsc | {{tt|&quot;alpha&quot;}} | identifies the category used by {{lc|iswalpha}} }}
{{dsc | {{tt|&quot;blank&quot;}} | identifies the category used by {{lc|iswblank}} {{mark c99}}}}
{{dsc | {{tt|&quot;cntrl&quot;}} | identifies the category used by {{lc|iswcntrl}} }}
{{dsc | {{tt|&quot;digit&quot;}} | identifies the category used by {{lc|iswdigit}} }}
{{dsc | {{tt|&quot;graph&quot;}} | identifies the category used by {{lc|iswgraph}} }}
{{dsc | {{tt|&quot;lower&quot;}} | identifies the category used by {{lc|iswlower}} }}
{{dsc | {{tt|&quot;print&quot;}} | identifies the category used by {{lc|iswprint}} }}
{{dsc | {{tt|&quot;space&quot;}} | identifies the category used by {{lc|iswspace}} }}
{{dsc | {{tt|&quot;upper&quot;}} | identifies the category used by {{lc|iswupper}} }}
{{dsc | {{tt|&quot;xdigit&quot;}} | identifies the category used by {{lc|iswxdigit}} }}
{{dsc end}}

===Return value===
{{c|wctype_t}} object suitable for use with {{lc|iswctype}} to classify wide characters according to the named category of the current C locale or zero if {{tt|str}} does not name a category supported by the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc iswctype}}
{{dsc see cpp | cpp/string/wide/wctype}}
{{dsc end}}

[[de:c/string/wide/wctype]]
[[es:c/string/wide/wctype]]
[[fr:c/string/wide/wctype]]
[[it:c/string/wide/wctype]]
[[ja:c/string/wide/wctype]]
[[pt:c/string/wide/wctype]]
[[ru:c/string/wide/wctype]]
[[zh:c/string/wide/wctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wmemchr</title>
    <ns>0</ns>
    <id>6088</id>
    <revision>
      <id>56874</id>
      <parentid>49181</parentid>
      <timestamp>2013-06-01T05:42:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1021">{{c/title|wmemchr}}
{{c/string/wide/navbar}}
{{dcl begin}}
{{dcl header | wchar.h}}
{{dcl |
wchar_t* wmemchr( const wchar_t* ptr, wchar_t ch, size_t count );
}}
{{dcl end}}

Locates the first occurrence of wide character {{tt|ch}} in the initial {{tt|count}} wide characters of the object pointed to by {{tt|ptr}}. 

===Parameters===
{{par begin}}
{{par | ptr | pointer to the object to be examined}}
{{par | ch | wide character to search for}}
{{par | count | number of characters to examine}}
{{par end}}

===Return value===
Pointer to the location of the character, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcschr}}
{{dsc see cpp | cpp/string/wide/wmemchr}}
{{dsc end}}

[[de:c/string/wide/wmemchr]]
[[es:c/string/wide/wmemchr]]
[[fr:c/string/wide/wmemchr]]
[[it:c/string/wide/wmemchr]]
[[ja:c/string/wide/wmemchr]]
[[pt:c/string/wide/wmemchr]]
[[ru:c/string/wide/wmemchr]]
[[zh:c/string/wide/wmemchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wmemcmp</title>
    <ns>0</ns>
    <id>6089</id>
    <revision>
      <id>65858</id>
      <parentid>56877</parentid>
      <timestamp>2013-10-11T05:54:11Z</timestamp>
      <contributor>
        <ip>218.101.54.25</ip>
      </contributor>
      <comment>Corrected &quot;count&quot; parameter</comment>
      <text xml:space="preserve" bytes="1089">{{c/title|wmemcmp}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
int wmemcmp( const wchar_t* lhs, const wchar_t* rhs, size_t count );
}}

Compares the first {{tt|count}} wide characters of the objects pointed to by {{tt|lhs}} and {{tt|rhs}}. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the memory buffers to compare}}
{{par | count | number of wide characters to examine}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wcscmp}}
{{dsc inc | c/string/wide/dsc wcsncmp}}
{{dsc see cpp | cpp/string/wide/wmemcmp}}
{{dsc end}}

[[de:c/string/wide/wmemcmp]]
[[es:c/string/wide/wmemcmp]]
[[fr:c/string/wide/wmemcmp]]
[[it:c/string/wide/wmemcmp]]
[[ja:c/string/wide/wmemcmp]]
[[pt:c/string/wide/wmemcmp]]
[[ru:c/string/wide/wmemcmp]]
[[zh:c/string/wide/wmemcmp]]</text>
      <sha1>fo19xggs7124clysmhvkhu587dvifa0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wmemcpy</title>
    <ns>0</ns>
    <id>6091</id>
    <revision>
      <id>67380</id>
      <parentid>56878</parentid>
      <timestamp>2014-02-07T04:23:22Z</timestamp>
      <contributor>
        <ip>131.107.192.139</ip>
      </contributor>
      <text xml:space="preserve" bytes="968">{{c/title|wmemcpy}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t* wmemcpy( wchar_t* dest, const wchar_t* src, size_t count );
}}

Copies {{tt|count}} wide characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. If the objects overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wmemmove}}
{{dsc see cpp | cpp/string/wide/wmemcpy}}
{{dsc end}}

[[de:c/string/wide/wmemcpy]]
[[es:c/string/wide/wmemcpy]]
[[fr:c/string/wide/wmemcpy]]
[[it:c/string/wide/wmemcpy]]
[[ja:c/string/wide/wmemcpy]]
[[pt:c/string/wide/wmemcpy]]
[[ru:c/string/wide/wmemcpy]]
[[zh:c/string/wide/wmemcpy]]</text>
      <sha1>mrtbrxixu56djmqo7tqbfat7kee0di5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wmemmove</title>
    <ns>0</ns>
    <id>6090</id>
    <revision>
      <id>56879</id>
      <parentid>49184</parentid>
      <timestamp>2013-06-01T05:42:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1094">{{c/title|wmemmove}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t* wmemmove( wchar_t* dest, const wchar_t* src, size_t count );
}}

Copies {{tt|count}} wide characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. The objects may overlap: copying takes place as if the characters were copied to a temporary character array and then the characters were copied from the array to {{tt|dest}}. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wmemcpy}}
{{dsc see cpp | cpp/string/wide/wmemmove}}
{{dsc end}}

[[de:c/string/wide/wmemmove]]
[[es:c/string/wide/wmemmove]]
[[fr:c/string/wide/wmemmove]]
[[it:c/string/wide/wmemmove]]
[[ja:c/string/wide/wmemmove]]
[[pt:c/string/wide/wmemmove]]
[[ru:c/string/wide/wmemmove]]
[[zh:c/string/wide/wmemmove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/string/wide/wmemset</title>
    <ns>0</ns>
    <id>6087</id>
    <revision>
      <id>56882</id>
      <parentid>49185</parentid>
      <timestamp>2013-06-01T05:42:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="858">{{c/title|wmemset}}
{{c/string/wide/navbar}}
{{ddcl | header=wchar.h |
wchar_t* wmemset( wchar_t* dest, wchar_t ch, size_t count );
}}

Copies wide character {{tt|ch}} into each of the first {{tt|count}} wide characters of the object pointed to by {{tt|dest}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the object to fill}}
{{par | ch | fill byte}}
{{par | count | number of bytes to fill}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | c/string/wide/dsc wmemcpy}}
{{dsc see cpp | cpp/string/wide/wmemset}}
{{dsc end}}

[[de:c/string/wide/wmemset]]
[[es:c/string/wide/wmemset]]
[[fr:c/string/wide/wmemset]]
[[it:c/string/wide/wmemset]]
[[ja:c/string/wide/wmemset]]
[[pt:c/string/wide/wmemset]]
[[ru:c/string/wide/wmemset]]
[[zh:c/string/wide/wmemset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread</title>
    <ns>0</ns>
    <id>6526</id>
    <revision>
      <id>71033</id>
      <parentid>71010</parentid>
      <timestamp>2014-06-04T20:16:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="2222">{{title|Thread support library}}
{{c/thread/navbar}}

If the macro constant {{tt|__STDC_NO_THREADS__}}{{mark c11}} is defined by the compiler, the header {{tt|&lt;threads.h&gt;}} and all of the names listed here are not provided.

===Threads===
{{dsc begin}}
{{dsc header | threads.h}}
{{dsc inc | c/thread/dsc thrd_t}}
{{dsc inc | c/thread/dsc thrd_create}}
{{dsc inc | c/thread/dsc thrd_equal}}
{{dsc inc | c/thread/dsc thrd_current}}
{{dsc inc | c/thread/dsc thrd_sleep}}
{{dsc inc | c/thread/dsc thrd_yield}}
{{dsc inc | c/thread/dsc thrd_exit}}
{{dsc inc | c/thread/dsc thrd_detach}}
{{dsc inc | c/thread/dsc thrd_join}}
{{dsc inc | c/thread/dsc thrd_errors}}
{{dsc inc | c/thread/dsc thrd_start_t}}
{{dsc end}}

===Mutual exclusion===
{{dsc begin}}
{{dsc header | threads.h}}
{{dsc inc | c/thread/dsc mtx_t}}
{{dsc inc | c/thread/dsc mtx_init}}
{{dsc inc | c/thread/dsc mtx_lock}}
{{dsc inc | c/thread/dsc mtx_timedlock}}
{{dsc inc | c/thread/dsc mtx_trylock}}
{{dsc inc | c/thread/dsc mtx_unlock}}
{{dsc inc | c/thread/dsc mtx_destroy}}
{{dsc inc | c/thread/dsc mtx_types}}
{{dsc h2 | Call once}}
{{dsc inc | c/thread/dsc once_flag}}
{{dsc inc | c/thread/dsc ONCE_FLAG_INIT}}
{{dsc inc | c/thread/dsc call_once}}
{{dsc end}}

===Condition variables===
{{dsc begin}}
{{dsc header | threads.h}}
{{dsc | {{ttb|cnd_t}} | condition variable identifier | notes={{mark c11}}}}
{{dsc inc | c/thread/dsc cnd_init}}
{{dsc inc | c/thread/dsc cnd_signal}}
{{dsc inc | c/thread/dsc cnd_broadcast}}
{{dsc inc | c/thread/dsc cnd_wait}}
{{dsc inc | c/thread/dsc cnd_timedwait}}
{{dsc inc | c/thread/dsc cnd_destroy}}
{{dsc end}}

===Thread-local storage===
{{dsc begin}}
{{dsc header | threads.h}}
{{dsc inc | c/thread/dsc thread_local}}
{{dsc inc | c/thread/dsc tss_t}}
{{dsc inc | c/thread/dsc TSS_DTOR_ITERATIONS}}
{{dsc inc | c/thread/dsc tss_dtor_t}}
{{dsc inc | c/thread/dsc tss_create}}
{{dsc inc | c/thread/dsc tss_get}}
{{dsc inc | c/thread/dsc tss_set}}
{{dsc inc | c/thread/dsc tss_delete}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/thread |Thread support library}}
{{dsc end}}

[[de:c/thread]]
[[es:c/thread]]
[[fr:c/thread]]
[[it:c/thread]]
[[ja:c/thread]]
[[pt:c/thread]]
[[ru:c/thread]]
[[zh:c/thread]]</text>
      <sha1>55hoae4gzw4p4dx6ctvyzawfb7zcs02</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/ONCE FLAG INIT</title>
    <ns>0</ns>
    <id>9142</id>
    <revision>
      <id>63536</id>
      <parentid>56886</parentid>
      <timestamp>2013-07-10T01:35:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="543">{{c/title|thread_local}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
#define ONCE_FLAG_INIT /* unspecified */
}}

Expands to a value that can be used to initialize an object of type {{lc|once_flag}}.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc call_once}}
{{dsc end}}

[[de:c/thread/ONCE FLAG INIT]]
[[es:c/thread/ONCE FLAG INIT]]
[[fr:c/thread/ONCE FLAG INIT]]
[[it:c/thread/ONCE FLAG INIT]]
[[ja:c/thread/ONCE FLAG INIT]]
[[pt:c/thread/ONCE FLAG INIT]]
[[ru:c/thread/ONCE FLAG INIT]]
[[zh:c/thread/ONCE FLAG INIT]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/TSS DTOR ITERATIONS</title>
    <ns>0</ns>
    <id>9143</id>
    <revision>
      <id>63537</id>
      <parentid>42260</parentid>
      <timestamp>2013-07-10T01:35:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="571">{{c/title|TSS_DTOR_ITERATIONS}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
#define TSS_DTOR_ITERATIONS /* unspecified */
}}

Expands to a positive integral expression defining the maximum number of times a destructor for thread-local storage pointer will be called.

[[de:c/thread/TSS DTOR ITERATIONS]]
[[es:c/thread/TSS DTOR ITERATIONS]]
[[fr:c/thread/TSS DTOR ITERATIONS]]
[[it:c/thread/TSS DTOR ITERATIONS]]
[[ja:c/thread/TSS DTOR ITERATIONS]]
[[pt:c/thread/TSS DTOR ITERATIONS]]
[[ru:c/thread/TSS DTOR ITERATIONS]]
[[zh:c/thread/TSS DTOR ITERATIONS]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/call once</title>
    <ns>0</ns>
    <id>9196</id>
    <revision>
      <id>63538</id>
      <parentid>49188</parentid>
      <timestamp>2013-07-10T01:36:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="784">{{c/title|call_once}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void call_once( once_flag* flag, void (*func)(void) );
}}

Calls function {{tt|func}} exactly once, even if invoked from several threads.

The completion of the function {{tt|func}} synchronizes with all previous or subsequent calls to {{tt|call_once}} with the same {{tt|flag}} variable.

===Parameters===
{{par begin}}
{{par | flag | pointer to an object that is used to ensure {{tt|func}} is called only once}}
{{par | func | the function to execute}}
{{par end}}

===Return value===
(none)

[[de:c/thread/call once]]
[[es:c/thread/call once]]
[[fr:c/thread/call once]]
[[it:c/thread/call once]]
[[ja:c/thread/call once]]
[[pt:c/thread/call once]]
[[ru:c/thread/call once]]
[[zh:c/thread/call once]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd broadcast</title>
    <ns>0</ns>
    <id>9198</id>
    <revision>
      <id>63539</id>
      <parentid>56887</parentid>
      <timestamp>2013-07-10T01:36:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="783">{{c/title|cnd_broadcast}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int cnd_broadcast( cnd_t *cond );
}}

Unblocks all thread that currently wait on condition variable pointed to by {{tt|cond}}. If no threads are blocked, does nothing and returns {{tt|thrd_success}}.

===Parameters===
{{par begin}}
{{par | cond | pointer to a condition variable}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc cnd_signal}}
{{dsc end}}

[[de:c/thread/cnd broadcast]]
[[es:c/thread/cnd broadcast]]
[[fr:c/thread/cnd broadcast]]
[[it:c/thread/cnd broadcast]]
[[ja:c/thread/cnd broadcast]]
[[pt:c/thread/cnd broadcast]]
[[ru:c/thread/cnd broadcast]]
[[zh:c/thread/cnd broadcast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd destroy</title>
    <ns>0</ns>
    <id>9194</id>
    <revision>
      <id>63540</id>
      <parentid>49190</parentid>
      <timestamp>2013-07-10T01:36:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="610">{{c/title|cnd_destroy}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void cnd_destroy( cnd_t* cond );
}}

Destroys the condition variable pointed to by {{tt|cond}}.

If there are threads waiting on {{tt|cond}}, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | cond | pointer to the condition variable to destroy}}
{{par end}}

===Return value===
(none)

[[de:c/thread/cnd destroy]]
[[es:c/thread/cnd destroy]]
[[fr:c/thread/cnd destroy]]
[[it:c/thread/cnd destroy]]
[[ja:c/thread/cnd destroy]]
[[pt:c/thread/cnd destroy]]
[[ru:c/thread/cnd destroy]]
[[zh:c/thread/cnd destroy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd init</title>
    <ns>0</ns>
    <id>9197</id>
    <revision>
      <id>63541</id>
      <parentid>49191</parentid>
      <timestamp>2013-07-10T01:36:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="798">{{c/title|cnd_init}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int cnd_init( cnd_t* cond );
}}
Initializes new condition variable. The object pointed to by {{tt|cond}} will be set to value that identifies the condition variable.

===Parameters===
{{par begin}}
{{par | cond | pointer to a variable to store identifier of the condition variable to}}
{{par end}}

===Return value===
{{lc|thrd_success}} if the condition variable was successfully created. Otherwise returns {{lc|thrd_nomem}} if there was insufficient amount of memory or {{tt|thrd_error}} if another error occurred.

[[de:c/thread/cnd init]]
[[es:c/thread/cnd init]]
[[fr:c/thread/cnd init]]
[[it:c/thread/cnd init]]
[[ja:c/thread/cnd init]]
[[pt:c/thread/cnd init]]
[[ru:c/thread/cnd init]]
[[zh:c/thread/cnd init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd signal</title>
    <ns>0</ns>
    <id>9199</id>
    <revision>
      <id>63542</id>
      <parentid>56888</parentid>
      <timestamp>2013-07-10T01:36:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="757">{{c/title|cnd_signal}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int cnd_signal( cnd_t *cond );
}}

Unblocks one thread that currently waits on condition variable pointed to by {{tt|cond}}. If no threads are blocked, does nothing and returns {{tt|thrd_success}}.

===Parameters===
{{par begin}}
{{par | cond | pointer to a condition variable}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc cnd_broadcast}}
{{dsc end}}

[[de:c/thread/cnd signal]]
[[es:c/thread/cnd signal]]
[[fr:c/thread/cnd signal]]
[[it:c/thread/cnd signal]]
[[ja:c/thread/cnd signal]]
[[pt:c/thread/cnd signal]]
[[ru:c/thread/cnd signal]]
[[zh:c/thread/cnd signal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd timedwait</title>
    <ns>0</ns>
    <id>9206</id>
    <revision>
      <id>63543</id>
      <parentid>56891</parentid>
      <timestamp>2013-07-10T01:36:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1414">{{c/title|cnd_timedwait}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int cnd_timedwait( cnd_t* restrict cond, mtx_t* restrict mutex,
                   const struct timespec* restrict time_point );
}}

Atomically locks the mutex pointed to by {{tt|mutex}} and blocks on the condition variable pointed to by {{tt|cond}} until the thread is signalled by {{lc|cnd_signal}} or {{lc|cnd_broadcast}}, or until the {{c|TIME_UTC}} based time point pointed to by {{tt|time_point}} has been reached. The mutex is locked again before the function returns.

The behavior is undefined if the mutex is not already locked by the calling thread.

===Parameters===
{{par begin}}
{{par | cond | pointer to the condition variable to block on}}
{{par | mutex | pointer to the mutex to unlock for the duration of the block}}
{{par | duration | pointer to a object specifying timeout time to wait until}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{c|thrd_timedout}} if the timeout time has been reached before the mutex is locked, or  {{lc|thrd_error}} if an error occurred.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc cnd_wait}}
{{dsc end}}

[[de:c/thread/cnd timedwait]]
[[es:c/thread/cnd timedwait]]
[[fr:c/thread/cnd timedwait]]
[[it:c/thread/cnd timedwait]]
[[ja:c/thread/cnd timedwait]]
[[pt:c/thread/cnd timedwait]]
[[ru:c/thread/cnd timedwait]]
[[zh:c/thread/cnd timedwait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/cnd wait</title>
    <ns>0</ns>
    <id>9205</id>
    <revision>
      <id>63544</id>
      <parentid>56892</parentid>
      <timestamp>2013-07-10T01:36:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1015">{{c/title|cnd_wait}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int cnd_wait( cnd_t* cond, mtx_t* mutex );
}}
Atomically unlocks the mutex pointed to by {{tt|mutex}} and blocks on the condition variable pointed to by {{tt|cond}} until the thread is signalled by {{lc|cnd_signal}} or {{lc|cnd_broadcast}}. The mutex is locked again before the function returns.

The behavior is undefined if the mutex is not already locked by the calling thread.

===Parameters===
{{par begin}}
{{par | cond | pointer to the condition variable to block on}}
{{par | mutex | pointer to the mutex to unlock for the duration of the block}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc cnd_timedwait}}
{{dsc end}}

[[de:c/thread/cnd wait]]
[[es:c/thread/cnd wait]]
[[fr:c/thread/cnd wait]]
[[it:c/thread/cnd wait]]
[[ja:c/thread/cnd wait]]
[[pt:c/thread/cnd wait]]
[[ru:c/thread/cnd wait]]
[[zh:c/thread/cnd wait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx destroy</title>
    <ns>0</ns>
    <id>9195</id>
    <revision>
      <id>64070</id>
      <parentid>63545</parentid>
      <timestamp>2013-08-08T08:20:56Z</timestamp>
      <contributor>
        <ip>193.46.209.2</ip>
      </contributor>
      <comment>Fixed parameter name in description</comment>
      <text xml:space="preserve" bytes="588">{{c/title|mtx_destroy}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void mtx_destroy( mtx_t *mutex );
}}

Destroys the mutex pointed to by {{tt|mutex}}.

If there are threads waiting on {{tt|mutex}}, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to destroy}}
{{par end}}

===Return value===
(none)

[[de:c/thread/mtx destroy]]
[[es:c/thread/mtx destroy]]
[[fr:c/thread/mtx destroy]]
[[it:c/thread/mtx destroy]]
[[ja:c/thread/mtx destroy]]
[[pt:c/thread/mtx destroy]]
[[ru:c/thread/mtx destroy]]
[[zh:c/thread/mtx destroy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx init</title>
    <ns>0</ns>
    <id>9200</id>
    <revision>
      <id>63546</id>
      <parentid>49196</parentid>
      <timestamp>2013-07-10T01:36:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1035">{{c/title|mtx_init}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int mtx_init( mtx_t* mutex, int type );
}}

Creates a new mutex object with {{tt|type}}. The object pointed to by {{tt|mutex}} is set to an identifier of the newly created mutex.

{{tt|type}} must have one of the following values:

*{{lc|mtx_plain}} - a simple, non-recursive mutex is created.
*{{lc|mtx_timed}} - a non-recursive mutex, that supports timeout, is created.
*{{c|mtx_plain {{!}} mtx_recursive}} - a recursive mutex is created.
*{{c|mtx_timed {{!}} mtx_recursive}} - a recursive mutex, that supports timeout, is created.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to initialize}}
{{par | type | the type of the mutex}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

[[de:c/thread/mtx init]]
[[es:c/thread/mtx init]]
[[fr:c/thread/mtx init]]
[[it:c/thread/mtx init]]
[[ja:c/thread/mtx init]]
[[pt:c/thread/mtx init]]
[[ru:c/thread/mtx init]]
[[zh:c/thread/mtx init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx lock</title>
    <ns>0</ns>
    <id>9201</id>
    <revision>
      <id>63547</id>
      <parentid>56893</parentid>
      <timestamp>2013-07-10T01:36:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="840">{{c/title|mtx_lock}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int mtx_lock( mtx_t* mutex );
}}

Blocks the current thread until the mutex pointed to by {{tt|mutex}} is locked.

The behavior is undefined if the current thread has already locked the mutex and the mutex is not recursive.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to lock}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc mtx_timedlock}}
{{dsc inc | c/thread/dsc mtx_trylock}}
{{dsc inc | c/thread/dsc mtx_unlock}}
{{dsc end}}

[[de:c/thread/mtx lock]]
[[es:c/thread/mtx lock]]
[[fr:c/thread/mtx lock]]
[[it:c/thread/mtx lock]]
[[ja:c/thread/mtx lock]]
[[pt:c/thread/mtx lock]]
[[ru:c/thread/mtx lock]]
[[zh:c/thread/mtx lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx timedlock</title>
    <ns>0</ns>
    <id>9202</id>
    <revision>
      <id>63548</id>
      <parentid>56896</parentid>
      <timestamp>2013-07-10T01:36:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1277">{{c/title|mtx_timedlock}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int mtx_timedlock( mtx_t *restrict mutex,
                   const struct timespec *restrict time_point );
}}

Blocks the current thread until the mutex pointed to by {{tt|mutex}} is locked or until the {{c|TIME_UTC}} based time point pointed to by {{tt|time_point}} has been reached.

The behavior is undefined if the current thread has already locked the mutex and the mutex is not recursive.

The behavior is undefined if the mutex does not support timeout.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to lock}}
{{par | time_point | pointer to the timeout time to wait until}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{c|thrd_timedout}} if the timeout time has been reached before the mutex is locked, {{lc|thrd_error}} if an error occurrs.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc mtx_lock}}
{{dsc inc | c/thread/dsc mtx_trylock}}
{{dsc inc | c/thread/dsc mtx_unlock}}
{{dsc end}}

[[de:c/thread/mtx timedlock]]
[[es:c/thread/mtx timedlock]]
[[fr:c/thread/mtx timedlock]]
[[it:c/thread/mtx timedlock]]
[[ja:c/thread/mtx timedlock]]
[[pt:c/thread/mtx timedlock]]
[[ru:c/thread/mtx timedlock]]
[[zh:c/thread/mtx timedlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx trylock</title>
    <ns>0</ns>
    <id>9203</id>
    <revision>
      <id>63549</id>
      <parentid>56897</parentid>
      <timestamp>2013-07-10T01:36:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="810">{{c/title|mtx_trylock}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int mtx_trylock( mtx_t *mutex );
}}

Tries to lock the mutex pointed to by {{tt|mutex}} without blocking.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to lock}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_busy}} if the mutex has already been locked, {{lc|thrd_error}} if an error occurrs.
===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc mtx_lock}}
{{dsc inc | c/thread/dsc mtx_timedlock}}
{{dsc inc | c/thread/dsc mtx_unlock}}
{{dsc end}}

[[de:c/thread/mtx trylock]]
[[es:c/thread/mtx trylock]]
[[fr:c/thread/mtx trylock]]
[[it:c/thread/mtx trylock]]
[[ja:c/thread/mtx trylock]]
[[pt:c/thread/mtx trylock]]
[[ru:c/thread/mtx trylock]]
[[zh:c/thread/mtx trylock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx types</title>
    <ns>0</ns>
    <id>9162</id>
    <revision>
      <id>63550</id>
      <parentid>56898</parentid>
      <timestamp>2013-07-10T01:36:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="784">{{c/title|mtx_plain|mtx_recursive|mtx_timed}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 | 1=
enum {
    mtx_plain = /* unspecified */,
    mtx_recursive = /* unspecified */,
    mtx_timed = /* unspecified */
};
}}

When passed to {{lc|mtx_init}}, identifies the type of a mutex to create.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|mtx_plain}} | plain mutex}}
{{dsc | {{tt|mtx_recursive}} | recursive mutex}}
{{dsc | {{tt|mtx_timed}} | timed mutex}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc | c/thread/dsc mtx_init}}
{{dsc end}}

[[de:c/thread/mtx types]]
[[es:c/thread/mtx types]]
[[fr:c/thread/mtx types]]
[[it:c/thread/mtx types]]
[[ja:c/thread/mtx types]]
[[pt:c/thread/mtx types]]
[[ru:c/thread/mtx types]]
[[zh:c/thread/mtx types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/mtx unlock</title>
    <ns>0</ns>
    <id>9204</id>
    <revision>
      <id>63551</id>
      <parentid>56901</parentid>
      <timestamp>2013-07-10T01:36:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="794">{{c/title|mtx_unlock}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int mtx_unlock( mtx_t *mutex );
}}

Unlocks the mutex pointed to by {{tt|mutex}}. 

The behavior is undefined if the mutex is not locked by the calling thread.

===Parameters===
{{par begin}}
{{par | mutex | pointer to the mutex to unlock}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc mtx_lock}}
{{dsc inc | c/thread/dsc mtx_timedlock}}
{{dsc inc | c/thread/dsc mtx_trylock}}
{{dsc end}}

[[de:c/thread/mtx unlock]]
[[es:c/thread/mtx unlock]]
[[fr:c/thread/mtx unlock]]
[[it:c/thread/mtx unlock]]
[[ja:c/thread/mtx unlock]]
[[pt:c/thread/mtx unlock]]
[[ru:c/thread/mtx unlock]]
[[zh:c/thread/mtx unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd create</title>
    <ns>0</ns>
    <id>9144</id>
    <revision>
      <id>71995</id>
      <parentid>63552</parentid>
      <timestamp>2014-07-07T09:34:53Z</timestamp>
      <contributor>
        <ip>89.189.9.250</ip>
      </contributor>
      <comment>Corrected the title</comment>
      <text xml:space="preserve" bytes="1317">{{c/title|thrd_create}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int thrd_create( thrd_t *thr, thrd_start_t func, void *arg );
}}

Creates a new thread executing the function {{tt|func}}. The function is invoked as {{c|func(arg)}}.

If successful, the object pointed to by {{tt|thr}} is set to the identifier of the new thread.

The completion of this function synchronizes with the beginning of the thread.

===Parameters===
{{par begin}}
{{par | thr | pointer to memory location to put the identifier of the new thread}}
{{par | func | function to execute}}
{{par | arg | argument to pass to the function}}
{{par end}}

===Return value===
{{lc|thrd_success}} if the creation of the new thread was successful. Otherwise returns {{lc|thrd_nomem}} if there was insufficient amount of memory or {{tt|thrd_error}} if another error occurred.

===Notes===
The thread identifies may be reused for new threads once the thread has finished and joined or detached.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_detach}}
{{dsc inc | c/thread/dsc thrd_join}}
{{dsc end}}

[[de:c/thread/thrd create]]
[[es:c/thread/thrd create]]
[[fr:c/thread/thrd create]]
[[it:c/thread/thrd create]]
[[ja:c/thread/thrd create]]
[[pt:c/thread/thrd create]]
[[ru:c/thread/thrd create]]
[[zh:c/thread/thrd create]]</text>
      <sha1>jwsb2mch2qocw8grxkat8ajrcd15opm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd current</title>
    <ns>0</ns>
    <id>9146</id>
    <revision>
      <id>63553</id>
      <parentid>42132</parentid>
      <timestamp>2013-07-10T01:36:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="475">{{c/title|thread_current}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
thrd_t thrd_current();
}}

Returns the identifier of the calling thread.

===Parameters===
(none)

===Return value===
The identifier of the calling thread.

[[de:c/thread/thrd current]]
[[es:c/thread/thrd current]]
[[fr:c/thread/thrd current]]
[[it:c/thread/thrd current]]
[[ja:c/thread/thrd current]]
[[pt:c/thread/thrd current]]
[[ru:c/thread/thrd current]]
[[zh:c/thread/thrd current]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd detach</title>
    <ns>0</ns>
    <id>9145</id>
    <revision>
      <id>63554</id>
      <parentid>56903</parentid>
      <timestamp>2013-07-10T01:36:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="762">{{c/title|thread_detach}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int thrd_detach( thrd_t thr );
}}

Detaches the thread identified by {{tt|thr}} from the current environment. The resources held by the thread will be freed automatically once the thread exits.

===Parameters===
{{par begin}}
{{par | thr | identifier of the thread to detach}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_join}}
{{dsc end}}

[[de:c/thread/thrd detach]]
[[es:c/thread/thrd detach]]
[[fr:c/thread/thrd detach]]
[[it:c/thread/thrd detach]]
[[ja:c/thread/thrd detach]]
[[pt:c/thread/thrd detach]]
[[ru:c/thread/thrd detach]]
[[zh:c/thread/thrd detach]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd equal</title>
    <ns>0</ns>
    <id>9147</id>
    <revision>
      <id>65924</id>
      <parentid>63555</parentid>
      <timestamp>2013-10-15T11:58:51Z</timestamp>
      <contributor>
        <ip>203.97.127.101</ip>
      </contributor>
      <comment>Fixed title of page</comment>
      <text xml:space="preserve" bytes="604">{{c/title|thrd_equal}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int thrd_equal( thrd_t lhs, thrd_t rhs );
}}

Checks whether {{tt|lhs}} and {{tt|rhs}} refer to the same thread.

===Parameters===
{{par begin}}
{{par | lhs, rhs | threads to compare}}
{{par end}}

===Return value===
Non-zero value if {{tt|lhs}} and {{tt|rhs}} refer to the same value, {{c|0}} otherwise.

[[de:c/thread/thrd equal]]
[[es:c/thread/thrd equal]]
[[fr:c/thread/thrd equal]]
[[it:c/thread/thrd equal]]
[[ja:c/thread/thrd equal]]
[[pt:c/thread/thrd equal]]
[[ru:c/thread/thrd equal]]
[[zh:c/thread/thrd equal]]</text>
      <sha1>fgdrch8ef2etxkl53bampwuwygxod7y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd errors</title>
    <ns>0</ns>
    <id>9152</id>
    <revision>
      <id>66926</id>
      <parentid>63556</parentid>
      <timestamp>2014-01-09T14:51:54Z</timestamp>
      <contributor>
        <username>Wayne82</username>
        <id>2779</id>
      </contributor>
      <minor/>
      <comment>The enum value is not right according to &lt;threads.h&gt;</comment>
      <text xml:space="preserve" bytes="1053">{{c/title|thrd_success|thrd_timedout|thrd_busy|thrd_nomem|thrd_error}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 | 1=
enum {
    thrd_success = /* unspecified */,
    thrd_nomem = /* unspecified */,
    thrd_timedout = /* unspecified */,
    thrd_busy = /* unspecified */,
    thrd_error = /* unspecified */
};
}}

Identifiers a thread error state.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|thrd_success}} | indicates successful return value}}
{{dsc | {{tt|thrd_timedout}} | indicates timed out return value}}
{{dsc | {{tt|thrd_busy}} | indicates unsuccessful return value due to resource temporary unavailable}}
{{dsc | {{tt|thrd_nomem}} | indicates unsuccessful return value due to out of memory condition}}
{{dsc | {{tt|thrd_error}} | indicates unsuccessful return value}}
{{dsc end}}

[[de:c/thread/thrd errors]]
[[es:c/thread/thrd errors]]
[[fr:c/thread/thrd errors]]
[[it:c/thread/thrd errors]]
[[ja:c/thread/thrd errors]]
[[pt:c/thread/thrd errors]]
[[ru:c/thread/thrd errors]]
[[zh:c/thread/thrd errors]]</text>
      <sha1>nxf89e2m71isqwwmrf951vscevo9svd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd exit</title>
    <ns>0</ns>
    <id>9148</id>
    <revision>
      <id>63557</id>
      <parentid>56906</parentid>
      <timestamp>2013-07-10T01:36:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="738">{{c/title|thread_exit}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
_Noreturn void thrd_exit( int res );
}}

Terminates the current thread and sets its result code to {{tt|res}}.

{{todo|The termination of the program after the last thread. The standard seems to be contradictory}}

===Parameters===
{{par begin}}
{{par | res | the result value to return}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_join}}
{{dsc inc | c/thread/dsc thrd_detach}}
{{dsc end}}

[[de:c/thread/thrd exit]]
[[es:c/thread/thrd exit]]
[[fr:c/thread/thrd exit]]
[[it:c/thread/thrd exit]]
[[ja:c/thread/thrd exit]]
[[pt:c/thread/thrd exit]]
[[ru:c/thread/thrd exit]]
[[zh:c/thread/thrd exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd join</title>
    <ns>0</ns>
    <id>9149</id>
    <revision>
      <id>63558</id>
      <parentid>56907</parentid>
      <timestamp>2013-07-10T01:36:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="849">{{c/title|thread_join}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int thrd_join( thrd_t thr, int *res );
}}

Blocks the current thread until the thread identified by {{tt|thr}} finishes execution.

The result code of the thread is put to the location pointed to by {{tt|res}}.

===Parameters===
{{par begin}}
{{par | thr | identifier of the thread to join}}
{{par | res | location to put the result code to}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_detach}}
{{dsc inc | c/thread/dsc thrd_exit}}
{{dsc end}}

[[de:c/thread/thrd join]]
[[es:c/thread/thrd join]]
[[fr:c/thread/thrd join]]
[[it:c/thread/thrd join]]
[[ja:c/thread/thrd join]]
[[pt:c/thread/thrd join]]
[[ru:c/thread/thrd join]]
[[zh:c/thread/thrd join]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd sleep</title>
    <ns>0</ns>
    <id>9150</id>
    <revision>
      <id>63559</id>
      <parentid>56908</parentid>
      <timestamp>2013-07-10T01:36:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1219">{{c/title|thread_sleep}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int thrd_sleep( const struct timespec* time_point,
                struct timespec* remaining );
}}

Blocks the execution of the current thread for ''at least'' until the {{c|TIME_UTC}} based time point pointed to by {{tt|time_point}} has been reached.

The sleep may resume earlier if a signal that is not ignored is received. In such case, if {{tt|remaining}} is not {{lc|NULL}}, the remaining time duration is stored into the object pointed to by {{tt|remaining}}.

===Parameters===
{{par begin}}
{{par | time_point | pointer to the time point to sleep until}}
{{par | remaining | pointer to the object to put the remaining time on interruption. May be {{lc|NULL}}, in which case it is ignored}}
{{par end}}

===Return value===
{{c|0}} on successful sleep, {{c|-1}} if an interrupt occurred, other negative value if an error occurred.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_yield}}
{{dsc end}}

[[de:c/thread/thrd sleep]]
[[es:c/thread/thrd sleep]]
[[fr:c/thread/thrd sleep]]
[[it:c/thread/thrd sleep]]
[[ja:c/thread/thrd sleep]]
[[pt:c/thread/thrd sleep]]
[[ru:c/thread/thrd sleep]]
[[zh:c/thread/thrd sleep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thrd yield</title>
    <ns>0</ns>
    <id>9151</id>
    <revision>
      <id>63560</id>
      <parentid>56911</parentid>
      <timestamp>2013-07-10T01:36:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="566">{{c/title|thread_yield}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void thrd_yield();
}}

Provides a hint to the implementation to reschedule the execution of threads, allowing other threads to run. 

===Parameters===
(none)

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc thrd_sleep}}
{{dsc end}}

[[de:c/thread/thrd yield]]
[[es:c/thread/thrd yield]]
[[fr:c/thread/thrd yield]]
[[it:c/thread/thrd yield]]
[[ja:c/thread/thrd yield]]
[[pt:c/thread/thrd yield]]
[[ru:c/thread/thrd yield]]
[[zh:c/thread/thrd yield]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/thread local</title>
    <ns>0</ns>
    <id>9141</id>
    <revision>
      <id>63561</id>
      <parentid>42059</parentid>
      <timestamp>2013-07-10T01:36:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="436">{{c/title|thread_local}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
#define thread_local _Thread_local
}}

Convenience macro which can be used to specify that a variable is thread-local.

[[de:c/thread/thread local]]
[[es:c/thread/thread local]]
[[fr:c/thread/thread local]]
[[it:c/thread/thread local]]
[[ja:c/thread/thread local]]
[[pt:c/thread/thread local]]
[[ru:c/thread/thread local]]
[[zh:c/thread/thread local]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/tss create</title>
    <ns>0</ns>
    <id>9193</id>
    <revision>
      <id>63562</id>
      <parentid>49210</parentid>
      <timestamp>2013-07-10T01:36:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="883">{{c/title|tss_create}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int tss_create( tss_t* tss_id, tss_dtor_t destructor );
}}

Creates new thread-specific storage and optionally stores destructor which is called when the storage is deleted. The object pointed to by {{tt|tss_id}} is set to the identifier of the new thread-specific storage.

===Parameters===
{{par begin}}
{{par | tss_id | pointer to memory location to store the identifier of the thread-specific storage}}
{{par | destructor | pointer to a function to call when the storage is deleted}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

[[de:c/thread/tss create]]
[[es:c/thread/tss create]]
[[fr:c/thread/tss create]]
[[it:c/thread/tss create]]
[[ja:c/thread/tss create]]
[[pt:c/thread/tss create]]
[[ru:c/thread/tss create]]
[[zh:c/thread/tss create]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/tss delete</title>
    <ns>0</ns>
    <id>9190</id>
    <revision>
      <id>63563</id>
      <parentid>49211</parentid>
      <timestamp>2013-07-10T01:36:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="606">{{c/title|tss_delete}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void tss_delete( tss_t tss_id );
}}

Destroys the thread-specific storage identified by {{tt|tss_id}}.

{{todo|The standard doesn't say anything about the destructor}}

===Parameters===
{{par begin}}
{{par | tss_id | identifier of thread-specific storage to destroy}}
{{par end}}

===Return value===
(none)

[[de:c/thread/tss delete]]
[[es:c/thread/tss delete]]
[[fr:c/thread/tss delete]]
[[it:c/thread/tss delete]]
[[ja:c/thread/tss delete]]
[[pt:c/thread/tss delete]]
[[ru:c/thread/tss delete]]
[[zh:c/thread/tss delete]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/tss get</title>
    <ns>0</ns>
    <id>9192</id>
    <revision>
      <id>63564</id>
      <parentid>56912</parentid>
      <timestamp>2013-07-10T01:36:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="663">{{c/title|tss_get}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
void *tss_get( tss_t tss_id );
}}

Returns the value held in thread-specific storage for the current thread identified by {{tt|tss_id}}

===Parameters===
{{par begin}}
{{par | tss_id | identifies the thread-specific storage to access}}
{{par end}}

===Return value===
The value on success, {{lc|NULL}} on failure.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc tss_set}}
{{dsc end}}

[[de:c/thread/tss get]]
[[es:c/thread/tss get]]
[[fr:c/thread/tss get]]
[[it:c/thread/tss get]]
[[ja:c/thread/tss get]]
[[pt:c/thread/tss get]]
[[ru:c/thread/tss get]]
[[zh:c/thread/tss get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/thread/tss set</title>
    <ns>0</ns>
    <id>9191</id>
    <revision>
      <id>63565</id>
      <parentid>56913</parentid>
      <timestamp>2013-07-10T01:36:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="757">{{c/title|tss_set}}
{{c/thread/navbar}}
{{ddcl | header=threads.h | since=c11 |
int tss_set( tss_t tss_id, void *val );
}}
Sets the value of the thread-specific storage identified by {{tt|tss_id}} for the current thread to {{tt|val}}. 

===Parameters===
{{par begin}}
{{par | tss_id | identifies the thread-specific storage to modify}}
{{par | val | value to set thread-specific storage to}}
{{par end}}

===Return value===
{{lc|thrd_success}} if successful, {{lc|thrd_error}} otherwise.

===See also===
{{dsc begin}}
{{dsc inc | c/thread/dsc tss_get}}
{{dsc end}}

[[de:c/thread/tss set]]
[[es:c/thread/tss set]]
[[fr:c/thread/tss set]]
[[it:c/thread/tss set]]
[[ja:c/thread/tss set]]
[[pt:c/thread/tss set]]
[[ru:c/thread/tss set]]
[[zh:c/thread/tss set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types</title>
    <ns>0</ns>
    <id>6320</id>
    <revision>
      <id>71021</id>
      <parentid>70950</parentid>
      <timestamp>2014-06-04T19:35:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="1148">{{title|Type support}}
{{c/types/navbar}}
===Basic types===

====[[c/language/types | Fundamental types defined by the language]]====

====Additional basic types and macros====
{{dsc begin}}
{{dsc header | stddef.h}}
{{dsc inc | c/types/dsc size_t}}
{{dsc inc | c/types/dsc ptrdiff_t}}
{{dsc inc | c/types/dsc NULL}}
{{dsc inc | c/types/dsc max_align_t}}
{{dsc inc | c/types/dsc offsetof}}
{{dsc header | stdbool.h}}
{{dsc macro const | __bool_true_false_are_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c99}}}}
{{dsc header | stdalign.h}}
{{dsc macro const | __alignas_is_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c99}}}}
{{dsc end}}

====[[c/types/integer | Fixed width integer types]] {{mark since c99}}====

====[[c/types/limits| Numeric limits]]====

{{todo|Variadic functions. Probably at [[c/variadic]].}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/types |Type support library}}
{{dsc end}}

[[de:c/types]]
[[es:c/types]]
[[fr:c/types]]
[[it:c/types]]
[[ja:c/types]]
[[pt:c/types]]
[[ru:c/types]]
[[zh:c/types]]</text>
      <sha1>hwsuouaqj9n7by6z0bsaoiqt63oc0mb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/NULL</title>
    <ns>0</ns>
    <id>9389</id>
    <revision>
      <id>70921</id>
      <parentid>49215</parentid>
      <timestamp>2014-06-03T14:09:13Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>new example</comment>
      <text xml:space="preserve" bytes="888">{{c/title|NULL}}
{{c/types/navbar}}
{{dcl begin}}
{{dcl header | stddef.h}}
{{dcl header | string.h}}
{{dcl header | wchar.h}}
{{dcl header | time.h}}
{{dcl header | locale.h}}
{{dcl header | stdio.h}}
{{dcl |
#define NULL /*implementation-defined*/
}}
{{dcl end}}

Expands into implementation-defined null-pointer constant.

===Example===
{{example |
 | code=
#include &lt;stdlib.h&gt;

struct S;
void(*f)() = NULL;

int main(void)
{    
    char *ptr = malloc(sizeof(char)*10);
    if (ptr == NULL) exit(EXIT_FAILURE);
    free(ptr);
    ptr = NULL;

    int* p = NULL;
    struct S *s = NULL;
    
    return EXIT_SUCCESS;
}
 | p=true
 | output=
(none)
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/types/NULL}}
{{dsc end}}

[[de:c/types/NULL]]
[[es:c/types/NULL]]
[[fr:c/types/NULL]]
[[it:c/types/NULL]]
[[ja:c/types/NULL]]
[[pt:c/types/NULL]]
[[ru:c/types/NULL]]
[[zh:c/types/NULL]]</text>
      <sha1>scsdr626ubyaaacjfpjdphso2mwyo9r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/integer</title>
    <ns>0</ns>
    <id>6396</id>
    <revision>
      <id>71213</id>
      <parentid>69582</parentid>
      <timestamp>2014-06-08T12:53:00Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>size of an integer type; p=</comment>
      <text xml:space="preserve" bytes="13102">{{title | Fixed width integer types {{mark since c99}}}}
{{c/types/navbar}}

===Types===

{{dsc begin}}
{{dsc header | stdint.h}}
{{dsc | {{tt|int8_t}}&lt;br&gt;{{tt|int16_t}}&lt;br&gt;{{tt|int32_t}}&lt;br&gt;{{tt|int64_t}} | signed integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively&lt;br&gt;with no padding bits and using 2's complement for negative values&lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|int_fast8_t}}&lt;br&gt;{{tt|int_fast16_t}}&lt;br&gt;{{tt|int_fast32_t}}&lt;br&gt;{{tt|int_fast64_t}} | fastest signed signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|int_least8_t}}&lt;br&gt;{{tt|int_least16_t}}&lt;br&gt;{{tt|int_least32_t}}&lt;br&gt;{{tt|int_least64_t}} | smallest signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|intmax_t}} | maximum width integer type }}
{{dsc | {{tt|intptr_t}} | integer type capable of holding a pointer}}{{dsc | {{tt|uint8_t}}&lt;br&gt;{{tt|uint16_t}}&lt;br&gt;{{tt|uint32_t}}&lt;br&gt;{{tt|uint64_t}} | unsigned integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively &lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|uint_fast8_t}}&lt;br&gt;{{tt|uint_fast16_t}}&lt;br&gt;{{tt|uint_fast32_t}}&lt;br&gt;{{tt|uint_fast64_t}} | fastest unsigned unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uint_least8_t}}&lt;br&gt;{{tt|uint_least16_t}}&lt;br&gt;{{tt|uint_least32_t}}&lt;br&gt;{{tt|uint_least64_t}} | smallest unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uintmax_t}} | maximum width unsigned integer type }}
{{dsc | {{tt|uintptr_t}} | unsigned integer type capable of holding a pointer}}
{{dsc end}}

===Macro constants===
{{dsc begin}}
{{dsc header | stdint.h}}
{{dsc h2 | Signed integers : minimum value}}
{{dsc macro const | INT8_MIN&lt;br&gt;INT16_MIN&lt;br&gt;INT32_MIN&lt;br&gt;INT64_MIN |  minimum value of an object of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MIN&lt;br&gt;INT_FAST16_MIN&lt;br&gt;INT_FAST32_MIN&lt;br&gt;INT_FAST64_MIN |  minimum value of an object of type {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MIN&lt;br&gt;INT_LEAST16_MIN&lt;br&gt;INT_LEAST32_MIN&lt;br&gt;INT_LEAST64_MIN |  minimum value of an object of type {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MIN | minimum value of an object of type {{lc|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MIN | minimum value of an object of type {{lc|intmax_t}} | nolink=true }}
{{dsc h2 | Signed integers : maximum value| nolink=true }}

{{dsc macro const | INT8_MAX&lt;br&gt;INT16_MAX&lt;br&gt;INT32_MAX&lt;br&gt;INT64_MAX |  maximum value of an object of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MAX&lt;br&gt;INT_FAST16_MAX&lt;br&gt;INT_FAST32_MAX&lt;br&gt;INT_FAST64_MAX |  maximum value of an object of type {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MAX&lt;br&gt;INT_LEAST16_MAX&lt;br&gt;INT_LEAST32_MAX&lt;br&gt;INT_LEAST64_MAX |  maximum value of an object of type {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MAX | maximum value of an object of type {{lc|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MAX | maximum value of an object of type {{lc|intmax_t}} | nolink=true }}
{{dsc h2 | Unsigned integers : maximum value| nolink=true }}{{dsc macro const | UINT8_MAX&lt;br&gt;UINT16_MAX&lt;br&gt;UINT32_MAX&lt;br&gt;UINT64_MAX |  maximum value of an object of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}} | nolink=true }}
{{dsc macro const | UINT_FAST8_MAX&lt;br&gt;UINT_FAST16_MAX&lt;br&gt;UINT_FAST32_MAX&lt;br&gt;UINT_FAST64_MAX |  maximum value of an object of type {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}} | nolink=true }}
{{dsc macro const | UINT_LEAST8_MAX&lt;br&gt;UINT_LEAST16_MAX&lt;br&gt;UINT_LEAST32_MAX&lt;br&gt;UINT_LEAST64_MAX |  maximum value of an object of type {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}} | nolink=true }}
{{dsc macro const | UINTPTR_MAX | maximum value of an object of type {{lc|uintptr_t}} | nolink=true }}
{{dsc macro const | UINTMAX_MAX | maximum value of an object of type {{lc|uintmax_t}} | nolink=true }}
{{dsc end}}

===Format macro constants===
{{todo|will look better as a table}}
{{dsc begin}}
{{dsc header | inttypes.h}}
{{dsc h2 | Format constants for the {{lc|fprintf}} family of functions}}
{{dsc macro const | PRId8&lt;br&gt;PRId16&lt;br&gt;PRId32&lt;br&gt;PRId64&lt;br&gt;PRIdLEAST8&lt;br&gt;PRIdLEAST16&lt;br&gt;PRIdLEAST32&lt;br&gt;PRIdLEAST64&lt;br&gt;PRIdFAST8&lt;br&gt;PRIdFAST16&lt;br&gt;PRIdFAST32&lt;br&gt;PRIdFAST64&lt;br&gt;PRIdMAX&lt;br&gt;PRIdPTR | format conversion specifier to output a signed decimal integer value of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}}, {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}}, {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}}, {{lc|intmax_t}}, {{lc|intptr_t}} respectively, equivalent to {{tt|%d}} for {{c|int}} | nolink=true }}
{{dsc macro const | PRIi8&lt;br&gt;PRIi16&lt;br&gt;PRIi32&lt;br&gt;PRIi64&lt;br&gt;PRIiLEAST8&lt;br&gt;PRIiLEAST16&lt;br&gt;PRIiLEAST32&lt;br&gt;PRIiLEAST64&lt;br&gt;PRIiFAST8&lt;br&gt;PRIiFAST16&lt;br&gt;PRIiFAST32&lt;br&gt;PRIiFAST64&lt;br&gt;PRIiMAX&lt;br&gt;PRIiPTR | format conversion specifier to output a signed decimal integer value of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}}, {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}}, {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}}, {{lc|intmax_t}}, {{lc|intptr_t}} respectively, equivalent to {{tt|%i}} for {{c|int}} | nolink=true }}
{{dsc macro const | PRIu8&lt;br&gt;PRIu16&lt;br&gt;PRIu32&lt;br&gt;PRIu64&lt;br&gt;PRIuLEAST8&lt;br&gt;PRIuLEAST16&lt;br&gt;PRIuLEAST32&lt;br&gt;PRIuLEAST64&lt;br&gt;PRIuFAST8&lt;br&gt;PRIuFAST16&lt;br&gt;PRIuFAST32&lt;br&gt;PRIuFAST64&lt;br&gt;PRIuMAX&lt;br&gt;PRIuPTR | format conversion specifier to output an unsigned decimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%u}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIo8&lt;br&gt;PRIo16&lt;br&gt;PRIo32&lt;br&gt;PRIo64&lt;br&gt;PRIoLEAST8&lt;br&gt;PRIoLEAST16&lt;br&gt;PRIoLEAST32&lt;br&gt;PRIoLEAST64&lt;br&gt;PRIoFAST8&lt;br&gt;PRIoFAST16&lt;br&gt;PRIoFAST32&lt;br&gt;PRIoFAST64&lt;br&gt;PRIoMAX&lt;br&gt;PRIoPTR | format conversion specifier to output an unsigned octal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%o}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIx8&lt;br&gt;PRIx16&lt;br&gt;PRIx32&lt;br&gt;PRIx64&lt;br&gt;PRIxLEAST8&lt;br&gt;PRIxLEAST16&lt;br&gt;PRIxLEAST32&lt;br&gt;PRIxLEAST64&lt;br&gt;PRIxFAST8&lt;br&gt;PRIxFAST16&lt;br&gt;PRIxFAST32&lt;br&gt;PRIxFAST64&lt;br&gt;PRIxMAX&lt;br&gt;PRIxPTR | format conversion specifier to output an unsigned hexadecimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%x}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIX8&lt;br&gt;PRIX16&lt;br&gt;PRIX32&lt;br&gt;PRIX64&lt;br&gt;PRIXLEAST8&lt;br&gt;PRIXLEAST16&lt;br&gt;PRIXLEAST32&lt;br&gt;PRIXLEAST64&lt;br&gt;PRIXFAST8&lt;br&gt;PRIXFAST16&lt;br&gt;PRIXFAST32&lt;br&gt;PRIXFAST64&lt;br&gt;PRIXMAX&lt;br&gt;PRIXPTR | format conversion specifier to output an unsigned uppercase hexadecimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%X}} for {{c|unsigned int}} | nolink=true }}
{{dsc h2 | Format constants for the {{lc|fscanf}} family of functions}}
{{dsc macro const | SCNd8&lt;br&gt;SCNd16&lt;br&gt;SCNd32&lt;br&gt;SCNd64&lt;br&gt;SCNdLEAST8&lt;br&gt;SCNdLEAST16&lt;br&gt;SCNdLEAST32&lt;br&gt;SCNdLEAST64&lt;br&gt;SCNdFAST8&lt;br&gt;SCNdFAST16&lt;br&gt;SCNdFAST32&lt;br&gt;SCNdFAST64&lt;br&gt;SCNdMAX&lt;br&gt;SCNdPTR | format conversion specifier to input a signed decimal integer value of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}}, {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}}, {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}}, {{lc|intmax_t}}, {{lc|intptr_t}} respectively, equivalent to {{tt|%d}} for {{c|int}} | nolink=true }}
{{dsc macro const | SCNi8&lt;br&gt;SCNi16&lt;br&gt;SCNi32&lt;br&gt;SCNi64&lt;br&gt;SCNiLEAST8&lt;br&gt;SCNiLEAST16&lt;br&gt;SCNiLEAST32&lt;br&gt;SCNiLEAST64&lt;br&gt;SCNiFAST8&lt;br&gt;SCNiFAST16&lt;br&gt;SCNiFAST32&lt;br&gt;SCNiFAST64&lt;br&gt;SCNiMAX&lt;br&gt;SCNiPTR | format conversion specifier to input a signed decimal/octal/hexadecimal integer value of type {{lc|int8_t}}, {{lc|int16_t}}, {{lc|int32_t}}, {{lc|int64_t}}, {{lc|int_least8_t}}, {{lc|int_least16_t}}, {{lc|int_least32_t}}, {{lc|int_least64_t}}, {{lc|int_fast8_t}}, {{lc|int_fast16_t}}, {{lc|int_fast32_t}}, {{lc|int_fast64_t}}, {{lc|intmax_t}}, {{lc|intptr_t}} respectively, equivalent to {{tt|%i}} for {{c|int}} | nolink=true }}
{{dsc macro const | SCNu8&lt;br&gt;SCNu16&lt;br&gt;SCNu32&lt;br&gt;SCNu64&lt;br&gt;SCNuLEAST8&lt;br&gt;SCNuLEAST16&lt;br&gt;SCNuLEAST32&lt;br&gt;SCNuLEAST64&lt;br&gt;SCNuFAST8&lt;br&gt;SCNuFAST16&lt;br&gt;SCNuFAST32&lt;br&gt;SCNuFAST64&lt;br&gt;SCNuMAX&lt;br&gt;SCNuPTR | format conversion specifier to input an unsigned decimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%u}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNo8&lt;br&gt;SCNo16&lt;br&gt;SCNo32&lt;br&gt;SCNo64&lt;br&gt;SCNoLEAST8&lt;br&gt;SCNoLEAST16&lt;br&gt;SCNoLEAST32&lt;br&gt;SCNoLEAST64&lt;br&gt;SCNoFAST8&lt;br&gt;SCNoFAST16&lt;br&gt;SCNoFAST32&lt;br&gt;SCNoFAST64&lt;br&gt;SCNoMAX&lt;br&gt;SCNoPTR | format conversion specifier to input an unsigned octal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%o}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNx8&lt;br&gt;SCNx16&lt;br&gt;SCNx32&lt;br&gt;SCNx64&lt;br&gt;SCNxLEAST8&lt;br&gt;SCNxLEAST16&lt;br&gt;SCNxLEAST32&lt;br&gt;SCNxLEAST64&lt;br&gt;SCNxFAST8&lt;br&gt;SCNxFAST16&lt;br&gt;SCNxFAST32&lt;br&gt;SCNxFAST64&lt;br&gt;SCNxMAX&lt;br&gt;SCNxPTR | format conversion specifier to input an unsigned hexadecimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%x}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNX8&lt;br&gt;SCNX16&lt;br&gt;SCNX32&lt;br&gt;SCNX64&lt;br&gt;SCNXLEAST8&lt;br&gt;SCNXLEAST16&lt;br&gt;SCNXLEAST32&lt;br&gt;SCNXLEAST64&lt;br&gt;SCNXFAST8&lt;br&gt;SCNXFAST16&lt;br&gt;SCNXFAST32&lt;br&gt;SCNXFAST64&lt;br&gt;SCNXMAX&lt;br&gt;SCNXPTR | format conversion specifier to input an unsigned uppercase hexadecimal integer value of type {{lc|uint8_t}}, {{lc|uint16_t}}, {{lc|uint32_t}}, {{lc|uint64_t}}, {{lc|uint_least8_t}}, {{lc|uint_least16_t}}, {{lc|uint_least32_t}}, {{lc|uint_least64_t}}, {{lc|uint_fast8_t}}, {{lc|uint_fast16_t}}, {{lc|uint_fast32_t}}, {{lc|uint_fast64_t}}, {{lc|uintmax_t}}, {{lc|uintptr_t}} respectively, equivalent to {{tt|%X}} for {{c|unsigned int}} | nolink=true }}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;inttypes.h&gt;

int main(void)
{
    printf(&quot;%zu\n&quot;, sizeof(int64_t));
    printf(&quot;%s\n&quot;, PRId64);
    printf(&quot;%+&quot;PRId64&quot;\n&quot;, INT64_MIN);
    printf(&quot;%+&quot;PRId64&quot;\n&quot;, INT64_MAX);
    
    int64_t n = 7;
    printf(&quot;%+&quot;PRId64&quot;\n&quot;, n);
    
    return 0;
}
 | p=true
 | output=
8
ld
-9223372036854775808
+9223372036854775807
+7
}}

===See also===
* [[cpp/language/types | Arithmetic types]]
* [[cpp/language/type  | C++ type system overview]]
* [[cpp/types          | Type support (basic types, RTTI, type traits)]]

[[de:c/types/integer]]
[[es:c/types/integer]]
[[fr:c/types/integer]]
[[it:c/types/integer]]
[[ja:c/types/integer]]
[[pt:c/types/integer]]
[[ru:c/types/integer]]
[[zh:c/types/integer]]</text>
      <sha1>7dj978019285l3n4fvxktt85zjaziwp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/limits</title>
    <ns>0</ns>
    <id>6397</id>
    <revision>
      <id>72423</id>
      <parentid>70273</parentid>
      <timestamp>2014-08-21T20:48:55Z</timestamp>
      <contributor>
        <ip>216.236.254.7</ip>
      </contributor>
      <comment>Replaced &quot;maximum&quot; with &quot;minimum&quot; in descriptions of several *_MIN macros</comment>
      <text xml:space="preserve" bytes="9077">{{title|Numeric limits}}
{{c/types/limits/navbar}}

{{dsc begin}}
{{dsc header | stdint.h}}
{{dsc macro const | PTRDIFF_MIN | minimum value of object of {{lc|ptrdiff_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | PTRDIFF_MAX | maximum value of object of {{lc|ptrdiff_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | SIZE_MAX | maximum value of object of {{lc|size_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | SIG_ATOMIC_MIN | minimum value of object of {{lc|sig_atomic_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | SIG_ATOMIC_MAX | maximum value of object of {{lc|sig_atomic_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | WCHAR_MIN | minimum value of object of {{c|wchar_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | WCHAR_MAX | maximum value of object of {{c|wchar_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | WINT_MIN | minimum value of object of {{c|wint_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc macro const | WINT_MAX | maximum value of object of {{c|wint_t}} type | notes={{mark c99}} | nolink=true}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdint.h&gt;

int main(void)
{   
    printf(&quot;PTRDIFF_MIN    = %+ld\n&quot;, PTRDIFF_MIN);
    printf(&quot;PTRDIFF_MAX    = %+ld\n&quot;, PTRDIFF_MAX);
    printf(&quot;SIZE_MAX       = %lu\n&quot;,  SIZE_MAX);
    printf(&quot;SIG_ATOMIC_MIN = %+d\n&quot;,  SIG_ATOMIC_MIN);
    printf(&quot;SIG_ATOMIC_MAX = %+d\n&quot;,  SIG_ATOMIC_MAX);
    printf(&quot;WCHAR_MIN      = %+d\n&quot;,  WCHAR_MIN);
    printf(&quot;WCHAR_MAX      = %+d\n&quot;,  WCHAR_MAX);
    printf(&quot;WINT_MIN       = %u\n&quot;,   WINT_MIN);
    printf(&quot;WINT_MAX       = %u\n&quot;,   WINT_MAX);
}
 | p=true
 | output=
PTRDIFF_MIN    = -9223372036854775808
PTRDIFF_MAX    = +9223372036854775807
SIZE_MAX       = 18446744073709551615
SIG_ATOMIC_MIN = -2147483648
SIG_ATOMIC_MAX = +2147483647
WCHAR_MIN      = -2147483648
WCHAR_MAX      = +2147483647
WINT_MIN       = 0
WINT_MAX       = 4294967295
}}

===Limits of integer types===
{{dsc begin}}
{{dsc header | limits.h}}
{{dsc macro const | CHAR_BIT | number of bits in byte | nolink=true }}
{{dsc macro const | MB_LEN_MAX | maximum number of bytes in a multibyte character | nolink=true }}
{{dsc macro const | CHAR_MIN | minimum value of {{c|char}} | nolink=true }}
{{dsc macro const | CHAR_MAX | maximum value of {{c|char}} | nolink=true }}
{{dsc macro const | SCHAR_MIN&lt;br&gt;SHRT_MIN&lt;br&gt;INT_MIN&lt;br&gt;LONG_MIN&lt;br&gt;LLONG_MIN | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}} | minimum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | SCHAR_MAX&lt;br&gt;SHRT_MAX&lt;br&gt;INT_MAX&lt;br&gt;LONG_MAX&lt;br&gt;LLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}} | maximum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | UCHAR_MAX&lt;br&gt;USHRT_MAX&lt;br&gt;UINT_MAX&lt;br&gt;ULONG_MAX&lt;br&gt;ULLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}} | maximum value of {{c|unsigned char}}, {{c|unsigned short}}, {{c|unsigned int}},&lt;br&gt;{{c|unsigned long}} and {{c|unsigned long long}} respectively}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;limits.h&gt;

int main(void)
{   
    printf(&quot;CHAR_BIT   = %d\n&quot;, CHAR_BIT);
    printf(&quot;MB_LEN_MAX = %d\n&quot;, MB_LEN_MAX);
    printf(&quot;\n&quot;);

    printf(&quot;CHAR_MIN   = %+d\n&quot;, CHAR_MIN);
    printf(&quot;CHAR_MAX   = %+d\n&quot;, CHAR_MAX);
    printf(&quot;SCHAR_MIN  = %+d\n&quot;, SCHAR_MIN);
    printf(&quot;SCHAR_MAX  = %+d\n&quot;, SCHAR_MAX);
    printf(&quot;UCHAR_MAX  = %u\n&quot;,  UCHAR_MAX);
    printf(&quot;\n&quot;);

    printf(&quot;SHRT_MIN   = %+d\n&quot;, SHRT_MIN);
    printf(&quot;SHRT_MAX   = %+d\n&quot;, SHRT_MAX);
    printf(&quot;USHRT_MAX  = %u\n&quot;,  USHRT_MAX);
    printf(&quot;\n&quot;);
    
    printf(&quot;INT_MIN    = %+d\n&quot;, INT_MIN);
    printf(&quot;INT_MAX    = %+d\n&quot;, INT_MAX);
    printf(&quot;UINT_MAX   = %u\n&quot;,  UINT_MAX);
    printf(&quot;\n&quot;);
    
    printf(&quot;LONG_MIN   = %+ld\n&quot;, LONG_MIN);
    printf(&quot;LONG_MAX   = %+ld\n&quot;, LONG_MAX);
    printf(&quot;ULONG_MAX  = %lu\n&quot;,  ULONG_MAX);
    printf(&quot;\n&quot;);
        
    printf(&quot;LLONG_MIN  = %+lld\n&quot;, LLONG_MIN);
    printf(&quot;LLONG_MAX  = %+lld\n&quot;, LLONG_MAX);
    printf(&quot;ULLONG_MAX = %llu\n&quot;,  ULLONG_MAX);
    printf(&quot;\n&quot;);
}
 | p=true
 | output=
CHAR_BIT   = 8
MB_LEN_MAX = 16

CHAR_MIN   = -128
CHAR_MAX   = +127
SCHAR_MIN  = -128
SCHAR_MAX  = +127
UCHAR_MAX  = 255

SHRT_MIN   = -32768
SHRT_MAX   = +32767
USHRT_MAX  = 65535

INT_MIN    = -2147483648
INT_MAX    = +2147483647
UINT_MAX   = 4294967295

LONG_MIN   = -9223372036854775808
LONG_MAX   = +9223372036854775807
ULONG_MAX  = 18446744073709551615

LLONG_MIN  = -9223372036854775808
LLONG_MAX  = +9223372036854775807
ULLONG_MAX = 18446744073709551615
}}

===Limits of floating point types===
{{dsc begin}}
{{dsc header | float.h}}
{{dsc macro const | FLT_RADIX | the radix (integer base) used by the representation of all three floating-point types | nolink=true }}
{{dsc macro const | DECIMAL_DIG | number of decimal digits that can be converted to {{c|long double}} and back without losing precision | nolink=true | notes={{mark c99}}}}
{{dsc macro const | FLT_MIN&lt;br&gt;DBL_MIN&lt;br&gt;LDBL_MIN | minimum, normalized, positive value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX&lt;br&gt;DBL_MAX&lt;br&gt;LDBL_MAX | maximum value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_EPSILON&lt;br&gt;DBL_EPSILON&lt;br&gt;LDBL_EPSILON | difference between {{c|1.0}} and the next representable value for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_DIG&lt;br&gt;DBL_DIG&lt;br&gt;LDBL_DIG | number of decimal digits that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MANT_DIG&lt;br&gt;DBL_MANT_DIG&lt;br&gt;LDBL_MANT_DIG | number of base-{{tt|FLT_RADIX}} digits that are in the floating-point mantissa and that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_EXP&lt;br&gt;DBL_MIN_EXP&lt;br&gt;LDBL_MIN_EXP | minimum negative integer such that {{tt|FLT_RADIX}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_10_EXP&lt;br&gt;DBL_MIN_10_EXP&lt;br&gt;LDBL_MIN_10_EXP | minimum negative integer such that {{c|10}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_EXP&lt;br&gt;DBL_MAX_EXP&lt;br&gt;LDBL_MAX_EXP | maximum positive integer such that {{tt|FLT_RADIX}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_10_EXP&lt;br&gt;DBL_MAX_10_EXP&lt;br&gt;LDBL_MAX_10_EXP | maximum positive integer such that {{c|10}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_ROUNDS | rounding mode of floating-point arithmetics, equal to {{c|float_round_style}} | nolink=true }}
{{dsc macro const | FLT_EVAL_METHOD | use of extended precision for intermediate results: 0 not used, 1 {{c|double}} is used instead of {{c|float}}, 2: {{c|long double}} is used | nolink=true | notes={{mark c99}}}}
{{dsc macro const | FLT_HAS_SUBNORM&lt;br /&gt;DBL_HAS_SUBNORM&lt;br /&gt;LDBL_HAS_SUBNORM | whether the type supports subnormal ([[enwiki:Denormal number|denormal]]) numbers: -1 indeterminable, 0 absent, 1 present | nolink=true | notes={{mark c11}}}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;float.h&gt; 
#include &lt;math.h&gt;

int main(void)
{
    printf(&quot;FLT_RADIX    = %d\n&quot;, FLT_RADIX);
    printf(&quot;DECIMAL_DIG  = %d\n&quot;, DECIMAL_DIG);
    printf(&quot;FLT_MIN      = %e\n&quot;, FLT_MIN);
    printf(&quot;FLT_MAX      = %e\n&quot;, FLT_MAX);
    printf(&quot;FLT_EPSILON  = %e\n&quot;, FLT_EPSILON);
    printf(&quot;FLT_DIG      = %d\n&quot;, FLT_DIG);
    printf(&quot;FLT_MANT_DIG = %d\n&quot;, FLT_MANT_DIG);
    printf(&quot;FLT_MIN_EXP  = %d\n&quot;,  FLT_MIN_EXP);
    printf(&quot;FLT_MIN_10_EXP  = %d\n&quot;,  FLT_MIN_10_EXP);
    printf(&quot;FLT_MAX_EXP     = %d\n&quot;,  FLT_MAX_EXP);
    printf(&quot;FLT_MAX_10_EXP  = %d\n&quot;,  FLT_MAX_10_EXP);
    printf(&quot;FLT_ROUNDS      = %d\n&quot;,  FLT_ROUNDS);
    printf(&quot;FLT_EVAL_METHOD = %d\n&quot;,  FLT_EVAL_METHOD);
    printf(&quot;FLT_HAS_SUBNORM = %d\n&quot;,  FLT_HAS_SUBNORM);
}
 | p=true
 | output=
FLT_RADIX    = 2
DECIMAL_DIG  = 37
FLT_MIN      = 1.175494e-38
FLT_MAX      = 3.402823e+38
FLT_EPSILON  = 1.192093e-07
FLT_DIG      = 6
FLT_MANT_DIG = 24
FLT_MIN_EXP  = -125
FLT_MIN_10_EXP  = -37
FLT_MAX_EXP     = 128
FLT_MAX_10_EXP  = 38
FLT_ROUNDS      = 1
FLT_EVAL_METHOD = 1
FLT_HAS_SUBNORM = 1
}}

[[de:c/types/limits]]
[[es:c/types/limits]]
[[fr:c/types/limits]]
[[it:c/types/limits]]
[[ja:c/types/limits]]
[[pt:c/types/limits]]
[[ru:c/types/limits]]
[[zh:c/types/limits]]</text>
      <sha1>clkjeewu1isj0ueblx6fpj1dzl1h1us</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/limits/FLT EVAL METHOD</title>
    <ns>0</ns>
    <id>8695</id>
    <revision>
      <id>63566</id>
      <parentid>49218</parentid>
      <timestamp>2013-07-10T01:36:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1420">{{title|FLT_EVAL_METHOD}}
{{c/types/limits/navbar}}
{{ddcl | header=float.h | since=c99 |
#define FLT_EVAL_METHOD /* implementation defined */
}}

Specifies the precision in which all floating-point arithmetic operations are done. 

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | negative values except {{tt|-1}} | implementation-defined behavior}}
{{dsc | {{tt|-1}} | the default precision is not known}}
{{dsc | {{tt|0}} | all operations and constants evaluate in the range and precision of the type used. Additionally, {{c|float_t}} and {{c|double_t}} are equivalent to {{c|float}} and {{c|double}} respectively}}
{{dsc | {{tt|1}} | all operations and constants evaluate in the range and precision of {{c|double}}. Additionally, both {{c|float_t}} and {{c|double_t}} are equivalent to {{c|double}}}}
{{dsc | {{tt|2}} | all operations and constants evaluate in the range and precision of {{c|long double}}. Additionally, both {{c|float_t}} and {{c|double_t}} are equivalent to {{c|long double}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/types/climits/FLT_EVAL_METHOD}}
{{dsc end}}

[[de:c/types/limits/FLT EVAL METHOD]]
[[es:c/types/limits/FLT EVAL METHOD]]
[[fr:c/types/limits/FLT EVAL METHOD]]
[[it:c/types/limits/FLT EVAL METHOD]]
[[ja:c/types/limits/FLT EVAL METHOD]]
[[pt:c/types/limits/FLT EVAL METHOD]]
[[ru:c/types/limits/FLT EVAL METHOD]]
[[zh:c/types/limits/FLT EVAL METHOD]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/limits/FLT ROUNDS</title>
    <ns>0</ns>
    <id>8697</id>
    <revision>
      <id>71780</id>
      <parentid>71777</parentid>
      <timestamp>2014-06-24T01:41:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-std:</comment>
      <text xml:space="preserve" bytes="1150">{{title|FLT_ROUNDS}}
{{c/types/limits/navbar}}
{{ddcl | header=float.h | since=c99 |
#define FLT_ROUNDS /* implementation defined */
}}

Returns the current rounding direction of floating-point arithmetic operations.

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | {{tt|-1}} | the default rounding direction is not known}}
{{dsc | {{tt|0}} | toward zero, {{lc|FE_TOWARDZERO}}}}
{{dsc | {{tt|1}} | to nearest, {{lc|FE_TONEAREST}}}}
{{dsc | {{tt|2}} | towards positive infinity, {{lc|FE_UPWARD}}}}
{{dsc | {{tt|3}} | towards negative infinity, {{lc|FE_DOWNWARD}}}}
{{dsc | other values | implementation-defined behavior}}
{{dsc end}}

===Notes===
The rounding mode can be changed with {{lc|fesetround}} and {{lc|FLT_ROUNDS}} reflects that change.

===See also===
{{dsc begin}}
{{dsc inc | c/numeric/fenv/dsc feround}}
{{dsc see cpp | cpp/types/climits/FLT_ROUNDS}}
{{dsc end}}

[[de:c/types/limits/FLT ROUNDS]]
[[es:c/types/limits/FLT ROUNDS]]
[[fr:c/types/limits/FLT ROUNDS]]
[[it:c/types/limits/FLT ROUNDS]]
[[ja:c/types/limits/FLT ROUNDS]]
[[pt:c/types/limits/FLT ROUNDS]]
[[ru:c/types/limits/FLT ROUNDS]]
[[zh:c/types/limits/FLT ROUNDS]]</text>
      <sha1>if53jgoe0hxm40qx1p0m8016m9nomtb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/max align t</title>
    <ns>0</ns>
    <id>9388</id>
    <revision>
      <id>71467</id>
      <parentid>71462</parentid>
      <timestamp>2014-06-11T11:09:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 71462 by [[Special:Contributions/Newatthis|Newatthis]] ([[User talk:Newatthis|talk]]) this isn't the malloc page, this is supposed to show how max_align_t is used (granted, it didn't before, but two different allocations are not related</comment>
      <text xml:space="preserve" bytes="1467">{{c/title|max_align_t}}
{{c/types/navbar}}
{{dcl begin}}
{{dcl header | stddef.h}}
{{dcl | since=c11 |
typedef /*implementation-defined*/ max_align_t;
}}
{{dcl end}}

{{lc|max_align_t}} is a type whose alignment requirement is at least as strict (as large) as that of every scalar type.

===Notes===
Pointers returned by allocation functions such as {{lc|malloc}} are suitably aligned for any object, which means they are aligned at least as strict as {{lc|max_align_t}}.

{{lc|max_align_t}} is usually synonymous with the largest scalar type, which is {{c|long double}} on most platforms, and its alignment requirement is either 8 or 16.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdalign.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;stdint.h&gt;
#include &lt;inttypes.h&gt;
 
int main(void)
{
    size_t a = alignof(max_align_t);
    printf(&quot;Alignment of max_align_t is %zu (%#zx)\n&quot;, a, a);

    int *p = malloc(123);
    printf(&quot;The address obtained from malloc(123) is %#&quot; PRIxPTR&quot;\n&quot;,
            (uintptr_t)p);
    free(p);
}
 | p=true
 | output=
Alignment of max_align_t is 16 (0x10)
The address obtained from malloc(123) is 0x1fa67010
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/types/max_align_t}}
{{dsc end}}

[[de:c/types/max align t]]
[[es:c/types/max align t]]
[[fr:c/types/max align t]]
[[it:c/types/max align t]]
[[ja:c/types/max align t]]
[[pt:c/types/max align t]]
[[ru:c/types/max align t]]
[[zh:c/types/max align t]]</text>
      <sha1>0u7kt826a8omp879nl0n7b76rzicovq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/offsetof</title>
    <ns>0</ns>
    <id>9390</id>
    <revision>
      <id>70954</id>
      <parentid>70922</parentid>
      <timestamp>2014-06-04T12:43:25Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected output</comment>
      <text xml:space="preserve" bytes="1044">{{c/title|offsetof}}
{{c/types/navbar}}
{{dcl begin}}
{{dcl header | stddef.h}}
{{dcl |
#define offsetof(type, member) /*implementation-defined*/
}}
{{dcl end}}

The macro {{lc|offsetof}} expands to a constant of type {{lc|size_t}}, the value of which is the offset, in bytes, from the beginning of an object of specified type to its specified member, including padding if any.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stddef.h&gt;

struct S {
    char c;
    double d;
};

int main(void)
{
    printf(&quot;the first element is at offset %zu\n&quot;, offsetof(struct S, c));
    printf(&quot;the double is at offset %zu\n&quot;, offsetof(struct S, d));
}
 | p=true
 | output=
the first element is at offset 0
the double is at offset 8
}}

===See also===
{{dsc begin}}
{{dsc inc | c/types/dsc size_t}}
{{dsc see cpp | cpp/types/offsetof}}
{{dsc end}}

[[de:c/types/offsetof]]
[[es:c/types/offsetof]]
[[fr:c/types/offsetof]]
[[it:c/types/offsetof]]
[[ja:c/types/offsetof]]
[[pt:c/types/offsetof]]
[[ru:c/types/offsetof]]
[[zh:c/types/offsetof]]</text>
      <sha1>1k5c0h3qvif8taq2ngy6wdnt79z7dth</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/ptrdiff t</title>
    <ns>0</ns>
    <id>9387</id>
    <revision>
      <id>70920</id>
      <parentid>56920</parentid>
      <timestamp>2014-06-03T13:17:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>new example</comment>
      <text xml:space="preserve" bytes="1885">{{c/title|ptrdiff_t}}
{{c/types/navbar}}
{{dcl begin}}
{{dcl header | stddef.h}}
{{dcl |
typedef /*implementation-defined*/ ptrdiff_t;
}}
{{dcl end}}

{{lc|ptrdiff_t}} is the signed integer type of the result of subtracting two pointers.

===Notes===
{{lc|ptrdiff_t}} is used for pointer arithmetic and array indexing, if negative values are possible. Programs that use other types, such as {{c|int}}, may fail on, e.g. 64-bit systems when the index exceeds {{lc|INT_MAX}} or if it relies on 32-bit modular arithmetic.

Only pointers to elements of the same array (including the pointer one past the end of the array) may be subtracted from each other. 

If an array is so large (greater than {{lc|PTRDIFF_MAX}} elements, but less than {{lc|SIZE_MAX}} bytes), that the difference between two pointers may not be representable as {{lc|ptrdiff_t}}, the result of subtracting two such pointers is undefined.

For char arrays shorter than {{lc|PTRDIFF_MAX}}, {{lc|ptrdiff_t}} acts as the signed counterpart of {{lc|size_t}}: it can store the size of the array of any type and is, on most platforms, synonymous with {{lc|intptr_t}}).

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdint.h&gt;

int main(void)
{
    const size_t N = 100;
    int numbers[N];
    
    printf(&quot;PTRDIFF_MAX = %ld\n&quot;, PTRDIFF_MAX);
    int *p1=&amp;numbers[18], *p2=&amp;numbers[23];
    ptrdiff_t diff = p2-p1;
    printf(&quot;p2-p1 = %td\n&quot;, diff);
    
    return 0;
}
 | p=true
 | output=
PTRDIFF_MAX = 9223372036854775807
p2-p1 = 5
}}

===See also===
{{dsc begin}}
{{dsc inc | c/types/dsc size_t}}
{{dsc inc | c/types/dsc offsetof}}
{{dsc see cpp | cpp/types/ptrdiff_t}}
{{dsc end}}

[[de:c/types/ptrdiff t]]
[[es:c/types/ptrdiff t]]
[[fr:c/types/ptrdiff t]]
[[it:c/types/ptrdiff t]]
[[ja:c/types/ptrdiff t]]
[[pt:c/types/ptrdiff t]]
[[ru:c/types/ptrdiff t]]
[[zh:c/types/ptrdiff t]]</text>
      <sha1>db1jhbk2iktosqupb8w9dys1dc898i1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/types/size t</title>
    <ns>0</ns>
    <id>9386</id>
    <revision>
      <id>70919</id>
      <parentid>56923</parentid>
      <timestamp>2014-06-03T13:05:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>new example</comment>
      <text xml:space="preserve" bytes="1696">{{c/title|size_t}}
{{c/types/navbar}}
{{dcl begin}}
{{dcl header | stddef.h}}
{{dcl header | stdio.h}}
{{dcl header | string.h}}
{{dcl header | time.h}}
{{dcl |
typedef /*implementation-defined*/ size_t;
}}
{{dcl end}}

{{lc|size_t}} is the unsigned integer type of the result of the {{ltt|c/language/sizeof}} operator and the {{ltt|c/language/alignof}} operator. 

===Notes===
{{lc|size_t}} can store the maximum size of a theoretically possible object of any type (including array). On many platforms (an exception are systems with segmented addressing)  {{lc|size_t}} can safely store the value of any non-member pointer, in which case it is synonymous with {{lc|uintptr_t}}.

{{lc|size_t}} is commonly used for array indexing and loop counting. Programs that use other types, such as {{c|unsigned int}}, for array indexing may fail on, e.g. 64-bit systems when the index exceeds {{lc|UINT_MAX}} or if it relies on 32-bit modular arithmetic.

===Example===
{{example |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stddef.h&gt;
#include &lt;stdint.h&gt;

int main(void)
{
    const size_t N = 100;
    int numbers[N];
    for (size_t ndx = 0; ndx &lt; N; ++ndx)
        numbers[ndx] = ndx;
    printf(&quot;SIZE_MAX = %lu\n&quot;, SIZE_MAX);
    size_t size = sizeof(numbers);
    printf(&quot;size = %zu\n&quot;, size);
    
    return 0;
}
 | p=true
 | output=
SIZE_MAX = 18446744073709551615
size = 400
}}

===See also===
{{dsc begin}}
{{dsc inc | c/types/dsc ptrdiff_t}}
{{dsc inc | c/types/dsc offsetof}}
{{dsc see cpp | cpp/types/size_t}}
{{dsc end}}

[[de:c/types/size t]]
[[es:c/types/size t]]
[[fr:c/types/size t]]
[[it:c/types/size t]]
[[ja:c/types/size t]]
[[pt:c/types/size t]]
[[ru:c/types/size t]]
[[zh:c/types/size t]]</text>
      <sha1>bez0wk9f6brgnuvdm4dpnam5kzsqhzm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic</title>
    <ns>0</ns>
    <id>13690</id>
    <revision>
      <id>71747</id>
      <parentid>71746</parentid>
      <timestamp>2014-06-22T19:37:01Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C++</comment>
      <text xml:space="preserve" bytes="1778">{{title|Variadic functions}}
{{c/variadic/navbar}}

Variadic functions are functions (e.g. {{lc|printf}}) which take a variable number of arguments.

The declaration of a variadic function uses an ellipsis as the last parameter, e.g. {{c|int printf(const char* format, ...);}}. See [[c/language/variadic_arguments|Variadic arguments]] for additional detail on the syntax and automatic argument conversions.

Accessing the variadic arguments from the function body uses the following library facilities:

{{dsc begin}}
{{dsc header | stdarg.h}}
{{dsc h2 | Macros}}
{{dsc inc | c/variadic/dsc va_start}}
{{dsc inc | c/variadic/dsc va_arg}}
{{dsc inc | c/variadic/dsc va_copy}}
{{dsc inc | c/variadic/dsc va_end}}

{{dsc h2 | Type}}
{{dsc inc | c/variadic/dsc va_list}}
{{dsc end}}

===Example===
{{example
 | Print values of different types.
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;
 
void simple_printf(const char* fmt,...)
{
    va_list args;
    va_start(args, fmt);
 
    while (*fmt != '\0') {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            printf(&quot;%d\n&quot;, i);
        } else if (*fmt == 'c') {
            // note automatic conversion to integral type
            int c = va_arg(args, int);
            printf(&quot;%c\n&quot;, c);
        } else if (*fmt == 'f') {
            double d = va_arg(args, double);
            printf(&quot;%f\n&quot;, d);
        }
        ++fmt;
    }
 
    va_end(args);
}
 
int main(void)
{
    simple_printf(&quot;dcff&quot;, 3, 'a', 1.999, 42.5); 
}
 | output=
3
a
1.999000
42.50000
}}

===See also===
{{dsc begin}}
{{dsc see cpp | cpp/utility/variadic | Variadic functions}}
{{dsc end}}

[[de:c/variadic]]
[[es:c/variadic]]
[[fr:c/variadic]]
[[it:c/variadic]]
[[ja:c/variadic]]
[[pt:c/variadic]]
[[ru:c/variadic]]
[[zh:c/variadic]]</text>
      <sha1>hupw4qtefvnoh6ietvpaloqh71qcyil</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic/va arg</title>
    <ns>0</ns>
    <id>13693</id>
    <revision>
      <id>71762</id>
      <parentid>71761</parentid>
      <timestamp>2014-06-23T19:34:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted see also</comment>
      <text xml:space="preserve" bytes="2272">{{ctitle | n={{trim|va_arg}} }}
{{c/variadic/navbar}}
{{dcl begin}}
{{dcl header | stdarg.h}}
{{dcl | 
T va_arg( va_list ap, T );
}}
{{dcl end}}

The {{tt|va_arg}} macro expands to an expression of type {{tt|T}} that corresponds to the next parameter from the {{lc|va_list}} {{tt|ap}}.

Prior to calling {{tt|va_arg}}, {{tt|ap}} must be initialized by a call to either {{lc|va_start}} or {{lc|va_copy}}, with no intervening call to {{lc|va_end}}.  Each invocation of the {{tt|va_arg}} macro modifies {{tt|ap}} to point to the next variable argument.

If {{tt|va_arg}} is called when there are no more arguments in {{tt|ap}}, or if the type of the next argument in {{tt|ap}} (after promotions) is not compatible with {{tt|T}}, the behavior is undefined, unless:

* one type is a signed integer type, the other type is the corresponding unsigned integer type, and the value is representable in both types; or
* one type is pointer to {{c|void}} and the other is a pointer to a character type.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type}}
{{par | T | the type of the next parameter in {{tt|ap}} }}
{{par end}}

===Expanded value===
the next variable parameter in {{tt|ap}}

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;math.h&gt;

double stddev(int count, ...) 
{
    double sum = 0;
    double sum_sq = 0;
    va_list args;
    va_start(args, count);
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args, double);
        sum += num;
        sum_sq += num*num;
    }
    va_end(args);
    return sqrt(sum_sq/count - (sum/count)*(sum/count));
}

int main(void) 
{
    printf(&quot;%f\n&quot;, stddev(4, 25.0, 27.3, 26.9, 25.7));
}
 | output=
0.920258
}}

===See also===
{{dsc begin}}
{{dsc inc | c/variadic/dsc va_copy}}
{{dsc inc | c/variadic/dsc va_end}}
{{dsc inc | c/variadic/dsc va_list}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc see cpp | cpp/utility/variadic/va_arg | va_arg}}
{{dsc end}}

[[de:cpp/utility/variadic/va arg]]
[[es:cpp/utility/variadic/va arg]]
[[fr:cpp/utility/variadic/va arg]]
[[it:cpp/utility/variadic/va arg]]
[[ja:cpp/utility/variadic/va arg]]
[[pt:cpp/utility/variadic/va arg]]
[[ru:cpp/utility/variadic/va arg]]
[[zh:cpp/utility/variadic/va arg]]</text>
      <sha1>mboodp30k4aiopin31wrkp1x6i79y9l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic/va copy</title>
    <ns>0</ns>
    <id>13696</id>
    <revision>
      <id>71771</id>
      <timestamp>2014-06-23T20:22:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>now with corrected template</comment>
      <text xml:space="preserve" bytes="1973">{{ctitle | n={{trim|va_copy}} }}
{{c/variadic/va_copy/navbar}}
{{dcl begin}}
{{dcl header | stdarg.h}}
{{dcl | since=c99 | 
void va_copy( va_list dest, va_list src );
}}
{{dcl end}}

The {{tt|va_copy}} macro copies {{tt|src}} to {{tt|dest}}.

{{lc|va_end}} should be called on {{tt|dest}} before the function returns or any subsequent re-initialization of {{tt|dest}} (via calls to {{lc|va_start}} or {{lc|va_copy}}).

===Parameters===
{{par begin}}
{{par | dest | an instance of the {{lc|va_list}} type to initialize}}
{{par | src | the source {{lc|va_list}} that will be used to initialize {{tt|dest}} }}
{{par end}}

===Expanded value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;
#include &lt;math.h&gt;

double sample_stddev(int count, ...) 
{
    /* Compute the mean with args1. */
    double sum = 0;
    va_list args1;
    va_start(args1, count);
    va_list args2;
    va_copy(args2, args1);   /* copy va_list object */
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args1, double);
        sum += num;
    }
    va_end(args1);
    double mean = sum / count;

    /* Compute standard deviation with args2 and mean. */
    double sum_sq_diff = 0;
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args2, double);
        sum_sq_diff += (num-mean) * (num-mean);
    }
    va_end(args2);
    return sqrt(sum_sq_diff / count);
}

int main(void) 
{
    printf(&quot;%f\n&quot;, sample_stddev(4, 25.0, 27.3, 26.9, 25.7));
}
 | p=true
 | output=
0.920258
}}

===See also===
{{dsc begin}}
{{dsc inc | c/variadic/dsc va_arg}}
{{dsc inc | c/variadic/dsc va_end}}
{{dsc inc | c/variadic/dsc va_list}}
{{dsc inc | c/variadic/dsc va_start}}
{{dsc see cpp | cpp/utility/variadic/va_copy | va_copy}}
{{dsc end}}

[[de:c/variadic/va copy]]
[[es:c/variadic/va copy]]
[[fr:c/variadic/va copy]]
[[it:c/variadic/va copy]]
[[ja:c/variadic/va copy]]
[[pt:c/variadic/va copy]]
[[ru:c/variadic/va copy]]
[[zh:c/variadic/va copy]]</text>
      <sha1>l3wzaocfdjfftfqxhv52sst2plisjih</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic/va end</title>
    <ns>0</ns>
    <id>13695</id>
    <revision>
      <id>71765</id>
      <timestamp>2014-06-23T19:57:13Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>New page for va_end and checked against n1570:7.16.1.3.</comment>
      <text xml:space="preserve" bytes="1130">{{ctitle | n={{trim|va_end}} }}
{{c/variadic/navbar}}
{{dcl begin}}
{{dcl header | stdarg.h}}
{{dcl | 
void va_end( va_list ap );
}}
{{dcl end}}

The {{tt|va_end}} macro performs cleanup for an {{tt|ap}} object initialized by a call to {{lc|va_start}} or {{lc|va_copy}}.  {{tt|va_end}} may modify {{tt|ap}} so that it is no longer usable.

If there is no corresponding call to {{lc|va_start}} or {{lc|va_copy}}, or if {{tt|va_end}} is not called before a function that calls {{lc|va_start}} or {{lc|va_copy}} returns, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type to clean up}}
{{par end}}

===Expanded value===
(none)

===See also===

{{dsc begin}}
{{dsc inc | c/variadic/dsc va_arg}}
{{dsc inc | c/variadic/dsc va_copy}}
{{dsc inc | c/variadic/dsc va_list}}
{{dsc inc | c/variadic/dsc va_start}}
{{dsc see cpp | cpp/utility/variadic/va_end | va_end}}
{{dsc end}}

[[de:c/variadic/va end]]
[[es:c/variadic/va end]]
[[fr:c/variadic/va end]]
[[it:c/variadic/va end]]
[[ja:c/variadic/va end]]
[[pt:c/variadic/va end]]
[[ru:c/variadic/va end]]
[[zh:c/variadic/va end]]</text>
      <sha1>a8v467cqvmget20tgc7qf9oxwg2trfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic/va list</title>
    <ns>0</ns>
    <id>13691</id>
    <revision>
      <id>71766</id>
      <parentid>71758</parentid>
      <timestamp>2014-06-23T20:01:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>rearranged</comment>
      <text xml:space="preserve" bytes="1056">{{ctitle | n={{trim|va_list}} }}
{{c/variadic/navbar}}
{{ddcl | /* unspecified */ va_list;}}

{{tt|va_list}} is a complete object type suitable for holding the information needed by the macros {{lc|va_start}}, {{lc|va_copy}}, {{lc|va_arg}}, and {{lc|va_end}}.

If a {{tt|va_list}} instance is created, passed to another function, and used via {{lc|va_arg}} in that function, then any subsequent use in the calling function should be preceded by a call to {{lc|va_end}}.

It is legal to pass a pointer to a {{tt|va_list}} object to another function and then use that object after the function returns.

===See also===

{{dsc begin}}
{{dsc inc | c/variadic/dsc va_arg}}
{{dsc inc | c/variadic/dsc va_copy}}
{{dsc inc | c/variadic/dsc va_end}}
{{dsc inc | c/variadic/dsc va_start}}
{{dsc see cpp | cpp/utility/variadic/va_list | va_list}}
{{dsc end}}

[[de:c/variadic/va list]]
[[es:c/variadic/va list]]
[[fr:c/variadic/va list]]
[[it:c/variadic/va list]]
[[ja:c/variadic/va list]]
[[pt:c/variadic/va list]]
[[ru:c/variadic/va list]]
[[zh:c/variadic/va list]]</text>
      <sha1>m47r5m6h52vi2iu5opof69nywdzp0i9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>c/variadic/va start</title>
    <ns>0</ns>
    <id>13692</id>
    <revision>
      <id>71763</id>
      <parentid>71760</parentid>
      <timestamp>2014-06-23T19:36:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Use C, not C++ requirements to the type.</comment>
      <text xml:space="preserve" bytes="1704">{{ctitle | n={{trim|va_start}} }}
{{cp/variadic/va_start/navbar}}
{{dcl begin}}
{{dcl header | stdarg.h}}
{{dcl | 
void va_start( va_list ap, parmN );
}}
{{dcl end}}

The {{tt|va_start}} macro enables access to the variable arguments following the named argument {{tt|parmN}}.  

{{tt|va_start}} should be invoked with an instance to a valid {{lc|va_list}} object {{tt|ap}} before any calls to {{lc|va_arg}}.

If {{tt|parmN}} is declared with {{tt|register}} storage class specifier, with an array type, with a function type, or with a type not compatible with the type that results from default argument promotions, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type}}
{{par | parmN | the named parameter preceding the first variable parameter}}
{{par end}}

===Expanded value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;stdio.h&gt;
#include &lt;stdarg.h&gt;

int add_nums(int count, ...) 
{
    int result = 0;
    va_list args;
    va_start(args, count);
    for (int i = 0; i &lt; count; ++i) {
        result += va_arg(args, int);
    }
    va_end(args);
    return result;
}

int main(void) 
{
    printf(&quot;%d\n&quot;, add_nums(4, 25, 25, 50, 50));
}
 | p=true
 | output=
150
}}

===See also===

{{dsc begin}}
{{dsc inc | c/variadic/dsc va_arg}}
{{dsc inc | c/variadic/dsc va_copy}}
{{dsc inc | c/variadic/dsc va_end}}
{{dsc inc | c/variadic/dsc va_list}}
{{dsc see cpp | cpp/utility/variadic/va_start | va_start}}
{{dsc end}}

[[de:c/variadic/va start]]
[[es:c/variadic/va start]]
[[fr:c/variadic/va start]]
[[it:c/variadic/va start]]
[[ja:c/variadic/va start]]
[[pt:c/variadic/va start]]
[[ru:c/variadic/va start]]
[[zh:c/variadic/va start]]</text>
      <sha1>5god8d0u28wzgz712u71rcbu99fe69j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp</title>
    <ns>0</ns>
    <id>720</id>
    <revision>
      <id>72005</id>
      <parentid>69190</parentid>
      <timestamp>2014-07-08T12:40:06Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>anguage/types now includes void</comment>
      <text xml:space="preserve" bytes="4022">{{title|1=C++ reference}}
{| cellpadding=&quot;5&quot;
|- valign=&quot;top&quot;
| 

'''[[Cppreference:FAQ|FAQ]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/ascii | ASCII chart]]&lt;br/&gt;
[[cpp/compiler_support | Compiler support]]
&lt;/div&gt;

'''[[cpp/language | Language]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/basic_concepts | Basic concepts]]&lt;br&gt;
[[cpp/preprocessor | Preprocessor]]&lt;br&gt;
[[cpp/keyword | Keywords]]&lt;br&gt;
[[cpp/language/operator_precedence | Operator precedence]]&lt;br&gt;
[[cpp/language/escape | Escape sequences]]&lt;br&gt;
[[cpp/language/types | Fundamental types]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/header | Headers]]'''

'''[[cpp/concept | Concepts]]'''

'''[[cpp/utility | Utilities library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/types | Type support]]&lt;br/&gt;&amp;nbsp;&amp;nbsp; (basic types, RTTI, type traits)&lt;br/&gt;
[[cpp/memory | Dynamic memory management]]&lt;br/&gt;
[[cpp/error | Error handling]]&lt;br/&gt;
[[cpp/utility/program | Program utilities]]&lt;br/&gt;
[[cpp/chrono | Date and time]]&lt;br/&gt;
{{ltt|cpp/utility/bitset}}&lt;br/&gt;
[[cpp/utility/functional | Function objects]]&lt;br/&gt;
{{ltt|cpp/utility/pair}}&amp;nbsp;&amp;nbsp;−&amp;nbsp;&amp;nbsp;
{{ltt|cpp/utility/tuple}} {{mark c++11}}&lt;br/&gt;
{{ltt|cpp/utility/integer_sequence}} {{mark c++14}}
&lt;/div&gt;

|

'''[[cpp/string | Strings library]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/string/basic_string}}&lt;br&gt;
[[cpp/string/byte | Null-terminated byte strings]]&lt;br&gt;
[[cpp/string/multibyte | Null-terminated multibyte strings]]&lt;br&gt;
[[cpp/string/wide | Null-terminated wide strings]]
&lt;/div&gt;

'''[[cpp/container | Containers library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/container/array}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/vector}}&lt;br&gt;
{{ltt|cpp/container/deque}}&lt;br&gt;
{{ltt|cpp/container/list}}&lt;br&gt;
{{ltt|cpp/container/forward_list}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/set}}&lt;br&gt;
{{ltt|cpp/container/multiset}}&lt;br&gt;
{{ltt|cpp/container/map}}&lt;br&gt;
{{ltt|cpp/container/multimap}}&lt;br&gt;
{{ltt|cpp/container/unordered_set}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_multiset}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_map}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/unordered_multimap}} {{mark c++11}}&lt;br&gt;
{{ltt|cpp/container/stack}}&lt;br&gt;
{{ltt|cpp/container/queue}}&lt;br&gt;
{{ltt|cpp/container/priority_queue}}
&lt;/div&gt;

'''[[cpp/algorithm | Algorithms library]]'''

'''[[cpp/iterator | Iterators library]]'''

'''[[cpp/numeric | Numerics library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/numeric/math | Common mathematical functions]]&lt;br&gt;
[[cpp/numeric/complex | Complex numbers]]&lt;br&gt;
[[cpp/numeric/random | Pseudo-random number generation]]
&lt;/div&gt;

|

'''[[cpp/io | Input/output library]]'''

&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/io/basic_streambuf}}&lt;br&gt;
{{ltt|cpp/io/basic_filebuf}}&lt;br&gt;
{{ltt|cpp/io/basic_stringbuf}}&lt;br&gt;
{{ltt|cpp/io/ios_base}}&lt;br&gt;
{{ltt|cpp/io/basic_ios}}&lt;br&gt;
{{ltt|cpp/io/basic_istream}}&lt;br&gt;
{{ltt|cpp/io/basic_ostream}}&lt;br&gt;
{{ltt|cpp/io/basic_iostream}}&lt;br&gt;
{{ltt|cpp/io/basic_ifstream}}&lt;br&gt;
{{ltt|cpp/io/basic_ofstream}}&lt;br&gt;
{{ltt|cpp/io/basic_fstream}}&lt;br&gt;
{{ltt|cpp/io/basic_istringstream}}&lt;br&gt;
{{ltt|cpp/io/basic_ostringstream}}&lt;br&gt;
{{ltt|cpp/io/basic_stringstream}}&lt;br&gt;
[[cpp/io/manip | I/O manipulators]]&lt;br&gt;
[[cpp/io/c | C-style I/O ]]
&lt;/div&gt;

'''[[cpp/locale | Localizations library]]'''

'''[[cpp/regex | Regular expression library]]''' {{mark c++11}}

'''[[cpp/atomic | Atomic operations library]]''' {{mark c++11}}

'''[[cpp/thread | Thread support library]]''' {{mark c++11}}
&lt;!--
'''[[cpp/experimental | Experimental standard libraries]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
{{ltt|cpp/experimental/optional}}&amp;nbsp;&amp;nbsp;{{mark since libfund_ts}}&lt;br&gt;
{{ltt|cpp/experimental/any}}&amp;nbsp;&amp;nbsp;{{mark since libfund_ts}}&lt;br&gt;
{{ltt|cpp/experimental/string_view}}&amp;nbsp;&amp;nbsp;{{mark since libfund_ts}}&lt;br&gt;
{{ltt|cpp/experimental/memory_resource}}&amp;nbsp;&amp;nbsp;{{mark since libfund_ts}}&lt;br&gt;
[[cpp/experimental/fs | Filesystem library]]&amp;nbsp;&amp;nbsp;{{mark since fs_ts}}
&lt;/div&gt;
--&gt;
|}

[[ar:cpp]]
[[cs:cpp]]
[[de:cpp]]
[[es:cpp]]
[[fr:cpp]]
[[it:cpp]]
[[ja:cpp]]
[[pl:cpp]]
[[pt:cpp]]
[[ru:cpp]]
[[tr:cpp]]
[[zh:cpp]]</text>
      <sha1>q55kf5u56kzbahkh8gk5yen7v6rdkty</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm</title>
    <ns>0</ns>
    <id>721</id>
    <revision>
      <id>70996</id>
      <parentid>70992</parentid>
      <timestamp>2014-06-04T18:39:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="4826">{{title | Algorithms library}}
{{cpp/algorithm/navbar}}

The algorithms library defines functions for a variety of purposes (e.g. searching, sorting, counting, manipulating) that operate on ranges of elements. Note that a range is defined as {{tt|[first, last)}} where {{tt|last}} refers to the element ''past'' the last element to inspect or modify.

{{dsc begin}}
{{dsc h2 | Non-modifying sequence operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc all_any_none_of}}
{{dsc inc | cpp/algorithm/dsc for_each}}
{{dsc inc | cpp/algorithm/dsc count}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc find_first_of}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc inc | cpp/algorithm/dsc search_n}}

{{dsc h2 | Modifying sequence operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_n}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/algorithm/dsc move}}
{{dsc inc | cpp/algorithm/dsc move_backward}}
{{dsc inc | cpp/algorithm/dsc fill}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/algorithm/dsc transform}}
{{dsc inc | cpp/algorithm/dsc generate}}
{{dsc inc | cpp/algorithm/dsc generate_n}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc inc | cpp/algorithm/dsc remove_copy}}
{{dsc inc | cpp/algorithm/dsc replace}}
{{dsc inc | cpp/algorithm/dsc replace_copy}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/algorithm/dsc swap_ranges}}
{{dsc inc | cpp/algorithm/dsc iter_swap}}
{{dsc inc | cpp/algorithm/dsc reverse}}
{{dsc inc | cpp/algorithm/dsc reverse_copy}}
{{dsc inc | cpp/algorithm/dsc rotate}}
{{dsc inc | cpp/algorithm/dsc rotate_copy}}
{{dsc inc | cpp/algorithm/dsc random_shuffle}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc inc | cpp/algorithm/dsc unique_copy}}

{{dsc h2 | Partitioning operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc is_partitioned}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc inc | cpp/algorithm/dsc partition_copy}}
{{dsc inc | cpp/algorithm/dsc stable_partition}}
{{dsc inc | cpp/algorithm/dsc partition_point}}

{{dsc h2 | Sorting operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc is_sorted}}
{{dsc inc | cpp/algorithm/dsc is_sorted_until}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc inc | cpp/algorithm/dsc nth_element}}

{{dsc h2 | Binary search operations (on sorted ranges)}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc lower_bound}}
{{dsc inc | cpp/algorithm/dsc upper_bound}}
{{dsc inc | cpp/algorithm/dsc binary_search}}
{{dsc inc | cpp/algorithm/dsc equal_range}}

{{dsc h2 | Set operations (on sorted ranges)}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc merge}}
{{dsc inc | cpp/algorithm/dsc inplace_merge}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc set_intersection}}
{{dsc inc | cpp/algorithm/dsc set_symmetric_difference}}
{{dsc inc | cpp/algorithm/dsc set_union}}

{{dsc h2 | Heap operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc is_heap}}
{{dsc inc | cpp/algorithm/dsc is_heap_until}}
{{dsc inc | cpp/algorithm/dsc make_heap}}
{{dsc inc | cpp/algorithm/dsc push_heap}}
{{dsc inc | cpp/algorithm/dsc pop_heap}}
{{dsc inc | cpp/algorithm/dsc sort_heap}}

{{dsc h2 | Minimum/maximum operations}}
{{dsc header | algorithm}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc is_permutation}}
{{dsc inc | cpp/algorithm/dsc next_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}

{{dsc h2 | Numeric operations}}
{{dsc header | numeric}}
{{dsc inc | cpp/algorithm/dsc iota}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc inc | cpp/algorithm/dsc inner_product}}
{{dsc inc | cpp/algorithm/dsc adjacent_difference}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}

{{dsc h2 | C library}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/algorithm/dsc qsort}}
{{dsc inc | cpp/algorithm/dsc bsearch}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/algorithm | Algorithms}}
{{dsc end}}

[[ar:cpp/algorithm]]
[[de:cpp/algorithm]]
[[es:cpp/algorithm]]
[[fr:cpp/algorithm]]
[[it:cpp/algorithm]]
[[ja:cpp/algorithm]]
[[pt:cpp/algorithm]]
[[ru:cpp/algorithm]]
[[tr:cpp/algorithm]]
[[zh:cpp/algorithm]]</text>
      <sha1>hy0w9a9p5hljij7s7fakx81ptmoqku2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/accumulate</title>
    <ns>0</ns>
    <id>722</id>
    <revision>
      <id>66419</id>
      <parentid>56927</parentid>
      <timestamp>2013-11-21T14:38:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>restrictions on the functor: we only had them in std::transform, but they are for 5 functions (LWG 242 was the C++11 change)</comment>
      <text xml:space="preserve" bytes="2844">{{cpp/title|accumulate}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | numeric}}
{{dcl | num=1 |
template&lt; class InputIt, class T &gt;
T accumulate( InputIt first, InputIt last, T init );
}}
{{dcl | num=2 |
template&lt; class InputIt, class T, class BinaryOperation &gt;
T accumulate( InputIt first, InputIt last, T init,
              BinaryOperation op );
}}
{{dcl end}}

Computes the sum of the given value {{tt|init}} and the elements in the range {{tt|[first, last)}}. The first version uses {{tt|operator+}} to sum up the elements, the second version uses the given binary function {{tt|op}}. 

{{rev begin}}
{{rev | until=c++11 |
{{tt|op}} must not have side effects.
}}
{{rev | since=c++11 |
{{tt|op}} must not invalidate any iterators, including the end iterators, or modify any elements of the range involved.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sum}}
{{par | init | initial value of the sum}}
{{par op2 | op | t1=T | p2=InputIt | rt=T}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | T | CopyConstructible | CopyAssignable}}
{{par end}}

===Return value===
The sum of the given value and elements in the given range.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class T&gt;
T accumulate(InputIt first, InputIt last, T init)
{
    for (; first != last; ++first) {
        init = init + *first;
    }
    return init;
}
 | 2=
template&lt;class InputIt, class T, class BinaryOperation&gt;
T accumulate(InputIt first, InputIt last, T init, 
             BinaryOperation op)
{
    for (; first != last; ++first) {
        init = op(init, *first);
    }
    return init;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;numeric&gt;
#include &lt;string&gt;
 
int multiply(int x, int y)
{
    return x*y;
}
 
std::string magic_function(std::string res, int x)
{
    return res += (x &gt; 5) ? &quot;b&quot; : &quot;s&quot;;
}
 
int main()
{
    std::vector&lt;int&gt; v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
    int sum = std::accumulate(v.begin(), v.end(), 0);
    int product = std::accumulate(v.begin(), v.end(), 1, multiply);
    std::string magic = std::accumulate(v.begin(), v.end(), std::string(), 
                                        magic_function);
 
    std::cout &lt;&lt; sum &lt;&lt; '\n'
              &lt;&lt; product &lt;&lt; '\n'
              &lt;&lt; magic &lt;&lt; '\n';
}
 | output=
55
3628800
sssssbbbbb
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc adjacent_difference}}
{{dsc inc | cpp/algorithm/dsc inner_product}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}
{{dsc end}}

[[de:cpp/algorithm/accumulate]]
[[es:cpp/algorithm/accumulate]]
[[fr:cpp/algorithm/accumulate]]
[[it:cpp/algorithm/accumulate]]
[[ja:cpp/algorithm/accumulate]]
[[pt:cpp/algorithm/accumulate]]
[[ru:cpp/algorithm/accumulate]]
[[zh:cpp/algorithm/accumulate]]</text>
      <sha1>mpkltnezw1t94ul3xgiwlocjlunsjnp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/adjacent difference</title>
    <ns>0</ns>
    <id>723</id>
    <revision>
      <id>69690</id>
      <parentid>66418</parentid>
      <timestamp>2014-04-19T22:16:17Z</timestamp>
      <contributor>
        <username>Whit</username>
        <id>3025</id>
      </contributor>
      <comment>Fixed typo in equivalent operation.</comment>
      <text xml:space="preserve" bytes="4075">{{cpp/title|adjacent_difference}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | numeric}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt &gt;
OutputIt adjacent_difference( InputIt first, InputIt last, 
                                    OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt, class OutputIt, class BinaryOperation &gt;
OutputIt adjacent_difference( InputIt first, InputIt last, 
                                    OutputIt d_first,
                                    BinaryOperation op );
}}
{{dcl end}}

Computes the differences between the second and the first of each adjacent pair of elements of the range {{tt|[first, last)}} and writes them to the range beginning at {{tt|d_first + 1}}. Unmodified copy of {{tt|first}} is written to {{tt|d_first}}. The first version uses {{tt|operator-}} to calculate the differences, the second version uses the given binary function {{tt|op}}.

Equivalent operation:

{{source|1=
*(d_first)   = *first;
*(d_first+1) = *(first+1) - *(first);
*(d_first+2) = *(first+2) - *(first+1);
*(d_first+3) = *(first+3) - *(first+2);
...
}}

{{rev begin}}
{{rev | until=c++11 |
{{tt|op}} must not have side effects.
}}
{{rev | since=c++11 |
{{tt|op}} must not invalidate any iterators, including the end iterators, or modify any elements of the ranges involved.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements}}
{{par | d_first | the beginning of the destination range}}
{{par op2 | op | t1=iterator_traits&lt;InputIt&gt;::value_type | rp=OutputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
It to the element past the last element written.

===Complexity===
Exactly {{tt|(last - first) - 1}} applications of the binary operation

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class OutputIt&gt;
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first)
{
    if (first == last) return d_first;

    typedef typename std::iterator_traits&lt;InputIt&gt;::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
    while (++first != last) {
        value_t val = *first;
        *++d_first = val - acc;
        acc = std::move(val);
    }
    return ++d_first;
}
 | 2 =
template&lt;class InputIt, class OutputIt, class BinaryOperation&gt;
OutputIt adjacent_difference(InputIt first, InputIt last, 
                             OutputIt d_first, BinaryOperation op)
{
    if (first == last) return d_first;

    typedef typename std::iterator_traits&lt;InputIt&gt;::value_type value_t;
    value_t acc = *first;
    *d_first = acc;
    while (++first != last) {
        value_t val = *first;
        *++d_first = op(val, acc);
        acc = std::move(val);
    }
    return ++d_first;
}
}}

===Example===
{{example
 | The following code converts a sequence of even numbers to repetitions of the number 2 and converts a sequence of ones to a sequence of Fibonacci numbers.
 | code=
​#include &lt;numeric&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;

int main()
{
    std::vector&lt;int&gt; v{2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
    std::adjacent_difference(v.begin(), v.end(), v.begin());
 
    for (auto n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    v = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
    std::adjacent_difference(v.begin(), v.end() - 1, v.begin() + 1, std::plus&lt;int&gt;());

    for (auto n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}​
 | output=
2 2 2 2 2 2 2 2 2 2
1 1 2 3 5 8 13 21 34 55
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc end}}

[[de:cpp/algorithm/adjacent difference]]
[[es:cpp/algorithm/adjacent difference]]
[[fr:cpp/algorithm/adjacent difference]]
[[it:cpp/algorithm/adjacent difference]]
[[ja:cpp/algorithm/adjacent difference]]
[[pt:cpp/algorithm/adjacent difference]]
[[ru:cpp/algorithm/adjacent difference]]
[[zh:cpp/algorithm/adjacent difference]]</text>
      <sha1>hpi3n3xw1sphp3r1n3tisq25gzcw1c0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/adjacent find</title>
    <ns>0</ns>
    <id>724</id>
    <revision>
      <id>69122</id>
      <parentid>65136</parentid>
      <timestamp>2014-03-28T03:34:53Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3096">{{cpp/title|adjacent_find}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt &gt;
ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, BinaryPredicate p &gt;
ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
}}
{{dcl end}}

Searches the range {{tt|[first, last)}} for two consecutive identical elements. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par pred2 eq | p | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===

an iterator to the first of the identical elements. If no such elements are found, {{tt|last}} is returned

===Complexity===

Exactly the smaller of {{tt|(result - first) + 1}} and {{tt|(last - first) - 1}} applications of the predicate where {{tt|result}} is the return value.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
    if (first == last) {
        return last;
    }
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first) {
        if (*first == *next) {
            return first;
        }
    }
    return last;
}
 | 2=
template&lt;class ForwardIt, BinaryPredicate p&gt;
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, 
                        BinaryPredicate p)
{
    if (first == last) {
        return last;
    }
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first) {
        if (p(*first, *next)) {
            return first;
        }
    }
    return last;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    std::vector&lt;int&gt; v1{0, 1, 2, 3, 40, 40, 41, 41, 5};
 
    auto i1 = std::adjacent_find(v1.begin(), v1.end());
 
    if (i1 == v1.end()) {
        std::cout &lt;&lt; &quot;no matching adjacent elements\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;the first adjacent pair of equal elements at: &quot;
                  &lt;&lt; std::distance(v1.begin(), i1) &lt;&lt; '\n';
    }

    auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater&lt;int&gt;());
    if (i2 == v1.end()) {
        std::cout &lt;&lt; &quot;The entire vector is sorted in ascending order\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;The last element in the non-decreasing subsequence is at: &quot;
                  &lt;&lt; std::distance(v1.begin(), i2) &lt;&lt; '\n';
    }
}
 | output=
The first adjacent pair of equal elements at: 4
The last element in the non-decreasing subsequence is at: 7
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc end}}

[[de:cpp/algorithm/adjacent find]]
[[es:cpp/algorithm/adjacent find]]
[[fr:cpp/algorithm/adjacent find]]
[[it:cpp/algorithm/adjacent find]]
[[ja:cpp/algorithm/adjacent find]]
[[pt:cpp/algorithm/adjacent find]]
[[ru:cpp/algorithm/adjacent find]]
[[zh:cpp/algorithm/adjacent find]]</text>
      <sha1>s7k8tz0j9duhgfowwx5xq2bf6gpl9y3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/all any none of</title>
    <ns>0</ns>
    <id>725</id>
    <revision>
      <id>65839</id>
      <parentid>62635</parentid>
      <timestamp>2013-10-10T09:35:48Z</timestamp>
      <contributor>
        <username>Newacct</username>
        <id>2520</id>
      </contributor>
      <comment>shorter implementations</comment>
      <text xml:space="preserve" bytes="3702">{{cpp/title| all_of | any_of | none_of}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 | num=1 |
template&lt; class InputIt, class UnaryPredicate &gt;
bool all_of( InputIt first, InputIt last, UnaryPredicate p );
}}
{{dcl | since=c++11 | num=2 |
template&lt; class InputIt, class UnaryPredicate &gt;
bool any_of( InputIt first, InputIt last, UnaryPredicate p );
}}
{{dcl | since=c++11 | num=3 |
template&lt; class InputIt, class UnaryPredicate &gt;
bool none_of( InputIt first, InputIt last, UnaryPredicate p );
}}
{{dcl end}}

@1@ Checks if unary predicate {{tt|p}} returns {{c|true}} for all elements in the range {{tt|[first, last)}}.

@2@ Checks if unary predicate {{tt|p}} returns {{c|true}} for at least one element in the range {{tt|[first, last)}}.

@3@ Checks if unary predicate {{tt|p}} returns {{c|true}} for no elements in the range {{tt|[first, last)}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par pred1 | p | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===

@1@ {{c|true}} if unary predicate returns {{c|true}} for all elements in the range, {{c|false}} otherwise. Returns {{c|true}} if the range is empty.

@2@ {{c|true}} if unary predicate returns {{c|true}} for at least one element in the range, {{c|false}} otherwise. Returns {{c|false}} if the range is empty.

@3@ {{c|true}} if unary predicate returns {{c|true}} for no elements in the range, {{c|false}} otherwise. Returns {{c|true}} if the range is empty.

===Complexity===

At most {{tt|last}} - {{tt|first}} applications of the predicate

===Possible implementation===
{{eq fun | 1=
template&lt; class InputIt, class UnaryPredicate &gt;
bool all_of(InputIt first, InputIt last, UnaryPredicate p)
{
    return std::find_if_not(first, last, p) == last;
}
 | 2=
template&lt; class InputIt, class UnaryPredicate &gt;
bool any_of(InputIt first, InputIt last, UnaryPredicate p)
{
    return std::find_if(first, last, p) != last;
}
 | 3=
template&lt; class InputIt, class UnaryPredicate &gt;
bool none_of(InputIt first, InputIt last, UnaryPredicate p)
{
    return std::find_if(first, last, p) == last;
}
}}

===Example===
{{example
 | code=#include &lt;vector&gt;
#include &lt;numeric&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;
 
int main()
{
    std::vector&lt;int&gt; v(10, 2);
    std::partial_sum(v.cbegin(), v.cend(), v.begin());
    std::cout &lt;&lt; &quot;Among the numbers: &quot;;
    std::copy(v.cbegin(), v.cend(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';
 
    if (std::all_of(v.cbegin(), v.cend(), [](int i){ return i % 2 == 0; })) {
        std::cout &lt;&lt; &quot;All numbers are even\n&quot;;
    }
    if (std::none_of(v.cbegin(), v.cend(), std::bind(std::modulus&lt;int&gt;(), 
                                                     std::placeholders::_1, 2))) {
        std::cout &lt;&lt; &quot;None of them are odd\n&quot;;
    }
    struct DivisibleBy
    {
        const int d;
        DivisibleBy(int n) : d(n) {}
        bool operator()(int n) const { return n % d == 0; }
    };
 
    if (std::any_of(v.cbegin(), v.cend(), DivisibleBy(7))) {
        std::cout &lt;&lt; &quot;At least one number is divisible by 7\n&quot;;
    }
}
 | output=Among the numbers: 2 4 6 8 10 12 14 16 18 20 
All numbers are even
None of them are odd
At least one number is divisible by 7
}}

[[de:cpp/algorithm/all any none of]]
[[es:cpp/algorithm/all any none of]]
[[fr:cpp/algorithm/all any none of]]
[[it:cpp/algorithm/all any none of]]
[[ja:cpp/algorithm/all any none of]]
[[pt:cpp/algorithm/all any none of]]
[[ru:cpp/algorithm/all any none of]]
[[zh:cpp/algorithm/all any none of]]</text>
      <sha1>4pu0ah4bn8tthxybq0f2sgyot242q67</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/all of</title>
    <ns>0</ns>
    <id>2544</id>
    <redirect title="cpp/algorithm/all any none of" />
    <revision>
      <id>9314</id>
      <timestamp>2011-08-21T16:07:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/algorithm/all_any_none_of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/any of</title>
    <ns>0</ns>
    <id>2543</id>
    <redirect title="cpp/algorithm/all any none of" />
    <revision>
      <id>9313</id>
      <timestamp>2011-08-21T16:07:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/algorithm/all_any_none_of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/binary search</title>
    <ns>0</ns>
    <id>726</id>
    <revision>
      <id>71650</id>
      <parentid>67346</parentid>
      <timestamp>2014-06-17T19:23:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+formal complexity spec</comment>
      <text xml:space="preserve" bytes="3604">{{cpp/title|binary_search}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
bool binary_search( ForwardIt first, ForwardIt last, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class T, class Compare &gt;
bool binary_search( ForwardIt first, ForwardIt last, const T&amp; value, Compare comp );
}}
{{dcl end}}

Checks if an element equivalent to {{tt|value}} appears within the range {{tt|[first, last)}}.

For {{tt|std::binary_search}} to succeed, the range {{tt|[first, last)}} must be at least partially ordered, i.e. it must satisfy all of the following requirements:
* partitioned with respect to {{c|element &lt; value}} or {{c|comp(element, value)}}
* partitioned with respect to {{c|!(value &lt; element)}} or {{c|!comp(value, element)}}
* for all elements, if {{c|element &lt; value}} or {{c|comp(element, value)}} is {{c|true}} then {{c|!(value &lt; element)}} or {{c|!comp(value, element)}} is also {{c|true}}
A fully-sorted range meets these criteria, as does a range resulting from a call to {{c|std::partition}}.

The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | value | value to compare the elements to}}
{{par cmp ord | comp | t1=T | p2=ForwardIt}}
{{todo|Update type requirements? The types {{c|Type1}} and {{c|Type2}} must be such that an object of type {{c|T}} can be implicitly converted to either type, ''and'' such that an object of type {{c|ForwardIt}} can be dereferenced and then implicitly converted to either type. Generally {{c|Type1}} and {{c|Type2}} will be the same type, although this is not required.}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
{{c|true}} if an element equal to {{tt|value}} is found, {{c|false}} otherwise.

===Complexity===
The number of comparisons performed is logarithmic in the distance between {{tt|first}} and {{tt|last}} (At most {{math|log{{su|b=2}}(last - first) + O(1)}} comparisons)

===Possible implementation===
{{eq fun 
 | 1=
template&lt;class ForwardIt, class T&gt;
bool binary_search(ForwardIt first, ForwardIt last, const T&amp; value)
{
    first = std::lower_bound(first, last, value);
    return (!(first == last) &amp;&amp; !(value &lt; *first));
}
 | 2=
template&lt;class ForwardIt, class T, class Compare&gt;
bool binary_search(ForwardIt first, ForwardIt last, const T&amp; value, Compare comp)
{
    first = std::lower_bound(first, last, value, comp);
    return (!(first == last) &amp;&amp; !(comp(value, *first)));
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; haystack {1, 3, 4, 5, 9};
    std::vector&lt;int&gt; needles {1, 2, 3};

    for (auto needle : needles) {
        std::cout &lt;&lt; &quot;Searching for &quot; &lt;&lt; needle &lt;&lt; '\n';
        if (std::binary_search(haystack.begin(), haystack.end(), needle)) {
            std::cout &lt;&lt; &quot;Found &quot; &lt;&lt; needle &lt;&lt; '\n';
        } else {
            std::cout &lt;&lt; &quot;no dice!\n&quot;;
        }
    }
}
 | output=
Searching for 1
Found 1
Searching for 2
no dice!
Searching for 3
Found 3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc equal_range}}
{{dsc end}}

[[de:cpp/algorithm/binary search]]
[[es:cpp/algorithm/binary search]]
[[fr:cpp/algorithm/binary search]]
[[it:cpp/algorithm/binary search]]
[[ja:cpp/algorithm/binary search]]
[[pt:cpp/algorithm/binary search]]
[[ru:cpp/algorithm/binary search]]
[[zh:cpp/algorithm/binary search]]</text>
      <sha1>cmh07gcuhirjlaz36me5sqsikc024j6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/bsearch</title>
    <ns>0</ns>
    <id>727</id>
    <revision>
      <id>67571</id>
      <parentid>56935</parentid>
      <timestamp>2014-02-12T20:16:25Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for size_t.</comment>
      <text xml:space="preserve" bytes="2656">{{cpp/title|bsearch}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl |
void* bsearch( const void* key, const void* ptr, std::size_t count, std::size_t size,
               int (*comp)(const void*, const void*) );
}}
{{dcl end}}

Finds an element equal to element pointed to by {{tt|key}} in a sorted array pointed to by {{tt|ptr}}. The array contains {{tt|count}} elements of {{tt|size}} bytes. The elements are compared using function pointed to by {{tt|comp}}. 

The behavior is undefined if the array is not already sorted in ascending order according to the same criteria that {{tt|comp}} uses.

If the array contains several elements that {{tt|comp}} would indicate as equal to the element searched for, then it is undefined which element the function will return as the result.

===Parameters===
{{par begin}}
{{par | key | pointer to the element to search for}}
{{par | ptr | pointer to the array to examine}}
{{par | count | number of element in the array}}
{{par | size | size of each element in the array in bytes}}
{{par ccmp | comp | {{tt|key}} is passed as the first argument, an element from the array as the second.}}
{{par end}}

===Return value===
Pointer to the found element or {{lc|NULL}} if the element has not been found.

===Example===
{{example
 |
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;

int compare(const void *ap, const void *bp)
{
    const int *a = (int *) ap;
    const int *b = (int *) bp;
    if(*a &lt; *b)
        return -1;
    else if(*a &gt; *b)
        return 1;
    else
        return 0;
}

int main(int argc, char **argv)
{
    const int ARR_SIZE = 8;
    int arr[ARR_SIZE] = { 1, 2, 3, 4, 5, 6, 7, 8 };

    int key1 = 4;
    int *p1 = (int *) std::bsearch(&amp;key1, arr, ARR_SIZE, sizeof(arr[0]), compare);
    if(p1)
        std::cout &lt;&lt; &quot;value &quot; &lt;&lt; key1 &lt;&lt; &quot; found at position &quot; &lt;&lt; (p1 - arr) &lt;&lt; '\n';
     else
        std::cout &lt;&lt; &quot;value &quot; &lt;&lt; key1 &lt;&lt; &quot; not found\n&quot;;

    int key2 = 9;
    int *p2 = (int *) std::bsearch(&amp;key2, arr, ARR_SIZE, sizeof(arr[0]), compare);
    if(p2)
        std::cout &lt;&lt; &quot;value &quot; &lt;&lt; key2 &lt;&lt; &quot; found at position &quot; &lt;&lt; (p2 - arr) &lt;&lt; '\n';
     else
        std::cout &lt;&lt; &quot;value &quot; &lt;&lt; key2 &lt;&lt; &quot; not found\n&quot;;
}
 | output=
value 4 found at position 3
value 9 not found
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc qsort}}
{{dsc inc | cpp/algorithm/dsc equal_range}}
{{dsc see c | c/algorithm/bsearch}}
{{dsc end}}

[[de:cpp/algorithm/bsearch]]
[[es:cpp/algorithm/bsearch]]
[[fr:cpp/algorithm/bsearch]]
[[it:cpp/algorithm/bsearch]]
[[ja:cpp/algorithm/bsearch]]
[[pt:cpp/algorithm/bsearch]]
[[ru:cpp/algorithm/bsearch]]
[[zh:cpp/algorithm/bsearch]]</text>
      <sha1>5h50jn7k0y93kxto68c7xlks85hj6yo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/copy</title>
    <ns>0</ns>
    <id>728</id>
    <revision>
      <id>69650</id>
      <parentid>68195</parentid>
      <timestamp>2014-04-17T09:58:50Z</timestamp>
      <contributor>
        <username>Alexchamberlain</username>
        <id>1578</id>
      </contributor>
      <comment>Add copy_n to links.</comment>
      <text xml:space="preserve" bytes="4232">{{cpp/title|copy|copy_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt &gt;
OutputIt copy( InputIt first, InputIt last, OutputIt d_first );
}}
{{dcl | num=2 | since=c++11 | 
template&lt; class InputIt, class OutputIt, class UnaryPredicate &gt;
OutputIt copy_if( InputIt first, InputIt last,
                  OutputIt d_first,
                  UnaryPredicate pred );
}}
{{dcl end}}

Copies the elements in the range, defined by {{tt|[first, last)}}, to another range beginning at {{tt|d_first}}. The second function only copies the elements for which the predicate {{tt|pred}} returns {{c|true}}. The order of the elements that are not removed is preserved.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to copy}}
{{par | d_first | the beginning of the destination range. If {{tt|d_first}} is within {{tt|[first, last)}}, {{lc|std::copy_backward}} must be used instead of {{lc|std::copy}}. }}
{{par pred1 | pred | value=true | for the required elements | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===

Output iterator to the element in the destination range, one past the last element copied.

===Complexity===

1) Exactly {{tt|last - first}} assignments

2) Exactly {{tt|last - first}} applications of the predicate

===Notes===
In practice, implementations of {{tt|std::copy}} avoid multiple assignments and use bulk copy functions such as {{lc|std::memmove}} if the value type is {{concept|TriviallyCopyable}}

When copying overlapping ranges, {{tt|std::copy}} is appropriate when copying to the left (beginning of the destination range is outside the source range) while {{tt|std::copy_backward}} is appropriate when copying to the right (end of the destination range is outside the source range).

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class OutputIt&gt;
OutputIt copy(InputIt first, InputIt last, 
              OutputIt d_first)
{
    while (first != last) {
        *d_first++ = *first++;
    }
    return d_first;
}
 | 2=
template&lt;class InputIt, class OutputIt, class UnaryPredicate&gt;
OutputIt copy_if(InputIt first, InputIt last, 
                 OutputIt d_first, UnaryPredicate pred)
{
    while (first != last) {
        if (pred(*first))
            *d_first++ = *first;
        first++;
    }
    return d_first;
}
}}

If you do not have C++11, an equivalent to {{lc|std::copy_if}} is to use {{lc|std::remove_copy_if}} with the negated predicate.
{{eq fun | 1=
template&lt;class InputIt, class OutputIt, class UnaryPredicate&gt;
OutputIt copy_if(InputIt first, InputIt last, 
                 OutputIt d_first, UnaryPredicate pred)
{
    return std::remove_copy_if(first, last, d_first, std::not1(pred));
}
}}

===Example===
{{example
 | The following code uses copy to both copy the contents of one vector to another and to display the resulting vector: 
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;
#include &lt;numeric&gt;

int main()
{
    std::vector&lt;int&gt; from_vector(10);
    std::iota(from_vector.begin(), from_vector.end(), 0);

    std::vector&lt;int&gt; to_vector;
    std::copy(from_vector.begin(), from_vector.end(),
              std::back_inserter(to_vector));
// or, alternatively,
//  std::vector&lt;int&gt; to_vector(from_vector.size());
//  std::copy(from_vector.begin(), from_vector.end(), to_vector.begin());
// either way is equivalent to
//  std::vector&lt;int&gt; to_vector = from_vector;

    std::cout &lt;&lt; &quot;to_vector contains: &quot;;

    std::copy(to_vector.begin(), to_vector.end(),
              std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';
}
 | output=
to_vector contains: 0 1 2 3 4 5 6 7 8 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/algorithm/dsc copy_n}}
{{dsc inc | cpp/algorithm/dsc remove_copy}}
{{dsc end}}

[[de:cpp/algorithm/copy]]
[[es:cpp/algorithm/copy]]
[[fr:cpp/algorithm/copy]]
[[it:cpp/algorithm/copy]]
[[ja:cpp/algorithm/copy]]
[[pt:cpp/algorithm/copy]]
[[ru:cpp/algorithm/copy]]
[[zh:cpp/algorithm/copy]]</text>
      <sha1>4awosw2l30avn1raueqedf2oev8kj9j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/copy backward</title>
    <ns>0</ns>
    <id>729</id>
    <revision>
      <id>69123</id>
      <parentid>65269</parentid>
      <timestamp>2014-03-28T03:37:47Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2424">{{cpp/title|copy_backward}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class BidirIt1, class BidirIt2 &gt;
BidirIt2 copy_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last );
}}
{{dcl end}}

Copies the elements from the range, defined by {{tt|[first, last)}}, to another range ending at {{tt|d_last}}. The elements are copied in reverse order (the last element is copied first), but their relative order is preserved.

The behavior is undefined if {{tt|d_last}} is within {{tt|(first, last]}}. {{lc|std::copy}} must be used instead of {{tt|std::copy_backward}} in that case.

===Parameters===
{{par begin}}
{{par | first, last | the range of the elements to copy}}
{{par | d_last | end of the destination range.. }}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Return value===

iterator to the last element copied.

===Complexity===

Exactly {{tt|last - first}} assignments.

===Notes===

When copying overlapping ranges, {{tt|std::copy}} is appropriate when copying to the left (beginning of the destination range is outside the source range) while {{tt|std::copy_backward}} is appropriate when copying to the right (end of the destination range is outside the source range).

===Possible implementation===
{{eq fun | 1=
template&lt; class BidirIt1, class BidirIt2 &gt;
BidirIt2 copy_backward(BidirIt1 first, BidirIt1 last, BidirIt2 d_last)
{
    while (first != last) {
        *(--d_last) = *(--last);
    }
    return d_last;
}
}}

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    std::vector&lt;int&gt; from_vector;
    for (int i = 0; i &lt; 10; i++) {
        from_vector.push_back(i);
    }
 
    std::vector&lt;int&gt; to_vector(15);
 
    std::copy_backward(from_vector.begin(), from_vector.end(), to_vector.end());
 
    std::cout &lt;&lt; &quot;to_vector contains: &quot;;
    for (unsigned int i = 0; i &lt; to_vector.size(); i++) {
        std::cout &lt;&lt; to_vector[i] &lt;&lt; &quot; &quot;;
    }
 }
 | output=
to_vector contains: 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc end}}

[[de:cpp/algorithm/copy backward]]
[[es:cpp/algorithm/copy backward]]
[[fr:cpp/algorithm/copy backward]]
[[it:cpp/algorithm/copy backward]]
[[ja:cpp/algorithm/copy backward]]
[[pt:cpp/algorithm/copy backward]]
[[ru:cpp/algorithm/copy backward]]
[[zh:cpp/algorithm/copy backward]]</text>
      <sha1>b7qcyvp2m9b56rf2m8tx6jo07xfydmw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/copy if</title>
    <ns>0</ns>
    <id>2513</id>
    <redirect title="cpp/algorithm/copy" />
    <revision>
      <id>9001</id>
      <timestamp>2011-08-18T12:08:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/algorithm/copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/copy n</title>
    <ns>0</ns>
    <id>2509</id>
    <revision>
      <id>69669</id>
      <parentid>66463</parentid>
      <timestamp>2014-04-18T21:31:31Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <comment>std::copy_n is a C++11 function</comment>
      <text xml:space="preserve" bytes="1866">{{cpp/title|copy_n}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 |
template&lt; class InputIt, class Size, class OutputIt &gt;
OutputIt copy_n( InputIt first, Size count, OutputIt result );
}}
{{dcl end}}

Copies exactly {{tt|count}} values from the range beginning at {{tt|first}} to the range beginning at {{tt|result}}, if {{tt|count&gt;0}}. Does nothing otherwise.

===Parameters===
{{par begin}}
{{par | first | the beginning of the range of elements to copy from}}
{{par | count | number of the elements to copy}}
{{par | result | the beginning of the destination range}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Iterator in the destination range, pointing past the last element copied if {{tt|count&gt;0}} or {{tt|result}} otherwise.

===Complexity===

Exactly {{tt|count}} assignments, if {{tt|count&gt;0}}.

===Possible implementation===
{{eq fun | 1=
template&lt; class InputIt, class Size, class OutputIt&gt;
OutputIt copy_n(InputIt first, Size count, OutputIt result)
{
    if (count &gt; 0) {
        *result++ = *first;
        for (Size i = 1; i &lt; count; ++i) {
            *result++ = *++first;
        }
    }
    return result;
}
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    std::string in = &quot;1234567890&quot;;
    std::string out;

    std::copy_n(in.begin(), 4, std::back_inserter(out));
    std::cout &lt;&lt; out &lt;&lt; '\n';
}
 | output=
1234
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc end}}

[[de:cpp/algorithm/copy n]]
[[es:cpp/algorithm/copy n]]
[[fr:cpp/algorithm/copy n]]
[[it:cpp/algorithm/copy n]]
[[ja:cpp/algorithm/copy n]]
[[pt:cpp/algorithm/copy n]]
[[ru:cpp/algorithm/copy n]]
[[zh:cpp/algorithm/copy n]]</text>
      <sha1>8v2lnbwfj5mqrtz8fh9yu8z8zqf2r48</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/count</title>
    <ns>0</ns>
    <id>730</id>
    <revision>
      <id>67013</id>
      <parentid>67012</parentid>
      <timestamp>2014-01-16T19:59:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 67012 by [[Special:Contributions/89.64.227.30|89.64.227.30]] ([[User talk:89.64.227.30|talk]]) no, the range is half-open</comment>
      <text xml:space="preserve" bytes="3256">{{cpp/title|count|count_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class T &gt;
typename iterator_traits&lt;InputIt&gt;::difference_type
    count( InputIt first, InputIt last, const T &amp;value );
}}
{{dcl | num=2 |
template&lt; class InputIt, class UnaryPredicate &gt;
typename iterator_traits&lt;InputIt&gt;::difference_type
    count_if( InputIt first, InputIt last, UnaryPredicate p );
}}
{{dcl end}}

Returns the number of elements in the range {{tt|[first, last)}} satisfying specific criteria. The first version counts the elements that are equal to {{tt|value}}, the second version counts elements for which predicate {{tt|p}} returns {{c|true}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | value | the value to search for}}
{{par pred1 | p | value=true | for the required elements | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
number of elements satisfying the condition.

===Complexity===

exactly {{tt|last}} - {{tt|first}} comparisons / applications of the predicate

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class T&gt;
typename iterator_traits&lt;InputIt&gt;::difference_type
    count(InputIt first, InputIt last, const T&amp; value)
{
    typename iterator_traits&lt;InputIt&gt;::difference_type ret = 0;
    for (; first != last; ++first) {
        if (*first == value) {
            ret++;
        }
    }
    return ret;
}
 | 2=
template&lt;class InputIt, class UnaryPredicate&gt;
typename iterator_traits&lt;InputIt&gt;::difference_type
    count_if(InputIt first, InputIt last, UnaryPredicate p)
{
    typename iterator_traits&lt;InputIt&gt;::difference_type ret = 0;
    for (; first != last; ++first) {
        if (p(*first)) {
            ret++;
        }
    }
    return ret;
}
}}

===Example===
{{example
 | The following code uses {{tt|count}} to determine how many integers in a {{lc|std::vector}} match a target value.
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    int data[] = { 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
    std::vector&lt;int&gt; v(data, data+10);
 
    int target1 = 3;
    int target2 = 5;
    int num_items1 = std::count(v.begin(), v.end(), target1);
    int num_items2 = std::count(v.begin(), v.end(), target2);
 
    std::cout &lt;&lt; &quot;number: &quot; &lt;&lt; target1 &lt;&lt; &quot; count: &quot; &lt;&lt; num_items1 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;number: &quot; &lt;&lt; target2 &lt;&lt; &quot; count: &quot; &lt;&lt; num_items2 &lt;&lt; '\n';
}
 | output=
number: 3 count: 2
number: 5 count: 0
}}
{{example
 | This example uses a [[cpp/language/lambda|lambda expression]] to count elements divisible by 3.
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    int data[] = { 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
    std::vector&lt;int&gt; v(data, data+10);
 
    int num_items1 = std::count_if(v.begin(), v.end(), [](int i) {return i % 3 == 0;});
 
    std::cout &lt;&lt; &quot;number divisible by three: &quot; &lt;&lt; num_items1 &lt;&lt; '\n';
}
 | output=
number divisible by three: 3
}}

[[de:cpp/algorithm/count]]
[[es:cpp/algorithm/count]]
[[fr:cpp/algorithm/count]]
[[it:cpp/algorithm/count]]
[[ja:cpp/algorithm/count]]
[[pt:cpp/algorithm/count]]
[[ru:cpp/algorithm/count]]
[[zh:cpp/algorithm/count]]</text>
      <sha1>52jgrk0ntyr7crbq8fdm4zhr2n32v3w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/count if</title>
    <ns>0</ns>
    <id>2542</id>
    <redirect title="cpp/algorithm/count" />
    <revision>
      <id>9312</id>
      <timestamp>2011-08-21T16:06:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/algorithm/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/equal</title>
    <ns>0</ns>
    <id>731</id>
    <revision>
      <id>72363</id>
      <parentid>72114</parentid>
      <timestamp>2014-08-14T19:58:13Z</timestamp>
      <contributor>
        <username>Emiola</username>
        <id>3320</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4482">{{cpp/title|equal}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2 &gt;
bool equal( InputIt1 first1, InputIt1 last1, 
            InputIt2 first2 );
}}
{{dcl | num=2 | 
template&lt; class InputIt1, class InputIt2, class BinaryPredicate &gt;
bool equal( InputIt1 first1, InputIt1 last1, 
            InputIt2 first2, BinaryPredicate p );
}}
{{dcl | num=3 | since=c++14 |
template&lt; class InputIt1, class InputIt2 &gt;
bool equal( InputIt1 first1, InputIt1 last1, 
            InputIt2 first2, InputIt2 last2 );
}}
{{dcl | num=4 | since=c++14 |
template&lt; class InputIt1, class InputIt2, class BinaryPredicate &gt;
bool equal( InputIt1 first1, InputIt1 last1, 
            InputIt2 first2, InputIt2 last2,
            BinaryPredicate p );
}}
{{dcl end}}

@1,2@ Returns {{c|true}} if the range {{tt|[first1, last1)}} is equal to the range {{tt|[first2, first2 + (last1 - first1))}}, and {{c|false}} otherwise
@3,4@ Returns {{c|true}} if the range {{tt|[first1, last1)}} is equal to the range {{tt|[first2, last2)}}, and {{c|false}} otherwise.

The two ranges are considered equal if, for every iterator {{tt|i}} in the range {{tt|[first1,last1)}}, {{c|*i}} equals {{c|*(first2 + (i - first1))}}. The overloads {{v|1,3}} use {{c|operator{{==}}}} to determine if two elements are equal, whereas overloads {{v|2,4}} use the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of the elements to compare}}
{{par | first2, last2 | the second range of the elements to compare}}
{{par pred2 eq | p | p1=InputIt1 | p2=InputIt2}}
{{par hreq}}
{{par req concept | InputIt1, InputIt2 | InputIterator}}
{{par end}}

===Return value===

@3,4@If the length of the range {{tt|[first1, last1)}} does not equal the length of the range {{tt|[first2, last2)}}, returns {{c|false}}

If the elements in the two ranges are equal, returns {{c|true}}.

Otherwise returns {{c|false}}.

===Notes===

{{tt|std::equal}} may not be used to compare the ranges formed by the iterators from {{lc|std::unordered_set}}, {{lc|std::unordered_multiset}}, {{lc|std::unordered_map}}, or {{lc|std::unordered_multimap}} because the order in which the elements are stored in those containers may be different even if the two containers store the same elements. 

When comparing entire containers for equality, {{tt|operator{{==}}}} for the corresponding container are usually preferred.

===Complexity===
@1,2@At most {{tt|last1}} - {{tt|first1}} applications of the predicate {{tt|p}}
@3,4@At most min({{tt|last1}} - {{tt|first1}}, {{tt|last2}} - {{tt|first2}}) applications of the predicate {{tt|p}}.&lt;br&gt;
However, if {{tt|InputIt1}} and {{tt|InputIt2}} meet the requirements of {{concept|RandomAccessIterator}} and {{c|last1 - first1 !{{=}} last2 - first2}} then no applications of the predicate {{tt|p}} are made.


===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2&gt;
bool equal(InputIt1 first1, InputIt1 last1, 
           InputIt2 first2)
{
    for (; first1 != last1; ++first1, ++first2) {
        if (!(*first1 == *first2)) {
            return false;
        }
    }
    return true;
}
 | 2=
template&lt;class InputIt1, class InputIt2, class BinaryPredicate&gt;
bool equal(InputIt1 first1, InputIt1 last1, 
           InputIt2 first2, BinaryPredicate p)
{
    for (; first1 != last1; ++first1, ++first2) {
        if (!p(*first1, *first2)) {
            return false;
        }
    }
    return true;
}
}}

===Example===
{{example
 | The following code uses {{c|equal()}} to test if a string is a palindrome
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

bool is_palindrome(const std::string&amp; s)
{
    return std::equal(s.begin(), s.begin() + s.size()/2, s.rbegin());
}

void test(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;\&quot;&quot; &lt;&lt; s &lt;&lt; &quot;\&quot; &quot;
        &lt;&lt; (is_palindrome(s) ? &quot;is&quot; : &quot;is not&quot;)
        &lt;&lt; &quot; a palindrome\n&quot;;
}

int main()
{
    test(&quot;radar&quot;);
    test(&quot;hello&quot;);
}
 | output=
&quot;radar&quot; is a palindrome
&quot;hello&quot; is not a palindrome
}}

{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/algorithm/equal]]
[[es:cpp/algorithm/equal]]
[[fr:cpp/algorithm/equal]]
[[it:cpp/algorithm/equal]]
[[ja:cpp/algorithm/equal]]
[[pt:cpp/algorithm/equal]]
[[ru:cpp/algorithm/equal]]
[[zh:cpp/algorithm/equal]]</text>
      <sha1>0f12sgfm7plg4ohtswo4yh36s9jhv1e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/equal range</title>
    <ns>0</ns>
    <id>732</id>
    <revision>
      <id>71649</id>
      <parentid>66424</parentid>
      <timestamp>2014-06-17T19:21:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+formal complexity spec</comment>
      <text xml:space="preserve" bytes="5728">{{cpp/title|equal_range}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
std::pair&lt;ForwardIt,ForwardIt&gt; 
    equal_range( ForwardIt first, ForwardIt last,
                 const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class T, class Compare &gt;
std::pair&lt;ForwardIt,ForwardIt&gt; 
    equal_range( ForwardIt first, ForwardIt last,
                 const T&amp; value, Compare comp );
}}
{{dcl end}}

Returns a range containing all elements equivalent to {{tt|value}} in the range {{tt|[first, last)}}.

The range {{tt|[first, last)}} must be partitioned with respect to comparison with {{tt|value}}, i.e. it must satisfy all of the following requirements:
* partitioned with respect to {{c|element &lt; value}} or {{c|comp(element, value)}}
* partitioned with respect to {{c|!(value &lt; element)}} or {{c|!comp(value, element)}}
* for all elements, if {{c|element &lt; value}} or {{c|comp(element, value)}} is {{c|true}} then {{c|!(value &lt; element)}} or {{c|!comp(value, element)}} is also {{c|true}}
A fully-sorted range meets these criteria, as does a range resulting from a call to {{c|std::partition}}.

The returned range is defined by two iterators, one pointing to the first element that is ''not less'' than {{tt|value}} and another pointing to the first element ''greater'' than {{tt|value}}. The first iterator may be alternatively obtained with {{lc|std::lower_bound()}}, the second - with {{lc|std::upper_bound()}}.

The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.


===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | value | value to compare the elements to}}
{{par | comp | comparison function which returns ​{{c|true}} if the first argument is ''less'' than the second. &lt;br&gt;
The signature of the comparison function should be equivalent to the following:
{{ddcl | 
bool cmp(const Type1 &amp;a, const Type2 &amp;b);
}}
The signature does not need to have {{c|const &amp;}}, but the function must not modify the objects passed to it.&lt;br&gt;
{{tt|cmp}} will be called as both {{tt|cmp(value, *iterator)}} and {{tt|cmp(*iterator, value)}}.
}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
{{lc|std::pair}} containing a pair of iterators defining the wanted range, the first pointing to the first element that is ''not less'' than {{tt|value}} and the second pointing to the first element ''greater'' than {{tt|value}}. 

If there are no elements ''not less'' than {{tt|value}}, {{tt|last}} is returned as the first element. Similarly if there are no elements ''greater'' than {{tt|value}}, {{tt|last}} is returned as the second element

===Complexity===
Logarithmic in the distance between {{tt|first}} and {{tt|last}} (At most {{math|2 * log{{su|b=2}}(last - first) + O(1)}} comparisons.)

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class T&gt;
std::pair&lt;ForwardIt,ForwardIt&gt; 
    equal_range(ForwardIt first, ForwardIt last,
                const T&amp; value)
{
    return std::make_pair(std::lower_bound(first, last, value),
                          std::upper_bound(first, last, value));
}
 | 2=
template&lt;class ForwardIt, class T, class Compare&gt;
std::pair&lt;ForwardIt,ForwardIt&gt; 
    equal_range(ForwardIt first, ForwardIt last,
                const T&amp; value, Compare comp);
{
    return std::make_pair(std::lower_bound(first, last, value, comp),
                          std::upper_bound(first, last, value, comp));
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

struct S
{
    int number;
    char name;

    S ( int number, char name  )
        : number ( number ), name ( name )
    {}

    // only the number is relevant with this comparison
    bool operator&lt; ( const S&amp; s ) const
    {
        return number &lt; s.number;
    }
};


int main()
{
    // note: not ordered, only partitioned w.r.t. S defined below
    std::vector&lt;S&gt; vec {{=}} { {1,'A'}, {2,'B'}, {2,'C'}, {2,'D'}, {4,'G'}, {3,'F'} };

    S value ( 2, '?' );

    auto p {{=}} std::equal_range(vec.begin(),vec.end(),value);

    for ( auto i = p.first; i !{{=}} p.second; ++i )
        std::cout &lt;&lt; i-&gt;name &lt;&lt; ' ';
}


 | output=
B C D
}}

===Example With Comparator===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

struct S
{
    int number;
    char name;

    S ( int number, char name  )
        : number ( number ), name ( name )
    {}

    // only the number is relevant with this comparison
    bool operator&lt; ( const S&amp; s ) const
    {
        return number &lt; s.number;
    }
};

struct Comp
{
    bool operator() ( const S&amp; s, int i )
    {
        return s.number &lt; i;
    }

    bool operator() ( int i, const S&amp; s )
    {
        return i &lt; s.number;
    }
};

int main()
{
    // note: not ordered, only partitioned w.r.t. S defined below
    std::vector&lt;S&gt; vec = { {1,'A'}, {2,'B'}, {2,'C'}, {2,'D'}, {4,'G'}, {3,'F'} };

    auto p = std::equal_range(vec.begin(),vec.end(),2,Comp());

    for ( auto i = p.first; i != p.second; ++i )
        std::cout &lt;&lt; i-&gt;name &lt;&lt; ' ';
}


 | output=
B C D
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc lower_bound}}
{{dsc inc | cpp/algorithm/dsc upper_bound}}
{{dsc inc | cpp/algorithm/dsc binary_search}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc end}}

[[de:cpp/algorithm/equal range]]
[[es:cpp/algorithm/equal range]]
[[fr:cpp/algorithm/equal range]]
[[it:cpp/algorithm/equal range]]
[[ja:cpp/algorithm/equal range]]
[[pt:cpp/algorithm/equal range]]
[[ru:cpp/algorithm/equal range]]
[[zh:cpp/algorithm/equal range]]</text>
      <sha1>qvnnhla9435mg7yz2hu2gpg6epzb94d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/fill</title>
    <ns>0</ns>
    <id>733</id>
    <revision>
      <id>66805</id>
      <parentid>62012</parentid>
      <timestamp>2013-12-31T17:01:07Z</timestamp>
      <contributor>
        <username>Satishgoda</username>
        <id>1041</id>
      </contributor>
      <comment>Replaced the for loop with a range based for loop</comment>
      <text xml:space="preserve" bytes="1650">{{cpp/title|fill}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class ForwardIt, class T &gt;
void fill( ForwardIt first, ForwardIt last, const T&amp; value );
}}
{{dcl end}}

Assigns the given {{tt|value}} to the elements in the range {{tt|[first, last)}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to modify}}
{{par | value | the value to be assigned}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
(none)

===Complexity===

Exactly {{tt|last - first}} assignments.

===Possible implementation===
{{eq fun | 1=
template&lt; class ForwardIt, class T &gt;
void fill(ForwardIt first, ForwardIt last, const T&amp; value)
{
    for (; first != last; ++first) {
        *first = value;
    }
}
}}

===Example===
{{example
 | The following code uses {{tt|fill()}} to set all of the elements of a vector of integers to -1: 
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
 
int main()
{
    int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    std::vector&lt;int&gt; v1(data, data+10);
 
    std::fill(v1.begin(), v1.end(), -1);
 
    for (auto elem : v1) {
        std::cout &lt;&lt; elem &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | output=
-1 -1 -1 -1 -1 -1 -1 -1 -1 -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/algorithm/dsc generate}}
{{dsc inc | cpp/algorithm/dsc transform}}
{{dsc end}}

[[de:cpp/algorithm/fill]]
[[es:cpp/algorithm/fill]]
[[fr:cpp/algorithm/fill]]
[[it:cpp/algorithm/fill]]
[[ja:cpp/algorithm/fill]]
[[pt:cpp/algorithm/fill]]
[[ru:cpp/algorithm/fill]]
[[zh:cpp/algorithm/fill]]</text>
      <sha1>d3hnb26zbviufab8gd6xbyd6ka22ta7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/fill n</title>
    <ns>0</ns>
    <id>734</id>
    <revision>
      <id>66578</id>
      <parentid>66577</parentid>
      <timestamp>2013-12-09T06:30:11Z</timestamp>
      <contributor>
        <username>Ppwwyyxx</username>
        <id>1791</id>
      </contributor>
      <comment>use iterator to print</comment>
      <text xml:space="preserve" bytes="2102">{{cpp/title|fill_n}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class OutputIt, class Size, class T &gt;
void fill_n( OutputIt first, Size count, const T&amp; value );
}}
{{dcl | since=c++11 |
template&lt; class OutputIt, class Size, class T &gt;
OutputIt fill_n( OutputIt first, Size count, const T&amp; value );
}}
{{dcl rev end}}
{{dcl end}}

Assigns the given value {{tt|value}} to the first {{tt|count}} elements in the range beginning at {{tt|first}} if {{tt|count &gt; 0}}. Does nothing otherwise.

===Parameters===
{{par begin}}
{{par | first | the beginning of the range of elements to modify}}
{{par | count | number of elements to modify}}
{{par | value | the value to be assigned}}
{{par hreq}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | Iterator one past the last element assigned if {{tt|count &gt; 0}}, {{tt|first}} otherwise.
}}
{{rev end}}

===Complexity===
Exactly {{tt|count}} assignments, for {{tt|count &gt; 0}}.

===Possible implementation===
{{eq fun | 1=
template&lt;class OutputIt, class Size, class T&gt;
OutputIt fill_n(OutputIt first, Size count, const T&amp; value)
{
    for (Size i = 0; i &lt; count; i++) {
        *first++ = value;
    }
    return first;
}
}}

===Example===
{{example
 | The following code uses {{tt|fill_n()}} to assign -1 to the first half of a vector of integers: 
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
 
int main()
{
    std::vector&lt;int&gt; v1{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
 
    std::fill_n(v1.begin(), 5, -1);
 
    std::copy(begin(v1), end(v1), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | output=
-1 -1 -1 -1 -1 5 6 7 8 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc fill}}
{{dsc end}}

[[de:cpp/algorithm/fill n]]
[[es:cpp/algorithm/fill n]]
[[fr:cpp/algorithm/fill n]]
[[it:cpp/algorithm/fill n]]
[[ja:cpp/algorithm/fill n]]
[[pt:cpp/algorithm/fill n]]
[[ru:cpp/algorithm/fill n]]
[[zh:cpp/algorithm/fill n]]</text>
      <sha1>azo7pyz7hkipkrcjx6dd7r1cu2w9e3a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/find</title>
    <ns>0</ns>
    <id>735</id>
    <revision>
      <id>67867</id>
      <parentid>67164</parentid>
      <timestamp>2014-03-04T03:40:19Z</timestamp>
      <contributor>
        <ip>208.92.17.165</ip>
      </contributor>
      <text xml:space="preserve" bytes="3815">{{cpp/title| find | find_if | find_if_not}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class T &gt;
InputIt find( InputIt first, InputIt last, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class InputIt, class UnaryPredicate &gt;
InputIt find_if( InputIt first, InputIt last, 
                 UnaryPredicate p );
}}
{{dcl | num=3 | since=c++11 |
template&lt; class InputIt, class UnaryPredicate &gt;
InputIt find_if_not( InputIt first, InputIt last, 
                     UnaryPredicate q );
}}
{{dcl end}}

Returns the first element in the range {{tt|[first, last)}} that satisfies specific criteria:

@1@ {{tt|find}} searches for an element equal to {{tt|value}}

@2@ {{tt|find_if}} searches for an element for which predicate {{tt|p}} returns {{c|true}}

@3@ {{tt|find_if_not}} searches for element for which predicate {{tt|q}} returns {{c|false}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | value | value to compare the elements to}}
{{par pred1 | p | value=true | for the required element | p1=InputIt}}
{{par pred1 | q | value=false | for the required element | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
Iterator to the first element satisfying the condition or {{tt|last}} if no such element is found.

===Complexity===
At most {{tt|last}} - {{tt|first}} applications of the predicate

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class T&gt;
InputIt find(InputIt first, InputIt last, const T&amp; value)
{
    for (; first != last; ++first) {
        if (*first == value) {
            return first;
        }
    }
    return last;
}
 | 2=
template&lt;class InputIt, class UnaryPredicate&gt;
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (p(*first)) {
            return first;
        }
    }
    return last;
}
 | 3=
template&lt;class InputIt, class UnaryPredicate&gt;
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
    for (; first != last; ++first) {
        if (!q(*first)) {
            return first;
        }
    }
    return last;
}
}}

If you do not have C++11, an equivalent to {{lc|std::find_if_not}} is to use {{lc|std::find_if}} with the negated predicate.
{{eq fun | 1=
template&lt;class InputIt, class UnaryPredicate&gt;
InputIt find_if_not(InputIt first, InputIt last, UnaryPredicate q)
{
    return std::find_if(first, last, std::not1(q));
}
}}

===Example===
{{example
 | The following example finds an integer in a vector of integers.
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;

int main()
{
    int n1 = 3;
    int n2 = 5;
 
    std::vector&lt;int&gt; v{0, 1, 2, 3, 4};
 
    auto result1 = std::find(std::begin(v), std::end(v), n1);
    auto result2 = std::find(std::begin(v), std::end(v), n2);
 
    if (result1 != std::end(v)) {
        std::cout &lt;&lt; &quot;v contains: &quot; &lt;&lt; n1 &lt;&lt; '\n';
    } else {
        std::cout &lt;&lt; &quot;v does not contain: &quot; &lt;&lt; n1 &lt;&lt; '\n';
    }

    if (result2 != std::end(v)) {
        std::cout &lt;&lt; &quot;v contains: &quot; &lt;&lt; n2 &lt;&lt; '\n';
    } else {
        std::cout &lt;&lt; &quot;v does not contain: &quot; &lt;&lt; n2 &lt;&lt; '\n';
    }
}
 | output=
v contains: 3
v does not contain: 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc find_first_of}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/algorithm/find]]
[[es:cpp/algorithm/find]]
[[fr:cpp/algorithm/find]]
[[it:cpp/algorithm/find]]
[[ja:cpp/algorithm/find]]
[[pt:cpp/algorithm/find]]
[[ru:cpp/algorithm/find]]
[[zh:cpp/algorithm/find]]</text>
      <sha1>7f889czw1wfqcaypmht59kyek2v6zv9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/find end</title>
    <ns>0</ns>
    <id>736</id>
    <revision>
      <id>66912</id>
      <parentid>61917</parentid>
      <timestamp>2014-01-07T22:55:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso to search and includes</comment>
      <text xml:space="preserve" bytes="4284">{{cpp/title|find_end}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
                     ForwardIt2 s_first, ForwardIt2 s_last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt1, class ForwardIt2, class BinaryPredicate &gt;
ForwardIt1 find_end( ForwardIt1 first, ForwardIt1 last,
                     ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
}}
{{dcl end}}

Searches for the last subsequence of elements {{tt|[s_first, s_last)}} in the range {{tt|[first, last)}}. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | s_first, s_last | the range of elements to search for}}
{{par pred2 eq | p | p1=ForwardIt1 | p2=ForwardIt2}}
{{par hreq}}
{{par req concept | ForwardIt1 | ForwardIterator}}
{{par req concept | ForwardIt2 | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the beginning of last subsequence {{tt|[s_first, s_last)}} in range {{tt|[first, last)}}.

{{rev begin}}
{{rev | until=c++11 |
If no such subsequence is found, {{tt|last}} is returned.
}}
{{rev | since=c++11 |
If {{tt|[s_first, s_last)}} is empty or if no such subsequence is found, {{tt|last}} is returned.
}}
{{rev end}}

===Complexity===
Does at most {{tt|S*(N-S+1)}} comparisons where {{c|S {{=}} distance(s_first, s_last)}} and {{c|N {{=}} distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt1, class ForwardIt2&gt;
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 s_first, ForwardIt2 s_last)
{
    if (s_first == s_last)
        return last;
    ForwardIt1 result = last;
    while (1) {
        ForwardIt1 new_result = std::search(first, last, s_first, s_last);
        if (new_result == last) {
            return result;
        } else {
            result = new_result;
            first = result;
            ++first;
        }
    }
    return result;
}
 | 2=
template&lt;class ForwardIt1, class ForwardIt2, class BinaryPredicate&gt;
ForwardIt1 find_end(ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 s_first, ForwardIt2 s_last,
                    BinaryPredicate p)
{
    if (s_first == s_last)
        return last;
    ForwardIt1 result = last;
    while (1) {
        ForwardIt1 new_result = std::search(first, last, s_first, s_last, p);
        if (new_result == last) {
            return result;
        } else {
            result = new_result;
            first = result;
            ++first;
        }
    }
    return result;
}
}}

===Example===
{{example
 | The following code uses {{tt|find_end()}} to search for two different sequences of numbers. 
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v{1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4};
    std::vector&lt;int&gt;::iterator result;
 
    std::vector&lt;int&gt; t1{1, 2, 3};

    result = std::find_end(v.begin(), v.end(), t1.begin(), t1.end());
    if (result == v.end()) {
        std::cout &lt;&lt; &quot;subsequence not found\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;last subsequence is at: &quot;
                  &lt;&lt; std::distance(v.begin(), result) &lt;&lt; &quot;\n&quot;;
    }

    std::vector&lt;int&gt; t2{4, 5, 6};
    result = std::find_end(v.begin(), v.end(), t2.begin(), t2.end());
    if (result == v.end()) {
        std::cout &lt;&lt; &quot;subsequence not found\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;last subsequence is at: &quot; 
                  &lt;&lt; std::distance(v.begin(), result) &lt;&lt; &quot;\n&quot;;
    }
}
 | output=
last subsequence is at: 8
subsequence not found
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc find_first_of}}
{{dsc inc | cpp/algorithm/dsc search_n}}
{{dsc end}}

[[de:cpp/algorithm/find end]]
[[es:cpp/algorithm/find end]]
[[fr:cpp/algorithm/find end]]
[[it:cpp/algorithm/find end]]
[[ja:cpp/algorithm/find end]]
[[pt:cpp/algorithm/find end]]
[[ru:cpp/algorithm/find end]]
[[zh:cpp/algorithm/find end]]</text>
      <sha1>6kxvhwhmj8h99rdcelf9nye4z4zy8pt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/find first of</title>
    <ns>0</ns>
    <id>737</id>
    <revision>
      <id>61921</id>
      <parentid>56957</parentid>
      <timestamp>2013-06-09T16:59:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="3819">{{cpp/title|find_first_of}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last,
                          ForwardIt2 s_first, ForwardIt2 s_last );
}}
{{dcl | since=c++11 |
template&lt; class InputIt, class ForwardIt &gt;
InputIt find_first_of( InputIt first, InputIt last,
                       ForwardIt s_first, ForwardIt s_last );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
template&lt; class ForwardIt1, class ForwardIt2, class BinaryPredicate &gt;
ForwardIt1 find_first_of( ForwardIt1 first, ForwardIt1 last,
                          ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
}}
{{dcl | since=c++11 |
template&lt; class InputIt, class ForwardIt, class BinaryPredicate &gt;
InputIt find_first_of( InputIt first, InputIt last,
                       ForwardIt s_first, ForwardIt s_last, BinaryPredicate p );
}}
{{dcl rev end}}
{{dcl end}}

Searches the range {{tt|[first, last)}} for any of the elements in the range {{tt|[s_first, s_last)}}. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | s_first, s_last | the range of elements to search for}}
{{par pred2 eq | p | p1=ForwardIt1 | p2=ForwardIt2}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | ForwardIt1 | ForwardIterator}}
{{par req concept | ForwardIt2 | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the first element in the range {{tt|[first, last)}} that is equal to an element from the range {{tt|[s_first; s_last)}}. If no such element is found, {{tt|last}} is returned.

===Complexity===
Does at most {{tt|(S*N)}} comparisons where {{c|S {{=}} distance(s_first, s_last)}} and {{c|N {{=}} distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class ForwardIt&gt;
InputIt find_first_of(InputIt first, InputIt last,
                      ForwardIt s_first, ForwardIt s_last)
{
    for (; first != last; ++first) {
        for (ForwardIt it = s_first; it != s_last; ++it) {
            if (*first == *it) {
                return first;
            }
        }
    }
    return last;
}
 | 2=
template&lt;class InputIt, class ForwardIt, class BinaryPredicate&gt;
InputIt find_first_of(InputIt first, InputIt last,
                      ForwardIt s_first, ForwardIt s_last,
                      BinaryPredicate p)
{
    for (; first != last; ++first) {
        for (ForwardIt it = s_first; it != s_last; ++it) {
            if (p(*first, *it)) {
                return first;
            }
        }
    }
    return last;
}
}}

===Example===
{{example
 | The following code searches for any of specified integers in a vector of integers: 
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    std::vector&lt;int&gt; v{0, 2, 3, 25, 5};
    std::vector&lt;int&gt; t{3, 19, 10, 2};
 
    auto result = std::find_first_of(v.begin(), v.end(), t.begin(), t.end());
 
    if (result == v.end()) {
        std::cout &lt;&lt; &quot;no elements of v were equal to 3, 19, 10 or 2\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;found a match at &quot;
                  &lt;&lt; std::distance(v.begin(), result) &lt;&lt; &quot;\n&quot;;
    }
 }
 | output=
found a match at 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc end}}

[[de:cpp/algorithm/find first of]]
[[es:cpp/algorithm/find first of]]
[[fr:cpp/algorithm/find first of]]
[[it:cpp/algorithm/find first of]]
[[ja:cpp/algorithm/find first of]]
[[pt:cpp/algorithm/find first of]]
[[ru:cpp/algorithm/find first of]]
[[zh:cpp/algorithm/find first of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/find if</title>
    <ns>0</ns>
    <id>2540</id>
    <redirect title="cpp/algorithm/find" />
    <revision>
      <id>9310</id>
      <timestamp>2011-08-21T16:05:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/algorithm/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/find if not</title>
    <ns>0</ns>
    <id>2541</id>
    <redirect title="cpp/algorithm/find" />
    <revision>
      <id>9311</id>
      <timestamp>2011-08-21T16:06:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/algorithm/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/for each</title>
    <ns>0</ns>
    <id>738</id>
    <revision>
      <id>66025</id>
      <parentid>61916</parentid>
      <timestamp>2013-10-21T15:23:41Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>separate intro, add a few clarifications to example</comment>
      <text xml:space="preserve" bytes="2650">{{cpp/title|for_each}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class InputIt, class UnaryFunction &gt;
UnaryFunction for_each( InputIt first, InputIt last, UnaryFunction f );
}}
{{dcl end}}

Applies the given function object {{tt|f}} to the result of dereferencing every iterator in the range {{tt|[first, last)}}, in order. 

If {{tt|InputIt}} is a mutable iterator, {{tt|f}} may modify the elements of the range through the dereferenced iterator. If {{tt|f}} returns a result, the result is ignored.

===Parameters===
{{par begin}}
{{par | first, last | the range to apply the function to}}
{{par | f | the unary function object to be applied }}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | UnaryFunction | MoveConstructible | notes=Does not have to be {{concept|CopyConstructible}}}}
{{par end}}

===Return value===
{{rev begin}}
{{rev | until=c++11 | {{tt|f}} }}
{{rev | since=c++11 | {{c|std::move(f)}} }}
{{rev end}}

===Complexity===
Exactly {{tt|last}} - {{tt|first}} applications of {{tt|f}}

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class UnaryFunction&gt;
UnaryFunction for_each(InputIt first, InputIt last, UnaryFunction f)
{
    for (; first != last; ++first) {
        f(*first);
    }
    return f;
}
}}

===Example===
{{example
 | The following example uses a [[cpp/language/lambda|lambda function]] to increment all of the elements of a vector and then uses an overloaded {{tt|operator()}} in a functor to compute their sum:
 | code=
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iostream&gt;

struct Sum {
    Sum() { sum = 0; }
    void operator()(int n) { sum += n; }

    int sum;
};

int main()
{
    std::vector&lt;int&gt; nums{3, 4, 2, 9, 15, 267};

    std::cout &lt;&lt; &quot;before: &quot;;
    for (auto n : nums) {
        std::cout &lt;&lt; n &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';

    std::for_each(nums.begin(), nums.end(), [](int &amp;n){ n++; });

    // Calls Sum::operator() for each number
    Sum s = std::for_each(nums.begin(), nums.end(), Sum());

    std::cout &lt;&lt; &quot;after:  &quot;;
    for (auto n : nums) {
        std::cout &lt;&lt; n &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;sum: &quot; &lt;&lt; s.sum &lt;&lt; '\n';
}
 | output=
before: 3 4 2 9 15 267
after:  4 5 3 10 16 268
sum: 306
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc transform}}
{{dsc inc | cpp/language/dsc range-for}}
{{dsc end}}

[[de:cpp/algorithm/for each]]
[[es:cpp/algorithm/for each]]
[[fr:cpp/algorithm/for each]]
[[it:cpp/algorithm/for each]]
[[ja:cpp/algorithm/for each]]
[[pt:cpp/algorithm/for each]]
[[ru:cpp/algorithm/for each]]
[[zh:cpp/algorithm/for each]]</text>
      <sha1>po585e7b9zalsqjqa9vt58sradqol4b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/generate</title>
    <ns>0</ns>
    <id>739</id>
    <revision>
      <id>71658</id>
      <parentid>65985</parentid>
      <timestamp>2014-06-18T04:47:56Z</timestamp>
      <contributor>
        <ip>60.242.183.100</ip>
      </contributor>
      <comment>Added iota example</comment>
      <text xml:space="preserve" bytes="2014">{{cpp/title|generate}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class ForwardIt, class Generator &gt;
void generate( ForwardIt first, ForwardIt last, Generator g );
}}
{{dcl end}}

Assigns each element in range {{tt|[first, last)}} a value generated by the given function object {{tt|g}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to generate}}
{{par gen | g | rp=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
(none)

===Complexity===

Exactly {{c|std::distance(first, last)}} invocations of {{tt|g()}} and assignments.

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt, class Generator&gt;
void generate(ForwardIt first, ForwardIt last, Generator g)
{
    while (first != last) {
        *first++ = g();
    }
}
}}

===Example===
{{example
 | The following code fills a vector with random numbers:
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
 
int main()
{
    std::vector&lt;int&gt; v(5);
    std::generate(v.begin(), v.end(), std::rand); // Using the C function rand()
 
    std::cout &lt;&lt; &quot;v: &quot;;
    for (auto iv: v) {
        std::cout &lt;&lt; iv &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; &quot;\n&quot;;

    // Initialize with default values 0,1,2,3,4 from a lambda function
    // Equivalent to std::iota(v.begin(), v.end(), 0);
    int n(0);
    std::generate(v.begin(), v.end(), [&amp;]{ return n++; }); 
    
    std::cout &lt;&lt; &quot;v: &quot;;
    for (auto iv: v) {
        std::cout &lt;&lt; iv &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | p=true
 | output=
v: 52894 15984720 41513563 41346135 51451456
v: 0 1 2 3 4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc fill}}
{{dsc inc | cpp/algorithm/dsc generate_n}}
{{dsc end}}

[[de:cpp/algorithm/generate]]
[[es:cpp/algorithm/generate]]
[[fr:cpp/algorithm/generate]]
[[it:cpp/algorithm/generate]]
[[ja:cpp/algorithm/generate]]
[[pt:cpp/algorithm/generate]]
[[ru:cpp/algorithm/generate]]
[[zh:cpp/algorithm/generate]]</text>
      <sha1>a2gylsaxrccd2i8xuapc1icpiafcyok</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/generate n</title>
    <ns>0</ns>
    <id>740</id>
    <revision>
      <id>61924</id>
      <parentid>61922</parentid>
      <timestamp>2013-06-09T17:01:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+rev</comment>
      <text xml:space="preserve" bytes="2313">{{cpp/title|generate_n}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class OutputIt, class Size, class Generator &gt;
void generate_n( OutputIt first, Size count, Generator g );
}}
{{dcl | since=c++11 |
template&lt; class OutputIt, class Size, class Generator &gt;
OutputIt generate_n( OutputIt first, Size count, Generator g );
}}
{{dcl rev end}}
{{dcl end}}

Assigns values, generated by given function object {{tt|g}}, to the first {{tt|count}} elements in the range beginning at {{tt|first}}, if {{tt|count&gt;0}}. Does nothing otherwise.

===Parameters===
{{par begin}}
{{par | first | the beginning of the range of elements to generate}}
{{par | count | number of the elements to generate}}
{{par gen | g | rp=OutputIt}}
{{par hreq}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | Iterator one past the last element assigned if {{tt|count&gt;0}}, {{tt|first}} otherwise.
}}
{{rev end}}

===Complexity===
Exactly {{tt|count}} invocations of {{tt|g()}} and assignments, for {{tt|count&gt;0}}.

===Possible implementation===
{{eq fun | 1=
template&lt; class OutputIt, class Size, class Generator &gt;
OutputIt generate_n( OutputIt first, Size count, Generator g )
{
    for( Size i = 0; i &lt; count; i++ ) {
        *first++ = g();
    }
    return first;
}
}}

===Example===
{{example
 | The following code fills an array of integers with random numbers. 
 | code=
#include &lt;cstddef&gt;
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
 
int main()
{
    const std::size_t N = 5;
    int ar[N];
    std::generate_n(ar, N, std::rand); // Using the C function rand()
 
    std::cout &lt;&lt; &quot;ar: &quot;;
    std::copy(ar, ar+N, std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | p=true
 | output=
ar: 52894 15984720 41513563 41346135 51451456
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/algorithm/dsc generate}}
{{dsc end}}

[[de:cpp/algorithm/generate n]]
[[es:cpp/algorithm/generate n]]
[[fr:cpp/algorithm/generate n]]
[[it:cpp/algorithm/generate n]]
[[ja:cpp/algorithm/generate n]]
[[pt:cpp/algorithm/generate n]]
[[ru:cpp/algorithm/generate n]]
[[zh:cpp/algorithm/generate n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/includes</title>
    <ns>0</ns>
    <id>741</id>
    <revision>
      <id>69140</id>
      <parentid>67347</parentid>
      <timestamp>2014-03-28T15:52:34Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4025">{{cpp/title|includes}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2 &gt;
bool includes( InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2 );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2 &gt;
bool includes( InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2, Compare comp );
}}
{{dcl end}}

Returns {{c|true}} if every element from the sorted range {{tt|[first2, last2)}} is found within the sorted range {{tt|[first1, last1)}}. Also returns {{c|true}} if {{tt|[first2, last2)}} is empty. 

The first version expects both ranges to be sorted with {{c|operator&lt;}}, the second version expects them to be sorted with the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first1, last1 | the sorted range of elements to examine}}
{{par | first2, last2 | the sorted range of elements to search for}}
{{par cmp ord | comp | p1=InputIt}} 
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
{{c|true}} if every element from {{tt|[first2, last2)}} is a member of {{tt|[first, last)}}.

===Complexity===
At most {{math|2&amp;middot;(N&lt;sub&gt;1&lt;/sub&gt;+N&lt;sub&gt;2&lt;/sub&gt;-1)}} comparisons, where {{math|N&lt;sub&gt;1&lt;/sub&gt;}} {{c|{{=}} std::distance(first1, last1)}} and {{math|N&lt;sub&gt;2&lt;/sub&gt;}} {{c|{{=}} std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2&gt;
bool includes(InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2)
{
    for (; first2 != last2; ++first1)
    {
        if (first1 == last1 {{!!}} *first2 &lt; *first1)
            return false;
        if ( !(*first1 &lt; *first2) )
            ++first2;
    }
    return true;
}
 | 2=
template&lt;class InputIt1, class InputIt2&gt;
bool includes(InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2, Compare comp)
{
    for (; first2 != last2; ++first1)
    {
        if (first1 == last1 {{!!}} comp(*first2, *first1))
            return false;
        if (!comp(*first1, *first2))
            ++first2;
    }
    return true;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;cctype&gt;
#include &lt;vector&gt;

int main()
{
  std::vector&lt;char&gt; v1 {'a', 'b', 'c', 'f', 'h', 'x'};
  std::vector&lt;char&gt; v2 {'a', 'b', 'c'};
  std::vector&lt;char&gt; v3 {'a', 'c'};
  std::vector&lt;char&gt; v4 {'g'};
  std::vector&lt;char&gt; v5 {'a', 'c', 'g'};
  std::vector&lt;char&gt; v6;

  for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;includes:\n&quot;;

  for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot; &lt;&lt; std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) &lt;&lt; '\n';
  for (auto i : v3) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot; &lt;&lt; std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) &lt;&lt; '\n';
  for (auto i : v4) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot; &lt;&lt; std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) &lt;&lt; '\n';
  for (auto i : v5) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot; &lt;&lt; std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) &lt;&lt; '\n';
  for (auto i : v6) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot; &lt;&lt; std::includes(v1.begin(), v1.end(), v6.begin(), v6.end()) &lt;&lt; '\n';

  auto cmp_nocase = [](char a, char b) {
    return std::tolower(a) &lt; std::tolower(b);
  };
  std::vector&lt;char&gt; v7 {'A', 'B', 'C'};
  for (auto i : v7) std::cout &lt;&lt; i &lt;&lt; ' ';
  std::cout &lt;&lt; &quot;: &quot;
            &lt;&lt; std::includes(v1.begin(), v1.end(), v7.begin(), v7.end(), cmp_nocase)
            &lt;&lt; '\n';
}
 | output=
a b c f h x includes:
a b c : 1
a c : 1
g : 0
a c g : 0
A B C : 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/algorithm/includes]]
[[es:cpp/algorithm/includes]]
[[fr:cpp/algorithm/includes]]
[[it:cpp/algorithm/includes]]
[[ja:cpp/algorithm/includes]]
[[pt:cpp/algorithm/includes]]
[[ru:cpp/algorithm/includes]]
[[zh:cpp/algorithm/includes]]</text>
      <sha1>ngexhhzm40ki9y0g8ibiz3e45h7im62</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/inner product</title>
    <ns>0</ns>
    <id>742</id>
    <revision>
      <id>66417</id>
      <parentid>65308</parentid>
      <timestamp>2013-11-21T14:38:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>restrictions on the functor: we only had them in std::transform, but they are for 5 functions (LWG 242 was the C++11 change)</comment>
      <text xml:space="preserve" bytes="3753">{{cpp/title|inner_product}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | numeric}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class T &gt;
T inner_product( InputIt1 first1, InputIt1 last1,
                 InputIt2 first2, T value );
}}
{{dcl | num=2 |
template&lt;
    class InputIt1,
    class InputIt2,
    class T,
    class BinaryOperation1,
    class BinaryOperation2
&gt; T inner_product( InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, T value,
                   BinaryOperation1 op1,
                   BinaryOperation2 op2 );
}}
{{dcl end}}

Computes inner product (i.e. sum of products) of the range {{tt|[first1, last1)}} and another range beginning at {{tt|first2}}. The first version uses {{tt|operator*}} to compute product of the element pairs and {{tt|operator+}} to sum up the products, the second version uses {{tt|op2}} and {{tt|op1}} for these tasks respectively.

{{rev begin}}
{{rev | until=c++11 |
{{tt|op1}} and {{tt|op2}} must not have side effects.
}}
{{rev | since=c++11 |
{{tt|op1}} and {{tt|op2}} must not invalidate any iterators, including the end iterators, or modify any elements of the ranges involved.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements}}
{{par | first2 | the beginning of the second range of elements}}
{{par | value | initial value of the sum of the products}}
{{par op2 | op1 | This &quot;sum&quot; function takes a value returned by op2 and the current value of the accumulator and produces a new value to be stored in the accumulator. | t1=T | t2=Type3 | rt=T}}
{{par op2 | op2 | This &quot;product&quot; function takes one value from each range and produces a new value. | p1=InputIt1 | p2=InputIt2 | rt=Type3}}
{{par hreq}}
{{par req concept | InputIt1, InputIt2 | InputIterator}}
{{par req concept | T | CopyConstructible | CopyAssignable}}
{{par end}}

===Return value===
The inner product of two ranges.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2, class T&gt;
T inner_product(InputIt1 first1, InputIt1 last1,
                InputIt2 first2, T value)
{
    while (first1 != last1) {
         value = value + *first1 * *first2;
         ++first1;
         ++first2;
    }
    return value;
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class T,
         class BinaryOperation1, class BinaryOperation2&gt;
T inner_product(InputIt1 first1, InputIt1 last1,
                InputIt2 first2, T value,
                BinaryOperation1 op1
                BinaryOperation2 op2)
{
    while (first1 != last1) {
         value = op1(value, op2(*first1, *first2));
         ++first1;
         ++first2;
    }
    return value;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;numeric&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;functional&gt;
int main()
{
    std::vector&lt;int&gt; a{0, 1, 2, 3, 4};
    std::vector&lt;int&gt; b{5, 4, 2, 3, 1};

    int r1 = std::inner_product(a.begin(), a.end(), b.begin(), 0);
    std::cout &lt;&lt; &quot;Inner product of a and b: &quot; &lt;&lt; r1 &lt;&lt; '\n';

    int r2 = std::inner_product(a.begin(), a.end(), b.begin(), 0,
                                std::plus&lt;int&gt;(), std::equal_to&lt;int&gt;());
    std::cout &lt;&lt; &quot;Number of pairwise matches between a and b: &quot; &lt;&lt;  r2 &lt;&lt; '\n';
}
 | output=
Inner product of a and b: 21
Number of pairwise matches between a and b: 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}
{{dsc end}}

[[de:cpp/algorithm/inner product]]
[[es:cpp/algorithm/inner product]]
[[fr:cpp/algorithm/inner product]]
[[it:cpp/algorithm/inner product]]
[[ja:cpp/algorithm/inner product]]
[[pt:cpp/algorithm/inner product]]
[[ru:cpp/algorithm/inner product]]
[[zh:cpp/algorithm/inner product]]</text>
      <sha1>dz2yj91r0l4g19kikdvmkozyq8hnm96</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/inplace merge</title>
    <ns>0</ns>
    <id>743</id>
    <revision>
      <id>67348</id>
      <parentid>56969</parentid>
      <timestamp>2014-02-05T20:28:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="2586">{{cpp/title|inplace_merge}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class BidirIt &gt;
void inplace_merge( BidirIt first, BidirIt middle, BidirIt last );
}}
{{dcl | num=2 |
template&lt; class BidirIt, class Compare&gt;
void inplace_merge( BidirIt first, BidirIt middle, BidirIt last, Compare comp );
}}
{{dcl end}}

Merges two consecutive sorted ranges {{tt|[first, middle)}} and {{tt|[middle, last)}} into one sorted range {{tt|[first, last)}}. The order of equal elements is guaranteed to be preserved. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first | the beginning of the first sorted range }}
{{par | middle | the end of the first sorted range and the beginning of the second }}
{{par | last | the end of the second sorted range }}
{{par cmp ord | comp | p1=BidirIt}} 
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator | ValueSwappable}}
{{par req concept deref | BidirIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
Exactly {{math|N-1}} comparisons if enough additional memory is available, otherwise {{math|N&amp;middot;log(N)}} where {{c|1=N = std::distance(first, last)}}.

===Notes===
This function attempts to allocate a temporary buffer, typically by calling {{lc|std::get_temporary_buffer}}. If the allocation fails, the less efficient algorithm is chosen.

===Example===
{{example
 | The following code is an implementation of merge sort.
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;

template&lt;class Iter&gt;
void merge_sort(Iter first, Iter last)
{
    if (last - first &gt; 1) {
        Iter middle = first + (last - first) / 2;
        merge_sort(first, middle);
        merge_sort(middle, last);
        std::inplace_merge(first, middle, last);
    }
}

int main()
{
    std::vector&lt;int&gt; v{8, 2, -2, 0, 11, 11, 1, 7, 3};
    merge_sort(v.begin(), v.end());
    for(auto n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
-2 0 1 2 3 7 8 11 11
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc merge}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc end}}

[[de:cpp/algorithm/inplace merge]]
[[es:cpp/algorithm/inplace merge]]
[[fr:cpp/algorithm/inplace merge]]
[[it:cpp/algorithm/inplace merge]]
[[ja:cpp/algorithm/inplace merge]]
[[pt:cpp/algorithm/inplace merge]]
[[ru:cpp/algorithm/inplace merge]]
[[zh:cpp/algorithm/inplace merge]]</text>
      <sha1>gaw1zg44k9mzxt6xp2f55ahxb1d3by5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/iota</title>
    <ns>0</ns>
    <id>2526</id>
    <revision>
      <id>67293</id>
      <parentid>62639</parentid>
      <timestamp>2014-02-03T18:32:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>frequently-asked question</comment>
      <text xml:space="preserve" bytes="2697">{{cpp/title|iota}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | numeric}}
{{dcl | since=c++11 |
template&lt; class ForwardIterator, class T &gt;
void iota( ForwardIterator first, ForwardIterator last, T value );
}}
{{dcl end}}

Fills the range {{tt|[first, last)}} with sequentially increasing values, starting with {{tt|value}} and repetitively evaluating {{c|++value}}.

Equivalent operation:

{{source|1=
*(d_first)   = value;
*(d_first+1) = ++value;
*(d_first+2) = ++value;
*(d_first+3) = ++value;
...
}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to fill with sequentially increasing values starting with value }}
{{par | value | initial value to store, the expression ++value must be well-formed }}
{{par end}}

===Return value===
(none)

===Complexity===
Exactly {{tt|last - first}} increments and assignments.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIterator, class T&gt;
void iota(ForwardIterator first, ForwardIterator last, T value)
{
    while(first != last) {
        *first++ = value;
        ++value;
    }
}
}}

===Notes===
The function is named after the integer function ⍳ &lt;!-- U+2373 APL FUNCTIONAL SYMBOL IOTA --&gt; from the programming language APL. It was one of the [http://www.sgi.com/tech/stl/iota.html STL components] that were not included in C++98, but eventually made it into the standard library in C++11.

===Example===
{{example
 | The following example applies {{lc|std::random_shuffle}} to a vector of iterators to a {{lc|std::list}} since {{lc|std::random_shuffle}} cannot be applied to an {{lc|std::list}} directly. {{lc|std::iota}} is used to create the vector.
 | code=
#include &lt;numeric&gt;
#include &lt;algorithm&gt;
#include &lt;list&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

int main()
{
    std::list&lt;int&gt; l(10);
    std::iota(l.begin(), l.end(), -4);

    std::vector&lt;std::list&lt;int&gt;::iterator&gt; v(l.size());
    std::iota(v.begin(), v.end(), l.begin());

    std::random_shuffle(v.begin(), v.end());

    std::cout &lt;&lt; &quot;Contents of the list: &quot;;
    for(auto n: l) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;Contents of the list, shuffled: &quot;;
    for(auto i: v) {
        std::cout &lt;&lt; *i &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
Contents of the list: -4 -3 -2 -1 0 1 2 3 4 5
Contents of the list, shuffled: 0 -1 3 4 -4 1 -2 -3 2 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc fill}}
{{dsc inc | cpp/algorithm/dsc generate}}
{{dsc end}}

[[de:cpp/algorithm/iota]]
[[es:cpp/algorithm/iota]]
[[fr:cpp/algorithm/iota]]
[[it:cpp/algorithm/iota]]
[[ja:cpp/algorithm/iota]]
[[pt:cpp/algorithm/iota]]
[[ru:cpp/algorithm/iota]]
[[zh:cpp/algorithm/iota]]</text>
      <sha1>svso0t4uwi8tdxgv84goe5sk5cwi71m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is heap</title>
    <ns>0</ns>
    <id>744</id>
    <revision>
      <id>69141</id>
      <parentid>66009</parentid>
      <timestamp>2014-03-28T15:54:04Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1885">{{cpp/title|is_heap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | since=c++11 |
template&lt; class RandomIt &gt;
bool is_heap( RandomIt first, RandomIt last );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class RandomIt, class Compare &gt;
bool is_heap( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Checks if the elements in range {{tt|[first, last)}} are a ''max heap''. 

The first version of {{tt|is_heap}} uses {{c|operator&lt;}} to compare elements, whereas the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator}}
{{par end}}

===Return value===
{{c|true}} if the range is ''max heap'', {{c|false}} otherwise.

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Notes===
{{cpp/algorithm/notes heap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v { 3, 1, 4, 1, 5, 9 };

    std::cout &lt;&lt; &quot;initially, v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    if (!std::is_heap(v.begin(), v.end())) {
        std::cout &lt;&lt; &quot;making heap...\n&quot;;
        std::make_heap(v.begin(), v.end());
    }

    std::cout &lt;&lt; &quot;after make_heap, v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
initially, v: 3 1 4 1 5 9 
making heap...
after make_heap, v: 9 5 4 1 1 3 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_heap_until}}
{{dsc end}}

[[de:cpp/algorithm/is heap]]
[[es:cpp/algorithm/is heap]]
[[fr:cpp/algorithm/is heap]]
[[it:cpp/algorithm/is heap]]
[[ja:cpp/algorithm/is heap]]
[[pt:cpp/algorithm/is heap]]
[[ru:cpp/algorithm/is heap]]
[[zh:cpp/algorithm/is heap]]</text>
      <sha1>38umniwo4bedums7jgf1vhp23gqtksh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is heap until</title>
    <ns>0</ns>
    <id>745</id>
    <revision>
      <id>69142</id>
      <parentid>63737</parentid>
      <timestamp>2014-03-28T15:55:42Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2182">{{cpp/title|is_heap_until}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | since=c++11 |
template&lt; class RandomIt &gt;
RandomIt is_heap_until( RandomIt first, RandomIt last );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class RandomIt, class Compare &gt;
RandomIt is_heap_until( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Examines the range {{tt|[first, last)}} and finds the largest range beginning at {{tt|first}} which is a ''max heap''. The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator}}
{{par end}}

===Return value===
The upper bound of the largest range beginning at {{tt|first}} which is a ''max heap''. That is, the last iterator {{tt|it}} for which range {{tt|[first, it)}} is a ''max heap''.

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Notes===
{{cpp/algorithm/notes heap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v { 3, 1, 4, 1, 5, 9 };

    std::make_heap(v.begin(), v.end());

    // probably mess up the heap
    v.push_back(2);
    v.push_back(6);

    auto heap_end = std::is_heap_until(v.begin(), v.end());

    std::cout &lt;&lt; &quot;all of v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;only heap: &quot;;
    for (auto i = v.begin(); i != heap_end; ++i) std::cout &lt;&lt; *i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
all of v:  9 5 4 1 1 3 2 6 
only heap: 9 5 4 1 1 3 2 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_heap}}
{{dsc end}}

&lt;!-- Language links go here --&gt;
{{lang}}

[[de:cpp/algorithm/is heap until]]
[[es:cpp/algorithm/is heap until]]
[[fr:cpp/algorithm/is heap until]]
[[it:cpp/algorithm/is heap until]]
[[ja:cpp/algorithm/is heap until]]
[[pt:cpp/algorithm/is heap until]]
[[ru:cpp/algorithm/is heap until]]
[[zh:cpp/algorithm/is heap until]]</text>
      <sha1>r4wczaedyt9rw58p25wigh191oc8dsq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is partitioned</title>
    <ns>0</ns>
    <id>2580</id>
    <revision>
      <id>62641</id>
      <parentid>56977</parentid>
      <timestamp>2013-07-01T23:30:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2358">{{cpp/title|is_partitioned}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 |
template&lt; class InputIt, class UnaryPredicate &gt;
bool is_partitioned( InputIt first, InputIt last, UnaryPredicate p );
}}
{{dcl end}}

Returns {{c|true}} if all elements in the range {{tt|[first, last)}} that satisfy the predicate {{tt|p}} appear before all elements that don't. Also returns {{c|true}} if {{tt|[first, last)}} is empty.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to check}}
{{par pred1 | p | for the elements expected to be found in the beginning of the range | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===

{{c|true}} if the range {{tt|[first, last)}} is empty or is partitioned by {{tt|p}}. {{c|false}} otherwise.

===Complexity===

At most {{tt|std::distance(first, last)}} applications of {{tt|p}}.

===Possible implementation===
{{eq fun | 1=
template&lt; class InputIt, class UnaryPredicate &gt;
bool is_partitioned(InputIt first, InputIt last, UnaryPredicate p)
{
    for (; first != last; ++first)
        if (!p(*first))
            break;
    for (; first != last; ++first)
        if (p(*first))
            return false;
    return true;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;array&gt;
#include &lt;iostream&gt;

int main()
{
    std::array&lt;int, 9&gt; v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    
    auto is_even = [](int i){ return i % 2 == 0; };
    std::cout.setf(std::ios_base::boolalpha);
    std::cout &lt;&lt; std::is_partitioned(v.begin(), v.end(), is_even) &lt;&lt; ' ';
    
    std::partition(v.begin(), v.end(), is_even);
    std::cout &lt;&lt; std::is_partitioned(v.begin(), v.end(), is_even) &lt;&lt; ' ';
    
    std::reverse(v.begin(), v.end());
    std::cout &lt;&lt; std::is_partitioned(v.begin(), v.end(), is_even);
}
 | output=
false true false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc inc | cpp/algorithm/dsc partition_point}}
{{dsc end}}

[[de:cpp/algorithm/is partitioned]]
[[es:cpp/algorithm/is partitioned]]
[[fr:cpp/algorithm/is partitioned]]
[[it:cpp/algorithm/is partitioned]]
[[ja:cpp/algorithm/is partitioned]]
[[pt:cpp/algorithm/is partitioned]]
[[ru:cpp/algorithm/is partitioned]]
[[zh:cpp/algorithm/is partitioned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is permutation</title>
    <ns>0</ns>
    <id>2583</id>
    <revision>
      <id>72389</id>
      <parentid>69420</parentid>
      <timestamp>2014-08-19T03:18:38Z</timestamp>
      <contributor>
        <username>LB</username>
        <id>2506</id>
      </contributor>
      <comment>Fix copy paste errors</comment>
      <text xml:space="preserve" bytes="4599">{{cpp/title|is_permutation}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 | num=1 |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
bool is_permutation( ForwardIt1 first1, ForwardIt1 last1,
                     ForwardIt2 first2 );
}}
{{dcl | since=c++11 | num=2 |
template&lt; class ForwardIt1, class ForwardIt2, class BinaryPredicate &gt;
bool is_permutation( ForwardIt1 first1, ForwardIt1 last1,
                     ForwardIt2 first2, BinaryPredicate p );
}}
{{dcl | since=c++14 | num=3 |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
bool is_permutation( ForwardIt1 first1, ForwardIt1 last1,
                     ForwardIt2 first2, ForwardIt2 last2 );
}}
{{dcl | since=c++14 | num=4 |
template&lt; class ForwardIt1, class ForwardIt2, class BinaryPredicate &gt;
bool is_permutation( ForwardIt1 first1, ForwardIt1 last1,
                     ForwardIt2 first2, ForwardIt2 last2,
                     BinaryPredicate p );
}}
{{dcl end}}

Returns {{c|true}} if there exists a permutation of the elements in the range {{tt|[first1, last1)}} that makes that range equal to the range {{tt|[first2,last2)}}, where {{tt|last2}} denotes {{c|first2 + (last1 - first1)}} if it was not given. 

The overloads (1) and (3) use {{tt|1=operator==}} for equality, whereas the overloads (2) and (4) use the binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first1, last1 | the range of elements to compare }}
{{par | first2, last2 | the second range to compare}}
{{par | p | binary predicate which returns ​{{c|{{{value|true}}}}} if the elements should be treated as equal. &lt;br/&gt;
The signature of the predicate function should be equivalent to the following:

{{cc | bool pred(const Type &amp;a, const Type &amp;b); }}

{{tt|Type}} should be the value type of both {{tt|ForwardIt1}} and {{tt|ForwardIt2}}. The signature does not need to have {{c|const &amp;}}, but the function must not modify the objects passed to it.}}​
{{par hreq}}
{{par req concept | ForwardIt1, ForwardIt2 | ForwardIterator}}
{{par req | {{tt|ForwardIt1, ForwardIt2}} must have the same value type.}}
{{par end}}

===Return value===

{{c|true}} if the range {{tt|[first1, last1)}} is a permutation of the range {{tt|[first2, last2)}}.

===Complexity===

At most {{math|O(N&lt;sup&gt;2&lt;/sup&gt;)}} applications of the predicate, or exactly {{math|N}} if the sequences are already equal, where {{c|1=N=std::distance(first1, last1)}}. 

However if {{tt|ForwardIt1}} and {{tt|ForwardIt2}} meet the requirements of {{concept|RandomAccessIterator}} and {{c|std::distance(first1, last1) !{{=}} std::distance(first2, last2)}} no applications of the predicate are made.

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt1, class ForwardIt2&gt;
bool is_permutation(ForwardIt1 first, ForwardIt1 last,
                    ForwardIt2 d_first)
{
   // skip common prefix
   std::tie(first, d_first) = std::mismatch(first, last, d_first);
   // iterate over the rest, counting how many times each element
   // from [first, last) appears in [d_first, d_last)
   if (first != last) {
       ForwardIt2 d_last = d_first;
       std::advance(d_last, std::distance(first, last));
       for (ForwardIt1 i = first; i != last; ++i) {
            if (i != std::find(first, i, *i)) continue; // already counted this *i

            auto m = std::count(d_first, d_last, *i);
            if (m==0 {{!!}} std::count(i, last, *i) != m) {
                return false;
            }
        }
    }
    return true;
}
}}

===Example===
{{example
 | 
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
int main()
{
    std::vector&lt;int&gt; v1{1,2,3,4,5};
    std::vector&lt;int&gt; v2{3,5,4,1,2};
    std::cout &lt;&lt; &quot;3,5,4,1,2 is a permutation of 1,2,3,4,5? &quot;
              &lt;&lt; std::boolalpha
              &lt;&lt; std::is_permutation(v1.begin(), v1.end(), v2.begin()) &lt;&lt; '\n';

    std::vector&lt;int&gt; v3{3,5,4,1,1};
    std::cout &lt;&lt; &quot;3,5,4,1,1 is a permutation of 1,2,3,4,5? &quot;
              &lt;&lt; std::boolalpha
              &lt;&lt; std::is_permutation(v1.begin(), v1.end(), v3.begin()) &lt;&lt; '\n';
}
 | output=
3,5,4,1,2 is a permutation of 1,2,3,4,5? true
3,5,4,1,1 is a permutation of 1,2,3,4,5? false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc next_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}

[[de:cpp/algorithm/is permutation]]
[[es:cpp/algorithm/is permutation]]
[[fr:cpp/algorithm/is permutation]]
[[it:cpp/algorithm/is permutation]]
[[ja:cpp/algorithm/is permutation]]
[[pt:cpp/algorithm/is permutation]]
[[ru:cpp/algorithm/is permutation]]
[[zh:cpp/algorithm/is permutation]]</text>
      <sha1>80mk3l6caiqxkb2n1do7g5xv13yypwx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is sorted</title>
    <ns>0</ns>
    <id>746</id>
    <revision>
      <id>67362</id>
      <parentid>62643</parentid>
      <timestamp>2014-02-05T20:35:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="2146">{{cpp/title|is_sorted}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | since=c++11 |
template&lt; class ForwardIt &gt;
bool is_sorted( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class ForwardIt, class Compare &gt;
bool is_sorted( ForwardIt first, ForwardIt last, Compare comp );
}}
{{dcl end}}

Checks if the elements in range {{tt|[first, last)}} are sorted in ascending order. The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.
===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par cmp ord | comp | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===

{{c|true}} if the elements in the range are sorted in ascending order

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
bool is_sorted(ForwardIt first, ForwardIt last)
{
    return std::is_sorted_until(first, last) == last;
}
 | 2=
template&lt;class ForwardIt, class Compare&gt;
bool is_sorted(ForwardIt first, ForwardIt last, Compare comp)
{
    return std::is_sorted_until(first, last, comp) == last;
}
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;

int main() 
{
    const int N = 5;
    int digits[N] = {3, 1, 4, 1, 5};

    for (auto i : digits) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; &quot;: is_sorted: &quot; &lt;&lt; std::is_sorted(digits, digits+N) &lt;&lt; '\n';

    std::sort(digits, digits+N);

    for (auto i : digits) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; &quot;: is_sorted: &quot; &lt;&lt; std::is_sorted(digits, digits+N) &lt;&lt; '\n';
}
 | output=
3 1 4 1 5 : is_sorted: 0
1 1 3 4 5 : is_sorted: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_sorted_until}}
{{dsc end}}

[[de:cpp/algorithm/is sorted]]
[[es:cpp/algorithm/is sorted]]
[[fr:cpp/algorithm/is sorted]]
[[it:cpp/algorithm/is sorted]]
[[ja:cpp/algorithm/is sorted]]
[[pt:cpp/algorithm/is sorted]]
[[ru:cpp/algorithm/is sorted]]
[[zh:cpp/algorithm/is sorted]]</text>
      <sha1>gsm3bezt5n3kd91mr5peblagb447aw9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/is sorted until</title>
    <ns>0</ns>
    <id>747</id>
    <revision>
      <id>71201</id>
      <parentid>67374</parentid>
      <timestamp>2014-06-08T04:34:21Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3176">{{cpp/title|is_sorted_until}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | since=c++11 |
template&lt; class ForwardIt &gt;
ForwardIt is_sorted_until( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class ForwardIt, class Compare &gt;
ForwardIt is_sorted_until( ForwardIt first, ForwardIt last, 
                           Compare comp );
}}
{{dcl end}}

Examines the range {{tt|[first, last)}} and finds the largest range beginning at {{tt|first}} in which the elements are sorted in ascending order. The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par cmp ord | comp | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===

The upper bound of the largest range beginning at {{tt|first}} in which the elements are sorted in ascending order. That is, the last iterator {{tt|it}} for which range {{tt|[first, it)}} is sorted.

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last)
{
    if (first != last) {
        ForwardIt next = first;
        while (++next != last) {
            if (*next &lt; *first)
                return next;
            first = next;
        }
    }
    return last;
}
 | 2=
template &lt;class ForwardIt, class Compare&gt;
ForwardIt is_sorted_until(ForwardIt first, ForwardIt last, Compare comp) 
{
    using namespace std::placeholders;
    ForwardIt it = std::adjacent_find(first, last, std::bind(comp, _2, _1));
    return it == last ? last : std::next(it);
}
}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 g(rd());
    const int N = 6;
    int nums[N] = {3, 1, 4, 1, 5, 9};

    const int min_sorted_size = 4;
    int sorted_size = 0;
    do {
        std::random_shuffle(nums, nums + N, g);
        int *sorted_end = std::is_sorted_until(nums, nums + N);
        sorted_size = std::distance(nums, sorted_end);

        for (auto i : nums) std::cout &lt;&lt; i &lt;&lt; ' ';
        std::cout &lt;&lt; &quot; : &quot; &lt;&lt; sorted_size &lt;&lt; &quot; initial sorted elements\n&quot;;
    } while (sorted_size &lt; min_sorted_size);
}
 | output=
4 1 9 5 1 3  : 1 initial sorted elements
4 5 9 3 1 1  : 3 initial sorted elements
9 3 1 4 5 1  : 1 initial sorted elements
1 3 5 4 1 9  : 3 initial sorted elements
5 9 1 1 3 4  : 2 initial sorted elements
4 9 1 5 1 3  : 2 initial sorted elements
1 1 4 9 5 3  : 4 initial sorted elements
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_sorted}}
{{dsc end}}

[[de:cpp/algorithm/is sorted until]]
[[es:cpp/algorithm/is sorted until]]
[[fr:cpp/algorithm/is sorted until]]
[[it:cpp/algorithm/is sorted until]]
[[ja:cpp/algorithm/is sorted until]]
[[pt:cpp/algorithm/is sorted until]]
[[ru:cpp/algorithm/is sorted until]]
[[zh:cpp/algorithm/is sorted until]]</text>
      <sha1>bhzi58clo3x6ch3987unf1aqt8b93lt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/iter swap</title>
    <ns>0</ns>
    <id>748</id>
    <revision>
      <id>56985</id>
      <parentid>49255</parentid>
      <timestamp>2013-06-01T05:44:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2130">{{cpp/title|iter_swap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
void iter_swap( ForwardIt1 a, ForwardIt2 b );
}}
{{dcl end}}

Swaps the values of the elements the given iterators are pointing to. 

===Parameters===
{{par begin}}
{{par | a, b | iterators to the elements to swap}}
{{par hreq}}
{{par req concept | ForwardIt1, ForwardIt2 | ForwardIterator}}
{{par req concept | &lt;nowiki&gt;*a, *b&lt;/nowiki&gt; | Swappable}}
{{par end}}

===Return value===
(none)

===Complexity===

constant

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt1, class ForwardIt2&gt;
void iter_swap(ForwardIt1 a, ForwardIt2 b)
{
   using std::swap;
   swap(*a, *b);
}
}}

===Example===
{{example
 | The following is an implementation of selection sort in C++
 | code=#include &lt;random&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iterator&gt;

template&lt;class ForwardIt&gt;
void selection_sort(ForwardIt begin, ForwardIt end)
{
    for (ForwardIt i = begin; i != end; ++i)
        std::iter_swap(i, std::min_element(i, end));
}

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution&lt;&gt; dist(-10, 10);
    std::vector&lt;int&gt; v;
    generate_n(back_inserter(v), 20, bind(dist, gen));

    std::cout &lt;&lt; &quot;Before sort: &quot;;
    copy(v.begin(), v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));

    selection_sort(v.begin(), v.end());

    std::cout &lt;&lt; &quot;\nAfter sort: &quot;;
    copy(v.begin(), v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';
}
 | output=Before sort: -7 6 2 4 -1 6 -9 -1 2 -5 10 -9 -5 -3 -5 -3 6 6 1 8
After sort: -9 -9 -7 -5 -5 -5 -3 -3 -1 -1 1 2 2 4 6 6 6 6 8 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/algorithm/dsc swap_ranges}}
{{dsc end}}

[[de:cpp/algorithm/iter swap]]
[[es:cpp/algorithm/iter swap]]
[[fr:cpp/algorithm/iter swap]]
[[it:cpp/algorithm/iter swap]]
[[ja:cpp/algorithm/iter swap]]
[[pt:cpp/algorithm/iter swap]]
[[ru:cpp/algorithm/iter swap]]
[[zh:cpp/algorithm/iter swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/lexicographical compare</title>
    <ns>0</ns>
    <id>749</id>
    <revision>
      <id>70044</id>
      <parentid>70040</parentid>
      <timestamp>2014-05-08T14:26:17Z</timestamp>
      <contributor>
        <ip>198.228.201.161</ip>
      </contributor>
      <comment>added &quot;see also&quot; header</comment>
      <text xml:space="preserve" bytes="4215">{{cpp/title|lexicographical_compare}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2 &gt;
bool lexicographical_compare( InputIt1 first1, InputIt1 last1,
                              InputIt2 first2, InputIt2 last2 );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2, class Compare &gt;
bool lexicographical_compare( InputIt1 first1, InputIt1 last1,
                              InputIt2 first2, InputIt2 last2,
                              Compare comp );
}}
{{dcl end}}

Checks if the first range {{c|[first1, last1)}} is lexicographically ''less'' than the second range {{c|[first2, last2)}}. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

Lexicographical comparison is a operation with the following properties:
* Two ranges are compared element by element.
* The first mismatching element defines which range is lexicographically ''less'' or ''greater'' than the other.
* If one range is a prefix of another, the shorter range is lexicographically ''less'' than the other.
* If two ranges have equivalent elements and are of the same length, then the ranges are lexicographically ''equal''.
* An empty range is lexicographically ''less'' than any non-empty range.
* Two empty ranges are lexicographically ''equal''.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements to examine}}
{{par | first2, last2 | the second range of elements to examine}}
{{par cmp | comp | p1=InputIt1 | p2=InputIt2}}
{{par hreq}}
{{par req concept | InputIt1, InputIt2 | InputIterator}}
{{par end}}

===Return value===
{{c|true}} if the first range is lexicographically ''less'' than the second.

===Complexity===

At most {{math|2&amp;middot;min(N1, N2)}} applications of the comparison operation, where {{c|1=N1 = std::distance(first1, last1)}} and {{c|1=N2 = std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt1, class InputIt2&gt;
bool lexicographical_compare(InputIt1 first1, InputIt1 last1,
                             InputIt2 first2, InputIt2 last2)
{
    for ( ; (first1 != last1) &amp;&amp; (first2 != last2); first1++, first2++ ) {
        if (*first1 &lt; *first2) return true;
        if (*first2 &lt; *first1) return false;
    }
    return (first1 == last1) &amp;&amp; (first2 != last2);
}
 | 2=
template&lt;class InputIt1, class InputIt2, class Compare&gt;
bool lexicographical_compare(InputIt1 first1, InputIt1 last1,
                             InputIt2 first2, InputIt2 last2,
                             Compare comp)
{
    for ( ; (first1 != last1) &amp;&amp; (first2 != last2); first1++, first2++ ) {
        if (comp(*first1, *first2)) return true;
        if (comp(*first2, *first1)) return false;
    }
    return (first1 == last1) &amp;&amp; (first2 != last2);
}
}}

===Example===
{{example
 | p=true
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;cstdlib&gt;
#include &lt;ctime&gt;

int main()
{
    std::vector&lt;char&gt; v1 {'a', 'b', 'c', 'd'};
    std::vector&lt;char&gt; v2 {'a', 'b', 'c', 'd'};

    std::srand(std::time(0));
    while (!std::lexicographical_compare(v1.begin(), v1.end(),
                                         v2.begin(), v2.end())) {
        for (auto c : v1) std::cout &lt;&lt; c &lt;&lt; ' ';
        std::cout &lt;&lt; &quot;&gt;= &quot;;
        for (auto c : v2) std::cout &lt;&lt; c &lt;&lt; ' ';
        std::cout &lt;&lt; '\n';

        std::random_shuffle(v1.begin(), v1.end());
        std::random_shuffle(v2.begin(), v2.end());
    }

    for (auto c : v1) std::cout &lt;&lt; c &lt;&lt; ' ';
    std::cout &lt;&lt; &quot;&lt; &quot;;
    for (auto c : v2) std::cout &lt;&lt; c &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
a b c d &gt;= a b c d 
d a b c &gt;= c b d a 
b d a c &gt;= a d c b 
a c d b &lt; c d a b 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc end}}

[[de:cpp/algorithm/lexicographical compare]]
[[es:cpp/algorithm/lexicographical compare]]
[[fr:cpp/algorithm/lexicographical compare]]
[[it:cpp/algorithm/lexicographical compare]]
[[ja:cpp/algorithm/lexicographical compare]]
[[pt:cpp/algorithm/lexicographical compare]]
[[ru:cpp/algorithm/lexicographical compare]]
[[zh:cpp/algorithm/lexicographical compare]]</text>
      <sha1>0cltfb75bijhrev8x9yj235mc3en5vb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/lower bound</title>
    <ns>0</ns>
    <id>750</id>
    <revision>
      <id>71648</id>
      <parentid>69762</parentid>
      <timestamp>2014-06-17T19:20:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+formal complexity spec (this page already had the complexity before possible impls)</comment>
      <text xml:space="preserve" bytes="3528">{{cpp/title|lower_bound}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class T, class Compare &gt;
ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T&amp; value, Compare comp );
}}
{{dcl end}}

Returns an iterator pointing to the first element in the range {{tt|[first, last)}} that is ''not less'' than (i.e. greater or equal to) {{tt|value}}.

The range {{tt|[first, last)}} must be at least partially ordered, i.e. partitioned with respect to the expression {{c|element &lt; value}} or {{c|comp(element, value)}}.  A fully-sorted range meets this criteria, as does a range resulting from a call to {{c|std::partition}}.

The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | iterators defining the partially-ordered range to examine}}
{{par | value | value to compare the elements to}}
{{par cmp | comp | p1=ForwardIt | t2=T }} 
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator pointing to the first element that is not ''less'' than {{tt|value}}, or {{tt|last}} if no such element is found.

===Complexity===
The number of comparisons performed is logarithmic in the distance between {{tt|first}} and {{tt|last}} (At most {{math|log{{su|b=2}}(last - first) + O(1)}} comparisons)

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class T&gt;
ForwardIt lower_bound(ForwardIt first, ForwardIt last, const T&amp; value)
{
    ForwardIt it;
    typename std::iterator_traits&lt;ForwardIt&gt;::difference_type count, step;
    count = std::distance(first, last);

    while (count &gt; 0) {
        it = first; 
        step = count / 2; 
        std::advance(it, step);
        if (*it &lt; value) {
            first = ++it; 
            count -= step + 1; 
        } else count = step;
    }
    return first;
}
 | 2=
template&lt;class ForwardIt, class T, class Compare&gt;
ForwardIt lower_bound(ForwardIt first, ForwardIt last, const T&amp; value, Compare comp)
{
    ForwardIt it;
    typename std::iterator_traits&lt;ForwardIt&gt;::difference_type count, step;
    count = std::distance(first,last);

    while (count &gt; 0) {
        it = first;
        step = count / 2;
        std::advance(it, step);
        if (comp(*it, value)) {
            first = ++it;
            count -= step + 1;
        } else count = step;
    }
    return first;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
    
    auto lower = std::lower_bound(data.begin(), data.end(), 4);
    auto upper = std::upper_bound(data.begin(), data.end(), 4);
    
    std::copy(lower, upper, std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
 | output=
4 4 4 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc equal_range}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc inc | cpp/algorithm/dsc upper_bound}}
{{dsc end}}

[[de:cpp/algorithm/lower bound]]
[[es:cpp/algorithm/lower bound]]
[[fr:cpp/algorithm/lower bound]]
[[it:cpp/algorithm/lower bound]]
[[ja:cpp/algorithm/lower bound]]
[[ko:cpp/algorithm/lower bound]]
[[pt:cpp/algorithm/lower bound]]
[[ru:cpp/algorithm/lower bound]]
[[zh:cpp/algorithm/lower bound]]</text>
      <sha1>imyc1sjhby8agppbvucyq32ykkijcau</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/make heap</title>
    <ns>0</ns>
    <id>751</id>
    <revision>
      <id>69143</id>
      <parentid>63732</parentid>
      <timestamp>2014-03-28T15:57:28Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2125">{{cpp/title|make_heap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void make_heap( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void make_heap( RandomIt first, RandomIt last,
                Compare comp );
}}
{{dcl end}}

Constructs a ''max heap'' in the range {{tt|[first, last)}}. The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to make the heap from}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
At most {{c|3*std::distance(first, last)}} comparisons.

===Notes===
{{cpp/algorithm/notes heap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v { 3, 1, 4, 1, 5, 9 };

    std::cout &lt;&lt; &quot;initially, v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::make_heap(v.begin(), v.end());

    std::cout &lt;&lt; &quot;after make_heap, v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::pop_heap(v.begin(), v.end());
    auto largest = v.back();
    v.pop_back();
    std::cout &lt;&lt; &quot;largest element: &quot; &lt;&lt; largest &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;after removing the largest element, v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
initially, v: 3 1 4 1 5 9 
after make_heap, v: 9 5 4 1 1 3 
largest element: 9
after removing the largest element, v: 5 3 4 1 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc sort_heap}}
{{dsc end}}

[[de:cpp/algorithm/make heap]]
[[es:cpp/algorithm/make heap]]
[[fr:cpp/algorithm/make heap]]
[[it:cpp/algorithm/make heap]]
[[ja:cpp/algorithm/make heap]]
[[pt:cpp/algorithm/make heap]]
[[ru:cpp/algorithm/make heap]]
[[zh:cpp/algorithm/make heap]]</text>
      <sha1>ex2wfodx69y6z40v6915bkc1kwdi58r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/max</title>
    <ns>0</ns>
    <id>752</id>
    <revision>
      <id>68850</id>
      <parentid>63169</parentid>
      <timestamp>2014-03-22T17:34:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2350 (constexpr)</comment>
      <text xml:space="preserve" bytes="3697">{{cpp/title|max}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin|num=1}}
{{dcl | until=c++14 |
template&lt; class T &gt; 
const T&amp; max( const T&amp; a, const T&amp; b );
}}
{{dcl | since=c++14 |
template&lt; class T &gt; 
constexpr const T&amp; max( const T&amp; a, const T&amp; b );
}}
{{dcl rev end}}
{{dcl rev begin|num=2}}
{{dcl | until=c++14 |
template&lt; class T, class Compare &gt;
const T&amp; max( const T&amp; a, const T&amp; b, Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr const T&amp; max( const T&amp; a, const T&amp; b, Compare comp );
}}
{{dcl rev end}}
{{dcl rev begin|num=3}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T &gt;
T max( std::initializer_list&lt;T&gt; ilist );
}}
{{dcl | since=c++14 |
template&lt; class T &gt;
constexpr T max( std::initializer_list&lt;T&gt; ilist );
}}
{{dcl rev end}}
{{dcl rev begin|num=4}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, class Compare &gt;
T max( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr T max( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl rev end}}
{{dcl end}}

Returns the greater of the given values.

@1-2@ Returns the greater of {{tt|a}} and {{tt|b}}. 

@3-4@ Returns the greatest of the values in initializer list {{tt|ilist}}.

The (1,3) versions use {{c|operator&lt;}} to compare the values, the (2,4) versions use the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | a, b | the values to compare}}
{{par | ilist | initializer list with the values to compare}}
{{par cmp | comp | t1=T | if {{tt|a}} is ''less'' than {{tt|b}}}} 
{{par hreq}}
{{par req concept | T | LessThanComparable | notes=for the overloads (1) and (3)}}
{{par req concept | T | CopyConstructible | notes=for the overloads (3) and (4)}}
{{par end}}

===Return value===
1-2) The greater of {{tt|a}} and {{tt|b}}. If they are equivalent, returns {{tt|a}}.

3-4) The greatest value in {{tt|ilist}}. If several values are equivalent to the greatest, returns the leftmost one.

===Complexity===
1-2) Constant

3-4) Linear in {{tt|ilist.size()}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; 
const T&amp; max(const T&amp; a, const T&amp; b)
{
    return (a &lt; b) ? b : a;
}
 | 2=
template&lt;class T, class Compare&gt; 
const T&amp; max(const T&amp; a, const T&amp; b, Compare comp)
{
    return (comp(a, b)) ? b : a;
}
 | 3=
template&lt; class T &gt;
T max( std::initializer_list&lt;T&gt; ilist)
{
    return *std::max_element(ilist.begin(), ilist.end());
}
 | 4=
template&lt; class T, class Compare &gt;
T max( std::initializer_list&lt;T&gt; ilist, Compare comp )
{
    return *std::max_element(ilist.begin(), ilist.end(), comp);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::cout &lt;&lt; &quot;larger of 1 and 9999: &quot; &lt;&lt; std::max(1, 9999) &lt;&lt; '\n'
              &lt;&lt; &quot;larger of 'a', and 'b': &quot; &lt;&lt; std::max('a', 'b') &lt;&lt; '\n'
              &lt;&lt; &quot;longest of \&quot;foo\&quot;, \&quot;bar\&quot;, and \&quot;hello\&quot;: &quot; &lt;&lt;
                  std::max( { &quot;foo&quot;, &quot;bar&quot;, &quot;hello&quot; },
                            [](const std::string&amp; s1, const std::string&amp; s2) {
                                 return s1.size() &lt; s2.size();
                             }) &lt;&lt; '\n';
}
 | output=
larger of 1 and 9999: 9999
larger of 'a', and 'b': b
longest of &quot;foo&quot;, &quot;bar&quot;, and &quot;hello&quot;: hello
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc end}}

[[de:cpp/algorithm/max]]
[[es:cpp/algorithm/max]]
[[fr:cpp/algorithm/max]]
[[it:cpp/algorithm/max]]
[[ja:cpp/algorithm/max]]
[[pt:cpp/algorithm/max]]
[[ru:cpp/algorithm/max]]
[[zh:cpp/algorithm/max]]</text>
      <sha1>s6o2um9jnnwdy8zjh6ljfa8m3y3ipji</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/max element</title>
    <ns>0</ns>
    <id>753</id>
    <revision>
      <id>69097</id>
      <parentid>69094</parentid>
      <timestamp>2014-03-27T09:28:16Z</timestamp>
      <contributor>
        <ip>81.14.208.18</ip>
      </contributor>
      <text xml:space="preserve" bytes="2983">{{cpp/title|max_element}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt &gt; 
ForwardIt max_element( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class Compare &gt;
ForwardIt max_element( ForwardIt first, ForwardIt last, Compare comp );
}}
{{dcl end}}

Finds the greatest element in the range {{tt|[first, last)}}. The first version uses {{c|operator&lt;}} to compare the values, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | forward iterators defining the range to examine}}
{{par cmp | cmp | p1=ForwardIt | the first argument is ''less'' than the second}}} 
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the greatest element in the range {{tt|[first, last)}}. If several elements in the range are equivalent to the greatest element, returns the iterator to the first such element. Returns {{tt|last}} if the range is empty. 

===Complexity===
Exactly {{math|max(N-1,0)}} comparisons, where {{c|N {{=}} std::distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
ForwardIt max_element(ForwardIt first, ForwardIt last)
{
    if (first == last) {
        return last;
    }
    ForwardIt largest = first;
    ++first;
    for (; first != last; ++first) {
        if (*largest &lt; *first) {
            largest = first;
        }
    }
    return largest;
}
 | 2=
template&lt;class ForwardIt, class Compare&gt;
ForwardIt max_element(ForwardIt first, ForwardIt last, 
                            Compare comp)
{
    if (first == last) {
        return last;
    }
    ForwardIt largest = first;
    ++first;
    for (; first != last; ++first) {
        if (comp(*largest, *first)) {
            largest = first;
        }
    }
    return largest;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;cmath&gt;

static bool abs_compare(int a, int b)
{
    return (std::abs(a) &lt; std::abs(b));
}

int main()
{
    std::vector&lt;int&gt; v{ 3, 1, -14, 1, 5, 9 }; 
    std::vector&lt;int&gt;::iterator result;

    result = std::max_element(v.begin(), v.end());
    std::cout &lt;&lt; &quot;max element at: &quot; &lt;&lt; std::distance(v.begin(), result) &lt;&lt; '\n';

    result = std::max_element(v.begin(), v.end(), abs_compare);
    std::cout &lt;&lt; &quot;max element (absolute) at: &quot; &lt;&lt; std::distance(v.begin(), result);
}
 | output=
max element at: 5
max element (absolute) at: 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc end}}

[[de:cpp/algorithm/max element]]
[[es:cpp/algorithm/max element]]
[[fr:cpp/algorithm/max element]]
[[it:cpp/algorithm/max element]]
[[ja:cpp/algorithm/max element]]
[[pt:cpp/algorithm/max element]]
[[ru:cpp/algorithm/max element]]
[[zh:cpp/algorithm/max element]]</text>
      <sha1>j7fbgczsaujbfovyczucfny417p15fh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/merge</title>
    <ns>0</ns>
    <id>754</id>
    <revision>
      <id>67400</id>
      <parentid>67382</parentid>
      <timestamp>2014-02-07T17:10:37Z</timestamp>
      <contributor>
        <ip>216.191.123.180</ip>
      </contributor>
      <comment>Changed complexity to be -1 as per N3797 25.4.4 [alg.merge]</comment>
      <text xml:space="preserve" bytes="4450">{{cpp/title|merge}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class OutputIt &gt;
OutputIt merge( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2, class OutputIt, class Compare&gt;
OutputIt merge( InputIt1 first1, InputIt1 last1,
                InputIt2 first2, InputIt2 last2,
                OutputIt d_first, Compare comp );
}}
{{dcl end}}

Merges two sorted ranges {{tt|[first1, last1)}} and {{tt|[first2, last2)}} into one sorted range beginning at {{tt|d_first}}. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}. The relative order of equivalent elements is preserved.

The behavior is undefined if the destination range overlaps either of the input ranges (the input ranges may overlap each other).

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements to merge}}
{{par | first2, last2 | the second range of elements to merge}}
{{par | d_first | the beginning of the destination range}}
{{par cmp ord | comp | p1=InputIt1 | p2=InputIt2}} 
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
An output iterator to element past the last element copied.

===Complexity===
At most {{c|1=std::distance(first1, last1) + std::distance(first2, last2) - 1}} comparisons.

===Possible implementation===
{{eq fun 
 | 1=
template&lt;class InputIt1, class InputIt2, class OutputIt&gt;
OutputIt merge(InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2,
               OutputIt d_first)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2) {
            return std::copy(first1, last1, d_first);
        }
        if (*first2 &lt; *first1) {
            *d_first = *first2;
            ++first2;
        } else {
            *d_first = *first1;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class OutputIt, class Compare&gt;
OutputIt merge(InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2,
               OutputIt d_first, Compare comp)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2) {
            return std::copy(first1, last1, d_first);
        }
        if (comp(*first2, *first1)) {
            *d_first = *first2;
            ++first2;
        } else {
            *d_first = *first1;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;random&gt;

int main()
{
    // fill the vectors with random numbers
    std::random_device rd;
    std::mt19937 mt(rd());
    std::uniform_int_distribution&lt;&gt; dis(0, 9);

    std::vector&lt;int&gt; v1(10), v2(10);
    std::generate(v1.begin(), v1.end(), std::bind(dis, std::ref(mt)));
    std::generate(v2.begin(), v2.end(), std::bind(dis, std::ref(mt)));

    // sort
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    // output v1
    std::cout &lt;&lt; &quot;v1 : &quot;;
    std::copy(v1.begin(), v1.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';

    // output v2
    std::cout &lt;&lt; &quot;v2 : &quot;;
    std::copy(v2.begin(), v2.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';

    // merge
    std::vector&lt;int&gt; dst;
    std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(dst));

    // output
    std::cout &lt;&lt; &quot;dst: &quot;;
    std::copy(dst.begin(), dst.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';
} 
| p=true
| output=
v1 : 0 1 3 4 4 5 5 8 8 9 
v2 : 0 2 2 3 6 6 8 8 8 9 
dst: 0 0 1 2 2 3 3 4 4 5 5 6 6 8 8 8 8 8 9 9 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc inplace_merge}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc end}}

[[de:cpp/algorithm/merge]]
[[es:cpp/algorithm/merge]]
[[fr:cpp/algorithm/merge]]
[[it:cpp/algorithm/merge]]
[[ja:cpp/algorithm/merge]]
[[pt:cpp/algorithm/merge]]
[[ru:cpp/algorithm/merge]]
[[zh:cpp/algorithm/merge]]</text>
      <sha1>hcxf5ls6mjtrr0pwa6x8zqc5pbhidve</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/min</title>
    <ns>0</ns>
    <id>755</id>
    <revision>
      <id>68849</id>
      <parentid>63172</parentid>
      <timestamp>2014-03-22T17:31:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2350 (constexpr)</comment>
      <text xml:space="preserve" bytes="3703">{{cpp/title|min}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin|num=1}}
{{dcl | until=c++14 |
template&lt; class T &gt; 
const T&amp; min( const T&amp; a, const T&amp; b );
}}
{{dcl | since=c++14 |
template&lt; class T &gt; 
constexpr const T&amp; min( const T&amp; a, const T&amp; b );
}}
{{dcl rev end}}
{{dcl rev begin|num=2}}
{{dcl | until=c++14 |
template&lt; class T, class Compare &gt;
const T&amp; min( const T&amp; a, const T&amp; b, Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr const T&amp; min( const T&amp; a, const T&amp; b, Compare comp );
}}
{{dcl rev end}}
{{dcl rev begin|num=3}}
{{dcl | since=c++11| until=c++14 |
template&lt; class T &gt;
T min( std::initializer_list&lt;T&gt; ilist );
}}
{{dcl | since=c++14 |
template&lt; class T &gt;
constexpr T min( std::initializer_list&lt;T&gt; ilist );
}}
{{dcl rev end}}
{{dcl rev begin|num=4}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, class Compare &gt;
T min( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr T min( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl rev end}}
{{dcl end}}

Returns the smaller of the given values.

@1-2@ Returns the smaller of {{tt|a}} and {{tt|b}}. 

@3-4@ Returns the smallest of the values in initializer list {{tt|ilist}}.

The (1,3) versions use {{c|operator&lt;}} to compare the values, the (2,4) versions use the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | a, b | the values to compare}}
{{par | ilist | initializer list with the values to compare}}
{{par cmp | cmp | t1=T | if {{tt|a}} is ''less'' than {{tt|b}}}} 
{{par hreq}}
{{par req concept | T | LessThanComparable | notes=for the overloads (1) and (3)}}
{{par req concept | T | CopyConstructible | notes=for the overloads (3) and (4)}}
{{par end}}

===Return value===
1-2) The smaller of {{tt|a}} and {{tt|b}}. If the values are equivalent, returns {{tt|a}}.

3-4) The smallest value in {{tt|ilist}}. If several values are equivalent to the smallest, returns the leftmost such value.

===Complexity===
1-2) Constant

3-4) Linear in {{tt|ilist.size()}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; 
const T&amp; min(const T&amp; a, const T&amp; b)
{
    return (b &lt; a) ? b : a;
}
 | 2=
template&lt;class T, class Compare&gt; 
const T&amp; min(const T&amp; a, const T&amp; b, Compare comp)
{
    return (comp(b, a)) ? b : a;
}
 | 3=
template&lt;class T&gt;
T min( std::initializer_list&lt;T&gt; ilist)
{
    return *std::min_element(ilist.begin(), ilist.end());
}
 | 4=
template&lt;class T, class Compare&gt;
T min(std::initializer_list&lt;T&gt; ilist, Compare comp)
{
    return *std::min_element(ilist.begin(), ilist.end(), comp);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::cout &lt;&lt; &quot;smaller of 1 and 9999: &quot; &lt;&lt; std::min(1, 9999) &lt;&lt; '\n'
              &lt;&lt; &quot;smaller of 'a', and 'b': &quot; &lt;&lt; std::min('a', 'b') &lt;&lt; '\n'
              &lt;&lt; &quot;shortest of \&quot;foo\&quot;, \&quot;bar\&quot;, and \&quot;hello\&quot;: &quot; &lt;&lt;
                  std::min( { &quot;foo&quot;, &quot;bar&quot;, &quot;hello&quot; },
                            [](const std::string&amp; s1, const std::string&amp; s2) {
                                 return s1.size() &lt; s2.size();
                             }) &lt;&lt; '\n';
}
 | output=
smaller of 1 and 9999: 1
smaller of 'a', and 'b': a
shortest of &quot;foo&quot;, &quot;bar&quot;, and &quot;hello&quot;: foo
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc end}}

[[de:cpp/algorithm/min]]
[[es:cpp/algorithm/min]]
[[fr:cpp/algorithm/min]]
[[it:cpp/algorithm/min]]
[[ja:cpp/algorithm/min]]
[[pt:cpp/algorithm/min]]
[[ru:cpp/algorithm/min]]
[[zh:cpp/algorithm/min]]</text>
      <sha1>54rgfs6cozpydlvob2d9n4pam8nx32t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/min element</title>
    <ns>0</ns>
    <id>756</id>
    <revision>
      <id>65404</id>
      <parentid>64114</parentid>
      <timestamp>2013-09-12T10:19:06Z</timestamp>
      <contributor>
        <ip>95.153.173.188</ip>
      </contributor>
      <comment>1) &quot;a&quot; and &quot;b&quot; in description of parameter &quot;cmp&quot; are references, but not pointers. 2) Deleted odd &quot;if&quot;</comment>
      <text xml:space="preserve" bytes="2662">{{cpp/title|min_element}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt &gt; 
ForwardIt min_element( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class Compare &gt;
ForwardIt min_element( ForwardIt first, ForwardIt last, Compare comp );
}}
{{dcl end}}

Finds the smallest element in the range {{tt|[first, last)}}. The first version uses {{c|operator&lt;}} to compare the values, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | forward iterators defining the range to examine}}
{{par cmp | cmp | p1=ForwardIt | {{tt|a}} is ''less'' than {{tt|b}}}} 
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the smallest element in the range {{tt|[first, last)}}. If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns {{tt|last}} if the range is empty.

===Complexity===
Exactly {{math|max(N-1,0)}} comparisons, where {{c|N {{=}} std::distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
ForwardIt min_element(ForwardIt first, ForwardIt last)
{
    if (first == last) return last;

    ForwardIt smallest = first;
    ++first;
    for (; first != last; ++first) {
        if (*first &lt; *smallest) {
            smallest = first;
        }
    }
    return smallest;
}
 | 2=
template&lt;class ForwardIt, class Compare&gt;
ForwardIt min_element(ForwardIt first, ForwardIt last, 
                            Compare comp)
{
    if (first == last) return last;
    
    ForwardIt smallest = first;
    ++first;
    for (; first != last; ++first) {
        if (comp(*first, *smallest)) {
            smallest = first;
        }
    }
    return smallest;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    std::vector&lt;int&gt; v{3, 1, 4, 1, 5, 9};
 
    std::vector&lt;int&gt;::iterator result = std::min_element(std::begin(v), std::end(v));
    std::cout &lt;&lt; &quot;min element at: &quot; &lt;&lt; std::distance(std::begin(v), result);
}
 | output=
min element at: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc end}}

[[de:cpp/algorithm/min element]]
[[es:cpp/algorithm/min element]]
[[fr:cpp/algorithm/min element]]
[[it:cpp/algorithm/min element]]
[[ja:cpp/algorithm/min element]]
[[pt:cpp/algorithm/min element]]
[[ru:cpp/algorithm/min element]]
[[zh:cpp/algorithm/min element]]</text>
      <sha1>jrh1r5c1ijgyd3v9eo1hz32k4d0d9sp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/minmax</title>
    <ns>0</ns>
    <id>2482</id>
    <revision>
      <id>72247</id>
      <parentid>68851</parentid>
      <timestamp>2014-07-29T11:14:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>format</comment>
      <text xml:space="preserve" bytes="4445">{{cpp/title|minmax}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin|num=1}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T &gt; 
std::pair&lt;const T&amp;,const T&amp;&gt; minmax( const T&amp; a, const T&amp; b );
}}
{{dcl | since=c++14 |
template&lt; class T &gt; 
constexpr std::pair&lt;const T&amp;,const T&amp;&gt; minmax( const T&amp; a, const T&amp; b );
}}
{{dcl rev end}}
{{dcl rev begin|num=2}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, class Compare &gt;
std::pair&lt;const T&amp;,const T&amp;&gt; minmax( const T&amp; a, const T&amp; b,
                                     Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr std::pair&lt;const T&amp;,const T&amp;&gt; minmax( const T&amp; a, const T&amp; b,
                                               Compare comp );
}}
{{dcl rev end}}
{{dcl rev begin|num=3}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T &gt;
std::pair&lt;T,T&gt; minmax( std::initializer_list&lt;T&gt; ilist);
}}
{{dcl | since=c++14 |
template&lt; class T &gt;
constexpr std::pair&lt;T,T&gt; minmax( std::initializer_list&lt;T&gt; ilist);
}}
{{dcl rev end}}
{{dcl rev begin|num=4}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, class Compare &gt;
std::pair&lt;T,T&gt; minmax( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl | since=c++14 |
template&lt; class T, class Compare &gt;
constexpr std::pair&lt;T,T&gt; minmax( std::initializer_list&lt;T&gt; ilist, Compare comp );
}}
{{dcl rev end}}
{{dcl end}}

Returns the lowest and the greatest of the given values.

@1-2@ Returns the smaller and the greater of {{tt|a}} and {{tt|b}}. 

@3-4@ Returns the smallest and the greatest of the values in initializer list {{tt|ilist}}.

The {{v|1,3}} versions use {{c|operator&lt;}} to compare the values, whereas the {{v|2,4}} versions use the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | a, b | the values to compare}}
{{par | ilist | initializer list with the values to compare}}
{{par cmp | comp | t1=T &lt;!--| if {{tt|a}} is ''less'' than {{tt|b}}--&gt;}} 
{{par hreq}}
{{par req concept | T | LessThanComparable}}
{{par req concept | T | CopyConstructible | overloads=3,4}}
{{par end}}

===Return value===
@1-2@ Returns the result of {{c|std::make_pair(a, b)}} if {{tt|a&lt;b}} or if {{tt|a}} is equivalent to {{tt|b}}. Returns the result of {{c|std::make_pair(b, a)}} if {{tt|b&lt;a}}.

@3-4@ A pair with the smallest value in {{tt|ilist}} as the first element and the greatest as the second. If several elements are equivalent to the smallest, the leftmost such element is returned. If several elements are equivalent to the largest, the rightmost such element is returned.

===Complexity===
@1-2@ Constant

@3-4@ Linear in {{tt|ilist.size()}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; 
std::pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b)
{
    return (b &lt; a) ? std::make_pair(b, a)
                   : std::make_pair(a, b);
}
 | 2=
template&lt;class T, class Compare&gt; 
std::pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b, Compare comp)
{
    return comp(b, a) ? std::make_pair(b, a)
                      : std::make_pair(a, b);
}
 | 3=
template&lt; class T &gt;
std::pair&lt;T, T&gt; minmax( std::initializer_list&lt;T&gt; ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::make_pair(*p.first, *p.second);
}
 | 4=
template&lt; class T, class Compare &gt;
std::pair&lt;T, T&gt; minmax( std::initializer_list&lt;T&gt; ilist, Compare comp )
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::make_pair(*p.first, *p.second);
}
}}

===Example===
{{example
 | p=true
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;cstdlib&gt;
#include &lt;ctime&gt;

int main()
{
    std::vector&lt;int&gt; v {3, 1, 4, 1, 5, 9, 2, 6}; 
    std::srand(std::time(0));
    std::pair&lt;int, int&gt; bounds = std::minmax(std::rand() % v.size(),
                                             std::rand() % v.size());

    std::cout &lt;&lt; &quot;v[&quot; &lt;&lt; bounds.first &lt;&lt; &quot;,&quot; &lt;&lt; bounds.second &lt;&lt; &quot;]: &quot;;
    for (int i = bounds.first; i &lt; bounds.second; ++i) {
        std::cout &lt;&lt; v[i] &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
v[2,7]: 4 1 5 9 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc end}}

[[de:cpp/algorithm/minmax]]
[[es:cpp/algorithm/minmax]]
[[fr:cpp/algorithm/minmax]]
[[it:cpp/algorithm/minmax]]
[[ja:cpp/algorithm/minmax]]
[[pt:cpp/algorithm/minmax]]
[[ru:cpp/algorithm/minmax]]
[[zh:cpp/algorithm/minmax]]</text>
      <sha1>htqjvieur86f0wakto6u3afjj3g8g11</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/minmax element</title>
    <ns>0</ns>
    <id>2481</id>
    <revision>
      <id>67686</id>
      <parentid>57006</parentid>
      <timestamp>2014-02-21T00:33:07Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>rm redundant assignment</comment>
      <text xml:space="preserve" bytes="3647">{{cpp/title|minmax_element}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt &gt; 
std::pair&lt;ForwardIt,ForwardIt&gt; 
    minmax_element( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class Compare &gt;
std::pair&lt;ForwardIt,ForwardIt&gt; 
    minmax_element( ForwardIt first, ForwardIt last, Compare comp );
}}
{{dcl end}}

Finds the greatest and the smallest element in the range {{tt|[first, last)}}. The first version uses {{c|operator&lt;}} to compare the values, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | forward iterators defining the range to examine}}
{{par cmp | cmp | p1=ForwardIt | if {{tt|*a}} is ''less'' than {{tt|*b}}}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}} 
{{par end}}

===Return value===
a pair consisting of an iterator to the smallest element as the first element and an iterator to the greatest element as the second. Returns {{c|std::make_pair(first, first)}} if the range is empty. If several elements are equivalent to the smallest element, the iterator to the first such element is returned. If several elements are equivalent to the largest element, the iterator to the last such element is returned.

===Complexity===
At most {{math|max(floor(3/2(N−1)), 0)}} applications of the predicate, where {{c|N {{=}} std::distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
std::pair&lt;ForwardIt, ForwardIt&gt; 
    minmax_element(ForwardIt first, ForwardIt last)
{
    typedef typename std::iterator_traits&lt;ForwardIt&gt;::value_type value_t;
    return std::minmax_element(first, last, std::less&lt;value_t&gt;());
}
 | 2=
template&lt;class ForwardIt, class Compare&gt;
std::pair&lt;ForwardIt, ForwardIt&gt; 
    minmax_element(ForwardIt first, ForwardIt last, Compare comp)
{
    std::pair&lt;ForwardIt, ForwardIt&gt; result(first, first);
    
    if (first == last) return result;
    if (++first == last) return result;

    if (comp(*first, *result.first)) {
        result.first = first;
    } else {
        result.second = first;
    }
    while (++first != last) {
        ForwardIt i = first;
        if (++first == last) {
            if (comp(*i, *result.first)) result.first = i;
            else if (!(comp(*i, *result.second))) result.second = i;
            break;
        } else {
            if (comp(*first, *i)) {
                if (comp(*first, *result.first)) result.first = first;
                if (!(comp(*i, *result.second))) result.second = i;
            } else {
                if (comp(*i, *result.first)) result.first = i;
                if (!(comp(*first, *result.second))) result.second = first;
            }
        }
    }
    return result;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
int main()
{
    std::vector&lt;int&gt; v = { 3, 9, 1, 4, 2, 5, 9 };
 
    auto result = std::minmax_element(v.begin(), v.end());
    std::cout &lt;&lt; &quot;min element at: &quot; &lt;&lt; (result.first - v.begin()) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;max element at: &quot; &lt;&lt; (result.second - v.begin()) &lt;&lt; '\n';
}
 | output=
min element at: 2
max element at: 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc end}}

[[de:cpp/algorithm/minmax element]]
[[es:cpp/algorithm/minmax element]]
[[fr:cpp/algorithm/minmax element]]
[[it:cpp/algorithm/minmax element]]
[[ja:cpp/algorithm/minmax element]]
[[pt:cpp/algorithm/minmax element]]
[[ru:cpp/algorithm/minmax element]]
[[zh:cpp/algorithm/minmax element]]</text>
      <sha1>ancdojby7itnlr5vxpkgmgr0g4srnt6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/mismatch</title>
    <ns>0</ns>
    <id>757</id>
    <revision>
      <id>62648</id>
      <parentid>57009</parentid>
      <timestamp>2013-07-01T23:31:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="4113">{{cpp/title|mismatch}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2 &gt;
std::pair&lt;InputIt1,InputIt2&gt;
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2 );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2, class BinaryPredicate &gt;
std::pair&lt;InputIt1,InputIt2&gt;
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2,
              BinaryPredicate p );
}}
{{dcl | num=3 | since=c++14 |
template&lt; class InputIt1, class InputIt2 &gt;
std::pair&lt;InputIt1,InputIt2&gt;
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2 );
}}
{{dcl | num=4 | since=c++14 |
template&lt; class InputIt1, class InputIt2, class BinaryPredicate &gt;
std::pair&lt;InputIt1,InputIt2&gt;
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2,
              BinaryPredicate p );
}}

{{dcl end}}

Returns the first mismatching pair of elements from two ranges: one defined by {{tt|[first1, last1)}} and another defined by {{tt|[first2,last2)}}. If {{tt|last2}} is not provided (overloads (1) and (2)), it denotes {{tt|first2 + (last1 - first1)}}.

Overloads (1) and (3) use  {{tt|operator{{==}}}} to compare the elements, the overloads (2) and (4) use the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of the elements}}
{{par | first2, last2 | the second range of the elements}}
{{par pred2 eq | p | p1=InputIt1 | p2=InputIt2}}
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | BinaryPredicate | BinaryPredicate}}
{{par end}}

===Return value===
{{lc|std::pair}} with iterators to the first two non-equivalent elements.

{{rev begin}}
{{rev | until=c++14 | If no mismatches are found when the comparison reaches {{tt|last1}}, the pair holds {{tt|last1}} and the corresponding iterator from the second range. The behavior is undefined if the second range is shorter than the first range.
}}
{{rev | since=c++14 | If no mismatches are found when the comparison reaches {{tt|last1}} or {{tt|last2}}, whichever happens first, the pair holds the end iterator and the corresponding iterator from the other range.
}}
{{rev end}}

===Complexity===
At most {{tt|last1}} - {{tt|first1}} applications of the predicate

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2&gt;
std::pair&lt;InputIt1, InputIt2&gt;
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{
    while (first1 != last1 &amp;&amp; *first1 == *first2) {
        ++first1, ++first2;
    }
    return std::make_pair(first1, first2);
}
| 2=
template&lt;class InputIt1, class InputIt2, class BinaryPredicate&gt;
std::pair&lt;InputIt1, InputIt2&gt;
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
{
    while (first1 != last1 &amp;&amp; p(*first1, *first2)) {
        ++first1, ++first2;
    }
    return std::make_pair(first1, first2);
}
}}

===Example===

{{example
 | This program determines the longest substring that is simultaneously found at the very beginning of the given string and at the very end of it, in reverse order (possibly overlapping)
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;

std::string mirror_ends(const std::string&amp; in)
{
    return std::string(in.begin(),
                       std::mismatch(in.begin(), in.end(), in.rbegin()).first);
}

int main()
{
    std::cout &lt;&lt; mirror_ends(&quot;abXYZba&quot;) &lt;&lt; '\n'
              &lt;&lt; mirror_ends(&quot;abca&quot;) &lt;&lt; '\n'
              &lt;&lt; mirror_ends(&quot;aba&quot;) &lt;&lt; '\n';
}
 | output=
ab
a
aba
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/algorithm/mismatch]]
[[es:cpp/algorithm/mismatch]]
[[fr:cpp/algorithm/mismatch]]
[[it:cpp/algorithm/mismatch]]
[[ja:cpp/algorithm/mismatch]]
[[pt:cpp/algorithm/mismatch]]
[[ru:cpp/algorithm/mismatch]]
[[zh:cpp/algorithm/mismatch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/move</title>
    <ns>0</ns>
    <id>2480</id>
    <revision>
      <id>66372</id>
      <parentid>65931</parentid>
      <timestamp>2013-11-14T17:58:27Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>formatting</comment>
      <text xml:space="preserve" bytes="2893">{{cpp/title|move}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 |
template&lt; class InputIt, class OutputIt &gt;
OutputIt move( InputIt first, InputIt last, OutputIt d_first );
}}
{{dcl end}}

Moves the elements in the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}}. After this operation the elements in the moved-from range will still contain valid values of the appropriate type, but not necessarily the same values as before the move.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to move}}
{{par | d_first | the beginning of the destination range. If {{tt|d_first}} is within {{tt|[first, last)}}, {{lc|std::move_backward}} must be used instead of [[cpp/algorithm/move#top | &lt;!--Manually apply syntax highlighting while avoiding automatic hyperlinking to the utility function rather than the algorithm--&gt;&lt;span class=&quot;mw-geshi cpp source-cpp&quot;&gt;std::move&lt;/span&gt;]]. }}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Output iterator to the element past the last element moved ({{c|d_first + (last - first)}})

===Complexity===
Exactly {{tt|last - first}} move assignments.

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class OutputIt&gt;
OutputIt move(InputIt first, InputIt last, OutputIt d_first)
{
    while (first != last) {
        *d_first++ = std::move(*first++);
    }
    return d_first;
}
}}

===Notes===

When moving overlapping ranges, {{tt|std::move}} is appropriate when moving to the left (beginning of the destination range is outside the source range) while {{tt|std::move_backward}} is appropriate when moving to the right (end of the destination range is outside the source range).

===Example===
The following code moves thread objects (which themselves are not copyable) from one container to another.

{{example
 |code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;list&gt;
#include &lt;iterator&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void f(int n)
{
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout &lt;&lt; &quot;thread &quot; &lt;&lt; n &lt;&lt; &quot; ended&quot; &lt;&lt; '\n';
}

int main() 
{
    std::vector&lt;std::thread&gt; v;
    v.emplace_back(f, 1);
    v.emplace_back(f, 2);
    v.emplace_back(f, 3);
    std::list&lt;std::thread&gt; l;
    // copy() would not compile, because std::thread is noncopyable

    std::move(v.begin(), v.end(), std::back_inserter(l)); 
    for (auto&amp; t : l) t.join();
}

 | output=
thread 1 ended
thread 2 ended
thread 3 ended
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc move_backward}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc end}}

[[de:cpp/algorithm/move]]
[[es:cpp/algorithm/move]]
[[fr:cpp/algorithm/move]]
[[it:cpp/algorithm/move]]
[[ja:cpp/algorithm/move]]
[[pt:cpp/algorithm/move]]
[[ru:cpp/algorithm/move]]
[[zh:cpp/algorithm/move]]</text>
      <sha1>lf5i6n3gv4g58qh4lpoqdcqhqhtm00o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/move backward</title>
    <ns>0</ns>
    <id>2479</id>
    <revision>
      <id>65287</id>
      <parentid>63648</parentid>
      <timestamp>2013-09-06T22:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix the off-by-one in the UB note</comment>
      <text xml:space="preserve" bytes="3070">{{cpp/title|move_backward}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 |
template&lt; class BidirIt1, class BidirIt2 &gt;
BidirIt2 move_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last );
}}
{{dcl end}}

Moves the elements from the range {{tt|[first, last)}}, to another range ending at {{tt|d_last}}. The elements are moved in reverse order (the last element is moved first), but their relative order is preserved. 

The behavior is undefined if {{tt|d_last}} is within {{tt|(first, last]}}.  [[cpp/algorithm/move | &lt;!--Manually apply syntax highlighting while avoiding automatic hyperlinking to the utility function rather than the algorithm--&gt;&lt;span class=&quot;mw-geshi cpp source-cpp&quot;&gt;std::move&lt;/span&gt;]] must be used instead of {{tt|std::move_backward}} in that case.

===Parameters===
{{par begin}}
{{par | first, last | the range of the elements to move}}
{{par | d_last | end of the destination range }}
{{par hreq}}
{{par req concept | BidirIt1, BidirIt2 | BidirectionalIterator}}
{{par end}}

===Return value===
Iterator in the destination range, pointing at the last element moved.

===Complexity===
Exactly {{tt|last - first}} move assignments.

===Possible implementation===
{{eq fun | 1=
template&lt; class BidirIt1, class BidirIt2 &gt;
BidirIt2 move_backward(BidirIt1 first,
                                     BidirIt1 last,
                                     BidirIt2 d_last)
{
    while (first != last) {
        *(--d_last) = std::move(*(--last));
    }
    return d_last;
}
}}

===Notes===

When moving overlapping ranges, {{tt|std::move}} is appropriate when moving to the left (beginning of the destination range is outside the source range) while {{tt|std::move_backward}} is appropriate when moving to the right (end of the destination range is outside the source range).

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;std::string&gt; src{&quot;foo&quot;, &quot;bar&quot;, &quot;baz&quot;};
    std::vector&lt;std::string&gt; dest(src.size());

    std::cout &lt;&lt; &quot;src: &quot;;
    for (const auto &amp;s : src)
    {
        std::cout &lt;&lt; s &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; &quot;\ndest: &quot;;
    for (const auto &amp;s : dest)
    {
        std::cout &lt;&lt; s &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; '\n';

    std::move_backward(src.begin(), src.end(), dest.end());

    std::cout &lt;&lt; &quot;src: &quot;;                                                       
    for (const auto &amp;s : src)
    {
        std::cout &lt;&lt; s &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; &quot;\ndest: &quot;;
    for (const auto &amp;s : dest)
    {
        std::cout &lt;&lt; s &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; '\n';
}
 | output=
src: foo bar baz 
dest:    
src:    
dest: foo bar baz 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc move}}
{{dsc end}}

[[de:cpp/algorithm/move backward]]
[[es:cpp/algorithm/move backward]]
[[fr:cpp/algorithm/move backward]]
[[it:cpp/algorithm/move backward]]
[[ja:cpp/algorithm/move backward]]
[[pt:cpp/algorithm/move backward]]
[[ru:cpp/algorithm/move backward]]
[[zh:cpp/algorithm/move backward]]</text>
      <sha1>h9ua1obbu9g3rqi3tnxz58z2ascw683</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/next permutation</title>
    <ns>0</ns>
    <id>758</id>
    <revision>
      <id>57014</id>
      <parentid>49269</parentid>
      <timestamp>2013-06-01T05:45:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2689">{{cpp/title|next_permutation}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class BidirIt &gt;
bool next_permutation( BidirIt first, BidirIt last );
}}
{{dcl |  num=2 |
template&lt; class BidirIt, class Compare &gt;
bool next_permutation( BidirIt first, BidirIt last, Compare comp );
}}
{{dcl end}}

Transforms the range {{tt|[first, last)}} into the next permutation from the set of all permutations that are lexicographically ordered with respect to {{tt|operator&lt;}} or {{tt|comp}}. Returns {{c|true}} if such permutation exists, otherwise transforms the range into the first permutation (as if by {{tt|std::sort(first, last)}}) and returns {{c|false}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to permute }}
{{par cmp | comp | p1=BidirIt}} 
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator | ValueSwappable}}
{{par end}}

===Return value===
{{c|true}} if the new permutation is lexicographically greater than the old. {{c|false}} if the last permutation was reached and the range was reset to the first permutation.

===Exceptions===
Any exceptions thrown from iterator operations or the element swap.

===Complexity===
At most {{math|N/2}} swaps, where {{c|1=N = std::distance(first, last)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class BidirIt&gt;
bool next_permutation(BidirIt first, BidirIt last)
{
    if (first == last) return false;
    BidirIt i = last;
    if (first == --i) return false;

    while (1) {
        BidirIt i1, i2;

        i1 = i;
        if (*--i &lt; *i1) {
            i2 = last;
            while (!(*i &lt; *--i2))
                ;
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}
}}

===Example===
{{example
 | The following code prints all three permutations of the string &quot;aba&quot;
 | code=
#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{
    std::string s = &quot;aba&quot;;
    std::sort(s.begin(), s.end());
    do {
        std::cout &lt;&lt; s &lt;&lt; '\n';
    } while(std::next_permutation(s.begin(), s.end()));
}
 | output=
aab
aba
baa
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}

[[de:cpp/algorithm/next permutation]]
[[es:cpp/algorithm/next permutation]]
[[fr:cpp/algorithm/next permutation]]
[[it:cpp/algorithm/next permutation]]
[[ja:cpp/algorithm/next permutation]]
[[pt:cpp/algorithm/next permutation]]
[[ru:cpp/algorithm/next permutation]]
[[zh:cpp/algorithm/next permutation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/none of</title>
    <ns>0</ns>
    <id>2545</id>
    <redirect title="cpp/algorithm/all any none of" />
    <revision>
      <id>9315</id>
      <timestamp>2011-08-21T16:07:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/algorithm/all_any_none_of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/nth element</title>
    <ns>0</ns>
    <id>759</id>
    <revision>
      <id>68848</id>
      <parentid>67350</parentid>
      <timestamp>2014-03-22T17:27:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2339</comment>
      <text xml:space="preserve" bytes="2920">{{cpp/title|nth_element}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void nth_element( RandomIt first, RandomIt nth, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void nth_element( RandomIt first, RandomIt nth, RandomIt last, Compare comp );
}}
{{dcl end}}

{{tt|nth_element}} is a partial sorting algorithm that rearranges elements in {{tt|[first, last)}} such that:

* The element pointed at by {{tt|nth}} is changed to whatever element would occur in that position if {{tt|[first, last)}} was sorted.
* All of the elements before this new {{tt|nth}} element are less than or equal to the elements after the new {{tt|nth}} element.

More formally, {{tt|nth_element}} partially sorts the range {{tt|[first, last)}} in ascending order so that the condition {{c|!(*j &lt; *i)}} (for the first version, or {{c|comp(*j, *i) {{==}} false}} for the second version) is met for any {{tt|i}} in the range {{tt|[first, nth)}} and for any {{tt|j}} in the range {{tt|[nth, last)}}. The element placed in the {{tt|nth}} position is exactly the element that would occur in this position if the range was fully sorted.

{{tt|nth}} may be the end iterator, in this case the function has no effect.

===Parameters===
{{par begin}}
{{par | first, last | random access iterators defining the range sort}}
{{par | nth | random access iterator defining the sort partition point}} 
{{par cmp ord | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===

Linear in {{c|std::distance(first, last)}} on average.

===Notes===
The algorithm used is typically [[enwiki::Introselect|introselect]] although other [[enwiki::Selection algorithm|selection algorithms]] with suitable average-case complexity are allowed.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;

int main()
{
    std::vector&lt;int&gt; v{5, 6, 4, 3, 2, 6, 7, 9, 3};

    std::nth_element(v.begin(), v.begin() + v.size()/2, v.end());
    std::cout &lt;&lt; &quot;The median is &quot; &lt;&lt; v[v.size()/2] &lt;&lt; '\n';

    std::nth_element(v.begin(), v.begin()+1, v.end(), std::greater&lt;int&gt;());
    std::cout &lt;&lt; &quot;The second largest element is &quot; &lt;&lt; v[1] &lt;&lt; '\n';
}
 | output=
The median is 5
The second largest element is 7
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc end}}

[[de:cpp/algorithm/nth element]]
[[es:cpp/algorithm/nth element]]
[[fr:cpp/algorithm/nth element]]
[[it:cpp/algorithm/nth element]]
[[ja:cpp/algorithm/nth element]]
[[pt:cpp/algorithm/nth element]]
[[ru:cpp/algorithm/nth element]]
[[zh:cpp/algorithm/nth element]]</text>
      <sha1>fq98amxyqan1ldsi9fu0tpwmlvv518k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partial sort</title>
    <ns>0</ns>
    <id>760</id>
    <revision>
      <id>67351</id>
      <parentid>66561</parentid>
      <timestamp>2014-02-05T20:31:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="2060">{{cpp/title|partial_sort}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void partial_sort( RandomIt first, RandomIt middle, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void partial_sort( RandomIt first, RandomIt middle, RandomIt last, Compare comp );
}}
{{dcl end}}

Rearranges elements such that the range {{tt|[first, middle)}} contains the sorted {{tt|middle - first}} smallest elements in the range {{tt|[first, last)}}.

The order of equal elements is not guaranteed to be preserved. The order of the remaining elements in the range {{tt|[middle, last)}} is unspecified. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par cmp ord | comp | p1=RandomIt}}
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}} 
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}} 
{{par end}}

===Return value===
(none)

===Complexity===
Approximately {{math|(last-first)log(middle-first))}} applications of {{tt|cmp}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;array&gt;
#include &lt;iostream&gt;

int main()
{
    std::array&lt;int, 10&gt; s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
  
    std::partial_sort(s.begin(), s.begin() + 3, s.end());
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    } 
}
 | output=
0 1 2 7 8 6 5 9 4 3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc nth_element}}
{{dsc inc | cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc end}}

[[de:cpp/algorithm/partial sort]]
[[es:cpp/algorithm/partial sort]]
[[fr:cpp/algorithm/partial sort]]
[[it:cpp/algorithm/partial sort]]
[[ja:cpp/algorithm/partial sort]]
[[pt:cpp/algorithm/partial sort]]
[[ru:cpp/algorithm/partial sort]]
[[zh:cpp/algorithm/partial sort]]</text>
      <sha1>2hv8g2bqzy207j52d0chgb5tp2wr4yb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partial sort copy</title>
    <ns>0</ns>
    <id>761</id>
    <revision>
      <id>67352</id>
      <parentid>65725</parentid>
      <timestamp>2014-02-05T20:31:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="3603">{{cpp/title|partial_sort_copy}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class RandomIt &gt;
RandomIt partial_sort_copy( InputIt first, InputIt last,
                            RandomIt d_first, RandomIt d_last );
}}
{{dcl | num=2 |
template&lt; class InputIt, class RandomIt, class Compare &gt;
RandomIt partial_sort_copy( InputIt first, InputIt last,
                            RandomIt d_first, RandomIt d_last,
                            Compare comp );
}}
{{dcl end}}

Sorts some of the elements in the range {{tt|[first, last)}} in ascending order, storing the result in the range {{tt|[d_first, d_last)}}.

At most {{c|d_last - d_first}} of the elements are moved to the range {{tt|[d_first, d_first + n)}} and then sorted. {{tt|n}} is the number of elements to sort ({{c|1=n = min(last - first, d_last - d_first)}}). The order of equal elements is not guaranteed to be preserved. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par | d_first, d_last | random access iterators defining the destination range}}
{{par cmp ord | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
an iterator to the element defining the upper boundary of the sorted range, i.e. {{c|d_first + min(last - first, d_last - d_first)}}.

===Complexity===
{{math|O(N&amp;middot;log(min(D,N))}}, where {{c|1=N = std::distance(first, last)}}, {{c|1=D = std::distance(d_first, d_last)}} applications of {{tt|cmp}}.

===Example===
{{example
 | The following code sorts an vector of integers and copies them into a smaller and a larger vector.
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; v0{4, 2, 5, 1, 3};
    std::vector&lt;int&gt; v1{10, 11, 12};
    std::vector&lt;int&gt; v2{10, 11, 12, 13, 14, 15, 16};
    std::vector&lt;int&gt;::iterator it;

    it = std::partial_sort_copy(v0.begin(), v0.end(), v1.begin(), v1.end());

    std::cout &lt;&lt; &quot;Writing to the smaller vector in ascending order gives: &quot;;
    for (int a : v1) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
    if(it == v1.end())
        std::cout &lt;&lt; &quot;The return value is the end iterator\n&quot;;

    it = std::partial_sort_copy(v0.begin(), v0.end(), v2.begin(), v2.end(), 
                                std::greater&lt;int&gt;());

    std::cout &lt;&lt; &quot;Writing to the larger vector in descending order gives: &quot;;
    for (int a : v2) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n' &lt;&lt; &quot;The return value is the iterator to &quot; &lt;&lt; *it &lt;&lt; '\n';
}
 | output=
Writing to the smaller vector in ascending order gives: 1 2 3
The return value is the end iterator
Writing to the larger vector in descending order gives: 5 4 3 2 1 15 16
The return value is the iterator to 15
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc end}}

[[de:cpp/algorithm/partial sort copy]]
[[es:cpp/algorithm/partial sort copy]]
[[fr:cpp/algorithm/partial sort copy]]
[[it:cpp/algorithm/partial sort copy]]
[[ja:cpp/algorithm/partial sort copy]]
[[pt:cpp/algorithm/partial sort copy]]
[[ru:cpp/algorithm/partial sort copy]]
[[zh:cpp/algorithm/partial sort copy]]</text>
      <sha1>6vgxjcywzgp6plb8qo40oyixrye4p3b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partial sum</title>
    <ns>0</ns>
    <id>762</id>
    <revision>
      <id>70456</id>
      <parentid>66416</parentid>
      <timestamp>2014-05-23T03:02:09Z</timestamp>
      <contributor>
        <ip>70.83.152.52</ip>
      </contributor>
      <comment>fix indent</comment>
      <text xml:space="preserve" bytes="3560">{{cpp/title|partial_sum}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | numeric}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt &gt;
OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt, class OutputIt, class BinaryOperation &gt;
OutputIt partial_sum( InputIt first, InputIt last, OutputIt d_first,
                      BinaryOperation op );
}}
{{dcl end}}

Computes the partial sums of the elements in the subranges of the range {{tt|[first, last)}} and writes them to the range beginning at {{tt|d_first}}. The first version uses {{tt|operator+}} to sum up the elements, the second version uses the given binary function {{tt|op}}.

Equivalent operation:

{{source|1=
*(d_first)   = *first;
*(d_first+1) = *first + *(first+1);
*(d_first+2) = *first + *(first+1) + *(first+2);
*(d_first+3) = *first + *(first+1) + *(first+2) + *(first+3);
...
}}

{{rev begin}}
{{rev | until=c++11 |
{{tt|op}} must not have side effects.
}}
{{rev | since=c++11 |
{{tt|op}} must not invalidate any iterators, including the end iterators, or modify any elements of the ranges involved.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sum}}
{{par | d_first | the beginning of the destination range}}
{{par op2 | op | t1=iterator_traits&lt;InputIt&gt;::value_type | p2=InputIt | rt=iterator_traits&lt;InputIt&gt;::value_type}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Iterator to the element past the last element written.

===Complexity===
Exactly {{tt|(last - first) - 1}} applications of the binary operation

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class OutputIt&gt;
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first)
{
    return std::partial_sum(first, last, d_first, 
                            std::plus&lt;InputIt, InputIt&gt;());
}
 | 2 = 
template&lt;class InputIt, class OutputIt, class BinaryOperator&gt;
OutputIt partial_sum(InputIt first, InputIt last, 
                     OutputIt d_first, BinaryOperation op)
{
    if (first == last) return d_first;

    typename std::iterator_traits&lt;InputIt&gt;::value_type sum = *first;
    *d_first = sum;

    while (++first != last) {
       sum = op(sum, *first);
       *++d_first = sum;
    }
    return ++d_first;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;numeric&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;functional&gt;

int main()
{
    std::vector&lt;int&gt; v = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};

    std::cout &lt;&lt; &quot;The first 10 even numbers are: &quot;;
    std::partial_sum(v.begin(), v.end(), 
                     std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';

    std::partial_sum(v.begin(), v.end(), v.begin(), std::multiplies&lt;int&gt;());
    std::cout &lt;&lt; &quot;The first 10 powers of 2 are: &quot;;
    for (auto n : v) {
        std::cout &lt;&lt; n &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
}
 | output=
The first 10 even numbers are: 2 4 6 8 10 12 14 16 18 20 
The first 10 powers of 2 are: 2 4 8 16 32 64 128 256 512 1024 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc adjacent_difference}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc end}}

[[de:cpp/algorithm/partial sum]]
[[es:cpp/algorithm/partial sum]]
[[fr:cpp/algorithm/partial sum]]
[[it:cpp/algorithm/partial sum]]
[[ja:cpp/algorithm/partial sum]]
[[pt:cpp/algorithm/partial sum]]
[[ru:cpp/algorithm/partial sum]]
[[zh:cpp/algorithm/partial sum]]</text>
      <sha1>ljvyl5vijxbr9weypqe2vcb6x5p64q6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partition</title>
    <ns>0</ns>
    <id>763</id>
    <revision>
      <id>65859</id>
      <parentid>65429</parentid>
      <timestamp>2013-10-11T06:37:01Z</timestamp>
      <contributor>
        <username>Newacct</username>
        <id>2520</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4613">{{cpp/title|partition}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class BidirIt, class UnaryPredicate &gt;
BidirectionalIterator partition( BidirIt first, BidirIt last,
                                 UnaryPredicate p );
}}
{{dcl | since=c++11 |
template&lt; class ForwardIt, class UnaryPredicate &gt;
ForwardIt partition( ForwardIt first, ForwardIt last,
                     UnaryPredicate p );
}}
{{dcl rev end}}
{{dcl end}}

Reorders the elements in the range {{tt|[first, last)}} in such a way that all elements for which the predicate {{tt|p}} returns {{c|true}} precede the elements for which predicate {{tt|p}} returns {{c|false}}. Relative order of the elements is not preserved. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to reorder}}
{{par pred1 | p | if the element should be ordered before other elements | p1=ForwardIt}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | ForwardIt | ForwardIterator | ValueSwappable | notes=However, the operation is more efficient if {{tt|ForwardIt}} also satisfies the requirements of {{concept|BidirectionalIterator}}}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
Iterator to the first element of the second group.

===Complexity===
Exactly {{c|last-first}} applications of the predicate and at most {{c|last-first}} swaps. If {{tt|ForwardIt}}  meets the requirements of {{concept|BidirectionalIterator}} at most {{c|(last-first)/2}} swaps are done.

===Possible implementation===
{{eq fun | 1=
template&lt;class BidirIt, class UnaryPredicate&gt;
BidirIt partition(BidirIt first, BidirIt last, UnaryPredicate p)
{
    while (1) {
        while ((first != last) &amp;&amp; p(*first)) {
            ++first;
        }
        if (first == last--) break;
        while ((first != last) &amp;&amp; !p(*last)) {
            --last;
        }
        if (first == last) break;
        std::iter_swap(first++, last);
    }
    return first;
}

}}

===Example 1===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

bool is_even(int i) { return i % 2 == 0; }

int main()
{
    std::vector&lt;int&gt; v;
    for (int i = 0; i &lt; 10; ++i) v.push_back(i);
    
    std::cout &lt;&lt; &quot;Original vector:\n    &quot;;
    std::copy(v.begin(), v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    
    // Partition the vector
    std::vector&lt;int&gt;::iterator p =
        std::partition(v.begin(), v.end(), std::ptr_fun(is_even));
    
    std::cout &lt;&lt; &quot;\nPartitioned vector:\n    &quot;;
    std::copy(v.begin(), v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\nBefore partition:\n    &quot;;
    std::copy(v.begin(), p,       std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\nAfter partition:\n    &quot;;
    std::copy(p,         v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
| p=true
| output =
Original vector:
    0 1 2 3 4 5 6 7 8 9 
Partitioned vector:
    0 8 2 6 4 5 3 7 1 9 
Before partition:
    0 8 2 6 4 
After partition:
    5 3 7 1 9 
}}

===Example 2===
{{example
 |
 | code=
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;forward_list&gt;
#include &lt;iostream&gt;

template &lt;class ForwardIt&gt;
 ForwardIt choose_pivot(ForwardIt first, ForwardIt last)
 {
   return std::next(first, std::distance(first,last)/2);
 }

template &lt;class ForwardIt&gt;
 void quicksort(ForwardIt first, ForwardIt last)
 {
    using T = typename std::iterator_traits&lt;ForwardIt&gt;::value_type;
    
    if(first == last) return;
    
    T pivot = *choose_pivot(first,last);
    
    ForwardIt middle1 = std::partition(first, last, 
                         [pivot](const T&amp; em){ return em &lt; pivot; });
    ForwardIt middle2 = std::partition(middle1, last, 
                         [pivot](const T&amp; em){ return !(pivot &lt; em); });
    
    quicksort(first, middle1);
    quicksort(middle2, last);
 }
 
 
int main()
{
   std::forward_list&lt;int&gt; fl = {1, 30, -4, 3, 5, -4, 1, 6, -8, 2, -5, 64, 1, 92};
  
   quicksort(std::begin(fl), std::end(fl));
   
   for(int fi : fl) std::cout &lt;&lt; fi &lt;&lt; ' ';
   std::cout &lt;&lt; '\n';
}
| output =
-8 -5 -4 -4 1 1 1 2 3 5 6 30 64 92 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_partitioned}}
{{dsc inc | cpp/algorithm/dsc stable_partition}}
{{dsc end}}

[[de:cpp/algorithm/partition]]
[[es:cpp/algorithm/partition]]
[[fr:cpp/algorithm/partition]]
[[it:cpp/algorithm/partition]]
[[ja:cpp/algorithm/partition]]
[[pt:cpp/algorithm/partition]]
[[ru:cpp/algorithm/partition]]
[[zh:cpp/algorithm/partition]]</text>
      <sha1>h7msa5qobizhj4k8ghk9ytqlw4y50hh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partition copy</title>
    <ns>0</ns>
    <id>2581</id>
    <revision>
      <id>68847</id>
      <parentid>62651</parentid>
      <timestamp>2014-03-22T17:25:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>dereferenced InputIt has to be CopyAssignable (lwg 2357), also undef behavior on overlap</comment>
      <text xml:space="preserve" bytes="3554">{{cpp/title|partition_copy}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | since=c++11 |
template&lt; class InputIt, class OutputIt1,
          class OutputIt2, class UnaryPredicate &gt;
std::pair&lt;OutputIt1, OutputIt2&gt;
     partition_copy( InputIt first, InputIt last,
                     OutputIt1 d_first_true, OutputIt2 d_first_false,
                     UnaryPredicate p );
}}
{{dcl end}}

Copies the elements from the range {{tt|[first, last)}} to two different ranges depending on the value returned by the predicate {{tt|p}}. The elements, that satisfy the predicate {{tt|p}}, are copied to the range beginning at {{tt|d_first_true}}. The rest of the elements are copied to the range beginning at {{tt|d_first_false}}.

The behavior is undefined if the input range overlaps either of the output ranges.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par | d_first_true | the beginning of the output range for the elements that satisfy p}}
{{par | d_first_false | the beginning of the output range for the elements that do not satisfy p}}
{{par pred1 | p | if the element should be placed in d_first_true | p1=InputIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept deref | InputIt | CopyAssignable}}
{{par req concept | OutputIt1 | OutputIterator}}
{{par req concept | OutputIt2 | OutputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
A {{c|pair}} constructed from the iterator to the end of the {{tt|d_first_true}} range and the iterator to the end of the {{tt|d_first_false}} range.

===Complexity===

Exactly {{tt|distance(first, last)}} applications of {{tt|p}}.

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class OutputIt1,
         class OutputIt2, class UnaryPredicate&gt;
std::pair&lt;OutputIt1, OutputIt2&gt;
    partition_copy(InputIt first, InputIt last,
                   OutputIt1 d_first_true, OutputIt2 d_first_false,
                   UnaryPredicate p)
{
    while (first != last) {
        if (p(*first)) {
            *d_first_true = *first;
            ++d_first_true;
        } else {
            *d_first_false = *first;
            ++d_first_false;
        }
        ++first;
    }
    return std::pair&lt;OutputIt1, OutputIt2&gt;(d_first_true, d_first_false);
}
}}

===Example===
{{example
 |
 | code= 

#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;utility&gt;

int main()
{
    int arr [10] = {1,2,3,4,5,6,7,8,9,10};
    int true_arr [5] = {0};
    int false_arr [5] = {0};

    std::partition_copy(std::begin(arr), std::end(arr), std::begin(true_arr),std::begin(false_arr),
                        [] (int i) {return i &gt; 5;});

    std::cout &lt;&lt; &quot;true_arr: &quot;;
    for (auto it = std::begin(true_arr); it != std::end(true_arr); ++it) {
        std::cout &lt;&lt; *it &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n'; 

    std::cout &lt;&lt; &quot;false_arr: &quot;;
    for (auto it = std::begin(false_arr); it != std::end(false_arr); ++it) {
        std::cout &lt;&lt; *it &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n'; 

    return 0;

}

 | output= 
true_arr: 6 7 8 9 10
false_arr: 1 2 3 4 5

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc inc | cpp/algorithm/dsc stable_partition}}
{{dsc end}}

[[de:cpp/algorithm/partition copy]]
[[es:cpp/algorithm/partition copy]]
[[fr:cpp/algorithm/partition copy]]
[[it:cpp/algorithm/partition copy]]
[[ja:cpp/algorithm/partition copy]]
[[pt:cpp/algorithm/partition copy]]
[[ru:cpp/algorithm/partition copy]]
[[zh:cpp/algorithm/partition copy]]</text>
      <sha1>egujergou4jjadqwo43g8du4m0m7y0i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/partition point</title>
    <ns>0</ns>
    <id>2582</id>
    <revision>
      <id>67253</id>
      <parentid>62652</parentid>
      <timestamp>2014-01-29T17:52:48Z</timestamp>
      <contributor>
        <ip>72.5.190.173</ip>
      </contributor>
      <comment>Fixed complexity</comment>
      <text xml:space="preserve" bytes="2158">{{cpp/title|partition_point}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | since=c++11 |
template&lt; class ForwardIt, class UnaryPredicate &gt;
ForwardIt partition_point( ForwardIt first, ForwardIt last, UnaryPredicate p );
}}
{{dcl end}}

Examines the partitioned (as if by {{lc|std::partition}}) range {{tt|[first, last)}} and locates the end of the first partition, that is, the first element that does not satisfy {{tt|p}} or {{tt|last}} if all elements satisfy {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first, last | the partitioned range of elements to examine}}
{{par pred1 | p | for the elements found in the beginning of the range | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
The iterator past the end of the first partition within {{tt|[first, last)}} or {{tt|last}} if all elements satisfy {{tt|p}}.

===Complexity===
The number of applications of the predicate p is logarithmic in the distance between {{tt|first}} and {{tt|last}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;array&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    std::array&lt;int, 9&gt; v = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    
    auto is_even = [](int i){ return i % 2 == 0; };
    std::partition(v.begin(), v.end(), is_even);
    
    auto p = std::partition_point(v.begin(), v.end(), is_even);
    
    std::cout &lt;&lt; &quot;Before partition:\n    &quot;;
    std::copy(v.begin(), p, std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\nAfter partition:\n    &quot;;
    std::copy(p, v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
 | output=
Before partition:
    8 2 6 4 
After partition:
    5 3 7 1 9 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_sorted}}
{{dsc end}}

[[de:cpp/algorithm/partition point]]
[[es:cpp/algorithm/partition point]]
[[fr:cpp/algorithm/partition point]]
[[it:cpp/algorithm/partition point]]
[[ja:cpp/algorithm/partition point]]
[[pt:cpp/algorithm/partition point]]
[[ru:cpp/algorithm/partition point]]
[[zh:cpp/algorithm/partition point]]</text>
      <sha1>avud82uo8zkn7to5az2443s7yo0bo7v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/pop heap</title>
    <ns>0</ns>
    <id>764</id>
    <revision>
      <id>69144</id>
      <parentid>63738</parentid>
      <timestamp>2014-03-28T16:01:10Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2385">{{cpp/title|pop_heap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void pop_heap( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void pop_heap( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Swaps the value in the position {{tt|first}} and the value in the position {{tt|last-1}} and makes the subrange {{tt|[first, last-1)}} into a ''max heap''. This has the effect of removing the first (largest) element from the heap defined by the range {{tt|[first, last)}}.

The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements defining the valid nonempty heap to modify}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
At most ''2&amp;times;log(N)'' comparisons where {{c|1=N=std::distance(first, last)}}.

===Notes===
{{cpp/algorithm/notes heap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v { 3, 1, 4, 1, 5, 9 };

    std::make_heap(v.begin(), v.end());

    std::cout &lt;&lt; &quot;v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::pop_heap(v.begin(), v.end()); // moves the largest to the end

    std::cout &lt;&lt; &quot;after pop_heap: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    int largest = v.back();
    v.pop_back();  // actually removes the largest element
    std::cout &lt;&lt; &quot;largest element: &quot; &lt;&lt; largest &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;heap without largest: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
v: 9 5 4 1 1 3 
after pop_heap: 5 3 4 1 1 9 
largest element: 9
heap without largest: 5 3 4 1 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc push_heap}}
{{dsc end}}

[[de:cpp/algorithm/pop heap]]
[[es:cpp/algorithm/pop heap]]
[[fr:cpp/algorithm/pop heap]]
[[it:cpp/algorithm/pop heap]]
[[ja:cpp/algorithm/pop heap]]
[[pt:cpp/algorithm/pop heap]]
[[ru:cpp/algorithm/pop heap]]
[[zh:cpp/algorithm/pop heap]]</text>
      <sha1>898xqg11ql4p1z3onyr6ctr0nci0mfs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/prev permutation</title>
    <ns>0</ns>
    <id>765</id>
    <revision>
      <id>57033</id>
      <parentid>49278</parentid>
      <timestamp>2013-06-01T05:45:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2773">{{cpp/title|prev_permutation}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class BidirIt &gt;
bool prev_permutation( BidirIt first, BidirIt last);
}}
{{dcl |  num=2 |
template&lt; class BidirIt, class Compare &gt;
bool prev_permutation( BidirIt first, BidirIt last, Compare comp);
}}
{{dcl end}}

Transforms the range {{tt|[first, last)}} into the previous permutation from the set of all permutations that are lexicographically ordered with respect to {{tt|operator&lt;}} or {{tt|comp}}. Returns {{c|true}} if such permutation exists, otherwise transforms the range into the last permutation (as if by {{tt|std::sort(first, last); std::reverse(first, last);}}) and returns {{c|false}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to permute }}
{{par cmp | comp | p1=BidirIt}} 
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator | ValueSwappable}}
{{par end}}

===Return value===

{{c|true}} if the new permutation precedes the old in lexicographical order. {{c|false}} if the first permutation was reached and the range was reset to the last permutation.

===Exceptions===
Any exceptions thrown from iterator operations or the element swap.

===Complexity===

At most {{tt|(last-first)/2}} swaps.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class BidirIt&gt;
bool prev_permutation(BidirIt first, BidirIt last)
{
    if (first == last) return false;
    BidirIt i = last;
    if (first == --i) return false;

    while (1) {
        BidirIt i1, i2;

        i1 = i;
        if (*i1 &lt; *--i) {
            i2 = last;
            while (!(*--i2 &lt; *i))
                ;
            std::iter_swap(i, i2);
            std::reverse(i1, last);
            return true;
        }
        if (i == first) {
            std::reverse(first, last);
            return false;
        }
    }
}
}}

===Example===
{{example
 | The following code prints all six permutations of the string &quot;abc&quot; in reverse order
 | code=
#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;
int main()
{
    std::string s=&quot;abc&quot;;
    std::sort(s.begin(), s.end(), std::greater&lt;char&gt;());
    do {
        std::cout &lt;&lt; s &lt;&lt; ' ';
    } while(std::prev_permutation(s.begin(), s.end()));
    std::cout &lt;&lt; '\n';
}
 | output=
cba cab bca bac acb abc
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc is_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}

[[de:cpp/algorithm/prev permutation]]
[[es:cpp/algorithm/prev permutation]]
[[fr:cpp/algorithm/prev permutation]]
[[it:cpp/algorithm/prev permutation]]
[[ja:cpp/algorithm/prev permutation]]
[[pt:cpp/algorithm/prev permutation]]
[[ru:cpp/algorithm/prev permutation]]
[[zh:cpp/algorithm/prev permutation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/push heap</title>
    <ns>0</ns>
    <id>766</id>
    <revision>
      <id>69719</id>
      <parentid>69718</parentid>
      <timestamp>2014-04-20T23:04:29Z</timestamp>
      <contributor>
        <ip>84.52.101.196</ip>
      </contributor>
      <comment>Undo revision 69718 by [[Special:Contributions/84.52.101.196|84.52.101.196]] ([[User talk:84.52.101.196|talk]])</comment>
      <text xml:space="preserve" bytes="2049">{{cpp/title|push_heap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void push_heap( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void push_heap( RandomIt first, RandomIt last,
                Compare comp );
}}
{{dcl end}}

Inserts the element at the position {{tt|last-1}} into the ''max heap'' defined by the range {{tt|[first, last-1)}}. The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements defining the heap to modify}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
At most ''2&amp;times;log(N)'' comparisons where {{c|1=N=std::distance(first, last)}}.

===Notes===
{{cpp/algorithm/notes heap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v { 3, 1, 4, 1, 5, 9 };

    std::make_heap(v.begin(), v.end());

    std::cout &lt;&lt; &quot;v: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    v.push_back(6);

    std::cout &lt;&lt; &quot;before push_heap: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::push_heap(v.begin(), v.end());

    std::cout &lt;&lt; &quot;after push_heap: &quot;;
    for (auto i : v) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
v: 9 5 4 1 1 3 
before push_heap: 9 5 4 1 1 3 6 
after push_heap:  9 5 6 1 1 3 4 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc pop_heap}}
{{dsc end}}

[[de:cpp/algorithm/push heap]]
[[es:cpp/algorithm/push heap]]
[[fr:cpp/algorithm/push heap]]
[[it:cpp/algorithm/push heap]]
[[ja:cpp/algorithm/push heap]]
[[pt:cpp/algorithm/push heap]]
[[ru:cpp/algorithm/push heap]]
[[zh:cpp/algorithm/push heap]]</text>
      <sha1>aoac538jswa0a0ays78s23m4edfnyvm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/qsort</title>
    <ns>0</ns>
    <id>767</id>
    <revision>
      <id>64120</id>
      <parentid>64117</parentid>
      <timestamp>2013-08-13T17:22:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 64117 by [[Special:Contributions/132.188.32.22|132.188.32.22]] ([[User talk:132.188.32.22|talk]]) back to correct compare function</comment>
      <text xml:space="preserve" bytes="1938">{{cpp/title|qsort}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl |
void qsort( void *ptr, std::size_t count, std::size_t size,
            int (*comp)(const void *, const void *) );
}}
{{dcl end}}

Sorts the given array pointed to by {{tt|ptr}} in ascending order. The array contains {{tt|count}} elements of {{tt|size}} bytes. Function pointed to by {{tt|comp}} is used for object comparison.

If {{tt|comp}} indicates two elements as equivalent, their order is undefined.

===Parameters===
{{par begin}}
{{par | ptr | pointer to the array to sort}}
{{par | count | number of element in the array}}
{{par | size | size of each element in the array in bytes}}
{{par ccmp | comp }}
{{par end}}

===Return value===
(none)

===Notes===
The type of the elements of the array must be a ''trivial type'', otherwise the behavior is undefined.

===Example===
{{example
 | The following code sorts an array of integers using {{tt|qsort()}}.
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

int compare_ints(const void* a, const void* b)   // comparison function
{
    int arg1 = *reinterpret_cast&lt;const int*&gt;(a);
    int arg2 = *reinterpret_cast&lt;const int*&gt;(b);
    if(arg1 &lt; arg2) return -1;
    if(arg1 &gt; arg2) return 1;
    return 0;
}

int main()
{
    int a[] = { -2, 99, 0, -743, 2, 3, 4 };
    constexpr std::size_t size = sizeof(a)/sizeof(int);

    std::qsort(a, size, sizeof(int), compare_ints);

    for (int ai : a) std::cout &lt;&lt; ai &lt;&lt; ' ';
}
 | output=
-743 -2 0 2 3 4 99
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc bsearch}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/types/dsc is_trivial}}
{{dsc see c | c/algorithm/qsort}}
{{dsc end}}

[[de:cpp/algorithm/qsort]]
[[es:cpp/algorithm/qsort]]
[[fr:cpp/algorithm/qsort]]
[[it:cpp/algorithm/qsort]]
[[ja:cpp/algorithm/qsort]]
[[pl:cpp/algorithm/qsort]]
[[pt:cpp/algorithm/qsort]]
[[ru:cpp/algorithm/qsort]]
[[zh:cpp/algorithm/qsort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/random shuffle</title>
    <ns>0</ns>
    <id>768</id>
    <revision>
      <id>67910</id>
      <parentid>67897</parentid>
      <timestamp>2014-03-05T15:25:12Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3794">{{cpp/title|random_shuffle|shuffle}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 | notes={{mark|deprecated in C++14}} |
template&lt; class RandomIt &gt;
void random_shuffle( RandomIt first, RandomIt last );
}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
template&lt; class RandomIt, class RandomFunc &gt;
void random_shuffle( RandomIt first, RandomIt last, RandomFunc&amp; r );
}}
{{dcl | since=c++11 | notes={{mark|deprecated in C++14}} |
template&lt; class RandomIt, class RandomFunc &gt;
void random_shuffle( RandomIt first, RandomIt last, RandomFunc&amp;&amp; r );
}}
{{dcl rev end}}
{{dcl | num=3 | since=c++11 |
template&lt; class RandomIt, class URNG &gt;
void shuffle( RandomIt first, RandomIt last, URNG&amp;&amp; g );
}}
{{dcl end}}

Reorders the elements in the given range {{tt|[first, last)}} such that each possible permutation of those elements has equal probability of appearance.

@1@ The random number generator is implementation-defined, but the function {{lc|std::rand}} is often used.

@2@ The random number generator is the function object {{tt|r}}. 

@3@ The random number generator is the function object {{tt|g}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to shuffle randomly}}
{{par | r | function object returning a randomly chosen value of type convertible to  {{tt|iterator_traits&lt;RandomIt&gt;::difference_type}} in the interval [0,n) if invoked as {{tt|r(n)}} }}
{{par | g | function object returning a randomly chosen value of type {{tt|URNG::result_type}} in the interval [g.min(), g.max()] if invoked as {{tt|g()}} (e.g. any of the uniform random number generators from {{tt|&lt;random&gt;}}) }}
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept | URNG | UniformRandomNumberGenerator}}
{{par end}}

===Return value===
(none)

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class RandomIt, class RandomFunc&gt;
void random_shuffle(RandomIt first, RandomIt last, RandomFunc&amp;&amp; r)
{
    typename std::iterator_traits&lt;RandomIt&gt;::difference_type i, n;
    n = last - first;
    for (i = n-1; i &gt; 0; --i) {
        using std::swap;
        swap(first[i], first[r(i+1)]);
    }
}
 |2=
template&lt;class RandomIt, class UniformRandomNumberGenerator&gt;
void shuffle(RandomIt first, RandomIt last, 
             UniformRandomNumberGenerator&amp;&amp; g)
{
    typedef typename std::iterator_traits&lt;RandomIt&gt;::difference_type diff_t;
    typedef typename std::make_unsigned&lt;diff_t&gt;::type udiff_t;
    typedef typename std::uniform_int_distribution&lt;udiff_t&gt; distr_t;
    typedef typename distr_t::param_type param_t;

    distr_t D;
    diff_t n = last - first;
    for (diff_t i = n-1; i &gt; 0; --i) {
        using std::swap;
        swap(first[i], first[D(g, param_t(0, i))]);
    }
}
}}

===Example===
{{example
 | The following code randomly shuffles the integers 1..10:
 | code=
#include &lt;random&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    std::random_device rd;
    std::mt19937 g(rd());

    std::shuffle(v.begin(), v.end(), g);

    copy(v.begin(), v.end(), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; &quot;\n&quot;;
}
}}

Possible output:

{{source 
| 1 = 
8 6 10 4 2 3 7 1 9 5
| lang=text}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc next_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}

[[de:cpp/algorithm/random shuffle]]
[[es:cpp/algorithm/random shuffle]]
[[fr:cpp/algorithm/random shuffle]]
[[it:cpp/algorithm/random shuffle]]
[[ja:cpp/algorithm/random shuffle]]
[[pt:cpp/algorithm/random shuffle]]
[[ru:cpp/algorithm/random shuffle]]
[[zh:cpp/algorithm/random shuffle]]</text>
      <sha1>s9s1aqbibo9wuw12ig7l8zhcuo9k7th</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/remove</title>
    <ns>0</ns>
    <id>769</id>
    <revision>
      <id>72315</id>
      <parentid>70207</parentid>
      <timestamp>2014-08-07T18:58:03Z</timestamp>
      <contributor>
        <username>Josephbruni</username>
        <id>2813</id>
      </contributor>
      <minor/>
      <comment>corrected spelling typo</comment>
      <text xml:space="preserve" bytes="4337">{{cpp/title|remove | remove_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
ForwardIt remove( ForwardIt first, ForwardIt last, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class UnaryPredicate &gt;
ForwardIt remove_if( ForwardIt first, ForwardIt last, UnaryPredicate p );
}}
{{dcl end}}

Removes all elements satisfying specific criteria from the range {{tt|[first, last)}} and returns a past-the-end iterator for the new end of the range. 

The first version removes all elements that are equal to {{tt|value}}, the second version removes all elements for which predicate {{tt|p}} returns {{c|true}}. 

Removing is done by shifting (by means of move assignment) the elements in the range in such a way that the elements that are not to be removed appear in the beginning of the range. Relative order of the elements that remain is preserved and the ''physical'' size of the container is unchanged. Iterators pointing to an element between the new ''logical'' end and the ''physical'' end of the range are still dereferenceable, but the elements themselves have unspecified values (as per {{concept|MoveAssignable}} post-condition). A call to {{tt|remove}} is typically followed by a call to a container's {{tt|erase}} method, which erases the unspecified values and reduces the ''physical'' size of the container to match its new ''logical'' size.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to process}}
{{par | value | the value of elements to remove}}
{{par pred1 | p | if the element should be removed | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par req concept deref | ForwardIt | MoveAssignable}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
Iterator to the new end of the range

===Complexity===
Exactly {{c|std::distance(first, last)}} applications of the predicate.

===Notes===
The similarly-named container member functions {{l2tt|cpp/container/list/remove}}, {{l2tt|cpp/container/list/remove|remove_if}}, {{l2tt|cpp/container/forward_list/remove}}, and {{l2tt|cpp/container/forward_list/remove|remove_if}} erase the removed elements.

These algorithms cannot be used with associative containers such as {{lc|std::set}} and {{lc|std::map}} because ForwardIt does not dereference to a MoveAssignable type (the keys in these containers are not modifiable)

===Possible implementation===
{{eq fun
 | 1=
template&lt; class ForwardIt, class T &gt;
ForwardIt remove(ForwardIt first, ForwardIt last, const T&amp; value)
{
    first = std::find(first, last, value);
    if (first != last)
        for(ForwardIt i = first; ++i != last; )
            if (!(*i == value))
                *first++ = std::move(*i);
    return first;
}
 | 2=
template&lt;class ForwardIt, class UnaryPredicate&gt;
ForwardIt remove_if(ForwardIt first, ForwardIt last, UnaryPredicate p)
{
    first = std::find_if(first, last, p);
    if (first != last)
        for(ForwardIt i = first; ++i != last; )
            if (!p(*i))
                *first++ = std::move(*i);
    return first;
}
}}

===Examples===
{{example
 | The following code removes all spaces from a string by shifting all non-space characters to the left and then erasing the extra. This is an example of [[enwiki:Erase-remove_idiom|erase-remove idiom]].
 | code=
#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;cctype&gt;

int main()
{
    std::string str1 = &quot;Text with some   spaces&quot;;
    str1.erase(std::remove(str1.begin(), str1.end(), ' '),
               str1.end());
    std::cout &lt;&lt; str1 &lt;&lt; '\n';

    std::string str2 = &quot;Text\n with\tsome \t  whitespaces\n\n&quot;;
    str2.erase(std::remove_if(str2.begin(), 
                              str2.end(),
                              [](char x){return std::isspace(x);}),
               str2.end());
    std::cout &lt;&lt; str2 &lt;&lt; '\n';
}
 | output=
Textwithsomespaces
Textwithsomewhitespaces
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc remove_copy}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc end}}

[[de:cpp/algorithm/remove]]
[[es:cpp/algorithm/remove]]
[[fr:cpp/algorithm/remove]]
[[it:cpp/algorithm/remove]]
[[ja:cpp/algorithm/remove]]
[[pt:cpp/algorithm/remove]]
[[ru:cpp/algorithm/remove]]
[[zh:cpp/algorithm/remove]]</text>
      <sha1>21b7sxt15h57qvz2wmos2h9pg3k0vzk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/remove copy</title>
    <ns>0</ns>
    <id>770</id>
    <revision>
      <id>57044</id>
      <parentid>49283</parentid>
      <timestamp>2013-06-01T05:46:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2926">{{cpp/title|remove_copy | remove_copy_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt, class T &gt;
OutputIt remove_copy( InputIt first, InputIt last, OutputIt d_first,
                      const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class InputIt, class OutputIt, class UnaryPredicate &gt;
OutputIt remove_copy_if( InputIt first, InputIt last, OutputIt d_first,
                         UnaryPredicate p );
}}
{{dcl end}}

Copies elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}}, omitting the elements which satisfy specific criteria. The first version ignores the elements that are equal to {{tt|value}}, the second version ignores the elements for which predicate {{tt|p}} returns {{c|true}}. Source and destination ranges cannot overlap.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to copy}}
{{par | d_first | the beginning of the destination range. }}
{{par | value | the value of the elements not to copy}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
Iterator to the element past the last element copied.

===Complexity===
Exactly {{tt|last - first}} applications of the predicate.

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class OutputIt, class T&gt;
OutputIt remove_copy(InputIt first, InputIt last,
                     OutputIt d_first, const T&amp; value)
{
    for (; first != last; ++first) {
        if (!(*first == value)) {
            *d_first++ = *first;
        }
    }
    return d_first;
}
 | 2=
template&lt;class InputIt, class OutputIt, class UnaryPredicate&gt;
OutputIt remove_copy_if(InputIt first, InputIt last,
                        OutputIt d_first, UnaryPredicate p)
{
    for (; first != last; ++first) {
        if (!p(*first)) {
            *d_first++ = *first;
        }
    }
    return d_first;
}
}}

===Example===
{{example
 | The following code outputs a string while erasing the spaces on the fly.
 | code=
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
int main()
{
    std::string str = &quot;Text with some   spaces&quot;;
    std::cout &lt;&lt; &quot;before: &quot; &lt;&lt; str &lt;&lt; &quot;\n&quot;;

    std::cout &lt;&lt; &quot;after:  &quot;;
    std::remove_copy(str.begin(), str.end(),
                     std::ostream_iterator&lt;char&gt;(std::cout), ' ');
    std::cout &lt;&lt; '\n';
}
 | output=
before: Text with some   spaces
after:  Textwithsomespaces
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc end}}

[[de:cpp/algorithm/remove copy]]
[[es:cpp/algorithm/remove copy]]
[[fr:cpp/algorithm/remove copy]]
[[it:cpp/algorithm/remove copy]]
[[ja:cpp/algorithm/remove copy]]
[[pt:cpp/algorithm/remove copy]]
[[ru:cpp/algorithm/remove copy]]
[[zh:cpp/algorithm/remove copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/remove copy if</title>
    <ns>0</ns>
    <id>2537</id>
    <redirect title="cpp/algorithm/remove copy" />
    <revision>
      <id>9306</id>
      <timestamp>2011-08-21T16:03:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/algorithm/remove_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/remove if</title>
    <ns>0</ns>
    <id>2536</id>
    <redirect title="cpp/algorithm/remove" />
    <revision>
      <id>9305</id>
      <parentid>9304</parentid>
      <timestamp>2011-08-21T16:02:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/algorithm/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/replace</title>
    <ns>0</ns>
    <id>771</id>
    <revision>
      <id>70037</id>
      <parentid>57047</parentid>
      <timestamp>2014-05-07T16:33:48Z</timestamp>
      <contributor>
        <ip>89.69.250.162</ip>
      </contributor>
      <text xml:space="preserve" bytes="2877">{{cpp/title|replace | replace_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
void replace( ForwardIt first, ForwardIt last,
              const T&amp; old_value, const T&amp; new_value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class UnaryPredicate, class T &gt;
void replace_if( ForwardIt first, ForwardIt last,
                 UnaryPredicate p, const T&amp; new_value );
}}
{{dcl end}}

Replaces all elements satisfying specific criteria with {{tt|new_value}} in the range {{tt|[first, last)}}. The first version replaces the elements that are equal to {{tt|old_value}}, the second version replaces elements for which predicate {{tt|p}} returns {{c|true}}. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to process}}
{{par | old_value | the value of elements to replace}}
{{par pred1 | p | if the element value should be replaced | p1=ForwardIt}}
{{par | new_value | the value to use as replacement}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
(none)

===Complexity===
Exactly {{tt|last - first}} applications of the predicate.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class T&gt;
void replace(ForwardIt first, ForwardIt last,
             const T&amp; old_value, const T&amp; new_value)
{
    for (; first != last; ++first) {
        if (*first == old_value) {
            *first = new_value;
        }
    }
}
 | 2=
template&lt;class ForwardIt, class UnaryPredicate, class T&gt;
void replace_if(ForwardIt first, ForwardIt last,
                UnaryPredicate p, const T&amp; new_value)
{
    for (; first != last; ++first) {
        if(p(*first)) {
            *first = new_value;
        }
    }
}
}}

===Example===
{{example
 | The following code at first replaces all occurrences of {{c|8}} with {{c|88}} in a vector of integers. Then it replaces all values less than {{c|5}} with 55.
 | code=
#include &lt;algorithm&gt;
#include &lt;array&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;

int main()
{
    std::array&lt;int, 10&gt; s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};

    std::replace(s.begin(), s.end(), 8, 88);

    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';

    std::replace_if(s.begin(), s.end(), 
                    std::bind(std::less&lt;int&gt;(), std::placeholders::_1, 5), 55);
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
}
 | output=
5 7 4 2 88 6 1 9 0 3
5 7 55 55 88 6 55 9 55 55
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc replace_copy}}
{{dsc end}}

[[de:cpp/algorithm/replace]]
[[es:cpp/algorithm/replace]]
[[fr:cpp/algorithm/replace]]
[[it:cpp/algorithm/replace]]
[[ja:cpp/algorithm/replace]]
[[pt:cpp/algorithm/replace]]
[[ru:cpp/algorithm/replace]]
[[zh:cpp/algorithm/replace]]</text>
      <sha1>ic4g236prpm7hd3b7584o8joophc9vz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/replace copy</title>
    <ns>0</ns>
    <id>772</id>
    <revision>
      <id>57048</id>
      <parentid>49285</parentid>
      <timestamp>2013-06-01T05:46:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3128">{{cpp/title|replace_copy|replace_copy_if}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt, class T &gt;
OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first,
                       const T&amp; old_value, const T&amp; new_value );
}}
{{dcl | num=2 |
template&lt; class InputIt, class OutputIt, class UnaryPredicate, class T &gt;
OutputIt replace_copy_if( InputIt first, InputIt last, OutputIt d_first,
                          UnaryPredicate p, const T&amp; new_value );
}}
{{dcl end}}

Copies the all elements from the range {{tt|[first, last)}} to another range beginning at {{tt|d_first}} replacing all elements satisfying specific criteria with {{tt|new_value}}. The first version replaces the elements that are equal to {{tt|old_value}}, the second version replaces elements for which predicate {{tt|p}} returns {{c|true}}. The source and destination ranges cannot overlap.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to copy}}
{{par | d_first | the beginning of the destination range}}
{{par | old_value | the value of elements to replace}}
{{par pred1 | p | if the element value should be replaced | p1=InputIt}}
{{par | new_value | the value to use as replacement}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Iterator to the element past the last element copied.

===Complexity===
Exactly {{tt|last - first}} applications of the predicate.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class OutputIt, class T&gt;
OutputIt replace_copy(InputIt first, InputIt last, OutputIt d_first,
                      const T&amp; old_value, const T&amp; new_value)
{
    for (; first != last; ++first) {
        *d_first++ = (*first == old_value) ? new_value : *first;
    }
    return d_first;
}
 | 2=
template&lt;class InputIt, class OutputIt, 
         class UnaryPredicate, class T&gt;
OutputIt replace_copy_if(InputIt first, InputIt last, OutputIt d_first,
                         UnaryPredicate p, const T&amp; new_value)
{
    for (; first != last; ++first) {
        *d_first++ = p( *first ) ? new_value : *first;
    }
    return d_first;
}
}}

===Example===
{{example
 | The following copy prints a vector, replacing all values over 5 with 99 on the fly.
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;functional&gt;

int main()
{
    std::vector&lt;int&gt; v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    std::replace_copy_if(v.begin(), v.end(),
                         std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;),
                         [](int n){return n &gt; 5;}, 99);
    std::cout &lt;&lt; '\n';
}
 | output=
5 99 4 2 99 99 1 99 0 3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc end}}

[[de:cpp/algorithm/replace copy]]
[[es:cpp/algorithm/replace copy]]
[[fr:cpp/algorithm/replace copy]]
[[it:cpp/algorithm/replace copy]]
[[ja:cpp/algorithm/replace copy]]
[[pt:cpp/algorithm/replace copy]]
[[ru:cpp/algorithm/replace copy]]
[[zh:cpp/algorithm/replace copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/replace copy if</title>
    <ns>0</ns>
    <id>2538</id>
    <redirect title="cpp/algorithm/replace copy" />
    <revision>
      <id>9307</id>
      <timestamp>2011-08-21T16:04:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/algorithm/replace_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/replace if</title>
    <ns>0</ns>
    <id>2539</id>
    <redirect title="cpp/algorithm/replace" />
    <revision>
      <id>9309</id>
      <parentid>9308</parentid>
      <timestamp>2011-08-21T16:04:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/algorithm/replace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/reverse</title>
    <ns>0</ns>
    <id>773</id>
    <revision>
      <id>69872</id>
      <parentid>65423</parentid>
      <timestamp>2014-04-30T08:25:19Z</timestamp>
      <contributor>
        <username>BoBTFish</username>
        <id>2685</id>
      </contributor>
      <text xml:space="preserve" bytes="1635">{{cpp/title|reverse}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class BidirIt &gt;
void reverse( BidirIt first, BidirIt last );
}}
{{dcl end}}

Reverses the order of the elements in the range {{tt|[first, last)}}

Behaves as if applying {{lc|std::iter_swap}} to every pair of iterators {{tt|first+i, (last-i) - 1}} for each non-negative {{tt|i &lt; (last-first)/2}}

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to reverse}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept deref | BidirIt | Swappable}}
{{par end}}

===Return value===
(none)

===Possible implementation===
{{eq fun | 1=
template&lt;class BidirIt&gt;
void reverse(BidirIt first, BidirIt last)
{
    while ((first != last) &amp;&amp; (first != --last)) {
        std::iter_swap(first++, last);
    }
}
}}

===Example===
{{example
 |
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
 
int main()
{
    std::vector&lt;int&gt; v({1,2,3});
    std::reverse(std::begin(v), std::end(v));
    std::cout &lt;&lt; v[0] &lt;&lt; v[1] &lt;&lt; v[2] &lt;&lt; '\n';

    int a[] = {4, 5, 6, 7};
    std::reverse(&amp;a[0], &amp;a[4]);
    std::cout &lt;&lt; a[0] &lt;&lt; a[1] &lt;&lt; a[2] &lt;&lt; a[3] &lt;&lt; '\n';
}
 | output=
321
7654
}}

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc reverse_copy}}
{{dsc end}}

[[de:cpp/algorithm/reverse]]
[[es:cpp/algorithm/reverse]]
[[fr:cpp/algorithm/reverse]]
[[it:cpp/algorithm/reverse]]
[[ja:cpp/algorithm/reverse]]
[[pt:cpp/algorithm/reverse]]
[[ru:cpp/algorithm/reverse]]
[[zh:cpp/algorithm/reverse]]</text>
      <sha1>o2nefs8bj9kogd4lgemwb46xet86rb9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/reverse copy</title>
    <ns>0</ns>
    <id>774</id>
    <revision>
      <id>64155</id>
      <parentid>64154</parentid>
      <timestamp>2013-08-15T14:42:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>whoops</comment>
      <text xml:space="preserve" bytes="2239">{{cpp/title|reverse_copy}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class BidirIt, class OutputIt &gt;
OutputIt reverse_copy( BidirIt first, BidirIt last, OutputIt d_first );
}}
{{dcl end}}

Copies the elements from the range {{tt|[first, last)}} to another range beginning at {{tt|d_first}} in such a way that the elements in the new range are in reverse order. 

Behaves as if by executing the assignment {{c|*(d_first + (last - first) - 1 - i) {{=}} *(first + i)}} once for each non-negative {{tt|i &lt; (last - first)}}

If the source and destination ranges (that is, {{tt|[first, last)}} and {{tt|[d_first, d_first+(last-first))}} respectively) overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to copy}}
{{par | d_first | the beginning of the destination range}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Output iterator to the element past the last element copied.

===Possible implementation===
{{eq fun | 1=
template&lt;class BidirIt, class OutputIt&gt;
OutputIt reverse_copy(BidirIt first, BidirIt last, OutputIt d_first)
{
    while (first != last) {
        *(d_first++) = *(--last);
    }
    return d_first;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;

int main()
{
    std::vector&lt;int&gt; v({1,2,3});
    for (const auto&amp; value : v) {
        std::cout &lt;&lt; value &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';

    std::vector&lt;int&gt; destiny(3);
    std::reverse_copy(std::begin(v), std::end(v), std::begin(destiny));
    for (const auto&amp; value : destiny) {
        std::cout &lt;&lt; value &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
}

 | output=
1 2 3 
3 2 1 
}}

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc reverse}}
{{dsc end}}

[[de:cpp/algorithm/reverse copy]]
[[es:cpp/algorithm/reverse copy]]
[[fr:cpp/algorithm/reverse copy]]
[[it:cpp/algorithm/reverse copy]]
[[ja:cpp/algorithm/reverse copy]]
[[pt:cpp/algorithm/reverse copy]]
[[ru:cpp/algorithm/reverse copy]]
[[zh:cpp/algorithm/reverse copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/rotate</title>
    <ns>0</ns>
    <id>775</id>
    <revision>
      <id>65866</id>
      <parentid>65860</parentid>
      <timestamp>2013-10-11T14:05:41Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>minor formatting</comment>
      <text xml:space="preserve" bytes="3324">{{cpp/title|rotate}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class ForwardIt &gt;
void rotate( ForwardIt first, ForwardIt n_first, ForwardIt last );
}}
{{dcl | since=c++11 |
template&lt; class ForwardIt &gt;
ForwardIt rotate( ForwardIt first, ForwardIt n_first, ForwardIt last );
}}
{{dcl rev end}}
{{dcl end}}

Performs a left rotation on a range of elements.

Specifically, {{tt|std::rotate}} swaps the elements in the range {{tt|[first, last)}} in such a way that the element {{tt|n_first}} becomes the first element of the new range and {{tt|n_first - 1}} becomes the last element. 

A precondition of this function is that {{tt|[first, n_first)}} and {{tt|[n_first, last)}} are valid ranges.

===Parameters===
{{par begin}}
{{par | first | the beginning of the original range}}
{{par | n_first | the element that should appear at the beginning of the rotated range}}
{{par | last | the end of the original range}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator | ValueSwappable}}
{{par req concept deref | ForwardIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
{{rev begin}}
{{rev | until=c++11 |
(none)
}}
{{rev | since=c++11 |
The iterator equal to {{tt|first + (last - n_first)}}
}}
{{rev end}}

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun | 1=
template &lt;class ForwardIt&gt;
void rotate(ForwardIt first, ForwardIt n_first, ForwardIt last)
{
    ForwardIt next = n_first;
    while (first != next) {
        std::iter_swap(first++, next++);
        if (next == last) {
            next = n_first;
        } else if (first == n_first) {
            n_first = next;
        }
    }
}
}}

===Example===
{{example
 | {{tt|std::rotate}} is a common building block in many algorithms. This example demonstrates insertion sort: 
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
 
int main()
{
    std::vector&lt;int&gt; v{2, 4, 2, 0, 5, 10, 7, 3, 7, 1}; 
 
    std::cout &lt;&lt; &quot;before sort:      &quot;;
    for (int n: v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    // insertion sort
    for (auto i = v.begin(); i != v.end(); ++i) {
        std::rotate(std::upper_bound(v.begin(), i, *i), i, i+1);
    }
 
    std::cout &lt;&lt; &quot;after sort:       &quot;;
    for (int n: v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    // simple rotation to the left
    std::rotate(v.begin(), v.begin() + 1, v.end());

    std::cout &lt;&lt; &quot;simple rotate left  : &quot;;
    for (int n: v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    // simple rotation to the right
    std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());

    std::cout &lt;&lt; &quot;simple rotate right : &quot;;
    for (int n: v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
 
}
 | output=
before sort:      2 4 2 0 5 10 7 3 7 1 
after sort:       0 1 2 2 3 4 5 7 7 10 
simple rotate left : 1 2 2 3 4 5 7 7 10 0
simple rotate right: 0 1 2 2 3 4 5 7 7 10 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc rotate_copy}}
{{dsc end}}

[[de:cpp/algorithm/rotate]]
[[es:cpp/algorithm/rotate]]
[[fr:cpp/algorithm/rotate]]
[[it:cpp/algorithm/rotate]]
[[ja:cpp/algorithm/rotate]]
[[pt:cpp/algorithm/rotate]]
[[ru:cpp/algorithm/rotate]]
[[zh:cpp/algorithm/rotate]]</text>
      <sha1>nxy6ljr0j7pnys92g1ajlcwo44fbuju</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/rotate copy</title>
    <ns>0</ns>
    <id>776</id>
    <revision>
      <id>57056</id>
      <parentid>49289</parentid>
      <timestamp>2013-06-01T05:46:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2202">{{cpp/title|rotate_copy}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class ForwardIt, class OutputIt &gt;
OutputIt rotate_copy( ForwardIt first, ForwardIt n_first,
                      ForwardIt last, OutputIt d_first );
}}
{{dcl end}}

Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}} in such a way, that the element {{tt|n_first}} becomes the first element of the new range and {{tt|n_first - 1}} becomes the last element. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to copy}}
{{par | n_first | an iterator to an element in {{tt|[first, last)}} that should appear at the beginning of the new range}}
{{par | d_first | beginning of the destination range}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Output iterator to the element past the last element copied.

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt, class OutputIt&gt;
OutputIt rotate_copy(ForwardIt first, ForwardIt n_first,
                           ForwardIt last, OutputIt d_first)
{
    d_first = std::copy(n_first, last, d_first);
    return std::copy(first, n_first, d_first);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; src = {1, 2, 3, 4, 5}; 
    auto pivot = std::find(src.begin(), src.end(), 3); 
    std::vector&lt;int&gt; dest(src.size());                                          

    std::rotate_copy(src.begin(), pivot, src.end(), dest.begin());

    for (const auto &amp;i : dest) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; '\n';
}
 | output=
3 4 5 1 2 
}}

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc rotate}}
{{dsc end}}

[[de:cpp/algorithm/rotate copy]]
[[es:cpp/algorithm/rotate copy]]
[[fr:cpp/algorithm/rotate copy]]
[[it:cpp/algorithm/rotate copy]]
[[ja:cpp/algorithm/rotate copy]]
[[pt:cpp/algorithm/rotate copy]]
[[ru:cpp/algorithm/rotate copy]]
[[zh:cpp/algorithm/rotate copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/search</title>
    <ns>0</ns>
    <id>777</id>
    <revision>
      <id>69146</id>
      <parentid>66913</parentid>
      <timestamp>2014-03-28T16:03:55Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4018">{{cpp/title|search}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
                   ForwardIt2 s_first, ForwardIt2 s_last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt1, class ForwardIt2, class BinaryPredicate &gt;
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
                   ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );
}}
{{dcl end}}

Searches for the first occurrence of the subsequence of elements {{tt|[s_first, s_last)}} in the range {{tt|[first, last - (s_last - s_first))}}. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | s_first, s_last | the range of elements to search for}}
{{par pred2 eq | p | p1=ForwardIt1 | p2=ForwardIt2}}
{{par hreq}}
{{par req concept | ForwardIt1, ForwardIt2 | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the beginning of first subsequence {{tt|[s_first, s_last)}} in the range {{tt|[first, last - (s_last - s_first))}}. If no such subsequence is found, {{tt|last}} is returned.&lt;br&gt;
If {{tt|[s_first, s_last)}} is empty, {{tt|first}} is returned. {{mark since c++11}}

===Complexity===
At most {{tt|S*N}} comparisons where {{c|S {{=}} std::distance(s_first, s_last)}} and {{c|N {{=}} std::distance(first, last)}}.

===Possible implementation===

{{eq fun | 1=
template&lt;class ForwardIt1, class ForwardIt2&gt;
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 s_first, ForwardIt2 s_last)
{
    for (; ; ++first) {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
            if (s_it == s_last) {
                return first;
            }
            if (it == last) {
                return last;
            }
            if (!(*it == *s_it)) {
                break;
            }
        }
    }
}
 | 2=
template&lt;class ForwardIt1, class ForwardIt2, class BinaryPredicate&gt;
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 s_first, ForwardIt2 s_last, 
                        BinaryPredicate p)
{
    for (; ; ++first) {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
            if (s_it == s_last) {
                return first;
            }
            if (it == last) {
                return last;
            }
            if (!p(*it, *s_it)) {
                break;
            }
        }
    }
}
}}

===Example===
{{example|
|code=
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

template&lt;typename Container&gt;
bool in_quote(const Container&amp; cont, const std::string&amp; s)
{
    return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}

int main()
{
    std::string str = &quot;why waste time learning, when ignorance is instantaneous?&quot;;
    // str.find() can be used as well
    std::cout &lt;&lt; std::boolalpha &lt;&lt; in_quote(str, &quot;learning&quot;) &lt;&lt; '\n'
                                &lt;&lt; in_quote(str, &quot;lemming&quot;)  &lt;&lt; '\n';

    std::vector&lt;char&gt; vec(str.begin(), str.end());
    std::cout &lt;&lt; std::boolalpha &lt;&lt; in_quote(vec, &quot;learning&quot;) &lt;&lt; '\n'
                                &lt;&lt; in_quote(vec, &quot;lemming&quot;)  &lt;&lt; '\n';
}
|output=
true
false
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc search_n}}
{{dsc end}}

[[de:cpp/algorithm/search]]
[[es:cpp/algorithm/search]]
[[fr:cpp/algorithm/search]]
[[it:cpp/algorithm/search]]
[[ja:cpp/algorithm/search]]
[[pt:cpp/algorithm/search]]
[[ru:cpp/algorithm/search]]
[[zh:cpp/algorithm/search]]</text>
      <sha1>ab4svkkb6b00762e0l5rp0kcs0c2ut1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/search n</title>
    <ns>0</ns>
    <id>778</id>
    <revision>
      <id>65325</id>
      <parentid>65320</parentid>
      <timestamp>2013-09-09T01:14:29Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>align arguments</comment>
      <text xml:space="preserve" bytes="3982">{{cpp/title|search_n}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class Size, class T &gt;
ForwardIt1 search_n( ForwardIt first, ForwardIt last, Size count, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class Size, class T, class BinaryPredicate &gt;
ForwardIt1 search_n( ForwardIt first, ForwardIt last, Size count, const T&amp; value, 
                     BinaryPredicate p );
}}
{{dcl end}}

Searches the range {{tt|[first, last)}} for the first sequence of count identical elements, each equal to the given value value. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | count | the length of the sequence to search for}}
{{par | value | the value of the elements to search for}}
{{par pred2 eq | p | p1=ForwardIt | t2=T}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the beginning of the found sequence in the range {{tt|[first, last)}}. If no such sequence is found, {{tt|last}} is returned.

===Complexity===
At most {{tt|last - first}} applications of the predicate.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class Size, class T&gt;
ForwardIt1 search_n(ForwardIt first, ForwardIt last,
                    Size count, const T&amp; value)
{
    for(; first != last; ++first) {
        if (!(*first == value)) {
            continue;
        }

        ForwardIt candidate = first;
        Size cur_count = 0;

        while (true) {
            ++cur_count;
            if (cur_count == count) {
                // success
                return candidate;
            }
            ++first;
            if (first == last) {
                // exhausted the list
                return last;
            }
            if (!(*first == value)) {
                // too few in a row
                break;
            }
        }
    }
    return last;
}
 | 2=
template&lt;class ForwardIt, class Size, class T, class BinaryPredicate&gt;
ForwardIt1 search_n(ForwardIt first, ForwardIt last,
                    Size count, const T&amp; value, BinaryPredicate p)
{
    for(; first != last; ++first) {
        if (!p(*first, value)) {
            continue;
        }

        ForwardIt candidate = first;
        Size cur_count = 0;

        while (true) {
            ++cur_count;
            if (cur_count == count) {
                // success
                return candidate;
            }
            ++first;
            if (first == last) {
                // exhausted the list
                return last;
            }
            if (!p(*first, value)) {
                // too few in a row
                break;
            }
        }
    }
    return last;
}
}}

===Example===

{{example|
|code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

template &lt;class Container, class Size, class T&gt;
bool consecutive_values(const Container&amp; c, Size count, const T&amp; v)
{
  return std::search_n(std::begin(c),std::end(c),count,v) != std::end(c);
}

int main()
{
   const char sequence[] = &quot;1001010100010101001010101&quot;;

   std::cout &lt;&lt; std::boolalpha;
   std::cout &lt;&lt; &quot;Has 4 consecutive zeros: &quot;
             &lt;&lt; consecutive_values(sequence,4,'0') &lt;&lt; '\n';
   std::cout &lt;&lt; &quot;Has 3 consecutive zeros: &quot;
             &lt;&lt; consecutive_values(sequence,3,'0') &lt;&lt; '\n';
}

|output=
Has 4 consecutive zeros: false
Has 3 consecutive zeros: true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/algorithm/search n]]
[[es:cpp/algorithm/search n]]
[[fr:cpp/algorithm/search n]]
[[it:cpp/algorithm/search n]]
[[ja:cpp/algorithm/search n]]
[[pt:cpp/algorithm/search n]]
[[ru:cpp/algorithm/search n]]
[[zh:cpp/algorithm/search n]]</text>
      <sha1>nr00u1sm4321b71hdfbdktpgoj5tx6y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/set difference</title>
    <ns>0</ns>
    <id>779</id>
    <revision>
      <id>67353</id>
      <parentid>57063</parentid>
      <timestamp>2014-02-05T20:32:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="4239">{{cpp/title|set_difference}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class OutputIt &gt;
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2,
          class OutputIt, class Compare &gt;
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first, Compare comp );
}}
{{dcl end}}

Copies the elements from the sorted range {{tt|[first1, last1)}} which are not found in the sorted range {{tt|[first2, last2)}} to the range beginning at {{tt|d_first}}. 

The resulting range is also sorted. The first version expects both input ranges to be sorted with {{c|operator&lt;}}, the second version expects them to be sorted with the given comparison function {{tt|comp}}. Equivalent elements are treated individually, that is, if some element is found {{tt|m}} times in {{tt|[first1, last1)}} and {{tt|n}} times in {{tt|[first2, last2)}}, it will be copied to {{tt|d_first}} exactly {{c|std::max(m-n, 0)}} times. The resulting range cannot overlap with either of the input ranges.

===Parameters===
{{par begin}}
{{par | first1, last1 | the range of elements to examine}}
{{par | first2, last2 | the range of elements to search for}}
{{par cmp ord | comp | p1=InputIt1 | p2=InputIt2}} 
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Iterator past the end of the constructed range.

===Complexity===
At most {{math|2&amp;middot;(N&lt;sub&gt;1&lt;/sub&gt;+N&lt;sub&gt;2&lt;/sub&gt;-1)}} comparisons, where {{math|N&lt;sub&gt;1&lt;/sub&gt;}} {{c|{{=}} std::distance(first1, last1)}} and {{math|N&lt;sub&gt;2&lt;/sub&gt;}} {{c|{{=}} std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2, class OutputIt&gt;
OutputIt set_difference(InputIt1 first1, InputIt1 last1,
                        InputIt2 first2, InputIt2 last2,
                        OutputIt d_first)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);

        if (*first1 &lt; *first2) {
            *d_first++ = *first1++;
        } else {
            if (! (*first2 &lt; *first1)) {
                ++first1;
            }
            ++first2;
        }
    }
    return d_first;
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class OutputIt, class Compare&gt;
OutputIt set_difference( InputIt1 first1, InputIt1 last1,
                         InputIt2 first2, InputIt2 last2,
                         OutputIt d_first, Compare comp)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);

        if (comp(*first1, *first2)) {
            *d_first++ = *first1++;
        } else {
            if (!comp(*first2, *first1)) {
                ++first1;
            }
            ++first2;
        }
    }
    return d_first;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;

int main() {
    std::vector&lt;int&gt; v1 {1, 2, 5, 5, 5, 9};
    std::vector&lt;int&gt; v2 {2, 5, 7};
    std::vector&lt;int&gt; diff;
 
    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), 
                        std::inserter(diff, diff.begin()));
  
    for (auto i : v1) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; &quot;minus &quot;;
    for (auto i : v2) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; &quot;is: &quot;;
  
    for (auto i : diff) std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}

 | output=
1 2 5 5 5 9 minus 2 5 7 is: 1 5 5 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_symmetric_difference}}
{{dsc end}}

[[de:cpp/algorithm/set difference]]
[[es:cpp/algorithm/set difference]]
[[fr:cpp/algorithm/set difference]]
[[it:cpp/algorithm/set difference]]
[[ja:cpp/algorithm/set difference]]
[[pt:cpp/algorithm/set difference]]
[[ru:cpp/algorithm/set difference]]
[[zh:cpp/algorithm/set difference]]</text>
      <sha1>ahwskskb50gz5rdjub4xk0izs0jxxpc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/set intersection</title>
    <ns>0</ns>
    <id>780</id>
    <revision>
      <id>67354</id>
      <parentid>57066</parentid>
      <timestamp>2014-02-05T20:32:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="4040">{{cpp/title|set_intersection}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class OutputIt &gt;
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                           InputIt2 first2, InputIt2 last2,
                           OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2,
          class OutputIt, class Compare &gt;
OutputIt set_intersection( InputIt1 first1, InputIt1 last1,
                           InputIt2 first2, InputIt2 last2,
                           OutputIt d_first, Compare comp );
}}
{{dcl end}}

Constructs a sorted range beginning at {{tt|d_first}} consisting of elements that are found in both sorted ranges {{tt|[first1, last1)}} and {{tt|[first2, last2)}}. The first version expects both input ranges to be sorted with {{c|operator&lt;}}, the second version expects them to be sorted with the given comparison function {{tt|comp}}. If some element is found {{tt|m}} times in {{tt|[first1, last1)}} and {{tt|n}} times in {{tt|[first2, last2)}}, the first {{c|std::min(m, n)}} elements will be copied from the first range to the destination range. The order of equivalent elements is preserved. The resulting range cannot overlap with either of the input ranges.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements to examine}}
{{par | first2, last2 | the second range of elements to examine}}
{{par cmp ord | comp | p1=InputIt1 | p2=InputIt2}} 
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===

Iterator past the end of the constructed range.

===Complexity===
At most {{math|2&amp;middot;(N&lt;sub&gt;1&lt;/sub&gt;+N&lt;sub&gt;2&lt;/sub&gt;-1)}} comparisons, where {{math|N&lt;sub&gt;1&lt;/sub&gt;}} {{c|{{=}} std::distance(first1, last1)}} and {{math|N&lt;sub&gt;2&lt;/sub&gt;}} {{c|{{=}} std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2, class OutputIt&gt;
OutputIt set_intersection(InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first)
{
    while (first1 != last1 &amp;&amp; first2 != last2) {
        if (*first1 &lt; *first2) {
            ++first1;
        } else  {
            if (!(*first2 &lt; *first1)) {
                *d_first++ = *first1++;
            }
            ++first2;
        }
    }
    return d_first;
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class OutputIt, class Compare&gt;
OutputIt set_intersection(InputIt1 first1, InputIt1 last1,
                          InputIt2 first2, InputIt2 last2,
                          OutputIt d_first, Compare comp)
{
    while (first1 != last1 &amp;&amp; first2 != last2) {
        if (comp(*first1, *first2)) {
            ++first1;
        } else {
            if (!comp(*first2, *first1)) {
                *d_first++ = *first1++;
            }
            ++first2;
        }
    }
    return d_first;
}
}}


===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
int main()
{
    std::vector&lt;int&gt; v1{1,2,3,4,5,6,7,8};
    std::vector&lt;int&gt; v2{        5,  7,  9,10};
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());

    std::vector&lt;int&gt; v_intersection;

    std::set_intersection(v1.begin(), v1.end(),
                          v2.begin(), v2.end(),
                          std::back_inserter(v_intersection));
    for(int n : v_intersection)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
 | output=
5 7
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc set_union}}
{{dsc end}}

[[de:cpp/algorithm/set intersection]]
[[es:cpp/algorithm/set intersection]]
[[fr:cpp/algorithm/set intersection]]
[[it:cpp/algorithm/set intersection]]
[[ja:cpp/algorithm/set intersection]]
[[pt:cpp/algorithm/set intersection]]
[[ru:cpp/algorithm/set intersection]]
[[zh:cpp/algorithm/set intersection]]</text>
      <sha1>6orzlcnqozbvtgsut14v8cc6x8erf3b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/set symmetric difference</title>
    <ns>0</ns>
    <id>781</id>
    <revision>
      <id>67670</id>
      <parentid>67355</parentid>
      <timestamp>2014-02-19T15:53:33Z</timestamp>
      <contributor>
        <ip>217.33.181.2</ip>
      </contributor>
      <comment>Changed example variable name to correctly describe it's contents.</comment>
      <text xml:space="preserve" bytes="4704">{{cpp/title|set_symmetric_difference}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class OutputIt &gt;
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2,
          class OutputIt, class Compare &gt;
OutputIt set_symmetric_difference( InputIt1 first1, InputIt1 last1,
                                   InputIt2 first2, InputIt2 last2,
                                   OutputIt d_first, Compare comp );
}}
{{dcl end}}

Computes symmetric difference of two sorted ranges: the elements that are found in either of the ranges, but not in both of them are copied to the range beginning at {{tt|d_first}}. The resulting range is also sorted.

The first version expects both input ranges to be sorted with {{c|operator&lt;}}, the second version expects them to be sorted with the given comparison function {{tt|comp}}. If some element is found {{tt|m}} times in {{tt|[first1, last1)}} and {{tt|n}} times in {{tt|[first2, last2)}}, it will be copied to {{tt|d_first}} exactly {{c|std::abs(m-n)}} times. If {{tt|m&gt;n}}, then the last {{tt|m-n}} of those elements are copied from {{tt|[first1,last1)}}, otherwise the last {{tt|n-m}} elements are copied from {{tt|[first2,last2)}}. The resulting range cannot overlap with either of the input ranges.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first sorted range of elements }}
{{par | first2, last2 | the second sorted range of elements}}
{{par cmp ord | comp | p1=InputIt1 | p2=InputIt2}} 
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Iterator past the end of the constructed range.

===Complexity===

At most {{math|2&amp;middot;(N&lt;sub&gt;1&lt;/sub&gt;+N&lt;sub&gt;2&lt;/sub&gt;-1)}} comparisons, where {{math|N&lt;sub&gt;1&lt;/sub&gt;}} {{c|{{=}} std::distance(first1, last1)}} and {{math|N&lt;sub&gt;2&lt;/sub&gt;}} {{c|{{=}} std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2, class OutputIt&gt;
OutputIt set_difference(InputIt1 first1, InputIt1 last1,
                        InputIt2 first2, InputIt2 last2,
                        OutputIt d_first)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);

        if (*first1 &lt; *first2) {
            *d_first++ = *first1++;
        } else {
            if (*first2 &lt; *first1) {
                *d_first++ = *first2;
            } else {
                ++first1;
            }
            ++first2;
        }
    }
    return std::copy(first2, last2, d_first);
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class OutputIt, class Compare&gt;
OutputIt set_difference(InputIt1 first1, InputIt1 last1,
                        InputIt2 first2, InputIt2 last2,
                        OutputIt d_first, Compare comp)
{
    while (first1 != last1) {
        if (first2 == last2) return std::copy(first1, last1, d_first);

        if (comp(*first1, *first2)) {
            *d_first++ = *first1++;
        } else {
            if (comp(*first2, *first1)) {
                *d_first++ = *first2;
            } else {
                ++first1;
            }
            ++first2;
        }
    }
    return std::copy(first2, last2, d_first);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
int main()
{
    std::vector&lt;int&gt; v1{1,2,3,4,5,6,7,8     };
    std::vector&lt;int&gt; v2{        5,  7,  9,10};
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
 
    std::vector&lt;int&gt; v_symDifference;
 
    std::set_symmetric_difference(
        v1.begin(), v1.end(),
        v2.begin(), v2.end(),
        std::back_inserter(v_symDifference));

    for(int n : v_symDifference)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
 | output=
1 2 3 4 6 8 9 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc set_union}}
{{dsc inc | cpp/algorithm/dsc set_intersection}}
{{dsc end}}

[[de:cpp/algorithm/set symmetric difference]]
[[es:cpp/algorithm/set symmetric difference]]
[[fr:cpp/algorithm/set symmetric difference]]
[[it:cpp/algorithm/set symmetric difference]]
[[ja:cpp/algorithm/set symmetric difference]]
[[pt:cpp/algorithm/set symmetric difference]]
[[ru:cpp/algorithm/set symmetric difference]]
[[zh:cpp/algorithm/set symmetric difference]]</text>
      <sha1>eq0f4olkn2lr5vs8igm8efxjvi3wh6n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/set union</title>
    <ns>0</ns>
    <id>782</id>
    <revision>
      <id>67357</id>
      <parentid>63255</parentid>
      <timestamp>2014-02-05T20:33:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="4318">{{cpp/title|set_union}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt1, class InputIt2, class OutputIt &gt;
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2,
                    OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2,
          class OutputIt, class Compare &gt;
OutputIt set_union( InputIt1 first1, InputIt1 last1,
                    InputIt2 first2, InputIt2 last2,
                    OutputIt d_first, Compare comp );
}}
{{dcl end}}

Constructs a sorted range beginning at {{tt|d_first}} consisting of all elements present in one or both sorted ranges {{tt|[first1, last1)}} and {{tt|[first2, last2)}}. 

@1@ Expects both input ranges to be sorted with {{c|operator&lt;}}
@2@ Expects them to be sorted with the given comparison function {{tt|comp}} 

If some element is found {{tt|m}} times in {{tt|[first1, last1)}} and {{tt|n}} times in {{tt|[first2, last2)}}, then all {{tt|m}} elements will be copied from {{tt|[first1, last1)}} to {{tt|d_first}}, preserving order, and then exactly {{c|std::max(n-m, 0)}} elements will be copied from {{tt|[first2, last2)}} to {{tt|d_first}}, also preserving order. 

The resulting range cannot overlap with either of the input ranges.

===Parameters===
{{par begin}}
{{par | first1, last1 | the first input sorted range}}
{{par | first2, last2 | the second input sorted range}}
{{par cmp ord | comp | p1=InputIt1 | p2=InputIt2}} 
{{par hreq}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===

Iterator past the end of the constructed range.

===Complexity===

At most {{math|2&amp;middot;(N&lt;sub&gt;1&lt;/sub&gt;+N&lt;sub&gt;2&lt;/sub&gt;-1)}} comparisons, where {{math|N&lt;sub&gt;1&lt;/sub&gt;}} {{c|{{=}} std::distance(first1, last1)}} and {{math|N&lt;sub&gt;2&lt;/sub&gt;}} {{c|{{=}} std::distance(first2, last2)}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt1, class InputIt2, class OutputIt&gt;
OutputIt set_union(InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, InputIt2 last2,
                   OutputIt d_first)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2)
            return std::copy(first1, last1, d_first);
        if (*first2 &lt; *first1) {
            *d_first = *first2++;
        } else {
            *d_first = *first1;
            if (!(*first1 &lt; *first2))
                ++first2;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}
 | 2=
template&lt;class InputIt1, class InputIt2,
         class OutputIt, class Compare&gt;
OutputIt set_union(InputIt1 first1, InputIt1 last1,
                   InputIt2 first2, InputIt2 last2,
                   OutputIt d_first, Compare comp)
{
    for (; first1 != last1; ++d_first) {
        if (first2 == last2)
            return std::copy(first1, last1, d_first);
        if (comp(*first2, *first1)) {
            *d_first = *first2++;
        } else {
            *d_first = *first1;
            if (!comp(*first1, *first2))
                ++first2;
            ++first1;
        }
    }
    return std::copy(first2, last2, d_first);
}
}}

===Example===
{{example
 | Example with vectors :
 | code=
#include &lt;vector&gt;
#include &lt;set&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    std::vector&lt;int&gt; v1 = {1, 2, 3, 4, 5}; 
    std::vector&lt;int&gt; v2 = {      3, 4, 5, 6, 7}; 
    std::vector&lt;int&gt; dest1;

    std::set_union(v1.begin(), v1.end(),
                   v2.begin(), v2.end(),                  
                   std::back_inserter(dest1));

    for (const auto &amp;i : dest1) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; '\n';
}
 | output=
1 2 3 4 5 6 7
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc set_intersection}}
{{dsc inc | cpp/algorithm/dsc set_symmetric_difference}}
{{dsc end}}

[[de:cpp/algorithm/set union]]
[[es:cpp/algorithm/set union]]
[[fr:cpp/algorithm/set union]]
[[it:cpp/algorithm/set union]]
[[ja:cpp/algorithm/set union]]
[[pt:cpp/algorithm/set union]]
[[ru:cpp/algorithm/set union]]
[[zh:cpp/algorithm/set union]]</text>
      <sha1>o6lw4jii8ri1927b4iy1ug1edggj6p4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/shuffle</title>
    <ns>0</ns>
    <id>2463</id>
    <redirect title="cpp/algorithm/random shuffle" />
    <revision>
      <id>8732</id>
      <timestamp>2011-08-16T07:49:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/algorithm/random_shuffle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/sort</title>
    <ns>0</ns>
    <id>783</id>
    <revision>
      <id>67356</id>
      <parentid>67155</parentid>
      <timestamp>2014-02-05T20:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ord</comment>
      <text xml:space="preserve" bytes="2719">{{cpp/title|sort}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void sort( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void sort( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Sorts the elements in the range {{tt|[first, last)}} in ascending order. The order of equal elements is not guaranteed to be preserved. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function object {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par cmp ord | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par req concept | Compare | Compare}} 
{{par end}}

===Return value===
(none)

===Complexity===

{{rev begin}}
{{rev|until=c++11|
{{math|O(N&amp;middot;log(N))}}, where {{c|1=N = std::distance(first, last)}} comparisons on average.
}}
{{rev|since=c++11|
{{math|O(N&amp;middot;log(N))}}, where {{c|1=N = std::distance(first, last)}} comparisons.
}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;array&gt;
#include &lt;iostream&gt;

int main()
{
    std::array&lt;int, 10&gt; s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; 

    // sort using the default operator&lt;
    std::sort(s.begin(), s.end());
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }   
    std::cout &lt;&lt; '\n';

    // sort using a standard library compare function object
    std::sort(s.begin(), s.end(), std::greater&lt;int&gt;());
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }   
    std::cout &lt;&lt; '\n';

    // sort using a custom function object
    struct {
        bool operator()(int a, int b)
        {   
            return a &lt; b;
        }   
    } customLess;
    std::sort(s.begin(), s.end(), customLess);
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    }   
    std::cout &lt;&lt; '\n';

    // sort using a lambda expression 
    std::sort(s.begin(), s.end(), [](int a, int b) {
        return b &lt; a;   
    });
    for (int a : s) {
        std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    } 
    std::cout &lt;&lt; '\n';
} 
 | output=
0 1 2 3 4 5 6 7 8 9 
9 8 7 6 5 4 3 2 1 0 
0 1 2 3 4 5 6 7 8 9 
9 8 7 6 5 4 3 2 1 0 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc end}}

[[de:cpp/algorithm/sort]]
[[es:cpp/algorithm/sort]]
[[fr:cpp/algorithm/sort]]
[[it:cpp/algorithm/sort]]
[[ja:cpp/algorithm/sort]]
[[pt:cpp/algorithm/sort]]
[[ru:cpp/algorithm/sort]]
[[zh:cpp/algorithm/sort]]</text>
      <sha1>ipyr30bvxwtw5wkg5392cc61nfmx3s1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/sort heap</title>
    <ns>0</ns>
    <id>784</id>
    <revision>
      <id>65850</id>
      <parentid>65842</parentid>
      <timestamp>2013-10-10T14:27:09Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>use site-consistent indentation</comment>
      <text xml:space="preserve" bytes="2347">{{cpp/title|sort_heap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void sort_heap( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void sort_heap( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Converts the ''max heap'' {{tt|[first, last)}} into a sorted range in ascending order. The resulting range no longer has the heap property.

The first version of the function uses {{c|operator&lt;}} to compare the elements, the second uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par cmp | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
At most ''N&amp;times;log(N)'' comparisons where {{c|1=N=std::distance(first, last)}}.

===Notes===
{{cpp/algorithm/notes heap}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class RandomIt &gt;
void sort_heap( RandomIt first, RandomIt last );
{
    while (first != last)
        std::pop_heap(first, last--);
}
 | 2=
template&lt; class RandomIt, class Compare &gt;
void sort_heap( RandomIt first, RandomIt last, Compare comp );
{
    while (first != last)
        std::pop_heap(first, last--, comp);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; v = {3, 1, 4, 1, 5, 9}; 

    std::make_heap(v.begin(), v.end());

    std::cout &lt;&lt; &quot;heap:\t&quot;;
    for (const auto &amp;i : v) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }   

    std::sort_heap(v.begin(), v.end());
    
    std::cout &lt;&lt; &quot;\nsorted:\t&quot;;
    for (const auto &amp;i : v) {                                                   
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }   
    std::cout &lt;&lt; '\n';
}
 | output=
heap:   9 4 5 1 1 3 
sorted: 1 1 3 4 5 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc make_heap}}
{{dsc end}}

[[de:cpp/algorithm/sort heap]]
[[es:cpp/algorithm/sort heap]]
[[fr:cpp/algorithm/sort heap]]
[[it:cpp/algorithm/sort heap]]
[[ja:cpp/algorithm/sort heap]]
[[pt:cpp/algorithm/sort heap]]
[[ru:cpp/algorithm/sort heap]]
[[zh:cpp/algorithm/sort heap]]</text>
      <sha1>i2bcak3hbkfzl9f3d24u74qovaj34zn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/stable partition</title>
    <ns>0</ns>
    <id>785</id>
    <revision>
      <id>69147</id>
      <parentid>57075</parentid>
      <timestamp>2014-03-28T16:05:07Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1926">{{cpp/title|stable_partition}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class BidirIt, class UnaryPredicate &gt;
BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPredicate p );
}}
{{dcl end}}

Reorders the elements in the range {{tt|[first, last)}} in such a way that all elements for which the predicate {{tt|p}} returns {{c|true}} precede the elements for which predicate {{tt|p}} returns {{c|false}}. Relative order of the elements is preserved. 

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to reorder}}
{{par pred1 | p | if the element should be ordered before other elements | p1=BidirIt}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator | ValueSwappable }}
{{par req concept deref | BidirIt | MoveConstructible | MoveAssignable }}
{{par req concept | UnaryPredicate | Predicate}}
{{par end}}

===Return value===
Iterator to the first element of the second group

===Complexity===
Exactly {{tt|last-first}} applications of the predicate and at most {{tt|(last-first)*log(last-first)}} swaps if there is insufficient memory or linear number of swaps if sufficient memory is available.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v{0, 0, 3, 0, 2, 4, 5, 0, 7};
    std::stable_partition(v.begin(), v.end(), [](int n){return n&gt;0;});
    for (int n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
3 2 4 5 7 0 0 0 0 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc end}}

[[de:cpp/algorithm/stable partition]]
[[es:cpp/algorithm/stable partition]]
[[fr:cpp/algorithm/stable partition]]
[[it:cpp/algorithm/stable partition]]
[[ja:cpp/algorithm/stable partition]]
[[pt:cpp/algorithm/stable partition]]
[[ru:cpp/algorithm/stable partition]]
[[zh:cpp/algorithm/stable partition]]</text>
      <sha1>rgs0cyb8bz5uh5zjpq9ridwsxruoj9m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/stable sort</title>
    <ns>0</ns>
    <id>786</id>
    <revision>
      <id>67358</id>
      <parentid>57078</parentid>
      <timestamp>2014-02-05T20:33:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="2465">{{cpp/title|stable_sort}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class RandomIt &gt;
void stable_sort( RandomIt first, RandomIt last );
}}
{{dcl | num=2 |
template&lt; class RandomIt, class Compare &gt;
void stable_sort( RandomIt first, RandomIt last, Compare comp );
}}
{{dcl end}}

Sorts the elements in the range {{tt|[first, last)}} in ascending order. The order of equal elements is guaranteed to be preserved. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to sort}}
{{par cmp ord | comp | p1=RandomIt}} 
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator | ValueSwappable}}
{{par req concept deref | RandomIt | MoveConstructible | MoveAssignable}}
{{par end}}

===Return value===
(none)

===Complexity===
{{math|O(N&amp;middot;log&lt;sup&gt;2&lt;/sup&gt;(N))}}, where {{c|1=N = std::distance(first, last)}} applications of {{tt|cmp}}. If additional memory is available, then the complexity is {{math|O(N&amp;middot;log(N))}}.

===Notes===
This function attempts to allocate a temporary buffer equal in size to the sequence to be sorted, typically by calling {{lc|std::get_temporary_buffer}}. If the allocation fails, the less efficient algorithm is chosen.

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;

struct Employee {
    Employee(int age, std::string name) : age(age), name(name) { } 
    int age;
    std::string name;  // Does not particpate in comparisons
};

bool operator&lt;(const Employee &amp;lhs, const Employee &amp;rhs) {
    return lhs.age &lt; rhs.age;
}

int main()
{
    std::vector&lt;Employee&gt; v = { 
        Employee(108, &quot;Zaphod&quot;),
        Employee(32, &quot;Arthur&quot;),
        Employee(108, &quot;Ford&quot;),
    };  

    std::stable_sort(v.begin(), v.end());

    for (const Employee &amp;e : v) {
        std::cout &lt;&lt; e.age &lt;&lt; &quot;, &quot; &lt;&lt; e.name &lt;&lt; '\n';
    }   
}   
 | output=
32, Arthur
108, Zaphod
108, Ford
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc end}}

[[de:cpp/algorithm/stable sort]]
[[es:cpp/algorithm/stable sort]]
[[fr:cpp/algorithm/stable sort]]
[[it:cpp/algorithm/stable sort]]
[[ja:cpp/algorithm/stable sort]]
[[pt:cpp/algorithm/stable sort]]
[[ru:cpp/algorithm/stable sort]]
[[zh:cpp/algorithm/stable sort]]</text>
      <sha1>7sl3u9y2g3io6ypvjfuo65be6vfiasm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/swap</title>
    <ns>0</ns>
    <id>787</id>
    <revision>
      <id>72222</id>
      <parentid>71860</parentid>
      <timestamp>2014-07-24T13:00:07Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>format</comment>
      <text xml:space="preserve" bytes="4248">{{cpp/title|swap}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm | utility | notes={{mark until c++11}}&lt;br&gt;{{mark since c++11}}}}
{{dcl | num=1 |
template&lt; class T &gt;
void swap( T&amp; a, T&amp; b );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T2, size_t N &gt;
void swap( T2 (&amp;a)[N], T2 (&amp;b)[N]);
}}
{{dcl end}}

Exchanges the given values.

@1@ Swaps the values {{tt|a}} and {{tt|b}}.

@2@ Swaps the arrays {{tt|a}} and {{tt|b}}. In effect calls {{c|std::swap_ranges(a, a+N, b)}}.

===Parameters===
{{par begin}}
{{par | a, b | the values to be swapped}}
{{par hreq}}
{{par req concept | T | MoveConstructible | MoveAssignable}}
{{par req concept | T2 | Swappable }}
{{par end}}

===Return value===
(none)

===Exceptions===
@1@{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|
{{noexcept|
    std::is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp;
    std::is_nothrow_move_assignable&lt;T&gt;::value
}}
}}{{rev end}}
@2@ {{noexcept|noexcept(swap(*a, *b))}}

===Complexity===
@1@ Constant

@2@ Linear in N

===Specializations===

{{lc|std::swap}} may be [[cpp/language/extending_std|specialized in namespace std]] for user-defined types, but such specializations are not found by [[cpp/language/adl|ADL]] (the namespace std is not the associated namespace for the user-defined type). The expected way to make a user-defined type swappable is to provide a non-member function swap in the same namespace as the type: see {{concept|Swappable}} for details. 

The following overloads are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/pair/dsc swap2}}
{{dsc inc | cpp/utility/tuple/dsc swap2}}
{{dsc inc | cpp/memory/shared_ptr/dsc swap2}}
{{dsc inc | cpp/memory/weak_ptr/dsc swap2}}
{{dsc inc | cpp/memory/unique_ptr/dsc swap2}}
{{dsc inc | cpp/utility/functional/function/dsc swap2}}
{{dsc inc | cpp/string/basic_string/dsc swap2}}
{{dsc inc | cpp/container/dsc swap2 | array}}
{{dsc inc | cpp/container/dsc swap2 | deque}}
{{dsc inc | cpp/container/dsc swap2 | forward_list}}
{{dsc inc | cpp/container/dsc swap2 | list}}
{{dsc inc | cpp/container/dsc swap2 | vector}}
{{dsc inc | cpp/container/dsc swap2 | map}}
{{dsc inc | cpp/container/dsc swap2 | multimap}}
{{dsc inc | cpp/container/dsc swap2 | set}}
{{dsc inc | cpp/container/dsc swap2 | multiset}}
{{dsc inc | cpp/container/dsc swap2 | unordered_map}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multimap}}
{{dsc inc | cpp/container/dsc swap2 | unordered_set}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multiset}}
{{dsc inc | cpp/container/dsc swap2 | queue}}
{{dsc inc | cpp/container/dsc swap2 | priority_queue}}
{{dsc inc | cpp/container/dsc swap2 | stack}}
{{dsc inc | cpp/numeric/valarray/dsc swap2}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap2}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_ostringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_stringstream}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap2}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_fstream}}
{{dsc inc | cpp/regex/basic_regex/dsc swap2}}
{{dsc inc | cpp/regex/match_results/dsc swap2}}
{{dsc inc | cpp/thread/thread/dsc swap2}}
{{dsc inc | cpp/thread/unique_lock/dsc swap2}}
{{dsc inc | cpp/thread/promise/dsc swap2}}
{{dsc inc | cpp/thread/packaged_task/dsc swap2}}
{{dsc end}}

===Example===
{{example
 | &lt;!-- should demo proper use of swap with generic types, as in void swap(T&amp; other) {using std::swap; swap(member, other.member);} , not just trivialities --&gt;
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;

int main()
{
   int a = 5, b = 3;

   // before
   std::cout &lt;&lt; a &lt;&lt; ' ' &lt;&lt; b &lt;&lt; '\n';

   std::swap(a,b);

   // after
   std::cout &lt;&lt; a &lt;&lt; ' ' &lt;&lt; b &lt;&lt; '\n';
}
 | output=
5 3
3 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc iter_swap}}
{{dsc inc | cpp/algorithm/dsc swap_ranges}}
{{dsc end}}

[[de:cpp/algorithm/swap]]
[[es:cpp/algorithm/swap]]
[[fr:cpp/algorithm/swap]]
[[it:cpp/algorithm/swap]]
[[ja:cpp/algorithm/swap]]
[[pt:cpp/algorithm/swap]]
[[ru:cpp/algorithm/swap]]
[[zh:cpp/algorithm/swap]]</text>
      <sha1>ly6owvxt7ez3cbx1s55ld2i74joyeq7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/swap ranges</title>
    <ns>0</ns>
    <id>788</id>
    <revision>
      <id>67907</id>
      <parentid>67906</parentid>
      <timestamp>2014-03-05T08:36:22Z</timestamp>
      <contributor>
        <username>Ted</username>
        <id>2908</id>
      </contributor>
      <comment>Undo revision 67906 by [[Special:Contributions/Ted|Ted]] ([[User talk:Ted|talk]])</comment>
      <text xml:space="preserve" bytes="2164">{{cpp/title|swap_ranges}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl |
template&lt; class ForwardIt1, class ForwardIt2 &gt;
ForwardIt2 swap_ranges( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 )
}}
{{dcl end}}

Exchanges elements between range {{tt|[first1, last1)}} and another range starting at {{tt|first2}}. 

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements to swap}}
{{par | first2 | beginning of the second range of elements to swap}}
{{par hreq}}
{{par req concept | ForwardIt1, ForwardIt2 | ForwardIterator}}
{{par req | The types of dereferenced {{tt|ForwardIt1}} and {{tt|ForwardIt2}} must meet the requirements of {{concept|Swappable}}}}
{{par end}}

===Return value===
Iterator to the element past the last element exchanged in the range beginning with {{tt|first2}}.

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt1, class ForwardIt2&gt;
ForwardIt2 swap_ranges(ForwardIt1 first1, 
                             ForwardIt1 last1, 
                             ForwardIt2 first2)
{
    while (first1 != last1) {
        std::iter_swap(first1++, first2++);
    }
    return first2;
}
}}

===Example===
{{example
 | Demonstrates swapping of subranges from different containers
 | code=
#include &lt;algorithm&gt;
#include &lt;list&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
int main()
{
    std::vector&lt;int&gt; v = {1, 2, 3, 4, 5};
    std::list&lt;int&gt; l = {-1, -2, -3, -4, -5};

    std::swap_ranges(v.begin(), v.begin()+3, l.begin());

    for(int n : v)
       std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
    for(int n : l)
       std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
-1 -2 -3 4 5
1 2 3 -4 -5
}}

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc iter_swap}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc end}}

[[de:cpp/algorithm/swap ranges]]
[[es:cpp/algorithm/swap ranges]]
[[fr:cpp/algorithm/swap ranges]]
[[it:cpp/algorithm/swap ranges]]
[[ja:cpp/algorithm/swap ranges]]
[[pt:cpp/algorithm/swap ranges]]
[[ru:cpp/algorithm/swap ranges]]
[[zh:cpp/algorithm/swap ranges]]</text>
      <sha1>11zhp81j3zdjgef5a7cdmrc6xfh8r0e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/transform</title>
    <ns>0</ns>
    <id>789</id>
    <revision>
      <id>66421</id>
      <parentid>66420</parentid>
      <timestamp>2013-11-21T14:51:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3793">{{cpp/title|transform}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt, class UnaryOperation &gt;
OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first,
                    UnaryOperation unary_op );
}}
{{dcl | num=2 |
template&lt; class InputIt1, class InputIt2, class OutputIt, class BinaryOperation &gt;
OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2, 
                    OutputIt d_first, BinaryOperation binary_op );
}}
{{dcl end}}

{{tt|std::transform}} applies the given function to a range and stores the result in another range, beginning at {{tt|d_first}}. 

In the first version unary operation {{tt|unary_op}} is applied to the range defined by {{tt|[first1, last1)}}. In the second version the binary operation {{tt|binary_op}} is applied to pairs of elements from two ranges: one defined by {{tt|[first1, last1)}} and the other beginning at {{tt|first2}}.

{{rev begin}}
{{rev | until=c++11 |
{{tt|unary_op}} and {{tt|binary_op}} must not have side effects.
}}
{{rev | since=c++11 |
{{tt|unary_op}} and {{tt|binary_op}} must not invalidate any iterators, including the end iterators, or modify any elements of the ranges involved.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | first1, last1 | the first range of elements to transform}}
{{par | first2 | the beginning of the second range of elements to transform}}
{{par | d_first | the beginning of the destination range, may be equal to {{tt|first1}} or {{tt|first2}} }}
{{par op1 | unary_op | rp=OutputIt | p1=InputIt}}
{{par op2 | binary_op | rp=OutputIt | p1=InputIt1 | p2=InputIt2}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | InputIt1 | InputIterator}}
{{par req concept | InputIt2 | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
Output iterator to the element past the last element transformed.

===Complexity===
@1@ Exactly {{c|std::distance(first1, last1)}} applications of {{tt|unary_op}}

@2@ Exactly {{c|std::distance(first1, last1)}} applications of {{tt|binary_op}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class InputIt, class OutputIt, class UnaryOperation&gt;
OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first, 
                   UnaryOperation unary_op)
{
    while (first1 != last1) {
        *d_first++ = unary_op(*first1++);
    }
    return d_first;
}
 | 2=
template&lt;class InputIt1, class InputIt2, 
         class OutputIt, class BinaryOperation&gt;
OutputIt transform(InputIt first1, InputIt last1, InputIt first2, 
                   OutputIt d_first, BinaryOperation binary_op)
{
    while (first1 != last1) {
        *d_first++ = binary_op(*first1++, *first2++);
    }
    return d_first;
}
}}

===Notes===
{{tt|std::transform}} does not guarantee in-order application of {{tt|unary_op}} or {{tt|binary_op}}. To apply a function to a sequence in-order or to apply a function that modifies the elements of a sequence, use {{lc|std::for_each}}

===Example===
{{example
 | The following code uses transform to convert a string to uppercase using the toupper function: 
 | code=
#include &lt;string&gt;
#include &lt;cctype&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::string s(&quot;hello&quot;);
    std::transform(s.begin(), s.end(), s.begin(), std::ptr_fun&lt;int, int&gt;(std::toupper));
    std::cout &lt;&lt; s;
}
 | output=
HELLO
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc for_each}}
{{dsc end}}

[[de:cpp/algorithm/transform]]
[[es:cpp/algorithm/transform]]
[[fr:cpp/algorithm/transform]]
[[it:cpp/algorithm/transform]]
[[ja:cpp/algorithm/transform]]
[[pt:cpp/algorithm/transform]]
[[ru:cpp/algorithm/transform]]
[[zh:cpp/algorithm/transform]]</text>
      <sha1>9gcevgeazlpsmok9j16k6ljfqyhm7fz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/unique</title>
    <ns>0</ns>
    <id>790</id>
    <revision>
      <id>71706</id>
      <parentid>63965</parentid>
      <timestamp>2014-06-21T02:28:37Z</timestamp>
      <contributor>
        <username>Rapptz</username>
        <id>1465</id>
      </contributor>
      <comment>Add another example that might also be helpful.</comment>
      <text xml:space="preserve" bytes="3844">{{cpp/title|unique}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt &gt;
ForwardIt unique( ForwardIt first, ForwardIt last );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class BinaryPredicate &gt;
ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPredicate p );
}}
{{dcl end}}

Removes all consecutive duplicate elements from the range {{tt|[first, last)}} and returns a past-the-end iterator for the new ''logical'' end of the range.  The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.

&lt;!-- Note: This paragraph is copied verbatim from remove. --&gt;
Removing is done by shifting the elements in the range in such a way that elements to be erased are overwritten. Relative order of the elements that remain is preserved and the ''physical'' size of the container is unchanged. Iterators pointing to an element between the new ''logical'' end and the ''physical'' end of the range are still dereferenceable, but the elements themselves have unspecified values. A call to {{tt|unique}} is typically followed by a call to a container's {{tt|erase}} method, which erases the unspecified values and reduces the ''physical'' size of the container to match its new ''logical'' size.


===Parameters===
{{par begin}}
{{par | first, last | the range of elements to process}}
{{par pred2 eq | p | p1=ForwardIt}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par req concept deref | ForwardIt | MoveAssignable}}
{{par end}}

===Return value===
Forward iterator to the new end of the range

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt&gt;
ForwardIt unique(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;

    ForwardIt result = first;
    while (++first != last) {
        if (!(*result == *first)) {
            *(++result) = *first;
        }
    }
    return ++result;
}
 | 2=
template&lt;class ForwardIt, class BinaryPredicate&gt;
ForwardIt unique(ForwardIt first, ForwardIt last, 
                       BinaryPredicate p)
{
    if (first == last)
        return last;

    ForwardIt result = first;
    while (++first != last) {
        if (!p(*result, *first)) {
            *(++result) = *first;
        }
    }
    return ++result;
}
}}

===Examples===
{{example
 | The following code removes all consecutive equivalent elements from a vector of integers.
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
 
int main() 
{
    std::vector&lt;int&gt; v{1, 2, 2, 2, 3, 3, 2, 2, 1};
    std::vector&lt;int&gt;::iterator last;
 
    last = std::unique(v.begin(), v.end()); // 1 2 3 2 1 3 2 2 1
                                            //           ^
    for (std::vector&lt;int&gt;::iterator it = v.begin(); it != last; ++it) {
        std::cout &lt;&lt; *it &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | output=
1 2 3 2 1
}}

{{example
 | The following code removes all duplicate elements from a vector of integers.
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v{1,2,3,1,2,3,3,4,5,4,5,6,7};
    std::sort(v.begin(), v.end()); 
    auto last = std::unique(v.begin(), v.end());
    v.erase(last, v.end());
    for (const auto&amp; i : v)
      std::cout &lt;&lt; i &lt;&lt; &quot; &quot;;
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | output =
1 2 3 4 5 6 7
}}

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc unique_copy}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc end}}

[[de:cpp/algorithm/unique]]
[[es:cpp/algorithm/unique]]
[[fr:cpp/algorithm/unique]]
[[it:cpp/algorithm/unique]]
[[ja:cpp/algorithm/unique]]
[[pt:cpp/algorithm/unique]]
[[ru:cpp/algorithm/unique]]
[[zh:cpp/algorithm/unique]]</text>
      <sha1>ismb5tvadc5swbp3br3c61kq4kvdi5u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/unique copy</title>
    <ns>0</ns>
    <id>791</id>
    <revision>
      <id>65976</id>
      <parentid>57089</parentid>
      <timestamp>2013-10-16T17:21:05Z</timestamp>
      <contributor>
        <ip>216.58.125.175</ip>
      </contributor>
      <comment>fixed return type</comment>
      <text xml:space="preserve" bytes="3333">{{cpp/title|unique_copy}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class InputIt, class OutputIt &gt;
OutputIt unique_copy( InputIt first, InputIt last,
                       OutputIt d_first );
}}
{{dcl | num=2 |
template&lt; class InputIt, class OutputIt, class BinaryPredicate &gt;
OutputIt unique_copy( InputIt first, InputIt last,
                       OutputIt d_first, BinaryPredicate p );
}}
{{dcl end}}

Copies the elements from the range {{tt|[first, last)}}, to another range beginning at {{tt|d_first}} in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to process}}
{{par | d_first | the beginning of the destination range}}
{{par pred2 eq | p | p1=ForwardIt}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | OutputIt | OutputIterator}}
{{par req concept deref | InputIt | CopyAssignable}}
{{par req concept deref | InputIt | CopyConstructible | notes=if neither {{c|InputIt}} nor {{c|OutputIt}} satisfies {{concept|ForwardIterator}}}}
{{par end}}

===Return value===
Output iterator to the element past the last written element

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class OutputIt&gt;
ForwardIt unique_copy(ForwardIt first, ForwardIt last,
                      OutputIt d_first)
{
 
    if (first == last)
        return d_first;

    *d_first = *first;
     while (++first != last) {
        if (!(*d_first == *first)) {
            *(++d_first) = *first;
        }
    }
    return ++d_first;
}
 | 2=
template&lt;class ForwardIt, class OutputIt, class BinaryPredicate&gt;
ForwardIt unique_copy(ForwardIt first, ForwardIt last,
                            OutputIt d_first, BinaryPredicate p)
{
 
    if (first == last)
        return d_first;

    *d_first = *first;
    while (++first != last) {
        if (!p(*result, *first)) {
            *(++d_first) = *first;
        }
    }
    return ++d_first;
}
}}

===Example===
{{example
 | The following program trims all multiple consecutive spaces in a const string and prints the result
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    std::string s1 = &quot;The      string    with many       spaces!&quot;;
    std::cout &lt;&lt; &quot;before: &quot; &lt;&lt; s1 &lt;&lt; '\n';

    std::string s2;
    std::unique_copy(s1.begin(), s1.end(), std::back_inserter(s2),
                     [](char c1, char c2){ return c1 == ' ' &amp;&amp; c2 == ' '; });

    std::cout &lt;&lt; &quot;after:  &quot; &lt;&lt; s2 &lt;&lt; '\n';
}
 | output=
before: The      string    with many       spaces!
after:  The string with many spaces!
}}

===Complexity===

linear in the distance between {{tt|first}} and {{tt|last}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc end}}

[[de:cpp/algorithm/unique copy]]
[[es:cpp/algorithm/unique copy]]
[[fr:cpp/algorithm/unique copy]]
[[it:cpp/algorithm/unique copy]]
[[ja:cpp/algorithm/unique copy]]
[[pt:cpp/algorithm/unique copy]]
[[ru:cpp/algorithm/unique copy]]
[[zh:cpp/algorithm/unique copy]]</text>
      <sha1>0o0v9ap1x3si0i7q0jmwlflp0ytst1q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/algorithm/upper bound</title>
    <ns>0</ns>
    <id>792</id>
    <revision>
      <id>71647</id>
      <parentid>71646</parentid>
      <timestamp>2014-06-17T19:17:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>oh wait it wasn't missing.. just not immediately visible.. well, at least it's more formal</comment>
      <text xml:space="preserve" bytes="3393">{{cpp/title|upper_bound}}
{{cpp/algorithm/navbar}}
{{dcl begin}}
{{dcl header | algorithm}}
{{dcl | num=1 |
template&lt; class ForwardIt, class T &gt;
ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T&amp; value );
}}
{{dcl | num=2 |
template&lt; class ForwardIt, class T, class Compare &gt;
ForwardIt upper_bound( ForwardIt first, ForwardIt last, const T&amp; value, Compare comp );
}}
{{dcl end}}

Returns an iterator pointing to the first element in the range {{tt|[first, last)}} that is ''greater'' than {{tt|value}}.

The range {{tt|[first, last)}} must be at least partially ordered, i.e. partitioned with respect to the expression {{c|!(value &lt; element)}} or {{c|!comp(value, element)}}.  A fully-sorted range meets this criteria, as does a range resulting from a call to {{c|std::partition}}.

The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements to examine}}
{{par | value | value to compare the elements to}}
{{par cmp | comp | t1=T | p2=ForwardIt}} 
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
iterator pointing to the first element that is ''greater'' than {{tt|value}}, or {{tt|last}} if no such element is found.

===Complexity===
At most {{math|log{{su|b=2}}(last - first) + O(1)}} comparisons.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class ForwardIt, class T&gt;
ForwardIt upper_bound(ForwardIt first, ForwardIt last,
                            const T&amp; value)
{
    ForwardIt it;
    typename std::iterator_traits&lt;ForwardIt&gt;::distance_type count, step;
    count = std::distance(first,last);

    while (count &gt; 0) {
        it = first; 
        step = count / 2; 
        std::advance(it, step);
        if (!(value &lt; *it)) {
            first = ++it;
            count -= step + 1;
        } else count = step;
    }
    return first;
}
 | 2=
template&lt;class ForwardIt, class T, class Compare&gt;
ForwardIt upper_bound(ForwardIt first, ForwardIt last,
                            const T&amp; value, Compare comp)
{
    ForwardIt it;
    typename std::iterator_traits&lt;ForwardIt&gt;::distance_type count, step;
    count = std::distance(first,last);

    while (count &gt; 0) {
        it = first; 
        step = count / 2;
        std::advance(it, step);
        if (!comp(value, *it)) {
            first = ++it;
            count -= step + 1;
        } else count = step;
    }
    return first;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; data = { 1, 1, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5, 6 };
    
    auto lower = std::lower_bound(data.begin(), data.end(), 4);
    auto upper = std::upper_bound(data.begin(), data.end(), 4);
    
    std::copy(lower, upper, std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
 | output=
4 4 4 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc equal_range}}
{{dsc inc | cpp/algorithm/dsc lower_bound}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc end}}

[[de:cpp/algorithm/upper bound]]
[[es:cpp/algorithm/upper bound]]
[[fr:cpp/algorithm/upper bound]]
[[it:cpp/algorithm/upper bound]]
[[ja:cpp/algorithm/upper bound]]
[[pt:cpp/algorithm/upper bound]]
[[ru:cpp/algorithm/upper bound]]
[[zh:cpp/algorithm/upper bound]]</text>
      <sha1>fhazilqblx7nublva0pazals400vzts</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic</title>
    <ns>0</ns>
    <id>793</id>
    <revision>
      <id>71017</id>
      <parentid>71009</parentid>
      <timestamp>2014-06-04T18:59:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="1904">{{title|Atomic operations library}}
{{cpp/atomic/navbar}}

The atomic library provides components for fine-grained atomic operations allowing for lockless concurrent programming. Each atomic operation is indivisible with regards to any other atomic operation that involves the same object. Atomic objects are the only C++ objects free of data races; that is, if one thread writes to an atomic while another thread reads from it, the behavior is well-defined.

{{dsc begin}}
{{dsc header | atomic }}
{{dsc h2 | Atomic types }}
{{dsc inc | cpp/atomic/dsc atomic}}
{{dsc h2 | Operations on atomic types }}
{{dsc inc | cpp/atomic/dsc atomic_is_lock_free}}
{{dsc inc | cpp/atomic/dsc atomic_store}}
{{dsc inc | cpp/atomic/dsc atomic_load}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_compare_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_add}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_sub}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_and}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_or}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_xor}}
{{dsc h2 | Flag type and operations }}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc inc | cpp/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | cpp/atomic/dsc atomic_flag_clear}}
{{dsc h2 | Initialization }}
{{dsc inc | cpp/atomic/dsc atomic_init}}
{{dsc inc | cpp/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc inc | cpp/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc h2 | Memory synchronization ordering }}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc inc | cpp/atomic/dsc kill_dependency}}
{{dsc inc | cpp/atomic/dsc atomic_thread_fence}}
{{dsc inc | cpp/atomic/dsc atomic_signal_fence}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/atomic | Atomic operations library}}
{{dsc end}}

[[ar:cpp/atomic]]
[[de:cpp/atomic]]
[[es:cpp/atomic]]
[[fr:cpp/atomic]]
[[it:cpp/atomic]]
[[ja:cpp/atomic]]
[[pt:cpp/atomic]]
[[ru:cpp/atomic]]
[[zh:cpp/atomic]]</text>
      <sha1>tsycwv4z1hnkafhunxyhyrr5qrijnli</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/ATOMIC FLAG INIT</title>
    <ns>0</ns>
    <id>2818</id>
    <revision>
      <id>68872</id>
      <parentid>66195</parentid>
      <timestamp>2014-03-22T20:52:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>lwg 2159</comment>
      <text xml:space="preserve" bytes="1376">{{title|ATOMIC_FLAG_INIT}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic}}
{{dcl |
#define ATOMIC_FLAG_INIT /* implementation-defined */
}}
{{dcl end}}

Defines the expression which can be used to initialize {{lc|std::atomic_flag}} to clear (false) state with the statement {{c|std::atomic_flag v {{=}} ATOMIC_FLAG_INIT;}}. It is unspecified if it can be used with other initialization contexts.

If the flag has static storage duration, this initialization is static.

This is the only way to initialize {{lc|std::atomic_flag}} to a definite value: the value held after any other initialization is unspecified.

===Example===
{{example
 | 
 | code=
#include &lt;atomic&gt;

std::atomic_flag static_flag = ATOMIC_FLAG_INIT; // static initialization,
// guaranteed to be available during dynamic initialization of static objects.

int main()
{
    std::atomic_flag automatic_flag = ATOMIC_FLAG_INIT; // guaranteed to work
//    std::atomic_flag another_flag(ATOMIC_FLAG_INIT); // unspecified
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc end}}

[[de:cpp/atomic/ATOMIC FLAG INIT]]
[[es:cpp/atomic/ATOMIC FLAG INIT]]
[[fr:cpp/atomic/ATOMIC FLAG INIT]]
[[it:cpp/atomic/ATOMIC FLAG INIT]]
[[ja:cpp/atomic/ATOMIC FLAG INIT]]
[[pt:cpp/atomic/ATOMIC FLAG INIT]]
[[ru:cpp/atomic/ATOMIC FLAG INIT]]
[[zh:cpp/atomic/ATOMIC FLAG INIT]]</text>
      <sha1>ec20u1q2kcrkqjj9r1fzzjon3b4s093</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/ATOMIC VAR INIT</title>
    <ns>0</ns>
    <id>9222</id>
    <revision>
      <id>63982</id>
      <parentid>63980</parentid>
      <timestamp>2013-08-05T14:08:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix the previous grammar fix</comment>
      <text xml:space="preserve" bytes="1264">{{title|ATOMIC_VAR_INIT}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic}}
{{dcl |
#define ATOMIC_VAR_INIT(value) /* implementation-defined */
}}
{{dcl end}}

Expands to an expression which can be used to initialize an {{lc|std::atomic}} object that can be initialized from {{tt|value}}. If the atomic object has static storage duration, this initialization is [[cpp/language/constant_initialization|constant initialization]].

===Notes===
Accessing the variable during initialization from another thread, even through an atomic operation, is a data race (it may happen if the address is immediately passed to another thread with a {{lc|std::memory_order_relaxed}} operation)

This macro is primarily provided for compatibility with C; it behaves the same as the constructor of {{lc|std::atomic}}.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_init}}
{{dsc inc | cpp/atomic/atomic/dsc constructor}}
{{dsc end}}

[[de:cpp/atomic/ATOMIC VAR INIT]]
[[es:cpp/atomic/ATOMIC VAR INIT]]
[[fr:cpp/atomic/ATOMIC VAR INIT]]
[[it:cpp/atomic/ATOMIC VAR INIT]]
[[ja:cpp/atomic/ATOMIC VAR INIT]]
[[pt:cpp/atomic/ATOMIC VAR INIT]]
[[ru:cpp/atomic/ATOMIC VAR INIT]]
[[zh:cpp/atomic/ATOMIC VAR INIT]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic</title>
    <ns>0</ns>
    <id>4734</id>
    <revision>
      <id>66487</id>
      <parentid>62655</parentid>
      <timestamp>2013-11-25T19:55:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>std::</comment>
      <text xml:space="preserve" bytes="6061">{{cpp/title|atomic}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic}}
{{dcl | num = 1 | since=c++11 | 1=
template&lt; class T &gt;
struct atomic;
}}
{{dcl | num = 2 | since=c++11 | 1=
template&lt;&gt;
struct atomic&lt;Integral&gt;;
}}
{{dcl | num = 3 | since=c++11 | 1=
template&lt; class T &gt;
struct atomic&lt;T*&gt;;
}}
{{dcl end}}

Each instantiation and full specialization of the {{tt|std::atomic}} template defines an atomic type. Objects of atomic types are the only C++ objects that are free from data races; that is, if one thread writes to an atomic object while another thread reads from it, the behavior is well-defined.

In addition, accesses to atomic objects may establish inter-thread synchronization and order non-atomic memory accesses as specified by {{lc|std::memory_order}}.

The standard library provides specializations of the {{tt|std::atomic}} template for the following types:

1) One full specialization for the type {{c|bool}} and its typedef name is defined that is treated as a non-specialized {{tt|std::atomic&lt;T&gt;}} except that it has standard layout, trivial default constructor, trivial destructors, and supports aggregate initialization syntax:
{{dsc begin}}
{{dsc hitem | Typedef name | Full specialization }}
{{dsc | {{c|std::atomic_bool}} | {{c|std::atomic&lt;bool&gt;}} }}
{{dsc end}}

2) Full specializations and typedefs for integral types, as follows:
{{dsc begin}}
{{dsc hitem | Typedef name | Full specialization }}
{{dsc | {{c|std::atomic_char}} | {{c|std::atomic&lt;char&gt;}} }}
{{dsc | {{c|std::atomic_schar}} | {{c|std::atomic&lt;signed char&gt;}} }}
{{dsc | {{c|std::atomic_uchar}} | {{c|std::atomic&lt;unsigned char&gt;}} }}
{{dsc | {{c|std::atomic_short}} | {{c|std::atomic&lt;short&gt;}} }}
{{dsc | {{c|std::atomic_ushort}} | {{c|std::atomic&lt;unsigned short&gt;}} }}
{{dsc | {{c|std::atomic_int}} | {{c|std::atomic&lt;int&gt;}} }}
{{dsc | {{c|std::atomic_uint}} | {{c|std::atomic&lt;unsigned int&gt;}} }}
{{dsc | {{c|std::atomic_long}} | {{c|std::atomic&lt;long&gt;}} }}
{{dsc | {{c|std::atomic_ulong}} | {{c|std::atomic&lt;unsigned long&gt;}} }}
{{dsc | {{c|std::atomic_llong}} | {{c|std::atomic&lt;long long&gt;}} }}
{{dsc | {{c|std::atomic_ullong}} | {{c|std::atomic&lt;unsigned long long&gt;}} }}
{{dsc | {{c|std::atomic_char16_t}} | {{c|std::atomic&lt;char16_t&gt;}} }}
{{dsc | {{c|std::atomic_char32_t}} | {{c|std::atomic&lt;char32_t&gt;}} }}
{{dsc | {{c|std::atomic_wchar_t}} | {{c|std::atomic&lt;wchar_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least8_t}} | {{c|std::atomic&lt;std::int_least8_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least8_t}} | {{c|std::atomic&lt;std::uint_least8_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least16_t}} | {{c|std::atomic&lt;std::int_least16_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least16_t}} | {{c|std::atomic&lt;std::uint_least16_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least32_t}} | {{c|std::atomic&lt;std::int_least32_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least32_t}} | {{c|std::atomic&lt;std::uint_least32_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least64_t}} | {{c|std::atomic&lt;std::int_least64_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least64_t}} | {{c|std::atomic&lt;std::uint_least64_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast8_t}} | {{c|std::atomic&lt;std::int_fast8_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast8_t}} | {{c|std::atomic&lt;std::uint_fast8_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast16_t}} | {{c|std::atomic&lt;std::int_fast16_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast16_t}} | {{c|std::atomic&lt;std::uint_fast16_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast32_t}} | {{c|std::atomic&lt;std::int_fast32_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast32_t}} | {{c|std::atomic&lt;std::uint_fast32_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast64_t}} | {{c|std::atomic&lt;std::int_fast64_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast64_t}} | {{c|std::atomic&lt;std::uint_fast64_t&gt;}} }}
{{dsc | {{c|std::atomic_intptr_t}} | {{c|std::atomic&lt;std::intptr_t&gt;}} }}
{{dsc | {{c|std::atomic_uintptr_t}} | {{c|std::atomic&lt;std::uintptr_t&gt;}} }}
{{dsc | {{c|std::atomic_size_t}} | {{c|std::atomic&lt;std::size_t&gt;}} }}
{{dsc | {{c|std::atomic_ptrdiff_t}} | {{c|std::atomic&lt;std::ptrdiff_t&gt;}} }}
{{dsc | {{c|std::atomic_intmax_t}} | {{c|std::atomic&lt;std::intmax_t&gt;}} }}
{{dsc | {{c|std::atomic_uintmax_t}} | {{c|std::atomic&lt;std::uintmax_t&gt;}} }}
{{dsc end}}
These specializations have standard layout, trivial default constructors, and trivial destructors. They support aggregate initialization syntax.

3) Partial specializations {{tt|std::atomic&lt;T*&gt;}} for all pointer types. These specializations have standard layout, trivial default constructors, and trivial destructors. They support aggregate initialization syntax.

In addition, {{tt|std::atomic}} may be instantiated with any {{concept|TriviallyCopyable}} type {{tt|T}}.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc constructor}}
{{dsc inc | cpp/atomic/atomic/dsc operator{{=}}}}
{{dsc inc | cpp/atomic/atomic/dsc is_lock_free}}
{{dsc inc | cpp/atomic/atomic/dsc store}}
{{dsc inc | cpp/atomic/atomic/dsc load}}
{{dsc inc | cpp/atomic/atomic/dsc operator_T}}
{{dsc inc | cpp/atomic/atomic/dsc exchange}}
{{dsc inc | cpp/atomic/atomic/dsc compare_exchange}}
{{dsc end}}

===Specialized member functions===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_add}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_sub}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_and}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_or}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_xor}}
{{dsc inc | cpp/atomic/atomic/dsc operator_arith}}
{{dsc inc | cpp/atomic/atomic/dsc operator_arith2}}
{{dsc end}}

===Notes===
There are non-member function template equivalents for all member functions of {{tt|std::atomic}}. Those non-member functions may be additionally overloaded for types that are not  specializations of {{lc|std::atomic}}, but are able to guarantee atomicity. The only such type in the standard library is {{c|std::shared_ptr&lt;T&gt;}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc end}}

[[de:cpp/atomic/atomic]]
[[es:cpp/atomic/atomic]]
[[fr:cpp/atomic/atomic]]
[[it:cpp/atomic/atomic]]
[[ja:cpp/atomic/atomic]]
[[pt:cpp/atomic/atomic]]
[[ru:cpp/atomic/atomic]]
[[zh:cpp/atomic/atomic]]</text>
      <sha1>syf6fud03pp7hjcklopzgs29e5q15uz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/atomic</title>
    <ns>0</ns>
    <id>9224</id>
    <revision>
      <id>62656</id>
      <parentid>49310</parentid>
      <timestamp>2013-07-01T23:31:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1079">{{cpp/atomic/atomic/title|atomic}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
atomic() = default;
}}
{{dcl | since=c++11 | num=2 |
constexpr atomic( T desired );
}}
{{dcl | since=c++11 | num=3 | 1=
atomic( const atomic&amp; ) = delete;
}}
{{dcl end}}

Constructs new atomic variable.
@1@ The default constructor is trivial: no initialization takes place other than [[cpp/language/zero_initialization|zero initialization]] of static and thread-local objects. {{lc|std::atomic_init}} may be used to complete initialization.
@2@ Initializes the underlying value with {{tt|desired}}. The initialization is not atomic.
@3@ Atomic variables are not {{concept|CopyConstructible}}.

===Parameters===
{{par begin}}
{{par | desired | value to initialize with}}
{{par end}}

===Exceptions===
{{noexcept}}

[[de:cpp/atomic/atomic/atomic]]
[[es:cpp/atomic/atomic/atomic]]
[[fr:cpp/atomic/atomic/atomic]]
[[it:cpp/atomic/atomic/atomic]]
[[ja:cpp/atomic/atomic/atomic]]
[[pt:cpp/atomic/atomic/atomic]]
[[ru:cpp/atomic/atomic/atomic]]
[[zh:cpp/atomic/atomic/atomic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/compare exchange</title>
    <ns>0</ns>
    <id>5628</id>
    <revision>
      <id>67737</id>
      <parentid>67694</parentid>
      <timestamp>2014-02-23T17:48:12Z</timestamp>
      <contributor>
        <ip>88.115.29.236</ip>
      </contributor>
      <comment>Fixed typo, see §29.6.5.21</comment>
      <text xml:space="preserve" bytes="6771">{{cpp/atomic/title|compare_exchange_weak|compare_exchange_strong}}
{{cpp/atomic/atomic/navbar}}

{{dcl begin}}
{{dcl header | atomic}}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 1=
bool compare_exchange_weak( T&amp; expected, T desired,
                            std::memory_order success, 
                            std::memory_order failure );
}}
{{dcl | 1=
bool compare_exchange_weak( T&amp; expected, T desired,
                            std::memory_order success, 
                            std::memory_order failure ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 1=
bool compare_exchange_weak( T&amp; expected, T desired,
                            std::memory_order order =
                                std::memory_order_seq_cst );
}}
{{dcl | 1=
bool compare_exchange_weak( T&amp; expected, T desired,
                            std::memory_order order =
                                std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=3 | since=c++11}}
{{dcl | 1=
bool compare_exchange_strong( T&amp; expected, T desired,
                              std::memory_order success, 
                              std::memory_order failure );
}}
{{dcl | 1=
bool compare_exchange_strong( T&amp; expected, T desired,
                              std::memory_order success, 
                              std::memory_order failure ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=4 | since=c++11}}
{{dcl | 1=
bool compare_exchange_strong( T&amp; expected, T desired,
                              std::memory_order order = 
                                  std::memory_order_seq_cst );
}}
{{dcl | 1=
bool compare_exchange_strong( T&amp; expected, T desired,
                              std::memory_order order = 
                                  std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically compares the value stored in {{tt|*this}} with the value of {{tt|expected}}, and if those are equal, replaces the former with {{tt|desired}} (performs read-modify-write operation). Otherwise, loads the actual value stored in {{tt|*this}} into {{tt|expected}} (performs load operation).

The memory models for the read-modify-write and load operations are {{tt|success}} and {{tt|failure}} respectively. In the (2) and (4) versions {{tt|order}} is used for both read-modify-write and load operations, except that {{lc|std::memory_order_acquire}} and {{lc|std::memory_order_relaxed}} are used for the load operation if {{c|1=order == std::memory_order_acq_rel}}, or {{c|1=order == std::memory_order_release}} respectively.

The weak forms (1-2) of the functions are allowed to fail spuriously, that is, act as if {{c|1=*this != expected}} even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

===Parameters===
{{par begin}}
{{par | expected | reference to the value expected to be found in the atomic object}}
{{par | desired | the value to store in the atomic object if it is as expected}}
{{par | success | the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. }}
{{par | failure | the memory synchronization ordering for the load operation if the comparison fails. Cannot be {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}} and cannot specify stronger ordering than {{tt|success}}}}
{{par | order | the memory synchronization ordering for both operations}}
{{par end}}

===Return value===
{{c|true}} if the underlying atomic value was changed, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | compare and exchange operations are often used as basic building blocks of lockfree data structures
 | code=
#include &lt;atomic&gt;
template&lt;typename T&gt;
struct node
{
    T data;
    node* next;
    node(const T&amp; data) : data(data), next(nullptr) {}
};

template&lt;typename T&gt;
class stack
{
    std::atomic&lt;node&lt;T&gt;*&gt; head;
 public:
    void push(const T&amp; data)
    {
        node&lt;T&gt;* new_node = new node&lt;T&gt;(data);

//      // put the current value of head into new_node-&gt;next
//      new_node-&gt;next = head.load(std::memory_order_relaxed);
//
//      // now make new_node the new head, but if the head
//      // is no longer what's stored in new_node-&gt;next
//      // (some other thread must have inserted a node just now)
//      // then put that new head into new_node-&gt;next and try again
//      while(!head.compare_exchange_weak(new_node-&gt;next, new_node,
//                                        std::memory_order_release,
//                                        std::memory_order_relaxed))
//          ; // the body of the loop is empty
//
// Note: the above use is not thread-safe in at least 
// GCC prior to 4.8.3 (bug 60272), clang (bug 18899), MSVC (bug 819819).
// The following is a workaround:
        node&lt;T&gt;* old_head = head.load(std::memory_order_relaxed);
        do {
            new_node-&gt;next = old_head;
        } while(!head.compare_exchange_weak(old_head, new_node,
                                            std::memory_order_release,
                                            std::memory_order_relaxed));
    }
};
int main()
{
    stack&lt;int&gt; s;
    s.push(1);
    s.push(2);
    s.push(3);
}
}}

{{example
 | Demonstrates how compare_exchange_strong either changes the value of the atomic variable or the variable used for comparison.
 | code=
#include &lt;atomic&gt;
#include &lt;iostream&gt;

std::atomic&lt;int&gt;  ai;

int  tst_val= 4;
int  new_val= 5;
bool exchanged= false;

void valsout()
{
    std::cout &lt;&lt; &quot;ai= &quot; &lt;&lt; ai
	      &lt;&lt; &quot;  tst_val= &quot; &lt;&lt; tst_val
	      &lt;&lt; &quot;  new_val= &quot; &lt;&lt; new_val
	      &lt;&lt; &quot;  exchanged= &quot; &lt;&lt; std::boolalpha &lt;&lt; exchanged
	      &lt;&lt; &quot;\n&quot;;
}

int main()
{
    ai= 3;
    valsout();

    // tst_val != ai   ==&gt;  tst_val is modified
    exchanged= ai.compare_exchange_strong( tst_val, new_val );
    valsout();

    // tst_val == ai   ==&gt;  ai is modified
    exchanged= ai.compare_exchange_strong( tst_val, new_val );
    valsout();
  
    return 0;
}
 | output=
ai= 3  tst_val= 4  new_val= 5  exchanged= false
ai= 3  tst_val= 3  new_val= 5  exchanged= false
ai= 5  tst_val= 3  new_val= 5  exchanged= true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_compare_exchange}}
{{dsc end}}

[[de:cpp/atomic/atomic/compare exchange]]
[[es:cpp/atomic/atomic/compare exchange]]
[[fr:cpp/atomic/atomic/compare exchange]]
[[it:cpp/atomic/atomic/compare exchange]]
[[ja:cpp/atomic/atomic/compare exchange]]
[[pt:cpp/atomic/atomic/compare exchange]]
[[ru:cpp/atomic/atomic/compare exchange]]
[[zh:cpp/atomic/atomic/compare exchange]]</text>
      <sha1>clqr7tv2hipe8v4vla4e9qgj8fva6ym</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/exchange</title>
    <ns>0</ns>
    <id>9230</id>
    <revision>
      <id>65614</id>
      <parentid>62658</parentid>
      <timestamp>2013-09-23T18:58:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1087">{{cpp/atomic/atomic/title|exchange}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11}}
{{dcl | 1=
T exchange( T desired, memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T exchange( T desired, memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the underlying value with {{tt|desired}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

===Parameters===
{{par begin}}
{{par | desired | value to assign}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc end}}

[[de:cpp/atomic/atomic/exchange]]
[[es:cpp/atomic/atomic/exchange]]
[[fr:cpp/atomic/atomic/exchange]]
[[it:cpp/atomic/atomic/exchange]]
[[ja:cpp/atomic/atomic/exchange]]
[[pt:cpp/atomic/atomic/exchange]]
[[ru:cpp/atomic/atomic/exchange]]
[[zh:cpp/atomic/atomic/exchange]]</text>
      <sha1>6a61o8o9p3jdiruwyq3bxbqtek4fkgs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/fetch add</title>
    <ns>0</ns>
    <id>9237</id>
    <revision>
      <id>70684</id>
      <parentid>70682</parentid>
      <timestamp>2014-05-28T13:23:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>-endl, -unused header, +relaxed since no other sync is necessary in the new example</comment>
      <text xml:space="preserve" bytes="2386">{{cpp/atomic/atomic/title|fetch_add}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T fetch_add( T arg, 
             memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T fetch_add( T arg, 
             memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}}}
{{dcl | 1=
T* fetch_add( std::ptrdiff_t arg, 
              memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T* fetch_add( std::ptrdiff_t arg, 
              memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of arithmetic addition of the value and {{tt|arg}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

For signed {{tt|Integral}} types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For {{tt|T*}} types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
{{par begin}}
{{par | arg | the other argument of arithmetic addition}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.
 
===Exceptions===
{{noexcept}}
===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;atomic&gt;

std::atomic&lt;long long&gt; data;
void do_work()
{
    data.fetch_add(1, std::memory_order_relaxed);
}

int main()
{
    std::thread th1(do_work);
    std::thread th2(do_work);
    std::thread th3(do_work);
    std::thread th4(do_work);
    std::thread th5(do_work);
    
    th1.join();
    th2.join();
    th3.join();
    th4.join();
    th5.join();

    std::cout &lt;&lt; &quot;Result:&quot; &lt;&lt; data &lt;&lt; '\n';
}
 | output=
Result:5
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_add}}
{{dsc end}}

[[de:cpp/atomic/atomic/fetch add]]
[[es:cpp/atomic/atomic/fetch add]]
[[fr:cpp/atomic/atomic/fetch add]]
[[it:cpp/atomic/atomic/fetch add]]
[[ja:cpp/atomic/atomic/fetch add]]
[[pt:cpp/atomic/atomic/fetch add]]
[[ru:cpp/atomic/atomic/fetch add]]
[[zh:cpp/atomic/atomic/fetch add]]</text>
      <sha1>723fginvucq4qjkj9taut8xh3zk921r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/fetch and</title>
    <ns>0</ns>
    <id>9236</id>
    <revision>
      <id>65627</id>
      <parentid>65625</parentid>
      <timestamp>2013-09-23T19:06:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1254">{{cpp/atomic/atomic/title|fetch_and}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T fetch_and( T arg, 
             memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T fetch_and( T arg, 
             memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of bitwise AND of the value and {{tt|arg}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

===Parameters===
{{par begin}}
{{par | arg | the other argument of bitwise AND}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.
 
===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_and}}
{{dsc end}}

[[de:cpp/atomic/atomic/fetch and]]
[[es:cpp/atomic/atomic/fetch and]]
[[fr:cpp/atomic/atomic/fetch and]]
[[it:cpp/atomic/atomic/fetch and]]
[[ja:cpp/atomic/atomic/fetch and]]
[[pt:cpp/atomic/atomic/fetch and]]
[[ru:cpp/atomic/atomic/fetch and]]
[[zh:cpp/atomic/atomic/fetch and]]</text>
      <sha1>epsmx8ezk2j3m8iarlc78a9nr2k8kh0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/fetch or</title>
    <ns>0</ns>
    <id>9235</id>
    <revision>
      <id>65624</id>
      <parentid>57107</parentid>
      <timestamp>2013-09-23T19:05:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1240">{{cpp/atomic/atomic/title|fetch_or}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T fetch_or( T arg, 
             memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T fetch_or( T arg, 
             memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of bitwise OR of the value and {{tt|arg}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

===Parameters===
{{par begin}}
{{par | arg | the other argument of bitwise OR}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.
 
===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_or}}
{{dsc end}}

[[de:cpp/atomic/atomic/fetch or]]
[[es:cpp/atomic/atomic/fetch or]]
[[fr:cpp/atomic/atomic/fetch or]]
[[it:cpp/atomic/atomic/fetch or]]
[[ja:cpp/atomic/atomic/fetch or]]
[[pt:cpp/atomic/atomic/fetch or]]
[[ru:cpp/atomic/atomic/fetch or]]
[[zh:cpp/atomic/atomic/fetch or]]</text>
      <sha1>o8dtfj4uvg5gvtk4f18yfpcqcobcce8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/fetch sub</title>
    <ns>0</ns>
    <id>9238</id>
    <revision>
      <id>65626</id>
      <parentid>57108</parentid>
      <timestamp>2013-09-23T19:06:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1870">{{cpp/atomic/atomic/title|fetch_sub}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T fetch_sub( T arg, 
             memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T fetch_sub( T arg, 
             memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}}}
{{dcl | 1=
T* fetch_sub( std::ptrdiff_t arg, 
              memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T* fetch_sub( std::ptrdiff_t arg, 
              memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of arithmetic subtraction of the value and {{tt|arg}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

For signed {{tt|Integral}} types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For {{tt|T*}} types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
{{par begin}}
{{par | arg | the other argument of arithmetic subtraction}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.
 
===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_sub}}
{{dsc end}}

[[de:cpp/atomic/atomic/fetch sub]]
[[es:cpp/atomic/atomic/fetch sub]]
[[fr:cpp/atomic/atomic/fetch sub]]
[[it:cpp/atomic/atomic/fetch sub]]
[[ja:cpp/atomic/atomic/fetch sub]]
[[pt:cpp/atomic/atomic/fetch sub]]
[[ru:cpp/atomic/atomic/fetch sub]]
[[zh:cpp/atomic/atomic/fetch sub]]</text>
      <sha1>chncz2at756yqzt6exunlv8ymq19uv6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/fetch xor</title>
    <ns>0</ns>
    <id>9234</id>
    <revision>
      <id>65623</id>
      <parentid>57111</parentid>
      <timestamp>2013-09-23T19:05:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1254">{{cpp/atomic/atomic/title|fetch_xor}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T fetch_xor( T arg, 
             memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
T fetch_xor( T arg, 
             memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of bitwise XOR of the value and {{tt|arg}}. The operation is read-modify-write operation. Memory is affected according to the value of {{tt|memory_order}}.

===Parameters===
{{par begin}}
{{par | arg | the other argument of bitwise XOR}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The value of the atomic variable before the call.
 
===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_xor}}
{{dsc end}}

[[de:cpp/atomic/atomic/fetch xor]]
[[es:cpp/atomic/atomic/fetch xor]]
[[fr:cpp/atomic/atomic/fetch xor]]
[[it:cpp/atomic/atomic/fetch xor]]
[[ja:cpp/atomic/atomic/fetch xor]]
[[pt:cpp/atomic/atomic/fetch xor]]
[[ru:cpp/atomic/atomic/fetch xor]]
[[zh:cpp/atomic/atomic/fetch xor]]</text>
      <sha1>c25m9itg7sb7ee5rakm8rv0w9c7cxna</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/is lock free</title>
    <ns>0</ns>
    <id>9226</id>
    <revision>
      <id>65617</id>
      <parentid>62659</parentid>
      <timestamp>2013-09-23T18:59:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="851">{{cpp/atomic/atomic/title|atomic}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11}}
{{dcl | 
bool is_lock_free() const;
}}
{{dcl | 
bool is_lock_free() const volatile;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether the atomic operations on the object are lock-free.

===Parameters===
(none)

===Return value===
{{c|true}} if the atomic operations on the object are lock-free, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_is_lock_free}}
{{dsc end}}

[[de:cpp/atomic/atomic/is lock free]]
[[es:cpp/atomic/atomic/is lock free]]
[[fr:cpp/atomic/atomic/is lock free]]
[[it:cpp/atomic/atomic/is lock free]]
[[ja:cpp/atomic/atomic/is lock free]]
[[pt:cpp/atomic/atomic/is lock free]]
[[ru:cpp/atomic/atomic/is lock free]]
[[zh:cpp/atomic/atomic/is lock free]]</text>
      <sha1>rohu5xmubkv6rywkxe39gi2a138xcjz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/load</title>
    <ns>0</ns>
    <id>9228</id>
    <revision>
      <id>65619</id>
      <parentid>62660</parentid>
      <timestamp>2013-09-23T19:00:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1206">{{cpp/atomic/atomic/title|load}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11}}
{{dcl | 1=
T load( memory_order = std::memory_order_seq_cst ) const;
}}
{{dcl | 1=
T load( memory_order = std::memory_order_seq_cst ) const volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically loads and returns the current value of the atomic variable. Memory is affected according to the value of {{tt|memory_order}}.

{{tt|memory_order}} must be one of {{lc|std::memory_order_relaxed}}, {{lc|std::memory_order_consume}}, {{lc|std::memory_order_acquire}} or {{lc|std::memory_order_seq_cst}}. Otherwise the behavior is undefined.

===Parameters===
{{par begin}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
The current value of the atomic variable.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc operator_T}}
{{dsc inc | cpp/atomic/dsc atomic_load}}
{{dsc end}}

[[de:cpp/atomic/atomic/load]]
[[es:cpp/atomic/atomic/load]]
[[fr:cpp/atomic/atomic/load]]
[[it:cpp/atomic/atomic/load]]
[[ja:cpp/atomic/atomic/load]]
[[pt:cpp/atomic/atomic/load]]
[[ru:cpp/atomic/atomic/load]]
[[zh:cpp/atomic/atomic/load]]</text>
      <sha1>f6lh25kaal6wqxw1yaxvw2k6sg4lbyn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/operator=</title>
    <ns>0</ns>
    <id>9225</id>
    <revision>
      <id>65616</id>
      <parentid>65615</parentid>
      <timestamp>2013-09-23T18:59:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1315">{{cpp/atomic/atomic/title|operator{{=}}}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 1=
T operator=( T desired );
}}
{{dcl | since=c++11 | num=1 | 1=
T operator=( T desired ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 1=
atomic&amp; operator=( const atomic&amp; ) = delete;
}}
{{dcl | 1=
atomic&amp; operator=( const atomic&amp; ) volatile = delete;
}}
{{dcl rev end}}
{{dcl end}}

@1@ Atomically assigns a value {{tt|t}} to the atomic variable. Equivalent to {{c|store(desired)}}.
@2@ Atomic variables are not {{concept|CopyAssignable}}.

===Parameters===
{{par begin}}
{{par | desired | value to assign}}
{{par end}}

===Return value===
{{tt|desired}}.

===Exceptions===
{{noexcept}}

===Notes===
Unlike most assignment operators, the assignment operators for atomic types do not return a reference to their left-hand arguments. They return a copy of the stored value instead.

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc constructor}}
{{dsc end}}

[[de:cpp/atomic/atomic/operator=]]
[[es:cpp/atomic/atomic/operator=]]
[[fr:cpp/atomic/atomic/operator=]]
[[it:cpp/atomic/atomic/operator=]]
[[ja:cpp/atomic/atomic/operator=]]
[[pt:cpp/atomic/atomic/operator=]]
[[ru:cpp/atomic/atomic/operator=]]
[[zh:cpp/atomic/atomic/operator=]]</text>
      <sha1>gs8j8v2nn5fndkazfv2v2lm1ethmny3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/operator T</title>
    <ns>0</ns>
    <id>9229</id>
    <revision>
      <id>65620</id>
      <parentid>62662</parentid>
      <timestamp>2013-09-23T19:00:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="806">{{cpp/atomic/atomic/title|operator T()}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11}}
{{dcl | 
operator T() const;
}}
{{dcl | 
operator T() const volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically loads and returns the current value of the atomic variable. Equivalent to {{c|load()}}.

===Parameters===
(none)

===Return value===
The current value of the atomic variable.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc load}}
{{dsc end}}

[[de:cpp/atomic/atomic/operator T]]
[[es:cpp/atomic/atomic/operator T]]
[[fr:cpp/atomic/atomic/operator T]]
[[it:cpp/atomic/atomic/operator T]]
[[ja:cpp/atomic/atomic/operator T]]
[[pt:cpp/atomic/atomic/operator T]]
[[ru:cpp/atomic/atomic/operator T]]
[[zh:cpp/atomic/atomic/operator T]]</text>
      <sha1>7617ox6zqjfltfwzeelpehd0ad2vvwq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/operator arith</title>
    <ns>0</ns>
    <id>9233</id>
    <revision>
      <id>57120</id>
      <parentid>49322</parentid>
      <timestamp>2013-06-01T05:47:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3083">{{cpp/atomic/atomic/title|1=operator++,++{{small|(int)}},--,--{{small|(int)}}}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl | num=1 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T operator++();
T operator++() volatile;
}}
{{dcl | num=1 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T* operator++();
T* operator++() volatile;
}}
{{dcl | num=2 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T operator++( int );
T operator++( int ) volatile;
}}
{{dcl | num=2 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T* operator++( int );
T* operator++( int ) volatile;
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T operator--();
T operator--() volatile;
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T* operator--();
T* operator--() volatile;
}}
{{dcl | num=4 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T operator--( int );
T operator--( int ) volatile;
}}
{{dcl | num=4 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T* operator--( int );
T* operator--( int ) volatile;
}}
{{dcl end}}

Atomically increments or decrements the current value. The operation is read-modify-write operation. 

@1@ Performs atomic pre-increment. Equivalent to {{c|fetch_add(1)+1}}.
@2@ Performs atomic post-increment. Equivalent to {{c|fetch_add(1)}}.
@3@ Performs atomic pre-decrement. Equivalent to {{c|fetch_sub(1)-1}}
@4@ Performs atomic post-decrement. Equivalent to {{c|fetch_sub(1)}}.

For signed {{tt|Integral}} types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For {{tt|T*}} types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
(none)

===Return value===
@1,3@ The value of the atomic variable after the modification.
@2,4@ The value of the atomic variable before the modification.

===Exceptions===
{{noexcept}}

===Notes===
Unlike most pre-increment and pre-decrement operators, the pre-increment and pre-decrement operators for atomic types do not return a reference to the modified object. They return a copy of the stored value instead.

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_add}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_sub}}
{{dsc inc | cpp/atomic/atomic/dsc operator_arith2}}
{{dsc end}}

[[de:cpp/atomic/atomic/operator arith]]
[[es:cpp/atomic/atomic/operator arith]]
[[fr:cpp/atomic/atomic/operator arith]]
[[it:cpp/atomic/atomic/operator arith]]
[[ja:cpp/atomic/atomic/operator arith]]
[[pt:cpp/atomic/atomic/operator arith]]
[[ru:cpp/atomic/atomic/operator arith]]
[[zh:cpp/atomic/atomic/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/operator arith2</title>
    <ns>0</ns>
    <id>9232</id>
    <revision>
      <id>65814</id>
      <parentid>57121</parentid>
      <timestamp>2013-10-08T19:47:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="3313">{{cpp/atomic/atomic/title|1=operator+=,-=,&amp;=,{{!}}=,^=}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T operator+=( T arg );
}}
{{dcl | 1=
T operator+=( T arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=1 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}}}
{{dcl | 1=
T* operator+=( std::ptrdiff_t arg );
}}
{{dcl | 1=
T* operator+=( std::ptrdiff_t arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T operator-=( T arg );
}}
{{dcl | 1=
T operator-=( T arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;T*&gt;}} template specialization}}}}
{{dcl | 1=
T* operator-=( std::ptrdiff_t arg );
}}
{{dcl | 1=
T* operator-=( std::ptrdiff_t arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=3 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T operator&amp;=( T arg );
}}
{{dcl | 1=
T operator&amp;=( T arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=4 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T operator{{!}}=( T arg );
}}
{{dcl | 1=
T operator{{!}}=( T arg ) volatile;
}}
{{dcl rev end}}
{{dcl rev begin | num=5 | since=c++11 | notes={{mark|member only of {{tt|atomic&lt;''Integral''&gt;}} template specialization}}}}
{{dcl | 1=
T operator^=( T arg );
}}
{{dcl | 1=
T operator^=( T arg ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with the result of computation involving the previous value and {{tt|arg}}. The operation is read-modify-write operation.

@1@ Performs atomic addition. Equivalent to {{c|fetch_add(arg)}} + arg.
@2@ Performs atomic subtraction. Equivalent to {{c|fetch_sub(arg)}} - arg.
@3@ Performs atomic bitwise and. Equivalent to {{c|fetch_and(arg)}} &amp; arg.
@4@ Performs atomic bitwise or. Equivalent to {{c|fetch_or(arg)}} | arg.
@5@ Performs atomic bitwise exclusive or. Equivalent to {{c|fetch_xor(arg)}} ^ arg.

For signed {{tt|Integral}} types, arithmetic is defined to use two’s complement representation. There
are no undefined results. For {{tt|T*}} types, the result may be an undefined address, but the operations otherwise have no undefined behavior.

===Parameters===
{{par begin}}
{{par | arg | the argument for the arithmetic operation}}
{{par end}}

===Return value===
The resulting value.

===Exceptions===
{{noexcept}}

===Notes===
Unlike most compound assignment operators, the compound assignment operators for atomic types do not return a reference to their left-hand arguments. They return a copy of the stored value instead.

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc operator_arith}}
{{dsc end}}

[[de:cpp/atomic/atomic/operator arith2]]
[[es:cpp/atomic/atomic/operator arith2]]
[[fr:cpp/atomic/atomic/operator arith2]]
[[it:cpp/atomic/atomic/operator arith2]]
[[ja:cpp/atomic/atomic/operator arith2]]
[[pt:cpp/atomic/atomic/operator arith2]]
[[ru:cpp/atomic/atomic/operator arith2]]
[[zh:cpp/atomic/atomic/operator arith2]]</text>
      <sha1>hnqc8q2maidenhe0pc3l8mz91087azq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic/store</title>
    <ns>0</ns>
    <id>9227</id>
    <revision>
      <id>65618</id>
      <parentid>62663</parentid>
      <timestamp>2013-09-23T19:00:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1220">{{cpp/atomic/atomic/title|store}}
{{cpp/atomic/atomic/navbar}}
{{dcl begin}}
{{dcl rev begin | since=c++11}}
{{dcl | 1=
void store( T desired, memory_order = std::memory_order_seq_cst );
}}
{{dcl | 1=
void store( T desired, memory_order = std::memory_order_seq_cst ) volatile;
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the current value with {{tt|desired}}. Memory is affected according to the value of {{tt|memory_order}}.

{{tt|memory_order}} must be one of {{lc|std::memory_order_relaxed}}, {{lc|std::memory_order_release}} or {{lc|std::memory_order_seq_cst}}. Otherwise the behavior is undefined.

===Parameters===
{{par begin}}
{{par | desired | the value to store into the atomic variable}}
{{par | memory_order | memory order constraints to enforce}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc operator{{=}}}}
{{dsc inc | cpp/atomic/dsc atomic_store}}
{{dsc end}}

[[de:cpp/atomic/atomic/store]]
[[es:cpp/atomic/atomic/store]]
[[fr:cpp/atomic/atomic/store]]
[[it:cpp/atomic/atomic/store]]
[[ja:cpp/atomic/atomic/store]]
[[pt:cpp/atomic/atomic/store]]
[[ru:cpp/atomic/atomic/store]]
[[zh:cpp/atomic/atomic/store]]</text>
      <sha1>sds9hjf3yqbgoz1bgl703qccy6rx68i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic compare exchange</title>
    <ns>0</ns>
    <id>6322</id>
    <revision>
      <id>67640</id>
      <parentid>67625</parentid>
      <timestamp>2014-02-15T14:27:59Z</timestamp>
      <contributor>
        <username>Duncan.forster</username>
        <id>2860</id>
      </contributor>
      <comment>Fix while condition in example</comment>
      <text xml:space="preserve" bytes="6500">{{cpp/title|atomic_compare_exchange_weak|atomic_compare_exchange_strong|atomic_compare_exchange_weak_explicit|atomic_compare_exchange_strong_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
bool atomic_compare_exchange_weak( std::atomic&lt;T&gt;* obj, 
                                   T* expected, T desired );
}}
{{dcl | 
template&lt; class T &gt;
bool atomic_compare_exchange_weak( volatile std::atomic&lt;T&gt;* obj, 
                                   T* expected, T desired );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_strong( std::atomic&lt;T&gt;* obj,
                                     T* expected, T desired );
}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_strong( volatile std::atomic&lt;T&gt;* obj,
                                     T* expected, T desired );
}}
{{dcl rev end}}
{{dcl rev begin | num=3 | since=c++11}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_weak_explicit( std::atomic&lt;T&gt;* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );
}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_weak_explicit( volatile std::atomic&lt;T&gt;* obj,
                                            T* expected, T desired,
                                            std::memory_order succ, 
                                            std::memory_order fail );
}}
{{dcl rev end}}
{{dcl rev begin | num=4 | since=c++11}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_strong_explicit( std::atomic&lt;T&gt;* obj,
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );
}}
{{dcl |
template&lt; class T &gt;
bool atomic_compare_exchange_strong_explicit( volatile std::atomic&lt;T&gt;* obj, 
                                              T* expected, T desired,
                                              std::memory_order succ, 
                                              std::memory_order fail );
}}
{{dcl rev end}}
{{dcl end}}

Atomically compares the value pointed to by {{tt|obj}} with the value pointed to by {{tt|expected}}, and if those are equal, replaces the former with {{tt|desired}} (performs read-modify-write operation). Otherwise, loads the actual value pointed to by {{tt|obj}} into {{tt|*expected}} (performs load operation).

The memory models for the read-modify-write and load operations are {{tt|succ}} and {{tt|fail}} respectively. The (1-2) versions use {{lc|std::memory_order_seq_cst}} by default.

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if {{c|1=*obj != *expected}} even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable.

These functions are defined in terms of member functions of {{lc|std::atomic}}:

@1@ {{c|obj-&gt;compare_exchange_weak(*expected, desired)}}
@2@ {{c|obj-&gt;compare_exchange_strong(*expected, desired)}}
@3@ {{c|obj-&gt;compare_exchange_weak(*expected, desired, succ, fail)}}
@4@ {{c|obj-&gt;compare_exchange_strong(*expected, desired, succ, fail)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to test and modify}}
{{par | expected | pointer to the value expected to be found in the atomic object}}
{{par | desired | the value to store in the atomic object if it is as expected}}
{{par | succ | the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted. }}
{{par | fail | the memory synchronization ordering for the load operation if the comparison fails. Cannot be {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}} and cannot specify stronger ordering than {{tt|succ}}}}
{{par end}} 

===Return value===
The result of the comparison: {{c|true}} if {{tt|*obj}} was equal to {{tt|*exp}}, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example | compare and exchange operations are often used as basic building blocks of lockfree data structures
|code=
#include &lt;atomic&gt;

template&lt;class T&gt;
struct node
{
    T data;
    node* next;
    node(const T&amp; data) : data(data), next(nullptr) {}
};

template&lt;class T&gt;
class stack
{
    std::atomic&lt;node&lt;T&gt;*&gt; head;
 public:
    void push(const T&amp; data)
    {
        node&lt;T&gt;* new_node = new node&lt;T&gt;(data);

        // put the current value of head into new_node-&gt;next
        node&lt;T&gt;* old_head = (new_node-&gt;next = head.load(std::memory_order_relaxed));

        // now make new_node the new head, but if the head
        // is no longer what's stored in new_node-&gt;next
        // (some other thread must have inserted a node just now)
        // then put that new head into new_node-&gt;next and try again
        while(!std::atomic_compare_exchange_weak_explicit( &amp;head
                                                         , &amp;old_head
                                                         , new_node
                                                         , std::memory_order_release
                                                         , std::memory_order_relaxed))
        {
            new_node-&gt;next = old_head;
        }
    }
};

int main()
{
    stack&lt;int&gt; s;
    s.push(1);
    s.push(2);
    s.push(3);
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc compare_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_compare_exchange_weak{{dsc small|(std::shared_ptr)}}
&lt;br&gt;std::atomic_compare_exchange_strong{{dsc small|(std::shared_ptr)}} | specializes atomic operations for std::shared_ptr }}
{{dsc see c | c/atomic/atomic_compare_exchange | atomic_compare_exchange | atomic_compare_exchange_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic compare exchange]]
[[es:cpp/atomic/atomic compare exchange]]
[[fr:cpp/atomic/atomic compare exchange]]
[[it:cpp/atomic/atomic compare exchange]]
[[ja:cpp/atomic/atomic compare exchange]]
[[pt:cpp/atomic/atomic compare exchange]]
[[ru:cpp/atomic/atomic compare exchange]]
[[zh:cpp/atomic/atomic compare exchange]]</text>
      <sha1>t53gloa48rcglzvitp1rk7vju12r84j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic exchange</title>
    <ns>0</ns>
    <id>4723</id>
    <revision>
      <id>66484</id>
      <parentid>65900</parentid>
      <timestamp>2013-11-25T02:31:31Z</timestamp>
      <contributor>
        <ip>83.85.17.177</ip>
      </contributor>
      <text xml:space="preserve" bytes="3153">{{cpp/title|atomic_exchange|atomic_exchange_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
T atomic_exchange( std::atomic&lt;T&gt;* obj, T desr );
}}
{{dcl | 
template&lt; class T &gt;
T atomic_exchange( volatile std::atomic&lt;T&gt;* obj, T desr );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
T atomic_exchange_explicit( std::atomic&lt;T&gt;* obj, T desr, 
                            std::memory_order order );
}}
{{dcl | 
template&lt; class T &gt;
T atomic_exchange_explicit( volatile std::atomic&lt;T&gt;* obj, T desr, 
                            std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

@1@ Atomically replaces the value pointed to by {{tt|obj}} with the value of {{tt|desr}} and returns the value {{tt|obj}} held previously, as if by {{c|obj-&gt;exchange(desr)}}

@2@ Atomically replaces the value pointed to by {{tt|obj}} with the value of {{tt|desr}} and returns the value {{tt|obj}} held previously, as if by {{c|obj-&gt;exchange(desr, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | desr | the value to store in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted.}}
{{par end}} 

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 | A spinlock mutex can be implemented in userspace using an atomic exchange operation, similar to {{c|std::atomic_flag_test_and_set}}:
 | code=
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;atomic&gt;

std::atomic&lt;bool&gt; lock(false); // holds true when locked
                               // holds false when unlocked

void f(int n)
{
    for (int cnt = 0; cnt &lt; 100; ++cnt) {
        while(std::atomic_exchange_explicit(&amp;lock, true, std::memory_order_acquire))
             ; // spin until acquired
        std::cout &lt;&lt; &quot;Output from thread &quot; &lt;&lt; n &lt;&lt; '\n';
        std::atomic_store_explicit(&amp;lock, false, std::memory_order_release);
    }
}
int main()
{
    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; 10; ++n) {
        v.emplace_back(f, n);
    }
    for (auto&amp; t : v) {
        t.join();
    }
}
 | output=
Output from thread 2
Output from thread 6
Output from thread 7
...&lt;exactly 1000 lines&gt;...
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc exchange | mem=std::atomic&lt;T&gt;}}
{{dsc inc | cpp/atomic/dsc atomic_compare_exchange}}
{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_exchange{{dsc small|(std::shared_ptr)}}
&lt;br&gt;std::atomic_exchange_explicit{{dsc small|(std::shared_ptr)}} | specializes atomic operations for {{lc|std::shared_ptr}} }}
{{dsc see c | c/atomic/atomic_exchange | atomic_exchange | atomic_exchange_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic exchange]]
[[es:cpp/atomic/atomic exchange]]
[[fr:cpp/atomic/atomic exchange]]
[[it:cpp/atomic/atomic exchange]]
[[ja:cpp/atomic/atomic exchange]]
[[pt:cpp/atomic/atomic exchange]]
[[ru:cpp/atomic/atomic exchange]]
[[zh:cpp/atomic/atomic exchange]]</text>
      <sha1>m7a7vqpiv2hczoj4h98d70w7dinkb9l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic fetch add</title>
    <ns>0</ns>
    <id>4725</id>
    <revision>
      <id>65609</id>
      <parentid>62665</parentid>
      <timestamp>2013-09-23T18:54:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="5259">{{cpp/title|atomic_fetch_add|atomic_fetch_add_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_add( std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl |
template&lt; class Integral &gt;
Integral atomic_fetch_add( volatile std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_add_explicit( std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_add_explicit( volatile std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order );
}}
{{dcl rev end}}
{{dcl rev begin | num=3 | since=c++11}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_add( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg );
}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_add( volatile std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=4 | since=c++11}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_add_explicit( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg, 
                              std::memory_order order );
}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_add_explicit( volatile std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg, 
                              std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

Performs atomic addition.

@1-2@ Atomically adds {{tt|arg}} to the value pointed to by {{tt|obj}} and returns the value {{tt|obj}} held previously. The operation is performed as if the following was executed:

:@1@ {{c|obj-&gt;fetch_add(arg)}}

:@2@ {{c|obj-&gt;fetch_add(arg, order)}}

@3-4@ Atomically increments the pointer value, pointed to by {{tt|obj}}, by {{tt|arg}}, and returns the value {{tt|obj}} held previously. The operation is performed as if the following was executed:

:@3@ {{c|obj-&gt;fetch_add(arg)}}

:@4@ {{c|obj-&gt;fetch_add(arg, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to add to the value stored in the atomic object}}
{{par | order | the memory sycnhronization ordering for this operation: all values are permitted.}}
{{par end}} 

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &amp;&amp; !std::is_same&lt;T, bool&gt;::value, T&gt;::type
atomic_fetch_add( std::atomic&lt;T&gt;* obj, T arg );
{
    return obj-&gt;fetch_add(arg);
}
 | 2=
template&lt; class T &gt;
T* atomic_fetch_add( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg)
{
    return obj-&gt;fetch_add(arg);
}
}}

===Example===
{{example
 | Single-writer/multiple-reader lock can be made with fetch_add. Note that this simplistic implementation is not lockout-free
 | code=
#include &lt;string&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;atomic&gt;
#include &lt;chrono&gt;
 
// meaning of cnt:
// 10: there are no active readers or writers.
// 1...9: there are 9...1 readers active, The writer is blocked
// 0: temporary value between fetch_sub and fetch_add in reader lock
// -1: there is a writer active. The readers are blocked.
const int N = 10; // nine concurrent readers are allowed
std::atomic&lt;int&gt; cnt = ATOMIC_VAR_INIT(N);

std::vector&lt;int&gt; data;

void reader(int id)
{
    for(;;)
    {
        // lock
        while(std::atomic_fetch_sub(&amp;cnt, 1) &lt;= 0)
            std::atomic_fetch_add(&amp;cnt, 1);
        // read
        if(!data.empty())
            std::cout &lt;&lt; (  &quot;reader &quot; + std::to_string(id)
                          + &quot; sees &quot; + std::to_string(*data.rbegin()) + '\n');
        if(data.size() == 100)
            break;
        // unlock
        std::atomic_fetch_add(&amp;cnt, 1);
        // pause
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}

void writer()
{
    for(int n = 0; n &lt; 100; ++n)
    {
        // lock
        while(std::atomic_fetch_sub(&amp;cnt, N+1) != N)
            std::atomic_fetch_add(&amp;cnt, N+1);
        // write
        data.push_back(n);
        std::cout &lt;&lt; &quot;writer pushed back &quot; &lt;&lt; n &lt;&lt; '\n';
        // unlock
        std::atomic_fetch_add(&amp;cnt, N+1);
        // pause
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
}
 
int main()
{
    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; N; ++n) {
        v.emplace_back(reader, n);
    }
    v.emplace_back(writer);
    for (auto&amp; t : v) {
        t.join();
    }
}
 | output=
writer pushed back 0
reader 8 sees 0
reader 3 sees 0
reader 1 sees 0
&lt;...&gt;
reader 2 sees 99
reader 6 sees 99
reader 1 sees 99
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_add}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_sub}}
{{dsc see c | c/atomic/atomic_fetch_add | atomic_fetch_add | atomic_fetch_add_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic fetch add]]
[[es:cpp/atomic/atomic fetch add]]
[[fr:cpp/atomic/atomic fetch add]]
[[it:cpp/atomic/atomic fetch add]]
[[ja:cpp/atomic/atomic fetch add]]
[[pt:cpp/atomic/atomic fetch add]]
[[ru:cpp/atomic/atomic fetch add]]
[[zh:cpp/atomic/atomic fetch add]]</text>
      <sha1>oxtxx1ptgjl1r82l6dwakqkjz9tbeb4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic fetch and</title>
    <ns>0</ns>
    <id>4729</id>
    <revision>
      <id>65607</id>
      <parentid>62666</parentid>
      <timestamp>2013-09-23T18:52:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2565">{{cpp/title|atomic_fetch_and|atomic_fetch_and_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_and( std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_and( volatile std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_and_explicit( std::atomic&lt;Integral&gt;* obj, 
                                    Integral arg, 
                                    std::memory_order order);
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_and_explicit( volatile std::atomic&lt;Integral&gt;* obj, 
                                    Integral arg, 
                                    std::memory_order order);
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|arg}} with the result of bitwise AND between the old value of {{tt|obj}} and {{tt|arg}}. Returns the value {{tt|obj}} held previously. 

The operation is performed as if the following is executed:

@1@ {{c|obj-&gt;fetch_and(arg)}}

@2@ {{c|obj-&gt;fetch_and(arg, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify. bool is not an Integral type for the purposes of the atomic operations.}}
{{par | arg | the value to bitwise AND to the value stored in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: all values are permitted.}}
{{par end}}

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &amp;&amp; !std::is_same&lt;T, bool&gt;::value, T&gt;::type
    atomic_fetch_and(std::atomic&lt;T&gt;* obj, T arg);
{
    return obj-&gt;fetch_and(arg);
}
}}

===Example===
{{include|cpp/atomic/atomic_fetch_cond_example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_and}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_or}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_xor}}
{{dsc see c | c/atomic/atomic_fetch_and | atomic_fetch_and | atomic_fetch_and_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic fetch and]]
[[es:cpp/atomic/atomic fetch and]]
[[fr:cpp/atomic/atomic fetch and]]
[[it:cpp/atomic/atomic fetch and]]
[[ja:cpp/atomic/atomic fetch and]]
[[pt:cpp/atomic/atomic fetch and]]
[[ru:cpp/atomic/atomic fetch and]]
[[zh:cpp/atomic/atomic fetch and]]</text>
      <sha1>s21m5svijpw7mcteq3wkvxi0d37w8on</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic fetch or</title>
    <ns>0</ns>
    <id>4731</id>
    <revision>
      <id>65606</id>
      <parentid>62667</parentid>
      <timestamp>2013-09-23T18:52:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2465">{{cpp/title|atomic_fetch_or|atomic_fetch_or_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_or( std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_or( volatile std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_or_explicit( std::atomic&lt;Integral&gt;* obj,
                                   Integral arg, 
                                   std::memory_order order );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_or_explicit( volatile std::atomic&lt;Integral&gt;* obj, 
                                   Integral arg, 
                                   std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|arg}} with the result of bitwise OR between the old value of {{tt|obj}} and {{tt|arg}}. Returns the value {{tt|obj}} held previously. 

The operation is performed as if the following is executed:

@1@ {{c|obj-&gt;fetch_or(arg)}}

@2@ {{c|obj-&gt;fetch_or(arg, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to bitwise OR to the value stored in the atomic object}}
{{par | order | the memory sycnhronization ordering for this operation: all values are permitted.}}
{{par end}} 

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &amp;&amp; !std::is_same&lt;T, bool&gt;::value, T&gt;::type
atomic_fetch_or( std::atomic&lt;T&gt;* obj, T arg );
{
    return obj-&gt;fetch_or(arg);
}
}}

===Example===
{{include|cpp/atomic/atomic_fetch_cond_example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_or}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_and}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_xor}}
{{dsc see c | c/atomic/atomic_fetch_or | atomic_fetch_or | atomic_fetch_or_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic fetch or]]
[[es:cpp/atomic/atomic fetch or]]
[[fr:cpp/atomic/atomic fetch or]]
[[it:cpp/atomic/atomic fetch or]]
[[ja:cpp/atomic/atomic fetch or]]
[[pt:cpp/atomic/atomic fetch or]]
[[ru:cpp/atomic/atomic fetch or]]
[[zh:cpp/atomic/atomic fetch or]]</text>
      <sha1>119ws8xhtk1yxpys92kg3c1dq4d81ey</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic fetch sub</title>
    <ns>0</ns>
    <id>4727</id>
    <revision>
      <id>65610</id>
      <parentid>65608</parentid>
      <timestamp>2013-09-23T18:55:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>oops</comment>
      <text xml:space="preserve" bytes="4500">{{cpp/title|atomic_fetch_sub|atomic_fetch_sub_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_sub( std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_sub( volatile std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_sub_explicit( std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_sub_explicit( volatile std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order);
}}
{{dcl rev end}}
{{dcl rev begin | num=3 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
T* atomic_fetch_sub( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg );
}}
{{dcl | 
template&lt; class T &gt;
T* atomic_fetch_sub( volatile std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=4 | since=c++11}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_sub_explicit( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg, 
                              std::memory_order order );
}}
{{dcl |
template&lt; class T &gt;
T* atomic_fetch_sub_explicit( volatile std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg, 
                              std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

Performs atomic subtraction.

@1-2@ Atomically subtracts {{tt|arg}} from the value pointed to by {{tt|obj}} and returns the value {{tt|obj}} held previously. The operation is performed as if the following was executed:

:@1@ {{c|obj-&gt;fetch_sub(arg)}}

:@2@ {{c|obj-&gt;fetch_sub(arg, order)}}

@3-4@ Atomically decrements the pointer value, pointed to by {{tt|obj}}, by {{tt|arg}}, and returns the value {{tt|obj}} held previously. The operation is performed as if the following was executed:

:@3@ {{c|obj-&gt;fetch_sub(arg)}}

:@4@ {{c|obj-&gt;fetch_sub(arg, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to subtract from the value stored in the atomic object}}
{{par | order | the memory sycnhronization ordering for this operation: all values are permitted.}}
{{par end}} 

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &amp;&amp; !std::is_same&lt;T, bool&gt;::value, T&gt;::type
atomic_fetch_sub( std::atomic&lt;T&gt;* obj, T arg );
{
    return obj-&gt;fetch_sub(arg);
}
 | 2=
template&lt; class T &gt;
T* atomic_fetch_sub( std::atomic&lt;T*&gt;* obj, std::ptrdiff_t arg)
{
    return obj-&gt;fetch_sub(arg);
}
}}

===Example===
{{example
 | Multiple threads may use {{tt|fetch_sub}} to concurrently process an indexed container
 | code=
#include &lt;string&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;atomic&gt;
#include &lt;numeric&gt;

const int N = 10000;
std::atomic&lt;int&gt; cnt;
std::vector&lt;int&gt; data(N);

void reader(int id) 
{
    for (;;) {
        int idx = atomic_fetch_sub_explicit(&amp;cnt, 1, std::memory_order_relaxed);
        if (idx &gt;= 0) {
            std::cout &lt;&lt; &quot;reader &quot; &lt;&lt; std::to_string(id) &lt;&lt; &quot; processed item &quot;
                      &lt;&lt; std::to_string(data[idx]) &lt;&lt; '\n';
        } else {
            std::cout &lt;&lt; &quot;reader &quot; &lt;&lt; std::to_string(id) &lt;&lt; &quot; done\n&quot;;
            break;
        }
    }
}

int main()
{
    std::iota(data.begin(), data.end(), 1);
    cnt = data.size() - 1;

    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; 10; ++n) {
        v.emplace_back(reader, n);
    }
    for (auto&amp; t : v) {
        t.join();
    }
}
 | output=
reader 2 processed item 10000
reader 6 processed item 9994
reader 4 processed item 9996
reader 6 processed item 9992
&lt;....&gt;
reader 0 done
reader 5 done
reader 3 done
reader 9 done
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_sub | mem=std::atomic&lt;T&gt;}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_add}}
{{dsc see c | c/atomic/atomic_fetch_sub | atomic_fetch_sub | atomic_fetch_sub_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic fetch sub]]
[[es:cpp/atomic/atomic fetch sub]]
[[fr:cpp/atomic/atomic fetch sub]]
[[it:cpp/atomic/atomic fetch sub]]
[[ja:cpp/atomic/atomic fetch sub]]
[[pt:cpp/atomic/atomic fetch sub]]
[[ru:cpp/atomic/atomic fetch sub]]
[[zh:cpp/atomic/atomic fetch sub]]</text>
      <sha1>qaruvoue33aonn5znsducdju8diu14l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic fetch xor</title>
    <ns>0</ns>
    <id>4733</id>
    <revision>
      <id>65605</id>
      <parentid>62669</parentid>
      <timestamp>2013-09-23T18:51:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2427">{{cpp/title|atomic_fetch_xor|atomic_fetch_xor_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_xor( std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_xor( volatile std::atomic&lt;Integral&gt;* obj, Integral arg );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_xor_explicit( std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order );
}}
{{dcl | 
template&lt; class Integral &gt;
Integral atomic_fetch_xor_explicit( volatile std::atomic&lt;Integral&gt;* obj, Integral arg, 
                                    std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

Atomically replaces the value pointed by {{tt|arg}} with the result of bitwise XOR between the old value of {{tt|obj}} and {{tt|arg}}. Returns the value {{tt|obj}} held previously. 

The operation is performed as if the following is executed:

@1@ {{c|obj-&gt;fetch_xor(arg)}}

@2@ {{c|obj-&gt;fetch_xor(arg, order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | arg | the value to bitwise XOR to the value stored in the atomic object}}
{{par | order | the memory sycnhronization ordering for this operation: all values are permitted.}}
{{par end}} 

===Return value===
The value held previously by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &amp;&amp; !std::is_same&lt;T, bool&gt;::value, T&gt;::type
atomic_fetch_xor( std::atomic&lt;T&gt;* obj, T arg );
{
    return obj-&gt;fetch_xor(arg);
}
}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc fetch_xor | mem=std::atomic&lt;T&gt;}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_or}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_and}}
{{dsc see c | c/atomic/atomic_fetch_xor | atomic_fetch_xor | atomic_fetch_xor_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic fetch xor]]
[[es:cpp/atomic/atomic fetch xor]]
[[fr:cpp/atomic/atomic fetch xor]]
[[it:cpp/atomic/atomic fetch xor]]
[[ja:cpp/atomic/atomic fetch xor]]
[[pt:cpp/atomic/atomic fetch xor]]
[[ru:cpp/atomic/atomic fetch xor]]
[[zh:cpp/atomic/atomic fetch xor]]</text>
      <sha1>bxkhe665jn5v36zp5nihgqim3b0teag</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag</title>
    <ns>0</ns>
    <id>2790</id>
    <revision>
      <id>62670</id>
      <parentid>57140</parentid>
      <timestamp>2013-07-01T23:32:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1976">{{cpp/title | atomic_flag}}
{{cpp/atomic/atomic_flag/navbar}}
{{dcl begin}}
{{dcl header | atomic}}
{{dcl | since=c++11 | 1=
class atomic_flag;
}}
{{dcl end}}

{{lc|std::atomic_flag}} is an atomic boolean type. Unlike all specializations of {{lc|std::atomic}}, it is guaranteed to be lock-free. Unlike {{c|std::atomic&lt;bool&gt;}}, {{tt|std::atomic_flag}} does not provide load or store operations.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/atomic/atomic_flag/atomic_flag   | constructs an atomic_flag }}
{{dsc mem fun  | cpp/atomic/atomic_flag/operator{{=}} | the assignment operator }}
{{dsc inc | cpp/atomic/atomic_flag/dsc clear}}
{{dsc inc | cpp/atomic/atomic_flag/dsc test_and_set}}
{{dsc end}}

===Example===
{{example
 | A spinlock mutex can be implemented in userspace using an atomic_flag
 | code=
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;atomic&gt;

std::atomic_flag lock = ATOMIC_FLAG_INIT;

void f(int n)
{
    for (int cnt = 0; cnt &lt; 100; ++cnt) {
        while (lock.test_and_set(std::memory_order_acquire))  // acquire lock
             ; // spin
        std::cout &lt;&lt; &quot;Output from thread &quot; &lt;&lt; n &lt;&lt; '\n';
        lock.clear(std::memory_order_release);               // release lock
    }
}

int main()
{
    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; 10; ++n) {
        v.emplace_back(f, n);
    }
    for (auto&amp; t : v) {
        t.join();
    }
}
 | output=
Output from thread 2
Output from thread 6
Output from thread 7
...&lt;exactly 1000 lines&gt;...
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | cpp/atomic/dsc atomic_flag_clear}}
{{dsc inc | cpp/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc see c | c/atomic/atomic_flag}}
{{dsc end}}

[[de:cpp/atomic/atomic flag]]
[[es:cpp/atomic/atomic flag]]
[[fr:cpp/atomic/atomic flag]]
[[it:cpp/atomic/atomic flag]]
[[ja:cpp/atomic/atomic flag]]
[[pt:cpp/atomic/atomic flag]]
[[ru:cpp/atomic/atomic flag]]
[[zh:cpp/atomic/atomic flag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag/atomic flag</title>
    <ns>0</ns>
    <id>2816</id>
    <revision>
      <id>68873</id>
      <parentid>62671</parentid>
      <timestamp>2014-03-22T20:53:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-stray parameters clause</comment>
      <text xml:space="preserve" bytes="1214">{{cpp/atomic/atomic_flag/title | atomic_flag}}
{{cpp/atomic/atomic_flag/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | num=1 | since=c++11 | 1=
atomic_flag();
}}
{{dcl | num=2 | since=c++11 | 1=
atomic_flag( const atomic_flag&amp; ) = delete;
}}
{{dcl end}}

Constructs a new {{lc|std::atomic_flag}}. 

1) Trivial default constructor, initializes {{lc|std::atomic_flag}} to unspecified state.

2) The copy constructor is deleted; {{lc|std::atomic_flag}} is not copyable.

In addition, {{lc|std::atomic_flag}} can be value-initialized to clear state with the expression {{lc|ATOMIC_FLAG_INIT}}. For an atomic_flag with static storage duration, this guarantees that the values of this flag is known before any constructors are run for static objects.

===Exceptions===
@1@ {{noexcept}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc end}}

[[de:cpp/atomic/atomic flag/atomic flag]]
[[es:cpp/atomic/atomic flag/atomic flag]]
[[fr:cpp/atomic/atomic flag/atomic flag]]
[[it:cpp/atomic/atomic flag/atomic flag]]
[[ja:cpp/atomic/atomic flag/atomic flag]]
[[pt:cpp/atomic/atomic flag/atomic flag]]
[[ru:cpp/atomic/atomic flag/atomic flag]]
[[zh:cpp/atomic/atomic flag/atomic flag]]</text>
      <sha1>7x9q2vhijvvvwxn4lkfnrmi194ek34l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag/clear</title>
    <ns>0</ns>
    <id>2830</id>
    <revision>
      <id>64458</id>
      <parentid>62672</parentid>
      <timestamp>2013-08-17T23:39:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>limitations on allowed ordering</comment>
      <text xml:space="preserve" bytes="1166">{{cpp/atomic/atomic_flag/title | clear}}
{{cpp/atomic/atomic_flag/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | num=1 | since=c++11 | 1=
void clear( std::memory_order order = std::memory_order_seq_cst ) volatile;
}}
{{dcl | num=2 | since=c++11 | 1=
void clear( std::memory_order order = std::memory_order_seq_cst );
}}
{{dcl end}}

Atomically changes the state of a {{lc|std::atomic_flag}} to clear ({{c|false}}). 

===Parameters===

{{par begin}}
{{par | order | the memory sycnhronization ordering for this operation (cannot be {{lc|std::memory_order_consume}}, {{lc|std::memory_order_acquire}}, or {{lc|std::memory_order_acq_rel}}) }}
{{par end}} 

===Exceptions===
{{noexcept}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/atomic/atomic_flag/dsc test_and_set}}
{{dsc inc | cpp/atomic/dsc atomic_flag_clear}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc end}}

[[de:cpp/atomic/atomic flag/clear]]
[[es:cpp/atomic/atomic flag/clear]]
[[fr:cpp/atomic/atomic flag/clear]]
[[it:cpp/atomic/atomic flag/clear]]
[[ja:cpp/atomic/atomic flag/clear]]
[[pt:cpp/atomic/atomic flag/clear]]
[[ru:cpp/atomic/atomic flag/clear]]
[[zh:cpp/atomic/atomic flag/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag/operator=</title>
    <ns>0</ns>
    <id>2819</id>
    <revision>
      <id>62673</id>
      <parentid>49335</parentid>
      <timestamp>2013-07-01T23:32:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="727">{{cpp/atomic/atomic_flag/title | operator{{=}}}}
{{cpp/atomic/atomic_flag/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | num=1 | since=c++11 | 1=
atomic_flag&amp; operator=( const atomic_flag&amp; ) = delete;
}}
{{dcl | num=2 | since=c++11 | 1=
atomic_flag&amp; operator=( const atomic_flag&amp; ) volatile = delete;
}}
{{dcl end}}

{{lc|std::atomic_flag}} is not assignable, its assignment operators are deleted.

[[de:cpp/atomic/atomic flag/operator=]]
[[es:cpp/atomic/atomic flag/operator=]]
[[fr:cpp/atomic/atomic flag/operator=]]
[[it:cpp/atomic/atomic flag/operator=]]
[[ja:cpp/atomic/atomic flag/operator=]]
[[pt:cpp/atomic/atomic flag/operator=]]
[[ru:cpp/atomic/atomic flag/operator=]]
[[zh:cpp/atomic/atomic flag/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag/test and set</title>
    <ns>0</ns>
    <id>2831</id>
    <revision>
      <id>65669</id>
      <parentid>62674</parentid>
      <timestamp>2013-09-24T23:11:43Z</timestamp>
      <contributor>
        <ip>8.31.246.162</ip>
      </contributor>
      <text xml:space="preserve" bytes="1157">{{cpp/atomic/atomic_flag/title | test_and_set}}
{{cpp/atomic/atomic_flag/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | num=1 | since=c++11 | 1=
bool test_and_set(std::memory_order order = std::memory_order_seq_cst) volatile;
}}
{{dcl | num=2 | since=c++11 | 1=
bool test_and_set(std::memory_order order = std::memory_order_seq_cst);
}}
{{dcl end}}

Atomically changes the state of a {{lc|std::atomic_flag}} to set ({{c|true}}) and returns the value it held before. 

===Parameters===

{{par begin}}
{{par | order | the memory synchronization ordering for this operation }}
{{par end}} 

===Exceptions===
{{noexcept}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/atomic/atomic_flag/dsc clear}}
{{dsc inc | cpp/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc end}}

[[de:cpp/atomic/atomic flag/test and set]]
[[es:cpp/atomic/atomic flag/test and set]]
[[fr:cpp/atomic/atomic flag/test and set]]
[[it:cpp/atomic/atomic flag/test and set]]
[[ja:cpp/atomic/atomic flag/test and set]]
[[pt:cpp/atomic/atomic flag/test and set]]
[[ru:cpp/atomic/atomic flag/test and set]]
[[zh:cpp/atomic/atomic flag/test and set]]</text>
      <sha1>5cr6210s3zfqm4nhvp3iwu8slr1ly2c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag clear</title>
    <ns>0</ns>
    <id>2833</id>
    <revision>
      <id>65603</id>
      <parentid>64459</parentid>
      <timestamp>2013-09-23T18:50:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2149">{{cpp/title | atomic_flag_clear|atomic_flag_clear_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
void atomic_flag_clear( volatile std::atomic_flag* p );
}}
{{dcl | 
void atomic_flag_clear( std::atomic_flag* p );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
void atomic_flag_clear_explicit( volatile std::atomic_flag* p, 
                                 std::memory_order order )
}}
{{dcl | 
void atomic_flag_clear_explicit( std::atomic_flag* p, 
                                 std::memory_order order )
}}
{{dcl rev end}}
{{dcl end}}

Atomically changes the state of a {{lc|std::atomic_flag}} pointed to by {{tt|p}} to clear ({{c|false}}). 

===Parameters===
{{par begin}}
{{par | p | pointer to {{lc|std::atomic_flag}} to access}}
{{par | order | the memory sycnhronization ordering for this operation: only {{lc|std::memory_order_relaxed}}, {{lc|std::memory_order_acquire}}, or {{lc|std::memory_order_seq_cst}} are permitted. }}
{{par end}} 

===Return value===
none.

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
void atomic_flag_clear(volatile std::atomic_flag* p) 
{
    p-&gt;clear();
}
 | 2=
void atomic_flag_clear(std::atomic_flag* p) 
{
    p-&gt;clear();
}
 | 3=
void atomic_flag_clear_explicit(volatile std::atomic_flag* p, 
                                std::memory_order order) 
{
    p-&gt;clear(order);
}
 | 4=
void atomic_flag_clear_explicit(std::atomic_flag* p, 
                                std::memory_order order) 
{
    p-&gt;clear(order);
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc inc | cpp/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc see c | c/atomic/atomic_flag_clear | atomic_flag_clear | atomic_flag_clear_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic flag clear]]
[[es:cpp/atomic/atomic flag clear]]
[[fr:cpp/atomic/atomic flag clear]]
[[it:cpp/atomic/atomic flag clear]]
[[ja:cpp/atomic/atomic flag clear]]
[[pt:cpp/atomic/atomic flag clear]]
[[ru:cpp/atomic/atomic flag clear]]
[[zh:cpp/atomic/atomic flag clear]]</text>
      <sha1>bd933pql91a9j3f7d8kjdodh93yf02x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic flag test and set</title>
    <ns>0</ns>
    <id>2832</id>
    <revision>
      <id>65604</id>
      <parentid>62676</parentid>
      <timestamp>2013-09-23T18:51:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="3165">{{cpp/title | atomic_flag_test_and_set|atomic_flag_test_and_set_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
bool atomic_flag_test_and_set( volatile std::atomic_flag* p );
}}
{{dcl | 
bool atomic_flag_test_and_set( std::atomic_flag* p );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
bool atomic_flag_test_and_set_explicit( volatile std::atomic_flag* p, 
                                        std::memory_order order );
}}
{{dcl | 
bool atomic_flag_test_and_set_explicit( std::atomic_flag* p, 
                                        std::memory_order order );
}}
{{dcl rev end}}
{{dcl end}}

Atomically changes the state of a {{lc|std::atomic_flag}} pointed to by {{tt|p}} to set ({{c|true}}) and returns the value it held before. 

===Parameters===
{{par begin}}
{{par | p | pointer to {{lc|std::atomic_flag}} to access}}
{{par | order | the memory synchronization order for this operation }}
{{par end}} 

===Return value===
The value previously held by the flag pointed to by {{tt|p}}

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
bool atomic_flag_test_and_set(volatile std::atomic_flag* p)
{
    return p-&gt;test_and_set();
}
 | 2=
bool atomic_flag_test_and_set(std::atomic_flag* p)
{
    return p-&gt;test_and_set();
}
 | 3=
bool atomic_flag_test_and_set_explicit(volatile std::atomic_flag* p, 
                                       std::memory_order order)
{
    return p-&gt;test_and_set(order);
}
 | 4=
bool atomic_flag_test_and_set_explicit(std::atomic_flag* p, 
                                       std::memory_order order) 
{
    return p-&gt;test_and_set(order);
}
}}

===Example===
{{example
 | A spinlock mutex can be implemented in userspace using an atomic_flag
 | code=
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;atomic&gt;

std::atomic_flag lock = ATOMIC_FLAG_INIT;

void f(int n)
{
    for (int cnt = 0; cnt &lt; 100; ++cnt) {
        while(std::atomic_flag_test_and_set_explicit(&amp;lock, std::memory_order_acquire))
             ; // spin until the lock is acquired
        std::cout &lt;&lt; &quot;Output from thread &quot; &lt;&lt; n &lt;&lt; '\n';
        std::atomic_flag_clear_explicit(&amp;lock, std::memory_order_release);
    }
}

int main()
{
    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; 10; ++n) {
        v.emplace_back(f, n);
    }
    for (auto&amp; t : v) {
        t.join();
    }
}
 | output=
Output from thread 2
Output from thread 6
Output from thread 7
...&lt;exactly 1000 lines&gt;...
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc inc | cpp/atomic/dsc atomic_flag_clear}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc see c | c/atomic/atomic_flag_test_and_set | atomic_flag_test_and_set | atomic_flag_test_and_set_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic flag test and set]]
[[es:cpp/atomic/atomic flag test and set]]
[[fr:cpp/atomic/atomic flag test and set]]
[[it:cpp/atomic/atomic flag test and set]]
[[ja:cpp/atomic/atomic flag test and set]]
[[pt:cpp/atomic/atomic flag test and set]]
[[ru:cpp/atomic/atomic flag test and set]]
[[zh:cpp/atomic/atomic flag test and set]]</text>
      <sha1>1quvynicsdkkk485paaxatqeub334zg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic init</title>
    <ns>0</ns>
    <id>9223</id>
    <revision>
      <id>64888</id>
      <parentid>57152</parentid>
      <timestamp>2013-08-27T01:45:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=</comment>
      <text xml:space="preserve" bytes="1539">{{cpp/title|atomic_init}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic}}
{{dcl | since=c++11 |
template&lt; class T &gt;
void atomic_init( std::atomic&lt;T&gt;* obj, T desired );
}}
{{dcl | since=c++11 |
template&lt; class T &gt;
void atomic_init( volatile std::atomic&lt;T&gt;* obj, T desired );
}}
{{dcl end}}

Initializes the default-constructed atomic object {{tt|object}} with the value {{tt|desired}}. The function is not atomic: concurrent access from another thread, even through an atomic operation, is a data race. 

If {{tt|obj}} was not default-constructed, the behavior is undefined.

If this function is called twice on the same {{tt|obj}}, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | obj | pointer to an atomic object to initialize}}
{{par | desired | the value to initialize atomic object with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Notes===
This function is provided for compatibility with C. If the compatibility is not required, {{lc|std::atomic}} may be initialized through their non-default constructors.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc inc | cpp/atomic/atomic/dsc constructor}}
{{dsc see c | c/atomic/atomic_init}}
{{dsc end}}

[[de:cpp/atomic/atomic init]]
[[es:cpp/atomic/atomic init]]
[[fr:cpp/atomic/atomic init]]
[[it:cpp/atomic/atomic init]]
[[ja:cpp/atomic/atomic init]]
[[pt:cpp/atomic/atomic init]]
[[ru:cpp/atomic/atomic init]]
[[zh:cpp/atomic/atomic init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic is lock free</title>
    <ns>0</ns>
    <id>6729</id>
    <revision>
      <id>65602</id>
      <parentid>64447</parentid>
      <timestamp>2013-09-23T18:49:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2722">{{title|{{dsc small|std::}}atomic_is_lock_free, ATOMIC_xxx_LOCK_FREE}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 1=
template&lt; class Atomic &gt;
bool atomic_is_lock_free( const volatile Atomic* obj )
}}
{{dcl | 1=
template&lt; class Atomic &gt;
bool atomic_is_lock_free( const Atomic* obj )
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 | 1=
#define ATOMIC_CHAR_LOCK_FREE     /* unspecified */
#define ATOMIC_CHAR16_T_LOCK_FREE /* unspecified */
#define ATOMIC_CHAR32_T_LOCK_FREE /* unspecified */
#define ATOMIC_WCHAR_T_LOCK_FREE  /* unspecified */
#define ATOMIC_SHORT_LOCK_FREE    /* unspecified */
#define ATOMIC_INT_LOCK_FREE      /* unspecified */
#define ATOMIC_LONG_LOCK_FREE     /* unspecified */
#define ATOMIC_LLONG_LOCK_FREE    /* unspecified */
#define ATOMIC_POINTER_LOCK_FREE  /* unspecified */
}}
{{dcl end}}

@1@ Determines if the atomic object pointed to by {{tt|obj}} is implemented lock-free, as if by calling {{c|obj-&gt;is_lock_free()}}

@2@ Expands to an integer constant expression with value {{c|0}} for the built-in atomic types that are never lock-free, to {{c|1}} for the built-in atomic types that are sometimes lock-free, and to {{c|2}} for the built-in atomic types that are always lock-free.

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to examine}}
{{par end}} 

===Return value===
{{c|true}} if {{c|*obj}} is a lock-free atomic, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Notes===
All atomic types except for {{lc|std::atomic_flag}} may be implemented using mutexes or other locking operations, rather than using the lock-free atomic CPU instructions. Atomic types are also allowed to be ''sometimes'' lock-free, e.g. if only aligned memory accesses are naturally atomic on a given architecture, misaligned objects of the same type have to use locks. If the type is sometimes lock-free, then the function (1) or its member function equivalent has to be used to determine if the particular instance is lock-free.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc is_lock_free | mem=std::atomic&lt;T&gt;}}
{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_is_lock_free{{dsc small|(std::shared_ptr)}} | specializes atomic operations for {{lc|std::shared_ptr}} }}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc end}}

[[de:cpp/atomic/atomic is lock free]]
[[es:cpp/atomic/atomic is lock free]]
[[fr:cpp/atomic/atomic is lock free]]
[[it:cpp/atomic/atomic is lock free]]
[[ja:cpp/atomic/atomic is lock free]]
[[pt:cpp/atomic/atomic is lock free]]
[[ru:cpp/atomic/atomic is lock free]]
[[zh:cpp/atomic/atomic is lock free]]</text>
      <sha1>fwqc2bdt78lpierle9kpwcmuj2vewnv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic load</title>
    <ns>0</ns>
    <id>4720</id>
    <revision>
      <id>67615</id>
      <parentid>67613</parentid>
      <timestamp>2014-02-13T15:23:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 67613 by [[Special:Contributions/216.239.45.67|216.239.45.67]] ([[User talk:216.239.45.67|talk]]) - noexcepts are listed lower at the page (although it's a fairly common complaint)</comment>
      <text xml:space="preserve" bytes="2018">{{cpp/title|atomic_load|atomic_load_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
T atomic_load( const std::atomic&lt;T&gt;* obj );
}}
{{dcl | 
template&lt; class T &gt;
T atomic_load( const volatile std::atomic&lt;T&gt;* obj );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
T atomic_load_explicit( const std::atomic&lt;T&gt;* obj, 
                        std::memory_order order );
}}
{{dcl | 
template&lt; class T &gt;
T atomic_load_explicit( const volatile std::atomic&lt;T&gt;* obj, 
                        std::memory_order order );
}}
{{dcl rev end}}

{{dcl end}}

@1@ Atomically obtains the value pointed to by {{tt|obj}} as if by {{c|obj-&gt;load()}}

@2@ Atomically obtains the value pointed to by {{tt|obj}} as if by {{c|obj-&gt;load(order)}}

===Parameters===
{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | order | the memory sycnhronization ordering for this operation: only {{lc|std::memory_order_relaxed}}, {{lc|std::memory_order_consume}}, {{lc|std::memory_order_acquire}} and {{lc|std::memory_order_seq_cst}} are permitted.}}
{{par end}} 

===Return value===
The value that is held by the atomic object pointed to by {{tt|obj}}

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc load | mem=std::atomic&lt;T&gt;}}
{{dsc inc | cpp/atomic/dsc atomic_store}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_load{{dsc small|(std::shared_ptr)}}
&lt;br&gt;std::atomic_load_explicit{{dsc small|(std::shared_ptr)}} | specializes atomic operations for std::shared_ptr }}
{{dsc see c | c/atomic/atomic_load | atomic_load | atomic_load_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic load]]
[[es:cpp/atomic/atomic load]]
[[fr:cpp/atomic/atomic load]]
[[it:cpp/atomic/atomic load]]
[[ja:cpp/atomic/atomic load]]
[[pt:cpp/atomic/atomic load]]
[[ru:cpp/atomic/atomic load]]
[[zh:cpp/atomic/atomic load]]</text>
      <sha1>ry9ocp6pls0vvql980mf91iufuabce2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic signal fence</title>
    <ns>0</ns>
    <id>2970</id>
    <revision>
      <id>62679</id>
      <parentid>57157</parentid>
      <timestamp>2013-07-01T23:32:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1470">{{cpp/title | atomic_signal_fence }}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | since=c++11 | 1=
extern &quot;C&quot; void atomic_signal_fence( std::memory_order order );
}}
{{dcl end}}

Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by {{tt|order}}, between a thread and a signal handler executed on the same thread. This is equivalent to {{lc|std::atomic_thread_fence}}, except no CPU instructions for memory ordering are issued. Only reordering of the instructions by the compiler is suppressed as {{tt|order}} instructs. For example, writes cannot be moved past a fence with release semantics and reads cannot be moved ahead of a fence with acquire semantics.

===Parameters===
{{par begin}}
{{par | order | the memory ordering executed by this fence}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example}} &lt;!-- adapt from http://stackoverflow.com/a/14594071/273767 --&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc inc | cpp/atomic/dsc atomic_thread_fence}}
{{dsc see c | c/atomic/atomic_signal_fence}}
{{dsc end}}

[[de:cpp/atomic/atomic signal fence]]
[[es:cpp/atomic/atomic signal fence]]
[[fr:cpp/atomic/atomic signal fence]]
[[it:cpp/atomic/atomic signal fence]]
[[ja:cpp/atomic/atomic signal fence]]
[[pt:cpp/atomic/atomic signal fence]]
[[ru:cpp/atomic/atomic signal fence]]
[[zh:cpp/atomic/atomic signal fence]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic store</title>
    <ns>0</ns>
    <id>4707</id>
    <revision>
      <id>67616</id>
      <parentid>67614</parentid>
      <timestamp>2014-02-13T15:24:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 67614 by [[Special:Contributions/216.239.45.67|216.239.45.67]] ([[User talk:216.239.45.67|talk]]) noexcepts are listed at the bottom of the page (although it is a fairly common complaint)</comment>
      <text xml:space="preserve" bytes="2104">{{cpp/title|atomic_store|atomic_store_explicit}}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl rev begin | num=1 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
void atomic_store( std::atomic&lt;T&gt;* obj, T desr );
}}
{{dcl | 
template&lt; class T &gt;
void atomic_store( volatile std::atomic&lt;T&gt;* obj, T desr );
}}
{{dcl rev end}}
{{dcl rev begin | num=2 | since=c++11}}
{{dcl | 
template&lt; class T &gt;
void atomic_store_explicit( std::atomic&lt;T&gt;* obj, T desr, 
                            std::memory_order order);
}}
{{dcl | 
template&lt; class T &gt;
void atomic_store_explicit( volatile std::atomic&lt;T&gt;* obj, T desr, 
                            std::memory_order order);
}}
{{dcl rev end}}
{{dcl end}}

@1@ Atomically replaces the value pointed to by {{tt|obj}} with the value of {{tt|desr}} as if by {{c|obj-&gt;store(desr)}}

@2@ Atomically replaces the value pointed to by {{tt|obj}} with the value of {{tt|desr}} as if by {{c|obj-&gt;store(desr, order)}}

===Parameters===

{{par begin}}
{{par | obj | pointer to the atomic object to modify}}
{{par | desr | the value to store in the atomic object}}
{{par | order | the memory synchronization ordering for this operation: only {{lc|std::memory_order_relaxed}}, {{lc|std::memory_order_release}} and {{lc|std::memory_order_seq_cst}} are permitted.}}
{{par end}} 

===Return value===
none.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/atomic/dsc store | mem=std::atomic&lt;T&gt;}}
{{dsc inc | cpp/atomic/dsc atomic_load}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_store{{dsc small|(std::shared_ptr)}}
&lt;br&gt;std::atomic_store_explicit{{dsc small|(std::shared_ptr)}} | specializes atomic operations for {{lc|std::shared_ptr}} }}
{{dsc see c | c/atomic/atomic_store | atomic_store | atomic_store_explicit}}
{{dsc end}}

[[de:cpp/atomic/atomic store]]
[[es:cpp/atomic/atomic store]]
[[fr:cpp/atomic/atomic store]]
[[it:cpp/atomic/atomic store]]
[[ja:cpp/atomic/atomic store]]
[[pt:cpp/atomic/atomic store]]
[[ru:cpp/atomic/atomic store]]
[[zh:cpp/atomic/atomic store]]</text>
      <sha1>817g52vk9ekemt55pcx7sx96vce22h7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/atomic thread fence</title>
    <ns>0</ns>
    <id>2969</id>
    <revision>
      <id>72099</id>
      <parentid>66504</parentid>
      <timestamp>2014-07-14T19:42:43Z</timestamp>
      <contributor>
        <ip>95.114.29.91</ip>
      </contributor>
      <comment>fences don't synchronize without an atomic load/store pair</comment>
      <text xml:space="preserve" bytes="2891">{{cpp/title | atomic_thread_fence }}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | since=c++11 | 1=
extern &quot;C&quot; void atomic_thread_fence( std::memory_order order );
}}
{{dcl end}}

Establishes memory synchronization ordering of non-atomic and relaxed atomic accesses, as instructed by {{tt|order}}, without an associated atomic operation. For example, all non-atomic and relaxed atomic stores that happen before a {{lc|std::memory_order_release}} fence in thread A will be synchronized with non-atomic and relaxed atomic loads from the same locations made in thread B after an {{lc|std::memory_order_acquire}} fence if there exist atomic operations X and Y, both
operating on some atomic object M, such that the fence in thread A is sequenced before X, X modifies M, Y is sequenced
before the fence in thread B, and Y reads the value written by X or a value written by any side effect in the hypothetical
release sequence X would head if it were a release operation..

===Parameters===
{{par begin}}
{{par | order | the memory ordering executed by this fence}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Notes===
{{tt|atomic_thread_fence}} imposes different synchronization constraints than an atomic store operation with the same {{lc|std::memory_order}}. While an atomic store-release operation prevents all preceding writes from moving past the store-release, an {{tt|atomic_thread_fence}} with {{tt|memory_order_release}} ordering prevents all preceding writes from moving past all subsequent stores.

===Examples===
{{example
 | Scan an array of mailboxes, and process only the ones intended for us, without unnecessary synchronization. 
 | code=
const int num_mailboxes = 32;
std::atomic&lt;int&gt; mailbox[num_mailboxes];

// The writer threads update non-atomic shared data and then update mailbox[i] as follows
 std::atomic_store_explicit(&amp;mailbox[i], std::memory_order_release);

// Reader thread needs to check all mailbox[i], but only needs to sync with one
 for (int i = 0; i &lt; num_mailboxes; ++i) {
    if (std::atomic_load_explicit(&amp;mailbox[i],  std::memory_order_relaxed) == my_id) {
        std::atomic_thread_fence(std::memory_order_acquire); // synchronize with just one writer
        do_work(i); // guaranteed to observe everything done in the writer thread before
                    // the atomic_store_explicit()
    }
 }

 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc inc | cpp/atomic/dsc atomic_signal_fence}}
{{dsc see c | c/atomic/atomic_thread_fence}}
{{dsc end}}

[[de:cpp/atomic/atomic thread fence]]
[[es:cpp/atomic/atomic thread fence]]
[[fr:cpp/atomic/atomic thread fence]]
[[it:cpp/atomic/atomic thread fence]]
[[ja:cpp/atomic/atomic thread fence]]
[[pt:cpp/atomic/atomic thread fence]]
[[ru:cpp/atomic/atomic thread fence]]
[[zh:cpp/atomic/atomic thread fence]]</text>
      <sha1>o5d0yqrcp1bkvss1eiq18852kc37ghr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/kill dependency</title>
    <ns>0</ns>
    <id>2840</id>
    <revision>
      <id>70758</id>
      <parentid>57162</parentid>
      <timestamp>2014-05-29T21:07:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+the big example from c++14</comment>
      <text xml:space="preserve" bytes="2442">{{cpp/title | kill_dependency }}
{{cpp/atomic/navbar}}
{{dcl begin}}
{{dcl header | atomic }}
{{dcl | 1=
template&lt; class T &gt;
T kill_dependency( T y );
}}
{{dcl end}}

Informs the compiler that the dependency tree started by an {{lc|std::memory_order_consume}} atomic load operation does not extend past the return value of {{lc|std::kill_dependency}}; that is, the argument does not carry a dependency into the return value.

This may be used to avoid unnecessary {{lc|std::memory_order_acquire}} fences when the dependency chain leaves function scope (and the function does not have the [[cpp/language/attributes|[&lt;nowiki&gt;[&lt;/nowiki&gt;carries_dependency]&lt;nowiki&gt;]&lt;/nowiki&gt;]] attribute)

===Parameters===
{{par begin}}
{{par | y | the expression whose return value is to be removed from a dependency tree}}
{{par end}} 

===Return value===
Returns {{tt|y}}, no longer a part of a dependency tree.

===Exceptions===
{{noexcept}}

===Examples===
{{source|1=
//file1.cpp
struct foo { int* a; int* b; };
std::atomic&lt;struct foo*&gt; foo_head[10];
int foo_array[10][10];

// consume operation starts a dependency chain, which escapes this function
[[carries_dependency]] struct foo* f(int i) {
    return foo_head[i].load(memory_order_consume);
}

// the dependency chain enters this function through the right parameter
// and is killed before the function ends (so no extra acquire operation place)
int g(int* x, int* y [[carries_dependency]]) {
    return std::kill_dependency(foo_array[*x][*y]);
}
}}

{{source|1=
//file2.cpp
[[carries_dependency]] struct foo* f(int i);
int g(int* x, int* y [[carries_dependency]]);

int c = 3;
void h(int i) {
    struct foo* p;
    p = f(i); // dependency chain started inside f continues into p without undue acquire
    do_something_with(g(&amp;c, p-&gt;a)); // p-&gt;b is not brought in from the cache
    do_something_with(g(p-&gt;a, &amp;c)); // left argument does not have the carries_dependency
                                    // attribute: memory acquire fence may be issued
                                    // p-&gt;b becomes visible before g() is entered
}
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc end}}

[[de:cpp/atomic/kill dependency]]
[[es:cpp/atomic/kill dependency]]
[[fr:cpp/atomic/kill dependency]]
[[it:cpp/atomic/kill dependency]]
[[ja:cpp/atomic/kill dependency]]
[[pt:cpp/atomic/kill dependency]]
[[ru:cpp/atomic/kill dependency]]
[[zh:cpp/atomic/kill dependency]]</text>
      <sha1>n5jisgy4rz3upowzla656r26ergd6f1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/atomic/memory order</title>
    <ns>0</ns>
    <id>2839</id>
    <revision>
      <id>72355</id>
      <parentid>72347</parentid>
      <timestamp>2014-08-14T11:38:02Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Modification order */ it's four requirements now</comment>
      <text xml:space="preserve" bytes="21452">{{cpp/title | memory_order}}
{{cpp/atomic/navbar}}
{{ddcl | header=atomic | since=c++11 | 1=
enum memory_order {
    memory_order_relaxed,
    memory_order_consume,
    memory_order_acquire,
    memory_order_release,
    memory_order_acq_rel,
    memory_order_seq_cst
};
}}

{{tt|std::memory_order}} specifies how regular, non-atomic memory accesses are to be ordered around an atomic operation. Absent any constraints on a multi-core system, when multiple threads simultaneously read and write to several variables, one thread can observe the values change in an order different from the order another thread wrote them. Indeed, the apparent order of changes can even differ among multiple reader threads.

The default behavior of the atomic operations in the library provides for ''sequentially consistent ordering'' (see discussion below). That default can hurt performance, but the library's atomic operations can be given an additional {{tt|std::memory_order}} argument to specify the exact constraints, beyond atomicity, that the compiler and processor must enforce for that operation.

===Constants===

{{dsc begin}}
{{dsc header | atomic}}
{{dsc hitem | Value | Explanation }}
{{dsc | {{tt|memory_order_relaxed}} | '''Relaxed''' ordering: there are no synchronization or ordering constraints, only atomicity is required of this operation.}}
{{dsc | {{tt|memory_order_consume}} | A load operation with this memory order performs a '''consume''' operation on the affected memory location: prior writes to data-dependent memory locations made by the thread that did a release operation become visible to this thread's dependency chain.}}
{{dsc | {{tt|memory_order_acquire}} | A load operation with this memory order performs the '''acquire''' operation on the affected memory location: prior writes made to other memory locations by the thread that did the release become visible in this thread.}}
{{dsc | {{tt|memory_order_release}} | A store operation with this memory order performs the '''release''' operation: prior writes to other memory locations become visible to the threads that do a '''consume''' or an '''acquire''' on the same location.}}
{{dsc | {{tt|memory_order_acq_rel}} | A load operation with this memory order performs the '''acquire''' operation on the affected memory location and a store operation with this memory order performs the '''release''' operation.}}
{{dsc | {{tt|memory_order_seq_cst}} | Same as {{tt|memory_order_acq_rel}}, plus a single total order exists in which all threads observe all modifications (see below) in the same order.}}
{{dsc end}}

===Formal description===
Inter-thread synchronization and memory ordering determine how ''evaluations'' and ''side effects'' of expressions are ordered between different threads of execution. They are defined in the following terms:

====Sequenced-before====
Within the same thread, evaluation A may be ''sequenced-before'' evaluation B, as described in [[cpp/language/eval_order|evaluation order]].

====Carries dependency====
Within the same thread, evaluation A that is ''sequenced-before'' evaluation B may also carry a dependency into B (that is, B depends on A), if any of the following is true
@1@ The value of A is used as an operand of B, '''except'''
:@a@ if B is a call to {{lc|std::kill_dependency}}
:@b@ if A is the left operand of the built-in {{c|&amp;&amp;}}, {{c|{{!!}}}}, {{c|?:}}, or {{c|,}} operators.
@2@ A writes to a scalar object M, B reads from M
@3@ A carries dependency into another evaluation X, and X carries dependency into B

====Modification order====
All modifications to any particular atomic variable occur in a total order that is specific to this one atomic variable.

The following four requirements are guaranteed for all atomic operations:
@1@ '''Write-write coherence''': If evaluation A that modifies some atomic M (a write) ''happens-before'' evaluation B that modifies M, then A appears earlier than B in the ''modification order'' of M
@2@ '''Read-read coherence''': if a value computation A of some atomic M (a read) ''happens-before'' a value computation B on M, and if the value of A comes from a write X on M, then the value of B is either the value stored by X, or the value stored by a side effect Y on M that appears later than X in the ''modification order'' of M.
@3@ '''Read-write coherence''': if a value computation A of some atomic M (a read) ''happens-before'' an operation B on M (a write), then the value of A comes from a side-effect (a write) X that appears earlier than B in the ''modification order'' of M
@4@ '''Write-read coherence''': if a side effect (a write) X on an atomic object M ''happens-before'' a value computation (a read) B of M, then the evaluation B shall take its value from X or from a side effect Y that follows X in the modification order of M

====Release sequence====
After a ''release operation'' A is performed on an atomic object M, the longest continuous subsequence of the modification order of M that consists of
@1@ Writes performed by the same thread that performed A
@2@ Atomic read-modify-write operations made to M by any thread

is known as ''release sequence headed by A''

====Dependency-ordered before====
Between threads, evaluation A is ''dependency-ordered before'' evaluation B if any of the following is true
@1@ A performs a ''release operation'' on some atomic M, and, in a different thread, B performs a ''consume operation'' on the same atomic M, and B reads a value written by any part of the release sequence headed by A.
@2@ A is dependency-ordered before X and X carries a dependency into B.

====Inter-thread happens-before====
Between threads, evaluation A ''inter-thread happens before'' evaluation B if any of the following is true
@1@ A ''synchronizes-with'' B
@2@ A is ''dependency-ordered before'' B
@3@ A ''synchronizes-with'' some evaluation X, and X is ''sequenced-before'' B
@3@ A is ''sequenced-before'' some evaluation X, and X ''inter-thread happens-before'' B
@4@ A ''inter-thread happens-before'' some evaluation X, and X ''inter-thread happens-before'' B

====Happens-before====
Regardless of threads, evaluation A ''happens-before'' evaluation B if any of the following is true:
@1@ A is ''sequenced-before'' B
@2@ A ''inter-thread happens before'' B

If one evaluation modifies a memory location, and the other reads or modifies the same memory location, and if at least one of the evaluations is not an atomic operation, the behavior of the program is undefined (the program has a [[cpp/language/memory_model|data race]]) unless there exists a ''happens-before'' relationship between these two evaluations.

====Visible side-effects====
The side-effect A on a scalar M (a write) is ''visible'' with respect to value computation B on M (a read) if both of the following are true:
@1@ A ''happens-before'' B
@2@ There is no other side effect X to M where A ''happens-before'' X and X ''happens-before'' B

If side-effect A is visible with respect to the value computation B, then the longest contiguous subset of the side-effects to M, in ''modification order'', where B does not ''happen-before'' it is known as the ''visible sequence of side-effects''. (the value of M, determined by B, will be the value stored by one of these side effects)

Note: inter-thread synchronization boils down to defining which side effects become visible under what conditions

====Consume operation====
Atomic load with {{tt|memory_order_consume}} or stronger is a consume operation. Note that {{lc|std::atomic_thread_fence}} is not a consume operation.

====Acquire operation====
Atomic load with {{tt|memory_order_acquire}} or stronger is an acquire operation. The lock() operation on a {{concept|Mutex}} is also an acquire operation. Note that {{lc|std::atomic_thread_fence}} is not an acquire operation.

====Release operation====
Atomic store with {{tt|memory_order_release}} or stronger is a release operation. The unlock() operation on a {{concept|Mutex}} is also a release operation. Note that {{lc|std::atomic_thread_fence}} is not a release operation.

===Explanation===

====Relaxed ordering====
Atomic operations tagged {{lc|std::memory_order_relaxed}} are not synchronization operations, they do not order memory. They only guarantee atomicity and  modification order consistency.

{{rev begin}}
{{rev|until=c++14|
For example, with {{tt|x}} and {{tt|y}} initially zero,

{{source|1=
// Thread 1:
r1 = y.load(memory_order_relaxed); // A
x.store(r1, memory_order_relaxed); // B
// Thread 2:
r2 = x.load(memory_order_relaxed); // C 
y.store(42, memory_order_relaxed); // D
}}

is allowed to produce {{tt|1=r1 == r2 == 42}} because, although A is ''sequenced-before'' B and C is ''sequenced before'' D, nothing prevents D from appearing before A in the modification order of y, and B from appearing before C in the modification order of x.
}}
{{rev|since=c++14|
Even with relaxed memory model, out-of-thin-air values are not allowed to circularly depend on their own computations, for example, with {{tt|x}} and {{tt|y}} initially zero,

{{source|1=
// Thread 1:
r1 = y.load(memory_order_relaxed); // A
x.store(r1, memory_order_relaxed); // B
// Thread 2:
r2 = x.load(memory_order_relaxed); // C 
y.store(42, memory_order_relaxed); // D
}}
is not allowed to produce {{tt|1=r1 == r2 == 42}} since the store of 42 to y is only possible if the store to x stores 42, which circularly depends on the store to y storing 42.
}}
{{rev end}}

Typical use for relaxed memory ordering is updating counters, such as the reference counters of {{lc|std::shared_ptr}}, since this only requires atomicity, but not ordering or synchronization.

{{example
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;atomic&gt;

std::atomic&lt;int&gt; cnt = {0};

void f()
{
    for (int n = 0; n &lt; 1000; ++n) {
        cnt.fetch_add(1, std::memory_order_relaxed);
    }
}

int main()
{
    std::vector&lt;std::thread&gt; v;
    for (int n = 0; n &lt; 10; ++n) {
        v.emplace_back(f);
    }
    for (auto&amp; t : v) {
        t.join();
    }
    std::cout &lt;&lt; &quot;Final counter value is &quot; &lt;&lt; cnt &lt;&lt; '\n';
}
 | output=
Final counter value is 10000
}}

====Release-Acquire ordering====
If an atomic store in thread A is tagged {{lc|std::memory_order_release}} and an atomic load in thread B from the same variable is tagged {{lc|std::memory_order_acquire}}, all memory writes (non-atomic and relaxed atomic) that ''happened-before'' the atomic store from the point of view of thread A, become ''visible side-effects'' in thread B, that is, once the atomic load is completed, thread B is guaranteed to see everything thread A wrote to memory.

The synchronization is established only between the threads ''releasing'' and ''acquiring'' the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.

On strongly-ordered systems (x86, SPARC TSO, IBM mainframe), release-acquire ordering is automatic for the majority of operations. No additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from moving non-atomic stores past the atomic store-release or perform non-atomic loads earlier than the atomic load-acquire). On weakly-ordered systems (ARM, Itanium, PowerPC), special CPU load or memory fence instructions have to be used.

Mutual exclusion locks (such as {{lc|std::mutex}} or [[cpp/atomic/atomic_flag|atomic spinlock]]) are an example of release-acquire synchronization: when the lock is released by thread A and acquired by thread B, everything that took place in the critical section (before the release) in the context of thread A has to be visible to thread B (after the acquire) which is executing the same critical section.

{{example
 | code=
#include &lt;thread&gt;
#include &lt;atomic&gt;
#include &lt;cassert&gt;
#include &lt;string&gt;
 
std::atomic&lt;std::string*&gt; ptr;
int data;
 
void producer()
{
    std::string* p  = new std::string(&quot;Hello&quot;);
    data = 42;
    ptr.store(p, std::memory_order_release);
}
 
void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_acquire)))
        ;
    assert(*p2 == &quot;Hello&quot;); // never fires
    assert(data == 42); // never fires
}
 
int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}
 | output=
}}

{{example
 | The following example demonstrates transitive release-acquire ordering across three threads
 | code=
#include &lt;thread&gt;
#include &lt;atomic&gt;
#include &lt;cassert&gt;
#include &lt;vector&gt;

std::vector&lt;int&gt; data;
std::atomic&lt;int&gt; flag = {0};

void thread_1()
{
    data.push_back(42);
    flag.store(1, std::memory_order_release);
}

void thread_2()
{
    int expected=1;
    while (!flag.compare_exchange_strong(expected, 2, std::memory_order_acq_rel)) {
        expected = 1;
    }
}

void thread_3()
{
    while (flag.load(std::memory_order_acquire) &lt; 2)
        ;
    assert(data.at(0) == 42); // will never fire
}

int main()
{
    std::thread a(thread_1);
    std::thread b(thread_2);
    std::thread c(thread_3);
    a.join(); b.join(); c.join();
}
 | output=
}}


====Release-Consume ordering====
If an atomic store in thread A is tagged {{lc|std::memory_order_release}} and an atomic load in thread B from the same variable is tagged {{lc|std::memory_order_consume}}, all memory writes (non-atomic and relaxed atomic) that are ''dependency-ordered-before'' the atomic store from the point of view of thread A, become ''visible side-effects'' within those operations in thread B into which the load operation ''carries dependency'', that is, once the atomic load is completed, those operators and functions in thread B that use the value obtained from the load are guaranteed to see what thread A wrote to memory.

The synchronization is established only between the threads ''releasing'' and ''acquiring'' the same atomic variable. Other threads can see different order of memory accesses than either or both of the synchronized threads.

On all mainstream CPUs other than DEC Alpha, dependency ordering is automatic, no additional CPU instructions are issued for this synchronization mode, only certain compiler optimizations are affected (e.g. the compiler is prohibited from performing speculative loads on the objects that are involved in the dependency chain). 

Typical use cases for this ordering involve read access to rarely written concurrent data structures (routing tables, configuration, security policies, firewall rules, etc) and publisher-subscriber situations with pointer-mediated publication, that is, when the producer publishes a pointer through which the consumer can access information: there is no need to make everything else the producer wrote to memory visible to the consumer (which may be an expensive operation on weakly-ordered architectures). An example of such scenario is [[enwiki:Read-copy-update|rcu_dereference]].

See also {{lc|std::kill_dependency}} and [[cpp/language/attributes|[&lt;nowiki&gt;[&lt;/nowiki&gt;carries_dependency]&lt;nowiki&gt;]&lt;/nowiki&gt;]] for fine-grained dependency chain control.

{{example
 | This example demonstrates dependency-ordered synchronization for pointer-mediated publication: the integer data is not related to the pointer to string by a data-dependency relationship, thus its value is undefined in the consumer.
 | code=
#include &lt;thread&gt;
#include &lt;atomic&gt;
#include &lt;cassert&gt;
#include &lt;string&gt;

std::atomic&lt;std::string*&gt; ptr;
int data;

void producer()
{
    std::string* p  = new std::string(&quot;Hello&quot;);
    data = 42;
    ptr.store(p, std::memory_order_release);
}

void consumer()
{
    std::string* p2;
    while (!(p2 = ptr.load(std::memory_order_consume)))
        ;
    assert(*p2 == &quot;Hello&quot;); // never fires: *p2 carries dependency from ptr
    assert(data == 42); // may or may not fire: data does not carry dependency from ptr
}

int main()
{
    std::thread t1(producer);
    std::thread t2(consumer);
    t1.join(); t2.join();
}
 | output=
}}


====Sequentially-consistent ordering====
Atomic operations tagged {{lc|std::memory_order_seq_cst}} not only order memory the same way as release/acquire ordering (everything that happened-before a store in one thread becomes a visible side effect in the thread that did a load), but also establish a single total modification order of all atomic operations that are so tagged.

Formally,

Each {{tt|memory_order_seq_cst}} operation B that loads from atomic variable M, observes one of the following:
* the result of the last operation A that modified M, which appears before B in the single total order
* OR, if there was such an A, B may observe the result of some modification on M that is not {{tt|memory_order_seq_cst}} and does not ''happen-before'' A
* OR, if there wasn't such an A, B may observe the result of some unrelated modification of M that is not {{tt|memory_order_seq_cst}}

If there was a {{tt|memory_order_seq_cst}} {{lc|std::atomic_thread_fence}} operation X ''sequenced-before'' B, then B observes one of the following:
* the last {{tt|memory_order_seq_cst}} modification of M that appears before X in the single total order
* some unrelated modification of M that appears later in M's modification order

For a pair of atomic operations on M called A and B, where A writes and B reads M's value, if there are two {{tt|memory_order_seq_cst}} {{lc|std::atomic_thread_fence}}s X and Y, and if A is ''sequenced-before'' X, Y is ''sequenced-before'' B, and X appears before Y in the Single Total Order, then B observes either:
* the effect of A
* some unrelated modification of M that appears after A in M's modification order

For a pair of atomic modifications of M called A and B, B occurs after A in M's modification order if 
* there is a {{tt|memory_order_seq_cst}} {{lc|std::atomic_thread_fence}} X such that A is ''sequenced-before'' X and X appears before B in the Single Total Order
* or, there is a {{tt|memory_order_seq_cst}} {{lc|std::atomic_thread_fence}} Y such that Y is ''sequenced-before'' B and A appears before Y in the Single Total Order
* or, there are {{tt|memory_order_seq_cst}} {{lc|std::atomic_thread_fence}}s X and Y such that A is ''sequenced-before'' X, Y is ''sequenced-before'' B, and X appears before Y in the Single Total Order.

Note that the means that:
@1@ as soon as atomic operations that are not tagged {{tt|memory_order_seq_cst}} enter the picture, the sequential consistency is lost
@2@ the sequentially-consistent fences are only establishing total ordering for the fences themselves, not for the atomic operations in the general case (''sequenced-before'' is not a cross-thread relationship, unlike ''happens-before'')

Sequential ordering may be necessary for multiple producer-multiple consumer situations where all consumers must observe the actions of all producers occurring in the same order.

Total sequential ordering requires a full memory fence CPU instruction on all multi-core systems. This may become a performance bottleneck since it forces the affected memory accesses to propagate to every core.

{{example
 | This example demonstrates a situation where sequential ordering is necessary. Any other ordering may trigger the assert because it would be possible for the threads {{tt|c}} and {{tt|d}} to observe changes to the atomics {{tt|x}} and {{tt|y}} in opposite order.
 | code=
#include &lt;thread&gt;
#include &lt;atomic&gt;
#include &lt;cassert&gt;

std::atomic&lt;bool&gt; x = {false};
std::atomic&lt;bool&gt; y = {false};
std::atomic&lt;int&gt; z = {0};

void write_x()
{
    x.store(true, std::memory_order_seq_cst);
}

void write_y()
{
    y.store(true, std::memory_order_seq_cst);
}

void read_x_then_y()
{
    while (!x.load(std::memory_order_seq_cst))
        ;
    if (y.load(std::memory_order_seq_cst)) {
        ++z;
    }
}

void read_y_then_x()
{
    while (!y.load(std::memory_order_seq_cst))
        ;
    if (x.load(std::memory_order_seq_cst)) {
        ++z;
    }
}

int main()
{
    std::thread a(write_x);
    std::thread b(write_y);
    std::thread c(read_x_then_y);
    std::thread d(read_y_then_x);
    a.join(); b.join(); c.join(); d.join();
    assert(z.load() != 0);  // will never happen
}
 | output=
}}

===Relationship with {{c|volatile}}===
Within a thread of execution, accesses (reads and writes) to all {{c|volatile}} objects are guaranteed to not be reordered relative to each other, but this order is not guaranteed to be observed by another thread, since volatile access does not establish inter-thread synchronization.

In addition, volatile accesses are not atomic (concurrent read and write is a [[cpp/language/memory_model|data race]]) and do not order memory (non-volatile memory accesses may be freely reordered around the volatile access).

One notable exception is Visual Studio, where, with default settings, every volatile write has release semantics and every volatile read has acquire semantics ([http://msdn.microsoft.com/en-us/library/12a04hfd(v=vs.100).aspx MSDN]), and thus volatiles may be used for inter-thread synchronization. Standard {{c|volatile}} semantics are not applicable to multithreaded programming, although they are sufficient for e.g. communication with a signal handler (see also {{lc|std::atomic_signal_fence}})


[[de:cpp/atomic/memory order]]
[[es:cpp/atomic/memory order]]
[[fr:cpp/atomic/memory order]]
[[it:cpp/atomic/memory order]]
[[ja:cpp/atomic/memory order]]
[[pt:cpp/atomic/memory order]]
[[ru:cpp/atomic/memory order]]
[[zh:cpp/atomic/memory order]]</text>
      <sha1>moheuq6stmbxl95jfhumzz9rmnsgujk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono</title>
    <ns>0</ns>
    <id>794</id>
    <revision>
      <id>72478</id>
      <parentid>72477</parentid>
      <timestamp>2014-08-25T14:42:08Z</timestamp>
      <contributor>
        <username>Supermelon</username>
        <id>3343</id>
      </contributor>
      <minor/>
      <comment>output updated to show 433494437 value</comment>
      <text xml:space="preserve" bytes="2689">{{title | Date and time utilities}}
{{cpp/chrono/navbar}}

C++ includes support for two types of time manipulation:

* The {{tt|chrono}} library, a flexible collection of types that track time with varying degrees of precision (e.g. {{lc|std::chrono::time_point}}).
* C-style date and time library (e.g. {{lc|std::time}})

==={{tt|chrono}} library===
The {{tt|chrono}} library defines three main types (durations, clocks, and time points) as well as utility functions and common typedefs.

====Duration====
A duration consists of a span of time, defined as some number of ticks of some time unit.  For example, &quot;42 seconds&quot; could be represented by a duration consisting of 42 ticks of a 1-second time unit.

{{dsc begin}}
{{dsc header | chrono}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/dsc duration}}
{{dsc end}}

====Clocks====
A clock consists of a starting point (or epoch) and a tick rate.  For example, a clock may have an epoch of January 1, 1970 and tick every second.  C++ defines three clock types:

{{dsc begin}}
{{dsc header | chrono}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/dsc system_clock}}
{{dsc inc | cpp/chrono/dsc steady_clock}}
{{dsc inc | cpp/chrono/dsc high_resolution_clock}}
{{dsc end}}

====Time point====
A time point is a duration of time that has passed since the epoch of specific clock.

{{dsc begin}}
{{dsc header | chrono}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/dsc time_point}}
{{dsc end}}

===[[cpp/chrono/c|C-style date and time library]]===

Also provided are the C-style date and time functions, such as {{lc|std::time_t}}, {{lc|std::difftime}}, and {{lc|CLOCKS_PER_SEC}}.

===Example===
{{example
 | This example displays information about the execution time of a function call:
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;ctime&gt;
 
long fibonacci(int n)
{
    if (n &lt; 3) return n;
    return fibonacci(n-1) + fibonacci(n-2);
}
 
int main()
{
    std::chrono::time_point&lt;std::chrono::system_clock&gt; start, end;
    start = std::chrono::system_clock::now();
    std::cout &lt;&lt; &quot;f(42) = &quot; &lt;&lt; fibonacci(42) &lt;&lt; '\n';
    end = std::chrono::system_clock::now();
 
    std::chrono::duration&lt;double&gt; elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
 
    std::cout &lt;&lt; &quot;finished computation at &quot; &lt;&lt; std::ctime(&amp;end_time)
              &lt;&lt; &quot;elapsed time: &quot; &lt;&lt; elapsed_seconds.count() &lt;&lt; &quot;s\n&quot;;
}
 | output=
f(42) = 433494437
finished computation at Mon Jul 29 08:41:09 2013
elapsed time: 0.670427s
}}

[[de:cpp/chrono]]
[[es:cpp/chrono]]
[[fr:cpp/chrono]]
[[it:cpp/chrono]]
[[ja:cpp/chrono]]
[[pt:cpp/chrono]]
[[ru:cpp/chrono]]
[[zh:cpp/chrono]]</text>
      <sha1>ppqkorrsd4gqnhckqisl1tykqf535oj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c</title>
    <ns>0</ns>
    <id>795</id>
    <revision>
      <id>71020</id>
      <parentid>57166</parentid>
      <timestamp>2014-06-04T19:24:34Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1107">{{title|C Date and time utilities}}
{{cpp/chrono/c/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | ctime}}
{{dsc h2 | Time manipulation}}
{{dsc inc | cpp/chrono/c/dsc difftime}}
{{dsc inc | cpp/chrono/c/dsc time}}
{{dsc inc | cpp/chrono/c/dsc clock}}
{{dsc h2 | Format conversions}}
{{dsc inc | cpp/chrono/c/dsc asctime}}
{{dsc inc | cpp/chrono/c/dsc ctime}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/chrono/c/dsc wcsftime}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc inc | cpp/chrono/c/dsc mktime}}
{{dsc end}}

===Constants===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc CLOCKS_PER_SEC}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc tm}}
{{dsc inc | cpp/chrono/c/dsc time_t}}
{{dsc inc | cpp/chrono/c/dsc clock_t}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/chrono |Date and time utilities }}
{{dsc end}}

[[cs:cpp/chrono/c]]
[[de:cpp/chrono/c]]
[[es:cpp/chrono/c]]
[[fr:cpp/chrono/c]]
[[it:cpp/chrono/c]]
[[ja:cpp/chrono/c]]
[[pt:cpp/chrono/c]]
[[ru:cpp/chrono/c]]
[[tr:cpp/chrono/c]]
[[zh:cpp/chrono/c]]</text>
      <sha1>a8gdkgwsge8qhnnsn3869kipsoyxxnv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/CLOCKS PER SEC</title>
    <ns>0</ns>
    <id>2054</id>
    <revision>
      <id>64221</id>
      <parentid>64217</parentid>
      <timestamp>2013-08-15T15:49:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="869">{{title| CLOCKS_PER_SEC}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
#define CLOCKS_PER_SEC /*implementation defined*/
}}

Expands to an expression (not necessarily a compile-time constant) of type {{lc|std::clock_t}} equal to the number of clock ticks per second, as returned by {{lc|std::clock()}}. 

===Notes===
POSIX defines {{tt|CLOCKS_PER_SEC}} as one million, regardless of the actual precision of {{lc|std::clock()}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc clock}}
{{dsc inc | cpp/chrono/c/dsc clock_t}}
{{dsc see c | c/chrono/CLOCKS_PER_SEC}}
{{dsc end}}

[[de:cpp/chrono/c/CLOCKS PER SEC]]
[[es:cpp/chrono/c/CLOCKS PER SEC]]
[[fr:cpp/chrono/c/CLOCKS PER SEC]]
[[it:cpp/chrono/c/CLOCKS PER SEC]]
[[ja:cpp/chrono/c/CLOCKS PER SEC]]
[[pt:cpp/chrono/c/CLOCKS PER SEC]]
[[ru:cpp/chrono/c/CLOCKS PER SEC]]
[[zh:cpp/chrono/c/CLOCKS PER SEC]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/asctime</title>
    <ns>0</ns>
    <id>2051</id>
    <revision>
      <id>57170</id>
      <parentid>49350</parentid>
      <timestamp>2013-06-01T05:48:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2312">{{cpp/title| asctime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
char* asctime( const std::tm* time_ptr );
}}

Converts given calendar time {{lc|std::tm}} to a textual representation.
The resulting string has the following format:

{{source|Www Mmm dd hh:mm:ss yyyy}}

*{{tt|Www}} - the day of the week (one of {{tt|Mon}}, {{tt|Tue}}, {{tt|Wed}}, {{tt|Thu}}, {{tt|Fri}}, {{tt|Sat}}, {{tt|Sun}}).
*{{tt|Mmm}} - the month (one of {{tt|Jan}}, {{tt|Feb}}, {{tt|Mar}}, {{tt|Apr}}, {{tt|May}}, {{tt|Jun}}, {{tt|Jul}}, {{tt|Aug}}, {{tt|Sep}}, {{tt|Oct}}, {{tt|Nov}}, {{tt|Dec}}).
*{{tt|dd}} - the day of the month
*{{tt|hh}} - hours
*{{tt|mm}} - minutes
*{{tt|ss}} - seconds 
*{{tt|yyyy}} - years

The function does not support localization.

===Parameters===
{{par begin}}
{{par | time_ptr | pointer to a {{lc|std::tm}} object specifying the time to print}}
{{par end}}

===Return value===
Pointer to a static null-terminated character string holding the textual representation of date and time. The string may be shared between {{tt|std::asctime}} and {{lc|std::ctime}}, and may be overwritten on each invocation of any of those functions.

===Notes===
This function returns a pointer to static data and is not thread-safe. POSIX marks this function obsolete and recommends {{lc|std::strftime}} instead.

The behavior is undefined if the output string would be longer than 25 characters, if {{tt|timeptr-&gt;tm_wday}} or {{tt|timeptr-&gt;tm_mon}} are not within the expected ranges, or if {{tt|timeptr-&gt;tm_year}} exceeds {{c|INT_MAX-1990}}.

Some implementations handle {{c|1=timeptr-&gt;tm_mday==0}} as meaning the last day of the preceding month.

===Example===
{{example
 |
 | code=
#include &lt;ctime&gt;
#include &lt;iostream&gt;

int main()
{
    std::time_t result = std::time(NULL);
    std::cout &lt;&lt; std::asctime(std::localtime(&amp;result));
}
 | output=
Tue Dec 27 16:45:52 2011
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc ctime}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc see c | c/chrono/asctime}}
{{dsc end}}

[[de:cpp/chrono/c/asctime]]
[[es:cpp/chrono/c/asctime]]
[[fr:cpp/chrono/c/asctime]]
[[it:cpp/chrono/c/asctime]]
[[ja:cpp/chrono/c/asctime]]
[[pt:cpp/chrono/c/asctime]]
[[ru:cpp/chrono/c/asctime]]
[[tr:cpp/chrono/c/asctime]]
[[zh:cpp/chrono/c/asctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/clock</title>
    <ns>0</ns>
    <id>2053</id>
    <revision>
      <id>66044</id>
      <parentid>66042</parentid>
      <timestamp>2013-10-22T16:41:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>Undo revision 66042 by [[Special:Contributions/192.100.120.42|192.100.120.42]] ([[User talk:192.100.120.42|talk]]) redundant C-style cast</comment>
      <text xml:space="preserve" bytes="2924">{{cpp/title| clock}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::clock_t clock();
}}

Returns the approximate processor time used by the process since the beginning of an implementation-defined era related to the program's execution. To convert result value to seconds divide it by {{lc|CLOCKS_PER_SEC}}. 

Only the difference between two values returned by different calls to {{lc|std::clock}} is meaningful, as the beginning of the {{lc|std::clock}} era does not have to coincide with the start of the program. {{lc|std::clock}} time may advance faster or slower than the wall clock, depending on the execution resources given to the program by the operating system. For example, if the CPU is shared by other processes, {{lc|std::clock}} time may advance slower than wall clock. On the other hand, if the current process is multithreaded and more than one execution core is available, {{lc|std::clock}} time may advance faster than wall clock.

===Parameters===
(none)

===Return value===
Processor time used by the program so far or {{c|(clock_t)(-1)}} if that information is unavailable.

===Exceptions===
(none)

===Notes===
On POSIX-compatible systems, &lt;code&gt;[http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html clock_gettime]&lt;/code&gt; with clock id {{c|CLOCK_PROCESS_CPUTIME_ID}} offers better resolution.

The value returned by {{tt|clock()}} may wrap around on some implementations. For example, on a machine with 32-bit  {{lc|std::clock_t}}, it wraps after 2147 seconds or 36 minutes.

===Example===
{{example
 | This example demonstrates the difference between clock() time and real time
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;ctime&gt;
#include &lt;thread&gt;

// the function f() does some time-consuming work
void f()
{
    volatile double d;
    for(int n=0; n&lt;10000; ++n)
       for(int m=0; m&lt;10000; ++m)
           d += d*n*m;
}

int main()
{
    std::clock_t c_start = std::clock();
    auto t_start = std::chrono::high_resolution_clock::now();
    std::thread t1(f); 
    std::thread t2(f); // f() is called on two threads
    t1.join();
    t2.join();
    std::clock_t c_end = std::clock();
    auto t_end = std::chrono::high_resolution_clock::now();

    std::cout &lt;&lt; &quot;CPU time used: &quot;
              &lt;&lt; 1000.0 * (c_end-c_start) / CLOCKS_PER_SEC
              &lt;&lt; &quot; ms\n&quot;;
    std::cout &lt;&lt; &quot;Wall clock time passed: &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(t_end - t_start).count()
              &lt;&lt; &quot; ms\n&quot;;
}
 | output=
CPU time used: 1520 ms
Wall clock time passed: 769 ms
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc ctime}}
{{dsc inc | cpp/chrono/c/dsc time}}
{{dsc see c | c/chrono/clock}}
{{dsc end}}

[[de:cpp/chrono/c/clock]]
[[es:cpp/chrono/c/clock]]
[[fr:cpp/chrono/c/clock]]
[[it:cpp/chrono/c/clock]]
[[ja:cpp/chrono/c/clock]]
[[pt:cpp/chrono/c/clock]]
[[ru:cpp/chrono/c/clock]]
[[zh:cpp/chrono/c/clock]]</text>
      <sha1>mg88gvl0ec2o5r8mkpq200q9o5a9vsk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/clock t</title>
    <ns>0</ns>
    <id>4644</id>
    <revision>
      <id>57174</id>
      <parentid>49352</parentid>
      <timestamp>2013-06-01T05:48:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="605">{{cpp/title|clock_t}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime | 1=
typedef /* unspecified */ clock_t;
}}
Arithmetic type capable of representing the process running time of implementation-defined range and precision.

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc clock}}
{{dsc inc | cpp/chrono/c/dsc CLOCKS_PER_SEC}}
{{dsc see c | c/chrono/clock_t}}
{{dsc end}}

[[de:cpp/chrono/c/clock t]]
[[es:cpp/chrono/c/clock t]]
[[fr:cpp/chrono/c/clock t]]
[[it:cpp/chrono/c/clock t]]
[[ja:cpp/chrono/c/clock t]]
[[pt:cpp/chrono/c/clock t]]
[[ru:cpp/chrono/c/clock t]]
[[zh:cpp/chrono/c/clock t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/ctime</title>
    <ns>0</ns>
    <id>2058</id>
    <revision>
      <id>57175</id>
      <parentid>49353</parentid>
      <timestamp>2013-06-01T05:48:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2246">{{cpp/title| ctime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
char* ctime( const std::time_t* time );
}}

Converts given time since epoch to a calendar local time and then to a textual representation, as if by calling {{c|std::asctime(std::localtime(time))}}. The resulting string has the following format:

{{source|Www Mmm dd hh:mm:ss yyyy}}

*{{tt|Www}} - the day of the week (one of {{tt|Mon}}, {{tt|Tue}}, {{tt|Wed}}, {{tt|Thu}}, {{tt|Fri}}, {{tt|Sat}}, {{tt|Sun}}).
*{{tt|Mmm}} - the month (one of {{tt|Jan}}, {{tt|Feb}}, {{tt|Mar}}, {{tt|Apr}}, {{tt|May}}, {{tt|Jun}}, {{tt|Jul}}, {{tt|Aug}}, {{tt|Sep}}, {{tt|Oct}}, {{tt|Nov}}, {{tt|Dec}}).
*{{tt|dd}} - the day of the month
*{{tt|hh}} - hours
*{{tt|mm}} - minutes
*{{tt|ss}} - seconds 
*{{tt|yyyy}} - years

The function does not support localization.

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|std::time_t}} object specifying the time to print}}
{{par end}}

===Return value===
Pointer to a static null-terminated character string holding the textual representation of date and time. The string may be shared between {{tt|std::asctime}} and {{lc|std::ctime}}, and may be overwritten on each invocation of any of those functions.

===Notes===
This function returns a pointer to static data and is not thread-safe. In addition, it modifies the static {{lc|std::tm}} object which may be shared with {{lc|std::gmtime}} and {{lc|std::localtime}}. POSIX marks this function obsolete and recommends {{lc|std::strftime}} instead.

The behavior may be undefined for the values of time_t that result in the string longer than 25 characters (e.g. year 10000)

===Example===
{{example
 |
 | code=
#include &lt;ctime&gt;
#include &lt;iostream&gt;

int main()
{
    std::time_t result = std::time(NULL);
    std::cout &lt;&lt; std::ctime(&amp;result);
}
 | output=
Tue Dec 27 17:21:29 2011
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc asctime}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc see c | c/chrono/ctime}}
{{dsc end}}

[[de:cpp/chrono/c/ctime]]
[[es:cpp/chrono/c/ctime]]
[[fr:cpp/chrono/c/ctime]]
[[it:cpp/chrono/c/ctime]]
[[ja:cpp/chrono/c/ctime]]
[[pt:cpp/chrono/c/ctime]]
[[ru:cpp/chrono/c/ctime]]
[[zh:cpp/chrono/c/ctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/difftime</title>
    <ns>0</ns>
    <id>2056</id>
    <revision>
      <id>64345</id>
      <parentid>57176</parentid>
      <timestamp>2013-08-15T18:26:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1485">{{cpp/title| difftime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
double difftime( std::time_t time_end, std::time_t time_beg );
}}

Computes difference between two calendar times as {{lc|std::time_t}} objects ({{c|time_end - time_beg}}) in seconds. If {{tt|time_end}} refers to time point before {{tt|time_beg}} then the result is negative.

===Parameters===
{{par begin}}
{{par | time_beg, time_end | times to compare}}
{{par end}}

===Return value===
Difference between two times in seconds.

===Notes===
On POSIX systems, {{lc|std::time_t}} is measured in seconds, and {{tt|difftime}} is equivalent to arithmetic subtraction, but C and C++ allow fractional units for {{tt|time_t}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ctime&gt;

int main()
{
    std::time_t start = std::time(NULL);
    volatile double d;

    // some time-consuming operation
    for (int n=0; n&lt;10000; ++n) {
        for (int m=0; m&lt;100000; ++m) {
           d += d*n*m;
        }
    }

    std::cout &lt;&lt; &quot;Wall time passed: &quot;
              &lt;&lt; std::difftime(std::time(NULL), start) &lt;&lt; &quot; s.\n&quot;;
}
 | output=
Wall time passed: 7 s.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/dsc duration}}
{{dsc see c | c/chrono/difftime}}
{{dsc end}}

[[de:cpp/chrono/c/difftime]]
[[es:cpp/chrono/c/difftime]]
[[fr:cpp/chrono/c/difftime]]
[[it:cpp/chrono/c/difftime]]
[[ja:cpp/chrono/c/difftime]]
[[pt:cpp/chrono/c/difftime]]
[[ru:cpp/chrono/c/difftime]]
[[zh:cpp/chrono/c/difftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/gmtime</title>
    <ns>0</ns>
    <id>2057</id>
    <revision>
      <id>67309</id>
      <parentid>67308</parentid>
      <timestamp>2014-02-04T14:33:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>std::</comment>
      <text xml:space="preserve" bytes="1493">{{cpp/title| gmtime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::tm* gmtime( const std::time_t* time );
}}

Converts given time since epoch as {{lc|std::time_t}} value into calendar time, expressed in Coordinated Universal Time (UTC). 

===Parameters===
{{par begin}}
{{par | time | pointer to a time_t object to convert}}
{{par end}}

===Return value===
Pointer to a static internal {{lc|std::tm}} object on success, or {{lc|NULL}} otherwise. The structure may be shared between {{lc|std::gmtime}}, {{lc|std::localtime}}, and {{lc|std::ctime}} and may be overwritten on each invocation.

===Notes===
This function may not be thread-safe.

POSIX requires that this function sets {{lc|errno}} to {{lc|EOVERFLOW}} if it fails because the argument is too large.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

int main()
{
    std::time_t t = std::time(NULL);
    std::cout &lt;&lt; &quot;UTC:   &quot; &lt;&lt; std::put_time(std::gmtime(&amp;t), &quot;%c %Z&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;local: &quot; &lt;&lt; std::put_time(std::localtime(&amp;t), &quot;%c %Z&quot;) &lt;&lt; '\n';
}
 | output=
UTC:   Wed Dec 28 11:44:28 2011 GMT
local: Wed Dec 28 06:44:28 2011 EST
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc see c | c/chrono/gmtime}}
{{dsc end}}

[[de:cpp/chrono/c/gmtime]]
[[es:cpp/chrono/c/gmtime]]
[[fr:cpp/chrono/c/gmtime]]
[[it:cpp/chrono/c/gmtime]]
[[ja:cpp/chrono/c/gmtime]]
[[pt:cpp/chrono/c/gmtime]]
[[ru:cpp/chrono/c/gmtime]]
[[zh:cpp/chrono/c/gmtime]]</text>
      <sha1>e1zdelbwioor674k9jjxc1xeqynrn2a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/localtime</title>
    <ns>0</ns>
    <id>2059</id>
    <revision>
      <id>67330</id>
      <parentid>57180</parentid>
      <timestamp>2014-02-05T01:05:28Z</timestamp>
      <contributor>
        <username>SeizeF</username>
        <id>2420</id>
      </contributor>
      <comment>fix bug due to unspecified evaluation order of argument expressions.</comment>
      <text xml:space="preserve" bytes="1506">{{cpp/title| localtime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::tm* localtime( const std::time_t *time );
}}

Converts given time since epoch as {{lc|std::time_t}} value into calendar time, expressed in local time. 

===Parameters===
{{par begin}}
{{par | time | pointer to a time_t object to convert}}
{{par end}}

===Return value===

pointer to a static internal {{lc|std::tm}} object on success, or {{lc|NULL}} otherwise. The structure may be shared between {{lc|std::gmtime}}, {{lc|std::localtime}}, and {{lc|std::ctime}}, and may be overwritten on each invocation.

===Notes===
This function may not be thread-safe.

POSIX requires that this function sets {{lc|errno}} to {{lc|EOVERFLOW}} if it fails because the argument is too large.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

int main()
{
    std::time_t t = std::time(nullptr);
    std::cout &lt;&lt; &quot;UTC:   &quot; &lt;&lt; std::put_time(std::gmtime(&amp;t), &quot;%c %Z&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;local: &quot; &lt;&lt; std::put_time(std::localtime(&amp;t), &quot;%c %Z&quot;) &lt;&lt; '\n';
}
 | output=
UTC:   Wed Dec 28 11:47:03 2011 GMT
local: Wed Dec 28 06:47:03 2011 EST
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc see c | c/chrono/localtime}}
{{dsc end}}

[[de:cpp/chrono/c/localtime]]
[[es:cpp/chrono/c/localtime]]
[[fr:cpp/chrono/c/localtime]]
[[it:cpp/chrono/c/localtime]]
[[ja:cpp/chrono/c/localtime]]
[[pt:cpp/chrono/c/localtime]]
[[ru:cpp/chrono/c/localtime]]
[[zh:cpp/chrono/c/localtime]]</text>
      <sha1>b4bo0m27vm0ahkgem903gzo9fjc1s4e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/mktime</title>
    <ns>0</ns>
    <id>2060</id>
    <revision>
      <id>71523</id>
      <parentid>69084</parentid>
      <timestamp>2014-06-12T16:52:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+note on tm_isdst</comment>
      <text xml:space="preserve" bytes="2205">{{cpp/title| mktime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::time_t mktime( std::tm* time );
}}

Converts local calendar time to a time since epoch as a {{c|time_t}} object. {{tt|time-&gt;tm_wday}} and {{tt|time-&gt;tm_yday}} are ignored. The values in {{tt|time}} are permitted to be outside their normal ranges.

A negative value of {{tt|time-&gt;tm_isdst}} causes {{tt|mktime}} to attempt to determine if Daylight Saving Time was in effect.

If the conversion is successful, the {{tt|time}} object is modified. All fields of {{tt|time}} are updated to fit their proper ranges. {{tt|time-&gt;tm_wday}} and {{tt|time-&gt;tm_yday}} are recalculated using information available in other fields.

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|std::tm}} object specifying local calendar time to convert}}
{{par end}}

===Return value===
Time since epoch as a {{lc|std::time_t}} object on success or {{c|-1}} if {{tt|time}} cannot be represented as a {{lc|std::time_t}} object.

===Notes===
If the {{lc|std::tm}} object was obtained from {{lc|std::get_time}} or the POSIX [http://pubs.opengroup.org/onlinepubs/009695399/functions/strptime.html strptime]], the value of {{tt|tm_isdst}} is indeterminate, and needs to be set explicitly before calling {{tt|mktime}}.

===Example===
{{example
 | Display the time 100 months ago
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

int main()
{
    std::time_t t = std::time(NULL);
    std::tm tm = *std::localtime(&amp;t);
    std::cout &lt;&lt; &quot;Today is           &quot; &lt;&lt; std::put_time(&amp;tm, &quot;%c %Z&quot;) &lt;&lt;'\n';
    tm.tm_mon -= 100;  // tm_mon is now outside its normal range
    std::mktime(&amp;tm);
    std::cout &lt;&lt; &quot;100 months ago was &quot; &lt;&lt; std::put_time(&amp;tm, &quot;%c %Z&quot;) &lt;&lt; '\n';
}
 | output=
Today is           Wed Dec 28 09:56:10 2011 EST
100 months ago was Thu Aug 28 10:56:10 2003 EDT
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc see c | c/chrono/mktime}}
{{dsc end}}

[[de:cpp/chrono/c/mktime]]
[[es:cpp/chrono/c/mktime]]
[[fr:cpp/chrono/c/mktime]]
[[it:cpp/chrono/c/mktime]]
[[ja:cpp/chrono/c/mktime]]
[[pl:cpp/chrono/c/mktime]]
[[pt:cpp/chrono/c/mktime]]
[[ru:cpp/chrono/c/mktime]]
[[zh:cpp/chrono/c/mktime]]</text>
      <sha1>i9e9yxph9q12a5nd9hhngygm3rhm5q5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/strftime</title>
    <ns>0</ns>
    <id>2061</id>
    <revision>
      <id>68789</id>
      <parentid>57184</parentid>
      <timestamp>2014-03-21T16:15:17Z</timestamp>
      <contributor>
        <ip>62.214.177.103</ip>
      </contributor>
      <comment>make call to strftime() more robust</comment>
      <text xml:space="preserve" bytes="1829">{{cpp/title| strftime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::size_t strftime( char* str, std::size_t count, const char* format, std::tm* time );
}}

Converts the date and time information from a given calendar time {{tt|time}} to a null-terminated multibyte character string {{tt|str}} according to format string {{tt|format}}. Up to {{tt|count}} bytes are written.

===Parameters===
{{par begin}}
{{par | str | pointer to the first element of the char array for output}}
{{par | count | maximum number of bytes to write}}
{{par | format | pointer to a null-terminated multibyte character string specifying the format of conversion. 
{{cpp/chrono/c/strftime format}}
}}
{{par end}}

===Return value===
The number of bytes written into the character array pointed to by {{tt|str}} not including the terminating {{c|'\0'}} on success. If {{tt|count}} was reached before the entire string could be stored, {{c|0}} is returned and the contents are undefined.

===Example===
{{example
 |
 | code=
#include &lt;ctime&gt;
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    std::time_t t = std::time(NULL);
    char mbstr[100];
    if (std::strftime(mbstr, sizeof(mbstr), &quot;%A %c&quot;, std::localtime(&amp;t))) {
        std::cout &lt;&lt; mbstr &lt;&lt; '\n';
    }
}
 | output=
火曜日 2011年12月27日 17時39分03秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc asctime}}
{{dsc inc | cpp/chrono/c/dsc ctime}}
{{dsc inc | cpp/chrono/c/dsc wcsftime}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc see c | c/chrono/strftime}}
{{dsc end}}

[[de:cpp/chrono/c/strftime]]
[[es:cpp/chrono/c/strftime]]
[[fr:cpp/chrono/c/strftime]]
[[it:cpp/chrono/c/strftime]]
[[ja:cpp/chrono/c/strftime]]
[[pt:cpp/chrono/c/strftime]]
[[ru:cpp/chrono/c/strftime]]
[[zh:cpp/chrono/c/strftime]]</text>
      <sha1>fbigbskzd30owr650o6ma8pgjz2zwcz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/time</title>
    <ns>0</ns>
    <id>2055</id>
    <revision>
      <id>67436</id>
      <parentid>57185</parentid>
      <timestamp>2014-02-09T11:26:07Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Return value in std namespace.</comment>
      <text xml:space="preserve" bytes="1780">{{cpp/title| time}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
std::time_t time( std::time_t *time );
}}

Returns the current calendar time encoded as a {{lc|std::time_t}} object. 

===Parameters===
{{par begin}}
{{par | time | pointer to a {{lc|std::time_t}} object to store the time in or {{lc|NULL}}}}
{{par end}}

===Return value===
Current calendar time encoded as {{lc|std::time_t}} object on success, {{c|(std::time_t)(-1)}} on error. If the argument is not {{lc|NULL}}, the return value is also set to the object pointed by {{tt|time}}.

===Notes===
The encoding of calendar time in {{lc|std::time_t}} is unspecified, but most systems conform to [http://pubs.opengroup.org/onlinepubs/9699919799/functions/time.html POSIX specification] and return a value of integral type holding the number of seconds since [http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_15 the Epoch]. Implementations in which {{lc|std::time_t}} is a 32-bit signed integer (many historical implementations) fail in the year 2038.

===Example===
{{example
 |
 | code=
#include &lt;ctime&gt;
#include &lt;iostream&gt;

int main()
{
    std::time_t result = std::time(NULL);
    std::cout &lt;&lt; std::asctime(std::localtime(&amp;result))
              &lt;&lt; result &lt;&lt; &quot; seconds since the Epoch\n&quot;;
}
 | output=
Wed Sep 21 10:27:52 2011
1316615272 seconds since the Epoch
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc inc | cpp/chrono/dsc system_clock}}
{{dsc see c | c/chrono/time}}
{{dsc end}}

[[de:cpp/chrono/c/time]]
[[es:cpp/chrono/c/time]]
[[fr:cpp/chrono/c/time]]
[[it:cpp/chrono/c/time]]
[[ja:cpp/chrono/c/time]]
[[pt:cpp/chrono/c/time]]
[[ru:cpp/chrono/c/time]]
[[tr:cpp/chrono/c/time]]
[[zh:cpp/chrono/c/time]]</text>
      <sha1>9qc8nx55hbpnexhtb32htaonsqzb1jv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/time t</title>
    <ns>0</ns>
    <id>2841</id>
    <revision>
      <id>71720</id>
      <parentid>64072</parentid>
      <timestamp>2014-06-22T01:04:51Z</timestamp>
      <contributor>
        <username>Ashish20</username>
        <id>519</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="763">{{cpp/title|time_t}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime | 1=
typedef /* unspecified */ time_t;
}}
Arithmetic type capable of representing times.

Although not defined, this is almost always an integral value holding the number of seconds (not counting leap seconds) since 00:00, Jan 1 1970 UTC, corresponding to [[enwiki:Unix_time | POSIX time]].

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc time}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc see c | c/chrono/time_t}}
{{dsc end}}

[[de:cpp/chrono/c/time t]]
[[es:cpp/chrono/c/time t]]
[[fr:cpp/chrono/c/time t]]
[[it:cpp/chrono/c/time t]]
[[ja:cpp/chrono/c/time t]]
[[pt:cpp/chrono/c/time t]]
[[ru:cpp/chrono/c/time t]]
[[zh:cpp/chrono/c/time t]]</text>
      <sha1>p1h1ods777tufr1jz4z1rtb4n9l6wg4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/tm</title>
    <ns>0</ns>
    <id>2842</id>
    <revision>
      <id>66539</id>
      <parentid>66393</parentid>
      <timestamp>2013-12-03T19:32:48Z</timestamp>
      <contributor>
        <username>Roysc</username>
        <id>2387</id>
      </contributor>
      <comment>header=ctime</comment>
      <text xml:space="preserve" bytes="1779">{{cpp/title| tm}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=ctime |
struct tm;
}}

Structure holding a calendar date and time broken down into its components.

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_sec | seconds after the minute &amp;ndash; [0, 61]{{mark until c++11}} / [0, 60] {{mark since c++11}}&lt;ref name=&quot;leapsecond&quot; group=&quot;note&quot;&gt;Range allows for a positive leap second. Two leap seconds in the same minute are not allowed (the range 0..61 was a defect introduced in C89 and corrected in C99)&lt;/ref&gt;}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_min | minutes after the hour &amp;ndash; [0, 59]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_hour | hours since midnight &amp;ndash; [0, 23]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_mday | day of the month &amp;ndash; [1, 31]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_mon | months since January &amp;ndash; [0, 11]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_year | years since 1900}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_wday | days since Sunday &amp;ndash; [0, 6]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_yday | days since January 1 &amp;ndash; [0, 365]}}
{{dsc mem obj | nolink=true | {{dsc small|int}} tm_isdst | Daylight Saving Time flag. The value is positive if DST is in effect, zero if not and negative if no information is available}}
{{dsc end}}

======Notes======
&lt;references group=&quot;note&quot; /&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc see c | c/chrono/tm}}
{{dsc end}}

[[de:cpp/chrono/c/tm]]
[[es:cpp/chrono/c/tm]]
[[fr:cpp/chrono/c/tm]]
[[it:cpp/chrono/c/tm]]
[[ja:cpp/chrono/c/tm]]
[[pt:cpp/chrono/c/tm]]
[[ru:cpp/chrono/c/tm]]
[[zh:cpp/chrono/c/tm]]</text>
      <sha1>ohr5sg3crn1adhqmtp4cncun3h80oos</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/c/wcsftime</title>
    <ns>0</ns>
    <id>4647</id>
    <revision>
      <id>57190</id>
      <parentid>49362</parentid>
      <timestamp>2013-06-01T05:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1784">{{cpp/title| wcsftime}}
{{cpp/chrono/c/navbar}}
{{ddcl | header=cwchar |
std::size_t wcsftime( wchar_t* str, std::size_t count, const wchar_t* format, std::tm* time );
}}

Converts the date and time information from a given calendar time {{tt|time}} to a null-terminated wide character string {{tt|str}} according to format string {{tt|format}}. Up to {{tt|count}} bytes are written.

===Parameters===
{{par begin}}
{{par | str | pointer to the first element of the wchar_t array for output}}
{{par | count | maximum number of wide characters to write}}
{{par | format | pointer to a null-terminated wide character string specifying the format of conversion. 
{{cpp/chrono/c/strftime format}}
}}
{{par end}}

===Return value===
Number of wide characters written into the wide character array pointed to by {{tt|str}} not including the terminating {{c|L'\0'}} on success. If {{tt|count}} was reached before the entire string could be stored, {{c|0}} is returned and the contents are undefined.

===Example===
{{example
 |
 | code=
#include &lt;ctime&gt;
#include &lt;cwchar&gt;
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    std::time_t t = std::time(NULL);
    wchar_t wstr[100];
    if(std::wcsftime(wstr, 100, L&quot;%A %c&quot;, std::localtime(&amp;t))) {
        std::wcout &lt;&lt; wstr &lt;&lt; '\n';
    }
}
 | output=
火曜日 2011年12月27日 17時43分13秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc see c | c/chrono/wcsftime}}
{{dsc end}}

[[de:cpp/chrono/c/wcsftime]]
[[es:cpp/chrono/c/wcsftime]]
[[fr:cpp/chrono/c/wcsftime]]
[[it:cpp/chrono/c/wcsftime]]
[[ja:cpp/chrono/c/wcsftime]]
[[pt:cpp/chrono/c/wcsftime]]
[[ru:cpp/chrono/c/wcsftime]]
[[zh:cpp/chrono/c/wcsftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration</title>
    <ns>0</ns>
    <id>2714</id>
    <revision>
      <id>67404</id>
      <parentid>64389</parentid>
      <timestamp>2014-02-07T19:35:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>hidden comment attributing the &quot;only data..&quot; line just in case</comment>
      <text xml:space="preserve" bytes="4511">{{cpp/chrono/title|duration}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
template&lt;
    class Rep, 
    class Period = std::ratio&lt;1&gt; 
&gt; class duration;
}}
{{dcl end}}

Class template {{tt|std::chrono::duration}} represents a time interval. 

It consists of a count of ticks of type {{tt|Rep}} and a tick period, where the tick period is a compile-time rational constant representing the number of seconds from one tick to the next.

The only data stored in a {{tt|duration}} is a tick count of type {{tt|Rep}}.&lt;!-- per N2661, not actually in the standard wording --&gt;  If {{tt|Rep}} is floating point, then the {{tt|duration}} can represent fractions of ticks.  {{tt|Period}} is included as part of the duration's type, and is only used when converting between different durations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|rep}} | {{tt|Rep}}, an arithmetic type representing the number of ticks}}
{{dsc | {{tt|period}} | {{tt|Period}}, a {{lc|std::ratio}} representing the tick period (i.e. the number of seconds per tick)}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc inc | cpp/chrono/duration/dsc operator{{=}} }}
{{dsc inc | cpp/chrono/duration/dsc count }}
{{dsc inc | cpp/chrono/duration/dsc zero }}
{{dsc inc | cpp/chrono/duration/dsc min }}
{{dsc inc | cpp/chrono/duration/dsc max }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith2 }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith3 }}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc common_type}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4}}
{{dsc inc | cpp/chrono/duration/dsc operator_cmp}}
{{dsc inc | cpp/chrono/duration/dsc duration_cast }}
{{dsc end}}

===Helper types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{lc|std::chrono::nanoseconds}} | {{c|duration&lt;/*signed integer type of at least 64 bits*/, std::nano&gt; }} }}
{{dsc | {{lc|std::chrono::microseconds}} | {{c|duration&lt;/*signed integer type of at least 55 bits*/, std::micro&gt; }} }}
{{dsc | {{lc|std::chrono::milliseconds}} | {{c|duration&lt;/*signed integer type of at least 45 bits*/, std::milli&gt;}} }}
{{dsc | {{lc|std::chrono::seconds}} | {{c|duration&lt;/*signed integer type of at least 35 bits*/ &gt; }} }}
{{dsc | {{lc|std::chrono::minutes}} | {{c|duration&lt;/*signed integer type of at least 29 bits*/,std::ratio&lt;60&gt;&gt; }} }}
{{dsc | {{lc|std::chrono::hours}} | {{c|duration&lt;/*signed integer type of at least 23 bits*/, std::ratio&lt;3600&gt;&gt; }} }}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc tclass | cpp/chrono/treat_as_floating_point | indicates that a duration is convertible to duration with different tick period }}
{{dsc tclass | cpp/chrono/duration_values | constructs zero, min, and max values of a tick count of given type}}
{{dsc end}}

===Literals===
{{dsc begin}}
{{dsc namespace | std::literals::chrono_literals | inline=true }}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;h}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;min}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;s}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;ms}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;us}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;ns}}
{{dsc end}}


===Example===
{{example
 | This example shows how to define several custom duration types and convert between types:
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    typedef std::chrono::duration&lt;int, std::ratio&lt;1, 100000000&gt;&gt; shakes;
    typedef std::chrono::duration&lt;int, std::centi&gt; jiffies;
    typedef std::chrono::duration&lt;float, std::ratio&lt;12096,10000&gt;&gt; microfortnights;
    typedef std::chrono::duration&lt;float, std::ratio&lt;3155,1000&gt;&gt; nanocenturies;

    std::chrono::seconds sec(1);

    std::cout &lt;&lt; &quot;1 second is:\n&quot;;

    std::cout &lt;&lt; std::chrono::duration_cast&lt;shakes&gt;(sec).count()
              &lt;&lt; &quot; shakes\n&quot;;
    std::cout &lt;&lt; std::chrono::duration_cast&lt;jiffies&gt;(sec).count()
              &lt;&lt; &quot; jiffies\n&quot;;
    std::cout &lt;&lt; microfortnights(sec).count() &lt;&lt; &quot; microfortnights\n&quot;;
    std::cout &lt;&lt; nanocenturies(sec).count() &lt;&lt; &quot; nanocenturies\n&quot;;
}
 | output=
1 second is:
100000000 shakes
100 jiffies
0.82672 microfortnights
0.316957 nanocenturies
}}

[[de:cpp/chrono/duration]]
[[es:cpp/chrono/duration]]
[[fr:cpp/chrono/duration]]
[[it:cpp/chrono/duration]]
[[ja:cpp/chrono/duration]]
[[pt:cpp/chrono/duration]]
[[ru:cpp/chrono/duration]]
[[zh:cpp/chrono/duration]]</text>
      <sha1>g52utszpnp0a4tcayhgb3tg7jdig3za</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/common type</title>
    <ns>0</ns>
    <id>8666</id>
    <revision>
      <id>64318</id>
      <parentid>63279</parentid>
      <timestamp>2013-08-15T17:31:08Z</timestamp>
      <contributor>
        <ip>77.119.0.205</ip>
      </contributor>
      <comment>Grammar fix</comment>
      <text xml:space="preserve" bytes="1877">{{cpp/title|common_type&lt;small&gt;(std::chrono::duration)&lt;/small&gt;}}
{{cpp/chrono/duration/navbar}}
{{ddcl | since=c++11 |
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
struct common_type&lt;std::chrono::duration&lt;Rep1, Period1&gt;,
                   std::chrono::duration&lt;Rep2, Period2&gt;&gt; {
    typedef std::chrono::duration&lt;
        typename std::common_type&lt;Rep1, Rep2&gt;::type, /*see note*/&gt; type;
};
}}

Exposes the type named {{tt|type}}, which is the common type of two {{lc|std::chrono::duration}}s.

===Note===

The period of the resulting duration is the greatest common divisor of {{tt|Period1}} and {{tt|Period2}}.

{{c|std::common_type&lt;&gt;}} is specialized for {{tt|std::chrono::duration}}.

===Example===

{{example
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

// std::chrono already finds the greatest common divisor,
// likely using std::common_type&lt;&gt;. We make the type
// deduction externally. 

template &lt;typename T,typename S&gt;
auto durationDiff(const T&amp; t, const S&amp; s)  -&gt; typename std::common_type&lt;T,S&gt;::type
{
    typedef typename std::common_type&lt;T,S&gt;::type Common;
    return Common(t) - Common(s);
}


int main() 
{
    typedef std::chrono::milliseconds milliseconds;
    typedef std::chrono::microseconds microseconds;
    
    auto ms = milliseconds(30);
    auto us = microseconds(1100);
    
    std::cout &lt;&lt; ms.count() &lt;&lt; &quot;ms - &quot; &lt;&lt; us.count() &lt;&lt; &quot;us = &quot; 
              &lt;&lt; durationDiff(ms,us).count() &lt;&lt;  &quot;\n&quot;;
}
 | output=
30ms - 1100us = 28900
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc common_type}}
{{dsc end}}

[[de:cpp/chrono/duration/common type]]
[[es:cpp/chrono/duration/common type]]
[[fr:cpp/chrono/duration/common type]]
[[it:cpp/chrono/duration/common type]]
[[ja:cpp/chrono/duration/common type]]
[[pt:cpp/chrono/duration/common type]]
[[ru:cpp/chrono/duration/common type]]
[[zh:cpp/chrono/duration/common type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/count</title>
    <ns>0</ns>
    <id>8632</id>
    <revision>
      <id>57197</id>
      <parentid>49365</parentid>
      <timestamp>2013-06-01T05:49:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1296">{{cpp/chrono/duration/title | count }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl |
constexpr rep count() const;
}}
{{dcl end}}

Returns the number of ticks for this duration.

===Parameters===
(none)

===Return value===
The number of ticks for this duration.

===Example===
{{example 
|
| code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;
int main()
{
    std::chrono::milliseconds ms{3}; // 3 milliseconds
    // 6000 microseconds constructed from 3 milliseconds
    std::chrono::microseconds us = 2*ms;
    // 30Hz clock using fractional ticks
    std::chrono::duration&lt;double, std::ratio&lt;1, 30&gt;&gt; hz30(3.5);

    std::cout &lt;&lt;  &quot;3 ms duration has &quot; &lt;&lt; ms.count() &lt;&lt; &quot; ticks\n&quot;
              &lt;&lt;  &quot;6000 us duration has &quot; &lt;&lt; us.count() &lt;&lt; &quot; ticks\n&quot;
              &lt;&lt;  &quot;3.5 30Hz duration has &quot; &lt;&lt; hz30.count() &lt;&lt; &quot; ticks\n&quot;;       
}
| output=
3 ms duration has 3 ticks
6000 us duration has 6000 ticks
3.5 30Hz duration has 3.5 ticks
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc duration_cast }}
{{dsc end}}

[[de:cpp/chrono/duration/count]]
[[es:cpp/chrono/duration/count]]
[[fr:cpp/chrono/duration/count]]
[[it:cpp/chrono/duration/count]]
[[ja:cpp/chrono/duration/count]]
[[pt:cpp/chrono/duration/count]]
[[ru:cpp/chrono/duration/count]]
[[zh:cpp/chrono/duration/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/duration</title>
    <ns>0</ns>
    <id>8620</id>
    <revision>
      <id>64407</id>
      <parentid>63266</parentid>
      <timestamp>2013-08-16T03:22:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>LWG #2094</comment>
      <text xml:space="preserve" bytes="3169">{{cpp/chrono/duration/title | duration}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
constexpr duration() {{=}} default;
}}
{{dcl | num=2 | since=c++11 |
duration( const duration&amp; ) {{=}} default;
}}
{{dcl | num=3 | since=c++11 |
template&lt; class Rep2 &gt;
constexpr explicit duration( const Rep2&amp; r );
}}
{{dcl | num=4 | since=c++11 |
template&lt; class Rep2, class Period2 &gt;
constexpr duration( const duration&lt;Rep2,Period2&gt;&amp; d );
}}
{{dcl end}}

Constructs a new {{tt|duration}} from one of several optional data sources.

@1@ The default constructor is defaulted.

@2@ The copy constructor  is defaulted (makes a bitwise copy of the tick count).

@3@ Constructs a duration with {{tt|r}} ticks.  Note that this constructor only participates in overload resolution if {{tt|Rep2}} (the argument type) is implicitly convertible to {{tt|rep}} (the type of this duration's ticks) and

::* {{c|std::chrono::treat_as_floating_point&lt;rep&gt;::value}} is true, or
::* {{c|std::chrono::treat_as_floating_point&lt;Rep2&gt;::value}} is false.

@@(that is, a duration with an integer tick count cannot be constructed from a floating-point value, but a duration with a floating-point tick count can be constructed from an integer value)

@4@ Constructs a duration by converting {{tt|d}} to an appropriate period and tick count, as if by {{c|std::chrono::duration_cast&lt;duration&gt;(d).count()}}.  In order to prevent truncation during conversion, this constructor only participates in overload resolution if no overflow is induced by conversion and:

::* {{c|std::chrono::treat_as_floating_point&lt;rep&gt;::value {{==}} true}}

@@ or both: 

::* {{c|std::ratio_divide&lt;Period2, period&gt;::den {{==}} 1}}, and  
::* {{c|std::chrono::treat_as_floating_point&lt;Rep2&gt;::value {{==}} false}}.

@@ (that is, either the duration uses floating-point ticks, or {{tt|Period2}} is exactly divisible by period)

===Parameters===
{{par begin}}
{{par | r  | a tick count}}
{{par | d  | a duration to copy from}}
{{par end}}

===Example===
{{example
 | The following code shows several examples (both valid and invalid) of how to construct durations:
 | code=
#include &lt;chrono&gt;
int main()
{
    std::chrono::hours h(1); // one hour
    std::chrono::milliseconds ms{3}; // 3 milliseconds
    std::chrono::duration&lt;int, std::kilo&gt; ks(3); // 3000 seconds

    // error: treat_as_floating_point&lt;int&gt;::value == false,
    // This duration allows whole tick counts only
//  std::chrono::duration&lt;int, std::kilo&gt; d3(3.5);

    // 30Hz clock using fractional ticks
    std::chrono::duration&lt;double, std::ratio&lt;1, 30&gt;&gt; hz30(3.5);

    // 3000 microseconds constructed from 3 milliseconds
    std::chrono::microseconds us = ms;
    // error: 1/1000000 is not divisible by 1/1000
//  std::chrono::milliseconds ms2 = us
}
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator{{=}} }}
{{dsc end}}

[[de:cpp/chrono/duration/duration]]
[[es:cpp/chrono/duration/duration]]
[[fr:cpp/chrono/duration/duration]]
[[it:cpp/chrono/duration/duration]]
[[ja:cpp/chrono/duration/duration]]
[[pt:cpp/chrono/duration/duration]]
[[ru:cpp/chrono/duration/duration]]
[[zh:cpp/chrono/duration/duration]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/duration cast</title>
    <ns>0</ns>
    <id>5053</id>
    <revision>
      <id>63280</id>
      <parentid>49367</parentid>
      <timestamp>2013-07-10T01:27:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2015">{{cpp/chrono/title|duration_cast}}
{{cpp/chrono/duration/navbar}}
{{ddcl | since=c++11 |
template &lt;class ToDuration, class Rep, class Period&gt;
constexpr ToDuration duration_cast(const duration&lt;Rep,Period&gt;&amp; d);
}}
Converts a {{lc|std::chrono::duration}} to a duration of different type {{tt|ToDuration}}.

No implicit conversions are used. Multiplications and divisions are avoided where possible, if it is known at compile time that one or more parameters are {{c|1}}. Computations are done in the widest type available and converted to the result type only when finished.

===Parameters===
{{par begin}}
{{par | d | duration to convert}}
{{par end}}

===Return value===
{{tt|d}} converted to a duration of type {{tt|ToDuration}}.

===Notes===
The function does not participate in the overload resolution unless {{tt|ToDuration}} is an instance of {{lc|std::chrono::duration}}.

Casting between floating-point durations or between integer durations where the source period is exactly divisible by the target period (e.g. hours to minutes) can be performed [[cpp/chrono/duration/duration|implicitly]], no {{c|duration_cast}} is needed.

===Example===
{{example
 | This example measures the execution time of a function
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;

void f()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    auto t1 = std::chrono::high_resolution_clock::now();
    f();
    auto t2 = std::chrono::high_resolution_clock::now();
    std::cout &lt;&lt; &quot;f() took &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(t2 - t1).count()
              &lt;&lt; &quot; milliseconds\n&quot;;
}
 | output=
f() took 1000 milliseconds
}}

[[de:cpp/chrono/duration/duration cast]]
[[es:cpp/chrono/duration/duration cast]]
[[fr:cpp/chrono/duration/duration cast]]
[[it:cpp/chrono/duration/duration cast]]
[[ja:cpp/chrono/duration/duration cast]]
[[pt:cpp/chrono/duration/duration cast]]
[[ru:cpp/chrono/duration/duration cast]]
[[zh:cpp/chrono/duration/duration cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/max</title>
    <ns>0</ns>
    <id>8636</id>
    <revision>
      <id>57201</id>
      <parentid>49368</parentid>
      <timestamp>2013-06-01T05:49:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="898">{{cpp/chrono/duration/title | max }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl |
static constexpr duration max();
}}
{{dcl end}}

Returns a duration with the largest possible value.

If the representation {{tt|rep}} of the duration requires some other implementation to return a maximum-length duration, {{lc|std::chrono::duration_values}} can be specialized to return the desired value.

===Parameters===
(none)

===Return value===
returns {{c|std::chrono::duration(std::chrono::duration_values&lt;rep&gt;::max()) }}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc zero }}
{{dsc inc | cpp/chrono/duration/dsc min }}
{{dsc end}}

[[de:cpp/chrono/duration/max]]
[[es:cpp/chrono/duration/max]]
[[fr:cpp/chrono/duration/max]]
[[it:cpp/chrono/duration/max]]
[[ja:cpp/chrono/duration/max]]
[[pt:cpp/chrono/duration/max]]
[[ru:cpp/chrono/duration/max]]
[[zh:cpp/chrono/duration/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/min</title>
    <ns>0</ns>
    <id>8635</id>
    <revision>
      <id>57202</id>
      <parentid>49369</parentid>
      <timestamp>2013-06-01T05:49:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="897">{{cpp/chrono/duration/title | min }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl |
static constexpr duration min();
}}
{{dcl end}}

Returns a duration with the lowest possible value.

If the representation {{tt|rep}} of the duration requires some other implementation to return a minimum-length duration, {{lc|std::chrono::duration_values}} can be specialized to return the desired value.

===Parameters===
(none)

===Return value===
returns {{c|std::chrono::duration(std::chrono::duration_values&lt;rep&gt;::min()) }}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc zero }}
{{dsc inc | cpp/chrono/duration/dsc max }}
{{dsc end}}

[[de:cpp/chrono/duration/min]]
[[es:cpp/chrono/duration/min]]
[[fr:cpp/chrono/duration/min]]
[[it:cpp/chrono/duration/min]]
[[ja:cpp/chrono/duration/min]]
[[pt:cpp/chrono/duration/min]]
[[ru:cpp/chrono/duration/min]]
[[zh:cpp/chrono/duration/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator=</title>
    <ns>0</ns>
    <id>8631</id>
    <revision>
      <id>63264</id>
      <parentid>57203</parentid>
      <timestamp>2013-07-08T11:18:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="734">{{cpp/chrono/duration/title | operator{{=}} }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
duration&amp; operator{{=}}( const duration &amp;other ) {{=}} default;
}}
{{dcl end}}

Assigns the contents of one {{tt|duration}} to another.

===Parameters===
{{par begin}}
{{par | other  | {{tt|duration}} to copy from}}
{{par end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor }}
{{dsc end}}

[[de:cpp/chrono/duration/operator=]]
[[es:cpp/chrono/duration/operator=]]
[[fr:cpp/chrono/duration/operator=]]
[[it:cpp/chrono/duration/operator=]]
[[ja:cpp/chrono/duration/operator=]]
[[pt:cpp/chrono/duration/operator=]]
[[ru:cpp/chrono/duration/operator=]]
[[zh:cpp/chrono/duration/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator arith</title>
    <ns>0</ns>
    <id>9407</id>
    <revision>
      <id>57206</id>
      <parentid>49371</parentid>
      <timestamp>2013-06-01T05:49:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1418">{{cpp/chrono/duration/title | operator+{{dsc small|(unary)}} | operator-{{dsc small|(unary)}} }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 |
constexpr duration operator+() const;
}}
{{dcl | num=2 |
constexpr duration operator-() const;
}}
{{dcl end}}

Implements unary plus and unary minus for the durations.

If {{tt|rep_}} is a member variable holding the number of ticks in a duration object, 
@1@ Equivalent to {{c|return *this;}}
@2@ Equivalent to {{c|return duration(-rep_);}}

===Parameters===
(none)

===Return value===
@1@ a copy of this duration object
@2@ a copy of this duration object, with the number of ticks negated

===Example===
{{example 
|
| code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;

int main()
{
    std::chrono::seconds s1(10);
    std::chrono::seconds s2 = -s1;

    std::cout &lt;&lt; &quot;negated 10 seconds are &quot; &lt;&lt; s2.count() &lt;&lt; &quot; seconds\n&quot;;
}
| output=
negated 10 seconds are -10 seconds
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith2 }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4 }}
{{dsc end}}

[[de:cpp/chrono/duration/operator arith]]
[[es:cpp/chrono/duration/operator arith]]
[[fr:cpp/chrono/duration/operator arith]]
[[it:cpp/chrono/duration/operator arith]]
[[ja:cpp/chrono/duration/operator arith]]
[[pt:cpp/chrono/duration/operator arith]]
[[ru:cpp/chrono/duration/operator arith]]
[[zh:cpp/chrono/duration/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator arith2</title>
    <ns>0</ns>
    <id>9404</id>
    <revision>
      <id>57207</id>
      <parentid>49372</parentid>
      <timestamp>2013-06-01T05:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1512">{{cpp/chrono/duration/title | operator++ | operator-- }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 |
duration&amp; operator++();
}}
{{dcl | num=2 |
duration operator++(int);
}}
{{dcl | num=3 |
duration&amp; operator--();
}}
{{dcl | num=4 |
duration operator--(int);
}}
{{dcl end}}

Increments or decrements the number of ticks for this duration.

If {{tt|rep_}} is a member variable holding the number of ticks in a duration object, 
@1@ Equivalent to {{c|++rep_; return *this;}}
@2@ Equivalent to {{c|return duration(rep_++)}}
@3@ Equivalent to {{c|--rep_; return *this;}}
@4@ Equivalent to {{c|return duration(rep_--);}}

===Parameters===
(none)

===Return value===
@1,3@ a reference to this duration after modification
@2,4@ a copy of the duration made before modification

===Example===
{{example 
|
| code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;

int main()
{
    std::chrono::hours h(1);
    std::chrono::minutes m = ++h;
    m--;
    std::cout &lt;&lt; m.count() &lt;&lt; &quot; minutes\n&quot;;
}
| output=
119 minutes
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith3 }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4 }}
{{dsc end}}

[[de:cpp/chrono/duration/operator arith2]]
[[es:cpp/chrono/duration/operator arith2]]
[[fr:cpp/chrono/duration/operator arith2]]
[[it:cpp/chrono/duration/operator arith2]]
[[ja:cpp/chrono/duration/operator arith2]]
[[pt:cpp/chrono/duration/operator arith2]]
[[ru:cpp/chrono/duration/operator arith2]]
[[zh:cpp/chrono/duration/operator arith2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator arith3</title>
    <ns>0</ns>
    <id>9405</id>
    <revision>
      <id>57210</id>
      <parentid>49373</parentid>
      <timestamp>2013-06-01T05:49:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2309">{{cpp/chrono/duration/title | operator+{{=}}, -{{=}}, *{{=}}, /{{=}}, %{{=}}}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 |
duration&amp; operator+{{=}}(const duration&amp; d);
}}
{{dcl | num=2 |
duration&amp; operator-{{=}}(const duration&amp; d);
}}
{{dcl | num=3 |
duration&amp; operator*{{=}}(const rep&amp; rhs);
}}
{{dcl | num=4 |
duration&amp; operator/{{=}}(const rep&amp; rhs);
}}
{{dcl | num=5 |
duration&amp; operator%{{=}}(const rep&amp; rhs);
}}
{{dcl | num=6 |
duration&amp; operator%{{=}}(const duration&amp; rhs);
}}
{{dcl end}}

Performs compound assignments between two durations with the same period or between a duration and a tick count value.

If {{tt|rep_}} is the member variable holding the number of ticks in this duration object,
@1@ Equivalent to {{c|rep_ +{{=}} d.count(); return *this;}}
@2@ Equivalent to {{c|rep_ -{{=}} d.count(); return *this;}}
@3@ Equivalent to {{c|rep_ *{{=}} rhs; return *this;}}
@4@ Equivalent to {{c|rep_ /{{=}} rhs; return *this;}}
@5@ Equivalent to {{c|rep_ %{{=}} rhs; return *this;}}
@6@ Equivalent to {{c|rep_ %{{=}} d.count(); return *this;}}

===Parameters===
{{par begin}}
{{par | d | duration on the right-hand side of the operator}}
{{par | rhs | number of ticks on the right-hand side of the operator}}
{{par end}}

===Return value===
A reference to this duration after modification

===Example===
{{example 
|
| code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;

int main()
{
    std::chrono::minutes m(11);
    m *= 2;
    m += std::chrono::hours(10); // hours implicitly convert to minutes
    std::cout &lt;&lt; m.count() &lt;&lt; &quot; minutes equals &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::hours&gt;(m).count() 
              &lt;&lt; &quot; hours and &quot;;
    m %= std::chrono::hours(1);
    std::cout &lt;&lt; m.count() &lt;&lt; &quot; minutes\n&quot;;
}
| output=
622 minutes equals 10 hours and 22 minutes
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith2 }}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4 }}
{{dsc end}}

[[de:cpp/chrono/duration/operator arith3]]
[[es:cpp/chrono/duration/operator arith3]]
[[fr:cpp/chrono/duration/operator arith3]]
[[it:cpp/chrono/duration/operator arith3]]
[[ja:cpp/chrono/duration/operator arith3]]
[[pt:cpp/chrono/duration/operator arith3]]
[[ru:cpp/chrono/duration/operator arith3]]
[[zh:cpp/chrono/duration/operator arith3]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator arith4</title>
    <ns>0</ns>
    <id>9399</id>
    <revision>
      <id>49374</id>
      <parentid>46325</parentid>
      <timestamp>2013-06-01T02:34:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="6181">{{title | 1=operator+,-,*,/,%&lt;small&gt;(std::chrono::duration)&lt;/small&gt;}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class Rep1, class Period1, class Rep2, class Period2 &gt;
typename std::common_type&lt;duration&lt;Rep1,Period1&gt;, duration&lt;Rep2,Period2&gt;&gt;::type
    constexpr operator+( const duration&lt;Rep1,Period1&gt;&amp; lhs,
                         const duration&lt;Rep2,Period2&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class Rep1, class Period1, class Rep2, class Period2 &gt;
typename std::common_type&lt;duration&lt;Rep1,Period1&gt;, duration&lt;Rep2,Period2&gt;&gt;::type
    constexpr operator-( const duration&lt;Rep1,Period1&gt;&amp; lhs,
                         const duration&lt;Rep2,Period2&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; class Rep1, class Period, class Rep2 &gt;
duration&lt;typename std::common_type&lt;Rep1,Rep2&gt;::type, Period&gt;
    constexpr operator*( const duration&lt;Rep1,Period&gt;&amp; d,
                         const Rep2&amp; s );
}}
{{dcl | num=4 | 1=
template&lt; class Rep1, class Rep2, class Period &gt;
duration&lt;typename std::common_type&lt;Rep1,Rep2&gt;::type, Period&gt;
    constexpr operator*( const Rep1&amp; s,
                         const duration&lt;Rep2,Period&gt;&amp; d );
}}
{{dcl | num=5 | 1=
template&lt; class Rep1, class Period, class Rep2 &gt;
duration&lt;typename common_type&lt;Rep1,Rep2&gt;::type, Period&gt;
    constexpr operator/( const duration&lt;Rep1,Period&gt;&amp; d,
                         const Rep2&amp; s );
}}
{{dcl | num=6 | 1=
template&lt; class Rep1, class Period1, class Rep2, class Period2 &gt;
typename std::common_type&lt;Rep1,Rep2&gt;::type
    constexpr operator/( const duration&lt;Rep1,Period1&gt;&amp; lhs,
                         const duration&lt;Rep2,Period2&gt;&amp; rhs );
}}
{{dcl | num=7 | 1=
template&lt; class Rep1, class Period, class Rep2 &gt;
duration&lt;typename common_type&lt;Rep1,Rep2&gt;::type, Period&gt;
    constexpr operator%( const duration&lt;Rep1, Period&gt;&amp; d,
                         const Rep2&amp; s );
}}
{{dcl | num=8 | 1=
template&lt; class Rep1, class Period1, class Rep2, class Period2 &gt;
typename common_type&lt;duration&lt;Rep1,Period1&gt;, duration&lt;Rep2,Period2&gt;&gt;::type
constexpr operator%( const duration&lt;Rep1,Period1&gt;&amp; lhs,
                     const duration&lt;Rep2,Period2&gt;&amp; rhs );
}}
{{dcl end}}

Performs basic arithmetic operations between two durations or between a duration and a tick count.

@1@ Converts the two durations to their common type and creates a duration whose tick count is the sum of the tick counts after conversion.

@2@ Converts the two durations to their common type and creates a duration whose tick count is the {{tt|rhs}} number of ticks subtracted from the {{tt|lhs}} number of ticks after conversion.

@3-4@ Converts the duration {{tt|d}} to one whose {{tt|rep}} is the common type between {{tt|Rep1}} and {{tt|Rep2}}, and multiples the number of ticks after conversion by {{tt|s}}.

@5@ Converts the duration {{tt|d}} to one whose {{tt|rep}} is the common type between {{tt|Rep1}} and {{tt|Rep2}}, and divides the number of ticks after conversion by {{tt|s}}

@6@ Converts the two durations to their common type and divides the tick count of {{tt|lhs}} after conversion by the tick count of {{tt|rhs}} after conversion. Note that the return value of this operator is not a duration.

@7@ Converts the duration {{tt|d}} to one whose {{tt|rep}} is the common type between {{tt|Rep1}} and {{tt|Rep2}}, and creates a duration whose tick count is the remainder of the division of the tick count, after conversion, by {{tt|s}}.

@8@ Converts the two durations to their common type and creates a duration whose tick count is the remainder of the tick counts after conversion.

===Parameters===
{{par begin}}
{{par | lhs | duration on the left-hand side of the operator}}
{{par | rhs | duration on the right-hand side of the operator}}
{{par | d | the duration argument for mixed-argument operators}}
{{par | s | tick count argument for mixed-argument operators}}
{{par end}}

===Return value===
Assuming that {{c|CD}} is the function return type and {{c|CR&lt;A, B&gt; {{=}} std::common_type&lt;A, B&gt;::type}}, then:

@1@ {{c|CD(CD(lhs).count() + CD(rhs).count())}}
@2@ {{c|CD(CD(lhs).count() - CD(rhs).count())}}
@3-4@ {{c|CD(CD(d).count() * s)}} 
@5@ {{c|CD(CD(d).count() / s).}}
@6@ {{c|CD(lhs).count() / CD(rhs).count()}}  (the return type of this operator is not a duration)
@7@ {{c|CD(CD(d).count() % s)}}
@8@ {{c|CD(CD(lhs).count() % CD(rhs).count())}}


===Example===
{{example
 | code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;
int main()
{
    // simple arithmetic
    std::chrono::seconds s = std::chrono::hours(1) 
                             + 2*std::chrono::minutes(10)
                             + std::chrono::seconds(70)/10;

    std::cout &lt;&lt; &quot;1 hour + 2*10 min + 70/10 sec = &quot; &lt;&lt; s.count() &lt;&lt; &quot; seconds\n&quot;;

    // difference between dividing a duration by a number
    // and dividing a duration by another duration
    std::cout &lt;&lt; &quot;Dividing that by 2 minutes gives &quot;
              &lt;&lt; s / std::chrono::minutes(2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;Dividing that by 2 gives &quot;
              &lt;&lt; (s / 2).count() &lt;&lt; &quot; seconds\n&quot;;

   // the remainder operator is useful in determining where in a time
   // frame is this particular duration, e.g. to break it down into hours,
   // minutes, and seconds:
   std::cout &lt;&lt; s.count() &lt;&lt; &quot; seconds is &quot;
             &lt;&lt; std::chrono::duration_cast&lt;std::chrono::hours&gt;(
                    s
                ).count() &lt;&lt; &quot; hours, &quot;
             &lt;&lt; std::chrono::duration_cast&lt;std::chrono::minutes&gt;(
                    s % std::chrono::hours(1)
                ).count() &lt;&lt; &quot; minutes, &quot;
             &lt;&lt; std::chrono::duration_cast&lt;std::chrono::seconds&gt;(
                    s % std::chrono::minutes(1)
                ).count() &lt;&lt; &quot; seconds\n&quot;;
}
 | output=
1 hour + 2*10 min + 70/10 sec = 4807 seconds
Dividing that by 2 minutes gives 40
Dividing that by 2 gives 2403 seconds
4807 seconds is 1 hours, 20 minutes, 7 seconds
}}

[[de:cpp/chrono/duration/operator arith4]]
[[es:cpp/chrono/duration/operator arith4]]
[[fr:cpp/chrono/duration/operator arith4]]
[[it:cpp/chrono/duration/operator arith4]]
[[ja:cpp/chrono/duration/operator arith4]]
[[pt:cpp/chrono/duration/operator arith4]]
[[ru:cpp/chrono/duration/operator arith4]]
[[zh:cpp/chrono/duration/operator arith4]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/operator cmp</title>
    <ns>0</ns>
    <id>8668</id>
    <revision>
      <id>49375</id>
      <parentid>42429</parentid>
      <timestamp>2013-06-01T02:34:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2967">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::chrono::duration)&lt;/small&gt;}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator{{==}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                          const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl | num=2 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator!{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                          const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl | num=3 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator&lt;(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                         const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl | num=4 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator&lt;{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                          const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl | num=5 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator&gt;(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                         const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl | num=6 | 1=
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
constexpr bool operator&gt;{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                          const duration&lt;Rep2, Period2&gt;&amp; rhs);
}}
{{dcl end}}

Compares two durations.

1-2) Checks if {{tt|lhs}} and {{tt|rhs}} are equal, i.e. the number of ticks for the type common to both durations are equal.

3-6) Compares {{tt|lhs}} to {{tt|rhs}}, i.e. compares the number of ticks for the type common to both durations.

===Parameters===
{{par begin}}
{{par | lhs | duration on the left-hand side of the operator}}
{{par | rhs | duration on the right-hand side of the operator}}
{{par end}}

===Return value===
Assuming that {{c|CT {{=}}
std::common_type&lt;std::chrono::duration&lt;Rep1, Period1&gt;,
                 std::chrono::duration&lt;Rep2, Period2&gt;&gt;::type}}, then:

1) {{c|CT(lhs).count() {{==}} CT(rhs).count()}}

2) {{c|!(lhs {{==}} rhs)}}

3) {{c|CT(lhs).count() &lt; CT(rhs).count()}}

4) {{c|!(rhs &lt; lhs)}}

5) {{c|rhs &lt; lhs}}

6) {{c|!(lhs &lt; rhs)}}

===Example===
{{example
 | code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;
int main()
{
    if(std::chrono::seconds(2) == std::chrono::milliseconds(2000))
        std::cout &lt;&lt;  &quot;2 s == 2000 ms\n&quot;;
    else
        std::cout &lt;&lt;  &quot;2 s != 2000 ms\n&quot;;

    if(std::chrono::seconds(61) &gt; std::chrono::minutes(1))
        std::cout &lt;&lt;  &quot;61 s &gt; 1 min\n&quot;;
    else
        std::cout &lt;&lt;  &quot;61 s &lt;= 1 min\n&quot;;

}
 | output=
2 s == 2000 ms
61 s &gt; 1 min
}}

[[de:cpp/chrono/duration/operator cmp]]
[[es:cpp/chrono/duration/operator cmp]]
[[fr:cpp/chrono/duration/operator cmp]]
[[it:cpp/chrono/duration/operator cmp]]
[[ja:cpp/chrono/duration/operator cmp]]
[[pt:cpp/chrono/duration/operator cmp]]
[[ru:cpp/chrono/duration/operator cmp]]
[[zh:cpp/chrono/duration/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration/zero</title>
    <ns>0</ns>
    <id>8634</id>
    <revision>
      <id>57211</id>
      <parentid>49376</parentid>
      <timestamp>2013-06-01T05:49:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="885">{{cpp/chrono/duration/title | zero }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl |
static constexpr duration zero();
}}
{{dcl end}}

Returns a zero-length duration.

If the representation {{tt|rep}} of the duration requires some other implementation to return a zero-length duration, {{lc|std::chrono::duration_values}} can be specialized to return the desired value.

===Parameters===
(none)

===Return value===
returns {{c|std::chrono::duration(std::chrono::duration_values&lt;rep&gt;::zero()) }}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc min }}
{{dsc inc | cpp/chrono/duration/dsc max }}
{{dsc end}}

[[de:cpp/chrono/duration/zero]]
[[es:cpp/chrono/duration/zero]]
[[fr:cpp/chrono/duration/zero]]
[[it:cpp/chrono/duration/zero]]
[[ja:cpp/chrono/duration/zero]]
[[pt:cpp/chrono/duration/zero]]
[[ru:cpp/chrono/duration/zero]]
[[zh:cpp/chrono/duration/zero]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration values</title>
    <ns>0</ns>
    <id>8640</id>
    <revision>
      <id>62683</id>
      <parentid>57212</parentid>
      <timestamp>2013-07-01T23:32:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1195">{{cpp/chrono/title|duration_values}}
{{cpp/chrono/duration_values/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
template &lt;class Rep&gt;
struct duration_values;
}}
{{dcl end}}

The {{tt|std::chrono::duration_values}} type defines three common durations:

* {{c|std::chrono::duration_values::zero}}
* {{c|std::chrono::duration_values::min}}
* {{c|std::chrono::duration_values::max}}

The [[cpp/chrono/duration/zero|zero]], [[cpp/chrono/duration/min|min]], and [[cpp/chrono/duration/max|max]] methods in {{lc|std::chrono::duration}} forward their work to these methods.

This type can be specialized if the representation {{tt|Rep}} requires a specific implementation to return these duration objects.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration_values/dsc zero }}
{{dsc inc | cpp/chrono/duration_values/dsc min }}
{{dsc inc | cpp/chrono/duration_values/dsc max }}
{{dsc end}}

[[de:cpp/chrono/duration values]]
[[es:cpp/chrono/duration values]]
[[fr:cpp/chrono/duration values]]
[[it:cpp/chrono/duration values]]
[[ja:cpp/chrono/duration values]]
[[pt:cpp/chrono/duration values]]
[[ru:cpp/chrono/duration values]]
[[zh:cpp/chrono/duration values]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration values/max</title>
    <ns>0</ns>
    <id>8643</id>
    <revision>
      <id>57215</id>
      <parentid>49378</parentid>
      <timestamp>2013-06-01T05:49:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="774">{{cpp/chrono/duration_values/title | max }}
{{cpp/chrono/duration_values/navbar}}
{{dcl begin}}
{{dcl |
static constexpr Rep max();
}}
{{dcl end}}

Returns the largest possible representation.

===Parameters===
(none)

===Return value===
returns {{c|std::numeric_limits&lt;Rep&gt;::max()}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc max }}
{{dsc inc | cpp/chrono/duration_values/dsc zero }}
{{dsc inc | cpp/chrono/duration_values/dsc min }}
{{dsc end}}

[[de:cpp/chrono/duration values/max]]
[[es:cpp/chrono/duration values/max]]
[[fr:cpp/chrono/duration values/max]]
[[it:cpp/chrono/duration values/max]]
[[ja:cpp/chrono/duration values/max]]
[[pt:cpp/chrono/duration values/max]]
[[ru:cpp/chrono/duration values/max]]
[[zh:cpp/chrono/duration values/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration values/min</title>
    <ns>0</ns>
    <id>8642</id>
    <revision>
      <id>57216</id>
      <parentid>49379</parentid>
      <timestamp>2013-06-01T05:49:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="776">{{cpp/chrono/duration_values/title | min }}
{{cpp/chrono/duration_values/navbar}}
{{dcl begin}}
{{dcl |
static constexpr Rep min();
}}
{{dcl end}}

Returns the lowest possible representation.

===Parameters===
(none)

===Return value===
returns {{c|std::numeric_limits&lt;Rep&gt;::lowest()}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc min }}
{{dsc inc | cpp/chrono/duration_values/dsc zero }}
{{dsc inc | cpp/chrono/duration_values/dsc max }}
{{dsc end}}

[[de:cpp/chrono/duration values/min]]
[[es:cpp/chrono/duration values/min]]
[[fr:cpp/chrono/duration values/min]]
[[it:cpp/chrono/duration values/min]]
[[ja:cpp/chrono/duration values/min]]
[[pt:cpp/chrono/duration values/min]]
[[ru:cpp/chrono/duration values/min]]
[[zh:cpp/chrono/duration values/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/duration values/zero</title>
    <ns>0</ns>
    <id>8641</id>
    <revision>
      <id>57217</id>
      <parentid>49380</parentid>
      <timestamp>2013-06-01T05:49:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="752">{{cpp/chrono/duration_values/title | zero }}
{{cpp/chrono/duration_values/navbar}}
{{dcl begin}}
{{dcl |
static constexpr Rep zero();
}}
{{dcl end}}

Returns a zero-length representation.

===Parameters===
(none)

===Return value===
returns {{c|Rep(0)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc zero }}
{{dsc inc | cpp/chrono/duration_values/dsc min }}
{{dsc inc | cpp/chrono/duration_values/dsc max }}
{{dsc end}}

[[de:cpp/chrono/duration values/zero]]
[[es:cpp/chrono/duration values/zero]]
[[fr:cpp/chrono/duration values/zero]]
[[it:cpp/chrono/duration values/zero]]
[[ja:cpp/chrono/duration values/zero]]
[[pt:cpp/chrono/duration values/zero]]
[[ru:cpp/chrono/duration values/zero]]
[[zh:cpp/chrono/duration values/zero]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/high resolution clock</title>
    <ns>0</ns>
    <id>3291</id>
    <revision>
      <id>64488</id>
      <parentid>62684</parentid>
      <timestamp>2013-08-18T04:01:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="2120">{{cpp/title|n=chrono::|high_resolution_clock}}
{{cpp/chrono/high_resolution_clock/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
class high_resolution_clock;
}}
{{dcl end}}

Class {{tt|std::chrono::high_resolution_clock}} represents the clock with the smallest tick period provided by the implementation. It may be an alias of {{lc|std::chrono::system_clock}} or {{lc|std::chrono::steady_clock}}, or a third, independent clock.

{{tt|std::chrono::high_resolution_clock}} meets the requirements of {{concept|TrivialClock}}. 

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|rep}} | arithmetic type representing the number of ticks in the clock's duration}}
{{dsc | {{tt|period}} | a {{lc|std::ratio}} type representing the tick period of the clock, in seconds}}
{{dsc | {{tt|duration}} | {{c|std::chrono::duration&lt;rep, period&gt;}}}}
{{dsc | {{tt|time_point}} | {{c|std::chrono::time_point&lt;std::chrono::high_resolution_clock&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr bool}} is_steady | {{c|true}} if the time between ticks is always constant, i.e. calls to {{ltf|cpp/chrono/high_resolution_clock/now}} return values that increase monotonically even in case of some external clock adjustment}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem sfun | cpp/chrono/high_resolution_clock/now  | returns a {{lc|std::chrono::time_point}} representing the current value of the clock}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc class | cpp/chrono/system_clock | wall clock time from the system-wide realtime clock  | notes={{mark c++11}}  }}
{{dsc class | cpp/chrono/steady_clock | monotonic clock that will never be adjusted | notes={{mark c++11}}  }}
{{dsc end}}

[[de:cpp/chrono/high resolution clock]]
[[es:cpp/chrono/high resolution clock]]
[[fr:cpp/chrono/high resolution clock]]
[[it:cpp/chrono/high resolution clock]]
[[ja:cpp/chrono/high resolution clock]]
[[pt:cpp/chrono/high resolution clock]]
[[ru:cpp/chrono/high resolution clock]]
[[zh:cpp/chrono/high resolution clock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/high resolution clock/now</title>
    <ns>0</ns>
    <id>5279</id>
    <revision>
      <id>50429</id>
      <parentid>42378</parentid>
      <timestamp>2013-06-01T03:28:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="412">{{include page|cpp/chrono/clock/now|high_resolution_clock}}

[[de:cpp/chrono/high resolution clock/now]]
[[es:cpp/chrono/high resolution clock/now]]
[[fr:cpp/chrono/high resolution clock/now]]
[[it:cpp/chrono/high resolution clock/now]]
[[ja:cpp/chrono/high resolution clock/now]]
[[pt:cpp/chrono/high resolution clock/now]]
[[ru:cpp/chrono/high resolution clock/now]]
[[zh:cpp/chrono/high resolution clock/now]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;h</title>
    <ns>0</ns>
    <id>12955</id>
    <revision>
      <id>68725</id>
      <parentid>66473</parentid>
      <timestamp>2014-03-20T03:39:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>bigger note, templated</comment>
      <text xml:space="preserve" bytes="1846">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;h }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr chrono::hours operator &quot;&quot; h(unsigned long long hrs);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr chrono::duration&lt;/*unspecified*/, std::ratio&lt;3600,1&gt;&gt;
                        operator &quot;&quot; h(long double hrs);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing hours.

@1@ integer literal, returns exactly {{c|std::chrono::hours(hrs)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::hours}}

===Parameters===
{{par begin}}
{{par | hrs | the number of hours}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::hours operator &quot;&quot;h(unsigned long long h)
{
    return std::chrono::hours(h);
}
constexpr std::chrono::duration&lt;long double, ratio&lt;3600,1&gt;&gt; operator &quot;&quot;h(long double h)
{
    return std::chrono::duration&lt;long double, std::ratio&lt;3600,1&gt;&gt;(h);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto day = 24h;
    auto halfhour = 0.5h;
    std::cout &lt;&lt; &quot;one day is &quot; &lt;&lt; day.count() &lt;&lt; &quot; hours\n&quot;
              &lt;&lt; &quot;half an hour is &quot; &lt;&lt; halfhour.count() &lt;&lt; &quot; hours\n&quot;;
}
| output=
one day is 24 hours
half an hour is 0.5 hours
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;h]]
[[es:cpp/chrono/operator&quot;&quot;h]]
[[fr:cpp/chrono/operator&quot;&quot;h]]
[[it:cpp/chrono/operator&quot;&quot;h]]
[[ja:cpp/chrono/operator&quot;&quot;h]]
[[pt:cpp/chrono/operator&quot;&quot;h]]
[[ru:cpp/chrono/operator&quot;&quot;h]]
[[zh:cpp/chrono/operator&quot;&quot;h]]</text>
      <sha1>5dy6ayiqw6ymk1l9021a7w5o13yifug</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;min</title>
    <ns>0</ns>
    <id>13091</id>
    <revision>
      <id>68726</id>
      <parentid>66474</parentid>
      <timestamp>2014-03-20T03:39:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>templated note</comment>
      <text xml:space="preserve" bytes="1937">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;min }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr chrono::minutes operator &quot;&quot; min(unsigned long long mins);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr chrono::duration&lt;/*unspecified*/, ratio&lt;60,1&gt;&gt;
                      operator &quot;&quot; min(long double mins);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing minutes.

@1@ integer literal, returns exactly {{c|std::chrono::minutes(mins)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::minutes}}

===Parameters===
{{par begin}}
{{par | minutes | the number of minutes}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::minutes operator &quot;&quot;min(unsigned long long m)
{
    return std::chrono::minutes(m);
}
constexpr std::chrono::duration&lt;long double,
                                std::ratio&lt;60,1&gt;&gt; operator &quot;&quot;min(long double m)
{
    return std::chrono::duration&lt;long double, ratio&lt;60,1&gt;&gt; (m);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto lesson = 45min;
    auto halfmin = 0.5min;
    std::cout &lt;&lt; &quot;one lesson is &quot; &lt;&lt; lesson.count() &lt;&lt; &quot; minutes\n&quot;
              &lt;&lt; &quot;half a minute is &quot; &lt;&lt; halfmin.count() &lt;&lt; &quot; minutes\n&quot;;
}
| output=
one lesson is 45 minutes
half a minute is 0.5 minutes
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;min]]
[[es:cpp/chrono/operator&quot;&quot;min]]
[[fr:cpp/chrono/operator&quot;&quot;min]]
[[it:cpp/chrono/operator&quot;&quot;min]]
[[ja:cpp/chrono/operator&quot;&quot;min]]
[[pt:cpp/chrono/operator&quot;&quot;min]]
[[ru:cpp/chrono/operator&quot;&quot;min]]
[[zh:cpp/chrono/operator&quot;&quot;min]]</text>
      <sha1>skz70liuvrn1s3hrcwzr1zbeeywsbxm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;ms</title>
    <ns>0</ns>
    <id>13093</id>
    <revision>
      <id>69465</id>
      <parentid>69464</parentid>
      <timestamp>2014-04-10T00:24:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 69464 by [[Special:Contributions/84.52.101.196|84.52.101.196]] ([[User talk:84.52.101.196|talk]])</comment>
      <text xml:space="preserve" bytes="1904">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;ms }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr std::chrono::milliseconds operator &quot;&quot; ms(unsigned long long ms);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr std::chrono::duration&lt;/*unspecified*/,
                           std::milli&gt; operator &quot;&quot; ms(long double ms);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing milliseconds.

@1@ integer literal, returns exactly {{c|std::chrono::milliseconds(ms)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::milliseconds}}

===Parameters===
{{par begin}}
{{par | ms | the number of milliseconds}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::milliseconds operator &quot;&quot;ms(unsigned long long ms)
{
    return chrono::milliseconds(ms);
}
constexpr std::chrono::duration&lt;long double, std::milli&gt; operator &quot;&quot;ms(long double ms)
{
    return std::chrono::duration&lt;long double, std::milli&gt;(ms);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto d1 = 250ms;
    std::chrono::milliseconds d2 = 1s;
    std::cout &lt;&lt; &quot;250ms = &quot; &lt;&lt; d1.count() &lt;&lt; &quot; milliseconds\n&quot;
              &lt;&lt; &quot;1 = &quot; &lt;&lt; d2.count() &lt;&lt; &quot; milliseconds\n&quot;;
}
| output=
250ms = 250 milliseconds
1 = 1000 milliseconds
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;ms]]
[[es:cpp/chrono/operator&quot;&quot;ms]]
[[fr:cpp/chrono/operator&quot;&quot;ms]]
[[it:cpp/chrono/operator&quot;&quot;ms]]
[[ja:cpp/chrono/operator&quot;&quot;ms]]
[[pt:cpp/chrono/operator&quot;&quot;ms]]
[[ru:cpp/chrono/operator&quot;&quot;ms]]
[[zh:cpp/chrono/operator&quot;&quot;ms]]</text>
      <sha1>gx8p3pni008r31vmrc3vsi9lld37hwc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;ns</title>
    <ns>0</ns>
    <id>13095</id>
    <revision>
      <id>68730</id>
      <parentid>66481</parentid>
      <timestamp>2014-03-20T03:40:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>templated note</comment>
      <text xml:space="preserve" bytes="1902">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;ns }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr std::chrono::nanoseconds operator &quot;&quot; ns(unsigned long long nsec);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr std::chrono::duration&lt;/*unspecified*/,
                           std::nano&gt; operator &quot;&quot; ns(long double nsec);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing nanoseconds.

@1@ integer literal, returns exactly {{c|std::chrono::nanoseconds(nsec)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::nanoseconds}}

===Parameters===
{{par begin}}
{{par | nsec | the number of nanoseconds}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::nanoseconds operator &quot;&quot;ns(unsigned long long ns)
{
    return chrono::nanoseconds(ns);
}
constexpr std::chrono::duration&lt;long double, std::nano&gt; operator &quot;&quot;ns(long double ns)
{
    return std::chrono::duration&lt;long double, std::nano&gt;(ns);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto d1 = 250ns;
    std::chrono::nanoseconds d2 = 1us;
    std::cout &lt;&lt; &quot;250ns = &quot; &lt;&lt; d1.count() &lt;&lt; &quot; nanoseconds\n&quot;
              &lt;&lt; &quot;1us = &quot; &lt;&lt; d2.count() &lt;&lt; &quot; nanoseconds\n&quot;;
}
| output=
250ns = 250 nanoseconds
1us = 1000 nanoseconds
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;ns]]
[[es:cpp/chrono/operator&quot;&quot;ns]]
[[fr:cpp/chrono/operator&quot;&quot;ns]]
[[it:cpp/chrono/operator&quot;&quot;ns]]
[[ja:cpp/chrono/operator&quot;&quot;ns]]
[[pt:cpp/chrono/operator&quot;&quot;ns]]
[[ru:cpp/chrono/operator&quot;&quot;ns]]
[[zh:cpp/chrono/operator&quot;&quot;ns]]</text>
      <sha1>dytqllh5c94zmdkuc4ryu8j921bkrw1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;s</title>
    <ns>0</ns>
    <id>13092</id>
    <revision>
      <id>68727</id>
      <parentid>66476</parentid>
      <timestamp>2014-03-20T03:39:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>templated note</comment>
      <text xml:space="preserve" bytes="2011">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;s }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr chrono::seconds operator &quot;&quot; s(unsigned long long secs);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr chrono::duration&lt;/*unspecified*/&gt; operator &quot;&quot; s(long double secs);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing seconds.

@1@ integer literal, returns exactly {{c|std::chrono::seconds(secs)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::seconds}}

===Parameters===
{{par begin}}
{{par | secs | the number of seconds}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::seconds operator &quot;&quot;s(unsigned long long s)
{
    return std::chrono::seconds(m);
}
constexpr std::chrono::duration&lt;long double&gt; operator &quot;&quot;s(long double s)
{
    return std::chrono::duration&lt;long double&gt;(s);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

{{lc|std::string}} also defines {{tt|operator&quot;&quot;s}}, to represent literal objects of type {{tt|std::string}}, but it is a string literal: {{c|10s}} is ten seconds, but {{c|&quot;10&quot;s}} is a two-character string.

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto halfmin = 30s;
    std::cout &lt;&lt; &quot;half a minute is &quot; &lt;&lt; halfmin.count() &lt;&lt; &quot; seconds\n&quot;
              &lt;&lt; &quot;a minute and a half is &quot; &lt;&lt; (1min + 30s).count() &lt;&lt; &quot; seconds\n&quot;;
}
| output=
half a minute is 30 seconds
a minute and a half is 90 seconds
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;s]]
[[es:cpp/chrono/operator&quot;&quot;s]]
[[fr:cpp/chrono/operator&quot;&quot;s]]
[[it:cpp/chrono/operator&quot;&quot;s]]
[[ja:cpp/chrono/operator&quot;&quot;s]]
[[pt:cpp/chrono/operator&quot;&quot;s]]
[[ru:cpp/chrono/operator&quot;&quot;s]]
[[zh:cpp/chrono/operator&quot;&quot;s]]</text>
      <sha1>butrp41z0ea4x2axzgc042pswetq8yy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/operator&quot;&quot;us</title>
    <ns>0</ns>
    <id>13094</id>
    <revision>
      <id>68729</id>
      <parentid>68033</parentid>
      <timestamp>2014-03-20T03:40:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>templated note</comment>
      <text xml:space="preserve" bytes="1914">{{cpp/title|n=literals::chrono_literals::|operator&quot;&quot;us }}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | num=1 | since=c++14 | 1=
constexpr std::chrono::microseconds operator &quot;&quot; us(unsigned long long us);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr std::chrono::duration&lt;/*unspecified*/,
                           std::micro&gt; operator &quot;&quot; us(long double us);
}}
{{dcl end}}

Forms a {{lc|std::chrono::duration}} literal representing microseconds.

@1@ integer literal, returns exactly {{c|std::chrono::microseconds(us)}} 
@2@ floating-point literal, returns a floating-point duration equivalent to {{lc|std::chrono::microseconds}}

===Parameters===
{{par begin}}
{{par | us | the number of microseconds}}
{{par end}}

===Return value===
The {{lc|std::chrono::duration}} literal.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::chrono::microseconds operator &quot;&quot;us(unsigned long long us)
{
    return std::chrono::microseconds(us);
}
constexpr std::chrono::duration&lt;long double, std::micro&gt; operator &quot;&quot;us(long double us)
{
    return std::chrono::duration&lt;long double, std::micro&gt;(us);
}
}}

===Notes===
{{cpp/chrono/chrono_literals_namespace}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

int main()
{
    using namespace std::literals::chrono_literals;
    auto d1 = 250us;
    std::chrono::microseconds d2 = 1ms;
    std::cout &lt;&lt; &quot;250us = &quot; &lt;&lt; d1.count() &lt;&lt; &quot; microseconds\n&quot;
              &lt;&lt; &quot;1ms = &quot; &lt;&lt; d2.count() &lt;&lt; &quot; microseconds\n&quot;;
}
| output=
250us = 250 microseconds
1ms = 1000 microseconds
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor}}
{{dsc end}}

[[de:cpp/chrono/operator&quot;&quot;us]]
[[es:cpp/chrono/operator&quot;&quot;us]]
[[fr:cpp/chrono/operator&quot;&quot;us]]
[[it:cpp/chrono/operator&quot;&quot;us]]
[[ja:cpp/chrono/operator&quot;&quot;us]]
[[pt:cpp/chrono/operator&quot;&quot;us]]
[[ru:cpp/chrono/operator&quot;&quot;us]]
[[zh:cpp/chrono/operator&quot;&quot;us]]</text>
      <sha1>5do8tfxwko1749emt6wbu780nfln4gf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/steady clock</title>
    <ns>0</ns>
    <id>3290</id>
    <revision>
      <id>64487</id>
      <parentid>62685</parentid>
      <timestamp>2013-08-18T04:00:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="1806">{{cpp/title|n=chrono::|steady_clock}}
{{cpp/chrono/steady_clock/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
class steady_clock;
}}
{{dcl end}}

Class {{tt|std::chrono::steady_clock}} represents a monotonic clock. The time points of this clock cannot decrease as physical time moves forward. This clock is not related to wall clock time, and is best suitable for measuring intervals.

{{tt|std::chrono::steady_clock}} meets the requirements of {{concept|TrivialClock}}. 

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|rep}} | arithmetic type representing the number of ticks in the clock's duration}}
{{dsc | {{tt|period}} | a {{lc|std::ratio}} type representing the tick period of the clock, in seconds}}
{{dsc | {{tt|duration}} | {{c|std::chrono::duration&lt;rep, period&gt;}}}}
{{dsc | {{tt|time_point}} | {{c|std::chrono::time_point&lt;std::chrono::steady_clock&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr bool}} is_steady | steady clock flag, always {{c|true}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem sfun | cpp/chrono/steady_clock/now  | returns a time_point representing the current value of the clock}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc class | cpp/chrono/system_clock | wall clock time from the system-wide realtime clock  | notes={{mark c++11}}  }}
{{dsc class | cpp/chrono/high_resolution_clock | the clock with the shortest tick period available | notes={{mark c++11}}  }}
{{dsc end}}

[[de:cpp/chrono/steady clock]]
[[es:cpp/chrono/steady clock]]
[[fr:cpp/chrono/steady clock]]
[[it:cpp/chrono/steady clock]]
[[ja:cpp/chrono/steady clock]]
[[pt:cpp/chrono/steady clock]]
[[ru:cpp/chrono/steady clock]]
[[zh:cpp/chrono/steady clock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/steady clock/now</title>
    <ns>0</ns>
    <id>5280</id>
    <revision>
      <id>50430</id>
      <parentid>42360</parentid>
      <timestamp>2013-06-01T03:28:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="331">{{include page|cpp/chrono/clock/now|steady_clock}}

[[de:cpp/chrono/steady clock/now]]
[[es:cpp/chrono/steady clock/now]]
[[fr:cpp/chrono/steady clock/now]]
[[it:cpp/chrono/steady clock/now]]
[[ja:cpp/chrono/steady clock/now]]
[[pt:cpp/chrono/steady clock/now]]
[[ru:cpp/chrono/steady clock/now]]
[[zh:cpp/chrono/steady clock/now]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/system clock</title>
    <ns>0</ns>
    <id>3289</id>
    <revision>
      <id>64486</id>
      <parentid>62686</parentid>
      <timestamp>2013-08-18T04:00:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="2106">{{cpp/title|n=chrono::|system_clock}}
{{cpp/chrono/system_clock/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
class system_clock;
}}
{{dcl end}}

Class {{tt|std::chrono::system_clock}} represents the system-wide real time wall clock. 

It may not be monotonic: on most systems, the system time can be adjusted at any moment. It is the only C++ clock that has the ability to map its time points to C-style time, and, therefore, to be displayed. 

{{tt|std::chrono::system_clock}} meets the requirements of {{concept|TrivialClock}}. 

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|rep}} | signed arithmetic type representing the number of ticks in the clock's duration}}
{{dsc | {{tt|period}} | an {{lc|std::ratio}} type representing the tick period of the clock, in seconds}}
{{dsc | {{tt|duration}} | {{c|std::chrono::duration&lt;rep, period&gt;}}, capable of representing negative durations}}
{{dsc | {{tt|time_point}} |  {{c|std::chrono::time_point&lt;std::chrono::system_clock&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr bool}} is_steady | {{c|true}} if the time between ticks is always constant, i.e. calls to {{ltf|cpp/chrono/system_clock/now}} return values that increase monotonically even in case of some external clock adjustment}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/system_clock/dsc now}}
{{dsc inc | cpp/chrono/system_clock/dsc to_time_t}}
{{dsc inc | cpp/chrono/system_clock/dsc from_time_t}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc class | cpp/chrono/steady_clock | monotonic clock that will never be adjusted | notes={{mark c++11}}  }}
{{dsc class | cpp/chrono/high_resolution_clock | the clock with the shortest tick period available | notes={{mark c++11}}  }}
{{dsc end}}

[[de:cpp/chrono/system clock]]
[[es:cpp/chrono/system clock]]
[[fr:cpp/chrono/system clock]]
[[it:cpp/chrono/system clock]]
[[ja:cpp/chrono/system clock]]
[[pt:cpp/chrono/system clock]]
[[ru:cpp/chrono/system clock]]
[[zh:cpp/chrono/system clock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/system clock/from time t</title>
    <ns>0</ns>
    <id>5269</id>
    <revision>
      <id>63281</id>
      <parentid>57221</parentid>
      <timestamp>2013-07-10T01:27:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1026">{{cpp/chrono/system_clock/title | from_time_t }}
{{cpp/chrono/system_clock/navbar}}
{{ddcl | since=c++11 |
static std::chrono::time_point from_time_t( std::time_t t );
}}

Converts {{tt|t}} to a time point type, using the coarser precision of the two types.

If {{tt|time_point}} has lower precision, it is implementation defined whether the value is rounded or truncated.

===Parameters===
{{par begin}}
{{par | t | {{lc|std::time_t}} value to convert}}
{{par end}}

===Return value===
A value of type {{lc|std::chrono::time_point}} representing {{tt|t}}.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/system_clock/dsc to_time_t}}
{{dsc end}}

[[de:cpp/chrono/system clock/from time t]]
[[es:cpp/chrono/system clock/from time t]]
[[fr:cpp/chrono/system clock/from time t]]
[[it:cpp/chrono/system clock/from time t]]
[[ja:cpp/chrono/system clock/from time t]]
[[pt:cpp/chrono/system clock/from time t]]
[[ru:cpp/chrono/system clock/from time t]]
[[zh:cpp/chrono/system clock/from time t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/system clock/now</title>
    <ns>0</ns>
    <id>5277</id>
    <revision>
      <id>50431</id>
      <parentid>42335</parentid>
      <timestamp>2013-06-01T03:28:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="331">{{include page|cpp/chrono/clock/now|system_clock}}

[[de:cpp/chrono/system clock/now]]
[[es:cpp/chrono/system clock/now]]
[[fr:cpp/chrono/system clock/now]]
[[it:cpp/chrono/system clock/now]]
[[ja:cpp/chrono/system clock/now]]
[[pt:cpp/chrono/system clock/now]]
[[ru:cpp/chrono/system clock/now]]
[[zh:cpp/chrono/system clock/now]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/system clock/to time t</title>
    <ns>0</ns>
    <id>5261</id>
    <revision>
      <id>62175</id>
      <parentid>62155</parentid>
      <timestamp>2013-06-25T11:51:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>member function, full qualification not necessary; use dcl</comment>
      <text xml:space="preserve" bytes="970">{{cpp/chrono/system_clock/title | to_time_t }}
{{cpp/chrono/system_clock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
static std::time_t to_time_t( const time_point&amp; t );
}}
{{dcl end}}

Converts {{tt|t}} to a {{lc|std::time_t}} type. 

If {{lc|std::time_t}} has lower precision, it is implementation-defined whether the value is rounded or truncated.

===Parameters===
{{par begin}}
{{par | t | system clock time point to convert}}
{{par end}}

===Return value===
A {{lc|std::time_t}} value representing {{tt|t}}.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/system_clock/dsc from_time_t}}
{{dsc end}}

[[de:cpp/chrono/system clock/to time t]]
[[es:cpp/chrono/system clock/to time t]]
[[fr:cpp/chrono/system clock/to time t]]
[[it:cpp/chrono/system clock/to time t]]
[[ja:cpp/chrono/system clock/to time t]]
[[pt:cpp/chrono/system clock/to time t]]
[[ru:cpp/chrono/system clock/to time t]]
[[zh:cpp/chrono/system clock/to time t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point</title>
    <ns>0</ns>
    <id>3263</id>
    <revision>
      <id>70971</id>
      <parentid>70969</parentid>
      <timestamp>2014-06-04T16:14:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>explicit namespaces in examples for the parser. Merge examples</comment>
      <text xml:space="preserve" bytes="2760">{{cpp/chrono/title|time_point}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
template&lt; 
    class Clock, 
    class Duration = typename Clock::duration 
&gt; class time_point;
}}
{{dcl end}}

Class template {{tt|std::chrono::time_point}} represents a point in time. It is implemented as if it stores a value of type {{tt|Duration}} indicating the time interval from the start of the {{tt|Clock}}'s epoch. 

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|clock}} | {{tt|Clock}}, the clock on which this time point is measured}}
{{dsc | {{tt|duration}} | {{tt|Duration}}, a {{lc|std::chrono::duration}} type used to measure the time since epoch}}
{{dsc | {{tt|rep}} | {{tt|Rep}}, an arithmetic type representing the number of ticks of the duration}}
{{dsc | {{tt|period}} | {{tt|Period}}, a {{lc|std::ratio}} type representing the tick period of the duration}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/time_point/dsc constructor}}
{{dsc inc | cpp/chrono/time_poind/dsc time_since_epoch}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith}}
{{dsc inc | cpp/chrono/time_point/dsc min}}
{{dsc inc | cpp/chrono/time_point/dsc max}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/chrono/time_point/dsc common_type}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith2}}
{{dsc inc | cpp/chrono/time_point/dsc operator_cmp}}
{{dsc inc | cpp/chrono/time_point/dsc time_point_cast}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;
#include &lt;chrono&gt;

int main()
{
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now - std::chrono::hours(24));
    std::cout &lt;&lt; &quot;24 hours ago, the time was &quot;
              &lt;&lt; std::put_time(std::localtime(&amp;now_c), &quot;%F %T&quot;) &lt;&lt; '\n';

    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
    std::cout &lt;&lt; &quot;Hello World\n&quot;;
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
    std::cout &lt;&lt; &quot;Printing took &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::microseconds&gt;(end - start).count()
              &lt;&lt; &quot;us.\n&quot;;
}
 | p=true
 | output=
24 hours ago, the time was 2011-10-25 12:00:08
Hello World
Printing took 84us.
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/chrono/duration | a time interval | notes={{mark c++11}}  }}
{{dsc end}}

[[de:cpp/chrono/time point]]
[[es:cpp/chrono/time point]]
[[fr:cpp/chrono/time point]]
[[it:cpp/chrono/time point]]
[[ja:cpp/chrono/time point]]
[[pt:cpp/chrono/time point]]
[[ru:cpp/chrono/time point]]
[[zh:cpp/chrono/time point]]</text>
      <sha1>6zqadn82c12r1g4h0l7nepepqtzm5a6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/common type</title>
    <ns>0</ns>
    <id>8665</id>
    <revision>
      <id>63282</id>
      <parentid>57228</parentid>
      <timestamp>2013-07-10T01:27:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1184">{{cpp/title|common_type&lt;small&gt;(std::chrono::time_point)&lt;/small&gt;}}
{{cpp/chrono/time_point/navbar}}
{{ddcl | since=c++11 |
template &lt;class Clock, class Duration1, class Duration2&gt;
struct common_type&lt;std::chrono::time_point&lt;Clock, Duration1&gt;, 
                   std::chrono::time_point&lt;Clock, Duration2&gt;&gt; {
    typedef std::chrono::time_point&lt;
        Clock, typename std::common_type&lt;Duration1, Duration2&gt;::type&gt; type;
};
}}

Exposes the type named {{tt|type}}, which is the common type of two {{lc|std::chrono::time_point}}s.

===Notes===

The common type of two {{lc|std::chrono::time_point}} types is a {{lc|std::chrono::time_point}} with the same clock as the two types and the {{lc|std::common_type}} of their durations.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc common_type}}
{{dsc end}}

[[de:cpp/chrono/time point/common type]]
[[es:cpp/chrono/time point/common type]]
[[fr:cpp/chrono/time point/common type]]
[[it:cpp/chrono/time point/common type]]
[[ja:cpp/chrono/time point/common type]]
[[pt:cpp/chrono/time point/common type]]
[[ru:cpp/chrono/time point/common type]]
[[zh:cpp/chrono/time point/common type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/max</title>
    <ns>0</ns>
    <id>8657</id>
    <revision>
      <id>49388</id>
      <parentid>42300</parentid>
      <timestamp>2013-06-01T02:34:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1664">{{cpp/chrono/time_point/title | max}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl |
static constexpr time_point max();
}}
{{dcl end}}

Returns a {{tt|time_point}} with the largest possible duration, i.e. {{c|std::chrono::time_point(std::chrono::duration::max())}}.

===Parameters===
(none)

===Return value===
the largest possible {{tt|time_point}}

===Example===
{{example
 | p=true
 | code=
#include &lt;chrono&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

int main() 
{
    std::chrono::time_point&lt;std::chrono::system_clock&gt; now =
        std::chrono::system_clock::now();
    std::vector&lt;std::chrono::time_point&lt;std::chrono::system_clock&gt;&gt; times {
        now - std::chrono::hours(24),
        now - std::chrono::hours(48),
        now + std::chrono::hours(24),
    };  
  
    std::chrono::time_point&lt;std::chrono::system_clock&gt; earliest =
        std::chrono::time_point&lt;std::chrono::system_clock&gt;::max();

    std::cout &lt;&lt; &quot;all times:\n&quot;;
    for (const auto &amp;time : times) {
        std::time_t t = std::chrono::system_clock::to_time_t(time);
        std::cout &lt;&lt; std::ctime(&amp;t);
    
        if (time &lt; earliest) earliest = time;
    }

    std::time_t t = std::chrono::system_clock::to_time_t(earliest);
    std::cout &lt;&lt; &quot;earliest:\n&quot; &lt;&lt; std::ctime(&amp;t);
}
 | output=
all times:
Sun Oct  7 19:06:48 2012
Sat Oct  6 19:06:48 2012
Tue Oct  9 19:06:48 2012
earliest:
Sat Oct  6 19:06:48 2012
}}

[[de:cpp/chrono/time point/max]]
[[es:cpp/chrono/time point/max]]
[[fr:cpp/chrono/time point/max]]
[[it:cpp/chrono/time point/max]]
[[ja:cpp/chrono/time point/max]]
[[pt:cpp/chrono/time point/max]]
[[ru:cpp/chrono/time point/max]]
[[zh:cpp/chrono/time point/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/min</title>
    <ns>0</ns>
    <id>8656</id>
    <revision>
      <id>49389</id>
      <parentid>42293</parentid>
      <timestamp>2013-06-01T02:34:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="672">{{cpp/chrono/time_point/title | min}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl |
static constexpr time_point min();
}}
{{dcl end}}

Returns a {{tt|time_point}} with the smallest possible duration, i.e. {{c|std::chrono::time_point(std::chrono::duration::min())}}.

===Parameters===
(none)

===Return value===
the smallest possible {{tt|time_point}}

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/chrono/time point/min]]
[[es:cpp/chrono/time point/min]]
[[fr:cpp/chrono/time point/min]]
[[it:cpp/chrono/time point/min]]
[[ja:cpp/chrono/time point/min]]
[[pt:cpp/chrono/time point/min]]
[[ru:cpp/chrono/time point/min]]
[[zh:cpp/chrono/time point/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/operator arith</title>
    <ns>0</ns>
    <id>12609</id>
    <revision>
      <id>61308</id>
      <parentid>61307</parentid>
      <timestamp>2013-06-05T21:21:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="869">{{cpp/chrono/time_point/title | operator+, operator-}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
time_point&amp; operator+=( const duration&amp; d );
}}
{{dcl | since=c++11 | num=2 | 1=
time_point&amp; operator-=( const duration&amp; d );
}}
{{dcl end}}

Modifies the time point by the given duration.

@1@ Applies the offset {{tt|d}} to {{tt|pt}}. Effectively, {{tt|d}} is added to the internally stored duration {{tt|d_}} as {{c|1=d_ += d}}.

@2@ Applies the offset {{tt|d}} to {{tt|pt}} in negative direction. Effectively, {{tt|d}} is subtracted from internally stored duration {{tt|d_}} as {{c|1=d_ -= d}}.

===Parameters===
{{par begin}}
{{par | d | a time offset to apply}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith2}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/operator arith2</title>
    <ns>0</ns>
    <id>12607</id>
    <revision>
      <id>64725</id>
      <parentid>64721</parentid>
      <timestamp>2013-08-26T14:01:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>dcl rev</comment>
      <text xml:space="preserve" bytes="2936">{{title | operator+, operator-{{dsc small|(std::time_point)}}}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class C, class D1, class R2, class P2 &gt;
time_point&lt;C, typename std::common_type&lt;D1, duration&lt;R2,P2&gt;&gt;::type&gt;
    operator+( const time_point&lt;C,D1&gt;&amp; pt, 
               const duration&lt;R2,P2&gt;&amp; d );
}}
{{dcl | since=c++14 |
template&lt; class C, class D1, class R2, class P2 &gt;
constexpr time_point&lt;C, typename std::common_type&lt;D1, duration&lt;R2,P2&gt;&gt;::type&gt;
    operator+( const time_point&lt;C,D1&gt;&amp; pt, 
               const duration&lt;R2,P2&gt;&amp; d );
}}
{{dcl rev end}}
{{dcl rev begin|num=2}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class R1, class P1, class C, class D2 &gt;
time_point&lt;C, typename std::common_type&lt;duration&lt;R1,P1&gt;,D2&gt;::type&gt;
    operator+( const duration&lt;R1,P1&gt;&amp; d, 
               const time_point&lt;C,D2&gt;&amp; pt );
}}
{{dcl | since=c++14 |
template&lt; class R1, class P1, class C, class D2 &gt;
constexpr time_point&lt;C, typename std::common_type&lt;duration&lt;R1,P1&gt;,D2&gt;::type&gt;
    operator+( const duration&lt;R1,P1&gt;&amp; d, 
               const time_point&lt;C,D2&gt;&amp; pt );
}}
{{dcl rev end}}
{{dcl rev begin|num=3}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class C, class D1, class R2, class P2 &gt;
time_point&lt;C, typename std::common_type&lt;D1, duration&lt;R2,P2&gt;&gt;::type&gt;
    operator-( const time_point&lt;C,D1&gt;&amp; d, 
               const duration&lt;R2,P2&gt;&amp; pt );
}}
{{dcl | since=c++14|
template&lt; class C, class D1, class R2, class P2 &gt;
constexpr time_point&lt;C, typename std::common_type&lt;D1, duration&lt;R2,P2&gt;&gt;::type&gt;
    operator-( const time_point&lt;C,D1&gt;&amp; d, 
               const duration&lt;R2,P2&gt;&amp; pt );
}}
{{dcl rev end}}
{{dcl rev begin|num=4}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class C, class D1, class D2 &gt;
typename std::common_type&lt;D1,D2&gt;::type
    operator-( const time_point&lt;C,D1&gt;&amp; pt_lhs, 
               const time_point&lt;C,D2&gt;&amp; pt_rhs );
}}
{{dcl | since=c++14|
template&lt; class C, class D1, class D2 &gt;
constexpr typename std::common_type&lt;D1,D2&gt;::type
    operator-( const time_point&lt;C,D1&gt;&amp; pt_lhs, 
               const time_point&lt;C,D2&gt;&amp; pt_rhs );
}}
{{dcl end}}

Performs add and subtract operations involving a {{tt|time_point}}.

@1-2@ Applies the offset {{tt|d}} to {{tt|pt}}. Effectively {{c|pt +{{=}} dur}} is performed.

@3@ Applies the offset {{tt|d}} to {{tt|pt}} in negative direction. Effectively {{c|pt +{{=}} (-dur)}} is performed.

@4@ Computes the difference between {{tt|pt_lhs}} and {{tt|pt_rhs}}.

===Parameters===
{{par begin}}
{{par | pt | a time point to apply the offset to}}
{{par | d | a time offset}}
{{par | pt_lhs, pt_rhs | time points to extract difference from}}
{{par end}}

===Return value===
@1-3@ The time point that resulted from applying the offset {{tt|d}}.

@4@ The duration between the time points.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/operator cmp</title>
    <ns>0</ns>
    <id>12608</id>
    <revision>
      <id>67317</id>
      <parentid>67292</parentid>
      <timestamp>2014-02-04T20:01:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>separate versions for C++11 and C++14</comment>
      <text xml:space="preserve" bytes="3966">{{title | 1= operator==,!=,&lt;,&lt;=,&gt;,&gt;={{dsc small|(std::time_point)}}}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator==( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                 const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator==( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                           const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator!=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                 const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator!=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                           const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator&lt;( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator&lt;( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                          const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin | num=4}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator&lt;=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                 const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator&lt;=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                           const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin | num=5}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator&gt;( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator&gt;( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                          const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin | num=6}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
bool operator&gt;=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                 const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Dur1, class Dur2 &gt;
constexpr bool operator&gt;=( const time_point&lt;Clock,Dur1&gt;&amp; lhs,
                           const time_point&lt;Clock,Dur2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl end}}

Compares two time points. The comparison is done by comparing the results {{lc|time_since_epoch()}} for the time points.

@1-2@ Checks if the time points {{tt|lhs}} and {{tt|rhs}} refer to the same time point for the given clock.

@3-6@ Compares the time points {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | time points to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if the {{tt|lhs}} and {{tt|rhs}} refer to the same time point, {{c|false}} otherwise.

@2@ {{c|true}} if the {{tt|lhs}} and {{tt|rhs}} refer to different time points, {{c|false}} otherwise.

@3@ {{c|true}} if the {{tt|lhs}} refers to time point ''before'' {{tt|rhs}}, {{c|false}} otherwise.

@4@ {{c|true}} if the {{tt|lhs}} refers to time point ''before'' {{tt|rhs}}, or to the same time point as {{tt|rhs}}, {{c|false}} otherwise.

@5@ {{c|true}} if the {{tt|lhs}} refers to time point ''after'' {{tt|rhs}}, {{c|false}} otherwise.

@6@ {{c|true}} if the {{tt|lhs}} refers to time point ''after'' {{tt|rhs}},  or to the same time point as {{tt|rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Notes===
These operators were not {{tt|constexpr}} in C++11, this was corrected in C++14</text>
      <sha1>2tzpfuudjnj04kca1ivw3vlbvm5a56w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/time point</title>
    <ns>0</ns>
    <id>8651</id>
    <revision>
      <id>64910</id>
      <parentid>64909</parentid>
      <timestamp>2013-08-27T10:30:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2685">{{cpp/chrono/time_point/title | time_point}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl rev begin | num = 1}}
{{dcl | since=c++11 | until=c++14 |
time_point();
}}
{{dcl | since=c++14 |
constexpr time_point();
}}
{{dcl rev end}}
{{dcl rev begin | num = 2}}
{{dcl | since=c++11 | until=c++14 |
explicit time_point( const duration&amp; d );
}}
{{dcl | since=c++14 |
constexpr explicit time_point( const duration&amp; d );
}}
{{dcl rev end}}
{{dcl rev begin | num = 3 }}
{{dcl | since=c++11 | until=c++14 |
template&lt; class Duration2 &gt;
time_point( const time_point&lt;Clock,Duration2&gt;&amp; t );
}}
{{dcl | since=c++14 |
template&lt; class Duration2 &gt;
constexpr time_point( const time_point&lt;Clock,Duration2&gt;&amp; t );
}}
{{dcl rev end}}
{{dcl end}}

Constructs a new {{tt|time_point}} from one of several optional data sources.

@1@ Default constructor, creates a {{tt|time_point}} with a value of {{tt|Clock}}'s epoch.

@2@ Constructs a {{tt|time_point}} at {{tt|Clock}}'s epoch plus {{tt|d}}.

@3@ Constructs a {{tt|time_point}} by converting {{tt|t}} to {{tt|duration}}.  This constructor only participates in overload resolution if {{tt|Duration2}} is implicitly convertible to {{tt|duration}}.

===Parameters===
{{par begin}}
{{par | d  | a {{tt|duration}} to copy from}}
{{par | t  | a {{tt|time_point}} to convert from}}
{{par end}}

===Example===
{{example
 | p=true
 | code=
#include &lt;chrono&gt;
#include &lt;iostream&gt;

using Clock = std::chrono::high_resolution_clock;
using TimePoint = std::chrono::time_point&lt;Clock&gt;;

void print_ms(const TimePoint&amp; point) 
{
    using Ms = std::chrono::milliseconds;
    const Clock::duration since_epoch = point.time_since_epoch();
    std::cout &lt;&lt; std::chrono::duration_cast&lt;Ms&gt;(since_epoch).count() &lt;&lt; &quot; ms\n&quot;;
}

int main() 
{
    const TimePoint default_value = TimePoint(); // (1)
    print_ms(default_value); // 0 ms

    const Clock::duration duration_4_seconds = std::chrono::seconds(4);
    const TimePoint time_point_4_seconds(duration_4_seconds); // (2)
      // 4 seconds from start of epoch
    print_ms(time_point_4_seconds); // 4000 ms

    const TimePoint time_point_now = Clock::now(); // (3)
    print_ms(time_point_now); // 43098276 ms
}
 | output=
0 ms
4000 ms
43098276 ms
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc constructor }}
{{dsc inc | cpp/chrono/duration/dsc duration_cast }}
{{dsc end}}

[[de:cpp/chrono/time point/time point]]
[[es:cpp/chrono/time point/time point]]
[[fr:cpp/chrono/time point/time point]]
[[it:cpp/chrono/time point/time point]]
[[ja:cpp/chrono/time point/time point]]
[[pt:cpp/chrono/time point/time point]]
[[ru:cpp/chrono/time point/time point]]
[[zh:cpp/chrono/time point/time point]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/time point cast</title>
    <ns>0</ns>
    <id>8658</id>
    <revision>
      <id>65059</id>
      <parentid>64732</parentid>
      <timestamp>2013-08-30T14:59:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, clutter</comment>
      <text xml:space="preserve" bytes="2241">{{cpp/chrono/title|time_point_cast}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl item | since=c++11 | until=c++14 |
template &lt;class ToDuration, class Clock, class Duration&gt;
time_point&lt;Clock, ToDuration&gt; time_point_cast(
                                 const time_point&lt;Clock, Duration&gt; &amp;t);
}}
{{dcl item | since=c++14 |
template &lt;class ToDuration, class Clock, class Duration&gt;
constexpr time_point&lt;Clock, ToDuration&gt; time_point_cast(
                                 const time_point&lt;Clock, Duration&gt; &amp;t);
}}
{{dcl rev end}}
{{dcl end}}

Converts a {{lc|std::chrono::time_point}} from one duration to another.

===Parameters===
{{par begin}}
{{par | t | {{tt|time_point}} to convert from}}
{{par end}}

===Return value===
{{c|std::chrono::time_point&lt;Clock, ToDuration&gt;(std::chrono::duration_cast&lt;ToDuration&gt;(t.time_since_epoch())) }}

===Notes===
{{tt|time_point_cast}} will only participate in overload resolution if {{tt|ToDuration}} is an instantiation of {{tt|duration}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

using Clock = std::chrono::high_resolution_clock;
using Ms = std::chrono::milliseconds;
using Sec = std::chrono::seconds;

template&lt;class Duration&gt;
using TimePoint = std::chrono::time_point&lt;Clock, Duration&gt;;

inline void print_ms(const TimePoint&lt;Ms&gt;&amp; time_point) 
{
    std::cout &lt;&lt; time_point.time_since_epoch().count() &lt;&lt; &quot; ms\n&quot;;
}

int main() 
{
    TimePoint&lt;Sec&gt; time_point_sec(Sec(4));

    // implicit cast, no precision loss
    TimePoint&lt;Ms&gt; time_point_ms(time_point_sec);
    print_ms(time_point_ms); // 4000 ms

    time_point_ms = TimePoint&lt;Ms&gt;(Ms(5756));

    // explicit cast, need when precision loss may happens
    // 5756 truncated to 5000
    time_point_sec = std::chrono::time_point_cast&lt;Sec&gt;(time_point_ms);
    print_ms(time_point_sec); // 5000 ms
}
 | output=
4000 ms
5000 ms
}}

[[de:cpp/chrono/time point/time point cast]]
[[es:cpp/chrono/time point/time point cast]]
[[fr:cpp/chrono/time point/time point cast]]
[[it:cpp/chrono/time point/time point cast]]
[[ja:cpp/chrono/time point/time point cast]]
[[pt:cpp/chrono/time point/time point cast]]
[[ru:cpp/chrono/time point/time point cast]]
[[zh:cpp/chrono/time point/time point cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/time point/time since epoch</title>
    <ns>0</ns>
    <id>8653</id>
    <revision>
      <id>64726</id>
      <parentid>64716</parentid>
      <timestamp>2013-08-26T14:01:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>dcl rev</comment>
      <text xml:space="preserve" bytes="1914">{{cpp/chrono/time_point/title | time_since_epoch}}
{{cpp/chrono/time_point/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
duration time_since_epoch() const;
}}
{{dcl | since=c++14 |
constexpr duration time_since_epoch() const;
}}
{{dcl rev end}}
{{dcl end}}

Returns a {{c|duration}} representing the amount of time between {{c|*this}} and the {{tt|clock}}'s epoch.

===Parameters===
(none)

===Return value===
The amount of time between this {{tt|time_point}} and the {{tt|clock}}'s epoch

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;ctime&gt;

int main()
{
    std::chrono::time_point&lt;std::chrono::system_clock&gt; p1, p2, p3;

    p2 = std::chrono::system_clock::now();
    p3 = p2 - std::chrono::hours(24);

    std::time_t epoch_time = std::chrono::system_clock::to_time_t(p1);
    std::cout &lt;&lt; &quot;epoch: &quot; &lt;&lt; std::ctime(&amp;epoch_time);
    std::time_t today_time = std::chrono::system_clock::to_time_t(p2);
    std::cout &lt;&lt; &quot;today: &quot; &lt;&lt; std::ctime(&amp;today_time);

    std::cout &lt;&lt; &quot;hours since epoch: &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::hours&gt;(
                   p2.time_since_epoch()).count() 
              &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;yesterday, hours since epoch: &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::hours&gt;(
                   p3.time_since_epoch()).count() 
              &lt;&lt; '\n';
}
 | output=
epoch: Wed Dec 31 19:00:00 1969
today: Tue Jun 19 12:05:37 2012
hours since epoch: 372256
yesterday, hours since epoch: 372232
}}

[[de:cpp/chrono/time point/time since epoch]]
[[es:cpp/chrono/time point/time since epoch]]
[[fr:cpp/chrono/time point/time since epoch]]
[[it:cpp/chrono/time point/time since epoch]]
[[ja:cpp/chrono/time point/time since epoch]]
[[pt:cpp/chrono/time point/time since epoch]]
[[ru:cpp/chrono/time point/time since epoch]]
[[zh:cpp/chrono/time point/time since epoch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/chrono/treat as floating point</title>
    <ns>0</ns>
    <id>8648</id>
    <revision>
      <id>67431</id>
      <parentid>67410</parentid>
      <timestamp>2014-02-08T23:20:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2389">{{cpp/chrono/title|treat_as_floating_point}}
{{cpp/chrono/duration/navbar}}
{{dcl begin}}
{{dcl header | chrono}}
{{dcl | since=c++11 | 1=
template &lt;class Rep&gt; 
struct treat_as_floating_point : std::is_floating_point&lt;Rep&gt; {};
}}
{{dcl end}}

The {{tt|std::chrono::treat_as_floating_point}} trait helps determine if a duration can be converted to another duration with a different tick period.

Implicit conversions between two durations normally depends on the tick period of the durations.  However, implicit conversions can happen regardless of tick period if {{c|std::chrono::treat_as_floating_point&lt;Rep&gt;::value {{==}} true}}.

===Example===
{{example|
  | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;

void timed_piece_of_code() 
{
    std::chrono::milliseconds simulated_work(2);
    std::this_thread::sleep_for(simulated_work);
}

int main() 
{
    auto start = std::chrono::high_resolution_clock::now();
    
    std::cout &lt;&lt; &quot;Running some timed piece of code...&quot; &lt;&lt; '\n';
    timed_piece_of_code();
    
    auto stop = std::chrono::high_resolution_clock::now();
    
    // A floating point milliseconds type
    using FpMilliseconds = 
        std::chrono::duration&lt;float, std::chrono::milliseconds::period&gt;;
    
    static_assert(std::chrono::treat_as_floating_point&lt;FpMilliseconds::rep&gt;::value, 
                  &quot;Rep required to be floating point&quot;);

    // Note that implicit conversion is not allowed here    
    auto i_ms = std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(stop - start);

    // Note that implicit conversion is allowed here
    auto f_ms = FpMilliseconds(stop - start);

    std::cout &lt;&lt; &quot;Time in milliseconds, using default rep: &quot;
              &lt;&lt; i_ms.count() &lt;&lt; '\n';
              
    
    std::cout &lt;&lt; &quot;Time in milliseconds, using floating point rep: &quot;
              &lt;&lt; f_ms.count() &lt;&lt; '\n';
              
}
  | output=
Running some timed piece of code...
Timing stats:
  Time in milliseconds, using default rep: 2
  Time in milliseconds, using floating point rep: 2.57307
  | p=true
}}

[[de:cpp/chrono/treat as floating point]]
[[es:cpp/chrono/treat as floating point]]
[[fr:cpp/chrono/treat as floating point]]
[[it:cpp/chrono/treat as floating point]]
[[ja:cpp/chrono/treat as floating point]]
[[pt:cpp/chrono/treat as floating point]]
[[ru:cpp/chrono/treat as floating point]]
[[zh:cpp/chrono/treat as floating point]]</text>
      <sha1>817iqrr150i5yeorjhxixedic8qxgsk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/comment</title>
    <ns>0</ns>
    <id>5016</id>
    <revision>
      <id>72198</id>
      <parentid>70225</parentid>
      <timestamp>2014-07-22T19:33:54Z</timestamp>
      <contributor>
        <username>Ybab321</username>
        <id>2952</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2139">{{title|Comments}}
{{cpp/language/basics/navbar}}
Comments serve as a sort of in-code documentation. When inserted into a program, they are effectively ignored by the compiler; they are solely intended to be used as notes by the humans that read source code. Although specific documentation is not part of the C++ standard, several utilities exist that parse comments with different documentation formats.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|/*}} {{spar|comment}} {{ttb|*/}} }}
{{sdsc | num=2 | {{ttb|//}} {{spar|comment}}\n }}
{{sdsc end}}

1) Often known as &quot;C-style&quot; or &quot;multi-line&quot; comments.

2) Often known as &quot;C++-style&quot; or &quot;single-line&quot; comments.

===C-style===
C-style comments are usually used to comment large blocks of text, however, they can be used to comment single lines. To insert a C-style comment, simply surround text with {{tt|/*}} and {{tt|*/}}; this will cause the contents of the comment to be ignored by the compiler. Although it is not part of the C++ standard, {{tt|/**}} and {{tt|*/}} are often used to indicate documentation blocks; this is legal because the second asterisk is simply treated as part of the comment. C-style comments cannot be nested.

C-style comments are often preferred in environments where C and C++ code may be mixed, because they are the only form of comment that can be used in the C standard (prior to C99).

===C++-style===
C++-style comments are usually used to to comment single lines, however, multiple C++-style comments can be placed together to form multi-line comments. C++-style comments tell the compiler to ignore all content between {{tt|//}} and a new line, which makes them very useful.

===Example===
{{example|
|code=
/* C-style comments can contain
multiple lines */
/* or just one */

// C++-style comments can comment one line

// or, they can
// be strung together

int main()
{
  // The below code won't be run
  // return 1;

  // The below code will be run
  return 0;
}
}}

[[de:cpp/comment]]
[[es:cpp/comment]]
[[fr:cpp/comment]]
[[it:cpp/comment]]
[[ja:cpp/comment]]
[[ko:cpp/comment]]
[[pt:cpp/comment]]
[[ru:cpp/comment]]
[[zh:cpp/comment]]</text>
      <sha1>7jg2wksy7bm45v0o3sgw3cqd55g4pw2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/comments</title>
    <ns>0</ns>
    <id>5442</id>
    <redirect title="cpp/comment" />
    <revision>
      <id>19802</id>
      <timestamp>2012-03-13T02:20:21Z</timestamp>
      <contributor>
        <username>Undeterminant</username>
        <id>421</id>
      </contributor>
      <comment>moved [[cpp/comments]] to [[cpp/comment]]: singular</comment>
      <text xml:space="preserve" bytes="25">#REDIRECT [[cpp/comment]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/compiler support</title>
    <ns>0</ns>
    <id>13465</id>
    <revision>
      <id>72405</id>
      <parentid>69627</parentid>
      <timestamp>2014-08-19T17:58:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>links to current support matrices</comment>
      <text xml:space="preserve" bytes="18863">{{title|C++ compiler support}}
{{cpp/language/navbar}}
{{fmbox|text=This page is work-in-progress and not yet up to date}}

The following table presents compiler support for new C++ features. These include C++11, C++14 and various technical specifications.

{| class=&quot;wikitable&quot; style=&quot;font-size:0.8em&quot;
|- style=&quot;height: 15em&quot;
| style=&quot;vertical-align:bottom;&quot; | C++ feature&lt;br/&gt;&amp;nbsp;
| style=&quot;vertical-align:bottom;&quot; | Paper(s)&lt;br/&gt;&amp;nbsp;
| {{vertical|HP aCC}}
| {{vertical|EDG eccp}}
| {{vertical|GCC}}
| {{vertical|Intel C++}}
| {{vertical|MSVC}}
| {{vertical|IBM XLC++}}
| {{vertical|Sun/Oracle C++}}
| {{vertical|Embarcadero C++ Builder}}
| {{vertical|Digital Mars C++}}
| {{vertical|Clang}}
|-
| {{tt|alignas}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf N2341]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.8}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;11.0*&lt;/span&gt;}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| {{tt|alignof}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2341.pdf N2341]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.5}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Atomic operations
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2427.html N2427]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|13.0}}
| &lt;!-- MSVC  --&gt; {{yes|11.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| {{tt|auto}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1984.pdf N1984(v1.0)]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1(v0.9)}}
| &lt;!-- GCC   --&gt; {{yes|4.4(v1.0)}}
| &lt;!-- ICC   --&gt; {{yes|11.0(v0.9)}}
| &lt;!-- MSVC  --&gt; {{yes|10.0(v0.9)}}
| &lt;!-- IBM   --&gt; {{yes|11.1(v1.0)}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| C99 preprocessor
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1653.htm N1653]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.3}}
| &lt;!-- ICC   --&gt; {{yes|11.1}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{yes|10.1}}
| &lt;!-- Sun   --&gt; {{yes|5.9}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{yes}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| Concepts (removed)
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2617.pdf N2617]
| &lt;!-- HP    --&gt; {{n/a|}}
| &lt;!-- EDG   --&gt; {{n/a|}}
| &lt;!-- GCC   --&gt; {{n/a|}}
| &lt;!-- ICC   --&gt; {{n/a|}}
| &lt;!-- MSVC  --&gt; {{n/a|}}
| &lt;!-- IBM   --&gt; {{n/a|}}
| &lt;!-- Sun   --&gt; {{n/a|}}
| &lt;!-- Embar --&gt; {{n/a|}}
| &lt;!-- Mars  --&gt; {{n/a|}}
| &lt;!-- Clang --&gt; {{n/a|}}
|-
| {{tt|constexpr}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2235.pdf N2235]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.6}}
| &lt;!-- ICC   --&gt; {{yes|13.0}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| {{tt|decltype}}
| v1.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2343.pdf N2343]&lt;br/&gt;
v1.1: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3276.pdf N3276]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1(v1.0)}}
| &lt;!-- GCC   --&gt; {{yes|4.3(v1.0)&lt;br/&gt;4.8.1(v1.1)}}
| &lt;!-- ICC   --&gt; {{yes|11.0(v1.0)}}
| &lt;!-- MSVC  --&gt; {{yes|10.0(v1.0)&lt;br/&gt;11.0(v1.1)}}
| &lt;!-- IBM   --&gt; {{yes|11.1(v1.0)}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Defaulted and deleted functions
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2346.htm N2346]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|12.0}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Delegating constructors
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1986.pdf N1986]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{yes|11.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Explicit conversion operators
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2437.pdf N2437]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.5}}
| &lt;!-- ICC   --&gt; {{yes|13.0}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Extended {{c|friend}} declarations
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1791.pdf N1791]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{yes|11.0}}
| &lt;!-- MSVC  --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;10.0*&lt;/span&gt;}}
| &lt;!-- IBM   --&gt; {{yes|11.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| {{c|extern template}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1987.htm N1987]
| &lt;!-- HP    --&gt; {{yes|3}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|3.3}}
| &lt;!-- ICC   --&gt; {{yes|9.0}}
| &lt;!-- MSVC  --&gt; {{yes|6.0}}
| &lt;!-- IBM   --&gt; {{yes|11.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| Forward {{c|enum}} declarations
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2764.pdf N2764]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.6}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{yes|11.0}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| Inheriting constructors
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2540.htm N2540]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.8}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.3}}
|-
| Initializer lists
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2672.htm N2672] 
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|13.0}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| Lambda expressions
| v0.9: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2550.pdf N2550] &lt;br/&gt;
v1.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2658.pdf N2658] &lt;br/&gt;
v1.1: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2927.pdf N2927]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1(v0.9)}}
| &lt;!-- GCC   --&gt; {{yes|4.5(v1.1)}}
| &lt;!-- ICC   --&gt; {{yes|11.0(v0.9)&lt;br/&gt;12.0(v1.0)}}
| &lt;!-- MSVC  --&gt; {{yes|10.0(v1.0)&lt;br/&gt;11.0(v1.1)}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| Local and unnamed types as template parameters
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm N2657]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.5}}
| &lt;!-- ICC   --&gt; {{yes|12.0}}
| &lt;!-- MSVC  --&gt; {{yes|10.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| {{c|long long}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1811.pdf N1811]
| &lt;!-- HP    --&gt; {{yes}}
| &lt;!-- EDG   --&gt; {{yes}}
| &lt;!-- GCC   --&gt; {{yes}}
| &lt;!-- ICC   --&gt; {{yes}}
| &lt;!-- MSVC  --&gt; {{yes}}
| &lt;!-- IBM   --&gt; {{yes}}
| &lt;!-- Sun   --&gt; {{yes}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{yes}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| Namespace Association
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2535.htm N2535]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{yes|11.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| New character types
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2249.html N2249]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Trailing function return types
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2541.htm N2541]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|12.1}}
| &lt;!-- MSVC  --&gt; {{yes|10.0}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| {{c|nullptr}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2431.pdf N2431]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.6}}
| &lt;!-- ICC   --&gt; {{yes|1=&lt;span title=&quot;undocumented&quot;&gt;12.1*&lt;/span&gt;}}
| &lt;!-- MSVC  --&gt; {{yes|10.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Unicode string literals
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm N2442] 
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|1=&lt;span title=&quot;undocumented&quot;&gt;11.0*&lt;/span&gt;}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{yes|5.7}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Raw string literals
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2442.htm N2442]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.5}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| User-defined literals
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2765.html N2765]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.1}}
|-
| Right angle brackets
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1757.html N1757]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1}}
| &lt;!-- GCC   --&gt; {{yes|4.3}}
| &lt;!-- ICC   --&gt; {{yes|11.0}}
| &lt;!-- MSVC  --&gt; {{yes|8.0}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| R-value references
| v1.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2118.html N2118]&lt;br/&gt;
v2.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2844.html N2844]&lt;br/&gt;
v2.1: [http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1138 N2844+]&lt;br/&gt;
v3.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3053.html N3053]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1(v1.0)}}
| &lt;!-- GCC   --&gt; {{yes|4.3(v1.0)&lt;br/&gt;4.5(v2.1)&lt;br&gt;4.6(v3.0)}}
| &lt;!-- ICC   --&gt; {{yes|11.1(v1.0)&lt;br/&gt;12.0(v2.0)}}
| &lt;!-- MSVC  --&gt; {{yes|10.0(v2.0)&lt;br/&gt;11.0(v2.1)}}
| &lt;!-- IBM   --&gt; {{yes|12.1(v2.1)}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes}}
|-
| {{c|static_assert}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1720.html N1720] 
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1}}
| &lt;!-- GCC   --&gt; {{yes|4.3}}
| &lt;!-- ICC   --&gt; {{yes|11.0}}
| &lt;!-- MSVC  --&gt; {{yes|10.0}}
| &lt;!-- IBM   --&gt; {{yes|11.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Strongly-typed {{c|enum}}
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2347.pdf N2347]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.4}}
| &lt;!-- ICC   --&gt; {{yes|12.0}}
| &lt;!-- MSVC  --&gt; {{yes|11.0}}
| &lt;!-- IBM   --&gt; {{yes|12.1}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Template aliases
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2258.pdf N2258]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{yes|12.1}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Thread-local storage
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2659.htm N2659]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;4.4*&lt;/span&gt;&lt;br/&gt;4.8}}
| &lt;!-- ICC   --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;11.1*&lt;/span&gt;}}
| &lt;!-- MSVC  --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;10.0*&lt;/span&gt;}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;5.9*&lt;/span&gt;}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|1=&lt;span title=&quot;partial&quot;&gt;3.3*&lt;/span&gt;&lt;br/&gt;3.3}}
|-
| Unrestricted unions
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2544.pdf N2544]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.6}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Type traits
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf N1836]
| &lt;!-- HP    --&gt; {{yes|6.16}}
| &lt;!-- EDG   --&gt; {{yes|4.0}}
| &lt;!-- GCC   --&gt; {{yes|4.3}}
| &lt;!-- ICC   --&gt; {{yes|10.0}}
| &lt;!-- MSVC  --&gt; {{yes|8.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{yes}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Variadic templates
| v0.9: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2242.pdf N2242]&lt;br/&gt;
v1.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2555.pdf N2555]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{yes|4.1(v0.9)}}
| &lt;!-- GCC   --&gt; {{yes|4.3(v0.9)&lt;br/&gt;4.4(v1.0)}}
| &lt;!-- ICC   --&gt; {{yes|12.1(v0.9)}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{yes|11.1(v0.9)}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9(v1.0)}}
|-
| Range-for loop
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2930.html N2930]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.6}}
| &lt;!-- ICC   --&gt; {{yes|13.0}}
| &lt;!-- MSVC  --&gt; {{yes|11.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| {{c|override}} and {{c|final}}
| v0.8: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2928.htm N2928]&lt;br/&gt;
v0.9: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3206.htm N3206]&lt;br/&gt;
v1.0: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3272.htm N3272] 
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{yes|12.0(v0.8)}}
| &lt;!-- MSVC  --&gt; {{yes|8.0(v0.8)&lt;br/&gt;11.0(v1.0)}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Attributes
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf N2761]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.8}}
| &lt;!-- ICC   --&gt; {{yes|12.1}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.3}}
|-
| ref-qualifiers
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2439.htm N2439]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.8.1}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|-
| Non-static data member initializers
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2756.htm N2756]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.7}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{yes|12.0}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|3.0}}
|-
| Dynamic initialization and destruction with concurrency
| [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2660.htm N2660]
| &lt;!-- HP    --&gt; {{no|}}
| &lt;!-- EDG   --&gt; {{no|}}
| &lt;!-- GCC   --&gt; {{yes|4.3}}
| &lt;!-- ICC   --&gt; {{no|}}
| &lt;!-- MSVC  --&gt; {{no|}}
| &lt;!-- IBM   --&gt; {{no|}}
| &lt;!-- Sun   --&gt; {{no|}}
| &lt;!-- Embar --&gt; {{no|}}
| &lt;!-- Mars  --&gt; {{no|}}
| &lt;!-- Clang --&gt; {{yes|2.9}}
|}

''*'' - hover over the version number to see notes


===References===
Individual vendor compatibility checklists (these are more up-to-date than the table above)
* GCC
:* [https://gcc.gnu.org/gcc-4.8/cxx0x_status.html C++11 core language support status]
:* [https://gcc.gnu.org/projects/cxx1y.html C++14 core language support status]
:* [https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#status.iso.200x C++11 library support status]
:* [https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#status.iso.2014 C++14 library support status]
:* [https://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#table.ts_status Technical Specifications support status]
* Clang++
:* [http://clang.llvm.org/cxx_status.html#cxx11 C++11 core language support status]
:* [http://clang.llvm.org/cxx_status.html#cxx14 C++14 core language support status]
:* [http://libcxx.llvm.org/cxx1y_status.html C++14 library support status]
:* [http://clang.llvm.org/cxx_status.html#ts Technical Specifications support status]
:* [http://clang.llvm.org/cxx_status.html#cxx17 C++17 core language support status]
* Intel C++
:* [https://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler C++11 core language support status]
:* [https://software.intel.com/en-us/articles/c14-features-supported-by-intel-c-compiler C++14 core language support status]
:* (note: Intel does not ship an implementation of the C++ standard library)
* Oracle C++
:* [http://docs.oracle.com/cd/E37069_01/html/E37071/gncix.html C++11 support status]</text>
      <sha1>6vmpyn7qmluzy2osmzr77j9eriqc0lz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept</title>
    <ns>0</ns>
    <id>2427</id>
    <revision>
      <id>72326</id>
      <parentid>68923</parentid>
      <timestamp>2014-08-09T06:13:54Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ numeric value type from 26.2 (26.1 in C++98) &amp; regular expression traits from 28.3</comment>
      <text xml:space="preserve" bytes="9909">{{title|Concepts}}
{{cpp/concept/navbar}}

A concept is a term that describes a '''named set of requirements''' for a type. Concepts are a more convenient way to specify both what properties are expected from a type, and what properties a type has.

There is [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3701.pdf a proposal] to include a formal specification of concepts into a future revision of C++. This proposal allows compilers to check type requirements ''before'' template instantiations, allowing much more sensible error messages when those types do not fulfill the template requirements. (This proposal replaces the original [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1758.pdf C++11 concepts] proposal, which was dropped for various reasons.)

Here ''concepts'' have little in common with the abovementioned proposal. They refer to informal named requirements, used in the C++03 and C++11 standards to define behavior and expected properties for various types. 

{{dsc begin}}
{{dsc h1 | Basic}}
{{dsc concept | cpp/concept/DefaultConstructible | specifies that an object of the type can be default constructed}}
{{dsc concept | cpp/concept/MoveConstructible | specifies that an object of the type can be constructed from rvalue | notes={{mark c++11}}}}
{{dsc concept | cpp/concept/CopyConstructible | specifies that an object of the type can be constructed from lvalue}}
{{dsc concept | cpp/concept/MoveAssignable | specifies that an object of the type can be assigned from rvalue| notes={{mark c++11}}}}
{{dsc concept | cpp/concept/CopyAssignable | specifies that an object of the type can be assigned from lvalue}}
{{dsc concept | cpp/concept/Destructible | specifies that type has a destructor}}

{{dsc h1 | Layout}}
{{dsc | Note, that the standard doesn't define named requirements or concepts with names specified in this subcategory. &lt;br&gt;These are type categories defined by the core language. They are included here as concepts only for consistency.}}
{{dsc concept | cpp/concept/TriviallyCopyable | class with trivial copy, assignment and destructor | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/TrivialType | class with trivial constructors, assignment and destructor | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/StandardLayoutType | non-virtual class containing only other StandardLayout members, all with the same access control | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/PODType | POD (Plain Old Data) structure, compatible with C {{c|struct}}  }}

{{dsc h1 | Library-wide}}
{{dsc concept | cpp/concept/EqualityComparable | has a working {{tt|operator{{==}}}} that is an equivalence relation}}
{{dsc concept | cpp/concept/LessThanComparable | {{tt|operator&lt;}} is a strict weak ordering relation}}
{{dsc concept | cpp/concept/Swappable| can be swapped with an unqualified non-member function call {{c|swap()}} | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/ValueSwappable| an {{concept|Iterator}} that dereferences to a {{concept|Swappable}} type | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/NullablePointer| pointer-like type supporting a null value | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/Hash | a {{concept|FunctionObject}} that for inputs with different values has a low probability of giving the same output | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/Allocator| class type that contains allocation information}}
{{dsc concept | cpp/concept/FunctionObject | an object that can be called with the function call syntax}}
{{dsc concept | cpp/concept/Callable | a type for which the invoke operation is defined}}
{{dsc concept | cpp/concept/Predicate | a {{concept|FunctionObject}} that returns a value convertible to {{c|bool}} for one argument without modifying it}}
{{dsc concept | cpp/concept/BinaryPredicate | a {{concept|FunctionObject}} that returns a value convertible to {{c|bool}} for two arguments without modifying them}}
{{dsc concept | cpp/concept/Compare | a {{concept|BinaryPredicate}} that establishes an ordering relation}}
{{dsc end}}
{{dsc begin}}
{{dsc h1 | Container}}
{{dsc concept | cpp/concept/Container | data structure that allows element access using iterators }}
{{dsc concept | cpp/concept/ReversibleContainer | container using bidirectional iterators }}
{{dsc concept | cpp/concept/AllocatorAwareContainer | container using an allocator | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/SequenceContainer | container with elements stored linearly }}
{{dsc concept | cpp/concept/AssociativeContainer | container that stores elements by associating them to keys }}
{{dsc concept | cpp/concept/UnorderedAssociativeContainer | container that stores elements stored in buckets by associating them to keys | notes={{mark c++11}} }}
{{dsc h2 | Container element}}
{{dsc concept | cpp/concept/CopyInsertable| element can be copy-constructed in uninitialized storage | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/MoveInsertable| element can be move-constructed in uninitialized storage | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/EmplaceConstructible| element can be constructed in uninitialized storage | notes={{mark c++11}} }}

{{dsc h1 | Iterator}}
{{dsc concept | cpp/concept/Iterator | general concept to access data within some data structure }}
{{dsc concept | cpp/concept/InputIterator | iterator that can be used to read data }}
{{dsc concept | cpp/concept/OutputIterator | iterator that can be used to write data }}
{{dsc concept | cpp/concept/ForwardIterator | iterator that can be used to read data multiple times}}
{{dsc concept | cpp/concept/BidirectionalIterator | iterator that can be both incremented and decremented }}
{{dsc concept | cpp/concept/RandomAccessIterator | iterator that can be advanced in constant time }}

{{dsc h1 | Stream I/O functions }}
&lt;!-- 27.7.2.3[istream.unformatted]/1 --&gt;
{{dsc concept | cpp/concept/UnformattedInputFunction | a stream input function that doesn't skip whitespace and counts the processed characters}}
&lt;!-- 27.7.2.2.1[istream.formatted.reqmts] --&gt;
{{dsc concept | cpp/concept/FormattedInputFunction  | a stream input function that skips leading whitespace}}
&lt;!-- 27.7.3.7[ostream.unformatted]/1 --&gt;
{{dsc concept | cpp/concept/UnformattedOutputFunction | a basic stream output function }}
&lt;!-- 27.7.3.6.1[ostream.formatted.reqmts] --&gt;
{{dsc concept | cpp/concept/FormattedOutputFunction | a stream output function that sets failbit on errors and returns a reference to the stream}}

{{dsc h1 | Random Number Generation}}
{{dsc concept | cpp/concept/SeedSequence | consumes a sequence of integers and produces a sequence of 32-bit unsigned values | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/UniformRandomNumberGenerator | returns uniformly distributed random unsigned integers | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/RandomNumberEngine | a deterministic {{concept|UniformRandomNumberGenerator}}, defined by the seed | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/RandomNumberEngineAdaptor | a {{concept|RandomNumberEngine}} that transforms the output of another {{concept|RandomNumberEngine}} | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/RandomNumberDistribution | returns random numbers distributed according to a given mathematical probability density function | notes={{mark c++11}} }}

{{dsc h1 | Concurrency}}
{{dsc concept | cpp/concept/BasicLockable | provides exclusive ownership semantics for execution agents (i.e. threads) | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/Lockable | adds attempted lock acquisition to {{concept|BasicLockable}} | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/TimedLockable | adds timed lock acquisition to {{concept|Lockable}} | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/Mutex | a {{concept|Lockable}} that protects against data races and sequentially consistent synchronization | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/TimedMutex | a {{concept|TimedLockable}} that protects against data races and sequentially consistent synchronization | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/SharedTimedMutex | a {{concept|TimedMutex}} that supports shared ownership mode | notes={{mark c++14}} }}

{{dsc h1 | Other}}
{{dsc concept | cpp/concept/UnaryTypeTrait | describes a property of a type | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/BinaryTypeTrait | describes a relationship  between two types |  notes={{mark c++11}} }}
{{dsc concept | cpp/concept/TransformationTrait | modifies a property of a type | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/Clock | aggregates a duration, a time point, and a function to get the current time point | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/TrivialClock | a {{concept|Clock}} that doesn't throw exceptions | notes={{mark c++11}} }}
{{dsc concept | cpp/concept/CharTraits | defines types and functions for a character type}}
{{dsc concept | cpp/concept/pos_type | represents a position in a stream }}
{{dsc concept | cpp/concept/off_type | represents an offset in a stream }}
{{dsc concept | cpp/concept/BitmaskType | bitset, integer, or enumeration}} &lt;!-- $17.5.2.1.3[bitmask types] --&gt;
{{dsc concept | cpp/concept/NumericType | a type for which initialization is effectively equal to assignment }} &lt;!-- C++98/03 §26.1[lib.numeric.requirements], C++11/14 §26.2[numeric.requirements] --&gt;
{{dsc concept | cpp/concept/RegexTraits | defines types and functions used by the [[cpp/regex|regular expressions library]] | notes={{mark c++11}}}} &lt;!-- C++11/14 §28.3[re.req] --&gt;
{{dsc concept | cpp/concept/LiteralType | a type with constexpr constructor | notes={{mark c++11}} }}

{{dsc end}}


{{todo|Any other missing concept?}}

[[ar:cpp/concept]]
[[de:cpp/concept]]
[[es:cpp/concept]]
[[fr:cpp/concept]]
[[it:cpp/concept]]
[[ja:cpp/concept]]
[[pt:cpp/concept]]
[[ru:cpp/concept]]
[[zh:cpp/concept]]</text>
      <sha1>kf9s9mksp74c2b27am02d8fqo6d2plz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Allocator</title>
    <ns>0</ns>
    <id>9133</id>
    <revision>
      <id>72468</id>
      <parentid>72181</parentid>
      <timestamp>2014-08-24T10:25:09Z</timestamp>
      <contributor>
        <username>Marc van Leeuwen</username>
        <id>3164</id>
      </contributor>
      <comment>make better distinction between Allocator (an object) and its type; also 'a' was never introduced</comment>
      <text xml:space="preserve" bytes="9669">{{cpp/concept/title|Allocator}}
{{cpp/concept/navbar}}

Encapsulates a memory allocation and deallocation strategy.

Every standard library component that may need to allocate or release storage, from {{tt|std::string}}, {{tt|std::vector}}, and every container except {{tt|std::array}}, to {{tt|std::shared_ptr}} and {{tt|std::function}}, does so through an {{concept|Allocator}}: an object of a class type that satisfies the following requirements.

Some requirements are optional: the template {{lc|std::allocator_traits}} supplies the default implementations for all optional requirements, and all standard library containers and other allocator-aware classes access the allocator through {{tt|std::allocator_traits}}, not directly.

===Requirements===

Given
* {{tt|A}}, an Allocator type for type {{tt|T}}
* {{tt|a}}, an object of type {{tt|A}}
* {{tt|B}}, the corresponding Allocator type for type {{tt|U}} (as obtained by rebinding {{tt|A}})
* {{tt|ptr}}, a value of type {{tt|allocator_traits&lt;A&gt;::pointer}}, obtained by calling {{c|allocator_traits&lt;A&gt;::allocate()}}
* {{tt|cptr}}, a value of type {{tt|allocator_traits&lt;A&gt;::const_pointer}}, obtained by conversion from {{tt|ptr}}
* {{tt|vptr}}, a value of type {{tt|allocator_traits&lt;A&gt;::void_pointer}}, obtained by conversion from {{tt|ptr}}
* {{tt|cvptr}}, a value of type {{tt|allocator_traits&lt;A&gt;::const_void_pointer}}, obtained by conversion from {{tt|cptr}} or from {{tt|vptr}}
* {{tt|xptr}}, a dereferencable pointer to some type {{tt|X}}

{|table class=wikitable
|-
!Expression||Requirements||Return type
|-
| {{c|A::pointer}} {{mark|optional}}
| Satisfies {{concept|NullablePointer}} and {{concept|RandomAccessIterator}}
| 
|-
| {{c|A::const_pointer}} {{mark|optional}}
| {{tt|A::pointer}} is convertible to {{tt|A::const_pointer}}. Satisfies {{concept|NullablePointer}} and {{concept|RandomAccessIterator}}
|
|-
| {{c|A::void_pointer}} {{mark|optional}}
| {{tt|A::pointer}} is convertible to {{tt|A::void_pointer}}
{{tt|B::void_pointer}} and {{tt|A::void_pointer}} are the same type. Satisfies {{concept|NullablePointer}}
|
|-
| {{c|A::const_void_pointer}} {{mark|optional}}
| {{tt|A::pointer}}, {{tt|A::const_pointer}}, and {{tt|A::void_pointer}} are convertible to {{tt|A::const_void_pointer}}
{{tt|B::const_void_pointer}} and {{tt|A::const_void_pointer}} are the same type. Satisfies {{concept|NullablePointer}}
|
|-
| {{c|A::value_type}}
| 
| the type {{tt|T}}
|-
| {{c|A::size_type}} {{mark|optional}}
| {{tt|A::size_type}} can represent the size of the largest object {{tt|A}} can allocate
| unsigned integer type
|-
| {{c|A::difference_type}} {{mark|optional}}
| {{tt|A::difference_type}} can represent the difference of any two pointers to the objects allocated by {{tt|A}}
| signed integer type
|-
| {{c|A::template rebind&lt;U&gt;::other}} {{mark|optional[1]}}
| for any {{tt|U}}, {{tt|B::template rebind&lt;T&gt;::other}} is {{tt|A}}
| the type {{tt|B}}
|-
| {{c|*ptr}}
| 
| {{tt|T&amp;}}
|-
| {{c|*cptr}}
| {{c|*cptr}} and {{c|*ptr}} identify the same object
| {{tt|const T&amp;}}
|-
| {{c|ptr-&gt;m}}
| same as {{c|(*ptr).m}}, if {{c|(*ptr).m}} is well-defined
| the type of {{tt|T::m}}
|-
| {{c|cptr-&gt;m}}
| same as {{c|(*cptr).m}}, if {{c|(*cptr).m}} is well-defined
| the type of {{tt|T::m}}
|-
| {{c|static_cast&lt;A::pointer&gt;(vptr)}}
| {{c|1=static_cast&lt;A::pointer&gt;(vptr) == ptr}}
| {{tt|A::pointer}}
|-
| {{c|static_cast&lt;A::const_pointer&gt;(cvptr)}}
| {{c|1=static_cast&lt;A::const_pointer&gt;(vptr) == cptr}}
| {{tt|A::const_pointer}}
|-
| {{c|a.allocate(n)}}
| allocates storage suitable for {{tt|n}} objects of type {{tt|T}}, but does not construct them. May throw exceptions.
| {{tt|A::pointer}}
|-
| {{c|a.allocate(n, cvptr)}} {{mark|optional}}
| same as {{tt|a.allocate(n)}}, but may use {{tt|cvptr}} (a pointer obtained from {{tt|a.allocate()}} or {{tt|nullptr_t}}) in unspecified manner to aid locality
| {{tt|A::pointer}}
|-
| {{c|a.deallocate(ptr, n)}}
| deallocates storage previously allocated by a call to {{c|a.allocate(n)}}. Does not call destructors, if any objects were constructed, they must be destroyed before calling {{c|a.deallocate()}}. Does not throw exceptions.
| (not used)
|-
| {{c|a.max_size()}} {{mark|optional}}
| the largest value that can be passed to {{tt|A::allocate()}}
| {{tt|A::size_type}}
|-
| {{c|1=a1 == a2}}
| returns {{c|true}} only if the storage allocated by the allocator {{tt|a1}} can be deallocated through {{tt|a2}}. Establishes reflexive, symmetric, and transitive relationship. Does not throw exceptions.
| {{c|bool}}
|-
| {{c|1=a1 != a2}}
| same as {{c|1=!(a1==a2)}}
| {{c|bool}}
|-
| {{c|A a1(a)}}
{{c|A a1 {{=}} a}}
| Copy-constructs {{tt|a1}} such that {{c|1=a1 == a}}. Does not throw exceptions. (Note: every {{tt|Allocator}} also satisfies {{concept|CopyConstructible}})
| 
|-
| {{c|A a(b)}}
| Constructs {{tt|a}} such that {{c|1=B(a)==b}} and {{c|1=A(b)==a}}. Does not throw exceptions. (Note: this implies that all allocators related by rebind maintain each other's resources, such as memory pools)
| 
|-
| {{c|A a1(std::move(a))}}
{{c|A a1 {{=}} std::move(a)}}
| Constructs {{tt|a1}} such that it equals the prior value of {{tt|a}}. Does not throw exceptions.
| 
|-
| {{c|A a(std::move(b))}}
| Constructs {{tt|a}} such that it equals the prior value of {{tt|A(b)}}. Does not throw exceptions.
| 
|-
| {{c|a.construct(xptr, args)}} {{mark|optional}}
| Constructs an object of type {{tt|X}} in previously-allocated storage at the address pointed to by {{tt|xptr}}, using args as the constructor arguments
| 
|-
| {{c|a.destroy(xptr)}} {{mark|optional}}
| Destructs an object of type {{tt|X}} pointed to by {{tt|xptr}}, but does not deallocate any storage.
| 
|-
| {{c|a.select_on_container_copy_construction()}} {{mark|optional}}
| Provides an instance of {{tt|A}} to be used by the container that is copy-constructed from the one that uses {{tt|a}} currently. Usually returns either a copy of {{tt|a}} or a default-constructed {{tt|A()}}.
| {{tt|A}}
|-
| {{c|a.propagate_on_container_copy_assignment}} {{mark|optional}}
| {{c|true}} if the allocator of type {{tt|A}} needs to be copied when the container that uses it is copy-assigned. Note that if the allocators of the source and the target containers do not compare equal, copy assignment has to deallocate the target's memory using the old allocator and then allocate it using the new allocator before copying the elements (and the allocator).
| {{lc|std::true_type}} or {{lc|std::false_type}} or derived from such
|-
| {{c|a.propagate_on_container_move_assignment}} {{mark|optional}}
| {{c|true}} if the allocator of type {{tt|A}} needs to be copied when the container that uses it is move-assigned. If this member is {{c|false}} and the allocators of the source and the target containers do not compare equal, move assignment cannot take ownership of the source memory and must move-assign or move-construct the elements individually, resizing its own memory as needed.
| {{lc|std::true_type}} or {{lc|std::false_type}} or derived from such
|-
| {{c|a.propagate_on_container_swap}} {{mark|optional}}
| {{c|true}} if the allocators of type {{tt|A}} need to be swapped when two containers that use them are swapped. If this member is {{c|false}} and the allocators of the two containers do not compare equal, the behavior of container swap is undefined.
| {{lc|std::true_type}} or {{lc|std::false_type}} or derived from such
|}

Notes:
[1] rebind is only optional (provided by {{lc|std::allocator_traits}}) if this allocator is a template of the form {{c|SomeAllocator&lt;T, Args&gt;}}, where {{tt|Args}} is zero or more additional template parameters.

{{rev begin}}
{{rev|since=c++14|
Given
* {{tt|x1}} and {{tt|x2}}, objects of (possibly different) types {{tt|X::void_pointer}}, {{tt|X::const_void_pointer}}, {{tt|X::pointer}}, or {{tt|X::const_pointer}}

Then, x1 and x2 are ''equivalently-valued'' pointer values, if and only if both {{tt|x1}} and {{tt|x2}} can be explicitly converted to the two corresponding objects {{tt|px1}} and {{tt|px2}} of type {{tt|X::const_pointer}}, using a sequence of {{tt|static_casts}} using only these four types, and the expression {{c|px1 {{==}} px2}} evaluates to true

Given
* {{tt|w1}} and {{tt|w2}}, objects of type {{tt|X::void_pointer}}.

Then for the expression {{c|w1 {{==}} w2}} and {{c|w1 !{{=}} w2}} either or both objects may be replaced by an ''equivalently-valued'' object of type {{tt|X::const_void_pointer}} with no change in semantics.

Given
* {{tt|p1}} and {{tt|p2}}, objects of type {{tt|X::pointer}}

Then, for the expressions {{c|p1 {{==}} p2}}, {{c|p1 !{{=}} p2}}, {{c|p1 &lt; p2}} {{c|p1 &lt;{{=}} p2}}, {{c|p1 &gt;{{=}} p2}}, {{c|p1 &gt; p2}}, {{c|p1 - p2}}} either or both objects may be replaced by an ''equivalently-valued'' object of type {{tt|X::const_pointer}} with no change in semantics.

The above requirements make it possible to compare {{concept|Container}}'s iterators and const_iterators.
}}
{{rev end}}

===Examples===
{{example|a minimum C++11 allocator 
|code=
template &lt;class Tp&gt;
struct SimpleAllocator {
  typedef Tp value_type;
  SimpleAllocator(/*ctor args*/);
  template &lt;class T&gt; SimpleAllocator(const SimpleAllocator&lt;T&gt;&amp; other);
  Tp* allocate(std::size_t n);
  void deallocate(Tp* p, std::size_t n);
};
template &lt;class T, class U&gt;
bool operator==(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);
template &lt;class T, class U&gt;
bool operator!=(const SimpleAllocator&lt;T&gt;&amp;, const SimpleAllocator&lt;U&gt;&amp;);
}}

[[de:cpp/concept/Allocator]]
[[es:cpp/concept/Allocator]]
[[fr:cpp/concept/Allocator]]
[[it:cpp/concept/Allocator]]
[[ja:cpp/concept/Allocator]]
[[pt:cpp/concept/Allocator]]
[[ru:cpp/concept/Allocator]]
[[zh:cpp/concept/Allocator]]</text>
      <sha1>6ztbkk7myenrfq4z51fxljfzb8gjabs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/AllocatorAwareContainer</title>
    <ns>0</ns>
    <id>9617</id>
    <revision>
      <id>68774</id>
      <parentid>66633</parentid>
      <timestamp>2014-03-21T02:10:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2320</comment>
      <text xml:space="preserve" bytes="4473">{{cpp/concept/title|AllocatorAwareContainer}}
{{cpp/concept/navbar}}

An {{concept|AllocatorAwareContainer}} is a {{concept|Container}} that holds an instance of an {{concept|Allocator}} and uses that instance to allocate and deallocate memory in all of its member functions.

The following rules apply to object construction

* Copy constructors of {{concept|AllocatorAwareContainer}}s obtain their instances of the allocator by calling {{c|std::allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction}} on the allocator of the container being copied.
* Move constructors obtain their instances of allocators by move-constructing from the allocator belonging to the old container.
* All other constructors take an allocator parameter.

The only way to replace an allocator is copy-assignment, move-assignment, and swap:

* Copy-assignment will replace the allocator only if {{c|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_copy_assignment::value}} is {{c|true}}
* Move-assignment will replace the allocator only if {{c|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment::value}} is {{c|true}}
* Swap will replace the allocator only if {{c|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value}} is {{c|true}}. Specifically, it will exchange the allocator instances through an unqualified call to the non-member function swap, see {{concept|Swappable}}.

Note: swapping two containers with unequal allocators if {{tt|propagate_on_container_swap}} is {{c|false}} is undefined behavior.

* The accessor {{tt|get_allocator()}} obtains a copy of the allocator that was used to construct the container or installed by the most recent allocator replacement operation.

===Requirements===
{{dsc begin}}
{{dsc h1|Legend}}
{{dsc|{{ttb|X}}|Container type}}
{{dsc|{{ttb|T}}|Element type}}
{{dsc|{{ttb|A}}|Allocator for {{ttb|T}} }}
{{dsc|{{ttb|a}}, {{ttb|b}}|Objects of type {{ttb|X}} (non-const lvalue)}}
{{dsc|{{ttb|t}}|Object of type {{ttb|X}} (lvalue or const rvalue) }}
{{dsc|{{ttb|rv}}|Object of type {{ttb|X}} (non-const rvalue) }}
{{dsc|{{ttb|m}}|Object of type {{ttb|A}} }}
{{dsc|{{ttb|Q}}| Allocator type }}
{{dsc end}}


{|class=wikitable
!expression||return type||pre/requirements||post/effects||complexity
|-
|{{c|allocator_type}}||{{ttb|A}}||{{c|allocator_type::value_type}} must be the same as {{c|X::value_type}} || || constant
|-
|{{c|get_allocator()}}||{{ttb|A}}|| || || constant
|-
|{{c|X u;}} || ||{{ttb|A}} is {{concept|DefaultConstructible}}|| {{c|u.empty() {{==}} true &amp;&amp; u.get_allocator() {{==}} A()}}  || constant
|-
|{{c|X u(m);}} || || || {{c|u.empty() {{==}} true &amp;&amp; u.get_allocator() {{==}} m}} || constant
|-
|{{c|X u(t,m);}} || 
| {{ttb|T}} is {{concept|CopyInsertable}} into {{ttb|X}}
|{{c|u {{==}} t &amp;&amp; u.get_allocator() {{==}} m}} || linear
|-
|{{c|X u(rv);}} ||
| Move constructor of {{ttb|A}} must not throw exceptions 
| {{ttb|u}} has the same elements and an equal allocator as {{ttb|rv}} had before the construction || constant
|-
|{{c|X u(rv,m);}}|| 
|{{ttb|T}} is {{concept|MoveInsertable}} into {{ttb|X}}
| The elements of {{ttb|u}} are the same or copies of those of {{ttb|rv}} and {{c|u.get_allocator() {{==}} m}}
| constant if {{c|m {{==}} rv.get_allocator()}}, otherwise linear
|-
|{{c|a {{=}} t}}||{{c|X&amp;}}
|{{c|{{ttb|T}} is {{concept|CopyInsertable}} into {{ttb|X}} and {{concept|CopyAssignable}} ||{{c|a {{==}} t}} || linear
|-
|{{c|a {{=}} rv}}||{{c|X&amp;}}
|If the allocator will &lt;i&gt;not&lt;/i&gt; be replaced by move-assignment (see above), then {{ttb|T}} is {{concept|MoveInsertable}} into {{ttb|X}} and {{concept|MoveAssignable}}
|All existing elements of {{ttb|a}} are either move assigned to or destroyed; {{ttb|a}} is equal to the value that {{ttb|rv}} had before the assignment|| linear
|-
|{{c|a.swap(b)}}||void|| || Exchanges the contents of {{ttb|a}} and {{ttb|b}} || constant
|-
|}

===Concept requirements===
;A
* {{concept|DefaultConstructible}}
;T
* {{concept|CopyInsertable}}
;X
* {{concept|CopyAssignable}}

===Standard library===
All standard library containers except {{lc|std::array}} are {{concept|AllocatorAwareContainer}}s:
* {{lc|std::basic_string}}
* {{lc|std::deque}}
* {{lc|std::forward_list}}
* {{lc|std::list}}
* {{lc|std::vector}}
* {{lc|std::map}}
* {{lc|std::multimap}}
* {{lc|std::set}}
* {{lc|std::multiset}}
* {{lc|std::unordered_map}}
* {{lc|std::unordered_multimap}}
* {{lc|std::unordered_set}}
* {{lc|std::unordered_multiset}}</text>
      <sha1>clgr20tyaofuwhdixwfs69z99y1ei8l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/AssociativeContainer</title>
    <ns>0</ns>
    <id>13038</id>
    <revision>
      <id>72446</id>
      <parentid>72426</parentid>
      <timestamp>2014-08-22T14:11:57Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Requirements */</comment>
      <text xml:space="preserve" bytes="4604">{{cpp/concept/title|AssociativeContainer}}
{{cpp/concept/navbar}}

An {{ttb|AssociativeContainer}} is an ordered {{concept|Container}} that provides fast lookup of objects based on keys.

===Requirements===
{{dsc begin}}
{{dsc h1|Legend}}
{{dsc|{{ttb|X}}|Container type}}
{{dsc|{{ttb|a}}|Object of type {{ttb|X}}}}
{{dsc|{{ttb|a_uniq}}|Object in {{ttb|X}} when {{ttb|X}} supports unique keys}}
{{dsc|{{ttb|a_eq}}|Object in {{ttb|X}} when {{ttb|X}} supports multiple keys}}
{{dsc|{{ttb|a_trans}}|Object in {{ttb|X}} when type {{tt|X::key_compare::is_transparent}} exists}}
{{dsc|{{ttb|i}}, {{ttb|j}}|{{concept|InputIterator}}s denoting a valid range}}
{{dsc|{{ttb|p}}|const_iterator to {{ttb|a}} }}
{{dsc|{{ttb|q}}|dereferenceable const_iterator to {{ttb|a}} }}
{{dsc|{{ttb|q1}}, {{ttb|q2}}|const_iterators denoting a valid range in {{ttb|a}} }}
{{dsc|{{ttb|il}}|{{lc|std::initializer_list}}&lt;value_type&gt;}}
{{dsc|{{ttb|t}}|Object of type {{ttb|X::value_type}} }}
{{dsc|{{ttb|k}}|Object of type {{ttb|X::key_type}} }}
{{dsc|{{ttb|c}}|Object of type {{ttb|X::key_compare}} }}
{{dsc|{{ttb|A}}|Storage allocator used by {{ttb|X}}, or {{lc|std::allocator_type&lt;X::value_type&gt;}} }}
{{dsc|{{ttb|m}}|Allocator of a type convertible to {{ttb|A}} }}
{{dsc end}}

{|class=wikitable
!expression||return type||pre/requirements||post/effects||complexity
|-
|{{c|X::key_type}}||{{ttb|Key}}||{{ttb|Key}} is {{concept|Destructible}}|| ||compile time
|-
|{{c|X::key_compare}}||{{ttb|Compare}}|| || ||compile time
|-
|{{c|X::value_compare}}||a type satisfying {{concept|BinaryPredicate}}||{{c|key_compare}} for {{c|std::set}} and {{c|std::multiset}}; an ordering relation over {{ttb|Key}} for {{c|std::map}} and {{c|std::multimap}} || ||compile time
|-
|{{c|X(c)}}, {{c|X a(c);}}|| ||{{c|key_compare}} is {{concept|CopyConstructible}}||Construct an empty container using a copy of {{c|c}} as {{ttb|key_comp}}||constant
|-
|{{c|X()}}, {{c|X a;}}|| ||{{c|key_compare}} is {{concept|CopyConstructible}}||Construct an empty container using a {{c|Compare()}} as {{ttb|key_comp}}||constant
|-
|{{c|X(i, j, c)}}, {{c|X a(i, j, c);}}|| ||{{c|key_compare}} is {{concept|CopyConstructible}} and {{c|value_type}} is {{concept|EmplaceConstructible}} into {{c|X}} from {{c|*i}}||Constructs an empty container using a copy of {{c|c}} as {{ttb|key_comp}} and inserts all elements from the range {{tt|[i; j)}}||generally {{tt|N log N}}, or {{tt|N}} if {{tt|[i, j)}} is sorted (where {{tt|N}} is {{c|std::distance(i, j)}}) 
|-
|{{c|X(i, j)}}, {{c|X a(i, j);}}|| ||{{c|key_compare}} is {{concept|CopyConstructible}} and {{c|value_type}} is {{concept|EmplaceConstructible}} into {{c|X}} from {{c|*i}}||Constructs an empty container using a {{c|Compare()}} as {{ttb|key_comp}} and inserts all elements from the range {{tt|[i; j)}}||generally {{tt|N log N}}, or {{tt|N}} if {{tt|[i, j)}} is sorted according to {{c|value_comp()}} (where {{tt|N}} is {{c|std::distance(i, j)}}) 
|-
|{{c|X(il);}}|| ||Equivalent to {{c|X(il.begin(), il.end());}}||Equivalent to {{c|X(il.begin(), il.end());}}
|-
|{{c|a {{=}} il}}||{{c|X&amp;}}||{{ttb|T}} is {{concept|CopyInsertable}} into {{ttb|X}} and also {{concept|CopyAssignable}}||Assign the range {{c|[il.begin(), il.end())}} into {{ttb|a}}. Elements of {{ttb|a}} that were not assigned to are destroyed||generally {{tt|N log N}}, or {{tt|N}} if {{c|[il.begin(), il.end())}} is sorted according to {{c|value_comp()}} (where {{tt|N}} is {{c|il.size() + a.size()}})
|-
|{{c|a.key_comp()}}||{{c|X::key_compare}}|| ||The comparison object with which {{ttb|a}} was constructed is returned.||constant
|-
|{{c|a.value_comp()}}||{{c|X::value_compare}}|| ||An object of type {{c|X::value_compare}} constructed out of the comparison object is returned.||constant
|-
|}

An AssociativeContainer {{ttb|X}} that is either {{ttb|std::map}} and {{ttb|std::multimap}} additionally supports the expression X::mapped_type, which has a return type of T, with the requirement that {{ttb|T}} be {{concept|Destructible}}, and compile time complexity.

{{todo|Finish requirements.}}

===AssociativeContainers in the standard library===
{{dsc begin}}
{{dsc inc | cpp/container/dsc set}}
{{dsc inc | cpp/container/dsc multiset}}
{{dsc inc | cpp/container/dsc map}}
{{dsc inc | cpp/container/dsc multimap}}
{{dsc end}}


[[de:cpp/concept/AssociativeContainer]]
[[es:cpp/concept/AssociativeContainer]]
[[fr:cpp/concept/AssociativeContainer]]
[[it:cpp/concept/AssociativeContainer]]
[[ja:cpp/concept/AssociativeContainer]]
[[pt:cpp/concept/AssociativeContainer]]
[[ru:cpp/concept/AssociativeContainer]]
[[zh:cpp/concept/AssociativeContainer]]</text>
      <sha1>lhey5t57ow29c65lrc32wbvinlsqbn7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/BasicLockable</title>
    <ns>0</ns>
    <id>8926</id>
    <revision>
      <id>65580</id>
      <parentid>42230</parentid>
      <timestamp>2013-09-21T01:11:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso mutex</comment>
      <text xml:space="preserve" bytes="1120">{{cpp/concept/title|BasicLockable}}
{{cpp/concept/navbar}}

The {{tt|BasicLockable}} concept describes the minimal characteristics of types that provide exclusive blocking semantics for execution agents (i.e. threads).

===Requirements===

For type {{ttb|L}} to be {{tt|BasicLockable}}, the following conditions have to be satisfied for an object {{ttb|m}} of type {{ttb|L}}:
{|table class=wikitable
|-
!Expression||Requires||Effects
|-
|{{c|m.lock()}}
|
|Blocks until a lock can be obtained for the current execution agent.  If an exception is thrown, no lock is obtained.
|-
|{{c|m.unlock()}}
|The current execution agent should hold the lock {{tt|m}}.
|Releases the lock held by the execution agent.  Throws no exceptions.
|}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|Mutex}}
* {{concept|Lockable}}
* {{concept|TimedLockable}}

[[de:cpp/concept/BasicLockable]]
[[es:cpp/concept/BasicLockable]]
[[fr:cpp/concept/BasicLockable]]
[[it:cpp/concept/BasicLockable]]
[[ja:cpp/concept/BasicLockable]]
[[pt:cpp/concept/BasicLockable]]
[[ru:cpp/concept/BasicLockable]]
[[zh:cpp/concept/BasicLockable]]</text>
      <sha1>035de56uvwh1fn4izr5uch02xzo47b9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/BidirectionalIterator</title>
    <ns>0</ns>
    <id>5519</id>
    <revision>
      <id>70269</id>
      <parentid>45715</parentid>
      <timestamp>2014-05-14T15:51:56Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>more precise requirement for operator--</comment>
      <text xml:space="preserve" bytes="1213">{{cpp/concept/title|BidirectionalIterator}}
{{cpp/concept/navbar}}

A {{tt|BidirectionalIterator}} is a {{concept|ForwardIterator}} that can be moved in both directions (i.e. incremented and decremented).

===Requirements===
* {{concept|ForwardIterator}}
In addition to the above requirement, for a type {{tt|It}} to be an {{tt|BidirectionalIterator}}, an instance {{tt|i}} of {{tt|It}} must:

{|table class=&quot;wikitable&quot;
|-
!Expression||Return||Equivalent expression||Notes
|-
|{{c|--i}}||{{c|It&amp;}}|| ||After this, copies of {{ttb|i}} are still valid
|-
|{{c|i--}}|| convertible to {{c|const It&amp;}}||{{c|
It temp {{=}} i;
--i;
return temp;
}} ||
|-
|{{c|*i--}}||{{c|reference}}|| ||
|-
|}
A {{tt|mutable BidirectionalIterator}} is a {{tt|BidirectionalIterator}} that additionally satisfies the {{concept|OutputIterator}} requirements.

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/BidirectionalIterator]]
[[es:cpp/concept/BidirectionalIterator]]
[[fr:cpp/concept/BidirectionalIterator]]
[[it:cpp/concept/BidirectionalIterator]]
[[ja:cpp/concept/BidirectionalIterator]]
[[pt:cpp/concept/BidirectionalIterator]]
[[ru:cpp/concept/BidirectionalIterator]]
[[zh:cpp/concept/BidirectionalIterator]]</text>
      <sha1>k4enrkrsior59yogw90k534pqtucqz0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/BinaryPredicate</title>
    <ns>0</ns>
    <id>9766</id>
    <revision>
      <id>67874</id>
      <parentid>63146</parentid>
      <timestamp>2014-03-04T04:10:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/callable/predicate</comment>
      <text xml:space="preserve" bytes="1707">{{cpp/concept/title|BinaryPredicate}}
{{cpp/concept/navbar}}

The concept {{concept|BinaryPredicate}} is a set of requirements expected by some of the standard library facilities from the user-provided arguments.

Given a {{concept|BinaryPredicate}} {{tt|bin_pred}} and a pair of iterators {{tt|iter1}} and {{tt|iter2}} or an iterator {{tt|iter}} and a value {{tt|value}}, the expression  {{c|bin_pred(*iter1, *iter2)}} or, respectively, {{c|bin_pred(*iter, value)}}, must be [[cpp/language/implicit_cast|contextually convertible]] to {{c|bool}}.

In addition, evaluation of that expression is not allowed to call non-const member functions of the dereferenced iterators.

===Requirements===
* {{concept|Predicate}}
* {{concept|CopyConstructible}} (unless otherwise specified)

===Standard library===
The following standard library facilities expect a {{concept|BinaryPredicate}} which isn't a {{concept|Compare}} type.
{{dsc begin}}
{{dsc inc | cpp/container/dsc unique | forward_list}}
{{dsc inc | cpp/container/dsc unique | list}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc find_first_of}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc inc | cpp/algorithm/dsc is_permutation}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc inc | cpp/algorithm/dsc search_n}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc inc | cpp/algorithm/dsc unique_copy}}
{{dsc inc | cpp/utility/functional/dsc not2}}
{{dsc inc | cpp/container/dsc unordered_set}}
{{dsc inc | cpp/container/dsc unordered_map}}
{{dsc inc | cpp/container/dsc unordered_multiset}}
{{dsc inc | cpp/container/dsc unordered_multimap}}
{{dsc end}}</text>
      <sha1>7dtf2nqaduu71eh57i7yidotj4ctyyr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/BitmaskType</title>
    <ns>0</ns>
    <id>9092</id>
    <revision>
      <id>68863</id>
      <parentid>66367</parentid>
      <timestamp>2014-03-22T20:01:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 1450</comment>
      <text xml:space="preserve" bytes="2272">{{cpp/concept/title|BitmaskType}}
{{cpp/concept/navbar}}

Defines a type that can be used to represent a set of constant values or any combination of those values. This trait is typically implemented by integer types, {{lc|std::bitset}}, or enumerations (scoped and unscoped) with additional operator overloads.

===Requirements===

The bitmask type supports a finite number of bitmask elements, which are distinct non-zero values of the bitmask type, such that, for any pair Ci and Cj, {{c|Ci &amp; Ci !{{=}} 0}} and {{c|1=Ci &amp; Cj == 0}}. In addition, the value {{tt|0}} is used to represent an empty bitmask, with no values set.

The bitwise operators {{c|operator&amp;}}, {{c|operator{{!}}}}, {{c|operator^}}, {{c|operator~}}, {{c|operator&amp;{{=}}}}, {{c|operator{{!}}{{=}}}}, and {{c|operator^{{=}}}} are defined for values of the bitmask type and have the same semantics as the corresponding built-in operators on unsigned integers would have if the bitmask elements were the distinct integer powers of two.

The following expressions are well-formed and have the following meaning for any BitsetType X

{{dsc begin}}
{{dsc | {{c|X {{!}}{{=}} Y}} | sets the value Y in the object X }}
{{dsc | {{c|X &amp;{{=}} ~Y}} | clears the value Y in the object X }}
{{dsc | {{c|(X&amp;Y) !{{=}} 0}} | indicates that the value Y is set in the object X }}
{{dsc end}}

Each representible bitmask element is defined as a {{c|constexpr}} value of the bitmask type.

===Usage===
The following standard library types satisfy {{concept|BitmaskType}}:
* {{lc|std::ctype_base::mask}}
* {{lc|std::ios_base::fmtflags}}
* {{lc|std::ios_base::iostate}}
* {{lc|std::ios_base::openmode}}
* {{c|std::regex_traits::char_class_type}}
* {{lc|std::regex_constants::syntax_option_type}}
* {{lc|std::regex_constants::match_flag_type}}
* {{lc|std::launch}}, 

Code that relies on some particular implementation option (e.g. {{c|1=int n = std::ios_base::hex}}), is nonportable because {{lc|std::ios_base::fmtflags}} is not necessarily implicitly convertible to {{c|int}}.

[[de:cpp/concept/BitmaskType]]
[[es:cpp/concept/BitmaskType]]
[[fr:cpp/concept/BitmaskType]]
[[it:cpp/concept/BitmaskType]]
[[ja:cpp/concept/BitmaskType]]
[[pt:cpp/concept/BitmaskType]]
[[ru:cpp/concept/BitmaskType]]
[[zh:cpp/concept/BitmaskType]]</text>
      <sha1>6f21gxtkp6wwjs2rxdozaj4smh45ve3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Callable</title>
    <ns>0</ns>
    <id>13171</id>
    <revision>
      <id>71476</id>
      <parentid>71086</parentid>
      <timestamp>2014-06-11T15:05:17Z</timestamp>
      <contributor>
        <ip>194.116.198.185</ip>
      </contributor>
      <text xml:space="preserve" bytes="2788">{{cpp/concept/title|Callable}}
{{cpp/concept/navbar}}

A {{concept|Callable}} type is a type, for which the INVOKE operation, as defined by {{lc|std::function}}, {{lc|std::bind}}, or {{lc|std::thread::thread}} is applicable.

===Requirements===

The type {{tt|T}} satisfies {{tt|Callable}} if

Given
* {{tt|f}}, an object of type {{tt|T}} or {{tt|const T}}
* {{tt|ArgTypes}}, suitable argument list
* {{tt|R}}, suitable return type

The following expressions must be valid:

{|table class=wikitable
|-
!Expression||Requirements
|-
| {{c|1=INVOKE(f, std::declval&lt;ArgTypes&gt;..., R)}}
| the expression is well-formed in unevaluated context
|}

where ''INVOKE(f, t1, t2, ..., tn, R)'' is defined as ''INVOKE(f, t1, t2, ..., tn)'', implicitly converted to {{tt|R}}

where ''INVOKE(f, t1, t2, ..., tn)'' is defined as follows:
* if {{tt|f}} is a [[cpp/language/pointer#Pointers_to_member_functions|pointer to member function]] of class {{tt|T}} and {{tt|t1}} is an object of class {{tt|T}} or reference to an object of class {{tt|T}} or derived from {{tt|T}}, then {{c|INVOKE(f, t1, t2, ..., tn)}} is equivalent to {{c|(t1.*f)(t2, ..., tn)}}
* otherwise, if {{tt|f}} is a pointer to member function and {{tt|t1}} is not one of the types described above, then {{c|INVOKE(f, t1, t2, ..., tn)}} is equivalent to {{c|((*t1).*f)(t2, ..., tn)}} 
* otherwise, if N == 1 and {{tt|f}} is a [[cpp/language/pointer#Pointers_to_data_members|pointer to data member]] of class {{tt|T}} and {{tt|t1}} is an object of class {{tt|T}} or reference to an object of class {{tt|T}} or derived from {{tt|T}}, then {{c|INVOKE(f, t1)}} is equivalent to {{c|t1.*f}}
* otherwise, if N == 1 and {{tt|f}} is a pointer to data member of class {{tt|T}} and {{tt|t1}} is not one of the types described above, then {{c|INVOKE(f, t1)}} is equivalent to {{c|(*t1).*f}}
* otherwise, {{c|INVOKE(f, t1, t2, ..., tn)}} is equivalent to {{c|f(t1, t2, ..., tn)}} (that is, {{tt|f}} is a {{concept|FunctionObject}})

===Notes===
For pointers to member functions and pointers to data members, {{tt|t1}} may be a regular pointer or an object of class type that overloads {{tt|operator*}}, such as {{lc|std::unique_ptr}} or {{lc|std::shared_ptr}}.


[[cpp/language/pointer#Pointers_to_data_members|Pointers to data members]] are {{tt|Callable}}, even though no function calls take place.

===Standard library===
In addition, the following standard library facilities accept any {{concept|Callable}} type (not just {{concept|FunctionObject}})

{{dsc begin}}
{{dsc | {{lc|std::function}} }}
{{dsc | {{lc|std::bind}} }}
{{dsc | {{lc|std::result_of}} }}
{{dsc | {{lc|std::thread::thread}} }}
{{dsc | {{lc|std::call_once}} }}
{{dsc | {{lc|std::async}} }}
{{dsc | {{lc|std::packaged_task}} }}
{{dsc | {{lc|std::reference_wrapper}} }}
{{dsc end}}</text>
      <sha1>o0i5w9xxmnh9jumarqs8l2s2ixla7gr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Clock</title>
    <ns>0</ns>
    <id>9876</id>
    <revision>
      <id>49400</id>
      <parentid>47365</parentid>
      <timestamp>2013-06-01T02:35:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1466">{{cpp/concept/title|Clock}}
{{cpp/concept/navbar}}

The {{tt|Clock}} concept describes a bundle consisting of a {{lc|std::chrono::duration}}, a {{lc|std::chrono::time_point}}, and a function {{c|now()}} to get the current time_point. The origin of the clock's time_point is referred to as the clock's epoch.

===Requirements===

{{c|C1}} and {{c|C2}} denote clock types. {{c|t1}} and {{c|t2}} are values returned by {{c|C1::now()}} where the call returning {{c|t1}} happens before the call returning {{c|t2}} and both of these calls occur before {{c|C1::time_point::max()}}.

{|table class=wikitable
|-
!Expression||Return type||Operational semantics
|-
|{{c|C1::rep}}
|An arithmetic type or a class emulating an arithmetic type
|The representation type of {{c|C1::duration}}.
|-
|{{c|C1::period}}
|A specialization of {{lc|std::ratio}}
|The tick period of the clock in seconds.
|-
|{{c|C1::duration}}
|{{c|std::chrono::duration&lt;C1::rep, C1::period&gt;}}
|The duration type of the clock.
|-
|{{c|C1::time_point}}
|{{c|std::chrono::time_point&lt;C1&gt;}} or {{c|std::chrono::time_point&lt;C2, C1::duration&gt;}}
|The {{lc|std::chrono::time_point}} type of the clock. C1 and C2 shall refer to the same epoch.
|-
|{{c|C1::is_steady}}
|{{c|const bool}}
|True if {{c|t1 &lt; t2}} is always {{c|true}} and the time between clock ticks is constant, otherwise {{c|false}}
|-
|{{c|C1::now()}}
|{{c|C1::time_point}}
|Returns a {{c|time_point}} object representing the current point in time.
|-}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Compare</title>
    <ns>0</ns>
    <id>13131</id>
    <revision>
      <id>67156</id>
      <timestamp>2014-01-24T04:19:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3932">{{cpp/concept/title|Compare}}
{{cpp/concept/navbar}}

The concept {{concept|Compare}} is a set of requirements expected by some of the standard library facilities from the user-provided function object types.

The return value of the function call operation applied to an object of type {{tt|Compare}}, when [[cpp/language/implicit_cast|contextually converted]] to {{c|bool}}, yields {{c|true}} if the first argument of the call appears before the second in the ''strict weak ordering relation'' induced by this {{tt|Compare}} type, and {{c|false}} otherwise.

As with any {{concept|BinaryPredicate}}, evaluation of that expression is not allowed to call non-const member functions of the dereferenced iterators.

===Requirements===
The type {{tt|T}} satisfies {{tt|Compare}} if

* The type {{tt|T}} satisfies {{concept|BinaryPredicate}}, and

Given
* {{tt|comp}}, an object of type {{tt|Compare}}
* {{tt|equiv(a, b)}}, an expression equivalent to {{tt|!comp(a, b) &amp;&amp; !comp(b, a)}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Requirements
|-
| {{c|comp(a, b)}}
| [[cpp/language/implicit_cast|implicitly convertible]] to {{c|bool}}
| Establishes [[enwiki:Strict_weak_ordering|strict weak ordering]] relation with the following properties
* For all {{tt|a}}, {{c|comp(a,a){{==}}false}}
* If {{c|comp(a,b){{==}}true}} then {{c|comp(b,a){{==}}false}}
* if {{c|comp(a,b){{==}}true}} and {{c|comp(b,c){{==}}true}} then {{c|comp(a,c){{==}}true}}
|-
| {{c|equiv(a, b)}}
| {{c|bool}}
| Establishes equivalence relationship with the following properties
* For all {{tt|a}}, {{c|equiv(a,a){{==}}true}}. 
* If {{c|equiv(a,b){{==}}true}}, then {{c|equiv(b,a){{==}}true}}
* If {{c|equiv(a,b){{==}}true}} and {{c|equiv(b,c){{==}}true}}, then {{c|equiv(a,c){{==}}true}}
|}

Note: {{tt|comp}} induces a ''strict total ordering'' on the equivalence classes determined by {{tt|equiv}}

===Standard library===
The following standard library facilities expect a {{concept|Compare}} type.
{{dsc begin}}
{{dsc inc | cpp/container/dsc set}}
{{dsc inc | cpp/container/dsc map}}
{{dsc inc | cpp/container/dsc multiset}}
{{dsc inc | cpp/container/dsc multimap}}
{{dsc inc | cpp/container/dsc priority_queue}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/container/dsc sort | forward_list}}
{{dsc inc | cpp/container/dsc sort | list}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc | cpp/algorithm/dsc is_sorted}}
{{dsc inc | cpp/algorithm/dsc is_sorted_until}}
{{dsc inc | cpp/algorithm/dsc nth_element}}
{{dsc inc | cpp/algorithm/dsc lower_bound}}
{{dsc inc | cpp/algorithm/dsc upper_bound}}
{{dsc inc | cpp/algorithm/dsc binary_search}}
{{dsc inc | cpp/algorithm/dsc equal_range}}
{{dsc inc | cpp/algorithm/dsc merge}}
{{dsc inc | cpp/container/dsc merge | forward_list}}
{{dsc inc | cpp/container/dsc merge | list}}
{{dsc inc | cpp/algorithm/dsc inplace_merge}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc set_intersection}}
{{dsc inc | cpp/algorithm/dsc set_symmetric_difference}}
{{dsc inc | cpp/algorithm/dsc set_union}}
{{dsc inc | cpp/algorithm/dsc push_heap}}
{{dsc inc | cpp/algorithm/dsc pop_heap}}
{{dsc inc | cpp/algorithm/dsc make_heap}}
{{dsc inc | cpp/algorithm/dsc sort_heap}}
{{dsc inc | cpp/algorithm/dsc is_heap}}
{{dsc inc | cpp/algorithm/dsc is_heap_until}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc next_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}</text>
      <sha1>naeencwylki9jfv16krvtj0dl8h4432</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Container</title>
    <ns>0</ns>
    <id>8490</id>
    <revision>
      <id>68766</id>
      <parentid>68765</parentid>
      <timestamp>2014-03-21T01:32:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2257</comment>
      <text xml:space="preserve" bytes="3896">{{cpp/concept/title|Container}}
{{cpp/concept/navbar}}

A {{tt|Container}} is an object used to store other objects and taking care of the management of the memory used by the objects it contains.

===Requirements===
* {{ttb|C}} Container type
* {{ttb|T}} Element type
* {{ttb|a}}, {{ttb|b}} Objects of type {{ttb|C}}
====Types====
{|class=wikitable
!name||type||notes
|-
|{{tt|value_type}}||T||{{concept|Destructible}}
|-
|{{tt|reference}}||T&amp;||
|-
|{{tt|const_reference}}||const T&amp;||
|-
|{{tt|iterator}}||iterator pointing to T||{{concept|ForwardIterator}}&lt;br/&gt;convertible to {{ttb|const_iterator}}
|-
|{{tt|const_iterator}}||const iterator pointing to T||{{concept|ForwardIterator}}
|-
|{{tt|difference_type}}||signed integer
|must be the same as {{ttb|[[cpp/iterator/iterator_traits|iterator_traits]]::difference_type}} for {{ttb|iterator}} and {{ttb|const_iterator}}
|-
|{{tt|size_type}}||unsigned integer||large enough to represent all positive values of {{ttb|difference_type}}
|}
====Methods and operators====
{|class=wikitable
!expression||return type||semantics||conditions||complexity
|-
|{{c|C()}}||C||Creates an empty container|| Post: C().empty() == true||Constant
|-
|{{c|C(a)}}||C||Create a copy of {{ttb|a}}||Pre: T must be {{concept|CopyInsertable}}&lt;br/&gt;Post: a == C(a)||Linear
|-
|{{c|a {{=}} b}}||C&amp;||All elements of {{ttb|a}} are destroyed or move assigned to elements of b||Post: a == b||Linear
|-
|{{c|(&amp;a)-&gt;~C()}}||void||Destroy all elements and free all memory||  ||Linear
|-
|{{c|a.begin()}}||(const_)iterator||Iterator to the first element|| ||Constant
|-
|{{c|a.end()}}||(const_)iterator||Iterator to one passed the last element||  ||Constant
|-
|{{c|a.cbegin()}}{{mark since c++11}}||const_iterator||{{c|const_cast&lt;const C&amp;&gt;(a).begin()}}|| ||Constant
|-
|{{c|a.cend()}}{{mark since c++11}}||const_iterator||{{c|const_cast&lt;const C&amp;&gt;(a).end()}}|| ||Constant
|-
|{{c|a {{==}} b}} || convertible to bool || {{c|std::equal(a.begin(), a.end(), b.begin(), b.end())}}{{mark since c++14}} ||Pre: T must be {{concept|EqualityComparable}} || Constant&lt;ref&gt;always linear for {{lc|std::forward_list}}&lt;/ref&gt; if {{tt|a.size() !{{=}} b.size()}}, linear otherwise
|-
|{{c|a !{{=}} b}} || convertible to bool || {{c|!(a{{==}}b)}} || || Linear
|-
|{{c|a.swap(b)}} || void || exchanges the values of a and b || 
| Constant&lt;ref name=&quot;array&quot;&gt;{{mark since c++11}} Linear for {{lc|std::array}}&lt;/ref&gt;&lt;ref name=&quot;should&quot;&gt;{{mark until c++11}} Not strictly constant&lt;/ref&gt;
|-
|{{c|swap(a,b)}} || void || {{c|a.swap(b)}} || || Constant&lt;ref name=&quot;array&quot;/&gt;
|-
|{{c|a.size()}} || size_type || {{c|distance(a.begin(),a.end())}} || || Constant&lt;ref name=&quot;should&quot; /&gt;
|-
|{{c|a.max_size()}} || size_type || b.size() where b is the largest possible container || || Constant&lt;ref name=&quot;should&quot; /&gt;
|-
|{{c|a.empty()}} || convertible to bool || {{c|a.begin() {{==}} a.end()}} || || Constant
|-
!colspan=6|notes
|-
|colspan=6|&lt;references/&gt;
|}

{{rev begin}}
{{rev |since=c++14|
Given

* {{tt|i}} and {{tt|j}}, objects of a container's {{tt|iterator}} type,

In the expressions {{c|i {{==}} j}}, {{c|i !{{=}} j}}, {{c|i &lt; j}}, {{c|i &lt;{{=}} j}}, {{c|i &gt;{{=}} j}}, {{c|i &gt; j}}, {{c|i - j}}, either or both may be replaced by an object of the container's {{tt|const_iterator}} type referring to the same element with no change in semantics.
}}
{{rev end}}

===Container data races===
see [[cpp/container#Thread_safety|container thread safety]]

===Other concepts===
;C
* {{concept|DefaultConstructible}}
* {{concept|CopyConstructible}}
* {{concept|EqualityComparable}}
* {{concept|Swappable}}
;T
* {{concept|CopyInsertable}}
* {{concept|EqualityComparable}}
* {{concept|Destructible}}

[[de:cpp/concept/Container]]
[[es:cpp/concept/Container]]
[[fr:cpp/concept/Container]]
[[it:cpp/concept/Container]]
[[ja:cpp/concept/Container]]
[[pt:cpp/concept/Container]]
[[ru:cpp/concept/Container]]
[[zh:cpp/concept/Container]]</text>
      <sha1>8mpg3ya89md69llcg43of2oxs6vdp18</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/CopyAssignable</title>
    <ns>0</ns>
    <id>5431</id>
    <revision>
      <id>66753</id>
      <parentid>66744</parentid>
      <timestamp>2013-12-28T20:48:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention lvalue in the intro sentence</comment>
      <text xml:space="preserve" bytes="1167">{{cpp/concept/title|CopyAssignable}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be copy-assigned from an [[cpp/language/value_category|lvalue expression]].

===Requirements===

The type {{tt|T}} satisfies {{tt|CopyAssignable}} if

* The type {{tt|T}} satisfies {{concept|MoveAssignable}}, and

Given
* {{tt|v}}, an [[cpp/language/value_category|lvalue]] expression of type {{tt|T}} or {{tt|const T}} or an [[cpp/language/value_category|rvalue]] expression of type {{tt|const T}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Return value||Post-conditions
|-
| {{c|1=t = v}}
| {{tt|T&amp;}}
| {{tt|t}}
| The value of {{tt|t}} is equivalent to the value of {{tt|v}}.
The value of {{tt|v}} is unchanged.
|}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_copy_assignable}}
{{dsc end}}

[[de:cpp/concept/CopyAssignable]]
[[es:cpp/concept/CopyAssignable]]
[[fr:cpp/concept/CopyAssignable]]
[[it:cpp/concept/CopyAssignable]]
[[ja:cpp/concept/CopyAssignable]]
[[pt:cpp/concept/CopyAssignable]]
[[ru:cpp/concept/CopyAssignable]]
[[zh:cpp/concept/CopyAssignable]]</text>
      <sha1>j6i0o0hv21dzoj2bcdp166o025cod7j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/CopyConstructible</title>
    <ns>0</ns>
    <id>5430</id>
    <revision>
      <id>66752</id>
      <parentid>66745</parentid>
      <timestamp>2013-12-28T20:48:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention lvalue in the intro sentence</comment>
      <text xml:space="preserve" bytes="1312">{{cpp/concept/title|CopyConstructible}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be copy-constructed from an [[cpp/language/value_category|lvalue expression]].

===Requirements===
The type {{tt|T}} satisfies {{tt|CopyConstructible}} if

* The type {{tt|T}} satisfies {{concept|MoveConstructible}}, and

Given
* {{tt|v}}, an [[cpp/language/value_category|lvalue]] expression of type {{tt|T}} or {{tt|const T}} or an [[cpp/language/value_category|rvalue]] expression of type {{tt|const T}}
* {{tt|u}}, an arbitrary identifier

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Post-conditions
|-
| {{c|1=T u = v;}}
| The value of {{tt|u}} is equivalent to the value of {{tt|v}}.
The value of {{tt|v}} is unchanged
|-
| {{c|T(v)}}
| The value of {{tt|T(v)}} is equivalent to the value of {{tt|v}}.
The value of {{tt|v}} is unchanged.
|}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc end}}

[[de:cpp/concept/CopyConstructible]]
[[es:cpp/concept/CopyConstructible]]
[[fr:cpp/concept/CopyConstructible]]
[[it:cpp/concept/CopyConstructible]]
[[ja:cpp/concept/CopyConstructible]]
[[pt:cpp/concept/CopyConstructible]]
[[ru:cpp/concept/CopyConstructible]]
[[zh:cpp/concept/CopyConstructible]]</text>
      <sha1>6j71gozlxiw8jpjvrh6v3gamzb46yh5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/CopyInsertable</title>
    <ns>0</ns>
    <id>5661</id>
    <revision>
      <id>68776</id>
      <parentid>64467</parentid>
      <timestamp>2014-03-21T02:23:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>clarify that this also requires MoveInsertable, as in LWG 2177</comment>
      <text xml:space="preserve" bytes="1304">{{cpp/concept/title|CopyInsertable}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be copy-constructed in-place, in uninitialized storage.

===Requirements===

The type {{tt|T}} is {{tt|CopyInsertable}} into the container {{tt|X}} if, given
{{dsc begin}}
{{dsc | {{tt|A}} | the allocator type defined as {{tt|X::allocator_type}} }}
{{dsc | {{tt|m}} | the lvalue of type {{tt|A}} obtained from {{tt|X::get_allocator()}} }}
{{dsc | {{tt|p}} | the pointer of type {{tt|T*}} prepared by the container }}
{{dsc | {{tt|v}} | expression of type {{tt|T}}, provided as the argument to push_back(), etc }}
{{dsc end}}

* The type {{tt|T}} satisfies {{concept|MoveInsertable}}, and the following expression is well-formed:

    {{c|
std::allocator_traits&lt;A&gt;::construct(m, p, v);
}}

And after evaluation, the value of {{c|*p}} is equivalent to the value of {{c|v}}. The value of {{c|v}} is unchanged.

===Notes===
If {{tt|A}} is {{c|std::allocator&lt;T&gt;}}, then this will call placement-new, as by {{c|::new((void*)p) T(v)}}

[[de:cpp/concept/CopyInsertable]]
[[es:cpp/concept/CopyInsertable]]
[[fr:cpp/concept/CopyInsertable]]
[[it:cpp/concept/CopyInsertable]]
[[ja:cpp/concept/CopyInsertable]]
[[pt:cpp/concept/CopyInsertable]]
[[ru:cpp/concept/CopyInsertable]]
[[zh:cpp/concept/CopyInsertable]]</text>
      <sha1>c478bcli48w40b4mplyrivm3jb4ebvi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/DefaultConstructible</title>
    <ns>0</ns>
    <id>5422</id>
    <revision>
      <id>70127</id>
      <parentid>70126</parentid>
      <timestamp>2014-05-10T16:28:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+non-objects and const</comment>
      <text xml:space="preserve" bytes="1865">{{cpp/concept/title|DefaultConstructible}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be default constructed.

===Requirements===

The type {{tt|T}} satisfies {{tt|DefaultConstructible}} if

Given
* {{tt|u}}, an arbitrary identifier

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Post-conditions
|-
| {{c|T u}}
| The object {{tt|u}} is [[cpp/language/default initialization|default-initialized]]
|-
| {{c|T u{} }}
| The object {{tt|u}} is [[cpp/language/value initialization|value-initialized]].
|-
| {{c|T()}}
{{c|T{} }}
| A temporary object of type {{tt|T}} is [[cpp/language/value initialization|value-initialized]].
|}

===Notes===
For objects of non-aggregate class type, a public [[cpp/language/default constructor|default constructor]] must be defined (either user-defined or implicitly defined) to satisfy {{tt|DefaultConstructible}}.

[[cpp/language/aggregate_initialization|Aggregates]] and non-const objects of [[cpp/language/type|non-class object type]] are always {{tt|DefaultConstructible}}.

Const non-class types are not {{tt|DefaultConstructible}}.

Const aggregate types are not {{tt|DefaultConstructible}} if any of their members is an object of non-class type.

Non-object types (function types, reference types, and the (possibly cv-qualified) type {{c|void}}) as well as the const non-object types are never {{tt|DefaultConstructible}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc end}}

[[de:cpp/concept/DefaultConstructible]]
[[es:cpp/concept/DefaultConstructible]]
[[fr:cpp/concept/DefaultConstructible]]
[[it:cpp/concept/DefaultConstructible]]
[[ja:cpp/concept/DefaultConstructible]]
[[pt:cpp/concept/DefaultConstructible]]
[[ru:cpp/concept/DefaultConstructible]]
[[zh:cpp/concept/DefaultConstructible]]</text>
      <sha1>q87qv0phyye40rr2mmukt4bmc3zlpas</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Destructible</title>
    <ns>0</ns>
    <id>5436</id>
    <revision>
      <id>66748</id>
      <parentid>57238</parentid>
      <timestamp>2013-12-28T20:10:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fmt to match the others</comment>
      <text xml:space="preserve" bytes="1086">{{cpp/concept/title|Destructible}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be destructed.

===Requirements===

The type {{tt|T}} satisfies {{tt|Destructible}} if

Given
* {{tt|u}}, a expression of type {{tt|T}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Post-conditions
|-
| {{c|u.~T()}}
| All resources owned by {{tt|u}} are reclaimed, no exceptions are thrown.
|}

===Notes===
Destructors are called implicitly at the end of [[cpp/language/lifetime|object lifetime]] such as when leaving [[cpp/language/scope|scope]] or by the [[cpp/language/delete|delete-expression]]. Explicit destructor call as shown in the type requirement table is rare.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_destructible}}
{{dsc end}}

[[de:cpp/concept/Destructible]]
[[es:cpp/concept/Destructible]]
[[fr:cpp/concept/Destructible]]
[[it:cpp/concept/Destructible]]
[[ja:cpp/concept/Destructible]]
[[pt:cpp/concept/Destructible]]
[[ru:cpp/concept/Destructible]]
[[zh:cpp/concept/Destructible]]</text>
      <sha1>fsqv0ehirstv18rla18hnzkrgxsckxs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/EmplaceConstructible</title>
    <ns>0</ns>
    <id>9645</id>
    <revision>
      <id>49407</id>
      <parentid>45380</parentid>
      <timestamp>2013-06-01T02:35:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="916">{{cpp/concept/title|EmplaceConstructible {{mark since c++11}} }}
{{cpp/concept/navbar}}

Specifies that an object of the type can be constructed in uninitialized storage.

===Requirements===

The type {{ttb|T}} is {{concept|EmplaceConstructible}} into the {{concept|Container}} {{ttb|X}} from the arguments {{ttb|args}} if, given
{{dsc begin}}
{{dsc | {{ttb|A}} | the allocator type defined as {{ttb|X::allocator_type}} }}
{{dsc | {{ttb|m}} | the lvalue of type {{ttb|A}} obtained from {{c|X::get_allocator()}} }}
{{dsc | {{ttb|p}} | the pointer of type {{ttb|T*}} prepared by the container }}
{{dsc | {{ttb|args}} | zero or more arguments passed to the constructor of {{ttb|T}} }}
{{dsc end}}

the following expression is well-formed:

{{source|
std::allocator_traits&lt;A&gt;::construct(m, p, args);
}}

===See Also===
{{dsc begin}}
{{dsc | {{concept|CopyInsertable}} }}
{{dsc | {{concept|MoveInsertable}} }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/EqualityComparable</title>
    <ns>0</ns>
    <id>5434</id>
    <revision>
      <id>66756</id>
      <parentid>66754</parentid>
      <timestamp>2013-12-28T21:06:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/values/expressions</comment>
      <text xml:space="preserve" bytes="1605">{{cpp/concept/title|EqualityComparable}}
{{cpp/concept/navbar}}

The type must work with == operator and the result should have standard semantics.

===Requirements===

The type {{tt|T}} satisfies {{tt|EqualityComparable}} if

Given
* {{tt|a}}, {{tt|b}}, and {{tt|c}}, expressions of type {{tt|T}} or {{tt|const T}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Requirements
|-
| {{ttb|a {{==}} b}}
| [[cpp/language/implicit_cast|implicitly convertible]] to {{c|bool}}
| Establishes equivalence relation with the following properties:
* For all values of {{tt|a}}, {{c|a {{==}} a}} yields {{c|true}}. 
* If {{c|a {{==}} b}}, then {{c|b {{==}} a}}
* If {{c|a {{==}} b}} and {{c|b {{==}} c}}, then {{c|a {{==}} c}}
|-
|}

===Notes===
To satisfy this requirement, types that do not have built-in [[cpp/language/operator_comparison|comparison operators]] have to provide a [[cpp/language/operators|user-defined operator==]]

For the types that are both {{tt|EqualityComparable}} and {{concept|LessThanComparable}}, the C++ standard library makes a distinction between ''equality'', which is the value of the expression {{c|a {{==}} b}} and ''equivalence'', which is the value of the expression {{c|!(a &lt; b) &amp;&amp; !(b &lt; a)}}.


[[de:cpp/concept/EqualityComparable]]
[[es:cpp/concept/EqualityComparable]]
[[fr:cpp/concept/EqualityComparable]]
[[it:cpp/concept/EqualityComparable]]
[[ja:cpp/concept/EqualityComparable]]
[[pt:cpp/concept/EqualityComparable]]
[[ru:cpp/concept/EqualityComparable]]
[[zh:cpp/concept/EqualityComparable]]</text>
      <sha1>9wimn5r1duyknfn9hlva35x3mt1oivt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/FormattedInputFunction</title>
    <ns>0</ns>
    <id>9560</id>
    <revision>
      <id>62006</id>
      <parentid>49408</parentid>
      <timestamp>2013-06-14T14:37:07Z</timestamp>
      <contributor>
        <username>Karzhenkov</username>
        <id>2075</id>
      </contributor>
      <minor/>
      <comment>sentry constructor: skip whitespace if ios_base::skipws</comment>
      <text xml:space="preserve" bytes="2898">{{cpp/concept/title|FormattedInputFunction}}
{{cpp/concept/navbar}}

===Requirements===

A {{tt|FormattedInputFunction}} is a stream input function that performs the following:

* Constructs an object of type {{l2tt|cpp/io/basic_istream/sentry}} with automatic storage duration and with the {{tt|noskipws}} argument set to {{c|false}}, which performs the following
:* if {{ltt|cpp/io/ios_base/iostate|eofbit}} or {{ltt|cpp/io/ios_base/iostate|badbit}} are set on the input stream, sets the {{tt|failbit}} as well, and if exceptions on failbit are enabled in this input stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* flushes the tie()'d output stream, if applicable
:* if {{tt|ios_base::skipws}} flag is set on this input stream, extracts and discards characters from the input stream until one of the following becomes true:
::* the next available character on the input stream is not a whitespace character, as tested by the {{lc|std::ctype}} facet of the locale currently imbued in this input stream. The non-whitespace character is not extracted.
::* the end of the stream is reached, in which case {{tt|failbit}} and {{tt|eofbit}} are set and if the stream is on for exceptions on one of these bits, {{l2tt|cpp/io/ios_base/failure}} is thrown.
* Checks the status of the sentry by calling {{tt|sentry::operator bool()}}, which is equivalent to {{l2tt|cpp/io/basic_ios/good}}.
* If the sentry returned {{c|false}} or sentry's constructor threw an exception, no input takes place
* If the sentry returned {{c|true}}, performs the input as if by calling {{c|rdbuf()-&gt;sbumpc()}} or {{c|rdbuf()-&gt;sgetc()}}.
:* if the end of the stream is reached (the call to {{c|rdbuf()-&gt;sbumpc()}} or {{c|rdbuf()-&gt;sgetc()}} returns {{c|Traits::eof()}}, sets {{tt|eofbit}}. If exceptions on eofbit are enabled in this stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* if an exception is thrown during input, sets {{tt|badbit}} in the input stream. If exceptions on badbit are enabled in this stream's exception mask, the exception is also rethrown.
:* If no exception was thrown, returns {{c|*this}}.
* In any event, whether terminating by exception or returning, the sentry's destructor is called before leaving this function.

===Standard library===

The following standard library functions are {{concept|FormattedInputFunction}}s.

* {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;{{dsc small|(int, long, double, void*, bool)}}}}
* {{ltt|cpp/io/basic_istream/operator_gtgt2|operator&gt;&gt;{{dsc small|(std::basic_istream, char&amp;)}}}}
* {{ltt|cpp/io/basic_istream/operator_gtgt2|operator&gt;&gt;{{dsc small|(std::basic_istream, char*)}}}}
* {{ltt|cpp/utility/bitset/operator_ltltgtgt2|operator&gt;&gt;{{dsc small|(std::basic_istream, std::bitset)}}}}
* {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&gt;&gt;{{dsc small|(std::basic_istream, std::string)}}}}
* {{lc|std::get_money}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/FormattedOutputFunction</title>
    <ns>0</ns>
    <id>9608</id>
    <revision>
      <id>49409</id>
      <parentid>44726</parentid>
      <timestamp>2013-06-01T02:35:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2400">{{cpp/concept/title|FormattedOutputFunction}}
{{cpp/concept/navbar}}

===Requirements===

A {{tt|FormattedOutputFunction}} is a stream output function that performs the following:

* Constructs an object of type {{l2tt|cpp/io/basic_ostream/sentry}} with automatic storage duration, which performs the following
:* if {{ltt|cpp/io/ios_base/iostate|eofbit}} or {{ltt|cpp/io/ios_base/iostate|badbit}} are set on the output stream, sets the {{tt|failbit}} as well, and if exceptions on failbit are enabled in this output stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* flushes the tie()'d output stream, if applicable.
* Checks the status of the sentry by calling {{tt|sentry::operator bool()}}, which is equivalent to {{l2tt|cpp/io/basic_ios/good}}.
* If the sentry returned {{c|false}} or sentry's constructor threw an exception, no output takes place
* If the sentry returned {{c|true}}, attempts to perform the desired output by inserting the characters into the output stream as if by calling {{c|rdbuf()-&gt;sputc()}} or {{c|rdbuf()-&gt;xsputn()}}. Additionally, {{c|rdbuf()-&gt;overflow()}} and {{c|rdbuf()-&gt;sync()}} may be called, but no other virtual member function of {{lc|std::basic_streambuf}}.
:* If the output could not be generated, sets {{tt|failbit}}, If exceptions on failbit are enabled in this stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* if an exception is thrown during output, sets {{tt|badbit}} in the output stream. If exceptions on badbit are enabled in this stream's exception mask, the exception is also rethrown.
:* If no exception was thrown, returns {{c|*this}}.
* In any event, whether terminating by exception or returning, the sentry's destructor is called before leaving this function.

===Standard library===

The following standard library functions are {{concept|FormattedOutputFunction}}s.

* {{l2tt|cpp/io/basic_ostream/operator_ltlt|operator&lt;&lt;{{dsc small|(int, long, double, void*, bool)}}}}
* {{ltt|cpp/io/basic_ostream/operator_ltlt2|operator&lt;&lt;{{dsc small|(std::basic_ostream, char)}}}}
* {{ltt|cpp/io/basic_ostream/operator_ltlt2|operator&lt;&lt;{{dsc small|(std::basic_ostream, char*)}}}}
* {{ltt|cpp/utility/bitset/operator_ltltgtgt2|operator&lt;&lt;{{dsc small|(std::basic_ostream, std::bitset)}}}}
* {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&lt;&lt;{{dsc small|(std::basic_ostream, std::string)}}}}
* {{lc|std::put_money}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/ForwardIterator</title>
    <ns>0</ns>
    <id>5441</id>
    <revision>
      <id>65318</id>
      <parentid>65317</parentid>
      <timestamp>2013-09-08T12:25:37Z</timestamp>
      <contributor>
        <ip>81.202.204.199</ip>
      </contributor>
      <text xml:space="preserve" bytes="1651">{{cpp/concept/title|ForwardIterator}}
{{cpp/concept/navbar}}

A {{tt|ForwardIterator}} is an {{concept|Iterator}} that can read data from the pointed-to element.

Unlike an {{concept|InputIterator}}, it guarantees validity when used in multipass algorithms.

===Requirements===

* {{concept|InputIterator}}
* {{concept|DefaultConstructible}}
* {{ttb|a {{==}} b}} implies {{ttb|++a {{==}} ++b}} 

In addition to the above requirements, for a type {{tt|It}} to be an {{tt|ForwardIterator}}, an instance {{tt|i}} of {{tt|It}} must:

{|table class=&quot;wikitable&quot;
|-
!Expression||Return||Equivalent expression||Notes
|-
|{{c|++i}}|| {{c|iterator}} || {{c|i{{=}}std::next(i); return i;}} ||After this, copies of {{ttb|i}} are still valid
|-
|{{c|i++}}|| {{c|iterator}} || {{c| iterator ip{{=}}i; i{{=}}std::next(i); return ip;}} ||
|-
|{{c|*i++}}|| {{c|reference}} ||{{c| value_type&amp; temp{{=}}*i; ++i; return temp;}}|| 
|-
|}

A {{tt|mutable ForwardIterator}} is a {{tt|ForwardIterator}} that additionally satisfies the {{concept|OutputIterator}} requirements.

{{rev inl|since=c++14|A [[cpp/language/value_initialization|value-initialized]] {{tt|ForwardIterator}} behaves like the past-the-end iterator of some unspecified empty container: it compares equal to all value-initialized {{tt|ForwardIterator}}s of the same type.}}

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/ForwardIterator]]
[[es:cpp/concept/ForwardIterator]]
[[fr:cpp/concept/ForwardIterator]]
[[it:cpp/concept/ForwardIterator]]
[[ja:cpp/concept/ForwardIterator]]
[[pt:cpp/concept/ForwardIterator]]
[[ru:cpp/concept/ForwardIterator]]
[[zh:cpp/concept/ForwardIterator]]</text>
      <sha1>4zsy9hpbo94ayq93dxbb1e4jrz32ibf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/FunctionObject</title>
    <ns>0</ns>
    <id>13170</id>
    <revision>
      <id>72140</id>
      <parentid>67886</parentid>
      <timestamp>2014-07-18T13:07:41Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>typo fixed</comment>
      <text xml:space="preserve" bytes="1159">{{cpp/concept/title|FunctionObject}}
{{cpp/concept/navbar}}

A {{concept|FunctionObject}} type is the type of an object that can be used on the left of the function call operator.

===Requirements===

The type {{tt|T}} satisfies {{tt|FunctionObject}} if

* The type {{tt|T}} satisfies {{lc|std::is_object}}, and

Given
* {{tt|f}}, a value of type {{tt|T}} or {{tt|const T}}
* {{tt|args}}, suitable argument list, which may be empty

The following expressions must be valid:

{|table class=wikitable
|-
!Expression||Requirements
|-
| {{c|1=f(args)}}
| performs a function call
|}

===Notes===
Functions and references to functions are not function object types, but can be used where function object types are expected due to function-to-pointer [[cpp/language/implicit_cast|implicit conversion]].

===Standard library===
* All [[cpp/language/pointer#Pointers_to_functions|pointers to functions]] satisfy this requirement. 

In addition, the following standard library facilities require a {{concept|FunctionObject}} which isn't {{concept|Callable}}, {{concept|Hash}}, or {{concept|Predicate}} type.

{{dsc begin}}
{{dsc | {{lc|std::unique_ptr}} }}
{{dsc end}}</text>
      <sha1>nockcuf26rtgg5967wnkz0o84f65src</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Hash</title>
    <ns>0</ns>
    <id>9618</id>
    <revision>
      <id>67869</id>
      <parentid>67868</parentid>
      <timestamp>2014-03-04T03:45:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1390">{{cpp/concept/title|Hash}}
{{cpp/concept/navbar}}

A {{concept|Hash}} is a function object for which the output depends only on the input and has a very low probability of yielding the same output given different input values.

===Requirements===

The type {{tt|T}} satisfies {{tt|Hash}} if

* The type {{tt|T}} satisfies {{concept|FunctionObject}}, {{concept|CopyConstructible}}, {{concept|Destructible}}, and

Given
* {{tt|h}}, a value of type {{tt|T}} or {{tt|const T}}, whose argument type is {{tt|Key}}
* {{tt|k}}, a value of type convertible to {{tt|Key}} or {{tt|const Key}}
* {{tt|u}}, an [[cpp/language/value_category|lvalue]] expression of type {{tt|Key}}

The following expressions must be valid and have their specified effects


{|table class=wikitable
|-
!Expression||Return type||Requirements
|-
| {{c|1=h(k)}}
| {{tt|std::size_t}}
| the returned value depends only on the value of {{tt|k}} {{rev inl|since=c++14|for the duration of the program}}
All evaluations of {{c|h(k)}} {{rev inl|since=c++14|executed within a given execution of a program}} yield the same result for the same value of {{tt|k}}.

The probability of {{c|h(a){{==}}h(b)}} for {{c|a!{{=}}b}} should approach {{c|1.0/std::numeric_limits&lt;std::size_t&gt;::max()}}.
|-
| {{c|1=h(u)}}
| {{tt|std::size_t}}
| {{tt|u}} is not modified
|}

===Standard library===
{{dsc begin}}
{{dsc | {{lc|std::hash}} }}
{{dsc end}}</text>
      <sha1>b1p9k7w0y9uae1ypoymmpjmbxcjqpv4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/InputIterator</title>
    <ns>0</ns>
    <id>5439</id>
    <revision>
      <id>63708</id>
      <parentid>63704</parentid>
      <timestamp>2013-07-21T14:08:55Z</timestamp>
      <contributor>
        <username>FZ</username>
        <id>2216</id>
      </contributor>
      <minor/>
      <comment>Renamed a -&gt; i for consistency; added some additional description</comment>
      <text xml:space="preserve" bytes="1913">{{cpp/concept/title|InputIterator}}
{{cpp/concept/navbar}}

An {{tt|InputIterator}} is an {{concept|Iterator}} that can read from the pointed-to element.  {{tt|InputIterator}}s only guarantee validity for single pass algorithms: once an {{tt|InputIterator}} {{c|i}} has been incremented, all copies of its previous value may be invalidated.

===Requirements===

* {{concept|Iterator}}
* {{concept|EqualityComparable}}

In addition to the above requirements, for a type {{c|It}} to be an {{tt|InputIterator}}, instances {{c|i}} and {{c|j}} of {{c|It}} must:

{|table class=&quot;wikitable&quot;
|-
!Expression||Return||Equivalent expression||Notes
|-
|{{c|i !{{=}} j}}||contextually convertible to {{c|bool}}||{{c|!(i {{==}} j)}}||'''Precondition''': {{c|(i, j)}} is in the domain of {{c|{{==}}}}.
|-
|{{c|*i}}||convertible to {{c|value_type}}||If {{c|i {{==}} j}} and {{c|(i, j)}} is in the domain of {{c|{{==}}}} then this is equivalent to {{c|*j}}.||

'''Precondition''': {{c|i}} is dereferenceable.

The expression {{c|(void)*i, *i}} is equivalent to {{c|*i}}.

|-
|{{c|i-&gt;m}}|| ||{{c|(*i).m}}||'''Precondition''': {{c|i}} is dereferenceable.
|-
|{{c|++i}}||{{c|It&amp;}}|| ||

'''Precondition''': {{c|i}} is dereferenceable.

'''Postcondition''': {{c|i}} is dereferenceable or {{c|i}} is past-the-end.

'''Postcondition''': Any copies of the previous value of {{c|i}} are no longer required to be either dereferenceable or to be in the domain of {{c|{{==}}}}.

|-
|{{c|(void)i++}}|| ||{{c|(void)++i}}||
|-
|{{c|*i++}}||convertible to {{c|value_type}}
|{{c|
value_type x {{=}} *i;
++i;
return x;
}} ||
|-
|}

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/InputIterator]]
[[es:cpp/concept/InputIterator]]
[[fr:cpp/concept/InputIterator]]
[[it:cpp/concept/InputIterator]]
[[ja:cpp/concept/InputIterator]]
[[pt:cpp/concept/InputIterator]]
[[ru:cpp/concept/InputIterator]]
[[zh:cpp/concept/InputIterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Iterator</title>
    <ns>0</ns>
    <id>5438</id>
    <revision>
      <id>72456</id>
      <parentid>70118</parentid>
      <timestamp>2014-08-22T15:11:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>apply lwg #2035 and fix up value category for r</comment>
      <text xml:space="preserve" bytes="2421">{{cpp/concept/title|Iterator}}
{{cpp/concept/navbar}}

The {{tt|Iterator}} concept describes types that can be used to identify and traverse the elements of a container.

{{tt|Iterator}} is the base concept used by other iterator types: {{concept|InputIterator}}, {{concept|OutputIterator}}, {{concept|ForwardIterator}}, {{concept|BidirectionalIterator}}, and {{concept|RandomAccessIterator}}. Iterators can be thought of as an abstraction of pointers.

===Requirements===
The type {{tt|It}} satisfies {{tt|Iterator}} if
* The type {{tt|It}} satisfies {{concept|CopyConstructible}}, and
* The type {{tt|It}} satisfies {{concept|CopyAssignable}}, and
* The type {{tt|It}} satisfies {{concept|Destructible}}, and
* [[cpp/language/value_category|lvalues]] of type {{tt|It}} satisfy {{concept|Swappable}}, and

Given
* {{tt|r}}, an lvalue of type {{tt|It}},
* {{tt|reference}}, the type denoted by {{c|std::iterator_traits&lt;It&gt;::reference}}

The following expressions must be valid and have their specified effects:

{|table class=wikitable
|-
!Expression||Return Type||Precondition
|-
|{{c|*r}}
|{{c|reference}}
|{{ttb|r}} is dereferenceable (see below)
|-
|{{c|++r}}
|{{c|It&amp;}}
|{{ttb|r}} is incrementable (see below)
|}

===Dereferenceable iterators===

Iterators for which the behavior of the expression {{c|*i}} is defined are called ''dereferenceable''.

{{tt|Iterator}}s are not dereferenceable if
* they are [[cpp/container/vector/end|past-the-end iterators]] (including pointers past the end of an array) or [[cpp/container/forward_list/before_begin|before-begin iterators]]. Such iterators may be dereferenceable in a particular implementation, but the library never assumes that they are.
* they are ''singular'' iterators, that is, iterators that are not associated with any sequence. A null pointer, as well as a default-constructed pointer (holding an indeterminate value) is singular
* they were [[cpp/container#Iterator_invalidation|invalidated]] by one of the iterator-invalidating operations on the sequence to which they refer.

Iterators for which the behavior of the expression {{c|++i}} is defined are called ''incrementable''.

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/Iterator]]
[[es:cpp/concept/Iterator]]
[[fr:cpp/concept/Iterator]]
[[it:cpp/concept/Iterator]]
[[ja:cpp/concept/Iterator]]
[[pt:cpp/concept/Iterator]]
[[ru:cpp/concept/Iterator]]
[[zh:cpp/concept/Iterator]]</text>
      <sha1>5uqljpc9e3ki9zqmhia1whdo87iwwwi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/LessThanComparable</title>
    <ns>0</ns>
    <id>5435</id>
    <revision>
      <id>66755</id>
      <parentid>65671</parentid>
      <timestamp>2013-12-28T21:05:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>notes and match fmt with equalitycomparable</comment>
      <text xml:space="preserve" bytes="1575">{{cpp/concept/title|LessThanComparable}}
{{cpp/concept/navbar}}
The type must work with &lt; operator and the result should have standard semantics.

===Requirements===

The type {{tt|T}} satisfies {{tt|LessThanComparable}} if

Given
* {{tt|a}}, {{tt|b}}, and {{tt|c}}, expressions of type {{tt|T}} or {{tt|const T}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Requirements
|-
| {{c|a &lt; b}}
| [[cpp/language/implicit_cast|implicitly convertible]] to {{c|bool}}
| Establishes [[enwiki:Strict_weak_ordering|strict weak ordering]] relation with the following properties
* For all {{tt|a}}, {{c|!(a &lt; a)}}
* If {{c|a &lt; b}} then {{c|!(b &lt; a)}}
* if {{c|a &lt; b}} and {{c|b &lt; c}} then {{c|a &lt; c}}
|}

===Notes===
To satisfy this requirement, types that do not have built-in [[cpp/language/operator_comparison|comparison operators]] have to provide a [[cpp/language/operators|user-defined operator&lt;]]

For the types that are both {{concept|EqualityComparable}} and {{tt|LessThanComparable}}, the C++ standard library makes a distinction between ''equality'', which is the value of the expression {{c|a {{==}} b}} and ''equivalence'', which is the value of the expression {{c|!(a &lt; b) &amp;&amp; !(b &lt; a)}}.

[[de:cpp/concept/LessThanComparable]]
[[es:cpp/concept/LessThanComparable]]
[[fr:cpp/concept/LessThanComparable]]
[[it:cpp/concept/LessThanComparable]]
[[ja:cpp/concept/LessThanComparable]]
[[pt:cpp/concept/LessThanComparable]]
[[ru:cpp/concept/LessThanComparable]]
[[zh:cpp/concept/LessThanComparable]]</text>
      <sha1>n774u0pp80iigfcg78j5u0ytv4t06vk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/LiteralType</title>
    <ns>0</ns>
    <id>12979</id>
    <revision>
      <id>71815</id>
      <parentid>66589</parentid>
      <timestamp>2014-06-25T08:35:01Z</timestamp>
      <contributor>
        <ip>89.14.67.249</ip>
      </contributor>
      <comment>Remove out2 since it is slightly confusing as it serves no purpose</comment>
      <text xml:space="preserve" bytes="2138">{{cpp/concept/title|LiteralType}}
{{cpp/concept/navbar}}

Specifies that a type is a literal type. Literal types can be constructed, manipulated, and returned from [[cpp/language/constexpr|constexpr functions]].

{{cpp/concept/concept note}}

===Requirements===
A literal type is any of the following
* {{c|void}}{{mark|since c++14}}
* scalar type
* reference type
* an array of literal type
* class type that has all of the following properties:
:* has a trivial destructor,
:* is either 
::* an aggregate type
::* a type with at least one constexpr (possibly template) constructor that is not a copy or move constructor
:* all non-static data members and base classes are of non-volatile literal types.

===Example===
{{example |
literal type that extends string literals:
 | code=
#include &lt;iostream&gt;
#include &lt;stdexcept&gt;

class conststr {
    const char * p;
    std::size_t sz;
 public:
    template&lt;std::size_t N&gt;
    constexpr conststr(const char(&amp;a)[N]) : p(a), sz(N-1) {}

    constexpr char operator[](std::size_t n) const {
        return n &lt; sz ? p[n] : throw std::out_of_range(&quot;&quot;);
    }
    constexpr std::size_t size() const { return sz; }
};

constexpr std::size_t countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0) {
    return n == s.size() ? c :
           s[n] &gt;= 'a' &amp;&amp; s[n] &lt;= 'z' ? countlower(s, n+1, c+1) :
           countlower(s, n+1, c);
}

// output function that requires a compile-time constant, for testing
template&lt;int n&gt; struct constN {
    constN() { std::cout &lt;&lt; n &lt;&lt; '\n'; }
};

int main()
{
    std::cout &lt;&lt; &quot;Number of lowercase letters in \&quot;Hello, world!\&quot; is &quot;;
    constN&lt;countlower(&quot;Hello, world!&quot;)&gt;(); // implicitly converted to conststr
}
 | output=
Number of lowercase letters in &quot;Hello, world!&quot; is 9
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_literal_type}}
{{dsc end}}

[[de:cpp/concept/LiteralType]]
[[es:cpp/concept/LiteralType]]
[[fr:cpp/concept/LiteralType]]
[[it:cpp/concept/LiteralType]]
[[ja:cpp/concept/LiteralType]]
[[pt:cpp/concept/LiteralType]]
[[ru:cpp/concept/LiteralType]]
[[zh:cpp/concept/LiteralType]]</text>
      <sha1>8ji6z4146rntd84nsjve47yrhzmvmr5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Lockable</title>
    <ns>0</ns>
    <id>8927</id>
    <revision>
      <id>65579</id>
      <parentid>42105</parentid>
      <timestamp>2013-09-21T01:11:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso mutex</comment>
      <text xml:space="preserve" bytes="942">{{cpp/concept/title|Lockable}}
{{cpp/concept/navbar}}

The {{tt|Lockable}} concept extends the {{concept|BasicLockable}} concept to include attempted locking.

===Requirements===

* {{concept|BasicLockable}}
For type {{ttb|L}} to be {{tt|Lockable}}, it must meet the above condition as well as the following:
{|table class=wikitable
|-
!Expression||Effects||Return value
|-
|{{c|m.try_lock()}}
|Attempts to acquire the lock for the current execution agent without blocking.  If an exception is thrown, no lock is obtained.
|{{c|true}} if the lock was acquired, {{c|false}} otherwise
|}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|Mutex}}
* {{concept|BasicLockable}}
* {{concept|TimedLockable}}

[[de:cpp/concept/Lockable]]
[[es:cpp/concept/Lockable]]
[[fr:cpp/concept/Lockable]]
[[it:cpp/concept/Lockable]]
[[ja:cpp/concept/Lockable]]
[[pt:cpp/concept/Lockable]]
[[ru:cpp/concept/Lockable]]
[[zh:cpp/concept/Lockable]]</text>
      <sha1>3p1ea5lz8i6dlhrv3kh8s2292rjvs3e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/MoveAssignable</title>
    <ns>0</ns>
    <id>5428</id>
    <revision>
      <id>66911</id>
      <parentid>66750</parentid>
      <timestamp>2014-01-07T21:53:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1655">{{cpp/concept/title|MoveAssignable {{mark since c++11}}}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be assigned from an [[cpp/language/value_category|rvalue]] argument. 

===Requirements===
The type {{tt|T}} satisfies {{tt|MoveAssignable}} if

Given
* {{tt|t}}, a modifiable [[cpp/language/value_category|lvalue expression]] of type {{tt|T}}
* {{tt|rv}}, an [[cpp/language/value_category|rvalue]] expression of type {{tt|T}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Return value||Post-conditions
|-
| {{c|1=t = rv}}
| {{tt|T&amp;}}
| {{tt|t}}
| The value of {{tt|t}} is equivalent to the value of {{tt|rv}} before the assignment.
The new value of {{tt|rv}} is unspecified
|}

===Notes===
The type does not have to implement [[cpp/language/move_operator|move assignment operator]] in order to satisfy this type requirement: a [[cpp/language/as_operator|copy assignment operator]] that takes its parameter by value or as a {{tt|const Type&amp;}}, will bind to rvalue argument.

If a MoveAssignable class implements a move assignment operator, it may also implement [[cpp/utility/move|move semantics]] to take advantage of the fact that the value of {{tt|rv}} after assignment is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_move_assignable}}
{{dsc end}}

[[de:cpp/concept/MoveAssignable]]
[[es:cpp/concept/MoveAssignable]]
[[fr:cpp/concept/MoveAssignable]]
[[it:cpp/concept/MoveAssignable]]
[[ja:cpp/concept/MoveAssignable]]
[[pt:cpp/concept/MoveAssignable]]
[[ru:cpp/concept/MoveAssignable]]
[[zh:cpp/concept/MoveAssignable]]</text>
      <sha1>ny3w9bh3gv0rtrphy5enke5zqs4e2o6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/MoveConstructible</title>
    <ns>0</ns>
    <id>5427</id>
    <revision>
      <id>70283</id>
      <parentid>66749</parentid>
      <timestamp>2014-05-16T09:09:37Z</timestamp>
      <contributor>
        <ip>115.249.242.50</ip>
      </contributor>
      <comment>Type is T</comment>
      <text xml:space="preserve" bytes="1703">{{cpp/concept/title|MoveConstructible {{mark since c++11}}}}
{{cpp/concept/navbar}}

Specifies that an instance of the type can be constructed from an [[cpp/language/value_category|rvalue]] argument.

===Requirements===

The type {{tt|T}} satisfies {{tt|MoveConstructible}} if

Given
* {{tt|rv}}, an [[cpp/language/value_category|rvalue]] expression of type {{tt|T}}
* {{tt|u}}, an arbitrary identifier

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Post-conditions
|-
| {{c|1=T u = rv;}}
| The value of {{tt|u}} is equivalent to the value of {{tt|rv}} before the initialization.
The new value of {{tt|rv}} is unspecified
|-
| {{c|T(rv)}}
| The value of {{tt|T(rv)}} is equivalent to the value of {{tt|rv}} before the initialization.
The new value of {{tt|rv}} is unspecified.
|}

===Notes===
A class does not have to implement a [[cpp/language/move constructor|move constructor]] to satisfy this type requirement: a [[cpp/language/copy constructor|copy constructor]] that takes a {{tt|const T&amp;}} argument can bind rvalue expressions.

If a MoveConstructible class implements a move constructor, it may also implement [[cpp/utility/move|move semantics]] to take advantage of the fact that the value of {{tt|rv}} after construction is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc end}}

[[de:cpp/concept/MoveConstructible]]
[[es:cpp/concept/MoveConstructible]]
[[fr:cpp/concept/MoveConstructible]]
[[it:cpp/concept/MoveConstructible]]
[[ja:cpp/concept/MoveConstructible]]
[[pt:cpp/concept/MoveConstructible]]
[[ru:cpp/concept/MoveConstructible]]
[[zh:cpp/concept/MoveConstructible]]</text>
      <sha1>srwz4uwikyemqhxarhsci4fb2qeqpy6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/MoveInsertable</title>
    <ns>0</ns>
    <id>9644</id>
    <revision>
      <id>68775</id>
      <parentid>64466</parentid>
      <timestamp>2014-03-21T02:20:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>clarify</comment>
      <text xml:space="preserve" bytes="1620">{{cpp/concept/title|MoveInsertable {{mark since c++11}} }}
{{cpp/concept/navbar}}

Specifies that a rvalue of the type can be copied in uninitialized storage.

===Requirements===

The type {{ttb|T}} is {{concept|MoveInsertable}} into the {{concept|Container}} {{ttb|X}} if, given
{{dsc begin}}
{{dsc | {{ttb|A}} | the allocator type defined as {{ttb|X::allocator_type}} }}
{{dsc | {{ttb|m}} | the lvalue of type {{ttb|A}} obtained from {{c|X::get_allocator()}} }}
{{dsc | {{ttb|p}} | the pointer of type {{ttb|T*}} prepared by the container }}
{{dsc | {{ttb|rv}} | rvalue expression of type {{ttb|T}}, provided as the argument to push_back(), etc }}
{{dsc end}}

the following expression is well-formed:

{{source|
std::allocator_traits&lt;A&gt;::construct(m, p, rv);
}}

And after evaluation, the value of {{tt|*p}} is equivalent to the value formerly held by {{tt|rv}} ({{tt|rv}} remains valid, but unspecified)

===Notes===
If {{tt|A}} is {{c|std::allocator&lt;T&gt;}}, then this will call placement-new, as by {{c|::new((void*)p) T(rv)}}.

If {{c|std::allocator&lt;T&gt;}} or a similar allocator is used, a class does not have to implement a [[cpp/language/move constructor|move constructor]] to satisfy this type requirement: a [[cpp/language/copy constructor|copy constructor]] that takes a {{tt|const T&amp;}} argument can bind rvalue expressions. If a MoveInsertable class implements a move constructor, it may also implement [[cpp/utility/move|move semantics]] to take advantage of the fact that the value of {{tt|rv}} after construction is unspecified.

===See Also===
{{dsc begin}}
{{dsc | {{concept|CopyInsertable}} }}
{{dsc end}}</text>
      <sha1>q55qlk5gz6udtgsxs8oi9jfllxn93se</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Mutex</title>
    <ns>0</ns>
    <id>12992</id>
    <revision>
      <id>66485</id>
      <parentid>65576</parentid>
      <timestamp>2013-11-25T14:14:10Z</timestamp>
      <contributor>
        <ip>87.54.11.90</ip>
      </contributor>
      <comment>Fix typo</comment>
      <text xml:space="preserve" bytes="2770">{{cpp/concept/title|Mutex}}
{{cpp/concept/navbar}}

The {{tt|Mutex}} concept extends the {{concept|Lockable}} concept to include inter-thread synchronization.

===Requirements===

* {{concept|Lockable}}
* {{concept|DefaultConstructible}}
* {{concept|Destructible}}
* not copyable
* not movable

For object {{ttb|m}} of {{tt|Mutex}} type.
* The expression {{c|m.lock()}} has the following properties
:* Behaves as an atomic operation.
:* Blocks the calling thread until exclusive ownership of the mutex can be obtained.
:* Prior {{c|m.unlock()}} operations on the same mutex ''synchronize-with'' this lock operation (equivalent to release-acquire {{lc|std::memory_order}})
:* The behavior is undefined if the calling thread already owns the mutex (except if m is {{lc|std::recursive_mutex}} or {{lc|std::recursive_timed_mutex}})
:* Exception of type {{lc|std::system_error}} may be thrown on errors, with the following error codes:
::* {{lc|std::errc::operation_not_permitted}} if the calling thread does not have required privileges
::* {{lc|std::errc::resource_deadlock_would_occur}} if the implementation detects that this operation would lead to deadlock
::* {{lc|std::errc::device_or_resource_busy}} if the mutex is already locked
* The expression {{c|m.try_lock()}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain exclusive ownership of the mutex for the calling thread without blocking. If ownership is not obtained, returns immediately. The function is allowed to spuriously fail and return even if the mutex is not currently owned by another thread.
:* If {{tt|try_lock()}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}). {{tt|lock()}} does not synchronize with a failed {{tt|try_lock()}}
* The expression {{c|m.unlock()}} has the following properties
:* Behaves as an atomic operation.
:* Releases the calling thread's ownership of the mutex and ''synchronizes-with'' the subsequent successful lock operations on the same object.
:* The behavior is undefined if the calling thread does not own the mutex.
* All lock and unlock operations on a single mutex occur in a single total order


===Library types===
The following standard library types satisfy {{concept|Mutex}}:
* {{lc|std::mutex}}
* {{lc|std::recursive_mutex}}
* {{lc|std::timed_mutex}}
* {{lc|std::recursive_timed_mutex}}
* {{lc|std::shared_mutex}}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|Lockable}}
* {{concept|TimedMutex}}

[[de:cpp/concept/Mutex]]
[[es:cpp/concept/Mutex]]
[[fr:cpp/concept/Mutex]]
[[it:cpp/concept/Mutex]]
[[ja:cpp/concept/Mutex]]
[[pt:cpp/concept/Mutex]]
[[ru:cpp/concept/Mutex]]
[[zh:cpp/concept/Mutex]]</text>
      <sha1>my8k4c7xo4astkap2gzxav81h6kyx87</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/NullablePointer</title>
    <ns>0</ns>
    <id>9850</id>
    <revision>
      <id>49414</id>
      <parentid>46143</parentid>
      <timestamp>2013-06-01T02:38:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1913">{{cpp/concept/title|NullablePointer {{mark since c++11}}}}
{{cpp/concept/navbar}}

Specifies that the type is an pointer-like object which can be compared to {{lc|std::nullptr_t}} objects.

===Requirements===

The type must meet all of the following concept requirements:

* {{concept|EqualityComparable}}
* {{concept|DefaultConstructible}}
* {{concept|CopyConstructible}}
* {{concept|CopyAssignable}}
* {{concept|Destructible}}

In addition, a value-initialized object of the type must produce a null value of that type. This null value shall only be equivalent to itself. Default initialization of the type may have an indeterminate value.

An object of the type must be contextually convertible to bool. The effect of this conversion returns false if the value is equivalent to its null value and true otherwise.

None of the operations that this type performs may throw exceptions.

The type must satisfy the following additional expressions, given two values {{tt|p}} and {{tt|q}} that are of the type, and that {{tt|np}} is a value of {{lc|std::nullptr_t}} type (possibly {{c|const}} qualified):

{{dsc begin}}
{{dsc hitem | Expression | Effects}}
{{dsc | {{c|Type p(np);}}
{{c|Type p {{=}} np;}} | Afterwards, {{tt|p}} is equivalent to {{c|nullptr}} }}
{{dsc | {{c|Type(np)}} |  a temporary object that is equivalent to {{c|nullptr}} }}
{{dsc | {{c|p {{=}} np }} |  Must return a {{tt|Type&amp;}}, and afterwards, {{tt|p}} is equivalent to {{c|nullptr}} }}
{{dsc | {{c|p !{{=}} q}} | Must return a value that is contextually convertible to bool.
The effect is {{tt|!(p {{=}}{{=}} q)}} }}
{{dsc | {{c|p {{=}}{{=}} np}}
{{c|np {{=}}{{=}} p}}| Must return a value that is contextually convertible to bool.
The effect is {{tt|(p {{=}}{{=}} Type())}} }}
{{dsc | {{c|p !{{=}} np}}
{{c|np !{{=}} p}}| Must return a value that is contextually convertible to bool.
The effect is {{tt|!(p {{=}}{{=}} np)}} }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/NumericType</title>
    <ns>0</ns>
    <id>13726</id>
    <revision>
      <id>72364</id>
      <parentid>72314</parentid>
      <timestamp>2014-08-14T23:12:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>-complex</comment>
      <text xml:space="preserve" bytes="967">{{cpp/concept/title|NumericType}}
{{cpp/concept/navbar}}
Specifies that the type can be used as the template argument of {{lc|std::valarray}}

=== Requirements ===
for a type {{ttb|T}} to be an {{tt|NumericType}}:
* {{tt|T}} cannot be a reference
* {{tt|T}} cannot be cv-qualified
* If {{tt|T}} is a class, it
:* does not overload {{c|operator&amp;}}
:* has no pure virtual member functions (is not [[cpp/language/abstract class|abstract]])
:* has a public [[cpp/language/default_constructor|default constructor]]
:* has a public [[cpp/language/copy_constructor|copy constructor]] {{c|T::T(const T&amp;)}}
:* has a public [[cpp/language/destructor|destructor]]
:* has a public assignment operator {{c|T&amp; T::operator{{=}}(const T&amp;)}} or {{c|T&amp; T::operator{{=}}(T)}}
:* default constructor followed by assignment has the same effect as copy constructor
:* destructor followed by copy constructor has the same effect as assignment
* No operation on {{tt|T}} may throw exceptions</text>
      <sha1>7ykbk4posa213r0wvesbtcsr5k245h4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/OutputIterator</title>
    <ns>0</ns>
    <id>5440</id>
    <revision>
      <id>72457</id>
      <parentid>72452</parentid>
      <timestamp>2014-08-22T16:00:45Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3331">{{cpp/concept/title|OutputIterator}}
{{cpp/concept/navbar}}

An {{tt|OutputIterator}} is an {{concept|Iterator}} that can write to the pointed-to element. 

An example of a type that implements {{tt|OutputIterator}} is [[cpp/iterator/ostream_iterator|std::ostream_iterator]].

When {{concept|ForwardIterator}}, {{concept|BidirectionalIterator}}, or {{concept|RandomAccessIterator}} satisfies the {{concept|OutputIterator}} requirements in addition to its own requirements, it is described as '''mutable'''.

===Requirements===

The type {{tt|X}} satisfies {{tt|OutputIterator}} if

* The type {{tt|X}} satisfies {{concept|Iterator}}
* {{tt|X}} is a class type or a pointer type

And, given
* {{tt|o}}, a value of some type that is writable to the output iterator (there may be multiple types that are writable, e.g. if {{tt|operator{{=}}}} may be a template. There is no notion of {{tt|value_type}} as for the input iterators)
* {{tt|r}}, an lvalue of type {{tt|X}},

The following expressions must be valid and have their specified effects
{|table class=&quot;wikitable&quot;
|-
!Expression||Return||Equivalent expression||Pre-condition||Post-conditions||Notes
|-
|{{c|*r {{=}} o}}
|(not used)
|
|{{tt|r}} is dereferencable
|{{tt|r}} is incrementable
|After this operation {{tt|r}} is not required to be dereferenceable and any copies of the previous value of {{tt|r}} are no longer required to be dereferenceable or incrementable.
|-
|{{c|++r}}
|{{c|X&amp;}}
|
|{{tt|r}} is incrementable
|{{c|&amp;r {{==}} &amp;++r}}, {{tt|r}} is dereferencable or past-the-end
|After this operation {{tt|r}} is not required to be incrementable and any copies of the previous value of {{tt|r}} are no longer required to be dereferenceable or incrementable.
|-
|{{c|r++}}
|convertible to {{c|const X&amp;}}
|{{c|
X temp {{=}} r;
++r;
return temp;
}}
|
|
|
|-
|{{c|*r++ {{=}} o}}
|(not used)
|{{c|*r {{=}} o;
++r;}} 
|
|
|
|}

===Notes===
The only valid use of {{tt|operator*}} with an output iterator is on the left of an assignment: {{tt|operator*}} may return a proxy object, which defines a member {{tt|operator{{=}}}} (which may be a template)

Equality and inequality may not be defined for output iterators. Even if an {{tt|operator{{==}}}} is defined, {{tt|x {{==}} y}} need not imply {{tt|++x {{==}} ++y}}.

Assignment through the same value of an output iterator happens only once: algorithms on output iterators must be single-pass algorithms.

Assignment through an output iterator is expected to alternate with incrementing. Double-increment is undefined behavior (C++ standard currently claims that double increment is supported, contrary to the STL documentation; this is [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2035 LWG #2035])

===Standard library===
The following standard library iterators are output iterators that are not forward iterators:
* {{lc|std::ostream_iterator}}
* {{lc|std::ostreambuf_iterator}}
* {{lc|std::insert_iterator}}
* {{lc|std::back_insert_iterator}}
* {{lc|std::front_insert_iterator}}

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/OutputIterator]]
[[es:cpp/concept/OutputIterator]]
[[fr:cpp/concept/OutputIterator]]
[[it:cpp/concept/OutputIterator]]
[[ja:cpp/concept/OutputIterator]]
[[pt:cpp/concept/OutputIterator]]
[[ru:cpp/concept/OutputIterator]]
[[zh:cpp/concept/OutputIterator]]</text>
      <sha1>mp18lqj47o5kgjh0vdhw42wy3zud1yn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/PODType</title>
    <ns>0</ns>
    <id>5543</id>
    <revision>
      <id>61896</id>
      <parentid>57243</parentid>
      <timestamp>2013-06-09T16:35:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use rev</comment>
      <text xml:space="preserve" bytes="1232">{{cpp/concept/title|PODType}}
{{cpp/concept/navbar}}
Specifies that the type is POD (Plain Old Data) type. This means the type is compatible with the types used in the C programming language, can be manipulated using C library functions: it can be created with {{lc|std::malloc}}, it can be copied with {{lc|std::memmove}}, etc, and can be exchanged with C libraries directly, in its binary form. 

{{cpp/concept/concept note}}

===Requirements===
Either
* {{concept|ScalarType}} 
Or a class type ({{c|class}} or {{c|struct}} or {{c|union}}) that is
{{rev begin}}
{{rev | until=c++11 |
* an {{concept|AggregateType}} 
* has no non-static members that are non-POD
* has no members of reference type
* has no user-defined copy constructor
* has no user-defined destructor
}}
{{rev | since=c++11 |
* {{concept|TrivialType}}
* {{concept|StandardLayoutType}}
* has no non-static members that are non-POD
}}
{{rev end}}
Or an array of such type

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pod}}
{{dsc end}}

[[de:cpp/concept/PODType]]
[[es:cpp/concept/PODType]]
[[fr:cpp/concept/PODType]]
[[it:cpp/concept/PODType]]
[[ja:cpp/concept/PODType]]
[[pt:cpp/concept/PODType]]
[[ru:cpp/concept/PODType]]
[[zh:cpp/concept/PODType]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Predicate</title>
    <ns>0</ns>
    <id>9767</id>
    <revision>
      <id>67873</id>
      <parentid>67102</parentid>
      <timestamp>2014-03-04T04:10:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/callable/function object</comment>
      <text xml:space="preserve" bytes="752">{{cpp/concept/title|Predicate}}
{{cpp/concept/navbar}}

The {{tt|Predicate}} concept describes a function object that takes a single iterator argument that is dereferenced and used to return a value testable as a {{c|bool}}.

In other words, if an algorithm takes a {{tt|Predicate pred}} and an iterator {{tt|first}}, it should be able to test the iterator using the predicate via a construct like {{c|if (pred(*first)) {...} }}. 

The function object {{tt|pred}} shall not apply any non-constant function through the dereferenced iterator. This function object may be a pointer to function or an object of a type with an appropriate function call operator.

===Requirements===
* {{concept|FunctionObject}}

{{todo|better describe actual requirements}}</text>
      <sha1>lg4dk9au4qp50xje6dbcjgn76i7sx9d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/RandomAccessIterator</title>
    <ns>0</ns>
    <id>5520</id>
    <revision>
      <id>65434</id>
      <parentid>45895</parentid>
      <timestamp>2013-09-15T04:43:05Z</timestamp>
      <contributor>
        <username>Lichray</username>
        <id>1196</id>
      </contributor>
      <comment>There is no such requirement `n - it`</comment>
      <text xml:space="preserve" bytes="2930">{{cpp/concept/title|RandomAccessIterator}}
{{cpp/concept/navbar}}

A {{tt|RandomAccessIterator}} is a {{concept|BidirectionalIterator}} that can be moved to point to any element in constant time.

A standard pointer is an example of a type that satisfies this concept.

===Requirements===

* {{concept|BidirectionalIterator}}

In addition to the above requirement, for a type {{tt|It}} to be an {{tt|RandomAccessIterator}}, instances {{tt|a}}, {{tt|b}}, {{tt|i}}, and {{tt|r}} of {{tt|It}} must:

{|table class=&quot;wikitable&quot;
|-
!Expression||Return||Equivalent expression||Notes
|-
|{{c|r +{{=}} n}}
|{{c|It&amp;}}
|{{c|1=if ( n &gt;= 0 )
   while(n--) ++r;
else
   while(n++) --r;
return r;}}
|
*{{ttb|n}} can be both positive or negative
*Constant complexity (that is, the equivalent expression cannot be used as implementation)
|-
|{{c|i + n}}||{{c|It}}
|{{c|1=It temp = i;
return temp += n;}} 
|-
|{{c|n + i}}||{{c|It}}||{{c|i + n}}
|-
|{{c|r -{{=}} n}}||{{c|It&amp;}}||{{c|return r +{{=}} -n;}}
||
|-
|{{c|i - n}}||{{c|It}}||{{c|1=It temp = i;
return temp -= n;}}
|-
|{{c|b - a}}||{{c|difference}}||{{c|n}}||returns {{ttb|n}} such that {{ttb|a + n {{==}} b}}, where {{ttb|b {{==}} a + (b - a)}}.
|-
|{{c|i[n]}}||convertible to {{c|reference}}||{{c|*(i + n)}}
|-
|{{c|a &lt; b}}||contextually convertible to {{c|bool}}||{{c|b - a &gt; 0}}
|Strict total ordering relation:
* {{ttb|!(a &lt; a)}}
* if {{ttb|a &lt; b}} then {{ttb|!(b &lt; a)}}
* if {{ttb|a &lt; b}} and {{ttb|b &lt; c}} then {{ttb|a &lt; c}}
* {{ttb|a &lt; b}} or {{ttb|b &lt; a}} or {{ttb|a {{==}} b}} &lt;br&gt; (exactly one of the expressions is true)
|-
|{{c|a &gt; b}}||contextually convertible to {{c|bool}}||{{c|b &lt; a}}||Total ordering relation opposite to {{c|a &lt; b}}
|-
|{{c|a &gt;{{=}} b}}||contextually convertible to {{c|bool}}||{{c|!(a &lt; b)}} 
|-
|{{c|a &lt;{{=}} b}}||contextually convertible to {{c|bool}}||{{c|!(a &gt; b)}}
|}
====Table Notes====
*{{ttb|It}} is the type implementing this concept
*{{ttb|T}} is the type {{c|std::iterator_traits&lt;It&gt;::value_type}}
*{{ttb|reference}} is the type {{c|std::iterator_traits&lt;It&gt;::reference}}
*{{ttb|difference}} is the type {{c|std::iterator_traits&lt;It&gt;::difference_type}}
*{{ttb|i}}, {{ttb|a}}, {{ttb|b}} are objects of type {{ttb|It}} or {{ttb|const It}}
*{{ttb|r}} is a value of type {{ttb|It&amp;}}
*{{ttb|n}} is an integer of type {{ttb|difference}}

The above rules imply that RandomAccessIterator also implements {{concept|LessThanComparable}}.

A {{tt|mutable RandomAccessIterator}} is a {{tt|RandomAccessIterator}} that additionally satisfies the {{concept|OutputIterator}} requirements.

===See also===
* [[cpp/iterator|Iterator library]]

[[de:cpp/concept/RandomAccessIterator]]
[[es:cpp/concept/RandomAccessIterator]]
[[fr:cpp/concept/RandomAccessIterator]]
[[it:cpp/concept/RandomAccessIterator]]
[[ja:cpp/concept/RandomAccessIterator]]
[[pt:cpp/concept/RandomAccessIterator]]
[[ru:cpp/concept/RandomAccessIterator]]
[[zh:cpp/concept/RandomAccessIterator]]</text>
      <sha1>fy36ommknbr38w0c130nz9kjyei1e78</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/RandomNumberDistribution</title>
    <ns>0</ns>
    <id>8897</id>
    <revision>
      <id>49416</id>
      <parentid>42054</parentid>
      <timestamp>2013-06-01T02:38:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="3655">{{cpp/concept/title|RandomNumberDistribution}}
{{cpp/concept/navbar}}

A {{tt|RandomNumberDistribution}} is a function object returning random numbers according to a [[enwiki:Probability density function|probability density function]] {{math|p(x)}} or a [[enwiki:Discrete probability distribution|discrete probability distribution]] {{math|P(x{{su|b=i}})}}.

=== Requirements ===
{{todo}}

* {{ttb|D}} is a class meeting the {{tt|RandomNumberDistribution}} requirements. It shall also satisfy the {{concept|CopyConstructible}} and {{concept|CopyAssignable}} requirements.
* {{ttb|T}} is the associated {{tt|result_type}}.
* {{ttb|P}} is the associated {{tt|param_type}}. It shall satisfy the {{concept|CopyConstructible}}, {{concept|CopyAssignable}}, and {{concept|EqualityComparable}} requirements.
* {{ttb|d}} is an object of {{tt|D}} and {{ttb|x}},{{ttb|y}} are potentially const objects of {{tt|D}}.
* {{ttb|p}} is a possibly constant value of {{tt|P}}.
* {{ttb|g}},{{ttb|g1}},{{ttb|g2}} are lvalues meeting the {{concept|UniformRandomNumberGenerator}} concept.
* {{ttb|os}} is an lvalue of {{lc|std::basic_ostream}}.
* {{ttb|is}} is an lvalue of {{lc|std::basic_istream}}.

{|class=wikitable
!Expression||Type||Notes||Complexity
|-
|{{tt|D::result_type}} || {{tt|T}} || An arithmetic type || compile-time
|-
|{{tt|D::param_type}} || {{tt|P}} || || compile-time
|-
|{{tt|D()}} || || || constant
|-
|{{tt|D(p)}} || || || Same as {{tt|p}}'s construction
|-
|{{tt|d.reset()}} || {{tt|void}} || Resets the internal state of the distribution object. After a call to this function, the next call to {{tt|operator()}} on the distribution object will not be dependent on previous calls to {{tt|operator()}}. || constant
|-
|{{tt|x.param()}} || {{tt|P}} || || No worse than {{tt|D(p)}}
|-
|{{tt|d.param(p)}} || {{tt|void}} || || No worse than {{tt|D(p)}}
|-
|{{tt|d(g)}} || {{tt|T}} || {{tt|d(g, d.param())}} || Same as {{tt|d(g, d.param())}}
|-
|{{tt|d(g,p)}} || {{tt|T}} || When called with the same {{tt|g}} and {{tt|p}} parameter it returns a sequence of numbers distributed according to {{math|p(x;{{tt|p}})}} or {{math|P(x{{su|b=i}};{{tt|p}})}} || Amortized constant number of incovations of {{tt|g}}
|-
|{{tt|x.min()}} || {{tt|T}} || The greatest lower bound returned by {{tt|operator()}} || constant
|-
|{{tt|x.max()}} || {{tt|T}} || The least upper bound returned by {{tt|operator()}} || constant
|-
|{{tt|x {{==}} y}} || {{tt|bool}} || || constant
|-
|{{tt|y !{{=}} y}} || {{tt|bool}} || {{tt|!(x {{==}} y)}} || constant
|-
|{{tt|os &lt;&lt; x}} || Reference to the type of {{tt|os}} || Writes a textual representation of the distribution parameters and internal state to {{tt|os}} as textual representation. The formatting flags and fill character of {{tt|os}} are unchanged. ||
|-
|{{tt|is &gt;&gt; d}} || Reference to the type of {{tt|is}} || Restores the distribution parameters and internal state with data read from {{tt|is}}. The formatting flags of {{tt|is}} are unchanged. The data must have been written using a stream with the same locale, {{tt|CharT}} and {{tt|Traits}} template parameters, otherwise the behavior is undefined. If bad input is encountered, {{tt|is.setstate(std::ios::failbit)}} is called, which may throw {{lc|std::ios_base::failure}}. {{tt|d}} is unchanged in that case. ||
|-
|}

[[de:cpp/concept/RandomNumberDistribution]]
[[es:cpp/concept/RandomNumberDistribution]]
[[fr:cpp/concept/RandomNumberDistribution]]
[[it:cpp/concept/RandomNumberDistribution]]
[[ja:cpp/concept/RandomNumberDistribution]]
[[pt:cpp/concept/RandomNumberDistribution]]
[[ru:cpp/concept/RandomNumberDistribution]]
[[zh:cpp/concept/RandomNumberDistribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/ReversibleContainer</title>
    <ns>0</ns>
    <id>9774</id>
    <revision>
      <id>64396</id>
      <parentid>49417</parentid>
      <timestamp>2013-08-16T01:42:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>LWG issue 2105 (fixed in c++14)</comment>
      <text xml:space="preserve" bytes="2018">{{cpp/concept/title|ReversibleContainer}}
{{cpp/concept/navbar}}

A {{ttb|ReversibleContainer}} is a {{concept|Container}} that has iterators that meet the requirements of either {{concept|BidirectionalIterator}} or {{concept|RandomAccessIterator}}.  Such iterators allow a {{ttb|ReversibleContainer}} to be iterated over in reverse.

===Requirements===

{{dsc begin}}
{{dsc|{{ttb|X}}|Container type}}
{{dsc|{{ttb|T}}|Element type}}
{{dsc|{{ttb|a}}, {{ttb|b}}|Objects of type {{ttb|X}}}}
{{dsc end}}

====Types====

{|class=wikitable
!expression||return type||conditions||complexity
|-
|{{c|X::reverse_iterator}}|| iterator type whose value type is {{tt|T}} || {{c|reverse_iterator&lt;iterator&gt; }} || compile time
|-
|{{c|X::const_reverse_iterator}}|| constant iterator type whose value type is {{tt|T}} || {{c|reverse_iterator&lt;const_iterator&gt; }} || compile time
|-
|}

====Methods====

{|class=wikitable
!expression||return type||conditions||complexity
|-
|{{c|a.rbegin()}}|| {{c|reverse_iterator;}} {{c|const_reverse_iterator}} for constant {{tt|a}} || {{c|reverse_iterator(end())}} || constant
|-
|{{c|a.rend()}}|| {{c|reverse_iterator;}} {{c|const_reverse_iterator}} for constant {{tt|a}} || {{c|reverse_iterator(begin())}} || constant
|-
|{{c|a.crbegin()}}|| {{c|const_reverse_iterator}} || {{c|const_cast&lt;X const&amp;&gt;(a).rbegin();}} || constant
|-
|{{c|a.crend()}}|| {{c|const_reverse_iterator}} || {{c|const_cast&lt;X const&amp;&gt;(a).rend();}} || constant
|-
|}


===Example===
{{example
 | The following example iterates over a vector (which has random-access iterators) in reverse.
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; v = {3, 1, 4, 1, 5, 9};

    for(std::vector&lt;int&gt;::reverse_iterator i = v.rbegin(); i != v.rend(); ++i) {
        std::cout &lt;&lt; *i &lt;&lt; '\n';
    }
}
 | output=
9
5
1
4
1
3
}}


===Standard library===
* {{lc|std::array}}
* {{lc|std::deque}}
* {{lc|std::list}}
* {{lc|std::vector}}
* {{lc|std::map}}
* {{lc|std::multimap}}
* {{lc|std::set}}
* {{lc|std::multiset}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/SeedSequence</title>
    <ns>0</ns>
    <id>8896</id>
    <revision>
      <id>49418</id>
      <parentid>42044</parentid>
      <timestamp>2013-06-01T02:38:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2105">{{cpp/concept/title|SeedSequence}}
{{cpp/concept/navbar}}

A {{tt|seed sequence}} is an object that produces unsigned integer values {{math|i}} in the range {{math|0 ≤ i &lt; 2{{su|p=32}}}} based on a consumed range of integer data.

===Requirements===
*{{ttb|S}} is a SeedSequence.
*{{ttb|q}} is an object of {{tt|S}} and {{ttb|r}} is a potentially constant object of {{tt|S}}.
*{{ttb|T}} is the {{tt|result_type}}.
*{{ttb|ib}},{{ttb|ie}} are {{concept|InputIterator}}s with a {{tt|value_type}} of unsigned integer values of at least 32&amp;nbsp;bits.
*{{ttb|il}} is an {{c|std::initializer_list&lt;T&gt;}}.
*{{ttb|rb}},{{ttb|re}} are modifiable {{concept|RandomAccessIterator}}s with a {{tt|value_type}} of unsigned integer values of at least 32&amp;nbsp;bits.
*{{ttb|ob}} is an {{concept|OutputIterator}}.

{|class=wikitable
!Expression||Type||Notes||Complexity
|-
|{{tt|S::result_type}}||{{tt|T}}||Unsigned integer of at least 32 bits||compile-time
|-
|{{tt|S()}}|| ||Creates a seed sequence with the same default values as other objects of type {{tt|S}}||constant
|-
|{{tt|S(ib,ie)}}|| ||Creates a seed sequence based on the supplied input bits by {{math|[{{tt|ib}},{{tt|ie}})}} || {{math|O(ie-ib)}}
|-
|{{tt|S(il)}}|| ||The same as {{tt|S(il.begin(), il.end())}} ||
|-
|{{tt|q.generate(rb,re)}}|| {{tt|void}} || Fills {{math|[{{tt|rb}},{{tt|re}})}} with 32-bit quantities depending on the initial supplied values and potential previous calls to {{tt|generate}}. If {{tt|rb==re}} it does nothing.  || {{math|O(re-rb)}}
|-
|{{tt|r.size()}}|| {{tt|size_t}} || The amount of 32-bit integers copied by {{tt|param}}. || constant
|-
|{{tt|r.param(ob)}}|| {{tt|void}} || Copies 32-bit values to {{tt|ob}} that would reproduce the current state of the object if passed to a constructor of {{tt|S}}. || {{math|O(r.size())}}
|-
|}

===See also===
*{{lc|std::seed_seq}}

[[de:cpp/concept/SeedSequence]]
[[es:cpp/concept/SeedSequence]]
[[fr:cpp/concept/SeedSequence]]
[[it:cpp/concept/SeedSequence]]
[[ja:cpp/concept/SeedSequence]]
[[pt:cpp/concept/SeedSequence]]
[[ru:cpp/concept/SeedSequence]]
[[zh:cpp/concept/SeedSequence]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/SequenceContainer</title>
    <ns>0</ns>
    <id>8994</id>
    <revision>
      <id>66945</id>
      <parentid>66944</parentid>
      <timestamp>2014-01-10T14:41:37Z</timestamp>
      <contributor>
        <username>Ben.Hymers</username>
        <id>2780</id>
      </contributor>
      <comment>Correction: renaming emplace(p, t) to insert since there is no such emplace requirement (ref. [sequence.reqmts])</comment>
      <text xml:space="preserve" bytes="4547">{{cpp/concept/title|SequenceContainer}}
{{cpp/concept/navbar}}

A {{ttb|SequenceContainer}} is a {{concept|Container}} that stores objects of the same type in a linear arrangement.

===Requirements===
{{dsc begin}}
{{dsc h1|Legend}}
{{dsc|{{ttb|X}}|Container type}}
{{dsc|{{ttb|T}}|Element type}}
{{dsc|{{ttb|a}}, {{ttb|b}}|Objects of type {{ttb|X}}}}
{{dsc|{{ttb|t}}|Object of type {{ttb|T}} }}
{{dsc|{{ttb|n}}|Positive integer}}
{{dsc|{{ttb|i}}, {{ttb|j}}|{{concept|InputIterator}}s denoting a valid range}}
{{dsc|{{ttb|il}}|{{lc|std::initializer_list}}&lt;T&gt;}}
{{dsc|{{ttb|args}}|Parameter pack}}
{{dsc|{{ttb|p}}, {{ttb|q}}|const_iterators in {{ttb|a}} }}
{{dsc end}}


{|class=wikitable
!expression||return type||effects||precondition||postcondition
|-
|{{c|X(n,t)}}|| ||Constructs a {{ttb|SequenceContainer}} containing {{ttb|n}} copies of {{ttb|t}} || T {{concept|CopyInsertable}} || {{c|std::distance(begin(),end()) {{==}} n}}
|-
|{{c|X(i,j)}}|| ||Constructs a {{ttb|SequenceContainer}} equivalent to the range {{tt|[i,j)}}
|
* T {{concept|EmplaceConstructible}} 
* {{mark|only for std::vector}} If the iterators are not {{concept|ForwardIterator}}s, T must be {{concept|CopyInsertable}}
|{{c|1=std::distance(begin(),end()) == 
std::distance(i,j)}}
|-
|{{c|X(il)}}|| || {{c|X(il.begin(),il.end())}} || ||
|-
|{{c|1=a = il}}||{{c|X&amp;}}||Assigns the range represented by {{ttb|il}} into {{ttb|a}}
| T {{concept|CopyInsertable}} and {{concept|CopyAssignable}}
| Existing elements of {{ttb|a}} are destroyed or assigned to
|- 
|{{c|a.emplace(p,args)}}||iterator
|Insert an object constructed with {{c|std::forward&lt;Args&gt;(args)}} before {{ttb|p}}
|
*T {{concept|CopyInsertable}}
*{{mark|for std::vector and std::deque}} T {{concept|MoveAssignable}} and {{concept|MoveInsertable}}
|
|- 
|{{c|a.insert(p,t)}}||iterator
|Inserts a copy of {{ttb|t}} before {{ttb|p}}
|
* T {{concept|CopyInsertable}}
*{{mark|for std::vector and std::deque}} T {{concept|CopyAssignable}} or {{concept|MoveAssignable}}
|
|-
|{{c|a.insert(p,n,t)}}||iterator||Inserts {{ttb|n}} copies of {{ttb|t}} before {{ttb|p}}
| T {{concept|CopyInsertable}} and {{concept|CopyAssignable}}
|
|-
|{{c|a.insert(p,i,j)}}||iterator||Inserts copies of elements in {{tt|[i, j)}} before {{ttb|p}}
|
* T {{concept|EmplaceConstructible}}
* {{mark|only for std::vector}} If the iterators are not {{concept|ForwardIterator}}s, T must be {{concept|MoveInsertable}} and {{concept|MoveAssignable}}
* {{ttb|i}} and {{ttb|j}} are not in {{ttb|a}}
|Each iterator in {{tt|[i,j)}} is dereferenced once
|-
|{{c|a.insert(p, il)}}||iterator||{{c|a.insert(p,il.begin(),il.end())}}|| ||
|-
|{{c|a.erase(q)}}||iterator||Erases the element pointed to by q
|{{mark|std::deque, std::vector}} T {{concept|MoveAssignable}}
|
|-
|{{c|a.erase(p,q)}}||iterator||Erases elements in {{tt|[p,q)}}||{{mark|std::deque, std::vector}} T {{concept|MoveAssignable}}||
|-
|{{c|a.clear()}}||void||Destroys all elements in {{ttb|a}}|| ||
* All references are invalidated
* {{c|1=a.empty() == true}}
|-
|{{c|a.assign(i,j)}}||void||Replaces elements in a with a copy of {{tt|[i, j)}}
|
* T {{concept|EmplaceConstructible}}
* {{mark|std::vector}} If not {{concept|ForwardIterator}} T {{concept|MoveInsertable}}
* {{ttb|i}}, {{ttb|j}} not in {{ttb|a}}
|Each iterator in {{tt|[i,j)}} is dereferenced once
|-
|{{c|a.assign(il)}}||void||{{c|a.assign(il.begin(),il.end())}}|| ||
|-
|{{c|a.assign(n,t)}}||void
|Replaces elements in {{ttb|a}} with {{ttb|n}} copies of {{ttb|t}}
|T {{concept|CopyInsertable}} and {{concept|CopyAssignable}}
|
|-
|}

===Optional Operations===
{{todo}}

===SequenceContainers in the standard library===
{{dsc begin}}
{{dsc inc | cpp/container/dsc array}}
{{dsc inc | cpp/container/dsc vector}}
{{dsc inc | cpp/container/dsc deque}}
{{dsc inc | cpp/container/dsc forward_list}}
{{dsc inc | cpp/container/dsc list}}
{{dsc end}}

====Trade-offs / usage notes====
{{dsc begin}}
{{dsc|std::array|Fast access but fixed number of elements}}
{{dsc|std::vector|Fast access but mostly inefficient insertions/deletions}}
{{dsc|std::list&lt;br/&gt;std::forward_list|Efficient insertion/deletion in the middle of the sequence}}
{{dsc|std::deque|Efficient insertion/deletion at the beginning and at the end of the sequence}}
{{dsc end}}

[[de:cpp/concept/SequenceContainer]]
[[es:cpp/concept/SequenceContainer]]
[[fr:cpp/concept/SequenceContainer]]
[[it:cpp/concept/SequenceContainer]]
[[ja:cpp/concept/SequenceContainer]]
[[pt:cpp/concept/SequenceContainer]]
[[ru:cpp/concept/SequenceContainer]]
[[zh:cpp/concept/SequenceContainer]]</text>
      <sha1>mbdd5ua15wr1n0l6dg5pnus0pakl1qy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/SharedMutex</title>
    <ns>0</ns>
    <id>13476</id>
    <redirect title="cpp/concept/SharedTimedMutex" />
    <revision>
      <id>68921</id>
      <timestamp>2014-03-22T22:37:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/concept/SharedMutex]] to [[cpp/concept/SharedTimedMutex]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/concept/SharedTimedMutex]]</text>
      <sha1>dblyj4xcfn5jrycwujkbnnpnch9hi27</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/SharedTimedMutex</title>
    <ns>0</ns>
    <id>13005</id>
    <revision>
      <id>68922</id>
      <parentid>68920</parentid>
      <timestamp>2014-03-22T22:38:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="5107">{{cpp/concept/title|SharedTimedMutex}}
{{cpp/concept/navbar}}

The {{tt|SharedTimedMutex}} concept extends the {{concept|TimedMutex}} concept to include inter-thread synchronization.

===Requirements===

* {{concept|TimedMutex}}

Additionally, for object {{ttb|m}} of {{tt|SharedTimedMutex}} type supports another mode of ownership: shared. Multiple threads (or, more generally, execution agents) can simulataneously own this mutex in shared mode, but no thread may obtain shared ownership if there is a thread that owns it in exclusive mode and no thread may obtain exclusive ownership if there is a thread that owns it in shared mode. If more than implementation-defined number of threads (no less than 10000) hold a shared lock, another attempt to acquire the mutex in shared mode blocks until the number of shared owners drops down below that threshold.

* The expression {{c|m.lock_shared()}} has the following properties
:* Behaves as an atomic operation.
:* Blocks the calling thread until shared ownership of the mutex can be obtained.
:* Prior {{c|m.unlock()}} operations on the same mutex ''synchronize-with'' this lock operation (equivalent to release-acquire {{lc|std::memory_order}})
:* The behavior is undefined if the calling thread already owns the mutex in any mode.
:* If an exception is thrown, the shared lock is not acquired.

* The expression {{c|m.try_lock_shared()}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain shared ownership of the mutex for the calling thread without blocking. If ownership is not obtained, returns immediately. The function is allowed to spuriously fail and return even if the mutex is not currently owned by any threads in any mode.
:* If {{tt|try_lock_shared()}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}).
:* The behavior is undefined if the calling thread already owns the mutex in any mode

* The expression {{c|m.try_lock_shared_for(duration)}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain shared ownership of the mutex within the duration specified by {{tt|duration}}. If {{tt|duration}} is less or equal {{tt|duration.zero()}}, attempts to obtain the ownership without locking (as if by {{tt|try_lock()}}). Otherwise, this function blocks until the mutex is acquired or until the time specified by {{tt|duration}} passes. It returns within {{tt|duration}} only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time during {{tt|duration}} it was not owned by another thread. In any case, it returns {{c|true}} if the mutex was acquired and {{c|false}} otherwise.
:* If {{tt|try_lock_shared_for(duration)}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}).
:* The behavior is undefined if the calling thread already owns the mutex in any mode
:* If an exception is thrown, the shared lock is not acquired.

* The expression {{c|m.try_lock_shared_until(time_point)}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain shared ownership of the mutex within the time left until {{tt|time_point}}. If {{tt|time_point}} already passed, attempts to obtain the ownership without locking (as if by {{tt|try_lock()}}). Otherwise, this function blocks until the mutex is acquired or until the time specified by {{tt|time_point}} passes. It returns before {{tt|time_point}} only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time before {{tt|time_point}} it was not owned by another thread. In any case, it returns {{c|true}} if the mutex was acquired and {{c|false}} otherwise.
:* If {{tt|try_lock_shared_until(time_point)}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}).
:* The behavior is undefined if the calling thread already owns the mutex in any mode
:* If an exception is thrown, the shared lock is not acquired.

* The expression {{c|m.unlock_shared()}} has the following properties
:* Behaves as an atomic operation.
:* Releases the calling thread's ownership of the mutex and ''synchronizes-with'' the subsequent successful lock operations on the same object.
:* The behavior is undefined if the calling thread does not own the mutex.

* All lock and unlock operations on a single mutex occur in a single total order

===Library types===
The following standard library types satisfy {{concept|SharedTimedMutex}}:
* {{lc|std::shared_timed_mutex}}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|Mutex}}
* {{concept|TimedMutex}}

[[de:cpp/concept/SharedTimedMutex]]
[[es:cpp/concept/SharedTimedMutex]]
[[fr:cpp/concept/SharedTimedMutex]]
[[it:cpp/concept/SharedTimedMutex]]
[[ja:cpp/concept/SharedTimedMutex]]
[[pt:cpp/concept/SharedTimedMutex]]
[[ru:cpp/concept/SharedTimedMutex]]
[[zh:cpp/concept/SharedTimedMutex]]</text>
      <sha1>t959hlnnshe9620burlupk9kys8jmnu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/StandardLayoutType</title>
    <ns>0</ns>
    <id>5542</id>
    <revision>
      <id>71668</id>
      <parentid>71372</parentid>
      <timestamp>2014-06-19T02:31:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to properties</comment>
      <text xml:space="preserve" bytes="1239">{{cpp/concept/title|StandardLayoutType}}
{{cpp/concept/navbar}}

Specifies that a type is [[cpp/language/data_members|standard layout type]]. Standard layout types are useful for communicating with code written in other programming languages.

{{cpp/concept/concept note}}

===Requirements===
* All non-static members have the same [[cpp/language/access|access control]]
* Has no virtual functions or virtual base classes
* All non-static members and base classes are themselves standard layout types
* Has no base classes of the same type as the first non-static data member
:* Either has no non-static data members in the most derived class and at most one base class with non-static data members
:* Or has no base classes with non-static data members at all

===Properties===
See [[cpp/language/data_members#Standard_layout|Standard layout]].

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_standard_layout}}
{{dsc end}}

[[de:cpp/concept/StandardLayoutType]]
[[es:cpp/concept/StandardLayoutType]]
[[fr:cpp/concept/StandardLayoutType]]
[[it:cpp/concept/StandardLayoutType]]
[[ja:cpp/concept/StandardLayoutType]]
[[pt:cpp/concept/StandardLayoutType]]
[[ru:cpp/concept/StandardLayoutType]]
[[zh:cpp/concept/StandardLayoutType]]</text>
      <sha1>ifz2fo7z1rswscfbrieodsy2j6fjkhk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/Swappable</title>
    <ns>0</ns>
    <id>9121</id>
    <revision>
      <id>70286</id>
      <parentid>49421</parentid>
      <timestamp>2014-05-16T17:57:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+mention friend approach</comment>
      <text xml:space="preserve" bytes="2476">{{cpp/concept/title|Swappable}}
{{cpp/concept/navbar}}
Any lvalue or rvalue of this type can be swapped with any lvalue or rvalue of the some other type, using unqualified function call {{c|swap()}} in the context where both {{lc|std::swap}} and the user-defined {{c|swap()}}s are visible.

===Requirements===

Type U is swappable with type T if, for any object u of type U and any object t of type T,

{|table class=wikitable
|-
!Expression||Requirements||Semantics
|-
| {{c|#include &lt;utility&gt;
using std::swap;
swap(u, t);}}
| After the call, the value of {{tt|t}} is the value held by {{tt|u}} before the call, and the value of {{tt|u}} is the value held by {{tt|t}} before the call.
| Calls the function named {{c|swap()}} found by overload resolution among all functions with that name that are found by argument-dependent lookup and the two {{lc|std::swap}} templates defined in the header {{c|&lt;utility&gt;}}.
|-
| {{c|#include &lt;utility&gt;
using std::swap;
swap(t, u);}}
| same
| same
|}

Many standard library functions (for example, many algorithms) expect their arguments to satisfy {{concept|Swappable}}, which means that any time the standard library performs a swap, it uses the equivalent of {{c|using std::swap; swap(t, u);}}.

Typical implementations either
@1@ Define a non-member swap in the enclosing namespace, which may forward to a member swap if access to non-public data members is required
@2@ Define a [[cpp/language/friend|friend function]] in-class (this approach hides the class-specific swap from name lookup other than ADL)

===Notes===
It is unspecified if {{c|&lt;utility&gt;}} is actually included when the standard library functions perform the swap, so the user-provided {{c|swap()}} should not expect it to be included.

===Example===
{{example
 | 
 | code=

#include &lt;iostream&gt;
#include &lt;vector&gt;

class IntVector {
    std::vector&lt;int&gt; v;
    IntVector&amp; operator=(IntVector); // not assignable
 public:
    void swap(IntVector&amp; other) {
        v.swap(other.v);
    }
};
void swap(IntVector&amp; v1, IntVector&amp; v2) {
    v1.swap(v2);
}

int main()
{
    IntVector v1, v2;
//  std::swap(v1, v2); // compiler error! std::swap requires MoveAssignable
    std::iter_swap(&amp;v1, &amp;v2); // OK: library calls unqualified swap()
}
}}

[[de:cpp/concept/Swappable]]
[[es:cpp/concept/Swappable]]
[[fr:cpp/concept/Swappable]]
[[it:cpp/concept/Swappable]]
[[ja:cpp/concept/Swappable]]
[[pt:cpp/concept/Swappable]]
[[ru:cpp/concept/Swappable]]
[[zh:cpp/concept/Swappable]]</text>
      <sha1>ppvn6mpqa7rn24gnzctgo363wgvg907</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/TimedLockable</title>
    <ns>0</ns>
    <id>9573</id>
    <revision>
      <id>65578</id>
      <parentid>63911</parentid>
      <timestamp>2013-09-21T01:10:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso timedmutex</comment>
      <text xml:space="preserve" bytes="781">{{cpp/concept/title|TimedLockable}}
{{cpp/concept/navbar}}

The {{tt|TimedLockable}} concept describes the characteristics of types that provide timed exclusive blocking semantics for execution agents (i.e. threads).

===Requirements===

For type {{ttb|L}} to be {{tt|TimedLockable}}, the following conditions have to be satisfied for an object {{ttb|m}} of type {{ttb|L}}:
{|table class=wikitable
|-
!Expression||Requires||Effects
|-
|{{c|m.try_lock_for(duration)}}
|
|Blocks for the provided duration the resource {{ttb|m}}.
|-
|{{c|m.try_lock_until(time_limit)}}
|
|Blocks the resource {{ttb|m}} until the provided time limit point is reached.
|}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|TimedMutex}}
* {{concept|Lockable}}
* {{concept|BasicLockable}}</text>
      <sha1>jtfaau1vzcnb6vs82gts45x76waomwh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/TimedMutex</title>
    <ns>0</ns>
    <id>13004</id>
    <revision>
      <id>65577</id>
      <timestamp>2013-09-21T01:09:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="2944">{{cpp/concept/title|TimedMutex}}
{{cpp/concept/navbar}}

The {{tt|TimedMutex}} concept extends the {{concept|TimedLockable}} concept to include inter-thread synchronization.

===Requirements===

* {{concept|TimedLockable}}
* {{concept|Mutex}}

Additionally, for object {{ttb|m}} of {{tt|TimedMutex}} type.
* The expression {{c|m.try_lock_for(duration)}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain exclusive ownership of the mutex within the duration specified by {{tt|duration}}. If {{tt|duration}} is less or equal {{tt|duration.zero()}}, attempts to obtain the ownership without locking (as if by {{tt|try_lock()}}). Otherwise, this function blocks until the mutex is acquired or until the time specified by {{tt|duration}} passes. It returns within {{tt|duration}} only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time during {{tt|duration}} it was not owned by another thread. In any case, it returns {{c|true}} if the mutex was acquired and {{c|false}} otherwise.
:* If {{tt|try_lock_for(duration)}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}).
:* The behavior is undefined if the calling thread already owns the mutex (except if m is {{lc|std::recursive_timed_mutex}})
* The expression {{c|m.try_lock_until(time_point)}} has the following properties
:* Behaves as an atomic operation.
:* Attempts to obtain exclusive ownership of the mutex within the time left until {{tt|time_point}}. If {{tt|time_point}} already passed, attempts to obtain the ownership without locking (as if by {{tt|try_lock()}}). Otherwise, this function blocks until the mutex is acquired or until the time specified by {{tt|time_point}} passes. It returns before {{tt|time_point}} only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time before {{tt|time_point}} it was not owned by another thread. In any case, it returns {{c|true}} if the mutex was acquired and {{c|false}} otherwise.
:* If {{tt|try_lock_until(time_point)}} succeeds, prior {{tt|unlock()}} operations on the same object ''synchronize-with'' this operation (equivalent to release-acquire {{lc|std::memory_order}}).
:* The behavior is undefined if the calling thread already owns the mutex (except if m is {{lc|std::recursive_timed_mutex}})

===Library types===
The following standard library types satisfy {{concept|TimedMutex}}:
* {{lc|std::timed_mutex}}
* {{lc|std::recursive_timed_mutex}}
* {{lc|std::shared_mutex}}

===See also===
* [[cpp/thread|Thread support library]]
* {{concept|TimedLockable}}
* {{concept|Mutex}}

[[de:cpp/concept/TimedMutex]]
[[es:cpp/concept/TimedMutex]]
[[fr:cpp/concept/TimedMutex]]
[[it:cpp/concept/TimedMutex]]
[[ja:cpp/concept/TimedMutex]]
[[pt:cpp/concept/TimedMutex]]
[[ru:cpp/concept/TimedMutex]]
[[zh:cpp/concept/TimedMutex]]</text>
      <sha1>qsjhbuwvrudogtwtvjtm5z56xhtagta</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/TrivialClock</title>
    <ns>0</ns>
    <id>9877</id>
    <revision>
      <id>72321</id>
      <parentid>72312</parentid>
      <timestamp>2014-08-08T14:37:22Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>link NumericType</comment>
      <text xml:space="preserve" bytes="896">{{cpp/concept/title|TrivialClock}}
{{cpp/concept/navbar}}

The {{concept|TrivialClock}} concept describes the requirements satisfied by all the clocks in the [[cpp/chrono|chrono library]].

===Requirements===
For a type {{c|TC}}:

* The type must meet {{concept|Clock}} requirements.
* The types {{c|TC::rep}}, {{c|TC::duration}}, and {{c|TC::time_point}} satisfy the requirements of {{concept|EqualityComparable}}, {{concept|LessThanComparable}}, {{concept|DefaultConstructible}}, {{concept|CopyConstructible}}, {{concept|CopyAssignable}}, {{concept|Destructible}}, and {{concept|NumericType}}.
* [[cpp/language/value category|lvalues]] of the types {{c|TC::rep}}, {{c|TC::duration}}, and {{c|TC::time_point}} are {{concept|Swappable}}.
* The function {{c|TC::now()}} does not throw exceptions.
* The type {{c|TC::time_point::clock}} meets the {{concept|TrivialClock}} requirements, recursively.</text>
      <sha1>rcpqi70ggezntozbv5shmyjnme2yjar</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/TrivialType</title>
    <ns>0</ns>
    <id>5541</id>
    <revision>
      <id>72383</id>
      <parentid>57248</parentid>
      <timestamp>2014-08-18T14:10:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link trivial default ctor</comment>
      <text xml:space="preserve" bytes="611">{{cpp/concept/title|TrivialType}}
{{cpp/concept/navbar}}
Specifies that a type is [[todo|trivial type]].

{{cpp/concept/concept note}}

===Requirements===
* {{concept|TriviallyCopyable}}
* [[cpp/language/default_constructor#Trivial_default_constructor|Trivial default constructor]]

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_trivial}}
{{dsc end}}

[[de:cpp/concept/TrivialType]]
[[es:cpp/concept/TrivialType]]
[[fr:cpp/concept/TrivialType]]
[[it:cpp/concept/TrivialType]]
[[ja:cpp/concept/TrivialType]]
[[pt:cpp/concept/TrivialType]]
[[ru:cpp/concept/TrivialType]]
[[zh:cpp/concept/TrivialType]]</text>
      <sha1>fc8f0emslqgqb4apqttoil6rqlr3w8j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/TriviallyCopyable</title>
    <ns>0</ns>
    <id>5540</id>
    <revision>
      <id>72384</id>
      <parentid>71432</parentid>
      <timestamp>2014-08-18T14:16:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>links, -redundant and poorly-worded note, raise the other note to main text</comment>
      <text xml:space="preserve" bytes="1320">{{cpp/concept/title|TriviallyCopyable}}
{{cpp/concept/navbar}}

===Requirements===
*[[cpp/language/copy_constructor#Trivial_copy_constructor|Trivial copy constructor]]
*[[cpp/language/move_constructor#Trivial_move_constructor|Trivial move constructor]]
*[[cpp/language/as_operator#Trivial_copy_assignment_operator|Trivial copy assignment operator]]
*[[cpp/language/move_operator#Trivial_move_assignment_operator|Trivial move assignment operator]]
*[[cpp/language/destructor#Trivial_destructor|Trivial destructor]]
*No [[cpp/language/virtual|virtual functions]] or [[cpp/language/derived_class#Virtual_base_classes|virtual base classes]]
*All (non-static) members and base classes are {{tt|TriviallyCopyable}}

Scalar types and arrays of {{tt|TriviallyCopiable}} objects are {{tt|TriviallyCopiable}} as well, as well as the [[cpp/language/cv|const]]-qualified (but not [[cpp/language/cv|volatile]]-qualified) versions of such types.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc end}}

[[de:cpp/concept/TriviallyCopyable]]
[[es:cpp/concept/TriviallyCopyable]]
[[fr:cpp/concept/TriviallyCopyable]]
[[it:cpp/concept/TriviallyCopyable]]
[[ja:cpp/concept/TriviallyCopyable]]
[[pt:cpp/concept/TriviallyCopyable]]
[[ru:cpp/concept/TriviallyCopyable]]
[[zh:cpp/concept/TriviallyCopyable]]</text>
      <sha1>lnlksu2z915hxj2rru9bhprmpxwzcii</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/UnformattedInputFunction</title>
    <ns>0</ns>
    <id>9532</id>
    <revision>
      <id>49424</id>
      <parentid>41987</parentid>
      <timestamp>2013-06-01T02:39:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="3264">{{cpp/concept/title|UnformattedInputFunction}}
{{cpp/concept/navbar}}

===Requirements===

An {{tt|UnformattedInputFunction}} is a stream input function that performs the following:

* Constructs an object of type {{l2tt|cpp/io/basic_istream/sentry}} with automatic storage duration and with the {{tt|noskipws}} argument set to {{c|true}}, which performs the following
:* if {{ltt|cpp/io/ios_base/iostate|eofbit}} or {{ltt|cpp/io/ios_base/iostate|badbit}} are set on the input stream, sets the {{tt|failbit}} as well, and if exceptions on failbit are enabled in this input stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* flushes the tie()'d output stream, if applicable
* Checks the status of the sentry by calling {{tt|sentry::operator bool()}}, which is equivalent to {{l2tt|cpp/io/basic_ios/good}}.
* If the sentry returned {{c|false}} or sentry's constructor threw an exception:
:* sets the number of extracted characters (gcount) in the input stream to zero
:* if the function was called to write to an array of {{tt|CharT}}, writes {{tt|CharT()}} (the null character) to the first location of the array
* If the sentry returned {{c|true}}, performs the input as if by calling {{c|rdbuf()-&gt;sbumpc()}} or {{c|rdbuf()-&gt;sgetc()}}.
:* if the end of the stream is reached (the call to {{c|rdbuf()-&gt;sbumpc()}} or {{c|rdbuf()-&gt;sgetc()}} returns {{c|Traits::eof()}}, sets {{tt|eofbit}}. If exceptions on eofbit are enabled in this stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* if an exception is thrown during input, sets {{tt|badbit}} in the input stream. If exceptions on badbit are enabled in this stream's exception mask, the exception is also rethrown.
:* If no exception was thrown during input, sets the number of extracted characters (gcount) in the input stream.
* In any event, whether terminating by exception or returning, the sentry's destructor is called before leaving this function.

===Standard library===

The following standard library functions are {{concept|UnformattedInputFunction}}s.

* {{lc|std::getline}}, except that it does not modify gcount.
* {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;{{dsc small|(basic_streambuf*)}}}}
* {{l2tt|cpp/io/basic_istream/get}}
* {{l2tt|cpp/io/basic_istream/getline}}
* {{l2tt|cpp/io/basic_istream/ignore}}
* {{l2tt|cpp/io/basic_istream/peek}}
* {{l2tt|cpp/io/basic_istream/read}}
* {{l2tt|cpp/io/basic_istream/readsome}}
* {{l2tt|cpp/io/basic_istream/putback}}, except that it first clears {{tt|eofbit}}
* {{l2tt|cpp/io/basic_istream/unget}}, except that it first clears {{tt|eofbit}}
* {{l2tt|cpp/io/basic_istream/sync}}, except that it does not modify gcount
* {{l2tt|cpp/io/basic_istream/tellg}}, except that it does not modify gcount
* {{l2tt|cpp/io/basic_istream/seekg}}, except that it first clears {{tt|eofbit}} and does not modify gcount
* {{lc|std::ws}}, except that it does not modify gcount

[[de:cpp/concept/UnformattedInputFunction]]
[[es:cpp/concept/UnformattedInputFunction]]
[[fr:cpp/concept/UnformattedInputFunction]]
[[it:cpp/concept/UnformattedInputFunction]]
[[ja:cpp/concept/UnformattedInputFunction]]
[[pt:cpp/concept/UnformattedInputFunction]]
[[ru:cpp/concept/UnformattedInputFunction]]
[[zh:cpp/concept/UnformattedInputFunction]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/UnformattedOutputFunction</title>
    <ns>0</ns>
    <id>9609</id>
    <revision>
      <id>61961</id>
      <parentid>49425</parentid>
      <timestamp>2013-06-12T15:53:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++11 seeks</comment>
      <text xml:space="preserve" bytes="2147">{{cpp/concept/title|UnformattedOutputFunction}}
{{cpp/concept/navbar}}

===Requirements===

A {{tt|UnformattedOutputFunction}} is a stream output function that performs the following:

* Constructs an object of type {{l2tt|cpp/io/basic_ostream/sentry}} with automatic storage duration, which performs the following
:* if {{ltt|cpp/io/ios_base/iostate|eofbit}} or {{ltt|cpp/io/ios_base/iostate|badbit}} are set on the output stream, sets the {{tt|failbit}} as well, and if exceptions on failbit are enabled in this output stream's exception mask, throws {{l2tt|cpp/io/ios_base/failure}}.
:* flushes the tie()'d output stream, if applicable.
* Checks the status of the sentry by calling {{tt|sentry::operator bool()}}, which is equivalent to {{l2tt|cpp/io/basic_ios/good}}.
* If the sentry returned {{c|false}} or sentry's constructor threw an exception, no output takes place
* If the sentry returned {{c|true}}, attempts to perform the desired output by inserting the characters into the output stream as if by calling {{c|rdbuf()-&gt;sputc()}} or {{c|rdbuf()-&gt;xsputn()}}. Additionally, {{c|rdbuf()-&gt;overflow()}} and {{c|rdbuf()-&gt;sync()}} may be called, but no other virtual member function of {{lc|std::basic_streambuf}}.
:* if an exception is thrown during output, sets {{tt|badbit}} in the output stream. If exceptions on badbit are enabled in this stream's exception mask, the exception is also rethrown.
:* If no exception was thrown, returns the value specified by the function.
* In any event, whether terminating by exception or returning, the sentry's destructor is called before leaving this function.

===Standard library===

The following standard library functions are {{concept|UnformattedOutputFunction}}s.

* {{l2tt|cpp/io/basic_ostream/operator_ltlt|operator&gt;&gt;{{dsc small|(basic_streambuf*)}}}}
* {{l2tt|cpp/io/basic_ostream/put}}
* {{l2tt|cpp/io/basic_ostream/write}}
* {{l2tt|cpp/io/basic_ostream/flush}}
{{rev begin}}
{{rev |since=c++11|
* {{l2tt|cpp/io/basic_ostream/tellp}} (except calls pubseekoff instead of output)
* {{l2tt|cpp/io/basic_ostream/seekp}} (except calls pubseekoff or pubseekpos instead of output)
}}
{{rev end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/UniformRandomNumberGenerator</title>
    <ns>0</ns>
    <id>13724</id>
    <revision>
      <id>72305</id>
      <timestamp>2014-08-06T20:00:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1904">{{cpp/concept/title|UniformRandomNumberGenerator}}
{{cpp/concept/navbar}}

A uniform random number generator is a function object returning unsigned integer values such that each value in the range of possible results has (ideally) equal probability. Any uniform random number generator may be plugged into any [[cpp/numeric/random|random number distribution]].

===Requirements===
The type {{tt|G}} satisfies {{tt|UniformRandomNumberGenerator}} if

Given
* {{tt|T}}, the type named by {{tt|G::result_type}}
* {{tt|g}}, a value of type {{tt|G}}

The following expressions must be valid and have their specified effects

{|table class=wikitable
|-
!Expression||Return type||Requirements
|-
| {{c|G::result_type}}
| {{tt|T}}
| {{tt|T}} is an unsigned integer type
|-
| {{c|G::min()}}
| {{tt|T}}
| Returns the smallest value that G's operator() may return. The value is strictly less than {{tt|G::max()}}.
|-
| {{c|G::max()}}
| {{tt|T}}
| Returns the largest value that G's operator() may return. The value is strictly greater than {{tt|G::min()}}
|-
| {{c|g()}}
| {{tt|T}}
| Returns a value in the closed interval {{c|[G::min(), G::max()]}}. Has amortized constant complexity.
|}

===Notes===
All {{concept|RandomNumberEngine}}s satisfy this concept.

===Standard library===
The following standard library facilities expect a {{concept|UniformRandomNumberGenerator}} type.
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc random_shuffle}}
{{dsc inc | cpp/numeric/random/dsc generate_canonical}}
{{dsc inc | cpp/numeric/random/dsc uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/dsc uniform_real_distribution}}
{{dsc | all other random number distributions}}
{{dsc end}}
The following standard library facilities satisfy {{concept|UniformRandomNumberGenerator}} without additionally satisfying {{concept|RandomNumberEngine}}:
{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc random_device}}
{{dsc end}}</text>
      <sha1>aemnt5x8zy08k67za6zy5n8jwo1kz2x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/concept/ValueSwappable</title>
    <ns>0</ns>
    <id>9307</id>
    <revision>
      <id>49426</id>
      <parentid>46583</parentid>
      <timestamp>2013-06-01T02:39:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1716">{{cpp/concept/title|ValueSwappable}}
{{cpp/concept/navbar}}
Two objects of this type can be dereferenced and the resulting values can be swapped using unqualified function call {{c|swap()}} in the context where both {{lc|std::swap}} and the user-defined {{c|swap()}}s are visible.

===Requirements===

Type T is {{concept|ValueSwappable}} if

@1@ Type {{tt|T}} satisfies the {{concept|Iterator}} requirements
@2@ For any dereferencable object {{tt|x}} of type {{tt|T}} (that is, any value other than the end iterator), {{tt|*x}} satisfies the {{concept|Swappable}} requirements.

Many standard library functions expect their arguments to satisfy {{concept|ValueSwappable}}, which means that any time the standard library performs a swap, it uses the equivalent of {{c|using std::swap; swap(*iter1, *iter2);}}.

===Example===
{{example
 | 
 | code=

#include &lt;iostream&gt;
#include &lt;vector&gt;

class IntVector {
    std::vector&lt;int&gt; v;
    IntVector&amp; operator=(IntVector); // not assignable
 public:
    void swap(IntVector&amp; other) {
        v.swap(other.v);
    }
};
void swap(IntVector&amp; v1, IntVector&amp; v2) {
    v1.swap(v2);
}

int main()
{
    IntVector v1, v2;    // IntVector is Swappable, but not MoveAssignable
    IntVector* p1 = &amp;v1;
    IntVector* p2 = &amp;v2; // IntVector* is ValueSwappable
    std::iter_swap(p1, p2); // OK: iter_swap requires ValueSwappable
//  std::swap(v1, v2); // compiler error! std::swap requires MoveAssignable
}
}}

[[de:cpp/concept/ValueSwappable]]
[[es:cpp/concept/ValueSwappable]]
[[fr:cpp/concept/ValueSwappable]]
[[it:cpp/concept/ValueSwappable]]
[[ja:cpp/concept/ValueSwappable]]
[[pt:cpp/concept/ValueSwappable]]
[[ru:cpp/concept/ValueSwappable]]
[[zh:cpp/concept/ValueSwappable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container</title>
    <ns>0</ns>
    <id>796</id>
    <revision>
      <id>72422</id>
      <parentid>69317</parentid>
      <timestamp>2014-08-21T12:43:38Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Member function table */ emplace() and adaptors::swap() are new in c++11</comment>
      <text xml:space="preserve" bytes="34962">{{title|Containers library}}
{{cpp/container/navbar}}

The Containers library is a generic collection of class templates and algorithms that allow programmers to easily implement common data structures like queues, lists and stacks.   There are three classes of containers -- sequence containers, associative containers, and unordered associative containers -- each of which is designed to support a different set of operations.

The container manages the storage space that is allocated for its elements and provides member functions to access them, either directly or through iterators (objects with similar properties to pointers).

Most containers have at least several member functions in common, and share functionalities. Which container is the best for the particular application depends not only on the offered functionality, but also on its efficiency for different workloads.

===Sequence containers===
Sequence containers implement data structures which can be accessed sequentially.

{{dsc begin}}
{{dsc inc | cpp/container/dsc array}}
&lt;!-- {{dsc inc | cpp/container/dsc dynarray}} todo: perhaps keep hidden until 2017?--&gt; 
{{dsc inc | cpp/container/dsc vector}}
{{dsc inc | cpp/container/dsc deque}}
{{dsc inc | cpp/container/dsc forward_list}}
{{dsc inc | cpp/container/dsc list}}
{{dsc end}}

===Associative containers===
Associative containers implement sorted data structures that can be quickly searched ({{math|O(log n)}} complexity).

{{dsc begin}}
{{dsc inc | cpp/container/dsc set}}
{{dsc inc | cpp/container/dsc map}}
{{dsc inc | cpp/container/dsc multiset}}
{{dsc inc | cpp/container/dsc multimap}}
{{dsc end}}

===Unordered associative containers===
Unordered associative containers implement unsorted (hashed) data structures that can be quickly searched ({{math|O(1)}} amortized, {{math|O(n)}} worst-case complexity).

{{dsc begin}}
{{dsc inc | cpp/container/dsc unordered_set}}
{{dsc inc | cpp/container/dsc unordered_map}}
{{dsc inc | cpp/container/dsc unordered_multiset}}
{{dsc inc | cpp/container/dsc unordered_multimap}}
{{dsc end}}

===Container adaptors===
Container adaptors provide a different interface for sequential containers.

{{dsc begin}}
{{dsc inc | cpp/container/dsc stack}}
{{dsc inc | cpp/container/dsc queue}}
{{dsc inc | cpp/container/dsc priority_queue}}
{{dsc end}}

===Iterator invalidation===

{{todo}}

{{rev begin}}
{{rev|since=c++11|
===Thread safety===
# All container functions can be called concurrently by different threads on different containers. More generally, the C++ standard library functions do not read objects accessible by other threads unless those objects are directly or indirectly accessible via the function arguments, including the this pointer.
# All {{lc|const}} member functions can be called concurrently by different threads on the same container. In addition, the member functions {{tt|begin()}}, {{tt|end()}}, {{tt|rbegin()}}, {{tt|rend()}}, {{tt|front()}}, {{tt|back()}}, {{tt|data()}}, {{tt|find()}}, {{tt|lower_bound()}}, {{tt|upper_bound()}}, {{tt|equal_range()}}, {{tt|at()}}, and, except in associative containers, {{tt|operator[]}}, behave as {{lc|const}} for the purposes of thread safety (that is, they can also be called concurrently by different threads on the same container). More generally, the C++ standard library functions do not modify objects unless those objects are accessible, directly or indirectly, via the function's non-const arguments, including the this pointer.
# Different elements in the same container can be modified concurrently by different threads, except for the elements of {{lc|std::vector&lt;bool&gt;}} (for example, a vector of {{lc|std::future}} objects can be receiving values from multiple threads).
# Iterator operations (e.g. incrementing an iterator) read, but do not modify the underlying container, and may be executed concurrently with operations on other iterators on the same container, with the const member functions, or reads from the elements. Container operations that invalidate any iterators modify the container and cannot be executed concurrently with any operations on existing iterators even if those iterators are not invalidated.
# Elements of the same container can be modified concurrently with those member functions that are not specified to access these elements. More generally, the C++ standard library functions do not read objects indirectly accessible through their arguments (including other elements of a container) except when required by its specification.
# In any case, container operations (as well as algorithms, or any other C++ standard library functions) may be parallelized internally as long as this does not change the user-visible results (e.g. {{lc|std::transform}} may be parallelized, but not {{lc|std::for_each}} which is specified to visit each element of a sequence in order)
}}
{{rev end}}

===Member function table===

{|
|-
| style=&quot;width:4em; background:#bcbcff;&quot; | 
| - functions present in C++03
|-
| style=&quot;width:4em; background:#bcffbc;&quot; | 
| - functions present since C++11
|}

{| class=&quot;wikitable&quot; style=&quot;font-size:0.8em; line-height:1em; text-align: center;&quot;
|- 
| colspan=&quot;2&quot; |
! colspan=&quot;5&quot; | Sequence containers  
! colspan=&quot;4&quot; | Associative containers 
! colspan=&quot;4&quot; | Unordered associative containers 
! colspan=&quot;3&quot; | Container adaptors
|-
! colspan=&quot;2&quot; | Header 
! {{tt|{{header|array}}}} 
! {{tt|{{header|vector}}}} 
! {{tt|{{header|deque}}}} 
! {{tt|{{header|forward_list}}}} 
! {{tt|{{header|list}}}} 
! colspan=&quot;2&quot; | {{tt|{{header|set}}}} 
! colspan=&quot;2&quot; | {{tt|{{header|map}}}} 
! colspan=&quot;2&quot; | {{tt|{{header|unordered_set}}}} 
! colspan=&quot;2&quot; | {{tt|{{header|unordered_map}}}} 
! {{tt|{{header|stack}}}} 
! colspan=&quot;2&quot; | {{tt|{{header|queue}}}}
|-
! colspan=&quot;2&quot; | Container
! {{cpp/container/table cell hn | /array }}
! {{cpp/container/table cell ho | /vector }}
! {{cpp/container/table cell ho | /deque }}
! {{cpp/container/table cell hn | /forward_list }}
! {{cpp/container/table cell ho | /list }}
! {{cpp/container/table cell ho | /set }}
! {{cpp/container/table cell ho | /multiset }}
! {{cpp/container/table cell ho | /map }}
! {{cpp/container/table cell ho | /multimap }}
! {{cpp/container/table cell hn | /unordered_set }}
! {{cpp/container/table cell hn | /unordered_multiset }}
! {{cpp/container/table cell hn | /unordered_map }}
! {{cpp/container/table cell hn | /unordered_multimap }}
! {{cpp/container/table cell ho | /stack }}
! {{cpp/container/table cell ho | /queue }}
! {{cpp/container/table cell ho | /priority_queue }}
|-
! rowspan=&quot;4&quot; |
| {{cpp/container/table cell lo | (constructor)}}
| {{cpp/container/table cell |(implicit)}}
| {{cpp/container/table cell o | /vector/vector }}
| {{cpp/container/table cell o | /deque/deque }}
| {{cpp/container/table cell n | /forward_list/forward_list }}
| {{cpp/container/table cell o | /list/list }}
| {{cpp/container/table cell o | /set/set }}
| {{cpp/container/table cell o | /multiset/multiset }}
| {{cpp/container/table cell o | /map/map }}
| {{cpp/container/table cell o | /multimap/multimap }}
| {{cpp/container/table cell n | /unordered_set/unordered_set }}
| {{cpp/container/table cell n | /unordered_multiset/unordered_multiset }}
| {{cpp/container/table cell n | /unordered_map/unordered_map }}
| {{cpp/container/table cell n | /unordered_multimap/unordered_multimap }}
| {{cpp/container/table cell o | /stack/stack }}
| {{cpp/container/table cell o | /queue/queue }}
| {{cpp/container/table cell o | /priority_queue/priority_queue }}
|-
&lt;!-- ---&gt;
| {{cpp/container/table cell lo | (destructor)}}
| {{cpp/container/table cell |(implicit)}}
| {{cpp/container/table cell o | /vector/~vector }}
| {{cpp/container/table cell o | /deque/~deque }}
| {{cpp/container/table cell n | /forward_list/~forward_list }}
| {{cpp/container/table cell o | /list/~list }}
| {{cpp/container/table cell o | /set/~set }}
| {{cpp/container/table cell o | /multiset/~multiset }}
| {{cpp/container/table cell o | /map/~map }}
| {{cpp/container/table cell o | /multimap/~multimap }}
| {{cpp/container/table cell n | /unordered_set/~unordered_set }}
| {{cpp/container/table cell n | /unordered_multiset/~unordered_multiset }}
| {{cpp/container/table cell n | /unordered_map/~unordered_map }}
| {{cpp/container/table cell n | /unordered_multimap/~unordered_multimap }}
| {{cpp/container/table cell o | /stack/~stack }}
| {{cpp/container/table cell o | /queue/~queue }}
| {{cpp/container/table cell o | /priority_queue/~priority_queue }}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | operator{{=}}}}
| {{cpp/container/table cell |(implicit)}}
| {{cpp/container/table cell o | /vector/operator{{=}} }}
| {{cpp/container/table cell o | /deque/operator{{=}} }}
| {{cpp/container/table cell n | /forward_list/operator{{=}} }}
| {{cpp/container/table cell o | /list/operator{{=}} }}
| {{cpp/container/table cell o | /set/operator{{=}} }}
| {{cpp/container/table cell o | /multiset/operator{{=}} }}
| {{cpp/container/table cell o | /map/operator{{=}} }}
| {{cpp/container/table cell o | /multimap/operator{{=}} }}
| {{cpp/container/table cell n | /unordered_set/operator{{=}} }}
| {{cpp/container/table cell n | /unordered_multiset/operator{{=}} }}
| {{cpp/container/table cell n | /unordered_map/operator{{=}} }}
| {{cpp/container/table cell n | /unordered_multimap/operator{{=}} }}
| {{cpp/container/table cell o | /stack/operator{{=}} }}
| {{cpp/container/table cell o | /queue/operator{{=}} }}
| {{cpp/container/table cell o | /priority_queue/operator{{=}} }}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | assign}}
| {{n/a||}}
| {{cpp/container/table cell o | /vector/assign }}
| {{cpp/container/table cell o | /deque/assign }}
| {{cpp/container/table cell n | /forward_list/assign }}
| {{cpp/container/table cell o | /list/assign }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! rowspan=&quot;4&quot; | Iterators
| {{cpp/container/table cell lon | begin|cbegin}}
| {{cpp/container/table cell nn | /array/begin |begin|cbegin}}
| {{cpp/container/table cell on | /vector/begin |begin|cbegin}}
| {{cpp/container/table cell on | /deque/begin |begin|cbegin}}
| {{cpp/container/table cell nn | /forward_list/begin |begin|cbegin}}
| {{cpp/container/table cell on | /list/begin |begin|cbegin}}
| {{cpp/container/table cell on | /set/begin |begin|cbegin}}
| {{cpp/container/table cell on | /multiset/begin |begin|cbegin}}
| {{cpp/container/table cell on | /map/begin |begin|cbegin}}
| {{cpp/container/table cell on | /multimap/begin |begin|cbegin}}
| {{cpp/container/table cell nn | /unordered_set/begin |begin|cbegin}}
| {{cpp/container/table cell nn | /unordered_multiset/begin |begin|cbegin}}
| {{cpp/container/table cell nn | /unordered_map/begin |begin|cbegin}}
| {{cpp/container/table cell nn | /unordered_multimap/begin |begin|cbegin}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lon | end|cend}}
| {{cpp/container/table cell nn | /array/end |end|cend}}
| {{cpp/container/table cell on | /vector/end |end|cend}}
| {{cpp/container/table cell on | /deque/end |end|cend}}
| {{cpp/container/table cell nn | /forward_list/end |end|cend}}
| {{cpp/container/table cell on | /list/end |end|cend}}
| {{cpp/container/table cell on | /set/end |end|cend}}
| {{cpp/container/table cell on | /multiset/end |end|cend}}
| {{cpp/container/table cell on | /map/end |end|cend}}
| {{cpp/container/table cell on | /multimap/end |end|cend}}
| {{cpp/container/table cell nn | /unordered_set/end |end|cend}}
| {{cpp/container/table cell nn | /unordered_multiset/end |end|cend}}
| {{cpp/container/table cell nn | /unordered_map/end |end|cend}}
| {{cpp/container/table cell nn | /unordered_multimap/end |end|cend}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lon | rbegin|crbegin}}
| {{cpp/container/table cell nn | /array/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /vector/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /deque/rbegin |rbegin|crbegin}}
| {{n/a|}}
| {{cpp/container/table cell on | /list/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /set/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /multiset/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /map/rbegin |rbegin|crbegin}}
| {{cpp/container/table cell on | /multimap/rbegin |rbegin|crbegin}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lon | rend|crend}}
| {{cpp/container/table cell nn | /array/rend |rend|crend}}
| {{cpp/container/table cell on | /vector/rend |rend|crend}}
| {{cpp/container/table cell on | /deque/rend |rend|crend}}
| {{n/a|}}
| {{cpp/container/table cell on | /list/rend |rend|crend}}
| {{cpp/container/table cell on | /set/rend |rend|crend}}
| {{cpp/container/table cell on | /multiset/rend |rend|crend}}
| {{cpp/container/table cell on | /map/rend |rend|crend}}
| {{cpp/container/table cell on | /multimap/rend |rend|crend}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! rowspan=&quot;4&quot; | Element &lt;br&gt; access
| {{cpp/container/table cell lo | at}}
| {{cpp/container/table cell n | /array/at }}
| {{cpp/container/table cell o | /vector/at }}
| {{cpp/container/table cell o | /deque/at }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /map/at }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /unordered_map/at }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | operator[]}}
| {{cpp/container/table cell n | /array/operator_at |operator[]}}
| {{cpp/container/table cell o | /vector/operator_at |operator[]}}
| {{cpp/container/table cell o | /deque/operator_at |operator[]}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /map/operator_at |operator[]}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /unordered_map/operator_at |operator[]}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | front}}
| {{cpp/container/table cell n | /array/front }}
| {{cpp/container/table cell o | /vector/front }}
| {{cpp/container/table cell o | /deque/front }}
| {{cpp/container/table cell n | /forward_list/front }}
| {{cpp/container/table cell o | /list/front }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /queue/front }}
| {{cpp/container/table cell o | /priority_queue/top | top }}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | back}}
| {{cpp/container/table cell n | /array/back }}
| {{cpp/container/table cell o | /vector/back }}
| {{cpp/container/table cell o | /deque/back }}
| {{n/a|}}
| {{cpp/container/table cell o | /list/back }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /stack/top | top}}
| {{cpp/container/table cell o | /queue/back }}
| {{n/a|}}
|-
! rowspan=&quot;7&quot; | Capacity
| {{cpp/container/table cell lo | empty}}
| {{cpp/container/table cell n | /array/empty }}
| {{cpp/container/table cell o | /vector/empty }}
| {{cpp/container/table cell o | /deque/empty }}
| {{cpp/container/table cell n | /forward_list/empty }}
| {{cpp/container/table cell o | /list/empty }}
| {{cpp/container/table cell o | /set/empty }}
| {{cpp/container/table cell o | /multiset/empty }}
| {{cpp/container/table cell o | /map/empty }}
| {{cpp/container/table cell o | /multimap/empty }}
| {{cpp/container/table cell n | /unordered_set/empty }}
| {{cpp/container/table cell n | /unordered_multiset/empty }}
| {{cpp/container/table cell n | /unordered_map/empty }}
| {{cpp/container/table cell n | /unordered_multimap/empty }}
| {{cpp/container/table cell o | /stack/empty }}
| {{cpp/container/table cell o | /queue/empty }}
| {{cpp/container/table cell o | /priority_queue/empty }}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | size}}
| {{cpp/container/table cell n | /array/size }}
| {{cpp/container/table cell o | /vector/size }}
| {{cpp/container/table cell o | /deque/size }}
| {{n/a|}}
| {{cpp/container/table cell o | /list/size }}
| {{cpp/container/table cell o | /set/size }}
| {{cpp/container/table cell o | /multiset/size }}
| {{cpp/container/table cell o | /map/size }}
| {{cpp/container/table cell o | /multimap/size }}
| {{cpp/container/table cell n | /unordered_set/size }}
| {{cpp/container/table cell n | /unordered_multiset/size }}
| {{cpp/container/table cell n | /unordered_map/size }}
| {{cpp/container/table cell n | /unordered_multimap/size }}
| {{cpp/container/table cell o | /stack/size }}
| {{cpp/container/table cell o | /queue/size }}
| {{cpp/container/table cell o | /priority_queue/size }}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | max_size}}
| {{cpp/container/table cell n | /array/max_size }}
| {{cpp/container/table cell o | /vector/max_size }}
| {{cpp/container/table cell o | /deque/max_size }}
| {{cpp/container/table cell n | /forward_list/max_size }}
| {{cpp/container/table cell o | /list/max_size }}
| {{cpp/container/table cell o | /set/max_size }}
| {{cpp/container/table cell o | /multiset/max_size }}
| {{cpp/container/table cell o | /map/max_size }}
| {{cpp/container/table cell o | /multimap/max_size }}
| {{cpp/container/table cell n | /unordered_set/max_size }}
| {{cpp/container/table cell n | /unordered_multiset/max_size }}
| {{cpp/container/table cell n | /unordered_map/max_size }}
| {{cpp/container/table cell n | /unordered_multimap/max_size }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | resize}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/resize }}
| {{cpp/container/table cell o | /deque/resize }}
| {{cpp/container/table cell n | /forward_list/resize }}
| {{cpp/container/table cell o | /list/resize }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | capacity}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/capacity }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | reserve}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/reserve}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /unordered_set/reserve }}
| {{cpp/container/table cell n | /unordered_multiset/reserve }}
| {{cpp/container/table cell n | /unordered_map/reserve }}
| {{cpp/container/table cell n | /unordered_multimap/reserve }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | shrink_to_fit}}
| {{n/a|}}
| {{cpp/container/table cell n | /vector/shrink_to_fit}}
| {{cpp/container/table cell n | /deque/shrink_to_fit}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! rowspan=&quot;12&quot; | Modifiers
| {{cpp/container/table cell lo | clear}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/clear }}
| {{cpp/container/table cell o | /deque/clear }}
| {{cpp/container/table cell n | /forward_list/clear }}
| {{cpp/container/table cell o | /list/clear }}
| {{cpp/container/table cell o | /set/clear }}
| {{cpp/container/table cell o | /multiset/clear }}
| {{cpp/container/table cell o | /map/clear }}
| {{cpp/container/table cell o | /multimap/clear }}
| {{cpp/container/table cell n | /unordered_set/clear }}
| {{cpp/container/table cell n | /unordered_multiset/clear }}
| {{cpp/container/table cell n | /unordered_map/clear }}
| {{cpp/container/table cell n | /unordered_multimap/clear }}
| {{n/a|}}  
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | insert}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/insert }}
| {{cpp/container/table cell o | /deque/insert }}
| {{cpp/container/table cell n | /forward_list/insert_after | insert_after}}
| {{cpp/container/table cell o | /list/insert }}
| {{cpp/container/table cell o | /set/insert }}
| {{cpp/container/table cell o | /multiset/insert }}
| {{cpp/container/table cell o | /map/insert }}
| {{cpp/container/table cell o | /multimap/insert }}
| {{cpp/container/table cell n | /unordered_set/insert }}
| {{cpp/container/table cell n | /unordered_multiset/insert }}
| {{cpp/container/table cell n | /unordered_map/insert }}
| {{cpp/container/table cell n | /unordered_multimap/insert }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | emplace}}
| {{n/a|}}
| {{cpp/container/table cell n | /vector/emplace }}
| {{cpp/container/table cell n | /deque/emplace }}
| {{cpp/container/table cell n | /forward_list/emplace_after | emplace_after}}
| {{cpp/container/table cell n | /list/emplace }}
| {{cpp/container/table cell n | /set/emplace }}
| {{cpp/container/table cell n | /multiset/emplace }}
| {{cpp/container/table cell n | /map/emplace }}
| {{cpp/container/table cell n | /multimap/emplace }}
| {{cpp/container/table cell n | /unordered_set/emplace }}
| {{cpp/container/table cell n | /unordered_multiset/emplace }}
| {{cpp/container/table cell n | /unordered_map/emplace }}
| {{cpp/container/table cell n | /unordered_multimap/emplace }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | emplace_hint}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /set/emplace_hint }}
| {{cpp/container/table cell n | /multiset/emplace_hint }}
| {{cpp/container/table cell n | /map/emplace_hint }}
| {{cpp/container/table cell n | /multimap/emplace_hint }}
| {{cpp/container/table cell n | /unordered_set/emplace_hint }}
| {{cpp/container/table cell n | /unordered_multiset/emplace_hint }}
| {{cpp/container/table cell n | /unordered_map/emplace_hint }}
| {{cpp/container/table cell n | /unordered_multimap/emplace_hint }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | erase}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/erase }}
| {{cpp/container/table cell o | /deque/erase }}
| {{cpp/container/table cell n | /forward_list/erase_after | erase_after}}
| {{cpp/container/table cell o | /list/erase }}
| {{cpp/container/table cell o | /set/erase }}
| {{cpp/container/table cell o | /multiset/erase }}
| {{cpp/container/table cell o | /map/erase }}
| {{cpp/container/table cell o | /multimap/erase }}
| {{cpp/container/table cell n | /unordered_set/erase }}
| {{cpp/container/table cell n | /unordered_multiset/erase }}
| {{cpp/container/table cell n | /unordered_map/erase }}
| {{cpp/container/table cell n | /unordered_multimap/erase }}
| {{n/a|}} 
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | push_front}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /deque/push_front }}
| {{cpp/container/table cell n | /forward_list/push_front }}
| {{cpp/container/table cell o | /list/push_front }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}} 
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | emplace_front}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /deque/emplace_front }}
| {{cpp/container/table cell n | /forward_list/emplace_front }}
| {{cpp/container/table cell n | /list/emplace_front }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}} 
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | pop_front}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /deque/pop_front }}
| {{cpp/container/table cell n | /forward_list/pop_front }}
| {{cpp/container/table cell o | /list/pop_front }} 
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}} 
| {{cpp/container/table cell o | /queue/pop }}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | push_back}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/push_back }}
| {{cpp/container/table cell o | /deque/push_back }}
| {{n/a|}}
| {{cpp/container/table cell o | /list/push_back }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /stack/push}}
| {{cpp/container/table cell o | /queue/push}}
| {{cpp/container/table cell o | /priority_queue/push}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | emplace_back}}
| {{n/a|}}
| {{cpp/container/table cell n | /vector/emplace_back }}
| {{cpp/container/table cell n | /deque/emplace_back }}
| {{n/a|}}
| {{cpp/container/table cell n | /list/emplace_back }} 
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /stack/emplace}}
| {{cpp/container/table cell n | /queue/emplace}}
| {{cpp/container/table cell n | /priority_queue/emplace}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | pop_back}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/pop_back }}
| {{cpp/container/table cell o | /deque/pop_back }}
| {{n/a|}}
| {{cpp/container/table cell o | /list/pop_back }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /stack/pop}}
| {{n/a|}}
| {{cpp/container/table cell o | /priority_queue/pop}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | swap}}
| {{cpp/container/table cell n | /array/swap }}
| {{cpp/container/table cell o | /vector/swap }}
| {{cpp/container/table cell o | /deque/swap }}
| {{cpp/container/table cell n | /forward_list/swap }}
| {{cpp/container/table cell o | /list/swap }}
| {{cpp/container/table cell o | /set/swap }}
| {{cpp/container/table cell o | /multiset/swap }}
| {{cpp/container/table cell o | /map/swap }}
| {{cpp/container/table cell o | /multimap/swap }}
| {{cpp/container/table cell n | /unordered_set/swap }}
| {{cpp/container/table cell n | /unordered_multiset/swap }}
| {{cpp/container/table cell n | /unordered_map/swap }}
| {{cpp/container/table cell n | /unordered_multimap/swap }}
| {{cpp/container/table cell n | /stack/swap }}
| {{cpp/container/table cell n | /queue/swap }}
| {{cpp/container/table cell n | /priority_queue/swap }}
|-
! rowspan=&quot;7&quot; | List operations
| {{cpp/container/table cell lo | merge }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/merge }}
| {{cpp/container/table cell o | /list/merge }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | splice }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/splice_after | splice_after }}
| {{cpp/container/table cell o | /list/splice }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | remove }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/remove }}
| {{cpp/container/table cell o | /list/remove }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | remove_if }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/remove | remove_if }}
| {{cpp/container/table cell o | /list/remove | remove_if }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | reverse }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/reverse }}
| {{cpp/container/table cell o | /list/reverse }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | unique }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/unique }}
| {{cpp/container/table cell o | /list/unique }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | sort }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /forward_list/sort }}
| {{cpp/container/table cell o | /list/sort }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! rowspan=&quot;5&quot; | Lookup
| {{cpp/container/table cell lo | count}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/count }}
| {{cpp/container/table cell o | /multiset/count }}
| {{cpp/container/table cell o | /map/count }}
| {{cpp/container/table cell o | /multimap/count }}
| {{cpp/container/table cell n | /unordered_set/count }}
| {{cpp/container/table cell n | /unordered_multiset/count }}
| {{cpp/container/table cell n | /unordered_map/count }}
| {{cpp/container/table cell n | /unordered_multimap/count }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | find}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/find }}
| {{cpp/container/table cell o | /multiset/find }}
| {{cpp/container/table cell o | /map/find }}
| {{cpp/container/table cell o | /multimap/find }}
| {{cpp/container/table cell n | /unordered_set/find }}
| {{cpp/container/table cell n | /unordered_multiset/find }}
| {{cpp/container/table cell n | /unordered_map/find }}
| {{cpp/container/table cell n | /unordered_multimap/find }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | lower_bound}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/lower_bound }}
| {{cpp/container/table cell o | /multiset/lower_bound }}
| {{cpp/container/table cell o | /map/lower_bound }}
| {{cpp/container/table cell o | /multimap/lower_bound }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | upper_bound}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/upper_bound }}
| {{cpp/container/table cell o | /multiset/upper_bound }}
| {{cpp/container/table cell o | /map/upper_bound }}
| {{cpp/container/table cell o | /multimap/upper_bound }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | equal_range}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/equal_range }}
| {{cpp/container/table cell o | /multiset/equal_range }}
| {{cpp/container/table cell o | /map/equal_range }}
| {{cpp/container/table cell o | /multimap/equal_range }}
| {{cpp/container/table cell n | /unordered_set/equal_range }}
| {{cpp/container/table cell n | /unordered_multiset/equal_range }}
| {{cpp/container/table cell n | /unordered_map/equal_range }}
| {{cpp/container/table cell n | /unordered_multimap/equal_range }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! rowspan=&quot;4&quot; | Observers
| {{cpp/container/table cell lo | key_comp}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/key_comp }}
| {{cpp/container/table cell o | /multiset/key_comp }}
| {{cpp/container/table cell o | /map/key_comp }}
| {{cpp/container/table cell o | /multimap/key_comp }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell lo | value_comp}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell o | /set/value_comp }}
| {{cpp/container/table cell o | /multiset/value_comp }}
| {{cpp/container/table cell o | /map/value_comp }}
| {{cpp/container/table cell o | /multimap/value_comp }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | hash_function}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /unordered_set/hash_function }}
| {{cpp/container/table cell n | /unordered_multiset/hash_function }}
| {{cpp/container/table cell n | /unordered_map/hash_function }}
| {{cpp/container/table cell n | /unordered_multimap/hash_function }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
&lt;!-- --&gt;
| {{cpp/container/table cell ln | key_eq}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
| {{cpp/container/table cell n | /unordered_set/key_eq }}
| {{cpp/container/table cell n | /unordered_multiset/key_eq }}
| {{cpp/container/table cell n | /unordered_map/key_eq }}
| {{cpp/container/table cell n | /unordered_multimap/key_eq }}
| {{n/a|}}
| {{n/a|}}
| {{n/a|}}
|-
! Allocator
| {{cpp/container/table cell lo | get_allocator}}
| {{n/a|}}
| {{cpp/container/table cell o | /vector/get_allocator }}
| {{cpp/container/table cell o | /deque/get_allocator }}
| {{cpp/container/table cell n | /forward_list/get_allocator }}
| {{cpp/container/table cell o | /list/get_allocator }}
| {{cpp/container/table cell o | /set/get_allocator }}
| {{cpp/container/table cell o | /multiset/get_allocator }}
| {{cpp/container/table cell o | /map/get_allocator }}
| {{cpp/container/table cell o | /multimap/get_allocator }}
| {{cpp/container/table cell n | /unordered_set/get_allocator }}
| {{cpp/container/table cell n | /unordered_multiset/get_allocator }}
| {{cpp/container/table cell n | /unordered_map/get_allocator }}
| {{cpp/container/table cell n | /unordered_multimap/get_allocator }}
| {{n/a|}}  
| {{n/a|}}
| {{n/a|}}
|-
! colspan=&quot;2&quot; | Container
! {{cpp/container/table cell hn | /array }}
! {{cpp/container/table cell ho | /vector }}
! {{cpp/container/table cell ho | /deque }}
! {{cpp/container/table cell hn | /forward_list }}
! {{cpp/container/table cell ho | /list }}
! {{cpp/container/table cell ho | /set }}
! {{cpp/container/table cell ho | /multiset }}
! {{cpp/container/table cell ho | /map }}
! {{cpp/container/table cell ho | /multimap }}
! {{cpp/container/table cell hn | /unordered_set }}
! {{cpp/container/table cell hn | /unordered_multiset }}
! {{cpp/container/table cell hn | /unordered_map }}
! {{cpp/container/table cell hn | /unordered_multimap }}
! {{cpp/container/table cell ho | /stack }}
! {{cpp/container/table cell ho | /queue }}
! {{cpp/container/table cell ho | /priority_queue }}
|- 
| colspan=&quot;2&quot; |
! colspan=&quot;5&quot; | Sequence containers  
! colspan=&quot;4&quot; | Associative containers 
! colspan=&quot;4&quot; | Unordered associative containers 
! colspan=&quot;3&quot; | Container adaptors
|}

(A PDF version of this table is available at [[File:container-library-overview-2012-12-27.pdf]].)

[[ar:cpp/container]]
[[de:cpp/container]]
[[es:cpp/container]]
[[fr:cpp/container]]
[[it:cpp/container]]
[[ja:cpp/container]]
[[pl:cpp/container]]
[[pt:cpp/container]]
[[ru:cpp/container]]
[[tr:cpp/container]]
[[zh:cpp/container]]</text>
      <sha1>muzn2vbr8e47n947sqjud5xfe3ddgay</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container//value compare</title>
    <ns>0</ns>
    <id>9937</id>
    <revision>
      <id>47101</id>
      <timestamp>2013-04-23T16:55:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>dummy</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array</title>
    <ns>0</ns>
    <id>850</id>
    <revision>
      <id>72475</id>
      <parentid>72418</parentid>
      <timestamp>2014-08-25T11:43:38Z</timestamp>
      <contributor>
        <ip>84.52.101.196</ip>
      </contributor>
      <comment>better wording (?)</comment>
      <text xml:space="preserve" bytes="4654">{{cpp/title|array}}
{{cpp/container/array/navbar}}
{{ddcl | header=array | since=c++11 |
template&lt; 
    class T, 
    std::size_t N 
&gt; struct array;
}}

{{tt|std::array}} is a container that encapsulates fixed size arrays.  

This container is an aggregate type with the same semantics as a struct holding a C-style array {{c|T[N]}} as its only non-static data member. It can be initialized with [[cpp/language/aggregate_initialization|aggregate-initialization]], given at most {{tt|N}} initializers that are convertible to {{tt|T}}: {{c|1=std::array&lt;int, 3&gt; a = {1,2,3};}}

The struct combines the performance and accessibility of a C-style array with the benefits of a standard container, such as knowing its own size, supporting assignment, random access iterators, etc.

There is a special case for a zero-length array (&lt;code&gt;N == 0&lt;/code&gt;). In that case, {{c|
1=array.begin() == array.end()}}, which is some unique value.  The effect of calling {{c|front()}} or {{c|back()}} on a zero-sized array is undefined.

An array can also be used as a tuple of {{tt|N}} elements of the same type.

===Iterator invalidation===
As a rule, iterators to an array are never invalidated throughout the lifetime of the array. One should take note, however, that during [[cpp/container/array/swap|swap]], the iterator will continue to point to the same array element, and will thus change its value.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | array}}
{{dsc inc | cpp/container/dsc size_type | array}}
{{dsc inc | cpp/container/dsc difference_type | array}}
{{dsc inc | cpp/container/dsc reference | array}}
{{dsc inc | cpp/container/dsc const_reference | array}}
{{dsc inc | cpp/container/dsc pointer | array}}
{{dsc inc | cpp/container/dsc const_pointer | array}}
{{dsc inc | cpp/container/dsc iterator | array}}
{{dsc inc | cpp/container/dsc const_iterator | array}}
{{dsc inc | cpp/container/dsc reverse_iterator | array}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | array}}
{{dsc end}}

===Member functions===
{{dsc begin}}

{{dsc h2 | Implicitly-defined member functions}}
{{dsc mem ctor | nolink=true | notes={{mark implicit}} | [[cpp/language/default_initialization|default-initializes]] or [[cpp/language/copy_initialization|copy-initializes]] every element of the array}}
{{dsc mem dtor | nolink=true | notes={{mark implicit}} | destroys every element of the array}}
{{dsc mem fun | operator{{=}} | nolink=true | notes={{mark implicit}} | overwrites every element of the array with the corresponding element of another array}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | array}}
{{dsc inc | cpp/container/dsc operator_at | array}}
{{dsc inc | cpp/container/dsc front | array}}
{{dsc inc | cpp/container/dsc back | array}}
{{dsc inc | cpp/container/dsc data | array}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | array}}
{{dsc inc | cpp/container/dsc end | array}}
{{dsc inc | cpp/container/dsc rbegin | array}}
{{dsc inc | cpp/container/dsc rend | array}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | array}}
{{dsc inc | cpp/container/dsc size | array}}
{{dsc inc | cpp/container/dsc max_size | array}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/container/dsc fill | array}}
{{dsc inc | cpp/container/dsc swap | array}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | array}}
{{dsc inc | cpp/container/array/dsc get}}
{{dsc inc | cpp/container/dsc swap2 | array}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/array/dsc tuple_size}}
{{dsc inc | cpp/container/array/dsc tuple_element}}
{{dsc end}}

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;array&gt;

int main()
{
    // construction uses aggregate initialization
    std::array&lt;int, 3&gt; a1{ {1,2,3} };  // double-braces required
    std::array&lt;int, 3&gt; a2 = {1, 2, 3}; // except after =
    std::array&lt;std::string, 2&gt; a3 = { {std::string(&quot;a&quot;), &quot;b&quot;} };

    // container operations are supported
    std::sort(a1.begin(), a1.end());
    std::reverse_copy(a2.begin(), a2.end(), 
                      std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));

    std::cout &lt;&lt; '\n';
    
    // ranged for loop is supported
    for(const auto&amp; s: a3)
        std::cout &lt;&lt; s &lt;&lt; ' ';
}
 | output=
3 2 1 
a b 
}}

[[de:cpp/container/array]]
[[es:cpp/container/array]]
[[fr:cpp/container/array]]
[[it:cpp/container/array]]
[[ja:cpp/container/array]]
[[pt:cpp/container/array]]
[[ru:cpp/container/array]]
[[zh:cpp/container/array]]</text>
      <sha1>2tbbc3mxb783h1ubmxjskcjz2e4vr1e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/at</title>
    <ns>0</ns>
    <id>851</id>
    <revision>
      <id>50432</id>
      <parentid>44212</parentid>
      <timestamp>2013-06-01T03:28:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/at|array}}

[[de:cpp/container/array/at]]
[[es:cpp/container/array/at]]
[[fr:cpp/container/array/at]]
[[it:cpp/container/array/at]]
[[ja:cpp/container/array/at]]
[[pt:cpp/container/array/at]]
[[ru:cpp/container/array/at]]
[[zh:cpp/container/array/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/back</title>
    <ns>0</ns>
    <id>852</id>
    <revision>
      <id>50433</id>
      <parentid>44207</parentid>
      <timestamp>2013-06-01T03:28:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/back|array}}

[[de:cpp/container/array/back]]
[[es:cpp/container/array/back]]
[[fr:cpp/container/array/back]]
[[it:cpp/container/array/back]]
[[ja:cpp/container/array/back]]
[[pt:cpp/container/array/back]]
[[ru:cpp/container/array/back]]
[[zh:cpp/container/array/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/begin</title>
    <ns>0</ns>
    <id>853</id>
    <revision>
      <id>50434</id>
      <parentid>44202</parentid>
      <timestamp>2013-06-01T03:28:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/begin|array}}

[[de:cpp/container/array/begin]]
[[es:cpp/container/array/begin]]
[[fr:cpp/container/array/begin]]
[[it:cpp/container/array/begin]]
[[ja:cpp/container/array/begin]]
[[pt:cpp/container/array/begin]]
[[ru:cpp/container/array/begin]]
[[zh:cpp/container/array/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/data</title>
    <ns>0</ns>
    <id>854</id>
    <revision>
      <id>50435</id>
      <parentid>44197</parentid>
      <timestamp>2013-06-01T03:28:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/data|array}}

[[de:cpp/container/array/data]]
[[es:cpp/container/array/data]]
[[fr:cpp/container/array/data]]
[[it:cpp/container/array/data]]
[[ja:cpp/container/array/data]]
[[pt:cpp/container/array/data]]
[[ru:cpp/container/array/data]]
[[zh:cpp/container/array/data]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/empty</title>
    <ns>0</ns>
    <id>855</id>
    <revision>
      <id>50436</id>
      <parentid>44190</parentid>
      <timestamp>2013-06-01T03:28:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/empty|array}}

[[de:cpp/container/array/empty]]
[[es:cpp/container/array/empty]]
[[fr:cpp/container/array/empty]]
[[it:cpp/container/array/empty]]
[[ja:cpp/container/array/empty]]
[[pt:cpp/container/array/empty]]
[[ru:cpp/container/array/empty]]
[[zh:cpp/container/array/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/end</title>
    <ns>0</ns>
    <id>856</id>
    <revision>
      <id>50437</id>
      <parentid>44186</parentid>
      <timestamp>2013-06-01T03:28:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/end|array}}

[[de:cpp/container/array/end]]
[[es:cpp/container/array/end]]
[[fr:cpp/container/array/end]]
[[it:cpp/container/array/end]]
[[ja:cpp/container/array/end]]
[[pt:cpp/container/array/end]]
[[ru:cpp/container/array/end]]
[[zh:cpp/container/array/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/fill</title>
    <ns>0</ns>
    <id>857</id>
    <revision>
      <id>50438</id>
      <parentid>47745</parentid>
      <timestamp>2013-06-01T03:28:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="301">{{include page | cpp/container/fill | array}}
[[de:cpp/container/array/fill]]
[[es:cpp/container/array/fill]]
[[fr:cpp/container/array/fill]]
[[it:cpp/container/array/fill]]
[[ja:cpp/container/array/fill]]
[[pt:cpp/container/array/fill]]
[[ru:cpp/container/array/fill]]
[[zh:cpp/container/array/fill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/front</title>
    <ns>0</ns>
    <id>858</id>
    <revision>
      <id>50439</id>
      <parentid>44175</parentid>
      <timestamp>2013-06-01T03:28:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/front|array}}

[[de:cpp/container/array/front]]
[[es:cpp/container/array/front]]
[[fr:cpp/container/array/front]]
[[it:cpp/container/array/front]]
[[ja:cpp/container/array/front]]
[[pt:cpp/container/array/front]]
[[ru:cpp/container/array/front]]
[[zh:cpp/container/array/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/get</title>
    <ns>0</ns>
    <id>5105</id>
    <revision>
      <id>64246</id>
      <parentid>62689</parentid>
      <timestamp>2013-08-15T16:01:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1966">{{cpp/title | get&lt;small&gt;(std::array)&lt;/small&gt;}}
{{cpp/container/array/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
template&lt; size_t I, class T, size_t N &gt;
constexpr T&amp; get( array&lt;T,N&gt;&amp; a );
}}
{{dcl | num=2 | since=c++11 |
template&lt; size_t I, class T, size_t N &gt;
constexpr T&amp;&amp; get( array&lt;T,N&gt;&amp;&amp; a );
}}
{{dcl | num=3 | since=c++11 |
template&lt; size_t I, class T, size_t N &gt;
constexpr const T&amp; get( const array&lt;T,N&gt;&amp; a );
}}
{{dcl end}}

Extracts the {{tt|Ith}} element element from the array. 

{{tt|I}} must be an integer value in range {{tt|[0, N)}}. This is enforced at compile time as opposed to {{lc|at()}} or {{lc|operator[]}}.

===Parameters===
{{par begin}}
{{par | a | array whose contents to extract}}
{{par end}}

===Return value===

1) Reference to the {{tt|Ith}} element of {{tt|a}}.

2) Rvalue reference to the {{tt|Ith}} element of {{tt|a}}, unless the element is of lvalue reference type, in which case lvalue reference is returned.

3) Const reference to the {{tt|Ith}} element of {{tt|a}}.

===Exceptions===

{{noexcept}}

===Notes===
The overloads are marked as {{c|constexpr}} since C++14.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;array&gt;

int main()
{
    std::array&lt;int, 3&gt; arr;
    
    // set values:
    std::get&lt;0&gt;(arr) = 1;
    std::get&lt;1&gt;(arr) = 2;
    std::get&lt;2&gt;(arr) = 3;
    
    // get values:
    std::cout &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;0&gt;(arr) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(arr)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;2&gt;(arr) &lt;&lt; &quot;)\n&quot;;
}
 | output=
(1, 2, 3)
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_at|array}}
{{dsc inc | cpp/container/dsc at|array}}	
{{dsc inc | cpp/utility/tuple/dsc get}}
{{dsc inc | cpp/utility/pair/dsc get}}
{{dsc end}}

[[de:cpp/container/array/get]]
[[es:cpp/container/array/get]]
[[fr:cpp/container/array/get]]
[[it:cpp/container/array/get]]
[[ja:cpp/container/array/get]]
[[pt:cpp/container/array/get]]
[[ru:cpp/container/array/get]]
[[zh:cpp/container/array/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/max size</title>
    <ns>0</ns>
    <id>859</id>
    <revision>
      <id>50440</id>
      <parentid>44164</parentid>
      <timestamp>2013-06-01T03:28:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/max_size|array}}

[[de:cpp/container/array/max size]]
[[es:cpp/container/array/max size]]
[[fr:cpp/container/array/max size]]
[[it:cpp/container/array/max size]]
[[ja:cpp/container/array/max size]]
[[pt:cpp/container/array/max size]]
[[ru:cpp/container/array/max size]]
[[zh:cpp/container/array/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/operator at</title>
    <ns>0</ns>
    <id>860</id>
    <revision>
      <id>50441</id>
      <parentid>44159</parentid>
      <timestamp>2013-06-01T03:28:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/operator_at|array}}

[[de:cpp/container/array/operator at]]
[[es:cpp/container/array/operator at]]
[[fr:cpp/container/array/operator at]]
[[it:cpp/container/array/operator at]]
[[ja:cpp/container/array/operator at]]
[[pt:cpp/container/array/operator at]]
[[ru:cpp/container/array/operator at]]
[[zh:cpp/container/array/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/operator cmp</title>
    <ns>0</ns>
    <id>5588</id>
    <revision>
      <id>50442</id>
      <parentid>44153</parentid>
      <timestamp>2013-06-01T03:28:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/container/operator_cmp |array}}

[[de:cpp/container/array/operator cmp]]
[[es:cpp/container/array/operator cmp]]
[[fr:cpp/container/array/operator cmp]]
[[it:cpp/container/array/operator cmp]]
[[ja:cpp/container/array/operator cmp]]
[[pt:cpp/container/array/operator cmp]]
[[ru:cpp/container/array/operator cmp]]
[[zh:cpp/container/array/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/rbegin</title>
    <ns>0</ns>
    <id>861</id>
    <revision>
      <id>50443</id>
      <parentid>44148</parentid>
      <timestamp>2013-06-01T03:28:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/rbegin|array}}

[[de:cpp/container/array/rbegin]]
[[es:cpp/container/array/rbegin]]
[[fr:cpp/container/array/rbegin]]
[[it:cpp/container/array/rbegin]]
[[ja:cpp/container/array/rbegin]]
[[pt:cpp/container/array/rbegin]]
[[ru:cpp/container/array/rbegin]]
[[zh:cpp/container/array/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/rend</title>
    <ns>0</ns>
    <id>862</id>
    <revision>
      <id>50444</id>
      <parentid>44143</parentid>
      <timestamp>2013-06-01T03:28:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/rend|array}}

[[de:cpp/container/array/rend]]
[[es:cpp/container/array/rend]]
[[fr:cpp/container/array/rend]]
[[it:cpp/container/array/rend]]
[[ja:cpp/container/array/rend]]
[[pt:cpp/container/array/rend]]
[[ru:cpp/container/array/rend]]
[[zh:cpp/container/array/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/size</title>
    <ns>0</ns>
    <id>863</id>
    <revision>
      <id>64976</id>
      <parentid>64975</parentid>
      <timestamp>2013-08-28T22:16:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>improve</comment>
      <text xml:space="preserve" bytes="1220">{{cpp/container/array/title | size}}
{{cpp/container/array/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
constexpr size_type size();
}}
{{dcl | since=c++14 |
constexpr size_type size() const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the number of elements in the container, i.e. {{c|std::distance(begin(), end())}}.

===Parameters===
(none)

===Return value===
The number of elements in the container.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===Example===
{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::array}}:
 | code=
#include &lt;array&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::array&lt;int, 4&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc empty |array}}
{{dsc inc | cpp/container/dsc max_size |array}}
{{dsc end}}

[[de:cpp/container/array/size]]
[[es:cpp/container/array/size]]
[[fr:cpp/container/array/size]]
[[it:cpp/container/array/size]]
[[ja:cpp/container/array/size]]
[[pt:cpp/container/array/size]]
[[ru:cpp/container/array/size]]
[[zh:cpp/container/array/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/std swap</title>
    <ns>0</ns>
    <id>3456</id>
    <redirect title="cpp/container/array/swap2" />
    <revision>
      <id>12998</id>
      <timestamp>2011-11-03T18:34:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/array/std swap]] to [[cpp/container/array/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/container/array/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/swap</title>
    <ns>0</ns>
    <id>864</id>
    <revision>
      <id>62124</id>
      <parentid>50446</parentid>
      <timestamp>2013-06-23T00:27:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>make a special case for std::array; this will simplify things</comment>
      <text xml:space="preserve" bytes="951">{{cpp/container/array/title | swap}}
{{cpp/container/array/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( array&amp; other );
}}
{{dcl end}}

Exchanges the contents of the container with those of {{tt|other}}. Does not cause iterators and references to associate with the other container.

===Parameters===
{{par begin}}
{{par | other | container to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept|noexcept(std::swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;()))}} 

For zero-sized arrays, {{noexcept|noexcept(true)}}

===Complexity===
Linear in size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap2 |array}}
{{dsc end}}

[[de:cpp/container/array/swap]]
[[es:cpp/container/array/swap]]
[[fr:cpp/container/array/swap]]
[[it:cpp/container/array/swap]]
[[ja:cpp/container/array/swap]]
[[pt:cpp/container/array/swap]]
[[ru:cpp/container/array/swap]]
[[zh:cpp/container/array/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/swap2</title>
    <ns>0</ns>
    <id>3013</id>
    <revision>
      <id>50447</id>
      <parentid>44125</parentid>
      <timestamp>2013-06-01T03:29:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/swap2|array}}

[[de:cpp/container/array/swap2]]
[[es:cpp/container/array/swap2]]
[[fr:cpp/container/array/swap2]]
[[it:cpp/container/array/swap2]]
[[ja:cpp/container/array/swap2]]
[[pt:cpp/container/array/swap2]]
[[ru:cpp/container/array/swap2]]
[[zh:cpp/container/array/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/tuple element</title>
    <ns>0</ns>
    <id>5589</id>
    <revision>
      <id>72074</id>
      <parentid>62690</parentid>
      <timestamp>2014-07-12T04:34:18Z</timestamp>
      <contributor>
        <ip>182.250.240.82</ip>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1245">{{cpp/title|tuple_element{{small|&lt;std::array&gt;}}}}
{{cpp/container/array/navbar}}
{{dcl begin}}
{{dcl header | array}}
{{dcl | since=c++11 | 1=
template&lt; std::size_t I, class T, std::size_t N &gt;
struct tuple_element&lt;I, array&lt;T, N&gt; &gt;;
}}
{{dcl end}}

Provides compile-time indexed access to the type of the elements of the array using tuple-like interface

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | type | the type of elements of the array}}
{{dsc end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;std::size_t I, typename T&gt;
  struct tuple_element;

template&lt;std::size_t I, typename T, std::size_t N&gt;
  struct tuple_element&lt;I, std::array&lt;T,N&gt; &gt;
  {
     using type = T;
  };
}}

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tuple_element}}
{{dsc inc | cpp/utility/pair/dsc tuple_element}}
{{dsc end}}

[[de:cpp/container/array/tuple element]]
[[es:cpp/container/array/tuple element]]
[[fr:cpp/container/array/tuple element]]
[[it:cpp/container/array/tuple element]]
[[ja:cpp/container/array/tuple element]]
[[pt:cpp/container/array/tuple element]]
[[ru:cpp/container/array/tuple element]]
[[zh:cpp/container/array/tuple element]]</text>
      <sha1>bjcauhtum7ipq1hv4zhioua91hpark0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/array/tuple size</title>
    <ns>0</ns>
    <id>5127</id>
    <revision>
      <id>62691</id>
      <parentid>57262</parentid>
      <timestamp>2013-07-01T23:33:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1187">{{cpp/title | tuple_size&lt;small&gt;(std::array)&lt;/small&gt;}}
{{cpp/container/array/navbar}}
{{dcl begin}}
{{dcl header | array}}
{{dcl | num=1 | since=c++11 |1=
template&lt; class T, size_t N &gt;
class tuple_size&lt; array&lt;T, N&gt; &gt; :
    public integral_constant&lt;size_t, N&gt;
{ };
}}
{{dcl end}}

Provides access to the number of elements in an {{lc|std::array}} as a compile-time constant expression.

{{cpp/types/integral_constant/inherit2 |{{tt|N}}, the number of elements in the array|std::size_t}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;array&gt;

template&lt;class T&gt;
void test(T t)
{
    int a[std::tuple_size&lt;T&gt;::value]; // can be used at compile time
    std::cout &lt;&lt; std::tuple_size&lt;T&gt;::value &lt;&lt; '\n';
}

int main()
{
    std::array&lt;float, 3&gt; arr;
    test(arr);
}
 | output=
3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tuple_size}}
{{dsc end}}

[[de:cpp/container/array/tuple size]]
[[es:cpp/container/array/tuple size]]
[[fr:cpp/container/array/tuple size]]
[[it:cpp/container/array/tuple size]]
[[ja:cpp/container/array/tuple size]]
[[pt:cpp/container/array/tuple size]]
[[ru:cpp/container/array/tuple size]]
[[zh:cpp/container/array/tuple size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque</title>
    <ns>0</ns>
    <id>865</id>
    <revision>
      <id>69357</id>
      <parentid>69349</parentid>
      <timestamp>2014-04-04T06:40:29Z</timestamp>
      <contributor>
        <username>Shachar</username>
        <id>2974</id>
      </contributor>
      <minor/>
      <comment>Add accuracy warning</comment>
      <text xml:space="preserve" bytes="4907">{{cpp/title|deque}}
{{cpp/container/deque/navbar}}
{{ddcl | header=deque |
template&lt;
    class T,
    class Allocator {{=}} std::allocator&lt;T&gt;
&gt; class deque;
}} 

{{tt|std::deque}} (double-ended queue) is an indexed sequence container that allows fast insertion and deletion at both its beginning and its end. In addition, insertion and deletion at either end of a deque never invalidates pointers or references to the rest of the elements.

As opposed to {{lc|std::vector}}, the elements of a deque are not stored contiguously: typical implementations use a sequence of individually allocated fixed-size arrays.

The storage of a deque is automatically expanded and contracted as needed. Expansion of a deque is cheaper than the expansion of a {{lc|std::vector}} because it does not involve copying of the existing elements to a new memory location.

The complexity (efficiency) of common operations on deques is as follows:

* Random access - constant {{math|O(1)}}
* Insertion or removal of elements at the end or beginning - amortized constant {{math|O(1)}}
* Insertion or removal of elements - linear {{math|O(n)}}

{{tt|std::deque}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|SequenceContainer}} and {{concept|ReversibleContainer}}.

===Template parameters===
{{par begin}}
{{par inc | cpp/container/param list T | deque}}
{{par inc | cpp/container/param list Allocator | deque}}
{{par end}}

===Iterator invalidation===
{{todo}}
There are still a few inaccuracies in this section.

{| class=&quot;dsctable&quot; style=&quot;font-size:0.8em&quot;
! Operations
! Invalidated
|-
| All read only operations, {{lc|swap}}, {{lc|std::swap}}
| Never
|-
| {{lc|shrink_to_fit}}, {{lc|clear}}, {{lc|insert}}, {{lc|emplace}}, {{lc|push_back}}, {{lc|emplace_back}}
| Always
|-
| {{lc|erase}}
| If erasing at beginning or end - only erased elements.&lt;br&gt;
Otherwise - all iterators are invalidated.
|-
| {{lc|resize}}
| Only if the new size is bigger than the old one.
|-
| {{lc|pop_back}}, {{lc|pop_front}}
| Only to the element erased
|}

====Notes====
* Under some circumstances, references are not invalidated by {{lc|insert}} and {{lc|emplace}}.
* {{lc|push_back}} and {{lc|emplace_back}} do not invalidate any references.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | deque}}
{{dsc inc | cpp/container/dsc allocator_type | deque}}
{{dsc inc | cpp/container/dsc size_type | deque}}
{{dsc inc | cpp/container/dsc difference_type | deque}}
{{dsc inc | cpp/container/dsc reference | deque}}
{{dsc inc | cpp/container/dsc const_reference | deque}}
{{dsc inc | cpp/container/dsc pointer | deque}}
{{dsc inc | cpp/container/dsc const_pointer | deque}}
{{dsc inc | cpp/container/dsc iterator | deque}}
{{dsc inc | cpp/container/dsc const_iterator | deque}}
{{dsc inc | cpp/container/dsc reverse_iterator | deque}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | deque}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | deque}}
{{dsc inc | cpp/container/dsc destructor | deque}}
{{dsc inc | cpp/container/dsc operator{{=}} | deque}}
{{dsc inc | cpp/container/dsc assign | deque}}
{{dsc inc | cpp/container/dsc get_allocator | deque}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | deque}}
{{dsc inc | cpp/container/dsc operator_at | deque}}
{{dsc inc | cpp/container/dsc front | deque}}
{{dsc inc | cpp/container/dsc back | deque}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | deque}}
{{dsc inc | cpp/container/dsc end | deque}}
{{dsc inc | cpp/container/dsc rbegin | deque}}
{{dsc inc | cpp/container/dsc rend | deque}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | deque}}
{{dsc inc | cpp/container/dsc size | deque}}
{{dsc inc | cpp/container/dsc max_size | deque}}
{{dsc inc | cpp/container/dsc shrink_to_fit | deque}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | deque}}
{{dsc inc | cpp/container/dsc insert | deque}}
{{dsc inc | cpp/container/dsc emplace | deque}}
{{dsc inc | cpp/container/dsc erase | deque}}
{{dsc inc | cpp/container/dsc push_back | deque}}
{{dsc inc | cpp/container/dsc emplace_back | deque}}
{{dsc inc | cpp/container/dsc pop_back | deque}}
{{dsc inc | cpp/container/dsc push_front | deque}}
{{dsc inc | cpp/container/dsc emplace_front | deque}}
{{dsc inc | cpp/container/dsc pop_front | deque}}
{{dsc inc | cpp/container/dsc resize | deque}}
{{dsc inc | cpp/container/dsc swap | deque}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | deque}}
{{dsc inc | cpp/container/dsc swap2 | deque}}
{{dsc end}}

[[de:cpp/container/deque]]
[[es:cpp/container/deque]]
[[fr:cpp/container/deque]]
[[it:cpp/container/deque]]
[[ja:cpp/container/deque]]
[[pt:cpp/container/deque]]
[[ru:cpp/container/deque]]
[[zh:cpp/container/deque]]</text>
      <sha1>absfxegbbpdtvbx05c8d7nk88y820eo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/assign</title>
    <ns>0</ns>
    <id>866</id>
    <revision>
      <id>50448</id>
      <parentid>44099</parentid>
      <timestamp>2013-06-01T03:29:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/assign|deque}}

[[de:cpp/container/deque/assign]]
[[es:cpp/container/deque/assign]]
[[fr:cpp/container/deque/assign]]
[[it:cpp/container/deque/assign]]
[[ja:cpp/container/deque/assign]]
[[pt:cpp/container/deque/assign]]
[[ru:cpp/container/deque/assign]]
[[zh:cpp/container/deque/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/at</title>
    <ns>0</ns>
    <id>867</id>
    <revision>
      <id>50449</id>
      <parentid>44094</parentid>
      <timestamp>2013-06-01T03:29:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/at|deque}}

[[de:cpp/container/deque/at]]
[[es:cpp/container/deque/at]]
[[fr:cpp/container/deque/at]]
[[it:cpp/container/deque/at]]
[[ja:cpp/container/deque/at]]
[[pt:cpp/container/deque/at]]
[[ru:cpp/container/deque/at]]
[[zh:cpp/container/deque/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/back</title>
    <ns>0</ns>
    <id>868</id>
    <revision>
      <id>50450</id>
      <parentid>44089</parentid>
      <timestamp>2013-06-01T03:29:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/back|deque}}

[[de:cpp/container/deque/back]]
[[es:cpp/container/deque/back]]
[[fr:cpp/container/deque/back]]
[[it:cpp/container/deque/back]]
[[ja:cpp/container/deque/back]]
[[pt:cpp/container/deque/back]]
[[ru:cpp/container/deque/back]]
[[zh:cpp/container/deque/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/begin</title>
    <ns>0</ns>
    <id>869</id>
    <revision>
      <id>50451</id>
      <parentid>44083</parentid>
      <timestamp>2013-06-01T03:29:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/begin|deque}}

[[de:cpp/container/deque/begin]]
[[es:cpp/container/deque/begin]]
[[fr:cpp/container/deque/begin]]
[[it:cpp/container/deque/begin]]
[[ja:cpp/container/deque/begin]]
[[pt:cpp/container/deque/begin]]
[[ru:cpp/container/deque/begin]]
[[zh:cpp/container/deque/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/clear</title>
    <ns>0</ns>
    <id>870</id>
    <revision>
      <id>50452</id>
      <parentid>44078</parentid>
      <timestamp>2013-06-01T03:29:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/clear|deque}}

[[de:cpp/container/deque/clear]]
[[es:cpp/container/deque/clear]]
[[fr:cpp/container/deque/clear]]
[[it:cpp/container/deque/clear]]
[[ja:cpp/container/deque/clear]]
[[pt:cpp/container/deque/clear]]
[[ru:cpp/container/deque/clear]]
[[zh:cpp/container/deque/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/deque</title>
    <ns>0</ns>
    <id>871</id>
    <revision>
      <id>50453</id>
      <parentid>44076</parentid>
      <timestamp>2013-06-01T03:29:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="313">{{include page|cpp/container/constructor|deque}}

[[de:cpp/container/deque/deque]]
[[es:cpp/container/deque/deque]]
[[fr:cpp/container/deque/deque]]
[[it:cpp/container/deque/deque]]
[[ja:cpp/container/deque/deque]]
[[pt:cpp/container/deque/deque]]
[[ru:cpp/container/deque/deque]]
[[zh:cpp/container/deque/deque]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/emplace</title>
    <ns>0</ns>
    <id>872</id>
    <revision>
      <id>50454</id>
      <parentid>44070</parentid>
      <timestamp>2013-06-01T03:29:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/emplace|deque}}

[[de:cpp/container/deque/emplace]]
[[es:cpp/container/deque/emplace]]
[[fr:cpp/container/deque/emplace]]
[[it:cpp/container/deque/emplace]]
[[ja:cpp/container/deque/emplace]]
[[pt:cpp/container/deque/emplace]]
[[ru:cpp/container/deque/emplace]]
[[zh:cpp/container/deque/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/emplace back</title>
    <ns>0</ns>
    <id>873</id>
    <revision>
      <id>50455</id>
      <parentid>44066</parentid>
      <timestamp>2013-06-01T03:29:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/emplace_back|deque}}

[[de:cpp/container/deque/emplace back]]
[[es:cpp/container/deque/emplace back]]
[[fr:cpp/container/deque/emplace back]]
[[it:cpp/container/deque/emplace back]]
[[ja:cpp/container/deque/emplace back]]
[[pt:cpp/container/deque/emplace back]]
[[ru:cpp/container/deque/emplace back]]
[[zh:cpp/container/deque/emplace back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/emplace front</title>
    <ns>0</ns>
    <id>874</id>
    <revision>
      <id>50456</id>
      <parentid>44061</parentid>
      <timestamp>2013-06-01T03:29:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/emplace_front|deque}}

[[de:cpp/container/deque/emplace front]]
[[es:cpp/container/deque/emplace front]]
[[fr:cpp/container/deque/emplace front]]
[[it:cpp/container/deque/emplace front]]
[[ja:cpp/container/deque/emplace front]]
[[pt:cpp/container/deque/emplace front]]
[[ru:cpp/container/deque/emplace front]]
[[zh:cpp/container/deque/emplace front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/empty</title>
    <ns>0</ns>
    <id>875</id>
    <revision>
      <id>50457</id>
      <parentid>44057</parentid>
      <timestamp>2013-06-01T03:29:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/empty|deque}}

[[de:cpp/container/deque/empty]]
[[es:cpp/container/deque/empty]]
[[fr:cpp/container/deque/empty]]
[[it:cpp/container/deque/empty]]
[[ja:cpp/container/deque/empty]]
[[pt:cpp/container/deque/empty]]
[[ru:cpp/container/deque/empty]]
[[zh:cpp/container/deque/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/end</title>
    <ns>0</ns>
    <id>876</id>
    <revision>
      <id>50458</id>
      <parentid>44056</parentid>
      <timestamp>2013-06-01T03:29:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/end|deque}}

[[de:cpp/container/deque/end]]
[[es:cpp/container/deque/end]]
[[fr:cpp/container/deque/end]]
[[it:cpp/container/deque/end]]
[[ja:cpp/container/deque/end]]
[[pt:cpp/container/deque/end]]
[[ru:cpp/container/deque/end]]
[[zh:cpp/container/deque/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/erase</title>
    <ns>0</ns>
    <id>877</id>
    <revision>
      <id>50459</id>
      <parentid>44051</parentid>
      <timestamp>2013-06-01T03:29:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/erase|deque}}

[[de:cpp/container/deque/erase]]
[[es:cpp/container/deque/erase]]
[[fr:cpp/container/deque/erase]]
[[it:cpp/container/deque/erase]]
[[ja:cpp/container/deque/erase]]
[[pt:cpp/container/deque/erase]]
[[ru:cpp/container/deque/erase]]
[[zh:cpp/container/deque/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/front</title>
    <ns>0</ns>
    <id>878</id>
    <revision>
      <id>50460</id>
      <parentid>44044</parentid>
      <timestamp>2013-06-01T03:29:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/front|deque}}

[[de:cpp/container/deque/front]]
[[es:cpp/container/deque/front]]
[[fr:cpp/container/deque/front]]
[[it:cpp/container/deque/front]]
[[ja:cpp/container/deque/front]]
[[pt:cpp/container/deque/front]]
[[ru:cpp/container/deque/front]]
[[zh:cpp/container/deque/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/get allocator</title>
    <ns>0</ns>
    <id>879</id>
    <revision>
      <id>50461</id>
      <parentid>44038</parentid>
      <timestamp>2013-06-01T03:29:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/get_allocator|deque}}

[[de:cpp/container/deque/get allocator]]
[[es:cpp/container/deque/get allocator]]
[[fr:cpp/container/deque/get allocator]]
[[it:cpp/container/deque/get allocator]]
[[ja:cpp/container/deque/get allocator]]
[[pt:cpp/container/deque/get allocator]]
[[ru:cpp/container/deque/get allocator]]
[[zh:cpp/container/deque/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/insert</title>
    <ns>0</ns>
    <id>880</id>
    <revision>
      <id>50462</id>
      <parentid>44033</parentid>
      <timestamp>2013-06-01T03:29:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/insert|deque}}

[[de:cpp/container/deque/insert]]
[[es:cpp/container/deque/insert]]
[[fr:cpp/container/deque/insert]]
[[it:cpp/container/deque/insert]]
[[ja:cpp/container/deque/insert]]
[[pt:cpp/container/deque/insert]]
[[ru:cpp/container/deque/insert]]
[[zh:cpp/container/deque/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/max size</title>
    <ns>0</ns>
    <id>881</id>
    <revision>
      <id>50463</id>
      <parentid>44029</parentid>
      <timestamp>2013-06-01T03:29:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/max_size|deque}}

[[de:cpp/container/deque/max size]]
[[es:cpp/container/deque/max size]]
[[fr:cpp/container/deque/max size]]
[[it:cpp/container/deque/max size]]
[[ja:cpp/container/deque/max size]]
[[pt:cpp/container/deque/max size]]
[[ru:cpp/container/deque/max size]]
[[zh:cpp/container/deque/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/operator=</title>
    <ns>0</ns>
    <id>882</id>
    <revision>
      <id>44025</id>
      <parentid>1765</parentid>
      <timestamp>2012-11-03T04:36:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="334">{{cpp/container/operator{{=}}|deque}}

[[de:cpp/container/deque/operator=]]
[[es:cpp/container/deque/operator=]]
[[fr:cpp/container/deque/operator=]]
[[it:cpp/container/deque/operator=]]
[[ja:cpp/container/deque/operator=]]
[[pt:cpp/container/deque/operator=]]
[[ru:cpp/container/deque/operator=]]
[[zh:cpp/container/deque/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/operator at</title>
    <ns>0</ns>
    <id>883</id>
    <revision>
      <id>50464</id>
      <parentid>44021</parentid>
      <timestamp>2013-06-01T03:29:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/operator_at|deque}}

[[de:cpp/container/deque/operator at]]
[[es:cpp/container/deque/operator at]]
[[fr:cpp/container/deque/operator at]]
[[it:cpp/container/deque/operator at]]
[[ja:cpp/container/deque/operator at]]
[[pt:cpp/container/deque/operator at]]
[[ru:cpp/container/deque/operator at]]
[[zh:cpp/container/deque/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/operator cmp</title>
    <ns>0</ns>
    <id>1996</id>
    <revision>
      <id>50465</id>
      <parentid>44016</parentid>
      <timestamp>2013-06-01T03:29:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/operator_cmp|deque}}

[[de:cpp/container/deque/operator cmp]]
[[es:cpp/container/deque/operator cmp]]
[[fr:cpp/container/deque/operator cmp]]
[[it:cpp/container/deque/operator cmp]]
[[ja:cpp/container/deque/operator cmp]]
[[pt:cpp/container/deque/operator cmp]]
[[ru:cpp/container/deque/operator cmp]]
[[zh:cpp/container/deque/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/operator comp</title>
    <ns>0</ns>
    <id>4211</id>
    <redirect title="cpp/container/deque/operator cmp" />
    <revision>
      <id>15239</id>
      <timestamp>2011-12-08T01:11:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/deque/operator comp]] to [[cpp/container/deque/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/container/deque/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/pop back</title>
    <ns>0</ns>
    <id>884</id>
    <revision>
      <id>50466</id>
      <parentid>44010</parentid>
      <timestamp>2013-06-01T03:29:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/pop_back|deque}}

[[de:cpp/container/deque/pop back]]
[[es:cpp/container/deque/pop back]]
[[fr:cpp/container/deque/pop back]]
[[it:cpp/container/deque/pop back]]
[[ja:cpp/container/deque/pop back]]
[[pt:cpp/container/deque/pop back]]
[[ru:cpp/container/deque/pop back]]
[[zh:cpp/container/deque/pop back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/pop front</title>
    <ns>0</ns>
    <id>885</id>
    <revision>
      <id>50467</id>
      <parentid>44004</parentid>
      <timestamp>2013-06-01T03:29:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/pop_front|deque}}

[[de:cpp/container/deque/pop front]]
[[es:cpp/container/deque/pop front]]
[[fr:cpp/container/deque/pop front]]
[[it:cpp/container/deque/pop front]]
[[ja:cpp/container/deque/pop front]]
[[pt:cpp/container/deque/pop front]]
[[ru:cpp/container/deque/pop front]]
[[zh:cpp/container/deque/pop front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/push back</title>
    <ns>0</ns>
    <id>886</id>
    <revision>
      <id>50468</id>
      <parentid>43998</parentid>
      <timestamp>2013-06-01T03:29:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/push_back|deque}}

[[de:cpp/container/deque/push back]]
[[es:cpp/container/deque/push back]]
[[fr:cpp/container/deque/push back]]
[[it:cpp/container/deque/push back]]
[[ja:cpp/container/deque/push back]]
[[pt:cpp/container/deque/push back]]
[[ru:cpp/container/deque/push back]]
[[zh:cpp/container/deque/push back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/push front</title>
    <ns>0</ns>
    <id>887</id>
    <revision>
      <id>50469</id>
      <parentid>43991</parentid>
      <timestamp>2013-06-01T03:29:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="352">{{include page|cpp/container/push_front|deque}}

[[de:cpp/container/deque/push front]]
[[es:cpp/container/deque/push front]]
[[fr:cpp/container/deque/push front]]
[[it:cpp/container/deque/push front]]
[[ja:cpp/container/deque/push front]]
[[pt:cpp/container/deque/push front]]
[[ru:cpp/container/deque/push front]]
[[zh:cpp/container/deque/push front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/rbegin</title>
    <ns>0</ns>
    <id>888</id>
    <revision>
      <id>50470</id>
      <parentid>43984</parentid>
      <timestamp>2013-06-01T03:29:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/rbegin|deque}}

[[de:cpp/container/deque/rbegin]]
[[es:cpp/container/deque/rbegin]]
[[fr:cpp/container/deque/rbegin]]
[[it:cpp/container/deque/rbegin]]
[[ja:cpp/container/deque/rbegin]]
[[pt:cpp/container/deque/rbegin]]
[[ru:cpp/container/deque/rbegin]]
[[zh:cpp/container/deque/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/rend</title>
    <ns>0</ns>
    <id>889</id>
    <revision>
      <id>50471</id>
      <parentid>43978</parentid>
      <timestamp>2013-06-01T03:29:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/rend|deque}}

[[de:cpp/container/deque/rend]]
[[es:cpp/container/deque/rend]]
[[fr:cpp/container/deque/rend]]
[[it:cpp/container/deque/rend]]
[[ja:cpp/container/deque/rend]]
[[pt:cpp/container/deque/rend]]
[[ru:cpp/container/deque/rend]]
[[zh:cpp/container/deque/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/resize</title>
    <ns>0</ns>
    <id>890</id>
    <revision>
      <id>50472</id>
      <parentid>43970</parentid>
      <timestamp>2013-06-01T03:29:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/resize|deque}}

[[de:cpp/container/deque/resize]]
[[es:cpp/container/deque/resize]]
[[fr:cpp/container/deque/resize]]
[[it:cpp/container/deque/resize]]
[[ja:cpp/container/deque/resize]]
[[pt:cpp/container/deque/resize]]
[[ru:cpp/container/deque/resize]]
[[zh:cpp/container/deque/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/shrink to fit</title>
    <ns>0</ns>
    <id>891</id>
    <revision>
      <id>50473</id>
      <parentid>43966</parentid>
      <timestamp>2013-06-01T03:29:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/shrink_to_fit|deque}}

[[de:cpp/container/deque/shrink to fit]]
[[es:cpp/container/deque/shrink to fit]]
[[fr:cpp/container/deque/shrink to fit]]
[[it:cpp/container/deque/shrink to fit]]
[[ja:cpp/container/deque/shrink to fit]]
[[pt:cpp/container/deque/shrink to fit]]
[[ru:cpp/container/deque/shrink to fit]]
[[zh:cpp/container/deque/shrink to fit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/size</title>
    <ns>0</ns>
    <id>892</id>
    <revision>
      <id>50474</id>
      <parentid>43960</parentid>
      <timestamp>2013-06-01T03:29:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/size|deque}}

[[de:cpp/container/deque/size]]
[[es:cpp/container/deque/size]]
[[fr:cpp/container/deque/size]]
[[it:cpp/container/deque/size]]
[[ja:cpp/container/deque/size]]
[[pt:cpp/container/deque/size]]
[[ru:cpp/container/deque/size]]
[[zh:cpp/container/deque/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/std swap</title>
    <ns>0</ns>
    <id>3458</id>
    <redirect title="cpp/container/deque/swap2" />
    <revision>
      <id>13005</id>
      <timestamp>2011-11-03T18:38:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/deque/std swap]] to [[cpp/container/deque/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/container/deque/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/swap</title>
    <ns>0</ns>
    <id>893</id>
    <revision>
      <id>50475</id>
      <parentid>43954</parentid>
      <timestamp>2013-06-01T03:29:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/swap|deque}}

[[de:cpp/container/deque/swap]]
[[es:cpp/container/deque/swap]]
[[fr:cpp/container/deque/swap]]
[[it:cpp/container/deque/swap]]
[[ja:cpp/container/deque/swap]]
[[pt:cpp/container/deque/swap]]
[[ru:cpp/container/deque/swap]]
[[zh:cpp/container/deque/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/swap2</title>
    <ns>0</ns>
    <id>1992</id>
    <revision>
      <id>50476</id>
      <parentid>43948</parentid>
      <timestamp>2013-06-01T03:29:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/swap2|deque}}

[[de:cpp/container/deque/swap2]]
[[es:cpp/container/deque/swap2]]
[[fr:cpp/container/deque/swap2]]
[[it:cpp/container/deque/swap2]]
[[ja:cpp/container/deque/swap2]]
[[pt:cpp/container/deque/swap2]]
[[ru:cpp/container/deque/swap2]]
[[zh:cpp/container/deque/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/deque/~deque</title>
    <ns>0</ns>
    <id>894</id>
    <revision>
      <id>50477</id>
      <parentid>43942</parentid>
      <timestamp>2013-06-01T03:30:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="320">{{include page|cpp/container/destructor|deque}}

[[de:cpp/container/deque/~deque]]
[[es:cpp/container/deque/~deque]]
[[fr:cpp/container/deque/~deque]]
[[it:cpp/container/deque/~deque]]
[[ja:cpp/container/deque/~deque]]
[[pt:cpp/container/deque/~deque]]
[[ru:cpp/container/deque/~deque]]
[[zh:cpp/container/deque/~deque]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray</title>
    <ns>0</ns>
    <id>10007</id>
    <revision>
      <id>65917</id>
      <parentid>65723</parentid>
      <timestamp>2013-10-15T04:33:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>update note in case people link here directly</comment>
      <text xml:space="preserve" bytes="3332">{{cpp/title|dynarray}}
{{cpp/container/dynarray/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=After reviewing national body comments to n3690, this library component was voted out from C++14 working paper into a separate Technical Specification. This container is not a part of the draft C++14 as of n3797}}
{{ddcl | header=dynarray | since=c++14 |
template&lt;
    class T
&gt; class dynarray;
}} 

{{tt|std::dynarray}} is a sequence container that encapsulates arrays with a size that is fixed at construction and does not change throughout the lifetime of the object.

The elements are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets on regular pointers to elements. This means that  a pointer to an element of a dynarray may be passed to any function that expects a pointer to an element of an array.

There is a special case for a zero-length array (the number of elements was specified as zero during construction). In that case, {{c|1=array.begin() == array.end()}}, which is some unique value. The effect of calling {{c|front()}} or {{c|back()}} on a zero-sized {{tt|dynarray}} is undefined.

&lt;!--{{tt|std::dynarray}} meets the requirements of {{concept|Container}}, {{concept|SequenceContainer}} and {{concept|ReversibleContainer}}.--&gt;

===Template parameters===
{{par begin}}
&lt;!--{{par inc | cpp/container/param list T | dynarray}}--&gt;
{{todo}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | dynarray}}
{{dsc inc | cpp/container/dsc size_type | dynarray}}
{{dsc inc | cpp/container/dsc difference_type | dynarray}}
{{dsc inc | cpp/container/dsc reference | dynarray}}
{{dsc inc | cpp/container/dsc const_reference | dynarray}}
{{dsc inc | cpp/container/dsc pointer | dynarray}}
{{dsc inc | cpp/container/dsc const_pointer | dynarray}}
{{dsc inc | cpp/container/dsc iterator | dynarray}}
{{dsc inc | cpp/container/dsc const_iterator | dynarray}}
{{dsc inc | cpp/container/dsc reverse_iterator | dynarray}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | dynarray}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | dynarray}}
{{dsc inc | cpp/container/dsc destructor | dynarray}}
{{dsc inc | cpp/container/dsc operator{{=}} | dynarray}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | dynarray}}
{{dsc inc | cpp/container/dsc operator_at | dynarray}}
{{dsc inc | cpp/container/dsc front | dynarray}}
{{dsc inc | cpp/container/dsc back | dynarray}}
{{dsc inc | cpp/container/dsc data | dynarray}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | dynarray}}
{{dsc inc | cpp/container/dsc end | dynarray}}
{{dsc inc | cpp/container/dsc rbegin | dynarray}}
{{dsc inc | cpp/container/dsc rend | dynarray}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | dynarray}}
{{dsc inc | cpp/container/dsc size | dynarray}}
{{dsc inc | cpp/container/dsc max_size | dynarray}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc fill | dynarray}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | dynarray}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc uses_allocator | dynarray}}
{{dsc end}}</text>
      <sha1>ieyhcez7n54mtw5d8gzhf5duf45xd8w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/at</title>
    <ns>0</ns>
    <id>10020</id>
    <revision>
      <id>50478</id>
      <parentid>47690</parentid>
      <timestamp>2013-06-01T03:30:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="46">{{include page | cpp/container/at | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/back</title>
    <ns>0</ns>
    <id>10017</id>
    <revision>
      <id>50479</id>
      <parentid>47686</parentid>
      <timestamp>2013-06-01T03:30:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="48">{{include page | cpp/container/back | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/begin</title>
    <ns>0</ns>
    <id>10015</id>
    <revision>
      <id>50480</id>
      <parentid>47684</parentid>
      <timestamp>2013-06-01T03:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="49">{{include page | cpp/container/begin | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/data</title>
    <ns>0</ns>
    <id>10016</id>
    <revision>
      <id>50481</id>
      <parentid>47685</parentid>
      <timestamp>2013-06-01T03:30:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="48">{{include page | cpp/container/data | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/dynarray</title>
    <ns>0</ns>
    <id>10056</id>
    <revision>
      <id>66350</id>
      <parentid>65499</parentid>
      <timestamp>2013-11-10T21:09:25Z</timestamp>
      <contributor>
        <ip>184.160.123.149</ip>
      </contributor>
      <text xml:space="preserve" bytes="2787">{{cpp/container/dynarray/title | dynarray}}
{{cpp/container/dynarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++14 | 1=
explicit dynarray( size_type count );
}}
{{dcl | num=2 | since=c++14 | 1=
template&lt; class Alloc &gt;
dynarray( size_type count, const Alloc&amp; alloc );
}}
{{dcl | num=3 | since=c++14 | 1=
dynarray( size_type count, const T&amp; value );
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class Alloc &gt;
dynarray( size_type count, const T&amp; value, const Alloc&amp; alloc );
}}
{{dcl | num=5 | since=c++14 | 1=
dynarray( const dynarray&amp; other );
}}
{{dcl | num=6 | since=c++14 | 1=
template&lt; class Alloc &gt;
dynarray( const dynarray&amp; other, const Alloc&amp; alloc );
}}
{{dcl | num=7 | since=c++14 | 1=
dynarray( std::initializer_list&lt;T&gt; init );
}}
{{dcl | num=8 | since=c++14 | 1=
template&lt; class Alloc &gt;
dynarray( std::initializer_list&lt;T&gt; init, const Alloc&amp; alloc );
}}
{{dcl end}}

Constructs a new container from a variety of data sources, optionally using user supplied allocator {{tt|alloc}}. If an allocator is provided, all memory allocations are done though it. Otherwise, the memory is allocated from an unspecified source, which may, or may not, invoke the global {{c|operator new}}. This way, additional optimization opportunities are possible, for example, using [[enwiki:Stack-based_memory_allocation|stack-based allocation]].

@1-2@ Constructs the container with {{tt|count}} default-initialized (or constructed by specified allocator) instances of {{tt|T}}. No copies are made.

@3-4@ Constructs the container with {{tt|count}} copies of elements with value {{tt|value}}. {{tt|T}} must meet the requirements of {{concept|CopyConstructible}}.

@5-6@ Copy-constructor. Constructs the container with the copy of the contents of {{tt|other}}. {{tt|T}} must meet the requirements of {{concept|CopyConstructible}}.

@7-8@ Constructs the container with the contents of the initializer list {{tt|init}}.

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for the memory allocations of this container}}
{{par | count | the size of the container}}
{{par | value | the value to initialize elements of the container with}}
{{par | other | another container to be used as source to initialize the elements of the container with}}
{{par | init | initializer list to initialize the elements of the container with}}
{{par hreq}}
{{par req concept | Alloc | Allocator}}
{{par end}} 

===Complexity===
@1-4@ Linear in {{tt|count}}

@5-6@ Linear in {{c|other.size()}}

@7-8@ Linear in size of {{tt|init}}

===Exceptions===
@1-4@ {{lc|std::bad_alloc}} if there's insufficient memory. {{c|std::bad_array_length}} if {{tt|count}} is above the implementation-defined limits.

@5-8@ {{lc|std::bad_alloc}} if there's insufficient memory.

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1>bsq0qlzzx3byn81lk573izh2h3v9gtd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/empty</title>
    <ns>0</ns>
    <id>10021</id>
    <revision>
      <id>50482</id>
      <parentid>47693</parentid>
      <timestamp>2013-06-01T03:30:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="49">{{include page | cpp/container/empty | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/end</title>
    <ns>0</ns>
    <id>10014</id>
    <revision>
      <id>50483</id>
      <parentid>47683</parentid>
      <timestamp>2013-06-01T03:30:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="47">{{include page | cpp/container/end | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/fill</title>
    <ns>0</ns>
    <id>10024</id>
    <revision>
      <id>50484</id>
      <parentid>47697</parentid>
      <timestamp>2013-06-01T03:30:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="48">{{include page | cpp/container/fill | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/front</title>
    <ns>0</ns>
    <id>10018</id>
    <revision>
      <id>50485</id>
      <parentid>47687</parentid>
      <timestamp>2013-06-01T03:30:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="49">{{include page | cpp/container/front | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/max size</title>
    <ns>0</ns>
    <id>10023</id>
    <revision>
      <id>50486</id>
      <parentid>47695</parentid>
      <timestamp>2013-06-01T03:30:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="52">{{include page | cpp/container/max_size | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/operator at</title>
    <ns>0</ns>
    <id>10019</id>
    <revision>
      <id>50487</id>
      <parentid>47688</parentid>
      <timestamp>2013-06-01T03:30:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="55">{{include page | cpp/container/operator_at | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/operator cmp</title>
    <ns>0</ns>
    <id>10051</id>
    <revision>
      <id>50488</id>
      <parentid>47742</parentid>
      <timestamp>2013-06-01T03:30:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="56">{{include page | cpp/container/operator_cmp | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/rbegin</title>
    <ns>0</ns>
    <id>10013</id>
    <revision>
      <id>50489</id>
      <parentid>47682</parentid>
      <timestamp>2013-06-01T03:30:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="50">{{include page | cpp/container/rbegin | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/rend</title>
    <ns>0</ns>
    <id>10012</id>
    <revision>
      <id>50490</id>
      <parentid>47681</parentid>
      <timestamp>2013-06-01T03:30:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="48">{{include page | cpp/container/rend | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/size</title>
    <ns>0</ns>
    <id>10022</id>
    <revision>
      <id>50491</id>
      <parentid>47694</parentid>
      <timestamp>2013-06-01T03:30:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="48">{{include page | cpp/container/size | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/uses allocator</title>
    <ns>0</ns>
    <id>10008</id>
    <revision>
      <id>63838</id>
      <parentid>62693</parentid>
      <timestamp>2013-07-29T14:11:50Z</timestamp>
      <contributor>
        <ip>82.238.42.70</ip>
      </contributor>
      <text xml:space="preserve" bytes="547">{{cpp/title | uses_allocator{{small|&lt;std::dynarray&gt;}}}}
{{cpp/container/dynarray/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |1=
template&lt; class T, class Alloc &gt;
struct uses_allocator&lt;dynarray&lt;T&gt;, Alloc&gt; : std::true_type;
}}
{{dcl end}}

Provides a specialization of the {{lc|std::uses_allocator}} type trait for {{lc|std::dynarray}}. A {{tt|dynarray}} may be constructed with an allocator, even though the class does not have {{tt|allocator_type}} member type. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/dynarray/~dynarray</title>
    <ns>0</ns>
    <id>10009</id>
    <revision>
      <id>50492</id>
      <parentid>47677</parentid>
      <timestamp>2013-06-01T03:30:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="54">{{include page | cpp/container/destructor | dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list</title>
    <ns>0</ns>
    <id>895</id>
    <revision>
      <id>70687</id>
      <parentid>69682</parentid>
      <timestamp>2014-05-28T13:47:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>T must be complete per 17.6.4.8/2</comment>
      <text xml:space="preserve" bytes="4480">{{cpp/title|forward_list}}
{{cpp/container/forward_list/navbar}}
{{ddcl | header=forward_list | since=c++11 |
template&lt;
    class T,
    class Allocator {{=}} std::allocator&lt;T&gt;
&gt; class forward_list;
}} 

{{tt|std::forward_list}} is a container that supports fast insertion and removal of elements from anywhere in the container. Fast random access is not supported. It is implemented as a singly-linked list and essentially does not have any overhead compared to its implementation in C. Compared to {{lc|std::list}} this container provides more space efficient storage when bidirectional iteration is not needed. 

Adding, removing and moving the elements within the list, or across several lists, does not invalidate the iterators currently referring to other elements in the list. However, an iterator or reference referring to an element is invalidated when the corresponding element is removed (via {{lc|erase_after}}) from the list.

{{tt|std::forward_list}} meets the requirements of {{concept|Container}} (except for the {{lc|size}} member function and that {{tt|operator{{==}}}}'s complexity is always linear), {{concept|AllocatorAwareContainer}} and {{concept|SequenceContainer}}.

===Template parameters===
{{par begin}}
{{par | T | The type of the elements. &lt;br/&gt;
The requirements that are imposed on the elements depend on the actual operations performed on the container. Generally, it is required that element type is a complete type&lt;!--17.6.4.8[res.on.functions]/2, last bullet--&gt; and meets the requirements of {{concept|MoveConstructible}} and {{concept|MoveAssignable}}, but many member functions impose stricter requirements.}}
{{par inc | cpp/container/param list Allocator | forward_list}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | forward_list}}
{{dsc inc | cpp/container/dsc allocator_type | forward_list}}
{{dsc inc | cpp/container/dsc size_type | forward_list}}
{{dsc inc | cpp/container/dsc difference_type | forward_list}}
{{dsc inc | cpp/container/dsc reference | forward_list}}
{{dsc inc | cpp/container/dsc const_reference | forward_list}}
{{dsc inc | cpp/container/dsc pointer | forward_list}}
{{dsc inc | cpp/container/dsc const_pointer | forward_list}}
{{dsc inc | cpp/container/dsc iterator | forward_list}}
{{dsc inc | cpp/container/dsc const_iterator | forward_list}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | forward_list}}
{{dsc inc | cpp/container/dsc destructor | forward_list}}
{{dsc inc | cpp/container/dsc operator{{=}} | forward_list}}
{{dsc inc | cpp/container/dsc assign | forward_list}}
{{dsc inc | cpp/container/dsc get_allocator | forward_list}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc front | forward_list}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc before_begin | forward_list}}
{{dsc inc | cpp/container/dsc begin | forward_list}}
{{dsc inc | cpp/container/dsc end | forward_list}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | forward_list}}
{{dsc inc | cpp/container/dsc max_size | forward_list}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | forward_list}}
{{dsc inc | cpp/container/dsc insert_after | forward_list}}
{{dsc inc | cpp/container/dsc emplace_after | forward_list}}
{{dsc inc | cpp/container/dsc erase_after | forward_list}}
{{dsc inc | cpp/container/dsc push_front | forward_list}}
{{dsc inc | cpp/container/dsc emplace_front | forward_list}}
{{dsc inc | cpp/container/dsc pop_front | forward_list}}
{{dsc inc | cpp/container/dsc resize | forward_list}}
{{dsc inc | cpp/container/dsc swap | forward_list}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/container/dsc merge | forward_list}}
{{dsc inc | cpp/container/dsc splice_after | forward_list}}
{{dsc inc | cpp/container/dsc remove | forward_list}}
{{dsc inc | cpp/container/dsc reverse | forward_list}}
{{dsc inc | cpp/container/dsc unique | forward_list}}
{{dsc inc | cpp/container/dsc sort | forward_list}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | forward_list}}
{{dsc inc | cpp/container/dsc swap2 | forward_list}}
{{dsc end}}

[[de:cpp/container/forward list]]
[[es:cpp/container/forward list]]
[[fr:cpp/container/forward list]]
[[it:cpp/container/forward list]]
[[ja:cpp/container/forward list]]
[[pt:cpp/container/forward list]]
[[ru:cpp/container/forward list]]
[[zh:cpp/container/forward list]]</text>
      <sha1>25vrrpxrjyz6i4xnu8xjufwg8hh2jq1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/assign</title>
    <ns>0</ns>
    <id>896</id>
    <revision>
      <id>50493</id>
      <parentid>43929</parentid>
      <timestamp>2013-06-01T03:30:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/assign|forward_list}}

[[de:cpp/container/forward list/assign]]
[[es:cpp/container/forward list/assign]]
[[fr:cpp/container/forward list/assign]]
[[it:cpp/container/forward list/assign]]
[[ja:cpp/container/forward list/assign]]
[[pt:cpp/container/forward list/assign]]
[[ru:cpp/container/forward list/assign]]
[[zh:cpp/container/forward list/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/before begin</title>
    <ns>0</ns>
    <id>897</id>
    <revision>
      <id>64174</id>
      <parentid>62694</parentid>
      <timestamp>2013-08-15T15:08:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, use {{lc}}</comment>
      <text xml:space="preserve" bytes="1429">{{cpp/container/forward_list/title | before_begin, cbefore_begin}}
{{cpp/container/forward_list/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
iterator before_begin();
}}
{{dcl | since=c++11 |
const_iterator before_begin() const;
}}
{{dcl | since=c++11 |
const_iterator cbefore_begin() const;
}}
{{dcl end}}

Returns an iterator to the element before the first element of the container. This element acts as a placeholder, attempting to access it results in undefined behavior. The only usage cases are in functions {{lc|insert_after()}}, {{lc|emplace_after()}}, {{lc|erase_after()}}, {{lc|splice_after()}} and the increment operator: incrementing the before-begin iterator gives exactly the same iterator as obtained from {{lc|begin()}}/{{lc|cbegin()}}.

===Parameters===
(none)

===Return value===
Iterator to the element before the first element.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc begin | forward_list}}
{{dsc inc | cpp/container/dsc end | forward_list}}
{{dsc end}}

[[de:cpp/container/forward list/before begin]]
[[es:cpp/container/forward list/before begin]]
[[fr:cpp/container/forward list/before begin]]
[[it:cpp/container/forward list/before begin]]
[[ja:cpp/container/forward list/before begin]]
[[pt:cpp/container/forward list/before begin]]
[[ru:cpp/container/forward list/before begin]]
[[zh:cpp/container/forward list/before begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/begin</title>
    <ns>0</ns>
    <id>898</id>
    <revision>
      <id>50494</id>
      <parentid>43918</parentid>
      <timestamp>2013-06-01T03:30:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/begin|forward_list}}

[[de:cpp/container/forward list/begin]]
[[es:cpp/container/forward list/begin]]
[[fr:cpp/container/forward list/begin]]
[[it:cpp/container/forward list/begin]]
[[ja:cpp/container/forward list/begin]]
[[pt:cpp/container/forward list/begin]]
[[ru:cpp/container/forward list/begin]]
[[zh:cpp/container/forward list/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/clear</title>
    <ns>0</ns>
    <id>899</id>
    <revision>
      <id>50495</id>
      <parentid>43912</parentid>
      <timestamp>2013-06-01T03:30:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/clear|forward_list}}

[[de:cpp/container/forward list/clear]]
[[es:cpp/container/forward list/clear]]
[[fr:cpp/container/forward list/clear]]
[[it:cpp/container/forward list/clear]]
[[ja:cpp/container/forward list/clear]]
[[pt:cpp/container/forward list/clear]]
[[ru:cpp/container/forward list/clear]]
[[zh:cpp/container/forward list/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/emplace after</title>
    <ns>0</ns>
    <id>901</id>
    <revision>
      <id>63287</id>
      <parentid>57274</parentid>
      <timestamp>2013-07-10T01:27:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1304">{{cpp/container/forward_list/title | emplace_after}}
{{cpp/container/forward_list/navbar}}
{{ddcl | since=c++11 |
template&lt; class... Args &gt; 
iterator emplace_after( const_iterator pos, Args&amp;&amp;... args );
}}

Inserts a new element into a position after the specified position in the container. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments, as supplied to the function.

{{cpp/container/note_iterator_invalidation|forward_list|emplace_after}}
===Parameters===
{{par begin}}
{{par | pos | iterator after which the new element will be constructed}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
iterator to the new element. 

===Complexity===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc insert_after | forward_list}}
{{dsc end}}

[[de:cpp/container/forward list/emplace after]]
[[es:cpp/container/forward list/emplace after]]
[[fr:cpp/container/forward list/emplace after]]
[[it:cpp/container/forward list/emplace after]]
[[ja:cpp/container/forward list/emplace after]]
[[pt:cpp/container/forward list/emplace after]]
[[ru:cpp/container/forward list/emplace after]]
[[zh:cpp/container/forward list/emplace after]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/emplace front</title>
    <ns>0</ns>
    <id>902</id>
    <revision>
      <id>50496</id>
      <parentid>43899</parentid>
      <timestamp>2013-06-01T03:30:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="442">{{include page|cpp/container/emplace_front|forward_list}}

[[de:cpp/container/forward list/emplace front]]
[[es:cpp/container/forward list/emplace front]]
[[fr:cpp/container/forward list/emplace front]]
[[it:cpp/container/forward list/emplace front]]
[[ja:cpp/container/forward list/emplace front]]
[[pt:cpp/container/forward list/emplace front]]
[[ru:cpp/container/forward list/emplace front]]
[[zh:cpp/container/forward list/emplace front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/empty</title>
    <ns>0</ns>
    <id>903</id>
    <revision>
      <id>50497</id>
      <parentid>43894</parentid>
      <timestamp>2013-06-01T03:30:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/empty|forward_list}}

[[de:cpp/container/forward list/empty]]
[[es:cpp/container/forward list/empty]]
[[fr:cpp/container/forward list/empty]]
[[it:cpp/container/forward list/empty]]
[[ja:cpp/container/forward list/empty]]
[[pt:cpp/container/forward list/empty]]
[[ru:cpp/container/forward list/empty]]
[[zh:cpp/container/forward list/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/end</title>
    <ns>0</ns>
    <id>904</id>
    <revision>
      <id>50498</id>
      <parentid>43888</parentid>
      <timestamp>2013-06-01T03:30:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="352">{{include page|cpp/container/end|forward_list}}

[[de:cpp/container/forward list/end]]
[[es:cpp/container/forward list/end]]
[[fr:cpp/container/forward list/end]]
[[it:cpp/container/forward list/end]]
[[ja:cpp/container/forward list/end]]
[[pt:cpp/container/forward list/end]]
[[ru:cpp/container/forward list/end]]
[[zh:cpp/container/forward list/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/erase after</title>
    <ns>0</ns>
    <id>905</id>
    <revision>
      <id>64173</id>
      <parentid>62695</parentid>
      <timestamp>2013-08-15T15:07:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, use {{lc}}</comment>
      <text xml:space="preserve" bytes="1914">{{cpp/container/forward_list/title | erase_after}}
{{cpp/container/forward_list/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
iterator erase_after( const_iterator position );
}}
{{dcl | num=2 | since=c++11 |
iterator erase_after( const_iterator first, const_iterator last );
}}
{{dcl end}}

Removes specified elements from the container. 

@1@ Removes the element following {{tt|pos}}.

@2@ Removes the elements in the range {{tt|(first; last)}}.

===Parameters===
{{par begin}}
{{par | pos | iterator to the element preceding the element to remove}}
{{par | first, last | range of elements to remove}}
{{par end}} 

===Return value===

@1@ Iterator to the element following the erased one, or {{lc|end()}} if no such element exists.

@2@ {{tt|last}}

===Complexity===

@1@ Constant.

@2@ Linear in distance between {{tt|first}} and {{tt|last}}.

===Example===
{{example
 | code=
#include &lt;forward_list&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
int main()
{
    std::forward_list&lt;int&gt; l = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

    //    l.erase( l.begin() ); // ERROR: No function erase
    
    l.erase_after( l.before_begin() ); // Removes first element
    
    for( auto n : l ) std::cout &lt;&lt; n &lt;&lt; &quot; &quot;;
    std::cout &lt;&lt; '\n';

    auto fi= std::next( l.begin() );
    auto la= std::next( fi, 3 );
    
    l.erase_after( fi, la );
    
    for( auto n : l ) std::cout &lt;&lt; n &lt;&lt; &quot; &quot;;
    std::cout &lt;&lt; '\n';
}
 | output=
2 3 4 5 6 7 8 9
2 3 6 7 8 9
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc clear |forward_list}}
{{dsc end}}

[[de:cpp/container/forward list/erase after]]
[[es:cpp/container/forward list/erase after]]
[[fr:cpp/container/forward list/erase after]]
[[it:cpp/container/forward list/erase after]]
[[ja:cpp/container/forward list/erase after]]
[[pt:cpp/container/forward list/erase after]]
[[ru:cpp/container/forward list/erase after]]
[[zh:cpp/container/forward list/erase after]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/forward list</title>
    <ns>0</ns>
    <id>906</id>
    <revision>
      <id>50499</id>
      <parentid>43877</parentid>
      <timestamp>2013-06-01T03:30:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="432">{{include page|cpp/container/constructor|forward_list}}

[[de:cpp/container/forward list/forward list]]
[[es:cpp/container/forward list/forward list]]
[[fr:cpp/container/forward list/forward list]]
[[it:cpp/container/forward list/forward list]]
[[ja:cpp/container/forward list/forward list]]
[[pt:cpp/container/forward list/forward list]]
[[ru:cpp/container/forward list/forward list]]
[[zh:cpp/container/forward list/forward list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/front</title>
    <ns>0</ns>
    <id>907</id>
    <revision>
      <id>50500</id>
      <parentid>43871</parentid>
      <timestamp>2013-06-01T03:30:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/front|forward_list}}

[[de:cpp/container/forward list/front]]
[[es:cpp/container/forward list/front]]
[[fr:cpp/container/forward list/front]]
[[it:cpp/container/forward list/front]]
[[ja:cpp/container/forward list/front]]
[[pt:cpp/container/forward list/front]]
[[ru:cpp/container/forward list/front]]
[[zh:cpp/container/forward list/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/get allocator</title>
    <ns>0</ns>
    <id>908</id>
    <revision>
      <id>50501</id>
      <parentid>43866</parentid>
      <timestamp>2013-06-01T03:30:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="442">{{include page|cpp/container/get_allocator|forward_list}}

[[de:cpp/container/forward list/get allocator]]
[[es:cpp/container/forward list/get allocator]]
[[fr:cpp/container/forward list/get allocator]]
[[it:cpp/container/forward list/get allocator]]
[[ja:cpp/container/forward list/get allocator]]
[[pt:cpp/container/forward list/get allocator]]
[[ru:cpp/container/forward list/get allocator]]
[[zh:cpp/container/forward list/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/insert after</title>
    <ns>0</ns>
    <id>909</id>
    <revision>
      <id>62696</id>
      <parentid>57278</parentid>
      <timestamp>2013-07-01T23:33:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2054">{{cpp/container/forward_list/title | insert_after}}
{{cpp/container/forward_list/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
iterator insert_after( const_iterator pos, const T&amp; value );
}}
{{dcl | num=2 | since=c++11 |
iterator insert_after( const_iterator pos, T&amp;&amp; value );
}}
{{dcl | num=3 | since=c++11 |
iterator insert_after( const_iterator pos, size_type count, const T&amp; value );
}}
{{dcl | num=4 | since=c++11 |
template&lt; class InputIt &gt;
iterator insert_after( const_iterator pos, InputIt first, InputIt last );
}}
{{dcl | num=5 | since=c++11 |
iterator insert_after( const_iterator pos, std::initializer_list&lt;T&gt; ilist );
}}
{{dcl end}}

Inserts elements after the specified position in the container.

@1-2@ inserts {{tt|value}} after the element pointed to by {{tt|pos}}

@3@ inserts {{tt|count}} copies of the {{tt|value}} after the element pointed to by {{tt|pos}}

@4@ inserts elements from range {{tt|[first, last)}} after the element pointed to by {{tt|pos}}

@5@ inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|insert_after}}

===Parameters===
{{par begin}}
{{par | pos | element after which the content will be inserted}}
{{par | value | element value to insert}}
{{par | first, last | the range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
Iterator to the inserted element.

===Complexity===

{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace after | forward_list}}
{{dsc inc | cpp/container/dsc push_front |forward_list}}
{{dsc end}}

[[de:cpp/container/forward list/insert after]]
[[es:cpp/container/forward list/insert after]]
[[fr:cpp/container/forward list/insert after]]
[[it:cpp/container/forward list/insert after]]
[[ja:cpp/container/forward list/insert after]]
[[pt:cpp/container/forward list/insert after]]
[[ru:cpp/container/forward list/insert after]]
[[zh:cpp/container/forward list/insert after]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/max size</title>
    <ns>0</ns>
    <id>910</id>
    <revision>
      <id>50502</id>
      <parentid>43854</parentid>
      <timestamp>2013-06-01T03:30:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="397">{{include page|cpp/container/max_size|forward_list}}

[[de:cpp/container/forward list/max size]]
[[es:cpp/container/forward list/max size]]
[[fr:cpp/container/forward list/max size]]
[[it:cpp/container/forward list/max size]]
[[ja:cpp/container/forward list/max size]]
[[pt:cpp/container/forward list/max size]]
[[ru:cpp/container/forward list/max size]]
[[zh:cpp/container/forward list/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/merge</title>
    <ns>0</ns>
    <id>911</id>
    <revision>
      <id>50503</id>
      <parentid>43848</parentid>
      <timestamp>2013-06-01T03:30:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/merge|forward_list}}

[[de:cpp/container/forward list/merge]]
[[es:cpp/container/forward list/merge]]
[[fr:cpp/container/forward list/merge]]
[[it:cpp/container/forward list/merge]]
[[ja:cpp/container/forward list/merge]]
[[pt:cpp/container/forward list/merge]]
[[ru:cpp/container/forward list/merge]]
[[zh:cpp/container/forward list/merge]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/operator=</title>
    <ns>0</ns>
    <id>912</id>
    <revision>
      <id>43841</id>
      <parentid>1825</parentid>
      <timestamp>2012-11-03T04:00:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="397">{{cpp/container/operator{{=}}|forward_list}}

[[de:cpp/container/forward list/operator=]]
[[es:cpp/container/forward list/operator=]]
[[fr:cpp/container/forward list/operator=]]
[[it:cpp/container/forward list/operator=]]
[[ja:cpp/container/forward list/operator=]]
[[pt:cpp/container/forward list/operator=]]
[[ru:cpp/container/forward list/operator=]]
[[zh:cpp/container/forward list/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/operator cmp</title>
    <ns>0</ns>
    <id>1994</id>
    <revision>
      <id>50504</id>
      <parentid>43835</parentid>
      <timestamp>2013-06-01T03:30:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/operator_cmp|forward_list}}

[[de:cpp/container/forward list/operator cmp]]
[[es:cpp/container/forward list/operator cmp]]
[[fr:cpp/container/forward list/operator cmp]]
[[it:cpp/container/forward list/operator cmp]]
[[ja:cpp/container/forward list/operator cmp]]
[[pt:cpp/container/forward list/operator cmp]]
[[ru:cpp/container/forward list/operator cmp]]
[[zh:cpp/container/forward list/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/operator comp</title>
    <ns>0</ns>
    <id>4212</id>
    <redirect title="cpp/container/forward list/operator cmp" />
    <revision>
      <id>15241</id>
      <timestamp>2011-12-08T01:11:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/forward list/operator comp]] to [[cpp/container/forward list/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[cpp/container/forward list/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/pop front</title>
    <ns>0</ns>
    <id>913</id>
    <revision>
      <id>50505</id>
      <parentid>43828</parentid>
      <timestamp>2013-06-01T03:30:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/pop_front|forward_list}}

[[de:cpp/container/forward list/pop front]]
[[es:cpp/container/forward list/pop front]]
[[fr:cpp/container/forward list/pop front]]
[[it:cpp/container/forward list/pop front]]
[[ja:cpp/container/forward list/pop front]]
[[pt:cpp/container/forward list/pop front]]
[[ru:cpp/container/forward list/pop front]]
[[zh:cpp/container/forward list/pop front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/push front</title>
    <ns>0</ns>
    <id>914</id>
    <revision>
      <id>50506</id>
      <parentid>43823</parentid>
      <timestamp>2013-06-01T03:30:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/push_front|forward_list}}

[[de:cpp/container/forward list/push front]]
[[es:cpp/container/forward list/push front]]
[[fr:cpp/container/forward list/push front]]
[[it:cpp/container/forward list/push front]]
[[ja:cpp/container/forward list/push front]]
[[pt:cpp/container/forward list/push front]]
[[ru:cpp/container/forward list/push front]]
[[zh:cpp/container/forward list/push front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/remove</title>
    <ns>0</ns>
    <id>915</id>
    <revision>
      <id>50507</id>
      <parentid>43818</parentid>
      <timestamp>2013-06-01T03:30:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/remove|forward_list}}

[[de:cpp/container/forward list/remove]]
[[es:cpp/container/forward list/remove]]
[[fr:cpp/container/forward list/remove]]
[[it:cpp/container/forward list/remove]]
[[ja:cpp/container/forward list/remove]]
[[pt:cpp/container/forward list/remove]]
[[ru:cpp/container/forward list/remove]]
[[zh:cpp/container/forward list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/remove if</title>
    <ns>0</ns>
    <id>916</id>
    <redirect title="cpp/container/forward list/remove" />
    <revision>
      <id>9321</id>
      <parentid>9320</parentid>
      <timestamp>2011-08-21T16:14:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/container/forward_list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/resize</title>
    <ns>0</ns>
    <id>917</id>
    <revision>
      <id>50508</id>
      <parentid>43812</parentid>
      <timestamp>2013-06-01T03:30:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/resize|forward_list}}

[[de:cpp/container/forward list/resize]]
[[es:cpp/container/forward list/resize]]
[[fr:cpp/container/forward list/resize]]
[[it:cpp/container/forward list/resize]]
[[ja:cpp/container/forward list/resize]]
[[pt:cpp/container/forward list/resize]]
[[ru:cpp/container/forward list/resize]]
[[zh:cpp/container/forward list/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/reverse</title>
    <ns>0</ns>
    <id>918</id>
    <revision>
      <id>50509</id>
      <parentid>43807</parentid>
      <timestamp>2013-06-01T03:31:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/reverse|forward_list}}

[[de:cpp/container/forward list/reverse]]
[[es:cpp/container/forward list/reverse]]
[[fr:cpp/container/forward list/reverse]]
[[it:cpp/container/forward list/reverse]]
[[ja:cpp/container/forward list/reverse]]
[[pt:cpp/container/forward list/reverse]]
[[ru:cpp/container/forward list/reverse]]
[[zh:cpp/container/forward list/reverse]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/sort</title>
    <ns>0</ns>
    <id>919</id>
    <revision>
      <id>50510</id>
      <parentid>43801</parentid>
      <timestamp>2013-06-01T03:31:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/sort|forward_list}}

[[de:cpp/container/forward list/sort]]
[[es:cpp/container/forward list/sort]]
[[fr:cpp/container/forward list/sort]]
[[it:cpp/container/forward list/sort]]
[[ja:cpp/container/forward list/sort]]
[[pt:cpp/container/forward list/sort]]
[[ru:cpp/container/forward list/sort]]
[[zh:cpp/container/forward list/sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/splice after</title>
    <ns>0</ns>
    <id>2448</id>
    <revision>
      <id>68832</id>
      <parentid>65061</parentid>
      <timestamp>2014-03-22T16:26:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>no effect for same-position single-element splice</comment>
      <text xml:space="preserve" bytes="3728">{{cpp/container/forward_list/title | splice_after}}
{{cpp/container/forward_list/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp; other );
}}
{{dcl | num=1 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp;&amp; other );
}}
{{dcl | num=2 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp; other, 
                   const_iterator it );
}}
{{dcl | num=2 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp;&amp; other,
                   const_iterator it );
}}
{{dcl | num=3 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp; other, 
                   const_iterator first, const_iterator last );
}}
{{dcl | num=3 | since=c++11 |
void splice_after( const_iterator pos, forward_list&amp;&amp; other, 
                   const_iterator first, const_iterator last );
}}
{{dcl end}}

Moves elements from another {{tt|forward_list}} to {{c|*this}}.

No elements are copied. {{tt|pos}} is a valid iterator in {{c|*this}} or is the {{c|before_begin()}} iterator. The behavior is undefined if {{c|get_allocator() !{{=}} other.get_allocator()}}. No iterators or references become invalidated, the iterators to the moved elements now refer into {{c|*this}}, not into {{tt|other}}.

@1@ Moves all elements from {{tt|other}} into {{c|*this}}. The elements are inserted after the element pointed to by {{tt|pos}}. The container {{tt|other}} becomes empty after the operation. The behavior is undefined if {{c|this {{==}} &amp;other}}

@2@ Moves the element pointed to by the iterator following {{tt|it}} from {{tt|other}} into {{c|*this}}. The element is inserted after the element pointed to by {{tt|pos}}. Has no effect if {{tt|pos{{==}}it}} or if {{tt|pos{{==}}++it}}.

@3@ Moves the elements in the range {{tt|(first, last)}} from {{tt|other}} into {{c|*this}}. The elements are inserted after the element pointed to by {{tt|pos}}. The element pointed-to by {{tt|first}} is not moved. The behavior is undefined if {{tt|pos}} is an iterator in the range {{tt|(first,last)}}.

===Parameters===
{{par begin}}
{{par | pos | element after which the content will be inserted }}
{{par | other | another container to move the content from}}
{{par | it | iterator preceding the iterator to the element to move from {{tt|other}} to {{c|*this}}}}
{{par | first, last | the range of elements to move from {{tt|other}} to {{c|*this}}}}
{{par end}} 

===Return value===
(none)

===Complexity===
@1@ Linear in the size of {{tt|other}}

@2@ Constant

@3@ Linear in {{c|std::distance(first, last)}}

===Example===
{{example
 | Demonstrates the meaning of open interval (first, last) in the third form of splice_after(): the first element of l1 is not moved.
 | code =
#include &lt;iostream&gt;
#include &lt;forward_list&gt;

int main()
{
    std::forward_list&lt;int&gt; l1 = {1,2,3,4,5};
    std::forward_list&lt;int&gt; l2 = {10,11,12};

    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // not equivalent to l2.splice_after(l2.cbegin(), l1);

    for(int n : l1)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    for(int n : l2)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
1
10 2 3 4 5 11 12
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc merge |forward_list}}
{{dsc inc | cpp/container/dsc remove |forward_list}}
{{dsc end}}

[[de:cpp/container/forward list/splice after]]
[[es:cpp/container/forward list/splice after]]
[[fr:cpp/container/forward list/splice after]]
[[it:cpp/container/forward list/splice after]]
[[ja:cpp/container/forward list/splice after]]
[[pt:cpp/container/forward list/splice after]]
[[ru:cpp/container/forward list/splice after]]
[[zh:cpp/container/forward list/splice after]]</text>
      <sha1>q6rdi8aeds2h8k35s01r0e705hpzyol</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/std swap</title>
    <ns>0</ns>
    <id>3459</id>
    <redirect title="cpp/container/forward list/swap2" />
    <revision>
      <id>13007</id>
      <timestamp>2011-11-03T18:38:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/forward list/std swap]] to [[cpp/container/forward list/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/container/forward list/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/swap</title>
    <ns>0</ns>
    <id>921</id>
    <revision>
      <id>50512</id>
      <parentid>43788</parentid>
      <timestamp>2013-06-01T03:31:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/swap|forward_list}}

[[de:cpp/container/forward list/swap]]
[[es:cpp/container/forward list/swap]]
[[fr:cpp/container/forward list/swap]]
[[it:cpp/container/forward list/swap]]
[[ja:cpp/container/forward list/swap]]
[[pt:cpp/container/forward list/swap]]
[[ru:cpp/container/forward list/swap]]
[[zh:cpp/container/forward list/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/swap2</title>
    <ns>0</ns>
    <id>1990</id>
    <revision>
      <id>50513</id>
      <parentid>43781</parentid>
      <timestamp>2013-06-01T03:31:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/swap2|forward_list}}

[[de:cpp/container/forward list/swap2]]
[[es:cpp/container/forward list/swap2]]
[[fr:cpp/container/forward list/swap2]]
[[it:cpp/container/forward list/swap2]]
[[ja:cpp/container/forward list/swap2]]
[[pt:cpp/container/forward list/swap2]]
[[ru:cpp/container/forward list/swap2]]
[[zh:cpp/container/forward list/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/unique</title>
    <ns>0</ns>
    <id>922</id>
    <revision>
      <id>50514</id>
      <parentid>43776</parentid>
      <timestamp>2013-06-01T03:31:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/unique|forward_list}}

[[de:cpp/container/forward list/unique]]
[[es:cpp/container/forward list/unique]]
[[fr:cpp/container/forward list/unique]]
[[it:cpp/container/forward list/unique]]
[[ja:cpp/container/forward list/unique]]
[[pt:cpp/container/forward list/unique]]
[[ru:cpp/container/forward list/unique]]
[[zh:cpp/container/forward list/unique]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/forward list/~forward list</title>
    <ns>0</ns>
    <id>923</id>
    <revision>
      <id>50515</id>
      <parentid>43770</parentid>
      <timestamp>2013-06-01T03:31:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="439">{{include page|cpp/container/destructor|forward_list}}

[[de:cpp/container/forward list/~forward list]]
[[es:cpp/container/forward list/~forward list]]
[[fr:cpp/container/forward list/~forward list]]
[[it:cpp/container/forward list/~forward list]]
[[ja:cpp/container/forward list/~forward list]]
[[pt:cpp/container/forward list/~forward list]]
[[ru:cpp/container/forward list/~forward list]]
[[zh:cpp/container/forward list/~forward list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list</title>
    <ns>0</ns>
    <id>924</id>
    <revision>
      <id>71666</id>
      <parentid>64490</parentid>
      <timestamp>2014-06-18T22:18:13Z</timestamp>
      <contributor>
        <ip>130.216.21.211</ip>
      </contributor>
      <comment>Added that references are also not invalidated</comment>
      <text xml:space="preserve" bytes="3821">{{cpp/title|list}}
{{cpp/container/list/navbar}}
{{ddcl | header=list |
template&lt;
    class T,
    class Allocator {{=}} std::allocator&lt;T&gt;
&gt; class list;
}} 

{{tt|std::list}} is a container that supports constant time insertion and removal of elements from anywhere in the container. Fast random access is not supported. It is usually implemented as double-linked list. Compared to {{lc|std::forward_list}} this container provides bidirectional iteration capability while being less space efficient.

Addition, removal and moving the elements within the list or across several lists does not invalidate the iterators or references. An iterator is invalidated only when the corresponding element is deleted.

{{tt|std::list}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|SequenceContainer}} and {{concept|ReversibleContainer}}.

===Template parameters===
{{par begin}}
{{par inc | cpp/container/param list T | deque}}
{{par inc | cpp/container/param list Allocator | deque}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | list}}
{{dsc inc | cpp/container/dsc allocator_type | list}}
{{dsc inc | cpp/container/dsc size_type | list}}
{{dsc inc | cpp/container/dsc difference_type | list}}
{{dsc inc | cpp/container/dsc reference | list}}
{{dsc inc | cpp/container/dsc const_reference | list}}
{{dsc inc | cpp/container/dsc pointer | list}}
{{dsc inc | cpp/container/dsc const_pointer | list}}
{{dsc inc | cpp/container/dsc iterator | list}}
{{dsc inc | cpp/container/dsc const_iterator | list}}
{{dsc inc | cpp/container/dsc reverse_iterator | list}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | list}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | list}}
{{dsc inc | cpp/container/dsc destructor | list}}
{{dsc inc | cpp/container/dsc operator{{=}} | list}}
{{dsc inc | cpp/container/dsc assign | list}}
{{dsc inc | cpp/container/dsc get_allocator | list}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc front | list}}
{{dsc inc | cpp/container/dsc back | list}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | list}}
{{dsc inc | cpp/container/dsc end | list}}
{{dsc inc | cpp/container/dsc rbegin | list}}
{{dsc inc | cpp/container/dsc rend | list}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | list}}
{{dsc inc | cpp/container/dsc size | list}}
{{dsc inc | cpp/container/dsc max_size | list}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | list}}
{{dsc inc | cpp/container/dsc insert | list}}
{{dsc inc | cpp/container/dsc emplace | list}}
{{dsc inc | cpp/container/dsc erase | list}}
{{dsc inc | cpp/container/dsc push_back | list}}
{{dsc inc | cpp/container/dsc emplace_back | list}}
{{dsc inc | cpp/container/dsc pop_back | list}}
{{dsc inc | cpp/container/dsc push_front | list}}
{{dsc inc | cpp/container/dsc emplace_front | list}}
{{dsc inc | cpp/container/dsc pop_front | list}}
{{dsc inc | cpp/container/dsc resize | list}}
{{dsc inc | cpp/container/dsc swap | list}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/container/dsc merge | list}}
{{dsc inc | cpp/container/dsc splice | list}}
{{dsc inc | cpp/container/dsc remove | list}}
{{dsc inc | cpp/container/dsc reverse | list}}
{{dsc inc | cpp/container/dsc unique | list}}
{{dsc inc | cpp/container/dsc sort | list}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | list}}
{{dsc inc | cpp/container/dsc swap2 | list}}
{{dsc end}}

[[de:cpp/container/list]]
[[es:cpp/container/list]]
[[fr:cpp/container/list]]
[[it:cpp/container/list]]
[[ja:cpp/container/list]]
[[ko:cpp/container/list]]
[[pt:cpp/container/list]]
[[ru:cpp/container/list]]
[[zh:cpp/container/list]]</text>
      <sha1>3lm0z8y6krvp12rw1d7ajagpxt7s4kt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/assign</title>
    <ns>0</ns>
    <id>925</id>
    <revision>
      <id>50516</id>
      <parentid>43757</parentid>
      <timestamp>2013-06-01T03:31:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/assign|list}}

[[de:cpp/container/list/assign]]
[[es:cpp/container/list/assign]]
[[fr:cpp/container/list/assign]]
[[it:cpp/container/list/assign]]
[[ja:cpp/container/list/assign]]
[[pt:cpp/container/list/assign]]
[[ru:cpp/container/list/assign]]
[[zh:cpp/container/list/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/back</title>
    <ns>0</ns>
    <id>926</id>
    <revision>
      <id>50517</id>
      <parentid>43751</parentid>
      <timestamp>2013-06-01T03:31:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/back|list}}

[[de:cpp/container/list/back]]
[[es:cpp/container/list/back]]
[[fr:cpp/container/list/back]]
[[it:cpp/container/list/back]]
[[ja:cpp/container/list/back]]
[[pt:cpp/container/list/back]]
[[ru:cpp/container/list/back]]
[[zh:cpp/container/list/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/begin</title>
    <ns>0</ns>
    <id>927</id>
    <revision>
      <id>50518</id>
      <parentid>43745</parentid>
      <timestamp>2013-06-01T03:31:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/begin|list}}

[[de:cpp/container/list/begin]]
[[es:cpp/container/list/begin]]
[[fr:cpp/container/list/begin]]
[[it:cpp/container/list/begin]]
[[ja:cpp/container/list/begin]]
[[pt:cpp/container/list/begin]]
[[ru:cpp/container/list/begin]]
[[zh:cpp/container/list/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/clear</title>
    <ns>0</ns>
    <id>928</id>
    <revision>
      <id>50519</id>
      <parentid>43739</parentid>
      <timestamp>2013-06-01T03:31:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/clear|list}}

[[de:cpp/container/list/clear]]
[[es:cpp/container/list/clear]]
[[fr:cpp/container/list/clear]]
[[it:cpp/container/list/clear]]
[[ja:cpp/container/list/clear]]
[[pt:cpp/container/list/clear]]
[[ru:cpp/container/list/clear]]
[[zh:cpp/container/list/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/emplace</title>
    <ns>0</ns>
    <id>929</id>
    <revision>
      <id>50520</id>
      <parentid>43736</parentid>
      <timestamp>2013-06-01T03:31:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/emplace|list}}

[[de:cpp/container/list/emplace]]
[[es:cpp/container/list/emplace]]
[[fr:cpp/container/list/emplace]]
[[it:cpp/container/list/emplace]]
[[ja:cpp/container/list/emplace]]
[[pt:cpp/container/list/emplace]]
[[ru:cpp/container/list/emplace]]
[[zh:cpp/container/list/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/emplace back</title>
    <ns>0</ns>
    <id>930</id>
    <revision>
      <id>50521</id>
      <parentid>43728</parentid>
      <timestamp>2013-06-01T03:31:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/emplace_back|list}}

[[de:cpp/container/list/emplace back]]
[[es:cpp/container/list/emplace back]]
[[fr:cpp/container/list/emplace back]]
[[it:cpp/container/list/emplace back]]
[[ja:cpp/container/list/emplace back]]
[[pt:cpp/container/list/emplace back]]
[[ru:cpp/container/list/emplace back]]
[[zh:cpp/container/list/emplace back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/emplace front</title>
    <ns>0</ns>
    <id>931</id>
    <revision>
      <id>50522</id>
      <parentid>43721</parentid>
      <timestamp>2013-06-01T03:31:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/emplace_front|list}}

[[de:cpp/container/list/emplace front]]
[[es:cpp/container/list/emplace front]]
[[fr:cpp/container/list/emplace front]]
[[it:cpp/container/list/emplace front]]
[[ja:cpp/container/list/emplace front]]
[[pt:cpp/container/list/emplace front]]
[[ru:cpp/container/list/emplace front]]
[[zh:cpp/container/list/emplace front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/empty</title>
    <ns>0</ns>
    <id>932</id>
    <revision>
      <id>50523</id>
      <parentid>43715</parentid>
      <timestamp>2013-06-01T03:31:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/empty|list}}

[[de:cpp/container/list/empty]]
[[es:cpp/container/list/empty]]
[[fr:cpp/container/list/empty]]
[[it:cpp/container/list/empty]]
[[ja:cpp/container/list/empty]]
[[pt:cpp/container/list/empty]]
[[ru:cpp/container/list/empty]]
[[zh:cpp/container/list/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/end</title>
    <ns>0</ns>
    <id>933</id>
    <revision>
      <id>50524</id>
      <parentid>43709</parentid>
      <timestamp>2013-06-01T03:31:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/end|list}}

[[de:cpp/container/list/end]]
[[es:cpp/container/list/end]]
[[fr:cpp/container/list/end]]
[[it:cpp/container/list/end]]
[[ja:cpp/container/list/end]]
[[pt:cpp/container/list/end]]
[[ru:cpp/container/list/end]]
[[zh:cpp/container/list/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/erase</title>
    <ns>0</ns>
    <id>934</id>
    <revision>
      <id>50525</id>
      <parentid>43702</parentid>
      <timestamp>2013-06-01T03:31:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/erase|list}}

[[de:cpp/container/list/erase]]
[[es:cpp/container/list/erase]]
[[fr:cpp/container/list/erase]]
[[it:cpp/container/list/erase]]
[[ja:cpp/container/list/erase]]
[[pt:cpp/container/list/erase]]
[[ru:cpp/container/list/erase]]
[[zh:cpp/container/list/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/front</title>
    <ns>0</ns>
    <id>935</id>
    <revision>
      <id>50526</id>
      <parentid>43696</parentid>
      <timestamp>2013-06-01T03:31:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/front|list}}

[[de:cpp/container/list/front]]
[[es:cpp/container/list/front]]
[[fr:cpp/container/list/front]]
[[it:cpp/container/list/front]]
[[ja:cpp/container/list/front]]
[[pt:cpp/container/list/front]]
[[ru:cpp/container/list/front]]
[[zh:cpp/container/list/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/get allocator</title>
    <ns>0</ns>
    <id>936</id>
    <revision>
      <id>50527</id>
      <parentid>43691</parentid>
      <timestamp>2013-06-01T03:31:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/get_allocator|list}}

[[de:cpp/container/list/get allocator]]
[[es:cpp/container/list/get allocator]]
[[fr:cpp/container/list/get allocator]]
[[it:cpp/container/list/get allocator]]
[[ja:cpp/container/list/get allocator]]
[[pt:cpp/container/list/get allocator]]
[[ru:cpp/container/list/get allocator]]
[[zh:cpp/container/list/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/insert</title>
    <ns>0</ns>
    <id>937</id>
    <revision>
      <id>50528</id>
      <parentid>43685</parentid>
      <timestamp>2013-06-01T03:31:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/insert|list}}

[[de:cpp/container/list/insert]]
[[es:cpp/container/list/insert]]
[[fr:cpp/container/list/insert]]
[[it:cpp/container/list/insert]]
[[ja:cpp/container/list/insert]]
[[pt:cpp/container/list/insert]]
[[ru:cpp/container/list/insert]]
[[zh:cpp/container/list/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/list</title>
    <ns>0</ns>
    <id>938</id>
    <revision>
      <id>50529</id>
      <parentid>43678</parentid>
      <timestamp>2013-06-01T03:31:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="297">{{include page|cpp/container/constructor |list}}

[[de:cpp/container/list/list]]
[[es:cpp/container/list/list]]
[[fr:cpp/container/list/list]]
[[it:cpp/container/list/list]]
[[ja:cpp/container/list/list]]
[[pt:cpp/container/list/list]]
[[ru:cpp/container/list/list]]
[[zh:cpp/container/list/list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/max size</title>
    <ns>0</ns>
    <id>939</id>
    <revision>
      <id>50530</id>
      <parentid>43672</parentid>
      <timestamp>2013-06-01T03:31:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/max_size|list}}

[[de:cpp/container/list/max size]]
[[es:cpp/container/list/max size]]
[[fr:cpp/container/list/max size]]
[[it:cpp/container/list/max size]]
[[ja:cpp/container/list/max size]]
[[pt:cpp/container/list/max size]]
[[ru:cpp/container/list/max size]]
[[zh:cpp/container/list/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/merge</title>
    <ns>0</ns>
    <id>940</id>
    <revision>
      <id>50531</id>
      <parentid>43666</parentid>
      <timestamp>2013-06-01T03:31:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/merge|list}}

[[de:cpp/container/list/merge]]
[[es:cpp/container/list/merge]]
[[fr:cpp/container/list/merge]]
[[it:cpp/container/list/merge]]
[[ja:cpp/container/list/merge]]
[[pt:cpp/container/list/merge]]
[[ru:cpp/container/list/merge]]
[[zh:cpp/container/list/merge]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/operator=</title>
    <ns>0</ns>
    <id>941</id>
    <revision>
      <id>43660</id>
      <parentid>1883</parentid>
      <timestamp>2012-11-03T03:25:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="325">{{cpp/container/operator{{=}}|list}}

[[de:cpp/container/list/operator=]]
[[es:cpp/container/list/operator=]]
[[fr:cpp/container/list/operator=]]
[[it:cpp/container/list/operator=]]
[[ja:cpp/container/list/operator=]]
[[pt:cpp/container/list/operator=]]
[[ru:cpp/container/list/operator=]]
[[zh:cpp/container/list/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/operator cmp</title>
    <ns>0</ns>
    <id>1995</id>
    <revision>
      <id>50532</id>
      <parentid>43654</parentid>
      <timestamp>2013-06-01T03:31:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/operator_cmp|list}}

[[de:cpp/container/list/operator cmp]]
[[es:cpp/container/list/operator cmp]]
[[fr:cpp/container/list/operator cmp]]
[[it:cpp/container/list/operator cmp]]
[[ja:cpp/container/list/operator cmp]]
[[pt:cpp/container/list/operator cmp]]
[[ru:cpp/container/list/operator cmp]]
[[zh:cpp/container/list/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/operator comp</title>
    <ns>0</ns>
    <id>4213</id>
    <redirect title="cpp/container/list/operator cmp" />
    <revision>
      <id>15243</id>
      <timestamp>2011-12-08T01:11:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/list/operator comp]] to [[cpp/container/list/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/container/list/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/pop back</title>
    <ns>0</ns>
    <id>942</id>
    <revision>
      <id>50533</id>
      <parentid>43649</parentid>
      <timestamp>2013-06-01T03:31:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/pop_back|list}}

[[de:cpp/container/list/pop back]]
[[es:cpp/container/list/pop back]]
[[fr:cpp/container/list/pop back]]
[[it:cpp/container/list/pop back]]
[[ja:cpp/container/list/pop back]]
[[pt:cpp/container/list/pop back]]
[[ru:cpp/container/list/pop back]]
[[zh:cpp/container/list/pop back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/pop front</title>
    <ns>0</ns>
    <id>943</id>
    <revision>
      <id>50534</id>
      <parentid>43643</parentid>
      <timestamp>2013-06-01T03:31:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/pop_front|list}}

[[de:cpp/container/list/pop front]]
[[es:cpp/container/list/pop front]]
[[fr:cpp/container/list/pop front]]
[[it:cpp/container/list/pop front]]
[[ja:cpp/container/list/pop front]]
[[pt:cpp/container/list/pop front]]
[[ru:cpp/container/list/pop front]]
[[zh:cpp/container/list/pop front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/push back</title>
    <ns>0</ns>
    <id>944</id>
    <revision>
      <id>50535</id>
      <parentid>43636</parentid>
      <timestamp>2013-06-01T03:31:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/push_back|list}}

[[de:cpp/container/list/push back]]
[[es:cpp/container/list/push back]]
[[fr:cpp/container/list/push back]]
[[it:cpp/container/list/push back]]
[[ja:cpp/container/list/push back]]
[[pt:cpp/container/list/push back]]
[[ru:cpp/container/list/push back]]
[[zh:cpp/container/list/push back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/push front</title>
    <ns>0</ns>
    <id>945</id>
    <revision>
      <id>50536</id>
      <parentid>43630</parentid>
      <timestamp>2013-06-01T03:31:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/push_front|list}}

[[de:cpp/container/list/push front]]
[[es:cpp/container/list/push front]]
[[fr:cpp/container/list/push front]]
[[it:cpp/container/list/push front]]
[[ja:cpp/container/list/push front]]
[[pt:cpp/container/list/push front]]
[[ru:cpp/container/list/push front]]
[[zh:cpp/container/list/push front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/rbegin</title>
    <ns>0</ns>
    <id>946</id>
    <revision>
      <id>50537</id>
      <parentid>43623</parentid>
      <timestamp>2013-06-01T03:31:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/rbegin|list}}

[[de:cpp/container/list/rbegin]]
[[es:cpp/container/list/rbegin]]
[[fr:cpp/container/list/rbegin]]
[[it:cpp/container/list/rbegin]]
[[ja:cpp/container/list/rbegin]]
[[pt:cpp/container/list/rbegin]]
[[ru:cpp/container/list/rbegin]]
[[zh:cpp/container/list/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/remove</title>
    <ns>0</ns>
    <id>947</id>
    <revision>
      <id>50538</id>
      <parentid>43617</parentid>
      <timestamp>2013-06-01T03:32:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/remove|list}}

[[de:cpp/container/list/remove]]
[[es:cpp/container/list/remove]]
[[fr:cpp/container/list/remove]]
[[it:cpp/container/list/remove]]
[[ja:cpp/container/list/remove]]
[[pt:cpp/container/list/remove]]
[[ru:cpp/container/list/remove]]
[[zh:cpp/container/list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/remove if</title>
    <ns>0</ns>
    <id>948</id>
    <redirect title="cpp/container/list/remove" />
    <revision>
      <id>9322</id>
      <parentid>1897</parentid>
      <timestamp>2011-08-21T16:14:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>redirect to remove</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/container/list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/rend</title>
    <ns>0</ns>
    <id>949</id>
    <revision>
      <id>50539</id>
      <parentid>43611</parentid>
      <timestamp>2013-06-01T03:32:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/rend|list}}

[[de:cpp/container/list/rend]]
[[es:cpp/container/list/rend]]
[[fr:cpp/container/list/rend]]
[[it:cpp/container/list/rend]]
[[ja:cpp/container/list/rend]]
[[pt:cpp/container/list/rend]]
[[ru:cpp/container/list/rend]]
[[zh:cpp/container/list/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/resize</title>
    <ns>0</ns>
    <id>950</id>
    <revision>
      <id>50540</id>
      <parentid>43606</parentid>
      <timestamp>2013-06-01T03:32:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/resize|list}}

[[de:cpp/container/list/resize]]
[[es:cpp/container/list/resize]]
[[fr:cpp/container/list/resize]]
[[it:cpp/container/list/resize]]
[[ja:cpp/container/list/resize]]
[[pt:cpp/container/list/resize]]
[[ru:cpp/container/list/resize]]
[[zh:cpp/container/list/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/reverse</title>
    <ns>0</ns>
    <id>951</id>
    <revision>
      <id>50541</id>
      <parentid>43600</parentid>
      <timestamp>2013-06-01T03:32:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/reverse|list}}

[[de:cpp/container/list/reverse]]
[[es:cpp/container/list/reverse]]
[[fr:cpp/container/list/reverse]]
[[it:cpp/container/list/reverse]]
[[ja:cpp/container/list/reverse]]
[[pt:cpp/container/list/reverse]]
[[ru:cpp/container/list/reverse]]
[[zh:cpp/container/list/reverse]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/size</title>
    <ns>0</ns>
    <id>952</id>
    <revision>
      <id>64980</id>
      <parentid>64979</parentid>
      <timestamp>2013-08-28T22:21:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1289">{{cpp/container/list/title | size}}
{{cpp/container/list/navbar}}
{{dcl begin}}
{{dcl |
size_type size() const;
}}
{{dcl end}}

Returns the number of elements in the container, i.e. {{c|std::distance(begin(), end())}}.

===Parameters===
(none)

===Return value===
The number of elements in the container.

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Complexity===
{{rev begin}}
{{rev | until=c++11 | Constant or linear.}}
{{rev | since=c++11 | Constant.}}
{{rev end}}

===Example===
{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::list}}:
 | code=
#include &lt;list&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::list&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc empty |list}}
{{dsc inc | cpp/container/dsc max_size |list}}
{{dsc inc | cpp/container/dsc resize |list}}
{{dsc end}}

[[de:cpp/container/list/size]]
[[es:cpp/container/list/size]]
[[fr:cpp/container/list/size]]
[[it:cpp/container/list/size]]
[[ja:cpp/container/list/size]]
[[pt:cpp/container/list/size]]
[[ru:cpp/container/list/size]]
[[zh:cpp/container/list/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/sort</title>
    <ns>0</ns>
    <id>953</id>
    <revision>
      <id>50543</id>
      <parentid>43588</parentid>
      <timestamp>2013-06-01T03:32:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/sort|list}}

[[de:cpp/container/list/sort]]
[[es:cpp/container/list/sort]]
[[fr:cpp/container/list/sort]]
[[it:cpp/container/list/sort]]
[[ja:cpp/container/list/sort]]
[[pt:cpp/container/list/sort]]
[[ru:cpp/container/list/sort]]
[[zh:cpp/container/list/sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/splice</title>
    <ns>0</ns>
    <id>954</id>
    <revision>
      <id>50544</id>
      <parentid>43582</parentid>
      <timestamp>2013-06-01T03:32:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/splice|list}}

[[de:cpp/container/list/splice]]
[[es:cpp/container/list/splice]]
[[fr:cpp/container/list/splice]]
[[it:cpp/container/list/splice]]
[[ja:cpp/container/list/splice]]
[[pt:cpp/container/list/splice]]
[[ru:cpp/container/list/splice]]
[[zh:cpp/container/list/splice]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/std swap</title>
    <ns>0</ns>
    <id>3460</id>
    <redirect title="cpp/container/list/swap2" />
    <revision>
      <id>13009</id>
      <timestamp>2011-11-03T18:38:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/list/std swap]] to [[cpp/container/list/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/container/list/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/swap</title>
    <ns>0</ns>
    <id>955</id>
    <revision>
      <id>50545</id>
      <parentid>43576</parentid>
      <timestamp>2013-06-01T03:32:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/swap|list}}

[[de:cpp/container/list/swap]]
[[es:cpp/container/list/swap]]
[[fr:cpp/container/list/swap]]
[[it:cpp/container/list/swap]]
[[ja:cpp/container/list/swap]]
[[pt:cpp/container/list/swap]]
[[ru:cpp/container/list/swap]]
[[zh:cpp/container/list/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/swap2</title>
    <ns>0</ns>
    <id>1991</id>
    <revision>
      <id>50546</id>
      <parentid>43569</parentid>
      <timestamp>2013-06-01T03:32:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/swap2|list}}

[[de:cpp/container/list/swap2]]
[[es:cpp/container/list/swap2]]
[[fr:cpp/container/list/swap2]]
[[it:cpp/container/list/swap2]]
[[ja:cpp/container/list/swap2]]
[[pt:cpp/container/list/swap2]]
[[ru:cpp/container/list/swap2]]
[[zh:cpp/container/list/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/unique</title>
    <ns>0</ns>
    <id>956</id>
    <revision>
      <id>50547</id>
      <parentid>43563</parentid>
      <timestamp>2013-06-01T03:32:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/unique|list}}

[[de:cpp/container/list/unique]]
[[es:cpp/container/list/unique]]
[[fr:cpp/container/list/unique]]
[[it:cpp/container/list/unique]]
[[ja:cpp/container/list/unique]]
[[pt:cpp/container/list/unique]]
[[ru:cpp/container/list/unique]]
[[zh:cpp/container/list/unique]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/list/~list</title>
    <ns>0</ns>
    <id>957</id>
    <revision>
      <id>50548</id>
      <parentid>43556</parentid>
      <timestamp>2013-06-01T03:32:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="303">{{include page|cpp/container/destructor|list}}

[[de:cpp/container/list/~list]]
[[es:cpp/container/list/~list]]
[[fr:cpp/container/list/~list]]
[[it:cpp/container/list/~list]]
[[ja:cpp/container/list/~list]]
[[pt:cpp/container/list/~list]]
[[ru:cpp/container/list/~list]]
[[zh:cpp/container/list/~list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map</title>
    <ns>0</ns>
    <id>958</id>
    <revision>
      <id>57282</id>
      <parentid>49442</parentid>
      <timestamp>2013-06-01T05:50:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3448">{{cpp/title|map}}
{{cpp/container/map/navbar}}
{{ddcl | header=map |
template&lt;
    class Key,
    class T,
    class Compare {{=}} std::less&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt;
&gt; class map;
}} 

{{tt|std::map}} is a sorted associative container that contains key-value pairs with unique keys. Keys are sorted by using the comparison function {{tt|Compare}}.  Search, removal, and insertion operations have logarithmic complexity. Maps are usually implemented as [[enwiki:Red–black_tree|red-black trees]].

{{tt|std::map}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|AssociativeContainer}} and {{concept|ReversibleContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | map}}
{{dsc inc | cpp/container/dsc mapped_type | map}}
{{dsc inc | cpp/container/dsc value_type | map}}
{{dsc inc | cpp/container/dsc size_type | map}}
{{dsc inc | cpp/container/dsc difference_type | map}}
{{dsc inc | cpp/container/dsc key_compare | map}}
{{dsc inc | cpp/container/dsc allocator_type | map}}
{{dsc inc | cpp/container/dsc reference | map}}
{{dsc inc | cpp/container/dsc const_reference | map}}
{{dsc inc | cpp/container/dsc pointer | map}}
{{dsc inc | cpp/container/dsc const_pointer | map}}
{{dsc inc | cpp/container/dsc iterator | map}}
{{dsc inc | cpp/container/dsc const_iterator | map}}
{{dsc inc | cpp/container/dsc reverse_iterator | map}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | map}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc value_compare | map}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | map}}
{{dsc inc | cpp/container/dsc destructor | map}}
{{dsc inc | cpp/container/dsc operator{{=}} | map}}
{{dsc inc | cpp/container/dsc get_allocator | map}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | map}}
{{dsc inc | cpp/container/dsc operator_at | map}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | map}}
{{dsc inc | cpp/container/dsc end | map}}
{{dsc inc | cpp/container/dsc rbegin | map}}
{{dsc inc | cpp/container/dsc rend | map}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | map}}
{{dsc inc | cpp/container/dsc size | map}}
{{dsc inc | cpp/container/dsc max_size | map}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | map}}
{{dsc inc | cpp/container/dsc insert | map}}
{{dsc inc | cpp/container/dsc emplace | map}}
{{dsc inc | cpp/container/dsc emplace_hint | map}}
{{dsc inc | cpp/container/dsc erase | map}}
{{dsc inc | cpp/container/dsc swap | map}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | map}}
{{dsc inc | cpp/container/dsc find | map}}
{{dsc inc | cpp/container/dsc equal_range | map}}
{{dsc inc | cpp/container/dsc lower_bound | map}}
{{dsc inc | cpp/container/dsc upper_bound | map}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc key_comp | map}}
{{dsc inc | cpp/container/dsc value_comp | map}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | map}}
{{dsc inc | cpp/container/dsc swap2 | map}}
{{dsc end}}

[[de:cpp/container/map]]
[[es:cpp/container/map]]
[[fr:cpp/container/map]]
[[it:cpp/container/map]]
[[ja:cpp/container/map]]
[[pl:cpp/container/map]]
[[pt:cpp/container/map]]
[[ru:cpp/container/map]]
[[zh:cpp/container/map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/at</title>
    <ns>0</ns>
    <id>959</id>
    <revision>
      <id>50549</id>
      <parentid>43541</parentid>
      <timestamp>2013-06-01T03:32:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="268">{{include page|cpp/container/at assoc|map}}

[[de:cpp/container/map/at]]
[[es:cpp/container/map/at]]
[[fr:cpp/container/map/at]]
[[it:cpp/container/map/at]]
[[ja:cpp/container/map/at]]
[[pt:cpp/container/map/at]]
[[ru:cpp/container/map/at]]
[[zh:cpp/container/map/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/begin</title>
    <ns>0</ns>
    <id>960</id>
    <revision>
      <id>72255</id>
      <parentid>72253</parentid>
      <timestamp>2014-07-31T15:49:20Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Example */ demonstrate the use of cbegin(), not range for</comment>
      <text xml:space="preserve" bytes="852">{{include page|cpp/container/begin|map}}
===Example===
{{example
| code=
#include &lt;map&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
 
int main() {
  std::map&lt;std::string,std::string&gt; a_map;
  a_map[&quot;Geely&quot;]    = &quot;Chinese&quot;;
  a_map[&quot;Peugeot&quot;]  = &quot;French&quot;;
  a_map[&quot;Mercedes&quot;] = &quot;German&quot;;
  a_map[&quot;Toyota&quot;]   = &quot;Japanese&quot;;
  a_map[&quot;Ford&quot;]     = &quot;American&quot;;
  a_map[&quot;Fiat&quot;]     = &quot;Italian&quot;;

  for (auto it = a_map.cbegin(); it != std::next(a_map.cbegin(), 3); ++it) {
    std::cout &lt;&lt; it-&gt;first &lt;&lt; &quot; : &quot; &lt;&lt; it-&gt;second &lt;&lt; '\n';
  }
}
| output=
Fiat : Italian
Ford : American
Geely : Chinese
}}
[[de:cpp/container/map/begin]]
[[es:cpp/container/map/begin]]
[[fr:cpp/container/map/begin]]
[[it:cpp/container/map/begin]]
[[ja:cpp/container/map/begin]]
[[pt:cpp/container/map/begin]]
[[ru:cpp/container/map/begin]]
[[zh:cpp/container/map/begin]]</text>
      <sha1>mgry5b47hmv8a36cqo4mny5m9id6ufh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/clear</title>
    <ns>0</ns>
    <id>961</id>
    <revision>
      <id>50551</id>
      <parentid>43528</parentid>
      <timestamp>2013-06-01T03:32:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="320">{{include page|cpp/container/clear|map}}

[[de:cpp/container/map/clear]]
[[es:cpp/container/map/clear]]
[[fr:cpp/container/map/clear]]
[[it:cpp/container/map/clear]]
[[ja:cpp/container/map/clear]]
[[pl:cpp/container/map/clear]]
[[pt:cpp/container/map/clear]]
[[ru:cpp/container/map/clear]]
[[zh:cpp/container/map/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/count</title>
    <ns>0</ns>
    <id>962</id>
    <revision>
      <id>65126</id>
      <parentid>50552</parentid>
      <timestamp>2013-08-30T16:36:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="293">{{include page|cpp/container/count_ord|map}}

[[de:cpp/container/map/count]]
[[es:cpp/container/map/count]]
[[fr:cpp/container/map/count]]
[[it:cpp/container/map/count]]
[[ja:cpp/container/map/count]]
[[pt:cpp/container/map/count]]
[[ru:cpp/container/map/count]]
[[zh:cpp/container/map/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/emplace</title>
    <ns>0</ns>
    <id>963</id>
    <revision>
      <id>50553</id>
      <parentid>43511</parentid>
      <timestamp>2013-06-01T03:32:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="313">{{include page|cpp/container/emplace assoc|map}}

[[de:cpp/container/map/emplace]]
[[es:cpp/container/map/emplace]]
[[fr:cpp/container/map/emplace]]
[[it:cpp/container/map/emplace]]
[[ja:cpp/container/map/emplace]]
[[pt:cpp/container/map/emplace]]
[[ru:cpp/container/map/emplace]]
[[zh:cpp/container/map/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/emplace hint</title>
    <ns>0</ns>
    <id>964</id>
    <revision>
      <id>65114</id>
      <parentid>65105</parentid>
      <timestamp>2013-08-30T16:27:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1676">{{cpp/container/map/title | emplace_hint}}
{{cpp/container/map/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed.

The constructor of the element type ({{tt|value_type}}, that is, {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.

{{cpp/container/note_iterator_invalidation|map|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

If the insertion failed because the element already exists, returns an iterator to the already existing element with the equivalent key.

===Complexity===
Logarithmic in the size of the container in general, but amortized constant if the new element is inserted just before {{tt|hint}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |map}}
{{dsc inc | cpp/container/dsc insert |map}}
{{dsc end}}

[[de:cpp/container/map/emplace hint]]
[[es:cpp/container/map/emplace hint]]
[[fr:cpp/container/map/emplace hint]]
[[it:cpp/container/map/emplace hint]]
[[ja:cpp/container/map/emplace hint]]
[[pt:cpp/container/map/emplace hint]]
[[ru:cpp/container/map/emplace hint]]
[[zh:cpp/container/map/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/empty</title>
    <ns>0</ns>
    <id>965</id>
    <revision>
      <id>50555</id>
      <parentid>43500</parentid>
      <timestamp>2013-06-01T03:32:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/empty|map}}

[[de:cpp/container/map/empty]]
[[es:cpp/container/map/empty]]
[[fr:cpp/container/map/empty]]
[[it:cpp/container/map/empty]]
[[ja:cpp/container/map/empty]]
[[pt:cpp/container/map/empty]]
[[ru:cpp/container/map/empty]]
[[zh:cpp/container/map/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/end</title>
    <ns>0</ns>
    <id>966</id>
    <revision>
      <id>50556</id>
      <parentid>43491</parentid>
      <timestamp>2013-06-01T03:32:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="271">{{include page|cpp/container/end|map}}

[[de:cpp/container/map/end]]
[[es:cpp/container/map/end]]
[[fr:cpp/container/map/end]]
[[it:cpp/container/map/end]]
[[ja:cpp/container/map/end]]
[[pt:cpp/container/map/end]]
[[ru:cpp/container/map/end]]
[[zh:cpp/container/map/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/equal range</title>
    <ns>0</ns>
    <id>967</id>
    <revision>
      <id>65093</id>
      <parentid>65079</parentid>
      <timestamp>2013-08-30T15:58:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="347">{{include page|cpp/container/equal_range_ord|map}}

[[de:cpp/container/map/equal range]]
[[es:cpp/container/map/equal range]]
[[fr:cpp/container/map/equal range]]
[[it:cpp/container/map/equal range]]
[[ja:cpp/container/map/equal range]]
[[pt:cpp/container/map/equal range]]
[[ru:cpp/container/map/equal range]]
[[zh:cpp/container/map/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/erase</title>
    <ns>0</ns>
    <id>968</id>
    <revision>
      <id>50558</id>
      <parentid>43476</parentid>
      <timestamp>2013-06-01T03:32:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="295">{{include page|cpp/container/erase assoc|map}}

[[de:cpp/container/map/erase]]
[[es:cpp/container/map/erase]]
[[fr:cpp/container/map/erase]]
[[it:cpp/container/map/erase]]
[[ja:cpp/container/map/erase]]
[[pt:cpp/container/map/erase]]
[[ru:cpp/container/map/erase]]
[[zh:cpp/container/map/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/find</title>
    <ns>0</ns>
    <id>969</id>
    <revision>
      <id>65563</id>
      <parentid>65562</parentid>
      <timestamp>2013-09-19T18:32:19Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>avoid lines beginning with &quot;C:&quot;, which tricks our coliru extension into thinking it's compiler output</comment>
      <text xml:space="preserve" bytes="982">{{include page|cpp/container/find|map}}


===Example===

{{example
 | Demonstrates the risk of accessing non-existing elements via operator [].
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;map&gt;

int main()
{
    std::map&lt;std::string,int&gt; my_map;
    my_map[&quot;x&quot;] =  11;
    my_map[&quot;y&quot;] = 23;
    
    auto it = my_map.find(&quot;x&quot;);
    if (it != my_map.end()) std::cout &lt;&lt; &quot;x: &quot; &lt;&lt; it-&gt;second &lt;&lt; &quot;\n&quot;;

    it = my_map.find(&quot;z&quot;);
    if (it != my_map.end()) std::cout &lt;&lt; &quot;z1: &quot; &lt;&lt; it-&gt;second &lt;&lt; &quot;\n&quot;;

    // Accessing a non-existing element creates it
    if (my_map[&quot;z&quot;] == 42) std::cout &lt;&lt; &quot;Oha!\n&quot;;
    
    it = my_map.find(&quot;z&quot;);
    if (it != my_map.end()) std::cout &lt;&lt; &quot;z2: &quot; &lt;&lt; it-&gt;second &lt;&lt; &quot;\n&quot;;
}
 | output=
x: 11
z2: 0
}}

[[de:cpp/container/map/find]]
[[es:cpp/container/map/find]]
[[fr:cpp/container/map/find]]
[[it:cpp/container/map/find]]
[[ja:cpp/container/map/find]]
[[pt:cpp/container/map/find]]
[[ru:cpp/container/map/find]]
[[zh:cpp/container/map/find]]</text>
      <sha1>3hnxajvgn9d8w11pwje7qon7sl309yh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/get allocator</title>
    <ns>0</ns>
    <id>970</id>
    <revision>
      <id>50560</id>
      <parentid>43466</parentid>
      <timestamp>2013-06-01T03:32:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/get_allocator|map}}

[[de:cpp/container/map/get allocator]]
[[es:cpp/container/map/get allocator]]
[[fr:cpp/container/map/get allocator]]
[[it:cpp/container/map/get allocator]]
[[ja:cpp/container/map/get allocator]]
[[pt:cpp/container/map/get allocator]]
[[ru:cpp/container/map/get allocator]]
[[zh:cpp/container/map/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/insert</title>
    <ns>0</ns>
    <id>971</id>
    <revision>
      <id>65005</id>
      <parentid>64995</parentid>
      <timestamp>2013-08-28T23:03:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{v}}</comment>
      <text xml:space="preserve" bytes="3286">{{cpp/container/map/title | insert}}
{{cpp/container/map/navbar}}
{{dcl begin}}
{{dcl | num=1 | 
std::pair&lt;iterator,bool&gt; insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class P &gt;
std::pair&lt;iterator,bool&gt; insert( P&amp;&amp; value );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator insert( iterator hint, const value_type&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 |
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
{{dcl | num=5 | 
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

@1-2@ Inserts {{tt|value}}. The overload {{v|2}} is equivalent to {{c|emplace(std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@3-4@ Inserts {{tt|value}} in the position as close as possible, just prior{{mark since c++11}}, to {{tt|hint}}. The overload {{v|4}} is equivalent to {{c|emplace_hint(hint, std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@5@ Inserts elements from range {{tt|[first, last)}}.

@6@ Inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|map|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-2@ Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a {{c|bool}} denoting whether the insertion took place.

@3-4@ Returns an iterator to the inserted element, or to the element that prevented the insertion.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}.

{{rev begin}}
{{rev | until=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''after'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev | since=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''before'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev end}}

@5-6@ {{tt|O(N*log(size() + N))}}, where N is the number of elements to insert.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |map}}
{{dsc inc | cpp/container/dsc emplace_hint |map}}
{{dsc end}}

[[de:cpp/container/map/insert]]
[[es:cpp/container/map/insert]]
[[fr:cpp/container/map/insert]]
[[it:cpp/container/map/insert]]
[[ja:cpp/container/map/insert]]
[[pt:cpp/container/map/insert]]
[[ru:cpp/container/map/insert]]
[[zh:cpp/container/map/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/key comp</title>
    <ns>0</ns>
    <id>972</id>
    <revision>
      <id>50561</id>
      <parentid>43453</parentid>
      <timestamp>2013-06-01T03:32:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/key_comp|map}}

[[de:cpp/container/map/key comp]]
[[es:cpp/container/map/key comp]]
[[fr:cpp/container/map/key comp]]
[[it:cpp/container/map/key comp]]
[[ja:cpp/container/map/key comp]]
[[pt:cpp/container/map/key comp]]
[[ru:cpp/container/map/key comp]]
[[zh:cpp/container/map/key comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/lower bound</title>
    <ns>0</ns>
    <id>973</id>
    <revision>
      <id>50562</id>
      <parentid>43432</parentid>
      <timestamp>2013-06-01T03:32:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/lower_bound|map}}

[[de:cpp/container/map/lower bound]]
[[es:cpp/container/map/lower bound]]
[[fr:cpp/container/map/lower bound]]
[[it:cpp/container/map/lower bound]]
[[ja:cpp/container/map/lower bound]]
[[pt:cpp/container/map/lower bound]]
[[ru:cpp/container/map/lower bound]]
[[zh:cpp/container/map/lower bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/map</title>
    <ns>0</ns>
    <id>974</id>
    <revision>
      <id>50563</id>
      <parentid>43425</parentid>
      <timestamp>2013-06-01T03:32:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="283">{{include page|cpp/container/constructor ord|map}}

[[de:cpp/container/map/map]]
[[es:cpp/container/map/map]]
[[fr:cpp/container/map/map]]
[[it:cpp/container/map/map]]
[[ja:cpp/container/map/map]]
[[pt:cpp/container/map/map]]
[[ru:cpp/container/map/map]]
[[zh:cpp/container/map/map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/max size</title>
    <ns>0</ns>
    <id>975</id>
    <revision>
      <id>50564</id>
      <parentid>43416</parentid>
      <timestamp>2013-06-01T03:32:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/max_size|map}}

[[de:cpp/container/map/max size]]
[[es:cpp/container/map/max size]]
[[fr:cpp/container/map/max size]]
[[it:cpp/container/map/max size]]
[[ja:cpp/container/map/max size]]
[[pt:cpp/container/map/max size]]
[[ru:cpp/container/map/max size]]
[[zh:cpp/container/map/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/operator=</title>
    <ns>0</ns>
    <id>976</id>
    <revision>
      <id>43411</id>
      <parentid>1953</parentid>
      <timestamp>2012-11-03T02:40:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="316">{{cpp/container/operator{{=}}|map}}

[[de:cpp/container/map/operator=]]
[[es:cpp/container/map/operator=]]
[[fr:cpp/container/map/operator=]]
[[it:cpp/container/map/operator=]]
[[ja:cpp/container/map/operator=]]
[[pt:cpp/container/map/operator=]]
[[ru:cpp/container/map/operator=]]
[[zh:cpp/container/map/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/operator at</title>
    <ns>0</ns>
    <id>977</id>
    <revision>
      <id>43405</id>
      <parentid>1955</parentid>
      <timestamp>2012-11-03T02:39:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="336">{{cpp/container/operator_at assoc|map}}

[[de:cpp/container/map/operator at]]
[[es:cpp/container/map/operator at]]
[[fr:cpp/container/map/operator at]]
[[it:cpp/container/map/operator at]]
[[ja:cpp/container/map/operator at]]
[[pt:cpp/container/map/operator at]]
[[ru:cpp/container/map/operator at]]
[[zh:cpp/container/map/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/operator cmp</title>
    <ns>0</ns>
    <id>2014</id>
    <revision>
      <id>50565</id>
      <parentid>43397</parentid>
      <timestamp>2013-06-01T03:32:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="352">{{include page|cpp/container/operator_cmp|map}}

[[de:cpp/container/map/operator cmp]]
[[es:cpp/container/map/operator cmp]]
[[fr:cpp/container/map/operator cmp]]
[[it:cpp/container/map/operator cmp]]
[[ja:cpp/container/map/operator cmp]]
[[pt:cpp/container/map/operator cmp]]
[[ru:cpp/container/map/operator cmp]]
[[zh:cpp/container/map/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/operator comp</title>
    <ns>0</ns>
    <id>4210</id>
    <redirect title="cpp/container/map/operator cmp" />
    <revision>
      <id>15237</id>
      <timestamp>2011-12-08T01:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/map/operator comp]] to [[cpp/container/map/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/container/map/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/rbegin</title>
    <ns>0</ns>
    <id>978</id>
    <revision>
      <id>50566</id>
      <parentid>43387</parentid>
      <timestamp>2013-06-01T03:32:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/rbegin|map}}

[[de:cpp/container/map/rbegin]]
[[es:cpp/container/map/rbegin]]
[[fr:cpp/container/map/rbegin]]
[[it:cpp/container/map/rbegin]]
[[ja:cpp/container/map/rbegin]]
[[pt:cpp/container/map/rbegin]]
[[ru:cpp/container/map/rbegin]]
[[zh:cpp/container/map/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/rend</title>
    <ns>0</ns>
    <id>979</id>
    <revision>
      <id>50567</id>
      <parentid>43379</parentid>
      <timestamp>2013-06-01T03:32:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/rend|map}}

[[de:cpp/container/map/rend]]
[[es:cpp/container/map/rend]]
[[fr:cpp/container/map/rend]]
[[it:cpp/container/map/rend]]
[[ja:cpp/container/map/rend]]
[[pt:cpp/container/map/rend]]
[[ru:cpp/container/map/rend]]
[[zh:cpp/container/map/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/size</title>
    <ns>0</ns>
    <id>980</id>
    <revision>
      <id>50568</id>
      <parentid>43375</parentid>
      <timestamp>2013-06-01T03:32:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/size|map}}

[[de:cpp/container/map/size]]
[[es:cpp/container/map/size]]
[[fr:cpp/container/map/size]]
[[it:cpp/container/map/size]]
[[ja:cpp/container/map/size]]
[[pt:cpp/container/map/size]]
[[ru:cpp/container/map/size]]
[[zh:cpp/container/map/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/std swap</title>
    <ns>0</ns>
    <id>3461</id>
    <redirect title="cpp/container/map/swap2" />
    <revision>
      <id>13011</id>
      <timestamp>2011-11-03T18:38:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/map/std swap]] to [[cpp/container/map/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/container/map/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/swap</title>
    <ns>0</ns>
    <id>981</id>
    <revision>
      <id>50569</id>
      <parentid>43369</parentid>
      <timestamp>2013-06-01T03:33:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/swap|map}}

[[de:cpp/container/map/swap]]
[[es:cpp/container/map/swap]]
[[fr:cpp/container/map/swap]]
[[it:cpp/container/map/swap]]
[[ja:cpp/container/map/swap]]
[[pt:cpp/container/map/swap]]
[[ru:cpp/container/map/swap]]
[[zh:cpp/container/map/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/swap2</title>
    <ns>0</ns>
    <id>2004</id>
    <revision>
      <id>50570</id>
      <parentid>43362</parentid>
      <timestamp>2013-06-01T03:33:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/swap2|map}}

[[de:cpp/container/map/swap2]]
[[es:cpp/container/map/swap2]]
[[fr:cpp/container/map/swap2]]
[[it:cpp/container/map/swap2]]
[[ja:cpp/container/map/swap2]]
[[pt:cpp/container/map/swap2]]
[[ru:cpp/container/map/swap2]]
[[zh:cpp/container/map/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/upper bound</title>
    <ns>0</ns>
    <id>982</id>
    <revision>
      <id>50571</id>
      <parentid>43349</parentid>
      <timestamp>2013-06-01T03:33:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/upper_bound|map}}

[[de:cpp/container/map/upper bound]]
[[es:cpp/container/map/upper bound]]
[[fr:cpp/container/map/upper bound]]
[[it:cpp/container/map/upper bound]]
[[ja:cpp/container/map/upper bound]]
[[pt:cpp/container/map/upper bound]]
[[ru:cpp/container/map/upper bound]]
[[zh:cpp/container/map/upper bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/value comp</title>
    <ns>0</ns>
    <id>983</id>
    <revision>
      <id>50572</id>
      <parentid>43344</parentid>
      <timestamp>2013-06-01T03:33:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/value_comp|map}}

[[de:cpp/container/map/value comp]]
[[es:cpp/container/map/value comp]]
[[fr:cpp/container/map/value comp]]
[[it:cpp/container/map/value comp]]
[[ja:cpp/container/map/value comp]]
[[pt:cpp/container/map/value comp]]
[[ru:cpp/container/map/value comp]]
[[zh:cpp/container/map/value comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/value compare</title>
    <ns>0</ns>
    <id>3617</id>
    <revision>
      <id>50573</id>
      <parentid>43339</parentid>
      <timestamp>2013-06-01T03:33:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/value_compare|map}}

[[de:cpp/container/map/value compare]]
[[es:cpp/container/map/value compare]]
[[fr:cpp/container/map/value compare]]
[[it:cpp/container/map/value compare]]
[[ja:cpp/container/map/value compare]]
[[pt:cpp/container/map/value compare]]
[[ru:cpp/container/map/value compare]]
[[zh:cpp/container/map/value compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/map/~map</title>
    <ns>0</ns>
    <id>984</id>
    <revision>
      <id>50574</id>
      <parentid>43330</parentid>
      <timestamp>2013-06-01T03:33:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="286">{{include page|cpp/container/destructor|map}}

[[de:cpp/container/map/~map]]
[[es:cpp/container/map/~map]]
[[fr:cpp/container/map/~map]]
[[it:cpp/container/map/~map]]
[[ja:cpp/container/map/~map]]
[[pt:cpp/container/map/~map]]
[[ru:cpp/container/map/~map]]
[[zh:cpp/container/map/~map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap</title>
    <ns>0</ns>
    <id>985</id>
    <revision>
      <id>57285</id>
      <parentid>49443</parentid>
      <timestamp>2013-06-01T05:50:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3669">{{cpp/title|multimap}}
{{cpp/container/multimap/navbar}}
{{ddcl | header=map |
template&lt;
    class Key,
    class T,
    class Compare {{=}} std::less&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt;
&gt; class multimap;
}} 

Multimap is an associative container that contains a sorted list of key-value pairs. Sorting is done according to the comparison function {{tt|Compare}}, applied to the keys. Search, insertion, and removal operations have logarithmic complexity.

The order of the key-value pairs whose keys compare equivalent is the order of insertion and does not change. {{mark since c++11}}

{{tt|std::multimap}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|AssociativeContainer}} and {{concept|ReversibleContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | multimap}}
{{dsc inc | cpp/container/dsc mapped_type | multimap}}
{{dsc inc | cpp/container/dsc value_type | multimap}}
{{dsc inc | cpp/container/dsc size_type | multimap}}
{{dsc inc | cpp/container/dsc difference_type | multimap}}
{{dsc inc | cpp/container/dsc key_compare | multimap}}
{{dsc inc | cpp/container/dsc allocator_type | multimap}}
{{dsc inc | cpp/container/dsc reference | multimap}}
{{dsc inc | cpp/container/dsc const_reference | multimap}}
{{dsc inc | cpp/container/dsc pointer | multimap}}
{{dsc inc | cpp/container/dsc const_pointer | multimap}}
{{dsc inc | cpp/container/dsc iterator | multimap}}
{{dsc inc | cpp/container/dsc const_iterator | multimap}}
{{dsc inc | cpp/container/dsc reverse_iterator | multimap}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | multimap}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc value_compare | multimap}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | multimap}}
{{dsc inc | cpp/container/dsc destructor | multimap}}
{{dsc inc | cpp/container/dsc operator{{=}} | multimap}}
{{dsc inc | cpp/container/dsc get_allocator | multimap}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | multimap}}
{{dsc inc | cpp/container/dsc end | multimap}}
{{dsc inc | cpp/container/dsc rbegin | multimap}}
{{dsc inc | cpp/container/dsc rend | multimap}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | multimap}}
{{dsc inc | cpp/container/dsc size | multimap}}
{{dsc inc | cpp/container/dsc max_size | multimap}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | multimap}}
{{dsc inc | cpp/container/dsc insert | multimap}}
{{dsc inc | cpp/container/dsc emplace | multimap}}
{{dsc inc | cpp/container/dsc emplace_hint | multimap}}
{{dsc inc | cpp/container/dsc erase | multimap}}
{{dsc inc | cpp/container/dsc swap | multimap}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | multimap}}
{{dsc inc | cpp/container/dsc find | multimap}}
{{dsc inc | cpp/container/dsc equal_range | multimap}}
{{dsc inc | cpp/container/dsc lower_bound | multimap}}
{{dsc inc | cpp/container/dsc upper_bound | multimap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc key_comp | multimap}}
{{dsc inc | cpp/container/dsc value_comp | multimap}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | multimap}}
{{dsc inc | cpp/container/dsc swap2 | multimap}}
{{dsc end}}

[[de:cpp/container/multimap]]
[[es:cpp/container/multimap]]
[[fr:cpp/container/multimap]]
[[it:cpp/container/multimap]]
[[ja:cpp/container/multimap]]
[[pl:cpp/container/multimap]]
[[pt:cpp/container/multimap]]
[[ru:cpp/container/multimap]]
[[zh:cpp/container/multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/begin</title>
    <ns>0</ns>
    <id>986</id>
    <revision>
      <id>50575</id>
      <parentid>43315</parentid>
      <timestamp>2013-06-01T03:33:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/begin|multimap}}

[[de:cpp/container/multimap/begin]]
[[es:cpp/container/multimap/begin]]
[[fr:cpp/container/multimap/begin]]
[[it:cpp/container/multimap/begin]]
[[ja:cpp/container/multimap/begin]]
[[pt:cpp/container/multimap/begin]]
[[ru:cpp/container/multimap/begin]]
[[zh:cpp/container/multimap/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/clear</title>
    <ns>0</ns>
    <id>987</id>
    <revision>
      <id>50576</id>
      <parentid>43308</parentid>
      <timestamp>2013-06-01T03:33:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/clear|multimap}}

[[de:cpp/container/multimap/clear]]
[[es:cpp/container/multimap/clear]]
[[fr:cpp/container/multimap/clear]]
[[it:cpp/container/multimap/clear]]
[[ja:cpp/container/multimap/clear]]
[[pt:cpp/container/multimap/clear]]
[[ru:cpp/container/multimap/clear]]
[[zh:cpp/container/multimap/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/count</title>
    <ns>0</ns>
    <id>988</id>
    <revision>
      <id>65125</id>
      <parentid>50577</parentid>
      <timestamp>2013-08-30T16:36:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="338">{{include page|cpp/container/count_ord|multimap}}

[[de:cpp/container/multimap/count]]
[[es:cpp/container/multimap/count]]
[[fr:cpp/container/multimap/count]]
[[it:cpp/container/multimap/count]]
[[ja:cpp/container/multimap/count]]
[[pt:cpp/container/multimap/count]]
[[ru:cpp/container/multimap/count]]
[[zh:cpp/container/multimap/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/emplace</title>
    <ns>0</ns>
    <id>989</id>
    <revision>
      <id>50578</id>
      <parentid>43292</parentid>
      <timestamp>2013-06-01T03:33:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="358">{{include page|cpp/container/emplace assoc|multimap}}

[[de:cpp/container/multimap/emplace]]
[[es:cpp/container/multimap/emplace]]
[[fr:cpp/container/multimap/emplace]]
[[it:cpp/container/multimap/emplace]]
[[ja:cpp/container/multimap/emplace]]
[[pt:cpp/container/multimap/emplace]]
[[ru:cpp/container/multimap/emplace]]
[[zh:cpp/container/multimap/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/emplace hint</title>
    <ns>0</ns>
    <id>990</id>
    <revision>
      <id>65113</id>
      <parentid>65104</parentid>
      <timestamp>2013-08-30T16:27:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1604">{{cpp/container/multimap/title | emplace_hint}}
{{cpp/container/multimap/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element type ({{tt|value_type}}, that is, {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.

{{cpp/container/note_iterator_invalidation|multimap|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

===Complexity===
Logarithmic in the size of the container in general, but amortized constant if the new element is inserted just before {{tt|hint}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |multimap}}
{{dsc inc | cpp/container/dsc insert |multimap}}
{{dsc end}}

[[de:cpp/container/multimap/emplace hint]]
[[es:cpp/container/multimap/emplace hint]]
[[fr:cpp/container/multimap/emplace hint]]
[[it:cpp/container/multimap/emplace hint]]
[[ja:cpp/container/multimap/emplace hint]]
[[pt:cpp/container/multimap/emplace hint]]
[[ru:cpp/container/multimap/emplace hint]]
[[zh:cpp/container/multimap/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/empty</title>
    <ns>0</ns>
    <id>991</id>
    <revision>
      <id>50580</id>
      <parentid>41943</parentid>
      <timestamp>2013-06-01T03:33:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/empty|multimap}}

[[de:cpp/container/multimap/empty]]
[[es:cpp/container/multimap/empty]]
[[fr:cpp/container/multimap/empty]]
[[it:cpp/container/multimap/empty]]
[[ja:cpp/container/multimap/empty]]
[[pt:cpp/container/multimap/empty]]
[[ru:cpp/container/multimap/empty]]
[[zh:cpp/container/multimap/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/end</title>
    <ns>0</ns>
    <id>992</id>
    <revision>
      <id>50581</id>
      <parentid>41940</parentid>
      <timestamp>2013-06-01T03:33:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/end|multimap}}

[[de:cpp/container/multimap/end]]
[[es:cpp/container/multimap/end]]
[[fr:cpp/container/multimap/end]]
[[it:cpp/container/multimap/end]]
[[ja:cpp/container/multimap/end]]
[[pt:cpp/container/multimap/end]]
[[ru:cpp/container/multimap/end]]
[[zh:cpp/container/multimap/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/equal range</title>
    <ns>0</ns>
    <id>993</id>
    <revision>
      <id>65092</id>
      <parentid>50582</parentid>
      <timestamp>2013-08-30T15:58:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="392">{{include page|cpp/container/equal_range_ord|multimap}}

[[de:cpp/container/multimap/equal range]]
[[es:cpp/container/multimap/equal range]]
[[fr:cpp/container/multimap/equal range]]
[[it:cpp/container/multimap/equal range]]
[[ja:cpp/container/multimap/equal range]]
[[pt:cpp/container/multimap/equal range]]
[[ru:cpp/container/multimap/equal range]]
[[zh:cpp/container/multimap/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/erase</title>
    <ns>0</ns>
    <id>994</id>
    <revision>
      <id>50583</id>
      <parentid>41934</parentid>
      <timestamp>2013-06-01T03:33:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="340">{{include page|cpp/container/erase assoc|multimap}}

[[de:cpp/container/multimap/erase]]
[[es:cpp/container/multimap/erase]]
[[fr:cpp/container/multimap/erase]]
[[it:cpp/container/multimap/erase]]
[[ja:cpp/container/multimap/erase]]
[[pt:cpp/container/multimap/erase]]
[[ru:cpp/container/multimap/erase]]
[[zh:cpp/container/multimap/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/find</title>
    <ns>0</ns>
    <id>995</id>
    <revision>
      <id>50584</id>
      <parentid>41932</parentid>
      <timestamp>2013-06-01T03:33:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/find|multimap}}

[[de:cpp/container/multimap/find]]
[[es:cpp/container/multimap/find]]
[[fr:cpp/container/multimap/find]]
[[it:cpp/container/multimap/find]]
[[ja:cpp/container/multimap/find]]
[[pt:cpp/container/multimap/find]]
[[ru:cpp/container/multimap/find]]
[[zh:cpp/container/multimap/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/get allocator</title>
    <ns>0</ns>
    <id>996</id>
    <revision>
      <id>50585</id>
      <parentid>41929</parentid>
      <timestamp>2013-06-01T03:33:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/get_allocator|multimap}}

[[de:cpp/container/multimap/get allocator]]
[[es:cpp/container/multimap/get allocator]]
[[fr:cpp/container/multimap/get allocator]]
[[it:cpp/container/multimap/get allocator]]
[[ja:cpp/container/multimap/get allocator]]
[[pt:cpp/container/multimap/get allocator]]
[[ru:cpp/container/multimap/get allocator]]
[[zh:cpp/container/multimap/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/insert</title>
    <ns>0</ns>
    <id>997</id>
    <revision>
      <id>65006</id>
      <parentid>64994</parentid>
      <timestamp>2013-08-28T23:03:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{v}}</comment>
      <text xml:space="preserve" bytes="3126">{{cpp/container/multimap/title | insert}}
{{cpp/container/multimap/navbar}}
{{dcl begin}}
{{dcl | num=1 |
iterator insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class P &gt;
iterator insert( P&amp;&amp; value );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator insert( iterator hint, const value_type&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 |
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
{{dcl | num=5 | 
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container.

@1-2@ inserts {{tt|value}}. If the container has elements with equivalent key, inserts at the upper bound of that range.{{mark since c++11}} The overload {{v|2}} is equivalent to {{c|emplace(std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@3-4@ inserts {{tt|value}} in the position as close as possible, just prior{{mark since c++11}}, to {{tt|hint}}. The overload {{v|4}} is equivalent to {{c|emplace_hint(hint, std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@5@ inserts elements from range {{tt|[first, last)}}.

@6@ inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|multimap|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-4@ Returns an iterator to the inserted element.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}.

{{rev begin}}
{{rev | until=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''after'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev | since=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''before'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev end}}

@5-6@ {{tt|O(N*log(size() + N))}}, where N is the number of elements to insert.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |multimap}}
{{dsc inc | cpp/container/dsc emplace_hint |multimap}}
{{dsc end}}

[[de:cpp/container/multimap/insert]]
[[es:cpp/container/multimap/insert]]
[[fr:cpp/container/multimap/insert]]
[[it:cpp/container/multimap/insert]]
[[ja:cpp/container/multimap/insert]]
[[pt:cpp/container/multimap/insert]]
[[ru:cpp/container/multimap/insert]]
[[zh:cpp/container/multimap/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/key comp</title>
    <ns>0</ns>
    <id>998</id>
    <revision>
      <id>50586</id>
      <parentid>41925</parentid>
      <timestamp>2013-06-01T03:33:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/key_comp|multimap}}

[[de:cpp/container/multimap/key comp]]
[[es:cpp/container/multimap/key comp]]
[[fr:cpp/container/multimap/key comp]]
[[it:cpp/container/multimap/key comp]]
[[ja:cpp/container/multimap/key comp]]
[[pt:cpp/container/multimap/key comp]]
[[ru:cpp/container/multimap/key comp]]
[[zh:cpp/container/multimap/key comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/lower bound</title>
    <ns>0</ns>
    <id>999</id>
    <revision>
      <id>50587</id>
      <parentid>41923</parentid>
      <timestamp>2013-06-01T03:33:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/lower_bound|multimap}}

[[de:cpp/container/multimap/lower bound]]
[[es:cpp/container/multimap/lower bound]]
[[fr:cpp/container/multimap/lower bound]]
[[it:cpp/container/multimap/lower bound]]
[[ja:cpp/container/multimap/lower bound]]
[[pt:cpp/container/multimap/lower bound]]
[[ru:cpp/container/multimap/lower bound]]
[[zh:cpp/container/multimap/lower bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/max size</title>
    <ns>0</ns>
    <id>1000</id>
    <revision>
      <id>50588</id>
      <parentid>41920</parentid>
      <timestamp>2013-06-01T03:33:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/max_size|multimap}}

[[de:cpp/container/multimap/max size]]
[[es:cpp/container/multimap/max size]]
[[fr:cpp/container/multimap/max size]]
[[it:cpp/container/multimap/max size]]
[[ja:cpp/container/multimap/max size]]
[[pt:cpp/container/multimap/max size]]
[[ru:cpp/container/multimap/max size]]
[[zh:cpp/container/multimap/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/multimap</title>
    <ns>0</ns>
    <id>1001</id>
    <revision>
      <id>50589</id>
      <parentid>41917</parentid>
      <timestamp>2013-06-01T03:33:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="368">{{include page|cpp/container/constructor ord|multimap}}

[[de:cpp/container/multimap/multimap]]
[[es:cpp/container/multimap/multimap]]
[[fr:cpp/container/multimap/multimap]]
[[it:cpp/container/multimap/multimap]]
[[ja:cpp/container/multimap/multimap]]
[[pt:cpp/container/multimap/multimap]]
[[ru:cpp/container/multimap/multimap]]
[[zh:cpp/container/multimap/multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/operator=</title>
    <ns>0</ns>
    <id>1002</id>
    <revision>
      <id>41915</id>
      <parentid>2005</parentid>
      <timestamp>2012-11-02T20:54:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="361">{{cpp/container/operator{{=}}|multimap}}

[[de:cpp/container/multimap/operator=]]
[[es:cpp/container/multimap/operator=]]
[[fr:cpp/container/multimap/operator=]]
[[it:cpp/container/multimap/operator=]]
[[ja:cpp/container/multimap/operator=]]
[[pt:cpp/container/multimap/operator=]]
[[ru:cpp/container/multimap/operator=]]
[[zh:cpp/container/multimap/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/operator cmp</title>
    <ns>0</ns>
    <id>2013</id>
    <revision>
      <id>50590</id>
      <parentid>41912</parentid>
      <timestamp>2013-06-01T03:33:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="397">{{include page|cpp/container/operator_cmp|multimap}}

[[de:cpp/container/multimap/operator cmp]]
[[es:cpp/container/multimap/operator cmp]]
[[fr:cpp/container/multimap/operator cmp]]
[[it:cpp/container/multimap/operator cmp]]
[[ja:cpp/container/multimap/operator cmp]]
[[pt:cpp/container/multimap/operator cmp]]
[[ru:cpp/container/multimap/operator cmp]]
[[zh:cpp/container/multimap/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/operator comp</title>
    <ns>0</ns>
    <id>4209</id>
    <redirect title="cpp/container/multimap/operator cmp" />
    <revision>
      <id>15235</id>
      <timestamp>2011-12-08T01:10:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/multimap/operator comp]] to [[cpp/container/multimap/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/container/multimap/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/rbegin</title>
    <ns>0</ns>
    <id>1003</id>
    <revision>
      <id>50591</id>
      <parentid>41909</parentid>
      <timestamp>2013-06-01T03:33:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/rbegin|multimap}}

[[de:cpp/container/multimap/rbegin]]
[[es:cpp/container/multimap/rbegin]]
[[fr:cpp/container/multimap/rbegin]]
[[it:cpp/container/multimap/rbegin]]
[[ja:cpp/container/multimap/rbegin]]
[[pt:cpp/container/multimap/rbegin]]
[[ru:cpp/container/multimap/rbegin]]
[[zh:cpp/container/multimap/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/rend</title>
    <ns>0</ns>
    <id>1004</id>
    <revision>
      <id>50592</id>
      <parentid>41906</parentid>
      <timestamp>2013-06-01T03:33:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/rend|multimap}}

[[de:cpp/container/multimap/rend]]
[[es:cpp/container/multimap/rend]]
[[fr:cpp/container/multimap/rend]]
[[it:cpp/container/multimap/rend]]
[[ja:cpp/container/multimap/rend]]
[[pt:cpp/container/multimap/rend]]
[[ru:cpp/container/multimap/rend]]
[[zh:cpp/container/multimap/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/size</title>
    <ns>0</ns>
    <id>1005</id>
    <revision>
      <id>50593</id>
      <parentid>41903</parentid>
      <timestamp>2013-06-01T03:33:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/size|multimap}}

[[de:cpp/container/multimap/size]]
[[es:cpp/container/multimap/size]]
[[fr:cpp/container/multimap/size]]
[[it:cpp/container/multimap/size]]
[[ja:cpp/container/multimap/size]]
[[pt:cpp/container/multimap/size]]
[[ru:cpp/container/multimap/size]]
[[zh:cpp/container/multimap/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/std swap</title>
    <ns>0</ns>
    <id>3462</id>
    <redirect title="cpp/container/multimap/swap2" />
    <revision>
      <id>13013</id>
      <timestamp>2011-11-03T18:38:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/multimap/std swap]] to [[cpp/container/multimap/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/container/multimap/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/swap</title>
    <ns>0</ns>
    <id>1006</id>
    <revision>
      <id>50594</id>
      <parentid>41900</parentid>
      <timestamp>2013-06-01T03:33:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/swap|multimap}}

[[de:cpp/container/multimap/swap]]
[[es:cpp/container/multimap/swap]]
[[fr:cpp/container/multimap/swap]]
[[it:cpp/container/multimap/swap]]
[[ja:cpp/container/multimap/swap]]
[[pt:cpp/container/multimap/swap]]
[[ru:cpp/container/multimap/swap]]
[[zh:cpp/container/multimap/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/swap2</title>
    <ns>0</ns>
    <id>2002</id>
    <revision>
      <id>50595</id>
      <parentid>41897</parentid>
      <timestamp>2013-06-01T03:33:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/swap2|multimap}}

[[de:cpp/container/multimap/swap2]]
[[es:cpp/container/multimap/swap2]]
[[fr:cpp/container/multimap/swap2]]
[[it:cpp/container/multimap/swap2]]
[[ja:cpp/container/multimap/swap2]]
[[pt:cpp/container/multimap/swap2]]
[[ru:cpp/container/multimap/swap2]]
[[zh:cpp/container/multimap/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/upper bound</title>
    <ns>0</ns>
    <id>1007</id>
    <revision>
      <id>50596</id>
      <parentid>41894</parentid>
      <timestamp>2013-06-01T03:33:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/upper_bound|multimap}}

[[de:cpp/container/multimap/upper bound]]
[[es:cpp/container/multimap/upper bound]]
[[fr:cpp/container/multimap/upper bound]]
[[it:cpp/container/multimap/upper bound]]
[[ja:cpp/container/multimap/upper bound]]
[[pt:cpp/container/multimap/upper bound]]
[[ru:cpp/container/multimap/upper bound]]
[[zh:cpp/container/multimap/upper bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/value comp</title>
    <ns>0</ns>
    <id>1008</id>
    <revision>
      <id>50597</id>
      <parentid>41891</parentid>
      <timestamp>2013-06-01T03:33:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/value_comp|multimap}}

[[de:cpp/container/multimap/value comp]]
[[es:cpp/container/multimap/value comp]]
[[fr:cpp/container/multimap/value comp]]
[[it:cpp/container/multimap/value comp]]
[[ja:cpp/container/multimap/value comp]]
[[pt:cpp/container/multimap/value comp]]
[[ru:cpp/container/multimap/value comp]]
[[zh:cpp/container/multimap/value comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/value compare</title>
    <ns>0</ns>
    <id>3618</id>
    <revision>
      <id>50598</id>
      <parentid>41888</parentid>
      <timestamp>2013-06-01T03:33:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/value_compare|multimap}}

[[de:cpp/container/multimap/value compare]]
[[es:cpp/container/multimap/value compare]]
[[fr:cpp/container/multimap/value compare]]
[[it:cpp/container/multimap/value compare]]
[[ja:cpp/container/multimap/value compare]]
[[pt:cpp/container/multimap/value compare]]
[[ru:cpp/container/multimap/value compare]]
[[zh:cpp/container/multimap/value compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multimap/~multimap</title>
    <ns>0</ns>
    <id>1009</id>
    <revision>
      <id>50599</id>
      <parentid>41885</parentid>
      <timestamp>2013-06-01T03:33:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/container/destructor|multimap}}

[[de:cpp/container/multimap/~multimap]]
[[es:cpp/container/multimap/~multimap]]
[[fr:cpp/container/multimap/~multimap]]
[[it:cpp/container/multimap/~multimap]]
[[ja:cpp/container/multimap/~multimap]]
[[pt:cpp/container/multimap/~multimap]]
[[ru:cpp/container/multimap/~multimap]]
[[zh:cpp/container/multimap/~multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset</title>
    <ns>0</ns>
    <id>1010</id>
    <revision>
      <id>57286</id>
      <parentid>49444</parentid>
      <timestamp>2013-06-01T05:50:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3593">{{cpp/title|multiset}}
{{cpp/container/multiset/navbar}}
{{ddcl | header=set |
template&lt;
    class Key,
    class Compare {{=}} std::less&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt;
&gt; class multiset;
}} 

Multiset is an associative container that contains a sorted set of objects of type Key. Unlike set, multiple keys with equal values are allowed. Sorting is done using the key comparison function Compare. Search, insertion, and removal operations have logarithmic complexity.

The order of the elements that compare equivalent is the order of insertion and does not change. {{mark since c++11}}

{{tt|std::multiset}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|AssociativeContainer}} and {{concept|ReversibleContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | multiset}}
{{dsc inc | cpp/container/dsc value_type | multiset}}
{{dsc inc | cpp/container/dsc size_type | multiset}}
{{dsc inc | cpp/container/dsc difference_type | multiset}}
{{dsc inc | cpp/container/dsc key_compare | multiset}}
{{dsc inc | cpp/container/dsc value_compare2 | multiset}}
{{dsc inc | cpp/container/dsc allocator_type | multiset}}
{{dsc inc | cpp/container/dsc reference | multiset}}
{{dsc inc | cpp/container/dsc const_reference | multiset}}
{{dsc inc | cpp/container/dsc pointer | multiset}}
{{dsc inc | cpp/container/dsc const_pointer | multiset}}
{{dsc inc | cpp/container/dsc iterator | multiset}}
{{dsc inc | cpp/container/dsc const_iterator | multiset}}
{{dsc inc | cpp/container/dsc reverse_iterator | multiset}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | multiset}}
{{dsc end}}



===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | multiset}}
{{dsc inc | cpp/container/dsc destructor | multiset}}
{{dsc inc | cpp/container/dsc operator{{=}} | multiset}}
{{dsc inc | cpp/container/dsc get_allocator | multiset}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | multiset}}
{{dsc inc | cpp/container/dsc end | multiset}}
{{dsc inc | cpp/container/dsc rbegin | multiset}}
{{dsc inc | cpp/container/dsc rend | multiset}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | multiset}}
{{dsc inc | cpp/container/dsc size | multiset}}
{{dsc inc | cpp/container/dsc max_size | multiset}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | multiset}}
{{dsc inc | cpp/container/dsc insert | multiset}}
{{dsc inc | cpp/container/dsc emplace | multiset}}
{{dsc inc | cpp/container/dsc emplace_hint | multiset}}
{{dsc inc | cpp/container/dsc erase | multiset}}
{{dsc inc | cpp/container/dsc swap | multiset}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | multiset}}
{{dsc inc | cpp/container/dsc find | multiset}}
{{dsc inc | cpp/container/dsc equal_range | multiset}}
{{dsc inc | cpp/container/dsc lower_bound | multiset}}
{{dsc inc | cpp/container/dsc upper_bound | multiset}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc key_comp | multiset}}
{{dsc inc | cpp/container/dsc value_comp | multiset}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | multiset}}
{{dsc inc | cpp/container/dsc swap2 | multiset}}
{{dsc end}}

===Notes===
{{cpp/container/assoc_note}}

[[de:cpp/container/multiset]]
[[es:cpp/container/multiset]]
[[fr:cpp/container/multiset]]
[[it:cpp/container/multiset]]
[[ja:cpp/container/multiset]]
[[pl:cpp/container/multiset]]
[[pt:cpp/container/multiset]]
[[ru:cpp/container/multiset]]
[[zh:cpp/container/multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/begin</title>
    <ns>0</ns>
    <id>1011</id>
    <revision>
      <id>50600</id>
      <parentid>41878</parentid>
      <timestamp>2013-06-01T03:33:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/begin|multiset}}

[[de:cpp/container/multiset/begin]]
[[es:cpp/container/multiset/begin]]
[[fr:cpp/container/multiset/begin]]
[[it:cpp/container/multiset/begin]]
[[ja:cpp/container/multiset/begin]]
[[pt:cpp/container/multiset/begin]]
[[ru:cpp/container/multiset/begin]]
[[zh:cpp/container/multiset/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/clear</title>
    <ns>0</ns>
    <id>1012</id>
    <revision>
      <id>50601</id>
      <parentid>41876</parentid>
      <timestamp>2013-06-01T03:33:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/clear|multiset}}

[[de:cpp/container/multiset/clear]]
[[es:cpp/container/multiset/clear]]
[[fr:cpp/container/multiset/clear]]
[[it:cpp/container/multiset/clear]]
[[ja:cpp/container/multiset/clear]]
[[pt:cpp/container/multiset/clear]]
[[ru:cpp/container/multiset/clear]]
[[zh:cpp/container/multiset/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/count</title>
    <ns>0</ns>
    <id>1013</id>
    <revision>
      <id>65124</id>
      <parentid>50602</parentid>
      <timestamp>2013-08-30T16:36:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="338">{{include page|cpp/container/count_ord|multiset}}

[[de:cpp/container/multiset/count]]
[[es:cpp/container/multiset/count]]
[[fr:cpp/container/multiset/count]]
[[it:cpp/container/multiset/count]]
[[ja:cpp/container/multiset/count]]
[[pt:cpp/container/multiset/count]]
[[ru:cpp/container/multiset/count]]
[[zh:cpp/container/multiset/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/emplace</title>
    <ns>0</ns>
    <id>1014</id>
    <revision>
      <id>50603</id>
      <parentid>41870</parentid>
      <timestamp>2013-06-01T03:34:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="358">{{include page|cpp/container/emplace assoc|multiset}}

[[de:cpp/container/multiset/emplace]]
[[es:cpp/container/multiset/emplace]]
[[fr:cpp/container/multiset/emplace]]
[[it:cpp/container/multiset/emplace]]
[[ja:cpp/container/multiset/emplace]]
[[pt:cpp/container/multiset/emplace]]
[[ru:cpp/container/multiset/emplace]]
[[zh:cpp/container/multiset/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/emplace hint</title>
    <ns>0</ns>
    <id>1015</id>
    <revision>
      <id>65112</id>
      <parentid>65103</parentid>
      <timestamp>2013-08-30T16:27:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1540">{{cpp/container/multiset/title | emplace_hint}}
{{cpp/container/multiset/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}. 

{{cpp/container/note_iterator_invalidation|multiset|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

===Complexity===
Logarithmic in the size of the container in general, but amortized constant if the new element is inserted just before {{tt|hint}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |multiset}}
{{dsc inc | cpp/container/dsc insert |multiset}}
{{dsc end}}

[[de:cpp/container/multiset/emplace hint]]
[[es:cpp/container/multiset/emplace hint]]
[[fr:cpp/container/multiset/emplace hint]]
[[it:cpp/container/multiset/emplace hint]]
[[ja:cpp/container/multiset/emplace hint]]
[[pt:cpp/container/multiset/emplace hint]]
[[ru:cpp/container/multiset/emplace hint]]
[[zh:cpp/container/multiset/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/empty</title>
    <ns>0</ns>
    <id>1016</id>
    <revision>
      <id>50605</id>
      <parentid>41865</parentid>
      <timestamp>2013-06-01T03:34:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/empty|multiset}}

[[de:cpp/container/multiset/empty]]
[[es:cpp/container/multiset/empty]]
[[fr:cpp/container/multiset/empty]]
[[it:cpp/container/multiset/empty]]
[[ja:cpp/container/multiset/empty]]
[[pt:cpp/container/multiset/empty]]
[[ru:cpp/container/multiset/empty]]
[[zh:cpp/container/multiset/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/end</title>
    <ns>0</ns>
    <id>1017</id>
    <revision>
      <id>50606</id>
      <parentid>41862</parentid>
      <timestamp>2013-06-01T03:34:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/end|multiset}}

[[de:cpp/container/multiset/end]]
[[es:cpp/container/multiset/end]]
[[fr:cpp/container/multiset/end]]
[[it:cpp/container/multiset/end]]
[[ja:cpp/container/multiset/end]]
[[pt:cpp/container/multiset/end]]
[[ru:cpp/container/multiset/end]]
[[zh:cpp/container/multiset/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/equal range</title>
    <ns>0</ns>
    <id>1018</id>
    <revision>
      <id>65091</id>
      <parentid>50607</parentid>
      <timestamp>2013-08-30T15:58:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="392">{{include page|cpp/container/equal_range_ord|multiset}}

[[de:cpp/container/multiset/equal range]]
[[es:cpp/container/multiset/equal range]]
[[fr:cpp/container/multiset/equal range]]
[[it:cpp/container/multiset/equal range]]
[[ja:cpp/container/multiset/equal range]]
[[pt:cpp/container/multiset/equal range]]
[[ru:cpp/container/multiset/equal range]]
[[zh:cpp/container/multiset/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/erase</title>
    <ns>0</ns>
    <id>1019</id>
    <revision>
      <id>50608</id>
      <parentid>41857</parentid>
      <timestamp>2013-06-01T03:34:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="340">{{include page|cpp/container/erase assoc|multiset}}

[[de:cpp/container/multiset/erase]]
[[es:cpp/container/multiset/erase]]
[[fr:cpp/container/multiset/erase]]
[[it:cpp/container/multiset/erase]]
[[ja:cpp/container/multiset/erase]]
[[pt:cpp/container/multiset/erase]]
[[ru:cpp/container/multiset/erase]]
[[zh:cpp/container/multiset/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/find</title>
    <ns>0</ns>
    <id>1020</id>
    <revision>
      <id>50609</id>
      <parentid>41853</parentid>
      <timestamp>2013-06-01T03:34:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/find|multiset}}

[[de:cpp/container/multiset/find]]
[[es:cpp/container/multiset/find]]
[[fr:cpp/container/multiset/find]]
[[it:cpp/container/multiset/find]]
[[ja:cpp/container/multiset/find]]
[[pt:cpp/container/multiset/find]]
[[ru:cpp/container/multiset/find]]
[[zh:cpp/container/multiset/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/get allocator</title>
    <ns>0</ns>
    <id>1021</id>
    <revision>
      <id>50610</id>
      <parentid>41851</parentid>
      <timestamp>2013-06-01T03:34:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/get_allocator|multiset}}

[[de:cpp/container/multiset/get allocator]]
[[es:cpp/container/multiset/get allocator]]
[[fr:cpp/container/multiset/get allocator]]
[[it:cpp/container/multiset/get allocator]]
[[ja:cpp/container/multiset/get allocator]]
[[pt:cpp/container/multiset/get allocator]]
[[ru:cpp/container/multiset/get allocator]]
[[zh:cpp/container/multiset/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/insert</title>
    <ns>0</ns>
    <id>1022</id>
    <revision>
      <id>64997</id>
      <parentid>64989</parentid>
      <timestamp>2013-08-28T22:44:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="3295">{{cpp/container/multiset/title | insert}}
{{cpp/container/multiset/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|multiset}} |
iterator insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
{{#switch: multiset
 | set | unordered_set =
std::pair&lt;iterator,bool&gt; insert( value_type&amp;&amp; value );
 | multiset | unordered_multiset =
iterator insert( value_type&amp;&amp; value );
 | map | unordered_map =
template&lt; class P &gt;
std::pair&lt;iterator,bool&gt; insert( P&amp;&amp; value );
 | multimap | unordered_multimap=
template&lt; class P &gt;
iterator insert( P&amp;&amp; value );
}}
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator insert( iterator hint, const value_type&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 |
{{#switch: multiset
 | set | unordered_set | multiset | unordered_multiset =
iterator insert( const_iterator hint, value_type&amp;&amp; value );
 | map | unordered_map | multimap | unordered_multimap =
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
}}
{{dcl | num=5 | since={{cpp/std|multiset}} |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container.

@1-2@ Inserts {{tt|value}}. If the container has elements with equivalent key, inserts at the upper bound of that range.{{mark since c++11}}.

@3-4@ inserts {{tt|value}} in the position as close as possible, just prior{{mark since c++11}}, to {{tt|hint}}. 

@5@ inserts elements from range {{tt|[first, last)}}.

@6@ inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|multiset|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-4@ Returns an iterator to the inserted element.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}.

{{rev begin}}
{{rev | until=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''after'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev | since=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''before'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev end}}

@5-6@ {{tt|O(N*log(size() + N))}}, where N is the number of elements to insert.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |multiset}}
{{dsc inc | cpp/container/dsc emplace_hint |multiset}}
{{dsc end}}

[[de:cpp/container/multiset/insert]]
[[es:cpp/container/multiset/insert]]
[[fr:cpp/container/multiset/insert]]
[[it:cpp/container/multiset/insert]]
[[ja:cpp/container/multiset/insert]]
[[pt:cpp/container/multiset/insert]]
[[ru:cpp/container/multiset/insert]]
[[zh:cpp/container/multiset/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/key comp</title>
    <ns>0</ns>
    <id>1023</id>
    <revision>
      <id>50611</id>
      <parentid>41847</parentid>
      <timestamp>2013-06-01T03:34:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/key_comp|multiset}}

[[de:cpp/container/multiset/key comp]]
[[es:cpp/container/multiset/key comp]]
[[fr:cpp/container/multiset/key comp]]
[[it:cpp/container/multiset/key comp]]
[[ja:cpp/container/multiset/key comp]]
[[pt:cpp/container/multiset/key comp]]
[[ru:cpp/container/multiset/key comp]]
[[zh:cpp/container/multiset/key comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/lower bound</title>
    <ns>0</ns>
    <id>1024</id>
    <revision>
      <id>50612</id>
      <parentid>41846</parentid>
      <timestamp>2013-06-01T03:34:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/lower_bound|multiset}}

[[de:cpp/container/multiset/lower bound]]
[[es:cpp/container/multiset/lower bound]]
[[fr:cpp/container/multiset/lower bound]]
[[it:cpp/container/multiset/lower bound]]
[[ja:cpp/container/multiset/lower bound]]
[[pt:cpp/container/multiset/lower bound]]
[[ru:cpp/container/multiset/lower bound]]
[[zh:cpp/container/multiset/lower bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/max size</title>
    <ns>0</ns>
    <id>1025</id>
    <revision>
      <id>50613</id>
      <parentid>41845</parentid>
      <timestamp>2013-06-01T03:34:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/max_size|multiset}}

[[de:cpp/container/multiset/max size]]
[[es:cpp/container/multiset/max size]]
[[fr:cpp/container/multiset/max size]]
[[it:cpp/container/multiset/max size]]
[[ja:cpp/container/multiset/max size]]
[[pt:cpp/container/multiset/max size]]
[[ru:cpp/container/multiset/max size]]
[[zh:cpp/container/multiset/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/multiset</title>
    <ns>0</ns>
    <id>1026</id>
    <revision>
      <id>50614</id>
      <parentid>41840</parentid>
      <timestamp>2013-06-01T03:34:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="368">{{include page|cpp/container/constructor ord|multiset}}

[[de:cpp/container/multiset/multiset]]
[[es:cpp/container/multiset/multiset]]
[[fr:cpp/container/multiset/multiset]]
[[it:cpp/container/multiset/multiset]]
[[ja:cpp/container/multiset/multiset]]
[[pt:cpp/container/multiset/multiset]]
[[ru:cpp/container/multiset/multiset]]
[[zh:cpp/container/multiset/multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/operator=</title>
    <ns>0</ns>
    <id>1027</id>
    <revision>
      <id>41835</id>
      <parentid>2055</parentid>
      <timestamp>2012-11-02T20:14:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="361">{{cpp/container/operator{{=}}|multiset}}

[[de:cpp/container/multiset/operator=]]
[[es:cpp/container/multiset/operator=]]
[[fr:cpp/container/multiset/operator=]]
[[it:cpp/container/multiset/operator=]]
[[ja:cpp/container/multiset/operator=]]
[[pt:cpp/container/multiset/operator=]]
[[ru:cpp/container/multiset/operator=]]
[[zh:cpp/container/multiset/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/operator cmp</title>
    <ns>0</ns>
    <id>2015</id>
    <revision>
      <id>50615</id>
      <parentid>41832</parentid>
      <timestamp>2013-06-01T03:34:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="397">{{include page|cpp/container/operator_cmp|multiset}}

[[de:cpp/container/multiset/operator cmp]]
[[es:cpp/container/multiset/operator cmp]]
[[fr:cpp/container/multiset/operator cmp]]
[[it:cpp/container/multiset/operator cmp]]
[[ja:cpp/container/multiset/operator cmp]]
[[pt:cpp/container/multiset/operator cmp]]
[[ru:cpp/container/multiset/operator cmp]]
[[zh:cpp/container/multiset/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/operator comp</title>
    <ns>0</ns>
    <id>4208</id>
    <redirect title="cpp/container/multiset/operator cmp" />
    <revision>
      <id>15233</id>
      <timestamp>2011-12-08T01:10:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/multiset/operator comp]] to [[cpp/container/multiset/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/container/multiset/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/rbegin</title>
    <ns>0</ns>
    <id>1028</id>
    <revision>
      <id>50616</id>
      <parentid>41829</parentid>
      <timestamp>2013-06-01T03:34:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/rbegin|multiset}}

[[de:cpp/container/multiset/rbegin]]
[[es:cpp/container/multiset/rbegin]]
[[fr:cpp/container/multiset/rbegin]]
[[it:cpp/container/multiset/rbegin]]
[[ja:cpp/container/multiset/rbegin]]
[[pt:cpp/container/multiset/rbegin]]
[[ru:cpp/container/multiset/rbegin]]
[[zh:cpp/container/multiset/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/rend</title>
    <ns>0</ns>
    <id>1029</id>
    <revision>
      <id>50617</id>
      <parentid>41824</parentid>
      <timestamp>2013-06-01T03:34:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/rend|multiset}}

[[de:cpp/container/multiset/rend]]
[[es:cpp/container/multiset/rend]]
[[fr:cpp/container/multiset/rend]]
[[it:cpp/container/multiset/rend]]
[[ja:cpp/container/multiset/rend]]
[[pt:cpp/container/multiset/rend]]
[[ru:cpp/container/multiset/rend]]
[[zh:cpp/container/multiset/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/size</title>
    <ns>0</ns>
    <id>1030</id>
    <revision>
      <id>50618</id>
      <parentid>41821</parentid>
      <timestamp>2013-06-01T03:34:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/size|multiset}}

[[de:cpp/container/multiset/size]]
[[es:cpp/container/multiset/size]]
[[fr:cpp/container/multiset/size]]
[[it:cpp/container/multiset/size]]
[[ja:cpp/container/multiset/size]]
[[pt:cpp/container/multiset/size]]
[[ru:cpp/container/multiset/size]]
[[zh:cpp/container/multiset/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/std swap</title>
    <ns>0</ns>
    <id>3463</id>
    <redirect title="cpp/container/multiset/swap2" />
    <revision>
      <id>13015</id>
      <timestamp>2011-11-03T18:39:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/multiset/std swap]] to [[cpp/container/multiset/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/container/multiset/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/swap</title>
    <ns>0</ns>
    <id>1031</id>
    <revision>
      <id>50619</id>
      <parentid>41820</parentid>
      <timestamp>2013-06-01T03:34:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/swap|multiset}}

[[de:cpp/container/multiset/swap]]
[[es:cpp/container/multiset/swap]]
[[fr:cpp/container/multiset/swap]]
[[it:cpp/container/multiset/swap]]
[[ja:cpp/container/multiset/swap]]
[[pt:cpp/container/multiset/swap]]
[[ru:cpp/container/multiset/swap]]
[[zh:cpp/container/multiset/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/swap2</title>
    <ns>0</ns>
    <id>2001</id>
    <revision>
      <id>50620</id>
      <parentid>41817</parentid>
      <timestamp>2013-06-01T03:34:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/swap2|multiset}}

[[de:cpp/container/multiset/swap2]]
[[es:cpp/container/multiset/swap2]]
[[fr:cpp/container/multiset/swap2]]
[[it:cpp/container/multiset/swap2]]
[[ja:cpp/container/multiset/swap2]]
[[pt:cpp/container/multiset/swap2]]
[[ru:cpp/container/multiset/swap2]]
[[zh:cpp/container/multiset/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/upper bound</title>
    <ns>0</ns>
    <id>1032</id>
    <revision>
      <id>50621</id>
      <parentid>41814</parentid>
      <timestamp>2013-06-01T03:34:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/upper_bound|multiset}}

[[de:cpp/container/multiset/upper bound]]
[[es:cpp/container/multiset/upper bound]]
[[fr:cpp/container/multiset/upper bound]]
[[it:cpp/container/multiset/upper bound]]
[[ja:cpp/container/multiset/upper bound]]
[[pt:cpp/container/multiset/upper bound]]
[[ru:cpp/container/multiset/upper bound]]
[[zh:cpp/container/multiset/upper bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/value comp</title>
    <ns>0</ns>
    <id>1033</id>
    <revision>
      <id>50622</id>
      <parentid>41809</parentid>
      <timestamp>2013-06-01T03:34:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/value_comp|multiset}}

[[de:cpp/container/multiset/value comp]]
[[es:cpp/container/multiset/value comp]]
[[fr:cpp/container/multiset/value comp]]
[[it:cpp/container/multiset/value comp]]
[[ja:cpp/container/multiset/value comp]]
[[pt:cpp/container/multiset/value comp]]
[[ru:cpp/container/multiset/value comp]]
[[zh:cpp/container/multiset/value comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/multiset/~multiset</title>
    <ns>0</ns>
    <id>255</id>
    <revision>
      <id>50623</id>
      <parentid>41804</parentid>
      <timestamp>2013-06-01T03:34:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/container/destructor|multiset}}

[[de:cpp/container/multiset/~multiset]]
[[es:cpp/container/multiset/~multiset]]
[[fr:cpp/container/multiset/~multiset]]
[[it:cpp/container/multiset/~multiset]]
[[ja:cpp/container/multiset/~multiset]]
[[pt:cpp/container/multiset/~multiset]]
[[ru:cpp/container/multiset/~multiset]]
[[zh:cpp/container/multiset/~multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue</title>
    <ns>0</ns>
    <id>256</id>
    <revision>
      <id>72300</id>
      <parentid>72299</parentid>
      <timestamp>2014-08-06T11:18:44Z</timestamp>
      <contributor>
        <username>Ruediger</username>
        <id>752</id>
      </contributor>
      <comment>Change to use template parameters section similar to {{lc|std::queue}}</comment>
      <text xml:space="preserve" bytes="3045">{{cpp/title|priority_queue}}
{{cpp/container/priority_queue/navbar}}
{{ddcl | header=queue | 1=
template&lt;
    class T,
    class Container = std::vector&lt;T&gt;,
    class Compare = std::less&lt;typename Container::value_type&gt;
&gt; class priority_queue;
}} 

A priority queue is a container adaptor that provides constant time maximum (or minimum, depending on {{tt|Compare}}) extraction at the expense of logarithmic insertion.

Working with a {{tt|priority_queue}} is similar to managing a [[cpp/algorithm/make_heap | heap]] in some random access container, with the benefit of not being able to accidentally invalidate the heap.


===Template parameters===
{{par begin}}
{{par | T | The type of the stored elements.}}
{{par | Container | The type of the underlying container to use to store the elements. The container must satisfy the requirements of {{concept|SequenceContainer}}. Additionally, it must provide the following functions with the usual semantics:

* {{tt|front()}}
* {{tt|push_back()}}
* {{tt|pop_back()}}

The standard containers {{lc|std::vector}} and {{lc|std::deque}} satisfy these requirements.}}
{{par | Compare | A {{concept|Compare}} type providing a strict weak ordering.}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc container_type | priority_queue}}
{{dsc inc | cpp/container/dsc value_type | priority_queue}}
{{dsc inc | cpp/container/dsc size_type | priority_queue}}
{{dsc inc | cpp/container/dsc reference | priority_queue}}
{{dsc inc | cpp/container/dsc const_reference | priority_queue}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | priority_queue}}
{{dsc inc | cpp/container/dsc destructor | priority_queue}}
{{dsc inc | cpp/container/dsc operator{{=}} | priority_queue}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc top | priority_queue}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | priority_queue}}
{{dsc inc | cpp/container/dsc size | priority_queue}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc push | priority_queue}}
{{dsc inc | cpp/container/dsc emplace | priority_queue}}
{{dsc inc | cpp/container/dsc pop | priority_queue}}
{{dsc inc | cpp/container/dsc swap | priority_queue}}

{{dsc h1 | Member objects}}
{{dsc inc | cpp/container/dsc c | priority_queue}}
{{dsc prot mem obj | nolink=true | {{dsc small|Compare}} comp | the comparison function object}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap2 | priority_queue}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc uses_allocator | priority_queue}}
{{dsc end}}

[[cs:cpp/container/priority queue]]
[[de:cpp/container/priority queue]]
[[es:cpp/container/priority queue]]
[[fr:cpp/container/priority queue]]
[[it:cpp/container/priority queue]]
[[ja:cpp/container/priority queue]]
[[pt:cpp/container/priority queue]]
[[ru:cpp/container/priority queue]]
[[tr:cpp/container/priority queue]]
[[zh:cpp/container/priority queue]]</text>
      <sha1>qdxrxhm5920g0wzadp56lzajb5et3o8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/emplace</title>
    <ns>0</ns>
    <id>257</id>
    <revision>
      <id>50624</id>
      <parentid>41798</parentid>
      <timestamp>2013-06-01T03:34:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="409">{{include page|cpp/container/emplace ad|priority_queue}}

[[de:cpp/container/priority queue/emplace]]
[[es:cpp/container/priority queue/emplace]]
[[fr:cpp/container/priority queue/emplace]]
[[it:cpp/container/priority queue/emplace]]
[[ja:cpp/container/priority queue/emplace]]
[[pt:cpp/container/priority queue/emplace]]
[[ru:cpp/container/priority queue/emplace]]
[[zh:cpp/container/priority queue/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/empty</title>
    <ns>0</ns>
    <id>258</id>
    <revision>
      <id>50625</id>
      <parentid>41795</parentid>
      <timestamp>2013-06-01T03:34:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="391">{{include page|cpp/container/empty ad|priority_queue}}

[[de:cpp/container/priority queue/empty]]
[[es:cpp/container/priority queue/empty]]
[[fr:cpp/container/priority queue/empty]]
[[it:cpp/container/priority queue/empty]]
[[ja:cpp/container/priority queue/empty]]
[[pt:cpp/container/priority queue/empty]]
[[ru:cpp/container/priority queue/empty]]
[[zh:cpp/container/priority queue/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/operator=</title>
    <ns>0</ns>
    <id>259</id>
    <revision>
      <id>63202</id>
      <parentid>41792</parentid>
      <timestamp>2013-07-05T18:13:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>include page</comment>
      <text xml:space="preserve" bytes="431">{{include page|cpp/container/operator{{=}} ad|priority_queue}}

[[de:cpp/container/priority queue/operator=]]
[[es:cpp/container/priority queue/operator=]]
[[fr:cpp/container/priority queue/operator=]]
[[it:cpp/container/priority queue/operator=]]
[[ja:cpp/container/priority queue/operator=]]
[[pt:cpp/container/priority queue/operator=]]
[[ru:cpp/container/priority queue/operator=]]
[[zh:cpp/container/priority queue/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/pop</title>
    <ns>0</ns>
    <id>260</id>
    <revision>
      <id>50626</id>
      <parentid>41790</parentid>
      <timestamp>2013-06-01T03:34:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/pop|priority_queue}}

[[de:cpp/container/priority queue/pop]]
[[es:cpp/container/priority queue/pop]]
[[fr:cpp/container/priority queue/pop]]
[[it:cpp/container/priority queue/pop]]
[[ja:cpp/container/priority queue/pop]]
[[pt:cpp/container/priority queue/pop]]
[[ru:cpp/container/priority queue/pop]]
[[zh:cpp/container/priority queue/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/priority queue</title>
    <ns>0</ns>
    <id>261</id>
    <revision>
      <id>72137</id>
      <parentid>66668</parentid>
      <timestamp>2014-07-18T11:30:28Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>-extra }}</comment>
      <text xml:space="preserve" bytes="7463">{{cpp/container/priority_queue/title | priority_queue}}
{{cpp/container/priority_queue/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 | 1=
explicit priority_queue( const Compare&amp; compare = Compare(),
                         const Container&amp; cont = Container() );
}}
{{dcl | since=c++11 | 1=
priority_queue( const Compare&amp; compare, const Container&amp; cont );
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 | 1=
explicit priority_queue( const Compare&amp; compare = Compare(),
                         Container&amp;&amp; cont = Container() );
}}
{{dcl | num=3 |1=
priority_queue( const priority_queue&amp; other );
}}
{{dcl | num=4 | since=c++11 |1=
priority_queue( priority_queue&amp;&amp; other );
}}
{{dcl | num=5 | since=c++11 |1=
template&lt; class Alloc &gt; 
explicit priority_queue( const Alloc&amp; alloc );
}}
{{dcl | num=6 | since=c++11 |1=
template&lt; class Alloc &gt; 
priority_queue( const Compare&amp; compare, const Alloc&amp; alloc );
}}
{{dcl | num=7 | since=c++11 |1=
template&lt; class Alloc &gt; 
priority_queue( const Compare&amp; compare, const Container&amp; cont,
                const Alloc&amp; alloc );
}}
{{dcl | num=8 | since=c++11 |1=
template&lt; class Alloc &gt; 
priority_queue( const Compare&amp; compare, Container&amp;&amp; cont,
                const Alloc&amp; alloc );
}}
{{dcl | num=9 | since=c++11 |1=
template&lt; class Alloc &gt; 
priority_queue( const priority_queue&amp; other, const Alloc&amp; alloc );
}}
{{dcl | num=10 | since=c++11 |1=
template&lt; class Alloc &gt; 
priority_queue( priority_queue&amp;&amp; other, const Alloc&amp; alloc );
}}
{{dcl | num=11 | since=c++11 |1=
template&lt; class InputIt &gt;
priority_queue( InputIt first, InputIt last,
                const Compare&amp; compare, const Container&amp; cont );
}}
{{dcl | num=12 | since=c++11 |1=
template&lt; class InputIt &gt;
priority_queue( InputIt first, InputIt last,
                const Compare&amp; compare = Compare(), 
                Container&amp;&amp; cont = Container() );
}}
{{dcl end}}

Constructs new underlying container of the container adaptor from a variety of data sources.

@1@ Copy-constructs the underlying container {{tt|c}} with the contents of {{tt|cont}}. Copy-constructs the comparison functor {{tt|comp}} with the contents of {{tt|compare}}. Calls {{c|std::make_heap(c.begin(), c.end(), comp)}}. {{rev inl|until=c++11| This is also the default constructor.}}

@2@ Move-constructs the underlying container {{tt|c}} with {{c|std::move(cont)}}. Move-constructs the comparison functor {{tt|comp}} with {{c|std::move(compare)}}. Calls {{c|std::make_heap(c.begin(), c.end(), comp)}}. {{rev inl|since=c++11 | This is also the default constructor.}}

@3@ Copy constructor. The adaptor is copy-constructed with the contents of {{c|other.c}}. The comparison functor is constructed with {{c|std::move(other.comp)}}. {{mark implicit}}

@4@ Move constructor. The adaptor is constructed with {{c|std::move(other.c)}}.The comparison functor is constructed with {{c|std::move(other.comp)}}. {{mark implicit}}

@5-10@ The following constructors are only defined if {{c|1=std::uses_allocator&lt;container_type, Alloc&gt;::value == true}}, that is, if the underlying container is an allocator-aware container (true for all standard library containers).

:@5@ Constructs the underlying container using {{tt|alloc}} as allocator. Effectively calls {{c|c(alloc)}}. {{#ifeq:priority_queue|priority_queue|{{tt|comp}} is value-initialized.}}

:@6@ Constructs the underlying container using {{tt|alloc}} as allocator. Effectively calls {{c|c(alloc)}}. Copy-constructs {{tt|comp}} from {{tt|compare}}.

:@7@ Constructs the underlying container with the contents of {{tt|cont}} and using {{tt|alloc}} as allocator. Effectively calls {{c|c(cont, alloc)}}. Copy-constructs {{tt|comp}} from {{tt|compare}}.

:@8@ Constructs the underlying container with the contents of {{tt|cont}} using move semantics while utilising {{tt|alloc}} as allocator. Effectively calls {{c|c(std::move(cont), alloc)}}. Copy-constructs {{tt|comp}} from {{tt|compare}}.

:@9@Constructs the adaptor with the contents of {{tt|other.c}} and using {{tt|alloc}} as allocator. Effectively calls {{c|c(athor.c, alloc)}}. Copy-constructs {{tt|comp}} from {{tt|other.comp}}.

:@10@ Constructs the adaptor with the contents of {{tt|other}} using move semantics while utilising {{tt|alloc}} as allocator. Effectively calls {{c|c(std::move(other.c), alloc)}}. Move-constructs {{tt|comp}} from {{tt|other.comp}}.

@11@ Copy-constructs {{tt|c}} from {{tt|cont}} and {{tt|comp}} from {{tt|compare}}. Then calls {{c|c.insert(c.end(), first, last);}}, and then calls {{c|std::make_heap(c.begin(), c.end(), comp);}}.

@12@ Move-constructs {{tt|c}} from {{tt|std::move(cont)}} and {{tt|comp}} from {{tt|std::move(compare)}}. Then calls {{c|c.insert(c.end(), first, last);}}, and then calls {{c|std::make_heap(c.begin(), c.end(), comp);}}.

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of the underlying container}}
{{par | other | another container adaptor to be used as source to initialize the underlying container}}
{{par | cont | container to be used as source to initialize the underlying container}}
{{par | compare | the comparison function object to initialize the underlying comparison functor}}
{{par | first, last | range of elements to initialize with}}
{{par hreq}}
{{par req concept | Alloc | Allocator}}
{{par req concept | Container | Container | notes=The constructors (5-10) are only defined if {{tt|Container}} meets the requirements of {{concept|AllocatorAwareContainer}}}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===
@1,3@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size()}}.

@@ Additionally, {{math|O(N)}} calls to the constructor of {{tt|value_type}}, where {{math|N}} is {{c|cont.size()}}.

@2@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size()}}.

@4-6@ Constant.

@7@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size()}}.

@@ Additionally, {{math|O(N)}} calls to the constructor of {{tt|value_type}}, where {{math|N}} is {{c|cont.size()}}.

@8@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size()}}.

@9@ Linear in size of {{tt|other}}.

@10@ Constant.

@11@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size() + std::distance(first, last)}}.

@@ Additionally, {{math|O(N)}} calls to the constructor of {{tt|value_type}}, where {{math|N}} is {{c|cont.size()}}.

@12@ {{math|O(N log(N))}} comparisons, where {{math|N}} is {{c|cont.size() + std::distance(first, last)}}.

===Example===
{{example
 | code=
#include &lt;queue&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;

int main()
{
    std::priority_queue&lt;int&gt; c1;
    c1.push(5);
    std::cout &lt;&lt; c1.size() &lt;&lt; '\n';

    std::priority_queue&lt;int&gt; c2(c1);
    std::cout &lt;&lt; c2.size() &lt;&lt; '\n';
 
    std::vector&lt;int&gt; vec={3, 1, 4, 1, 5};
    std::priority_queue&lt;int&gt; c3(std::less&lt;int&gt;(), vec);
    std::cout &lt;&lt; c3.size() &lt;&lt; '\n';
}
 | output=
1
1
5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator{{=}} | priority_queue}}
{{dsc end}}

[[de:cpp/container/priority queue/priority queue]]
[[es:cpp/container/priority queue/priority queue]]
[[fr:cpp/container/priority queue/priority queue]]
[[it:cpp/container/priority queue/priority queue]]
[[ja:cpp/container/priority queue/priority queue]]
[[pt:cpp/container/priority queue/priority queue]]
[[ru:cpp/container/priority queue/priority queue]]
[[zh:cpp/container/priority queue/priority queue]]</text>
      <sha1>qk5wlyyeisuxesb2kgqkr2ps1osy5mz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/push</title>
    <ns>0</ns>
    <id>262</id>
    <revision>
      <id>50627</id>
      <parentid>41783</parentid>
      <timestamp>2013-06-01T03:34:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/push|priority_queue}}

[[de:cpp/container/priority queue/push]]
[[es:cpp/container/priority queue/push]]
[[fr:cpp/container/priority queue/push]]
[[it:cpp/container/priority queue/push]]
[[ja:cpp/container/priority queue/push]]
[[pt:cpp/container/priority queue/push]]
[[ru:cpp/container/priority queue/push]]
[[zh:cpp/container/priority queue/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/size</title>
    <ns>0</ns>
    <id>263</id>
    <revision>
      <id>50628</id>
      <parentid>41781</parentid>
      <timestamp>2013-06-01T03:34:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="382">{{include page|cpp/container/size ad|priority_queue}}

[[de:cpp/container/priority queue/size]]
[[es:cpp/container/priority queue/size]]
[[fr:cpp/container/priority queue/size]]
[[it:cpp/container/priority queue/size]]
[[ja:cpp/container/priority queue/size]]
[[pt:cpp/container/priority queue/size]]
[[ru:cpp/container/priority queue/size]]
[[zh:cpp/container/priority queue/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/std swap</title>
    <ns>0</ns>
    <id>3464</id>
    <redirect title="cpp/container/priority queue/swap2" />
    <revision>
      <id>13017</id>
      <timestamp>2011-11-03T18:40:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/priority queue/std swap]] to [[cpp/container/priority queue/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/container/priority queue/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/swap</title>
    <ns>0</ns>
    <id>264</id>
    <revision>
      <id>50629</id>
      <parentid>41778</parentid>
      <timestamp>2013-06-01T03:34:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="382">{{include page|cpp/container/swap ad|priority_queue}}

[[de:cpp/container/priority queue/swap]]
[[es:cpp/container/priority queue/swap]]
[[fr:cpp/container/priority queue/swap]]
[[it:cpp/container/priority queue/swap]]
[[ja:cpp/container/priority queue/swap]]
[[pt:cpp/container/priority queue/swap]]
[[ru:cpp/container/priority queue/swap]]
[[zh:cpp/container/priority queue/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/swap2</title>
    <ns>0</ns>
    <id>3016</id>
    <revision>
      <id>50630</id>
      <parentid>41776</parentid>
      <timestamp>2013-06-01T03:34:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/swap2|priority_queue}}

[[de:cpp/container/priority queue/swap2]]
[[es:cpp/container/priority queue/swap2]]
[[fr:cpp/container/priority queue/swap2]]
[[it:cpp/container/priority queue/swap2]]
[[ja:cpp/container/priority queue/swap2]]
[[pt:cpp/container/priority queue/swap2]]
[[ru:cpp/container/priority queue/swap2]]
[[zh:cpp/container/priority queue/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/top</title>
    <ns>0</ns>
    <id>265</id>
    <revision>
      <id>60936</id>
      <parentid>57293</parentid>
      <timestamp>2013-06-01T12:08:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use lc</comment>
      <text xml:space="preserve" bytes="919">{{cpp/container/priority_queue/title | top}}
{{cpp/container/priority_queue/navbar}}
{{ddcl |
const_reference top() const;
}}

Returns reference to the top element in the priority queue. This element will be removed on a call to {{lc|pop()}}. If default comparison function is used, the returned element is also the greatest among the elements in the queue. 

===Parameters===
(none)

===Return value===

Reference to the top element as if obtained by a call to {{c|c.front()}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc pop|priority_queue}}
{{dsc end}}

[[de:cpp/container/priority queue/top]]
[[es:cpp/container/priority queue/top]]
[[fr:cpp/container/priority queue/top]]
[[it:cpp/container/priority queue/top]]
[[ja:cpp/container/priority queue/top]]
[[pt:cpp/container/priority queue/top]]
[[ru:cpp/container/priority queue/top]]
[[zh:cpp/container/priority queue/top]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/uses allocator</title>
    <ns>0</ns>
    <id>3402</id>
    <revision>
      <id>50631</id>
      <parentid>41770</parentid>
      <timestamp>2013-06-01T03:34:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="469">{{include page|cpp/container/uses_allocator|priority_queue}}

[[de:cpp/container/priority queue/uses allocator]]
[[es:cpp/container/priority queue/uses allocator]]
[[fr:cpp/container/priority queue/uses allocator]]
[[it:cpp/container/priority queue/uses allocator]]
[[ja:cpp/container/priority queue/uses allocator]]
[[pt:cpp/container/priority queue/uses allocator]]
[[ru:cpp/container/priority queue/uses allocator]]
[[zh:cpp/container/priority queue/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/priority queue/~priority queue</title>
    <ns>0</ns>
    <id>266</id>
    <revision>
      <id>50632</id>
      <parentid>41767</parentid>
      <timestamp>2013-06-01T03:34:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="473">{{include page|cpp/container/destructor|priority_queue}}

[[de:cpp/container/priority queue/~priority queue]]
[[es:cpp/container/priority queue/~priority queue]]
[[fr:cpp/container/priority queue/~priority queue]]
[[it:cpp/container/priority queue/~priority queue]]
[[ja:cpp/container/priority queue/~priority queue]]
[[pt:cpp/container/priority queue/~priority queue]]
[[ru:cpp/container/priority queue/~priority queue]]
[[zh:cpp/container/priority queue/~priority queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue</title>
    <ns>0</ns>
    <id>267</id>
    <revision>
      <id>64023</id>
      <parentid>57296</parentid>
      <timestamp>2013-08-06T20:32:57Z</timestamp>
      <contributor>
        <username>Blindley</username>
        <id>10</id>
      </contributor>
      <comment>vector has no pop_front member</comment>
      <text xml:space="preserve" bytes="2649">{{cpp/title|queue}}
{{cpp/container/queue/navbar}}
{{ddcl | header=queue |
template&lt;
    class T,
    class Container {{=}} std::deque&lt;T&gt;
&gt; class queue;
}} 

The {{tt|std::queue}} class is a container adapter that gives the programmer the functionality of a queue - specifically, a FIFO (first-in, first-out) data structure. 

The class template acts as a wrapper to the underlying container - only a specific set of functions is provided. The queue pushes the elements on the back of the underlying container and pops them from the front.

===Template parameters===
{{par begin}}
{{par | T | The type of the stored elements.}}
{{par | Container | The type of the underlying container to use to store the elements. The container must satisfy the requirements of {{concept|SequenceContainer}}. Additionally, it must provide the following functions with the usual semantics:

* {{tt|back()}}
* {{tt|front()}}
* {{tt|push_back()}}
* {{tt|pop_front()}}

The standard containers {{lc|std::deque}} and {{lc|std::list}} satisfy these requirements. 
}}{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc container_type | queue}}
{{dsc inc | cpp/container/dsc value_type | queue}}
{{dsc inc | cpp/container/dsc size_type | queue}}
{{dsc inc | cpp/container/dsc reference | queue}}
{{dsc inc | cpp/container/dsc const_reference | queue}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | queue}}
{{dsc inc | cpp/container/dsc destructor | queue}}
{{dsc inc | cpp/container/dsc operator{{=}} | queue}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc front | queue}}
{{dsc inc | cpp/container/dsc back | queue}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | queue}}
{{dsc inc | cpp/container/dsc size | queue}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc push | queue}}
{{dsc inc | cpp/container/dsc emplace | queue}}
{{dsc inc | cpp/container/dsc pop | queue}}
{{dsc inc | cpp/container/dsc swap | queue}}

{{dsc h1 | Member objects}}
{{dsc inc | cpp/container/dsc c | queue}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | queue}}
{{dsc inc | cpp/container/dsc swap2 | queue}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc uses_allocator | queue}}
{{dsc end}}

[[de:cpp/container/queue]]
[[es:cpp/container/queue]]
[[fr:cpp/container/queue]]
[[it:cpp/container/queue]]
[[ja:cpp/container/queue]]
[[pl:cpp/container/queue]]
[[pt:cpp/container/queue]]
[[ru:cpp/container/queue]]
[[tr:cpp/container/queue]]
[[zh:cpp/container/queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/back</title>
    <ns>0</ns>
    <id>268</id>
    <revision>
      <id>69407</id>
      <parentid>57297</parentid>
      <timestamp>2014-04-07T11:41:59Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="814">{{cpp/container/queue/title | back}}
{{cpp/container/queue/navbar}}
{{dcl begin}}
{{dcl |
reference back();
}}
{{dcl |
const_reference back() const;
}}
{{dcl end}}

Returns reference to the last element in the queue. This is the most recently pushed element. Effectively calls {{c|c.back()}}.

===Parameters===
(none)

===Return value===

reference to the last element

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc front|queue}}
{{dsc inc | cpp/container/dsc push|queue}}
{{dsc end}}

[[de:cpp/container/queue/back]]
[[es:cpp/container/queue/back]]
[[fr:cpp/container/queue/back]]
[[it:cpp/container/queue/back]]
[[ja:cpp/container/queue/back]]
[[pl:cpp/container/queue/back]]
[[pt:cpp/container/queue/back]]
[[ru:cpp/container/queue/back]]
[[zh:cpp/container/queue/back]]</text>
      <sha1>0rdwtn2fztd0qj19eydv22u1uz9u6ds</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/emplace</title>
    <ns>0</ns>
    <id>269</id>
    <revision>
      <id>50633</id>
      <parentid>41759</parentid>
      <timestamp>2013-06-01T03:34:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="328">{{include page|cpp/container/emplace ad|queue}}

[[de:cpp/container/queue/emplace]]
[[es:cpp/container/queue/emplace]]
[[fr:cpp/container/queue/emplace]]
[[it:cpp/container/queue/emplace]]
[[ja:cpp/container/queue/emplace]]
[[pt:cpp/container/queue/emplace]]
[[ru:cpp/container/queue/emplace]]
[[zh:cpp/container/queue/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/empty</title>
    <ns>0</ns>
    <id>270</id>
    <revision>
      <id>50634</id>
      <parentid>41757</parentid>
      <timestamp>2013-06-01T03:34:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/empty ad|queue}}

[[de:cpp/container/queue/empty]]
[[es:cpp/container/queue/empty]]
[[fr:cpp/container/queue/empty]]
[[it:cpp/container/queue/empty]]
[[ja:cpp/container/queue/empty]]
[[pl:cpp/container/queue/empty]]
[[pt:cpp/container/queue/empty]]
[[ru:cpp/container/queue/empty]]
[[zh:cpp/container/queue/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/front</title>
    <ns>0</ns>
    <id>271</id>
    <revision>
      <id>60968</id>
      <parentid>60967</parentid>
      <timestamp>2013-06-03T11:20:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="864">{{cpp/container/queue/title | front}}
{{cpp/container/queue/navbar}}
{{dcl begin}}
{{dcl |
reference front();
}}
{{dcl |
const_reference front() const;
}}
{{dcl end}}

Returns reference to the first element in the queue. This element will be the first element to be removed on a call to {{lc|pop()}}. Effectively calls {{c|c.front()}}.

===Parameters===
(none)

===Return value===
Reference to the first element.

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc back|queue}}
{{dsc inc | cpp/container/dsc pop|queue}}
{{dsc end}}

[[de:cpp/container/queue/front]]
[[es:cpp/container/queue/front]]
[[fr:cpp/container/queue/front]]
[[it:cpp/container/queue/front]]
[[ja:cpp/container/queue/front]]
[[pl:cpp/container/queue/front]]
[[pt:cpp/container/queue/front]]
[[ru:cpp/container/queue/front]]
[[zh:cpp/container/queue/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/operator=</title>
    <ns>0</ns>
    <id>272</id>
    <revision>
      <id>41753</id>
      <parentid>543</parentid>
      <timestamp>2012-11-02T19:28:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/container/operator{{=}} ad|queue}}

[[de:cpp/container/queue/operator=]]
[[es:cpp/container/queue/operator=]]
[[fr:cpp/container/queue/operator=]]
[[it:cpp/container/queue/operator=]]
[[ja:cpp/container/queue/operator=]]
[[pt:cpp/container/queue/operator=]]
[[ru:cpp/container/queue/operator=]]
[[zh:cpp/container/queue/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/operator cmp</title>
    <ns>0</ns>
    <id>9079</id>
    <revision>
      <id>50635</id>
      <parentid>41749</parentid>
      <timestamp>2013-06-01T03:34:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="378">{{include page|cpp/container_adaptor/operator_cmp|queue}}

[[de:cpp/container/queue/operator cmp]]
[[es:cpp/container/queue/operator cmp]]
[[fr:cpp/container/queue/operator cmp]]
[[it:cpp/container/queue/operator cmp]]
[[ja:cpp/container/queue/operator cmp]]
[[pt:cpp/container/queue/operator cmp]]
[[ru:cpp/container/queue/operator cmp]]
[[zh:cpp/container/queue/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/pop</title>
    <ns>0</ns>
    <id>273</id>
    <revision>
      <id>50636</id>
      <parentid>41746</parentid>
      <timestamp>2013-06-01T03:34:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="320">{{include page|cpp/container/pop|queue}}

[[de:cpp/container/queue/pop]]
[[es:cpp/container/queue/pop]]
[[fr:cpp/container/queue/pop]]
[[it:cpp/container/queue/pop]]
[[ja:cpp/container/queue/pop]]
[[pl:cpp/container/queue/pop]]
[[pt:cpp/container/queue/pop]]
[[ru:cpp/container/queue/pop]]
[[zh:cpp/container/queue/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/push</title>
    <ns>0</ns>
    <id>274</id>
    <revision>
      <id>50637</id>
      <parentid>41743</parentid>
      <timestamp>2013-06-01T03:35:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/container/push|queue}}

[[de:cpp/container/queue/push]]
[[es:cpp/container/queue/push]]
[[fr:cpp/container/queue/push]]
[[it:cpp/container/queue/push]]
[[ja:cpp/container/queue/push]]
[[pl:cpp/container/queue/push]]
[[pt:cpp/container/queue/push]]
[[ru:cpp/container/queue/push]]
[[zh:cpp/container/queue/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/queue</title>
    <ns>0</ns>
    <id>275</id>
    <revision>
      <id>50638</id>
      <parentid>41740</parentid>
      <timestamp>2013-06-01T03:35:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="349">{{include page|cpp/container/constructor ad|queue}}

[[de:cpp/container/queue/queue]]
[[es:cpp/container/queue/queue]]
[[fr:cpp/container/queue/queue]]
[[it:cpp/container/queue/queue]]
[[ja:cpp/container/queue/queue]]
[[pl:cpp/container/queue/queue]]
[[pt:cpp/container/queue/queue]]
[[ru:cpp/container/queue/queue]]
[[zh:cpp/container/queue/queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/size</title>
    <ns>0</ns>
    <id>276</id>
    <revision>
      <id>50639</id>
      <parentid>41738</parentid>
      <timestamp>2013-06-01T03:35:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="333">{{include page|cpp/container/size ad|queue}}

[[de:cpp/container/queue/size]]
[[es:cpp/container/queue/size]]
[[fr:cpp/container/queue/size]]
[[it:cpp/container/queue/size]]
[[ja:cpp/container/queue/size]]
[[pl:cpp/container/queue/size]]
[[pt:cpp/container/queue/size]]
[[ru:cpp/container/queue/size]]
[[zh:cpp/container/queue/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/std swap</title>
    <ns>0</ns>
    <id>3466</id>
    <redirect title="cpp/container/queue/swap2" />
    <revision>
      <id>13021</id>
      <timestamp>2011-11-03T18:41:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/queue/std swap]] to [[cpp/container/queue/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/container/queue/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/swap</title>
    <ns>0</ns>
    <id>277</id>
    <revision>
      <id>50640</id>
      <parentid>41736</parentid>
      <timestamp>2013-06-01T03:35:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="301">{{include page|cpp/container/swap ad|queue}}

[[de:cpp/container/queue/swap]]
[[es:cpp/container/queue/swap]]
[[fr:cpp/container/queue/swap]]
[[it:cpp/container/queue/swap]]
[[ja:cpp/container/queue/swap]]
[[pt:cpp/container/queue/swap]]
[[ru:cpp/container/queue/swap]]
[[zh:cpp/container/queue/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/swap2</title>
    <ns>0</ns>
    <id>3015</id>
    <revision>
      <id>50641</id>
      <parentid>41735</parentid>
      <timestamp>2013-06-01T03:35:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/swap2|queue}}

[[de:cpp/container/queue/swap2]]
[[es:cpp/container/queue/swap2]]
[[fr:cpp/container/queue/swap2]]
[[it:cpp/container/queue/swap2]]
[[ja:cpp/container/queue/swap2]]
[[pt:cpp/container/queue/swap2]]
[[ru:cpp/container/queue/swap2]]
[[zh:cpp/container/queue/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/uses allocator</title>
    <ns>0</ns>
    <id>3401</id>
    <revision>
      <id>50642</id>
      <parentid>41733</parentid>
      <timestamp>2013-06-01T03:35:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/uses_allocator|queue}}

[[de:cpp/container/queue/uses allocator]]
[[es:cpp/container/queue/uses allocator]]
[[fr:cpp/container/queue/uses allocator]]
[[it:cpp/container/queue/uses allocator]]
[[ja:cpp/container/queue/uses allocator]]
[[pt:cpp/container/queue/uses allocator]]
[[ru:cpp/container/queue/uses allocator]]
[[zh:cpp/container/queue/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/queue/~queue</title>
    <ns>0</ns>
    <id>278</id>
    <revision>
      <id>50643</id>
      <parentid>41730</parentid>
      <timestamp>2013-06-01T03:35:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="320">{{include page|cpp/container/destructor|queue}}

[[de:cpp/container/queue/~queue]]
[[es:cpp/container/queue/~queue]]
[[fr:cpp/container/queue/~queue]]
[[it:cpp/container/queue/~queue]]
[[ja:cpp/container/queue/~queue]]
[[pt:cpp/container/queue/~queue]]
[[ru:cpp/container/queue/~queue]]
[[zh:cpp/container/queue/~queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set</title>
    <ns>0</ns>
    <id>279</id>
    <revision>
      <id>57301</id>
      <parentid>49451</parentid>
      <timestamp>2013-06-01T05:51:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3263">{{cpp/title|set}}
{{cpp/container/set/navbar}}
{{ddcl | header=set |
template&lt;
    class Key,
    class Compare {{=}} std::less&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt;
&gt; class set;
}} 

{{tt|std::set}} is an associative container that contains a sorted set of unique objects of type Key. Sorting is done using the key comparison function Compare. Search, removal, and insertion operations have logarithmic complexity. Sets are usually implemented as [[enwiki:Red–black_tree|red-black trees]].

{{tt|std::set}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|AssociativeContainer}} and {{concept|ReversibleContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | set}}
{{dsc inc | cpp/container/dsc value_type | set}}
{{dsc inc | cpp/container/dsc size_type | set}}
{{dsc inc | cpp/container/dsc difference_type | set}}
{{dsc inc | cpp/container/dsc key_compare | set}}
{{dsc inc | cpp/container/dsc value_compare2 | set}}
{{dsc inc | cpp/container/dsc allocator_type | set}}
{{dsc inc | cpp/container/dsc reference | set}}
{{dsc inc | cpp/container/dsc const_reference | set}}
{{dsc inc | cpp/container/dsc pointer | set}}
{{dsc inc | cpp/container/dsc const_pointer | set}}
{{dsc inc | cpp/container/dsc iterator | set}}
{{dsc inc | cpp/container/dsc const_iterator | set}}
{{dsc inc | cpp/container/dsc reverse_iterator | set}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | set}}
{{dsc end}}



===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | set}}
{{dsc inc | cpp/container/dsc destructor | set}}
{{dsc inc | cpp/container/dsc operator{{=}} | set}}
{{dsc inc | cpp/container/dsc get_allocator | set}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | set}}
{{dsc inc | cpp/container/dsc end | set}}
{{dsc inc | cpp/container/dsc rbegin | set}}
{{dsc inc | cpp/container/dsc rend | set}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | set}}
{{dsc inc | cpp/container/dsc size | set}}
{{dsc inc | cpp/container/dsc max_size | set}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | set}}
{{dsc inc | cpp/container/dsc insert | set}}
{{dsc inc | cpp/container/dsc emplace | set}}
{{dsc inc | cpp/container/dsc emplace_hint | set}}
{{dsc inc | cpp/container/dsc erase | set}}
{{dsc inc | cpp/container/dsc swap | set}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | set}}
{{dsc inc | cpp/container/dsc find | set}}
{{dsc inc | cpp/container/dsc equal_range | set}}
{{dsc inc | cpp/container/dsc lower_bound | set}}
{{dsc inc | cpp/container/dsc upper_bound | set}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc key_comp | set}}
{{dsc inc | cpp/container/dsc value_comp | set}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | set}}
{{dsc inc | cpp/container/dsc swap2 | set}}
{{dsc end}}

===Notes===
{{cpp/container/assoc_note}}

[[cs:cpp/container/set]]
[[de:cpp/container/set]]
[[es:cpp/container/set]]
[[fr:cpp/container/set]]
[[it:cpp/container/set]]
[[ja:cpp/container/set]]
[[pl:cpp/container/set]]
[[pt:cpp/container/set]]
[[ru:cpp/container/set]]
[[zh:cpp/container/set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/begin</title>
    <ns>0</ns>
    <id>280</id>
    <revision>
      <id>50644</id>
      <parentid>41724</parentid>
      <timestamp>2013-06-01T03:35:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/begin|set}}

[[de:cpp/container/set/begin]]
[[es:cpp/container/set/begin]]
[[fr:cpp/container/set/begin]]
[[it:cpp/container/set/begin]]
[[ja:cpp/container/set/begin]]
[[pt:cpp/container/set/begin]]
[[ru:cpp/container/set/begin]]
[[zh:cpp/container/set/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/clear</title>
    <ns>0</ns>
    <id>281</id>
    <revision>
      <id>50645</id>
      <parentid>41721</parentid>
      <timestamp>2013-06-01T03:35:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/clear|set}}

[[de:cpp/container/set/clear]]
[[es:cpp/container/set/clear]]
[[fr:cpp/container/set/clear]]
[[it:cpp/container/set/clear]]
[[ja:cpp/container/set/clear]]
[[pt:cpp/container/set/clear]]
[[ru:cpp/container/set/clear]]
[[zh:cpp/container/set/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/count</title>
    <ns>0</ns>
    <id>282</id>
    <revision>
      <id>65131</id>
      <parentid>50646</parentid>
      <timestamp>2013-08-30T16:36:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="293">{{include page|cpp/container/count_ord|set}}

[[de:cpp/container/set/count]]
[[es:cpp/container/set/count]]
[[fr:cpp/container/set/count]]
[[it:cpp/container/set/count]]
[[ja:cpp/container/set/count]]
[[pt:cpp/container/set/count]]
[[ru:cpp/container/set/count]]
[[zh:cpp/container/set/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/crend</title>
    <ns>0</ns>
    <id>10175</id>
    <redirect title="cpp/container/set/rend" />
    <revision>
      <id>48508</id>
      <timestamp>2013-05-30T14:28:26Z</timestamp>
      <contributor>
        <ip>91.115.8.62</ip>
      </contributor>
      <comment>Redirected page to [[cpp/container/set/rend]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/container/set/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/emplace</title>
    <ns>0</ns>
    <id>283</id>
    <revision>
      <id>50647</id>
      <parentid>41716</parentid>
      <timestamp>2013-06-01T03:35:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="313">{{include page|cpp/container/emplace assoc|set}}

[[de:cpp/container/set/emplace]]
[[es:cpp/container/set/emplace]]
[[fr:cpp/container/set/emplace]]
[[it:cpp/container/set/emplace]]
[[ja:cpp/container/set/emplace]]
[[pt:cpp/container/set/emplace]]
[[ru:cpp/container/set/emplace]]
[[zh:cpp/container/set/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/emplace hint</title>
    <ns>0</ns>
    <id>284</id>
    <revision>
      <id>65111</id>
      <parentid>65110</parentid>
      <timestamp>2013-08-30T16:22:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1612">{{cpp/container/set/title | emplace_hint}}
{{cpp/container/set/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.

{{cpp/container/note_iterator_invalidation|set|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

If the insertion failed because the element already exists, returns an iterator to the already existing element with the equivalent key.

===Complexity===
Logarithmic in the size of the container in general, but amortized constant if the new element is inserted just before {{tt|hint}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |set}}
{{dsc inc | cpp/container/dsc insert |set}}
{{dsc end}}

[[de:cpp/container/set/emplace hint]]
[[es:cpp/container/set/emplace hint]]
[[fr:cpp/container/set/emplace hint]]
[[it:cpp/container/set/emplace hint]]
[[ja:cpp/container/set/emplace hint]]
[[pt:cpp/container/set/emplace hint]]
[[ru:cpp/container/set/emplace hint]]
[[zh:cpp/container/set/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/empty</title>
    <ns>0</ns>
    <id>285</id>
    <revision>
      <id>50649</id>
      <parentid>41710</parentid>
      <timestamp>2013-06-01T03:35:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/empty|set}}

[[de:cpp/container/set/empty]]
[[es:cpp/container/set/empty]]
[[fr:cpp/container/set/empty]]
[[it:cpp/container/set/empty]]
[[ja:cpp/container/set/empty]]
[[pt:cpp/container/set/empty]]
[[ru:cpp/container/set/empty]]
[[zh:cpp/container/set/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/end</title>
    <ns>0</ns>
    <id>286</id>
    <revision>
      <id>50650</id>
      <parentid>41708</parentid>
      <timestamp>2013-06-01T03:35:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="271">{{include page|cpp/container/end|set}}

[[de:cpp/container/set/end]]
[[es:cpp/container/set/end]]
[[fr:cpp/container/set/end]]
[[it:cpp/container/set/end]]
[[ja:cpp/container/set/end]]
[[pt:cpp/container/set/end]]
[[ru:cpp/container/set/end]]
[[zh:cpp/container/set/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/equal range</title>
    <ns>0</ns>
    <id>287</id>
    <revision>
      <id>65099</id>
      <parentid>65098</parentid>
      <timestamp>2013-08-30T15:58:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>whoops</comment>
      <text xml:space="preserve" bytes="347">{{include page|cpp/container/equal_range_ord|set}}

[[de:cpp/container/set/equal range]]
[[es:cpp/container/set/equal range]]
[[fr:cpp/container/set/equal range]]
[[it:cpp/container/set/equal range]]
[[ja:cpp/container/set/equal range]]
[[pt:cpp/container/set/equal range]]
[[ru:cpp/container/set/equal range]]
[[zh:cpp/container/set/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/erase</title>
    <ns>0</ns>
    <id>288</id>
    <revision>
      <id>50652</id>
      <parentid>41703</parentid>
      <timestamp>2013-06-01T03:35:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="295">{{include page|cpp/container/erase assoc|set}}

[[de:cpp/container/set/erase]]
[[es:cpp/container/set/erase]]
[[fr:cpp/container/set/erase]]
[[it:cpp/container/set/erase]]
[[ja:cpp/container/set/erase]]
[[pt:cpp/container/set/erase]]
[[ru:cpp/container/set/erase]]
[[zh:cpp/container/set/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/find</title>
    <ns>0</ns>
    <id>289</id>
    <revision>
      <id>50653</id>
      <parentid>41701</parentid>
      <timestamp>2013-06-01T03:35:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/find|set}}

[[de:cpp/container/set/find]]
[[es:cpp/container/set/find]]
[[fr:cpp/container/set/find]]
[[it:cpp/container/set/find]]
[[ja:cpp/container/set/find]]
[[pt:cpp/container/set/find]]
[[ru:cpp/container/set/find]]
[[zh:cpp/container/set/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/get allocator</title>
    <ns>0</ns>
    <id>290</id>
    <revision>
      <id>50654</id>
      <parentid>41700</parentid>
      <timestamp>2013-06-01T03:35:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/get_allocator|set}}

[[de:cpp/container/set/get allocator]]
[[es:cpp/container/set/get allocator]]
[[fr:cpp/container/set/get allocator]]
[[it:cpp/container/set/get allocator]]
[[ja:cpp/container/set/get allocator]]
[[pt:cpp/container/set/get allocator]]
[[ru:cpp/container/set/get allocator]]
[[zh:cpp/container/set/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/insert</title>
    <ns>0</ns>
    <id>291</id>
    <revision>
      <id>68001</id>
      <parentid>66899</parentid>
      <timestamp>2014-03-12T14:16:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>drop redundant type aliases from the example</comment>
      <text xml:space="preserve" bytes="3732">{{cpp/container/set/title | insert}}
{{cpp/container/set/navbar}}
{{dcl begin}}
{{dcl | num=1 | 
std::pair&lt;iterator,bool&gt; insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
std::pair&lt;iterator,bool&gt; insert( value_type&amp;&amp; value );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator insert( iterator hint, const value_type&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 |
iterator insert( const_iterator hint, value_type&amp;&amp; value );
}}
{{dcl | num=5 |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

@1-2@ inserts {{tt|value}}. 

@3-4@ inserts {{tt|value}} in the position as close as possible, just prior{{mark since c++11}}, to {{tt|hint}}. 

@5@ Inserts elements from range {{tt|[first, last)}}.

@6@ Inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|set|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-2@ Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a {{c|bool}} denoting whether the insertion took place.

@3-4@ Returns an iterator to the inserted element, or to the element that prevented the insertion.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}.

{{rev begin}}
{{rev | until=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''after'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev | since=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''before'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev end}}

@5-6@ {{tt|O(N*log(size() + N))}}, where N is the number of elements to insert.

===Notes===
The overloads (5-6) are often implemented &lt;!--examined GNU libstdc++ 4.8 and LLVM libc++ --&gt; as a loop that calls the overload (3) with {{lc|end()}} as the hint; they are optimized for appending a sorted sequence (such as another set) whose smallest element is greater than the last element in {{c|*this}}

===Example===
{{example
|
| code=
#include &lt;set&gt;
#include &lt;cassert&gt;
#include &lt;iostream&gt;

int main()
{
  std::set&lt;int&gt; set;

  auto result_1 = set.insert(3);
  assert(result_1.first != set.end()); // it's a valid iterator
  assert(*result_1.first == 3);
  if (result_1.second)
    std::cout &lt;&lt; &quot;insert done\n&quot;;

  auto result_2 = set.insert(3);
  assert(result_2.first == result_1.first); // same iterator
  assert(*result_2.first == 3);
  if (!result_2.second)
    std::cout &lt;&lt; &quot;no insertion\n&quot;;
}
| output=
insert done
no insertion
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |set}}
{{dsc inc | cpp/container/dsc emplace_hint |set}}
{{dsc end}}

[[de:cpp/container/set/insert]]
[[es:cpp/container/set/insert]]
[[fr:cpp/container/set/insert]]
[[it:cpp/container/set/insert]]
[[ja:cpp/container/set/insert]]
[[pt:cpp/container/set/insert]]
[[ru:cpp/container/set/insert]]
[[zh:cpp/container/set/insert]]</text>
      <sha1>5w5r448syvjbd70tp2g9lg7vcz7xeuw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/key comp</title>
    <ns>0</ns>
    <id>292</id>
    <revision>
      <id>50655</id>
      <parentid>41695</parentid>
      <timestamp>2013-06-01T03:35:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/key_comp|set}}

[[de:cpp/container/set/key comp]]
[[es:cpp/container/set/key comp]]
[[fr:cpp/container/set/key comp]]
[[it:cpp/container/set/key comp]]
[[ja:cpp/container/set/key comp]]
[[pt:cpp/container/set/key comp]]
[[ru:cpp/container/set/key comp]]
[[zh:cpp/container/set/key comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/lower bound</title>
    <ns>0</ns>
    <id>293</id>
    <revision>
      <id>50656</id>
      <parentid>41692</parentid>
      <timestamp>2013-06-01T03:35:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/lower_bound|set}}

[[de:cpp/container/set/lower bound]]
[[es:cpp/container/set/lower bound]]
[[fr:cpp/container/set/lower bound]]
[[it:cpp/container/set/lower bound]]
[[ja:cpp/container/set/lower bound]]
[[pt:cpp/container/set/lower bound]]
[[ru:cpp/container/set/lower bound]]
[[zh:cpp/container/set/lower bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/max size</title>
    <ns>0</ns>
    <id>294</id>
    <revision>
      <id>50657</id>
      <parentid>41689</parentid>
      <timestamp>2013-06-01T03:35:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/max_size|set}}

[[de:cpp/container/set/max size]]
[[es:cpp/container/set/max size]]
[[fr:cpp/container/set/max size]]
[[it:cpp/container/set/max size]]
[[ja:cpp/container/set/max size]]
[[pt:cpp/container/set/max size]]
[[ru:cpp/container/set/max size]]
[[zh:cpp/container/set/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/operator=</title>
    <ns>0</ns>
    <id>295</id>
    <revision>
      <id>41686</id>
      <parentid>589</parentid>
      <timestamp>2012-11-02T18:53:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="316">{{cpp/container/operator{{=}}|set}}

[[de:cpp/container/set/operator=]]
[[es:cpp/container/set/operator=]]
[[fr:cpp/container/set/operator=]]
[[it:cpp/container/set/operator=]]
[[ja:cpp/container/set/operator=]]
[[pt:cpp/container/set/operator=]]
[[ru:cpp/container/set/operator=]]
[[zh:cpp/container/set/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/operator cmp</title>
    <ns>0</ns>
    <id>2016</id>
    <revision>
      <id>50658</id>
      <parentid>41683</parentid>
      <timestamp>2013-06-01T03:35:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="352">{{include page|cpp/container/operator_cmp|set}}

[[de:cpp/container/set/operator cmp]]
[[es:cpp/container/set/operator cmp]]
[[fr:cpp/container/set/operator cmp]]
[[it:cpp/container/set/operator cmp]]
[[ja:cpp/container/set/operator cmp]]
[[pt:cpp/container/set/operator cmp]]
[[ru:cpp/container/set/operator cmp]]
[[zh:cpp/container/set/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/operator comp</title>
    <ns>0</ns>
    <id>4207</id>
    <redirect title="cpp/container/set/operator cmp" />
    <revision>
      <id>15231</id>
      <timestamp>2011-12-08T01:09:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/set/operator comp]] to [[cpp/container/set/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/container/set/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/rbegin</title>
    <ns>0</ns>
    <id>296</id>
    <revision>
      <id>50659</id>
      <parentid>41678</parentid>
      <timestamp>2013-06-01T03:35:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/rbegin|set}}

[[de:cpp/container/set/rbegin]]
[[es:cpp/container/set/rbegin]]
[[fr:cpp/container/set/rbegin]]
[[it:cpp/container/set/rbegin]]
[[ja:cpp/container/set/rbegin]]
[[pt:cpp/container/set/rbegin]]
[[ru:cpp/container/set/rbegin]]
[[zh:cpp/container/set/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/rend</title>
    <ns>0</ns>
    <id>297</id>
    <revision>
      <id>50660</id>
      <parentid>41676</parentid>
      <timestamp>2013-06-01T03:35:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/rend|set}}

[[de:cpp/container/set/rend]]
[[es:cpp/container/set/rend]]
[[fr:cpp/container/set/rend]]
[[it:cpp/container/set/rend]]
[[ja:cpp/container/set/rend]]
[[pt:cpp/container/set/rend]]
[[ru:cpp/container/set/rend]]
[[zh:cpp/container/set/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/set</title>
    <ns>0</ns>
    <id>298</id>
    <revision>
      <id>71728</id>
      <parentid>50661</parentid>
      <timestamp>2014-06-22T07:40:45Z</timestamp>
      <contributor>
        <username>DizzySkin</username>
        <id>3171</id>
      </contributor>
      <comment>Replaced old example with an example that was more bespoke to set, previously used map.</comment>
      <text xml:space="preserve" bytes="286">{{include page|cpp/container/constructor ordset|set}}

[[de:cpp/container/set/set]]
[[es:cpp/container/set/set]]
[[fr:cpp/container/set/set]]
[[it:cpp/container/set/set]]
[[ja:cpp/container/set/set]]
[[pt:cpp/container/set/set]]
[[ru:cpp/container/set/set]]
[[zh:cpp/container/set/set]]</text>
      <sha1>73u8mypw9luizyk5hcmeqeu1ftymdqu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/size</title>
    <ns>0</ns>
    <id>299</id>
    <revision>
      <id>50662</id>
      <parentid>41670</parentid>
      <timestamp>2013-06-01T03:35:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/size|set}}

[[de:cpp/container/set/size]]
[[es:cpp/container/set/size]]
[[fr:cpp/container/set/size]]
[[it:cpp/container/set/size]]
[[ja:cpp/container/set/size]]
[[pt:cpp/container/set/size]]
[[ru:cpp/container/set/size]]
[[zh:cpp/container/set/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/std swap</title>
    <ns>0</ns>
    <id>3465</id>
    <redirect title="cpp/container/set/swap2" />
    <revision>
      <id>13019</id>
      <timestamp>2011-11-03T18:40:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/set/std swap]] to [[cpp/container/set/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/container/set/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/swap</title>
    <ns>0</ns>
    <id>300</id>
    <revision>
      <id>50663</id>
      <parentid>41667</parentid>
      <timestamp>2013-06-01T03:35:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="280">{{include page|cpp/container/swap|set}}

[[de:cpp/container/set/swap]]
[[es:cpp/container/set/swap]]
[[fr:cpp/container/set/swap]]
[[it:cpp/container/set/swap]]
[[ja:cpp/container/set/swap]]
[[pt:cpp/container/set/swap]]
[[ru:cpp/container/set/swap]]
[[zh:cpp/container/set/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/swap2</title>
    <ns>0</ns>
    <id>2000</id>
    <revision>
      <id>50664</id>
      <parentid>41664</parentid>
      <timestamp>2013-06-01T03:35:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/swap2|set}}

[[de:cpp/container/set/swap2]]
[[es:cpp/container/set/swap2]]
[[fr:cpp/container/set/swap2]]
[[it:cpp/container/set/swap2]]
[[ja:cpp/container/set/swap2]]
[[pt:cpp/container/set/swap2]]
[[ru:cpp/container/set/swap2]]
[[zh:cpp/container/set/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/upper bound</title>
    <ns>0</ns>
    <id>301</id>
    <revision>
      <id>50665</id>
      <parentid>41662</parentid>
      <timestamp>2013-06-01T03:35:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/upper_bound|set}}

[[de:cpp/container/set/upper bound]]
[[es:cpp/container/set/upper bound]]
[[fr:cpp/container/set/upper bound]]
[[it:cpp/container/set/upper bound]]
[[ja:cpp/container/set/upper bound]]
[[pt:cpp/container/set/upper bound]]
[[ru:cpp/container/set/upper bound]]
[[zh:cpp/container/set/upper bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/value comp</title>
    <ns>0</ns>
    <id>302</id>
    <revision>
      <id>50666</id>
      <parentid>41658</parentid>
      <timestamp>2013-06-01T03:35:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/value_comp|set}}

[[de:cpp/container/set/value comp]]
[[es:cpp/container/set/value comp]]
[[fr:cpp/container/set/value comp]]
[[it:cpp/container/set/value comp]]
[[ja:cpp/container/set/value comp]]
[[pt:cpp/container/set/value comp]]
[[ru:cpp/container/set/value comp]]
[[zh:cpp/container/set/value comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/set/~set</title>
    <ns>0</ns>
    <id>303</id>
    <revision>
      <id>50667</id>
      <parentid>41656</parentid>
      <timestamp>2013-06-01T03:35:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="286">{{include page|cpp/container/destructor|set}}

[[de:cpp/container/set/~set]]
[[es:cpp/container/set/~set]]
[[fr:cpp/container/set/~set]]
[[it:cpp/container/set/~set]]
[[ja:cpp/container/set/~set]]
[[pt:cpp/container/set/~set]]
[[ru:cpp/container/set/~set]]
[[zh:cpp/container/set/~set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack</title>
    <ns>0</ns>
    <id>304</id>
    <revision>
      <id>57304</id>
      <parentid>49452</parentid>
      <timestamp>2013-06-01T05:51:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2642">{{cpp/title|stack}}
{{cpp/container/stack/navbar}}
{{ddcl | header=stack |
template&lt;
    class T,
    class Container {{=}} std::deque&lt;T&gt;
&gt; class stack;
}} 

The {{tt|std::stack}} class is a container adapter that gives the programmer the functionality of a stack - specifically, a FILO (first-in, last-out) data structure.

The class template acts as a wrapper to the underlying container - only a specific set of functions is provided. The stack pushes and pops the element from the back of the underlying container, known as the top of the stack.

===Template parameters===
{{par begin}}
{{par | T | The type of the stored elements.}}
{{par | Container | The type of the underlying container to use to store the elements. The container must satisfy the requirements of {{concept|SequenceContainer}}. Additionally, it must provide the following functions with the usual semantics:

* {{tt|back()}}
* {{tt|push_back()}}
* {{tt|pop_back()}}

The standard containers {{lc|std::vector}}, {{lc|std::deque}} and {{lc|std::list}} satisfy these requirements. 
}}{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc container_type | stack}}
{{dsc inc | cpp/container/dsc value_type | stack}}
{{dsc inc | cpp/container/dsc size_type | stack}}
{{dsc inc | cpp/container/dsc reference | stack}}
{{dsc inc | cpp/container/dsc const_reference | stack}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | stack}}
{{dsc inc | cpp/container/dsc destructor | stack}}
{{dsc inc | cpp/container/dsc operator{{=}} | stack}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc top | stack}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | stack}}
{{dsc inc | cpp/container/dsc size | stack}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc push | stack}}
{{dsc inc | cpp/container/dsc emplace | stack}}
{{dsc inc | cpp/container/dsc pop | stack}}
{{dsc inc | cpp/container/dsc swap | stack}}

{{dsc h1 | Member objects}}
{{dsc inc | cpp/container/dsc c | stack}}

{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | stack}}
{{dsc inc | cpp/container/dsc swap2 | stack}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/dsc uses_allocator | stack}}
{{dsc end}}

[[cs:cpp/container/stack]]
[[de:cpp/container/stack]]
[[es:cpp/container/stack]]
[[fr:cpp/container/stack]]
[[it:cpp/container/stack]]
[[ja:cpp/container/stack]]
[[pl:cpp/container/stack]]
[[pt:cpp/container/stack]]
[[ru:cpp/container/stack]]
[[tr:cpp/container/stack]]
[[zh:cpp/container/stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/emplace</title>
    <ns>0</ns>
    <id>305</id>
    <revision>
      <id>50668</id>
      <parentid>41652</parentid>
      <timestamp>2013-06-01T03:35:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="328">{{include page|cpp/container/emplace ad|stack}}

[[de:cpp/container/stack/emplace]]
[[es:cpp/container/stack/emplace]]
[[fr:cpp/container/stack/emplace]]
[[it:cpp/container/stack/emplace]]
[[ja:cpp/container/stack/emplace]]
[[pt:cpp/container/stack/emplace]]
[[ru:cpp/container/stack/emplace]]
[[zh:cpp/container/stack/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/empty</title>
    <ns>0</ns>
    <id>306</id>
    <revision>
      <id>50669</id>
      <parentid>41650</parentid>
      <timestamp>2013-06-01T03:35:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="376">{{include page|cpp/container/empty ad|stack}}

[[cs:cpp/container/stack/empty]]
[[de:cpp/container/stack/empty]]
[[es:cpp/container/stack/empty]]
[[fr:cpp/container/stack/empty]]
[[it:cpp/container/stack/empty]]
[[ja:cpp/container/stack/empty]]
[[pl:cpp/container/stack/empty]]
[[pt:cpp/container/stack/empty]]
[[ru:cpp/container/stack/empty]]
[[zh:cpp/container/stack/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/operator=</title>
    <ns>0</ns>
    <id>307</id>
    <revision>
      <id>41648</id>
      <parentid>613</parentid>
      <timestamp>2012-11-02T18:30:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/container/operator{{=}} ad|stack}}

[[de:cpp/container/stack/operator=]]
[[es:cpp/container/stack/operator=]]
[[fr:cpp/container/stack/operator=]]
[[it:cpp/container/stack/operator=]]
[[ja:cpp/container/stack/operator=]]
[[pt:cpp/container/stack/operator=]]
[[ru:cpp/container/stack/operator=]]
[[zh:cpp/container/stack/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/operator cmp</title>
    <ns>0</ns>
    <id>9080</id>
    <revision>
      <id>50670</id>
      <parentid>41646</parentid>
      <timestamp>2013-06-01T03:36:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="378">{{include page|cpp/container_adaptor/operator_cmp|stack}}

[[de:cpp/container/stack/operator cmp]]
[[es:cpp/container/stack/operator cmp]]
[[fr:cpp/container/stack/operator cmp]]
[[it:cpp/container/stack/operator cmp]]
[[ja:cpp/container/stack/operator cmp]]
[[pt:cpp/container/stack/operator cmp]]
[[ru:cpp/container/stack/operator cmp]]
[[zh:cpp/container/stack/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/pop</title>
    <ns>0</ns>
    <id>308</id>
    <revision>
      <id>50671</id>
      <parentid>41644</parentid>
      <timestamp>2013-06-01T03:36:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="351">{{include page|cpp/container/pop|stack}}

[[de:cpp/container/stack/pop]]
[[es:cpp/container/stack/pop]]
[[fr:cpp/container/stack/pop]]
[[it:cpp/container/stack/pop]]
[[ja:cpp/container/stack/pop]]
[[pl:cpp/container/stack/pop]]
[[pt:cpp/container/stack/pop]]
[[ru:cpp/container/stack/pop]]
[[tr:cpp/container/stack/pop]]
[[zh:cpp/container/stack/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/push</title>
    <ns>0</ns>
    <id>309</id>
    <revision>
      <id>50672</id>
      <parentid>41642</parentid>
      <timestamp>2013-06-01T03:36:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/container/push|stack}}

[[de:cpp/container/stack/push]]
[[es:cpp/container/stack/push]]
[[fr:cpp/container/stack/push]]
[[it:cpp/container/stack/push]]
[[ja:cpp/container/stack/push]]
[[pl:cpp/container/stack/push]]
[[pt:cpp/container/stack/push]]
[[ru:cpp/container/stack/push]]
[[zh:cpp/container/stack/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/size</title>
    <ns>0</ns>
    <id>310</id>
    <revision>
      <id>50673</id>
      <parentid>41639</parentid>
      <timestamp>2013-06-01T03:36:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="333">{{include page|cpp/container/size ad|stack}}

[[de:cpp/container/stack/size]]
[[es:cpp/container/stack/size]]
[[fr:cpp/container/stack/size]]
[[it:cpp/container/stack/size]]
[[ja:cpp/container/stack/size]]
[[pl:cpp/container/stack/size]]
[[pt:cpp/container/stack/size]]
[[ru:cpp/container/stack/size]]
[[zh:cpp/container/stack/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/stack</title>
    <ns>0</ns>
    <id>311</id>
    <revision>
      <id>50674</id>
      <parentid>41637</parentid>
      <timestamp>2013-06-01T03:36:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="349">{{include page|cpp/container/constructor ad|stack}}

[[de:cpp/container/stack/stack]]
[[es:cpp/container/stack/stack]]
[[fr:cpp/container/stack/stack]]
[[it:cpp/container/stack/stack]]
[[ja:cpp/container/stack/stack]]
[[pl:cpp/container/stack/stack]]
[[pt:cpp/container/stack/stack]]
[[ru:cpp/container/stack/stack]]
[[zh:cpp/container/stack/stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/std swap</title>
    <ns>0</ns>
    <id>3467</id>
    <redirect title="cpp/container/stack/swap2" />
    <revision>
      <id>13023</id>
      <timestamp>2011-11-03T18:41:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/stack/std swap]] to [[cpp/container/stack/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/container/stack/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/swap</title>
    <ns>0</ns>
    <id>312</id>
    <revision>
      <id>50675</id>
      <parentid>41635</parentid>
      <timestamp>2013-06-01T03:36:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="301">{{include page|cpp/container/swap ad|stack}}

[[de:cpp/container/stack/swap]]
[[es:cpp/container/stack/swap]]
[[fr:cpp/container/stack/swap]]
[[it:cpp/container/stack/swap]]
[[ja:cpp/container/stack/swap]]
[[pt:cpp/container/stack/swap]]
[[ru:cpp/container/stack/swap]]
[[zh:cpp/container/stack/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/swap2</title>
    <ns>0</ns>
    <id>3014</id>
    <revision>
      <id>50676</id>
      <parentid>41633</parentid>
      <timestamp>2013-06-01T03:36:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/swap2|stack}}

[[de:cpp/container/stack/swap2]]
[[es:cpp/container/stack/swap2]]
[[fr:cpp/container/stack/swap2]]
[[it:cpp/container/stack/swap2]]
[[ja:cpp/container/stack/swap2]]
[[pt:cpp/container/stack/swap2]]
[[ru:cpp/container/stack/swap2]]
[[zh:cpp/container/stack/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/top</title>
    <ns>0</ns>
    <id>313</id>
    <revision>
      <id>60970</id>
      <parentid>60969</parentid>
      <timestamp>2013-06-03T11:21:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>reorder sections</comment>
      <text xml:space="preserve" bytes="1497">{{cpp/container/stack/title | top}}
{{cpp/container/stack/navbar}}
{{dcl begin}}
{{dcl |
reference top();
}}
{{dcl |
const_reference top() const;
}}
{{dcl end}}

Returns reference to the top element in the stack. This is the most recently pushed element. This element will be removed on a call to {{lc|pop()}}. Effectively calls {{c|c.back()}}.

===Parameters===
(none)

===Return value===
Reference to the last element

===Complexity===
Constant

===Example===
{{example
| code=
#include &lt;stack&gt;
#include &lt;iostream&gt;

int main()
{
    std::stack&lt;int&gt;   s;

    s.push( 2 );
    s.push( 6 );
    s.push( 51 );

    std::cout &lt;&lt; s.size() &lt;&lt; &quot; elements on stack\n&quot;;
    std::cout &lt;&lt; &quot;Top element: &quot;
	      &lt;&lt; s.top()         // Leaves element on stack
	      &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; s.size() &lt;&lt; &quot; elements on stack\n&quot;;
    s.pop();
    std::cout &lt;&lt; s.size() &lt;&lt; &quot; elements on stack\n&quot;;
    std::cout &lt;&lt; &quot;Top element: &quot; &lt;&lt; s.top() &lt;&lt; &quot;\n&quot;;
  
    return 0;
}
| output=
3 elements on stack
Top element: 51
3 elements on stack
2 elements on stack
Top element: 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc push|stack}}
{{dsc inc | cpp/container/dsc pop|stack}}
{{dsc end}}

[[de:cpp/container/stack/top]]
[[es:cpp/container/stack/top]]
[[fr:cpp/container/stack/top]]
[[it:cpp/container/stack/top]]
[[ja:cpp/container/stack/top]]
[[pl:cpp/container/stack/top]]
[[pt:cpp/container/stack/top]]
[[ru:cpp/container/stack/top]]
[[tr:cpp/container/stack/top]]
[[zh:cpp/container/stack/top]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/uses allocator</title>
    <ns>0</ns>
    <id>3403</id>
    <revision>
      <id>50677</id>
      <parentid>41629</parentid>
      <timestamp>2013-06-01T03:36:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/uses_allocator|stack}}

[[de:cpp/container/stack/uses allocator]]
[[es:cpp/container/stack/uses allocator]]
[[fr:cpp/container/stack/uses allocator]]
[[it:cpp/container/stack/uses allocator]]
[[ja:cpp/container/stack/uses allocator]]
[[pt:cpp/container/stack/uses allocator]]
[[ru:cpp/container/stack/uses allocator]]
[[zh:cpp/container/stack/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/stack/~stack</title>
    <ns>0</ns>
    <id>314</id>
    <revision>
      <id>50678</id>
      <parentid>41627</parentid>
      <timestamp>2013-06-01T03:36:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="320">{{include page|cpp/container/destructor|stack}}

[[de:cpp/container/stack/~stack]]
[[es:cpp/container/stack/~stack]]
[[fr:cpp/container/stack/~stack]]
[[it:cpp/container/stack/~stack]]
[[ja:cpp/container/stack/~stack]]
[[pt:cpp/container/stack/~stack]]
[[ru:cpp/container/stack/~stack]]
[[zh:cpp/container/stack/~stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map</title>
    <ns>0</ns>
    <id>315</id>
    <revision>
      <id>69324</id>
      <parentid>69323</parentid>
      <timestamp>2014-04-03T06:46:37Z</timestamp>
      <contributor>
        <username>Shachar</username>
        <id>2974</id>
      </contributor>
      <comment>Add iterator semantics notes</comment>
      <text xml:space="preserve" bytes="5268">{{cpp/title|unordered_map}}
{{cpp/container/unordered_map/navbar}}
{{ddcl | header=unordered_map | since=c++11 |
template&lt;
    class Key,
    class T,
    class Hash {{=}} std::hash&lt;Key&gt;,
    class KeyEqual {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt; std::pair&lt;const Key, T&gt; &gt;
&gt; class unordered_map;
}}

Unordered map is an associative container that contains key-value pairs with unique keys. Search, insertion, and removal of elements have average constant-time complexity.

Internally, the elements are not sorted in any particular order, but organized into buckets. Which bucket an element is placed into depends entirely on the hash of its key. This allows fast access to individual elements, since once hash is computed, it refers to the exact bucket the element is placed into.

{{tt|std::unordered_map}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|UnorderedAssociativeContainer}}.

===Iterator invalidation===

{| class=&quot;dsctable&quot; style=&quot;font-size:0.8em&quot;
! Operations
! Invalidated
|-
| All read only operations, {{lc|swap}}, {{lc|std::swap}}
| Never
|-
| {{lc|clear}}, {{lc|rehash}}, {{lc|reserve}}, {{lc|1=operator=}}
| Always
|-
| {{lc|insert}}, {{lc|emplace}}, {{lc|emplace_hint}}, {{lc|operator[]}}
| Only if causes rehash
|-
| {{lc|erase}}
| Only to the element erased
|}

====Notes====
* The swap functions do not invalidate any of the iterators inside the container, but they do invalidate the iterator marking the end of the swap region.

* References and pointers to either key or data stored in the container are only invalidated by erasing that element, even when the corresponding iterator is invalidated.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | unordered_map}}
{{dsc inc | cpp/container/dsc mapped_type | unordered_map}}
{{dsc inc | cpp/container/dsc value_type | unordered_map}}
{{dsc inc | cpp/container/dsc size_type | unordered_map}}
{{dsc inc | cpp/container/dsc difference_type | unordered_map}}
{{dsc inc | cpp/container/dsc hasher | unordered_map}}
{{dsc inc | cpp/container/dsc key_equal | unordered_map}}
{{dsc inc | cpp/container/dsc allocator_type | unordered_map}}
{{dsc inc | cpp/container/dsc reference | unordered_map}}
{{dsc inc | cpp/container/dsc const_reference | unordered_map}}
{{dsc inc | cpp/container/dsc pointer | unordered_map}}
{{dsc inc | cpp/container/dsc const_pointer | unordered_map}}
{{dsc inc | cpp/container/dsc iterator | unordered_map}}
{{dsc inc | cpp/container/dsc const_iterator | unordered_map}}
{{dsc inc | cpp/container/dsc local_iterator | unordered_map}}
{{dsc inc | cpp/container/dsc const_local_iterator | unordered_map}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | unordered_map}}
{{dsc inc | cpp/container/dsc destructor | unordered_map}}
{{dsc inc | cpp/container/dsc operator{{=}} | unordered_map}}
{{dsc inc | cpp/container/dsc get_allocator | unordered_map}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | unordered_map}}
{{dsc inc | cpp/container/dsc end | unordered_map}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | unordered_map}}
{{dsc inc | cpp/container/dsc size | unordered_map}}
{{dsc inc | cpp/container/dsc max_size | unordered_map}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | unordered_map}}
{{dsc inc | cpp/container/dsc insert | unordered_map}}
{{dsc inc | cpp/container/dsc emplace | unordered_map}}
{{dsc inc | cpp/container/dsc emplace_hint | unordered_map}}
{{dsc inc | cpp/container/dsc erase | unordered_map}}
{{dsc inc | cpp/container/dsc swap | unordered_map}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc at | unordered_map}}
{{dsc inc | cpp/container/dsc operator_at | unordered_map}}
{{dsc inc | cpp/container/dsc count | unordered_map}}
{{dsc inc | cpp/container/dsc find | unordered_map}}
{{dsc inc | cpp/container/dsc equal_range | unordered_map}}

{{dsc h2 | Bucket interface}}
{{dsc inc | cpp/container/dsc begin(int) | unordered_map}}
{{dsc inc | cpp/container/dsc end(int) | unordered_map}}
{{dsc inc | cpp/container/dsc bucket_count | unordered_map}}
{{dsc inc | cpp/container/dsc max_bucket_count | unordered_map}}
{{dsc inc | cpp/container/dsc bucket_size | unordered_map}}
{{dsc inc | cpp/container/dsc bucket | unordered_map}}

{{dsc h2 | Hash policy}}
{{dsc inc | cpp/container/dsc load_factor | unordered_map}}
{{dsc inc | cpp/container/dsc max_load_factor | unordered_map}}
{{dsc inc | cpp/container/dsc rehash | unordered_map}}
{{dsc inc | cpp/container/dsc reserve | unordered_map}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc hash_function | unordered_map}}
{{dsc inc | cpp/container/dsc key_eq | unordered_map}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_map}}
{{dsc inc | cpp/container/dsc swap2 | unordered_map}}
{{dsc end}}


[[de:cpp/container/unordered map]]
[[es:cpp/container/unordered map]]
[[fr:cpp/container/unordered map]]
[[it:cpp/container/unordered map]]
[[ja:cpp/container/unordered map]]
[[pt:cpp/container/unordered map]]
[[ru:cpp/container/unordered map]]
[[zh:cpp/container/unordered map]]</text>
      <sha1>4fp5zp2s80z2grj6jkjfjfzhuvldgfn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/at</title>
    <ns>0</ns>
    <id>316</id>
    <revision>
      <id>50679</id>
      <parentid>41623</parentid>
      <timestamp>2013-06-01T03:36:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="358">{{include page|cpp/container/at assoc|unordered_map}}

[[de:cpp/container/unordered map/at]]
[[es:cpp/container/unordered map/at]]
[[fr:cpp/container/unordered map/at]]
[[it:cpp/container/unordered map/at]]
[[ja:cpp/container/unordered map/at]]
[[pt:cpp/container/unordered map/at]]
[[ru:cpp/container/unordered map/at]]
[[zh:cpp/container/unordered map/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/begin</title>
    <ns>0</ns>
    <id>317</id>
    <revision>
      <id>50680</id>
      <parentid>41622</parentid>
      <timestamp>2013-06-01T03:36:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/begin|unordered_map}}

[[de:cpp/container/unordered map/begin]]
[[es:cpp/container/unordered map/begin]]
[[fr:cpp/container/unordered map/begin]]
[[it:cpp/container/unordered map/begin]]
[[ja:cpp/container/unordered map/begin]]
[[pt:cpp/container/unordered map/begin]]
[[ru:cpp/container/unordered map/begin]]
[[zh:cpp/container/unordered map/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/begin(int)</title>
    <ns>0</ns>
    <id>9081</id>
    <redirect title="cpp/container/unordered map/begin2" />
    <revision>
      <id>38131</id>
      <timestamp>2012-07-24T13:26:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered map/begin(int)]] to [[cpp/container/unordered map/begin2]]: Text replace - &quot;/begin(int)&quot; to &quot;/begin2&quot;</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/container/unordered map/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/begin2</title>
    <ns>0</ns>
    <id>318</id>
    <revision>
      <id>50681</id>
      <parentid>41620</parentid>
      <timestamp>2013-06-01T03:36:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/begin2|unordered_map}}

[[de:cpp/container/unordered map/begin2]]
[[es:cpp/container/unordered map/begin2]]
[[fr:cpp/container/unordered map/begin2]]
[[it:cpp/container/unordered map/begin2]]
[[ja:cpp/container/unordered map/begin2]]
[[pt:cpp/container/unordered map/begin2]]
[[ru:cpp/container/unordered map/begin2]]
[[zh:cpp/container/unordered map/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/bucket</title>
    <ns>0</ns>
    <id>319</id>
    <revision>
      <id>50682</id>
      <parentid>41618</parentid>
      <timestamp>2013-06-01T03:36:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/bucket|unordered_map}}

[[de:cpp/container/unordered map/bucket]]
[[es:cpp/container/unordered map/bucket]]
[[fr:cpp/container/unordered map/bucket]]
[[it:cpp/container/unordered map/bucket]]
[[ja:cpp/container/unordered map/bucket]]
[[pt:cpp/container/unordered map/bucket]]
[[ru:cpp/container/unordered map/bucket]]
[[zh:cpp/container/unordered map/bucket]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/bucket count</title>
    <ns>0</ns>
    <id>320</id>
    <revision>
      <id>50683</id>
      <parentid>41616</parentid>
      <timestamp>2013-06-01T03:36:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="442">{{include page|cpp/container/bucket_count|unordered_map}}

[[de:cpp/container/unordered map/bucket count]]
[[es:cpp/container/unordered map/bucket count]]
[[fr:cpp/container/unordered map/bucket count]]
[[it:cpp/container/unordered map/bucket count]]
[[ja:cpp/container/unordered map/bucket count]]
[[pt:cpp/container/unordered map/bucket count]]
[[ru:cpp/container/unordered map/bucket count]]
[[zh:cpp/container/unordered map/bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/bucket size</title>
    <ns>0</ns>
    <id>321</id>
    <revision>
      <id>50684</id>
      <parentid>41615</parentid>
      <timestamp>2013-06-01T03:36:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/bucket_size|unordered_map}}

[[de:cpp/container/unordered map/bucket size]]
[[es:cpp/container/unordered map/bucket size]]
[[fr:cpp/container/unordered map/bucket size]]
[[it:cpp/container/unordered map/bucket size]]
[[ja:cpp/container/unordered map/bucket size]]
[[pt:cpp/container/unordered map/bucket size]]
[[ru:cpp/container/unordered map/bucket size]]
[[zh:cpp/container/unordered map/bucket size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/clear</title>
    <ns>0</ns>
    <id>322</id>
    <revision>
      <id>50685</id>
      <parentid>41613</parentid>
      <timestamp>2013-06-01T03:36:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/clear|unordered_map}}

[[de:cpp/container/unordered map/clear]]
[[es:cpp/container/unordered map/clear]]
[[fr:cpp/container/unordered map/clear]]
[[it:cpp/container/unordered map/clear]]
[[ja:cpp/container/unordered map/clear]]
[[pt:cpp/container/unordered map/clear]]
[[ru:cpp/container/unordered map/clear]]
[[zh:cpp/container/unordered map/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/count</title>
    <ns>0</ns>
    <id>323</id>
    <revision>
      <id>65130</id>
      <parentid>50686</parentid>
      <timestamp>2013-08-30T16:36:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="385">{{include page|cpp/container/count_unord|unordered_map}}

[[de:cpp/container/unordered map/count]]
[[es:cpp/container/unordered map/count]]
[[fr:cpp/container/unordered map/count]]
[[it:cpp/container/unordered map/count]]
[[ja:cpp/container/unordered map/count]]
[[pt:cpp/container/unordered map/count]]
[[ru:cpp/container/unordered map/count]]
[[zh:cpp/container/unordered map/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/emplace</title>
    <ns>0</ns>
    <id>324</id>
    <revision>
      <id>50687</id>
      <parentid>41609</parentid>
      <timestamp>2013-06-01T03:36:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/container/emplace assoc|unordered_map}}

[[de:cpp/container/unordered map/emplace]]
[[es:cpp/container/unordered map/emplace]]
[[fr:cpp/container/unordered map/emplace]]
[[it:cpp/container/unordered map/emplace]]
[[ja:cpp/container/unordered map/emplace]]
[[pt:cpp/container/unordered map/emplace]]
[[ru:cpp/container/unordered map/emplace]]
[[zh:cpp/container/unordered map/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/emplace hint</title>
    <ns>0</ns>
    <id>325</id>
    <revision>
      <id>65118</id>
      <parentid>65109</parentid>
      <timestamp>2013-08-30T16:27:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1754">{{cpp/container/unordered_map/title | emplace_hint}}
{{cpp/container/unordered_map/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element type ({{tt|value_type}}, that is, {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.

{{cpp/container/note_iterator_invalidation|unordered_map|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

If the insertion failed because the element already exists, returns an iterator to the already existing element with the equivalent key.

===Complexity===
Amortized constant on average, worst case linear in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_map}}
{{dsc inc | cpp/container/dsc insert |unordered_map}}
{{dsc end}}

[[de:cpp/container/unordered map/emplace hint]]
[[es:cpp/container/unordered map/emplace hint]]
[[fr:cpp/container/unordered map/emplace hint]]
[[it:cpp/container/unordered map/emplace hint]]
[[ja:cpp/container/unordered map/emplace hint]]
[[pt:cpp/container/unordered map/emplace hint]]
[[ru:cpp/container/unordered map/emplace hint]]
[[zh:cpp/container/unordered map/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/empty</title>
    <ns>0</ns>
    <id>326</id>
    <revision>
      <id>50689</id>
      <parentid>41605</parentid>
      <timestamp>2013-06-01T03:36:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/empty|unordered_map}}

[[de:cpp/container/unordered map/empty]]
[[es:cpp/container/unordered map/empty]]
[[fr:cpp/container/unordered map/empty]]
[[it:cpp/container/unordered map/empty]]
[[ja:cpp/container/unordered map/empty]]
[[pt:cpp/container/unordered map/empty]]
[[ru:cpp/container/unordered map/empty]]
[[zh:cpp/container/unordered map/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/end</title>
    <ns>0</ns>
    <id>327</id>
    <revision>
      <id>50690</id>
      <parentid>41603</parentid>
      <timestamp>2013-06-01T03:36:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/end|unordered_map}}

[[de:cpp/container/unordered map/end]]
[[es:cpp/container/unordered map/end]]
[[fr:cpp/container/unordered map/end]]
[[it:cpp/container/unordered map/end]]
[[ja:cpp/container/unordered map/end]]
[[pt:cpp/container/unordered map/end]]
[[ru:cpp/container/unordered map/end]]
[[zh:cpp/container/unordered map/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/end(int)</title>
    <ns>0</ns>
    <id>9086</id>
    <redirect title="cpp/container/unordered map/end2" />
    <revision>
      <id>38151</id>
      <timestamp>2012-07-24T13:41:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered map/end(int)]] to [[cpp/container/unordered map/end2]]: Text replace - &quot;/end(int)&quot; to &quot;/end2&quot;</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/container/unordered map/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/end2</title>
    <ns>0</ns>
    <id>328</id>
    <revision>
      <id>50691</id>
      <parentid>41601</parentid>
      <timestamp>2013-06-01T03:36:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/end2|unordered_map}}

[[de:cpp/container/unordered map/end2]]
[[es:cpp/container/unordered map/end2]]
[[fr:cpp/container/unordered map/end2]]
[[it:cpp/container/unordered map/end2]]
[[ja:cpp/container/unordered map/end2]]
[[pt:cpp/container/unordered map/end2]]
[[ru:cpp/container/unordered map/end2]]
[[zh:cpp/container/unordered map/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/equal range</title>
    <ns>0</ns>
    <id>329</id>
    <revision>
      <id>65097</id>
      <parentid>65083</parentid>
      <timestamp>2013-08-30T15:58:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="439">{{include page|cpp/container/equal_range_unord|unordered_map}}

[[de:cpp/container/unordered map/equal range]]
[[es:cpp/container/unordered map/equal range]]
[[fr:cpp/container/unordered map/equal range]]
[[it:cpp/container/unordered map/equal range]]
[[ja:cpp/container/unordered map/equal range]]
[[pt:cpp/container/unordered map/equal range]]
[[ru:cpp/container/unordered map/equal range]]
[[zh:cpp/container/unordered map/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/erase</title>
    <ns>0</ns>
    <id>330</id>
    <revision>
      <id>50693</id>
      <parentid>41598</parentid>
      <timestamp>2013-06-01T03:36:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="385">{{include page|cpp/container/erase assoc|unordered_map}}

[[de:cpp/container/unordered map/erase]]
[[es:cpp/container/unordered map/erase]]
[[fr:cpp/container/unordered map/erase]]
[[it:cpp/container/unordered map/erase]]
[[ja:cpp/container/unordered map/erase]]
[[pt:cpp/container/unordered map/erase]]
[[ru:cpp/container/unordered map/erase]]
[[zh:cpp/container/unordered map/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/find</title>
    <ns>0</ns>
    <id>331</id>
    <revision>
      <id>50694</id>
      <parentid>41596</parentid>
      <timestamp>2013-06-01T03:36:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/find|unordered_map}}

[[de:cpp/container/unordered map/find]]
[[es:cpp/container/unordered map/find]]
[[fr:cpp/container/unordered map/find]]
[[it:cpp/container/unordered map/find]]
[[ja:cpp/container/unordered map/find]]
[[pt:cpp/container/unordered map/find]]
[[ru:cpp/container/unordered map/find]]
[[zh:cpp/container/unordered map/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/get allocator</title>
    <ns>0</ns>
    <id>332</id>
    <revision>
      <id>50695</id>
      <parentid>41594</parentid>
      <timestamp>2013-06-01T03:36:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/get_allocator|unordered_map}}

[[de:cpp/container/unordered map/get allocator]]
[[es:cpp/container/unordered map/get allocator]]
[[fr:cpp/container/unordered map/get allocator]]
[[it:cpp/container/unordered map/get allocator]]
[[ja:cpp/container/unordered map/get allocator]]
[[pt:cpp/container/unordered map/get allocator]]
[[ru:cpp/container/unordered map/get allocator]]
[[zh:cpp/container/unordered map/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/hash function</title>
    <ns>0</ns>
    <id>333</id>
    <revision>
      <id>50696</id>
      <parentid>41593</parentid>
      <timestamp>2013-06-01T03:36:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/hash_function|unordered_map}}

[[de:cpp/container/unordered map/hash function]]
[[es:cpp/container/unordered map/hash function]]
[[fr:cpp/container/unordered map/hash function]]
[[it:cpp/container/unordered map/hash function]]
[[ja:cpp/container/unordered map/hash function]]
[[pt:cpp/container/unordered map/hash function]]
[[ru:cpp/container/unordered map/hash function]]
[[zh:cpp/container/unordered map/hash function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/insert</title>
    <ns>0</ns>
    <id>334</id>
    <revision>
      <id>65007</id>
      <parentid>64998</parentid>
      <timestamp>2013-08-28T23:04:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{v}}</comment>
      <text xml:space="preserve" bytes="2976">{{cpp/container/unordered_map/title | insert}}
{{cpp/container/unordered_map/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
std::pair&lt;iterator,bool&gt; insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class P &gt;
std::pair&lt;iterator,bool&gt; insert( P&amp;&amp; value );
}}
{{dcl | num=3 | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl | num=4 | since=c++11 |
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
{{dcl | num=5 | since=c++11 |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

@1-2@ Inserts {{tt|value}}. The overload {{v|2}} is equivalent to {{c|emplace(std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@3-4@ Inserts {{tt|value}}, using {{tt|hint}} as a non-binding suggestion to where the search should start. The overload {{v|4}} is equivalent to {{c|emplace_hint(hint, std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@5@ Inserts elements from range {{tt|[first, last)}}.

@6@ Inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|unordered_map|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-2@ Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a {{c|bool}} denoting whether the insertion took place.

@3-4@ Returns an iterator to the inserted element, or to the element that prevented the insertion.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-4@ Average case: {{tt|O(1)}}, worst case {{tt|O(size())}}

@5-6@ Average case: {{tt|O(N)}}, where N is the number of elements to insert. Worse case: {{tt|O(N*size()+N)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_map}}
{{dsc inc | cpp/container/dsc emplace_hint |unordered_map}}
{{dsc end}}

[[de:cpp/container/unordered map/insert]]
[[es:cpp/container/unordered map/insert]]
[[fr:cpp/container/unordered map/insert]]
[[it:cpp/container/unordered map/insert]]
[[ja:cpp/container/unordered map/insert]]
[[pt:cpp/container/unordered map/insert]]
[[ru:cpp/container/unordered map/insert]]
[[zh:cpp/container/unordered map/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/iterator semantics</title>
    <ns>0</ns>
    <id>13502</id>
    <revision>
      <id>69325</id>
      <parentid>69319</parentid>
      <timestamp>2014-04-03T06:49:18Z</timestamp>
      <contributor>
        <username>Shachar</username>
        <id>2974</id>
      </contributor>
      <comment>Remove request</comment>
      <text xml:space="preserve" bytes="1162">{|
|+ Iterator invalidation rules
! Operations
! Invalidated
|-
| All read only operations
[[cpp/container/unordered_map/swap|swap]],
[[cpp/container/unordered_map/swap2|std::swap]]
| Never
|-
|
[[cpp/container/unordered_map/clear|clear]],
[[cpp/container/unordered_map/rehash|rehash]],
[[cpp/container/unordered_map/reserve|reserve]],
[[cpp/container/unordered_map/operator%3D|operator=]]
| Always
|-
|
[[cpp/container/unordered_map/insert|insert]],
[[cpp/container/unordered_map/emplace|emplace]],
[[cpp/container/unordered_map/emplace_hint|emplace_hint]],
[[cpp/container/unordered_map/operator_at|operator[]]]
| Only if causes rehash
|-
| [[cpp/container/unordered_map/erase|erase]]
| Only to the element erased
|}

==Page needs to be removed==
The content of this page has been integrated into the main container page.

===Notes===
* The swap functions do not invalidate any of the iterators inside the container, but they do invalidate the iterator marking the end of the swap region.

* References and pointers to either key or data stored in the container are only invalidated by erasing that element, even when the corresponding iterator is invalidated.</text>
      <sha1>mnxava3kdx65j0n8a5tn7ye67h8myyd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/key eq</title>
    <ns>0</ns>
    <id>335</id>
    <revision>
      <id>50697</id>
      <parentid>41589</parentid>
      <timestamp>2013-06-01T03:36:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/key_eq|unordered_map}}

[[de:cpp/container/unordered map/key eq]]
[[es:cpp/container/unordered map/key eq]]
[[fr:cpp/container/unordered map/key eq]]
[[it:cpp/container/unordered map/key eq]]
[[ja:cpp/container/unordered map/key eq]]
[[pt:cpp/container/unordered map/key eq]]
[[ru:cpp/container/unordered map/key eq]]
[[zh:cpp/container/unordered map/key eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/load factor</title>
    <ns>0</ns>
    <id>336</id>
    <revision>
      <id>50698</id>
      <parentid>41587</parentid>
      <timestamp>2013-06-01T03:36:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/load_factor|unordered_map}}

[[de:cpp/container/unordered map/load factor]]
[[es:cpp/container/unordered map/load factor]]
[[fr:cpp/container/unordered map/load factor]]
[[it:cpp/container/unordered map/load factor]]
[[ja:cpp/container/unordered map/load factor]]
[[pt:cpp/container/unordered map/load factor]]
[[ru:cpp/container/unordered map/load factor]]
[[zh:cpp/container/unordered map/load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/max bucket count</title>
    <ns>0</ns>
    <id>337</id>
    <revision>
      <id>50699</id>
      <parentid>41586</parentid>
      <timestamp>2013-06-01T03:36:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/max_bucket_count|unordered_map}}

[[de:cpp/container/unordered map/max bucket count]]
[[es:cpp/container/unordered map/max bucket count]]
[[fr:cpp/container/unordered map/max bucket count]]
[[it:cpp/container/unordered map/max bucket count]]
[[ja:cpp/container/unordered map/max bucket count]]
[[pt:cpp/container/unordered map/max bucket count]]
[[ru:cpp/container/unordered map/max bucket count]]
[[zh:cpp/container/unordered map/max bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/max load factor</title>
    <ns>0</ns>
    <id>338</id>
    <revision>
      <id>50700</id>
      <parentid>41584</parentid>
      <timestamp>2013-06-01T03:36:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="469">{{include page|cpp/container/max_load_factor|unordered_map}}

[[de:cpp/container/unordered map/max load factor]]
[[es:cpp/container/unordered map/max load factor]]
[[fr:cpp/container/unordered map/max load factor]]
[[it:cpp/container/unordered map/max load factor]]
[[ja:cpp/container/unordered map/max load factor]]
[[pt:cpp/container/unordered map/max load factor]]
[[ru:cpp/container/unordered map/max load factor]]
[[zh:cpp/container/unordered map/max load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/max size</title>
    <ns>0</ns>
    <id>339</id>
    <revision>
      <id>50701</id>
      <parentid>41582</parentid>
      <timestamp>2013-06-01T03:36:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/max_size|unordered_map}}

[[de:cpp/container/unordered map/max size]]
[[es:cpp/container/unordered map/max size]]
[[fr:cpp/container/unordered map/max size]]
[[it:cpp/container/unordered map/max size]]
[[ja:cpp/container/unordered map/max size]]
[[pt:cpp/container/unordered map/max size]]
[[ru:cpp/container/unordered map/max size]]
[[zh:cpp/container/unordered map/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/operator=</title>
    <ns>0</ns>
    <id>340</id>
    <revision>
      <id>41580</id>
      <parentid>679</parentid>
      <timestamp>2012-11-02T17:29:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="406">{{cpp/container/operator{{=}}|unordered_map}}

[[de:cpp/container/unordered map/operator=]]
[[es:cpp/container/unordered map/operator=]]
[[fr:cpp/container/unordered map/operator=]]
[[it:cpp/container/unordered map/operator=]]
[[ja:cpp/container/unordered map/operator=]]
[[pt:cpp/container/unordered map/operator=]]
[[ru:cpp/container/unordered map/operator=]]
[[zh:cpp/container/unordered map/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/operator at</title>
    <ns>0</ns>
    <id>341</id>
    <revision>
      <id>44650</id>
      <parentid>41578</parentid>
      <timestamp>2012-11-09T19:13:25Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>rm example, which now appears in template</comment>
      <text xml:space="preserve" bytes="426">{{cpp/container/operator_at assoc|unordered_map}}

[[de:cpp/container/unordered map/operator at]]
[[es:cpp/container/unordered map/operator at]]
[[fr:cpp/container/unordered map/operator at]]
[[it:cpp/container/unordered map/operator at]]
[[ja:cpp/container/unordered map/operator at]]
[[pt:cpp/container/unordered map/operator at]]
[[ru:cpp/container/unordered map/operator at]]
[[zh:cpp/container/unordered map/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/operator cmp</title>
    <ns>0</ns>
    <id>2011</id>
    <revision>
      <id>50702</id>
      <parentid>41577</parentid>
      <timestamp>2013-06-01T03:36:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/operator_cmp_unord|unordered_map}}

[[de:cpp/container/unordered map/operator cmp]]
[[es:cpp/container/unordered map/operator cmp]]
[[fr:cpp/container/unordered map/operator cmp]]
[[it:cpp/container/unordered map/operator cmp]]
[[ja:cpp/container/unordered map/operator cmp]]
[[pt:cpp/container/unordered map/operator cmp]]
[[ru:cpp/container/unordered map/operator cmp]]
[[zh:cpp/container/unordered map/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/operator comp</title>
    <ns>0</ns>
    <id>4215</id>
    <redirect title="cpp/container/unordered map/operator cmp" />
    <revision>
      <id>15249</id>
      <timestamp>2011-12-08T01:16:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered map/operator comp]] to [[cpp/container/unordered map/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[cpp/container/unordered map/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/rehash</title>
    <ns>0</ns>
    <id>342</id>
    <revision>
      <id>50703</id>
      <parentid>41576</parentid>
      <timestamp>2013-06-01T03:36:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/rehash|unordered_map}}

[[de:cpp/container/unordered map/rehash]]
[[es:cpp/container/unordered map/rehash]]
[[fr:cpp/container/unordered map/rehash]]
[[it:cpp/container/unordered map/rehash]]
[[ja:cpp/container/unordered map/rehash]]
[[pt:cpp/container/unordered map/rehash]]
[[ru:cpp/container/unordered map/rehash]]
[[zh:cpp/container/unordered map/rehash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/reserve</title>
    <ns>0</ns>
    <id>343</id>
    <revision>
      <id>50704</id>
      <parentid>41575</parentid>
      <timestamp>2013-06-01T03:36:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/container/reserve unord|unordered_map}}

[[de:cpp/container/unordered map/reserve]]
[[es:cpp/container/unordered map/reserve]]
[[fr:cpp/container/unordered map/reserve]]
[[it:cpp/container/unordered map/reserve]]
[[ja:cpp/container/unordered map/reserve]]
[[pt:cpp/container/unordered map/reserve]]
[[ru:cpp/container/unordered map/reserve]]
[[zh:cpp/container/unordered map/reserve]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/size</title>
    <ns>0</ns>
    <id>344</id>
    <revision>
      <id>50705</id>
      <parentid>41574</parentid>
      <timestamp>2013-06-01T03:37:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/size|unordered_map}}

[[de:cpp/container/unordered map/size]]
[[es:cpp/container/unordered map/size]]
[[fr:cpp/container/unordered map/size]]
[[it:cpp/container/unordered map/size]]
[[ja:cpp/container/unordered map/size]]
[[pt:cpp/container/unordered map/size]]
[[ru:cpp/container/unordered map/size]]
[[zh:cpp/container/unordered map/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/std swap</title>
    <ns>0</ns>
    <id>3468</id>
    <redirect title="cpp/container/unordered map/swap2" />
    <revision>
      <id>13025</id>
      <timestamp>2011-11-03T18:41:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered map/std swap]] to [[cpp/container/unordered map/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/container/unordered map/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/swap</title>
    <ns>0</ns>
    <id>345</id>
    <revision>
      <id>50706</id>
      <parentid>41573</parentid>
      <timestamp>2013-06-01T03:37:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/swap|unordered_map}}

[[de:cpp/container/unordered map/swap]]
[[es:cpp/container/unordered map/swap]]
[[fr:cpp/container/unordered map/swap]]
[[it:cpp/container/unordered map/swap]]
[[ja:cpp/container/unordered map/swap]]
[[pt:cpp/container/unordered map/swap]]
[[ru:cpp/container/unordered map/swap]]
[[zh:cpp/container/unordered map/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/swap2</title>
    <ns>0</ns>
    <id>1999</id>
    <revision>
      <id>50707</id>
      <parentid>41572</parentid>
      <timestamp>2013-06-01T03:37:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/swap2|unordered_map}}

[[de:cpp/container/unordered map/swap2]]
[[es:cpp/container/unordered map/swap2]]
[[fr:cpp/container/unordered map/swap2]]
[[it:cpp/container/unordered map/swap2]]
[[ja:cpp/container/unordered map/swap2]]
[[pt:cpp/container/unordered map/swap2]]
[[ru:cpp/container/unordered map/swap2]]
[[zh:cpp/container/unordered map/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/unordered map</title>
    <ns>0</ns>
    <id>346</id>
    <revision>
      <id>50708</id>
      <parentid>41571</parentid>
      <timestamp>2013-06-01T03:37:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="455">{{include page|cpp/container/constructor unord|unordered_map}}

[[de:cpp/container/unordered map/unordered map]]
[[es:cpp/container/unordered map/unordered map]]
[[fr:cpp/container/unordered map/unordered map]]
[[it:cpp/container/unordered map/unordered map]]
[[ja:cpp/container/unordered map/unordered map]]
[[pt:cpp/container/unordered map/unordered map]]
[[ru:cpp/container/unordered map/unordered map]]
[[zh:cpp/container/unordered map/unordered map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered map/~unordered map</title>
    <ns>0</ns>
    <id>347</id>
    <revision>
      <id>50709</id>
      <parentid>41569</parentid>
      <timestamp>2013-06-01T03:37:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="456">{{include page|cpp/container/destructor|unordered_map}}

[[de:cpp/container/unordered map/~unordered map]]
[[es:cpp/container/unordered map/~unordered map]]
[[fr:cpp/container/unordered map/~unordered map]]
[[it:cpp/container/unordered map/~unordered map]]
[[ja:cpp/container/unordered map/~unordered map]]
[[pt:cpp/container/unordered map/~unordered map]]
[[ru:cpp/container/unordered map/~unordered map]]
[[zh:cpp/container/unordered map/~unordered map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap</title>
    <ns>0</ns>
    <id>348</id>
    <revision>
      <id>65960</id>
      <parentid>65959</parentid>
      <timestamp>2013-10-16T14:30:35Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="4889">{{cpp/title|unordered_multimap}}
{{cpp/container/unordered_multimap/navbar}}
{{ddcl | header=unordered_map | since=c++11 |
template&lt;
    class Key,
    class T,
    class Hash {{=}} std::hash&lt;Key&gt;,
    class KeyEqual {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt; std::pair&lt;const Key, T&gt; &gt;
&gt; class unordered_multimap;
}} 

Unordered multimap is an unordered associative container that supports equivalent keys (an unordered_multimap may contain multiple copies of each key value) and that associates values of another type with the keys. The unordered_multimap class supports forward iterators. Search, insertion, and removal have average constant-time complexity.

Internally, the elements are not sorted in any particular order, but organized into buckets. Which bucket an element is placed into depends entirely on the hash of its key. This allows fast access to individual elements, since once hash is computed, it refers to the exact bucket the element is placed into.

{{tt|std::unordered_multimap}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|UnorderedAssociativeContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc mapped_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc value_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc size_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc difference_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc hasher | unordered_multimap}}
{{dsc inc | cpp/container/dsc key_equal | unordered_multimap}}
{{dsc inc | cpp/container/dsc allocator_type | unordered_multimap}}
{{dsc inc | cpp/container/dsc reference | unordered_multimap}}
{{dsc inc | cpp/container/dsc const_reference | unordered_multimap}}
{{dsc inc | cpp/container/dsc pointer | unordered_multimap}}
{{dsc inc | cpp/container/dsc const_pointer | unordered_multimap}}
{{dsc inc | cpp/container/dsc iterator | unordered_multimap}}
{{dsc inc | cpp/container/dsc const_iterator | unordered_multimap}}
{{dsc inc | cpp/container/dsc local_iterator | unordered_multimap}}
{{dsc inc | cpp/container/dsc const_local_iterator | unordered_multimap}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | unordered_multimap}}
{{dsc inc | cpp/container/dsc destructor | unordered_multimap}}
{{dsc inc | cpp/container/dsc operator{{=}} | unordered_multimap}}
{{dsc inc | cpp/container/dsc get_allocator | unordered_multimap}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | unordered_multimap}}
{{dsc inc | cpp/container/dsc end | unordered_multimap}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | unordered_multimap}}
{{dsc inc | cpp/container/dsc size | unordered_multimap}}
{{dsc inc | cpp/container/dsc max_size | unordered_multimap}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | unordered_multimap}}
{{dsc inc | cpp/container/dsc insert | unordered_multimap}}
{{dsc inc | cpp/container/dsc emplace | unordered_multimap}}
{{dsc inc | cpp/container/dsc emplace_hint | unordered_multimap}}
{{dsc inc | cpp/container/dsc erase | unordered_multimap}}
{{dsc inc | cpp/container/dsc swap | unordered_multimap}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | unordered_multimap}}
{{dsc inc | cpp/container/dsc find | unordered_multimap}}
{{dsc inc | cpp/container/dsc equal_range | unordered_multimap}}

{{dsc h2 | Bucket interface}}
{{dsc inc | cpp/container/dsc begin(int) | unordered_multimap}}
{{dsc inc | cpp/container/dsc end(int) | unordered_multimap}}
{{dsc inc | cpp/container/dsc bucket_count | unordered_multimap}}
{{dsc inc | cpp/container/dsc max_bucket_count | unordered_multimap}}
{{dsc inc | cpp/container/dsc bucket_size | unordered_multimap}}
{{dsc inc | cpp/container/dsc bucket | unordered_multimap}}

{{dsc h2 | Hash policy}}
{{dsc inc | cpp/container/dsc load_factor | unordered_multimap}}
{{dsc inc | cpp/container/dsc max_load_factor | unordered_multimap}}
{{dsc inc | cpp/container/dsc rehash | unordered_multimap}}
{{dsc inc | cpp/container/dsc reserve | unordered_multimap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc hash_function | unordered_multimap}}
{{dsc inc | cpp/container/dsc key_eq | unordered_multimap}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multimap}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multimap}}
{{dsc end}}

[[de:cpp/container/unordered multimap]]
[[es:cpp/container/unordered multimap]]
[[fr:cpp/container/unordered multimap]]
[[it:cpp/container/unordered multimap]]
[[ja:cpp/container/unordered multimap]]
[[pt:cpp/container/unordered multimap]]
[[ru:cpp/container/unordered multimap]]
[[zh:cpp/container/unordered multimap]]</text>
      <sha1>buw1w9yt8af0zuxygxclnnwkatjf6wz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/begin</title>
    <ns>0</ns>
    <id>349</id>
    <revision>
      <id>50710</id>
      <parentid>41567</parentid>
      <timestamp>2013-06-01T03:37:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/begin|unordered_multimap}}

[[de:cpp/container/unordered multimap/begin]]
[[es:cpp/container/unordered multimap/begin]]
[[fr:cpp/container/unordered multimap/begin]]
[[it:cpp/container/unordered multimap/begin]]
[[ja:cpp/container/unordered multimap/begin]]
[[pt:cpp/container/unordered multimap/begin]]
[[ru:cpp/container/unordered multimap/begin]]
[[zh:cpp/container/unordered multimap/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/begin(int)</title>
    <ns>0</ns>
    <id>9082</id>
    <redirect title="cpp/container/unordered multimap/begin2" />
    <revision>
      <id>38133</id>
      <timestamp>2012-07-24T13:28:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multimap/begin(int)]] to [[cpp/container/unordered multimap/begin2]]: Text replace - &quot;/begin(int)&quot; to &quot;/begin2&quot;</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[cpp/container/unordered multimap/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/begin2</title>
    <ns>0</ns>
    <id>350</id>
    <revision>
      <id>50711</id>
      <parentid>41566</parentid>
      <timestamp>2013-06-01T03:37:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/begin2|unordered_multimap}}

[[de:cpp/container/unordered multimap/begin2]]
[[es:cpp/container/unordered multimap/begin2]]
[[fr:cpp/container/unordered multimap/begin2]]
[[it:cpp/container/unordered multimap/begin2]]
[[ja:cpp/container/unordered multimap/begin2]]
[[pt:cpp/container/unordered multimap/begin2]]
[[ru:cpp/container/unordered multimap/begin2]]
[[zh:cpp/container/unordered multimap/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/bucket</title>
    <ns>0</ns>
    <id>351</id>
    <revision>
      <id>50712</id>
      <parentid>41565</parentid>
      <timestamp>2013-06-01T03:37:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/bucket|unordered_multimap}}

[[de:cpp/container/unordered multimap/bucket]]
[[es:cpp/container/unordered multimap/bucket]]
[[fr:cpp/container/unordered multimap/bucket]]
[[it:cpp/container/unordered multimap/bucket]]
[[ja:cpp/container/unordered multimap/bucket]]
[[pt:cpp/container/unordered multimap/bucket]]
[[ru:cpp/container/unordered multimap/bucket]]
[[zh:cpp/container/unordered multimap/bucket]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/bucket count</title>
    <ns>0</ns>
    <id>352</id>
    <revision>
      <id>50713</id>
      <parentid>41564</parentid>
      <timestamp>2013-06-01T03:37:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="487">{{include page|cpp/container/bucket_count|unordered_multimap}}

[[de:cpp/container/unordered multimap/bucket count]]
[[es:cpp/container/unordered multimap/bucket count]]
[[fr:cpp/container/unordered multimap/bucket count]]
[[it:cpp/container/unordered multimap/bucket count]]
[[ja:cpp/container/unordered multimap/bucket count]]
[[pt:cpp/container/unordered multimap/bucket count]]
[[ru:cpp/container/unordered multimap/bucket count]]
[[zh:cpp/container/unordered multimap/bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/bucket size</title>
    <ns>0</ns>
    <id>353</id>
    <revision>
      <id>50714</id>
      <parentid>41563</parentid>
      <timestamp>2013-06-01T03:37:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/bucket_size|unordered_multimap}}

[[de:cpp/container/unordered multimap/bucket size]]
[[es:cpp/container/unordered multimap/bucket size]]
[[fr:cpp/container/unordered multimap/bucket size]]
[[it:cpp/container/unordered multimap/bucket size]]
[[ja:cpp/container/unordered multimap/bucket size]]
[[pt:cpp/container/unordered multimap/bucket size]]
[[ru:cpp/container/unordered multimap/bucket size]]
[[zh:cpp/container/unordered multimap/bucket size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/clear</title>
    <ns>0</ns>
    <id>354</id>
    <revision>
      <id>50715</id>
      <parentid>41562</parentid>
      <timestamp>2013-06-01T03:37:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/clear|unordered_multimap}}

[[de:cpp/container/unordered multimap/clear]]
[[es:cpp/container/unordered multimap/clear]]
[[fr:cpp/container/unordered multimap/clear]]
[[it:cpp/container/unordered multimap/clear]]
[[ja:cpp/container/unordered multimap/clear]]
[[pt:cpp/container/unordered multimap/clear]]
[[ru:cpp/container/unordered multimap/clear]]
[[zh:cpp/container/unordered multimap/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/count</title>
    <ns>0</ns>
    <id>355</id>
    <revision>
      <id>65129</id>
      <parentid>50716</parentid>
      <timestamp>2013-08-30T16:36:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="430">{{include page|cpp/container/count_unord|unordered_multimap}}

[[de:cpp/container/unordered multimap/count]]
[[es:cpp/container/unordered multimap/count]]
[[fr:cpp/container/unordered multimap/count]]
[[it:cpp/container/unordered multimap/count]]
[[ja:cpp/container/unordered multimap/count]]
[[pt:cpp/container/unordered multimap/count]]
[[ru:cpp/container/unordered multimap/count]]
[[zh:cpp/container/unordered multimap/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/emplace</title>
    <ns>0</ns>
    <id>356</id>
    <revision>
      <id>50717</id>
      <parentid>41560</parentid>
      <timestamp>2013-06-01T03:37:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/emplace assoc|unordered_multimap}}

[[de:cpp/container/unordered multimap/emplace]]
[[es:cpp/container/unordered multimap/emplace]]
[[fr:cpp/container/unordered multimap/emplace]]
[[it:cpp/container/unordered multimap/emplace]]
[[ja:cpp/container/unordered multimap/emplace]]
[[pt:cpp/container/unordered multimap/emplace]]
[[ru:cpp/container/unordered multimap/emplace]]
[[zh:cpp/container/unordered multimap/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/emplace hint</title>
    <ns>0</ns>
    <id>357</id>
    <revision>
      <id>65117</id>
      <parentid>65108</parentid>
      <timestamp>2013-08-30T16:27:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1680">{{cpp/container/unordered_multimap/title | emplace_hint}}
{{cpp/container/unordered_multimap/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed.

The constructor of the element type ({{tt|value_type}}, that is, {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.

{{cpp/container/note_iterator_invalidation|unordered_multimap|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

===Complexity===
Amortized constant on average, worst case linear in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_multimap}}
{{dsc inc | cpp/container/dsc insert |unordered_multimap}}
{{dsc end}}

[[de:cpp/container/unordered multimap/emplace hint]]
[[es:cpp/container/unordered multimap/emplace hint]]
[[fr:cpp/container/unordered multimap/emplace hint]]
[[it:cpp/container/unordered multimap/emplace hint]]
[[ja:cpp/container/unordered multimap/emplace hint]]
[[pt:cpp/container/unordered multimap/emplace hint]]
[[ru:cpp/container/unordered multimap/emplace hint]]
[[zh:cpp/container/unordered multimap/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/empty</title>
    <ns>0</ns>
    <id>358</id>
    <revision>
      <id>50719</id>
      <parentid>41558</parentid>
      <timestamp>2013-06-01T03:37:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/empty|unordered_multimap}}

[[de:cpp/container/unordered multimap/empty]]
[[es:cpp/container/unordered multimap/empty]]
[[fr:cpp/container/unordered multimap/empty]]
[[it:cpp/container/unordered multimap/empty]]
[[ja:cpp/container/unordered multimap/empty]]
[[pt:cpp/container/unordered multimap/empty]]
[[ru:cpp/container/unordered multimap/empty]]
[[zh:cpp/container/unordered multimap/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/end</title>
    <ns>0</ns>
    <id>359</id>
    <revision>
      <id>50720</id>
      <parentid>41557</parentid>
      <timestamp>2013-06-01T03:37:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/end|unordered_multimap}}

[[de:cpp/container/unordered multimap/end]]
[[es:cpp/container/unordered multimap/end]]
[[fr:cpp/container/unordered multimap/end]]
[[it:cpp/container/unordered multimap/end]]
[[ja:cpp/container/unordered multimap/end]]
[[pt:cpp/container/unordered multimap/end]]
[[ru:cpp/container/unordered multimap/end]]
[[zh:cpp/container/unordered multimap/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/end(int)</title>
    <ns>0</ns>
    <id>9087</id>
    <redirect title="cpp/container/unordered multimap/end2" />
    <revision>
      <id>38153</id>
      <timestamp>2012-07-24T13:41:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multimap/end(int)]] to [[cpp/container/unordered multimap/end2]]: Text replace - &quot;/end(int)&quot; to &quot;/end2&quot;</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[cpp/container/unordered multimap/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/end2</title>
    <ns>0</ns>
    <id>360</id>
    <revision>
      <id>50721</id>
      <parentid>41556</parentid>
      <timestamp>2013-06-01T03:37:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/end2|unordered_multimap}}

[[de:cpp/container/unordered multimap/end2]]
[[es:cpp/container/unordered multimap/end2]]
[[fr:cpp/container/unordered multimap/end2]]
[[it:cpp/container/unordered multimap/end2]]
[[ja:cpp/container/unordered multimap/end2]]
[[pt:cpp/container/unordered multimap/end2]]
[[ru:cpp/container/unordered multimap/end2]]
[[zh:cpp/container/unordered multimap/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/equal range</title>
    <ns>0</ns>
    <id>361</id>
    <revision>
      <id>65096</id>
      <parentid>65082</parentid>
      <timestamp>2013-08-30T15:58:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="484">{{include page|cpp/container/equal_range_unord|unordered_multimap}}

[[de:cpp/container/unordered multimap/equal range]]
[[es:cpp/container/unordered multimap/equal range]]
[[fr:cpp/container/unordered multimap/equal range]]
[[it:cpp/container/unordered multimap/equal range]]
[[ja:cpp/container/unordered multimap/equal range]]
[[pt:cpp/container/unordered multimap/equal range]]
[[ru:cpp/container/unordered multimap/equal range]]
[[zh:cpp/container/unordered multimap/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/erase</title>
    <ns>0</ns>
    <id>362</id>
    <revision>
      <id>50723</id>
      <parentid>41554</parentid>
      <timestamp>2013-06-01T03:37:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="430">{{include page|cpp/container/erase assoc|unordered_multimap}}

[[de:cpp/container/unordered multimap/erase]]
[[es:cpp/container/unordered multimap/erase]]
[[fr:cpp/container/unordered multimap/erase]]
[[it:cpp/container/unordered multimap/erase]]
[[ja:cpp/container/unordered multimap/erase]]
[[pt:cpp/container/unordered multimap/erase]]
[[ru:cpp/container/unordered multimap/erase]]
[[zh:cpp/container/unordered multimap/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/find</title>
    <ns>0</ns>
    <id>363</id>
    <revision>
      <id>50724</id>
      <parentid>41553</parentid>
      <timestamp>2013-06-01T03:37:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/find|unordered_multimap}}

[[de:cpp/container/unordered multimap/find]]
[[es:cpp/container/unordered multimap/find]]
[[fr:cpp/container/unordered multimap/find]]
[[it:cpp/container/unordered multimap/find]]
[[ja:cpp/container/unordered multimap/find]]
[[pt:cpp/container/unordered multimap/find]]
[[ru:cpp/container/unordered multimap/find]]
[[zh:cpp/container/unordered multimap/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/get allocator</title>
    <ns>0</ns>
    <id>364</id>
    <revision>
      <id>50725</id>
      <parentid>41552</parentid>
      <timestamp>2013-06-01T03:37:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="496">{{include page|cpp/container/get_allocator|unordered_multimap}}

[[de:cpp/container/unordered multimap/get allocator]]
[[es:cpp/container/unordered multimap/get allocator]]
[[fr:cpp/container/unordered multimap/get allocator]]
[[it:cpp/container/unordered multimap/get allocator]]
[[ja:cpp/container/unordered multimap/get allocator]]
[[pt:cpp/container/unordered multimap/get allocator]]
[[ru:cpp/container/unordered multimap/get allocator]]
[[zh:cpp/container/unordered multimap/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/hash function</title>
    <ns>0</ns>
    <id>365</id>
    <revision>
      <id>50726</id>
      <parentid>41551</parentid>
      <timestamp>2013-06-01T03:37:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="496">{{include page|cpp/container/hash_function|unordered_multimap}}

[[de:cpp/container/unordered multimap/hash function]]
[[es:cpp/container/unordered multimap/hash function]]
[[fr:cpp/container/unordered multimap/hash function]]
[[it:cpp/container/unordered multimap/hash function]]
[[ja:cpp/container/unordered multimap/hash function]]
[[pt:cpp/container/unordered multimap/hash function]]
[[ru:cpp/container/unordered multimap/hash function]]
[[zh:cpp/container/unordered multimap/hash function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/insert</title>
    <ns>0</ns>
    <id>366</id>
    <revision>
      <id>65008</id>
      <parentid>64999</parentid>
      <timestamp>2013-08-28T23:04:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{v}}</comment>
      <text xml:space="preserve" bytes="2704">{{cpp/container/unordered_multimap/title | insert}}
{{cpp/container/unordered_multimap/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
iterator insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class P &gt;
iterator insert( P&amp;&amp; value );
}}
{{dcl | num=3 | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl | num=4 | since=c++11 |
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
{{dcl | num=5 | since=c++11 |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container.

@1-2@ inserts {{tt|value}}. The overload {{v|2}} is equivalent to {{c|emplace(std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@3-4@ inserts {{tt|value}}, using {{tt|hint}} as a non-binding suggestion to where the search should start. The overload {{v|4}} is equivalent to {{c|emplace_hint(hint, std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.

@5@ inserts elements from range {{tt|[first, last)}}.

@6@ inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|unordered_multimap|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-4@ Returns an iterator to the inserted element.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-4@ Average case: {{tt|O(1)}}, worst case {{tt|O(size())}}

@5-6@ Average case: {{tt|O(N)}}, where N is the number of elements to insert. Worse case: {{tt|O(N*size()+N)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_multimap}}
{{dsc inc | cpp/container/dsc emplace_hint |unordered_multimap}}
{{dsc end}}

[[de:cpp/container/unordered multimap/insert]]
[[es:cpp/container/unordered multimap/insert]]
[[fr:cpp/container/unordered multimap/insert]]
[[it:cpp/container/unordered multimap/insert]]
[[ja:cpp/container/unordered multimap/insert]]
[[pt:cpp/container/unordered multimap/insert]]
[[ru:cpp/container/unordered multimap/insert]]
[[zh:cpp/container/unordered multimap/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/key eq</title>
    <ns>0</ns>
    <id>367</id>
    <revision>
      <id>50727</id>
      <parentid>41549</parentid>
      <timestamp>2013-06-01T03:37:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/key_eq|unordered_multimap}}

[[de:cpp/container/unordered multimap/key eq]]
[[es:cpp/container/unordered multimap/key eq]]
[[fr:cpp/container/unordered multimap/key eq]]
[[it:cpp/container/unordered multimap/key eq]]
[[ja:cpp/container/unordered multimap/key eq]]
[[pt:cpp/container/unordered multimap/key eq]]
[[ru:cpp/container/unordered multimap/key eq]]
[[zh:cpp/container/unordered multimap/key eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/load factor</title>
    <ns>0</ns>
    <id>368</id>
    <revision>
      <id>50728</id>
      <parentid>41548</parentid>
      <timestamp>2013-06-01T03:37:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/load_factor|unordered_multimap}}

[[de:cpp/container/unordered multimap/load factor]]
[[es:cpp/container/unordered multimap/load factor]]
[[fr:cpp/container/unordered multimap/load factor]]
[[it:cpp/container/unordered multimap/load factor]]
[[ja:cpp/container/unordered multimap/load factor]]
[[pt:cpp/container/unordered multimap/load factor]]
[[ru:cpp/container/unordered multimap/load factor]]
[[zh:cpp/container/unordered multimap/load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/max bucket count</title>
    <ns>0</ns>
    <id>369</id>
    <revision>
      <id>50729</id>
      <parentid>41547</parentid>
      <timestamp>2013-06-01T03:37:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="523">{{include page|cpp/container/max_bucket_count|unordered_multimap}}

[[de:cpp/container/unordered multimap/max bucket count]]
[[es:cpp/container/unordered multimap/max bucket count]]
[[fr:cpp/container/unordered multimap/max bucket count]]
[[it:cpp/container/unordered multimap/max bucket count]]
[[ja:cpp/container/unordered multimap/max bucket count]]
[[pt:cpp/container/unordered multimap/max bucket count]]
[[ru:cpp/container/unordered multimap/max bucket count]]
[[zh:cpp/container/unordered multimap/max bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/max load factor</title>
    <ns>0</ns>
    <id>370</id>
    <revision>
      <id>50730</id>
      <parentid>41546</parentid>
      <timestamp>2013-06-01T03:37:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="514">{{include page|cpp/container/max_load_factor|unordered_multimap}}

[[de:cpp/container/unordered multimap/max load factor]]
[[es:cpp/container/unordered multimap/max load factor]]
[[fr:cpp/container/unordered multimap/max load factor]]
[[it:cpp/container/unordered multimap/max load factor]]
[[ja:cpp/container/unordered multimap/max load factor]]
[[pt:cpp/container/unordered multimap/max load factor]]
[[ru:cpp/container/unordered multimap/max load factor]]
[[zh:cpp/container/unordered multimap/max load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/max size</title>
    <ns>0</ns>
    <id>371</id>
    <revision>
      <id>50731</id>
      <parentid>41545</parentid>
      <timestamp>2013-06-01T03:37:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/max_size|unordered_multimap}}

[[de:cpp/container/unordered multimap/max size]]
[[es:cpp/container/unordered multimap/max size]]
[[fr:cpp/container/unordered multimap/max size]]
[[it:cpp/container/unordered multimap/max size]]
[[ja:cpp/container/unordered multimap/max size]]
[[pt:cpp/container/unordered multimap/max size]]
[[ru:cpp/container/unordered multimap/max size]]
[[zh:cpp/container/unordered multimap/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/operator=</title>
    <ns>0</ns>
    <id>372</id>
    <revision>
      <id>41544</id>
      <parentid>743</parentid>
      <timestamp>2012-11-02T16:31:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="451">{{cpp/container/operator{{=}}|unordered_multimap}}

[[de:cpp/container/unordered multimap/operator=]]
[[es:cpp/container/unordered multimap/operator=]]
[[fr:cpp/container/unordered multimap/operator=]]
[[it:cpp/container/unordered multimap/operator=]]
[[ja:cpp/container/unordered multimap/operator=]]
[[pt:cpp/container/unordered multimap/operator=]]
[[ru:cpp/container/unordered multimap/operator=]]
[[zh:cpp/container/unordered multimap/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/operator cmp</title>
    <ns>0</ns>
    <id>2010</id>
    <revision>
      <id>50732</id>
      <parentid>41543</parentid>
      <timestamp>2013-06-01T03:37:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="493">{{include page|cpp/container/operator_cmp_unord|unordered_multimap}}

[[de:cpp/container/unordered multimap/operator cmp]]
[[es:cpp/container/unordered multimap/operator cmp]]
[[fr:cpp/container/unordered multimap/operator cmp]]
[[it:cpp/container/unordered multimap/operator cmp]]
[[ja:cpp/container/unordered multimap/operator cmp]]
[[pt:cpp/container/unordered multimap/operator cmp]]
[[ru:cpp/container/unordered multimap/operator cmp]]
[[zh:cpp/container/unordered multimap/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/operator comp</title>
    <ns>0</ns>
    <id>4206</id>
    <redirect title="cpp/container/unordered multimap/operator cmp" />
    <revision>
      <id>15229</id>
      <timestamp>2011-12-08T01:09:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multimap/operator comp]] to [[cpp/container/unordered multimap/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[cpp/container/unordered multimap/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/rehash</title>
    <ns>0</ns>
    <id>373</id>
    <revision>
      <id>50733</id>
      <parentid>41542</parentid>
      <timestamp>2013-06-01T03:37:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/rehash|unordered_multimap}}

[[de:cpp/container/unordered multimap/rehash]]
[[es:cpp/container/unordered multimap/rehash]]
[[fr:cpp/container/unordered multimap/rehash]]
[[it:cpp/container/unordered multimap/rehash]]
[[ja:cpp/container/unordered multimap/rehash]]
[[pt:cpp/container/unordered multimap/rehash]]
[[ru:cpp/container/unordered multimap/rehash]]
[[zh:cpp/container/unordered multimap/rehash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/reserve</title>
    <ns>0</ns>
    <id>374</id>
    <revision>
      <id>50734</id>
      <parentid>41541</parentid>
      <timestamp>2013-06-01T03:38:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/reserve unord|unordered_multimap}}

[[de:cpp/container/unordered multimap/reserve]]
[[es:cpp/container/unordered multimap/reserve]]
[[fr:cpp/container/unordered multimap/reserve]]
[[it:cpp/container/unordered multimap/reserve]]
[[ja:cpp/container/unordered multimap/reserve]]
[[pt:cpp/container/unordered multimap/reserve]]
[[ru:cpp/container/unordered multimap/reserve]]
[[zh:cpp/container/unordered multimap/reserve]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/size</title>
    <ns>0</ns>
    <id>375</id>
    <revision>
      <id>50735</id>
      <parentid>41540</parentid>
      <timestamp>2013-06-01T03:38:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/size|unordered_multimap}}

[[de:cpp/container/unordered multimap/size]]
[[es:cpp/container/unordered multimap/size]]
[[fr:cpp/container/unordered multimap/size]]
[[it:cpp/container/unordered multimap/size]]
[[ja:cpp/container/unordered multimap/size]]
[[pt:cpp/container/unordered multimap/size]]
[[ru:cpp/container/unordered multimap/size]]
[[zh:cpp/container/unordered multimap/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/std swap</title>
    <ns>0</ns>
    <id>3469</id>
    <redirect title="cpp/container/unordered multimap/swap2" />
    <revision>
      <id>13027</id>
      <timestamp>2011-11-03T18:41:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multimap/std swap]] to [[cpp/container/unordered multimap/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[cpp/container/unordered multimap/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/swap</title>
    <ns>0</ns>
    <id>376</id>
    <revision>
      <id>50736</id>
      <parentid>41539</parentid>
      <timestamp>2013-06-01T03:38:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/swap|unordered_multimap}}

[[de:cpp/container/unordered multimap/swap]]
[[es:cpp/container/unordered multimap/swap]]
[[fr:cpp/container/unordered multimap/swap]]
[[it:cpp/container/unordered multimap/swap]]
[[ja:cpp/container/unordered multimap/swap]]
[[pt:cpp/container/unordered multimap/swap]]
[[ru:cpp/container/unordered multimap/swap]]
[[zh:cpp/container/unordered multimap/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/swap2</title>
    <ns>0</ns>
    <id>2005</id>
    <revision>
      <id>50737</id>
      <parentid>41538</parentid>
      <timestamp>2013-06-01T03:38:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/swap2|unordered_multimap}}

[[de:cpp/container/unordered multimap/swap2]]
[[es:cpp/container/unordered multimap/swap2]]
[[fr:cpp/container/unordered multimap/swap2]]
[[it:cpp/container/unordered multimap/swap2]]
[[ja:cpp/container/unordered multimap/swap2]]
[[pt:cpp/container/unordered multimap/swap2]]
[[ru:cpp/container/unordered multimap/swap2]]
[[zh:cpp/container/unordered multimap/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/unordered multimap</title>
    <ns>0</ns>
    <id>378</id>
    <revision>
      <id>50738</id>
      <parentid>41537</parentid>
      <timestamp>2013-06-01T03:38:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="540">{{include page|cpp/container/constructor unord|unordered_multimap}}

[[de:cpp/container/unordered multimap/unordered multimap]]
[[es:cpp/container/unordered multimap/unordered multimap]]
[[fr:cpp/container/unordered multimap/unordered multimap]]
[[it:cpp/container/unordered multimap/unordered multimap]]
[[ja:cpp/container/unordered multimap/unordered multimap]]
[[pt:cpp/container/unordered multimap/unordered multimap]]
[[ru:cpp/container/unordered multimap/unordered multimap]]
[[zh:cpp/container/unordered multimap/unordered multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multimap/~unordered multimap</title>
    <ns>0</ns>
    <id>380</id>
    <revision>
      <id>50739</id>
      <parentid>41536</parentid>
      <timestamp>2013-06-01T03:38:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="541">{{include page|cpp/container/destructor|unordered_multimap}}

[[de:cpp/container/unordered multimap/~unordered multimap]]
[[es:cpp/container/unordered multimap/~unordered multimap]]
[[fr:cpp/container/unordered multimap/~unordered multimap]]
[[it:cpp/container/unordered multimap/~unordered multimap]]
[[ja:cpp/container/unordered multimap/~unordered multimap]]
[[pt:cpp/container/unordered multimap/~unordered multimap]]
[[ru:cpp/container/unordered multimap/~unordered multimap]]
[[zh:cpp/container/unordered multimap/~unordered multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset</title>
    <ns>0</ns>
    <id>381</id>
    <revision>
      <id>65961</id>
      <parentid>63290</parentid>
      <timestamp>2013-10-16T14:30:39Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="4672">{{cpp/title|unordered_multiset}}
{{cpp/container/unordered_multiset/navbar}}
{{ddcl | header=unordered_set | since=c++11 |
template&lt;
    class Key,
    class Hash {{=}} std::hash&lt;Key&gt;,
    class KeyEqual {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt;
&gt; class unordered_multiset;
}} 

Unordered multiset is an associative container that contains set of possibly non-unique objects of type Key. Search, insertion, and removal have average constant-time complexity.

Internally, the elements are not sorted in any particular order, but organized into buckets. Which bucket an element is placed into depends entirely on the hash of its value. This allows fast access to individual elements, since once hash is computed, it refers to the exact bucket the element is placed into.

{{tt|std::unordered_multiset}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|UnorderedAssociativeContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | unordered_multiset}}
{{dsc inc | cpp/container/dsc value_type | unordered_multiset}}
{{dsc inc | cpp/container/dsc size_type | unordered_multiset}}
{{dsc inc | cpp/container/dsc difference_type | unordered_multiset}}
{{dsc inc | cpp/container/dsc hasher | unordered_multiset}}
{{dsc inc | cpp/container/dsc key_equal | unordered_multiset}}
{{dsc inc | cpp/container/dsc allocator_type | unordered_multiset}}
{{dsc inc | cpp/container/dsc reference | unordered_multiset}}
{{dsc inc | cpp/container/dsc const_reference | unordered_multiset}}
{{dsc inc | cpp/container/dsc pointer | unordered_multiset}}
{{dsc inc | cpp/container/dsc const_pointer | unordered_multiset}}
{{dsc inc | cpp/container/dsc iterator | unordered_multiset}}
{{dsc inc | cpp/container/dsc const_iterator | unordered_multiset}}
{{dsc inc | cpp/container/dsc local_iterator | unordered_multiset}}
{{dsc inc | cpp/container/dsc const_local_iterator | unordered_multiset}}
{{dsc end}}



===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | unordered_multiset}}
{{dsc inc | cpp/container/dsc destructor | unordered_multiset}}
{{dsc inc | cpp/container/dsc operator{{=}} | unordered_multiset}}
{{dsc inc | cpp/container/dsc get_allocator | unordered_multiset}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | unordered_multiset}}
{{dsc inc | cpp/container/dsc end | unordered_multiset}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | unordered_multiset}}
{{dsc inc | cpp/container/dsc size | unordered_multiset}}
{{dsc inc | cpp/container/dsc max_size | unordered_multiset}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | unordered_multiset}}
{{dsc inc | cpp/container/dsc insert | unordered_multiset}}
{{dsc inc | cpp/container/dsc emplace | unordered_multiset}}
{{dsc inc | cpp/container/dsc emplace_hint | unordered_multiset}}
{{dsc inc | cpp/container/dsc erase | unordered_multiset}}
{{dsc inc | cpp/container/dsc swap | unordered_multiset}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | unordered_multiset}}
{{dsc inc | cpp/container/dsc find | unordered_multiset}}
{{dsc inc | cpp/container/dsc equal_range | unordered_multiset}}

{{dsc h2 | Bucket interface}}
{{dsc inc | cpp/container/dsc begin(int) | unordered_multiset}}
{{dsc inc | cpp/container/dsc end(int) | unordered_multiset}}
{{dsc inc | cpp/container/dsc bucket_count | unordered_multiset}}
{{dsc inc | cpp/container/dsc max_bucket_count | unordered_multiset}}
{{dsc inc | cpp/container/dsc bucket_size | unordered_multiset}}
{{dsc inc | cpp/container/dsc bucket | unordered_multiset}}

{{dsc h2 | Hash policy}}
{{dsc inc | cpp/container/dsc load_factor | unordered_multiset}}
{{dsc inc | cpp/container/dsc max_load_factor | unordered_multiset}}
{{dsc inc | cpp/container/dsc rehash | unordered_multiset}}
{{dsc inc | cpp/container/dsc reserve | unordered_multiset}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc hash_function | unordered_multiset}}
{{dsc inc | cpp/container/dsc key_eq | unordered_multiset}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multiset}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multiset}}
{{dsc end}}

===Notes===
{{cpp/container/assoc_note}}

[[de:cpp/container/unordered multiset]]
[[es:cpp/container/unordered multiset]]
[[fr:cpp/container/unordered multiset]]
[[it:cpp/container/unordered multiset]]
[[ja:cpp/container/unordered multiset]]
[[pt:cpp/container/unordered multiset]]
[[ru:cpp/container/unordered multiset]]
[[zh:cpp/container/unordered multiset]]</text>
      <sha1>8ccyo2mrcy1tiwjm1ja7exs31y3hk1l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/begin</title>
    <ns>0</ns>
    <id>382</id>
    <revision>
      <id>50740</id>
      <parentid>41534</parentid>
      <timestamp>2013-06-01T03:38:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/begin|unordered_multiset}}

[[de:cpp/container/unordered multiset/begin]]
[[es:cpp/container/unordered multiset/begin]]
[[fr:cpp/container/unordered multiset/begin]]
[[it:cpp/container/unordered multiset/begin]]
[[ja:cpp/container/unordered multiset/begin]]
[[pt:cpp/container/unordered multiset/begin]]
[[ru:cpp/container/unordered multiset/begin]]
[[zh:cpp/container/unordered multiset/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/begin(int)</title>
    <ns>0</ns>
    <id>9083</id>
    <redirect title="cpp/container/unordered multiset/begin2" />
    <revision>
      <id>38135</id>
      <timestamp>2012-07-24T13:28:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multiset/begin(int)]] to [[cpp/container/unordered multiset/begin2]]: Text replace - &quot;/begin(int)&quot; to &quot;/begin2&quot;</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[cpp/container/unordered multiset/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/begin2</title>
    <ns>0</ns>
    <id>383</id>
    <revision>
      <id>50741</id>
      <parentid>41533</parentid>
      <timestamp>2013-06-01T03:38:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/begin2|unordered_multiset}}

[[de:cpp/container/unordered multiset/begin2]]
[[es:cpp/container/unordered multiset/begin2]]
[[fr:cpp/container/unordered multiset/begin2]]
[[it:cpp/container/unordered multiset/begin2]]
[[ja:cpp/container/unordered multiset/begin2]]
[[pt:cpp/container/unordered multiset/begin2]]
[[ru:cpp/container/unordered multiset/begin2]]
[[zh:cpp/container/unordered multiset/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/bucket</title>
    <ns>0</ns>
    <id>384</id>
    <revision>
      <id>50742</id>
      <parentid>41532</parentid>
      <timestamp>2013-06-01T03:38:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/bucket|unordered_multiset}}

[[de:cpp/container/unordered multiset/bucket]]
[[es:cpp/container/unordered multiset/bucket]]
[[fr:cpp/container/unordered multiset/bucket]]
[[it:cpp/container/unordered multiset/bucket]]
[[ja:cpp/container/unordered multiset/bucket]]
[[pt:cpp/container/unordered multiset/bucket]]
[[ru:cpp/container/unordered multiset/bucket]]
[[zh:cpp/container/unordered multiset/bucket]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/bucket count</title>
    <ns>0</ns>
    <id>385</id>
    <revision>
      <id>50743</id>
      <parentid>41531</parentid>
      <timestamp>2013-06-01T03:38:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="487">{{include page|cpp/container/bucket_count|unordered_multiset}}

[[de:cpp/container/unordered multiset/bucket count]]
[[es:cpp/container/unordered multiset/bucket count]]
[[fr:cpp/container/unordered multiset/bucket count]]
[[it:cpp/container/unordered multiset/bucket count]]
[[ja:cpp/container/unordered multiset/bucket count]]
[[pt:cpp/container/unordered multiset/bucket count]]
[[ru:cpp/container/unordered multiset/bucket count]]
[[zh:cpp/container/unordered multiset/bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/bucket size</title>
    <ns>0</ns>
    <id>386</id>
    <revision>
      <id>50744</id>
      <parentid>41530</parentid>
      <timestamp>2013-06-01T03:38:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/bucket_size|unordered_multiset}}

[[de:cpp/container/unordered multiset/bucket size]]
[[es:cpp/container/unordered multiset/bucket size]]
[[fr:cpp/container/unordered multiset/bucket size]]
[[it:cpp/container/unordered multiset/bucket size]]
[[ja:cpp/container/unordered multiset/bucket size]]
[[pt:cpp/container/unordered multiset/bucket size]]
[[ru:cpp/container/unordered multiset/bucket size]]
[[zh:cpp/container/unordered multiset/bucket size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/clear</title>
    <ns>0</ns>
    <id>387</id>
    <revision>
      <id>50745</id>
      <parentid>41529</parentid>
      <timestamp>2013-06-01T03:38:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/clear|unordered_multiset}}

[[de:cpp/container/unordered multiset/clear]]
[[es:cpp/container/unordered multiset/clear]]
[[fr:cpp/container/unordered multiset/clear]]
[[it:cpp/container/unordered multiset/clear]]
[[ja:cpp/container/unordered multiset/clear]]
[[pt:cpp/container/unordered multiset/clear]]
[[ru:cpp/container/unordered multiset/clear]]
[[zh:cpp/container/unordered multiset/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/count</title>
    <ns>0</ns>
    <id>388</id>
    <revision>
      <id>65128</id>
      <parentid>50746</parentid>
      <timestamp>2013-08-30T16:36:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="430">{{include page|cpp/container/count_unord|unordered_multiset}}

[[de:cpp/container/unordered multiset/count]]
[[es:cpp/container/unordered multiset/count]]
[[fr:cpp/container/unordered multiset/count]]
[[it:cpp/container/unordered multiset/count]]
[[ja:cpp/container/unordered multiset/count]]
[[pt:cpp/container/unordered multiset/count]]
[[ru:cpp/container/unordered multiset/count]]
[[zh:cpp/container/unordered multiset/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/emplace</title>
    <ns>0</ns>
    <id>389</id>
    <revision>
      <id>50747</id>
      <parentid>41527</parentid>
      <timestamp>2013-06-01T03:38:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/emplace assoc|unordered_multiset}}

[[de:cpp/container/unordered multiset/emplace]]
[[es:cpp/container/unordered multiset/emplace]]
[[fr:cpp/container/unordered multiset/emplace]]
[[it:cpp/container/unordered multiset/emplace]]
[[ja:cpp/container/unordered multiset/emplace]]
[[pt:cpp/container/unordered multiset/emplace]]
[[ru:cpp/container/unordered multiset/emplace]]
[[zh:cpp/container/unordered multiset/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/emplace hint</title>
    <ns>0</ns>
    <id>390</id>
    <revision>
      <id>65116</id>
      <parentid>65107</parentid>
      <timestamp>2013-08-30T16:27:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1617">{{cpp/container/unordered_multiset/title | emplace_hint}}
{{cpp/container/unordered_multiset/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}. 

{{cpp/container/note_iterator_invalidation|unordered_multiset|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

===Complexity===
Amortized constant on average, worst case linear in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_multiset}}
{{dsc inc | cpp/container/dsc insert |unordered_multiset}}
{{dsc end}}

[[de:cpp/container/unordered multiset/emplace hint]]
[[es:cpp/container/unordered multiset/emplace hint]]
[[fr:cpp/container/unordered multiset/emplace hint]]
[[it:cpp/container/unordered multiset/emplace hint]]
[[ja:cpp/container/unordered multiset/emplace hint]]
[[pt:cpp/container/unordered multiset/emplace hint]]
[[ru:cpp/container/unordered multiset/emplace hint]]
[[zh:cpp/container/unordered multiset/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/empty</title>
    <ns>0</ns>
    <id>391</id>
    <revision>
      <id>50749</id>
      <parentid>41525</parentid>
      <timestamp>2013-06-01T03:38:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/empty|unordered_multiset}}

[[de:cpp/container/unordered multiset/empty]]
[[es:cpp/container/unordered multiset/empty]]
[[fr:cpp/container/unordered multiset/empty]]
[[it:cpp/container/unordered multiset/empty]]
[[ja:cpp/container/unordered multiset/empty]]
[[pt:cpp/container/unordered multiset/empty]]
[[ru:cpp/container/unordered multiset/empty]]
[[zh:cpp/container/unordered multiset/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/end</title>
    <ns>0</ns>
    <id>392</id>
    <revision>
      <id>50750</id>
      <parentid>41524</parentid>
      <timestamp>2013-06-01T03:38:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/end|unordered_multiset}}

[[de:cpp/container/unordered multiset/end]]
[[es:cpp/container/unordered multiset/end]]
[[fr:cpp/container/unordered multiset/end]]
[[it:cpp/container/unordered multiset/end]]
[[ja:cpp/container/unordered multiset/end]]
[[pt:cpp/container/unordered multiset/end]]
[[ru:cpp/container/unordered multiset/end]]
[[zh:cpp/container/unordered multiset/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/end(int)</title>
    <ns>0</ns>
    <id>9088</id>
    <redirect title="cpp/container/unordered multiset/end2" />
    <revision>
      <id>38155</id>
      <timestamp>2012-07-24T13:41:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multiset/end(int)]] to [[cpp/container/unordered multiset/end2]]: Text replace - &quot;/end(int)&quot; to &quot;/end2&quot;</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[cpp/container/unordered multiset/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/end2</title>
    <ns>0</ns>
    <id>393</id>
    <revision>
      <id>50751</id>
      <parentid>41523</parentid>
      <timestamp>2013-06-01T03:38:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/end2|unordered_multiset}}

[[de:cpp/container/unordered multiset/end2]]
[[es:cpp/container/unordered multiset/end2]]
[[fr:cpp/container/unordered multiset/end2]]
[[it:cpp/container/unordered multiset/end2]]
[[ja:cpp/container/unordered multiset/end2]]
[[pt:cpp/container/unordered multiset/end2]]
[[ru:cpp/container/unordered multiset/end2]]
[[zh:cpp/container/unordered multiset/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/equal range</title>
    <ns>0</ns>
    <id>394</id>
    <revision>
      <id>65095</id>
      <parentid>65081</parentid>
      <timestamp>2013-08-30T15:58:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="484">{{include page|cpp/container/equal_range_unord|unordered_multiset}}

[[de:cpp/container/unordered multiset/equal range]]
[[es:cpp/container/unordered multiset/equal range]]
[[fr:cpp/container/unordered multiset/equal range]]
[[it:cpp/container/unordered multiset/equal range]]
[[ja:cpp/container/unordered multiset/equal range]]
[[pt:cpp/container/unordered multiset/equal range]]
[[ru:cpp/container/unordered multiset/equal range]]
[[zh:cpp/container/unordered multiset/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/erase</title>
    <ns>0</ns>
    <id>395</id>
    <revision>
      <id>50753</id>
      <parentid>43287</parentid>
      <timestamp>2013-06-01T03:38:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="430">{{include page|cpp/container/erase assoc|unordered_multiset}}

[[de:cpp/container/unordered multiset/erase]]
[[es:cpp/container/unordered multiset/erase]]
[[fr:cpp/container/unordered multiset/erase]]
[[it:cpp/container/unordered multiset/erase]]
[[ja:cpp/container/unordered multiset/erase]]
[[pt:cpp/container/unordered multiset/erase]]
[[ru:cpp/container/unordered multiset/erase]]
[[zh:cpp/container/unordered multiset/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/find</title>
    <ns>0</ns>
    <id>396</id>
    <revision>
      <id>50754</id>
      <parentid>43280</parentid>
      <timestamp>2013-06-01T03:38:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/find|unordered_multiset}}

[[de:cpp/container/unordered multiset/find]]
[[es:cpp/container/unordered multiset/find]]
[[fr:cpp/container/unordered multiset/find]]
[[it:cpp/container/unordered multiset/find]]
[[ja:cpp/container/unordered multiset/find]]
[[pt:cpp/container/unordered multiset/find]]
[[ru:cpp/container/unordered multiset/find]]
[[zh:cpp/container/unordered multiset/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/get allocator</title>
    <ns>0</ns>
    <id>397</id>
    <revision>
      <id>50755</id>
      <parentid>43273</parentid>
      <timestamp>2013-06-01T03:38:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="496">{{include page|cpp/container/get_allocator|unordered_multiset}}

[[de:cpp/container/unordered multiset/get allocator]]
[[es:cpp/container/unordered multiset/get allocator]]
[[fr:cpp/container/unordered multiset/get allocator]]
[[it:cpp/container/unordered multiset/get allocator]]
[[ja:cpp/container/unordered multiset/get allocator]]
[[pt:cpp/container/unordered multiset/get allocator]]
[[ru:cpp/container/unordered multiset/get allocator]]
[[zh:cpp/container/unordered multiset/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/hash function</title>
    <ns>0</ns>
    <id>398</id>
    <revision>
      <id>50756</id>
      <parentid>43267</parentid>
      <timestamp>2013-06-01T03:38:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="496">{{include page|cpp/container/hash_function|unordered_multiset}}

[[de:cpp/container/unordered multiset/hash function]]
[[es:cpp/container/unordered multiset/hash function]]
[[fr:cpp/container/unordered multiset/hash function]]
[[it:cpp/container/unordered multiset/hash function]]
[[ja:cpp/container/unordered multiset/hash function]]
[[pt:cpp/container/unordered multiset/hash function]]
[[ru:cpp/container/unordered multiset/hash function]]
[[zh:cpp/container/unordered multiset/hash function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/insert</title>
    <ns>0</ns>
    <id>399</id>
    <revision>
      <id>65001</id>
      <parentid>64985</parentid>
      <timestamp>2013-08-28T22:52:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="2293">{{cpp/container/unordered_multiset/title | insert}}
{{cpp/container/unordered_multiset/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
iterator insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
iterator insert( value_type&amp;&amp; value );
}}
{{dcl | num=3 | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl | num=4 | since=c++11 |
iterator insert( const_iterator hint, value_type&amp;&amp; value );
}}
{{dcl | num=5 | since=c++11 |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container.

@1-2@ Inserts {{tt|value}}.

@3-4@ Inserts {{tt|value}}, using {{tt|hint}} as a non-binding suggestion to where the search should start.

@5@ Inserts elements from range {{tt|[first, last)}}.

@6@ Inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|unordered_multiset|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-4@ Returns an iterator to the inserted element.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-4@ Average case: {{tt|O(1)}}, worst case {{tt|O(size())}}

@5-6@ Average case: {{tt|O(N)}}, where N is the number of elements to insert. Worse case: {{tt|O(N*size()+N)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_multiset}}
{{dsc inc | cpp/container/dsc emplace_hint |unordered_multiset}}
{{dsc end}}

[[de:cpp/container/unordered multiset/insert]]
[[es:cpp/container/unordered multiset/insert]]
[[fr:cpp/container/unordered multiset/insert]]
[[it:cpp/container/unordered multiset/insert]]
[[ja:cpp/container/unordered multiset/insert]]
[[pt:cpp/container/unordered multiset/insert]]
[[ru:cpp/container/unordered multiset/insert]]
[[zh:cpp/container/unordered multiset/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/key eq</title>
    <ns>0</ns>
    <id>400</id>
    <revision>
      <id>50757</id>
      <parentid>43254</parentid>
      <timestamp>2013-06-01T03:38:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/key_eq|unordered_multiset}}

[[de:cpp/container/unordered multiset/key eq]]
[[es:cpp/container/unordered multiset/key eq]]
[[fr:cpp/container/unordered multiset/key eq]]
[[it:cpp/container/unordered multiset/key eq]]
[[ja:cpp/container/unordered multiset/key eq]]
[[pt:cpp/container/unordered multiset/key eq]]
[[ru:cpp/container/unordered multiset/key eq]]
[[zh:cpp/container/unordered multiset/key eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/load factor</title>
    <ns>0</ns>
    <id>401</id>
    <revision>
      <id>50758</id>
      <parentid>43247</parentid>
      <timestamp>2013-06-01T03:38:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/load_factor|unordered_multiset}}

[[de:cpp/container/unordered multiset/load factor]]
[[es:cpp/container/unordered multiset/load factor]]
[[fr:cpp/container/unordered multiset/load factor]]
[[it:cpp/container/unordered multiset/load factor]]
[[ja:cpp/container/unordered multiset/load factor]]
[[pt:cpp/container/unordered multiset/load factor]]
[[ru:cpp/container/unordered multiset/load factor]]
[[zh:cpp/container/unordered multiset/load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/max bucket count</title>
    <ns>0</ns>
    <id>402</id>
    <revision>
      <id>50759</id>
      <parentid>43241</parentid>
      <timestamp>2013-06-01T03:38:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="523">{{include page|cpp/container/max_bucket_count|unordered_multiset}}

[[de:cpp/container/unordered multiset/max bucket count]]
[[es:cpp/container/unordered multiset/max bucket count]]
[[fr:cpp/container/unordered multiset/max bucket count]]
[[it:cpp/container/unordered multiset/max bucket count]]
[[ja:cpp/container/unordered multiset/max bucket count]]
[[pt:cpp/container/unordered multiset/max bucket count]]
[[ru:cpp/container/unordered multiset/max bucket count]]
[[zh:cpp/container/unordered multiset/max bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/max load factor</title>
    <ns>0</ns>
    <id>403</id>
    <revision>
      <id>50760</id>
      <parentid>43236</parentid>
      <timestamp>2013-06-01T03:38:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="514">{{include page|cpp/container/max_load_factor|unordered_multiset}}

[[de:cpp/container/unordered multiset/max load factor]]
[[es:cpp/container/unordered multiset/max load factor]]
[[fr:cpp/container/unordered multiset/max load factor]]
[[it:cpp/container/unordered multiset/max load factor]]
[[ja:cpp/container/unordered multiset/max load factor]]
[[pt:cpp/container/unordered multiset/max load factor]]
[[ru:cpp/container/unordered multiset/max load factor]]
[[zh:cpp/container/unordered multiset/max load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/max size</title>
    <ns>0</ns>
    <id>404</id>
    <revision>
      <id>50761</id>
      <parentid>43228</parentid>
      <timestamp>2013-06-01T03:38:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/max_size|unordered_multiset}}

[[de:cpp/container/unordered multiset/max size]]
[[es:cpp/container/unordered multiset/max size]]
[[fr:cpp/container/unordered multiset/max size]]
[[it:cpp/container/unordered multiset/max size]]
[[ja:cpp/container/unordered multiset/max size]]
[[pt:cpp/container/unordered multiset/max size]]
[[ru:cpp/container/unordered multiset/max size]]
[[zh:cpp/container/unordered multiset/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/operator=</title>
    <ns>0</ns>
    <id>405</id>
    <revision>
      <id>43221</id>
      <parentid>809</parentid>
      <timestamp>2012-11-03T02:04:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="451">{{cpp/container/operator{{=}}|unordered_multiset}}

[[de:cpp/container/unordered multiset/operator=]]
[[es:cpp/container/unordered multiset/operator=]]
[[fr:cpp/container/unordered multiset/operator=]]
[[it:cpp/container/unordered multiset/operator=]]
[[ja:cpp/container/unordered multiset/operator=]]
[[pt:cpp/container/unordered multiset/operator=]]
[[ru:cpp/container/unordered multiset/operator=]]
[[zh:cpp/container/unordered multiset/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/operator cmp</title>
    <ns>0</ns>
    <id>2009</id>
    <revision>
      <id>50762</id>
      <parentid>43214</parentid>
      <timestamp>2013-06-01T03:38:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="493">{{include page|cpp/container/operator_cmp_unord|unordered_multiset}}

[[de:cpp/container/unordered multiset/operator cmp]]
[[es:cpp/container/unordered multiset/operator cmp]]
[[fr:cpp/container/unordered multiset/operator cmp]]
[[it:cpp/container/unordered multiset/operator cmp]]
[[ja:cpp/container/unordered multiset/operator cmp]]
[[pt:cpp/container/unordered multiset/operator cmp]]
[[ru:cpp/container/unordered multiset/operator cmp]]
[[zh:cpp/container/unordered multiset/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/operator comp</title>
    <ns>0</ns>
    <id>4204</id>
    <redirect title="cpp/container/unordered multiset/operator cmp" />
    <revision>
      <id>15224</id>
      <timestamp>2011-12-08T01:02:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multiset/operator comp]] to [[cpp/container/unordered multiset/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[cpp/container/unordered multiset/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/rehash</title>
    <ns>0</ns>
    <id>406</id>
    <revision>
      <id>50763</id>
      <parentid>43211</parentid>
      <timestamp>2013-06-01T03:38:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/rehash|unordered_multiset}}

[[de:cpp/container/unordered multiset/rehash]]
[[es:cpp/container/unordered multiset/rehash]]
[[fr:cpp/container/unordered multiset/rehash]]
[[it:cpp/container/unordered multiset/rehash]]
[[ja:cpp/container/unordered multiset/rehash]]
[[pt:cpp/container/unordered multiset/rehash]]
[[ru:cpp/container/unordered multiset/rehash]]
[[zh:cpp/container/unordered multiset/rehash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/reserve</title>
    <ns>0</ns>
    <id>407</id>
    <revision>
      <id>50764</id>
      <parentid>43204</parentid>
      <timestamp>2013-06-01T03:38:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/reserve unord|unordered_multiset}}

[[de:cpp/container/unordered multiset/reserve]]
[[es:cpp/container/unordered multiset/reserve]]
[[fr:cpp/container/unordered multiset/reserve]]
[[it:cpp/container/unordered multiset/reserve]]
[[ja:cpp/container/unordered multiset/reserve]]
[[pt:cpp/container/unordered multiset/reserve]]
[[ru:cpp/container/unordered multiset/reserve]]
[[zh:cpp/container/unordered multiset/reserve]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/size</title>
    <ns>0</ns>
    <id>408</id>
    <revision>
      <id>50765</id>
      <parentid>43198</parentid>
      <timestamp>2013-06-01T03:38:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/size|unordered_multiset}}

[[de:cpp/container/unordered multiset/size]]
[[es:cpp/container/unordered multiset/size]]
[[fr:cpp/container/unordered multiset/size]]
[[it:cpp/container/unordered multiset/size]]
[[ja:cpp/container/unordered multiset/size]]
[[pt:cpp/container/unordered multiset/size]]
[[ru:cpp/container/unordered multiset/size]]
[[zh:cpp/container/unordered multiset/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/std swap</title>
    <ns>0</ns>
    <id>3470</id>
    <redirect title="cpp/container/unordered multiset/swap2" />
    <revision>
      <id>13029</id>
      <timestamp>2011-11-03T18:41:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered multiset/std swap]] to [[cpp/container/unordered multiset/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[cpp/container/unordered multiset/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/swap</title>
    <ns>0</ns>
    <id>409</id>
    <revision>
      <id>50766</id>
      <parentid>43191</parentid>
      <timestamp>2013-06-01T03:38:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="415">{{include page|cpp/container/swap|unordered_multiset}}

[[de:cpp/container/unordered multiset/swap]]
[[es:cpp/container/unordered multiset/swap]]
[[fr:cpp/container/unordered multiset/swap]]
[[it:cpp/container/unordered multiset/swap]]
[[ja:cpp/container/unordered multiset/swap]]
[[pt:cpp/container/unordered multiset/swap]]
[[ru:cpp/container/unordered multiset/swap]]
[[zh:cpp/container/unordered multiset/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/swap2</title>
    <ns>0</ns>
    <id>2003</id>
    <revision>
      <id>50767</id>
      <parentid>43186</parentid>
      <timestamp>2013-06-01T03:38:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="424">{{include page|cpp/container/swap2|unordered_multiset}}

[[de:cpp/container/unordered multiset/swap2]]
[[es:cpp/container/unordered multiset/swap2]]
[[fr:cpp/container/unordered multiset/swap2]]
[[it:cpp/container/unordered multiset/swap2]]
[[ja:cpp/container/unordered multiset/swap2]]
[[pt:cpp/container/unordered multiset/swap2]]
[[ru:cpp/container/unordered multiset/swap2]]
[[zh:cpp/container/unordered multiset/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/unordered multiset</title>
    <ns>0</ns>
    <id>410</id>
    <revision>
      <id>50768</id>
      <parentid>43178</parentid>
      <timestamp>2013-06-01T03:39:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="540">{{include page|cpp/container/constructor unord|unordered_multiset}}

[[de:cpp/container/unordered multiset/unordered multiset]]
[[es:cpp/container/unordered multiset/unordered multiset]]
[[fr:cpp/container/unordered multiset/unordered multiset]]
[[it:cpp/container/unordered multiset/unordered multiset]]
[[ja:cpp/container/unordered multiset/unordered multiset]]
[[pt:cpp/container/unordered multiset/unordered multiset]]
[[ru:cpp/container/unordered multiset/unordered multiset]]
[[zh:cpp/container/unordered multiset/unordered multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered multiset/~unordered multiset</title>
    <ns>0</ns>
    <id>411</id>
    <revision>
      <id>50769</id>
      <parentid>43171</parentid>
      <timestamp>2013-06-01T03:39:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="541">{{include page|cpp/container/destructor|unordered_multiset}}

[[de:cpp/container/unordered multiset/~unordered multiset]]
[[es:cpp/container/unordered multiset/~unordered multiset]]
[[fr:cpp/container/unordered multiset/~unordered multiset]]
[[it:cpp/container/unordered multiset/~unordered multiset]]
[[ja:cpp/container/unordered multiset/~unordered multiset]]
[[pt:cpp/container/unordered multiset/~unordered multiset]]
[[ru:cpp/container/unordered multiset/~unordered multiset]]
[[zh:cpp/container/unordered multiset/~unordered multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set</title>
    <ns>0</ns>
    <id>412</id>
    <revision>
      <id>70298</id>
      <parentid>65962</parentid>
      <timestamp>2014-05-18T00:15:01Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4361">{{cpp/title|unordered_set}}
{{cpp/container/unordered_set/navbar}}
{{ddcl | header=unordered_set | since=c++11 |
template&lt;
    class Key,
    class Hash {{=}} std::hash&lt;Key&gt;,
    class KeyEqual {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt;
&gt; class unordered_set;
}} 

Unordered set is an associative container that contains set of unique objects of type Key. Search, insertion, and removal have average constant-time complexity.

Internally, the elements are not sorted in any particular order, but organized into buckets. Which bucket an element is placed into depends entirely on the hash of its value. This allows fast access to individual elements, since once a hash is computed, it refers to the exact bucket the element is placed into.

{{tt|std::unordered_set}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|UnorderedAssociativeContainer}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc key_type | unordered_set}}
{{dsc inc | cpp/container/dsc value_type | unordered_set}}
{{dsc inc | cpp/container/dsc size_type | unordered_set}}
{{dsc inc | cpp/container/dsc difference_type | unordered_set}}
{{dsc inc | cpp/container/dsc hasher | unordered_set}}
{{dsc inc | cpp/container/dsc key_equal | unordered_set}}
{{dsc inc | cpp/container/dsc allocator_type | unordered_set}}
{{dsc inc | cpp/container/dsc reference | unordered_set}}
{{dsc inc | cpp/container/dsc const_reference | unordered_set}}
{{dsc inc | cpp/container/dsc pointer | unordered_set}}
{{dsc inc | cpp/container/dsc const_pointer | unordered_set}}
{{dsc inc | cpp/container/dsc iterator | unordered_set}}
{{dsc inc | cpp/container/dsc const_iterator | unordered_set}}
{{dsc inc | cpp/container/dsc local_iterator | unordered_set}}
{{dsc inc | cpp/container/dsc const_local_iterator | unordered_set}}
{{dsc end}}



===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | unordered_set}}
{{dsc inc | cpp/container/dsc destructor | unordered_set}}
{{dsc inc | cpp/container/dsc operator{{=}} | unordered_set}}
{{dsc inc | cpp/container/dsc get_allocator | unordered_set}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | unordered_set}}
{{dsc inc | cpp/container/dsc end | unordered_set}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | unordered_set}}
{{dsc inc | cpp/container/dsc size | unordered_set}}
{{dsc inc | cpp/container/dsc max_size | unordered_set}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | unordered_set}}
{{dsc inc | cpp/container/dsc insert | unordered_set}}
{{dsc inc | cpp/container/dsc emplace | unordered_set}}
{{dsc inc | cpp/container/dsc emplace_hint | unordered_set}}
{{dsc inc | cpp/container/dsc erase | unordered_set}}
{{dsc inc | cpp/container/dsc swap | unordered_set}}

{{dsc h2 | Lookup}}
{{dsc inc | cpp/container/dsc count | unordered_set}}
{{dsc inc | cpp/container/dsc find | unordered_set}}
{{dsc inc | cpp/container/dsc equal_range | unordered_set}}

{{dsc h2 | Bucket interface}}
{{dsc inc | cpp/container/dsc begin(int) | unordered_set}}
{{dsc inc | cpp/container/dsc end(int) | unordered_set}}
{{dsc inc | cpp/container/dsc bucket_count | unordered_set}}
{{dsc inc | cpp/container/dsc max_bucket_count | unordered_set}}
{{dsc inc | cpp/container/dsc bucket_size | unordered_set}}
{{dsc inc | cpp/container/dsc bucket | unordered_set}}

{{dsc h2 | Hash policy}}
{{dsc inc | cpp/container/dsc load_factor | unordered_set}}
{{dsc inc | cpp/container/dsc max_load_factor | unordered_set}}
{{dsc inc | cpp/container/dsc rehash | unordered_set}}
{{dsc inc | cpp/container/dsc reserve | unordered_set}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/container/dsc hash_function | unordered_set}}
{{dsc inc | cpp/container/dsc key_eq | unordered_set}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_set}}
{{dsc inc | cpp/container/dsc swap2 | unordered_set}}
{{dsc end}}

===Notes===
{{cpp/container/assoc_note}}

[[de:cpp/container/unordered set]]
[[es:cpp/container/unordered set]]
[[fr:cpp/container/unordered set]]
[[it:cpp/container/unordered set]]
[[ja:cpp/container/unordered set]]
[[pt:cpp/container/unordered set]]
[[ru:cpp/container/unordered set]]
[[zh:cpp/container/unordered set]]</text>
      <sha1>45ush5rqwgygtlq24d00t7gjzx4o6om</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/begin</title>
    <ns>0</ns>
    <id>413</id>
    <revision>
      <id>50770</id>
      <parentid>43157</parentid>
      <timestamp>2013-06-01T03:39:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/begin|unordered_set}}

[[de:cpp/container/unordered set/begin]]
[[es:cpp/container/unordered set/begin]]
[[fr:cpp/container/unordered set/begin]]
[[it:cpp/container/unordered set/begin]]
[[ja:cpp/container/unordered set/begin]]
[[pt:cpp/container/unordered set/begin]]
[[ru:cpp/container/unordered set/begin]]
[[zh:cpp/container/unordered set/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/begin(int)</title>
    <ns>0</ns>
    <id>9084</id>
    <redirect title="cpp/container/unordered set/begin2" />
    <revision>
      <id>38137</id>
      <timestamp>2012-07-24T13:29:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered set/begin(int)]] to [[cpp/container/unordered set/begin2]]: Text replace - &quot;/begin(int)&quot; to &quot;/begin2&quot;</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/container/unordered set/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/begin2</title>
    <ns>0</ns>
    <id>414</id>
    <revision>
      <id>50771</id>
      <parentid>43149</parentid>
      <timestamp>2013-06-01T03:39:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/begin2|unordered_set}}

[[de:cpp/container/unordered set/begin2]]
[[es:cpp/container/unordered set/begin2]]
[[fr:cpp/container/unordered set/begin2]]
[[it:cpp/container/unordered set/begin2]]
[[ja:cpp/container/unordered set/begin2]]
[[pt:cpp/container/unordered set/begin2]]
[[ru:cpp/container/unordered set/begin2]]
[[zh:cpp/container/unordered set/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/bucket</title>
    <ns>0</ns>
    <id>415</id>
    <revision>
      <id>50772</id>
      <parentid>43144</parentid>
      <timestamp>2013-06-01T03:39:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/bucket|unordered_set}}

[[de:cpp/container/unordered set/bucket]]
[[es:cpp/container/unordered set/bucket]]
[[fr:cpp/container/unordered set/bucket]]
[[it:cpp/container/unordered set/bucket]]
[[ja:cpp/container/unordered set/bucket]]
[[pt:cpp/container/unordered set/bucket]]
[[ru:cpp/container/unordered set/bucket]]
[[zh:cpp/container/unordered set/bucket]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/bucket count</title>
    <ns>0</ns>
    <id>416</id>
    <revision>
      <id>50773</id>
      <parentid>43137</parentid>
      <timestamp>2013-06-01T03:39:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="442">{{include page|cpp/container/bucket_count|unordered_set}}

[[de:cpp/container/unordered set/bucket count]]
[[es:cpp/container/unordered set/bucket count]]
[[fr:cpp/container/unordered set/bucket count]]
[[it:cpp/container/unordered set/bucket count]]
[[ja:cpp/container/unordered set/bucket count]]
[[pt:cpp/container/unordered set/bucket count]]
[[ru:cpp/container/unordered set/bucket count]]
[[zh:cpp/container/unordered set/bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/bucket size</title>
    <ns>0</ns>
    <id>417</id>
    <revision>
      <id>50774</id>
      <parentid>43128</parentid>
      <timestamp>2013-06-01T03:39:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/bucket_size|unordered_set}}

[[de:cpp/container/unordered set/bucket size]]
[[es:cpp/container/unordered set/bucket size]]
[[fr:cpp/container/unordered set/bucket size]]
[[it:cpp/container/unordered set/bucket size]]
[[ja:cpp/container/unordered set/bucket size]]
[[pt:cpp/container/unordered set/bucket size]]
[[ru:cpp/container/unordered set/bucket size]]
[[zh:cpp/container/unordered set/bucket size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/clear</title>
    <ns>0</ns>
    <id>418</id>
    <revision>
      <id>50775</id>
      <parentid>43123</parentid>
      <timestamp>2013-06-01T03:39:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/clear|unordered_set}}

[[de:cpp/container/unordered set/clear]]
[[es:cpp/container/unordered set/clear]]
[[fr:cpp/container/unordered set/clear]]
[[it:cpp/container/unordered set/clear]]
[[ja:cpp/container/unordered set/clear]]
[[pt:cpp/container/unordered set/clear]]
[[ru:cpp/container/unordered set/clear]]
[[zh:cpp/container/unordered set/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/count</title>
    <ns>0</ns>
    <id>419</id>
    <revision>
      <id>65127</id>
      <parentid>50776</parentid>
      <timestamp>2013-08-30T16:36:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="385">{{include page|cpp/container/count_unord|unordered_set}}

[[de:cpp/container/unordered set/count]]
[[es:cpp/container/unordered set/count]]
[[fr:cpp/container/unordered set/count]]
[[it:cpp/container/unordered set/count]]
[[ja:cpp/container/unordered set/count]]
[[pt:cpp/container/unordered set/count]]
[[ru:cpp/container/unordered set/count]]
[[zh:cpp/container/unordered set/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/emplace</title>
    <ns>0</ns>
    <id>420</id>
    <revision>
      <id>50777</id>
      <parentid>43109</parentid>
      <timestamp>2013-06-01T03:39:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/container/emplace assoc|unordered_set}}

[[de:cpp/container/unordered set/emplace]]
[[es:cpp/container/unordered set/emplace]]
[[fr:cpp/container/unordered set/emplace]]
[[it:cpp/container/unordered set/emplace]]
[[ja:cpp/container/unordered set/emplace]]
[[pt:cpp/container/unordered set/emplace]]
[[ru:cpp/container/unordered set/emplace]]
[[zh:cpp/container/unordered set/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/emplace hint</title>
    <ns>0</ns>
    <id>421</id>
    <revision>
      <id>65115</id>
      <parentid>65106</parentid>
      <timestamp>2013-08-30T16:27:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="1690">{{cpp/container/unordered_set/title | emplace_hint}}
{{cpp/container/unordered_set/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. 

The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}. 

{{cpp/container/note_iterator_invalidation|unordered_set|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.

If the insertion failed because the element already exists, returns an iterator to the already existing element with the equivalent key.

===Complexity===
Amortized constant on average, worst case linear in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_set}}
{{dsc inc | cpp/container/dsc insert |unordered_set}}
{{dsc end}}

[[de:cpp/container/unordered set/emplace hint]]
[[es:cpp/container/unordered set/emplace hint]]
[[fr:cpp/container/unordered set/emplace hint]]
[[it:cpp/container/unordered set/emplace hint]]
[[ja:cpp/container/unordered set/emplace hint]]
[[pt:cpp/container/unordered set/emplace hint]]
[[ru:cpp/container/unordered set/emplace hint]]
[[zh:cpp/container/unordered set/emplace hint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/empty</title>
    <ns>0</ns>
    <id>422</id>
    <revision>
      <id>50779</id>
      <parentid>43095</parentid>
      <timestamp>2013-06-01T03:39:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/empty|unordered_set}}

[[de:cpp/container/unordered set/empty]]
[[es:cpp/container/unordered set/empty]]
[[fr:cpp/container/unordered set/empty]]
[[it:cpp/container/unordered set/empty]]
[[ja:cpp/container/unordered set/empty]]
[[pt:cpp/container/unordered set/empty]]
[[ru:cpp/container/unordered set/empty]]
[[zh:cpp/container/unordered set/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/end</title>
    <ns>0</ns>
    <id>423</id>
    <revision>
      <id>50780</id>
      <parentid>43087</parentid>
      <timestamp>2013-06-01T03:39:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="361">{{include page|cpp/container/end|unordered_set}}

[[de:cpp/container/unordered set/end]]
[[es:cpp/container/unordered set/end]]
[[fr:cpp/container/unordered set/end]]
[[it:cpp/container/unordered set/end]]
[[ja:cpp/container/unordered set/end]]
[[pt:cpp/container/unordered set/end]]
[[ru:cpp/container/unordered set/end]]
[[zh:cpp/container/unordered set/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/end(int)</title>
    <ns>0</ns>
    <id>9089</id>
    <redirect title="cpp/container/unordered set/end2" />
    <revision>
      <id>38157</id>
      <timestamp>2012-07-24T13:41:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[cpp/container/unordered set/end(int)]] to [[cpp/container/unordered set/end2]]: Text replace - &quot;/end(int)&quot; to &quot;/end2&quot;</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/container/unordered set/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/end2</title>
    <ns>0</ns>
    <id>424</id>
    <revision>
      <id>50781</id>
      <parentid>43077</parentid>
      <timestamp>2013-06-01T03:39:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/end2|unordered_set}}

[[de:cpp/container/unordered set/end2]]
[[es:cpp/container/unordered set/end2]]
[[fr:cpp/container/unordered set/end2]]
[[it:cpp/container/unordered set/end2]]
[[ja:cpp/container/unordered set/end2]]
[[pt:cpp/container/unordered set/end2]]
[[ru:cpp/container/unordered set/end2]]
[[zh:cpp/container/unordered set/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/equal range</title>
    <ns>0</ns>
    <id>425</id>
    <revision>
      <id>65094</id>
      <parentid>65080</parentid>
      <timestamp>2013-08-30T15:58:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="439">{{include page|cpp/container/equal_range_unord|unordered_set}}

[[de:cpp/container/unordered set/equal range]]
[[es:cpp/container/unordered set/equal range]]
[[fr:cpp/container/unordered set/equal range]]
[[it:cpp/container/unordered set/equal range]]
[[ja:cpp/container/unordered set/equal range]]
[[pt:cpp/container/unordered set/equal range]]
[[ru:cpp/container/unordered set/equal range]]
[[zh:cpp/container/unordered set/equal range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/erase</title>
    <ns>0</ns>
    <id>426</id>
    <revision>
      <id>50783</id>
      <parentid>43066</parentid>
      <timestamp>2013-06-01T03:39:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="385">{{include page|cpp/container/erase assoc|unordered_set}}

[[de:cpp/container/unordered set/erase]]
[[es:cpp/container/unordered set/erase]]
[[fr:cpp/container/unordered set/erase]]
[[it:cpp/container/unordered set/erase]]
[[ja:cpp/container/unordered set/erase]]
[[pt:cpp/container/unordered set/erase]]
[[ru:cpp/container/unordered set/erase]]
[[zh:cpp/container/unordered set/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/find</title>
    <ns>0</ns>
    <id>427</id>
    <revision>
      <id>50784</id>
      <parentid>43059</parentid>
      <timestamp>2013-06-01T03:39:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/find|unordered_set}}

[[de:cpp/container/unordered set/find]]
[[es:cpp/container/unordered set/find]]
[[fr:cpp/container/unordered set/find]]
[[it:cpp/container/unordered set/find]]
[[ja:cpp/container/unordered set/find]]
[[pt:cpp/container/unordered set/find]]
[[ru:cpp/container/unordered set/find]]
[[zh:cpp/container/unordered set/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/get allocator</title>
    <ns>0</ns>
    <id>428</id>
    <revision>
      <id>50785</id>
      <parentid>43051</parentid>
      <timestamp>2013-06-01T03:39:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/get_allocator|unordered_set}}

[[de:cpp/container/unordered set/get allocator]]
[[es:cpp/container/unordered set/get allocator]]
[[fr:cpp/container/unordered set/get allocator]]
[[it:cpp/container/unordered set/get allocator]]
[[ja:cpp/container/unordered set/get allocator]]
[[pt:cpp/container/unordered set/get allocator]]
[[ru:cpp/container/unordered set/get allocator]]
[[zh:cpp/container/unordered set/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/hash function</title>
    <ns>0</ns>
    <id>429</id>
    <revision>
      <id>50786</id>
      <parentid>43044</parentid>
      <timestamp>2013-06-01T03:39:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="451">{{include page|cpp/container/hash_function|unordered_set}}

[[de:cpp/container/unordered set/hash function]]
[[es:cpp/container/unordered set/hash function]]
[[fr:cpp/container/unordered set/hash function]]
[[it:cpp/container/unordered set/hash function]]
[[ja:cpp/container/unordered set/hash function]]
[[pt:cpp/container/unordered set/hash function]]
[[ru:cpp/container/unordered set/hash function]]
[[zh:cpp/container/unordered set/hash function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/insert</title>
    <ns>0</ns>
    <id>430</id>
    <revision>
      <id>65000</id>
      <parentid>64986</parentid>
      <timestamp>2013-08-28T22:52:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="2566">{{cpp/container/unordered_set/title | insert}}
{{cpp/container/unordered_set/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
std::pair&lt;iterator,bool&gt; insert( const value_type&amp; value );
}}
{{dcl | num=2 | since=c++11 |
std::pair&lt;iterator,bool&gt; insert( value_type&amp;&amp; value );
}}
{{dcl | num=3 | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl | num=4 | since=c++11 |
iterator insert( const_iterator hint, value_type&amp;&amp; value );
}}
{{dcl | num=5 | since=c++11 |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.

@1-2@ Inserts {{tt|value}}. 

@3-4@ Inserts {{tt|value}}, using {{tt|hint}} as a non-binding suggestion to where the search should start.

@5@ Inserts elements from range {{tt|[first, last)}}.

@6@ Inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|unordered_set|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-2@ Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a {{c|bool}} denoting whether the insertion took place.

@3-4@ Returns an iterator to the inserted element, or to the element that prevented the insertion.

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===
@1-4@ Average case: {{tt|O(1)}}, worst case {{tt|O(size())}}

@5-6@ Average case: {{tt|O(N)}}, where N is the number of elements to insert. Worse case: {{tt|O(N*size()+N)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |unordered_set}}
{{dsc inc | cpp/container/dsc emplace_hint |unordered_set}}
{{dsc end}}

[[de:cpp/container/unordered set/insert]]
[[es:cpp/container/unordered set/insert]]
[[fr:cpp/container/unordered set/insert]]
[[it:cpp/container/unordered set/insert]]
[[ja:cpp/container/unordered set/insert]]
[[pt:cpp/container/unordered set/insert]]
[[ru:cpp/container/unordered set/insert]]
[[zh:cpp/container/unordered set/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/key eq</title>
    <ns>0</ns>
    <id>431</id>
    <revision>
      <id>50787</id>
      <parentid>43032</parentid>
      <timestamp>2013-06-01T03:39:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/key_eq|unordered_set}}

[[de:cpp/container/unordered set/key eq]]
[[es:cpp/container/unordered set/key eq]]
[[fr:cpp/container/unordered set/key eq]]
[[it:cpp/container/unordered set/key eq]]
[[ja:cpp/container/unordered set/key eq]]
[[pt:cpp/container/unordered set/key eq]]
[[ru:cpp/container/unordered set/key eq]]
[[zh:cpp/container/unordered set/key eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/load factor</title>
    <ns>0</ns>
    <id>432</id>
    <revision>
      <id>50788</id>
      <parentid>43025</parentid>
      <timestamp>2013-06-01T03:39:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="433">{{include page|cpp/container/load_factor|unordered_set}}

[[de:cpp/container/unordered set/load factor]]
[[es:cpp/container/unordered set/load factor]]
[[fr:cpp/container/unordered set/load factor]]
[[it:cpp/container/unordered set/load factor]]
[[ja:cpp/container/unordered set/load factor]]
[[pt:cpp/container/unordered set/load factor]]
[[ru:cpp/container/unordered set/load factor]]
[[zh:cpp/container/unordered set/load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/max bucket count</title>
    <ns>0</ns>
    <id>433</id>
    <revision>
      <id>50789</id>
      <parentid>43018</parentid>
      <timestamp>2013-06-01T03:39:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="478">{{include page|cpp/container/max_bucket_count|unordered_set}}

[[de:cpp/container/unordered set/max bucket count]]
[[es:cpp/container/unordered set/max bucket count]]
[[fr:cpp/container/unordered set/max bucket count]]
[[it:cpp/container/unordered set/max bucket count]]
[[ja:cpp/container/unordered set/max bucket count]]
[[pt:cpp/container/unordered set/max bucket count]]
[[ru:cpp/container/unordered set/max bucket count]]
[[zh:cpp/container/unordered set/max bucket count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/max load factor</title>
    <ns>0</ns>
    <id>434</id>
    <revision>
      <id>50790</id>
      <parentid>43014</parentid>
      <timestamp>2013-06-01T03:39:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="469">{{include page|cpp/container/max_load_factor|unordered_set}}

[[de:cpp/container/unordered set/max load factor]]
[[es:cpp/container/unordered set/max load factor]]
[[fr:cpp/container/unordered set/max load factor]]
[[it:cpp/container/unordered set/max load factor]]
[[ja:cpp/container/unordered set/max load factor]]
[[pt:cpp/container/unordered set/max load factor]]
[[ru:cpp/container/unordered set/max load factor]]
[[zh:cpp/container/unordered set/max load factor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/max size</title>
    <ns>0</ns>
    <id>435</id>
    <revision>
      <id>50791</id>
      <parentid>43008</parentid>
      <timestamp>2013-06-01T03:39:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="406">{{include page|cpp/container/max_size|unordered_set}}

[[de:cpp/container/unordered set/max size]]
[[es:cpp/container/unordered set/max size]]
[[fr:cpp/container/unordered set/max size]]
[[it:cpp/container/unordered set/max size]]
[[ja:cpp/container/unordered set/max size]]
[[pt:cpp/container/unordered set/max size]]
[[ru:cpp/container/unordered set/max size]]
[[zh:cpp/container/unordered set/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/operator=</title>
    <ns>0</ns>
    <id>436</id>
    <revision>
      <id>42999</id>
      <parentid>871</parentid>
      <timestamp>2012-11-03T01:18:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="406">{{cpp/container/operator{{=}}|unordered_set}}

[[de:cpp/container/unordered set/operator=]]
[[es:cpp/container/unordered set/operator=]]
[[fr:cpp/container/unordered set/operator=]]
[[it:cpp/container/unordered set/operator=]]
[[ja:cpp/container/unordered set/operator=]]
[[pt:cpp/container/unordered set/operator=]]
[[ru:cpp/container/unordered set/operator=]]
[[zh:cpp/container/unordered set/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/operator cmp</title>
    <ns>0</ns>
    <id>2008</id>
    <revision>
      <id>50792</id>
      <parentid>42994</parentid>
      <timestamp>2013-06-01T03:39:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/container/operator_cmp_unord|unordered_set}}

[[de:cpp/container/unordered set/operator cmp]]
[[es:cpp/container/unordered set/operator cmp]]
[[fr:cpp/container/unordered set/operator cmp]]
[[it:cpp/container/unordered set/operator cmp]]
[[ja:cpp/container/unordered set/operator cmp]]
[[pt:cpp/container/unordered set/operator cmp]]
[[ru:cpp/container/unordered set/operator cmp]]
[[zh:cpp/container/unordered set/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/operator comp</title>
    <ns>0</ns>
    <id>4214</id>
    <redirect title="cpp/container/unordered set/operator cmp" />
    <revision>
      <id>15247</id>
      <timestamp>2011-12-08T01:15:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered set/operator comp]] to [[cpp/container/unordered set/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[cpp/container/unordered set/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/rehash</title>
    <ns>0</ns>
    <id>437</id>
    <revision>
      <id>50793</id>
      <parentid>42984</parentid>
      <timestamp>2013-06-01T03:39:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/rehash|unordered_set}}

[[de:cpp/container/unordered set/rehash]]
[[es:cpp/container/unordered set/rehash]]
[[fr:cpp/container/unordered set/rehash]]
[[it:cpp/container/unordered set/rehash]]
[[ja:cpp/container/unordered set/rehash]]
[[pt:cpp/container/unordered set/rehash]]
[[ru:cpp/container/unordered set/rehash]]
[[zh:cpp/container/unordered set/rehash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/reserve</title>
    <ns>0</ns>
    <id>438</id>
    <revision>
      <id>50794</id>
      <parentid>42977</parentid>
      <timestamp>2013-06-01T03:39:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/container/reserve unord|unordered_set}}

[[de:cpp/container/unordered set/reserve]]
[[es:cpp/container/unordered set/reserve]]
[[fr:cpp/container/unordered set/reserve]]
[[it:cpp/container/unordered set/reserve]]
[[ja:cpp/container/unordered set/reserve]]
[[pt:cpp/container/unordered set/reserve]]
[[ru:cpp/container/unordered set/reserve]]
[[zh:cpp/container/unordered set/reserve]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/size</title>
    <ns>0</ns>
    <id>439</id>
    <revision>
      <id>50795</id>
      <parentid>42971</parentid>
      <timestamp>2013-06-01T03:39:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/size|unordered_set}}

[[de:cpp/container/unordered set/size]]
[[es:cpp/container/unordered set/size]]
[[fr:cpp/container/unordered set/size]]
[[it:cpp/container/unordered set/size]]
[[ja:cpp/container/unordered set/size]]
[[pt:cpp/container/unordered set/size]]
[[ru:cpp/container/unordered set/size]]
[[zh:cpp/container/unordered set/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/std swap</title>
    <ns>0</ns>
    <id>3471</id>
    <redirect title="cpp/container/unordered set/swap2" />
    <revision>
      <id>13031</id>
      <timestamp>2011-11-03T18:42:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/unordered set/std swap]] to [[cpp/container/unordered set/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/container/unordered set/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/swap</title>
    <ns>0</ns>
    <id>440</id>
    <revision>
      <id>50796</id>
      <parentid>42964</parentid>
      <timestamp>2013-06-01T03:39:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/swap|unordered_set}}

[[de:cpp/container/unordered set/swap]]
[[es:cpp/container/unordered set/swap]]
[[fr:cpp/container/unordered set/swap]]
[[it:cpp/container/unordered set/swap]]
[[ja:cpp/container/unordered set/swap]]
[[pt:cpp/container/unordered set/swap]]
[[ru:cpp/container/unordered set/swap]]
[[zh:cpp/container/unordered set/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/swap2</title>
    <ns>0</ns>
    <id>1998</id>
    <revision>
      <id>50797</id>
      <parentid>42958</parentid>
      <timestamp>2013-06-01T03:39:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/swap2|unordered_set}}

[[de:cpp/container/unordered set/swap2]]
[[es:cpp/container/unordered set/swap2]]
[[fr:cpp/container/unordered set/swap2]]
[[it:cpp/container/unordered set/swap2]]
[[ja:cpp/container/unordered set/swap2]]
[[pt:cpp/container/unordered set/swap2]]
[[ru:cpp/container/unordered set/swap2]]
[[zh:cpp/container/unordered set/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/unordered set</title>
    <ns>0</ns>
    <id>441</id>
    <revision>
      <id>50798</id>
      <parentid>42944</parentid>
      <timestamp>2013-06-01T03:39:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="455">{{include page|cpp/container/constructor unord|unordered_set}}

[[de:cpp/container/unordered set/unordered set]]
[[es:cpp/container/unordered set/unordered set]]
[[fr:cpp/container/unordered set/unordered set]]
[[it:cpp/container/unordered set/unordered set]]
[[ja:cpp/container/unordered set/unordered set]]
[[pt:cpp/container/unordered set/unordered set]]
[[ru:cpp/container/unordered set/unordered set]]
[[zh:cpp/container/unordered set/unordered set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/unordered set/~unordered set</title>
    <ns>0</ns>
    <id>442</id>
    <revision>
      <id>50799</id>
      <parentid>42942</parentid>
      <timestamp>2013-06-01T03:39:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="456">{{include page|cpp/container/destructor|unordered_set}}

[[de:cpp/container/unordered set/~unordered set]]
[[es:cpp/container/unordered set/~unordered set]]
[[fr:cpp/container/unordered set/~unordered set]]
[[it:cpp/container/unordered set/~unordered set]]
[[ja:cpp/container/unordered set/~unordered set]]
[[pt:cpp/container/unordered set/~unordered set]]
[[ru:cpp/container/unordered set/~unordered set]]
[[zh:cpp/container/unordered set/~unordered set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector</title>
    <ns>0</ns>
    <id>443</id>
    <revision>
      <id>69480</id>
      <parentid>69479</parentid>
      <timestamp>2014-04-12T13:48:38Z</timestamp>
      <contributor>
        <ip>82.240.132.144</ip>
      </contributor>
      <text xml:space="preserve" bytes="5584">{{cpp/title|vector}}
{{cpp/container/vector/navbar}}
{{ddcl | header=vector |
template&lt;
    class T,
    class Allocator {{=}} std::allocator&lt;T&gt;
&gt; class vector;
}} 

{{tt|std::vector}} is a sequence container that encapsulates dynamic size arrays.

The elements are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets on regular pointers to elements. This means that  a pointer to an element of a vector may be passed to any function that expects a pointer to an element of an array.

The storage of the vector is handled automatically, being expanded and contracted as needed. Vectors usually occupy more space than static arrays, because more memory is allocated to handle future growth. This way a vector does not need to reallocate each time an element is inserted, but only when the additional memory is exhausted. The total amount of allocated memory can be queried using {{lc|capacity()}} function. {{rev inl | since=c++11 | Extra memory can be returned to the system via a call to {{lc|shrink_to_fit()}}.}}

Reallocations are usually costly operations in terms of performance. {{lc|reserve()}} function can be used to eliminate reallocations if the number of elements is known beforehand.

The complexity (efficiency) of common operations on vectors is as follows:

* Random access - constant {{math|O(1)}}
* Insertion or removal of elements at the end - amortized constant {{math|O(1)}}
* Insertion or removal of elements - linear in distance to the end of the vector {{math|O(n)}}

{{tt|std::vector}} meets the requirements of {{concept|Container}}, {{concept|AllocatorAwareContainer}}, {{concept|SequenceContainer}} and {{concept|ReversibleContainer}}.

===Template parameters===
{{par begin}}
{{par inc | cpp/container/param list T | vector}}
{{par inc | cpp/container/param list Allocator | vector}}
{{par end}}

===Specializations===
The standard library provides a specialization of {{tt|std::vector}} for the type {{c|bool}}, which is optimized for space efficiency.
{{dsc begin}}
{{dsc inc | cpp/container/dsc vector_bool}}
{{dsc end}}

===Iterator invalidation===
{{todo}}
There are still a few inaccuracies in this section.

{| class=&quot;dsctable&quot; style=&quot;font-size:0.8em&quot;
! Operations
! Invalidated
|-
| All read only operations, {{lc|swap}}, {{lc|std::swap}}
| Never
|-
| {{lc|reserve}}, {{lc|shrink_to_fit}}, {{lc|clear}}, {{lc|1=operator=}}
| Always
|-
| {{lc|erase}}
| Erased elements + all elements after them (including {{lc|end()}})
|-
| {{lc|push_back}}, {{lc|emplace_back}}
| If the vector changed capacity, all of them. If not, only end().
|-
| {{lc|insert}}, {{lc|emplace}}, {{lc|resize}}
| If the vector changed capacity, all of them. If not, only those after the insertion point.
|-
| {{lc|pop_back}}
| The element erased and {{lc|end()}}.
|}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | vector}}
{{dsc inc | cpp/container/dsc allocator_type | vector}}
{{dsc inc | cpp/container/dsc size_type | vector}}
{{dsc inc | cpp/container/dsc difference_type | vector}}
{{dsc inc | cpp/container/dsc reference | vector}}
{{dsc inc | cpp/container/dsc const_reference | vector}}
{{dsc inc | cpp/container/dsc pointer | vector}}
{{dsc inc | cpp/container/dsc const_pointer | vector}}
{{dsc inc | cpp/container/dsc iterator | vector}}
{{dsc inc | cpp/container/dsc const_iterator | vector}}
{{dsc inc | cpp/container/dsc reverse_iterator | vector}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | vector}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | vector}}
{{dsc inc | cpp/container/dsc destructor | vector}}
{{dsc inc | cpp/container/dsc operator{{=}} | vector}}
{{dsc inc | cpp/container/dsc assign | vector}}
{{dsc inc | cpp/container/dsc get_allocator | vector}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | vector}}
{{dsc inc | cpp/container/dsc operator_at | vector}}
{{dsc inc | cpp/container/dsc front | vector}}
{{dsc inc | cpp/container/dsc back | vector}}
{{dsc inc | cpp/container/dsc data | vector}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | vector}}
{{dsc inc | cpp/container/dsc end | vector}}
{{dsc inc | cpp/container/dsc rbegin | vector}}
{{dsc inc | cpp/container/dsc rend | vector}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | vector}}
{{dsc inc | cpp/container/dsc size | vector}}
{{dsc inc | cpp/container/dsc max_size | vector}}
{{dsc inc | cpp/container/dsc reserve | vector}}
{{dsc inc | cpp/container/dsc capacity | vector}}
{{dsc inc | cpp/container/dsc shrink_to_fit | vector}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | vector}}
{{dsc inc | cpp/container/dsc insert | vector}}
{{dsc inc | cpp/container/dsc emplace | vector}}
{{dsc inc | cpp/container/dsc erase | vector}}
{{dsc inc | cpp/container/dsc push_back | vector}}
{{dsc inc | cpp/container/dsc emplace_back | vector}}
{{dsc inc | cpp/container/dsc pop_back | vector}}
{{dsc inc | cpp/container/dsc resize | vector}}
{{dsc inc | cpp/container/dsc swap | vector}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | vector}}
{{dsc inc | cpp/container/dsc swap2 | vector}}
{{dsc end}}

[[cs:cpp/container/vector]]
[[de:cpp/container/vector]]
[[es:cpp/container/vector]]
[[fr:cpp/container/vector]]
[[it:cpp/container/vector]]
[[ja:cpp/container/vector]]
[[ko:cpp/container/vector]]
[[pt:cpp/container/vector]]
[[ru:cpp/container/vector]]
[[zh:cpp/container/vector]]</text>
      <sha1>oegpi8wsmeyjoir3ov8rrt31nx92e0c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/assign</title>
    <ns>0</ns>
    <id>444</id>
    <revision>
      <id>50800</id>
      <parentid>42927</parentid>
      <timestamp>2013-06-01T03:39:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/assign|vector}}

[[de:cpp/container/vector/assign]]
[[es:cpp/container/vector/assign]]
[[fr:cpp/container/vector/assign]]
[[it:cpp/container/vector/assign]]
[[ja:cpp/container/vector/assign]]
[[pt:cpp/container/vector/assign]]
[[ru:cpp/container/vector/assign]]
[[zh:cpp/container/vector/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/at</title>
    <ns>0</ns>
    <id>445</id>
    <revision>
      <id>50801</id>
      <parentid>42921</parentid>
      <timestamp>2013-06-01T03:40:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="289">{{include page|cpp/container/at|vector}}

[[de:cpp/container/vector/at]]
[[es:cpp/container/vector/at]]
[[fr:cpp/container/vector/at]]
[[it:cpp/container/vector/at]]
[[ja:cpp/container/vector/at]]
[[pt:cpp/container/vector/at]]
[[ru:cpp/container/vector/at]]
[[zh:cpp/container/vector/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/back</title>
    <ns>0</ns>
    <id>446</id>
    <revision>
      <id>50802</id>
      <parentid>42915</parentid>
      <timestamp>2013-06-01T03:40:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/back|vector}}

[[de:cpp/container/vector/back]]
[[es:cpp/container/vector/back]]
[[fr:cpp/container/vector/back]]
[[it:cpp/container/vector/back]]
[[ja:cpp/container/vector/back]]
[[pt:cpp/container/vector/back]]
[[ru:cpp/container/vector/back]]
[[zh:cpp/container/vector/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/begin</title>
    <ns>0</ns>
    <id>447</id>
    <revision>
      <id>50803</id>
      <parentid>42905</parentid>
      <timestamp>2013-06-01T03:40:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/begin|vector}}

[[de:cpp/container/vector/begin]]
[[es:cpp/container/vector/begin]]
[[fr:cpp/container/vector/begin]]
[[it:cpp/container/vector/begin]]
[[ja:cpp/container/vector/begin]]
[[pt:cpp/container/vector/begin]]
[[ru:cpp/container/vector/begin]]
[[zh:cpp/container/vector/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/capacity</title>
    <ns>0</ns>
    <id>448</id>
    <revision>
      <id>67634</id>
      <parentid>50804</parentid>
      <timestamp>2014-02-14T21:16:18Z</timestamp>
      <contributor>
        <username>Samy</username>
        <id>2858</id>
      </contributor>
      <minor/>
      <comment>added link to cs translation</comment>
      <text xml:space="preserve" bytes="380">{{include page|cpp/container/capacity|vector}}

[[cs:cpp/container/vector/capacity]]
[[de:cpp/container/vector/capacity]]
[[es:cpp/container/vector/capacity]]
[[fr:cpp/container/vector/capacity]]
[[it:cpp/container/vector/capacity]]
[[ja:cpp/container/vector/capacity]]
[[pt:cpp/container/vector/capacity]]
[[ru:cpp/container/vector/capacity]]
[[zh:cpp/container/vector/capacity]]</text>
      <sha1>6qhbl9wiqxwma37siavjzqi0dn8q291</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/clear</title>
    <ns>0</ns>
    <id>449</id>
    <revision>
      <id>50805</id>
      <parentid>42892</parentid>
      <timestamp>2013-06-01T03:40:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/clear|vector}}

[[de:cpp/container/vector/clear]]
[[es:cpp/container/vector/clear]]
[[fr:cpp/container/vector/clear]]
[[it:cpp/container/vector/clear]]
[[ja:cpp/container/vector/clear]]
[[pt:cpp/container/vector/clear]]
[[ru:cpp/container/vector/clear]]
[[zh:cpp/container/vector/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/data</title>
    <ns>0</ns>
    <id>450</id>
    <revision>
      <id>50806</id>
      <parentid>42886</parentid>
      <timestamp>2013-06-01T03:40:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/data|vector}}

[[de:cpp/container/vector/data]]
[[es:cpp/container/vector/data]]
[[fr:cpp/container/vector/data]]
[[it:cpp/container/vector/data]]
[[ja:cpp/container/vector/data]]
[[pt:cpp/container/vector/data]]
[[ru:cpp/container/vector/data]]
[[zh:cpp/container/vector/data]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/emplace</title>
    <ns>0</ns>
    <id>451</id>
    <revision>
      <id>50807</id>
      <parentid>42880</parentid>
      <timestamp>2013-06-01T03:40:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="334">{{include page|cpp/container/emplace|vector}}

[[de:cpp/container/vector/emplace]]
[[es:cpp/container/vector/emplace]]
[[fr:cpp/container/vector/emplace]]
[[it:cpp/container/vector/emplace]]
[[ja:cpp/container/vector/emplace]]
[[pt:cpp/container/vector/emplace]]
[[ru:cpp/container/vector/emplace]]
[[zh:cpp/container/vector/emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/emplace back</title>
    <ns>0</ns>
    <id>452</id>
    <revision>
      <id>50808</id>
      <parentid>42872</parentid>
      <timestamp>2013-06-01T03:40:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/emplace_back|vector}}

[[de:cpp/container/vector/emplace back]]
[[es:cpp/container/vector/emplace back]]
[[fr:cpp/container/vector/emplace back]]
[[it:cpp/container/vector/emplace back]]
[[ja:cpp/container/vector/emplace back]]
[[pt:cpp/container/vector/emplace back]]
[[ru:cpp/container/vector/emplace back]]
[[zh:cpp/container/vector/emplace back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/empty</title>
    <ns>0</ns>
    <id>453</id>
    <revision>
      <id>67652</id>
      <parentid>50809</parentid>
      <timestamp>2014-02-17T20:09:08Z</timestamp>
      <contributor>
        <username>Samy</username>
        <id>2858</id>
      </contributor>
      <minor/>
      <comment>added link to cs translation</comment>
      <text xml:space="preserve" bytes="384">{{include page|cpp/container/empty|vector}}

[[cs:cpp/container/vector/empty]]
[[de:cpp/container/vector/empty]]
[[es:cpp/container/vector/empty]]
[[fr:cpp/container/vector/empty]]
[[it:cpp/container/vector/empty]]
[[ja:cpp/container/vector/empty]]
[[pl:cpp/container/vector/empty]]
[[pt:cpp/container/vector/empty]]
[[ru:cpp/container/vector/empty]]
[[zh:cpp/container/vector/empty]]</text>
      <sha1>k9ua11n02fos97ck5liyzbtsjsdqv2s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/end</title>
    <ns>0</ns>
    <id>454</id>
    <revision>
      <id>50810</id>
      <parentid>42853</parentid>
      <timestamp>2013-06-01T03:40:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="298">{{include page|cpp/container/end|vector}}

[[de:cpp/container/vector/end]]
[[es:cpp/container/vector/end]]
[[fr:cpp/container/vector/end]]
[[it:cpp/container/vector/end]]
[[ja:cpp/container/vector/end]]
[[pt:cpp/container/vector/end]]
[[ru:cpp/container/vector/end]]
[[zh:cpp/container/vector/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/erase</title>
    <ns>0</ns>
    <id>455</id>
    <revision>
      <id>50811</id>
      <parentid>42846</parentid>
      <timestamp>2013-06-01T03:40:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/erase|vector}}

[[de:cpp/container/vector/erase]]
[[es:cpp/container/vector/erase]]
[[fr:cpp/container/vector/erase]]
[[it:cpp/container/vector/erase]]
[[ja:cpp/container/vector/erase]]
[[pt:cpp/container/vector/erase]]
[[ru:cpp/container/vector/erase]]
[[zh:cpp/container/vector/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/front</title>
    <ns>0</ns>
    <id>456</id>
    <revision>
      <id>50812</id>
      <parentid>42835</parentid>
      <timestamp>2013-06-01T03:40:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/front|vector}}

[[de:cpp/container/vector/front]]
[[es:cpp/container/vector/front]]
[[fr:cpp/container/vector/front]]
[[it:cpp/container/vector/front]]
[[ja:cpp/container/vector/front]]
[[pt:cpp/container/vector/front]]
[[ru:cpp/container/vector/front]]
[[zh:cpp/container/vector/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/get allocator</title>
    <ns>0</ns>
    <id>457</id>
    <revision>
      <id>50813</id>
      <parentid>42826</parentid>
      <timestamp>2013-06-01T03:40:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/get_allocator|vector}}

[[de:cpp/container/vector/get allocator]]
[[es:cpp/container/vector/get allocator]]
[[fr:cpp/container/vector/get allocator]]
[[it:cpp/container/vector/get allocator]]
[[ja:cpp/container/vector/get allocator]]
[[pt:cpp/container/vector/get allocator]]
[[ru:cpp/container/vector/get allocator]]
[[zh:cpp/container/vector/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/insert</title>
    <ns>0</ns>
    <id>458</id>
    <revision>
      <id>50814</id>
      <parentid>42820</parentid>
      <timestamp>2013-06-01T03:40:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/insert|vector}}

[[de:cpp/container/vector/insert]]
[[es:cpp/container/vector/insert]]
[[fr:cpp/container/vector/insert]]
[[it:cpp/container/vector/insert]]
[[ja:cpp/container/vector/insert]]
[[pt:cpp/container/vector/insert]]
[[ru:cpp/container/vector/insert]]
[[zh:cpp/container/vector/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/max size</title>
    <ns>0</ns>
    <id>459</id>
    <revision>
      <id>50815</id>
      <parentid>42809</parentid>
      <timestamp>2013-06-01T03:40:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/max_size|vector}}

[[de:cpp/container/vector/max size]]
[[es:cpp/container/vector/max size]]
[[fr:cpp/container/vector/max size]]
[[it:cpp/container/vector/max size]]
[[ja:cpp/container/vector/max size]]
[[pt:cpp/container/vector/max size]]
[[ru:cpp/container/vector/max size]]
[[zh:cpp/container/vector/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/operator=</title>
    <ns>0</ns>
    <id>460</id>
    <revision>
      <id>63214</id>
      <parentid>42799</parentid>
      <timestamp>2013-07-06T11:44:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{include page}}</comment>
      <text xml:space="preserve" bytes="356">{{include page|cpp/container/operator{{=}}|vector}}

[[de:cpp/container/vector/operator=]]
[[es:cpp/container/vector/operator=]]
[[fr:cpp/container/vector/operator=]]
[[it:cpp/container/vector/operator=]]
[[ja:cpp/container/vector/operator=]]
[[pt:cpp/container/vector/operator=]]
[[ru:cpp/container/vector/operator=]]
[[zh:cpp/container/vector/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/operator at</title>
    <ns>0</ns>
    <id>461</id>
    <revision>
      <id>50816</id>
      <parentid>42794</parentid>
      <timestamp>2013-06-01T03:40:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/operator_at|vector}}

[[de:cpp/container/vector/operator at]]
[[es:cpp/container/vector/operator at]]
[[fr:cpp/container/vector/operator at]]
[[it:cpp/container/vector/operator at]]
[[ja:cpp/container/vector/operator at]]
[[pt:cpp/container/vector/operator at]]
[[ru:cpp/container/vector/operator at]]
[[zh:cpp/container/vector/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/operator cmp</title>
    <ns>0</ns>
    <id>1993</id>
    <revision>
      <id>50817</id>
      <parentid>42786</parentid>
      <timestamp>2013-06-01T03:40:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/container/operator_cmp|vector}}

[[de:cpp/container/vector/operator cmp]]
[[es:cpp/container/vector/operator cmp]]
[[fr:cpp/container/vector/operator cmp]]
[[it:cpp/container/vector/operator cmp]]
[[ja:cpp/container/vector/operator cmp]]
[[pt:cpp/container/vector/operator cmp]]
[[ru:cpp/container/vector/operator cmp]]
[[zh:cpp/container/vector/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/operator comp</title>
    <ns>0</ns>
    <id>4449</id>
    <redirect title="cpp/container/vector/operator cmp" />
    <revision>
      <id>15827</id>
      <timestamp>2011-12-16T16:54:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/vector/operator comp]] to [[cpp/container/vector/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/container/vector/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/pop back</title>
    <ns>0</ns>
    <id>462</id>
    <revision>
      <id>50818</id>
      <parentid>42778</parentid>
      <timestamp>2013-06-01T03:40:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="343">{{include page|cpp/container/pop_back|vector}}

[[de:cpp/container/vector/pop back]]
[[es:cpp/container/vector/pop back]]
[[fr:cpp/container/vector/pop back]]
[[it:cpp/container/vector/pop back]]
[[ja:cpp/container/vector/pop back]]
[[pt:cpp/container/vector/pop back]]
[[ru:cpp/container/vector/pop back]]
[[zh:cpp/container/vector/pop back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/push back</title>
    <ns>0</ns>
    <id>463</id>
    <revision>
      <id>42770</id>
      <parentid>40445</parentid>
      <timestamp>2012-11-03T00:23:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/container/vector/push back]], [[pt:cpp/container/vector/push back]]</comment>
      <text xml:space="preserve" bytes="353">{{page_template|cpp/container/push_back|vector}}

[[de:cpp/container/vector/push back]]
[[es:cpp/container/vector/push back]]
[[fr:cpp/container/vector/push back]]
[[it:cpp/container/vector/push back]]
[[ja:cpp/container/vector/push back]]
[[pt:cpp/container/vector/push back]]
[[ru:cpp/container/vector/push back]]
[[zh:cpp/container/vector/push back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/rbegin</title>
    <ns>0</ns>
    <id>464</id>
    <revision>
      <id>50819</id>
      <parentid>42762</parentid>
      <timestamp>2013-06-01T03:40:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/rbegin|vector}}

[[de:cpp/container/vector/rbegin]]
[[es:cpp/container/vector/rbegin]]
[[fr:cpp/container/vector/rbegin]]
[[it:cpp/container/vector/rbegin]]
[[ja:cpp/container/vector/rbegin]]
[[pt:cpp/container/vector/rbegin]]
[[ru:cpp/container/vector/rbegin]]
[[zh:cpp/container/vector/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/rend</title>
    <ns>0</ns>
    <id>465</id>
    <revision>
      <id>50820</id>
      <parentid>42753</parentid>
      <timestamp>2013-06-01T03:40:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/rend|vector}}

[[de:cpp/container/vector/rend]]
[[es:cpp/container/vector/rend]]
[[fr:cpp/container/vector/rend]]
[[it:cpp/container/vector/rend]]
[[ja:cpp/container/vector/rend]]
[[pt:cpp/container/vector/rend]]
[[ru:cpp/container/vector/rend]]
[[zh:cpp/container/vector/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/reserve</title>
    <ns>0</ns>
    <id>466</id>
    <revision>
      <id>67648</id>
      <parentid>50821</parentid>
      <timestamp>2014-02-17T18:52:28Z</timestamp>
      <contributor>
        <username>Samy</username>
        <id>2858</id>
      </contributor>
      <minor/>
      <comment>added link to cs translation</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/container/reserve|vector}}

[[cs:cpp/container/vector/reserve]]
[[de:cpp/container/vector/reserve]]
[[es:cpp/container/vector/reserve]]
[[fr:cpp/container/vector/reserve]]
[[it:cpp/container/vector/reserve]]
[[ja:cpp/container/vector/reserve]]
[[pt:cpp/container/vector/reserve]]
[[ru:cpp/container/vector/reserve]]
[[zh:cpp/container/vector/reserve]]</text>
      <sha1>mi5q095czk4a1p0vppvaq302pggptal</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/resize</title>
    <ns>0</ns>
    <id>467</id>
    <revision>
      <id>50822</id>
      <parentid>42740</parentid>
      <timestamp>2013-06-01T03:40:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="325">{{include page|cpp/container/resize|vector}}

[[de:cpp/container/vector/resize]]
[[es:cpp/container/vector/resize]]
[[fr:cpp/container/vector/resize]]
[[it:cpp/container/vector/resize]]
[[ja:cpp/container/vector/resize]]
[[pt:cpp/container/vector/resize]]
[[ru:cpp/container/vector/resize]]
[[zh:cpp/container/vector/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/shrink to fit</title>
    <ns>0</ns>
    <id>468</id>
    <revision>
      <id>50823</id>
      <parentid>42733</parentid>
      <timestamp>2013-06-01T03:40:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="388">{{include page|cpp/container/shrink_to_fit|vector}}

[[de:cpp/container/vector/shrink to fit]]
[[es:cpp/container/vector/shrink to fit]]
[[fr:cpp/container/vector/shrink to fit]]
[[it:cpp/container/vector/shrink to fit]]
[[ja:cpp/container/vector/shrink to fit]]
[[pt:cpp/container/vector/shrink to fit]]
[[ru:cpp/container/vector/shrink to fit]]
[[zh:cpp/container/vector/shrink to fit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/size</title>
    <ns>0</ns>
    <id>469</id>
    <revision>
      <id>67650</id>
      <parentid>50824</parentid>
      <timestamp>2014-02-17T19:25:49Z</timestamp>
      <contributor>
        <username>Samy</username>
        <id>2858</id>
      </contributor>
      <minor/>
      <comment>added link to cs translation</comment>
      <text xml:space="preserve" bytes="373">{{include page|cpp/container/size|vector}}

[[cs:cpp/container/vector/size]]
[[de:cpp/container/vector/size]]
[[es:cpp/container/vector/size]]
[[fr:cpp/container/vector/size]]
[[it:cpp/container/vector/size]]
[[ja:cpp/container/vector/size]]
[[pl:cpp/container/vector/size]]
[[pt:cpp/container/vector/size]]
[[ru:cpp/container/vector/size]]
[[zh:cpp/container/vector/size]]</text>
      <sha1>oecbw6s366srawbrazg8xftxfhmm6ki</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/std swap</title>
    <ns>0</ns>
    <id>3472</id>
    <redirect title="cpp/container/vector/swap2" />
    <revision>
      <id>13033</id>
      <timestamp>2011-11-03T18:42:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/container/vector/std swap]] to [[cpp/container/vector/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/container/vector/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/swap</title>
    <ns>0</ns>
    <id>470</id>
    <revision>
      <id>50825</id>
      <parentid>42717</parentid>
      <timestamp>2013-06-01T03:40:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="307">{{include page|cpp/container/swap|vector}}

[[de:cpp/container/vector/swap]]
[[es:cpp/container/vector/swap]]
[[fr:cpp/container/vector/swap]]
[[it:cpp/container/vector/swap]]
[[ja:cpp/container/vector/swap]]
[[pt:cpp/container/vector/swap]]
[[ru:cpp/container/vector/swap]]
[[zh:cpp/container/vector/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/swap2</title>
    <ns>0</ns>
    <id>1989</id>
    <revision>
      <id>50826</id>
      <parentid>42710</parentid>
      <timestamp>2013-06-01T03:40:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{include page|cpp/container/swap2|vector}}

[[de:cpp/container/vector/swap2]]
[[es:cpp/container/vector/swap2]]
[[fr:cpp/container/vector/swap2]]
[[it:cpp/container/vector/swap2]]
[[ja:cpp/container/vector/swap2]]
[[pt:cpp/container/vector/swap2]]
[[ru:cpp/container/vector/swap2]]
[[zh:cpp/container/vector/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/vector</title>
    <ns>0</ns>
    <id>471</id>
    <revision>
      <id>50827</id>
      <parentid>42700</parentid>
      <timestamp>2013-06-01T03:40:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="331">{{include page|cpp/container/constructor |vector}}

[[de:cpp/container/vector/vector]]
[[es:cpp/container/vector/vector]]
[[fr:cpp/container/vector/vector]]
[[it:cpp/container/vector/vector]]
[[ja:cpp/container/vector/vector]]
[[pt:cpp/container/vector/vector]]
[[ru:cpp/container/vector/vector]]
[[zh:cpp/container/vector/vector]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector/~vector</title>
    <ns>0</ns>
    <id>472</id>
    <revision>
      <id>50828</id>
      <parentid>42692</parentid>
      <timestamp>2013-06-01T03:40:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="337">{{include page|cpp/container/destructor|vector}}

[[de:cpp/container/vector/~vector]]
[[es:cpp/container/vector/~vector]]
[[fr:cpp/container/vector/~vector]]
[[it:cpp/container/vector/~vector]]
[[ja:cpp/container/vector/~vector]]
[[pt:cpp/container/vector/~vector]]
[[ru:cpp/container/vector/~vector]]
[[zh:cpp/container/vector/~vector]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool</title>
    <ns>0</ns>
    <id>5548</id>
    <revision>
      <id>72318</id>
      <parentid>68717</parentid>
      <timestamp>2014-08-08T00:59:37Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <comment>Default template arguments are not allowed in class template specializations. This is corrected to match the declaration from the Standard.</comment>
      <text xml:space="preserve" bytes="4754">{{cpp/title|vector&lt;bool&gt;}}
{{cpp/container/vector_bool/navbar}}
{{ddcl | header=vector |
template&lt;class Allocator&gt; 
class vector&lt;bool, Allocator&gt;;
}} 

{{c|std::vector&lt;bool&gt;}} is a space-efficient specialization of {{lc|std::vector}} for the type {{c|bool}}. 

The manner in which {{c|std::vector&lt;bool&gt;}} is made space efficient (as well as whether it is optimized at all) is implementation defined.  One potential optimization involves coalescing vector elements such that each element occupies a single bit instead of {{c|sizeof(bool)}} bytes.

{{c|std::vector&lt;bool&gt;}} behaves similarly to {{lc|std::vector}}, but in order to be space efficient, it:

* Does not necessarily store its data in a single contiguous chunk of memory.
* Exposes {{c|std::vector&lt;bool&gt;::reference}} as a method of accessing individual bits.
* Does not use {{c|std::allocator_traits::construct}} to construct bit values.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/container/dsc value_type | vector_bool}}
{{dsc inc | cpp/container/dsc allocator_type | vector_bool}}
{{dsc inc | cpp/container/dsc size_type | vector_bool}}
{{dsc inc | cpp/container/dsc difference_type | vector_bool}}
{{dsc class | cpp/container/vector_bool/reference | proxy class representing a reference to a single bool}}
{{dsc inc | cpp/container/dsc const_reference | vector_bool}}
{{dsc inc | cpp/container/dsc pointer | vector_bool}}
{{dsc inc | cpp/container/dsc const_pointer | vector_bool}}
{{dsc inc | cpp/container/dsc iterator | vector_bool}}
{{dsc inc | cpp/container/dsc const_iterator | vector_bool}}
{{dsc inc | cpp/container/dsc reverse_iterator | vector_bool}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | vector_bool}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | vector}}
{{dsc inc | cpp/container/dsc destructor | vector}}
{{dsc inc | cpp/container/dsc operator{{=}} | vector}}
{{dsc inc | cpp/container/dsc assign | vector}}
{{dsc inc | cpp/container/dsc get_allocator | vector}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/container/dsc at | vector}}
{{dsc inc | cpp/container/dsc operator_at | vector}}
{{dsc inc | cpp/container/dsc front | vector}}
{{dsc inc | cpp/container/dsc back | vector}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/container/dsc begin | vector}}
{{dsc inc | cpp/container/dsc end | vector}}
{{dsc inc | cpp/container/dsc rbegin | vector}}
{{dsc inc | cpp/container/dsc rend | vector}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/container/dsc empty | vector}}
{{dsc inc | cpp/container/dsc size | vector}}
{{dsc inc | cpp/container/dsc max_size | vector}}
{{dsc inc | cpp/container/dsc reserve | vector}}
{{dsc inc | cpp/container/dsc capacity | vector}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/container/dsc clear | vector}}
{{dsc inc | cpp/container/dsc insert | vector}}
{{dsc inc | cpp/container/vector_bool/dsc emplace}}
{{dsc inc | cpp/container/dsc erase | vector}}
{{dsc inc | cpp/container/dsc push_back | vector}}
{{dsc inc | cpp/container/vector_bool/dsc emplace_back}}
{{dsc inc | cpp/container/dsc pop_back | vector}}
{{dsc inc | cpp/container/dsc resize | vector}}
{{dsc inc | cpp/container/dsc swap | vector}}

{{dsc h2 | {{tt|vector&lt;bool&gt;}} specific modifiers}}
{{dsc inc | cpp/container/vector_bool/dsc flip}}
{{dsc inc | cpp/container/vector_bool/dsc swap}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_cmp | vector}}
{{dsc inc | cpp/container/dsc swap2 | vector}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/container/vector_bool/dsc hash}}
{{dsc end}}

===Notes===
If the size of the bitset is known at compile time, {{lc|std::bitset}} may be used, which offers a richer set of member functions. In addition, [http://www.boost.org/doc/libs/release/libs/dynamic_bitset/dynamic_bitset.html boost::dynamic_bitset] exists as an alternative to {{tt|std::vector&lt;bool&gt;}}.

Since its representation may by optimized, {{c|std::vector&lt;bool&gt;}} does not necessarily meet all {{concept|Container}} or {{concept|SequenceContainer}} requirements. For example, because {{c|std::vector&lt;bool&gt;::iterator}} is implementation-defined, it may not satisfy the {{concept|ForwardIterator}} requirement.  Use of algorithms such as {{lc|std::search}} that require {{concept|ForwardIterator}}s may result in [http://www.boost.org/doc/libs/1_52_0/libs/dynamic_bitset/dynamic_bitset.html#rationale either compile-time or run-time errors].


[[de:cpp/container/vector bool]]
[[es:cpp/container/vector bool]]
[[fr:cpp/container/vector bool]]
[[it:cpp/container/vector bool]]
[[ja:cpp/container/vector bool]]
[[pt:cpp/container/vector bool]]
[[ru:cpp/container/vector bool]]
[[zh:cpp/container/vector bool]]</text>
      <sha1>76jfogfdpb1oey1udia5unpmzw5f1ns</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool/flip</title>
    <ns>0</ns>
    <id>5567</id>
    <revision>
      <id>57332</id>
      <parentid>49460</parentid>
      <timestamp>2013-06-01T05:51:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="689">{{cpp/container/vector_bool/title | flip}}
{{cpp/container/vector_bool/navbar}}
{{ddcl | header=vector |
void flip();
}}

Toggles each {{c|bool}} in the vector (replaces with its opposite value).

===Parameters===
(none)

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_at | vector}}
{{dsc inc | cpp/utility/bitset/dsc flip}}
{{dsc end}}

[[de:cpp/container/vector bool/flip]]
[[es:cpp/container/vector bool/flip]]
[[fr:cpp/container/vector bool/flip]]
[[it:cpp/container/vector bool/flip]]
[[ja:cpp/container/vector bool/flip]]
[[pt:cpp/container/vector bool/flip]]
[[ru:cpp/container/vector bool/flip]]
[[zh:cpp/container/vector bool/flip]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool/hash</title>
    <ns>0</ns>
    <id>9783</id>
    <revision>
      <id>63943</id>
      <parentid>62698</parentid>
      <timestamp>2013-08-01T15:42:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="491">{{cpp/title | hash &lt;small&gt;(std::vector&lt;bool&gt;)&lt;/small&gt;}}
{{cpp/container/vector_bool/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt;&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for {{c|std::vector&lt;bool&gt;}} allows users to obtain hashes of objects of type {{c|std::vector&lt;bool&gt;}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool/reference</title>
    <ns>0</ns>
    <id>5566</id>
    <revision>
      <id>71843</id>
      <parentid>68709</parentid>
      <timestamp>2014-06-27T11:47:32Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>It seems that std::vector&lt;bool&gt;::reference does never have operator~</comment>
      <text xml:space="preserve" bytes="2726">{{cpp/title | {{small|vector&lt;bool&gt;::}}reference}}
{{cpp/container/vector_bool/navbar}}
{{ddcl | 1=
class reference;
}}

The {{c|std::vector&lt;bool&gt;}} specialization defines {{c|std::vector&lt;bool&gt;::reference}} as a publicly-accessible nested class.  {{c|std::vector&lt;bool&gt;::reference}} proxies the behavior of references to a single bit in {{c|std::vector&lt;bool&gt;}}. 

The primary use of {{c|std::vector&lt;bool&gt;::reference}} is to provide an l-value that can be returned from {{tt|operator[]}}.

Any reads or writes to a vector that happen via a {{c|std::vector&lt;bool&gt;::reference}} potentially read or write to the entire underlying vector.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | constructs the reference. Accessible only to {{c|std::vector&lt;bool&gt;}} itself}}
{{dsc mem dtor | nolink=true | destroys the reference}}
{{dsc mem fun | operator{{=}} | nolink=true | assigns a {{c|bool}} to the referenced bit}}
{{dsc inc | cpp/container/vector_bool/reference/dsc operator bool}}
{{dsc mem fun | flip | nolink=true | flips the referenced bit}}
{{dsc end}}

{{member | {{small|std::vector&lt;bool&gt;::}}~reference | 2=
{{ddcl | 1=
~reference()
}}

Destroys the reference.
}}

{{member | {{small|std::vector&lt;bool&gt;::reference::}}operator{{=}} | 2=
{{ddcl | 1=
reference&amp; operator=( bool x );
reference&amp; operator=( const reference&amp; x );
}}

Assigns a value to the referenced bit.

===Parameters===
{{par begin}}
{{par | x | value to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::vector&lt;bool&gt;::reference::}}operator bool | 2=
{{ddcl | 1=        
operator bool() const;
}}

Returns the value of the referenced bit.

===Parameters===
(none)

===Return value===
The referenced bit.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::vector&lt;bool&gt;::reference::}}flip | 2=
{{ddcl | 1=        
void flip();
}}

Inverts the referenced bit.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_at | vector}}
{{dsc inc | cpp/container/vector bool/dsc swap}}
{{dsc end}}

[[de:cpp/container/vector bool/reference]]
[[es:cpp/container/vector bool/reference]]
[[fr:cpp/container/vector bool/reference]]
[[it:cpp/container/vector bool/reference]]
[[ja:cpp/container/vector bool/reference]]
[[pt:cpp/container/vector bool/reference]]
[[ru:cpp/container/vector bool/reference]]
[[zh:cpp/container/vector bool/reference]]</text>
      <sha1>6tfviosdgbv2xbbxuyg9pb64xycnqb5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool/swap</title>
    <ns>0</ns>
    <id>5569</id>
    <revision>
      <id>57337</id>
      <parentid>49463</parentid>
      <timestamp>2013-06-01T05:51:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="924">{{cpp/container/vector_bool/title | swap}}
{{cpp/container/vector_bool/navbar}}
{{ddcl | header=vector |
static void swap(reference x, reference y);
}}

Swaps the contents of {{tt|x}} and {{tt|y}}.

===Parameters===
{{par begin}}
{{par | x | {{c|std::vector&lt;bool&gt;::reference}} value to swap with {{tt|y}}}}
{{par | y | {{c|std::vector&lt;bool&gt;::reference}} value to swap with {{tt|x}}}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc class | cpp/container/vector_bool/reference | proxy class representing a reference to a single bool}}
{{dsc inc | cpp/container/dsc swap2 | vector}}
{{dsc end}}

[[de:cpp/container/vector bool/swap]]
[[es:cpp/container/vector bool/swap]]
[[fr:cpp/container/vector bool/swap]]
[[it:cpp/container/vector bool/swap]]
[[ja:cpp/container/vector bool/swap]]
[[pt:cpp/container/vector bool/swap]]
[[ru:cpp/container/vector bool/swap]]
[[zh:cpp/container/vector bool/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/container/vector bool/vector bool</title>
    <ns>0</ns>
    <id>10119</id>
    <revision>
      <id>50829</id>
      <parentid>48203</parentid>
      <timestamp>2013-06-01T03:40:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="57">{{include page|cpp/container/constructor |vector | bool}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/dragon/call dragon</title>
    <ns>0</ns>
    <id>473</id>
    <revision>
      <id>42657</id>
      <parentid>945</parentid>
      <timestamp>2012-11-03T00:04:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="250">{{dummy}}

[[de:cpp/dragon/call dragon]]
[[es:cpp/dragon/call dragon]]
[[fr:cpp/dragon/call dragon]]
[[it:cpp/dragon/call dragon]]
[[ja:cpp/dragon/call dragon]]
[[pt:cpp/dragon/call dragon]]
[[ru:cpp/dragon/call dragon]]
[[zh:cpp/dragon/call dragon]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/dragon/receive fire</title>
    <ns>0</ns>
    <id>474</id>
    <revision>
      <id>42652</id>
      <parentid>947</parentid>
      <timestamp>2012-11-03T00:03:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="258">{{dummy}}

[[de:cpp/dragon/receive fire]]
[[es:cpp/dragon/receive fire]]
[[fr:cpp/dragon/receive fire]]
[[it:cpp/dragon/receive fire]]
[[ja:cpp/dragon/receive fire]]
[[pt:cpp/dragon/receive fire]]
[[ru:cpp/dragon/receive fire]]
[[zh:cpp/dragon/receive fire]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error</title>
    <ns>0</ns>
    <id>475</id>
    <revision>
      <id>71015</id>
      <parentid>70981</parentid>
      <timestamp>2014-06-04T18:57:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="3731">{{title|Error handling}}
{{cpp/error/navbar}}

===Exception handling===
The header {{tt|&lt;exception&gt;}} provides several classes and functions related to exception handling in C++ programs.

{{dsc begin}}
{{dsc header | exception}}
{{dsc inc | cpp/error/dsc exception}}
{{dsc h2 | Capture and storage of exception objects}}
{{dsc inc | cpp/error/dsc uncaught_exception}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc inc | cpp/error/dsc make_exception_ptr}}
{{dsc inc | cpp/error/dsc current_exception}}
{{dsc inc | cpp/error/dsc rethrow_exception}}
{{dsc inc | cpp/error/dsc nested_exception}}
{{dsc inc | cpp/error/dsc throw_with_nested}}
{{dsc inc | cpp/error/dsc rethrow_if_nested}}
{{dsc h2 | Handling of failures in exception handling}}
{{dsc inc | cpp/error/dsc terminate}}
{{dsc inc | cpp/error/dsc terminate_handler}}
{{dsc inc | cpp/error/dsc get_terminate}}
{{dsc inc | cpp/error/dsc set_terminate}}
{{dsc h2 | Handling of exception specification violations}}
{{dsc inc | cpp/error/dsc unexpected}}
{{dsc inc | cpp/error/dsc bad_exception}}
{{dsc inc | cpp/error/dsc unexpected_handler}}
{{dsc inc | cpp/error/dsc get_unexpected}}
{{dsc inc | cpp/error/dsc set_unexpected}}
{{dsc end}}

====Exception categories====

Several convenience classes are predefined in the header {{tt|&lt;stdexcept&gt;}} to report particular error conditions. These classes can be divided into two categories: ''logic'' errors and ''runtime'' errors. Logic errors are a consequence of faulty logic within the program and may be preventable. Runtime errors are due to events beyond the scope of the program and can not be easily predicted.

{{dsc begin}}
{{dsc header | stdexcept}}
{{dsc class | cpp/error/logic_error | exception class to indicate violations of logical preconditions or class invariants}}
{{dsc class | cpp/error/invalid_argument | exception class to report invalid arguments}}
{{dsc class | cpp/error/domain_error | exception class to report domain errors}}
{{dsc class | cpp/error/length_error | exception class to report attempts to exceed maximum allowed size}}
{{dsc class | cpp/error/out_of_range | exception class to report arguments outside of expected range}}
{{dsc class | cpp/error/runtime_error | exception class to indicate conditions only detectable at run time}}
{{dsc class | cpp/error/range_error | exception class to report range errors in internal computations}}
{{dsc class | cpp/error/overflow_error | exception class to report arithmetic overflows}}
{{dsc class | cpp/error/underflow_error | exception class to report arithmetic underflows}}
{{dsc end}}

===Error numbers===

{{dsc begin}}
{{dsc header | cerrno}}
{{dsc inc | cpp/error/dsc errno}}
{{dsc inc | cpp/error/dsc errno_macros}}
{{dsc end}}

===Assertions===

Assertions help to implement checking of preconditions in programs.

{{dsc begin}}
{{dsc inc | cpp/language/dsc static_assert}}
{{dsc break}}
{{dsc header | cassert}}
{{dsc inc | cpp/error/dsc assert}}
{{dsc end}}

===System error===

The header {{tt|&lt;system_error&gt;}} defines types and functions used to report error conditions originating from the operating system, streams I/O, {{lc|std::future}}, or other low-level APIs.

{{dsc begin}}
{{dsc header | system_error}}
{{dsc inc | cpp/error/dsc error_category}}
{{dsc inc | cpp/error/dsc generic_category}}
{{dsc inc | cpp/error/dsc system_category}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/error/dsc errc}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc system_error}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/error | Error handling}}
{{dsc end}}

[[de:cpp/error]]
[[es:cpp/error]]
[[fr:cpp/error]]
[[it:cpp/error]]
[[ja:cpp/error]]
[[pt:cpp/error]]
[[ru:cpp/error]]
[[zh:cpp/error]]</text>
      <sha1>9yije4dklqr19jcvyoe4sznf9filp3o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/assert</title>
    <ns>0</ns>
    <id>3565</id>
    <revision>
      <id>69380</id>
      <parentid>57341</parentid>
      <timestamp>2014-04-04T12:53:25Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1813">{{title|assert}}
{{cpp/error/navbar}}
{{ddcl | header=cassert | 
#ifdef NDEBUG
#define assert(condition) ((void)0)
#else
#define assert(condition) /*implementation defined*/
#endif
}}

The definition of the macro {{tt|assert}} depends on another macro, {{c|NDEBUG}}, which is not defined by the standard library.

If {{c|NDEBUG}} is defined as a macro name at the point in the source code where {{tt|&lt;cassert&gt;}} is included, then {{tt|assert}} does nothing.

If {{c|NDEBUG}} is not defined, then {{tt|assert}} checks if its argument (which must have scalar type) compares equal to zero. If it does, {{tt|assert}} outputs implementation-specific diagnostic information on the standard error output and calls {{lc|std::abort}}. The diagnostic information is required to include the text of {{tt|expression}}, as well as the values of the standard macros {{c|__FILE__}},  {{c|__LINE__}}, and the standard variable {{c|__func__}}.

===Parameters===
{{par begin}}
{{par | condition | expression of scalar type}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
// uncomment to disable assert()
// #define NDEBUG
#include &lt;cassert&gt;

int main()
{
    assert(2+2==4);
    std::cout &lt;&lt; &quot;Execution continues past the first assert\n&quot;;
    assert(2+2==5);
    std::cout &lt;&lt; &quot;Execution continues past the second assert\n&quot;;
}
 | p=true
 | output=
Execution continues past the first assert
test: test.cc:10: int main(): Assertion `2+2==5' failed.
Aborted
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/language/dsc static_assert}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc end}}

[[de:cpp/error/assert]]
[[es:cpp/error/assert]]
[[fr:cpp/error/assert]]
[[it:cpp/error/assert]]
[[ja:cpp/error/assert]]
[[pt:cpp/error/assert]]
[[ru:cpp/error/assert]]
[[zh:cpp/error/assert]]</text>
      <sha1>k7zq2j72vs0l99mthu43ykmjqqynkct</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/bad exception</title>
    <ns>0</ns>
    <id>5561</id>
    <revision>
      <id>61389</id>
      <parentid>49466</parentid>
      <timestamp>2013-06-05T22:42:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use correct navbar</comment>
      <text xml:space="preserve" bytes="1867">{{cpp/title|bad_exception}}
{{cpp/error/bad_exception/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl |1=
class bad_exception;
}}
{{dcl end}}

{{tt|std::bad_exception}} is the type of the exception thrown by the C++ runtime in the following situations:

@1@ If a [[cpp/language/except_spec|dynamic exception specification]] is violated and {{lc|std::unexpected}} throws or rethrows an exception that still violates the exception specification, but the exception specification allows {{tt|std::bad_exception}},  {{tt|std::bad_exception}} is thrown.

@2@ If {{lc|std::exception_ptr}} stores a copy of the caught exception and if the copy constructor of the exception object caught by {{c|current_exception}} throws an exception, the captured exception is an instance of {{tt|std::bad_exception}}.

{{inheritance diagram/std-bad_exception}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/error/bad_exception/bad_exception | constructs the {{tt|bad_exception}} object}}
{{dsc mem fun | cpp/error/bad_exception/operator{{=}} | copies the object}}
{{dsc mem vfun | cpp/error/bad_exception/what | returns the explanatory string}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;exception&gt;
#include &lt;stdexcept&gt;

void my_unexp() { throw; }

void test() throw(std::bad_exception)
{
    throw std::runtime_error(&quot;test&quot;);
}

int main()
{
    std::set_unexpected(my_unexp);
    try {
         test();
    } catch(const std::bad_exception&amp; e)
    {
        std::cerr &lt;&lt; &quot;Caught &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Caught std::bad_exception
}}

[[de:cpp/error/bad exception]]
[[es:cpp/error/bad exception]]
[[fr:cpp/error/bad exception]]
[[it:cpp/error/bad exception]]
[[ja:cpp/error/bad exception]]
[[pt:cpp/error/bad exception]]
[[ru:cpp/error/bad exception]]
[[zh:cpp/error/bad exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/bad exception/bad exception</title>
    <ns>0</ns>
    <id>12645</id>
    <revision>
      <id>61390</id>
      <timestamp>2013-06-05T22:44:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="512">{{cpp/error/bad_exception/title|bad_exception}}
{{cpp/error/bad_exception/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
bad_exception();
}}
{{dcl | since=c++11 |
bad_exception( const bad_exception&amp; other );
}}
{{dcl end}}

Constructs new {{tt|bad_exception}} object.

@1@ Default constructor.

@2@ Copy constructor. Initializes the object with the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | {{tt|bad_exception}} object to initialize with}}
{{par end}}

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/bad exception/operator=</title>
    <ns>0</ns>
    <id>12646</id>
    <revision>
      <id>61391</id>
      <timestamp>2013-06-05T22:46:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="403">{{cpp/error/bad_exception/title|operator{{=}}}}
{{cpp/error/bad_exception/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
bad_exception&amp; operator=( const bad_exception&amp; other );
}}
{{dcl end}}

Assigns the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another {{tt|bad_exception}} object to assign}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/bad exception/what</title>
    <ns>0</ns>
    <id>8989</id>
    <revision>
      <id>63292</id>
      <parentid>42619</parentid>
      <timestamp>2013-07-10T01:27:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="598">{{cpp/error/bad_exception/title|what}}
{{cpp/error/bad_exception/navbar}}
{{ddcl | since=c++11 |
virtual const char* what() const;
}}

Returns the explanatory string.

===Parameters===
(none)

===Return value===
Pointer to a null-terminated string with explanatory information. 

===Exceptions===
{{noexcept}}

[[de:cpp/error/bad exception/what]]
[[es:cpp/error/bad exception/what]]
[[fr:cpp/error/bad exception/what]]
[[it:cpp/error/bad exception/what]]
[[ja:cpp/error/bad exception/what]]
[[pt:cpp/error/bad exception/what]]
[[ru:cpp/error/bad exception/what]]
[[zh:cpp/error/bad exception/what]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/current exception</title>
    <ns>0</ns>
    <id>5611</id>
    <revision>
      <id>63293</id>
      <parentid>62299</parentid>
      <timestamp>2013-07-10T01:27:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1876">{{cpp/title|current_exception}}
{{cpp/error/navbar}}
{{ddcl | header=exception | since=c++11 |
std::exception_ptr current_exception()
}}

If called during exception handling (typically, in a {{c|catch}} clause), captures the current exception object and creates an {{lc|std::exception_ptr}} that holds either a copy or a reference to that exception object (it is implementation-defined if a copy is made).

If the implementation of this function requires a call to {{c|new}} and the call fails, the returned pointer will hold a reference to an instance of {{lc|std::bad_alloc}}

If the implementation of this function requires to copy the captured exception object and its copy constructor throws an exception, the returned pointer will hold a reference to the exception thrown. If the copy constructor of the thrown exception object also throws, the returned pointer may hold a reference to an instance of {{lc|std::bad_exception}} to break the endless loop.

If the function is called when no exception is being handled, an empty {{lc|std::exception_ptr}} is returned.

===Parameters===
(none)

===Return value===
An instance of {{lc|std::exception_ptr}} holding a reference to the exception object, or a copy of the exception object, or to an instance of {{lc|std::bad_alloc}} or to an instance of {{lc|std::bad_exception}}.

===Exceptions===
{{noexcept}}

===Example===
{{include| cpp/error/example_exception_ptr}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc inc | cpp/error/dsc rethrow_exception}}
{{dsc inc | cpp/error/dsc make_exception_ptr}}
{{dsc end}}

[[de:cpp/error/current exception]]
[[es:cpp/error/current exception]]
[[fr:cpp/error/current exception]]
[[it:cpp/error/current exception]]
[[ja:cpp/error/current exception]]
[[pt:cpp/error/current exception]]
[[ru:cpp/error/current exception]]
[[zh:cpp/error/current exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/domain error</title>
    <ns>0</ns>
    <id>2086</id>
    <revision>
      <id>70816</id>
      <parentid>70815</parentid>
      <timestamp>2014-05-30T18:37:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>aha, boost.math uses it</comment>
      <text xml:space="preserve" bytes="1231">{{cpp/title | domain_error}}
{{cpp/error/domain_error/navbar}}
{{ddcl | header=stdexcept |
class domain_error;
}}

Defines a type of object to be thrown as exception. It may be used by the implementation to report domain errors, that is, situations where the inputs are outside of the domain on which an operation is defined.

The standard library components do not throw this exception (mathematical functions report domain errors as specified in {{lc|math_errhandling}}). Third-party libraries, however, use this. For example, [http://www.boost.org/doc/libs/1_55_0/libs/math/doc/html/math_toolkit/error_handling.html boost.math] throws {{tt|std::domain_error}} if {{tt|boost::math::policies::throw_on_error}} is enabled (the default setting).

{{inheritance diagram/std-domain_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|domain_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|domain_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/domain error]]
[[es:cpp/error/domain error]]
[[fr:cpp/error/domain error]]
[[it:cpp/error/domain error]]
[[ja:cpp/error/domain error]]
[[pt:cpp/error/domain error]]
[[ru:cpp/error/domain error]]
[[zh:cpp/error/domain error]]</text>
      <sha1>r265e9n0yyoeu7dekgaukhhzcnyrzv0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/domain error/domain error</title>
    <ns>0</ns>
    <id>4495</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>47831</id>
      <parentid>42592</parentid>
      <timestamp>2013-05-16T22:27:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/domain_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errc</title>
    <ns>0</ns>
    <id>5565</id>
    <revision>
      <id>62699</id>
      <parentid>61368</parentid>
      <timestamp>2013-07-01T23:33:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="8587">{{cpp/title|errc}}
{{cpp/error/errc/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 | 1=
enum class errc;
}}
{{dcl end}}

The scoped enumeration {{tt|std::errc}} defines the values of portable error conditions that correspond to the POSIX error codes. 

===Member constants===
{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|address_family_not_supported}} | error condition corresponding to POSIX code EAFNOSUPPORT}}
{{dsc | {{tt|address_in_use}} | error condition corresponding to POSIX code EADDRINUSE}}
{{dsc | {{tt|address_not_available}} | error condition corresponding to POSIX code EADDRNOTAVAIL}}
{{dsc | {{tt|already_connected}} | error condition corresponding to POSIX code EISCONN}}
{{dsc | {{tt|argument_list_too_long}} | error condition corresponding to POSIX code E2BIG}}
{{dsc | {{tt|argument_out_of_domain}} | error condition corresponding to POSIX code EDOM}}
{{dsc | {{tt|bad_address}} | error condition corresponding to POSIX code EFAULT}}
{{dsc | {{tt|bad_file_descriptor}} | error condition corresponding to POSIX code EBADF}}
{{dsc | {{tt|bad_message}} | error condition corresponding to POSIX code EBADMSG}}
{{dsc | {{tt|broken_pipe}} | error condition corresponding to POSIX code EPIPE}}
{{dsc | {{tt|connection_aborted}} | error condition corresponding to POSIX code ECONNABORTED}}
{{dsc | {{tt|connection_already_in_progress}} | error condition corresponding to POSIX code EALREADY}}
{{dsc | {{tt|connection_refused}} | error condition corresponding to POSIX code ECONNREFUSED}}
{{dsc | {{tt|connection_reset}} | error condition corresponding to POSIX code ECONNRESET}}
{{dsc | {{tt|cross_device_link}} | error condition corresponding to POSIX code EXDEV}}
{{dsc | {{tt|destination_address_required}} | error condition corresponding to POSIX code EDESTADDRREQ}}
{{dsc | {{tt|device_or_resource_busy}} | error condition corresponding to POSIX code EBUSY}}
{{dsc | {{tt|directory_not_empty}} | error condition corresponding to POSIX code ENOTEMPTY}}
{{dsc | {{tt|executable_format_error}} | error condition corresponding to POSIX code ENOEXEC}}
{{dsc | {{tt|file_exists}} | error condition corresponding to POSIX code EEXIST}}
{{dsc | {{tt|file_too_large}} | error condition corresponding to POSIX code EFBIG}}
{{dsc | {{tt|filename_too_long}} | error condition corresponding to POSIX code ENAMETOOLONG}}
{{dsc | {{tt|function_not_supported}} | error condition corresponding to POSIX code ENOSYS}}
{{dsc | {{tt|host_unreachable}} | error condition corresponding to POSIX code EHOSTUNREACH}}
{{dsc | {{tt|identifier_removed}} | error condition corresponding to POSIX code EIDRM}}
{{dsc | {{tt|illegal_byte_sequence}} | error condition corresponding to POSIX code EILSEQ}}
{{dsc | {{tt|inappropriate_io_control_operation}} | error condition corresponding to POSIX code ENOTTY}}
{{dsc | {{tt|interrupted}} | error condition corresponding to POSIX code EINTR}}
{{dsc | {{tt|invalid_argument}} | error condition corresponding to POSIX code EINVAL}}
{{dsc | {{tt|invalid_seek}} | error condition corresponding to POSIX code ESPIPE}}
{{dsc | {{tt|io_error}} | error condition corresponding to POSIX code EIO}}
{{dsc | {{tt|is_a_directory}} | error condition corresponding to POSIX code EISDIR}}
{{dsc | {{tt|message_size}} | error condition corresponding to POSIX code EMSGSIZE}}
{{dsc | {{tt|network_down}} | error condition corresponding to POSIX code ENETDOWN}}
{{dsc | {{tt|network_reset}} | error condition corresponding to POSIX code ENETRESET}}
{{dsc | {{tt|network_unreachable}} | error condition corresponding to POSIX code ENETUNREACH}}
{{dsc | {{tt|no_buffer_space}} | error condition corresponding to POSIX code ENOBUFS}}
{{dsc | {{tt|no_child_process}} | error condition corresponding to POSIX code ECHILD}}
{{dsc | {{tt|no_link}} | error condition corresponding to POSIX code ENOLINK}}
{{dsc | {{tt|no_lock_available}} | error condition corresponding to POSIX code ENOLCK}}
{{dsc | {{tt|no_message_available}} | error condition corresponding to POSIX code ENODATA}}
{{dsc | {{tt|no_message}} | error condition corresponding to POSIX code ENOMSG}}
{{dsc | {{tt|no_protocol_option}} | error condition corresponding to POSIX code ENOPROTOOPT}}
{{dsc | {{tt|no_space_on_device}} | error condition corresponding to POSIX code ENOSPC}}
{{dsc | {{tt|no_stream_resources}} | error condition corresponding to POSIX code ENOSR}}
{{dsc | {{tt|no_such_device_or_address}} | error condition corresponding to POSIX code ENXIO}}
{{dsc | {{tt|no_such_device}} | error condition corresponding to POSIX code ENODEV}}
{{dsc | {{tt|no_such_file_or_directory}} | error condition corresponding to POSIX code ENOENT}}
{{dsc | {{tt|no_such_process}} | error condition corresponding to POSIX code ESRCH}}
{{dsc | {{tt|not_a_directory}} | error condition corresponding to POSIX code ENOTDIR}}
{{dsc | {{tt|not_a_socket}} | error condition corresponding to POSIX code ENOTSOCK}}
{{dsc | {{tt|not_a_stream}} | error condition corresponding to POSIX code ENOSTR}}
{{dsc | {{tt|not_connected}} | error condition corresponding to POSIX code ENOTCONN}}
{{dsc | {{tt|not_enough_memory}} | error condition corresponding to POSIX code ENOMEM}}
{{dsc | {{tt|not_supported}} | error condition corresponding to POSIX code ENOTSUP}}
{{dsc | {{tt|operation_canceled}} | error condition corresponding to POSIX code ECANCELED}}
{{dsc | {{tt|operation_in_progress}} | error condition corresponding to POSIX code EINPROGRESS}}
{{dsc | {{tt|operation_not_permitted}} | error condition corresponding to POSIX code EPERM}}
{{dsc | {{tt|operation_not_supported}} | error condition corresponding to POSIX code EOPNOTSUPP}}
{{dsc | {{tt|operation_would_block}} | error condition corresponding to POSIX code EWOULDBLOCK}}
{{dsc | {{tt|owner_dead}} | error condition corresponding to POSIX code EOWNERDEAD}}
{{dsc | {{tt|permission_denied}} | error condition corresponding to POSIX code EACCES}}
{{dsc | {{tt|protocol_error}} | error condition corresponding to POSIX code EPROTO}}
{{dsc | {{tt|protocol_not_supported}} | error condition corresponding to POSIX code EPROTONOSUPPORT}}
{{dsc | {{tt|read_only_file_system}} | error condition corresponding to POSIX code EROFS}}
{{dsc | {{tt|resource_deadlock_would_occur}} | error condition corresponding to POSIX code EDEADLK}}
{{dsc | {{tt|resource_unavailable_try_again}} | error condition corresponding to POSIX code EAGAIN}}
{{dsc | {{tt|result_out_of_range}} | error condition corresponding to POSIX code ERANGE}}
{{dsc | {{tt|state_not_recoverable}} | error condition corresponding to POSIX code ENOTRECOVERABLE}}
{{dsc | {{tt|stream_timeout}} | error condition corresponding to POSIX code ETIME}}
{{dsc | {{tt|text_file_busy}} | error condition corresponding to POSIX code ETXTBSY}}
{{dsc | {{tt|timed_out}} | error condition corresponding to POSIX code ETIMEDOUT}}
{{dsc | {{tt|too_many_files_open_in_system}} | error condition corresponding to POSIX code ENFILE}}
{{dsc | {{tt|too_many_files_open}} | error condition corresponding to POSIX code EMFILE}}
{{dsc | {{tt|too_many_links}} | error condition corresponding to POSIX code EMLINK}}
{{dsc | {{tt|too_many_symbolic_link_levels}} | error condition corresponding to POSIX code ELOOP}}
{{dsc | {{tt|value_too_large}} | error condition corresponding to POSIX code EOVERFLOW}}
{{dsc | {{tt|wrong_protocol_type}} | error condition corresponding to POSIX code EPROTOTYPE}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/error/errc/dsc make_error_code}}
{{dsc inc | cpp/error/errc/dsc make_error_condition}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/error/errc/dsc is_error_condition_enum}}
{{dsc end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;
#include &lt;thread&gt;
int main()
{
    try {
        std::thread().detach(); // detaching a not-a-thread
    } catch (const std::system_error&amp; e) {
        std::cout &lt;&lt; &quot;Caught a system_error\n&quot;;
        if(e.code() == std::errc::invalid_argument)
            std::cout &lt;&lt; &quot;The error condition is std::errc::invalid_argument\n&quot;;
        std::cout &lt;&lt; &quot;the error description is &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
| output=
Caught a system_error
The error condition is std::errc::invalid_argument
the error description is Invalid argument
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc end}}

[[de:cpp/error/errc]]
[[es:cpp/error/errc]]
[[fr:cpp/error/errc]]
[[it:cpp/error/errc]]
[[ja:cpp/error/errc]]
[[pt:cpp/error/errc]]
[[ru:cpp/error/errc]]
[[zh:cpp/error/errc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errc/is error condition enum</title>
    <ns>0</ns>
    <id>12627</id>
    <revision>
      <id>61364</id>
      <parentid>61349</parentid>
      <timestamp>2013-06-05T22:23:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+navbar</comment>
      <text xml:space="preserve" bytes="562">{{cpp/title|is_error_condition_enum{{dsc small|&lt;std::errc&gt;}}}}
{{cpp/error/errc/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 | 
template&lt;&gt;
struct is_error_condition_enum&lt;std::errc&gt; : std::true_type;
}}
{{dcl end}}

Specifies that {{lc|std::errc}} is an error condition enum. This enables {{lc|std::error_code}} and {{lc|std::error_condition}} automatic conversions.

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error condition/dsc is_error_condition_enum}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errc/make error code</title>
    <ns>0</ns>
    <id>9023</id>
    <revision>
      <id>72285</id>
      <parentid>63294</parentid>
      <timestamp>2014-08-04T14:59:21Z</timestamp>
      <contributor>
        <username>Ecatmur</username>
        <id>1355</id>
      </contributor>
      <minor/>
      <comment>add std to enable linking</comment>
      <text xml:space="preserve" bytes="500">{{cpp/title|make_error_code{{dsc small|(std::errc)}}}}
{{cpp/error/errc/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
std::error_code make_error_code( std::errc e );
}}

Creates error code value for errc enum {{tt|e}}.

Equivalent to {{c|std::error_code(static_cast&lt;int&gt;(e), std::generic_category())}}

===Parameters===
{{par begin}}
{{par | e | error code enum to create error code for}}
{{par end}}

===Return value===
Error code corresponding to {{tt|e}}.

===Exceptions===
{{noexcept}}</text>
      <sha1>07mmyr0e52jvi94bcowem1bv67qvy1x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errc/make error condition</title>
    <ns>0</ns>
    <id>9637</id>
    <revision>
      <id>62700</id>
      <parentid>61361</parentid>
      <timestamp>2013-07-01T23:33:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="534">{{cpp/title|make_error_condition{{dsc small|(std::errc)}}}}
{{cpp/error/errc/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 |
std::error_condition make_error_condition( std::errc e );
}}
{{dcl end}}

Creates an error condition for an {{tt|errc}} value {{tt|e}}. Sets the error code to {{c|int(e)}} and error category to {{lc|std::generic_category}}.

===Parameters===
{{par begin}}
{{par | e | standard error code}}
{{par end}}

===Return value===
Error condition for {{tt|e}}.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errno</title>
    <ns>0</ns>
    <id>5564</id>
    <revision>
      <id>69291</id>
      <parentid>69289</parentid>
      <timestamp>2014-04-02T15:41:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 69289 by [[Special:Contributions/84.52.101.196|84.52.101.196]] ([[User talk:84.52.101.196|talk]]) the C++11 requirement is already mentioned two lines above</comment>
      <text xml:space="preserve" bytes="1334">{{title|errno}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | cerrno}}
{{dcl |
#define errno /*implementation-defined*/
}}
{{dcl end}}

{{tt|errno}} is a preprocessor macro used for error indication.

{{rev begin}}
{{rev | until=c++11 | It expands to a static modifiable lvalue of type {{c|int}}.}}
{{rev | since=c++11 | It expands to a thread-local modifiable lvalue of type {{c|int}}.}}
{{rev end}}

Several standard library functions indicate errors by writing positive integers to {{tt|errno}}. Typically, the value of {{tt|errno}} is set to one of the error codes, listed in {{tt|&lt;cerrno&gt;}} as macro constants that begin with the letter {{tt|E}}, followed by uppercase letters or digits.

The value of {{tt|errno}} is {{c|0}} at program startup, and although library functions are allowed to write positive integers to {{tt|errno}} whether or not an error occurred, library functions never store {{c|0}} in {{tt|errno}}.

===Example===
{{example template|cpp/error/example_errno}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc errno_macros}}
{{dsc inc | cpp/io/c/dsc perror}}
{{dsc inc | cpp/string/byte/dsc strerror}}
{{dsc end}}

[[de:cpp/error/errno]]
[[es:cpp/error/errno]]
[[fr:cpp/error/errno]]
[[it:cpp/error/errno]]
[[ja:cpp/error/errno]]
[[pt:cpp/error/errno]]
[[ru:cpp/error/errno]]
[[zh:cpp/error/errno]]</text>
      <sha1>h0neteu1394csxck9f22h7rlcsgv5pg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/errno macros</title>
    <ns>0</ns>
    <id>3444</id>
    <revision>
      <id>71618</id>
      <parentid>57352</parentid>
      <timestamp>2014-06-17T03:03:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso c</comment>
      <text xml:space="preserve" bytes="8882">{{title|Error numbers}}
{{cpp/error/navbar}}

Each of the macros defined in {{tt|&lt;cerrno&gt;}} expands to integer constant expressions with type {{c|int}}, each with a positive value, matching most of the [http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html POSIX error codes]. The following constants are defined (the implementation may define more, as long as they begin with {{c|'E'}} followed by digits or uppercase letters)

{{dsc begin}}
{{dsc header | cerrno}}
{{dsc macro const | E2BIG            | nolink=true| notes={{mark c++11}}| Argument list too long }}
{{dsc macro const | EACCES           | nolink=true| notes={{mark c++11}}| Permission denied}}
{{dsc macro const | EADDRINUSE       | nolink=true| notes={{mark c++11}}| Address in use}}
{{dsc macro const | EADDRNOTAVAIL    | nolink=true| notes={{mark c++11}}| Address not available}}
{{dsc macro const | EAFNOSUPPORT     | nolink=true| notes={{mark c++11}}| Address family not supported}}
{{dsc macro const | EAGAIN           | nolink=true| notes={{mark c++11}}| Resource unavailable, try again}}
{{dsc macro const | EALREADY         | nolink=true| notes={{mark c++11}}| Connection already in progress}}
{{dsc macro const | EBADF            | nolink=true| notes={{mark c++11}}| Bad file descriptor}}
{{dsc macro const | EBADMSG          | nolink=true| notes={{mark c++11}}| Bad message}}
{{dsc macro const | EBUSY            | nolink=true| notes={{mark c++11}}| Device or resource busy}}
{{dsc macro const | ECANCELED        | nolink=true| notes={{mark c++11}}| Operation canceled}}
{{dsc macro const | ECHILD           | nolink=true| notes={{mark c++11}}| No child processes}}
{{dsc macro const | ECONNABORTED     | nolink=true| notes={{mark c++11}}| Connection aborted}}
{{dsc macro const | ECONNREFUSED     | nolink=true| notes={{mark c++11}}| Connection refused}}
{{dsc macro const | ECONNRESET       | nolink=true| notes={{mark c++11}}| Connection reset}}
{{dsc macro const | EDEADLK          | nolink=true| notes={{mark c++11}}| Resource deadlock would occur}}
{{dsc macro const | EDESTADDRREQ     | nolink=true| notes={{mark c++11}}| Destination address required}}
{{dsc macro const | EDOM             | nolink=true                      | Mathematics argument out of domain of function}}
{{dsc macro const | EEXIST           | nolink=true| notes={{mark c++11}}| File exists}}
{{dsc macro const | EFAULT           | nolink=true| notes={{mark c++11}}| Bad address}}
{{dsc macro const | EFBIG            | nolink=true| notes={{mark c++11}}| File too large}}
{{dsc macro const | EHOSTUNREACH     | nolink=true| notes={{mark c++11}}| Host is unreachable}}
{{dsc macro const | EIDRM            | nolink=true| notes={{mark c++11}}| Identifier removed}}
{{dsc macro const | EILSEQ           | nolink=true| notes={{mark c++11}}| Illegal byte sequence}}
{{dsc macro const | EINPROGRESS      | nolink=true| notes={{mark c++11}}| Operation in progress}}
{{dsc macro const | EINTR            | nolink=true| notes={{mark c++11}}| Interrupted function}}
{{dsc macro const | EINVAL           | nolink=true| notes={{mark c++11}}| Invalid argument}}
{{dsc macro const | EIO              | nolink=true| notes={{mark c++11}}| I/O error}}
{{dsc macro const | EISCONN          | nolink=true| notes={{mark c++11}}| Socket is connected}}
{{dsc macro const | EISDIR           | nolink=true| notes={{mark c++11}}| Is a directory}}
{{dsc macro const | ELOOP            | nolink=true| notes={{mark c++11}}| Too many levels of symbolic links}}
{{dsc macro const | EMFILE           | nolink=true| notes={{mark c++11}}| File descriptor value too large}}
{{dsc macro const | EMLINK           | nolink=true| notes={{mark c++11}}| Too many links}}
{{dsc macro const | EMSGSIZE         | nolink=true| notes={{mark c++11}}| Message too large}}
{{dsc macro const | ENAMETOOLONG     | nolink=true| notes={{mark c++11}}| Filename too long}}
{{dsc macro const | ENETDOWN         | nolink=true| notes={{mark c++11}}| Network is down}}
{{dsc macro const | ENETRESET        | nolink=true| notes={{mark c++11}}| Connection aborted by network}}
{{dsc macro const | ENETUNREACH      | nolink=true| notes={{mark c++11}}| Network unreachable}}
{{dsc macro const | ENFILE           | nolink=true| notes={{mark c++11}}| Too many files open in system}}
{{dsc macro const | ENOBUFS          | nolink=true| notes={{mark c++11}}| No buffer space available}}
{{dsc macro const | ENODATA          | nolink=true| notes={{mark c++11}}| No message is available on the STREAM head read queue}}
{{dsc macro const | ENODEV           | nolink=true| notes={{mark c++11}}| No such device}}
{{dsc macro const | ENOENT           | nolink=true| notes={{mark c++11}}| No such file or directory}}
{{dsc macro const | ENOEXEC          | nolink=true| notes={{mark c++11}}| Executable file format error}}
{{dsc macro const | ENOLCK           | nolink=true| notes={{mark c++11}}| No locks available}}
{{dsc macro const | ENOLINK          | nolink=true| notes={{mark c++11}}| Link has been severed}}
{{dsc macro const | ENOMEM           | nolink=true| notes={{mark c++11}}| Not enough space}}
{{dsc macro const | ENOMSG           | nolink=true| notes={{mark c++11}}| No message of the desired type}}
{{dsc macro const | ENOPROTOOPT      | nolink=true| notes={{mark c++11}}| Protocol not available}}
{{dsc macro const | ENOSPC           | nolink=true| notes={{mark c++11}}| No space left on device}}
{{dsc macro const | ENOSR            | nolink=true| notes={{mark c++11}}| No STREAM resources}}
{{dsc macro const | ENOSTR           | nolink=true| notes={{mark c++11}}| Not a STREAM}}
{{dsc macro const | ENOSYS           | nolink=true| notes={{mark c++11}}| Function not supported}}
{{dsc macro const | ENOTCONN         | nolink=true| notes={{mark c++11}}| The socket is not connected}}
{{dsc macro const | ENOTDIR          | nolink=true| notes={{mark c++11}}| Not a directory}}
{{dsc macro const | ENOTEMPTY        | nolink=true| notes={{mark c++11}}| Directory not empty}}
{{dsc macro const | ENOTRECOVERABLE  | nolink=true| notes={{mark c++11}}| State not recoverable}}
{{dsc macro const | ENOTSOCK         | nolink=true| notes={{mark c++11}}| Not a socket}}
{{dsc macro const | ENOTSUP          | nolink=true| notes={{mark c++11}}| Not supported}}
{{dsc macro const | ENOTTY           | nolink=true| notes={{mark c++11}}| Inappropriate I/O control operation}}
{{dsc macro const | ENXIO            | nolink=true| notes={{mark c++11}}| No such device or address}}
{{dsc macro const | EOPNOTSUPP       | nolink=true| notes={{mark c++11}}| Operation not supported on socket}}
{{dsc macro const | EOVERFLOW        | nolink=true| notes={{mark c++11}}| Value too large to be stored in data type}}
{{dsc macro const | EOWNERDEAD       | nolink=true| notes={{mark c++11}}| Previous owner died}}
{{dsc macro const | EPERM            | nolink=true| notes={{mark c++11}}| Operation not permitted}}
{{dsc macro const | EPIPE            | nolink=true| notes={{mark c++11}}| Broken pipe}}
{{dsc macro const | EPROTO           | nolink=true| notes={{mark c++11}}| Protocol error}}
{{dsc macro const | EPROTONOSUPPORT  | nolink=true| notes={{mark c++11}}| Protocol not supported}}
{{dsc macro const | EPROTOTYPE       | nolink=true| notes={{mark c++11}}| Protocol wrong type for socket}}
{{dsc macro const | ERANGE           | nolink=true|                       Result too large}}
{{dsc macro const | EROFS            | nolink=true| notes={{mark c++11}}| Read-only file system}}
{{dsc macro const | ESPIPE           | nolink=true| notes={{mark c++11}}| Invalid seek}}
{{dsc macro const | ESRCH            | nolink=true| notes={{mark c++11}}| No such process}}
{{dsc macro const | ETIME            | nolink=true| notes={{mark c++11}}| Stream ioctl() timeout}}
{{dsc macro const | ETIMEDOUT        | nolink=true| notes={{mark c++11}}| Connection timed out}}
{{dsc macro const | ETXTBSY          | nolink=true| notes={{mark c++11}}| Text file busy}}
{{dsc macro const | EWOULDBLOCK      | nolink=true| notes={{mark c++11}}| Operation would block}}
{{dsc macro const | EXDEV            | nolink=true| notes={{mark c++11}}| Cross-device link}}
{{dsc end}}

All values are required to be unique except that the values of {{tt|EOPNOTSUPP}} and {{tt|ENOTSUP}} may be identical and the values of {{tt|EAGAIN}} and {{tt|EWOULDBLOCK}} may be identical

===Example===
{{example template|cpp/error/example_errno}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc errc}}
{{dsc inc | cpp/error/dsc errno}}
{{dsc inc | cpp/io/c/dsc perror}}
{{dsc inc | cpp/string/byte/dsc strerror}}
{{dsc see c | c/error/errno_macros | Error numbers }}
{{dsc end}}

[[de:cpp/error/errno macros]]
[[es:cpp/error/errno macros]]
[[fr:cpp/error/errno macros]]
[[it:cpp/error/errno macros]]
[[ja:cpp/error/errno macros]]
[[pt:cpp/error/errno macros]]
[[ru:cpp/error/errno macros]]
[[zh:cpp/error/errno macros]]</text>
      <sha1>pd6qzmbr75rzdpm0nkbiyzwkl043wfh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category</title>
    <ns>0</ns>
    <id>4828</id>
    <revision>
      <id>63295</id>
      <parentid>57355</parentid>
      <timestamp>2013-07-10T01:27:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1654">{{cpp/title|error_category}}
{{cpp/error/error_category/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
class error_category;
}}

{{tt|std::error_category}} serves as the base class for specific error category types, such as {{lc|std::system_category}}, {{c|std::iostream_category}}, etc. Each specific category class defines the {{tt|error_code}} - {{tt|error_condition}} mapping and holds the explanatory strings for all error_conditions. The objects of error category classes are treated as singletons, passed by reference.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_category/dsc constructor}}
{{dsc inc | cpp/error/error_category/dsc destructor}}
{{dsc inc | cpp/error/error_category/dsc operator{{=}}}}
{{dsc inc | cpp/error/error_category/dsc name}}
{{dsc inc | cpp/error/error_category/dsc default_error_condition}}
{{dsc inc | cpp/error/error_category/dsc equivalent}}
{{dsc inc | cpp/error/error_category/dsc message}}
{{dsc inc | cpp/error/error_category/dsc operator_cmp}}
{{dsc end}}

===Specific error categories===
{{dsc begin}}
{{dsc inc | cpp/error/dsc generic_category}}
{{dsc inc | cpp/error/dsc system_category}}
{{dsc inc | cpp/io/dsc iostream_category}}
{{dsc inc | cpp/thread/future/dsc future_category}}
{{dsc begin}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc end}}

[[de:cpp/error/error category]]
[[es:cpp/error/error category]]
[[fr:cpp/error/error category]]
[[it:cpp/error/error category]]
[[ja:cpp/error/error category]]
[[pt:cpp/error/error category]]
[[ru:cpp/error/error category]]
[[zh:cpp/error/error category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/default error condition</title>
    <ns>0</ns>
    <id>8925</id>
    <revision>
      <id>63296</id>
      <parentid>49473</parentid>
      <timestamp>2013-07-10T01:27:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="960">{{cpp/error/error_category/title|default_error_condition}}
{{cpp/error/error_category/navbar}}
{{ddcl | since=c++11 | 1=
virtual std::error_condition default_error_condition( int code ) const;
}}

Returns the error condition for the given error code.

Equivalent to {{c|std::error_condition(code, *this)}}.

===Parameters===
{{par begin}}
{{par | code | error code for which to return error condition}}
{{par end}}

===Return value===
The error condition for the given error code.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error category/default error condition]]
[[es:cpp/error/error category/default error condition]]
[[fr:cpp/error/error category/default error condition]]
[[it:cpp/error/error category/default error condition]]
[[ja:cpp/error/error category/default error condition]]
[[pt:cpp/error/error category/default error condition]]
[[ru:cpp/error/error category/default error condition]]
[[zh:cpp/error/error category/default error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/equivalent</title>
    <ns>0</ns>
    <id>8922</id>
    <revision>
      <id>62701</id>
      <parentid>49474</parentid>
      <timestamp>2013-07-01T23:33:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1357">{{cpp/error/error_category/title|equivalent}}
{{cpp/error/error_category/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
virtual bool equivalent( int code, 
                         const std::error_condition&amp; condition ) const;
}}
{{dcl | since=c++11 | num=2 | 1=
virtual bool equivalent( const std::error_code&amp; code,
                         int condition ) const;
}}
{{dcl end}}

Checks whether error code is equivalent to an error condition for the error category represented by {{c|*this}}.

@1@ Equivalent to {{c|1=default_error_condition(code) == condition}}.
@2@ Equivalent to {{c|1=*this == code.category() &amp;&amp; code.value() == condition}}.

===Parameters===
{{par begin}}
{{par | code | specifies the error code to compare}}
{{par | condition | specifies the error condition to compare}}
{{par end}}

===Return value===
{{c|true}} if the error code is equivalent to the given error condition for the error category represented by {{c|*this}}, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error category/equivalent]]
[[es:cpp/error/error category/equivalent]]
[[fr:cpp/error/error category/equivalent]]
[[it:cpp/error/error category/equivalent]]
[[ja:cpp/error/error category/equivalent]]
[[pt:cpp/error/error category/equivalent]]
[[ru:cpp/error/error category/equivalent]]
[[zh:cpp/error/error category/equivalent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/error category</title>
    <ns>0</ns>
    <id>8918</id>
    <revision>
      <id>68197</id>
      <parentid>64409</parentid>
      <timestamp>2014-03-18T03:03:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>default ctor was c++14, not c++11 (lwg 2145)</comment>
      <text xml:space="preserve" bytes="743">{{cpp/error/error_category/title|error_category}}
{{cpp/error/error_category/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
error_category( const error_category&amp; other ) = delete;
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr error_category();
}}
{{dcl end}}

Constructs the error category object.

===Parameters===
(none)

===Exceptions===
@2@ {{noexcept}}

[[de:cpp/error/error category/error category]]
[[es:cpp/error/error category/error category]]
[[fr:cpp/error/error category/error category]]
[[it:cpp/error/error category/error category]]
[[ja:cpp/error/error category/error category]]
[[pt:cpp/error/error category/error category]]
[[ru:cpp/error/error category/error category]]
[[zh:cpp/error/error category/error category]]</text>
      <sha1>61g0wuoq7luj383dyzh75qyqljvretx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/message</title>
    <ns>0</ns>
    <id>8923</id>
    <revision>
      <id>69276</id>
      <parentid>63297</parentid>
      <timestamp>2014-04-02T14:01:04Z</timestamp>
      <contributor>
        <ip>182.170.95.127</ip>
      </contributor>
      <comment>This method is not noexcept</comment>
      <text xml:space="preserve" bytes="790">{{cpp/error/error_category/title|message}}
{{cpp/error/error_category/navbar}}
{{ddcl | since=c++11 | 1=
virtual std::string message( int condition ) const = 0;
}}

Returns a string describing the given error condition for the error category represented by {{c|*this}}.

===Parameters===
{{par begin}}
{{par | condition | specifies the error condition to describe}}
{{par end}}

===Return value===
A string describing the given error condition.

===Exceptions===
(none)

[[de:cpp/error/error category/message]]
[[es:cpp/error/error category/message]]
[[fr:cpp/error/error category/message]]
[[it:cpp/error/error category/message]]
[[ja:cpp/error/error category/message]]
[[pt:cpp/error/error category/message]]
[[ru:cpp/error/error category/message]]
[[zh:cpp/error/error category/message]]</text>
      <sha1>7ujasoka35cx8z42ekeuxqcaltcwn6z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/name</title>
    <ns>0</ns>
    <id>8921</id>
    <revision>
      <id>63298</id>
      <parentid>42524</parentid>
      <timestamp>2013-07-10T01:27:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="685">{{cpp/error/error_category/title|name}}
{{cpp/error/error_category/navbar}}
{{ddcl | since=c++11 | 1=
virtual const char* name() const = 0;
}}

Returns a pointer to a null-terminated byte string that specifies the name of the error category.

===Parameters===
(none)

===Return value===
Null-terminated byte string specifying the name of the error category.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error category/name]]
[[es:cpp/error/error category/name]]
[[fr:cpp/error/error category/name]]
[[it:cpp/error/error category/name]]
[[ja:cpp/error/error category/name]]
[[pt:cpp/error/error category/name]]
[[ru:cpp/error/error category/name]]
[[zh:cpp/error/error category/name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/operator cmp</title>
    <ns>0</ns>
    <id>8924</id>
    <revision>
      <id>62703</id>
      <parentid>62022</parentid>
      <timestamp>2013-07-01T23:33:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1591">{{cpp/error/error_category/title|1=operator==,!=,&lt;}}
{{cpp/error/error_category/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
bool operator==( const error_category&amp; rhs ) const;
}}
{{dcl | since=c++11 | num=2 | 1=
bool operator!=( const error_category&amp; rhs ) const;
}}
{{dcl | since=c++11 | num=3 | 1=
bool operator&lt;( const error_category&amp; rhs ) const;
}}
{{dcl end}}

Compares to another error category.

@1@ Checks whether {{c|*this}} and {{tt|rhs}} refer to the same object.
@2@ Checks whether {{c|*this}} and {{tt|rhs}} do not refer to the same object.
@3@ Orders {{c|*this}} and {{tt|rhs}} by the order of {{c|this}} and {{c|&amp;rhs}}. Equivalent to {{c|std::less&lt;const error_category*&gt;()(this, &amp;rhs)}}.

===Parameters===
{{par begin}}
{{par | code | specifies the error code to compare}}
{{par | condition | specifies the error condition to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if {{c|*this}} and {{tt|rhs}} refer to the same object, {{c|false}} otherwise.
@2@ {{c|true}} if {{c|*this}} and {{tt|rhs}} do not refer to the same object, {{c|false}} otherwise.
@3@ {{c|true}} if {{c|*this}} is less than {{tt|rhs}} as defined by the order of {{tt|this}} and {{c|&amp;rhs}}.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error category/operator cmp]]
[[es:cpp/error/error category/operator cmp]]
[[fr:cpp/error/error category/operator cmp]]
[[it:cpp/error/error category/operator cmp]]
[[ja:cpp/error/error category/operator cmp]]
[[pt:cpp/error/error category/operator cmp]]
[[ru:cpp/error/error category/operator cmp]]
[[zh:cpp/error/error category/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error category/~error category</title>
    <ns>0</ns>
    <id>8919</id>
    <revision>
      <id>68198</id>
      <parentid>63299</parentid>
      <timestamp>2014-03-18T03:04:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no noexcept since LWG 2145 (it's default for all dtors anyway)</comment>
      <text xml:space="preserve" bytes="574">{{cpp/error/error_category/title|~error_category}}
{{cpp/error/error_category/navbar}}
{{ddcl | since=c++11 | 1=
virtual ~error_category();
}}

Destroys the object.

===Parameters===
(none)

[[de:cpp/error/error category/~error category]]
[[es:cpp/error/error category/~error category]]
[[fr:cpp/error/error category/~error category]]
[[it:cpp/error/error category/~error category]]
[[ja:cpp/error/error category/~error category]]
[[pt:cpp/error/error category/~error category]]
[[ru:cpp/error/error category/~error category]]
[[zh:cpp/error/error category/~error category]]</text>
      <sha1>q9o0oora5w4rndd89z40qgfqa0fc76y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code</title>
    <ns>0</ns>
    <id>4815</id>
    <revision>
      <id>63300</id>
      <parentid>61356</parentid>
      <timestamp>2013-07-10T01:27:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1703">{{cpp/title|error_code}}
{{cpp/error/error_code/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
class error_code;
}}

{{tt|std::error_code}} is a platform-dependent error code. Each {{tt|std::error_code}} object holds a pair of error code originating from the operating system, or some low-level interface and a pointer to an object of type {{lc|std::error_category}}, which corresponds to the said interface. The error code values may be not unique across different error categories.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc constructor}}
{{dsc inc | cpp/error/error_code/dsc operator{{=}}}}
{{dsc inc | cpp/error/error_code/dsc assign}}
{{dsc h2 | Modifiers}}
{{dsc inc | cpp/error/error_code/dsc clear}}
{{dsc h2 | Observers}}
{{dsc inc | cpp/error/error_code/dsc value}}
{{dsc inc | cpp/error/error_code/dsc category}}
{{dsc inc | cpp/error/error_code/dsc default_error_condition}}
{{dsc inc | cpp/error/error_code/dsc message}}
{{dsc inc | cpp/error/error_code/dsc operator bool}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc operator_cmp}}
{{dsc inc | cpp/error/error_code/dsc operator_ltlt}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc is_error_code_enum}}
{{dsc inc | cpp/error/error_code/dsc hash}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/error/dsc error_category}}
{{dsc end}}

[[de:cpp/error/error code]]
[[es:cpp/error/error code]]
[[fr:cpp/error/error code]]
[[it:cpp/error/error code]]
[[ja:cpp/error/error code]]
[[pt:cpp/error/error code]]
[[ru:cpp/error/error code]]
[[zh:cpp/error/error code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/assign</title>
    <ns>0</ns>
    <id>9016</id>
    <revision>
      <id>62704</id>
      <parentid>62300</parentid>
      <timestamp>2013-07-01T23:33:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="860">{{cpp/error/error_code/title|assign}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void assign( int ec, const error_category&amp; ecat );
}}
{{dcl end}}

Replaces the contents with error code {{tt|ec}} and corresponding category {{tt|ecat}}.

===Parameters===
{{par begin}}
{{par | ec | platform-dependent error code enum to assign}}
{{par | ecat | error category corresponding to {{tt|ec}}}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/error/error code/assign]]
[[es:cpp/error/error code/assign]]
[[fr:cpp/error/error code/assign]]
[[it:cpp/error/error code/assign]]
[[ja:cpp/error/error code/assign]]
[[pt:cpp/error/error code/assign]]
[[ru:cpp/error/error code/assign]]
[[zh:cpp/error/error code/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/category</title>
    <ns>0</ns>
    <id>9019</id>
    <revision>
      <id>63301</id>
      <parentid>57360</parentid>
      <timestamp>2013-07-10T01:27:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="693">{{cpp/error/error_code/title|category}}
{{cpp/error/error_code/navbar}}
{{ddcl  | since=c++11 | 1=
const std::error_category&amp; category() const;
}}

Returns the error category of the error value.

===Parameters===
(none)

===Return value===
The error category of the error value.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc value}}
{{dsc end}}

[[de:cpp/error/error code/category]]
[[es:cpp/error/error code/category]]
[[fr:cpp/error/error code/category]]
[[it:cpp/error/error code/category]]
[[ja:cpp/error/error code/category]]
[[pt:cpp/error/error code/category]]
[[ru:cpp/error/error code/category]]
[[zh:cpp/error/error code/category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/clear</title>
    <ns>0</ns>
    <id>9017</id>
    <revision>
      <id>62705</id>
      <parentid>49481</parentid>
      <timestamp>2013-07-01T23:34:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="628">{{cpp/error/error_code/title|clear}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void clear();
}}
{{dcl end}}

Replaces the error code and error category with default values. 

Equivalent to {{c|1=*this = error_code(0, std::system_category())}}.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/error/error code/clear]]
[[es:cpp/error/error code/clear]]
[[fr:cpp/error/error code/clear]]
[[it:cpp/error/error code/clear]]
[[ja:cpp/error/error code/clear]]
[[pt:cpp/error/error code/clear]]
[[ru:cpp/error/error code/clear]]
[[zh:cpp/error/error code/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/default error condition</title>
    <ns>0</ns>
    <id>9020</id>
    <revision>
      <id>63302</id>
      <parentid>42463</parentid>
      <timestamp>2013-07-10T01:27:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="852">{{cpp/error/error_code/title|default_error_condition}}
{{cpp/error/error_code/navbar}}
{{ddcl  | since=c++11 | 1=
std::error_condition default_error_condition() const;
}}

Returns the default error condition for the current error value.

Equivalent to {{c|category().default_error_condition(value())}}.

===Parameters===
(none)

===Return value===
The default error condition for the current error value.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error code/default error condition]]
[[es:cpp/error/error code/default error condition]]
[[fr:cpp/error/error code/default error condition]]
[[it:cpp/error/error code/default error condition]]
[[ja:cpp/error/error code/default error condition]]
[[pt:cpp/error/error code/default error condition]]
[[ru:cpp/error/error code/default error condition]]
[[zh:cpp/error/error code/default error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/error code</title>
    <ns>0</ns>
    <id>9014</id>
    <revision>
      <id>62706</id>
      <parentid>49482</parentid>
      <timestamp>2013-07-01T23:34:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1393">{{cpp/error/error_code/title|error_code}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
error_code();
}}
{{dcl | num=2 | since=c++11 | 1=
error_code( int ec, const error_category&amp; ecat );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class ErrorCodeEnum &gt;
error_code( ErrorCodeEnum e );
}}
{{dcl end}}

Constructs new error code.

@1@ Constructs error code with default value. Equivalent to {{c|error_code(0, std::system_category())}}.
@2@ Constructs error code with {{tt|ec}} as the platform-dependent error code and {{tt|ecat}} as the corresponding error category.
@3@ Constructs error code from an error code enum {{tt|e}}. Equivalent to {{c|1=*this = std::make_error_code(e)}}. The overload participates in overload resolutions only if {{c|1=std::is_error_code_enum&lt;ErrorCodeEnum&gt;::value == true}}.

===Parameters===
{{par begin}}
{{par | ec | platform dependent error code to construct with}}
{{par | ecat | error category corresponding to {{tt|ec}}}}
{{par | e | error code enum to construct with}}
{{par end}}

===Exceptions===
{{noexcept}}

[[de:cpp/error/error code/error code]]
[[es:cpp/error/error code/error code]]
[[fr:cpp/error/error code/error code]]
[[it:cpp/error/error code/error code]]
[[ja:cpp/error/error code/error code]]
[[pt:cpp/error/error code/error code]]
[[ru:cpp/error/error code/error code]]
[[zh:cpp/error/error code/error code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/hash</title>
    <ns>0</ns>
    <id>5533</id>
    <revision>
      <id>72079</id>
      <parentid>63303</parentid>
      <timestamp>2014-07-12T11:47:47Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ template&lt;&gt;</comment>
      <text xml:space="preserve" bytes="580">{{cpp/title | hash{{small|&lt;std::error_code&gt;}}}}
{{cpp/error/error_code/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
template&lt;&gt; struct hash&lt;error_code&gt;;
}}

The template specialization of {{lc|std::hash}} for {{lc|std::error_code}} allows users to obtain hashes of objects of type {{lc|std::error_code}}.

[[de:cpp/error/error code/hash]]
[[es:cpp/error/error code/hash]]
[[fr:cpp/error/error code/hash]]
[[it:cpp/error/error code/hash]]
[[ja:cpp/error/error code/hash]]
[[pt:cpp/error/error code/hash]]
[[ru:cpp/error/error code/hash]]
[[zh:cpp/error/error code/hash]]</text>
      <sha1>o7nn81zms24psdo5gtc13e3ovvd1rra</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/is error code enum</title>
    <ns>0</ns>
    <id>9930</id>
    <revision>
      <id>62707</id>
      <parentid>49484</parentid>
      <timestamp>2013-07-01T23:34:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="735">{{cpp/title|is_error_code_enum}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_error_code_enum;
}}
{{dcl end}}

If {{tt|T}} is an error code enumeration, this template provides the member constant {{c|value}} equal {{c|true}}.  For any other type, {{tt|value}} is {{c|false}}.

This template may be specialized for a user-defined type to indicate that the type is eligible for {{lc|std::error_code}} and {{lc|std::error_condition}} automatic conversions.

The following classes of the standard library are an error code enum: 
* {{lc|std::io_errc}}
* {{lc|std::future_errc}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an error code enum}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/make error code</title>
    <ns>0</ns>
    <id>12631</id>
    <redirect title="cpp/error/errc/make error code" />
    <revision>
      <id>61353</id>
      <timestamp>2013-06-05T22:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/error code/make error code]] to [[cpp/error/errc/make error code]]: errc specific</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/error/errc/make error code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/message</title>
    <ns>0</ns>
    <id>9021</id>
    <revision>
      <id>63304</id>
      <parentid>42427</parentid>
      <timestamp>2013-07-10T01:27:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="687">{{cpp/error/error_code/title|message}}
{{cpp/error/error_code/navbar}}
{{ddcl  | since=c++11 | 1=
std::string message() const;
}}

Returns the message corresponding to the current error value and category.

Equivalent to {{c|category().message(value())}}.

===Parameters===
(none)

===Return value===
The error message corresponding to the current error value and category.

===Exceptions===
(none)

[[de:cpp/error/error code/message]]
[[es:cpp/error/error code/message]]
[[fr:cpp/error/error code/message]]
[[it:cpp/error/error code/message]]
[[ja:cpp/error/error code/message]]
[[pt:cpp/error/error code/message]]
[[ru:cpp/error/error code/message]]
[[zh:cpp/error/error code/message]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/operator=</title>
    <ns>0</ns>
    <id>9015</id>
    <revision>
      <id>62708</id>
      <parentid>57361</parentid>
      <timestamp>2013-07-01T23:34:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1088">{{cpp/error/error_code/title|operator{{=}}}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class ErrorCodeEnum &gt;
error_code&amp; operator=( ErrorCodeEnum e );
}}
{{dcl end}}

Replaces the error code and corresponding category with those representing error code enum {{tt|e}}. 

Equivalent to {{c|1=*this = std::make_error_code(e)}}. The overload participates in overload resolutions only if {{c|1=std::is_error_code_enum&lt;ErrorCodeEnum&gt;::value == true}}.

===Parameters===
{{par begin}}
{{par | e | error code enum to construct}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===Notes===
Copy-assignment operator is defined implicitly.

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc assign}}
{{dsc end}}

[[de:cpp/error/error code/operator=]]
[[es:cpp/error/error code/operator=]]
[[fr:cpp/error/error code/operator=]]
[[it:cpp/error/error code/operator=]]
[[ja:cpp/error/error code/operator=]]
[[pt:cpp/error/error code/operator=]]
[[ru:cpp/error/error code/operator=]]
[[zh:cpp/error/error code/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/operator bool</title>
    <ns>0</ns>
    <id>9022</id>
    <revision>
      <id>63305</id>
      <parentid>42405</parentid>
      <timestamp>2013-07-10T01:27:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="662">{{cpp/error/error_code/title|operator bool}}
{{cpp/error/error_code/navbar}}
{{ddcl  | since=c++11 | 1=
explicit operator bool() const;
}}

Checks if the error value is valid, i.e. non-zero.

===Parameters===
(none)

===Return value===
{{c|false}} if {{c|1=value() == 0}}, {{c|true}} otherwise.

===Exceptions===
{{noexcept}}

[[de:cpp/error/error code/operator bool]]
[[es:cpp/error/error code/operator bool]]
[[fr:cpp/error/error code/operator bool]]
[[it:cpp/error/error code/operator bool]]
[[ja:cpp/error/error code/operator bool]]
[[pt:cpp/error/error code/operator bool]]
[[ru:cpp/error/error code/operator bool]]
[[zh:cpp/error/error code/operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/operator cmp</title>
    <ns>0</ns>
    <id>9025</id>
    <revision>
      <id>62709</id>
      <parentid>57364</parentid>
      <timestamp>2013-07-01T23:34:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1522">{{cpp/title|1=operator==,!=,&lt;{{small|(std::error_code)}}}}
{{cpp/error/error_code/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | num=1 | since=c++11 | 1=
bool operator==( const error_code&amp; lhs, const error_code&amp; rhs );
}}
{{dcl | num=1 | since=c++11 | 1=
bool operator!=( const error_code&amp; lhs, const error_code&amp; rhs );
}}
{{dcl | num=1 | since=c++11 | 1=
bool operator&lt;( const error_code&amp; lhs, const error_code&amp; rhs );
}}
{{dcl end}}

Compares two error code objects.

@1@ Compares {{tt|lhs}} and {{tt|rhs}} for equality.
@2@ Compares {{tt|lhs}} and {{tt|rhs}} for equality.
@3@ Checks whether {{tt|lhs}} is less than {{tt|rhs}}. 

===Parameters===
{{par begin}}
{{par | lhs, rhs | error codes to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if the error category and error value compare equal.
@2@ {{c|true}} if the error category or error value compare are not equal.
@3@ {{c|true}} if {{c|lhs.category() &lt; rhs.category()}}. Otherwise, {{c|true}} if {{c|1=lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value()}}. Otherwise, {{c|false}}

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc category}}
{{dsc end}}

[[de:cpp/error/error code/operator cmp]]
[[es:cpp/error/error code/operator cmp]]
[[fr:cpp/error/error code/operator cmp]]
[[it:cpp/error/error code/operator cmp]]
[[ja:cpp/error/error code/operator cmp]]
[[pt:cpp/error/error code/operator cmp]]
[[ru:cpp/error/error code/operator cmp]]
[[zh:cpp/error/error code/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/operator ltlt</title>
    <ns>0</ns>
    <id>9024</id>
    <revision>
      <id>63306</id>
      <parentid>49488</parentid>
      <timestamp>2013-07-10T01:27:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="894">{{cpp/title|operator&lt;&lt;{{small|(std::error_code)}}}}
{{cpp/error/error_code/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp;
    operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp; os, const error_code&amp; ec );
}}

Performs stream output operation on error code {{tt|ec}}.

Equivalent to {{c|os &lt;&lt; ec.category().name() &lt;&lt; ’:’ &lt;&lt; ec.value}}.

===Parameters===
{{par begin}}
{{par | os | output stream to insert data to}}
{{par | ec | error code}}
{{par end}}

===Return value===
{{tt|os}}

[[de:cpp/error/error code/operator ltlt]]
[[es:cpp/error/error code/operator ltlt]]
[[fr:cpp/error/error code/operator ltlt]]
[[it:cpp/error/error code/operator ltlt]]
[[ja:cpp/error/error code/operator ltlt]]
[[pt:cpp/error/error code/operator ltlt]]
[[ru:cpp/error/error code/operator ltlt]]
[[zh:cpp/error/error code/operator ltlt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error code/value</title>
    <ns>0</ns>
    <id>9018</id>
    <revision>
      <id>63307</id>
      <parentid>57365</parentid>
      <timestamp>2013-07-10T01:27:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="637">{{cpp/error/error_code/title|value}}
{{cpp/error/error_code/navbar}}
{{ddcl  | since=c++11 | 1=
int value() const;
}}

Returns the platform dependent error value.

===Parameters===
(none)

===Return value===
The platform-dependent error value.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc category}}
{{dsc end}}

[[de:cpp/error/error code/value]]
[[es:cpp/error/error code/value]]
[[fr:cpp/error/error code/value]]
[[it:cpp/error/error code/value]]
[[ja:cpp/error/error code/value]]
[[pt:cpp/error/error code/value]]
[[ru:cpp/error/error code/value]]
[[zh:cpp/error/error code/value]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition</title>
    <ns>0</ns>
    <id>4808</id>
    <revision>
      <id>63308</id>
      <parentid>61355</parentid>
      <timestamp>2013-07-10T01:27:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1599">{{cpp/title|error_condition}}
{{cpp/error/error_condition/navbar}}
{{ddcl | header=system_error | since=c++11 | 1=
class error_condition;
}}

{{tt|std::error_condition}} is a platform-independent error code. Like {{lc|std::error_code}}, it is uniquely identified by an integer value and a {{lc|std::error_category}}, but unlike {{lc|std::error_code}}, the value is not platform-dependent.

A typical implementation holds one integer data member (the value) and a pointer to an {{lc|std::error_category}}.
 
===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_condition/dsc constructor}}
{{dsc inc | cpp/error/error_condition/dsc operator{{=}}}}
{{dsc inc | cpp/error/error_condition/dsc assign}}
{{dsc inc | cpp/error/error_condition/dsc clear}}
{{dsc inc | cpp/error/error_condition/dsc value}}
{{dsc inc | cpp/error/error_condition/dsc category}}
{{dsc inc | cpp/error/error_condition/dsc message}}
{{dsc inc | cpp/error/error_condition/dsc operator bool}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_condition/dsc operator_cmp}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/error/error_condition/dsc is_error_condition_enum}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc error_category}}
{{dsc end}}

[[de:cpp/error/error condition]]
[[es:cpp/error/error condition]]
[[fr:cpp/error/error condition]]
[[it:cpp/error/error condition]]
[[ja:cpp/error/error condition]]
[[pt:cpp/error/error condition]]
[[ru:cpp/error/error condition]]
[[zh:cpp/error/error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/assign</title>
    <ns>0</ns>
    <id>9630</id>
    <revision>
      <id>62710</id>
      <parentid>49491</parentid>
      <timestamp>2013-07-01T23:34:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="452">{{cpp/error/error_condition/title | assign}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void assign( int val, const error_category&amp; cat );
}}
{{dcl end}}

Assigns contents to an error condition. Sets the error code to {{tt|val}} and error category to {{tt|cat}}.

===Parameters===
{{par begin}}
{{par | val | error code}}
{{par | cat | error category}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/category</title>
    <ns>0</ns>
    <id>9633</id>
    <revision>
      <id>62711</id>
      <parentid>49492</parentid>
      <timestamp>2013-07-01T23:34:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="313">{{cpp/error/error_condition/title | category}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
const error_category&amp; category() const;
}}
{{dcl end}}

Returns the stored error category.

===Parameters===
(none)

===Return value===
The stored error category.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/clear</title>
    <ns>0</ns>
    <id>9631</id>
    <revision>
      <id>62712</id>
      <parentid>49493</parentid>
      <timestamp>2013-07-01T23:34:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="353">{{cpp/error/error_condition/title | clear}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void clear();
}}
{{dcl end}}

Clears the state of the error condition. Sets the error code to {{c|0}} and error category to {{lc|std::generic_category}}.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/error condition</title>
    <ns>0</ns>
    <id>9628</id>
    <revision>
      <id>68024</id>
      <parentid>64279</parentid>
      <timestamp>2014-03-15T14:40:42Z</timestamp>
      <contributor>
        <ip>126.87.43.135</ip>
      </contributor>
      <text xml:space="preserve" bytes="1268">{{cpp/error/error_condition/title | error_condition}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
error_condition();
}}
{{dcl | num=2 | notes={{mark since c++11}}&lt;br/&gt;{{mark implicit}} |
error_condition( const error_condition&amp; other );
}}
{{dcl | num=3 | since=c++11 |
error_condition( int val, const error_category&amp; cat );
}}
{{dcl | num=4 | since=c++11 |
template&lt; class ErrorConditionEnum &gt;
error_condition( ErrorConditionEnum e );
}}
{{dcl end}}

Constructs new error condition.
@1@ Default constructor. Initializes the error condition with generic category and error code {{c|0}}.

@2@ Copy constructor. Initializes the error condition with the contents of {{tt|other}}.
@3@ Initializes the error condition with error code {{tt|val}} and error category {{tt|cat}}.

@4@ Initializes the error condition with enum {{tt|e}}. Effectively calls {{lc|make_error_condition()}}. Does not participate in the overload resolution unless {{c|is_error_condition_enum&lt;ErrorConditionEnum&gt;::value}} is {{c|true}}.

===Parameters===
{{par begin}}
{{par | other | another error condition to initialize with}}
{{par | val | error code}}
{{par | cat | error category}}
{{par | e | error condition enum}}
{{par end}}

===Exceptions===
{{noexcept}}</text>
      <sha1>1g8he3j3rcsoo0f6ze1xwgp4gfn3zow</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/is error condition enum</title>
    <ns>0</ns>
    <id>9638</id>
    <revision>
      <id>62714</id>
      <parentid>49495</parentid>
      <timestamp>2013-07-01T23:34:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="723">{{cpp/title|is_error_condition_enum}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_error_condition_enum;
}}
{{dcl end}}

If {{tt|T}} is an error condition enum, this template provides the member constant {{c|value}} equal {{c|true}}.  For any other type, {{tt|value}} is {{c|false}}.

This template may be specialized for a user-defined type to indicate that the type is eligible for {{lc|std::error_code}} and {{lc|std::error_condition}} automatic conversions.

The following class of the standard library is an error condition enum: {{lc|std::errc}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an error condition enum}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/make error condition</title>
    <ns>0</ns>
    <id>12630</id>
    <redirect title="cpp/error/errc/make error condition" />
    <revision>
      <id>61351</id>
      <timestamp>2013-06-05T22:10:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/error condition/make error condition]] to [[cpp/error/errc/make error condition]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/error/errc/make error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/message</title>
    <ns>0</ns>
    <id>9634</id>
    <revision>
      <id>62715</id>
      <parentid>49497</parentid>
      <timestamp>2013-07-01T23:34:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="433">{{cpp/error/error_condition/title | message}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
std::string message() const;
}}
{{dcl end}}

Returns an explanatory message for the stored error code and error category. Effectively calls {{c|category().message(value())}}.

===Parameters===
(none)

===Return value===
An explanatory message for the stored error code and error category. 

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/operator=</title>
    <ns>0</ns>
    <id>9629</id>
    <revision>
      <id>64278</id>
      <parentid>62716</parentid>
      <timestamp>2013-08-15T16:19:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="910">{{cpp/error/error_condition/title | operator{{=}}}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | num=1 | notes={{mark since c++11}}&lt;br&gt;{{mark implicit}} |
error_condition&amp; operator{{=}}( const error_condition&amp; other );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class ErrorConditionEnum &gt;
error_condition&amp; operator{{=}}( ErrorConditionEnum e );
}}
{{dcl end}}

Assigns contents to an error condition.
@1@ Copy assignment operator. Assigns the contents of {{tt|other}}.

@2@ Assigns error condition for enum {{tt|e}}. Effectively calls {{lc|make_error_condition()}}. Does not participate in the overload resolution unless {{c|is_error_condition_enum&lt;ErrorConditionEnum&gt;::value}} is {{c|true}}.

===Parameters===
{{par begin}}
{{par | other | another error condition to initialize with}}
{{par | e | error condition enum}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/operator bool</title>
    <ns>0</ns>
    <id>9635</id>
    <revision>
      <id>62717</id>
      <parentid>49499</parentid>
      <timestamp>2013-07-01T23:34:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="355">{{cpp/error/error_condition/title | operator bool}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
explicit operator bool() const;
}}
{{dcl end}}

Checks whether the stored error code is not zero.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|1=value != 0}}, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/operator cmp</title>
    <ns>0</ns>
    <id>9636</id>
    <revision>
      <id>62718</id>
      <parentid>49500</parentid>
      <timestamp>2013-07-01T23:34:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1858">{{cpp/error/error_condition/title | operator{{==}},!{{=}},&lt;}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | num=1 | since=c++11 | 1=
bool operator==( const error_condition&amp; lhs, const error_condition&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
bool operator==( const error_code&amp; lhs, const error_condition&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
bool operator==( const error_condition&amp; lhs, const error_code&amp; rhs );
}}
{{dcl | num=3 | since=c++11 | 1=
bool operator!=( const error_condition&amp; lhs, const error_condition&amp; rhs );
}}
{{dcl | num=4 | since=c++11 | 1=
bool operator!=( const error_code&amp; lhs, const error_condition&amp; rhs );
}}
{{dcl | num=4 | since=c++11 | 1=
bool operator!=( const error_condition&amp; lhs, const error_code&amp; rhs );
}}
{{dcl | num=5 | since=c++11 |
bool operator&lt;( const error_condition&amp; lhs, const error_condition&amp; rhs );
}}
{{dcl end}}

Compares two error conditions. 

@1-2@ Checks whether {{tt|lhs}} and {{tt|rhs}} are equal.
@3-4@ Checks whether {{tt|lhs}} and {{tt|rhs}} are not equal.
@5@ Checks whether {{tt|lhs}} is ''less than'' {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | error conditions to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if the error category and error value compare equal.
@2@ {{c|true}} if {{c|lhs.category().equivalent(rhs.value(), lhs)}} or {{c|rhs.category().equivalent(lhs.value(), rhs)}} is {{c|true}}.
@3@ {{c|true}} if the error category or error value compare are not equal.
@4@ {{c|true}} if {{c|lhs.category().equivalent(rhs.value(), lhs)}} and {{c|rhs.category().equivalent(lhs.value(), rhs)}} is {{c|false}}.
@5@ {{c|true}} if {{c|lhs.category() &lt; rhs.category()}}. Otherwise, {{c|true}} if {{c|1=lhs.category() == rhs.category() &amp;&amp; lhs.value() &lt; rhs.value()}}. Otherwise, {{c|false}}.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/error condition/value</title>
    <ns>0</ns>
    <id>9632</id>
    <revision>
      <id>62719</id>
      <parentid>49501</parentid>
      <timestamp>2013-07-01T23:34:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="281">{{cpp/error/error_condition/title | value}}
{{cpp/error/error_condition/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
int value() const;
}}
{{dcl end}}

Returns the stored error code.

===Parameters===
(none)

===Return value===
The stored error code.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception</title>
    <ns>0</ns>
    <id>2077</id>
    <revision>
      <id>68219</id>
      <parentid>67289</parentid>
      <timestamp>2014-03-18T18:56:41Z</timestamp>
      <contributor>
        <username>MFH</username>
        <id>2268</id>
      </contributor>
      <comment>regex_error is missing in hierarchy</comment>
      <text xml:space="preserve" bytes="1768">{{cpp/title | exception}}
{{cpp/error/exception/navbar}}
{{ddcl | header=exception |
class exception;
}}

Provides consistent interface to handle errors through the [[cpp/language/throw|throw expression]]. 

All exceptions generated by the standard library inherit from {{lc|std::exception}}

*{{ltt|cpp/error/logic_error}}
:*{{ltt|cpp/error/invalid_argument}}
:*{{ltt|cpp/error/domain_error}}
:*{{ltt|cpp/error/length_error}}
:*{{ltt|cpp/error/out_of_range}}
:*{{ltt|cpp/thread/future_error}}{{mark c++11}}
&lt;!--:*{{ltt|cpp/utility/bad_optional_access}}{{mark c++14}}--&gt;
*{{ltt|cpp/error/runtime_error}}
:*{{ltt|cpp/error/range_error}}
:*{{ltt|cpp/error/overflow_error}}
:*{{ltt|cpp/error/underflow_error}}
:*{{ltt|cpp/regex/regex_error}}{{mark c++11}}
:*{{ltt|cpp/error/system_error}}{{mark c++11}}
::*{{ltt|cpp/io/ios_base/failure|ios_base::failure}}{{mark since c++11}}
*{{ltt|cpp/types/bad_typeid}}
*{{ltt|cpp/types/bad_cast}}
*{{ltt|cpp/memory/bad_weak_ptr}}{{mark c++11}}
*{{ltt|cpp/utility/functional/bad_function_call}}{{mark c++11}}
*{{ltt|cpp/memory/new/bad_alloc}}
:*{{ltt|cpp/memory/new/bad_array_length}}{{mark c++14}}
:*{{ltt|cpp/memory/new/bad_array_new_length}}{{mark c++11}}
*{{ltt|cpp/error/bad_exception}}
*{{ltt|cpp/io/ios_base/failure|ios_base::failure}}{{mark until c++11}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor | exception}}
{{dsc inc | cpp/error/exception/dsc destructor}}
{{dsc inc | cpp/error/exception/dsc operator{{=}}}}
{{dsc inc | cpp/error/exception/dsc what}}
{{dsc end}}

[[de:cpp/error/exception]]
[[es:cpp/error/exception]]
[[fr:cpp/error/exception]]
[[it:cpp/error/exception]]
[[ja:cpp/error/exception]]
[[pt:cpp/error/exception]]
[[ru:cpp/error/exception]]
[[zh:cpp/error/exception]]</text>
      <sha1>t91eyznhen674rojqj8q6652boqgech</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/bad exception</title>
    <ns>0</ns>
    <id>6605</id>
    <redirect title="cpp/error/bad exception" />
    <revision>
      <id>25926</id>
      <timestamp>2012-04-29T08:17:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/bad exception]] to [[cpp/error/bad exception]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/bad exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/current exception</title>
    <ns>0</ns>
    <id>6606</id>
    <redirect title="cpp/error/current exception" />
    <revision>
      <id>25928</id>
      <timestamp>2012-04-29T08:17:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/current exception]] to [[cpp/error/current exception]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/error/current exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/domain error</title>
    <ns>0</ns>
    <id>6607</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>25930</id>
      <timestamp>2012-04-29T08:17:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/domain error]] to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/domain error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/domain error/domain error</title>
    <ns>0</ns>
    <id>6608</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>61269</id>
      <parentid>25932</parentid>
      <timestamp>2013-06-05T14:10:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/domain error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception</title>
    <ns>0</ns>
    <id>8850</id>
    <revision>
      <id>64867</id>
      <parentid>49503</parentid>
      <timestamp>2013-08-27T01:37:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept, fmt</comment>
      <text xml:space="preserve" bytes="890">{{cpp/error/exception/title|exception}}
{{cpp/error/exception/navbar}}
{{dcl begin}}
{{dcl | num=1 |
exception();
}}
{{dcl | num=2 | 
exception( const exception&amp; other );
}}
{{dcl end}}

Constructs new exception object.

@1@ Default constructor. {{ltf|cpp/error/exception/what}} returns empty string.

@2@ Copy constructor. Initializes the contents with those of {{tt|other}}

===Parameters===
{{par begin}}
{{par | other | another exception to assign the contents of}}
{{par end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/error/exception/exception]]
[[es:cpp/error/exception/exception]]
[[fr:cpp/error/exception/exception]]
[[it:cpp/error/exception/exception]]
[[ja:cpp/error/exception/exception]]
[[pt:cpp/error/exception/exception]]
[[ru:cpp/error/exception/exception]]
[[zh:cpp/error/exception/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception/exception</title>
    <ns>0</ns>
    <id>4514</id>
    <redirect title="cpp/error/exception/exception" />
    <revision>
      <id>37280</id>
      <parentid>33630</parentid>
      <timestamp>2012-07-04T07:26:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/exception/exception]]</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/error/exception/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception/operator=</title>
    <ns>0</ns>
    <id>6609</id>
    <redirect title="cpp/error/exception/operator=" />
    <revision>
      <id>25934</id>
      <timestamp>2012-04-29T08:17:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/exception/operator=]] to [[cpp/error/exception/operator=]]</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/error/exception/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception/what</title>
    <ns>0</ns>
    <id>6610</id>
    <redirect title="cpp/error/exception/what" />
    <revision>
      <id>25936</id>
      <timestamp>2012-04-29T08:17:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/exception/what]] to [[cpp/error/exception/what]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/exception/what]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception/~exception</title>
    <ns>0</ns>
    <id>6611</id>
    <redirect title="cpp/error/exception/~exception" />
    <revision>
      <id>25938</id>
      <timestamp>2012-04-29T08:17:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/exception/~exception]] to [[cpp/error/exception/~exception]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/error/exception/~exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/exception ptr</title>
    <ns>0</ns>
    <id>6612</id>
    <redirect title="cpp/error/exception ptr" />
    <revision>
      <id>25940</id>
      <timestamp>2012-04-29T08:17:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/exception ptr]] to [[cpp/error/exception ptr]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/exception ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/get terminate</title>
    <ns>0</ns>
    <id>6613</id>
    <redirect title="cpp/error/get terminate" />
    <revision>
      <id>25942</id>
      <timestamp>2012-04-29T08:17:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/get terminate]] to [[cpp/error/get terminate]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/get terminate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/get unexpected</title>
    <ns>0</ns>
    <id>6614</id>
    <redirect title="cpp/error/get unexpected" />
    <revision>
      <id>25944</id>
      <timestamp>2012-04-29T08:17:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/get unexpected]] to [[cpp/error/get unexpected]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/get unexpected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/invalid argument</title>
    <ns>0</ns>
    <id>6615</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>25946</id>
      <timestamp>2012-04-29T08:17:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/invalid argument]] to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/error/invalid argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/invalid argument/invalid argument</title>
    <ns>0</ns>
    <id>6616</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>61271</id>
      <parentid>25948</parentid>
      <timestamp>2013-06-05T14:10:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/error/invalid argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/length error</title>
    <ns>0</ns>
    <id>6617</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>25950</id>
      <timestamp>2012-04-29T08:17:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/length error]] to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/length error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/length error/length error</title>
    <ns>0</ns>
    <id>6618</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>61273</id>
      <parentid>25952</parentid>
      <timestamp>2013-06-05T14:10:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/length error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/logic error</title>
    <ns>0</ns>
    <id>6619</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>25954</id>
      <timestamp>2012-04-29T08:17:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/logic error]] to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/logic error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/logic error/logic error</title>
    <ns>0</ns>
    <id>6620</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>61275</id>
      <parentid>25956</parentid>
      <timestamp>2013-06-05T14:10:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/logic error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/make exception ptr</title>
    <ns>0</ns>
    <id>6621</id>
    <redirect title="cpp/error/make exception ptr" />
    <revision>
      <id>25958</id>
      <timestamp>2012-04-29T08:17:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/make exception ptr]] to [[cpp/error/make exception ptr]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/error/make exception ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/nested exception</title>
    <ns>0</ns>
    <id>6622</id>
    <redirect title="cpp/error/nested exception" />
    <revision>
      <id>25960</id>
      <timestamp>2012-04-29T08:17:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/nested exception]] to [[cpp/error/nested exception]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/error/nested exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/operator=</title>
    <ns>0</ns>
    <id>4519</id>
    <revision>
      <id>64833</id>
      <parentid>49504</parentid>
      <timestamp>2013-08-27T01:17:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="716">{{cpp/error/exception/title|operator{{=}}}}
{{cpp/error/exception/navbar}}
{{ddcl | 1=
exception&amp; operator=( const exception&amp; other );
}}

Copy assignment operator. Assigns the contents of {{tt|other}}

===Parameters===
{{par begin}}
{{par | other | another exception to assign the contents of}}
{{par end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/error/exception/operator=]]
[[es:cpp/error/exception/operator=]]
[[fr:cpp/error/exception/operator=]]
[[it:cpp/error/exception/operator=]]
[[ja:cpp/error/exception/operator=]]
[[pt:cpp/error/exception/operator=]]
[[ru:cpp/error/exception/operator=]]
[[zh:cpp/error/exception/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/out of range</title>
    <ns>0</ns>
    <id>6623</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>25962</id>
      <timestamp>2012-04-29T08:17:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/out of range]] to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/out of range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/out of range/out of range</title>
    <ns>0</ns>
    <id>6624</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>61277</id>
      <parentid>25964</parentid>
      <timestamp>2013-06-05T14:10:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/out of range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/overflow error</title>
    <ns>0</ns>
    <id>6625</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>25966</id>
      <timestamp>2012-04-29T08:17:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/overflow error]] to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/overflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/overflow error/overflow error</title>
    <ns>0</ns>
    <id>6626</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>61279</id>
      <parentid>25968</parentid>
      <timestamp>2013-06-05T14:10:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/overflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/range error</title>
    <ns>0</ns>
    <id>6627</id>
    <redirect title="cpp/error/range error" />
    <revision>
      <id>25970</id>
      <timestamp>2012-04-29T08:17:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/range error]] to [[cpp/error/range error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/range error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/rethrow exception</title>
    <ns>0</ns>
    <id>6628</id>
    <redirect title="cpp/error/rethrow exception" />
    <revision>
      <id>25972</id>
      <timestamp>2012-04-29T08:17:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/rethrow exception]] to [[cpp/error/rethrow exception]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/error/rethrow exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/rethrow if nested</title>
    <ns>0</ns>
    <id>6629</id>
    <redirect title="cpp/error/rethrow if nested" />
    <revision>
      <id>25974</id>
      <timestamp>2012-04-29T08:17:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/rethrow if nested]] to [[cpp/error/rethrow if nested]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/error/rethrow if nested]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/runtime error</title>
    <ns>0</ns>
    <id>6630</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>25976</id>
      <timestamp>2012-04-29T08:17:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/runtime error]] to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/runtime error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/runtime error/runtime error</title>
    <ns>0</ns>
    <id>6631</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>61282</id>
      <parentid>25978</parentid>
      <timestamp>2013-06-05T14:11:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/runtime error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/set terminate</title>
    <ns>0</ns>
    <id>6632</id>
    <redirect title="cpp/error/set terminate" />
    <revision>
      <id>25980</id>
      <timestamp>2012-04-29T08:17:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/set terminate]] to [[cpp/error/set terminate]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/set terminate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/set unexpected</title>
    <ns>0</ns>
    <id>6633</id>
    <redirect title="cpp/error/set unexpected" />
    <revision>
      <id>25982</id>
      <timestamp>2012-04-29T08:17:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/set unexpected]] to [[cpp/error/set unexpected]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/set unexpected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/terminate</title>
    <ns>0</ns>
    <id>6634</id>
    <redirect title="cpp/error/terminate" />
    <revision>
      <id>25984</id>
      <timestamp>2012-04-29T08:17:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/terminate]] to [[cpp/error/terminate]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/error/terminate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/terminate handler</title>
    <ns>0</ns>
    <id>6635</id>
    <redirect title="cpp/error/terminate handler" />
    <revision>
      <id>25986</id>
      <timestamp>2012-04-29T08:17:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/terminate handler]] to [[cpp/error/terminate handler]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/error/terminate handler]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/throw with nested</title>
    <ns>0</ns>
    <id>6636</id>
    <redirect title="cpp/error/throw with nested" />
    <revision>
      <id>25988</id>
      <timestamp>2012-04-29T08:17:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/throw with nested]] to [[cpp/error/throw with nested]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/error/throw with nested]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/uncaught exception</title>
    <ns>0</ns>
    <id>6637</id>
    <redirect title="cpp/error/uncaught exception" />
    <revision>
      <id>25990</id>
      <timestamp>2012-04-29T08:17:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/uncaught exception]] to [[cpp/error/uncaught exception]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/error/uncaught exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/underflow error</title>
    <ns>0</ns>
    <id>6638</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>25992</id>
      <timestamp>2012-04-29T08:17:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/underflow error]] to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/underflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/underflow error/underflow error</title>
    <ns>0</ns>
    <id>6639</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>61284</id>
      <parentid>25994</parentid>
      <timestamp>2013-06-05T14:11:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/underflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/unexpected</title>
    <ns>0</ns>
    <id>6640</id>
    <redirect title="cpp/error/unexpected" />
    <revision>
      <id>25996</id>
      <timestamp>2012-04-29T08:17:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/unexpected]] to [[cpp/error/unexpected]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/error/unexpected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/unexpected handler</title>
    <ns>0</ns>
    <id>6641</id>
    <redirect title="cpp/error/unexpected handler" />
    <revision>
      <id>25998</id>
      <timestamp>2012-04-29T08:17:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/exception/unexpected handler]] to [[cpp/error/unexpected handler]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/error/unexpected handler]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/what</title>
    <ns>0</ns>
    <id>4516</id>
    <revision>
      <id>66024</id>
      <parentid>66023</parentid>
      <timestamp>2013-10-21T15:22:04Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="811">{{cpp/error/exception/title|what}}
{{cpp/error/exception/navbar}}
{{ddcl | 
virtual const char* what() const;
}}

Returns the explanatory string.

===Parameters===
(none)

===Return value===
Pointer to a null-terminated string with explanatory information. The pointer is guaranteed to be valid at least until the exception object from which it is obtained is destroyed, or until a non-const member function on the exception object is called.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/error/exception/what]]
[[es:cpp/error/exception/what]]
[[fr:cpp/error/exception/what]]
[[it:cpp/error/exception/what]]
[[ja:cpp/error/exception/what]]
[[pt:cpp/error/exception/what]]
[[ru:cpp/error/exception/what]]
[[zh:cpp/error/exception/what]]</text>
      <sha1>liat4fwhszbgpreuztb9y6baf9nv9ov</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception/~exception</title>
    <ns>0</ns>
    <id>4517</id>
    <revision>
      <id>42336</id>
      <parentid>33633</parentid>
      <timestamp>2012-11-02T22:55:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="443">{{cpp/error/exception/title|~exception}}
{{cpp/error/exception/navbar}}
{{ddcl | 
virtual ~exception();
}}

Destroys the exception object.

[[de:cpp/error/exception/~exception]]
[[es:cpp/error/exception/~exception]]
[[fr:cpp/error/exception/~exception]]
[[it:cpp/error/exception/~exception]]
[[ja:cpp/error/exception/~exception]]
[[pt:cpp/error/exception/~exception]]
[[ru:cpp/error/exception/~exception]]
[[zh:cpp/error/exception/~exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/exception ptr</title>
    <ns>0</ns>
    <id>3538</id>
    <revision>
      <id>72325</id>
      <parentid>69702</parentid>
      <timestamp>2014-08-09T02:18:02Z</timestamp>
      <contributor>
        <ip>116.82.165.208</ip>
      </contributor>
      <comment>NullablePointer concept</comment>
      <text xml:space="preserve" bytes="1710">{{cpp/title|exception_ptr}}
{{cpp/error/navbar}}
{{ddcl | header=exception | since=c++11 | 1=
typedef /*unspecified*/ exception_ptr;
}}

{{tt|std::exception_ptr}} is a nullable pointer-like type that manages an exception object which has been thrown and captured with {{lc|std::current_exception}}. An instance of {{tt|std::exception_ptr}} may be passed to another function, possibly on another thread, where the exception may be rethrown and handled with a catch clause.

A default-constructed {{tt|std::exception_ptr}} is a null pointer; it does not point to an exception object.

Two instances of {{tt|std::exception_ptr}} compare equal only if they are both null or both point at the same exception object.

{{tt|std::exception_ptr}} is not implicitly convertible to any arithmetic, enumeration, or pointer type. It is convertible to {{tt|bool}}, and will evaluate to false if it is null, true otherwise.

The exception object referenced by an {{tt|std::exception_ptr}} remains valid as long as there remains at least one {{tt|std::exception_ptr}} that is referencing it: {{tt|std::exception_ptr}} is a shared-ownership smart pointer.

{{tt|std::exception_ptr}} meets the requirements of {{concept|NullablePointer}}.

===Example===
{{include| cpp/error/example_exception_ptr}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc make_exception_ptr}}
{{dsc inc | cpp/error/dsc current_exception}}
{{dsc inc | cpp/error/dsc rethrow_exception}}
{{dsc end}}

[[de:cpp/error/exception ptr]]
[[es:cpp/error/exception ptr]]
[[fr:cpp/error/exception ptr]]
[[it:cpp/error/exception ptr]]
[[ja:cpp/error/exception ptr]]
[[pt:cpp/error/exception ptr]]
[[ru:cpp/error/exception ptr]]
[[zh:cpp/error/exception ptr]]</text>
      <sha1>eiej4be9eh12yb27yfy0vv2d393l17i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/generic category</title>
    <ns>0</ns>
    <id>4832</id>
    <revision>
      <id>63310</id>
      <parentid>57373</parentid>
      <timestamp>2013-07-10T01:27:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1498">{{cpp/title|generic_category}}
{{cpp/error/navbar}}
{{ddcl | header=system_error | since=c++11 |
const std::error_category&amp; generic_category();
}}

Obtains a reference to the static error category object for generic errors. The object is required to override the virtual function {{c|error_category::name()}} to return a pointer to the string {{c|&quot;generic&quot;}}. It is used to identify error conditions that correspond to the POSIX {{lc|errno}} codes.

===Parameters===
(none)

===Return value===
A reference to the static object of unspecified runtime type, derived from {{lc|std::error_category}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;
#include &lt;cerrno&gt;
#include &lt;string&gt;
int main()
{
    std::error_condition econd = std::generic_category().default_error_condition(EDOM);
    std::cout &lt;&lt; &quot;Category: &quot; &lt;&lt; econd.category().name() &lt;&lt; '\n'
              &lt;&lt; &quot;Value: &quot; &lt;&lt; econd.value() &lt;&lt; '\n'
              &lt;&lt; &quot;Message: &quot; &lt;&lt; econd.message() &lt;&lt; '\n';
}
 | output=
Category: generic
Value: 33
Message: Numerical argument out of domain
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc system_category}}
{{dsc inc | cpp/error/dsc errc}}
{{dsc end}}

[[de:cpp/error/generic category]]
[[es:cpp/error/generic category]]
[[fr:cpp/error/generic category]]
[[it:cpp/error/generic category]]
[[ja:cpp/error/generic category]]
[[pt:cpp/error/generic category]]
[[ru:cpp/error/generic category]]
[[zh:cpp/error/generic category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/get terminate</title>
    <ns>0</ns>
    <id>5557</id>
    <revision>
      <id>72154</id>
      <parentid>62720</parentid>
      <timestamp>2014-07-19T14:20:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="957">{{cpp/title|get_terminate}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl | since=c++11 |1=
std::terminate_handler get_terminate();
}}
{{dcl end}}

Returns the currently installed {{lc|std::terminate_handler}}, which may be a null pointer.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Prior call to {{lc|std::set_terminate}} ''synchronizes-with'' (see {{lc|std::memory_order}}) this function.
}}
{{rev end}}
===Parameters===
(none)

===Return value===
The currently installed {{lc|std::terminate_handler}}.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc terminate_handler}}
{{dsc inc | cpp/error/dsc set_terminate}}
{{dsc end}}

[[de:cpp/error/get terminate]]
[[es:cpp/error/get terminate]]
[[fr:cpp/error/get terminate]]
[[it:cpp/error/get terminate]]
[[ja:cpp/error/get terminate]]
[[pt:cpp/error/get terminate]]
[[ru:cpp/error/get terminate]]
[[zh:cpp/error/get terminate]]</text>
      <sha1>mew6ijfh2tsqmia5yvlnnkrl0rwxi8x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/get unexpected</title>
    <ns>0</ns>
    <id>5572</id>
    <revision>
      <id>72159</id>
      <parentid>57377</parentid>
      <timestamp>2014-07-19T14:24:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="1032">{{cpp/title|get_unexpected}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl | notes={{mark since c++11}}{{mark deprecated}} |1=
std::unexpected_handler get_unexpected();
}}
{{dcl end}}

Returns the currently installed {{lc|std::unexpected_handler}}, which may be a null pointer.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Prior call to {{tt|std::set_unexpected}} ''synchronizes-with'' (see {{lc|std::memory_order}}) the subsequent calls to this function.
}}
{{rev end}}

===Parameters===
(none)

===Return value===
The currently installed {{lc|std::unexpected_handler}}.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc unexpected_handler}}
{{dsc inc | cpp/error/dsc set_unexpected}}
{{dsc end}}

[[de:cpp/error/get unexpected]]
[[es:cpp/error/get unexpected]]
[[fr:cpp/error/get unexpected]]
[[it:cpp/error/get unexpected]]
[[ja:cpp/error/get unexpected]]
[[pt:cpp/error/get unexpected]]
[[ru:cpp/error/get unexpected]]
[[zh:cpp/error/get unexpected]]</text>
      <sha1>eioahv4npvf5khzarq7bcdrm0fit2ak</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/invalid argument</title>
    <ns>0</ns>
    <id>2087</id>
    <revision>
      <id>70827</id>
      <parentid>57380</parentid>
      <timestamp>2014-05-30T19:51:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>usage note, related errc/errno</comment>
      <text xml:space="preserve" bytes="1157">{{cpp/title | invalid_argument}}
{{cpp/error/invalid_argument/navbar}}
{{ddcl | header=stdexcept |
class invalid_argument;
}}

Defines a type of object to be thrown as exception. It reports errors that arise because an argument value has not been accepted.

This exception is thrown by {{lc|std::bitset::bitset}}, and the {{lc|std::stoi}} and {{lc|std::stof}} families of functions.

{{inheritance diagram/std-invalid_argument}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|invalid_argument}}
{{dsc end}}

{{include|cpp/error/exception/constructor|invalid_argument}}

{{cpp/error/exception/inherit}}

===Notes===
The purpose of this exception type is similar to the error condition {{lc|std::errc::invalid_argument}} (thrown in {{lc|std::system_error}} from member functions of {{lc|std::thread}}) and the related errno constant {{lc|EINVAL}}.

[[de:cpp/error/invalid argument]]
[[es:cpp/error/invalid argument]]
[[fr:cpp/error/invalid argument]]
[[it:cpp/error/invalid argument]]
[[ja:cpp/error/invalid argument]]
[[pt:cpp/error/invalid argument]]
[[ru:cpp/error/invalid argument]]
[[zh:cpp/error/invalid argument]]</text>
      <sha1>p0rnal653is1z9dc64i2fm1qhls2jrv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/invalid argument/invalid argument</title>
    <ns>0</ns>
    <id>4501</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>47830</id>
      <parentid>42273</parentid>
      <timestamp>2013-05-16T22:27:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/error/invalid_argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/length error</title>
    <ns>0</ns>
    <id>2088</id>
    <revision>
      <id>70826</id>
      <parentid>70825</parentid>
      <timestamp>2014-05-30T19:45:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/]/}</comment>
      <text xml:space="preserve" bytes="966">{{cpp/title | length_error}}
{{cpp/error/length_error/navbar}}
{{ddcl | header=stdexcept |
class length_error;
}}

Defines a type of object to be thrown as exception. It reports errors that are consequence of attempt to exceed implementation defined length limits for some object.

This exception is thrown by member functions of {{lc|std::basic_string}} and {{lc|std::vector::reserve}}

{{inheritance diagram/std-length_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|length_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|length_error}}

{{cpp/error/exception/inherit}}


===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc resize}}
{{dsc end}}

[[de:cpp/error/length error]]
[[es:cpp/error/length error]]
[[fr:cpp/error/length error]]
[[it:cpp/error/length error]]
[[ja:cpp/error/length error]]
[[pt:cpp/error/length error]]
[[ru:cpp/error/length error]]
[[zh:cpp/error/length error]]</text>
      <sha1>dhytfc4s1xjxukrzajamyhma22r4vmd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/length error/length error</title>
    <ns>0</ns>
    <id>4502</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>47832</id>
      <parentid>42255</parentid>
      <timestamp>2013-05-16T22:27:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/length_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/logic error</title>
    <ns>0</ns>
    <id>2081</id>
    <revision>
      <id>70829</id>
      <parentid>57382</parentid>
      <timestamp>2014-05-30T19:55:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>usage note</comment>
      <text xml:space="preserve" bytes="1066">{{cpp/title | logic_error}}
{{cpp/error/logic_error/navbar}}
{{ddcl | header=stdexcept |
class logic_error;
}}

Defines a type of object to be thrown as exception. It reports errors that are a consequence of faulty logic within the program such as violating logical preconditions or class invariants and may be preventable.

No standard library components throw this exception directly, but the exception types 
{{lc|std::invalid_argument}}, {{lc|std::domain_error}}, {{lc|std::length_error}}, {{lc|std::out_of_range}}, and {{lc|std::future_error}} are derived from {{tt|std::logic_error}}.

{{inheritance diagram/std-logic_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|logic_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|logic_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/logic error]]
[[es:cpp/error/logic error]]
[[fr:cpp/error/logic error]]
[[it:cpp/error/logic error]]
[[ja:cpp/error/logic error]]
[[pt:cpp/error/logic error]]
[[ru:cpp/error/logic error]]
[[zh:cpp/error/logic error]]</text>
      <sha1>tlqrujidmzcyvz7ml8ca4s4xzdzho0v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/logic error/logic error</title>
    <ns>0</ns>
    <id>4500</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>47798</id>
      <parentid>42236</parentid>
      <timestamp>2013-05-16T21:33:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect  [[cpp/error/logic_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/make exception ptr</title>
    <ns>0</ns>
    <id>5612</id>
    <revision>
      <id>62327</id>
      <parentid>57385</parentid>
      <timestamp>2013-06-26T21:04:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1049">{{cpp/title|make_exception_ptr}}
{{cpp/error/navbar}}
{{ddcl | header=exception | since=c++11 |
template&lt; class E &gt;
std::exception_ptr make_exception_ptr( E e )
}}

Creates an {{lc|std::exception_ptr}} that holds a reference to a copy of {{tt|e}}. This is done as if executing the following code:

{{source|
try {
    throw e;
} catch(...) {
    return std::current_exception();
}
}}

===Parameters===
(none)

===Return value===
An instance of {{lc|std::exception_ptr}} holding a reference to the copy of {{tt|e}}, or to an instance of {{lc|std::bad_alloc}} or to an instance of {{lc|std::bad_exception}} (see {{lc|std::current_exception}}).

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc current_exception}}
{{dsc end}}

[[de:cpp/error/make exception ptr]]
[[es:cpp/error/make exception ptr]]
[[fr:cpp/error/make exception ptr]]
[[it:cpp/error/make exception ptr]]
[[ja:cpp/error/make exception ptr]]
[[pt:cpp/error/make exception ptr]]
[[ru:cpp/error/make exception ptr]]
[[zh:cpp/error/make exception ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception</title>
    <ns>0</ns>
    <id>4065</id>
    <revision>
      <id>70489</id>
      <parentid>63311</parentid>
      <timestamp>2014-05-24T04:18:14Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Non-member functions</comment>
      <text xml:space="preserve" bytes="1506">{{cpp/title|nested_exception}}
{{cpp/error/navbar}}
{{ddcl | header=exception | since=c++11 | 1=
class nested_exception;
}}

{{tt|std::nested_exceptions}} is a polymorphic mixin class which can capture and store the current exception, making it possible to nest exceptions of arbitrary types within each other.  

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/error/nested_exception/nested_exception | constructs a nested_exception}}
{{dsc mem vdtor | cpp/error/nested_exception/~nested_exception | destructs a nested exception}}
{{dsc mem fun | cpp/error/nested_exception/operator{{=}} | replaces the contents of a nested_exception}}
{{dsc mem fun | cpp/error/nested_exception/rethrow_nested | throws the stored exception}}
{{dsc mem fun | cpp/error/nested_exception/nested_ptr | obtains a pointer to the stored exception}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/error/dsc throw_with_nested}}
{{dsc inc | cpp/error/dsc rethrow_if_nested}}
{{dsc end}}

===Example===
{{include| cpp/error/example_nested_exception}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc inc | cpp/error/dsc throw_with_nested}}
{{dsc inc | cpp/error/dsc rethrow_if_nested}}
{{dsc end}}

[[de:cpp/error/nested exception]]
[[es:cpp/error/nested exception]]
[[fr:cpp/error/nested exception]]
[[it:cpp/error/nested exception]]
[[ja:cpp/error/nested exception]]
[[pt:cpp/error/nested exception]]
[[ru:cpp/error/nested exception]]
[[zh:cpp/error/nested exception]]</text>
      <sha1>n10ds58fzb5kghwvj9lzn7c2l8hiv6m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/nested exception</title>
    <ns>0</ns>
    <id>9885</id>
    <revision>
      <id>62721</id>
      <parentid>49514</parentid>
      <timestamp>2013-07-01T23:34:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="697">{{cpp/error/nested_exception/title|nested_exception}}
{{cpp/error/nested_exception/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
nested_exception();
}}
{{dcl | num=2 | since=c++11 | 1=
nested_exception( const nested_exception&amp; other ) = default;
}}
{{dcl end}}

Constructs new {{tt|nested_exception}} object.

@1@ Default constructor. Stores an exception object obtained by calling {{c|std::current_exception()}} within the new {{tt|nested_exception}} object.

@2@ Copy contructor. Initializes the object with the exception stored in {{tt|other}}. 

===Parameters===
{{par begin}}
{{par | other | nested exception to initialize the contents with}}
{{par end}}

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/nested ptr</title>
    <ns>0</ns>
    <id>9888</id>
    <revision>
      <id>63312</id>
      <parentid>46527</parentid>
      <timestamp>2013-07-10T01:28:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="287">{{cpp/error/nested_exception/title|nested_ptr}}
{{cpp/error/nested_exception/navbar}}
{{ddcl | since=c++11 | 1=
std::exception_ptr nested_ptr() const
}}

Returns a pointer to the stored exception, if any.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/operator=</title>
    <ns>0</ns>
    <id>9886</id>
    <revision>
      <id>63313</id>
      <parentid>49515</parentid>
      <timestamp>2013-07-10T01:28:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="427">{{cpp/error/nested_exception/title|operator{{=}}}}
{{cpp/error/nested_exception/navbar}}
{{ddcl | since=c++11 | 1=
nested_exception&amp; operator=( const nested_exception&amp; other ) = default;
}}

Replaces the stored exception with the one held in {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | nested exception to replace the contents with }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/rethrow nested</title>
    <ns>0</ns>
    <id>9887</id>
    <revision>
      <id>63314</id>
      <parentid>60955</parentid>
      <timestamp>2013-07-10T01:28:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="364">{{cpp/error/nested_exception/title|rethrow_nested}}
{{cpp/error/nested_exception/navbar}}
{{ddcl | since=c++11 | 1=
[[noreturn]] void rethrow_nested() const;
}}

Rethrows the stored exception. If there is no stored exceptions (i.e. {{lc|nested_ptr()}} returns null pointer), then {{lc|std::terminate}} is called.

===Parameters===
(none)

===Return value===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/throw with nested</title>
    <ns>0</ns>
    <id>13107</id>
    <redirect title="cpp/error/throw with nested" />
    <revision>
      <id>66709</id>
      <timestamp>2013-12-27T14:30:42Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/throw with nested]]</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/error/throw_with_nested]]</text>
      <sha1>17zbkz4z3pdce9k9je9hdgyr16k6l9q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/nested exception/~nested exception</title>
    <ns>0</ns>
    <id>9884</id>
    <revision>
      <id>63315</id>
      <parentid>46522</parentid>
      <timestamp>2013-07-10T01:28:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="200">{{cpp/error/nested_exception/title|~nested_exception}}
{{cpp/error/nested_exception/navbar}}
{{ddcl | since=c++11 |
virtual ~nested_exception() {{=}} default;
}}

Destroys the nested exception object.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/out of range</title>
    <ns>0</ns>
    <id>2089</id>
    <revision>
      <id>70848</id>
      <parentid>70824</parentid>
      <timestamp>2014-05-31T03:20:56Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1342">{{cpp/title | out_of_range}}
{{cpp/error/out_of_range/navbar}}
{{ddcl | header=stdexcept |
class out_of_range;
}}

Defines a type of object to be thrown as exception. It reports errors that are consequence of attempt to access elements out of defined range.

It may be thrown by the member functions of {{lc|std::bitset}} and {{lc|std::basic_string}}, by  {{lc|std::stoi}} and {{lc|std::stod}} families of functions, and by the bounds-checked member access functions (e.g. {{lc|std::vector::at}} and {{lc|std::map::at}})

{{inheritance diagram/std-out_of_range}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|out_of_range}}
{{dsc end}}

{{include|cpp/error/exception/constructor|out_of_range}}

{{cpp/error/exception/inherit}}

===Notes===
The standard error condition {{lc|std::errc::result_out_of_range}} typically indicates the condition where the result, rather than the input, is out of range, and is more closely related to {{lc|std::range_error}} and {{lc|ERANGE}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc at }}
{{dsc end}}

[[de:cpp/error/out of range]]
[[es:cpp/error/out of range]]
[[fr:cpp/error/out of range]]
[[it:cpp/error/out of range]]
[[ja:cpp/error/out of range]]
[[pt:cpp/error/out of range]]
[[ru:cpp/error/out of range]]
[[zh:cpp/error/out of range]]</text>
      <sha1>dk3evmicksthvj4npb5bkig6fm83z1n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/out of range/out of range</title>
    <ns>0</ns>
    <id>4503</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>47836</id>
      <parentid>42203</parentid>
      <timestamp>2013-05-16T22:28:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/out_of_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/overflow error</title>
    <ns>0</ns>
    <id>2084</id>
    <revision>
      <id>70819</id>
      <parentid>70817</parentid>
      <timestamp>2014-05-30T19:03:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+bitset throws this</comment>
      <text xml:space="preserve" bytes="1410">{{cpp/title | overflow_error}}
{{cpp/error/overflow_error/navbar}}
{{ddcl | header=stdexcept |
class overflow_error;
}}

Defines a type of object to be thrown as exception. It can be used to report arithmetic overflow errors (that is, situations where a result of a computation is too large for the destination type)

The only standard library components that throw this exception are {{lc|std::bitset::to_ulong}} and {{lc|std::bitset::to_ullong}}.

The mathematical functions of the standard library components do not throw this exception (mathematical functions report overflow errors as specified in {{lc|math_errhandling}}). Third-party libraries, however, use this. For example, [http://www.boost.org/doc/libs/1_55_0/libs/math/doc/html/math_toolkit/error_handling.html boost.math] throws {{tt|std::overflow_error}} if {{tt|boost::math::policies::throw_on_error}} is enabled (the default setting).

{{inheritance diagram/std-overflow_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|overflow_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|overflow_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/overflow error]]
[[es:cpp/error/overflow error]]
[[fr:cpp/error/overflow error]]
[[it:cpp/error/overflow error]]
[[ja:cpp/error/overflow error]]
[[pt:cpp/error/overflow error]]
[[ru:cpp/error/overflow error]]
[[zh:cpp/error/overflow error]]</text>
      <sha1>qh4zxa64s404mwtaqy3mzhzbkaw4e2z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/overflow error/overflow error</title>
    <ns>0</ns>
    <id>4505</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>47834</id>
      <parentid>42189</parentid>
      <timestamp>2013-05-16T22:28:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/error/overflow_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/range error</title>
    <ns>0</ns>
    <id>2085</id>
    <revision>
      <id>72071</id>
      <parentid>70822</parentid>
      <timestamp>2014-07-11T20:32:11Z</timestamp>
      <contributor>
        <username>Gsauthof</username>
        <id>3226</id>
      </contributor>
      <comment>restore inheritance diagram</comment>
      <text xml:space="preserve" bytes="1105">{{cpp/title | range_error}}
{{cpp/error/range_error/navbar}}
{{ddcl | header=stdexcept |
class range_error;
}}

Defines a type of object to be thrown as exception. It can be used to report range errors (that is, situations where a result of a computation cannot be represented by the destination type)

The only standard library components that throw this exception are {{lc|std::wstring_convert::from_bytes}} and {{lc|std::wstring_convert::to_bytes}}.

The mathematical functions in the standard library components do not throw this exception (mathematical functions report range errors as specified in {{lc|math_errhandling}}).

{{inheritance diagram/std-range_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|range_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|range_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/range error]]
[[es:cpp/error/range error]]
[[fr:cpp/error/range error]]
[[it:cpp/error/range error]]
[[ja:cpp/error/range error]]
[[pt:cpp/error/range error]]
[[ru:cpp/error/range error]]
[[zh:cpp/error/range error]]</text>
      <sha1>sqdjv32m2pzl3k8rc1t7a6lfj7vpido</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/range error/range error</title>
    <ns>0</ns>
    <id>6726</id>
    <redirect title="cpp/error/range error" />
    <revision>
      <id>47837</id>
      <parentid>42173</parentid>
      <timestamp>2013-05-16T22:28:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/range error]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/error/range_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/rethrow exception</title>
    <ns>0</ns>
    <id>5608</id>
    <revision>
      <id>63316</id>
      <parentid>57394</parentid>
      <timestamp>2013-07-10T01:28:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="847">{{cpp/title|rethrow_exception}}
{{cpp/error/navbar}}

{{ddcl | header=exception | since=c++11 |
[[noreturn]] void rethrow_exception( std::exception_ptr p )
}}

Throws the previously captured exception object, referred to by the exception pointer {{tt|p}}.

===Parameters===
{{par begin}}
{{par | p | non-null {{lc|std::exception_ptr}} }}
{{par end}}

===Return value===
(none)

===Example===
{{include| cpp/error/example_exception_ptr}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc inc | cpp/error/dsc current_exception}}
{{dsc end}}

[[de:cpp/error/rethrow exception]]
[[es:cpp/error/rethrow exception]]
[[fr:cpp/error/rethrow exception]]
[[it:cpp/error/rethrow exception]]
[[ja:cpp/error/rethrow exception]]
[[pt:cpp/error/rethrow exception]]
[[ru:cpp/error/rethrow exception]]
[[zh:cpp/error/rethrow exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/rethrow if nested</title>
    <ns>0</ns>
    <id>5555</id>
    <revision>
      <id>72306</id>
      <parentid>63317</parentid>
      <timestamp>2014-08-07T10:40:05Z</timestamp>
      <contributor>
        <ip>193.40.6.84</ip>
      </contributor>
      <comment>dynamic type, not static type</comment>
      <text xml:space="preserve" bytes="1058">{{cpp/title|rethrow_if_nested}}
{{cpp/error/navbar}}

{{ddcl | header=exception | since=c++11 |
template&lt; class E &gt;
void rethrow_if_nested( const E&amp; e );
}}

If the dynamic type (the most derived type) of the object referenced by {{tt|e}} is publicly and unambiguously derived from {{lc|std::nested_exception}}, extracts and throws the nested exception as if by calling {{c|dynamic_cast&lt;const std::nested_exception&amp;&gt;(e).rethrow_nested()}}. Otherwise, does nothing.

===Parameters===
{{par begin}}
{{par | e | the exception object to rethrow}}
{{par end}}

===Return value===
(none)

===Example===
{{include| cpp/error/example_nested_exception}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc nested_exception}}
{{dsc inc | cpp/error/dsc throw_with_nested}}
{{dsc end}}

[[de:cpp/error/rethrow if nested]]
[[es:cpp/error/rethrow if nested]]
[[fr:cpp/error/rethrow if nested]]
[[it:cpp/error/rethrow if nested]]
[[ja:cpp/error/rethrow if nested]]
[[pt:cpp/error/rethrow if nested]]
[[ru:cpp/error/rethrow if nested]]
[[zh:cpp/error/rethrow if nested]]</text>
      <sha1>4zp6u3shdo1opk8u9d3hocgzjo9oprv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/runtime error</title>
    <ns>0</ns>
    <id>2082</id>
    <revision>
      <id>70823</id>
      <parentid>57396</parentid>
      <timestamp>2014-05-30T19:35:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>usage note</comment>
      <text xml:space="preserve" bytes="1159">{{cpp/title | runtime_error}}
{{cpp/error/runtime_error/navbar}}
{{ddcl | header=stdexcept |
class runtime_error;
}}

Defines a type of object to be thrown as exception. It reports errors that are due to events beyond the scope of the program and can not be easily predicted. 

Exceptions of type {{tt|std:runtime_error}} are thrown by the following standard library components: {{lc|std::locale::locale}} and {{lc|std::locale::combine}}.

In addition, the standard exception types {{lc|std::range_error}}, {{lc|std::overflow_error}}, {{lc|std::underflow_error}}, {{lc|std::regex_error}}, and {{lc|std::system_error}} are derived from {{tt|std::runtime_error}}.

{{inheritance diagram/std-runtime_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|runtime_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|runtime_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/runtime error]]
[[es:cpp/error/runtime error]]
[[fr:cpp/error/runtime error]]
[[it:cpp/error/runtime error]]
[[ja:cpp/error/runtime error]]
[[pt:cpp/error/runtime error]]
[[ru:cpp/error/runtime error]]
[[zh:cpp/error/runtime error]]</text>
      <sha1>d8sb0cr2ts2dtdpt36jdrjc7myn2hsn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/runtime error/runtime error</title>
    <ns>0</ns>
    <id>4504</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>47833</id>
      <parentid>42137</parentid>
      <timestamp>2013-05-16T22:28:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/error/runtime_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/set terminate</title>
    <ns>0</ns>
    <id>5558</id>
    <revision>
      <id>72153</id>
      <parentid>64861</parentid>
      <timestamp>2014-07-19T14:19:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety rule from 17.6.4.7/4</comment>
      <text xml:space="preserve" bytes="1321">{{cpp/title|set_terminate}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl | 1=
std::terminate_handler set_terminate( std::terminate_handler f )
}}
{{dcl end}}

Makes {{tt|f}} the new global terminate handler function and returns the previously installed {{lc|std::terminate_handler}}.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Every call to {{tt|std::set_terminate}} ''synchronizes-with'' (see {{lc|std::memory_order}}) the subsequent {{tt|std::set_terminate}} and {{lc|std::get_terminate}}
}}
{{rev end}}
===Parameters===
{{par begin}}
{{par | f | pointer to function of type {{lc|std::terminate_handler}}, or null pointer}}
{{par end}}

===Return value===
The previously-installed terminate handler, or a null pointer value if none was installed.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc terminate}}
{{dsc inc | cpp/error/dsc get_terminate}}
{{dsc inc | cpp/error/dsc terminate_handler}}
{{dsc end}}

[[de:cpp/error/set terminate]]
[[es:cpp/error/set terminate]]
[[fr:cpp/error/set terminate]]
[[it:cpp/error/set terminate]]
[[ja:cpp/error/set terminate]]
[[pt:cpp/error/set terminate]]
[[ru:cpp/error/set terminate]]
[[zh:cpp/error/set terminate]]</text>
      <sha1>2nor55my17qqfavi9zn9p9zssuyc725</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/set unexpected</title>
    <ns>0</ns>
    <id>5573</id>
    <revision>
      <id>72158</id>
      <parentid>64864</parentid>
      <timestamp>2014-07-19T14:24:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="1356">{{cpp/title|set_unexpected}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl | 1=
std::unexpected_handler set_unexpected( std::unexpected_handler f )
}}
{{dcl end}}

Makes {{tt|f}} the new global {{lc|std::unexpected_handler}} and returns the previously installed {{lc|std::unexpected_handler}}.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Every call to {{tt|std::set_unexpected}} ''synchronizes-with'' (see {{lc|std::memory_order}}) the subsequent calls to {{tt|std::set_unexpected}} and {{lc|std::get_unexpected}}
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | f | pointer to function of type {{lc|std::unexpected_handler}}, or null pointer}}
{{par end}}

===Return value===
The previously-installed unexpected handler, or a null pointer value if none was installed.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc unexpected}}
{{dsc inc | cpp/error/dsc get_unexpected}}
{{dsc inc | cpp/error/dsc unexpected_handler}}
{{dsc end}}

[[de:cpp/error/set unexpected]]
[[es:cpp/error/set unexpected]]
[[fr:cpp/error/set unexpected]]
[[it:cpp/error/set unexpected]]
[[ja:cpp/error/set unexpected]]
[[pt:cpp/error/set unexpected]]
[[ru:cpp/error/set unexpected]]
[[zh:cpp/error/set unexpected]]</text>
      <sha1>8ht21i0iw41ix8j3gjvpo4fxtqym9f8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system category</title>
    <ns>0</ns>
    <id>4833</id>
    <revision>
      <id>63318</id>
      <parentid>57403</parentid>
      <timestamp>2013-07-10T01:28:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1920">{{cpp/title|system_category}}
{{cpp/error/navbar}}
{{ddcl | header=system_error | since=c++11 |
const std::error_category&amp; system_category();
}}

Obtains a reference to the static error category object for errors reported by the operating system. The object is required to override the virtual function {{c|error_category::name()}} to return a pointer to the string {{c|&quot;system&quot;}}. It is also required to override the virtual function {{c|error_category::default_error_condition()}} to map the error codes that match POSIX {{lc|errno}} values to {{lc|std::generic_category}}.

===Parameters===
(none)

===Return value===
A reference to the static object of unspecified runtime type, derived from {{lc|std::error_category}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;

int main()
{
    std::error_condition econd = std::system_category().default_error_condition(EDOM);
    std::cout &lt;&lt; &quot;Category: &quot; &lt;&lt; econd.category().name() &lt;&lt; '\n'
              &lt;&lt; &quot;Value: &quot; &lt;&lt; econd.value() &lt;&lt; '\n'
              &lt;&lt; &quot;Message: &quot; &lt;&lt; econd.message() &lt;&lt; '\n';

    econd = std::system_category().default_error_condition(10001);
    std::cout &lt;&lt; &quot;Category: &quot; &lt;&lt; econd.category().name() &lt;&lt; '\n'
              &lt;&lt; &quot;Value: &quot; &lt;&lt; econd.value() &lt;&lt; '\n'
              &lt;&lt; &quot;Message: &quot; &lt;&lt; econd.message() &lt;&lt; '\n';
}
 | output=
Category: generic
Value: 33
Message: Numerical argument out of domain
Category: system
Value: 10001
Message: Unknown error 10001
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc generic_category}}
{{dsc inc | cpp/error/dsc errc}}
{{dsc end}}

[[de:cpp/error/system category]]
[[es:cpp/error/system category]]
[[fr:cpp/error/system category]]
[[it:cpp/error/system category]]
[[ja:cpp/error/system category]]
[[pt:cpp/error/system category]]
[[ru:cpp/error/system category]]
[[zh:cpp/error/system category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error</title>
    <ns>0</ns>
    <id>5447</id>
    <revision>
      <id>69432</id>
      <parentid>62722</parentid>
      <timestamp>2014-04-08T17:33:47Z</timestamp>
      <contributor>
        <username>C.m.brandenburg</username>
        <id>2248</id>
      </contributor>
      <minor/>
      <comment>grammar fix for summary</comment>
      <text xml:space="preserve" bytes="1385">{{cpp/title|system_error}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | system_error}}
{{dcl | since=c++11 | 1=
class system_error;
}}
{{dcl end}}

{{tt|std::system_error}} is the type of the exception thrown by various library functions (typically the functions that interface with the OS facilities, e.g. the constructor of {{lc|std::thread}}) when the exception has an associated {{lc|std::error_code}}, which may be reported.

{{inheritance diagram/std-system_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/system_error/dsc constructor}}
{{dsc inc | cpp/error/system_error/dsc code}}
{{dsc inc | cpp/error/system_error/dsc what}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;system_error&gt;

int main()
{
    try {
        std::thread().detach(); // attempt to detach a non-thread
    } catch(const std::system_error&amp; e) {
        std::cout &lt;&lt; &quot;Caught system_error with code &quot; &lt;&lt; e.code() 
                  &lt;&lt; &quot; meaning &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Caught system_error with code generic:22 meaning Invalid argument
}}

[[de:cpp/error/system error]]
[[es:cpp/error/system error]]
[[fr:cpp/error/system error]]
[[it:cpp/error/system error]]
[[ja:cpp/error/system error]]
[[pt:cpp/error/system error]]
[[ru:cpp/error/system error]]
[[zh:cpp/error/system error]]</text>
      <sha1>c8qvih5ycw3w9lfk0u9ghwilvls0o30</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/code</title>
    <ns>0</ns>
    <id>8971</id>
    <revision>
      <id>63319</id>
      <parentid>57407</parentid>
      <timestamp>2013-07-10T01:28:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="634">{{cpp/error/system_error/title|code}}
{{cpp/error/system_error/navbar}}
{{ddcl | since=c++11 |
const std::error_code&amp; code() const;
}}

Returns the stored error code.

===Parameters===
(none)

===Return value===
The stored error code.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/system_error/dsc what}}
{{dsc end}}

[[de:cpp/error/system error/code]]
[[es:cpp/error/system error/code]]
[[fr:cpp/error/system error/code]]
[[it:cpp/error/system error/code]]
[[ja:cpp/error/system error/code]]
[[pt:cpp/error/system error/code]]
[[ru:cpp/error/system error/code]]
[[zh:cpp/error/system error/code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/errc</title>
    <ns>0</ns>
    <id>6644</id>
    <redirect title="cpp/error/errc" />
    <revision>
      <id>26003</id>
      <timestamp>2012-04-29T08:18:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/errc]] to [[cpp/error/errc]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/error/errc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/error category</title>
    <ns>0</ns>
    <id>6645</id>
    <redirect title="cpp/error/error category" />
    <revision>
      <id>26005</id>
      <timestamp>2012-04-29T08:18:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/error category]] to [[cpp/error/error category]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/error category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/error code</title>
    <ns>0</ns>
    <id>6646</id>
    <redirect title="cpp/error/error code" />
    <revision>
      <id>26007</id>
      <timestamp>2012-04-29T08:18:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/error code]] to [[cpp/error/error code]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/error/error code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/error code/hash</title>
    <ns>0</ns>
    <id>6647</id>
    <redirect title="cpp/error/error code/hash" />
    <revision>
      <id>26009</id>
      <timestamp>2012-04-29T08:18:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/error code/hash]] to [[cpp/error/error code/hash]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/error code/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/error condition</title>
    <ns>0</ns>
    <id>6648</id>
    <redirect title="cpp/error/error condition" />
    <revision>
      <id>26011</id>
      <timestamp>2012-04-29T08:18:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/error condition]] to [[cpp/error/error condition]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/generic category</title>
    <ns>0</ns>
    <id>6649</id>
    <redirect title="cpp/error/generic category" />
    <revision>
      <id>26013</id>
      <timestamp>2012-04-29T08:18:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/generic category]] to [[cpp/error/generic category]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/error/generic category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/system category</title>
    <ns>0</ns>
    <id>6650</id>
    <redirect title="cpp/error/system category" />
    <revision>
      <id>26015</id>
      <timestamp>2012-04-29T08:18:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/error/system error/system category]] to [[cpp/error/system category]]: merge cpp/error/exception and cpp/error/system_error paths to cpp/error</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/system category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/system error</title>
    <ns>0</ns>
    <id>6651</id>
    <revision>
      <id>64307</id>
      <parentid>62723</parentid>
      <timestamp>2013-08-15T16:30:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="2273">{{cpp/error/system_error/title|system_error}}
{{cpp/error/system_error/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
system_error( std::error_code ec );
}}
{{dcl | num=2 | since=c++11 |
system_error( std::error_code ec, const std::string&amp; what_arg );
}}
{{dcl | num=2 | since=c++11 |
system_error( std::error_code ec, const char* what_arg );
}}
{{dcl | num=3 | since=c++11 |
system_error( int ev, const std::error_category&amp; ecat );
}}
{{dcl | num=4 | since=c++11 |
system_error( int ev, const std::error_category&amp; ecat,
              const std::string&amp; what_arg);
}}
{{dcl | num=4 | since=c++11 |
system_error( int ev, const std::error_category&amp; ecat,
              const char* what_arg);
}}
{{dcl end}}

Constructs new system error object.

@1@ Constructs with error code {{tt|ec}}
@2@ Constructs with error code {{tt|ec}} and explanation string {{tt|what_arg}}. The string returned by {{lc|what()}} is guaranteed to contain {{tt|what_arg}}.
@3@ Constructs with underlying error code {{tt|ev}} and associated error category {{tt|ecat}}.
@4@ Constructs with underlying error code {{tt|ev}}, associated error category {{tt|ecat}} and explanatory string {{tt|what_arg}}. The string returned by {{lc|what()}} is guaranteed to contain {{tt|what_arg}}.

===Parameters===
{{par begin}}
{{par | ec | error code}}
{{par | ev | error code in base encoding}}
{{par | ecat | the category of error}}
{{par | what_arg | explanatory string}}
{{par end}}

===Example===
{{example
 | Demonstrates how to create a system_error exception from a errno value 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;

int main()
{
    try
    {
        throw std::system_error(EDOM, std::system_category());
    }
    catch (const std::system_error&amp; error)
    {
        std::cout &lt;&lt; &quot;Error: &quot; &lt;&lt; error.code()
                  &lt;&lt; &quot; - &quot; &lt;&lt; error.code().message() &lt;&lt; '\n';
    }
}
 | output=
Error: system:33 - Numerical argument out of domain
}}

[[de:cpp/error/system error/system error]]
[[es:cpp/error/system error/system error]]
[[fr:cpp/error/system error/system error]]
[[it:cpp/error/system error/system error]]
[[ja:cpp/error/system error/system error]]
[[pt:cpp/error/system error/system error]]
[[ru:cpp/error/system error/system error]]
[[zh:cpp/error/system error/system error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/system error/what</title>
    <ns>0</ns>
    <id>8972</id>
    <revision>
      <id>63320</id>
      <parentid>57410</parentid>
      <timestamp>2013-07-10T01:28:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="676">{{cpp/error/system_error/title|what}}
{{cpp/error/system_error/navbar}}
{{ddcl | since=c++11 |
virtual const char* what() const;
}}

Returns the explanatory string.

===Parameters===
(none)

===Return value===
Pointer to a null-terminated string with explanatory information. 

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/system_error/dsc code}}
{{dsc end}}

[[de:cpp/error/system error/what]]
[[es:cpp/error/system error/what]]
[[fr:cpp/error/system error/what]]
[[it:cpp/error/system error/what]]
[[ja:cpp/error/system error/what]]
[[pt:cpp/error/system error/what]]
[[ru:cpp/error/system error/what]]
[[zh:cpp/error/system error/what]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/terminate</title>
    <ns>0</ns>
    <id>5556</id>
    <revision>
      <id>71867</id>
      <parentid>64849</parentid>
      <timestamp>2014-06-29T17:08:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link throw</comment>
      <text xml:space="preserve" bytes="2319">{{cpp/title|terminate}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl rev begin}}
{{dcl | until=c++11 |
void terminate();
}}
{{dcl | since=c++11 |
[[noreturn]] void terminate();
}}
{{dcl rev end}}
{{dcl end}}

{{tt|std::terminate()}} is called by the C++ runtime when exception handling fails for any of the following reasons:

@1@ an [[cpp/language/throw|exception is thrown]] and not caught (it is implementation-defined whether any stack unwinding is done in this case)

@2@ an exception is thrown during exception handling (e.g. from a destructor of some local object, or from a function that had to be called during exception handling)

@3@ the constructor or the destructor of a static or thread-local object throws an exception

@4@ a function registered with {{lc|std::atexit}} or {{lc|std::at_quick_exit}} throws an exception

@5@ a [[cpp/language/noexcept_spec|noexcept specification]] is violated (it is implementation-defined whether any stack unwinding is done in this case)

@6@ a [[cpp/language/except_spec|dynamic exception specification]] is violated and the default handler for {{lc|std::unexpected}} is executed

@7@ a non-default handler for {{lc|std::unexpected}} throws an exception that violates the previously violated dynamic exception specification, if the specification does not include {{lc|std::bad_exception}}

@8@ {{c|std::nested_exception::rethrow_nested}} is called for an object that isn't holding a captured exception

@9@ an exception is thrown from the initial function of {{lc|std::thread}}

@10@ a joinable {{lc|std::thread}} is destroyed or assigned to

{{tt|std::terminate()}} may also be called directly from the program.


In any case, {{tt|std::terminate}} calls the currently installed {{lc|std::terminate_handler}}. The default {{lc|std::terminate_handler}} calls {{lc|std::abort}}.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc terminate_handler}}
{{dsc end}}

[[de:cpp/error/terminate]]
[[es:cpp/error/terminate]]
[[fr:cpp/error/terminate]]
[[it:cpp/error/terminate]]
[[ja:cpp/error/terminate]]
[[pt:cpp/error/terminate]]
[[ru:cpp/error/terminate]]
[[zh:cpp/error/terminate]]</text>
      <sha1>d0ul1p2ncorbetotk2xs7sy6otplcz5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/terminate handler</title>
    <ns>0</ns>
    <id>5559</id>
    <revision>
      <id>57414</id>
      <parentid>49531</parentid>
      <timestamp>2013-06-01T05:53:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1120">{{cpp/title|terminate_handler}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl |1=
typedef void (*terminate_handler)();
}}
{{dcl end}}

{{tt|std::terminate_handler}} is the function pointer type (pointer to function that takes no arguments and returns void), which is installed and queried by the functions {{lc|std::set_terminate}} and {{lc|std::get_terminate}} and called by {{lc|std::terminate}}.

The C++ implementation provides a default {{tt|std::terminate_handler}} function, which calls {{c|std::abort()}}. If the null pointer value is installed (by means of {{lc|std::set_terminate}}), the implementation may restore the default handler instead.

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc terminate}}
{{dsc inc | cpp/error/dsc set_terminate}}
{{dsc inc | cpp/error/dsc get_terminate}}
{{dsc end}}

[[de:cpp/error/terminate handler]]
[[es:cpp/error/terminate handler]]
[[fr:cpp/error/terminate handler]]
[[it:cpp/error/terminate handler]]
[[ja:cpp/error/terminate handler]]
[[pt:cpp/error/terminate handler]]
[[ru:cpp/error/terminate handler]]
[[zh:cpp/error/terminate handler]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/throw with nested</title>
    <ns>0</ns>
    <id>5554</id>
    <revision>
      <id>63321</id>
      <parentid>57415</parentid>
      <timestamp>2013-07-10T01:28:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1347">{{cpp/title|throw_with_nested}}
{{cpp/error/navbar}}

{{ddcl | header=exception | since=c++11 |
template&lt; class T &gt;
[[noreturn]] void throw_with_nested( T&amp;&amp; t );
}}

Throws an exception of unspecified type that is derived from both {{lc|std::nested_exception}} and from {{c|std::remove_reference&lt;T&gt;::type}}, and constructed from {{c|std::forward&lt;T&gt;(t)}}. The default constructor of the nested_exception parent calls {{lc|std::current_exception}}, capturing the currently handled exception object, if any, in {{lc|std::exception_ptr}}. 

If {{c|std::remove_reference&lt;T&gt;::type}} is already derived from {{lc|std::nested_exception}}, simply throws {{c|std::forward&lt;T&gt;(t)}}.

Requires that {{c|std::remove_reference&lt;T&gt;::type}} is {{concept|CopyConstructible}}

===Parameters===
{{par begin}}
{{par | t | the exception object to throw}}
{{par end}}

===Return value===
(none)

===Example===
{{include| cpp/error/example_nested_exception}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc nested_exception}}
{{dsc inc | cpp/error/dsc rethrow_if_nested}}
{{dsc end}}

[[de:cpp/error/throw with nested]]
[[es:cpp/error/throw with nested]]
[[fr:cpp/error/throw with nested]]
[[it:cpp/error/throw with nested]]
[[ja:cpp/error/throw with nested]]
[[pt:cpp/error/throw with nested]]
[[ru:cpp/error/throw with nested]]
[[zh:cpp/error/throw with nested]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/uncaught exception</title>
    <ns>0</ns>
    <id>3512</id>
    <revision>
      <id>64831</id>
      <parentid>57418</parentid>
      <timestamp>2013-08-27T01:17:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="2169">{{cpp/title|uncaught_exception}}
{{cpp/error/navbar}}
{{ddcl | header=exception| 
bool uncaught_exception();
}}

Detects if the current thread has a live exception object, that is, an exception has been thrown and not yet entered a matching catch clause, {{lc|std::terminate}} or {{lc|std::unexpected}}. In other words, {{lc|std::uncaught_exception}} detects if stack unwinding is currently in progress.

Sometimes it's safe to throw an exception even while {{c|1=std::uncaught_exception() == true}}. For example, if stack unwinding causes a stack-allocated object to be destructed, the destructor for that object could run code that throws an exception as long as the exception is caught by some catch block before escaping the destructor.

===Parameters===
(none)

===Return value===
{{c|true}} if stack unwinding is currently in progress in this thread.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;exception&gt;
#include &lt;stdexcept&gt;

struct Foo {
    ~Foo() {
        if (std::uncaught_exception()) {
            std::cout &lt;&lt; &quot;~Foo() called during stack unwinding\n&quot;;
        } else {
            std::cout &lt;&lt; &quot;~Foo() called normally\n&quot;;
        }
    }
};
int main()
{
    Foo f;
    try {
        Foo f;
        std::cout &lt;&lt; &quot;Exception thrown\n&quot;;
        throw std::runtime_error(&quot;test exception&quot;);
    } catch (const std::exception&amp; e) {
        std::cout &lt;&lt; &quot;Exception caught: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Exception thrown
~Foo() called during stack unwinding
Exception caught: test exception
~Foo() called normally
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc terminate}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc end}}

===External links===
[http://www.gotw.ca/gotw/047.htm GOTW issue 47: Uncaught Exceptions]

[[de:cpp/error/uncaught exception]]
[[es:cpp/error/uncaught exception]]
[[fr:cpp/error/uncaught exception]]
[[it:cpp/error/uncaught exception]]
[[ja:cpp/error/uncaught exception]]
[[pt:cpp/error/uncaught exception]]
[[ru:cpp/error/uncaught exception]]
[[zh:cpp/error/uncaught exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/underflow error</title>
    <ns>0</ns>
    <id>2083</id>
    <revision>
      <id>70818</id>
      <parentid>64344</parentid>
      <timestamp>2014-05-30T18:59:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>usage note</comment>
      <text xml:space="preserve" bytes="1265">{{cpp/title | underflow_error}}
{{cpp/error/underflow_error/navbar}}
{{ddcl | header=stdexcept |
class underflow_error;
}}

Defines a type of object to be thrown as exception. It may be used to report arithmetic underflow errors (that is, situations where the result of a computation is a subnormal floating-point value)

The standard library components do not throw this exception (mathematical functions report underflow errors as specified in {{lc|math_errhandling}}). Third-party libraries, however, use this. For example, [http://www.boost.org/doc/libs/1_55_0/libs/math/doc/html/math_toolkit/error_handling.html boost.math] throws {{tt|std::underflow_error}} if {{tt|boost::math::policies::throw_on_error}} is enabled (the default setting).

{{inheritance diagram/std-underflow_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc constructor|underflow_error}}
{{dsc end}}

{{include|cpp/error/exception/constructor|underflow_error}}

{{cpp/error/exception/inherit}}

[[de:cpp/error/underflow error]]
[[es:cpp/error/underflow error]]
[[fr:cpp/error/underflow error]]
[[it:cpp/error/underflow error]]
[[ja:cpp/error/underflow error]]
[[pt:cpp/error/underflow error]]
[[ru:cpp/error/underflow error]]
[[zh:cpp/error/underflow error]]</text>
      <sha1>c9cgy7aairkqtu3mi8zo6wutkmzeej5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/underflow error/underflow error</title>
    <ns>0</ns>
    <id>4506</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>47835</id>
      <parentid>42022</parentid>
      <timestamp>2013-05-16T22:28:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/error/underflow_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/unexpected</title>
    <ns>0</ns>
    <id>5570</id>
    <revision>
      <id>72173</id>
      <parentid>64863</parentid>
      <timestamp>2014-07-20T10:32:47Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>correct the /* Exceptions */ part</comment>
      <text xml:space="preserve" bytes="1214">{{cpp/title|unexpected}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl rev begin}}
{{dcl | until=c++11 |
void unexpected();
}}
{{dcl | notes={{mark deprecated}} | since=c++11 |
[[noreturn]] void unexpected();
}}
{{dcl rev end}}
{{dcl end}}

{{tt|std::unexpected()}} is called by the C++ runtime when a [[cpp/language/except_spec|dynamic exception specification]] is violated: an exception is thrown from a function whose exception specification forbids exceptions of this type.

{{tt|std::unexpected()}} may also be called directly from the program.

In either case, {{tt|std::unexpected}} calls the currently installed {{lc|std::unexpected_handler}}. The default {{lc|std::unexpected_handler}} calls {{lc|std::terminate}}.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
Throw any exception thrown by the currently installed {{lc|std::unexpected_handler}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc unexpected_handler}}
{{dsc end}}

[[de:cpp/error/unexpected]]
[[es:cpp/error/unexpected]]
[[fr:cpp/error/unexpected]]
[[it:cpp/error/unexpected]]
[[ja:cpp/error/unexpected]]
[[pt:cpp/error/unexpected]]
[[ru:cpp/error/unexpected]]
[[zh:cpp/error/unexpected]]</text>
      <sha1>t54osemn59ey0x4hl3xxvhh7cwir15l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/error/unexpected handler</title>
    <ns>0</ns>
    <id>5571</id>
    <revision>
      <id>57423</id>
      <parentid>49536</parentid>
      <timestamp>2013-06-01T05:53:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1997">{{cpp/title|unexpected_handler}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | exception}}
{{dcl | notes={{mark deprecated}} |
typedef void (*unexpected_handler)();
}}
{{dcl end}}

{{tt|std::unexpected_handler}} is the function pointer type (pointer to function that takes no arguments and returns void), which is installed and queried by the functions {{lc|std::set_unexpected}} and {{lc|std::get_unexpected}} and called by {{lc|std::unexpected}}.

The C++ implementation provides a default {{tt|std::unexpected_handler}} function, which calls {{c|std::terminate()}}. If the null pointer value is installed (by means of {{lc|std::set_unexpected}}), the implementation may restore the default handler instead.

A user-defined {{tt|std::unexpected_handler}} is expected to either terminate the program or throw an exception. If it throws an exception, one of the following three situations may be encountered:

1) the exception thrown by {{tt|std::unexpected_handler}} satisfies the dynamic exception specification that was violated earlier. The new exception is allowed to escape the function and stack unwinding continues.

2) the exception thrown by {{tt|std::unexpected_handler}} still violates the exception specification:

2a) however, the exception specification allows {{lc|std::bad_exception}}: the thrown exception object is destroyed, and {{lc|std::bad_exception}} is constructed by the C++ runtime and thrown instead.

2b) the exception specification does not allow {{lc|std::bad_exception}}: {{c|std::terminate()}} is called.

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc unexpected}}
{{dsc inc | cpp/error/dsc set_unexpected}}
{{dsc inc | cpp/error/dsc get_unexpected}}
{{dsc end}}

[[de:cpp/error/unexpected handler]]
[[es:cpp/error/unexpected handler]]
[[fr:cpp/error/unexpected handler]]
[[it:cpp/error/unexpected handler]]
[[ja:cpp/error/unexpected handler]]
[[pt:cpp/error/unexpected handler]]
[[ru:cpp/error/unexpected handler]]
[[zh:cpp/error/unexpected handler]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental</title>
    <ns>0</ns>
    <id>13460</id>
    <revision>
      <id>72041</id>
      <parentid>72040</parentid>
      <timestamp>2014-07-09T19:30:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fmt and date old TR links</comment>
      <text xml:space="preserve" bytes="3160">{{title|Experimental C++ standard libraries}}
{{cpp/navbar}}

The C++ standards committee publishes experimental C++ language and library extensions for future standardization.

Note: until 2012, these publications used the TR (technical report) format. Since 2012 ISO procedure changed to use the TS (technical specification) format.

{|table class=wikitable
|-
!ISO number||Name||Status||links
|-
| ISO/IEC TR 19768:2007
| Technical Report on C++ Library Extensions
| Published 2007-xx-xx ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=43289 ISO store])
Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf n1745] (2005-01-17)&lt;br&gt;
TR 29124 split off, the rest merged into C++11
|
|-
| ISO/IEC TR 29124:2010
| Extensions to the C++ Library to support mathematical special functions
| Published 2010-09-03 ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=50511 ISO Store])
Final draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3060.pdf n3060] (2010-03-06)
|
|-
| ISO/IEC TR 24733:2011
| Extensions for the programming language C++ to support decimal floating-point arithmetic
| Published 2011-10-25 ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=38843 ISO Store])
Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2849.pdf n2849] (2009-03-06 
)&lt;br&gt;
May be superseded by a future Decimal TS or merged into C++17 via [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3871.html n3871]
|
|-
| ISO/IEC DTS 18822:2014
| C++ File System Technical Specification
| DTS. Final draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4100.pdf n4100] (2014-07-04)
| {{ltt|cpp/experimental/fs|fs}}
|-
| ISO/IEC PDTS 19568:xxxx
| C++ Extensions for Library Fundamentals
| PDTS. Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4082.pdf n4082] (2014-07-07)
|{{ltt|cpp/experimental/optional}}
{{ltt|cpp/experimental/any}}&lt;br&gt;
{{ltt|cpp/experimental/basic_string_view}}&lt;br&gt;
[[cpp/experimental/memory | Polymorphic allocators]]
|-
| ISO/IEC PDTS 19570:xxxx
| C++ Extensions for Parallelism
| PDTS. Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4104.html n4104] (2014-07-04)
|
|-
| ISO/IEC PDTS 19571:xxxx
| C++ Extensions for Concurrency
| In development: Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4107.html n4107] (2014-07-07)
|
|-
| ISO/IEC PDTS 19217:xxxx
| Concepts TS
| In development. Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4040.pdf n4040] (2014-05-26)
|
|-
|
| C++ Extensions for Library Fundamentals, Version 2
| In development. Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4084.html n4084] (2014-07-06)
| {{tt|not_fn}}
|-
| ISO/IEC PDTS 19569:xxxx
| Array Extensions TS
| In development. Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3820.html n3820] (2013-10-10)
|
|-
|
| Transactional Memory TS
| Early development, Draft: [http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3999.pdf n3999] (2014-05-23)
|
|-
| ISO/IEC PDTS 19216:xxxx
| Networking TS
| no working paper
|
|}</text>
      <sha1>p187vyn3cqlqlrhojsfbx9uy5j0ard6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any</title>
    <ns>0</ns>
    <id>13657</id>
    <revision>
      <id>71495</id>
      <parentid>71490</parentid>
      <timestamp>2014-06-12T00:46:55Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add clear function.</comment>
      <text xml:space="preserve" bytes="1545">{{cpp/title|n=experimental::|any}}
{{cpp/experimental/any/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This library component was voted out from C++14 working paper into a separate Technical Specification. It is not a part of the draft C++14.}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This is work in progress, there may be inaccuracies.}}
{{ddcl | header=experimental/any | since=libfund_ts |
class any;
}}

The class {{tt|any}} describes a type-safe container for single values of any type.

@1@ An object of class {{tt|any}} stores an instance of any type that satisfies the constructor requirements or is empty, and this is referred to as the ''state'' of the class {{tt|any}} object. The stored instance is called the contained object. Two states are equivalent if they are either both empty or if both are not empty and if the contained objects are equivalent.

@2@ The non-member {{tt|any_cast}} functions provide type-safe access to the contained object.


===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc constructor}}
{{dsc inc | cpp/experimental/any/dsc operator{{=}}}}

{{dsc h2 | Modifers}}
{{dsc inc | cpp/experimental/any/dsc clear}}
{{dsc inc | cpp/experimental/any/dsc swap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/experimental/any/dsc empty}}
{{dsc inc | cpp/experimental/any/dsc type}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc swap2}}
{{dsc inc | cpp/experimental/any/dsc any_cast}}
{{dsc end}}</text>
      <sha1>rt3h9nzmpy8zd1rfc7pvm9c4qhf2am3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/any</title>
    <ns>0</ns>
    <id>13659</id>
    <revision>
      <id>71491</id>
      <parentid>71460</parentid>
      <timestamp>2014-06-12T00:36:59Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Updated constructor signatures to match current draft.</comment>
      <text xml:space="preserve" bytes="2146">{{cpp/experimental/any/title|any}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
any();
}}
{{dcl | num=2 | since=libfund_ts |
any(const any&amp; other);
}}
{{dcl | num=3 | since=libfund_ts |
any(any&amp;&amp; other);
}}
{{dcl | num=4 | since=libfund_ts |
template&lt;typename ValueType&gt;
    any(ValueType&amp;&amp; value);
}}
{{dcl | num=5 | since=libfund_ts |
template &lt;class Allocator&gt;
    any(std::allocator_arg_t, const Allocator&amp; a);
}}
{{dcl | num=6 | since=libfund_ts |
template &lt;class Allocator, typename ValueType&gt;
    any(std::allocator_arg_t, const Allocator&amp; a, ValueType&amp;&amp; value);
}}
{{dcl | num=7 | since=libfund_ts |
template &lt;class Allocator&gt;
    any(std::allocator_arg_t, const Allocator&amp; a, const any&amp; other);
}}
{{dcl | num=8 | since=libfund_ts |
template &lt;class Allocator&gt;
    any(std::allocator_arg_t, const Allocator&amp; a, any&amp;&amp; other);
}}
{{dcl end}}


Constructs a new {{tt|any}} object.

@1@ Constructs an empty object.

@2-3@ Copies (2) or moves (3) content of {{tt|other}} into a new instance, so that any content is equivalent in both type and value to {{tt|other}}, or empty if {{tt|other}} is empty.

@4@ Constructs an object with initial content equivalent in both type and value to {{tt|value}}.

@5-8@ Equivalent to the preceding constructors except that the stored value is constructed using the supplied allocator instance.

===Template parameters===
{{par begin}}
{{par | ValueType | contained value type}}
{{par | Allocator | {{concept|Allocator}} type used to allocate internal storage}}
{{par hreq}}
{{par req concept | ValueType | CopyConstructible}}
{{par req concept | Allocator | Allocator}}
{{par end}}

===Parameters===
{{par begin}}
{{par | other | another {{tt|any}} object to copy or move from}}
{{par | value | value to initialize the contained value with}}
{{par | a | instance of an allocator to use for allocating the contained value}}
{{par end}}

===Exceptions===
@1,3,5,8@ {{noexcept}}

@2,4,6,7@ Throws {{lc|bad_alloc}} or any exception thrown by the constructor of the contained type.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc operator{{=}}}}
{{dsc end}}</text>
      <sha1>cg1ddwm8yifka5xp0jshrls1syopegg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/any cast</title>
    <ns>0</ns>
    <id>13665</id>
    <revision>
      <id>71516</id>
      <parentid>71498</parentid>
      <timestamp>2014-06-12T08:22:14Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix namespace.</comment>
      <text xml:space="preserve" bytes="1396">{{cpp/title|n=experimental::|any_cast}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | num=1 |
template&lt;class ValueType&gt;
    ValueType any_cast(const any&amp; operand);
}}
{{dcl | since=libfund_ts | num=2 |
template&lt;class ValueType&gt;
    ValueType any_cast(any&amp; operand);
}}
{{dcl | since=libfund_ts | num=3 |
template&lt;class ValueType&gt;
    ValueType any_cast(any&amp;&amp; operand);
}}
{{dcl | since=libfund_ts | num=4 |
template&lt;class ValueType&gt;
    const ValueType* any_cast(const any* operand);
}}
{{dcl | since=libfund_ts | num=5 |
template&lt;class ValueType&gt;
    ValueType* any_cast(any* operand);
}}
{{dcl end}}

Performs type-safe access to the contained object.

===Parameters===
{{par begin}}
{{par | operand | target {{tt|any}} object}}
{{par end}} 

===Return value===
@1-3@ The value, or a reference to the value contained by {{tt|operand}}. If the requested {{tt|ValueType}} is a reference, it is const-qualified for (1).
@4-5@ If {{tt|operand}} is not a null pointer, and the {{tt|typeid}} of the requested {{tt|ValueType}} matches that of the contents of {{tt|operand}}, a pointer to the value contained by operand, otherwise a null pointer. The returned pointer is const qualified for (4).

===Exceptions===
@1-3@ Throws {{tt|bad_any_cast}} if the {{tt|typeid}} of the requested {{tt|ValueType}} does not match that of the contents of {{tt|operand}}.
@4-5@ {{noexcept}}</text>
      <sha1>ngahd78x5lgkmbmvcvrh6qt3wsdg62k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/clear</title>
    <ns>0</ns>
    <id>13667</id>
    <revision>
      <id>71493</id>
      <timestamp>2014-06-12T00:45:43Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="267">{{cpp/experimental/any/title|clear}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
void clear();
}}
{{dcl end}}

If not empty, destroys the contained object.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1>2ue2fup4coz9uv6d7umwuk9e2rc1jw8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/empty</title>
    <ns>0</ns>
    <id>13662</id>
    <revision>
      <id>71453</id>
      <timestamp>2014-06-11T05:59:19Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="321">{{cpp/experimental/any/title|empty}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
bool empty() const;
}}
{{dcl end}}

Checks whether the object contains a value.

===Parameters===
(none)

===Return value===
{{c|true}} if instance is empty, otherwise {{c|false}}.

===Exceptions===
{{noexcept}}</text>
      <sha1>3npj7lcu7157jj9uks86m15vr6pxzav</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/operator=</title>
    <ns>0</ns>
    <id>13660</id>
    <revision>
      <id>71596</id>
      <parentid>71595</parentid>
      <timestamp>2014-06-14T14:10:10Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix constructor description order.</comment>
      <text xml:space="preserve" bytes="1025">{{cpp/experimental/any/title|operator{{=}}}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | num=1 | 1=
any&amp; operator=(const any&amp; rhs);
}}
{{dcl | since=libfund_ts | num=2 | 1=
any&amp; operator=(any&amp;&amp; rhs);
}}
{{dcl | since=libfund_ts | num=3 | 1=
template&lt;typename ValueType&gt;
    any&amp; operator=(ValueType&amp;&amp; rhs);
}}
{{dcl end}}

Assigns contents to the contained value. 

@1-2@ Assigns by copying (1) or moving(2) the value of {{tt|rhs}}.

@3@ Assigns the type and value of {{tt|rhs}}.

===Template parameters===
{{par begin}}
{{par | ValueType | contained value type}}
{{par hreq}}
{{par req concept | ValueType | CopyConstructible}}
{{par end}}

===Parameters===
{{par begin}}
{{par | rhs | object whose contained value to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@2@ {{noexcept}}

@1,3@ Throws {{lc|bad_alloc}} or any exception thrown by the constructor of the contained type.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc constructor}}
{{dsc end}}</text>
      <sha1>4mhs1tdal76mbfurshnel1zvl4gwht2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/swap</title>
    <ns>0</ns>
    <id>13661</id>
    <revision>
      <id>71452</id>
      <timestamp>2014-06-11T05:56:57Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="332">{{cpp/experimental/any/title|swap}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
void swap(any&amp; other);
}}
{{dcl end}}

Swaps the content of two {{tt|any}} objects.

===Parameters===
{{par begin}}
{{par | other | object to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1>ri1njb1pjx2tjf5mshzima1kfxuuj5e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/swap2</title>
    <ns>0</ns>
    <id>13664</id>
    <revision>
      <id>71519</id>
      <parentid>71518</parentid>
      <timestamp>2014-06-12T08:25:20Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Fix title template usage.</comment>
      <text xml:space="preserve" bytes="426">{{cpp/title|n=experimental::|swap}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
void swap(any&amp; lhs, any&amp; rhs);
}}
{{dcl end}}

Swaps the content of two {{tt|any}} objects.

===Parameters===
{{par begin}}
{{par | lhs, rhs | objects to swap}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc swap}}
{{dsc end}}</text>
      <sha1>baipkjjkrex0qnxqtomz1gsglm1kb32</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/any/type</title>
    <ns>0</ns>
    <id>13663</id>
    <revision>
      <id>71496</id>
      <parentid>71454</parentid>
      <timestamp>2014-06-12T00:48:41Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Fix function signature.</comment>
      <text xml:space="preserve" bytes="356">{{cpp/experimental/any/title|type}}
{{cpp/experimental/any/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
const type_info&amp; type() const;
}}
{{dcl end}}

Queries the contained type.

===Parameters===
(none)

===Return value===
The {{tt|typeid}} of the contained value if instance is non-empty, otherwise {{c|typeid(void)}}.

===Exceptions===
{{noexcept}}</text>
      <sha1>g7k7r62z56zfwj270owq75hcqq0ccuk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view</title>
    <ns>0</ns>
    <id>13633</id>
    <revision>
      <id>72329</id>
      <parentid>71502</parentid>
      <timestamp>2014-08-10T16:35:02Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4591">{{cpp/title|n=experimental::|basic_string_view}}
{{cpp/experimental/basic_string_view/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This library component was voted out from C++14 working paper into a separate Technical Specification. It is not a part of the draft C++14.}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This is work in progress, there may be inaccuracies.}}
{{ddcl | header=experimental/string_view | since=libfund_ts |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt; 
&gt; class basic_string_view;
}}

The class template {{tt|basic_string_view}} describes an object that can refer to a constant contiguous sequence of {{c|char}}-like objects with the first element of the sequence at position zero. 


Several typedefs for common character types are provided:
{{dsc begin}}
{{dsc header | experimental/string_view}}
{{dsc hitem | Type | Definition}}
{{dsc | {{lc|std::experimental::string_view}} | {{c|std::experimental::basic_string_view&lt;char&gt;}} }}
{{dsc | {{lc|std::experimental::wstring_view}} | {{c|std::experimental::basic_string_view&lt;wchar_t&gt;}} }}
{{dsc | {{lc|std::experimental::u16string_view}} | {{c|std::experimental::basic_string_view&lt;char16_t&gt;}} }}
{{dsc | {{lc|std::experimental::u32string_view}} | {{c|std::experimental::basic_string_view&lt;char32_t&gt;}} }}
{{dsc end}}

===Template parameters===
{{par begin}}
{{par | CharT | character type}}
{{par | Traits | traits class specifying the operations on the character type}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}} }}
{{dsc | {{tt|value_type}} | {{tt|CharT}} }}
{{dsc | {{tt|pointer}} | {{tt|CharT*}} }}
{{dsc | {{tt|const_pointer}} | {{tt|const CharT*}} }}
{{dsc | {{tt|reference}} | {{tt|CharT&amp;}} }}
{{dsc | {{tt|const_reference}} | {{tt|const CharT&amp;}} }}
{{dsc | {{tt|const_iterator}} | {{concept|RandomAccessIterator}} }}
{{dsc | {{tt|iterator}} | {{tt|const_iterator}} }}
{{dsc | {{tt|reverse_iterator}} | {{tt|const_reverse_iterator}} }}
{{dsc | {{tt|const_reverse_iterator}} | {{c|std::reverse_iterator&lt;const_iterator&gt;}} }}
{{dsc | {{tt|size_type}} | {{lc|std::size_t}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc constructor}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator{{=}}}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/experimental/basic_string_view/dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc end}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rbegin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rend}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_at}}
{{dsc inc | cpp/experimental/basic_string_view/dsc at}}
{{dsc inc | cpp/experimental/basic_string_view/dsc front}}
{{dsc inc | cpp/experimental/basic_string_view/dsc back}}
{{dsc inc | cpp/experimental/basic_string_view/dsc data}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/experimental/basic_string_view/dsc size}}
{{dsc inc | cpp/experimental/basic_string_view/dsc max_size}}
{{dsc inc | cpp/experimental/basic_string_view/dsc empty}}

{{dsc h2 | Modifers}}
{{dsc inc | cpp/experimental/basic_string_view/dsc clear}}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_prefix}}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_suffix}}
{{dsc inc | cpp/experimental/basic_string_view/dsc swap}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/experimental/basic_string_view/dsc to_string}}
{{dsc inc | cpp/experimental/basic_string_view/dsc copy}}
{{dsc inc | cpp/experimental/basic_string_view/dsc substr}}
{{dsc inc | cpp/experimental/basic_string_view/dsc compare}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}

{{dsc h1 | Constants}}
{{dsc inc | cpp/experimental/basic_string_view/dsc npos}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_cmp}}

{{dsc h2 | Input/output}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_ltlt}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc hash}}
{{dsc end}}</text>
      <sha1>o7hi89a83adjywq8ppbjfbvdvmih5md</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/at</title>
    <ns>0</ns>
    <id>13571</id>
    <revision>
      <id>71247</id>
      <timestamp>2014-06-09T01:16:27Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="748">{{cpp/experimental/basic_string_view/title | at}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reference at(size_type pos) const;
}}
{{dcl end}}

Returns a reference to the character at specified location {{tt|pos}}. Bounds checking is performed, exception of type {{lc|std::out_of_range}} will be thrown on invalid access.

===Parameters===
{{par begin}}
{{par | pos | position of the character to return}}
{{par end}}

===Return value===
Reference to the requested character.

===Exceptions===
Throws {{lc|std::out_of_range}} if {{c|1=pos &gt;= size()}}.

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_at }}
{{dsc end}}</text>
      <sha1>3ib13jd9m4v1vlmhzt3rlr2syt1jk0v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/back</title>
    <ns>0</ns>
    <id>13574</id>
    <revision>
      <id>71253</id>
      <parentid>71250</parentid>
      <timestamp>2014-06-09T01:32:35Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix title.</comment>
      <text xml:space="preserve" bytes="500">{{cpp/experimental/basic_string_view/title | back}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reference back() const;
}}
{{dcl end}}

Returns reference to the last character in the view.

===Parameters===
(none)

===Return value===
Reference to the last character, equivalent to {{c|operator[](size() - 1)}}.

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc front }}
{{dsc end}}</text>
      <sha1>19y1hs01ubyj82vzkgzqo93tsuevwjp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/basic string view</title>
    <ns>0</ns>
    <id>13562</id>
    <revision>
      <id>71136</id>
      <parentid>71119</parentid>
      <timestamp>2014-06-07T00:14:21Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Moved noexcept to body.</comment>
      <text xml:space="preserve" bytes="1840">{{cpp/experimental/basic_string_view/title|basic_string_view}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts | 
constexpr basic_string_view();
}}
{{dcl | num=2 | since=libfund_ts | 
constexpr basic_string_view(const basic_string_view&amp; other) {{=}}default;
}}
{{dcl | num=3 | since=libfund_ts |
template&lt;class Allocator&gt;
basic_string_view(const basic_string&lt;CharT, Traits, Allocator&gt;&amp; str);
}}
{{dcl | num=4 | since=libfund_ts |
constexpr basic_string_view(const CharT* s, size_type count);
}}
{{dcl | num=5 | since=libfund_ts |
constexpr basic_string_view(const CharT* s);
}}
{{dcl end}}

@1@ Default constructor. Constructs an empty {{tt|basic_string_view}}.
@2@ Copy constructor. Constructs a view of the same content of {{tt|other}}.
@3@ Constructs a view of {{tt|str}}.
@4@ Constructs a view of the first {{tt|count}} characters of character string pointed to by {{tt|s}}. {{tt|s}} can contain null characters. The behavior is undefined if {{tt|s}} does not point to an array of at least {{tt|count}} elements of {{tt|CharT}}. 
@5@ Constructs a view of the null-terminated character string pointed to by {{tt|s}}. The length of the view is determined by the first null character. The behavior is undefined if {{tt|s}} does not point to an array of at least {{c|Traits::length(s)+1}} elements of {{tt|CharT}}.

===Parameters===
{{par begin}}
{{par | other | another view to initialize the view with}}
{{par | str | string to initialize view with}}
{{par | s | pointer to a character string to initialize the view with}}
{{par | count | size of the resulting view}}
{{par end}} 

===Exceptions===
1-3) {{noexcept}}

===Complexity===

1-4) constant

5) linear in length of {{tt|s}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator{{=}} }}
{{dsc end}}</text>
      <sha1>mw81gij139tvf7j7o8pgt7wusz3srdf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/begin</title>
    <ns>0</ns>
    <id>13564</id>
    <revision>
      <id>71243</id>
      <parentid>71139</parentid>
      <timestamp>2014-06-09T00:23:04Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>return value: iterator -&gt; const_iterator</comment>
      <text xml:space="preserve" bytes="611">{{cpp/experimental/basic_string_view/title | begin | cbegin}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_iterator begin() const;
}}
{{dcl | since=libfund_ts |
constexpr const_iterator cbegin() const;
}}
{{dcl end}}

Returns an iterator to the first character of the view. 

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
{{tt|const_iterator}} to the first character

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc end}}
{{dsc end}}</text>
      <sha1>o0n5obh7n1lrz9mknp4shaa094vs7yp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/clear</title>
    <ns>0</ns>
    <id>13581</id>
    <revision>
      <id>71262</id>
      <timestamp>2014-06-09T02:34:20Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="539">{{cpp/experimental/basic_string_view/title | clear }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr void clear();
}}
{{dcl end}}

Clears the view. Equivalent to {{c|*this {{=}} basic_string_view()}}

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_prefix }}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_suffix }}
{{dsc end}}</text>
      <sha1>rjyypjwokfucngzysgg9zgvgyh41ue2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/compare</title>
    <ns>0</ns>
    <id>13609</id>
    <revision>
      <id>71319</id>
      <parentid>71318</parentid>
      <timestamp>2014-06-09T07:29:09Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Added other compare functions.</comment>
      <text xml:space="preserve" bytes="3145">{{cpp/experimental/basic_string_view/title | compare }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr int compare(basic_string_view v) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr int compare(size_type pos1, size_type count1,
                      basic_string_view v) const
}}
{{dcl | num=3 | since=libfund_ts |
constexpr int compare(size_type pos1, size_type count1, basic_string_view v,
                      size_type pos2, size_type count2) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr int compare(const CharT* s) const;
}}
{{dcl | num=5 | since=libfund_ts |
constexpr int compare(size_type pos1, size_type count1,
                      const CharT* s) const;
}}
{{dcl | num=6 | since=libfund_ts |
constexpr int compare(size_type pos1, size_type count1,
                      const CharT* s, size_type count2) const;
}}
{{dcl end}}

Compares two character sequences.

@1@The length {{tt|rlen}} of the sequences to compare is the smaller of {{c|size()}} and {{c|v.size()}}. The function compares the two views by calling {{c|traits::compare(data(), v.data(), rlen)}}, and returns a value according to the following table:

{| class=&quot;wikitable&quot; style=&quot;text-align:center;&quot;
! colspan=2 | Condition
! Result
! Return value
|-
| colspan=2 style=&quot;text-align:left;&quot; | {{tt|Traits::compare(data(), v.data(), {{spar|rlen}}) &lt; 0}}
| {{tt|this}} is ''less'' than {{tt|v}}
| {{c|&lt;0}}
|-
| rowspan=3 | {{tt|Traits::compare(data(), v.data(), {{spar|rlen}}) {{==}} 0}}
| {{tt|size() &lt; v.size()}}
| {{tt|this}} is ''less'' than {{tt|v}}
| {{c|&lt;0}}
|-
&lt;!-- --&gt;
| {{tt|size() {{==}} v.size()}}
| {{tt|this}} is ''equal'' to {{tt|v}}
| {{c|0}}
|-
&lt;!-- --&gt;
| {{tt|size() &gt; v.size()}}
| {{tt|this}} is ''greater'' than {{tt|v}}
| {{c|&gt;0}}
|-
| colspan=2 style=&quot;text-align:left;&quot; | {{tt|Traits::compare(data(), v.data(), {{spar|rlen}}) &gt; 0}}
| {{tt|this}} is ''greater'' than {{tt|v}}
| {{c|&gt;0}}
|}

@2@Equivalent to {{c|substr(pos1, count1).compare(v)}}.
@3@Equivalent to {{c|substr(pos1, count1).compare(v.substr(pos2, count2))}}.
@4@Equivalent to {{c|compare(basic_string_view(s))}}.
@5@Equivalent to {{c|substr(pos1, count1).compare(basic_string_view(s))}}.
@6@Equivalent to {{c|substr(pos1, count1).compare(basic_string_view(s, count2))}}.

===Parameters===
{{par begin}}
{{par | v | view to compare}}
{{par | s | pointer to the character string to compare to}}
{{par | count1 | number of characters of this view to compare}}
{{par | pos1 | position of the first character in this view to compare}}
{{par | count2 | number of characters of the given view to compare}}
{{par | pos2 | position of the first character of the given view to compare}}
{{par end}} 

===Return value===
negative value if this view is less than the other character sequence, zero if the both character sequences are equal, positive value if this view is greater than the other character sequence.

===Exceptions===
1) {{noexcept}}

===Complexity===
1) Linear in the number of characters compared.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_cmp}}
{{dsc end}}</text>
      <sha1>ai6t8cs6p50c3ky5wkt679m0o2ow49x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/copy</title>
    <ns>0</ns>
    <id>13604</id>
    <revision>
      <id>71312</id>
      <parentid>71311</parentid>
      <timestamp>2014-06-09T06:31:12Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Wording.</comment>
      <text xml:space="preserve" bytes="898">{{cpp/experimental/basic_string_view/title | copy }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
size_type copy( CharT* dest,
                size_type count,
                size_type pos {{=}} 0) const;
}}
{{dcl end}}

Copies the substring {{tt|[pos, pos + rcount)}} to the character string pointed to by {{tt|dest}}, where {{tt|rcount}} is the smaller of {{tt|count}} and {{c|size() - pos}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the destination character string}}
{{par | pos | position of the first character}}
{{par | count | requested substring length}}
{{par end}} 

===Return value===
Number of characters copied

===Exceptions===
{{lc|std::out_of_range}} if {{c|1=pos &gt;= size()}}.

===Complexity===
Linear in {{tt|rcount}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc substr}}
{{dsc end}}</text>
      <sha1>2xs7e4d2ivojhpqqsgithi20c3lerhe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/data</title>
    <ns>0</ns>
    <id>13575</id>
    <revision>
      <id>71255</id>
      <parentid>71251</parentid>
      <timestamp>2014-06-09T01:41:47Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Moved noexcept to body.</comment>
      <text xml:space="preserve" bytes="971">{{cpp/experimental/basic_string_view/title | data}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_pointer data() const;
}}
{{dcl end}}

Returns a pointer to the underlying character array. The pointer is such that the range [data(); data() + size()) is valid and the values in it correspond to the values of the view. (n.b. Unlike {{tt|basic_string::data()}} and string literals, {{tt|data()}} may return a pointer to a buffer that is not null-terminated. Therefore it is typically a mistake to pass {{tt|data()}} to a routine that takes just a {{tt|const CharT*}} and expects a null-terminated string.)

===Parameters===
(none)

===Return value===
A pointer to the underlying character array.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc front }}
{{dsc inc | cpp/experimental/basic_string_view/dsc back }}
{{dsc end}}</text>
      <sha1>ald9zztvzpl84cku868029l50gys95t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/empty</title>
    <ns>0</ns>
    <id>13578</id>
    <revision>
      <id>71259</id>
      <timestamp>2014-06-09T02:09:25Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="585">{{cpp/experimental/basic_string_view/title | empty }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr bool empty() const;
}}
{{dcl end}}

Checks if the view has no characters, i.e. whether {{tt|size() {{==}} 0}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the view is empty, {{c|false}} otherwise

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc size }}
{{dsc inc | cpp/experimental/basic_string_view/dsc max_size }}
{{dsc end}}</text>
      <sha1>eabwcaz6lfudzn18o8njdpp39kxmyfo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/end</title>
    <ns>0</ns>
    <id>13568</id>
    <revision>
      <id>71242</id>
      <timestamp>2014-06-09T00:22:34Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Created page with &quot;{{cpp/experimental/basic_string_view/title | end | cend}} {{cpp/experimental/basic_string_view/navbar}} {{dcl begin}} {{dcl | since=libfund_ts | constexpr const_iterator end()...&quot;</comment>
      <text xml:space="preserve" bytes="744">{{cpp/experimental/basic_string_view/title | end | cend}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_iterator end() const;
}}
{{dcl | since=libfund_ts |
constexpr const_iterator cend() const;
}}
{{dcl end}}

Returns an iterator to the character following the last character of the view. This character acts as a placeholder, attempting to access it results in undefined behavior.

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
{{tt|const_iterator}} to the character following the last character.

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc begin}}
{{dsc end}}</text>
      <sha1>hg58mrucvz4gvvbwemhkfor1esv11jp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/find</title>
    <ns>0</ns>
    <id>13611</id>
    <revision>
      <id>71334</id>
      <parentid>71321</parentid>
      <timestamp>2014-06-09T09:43:58Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Typo.</comment>
      <text xml:space="preserve" bytes="1779">{{cpp/experimental/basic_string_view/title | find }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type find(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type find(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type find(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type find(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the first substring equal to the given character sequence.

@1@Finds the first occurence of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|find(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|find(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|find(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of substring to search for}}
{{par | s | pointer to a character string to search for}}
{{par | ch | character to search for}}
{{par end}} 


===Return value===
Position of the first character of the found substring, or {{lc|npos}} if no such substring is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}
{{dsc end}}</text>
      <sha1>drtpk2t0qvzy1fvzgl505ho0xybabdf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/find first not of</title>
    <ns>0</ns>
    <id>13620</id>
    <revision>
      <id>71333</id>
      <timestamp>2014-06-09T09:42:55Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="1992">{{cpp/experimental/basic_string_view/title | find_first_not_of }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type 
    find_first_not_of(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type
    find_first_not_of(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type
    find_first_not_of(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type
    find_first_not_of(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the first character not equal to any of the characters in the given character sequence.

@1@Finds the first character not equal to any of the characters of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|find_first_not_of(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|find_first_not_of(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|find_first_not_of(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of the string of characters to compare}}
{{par | s | pointer to a string of characters to compare}}
{{par | ch | character to compare}}
{{par end}} 

===Return value===
Position of the first character not equal to any of the characters in the given string, or {{lc|npos}} if no such character is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}
{{dsc end}}</text>
      <sha1>b6f20gyoqra3to6oqu42173dwfurorg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/find first of</title>
    <ns>0</ns>
    <id>13618</id>
    <revision>
      <id>71336</id>
      <parentid>71332</parentid>
      <timestamp>2014-06-09T09:45:39Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Typos.</comment>
      <text xml:space="preserve" bytes="1922">{{cpp/experimental/basic_string_view/title | find_first_of }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type find_first_of(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type find_first_of(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type find_first_of(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type find_first_of(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the first character equal to any of the characters in the given character sequence.

@1@Finds the first occurence of any of the characters of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|find_first_of(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|find_first_of(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|find_first_of(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of the string of characters to search for}}
{{par | s | pointer to a string of characters to search for}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the first occurrence of any character of the substring, or {{lc|npos}} if no such character is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}
{{dsc end}}</text>
      <sha1>o6z8s5lan58a2bh7s5mpfuooofvrc4o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/find last not of</title>
    <ns>0</ns>
    <id>13621</id>
    <revision>
      <id>71338</id>
      <timestamp>2014-06-09T09:47:36Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="1982">{{cpp/experimental/basic_string_view/title | find_last_not_of }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type 
    find_last_not_of(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type
    find_last_not_of(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type
    find_last_not_of(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type
    find_last_not_of(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the last character not equal to any of the characters in the given character sequence.

@1@Finds the last character not equal to any of the characters of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|find_last_not_of(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|find_last_not_of(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|find_last_not_of(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of the string of characters to compare}}
{{par | s | pointer to a string of characters to compare}}
{{par | ch | character to compare}}
{{par end}} 

===Return value===
Position of the last character not equal to any of the characters in the given string, or {{lc|npos}} if no such character is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc end}}</text>
      <sha1>lqwlezmnpn1ggwxd1kxq4ic1mvi9qve</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/find last of</title>
    <ns>0</ns>
    <id>13619</id>
    <revision>
      <id>71337</id>
      <parentid>71331</parentid>
      <timestamp>2014-06-09T09:46:18Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Typo.</comment>
      <text xml:space="preserve" bytes="1912">{{cpp/experimental/basic_string_view/title | find_last_of }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type find_last_of(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type find_last_of(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type find_last_of(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type find_last_of(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the last character equal to any of the characters in the given character sequence.

@1@Finds the last occurence of any of the characters of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|find_last_of(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|find_last_of(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|find_last_of(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of the string of characters to search for}}
{{par | s | pointer to a string of characters to search for}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the last occurrence of any character of the substring, or {{lc|npos}} if no such character is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rfind}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}
{{dsc end}}</text>
      <sha1>hr8lufd8lnh6jhzwvorzftjzq2g49h5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/front</title>
    <ns>0</ns>
    <id>13573</id>
    <revision>
      <id>71252</id>
      <parentid>71249</parentid>
      <timestamp>2014-06-09T01:32:23Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix title.</comment>
      <text xml:space="preserve" bytes="494">{{cpp/experimental/basic_string_view/title | front}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reference front() const;
}}
{{dcl end}}

Returns reference to the first character in the view.

===Parameters===
(none)

===Return value===
reference to the first character, equivalent to {{c|operator[](0)}}.

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc back }}
{{dsc end}}</text>
      <sha1>eznv7v4rlhfvo8o37i4vz4pzux0bjq8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/hash</title>
    <ns>0</ns>
    <id>13625</id>
    <revision>
      <id>71345</id>
      <timestamp>2014-06-09T10:13:34Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="719">{{cpp/title|hash &lt;small&gt;(std::experimental::string_view, std::experimental::wstring_view, std::experimental::u16string_view, std::experimental::u32string_view)&lt;/small&gt;}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl header | experimental/string_view}}
{{dcl | since=libfund_ts | 1=
template&lt;&gt; struct hash&lt;std::experimental::string_view&gt;;
template&lt;&gt; struct hash&lt;std::experimental::wstring_view&gt;;
template&lt;&gt; struct hash&lt;std::experimental::u16string_view&gt;;
template&lt;&gt; struct hash&lt;std::experimental::u32string_view&gt;;
}}
{{dcl end}}

Template specializations of {{lc|std::hash}} for the various view classes for hashing views.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}</text>
      <sha1>0hol22y79q5rchtqcluiwjwtdxhonwb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/max size</title>
    <ns>0</ns>
    <id>13577</id>
    <revision>
      <id>71258</id>
      <timestamp>2014-06-09T02:07:01Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="597">{{cpp/experimental/basic_string_view/title | max_size }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr size_type max_size() const;
}}
{{dcl end}}

The largest possible number of char-like objects that can be referred to by a {{tt|basic_string_view}}.

===Parameters===
(none)

===Return value===
Maximum number of characters.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc size }}
{{dsc inc | cpp/experimental/basic_string_view/dsc empty }}
{{dsc end}}</text>
      <sha1>tb8akax6m23085gi927ihjxczpoiw8f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/npos</title>
    <ns>0</ns>
    <id>13622</id>
    <revision>
      <id>71344</id>
      <parentid>71339</parentid>
      <timestamp>2014-06-09T10:08:21Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Added library fundamentals note.</comment>
      <text xml:space="preserve" bytes="482">{{cpp/experimental/basic_string_view/title | npos}}
{{cpp/experimental/basic_string_view/navbar}}
{{ddcl | since=libfund_ts | 1=
static constexpr size_type npos = size_type(-1);
}}

This is a special value equal to the maximum value representable by the type {{tt|size_type}}. The exact meaning depends on context, but it is generally used either as end of view indicator by the functions that expect a view index or as the error indicator by the functions that return a view index.</text>
      <sha1>s9rs5dywfqsid76io889yg4nddnc6yo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/operator=</title>
    <ns>0</ns>
    <id>13563</id>
    <revision>
      <id>71138</id>
      <parentid>71137</parentid>
      <timestamp>2014-06-07T00:17:37Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Formatting</comment>
      <text xml:space="preserve" bytes="554">{{cpp/experimental/basic_string_view/title | operator{{=}}}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |1=
basic_string_view&amp; operator=( const basic_string_view&amp; view ) =default;
}}
{{dcl end}}

Replaces the view with that of {{tt|view}}.

===Parameters===
{{par begin}}
{{par | view | view to copy}}
{{par end}} 

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===Complexity===

Linear.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc constructor}}
{{dsc end}}</text>
      <sha1>t5e9sudkcpvvl8zzbcn43afdoxaw3n7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/operator at</title>
    <ns>0</ns>
    <id>13572</id>
    <revision>
      <id>71248</id>
      <timestamp>2014-06-09T01:21:05Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="757">{{cpp/experimental/basic_string_view/title | operator[]}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reference operator[](size_type pos) const;
}}
{{dcl end}}

Returns a reference to the character at specified location {{tt|pos}}. No bounds checking is performed.
(n.b. unlike {{tt|basic_string::operator[]}}, {{tt|basic_string_view::operator[](size())}} has undefined behavior instead of returning {{tt|CharT()}}.)

===Parameters===
{{par begin}}
{{par | pos | position of the character to return}}
{{par end}}

===Return value===
Reference to the requested character.

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc at }}
{{dsc end}}</text>
      <sha1>tdvoiont2lrgoxmpep694ahdy7csfd0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/operator cmp</title>
    <ns>0</ns>
    <id>13623</id>
    <revision>
      <id>71343</id>
      <parentid>71340</parentid>
      <timestamp>2014-06-09T10:07:50Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Added library fundamentals note, header.</comment>
      <text xml:space="preserve" bytes="2200">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::experimental::basic_string_view)&lt;/small&gt;}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl header | experimental/string_view}}
{{dcl h | Compare two {{tt|basic_string_view}} objects}}
{{dcl | num=1 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator==( basic_string_view &lt;CharT,Traits&gt; lhs, 
                 basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl | num=2 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator!=( basic_string_view &lt;CharT,Traits&gt; lhs, 
                 basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl | num=3 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator&lt;( basic_string_view &lt;CharT,Traits&gt; lhs, 
                basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl | num=4 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator&lt;=( basic_string_view &lt;CharT,Traits&gt; lhs, 
                 basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl | num=5 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator&gt;( basic_string_view &lt;CharT,Traits&gt; lhs, 
                basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl | num=6 | since=libfund_ts | 1=
template&lt; class CharT, class Traits &gt;
bool operator&gt;=( basic_string_view &lt;CharT,Traits&gt; lhs, 
                 basic_string_view &lt;CharT,Traits&gt; rhs );
}}
{{dcl end}}

Compares two views.

All comparisons are done via the {{lc|compare()}} member function (which itself is defined in terms of {{tt|Traits::compare()}}):

* Two views are equal if both the size of {{tt|lhs}} and {{tt|rhs}} are equal and each character in {{tt|lhs}} has an equivalent character in {{tt|rhs}} at the same position.

* The ordering comparisons are done lexicographically -- the comparison is performed by a function equivalent to {{lc|std::lexicographical_compare}}.

@1-6@ Compares two {{tt|basic_string_view}} objects.

===Parameters===
{{par begin}}
{{par | lhs, rhs | views to compare}}
{{par end}} 

===Return value===
{{c|true}} if the corresponding comparison holds, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Complexity===
Linear in the size of the views.</text>
      <sha1>9vfjhon29s5a4hqzhx8yci6raglkmf9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/operator ltlt</title>
    <ns>0</ns>
    <id>13624</id>
    <revision>
      <id>71342</id>
      <parentid>71341</parentid>
      <timestamp>2014-06-09T10:05:50Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Submitted prematurely.</comment>
      <text xml:space="preserve" bytes="592">{{title|operator&lt;&lt;{{small|(std::experimental::basic_string_view)}}}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl header | experimental/string_view}}
{{dcl | since=libfund_ts |
template &lt;class CharT, class Traits&gt;
std::basic_ostream&lt;CharT, Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, 
               std::basic_string_view &lt;CharT, Traits&gt; v);
}}
{{dcl end}}

Equivalent to {{c|os &lt;&lt; v.to_string()}}.

===Parameters===
{{par begin}}
{{par | os | a character output stream}}
{{par | v | the view to be inserted}}
{{par end}}

===Return value===
{{tt|os}}</text>
      <sha1>qzk325kkps353v9rhp0djr8y5krf4tf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/rbegin</title>
    <ns>0</ns>
    <id>13569</id>
    <revision>
      <id>71246</id>
      <parentid>71244</parentid>
      <timestamp>2014-06-09T00:28:53Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Corrected sequence image.</comment>
      <text xml:space="preserve" bytes="720">{{cpp/experimental/basic_string_view/title | rbegin | crbegin}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reverse_iterator rbegin() const;
}}
{{dcl | since=libfund_ts |
constexpr const_reverse_iterator crbegin() const;
}}
{{dcl end}}

Returns a reverse iterator to the first character of the reversed view. It corresponds to the last character of the non-reversed view.

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
{{tt|const_reverse_iterator}} to the first character

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rend}}
{{dsc end}}</text>
      <sha1>0yipoy8ywutud2ubb1k3wr6dh94n578</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/remove prefix</title>
    <ns>0</ns>
    <id>13582</id>
    <revision>
      <id>71264</id>
      <timestamp>2014-06-09T02:42:40Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="694">{{cpp/experimental/basic_string_view/title | remove_prefix }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr void remove_prefix(size_type n);
}}
{{dcl end}}

Moves the start of the view forward by {{tt|n}} characters. Using a value for {{tt|n}} greater than {{tt|size()}} results in undefined behavior.

===Parameters===
{{par begin}}
{{par | n | number of characters to remove from the start of the view}}
{{par end}}

===Return value===
(none)

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_suffix }}
{{dsc inc | cpp/experimental/basic_string_view/dsc clear }}
{{dsc end}}</text>
      <sha1>aiafm6mye25aalm2igfcm31y201vmzr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/remove suffix</title>
    <ns>0</ns>
    <id>13583</id>
    <revision>
      <id>71269</id>
      <timestamp>2014-06-09T03:28:56Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="687">{{cpp/experimental/basic_string_view/title | remove_suffix }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr void remove_suffix(size_type n);
}}
{{dcl end}}

Moves the end of the view back by {{tt|n}} characters. Using a value for {{tt|n}} greater than {{tt|size()}} results in undefined behavior.

===Parameters===
{{par begin}}
{{par | n | number of characters to remove from the end of the view}}
{{par end}}

===Return value===
(none)

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc remove_prefix }}
{{dsc inc | cpp/experimental/basic_string_view/dsc clear }}
{{dsc end}}</text>
      <sha1>ro0u18nqyj727os67lse3e6p8is0cfv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/rend</title>
    <ns>0</ns>
    <id>13570</id>
    <revision>
      <id>71286</id>
      <parentid>71245</parentid>
      <timestamp>2014-06-09T04:12:19Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix see also template</comment>
      <text xml:space="preserve" bytes="879">{{cpp/experimental/basic_string_view/title | rend | crend}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr const_reverse_iterator rend() const;
}}
{{dcl | since=libfund_ts |
constexpr const_reverse_iterator crend() const;
}}
{{dcl end}}

Returns a reverse iterator to the character following the last character of the reversed view. It corresponds to the character preceding the first character of the non-reversed view. This character acts as a placeholder, attempting to access it results in undefined behavior.

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
{{tt|const_reverse_iterator}} to the character following the last character.

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc rbegin}}
{{dsc end}}</text>
      <sha1>fcfw210jg3ccsouj76q962pjvhvfggn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/rfind</title>
    <ns>0</ns>
    <id>13617</id>
    <revision>
      <id>71335</id>
      <parentid>71327</parentid>
      <timestamp>2014-06-09T09:44:45Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>typo.</comment>
      <text xml:space="preserve" bytes="1783">{{cpp/experimental/basic_string_view/title | rfind }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr size_type rfind(basic_string_view v, size_type pos {{=}} 0) const;
}}
{{dcl | num=2 | since=libfund_ts |
constexpr size_type rfind(CharT c, size_type pos {{=}} 0) const;
}}
{{dcl | num=3 | since=libfund_ts |
constexpr size_type rfind(const CharT* s, size_type pos, size_type count) const;
}}
{{dcl | num=4 | since=libfund_ts |
constexpr size_type rfind(const CharT* s, size_type pos {{=}} 0) const;
}}
{{dcl end}}

Finds the last substring equal to the given character sequence.

@1@Finds the last occurence of {{tt|v}} in this view, starting at position {{tt|pos}}.
@2@Equivalent to {{c|rfind(basic_string_view(&amp;c, 1), pos)}}.
@3@Equivalent to {{c|rfind(basic_string_view(s, count), pos)}}.
@4@Equivalent to {{c|rfind(basic_string_view(s), pos)}}.

===Parameters===
{{par begin}}
{{par | v | view to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of substring to search for}}
{{par | s | pointer to a character string to search for}}
{{par | ch | character to search for}}
{{par end}} 


===Return value===
Position of the first character of the found substring or {{lc|npos}} if no such substring is found.

===Exceptions===
1-2) {{noexcept}}

===Complexity===
O({{tt|size()}} * {{tt|v.size()}}) at worst.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_first_not_of}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find_last_not_of}}
{{dsc end}}</text>
      <sha1>hgr604v4ovnzw46l9u5jstm5m8gial3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/size</title>
    <ns>0</ns>
    <id>13576</id>
    <revision>
      <id>71257</id>
      <parentid>71256</parentid>
      <timestamp>2014-06-09T02:04:09Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Added length to title</comment>
      <text xml:space="preserve" bytes="682">{{cpp/experimental/basic_string_view/title | size | length}}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr size_type size() const;
}}
{{dcl | since=libfund_ts |
constexpr size_type length() const;
}}
{{dcl end}}

Returns the number of {{tt|CharT}} elements in the view, i.e. {{c|std::distance(begin(), end())}}. 

===Parameters===
(none)

===Return value===
The number of {{tt|CharT}} elements in the view.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc empty }}
{{dsc inc | cpp/experimental/basic_string_view/dsc max_size }}
{{dsc end}}</text>
      <sha1>c77rl9yjqzdm2qq40d5o1v5ennqmzoc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/substr</title>
    <ns>0</ns>
    <id>13606</id>
    <revision>
      <id>71315</id>
      <parentid>71310</parentid>
      <timestamp>2014-06-09T06:44:34Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Removed size link.</comment>
      <text xml:space="preserve" bytes="794">{{cpp/experimental/basic_string_view/title | substr}}
{{cpp/experimental/basic_string_view/navbar}}
{{ddcl | 1=
constexpr basic_string_view
    substr(size_type pos = 0, size_type count = npos ) const;
}}

Returns a view of the substring {{tt|[pos, pos + rcount)}}, where {{tt|rcount}} is the smaller of {{tt|count}} and {{c|size() - pos}}.

===Parameters===
{{par begin}}
{{par | pos | position of the first character}}
{{par | count | requested length}}
{{par end}} 

===Return value===
View of the substring {{tt|[pos, pos + rcount)}}.

===Exceptions===
{{lc|std::out_of_range}} if {{c|pos &gt;{{=}} size()}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc copy}}
{{dsc inc | cpp/experimental/basic_string_view/dsc find}}
{{dsc end}}</text>
      <sha1>99lf6oh5vaug4zje0in2g3jjoq4h8i8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/swap</title>
    <ns>0</ns>
    <id>13584</id>
    <revision>
      <id>71305</id>
      <parentid>71270</parentid>
      <timestamp>2014-06-09T04:36:55Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Remove see also section</comment>
      <text xml:space="preserve" bytes="406">{{cpp/experimental/basic_string_view/title | swap }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
constexpr void swap(basic_string_view&amp; v);
}}
{{dcl end}}

Exchanges the the view with that of {{tt|v}}.

===Parameters===
{{par begin}}
{{par | v | view to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Complexity===
Constant.</text>
      <sha1>9tnd8ymtw7dyibweqlojjtn52e3k7v6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/basic string view/to string</title>
    <ns>0</ns>
    <id>13603</id>
    <revision>
      <id>71307</id>
      <parentid>71306</parentid>
      <timestamp>2014-06-09T04:54:07Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Swap function order.</comment>
      <text xml:space="preserve" bytes="922">{{cpp/experimental/basic_string_view/title | to_string | operator basic_string }}
{{cpp/experimental/basic_string_view/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts |
template&lt;class Allocator {{=}} allocator&lt;CharT&gt;&gt;
basic_string&lt;CharT, Traits, Allocator&gt;
    to_string(const Allocator&amp; a {{=}} Allocator()) const;
}}
{{dcl | since=libfund_ts |
template&lt;class Allocator&gt;
explicit operator basic_string&lt;CharT, Traits, Allocator&gt;() const;
}}
{{dcl end}}

Creates a {{tt|basic_string}} with a copy of the content of the current view.

===Template parameters===
{{par begin}}
{{par | Allocator | {{concept|Allocator}} type used to allocate internal storage}}
{{par end}}

===Parameters===
{{par begin}}
{{par | a | Allocator instance to use for allocating the new string}}
{{par end}}

===Return value===
A {{tt|basic_string}} containing a copy of the characters of the current view.

===Complexity===
Linear in {{tt|size()}}</text>
      <sha1>b4uqxj42fks33z245y8mf293ak6i2mf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs</title>
    <ns>0</ns>
    <id>13361</id>
    <revision>
      <id>68701</id>
      <parentid>68693</parentid>
      <timestamp>2014-03-19T16:35:14Z</timestamp>
      <contributor>
        <username>Nramsey</username>
        <id>2943</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3031">{{title|Filesystem library}}
{{cpp/experimental/fs/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This is work in progress, there may be inaccuracies}}

The Filesystem library provides facilities for performing operations on file systems and their components, such a paths, regular files, and directories.

The Filesystem library currently is described not in the C++ standard, but in separate Technical Specification. It is implementation-defined whether the Filesystem library is provided.

Some functionality may not be provided by the implementation if the underlying file system does not support it.

The behavior of the implementation may be different than described here in the presence of file-system races.

&lt;!--===[[cpp/experimental/fs/definitions | Definitions]]===--&gt;

{{dsc begin}}
{{dsc inc | cpp/experimental/fs/dsc path}}
{{dsc inc | cpp/experimental/fs/dsc filesystem_error}}
{{dsc inc | cpp/experimental/fs/dsc directory_entry}}
{{dsc inc | cpp/experimental/fs/dsc directory_iterator}}
{{dsc inc | cpp/experimental/fs/dsc recursive_directory_iterator}}
{{dsc inc | cpp/experimental/fs/dsc file_type}}
{{dsc inc | cpp/experimental/fs/dsc perms}}
{{dsc inc | cpp/experimental/fs/dsc file_status}}
{{dsc inc | cpp/experimental/fs/dsc space_info}}
{{dsc inc | cpp/experimental/fs/dsc copy_options}}
{{dsc inc | cpp/experimental/fs/dsc directory_options}}
{{dsc inc | cpp/experimental/fs/dsc file_time_type}}

{{dsc inc | cpp/experimental/fs/dsc absolute}}
{{dsc inc | cpp/experimental/fs/dsc canonical}}
{{dsc inc | cpp/experimental/fs/dsc copy}}
{{dsc inc | cpp/experimental/fs/dsc copy_file}}
{{dsc inc | cpp/experimental/fs/dsc copy_symlink}}
{{dsc inc | cpp/experimental/fs/dsc create_directory}}
{{dsc inc | cpp/experimental/fs/dsc create_hard_link}}
{{dsc inc | cpp/experimental/fs/dsc create_symlink}}
{{dsc inc | cpp/experimental/fs/dsc current_path}}
{{dsc inc | cpp/experimental/fs/dsc exists}}
{{dsc inc | cpp/experimental/fs/dsc equivalent}}
{{dsc inc | cpp/experimental/fs/dsc file_size}}
{{dsc inc | cpp/experimental/fs/dsc hard_link_count}}

{{dsc h2 | File types}}
{{dsc inc | cpp/experimental/fs/dsc is_block_file}}
{{dsc inc | cpp/experimental/fs/dsc is_character_file}}
{{dsc inc | cpp/experimental/fs/dsc is_directory}}
{{dsc inc | cpp/experimental/fs/dsc is_empty}}
{{dsc inc | cpp/experimental/fs/dsc is_fifo}}
{{dsc inc | cpp/experimental/fs/dsc is_other}}
{{dsc inc | cpp/experimental/fs/dsc is_regular_file}}
{{dsc inc | cpp/experimental/fs/dsc is_socket}}
{{dsc inc | cpp/experimental/fs/dsc is_symlink}}

{{dsc inc | cpp/experimental/fs/dsc last_write_time}}
{{dsc inc | cpp/experimental/fs/dsc read_symlink}}
{{dsc inc | cpp/experimental/fs/dsc remove}}
{{dsc inc | cpp/experimental/fs/dsc rename}}
{{dsc inc | cpp/experimental/fs/dsc resize_file}}
{{dsc inc | cpp/experimental/fs/dsc space}}
{{dsc inc | cpp/experimental/fs/dsc status}}
{{dsc inc | cpp/experimental/fs/dsc system_complete}}
{{dsc inc | cpp/experimental/fs/dsc temp_directory_path}}
{{dsc end}}</text>
      <sha1>pl0gma70s1n381dap50yqxnquo6f71j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/absolute</title>
    <ns>0</ns>
    <id>13362</id>
    <revision>
      <id>68479</id>
      <parentid>68478</parentid>
      <timestamp>2014-03-19T00:37:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="850">{{cpp/experimental/fs/title|absolute}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
path absolute( const path&amp; p, const path&amp; base = current_path() );
}}
{{dcl end}}

Returns absolute path of {{tt|p}} relative to {{tt|base}} according to the following table:

{| class=&quot;wikitable&quot;
|-
| 
| p.has_root_directory()
| !p.has_root_directory()
|-
| p.has_root_name()
| return p
| return p.root_name() / absolute(base).root_directory() &lt;br&gt;
/ absolute(base).relative_path() / p.relative_path()
|-
| !p.has_root_name()
| absolute(base).root_name() / p
| return absolute(base) / p
|}

===Parameters===
{{todo}}

===Return value===
{{todo}}

===Exceptions===
{{todo}}

* {{c|std::bad_alloc}} if memory allocation fails

===Notes===
The returned path is always absolute.

===See also===
{{todo}}</text>
      <sha1>2d3nvidc3iyv7bnpimx7hgydq74x1vy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/canonical</title>
    <ns>0</ns>
    <id>13363</id>
    <revision>
      <id>68481</id>
      <parentid>68480</parentid>
      <timestamp>2014-03-19T00:37:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1046">{{cpp/experimental/fs/title|canonical}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
path canonical( const path&amp; p, const path&amp; base {{=}} current_path() );
}}
{{dcl | num=2 | since=fs_ts | 1=
path canonical( const path&amp; p, error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
path canonical( const path&amp; p, const path&amp; base, error_code&amp; ec );
}}
{{dcl end}}

Converts path {{tt|p}} to a canonical absolute path, i.e. one that has no dot, dot-dot elements or symbolic links. {{tt|p}} is optionally relative to {{tt|base}}.

{{tt|p}} must resolve to an existing file, otherwise error occurs.

The return path resolves to the same path as {{c|absolute(p, base}} (or {{c|absolute(p)}} for (2)}}.

{{todo|errors}}

===Parameters===
{{todo}}
{{par begin}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
The canonical absolute path of {{tt|p}}, which is optionally relative to {{tt|base}}.

===Exceptions===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>gismjqm03o1lam0m0c4ne54k71537kr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/copy</title>
    <ns>0</ns>
    <id>13364</id>
    <revision>
      <id>68483</id>
      <parentid>68482</parentid>
      <timestamp>2014-03-19T00:37:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="792">{{cpp/experimental/fs/title|copy}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
void copy( const path&amp; from, const path&amp; to );
}}
{{dcl | num=2 | since=fs_ts | 1=
void copy( const path&amp; from, const path&amp; to, error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
void copy( const path&amp; from, const path&amp; to, copy_options options );
}}
{{dcl | num=4 | since=fs_ts | 1=
void copy( const path&amp; from, const path&amp; to, copy_options options, 
           error_code&amp; ec );
}}
{{dcl end}}

Copies file or directory.

{{todo}}

===Parameters===
{{todo}}
{{par begin}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{todo}}

@2,4@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>ixz9gy4vyv6pk2y1wdcyrui5cv8vvo5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/copy file</title>
    <ns>0</ns>
    <id>13365</id>
    <revision>
      <id>68485</id>
      <parentid>68484</parentid>
      <timestamp>2014-03-19T00:37:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1073">{{cpp/experimental/fs/title|copy_file}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool copy_file( const path&amp; from, const path&amp; to );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool copy_file( const path&amp; from, const path&amp; to, 
                error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool copy_file( const path&amp; from, const path&amp; to, copy_options options );
}}
{{dcl | num=4 | since=fs_ts | 1=
bool copy_file( const path&amp; from, const path&amp; to, copy_options options,
                error_code&amp; ec );
}}
{{dcl end}}

Copies file contents and their attributes.

@1@ Equivalent to {{c|copy_file(from, to, copy_options::none)}}.

@2@ Equivalent to {{c|copy_file(from, to, copy_options::none, ec)}}.

{{todo}}

The functions involve at most one direct or indirect call to {{c|status(to)}}.

===Parameters===
{{todo}}
{{par begin}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
{{todo}}

===Exceptions===
{{todo}}

@2,4@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>1zeqforvlb69jnozw7vwdma0212a7q2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/copy options</title>
    <ns>0</ns>
    <id>13366</id>
    <revision>
      <id>68487</id>
      <parentid>68486</parentid>
      <timestamp>2014-03-19T00:37:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1398">{{cpp/experimental/fs/title|copy_options}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
enum class copy_options {
    none = 0,
    skip_existing = 1,
    overwrite_existing = 2,
    update_existing = 4,
    recursive = 8,
    copy_symlinks = 16,
    skip_symlinks = 32,
    directories_only = 64,
    create_symlinks = 128,
    create_hard_links = 256
};
}}
{{dcl end}}

{{todo}}

===Constants===
{{dsc begin}}
{{dsc hitem | Constant | Meaning}}
{{dsc | {{tt|skip_existing}} | do not overwrite existing file or report an error}}
{{dsc | {{tt|overwrite_existing}} | overwrite existing file}}
{{dsc | {{tt|update_existing}} | overwrite existing file if it is older than the replacement}}
{{dsc | {{tt|recursive}} | recursively copy sub-directories and their contents}}
{{dsc | {{tt|copy_symlinks | do not resolve the symbolic links -- copy them as links instead of copying the pointed to files}}
{{dsc | {{tt|skip_symlinks}} | ignore symbolic links}}
{{dsc | {{tt|directories-only}} | copy directory structure only, skip all files}}
{{dsc | {{tt|create_symlinks}} | create symlinks instead of copying the files. The source path shall be an absolute path unless the destination path is in the current directory.}}
{{dsc | {{tt|create_hard_links}} | create hard links instead of copying the files}}
{{dsc end}}

===See also===
{{todo}}</text>
      <sha1>rjanxbmwvuhapag2eybztxlnwzef1va</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/copy symlink</title>
    <ns>0</ns>
    <id>13367</id>
    <revision>
      <id>68489</id>
      <parentid>68488</parentid>
      <timestamp>2014-03-19T00:37:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1105">{{cpp/experimental/fs/title|copy_symlink}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
void copy_symlink( const path&amp; from, const path&amp; to);
}}
{{dcl | num=2 | since=fs_ts | 1=
void copy_symlink( const path&amp; from, const path&amp; to,
                   error_code&amp; ec );
}}
{{dcl end}}

Copies a symlink to another location.

@1@ Effectively calls {{c|f(read_symlink(from), to)}} where {{tt|f}} is {{c|create_symlink()}} or {{c|create_directory_symlink}} depending on whether {{tt|from}} resolves to a file or directory.

@2@ Effectively calls {{c|f(read_symlink(from, ec), to, ec)}} where {{tt|f}} is {{c|create_symlink()}} or {{c|create_directory_symlink}} depending on whether {{tt|from}} resolves to a file or directory.

{{todo|errors}}

===Parameters===
{{par begin}}
{{par | from | path to a symbolic link to copy}}
{{par | to | destination path of the new symlink}}
{{par | ec | error code to store the error status}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{todo}}

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>9uzh5dji5tsbyj45t1z9x9lkaqgqhq1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/create directory</title>
    <ns>0</ns>
    <id>13368</id>
    <revision>
      <id>68491</id>
      <parentid>68490</parentid>
      <timestamp>2014-03-19T00:37:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="2574">{{cpp/experimental/fs/title|create_directory,create_directories}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool create_directory( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool create_directory( const path&amp; p, error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool create_directory( const path&amp; p, const path&amp; existing_p );
}}
{{dcl | num=4 | since=fs_ts | 1=
bool create_directory( const path&amp; p, const path&amp; existing_p, error_code&amp; ec );
}}
{{dcl | num=5 | since=fs_ts | 1=
bool create_directories( const path&amp; p );
}}
{{dcl | num=6 | since=fs_ts | 1=
bool create_directories( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Creates directory that {{tt|p}} resolves to. Directory creating failures caused by an already existing directory at {{tt|p}} are not treated as errors.

@1-4@ Parent directories are not created. If parent directory of {{tt|p}} does not exist, error occurs. (3-4) additionally copy operating system-dependent set of attributes from {{tt|existing_p}} to the newly created directory.

@5-6@ If parent directory does not exist, any missing directories are created as if by call to {{tt|create_directory}}.

{{tt|true}} is returned on success, {{tt|false}} on failure.

The (2), (4) and (6) overloads set {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | p | the path to the new directory to create}}
{{par | existing_p | the path to a directory to copy the attributes from}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if directory creation is successful, {{c|false}} otherwise.

===Exceptions===
@1,3,5@ {{c|filesystem_error}} if a directory can not be created or any other error occurs. The exception object is constructed with {{tt|p}} (and {{tt|existing_p}} in case of (3-4)) as an argument. The error code is set to appropriate operating system dependent value.

@2,4,6@ {{noexcept}}

===Notes===

On POSIX systems, new directories are created as if by calling {{c|mkdir(p.c_str(), S_IRWXU{{!}}S_IRWXG{{!}}S_IRWXO)}}.

On POSIX systems, the attributes copied by (3-4) are those copied by {{c|mkdir(p.c_str(), attr.st_mode}}, where {{tt|attr}} are retrieved as if by {{c|stat(existing_p.c_str(), &amp;attr)}}.

On Windows-based operating systems the attributes copied by (3-4) are those copied by native {{tt|CreateDirectoryExW(existing_p.c_str(), p.c_str(), 0)}}.

===See also===
{{todo}}</text>
      <sha1>lk6ff799tyhk9cge0wplpmmohdvaxum</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/create hard link</title>
    <ns>0</ns>
    <id>13369</id>
    <revision>
      <id>68493</id>
      <parentid>68492</parentid>
      <timestamp>2014-03-19T00:37:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1496">{{cpp/experimental/fs/title|create_hard_link}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
void create_hard_link( const path&amp; to, const path&amp; new_link );
}}
{{dcl | num=2 | since=fs_ts | 1=
void create_hard_link( const path&amp; to, const path&amp; new_link,
                       error_code&amp; ec );
}}
{{dcl end}}

Creates a hard link at {{tt|new_link}} which links to a file or directory {{tt|to}}. {{c|equivalent(to, new_link)}} holds after successful creation of a hard link.

The contents of {{tt|to}} are not changed.

The second overload sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

Symbolic link support depends on the operating system the program runs on and on the target file system. Some operating systems do not support hard links or support hard links only for regular files. Some file systems do not support hard links at all. 

===Parameters===
{{par begin}}
{{par | to | path of the file to link to}}
{{par | new_link | path of the new symbolic link}}
{{par | ec | error code to store the error state to}}
{{par end}}

===Return value===
(none)

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|to}} and {{tt|new_link}} as arguments. The error code is set to an appropriate error code for the error that caused the failure.

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>kgtzf9mkprcujsmjh21crtyp4vx4r4a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/create symlink</title>
    <ns>0</ns>
    <id>13370</id>
    <revision>
      <id>68495</id>
      <parentid>68494</parentid>
      <timestamp>2014-03-19T00:37:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1820">{{cpp/experimental/fs/title|create_symlink,create_directory_symlink}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
void create_symlink( const path&amp; to, const path&amp; new_symlink );
}}
{{dcl | num=2 | since=fs_ts | 1=
void create_symlink( const path&amp; to, const path&amp; new_symlink,
                     error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
void create_directory_symlink( const path&amp; to, const path&amp; new_symlink );
}}
{{dcl | num=4 | since=fs_ts | 1=
void create_directory_symlink( const path&amp; to, const path&amp; new_symlink,
                               error_code&amp; ec );
}}
{{dcl end}}

Creates a symbolic link from {{tt|new_symlink}} to {{tt|to}}. The (1-2) overloads should be used to create symbolic links to files whereas the (3-4) overloads should be used to create symbolic links to directories.

The (2) and (4) versions set {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

Symbolic link support depends on the operating system the program runs on and on the target file system. Some operating systems do not support symbolic links or support symbolic links only for regular files. Some file systems do not support symbolic links at all.

===Parameters===
{{par begin}}
{{par | to | path of the file to link to}}
{{par | new_symlink | path of the new symbolic link}}
{{par | ec | error code to store the error state to}}
{{par end}}

===Return value===
(none)

===Exceptions===
@1, 3@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|to}} and {{tt|new_symlink}} as arguments. The error code is set to an appropriate error code for the error that caused the failure.

@2, 4@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>nbvaqelextakmbwyacdfjj7922zc5qt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/current path</title>
    <ns>0</ns>
    <id>13371</id>
    <revision>
      <id>68497</id>
      <parentid>68496</parentid>
      <timestamp>2014-03-19T00:37:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1498">{{cpp/experimental/fs/title|current_path}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
path current_path();
}}
{{dcl | num=2 | since=fs_ts | 1=
path current_path( error_code&amp; ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
void current_path( const path&amp; p );
}}
{{dcl | num=4 | since=fs_ts | 1=
void current_path( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Returns or changes the current path.

@1-2@ Returns the absolute path of the current working directory. {{v|2}} returns {{c|path()}} if error occurs.

@3-4@ Changes the current working directory to {{tt|p}}.

===Parameters===
{{par begin}}
{{par | p | path to change the current working directory to}}
{{par | ec | error code to set in case of errors}}
{{par end}}

===Return value===
@1-2@ Returns the current working directory.

@3-4@ (none)

===Exceptions===
@1@ {{todo}}

@2@ {{noexcept}}

@3@ {{todo}}

@4@ {{noexcept}}

===Notes===

The current working directory is the directory that is used as the starting location in path resolution for relative paths. Single current working directory is associated with entire process.

The current working directory is a dangerous global state of the program. Behavior of various file input/output related functions are affected by the value of the current path. The current path may be unexpectedly changed by any component of the program, including various external libraries or other threads.

===See also===
{{todo}}</text>
      <sha1>qtwakhkhao6lw9caowcefs0wgvac4zw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry</title>
    <ns>0</ns>
    <id>13372</id>
    <revision>
      <id>68499</id>
      <parentid>68498</parentid>
      <timestamp>2014-03-19T00:37:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1096">{{cpp/experimental/fs/title|directory_entry}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
class directory_entry;
}}
{{dcl end}}

Represents a directory entry. The objects stores a {{tt|path}} and two {{tt|file_status}} objects: one for file status and the second for the pointed-to file status if the directory entry refers to a symbolic link.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc constructor}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc destructor}}

{{dsc h2 | Modifiers}}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc operator{{=}}}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc assign}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc replace_filename}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc path}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc status}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc symlink_status}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc operator_cmp}}
{{dsc end}}</text>
      <sha1>cm7kiqooxsssfpf32mh5spqrm3spafg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/assign</title>
    <ns>0</ns>
    <id>13373</id>
    <revision>
      <id>68501</id>
      <parentid>68500</parentid>
      <timestamp>2014-03-19T00:37:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="620">{{cpp/experimental/fs/directory_entry/title|assign}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
void assign( const path&amp; p, file_status status = file_status(),
             file_status symlink_status = file_status() );
}}
{{dcl end}}

Assigns new content to the directory entry object. Sets the path to {{tt|p}}, file status to {{tt|status}} and symlink status to {{tt|symlink_status}}.

===Parameters===
{{todo}}

===Return value===
(none)

===Exceptions===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc operator{{=}}}}
{{dsc end}}</text>
      <sha1>r7arkq3j4yl1c1nmirvsl1cg4yr9f9f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/directory entry</title>
    <ns>0</ns>
    <id>13374</id>
    <revision>
      <id>68503</id>
      <parentid>68502</parentid>
      <timestamp>2014-03-19T00:37:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="900">{{cpp/experimental/fs/directory_entry/title|directory_entry}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
directory_entry() = default;
}}
{{dcl | since=fs_ts | num=2 | 1=
directory_entry( const directory_entry&amp; ) = default;
}}
{{dcl | since=fs_ts | num=3 | 1=
directory_entry( directory_entry&amp;&amp; ) = default;
}}
{{dcl | since=fs_ts | num=4 | 1=
explicit directory_entry( const path&amp; p, file_status status = file_status(),
                          file_status symlink_status = file_status() );
}}
{{dcl end}}

Constructs a new {{tt|directory_entry}} object.

@1@ Default constructor.

@2@ Default copy constructor.

@3@ Default move constructor.

@4@ Initializes the directory entry with path {{tt|p}} and file and symlink statuses initialized to {{tt|status}} and {{tt|file_status}} respectively.

===Parameters===
{{todo}}

===Exceptions===
{{todo}}</text>
      <sha1>rngu7ht43ikn4zzk57ir595ci17r74d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/operator=</title>
    <ns>0</ns>
    <id>13375</id>
    <revision>
      <id>68505</id>
      <parentid>68504</parentid>
      <timestamp>2014-03-19T00:37:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="567">{{cpp/experimental/fs/directory_entry/title|operator{{=}}}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
directory_entry&amp; operator=( const directory_entry&amp; ) = default;
}}
{{dcl | since=fs_ts | num=2 | 1=
directory_entry&amp; operator=( directory_entry&amp;&amp;) = default;
}}
{{dcl end}}

Assigns another directory entry.

===Parameters===
{{todo}}

===Return value===
{{c|*this}}

===Exceptions===
{{todo}}

@2@ {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/directory_entry/dsc assign}}
{{dsc end}}</text>
      <sha1>0hcs8lch5oo4z58fjdfi77n5kglrc7v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/operator cmp</title>
    <ns>0</ns>
    <id>13376</id>
    <revision>
      <id>68507</id>
      <parentid>68506</parentid>
      <timestamp>2014-03-19T00:37:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="784">{{cpp/experimental/fs/directory_entry/title|1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
bool operator==( const directory_entry&amp; rhs ) const;
}}
{{dcl | since=fs_ts | 1=
bool operator!=( const directory_entry&amp; rhs ) const;
}}
{{dcl | since=fs_ts | 1=
bool operator&lt;( const directory_entry&amp; rhs ) const;
}}
{{dcl | since=fs_ts | 1=
bool operator&lt;=( const directory_entry&amp; rhs ) const;
}}
{{dcl | since=fs_ts | 1=
bool operator&gt;( const directory_entry&amp; rhs ) const;
}}
{{dcl | since=fs_ts | 1=
bool operator&gt;=( const directory_entry&amp; rhs ) const;
}}

Compares the path with the directory entry {{tt|rhs}}.

===Parameters===
{{todo}}

===Return value===
{{todo}}

===Exceptions===
{{noexcept}}

===See also===
{{todo}}</text>
      <sha1>fw5fh3i03xujvc23eamortorm4ojuet</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/path</title>
    <ns>0</ns>
    <id>13377</id>
    <revision>
      <id>68509</id>
      <parentid>68508</parentid>
      <timestamp>2014-03-19T00:37:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="377">{{cpp/experimental/fs/directory_entry/title|path}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
const path&amp; path() const;
}}
{{dcl end}}

Returns the full path the directory entry refers to.

===Parameters===
(none)

===Return value===
The full path the directory entry refers to.

===Exceptions===
{{noexcept}}

===See also===
{{todo}}</text>
      <sha1>6qy6lpt07buxi9tf84eaihki16shczi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/replace filename</title>
    <ns>0</ns>
    <id>13378</id>
    <revision>
      <id>68511</id>
      <parentid>68510</parentid>
      <timestamp>2014-03-19T00:37:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="810">{{cpp/experimental/fs/directory_entry/title|replace_filename}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
void replace_filename( const path&amp; p, file_status status = file_status(),
                       file_status symlink_status = file_status() );
}}
{{dcl end}}

Changes the filename and the cached file and symlink status of the directory entry.

Effectively sets path to {{c|path().parent_path() / p}}.

This function does not commit any changes to the filesystem.

===Parameters===
{{par begin}}
{{par | p | the path to append to the parent path of the currently stored path}}
{{par | status | new cached file status}}
{{par | symlink_status | new cached symlink status}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>9hnbpw5k456ekl5knre3cnmhy1qew2a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/status</title>
    <ns>0</ns>
    <id>13379</id>
    <revision>
      <id>68513</id>
      <parentid>68512</parentid>
      <timestamp>2014-03-19T00:37:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="830">{{cpp/experimental/fs/directory_entry/title|status}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
file_status status() const;
}}
{{dcl | since=fs_ts | 1=
file_status status( error_code&amp; ec ) const;
}}
{{dcl end}}

Returns the potentially cached status of the entry.

The second version returns {{c|file_status::none}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | ec | error code to set}}
{{par end}}

===Return value===
The status of the file referred to by the entry.

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with path of the directory entry as an argument.

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>k936cfs2w6rxa5lsgxqkp9gmm35sogu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory entry/symbolic status</title>
    <ns>0</ns>
    <id>13380</id>
    <revision>
      <id>68515</id>
      <parentid>68514</parentid>
      <timestamp>2014-03-19T00:37:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="615">{{cpp/experimental/fs/directory_entry/title|symlink_status}}
{{cpp/experimental/fs/directory_entry/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
file_status symlink_status() const;
}}
{{dcl | since=fs_ts | 1=
file_status symlink_status( error_code&amp; ec ) const;
}}
{{dcl end}}

Returns potentially cached status of the target of the symbolic link referred to by entry.

{{todo}}

===Parameters===
{{par begin}}
{{par | ec | error code to set in case of errors}}
{{par end}}

===Return value===
Returns the symlink status of the directory entry.

===Exceptions===
{{todo}}

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>jzjhpuv65clyzfe0ebbpgztwthw9dav</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory iterator</title>
    <ns>0</ns>
    <id>13381</id>
    <revision>
      <id>68517</id>
      <parentid>68516</parentid>
      <timestamp>2014-03-19T00:37:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1655">{{cpp/experimental/fs/title|directory_iterator}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
class directory_iterator : public std::iterator&lt;input_iterator_tag, directory_entry&gt;;
}}
{{dcl end}}

{{c|directory_iterator}} is an input iterator that can advance through entries of a directory. Directory iteration never returns directory entries to the current (dot) and parent (dot-dot) directories. The order of directory entries is unspecified.

The past-the-end iterator (simply called the end iterator) is a special iterator. An end iterator is always equal to an end iterator and never equal to a non-end iterator. An end iterator is created by the default constructor of directory iterator and when a directory iterator is advanced past the last directory element. Calling {{c|operator*}} or {{c|operator-&gt;}} on an end iterator yields undefined behavior.

If a file in a directory is deleted after the directory iterator has been created, the directory iterator may return a directory entry to the deleted file. If, on the other hand, a new file is created after the directory iterator has been created, iteration of the directory is not guaranteed to return a directory entry to the new file.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/directory_iterator/dsc constructor}}
{{dsc inc | cpp/experimental/fs/directory_iterator/dsc destructor}}
{{dsc inc | cpp/experimental/fs/directory_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/experimental/fs/directory_iterator/dsc operator*}}
{{dsc inc | cpp/experimental/fs/directory_iterator/dsc increment}}
{{dsc end}}</text>
      <sha1>s48i5ki7bkul41v88a29usr7ot71lu8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory iterator/directory iterator</title>
    <ns>0</ns>
    <id>13382</id>
    <revision>
      <id>68519</id>
      <parentid>68518</parentid>
      <timestamp>2014-03-19T00:37:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1180">{{cpp/experimental/fs/directory_iterator/title | directory_iterator}}
{{cpp/experimental/fs/directory_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
directory_iterator();
}}
{{dcl | num=2 | since=fs_ts | 1=
explicit directory_iterator( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
directory_iterator( const path&amp; p, error_code&amp; ec );
}}
{{dcl | num=4 | since=fs_ts | 1=
directory_iterator( const directory_iterator&amp; ) = default;
}}
{{dcl | num=5 | since=fs_ts | 1=
directory_iterator( directory_iterator&amp;&amp; ) = default;
}}
{{dcl end}}

Constructs a new directory iterator.

@1@ Constructs the end iterator.

@2@ Constructs a directory iterator that refers to the first directory entry of a directory identified by {{tt|p}}. If {{tt|p}} refers to an non-existing file or not a directory, returns the end iterator.

===Parameters===
{{todo}}

===Exceptions===
@1@ {{noexcept}}

@2@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument.

@3@ {{noexcept}}

===Notes===
To iterate over the current directory, construct the iterator as {{c|directory_iterator(&quot;.&quot;)}} instead of {{c|directory_iterator(&quot;&quot;)}}.</text>
      <sha1>io9suhw518satcmxbmignpm8kg47mtm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory iterator/increment</title>
    <ns>0</ns>
    <id>13383</id>
    <revision>
      <id>68521</id>
      <parentid>68520</parentid>
      <timestamp>2014-03-19T00:37:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="489">{{cpp/experimental/fs/directory_iterator/title | operator{{=}}}}
{{cpp/experimental/fs/directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
directory_iterator&amp; operator++();

directory_iterator&amp; increment( error_code&amp; ec ) noexcept;
}}
{{dcl end}}

Advances the iterator to the next entry.

{{todo}}

===Parameters===
{{par begin}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{todo}}

@2@ {{noexcept}}</text>
      <sha1>bib1r1z8f0kpvz1aqwfa7qs1cfc2x7a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory iterator/operator*</title>
    <ns>0</ns>
    <id>13384</id>
    <revision>
      <id>68523</id>
      <parentid>68522</parentid>
      <timestamp>2014-03-19T00:37:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="402">{{cpp/experimental/fs/directory_iterator/title | operator*,operator-&gt;}}
{{cpp/experimental/fs/directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
const directory_entry&amp; operator*() const;
        
const directory_entry* operator-&gt;() const;
}}
{{dcl end}}

Accesses the pointed-to directory entry.

{{todo}}

===Parameters===
(none)

===Return value===
{{todo}}

===Exceptions===
{{todo}}</text>
      <sha1>c74se28t3m57x174fh3wn8fw4nxbd1n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory iterator/operator=</title>
    <ns>0</ns>
    <id>13385</id>
    <revision>
      <id>68525</id>
      <parentid>68524</parentid>
      <timestamp>2014-03-19T00:37:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="396">{{cpp/experimental/fs/directory_iterator/title | operator{{=}}}}
{{cpp/experimental/fs/directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
directory_iterator&amp; operator=(const directory_iterator&amp;) = default;

directory_iterator&amp; operator=(directory_iterator&amp;&amp;) = default;
}}
{{dcl end}}

{{todo}}

===Parameters===
{{todo}}

===Return value===
{{c|*this}}

===Exceptions===
{{todo}}</text>
      <sha1>a3iuf8jadm24cwh6e04syyp16c70mhi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/directory options</title>
    <ns>0</ns>
    <id>13386</id>
    <revision>
      <id>68527</id>
      <parentid>68526</parentid>
      <timestamp>2014-03-19T00:37:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="309">{{cpp/experimental/fs/title|directory_options}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl  | since=fs_ts | 1=
enum class directory_options {
    none,
    follow_directory_symlink,
    skip_permission_denied
}
}}
{{dcl end}}

{{todo}}

===See also===
{{todo}}</text>
      <sha1>ijtld4c5lnbahg34jouruahjand2o6d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/equivalent</title>
    <ns>0</ns>
    <id>13387</id>
    <revision>
      <id>68529</id>
      <parentid>68528</parentid>
      <timestamp>2014-03-19T00:37:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1204">{{cpp/experimental/fs/title|equivalent}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool equivalent( const path&amp; p1, const path&amp; p2 );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool equivalent( const path&amp; p1, const path&amp; p2, error_code&amp; ec );
}}
{{dcl end}}

Checks whether the paths {{tt|p1}} and {{tt|p2}} refer to the same file or directory.

Internally, the function checks whether the paths have the same file status and resolve to the same file system entity, i.e. are on the same physical device at the same location.

The second version sets {{tt|ec}} to an appropriate error code and returns false if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | p1, p2 | paths to check for equivalence}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
{{c|true}} if the paths refer to the same file or directory.

===Exceptions===
@1@ {{c|filesystem_error}} if
:* neither of the paths resolve to an existing file 
:* both paths resolve to a file of type ''other''
:* other error occurs

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>kgcjzj9ot9ykfm8sc32rdti5nfk0ps4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/exists</title>
    <ns>0</ns>
    <id>13388</id>
    <revision>
      <id>68531</id>
      <parentid>68530</parentid>
      <timestamp>2014-03-19T00:37:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1343">{{cpp/experimental/fs/title|exists}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool exists( file_status s ) noexcept;
}}
{{dcl | num=2 | since=fs_ts | 1=
bool exists( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool exists( const path&amp; p, error_code&amp; ec ) noexcept;
}}
{{dcl end}}

Checks if the given file status or path corresponds to an existing file or directory.

@1@ Equivalent to {{c|status_known(s) &amp;&amp; s.type() {{!=}} file_type::not_found}}.

@2@ Equivalent to {{c|exists(status(p))}}.

@3@ Equivalent to {{c|exists(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to an existing file or directory, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>rbax5641pxi8ttx40al8klre40b31d4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file size</title>
    <ns>0</ns>
    <id>13389</id>
    <revision>
      <id>68533</id>
      <parentid>68532</parentid>
      <timestamp>2014-03-19T00:37:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1090">{{cpp/experimental/fs/title|file_size}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
uintmax_t file_size( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
uintmax_t file_size( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Returns the size of a regular file. If {{tt|p}} does not resolve to a regular file, returns {{c|-1}}.

The second version sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

{{todo|does the first version throw if {{tt|p}} is not a regular file?}}

===Parameters===
{{par begin}}
{{par | p | path to the regular file}}
{{par | ec | error code to modify in case of error}}
{{par end}}

===Return value===
The size of the file or {{c|-1}} on error.

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>2iqyao7ce9alq01uhor0jpmsrsafa82</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file status</title>
    <ns>0</ns>
    <id>13390</id>
    <revision>
      <id>68535</id>
      <parentid>68534</parentid>
      <timestamp>2014-03-19T00:37:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="604">{{cpp/experimental/fs/title|file_status}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
class file_status;
}}
{{dcl end}}

Stores information about the type and permissions of a file. 

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/file_status/dsc constructor}}
{{dsc inc | cpp/experimental/fs/file_status/dsc operator{{=}}}}
{{dsc inc | cpp/experimental/fs/file_status/dsc destructor}}

{{dsc inc | cpp/experimental/fs/file_status/dsc type}}
{{dsc inc | cpp/experimental/fs/file_status/dsc permissions}}
{{dsc end}}</text>
      <sha1>1d5csxwer8q37mpg6o39n9vk6ogxsga</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file status/file status</title>
    <ns>0</ns>
    <id>13391</id>
    <revision>
      <id>68537</id>
      <parentid>68536</parentid>
      <timestamp>2014-03-19T00:37:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="699">{{cpp/experimental/fs/file_status/title|file_status}}
{{cpp/experimental/fs/file_status/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
file_status( const file_status&amp; ) = default;
}}
{{dcl | since=fs_ts | num=2 | 1=
file_status( file_status&amp;&amp; ) = default;
}}
{{dcl | since=fs_ts | num=3 | 1=
explicit file_status( file_type type = file_type::none,
                      perms permissions = perms::unknown);
}}
{{dcl end}}

Constructs a new {{tt|file_status}} object.

@1@ Default copy constructor.

@2@ Default move constructor.

@3@ Initializes the file status object with {{tt|type}} as type and {{tt|permissions}} as permissions.

===Parameters===
{{todo}}

===Exceptions===
{{noexcept}}</text>
      <sha1>nukin4jd5z1bkc6xleh37lw9ou4rgdu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file status/operator=</title>
    <ns>0</ns>
    <id>13392</id>
    <revision>
      <id>68539</id>
      <parentid>68538</parentid>
      <timestamp>2014-03-19T00:37:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="605">{{cpp/experimental/fs/file_status/title|operator{{=}}}}
{{cpp/experimental/fs/file_status/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
file_status&amp; operator=( const file_status&amp; other ) = default;
}}
{{dcl | since=fs_ts | num=2 | 1=
file_status&amp; operator=( file_status&amp;&amp; other ) = default;
}}
{{dcl | since=fs_ts | num=3 | 1=
explicit file_status( file_type type = file_type::none,
                      perms permissions = perms::unknown);
}}
{{dcl end}}

Copy- or move-assigns another file type object.

===Parameters===
{{todo}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}</text>
      <sha1>iw2p1yw3q6eip97mli3xsolan5xy9ji</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file status/permissions</title>
    <ns>0</ns>
    <id>13393</id>
    <revision>
      <id>68541</id>
      <parentid>68540</parentid>
      <timestamp>2014-03-19T00:37:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="561">{{cpp/experimental/fs/file_status/title|permissions}}
{{cpp/experimental/fs/file_status/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
perms permissions() const;
}}
{{dcl | since=fs_ts | num=2 | 1=
void permissions( perms perm );
}}
{{dcl end}}

Accesses the file permissions information.

@1@ Returns file permissions information.

@2@ Sets file type to {{tt|perm}}.

===Parameters===
{{par begin}}
{{par | perm | file permissions to set to}}
{{par end}}

===Return value===
@1@ File permissions information.

@2@ (none)

===Exceptions===
{{noexcept}}</text>
      <sha1>1qicj1q8bqbyw1b7lm39nsmjvmsqlz8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file status/type</title>
    <ns>0</ns>
    <id>13394</id>
    <revision>
      <id>68543</id>
      <parentid>68542</parentid>
      <timestamp>2014-03-19T00:37:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="520">{{cpp/experimental/fs/file_status/title|type}}
{{cpp/experimental/fs/file_status/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 | 1=
file_type type() const;
}}
{{dcl | since=fs_ts | num=2 | 1=
void type( file_type type );
}}
{{dcl end}}

Accesses the file type information.

@1@ Returns file type information.

@2@ Sets file type to {{tt|type}}.

===Parameters===
{{par begin}}
{{par | type | file type to set to}}
{{par end}}

===Return value===
@1@ File type information.

@2@ (none)

===Exceptions===
{{noexcept}}</text>
      <sha1>54708s5ck1r31rcegisyqpbbkznk1fd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file time type</title>
    <ns>0</ns>
    <id>13395</id>
    <revision>
      <id>68545</id>
      <parentid>68544</parentid>
      <timestamp>2014-03-19T00:37:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="280">{{cpp/experimental/fs/title|file_time_type}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
using file_time_type = chrono::time_point&lt;/*trivial-clock*/&gt;;
}}
{{dcl end}}

Represents file time.

===See also===
{{todo}}</text>
      <sha1>isk7khum97cxkx16krp48yfqcb2h43m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/file type</title>
    <ns>0</ns>
    <id>13396</id>
    <revision>
      <id>68547</id>
      <parentid>68546</parentid>
      <timestamp>2014-03-19T00:37:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1120">{{cpp/experimental/fs/title|file_type}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
enum class file_type {
    none = 0,
    not_found = -1,
    regular = 1,
    directory = 2,
    symlink = 3,
    block = 4,
    character = 5,
    fifo = 6,
    socket = 7,
    unknown = 8
};
}}
{{dcl end}}

Indicates a type of a file or directory a path refers to.
{{todo}}

===Constants===
{{dsc begin}}
{{dsc hitem | Constant | Meaning}}
{{dsc | {{tt|none}} | indicates that the file status has not been evaluated yet, or an error occurred when evaluating it}}
{{dsc | {{tt|not_found}} | indicates that the file was not found (this is not considered an error) }}
{{dsc | {{tt|regular}} | a regular file}}
{{dsc | {{tt|directory}} | a directory}}
{{dsc | {{tt|symlink}} | a symbolic link}}
{{dsc | {{tt|block}} | a block special file}}
{{dsc | {{tt|character}} | a character special file}}
{{dsc | {{tt|fifo}} | a FIFO (also known as pipe) file}}
{{dsc | {{tt|socket}} | a socket file}}
{{dsc | {{tt|unknown}} | an unknown file}}
{{dsc end}}

===See also===
{{todo}}</text>
      <sha1>15mhyo5d7zn6t6ht7555bd33sj963mt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/filesystem error</title>
    <ns>0</ns>
    <id>13397</id>
    <revision>
      <id>68549</id>
      <parentid>68548</parentid>
      <timestamp>2014-03-19T00:37:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="547">{{cpp/experimental/fs/title|filesystem_error}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
class filesystem_error;
}}
{{dcl end}}

An exception type thrown when errors are encountered.

{{todo|add inheritance diagram}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/filesystem_error/dsc constructor}}
{{dsc inc | cpp/experimental/fs/filesystem_error/dsc path}}
{{dsc inc | cpp/experimental/fs/filesystem_error/dsc what}}
{{dsc end}}

===See also===
{{todo}}</text>
      <sha1>8tk3vs93on3dq88bdd20bnxdrmkgqq8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/filesystem error/filesystem error</title>
    <ns>0</ns>
    <id>13398</id>
    <revision>
      <id>68551</id>
      <parentid>68550</parentid>
      <timestamp>2014-03-19T00:37:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="772">{{cpp/experimental/fs/filesystem_error/title|filesystem_error}}
{{cpp/experimental/fs/filesystem_error/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
filesystem_error( const string&amp; what_arg, error_code ec );
}}
{{dcl | num=2 | since=fs_ts | 1=
filesystem_error( const string&amp; what_arg, const path&amp; p1, error_code ec );
}}
{{dcl | num=3 | since=fs_ts | 1=
filesystem_error( const string&amp; what_arg, const path&amp; p1, const path&amp; p2, error_code ec );
}}
{{dcl end}}

Constructs a new filesystem error object. The explanatory string is set to {{tt|what_arg}}, error code is set to {{tt|ec}} and optionally, the paths that were involved in the operation that resulted in the error, are set to {{tt|p1}} and {{tt|p2}}.

===Parameters===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>8niau1aanubucq5ta122e6rhn59iig9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/filesystem error/path</title>
    <ns>0</ns>
    <id>13399</id>
    <revision>
      <id>68553</id>
      <parentid>68552</parentid>
      <timestamp>2014-03-19T00:37:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="402">{{cpp/experimental/fs/filesystem_error/title|path1,path2}}
{{cpp/experimental/fs/filesystem_error/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=fs_ts | 1=
const path&amp; path1() const;
}}
{{dcl | since=fs_ts | 1=
const path&amp; path2() const;
}}
{{dcl end}}

Returns the paths that were stored in the exception object.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{todo}}</text>
      <sha1>a0nvpqrk8vc37f44xmzfnjjeevgu2os</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/filesystem error/what</title>
    <ns>0</ns>
    <id>13400</id>
    <revision>
      <id>68555</id>
      <parentid>68554</parentid>
      <timestamp>2014-03-19T00:37:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="338">{{cpp/experimental/fs/filesystem_error/title|what}}
{{cpp/experimental/fs/filesystem_error/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
const char* what() const;
}}
{{dcl end}}

Returns the explanatory byte string that was stored in the exception object.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{todo}}</text>
      <sha1>lr4q2aa04db6lbjb28v8uvvhy8jf9hr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/hard link count</title>
    <ns>0</ns>
    <id>13401</id>
    <revision>
      <id>68557</id>
      <parentid>68556</parentid>
      <timestamp>2014-03-19T00:37:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="887">{{cpp/experimental/fs/title|hard_link_count}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
uintmax_t hard_link_count( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
uintmax_t hard_link_count( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Returns the number of hard links for the file identified by path {{tt|p}}.

The second version returns {{tt|-1}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared using {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | p | path to return the hard link count for}}
{{par end}}

===Return value===
The number of hard links for {{tt|p}}.

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument.

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>qkt3o8k5asafp9y0umdkr9kh2jcgf0y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is block file</title>
    <ns>0</ns>
    <id>13402</id>
    <revision>
      <id>68559</id>
      <parentid>68558</parentid>
      <timestamp>2014-03-19T00:37:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1303">{{cpp/experimental/fs/title|is_block_file}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_block_file( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_block_file( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_block_file( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a block special file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::character}}.

@2@ Equivalent to {{c|is_block_file(status(p))}}.

@3@ Equivalent to {{c|is_block_file(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a block special file.

===Exceptions===
@1,3@ {{noexcept}}

@2@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>rygodp9f8xcf0wxi2ohl3mg7294d7q7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is character file</title>
    <ns>0</ns>
    <id>13403</id>
    <revision>
      <id>68561</id>
      <parentid>68560</parentid>
      <timestamp>2014-03-19T00:37:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1362">{{cpp/experimental/fs/title|is_character_file}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_character_file( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_character_file( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_character_file( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a character special file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::character}}.

@2@ Equivalent to {{c|is_character_file(status(p))}}.

@3@ Equivalent to {{c|is_character_file(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a character special file, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>j5md8aobkuzxpwadr51fbe21wxwx5q9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is directory</title>
    <ns>0</ns>
    <id>13404</id>
    <revision>
      <id>68563</id>
      <parentid>68562</parentid>
      <timestamp>2014-03-19T00:37:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1104">{{cpp/experimental/fs/title|is_directory}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_directory( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_directory( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_directory( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the gived file status or path corresponds to a directory.

@1@ Equivalent to {{c|s.type() {{==}} file_type::character}}.

@2@ Equivalent to {{c|is_directory(status(p))}}.

@3@ Equivalent to {{c|is_directory(status(p, ec))}}. Returns {{c|false}} if error occurs.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to query}}
{{par | ec | error code to modify in case of errors}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a directory, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument.

===See also===
{{todo}}</text>
      <sha1>8o9tc1d1mn0hzu99a2vw1oit6iiuwmo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is empty</title>
    <ns>0</ns>
    <id>13405</id>
    <revision>
      <id>68565</id>
      <parentid>68564</parentid>
      <timestamp>2014-03-19T00:37:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1025">{{cpp/experimental/fs/title|is_empty}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_empty( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_empty( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks whether the given path refers to an empty file or directory.

The second version returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | p | path to examine}}
{{par | ec | error code to modify in case of error}}
{{par end}}

===Return value===
{{c|true}} if {{tt|p}} refers to an empty file or directory, {{c|false}} otherwise.

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

@2@ {{noexcept}}

===See also===
{{todo}}</text>
      <sha1>i5umz3dkczoqsmrp3yqj9hjsqjy13fw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is fifo</title>
    <ns>0</ns>
    <id>13406</id>
    <revision>
      <id>68567</id>
      <parentid>68566</parentid>
      <timestamp>2014-03-19T00:37:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1170">{{cpp/experimental/fs/title|is_fifo}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_fifo( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_fifo( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_fifo( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a FIFO or pipe file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::fifo}}.

@2@ Equivalent to {{c|is_fifo(status(p))}}.

@3@ Equivalent to {{c|is_fifo(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to query}}
{{par | ec | error code to modify in case of errors}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a FIFO file.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The exception object is constructed with {{tt|p}} as an argument.

===See also===
{{todo}}</text>
      <sha1>rm22o2f0n7vtgxh8qker8rj9tk7n6a4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is other</title>
    <ns>0</ns>
    <id>13407</id>
    <revision>
      <id>68569</id>
      <parentid>68568</parentid>
      <timestamp>2014-03-19T00:37:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1419">{{cpp/experimental/fs/title|is_other}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_other( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_other( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_other( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a file of type ''other'' type. That is, the file exists, but is neither regular file, nor directory nor a symlink.

@1@ Equivalent to {{c|exists(s) &amp;&amp; !is_regular_file(s) &amp;&amp; !is_directory(s) &amp;&amp; !is_symlink(s)}}.

@2@ Equivalent to {{c|is_other(status(p))}}.

@3@ Equivalent to {{c|is_other(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a ''other'' file, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The error is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>5z58iquvuc53b2djyohiuk41d4ska26</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is regular file</title>
    <ns>0</ns>
    <id>13408</id>
    <revision>
      <id>68571</id>
      <parentid>68570</parentid>
      <timestamp>2014-03-19T00:37:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1539">{{cpp/experimental/fs/title|is_regular_file}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_regular_file( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_regular_file( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_regular_file( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a regular file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::socket}}.

@2@ Equivalent to {{c|is_regular_file(status(p))}}.

@3@ Equivalent to {{c|is_regular_file(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

{{todo|the specification says that (2) throws filesystem_error if status(p) would throw filesystem_error. This is different from the rest of is_**_file functions. Is that correct and if yes, what's the rationale?}}

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a regular link, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The error is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>e896h10mfwiy67vleoduyxspa8m5g26</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is socket</title>
    <ns>0</ns>
    <id>13409</id>
    <revision>
      <id>68573</id>
      <parentid>68572</parentid>
      <timestamp>2014-03-19T00:37:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1285">{{cpp/experimental/fs/title|is_socket}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_socket( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_socket( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_socket( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a socket file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::socket}}.

@2@ Equivalent to {{c|is_socket(status(p))}}.

@3@ Equivalent to {{c|is_socket(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a socket file, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The error is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>c5wyf3uoprmyg4ea7brolyzaggn3m2f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/is symlink</title>
    <ns>0</ns>
    <id>13410</id>
    <revision>
      <id>68575</id>
      <parentid>68574</parentid>
      <timestamp>2014-03-19T00:37:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1296">{{cpp/experimental/fs/title|is_symlink}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_symlink( file_status s );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_symlink( const path&amp; p );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool is_symlink( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Checks if the given file status or path corresponds to a symbolic file.

@1@ Equivalent to {{c|s.type() {{==}} file_type::symlink}}.

@2@ Equivalent to {{c|is_symlink(status(p))}}.

@3@ Equivalent to {{c|is_symlink(status(p, ec))}}. Returns {{c|false}} and sets {{tt|ec}} to an appropriate error code if an error occurs. Otherwise, {{tt|ec}} is cleared with a call to {{c|ec.clear()}}.

===Parameters===
{{par begin}}
{{par | s | file status to check}}
{{par | p | path to examine}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|true}} if the given path or file status corresponds to a symbolic link, {{c|false}} otherwise.

===Exceptions===
@1,3@ {{noexcept}}

@2@ Throws {{c|filesystem_error}} if an error occurs. The error is constructed with {{tt|p}} as an argument. The error code is set to an appropriate error code for the error that caused the failure.

===See also===
{{todo}}</text>
      <sha1>ckako1wi1wuc7wfeujlddp8ncw3cnjh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path</title>
    <ns>0</ns>
    <id>13411</id>
    <revision>
      <id>68577</id>
      <parentid>68576</parentid>
      <timestamp>2014-03-19T00:37:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="3546">{{cpp/experimental/fs/title|path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 
class path;
}}
{{dcl end}}

Objects of type {{tt|path}} represent a path. Only syntactic aspects of paths are handled: the pathname may represent a non-existing path or even one that is not allowed on the current operating or file system.

The path can be traversed element-wise via iterators returned by the {{lc|begin()}} and {{lc|end()}} functions.

Calling any non-const member function of a {{tt|path}} invalidates all iterators referring to elements of that object.

The forward traversal is done in the following order:
* The root name element, if any
* The root directory element, if any. The element is presented in generic format, thus lexicographical comparisons work correctly.
* Each successive filename element.
* {{tt|.}} if one or mare trailing non-root {{tt|/}} characters are present.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | value_type | todo }}
{{dsc | string_type | {{c|std::basic_string&lt;value_type&gt;}}}}
{{dsc | iterator | a constant {{concept|BidirectionalIterator}} with a {{tt|value_type}} of {{tt|path}}}}
{{dsc | const_iterator | todo}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr value_type}} preferred_separator | todo }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc constructor}}
{{dsc inc | cpp/experimental/fs/path/dsc destructor}}
{{dsc inc | cpp/experimental/fs/path/dsc operator{{=}}}}
{{dsc inc | cpp/experimental/fs/path/dsc assign}}

{{dsc h2 | Concatenation}}
{{dsc inc | cpp/experimental/fs/path/dsc append}}
{{dsc inc | cpp/experimental/fs/path/dsc concat}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/experimental/fs/path/dsc clear}}
{{dsc inc | cpp/experimental/fs/path/dsc make_preferred}}
{{dsc inc | cpp/experimental/fs/path/dsc remove_filename}}
{{dsc inc | cpp/experimental/fs/path/dsc replace_filename}}
{{dsc inc | cpp/experimental/fs/path/dsc replace_extension}}
{{dsc inc | cpp/experimental/fs/path/dsc swap}}

{{dsc h2 | Format observers}}
{{dsc inc | cpp/experimental/fs/path/dsc native}}
{{dsc inc | cpp/experimental/fs/path/dsc c_str}}
{{dsc inc | cpp/experimental/fs/path/dsc string}}
{{dsc inc | cpp/experimental/fs/path/dsc generic_string}}

{{dsc h2 | Compare}}
{{dsc inc | cpp/experimental/fs/path/dsc compare}}

{{dsc h2 | Decomposition}}
{{dsc inc | cpp/experimental/fs/path/dsc root_name}}
{{dsc inc | cpp/experimental/fs/path/dsc root_directory}}
{{dsc inc | cpp/experimental/fs/path/dsc root_path}}
{{dsc inc | cpp/experimental/fs/path/dsc relative_path}}
{{dsc inc | cpp/experimental/fs/path/dsc parent_path}}
{{dsc inc | cpp/experimental/fs/path/dsc filename}}
{{dsc inc | cpp/experimental/fs/path/dsc stem}}
{{dsc inc | cpp/experimental/fs/path/dsc extension}}

{{dsc h2 | Queries}}
{{dsc inc | cpp/experimental/fs/path/dsc empty}}
{{dsc inc | cpp/experimental/fs/path/dsc has_path}}
{{dsc inc | cpp/experimental/fs/path/dsc is_absrel}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/experimental/fs/path/dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc end}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc swap2}}
{{dsc inc | cpp/experimental/fs/path/dsc operator_cmp}}
{{dsc inc | cpp/experimental/fs/path/dsc operator/}}
{{dsc inc | cpp/experimental/fs/path/dsc operator_ltltgtgt}}
{{dsc inc | cpp/experimental/fs/path/dsc u8path}}
{{dsc end}}</text>
      <sha1>mbgogm2uuauwwuj50xax3yvx0thyg97</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/append</title>
    <ns>0</ns>
    <id>13412</id>
    <revision>
      <id>68579</id>
      <parentid>68578</parentid>
      <timestamp>2014-03-19T00:37:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1133">{{cpp/experimental/fs/path/title|append,operator/{{=}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; append( const Source&amp; source );
}}
{{dcl | num=2 | since=fs_ts | 1=
template&lt; class InputIt &gt;
path&amp; append( InputIt first, InputIt last );
}}
{{dcl | num=3 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; operator/=( const Source&amp; source );
}}
{{dcl end}}

Appends the given path to the current path, inserting preferred directory separator if needed.

The directory iterator is not appended if any of the following conditions hold:

* an added separator would be redundant
* would change a relative path to an absolute path
* {{tt|p}} is an empty path.
* the first character of {{c|p.native()}} is a separator.

{{todo}}

===Parameters===
{{par begin}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req | The value type of {{tt|InputIt}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>l79e049i2pzeddojp7xgrtcunwxiasy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/assign</title>
    <ns>0</ns>
    <id>13413</id>
    <revision>
      <id>68581</id>
      <parentid>68580</parentid>
      <timestamp>2014-03-19T00:37:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="981">{{cpp/experimental/fs/path/title|assign}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; assign( const Source&amp; source );
}}
{{dcl | num=2 | since=fs_ts | 1=
template&lt; class InputIt &gt;
path&amp; assign( InputIt first, InputIt last );
}}
{{dcl end}}

Assigns the contents to the {{tt|path}} object.

@1@ Assigns the range of {{tt|source}}. {{todo}}

@2@ Assigns the pathname identified by range {{tt|[first, last)}}.

===Parameters===
{{par begin}}
{{par | source | a range to assign}}
{{par | first, last | a range to assign}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req | The value type of {{tt|InputIt}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc operator{{=}}}}
{{dsc end}}</text>
      <sha1>6axx4ney0edmgemjvd2nx208t8viumo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/begin</title>
    <ns>0</ns>
    <id>13414</id>
    <revision>
      <id>68583</id>
      <parentid>68582</parentid>
      <timestamp>2014-03-19T00:37:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="483">{{cpp/experimental/fs/path/title|begin}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
iterator begin() const;
}}
{{dcl end}}

Returns an iterator to the first element of the path. 

If the path is empty, the returned iterator is equal to {{lc|end()}}.

===Parameters===
(none)

===Return value===
Iterator to the first element of the path.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc end}}
{{dsc end}}</text>
      <sha1>ojj4skcyg3z488pl3wb8jpdjyuxnvsk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/c str</title>
    <ns>0</ns>
    <id>13415</id>
    <revision>
      <id>68585</id>
      <parentid>68584</parentid>
      <timestamp>2014-03-19T00:37:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="444">{{cpp/experimental/fs/path/title|c_str}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
const value_type* c_str() const;
}}
{{dcl end}}

Returts C-string version of the path.

Equivalent to {{c|native().c_str()}}.

===Parameters===
(none)

===Return value===
C-string version of the path name.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc native}}
{{dsc end}}</text>
      <sha1>1c82klo56dp53yw41242ea6tg6h5nqj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/clear</title>
    <ns>0</ns>
    <id>13416</id>
    <revision>
      <id>68587</id>
      <parentid>68586</parentid>
      <timestamp>2014-03-19T00:37:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="273">{{cpp/experimental/fs/path/title|clear}}
{{cpp/experimental/fs/path/navbar}}
{{ddcl | since=fs_ts |
void clear();
}}

Clears the stored pathname. {{lc|clear()}} is {{c|true}} after the call.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}</text>
      <sha1>m9p3dqhkrmolt41bg1xjg1cjoeg4oqw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/compare</title>
    <ns>0</ns>
    <id>13417</id>
    <revision>
      <id>68589</id>
      <parentid>68588</parentid>
      <timestamp>2014-03-19T00:37:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1391">{{cpp/experimental/fs/path/title|compare}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
int compare( const path&amp; p ) const;
}}
{{dcl | num=2 | since=fs_ts | 1=
int compare( const std::string&amp; str ) const;
}}
{{dcl | num=3 | since=fs_ts | 1=
int compare( const value_type&amp; s ) const;
}}
{{dcl end}}

Compares the lexical representations of the path and another path.

@1@ Returns a value less than, equal to or greater than {{math|0}} if the native representation of the path ({{lc|native()}}) is respectively lexicographically less than, equal to or greater than the native representation of {{tt|p}} ({{c|p.native()}}).

@2@ Equivalent to {{c|compare(path(str))}}.

@3@ Equivalent to {{c|compare(path(s))}}.

===Parameters===
{{par begin}}
{{par | p | a path to compare to}}
{{par | str | a string representing path to compare to}}}
{{par | s | a null-terminated string representing path to compare to}}
{{par end}}

===Return value===
A value less than {{math|0}} if the path is lexicographically less than the given path.

A value equal to {{math|0}} if the path is lexicographically equal to the given path.

A value greater than {{math|0}} if the path is lexicographically greater than the given path.

===Exceptions===
@1@ {{noexcept}}

@2-3@ (none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc operator_cmp}}
{{dsc end}}</text>
      <sha1>3floctflfxrz5rnbz3gwqyaf1buvuqm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/concat</title>
    <ns>0</ns>
    <id>13418</id>
    <revision>
      <id>68591</id>
      <parentid>68590</parentid>
      <timestamp>2014-03-19T00:37:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1982">{{cpp/experimental/fs/path/title|concat,operator+{{=}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; operator+=( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
path&amp; operator+=( const string_type&amp; x );
}}
{{dcl | num=3 | since=fs_ts | 1=
path&amp; operator+=( const value_type* x );
}}
{{dcl | num=4 | since=fs_ts | 1=
path&amp; operator+=( value_type x );
}}
{{dcl | num=5 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; operator+=( const Source&amp; source );
}}
{{dcl | num=6 | since=fs_ts | 1=
template&lt; class CharT &gt;
path&amp; operator+=( CharT x );
}}
{{dcl | num=7 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; concat( const Source&amp; source );
}}
{{dcl | num=8 | since=fs_ts | 1=
template&lt; class InputIt &gt;
path&amp; concat( InputIterator first, InputIterator last );
}}
{{dcl end}}

Concatenates the current path and the argument. Differently from {{lc|append()}} or {{lc|operator/{{=}}}}, separator is not appended.

@1@ Concatenates the current path and {{c|p.native()}}

@2-4@ Concatenates the current path and {{tt|x}}

@5,7@ Concatenates the current path and ''[[todo|the effective argument]]''. The argument is firstly [[todo|converted]] to {{tt|path::value_type}} if such conversion is necessary.

@6@ Concatenates the current path and {{tt|x}}.

@8@ Concatenates the current path and the range {{tt|[first, last)}}.

===Parameters===
{{par begin}}
{{par | p | path to append}}
{{par | source | [[todo|''effective argument'']] to append}}
{{par | first, last | the [[todo|range]] to append}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req | The value type of {{tt|InputIt}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par req | {{tt|CharT}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>6d73gf0hzu31pufu45gni8a9zkyvqer</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/empty</title>
    <ns>0</ns>
    <id>13419</id>
    <revision>
      <id>68593</id>
      <parentid>68592</parentid>
      <timestamp>2014-03-19T00:37:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="406">{{cpp/experimental/fs/path/title|empty}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
bool empty() const;
}}
{{dcl end}}

Checks if the path is empty.

===Parameters===
(none)

===Return value===
{{c|true}} if the path is empty, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc has_path}}
{{dsc end}}</text>
      <sha1>8ktonooht205dejicbbbvptvjjfyhvu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/end</title>
    <ns>0</ns>
    <id>13420</id>
    <revision>
      <id>68595</id>
      <parentid>68594</parentid>
      <timestamp>2014-03-19T00:38:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="503">{{cpp/experimental/fs/path/title|end}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
iterator end() const;
}}
{{dcl end}}

Returns an iterator to the past-the-last element of the path. 

The iterator acts as a placeholder. Accessing it yields undefined behavior.

===Parameters===
(none)

===Return value===
Iterator to the past-the-last element of the path.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc begin}}
{{dsc end}}</text>
      <sha1>oexbz51qnbtw38t58eg12bsx2h51z4u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/extension</title>
    <ns>0</ns>
    <id>13421</id>
    <revision>
      <id>68597</id>
      <parentid>68596</parentid>
      <timestamp>2014-03-19T00:38:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1774">{{cpp/experimental/fs/path/title|extension}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path extension() const;
}}
{{dcl end}}

Returns the extension of the {{tt|filename()}} identified by the path.

The extension is the substring between the last {{tt|.}} character and the end of the filename. The return value of the function returns the {{tt|.}} character if an extension is present.

If the pathname is either {{tt|.}} or {{tt|..}}, or the pathname does not contain the {{tt|.}} character, then empty path is returned. 

Additional behavior may be defined by the implementations for file systems which append additional elements (such as alternate data streams or partitioned dataset names) to extensions.

===Parameters===
(none)

===Return value===
The extension of the current pathname or an empty path if there's no extension.

===Exceptions===
(none)

===Example===
{{example 
| code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt/bar.cc&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt/bar.&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt/bar&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/.&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/..&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/.hidden&quot;).extension() &lt;&lt; '\n';
}
| output=
.txt
.

.cc
.



.hidden
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc filename}}
{{dsc inc | cpp/experimental/fs/path/dsc stem}}
{{dsc end}}</text>
      <sha1>ppqajr3t8i6axyf8wq2qjme3hd2v99i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/filename</title>
    <ns>0</ns>
    <id>13422</id>
    <revision>
      <id>68599</id>
      <parentid>68598</parentid>
      <timestamp>2014-03-19T00:38:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1136">{{cpp/experimental/fs/path/title|filename}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path filename() const;
}}
{{dcl end}}

Returns the filename identified by the path. 

Equivalent to {{cc|empty() ? path() : *--end()}}.

===Parameters===
(none)

===Return value===
The filename identified by the path.

===Exceptions===
(none)

===Example===
{{example 
| code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/.bar&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar/&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/.&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/..&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;.&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;..&quot;).extension() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/&quot;).extension() &lt;&lt; '\n';
}
| output=
bar.txt
.bar
/

.cc
.
..
.
..
/
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc extension}}
{{dsc inc | cpp/experimental/fs/path/dsc stem}}
{{dsc end}}</text>
      <sha1>s8s0019sqlwl3im8x3dsvnklloczp8x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/generic string</title>
    <ns>0</ns>
    <id>13423</id>
    <revision>
      <id>68601</id>
      <parentid>68600</parentid>
      <timestamp>2014-03-19T00:38:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1480">{{cpp/experimental/fs/path/title|generic_string,generic_wstring,generic_u8string,...}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class CharT, class Traits = std::char_traits&lt;CharT&gt;
          class Alloc = std::allocator&lt;CharT&gt; &gt;
std::basic_string&lt;CharT,Traits,Alloc&gt;
    generic_string( const Allocator&amp; a = Allocator() ) const;
}}
{{dcl rev begin | num=2 | since=fs_ts}}
{{dcl | 
std::string generic_string() const;
}}
{{dcl |
std::wstring generic_wstring() const;
}}
{{dcl |
std::u8string generic_u8string() const;
}}
{{dcl |
std::u16string generic_u16string() const;
}}
{{dcl |
std::u32string generic_u32string() const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the internal pathname in generic pathname format, converted to specific string type. Conversion, if any, is specified in [[todo]]. The {{tt|/}} character is used as the directory separator. 

@1@ All memory allocations are performed by {{tt|a}}.

@2@ The encoding in the case of {{tt|u8string()}} is always UTF-8.

===Parameters===
{{par begin}}
{{par | a | allocator to construct the string with}}
{{par req | {{tt|CharT}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}

===Return value===
The internal pathname in generic pathname format, converted to specified string type.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc string}}
{{dsc end}}</text>
      <sha1>phwtsh6nx45lac9vestkirfqmhnajwp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/has path</title>
    <ns>0</ns>
    <id>13424</id>
    <revision>
      <id>68603</id>
      <parentid>68602</parentid>
      <timestamp>2014-03-19T00:38:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1324">{{cpp/experimental/fs/path/title|has_..._path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
bool has_root_path() const;
}}
{{dcl | num=2 | since=fs_ts | 1=
bool has_root_name() const;
}}
{{dcl | num=3 | since=fs_ts | 1=
bool has_root_directory() const;
}}
{{dcl | num=4 | since=fs_ts | 1=
bool has_relative_path() const;
}}
{{dcl | num=5 | since=fs_ts | 1=
bool has_parent_path() const;
}}
{{dcl | num=6 | since=fs_ts | 1=
bool has_filename() const;
}}
{{dcl | num=7 | since=fs_ts | 1=
bool has_stem() const;
}}
{{dcl | num=8 | since=fs_ts | 1=
bool has_extension() const;
}}
{{dcl end}}

Checks whether the path contains the corresponding path element.

@1@ Checks whether {{lc|root_path()}} is empty.

@2@ Checks whether {{lc|root_name()}} is empty.

@3@ Checks whether {{lc|root_directory()}} is empty.

@4@ Checks whether {{lc|relative_path()}} is empty.

@5@ Checks whether {{lc|parent_path()}} is empty.

@6@ Checks whether {{lc|filename()}} is empty.

@7@ Checks whether {{lc|stem()}} is empty.

@8@ Checks whether {{lc|extension()}} is empty.

===Parameters===
(none)

===Return value===
{{c|true}} if the corresponding path is not empty, {{c|false}} otherwise.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc empty}}
{{dsc end}}</text>
      <sha1>gwrgivb59w9bsw5o75k617xjuxdnkw9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/is absrel</title>
    <ns>0</ns>
    <id>13425</id>
    <revision>
      <id>68605</id>
      <parentid>68604</parentid>
      <timestamp>2014-03-19T00:38:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="749">{{cpp/experimental/fs/path/title|is_absolute,is_relative}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
bool is_absolute() const;
}}
{{dcl | num=2 | since=fs_ts | 1=
bool is_relative() const;
}}
{{dcl end}}

Checks whether the path is absolute or relative. An absolute path is such that the elements of {{c|root_path()}} uniquely identify a file system location. The first version returns {{c|true}} if the path is absolute, {{c|false}} otherwise; the second version the other way round.

===Parameters===
(none)

===Return value===
@1@ {{c|true}} if the path is absolute, {{c|false}} otherwise.

@2@ {{c|false}} if the path is absolute, {{c|true}} otherwise.

===Exceptions===
{{todo}}

===See also===
{{todo}}</text>
      <sha1>gl7zq5hh4785mkhoz938m7omqdaankt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/make preferred</title>
    <ns>0</ns>
    <id>13426</id>
    <revision>
      <id>68607</id>
      <parentid>68606</parentid>
      <timestamp>2014-03-19T00:38:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="488">{{cpp/experimental/fs/path/title|make_preferred}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; make_preferred()
}}
{{dcl end}}

Converts all directory separators in path to the preferred directory separator.

For example, on systems, where {{tt|\}} is the preferred separator, the path {{tt|foo/bar}} will be converted to {{tt|foo\bar}}.

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
(none)

===See also===
{{todo}}</text>
      <sha1>80fc42u5dy49oybd989l14x0p2j9nbt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/native</title>
    <ns>0</ns>
    <id>13427</id>
    <revision>
      <id>68609</id>
      <parentid>68608</parentid>
      <timestamp>2014-03-19T00:38:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="505">{{cpp/experimental/fs/path/title|native, operator string_type()}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
const string_type&amp; native() const;
}}
{{dcl | num=2 | since=fs_ts | 1=
operator string_type() const;
}}
{{dcl end}}

Returns the path name converted to the native path encoding.

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc c_str}}
{{dsc end}}</text>
      <sha1>homa19rb6717lo8zgtim3na4khxkt1g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/operator=</title>
    <ns>0</ns>
    <id>13428</id>
    <revision>
      <id>68611</id>
      <parentid>68610</parentid>
      <timestamp>2014-03-19T00:38:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="887">{{cpp/experimental/fs/path/title|operator{{=}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; operator=( const path&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
path&amp; operator=( path&amp;&amp; p );
}}
{{dcl | num=2 | since=fs_ts | 1=
template&lt; class Source &gt;
path&amp; operator=( const Source&amp; source );
}}
{{dcl end}}

Assigns the contents of another {{tt|path}} object.

@1@ Assigns the pathname of {{tt|p}}.

@2@ Assigns the pathname of {{tt|p}}. {{tt|p}} is in valid, but unspecified state after the call.

@3@ Assigns the range of the {{tt|source}}. {{todo}}

===Parameters===
{{par begin}}
{{par | p | a path to assign}}
{{par | source | a range to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ (none)

@2@ {{noexcept}}

@3@ (none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc assign}}
{{dsc end}}</text>
      <sha1>7sumhd1ie4rrx3zzt32bh2v0qvbbcfv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/operator cmp</title>
    <ns>0</ns>
    <id>13429</id>
    <revision>
      <id>68613</id>
      <parentid>68612</parentid>
      <timestamp>2014-03-19T00:38:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="2078">{{title|1=operator==,!=,&lt;,&lt;=,&gt;,&gt;={{small|(std::fs::path)}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
bool operator==( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl | num=2 | since=fs_ts | 1=
bool operator!=( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl | num=3 | since=fs_ts | 1=
bool operator&lt;( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl | num=4 | since=fs_ts | 1=
bool operator&lt;=( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl | num=5 | since=fs_ts | 1=
bool operator&gt;( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl | num=6 | since=fs_ts | 1=
bool operator&gt;=( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl end}}

Compares two paths lexicographically.

@1@ Checks whether {{tt|lhs}} and {{tt|rhs}} are equal. Equivalent to {{c|!(lhs &lt; rhs) &amp;&amp; !(rhs &lt; lhs)}}.

@2@ Checks whether {{tt|lhs}} and {{tt|rhs}} are not equal. Equivalent to {{c|!(lhs == rhs)}}.

@3@ Checks whether {{tt|lhs}} is less than {{tt|rhs}}. Equivalent to {{c|lhs.compare(rhs) &lt; 0}}.

@4@ Checks whether {{tt|lhs}} is less than or equal to {{tt|rhs}}. Equivalent to {{c|!(rhs &lt; lhs)}}.

@5@ Checks whether {{tt|lhs}} is greater than {{tt|rhs}}. Equivalent to {{c|rhs &lt; lhs}}.

@6@ Checks whether {{tt|lhs}} is greater than or equal to {{tt|rhs}}. Equivalent to {{c|!(lhs &lt; rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | the paths to compare}}
{{par end}}

===Return value===
{{c|true}} if the corresponding comparison yields, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Notes===
Path equality and equivalence have different semantics.

In the case of equality, as determined by {{tt|operator==}}, only lexical representations are compared. Therefore, {{c|1=path(&quot;a&quot;) == path(&quot;b&quot;)}} is never {{c|true}}.

In the case of equivalence, as determined by {{lc|std::fs::equivalent()}}, it is checked whether two paths ''resolve'' to the same file system object. Thus {{c|equivalent(&quot;a&quot;, &quot;b&quot;)}} will return {{c|true}} if the paths resolve to the same file.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc compare}}
{{dsc end}}</text>
      <sha1>3bl3mv8cogen1y08sy4s3dlbw1dx29l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/operator ltltgtgt</title>
    <ns>0</ns>
    <id>13430</id>
    <revision>
      <id>68615</id>
      <parentid>68614</parentid>
      <timestamp>2014-03-19T00:38:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="852">{{title|operator&lt;&lt;,&gt;&gt;(std::fs::path)}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp;
    operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; os, const path&amp; p );
}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp;
    operator&gt;&gt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; os, path&amp; p );
}}

{{dcl end}}

Performs stream input or output on the path {{tt|p}}. 

There is no special handling for spaces in the path: the user must himself ensure that spaces are not truncation when later read by stream input operator.

===Parameters===
{{par begin}}
{{par | os | stream to perform input/output on}}
{{par | p | path to insert or extract}}
{{par end}}

===Return value===
{{c|os}}

===Exceptions===
(none)</text>
      <sha1>mf6g337whpntmz5zojtdn2tj4trdtte</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/operator slash</title>
    <ns>0</ns>
    <id>13431</id>
    <revision>
      <id>68617</id>
      <parentid>68616</parentid>
      <timestamp>2014-03-19T00:38:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="533">{{title|operator/{{small|(std::fs::path)}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl header | fs}}
{{dcl | since=fs_ts | 1=
path operator/( const path&amp; lhs, const path&amp; rhs );
}}
{{dcl end}}

Concatenates two path. Effectively returns {{c|1=path(lhs) /= rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | paths to concatenate}}
{{par end}}

===Return value===
The result of path concatenation.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc append}}
{{dsc end}}</text>
      <sha1>3qdctygsbeb588gfdyupc3kx1hekx6i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/parent path</title>
    <ns>0</ns>
    <id>13432</id>
    <revision>
      <id>68619</id>
      <parentid>68618</parentid>
      <timestamp>2014-03-19T00:38:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="610">{{cpp/experimental/fs/path/title|parent_path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path parent_path() const;
}}
{{dcl end}}

Returns the path to the parent directory. Returns empty path if {{c|empty()}} or there's only a single element in the path ({{c|1=begin() == --end()}}.

The resulting path is constructed by appending all elements in a range {{tt|[begin(), --end())}} to an empty path.

===Parameters===
(none)

===Return value===
The path to the parent directory.

===Exceptions===
(none)

===Example===
{{todo}}

===See also===
{{dsc begin}}
{{todo}}
{{dsc end}}</text>
      <sha1>d66glr2wqpkxrjqy1cc2kap9bkoc4sb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/path</title>
    <ns>0</ns>
    <id>13433</id>
    <revision>
      <id>68621</id>
      <parentid>68620</parentid>
      <timestamp>2014-03-19T00:38:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1944">{{cpp/experimental/fs/path/title|path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | num=1 |
path();
}}
{{dcl | since=fs_ts | num=2 |
path( const path&amp; p );
}}
{{dcl | since=fs_ts | num=3 |
path( path&amp;&amp; p );
}}
{{dcl | since=fs_ts | num=4 |
template&lt; class Source &gt;
path( const Source&amp; source );
}}
{{dcl | since=fs_ts | num=5 |
template&lt; class InputIt &gt;
path( InputIt first, InputIt last );
}}
{{dcl | since=fs_ts | num=6 |
template&lt; class Source &gt;
path( const Source&amp; source, const std::locale&amp; loc );
}}
{{dcl | since=fs_ts | num=7 |
template&lt; class InputIt &gt;
path( InputIt first, InputIt last, const std::locale&amp; loc );
}}
{{dcl end}}

Constructs a new {{tt|path}} object.

@1@ Constructs an empty path.

@2@ Copy constructor. Constructs a copy of {{tt|p}}.

@3@ Move constructor. Constructs a copy of {{tt|p}}, {{tt|p}} is left in valid but unspecified state.

@4-7@ Constructs the path from either a range of {{tt|source}} {{v|4,6}} {{todo}} or a range [{{tt|first}}, {{tt|last}}) {{v|5,7}}. The format and encoding are converted, if needed.

:@4-5@ {{todo}}

:@6-7@ Uses {{tt|loc}} to perform the encoding conversion. If {{tt|value_type}} is {{c|wchar_t}}, converts to native wide encoding using the {{c|std::codecvt&lt;wchar_t,char&gt;}} of {{tt|loc}}. Otherwise, the conversion firstly is performed using the {{c|std::codecvt&lt;wchar_t,char&gt;}} facet and is followed by second conversion to the current byte encoding.

===Parameters===
{{par begin}}
{{par | p | a path to copy}}
{{par | source | todo}}
{{par | first, last | a range of characters to initialize with}}
{{par | loc | locale that defines encoding conversion to use}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req | The value type of {{tt|InputIt}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}

===Exceptions===
@1-2@ (none)

@3@ {{noexcept}}

@4-7@ (none)</text>
      <sha1>rbe7xuyge09bmyhxks38crkxd39cpbk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/relative path</title>
    <ns>0</ns>
    <id>13434</id>
    <revision>
      <id>68623</id>
      <parentid>68622</parentid>
      <timestamp>2014-03-19T00:38:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="457">{{cpp/experimental/fs/path/title|relative_path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path relative_path() const;
}}
{{dcl end}}

Returns path relative to the ''root-path''. If {{c|*this}} is an empty path, returns an empty path.

{{todo|what is ''root-path''?}}

===Parameters===
(none)

===Return value===
Path relative to the ''root-path''.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{todo}}
{{dsc end}}</text>
      <sha1>n0aoib9k31kvkjntxygkk46b8s547uk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/remove filename</title>
    <ns>0</ns>
    <id>13435</id>
    <revision>
      <id>68625</id>
      <parentid>68624</parentid>
      <timestamp>2014-03-19T00:38:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="564">{{cpp/experimental/fs/path/title|remove_filename}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; remove_filename()
}}
{{dcl end}}

Removes a single filename component. 

{{todo}}

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
(none)

===Example===
{{example
| code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::fs::path(&quot;/foo&quot;).remove_filename() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/&quot;).remove_filename() &lt;&lt; '\n';
}
| output=
/

}}

===See also===
{{todo}}</text>
      <sha1>2qn4iqkd0vl3a5kzbylukybhd41bx7h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/replace extension</title>
    <ns>0</ns>
    <id>13436</id>
    <revision>
      <id>68627</id>
      <parentid>68626</parentid>
      <timestamp>2014-03-19T00:38:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="724">{{cpp/experimental/fs/path/title|replace_extension}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; replace_extension( const path&amp; replacement = path() );
}}
{{dcl end}}

Replaces the extension with {{tt|replacement}}.

Firstly, any existing {{lc|extension}} is removed.

Then, a dot character is appended if {{tt|replacement}} is not empty or does not begin with a dot character.

{{tt|replacement}} is appended to the path.

===Parameters===
{{par begin}}
{{par | replacement | the extension to replace with}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc replace_filename}}
{{dsc end}}</text>
      <sha1>noeqzwog9fwfb06835j9cd7ysdvogjx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/replace filename</title>
    <ns>0</ns>
    <id>13437</id>
    <revision>
      <id>68629</id>
      <parentid>68628</parentid>
      <timestamp>2014-03-19T00:38:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="788">{{cpp/experimental/fs/path/title|replace_filename}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
path&amp; replace_filename( const path&amp; replacement );
}}
{{dcl end}}

Replaces a single filename component with {{tt|replacement}}. Equivalent to the following:

{{cc| 1=
remove_filename();
operator/=(replacement);
}}

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
(none)

===Example===
{{example
| code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::fs::path(&quot;/foo&quot;).replace_filename(&quot;bar&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/&quot;).replace_filename(&quot;bar&quot;) &lt;&lt; '\n';
}
| output=
/bar
bar
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc replace_extension}}
{{dsc end}}</text>
      <sha1>j14twjhzrervth2t3mfc2tcuczl7oht</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/root directory</title>
    <ns>0</ns>
    <id>13438</id>
    <revision>
      <id>68631</id>
      <parentid>68630</parentid>
      <timestamp>2014-03-19T00:38:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="521">{{cpp/experimental/fs/path/title|root_directory}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path root_directory() const;
}}
{{dcl end}}

Returns the root directory of the path. If the path does not include root name, returns {{c|path()}}.

===Parameters===
(none)

===Return value===
The root directory of the path.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc root_name}}
{{dsc inc | cpp/experimental/fs/path/dsc root_path}}
{{dsc end}}</text>
      <sha1>hwanoohxl6g3yx7sp3i96yw2zbtdrcx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/root name</title>
    <ns>0</ns>
    <id>13439</id>
    <revision>
      <id>68633</id>
      <parentid>68632</parentid>
      <timestamp>2014-03-19T00:38:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="506">{{cpp/experimental/fs/path/title|root_name}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path root_name() const;
}}
{{dcl end}}

Returns the root name of the path. If the path does not include root name, returns {{c|path()}}.

===Parameters===
(none)

===Return value===
The root name of the path.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc root_directory}}
{{dsc inc | cpp/experimental/fs/path/dsc root_path}}
{{dsc end}}</text>
      <sha1>rsjc6bh1906hc1adq3hyno74qv0qmit</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/root path</title>
    <ns>0</ns>
    <id>13440</id>
    <revision>
      <id>68703</id>
      <parentid>68635</parentid>
      <timestamp>2014-03-19T17:10:51Z</timestamp>
      <contributor>
        <ip>159.178.227.1</ip>
      </contributor>
      <comment>teh typo</comment>
      <text xml:space="preserve" bytes="583">{{cpp/experimental/fs/path/title|root_name}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path root_path() const;
}}
{{dcl end}}

Returns the root path of the path. If the path does not include root path, returns {{c|path()}}.

Effectively, returns the following:
{{cc|
root_name() / root_directory()
}}

===Parameters===
(none)

===Return value===
The root path of the path.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc root_name}}
{{dsc inc | cpp/experimental/fs/path/dsc root_directory}}
{{dsc end}}</text>
      <sha1>cgdkbsvnys1mz47qhd744i6d09dqa6x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/stem</title>
    <ns>0</ns>
    <id>13441</id>
    <revision>
      <id>68637</id>
      <parentid>68636</parentid>
      <timestamp>2014-03-19T00:38:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1005">{{cpp/experimental/fs/path/title|stem}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
path stem() const;
}}
{{dcl end}}

Returns the filename identified by the path stripped of its extension.

If {{lc|filename()}} is not equal to {{tt|.}} or {{tt|..}}, then returns the substring between its beginning and the last {{tt|.}} character, if present. The {{tt|.}} character is not included into the return value. 

===Parameters===
(none)

===Return value===
The stem of the filename identified by the path.

===Exceptions===
(none)

===Example===
{{example 
| code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar.txt&quot;).stem() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/.bar&quot;).stem() &lt;&lt; '\n';
    std::cout &lt;&lt; std::fs::path(&quot;/foo/bar&quot;).extension() &lt;&lt; '\n';
}
| output=
bar

bar
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc filename}}
{{dsc inc | cpp/experimental/fs/path/dsc extension}}
{{dsc end}}</text>
      <sha1>0x07pea8amyjmexe30y62w6e51719ri</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/string</title>
    <ns>0</ns>
    <id>13442</id>
    <revision>
      <id>68639</id>
      <parentid>68638</parentid>
      <timestamp>2014-03-19T00:38:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1146">{{cpp/experimental/fs/path/title|string,wstring,u8string,...}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class CharT, class Traits = std::char_traits&lt;CharT&gt;
          class Alloc = std::allocator&lt;CharT&gt; &gt;
std::basic_string&lt;CharT,Traits,Alloc&gt;
    string( const Alloc&amp; a = Allocator() ) const;
}}
{{dcl rev begin | num=2 | since=fs_ts}}
{{dcl | 
std::string string() const;
}}
{{dcl |
std::wstring wstring() const;
}}
{{dcl |
std::u8string u8string() const;
}}
{{dcl |
std::u16string u16string() const;
}}
{{dcl |
std::u32string u32string() const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the internal pathname in native pathname format, converted to specific string type. Conversion, if any, is specified in [[todo]].

@1@ All memory allocations are performed by {{tt|a}}.

@2@ The encoding in the case of {{tt|u8string()}} is always UTF-8.

===Parameters===
(none)

===Return value===
The internal pathname in generic pathname format, converted to specified string type.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc generic string}}
{{dsc end}}</text>
      <sha1>cztw1df7n8w2vk3ucs0gazlhr0l3j2i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/swap</title>
    <ns>0</ns>
    <id>13443</id>
    <revision>
      <id>68641</id>
      <parentid>68640</parentid>
      <timestamp>2014-03-19T00:38:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="432">{{cpp/experimental/fs/path/title|swap}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
void swap( path&amp; other );
}}
{{dcl end}}

Swaps the contents of {{c|*this}} and {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another path to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

===See also===
{{todo}}</text>
      <sha1>n7czlc6kon2z8i2a06c2rbogdjnanir</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/swap2</title>
    <ns>0</ns>
    <id>13444</id>
    <revision>
      <id>68643</id>
      <parentid>68642</parentid>
      <timestamp>2014-03-19T00:38:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="506">{{cpp/title | swap{{small|(std::fs::path)}}}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts |
void swap( path&amp; lhs, path&amp; rhs );
}}
{{dcl end}}

Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | paths whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/path/dsc swap}}
{{dsc end}}</text>
      <sha1>om4cgv9kooplxlwxovrgc60d19szuat</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/u8path</title>
    <ns>0</ns>
    <id>13445</id>
    <revision>
      <id>68645</id>
      <parentid>68644</parentid>
      <timestamp>2014-03-19T00:38:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1592">{{cpp/experimental/fs/title|u8path}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
template&lt; class Source &gt;
path u8path( const Source&amp; source );
}}
{{dcl | num=2 | since=fs_ts | 1=
template&lt; class InputIt &gt;
path u8path( InputIt first, InputIt last );
}}
{{dcl end}}

Creates an UTF-8 path from the given UTF-8 encoded {{c|char}}-based sources.

If {{tt|value_type}} is {{c|char}} and the current native narrow encoding is UTF-8, returns {{c|path(source)}} or {{c|path(begin, end)}}.

Otherwise, if {{tt|value_type}} is {{c|wchar_t}} and the native wide encoding is UTF-16, or if {{tt|value_type}} is {{c|char16_t}} or {{c|char32_t}}, converts {{tt|source}} or the range {{tt|[first, last)}} to a temporary value of type {{tt|string_type}} and returns a {{tt|path}} constructed from that value.

Otherwise, converts {{tt|source}} or the range {{tt|[first, last)}} to a temporary value of type {{c|std::u32string}} and returns a {{tt|path}} constructed from that value.

{{todo|argument format conversion}}

It is unspecified how Unicode encoding conversions are performed.

===Parameters===
{{par begin}}
{{par | source | a character sequence to construct the path from. {{todo}} }}
{{par | first, last | a range to construct the path from. {{todo}} }}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req | The value type of {{tt|InputIt}} must be one of the encoded character types ({{c|char}}, {{c|wchar_t}}, {{c|char16_t}} and {{c|char32_t}})}}
{{par end}}

===Return value===
A newly constructed UTF-8 encoded path.

===Exceptions===
(none)</text>
      <sha1>phrog4m7uzj8npfexupkj2wzqrrrbop</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/path/~path</title>
    <ns>0</ns>
    <id>13446</id>
    <revision>
      <id>68647</id>
      <parentid>68646</parentid>
      <timestamp>2014-03-19T00:38:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="163">{{cpp/experimental/fs/path/title|~path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts |
~path();
}}
{{dcl end}}

Destroys the path object.</text>
      <sha1>euj43tlrvam3zxphahd3hl8njia7mmb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/perms</title>
    <ns>0</ns>
    <id>13447</id>
    <revision>
      <id>69840</id>
      <parentid>69833</parentid>
      <timestamp>2014-04-28T16:02:52Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>fix template error</comment>
      <text xml:space="preserve" bytes="1413">{{cpp/experimental/fs/title|perms}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
enum class perms {
    none = 0,
    owner_read = 0400,
    owner_write = 0200,
    owner_exec = 0100,
    owner_all = 0700,
    group_read = 040,
    group_write = 020,
    group_exec = 010,
    group_all = 070,
    others_read = 04,
    others_write = 02,
    others_exec = 01,
    others_all = 07,
    all = 0777,
    set_uid = 04000,
    set_gid = 02000,
    sticky_bit = 01000,
    mask = 07777,
    unknown = 0xffff,
    add_perms = 0x10000,
    remove_perms = 0x20000,
    resolve_symlinks = 0x40000
};
}}
{{dcl end}}

{{todo}}

===Constants===
{{dsc begin}}
{{dsc hitem | Constant | Meaning}}
{{dsc | {{tt|owner_read}} | }}
{{dsc | {{tt|owner_write}} | }}
{{dsc | {{tt|owner_exec}} | }}
{{dsc | {{tt|owner_all}} | }}
{{dsc | {{tt|group_read}} | }}
{{dsc | {{tt|group_write}} | }}
{{dsc | {{tt|group_exec}} | }}
{{dsc | {{tt|group_all}} | }}
{{dsc | {{tt|others_read}} | }}
{{dsc | {{tt|others_write}} | }}
{{dsc | {{tt|others_exec}} | }}
{{dsc | {{tt|others_all}} | }}
{{dsc | {{tt|all}} | }}
{{dsc | {{tt|set_uid}} | }}
{{dsc | {{tt|set_gid}} | }}
{{dsc | {{tt|sticky_bit}} | meaning operating-system dependent}}
{{dsc | {{tt|mask}} | {{c|all {{!}} set_uid {{!}} set_gid {{!}} sticky_bit}} }}
{{dsc | {{tt|unknown}} | }}
{{dsc end}}

===See also===
{{todo}}</text>
      <sha1>ca6qpu7b3csyriipaui9bh7q5epwceg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator</title>
    <ns>0</ns>
    <id>13448</id>
    <revision>
      <id>68680</id>
      <parentid>68651</parentid>
      <timestamp>2014-03-19T00:42:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix links</comment>
      <text xml:space="preserve" bytes="2244">{{cpp/experimental/fs/title|recursive_directory_iterator}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
class recursive_directory_iterator : 
    public std::iterator&lt;input_iterator_tag, directory_entry&gt;;
}}
{{dcl end}}

{{c|recursive_directory_iterator}} is an input iterator that can recursively advance through entries of a directory and its children directories. Directory iteration never returns directory entries to the current (dot) and parent (dot-dot) directories. The order of directory entries is unspecified.

The past-the-end iterator (simply called the end iterator) is a special iterator. An end iterator is always equal to an end iterator and never equal to a non-end iterator. An end iterator is created by the default constructor of directory iterator and when a directory iterator is advanced past the last directory element. Calling {{c|operator*}} or {{c|operator-&gt;}} on an end iterator yields undefined behavior.

{{todo|clarify}}

If a file in a directory is deleted after the directory iterator has been created, the directory iterator may return a directory entry to the deleted file. If, on the other hand, a new file is created after the directory iterator has been created, iteration of the directory is not guaranteed to return a directory entry to the new file.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc constructor}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc destructor}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc operator*}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc options}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc depth}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc recursion_pending}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc increment}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc pop}}
{{dsc inc | cpp/experimental/fs/recursive_directory_iterator/dsc disable_recursion_pending}}
{{dsc end}}</text>
      <sha1>tm86pbchswcmsust0oqryyv4rgv4iqx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/depth</title>
    <ns>0</ns>
    <id>13449</id>
    <revision>
      <id>68653</id>
      <parentid>68652</parentid>
      <timestamp>2014-03-19T00:38:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="512">{{cpp/experimental/fs/recursive_directory_iterator/title | depth}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
int depth() const;
}}
{{dcl end}}

Returns the number of directories from the starting directory to the currently iterated directory, i.e. the current depth of the directory hierarchy. 

The starting directory has depth of {{math|0}}.

===Parameters===
(none)

===Return value===
Current depth of the directory hierarchy.

===Exceptions===
(none)</text>
      <sha1>6due5m5573n5x7nq2ts77yd71x943go</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/disable recursion pending</title>
    <ns>0</ns>
    <id>13450</id>
    <revision>
      <id>68655</id>
      <parentid>68654</parentid>
      <timestamp>2014-03-19T00:38:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="454">{{cpp/experimental/fs/recursive_directory_iterator/title | disable_recursion_pending}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
void disable_recursion_pending();
}}
{{dcl end}}

Disables recursion to the currently referred directory, if any. {{c|1=recursion_pending() == false}} after the call.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
(none)
{{todo|underspecified?}}</text>
      <sha1>gyd96hh40lilg2p9mftl9rr4hofuvsb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/increment</title>
    <ns>0</ns>
    <id>13451</id>
    <revision>
      <id>68657</id>
      <parentid>68656</parentid>
      <timestamp>2014-03-19T00:38:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1505">{{cpp/experimental/fs/recursive_directory_iterator/title | operator++, increment}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
recursive_directory_iterator&amp; operator++();
}}
{{dcl | since=fs_ts | 1=
recursive_directory_iterator&amp; increment( error_code&amp; ec );
}}
{{dcl end}}

Advances the iterator to the next entry.

If there are no more entries left in the currently iterated directory, the iteration is resumed over the parent directory. The process is repeated if the parent directory has no sibling entries that can to be iterated on. If the parent of the directory hierarchy that has been recursively iterated on is reached (there are no candidate entries at {{c|1=depth() == 0)}}, {{c|*this}} is set to an end iterator.

Otherwise, if {{c|*this}} refers to a directory, it is iterated into if the following conditions are met:

* {{lc|disable_recursion_pending()}} has not been called before this increment, i.e. {{c|1=recursion_pending() == true}}.
* The directory is not a symlink or following symlinks is enabled, i.e. 
:{{cc|1=!is_symlink(this-&gt;symlink_status()) {{!!}} 
(options() &amp; directory_options::follow_directory_symlink) != 0)}}.

===Parameters===
{{par begin}}
{{par | ec | error code to store the error status to}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs. The error code is set to an appropriate error code for the error that caused the failure.

@2@ {{noexcept}}</text>
      <sha1>cpce0blde0zze0olotg6vkahvx9p7vv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/operator*</title>
    <ns>0</ns>
    <id>13452</id>
    <revision>
      <id>68659</id>
      <parentid>68658</parentid>
      <timestamp>2014-03-19T00:38:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="442">{{cpp/experimental/fs/recursive_directory_iterator/title | operator*,operator-&gt;}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
const recursive_directory_entry&amp; operator*() const;
        
const recursive_directory_entry* operator-&gt;() const;
}}
{{dcl end}}

Accesses the pointed-to directory entry.

{{todo}}

===Parameters===
(none)

===Return value===
{{todo}}

===Exceptions===
{{todo}}</text>
      <sha1>r9qo73673t8pu1d0w4i6lkf9bjgr19c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/operator=</title>
    <ns>0</ns>
    <id>13453</id>
    <revision>
      <id>68661</id>
      <parentid>68660</parentid>
      <timestamp>2014-03-19T00:38:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="594">{{cpp/experimental/fs/recursive_directory_iterator/title | operator{{=}}}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
recursive_directory_iterator&amp; operator=( const recursive_directory_iterator&amp; ) = default;
}}
{{dcl | since=fs_ts | 1=
recursive_directory_iterator&amp; operator=( recursive_directory_iterator&amp;&amp; ) = default;
}}
{{dcl end}}

Assigns a recursive directory iterator.

===Parameters===
{{par begin}}
{{par | - | another directory iterator to assign }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
(none)
{{todo}}</text>
      <sha1>e0g8l6cw3fw1eso0sdo7m2l4mtx9kva</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/options</title>
    <ns>0</ns>
    <id>13454</id>
    <revision>
      <id>68663</id>
      <parentid>68662</parentid>
      <timestamp>2014-03-19T00:38:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="552">{{cpp/experimental/fs/recursive_directory_iterator/title | options}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
directory_options options() const;
}}
{{dcl end}}

Returns the options that affect the directory iteration. The options can only be supplied when constructing the directory iterator.

If the options argument was not supplied, returns {{c|options::none}}.

===Parameters===
(none)

===Return value===
The effective options that affect the directory iteration. 

===Exceptions===
(none)</text>
      <sha1>sks2v7ydzkmlcyv7piwu2gtdvaxnppt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/pop</title>
    <ns>0</ns>
    <id>13455</id>
    <revision>
      <id>68665</id>
      <parentid>68664</parentid>
      <timestamp>2014-03-19T00:38:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="482">{{cpp/experimental/fs/recursive_directory_iterator/title | pop}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
void pop();
}}
{{dcl end}}

Moves the iterator one level up in the directory hierarchy.

If the parent directory is outside directory hierarchy that is iterated on (i.e. {{c|1=depth() == 0}}), sets {{c|*this}} to an end directory iterator.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{todo}}</text>
      <sha1>5cbb60fjszn7ps2pmtfbwym5va5cz0r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/recursion pending</title>
    <ns>0</ns>
    <id>13456</id>
    <revision>
      <id>68667</id>
      <parentid>68666</parentid>
      <timestamp>2014-03-19T00:38:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="675">{{cpp/experimental/fs/recursive_directory_iterator/title | recursion_pending}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | since=fs_ts | 1=
bool recursion_pending() const;
}}
{{dcl end}}

Returns {{c|true}} if the next increment will cause the directory currently referred to by {{c|*this}} to be iterated into.

This function returns {{c|true}} immediately after construction or an increment. Recursion can be disabled via {{lc|disable_recursion_pending()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the next increment will iterate into the currently referred directory, {{c|false}} otherwise.

===Exceptions===
(none)</text>
      <sha1>rae8wyomt6eh1uw1iguciyjs7owr6vv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/recursive directory iterator/recursive directory iterator</title>
    <ns>0</ns>
    <id>13457</id>
    <revision>
      <id>68669</id>
      <parentid>68668</parentid>
      <timestamp>2014-03-19T00:38:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1457">{{cpp/experimental/fs/recursive_directory_iterator/title | recursive_directory_iterator}}
{{cpp/experimental/fs/recursive_directory_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=fs_ts | 1=
recursive_directory_iterator();
}}
{{dcl | num=2 | since=fs_ts | 1=
recursive_directory_iterator( const recursive_directory_iterator&amp; ) = default;
}}
{{dcl | num=3 | since=fs_ts | 1=
recursive_directory_iterator( recursive_directory_iterator&amp;&amp; ) = default;
}}
{{dcl | num=4 | since=fs_ts | 1=
explicit recursive_directory_iterator( const path&amp; p,
                                       directory_options options = directory_options::none );
}}
{{dcl | num=5 | since=fs_ts | 1=
recursive_directory_iterator( const path&amp; p,
                              directory_options options, error_code&amp; ec );
}}
{{dcl | num=6 | since=fs_ts | 1=
recursive_directory_iterator( const path&amp; p, error_code&amp; ec );
}}
{{dcl end}}

Contructs new recursive directory iterator.

@1@ Default constructor. Constructs an end iterator.

@2-3@ Default copy and move constructors.

@4-6@ Constructs a iterator that refers to the first entry in the directory that {{tt|p}} resolves to. 

{{todo|errors}}

===Parameters===
{{todo}}

===Exceptions===
@1,5,6@ {{noexcept}}

{{todo}}

===Notes===

Recursive directory iterators do not follow directory symlinks by default. To enable this behavior, specify {{tt|directory_options::follow_directory_symlink}} among the {{tt|options}} option set.</text>
      <sha1>hdc25hawktqdwt2mrokm7r58k1x8mp6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/space info</title>
    <ns>0</ns>
    <id>13458</id>
    <revision>
      <id>68671</id>
      <parentid>68670</parentid>
      <timestamp>2014-03-19T00:38:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="359">{{cpp/experimental/fs/title|space_info}}
{{cpp/experimental/fs/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | since=fs_ts | 1=
struct space_info {
    uintmax_t capacity;
    uintmax_t free; 
    uintmax_t available; 
};
}}
{{dcl end}}

{{todo}}

available --  free space available to a non-privileged process

===See also===
{{todo}}</text>
      <sha1>p0sk49am9l6cf6fdcfu42n1665u5noy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/fs/temp directory path</title>
    <ns>0</ns>
    <id>13459</id>
    <revision>
      <id>68673</id>
      <parentid>68672</parentid>
      <timestamp>2014-03-19T00:38:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="1076">{{cpp/experimental/fs/title|temp_directory_path}}
{{cpp/experimental/fs/path/navbar}}
{{dcl begin}}
{{dcl header | experimental/filesystem}}
{{dcl | num=1 | since=fs_ts | 1=
path temp_directory_path();
}}
{{dcl | num=2 | since=fs_ts | 1=
path temp_directory_path( error_code&amp; ec );
}}
{{dcl end}}

Returns an unspecified directory suitable for temporary files.

An error is reported if the path to be returned does not exist or is not directory.

The second version returns {{c|path()}} and sets {{tt|ec}} to an appropriate error code if error occurs. Otherwise, {{tt|ec}} is cleared via {{c|ec.clear()}}.

===Parameters===
(none)

===Return value===
A directory suitable for temporary files.

===Exceptions===
@1@ {{c|filesystem_error}} if an error occurs.

@2@ {{noexcept}}

===Example===
{{example
|code=
#include &lt;filesystem&gt;
#include &lt;iostream&gt;

int main()
{
    namespace fs = std::experimental::filesystem;
    std::cout &lt;&lt; fs::temp_directory_path() &lt;&lt; '\n';
}
|output=
/tmp
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/fs/dsc unique_path}}
{{dsc end}}</text>
      <sha1>k7lx5ixkhaslqifio2eq1vzigylrrc5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/lib extensions</title>
    <ns>0</ns>
    <id>13683</id>
    <revision>
      <id>71626</id>
      <parentid>71616</parentid>
      <timestamp>2014-06-17T04:25:07Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix headers.</comment>
      <text xml:space="preserve" bytes="2686">{{title|C++ standard libraries extensions}}
{{cpp/experimental/lib_extensions/navbar}}

The C++ Extensions for Library Fundamentals technical specification includes the following significant features:

{|table class=wikitable
|-
!Doc. No.||Title||Macro Name Suffix||Header
|-
| N3920
| Extending {{lc|std::shared_ptr}} to support arrays
| {{tt|shared_ptr_arrays}}
| {{ltt|cpp/header/experimental/memory|&lt;experimental/memory&gt;}}
|-
| N3916
| Type-erased allocator for {{lc|std::function}}
| {{tt|function_erased_allocator}}
| {{ltt|cpp/header/experimental/functional|&lt;experimental/functional&gt;}}
|-
| N3843
| A SFINAE-Friendly {{lc|std::common_type}}
| {{tt|common_type_sfinae}}
| {{ltt|cpp/header/experimental/type_traits|&lt;experimental/type_traits&gt;}}
|-
| N3923
| A SFINAE-Friendly {{lc|std::iterator_traits}}
| {{tt|iterator_traits_sfinae}}
| {{ltt|cpp/header/experimental/iterator|&lt;experimental/iterator&gt;}}
|-
| N3916
| Type-erased allocator for {{lc|std::promise}}
| {{tt|promise_erased_allocator}}
| {{ltt|cpp/header/experimental/future|&lt;experimental/future&gt;}}
|-
| N3916
| Type-erased allocator for {{lc|std::packaged_task}}
| {{tt|packaged_task_erased_allocator}}
| {{ltt|cpp/header/experimental/future|&lt;experimental/future&gt;}}
|-
| N3915
| {{tt|apply()}} call a function with arguments from a tuple
| {{tt|apply}}
| {{ltt|cpp/header/experimental/tuple|&lt;experimental/tuple&gt;}}
|-
| N3932
| Variable Templates For Type Traits
| {{tt|type_trait_variable_templates}}
| {{ltt|cpp/header/experimental/type_traits|&lt;experimental/type_traits&gt;}}
|-
| N3866
| Invocation type traits
| {{tt|invocation_type}}
| {{ltt|cpp/header/experimental/type_traits|&lt;experimental/type_traits&gt;}}
|-
| N3905
| Extending {{lc|std::search}} to use Additional Searching Algorithms
| {{tt|boyer_moore_searching}}
| {{ltt|cpp/header/experimental/functional|&lt;experimental/functional&gt;}}
|-
| N3672, N3793
| A utility class to represent optional objects
| {{tt|optional}}
| {{ltt|cpp/header/experimental/optional|&lt;experimental/optional&gt;}}
|-
| N3804
| Any Library Proposal
| {{tt|any}}
| {{ltt|cpp/header/experimental/any|&lt;experimental/any&gt;}}
|-
| N3921
| {{tt|string_view}}: a non-owning reference to a string
| {{tt|string_view}}
| {{ltt|cpp/header/experimental/string_view|&lt;experimental/string_view&gt;}}
|-
| N3916
| Polymorphic Memory Resources
| {{tt|memory_resources}}
| {{ltt|cpp/header/experimental/memory_resource|&lt;experimental/memory_resource&gt;}}
|-
| N3925
| A {{tt|sample}} Proposal
| {{tt|sample}}
| {{ltt|cpp/header/experimental/algorithm|&lt;experimental/algorithm&gt;}}
|-
| N3783
| Network Byte Order Conversion
| {{tt|network_byte_order}}
| {{ltt|cpp/header/experimental/net|&lt;experimental/net&gt;}}
|}


{{todo}}</text>
      <sha1>st9naghl30bs1z2xagdenx0fm91lc24</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/memory</title>
    <ns>0</ns>
    <id>13678</id>
    <revision>
      <id>71552</id>
      <parentid>71551</parentid>
      <timestamp>2014-06-13T07:01:11Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Formatting improvements.</comment>
      <text xml:space="preserve" bytes="1509">{{title|Polymorphic allocator library}}
{{cpp/experimental/memory/navbar}}

The C++ Extensions for Library Fundamentals includes classes for providing allocator type erasure and runtime polymorphism.

=== {{lc|std::experimental::pmr::memory_resource}} ===

The {{lc|memory_resource}} class is an abstract interface for classes that encapsulate memory resources.

The library provides the following concrete classes:


{{dsc begin}}
{{dsc header | experimental/memory_resource}}
{{dsc hitem | Class | Description}}
{{dsc | {{lc|std::experimental::pmr::synchronized_pool_resource}}&lt;br/&gt;
{{lc|std::experimental::pmr::unsynchronized_pool_resource}} | Pool resources are a type of {{lc|memory_resource}} for managing allocations in pools of different block sizes. The library provides both a thread-safe and unsafe pool resource.
}}
{{dsc | {{lc|std::experimental::pmr::monotonic_buffer_resource}} | A special-purpose {{lc|memory_resource}} intended for very fast memory allocations in situations where memory is used to build up a few objects and then is released all at once when the buffer is destroyed.
}}
{{dsc end}}

=== {{lc|std::experimental::pmr::polymorphic_allocator}} ===

Using a specialization of the class template {{tt|pmr::polymorphic_allocator}} with an allocator-aware class allows allocators to be used polymorphically at run time.

=== {{lc|std::experimental::pmr::resource_adaptor}} ===

The template alias {{tt|resource_adaptor}} wraps a {{lc|memory_resource}} interface around an allocator.</text>
      <sha1>ltqk7cvxibocqi3pfej8zye09pf5ukj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional</title>
    <ns>0</ns>
    <id>10061</id>
    <revision>
      <id>69014</id>
      <parentid>68220</parentid>
      <timestamp>2014-03-23T21:40:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="3262">{{cpp/title|n=experimental::|optional}}
{{cpp/experimental/optional/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=After reviewing national body comments to N3690, this library component was voted out from C++14 working paper into a separate Technical Specification. It is not a part of the draft C++14 as of n3797.}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=This is work in progress, there may be inaccuracies}}
{{ddcl | header=experimental/optional | since=libfund_ts |
template&lt; class T &gt;
class optional;
}}

The class template {{tt|std::experimental::optional}} manages an ''optional'' contained value, i.e. a value that semantically may not be present.

A common use case for {{tt|optional}} is the return value of a function that may fail. As opposed to other approaches, such as {{c|std::pair&lt;T,bool&gt;}}, {{tt|optional}} handles expensive to construct objects well and is more readable, as the intent is expressed explicitly.

The value is guaranteed to be allocated within the {{tt|optional}} object itself, i.e. no dynamic memory allocation ever takes place. Thus, an {{tt|optional}} object models an object, not a pointer, even though the {{lc|operator*()}} and {{lc|operator-&gt;()}} are defined.

The value inside an {{tt|optional}} object may be in either an initialized or uninitialized state.  An {{tt|optional}} object with a value in initialized state is called ''engaged'', whereas if the value is in uninitialized state, the object is called ''disengaged''.

The {{tt|optional}} object is ''engaged'' on the following conditions:

* The object is initialized with a value of type {{tt|T}}

* The object is assigned an ''engaged'' {{tt|optional}}.

The object is ''disengaged'' on the following conditions:

* The object is default-initialized.

* The object is initialized with a value of {{lc|std::experimental::nullopt_t}} or a ''disengaged'' {{tt|optional}} object.

* The object is assigned a value of {{lc|std::experimental::nullopt_t}} or a ''disengaged'' {{tt|optional}}.

===Template parameters===
{{par begin}}
{{par | T | the type of the value to manage initialization state for. The type must meet the requirements of {{concept|Destructible}} }}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc constructor}}
{{dsc inc | cpp/experimental/optional/dsc destructor}}
{{dsc inc | cpp/experimental/optional/dsc operator{{=}}}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/experimental/optional/dsc operator*}}
{{dsc inc | cpp/experimental/optional/dsc operator bool}}
{{dsc inc | cpp/experimental/optional/dsc value}}
{{dsc inc | cpp/experimental/optional/dsc value_or}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/experimental/optional/dsc swap}}
{{dsc inc | cpp/experimental/optional/dsc emplace}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc operator_cmp}}
{{dsc inc | cpp/experimental/optional/dsc make_optional}}
{{dsc inc | cpp/experimental/optional/dsc swap2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc hash}}
{{dsc end}}</text>
      <sha1>gzqyh2zb4sfmoyh4qtzbdok76ootpcn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/emplace</title>
    <ns>0</ns>
    <id>10087</id>
    <revision>
      <id>68702</id>
      <parentid>68169</parentid>
      <timestamp>2014-03-19T17:03:07Z</timestamp>
      <contributor>
        <ip>163.5.141.52</ip>
      </contributor>
      <comment>Fixed typo (Inilializes =&gt; Initializes)</comment>
      <text xml:space="preserve" bytes="1366">{{cpp/experimental/optional/title|emplace}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | 1=
template&lt; class... Args &gt; 
void emplace( Args&amp;&amp;... args );
}}
{{dcl | since=libfund_ts | 1=
template&lt; class U, class... Args &gt; 
void emplace( std::initializer_list&lt;U&gt; ilist, Args&amp;&amp;... args );
}}
{{dcl end}}

Constructs the contained value in-place. If {{c|*this}} is in ''engaged'' state before the call, the contained value is destroyed by calling its destructor.

@1@ Initializes the contained value by calling its constructor with {{tt|args...}} as parameters.

@2@ Initializes the contained value by calling its constructor with {{tt|ilist}} and {{tt|args...}} as parameters.

===Parameters===
{{par begin}}
{{par | args... | the arguments to pass to the constructor}}
{{par | ilist | the initializer list to pass to the constructor}}
{{par hreq}}
{{par req | {{tt|T}} must be constructible from {{tt|Args...}} | overload=1}}
{{par req | {{tt|T}} must be constructible from {{lc|std::initializer_list}} and {{tt|Args...}} | overload=2}}
{{par end}}

===Return value===
(none)

===Exceptions===
Any exception thrown by the selected constructor of {{tt|T}}. If an exception is thrown, {{c|*this}} is in ''disengaged'' state after the call.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc operator{{=}}}}
{{dsc end}}</text>
      <sha1>gey9yxai2dye9887vc6u9djlfml525c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/hash</title>
    <ns>0</ns>
    <id>10098</id>
    <revision>
      <id>69018</id>
      <parentid>68174</parentid>
      <timestamp>2014-03-23T21:41:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="1059">{{cpp/title|hash &lt;small&gt;&lt;std::experimental::optional&gt;&lt;/small&gt;}}
{{cpp/experimental/optional/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=After reviewing national body comments to n3690, this library component was voted out from C++14 working paper into a separate Technical Specification. It is not a part of the draft C++14 as of n3797.}}
{{dcl begin}}
{{dcl header | experimental/optional}}
{{dcl | since=libfund_ts | 1=
template&lt;class T&gt;
struct hash&lt;std::experimental::optional&lt;T&gt;&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for the {{lc|std::experimental::optional}} class allows users to obtain hashes of the values contained in {{tt|optional}} objects.

===Template parameters===
{{par begin}}
{{par | T | the type of the value contained in {{tt|optional}} object. The specialization {{c|std::hash&lt;T&gt;}} must meet the requirements of class template {{tt|hash}}.}}
{{par end}}

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}</text>
      <sha1>7ul3vjsqnxz6mq8cwrfqsk74dgqdh72</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/make optional</title>
    <ns>0</ns>
    <id>10090</id>
    <revision>
      <id>69016</id>
      <parentid>68172</parentid>
      <timestamp>2014-03-23T21:40:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="727">{{cpp/title|make_optional}}
{{cpp/experimental/optional/navbar}}
{{ddcl | header=experimental/optional | since=libfund_ts | 1=
template&lt; class T &gt; 
constexpr optional&lt;typename std::decay&lt;T&gt;::type&gt; 
    make_optional( T&amp;&amp; value );
}}

Creates an optional object from {{tt|value}}. Effectively calls 
{{cc|optional&lt;typename std::decay&lt;T&gt;::type&gt;(std::forward&lt;T&gt;(v))}}

===Parameters===
{{par begin}}
{{par | value | the value to construct optional object with}}
{{par end}}

===Return value===
An optional object with {{tt|value}} as the contained value.

===Exceptions===
Throws any exception thrown by the constructor of {{tt|T}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc constructor}}
{{dsc end}}</text>
      <sha1>c84qbl4v4l3iykeub97vtuu3f861wey</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/operator*</title>
    <ns>0</ns>
    <id>10083</id>
    <revision>
      <id>68165</id>
      <parentid>68044</parentid>
      <timestamp>2014-03-17T01:39:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="705">{{cpp/experimental/optional/title|operator-&gt;|operator*}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | num=1 | 1=
constexpr const T* operator-&gt;() const;
}}
{{dcl | since=libfund_ts | num=1 | 1=
T* operator-&gt;();
}}
{{dcl | since=libfund_ts | num=2 | 1=
constexpr const T&amp; operator*() const;
}}
{{dcl | since=libfund_ts | num=2 | 1=
T&amp; operator*();
}}
{{dcl end}}

Accesses the contained value.

@1@ Returns a pointer to the contained value.

@2@ Returns a reference to the contained value.

The behavior is undefined if {{c|*this}} is in ''disengaged'' state.

===Parameters===
(none)

===Return value===
Pointer or reference to the contained value.

===Exceptions===
(none)</text>
      <sha1>9syb65j30rs2af2jfdzmby0pyw4ewq2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/operator=</title>
    <ns>0</ns>
    <id>10082</id>
    <revision>
      <id>68164</id>
      <parentid>68046</parentid>
      <timestamp>2014-03-17T01:39:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="2906">{{cpp/experimental/optional/title|operator{{=}}}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | num=1 | 1=
optional&amp; operator=( std::nullopt_t );
}}
{{dcl | since=libfund_ts | num=2 | 1=
optional&amp; operator=( const optional&amp; other );
}}
{{dcl | since=libfund_ts | num=3 | 1=
optional&amp; operator=( optional&amp;&amp; other );
}}
{{dcl | since=libfund_ts | num=4 | 1=
template&lt; class U &gt; 
optional&amp; operator=( U&amp;&amp; value );
}}
{{dcl end}}

Assigns contents to the contained value. 

@1@ If {{c|*this}} is in ''engaged'' state before the call, the contained value is destroyed by calling its destructor. {{c|*this}} is in ''disengaged'' state after the call.

@2-3@ Assigns the state of {{tt|other}}. 

@@* If both {{c|*this}} and {{tt|other}} are in ''disengaged'' states, the function has no effect.

@@* If {{c|*this}} is in ''engaged'' state, but {{tt|other}} is not, then the contained value is destroyed by calling its destructor. {{c|*this}} is in ''disengaged'' state after the call.

@@* If {{tt|other}} is in ''engaged'' state, then depending on whether {{c|*this}} is in ''engaged'' state, the contained value is either direct-constructed or assigned the contained value of {{tt|other}}. The contained value is either copied (2), or moved (3).

@4@ Depending on whether {{c|*this}} is in ''engaged'' state before the call, the contained value is either direct-constructed from {{tt|value}} or assigned {{tt|value}}. {{tt|T}} must be constructible and assignable from {{tt|U}}, i.e. the following must hold:
{{cc|1=std::is_constructible&lt;T,U&gt;::value == true &amp;&amp; std::is_assignable&lt;T,U&gt;::value == true}}

===Parameters===
{{par begin}}
{{par | other | another {{tt|optional}} object whose contained value to assign}}
{{par | value | value to assign to the contained value}}
{{par hreq}}
{{par req concept | T | CopyConstructible | CopyAssignable | overload=2 }}
{{par req concept | T | MoveConstructible | MoveAssignable | overload=3 }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{noexcept}}

@2-4@ Throws any exception thrown by the constructor or assignment operator of {{tt|T}}. If an exception is thrown, the initialization state of {{c|*this}} (and of {{tt|other}} in case of (2) ) is unchanged, i.e. if the object was in ''engaged'' state, it is left in ''engaged'' state, and the other way round. The contents of {{tt|value}} and the contained values of {{c|*this}} and {{tt|other}} depend on the exception safety guarantees of the operation from which the exception originates (copy-constructor, move-assignment, etc.).

:@3@ Throws any exception thrown by the constructor or assignment operator {{tt|T}}. Has the following {{tt|noexcept}} declaration: {{noexcept|std::is_nothrow_move_assignable&lt;T&gt;::value &amp;&amp; std::is_nothrow_move_constructible&lt;T&gt;::value}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc emplace}}
{{dsc end}}</text>
      <sha1>ouw1llo1i1f52lv09lt32h4h18k45jt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/operator bool</title>
    <ns>0</ns>
    <id>10086</id>
    <revision>
      <id>68168</id>
      <parentid>68048</parentid>
      <timestamp>2014-03-17T01:39:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="439">{{cpp/experimental/optional/title|operator bool}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | 1=
constexpr explicit operator bool() const;
}}
{{dcl end}}

Checks whether {{c|*this}} is in ''engaged'' state, i.e. whether the contained value is initialized.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} is in ''engaged'' state, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}</text>
      <sha1>nactopipmupvdrnbpbh9g36m38h1v94</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/operator cmp</title>
    <ns>0</ns>
    <id>10093</id>
    <revision>
      <id>69015</id>
      <parentid>68173</parentid>
      <timestamp>2014-03-23T21:40:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="3243">{{title|operator{{=}}{{small|(std::experimental::optional)}}}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl header | experimental/optional}}
{{dcl h | Compare two {{tt|optional}} objects}}
{{dcl | since=libfund_ts | num=1 | 1=
template&lt; class T &gt; 
constexpr bool operator==( const optional&lt;T&gt;&amp; lhs, const optional&lt;T&gt;&amp; rhs );
}}
{{dcl | since=libfund_ts | num=2 | 1=
template&lt; class T &gt; 
constexpr bool operator&lt;( const optional&lt;T&gt;&amp; lhs, const optional&lt;T&gt;&amp; rhs );
}}
{{dcl h | Compare an {{tt|optional}} object with a {{tt|nullopt}} }}
{{dcl | since=libfund_ts | num=3 | 1=
template&lt; class T &gt; 
constexpr bool operator==( const optional&lt;T&gt;&amp; opt, std::nullopt_t );
}}
{{dcl | since=libfund_ts | num=4 | 1=
template&lt; class T &gt; 
constexpr bool operator==( std::nullopt_t, const optional&lt;T&gt;&amp; opt );
}}
{{dcl | since=libfund_ts | num=5 | 1=
template&lt; class T &gt; 
constexpr bool operator&lt;( const optional&lt;T&gt;&amp; opt, std::nullopt_t );
}}
{{dcl | since=libfund_ts | num=6 | 1=
template&lt; class T &gt; 
constexpr bool operator&lt;( std::nullopt_t, const optional&lt;T&gt;&amp; opt);
}}
{{dcl h | Compare an {{tt|optional}} object with a {{tt|T}} }}
{{dcl | since=libfund_ts | num=7 | 1=
template&lt; class T &gt; 
constexpr bool operator==( const optional&lt;T&gt;&amp; opt, const T&amp; v );
}}
{{dcl | since=libfund_ts | num=8 | 1=
template&lt; class T &gt; 
constexpr bool operator==( const T&amp; value, const optional&lt;T&gt;&amp; opt );
}}
{{dcl | since=libfund_ts | num=9 | 1=
template&lt; class T &gt; 
constexpr bool operator&lt;( const optional&lt;T&gt;&amp; opt, const T&amp; v );
}}
{{dcl end}}

Performs comparison operations on {{tt|optional}} objects.

@1-2@ Compares two {{tt|optional}} objects, {{tt|lhs}} and {{tt|rhs}}. The contained values are compared only if both {{tt|lhs}} and {{tt|rhs}} are in ''engaged'' states. Otherwise, 

::*{{tt|lhs}} is considered ''equal to'' {{tt|rhs}} if, and only if, both {{tt|lhs}} and {{tt|rhs}} are in ''disengaged'' states.
::*{{tt|lhs}} is considered ''less than'' {{tt|rhs}} if, and only if, {{tt|rhs}} is in ''engaged'' state and {{tt|lhs}} is not.

@3-6@ Compares {{tt|opt}} with a {{tt|nullopt}}. Equivalent to (1-2) when comparing to an {{tt|optional}} with ''engaged'' state.

@7-9@ Compares {{tt|opt}} with a {{tt|value}}. The values are compared only if {{tt|opt}} is in ''engaged'' state. Otherwise, {{tt|opt}} is considered ''less than'' {{tt|value}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs, opt | an {{tt|optional}} object to compare}}
{{par | value | value to compare to the contained value}}
{{par hreq}}
{{par req concept | T | EqualityComparable | overloads=1, 7-8 }}
{{par end}}

===Return value===
@1@ If {{c|1=bool(lhs) != bool(rhs)}}, returns {{c|false}}
@@ Otherwise, if {{c|1=bool(lhs) == bool(rhs) == false}}, returns {{c|true}}
@@ Otherwise, returns {{c|1=*lhs == *rhs}}.

@2@ If {{c|1=bool(rhs) == false}} returns {{c|false}}
@@ Otherwise, if {{c|1=lhs == false}}, returns {{c|true}}
@@ Otherwise returns {{c|std::less&lt;T&gt;{}(*x, *y)}}

@3@ Returns {{c|!opt}}.

@4@ Returns {{c|false}}.

@5@ Returns {{c|!opt}}.

@6@ Returns {{c|bool(opt)}}

@7-8@ Returns {{c|1=bool(opt) ? *opt == value : false}}.

@9@ Returns {{c|1=bool(opt) ? std::less&lt;T&gt;{}(*opt, value) : true}}.

===Exceptions===
@1-2@ (none)

@3-6@ {{noexcept}}

@7-9@ (none)</text>
      <sha1>4gtrb5zs35dxm31cy3yodvbh2dunmsp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/optional</title>
    <ns>0</ns>
    <id>10078</id>
    <revision>
      <id>68162</id>
      <parentid>68052</parentid>
      <timestamp>2014-03-17T01:38:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="2828">{{cpp/experimental/optional/title|optional}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
constexpr optional();
}}
{{dcl | num=1 | since=libfund_ts |
constexpr optional( std::nullopt_t );
}}
{{dcl | num=2 | since=libfund_ts |
optional( const optional&amp; other);
}}
{{dcl | num=3 | since=libfund_ts |
optional( optional&amp;&amp; other );
}}
{{dcl | num=4 | since=libfund_ts |
constexpr optional( const T&amp; value );
}}
{{dcl | num=5 | since=libfund_ts |
constexpr optional( T&amp;&amp; value );
}}
{{dcl | num=6 | since=libfund_ts |
template&lt; class... Args &gt; 
constexpr explicit optional( std::in_place_t, Args&amp;&amp;... args );
}}
{{dcl | num=7 | since=libfund_ts |
template&lt; class U, class... Args &gt;
constexpr explicit optional( std::in_place_t, std::initializer_list&lt;U&gt; ilist, 
                             Args&amp;&amp;... args );
}}
{{dcl end}}

Constructs a new {{tt|optional}} object.

@1@ Constructs the object without initializing the contained value. The object is in ''disengaged'' state after the call.

@2-3@ Initializes the contained value by copying (2) or moving(3) the contained value of {{tt|other}}, but only if {{tt|other}} is ''engaged''. {{tt|other}} is still in ''engaged'' state if it was in ''engaged'' state before the call.

@4-7@ Initializes the contained value from various sources. {{c|*this}} is in ''engaged'' state after the call. 

:@4@ Initializes the contained value by copying {{tt|value}}.

:@5@ Initializes the contained value by moving {{tt|value}}.

:@6@ Initializes the contained value by constructing it in-place and passing {{tt|args...}} to the constructor.

:@7@ Initializes the contained value by constructing it in-place and passing the initializer list {{tt|ilist}} and arguments {{tt|args...}} to the constructor. The function does not participate in the overload resolution if 

:@@{{cc|1=std::is_constructible&lt;T, std::initializer_list&lt;U&gt;&amp;, Args&amp;&amp;...&gt;::value != true}}

===Parameters===
{{par begin}}
{{par | other | another {{tt|optional}} object whose contained value to copy}}
{{par | value | value to initialize the contained value with}}
{{par | args... | arguments to initialize the contained value with}}
{{par | ilist | initializer list to initialize the contained value with}}
{{par hreq}}
{{par req concept | T | CopyConstructible | overloads=2,4}}
{{par req concept | T | MoveConstructible | overloads=3,5}}
{{par end}}

===Exceptions===
@1@ {{noexcept}}

@2@ Throws any exception thrown by the constructor of {{tt|T}}.

@3@ Throws any exception thrown by the constructor of {{tt|T}}. Has the following {{tt|noexcept}} declaration: {{noexcept|std::is_nothrow_move_constructible&lt;T&gt;::value}}.

@4-5@ Throws any exception thrown by the constructor of {{tt|T}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc make_optional}}
{{dsc end}}</text>
      <sha1>tkwu5h1abjfj10lpv5lsu1tk53odcmb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/swap</title>
    <ns>0</ns>
    <id>10088</id>
    <revision>
      <id>68170</id>
      <parentid>68054</parentid>
      <timestamp>2014-03-17T01:39:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="1564">{{cpp/experimental/optional/title|swap}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | 1=
void swap( optional&amp; other );
}}
{{dcl end}}

Swaps the contents with those of {{tt|other}}.

* If none of {{c|*this}} and {{tt|other}} are in ''engaged'' states, the function has no effect.

* If only one of {{c|*this}} and {{tt|other}} is in ''engaged'' state (let's call this object {{tt|in}} and the other {{tt|un}}), the contained value of {{tt|un}} is initialized by moving the contained value of {{tt|in}}, followed by destruction of the contained value of {{tt|in}}. {{tt|in}} is in ''disengaged'' state and {{tt|un}} is in ''engaged'' state afterwards.

* If both {{c|*this}} and {{tt|other}} have ''engaged'' states, the contained values are exchanged by calling {{c|swap(**this, *other)}}.

===Parameters===
{{par begin}}
{{par | other | the {{tt|optional}} object to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept|is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; 
           noexcept(swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;()))}}

In the case of thrown exception, the states of the contained values of {{c|*this}} and {{tt|other}} are determined by the exception safety guarantees of {{tt|swap}} of type {{tt|T}} or {{tt|T}}'s move constructor, whichever is called. For both {{c|*this}} and {{tt|other}}, if the object was in ''engaged'' state, it is left in ''engaged'' state, and the other way round.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc swap2}}
{{dsc end}}</text>
      <sha1>hgbvt7sdlijel2tlpzlpz0w4dgckuvn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/swap2</title>
    <ns>0</ns>
    <id>10089</id>
    <revision>
      <id>69017</id>
      <parentid>68171</parentid>
      <timestamp>2014-03-23T21:40:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="761">{{cpp/title | swap{{small|(std::experimental::optional)}}}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl header | experimental/optional}}
{{dcl | since=libfund_ts |
template&lt; class T &gt;
void swap( optional&lt;T&gt;&amp; lhs, optional&lt;T&gt;&amp; rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::experimental::optional}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | {{tt|optional}} objects whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept|lhs.swap(rhs)}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc swap}}
{{dsc end}}</text>
      <sha1>madx9qxivbd15i29wbs3qilkmofs1al</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/value</title>
    <ns>0</ns>
    <id>10084</id>
    <revision>
      <id>68166</id>
      <parentid>68058</parentid>
      <timestamp>2014-03-17T01:39:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="515">{{cpp/experimental/optional/title|value}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | 1=
constexpr const T&amp; value() const;
}}
{{dcl | since=libfund_ts | 1=
T&amp; value();
}}
{{dcl end}}

Returns the contained value.

===Parameters===
(none)

===Return value===
A reference to the contained value.

===Exceptions===
{{lc|std::bad_optional_access}} if {{c|*this}} is in ''disengaged'' state.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc value_or}}
{{dsc end}}</text>
      <sha1>q2xu3dxvxdp9zh2u3468a1mh0ltefz8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/value or</title>
    <ns>0</ns>
    <id>10085</id>
    <revision>
      <id>68167</id>
      <parentid>68060</parentid>
      <timestamp>2014-03-17T01:39:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="1305">{{cpp/experimental/optional/title|value_or}}
{{cpp/experimental/optional/navbar}}
{{dcl begin}}
{{dcl | since=libfund_ts | 1=
template&lt; class U &gt; 
constexpr T value_or( U&amp;&amp; value ) const&amp;;
}}
{{dcl | since=libfund_ts | 1=
template&lt; class U &gt; 
T value_or( U&amp;&amp; value ) &amp;&amp;;
}}
{{dcl end}}

Returns the contained value if {{c|*this}} is in ''engaged'' state, otherwise returns {{tt|value}}.

===Parameters===
{{par begin}}
{{par | value | the value to exchange}}
{{par hreq}}
{{par req concept | T | CopyConstructible | overload=1}}
{{par req concept | T | MoveConstructible | overload=2}}
{{par req | {{tt|U&amp;&amp;}} must be convertible to {{tt|T}}}}
{{par end}}

===Return value===
The current value if {{c|*this}} is in ''engaged'' state, or {{tt|value}} otherwise.

===Exceptions===
Any exception thrown by the selected constructor of {{tt|T}}.

If an exception is thrown, the exception safety guarantee is as follows:

* If {{c|*this}} was in ''engaged'' state, the contents of the contained value depend on the exception safety guarantee of {{tt|T}}'s constructor.
* Otherwise, the state of {{c|*this}} does not change. The contents of {{tt|value}} depend on the exception safety guarantee of {{tt|T}}'s constructor.

===See also===
{{dsc begin}}
{{dsc inc | cpp/experimental/optional/dsc value}}
{{dsc end}}</text>
      <sha1>e0w6v0h8df7h4t12w2wydf5p74j1h2b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/experimental/optional/~optional</title>
    <ns>0</ns>
    <id>10079</id>
    <revision>
      <id>68163</id>
      <parentid>68062</parentid>
      <timestamp>2014-03-17T01:39:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="220">{{cpp/experimental/optional/title|optional}}
{{cpp/experimental/optional/navbar}}
{{ddcl | since=libfund_ts |
~optional()
}}

If the object is in ''engaged'' state, destroys the contained value by calling its destructor.</text>
      <sha1>dlww0sg4y549j5vamk6pt386pt3b3bn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/functional</title>
    <ns>0</ns>
    <id>2357</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>5347</id>
      <timestamp>2011-07-26T15:27:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/functional]] to [[cpp/utility/functional]]: correct the hierarchy</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/functional/placeholders</title>
    <ns>0</ns>
    <id>2697</id>
    <redirect title="cpp/utility/functional/placeholders" />
    <revision>
      <id>10191</id>
      <timestamp>2011-08-31T22:17:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/functional/placeholders]] to [[cpp/utility/functional/placeholders]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/utility/functional/placeholders]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header</title>
    <ns>0</ns>
    <id>2125</id>
    <revision>
      <id>72065</id>
      <parentid>71004</parentid>
      <timestamp>2014-07-11T10:30:30Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>std::basic_iostream is defined in the header &lt;istream&gt;, while &lt;iostream&gt; only declares standard stream objects and includes other headers</comment>
      <text xml:space="preserve" bytes="13224">{{title|C++ Standard Library header files}}
{{cpp/header/navbar}}

The interface of C++ standard library is defined by the following collection of header files.

{{dsc begin}}

{{dsc h1|Utilities library}}

{{dsc|{{ttb|{{header|cstdlib}}}} |General purpose utilities: [[cpp/utility/program | program control]], [[cpp/memory/c | dynamic memory allocation]], [[cpp/numeric/random | random numbers]], [[cpp/algorithm | sort and search]] }}
{{dsc|{{ttb|{{header|csignal}}}} |[[cpp/utility/program | Functions and macro constants for signal management]]}}
{{dsc|{{ttb|{{header|csetjmp}}}} |[[cpp/utility/program/setjmp | Macro (and function) that saves (and jumps) to an execution context]]}}
{{dsc|{{ttb|{{header|cstdarg}}}} |[[cpp/utility/variadic | Handling of variable length argument lists]]}}
{{dsc|{{ttb|{{header|typeinfo}}}} |[[cpp/types | Runtime type information utilities]]}}
{{dsc|{{ttb|{{header|typeindex}}}} {{mark since c++11}}|{{lc|std::type_index}} }}
{{dsc|{{ttb|{{header|type_traits}}}} {{mark since c++11}}|[[cpp/types|Compile-time type information]] }}
{{dsc|{{ttb|{{header|bitset}}}} |{{lc|std::bitset}} class template }}
{{dsc|{{ttb|{{header|functional}}}} |[[cpp/utility/functional | Function objects]], designed for use with the [[cpp/algorithm | standard algorithms]] }}
{{dsc|{{ttb|{{header|utility}}}} |Various [[cpp/utility | utility components]]}}
{{dsc|{{ttb|{{header|ctime}}}} |[[cpp/chrono/c | C-style time/date utilites]] }}
{{dsc|{{ttb|{{header|chrono}}}} {{mark since c++11}}|[[cpp/chrono | C++ time utilites]] }}
{{dsc|{{ttb|{{header|cstddef}}}} |[[cpp/types | typedefs for types such as size_t, NULL and others]] }}
{{dsc|{{ttb|{{header|initializer_list}}}} {{mark since c++11}}|{{lc|std::initializer_list}} class template }}
{{dsc|{{ttb|{{header|tuple}}}} {{mark since c++11}}|{{lc|std::tuple}} class template }}

{{dsc h2|Dynamic memory management}}

{{dsc|{{ttb|{{header|new}}}} |[[cpp/memory/new | Low-level memory management utilities]]}}
{{dsc|{{ttb|{{header|memory}}}} |[[cpp/memory | Higher level memory management utilities]] }}
{{dsc|{{ttb|{{header|scoped_allocator}}}} {{mark since c++11}}|[[cpp/memory/scoped_allocator_adaptor | Nested allocator class ]] }}

{{dsc h2|Numeric limits}}

{{dsc|{{ttb|{{header|climits}}}} |[[cpp/types/climits | limits of integral types]]}}
{{dsc|{{ttb|{{header|cfloat}}}} |[[cpp/types/climits | limits of float types]]}}
{{dsc|{{ttb|{{header|cstdint}}}} {{mark since c++11}}| [[cpp/types/integer | fixed-size types]] and [[cpp/types/climits | limits of other types]]}}
{{dsc|{{ttb|{{header|cinttypes}}}} {{mark since c++11}} | [[cpp/types/integer | formatting macros ]], {{tt|intmax_t}} and {{tt|uintmax_t}} math and conversions }}
{{dsc|{{ttb|{{header|limits}}}} |[[cpp/types/numeric_limits | standardized way to query properties of fundamental types]]}}

{{dsc h2|Error handling}}

{{dsc|{{ttb|{{header|exception}}}} |[[cpp/error | Exception handling utilities]]}}
{{dsc|{{ttb|{{header|stdexcept}}}} |[[cpp/error | Standard exception objects]] }}
{{dsc|{{ttb|{{header|cassert}}}} |[[cpp/error/assert | Conditionally compiled macro that compares its argument to zero]]}}
{{dsc|{{ttb|{{header|system_error}}}} {{mark since c++11}} |[[cpp/error/error_code | defines std::error_code, a platform-dependent error code]]}}
{{dsc|{{ttb|{{header|cerrno}}}} |[[cpp/error | Macro containing the last error number]]}}

{{dsc h1|Strings library}}

{{dsc|{{ttb|{{header|cctype}}}} |[[cpp/string/byte | functions to determine the type contained in character data]] }}
{{dsc|{{ttb|{{header|cwctype}}}} |[[cpp/string/wide | functions for determining the type of wide character data ]]}}
{{dsc|{{ttb|{{header|cstring}}}} |various [[cpp/string/byte | narrow character string handling functions]] }}
{{dsc|{{ttb|{{header|cwchar}}}} |various [[cpp/string/wide | wide ]] and [[cpp/string/multibyte | multibyte]] string handling functions }}
{{dsc|{{ttb|{{header|cuchar}}}} {{mark since c++11}}|C-style [[cpp/string/multibyte | Unicode character conversion functions]] }}
{{dsc|{{ttb|{{header|string}}}} |{{lc|std::basic_string}} class template }}

{{dsc h1|Containers library}}

{{dsc|{{ttb|{{header|array}}}} {{mark since c++11}}|{{lc|std::array}} container }}
{{dsc|{{ttb|{{header|vector}}}} |{{lc|std::vector}} container }}
{{dsc|{{ttb|{{header|deque}}}} |{{lc|std::deque}} container }}
{{dsc|{{ttb|{{header|list}}}} |{{lc|std::list}} container }}
{{dsc|{{ttb|{{header|forward_list}}}} {{mark since c++11}}|{{lc|std::forward_list}} container }}
{{dsc|{{ttb|{{header|set}}}} |{{lc|std::set}} and {{lc|std::multiset}} associative containers }}
{{dsc|{{ttb|{{header|map}}}} |{{lc|std::map}} and {{lc|std::multimap}} associative containers }}
{{dsc|{{ttb|{{header|unordered_set}}}} {{mark since c++11}} |{{lc|std::unordered_set}} and {{lc|std::unordered_multiset}} unordered associative containers }}
{{dsc|{{ttb|{{header|unordered_map}}}} {{mark since c++11}}|{{lc|std::unordered_map}} and {{lc|std::unordered_multimap}} unordered associative containers }}
{{dsc|{{ttb|{{header|stack}}}} |{{lc|std::stack}} container adaptor }}
{{dsc|{{ttb|{{header|queue}}}} |{{lc|std::queue}} and {{lc|std::priority_queue}} container adaptors }}

{{dsc h1|Algorithms library}}

{{dsc|{{ttb|{{header|algorithm}}}} |[[cpp/algorithm | Algorithms that operate on containers]] }}

{{dsc h1|Iterators library}}

{{dsc|{{ttb|{{header|iterator}}}} |[[cpp/iterator | Container iterators]] }}

{{dsc h1|Numerics library}}

{{dsc|{{ttb|{{header|cmath}}}} |[[cpp/numeric/math | Common mathematics functions]] }}
{{dsc|{{ttb|{{header|complex}}}} |[[cpp/numeric/complex | Complex number type]] }}
{{dsc|{{ttb|{{header|valarray}}}} |[[cpp/numeric/valarray | Class for representing and manipulating arrays of values]] }}
{{dsc|{{ttb|{{header|random}}}} {{mark since c++11}} |[[cpp/numeric/random | Random number generators and distributions]] }}
{{dsc|{{ttb|{{header|numeric}}}} |[[cpp/numeric | Numeric operations on values in containers]] }}
{{dsc|{{ttb|{{header|ratio}}}} {{mark since c++11}}|[[cpp/numeric/ratio | Compile-time rational arithmetic]] }}
{{dsc|{{ttb|{{header|cfenv}}}} {{mark since c++11}}|[[cpp/numeric/fenv | Floating-point environment]] access functions }}

{{dsc h1|Input/output library}}

{{dsc|{{ttb|{{header|iosfwd}}}} |forward declarations of all classes in the input/output library }}
{{dsc|{{ttb|{{header|ios}}}} |{{lc|std::ios_base}} class, {{lc|std::basic_ios}} class template and several typedefs }}
{{dsc|{{ttb|{{header|istream}}}} |{{lc|std::basic_istream}} class template and several typedefs }}
{{dsc|{{ttb|{{header|ostream}}}} |{{lc|std::basic_ostream}}, {{lc|std::basic_iostream}} class templates and several typedefs }}
{{dsc|{{ttb|{{header|iostream}}}} |several standard stream objects  }}
{{dsc|{{ttb|{{header|fstream}}}} |{{lc|std::basic_fstream}}, {{lc|std::basic_ifstream}}, {{lc|std::basic_ofstream}} class templates and several typedefs }}
{{dsc|{{ttb|{{header|sstream}}}} |{{lc|std::basic_stringstream}}, {{lc|std::basic_istringstream}}, {{lc|std::basic_ostringstream}} class templates and several typedefs }}
{{dsc|{{ttb|{{header|strstream}}}}|{{c|std::strstream}}, {{c|std::istrstream}}, {{c|std::ostrstream}}{{mark deprecated}} }}
{{dsc|{{ttb|{{header|iomanip}}}} |[[cpp/io/manip | Helper functions to control the format or input and output]] }}
{{dsc|{{ttb|{{header|streambuf}}}} |{{lc|std::basic_streambuf}} class template}}
{{dsc|{{ttb|{{header|cstdio}}}} |[[cpp/io/c | C-style input-output functions]] }}

{{dsc h1|Localization library}}

{{dsc|{{ttb|{{header|locale}}}} |[[cpp/locale | Localization utilities]] }}
{{dsc|{{ttb|{{header|clocale}}}} |[[cpp/locale | C localization utilities]] }}
{{dsc|{{ttb|{{header|codecvt}}}} {{mark since c++11}} |[[cpp/locale | Unicode conversion facilities]] }}

{{dsc h1|Regular Expressions library}}

{{dsc|{{ttb|{{header|regex}}}} {{mark since c++11}}|[[cpp/regex | Classes, algorithms and iterators to support regular expression processing  ]]}}

{{dsc h1|Atomic Operations library}}

{{dsc|{{ttb|{{header|atomic}}}} {{mark since c++11}}|[[cpp/atomic | Atomic operations library]] }}

{{dsc h1|Thread support library}}

{{dsc|{{ttb|{{header|thread}}}} {{mark since c++11}}|{{lc|std::thread}} class and [[cpp/thread | supporting functions]] }}
{{dsc|{{ttb|{{header|mutex}}}} {{mark since c++11}}|[[cpp/thread | mutual exclusion primitives]] }}
{{dsc|{{ttb|{{header|shared_mutex}}}} {{mark since c++14}}|[[cpp/thread | shared mutual exclusion primitives]] }}
{{dsc|{{ttb|{{header|future}}}} {{mark since c++11}}|[[cpp/thread | primitives for asynchronous computations]]}}
{{dsc|{{ttb|{{header|condition_variable}}}} {{mark since c++11}}|[[cpp/thread|thread waiting conditions]]}}

{{dsc h1|C compatibility headers}}
{{dsc|{{ttb|{{header|ciso646}}}} | empty header. The macros that appear in {{tt|iso646.h}} in C are keywords in C++ }}
{{dsc|{{ttb|{{header|ccomplex}}}} {{mark since c++11}} | simply includes the header &amp;lt;complex&amp;gt; }}
{{dsc|{{ttb|{{header|ctgmath}}}} {{mark since c++11}} | simply includes the headers &amp;lt;ccomplex&amp;gt; and &amp;lt;cmath&amp;gt;: the overloads equivalent to the contents of the C header {{tt|tgmath.h}} are already provided by &amp;lt;cmath&amp;gt; and &amp;lt;complex&amp;gt; }}
{{dsc|{{ttb|{{header|cstdalign}}}} {{mark since c++11}} | defines one [[cpp/types |compatibility macro constant ]] }}
{{dsc|{{ttb|{{header|cstdbool}}}} {{mark since c++11}} | defines one [[cpp/types |compatibility macro constant ]] }}

{{dsc h1|Deprecated headers}}
{{dsc|{{ttb|&amp;lt;assert.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cassert}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;complex.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|ccomplex}}  is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;ctype.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cctype}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;errno.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cerrno}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;fenv.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cfenv}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;float.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cfloat}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;inttypes.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cinttypes}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;iso646.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|ciso646}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;limits.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|climits}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;locale.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|clocale}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;math.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cmath}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;setjmp.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|csetjmp}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;signal.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|csignal}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdalign.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdalign}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdarg.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdarg}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdbool.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdbool}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stddef.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstddef}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdint.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdint}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdio.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdio}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;stdlib.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstdlib}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;string.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cstring}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;tgmath.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|ctgmath}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;time.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|ctime}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;uchar.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cuchar}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;wchar.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cwchar}} is placed in global namespace }}
{{dsc|{{ttb|&amp;lt;wctype.h&amp;gt;}} {{mark deprecated}} | behaves as if each name from {{header|cwctype}} is placed in global namespace }}

{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/header | C Standard Library header files}}
{{dsc end}}

[[ar:cpp/header]]
[[de:cpp/header]]
[[es:cpp/header]]
[[fr:cpp/header]]
[[it:cpp/header]]
[[ja:cpp/header]]
[[pt:cpp/header]]
[[ru:cpp/header]]
[[zh:cpp/header]]</text>
      <sha1>j9jbm2xeff6fti01gwgmxapfh9l2ypy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/algorithm</title>
    <ns>0</ns>
    <id>9750</id>
    <revision>
      <id>57426</id>
      <parentid>49538</parentid>
      <timestamp>2013-06-01T05:53:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="30900">{{cpp/header/title|algorithm}}
{{cpp/header/navbar}}

This header is part of the [[cpp/algorithm|algorithm]] library.

===Functions===
{{dsc begin}}
{{dsc h2 | Non-modifying sequence operations}}
{{dsc inc | cpp/algorithm/dsc all_any_none_of}}
{{dsc inc | cpp/algorithm/dsc for_each}}
{{dsc inc | cpp/algorithm/dsc count}}
{{dsc inc | cpp/algorithm/dsc mismatch}}
{{dsc inc | cpp/algorithm/dsc equal}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc inc | cpp/algorithm/dsc find_end}}
{{dsc inc | cpp/algorithm/dsc find_first_of}}
{{dsc inc | cpp/algorithm/dsc adjacent_find}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc inc | cpp/algorithm/dsc search_n}}

{{dsc h2 | Modifying sequence operations}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_n}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/algorithm/dsc move}}
{{dsc inc | cpp/algorithm/dsc move_backward}}
{{dsc inc | cpp/algorithm/dsc fill}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/algorithm/dsc transform}}
{{dsc inc | cpp/algorithm/dsc generate}}
{{dsc inc | cpp/algorithm/dsc generate_n}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc inc | cpp/algorithm/dsc remove_copy}}
{{dsc inc | cpp/algorithm/dsc replace}}
{{dsc inc | cpp/algorithm/dsc replace_copy}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/algorithm/dsc swap_ranges}}
{{dsc inc | cpp/algorithm/dsc iter_swap}}
{{dsc inc | cpp/algorithm/dsc reverse}}
{{dsc inc | cpp/algorithm/dsc reverse_copy}}
{{dsc inc | cpp/algorithm/dsc rotate}}
{{dsc inc | cpp/algorithm/dsc rotate_copy}}
{{dsc inc | cpp/algorithm/dsc random_shuffle}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc inc | cpp/algorithm/dsc unique_copy}}

{{dsc h2 | Partitioning operations}}
{{dsc inc | cpp/algorithm/dsc is_partitioned}}
{{dsc inc | cpp/algorithm/dsc partition}}
{{dsc inc | cpp/algorithm/dsc partition_copy}}
{{dsc inc | cpp/algorithm/dsc stable_partition}}
{{dsc inc | cpp/algorithm/dsc partition_point}}

{{dsc h2 | Sorting operations (on sorted ranges)}}
{{dsc inc | cpp/algorithm/dsc is_sorted}}
{{dsc inc | cpp/algorithm/dsc is_sorted_until}}
{{dsc inc | cpp/algorithm/dsc sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort}}
{{dsc inc | cpp/algorithm/dsc partial_sort_copy}}
{{dsc inc | cpp/algorithm/dsc stable_sort}}
{{dsc inc | cpp/algorithm/dsc nth_element}}

{{dsc h2 | Binary search operations (on sorted ranges)}}
{{dsc inc | cpp/algorithm/dsc lower_bound}}
{{dsc inc | cpp/algorithm/dsc upper_bound}}
{{dsc inc | cpp/algorithm/dsc binary_search}}
{{dsc inc | cpp/algorithm/dsc equal_range}}

{{dsc h2 | Set operations (on sorted ranges)}}
{{dsc inc | cpp/algorithm/dsc merge}}
{{dsc inc | cpp/algorithm/dsc inplace_merge}}
{{dsc inc | cpp/algorithm/dsc includes}}
{{dsc inc | cpp/algorithm/dsc set_difference}}
{{dsc inc | cpp/algorithm/dsc set_intersection}}
{{dsc inc | cpp/algorithm/dsc set_symmetric_difference}}
{{dsc inc | cpp/algorithm/dsc set_union}}

{{dsc h2 | Heap operations}}
{{dsc inc | cpp/algorithm/dsc is_heap}}
{{dsc inc | cpp/algorithm/dsc is_heap_until}}
{{dsc inc | cpp/algorithm/dsc make_heap}}
{{dsc inc | cpp/algorithm/dsc push_heap}}
{{dsc inc | cpp/algorithm/dsc pop_heap}}
{{dsc inc | cpp/algorithm/dsc sort_heap}}

{{dsc h2 | Minimum/maximum operations}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc inc | cpp/algorithm/dsc is_permutation}}
{{dsc inc | cpp/algorithm/dsc next_permutation}}
{{dsc inc | cpp/algorithm/dsc prev_permutation}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;initializer_list&gt;
namespace std
{
    // non-modifying sequence operations:
    template &lt;class InputIterator, class Predicate&gt;
        bool all_of(InputIterator first, InputIterator last, Predicate pred);
    template &lt;class InputIterator, class Predicate&gt;
        bool any_of(InputIterator first, InputIterator last, Predicate pred);
    template &lt;class InputIterator, class Predicate&gt;
        bool none_of(InputIterator first, InputIterator last, Predicate pred);
        
    template&lt;class InputIterator, class Function&gt;
        Function for_each(InputIterator first, InputIterator last, Function f);
        
    template&lt;class InputIterator, class T&gt;
        InputIterator find(InputIterator first, InputIterator last,
                           const T&amp; value);
    template&lt;class InputIterator, class Predicate&gt;
        InputIterator find_if(InputIterator first, InputIterator last,
                              Predicate pred);
    template&lt;class InputIterator, class Predicate&gt;
        InputIterator find_if_not(InputIterator first, InputIterator last,
                                  Predicate pred);
                                  
    template&lt;class ForwardIterator1, class ForwardIterator2&gt;
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2);
    template&lt;class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate&gt;
        ForwardIterator1
        find_end(ForwardIterator1 first1, ForwardIterator1 last1,
                 ForwardIterator2 first2, ForwardIterator2 last2,
                 BinaryPredicate pred);
                 
    template&lt;class InputIterator, class ForwardIterator&gt;
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2);
    template&lt;class InputIterator, class ForwardIterator,
             class BinaryPredicate&gt;
        InputIterator
        find_first_of(InputIterator first1, InputIterator last1,
                      ForwardIterator first2, ForwardIterator last2,
                      BinaryPredicate pred);
                      
    template&lt;class ForwardIterator&gt;
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last);
    template&lt;class ForwardIterator, class BinaryPredicate&gt;
        ForwardIterator adjacent_find(ForwardIterator first,
                                      ForwardIterator last,
                                      BinaryPredicate pred);
    template&lt;class InputIterator, class T&gt;
        typename iterator_traits&lt;InputIterator&gt;::difference_type
        count(InputIterator first, InputIterator last, const T&amp; value);
    template&lt;class InputIterator, class Predicate&gt;
        typename iterator_traits&lt;InputIterator&gt;::difference_type
        count_if(InputIterator first, InputIterator last, Predicate pred);
        
    template&lt;class InputIterator1, class InputIterator2&gt;
        pair&lt;InputIterator1, InputIterator2&gt;
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2);
    template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
        pair&lt;InputIterator1, InputIterator2&gt;
        mismatch(InputIterator1 first1, InputIterator1 last1,
                 InputIterator2 first2, BinaryPredicate pred);
                 
    template&lt;class InputIterator1, class InputIterator2&gt;
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2);
    template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
        bool equal(InputIterator1 first1, InputIterator1 last1,
                   InputIterator2 first2, BinaryPredicate pred);
                   
    template&lt;class ForwardIterator1, class ForwardIterator2&gt;
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2);
    template&lt;class ForwardIterator1, class ForwardIterator2,
    class BinaryPredicate&gt;
        bool is_permutation(ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, BinaryPredicate pred);
                            
    template&lt;class ForwardIterator1, class ForwardIterator2&gt;
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2);
    template&lt;class ForwardIterator1, class ForwardIterator2,
             class BinaryPredicate&gt;
        ForwardIterator1 search(
            ForwardIterator1 first1, ForwardIterator1 last1,
            ForwardIterator2 first2, ForwardIterator2 last2,
            BinaryPredicate pred);
            
    template&lt;class ForwardIterator, class Size, class T&gt;
        ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                                 Size count, const T&amp; value);
    template&lt;class ForwardIterator, class Size, class T, class BinaryPredicate&gt;
        ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                                  Size count, const T&amp; value,
                                  BinaryPredicate pred);
                                  
    // modifying sequence operations:
    
    // copy:
    template&lt;class InputIterator, class OutputIterator&gt;
        OutputIterator copy(InputIterator first, InputIterator last,
                            OutputIterator result);
    template&lt;class InputIterator, class Size, class OutputIterator&gt;
        OutputIterator copy_n(InputIterator first, Size n,
                              OutputIterator result);
    template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
        OutputIterator copy_if(InputIterator first, InputIterator last,
                               OutputIterator result, Predicate pred);
    template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
        BidirectionalIterator2 copy_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
            
    // move:
    template&lt;class InputIterator, class OutputIterator&gt;
        OutputIterator move(InputIterator first, InputIterator last,
                            OutputIterator result);
    template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
        BidirectionalIterator2 move_backward(
            BidirectionalIterator1 first, BidirectionalIterator1 last,
            BidirectionalIterator2 result);
            
    // swap:
    template&lt;class ForwardIterator1, class ForwardIterator2&gt;
        ForwardIterator2 swap_ranges(ForwardIterator1 first1,
                                     ForwardIterator1 last1, ForwardIterator2 first2);
    template&lt;class ForwardIterator1, class ForwardIterator2&gt;
        void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
    template&lt;class InputIterator, class OutputIterator, class UnaryOperation&gt;
        OutputIterator transform(InputIterator first, InputIterator last,
                                 OutputIterator result, UnaryOperation op);
                                 
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
             class BinaryOperation&gt;
        OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, OutputIterator result,
                                 BinaryOperation binary_op);
                                 
    template&lt;class ForwardIterator, class T&gt;
        void replace(ForwardIterator first, ForwardIterator last,
                     const T&amp; old_value, const T&amp; new_value);
    template&lt;class ForwardIterator, class Predicate, class T&gt;
        void replace_if(ForwardIterator first, ForwardIterator last,
                        Predicate pred, const T&amp; new_value);
    template&lt;class InputIterator, class OutputIterator, class T&gt;
        OutputIterator replace_copy(InputIterator first, InputIterator last,
                                    OutputIterator result,
                                    const T&amp; old_value, const T&amp; new_value);
    template&lt;class InputIterator, class OutputIterator, class Predicate, class T&gt;
        OutputIterator replace_copy_if(InputIterator first, InputIterator last,
                                       OutputIterator result,
                                       Predicate pred, const T&amp; new_value);
                                       
    template&lt;class ForwardIterator, class T&gt;
        void fill(ForwardIterator first, ForwardIterator last, const T&amp; value);
    template&lt;class OutputIterator, class Size, class T&gt;
        OutputIterator fill_n(OutputIterator first, Size n, const T&amp; value);
    template&lt;class ForwardIterator, class Generator&gt;
        void generate(ForwardIterator first, ForwardIterator last,
                      Generator gen);
    template&lt;class OutputIterator, class Size, class Generator&gt;
        OutputIterator generate_n(OutputIterator first, Size n, Generator gen);
        
    template&lt;class ForwardIterator, class T&gt;
        ForwardIterator remove(ForwardIterator first, ForwardIterator last,
                               const T&amp; value);
    template&lt;class ForwardIterator, class Predicate&gt;
        ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
                                  Predicate pred);
    template&lt;class InputIterator, class OutputIterator, class T&gt;
        OutputIterator remove_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, const T&amp; value);
    template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
        OutputIterator remove_copy_if(InputIterator first, InputIterator last,
                                      OutputIterator result, Predicate pred);
                                      
    template&lt;class ForwardIterator&gt;
        ForwardIterator unique(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class BinaryPredicate&gt;
        ForwardIterator unique(ForwardIterator first, ForwardIterator last,
                               BinaryPredicate pred);
    template&lt;class InputIterator, class OutputIterator&gt;
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result);
    template&lt;class InputIterator, class OutputIterator, class BinaryPredicate&gt;
        OutputIterator unique_copy(InputIterator first, InputIterator last,
                                   OutputIterator result, BinaryPredicate pred);
                                   
    template&lt;class BidirectionalIterator&gt;
        void reverse(BidirectionalIterator first, BidirectionalIterator last);
    template&lt;class BidirectionalIterator, class OutputIterator&gt;
        OutputIterator reverse_copy(BidirectionalIterator first,
                                    BidirectionalIterator last,
                                    OutputIterator result);
                                    
    template&lt;class ForwardIterator&gt;
        ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
                               ForwardIterator last);
    template&lt;class ForwardIterator, class OutputIterator&gt;
        OutputIterator rotate_copy(
            ForwardIterator first, ForwardIterator middle,
            ForwardIterator last, OutputIterator result);
            
    template&lt;class RandomAccessIterator&gt;
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;
        void random_shuffle(RandomAccessIterator first,
                            RandomAccessIterator last,
                            RandomNumberGenerator&amp;&amp; rand);
    template&lt;class RandomAccessIterator, class UniformRandomNumberGenerator&gt;
        void shuffle(RandomAccessIterator first,
                     RandomAccessIterator last,
                     UniformRandomNumberGenerator&amp;&amp; rand);
                     
    // partitions:
    template &lt;class InputIterator, class Predicate&gt;
        bool is_partitioned(InputIterator first, InputIterator last, Predicate pred);
        
    template&lt;class ForwardIterator, class Predicate&gt;
        ForwardIterator partition(ForwardIterator first,
                                  ForwardIterator last,
                                  Predicate pred);
                                  
    template&lt;class BidirectionalIterator, class Predicate&gt;
        BidirectionalIterator stable_partition(BidirectionalIterator first,
                                               BidirectionalIterator last,
                                               Predicate pred);
                                               
    template &lt;class InputIterator, class OutputIterator1,
              class OutputIterator2, class Predicate&gt;
        pair&lt;OutputIterator1, OutputIterator2&gt;
        partition_copy(InputIterator first, InputIterator last,
                       OutputIterator1 out_true, OutputIterator2 out_false,
                       Predicate pred);
                       
    template&lt;class ForwardIterator, class Predicate&gt;
        ForwardIterator partition_point(ForwardIterator first,
                                        ForwardIterator last,
                                        Predicate pred);
                                        
    // sorting and related operations:
    
    // sorting:
    template&lt;class RandomAccessIterator&gt;
        void sort(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void sort(RandomAccessIterator first, RandomAccessIterator last,
                  Compare comp);
                  
    template&lt;class RandomAccessIterator&gt;
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
                         Compare comp);
                         
    template&lt;class RandomAccessIterator&gt;
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void partial_sort(RandomAccessIterator first,
                          RandomAccessIterator middle,
                          RandomAccessIterator last, Compare comp);
    template&lt;class InputIterator, class RandomAccessIterator&gt;
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last);
    template&lt;class InputIterator, class RandomAccessIterator, class Compare&gt;
        RandomAccessIterator partial_sort_copy(
            InputIterator first, InputIterator last,
            RandomAccessIterator result_first,
            RandomAccessIterator result_last,
            Compare comp);
            
    template&lt;class ForwardIterator&gt;
        bool is_sorted(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class Compare&gt;
        bool is_sorted(ForwardIterator first, ForwardIterator last,
                       Compare comp);
    template&lt;class ForwardIterator&gt;
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class Compare&gt;
        ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
                                        Compare comp);
                                        
    template&lt;class RandomAccessIterator&gt;
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
                         RandomAccessIterator last, Compare comp);
    // binary search:
    template&lt;class ForwardIterator, class T&gt;
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T&amp; value);
    template&lt;class ForwardIterator, class T, class Compare&gt;
        ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
                                    const T&amp; value, Compare comp);
                                    
    template&lt;class ForwardIterator, class T&gt;
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T&amp; value);
    template&lt;class ForwardIterator, class T, class Compare&gt;
        ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
                                    const T&amp; value, Compare comp);
                                    
    template&lt;class ForwardIterator, class T&gt;
        pair&lt;ForwardIterator, ForwardIterator&gt;
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T&amp; value);
    template&lt;class ForwardIterator, class T, class Compare&gt;
        pair&lt;ForwardIterator, ForwardIterator&gt;
        equal_range(ForwardIterator first, ForwardIterator last,
                    const T&amp; value, Compare comp);
                    
    template&lt;class ForwardIterator, class T&gt;
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T&amp; value);
    template&lt;class ForwardIterator, class T, class Compare&gt;
        bool binary_search(ForwardIterator first, ForwardIterator last,
                           const T&amp; value, Compare comp);
                       
    // merge:
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result);
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
            class Compare&gt;
        OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
                             InputIterator2 first2, InputIterator2 last2,
                             OutputIterator result, Compare comp);
                             
    template&lt;class BidirectionalIterator&gt;
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last);
    template&lt;class BidirectionalIterator, class Compare&gt;
        void inplace_merge(BidirectionalIterator first,
                           BidirectionalIterator middle,
                           BidirectionalIterator last, Compare comp);
                       
    // set operations:
    template&lt;class InputIterator1, class InputIterator2&gt;
        bool includes(InputIterator1 first1, InputIterator1 last1,
                      InputIterator2 first2, InputIterator2 last2);
    template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
        bool includes(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2, Compare comp);
            
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result);
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare&gt;
        OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
                                 InputIterator2 first2, InputIterator2 last2,
                                 OutputIterator result, Compare comp);
                                 
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare&gt;
        OutputIterator set_intersection(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
            
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare&gt;
        OutputIterator set_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
            
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result);
    template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
             class Compare&gt;
        OutputIterator set_symmetric_difference(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            OutputIterator result, Compare comp);
        
    // heap operations:
    template&lt;class RandomAccessIterator&gt;
        void push_heap(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void push_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
    template&lt;class RandomAccessIterator&gt;
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
                      Compare comp);
                  
    template&lt;class RandomAccessIterator&gt;
        void make_heap(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void make_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
                   
    template&lt;class RandomAccessIterator&gt;
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
                       Compare comp);
                   
    template&lt;class RandomAccessIterator&gt;
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        bool is_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp);
    template&lt;class RandomAccessIterator&gt;
        RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last);
    template&lt;class RandomAccessIterator, class Compare&gt;
        RandomAccessIterator is_heap_until(RandomAccessIterator first, RandomAccessIterator last,
                                           Compare comp);
    // minimum and maximum:
    template&lt;class T&gt; const T&amp; min(const T&amp; a, const T&amp; b);
    template&lt;class T, class Compare&gt;
        const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
    template&lt;class T&gt;
        T min(initializer_list&lt;T&gt; t);
    template&lt;class T, class Compare&gt;
        T min(initializer_list&lt;T&gt; t, Compare comp);
        
    template&lt;class T&gt; const T&amp; max(const T&amp; a, const T&amp; b);
    template&lt;class T, class Compare&gt;
        const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);
    template&lt;class T&gt;
        T max(initializer_list&lt;T&gt; t);
    template&lt;class T, class Compare&gt;
        T max(initializer_list&lt;T&gt; t, Compare comp);
        
    template&lt;class T&gt; pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b);
    template&lt;class T, class Compare&gt;
        pair&lt;const T&amp;, const T&amp;&gt; minmax(const T&amp; a, const T&amp; b, Compare comp);
    template&lt;class T&gt;
        pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t);
    template&lt;class T, class Compare&gt;
        pair&lt;T, T&gt; minmax(initializer_list&lt;T&gt; t, Compare comp);
        
    template&lt;class ForwardIterator&gt;
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class Compare&gt;
        ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
                                    
    template&lt;class ForwardIterator&gt;
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class Compare&gt;
        ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
                                    Compare comp);
                                    
    template&lt;class ForwardIterator&gt;
        pair&lt;ForwardIterator, ForwardIterator&gt;
        minmax_element(ForwardIterator first, ForwardIterator last);
    template&lt;class ForwardIterator, class Compare&gt;
        pair&lt;ForwardIterator, ForwardIterator&gt;
        minmax_element(ForwardIterator first, ForwardIterator last, Compare comp);
        
    template&lt;class InputIterator1, class InputIterator2&gt;
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2);
    template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
        bool lexicographical_compare(
            InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, InputIterator2 last2,
            Compare comp);
        
    // permutations:
    template&lt;class BidirectionalIterator&gt;
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template&lt;class BidirectionalIterator, class Compare&gt;
        bool next_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
                              
    template&lt;class BidirectionalIterator&gt;
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last);
    template&lt;class BidirectionalIterator, class Compare&gt;
        bool prev_permutation(BidirectionalIterator first,
                              BidirectionalIterator last, Compare comp);
}
 

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/array</title>
    <ns>0</ns>
    <id>9673</id>
    <revision>
      <id>57429</id>
      <parentid>49539</parentid>
      <timestamp>2013-06-01T05:53:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4152">{{cpp/header/title|array|{{mark since c++11}}}}
{{cpp/header/navbar}}

This header is part of the [[cpp/container|containers]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc array}}
{{dsc inc | cpp/container/array/dsc tuple_size}}
{{dsc inc | cpp/container/array/dsc tuple_element}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | array}}
{{dsc inc | cpp/container/array/dsc get}}
{{dsc inc | cpp/container/dsc swap2 | array}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    
    template &lt;class T, size_t N &gt; struct array;
    
    template &lt;class T, size_t N&gt;
        bool operator{{==}}(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
    template &lt;class T, size_t N&gt;
        bool operator!{{=}}(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
    template &lt;class T, size_t N&gt;
        bool operator&lt;(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
    template &lt;class T, size_t N&gt;
        bool operator&gt;(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
    template &lt;class T, size_t N&gt;
        bool operator&lt;{{=}}(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
    template &lt;class T, size_t N&gt;
        bool operator&gt;{{=}}(const array&lt;T,N&gt;&amp; x, const array&lt;T,N&gt;&amp; y);
        
    template &lt;class T, size_t N &gt;
        void swap(array&lt;T,N&gt;&amp; x, array&lt;T,N&gt;&amp; y) noexcept(noexcept(x.swap(y)));
    
    template &lt;class T&gt; class tuple_size;
    template &lt;size_t I, class T&gt; class tuple_element;
    template &lt;class T, size_t N&gt; struct tuple_size&lt;array&lt;T, N&gt; &gt;;
    template &lt;size_t I, class T, size_t N&gt; struct tuple_element&lt;I, array&lt;T, N&gt; &gt;;
    template &lt;size_t I, class T, size_t N&gt; T&amp; get(array&lt;T, N&gt;&amp;) noexcept;
    template &lt;size_t I, class T, size_t N&gt; T&amp;&amp; get(array&lt;T, N&gt;&amp;&amp;) noexcept;
    template &lt;size_t I, class T, size_t N&gt; const T&amp; get(const array&lt;T, N&gt;&amp;) noexcept;
}

}}

====Class {{lc|std::array}}====
{{source|

template &lt;class T, size_t N &gt;
struct array {
    // types:
    typedef T&amp;                               reference;
    typedef const T&amp;                         const_reference;
    typedef /*implementation-defined*/       iterator;
    typedef /*implementation-defined*/       const_iterator;
    typedef size_t                           size_type;
    typedef ptrdiff_t                        difference_type;
    typedef T                                value_type;
    typedef T*                               pointer;
    typedef const T*                         const_pointer;
    typedef reverse_iterator&lt;iterator&gt;       reverse_iterator;
    typedef reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;

    T elems[N]; // exposition only

    // no explicit construct/copy/destroy for aggregate type
    
    void fill(const T&amp; u);
    void swap(array&lt;T, N&gt;&amp;) noexcept(noexcept(swap(declval&lt;T&amp;&gt;(), declval&lt;T&amp;&gt;())));

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;

    // capacity:
    constexpr size_type size() noexcept;
    constexpr size_type max_size() noexcept;
    constexpr bool      empty() noexcept;

    // element access:
    reference       operator[](size_type n);
    const_reference operator[](size_type n) const;
    const_reference at(size_type n) const;
    reference       at(size_type n);
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;
    
    T *       data() noexcept;
    const T * data() const noexcept;
};

}}
=====Note=====
The variable {{ttb|array::elems}} is only for exposition, it's not part of the interface.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/atomic</title>
    <ns>0</ns>
    <id>12858</id>
    <revision>
      <id>64001</id>
      <parentid>64000</parentid>
      <timestamp>2013-08-06T03:28:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="25481">{{cpp/header/title|atomic}}
{{cpp/header/navbar}}
This header is part of the [[cpp/atomic|atomic operations]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/atomic/dsc atomic}}
{{dsc inc | cpp/atomic/dsc atomic_flag}}
{{dsc inc | cpp/atomic/dsc memory_order}}
{{dsc h1|Typedefs}}
{{dsc | {{c|std::atomic_bool}} | {{c|std::atomic&lt;bool&gt;}} }}
{{dsc | {{c|std::atomic_char}} | {{c|std::atomic&lt;char&gt;}} }}
{{dsc | {{c|std::atomic_schar}} | {{c|std::atomic&lt;signed char&gt;}} }}
{{dsc | {{c|std::atomic_uchar}} | {{c|std::atomic&lt;unsigned char&gt;}} }}
{{dsc | {{c|std::atomic_short}} | {{c|std::atomic&lt;short&gt;}} }}
{{dsc | {{c|std::atomic_ushort}} | {{c|std::atomic&lt;unsigned short&gt;}} }}
{{dsc | {{c|std::atomic_int}} | {{c|std::atomic&lt;int&gt;}} }}
{{dsc | {{c|std::atomic_uint}} | {{c|std::atomic&lt;unsigned int&gt;}} }}
{{dsc | {{c|std::atomic_long}} | {{c|std::atomic&lt;long&gt;}} }}
{{dsc | {{c|std::atomic_ulong}} | {{c|std::atomic&lt;unsigned long&gt;}} }}
{{dsc | {{c|std::atomic_llong}} | {{c|std::atomic&lt;long long&gt;}} }}
{{dsc | {{c|std::atomic_ullong}} | {{c|std::atomic&lt;unsigned long long&gt;}} }}
{{dsc | {{c|std::atomic_char16_t}} | {{c|std::atomic&lt;char16_t&gt;}} }}
{{dsc | {{c|std::atomic_char32_t}} | {{c|std::atomic&lt;char32_t&gt;}} }}
{{dsc | {{c|std::atomic_wchar_t}} | {{c|std::atomic&lt;wchar_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least8_t}} | {{c|std::atomic&lt;int_least8_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least8_t}} | {{c|std::atomic&lt;uint_least8_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least16_t}} | {{c|std::atomic&lt;int_least16_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least16_t}} | {{c|std::atomic&lt;uint_least16_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least32_t}} | {{c|std::atomic&lt;int_least32_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least32_t}} | {{c|std::atomic&lt;uint_least32_t&gt;}} }}
{{dsc | {{c|std::atomic_int_least64_t}} | {{c|std::atomic&lt;int_least64_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_least64_t}} | {{c|std::atomic&lt;uint_least64_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast8_t}} | {{c|std::atomic&lt;int_fast8_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast8_t}} | {{c|std::atomic&lt;uint_fast8_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast16_t}} | {{c|std::atomic&lt;int_fast16_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast16_t}} | {{c|std::atomic&lt;uint_fast16_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast32_t}} | {{c|std::atomic&lt;int_fast32_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast32_t}} | {{c|std::atomic&lt;uint_fast32_t&gt;}} }}
{{dsc | {{c|std::atomic_int_fast64_t}} | {{c|std::atomic&lt;int_fast64_t&gt;}} }}
{{dsc | {{c|std::atomic_uint_fast64_t}} | {{c|std::atomic&lt;uint_fast64_t&gt;}} }}
{{dsc | {{c|std::atomic_intptr_t}} | {{c|std::atomic&lt;intptr_t&gt;}} }}
{{dsc | {{c|std::atomic_uintptr_t}} | {{c|std::atomic&lt;uintptr_t&gt;}} }}
{{dsc | {{c|std::atomic_size_t}} | {{c|std::atomic&lt;size_t&gt;}} }}
{{dsc | {{c|std::atomic_ptrdiff_t}} | {{c|std::atomic&lt;ptrdiff_t&gt;}} }}
{{dsc | {{c|std::atomic_intmax_t}} | {{c|std::atomic&lt;intmax_t&gt;}} }}
{{dsc | {{c|std::atomic_uintmax_t}} | {{c|std::atomic&lt;uintmax_t&gt;}} }}
{{dsc h1|Functions}}
{{dsc inc | cpp/atomic/dsc atomic_is_lock_free}}
{{dsc inc | cpp/atomic/dsc atomic_store}}
{{dsc inc | cpp/atomic/dsc atomic_load}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_compare_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_add}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_sub}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_and}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_or}}
{{dsc inc | cpp/atomic/dsc atomic_fetch_xor}}
{{dsc inc | cpp/atomic/dsc atomic_flag_test_and_set}}
{{dsc inc | cpp/atomic/dsc atomic_flag_clear}}
{{dsc inc | cpp/atomic/dsc atomic_init}}
{{dsc inc | cpp/atomic/dsc kill_dependency}}
{{dsc inc | cpp/atomic/dsc atomic_thread_fence}}
{{dsc inc | cpp/atomic/dsc atomic_signal_fence}}
{{dsc h1|Preprocessor macros}}
{{dsc inc | cpp/atomic/dsc ATOMIC_VAR_INIT}}
{{dsc inc | cpp/atomic/dsc ATOMIC_FLAG_INIT}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    typedef enum memory_order {
        memory_order_relaxed,
        memory_order_consume,
        memory_order_acquire,
        memory_order_release,
        memory_order_acq_rel,
        memory_order_seq_cst
    } memory_order;

    template &lt;class T&gt;
    T kill_dependency(T y) noexcept;

    // lock-free property
    #define ATOMIC_BOOL_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR16_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR32_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_WCHAR_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_SHORT_LOCK_FREE /*unspecified*/
    #define ATOMIC_INT_LOCK_FREE /*unspecified*/
    #define ATOMIC_LONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_LLONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_POINTER_LOCK_FREE /*unspecified*/
 
    // generic atomic type
    template&lt;class T&gt; struct atomic;
    // specialization for integral types
    template&lt;&gt; struct atomic&lt;/*integral*/&gt;;
    // specialization for pointers
    template&lt;class T&gt; struct atomic&lt;T*&gt;;

    // named typedefs
    typedef atomic&lt;bool&gt; atomic_bool;
    typedef atomic&lt;char&gt; atomic_char;
    typedef atomic&lt;signed char&gt; atomic_schar;
    typedef atomic&lt;unsigned char&gt; atomic_uchar;
    typedef atomic&lt;short&gt; atomic_short;
    typedef atomic&lt;unsigned short&gt; atomic_ushort;
    typedef atomic&lt;int&gt; atomic_int;
    typedef atomic&lt;unsigned int&gt; atomic_uint;
    typedef atomic&lt;long&gt; atomic_long;
    typedef atomic&lt;unsigned long&gt; atomic_ulong;
    typedef atomic&lt;long long&gt; atomic_llong;
    typedef atomic&lt;unsigned long long&gt; atomic_ullong;
    typedef atomic&lt;char16_t&gt; atomic_char16_t;
    typedef atomic&lt;char32_t&gt; atomic_char32_t;
    typedef atomic&lt;wchar_t&gt; atomic_wchar_t;
    typedef atomic&lt;int_least8_t&gt; atomic_int_least8_t;
    typedef atomic&lt;uint_least8_t&gt; atomic_uint_least8_t;
    typedef atomic&lt;int_least16_t&gt; atomic_int_least16_t;
    typedef atomic&lt;uint_least16_t&gt; atomic_uint_least16_t;
    typedef atomic&lt;int_least32_t&gt; atomic_int_least32_t;
    typedef atomic&lt;uint_least32_t&gt; atomic_uint_least32_t;
    typedef atomic&lt;int_least64_t&gt; atomic_int_least64_t;
    typedef atomic&lt;uint_least64_t&gt; atomic_uint_least64_t;
    typedef atomic&lt;int_fast8_t&gt; atomic_int_fast8_t;
    typedef atomic&lt;uint_fast8_t&gt; atomic_uint_fast8_t;
    typedef atomic&lt;int_fast16_t&gt; atomic_int_fast16_t;
    typedef atomic&lt;uint_fast16_t&gt; atomic_uint_fast16_t;
    typedef atomic&lt;int_fast32_t&gt; atomic_int_fast32_t;
    typedef atomic&lt;uint_fast32_t&gt; atomic_uint_fast32_t;
    typedef atomic&lt;int_fast64_t&gt; atomic_int_fast64_t;
    typedef atomic&lt;uint_fast64_t&gt; atomic_uint_fast64_t;
    typedef atomic&lt;intptr_t&gt; atomic_intptr_t;
    typedef atomic&lt;uintptr_t&gt; atomic_uintptr_t;
    typedef atomic&lt;size_t&gt; atomic_size_t;
    typedef atomic&lt;ptrdiff_t&gt; atomic_ptrdiff_t;
    typedef atomic&lt;intmax_t&gt; atomic_intmax_t;
    typedef atomic&lt;uintmax_t&gt; atomic_uintmax_t;

    // general operations on atomic types
    // /*atomic-type*/ is either atomic&lt;T&gt; or one of the typedefs
    // (if it's atomic&lt;T&gt;, then template&lt;class T&gt; is implied)
    bool atomic_is_lock_free(const volatile /*atomic-type*/ *) noexcept;
    bool atomic_is_lock_free(const /*atomic-type*/ *) noexcept;
    void atomic_init(volatile /*atomic-type*/ *, T) noexcept;
    void atomic_init(/*atomic-type*/ *, T) noexcept;
    void atomic_store(volatile /*atomic-type*/ *, T) noexcept;
    void atomic_store(/*atomic-type*/ *, T) noexcept;
    void atomic_store_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept;
    void atomic_store_explicit(/*atomic-type*/ *, T, memory_order) noexcept;
    T atomic_load(const volatile /*atomic-type*/ *) noexcept;
    T atomic_load(const /*atomic-type*/ *) noexcept;
    T atomic_load_explicit(const volatile /*atomic-type*/ *, memory_order) noexcept;
    T atomic_load_explicit(const /*atomic-type*/ *, memory_order) noexcept;
    T atomic_exchange(volatile /*atomic-type*/ *, T) noexcept;
    T atomic_exchange(/*atomic-type*/ *, T) noexcept;
    T atomic_exchange_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept;
    T atomic_exchange_explicit(/*atomic-type*/ *, T, memory_order) noexcept;
    bool atomic_compare_exchange_weak(volatile /*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_weak(/*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_strong(volatile /*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_strong(/*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_weak_explicit(volatile /*atomic-type*/ *, T*, T,
                                               memory_order, memory_order) noexcept;
    bool atomic_compare_exchange_weak_explicit(/*atomic-type*/ *, T*, T.
                                               memory_order, memory_order) noexcept;
    bool atomic_compare)exchange_strong_explicit(volatile /*atomic-type*/ *, T*, T,
                                                 memory_order, memory_order) noexcept;
    bool atomic_compare_exchange_strong_explicit(/*atomic-type*/ *, T*, T,
                                                 memory_order, memory_order) noexcept;

    // templated operations on atomic types (declared, but not defined)
    template &lt;class T&gt;
    T atomic_fetch_add(volatile atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_add(atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_add_explicit(volatile atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_add_explicit(atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_sub(volatile atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_sub(atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_sub_explicit(volatile atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_sub_explicit(atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_and(volatile atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_and(atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_and_explicit(volatile atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_and_explicit(atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_or(volatile atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_or(atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_or_explicit(volatile atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_or_explicit(atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_xor(volatile atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_xor(atomic&lt;T&gt;*, T) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_xor_explicit(volatile atomic&lt;T&gt;*, T, memory_order) noexcept;
    template &lt;class T&gt;
    T atomic_fetch_xor_explicit(atomic&lt;T&gt;*, T, memory_order) noexcept;

    // arithmetic operations on atomic types
    // /*atomic-integral*/ is either atomic&lt;T&gt; or one of the typedefs
    // (if it's atomic&lt;T&gt;, then template&lt;&gt; is implied)
    /*integral*/ atomic_fetch_add(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_add(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_add_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/,
                                            memory_order) noexcept;
    /*integral*/ atomic_fetch_add_explicit(/*atomic-integral*/ *,
                                           /*integral*/,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_sub(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_sub(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_sub_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_sub_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_and(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_and(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_and_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_and_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_or(volatile /*atomic-integral*/ *,
                                 /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_or(/*atomic-integral*/ *,
                                 /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_or_explicit(volatile /*atomic-integral*/ *,
                                          /*integral*/ ,
                                          memory_order) noexcept;
    /*integral*/ atomic_fetch_or_explicit(/*atomic-integral*/ *,
                                          /*integral*/ ,
                                          memory_order) noexcept;
    /*integral*/ atomic_fetch_xor(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_xor(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_xor_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ , memory_order) noexcept;
    /*integral*/ atomic_fetch_xor_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;

    // partial specializations for pointers
    template &lt;class T&gt;
    T* atomic_fetch_add(volatile atomic&lt;T*&gt;*, ptrdiff_t) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_add(atomic&lt;T*&gt;*, ptrdiff_t) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_add_explicit(volatile atomic&lt;T*&gt;*,
                                 ptrdiff_t, memory_order) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_add_explicit(atomic&lt;T*&gt;*, ptrdiff_t, memory_order) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_sub(volatile atomic&lt;T*&gt;*, ptrdiff_t) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_sub(atomic&lt;T*&gt;*, ptrdiff_t) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_sub_explicit(volatile atomic&lt;T*&gt;*,
                                 ptrdiff_t, memory_order) noexcept;
    template &lt;class T&gt;
    T* atomic_fetch_sub_explicit(atomic&lt;T*&gt;*, ptrdiff_t, memory_order) noexcept;

    // initialization
    #define ATOMIC_VAR_INIT(value) /*see description*/

    // flag type and operations
    struct atomic_flag;

    bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
    bool atomic_flag_test_and_set(atomic_flag*) noexcept;
    bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,
                                           memory_order) noexcept;
    bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear(volatile atomic_flag*) noexcept;
    void atomic_flag_clear(atomic_flag*) noexcept;
    void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;

    #define ATOMIC_FLAG_INIT /*see description*/

    // fences
    extern &quot;C&quot; void atomic_thread_fence(memory_order) noexcept;
    extern &quot;C&quot; void atomic_signal_fence(memory_order) noexcept;
}}

====Class {{lc|std::atomic}}====
{{source|1=
template &lt;class T&gt; struct atomic {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T, memory_order = memory_order_seq_cst) noexcept;
    T load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T load(memory_order = memory_order_seq_cst) const noexcept;
    operator T() const volatile noexcept;
    operator T() const noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) volatile noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T&amp;, T,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T&amp;, T,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T&amp;, T,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T&amp;, T,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T&amp;, T,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T&amp;, T,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T&amp;, T,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T&amp;, T,
                                 memory_order = memory_order_seq_cst) noexcept;

    atomic() noexcept = default;
    constexpr atomic(T) noexcept;
    atomic(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) volatile = delete;
    T operator=(T) volatile noexcept;
    T operator=(T) noexcept;
};
}}

====Specialization of {{lc|std::atomic}} for integral types====
{{source|1=
template&lt;&gt; struct atomic&lt;/*integral*/&gt; {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) volatile noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const volatile noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const noexcept;
    operator /*integral*/() const volatile noexcept;
    operator /*integral*/() const noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(/*integral*/&amp;, /*integral*/,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&amp;, /*integral*/,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(/*integral*/&amp;, /*integral*/,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&amp;, /*integral*/,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(/*integral*/&amp;, /*integral*/,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&amp;, /*integral*/,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(/*integral*/&amp;, /*integral*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&amp;, /*integral*/,
                                 memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;

    atomic() noexcept = default;
    constexpr atomic(/*integral*/) noexcept;
    atomic(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) volatile = delete;
    /*integral*/ operator=(/*integral*/) volatile noexcept;
    /*integral*/ operator=(/*integral*/) noexcept;
    /*integral*/ operator++(int) volatile noexcept;
    /*integral*/ operator++(int) noexcept;
    /*integral*/ operator--(int) volatile noexcept;
    /*integral*/ operator--(int) noexcept;
    /*integral*/ operator++() volatile noexcept;
    /*integral*/ operator++() noexcept;
    /*integral*/ operator--() volatile noexcept;
    /*integral*/ operator--() noexcept;
    /*integral*/ operator+=(/*integral*/) volatile noexcept;
    /*integral*/ operator+=(/*integral*/) noexcept;
    /*integral*/ operator-=(/*integral*/) volatile noexcept;
    /*integral*/ operator-=(/*integral*/) noexcept;
    /*integral*/ operator&amp;=(/*integral*/) volatile noexcept;
    /*integral*/ operator&amp;=(/*integral*/) noexcept;
    /*integral*/ operator{{!}}=(/*integral*/) volatile noexcept;
    /*integral*/ operator{{!}}=(/*integral*/) noexcept;
    /*integral*/ operator^=(/*integral*/) volatile noexcept;
    /*integral*/ operator^=(/*integral*/) noexcept;
};
}}

====Specialization of {{lc|std::atomic}} for pointer types====
{{source|1=
template &lt;class T&gt; struct atomic&lt;T*&gt; {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T*, memory_order = memory_order_seq_cst) noexcept;
    T* load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T* load(memory_order = memory_order_seq_cst) const noexcept;
    operator T*() const volatile noexcept;
    operator T*() const noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T*&amp;, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T*&amp;, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T*&amp;, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T*&amp;, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T*&amp;, T*,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T*&amp;, T*,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T*&amp;, T*,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T*&amp;, T*,
                                 memory_order = memory_order_seq_cst) noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;

    atomic() noexcept = default;
    constexpr atomic(T*) noexcept;
    atomic(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) = delete;
    atomic&amp; operator=(const atomic&amp;) volatile = delete;
    T* operator=(T*) volatile noexcept;
    T* operator=(T*) noexcept;
    T* operator++(int) volatile noexcept;
    T* operator++(int) noexcept;
    T* operator--(int) volatile noexcept;
    T* operator--(int) noexcept;
    T* operator++() volatile noexcept;
    T* operator++() noexcept;
    T* operator--() volatile noexcept;
    T* operator--() noexcept;
    T* operator+=(ptrdiff_t) volatile noexcept;
    T* operator+=(ptrdiff_t) noexcept;
    T* operator-=(ptrdiff_t) volatile noexcept;
    T* operator-=(ptrdiff_t) noexcept;
};
}}

====Class {{lc|std::atomic_flag}}====
{{source|1=
typedef struct atomic_flag {
    bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept;
    bool test_and_set(memory_order = memory_order_seq_cst) noexcept;
    void clear(memory_order = memory_order_seq_cst) volatile noexcept;
    void clear(memory_order = memory_order_seq_cst) noexcept;
    atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&amp;) = delete;
    atomic_flag&amp; operator=(const atomic_flag&amp;) = delete;
    atomic_flag&amp; operator=(const atomic_flag&amp;) volatile = delete;
} atomic_flag;
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/bitset</title>
    <ns>0</ns>
    <id>9745</id>
    <revision>
      <id>69984</id>
      <parentid>57430</parentid>
      <timestamp>2014-05-04T19:28:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix apostrophe characters</comment>
      <text xml:space="preserve" bytes="4317">{{cpp/header/title|bitset}}
{{cpp/header/navbar}}
This header is part of the [[cpp/utility|general utility]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|string}}}}
{{dsc|{{header|iosfwd}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/utility/dsc bitset}}
{{dsc inc | cpp/utility/bitset/dsc hash}}
{{dsc h1|Functions}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic2}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt2}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;string&gt;
#include &lt;iosfwd&gt; // for istream, ostream

namespace std {
    template &lt;size_t N&gt; class bitset;
    
    // bitset operators:
    template &lt;size_t N&gt;
        bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
    template &lt;size_t N&gt;
        bitset&lt;N&gt; operator{{!}}(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
    template &lt;size_t N&gt;
        bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;) noexcept;
    template &lt;class charT, class traits, size_t N&gt;
        basic_istream&lt;charT, traits&gt;&amp;
        operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);
    template &lt;class charT, class traits, size_t N&gt;
        basic_ostream&lt;charT, traits&gt;&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);
    
    // Hash support
    template &lt;class T&gt; struct hash;
    template &lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt; &gt;;

}


}}


====Class {{lc|std::bitset}}====
{{source|

template&lt;size_t N&gt; class bitset {
public:
    // bit reference:
    class reference {
        friend class bitset;
        reference() noexcept;
    public:
        ~reference() noexcept;
        reference&amp; operator{{=}}(bool x) noexcept;          //  for b[i] {{=}} x;
        reference&amp; operator{{=}}(const reference&amp;) noexcept;//  for b[i] {{=}} b[j];
        bool operator~() const noexcept;                //  flips the bit
        operator bool() const noexcept;                 //  for x {{=}} b[i];
        reference&amp; flip() noexcept;                     //  for b[i].flip();

    };

    //constructors:
    constexpr bitset() noexcept;
    constexpr bitset(unsigned long long val) noexcept;
    template&lt;class charT, class traits, class Allocator&gt;
        explicit bitset(
            const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
            typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos {{=}} 0,
            typename basic_string&lt;charT,traits,Allocator&gt;::size_type n {{=}}
                basic_string&lt;charT,traits,Allocator&gt;::npos,
            charT zero {{=}} charT('0'), charT one {{=}} charT('1'));
    template &lt;class charT&gt;
        explicit bitset(
            const charT* str,
            typename basic_string&lt;charT&gt;::size_type n {{=}} basic_string&lt;charT&gt;::npos,
            charT zero {{=}} charT('0'), charT one {{=}} charT('1'));
        
    // bitset operations:
    bitset&lt;N&gt;&amp; operator&amp;{{=}}(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator{{!=}}(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator^{{=}}(const bitset&lt;N&gt;&amp; rhs) noexcept;
    bitset&lt;N&gt;&amp; operator&lt;&lt;{{=}}(size_t pos) noexcept;
    bitset&lt;N&gt;&amp; operator&gt;&gt;{{=}}(size_t pos) noexcept;
    bitset&lt;N&gt;&amp; set() noexcept;
    bitset&lt;N&gt;&amp; set(size_t pos, bool val {{=}} true);
    bitset&lt;N&gt;&amp; reset() noexcept;
    bitset&lt;N&gt;&amp; reset(size_t pos);
    bitset&lt;N&gt; operator~() const noexcept;
    bitset&lt;N&gt;&amp; flip() noexcept;
    bitset&lt;N&gt;&amp; flip(size_t pos);
    
    // element access:
    constexpr bool operator[](size_t pos) const; // for b[i];
    reference operator[](size_t pos); // for b[i];
    
    
    unsigned long to_ulong() const;
    unsigned long long to_ullong() const;
    template &lt;class charT {{=}} char,
            class traits {{=}} char_traits&lt;charT&gt;,
            class Allocator {{=}} allocator&lt;charT&gt; &gt;
        basic_string&lt;charT, traits, Allocator&gt;
        to_string(charT zero {{=}} charT('0'), charT one {{=}} charT('1')) const;
        
    size_t count() const noexcept;
    constexpr size_t size() noexcept;
    
    bool operator{{==}}(const bitset&lt;N&gt;&amp; rhs) const noexcept;
    bool operator!{{=}}(const bitset&lt;N&gt;&amp; rhs) const noexcept;
    
    bool test(size_t pos) const;
    bool all() const noexcept;
    bool any() const noexcept;
    bool none() const noexcept;
    
    bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const noexcept;
    bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const noexcept;
};


}}</text>
      <sha1>rpb7puh763f33z41z1zkqo2pdesenah</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cassert</title>
    <ns>0</ns>
    <id>9688</id>
    <revision>
      <id>57433</id>
      <parentid>49541</parentid>
      <timestamp>2013-06-01T05:53:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="207">{{cpp/header/title|cassert}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/error|error handling]] library.
===Macros===
{{dsc begin}}
{{dsc inc | cpp/error/dsc assert}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ccomplex</title>
    <ns>0</ns>
    <id>9791</id>
    <revision>
      <id>49542</id>
      <parentid>45523</parentid>
      <timestamp>2013-06-01T02:44:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="137">{{cpp/header/title|ccomplex}}
{{cpp/header/navbar}}
{{cpp/header/c}}

===Includes===
{{dsc begin}}
{{dsc|{{header|complex}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cctype</title>
    <ns>0</ns>
    <id>9686</id>
    <revision>
      <id>57434</id>
      <parentid>49543</parentid>
      <timestamp>2013-06-01T05:53:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="791">{{cpp/header/title|cctype}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/string/byte|null-terminated byte strings]] library.

{{dsc begin}}
{{dsc h1 | Functions}}
{{dsc inc | cpp/string/byte/dsc isalnum}}
{{dsc inc | cpp/string/byte/dsc isalpha}}
{{dsc inc | cpp/string/byte/dsc islower}}
{{dsc inc | cpp/string/byte/dsc isupper}}
{{dsc inc | cpp/string/byte/dsc isdigit}}
{{dsc inc | cpp/string/byte/dsc isxdigit}}
{{dsc inc | cpp/string/byte/dsc iscntrl}}
{{dsc inc | cpp/string/byte/dsc isgraph}}
{{dsc inc | cpp/string/byte/dsc isspace}}
{{dsc inc | cpp/string/byte/dsc isblank}}
{{dsc inc | cpp/string/byte/dsc isprint}}
{{dsc inc | cpp/string/byte/dsc ispunct}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cerrno</title>
    <ns>0</ns>
    <id>9689</id>
    <revision>
      <id>57437</id>
      <parentid>49544</parentid>
      <timestamp>2013-06-01T05:53:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="7949">{{cpp/header/title|cerrno}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/error|error handling]] library.

===Macros===
{{dsc begin}}
{{dsc inc | cpp/error/dsc errno}}
{{dsc macro const | E2BIG            | nolink=true| notes={{mark c++11}}| Argument list too long }}
{{dsc macro const | EACCES           | nolink=true| notes={{mark c++11}}| Permission denied}}
{{dsc macro const | EADDRINUSE       | nolink=true| notes={{mark c++11}}| Address in use}}
{{dsc macro const | EADDRNOTAVAIL    | nolink=true| notes={{mark c++11}}| Address not available}}
{{dsc macro const | EAFNOSUPPORT     | nolink=true| notes={{mark c++11}}| Address family not supported}}
{{dsc macro const | EAGAIN           | nolink=true| notes={{mark c++11}}| Resource unavailable, try again}}
{{dsc macro const | EALREADY         | nolink=true| notes={{mark c++11}}| Connection already in progress}}
{{dsc macro const | EBADF            | nolink=true| notes={{mark c++11}}| Bad file descriptor}}
{{dsc macro const | EBADMSG          | nolink=true| notes={{mark c++11}}| Bad message}}
{{dsc macro const | EBUSY            | nolink=true| notes={{mark c++11}}| Device or resource busy}}
{{dsc macro const | ECANCELED        | nolink=true| notes={{mark c++11}}| Operation canceled}}
{{dsc macro const | ECHILD           | nolink=true| notes={{mark c++11}}| No child processes}}
{{dsc macro const | ECONNABORTED     | nolink=true| notes={{mark c++11}}| Connection aborted}}
{{dsc macro const | ECONNREFUSED     | nolink=true| notes={{mark c++11}}| Connection refused}}
{{dsc macro const | ECONNRESET       | nolink=true| notes={{mark c++11}}| Connection reset}}
{{dsc macro const | EDEADLK          | nolink=true| notes={{mark c++11}}| Resource deadlock would occur}}
{{dsc macro const | EDESTADDRREQ     | nolink=true| notes={{mark c++11}}| Destination address required}}
{{dsc macro const | EDOM             | nolink=true                      | Mathematics argument out of domain of function}}
{{dsc macro const | EEXIST           | nolink=true| notes={{mark c++11}}| File exists}}
{{dsc macro const | EFAULT           | nolink=true| notes={{mark c++11}}| Bad address}}
{{dsc macro const | EFBIG            | nolink=true| notes={{mark c++11}}| File too large}}
{{dsc macro const | EHOSTUNREACH     | nolink=true| notes={{mark c++11}}| Host is unreachable}}
{{dsc macro const | EIDRM            | nolink=true| notes={{mark c++11}}| Identifier removed}}
{{dsc macro const | EILSEQ           | nolink=true| notes={{mark c++11}}| Illegal byte sequence}}
{{dsc macro const | EINPROGRESS      | nolink=true| notes={{mark c++11}}| Operation in progress}}
{{dsc macro const | EINTR            | nolink=true| notes={{mark c++11}}| Interrupted function}}
{{dsc macro const | EINVAL           | nolink=true| notes={{mark c++11}}| Invalid argument}}
{{dsc macro const | EIO              | nolink=true| notes={{mark c++11}}| I/O error}}
{{dsc macro const | EISCONN          | nolink=true| notes={{mark c++11}}| Socket is connected}}
{{dsc macro const | EISDIR           | nolink=true| notes={{mark c++11}}| Is a directory}}
{{dsc macro const | ELOOP            | nolink=true| notes={{mark c++11}}| Too many levels of symbolic links}}
{{dsc macro const | EMFILE           | nolink=true| notes={{mark c++11}}| File descriptor value too large}}
{{dsc macro const | EMLINK           | nolink=true| notes={{mark c++11}}| Too many links}}
{{dsc macro const | EMSGSIZE         | nolink=true| notes={{mark c++11}}| Message too large}}
{{dsc macro const | ENAMETOOLONG     | nolink=true| notes={{mark c++11}}| Filename too long}}
{{dsc macro const | ENETDOWN         | nolink=true| notes={{mark c++11}}| Network is down}}
{{dsc macro const | ENETRESET        | nolink=true| notes={{mark c++11}}| Connection aborted by network}}
{{dsc macro const | ENETUNREACH      | nolink=true| notes={{mark c++11}}| Network unreachable}}
{{dsc macro const | ENFILE           | nolink=true| notes={{mark c++11}}| Too many files open in system}}
{{dsc macro const | ENOBUFS          | nolink=true| notes={{mark c++11}}| No buffer space available}}
{{dsc macro const | ENODATA          | nolink=true| notes={{mark c++11}}| No message is available on the STREAM head read queue}}
{{dsc macro const | ENODEV           | nolink=true| notes={{mark c++11}}| No such device}}
{{dsc macro const | ENOENT           | nolink=true| notes={{mark c++11}}| No such file or directory}}
{{dsc macro const | ENOEXEC          | nolink=true| notes={{mark c++11}}| Executable file format error}}
{{dsc macro const | ENOLCK           | nolink=true| notes={{mark c++11}}| No locks available}}
{{dsc macro const | ENOLINK          | nolink=true| notes={{mark c++11}}| Link has been severed}}
{{dsc macro const | ENOMEM           | nolink=true| notes={{mark c++11}}| Not enough space}}
{{dsc macro const | ENOMSG           | nolink=true| notes={{mark c++11}}| No message of the desired type}}
{{dsc macro const | ENOPROTOOPT      | nolink=true| notes={{mark c++11}}| Protocol not available}}
{{dsc macro const | ENOSPC           | nolink=true| notes={{mark c++11}}| No space left on device}}
{{dsc macro const | ENOSR            | nolink=true| notes={{mark c++11}}| No STREAM resources}}
{{dsc macro const | ENOSTR           | nolink=true| notes={{mark c++11}}| Not a STREAM}}
{{dsc macro const | ENOSYS           | nolink=true| notes={{mark c++11}}| Function not supported}}
{{dsc macro const | ENOTCONN         | nolink=true| notes={{mark c++11}}| The socket is not connected}}
{{dsc macro const | ENOTDIR          | nolink=true| notes={{mark c++11}}| Not a directory}}
{{dsc macro const | ENOTEMPTY        | nolink=true| notes={{mark c++11}}| Directory not empty}}
{{dsc macro const | ENOTRECOVERABLE  | nolink=true| notes={{mark c++11}}| State not recoverable}}
{{dsc macro const | ENOTSOCK         | nolink=true| notes={{mark c++11}}| Not a socket}}
{{dsc macro const | ENOTSUP          | nolink=true| notes={{mark c++11}}| Not supported}}
{{dsc macro const | ENOTTY           | nolink=true| notes={{mark c++11}}| Inappropriate I/O control operation}}
{{dsc macro const | ENXIO            | nolink=true| notes={{mark c++11}}| No such device or address}}
{{dsc macro const | EOPNOTSUPP       | nolink=true| notes={{mark c++11}}| Operation not supported on socket}}
{{dsc macro const | EOVERFLOW        | nolink=true| notes={{mark c++11}}| Value too large to be stored in data type}}
{{dsc macro const | EOWNERDEAD       | nolink=true| notes={{mark c++11}}| Previous owner died}}
{{dsc macro const | EPERM            | nolink=true| notes={{mark c++11}}| Operation not permitted}}
{{dsc macro const | EPIPE            | nolink=true| notes={{mark c++11}}| Broken pipe}}
{{dsc macro const | EPROTO           | nolink=true| notes={{mark c++11}}| Protocol error}}
{{dsc macro const | EPROTONOSUPPORT  | nolink=true| notes={{mark c++11}}| Protocol not supported}}
{{dsc macro const | EPROTOTYPE       | nolink=true| notes={{mark c++11}}| Protocol wrong type for socket}}
{{dsc macro const | ERANGE           | nolink=true|                       Result too large}}
{{dsc macro const | EROFS            | nolink=true| notes={{mark c++11}}| Read-only file system}}
{{dsc macro const | ESPIPE           | nolink=true| notes={{mark c++11}}| Invalid seek}}
{{dsc macro const | ESRCH            | nolink=true| notes={{mark c++11}}| No such process}}
{{dsc macro const | ETIME            | nolink=true| notes={{mark c++11}}| Stream ioctl() timeout}}
{{dsc macro const | ETIMEDOUT        | nolink=true| notes={{mark c++11}}| Connection timed out}}
{{dsc macro const | ETXTBSY          | nolink=true| notes={{mark c++11}}| Text file busy}}
{{dsc macro const | EWOULDBLOCK      | nolink=true| notes={{mark c++11}}| Operation would block}}
{{dsc macro const | EXDEV            | nolink=true| notes={{mark c++11}}| Cross-device link}}
{{dsc end}}


===See Also===
* [[cpp/error/errno_macros|Description for the error number values]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cfenv</title>
    <ns>0</ns>
    <id>9773</id>
    <revision>
      <id>57440</id>
      <parentid>49545</parentid>
      <timestamp>2013-06-01T05:53:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1552">{{cpp/header/title|cfenv}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/numeric/fenv|floating-point environment]] library.


===Types===
{{dsc begin}}
{{dsc | {{c|fenv_t}}  | The type representing the entire floating-point environment }}
{{dsc | {{c|fexcept_t}} | The type representing all floating-point status flags collectively }}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feclearexcept}}
{{dsc inc | cpp/numeric/fenv/dsc fetestexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feraiseexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feexceptflag}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc inc | cpp/numeric/fenv/dsc feenv}}
{{dsc inc | cpp/numeric/fenv/dsc feholdexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feupdateenv}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc FE_exceptions}}
{{dsc inc | cpp/numeric/fenv/dsc FE_round}}
{{dsc inc | cpp/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    // types
    typedef /*object type*/ fenv_t;
    typedef /*integer type*/ fexcept_t;
    
    // functions
    int feclearexcept(int except);
    int fegetexceptflag(fexcept_t *pflag, int except);
    int feraiseexcept(int except);
    int fesetexceptflag(const fexcept_t *pflag, int except);
    int fetestexcept(int except);
    int fegetround(void);
    int fesetround(int mode);
    int fegetenv(fenv_t *penv);
    int feholdexcept(fenv_t *penv);
    int fesetenv(const fenv_t *penv);
    int feupdateenv(const fenv_t *penv);
}


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cfloat</title>
    <ns>0</ns>
    <id>9664</id>
    <revision>
      <id>49546</id>
      <parentid>45305</parentid>
      <timestamp>2013-06-01T02:44:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2782">{{cpp/header/title|cfloat}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/types|type support]] library, in particular it's part of the [[cpp/types/climits|C numeric limits interface]].

===Macros===
{{dsc begin}}
{{dsc macro const | FLT_RADIX | the radix (integer base) used by the representation of all three floating-point types | nolink=true }}
{{dsc macro const | DECIMAL_DIG | number of decimal digits that can be converted to {{c|long double}} and back without losing precision | nolink=true | notes={{mark c++11}}}}
{{dsc macro const | FLT_MIN&lt;br&gt;DBL_MIN&lt;br&gt;LDBL_MIN | minimum value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX&lt;br&gt;DBL_MAX&lt;br&gt;LDBL_MAX | maximum value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_EPSILON&lt;br&gt;DBL_EPSILON&lt;br&gt;LDBL_EPSILON | difference between {{c|1.0}} and the next representable value for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_DIG&lt;br&gt;DBL_DIG&lt;br&gt;LDBL_DIG | number of decimal digits that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MANT_DIG&lt;br&gt;DBL_MANT_DIG&lt;br&gt;LDBL_MANT_DIG | number of base {{tt|FLT_RADIX}} digits that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_EXP&lt;br&gt;DBL_MIN_EXP&lt;br&gt;LDBL_MIN_EXP | minimum negative integer such that {{tt|FLT_RADIX}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_10_EXP&lt;br&gt;DBL_MIN_10_EXP&lt;br&gt;LDBL_MIN_10_EXP | minimum negative integer such that {{c|10}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_EXP&lt;br&gt;DBL_MAX_EXP&lt;br&gt;LDBL_MAX_EXP | maximum positive integer such that {{tt|FLT_RADIX}} raised by power one more than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_10_EXP&lt;br&gt;DBL_MAX_10_EXP&lt;br&gt;LDBL_MAX_10_EXP | maximum positive integer such that {{c|10}} raised by power one more than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | cpp/types/climits/FLT_ROUNDS | default rounding mode of floating-point arithmetics }}
{{dsc macro const | cpp/types/climits/FLT_EVAL_METHOD | specifies in what precision all arithmetic operations are done | notes={{mark c++11}} }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/chrono</title>
    <ns>0</ns>
    <id>9807</id>
    <revision>
      <id>67019</id>
      <parentid>57441</parentid>
      <timestamp>2014-01-18T02:39:17Z</timestamp>
      <contributor>
        <ip>24.7.115.185</ip>
      </contributor>
      <comment>Fix a typo</comment>
      <text xml:space="preserve" bytes="9166">{{cpp/header/title|chrono}}
{{cpp/header/navbar}}

This header is part of the [[cpp/chrono|date and time]] library.

===Classes===
{{dsc begin}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/dsc duration}}
{{dsc inc | cpp/chrono/dsc system_clock}}
{{dsc inc | cpp/chrono/dsc steady_clock}}
{{dsc inc | cpp/chrono/dsc high_resolution_clock}}
{{dsc inc | cpp/chrono/dsc time_point}}
{{dsc tclass | cpp/chrono/treat_as_floating_point | indicates that a duration is convertible to duration with different tick period }}
{{dsc tclass | cpp/chrono/duration_values | constructs zero, min, and max values of a tick count of given type}}

{{dsc h2|Convenience Typedefs}}
{{dsc namespace | std::chrono}}
{{dsc | {{lc|std::chrono::nanoseconds}} | duration type with Period {{lc|std::nano}} }}
{{dsc | {{lc|std::chrono::microseconds}} | duration type with Period {{lc|std::micro}} }}
{{dsc | {{lc|std::chrono::milliseconds}} | duration type with Period {{lc|std::milli}} }}
{{dsc | {{lc|std::chrono::seconds}} | duration type with Period {{c|std::ratio&lt;1&gt;}} }}
{{dsc | {{lc|std::chrono::minutes}} | duration type with Period {{c|std::ratio&lt;60&gt;}} }}
{{dsc | {{lc|std::chrono::hours}} | duration type with Period {{c|std::ratio&lt;3600&gt;}} }}

{{dsc h2|Specializations}}
{{dsc namespace | std}}
{{dsc inc | cpp/chrono/duration/dsc common_type}}
{{dsc inc | cpp/chrono/time_point/dsc common_type}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2|Duration}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4}}
{{dsc inc | cpp/chrono/duration/dsc operator_cmp}}
{{dsc inc | cpp/chrono/duration/dsc duration_cast }}

{{dsc h2|Time point}}
{{dsc namespace | std::chrono}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith2}}
{{dsc inc | cpp/chrono/time_point/dsc operator_cmp}}
{{dsc inc | cpp/chrono/time_point/dsc time_point_cast}}
{{dsc end}}


===Synopsis===
{{source|

namespace std {
namespace chrono {
        
    // class template duration
    template &lt;class Rep, class Period {{=}} ratio&lt;1&gt; &gt; class duration;

    // class template time_point
    template &lt;class Clock, class Duration {{=}} typename Clock::duration&gt; class time_point;
        
} // namespace chrono
    
// common_type specializations
template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
    struct common_type&lt;chrono::duration&lt;Rep1, Period1&gt;, chrono::duration&lt;Rep2, Period2&gt;&gt;;

template &lt;class Clock, class Duration1, class Duration2&gt;
    struct common_type&lt;chrono::time_point&lt;Clock, Duration1&gt;, chrono::time_point&lt;Clock, Duration2&gt;&gt;;
    
namespace chrono {
        
    // customization traits
    template &lt;class Rep&gt; struct treat_as_floating_point;
    template &lt;class Rep&gt; struct duration_values;
        
    // duration arithmetic
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
        constexpr operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
        constexpr operator-(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period, class Rep2&gt;
        duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
        constexpr operator*(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template &lt;class Rep1, class Rep2, class Period&gt;
        duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
        constexpr operator*(const Rep1&amp; s, const duration&lt;Rep2, Period&gt;&amp; d);
    template &lt;class Rep1, class Period, class Rep2&gt;
        duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
        constexpr operator/(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        typename common_type&lt;Rep1, Rep2&gt;::type
        constexpr operator/(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period, class Rep2&gt;
        duration&lt;typename common_type&lt;Rep1, Rep2&gt;::type, Period&gt;
        constexpr operator%(const duration&lt;Rep1, Period&gt;&amp; d, const Rep2&amp; s);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        typename common_type&lt;duration&lt;Rep1, Period1&gt;, duration&lt;Rep2, Period2&gt;&gt;::type
        constexpr operator%(const duration&lt;Rep1, Period1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    
    // duration comparisons
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator{{=}}{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator!{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator&lt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator&lt;{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator&gt; (const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Rep2, class Period2&gt;
        constexpr bool operator&gt;{{=}}(const duration&lt;Rep1, Period1&gt;&amp; lhs,
                                    const duration&lt;Rep2, Period2&gt;&amp; rhs);
    
    // duration_cast 
    template &lt;class ToDuration, class Rep, class Period&gt; 
        constexpr ToDuration duration_cast(const duration&lt;Rep, Period&gt;&amp; d); 
    
    // convenience typedefs 
    typedef duration&lt;/*signed integer type of at least 64 bits*/, nano&gt;        nanoseconds;
    typedef duration&lt;/*signed integer type of at least 55 bits*/, micro&gt;       microseconds;
    typedef duration&lt;/*signed integer type of at least 45 bits*/, milli&gt;       milliseconds;
    typedef duration&lt;/*signed integer type of at least 35 bits*/ &gt;             seconds;
    typedef duration&lt;/*signed integer type of at least 29 bits*/, ratio&lt; 60&gt;&gt;  minutes; 
    typedef duration&lt;/*signed integer type of at least 23 bits*/, ratio&lt;3600&gt;&gt; hours; 
    
    // time_point arithmetic
    template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
        time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
        operator+(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Rep1, class Period1, class Clock, class Duration2&gt;
        time_point&lt;Clock, typename common_type&lt;duration&lt;Rep1, Period1&gt;, Duration2&gt;::type&gt;
        operator+(const duration&lt;Rep1, Period1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Rep2, class Period2&gt;
        time_point&lt;Clock, typename common_type&lt;Duration1, duration&lt;Rep2, Period2&gt;&gt;::type&gt;
        operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const duration&lt;Rep2, Period2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        typename common_type&lt;Duration1, Duration2&gt;::type
        operator-(const time_point&lt;Clock, Duration1&gt;&amp; lhs, const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    
    // time_point comparisons
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator{{=}}{{=}}(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator!{{=}}(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator&lt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator&lt;{{=}}(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator&gt; (const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    template &lt;class Clock, class Duration1, class Duration2&gt;
        bool operator&gt;{{=}}(const time_point&lt;Clock, Duration1&gt;&amp; lhs,
                        const time_point&lt;Clock, Duration2&gt;&amp; rhs);
    
    // time_point_cast
    template &lt;class ToDuration, class Clock, class Duration&gt;
        time_point&lt;Clock, ToDuration&gt; time_point_cast(const time_point&lt;Clock, Duration&gt;&amp; t);
    
    // clocks
    class system_clock;
    class steady_clock;
    class high_resolution_clock;
    
} // namespace chrono
}// namespace std
    
    
    
}}

{{todo|Class synopses}}</text>
      <sha1>8cqp7sxfytpyog349xfbqqpdo2zuadk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cinttypes</title>
    <ns>0</ns>
    <id>9789</id>
    <revision>
      <id>71908</id>
      <parentid>57444</parentid>
      <timestamp>2014-07-01T19:04:34Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>Use new templates</comment>
      <text xml:space="preserve" bytes="9298">{{cpp/header/title|cinttypes}}
{{cpp/header/navbar}}
{{cpp/header/c}}

Provides conversions from C [[cpp/string/byte|byte]] and [[cpp/string/wide|wide]] strings to {{lc|std::intmax_t}} and {{lc|std::uintmax_t}}, overloads some [[cpp/numeric/math|math functions]] for {{lc|std::intmax_t}} and provide [[cpp/io/c|C style input/output]] format macros for the types declared in {{header|cstdint}}.

===Includes===
{{dsc begin}}
{{dsc|{{header|cstdint}}}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc imaxdiv_t}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc imaxabs}}
{{dsc inc | cpp/numeric/math/dsc imaxdiv}}
{{dsc inc | cpp/string/byte/dsc strtoimax}}
{{dsc inc | cpp/string/wide/dsc wcstoimax}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc h2 | Format constants for the {{lc|std::fprintf}} family of functions}}
{{dsc macro const | PRId8&lt;br&gt;PRId16&lt;br&gt;PRId32&lt;br&gt;PRId64&lt;br&gt;PRIdLEAST8&lt;br&gt;PRIdLEAST16&lt;br&gt;PRIdLEAST32&lt;br&gt;PRIdLEAST64&lt;br&gt;PRIdFAST8&lt;br&gt;PRIdFAST16&lt;br&gt;PRIdFAST32&lt;br&gt;PRIdFAST64&lt;br&gt;PRIdMAX&lt;br&gt;PRIdPTR | format conversion specifier to output a signed decimal integer value of type {{lc|std::int8_t}}, {{lc|std::int16_t}}, {{lc|std::int32_t}}, {{lc|std::int64_t}}, {{lc|std::int_least8_t}}, {{lc|std::int_least16_t}}, {{lc|std::int_least32_t}}, {{lc|std::int_least64_t}}, {{lc|std::int_fast8_t}}, {{lc|std::int_fast16_t}}, {{lc|std::int_fast32_t}}, {{lc|std::int_fast64_t}}, {{c|std:intmax_t}}, {{lc|std::intptr_t}} respectively, equivalent to {{tt|%d}} for {{c|int}} | nolink=true }}
{{dsc macro const | PRIi8&lt;br&gt;PRIi16&lt;br&gt;PRIi32&lt;br&gt;PRIi64&lt;br&gt;PRIiLEAST8&lt;br&gt;PRIiLEAST16&lt;br&gt;PRIiLEAST32&lt;br&gt;PRIiLEAST64&lt;br&gt;PRIiFAST8&lt;br&gt;PRIiFAST16&lt;br&gt;PRIiFAST32&lt;br&gt;PRIiFAST64&lt;br&gt;PRIiMAX&lt;br&gt;PRIiPTR | format conversion specifier to output a signed decimal integer value of type {{lc|std::int8_t}}, {{lc|std::int16_t}}, {{lc|std::int32_t}}, {{lc|std::int64_t}}, {{lc|std::int_least8_t}}, {{lc|std::int_least16_t}}, {{lc|std::int_least32_t}}, {{lc|std::int_least64_t}}, {{lc|std::int_fast8_t}}, {{lc|std::int_fast16_t}}, {{lc|std::int_fast32_t}}, {{lc|std::int_fast64_t}}, {{c|std:intmax_t}}, {{lc|std::intptr_t}} respectively, equivalent to {{tt|%i}} for {{c|int}} | nolink=true }}
{{dsc macro const | PRIu8&lt;br&gt;PRIu16&lt;br&gt;PRIu32&lt;br&gt;PRIu64&lt;br&gt;PRIuLEAST8&lt;br&gt;PRIuLEAST16&lt;br&gt;PRIuLEAST32&lt;br&gt;PRIuLEAST64&lt;br&gt;PRIuFAST8&lt;br&gt;PRIuFAST16&lt;br&gt;PRIuFAST32&lt;br&gt;PRIuFAST64&lt;br&gt;PRIuMAX&lt;br&gt;PRIuPTR | format conversion specifier to output an unsigned decimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%u}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIo8&lt;br&gt;PRIo16&lt;br&gt;PRIo32&lt;br&gt;PRIo64&lt;br&gt;PRIoLEAST8&lt;br&gt;PRIoLEAST16&lt;br&gt;PRIoLEAST32&lt;br&gt;PRIoLEAST64&lt;br&gt;PRIoFAST8&lt;br&gt;PRIoFAST16&lt;br&gt;PRIoFAST32&lt;br&gt;PRIoFAST64&lt;br&gt;PRIoMAX&lt;br&gt;PRIoPTR | format conversion specifier to output an unsigned octal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%o}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIx8&lt;br&gt;PRIx16&lt;br&gt;PRIx32&lt;br&gt;PRIx64&lt;br&gt;PRIxLEAST8&lt;br&gt;PRIxLEAST16&lt;br&gt;PRIxLEAST32&lt;br&gt;PRIxLEAST64&lt;br&gt;PRIxFAST8&lt;br&gt;PRIxFAST16&lt;br&gt;PRIxFAST32&lt;br&gt;PRIxFAST64&lt;br&gt;PRIxMAX&lt;br&gt;PRIxPTR | format conversion specifier to output an unsigned hexadecimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%x}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | PRIX8&lt;br&gt;PRIX16&lt;br&gt;PRIX32&lt;br&gt;PRIX64&lt;br&gt;PRIXLEAST8&lt;br&gt;PRIXLEAST16&lt;br&gt;PRIXLEAST32&lt;br&gt;PRIXLEAST64&lt;br&gt;PRIXFAST8&lt;br&gt;PRIXFAST16&lt;br&gt;PRIXFAST32&lt;br&gt;PRIXFAST64&lt;br&gt;PRIXMAX&lt;br&gt;PRIXPTR | format conversion specifier to output an unsigned uppercase hexadecimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%X}} for {{c|unsigned int}} | nolink=true }}
{{dsc h2 | Format constants for the {{lc|std::fscanf}} family of functions}}
{{dsc macro const | SCNd8&lt;br&gt;SCNd16&lt;br&gt;SCNd32&lt;br&gt;SCNd64&lt;br&gt;SCNdLEAST8&lt;br&gt;SCNdLEAST16&lt;br&gt;SCNdLEAST32&lt;br&gt;SCNdLEAST64&lt;br&gt;SCNdFAST8&lt;br&gt;SCNdFAST16&lt;br&gt;SCNdFAST32&lt;br&gt;SCNdFAST64&lt;br&gt;SCNdMAX&lt;br&gt;SCNdPTR | format conversion specifier to input a signed decimal integer value of type {{lc|std::int8_t}}, {{lc|std::int16_t}}, {{lc|std::int32_t}}, {{lc|std::int64_t}}, {{lc|std::int_least8_t}}, {{lc|std::int_least16_t}}, {{lc|std::int_least32_t}}, {{lc|std::int_least64_t}}, {{lc|std::int_fast8_t}}, {{lc|std::int_fast16_t}}, {{lc|std::int_fast32_t}}, {{lc|std::int_fast64_t}}, {{c|std:intmax_t}}, {{lc|std::intptr_t}} respectively, equivalent to {{tt|%d}} for {{c|int}} | nolink=true }}
{{dsc macro const | SCNi8&lt;br&gt;SCNi16&lt;br&gt;SCNi32&lt;br&gt;SCNi64&lt;br&gt;SCNiLEAST8&lt;br&gt;SCNiLEAST16&lt;br&gt;SCNiLEAST32&lt;br&gt;SCNiLEAST64&lt;br&gt;SCNiFAST8&lt;br&gt;SCNiFAST16&lt;br&gt;SCNiFAST32&lt;br&gt;SCNiFAST64&lt;br&gt;SCNiMAX&lt;br&gt;SCNiPTR | format conversion specifier to input a signed decimal/octal/hexadecimal integer value of type {{lc|std::int8_t}}, {{lc|std::int16_t}}, {{lc|std::int32_t}}, {{lc|std::int64_t}}, {{lc|std::int_least8_t}}, {{lc|std::int_least16_t}}, {{lc|std::int_least32_t}}, {{lc|std::int_least64_t}}, {{lc|std::int_fast8_t}}, {{lc|std::int_fast16_t}}, {{lc|std::int_fast32_t}}, {{lc|std::int_fast64_t}}, {{c|std:intmax_t}}, {{lc|std::intptr_t}} respectively, equivalent to {{tt|%i}} for {{c|int}} | nolink=true }}
{{dsc macro const | SCNu8&lt;br&gt;SCNu16&lt;br&gt;SCNu32&lt;br&gt;SCNu64&lt;br&gt;SCNuLEAST8&lt;br&gt;SCNuLEAST16&lt;br&gt;SCNuLEAST32&lt;br&gt;SCNuLEAST64&lt;br&gt;SCNuFAST8&lt;br&gt;SCNuFAST16&lt;br&gt;SCNuFAST32&lt;br&gt;SCNuFAST64&lt;br&gt;SCNuMAX&lt;br&gt;SCNuPTR | format conversion specifier to input an unsigned decimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%u}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNo8&lt;br&gt;SCNo16&lt;br&gt;SCNo32&lt;br&gt;SCNo64&lt;br&gt;SCNoLEAST8&lt;br&gt;SCNoLEAST16&lt;br&gt;SCNoLEAST32&lt;br&gt;SCNoLEAST64&lt;br&gt;SCNoFAST8&lt;br&gt;SCNoFAST16&lt;br&gt;SCNoFAST32&lt;br&gt;SCNoFAST64&lt;br&gt;SCNoMAX&lt;br&gt;SCNoPTR | format conversion specifier to input an unsigned octal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%o}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNx8&lt;br&gt;SCNx16&lt;br&gt;SCNx32&lt;br&gt;SCNx64&lt;br&gt;SCNxLEAST8&lt;br&gt;SCNxLEAST16&lt;br&gt;SCNxLEAST32&lt;br&gt;SCNxLEAST64&lt;br&gt;SCNxFAST8&lt;br&gt;SCNxFAST16&lt;br&gt;SCNxFAST32&lt;br&gt;SCNxFAST64&lt;br&gt;SCNxMAX&lt;br&gt;SCNxPTR | format conversion specifier to input an unsigned hexadecimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%x}} for {{c|unsigned int}} | nolink=true }}
{{dsc macro const | SCNX8&lt;br&gt;SCNX16&lt;br&gt;SCNX32&lt;br&gt;SCNX64&lt;br&gt;SCNXLEAST8&lt;br&gt;SCNXLEAST16&lt;br&gt;SCNXLEAST32&lt;br&gt;SCNXLEAST64&lt;br&gt;SCNXFAST8&lt;br&gt;SCNXFAST16&lt;br&gt;SCNXFAST32&lt;br&gt;SCNXFAST64&lt;br&gt;SCNXMAX&lt;br&gt;SCNXPTR | format conversion specifier to input an unsigned uppercase hexadecimal integer value of type {{lc|std::uint8_t}}, {{lc|std::uint16_t}}, {{lc|std::uint32_t}}, {{lc|std::uint64_t}}, {{lc|std::uint_least8_t}}, {{lc|std::uint_least16_t}}, {{lc|std::uint_least32_t}}, {{lc|std::uint_least64_t}}, {{lc|std::uint_fast8_t}}, {{lc|std::uint_fast16_t}}, {{lc|std::uint_fast32_t}}, {{lc|std::uint_fast64_t}}, {{c|std:uintmax_t}}, {{lc|std::uintptr_t}} respectively, equivalent to {{tt|%X}} for {{c|unsigned int}} | nolink=true }}
{{dsc end}}</text>
      <sha1>9u8lwlqa5endqror3th7wzwnvn6z600</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ciso646</title>
    <ns>0</ns>
    <id>9682</id>
    <revision>
      <id>45307</id>
      <parentid>45035</parentid>
      <timestamp>2012-12-15T10:02:03Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>c</comment>
      <text xml:space="preserve" bytes="433">{{cpp/header/title|ciso646}}
{{cpp/header/navbar}}
{{cpp/header/c}}

Compatibility header, in C defines [[cpp/language/operator_alternative|alternative operator representations]] which are keywords in C++.

This means that in a conforming implementation this header is empty.

It may still be required in order to have the [[cpp/language/operator_alternative|alternative operator representations]] in old or non-conformant compilers.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/climits</title>
    <ns>0</ns>
    <id>9663</id>
    <revision>
      <id>49549</id>
      <parentid>45304</parentid>
      <timestamp>2013-06-01T02:44:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1336">{{cpp/header/title|climits}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/types|type support]] library, in particular it's part of the [[cpp/types/climits|C numeric limits interface]].

===Macros===
{{dsc begin}}
{{dsc macro const | CHAR_BIT | number of bits in byte | nolink=true }}
{{dsc macro const | MB_LEN_MAX | maximum number of bytes in a multibyte character | nolink=true }}
{{dsc macro const | CHAR_MIN | minimum value of {{c|char}} | nolink=true }}
{{dsc macro const | CHAR_MAX | maximum value of {{c|char}} | nolink=true }}
{{dsc macro const | SCHAR_MIN&lt;br&gt;SHRT_MIN&lt;br&gt;INT_MIN&lt;br&gt;LONG_MIN&lt;br&gt;LLONG_MIN | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | minimum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | SCHAR_MAX&lt;br&gt;SHRT_MAX&lt;br&gt;INT_MAX&lt;br&gt;LONG_MAX&lt;br&gt;LLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | maximum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | UCHAR_MAX&lt;br&gt;USHRT_MAX&lt;br&gt;UINT_MAX&lt;br&gt;ULONG_MAX&lt;br&gt;ULLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | maximum value of {{c|unsigned char}}, {{c|unsigned short}}, {{c|unsigned int}},&lt;br&gt;{{c|unsigned long}} and {{c|unsigned long long}} respectively}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/clocale</title>
    <ns>0</ns>
    <id>9748</id>
    <revision>
      <id>57445</id>
      <parentid>49550</parentid>
      <timestamp>2013-06-01T05:53:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="588">{{cpp/header/title|clocale}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/locale|localization]] library

{{dsc begin}}
{{dsc h1 | Types}}
{{dsc inc | cpp/locale/dsc lconv}}
{{dsc h1 | Constants}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc inc | cpp/locale/dsc LC_categories}}
{{dsc h1 | Functions}}
{{dsc inc | cpp/locale/dsc setlocale}}
{{dsc inc | cpp/locale/dsc localeconv}}
{{dsc end}}

===Notes===
* {{lc|NULL}} is also defined in the following headers:
** {{header|cstring}}
** {{header|ctime}}
** {{header|cstddef}}
** {{header|cstdio}}
** {{header|cwchar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cmath</title>
    <ns>0</ns>
    <id>9752</id>
    <revision>
      <id>71827</id>
      <parentid>71576</parentid>
      <timestamp>2014-06-25T20:44:06Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>tgamma first than lgamma</comment>
      <text xml:space="preserve" bytes="3577">{{cpp/header/title|cmath}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/numeric|numeric]] library.

===Macro constants===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc HUGE_VAL}}}
{{dsc inc | cpp/numeric/math/dsc INFINITY}}}
{{dsc inc | cpp/numeric/math/dsc NAN}}}
{{dsc inc | cpp/numeric/math/dsc math_errhandling}}
{{dsc h2 | Classification}}
{{dsc inc | cpp/numeric/math/dsc FP_categories}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc float_t}}
{{dsc inc | cpp/numeric/math/dsc double_t}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | Basic operations}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/math/dsc fmod}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc inc | cpp/numeric/math/dsc fma}}
{{dsc inc | cpp/numeric/math/dsc fmax}}
{{dsc inc | cpp/numeric/math/dsc fmin}}
{{dsc inc | cpp/numeric/math/dsc fdim}}
{{dsc inc | cpp/numeric/math/dsc fnan}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc exp2}}
{{dsc inc | cpp/numeric/math/dsc expm1}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc inc | cpp/numeric/math/dsc log1p}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc cbrt}}
{{dsc inc | cpp/numeric/math/dsc hypot}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc atan2}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}

{{dsc h2 | Error and gamma functions}}
{{dsc inc | cpp/numeric/math/dsc erf}}
{{dsc inc | cpp/numeric/math/dsc erfc}}
{{dsc inc | cpp/numeric/math/dsc tgamma}}
{{dsc inc | cpp/numeric/math/dsc lgamma}}

{{dsc h2 | Nearest integer floating point operations}}
{{dsc inc | cpp/numeric/math/dsc ceil}}
{{dsc inc | cpp/numeric/math/dsc floor}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
{{dsc inc | cpp/numeric/math/dsc rint}}

{{dsc h2 | Floating point manipulation functions}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc ldexp}}
{{dsc inc | cpp/numeric/math/dsc modf}}
{{dsc inc | cpp/numeric/math/dsc scalbn}}
{{dsc inc | cpp/numeric/math/dsc ilogb}}
{{dsc inc | cpp/numeric/math/dsc logb}}
{{dsc inc | cpp/numeric/math/dsc nextafter}}
{{dsc inc | cpp/numeric/math/dsc copysign}}

{{dsc h2 | Classification and comparison}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc inc | cpp/numeric/math/dsc signbit}}

{{dsc inc | cpp/numeric/math/dsc isgreater}}
{{dsc inc | cpp/numeric/math/dsc isgreaterequal}}
{{dsc inc | cpp/numeric/math/dsc isless}}
{{dsc inc | cpp/numeric/math/dsc islessequal}}
{{dsc inc | cpp/numeric/math/dsc islessgreater}}
{{dsc inc | cpp/numeric/math/dsc isunordered}}
{{dsc end}}</text>
      <sha1>st5vlz2g6yq29zcyld1gfu3bie7ud8l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/codectv</title>
    <ns>0</ns>
    <id>9772</id>
    <redirect title="cpp/header/codecvt" />
    <revision>
      <id>67854</id>
      <parentid>57451</parentid>
      <timestamp>2014-03-03T13:36:38Z</timestamp>
      <contributor>
        <ip>59.78.56.117</ip>
      </contributor>
      <comment>The header name should be &quot;codeCVT&quot;, not &quot;CTV&quot;.</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/header/codecvt]]</text>
      <sha1>rwqhk82dowl3z3ee6jur73r119ei9pf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/codecvt</title>
    <ns>0</ns>
    <id>12860</id>
    <revision>
      <id>64004</id>
      <parentid>64003</parentid>
      <timestamp>2013-08-06T03:43:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1895">{{cpp/header/title|codecvt}}
{{cpp/header/navbar}}
This header is part of the [[cpp/locale|Localization]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_mode}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    enum codecvt_mode {
        consume_header = 4,
        generate_header = 2,
        little_endian = 1
    };

    template&lt;class Elem,
             unsigned long Maxcode = 0x10ffff,
             codecvt_mode Mode = (codecvt_mode)0&gt;
    class codecvt_utf8;

    template&lt;class Elem,
             unsigned long Maxcode = 0x10ffff,
             codecvt_mode Mode = (codecvt_mode)0&gt;
    class codecvt_utf16;

    template&lt;class Elem,
             unsigned long Maxcode = 0x10ffff,
             codecvt_mode Mode = (codecvt_mode)0&gt;
    class codecvt_utf8_utf16;
}
}}

====Class {{lc|std::codecvt_utf8}}====
{{source|1=
template&lt; class Elem,
          unsigned long Maxcode = 0x10ffff,
          codecvt_mode Mode = (codecvt_mode)0 &gt;
class codecvt_utf8 : public codecvt&lt;Elem, char, mbstate_t&gt; {
 public:
    explicit codecvt_utf8(size_t refs = 0);
    ~codecvt_utf8();
};
}}

====Class {{lc|std::codecvt_utf16}}====
{{source|1=
template&lt; class Elem,
          unsigned long Maxcode = 0x10ffff,
          codecvt_mode Mode = (codecvt_mode)0 &gt;
class codecvt_utf16 : public codecvt&lt;Elem, char, mbstate_t&gt; {
 public:
    explicit codecvt_utf16(size_t refs = 0);
    ~codecvt_utf16();
};
}}

====Class {{lc|std::codecvt_utf8_utf16}}====
{{source|1=
template&lt; class Elem,
          unsigned long Maxcode = 0x10ffff,
          codecvt_mode Mode = (codecvt_mode)0 &gt;
class codecvt_utf8_utf16 : public codecvt&lt;Elem, char, mbstate_t&gt; {
 public:
    explicit codecvt_utf8_utf16(size_t refs = 0);
    ~codecvt_utf8_utf16();
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/complex</title>
    <ns>0</ns>
    <id>9801</id>
    <revision>
      <id>57454</id>
      <parentid>49553</parentid>
      <timestamp>2013-06-01T05:53:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="9906">{{cpp/header/title|complex}}
{{cpp/header/navbar}}

This header is part of the [[cpp/numeric|numeric]] library.

===Classes===

{{dsc begin}}
{{dsc tclass | cpp/numeric/complex | a complex number type }}
{{dsc ptclass | title={{ttb|complex}}{{small|&lt;float&gt;}}&lt;br&gt;{{ttb|complex}}{{small|&lt;double&gt;}}&lt;br&gt;{{ttb|complex}}{{small|&lt;long double&gt;}} |cpp/numeric/complex | a complex number type }}
{{dsc end}}

===Functions===
{{dsc begin}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith2}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc inc | cpp/numeric/complex/dsc operator_cmp}}
{{dsc inc | cpp/numeric/complex/dsc operator_ltltgtgt}}
{{dsc inc | cpp/numeric/complex/dsc real2}}
{{dsc inc | cpp/numeric/complex/dsc imag2}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc inc | cpp/numeric/complex/dsc norm}}
{{dsc inc | cpp/numeric/complex/dsc conj}}
{{dsc inc | cpp/numeric/complex/dsc proj}}
{{dsc inc | cpp/numeric/complex/dsc polar}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/complex/dsc exp}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc inc | cpp/numeric/complex/dsc log10}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/complex/dsc pow}}
{{dsc inc | cpp/numeric/complex/dsc sqrt}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc atan}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc end}}


===Synopsis===
{{source|

namespace std {
    
    template&lt;class T&gt; class complex;
    
    template&lt;&gt; class complex&lt;float&gt;;
    template&lt;&gt; class complex&lt;double&gt;;
    template&lt;&gt; class complex&lt;long double&gt;;
    
    // operators:
    template&lt;class T&gt;
    complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; operator-(
        const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; operator*(
        const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; operator/(
        const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; bool operator{{=}}{{=}}(
        const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; bool operator{{=}}{{=}}(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; bool operator{{=}}{{=}}(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; bool operator!{{=}}(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; bool operator!{{=}}(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; bool operator!{{=}}(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T, class charT, class traits&gt;
    basic_istream&lt;charT, traits&gt;&amp;
    operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);
    
    template&lt;class T, class charT, class traits&gt;
    basic_ostream&lt;charT, traits&gt;&amp;
    operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);
    
    // values:
    template&lt;class T&gt; T real(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; T imag(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; T abs(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; T arg(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; T norm(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);
    template &lt;class T&gt; complex&lt;T&gt; proj(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp;, const T&amp; {{=}} 0);
    
    // transcendentals:
    template&lt;class T&gt; complex&lt;T&gt; acos(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; asin(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; atan(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; acosh(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; asinh(const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; atanh(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; cos  (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; cosh (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; exp  (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; log  (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; log10(const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; pow(const T&amp;, const complex&lt;T&gt;&amp;);
    
    template&lt;class T&gt; complex&lt;T&gt; sin    (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; sinh   (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; sqrt   (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; tan    (const complex&lt;T&gt;&amp;);
    template&lt;class T&gt; complex&lt;T&gt; tanh   (const complex&lt;T&gt;&amp;);
    
    
}

}}



====Class {{lc|std::complex}}====
{{source|

template&lt;class T&gt;
class complex {
public:
    typedef T value_type;
    complex(const T&amp; re {{=}} T(), const T&amp; im {{=}} T());
    complex(const complex&amp;);
    template&lt;class X&gt; complex(const complex&lt;X&gt;&amp;);
    
    T real() const;
    void real(T);
    T imag() const;
    void imag(T);
    
    complex&lt;T&gt;&amp; operator{{=}} (const T&amp;);
    complex&lt;T&gt;&amp; operator+{{=}}(const T&amp;);
    complex&lt;T&gt;&amp; operator-{{=}}(const T&amp;);
    complex&lt;T&gt;&amp; operator*{{=}}(const T&amp;);
    complex&lt;T&gt;&amp; operator/{{=}}(const T&amp;);
    
    complex&amp; operator{{=}}(const complex&amp;);     
    template&lt;class X&gt; complex&lt;T&gt;&amp; operator{{=}} (const complex&lt;X&gt;&amp;);   
    template&lt;class X&gt; complex&lt;T&gt;&amp; operator+{{=}}(const complex&lt;X&gt;&amp;);   
    template&lt;class X&gt; complex&lt;T&gt;&amp; operator-{{=}}(const complex&lt;X&gt;&amp;);   
    template&lt;class X&gt; complex&lt;T&gt;&amp; operator*{{=}}(const complex&lt;X&gt;&amp;);   
    template&lt;class X&gt; complex&lt;T&gt;&amp; operator/{{=}}(const complex&lt;X&gt;&amp;);   
    
};

}}

===={{lc|std::complex}} specializations====
{{source|
template&lt;&gt; class complex&lt;float&gt; {
public:
    typedef float value_type;
    
    constexpr complex(float re {{=}} 0.0f, float im {{=}} 0.0f);
    explicit constexpr complex(const complex&lt;double&gt;&amp;);
    explicit constexpr complex(const complex&lt;long double&gt;&amp;);
    
    constexpr float real();
    void real(float);
    constexpr float imag();
    void imag(float);
    
    complex&lt;float&gt;&amp; operator{{=}} (float);
    complex&lt;float&gt;&amp; operator+{{=}}(float);
    complex&lt;float&gt;&amp; operator-{{=}}(float);
    complex&lt;float&gt;&amp; operator*{{=}}(float);
    complex&lt;float&gt;&amp; operator/{{=}}(float);
    
    complex&lt;float&gt;&amp; operator{{=}}(const complex&lt;float&gt;&amp;);
    template&lt;class X&gt; complex&lt;float&gt;&amp; operator{{=}} (const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;float&gt;&amp; operator+{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;float&gt;&amp; operator-{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;float&gt;&amp; operator*{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;float&gt;&amp; operator/{{=}}(const complex&lt;X&gt;&amp;);
};

template&lt;&gt; class complex&lt;double&gt; {
public:
    typedef double value_type;
    
    constexpr complex(double re {{=}} 0.0, double im {{=}} 0.0);
    constexpr complex(const complex&lt;float&gt;&amp;);
    explicit constexpr complex(const complex&lt;long double&gt;&amp;);
    
    constexpr double real();
    void real(double);
    constexpr double imag();
    void imag(double);
    
    complex&lt;double&gt;&amp; operator{{=}} (double);
    complex&lt;double&gt;&amp; operator+{{=}}(double);
    complex&lt;double&gt;&amp; operator-{{=}}(double);
    complex&lt;double&gt;&amp; operator*{{=}}(double);
    complex&lt;double&gt;&amp; operator/{{=}}(double);
    
    complex&lt;double&gt;&amp; operator{{=}}(const complex&lt;double&gt;&amp;);
    template&lt;class X&gt; complex&lt;double&gt;&amp; operator{{=}} (const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;double&gt;&amp; operator+{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;double&gt;&amp; operator-{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;double&gt;&amp; operator*{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;double&gt;&amp; operator/{{=}}(const complex&lt;X&gt;&amp;);
};

template&lt;&gt; class complex&lt;long double&gt; {
public:
    typedef long double value_type;
    
    constexpr complex(long double re {{=}} 0.0L, long double im {{=}} 0.0L);
    constexpr complex(const complex&lt;float&gt;&amp;);
    constexpr complex(const complex&lt;double&gt;&amp;);
    
    constexpr long double real();
    void real(long double);
    constexpr long double imag();
    void imag(long double);
    
    complex&lt;long double&gt;&amp; operator{{=}}(const complex&lt;long double&gt;&amp;);
    complex&lt;long double&gt;&amp; operator{{=}} (long double);
    complex&lt;long double&gt;&amp; operator+{{=}}(long double);
    complex&lt;long double&gt;&amp; operator-{{=}}(long double);
    complex&lt;long double&gt;&amp; operator*{{=}}(long double);
    complex&lt;long double&gt;&amp; operator/{{=}}(long double);
    
    template&lt;class X&gt; complex&lt;long double&gt;&amp; operator{{=}} (const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;long double&gt;&amp; operator+{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;long double&gt;&amp; operator-{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;long double&gt;&amp; operator*{{=}}(const complex&lt;X&gt;&amp;);
    template&lt;class X&gt; complex&lt;long double&gt;&amp; operator/{{=}}(const complex&lt;X&gt;&amp;);
    
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/condition variable</title>
    <ns>0</ns>
    <id>12853</id>
    <revision>
      <id>63995</id>
      <timestamp>2013-08-06T01:15:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3713">{{cpp/header/title|condition_variable}}
{{cpp/header/navbar}}
This header is part of the [[cpp/thread|thread support]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc class | cpp/thread/condition_variable | provides a condition variable associated with a {{lc|std::unique_lock}} | notes={{mark c++11}}}}
{{dsc class | cpp/thread/condition_variable_any | provides a condition variable associated with any lock type | notes={{mark c++11}}}}
{{dsc enum | cpp/thread/cv_status | lists the possible results of timed waits on condition variables | notes={{mark c++11}}}}
{{dsc h1|Functions}}
{{dsc fun   | cpp/thread/notify_all_at_thread_exit | schedules a call to {{tt|notify_all}} to be invoked when this thread is completely finished | notes={{mark c++11}}}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

    class condition_variable;
    class condition_variable_any;

    void notify_all_at_thread_exit(condition_variable&amp; cond, unique_lock&lt;mutex&gt; lk);

    enum class cv_status {
        no_timeout,
        timeout
    };
}
}}

====Class {{lc|std::condition_variable}}====
{{source|1=
class condition_variable {
 public:
    condition_variable();
    ~condition_variable();
    condition_variable(const condition_variable&amp;) = delete;
    condition_variable&amp; operator=(const condition_variable&amp;) = delete;

    void notify_one() noexcept;
    void notify_all() noexcept;
    void wait(unique_lock&lt;mutex&gt;&amp; lock);
    template &lt;class Predicate&gt;
        void wait(unique_lock&lt;mutex&gt;&amp; lock, Predicate pred);
    template &lt;class Clock, class Duration&gt;
        cv_status wait_until(unique_lock&lt;mutex&gt;&amp; lock,
                             const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    template &lt;class Clock, class Duration, class Predicate&gt;
        bool wait_until(unique_lock&lt;mutex&gt;&amp; lock,
                        const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
                        Predicate pred);
    template &lt;class Rep, class Period&gt;
        cv_status wait_for(unique_lock&lt;mutex&gt;&amp; lock,
                           const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Rep, class Period, class Predicate&gt;
        bool wait_for(unique_lock&lt;mutex&gt;&amp; lock,
                      const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
                      Predicate pred);

    typedef implementation-defined native_handle_type;
    native_handle_type native_handle();
};
}}

====Class {{lc|std::condition_variable_any}}====
{{source|1=
class condition_variable_any {
 public:
    condition_variable_any();
    ~condition_variable_any();
    condition_variable_any(const condition_variable_any&amp;) = delete;
    condition_variable_any&amp; operator=(const condition_variable_any&amp;) = delete;

    void notify_one() noexcept;
    void notify_all() noexcept;
    template &lt;class Lock&gt;
        void wait(Lock&amp; lock);
    template &lt;class Lock, class Predicate&gt;
        void wait(Lock&amp; lock, Predicate pred);
    template &lt;class Lock, class Clock, class Duration&gt;
        cv_status wait_until(Lock&amp; lock,
                             const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    template &lt;class Lock, class Clock, class Duration, class Predicate&gt;
        bool wait_until(Lock&amp; lock,
                        const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time,
                        Predicate pred);
    template &lt;class Lock, class Rep, class Period&gt;
        cv_status wait_for(Lock&amp; lock,
                           const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Lock, class Rep, class Period, class Predicate&gt;
        bool wait_for(Lock&amp; lock,
                      const chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
                      Predicate pred);
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/csetjmp</title>
    <ns>0</ns>
    <id>9679</id>
    <revision>
      <id>57455</id>
      <parentid>49554</parentid>
      <timestamp>2013-06-01T05:53:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="369">{{cpp/header/title|csetjmp}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/utility/program|program support]] library.
{{dsc begin}}
{{dsc h1 | Types}}
{{dsc inc | cpp/utility/program/dsc jmp_buf}}
{{dsc h1 | Macros}}
{{dsc inc | cpp/utility/program/dsc setjmp}}
{{dsc h1 | Functions}}
{{dsc inc | cpp/utility/program/dsc longjmp}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/csignal</title>
    <ns>0</ns>
    <id>9680</id>
    <revision>
      <id>65020</id>
      <parentid>57456</parentid>
      <timestamp>2013-08-29T12:40:36Z</timestamp>
      <contributor>
        <ip>216.163.111.123</ip>
      </contributor>
      <comment>changed Typefefs to Typedefs (typo)</comment>
      <text xml:space="preserve" bytes="613">{{cpp/header/title|csignal}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/utility/program|program support]] library.

{{dsc begin}}
{{dsc h1|Typedefs}}
{{dsc typedef | cpp/utility/program/sig_atomic_t | the integer type that can be accessed as an atomic entity from an asynchronous signal handler}}
{{dsc h1|Macros}}
{{dsc inc | cpp/utility/program/dsc SIG_types}}
{{dsc inc | cpp/utility/program/dsc SIG_strategies}}
{{dsc inc | cpp/utility/program/dsc SIG_ERR}}
{{dsc h1|Functions}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc inc | cpp/utility/program/dsc raise}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdalign</title>
    <ns>0</ns>
    <id>9681</id>
    <revision>
      <id>49556</id>
      <parentid>45310</parentid>
      <timestamp>2013-06-01T02:45:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="268">{{cpp/header/title|cstdalign}}
{{cpp/header/navbar}}
{{cpp/header/c}}

C compatibility header.
{{dsc begin}}
{{dsc macro const | __alignas_is_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c++11}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdarg</title>
    <ns>0</ns>
    <id>9683</id>
    <revision>
      <id>57459</id>
      <parentid>49557</parentid>
      <timestamp>2013-06-01T05:53:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="454">{{cpp/header/title|cstdarg}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header provides support for [[cpp/utility/variadic|C-style variadic functions]].

{{dsc begin}}
{{dsc h1 | Types}}
{{dsc inc | cpp/utility/variadic/dsc va_list}}
{{dsc h1 | Macros}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdbool</title>
    <ns>0</ns>
    <id>9684</id>
    <revision>
      <id>49558</id>
      <parentid>46797</parentid>
      <timestamp>2013-06-01T02:45:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="418">{{cpp/header/title|cstdbool}}
{{cpp/header/navbar}}
{{cpp/header/c}}

Compatibility header, in C defines [[cpp/keyword/true|{{c|true}}]], [[cpp/keyword/false|{{c|false}}]] and [[cpp/keyword/bool|{{c|bool}}]] which are keywords in C++.

{{dsc begin}}
{{dsc macro const | __bool_true_false_are_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c++11}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstddef</title>
    <ns>0</ns>
    <id>9661</id>
    <revision>
      <id>57460</id>
      <parentid>49559</parentid>
      <timestamp>2013-06-01T05:53:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="750">{{cpp/header/title|cstddef}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/utility|utility]] library.

===Macros===
{{dsc begin}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc inc | cpp/types/dsc offsetof}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/types/dsc ptrdiff_t}}
{{dsc inc | cpp/types/dsc nullptr_t}}
{{dsc inc | cpp/types/dsc max_align_t}}
{{dsc end}}

===Notes===
* {{lc|NULL}} is also defined in the following headers:
** {{header|clocale}}
** {{header|ctime}}
** {{header|cstring}}
** {{header|cstdio}}
** {{header|cwchar}}
* {{lc|std::size_t}} is also defined in the following headers:
** {{header|ctime}}
** {{header|cstring}}
** {{header|cstdio}}
** {{header|cwchar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdef</title>
    <ns>0</ns>
    <id>9749</id>
    <redirect title="cpp/header/cstddef" />
    <revision>
      <id>45258</id>
      <timestamp>2012-12-12T21:02:10Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>moved [[cpp/header/cstdef]] to [[cpp/header/cstddef]]: typo</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/header/cstddef]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdint</title>
    <ns>0</ns>
    <id>9665</id>
    <revision>
      <id>69418</id>
      <parentid>66363</parentid>
      <timestamp>2014-04-08T08:20:25Z</timestamp>
      <contributor>
        <username>Yoursunny</username>
        <id>2989</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6149">{{cpp/header/title|cstdint}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/types|type support]] library, providing [[cpp/types/integer|fixed width integer types]].

===Types===

{{dsc begin}}
{{dsc | {{tt|int8_t}}&lt;br&gt;{{tt|int16_t}}&lt;br&gt;{{tt|int32_t}}&lt;br&gt;{{tt|int64_t}} | signed integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively&lt;br&gt;with no padding bits and using 2's complement for negative values&lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|int_fast8_t}}&lt;br&gt;{{tt|int_fast16_t}}&lt;br&gt;{{tt|int_fast32_t}}&lt;br&gt;{{tt|int_fast64_t}} | fastest signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|int_least8_t}}&lt;br&gt;{{tt|int_least16_t}}&lt;br&gt;{{tt|int_least32_t}}&lt;br&gt;{{tt|int_least64_t}} | smallest signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|intmax_t}} | maximum width integer type }}
{{dsc | {{tt|intptr_t}} | integer type capable of holding a pointer}}{{dsc | {{tt|uint8_t}}&lt;br&gt;{{tt|uint16_t}}&lt;br&gt;{{tt|uint32_t}}&lt;br&gt;{{tt|uint64_t}} | unsigned integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively &lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|uint_fast8_t}}&lt;br&gt;{{tt|uint_fast16_t}}&lt;br&gt;{{tt|uint_fast32_t}}&lt;br&gt;{{tt|uint_fast64_t}} | fastest unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uint_least8_t}}&lt;br&gt;{{tt|uint_least16_t}}&lt;br&gt;{{tt|uint_least32_t}}&lt;br&gt;{{tt|uint_least64_t}} | smallest unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uintmax_t}} | maximum width unsigned integer type }}
{{dsc | {{tt|uintptr_t}} | unsigned integer type capable of holding a pointer}}
{{dsc end}}

===Macro constants===
{{dsc begin}}
{{dsc h2 | Signed integers : minimum value}}
{{dsc macro const | INT8_MIN&lt;br&gt;INT16_MIN&lt;br&gt;INT32_MIN&lt;br&gt;INT64_MIN |  minimum value of an object of type {{c|int8_t}}, {{c|int16_t}}, {{c|int32_t}}, {{c|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MIN&lt;br&gt;INT_FAST16_MIN&lt;br&gt;INT_FAST32_MIN&lt;br&gt;INT_FAST64_MIN |  minimum value of an object of type {{c|int_fast8_t}}, {{c|int_fast16_t}}, {{c|int_fast32_t}}, {{c|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MIN&lt;br&gt;INT_LEAST16_MIN&lt;br&gt;INT_LEAST32_MIN&lt;br&gt;INT_LEAST64_MIN |  minimum value of an object of type {{c|int_least8_t}}, {{c|int_least16_t}}, {{c|int_least32_t}}, {{c|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MIN | minimum value of an object of type {{c|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MIN | minimum value of an object of type {{c|intmax_t}} | nolink=true }}
{{dsc h2 | Signed integers : maximum value| nolink=true }}

{{dsc macro const | INT8_MAX&lt;br&gt;INT16_MAX&lt;br&gt;INT32_MAX&lt;br&gt;INT64_MAX |  maximum value of an object of type {{c|int8_t}}, {{c|int16_t}}, {{c|int32_t}}, {{c|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MAX&lt;br&gt;INT_FAST16_MAX&lt;br&gt;INT_FAST32_MAX&lt;br&gt;INT_FAST64_MAX |  maximum value of an object of type {{c|int_fast8_t}}, {{c|int_fast16_t}}, {{c|int_fast32_t}}, {{c|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MAX&lt;br&gt;INT_LEAST16_MAX&lt;br&gt;INT_LEAST32_MAX&lt;br&gt;INT_LEAST64_MAX |  maximum value of an object of type {{c|int_least8_t}}, {{c|int_least16_t}}, {{c|int_least32_t}}, {{c|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MAX | maximum value of an object of type {{c|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MAX | maximum value of an object of type {{c|intmax_t}} | nolink=true }}
{{dsc h2 | Unsigned integers : maximum value| nolink=true }}{{dsc macro const | UINT8_MAX&lt;br&gt;UINT16_MAX&lt;br&gt;UINT32_MAX&lt;br&gt;UINT64_MAX |  maximum value of an object of type {{c|uint8_t}}, {{c|uint16_t}}, {{c|uint32_t}}, {{c|uint64_t}} | nolink=true }}
{{dsc macro const | UINT_FAST8_MAX&lt;br&gt;UINT_FAST16_MAX&lt;br&gt;UINT_FAST32_MAX&lt;br&gt;UINT_FAST64_MAX |  maximum value of an object of type {{c|uint_fast8_t}}, {{c|uint_fast16_t}}, {{c|uint_fast32_t}}, {{c|uint_fast64_t}} | nolink=true }}
{{dsc macro const | UINT_LEAST8_MAX&lt;br&gt;UINT_LEAST16_MAX&lt;br&gt;UINT_LEAST32_MAX&lt;br&gt;UINT_LEAST64_MAX |  maximum value of an object of type {{c|uint_least8_t}}, {{c|uint_least16_t}}, {{c|uint_least32_t}}, {{c|uint_least64_t}} | nolink=true }}
{{dsc macro const | UINTPTR_MAX | maximum value of an object of type {{c|uintptr_t}} | nolink=true }}
{{dsc macro const | UINTMAX_MAX | maximum value of an object of type {{c|uintmax_t}} | nolink=true }}
{{dsc end}}

===Synopsis===

{{source|
namespace std {
    typedef /*signed integer type*/ int8_t;  // optional
    typedef /*signed integer type*/ int16_t; // optional
    typedef /*signed integer type*/ int32_t; // optional
    typedef /*signed integer type*/ int64_t; // optional
    
    typedef /*signed integer type*/ int_fast8_t;
    typedef /*signed integer type*/ int_fast16_t;
    typedef /*signed integer type*/ int_fast32_t;
    typedef /*signed integer type*/ int_fast64_t;

    typedef /*signed integer type*/ int_least8_t;
    typedef /*signed integer type*/ int_least16_t;
    typedef /*signed integer type*/ int_least32_t;
    typedef /*signed integer type*/ int_least64_t;

    typedef /*signed integer type*/ intmax_t;
    typedef /*signed integer type*/ intptr_t; //optional


    typedef /*unsigned integer type*/ uint8_t;  // optional
    typedef /*unsigned integer type*/ uint16_t; // optional
    typedef /*unsigned integer type*/ uint32_t; // optional
    typedef /*unsigned integer type*/ uint64_t; // optional
    
    typedef /*unsigned integer type*/ uint_fast8_t;
    typedef /*unsigned integer type*/ uint_fast16_t;
    typedef /*unsigned integer type*/ uint_fast32_t;
    typedef /*unsigned integer type*/ uint_fast64_t;

    typedef /*unsigned integer type*/ uint_least8_t;
    typedef /*unsigned integer type*/ uint_least16_t;
    typedef /*unsigned integer type*/ uint_least32_t;
    typedef /*unsigned integer type*/ uint_least64_t;

    typedef /*unsigned integer type*/ uintmax_t;
    typedef /*unsigned integer type*/ uintptr_t; //optional

} // namespace std

}}</text>
      <sha1>0em9eufd9r4m8xc64r99k2jlssn9s4q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdio</title>
    <ns>0</ns>
    <id>9758</id>
    <revision>
      <id>57463</id>
      <parentid>49561</parentid>
      <timestamp>2013-06-01T05:53:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3832">{{cpp/header/title|cstdio}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/io/c|C-style input/output]] library.

===Types===
{{dsc begin}}
{{dsc | {{c|FILE}} | type, capable of holding all information needed to control a C I/O stream}}
{{dsc | {{c|fpos_t}} | type, capable of uniquely specifying a position in a file}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc end}}

===Macros===

{{dsc begin}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc macro const | stdin | nolink=true| title=stdin&lt;br&gt;stdout&lt;br&gt;stderr | expression of type {{c|FILE*}} associated with the input stream&lt;br&gt;expression of type {{c|FILE*}} associated with the output stream&lt;br&gt;expression of type {{c|FILE*}} associated with the error output stream}}
{{dsc macro const | EOF | nolink=true| integer constant expression of type {{c|int}} and negative value }}
{{dsc macro const | FOPEN_MAX | nolink=true| number of files that can be open simultaneously }}
{{dsc macro const | FILENAME_MAX | nolink=true| size needed for an array of char to hold the longest supported file name}}
{{dsc macro const | BUFSIZ | nolink=true| size of the buffer used by {{lc|std::setbuf}} }}
{{dsc macro const | _IOFBF| nolink=true| title=_IOFBF&lt;br&gt;_IOLBF&lt;br&gt;_IONBF|argument to {{lc|std::setbuf}} indicating fully buffered I/O&lt;br&gt;argument to {{lc|std::setbuf}} indicating line buffered I/O&lt;br&gt;argument to {{lc|std::setbuf}} indicating unbuffered I/O}}
{{dsc macro const | SEEK_SET | nolink=true| title=SEEK_SET&lt;br&gt;SEEK_CUR&lt;br&gt;SEEK_END | argument to {{lc|std::fseek}} indicating seeking from beginning of the file&lt;br&gt;argument to {{lc|std::fseek}} indicating seeking from the current file position&lt;br&gt;argument to {{lc|std::fseek}} indicating seeking from end of the file}}
{{dsc macro const | TMP_MAX | nolink=true| maximum number of unique filenames that can be generated by {{lc|std::tmpnam}} }}
{{dsc macro const | L_tmpnam |nolink=true|  size needed for an array of char to hold the result of {{lc|std::tmpnam}} }}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | File access}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc inc | cpp/io/c/dsc freopen}}
{{dsc inc | cpp/io/c/dsc fclose}}
{{dsc inc | cpp/io/c/dsc fflush}}
{{dsc inc | cpp/io/c/dsc setbuf}}
{{dsc inc | cpp/io/c/dsc setvbuf}}

{{dsc h2 | Direct input/output}}
{{dsc inc | cpp/io/c/dsc fread}}
{{dsc inc | cpp/io/c/dsc fwrite}}

{{dsc h2 | Unformatted input/output}}
{{dsc h2 | {{small|Narrow character}}}}
{{dsc inc | cpp/io/c/dsc fgetc}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc inc | cpp/io/c/dsc fputc}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc getchar}}
{{dsc inc | cpp/io/c/dsc gets}}
{{dsc inc | cpp/io/c/dsc putchar}}
{{dsc inc | cpp/io/c/dsc puts}}
{{dsc inc | cpp/io/c/dsc ungetc}}

{{dsc h2 | Formatted input/output}}
{{dsc h2 | {{small|Narrow/multibyte character}}}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc vfscanf}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc inc | cpp/io/c/dsc vfprintf}}

{{dsc h2 | File positioning}}
{{dsc inc | cpp/io/c/dsc ftell}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc inc | cpp/io/c/dsc fsetpos}}
{{dsc inc | cpp/io/c/dsc rewind}}

{{dsc h2 | Error handling}}
{{dsc inc | cpp/io/c/dsc clearerr}}
{{dsc inc | cpp/io/c/dsc feof}}
{{dsc inc | cpp/io/c/dsc ferror}}
{{dsc inc | cpp/io/c/dsc perror}}

{{dsc h2 | Operations on files}}
{{dsc inc | cpp/io/c/dsc remove}}
{{dsc inc | cpp/io/c/dsc rename}}
{{dsc inc | cpp/io/c/dsc tmpfile}}
{{dsc inc | cpp/io/c/dsc tmpnam}}
{{dsc end}}


===Notes===
* {{lc|NULL}} is also defined in the following headers:
** {{header|clocale}}
** {{header|ctime}}
** {{header|cstddef}}
** {{header|cstring}}
** {{header|cwchar}}
* {{lc|std::size_t}} is also defined in the following headers:
** {{header|ctime}}
** {{header|cstddef}}
** {{header|cstring}}
** {{header|cwchar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstdlib</title>
    <ns>0</ns>
    <id>9678</id>
    <revision>
      <id>71945</id>
      <parentid>71893</parentid>
      <timestamp>2014-07-02T20:44:20Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ MB_CUR_MAX</comment>
      <text xml:space="preserve" bytes="2597">{{cpp/header/title|cstdlib}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header provides miscellaneous utilities. Symbols defined here are used by several library components.

===Macro constants===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc EXIT_status}}
{{dsc macro const | MB_CUR_MAX | maximum number of bytes in a multibyte character with the current locale | nolink=true }}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc inc | cpp/numeric/random/dsc RAND_MAX}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc div_t}}
{{dsc inc | cpp/numeric/math/dsc ldiv_t}}
{{dsc inc | cpp/numeric/math/dsc lldiv_t}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | Process control}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc inc | cpp/utility/program/dsc exit}}
{{dsc inc | cpp/utility/program/dsc quick_exit}}
{{dsc inc | cpp/utility/program/dsc _Exit}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc inc | cpp/utility/program/dsc at_quick_exit}}
{{dsc inc | cpp/utility/program/dsc system}}
{{dsc inc | cpp/utility/program/dsc getenv}}

{{dsc h2 | Memory management}}
{{dsc fun | cpp/memory/c/malloc | allocates memory}}
{{dsc fun | cpp/memory/c/calloc | allocates and zeroes memory}}
{{dsc fun | cpp/memory/c/realloc | expands previously allocated memory block}}
{{dsc fun | cpp/memory/c/free | deallocates previously allocated memory}}

{{dsc h2 | Numeric string conversion}}
{{dsc inc | cpp/string/byte/dsc atof}}
{{dsc inc | cpp/string/byte/dsc atoi}}
{{dsc inc | cpp/string/byte/dsc strtol}}
{{dsc inc | cpp/string/byte/dsc strtoul}}
{{dsc inc | cpp/string/byte/dsc strtof}}

{{dsc h2 | Wide string manimpulation}}
{{dsc inc | cpp/string/multibyte/dsc mblen}}
{{dsc inc | cpp/string/multibyte/dsc mbtowc}}
{{dsc inc | cpp/string/multibyte/dsc wctomb}}
{{dsc inc | cpp/string/multibyte/dsc mbstowcs}}
{{dsc inc | cpp/string/multibyte/dsc wcstombs}}

{{dsc h2 | Miscellaneous algorithms and math}}
{{dsc inc | cpp/numeric/random/dsc rand}}
{{dsc inc | cpp/numeric/random/dsc srand}}
{{dsc inc | cpp/algorithm/dsc qsort}}
{{dsc inc | cpp/algorithm/dsc bsearch}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc div}}
{{dsc end}}

===See Also===
* [[cpp/utility/program|Program support utilities]]
* [[cpp/numeric/random|Pseudo-random number generation]]
* [[cpp/numeric/math|Common mathematical functions]]
* [[cpp/memory/c|C memory management library]]
* [[cpp/string/byte|Null-terminated byte strings]]
* [[cpp/string/multibyte|Null-terminated multibyte strings]]
* [[cpp/algorithm|Algorithms library]]</text>
      <sha1>a2npiymws0wrvrnla2wcrtuo5knd64r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cstring</title>
    <ns>0</ns>
    <id>9735</id>
    <revision>
      <id>57467</id>
      <parentid>49563</parentid>
      <timestamp>2013-06-01T05:54:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1708">{{cpp/header/title|cstring}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is for [[cpp/string/byte|C-style null-terminated byte strings]].

===Macros===
{{dsc begin}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | String manipulation}}
{{dsc inc | cpp/string/byte/dsc strcpy}}
{{dsc inc | cpp/string/byte/dsc strncpy}}
{{dsc inc | cpp/string/byte/dsc strcat}}
{{dsc inc | cpp/string/byte/dsc strncat}}
{{dsc inc | cpp/string/byte/dsc strxfrm}}

{{dsc h2 | String examination}}
{{dsc inc | cpp/string/byte/dsc strlen}}
{{dsc inc | cpp/string/byte/dsc strcmp}}
{{dsc inc | cpp/string/byte/dsc strncmp}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/byte/dsc strrchr}}
{{dsc inc | cpp/string/byte/dsc strspn}}
{{dsc inc | cpp/string/byte/dsc strcspn}}
{{dsc inc | cpp/string/byte/dsc strpbrk}}
{{dsc inc | cpp/string/byte/dsc strstr}}
{{dsc inc | cpp/string/byte/dsc strtok}}

{{dsc h2 | Character array manipulation}}
{{dsc inc | cpp/string/byte/dsc memchr}}
{{dsc inc | cpp/string/byte/dsc memcmp}}
{{dsc inc | cpp/string/byte/dsc memset}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc inc | cpp/string/byte/dsc memmove}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/string/byte/dsc strerror}}
{{dsc end}}


===Notes===
* {{lc|NULL}} is also defined in the following headers:
** {{header|clocale}}
** {{header|ctime}}
** {{header|cstddef}}
** {{header|cstdio}}
** {{header|cwchar}}
* {{lc|std::size_t}} is also defined in the following headers:
** {{header|ctime}}
** {{header|cstddef}}
** {{header|cstdio}}
** {{header|cwchar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ctgmath</title>
    <ns>0</ns>
    <id>9790</id>
    <revision>
      <id>49564</id>
      <parentid>45522</parentid>
      <timestamp>2013-06-01T02:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="223">{{cpp/header/title|ctgmath}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/numeric|numeric]] library.

===Includes===
{{dsc begin}}
{{dsc|{{header|ccomplex}}}}
{{dsc|{{header|cmath}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ctime</title>
    <ns>0</ns>
    <id>9685</id>
    <revision>
      <id>71946</id>
      <parentid>65249</parentid>
      <timestamp>2014-07-02T21:06:08Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ NULL and size_t, and some links reordered</comment>
      <text xml:space="preserve" bytes="947">{{cpp/header/title|ctime}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/chrono/c|C-style date and time]] library.

===Macro Constants===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc CLOCKS_PER_SEC}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/chrono/c/dsc clock_t}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/chrono/c/dsc time_t}}
{{dsc inc | cpp/chrono/c/dsc tm}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | Time manipulation}}
{{dsc inc | cpp/chrono/c/dsc clock}}
{{dsc inc | cpp/chrono/c/dsc time}}
{{dsc inc | cpp/chrono/c/dsc difftime}}

{{dsc h2 | Format conversions}}
{{dsc inc | cpp/chrono/c/dsc ctime}}
{{dsc inc | cpp/chrono/c/dsc asctime}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/chrono/c/dsc wcsftime}}
{{dsc inc | cpp/chrono/c/dsc gmtime}}
{{dsc inc | cpp/chrono/c/dsc localtime}}
{{dsc inc | cpp/chrono/c/dsc mktime}}
{{dsc end}}</text>
      <sha1>e0ybgc80q8u6xg8ax8jf0ar5fmmzlfa</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cuchar</title>
    <ns>0</ns>
    <id>9737</id>
    <revision>
      <id>57471</id>
      <parentid>49566</parentid>
      <timestamp>2013-06-01T05:54:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="658">{{cpp/header/title|cuchar}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/string/multibyte|null-terminated multibyte strings]] library.

{{dsc begin}}
{{dsc h1|Macros}}
{{dsc macro const | __STDC_UTF_16__ |  nolink=true | indicates that UTF-16 encoding is used by mbrtoc16 and c16rtomb}}
{{dsc macro const | __STDC_UTF_32__ |  nolink=true | indicates that UTF-32 encoding is used by mbrtoc32 and c32rtomb}}
{{dsc h1|Functions}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc16}}
{{dsc inc | cpp/string/multibyte/dsc c16rtomb}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc32}}
{{dsc inc | cpp/string/multibyte/dsc c32rtomb}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cwchar</title>
    <ns>0</ns>
    <id>9736</id>
    <revision>
      <id>65246</id>
      <parentid>57474</parentid>
      <timestamp>2013-09-05T15:22:23Z</timestamp>
      <contributor>
        <ip>95.220.170.37</ip>
      </contributor>
      <comment>from &quot;fom&quot; to &quot;from&quot;</comment>
      <text xml:space="preserve" bytes="3482">{{cpp/header/title|cwchar}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the null-terminated [[cpp/string/wide|wide]] and [[cpp/string/multibyte|multibyte]] strings libraries.
It also provides some [[cpp/io/c|C-style I/O]] functions and conversion from [[cpp/chrono/c|C-style Date]].

===Macros===
{{dsc begin}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc macro const | WEOF |  nolink=true | a non-character value of type wint_t used to indicate errors}}
{{dsc macro const | WCHAR_MIN |  nolink=true | the smallest valid value of wchar_t }}
{{dsc macro const | WCHAR_MAX |  nolink=true | the largest valid value of wchar_t }}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbstate_t}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc | {{tt|wint_t}} | integer type that can hold any valid wide character and at least one more value }}
{{dsc inc | cpp/chrono/c/dsc tm}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | String manipulation}}
{{dsc inc | cpp/string/wide/dsc wcscpy}}
{{dsc inc | cpp/string/wide/dsc wcsncpy}}
{{dsc inc | cpp/string/wide/dsc wcscat}}
{{dsc inc | cpp/string/wide/dsc wcsncat}}
{{dsc inc | cpp/string/wide/dsc wcsxfrm}}

{{dsc h2 | String examination}}
{{dsc inc | cpp/string/wide/dsc wcslen}}
{{dsc inc | cpp/string/wide/dsc wcscmp}}
{{dsc inc | cpp/string/wide/dsc wcsncmp}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/wide/dsc wcsrchr}}
{{dsc inc | cpp/string/wide/dsc wcsspn}}
{{dsc inc | cpp/string/wide/dsc wcscspn}}
{{dsc inc | cpp/string/wide/dsc wcspbrk}}
{{dsc inc | cpp/string/wide/dsc wcsstr}}
{{dsc inc | cpp/string/wide/dsc wcstok}}

{{dsc h2 | Wide character array manipulation}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc inc | cpp/string/wide/dsc wmemmove}}
{{dsc inc | cpp/string/wide/dsc wmemcmp}}
{{dsc inc | cpp/string/wide/dsc wmemchr}}
{{dsc inc | cpp/string/wide/dsc wmemset}}

{{dsc h2 | Multibyte/wide character conversion }}
{{dsc inc | cpp/string/multibyte/dsc mbsinit}}
{{dsc inc | cpp/string/multibyte/dsc btowc}}
{{dsc inc | cpp/string/multibyte/dsc wctob}}
{{dsc inc | cpp/string/multibyte/dsc mbrlen}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}

{{dsc h2 | Input/Output }}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc inc | cpp/io/c/dsc fgetws}}
{{dsc inc | cpp/io/c/dsc fputwc}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc inc | cpp/io/c/dsc getwchar}}
{{dsc inc | cpp/io/c/dsc putwchar}}
{{dsc inc | cpp/io/c/dsc ungetwc}}
{{dsc inc | cpp/io/c/dsc fwide}}
{{dsc inc | cpp/io/c/dsc fwscanf}}
{{dsc inc | cpp/io/c/dsc vfwscanf}}
{{dsc inc | cpp/io/c/dsc fwprintf}}
{{dsc inc | cpp/io/c/dsc vfwprintf}}

{{dsc h2|String conversions}}
{{dsc inc | cpp/chrono/c/dsc wcsftime}}
{{dsc inc | cpp/string/wide/dsc wcstol}}
{{dsc inc | cpp/string/wide/dsc wcstoul}}
{{dsc inc | cpp/string/wide/dsc wcstof}}

{{dsc end}}


===Notes===
* {{lc|NULL}} is also defined in the following headers:
** {{header|cstddef}}
** {{header|cstring}}
** {{header|ctime}}
** {{header|clocale}}
** {{header|cstdio}}
* {{lc|std::size_t}} is also defined in the following headers:
** {{header|cstddef}}
** {{header|ctime}}
** {{header|cstdio}}
* {{c|std::wint_t}} is also defined in the following headers:
** {{header|cwctype}}
* {{lc|std::tm}} is also defined in the following headers:
** {{header|ctime}}</text>
      <sha1>ee61t6zx2atkupvncv5jpiwv7vpyncd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/cwctype</title>
    <ns>0</ns>
    <id>9687</id>
    <revision>
      <id>57475</id>
      <parentid>49568</parentid>
      <timestamp>2013-06-01T05:54:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1522">{{cpp/header/title|cwctype}}
{{cpp/header/navbar}}
{{cpp/header/c}}

This header is part of the [[cpp/string/wide|C-style null-terminated wide strings]] library.

===Types===
{{dsc begin}}
{{dsc | {{tt|wctrans_t}} | scalar type that holds locale-specific character mapping }}
{{dsc | {{tt|wctype_t}} | scalar type that holds locale-specific character classification }}
{{dsc | {{tt|wint_t}} | integer type that can hold any valid wide character and at least one more value }}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc macro const | WEOF |  nolink=true | a non-character value of type wint_t used to indicate errors}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | Character classification}}
{{dsc inc | cpp/string/wide/dsc iswalnum}}
{{dsc inc | cpp/string/wide/dsc iswalpha}}
{{dsc inc | cpp/string/wide/dsc iswlower}}
{{dsc inc | cpp/string/wide/dsc iswupper}}
{{dsc inc | cpp/string/wide/dsc iswdigit}}
{{dsc inc | cpp/string/wide/dsc iswxdigit}}
{{dsc inc | cpp/string/wide/dsc iswcntrl}}
{{dsc inc | cpp/string/wide/dsc iswgraph}}
{{dsc inc | cpp/string/wide/dsc iswspace}}
{{dsc inc | cpp/string/wide/dsc iswblank}}
{{dsc inc | cpp/string/wide/dsc iswprint}}
{{dsc inc | cpp/string/wide/dsc iswpunct}}
{{dsc inc | cpp/string/wide/dsc iswctype}}
{{dsc inc | cpp/string/wide/dsc wctype}}
{{dsc h2 | Character manipulation}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc inc | cpp/string/wide/dsc towctrans}}
{{dsc inc | cpp/string/wide/dsc wctrans}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/deque</title>
    <ns>0</ns>
    <id>9674</id>
    <revision>
      <id>57478</id>
      <parentid>49569</parentid>
      <timestamp>2013-06-01T05:54:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="5575">{{cpp/header/title|deque}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc deque}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | deque}}
{{dsc inc | cpp/container/dsc swap2 | deque}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {

    #include &lt;initializer_list&gt;

    template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt; class deque;
    
    template &lt;class T, class Allocator&gt;
        bool operator{{==}}(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&lt;(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator!{{=}}(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&gt;(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&gt;{{=}}(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&lt;{{=}}(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
        
    template &lt;class T, class Allocator&gt;
        void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
}

}}

===Class {{lc|std::deque}}===
{{source|

template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt;
class deque {
public:
    // types:
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef T                                                   value_type;
    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    // construct/copy/destroy:
    explicit deque(const Allocator&amp; {{=}} Allocator());
    explicit deque(size_type n);
    deque(size_type n, const T&amp; value,const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        deque(InputIterator first, InputIterator last,const Allocator&amp; {{=}} Allocator());
    deque(const deque&lt;T,Allocator&gt;&amp; x);
    deque(deque&amp;&amp;);
    deque(const deque&amp;, const Allocator&amp;);
    deque(deque&amp;&amp;, const Allocator&amp;);
    deque(initializer_list&lt;T&gt;, const Allocator&amp; {{=}} Allocator());
    
    ~deque();
    deque&lt;T,Allocator&gt;&amp; operator{{=}}(const deque&lt;T,Allocator&gt;&amp; x);
    deque&lt;T,Allocator&gt;&amp; operator{{=}}(deque&lt;T,Allocator&gt;&amp;&amp; x);
    deque&amp; operator{{=}}(initializer_list&lt;T&gt;);
    template &lt;class InputIterator&gt;
    void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const T&amp; t);
    void assign(initializer_list&lt;T&gt;);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const T&amp; c);
    void      shrink_to_fit();
    bool      empty() const noexcept;
    
    // element access:
    reference       operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference       at(size_type n);
    const_reference at(size_type n) const;
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;
    
    // modifiers:
    template &lt;class... Args&gt; void emplace_front(Args&amp;&amp;... args);
    template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
    
    void push_front(const T&amp; x);
    void push_front(T&amp;&amp; x);
    void push_back(const T&amp; x);
    void push_back(T&amp;&amp; x);

    iterator insert(const_iterator position, const T&amp; x);
    iterator insert(const_iterator position, T&amp;&amp; x);
    iterator insert(const_iterator position, size_type n, const T&amp; x);
    template &lt;class InputIterator&gt;
        iterator insert (const_iterator position, InputIterator first, 
                         InputIterator last);
    iterator insert(const_iterator position, initializer_list&lt;T&gt;);

    void pop_front();
    void pop_back();

    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(deque&lt;T,Allocator&gt;&amp;);
    void     clear() noexcept;
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/dynarray</title>
    <ns>0</ns>
    <id>12851</id>
    <revision>
      <id>63993</id>
      <timestamp>2013-08-06T00:46:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3321">{{cpp/header/title|dynarray}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc dynarray}}
{{dsc inc | cpp/container/dsc uses_allocator | dynarray}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | dynarray}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

    template &lt;class T&gt; class dynarray;

    template &lt;class Type, class Alloc&gt;
    struct uses_allocator&lt;dynarray&lt;Type&gt;, Alloc&gt;;

    template &lt;class T&gt;
    bool operator==(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);
    template &lt;class T&gt;
    bool operator!=(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);

    template &lt;class T&gt;
    bool operator&lt;(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);
    template &lt;class T&gt;
    bool operator&gt;(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);
    template &lt;class T&gt;
    bool operator&gt;=(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);
    template &lt;class T&gt;
    bool operator&lt;=(const dynarray&lt;T&gt;&amp; x, const dynarray&lt;T&gt;&amp; y);
}
}
}}

====Class {{lc|std::dynarray}}====
{{source|1=
template &lt;class T&gt;
class dynarray {
 public:
    // types:
    typedef T value_type;
    typedef T&amp; reference;
    typedef const T&amp; const_reference;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef /*implementation-defined*/ iterator;
    typedef /*implementation-defined*/ const_iterator;
    typedef reverse_iterator&lt;iterator&gt; reverse_iterator;
    typedef reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;

    // construct/copy/destroy:
    explicit dynarray(size_type c);
    template &lt;class Alloc&gt; dynarray(size_type c, const Alloc&amp; alloc);
    dynarray(size_type c, const T&amp; v);
    template &lt;class Alloc&gt; dynarray(size_type c, const T&amp; v, const Alloc&amp; alloc);
    dynarray(const dynarray&amp; d);
    template &lt;class Alloc&gt; dynarray(const dynarray&amp; d, const Alloc&amp; alloc);
    dynarray(initializer_list&lt;T&gt;);
    template &lt;class Alloc&gt; dynarray(initializer_list&lt;T&gt;, const Alloc&amp; alloc);
    dynarray&amp; operator=(const dynarray&amp;) = delete;
    ~dynarray();

    // iterators:
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    const_iterator cbegin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cend() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_reverse_iterator crend() const noexcept;

    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    bool empty() const noexcept;

    // element access:
    reference operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;
    const_reference at(size_type n) const;
    reference at(size_type n);

    // data access:
    T* data() noexcept;
    const T* data() const noexcept;

    // mutating member functions:
    void fill(const T&amp; v);
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/exception</title>
    <ns>0</ns>
    <id>9667</id>
    <revision>
      <id>57481</id>
      <parentid>49570</parentid>
      <timestamp>2013-06-01T05:54:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2980">{{cpp/header/title|exception}}
{{cpp/header/navbar}}

This header is part of the [[cpp/error|error handling]] library.

{{dsc begin}}
{{dsc h1 | Classes}}
{{dsc inc | cpp/error/dsc exception}}
{{dsc inc | cpp/error/dsc nested_exception}}
{{dsc inc | cpp/error/dsc bad_exception}}
{{dsc h1 | Typedefs}}
{{dsc inc | cpp/error/dsc unexpected}}
{{dsc inc | cpp/error/dsc unexpected_handler}}
{{dsc inc | cpp/error/dsc terminate_handler}}
{{dsc inc | cpp/error/dsc exception_ptr}}
{{dsc h1 | Functions}}
{{dsc inc | cpp/error/dsc uncaught_exception}}
{{dsc inc | cpp/error/dsc make_exception_ptr}}
{{dsc inc | cpp/error/dsc current_exception}}
{{dsc inc | cpp/error/dsc rethrow_exception}}
{{dsc inc | cpp/error/dsc throw_with_nested}}
{{dsc inc | cpp/error/dsc rethrow_if_nested}}
{{dsc inc | cpp/error/dsc terminate}}
{{dsc inc | cpp/error/dsc get_terminate}}
{{dsc inc | cpp/error/dsc set_terminate}}
{{dsc inc | cpp/error/dsc get_unexpected}}
{{dsc inc | cpp/error/dsc set_unexpected}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    class exception;
    class bad_exception;
    class nested_exception;

    typedef void (*unexpected_handler)();
    unexpected_handler get_unexpected() noexcept;
    unexpected_handler set_unexpected(unexpected_handler f) noexcept;
    [[noreturn]] void unexpected();

    typedef void (*terminate_handler)();
    terminate_handler get_terminate() noexcept;
    terminate_handler set_terminate(terminate_handler f) noexcept;
    [[noreturn]] void terminate() noexcept;

    bool uncaught_exception() noexcept;

    typedef /*unspecified*/ exception_ptr;

    exception_ptr current_exception() noexcept;
    [[noreturn]] void rethrow_exception(exception_ptr p);
    template&lt;class E&gt; exception_ptr make_exception_ptr(E e) noexcept;

    [[noreturn]] template &lt;class T&gt; void throw_with_nested(T&amp;&amp; t);
    template &lt;class E&gt; void rethrow_if_nested(const E&amp; e);
}

}}

====Class {{lc|std::exception}}====
{{source|

class exception {
public:
    exception() noexcept;
    exception(const exception&amp;) noexcept;
    exception&amp; operator{{=}}(const exception&amp;) noexcept;
    virtual ~exception();
    virtual const char* what() const noexcept;
};

}}

====Class {{lc|std::bad_exception}}====
{{source|

class bad_exception : public exception {
public:
    bad_exception() noexcept;
    bad_exception(const bad_exception&amp;) noexcept;
    bad_exception&amp; operator{{=}}(const bad_exception&amp;) noexcept;
    virtual const char* what() const noexcept;
};

}}


====Class {{lc|std::nested_exception}}====
{{source|
class nested_exception {
public:
    nested_exception() noexcept;
    nested_exception(const nested_exception&amp;) noexcept {{=}} default;
    nested_exception&amp; operator{{=}}(const nested_exception&amp;) noexcept {{=}} default;
    virtual ~nested_exception() {{=}} default;

    // access functions
    [[noreturn]] void rethrow_nested() const;
    exception_ptr nested_ptr() const noexcept;
};
}}

===See Also===
*[[cpp/error|Error handling]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/experimental/any</title>
    <ns>0</ns>
    <id>13646</id>
    <revision>
      <id>71489</id>
      <parentid>71416</parentid>
      <timestamp>2014-06-12T00:23:31Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Updated synopsis to match draft paper.</comment>
      <text xml:space="preserve" bytes="2438">{{cpp/header/title|experimental/any}}
{{cpp/header/navbar}}

This header is part of the [[cpp/experimental|experimental]] library.

===Classes===
{{dsc begin}}
{{dsc hitem | Name | Description}}
{{dsc| {{lc|std::experimental::bad_any_cast}} {{mark since libfund ts}} | Objects of type {{tt|bad_any_cast}} are thrown by a failed {{tt|any_cast}}. {{mark class}} }}
{{dsc| {{lc|std::experimental::any}} {{mark since libfund ts}} | Objects of class {{tt|any}} hold instances of any type that satisfies the {{tt|ValueType}} requirements. {{mark class}} }}
{{dsc end}}

===Functions===

{{dsc begin}}
{{dsc inc | cpp/experimental/any/dsc swap2}}
{{dsc inc | cpp/experimental/any/dsc any_cast}}
{{dsc end}}

===Synopsis===
{{source|1=

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {

  class bad_any_cast : public bad_cast
  {
  public:
    virtual const char* what() const noexcept;
  };

  class any
  {
  public:
    // 6.3.1, any construct/destruct
    any() noexcept;

    any(const any&amp; other);
    any(any&amp;&amp; x) noexcept;

    template &lt;class ValueType&gt;
        any(ValueType&amp;&amp; value);

    template &lt;class Allocator&gt;
        any(allocator_arg_t, const Allocator&amp; a) noexcept;
    template &lt;class Allocator, class ValueType&gt;
        any(allocator_arg_t, const Allocator&amp; a, ValueType&amp;&amp; value);
    template &lt;class Allocator&gt;
        any(allocator_arg_t, const Allocator&amp; a, const any&amp; other);
    template &lt;class Allocator&gt;
        any(allocator_arg_t, const Allocator&amp; a, any&amp;&amp; other) noexcept;

    ~any();

    // 6.3.2, any assignments
    any&amp; operator=(const any&amp; rhs);
    any&amp; operator=(any&amp;&amp; rhs) noexcept;

    template &lt;class ValueType&gt;
      any&amp; operator=(ValueType&amp;&amp; rhs);

    // 6.3.3, any modifiers
    void clear() noexcept;
    void swap(any&amp; rhs) noexcept;

    // 6.3.4, any observers
    bool empty() const noexcept;
    const type_info&amp; type() const noexcept;
  };

  // 6.4, Non-member functions
  void swap(any&amp; x, any&amp; y) noexcept;

  template&lt;class ValueType&gt;
    ValueType any_cast(const any&amp; operand);
  template&lt;class ValueType&gt;
    ValueType any_cast(any&amp; operand);
  template&lt;class ValueType&gt;
    ValueType any_cast(any&amp;&amp; operand);

  template&lt;class ValueType&gt;
    const ValueType* any_cast(const any* operand) noexcept;
  template&lt;class ValueType&gt;
    ValueType* any_cast(any* operand) noexcept;

} // namespace fundamentals_v1
} // namespace experimental
} // namespace std
}}</text>
      <sha1>eng01rb8dvuwrlvi1czb3bhh0x9aq52</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/experimental/memory resource</title>
    <ns>0</ns>
    <id>13674</id>
    <revision>
      <id>71536</id>
      <timestamp>2014-06-13T04:04:04Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add page.</comment>
      <text xml:space="preserve" bytes="3393">{{cpp/header/title|experimental/memory_resource}}
{{cpp/header/navbar}}

This header is part of the [[cpp/experimental|experimental]] library.

===Classes===
{{dsc begin}}
{{dsc hitem | Name | Description}}
{{dsc| {{lc|std::experimental::pmr::memory_resource}} {{mark since libfund ts}} | Abstract interface for classes that encapsulate memory resources {{mark class}} }}
{{dsc| {{lc|std::experimental::pmr::polymorphic_allocator}} {{mark since libfund ts}} | Template class for run-time polymorphism of {{tt|Allocator}}s {{mark tclass}} }}
{{dsc| {{lc|std::experimental::pmr::resource_adaptor}} {{mark since libfund ts}} | Wraps an {{tt|Allocator}} in a {{tt|memory_resource}} {{mark|template alias}} }}
{{dsc| {{lc|std::experimental::pmr::pool_options}} {{mark since libfund ts}} | Passes options to  pool resource constructors {{mark|struct}} }}
{{dsc| {{lc|std::experimental::pmr::synchronized_pool_resource}} {{mark since libfund ts}} | Thread-safe {{tt|memory_resource}} for allocating memory in pools {{mark class}} }}
{{dsc| {{lc|std::experimental::pmr::unsynchronized_pool_resource}} {{mark since libfund ts}} | Thread-unsafe {{tt|memory_resource}} for allocating memory in pools {{mark class}} }}
{{dsc| {{lc|std::experimental::pmr::monotonic_buffer_resource}} {{mark since libfund ts}} | {{tt|memory_resource}} that allocates memory monotonically and only releases it on destruction {{mark class}} }}
{{dsc end}}

===Functions===

{{dsc begin}}
{{dsc h2 | Comparison}}
{{dsc inc | cpp/experimental/pmr/memory_resource/dsc operator_cmp}}
{{dsc inc | cpp/experimental/pmr/polymorphic_allocator/dsc operator_cmp}}

{{dsc h2 | Global memory resources}}
{{dsc inc | cpp/experimental/pmr/dsc new_delete_resource}}
{{dsc inc | cpp/experimental/pmr/dsc null_memory_resource}}

{{dsc h2 | Default memory resource}}
{{dsc inc | cpp/experimental/pmr/dsc set_default_resource}}
{{dsc end}}

===Synopsis===
{{source|1=

namespace std {
namespace experimental {
inline namespace fundamentals_v1 {
namespace pmr {

  class memory_resource;

  bool operator==(const memory_resource&amp; a,
                  const memory_resource&amp; b) noexcept;
  bool operator!=(const memory_resource&amp; a,
                  const memory_resource&amp; b) noexcept;

  template &lt;class Tp&gt; class polymorphic_allocator;

  template &lt;class T1, class T2&gt;
  bool operator==(const polymorphic_allocator&lt;T1&gt;&amp; a,
                  const polymorphic_allocator&lt;T2&gt;&amp; b) noexcept;
  template &lt;class T1, class T2&gt;
  bool operator!=(const polymorphic_allocator&lt;T1&gt;&amp; a,
                  const polymorphic_allocator&lt;T2&gt;&amp; b) noexcept;

  // The name resource_adaptor_imp is for exposition only.
  template &lt;class Allocator&gt; class resource_adaptor_imp;

  template &lt;class Allocator&gt;
    using resource_adaptor = resource_adaptor_imp&lt;
      allocator_traits&lt;Allocator&gt;::rebind_alloc&lt;char&gt;&gt;;

  // Global memory resources
  memory_resource* new_delete_resource() noexcept;
  memory_resource* null_memory_resource() noexcept;

  // The default memory resource
  memory_resource* set_default_resource(memory_resource* r) noexcept;
  memory_resource* get_default_resource() noexcept;

  // Standard memory resources
  struct pool_options;
  class synchronized_pool_resource;
  class unsynchronized_pool_resource;
  class monotonic_buffer_resource;

} // namespace pmr
} // namespace fundamentals_v1
} // namespace experimental
} // namespace std
}}</text>
      <sha1>ok57m2majc72tm93wp42r1kbar94yr0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/experimental/optional</title>
    <ns>0</ns>
    <id>13666</id>
    <revision>
      <id>71487</id>
      <parentid>71461</parentid>
      <timestamp>2014-06-12T00:19:35Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Updated synopsis to match draft paper.</comment>
      <text xml:space="preserve" bytes="4763">{{cpp/header/title|experimental/optional}}
{{cpp/header/navbar}}

This header is part of the [[cpp/experimental|experimental]] library.

===Classes===
{{dsc begin}}
{{dsc hitem | Name | Description}}
{{dsc| {{lc|std::experimental::optional}} {{mark since libfund ts}} | Class template representing a value that may or may not be present {{mark tclass}} }}
{{dsc| {{lc|std::experimental::emplace_t}} {{mark since libfund ts}} | Tag used for in-place construction {{mark|struct}} }}
{{dsc| {{lc|std::experimental::nullopt_t}} {{mark since libfund ts}} | Tag used to indicate disengaged state {{mark|struct}} }}
{{dsc| {{lc|std::experimental::bad_optional_access}} {{mark since libfund ts}} | Exception thrown when attempting to access a disengaged value {{mark class}} }}
{{dsc| {{c|std::hash&lt;std::experimental::optional&lt;T&gt;&gt;}} {{mark since libfund ts}} | {{mark ptclass}} }}
{{dsc end}}

===Functions===

{{dsc begin}}

{{dsc h2 | Comparison}}
{{dsc inc | cpp/experimental/optional/dsc operator_cmp}}

{{dsc h2 | Specialized algorithms}}
{{dsc inc | cpp/experimental/optional/dsc swap2}}
{{dsc inc | cpp/experimental/optional/dsc make_optional}}

{{dsc h2 | Hash support}}
{{dsc end}}

===Synopsis===
{{source|1=

namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    // 5.4, optional for object types
    template &lt;class T&gt; class optional;

    // 5.5, In-place construction
    struct in_place_t{};
    constexpr in_place_t in_place{};

    // 5.6, Disengaged state indicator
    struct nullopt_t{see below};
    constexpr nullopt_t nullopt(unspecified);

    // 5.7, Class bad_optional_access
    class bad_optional_access;

    // 5.8, Relational operators
    template &lt;class T&gt;
      constexpr bool operator==(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt;
      constexpr bool operator!=(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt;
      constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt;
      constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt;
      constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt;
      constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);

    // 5.9, Comparison with nullopt
    template &lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator==(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator!=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator&lt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator&lt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator&gt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool operator&gt;=(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;

    // 5.10, Comparison with T
    template &lt;class T&gt; constexpr bool operator==(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator==(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator!=(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator!=(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;=(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;=(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&gt;(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator&gt;(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&gt;=(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator&gt;=(const T&amp;, const optional&lt;T&gt;&amp;);

    // 5.11, Specialized algorithms
    template &lt;class T&gt; void swap(optional&lt;T&gt;&amp;, optional&lt;T&gt;&amp;) noexcept(see below);
    template &lt;class T&gt; constexpr optional&lt;see below&gt; make_optional(T&amp;&amp;);

  } // namespace fundamentals_v1
  } // namespace experimental

  // 5.12, Hash support
  template &lt;class T&gt; struct hash;
  template &lt;class T&gt; struct hash&lt;experimental::optional&lt;T&gt;&gt;;

} // namespace std
}}</text>
      <sha1>5s3v4859bdtesi14jttkeg76nb20au8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/experimental/string view</title>
    <ns>0</ns>
    <id>13645</id>
    <revision>
      <id>71500</id>
      <parentid>71382</parentid>
      <timestamp>2014-06-12T01:46:24Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Updated synopsis to match draft paper.</comment>
      <text xml:space="preserve" bytes="3920">{{cpp/header/title|experimental/string_view}}
{{cpp/header/navbar}}

This header is part of the [[cpp/experimental|experimental]] library.

===Classes===
{{dsc begin}}
{{dsc hitem | Name | Description}}
{{dsc| {{lc|std::experimental::basic_string_view}} {{mark since libfund ts}} | Class template representing a reference to a character string {{mark tclass}} }}
{{dsc| {{lc|std::experimental::string_view}} {{mark since libfund ts}} | {{c|std::experimental::basic_string_view&lt;char&gt;}} {{mark typedef}} }}
{{dsc | {{lc|std::experimental::wstring_view}} {{mark since libfund ts}} | {{c|std::experimental::basic_string_view&lt;wchar_t&gt;}} {{mark typedef}} }}
{{dsc | {{lc|std::experimental::u16string_view}} {{mark since libfund ts}} | {{c|std::experimental::basic_string_view&lt;char16_t&gt;}}  {{mark typedef}} }}
{{dsc | {{lc|std::experimental::u32string_view}} {{mark since libfund ts}} | {{c|std::experimental::basic_string_view&lt;char32_t&gt;}} {{mark typedef}}}}

{{dsc | {{c|std::hash&lt;std::experimental::string_view&gt;}} {{mark since libfund ts}} | {{mark ptclass}} }}
{{dsc | {{c|std::hash&lt;std::experimental::u16string_view&gt;}} {{mark since libfund ts}} | {{mark ptclass}} }}
{{dsc | {{c|std::hash&lt;std::experimental::u32string_view&gt;}} {{mark since libfund ts}} | {{mark ptclass}}}}
{{dsc | {{c|std::hash&lt;std::experimental::wstring_view&gt;}}  {{mark since libfund ts}} | {{mark ptclass}}}}
{{dsc end}}

===Functions===

{{dsc begin}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_cmp}}

{{dsc h2 | Output}}
{{dsc inc | cpp/experimental/basic_string_view/dsc operator_ltlt}}
{{dsc end}}

===Synopsis===
{{source|1=

namespace std {
  namespace experimental {
  inline namespace fundamentals_v1 {

    // 7.2, Class template basic_string_view
    template&lt;class charT, class traits = char_traits&lt;charT&gt;&gt;
        class basic_string_view;

    // 7.9, basic_string_view non-member comparison functions
    template&lt;class charT, class traits&gt;
    constexpr bool operator==(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept;
    template&lt;class charT, class traits&gt;
    constexpr bool operator!=(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept;
    template&lt;class charT, class traits&gt;
    constexpr bool operator&lt; (basic_string_view&lt;charT, traits&gt; x,
                                 basic_string_view&lt;charT, traits&gt; y) noexcept;
    template&lt;class charT, class traits&gt;
    constexpr bool operator&gt; (basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept;
    template&lt;class charT, class traits&gt;
    constexpr bool operator&lt;=(basic_string_view&lt;charT, traits&gt; x,
                                 basic_string_view&lt;charT, traits&gt; y) noexcept;
    template&lt;class charT, class traits&gt;
    constexpr bool operator&gt;=(basic_string_view&lt;charT, traits&gt; x,
                              basic_string_view&lt;charT, traits&gt; y) noexcept;
    // see below, sufficient additional overloads of comparison functions

    // 7.10, Inserters and extractors
    template&lt;class charT, class traits&gt;
      basic_ostream&lt;charT, traits&gt;&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
                   basic_string_view&lt;charT, traits&gt; str);

    // basic_string_view typedef names
    typedef basic_string_view&lt;char&gt; string_view;
    typedef basic_string_view&lt;char16_t&gt; u16string_view;
    typedef basic_string_view&lt;char32_t&gt; u32string_view;
    typedef basic_string_view&lt;wchar_t&gt; wstring_view;

  }  // namespace fundamentals_v1
  }  // namespace experimental

  // 7.11, Hash support
  template &lt;class T&gt; struct hash;
  template &lt;&gt; struct hash&lt;experimental::string_view&gt;;
  template &lt;&gt; struct hash&lt;experimental::u16string_view&gt;;
  template &lt;&gt; struct hash&lt;experimental::u32string_view&gt;;
  template &lt;&gt; struct hash&lt;experimental::wstring_view&gt;;

}  // namespace std
}}</text>
      <sha1>6q0dcc7ollgrhexdciqoylfvjtwvye8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/forward list</title>
    <ns>0</ns>
    <id>9676</id>
    <revision>
      <id>57482</id>
      <parentid>49571</parentid>
      <timestamp>2013-06-01T05:54:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="6616">{{cpp/header/title|forward_list}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc forward_list}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | forward_list}}
{{dsc inc | cpp/container/dsc swap2 | forward_list}}
{{dsc end}}


===Synopsis===
{{source|

namespace std {
    
#include &lt;initializer_list&gt;

template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt; class forward_list;

template &lt;class T, class Allocator&gt;
    bool operator{{=}}{{=}}(const forward_list&lt;T,Allocator&gt;&amp; x, 
                            const forward_list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&lt; (const forward_list&lt;T,Allocator&gt;&amp; x, 
                    const forward_list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator!{{=}}(const forward_list&lt;T,Allocator&gt;&amp; x, 
                        const forward_list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&gt; (const forward_list&lt;T,Allocator&gt;&amp; x, 
                    const forward_list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&gt;{{=}}(const forward_list&lt;T,Allocator&gt;&amp; x, 
                        const forward_list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&lt;{{=}}(const forward_list&lt;T,Allocator&gt;&amp; x, 
                        const forward_list&lt;T,Allocator&gt;&amp; y);

template &lt;class T, class Allocator&gt;
    void swap(forward_list&lt;T,Allocator&gt;&amp; x, forward_list&lt;T,Allocator&gt;&amp; y);

}

}}

====Class {{lc|std::list}}====
{{source|

template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt;
class forward_list {
public:
    // types:
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef T                                                   value_type;
    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    
    // construct/copy/destroy:
    explicit forward_list(const Allocator&amp; {{=}} Allocator());
    explicit forward_list(size_type n);
    forward_list(size_type n, const T&amp; value,const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        forward_list(InputIterator first, InputIterator last,
                     const Allocator&amp; {{=}} Allocator());
    forward_list(const forward_list&lt;T,Allocator&gt;&amp; x);
    forward_list(forward_list&amp;&amp;);
    forward_list(const forward_list&amp;, const Allocator&amp;);
    forward_list(forward_list&amp;&amp;, const Allocator&amp;);
    forward_list(initializer_list&lt;T&gt;, const Allocator&amp; {{=}} Allocator());
    
    ~forward_list();
    forward_list&lt;T,Allocator&gt;&amp; operator{{=}}(const forward_list&lt;T,Allocator&gt;&amp; x);
    forward_list&lt;T,Allocator&gt;&amp; operator{{=}}(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
    forward_list&amp; operator{{=}}(initializer_list&lt;T&gt;);
    template &lt;class InputIterator&gt;
        void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const T&amp; t);
    void assign(initializer_list&lt;T&gt;);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                before_begin() noexcept;
    const_iterator          before_begin() const noexcept;
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cbefore_begin() const noexcept;
    const_iterator          cend() noexcept;
    
    // capacity:
    size_type max_size() const noexcept;
    bool      empty() const noexcept;
    
    // element access:
    reference       front();
    const_reference front() const;
    
    // modifiers:
    template &lt;class... Args&gt; void emplace_front(Args&amp;&amp;... args);
    
    void push_front(const T&amp; x);
    void push_front(T&amp;&amp; x);
    void pop_front();
    
    template &lt;class... Args&gt; 
        iterator emplace_after(const_iterator position, Args&amp;&amp;... args);
    iterator insert_after(const_iterator position, const T&amp; x);
    iterator insert_after(const_iterator position, T&amp;&amp; x);
    
    iterator insert_after(const_iterator position, size_type n, const T&amp; x);
    template &lt;class InputIterator&gt;
        iterator insert_after(const_iterator position, InputIterator first, 
                              InputIterator last);
    iterator insert_after(const_iterator position, initializer_list&lt;T&gt; il);

    iterator erase_after(const_iterator position);
    iterator erase_after(const_iterator position, iterator last);
    void swap(forward_list&lt;T,Allocator&gt;&amp;);
    
    void resize(size_type sz);
    void resize(size_type sz, const value_type&amp; c);
    void clear() noexcept;
    
    // forward_list operations:
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x);
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x);
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x,
                    const_iterator i);
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x,
                    const_iterator i);
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp; x,
                    const_iterator first, const_iterator last);
    void splice_after(const_iterator position, forward_list&lt;T,Allocator&gt;&amp;&amp; x,
                    const_iterator first, const_iterator last);

    void remove(const T&amp; value);
    template &lt;class Predicate&gt; void remove_if(Predicate pred);

    void unique();
    template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate binary_pred);

    void merge(forward_list&lt;T,Allocator&gt;&amp; x);
    void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x);
    template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp; x, Compare comp);
    template &lt;class Compare&gt; void merge(forward_list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);

    void sort();
    template &lt;class Compare&gt; void sort(Compare comp);
    void reverse() noexcept;
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/fstream</title>
    <ns>0</ns>
    <id>12850</id>
    <revision>
      <id>63992</id>
      <timestamp>2013-08-06T00:38:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="7897">{{cpp/header/title|fstream}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/Output]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc tclass | cpp/io/basic_filebuf | implements raw file device}}
{{dsc tclass | cpp/io/basic_ifstream | implements high-level file stream input operations}}
{{dsc tclass | cpp/io/basic_ofstream | implements high-level file stream output operations}}
{{dsc tclass | cpp/io/basic_fstream | implements high-level file stream input/output}}
{{dsc h1|Typedefs}}
{{dsc | {{tt|filebuf}} | {{c|basic_filebuf&lt;char&gt;}}}}
{{dsc | {{tt|wfilebuf}} | {{c|basic_filebuf&lt;wchar_t&gt;}}}}
{{dsc | {{tt|ifstream}} | {{c|basic_ifstream&lt;char&gt;}}}}
{{dsc | {{tt|wifstream}} | {{c|basic_ifstream&lt;wchar_t&gt;}}}}
{{dsc | {{tt|ofstream}} | {{c|basic_ofstream&lt;char&gt;}}}}
{{dsc | {{tt|wofstream}} | {{c|basic_ofstream&lt;wchar_t&gt;}}}}
{{dsc | {{tt|fstream}} | {{c|basic_fstream&lt;char&gt;}}}}
{{dsc | {{tt|wfstream}} | {{c|basic_fstream&lt;wchar_t&gt;}}}}
{{dsc h1|Functions}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap2}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_fstream}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
    class basic_filebuf;
typedef basic_filebuf&lt;char&gt; filebuf;
typedef basic_filebuf&lt;wchar_t&gt; wfilebuf;
template &lt;class charT, class traits&gt;
    void swap(basic_filebuf&lt;charT, traits&gt;&amp; x,
              basic_filebuf&lt;charT, traits&gt;&amp; y);

template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
    class basic_ifstream;
typedef basic_ifstream&lt;char&gt; ifstream;
typedef basic_ifstream&lt;wchar_t&gt; wifstream;
template &lt;class charT, class traits&gt;
    void swap(basic_ifstream&lt;charT, traits&gt;&amp; x,
              basic_ifstream&lt;charT, traits&gt;&amp; y);

template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
    class basic_ofstream;
typedef basic_ofstream&lt;char&gt; ofstream;
typedef basic_ofstream&lt;wchar_t&gt; wofstream;
template &lt;class charT, class traits&gt;
    void swap(basic_ofstream&lt;charT, traits&gt;&amp; x,
              basic_ofstream&lt;charT, traits&gt;&amp; y);

template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
    class basic_fstream;
typedef basic_fstream&lt;char&gt; fstream;
typedef basic_fstream&lt;wchar_t&gt; wfstream;
template &lt;class charT, class traits&gt;
    void swap(basic_fstream&lt;charT, traits&gt;&amp; x,
              basic_fstream&lt;charT, traits&gt;&amp; y);
}
}}

====Class {{lc|std::basic_filebuf}}====
{{source|1=
template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    // Constructors/destructor:
    basic_filebuf();
    basic_filebuf(const basic_filebuf&amp; rhs) = delete;
    basic_filebuf(basic_filebuf&amp;&amp; rhs);
    virtual ~basic_filebuf();

    // Assign/swap:
    basic_filebuf&amp; operator=(const basic_filebuf&amp; rhs) = delete;
    basic_filebuf&amp; operator=(basic_filebuf&amp;&amp; rhs);
    void swap(basic_filebuf&amp; rhs);

    // Members:
    bool is_open() const;
    basic_filebuf&lt;charT,traits&gt;* open(const char* s, ios_base::openmode mode);
    basic_filebuf&lt;charT,traits&gt;* open(const string&amp; s, ios_base::openmode mode);
    basic_filebuf&lt;charT,traits&gt;* close();

 protected:
    // Overridden virtual functions:
    virtual streamsize showmanyc();
    virtual int_type underflow();
    virtual int_type uflow();
    virtual int_type pbackfail(int_type c = traits::eof());
    virtual int_type overflow (int_type c = traits::eof());
    virtual basic_streambuf&lt;charT,traits&gt;* setbuf(char_type* s, streamsize n);
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual int sync();
    virtual void imbue(const locale&amp; loc);
};
}}

====Class {{lc|std::basic_ifstream}}====
{{source|1=
template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
class basic_ifstream : public basic_istream&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    // Constructors:
    basic_ifstream();
    explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in);
    explicit basic_ifstream(const string&amp; s, ios_base::openmode mode = ios_base::in);
    basic_ifstream(const basic_ifstream&amp; rhs) = delete;
    basic_ifstream(basic_ifstream&amp;&amp; rhs);

    // Assign/swap:
    basic_ifstream&amp; operator=(const basic_ifstream&amp; rhs) = delete;
    basic_ifstream&amp; operator=(basic_ifstream&amp;&amp; rhs);
    void swap(basic_ifstream&amp; rhs);

    // Members:
    basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
    bool is_open() const;
    void open(const char* s, ios_base::openmode mode = ios_base::in);
    void open(const string&amp; s, ios_base::openmode mode = ios_base::in);
    void close();

 private:
    basic_filebuf&lt;charT,traits&gt; sb; // exposition only
};
}}

====Class {{lc|std::basic_ofstream}}====
{{source|1=
template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    // Constructors:
    basic_ofstream();
    explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out);
    explicit basic_ofstream(const string&amp; s, ios_base::openmode mode = ios_base::out);
    basic_ofstream(const basic_ofstream&amp; rhs) = delete;
    basic_ofstream(basic_ofstream&amp;&amp; rhs);

    // Assign/swap:
    basic_ofstream&amp; operator=(const basic_ofstream&amp; rhs) = delete;
    basic_ofstream&amp; operator=(basic_ofstream&amp;&amp; rhs);
    void swap(basic_ofstream&amp; rhs);

    // Members:
    basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
    bool is_open() const;
    void open(const char* s, ios_base::openmode mode = ios_base::out);
    void open(const string&amp; s, ios_base::openmode mode = ios_base::out);
    void close();

 private:
    basic_filebuf&lt;charT,traits&gt; sb; // exposition only
};
}}

====Class {{lc|std::basic_fstream}}====
{{source|1=
template &lt;class charT, class traits=char_traits&lt;charT&gt; &gt;
class basic_fstream : public basic_iostream&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    // constructors/destructor
    basic_fstream();
    explicit basic_fstream(const char* s,
                           ios_base::openmode mode = ios_base::in{{!}}ios_base::out);
    explicit basic_fstream(const string&amp; s,
                           ios_base::openmode mode = ios_base::in{{!}}ios_base::out);
    basic_fstream(const basic_fstream&amp; rhs) = delete;
    basic_fstream(basic_fstream&amp;&amp; rhs);

    // Assign/swap:
    basic_fstream&amp; operator=(const basic_fstream&amp; rhs) = delete;
    basic_fstream&amp; operator=(basic_fstream&amp;&amp; rhs);
    void swap(basic_fstream&amp; rhs);

    // Members:
    basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
    bool is_open() const;
    void open(const char* s,
              ios_base::openmode mode = ios_base::in{{!}}ios_base::out);
    void open(const string&amp; s,
              ios_base::openmode mode = ios_base::in{{!}}ios_base::out);
    void close();

 private:
    basic_filebuf&lt;charT,traits&gt; sb; // exposition only
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/functional</title>
    <ns>0</ns>
    <id>9770</id>
    <revision>
      <id>57485</id>
      <parentid>49572</parentid>
      <timestamp>2013-06-01T05:54:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="15258">{{cpp/header/title|functional}}
{{cpp/header/navbar}}

This header is part of the [[cpp/utility/functional|function objects]] library and provides the standard [[cpp/utility/hash|hash function]].

===Namespaces===
{{dsc begin}}
{{dsc|[[cpp/utility/functional/placeholders|placeholders]] | Defines placeholders for the unbound arguments in a std::bind expression  }}
{{dsc h2|Constants}}
{{dsc namespace | std::placeholders }}
{{dsc inc | cpp/utility/functional/dsc placeholders}}
{{dsc end}}

===Classes===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc mem_fn}}
{{dsc inc | cpp/utility/functional/dsc bad_function_call}}
{{dsc inc | cpp/utility/functional/dsc is_bind_expression}}
{{dsc inc | cpp/utility/functional/dsc is_placeholder}}
{{dsc inc | cpp/utility/functional/dsc reference_wrapper}}

{{dsc h2|Hashing}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc|{{c|
template&lt;&gt; struct hash&lt;bool&gt;;
template&lt;&gt; struct hash&lt;char&gt;;
template&lt;&gt; struct hash&lt;signed char&gt;;
template&lt;&gt; struct hash&lt;unsigned char&gt;;
template&lt;&gt; struct hash&lt;char16_t&gt;;
template&lt;&gt; struct hash&lt;char32_t&gt;;
template&lt;&gt; struct hash&lt;wchar_t&gt;;
template&lt;&gt; struct hash&lt;short&gt;;
template&lt;&gt; struct hash&lt;unsigned short&gt;;
template&lt;&gt; struct hash&lt;int&gt;;
template&lt;&gt; struct hash&lt;unsigned int&gt;;
template&lt;&gt; struct hash&lt;long&gt;;
template&lt;&gt; struct hash&lt;long long&gt;;
template&lt;&gt; struct hash&lt;unsigned long&gt;;
template&lt;&gt; struct hash&lt;unsigned long long&gt;;
template&lt;&gt; struct hash&lt;float&gt;;
template&lt;&gt; struct hash&lt;double&gt;;
template&lt;&gt; struct hash&lt;long double&gt;;
template&lt; class T &gt; struct hash&lt;T*&gt;;
}} | {{lc|std::hash}} specializations for built-in types &lt;br&gt; {{mark ptclass}} }}

{{dsc end}}



===Functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc inc | cpp/utility/functional/dsc ref}}
{{dsc end}}


===Function Objects===

{{dsc begin}}
{{dsc h2 | Arithmetic operations}}
{{dsc inc | cpp/utility/functional/dsc plus}}
{{dsc inc | cpp/utility/functional/dsc minus}}
{{dsc inc | cpp/utility/functional/dsc multiplies}}
{{dsc inc | cpp/utility/functional/dsc divides}}
{{dsc inc | cpp/utility/functional/dsc modulus}}
{{dsc inc | cpp/utility/functional/dsc negate}}

{{dsc h2 | Comparisons }}
{{dsc inc | cpp/utility/functional/dsc equal_to}}
{{dsc inc | cpp/utility/functional/dsc not_equal_to}}
{{dsc inc | cpp/utility/functional/dsc greater}}
{{dsc inc | cpp/utility/functional/dsc less}}
{{dsc inc | cpp/utility/functional/dsc greater_equal}}
{{dsc inc | cpp/utility/functional/dsc less_equal}}

{{dsc h2 | Logical operations }}
{{dsc inc | cpp/utility/functional/dsc logical_and}}
{{dsc inc | cpp/utility/functional/dsc logical_or}}
{{dsc inc | cpp/utility/functional/dsc logical_not}}

{{dsc h2 | Bitwise operations }}
{{dsc inc | cpp/utility/functional/dsc bit_and}}
{{dsc inc | cpp/utility/functional/dsc bit_or}}
{{dsc inc | cpp/utility/functional/dsc bit_xor}}

{{dsc h2 | Negators }}
{{dsc inc | cpp/utility/functional/dsc unary_negate}}
{{dsc inc | cpp/utility/functional/dsc binary_negate}}
{{dsc inc | cpp/utility/functional/dsc not1}}
{{dsc inc | cpp/utility/functional/dsc not2}}
{{dsc end}}

===Deprecated in C++11===

{{dsc begin}}
{{dsc h2 | Base}}
{{dsc inc | cpp/utility/functional/dsc unary_function}}
{{dsc inc | cpp/utility/functional/dsc binary_function}}

{{dsc h2 | Binders}}
{{dsc inc | cpp/utility/functional/dsc binder12}}
{{dsc inc | cpp/utility/functional/dsc bind12}}

{{dsc h2 | Function adaptors}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_unary_function}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_binary_function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_t}}
{{dsc inc | cpp/utility/functional/dsc mem_fun}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref_t}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    
    // base (deprecated):
    template &lt;class Arg, class Result&gt; struct unary_function;
    template &lt;class Arg1, class Arg2, class Result&gt; struct binary_function;

    // reference_wrapper:
    template &lt;class T&gt; class reference_wrapper;
    template &lt;class T&gt; reference_wrapper&lt;T&gt; ref(T&amp;) noexcept;
    template &lt;class T&gt; reference_wrapper&lt;const T&gt; cref(const T&amp;) noexcept;
    template &lt;class T&gt; void ref(const T&amp;&amp;) {{=}} delete;
    template &lt;class T&gt; void cref(const T&amp;&amp;) {{=}} delete;
    template &lt;class T&gt; reference_wrapper&lt;T&gt; ref(reference_wrapper&lt;T&gt;) noexcept;
    template &lt;class T&gt; reference_wrapper&lt;const T&gt; cref(reference_wrapper&lt;T&gt;) noexcept;

    // arithmetic operations:
    template &lt;class T&gt; struct plus;
    template &lt;class T&gt; struct minus;
    template &lt;class T&gt; struct multiplies;
    template &lt;class T&gt; struct divides;
    template &lt;class T&gt; struct modulus;
    template &lt;class T&gt; struct negate;

    // comparisons:
    template &lt;class T&gt; struct equal_to;
    template &lt;class T&gt; struct not_equal_to;
    template &lt;class T&gt; struct greater;
    template &lt;class T&gt; struct less;
    template &lt;class T&gt; struct greater_equal;
    template &lt;class T&gt; struct less_equal;

    // logical operations:
    template &lt;class T&gt; struct logical_and;
    template &lt;class T&gt; struct logical_or;
    template &lt;class T&gt; struct logical_not;

    // bitwise operations:
    template &lt;class T&gt; struct bit_and;
    template &lt;class T&gt; struct bit_or;
    template &lt;class T&gt; struct bit_xor;

    // negators:
    template &lt;class Predicate&gt; class unary_negate;
    template &lt;class Predicate&gt;
        unary_negate&lt;Predicate&gt; 
        not1(const Predicate&amp;);
    template &lt;class Predicate&gt;  class binary_negate;
    template &lt;class Predicate&gt;
        binary_negate&lt;Predicate&gt;
        not2(const Predicate&amp;);
        
    // bind:
    template&lt;class T&gt; struct is_bind_expression;
    template&lt;class T&gt; struct is_placeholder;
    template&lt;class  F, class... BoundArgs&gt;
        /*unspecified*/ bind(F&amp;&amp;, BoundArgs&amp;&amp;...);
    template&lt;class  R, class F, class... BoundArgs&gt;
        /*unspecified*/ bind(F&amp;&amp;, BoundArgs&amp;&amp;...);

    namespace placeholders {
        // M is the implementation-defined number of placeholders
        extern /*unspecified*/ _1;
        extern /*unspecified*/ _2;
        .
        .
        .
        extern /*unspecified*/ _M;
    }

    // binders (deprecated):
    template &lt;class Fn&gt; class binder1st;
    template &lt;class Fn, class T&gt;
        binder1st&lt;Fn&gt; bind1st(const Fn&amp;, const T&amp;);
    template &lt;class Fn&gt; class binder2nd;
    template &lt;class Fn, class T&gt;
        binder2nd&lt;Fn&gt; bind2nd(const Fn&amp;, const T&amp;);

    // adaptors (deprecated):
    template &lt;class Arg, class Result&gt; class pointer_to_unary_function;
    template &lt;class Arg, class Result&gt;
        pointer_to_unary_function&lt;Arg,Result&gt; ptr_fun(Result (*)(Arg));
    template &lt;class Arg1, class Arg2, class Result&gt;
        class pointer_to_binary_function;
    template &lt;class Arg1, class Arg2, class Result&gt;
        pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;
        ptr_fun(Result (*)(Arg1,Arg2));
        
    // adaptors (deprecated):
    template&lt;class S, class T&gt; class mem_fun_t;
    template&lt;class S, class T, class A&gt; class mem_fun1_t;
    template&lt;class S, class T&gt;
        mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)());
    template&lt;class S, class T, class A&gt;
        mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A));
    template&lt;class S, class T&gt; class mem_fun_ref_t;
    template&lt;class S, class T, class A&gt; class mem_fun1_ref_t;
    template&lt;class S, class T&gt;
        mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)());
    template&lt;class S, class T, class A&gt;
        mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A));
    template &lt;class S, class T&gt; class const_mem_fun_t;
    template &lt;class S, class T, class A&gt; class const_mem_fun1_t;
    template &lt;class S, class T&gt;
        const_mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)() const);
    template &lt;class S, class T, class A&gt;
        const_mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A) const);
    template &lt;class S, class T&gt; class const_mem_fun_ref_t;
    template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t;
    template &lt;class S, class T&gt;
        const_mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)() const);
    template &lt;class S, class T, class A&gt;
        const_mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A) const);
        
    // member function adaptors:
    template&lt;class R, class T&gt; /*unspecified*/ mem_fn(R T::*);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...));
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) &amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const &amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) &amp;&amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const &amp;&amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) volatile &amp;&amp;);
    template&lt;class R, class T, class... Args&gt;
        /*unspecified*/ mem_fn(R (T::*)(Args...) const volatile &amp;&amp;);

    // polymorphic function wrappers:
    class bad_function_call;
    template&lt;class&gt; class function; // undefined
    template&lt;class R, class... ArgTypes&gt; class function&lt;R(ArgTypes...)&gt;;
    template&lt;class R, class... ArgTypes&gt;
        void swap(function&lt;R(ArgTypes...)&gt;&amp;, function&lt;R(ArgTypes...)&gt;&amp;);
    template&lt;class R, class... ArgTypes&gt;
        bool operator{{=}}{{=}}(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t);
    template&lt;class R, class... ArgTypes&gt;
        bool operator{{=}}{{=}}(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;);
    template&lt;class R, class... ArgTypes&gt;
        bool operator!{{=}}(const function&lt;R(ArgTypes...)&gt;&amp;, nullptr_t);
    template&lt;class R, class... ArgTypes&gt;
        bool operator!{{=}}(nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp;);

    // hash function base template:
    template &lt;class T&gt; struct hash;

    // Hash function specializations
    template &lt;&gt; struct hash&lt;bool&gt;;
    template &lt;&gt; struct hash&lt;char&gt;;
    template &lt;&gt; struct hash&lt;signed char&gt;;
    template &lt;&gt; struct hash&lt;unsigned char&gt;;
    template &lt;&gt; struct hash&lt;char16_t&gt;;
    template &lt;&gt; struct hash&lt;char32_t&gt;;
    template &lt;&gt; struct hash&lt;wchar_t&gt;;
    template &lt;&gt; struct hash&lt;short&gt;;
    template &lt;&gt; struct hash&lt;unsigned short&gt;;
    template &lt;&gt; struct hash&lt;int&gt;;
    template &lt;&gt; struct hash&lt;unsigned int&gt;;
    template &lt;&gt; struct hash&lt;long&gt;;
    template &lt;&gt; struct hash&lt;long long&gt;;
    template &lt;&gt; struct hash&lt;unsigned long&gt;;
    template &lt;&gt; struct hash&lt;unsigned long long&gt;;
    template &lt;&gt; struct hash&lt;float&gt;;
    template &lt;&gt; struct hash&lt;double&gt;;
    template &lt;&gt; struct hash&lt;long double&gt;;
    template&lt;class T&gt; struct hash&lt;T*&gt;;
    
}


}}


====Class {{lc|std::reference_wrapper}}====
{{source|

template &lt;class T&gt; class reference_wrapper {
public :
    // types
    typedef T type;
    typedef /*Return type of T*/     result_type;          // not always defined
    typedef /*Single argument of T*/ argument_type;        // not always defined
    typedef /*1st argument of T*/    first_argument_type;  // not always defined
    typedef /*2nd argument of T*/    second_argument_type; // not always defined

    // construct/copy/destroy
    reference_wrapper(T&amp;) noexcept;
    reference_wrapper(T&amp;&amp;) {{=}} delete;

    // do not bind to temporary objects
    reference_wrapper(const reference_wrapper&lt;T&gt;&amp; x) noexcept;

    // assignment
    reference_wrapper&amp; operator{{=}}(const reference_wrapper&lt;T&gt;&amp; x) noexcept;

    // access
    operator T&amp; () const noexcept;
    T&amp; get() const noexcept;

    // invocation
    template &lt;class... ArgTypes&gt;
        typename result_of&lt;T&amp;(ArgTypes&amp;&amp;...)&gt;::type
        operator() (ArgTypes&amp;&amp;...) const;

};

}}

====Class {{lc|std::is_bind_expression}}====
{{source|

template&lt;class T&gt; struct is_bind_expression
    : integral_constant&lt;bool, /*true|false*/&gt; { };

}}


====Class {{lc|std::bad_function_call}}====
{{source|

class bad_function_call : public std::exception {
public:
    // constructor:
    bad_function_call() noexcept;
};

}}

====Class {{lc|std::function}}====
{{source|
template&lt;class&gt; class function; // undefined

template&lt;class R, class... ArgTypes&gt;
class function&lt;R(ArgTypes...)&gt; {
public:
    typedef R result_type;      
    typedef T1 argument_type;       //  iff sizeof...(ArgTypes) {{=}}{{=}} 1 and
                                    //  the type in ArgTypes is T1
    typedef T1 first_argument_type; //  iff sizeof...(ArgTypes) {{=}}{{=}} 2 and
                                    //  ArgTypes contains T1 and T2
    typedef T2 second_argument_type;//  iff sizeof...(ArgTypes) {{=}}{{=}} 2 and
                                    //  ArgTypes contains T1 and T2

    // construct/copy/destroy:
    function() noexcept;
    function(nullptr_t) noexcept;
    function(const function&amp;);
    function(function&amp;&amp;);

    template&lt;class F&gt; function(F);
    template&lt;class A&gt; function(allocator_arg_t, const A&amp;) noexcept;
    template&lt;class A&gt; function(allocator_arg_t, const A&amp;, nullptr_t) noexcept;
    template&lt;class A&gt; function(allocator_arg_t, const A&amp;, const function&amp;);
    template&lt;class A&gt; function(allocator_arg_t, const A&amp;, function&amp;&amp;);
    template&lt;class F, class A&gt; function(allocator_arg_t, const A&amp;, F);

    function&amp; operator{{=}}(const function&amp;);
    function&amp; operator{{=}}(function&amp;&amp;);
    function&amp; operator{{=}}(nullptr_t);
    template&lt;class F&gt; function&amp; operator{{=}}(F&amp;&amp;);
    template&lt;class F&gt; function&amp; operator{{=}}(reference_wrapper&lt;F&gt;) noexcept;

    ~function();

    // function modifiers:
    void swap(function&amp;) noexcept;
    template&lt;class F, class A&gt; void assign(F&amp;&amp;, const A&amp;);

    // function capacity:
    explicit operator bool() const noexcept;

    // function invocation:
    R operator()(ArgTypes...) const;

    // function target access:
    const std::type_info&amp; target_type() const noexcept;
    template &lt;typename T&gt;       T* target() noexcept;
    template &lt;typename T&gt; const T* target() const noexcept;

};

}}


===See Also===
{{dsc begin}}
{{dsc|{{header|string}}|Specializes {{lc|std::hash}} for {{lc|std::string}}, {{lc|std::u16string}},  {{lc|std::u32string}},  {{lc|std::wstring}} }}
{{dsc|{{header|system_error}}|Specializes {{lc|std::hash}} for {{lc|std::error_code}} }}
{{dsc|{{header|bitset}}|Specializes {{lc|std::hash}} for {{lc|std::bitset}} }}
{{dsc|{{header|memory}}|Specializes {{lc|std::hash}} for {{lc|std::unique_ptr}}, {{lc|std::shared_ptr}} }}
{{dsc|{{header|typeindex}}|Specializes {{lc|std::hash}} for {{lc|std::type_index}} }}
{{dsc|{{header|vector}}|Specializes {{lc|std::hash}} for {{c|std::vector&lt;bool&gt;}} }}
{{dsc|{{header|thread}}|Specializes {{lc|std::hash}} for {{lc|std::thread::id}} }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/future</title>
    <ns>0</ns>
    <id>12863</id>
    <revision>
      <id>65915</id>
      <parentid>64008</parentid>
      <timestamp>2013-10-15T04:28:12Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6367">{{cpp/header/title|future}}
{{cpp/header/navbar}}
This header is part of the [[cpp/thread|thread support]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/thread/dsc promise}}
{{dsc inc | cpp/thread/dsc packaged_task}}
{{dsc inc | cpp/thread/dsc future}}
{{dsc inc | cpp/thread/dsc shared_future}}
{{dsc inc | cpp/thread/dsc launch}}
{{dsc inc | cpp/thread/dsc future_status}}
{{dsc inc | cpp/thread/dsc future_error}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc inc | cpp/thread/promise/dsc uses_allocator}}
{{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}}
{{dsc h1|Functions}}
{{dsc inc | cpp/thread/dsc async}}
{{dsc inc | cpp/thread/dsc future_category}}
{{dsc inc | cpp/thread/promise/dsc swap2}}
{{dsc inc | cpp/thread/packaged_task/dsc swap2}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    enum class future_errc {
        broken_promise = /*implementation-defined*/,
        future_already_retrieved = /*implementation-defined*/,
        promise_already_satisfied = /*implementation-defined*/,
        no_state = /*implementation-defined*/
    };

    enum class launch : /*unspecified*/ {
        async = /*unspecified*/,
        deferred = /*unspecified*/,
        /*implementation-defined*/
    };

    enum class future_status {
        ready,
        timeout,
        deferred
    };

    template &lt;&gt;
    struct is_error_code_enum&lt;future_errc&gt; : public true_type { };

    error_code make_error_code(future_errc e) noexcept;
    error_condition make_error_condition(future_errc e) noexcept;
    const error_category&amp; future_category() noexcept;

    class future_error;

    template &lt;class R&gt; class promise;
    template &lt;class R&gt; class promise&lt;R&amp;&gt;;
    template &lt;&gt; class promise&lt;void&gt;;

    template &lt;class R&gt;
    void swap(promise&lt;R&gt;&amp; x, promise&lt;R&gt;&amp; y) noexcept;

    template &lt;class R, class Alloc&gt;
    struct uses_allocator&lt;promise&lt;R&gt;, Alloc&gt; : true_type {};

    template &lt;class R&gt; class future;
    template &lt;class R&gt; class future&lt;R&amp;&gt;;
    template &lt;&gt; class future&lt;void&gt;;

    template &lt;class R&gt; class shared_future;
    template &lt;class R&gt; class shared_future&lt;R&amp;&gt;;
    template &lt;&gt; class shared_future&lt;void&gt;;

    template &lt;class&gt; class packaged_task; // undefined
    template &lt;class R, class... ArgTypes&gt;
    class packaged_task&lt;R(ArgTypes...)&gt;;

    template &lt;class R&gt;
    void swap(packaged_task&lt;R(ArgTypes...)&gt;&amp;,
              packaged_task&lt;R(ArgTypes...)&gt;&amp;) noexcept;

    template &lt;class R, class Alloc&gt;
    struct uses_allocator&lt;packaged_task&lt;R&gt;, Alloc&gt; : true_type {};

    template &lt;class F, class... Args&gt;
     future&lt;result_of_t&lt;decay_t&lt;F&gt;(decay_t&lt;Args&gt;...)&gt;&gt;
     async(F&amp;&amp; f, Args&amp;&amp;... args);

    template &lt;class F, class... Args&gt;
     future&lt;result_of_t&lt;decay_t&lt;F&gt;(decay_t&lt;Args&gt;...)&gt;&gt;
     async(launch policy, F&amp;&amp; f, Args&amp;&amp;... args);
}
}}

====Class {{lc|std::future_error}}====
{{source|1=
class future_error : public logic_error {
 public:
    future_error(error_code ec); // exposition only
    const error_code&amp; code() const noexcept;
    const char* what() const noexcept;
};
}}

====Class {{lc|std::promise}}====
{{source|1=
template &lt;class R&gt;
class promise {
 public:
    promise();
    template &lt;class Allocator&gt;
    promise(allocator_arg_t, const Allocator&amp; a);
    promise(promise&amp;&amp; rhs) noexcept;
    promise(const promise&amp; rhs) = delete;
    ~promise();

    // assignment
    promise&amp; operator=(promise&amp;&amp; rhs) noexcept;
    promise&amp; operator=(const promise&amp; rhs) = delete;
    void swap(promise&amp; other) noexcept;

    // retrieving the result
    future&lt;R&gt; get_future();

    // setting the result
    void set_value(see below );
    void set_exception(exception_ptr p);

    // setting the result with deferred notification
    void set_value_at_thread_exit(const R&amp; r);
    void set_value_at_thread_exit(see below );
    void set_exception_at_thread_exit(exception_ptr p);
};
}}

====Class {{lc|std::future}}====
{{source|1=
template &lt;class R&gt;
class future {
 public:
    future() noexcept;
    future(future &amp;&amp;) noexcept;
    future(const future&amp; rhs) = delete;
    ~future();
    future&amp; operator=(const future&amp; rhs) = delete;
    future&amp; operator=(future&amp;&amp;) noexcept;
    shared_future&lt;R&gt; share();

    // retrieving the value
    see below get();

    // functions to check state
    bool valid() const noexcept;
    void wait() const;
    template &lt;class Rep, class Period&gt;
    future_status wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
    template &lt;class Clock, class Duration&gt;
    future_status wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
};
}}

====Class {{lc|std::shared_future}}====
{{source|1=
template &lt;class R&gt;
class shared_future {
 public:
    shared_future() noexcept;
    shared_future(const shared_future&amp; rhs);
    shared_future(future&lt;R&gt;&amp;&amp;) noexcept;
    shared_future(shared_future&amp;&amp; rhs) noexcept;
    ~shared_future();
    shared_future&amp; operator=(const shared_future&amp; rhs);
    shared_future&amp; operator=(shared_future&amp;&amp; rhs) noexcept;

    // retrieving the value
    /*see description*/ get() const;

    // functions to check state
    bool valid() const noexcept;
    void wait() const;
    template &lt;class Rep, class Period&gt;
    future_status wait_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time) const;
    template &lt;class Clock, class Duration&gt;
    future_status wait_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time) const;
};
}}

====Class {{lc|std::packaged_task}}====
{{source|1=
template&lt;class&gt; class packaged_task; // undefined

template&lt;class R, class... ArgTypes&gt;
class packaged_task&lt;R(ArgTypes...)&gt; {
 public:
    // construction and destruction
    packaged_task() noexcept;
    template &lt;class F&gt;
    explicit packaged_task(F&amp;&amp; f);
    template &lt;class F, class Allocator&gt;
    explicit packaged_task(allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f);
    ~packaged_task();

    // no copy
    packaged_task(const packaged_task&amp;) = delete;
    packaged_task&amp; operator=(const packaged_task&amp;) = delete;

    // move support
    packaged_task(packaged_task&amp;&amp; rhs) noexcept;
    packaged_task&amp; operator=(packaged_task&amp;&amp; rhs) noexcept;

    void swap(packaged_task&amp; other) noexcept;
    bool valid() const noexcept;

    // result retrieval
    future&lt;R&gt; get_future();

    // execution
    void operator()(ArgTypes... );
    void make_ready_at_thread_exit(ArgTypes...);

    void reset();
};
}}</text>
      <sha1>nci4483klr8dio2jhzc5opfyhyxmfh0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/initializer list</title>
    <ns>0</ns>
    <id>9660</id>
    <revision>
      <id>57488</id>
      <parentid>49573</parentid>
      <timestamp>2013-06-01T05:54:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1115">{{cpp/header/title|initializer_list}}
{{cpp/header/navbar}}
This header is part of the [[cpp/utility|utility]] library.

===Classes===
{{dsc begin}}
{{dsc| {{lc|std::initializer_list}}{{mark c++11}} | {{mark tclass}} }}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc begin2}}
{{dsc inc | cpp/utility/initializer_list/dsc end2}}
{{dsc end}}



===Synopsis===
{{source|

namespace std {
    template&lt;class E&gt; class initializer_list {
    public:
        typedef E value_type;
        typedef const E&amp; reference;
        typedef const E&amp; const_reference;
        typedef size_t size_type;
        typedef const E* iterator;
        typedef const E* const_iterator;
        initializer_list() noexcept;
        size_t size() const noexcept; // number of elements
        const E* begin() const noexcept; // first element
        const E* end() const noexcept; // one past the last element
    };
    // initializer list range access
    template&lt;class E&gt; const E* begin(initializer_list&lt;E&gt; il) noexcept;
    template&lt;class E&gt; const E* end(initializer_list&lt;E&gt; il) noexcept;
}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/iomanip</title>
    <ns>0</ns>
    <id>9669</id>
    <revision>
      <id>57489</id>
      <parentid>49574</parentid>
      <timestamp>2013-06-01T05:54:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1257">{{cpp/header/title|iomanip}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io/manip|Input/output manipulators]] library.
===Definitions===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc inc | cpp/io/manip/dsc setbase}}
{{dsc inc | cpp/io/manip/dsc setfill}}
{{dsc inc | cpp/io/manip/dsc setprecision}}
{{dsc inc | cpp/io/manip/dsc setw}}
{{dsc inc | cpp/io/manip/dsc get_money}}
{{dsc inc | cpp/io/manip/dsc put_money}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    // types T1, T2, ... are unspecified implementation types
    /*T1*/ resetiosflags(ios_base::fmtflags mask);
    /*T2*/ setiosflags (ios_base::fmtflags mask);
    /*T3*/ setbase(int base);
    template&lt;charT&gt; /*T4*/ setfill(charT c);
    /*T5*/ setprecision(int n);
    /*T6*/ setw(int n);
    template &lt;class moneyT&gt; /*T7*/ get_money(moneyT&amp; mon, bool intl {{=}} false);
    template &lt;class moneyT&gt; /*T8*/ put_money(const moneyT&amp; mon, bool intl {{=}} false);
    template &lt;class charT&gt; /*T9*/ get_time(struct tm* tmb, const charT* fmt);
    template &lt;class charT&gt; /*T10*/ put_time(const struct tm* tmb, const charT* fmt);
}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ios</title>
    <ns>0</ns>
    <id>12856</id>
    <revision>
      <id>72066</id>
      <parentid>63998</parentid>
      <timestamp>2014-07-11T10:58:54Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>(w)ios and (w)streampos are declared in &lt;iosfwd&gt;</comment>
      <text xml:space="preserve" bytes="8432">{{cpp/header/title|ios}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/Output]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|iosfwd}}}}
{{dsc h1|Classes}}
{{dsc class | cpp/io/ios_base | manages formatting flags and input/output exceptions}}
{{dsc tclass | cpp/io/basic_ios | manages an arbitrary stream buffer}}
{{dsc tclass  | cpp/io/fpos | represents absolute position in a stream or a file}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc inc | cpp/io/dsc iostream_category}}
{{dsc inc | cpp/io/io_errc/dsc is_error_code_enum}}
{{dsc h1|Typedefs}}
{{dsc typedef | cpp/io/streamoff | represents relative file/stream position (offset from fpos), sufficient to represent any file size }}
{{dsc typedef | cpp/io/streamsize | represents the number of characters transferred in an I/O operation or the size of an I/O buffer}}
{{dsc h1|Functions}}
{{dsc inc | cpp/io/io_errc/dsc make_error_code}}
{{dsc inc | cpp/io/io_errc/dsc make_error_condition}}
{{dsc inc | cpp/io/manip/dsc boolalpha}}
{{dsc inc | cpp/io/manip/dsc showbase}}
{{dsc inc | cpp/io/manip/dsc showpoint}}
{{dsc inc | cpp/io/manip/dsc showpos}}
{{dsc inc | cpp/io/manip/dsc skipws}}
{{dsc inc | cpp/io/manip/dsc uppercase}}
{{dsc inc | cpp/io/manip/dsc unitbuf}}
{{dsc inc | cpp/io/manip/dsc left}}
{{dsc inc | cpp/io/manip/dsc hex}}
{{dsc inc | cpp/io/manip/dsc fixed}}
{{dsc end}}

===Synopsis===

{{source|1=
#include &lt;iosfwd&gt;
namespace std {

    typedef /*implementation-defined*/ streamoff;
    typedef /*implementation-defined*/ streamsize;

    template &lt;class stateT&gt; class fpos;

    class ios_base;

    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
        class basic_ios;

    // manipulators:
    ios_base&amp; boolalpha (ios_base&amp; str);
    ios_base&amp; noboolalpha(ios_base&amp; str);
    ios_base&amp; showbase (ios_base&amp; str);
    ios_base&amp; noshowbase (ios_base&amp; str);
    ios_base&amp; showpoint (ios_base&amp; str);
    ios_base&amp; noshowpoint(ios_base&amp; str);
    ios_base&amp; showpos (ios_base&amp; str);
    ios_base&amp; noshowpos (ios_base&amp; str);
    ios_base&amp; skipws (ios_base&amp; str);
    ios_base&amp; noskipws (ios_base&amp; str);
    ios_base&amp; uppercase (ios_base&amp; str);
    ios_base&amp; nouppercase(ios_base&amp; str);
    ios_base&amp; unitbuf (ios_base&amp; str);
    ios_base&amp; nounitbuf (ios_base&amp; str);
    ios_base&amp; internal (ios_base&amp; str);
    ios_base&amp; left (ios_base&amp; str);
    ios_base&amp; right (ios_base&amp; str);
    ios_base&amp; dec (ios_base&amp; str);
    ios_base&amp; hex (ios_base&amp; str);
    ios_base&amp; oct (ios_base&amp; str);
    ios_base&amp; fixed (ios_base&amp; str);
    ios_base&amp; scientific (ios_base&amp; str);
    ios_base&amp; hexfloat (ios_base&amp; str);
    ios_base&amp; defaultfloat(ios_base&amp; str);

    enum class io_errc {
        stream = 1
    };

    template &lt;&gt;
    struct is_error_code_enum&lt;io_errc&gt; : public true_type { };

    error_code make_error_code(io_errc e);
    error_condition make_error_condition(io_errc e);
    const error_category&amp; iostream_category();
}
}}

====Class {{lc|std::ios_base}}====
{{source|1=
class ios_base {
 public:
    class failure;

    // fmtflags
    typedef /*bitmask-type-1*/ fmtflags;
    static constexpr fmtflags boolalpha = /*unspecified*/;
    static constexpr fmtflags dec = /*unspecified*/;
    static constexpr fmtflags fixed = /*unspecified*/;
    static constexpr fmtflags hex = /*unspecified*/;
    static constexpr fmtflags internal = /*unspecified*/;
    static constexpr fmtflags left = /*unspecified*/;
    static constexpr fmtflags oct = /*unspecified*/;
    static constexpr fmtflags right = /*unspecified*/;
    static constexpr fmtflags scientific = /*unspecified*/;
    static constexpr fmtflags showbase = /*unspecified*/;
    static constexpr fmtflags showpoint = /*unspecified*/;
    static constexpr fmtflags showpos = /*unspecified*/;
    static constexpr fmtflags skipws = /*unspecified*/;
    static constexpr fmtflags unitbuf = /*unspecified*/;
    static constexpr fmtflags uppercase = /*unspecified*/;
    static constexpr fmtflags adjustfield = /*left{{!}}right{{!}}internal*/ ;
    static constexpr fmtflags basefield = /*dec{{!}}oct{{!}}hex*/ ;
    static constexpr fmtflags floatfield = /*scientific{{!}}fixed*/ ;

    // iostate
    typedef /*bitmask-type-2*/ iostate;
    static constexpr iostate badbit = /*unspecified*/;
    static constexpr iostate eofbit = /*unspecified*/;
    static constexpr iostate failbit = /*unspecified*/;
    static constexpr iostate goodbit = /*0*/ ;

    // openmode
    typedef /*bitmask-type-3*/ openmode;
    static constexpr openmode app = /*unspecified*/;
    static constexpr openmode ate = /*unspecified*/;
    static constexpr openmode binary = /*unspecified*/;
    static constexpr openmode in = /*unspecified*/;
    static constexpr openmode out = /*unspecified*/;
    static constexpr openmode trunc = /*unspecified*/;

    // seekdir
    typedef /*bitmask-type-4*/ seekdir;
    static constexpr seekdir beg = /*unspecified*/;
    static constexpr seekdir cur = /*unspecified*/;
    static constexpr seekdir end = /*unspecified*/;

    class Init;

    // fmtflags state:
    fmtflags flags() const;
    fmtflags flags(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl);
    fmtflags setf(fmtflags fmtfl, fmtflags mask);
    void unsetf(fmtflags mask);
    streamsize precision() const;
    streamsize precision(streamsize prec);
    streamsize width() const;
    streamsize width(streamsize wide);

    // locales:
    locale imbue(const locale&amp; loc);
    locale getloc() const;

    // storage:
    static int xalloc();
    long&amp; iword(int index);
    void*&amp; pword(int index);

    // destructor
    virtual ~ios_base();

    // callbacks;
    enum event {
        erase_event,
        imbue_event,
        copyfmt_event
    };
    typedef void (*event_callback)(event, ios_base&amp;, int index);
    void register_callback(event_callback fn, int index);

    ios_base(const ios_base&amp;) = delete;
    ios_base&amp; operator=(const ios_base&amp;) = delete;
    static bool sync_with_stdio(bool sync = true);

 protected:
    ios_base();

 private:
    static int index; // exposition only
    long* iarray; // exposition only
    void** parray; // exposition only
};
}}

====Class {{lc|std::ios_base::failure}}====
{{source|1=
class ios_base::failure : public system_error {
 public:
    explicit failure(const string&amp; msg, const error_code&amp; ec = io_errc::stream);
    explicit failure(const char* msg, const error_code&amp; ec = io_errc::stream);
};
}}

====Class {{lc|std::ios_base::Init}}====
{{source|1=
class ios_base::Init {
 public:
    Init();
    ~Init();
 private:
    static int init_cnt; // exposition only
};
}}

====Class {{lc|std::fpos}}====
{{source|1=
template &lt;class stateT&gt; class fpos {
 public:
    stateT state() const;
    void state(stateT);
 private;
    stateT st; // exposition only
};
}}

====Class {{lc|std::basic_ios}}====
{{source|1=
template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
class basic_ios : public ios_base {
 public:
    // types:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    explicit operator bool() const;
    bool operator!() const;
    iostate rdstate() const;
    void clear(iostate state = goodbit);
    void setstate(iostate state);
    bool good() const;
    bool eof() const;
    bool fail() const;
    bool bad() const;

    iostate exceptions() const;
    void exceptions(iostate except);

    // Constructor/destructor:
    explicit basic_ios(basic_streambuf&lt;charT,traits&gt;* sb);
    virtual ~basic_ios();

    // Members:
    basic_ostream&lt;charT,traits&gt;* tie() const;
    basic_ostream&lt;charT,traits&gt;* tie(basic_ostream&lt;charT,traits&gt;* tiestr);
    basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
    basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);
    basic_ios&amp; copyfmt(const basic_ios&amp; rhs);
    char_type fill() const;
    char_type fill(char_type ch);
    locale imbue(const locale&amp; loc);
    char narrow(char_type c, char dfault) const;
    char_type widen(char c) const;
    basic_ios(const basic_ios&amp; ) = delete;
    basic_ios&amp; operator=(const basic_ios&amp;) = delete;

 protected:
    basic_ios();
    void init(basic_streambuf&lt;charT,traits&gt;* sb);
    void move(basic_ios&amp; rhs);
    void move(basic_ios&amp;&amp; rhs);
    void swap(basic_ios&amp; rhs) noexcept;
    void set_rdbuf(basic_streambuf&lt;charT, traits&gt;* sb);
};
}}</text>
      <sha1>nkp9cyjc6wuj3qty0gvbxengjtj58wr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/iosfwd</title>
    <ns>0</ns>
    <id>9738</id>
    <revision>
      <id>72077</id>
      <parentid>72068</parentid>
      <timestamp>2014-07-12T06:15:36Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6842">{{cpp/header/title|iosfwd}}
{{cpp/header/navbar}}
This header contains forward declarations for the [[cpp/io|Input/output]] library.

{{dsc begin}}
{{dsc h1|Forward declarations}}
{{dsc header|string}}
{{dsc| {{lc|std::char_traits}} | Class Template which describes properties of a character type {{mark tclass}} }}
{{dsc| {{c|std::char_traits&lt;char&gt;}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;wchar_t&gt;}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;char16_t&gt;}} {{mark c++11}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;char32_t&gt;}} {{mark c++11}} | {{mark ptclass}} }}

{{dsc header | memory}}
{{dsc inc | cpp/memory/dsc allocator}}

{{dsc header | ios}}
{{dsc tclass | cpp/io/basic_ios | manages an arbitrary stream buffer}}
{{dsc tclass | cpp/io/fpos | represents absolute position in a stream or a file}}

{{dsc header | streambuf}}
{{dsc tclass | cpp/io/basic_streambuf | abstracts a raw device}}

{{dsc header | ostream}}
{{dsc tclass | cpp/io/basic_ostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level output interface}}

{{dsc header | istream}}
{{dsc tclass | cpp/io/basic_istream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input interface}}
{{dsc tclass | cpp/io/basic_iostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input/output interface}}

{{dsc header | fstream}}
{{dsc tclass | cpp/io/basic_filebuf | implements raw file device}}
{{dsc tclass | cpp/io/basic_ifstream | implements high-level file stream input operations}}
{{dsc tclass | cpp/io/basic_ofstream | implements high-level file stream output operations}}
{{dsc tclass | cpp/io/basic_fstream | implements high-level file stream input/output operations}}

{{dsc header | sstream}}
{{dsc tclass | cpp/io/basic_stringbuf | implements raw string device}}
{{dsc tclass | cpp/io/basic_istringstream | implements high-level string stream input operations}}
{{dsc tclass | cpp/io/basic_ostringstream | implements high-level string stream output operations}}
{{dsc tclass | cpp/io/basic_stringstream | implements high-level string stream input/output operations}}

{{dsc header | strstream}}
{{dsc class | cpp/io/strstreambuf | notes={{mark deprecated}} | implements raw character array device}}
{{dsc class | cpp/io/istrstream | notes={{mark deprecated}} | implements character array input operations}}
{{dsc class | cpp/io/ostrstream | notes={{mark deprecated}} | implements character array output operations}}
{{dsc class | cpp/io/strstream | notes={{mark deprecated}} | implements character array input/output operations}}

{{dsc h1|Typedefs and specializations}}
{{dsc | {{lc|std::streampos}} | {{c|fpos&lt;char_traits&lt;char&gt;::state_type&gt;}}}}
{{dsc | {{lc|std::wstreampos}} | {{c|fpos&lt;char_traits&lt;wchar_t&gt;::state_type&gt;}}}}
{{dsc | In addition, for each class template {{tt|std::basic_''T''}} declared in this header, {{tt|std::''T''}} and {{tt|std::w''T''}} are declared as a synonym of {{tt|std::basic_''T''&lt;char&gt;}} and {{tt|std::basic_''T''&lt;wchar_t&gt;}} respectively.}}&lt;!--It will be a rather long list if all of them are shown, see http://en.cppreference.com/w/?oldid=72068 and the header synopsis below--&gt;
{{dsc end}}

===Synopsis===
{{source|
namespace std {
    
    template&lt;class charT&gt; class char_traits;
    template&lt;&gt; class char_traits&lt;char&gt;;
    template&lt;&gt; class char_traits&lt;char16_t&gt;;
    template&lt;&gt; class char_traits&lt;char32_t&gt;;
    template&lt;&gt; class char_traits&lt;wchar_t&gt;;
    
    template&lt;class T&gt; class allocator;
    
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_ios;

    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_streambuf;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_istream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_ostream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_iostream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt;,
            class Allocator {{=}} allocator&lt;charT&gt; &gt;
        class basic_stringbuf;

    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt;,
            class Allocator {{=}} allocator&lt;charT&gt; &gt;
        class basic_istringstream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt;,
            class Allocator {{=}} allocator&lt;charT&gt; &gt;
        class basic_ostringstream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt;,
            class Allocator {{=}} allocator&lt;charT&gt; &gt;
        class basic_stringstream;
        
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_filebuf;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_ifstream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_ofstream;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_fstream;
    
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class istreambuf_iterator;
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class ostreambuf_iterator;


    typedef basic_ios&lt;char&gt;     ios;    
    typedef basic_ios&lt;wchar_t&gt;  wios;   
            
    typedef basic_streambuf&lt;char&gt;   streambuf;
    typedef basic_istream&lt;char&gt;     istream;
    typedef basic_ostream&lt;char&gt;     ostream;
    typedef basic_iostream&lt;char&gt;    iostream;
            
    typedef basic_stringbuf&lt;char&gt;       stringbuf;
    typedef basic_istringstream&lt;char&gt;   istringstream;
    typedef basic_ostringstream&lt;char&gt;   ostringstream;
    typedef basic_stringstream&lt;char&gt;    stringstream;
            
    typedef basic_filebuf&lt;char&gt;     filebuf;
    typedef basic_ifstream&lt;char&gt;    ifstream;
    typedef basic_ofstream&lt;char&gt;    ofstream;
    typedef basic_fstream&lt;char&gt;     fstream;
            
    typedef basic_streambuf&lt;wchar_t&gt;    wstreambuf;
    typedef basic_istream&lt;wchar_t&gt;      wistream;
    typedef basic_ostream&lt;wchar_t&gt;      wostream;
    typedef basic_iostream&lt;wchar_t&gt;     wiostream;
            
    typedef basic_stringbuf&lt;wchar_t&gt;        wstringbuf;
    typedef basic_istringstream&lt;wchar_t&gt;    wistringstream;
    typedef basic_ostringstream&lt;wchar_t&gt;    wostringstream;
    typedef basic_stringstream&lt;wchar_t&gt;     wstringstream;
            
    typedef basic_filebuf&lt;wchar_t&gt;  wfilebuf;        
    typedef basic_ifstream&lt;wchar_t&gt; wifstream;      
    typedef basic_ofstream&lt;wchar_t&gt; wofstream;      
    typedef basic_fstream&lt;wchar_t&gt;  wfstream;   
            
    template &lt;class state&gt; class fpos;      
    typedef fpos&lt;char_traits&lt;char&gt;::state_type&gt; streampos;  
    typedef fpos&lt;char_traits&lt;wchar_t&gt;::state_type&gt; wstreampos;  

}    

}}</text>
      <sha1>6ciuw65dx0smqcm4bm42vqxbx1vbqeo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/iostream</title>
    <ns>0</ns>
    <id>9756</id>
    <revision>
      <id>72149</id>
      <parentid>49576</parentid>
      <timestamp>2014-07-19T06:26:04Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Includes */ mark since c++11</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/header/title|iostream}}
{{cpp/header/navbar}}

This header is part of the [[cpp/io|Input/output]] library.
{{dsc begin}}

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc | {{header|ios}} | {{mark since c++11}} }}
{{dsc | {{header|streambuf}} | {{mark since c++11}} }}
{{dsc | {{header|istream}} | {{mark since c++11}} }}
{{dsc | {{header|ostream}} | {{mark since c++11}} }}
{{dsc h1|Objects}}
{{dsc|{{lc|std::cin}}|standard input}}
{{dsc|{{lc|std::cout}}|standard output}}
{{dsc|{{lc|std::cerr}}|standard error}}
{{dsc|{{lc|std::clog}}|standard log}}
{{dsc|{{lc|std::wcin}}|standard input}}
{{dsc|{{lc|std::wcout}}|standard output}}
{{dsc|{{lc|std::wcerr}}|standard error}}
{{dsc|{{lc|std::wclog}}|standard log}}
{{dsc end}}


===Synopsis===
{{source|

#include &lt;ios&gt;
#include &lt;streambuf&gt;
#include &lt;istream&gt;
#include &lt;ostream&gt;

namespace std {
    
    extern istream cin;
    extern ostream cout;
    extern ostream cerr;
    extern ostream clog;

    extern  wistream wcin;
    extern  wostream wcout;
    extern  wostream wcerr;
    extern  wostream wclog;

}

}}</text>
      <sha1>8qwd3fg97fi1g4qswrwscnovqjudk0w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/istream</title>
    <ns>0</ns>
    <id>9755</id>
    <revision>
      <id>57495</id>
      <parentid>49577</parentid>
      <timestamp>2013-06-01T05:54:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="7013">{{cpp/header/title|istream}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|input/output]] library.
{{dsc begin}}
{{dsc h1 | Classes}}
{{dsc tclass | cpp/io/basic_istream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input interface}}
{{dsc|{{lc|std::istream}}|{{c|basic_istream&lt;char&gt;}}&lt;br/&gt; {{mark typedef}}}}
{{dsc|{{lc|std::wistream}}|{{c|basic_istream&lt;wchar_t&gt;}}&lt;br/&gt; {{mark typedef}} }}
{{dsc tclass | cpp/io/basic_iostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input/output interface}}
{{dsc|{{lc|std::iostream}}|{{c|basic_iostream&lt;char&gt;}}&lt;br/&gt; {{mark typedef}}}}
{{dsc|{{lc|std::wiostream}}|{{c|basic_iostream&lt;wchar_t&gt;}}&lt;br/&gt; {{mark typedef}} }}
{{dsc h1 | Functions}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc h2 | Manipulators}}
{{dsc inc | cpp/io/manip/dsc ws}}
{{dsc end}}

===Synopsis===
{{source|
namespace std {
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_istream;
    typedef basic_istream&lt;char&gt;    istream;
    typedef basic_istream&lt;wchar_t&gt; wistream;

    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_iostream;
    typedef basic_istream&lt;char&gt;    iostream;
    typedef basic_istream&lt;wchar_t&gt; wiostream;

    template &lt;class charT, class traits&gt;
        basic_istream&lt;charT,traits&gt;&amp; ws(basic_istream&lt;charT,traits&gt;&amp; is);

    template &lt;class charT, class traits, class T&gt;
        basic_istream&lt;charT, traits&gt;&amp;
        operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;&amp; is, T&amp; x);

    // character extraction templates:
    template&lt;class charT, class traits&gt;
        basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;, 
                                                charT&amp;);
    template&lt;class traits&gt;
        basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
                                            unsigned char&amp;);
    template&lt;class traits&gt;
        basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
                                            signed char&amp;);
    template&lt;class charT, class traits&gt;
        basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
                                                charT*);
    template&lt;class traits&gt;
        basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
                                            unsigned char*);
    template&lt;class traits&gt;
        basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
                                            signed char*);

}

}}


====Class {{lc|std::basic_istream}}====
{{source|

template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
class basic_istream : virtual public basic_ios&lt;charT,traits&gt; {
public:
    // types (inherited from basic_ios):
    typedef charT                     char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits                    traits_type;
    
    // Constructor/destructor:
    explicit basic_istream(basic_streambuf&lt;char_type,traits&gt;* sb);
    virtual ~basic_istream();
    
    // Prefix/suffix:
    class sentry;
    
    // Formatted input:
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(
        basic_istream&lt;charT,traits&gt;&amp; (*pf)(basic_istream&lt;charT,traits&gt;&amp;));
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(
        basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;));
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(
        ios_base&amp; (*pf)(ios_base&amp;));

    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(bool&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(short&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned short&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(int&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned int&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned long&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long long&amp; n);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned long long&amp; n);

    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(float&amp; f);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(double&amp; f);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long double&amp; f);

    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(void*&amp; p);
    basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(
        basic_streambuf&lt;char_type,traits&gt;* sb);

    // Unformatted input:
    streamsize gcount() const;
    int_type get();
    basic_istream&lt;charT,traits&gt;&amp; get(char_type&amp; c);
    basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n);
    basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n,
                                     char_type delim);
    basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb);
    basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb,
                                     char_type delim);
    
    basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);
    basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n,
                                         char_type delim);
    
    
    basic_istream&lt;charT,traits&gt;&amp; ignore(
        streamsize n {{=}} 1, int_type delim {{=}} traits::eof());
    int_type                     peek();
    basic_istream&lt;charT,traits&gt;&amp; read    (char_type* s, streamsize n);
    streamsize                   readsome(char_type* s, streamsize n);

    basic_istream&lt;charT,traits&gt;&amp; putback(char_type c);
    basic_istream&lt;charT,traits&gt;&amp; unget();
    int sync();

    pos_type tellg();
    basic_istream&lt;charT,traits&gt;&amp; seekg(pos_type);
    basic_istream&lt;charT,traits&gt;&amp; seekg(off_type, ios_base::seekdir);
    
protected:
    basic_istream(const basic_istream&amp; rhs) {{=}} delete;
    basic_istream(basic_istream&amp;&amp; rhs);
    
    // Assign/swap:
    basic_istream&amp; operator{{=}}(const basic_istream&amp; rhs) {{=}} delete;
    basic_istream&amp; operator{{=}}(basic_istream&amp;&amp; rhs);
    void swap(basic_istream&amp; rhs);

};

}}

====Class {{lc|std::basic_iostream}}====
{{source|

template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
class basic_iostream :
    public basic_istream&lt;charT,traits&gt;,
    public basic_ostream&lt;charT,traits&gt; {

public:
    // types
    typedef charT                     char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits                    traits_type;
    
    // constructor/destructor
    explicit basic_iostream(basic_streambuf&lt;charT,traits&gt;* sb);
    virtual ~basic_iostream();

protected:
    basic_iostream(const basic_iostream&amp; rhs) {{=}} delete;
    basic_iostream(basic_iostream&amp;&amp; rhs);
    
    // assign/swap
    basic_iostream&amp; operator{{=}}(const basic_iostream&amp; rhs) {{=}} delete;
    basic_iostream&amp; operator{{=}}(basic_iostream&amp;&amp; rhs);
    void swap(basic_iostream&amp; rhs);
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/iterator</title>
    <ns>0</ns>
    <id>9780</id>
    <revision>
      <id>71996</id>
      <parentid>64128</parentid>
      <timestamp>2014-07-07T11:36:55Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Functions */ + rbegin/rend</comment>
      <text xml:space="preserve" bytes="15299">{{cpp/header/title|iterator}}
{{cpp/header/navbar}}

This header is part of the [[cpp/iterator|iterator]] library.

===Classes===
{{dsc begin}}
{{dsc h2|Primitives}}
{{dsc inc | cpp/iterator/dsc iterator_traits}}
{{dsc inc | cpp/iterator/dsc iterator_tags}}
{{dsc inc | cpp/iterator/dsc iterator}}
{{dsc h2|Adaptors}}
{{dsc inc | cpp/iterator/dsc reverse_iterator}}
{{dsc inc | cpp/iterator/dsc move_iterator}}
{{dsc inc | cpp/iterator/dsc back_insert_iterator}}
{{dsc inc | cpp/iterator/dsc front_insert_iterator}}
{{dsc inc | cpp/iterator/dsc insert_iterator}}
{{dsc h2|Stream Iterators}}
{{dsc inc | cpp/iterator/dsc istream_iterator}}
{{dsc inc | cpp/iterator/dsc ostream_iterator}}
{{dsc inc | cpp/iterator/dsc istreambuf_iterator}}
{{dsc inc | cpp/iterator/dsc ostreambuf_iterator}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2|Adaptors}}
{{dsc inc | cpp/iterator/dsc make_move_iterator}}
{{dsc inc | cpp/iterator/dsc front_inserter}}
{{dsc inc | cpp/iterator/dsc back_inserter}}
{{dsc inc | cpp/iterator/dsc inserter}}
{{dsc h2|Operations}}
{{dsc inc | cpp/iterator/dsc advance}}
{{dsc inc | cpp/iterator/dsc distance}}
{{dsc inc | cpp/iterator/dsc next}}
{{dsc inc | cpp/iterator/dsc prev}}
{{dsc h2|Range}}
{{dsc inc | cpp/iterator/dsc begin}}
{{dsc inc | cpp/iterator/dsc end}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc rend}}

{{dsc h2|Non-member operators}}

{{dsc inc | cpp/iterator/adaptor/dsc operator_cmp | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator+ | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator- | move_iterator}}

{{dsc inc | cpp/iterator/adaptor/dsc operator_cmp | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator+ | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator- | reverse_iterator}}

{{dsc inc | cpp/iterator/istream_iterator/dsc operator_cmp}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator_cmp}}

{{dsc end}}

===Synopsis===
{{source|
namespace std {
    // primitives:
    template&lt;class Iterator&gt; struct iterator_traits;
    template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;
    template&lt;class Category, class T, class Distance {{=}} ptrdiff_t,
    class Pointer {{=}} T*, class Reference {{=}} T&amp;&gt; struct iterator;

    struct input_iterator_tag { };
    struct output_iterator_tag { };
    struct forward_iterator_tag: public input_iterator_tag { };
    struct bidirectional_iterator_tag: public forward_iterator_tag { };
    struct random_access_iterator_tag: public bidirectional_iterator_tag { };

    // iterator operations:
    template &lt;class InputIterator, class Distance&gt;
        void advance(InputIterator&amp; i, Distance n);
    template &lt;class InputIterator&gt;
        typename iterator_traits&lt;InputIterator&gt;::difference_type
        distance(InputIterator first, InputIterator last);
    template &lt;class ForwardIterator&gt;
        ForwardIterator next(ForwardIterator x,
            typename std::iterator_traits&lt;ForwardIterator&gt;::difference_type n {{=}} 1);
    template &lt;class BidirectionalIterator&gt;
        BidirectionalIterator prev(BidirectionalIterator x,
            typename std::iterator_traits&lt;BidirectionalIterator&gt;::difference_type n {{=}} 1);

    // predefined iterators:
    template &lt;class Iterator&gt; class reverse_iterator;

    template &lt;class Iterator1, class Iterator2&gt;
        bool operator{{=}}{{=}}(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&lt;(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator!{{=}}(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&gt;(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&gt;{{=}}(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&lt;{{=}}(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y);

    template &lt;class Iterator1, class Iterator2&gt;
        auto operator-(
            const reverse_iterator&lt;Iterator1&gt;&amp; x,
            const reverse_iterator&lt;Iterator2&gt;&amp; y) -&gt;decltype(y.base() - x.base());
    template &lt;class Iterator&gt;
        reverse_iterator&lt;Iterator&gt;
        operator+(
            typename reverse_iterator&lt;Iterator&gt;::difference_type n,
            const reverse_iterator&lt;Iterator&gt;&amp; x);

    template &lt;class Container&gt; class back_insert_iterator;
    template &lt;class Container&gt;
        back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);

    template &lt;class Container&gt; class front_insert_iterator;
    template &lt;class Container&gt;
        front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);

    template &lt;class Container&gt; class insert_iterator;
    template &lt;class Container&gt;
        insert_iterator&lt;Container&gt; inserter(Container&amp; x, typename Container::iterator i);

    template &lt;class Iterator&gt; class move_iterator;
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator{{=}}{{=}}(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator!{{=}}(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&lt;(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&lt;{{=}}(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&gt;(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);
    template &lt;class Iterator1, class Iterator2&gt;
        bool operator&gt;{{=}}(
            const move_iterator&lt;Iterator1&gt;&amp; x, const move_iterator&lt;Iterator2&gt;&amp; y);

    template &lt;class Iterator1, class Iterator2&gt;
        auto operator-(
            const move_iterator&lt;Iterator1&gt;&amp; x,
            const move_iterator&lt;Iterator2&gt;&amp; y) -&gt; decltype(x.base() - y.base());
    template &lt;class Iterator&gt;
        move_iterator&lt;Iterator&gt; operator+(
            typename move_iterator&lt;Iterator&gt;::difference_type n, 
            const move_iterator&lt;Iterator&gt;&amp; x);
    template &lt;class Iterator&gt;
        move_iterator&lt;Iterator&gt; make_move_iterator( Iterator i);

    // stream iterators:
    template &lt;class T, class charT {{=}} char, class traits {{=}} char_traits&lt;charT&gt;,
            class Distance {{=}} ptrdiff_t&gt;
        class istream_iterator;
    template &lt;class T, class charT, class traits, class Distance&gt;
        bool operator{{=}}{{=}}(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
            const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
    template &lt;class T, class charT, class traits, class Distance&gt;
        bool operator!{{=}}(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
            const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);

    template &lt;class T, class charT {{=}} char, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class ostream_iterator;

    template&lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class istreambuf_iterator;
    template &lt;class charT, class traits&gt;
        bool operator{{=}}{{=}}(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
            const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
    template &lt;class charT, class traits&gt;
        bool operator!{{=}}(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
            const istreambuf_iterator&lt;charT,traits&gt;&amp; b);

    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class ostreambuf_iterator;

    // range access:
    template &lt;class C&gt; auto begin(C&amp; c) -&gt; decltype(c.begin());
    template &lt;class C&gt; auto begin(const C&amp; c) -&gt; decltype(c.begin());
    template &lt;class C&gt; auto end(C&amp; c) -&gt; decltype(c.end());
    template &lt;class C&gt; auto end(const C&amp; c) -&gt; decltype(c.end());
    template &lt;class T, size_t N&gt; T* begin(T (&amp;array)[N]);
    template &lt;class T, size_t N&gt; T* end(T (&amp;array)[N]);
}

}}

====Class {{lc|std::iterator_traits}}====
{{source|
template&lt;class Iterator&gt; struct iterator_traits {
    typedef typename Iterator::difference_type      difference_type;
    typedef typename Iterator::value_type           value_type;
    typedef typename Iterator::pointer              pointer;
    typedef typename Iterator::reference            reference;
    typedef typename Iterator::iterator_category    iterator_category;
};

template&lt;class T&gt; struct iterator_traits&lt;T*&gt; {
    typedef ptrdiff_t                   difference_type;
    typedef T                           value_type;
    typedef T*                          pointer;
    typedef T&amp;                          reference;
    typedef random_access_iterator_tag  iterator_category;
};

template&lt;class T&gt; struct iterator_traits&lt;const T*&gt; {
    typedef ptrdiff_t                   difference_type;
    typedef T                           value_type;
    typedef const T*                    pointer;
    typedef const T&amp;                    reference;
    typedef random_access_iterator_tag  iterator_category;
};

}}

====Class {{lc|std::iterator}}====
{{source|

template&lt;class Category, class T, class Distance {{=}} ptrdiff_t,
         class Pointer {{=}} T*, class Reference {{=}} T&amp;&gt;
struct iterator {
    typedef T           value_type;
    typedef Distance    difference_type;
    typedef Pointer     pointer;
    typedef Reference   reference;
    typedef Category    iterator_category;
};

}}

====Iterator tags====
{{source|
struct input_iterator_tag { };
struct output_iterator_tag { };
struct forward_iterator_tag: public input_iterator_tag { };
struct bidirectional_iterator_tag: public forward_iterator_tag { };
struct random_access_iterator_tag: public bidirectional_iterator_tag { };

}}
====Class {{lc|std::reverse_iterator}}====
{{source|

template &lt;class Iterator&gt;
class reverse_iterator : public
    iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
    typename iterator_traits&lt;Iterator&gt;::value_type,
    typename iterator_traits&lt;Iterator&gt;::difference_type,
    typename iterator_traits&lt;Iterator&gt;::pointer,
    typename iterator_traits&lt;Iterator&gt;::reference&gt; {
public:
    typedef Iterator                                            iterator_type;
    typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
    typedef typename iterator_traits&lt;Iterator&gt;::reference       reference;
    typedef typename iterator_traits&lt;Iterator&gt;::pointer         pointer;

    reverse_iterator();
    explicit reverse_iterator(Iterator x);
    template &lt;class U&gt; reverse_iterator(const reverse_iterator&lt;U&gt;&amp; u);
    template &lt;class U&gt; reverse_iterator&amp; operator{{=}}(const reverse_iterator&lt;U&gt;&amp; u);
    
    Iterator base() const; // explicit
    reference operator*() const;
    pointer operator-&gt;() const;

    reverse_iterator&amp; operator++();
    reverse_iterator  operator++(int);
    reverse_iterator&amp; operator--();
    reverse_iterator  operator--(int);
    
    reverse_iterator  operator+ (difference_type n) const;
    reverse_iterator&amp; operator+{{=}}(difference_type n);
    reverse_iterator  operator- (difference_type n) const;
    reverse_iterator&amp; operator-{{=}}(difference_type n);
    
    /*unspecified*/ operator[](difference_type n) const;
protected:
    Iterator current;
private:
    Iterator deref_tmp; // exposition only
};

}}
====Class {{lc|std::back_insert_iterator}}====
{{source|

template &lt;class Container&gt;
class back_insert_iterator :
    public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
protected:
    Container* container;
public:
    typedef Container container_type;
    
    explicit back_insert_iterator(Container&amp; x);
    back_insert_iterator&lt;Container&gt;&amp;
        operator{{=}}(const typename Container::value_type&amp; value);
    back_insert_iterator&lt;Container&gt;&amp;
        operator{{=}}(typename Container::value_type&amp;&amp; value);
    
    back_insert_iterator&lt;Container&gt;&amp; operator*();
    back_insert_iterator&lt;Container&gt;&amp; operator++();
    back_insert_iterator&lt;Container&gt;  operator++(int);
};


}}
====Class {{lc|std::front_insert_iterator}}====
{{source|

template &lt;class Container&gt;
class front_insert_iterator :
    public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
protected:
    Container* container;
public:
    typedef Container container_type;
    
    explicit front_insert_iterator(Container&amp; x);
    front_insert_iterator&lt;Container&gt;&amp;
    operator{{=}}(const typename Container::value_type&amp; value);
    front_insert_iterator&lt;Container&gt;&amp;
    operator{{=}}(typename Container::value_type&amp;&amp; value);
    
    front_insert_iterator&lt;Container&gt;&amp; operator*();
    front_insert_iterator&lt;Container&gt;&amp; operator++();
    front_insert_iterator&lt;Container&gt;  operator++(int);
};


}}
====Class {{lc|std::insert_iterator}}====
{{source|

template &lt;class Container&gt;
class insert_iterator :
    public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
protected:
    Container*                   container;
    typename Container::iterator iter;
public:
    typedef Container container_type;

    insert_iterator(Container&amp; x, typename Container::iterator i);
    insert_iterator&lt;Container&gt;&amp;
    operator{{=}}(const typename Container::value_type&amp; value);
    insert_iterator&lt;Container&gt;&amp;
    operator{{=}}(typename Container::value_type&amp;&amp; value);

    insert_iterator&lt;Container&gt;&amp; operator*();
    insert_iterator&lt;Container&gt;&amp; operator++();
    insert_iterator&lt;Container&gt;&amp; operator++(int);
};

}}
====Class {{lc|std::move_iterator}}====
{{source|
template &lt;class Iterator&gt;
class move_iterator {
public:
    typedef Iterator                                            iterator_type;
    typedef typename iterator_traits&lt;Iterator&gt;::difference_type difference_type;
    typedef Iterator                                            pointer;
    typedef typename iterator_traits&lt;Iterator&gt;::value_type      value_type;
    typedef typename iterator_traits&lt;Iterator&gt;::iterator_category
                                                                iterator_category;
    typedef value_type&amp;&amp;                                        reference;

    move_iterator();
    explicit move_iterator(Iterator i);
    template &lt;class U&gt; move_iterator(const move_iterator&lt;U&gt;&amp; u);
    template &lt;class U&gt; move_iterator&amp; operator{{=}}(const move_iterator&lt;U&gt;&amp; u);
    
    iterator_type base() const;
    reference operator*() const;
    pointer operator-&gt;() const;
    
    move_iterator&amp; operator++();
    move_iterator  operator++(int);
    move_iterator&amp; operator--();
    move_iterator  operator--(int);
   
    move_iterator   operator+(difference_type n) const;
    move_iterator&amp;  operator+{{=}}(difference_type n);
    move_iterator   operator-(difference_type n) const;
    move_iterator&amp;  operator-{{=}}(difference_type n);
    /*unspecified*/ operator[](difference_type n) const;
    
private:
    Iterator current; // exposition only
};

}}</text>
      <sha1>j8wzzx3gtl0gpkfh0nt7a3whwveb32p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/limits</title>
    <ns>0</ns>
    <id>9662</id>
    <revision>
      <id>57499</id>
      <parentid>49579</parentid>
      <timestamp>2013-06-01T05:54:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="5387">{{cpp/header/title|limits}}
{{cpp/header/navbar}}

This header is part of the [[cpp/types|type support]] library.

===Declarations===
{{dsc begin}}
{{dsc inc | cpp/types/dsc numeric_limits}}
{{dsc inc | cpp/types/numeric_limits/dsc float_round_style}}
{{dsc inc | cpp/types/numeric_limits/dsc float_denorm_style}}
{{dsc end}}

===Synopsis===

{{source|

namespace std {
    template&lt;class T&gt; class numeric_limits;

    enum float_round_style {
        round_indeterminate         {{=}} -1,
        round_toward_zero           {{=}}  0,
        round_to_nearest            {{=}}  1,
        round_toward_infinity       {{=}}  2,
        round_toward_neg_infinity   {{=}}  3,
    };

    enum float_denorm_style {
        denorm_indeterminate {{=}} -1,
        denorm_absent        {{=}}  0,
        denorm_present       {{=}}  1
    };


    template&lt;&gt; class numeric_limits&lt;bool&gt;;

    template&lt;&gt; class numeric_limits&lt;char&gt;;
    template&lt;&gt; class numeric_limits&lt;signed char&gt;;
    template&lt;&gt; class numeric_limits&lt;unsigned char&gt;;
    template&lt;&gt; class numeric_limits&lt;char16_t&gt;;
    template&lt;&gt; class numeric_limits&lt;char32_t&gt;;
    template&lt;&gt; class numeric_limits&lt;wchar_t&gt;;

    template&lt;&gt; class numeric_limits&lt;short&gt;;
    template&lt;&gt; class numeric_limits&lt;int&gt;;
    template&lt;&gt; class numeric_limits&lt;long&gt;;
    template&lt;&gt; class numeric_limits&lt;long long&gt;;
    template&lt;&gt; class numeric_limits&lt;unsigned short&gt;;
    template&lt;&gt; class numeric_limits&lt;unsigned int&gt;;
    template&lt;&gt; class numeric_limits&lt;unsigned long&gt;;
    template&lt;&gt; class numeric_limits&lt;unsigned long long&gt;;

    template&lt;&gt; class numeric_limits&lt;float&gt;;
    template&lt;&gt; class numeric_limits&lt;double&gt;;
    template&lt;&gt; class numeric_limits&lt;long double&gt;;
}

}}


====Class template {{lc|std::numeric_limits}}====
{{source|
template&lt;class T&gt; class numeric_limits {
public:
    static constexpr bool is_specialized {{=}} false;

    static constexpr T min() noexcept { return T(); }
    static constexpr T max() noexcept { return T(); }
    static constexpr T lowest() noexcept { return T(); }

    static constexpr int digits {{=}} 0;
    static constexpr int digits10 {{=}} 0;
    static constexpr int max_digits10 {{=}} 0;

    static constexpr bool is_signed {{=}} false;
    static constexpr bool is_integer {{=}} false;
    static constexpr bool is_exact {{=}} false;
    static constexpr int radix {{=}} 0;
    static constexpr T epsilon() noexcept { return T(); }
    static constexpr T round_error() noexcept { return T(); }

    static constexpr int min_exponent {{=}} 0;
    static constexpr int min_exponent10 {{=}} 0;
    static constexpr int max_exponent {{=}} 0;
    static constexpr int max_exponent10 {{=}} 0;

    static constexpr bool has_infinity {{=}} false;
    static constexpr bool has_quiet_NaN {{=}} false;
    static constexpr bool has_signaling_NaN {{=}} false;
    static constexpr float_denorm_style has_denorm {{=}} denorm_absent;
    static constexpr bool has_denorm_loss {{=}} false;
    static constexpr T infinity() noexcept { return T(); }
    static constexpr T quiet_NaN() noexcept { return T(); }
    static constexpr T signaling_NaN() noexcept { return T(); }
    static constexpr T denorm_min() noexcept { return T(); }

    static constexpr bool is_iec559 {{=}} false;
    static constexpr bool is_bounded {{=}} false;
    static constexpr bool is_modulo {{=}} false;

    static constexpr bool traps {{=}} false;
    static constexpr bool tinyness_before {{=}} false;
    static constexpr float_round_style round_style {{=}} round_toward_zero;

};
}}

====Specialization {{c|std::numeric_limits&lt;bool&gt;}}====
{{source|
template&lt;&gt; class numeric_limits&lt;bool&gt; {
public:
    static constexpr bool is_specialized {{=}} true;

    static constexpr bool min() noexcept { return false; }
    static constexpr bool max() noexcept { return true; }
    static constexpr bool lowest() noexcept { return false; }

    static constexpr int digits {{=}} 1;
    static constexpr int digits10 {{=}} 0;
    static constexpr int max_digits10 {{=}} 0;
    
    static constexpr bool is_signed {{=}} false;
    static constexpr bool is_integer {{=}} true;
    static constexpr bool is_exact {{=}} true;
    static constexpr int radix {{=}} 2;
    static constexpr bool epsilon() noexcept { return 0; }
    static constexpr bool round_error() noexcept { return 0; }

    static constexpr int min_exponent {{=}} 0;
    static constexpr int min_exponent10 {{=}} 0;
    static constexpr int max_exponent {{=}} 0;
    static constexpr int max_exponent10 {{=}} 0;

    static constexpr bool has_infinity {{=}} false;
    static constexpr bool has_quiet_NaN {{=}} false;
    static constexpr bool has_signaling_NaN {{=}} false;
    static constexpr float_denorm_style has_denorm {{=}} denorm_absent;
    static constexpr bool has_denorm_loss {{=}} false;
    static constexpr bool infinity() noexcept { return 0; }
    static constexpr bool quiet_NaN() noexcept { return 0; }
    static constexpr bool signaling_NaN() noexcept { return 0; }
    static constexpr bool denorm_min() noexcept { return 0; }

    static constexpr bool is_iec559 {{=}} false;
    static constexpr bool is_bounded {{=}} true;
    static constexpr bool is_modulo {{=}} false;

    static constexpr bool traps {{=}} false;
    static constexpr bool tinyness_before {{=}} false;
    static constexpr float_round_style round_style {{=}} round_toward_zero;

};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/list</title>
    <ns>0</ns>
    <id>9677</id>
    <revision>
      <id>57502</id>
      <parentid>49580</parentid>
      <timestamp>2013-06-01T05:54:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="6405">{{cpp/header/title|list}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc list}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | list}}
{{dsc inc | cpp/container/dsc swap2 | list}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {

#include &lt;initializer_list&gt;

template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt; class list;

template &lt;class T, class Allocator&gt;
    bool operator{{==}}(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator!{{=}}(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&gt;{{=}}(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
template &lt;class T, class Allocator&gt;
    bool operator&lt;{{=}}(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);

template &lt;class T, class Allocator&gt;
    void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);

}

}}


====Class {{lc|std::list}}====
{{source|


template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt;
class list {
public:
    // types:
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef T                                                   value_type;
    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    // construct/copy/destroy:
    explicit list(const Allocator&amp; {{=}} Allocator());
    explicit list(size_type n);
    list(size_type n, const T&amp; value,const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        list(InputIterator first, InputIterator last,const Allocator&amp; {{=}} Allocator());
    list(const list&lt;T,Allocator&gt;&amp; x);
    list(list&amp;&amp;);
    list(const list&amp;, const Allocator&amp;);
    list(list&amp;&amp;, const Allocator&amp;);
    list(initializer_list&lt;T&gt;, const Allocator&amp; {{=}} Allocator());
    ~list();
    list&lt;T,Allocator&gt;&amp; operator{{=}}(const list&lt;T,Allocator&gt;&amp; x);
    list&lt;T,Allocator&gt;&amp; operator{{=}}(list&lt;T,Allocator&gt;&amp;&amp; x);
    list&amp; operator{{=}}(initializer_list&lt;T&gt;);
    template &lt;class InputIterator&gt;
        void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const T&amp; t);
    void assign(initializer_list&lt;T&gt;);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const T&amp; c);
    bool      empty() const noexcept;
    
    // element access:
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;
    
    // modifiers:
    template &lt;class... Args&gt; void emplace_front(Args&amp;&amp;... args);
    void pop_front();
    template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
    void push_front(const T&amp; x);
    void push_front(T&amp;&amp; x);
    void push_back(const T&amp; x);
    void push_back(T&amp;&amp; x);
    void pop_back();
    
    template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
    iterator insert(const_iterator position, const T&amp; x);
    iterator insert(const_iterator position, T&amp;&amp; x);
    iterator insert(const_iterator position, size_type n, const T&amp; x);
    template &lt;class InputIterator&gt;
        iterator insert (const_iterator position, InputIterator first, 
                         InputIterator last);
    iterator insert(const_iterator position, initializer_list&lt;T&gt;);


    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(list&lt;T,Allocator&gt;&amp;);
    void     clear() noexcept;

    // list operations:
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x);
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x);
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x,
                    const_iterator i);
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x,
                    const_iterator i);
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp; x,
                    const_iterator first, const_iterator last);
    void splice(const_iterator position, list&lt;T,Allocator&gt;&amp;&amp; x,
                    const_iterator first, const_iterator last);

    void remove(const T&amp; value);
    template &lt;class Predicate&gt; void remove_if(Predicate pred);

    void unique();
    template &lt;class BinaryPredicate&gt; void unique(BinaryPredicate binary_pred);

    void merge(list&lt;T,Allocator&gt;&amp; x);
    void merge(list&lt;T,Allocator&gt;&amp;&amp; x);
    template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);
    template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp;&amp; x, Compare comp);

    void sort();
    template &lt;class Compare&gt; void sort(Compare comp);
    
    void reverse() noexcept;
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/locale</title>
    <ns>0</ns>
    <id>9751</id>
    <revision>
      <id>65366</id>
      <parentid>57505</parentid>
      <timestamp>2013-09-10T16:52:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>removing ctype_byname&lt;char&gt; from the links (the text of the header already doesn't have it)</comment>
      <text xml:space="preserve" bytes="18463">{{cpp/header/title|locale}}
{{cpp/header/navbar}}

This header is part of the [[cpp/locale|localization]] library.


{{dsc begin}}
{{dsc h1 | Classes }}
{{dsc inc | cpp/locale/dsc locale}}

{{dsc h2 | String and stream conversions }}
{{dsc inc | cpp/locale/dsc wstring_convert}}
{{dsc inc | cpp/locale/dsc wbuffer_convert}}

{{dsc h2 | Facet category base classes }}
{{dsc inc | cpp/locale/dsc ctype_base}}
{{dsc inc | cpp/locale/dsc codecvt_base}}
{{dsc inc | cpp/locale/dsc messages_base}}
{{dsc inc | cpp/locale/dsc time_base}}
{{dsc inc | cpp/locale/dsc money_base}}

{{dsc h2 | Facet categories }}
{{dsc inc | cpp/locale/dsc ctype}}
{{dsc inc | cpp/locale/dsc ctype_char}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc collate}}
{{dsc inc | cpp/locale/dsc messages}}
{{dsc inc | cpp/locale/dsc time_get}}
{{dsc inc | cpp/locale/dsc time_put}}
{{dsc inc | cpp/locale/dsc num_get}}
{{dsc inc | cpp/locale/dsc num_put}}
{{dsc inc | cpp/locale/dsc numpunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc inc | cpp/locale/dsc moneypunct}}

{{dsc h2 | Locale-specific facet categories }}
{{dsc inc | cpp/locale/dsc ctype_byname}}
{{dsc inc | cpp/locale/dsc codecvt_byname}}
{{dsc inc | cpp/locale/dsc messages_byname}}
{{dsc inc | cpp/locale/dsc collate_byname}}
{{dsc inc | cpp/locale/dsc time_get_byname}}
{{dsc inc | cpp/locale/dsc time_put_byname}}
{{dsc inc | cpp/locale/dsc numpunct_byname}}
{{dsc inc | cpp/locale/dsc moneypunct_byname}}

{{dsc h1|Functions}}

{{dsc h2 | Locales and facets }}
{{dsc inc | cpp/locale/dsc use_facet}}
{{dsc inc | cpp/locale/dsc has_facet}}

{{dsc h2 | Character classification }}
{{dsc inc | cpp/locale/dsc isspace}}
{{dsc inc | cpp/locale/dsc isblank}}
{{dsc inc | cpp/locale/dsc iscntrl}}
{{dsc inc | cpp/locale/dsc isupper}}
{{dsc inc | cpp/locale/dsc islower}}
{{dsc inc | cpp/locale/dsc isalpha}}
{{dsc inc | cpp/locale/dsc isdigit}}
{{dsc inc | cpp/locale/dsc ispunct}}
{{dsc inc | cpp/locale/dsc isxdigit}}
{{dsc inc | cpp/locale/dsc isalnum}}
{{dsc inc | cpp/locale/dsc isprint}}
{{dsc inc | cpp/locale/dsc isgraph}}

{{dsc h2 | Character conversions }}
{{dsc inc | cpp/locale/dsc toupper}}
{{dsc inc | cpp/locale/dsc tolower}}

{{dsc end}}

====Synospis====
{{source|

namespace std {
    
    // locale:
    class locale;
    template &lt;class Facet&gt; const Facet&amp; use_facet(const locale&amp;);
    template &lt;class Facet&gt; bool has_facet(const locale&amp;) noexcept;
    
    // convenience interfaces:
    template &lt;class charT&gt; bool isspace (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isprint (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool iscntrl (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isupper (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool islower (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isalpha (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isdigit (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool ispunct (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isxdigit(charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isalnum (charT c, const locale&amp; loc);
    template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);
    template &lt;class charT&gt; charT toupper(charT c, const locale&amp; loc);
    template &lt;class charT&gt; charT tolower(charT c, const locale&amp; loc);
    template &lt;class Codecvt, class Elem {{=}} wchar_t,
              class Wide_alloc {{=}} std::allocator&lt;Elem&gt;,
        class Byte_alloc {{=}} std::allocator&lt;char&gt; &gt; class wstring_convert;
    template &lt;class Codecvt, class Elem {{=}} wchar_t,
              class Tr {{=}} char_traits&lt;Elem&gt;&gt; class wbuffer_convert;
              
    // ctype:
    class ctype_base;
    template &lt;class charT&gt; class ctype;
    template &lt;&gt;            class ctype&lt;char&gt;; // specialization
    template &lt;class charT&gt; class ctype_byname;
    class codecvt_base;
    template &lt;class internT, class externT, class stateT&gt; class codecvt;
    template &lt;class internT, class externT, class stateT&gt; class codecvt_byname;
    
    // numeric:
    template &lt;class charT,	class	InputIterator {{=}} istreambuf_iterator&lt;charT&gt; &gt; class num_get;
    template &lt;class charT,	class	OutputIterator {{=}} osterambuf_iterator&lt;charT&gt; &gt; class num_put;
    template &lt;class charT&gt;	class	numpunct;
    template &lt;class charT&gt;	class	numpunct_byname;
    
    // collation:
    template &lt;class charT&gt; class collate;
    template &lt;class charT&gt; class collate_byname;
    
    // date and time:
    class time_base;	
    template &lt;class charT, class InputIterator {{=}} istreambuf_iterator&lt;charT&gt; &gt;
        class time_get;	
    template &lt;class charT, class InputIterator&gt; {{=}} istreambuf_iterator&lt;charT&gt; &gt;
        class time_get_byname;	
    template &lt;class charT, class OutputIterator&gt; {{=}} ostreambuf_iterator&lt;charT&gt; &gt;
        class time_put;	
    template &lt;class charT, class OutputIterator&gt; {{=}} ostreambuf_iterator&lt;charT&gt; &gt;
        class time_put_byname;	
        
    // money:	
    class money_base;	
    template &lt;class charT, class InputIterator {{=}} istreambuf_iterator&lt;charT&gt; &gt; &gt; 
        class money_get;
    template &lt;class charT, class OutputIterator {{=}} ostreambuf_iterator&lt;charT&gt; &gt; &gt; 
        class money_put;
    template &lt;class charT, bool Intl {{=}} false&gt; class moneypunct;
    template &lt;class charT, bool Intl {{=}} false&gt; class moneypunct_byname;

    // message retrieval:
    class messages_base;
    template &lt;class charT&gt; class messages;
    template &lt;class charT&gt; class messages_byname;
}

}}


====Class {{lc|std::locale}}====

{{source|

class locale
{
public:
    // types:
    class facet;
    class id;
    typedef int category;
    static const category // values assigned here are for exposition only
        none    {{=}} 0,
        collate {{=}} 0x010, 
        ctype   {{=}} 0x020,
        monetary{{=}} 0x040, 
        numeric {{=}} 0x080,
        time    {{=}} 0x100, 
        messages{{=}} 0x200,
        all {{=}} collate {{!}} ctype {{!}} monetary {{!}} numeric {{!}} time {{!}} messages;
    
    // construct/copy/destroy:
    locale() noexcept;
    locale(const locale&amp; other) noexcept;
    explicit locale(const char* std_name);
    explicit locale(const string&amp; std_name);
    locale(const locale&amp; other, const char* std_name, category);
    locale(const locale&amp; other, const string&amp; std_name, category);
    template &lt;class Facet&gt; locale(const locale&amp; other, Facet* f);
    locale(const locale&amp; other, const locale&amp; one, category);
    ~locale();
    
    // not virtual
    const locale&amp; operator{{=}}(const locale&amp; other) noexcept;
    template &lt;class Facet&gt; locale combine(const locale&amp; other) const;
    
    // locale operations:
    basic_string&lt;char&gt;
    name() const;
    bool operator{{=}}{{=}}(const locale&amp; other) const;
    bool operator!{{=}}(const locale&amp; other) const;
    template &lt;class charT, class traits, class Allocator&gt;
    bool operator()(const basic_string&lt;charT,traits,Allocator&gt;&amp; s1,
                    const basic_string&lt;charT,traits,Allocator&gt;&amp; s2) const;
                    
    // global locale objects:
    static
    locale global(const locale&amp;);
    static const locale&amp; classic();
};
 
}}

====Class {{lc|std::ctype_base}}====
{{source|

class ctype_base {
public:
    typedef /*T*/ mask;
    
    // numeric values are for exposition only.
    static const mask space {{=}} 1 &lt;&lt; 0;
    static const mask print {{=}} 1 &lt;&lt; 1;
    static const mask cntrl {{=}} 1 &lt;&lt; 2;
    static const mask upper {{=}} 1 &lt;&lt; 3;
    static const mask lower {{=}} 1 &lt;&lt; 4;
    static const mask alpha {{=}} 1 &lt;&lt; 5;
    static const mask digit {{=}} 1 &lt;&lt; 6;
    static const mask punct {{=}} 1 &lt;&lt; 7;
    static const mask xdigit{{=}} 1 &lt;&lt; 8;
    static const mask blank {{=}} 1 &lt;&lt; 9;
    static const mask alnum {{=}} alpha {{!}} digit;
    static const mask graph {{=}} alnum {{!}} punct;

};

}}

====Class {{lc|std::ctype}}====
{{source|

template &lt;class charT&gt;
class ctype : public locale::facet, public ctype_base
{
public:
    typedef charT char_type;
    
    explicit ctype(size_t refs {{=}} 0);
    
    bool is(mask m, charT c) const;
    const charT* is(const charT* low, const charT* high, mask* vec) const;
    const charT* scan_is(mask m,
                         const charT* low, const charT* high) const;
    const charT* scan_not(mask m,
                          const charT* low, const charT* high) const;
                          
    charT           toupper(charT c) const;
    const charT*    toupper(charT* low, const charT* high) const;
    charT           tolower(charT c) const;
    const charT*    tolower(charT* low, const charT* high) const;
    
    charT       widen(char c) const;
    const char* widen(const char* low, const char* high, charT* to) const;
    char        narrow(charT c, char dfault) const;
    const charT*narrow(const charT* low, const charT*, char dfault,
                        char* to) const;
                        
    static locale::id id;
    
protected:
    ~ctype();
    virtual bool do_is(mask m, charT c) const;
    virtual const charT* do_is(const charT* low, const charT* high,
                               mask* vec) const;
    virtual const charT* do_scan_is(mask m,
                                    const charT* low, const charT* high) const;
    virtual const charT* do_scan_not(mask m,
                                     const charT* low, const charT* high) const;
                                     
    virtual charT do_toupper(charT) const;
    virtual const charT* do_toupper(charT* low, const charT* high) const;
    virtual charT do_tolower(charT) const;
    virtual const charT* do_tolower(charT* low, const charT* high) const;
    virtual charT do_widen(char) const;
    virtual const char*  do_widen(const char* low, const char* high,
                                  charT* dest) const;
    virtual char do_narrow(charT, char dfault) const;
    virtual const charT* do_narrow(const charT* low, const charT* high,
                                   char dfault, char* dest) const;
};
 
}}


====Class {{lc|std::ctype_byname}}====
{{source|

template &lt;class charT&gt;
class ctype_byname : public ctype&lt;charT&gt; {
public:
    typedef typename ctype&lt;charT&gt;::mask mask;
    explicit ctype_byname(const char*, size_t refs {{=}} 0);
    explicit ctype_byname(const string&amp;, size_t refs {{=}} 0);
    protected:
    ~ctype_byname();
};


}}

====Class {{c|std::ctype&lt;char&gt;}}====
{{source|

template &lt;&gt; class ctype&lt;char&gt;
    : public locale::facet, public ctype_base
{
public:
    typedef char char_type;
    explicit ctype(const mask* tab {{=}} 0, bool del {{=}} false,
                   size_t refs {{=}} 0);
    bool is(mask m, char c) const;
    const char* is(const char* low, const char* high, mask* vec) const;
    const char* scan_is (mask m,
                         const char* low, const char* high) const;
    const char* scan_not(mask m,
                         const char* low, const char* high) const;
    char        toupper(char c) const;
    const char* toupper(char* low, const char* high) const;
    char        tolower(char c) const;
    const char* tolower(char* low, const char* high) const;
    char        widen(char c) const;
    const char* widen(const char* low, const char* high, char* to) const;
    char        narrow(char c, char dfault) const;
    const char* narrow(const char* low, const char* high, char dfault,
                       char* to) const;
                       
    static locale::id id;
    
    static const size_t table_size {{=}} implementation-defined;
    const mask* table() const noexcept;
    static const mask* classic_table() noexcept;
    
protected:
    ~ctype();
    virtual char        do_toupper(char c) const;
    virtual const char* do_toupper(char* low, const char* high) const;
    virtual char        do_tolower(char c) const;
    virtual const char* do_tolower(char* low, const char* high) const;
    virtual char        do_widen(char c) const;
    virtual const char* do_widen(const char* low,
                                 const char* high,
                                 char* to) const;
    virtual char        do_narrow(char c, char dfault) const;
    virtual const char* do_narrow(const char* low,
                                  const char* high,
                                  char dfault, char* to) const;
};

}}

====Class {{lc|std::codecvt_base}}====
{{source|

class codecvt_base
{
public:
    enum result { ok, partial, error, noconv };
};

}}

====Class {{lc|std::codecvt}}====
{{source|

template &lt;class internT, class externT, class stateT&gt;
class codecvt : public locale::facet, public codecvt_base
{
public:
        typedef internT intern_type;
        typedef externT extern_type;
        typedef stateT state_type;
        explicit codecvt(size_t refs {{=}} 0);
        result out(stateT&amp; state,
                   const internT* from, const internT* from_end, 
                   const internT*&amp; from_next,
                   externT* to, externT* to_end, externT*&amp; to_next) const;
        result unshift(stateT&amp; state, externT* to,
                       externT* to_end, externT*&amp; to_next) const;
        result in(stateT&amp; state,
                  const externT* from, const externT* from_end, 
                  const externT*&amp; from_next,
                  internT* to,
                  internT* to_end, internT*&amp; to_next) const;
        int encoding() const noexcept;
        bool always_noconv() const noexcept;
        int length(stateT&amp;, const externT* from, const externT* end,
                   size_t max) const;
        int max_length() const noexcept;
        static locale::id id;
protected:
        ~codecvt();
        virtual result do_out(stateT&amp; state,
                              const internT* from, const internT* from_end, 
                              const internT*&amp; from_next,
                              externT* to,
                              externT* to_end, externT*&amp; to_next) const;
        virtual result do_in(stateT&amp; state,
                             const externT* from, const externT* from_end, 
                             const externT*&amp; from_next,
                             internT* to,
                             internT* to_end, internT*&amp; to_next) const;
        virtual result do_unshift(stateT&amp; state,
                                  externT* to,
                                  externT* to_end, externT*&amp; to_next) const;
        virtual int do_encoding() const noexcept;
        virtual bool do_always_noconv() const noexcept;
        virtual int do_length(stateT&amp;, const externT* from,
                              const externT* end, size_t max) const;
        virtual int do_max_length() const noexcept;
};

}}

====Class {{lc|std::codecvt_byname}}====
{{source|

template &lt;class internT, class externT, class stateT&gt;
class codecvt_byname : public codecvt&lt;internT, externT, stateT&gt; {
public:
    explicit codecvt_byname(const char*, size_t refs {{=}} 0);
    explicit codecvt_byname(const string&amp;, size_t refs {{=}} 0);
protected:
    ~codecvt_byname();
};

}}


====Class {{lc|std::num_get}}====
{{source|

template &lt;class charT, class InputIterator {{=}} istreambuf_iterator&lt;charT&gt; &gt;
class num_get : public locale::facet
{
public:
    typedef charT           char_type;
    typedef InputIterator   iter_type;
    explicit num_get(size_t refs {{=}} 0);
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, bool&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp; ,
                  ios_base::iostate&amp; err, long&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp; ,
                  ios_base::iostate&amp; err, long long&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, unsigned short&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, unsigned int&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, unsigned long&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp; ,
                  ios_base::iostate&amp; err, unsigned long long&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, float&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, double&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, long double&amp; v) const;
    iter_type get(iter_type in, iter_type end, ios_base&amp;,
                  ios_base::iostate&amp; err, void*&amp; v) const;
     
    static locale::id id;
     
     
protected:
    ~num_get();
    
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, bool&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, long&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, long long&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, unsigned short&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, unsigned int&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, unsigned long&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, unsigned long long&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, float&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, double&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, long double&amp; v) const;
    virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
                             ios_base::iostate&amp; err, void*&amp; v) const;
};

}}

{{todo|Synopses for numpunct, collate, time_get, time_put, money_get, money_put, money_punct, messages, *_byname }}</text>
      <sha1>djlj6p8cjhctm5gocyo18vfyq7y5ozb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/map</title>
    <ns>0</ns>
    <id>9694</id>
    <revision>
      <id>57508</id>
      <parentid>49582</parentid>
      <timestamp>2013-06-01T05:54:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="13884">{{cpp/header/title|map}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc map}}
{{dsc inc | cpp/container/dsc multimap}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | map}}
{{dsc inc | cpp/container/dsc swap2 | map}}
{{dsc inc | cpp/container/dsc operator_cmp | multimap}}
{{dsc inc | cpp/container/dsc swap2 | multimap}}
{{dsc end}}


===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    template &lt;class Key, class T, class Compare {{=}} less&lt;Key&gt;,
              class Allocator {{=}} allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
        class map;
        
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator{{=}}{{=}}(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator!{{=}}(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&gt;{{=}}(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&lt;{{=}}(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
        
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,
                  map&lt;Key,T,Compare,Allocator&gt;&amp; y);

        
    template &lt;class Key, class T, class Compare {{=}} less&lt;Key&gt;,
              class Allocator {{=}} allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
        class multimap;
        
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator{{=}}{{=}}(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator!{{=}}(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&gt;{{=}}(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        bool operator&lt;{{=}}(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                        const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
        
    template &lt;class Key, class T, class Compare, class Allocator&gt;
        void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
                  multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
}

}}

====Class {{lc|std::map}}====
{{source|

template &lt;class Key, class T, class Compare {{=}} less&lt;Key&gt;,
          class Allocator {{=}} allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
class map {
public:
    // types:
    typedef Key                                                 key_type;
    typedef T                                                   mapped_type;
    typedef pair&lt;const Key, T&gt;                                  value_type;
    typedef Compare                                             key_compare;
    typedef Allocator                                           allocator_type;
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    class value_compare {
        friend class map;
    protected:
        Compare comp;
        value_compare(Compare c) : comp(c) {}
    public:
        typedef bool        result_type;
        typedef value_type  first_argument_type;
        typedef value_type  second_argument_type;
        bool operator()(const value_type&amp; x, const value_type&amp; y) const {
            return comp(x.first, y.first);
        }
    };
        
    explicit map(const Compare&amp; comp {{=}} Compare(),
                 const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        map(InputIterator first, InputIterator last,
            const Compare&amp; comp {{=}} Compare(), const Allocator&amp; {{=}} Allocator());
    map(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
    map(map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x);
    explicit map(const Allocator&amp;);
    map(const map&amp;, const Allocator&amp;);
    map(map&amp;&amp;, const Allocator&amp;);
    map(initializer_list&lt;value_type&gt;,
        const Compare&amp; {{=}} Compare(),
        const Allocator&amp; {{=}} Allocator());
    
    ~map();
    
    map&lt;Key,T,Compare,Allocator&gt;&amp;
        operator{{=}}(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
    map&lt;Key,T,Compare,Allocator&gt;&amp;
        operator{{=}}(map&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x);
    map&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    
    allocator_type get_allocator() const noexcept;


    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    
    // element access:
    T&amp; operator[](const key_type&amp; x);
    T&amp; operator[](key_type&amp;&amp; x);
    T&amp;       at(const key_type&amp; x);
    const T&amp; at(const key_type&amp; x) const;

    // modifiers:
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; 
        iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    pair&lt;iterator, bool&gt; insert(const value_type&amp; x);
    template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
        iterator insert(const_iterator position, const value_type&amp; x);
    template &lt;class P&gt;
        iterator insert(const_iterator position, P&amp;&amp;);
    template &lt;class InputIterator&gt;
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; x);
    iterator erase(const_iterator first, const_iterator last);
    void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;);
    void clear() noexcept;

    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
    
    //map operations:
    iterator        find(const key_type&amp; x);
    const_iterator  find(const key_type&amp; x) const;
    size_type       count(const key_type&amp; x) const;
    
    iterator        lower_bound(const key_type&amp; x);
    const_iterator  lower_bound(const key_type&amp; x) const;
    iterator        upper_bound(const key_type&amp; x);
    const_iterator  upper_bound(const key_type&amp; x) const;

    pair&lt;iterator,iterator&gt; 
        equal_range(const key_type&amp; x);
    pair&lt;const_iterator,const_iterator&gt; 
        equal_range(const key_type&amp; x) const;
};


}}
====Class {{lc|std::multimap}}====
{{source|

template &lt;class Key, class T, class Compare {{=}} less&lt;Key&gt;,
          class Allocator {{=}} allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
class multimap {
public:
    // types:
    typedef Key                                                 key_type;
    typedef T                                                   mapped_type;
    typedef pair&lt;const Key, T&gt;                                  value_type;
    typedef Compare                                             key_compare;
    typedef Allocator                                           allocator_type;
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    class value_compare {
        friend class multimap;
    protected:
        Compare comp;
        value_compare(Compare c) : comp(c) {}
    public:
        typedef bool        result_type;
        typedef value_type  first_argument_type;
        typedef value_type  second_argument_type;
        bool operator()(const value_type&amp; x, const value_type&amp; y) const {
            return comp(x.first, y.first);
        }
    };
        
    explicit multimap(const Compare&amp; comp {{=}} Compare(),
                 const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        multimap(InputIterator first, InputIterator last,
            const Compare&amp; comp {{=}} Compare(), const Allocator&amp; {{=}} Allocator());
    multimap(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
    multimap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x);
    explicit multimap(const Allocator&amp;);
    multimap(const multimap&amp;, const Allocator&amp;);
    multimap(multimap&amp;&amp;, const Allocator&amp;);
    multimap(initializer_list&lt;value_type&gt;,
        const Compare&amp; {{=}} Compare(),
        const Allocator&amp; {{=}} Allocator());
    
    ~multimap();
    
    multimap&lt;Key,T,Compare,Allocator&gt;&amp;
        operator{{=}}(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
    multimap&lt;Key,T,Compare,Allocator&gt;&amp;
        operator{{=}}(multimap&lt;Key,T,Compare,Allocator&gt;&amp;&amp; x);
    multimap&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    
    allocator_type get_allocator() const noexcept;


    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;

    // modifiers:
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    pair&lt;iterator, bool&gt; insert(const value_type&amp; x);
    template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; x);
        iterator insert(const_iterator position, const value_type&amp; x);
    template &lt;class P&gt;
        iterator insert(const_iterator position, P&amp;&amp;);
    template &lt;class InputIterator&gt;
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; x);
    iterator erase(const_iterator first, const_iterator last);
    void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;);
    void clear() noexcept;

    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
    
    //multimap operations:
    iterator        find(const key_type&amp; x);
    const_iterator  find(const key_type&amp; x) const;
    size_type       count(const key_type&amp; x) const;
    
    iterator        lower_bound(const key_type&amp; x);
    const_iterator  lower_bound(const key_type&amp; x) const;
    iterator        upper_bound(const key_type&amp; x);
    const_iterator  upper_bound(const key_type&amp; x) const;

    pair&lt;iterator,iterator&gt; 
        equal_range(const key_type&amp; x);
    pair&lt;const_iterator,const_iterator&gt; 
        equal_range(const key_type&amp; x) const;
};


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/memory</title>
    <ns>0</ns>
    <id>9769</id>
    <revision>
      <id>57511</id>
      <parentid>49583</parentid>
      <timestamp>2013-06-01T05:54:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="12426">{{cpp/header/title|memory}}
{{cpp/header/navbar}}

This header is part of the [[cpp/memory|dynamic memory management]] library.

===Classes===
{{dsc begin}}
{{dsc h2 |Smart pointers categories}}
{{dsc inc | cpp/memory/dsc unique_ptr}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc inc | cpp/memory/dsc weak_ptr}}
{{dsc inc | cpp/memory/dsc auto_ptr}}
{{dsc h2 | Smart pointers helper classes}}
{{dsc inc | cpp/memory/dsc owner_less}}
{{dsc inc | cpp/memory/dsc enable_shared_from_this}}
{{dsc inc | cpp/memory/dsc bad_weak_ptr}}
{{dsc inc | cpp/memory/dsc default_delete}}

{{dsc h2 | Allocators}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc allocator_arg_t}}
{{dsc inc | cpp/memory/dsc allocator_arg}}
{{dsc inc | cpp/memory/dsc uses_allocator}}

{{dsc h2|Other}}
{{dsc inc | cpp/memory/gc/dsc pointer_safety}}
{{dsc inc | cpp/memory/dsc pointer_traits}}
{{dsc inc | cpp/memory/shared_ptr/dsc hash}}
{{dsc inc | cpp/memory/unique_ptr/dsc hash}}

{{dsc h2|Forward declaration}}
{{dsc header|functional}}
{{dsc inc | cpp/utility/dsc hash}}

{{dsc h1|Constants}}
{{dsc inc | cpp/memory/dsc allocator_arg}}

{{dsc end}}

===Functions===
{{dsc begin}}

{{dsc h2|Uninitialized storage}}
{{dsc inc | cpp/memory/dsc uninitialized_copy}}
{{dsc inc | cpp/memory/dsc uninitialized_copy_n}}
{{dsc inc | cpp/memory/dsc uninitialized_fill}}
{{dsc inc | cpp/memory/dsc uninitialized_fill_n}}
{{dsc inc | cpp/memory/dsc raw_storage_iterator}}
{{dsc inc | cpp/memory/dsc get_temporary_buffer}}
{{dsc inc | cpp/memory/dsc return_temporary_buffer}}

{{dsc h2 | Garbage collector support}}
{{dsc inc | cpp/memory/gc/dsc declare_reachable}}
{{dsc inc | cpp/memory/gc/dsc undeclare_reachable}}
{{dsc inc | cpp/memory/gc/dsc declare_no_pointers}}
{{dsc inc | cpp/memory/gc/dsc undeclare_no_pointers}}
{{dsc inc | cpp/memory/gc/dsc get_pointer_safety}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/memory/dsc addressof}}
{{dsc inc | cpp/memory/dsc align}}

{{dsc h2|Smart pointer non-member operations}}
{{dsc inc | cpp/memory/shared_ptr/dsc make_shared}}
{{dsc inc | cpp/memory/shared_ptr/dsc allocate_shared}}
{{dsc inc | cpp/memory/shared_ptr/dsc pointer_cast}}
{{dsc inc | cpp/memory/shared_ptr/dsc get_deleter}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator_cmp}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator_ltlt}}
{{dsc inc | cpp/memory/shared_ptr/dsc swap2}}
{{dsc break}}
{{dsc inc | cpp/memory/shared_ptr/dsc atomic}}
{{dsc break}}

{{dsc inc | cpp/memory/unique_ptr/dsc operator_cmp}}
{{dsc inc | cpp/memory/unique_ptr/dsc swap2}}

{{dsc inc | cpp/memory/weak_ptr/dsc swap2}}

{{dsc h2|Allocator non-member operations}}
{{dsc inc | cpp/memory/allocator/dsc operator_cmp}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc operator_cmp}}

{{dsc end}}

===Synopsis===
{{source|

namespace std {
    // pointer traits
    template &lt;class Ptr&gt; struct pointer_traits;
    template &lt;class T&gt; struct pointer_traits&lt;T*&gt;;
    
    // pointer safety
    enum class pointer_safety { relaxed, preferred, strict };
    void declare_reachable(void *p);
    template &lt;class T&gt; T *undeclare_reachable(T *p);
    void declare_no_pointers(char *p, size_t n);
    void undeclare_no_pointers(char *p, size_t n);
    pointer_safety get_pointer_safety() noexcept;
    
    // pointer alignment function
    void *align(std::size_t alignment, std::size_t size,
                void *&amp;ptr, std::size_t&amp; space);
    
    // allocator argument tag
    struct allocator_arg_t { };
    constexpr allocator_arg_t allocator_arg {{=}} allocator_arg_t();
    
    // uses_allocator
    template &lt;class T, class Alloc&gt; struct uses_allocator;
    
    // allocator traits
    template &lt;class Alloc&gt; struct allocator_traits;
    
    // the default allocator:
    template &lt;class T&gt; class allocator;
    template &lt;&gt; class allocator&lt;void&gt;;
    template &lt;class T, class U&gt;
        bool operator{{=}}{{=}}(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;
    template &lt;class T, class U&gt;
        bool operator!{{=}}(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) noexcept;
        
    // raw storage iterator:
    template &lt;class OutputIterator, class T&gt; class raw_storage_iterator;
    
    // temporary buffers:
    template &lt;class T&gt;
        pair&lt;T*,ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n) noexcept;
    template &lt;class T&gt;
        void return_temporary_buffer(T* p);
        
    // specialized algorithms:
    template &lt;class T&gt; T* addressof(T&amp; r) noexcept;
    template &lt;class InputIterator, class ForwardIterator&gt;
        ForwardIterator uninitialized_copy(InputIterator first, InputIterator last,
                                           ForwardIterator result);
    template &lt;class InputIterator, class Size, class ForwardIterator&gt;
        ForwardIterator uninitialized_copy_n(InputIterator first, Size n,
                                             ForwardIterator result);
    template &lt;class ForwardIterator, class T&gt;
        void uninitialized_fill(ForwardIterator first, ForwardIterator last,
                                const T&amp; x);
    template &lt;class ForwardIterator, class Size, class T&gt;
        ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
    // class template unique_ptr:
    template &lt;class T&gt; class default_delete;
    template &lt;class T&gt; class default_delete&lt;T[]&gt;;
    template &lt;class T, class D {{=}} default_delete&lt;T&gt;&gt; class unique_ptr;
    template &lt;class T, class D&gt; class unique_ptr&lt;T[], D&gt;;
    
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator{{=}}{{=}}(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator!{{=}}(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator&lt;{{=}}(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
    template &lt;class T1, class D1, class T2, class D2&gt;
        bool operator&gt;{{=}}(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
        
    template &lt;class T, class D&gt;
        bool operator{{=}}{{=}}(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T, class D&gt;
        bool operator{{=}}{{=}}(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;
    template &lt;class T, class D&gt;
        bool operator!{{=}}(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T, class D&gt;
        bool operator!{{=}}(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y) noexcept;
        
    template &lt;class T, class D&gt;
        bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
    template &lt;class T, class D&gt;
        bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
    template &lt;class T, class D&gt;
        bool operator&lt;{{=}}(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
    template &lt;class T, class D&gt;
        bool operator&lt;{{=}}(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
    template &lt;class T, class D&gt;
        bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
    template &lt;class T, class D&gt;
        bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
    template &lt;class T, class D&gt;
        bool operator&gt;{{=}}(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
    template &lt;class T, class D&gt;
        bool operator&gt;{{=}}(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
        
    // class bad_weak_ptr:
    class bad_weak_ptr;
    
    // class template shared_ptr:
    template&lt;class T&gt; class shared_ptr;
    
    // shared_ptr comparisons:
    template&lt;class T, class U&gt;
        bool operator{{=}}{{=}}(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
    template&lt;class T, class U&gt;
        bool operator!{{=}}(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
    template&lt;class T, class U&gt;
        bool operator&lt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
    template&lt;class T, class U&gt;
        bool operator&gt;(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
    template&lt;class T, class U&gt;
        bool operator&lt;{{=}}(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
    template&lt;class T, class U&gt;
        bool operator&gt;{{=}}(shared_ptr&lt;T&gt; const&amp; a, shared_ptr&lt;U&gt; const&amp; b) noexcept;
        
    template &lt;class T&gt;
        bool operator{{=}}{{=}}(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
        bool operator{{=}}{{=}}(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
    template &lt;class T&gt;
        bool operator!{{=}}(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
        bool operator!{{=}}(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
    template &lt;class T&gt;
        bool operator&lt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
        bool operator&lt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
    template &lt;class T&gt;
        bool operator&lt;{{=}}(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
        bool operator&lt;{{=}}(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
    template &lt;class T&gt;
        bool operator&gt;(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
    bool operator&gt;(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
    template &lt;class T&gt;
        bool operator&gt;{{=}}(const shared_ptr&lt;T&gt;&amp; x, nullptr_t) noexcept;
    template &lt;class T&gt;
        bool operator&gt;{{=}}(nullptr_t, const shared_ptr&lt;T&gt;&amp; y) noexcept;
        
    // shared_ptr specialized algorithms:
    template&lt;class T&gt; void swap(shared_ptr&lt;T&gt;&amp; a, shared_ptr&lt;T&gt;&amp; b) noexcept;
    
    // shared_ptr casts:
    template&lt;class T, class U&gt;
        shared_ptr&lt;T&gt; static_pointer_cast(shared_ptr&lt;U&gt; const&amp; r) noexcept;
    template&lt;class T, class U&gt;
        shared_ptr&lt;T&gt; dynamic_pointer_cast(shared_ptr&lt;U&gt; const&amp; r) noexcept;
    template&lt;class T, class U&gt;
        shared_ptr&lt;T&gt; const_pointer_cast(shared_ptr&lt;U&gt; const&amp; r) noexcept;
        
    // shared_ptr get_deleter:
    template&lt;class D, class T&gt; D* get_deleter(shared_ptr&lt;T&gt; const&amp; p) noexcept;
    
    // shared_ptr I/O:
    template&lt;class E, class T, class Y&gt;
        basic_ostream&lt;E, T&gt;&amp; operator&lt;&lt; (basic_ostream&lt;E, T&gt;&amp; os, shared_ptr&lt;Y&gt; const&amp; p);
        
    // class template weak_ptr:
    template&lt;class T&gt; class weak_ptr;
    
    // weak_ptr specialized algorithms:
    template&lt;class T&gt; void swap(weak_ptr&lt;T&gt;&amp; a, weak_ptr&lt;T&gt;&amp; b) noexcept;
    
    // class template owner_less:
    template&lt;class T&gt; class owner_less;
    
    // class template enable_shared_from_this:
    template&lt;class T&gt; class enable_shared_from_this;
    
    // shared_ptr atomic access:
    template&lt;class T&gt;
        bool atomic_is_lock_free(const shared_ptr&lt;T&gt;* p);
    template&lt;class T&gt;
        shared_ptr&lt;T&gt; atomic_load(const shared_ptr&lt;T&gt;* p);
    template&lt;class T&gt;
        shared_ptr&lt;T&gt; atomic_load_explicit(const shared_ptr&lt;T&gt;* p, memory_order mo);
    template&lt;class T&gt;
        void atomic_store(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r);
    template&lt;class T&gt;
        void atomic_store_explicit(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r, memory_order mo);
    template&lt;class T&gt;
        shared_ptr&lt;T&gt; atomic_exchange(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r);
    template&lt;class T&gt;
        shared_ptr&lt;T&gt; atomic_exchange_explicit(shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt; r,
                                                memory_order mo);
    template&lt;class T&gt;
        bool atomic_compare_exchange_weak(
            shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt;  w);
    template&lt;class T&gt;
        bool atomic_compare_exchange_strong(
            shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt;  w);
    template&lt;class T&gt;
        bool atomic_compare_exchange_weak_explicit(
            shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w,
            memory_order success, memory_order failure);
    template&lt;class T&gt;
        bool atomic_compare_exchange_strong_explicit(
            shared_ptr&lt;T&gt;* p, shared_ptr&lt;T&gt;* v, shared_ptr&lt;T&gt; w,
            memory_order success, memory_order failure);
   
    //  hash support
    template &lt;class T&gt; struct hash;
    template &lt;class T, class D&gt; struct hash&lt;unique_ptr&lt;T, D&gt; &gt;;
    template &lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt; &gt;;
    
    // auto_ptr (deprecated)
    template &lt;class X&gt; class auto_ptr;
}


}}

{{todo|Class synopses}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/mutex</title>
    <ns>0</ns>
    <id>12861</id>
    <revision>
      <id>64006</id>
      <parentid>64005</parentid>
      <timestamp>2013-08-06T03:55:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="5775">{{cpp/header/title|mutex}}
{{cpp/header/navbar}}
This header is part of the [[cpp/thread|thread support]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/thread/dsc mutex}}
{{dsc inc | cpp/thread/dsc timed_mutex}}
{{dsc inc | cpp/thread/dsc recursive_mutex}}
{{dsc inc | cpp/thread/dsc recursive_timed_mutex}}
{{dsc inc | cpp/thread/dsc lock_guard}}
{{dsc inc | cpp/thread/dsc unique_lock}}
{{dsc inc | cpp/thread/dsc lock_tag_t}}
{{dsc inc | cpp/thread/dsc lock_tag}}
{{dsc inc | cpp/thread/dsc once_flag}}
{{dsc h1|Functions}}
{{dsc inc | cpp/thread/dsc try_lock}}
{{dsc inc | cpp/thread/dsc lock}}
{{dsc inc | cpp/thread/dsc call_once}}
{{dsc inc | cpp/thread/unique_lock/dsc swap2}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    class mutex;
    class recursive_mutex;
    class timed_mutex;
    class recursive_timed_mutex;

    struct defer_lock_t { };
    constexpr defer_lock_t defer_lock { };

    struct try_to_lock_t { };
    constexpr try_to_lock_t try_to_lock { };

    struct adopt_lock_t { };
    constexpr adopt_lock_t adopt_lock { };

    template &lt;class Mutex&gt; class lock_guard;
    template &lt;class Mutex&gt; class unique_lock;

    template &lt;class Mutex&gt;
    void swap(unique_lock&lt;Mutex&gt;&amp; x,
              unique_lock&lt;Mutex&gt;&amp; y) noexcept;

    template &lt;class L1, class L2, class... L3&gt;
    int try_lock(L1&amp;, L2&amp;, L3&amp;...);

    template &lt;class L1, class L2, class... L3&gt;
    void lock(L1&amp;, L2&amp;, L3&amp;...);

    struct once_flag;

    template&lt;class Callable, class ...Args&gt;
    void call_once(once_flag&amp; flag, Callable func, Args&amp;&amp;... args);
}
}}

====Class {{lc|std::mutex}}====
{{source|1=
class mutex {
 public:
    constexpr mutex() noexcept;
    ~mutex();
    mutex(const mutex&amp;) = delete;
    mutex&amp; operator=(const mutex&amp;) = delete;

    void lock();
    bool try_lock();
    void unlock();
    typedef /*implementation-defined*/ native_handle_type;
    native_handle_type native_handle();
};
}}

====Class {{lc|std::recursive_mutex}}====
{{source|1=
class recursive_mutex {
 public:
    recursive_mutex();
    ~recursive_mutex();
    recursive_mutex(const recursive_mutex&amp;) = delete;
    recursive_mutex&amp; operator=(const recursive_mutex&amp;) = delete;

    void lock();
    bool try_lock() noexcept;
    void unlock();
    typedef /*implementation-defined*/ native_handle_type;
    native_handle_type native_handle();
};
}}

====Class {{lc|std::timed_mutex}}====
{{source|1=
class timed_mutex {
 public:
    timed_mutex();
    ~timed_mutex();
    timed_mutex(const timed_mutex&amp;) = delete;
    timed_mutex&amp; operator=(const timed_mutex&amp;) = delete;

    void lock();
    bool try_lock();
    template &lt;class Rep, class Period&gt;
        bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
        bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock();
    typedef /*implementation-defined*/ native_handle_type;
    native_handle_type native_handle();
};
}}

====Class {{lc|std::recursive_timed_mutex}}====
{{source|1=
class recursive_timed_mutex {
 public:
    recursive_timed_mutex();
    ~recursive_timed_mutex();
    recursive_timed_mutex(const recursive_timed_mutex&amp;) = delete;
    recursive_timed_mutex&amp; operator=(const recursive_timed_mutex&amp;) = delete;

    void lock();
    bool try_lock() noexcept;
    template &lt;class Rep, class Period&gt;
        bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
        bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock();
    typedef /*implementation-defined*/ native_handle_type;
    native_handle_type native_handle();
};
}}

====Class {{lc|std::lock_guard}}====
{{source|1=
template &lt;class Mutex&gt;
class lock_guard {
 public:
    typedef Mutex mutex_type;
    explicit lock_guard(mutex_type&amp; m);
    lock_guard(mutex_type&amp; m, adopt_lock_t);
    ~lock_guard();
    lock_guard(lock_guard const&amp;) = delete;
    lock_guard&amp; operator=(lock_guard const&amp;) = delete;
 private:
    mutex_type&amp; pm; // exposition only
};
}}

====Class {{lc|std::unique_lock}}====
{{source|1=
template &lt;class Mutex&gt;
class unique_lock {
 public:
    typedef Mutex mutex_type;

    // construct/copy/destroy:
    unique_lock() noexcept;
    explicit unique_lock(mutex_type&amp; m);
    unique_lock(mutex_type&amp; m, defer_lock_t) noexcept;
    unique_lock(mutex_type&amp; m, try_to_lock_t);
    unique_lock(mutex_type&amp; m, adopt_lock_t);
    template &lt;class Clock, class Duration&gt;
    unique_lock(mutex_type&amp; m, const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    template &lt;class Rep, class Period&gt;
    unique_lock(mutex_type&amp; m, const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    ~unique_lock();
    unique_lock(unique_lock const&amp;) = delete;
    unique_lock&amp; operator=(unique_lock const&amp;) = delete;
    unique_lock(unique_lock&amp;&amp; u) noexcept;
    unique_lock&amp; operator=(unique_lock&amp;&amp; u) noexcept;

    // locking:
    void lock();
    bool try_lock();
    template &lt;class Rep, class Period&gt;
    bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
    bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock();

    // modifiers:
    void swap(unique_lock&amp; u) noexcept;
    mutex_type *release() noexcept;

    // observers:
    bool owns_lock() const noexcept;
    explicit operator bool () const noexcept;
    mutex_type* mutex() const noexcept;

 private:
    mutex_type *pm; // exposition only
    bool owns; // exposition only
};
}}

====Class {{lc|std::once_flag}}====
{{source|1=
struct once_flag {
    constexpr once_flag() noexcept;
    once_flag(const once_flag&amp;) = delete;
    once_flag&amp; operator=(const once_flag&amp;) = delete;
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/new</title>
    <ns>0</ns>
    <id>9666</id>
    <revision>
      <id>57512</id>
      <parentid>49584</parentid>
      <timestamp>2013-06-01T05:54:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1705">{{cpp/header/title|new}}
{{cpp/header/navbar}}
This header is part of the [[cpp/memory|dynamic memory management]] library, in particular provides [[cpp/memory/new|low level memory management]] features.

{{dsc begin}}
{{dsc h2 | Functions}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc operator_delete}}
{{dsc inc | cpp/memory/new/dsc get_new_handler}}
{{dsc inc | cpp/memory/new/dsc set_new_handler}}
{{dsc h2 | Classes }}
{{dsc inc | cpp/memory/new/dsc bad_alloc}}
{{dsc inc | cpp/memory/new/dsc bad_array_new_length}}
{{dsc inc | cpp/memory/new/dsc nothrow_t}}
{{dsc h2 | Types }}
{{dsc inc | cpp/memory/new/dsc new_handler}}
{{dsc h2 | Objects}}
{{dsc inc | cpp/memory/new/dsc nothrow}}
{{dsc end}}


===Synopsis===

{{source|

namespace std {
    class bad_alloc;
    class bad_array_new_length;
    struct nothrow_t {};
    extern const nothrow_t nothrow;
    typedef void (*new_handler)();
    new_handler get_new_handler() noexcept;
    new_handler set_new_handler(new_handler new_p) noexcept;
}

void* operator new(std::size_t size);
void* operator new(std::size_t size, const std::nothrow_t&amp;) noexcept;
void  operator delete(void* ptr) noexcept;
void  operator delete(void* ptr, const std::nothrow_t&amp;) noexcept;
void* operator new[](std::size_t size);
void* operator new[](std::size_t size, const std::nothrow_t&amp;) noexcept;
void  operator delete[](void* ptr) noexcept;
void  operator delete([]void* ptr, const std::nothrow_t&amp;) noexcept;

void* operator new  (std::size_t size, void* ptr) noexcept;
void* operator new[](std::size_t size, void* ptr) noexcept;
void operator delete (void* ptr, void*) noexcept;
void operator delete[](void* ptr, void*) noexcept;

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/numeric</title>
    <ns>0</ns>
    <id>9794</id>
    <revision>
      <id>57517</id>
      <parentid>49585</parentid>
      <timestamp>2013-06-01T05:54:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2253">{{cpp/header/title|numeric}}
{{cpp/header/navbar}}

This header is part of the [[cpp/numeric|numeric]] library.

===Functions===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc iota}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc inc | cpp/algorithm/dsc inner_product}}
{{dsc inc | cpp/algorithm/dsc adjacent_difference}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    template &lt;class InputIterator, class T&gt;
        T accumulate(InputIterator first, InputIterator last, T init);
    template &lt;class InputIterator, class T, class BinaryOperation&gt;
        T accumulate(InputIterator first, InputIterator last, T init,
            BinaryOperation binary_op);
        
    template &lt;class InputIterator1, class InputIterator2, class T&gt;
        T inner_product(InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, T init);
    template &lt;class InputIterator1, class InputIterator2, class T,
            class BinaryOperation1, class BinaryOperation2&gt;
        T inner_product(InputIterator1 first1, InputIterator1 last1,
            InputIterator2 first2, T init,
            BinaryOperation1 binary_op1,
            BinaryOperation2 binary_op2);
        
    template &lt;class InputIterator, class OutputIterator&gt;
        OutputIterator partial_sum(InputIterator first,
            InputIterator last,
            OutputIterator result);
    template &lt;class InputIterator, class OutputIterator,
            class BinaryOperation&gt;
        OutputIterator partial_sum(InputIterator first,
            InputIterator last,
            OutputIterator result,
            BinaryOperation binary_op);
    template &lt;class InputIterator, class OutputIterator&gt;
        OutputIterator adjacent_difference(InputIterator first,
            InputIterator last,
            OutputIterator result);
    template &lt;class InputIterator, class OutputIterator,
            class BinaryOperation&gt;
        OutputIterator adjacent_difference(InputIterator first,
            InputIterator last,
            OutputIterator result,
            BinaryOperation binary_op);
        
    template &lt;class ForwardIterator, class T&gt;
        void iota(ForwardIterator first, ForwardIterator last, T value);
}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/optional</title>
    <ns>0</ns>
    <id>12788</id>
    <revision>
      <id>68175</id>
      <parentid>66814</parentid>
      <timestamp>2014-03-17T01:39:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="4198">{{cpp/header/title|optional}}
{{cpp/header/navbar}}
{{fmbox | style=font-size: 0.8em; background-color:#ffffbb | text=After reviewing national body comments to n3690, this library component was voted out from C++14 working paper into a separate Technical Specification. It is not a part of the draft C++14 as of n3797.}}

This header is part of the [[cpp/utility|general utility]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/utility/dsc optional}}
{{dsc inc | cpp/utility/dsc bad_optional_access}}
{{dsc inc | cpp/utility/dsc in_place_t}}
{{dsc inc | cpp/experimental/optional/dsc hash}}
{{dsc inc | cpp/utility/dsc nullopt_t}}

{{dsc h1|Functions}}
{{dsc inc | cpp/experimental/optional/dsc operator_cmp}}
{{dsc inc | cpp/experimental/optional/dsc make_optional}}
{{dsc inc | cpp/experimental/optional/dsc swap2}}
{{dsc end}}

===Synopsis===
{{source|
#include &lt;initializer_list&gt;
namespace std {
    // 20.6.4, optional for object types
    template &lt;class T&gt; class optional;
    // 20.6.5, In-place construction
    struct in_place_t{};
    constexpr in_place_t in_place{};
    // 20.6.6, Disengaged state indicator
    struct nullopt_t;
    constexpr nullopt_t nullopt( /*unspecified*/ );
    // 20.6.7, class bad_optional_access
    class bad_optional_access;
    // 20.6.8, Relational operators
    template &lt;class T&gt; constexpr bool operator{{==}}(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const optional&lt;T&gt;&amp;);
    // 20.6.9, Comparison with nullopt
    template &lt;class T&gt; constexpr bool
    operator{{==}}(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool
    operator{{==}}(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    template &lt;class T&gt; constexpr bool
    operator&lt;(const optional&lt;T&gt;&amp;, nullopt_t) noexcept;
    template &lt;class T&gt; constexpr bool
    operator&lt;(nullopt_t, const optional&lt;T&gt;&amp;) noexcept;
    // 20.6.10, Comparison with T
    template &lt;class T&gt; constexpr bool operator{{==}}(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator{{==}}(const T&amp;, const optional&lt;T&gt;&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;(const optional&lt;T&gt;&amp;, const T&amp;);
    template &lt;class T&gt; constexpr bool operator&lt;(const T&amp;, const optional&lt;T&gt;&amp;);
    // 20.6.11, Specialized algorithms
    template &lt;class T&gt; void swap(optional&lt;T&gt;&amp;, optional&lt;T&gt;&amp;) noexcept(see below );
    template &lt;class T&gt; constexpr optional&lt;T&gt; make_optional(T&amp;&amp;);
    // 20.6.12, hash support
    template &lt;class T&gt; struct hash;
    template &lt;class T&gt; struct hash&lt;optional&lt;T&gt;&gt;;
} // namespace std

}}

====Class {{lc|std::experimental::optional}}====
{{source|

template &lt;class T&gt;
class optional
{
public:
    typedef T value_type;
    
    // 20.6.4.1, constructors
    constexpr optional() noexcept;
    constexpr optional(nullopt_t) noexcept;
    optional(const optional&amp;);
    optional(optional&amp;&amp;) noexcept(see below );
    constexpr optional(const T&amp;);
    constexpr optional(T&amp;&amp;);
    template &lt;class... Args&gt; constexpr explicit optional(in_place_t, Args&amp;&amp;...);
    template &lt;class U, class... Args&gt;
    constexpr explicit optional(in_place_t, initializer_list&lt;U&gt;, Args&amp;&amp;...);
    
    // 20.6.4.2, destructor
    ~optional();
    
    // 20.6.4.3, assignment
    optional&amp; operator{{=}}(nullopt_t) noexcept;
    optional&amp; operator{{=}}(const optional&amp;);
    optional&amp; operator{{=}}(optional&amp;&amp;) noexcept(see below );
    template &lt;class U&gt; optional&amp; operator{{=}}(U&amp;&amp;);
    template &lt;class... Args&gt; void emplace(Args&amp;&amp;...);
    template &lt;class U, class... Args&gt; void emplace(initializer_list&lt;U&gt;, Args&amp;&amp;...);
    
    // 20.6.4.4, swap
    void swap(optional&amp;) noexcept(see below );
    
    // 20.6.4.5, observers
    constexpr T const* operator-&gt;() const;
    T* operator-&gt;();
    constexpr T const&amp; operator*() const;
    T&amp; operator*();
    constexpr explicit operator bool() const noexcept;
    constexpr T const&amp; value() const;
    T&amp; value();
    template &lt;class U&gt; constexpr T value_or(U&amp;&amp;) const&amp;;
    template &lt;class U&gt; T value_or(U&amp;&amp;) &amp;&amp;;
    
private:
    bool init; // exposition only
    T* val; // exposition only
};

}}</text>
      <sha1>d0d0cxs4hozzn4nhq4b4ot2nb81yxzp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ostream</title>
    <ns>0</ns>
    <id>9670</id>
    <revision>
      <id>57518</id>
      <parentid>49586</parentid>
      <timestamp>2013-06-01T05:54:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="5322">{{cpp/header/title|ostream}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/output]] library.
{{dsc begin}}
{{dsc h1 | Classes}}
{{dsc tclass | cpp/io/basic_ostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level output interface}}
{{dsc|{{lc|std::ostream}}|{{c|basic_ostream&lt;char&gt;}}&lt;br/&gt; {{mark typedef}}}}
{{dsc|{{lc|std::wostream}}|{{c|basic_ostream&lt;wchar_t&gt;}}&lt;br/&gt; {{mark typedef}} }}
{{dsc h1 | Functions}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc h2 | Manipulators}}
{{dsc inc | cpp/io/manip/dsc ends}}
{{dsc inc | cpp/io/manip/dsc flush}}
{{dsc inc | cpp/io/manip/dsc endl}}
{{dsc end}}

===Synopsis===
{{source|
namespace std {
    template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
        class basic_ostream;
    typedef basic_ostream&lt;char&gt;    ostream;
    typedef basic_ostream&lt;wchar_t&gt; wostream;

    template &lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; endl(basic_ostream&lt;charT,traits&gt;&amp; os);
    template &lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; ends(basic_ostream&lt;charT,traits&gt;&amp; os);
    template &lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; flush(basic_ostream&lt;charT,traits&gt;&amp; os);

    template &lt;class charT, class traits, class T&gt;
        basic_ostream&lt;charT, traits&gt;&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;&amp; os, const T&amp; x);

    // character inserters
    template&lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;, charT);
    template&lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;, char);
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, char);

    // signed and unsigned
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, signed char);
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, unsigned char);
    template&lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;, const charT*);
    template&lt;class charT, class traits&gt;
        basic_ostream&lt;charT,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;, const char*);
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, const char*);

    // signed and unsigned
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, const signed char*);
    template&lt;class traits&gt;
        basic_ostream&lt;char,traits&gt;&amp; 
        operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;, const unsigned char*);
}

}}


====Class {{lc|std::basic_ostream}}====
{{source|

template &lt;class charT, class traits {{=}} char_traits&lt;charT&gt; &gt;
class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {
public:
    // types (inherited from basic_ios):
    typedef charT                     char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits                    traits_type;
    
    // Constructor/destructor:
    explicit basic_ostream(basic_streambuf&lt;char_type,traits&gt;* sb);
    virtual ~basic_ostream();
    
    // Prefix/suffix:
    class sentry;
    
    // Formatted output:
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(
        basic_ostream&lt;charT,traits&gt;&amp; (*pf)(basic_ostream&lt;charT,traits&gt;&amp;));
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(
        basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;));
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(
        ios_base&amp; (*pf)(ios_base&amp;));
    
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(bool n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(short n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned short n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(int n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned int n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned long n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long long n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned long long n);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(float f);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(double f);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long double f);
    
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(const void* p);
    basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(
        basic_streambuf&lt;char_type,traits&gt;* sb);

    // Unformatted output:
    basic_ostream&lt;charT,traits&gt;&amp; put(char_type c);
    basic_ostream&lt;charT,traits&gt;&amp; write(const char_type* s, streamsize n);
    
    basic_ostream&lt;charT,traits&gt;&amp; flush();

    // seeks:
    pos_type tellp();
    basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type);
    basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type, ios_base::seekdir);

protected:
    basic_ostream(const basic_ostream&amp; rhs) {{=}} delete;
    basic_ostream(basic_ostream&amp;&amp; rhs);

    // Assign/swap
    basic_ostream&amp; operator{{=}}(basic_ostream&amp; rhs) {{=}} delete;
    basic_ostream&amp; operator{{=}}(const basic_ostream&amp;&amp; rhs);
    void swap(basic_ostream&amp; rhs);
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/queue</title>
    <ns>0</ns>
    <id>12849</id>
    <revision>
      <id>63990</id>
      <timestamp>2013-08-06T00:05:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="5864">{{cpp/header/title|queue}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc queue}}
{{dsc inc | cpp/container/dsc priority_queue}}
{{dsc inc | cpp/container/dsc uses_allocator | queue}}
{{dsc inc | cpp/container/dsc uses_allocator | priority_queue}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | queue}}
{{dsc inc | cpp/container/dsc swap2 | queue}}
{{dsc inc | cpp/container/dsc swap2 | priority_queue}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    template &lt;class T, class Container = deque&lt;T&gt; &gt; class queue;

    template &lt;class T,
              class Container = vector&lt;T&gt;,
              class Compare = less&lt;typename Container::value_type&gt; &gt;
    class priority_queue;

    template &lt;class T, class Container&gt;
        bool operator==(const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator!=(const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);

    template &lt;class T, class Container&gt;
        bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,const queue&lt;T, Container&gt;&amp; y);

    template &lt;class T, class Container&gt;
        void swap(queue&lt;T, Container&gt;&amp; x, queue&lt;T, Container&gt;&amp; y)
            noexcept(noexcept(x.swap(y)));

    template &lt;class T, class Container, class Compare&gt;
        void swap(priority_queue&lt;T, Container, Compare&gt;&amp; x,
                  priority_queue&lt;T, Container, Compare&gt;&amp; y)
        noexcept(noexcept(x.swap(y)));

    template &lt;class T, class Container, class Alloc&gt;
        struct uses_allocator&lt;queue&lt;T, Container&gt;, Alloc&gt;
            : uses_allocator&lt;Container, Alloc&gt;::type { };

}
}}

====Class {{lc|std::queue}}====
{{source|1=
template &lt;class T, class Container = deque&lt;T&gt; &gt;
class queue {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 protected:
    Container c;
 public:
    explicit queue(const Container&amp;);
    explicit queue(Container&amp;&amp; = Container());
    template &lt;class Alloc&gt; explicit queue(const Alloc&amp;);
    template &lt;class Alloc&gt; queue(const Container&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; queue(Container&amp;&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; queue(const queue&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; queue(queue&amp;&amp;, const Alloc&amp;);

    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    reference front() {
        return c.front();
    }
    const_reference front() const {
        return c.front();
    }
    reference back() {
        return c.back();
    }
    const_reference back() const {
        return c.back();
    }
    void push(const value_type&amp; x) {
        c.push_back(x);
    }
    void push(value_type&amp;&amp; x) {
        c.push_back(std::move(x));
    }
    template &lt;class... Args&gt; void emplace(Args&amp;&amp;... args) {
        c.emplace_back(std::forward&lt;Args&gt;(args)...);
    }
    void pop() {
        c.pop_front();
    }
    void swap(queue&amp; q) noexcept(noexcept(swap(c, q.c))) {
        using std::swap;
        swap(c, q.c);
    }
};
}}

====Class {{lc|std::priority_queue}}====
{{source|1=
template &lt;class T,
          class Container = vector&lt;T&gt;,
          class Compare = less&lt;typename Container::value_type&gt; &gt;
class priority_queue {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 protected:
    Container c;
    Compare comp;
 public:
    priority_queue(const Compare&amp; x, const Container&amp;);
    explicit priority_queue(const Compare&amp; x = Compare(), Container&amp;&amp; = Container());
    template &lt;class InputIterator&gt;
    priority_queue(InputIterator first, InputIterator last,
                       const Compare&amp; x, const Container&amp;);
    template &lt;class InputIterator&gt;
    priority_queue(InputIterator first, InputIterator last,
                   const Compare&amp; x = Compare(), Container&amp;&amp; = Container());
    template &lt;class Alloc&gt; explicit priority_queue(const Alloc&amp;);
    template &lt;class Alloc&gt; priority_queue(const Compare&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; priority_queue(const Compare&amp;,
                                          const Container&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; priority_queue(const Compare&amp;,
                                          Container&amp;&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; priority_queue(const priority_queue&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; priority_queue(priority_queue&amp;&amp;, const Alloc&amp;);

    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    const_reference top() const {
        return c.front();
    }
    void push(const value_type&amp; x);
    void push(value_type&amp;&amp; x);
    template &lt;class... Args&gt; void emplace(Args&amp;&amp;... args);
    void pop();
    void swap(priority_queue&amp; q) noexcept( noexcept(swap(c, q.c))
                                        &amp;&amp; noexcept(swap(comp, q.comp))) {
        using std::swap;
        swap(c, q.c);
        swap(comp, q.comp);
    }
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/random</title>
    <ns>0</ns>
    <id>9771</id>
    <revision>
      <id>57523</id>
      <parentid>49587</parentid>
      <timestamp>2013-06-01T05:55:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="36003">{{cpp/header/title|random}}
{{cpp/header/navbar}}

This header is part of the [[cpp/numeric/random|pseudo-random number generation]] library.

===Classes===
{{dsc begin}}
{{dsc h2|Random number engines}}
{{dsc tclass | cpp/numeric/random/linear_congruential_engine | implements [[enwiki:Linear_congruential_generator | linear congruential]] algorithm | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/mersenne_twister_engine | implements [[enwiki:Mersenne_twister | Mersenne twister]] algorithm | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/subtract_with_carry_engine | implements subtract with carry (a [[enwiki:Lagged_Fibonacci_generator | lagged Fibonacci]]) algorithm | notes={{mark c++11}}}}

{{dsc h2|Random number engine adaptors}}
{{dsc tclass | cpp/numeric/random/discard_block_engine | discards some output of a random number engine | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/independent_bits_engine | packs the output of a random number engine into blocks of specified number of bits | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/shuffle_order_engine | delivers the output of a random number engine in different order | notes={{mark c++11}}}}


{{dsc h2|Predefined generators}}
{{dsc class | cpp/numeric/random/seed_seq | general-purpose bias-eliminating scrambled seed sequence generator | notes={{mark c++11}}}}
{{dsc | {{tt|minstd_rand0}} | {{c|std::linear_congruential_engine&lt;uint_fast32_t, 16807, 0, 2147483647&gt;}}}}
{{dsc | {{tt|minstd_rand}} | {{c|std::linear_congruential_engine&lt;uint_fast32_t, 48271, 0, 2147483647&gt;}}}}
{{dsc | {{tt|mt19937}} | {{c|std::mersenne_twister_engine&lt;uint_fast32_t, 32, 624, 397, 31, 
                             0x9908b0df, 11, 
                             0xffffffff, 7, 
                             0x9d2c5680, 15, 
                             0xefc60000, 18, 1812433253&gt;}}}}
{{dsc | {{tt|mt19937_64}} | {{c|std::mersenne_twister_engine&lt;uint_fast64_t, 64, 312, 156, 31,
                             0xb5026f5aa96619e9, 29,
                             0x5555555555555555, 17,
                             0x71d67fffeda60000, 37,
                             0xfff7eee000000000, 43, 6364136223846793005&gt;}}}}
{{dsc | {{tt|ranlux24_base}} | {{c|std::subtract_with_carry_engine&lt;uint_fast32_t, 24, 10, 24&gt;}}}}
{{dsc | {{tt|ranlux48_base}} | {{c|std::subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;}}}}
{{dsc | {{tt|ranlux24}} | {{c|std::discard_block_engine&lt;ranlux24_base, 223, 23&gt;}}}}
{{dsc | {{tt|ranlux48}} | {{c|std::discard_block_engine&lt;ranlux48_base, 389, 11&gt;}}}}
{{dsc | {{tt|knuth_b}} | {{c|std::shuffle_order_engine&lt;minstd_rand0, 256&gt;}}}}
{{dsc | {{tt|default_random_engine}} | ''implementation-defined''}}

{{dsc h2 | Uniform distributions}}
{{dsc tclass | cpp/numeric/random/uniform_int_distribution | produces integer values evenly distributed across a range | notes={{mark c++11}}}}
{{dsc inc | cpp/numeric/random/dsc uniform_real_distribution}}

{{dsc h2 | Bernoulli distributions}}
{{dsc class | cpp/numeric/random/bernoulli_distribution | produces {{c|bool}} values on a [[enwiki:Bernoulli_distribution | Bernoulli distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/binomial_distribution | produces integer values on a  [[enwiki:Binomial_distribution | binomial distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/negative_binomial_distribution | produces integer values on a  [[enwiki:Negative_binomial_distribution | negative binomial distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/geometric_distribution | produces integer values on a  [[enwiki:Geometric_distribution | geometric distribution]].  | notes={{mark c++11}}}}

{{dsc h2 | Poisson distributions}}
{{dsc tclass | cpp/numeric/random/poisson_distribution | produces integer values on a  [[enwiki:Poisson_distribution | poisson distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/exponential_distribution | produces real values on an  [[enwiki:Exponential_distribution | exponential distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/gamma_distribution | produces real values on an  [[enwiki:Gamma_distribution | gamma distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/weibull_distribution |produces real values on a  [[enwiki:Weibull_distribution | Weibull distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/extreme_value_distribution | produces real values on an  [[enwiki:Generalized_extreme_value_distribution | extreme value distribution]]. | notes={{mark c++11}}}}

{{dsc h2 | Normal distributions}}
{{dsc tclass | cpp/numeric/random/normal_distribution | produces real values on a  [[enwiki:Normal_distribution | standard normal (Gaussian) distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/lognormal_distribution | produces real values on a  [[enwiki:Lognormal_distribution | lognormal distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/chi_squared_distribution | produces real values on a  [[enwiki:Chi-squared_distribution | chi-squared distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/cauchy_distribution | produces real values on a  [[enwiki:Cauchy_distribution | Cauchy distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/fisher_f_distribution | produces real values on a  [[enwiki:F-distribution | Fisher's F-distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/student_t_distribution | produces real values on a  [[enwiki:Student's t-distribution | Student's t-distribution]]. | notes={{mark c++11}}}}

{{dsc h2 | Sampling distributions}}
{{dsc tclass | cpp/numeric/random/discrete_distribution | produces random integers on a discrete distribution. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/piecewise_constant_distribution | produces real values distributed on constant subintervals.| notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/piecewise_linear_distribution | produces real values distributed on defined subintervals. | notes={{mark c++11}}}}

{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc generate_canonical}}
{{dsc end}}


===Synopsis===
{{source|

#include &lt;initializer_list&gt;
namespace std {
    // class template linear_congruential_engine
    template&lt;class UIntType, UIntType a, UIntType c, UIntType m&gt;
        class linear_congruential_engine;
        
    // class template mersenne_twister_engine
    template&lt;class UIntType, size_t w, size_t n, size_t m, size_t r,
             UIntType a, size_t u, UintType d, size_t s,
             UIntType b, size_t t,
             UIntType c, size_t l, UintType f&gt;
     class mersenne_twister_engine;
     
    // class template subtract_with_carry_engine
    template&lt;class UIntType, size_t w, size_t s, size_t r&gt;
        class subtract_with_carry_engine;
    
    // class template discard_block_engine
    template&lt;class Engine, size_t p, size_t r&gt;
        class discard_block_engine;
        
    // class template independent_bits_engine
    template&lt;class Engine, size_t w, class UIntType&gt;
        class independent_bits_engine;
        
    // class template shuffle_order_engine
    template&lt;class Engine, size_t k&gt;
        class shuffle_order_engine;
        
    // engines and engine adaptors with predefined parameters
    typedef linear_congruential_engine&lt;uint_fast32_t, 16807, 0, 2147483647&gt;
        minstd_rand0;
    typedef  linear_congruential_engine&lt;uint_fast32_t, 48271, 0, 2147483647&gt;
        minstd_rand;
    typedef  mersenne_twister_engine&lt;uint_fast32_t,
            32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,
            0xefc60000,18,1812433253&gt;
        mt19937;
    typedef mersenne_twister_engine&lt;uint_fast64_t,
                64,312,156,31,0xb5026f5aa96619e9,29,
                0x5555555555555555,17,
                0x71d67fffeda60000,37,
                0xfff7eee000000000,43,
                6364136223846793005&gt;
        mt19937_64;
    typedef subtract_with_carry_engine&lt;uint_fast32_t, 24, 10, 24&gt;
        ranlux24_base;
    typedef subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;
        ranlux48_base;
    typedef  discard_block_engine&lt;ranlux24_base, 223, 23&gt;
        ranlux24;
    typedef discard_block_engine&lt;ranlux48_base, 389, 11&gt;
        ranlux48;
    typedef  shuffle_order_engine&lt;minstd_rand0,256&gt;
        knuth_b;
    typedef /*implementation-defined*/ default_random_engine;
    
    // class random_device
    class random_device;
    
    // class seed_seq
    class seed_seq;
    
    // function template generate_canonical
    template&lt;class RealType, size_t bits, class URNG&gt;
        RealType generate_canonical(URNG&amp; g);
    
    // class template uniform_int_distribution
    template&lt;class IntType {{=}} int&gt;
        class uniform_int_distribution;
        
    // class template uniform_real_distribution
    template&lt;class RealType {{=}} double&gt;
        class uniform_real_distribution;
        
    // class bernoulli_distribution
    class bernoulli_distribution;
    
    // class template binomial_distribution
    template&lt;class IntType {{=}} int&gt;
        class binomial_distribution;
        
    // class template geometric_distribution
    template&lt;class IntType {{=}} int&gt;
        class geometric_distribution;
        
    // class template negative_binomial_distribution
    template&lt;class IntType {{=}} int&gt;
        class negative_binomial_distribution;
        
    // class template poisson_distribution
    template&lt;class IntType {{=}} int&gt;
        class poisson_distribution;
        
    // class template exponential_distribution
    template&lt;class RealType {{=}} double&gt;
        class exponential_distribution;
        
    // class template gamma_distribution
    template&lt;class RealType {{=}} double&gt;
        class gamma_distribution;
        
    // class template weibull_distribution
    template&lt;class RealType {{=}} double&gt;
        class weibull_distribution;
        
    // class template extreme_value_distribution
    template&lt;class RealType {{=}} double&gt;
        class extreme_value_distribution;
        
    // class template normal_distribution
    template&lt;class RealType {{=}} double&gt;
    class normal_distribution;
    
    // class template lognormal_distribution
    template&lt;class RealType {{=}} double&gt;
        class lognormal_distribution;
        
    // class template chi_squared_distribution
    template&lt;class RealType {{=}} double&gt;
        class chi_squared_distribution;
        
    // class template cauchy_distribution
    template&lt;class RealType {{=}} double&gt;
        class cauchy_distribution;
        
    // class template fisher_f_distribution
    template&lt;class RealType {{=}} double&gt;
        class fisher_f_distribution;
        
    // class template student_t_distribution
    template&lt;class RealType {{=}} double&gt;
        class student_t_distribution;
        
    // class template discrete_distribution
    template&lt;class IntType {{=}} int&gt;
        class discrete_distribution;
        
    // class template piecewise_constant_distribution
    template&lt;class RealType {{=}} double&gt;
        class piecewise_constant_distribution;
        
    // class template piecewise_linear_distribution
    template&lt;class RealType {{=}} double&gt;
        class piecewise_linear_distribution;
} // namespace std

}}

====Class {{lc|std::linear_congruential_engine}}====
{{source|

template&lt;class UIntType, UIntType a, UIntType c, UIntType m&gt;
class linear_congruential_engine
{
public:
    // types
    typedef UIntType result_type;
    
    // engine characteristics
    static constexpr result_type multiplier {{=}} a;
    static constexpr result_type increment {{=}} c;
    static constexpr result_type modulus {{=}} m;
    static constexpr result_type min() { return c {{=}}{{=}} 0u ? 1u: 0u };
    static constexpr result_type max() { return m - 1u };
    static constexpr result_type default_seed {{=}} 1u;
    
    // constructors and seeding functions
    explicit linear_congruential_engine(result_type s {{=}} default_seed);
    template&lt;class Sseq&gt; explicit linear_congruential_engine(Sseq&amp; q);
        void seed(result_type s {{=}} default_seed);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

}}

====Class {{lc|std::mersenne_twister_engine}}====
{{source|
template&lt;class UIntType, size_t w, size_t n, size_t m, size_t r,
        UIntType a, size_t u, UIntType d, size_t s,
        UIntType b, size_t t,
        UIntType c, size_t l, UIntType f&gt;
class mersenne_twister_engine
{
public:
    // types
    typedef UIntType result_type;
    
    // engine characteristics
    static constexpr size_t word_size {{=}} w;
    static constexpr size_t state_size {{=}} n;
    static constexpr size_t shift_size {{=}} m;
    static constexpr size_t mask_bits {{=}} r;
    static constexpr UIntType xor_mask {{=}} a;
    static constexpr size_t tempering_u {{=}} u;
    static constexpr UIntType tempering_d {{=}} d;
    static constexpr size_t tempering_s {{=}} s;
    static constexpr UIntType tempering_b {{=}} b;
    static constexpr size_t tempering_t {{=}} t;
    static constexpr UIntType tempering_c {{=}} c;
    static constexpr size_t tempering_l {{=}} l;
    static constexpr UIntType initialization_multiplier {{=}} f;
    static constexpr result_type min () { return 0; }
    static constexpr result_type max() { return 2w − 1; }
    static constexpr result_type default_seed {{=}} 5489u;
    
    // constructors and seeding functions
    explicit mersenne_twister_engine(result_type value {{=}} default_seed);
    template&lt;class Sseq&gt; explicit mersenne_twister_engine(Sseq&amp; q);
        void seed(result_type value {{=}} default_seed);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

}}

====Class {{lc|std::subtract_with_carry_engine}}====
{{source|

template&lt;class UIntType, size_t w, size_t s, size_t r&gt;
class subtract_with_carry_engine
{
public:
    // types
    typedef UIntType result_type;
    
    // engine characteristics
    static constexpr size_t word_size {{=}} w;
    static constexpr size_t short_lag {{=}} s;
    static constexpr size_t long_lag {{=}} r;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return m − 1; }
    static constexpr result_type default_seed {{=}} 19780503u;
    
    // constructors and seeding functions
    explicit subtract_with_carry_engine(result_type value {{=}} default_seed);
    template&lt;class Sseq&gt; explicit subtract_with_carry_engine(Sseq&amp; q);
        void seed(result_type value {{=}} default_seed);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

}}

====Class {{lc|std::discard_block_engine}}====
{{source|

template&lt;class Engine, size_t p, size_t r&gt;
class discard_block_engine
{
public:
    // types
    typedef typename Engine::result_type result_type;
    
    // engine characteristics
    static constexpr size_t block_size {{=}} p;
    static constexpr size_t used_block {{=}} r;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
    
    // constructors and seeding functions
    discard_block_engine();
    explicit discard_block_engine(const Engine&amp; e);
    explicit discard_block_engine(Engine&amp;&amp; e);
    explicit discard_block_engine(result_type s);
    template&lt;class Sseq&gt; explicit discard_block_engine(Sseq&amp; q);
    void seed();
    void seed(result_type s);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
    
    // property functions
    const Engine&amp; base() const noexcept { return e; };
private:
    Engine e; // exposition only
    int n; // exposition only
};

}}


====Class {{lc|std::independent_bits_engine}}====
{{source|

template&lt;class Engine, size_t w, class UIntType&gt;
class independent_bits_engine
{
public:
    // types
    typedef UIntType result_type;
    
    // engine characteristics
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return 2w - 1; }
    
    // constructors and seeding functions
    independent_bits_engine();
    explicit independent_bits_engine(const Engine&amp; e);
    explicit independent_bits_engine(Engine&amp;&amp; e);
    explicit independent_bits_engine(result_type s);
    template&lt;class Sseq&gt; explicit independent_bits_engine(Sseq&amp; q);
    void seed();
    void seed(result_type s);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
    
    // property functions
    const Engine&amp; base() const noexcept { return e; };

private:
    Engine e; // exposition only
};



}}


====Class {{lc|std::shuffle_order_engine}}====
{{source|

template&lt;class Engine, size_t k&gt;
class shuffle_order_engine
{
public:
    // types
    typedef typename Engine::result_type result_type;
    
    // engine characteristics
    static constexpr size_t table_size {{=}} k;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
    
    // constructors and seeding functions
    shuffle_order_engine();
    explicit shuffle_order_engine(const Engine&amp; e);
    explicit shuffle_order_engine(Engine&amp;&amp; e);
    explicit shuffle_order_engine(result_type s);
    template&lt;class Sseq&gt; explicit shuffle_order_engine(Sseq&amp; q);
    void seed();
    void seed(result_type s);
    template&lt;class Sseq&gt; void seed(Sseq&amp; q);
    
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
    
    // property functions
    const Engine&amp; base() const noexcept { return e; };
    
private:
    Engine e;           // exposition only
    result_type Y;      // exposition only
    result_type V[k];   // exposition only
};


}}

====Class {{lc|std::random_device}}====
{{source|

class random_device
{
public:
    // types
    typedef unsigned int result_type;
    
    // generator characteristics
    static constexpr result_type min() { return numeric_limits&lt;result_type&gt;::min(); }
    static constexpr result_type max() { return numeric_limits&lt;result_type&gt;::max(); }
    
    // constructors
    explicit random_device(const string&amp; token {{=}} implementation-defined);
    
    // generating functions
    result_type operator()();
    
    // property functions
    double entropy() const noexcept;
    
    // no copy functions
    random_device(const random_device&amp; ) {{=}} delete;
    void operator{{=}}(const random_device&amp; ) {{=}} delete;
};

}}

====Class {{lc|std::seed_seq}}====
{{source|

class seed_seq
{
public:
    // types
    typedef uint_least32_t result_type;

    // constructors
    seed_seq();
    template&lt;class T&gt;
    seed_seq(initializer_list&lt;T&gt; il);
    template&lt;class InputIterator&gt;
    seed_seq(InputIterator begin, InputIterator end);

    // generating functions
    template&lt;class RandomAccessIterator&gt;
    void generate(RandomAccessIterator begin, RandomAccessIterator end);

    // property functions
    size_t size() const;
    template&lt;class OutputIterator&gt;
    void param(OutputIterator dest) const;

    // no copy functions
    seed_seq(const seed_seq&amp; ) {{=}} delete;
    void operator{{=}}(const seed_seq&amp; ) {{=}} delete;

private:
    vector&lt;result_type&gt; v; // exposition only
};

}}

====Class {{lc|std::uniform_int_distribution}}====
{{source|

template&lt;class IntType {{=}} int&gt;
class uniform_int_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
    
    // constructors and reset functions
    explicit uniform_int_distribution(IntType a {{=}} 0, IntType b {{=}} numeric_limits&lt;IntType&gt;::max());
    explicit uniform_int_distribution(const param_type&amp; parm);
    void reset();
    
    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);
    
    // property functions
    result_type a() const;
    result_type b() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::bernoulli_distribution}}====
{{source|

class bernoulli_distribution
{
public:
    // types
    typedef bool result_type;
    typedef /*unspecified*/ param_type;
    
    // constructors and reset functions
    explicit bernoulli_distribution(double p {{=}} 0.5);
    explicit bernoulli_distribution(const param_type&amp; parm);
    void reset();
    
    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);
    
    // property functions
    double p() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::binomial_distribution}}====
{{source|

template&lt;class IntType {{=}} int&gt;
class binomial_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
    
    // constructors and reset functions
    explicit binomial_distribution(IntType t {{=}} 1, double p {{=}} 0.5);
    explicit binomial_distribution(const param_type&amp; parm);
    void reset();
    
    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);
    
    // property functions
    IntType t() const;
    double p() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::geometric_distribution}}====
{{source|

template&lt;class IntType {{=}} int&gt;
class geometric_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
    
    // constructors and reset functions
    explicit geometric_distribution(double p {{=}} 0.5);
    explicit geometric_distribution(const param_type&amp; parm);
    void reset();
    
    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);
    
    // property functions
    double p() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::negative_binomial_distribution}}====
{{source|
template&lt;class IntType {{=}} int&gt;
class negative_binomial_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
    // constructor and reset functions
    explicit negative_binomial_distribution(IntType k {{=}} 1, double p {{=}} 0.5);
    explicit negative_binomial_distribution(const param_type&amp; parm);
    void reset();
    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);
    // property functions
    IntType k() const;
    double p() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::poisson_distribution}}====
{{source|

template&lt;class IntType {{=}} int&gt;
class poisson_distribution
{
public:

    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;

    // constructors and reset functions
    explicit poisson_distribution(double mean {{=}} 1.0);
    explicit poisson_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    double mean() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::seed_seq}}====
{{source|

template&lt;class RealType {{=}} double&gt;
class exponential_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructors and reset functions
    explicit exponential_distribution(RealType lambda {{=}} 1.0);
    explicit exponential_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType lambda() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::gamma_distribution}}====
{{source|

template&lt;class RealType {{=}} double&gt;
class gamma_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructors and reset functions
    explicit gamma_distribution(RealType alpha {{=}} 1.0, RealType beta {{=}} 1.0);
    explicit gamma_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType alpha() const;
    RealType beta() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}


====Class {{lc|std::weibull_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class weibull_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit weibull_distribution(RealType a {{=}} 1.0, RealType b {{=}} 1.0)
    explicit weibull_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::extreme_value_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class extreme_value_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit extreme_value_distribution(RealType a {{=}} 0.0, RealType b {{=}} 1.0);
    explicit extreme_value_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}

====Class {{lc|std::normal_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class normal_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructors and reset functions
    explicit normal_distribution(RealType mean {{=}} 0.0, RealType stddev {{=}} 1.0);
    explicit normal_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType mean() const;
    RealType stddev() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::lognormal_distribution}}====
{{source|

template&lt;class RealType {{=}} double&gt;
class lognormal_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit lognormal_distribution(RealType m {{=}} 0.0, RealType s {{=}} 1.0);
    explicit lognormal_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType m() const;
    RealType s() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::chi_squared_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class chi_squared_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit chi_squared_distribution(RealType n {{=}} 1);
    explicit chi_squared_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType n() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::cauchy_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class cauchy_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit cauchy_distribution(RealType a {{=}} 0.0, RealType b {{=}} 1.0);
    explicit cauchy_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::fisher_f_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class fisher_f_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit fisher_f_distribution(RealType m {{=}} 1, RealType n {{=}} 1);
    explicit fisher_f_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType m() const;
    RealType n() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::student_t_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class student_t_distribution
{
    public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    explicit student_t_distribution(RealType n {{=}} 1);
    explicit student_t_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    RealType n() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::discrete_distribution}}====
{{source|
template&lt;class IntType {{=}} int&gt;
class discrete_distribution
{
public:

    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    discrete_distribution();
    template&lt;class InputIterator&gt;
    discrete_distribution(InputIterator firstW, InputIterator lastW);
    discrete_distribution(initializer_list&lt;double&gt; wl);
    template&lt;class UnaryOperation&gt;
    discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
    explicit discrete_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    vector&lt;double&gt; probabilities() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::piecewise_constant_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class piecewise_constant_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    piecewise_constant_distribution();
    template&lt;class InputIteratorB, class InputIteratorW&gt;
    piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
    InputIteratorW firstW);
    template&lt;class UnaryOperation&gt;
    piecewise_constant_distribution(initializer_list&lt;RealType&gt; bl, UnaryOperation fw);
    template&lt;class UnaryOperation&gt;
    piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
    explicit piecewise_constant_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    vector&lt;result_type&gt; intervals() const;
    vector&lt;result_type&gt; densities() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};


}}

====Class {{lc|std::piecewise_linear_distribution}}====
{{source|
template&lt;class RealType {{=}} double&gt;
class piecewise_linear_distribution
{
public:

    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;

    // constructor and reset functions
    piecewise_linear_distribution();
    template&lt;class InputIteratorB, class InputIteratorW&gt;
    piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
    InputIteratorW firstW);
    template&lt;class UnaryOperation&gt;
    piecewise_linear_distribution(initializer_list&lt;RealType&gt; bl, UnaryOperation fw);
    template&lt;class UnaryOperation&gt;
    piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
    explicit piecewise_linear_distribution(const param_type&amp; parm);
    void reset();

    // generating functions
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g);
    template&lt;class URNG&gt;
    result_type operator()(URNG&amp; g, const param_type&amp; parm);

    // property functions
    vector&lt;result_type&gt; intervals() const;
    vector&lt;result_type&gt; densities() const;
    param_type param() const;
    void param(const param_type&amp; parm);
    result_type min() const;
    result_type max() const;
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/ratio</title>
    <ns>0</ns>
    <id>9747</id>
    <revision>
      <id>57524</id>
      <parentid>49588</parentid>
      <timestamp>2013-06-01T05:55:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4466">{{cpp/header/title|ratio}}
{{cpp/header/navbar}}
This header is part of the [[cpp/numeric/ratio|compile-time rational arithmetic]] library.

{{dsc begin}}

{{dsc h1|Classes}}
{{dsc tclass | cpp/numeric/ratio/ratio | represents exact rational fraction}}

{{dsc h2|Arithmetic}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_add}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_subtract}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_multiply}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_divide}}

{{dsc h2|Comparison}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_not_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_less}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_less_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_greater}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_greater_equal}}

{{dsc h2|Constants}}
{{dsc | {{tt|yocto}} | {{c|std::ratio&lt;1, 1000000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|zepto}} | {{c|std::ratio&lt;1, 1000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|atto}}  | {{c|std::ratio&lt;1, 1000000000000000000&gt;}}}}
{{dsc | {{tt|femto}} | {{c|std::ratio&lt;1, 1000000000000000&gt;}}}}
{{dsc | {{tt|pico}}  | {{c|std::ratio&lt;1, 1000000000000&gt;}}}}
{{dsc | {{tt|nano}}  | {{c|std::ratio&lt;1, 1000000000&gt;}}}}
{{dsc | {{tt|micro}} | {{c|std::ratio&lt;1, 1000000&gt;}}}}
{{dsc | {{tt|milli}} | {{c|std::ratio&lt;1, 1000&gt;}}}}
{{dsc | {{tt|centi}} | {{c|std::ratio&lt;1, 100&gt;}}}}
{{dsc | {{tt|deci}}  | {{c|std::ratio&lt;1, 10&gt;}}}}
{{dsc | {{tt|deca}}  | {{c|std::ratio&lt;10, 1&gt;}}}}
{{dsc | {{tt|hecto}} | {{c|std::ratio&lt;100, 1&gt;}}}}
{{dsc | {{tt|kilo}}  | {{c|std::ratio&lt;1000, 1&gt;}}}}
{{dsc | {{tt|mega}}  | {{c|std::ratio&lt;1000000, 1&gt;}}}}
{{dsc | {{tt|giga}}  | {{c|std::ratio&lt;1000000000, 1&gt;}}}}
{{dsc | {{tt|tera}}  | {{c|std::ratio&lt;1000000000000, 1&gt;}}}}
{{dsc | {{tt|peta}}  | {{c|std::ratio&lt;1000000000000000, 1&gt;}}}}
{{dsc | {{tt|exa}}   | {{c|std::ratio&lt;1000000000000000000, 1&gt;}}}}
{{dsc | {{tt|zetta}} | {{c|std::ratio&lt;1000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc | {{tt|yotta}} | {{c|std::ratio&lt;1000000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc end}}

{{source|

namespace std {

    //class template ratio
    template &lt;intmax_t N, intmax_t D {{=}} 1&gt;
    class ratio {
    public:
        typedef ratio&lt;num, den&gt; type;
        static constexpr intmax_t num;
        static constexpr intmax_t den;
    };
 
       
    // ratio arithmetic            
    template &lt;class R1, class   R2&gt; using   ratio_add      {{=}} /*ratio*/;
    template &lt;class R1, class   R2&gt; using   ratio_subtract {{=}} /*ratio*/;
    template &lt;class R1, class   R2&gt; using   ratio_multiply {{=}} /*ratio*/;
    template &lt;class R1, class   R2&gt; using   ratio_divide   {{=}} /*ratio*/;
                
    // ratio comparison            
    template &lt;class R1, class R2&gt; struct ratio_equal;           
    template &lt;class R1, class R2&gt; struct ratio_not_equal;           
    template &lt;class R1, class R2&gt; struct ratio_less;      
    template &lt;class R1, class R2&gt; struct ratio_less_equal;          
    template &lt;class R1, class R2&gt; struct ratio_greater;         
    template &lt;class R1, class R2&gt; struct ratio_greater_equal;  
    
    // convenience SI typedefs         
    typedef ratio&lt;1, 1000000000000000000000000&gt; yocto;
    typedef ratio&lt;1,    1000000000000000000000&gt; zepto;
    typedef ratio&lt;1,       1000000000000000000&gt; atto;   
    typedef ratio&lt;1,          1000000000000000&gt; femto;  
    typedef ratio&lt;1,             1000000000000&gt; pico;   
    typedef ratio&lt;1,                1000000000&gt; nano;   
    typedef ratio&lt;1,                   1000000&gt; micro;  
    typedef ratio&lt;1,                      1000&gt; milli;  
    typedef ratio&lt;1,                       100&gt; centi;  
    typedef ratio&lt;1,                        10&gt; deci;   
    typedef ratio&lt;                       10, 1&gt; deca;   
    typedef ratio&lt;                      100, 1&gt; hecto;  
    typedef ratio&lt;                     1000, 1&gt; kilo;   
    typedef ratio&lt;                  1000000, 1&gt; mega;   
    typedef ratio&lt;               1000000000, 1&gt; giga;   
    typedef ratio&lt;            1000000000000, 1&gt; tera;   
    typedef ratio&lt;         1000000000000000, 1&gt; peta;   
    typedef ratio&lt;      1000000000000000000, 1&gt; exa;    
    typedef ratio&lt;   1000000000000000000000, 1&gt; zetta;
    typedef ratio&lt;1000000000000000000000000, 1&gt; yotta;

}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/regex</title>
    <ns>0</ns>
    <id>9734</id>
    <revision>
      <id>65813</id>
      <parentid>61431</parentid>
      <timestamp>2013-10-08T18:52:36Z</timestamp>
      <contributor>
        <ip>199.87.84.206</ip>
      </contributor>
      <comment>sp: synopsis</comment>
      <text xml:space="preserve" bytes="30712">{{cpp/header/title|regex}}
{{cpp/header/navbar}}
This header is part of the [[cpp/regex|regular expressions]] library.

===Namespace {{c|std::regex_constants}}===

{{dsc begin}}
{{dsc h2|Types}}
{{dsc namespace | std::regex_constants }}
{{dsc inc | cpp/regex/dsc syntax_option_type}}
{{dsc inc | cpp/regex/dsc match_flag_type}}
{{dsc inc | cpp/regex/dsc error_type}}
{{dsc end}}
{{todo|list all constants}}



===Classes===

{{dsc begin}}
{{dsc inc | cpp/regex/dsc basic_regex }}
{{dsc inc | cpp/regex/dsc sub_match }}
{{dsc inc | cpp/regex/dsc match_results }}
{{dsc inc | cpp/regex/dsc regex_iterator }}
{{dsc inc | cpp/regex/dsc regex_token_iterator }}
{{dsc inc | cpp/regex/dsc regex_error }}
{{dsc inc | cpp/regex/dsc regex_traits }}
{{dsc end}}

===Functions===

{{dsc begin}}
{{dsc h2|Algorithm}}
{{dsc inc | cpp/regex/dsc regex_match }}
{{dsc inc | cpp/regex/dsc regex_search }}
{{dsc inc | cpp/regex/dsc regex_replace }}
{{dsc h2|Non-member operations}}
{{dsc inc | cpp/regex/basic_regex/dsc swap2}}
{{dsc inc | cpp/regex/sub_match/dsc operator_cmp}}
{{dsc tfun | cpp/regex/sub_match/operator_ltlt | title=operator&lt;&lt; | outputs the matched character subsequence}}
{{dsc inc | cpp/regex/match_results/dsc operator_cmp}}
{{dsc inc | cpp/regex/match_results/dsc swap2}}

{{dsc end}}


===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    
    // regex constants:
    namespace regex_constants {
        enum error_type;
    } // namespace regex_constants
    
    // class regex_error:
    class regex_error;
    // class template regex_traits:
    template &lt;class charT&gt; struct regex_traits;
    // class template basic_regex:
    template &lt;class charT, class traits {{=}} regex_traits&lt;charT&gt; &gt; class basic_regex;
    
    typedef basic_regex&lt;char&gt; regex;
    typedef basic_regex&lt;wchar_t&gt; wregex;
    
    // basic_regex swap:
    template &lt;class charT, class traits&gt;
        void swap(basic_regex&lt;charT, traits&gt;&amp; e1, basic_regex&lt;charT, traits&gt;&amp; e2);
        
    // class template sub_match:
    template &lt;class BidirectionalIterator&gt; class sub_match;

    typedef sub_match&lt;const char*&gt;              csub_match;
    typedef sub_match&lt;const wchar_t*&gt;           wcsub_match;
    typedef sub_match&lt;string::const_iterator&gt;   ssub_match;
    typedef sub_match&lt;wstring::const_iterator&gt;  wssub_match;

    // sub_match non-member operators:
    template &lt;class BiIter&gt;
        bool operator{{=}}{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator!{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs, const sub_match&lt;BiIter&gt;&amp; rhs);
        
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator{{=}}{{=}}(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator!{{=}}(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&lt;(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&gt;(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&gt;{{=}}(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&lt;{{=}}(
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);


    template &lt;class BiIter, class ST, class SA&gt;
        bool operator{{=}}{{=}}(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator!{{=}}(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&lt;(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&gt;(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&lt;{{=}}(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
    template &lt;class BiIter, class ST, class SA&gt;
        bool operator&gt;{{=}}(
            const sub_match&lt;BiIter&gt;&amp; lhs,
            const basic_string&lt;
                typename iterator_traits&lt;BiIter&gt;::value_type, ST, SA&gt;&amp; rhs);
        
    template &lt;class BiIter&gt;
        bool operator{{=}}{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator!{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const* lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
        
    template &lt;class BiIter&gt;
        bool operator{{=}}{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
    template &lt;class BiIter&gt;
        bool operator!{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const* rhs);


    template &lt;class BiIter&gt;
        bool operator{{=}}{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator!{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;{{=}}(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;(typename iterator_traits&lt;BiIter&gt;::value_type const&amp; lhs,
            const sub_match&lt;BiIter&gt;&amp; rhs);
        
    template &lt;class BiIter&gt;
        bool operator{{=}}{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator!{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;{{=}}(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&lt;(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
    template &lt;class BiIter&gt;
        bool operator&gt;(const sub_match&lt;BiIter&gt;&amp; lhs,
            typename iterator_traits&lt;BiIter&gt;::value_type const&amp; rhs);
        
    template &lt;class charT, class ST, class BiIter&gt;
        basic_ostream&lt;charT, ST&gt;&amp;
        operator&lt;&lt;(basic_ostream&lt;charT, ST&gt;&amp; os, const sub_match&lt;BiIter&gt;&amp; m);
        
    // class template match_results:
    template &lt;class BidirectionalIterator,
              class Allocator {{=}} allocator&lt;sub_match&lt;BidirectionalIterator&gt; &gt; &gt;
        class match_results;
        
    typedef match_results&lt;const char*&gt;              cmatch;
    typedef match_results&lt;const wchar_t*&gt;           wcmatch;
    typedef match_results&lt;string::const_iterator&gt;   smatch;
    typedef match_results&lt;wstring::const_iterator&gt;  wsmatch;

    // match_results comparisons
    template &lt;class BidirectionalIterator, class Allocator&gt;
        bool operator{{=}}{{=}} (const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
                         const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);
    template &lt;class BidirectionalIterator, class Allocator&gt;
        bool operator!{{=}} (const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
                         const match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);

    //  match_results swap:
    template &lt;class BidirectionalIterator, class Allocator&gt;
        void swap(match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m1,
                  match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m2);

    //  function template regex_match:
    template &lt;class BidirectionalIterator, class Allocator,
              class charT, class traits&gt;
        bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
                         match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,
                         const basic_regex&lt;charT, traits&gt;&amp; e,
                         regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class BidirectionalIterator, class charT, class traits&gt;
        bool regex_match(BidirectionalIterator first, BidirectionalIterator last,
                         const basic_regex&lt;charT, traits&gt;&amp; e,
                         regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class charT, class Allocator, class traits&gt;
        bool regex_match(const charT* str, match_results&lt;const charT*, Allocator&gt;&amp; m,
                         const basic_regex&lt;charT, traits&gt;&amp; e,
                         regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class ST, class SA, class Allocator, class charT, class traits&gt;
        bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp; s,
            match_results&lt;
                typename basic_string&lt;charT, ST, SA&gt;::const_iterator,
                Allocator&gt;&amp; m,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class charT, class traits&gt;
        bool regex_match(const charT* str,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class ST, class SA, class charT, class traits&gt;
        bool regex_match(const basic_string&lt;charT, ST, SA&gt;&amp; s,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);

    // function template regex_search:
    template &lt;class BidirectionalIterator, class Allocator,
              class charT, class traits&gt;
        bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
            match_results&lt;BidirectionalIterator, Allocator&gt;&amp; m,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class BidirectionalIterator, class charT, class traits&gt;
        bool regex_search(BidirectionalIterator first, BidirectionalIterator last,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class charT, class Allocator, class traits&gt;
        bool regex_search(const charT* str,
            match_results&lt;const charT*, Allocator&gt;&amp; m,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class charT, class traits&gt;
        bool regex_search(const charT* str,
            const basic_regex&lt;charT, traits&gt;&amp; e,
                regex_constants::match_flag_type flags {{=}}
                    regex_constants::match_default);
    template &lt;class ST, class SA, class charT, class traits&gt;
        bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp; s,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);
    template &lt;class ST, class SA, class Allocator, class charT, class traits&gt;
        bool regex_search(const basic_string&lt;charT, ST, SA&gt;&amp; s,
            match_results&lt;
                typename basic_string&lt;charT, ST, SA&gt;::const_iterator,
                Allocator&gt;&amp; m,
            const basic_regex&lt;charT, traits&gt;&amp; e,
            regex_constants::match_flag_type flags {{=}}
                regex_constants::match_default);

    //  function template regex_replace:
    template &lt;class OutputIterator, class BidirectionalIterator,
              class traits, class charT, class ST, class SA&gt;
        OutputIterator
        regex_replace(  OutputIterator out,
                        BidirectionalIterator first, 
                        BidirectionalIterator last,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const basic_string&lt;charT, ST, SA&gt;&amp; fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class OutputIterator, class BidirectionalIterator,
              class traits, class charT&gt;
        OutputIterator
        regex_replace(  OutputIterator out,
                        BidirectionalIterator first, 
                        BidirectionalIterator last,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const charT* fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class traits, class charT, class ST, class SA,
              class FST, class FSA&gt;
        basic_string&lt;charT, ST, SA&gt;
        regex_replace(  const basic_string&lt;charT, ST, SA&gt;&amp; s,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const basic_string&lt;charT, FST, FSA&gt;&amp; fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class traits, class charT, class ST, class SA&gt;
        basic_string&lt;charT, ST, SA&gt;
        regex_replace(  const basic_string&lt;charT, ST, SA&gt;&amp; s,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const charT* fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class traits, class charT, class ST, class SA&gt;
        basic_string&lt;charT&gt;
        regex_replace(  const charT* s,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const basic_string&lt;charT, ST, SA&gt;&amp; fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
    template &lt;class traits, class charT&gt;
        basic_string&lt;charT&gt;
        regex_replace(  const charT* s,
                        const basic_regex&lt;charT, traits&gt;&amp; e,
                        const charT* fmt,
                        regex_constants::match_flag_type flags {{=}}
                            regex_constants::match_default);
        
    // class template regex_iterator:
    template &lt;class BidirectionalIterator,
              class charT {{=}} typename iterator_traits&lt;
                    BidirectionalIterator&gt;::value_type,
              class traits {{=}} regex_traits&lt;charT&gt; &gt;
        class regex_iterator;
        
    typedef regex_iterator&lt;const char*&gt;             cregex_iterator;
    typedef regex_iterator&lt;const wchar_t*&gt;          wcregex_iterator;
    typedef regex_iterator&lt;string::const_iterator&gt;  sregex_iterator;
    typedef regex_iterator&lt;wstring::const_iterator&gt; wsregex_iterator;

    // class template regex_token_iterator:
    template &lt;class BidirectionalIterator,
              class charT {{=}} typename iterator_traits&lt;
                BidirectionalIterator&gt;::value_type,
              class traits {{=}} regex_traits&lt;charT&gt; &gt;
        class regex_token_iterator;

    typedef regex_token_iterator&lt;const char*&gt;               cregex_token_iterator;
    typedef regex_token_iterator&lt;const wchar_t*&gt;            wcregex_token_iterator;
    typedef regex_token_iterator&lt;string::const_iterator&gt;    scregex_token_iterator;
    typedef regex_token_iterator&lt;wstring::const_iterator&gt;   wscregex_token_iterator;


} // namespace std


}}


====Namespace {{c|std::regex_constants}}====
{{source|
namespace regex_constants {
    typedef /*T1*/ syntax_option_type;
    static constexpr syntax_option_type icase {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type nosubs {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type optimize {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type collate {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type ECMAScript {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type basic {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type extended {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type awk {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type grep {{=}} /*unspecified*/ ;
    static constexpr syntax_option_type egrep {{=}} /*unspecified*/ ;
    
    typedef /*T2*/ match_flag_type;
    static constexpr match_flag_type match_default {{=}} 0;
    static constexpr match_flag_type match_not_bol {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_not_eol {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_not_bow {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_not_eow {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_any {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_not_null {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_continuous {{=}} /*unspecified*/ ;
    static constexpr match_flag_type match_prev_avail {{=}} /*unspecified*/ ;
    static constexpr match_flag_type format_default {{=}} 0;
    static constexpr match_flag_type format_sed {{=}} /*unspecified*/ ;
    static constexpr match_flag_type format_no_copy {{=}} /*unspecified*/ ;
    static constexpr match_flag_type format_first_only {{=}} /*unspecified*/ ;

    typedef /*T3*/ error_type;
    static constexpr error_type error_collate {{=}} /*unspecified*/ ;
    static constexpr error_type error_ctype {{=}} /*unspecified*/ ;
    static constexpr error_type error_escape {{=}} /*unspecified*/ ;
    static constexpr error_type error_backref {{=}} /*unspecified*/ ;
    static constexpr error_type error_brack {{=}} /*unspecified*/ ;
    static constexpr error_type error_paren {{=}} /*unspecified*/ ;
    static constexpr error_type error_brace {{=}} /*unspecified*/ ;
    static constexpr error_type error_badbrace {{=}} /*unspecified*/ ;
    static constexpr error_type error_range {{=}} /*unspecified*/ ;
    static constexpr error_type error_space {{=}} /*unspecified*/ ;
    static constexpr error_type error_badrepeat {{=}} /*unspecified*/ ;
    static constexpr error_type error_complexity {{=}} /*unspecified*/ ;
    static constexpr error_type error_stack {{=}} /*unspecified*/ ;

}

}}

====Class {{lc|std::regex_error}}====
{{source|
class regex_error : public std::runtime_error {
public:
    explicit regex_error(regex_constants::error_type ecode);
    regex_constants::error_type code() const;
};

}}


====Class {{lc|std::regex_traits}}====
{{source|

template &lt;class charT&gt;
struct regex_traits {
public:
    typedef charT                           char_type;
    typedef std::basic_string&lt;char_type&gt;    string_type;
    typedef std::locale                     locale_type;
    typedef /*bitmask_type*/                char_class_type;
    
    regex_traits();
    static std::size_t length(const char_type* p);
    charT translate(charT c) const;
    charT translate_nocase(charT c) const;
    template &lt;class ForwardIterator&gt;
        string_type transform(ForwardIterator first, ForwardIterator last) const;
    template &lt;class ForwardIterator&gt;
        string_type transform_primary(
            ForwardIterator first, ForwardIterator last) const;
    template &lt;class ForwardIterator&gt;
        string_type lookup_collatename(
            ForwardIterator first, ForwardIterator last) const;
    template &lt;class ForwardIterator&gt;
        char_class_type lookup_classname(
            ForwardIterator first, ForwardIterator last, bool icase {{=}} false) const;
    bool isctype(charT c, char_class_type f) const;
    int value(charT ch, int radix) const;
    locale_type imbue(locale_type l);
    locale_type getloc()const;
};

}}

====Class {{lc|std::regex}}====
{{source|

template &lt;class charT,
    class traits {{=}} regex_traits&lt;charT&gt; &gt;
class basic_regex {
public:
    // types:
    typedef          charT                                  value_type;
    typedef          traits                                 traits_type;
    typedef typename traits::string_type                    string_type;
    typedef          regex_constants::syntax_option_type    flag_type;
    typedef typename traits::locale_type                    locale_type;
    
    //  constants:
    static constexpr regex_constants::syntax_option_type
        icase {{=}} regex_constants::icase;
    static constexpr regex_constants::syntax_option_type
        nosubs {{=}} regex_constants::nosubs;
    static constexpr regex_constants::syntax_option_type
        optimize {{=}} regex_constants::optimize;
    static constexpr regex_constants::syntax_option_type
        collate {{=}} regex_constants::collate;
    static constexpr regex_constants::syntax_option_type
        ECMAScript {{=}} regex_constants::ECMAScript;
    static constexpr regex_constants::syntax_option_type
        basic {{=}} regex_constants::basic;
    static constexpr regex_constants::syntax_option_type
        extended {{=}} regex_constants::extended;
    static constexpr regex_constants::syntax_option_type
        awk {{=}} regex_constants::awk;
    static constexpr regex_constants::syntax_option_type
        grep {{=}} regex_constants::grep;
    static constexpr regex_constants::syntax_option_type
        egrep {{=}} regex_constants::egrep;

    //construct/copy/destroy:
    basic_regex();
    explicit basic_regex(const charT* p,
        flag_type f {{=}} regex_constants::ECMAScript);
    basic_regex(const charT* p, size_t len, flag_type f {{=}} regex_constants::ECMAScript);
    basic_regex(const basic_regex&amp;);
    basic_regex(basic_regex&amp;&amp;) noexcept;
    template &lt;class ST, class SA&gt;
        explicit basic_regex(const basic_string&lt;charT, ST, SA&gt;&amp; p,
            flag_type f {{=}} regex_constants::ECMAScript);
    template &lt;class ForwardIterator&gt;
        basic_regex(ForwardIterator first, ForwardIterator last,
            flag_type f {{=}} regex_constants::ECMAScript);
    basic_regex(initializer_list&lt;charT&gt;,
        flag_type {{=}} regex_constants::ECMAScript);

    ~basic_regex();
    basic_regex&amp; operator{{=}}(const basic_regex&amp;);
    basic_regex&amp; operator{{=}}(basic_regex&amp;&amp;) noexcept;
    basic_regex&amp; operator{{=}}(const charT* ptr);
    basic_regex&amp; operator{{=}}(initializer_list&lt;charT&gt; il);
    template &lt;class ST, class SA&gt;
        basic_regex&amp; operator{{=}}(const basic_string&lt;charT, ST, SA&gt;&amp; p);
        
    //  assign:
    basic_regex&amp; assign(const basic_regex&amp; that);
    basic_regex&amp; assign(basic_regex&amp;&amp; that) noexcept;
    basic_regex&amp; assign(const charT* ptr,
        flag_type f {{=}} regex_constants::ECMAScript);
    basic_regex&amp; assign(const charT* p, size_t len, flag_type f);
    template &lt;class string_traits, class A&gt;
        basic_regex&amp; assign(const basic_string&lt;charT, string_traits, A&gt;&amp; s,
            flag_type f {{=}} regex_constants::ECMAScript);
    template &lt;class InputIterator&gt;
        basic_regex&amp; assign(InputIterator first, InputIterator last,
            flag_type f {{=}} regex_constants::ECMAScript);
    basic_regex&amp; assign(initializer_list&lt;charT&gt;,
        flag_type {{=}} regex_constants::ECMAScript);

    // const operations:
    unsigned mark_count() const;
    flag_type flags() const;
    
    // locale:
    locale_type imbue(locale_type loc);
    locale_type getloc() const;
    
    // swap:
    void swap(basic_regex&amp;);
};

}}

====Class {{lc|std::sub_match}}====
{{source|

template &lt;class BidirectionalIterator&gt;
class sub_match : public std::pair&lt;BidirectionalIterator, BidirectionalIterator&gt; {
public:
    typedef typename iterator_traits&lt;BidirectionalIterator&gt;::
        value_type                                              value_type;
    typedef typename iterator_traits&lt;BidirectionalIterator&gt;::
    difference_type                                             difference_type;
    typedef BidirectionalIterator                               iterator;
    typedef basic_string&lt;value_type&gt;                            string_type;
    
    bool matched;
    
    constexpr sub_match();
    difference_type length() const;
    operator string_type() const;
    string_type str() const;
    
    int compare(const sub_match&amp; s) const;
    int compare(const string_type&amp; s) const;
    int compare(const value_type* s) const;
};

}}

====Class {{lc|std::match_results}}====
{{source|

template &lt;class BidirectionalIterator,
            class Allocator {{=}} allocator&lt;sub_match&lt;BidirectionalIterator&gt; &gt;
class match_results {
public:
    typedef sub_match&lt;BidirectionalIterator&gt;                    value_type;
    typedef const value_type&amp;                                   const_reference;
    typedef const_reference                                     reference;
    typedef /*implementation-defined*/                          const_iterator;
    typedef const_iterator                                      iterator;
    typedef typename 
        iterator_traits&lt;BidirectionalIterator&gt;::difference_type difference_type;
    typedef typename allocator_traits&lt;Allocator&gt;::size_type     size_type;
    typedef Allocator                                           allocator_type;
    typedef typename 
        iterator_traits&lt;BidirectionalIterator&gt;::value_type      char_type;
    typedef basic_string&lt;char_type&gt;                             string_type;
    
    // construct/copy/destroy:
    explicit match_results(const Allocator&amp; a {{=}} Allocator());
    match_results(const match_results&amp; m);
    match_results(match_results&amp;&amp; m) noexcept;
    match_results&amp; operator{{=}}(const match_results&amp; m);
    match_results&amp; operator{{=}}(match_results&amp;&amp; m);
    ~match_results();
    
    // state:
    bool ready() const;
    
    // size:
    size_type size() const;
    size_type max_size() const;
    bool empty() const;

    // element access:
    difference_type length(size_type sub {{=}} 0) const;
    difference_type position(size_type sub {{=}} 0) const;
    string_type str(size_type sub {{=}} 0) const;
    const_reference operator[](size_type n) const;

    const_reference prefix() const;
    const_reference suffix() const;
    const_iterator  begin() const;
    const_iterator  end() const;
    const_iterator  cbegin() const;
    const_iterator  cend() const;

    //  format:
    template &lt;class OutputIter&gt;
        OutputIter
        format(OutputIter out,
            const char_type* fmt_first, const char_type* fmt_last,
            regex_constants::match_flag_type flags {{=}}
            regex_constants::format_default) const;
    template &lt;class OutputIter, class ST, class SA&gt;
        OutputIter
        format(OutputIter out,
            const basic_string&lt;char_type, ST, SA&gt;&amp; fmt,
            regex_constants::match_flag_type flags {{=}}
            regex_constants::format_default) const;
    template &lt;class ST, class SA&gt;
        basic_string&lt;char_type, ST, SA&gt;
        format(const basic_string&lt;char_type, ST, SA&gt;&amp; fmt,
            regex_constants::match_flag_type flags {{=}}
            regex_constants::format_default) const;
    string_type
        format(const char_type* fmt,
            regex_constants::match_flag_type flags {{=}}
            regex_constants::format_default) const;
        
    // allocator:
    allocator_type get_allocator() const;
    
    // swap:
    void swap(match_results&amp; that);
    
};

}}</text>
      <sha1>jp4snl3difi13npiiboz6q1ytpvx51u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/scoped allocator</title>
    <ns>0</ns>
    <id>12857</id>
    <revision>
      <id>63999</id>
      <timestamp>2013-08-06T02:38:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="4515">{{cpp/header/title|scoped_allocator}}
{{cpp/header/navbar}}
This header is part of the [[cpp/memory|dynamic memory management]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc h1|Functions}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc operator_cmp}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

    template &lt;class OuterAlloc, class... InnerAlloc&gt;
    class scoped_allocator_adaptor;

    template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
    bool operator==(const scoped_allocator_adaptor&lt;OuterA1,
                                                   InnerAllocs...&gt;&amp; a,
                    const scoped_allocator_adaptor&lt;OuterA2,
                                                   InnerAllocs...&gt;&amp; b) noexcept;
    template &lt;class OuterA1, class OuterA2, class... InnerAllocs&gt;
    bool operator!=(const scoped_allocator_adaptor&lt;OuterA1,
                                                   InnerAllocs...&gt;&amp; a,
                    const scoped_allocator_adaptor&lt;OuterA2,
                                                   InnerAllocs...&gt;&amp; b) noexcept;
}
}}

====Class {{lc|std::scoped_allocator_adaptor}}====
{{source|1=
template &lt;class OuterAlloc, class... InnerAllocs&gt;
class scoped_allocator_adaptor : public OuterAlloc {
 private:
    typedef allocator_traits&lt;OuterAlloc&gt; OuterTraits; // exposition only
    scoped_allocator_adaptor&lt;InnerAllocs...&gt; inner; // exposition only

 public:
    typedef OuterAlloc outer_allocator_type;
    typedef /*see description*/ inner_allocator_type;
    typedef typename OuterTraits::value_type value_type;
    typedef typename OuterTraits::size_type size_type;
    typedef typename OuterTraits::difference_type difference_type;
    typedef typename OuterTraits::pointer pointer;
    typedef typename OuterTraits::const_pointer const_pointer;
    typedef typename OuterTraits::void_pointer void_pointer;
    typedef typename OuterTraits::const_void_pointer const_void_pointer;
    typedef /*see description*/ propagate_on_container_copy_assignment;
    typedef /*see description*/ propagate_on_container_move_assignment;
    typedef /*see description*/ propagate_on_container_swap;
    template &lt;class Tp&gt;
    struct rebind {
        typedef scoped_allocator_adaptor&lt;
                          OuterTraits::template rebind_alloc&lt;Tp&gt;,
                          InnerAllocs...
                &gt; other;
    };

    scoped_allocator_adaptor();
    template &lt;class OuterA2&gt;
    scoped_allocator_adaptor(OuterA2&amp;&amp; outerAlloc,
                             const InnerAllocs&amp;... innerAllocs) noexcept;
    scoped_allocator_adaptor(const scoped_allocator_adaptor&amp; other) noexcept;
    scoped_allocator_adaptor(scoped_allocator_adaptor&amp;&amp; other) noexcept;
    template &lt;class OuterA2&gt;
    scoped_allocator_adaptor(const scoped_allocator_adaptor&lt;
                                          OuterA2,
                                          InnerAllocs...
                                   &gt;&amp; other) noexcept;
    template &lt;class OuterA2&gt;
    scoped_allocator_adaptor(scoped_allocator_adaptor&lt;
                                    OuterA2,
                                    InnerAllocs...
                             &gt;&amp;&amp; other) noexcept;

    ~scoped_allocator_adaptor();

    inner_allocator_type&amp; inner_allocator() noexcept;
    const inner_allocator_type&amp; inner_allocator() const noexcept;
    outer_allocator_type&amp; outer_allocator() noexcept;
    const outer_allocator_type&amp; outer_allocator() const noexcept;
    pointer allocate(size_type n);
    pointer allocate(size_type n, const_void_pointer hint);
    void deallocate(pointer p, size_type n);
    size_type max_size() const;

    template &lt;class T, class... Args&gt;
    void construct(T* p, Args&amp;&amp;... args);
    template &lt;class T1, class T2, class... Args1, class... Args2&gt;
    void construct(pair&lt;T1, T2&gt;* p,
                   piecewise_construct_t,
                   tuple&lt;Args1...&gt; x,
                   tuple&lt;Args2...&gt; y);
    template &lt;class T1, class T2&gt;
    void construct(pair&lt;T1, T2&gt;* p);
    template &lt;class T1, class T2, class U, class V&gt;
    void construct(pair&lt;T1, T2&gt;* p, U&amp;&amp; x, V&amp;&amp; y);
    template &lt;class T1, class T2, class U, class V&gt;
    void construct(pair&lt;T1, T2&gt;* p, const pair&lt;U, V&gt;&amp; x);
    template &lt;class T1, class T2, class U, class V&gt;
    void construct(pair&lt;T1, T2&gt;* p, pair&lt;U, V&gt;&amp;&amp; x);
    template &lt;class T&gt;
    void destroy(T* p);

    scoped_allocator_adaptor select_on_container_copy_construction() const;
}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/set</title>
    <ns>0</ns>
    <id>9753</id>
    <revision>
      <id>57530</id>
      <parentid>49590</parentid>
      <timestamp>2013-06-01T05:55:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="11590">{{cpp/header/title|set}}
{{cpp/header/navbar}}

This header is part of the [[cpp/container|containers]] library.


{{dsc begin}}
{{dsc h1|Includes}}
{{dsc | {{header|initializer_list}} {{mark c++11}} }}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc set}}
{{dsc inc | cpp/container/dsc multiset}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | set}}
{{dsc inc | cpp/container/dsc swap2 | set}}
{{dsc inc | cpp/container/dsc operator_cmp | multiset}}
{{dsc inc | cpp/container/dsc swap2 | multiset}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std
{
    template &lt;class Key, class Compare {{=}} less&lt;Key&gt;,
              class Allocator {{=}} allocator&lt;Key&gt; &gt;
        class set;

    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator{{==}}(const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator!{{=}}(const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&gt;{{=}}(const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&lt;{{=}}(const set&lt;Key,Compare,Allocator&gt;&amp; x,
                        const set&lt;Key,Compare,Allocator&gt;&amp; y);
                    
    template &lt;class Key, class Compare, class Allocator&gt;
        void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,
                  set&lt;Key,Compare,Allocator&gt;&amp; y);
              
    template &lt;class Key, class Compare {{=}} less&lt;Key&gt;,
             class Allocator {{=}} allocator&lt;Key&gt; &gt;
        class multiset;

    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator{{==}}(const multiset&lt;Key,Compare,Allocator&gt;&amp;
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator!{{=}}(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&gt;{{=}}(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
    template &lt;class Key, class Compare, class Allocator&gt;
        bool operator&lt;{{=}}(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                        const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
                        
    template &lt;class Key, class Compare, class Allocator&gt;
        void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,
                  multiset&lt;Key,Compare,Allocator&gt;&amp; y);
}
 
}}

====Class {{lc|std::set}}====
{{source|

template &lt;class Key, class Compare {{=}} less&lt;Key&gt;,
class Allocator {{=}} allocator&lt;Key&gt; &gt;
class set
{
public:
    // types:
    typedef Key key_type;
    typedef Key value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef value_type&amp; reference;
    typedef const value_type&amp; const_reference;
    typedef /*implementation-defined*/ iterator;
    typedef /*implementation-defined*/ const_iterator;
    typedef /*implementation-defined*/ size_type;
    typedef /*implementation-defined*/ difference_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt; reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
    
    // construct/copy/destroy:
    explicit set(const Compare&amp; comp {{=}} Compare(),
                 const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
    set(InputIterator first, InputIterator last,
        const Compare&amp; comp {{=}} Compare(), const Allocator&amp; {{=}} Allocator());
    set(const set&lt;Key,Compare,Allocator&gt;&amp; x);
    set(set&lt;Key,Compare,Allocator&gt;&amp;&amp; x);
    explicit set(const Allocator&amp;);
    set(const set&amp;, const Allocator&amp;);
    set(set&amp;&amp;, const Allocator&amp;);
    set(initializer_list&lt;value_type&gt;,
        const Compare&amp; {{=}} Compare(),
        const Allocator&amp; {{=}} Allocator());
    ~set();
    
    set&lt;Key,Compare,Allocator&gt;&amp; operator{{=}} (const set&lt;Key,Compare,Allocator&gt;&amp; x);
    set&lt;Key,Compare,Allocator&gt;&amp; operator{{=}} (set&lt;Key,Compare,Allocator&gt;&amp;&amp; x);
    set&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    // iterators:
    iterator        begin() noexcept;
    const_iterator  begin() const noexcept;
    iterator        end() noexcept;
    const_iterator  end() const noexcept;
 
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
 
    const_iterator          cbegin() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    bool        empty() const noexcept;
    size_type   size() const noexcept;
    size_type   max_size() const noexcept;
 
    // modifiers:
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; 
        iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
        
    pair&lt;iterator,bool&gt; insert(const value_type&amp; x);
    pair&lt;iterator,bool&gt; insert(value_type&amp;&amp; x);
    iterator insert(const_iterator position, const value_type&amp; x);
    iterator insert(const_iterator position, value_type&amp;&amp; x);
    template &lt;class InputIterator&gt;
    void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; x);
    iterator erase(const_iterator first, const_iterator last);
    
    void swap(set&lt;Key,Compare,Allocator&gt;&amp;);
    void clear() noexcept;
    
    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
    
    // set operations:
    iterator       find(const key_type&amp; x);
    const_iterator find(const key_type&amp; x) const;
    size_type      count(const key_type&amp; x) const;
    iterator       lower_bound(const key_type&amp; x);
    const_iterator lower_bound(const key_type&amp; x) const;
    iterator       upper_bound(const key_type&amp; x);
    const_iterator upper_bound(const key_type&amp; x) const;
    pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x);
    pair&lt;const_iterator,const_iterator&gt; equal_range(const key_type&amp; x) const;
};
 
}}

====Class {{lc|std::multiset}}====
{{source|

template &lt;class Key, class Compare {{=}} less&lt;Key&gt;,
class Allocator {{=}} allocator&lt;Key&gt; &gt;
class multiset
{
public:
    // types:
    typedef Key key_type;
    typedef Key value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef value_type&amp; reference;
    typedef const value_type&amp; const_reference;
    typedef /*implementation-defined*/ iterator;
    typedef /*implementation-defined*/ const_iterator;
    typedef /*implementation-defined*/ size_type;
    typedef /*implementation-defined*/ difference_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt; reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
    
    // construct/copy/destroy:
    explicit multiset(const Compare&amp; comp {{=}} Compare(),
                 const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
    multiset(InputIterator first, InputIterator last,
        const Compare&amp; comp {{=}} Compare(), const Allocator&amp; {{=}} Allocator());
    multiset(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
    multiset(multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; x);
    explicit multiset(const Allocator&amp;);
    multiset(const multiset&amp;, const Allocator&amp;);
    multiset(multiset&amp;&amp;, const Allocator&amp;);
    multiset(initializer_list&lt;value_type&gt;,
        const Compare&amp; {{=}} Compare(),
        const Allocator&amp; {{=}} Allocator());
    ~multiset();
    
    multiset&lt;Key,Compare,Allocator&gt;&amp; operator{{=}} (const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
    multiset&lt;Key,Compare,Allocator&gt;&amp; operator{{=}} (multiset&lt;Key,Compare,Allocator&gt;&amp;&amp; x);
    multiset&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    // iterators:
    iterator        begin() noexcept;
    const_iterator  begin() const noexcept;
    iterator        end() noexcept;
    const_iterator  end() const noexcept;
 
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
 
    const_iterator          cbegin() const noexcept;
    const_iterator          cend() const noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
 
    // capacity:
    bool        empty() const noexcept;
    size_type   size() const noexcept;
    size_type   max_size() const noexcept;
 
    // modifiers:
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; 
        iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
        
    pair&lt;iterator,bool&gt; insert(const value_type&amp; x);
    pair&lt;iterator,bool&gt; insert(value_type&amp;&amp; x);
    iterator insert(const_iterator position, const value_type&amp; x);
    iterator insert(const_iterator position, value_type&amp;&amp; x);
    template &lt;class InputIterator&gt;
    void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; x);
    iterator erase(const_iterator first, const_iterator last);
    
    void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;);
    void clear() noexcept;
    
    // observers:
    key_compare   key_comp() const;
    value_compare value_comp() const;
    
    // multiset operations:
    iterator       find(const key_type&amp; x);
    const_iterator find(const key_type&amp; x) const;
    size_type      count(const key_type&amp; x) const;
    iterator       lower_bound(const key_type&amp; x);
    const_iterator lower_bound(const key_type&amp; x) const;
    iterator       upper_bound(const key_type&amp; x);
    const_iterator upper_bound(const key_type&amp; x) const;
    pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x);
    pair&lt;const_iterator,const_iterator&gt; equal_range(const key_type&amp; x) const;
};
 
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/shared mutex</title>
    <ns>0</ns>
    <id>12862</id>
    <revision>
      <id>68919</id>
      <parentid>64007</parentid>
      <timestamp>2014-03-22T22:36:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="2976">{{cpp/header/title|shared_mutex}}
{{cpp/header/navbar}}
This header is part of the [[cpp/thread|thread support]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/thread/dsc shared_timed_mutex}}
{{dsc inc | cpp/thread/dsc shared_lock}}
{{dsc h1|Functions}}
{{dsc inc | cpp/thread/shared_lock/dsc swap2}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    class shared_timed_mutex;

    template &lt;class Mutex&gt; class shared_lock;

    template &lt;class Mutex&gt;
    void swap(shared_lock&lt;Mutex&gt;&amp; x, shared_lock&lt;Mutex&gt;&amp; y) noexcept;
}
}}

====Class {{lc|std::shared_timed_mutex}}====
{{source|1=
class shared_timed_mutex {
 public:
    shared_timed_mutex();
    ~shared_timed_mutex();
    shared_timed_mutex(const shared_timed_mutex&amp;) = delete;
    shared_timed_mutex&amp; operator=(const shared_timed_mutex&amp;) = delete;

    // Exclusive ownership
    void lock(); // blocking
    bool try_lock();
    template &lt;class Rep, class Period&gt;
    bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
    bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock();

    // Shared ownership
    void lock_shared(); // blocking
    bool try_lock_shared();
    template &lt;class Rep, class Period&gt;
    bool try_lock_shared_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
    bool try_lock_shared_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock_shared();
};
}}

====Class {{lc|std::shared_lock}}====
{{source|1=
template &lt;class Mutex&gt;
class shared_lock {
 public:
    typedef Mutex mutex_type;

    shared_lock() noexcept;
    explicit shared_lock(mutex_type&amp; m); // blocking
    shared_lock(mutex_type&amp; m, defer_lock_t) noexcept;
    shared_lock(mutex_type&amp; m, try_to_lock_t);
    shared_lock(mutex_type&amp; m, adopt_lock_t);
    template &lt;class Clock, class Duration&gt;
    shared_lock(mutex_type&amp; m,
    const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    template &lt;class Rep, class Period&gt;
    shared_lock(mutex_type&amp; m,
    const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    ~shared_lock();
    shared_lock(shared_lock const&amp;) = delete;
    shared_lock&amp; operator=(shared_lock const&amp;) = delete;
    shared_lock(shared_lock&amp;&amp; u) noexcept;
    shared_lock&amp; operator=(shared_lock&amp;&amp; u) noexcept;

    void lock(); // blocking
    bool try_lock();
    template &lt;class Rep, class Period&gt;
    bool try_lock_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
    template &lt;class Clock, class Duration&gt;
    bool try_lock_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
    void unlock();

    // Setters
    void swap(shared_lock&amp; u) noexcept;
    mutex_type* release() noexcept;

    // Getters
    bool owns_lock() const noexcept;
    explicit operator bool () const noexcept;
    mutex_type* mutex() const noexcept;

 private:
    mutex_type* pm; // exposition only
    bool owns; // exposition only
};
}}</text>
      <sha1>ddbmxb47qmx1kkrbwy0agbsrd4orjyu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/sstream</title>
    <ns>0</ns>
    <id>12855</id>
    <revision>
      <id>63997</id>
      <timestamp>2013-08-06T02:03:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="9146">{{cpp/header/title|sstream}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/Output]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc tclass | cpp/io/basic_stringbuf | implements raw string device}}
{{dsc tclass | cpp/io/basic_istringstream | implements high-level string stream input operations}}
{{dsc tclass | cpp/io/basic_ostringstream | implements high-level string stream output operations}}
{{dsc tclass | cpp/io/basic_stringstream | implements high-level string stream input/output operations}}
{{dsc h1|Typedefs}}
{{dsc | {{tt|stringbuf}} | {{c|basic_stringbuf&lt;char&gt;}}}}
{{dsc | {{tt|wstringbuf}} | {{c|basic_stringbuf&lt;wchar_t&gt;}}}}
{{dsc | {{tt|istringstream}} | {{c|basic_istringstream&lt;char&gt;}}}}
{{dsc | {{tt|wistringstream}} | {{c|basic_istringstream&lt;wchar_t&gt;}}}}
{{dsc | {{tt|ostringstream}} | {{c|basic_ostringstream&lt;char&gt;}}}}
{{dsc | {{tt|wostringstream}} | {{c|basic_ostringstream&lt;wchar_t&gt;}}}}
{{dsc | {{tt|stringstream}} | {{c|basic_stringstream&lt;char&gt;}}}}
{{dsc | {{tt|wstringstream}} | {{c|basic_stringstream&lt;wchar_t&gt;}}}}
{{dsc h1|Functions}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap2}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

    template &lt;class charT,
              class traits = char_traits&lt;charT&gt;,
              class Allocator = allocator&lt;charT&gt; &gt;
        class basic_stringbuf;
    typedef basic_stringbuf&lt;char&gt; stringbuf;
    typedef basic_stringbuf&lt;wchar_t&gt; wstringbuf;
    template &lt;class charT, class traits, class Allocator&gt;
        void swap(basic_stringbuf&lt;charT, traits, Allocator&gt;&amp; x,
                  basic_stringbuf&lt;charT, traits, Allocator&gt;&amp; y);

    template &lt;class charT,
              class traits = char_traits&lt;charT&gt;,
              class Allocator = allocator&lt;charT&gt; &gt;
        class basic_istringstream;
    typedef basic_istringstream&lt;char&gt; istringstream;
    typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
    template &lt;class charT, class traits, class Allocator&gt;
        void swap(basic_istringstream&lt;charT, traits, Allocator&gt;&amp; x,
                  basic_istringstream&lt;charT, traits, Allocator&gt;&amp; y);

    template &lt;class charT,
              class traits = char_traits&lt;charT&gt;,
              class Allocator = allocator&lt;charT&gt; &gt;
        class basic_ostringstream;
    typedef basic_ostringstream&lt;char&gt; ostringstream;
    typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
    template &lt;class charT, class traits, class Allocator&gt;
        void swap(basic_ostringstream&lt;charT, traits, Allocator&gt;&amp; x,
                  basic_ostringstream&lt;charT, traits, Allocator&gt;&amp; y);

    template &lt;class charT,
              class traits = char_traits&lt;charT&gt;,
              class Allocator = allocator&lt;charT&gt; &gt;
        class basic_stringstream;
    typedef basic_stringstream&lt;char&gt; stringstream;
    typedef basic_stringstream&lt;wchar_t&gt; wstringstream;
    template &lt;class charT, class traits, class Allocator&gt;
        void swap(basic_stringstream&lt;charT, traits, Allocator&gt;&amp; x,
                  basic_stringstream&lt;charT, traits, Allocator&gt;&amp; y);
}
}}

====Class {{lc|std::basic_stringbuf}}====
{{source|1=
template &lt;class charT,
          class traits = char_traits&lt;charT&gt;,
          class Allocator = allocator&lt;charT&gt; &gt;
class basic_stringbuf : public basic_streambuf&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;
    typedef Allocator allocator_type;

    // Constructors:
    explicit basic_stringbuf(ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    explicit basic_stringbuf(const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    basic_stringbuf(const basic_stringbuf&amp; rhs) = delete;
    basic_stringbuf(basic_stringbuf&amp;&amp; rhs);

    // Assign and swap:
    basic_stringbuf&amp; operator=(const basic_stringbuf&amp; rhs) = delete;
    basic_stringbuf&amp; operator=(basic_stringbuf&amp;&amp; rhs);
    void swap(basic_stringbuf&amp; rhs);

    // Get and set:
    basic_string&lt;charT,traits,Allocator&gt; str() const;
    void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);

 protected:
    // Overridden virtual functions:
    virtual int_type underflow();
    virtual int_type pbackfail(int_type c = traits::eof());
    virtual int_type overflow (int_type c = traits::eof());
    virtual basic_streambuf&lt;charT,traits&gt;* setbuf(charT*, streamsize);
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);

 private:
    ios_base::openmode mode; // exposition only
};
}}

====Class {{lc|std::basic_istringstream}}====
{{source|1=
template &lt;class charT,
          class traits = char_traits&lt;charT&gt;,
          class Allocator = allocator&lt;charT&gt; &gt;
class basic_istringstream : public basic_istream&lt;charT,traits&gt; {
 public:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;
    typedef Allocator allocator_type;

    // Constructors:
    explicit basic_istringstream(ios_base::openmode which = ios_base::in);
    explicit basic_istringstream(const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                                 ios_base::openmode which = ios_base::in);
    basic_istringstream(const basic_istringstream&amp; rhs) = delete;
    basic_istringstream(basic_istringstream&amp;&amp; rhs);

    // Assign and swap:
    basic_istringstream&amp; operator=(const basic_istringstream&amp; rhs) = delete;
    basic_istringstream&amp; operator=(basic_istringstream&amp;&amp; rhs);
    void swap(basic_istringstream&amp; rhs);

    // Members:
    basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
    basic_string&lt;charT,traits,Allocator&gt; str() const;
    void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);

 private:
    basic_stringbuf&lt;charT,traits,Allocator&gt; sb; // exposition only
};
}}

====Class {{lc|std::basic_ostringstream}}====
{{source|1=
template &lt;class charT,
          class traits = char_traits&lt;charT&gt;,
          class Allocator = allocator&lt;charT&gt; &gt;
class basic_ostringstream : public basic_ostream&lt;charT,traits&gt; {
 public:
    // types:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;
    typedef Allocator allocator_type;

    // Constructors/destructor:
    explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
    explicit basic_ostringstream(const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                                 ios_base::openmode which = ios_base::out);
     basic_ostringstream(const basic_ostringstream&amp; rhs) = delete;
     basic_ostringstream(basic_ostringstream&amp;&amp; rhs);

    // Assign/swap:
    basic_ostringstream&amp; operator=(const basic_ostringstream&amp; rhs) = delete;
    basic_ostringstream&amp; operator=(basic_ostringstream&amp;&amp; rhs);
    void swap(basic_ostringstream&amp; rhs);

    // Members:
    basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
    basic_string&lt;charT,traits,Allocator&gt; str() const;
    void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);

 private:
    basic_stringbuf&lt;charT,traits,Allocator&gt; sb; // exposition only
};
}}

====Class {{lc|std::basic_stringstream}}====
{{source|1=
template &lt;class charT,
          class traits = char_traits&lt;charT&gt;,
          class Allocator = allocator&lt;charT&gt; &gt;
class basic_stringstream : public basic_iostream&lt;charT,traits&gt; {
 public:
    // types:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;
    typedef Allocator allocator_type;

    // constructors/destructor
    explicit basic_stringstream(ios_base::openmode which = ios_base::out{{!}}ios_base::in);
    explicit basic_stringstream(const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                                ios_base::openmode which = ios_base::out{{!}}ios_base::in);
    basic_stringstream(const basic_stringstream&amp; rhs) = delete;
    basic_stringstream(basic_stringstream&amp;&amp; rhs);

    // Assign/swap:
    basic_stringstream&amp; operator=(const basic_stringstream&amp; rhs) = delete;
    basic_stringstream&amp; operator=(basic_stringstream&amp;&amp; rhs);
    void swap(basic_stringstream&amp; rhs);

    // Members:
    basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
    basic_string&lt;charT,traits,Allocator&gt; str() const;
    void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);

 private:
    basic_stringbuf&lt;charT, traits&gt; sb; // exposition only
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/stack</title>
    <ns>0</ns>
    <id>12848</id>
    <revision>
      <id>63989</id>
      <parentid>63988</parentid>
      <timestamp>2013-08-05T23:58:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>no std:: inside std</comment>
      <text xml:space="preserve" bytes="3124">{{cpp/header/title|stack}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc stack}}
{{dsc inc | cpp/container/dsc uses_allocator | stack}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | stack}}
{{dsc inc | cpp/container/dsc swap2 | stack}}
{{dsc end}}

===Synopsis===

{{source|1=

#include &lt;initializer_list&gt;

namespace std {
    template &lt;class T, class Container = deque&lt;T&gt; &gt; class stack;

    template &lt;class T, class Container&gt;
        bool operator==(const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator!=(const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);

    template &lt;class T, class Container&gt;
        bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);
    template &lt;class T, class Container&gt;
        bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,const stack&lt;T, Container&gt;&amp; y);

    template &lt;class T, class Container&gt;
        void swap(stack&lt;T, Container&gt;&amp; x, stack&lt;T, Container&gt;&amp; y)
            noexcept(noexcept(x.swap(y)));

    template &lt;class T, class Container, class Alloc&gt;
        struct uses_allocator&lt;stack&lt;T, Container&gt;, Alloc&gt; :
             uses_allocator&lt;Container, Alloc&gt;::type { };
}
}}

====Class {{lc|std::stack}}====
{{source|1=
template &lt;class T, class Container = std::deque&lt;T&gt; &gt;
class stack {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;

 protected:
    Container c;

 public:
    explicit stack(const Container&amp;);
    explicit stack(Container&amp;&amp; = Container());
    template &lt;class Alloc&gt; explicit stack(const Alloc&amp;);
    template &lt;class Alloc&gt; stack(const Container&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; stack(Container&amp;&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; stack(const stack&amp;, const Alloc&amp;);
    template &lt;class Alloc&gt; stack(stack&amp;&amp;, const Alloc&amp;);

    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    reference top() {
        return c.back();
    }
    const_reference top() const {
        return c.back();
    }
    void push(const value_type&amp; x) {
        c.push_back(x);
    }
    void push(value_type&amp;&amp; x) {
        c.push_back(std::move(x));
    }
    template &lt;class... Args&gt; void emplace(Args&amp;&amp;... args) {
        c.emplace_back(std::forward&lt;Args&gt;(args)...);
    }
    void pop() {
        c.pop_back();
    }
    void swap(stack&amp; s) noexcept(noexcept(swap(c, s.c))) {
        using std::swap;
        swap(c, s.c);
    }
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/stdexcept</title>
    <ns>0</ns>
    <id>9690</id>
    <revision>
      <id>49591</id>
      <parentid>45196</parentid>
      <timestamp>2013-06-01T02:47:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2953">{{cpp/header/title|stdexcept}}
{{cpp/header/navbar}}

This header is part of the [[cpp/error|error handling]] library.

===Classes===
{{dsc begin}}
{{dsc class | cpp/error/logic_error | exception class to indicate violations of logical preconditions or class invariants}}
{{dsc class | cpp/error/invalid_argument | exception class to report invalid arguments}}
{{dsc class | cpp/error/domain_error | exception class to report domain errors}}
{{dsc class | cpp/error/length_error | exception class to report attempts to exceed maximum allowed size}}
{{dsc class | cpp/error/out_of_range | exception class to report arguments outside of expected range}}
{{dsc class | cpp/error/runtime_error | exception class to indicate conditions only detectable at run time}}
{{dsc class | cpp/error/range_error | exception class to report range errors in internal computations}}
{{dsc class | cpp/error/overflow_error | exception class to report arithmetic overflows}}
{{dsc class | cpp/error/underflow_error | exception class to report arithmetic underflows}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    class logic_error;
        class domain_error;
        class invalid_argument;
        class length_error;
        class out_of_range;
    class runtime_error;
        class range_error;
        class overflow_error;
        class underflow_error;
}

}}

====Classes====
{{source|

class logic_error : public exception {
    public:
        explicit logic_error(const string&amp; what_arg);
        explicit logic_error(const char* what_arg);
};

class domain_error : public logic_error {
    public:
        explicit domain_error(const string&amp; what_arg);
        explicit domain_error(const char* what_arg);
};


class invalid_argument : public logic_error {
    public:
        explicit invalid_argument(const string&amp; what_arg);
        explicit invalid_argument(const char* what_arg);
};


class length_error : public logic_error {
    public:
        explicit length_error(const string&amp; what_arg);
        explicit length_error(const char* what_arg);
};


class out_of_range : public logic_error {
    public:
        explicit out_of_range(const string&amp; what_arg);
        explicit out_of_range(const char* what_arg);
};

class runtime_error : public exception {
    public:
        explicit runtime_error(const string&amp; what_arg);
        explicit runtime_error(const char* what_arg);
};

class range_error : public runtime_error {
    public:
        explicit range_error(const string&amp; what_arg);
        explicit range_error(const char* what_arg);
};

class overflow_error : public runtime_error {
    public:
        explicit overflow_error(const string&amp; what_arg);
        explicit overflow_error(const char* what_arg);
};

class underflow_error : public runtime_error {
    public:
        explicit underflow_error(const string&amp; what_arg);
        explicit underflow_error(const char* what_arg);
};

}}

===See Also===
* {{lc|std::exception}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/streambuf</title>
    <ns>0</ns>
    <id>12854</id>
    <revision>
      <id>63996</id>
      <timestamp>2013-08-06T01:32:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3309">{{cpp/header/title|streambuf}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/Output]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc tclass | cpp/io/basic_streambuf | abstracts a raw device}}
{{dsc h1|Typedefs}}
{{dsc | {{tt|streambuf}} | {{c|basic_streambuf&lt;char&gt;}}}}
{{dsc | {{tt|wstreambuf}} | {{c|basic_streambuf&lt;wchar_t&gt;}}}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {

    template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
    class basic_streambuf;

    typedef basic_streambuf&lt;char&gt; streambuf;
    typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
}
}}

====Class {{lc|std::basic_streambuf}}====
{{source|1=
template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
class basic_streambuf {
 public:
    // types:
    typedef charT char_type;
    typedef typename traits::int_type int_type;
    typedef typename traits::pos_type pos_type;
    typedef typename traits::off_type off_type;
    typedef traits traits_type;

    virtual ~basic_streambuf();

    // locales:
    locale pubimbue(const locale&amp; loc);
    locale getloc() const;

    // buffer and positioning:
    basic_streambuf&lt;char_type,traits&gt;*
    pubsetbuf(char_type* s, streamsize n);
    pos_type pubseekoff(off_type off, ios_base::seekdir way,
                        ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    pos_type pubseekpos(pos_type sp,
                        ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    int pubsync();

    // Get area:
    streamsize in_avail();
    int_type snextc();
    int_type sbumpc();
    int_type sgetc();
    streamsize sgetn(char_type* s, streamsize n);

    // Putback:
    int_type sputbackc(char_type c);
    int_type sungetc();

    // Put area:
    int_type sputc(char_type c);
    streamsize sputn(const char_type* s, streamsize n);

 protected:
    basic_streambuf();
    basic_streambuf(const basic_streambuf&amp; rhs);
    basic_streambuf&amp; operator=(const basic_streambuf&amp; rhs);
    void swap(basic_streambuf&amp; rhs);

    // Get area:
    char_type* eback() const;
    char_type* gptr() const;
    char_type* egptr() const;
    void gbump(int n);
    void setg(char_type* gbeg, char_type* gnext, char_type* gend);

    // Put area:
    char_type* pbase() const;
    char_type* pptr() const;
    char_type* epptr() const;
    void pbump(int n);
    void setp(char_type* pbeg, char_type* pend);

    // virtual functions:
    // Locales:
    virtual void imbue(const locale&amp; loc);

    // Buffer management and positioning:
    virtual basic_streambuf&lt;char_type,traits&gt;* setbuf(char_type* s, streamsize n);
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual int sync();

    // Get area:
    virtual streamsize showmanyc();
    virtual streamsize xsgetn(char_type* s, streamsize n);
    virtual int_type underflow();
    virtual int_type uflow();

    // Putback:
    virtual int_type pbackfail(int_type c = traits::eof());

    // Put area:
    virtual streamsize xsputn(const char_type* s, streamsize n);
    virtual int_type overflow (int_type c = traits::eof());
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/string</title>
    <ns>0</ns>
    <id>9652</id>
    <revision>
      <id>57533</id>
      <parentid>49592</parentid>
      <timestamp>2013-06-01T05:55:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="12333">{{cpp/header/title|string}}
{{cpp/header/navbar}}

This header is part of the [[cpp/string|strings]] library.

===Includes===
{{dsc begin}}
{{dsc | {{header|initializer_list}} | {{mark since c++11}} }}
{{dsc end}}

===Classes===
{{dsc begin}}
{{dsc hitem | Name | Description}}
{{dsc| {{lc|std::char_traits}} | Class Template which describes properties of a character type {{mark tclass}} }}
{{dsc| {{c|std::char_traits&lt;char&gt;}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;wchar_t&gt;}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;char16_t&gt;}} {{mark c++11}} | {{mark ptclass}} }}
{{dsc| {{c|std::char_traits&lt;char32_t&gt;}} {{mark c++11}} | {{mark ptclass}} }}

{{dsc| {{lc|std::basic_string}} | Class template representing a text string object {{mark tclass}} }}
{{dsc| {{lc|std::string}} | {{c|std::basic_string&lt;char&gt;}} {{mark typedef}} }}
{{dsc | {{lc|std::wstring}} | {{c|std::basic_string&lt;wchar_t&gt;}} {{mark typedef}} }}
{{dsc | {{lc|std::u16string}} {{mark c++11}} | {{c|std::basic_string&lt;char16_t&gt;}}  {{mark typedef}} }}
{{dsc | {{lc|std::u32string}} {{mark c++11}} | {{c|std::basic_string&lt;char32_t&gt;}} {{mark typedef}}}}

{{dsc | {{c|std::hash&lt;std::string&gt;}} {{mark c++11}} | {{mark ptclass}} }}
{{dsc | {{c|std::hash&lt;std::u16string&gt;}} {{mark c++11}} | {{mark ptclass}} }}
{{dsc | {{c|std::hash&lt;std::u32string&gt;}} {{mark c++11}} | {{mark ptclass}}}}
{{dsc | {{c|std::hash&lt;std::wstring&gt;}}  {{mark c++11}} | {{mark ptclass}}}}
{{dsc end}}

===Functions===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator+}}
{{dsc inc | cpp/string/basic_string/dsc operator_cmp}}
{{dsc inc | cpp/string/basic_string/dsc swap2}}

{{dsc h2 | Input/output}}
{{dsc inc | cpp/string/basic_string/dsc operator_ltltgtgt}}
{{dsc inc | cpp/string/basic_string/dsc getline}}

{{dsc h2 | Numeric conversions}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/basic_string/dsc stoul}}
{{dsc inc | cpp/string/basic_string/dsc stof}}
{{dsc inc | cpp/string/basic_string/dsc to_string}}
{{dsc inc | cpp/string/basic_string/dsc to_wstring}}
{{dsc end}}


===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {

    // character traits:
    template&lt;class charT&gt; struct char_traits;
    template &lt;&gt; struct char_traits&lt;char&gt;;
    template &lt;&gt; struct char_traits&lt;char16_t&gt;;
    template &lt;&gt; struct char_traits&lt;char32_t&gt;;
    template &lt;&gt; struct char_traits&lt;wchar_t&gt;;
        
    // basic_string:
    template&lt;class charT, class traits {{=}} char_traits&lt;charT&gt;,
        class Allocator {{=}} allocator&lt;charT&gt; &gt;
            class basic_string;
            
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                    const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
                    const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                    basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
                    basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const charT* lhs,
                    const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const charT* lhs,
                    basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(charT lhs, const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(charT lhs, basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                    const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs,
                    const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, charT rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_string&lt;charT,traits,Allocator&gt;
            operator+(basic_string&lt;charT,traits,Allocator&gt;&amp;&amp; lhs, charT rhs);
            
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator{{==}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
            const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator{{==}}(const charT* lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator{{==}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs
                        const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator!{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator!{{=}}(const charT* lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator!{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const charT* rhs);

    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt; (const charT* lhs,
            const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
        
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt; (const charT* lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);

    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt;{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt;{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&lt;{{=}}(const charT* lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt;{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt;{{=}}(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                        const charT* rhs);
    template&lt;class charT, class traits, class Allocator&gt;
        bool operator&gt;{{=}}(const charT* lhs,
                        const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);

    // swap:
    template&lt;class charT, class traits, class Allocator&gt;
        void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
                basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);

    // inserters and extractors:
    template&lt;class charT, class traits, class Allocator&gt;
        basic_istream&lt;charT,traits&gt;&amp;
            operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;&amp; is,
                    basic_string&lt;charT,traits,Allocator&gt;&amp; str);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_ostream&lt;charT, traits&gt;&amp;
            operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;&amp; os,
                    const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_istream&lt;charT,traits&gt;&amp;
            getline(basic_istream&lt;charT,traits&gt;&amp; is,
                    basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                    charT delim);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_istream&lt;charT,traits&gt;&amp;
            getline(basic_istream&lt;charT,traits&gt;&amp;&amp; is,
                    basic_string&lt;charT,traits,Allocator&gt;&amp; str,
                    charT delim);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_istream&lt;charT,traits&gt;&amp;
            getline(basic_istream&lt;charT,traits&gt;&amp; is,
                    basic_string&lt;charT,traits,Allocator&gt;&amp; str);
    template&lt;class charT, class traits, class Allocator&gt;
        basic_istream&lt;charT,traits&gt;&amp;
            getline(basic_istream&lt;charT,traits&gt;&amp;&amp; is,
                    basic_string&lt;charT,traits,Allocator&gt;&amp; str);

    // basic_string typedef names
    typedef basic_string&lt;char&gt; string;
    typedef basic_string&lt;char16_t&gt; u16string;
    typedef basic_string&lt;char32_t&gt; u32string;
    typedef basic_string&lt;wchar_t&gt; wstring;

    // numeric conversions:
    int stoi(const string&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    long stol(const string&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    unsigned long stoul(const string&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    long long stoll(const string&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    unsigned long long stoull(const string&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    float stof(const string&amp; str, size_t *idx {{=}} 0);
    double stod(const string&amp; str, size_t *idx {{=}} 0);
    long double stold(const string&amp; str, size_t *idx {{=}} 0);
    string to_string(int val);
    string to_string(unsigned val);
    string to_string(long val);
    string to_string(unsigned long val);
    string to_string(long long val);
    string to_string(unsigned long long val);
    string to_string(float val);
    string to_string(double val);
    string to_string(long double val);

    int stoi(const wstring&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    long stol(const wstring&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    unsigned long stoul(const wstring&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    long long stoll(const wstring&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    unsigned long long stoull(const wstring&amp; str, size_t *idx {{=}} 0, int base {{=}} 10);
    float stof(const wstring&amp; str, size_t *idx {{=}} 0);
    double stod(const wstring&amp; str, size_t *idx {{=}} 0);
    long double stold(const wstring&amp; str, size_t *idx {{=}} 0);
    wstring to_wstring(int val);
    wstring to_wstring(unsigned val);
    wstring to_wstring(long val);
    wstring to_wstring(unsigned long val);
    wstring to_wstring(long long val);
    wstring to_wstring(unsigned long long val);
    wstring to_wstring(float val);
    wstring to_wstring(double val);
    wstring to_wstring(long double val);

    // hash support:
    template &lt;class T&gt; struct hash;
    template &lt;&gt; struct hash&lt;string&gt;;
    template &lt;&gt; struct hash&lt;u16string&gt;;
    template &lt;&gt; struct hash&lt;u32string&gt;;
    template &lt;&gt; struct hash&lt;wstring&gt;;

} // namespace std


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/strstream</title>
    <ns>0</ns>
    <id>12859</id>
    <revision>
      <id>64002</id>
      <timestamp>2013-08-06T03:36:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3922">{{cpp/header/title|strstream}}
{{cpp/header/navbar}}
This header is part of the [[cpp/io|Input/Output]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc class | cpp/io/strstreambuf | notes={{mark deprecated}} | implements raw character array device}}
{{dsc class | cpp/io/istrstream | notes={{mark deprecated}} | implements character array input operations}}
{{dsc class | cpp/io/ostrstream | notes={{mark deprecated}} | implements character array output operations}}
{{dsc class | cpp/io/strstream | notes={{mark deprecated}} | implements character array input/output operations}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    class strstreambuf;
    class istrstream;
    class ostrstream;
    class strstream;
}
}}

====Class {{lc|std::strstreambuf}}====
{{source|1=
class strstreambuf : public basic_streambuf&lt;char&gt; {
 public:
    explicit strstreambuf(streamsize alsize_arg = 0);
    strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
    strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
    strstreambuf(const char* gnext_arg, streamsize n);
    strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0);
    strstreambuf(const signed char* gnext_arg, streamsize n);
    strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0);
    strstreambuf(const unsigned char* gnext_arg, streamsize n);
    virtual ~strstreambuf();

    void freeze(bool freezefl = true);
    char* str();
    int pcount();

 protected:
    virtual int_type overflow (int_type c = EOF);
    virtual int_type pbackfail(int_type c = EOF);
    virtual int_type underflow();
    virtual pos_type seekoff(off_type off, ios_base::seekdir way,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual pos_type seekpos(pos_type sp,
                             ios_base::openmode which = ios_base::in{{!}}ios_base::out);
    virtual streambuf* setbuf(char* s, streamsize n);

 private:
    typedef /*bitmask type*/ strstate; // exposition only
    static const strstate allocated; // exposition only
    static const strstate constant; // exposition only
    static const strstate dynamic; // exposition only
    static const strstate frozen; // exposition only
    strstate strmode; // exposition only
    streamsize alsize; // exposition only
    void* (*palloc)(size_t); // exposition only
    void (*pfree)(void*); // exposition only
};
}}

====Class {{lc|std::istrstream}}====
{{source|1=
class istrstream : public basic_istream&lt;char&gt; {
 public:
    explicit istrstream(const char* s);
    explicit istrstream(char* s);
    istrstream(const char* s, streamsize n);
    istrstream(char* s, streamsize n);
    virtual ~istrstream();

    strstreambuf* rdbuf() const;
    char *str();

 private:
    strstreambuf sb; // exposition only
};
}}

====Class {{lc|std::ostrstream}}====
{{source|1=
class ostrstream : public basic_ostream&lt;char&gt; {
 public:
    ostrstream();
    ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
    virtual ~ostrstream();

    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    char* str();
    int pcount() const;

 private:
    strstreambuf sb; // exposition only
};
}}

====Class {{lc|std::strstream}}====
{{source|1=
class strstream : public basic_iostream&lt;char&gt; {
 public:
    // Types
    typedef char char_type;
    typedef typename char_traits&lt;char&gt;::int_type int_type;
    typedef typename char_traits&lt;char&gt;::pos_type pos_type;
    typedef typename char_traits&lt;char&gt;::off_type off_type;

    // constructors/destructor
    strstream();
    strstream(char* s, int n,
    ios_base::openmode mode = ios_base::in|ios_base::out);
    virtual ~strstream();

    // Members:
    strstreambuf* rdbuf() const;
    void freeze(bool freezefl = true);
    int pcount() const;
    char* str();

 private:
    strstreambuf sb; // exposition only
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/system error</title>
    <ns>0</ns>
    <id>9742</id>
    <revision>
      <id>63147</id>
      <parentid>57534</parentid>
      <timestamp>2013-07-03T08:13:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typos, links</comment>
      <text xml:space="preserve" bytes="6732">{{cpp/header/title|system_error}}
{{cpp/header/navbar}}

This header is part of the [[cpp/error|error handling]] library.

===Classes===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_category}}
{{dsc inc | cpp/error/dsc generic_category}}
{{dsc inc | cpp/error/dsc system_category}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/error/dsc errc}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc system_error}}
{{dsc inc | cpp/error/error_code/dsc is_error_code_enum}}
{{dsc inc | cpp/error/error_condition/dsc is_error_condition_enum}}
{{dsc inc | cpp/error/error_code/dsc hash}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc operator_cmp}}
{{dsc inc | cpp/error/error_code/dsc operator_ltlt}}
{{dsc inc | cpp/error/errc/dsc make_error_code}}
{{dsc inc | cpp/error/error_condition/dsc operator_cmp}}
{{dsc inc | cpp/error/errc/dsc make_error_condition}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    class error_category;
    class error_code;
    class error_condition;
    class system_error;
    
    template &lt;class T&gt;
        struct is_error_code_enum : public false_type {};
        
    template &lt;class T&gt;
        struct is_error_condition_enum : public false_type {};
        
    enum class errc {
    
        address_family_not_supported,       //  EAFNOSUPPORT
        address_in_use,                     //  EADDRINUSE
        address_not_available,              //  EADDRNOTAVAIL
        already_connected,                  //  EISCONN
        argument_list_too_long,             //  E2BIG
        argument_out_of_domain,             //  EDOM
        bad_address,                        //  EFAULT
        bad_file_descriptor,                //  EBADF
        bad_message,                        //  EBADMSG
        broken_pipe,                        //  EPIPE
        connection_aborted,                 //  ECONNABORTED
        connection_already_in_progress,     //  EALREADY
        connection_refused,                 //  ECONNREFUSED
        connection_reset,                   //  ECONNRESET
        cross_device_link,                  //  EXDEV
        destination_address_required,       //  EDESTADDRREQ
        device_or_resource_busy,            //  EBUSY
        directory_not_empty,                //  ENOTEMPTY
        executable_format_error,            //  ENOEXEC
        file_exists,                        //  EEXIST
        file_too_large,                     //  EFBIG
        filename_too_long,                  //  ENAMETOOLONG
        function_not_supported,             //  ENOSYS
        host_unreachable,                   //  EHOSTUNREACH
        identifier_removed,                 //  EIDRM
        illegal_byte_sequence,              //  EILSEQ
        inappropriate_io_control_operation, //  ENOTTY
        interrupted,                        //  EINTR
        invalid_argument,                   //  EINVAL
        invalid_seek,                       //  ESPIPE
        io_error,                           //  EIO
        is_a_directory,                     //  EISDIR
        message_size,                       //  EMSGSIZE
        network_down,                       //  ENETDOWN
        network_reset,                      //  ENETRESET
        network_unreachable,                //  ENETUNREACH
        no_buffer_space,                    //  ENOBUFS
        no_child_process,                   //  ECHILD
        no_link,                            //  ENOLINK
        no_lock_available,                  //  ENOLCK
        no_message_available,               //  ENODATA
        no_message,                         //  ENOMSG
        no_protocol_option,                 //  ENOPROTOOPT
        no_space_on_device,                 //  ENOSPC
        no_stream_resources,                //  ENOSR
        no_such_device_or_address,          //  ENXIO
        no_such_device,                     //  ENODEV
        no_such_file_or_directory,          //  ENOENT
        no_such_process,                    //  ESRCH
        not_a_directory,                    //  ENOTDIR
        not_a_socket,                       //  ENOTSOCK
        not_a_stream,                       //  ENOSTR
        not_connected,                      //  ENOTCONN
        not_enough_memory,                  //  ENOMEM
        not_supported,                      //  ENOTSUP
        operation_canceled,                 //  ECANCELED
        operation_in_progress,              //  EINPROGRESS
        operation_not_permitted,            //  EPERM
        operation_not_supported,            //  EOPNOTSUPP
        operation_would_block,              //  EWOULDBLOCK
        owner_dead,                         //  EOWNERDEAD
        permission_denied,                  //  EACCES
        protocol_error,                     //  EPROTO
        protocol_not_supported,             //  EPROTONOSUPPORT
        read_only_file_system,              //  EROFS
        resource_deadlock_would_occur,      //  EDEADLK
        resource_unavailable_try_again,     //  EAGAIN
        result_out_of_range,                //  ERANGE
        state_not_recoverable,              //  ENOTRECOVERABLE
        stream_timeout,                     //  ETIME
        text_file_busy,                     //  ETXTBSY
        timed_out,                          //  ETIMEDOUT
        too_many_files_open_in_system,      //  ENFILE
        too_many_files_open,                //  EMFILE
        too_many_links,                     //  EMLINK
        too_many_symbolic_link_levels,      //  ELOOP
        value_too_large,                    //  EOVERFLOW
        wrong_protocol_type,                //  EPROTOTYPE
    };
    
    template &lt;&gt; struct is_error_condition_enum&lt;errc&gt; : true_type { }
    
    error_code make_error_code(errc e) noexcept;
    error_condition make_error_condition(errc e) noexcept;
    
    // Comparison operators:
    bool operator{{==}}(const error_code&amp; lhs,  const error_code&amp; rhs) noexcept;
    bool operator{{==}}(const error_code&amp; lhs,  const error_condition&amp; rhs) noexcept;
    bool operator{{==}}(const error_condition&amp;  lhs, const error_code&amp; rhs) noexcept;
    bool operator{{==}}(const error_condition&amp;  lhs, const error_condition&amp; rhs) noexcept;
    bool operator!{{=}}(const error_code&amp; lhs,  const error_code&amp; rhs) noexcept;
    bool operator!{{=}}(const error_code&amp; lhs,  const error_condition&amp; rhs) noexcept;
    bool operator!{{=}}(const error_condition&amp;  lhs, const error_code&amp; rhs) noexcept;
    bool operator!{{=}}(const error_condition&amp;  lhs, const error_condition&amp; rhs) noexcept;

    // Hash support
    template &lt;class T&gt; struct hash;
    template &lt;&gt; struct hash&lt;error_code&gt;;
} // namespace std


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/thread</title>
    <ns>0</ns>
    <id>12852</id>
    <revision>
      <id>72412</id>
      <parentid>63994</parentid>
      <timestamp>2014-08-20T08:16:54Z</timestamp>
      <contributor>
        <username>LB</username>
        <id>2506</id>
      </contributor>
      <comment>Pretty sure that was a typo, or meant for the above section</comment>
      <text xml:space="preserve" bytes="2735">{{cpp/header/title|thread}}
{{cpp/header/navbar}}
This header is part of the [[cpp/thread|thread support]] library.
{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/thread/dsc thread}}
{{dsc h1|Functions}}
{{dsc inc | cpp/thread/thread/dsc swap2}}
{{dsc inc | cpp/thread/thread/id/dsc operator_cmp}}
{{dsc inc | cpp/thread/thread/id/dsc operator_ltlt}}
{{dsc ptclass | cpp/thread/thread/id/hash | title=std::hash{{dsc small|&lt;std::thread::id&gt;}} | specializes {{lc|std::hash}}}}
{{dsc h1|Namespaces}}
{{dsc | {{ttb|this_thread}} | provide functions that access current the thread of execution}}
{{dsc h2|Functions}}
{{dsc namespace | std::this_thread }}
{{dsc inc | cpp/thread/dsc yield}}
{{dsc inc | cpp/thread/dsc get_id}}
{{dsc inc | cpp/thread/dsc sleep_for}}
{{dsc inc | cpp/thread/dsc sleep_until}}
{{dsc end}}

===Synopsis===

{{source|1=
namespace std {
    class thread;

    void swap(thread&amp; x, thread&amp; y) noexcept;

    bool operator==(thread::id x, thread::id y) noexcept;
    bool operator!=(thread::id x, thread::id y) noexcept;

    bool operator&lt;(thread::id x, thread::id y) noexcept;
    bool operator&lt;=(thread::id x, thread::id y) noexcept;
    bool operator&gt;(thread::id x, thread::id y) noexcept;
    bool operator&gt;=(thread::id x, thread::id y) noexcept;

    template&lt;class CharT, class Traits&gt;
    basic_ostream&lt;CharT, Traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;CharT, Traits&gt;&amp; out,
                                            thread::id id);
    
    template &lt;class T&gt; struct hash;
    template &lt;&gt; struct hash&lt;thread::id&gt;;

    namespace this_thread {

        thread::id get_id() noexcept;
        void yield() noexcept;
        template &lt;class Clock, class Duration&gt;
            void sleep_until(const chrono::time_point&lt;Clock, Duration&gt;&amp; abs_time);
        template &lt;class Rep, class Period&gt;
            void sleep_for(const chrono::duration&lt;Rep, Period&gt;&amp; rel_time);

    }
}
}}

====Class {{lc|std::thread}}====
{{source|1=
class thread {
 public:
    // types:
    class id;
    typedef /*implementation-defined*/ native_handle_type;

    // construct/copy/destroy:
    thread() noexcept;
    template &lt;class F, class ...Args&gt; explicit thread(F&amp;&amp; f, Args&amp;&amp;... args);
    ~thread();
    thread(const thread&amp;) = delete;
    thread(thread&amp;&amp;) noexcept;
    thread&amp; operator=(const thread&amp;) = delete;
    thread&amp; operator=(thread&amp;&amp;) noexcept;

    // members:
    void swap(thread&amp;) noexcept;
    bool joinable() const noexcept;
    void join();
    void detach();
    id get_id() const noexcept;
    native_handle_type native_handle();

    // static members:
    static unsigned hardware_concurrency() noexcept;
};
}}

====Class {{lc|std::thread::id}}====
{{source|1=
class thread::id {
 public:
    id() noexcept;
};
}}</text>
      <sha1>s06kj0lzdm3xlqmyjpyjq0yef735vfe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/tuple</title>
    <ns>0</ns>
    <id>9744</id>
    <revision>
      <id>57537</id>
      <parentid>49594</parentid>
      <timestamp>2013-06-01T05:55:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="5720">{{cpp/header/title|tuple}}
{{cpp/header/navbar}}
This header is part of the [[cpp/utility|general utility]] library.

{{dsc begin}}
{{dsc h1|Classes}}
{{dsc inc | cpp/utility/dsc tuple}}
{{dsc inc | cpp/utility/tuple/dsc tuple_size}}
{{dsc inc | cpp/utility/tuple/dsc tuple_element}}
{{dsc inc | cpp/utility/tuple/dsc uses_allocator}}
{{dsc h1|Constants}}
{{dsc inc | cpp/utility/tuple/dsc ignore}}
{{dsc h1|Functions}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tuple_cat}}
{{dsc inc | cpp/utility/tuple/dsc get}}
{{dsc inc | cpp/utility/tuple/dsc operator_cmp}}
{{dsc inc | cpp/utility/tuple/dsc swap2}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    
    // class template tuple:
    template &lt;class... Types&gt; class tuple;
        
    // tuple creation functions:
    const /*unspecified*/ ignore;
    template &lt;class... Types&gt;
        tuple&lt;VTypes...&gt; make_tuple(Types&amp;&amp;...);
    template &lt;class... Types&gt;
        tuple&lt;Types...&gt; forward_as_tuple(Types&amp;&amp;...) noexcept;
    template&lt;class... Types&gt;
        tuple&lt;Types&amp;...&gt; tie(Types&amp;...) noexcept;
    template &lt;class... Tuples&gt;
        tuple&lt;Ctypes...&gt; tuple_cat(Tuples&amp;&amp;...);
        
    //  tuple helper classes:
    template &lt;class T&gt; class tuple_size; // undefined
    template &lt;class T&gt; class tuple_size&lt;const T&gt;;
    template &lt;class T&gt; class tuple_size&lt;volatile T&gt;;
    template &lt;class T&gt; class tuple_size&lt;const volatile T&gt;;
    template &lt;class... Types&gt; class tuple_size&lt;tuple&lt;Types...&gt; &gt;;

    template    &lt;size_t I,  class   T&gt;  class   tuple_element; // undefined
    template    &lt;size_t I,  class   T&gt;  class   tuple_element&lt;I, const T&gt;;
    template    &lt;size_t I,  class   T&gt;  class   tuple_element&lt;I, volatile T&gt;;
    template    &lt;size_t I,  class   T&gt;  class   tuple_element&lt;I, const volatile T&gt;;
    template &lt;size_t I, class... Types&gt; class tuple_element&lt;I, tuple&lt;Types...&gt; &gt;;
    
    //  element access:
    template &lt;size_t I, class... Types&gt;
        typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp; get(tuple&lt;Types...&gt;&amp;) noexcept;
    template &lt;size_t I, class... types&gt;
        typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp;) noexcept;
    template &lt;size_t I, class... types&gt;
        typename tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp; get(const tuple&lt;Types...&gt;&amp;) noexcept;
        
    //relational operators:
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator{{==}}(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator&lt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator!{{=}}(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator&gt;(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator&lt;{{=}}(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
    template&lt;class... TTypes, class... UTypes&gt;
        bool operator&gt;{{=}}(const tuple&lt;TTypes...&gt;&amp;, const tuple&lt;UTypes...&gt;&amp;);
        
    // allocator-related traits
    template &lt;class... Types, class Alloc&gt;
        struct uses_allocator&lt;tuple&lt;Types...&gt;, Alloc&gt;;
    // specialized algorithms:
    template &lt;class... Types&gt;
        void swap(tuple&lt;Types...&gt;&amp; x, tuple&lt;Types...&gt;&amp; y) noexcept(x.swap(y));
}

}}

====Class {{lc|std::tuple}}====
{{source|

template &lt;class... Types&gt;
class tuple {
public:
    // tuple construction
    constexpr tuple();
    explicit tuple(const Types&amp;...);
    template &lt;class... UTypes&gt;
        explicit tuple(UTypes&amp;&amp;...);
    tuple(const tuple&amp;) {{=}} default;
    tuple(tuple&amp;&amp;) {{=}} default;
    template &lt;class... UTypes&gt;
        tuple(const tuple&lt;UTypes...&gt;&amp;); 
    template &lt;class... UTypes&gt;
        tuple(tuple&lt;UTypes...&gt;&amp;&amp;);
    template &lt;class U1, class U2&gt;
        tuple(const pair&lt;U1, U2&gt;&amp;);  // iff sizeof...(Types) {{==}} 2
    template &lt;class U1, class U2&gt;
        tuple(pair&lt;U1, U2&gt;&amp;&amp;);       // iff sizeof...(Types) {{==}} 2
    
    // allocator-extended constructors
    template &lt;class Alloc&gt;
        tuple(allocator_arg_t, const Alloc&amp; a);
    template &lt;class Alloc&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, const Types&amp;...);
    template &lt;class Alloc, class... UTypes&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, const UTypes&amp;&amp;...);
    template &lt;class Alloc&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, const tuple&amp;);
    template &lt;class Alloc&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp;);
    template &lt;class Alloc, class... UTypes&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp;);
    template &lt;class Alloc, class... UTypes&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp;);
    template &lt;class Alloc, class U1, class U2&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp;);
    template &lt;class Alloc, class U1, class U2&gt;
        tuple(allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp;);
        
    // tuple assignment
    tuple&amp; operator{{=}}(const tuple&amp;);
    tuple&amp; operator{{=}}(tuple&amp;&amp;) noexcept(see below);
    template &lt;class... UTypes&gt;
        tuple&amp; operator{{=}}(const tuple&lt;UTypes...&gt;&amp;);
    template &lt;class... UTypes&gt;
        tuple&amp; operator{{=}}(tuple&lt;UTypes...&gt;&amp;&amp;);
    template &lt;class U1, class U2&gt;
        tuple&amp; operator{{=}}(const pair&lt;U1, U2&gt;&amp;); // iff sizeof...(Types) {{==}} 2
    template &lt;class U1, class U2&gt;
        tuple&amp; operator{{=}}(pair&lt;U1, U2&gt;&amp;&amp;) noexcept; // iff sizeof...(Types) {{==}} 2
    
    // tuple swap
    void swap(tuple&amp;) noexcept(see below);
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/type traits</title>
    <ns>0</ns>
    <id>9746</id>
    <revision>
      <id>66214</id>
      <parentid>66213</parentid>
      <timestamp>2013-11-09T23:13:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>= in template</comment>
      <text xml:space="preserve" bytes="11052">{{cpp/header/title|type_traits}}
{{cpp/header/navbar}}
This header is part of the [[cpp/types|type support]] library.

{{dsc begin}}

{{dsc h1 | Classes}}

{{dsc h2 | Helper Classes}}
{{dsc inc | cpp/types/dsc integral_constant}}
{{dsc | {{tt|true_type}} | {{c|std::integral_constant&lt;bool, true&gt;}}}}
{{dsc | {{tt|false_type}} | {{c|std::integral_constant&lt;bool, false&gt;}}}}

{{dsc h2 | Primary type categories}}
{{dsc inc | cpp/types/dsc is_void}}
{{dsc inc | cpp/types/dsc is_null_pointer}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_enum}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_function}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_lvalue_reference}}
{{dsc inc | cpp/types/dsc is_rvalue_reference}}
{{dsc inc | cpp/types/dsc is_member_object_pointer}}
{{dsc inc | cpp/types/dsc is_member_function_pointer}}

{{dsc h2 | Composite type categories}}
{{dsc inc | cpp/types/dsc is_fundamental}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc inc | cpp/types/dsc is_compound}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc inc | cpp/types/dsc is_member_pointer}}

{{dsc h2 | Type properties}}
{{dsc inc | cpp/types/dsc is_const}}
{{dsc inc | cpp/types/dsc is_volatile}}
{{dsc inc | cpp/types/dsc is_trivial}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc inc | cpp/types/dsc is_standard_layout}}
{{dsc inc | cpp/types/dsc is_pod}}
{{dsc inc | cpp/types/dsc is_literal_type}}
{{dsc inc | cpp/types/dsc is_empty}}
{{dsc inc | cpp/types/dsc is_polymorphic}}
{{dsc inc | cpp/types/dsc is_abstract}}
{{dsc inc | cpp/types/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_unsigned}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Supported operations}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc inc | cpp/types/dsc is_assignable}}
{{dsc inc | cpp/types/dsc is_copy_assignable}}
{{dsc inc | cpp/types/dsc is_move_assignable}}
{{dsc inc | cpp/types/dsc is_destructible}}
{{dsc inc | cpp/types/dsc has_virtual_destructor}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Property queries}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Type relationships}}
{{dsc inc | cpp/types/dsc is_same}}
{{dsc inc | cpp/types/dsc is_base_of}}
{{dsc inc | cpp/types/dsc is_convertible}}

{{dsc h2 | Const-volatility specifiers}}
{{dsc inc | cpp/types/dsc remove_cv}}
{{dsc inc | cpp/types/dsc add_cv}}

{{dsc h2 | References}}
{{dsc inc | cpp/types/dsc remove_reference}}
{{dsc inc | cpp/types/dsc add_reference}}

{{dsc h2 | Pointers}}
{{dsc inc | cpp/types/dsc remove_pointer}}
{{dsc inc | cpp/types/dsc add_pointer}}

{{dsc h2 | Sign modifiers}}
{{dsc inc | cpp/types/dsc make_signed}}
{{dsc inc | cpp/types/dsc make_unsigned}}

{{dsc h2 | Arrays}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}

{{dsc h2 | Miscellaneous transformations}}
{{dsc inc | cpp/types/dsc aligned_storage}}
{{dsc inc | cpp/types/dsc aligned_union}}
{{dsc inc | cpp/types/dsc decay}}
{{dsc inc | cpp/types/dsc enable_if}}
{{dsc inc | cpp/types/dsc conditional}}
{{dsc inc | cpp/types/dsc common_type}}
{{dsc inc | cpp/types/dsc underlying_type}}
{{dsc inc | cpp/types/dsc result_of}}
{{dsc end}}

===Synopsis===
{{source|1=

namespace std {
    // helper class:
    template &lt;class T, T v&gt; struct integral_constant;
    typedef integral_constant&lt;bool, true&gt; true_type;
    typedef integral_constant&lt;bool, false&gt; false_type;
    // primary type categories:
    template &lt;class T&gt; struct is_void;
    template &lt;class T&gt; struct is_null_pointer;
    template &lt;class T&gt; struct is_integral;
    template &lt;class T&gt; struct is_floating_point;
    template &lt;class T&gt; struct is_array;
    template &lt;class T&gt; struct is_pointer;
    template &lt;class T&gt; struct is_lvalue_reference;
    template &lt;class T&gt; struct is_rvalue_reference;
    template &lt;class T&gt; struct is_member_object_pointer;
    template &lt;class T&gt; struct is_member_function_pointer;
    template &lt;class T&gt; struct is_enum;
    template &lt;class T&gt; struct is_union;
    template &lt;class T&gt; struct is_class;
    template &lt;class T&gt; struct is_function;
    // composite type categories:
    template &lt;class T&gt; struct is_reference;
    template &lt;class T&gt; struct is_arithmetic;
    template &lt;class T&gt; struct is_fundamental;
    template &lt;class T&gt; struct is_object;
    template &lt;class T&gt; struct is_scalar;
    template &lt;class T&gt; struct is_compound;
    template &lt;class T&gt; struct is_member_pointer;
    // type properties:
    template &lt;class T&gt; struct is_const;
    template &lt;class T&gt; struct is_volatile;
    template &lt;class T&gt; struct is_trivial;
    template &lt;class T&gt; struct is_trivially_copyable;
    template &lt;class T&gt; struct is_standard_layout;
    template &lt;class T&gt; struct is_pod;
    template &lt;class T&gt; struct is_literal_type;
    template &lt;class T&gt; struct is_empty;
    template &lt;class T&gt; struct is_polymorphic;
    template &lt;class T&gt; struct is_abstract;
    template &lt;class T&gt; struct is_signed;
    template &lt;class T&gt; struct is_unsigned;
    template &lt;class T, class... Args&gt; struct is_constructible;
    template &lt;class T&gt; struct is_default_constructible;
    template &lt;class T&gt; struct is_copy_constructible;
    template &lt;class T&gt; struct is_move_constructible;
    template &lt;class T, class U&gt; struct is_assignable;
    template &lt;class T&gt; struct is_copy_assignable;
    template &lt;class T&gt; struct is_move_assignable;
    template &lt;class T&gt; struct is_destructible;
    template &lt;class T, class... Args&gt; struct is_trivially_constructible;
    template &lt;class T&gt; struct is_trivially_default_constructible;
    template &lt;class T&gt; struct is_trivially_copy_constructible;
    template &lt;class T&gt; struct is_trivially_move_constructible;
    template &lt;class T, class U&gt; struct is_trivially_assignable;
    template &lt;class T&gt; struct is_trivially_copy_assignable;
    template &lt;class T&gt; struct is_trivially_move_assignable;
    template &lt;class T&gt; struct is_trivially_destructible;
    template &lt;class T, class... Args&gt; struct is_nothrow_constructible;
    template &lt;class T&gt; struct is_nothrow_default_constructible;
    template &lt;class T&gt; struct is_nothrow_copy_constructible;
    template &lt;class T&gt; struct is_nothrow_move_constructible;
    template &lt;class T, class U&gt; struct is_nothrow_assignable;
    template &lt;class T&gt; struct is_nothrow_copy_assignable;
    template &lt;class T&gt; struct is_nothrow_move_assignable;
    template &lt;class T&gt; struct is_nothrow_destructible;
    template &lt;class T&gt; struct has_virtual_destructor;
    // type property queries:
    template &lt;class T&gt; struct alignment_of;
    template &lt;class T&gt; struct rank;
    template &lt;class T, unsigned I {{=}} 0&gt; struct extent;
    // type relations:
    template &lt;class T, class U&gt; struct is_same;
    template &lt;class Base, class Derived&gt; struct is_base_of;
    template &lt;class From, class To&gt; struct is_convertible;
    // const-volatile modifications:
    template &lt;class T&gt; struct remove_const;
    template &lt;class T&gt; struct remove_volatile;
    template &lt;class T&gt; struct remove_cv;
    template &lt;class T&gt; struct add_const;
    template &lt;class T&gt; struct add_volatile;
    template &lt;class T&gt; struct add_cv;
    template &lt;class T&gt;
    using remove_const_t = typename remove_const&lt;T&gt;::type;
    template &lt;class T&gt;
    using remove_volatile_t = typename remove_volatile&lt;T&gt;::type;
    template &lt;class T&gt;
    using remove_cv_t = typename remove_cv&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_const_t = typename add_const&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_volatile_t = typename add_volatile&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_cv_t = typename add_cv&lt;T&gt;::type;
    // reference modifications:
    template &lt;class T&gt; struct remove_reference;
    template &lt;class T&gt; struct add_lvalue_reference;
    template &lt;class T&gt; struct add_rvalue_reference;
    template &lt;class T&gt;
    using remove_reference_t = typename remove_reference&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_lvalue_reference_t = typename add_lvalue_reference&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_rvalue_reference_t = typename add_rvalue_reference&lt;T&gt;::type;
    // sign modifications:
    template &lt;class T&gt; struct make_signed;
    template &lt;class T&gt; struct make_unsigned;
    template &lt;class T&gt;
    using make_signed_t = typename make_signed&lt;T&gt;::type;
    template &lt;class T&gt;
    using make_unsigned_t = typename make_unsigned&lt;T&gt;::type;
    // array modifications:
    template &lt;class T&gt; struct remove_extent;
    template &lt;class T&gt; struct remove_all_extents;
    template &lt;class T&gt;
    using remove_extent_t = typename remove_extent&lt;T&gt;::type;
    template &lt;class T&gt;
    using remove_all_extents_t = typename remove_all_extents&lt;T&gt;::type;
    // pointer modifications:
    template &lt;class T&gt; struct remove_pointer;
    template &lt;class T&gt; struct add_pointer;
    template &lt;class T&gt;
    using remove_pointer_t = typename remove_pointer&lt;T&gt;::type;
    template &lt;class T&gt;
    using add_pointer_t = typename add_pointer&lt;T&gt;::type;
    // other transformations:
    template &lt;std::size_t Len,
              std::size_t Align = /*default-alignment*/&gt;
    struct aligned_storage;
    template &lt;class T&gt; struct decay;
    template &lt;bool, class T {{=}} void&gt; struct enable_if;
    template &lt;bool, class T, class F&gt; struct conditional;
    template &lt;class... T&gt; struct common_type;
    template &lt;class T&gt; struct underlying_type;
    template &lt;class&gt; class result_of; // not defined
    template &lt;class F, class... ArgTypes&gt; class result_of&lt;F(ArgTypes...)&gt;;

    template &lt;std::size_t Len,
              std::size_t Align = /*default-alignment*/&gt;
    using aligned_storage_t = typename aligned_storage&lt;Len,Align&gt;::type;
    template &lt;std::size_t Len, class... Types&gt;
    using aligned_union_t = typename aligned_union&lt;Len,Types...&gt;::type;
    template &lt;class T&gt;
    using decay_t = typename decay&lt;T&gt;::type;
    template &lt;bool b, class T = void&gt;
    using enable_if_t = typename enable_if&lt;b,T&gt;::type;
    template &lt;bool b, class T, class F&gt;
    using conditional_t = typename conditional&lt;b,T,F&gt;::type;
    template &lt;class... T&gt;
    using common_type_t = typename common_type&lt;T...&gt;::type;
    template &lt;class T&gt;
    using underlying_type_t = typename underlying_type&lt;T&gt;::type;
    template &lt;class T&gt;
    using result_of_t = typename result_of&lt;T&gt;::type;
} // namespace std


}}

====Class {{lc|std::integral_constant}}====
{{source|

template &lt;class T, T v&gt;
struct integral_constant {
    static constexpr T value {{=}} v;
    typedef T value_type;
    typedef integral_constant&lt;T,v&gt; type;
    constexpr operator value_type() { return value; }
};
typedef integral_constant&lt;bool, true&gt; true_type;
typedef integral_constant&lt;bool, false&gt; false_type;

}}</text>
      <sha1>l1ikyakke8m1lj738ytvwizeb698eqi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/typeindex</title>
    <ns>0</ns>
    <id>9741</id>
    <revision>
      <id>57541</id>
      <parentid>49596</parentid>
      <timestamp>2013-06-01T05:55:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1292">{{cpp/header/title|typeindex}}
{{cpp/header/navbar}}

This header is part of the [[cpp/types|types support]] library.

===Classes===
{{dsc begin}}
{{dsc inc | cpp/types/dsc type_index}}
{{dsc inc | cpp/types/type_index/dsc hash}}
{{dsc h2|Forward declarations}}
{{dsc header|functional}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

===Synopsis===
{{source|

namespace std {
    class type_index;
    template &lt;class T&gt; struct hash;
    template&lt;&gt; struct hash&lt;type_index&gt;;
}

}}

====Class {{lc|std::type_index}}====
{{source|

class type_index {
public:
    type_index(const type_info&amp; rhs) noexcept;
    bool operator{{==}}(const type_index&amp; rhs) const noexcept;
    bool operator!{{=}}(const type_index&amp; rhs) const noexcept;
    bool operator&lt; (const type_index&amp; rhs) const noexcept;
    bool operator&lt;{{=}} (const type_index&amp; rhs) const noexcept;
    bool operator&gt; (const type_index&amp; rhs) const noexcept;
    bool operator&gt;{{=}} (const type_index&amp; rhs) const noexcept;
    size_t hash_code() const;
    const char* name() const;
private:
    const type_info* target; // exposition only
    // Note that the use of a pointer here, rather than a reference,
    // means that the default copy/move constructor and assignment
    // operators will be provided and work as expected.
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/typeinfo</title>
    <ns>0</ns>
    <id>9668</id>
    <revision>
      <id>57544</id>
      <parentid>49597</parentid>
      <timestamp>2013-06-01T05:55:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1444">{{cpp/header/title|typeinfo}}
{{cpp/header/navbar}}

This header is part of the [[cpp/types|type support]] library.

===Classes===
{{dsc begin}}
{{dsc inc | cpp/types/dsc type_info}}
{{dsc inc | cpp/types/dsc bad_typeid}}
{{dsc inc | cpp/types/dsc bad_cast}}
{{dsc end}}

===Synopsis===

{{source|

namespace std {
    class type_info;
    class bad_cast;
    class bad_typeid;
}

}}

====Class {{lc|std::type_info}}====
{{source|
class type_info {
public:
    virtual ~type_info();
    bool operator{{==}}(const type_info&amp; rhs) const noexcept;
    bool operator!{{=}}(const type_info&amp; rhs) const noexcept;
    bool before(const type_info&amp; rhs) const noexcept;
    size_t hash_code() const noexcept;
    const char* name() const noexcept;
    type_info(const type_info&amp; rhs) {{=}} delete;
    // cannot be copied
    type_info&amp; operator{{=}}(const type_info&amp; rhs) {{=}} delete; // cannot be copied
};
}}


====Class {{lc|std::bad_cast}}====
{{source|
class bad_cast : public exception {
public:
    bad_cast() noexcept;
    bad_cast(const bad_cast&amp;) noexcept;
    bad_cast&amp; operator{{=}}(const bad_cast&amp;) noexcept;
    virtual const char* what() const noexcept;
};
}}

====Class {{lc|std::bad_typeid}}====
{{source|
class bad_typeid : public exception {
public:
    bad_typeid() noexcept;
    bad_typeid(const bad_typeid&amp;) noexcept;
    bad_typeid&amp; operator{{=}}(const bad_typeid&amp;) noexcept;
    virtual const char* what() const noexcept;
};
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/unordered map</title>
    <ns>0</ns>
    <id>9797</id>
    <revision>
      <id>57545</id>
      <parentid>49598</parentid>
      <timestamp>2013-06-01T05:55:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="12798">{{cpp/header/title|unordered_map}}
{{cpp/header/navbar}}

This header is part of the [[cpp/container|containers]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc | {{header|initializer_list}} {{mark c++11}} }}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc unordered_map}}
{{dsc inc | cpp/container/dsc unordered_multimap}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_map}}
{{dsc inc | cpp/container/dsc swap2 | unordered_map}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multimap}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multimap}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    
    // class template unordered_map:
    template &lt;class Key,
        class T,
        class Hash {{=}} hash&lt;Key&gt;,
        class Pred {{=}} std::equal_to&lt;Key&gt;,
        class Alloc {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
    class unordered_map;
    
    // 23.5.5, class template unordered_multimap:
    template &lt;class Key,
        class T,
        class Hash {{=}} hash&lt;Key&gt;,
        class Pred {{=}} std::equal_to&lt;Key&gt;,
        class Alloc {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
    class unordered_multimap;
    
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    void swap(unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; x,
              unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; y);
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    void swap(unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; x,
              unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; y);
    
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    bool operator{{=}}{{=}}(const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,
                            const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    bool operator!{{=}}(const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_map&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    bool operator{{=}}{{=}}(const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,
                            const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class T, class Hash, class Pred, class Alloc&gt;
    bool operator!{{=}}(const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_multimap&lt;Key, T, Hash, Pred, Alloc&gt;&amp; b);
    
} // namespace std

}}

====Class {{lc|std::unordered_map}}====
{{source|

template &lt;class Key,
    class T,
    class Hash {{=}} hash&lt;Key&gt;,
    class Pred {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
class unordered_map
{
public:
    // types
    typedef Key                                         key_type;
    typedef Key                                         value_type;
    typedef Hash                                        hasher;
    typedef Pred                                        key_equal;
    typedef Allocator                                   allocator_type;
    typedef typename allocator_type::pointer            pointer;
    typedef typename allocator_type::const_pointer      const_pointer;
    typedef typename allocator_type::reference          reference;
    typedef typename allocator_type::const_reference    const_reference;
    typedef /*implementation-defined*/                  size_type;
    typedef /*implementation-defined*/                  difference_type;
    typedef /*implementation-defined*/                  iterator;
    typedef /*implementation-defined*/                  const_iterator;
    typedef /*implementation-defined*/                  local_iterator;
    typedef /*implementation-defined*/                  const_local_iterator;
    
    // construct/destroy/copy
    explicit unordered_map(size_type n {{=}} see below,
                           const hasher&amp; hf {{=}} hasher(),
                           const key_equal&amp; eql {{=}} key_equal(),
                           const allocator_type&amp; a {{=}} allocator_type());
    template &lt;class InputIterator&gt;
    unordered_map(InputIterator f, InputIterator l,
                  size_type n {{=}} see below,
                  const hasher&amp; hf {{=}} hasher(),
                  const key_equal&amp; eql {{=}} key_equal(),
                  const allocator_type&amp; a {{=}} allocator_type());
    unordered_map(const unordered_map&amp;);
    unordered_map(unordered_map&amp;&amp;);
    explicit unordered_map(const Allocator&amp;);
    unordered_map(const unordered_map&amp;, const Allocator&amp;);
    unordered_map(unordered_map&amp;&amp;, const Allocator&amp;);
    unordered_map(initializer_list&lt;value_type&gt;,
                  size_type {{=}} see below,
                  const hasher&amp; hf {{=}} hasher(),
                  const key_equal&amp; eql {{=}} key_equal(),
                  const allocator_type&amp; a {{=}} allocator_type());
    ~unordered_map();
    unordered_map&amp; operator{{=}}(const unordered_map&amp;);
    unordered_map&amp; operator{{=}}(unordered_map&amp;&amp;);
    unordered_map&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    // size and capacity
    bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    
    // iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    
    // modifiers
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    pair&lt;iterator, bool&gt; insert(const value_type&amp; obj);
    template &lt;class P&gt; pair&lt;iterator, bool&gt; insert(P&amp;&amp; obj);
    iterator insert(const_iterator hint, const value_type&amp; obj);
    template &lt;class P&gt; iterator insert(const_iterator hint, P&amp;&amp; obj);
    template &lt;class InputIterator&gt; void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    
    void swap(unordered_map&amp;);
    
    
    // observers
    hasher hash_function() const;
    key_equal key_eq() const;
    
    // lookup
    iterator find(const key_type&amp; k);
    const_iterator find(const key_type&amp; k) const;
    size_type count(const key_type&amp; k) const;
    std::pair&lt;iterator, iterator&gt;
    equal_range(const key_type&amp; k);
    std::pair&lt;const_iterator, const_iterator&gt; equal_range(const key_type&amp; k) const;
    mapped_type&amp; operator[](const key_type&amp; k);
    mapped_type&amp; operator[](key_type&amp;&amp; k);
    mapped_type&amp; at(const key_type&amp; k);
    const mapped_type&amp; at(const key_type&amp; k) const;
    
    // bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type&amp; k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    // hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};

}}

====Class {{lc|std::unordered_multimap}}====
{{source|

template &lt;class Key,
class T,
class Hash {{=}} hash&lt;Key&gt;,
class Pred {{=}} std::equal_to&lt;Key&gt;,
class Allocator {{=}} std::allocator&lt;std::pair&lt;const Key, T&gt; &gt; &gt;
class unordered_multimap
{
public:
    // types
    typedef Key                                         key_type;
    typedef Key                                         value_type;
    typedef Hash                                        hasher;
    typedef Pred                                        key_equal;
    typedef Allocator                                   allocator_type;
    typedef typename allocator_type::pointer            pointer;
    typedef typename allocator_type::const_pointer      const_pointer;
    typedef typename allocator_type::reference          reference;
    typedef typename allocator_type::const_reference    const_reference;
    typedef /*implementation-defined*/                  size_type;
    typedef /*implementation-defined*/                  difference_type;
    typedef /*implementation-defined*/                  iterator;
    typedef /*implementation-defined*/                  const_iterator;
    typedef /*implementation-defined*/                  local_iterator;
    typedef /*implementation-defined*/                  const_local_iterator;
    
    // construct/destroy/copy
    explicit unordered_multimap(size_type n {{=}} see below,
                                const hasher&amp; hf {{=}} hasher(),
                                const key_equal&amp; eql {{=}} key_equal(),
                                const allocator_type&amp; a {{=}} allocator_type());
    template &lt;class InputIterator&gt;
    unordered_multimap(InputIterator f, InputIterator l,
                       size_type n {{=}} see below,
                       const hasher&amp; hf {{=}} hasher(),
                       const key_equal&amp; eql {{=}} key_equal(),
                       const allocator_type&amp; a {{=}} allocator_type());
    unordered_multimap(const unordered_multimap&amp;);
    unordered_multimap(unordered_multimap&amp;&amp;);
    explicit unordered_multimap(const Allocator&amp;);
    unordered_multimap(const unordered_multimap&amp;, const Allocator&amp;);
    unordered_multimap(unordered_multimap&amp;&amp;, const Allocator&amp;);
    unordered_multimap(initializer_list&lt;value_type&gt;,
                       size_type {{=}} see below,
                       const hasher&amp; hf {{=}} hasher(),
                       const key_equal&amp; eql {{=}} key_equal(),
                       const allocator_type&amp; a {{=}} allocator_type());
    ~unordered_multimap();
    unordered_multimap&amp; operator{{=}}(const unordered_multimap&amp;);
    unordered_multimap&amp; operator{{=}}(unordered_multimap&amp;&amp;);
    unordered_multimap&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    
    // size and capacity
    bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    
    // iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    
    // modifiers
    template &lt;class... Args&gt; iterator emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    iterator insert(const value_type&amp; obj);
    template &lt;class P&gt; iterator insert(P&amp;&amp; obj);
    iterator insert(const_iterator hint, const value_type&amp; obj);
    template &lt;class P&gt; iterator insert(const_iterator hint, P&amp;&amp; obj);
    template &lt;class InputIterator&gt; void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    
    void swap(unordered_multimap&amp;);
    
    
    
    // observers
    hasher hash_function() const;
    key_equal key_eq() const;
    
    // lookup
    iterator find(const key_type&amp; k);
    const_iterator find(const key_type&amp; k) const;
    size_type count(const key_type&amp; k) const;
    std::pair&lt;iterator, iterator&gt;
    equal_range(const key_type&amp; k);
    std::pair&lt;const_iterator, const_iterator&gt; equal_range(const key_type&amp; k) const;
    
    // bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type&amp; k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    // hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/unordered set</title>
    <ns>0</ns>
    <id>9796</id>
    <revision>
      <id>57548</id>
      <parentid>49599</parentid>
      <timestamp>2013-06-01T05:55:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="12464">{{cpp/header/title|unordered_set}}
{{cpp/header/navbar}}

This header is part of the [[cpp/container|containers]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc | {{header|initializer_list}} {{mark c++11}} }}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc unordered_set}}
{{dsc inc | cpp/container/dsc unordered_multiset}}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_set}}
{{dsc inc | cpp/container/dsc swap2 | unordered_set}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multiset}}
{{dsc inc | cpp/container/dsc swap2 | unordered_multiset}}
{{dsc end}}

===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    // class template unordered_set:
    template &lt;class Key,
            class Hash {{=}} hash&lt;Key&gt;,
            class Pred {{=}} std::equal_to&lt;Key&gt;,
            class Alloc {{=}} std::allocator&lt;Key&gt; &gt;
        class unordered_set;
        
    // class template unordered_multiset:
    template &lt;class Key,
            class Hash {{=}} hash&lt;Key&gt;,
            class Pred {{=}} std::equal_to&lt;Key&gt;,
            class Alloc {{=}} std::allocator&lt;Key&gt; &gt;
        class unordered_multiset;
        
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        void swap(unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; x,
                unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; y);
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        void swap(unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; x,
                unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; y);
        
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        bool operator{{=}}{{=}}(const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        bool operator!{{=}}(const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_set&lt;Key, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        bool operator{{=}}{{=}}(const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; b);
    template &lt;class Key, class Hash, class Pred, class Alloc&gt;
        bool operator!{{=}}(const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; a,
                        const unordered_multiset&lt;Key, Hash, Pred, Alloc&gt;&amp; b);
} // namespace std

}}


====Class {{lc|std::unordered_set}}====
{{source|

template &lt;class Key,
    class Hash {{=}} hash&lt;Key&gt;,
    class Pred {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt; &gt;
class unordered_set
{
public:
    // types
    typedef Key                                         key_type;
    typedef Key                                         value_type;
    typedef Hash                                        hasher;
    typedef Pred                                        key_equal;
    typedef Allocator                                   allocator_type;
    typedef typename allocator_type::pointer            pointer;
    typedef typename allocator_type::const_pointer      const_pointer;
    typedef typename allocator_type::reference          reference;
    typedef typename allocator_type::const_reference    const_reference;
    typedef /*implementation-defined*/                  size_type;
    typedef /*implementation-defined*/                  difference_type;
    
    typedef /*implementation-defined*/                  iterator;
    typedef /*implementation-defined*/                  const_iterator;
    typedef /*implementation-defined*/                  local_iterator;
    typedef /*implementation-defined*/                  const_local_iterator;
    
    // construct/destroy/copy
    explicit unordered_set(size_type n {{=}} implementation-defined,
                           const hasher&amp; hf {{=}} hasher(),
                           const key_equal&amp; eql {{=}} key_equal(),
                           const allocator_type&amp; a {{=}} allocator_type());
    template &lt;class InputIterator&gt;
    unordered_set(InputIterator f, InputIterator l,
                  size_type n {{=}} see below,
                  const hasher&amp; hf {{=}} hasher(),
                  const key_equal&amp; eql {{=}} key_equal(),
                  const allocator_type&amp; a {{=}} allocator_type());
    unordered_set(const unordered_set&amp;);
    unordered_set(unordered_set&amp;&amp;);
    explicit unordered_set(const Allocator&amp;);
    unordered_set(const unordered_set&amp;, const Allocator&amp;);
    unordered_set(unordered_set&amp;&amp;, const Allocator&amp;);
    unordered_set(initializer_list&lt;value_type&gt;,
                  size_type {{=}} see below,
                  const hasher&amp; hf {{=}} hasher(),
                  const key_equal&amp; eql {{=}} key_equal(),
                  const allocator_type&amp; a {{=}} allocator_type());
    ~unordered_set();
    unordered_set&amp; operator{{=}}(const unordered_set&amp;);
    unordered_set&amp; operator{{=}}(unordered_set&amp;&amp;);
    unordered_set&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    // size and capacity
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    
    // iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    
    // modifiers
    template &lt;class... Args&gt; pair&lt;iterator, bool&gt; emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    pair&lt;iterator, bool&gt; insert(const value_type&amp; obj);
    pair&lt;iterator, bool&gt; insert(value_type&amp;&amp; obj);
    iterator insert(const_iterator hint, const value_type&amp; obj);
    iterator insert(const_iterator hint, value_type&amp;&amp; obj);
    template &lt;class InputIterator&gt; void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    
    void swap(unordered_set&amp;);
    
    // observers
    hasher hash_function() const;
    key_equal key_eq() const;
    
    // lookup
    iterator       find(const key_type&amp; k);
    const_iterator find(const key_type&amp; k) const;
    size_type count(const key_type&amp; k) const;
    std::pair&lt;iterator, iterator&gt; equal_range(const key_type&amp; k);
    std::pair&lt;const_iterator, const_iterator&gt; equal_range(const key_type&amp; k) const;
    
    // bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type&amp; k) const;
    local_iterator begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    
    // hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};

}}


====Class {{lc|std::unordered_multiset}}====
{{source|

template &lt;class Key,
    class Hash {{=}} hash&lt;Key&gt;,
    class Pred {{=}} std::equal_to&lt;Key&gt;,
    class Allocator {{=}} std::allocator&lt;Key&gt; &gt;
class unordered_multiset
{
public:
    // types
    typedef Key                                         key_type;
    typedef Key                                         value_type;
    typedef Hash                                        hasher;
    typedef Pred                                        key_equal;
    typedef Allocator                                   allocator_type;
    typedef typename allocator_type::pointer            pointer;
    typedef typename allocator_type::const_pointer      const_pointer;
    typedef typename allocator_type::reference          reference;
    typedef typename allocator_type::const_reference    const_reference;
    typedef /*implementation-defined*/                  size_type;
    typedef /*implementation-defined*/                  difference_type;
    typedef /*implementation-defined*/                  iterator;
    typedef /*implementation-defined*/                  const_iterator;
    typedef /*implementation-defined*/                  local_iterator;
    typedef /*implementation-defined*/                  const_local_iterator;
    
    // construct/destroy/copy
    explicit unordered_multiset(size_type n {{=}} /*implementation-defined*/,
                                const hasher&amp; hf {{=}} hasher(),
                                const key_equal&amp; eql {{=}} key_equal(),
                                const allocator_type&amp; a {{=}} allocator_type());
    template &lt;class InputIterator&gt;
    unordered_multiset(InputIterator f, InputIterator l,
                       size_type n {{=}} see below,
                       const hasher&amp; hf {{=}} hasher(),
                       const key_equal&amp; eql {{=}} key_equal(),
                       const allocator_type&amp; a {{=}} allocator_type());
    unordered_multiset(const unordered_multiset&amp;);
    unordered_multiset(unordered_multiset&amp;&amp;);
    explicit unordered_multiset(const Allocator&amp;);
    unordered_multiset(const unordered_multiset&amp;, const Allocator&amp;);
    unordered_multiset(unordered_multiset&amp;&amp;, const Allocator&amp;);
    unordered_multiset(initializer_list&lt;value_type&gt;,
                       size_type {{=}} see below,
                       const hasher&amp; hf {{=}} hasher(),
                       const key_equal&amp; eql {{=}} key_equal(),
                       const allocator_type&amp; a {{=}} allocator_type());
    ~unordered_multiset();
    unordered_multiset&amp; operator{{=}}(const unordered_multiset&amp;);
    unordered_multiset operator{{=}}(unordered_multiset&amp;&amp;);
    unordered_multiset&amp; operator{{=}}(initializer_list&lt;value_type&gt;);
    allocator_type get_allocator() const noexcept;
    
    // size and capacity
    bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    
    // iterators
    iterator       begin() noexcept;
    const_iterator begin() const noexcept;
    iterator       end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    
    // modifiers
    template &lt;class... Args&gt; iterator emplace(Args&amp;&amp;... args);
    template &lt;class... Args&gt; iterator emplace_hint(const_iterator position, Args&amp;&amp;... args);
    iterator insert(const value_type&amp; obj);
    iterator insert(value_type&amp;&amp; obj);
    iterator insert(const_iterator hint, const value_type&amp; obj);
    iterator insert(const_iterator hint, value_type&amp;&amp; obj);
    template &lt;class InputIterator&gt; void insert(InputIterator first, InputIterator last);
    void insert(initializer_list&lt;value_type&gt;);
    
    iterator erase(const_iterator position);
    size_type erase(const key_type&amp; k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    
    void swap(unordered_multiset&amp;);
    
    // observers
    hasher hash_function() const;
    key_equal key_eq() const;
    
    // lookup
    iterator        find(const key_type&amp; k);
    const_iterator  find(const key_type&amp; k) const;
    size_type count(const key_type&amp; k) const;
    std::pair&lt;iterator, iterator&gt;             equal_range(const key_type&amp; k);
    std::pair&lt;const_iterator, const_iterator&gt; equal_range(const key_type&amp; k) const;
    
    // bucket interface
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type&amp; k) const;
    local_iterator       begin(size_type n);
    const_local_iterator begin(size_type n) const;
    local_iterator       end(size_type n);
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    
    // hash policy
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};


}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/utility</title>
    <ns>0</ns>
    <id>9671</id>
    <revision>
      <id>70330</id>
      <parentid>57551</parentid>
      <timestamp>2014-05-19T19:05:27Z</timestamp>
      <contributor>
        <ip>203.166.248.223</ip>
      </contributor>
      <comment>Added mention of std::integer_sequence</comment>
      <text xml:space="preserve" bytes="5405">{{cpp/header/title|utility}}
{{cpp/header/navbar}}

This header is part of the [[cpp/utility|general utility]] library.

{{dsc begin}}
{{dsc h1|Includes}}
{{dsc| {{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Namespaces}}
{{dsc | {{ttb|[[cpp/utility/rel_ops/operator_cmp|rel_ops]]}} | Provide automatic comparison operators }}
{{dsc namespace | std::rel_ops }}
{{dsc inc | cpp/utility/rel_ops/dsc operator_cmp}}
{{dsc h1|Functions}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/utility/dsc forward}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc inc | cpp/utility/dsc declval}}
{{dsc inc | cpp/utility/pair/dsc make_pair}}
{{dsc inc | cpp/utility/pair/dsc operator_cmp}}
{{dsc inc | cpp/utility/pair/dsc swap2}}
{{dsc inc | cpp/utility/pair/dsc get}}
{{dsc h1|Classes}}
{{dsc inc | cpp/utility/dsc pair}}
{{dsc inc | cpp/utility/dsc piecewise_construct_t}}
{{dsc inc | cpp/utility/dsc integer_sequence}}
{{dsc h2|Forward declarations}}
{{dsc inc | cpp/utility/dsc tuple}}
{{dsc h2|Objects}}
{{dsc inc | cpp/utility/dsc piecewise_construct}}
{{dsc end}}



===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    // operators:
    namespace rel_ops {
        template&lt;class T&gt; bool operator!{{=}}(const T&amp;, const T&amp;);
        template&lt;class T&gt; bool operator&gt; (const T&amp;, const T&amp;);
        template&lt;class T&gt; bool operator&lt;{{=}}(const T&amp;, const T&amp;);
        template&lt;class T&gt; bool operator&gt;{{=}}(const T&amp;, const T&amp;);
    }

    // swap:
    template&lt;class T&gt; void swap(T&amp; a, T&amp; b) noexcept(noexcept(a.swap(b));
    template &lt;class T, size_t N&gt; 
        void swap(T (&amp;a)[N], T (&amp;b)[N]) noexcept(noexcept(swap(*a, *b)));

    // forward/move:
    template &lt;class T&gt; T&amp;&amp; forward(typename remove_reference&lt;T&gt;::type&amp; t) noexcept;
    template &lt;class T&gt; T&amp;&amp; forward(typename remove_reference&lt;T&gt;::type&amp;&amp; t) noexcept;
    template &lt;class T&gt; typename remove_reference&lt;T&gt;::type&amp;&amp; move(T&amp;&amp;) noexcept;
    template &lt;class T&gt; typename conditional&lt;
        !is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; is_copy_constructible&lt;T&gt;::value,
        const T&amp;, T&amp;&amp;&gt;::type move_if_noexcept(T&amp; x) noexcept;

    // declval, as unevaluated operand:
    template &lt;class T&gt;
        typename add_rvalue_reference&lt;T&gt;::type declval() noexcept; 
 
    // pairs:
    template &lt;class T1, class T2&gt; struct pair;

    // pair specialized algorithms:
    template &lt;class T1, class T2&gt;
        bool operator{{{{=}}{{=}}}}(const pair&lt;T1,T2&gt;&amp;, const
    template &lt;class T1, class T2&gt;
        bool operator&lt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
    template &lt;class T1, class T2&gt;
        bool operator!{{=}}(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
    template &lt;class T1, class T2&gt;
        bool operator&gt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
    template &lt;class T1, class T2&gt;
        bool operator&gt;{{=}}(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
    template &lt;class T1, class T2&gt;
        bool operator&lt;{{=}}(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
    template &lt;class T1, class T2&gt;
        void swap(pair&lt;T1,T2&gt;&amp; x, pair&lt;T1,T2&gt;&amp; y) noexcept(noexcept(x.swap(y)));
    template &lt;class T1, class T2&gt;
        pair&lt;V1,V2&gt; make_pair(T1&amp;&amp;, T2&amp;&amp;);

    //tuple-like access to pair:
    template &lt;class T&gt; class tuple_size;
    template &lt;size_t I, class T&gt; class tuple_element;
    
    template &lt;class T1, class T2&gt; struct tuple_size&lt;std::pair&lt;T1, T2&gt; &gt;;
    template &lt;class T1, class T2&gt; struct tuple_element&lt;0, std::pair&lt;T1, T2&gt; &gt;;
    template &lt;class T1, class T2&gt; struct tuple_element&lt;1, std::pair&lt;T1, T2&gt; &gt;;
    
    template&lt;size_t I, class T1, class T2&gt;
        typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp; 
        get(std::pair&lt;T1, T2&gt;&amp;) noexcept;
    template&lt;size_t I, class T1, class T2&gt;
        typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp;&amp; 
        get(std::pair&lt;T1, T2&gt;&amp;&amp;) noexcept;
    template&lt;size_t I, class T1, class T2&gt;
        const typename tuple_element&lt;I, std::pair&lt;T1, T2&gt; &gt;::type&amp;
            get(const std::pair&lt;T1, T2&gt;&amp;) noexcept;
            
    // pair piecewise construction
    struct piecewise_construct_t { };
    constexpr piecewise_construct_t piecewise_construct {{=}} piecewise_construct_t();

    template &lt;class... Types&gt; class tuple; // defined in &lt;tuple&gt;
}


}}

====Class {{lc|std::pair}}====
{{source|

template &lt;class T1, class T2&gt;
struct pair {
    typedef T1 first_type;
    typedef T2 second_type;
    
    T1 first;
    T2 second;
    pair(const pair&amp;) {{=}} default;
    pair(pair&amp;&amp;) {{=}} default;

    constexpr pair();
    pair(const T1&amp; x, const T2&amp; y);
    template&lt;class U, class V&gt; pair(U&amp;&amp; x, V&amp;&amp; y);
    template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt;&amp; p);
    template&lt;class U, class V&gt; pair(pair&lt;U, V&gt;&amp;&amp; p);
    template &lt;class... Args1, class... Args2&gt;
        pair(piecewise_construct_t,
             tuple&lt;Args1...&gt; first_args, tuple&lt;Args2...&gt; second_args);
        
    pair&amp; operator{{=}}(const pair&amp; p);
    template&lt;class U, class V&gt; pair&amp; operator{{=}}(const pair&lt;U, V&gt;&amp; p);
    pair&amp; operator{{=}}(pair&amp;&amp; p) noexcept(see below);
    template&lt;class U, class V&gt; pair&amp; operator{{=}}(pair&lt;U, V&gt;&amp;&amp; p);
    
    void swap(pair&amp; p) noexcept( noexcept(swap(first, p.first)) &amp;&amp;
                                 noexcept(swap(second, p.second)) );
};

}}

===See also===
{{dsc begin}}
{{dsc| {{header|tuple}} | Defines {{lc|std::tuple}} }}
{{dsc| [[cpp/utility|Utility library]] }}
{{dsc end}}</text>
      <sha1>d6ndzmk48kuye1ftz88zyhcobs5yaic</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/valarray</title>
    <ns>0</ns>
    <id>9802</id>
    <revision>
      <id>57552</id>
      <parentid>49601</parentid>
      <timestamp>2013-06-01T05:55:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="8477">{{cpp/header/title|valarray}}
{{cpp/header/navbar}}

This header is part of the [[cpp/numeric|numeric]] library.

===Classes===
{{dsc begin}}
{{dsc tclass | cpp/numeric/valarray | numeric arrays and array slices }}
{{dsc inc | cpp/numeric/valarray/dsc slice}}
{{dsc inc | cpp/numeric/valarray/dsc slice_array}}
{{dsc inc | cpp/numeric/valarray/dsc gslice}}
{{dsc inc | cpp/numeric/valarray/dsc gslice_array}}
{{dsc inc | cpp/numeric/valarray/dsc mask_array}}
{{dsc inc | cpp/numeric/valarray/dsc indirect_array}}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc h2 | Operations}}
{{dsc inc | cpp/numeric/valarray/dsc swap2}}
{{dsc inc | cpp/numeric/valarray/dsc begin2}}
{{dsc inc | cpp/numeric/valarray/dsc end2}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith3}}
{{dsc inc | cpp/numeric/valarray/dsc operator_cmp}}
{{dsc inc | cpp/numeric/valarray/dsc abs}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/valarray/dsc exp}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc inc | cpp/numeric/valarray/dsc log10}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/valarray/dsc pow}}
{{dsc inc | cpp/numeric/valarray/dsc sqrt}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc end}}



===Synopsis===
{{source|

#include &lt;initializer_list&gt;

namespace std {
    template&lt;class T&gt; class valarray;       // An array of type T
    class slice;                            // a BLAS-like slice out of an array
    template&lt;class T&gt; class slice_array;   
    class gslice;                           // a generalized slice out of an array
    template&lt;class T&gt; class gslice_array;
    template&lt;class T&gt; class mask_array;     // a masked array
    template&lt;class T&gt; class indirect_array; // an indirected array
    
    template&lt;class T&gt; void swap(valarray&lt;T&gt;&amp;, valarray&lt;T&gt;&amp;) noexcept;
    
    template&lt;class T&gt; valarray&lt;T&gt; operator* (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator* (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator* (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator/ (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator/ (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator/ (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator% (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator% (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator% (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator+ (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator+ (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator+ (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator- (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator- (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator- (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator^ (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator^ (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator^ (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator{{!}} (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator{{!}} (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator{{!}} (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;bool&gt; operator{{!}}{{!}}(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator{{!}}{{!}}(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator{{!}}{{!}}(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator{{=}}{{=}}(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator{{=}}{{=}}(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator{{=}}{{=}}(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator!{{=}}(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator!{{=}}(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator!{{=}}(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator&lt;{{=}}(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;{{=}}(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;{{=}}(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;
    valarray&lt;bool&gt; operator&gt;{{=}}(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;{{=}}(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;{{=}}(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class  T&gt;  valarray&lt;T&gt; abs (const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; acos(const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; asin(const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; atan(const  valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; atan2(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; atan2(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; atan2(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class  T&gt;  valarray&lt;T&gt; cos  (const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; cosh (const valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; exp  (const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; log  (const  valarray&lt;T&gt;&amp;);
    template&lt;class  T&gt;  valarray&lt;T&gt; log10(const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const T&amp;);
    template&lt;class T&gt; valarray&lt;T&gt; pow(const T&amp;, const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;  valarray&lt;T&gt; sin (const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt;  valarray&lt;T&gt; sinh(const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt;  valarray&lt;T&gt; sqrt(const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt;  valarray&lt;T&gt; tan (const valarray&lt;T&gt;&amp;);
    template&lt;class T&gt;  valarray&lt;T&gt; tanh(const valarray&lt;T&gt;&amp;);
    
    template&lt;class T&gt;  /*unspecified1*/ begin(valarray&lt;T&gt;&amp; v);
    template&lt;class T&gt;  /*unspecified2*/ begin(const valarray&lt;T&gt;&amp; v);
    template&lt;class T&gt;  /*unspecified1*/ end(valarray&lt;T&gt;&amp; v);
    template&lt;class T&gt;  /*unspecified2*/ end(const valarray&lt;T&gt;&amp; v);
    
    
}

}}

{{todo|Class synopses}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/header/vector</title>
    <ns>0</ns>
    <id>9675</id>
    <revision>
      <id>57555</id>
      <parentid>49602</parentid>
      <timestamp>2013-06-01T05:55:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="10777">{{cpp/header/title|vector}}
{{cpp/header/navbar}}
This header is part of the [[cpp/container|containers]] library.
{{dsc begin}}
{{dsc h1|Includes}}
{{dsc|{{header|initializer_list}}{{mark c++11}}}}
{{dsc h1|Classes}}
{{dsc inc | cpp/container/dsc vector}}
{{dsc inc | cpp/container/dsc vector_bool}}
{{dsc ptclass | cpp/container/vector bool/hash | title=std::hash{{dsc small|&lt;std::vector&lt;bool&gt;&gt;}} | hash support for {{c|std::vector&lt;bool&gt;}} | notes={{mark c++11}} }}
{{dsc h1|Functions}}
{{dsc inc | cpp/container/dsc operator_cmp | vector}}
{{dsc inc | cpp/container/dsc swap2 | vector}}
{{dsc end}}

===Synopsis===

{{source|

#include &lt;initializer_list&gt;
namespace std {
    template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt; class vector;
    
    template &lt;class T, class Allocator&gt;
        bool operator{{=}}{{=}}(const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator!{{=}}(const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&gt;{{=}}(const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
    template &lt;class T, class Allocator&gt;
        bool operator&lt;{{=}}(const vector&lt;T,Allocator&gt;&amp; x,const vector&lt;T,Allocator&gt;&amp; y);
        
    template &lt;class T, class Allocator&gt;
        void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);

    template &lt;class Allocator&gt; class vector&lt;bool,Allocator&gt;;
    
    // hash support
    template &lt;class T&gt; struct hash;
    template &lt;class Allocator&gt; struct hash&lt;vector&lt;bool, Allocator&gt; &gt;;
}

}}

====Class {{lc|std::vector}}====
{{source|


template &lt;class T, class Allocator {{=}} allocator&lt;T&gt; &gt;
class vector {
public:
    // types:
    typedef value_type&amp;                                         reference;
    typedef const value_type&amp;                                   const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef T                                                   value_type;
    typedef Allocator                                           allocator_type;
    typedef typename allocator_traits&lt;Allocator&gt;::pointer       pointer;
    typedef typename allocator_traits&lt;Allocator&gt;::const_pointer const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    // construct/copy/destroy:
    explicit vector(const Allocator&amp; {{=}} Allocator());
    explicit vector(size_type n);
    vector(size_type n, const T&amp; value,const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        vector(InputIterator first, InputIterator last,const Allocator&amp; {{=}} Allocator());
    vector(const vector&lt;T,Allocator&gt;&amp; x);
    vector(vector&amp;&amp;);
    vector(const vector&amp;, const Allocator&amp;);
    vector(vector&amp;&amp;, const Allocator&amp;);
    vector(initializer_list&lt;T&gt;, const Allocator&amp; {{=}} Allocator());
    
    ~vector();
    vector&lt;T,Allocator&gt;&amp; operator{{=}}(const vector&lt;T,Allocator&gt;&amp; x);
    vector&lt;T,Allocator&gt;&amp; operator{{=}}(vector&lt;T,Allocator&gt;&amp;&amp; x);
    vector&amp; operator{{=}}(initializer_list&lt;T&gt;);
    template &lt;class InputIterator&gt;
        void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const T&amp; t);
    void assign(initializer_list&lt;T&gt;);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const T&amp; c);
    size_type capacity() const noexcept;
    bool      empty() const noexcept;
    void      reserve(size_type n);
    void      shrink_to_fit();
    
    // element access:
    reference       operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference       at(size_type n);
    const_reference at(size_type n) const;
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;
    
    //data access
    T*       data() noexcept;
    const T* data() noexcept;
    
    // modifiers:
    template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
    void push_back(const T&amp; x);
    void push_back(T&amp;&amp; x);
    void pop_back();
    
    template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
    iterator insert(const_iterator position, const T&amp; x);
    iterator insert(const_iterator position, T&amp;&amp; x);
    iterator insert(const_iterator position, size_type n, const T&amp; x);
    template &lt;class InputIterator&gt;
        iterator insert (const_iterator position, InputIterator first, 
                         InputIterator last);
    iterator insert(const_iterator position, initializer_list&lt;T&gt;);

    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(vector&lt;T,Allocator&gt;&amp;);
    void     clear() noexcept;
};

}}

====Specialization {{c|std::vector&lt;bool&gt;}}====
{{source|


template &lt;class bool, class Allocator {{=}} allocator&lt;bool&gt; &gt;
class vector {
public:
    // types:
    typedef bool                                                const_reference;
    typedef /*implementation-defined*/                          iterator;
    typedef /*implementation-defined*/                          const_iterator; 
    typedef /*implementation-defined*/                          size_type;
    typedef /*implementation-defined*/                          difference_type;
    typedef bool                                                value_type;
    typedef Allocator                                           allocator_type;
    typedef /*implementation-defined*/                          pointer;
    typedef /*implementation-defined*/                          const_pointer;
    typedef std::reverse_iterator&lt;iterator&gt;                     reverse_iterator;
    typedef std::reverse_iterator&lt;const_iterator&gt;               const_reverse_iterator;
    
    // bit reference:
    class reference {
        friend class vector;
        reference() noexcept;
    public:
        ~reference();
        operator bool() const noexcept;
        reference&amp; operator{{=}}(const bool x) noexcept;
        reference&amp; operator{{=}}(const reference&amp; x) noexcept;
        void flip() noexcept; // flips the bit
    };

    // construct/copy/destroy:
    explicit vector(const Allocator&amp; {{=}} Allocator());
    explicit vector(size_type n);
    vector(size_type n, const bool&amp; value,const Allocator&amp; {{=}} Allocator());
    template &lt;class InputIterator&gt;
        vector(InputIterator first, InputIterator last,const Allocator&amp; {{=}} Allocator());
    vector(const vector&lt;bool,Allocator&gt;&amp; x);
    vector(vector&amp;&amp;);
    vector(const vector&amp;, const Allocator&amp;);
    vector(vector&amp;&amp;, const Allocator&amp;);
    vector(initializer_list&lt;bool&gt;, const Allocator&amp; {{=}} Allocator());
    
    ~vector();
    vector&lt;bool,Allocator&gt;&amp; operator{{=}}(const vector&lt;bool,Allocator&gt;&amp; x);
    vector&lt;bool,Allocator&gt;&amp; operator{{=}}(vector&lt;bool,Allocator&gt;&amp;&amp; x);
    vector&amp; operator{{=}}(initializer_list&lt;bool&gt;);
    template &lt;class InputIterator&gt;
        void assign(InputIterator first, InputIterator last);
    void assign(size_type n, const bool&amp; t);
    void assign(initializer_list&lt;bool&gt;);
    allocator_type get_allocator() const noexcept;

    // iterators:
    iterator                begin() noexcept;
    const_iterator          begin() const noexcept;
    iterator                end() noexcept;
    const_iterator          end() const noexcept;
    
    reverse_iterator        rbegin() noexcept;
    const_reverse_iterator  rbegin() const noexcept;
    reverse_iterator        rend() noexcept;
    const_reverse_iterator  rend() const noexcept;
    
    const_iterator          cbegin() noexcept;
    const_iterator          cend() noexcept;
    const_reverse_iterator  crbegin() const noexcept;
    const_reverse_iterator  crend() const noexcept;
    
    // capacity:
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void      resize(size_type sz);
    void      resize(size_type sz, const bool&amp; c);
    size_type capacity() const noexcept;
    bool      empty() const noexcept;
    void      reserve(size_type n);
    void      shrink_to_fit();
    
    // element access:
    reference       operator[](size_type n);
    const_reference operator[](size_type n) const;
    reference       at(size_type n);
    const_reference at(size_type n) const;
    reference       front();
    const_reference front() const;
    reference       back();
    const_reference back() const;
    
    //data access
    bool*       data() noexcept;
    const bool* data() noexcept;
    
    // modifiers:
    template &lt;class... Args&gt; void emplace_back(Args&amp;&amp;... args);
    void push_back(const bool&amp; x);
    void push_back(bool&amp;&amp; x);
    void pop_back();
    
    template &lt;class... Args&gt; iterator emplace(const_iterator position, Args&amp;&amp;... args);
    iterator insert(const_iterator position, const bool&amp; x);
    iterator insert(const_iterator position, bool&amp;&amp; x);
    iterator insert(const_iterator position, size_type n, const bool&amp; x);
    template &lt;class InputIterator&gt;
        iterator insert (const_iterator position, InputIterator first, 
                         InputIterator last);
    iterator insert(const_iterator position, initializer_list&lt;bool&gt;);

    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void     swap(vector&lt;bool,Allocator&gt;&amp;);
    void     flip() noexcept;// flips all bits
    void     clear() noexcept;
};

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/headers</title>
    <ns>0</ns>
    <id>5419</id>
    <redirect title="cpp/header" />
    <revision>
      <id>19611</id>
      <timestamp>2012-03-11T12:25:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/headers]] to [[cpp/header]]: We use singular mostly</comment>
      <text xml:space="preserve" bytes="24">#REDIRECT [[cpp/header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io</title>
    <ns>0</ns>
    <id>476</id>
    <revision>
      <id>70830</id>
      <parentid>57558</parentid>
      <timestamp>2014-05-30T22:03:53Z</timestamp>
      <contributor>
        <username>FeelUs</username>
        <id>2194</id>
      </contributor>
      <minor/>
      <comment>replace zero to O</comment>
      <text xml:space="preserve" bytes="6636">{{title|Input/output library}}
{{cpp/io/navbar}}

C++ includes two input/output libraries: a modern, stream-based I/O library and the standard set of C-style I/O functions.

===Stream-based I/O===

The stream-based input/output library is organized around abstract input/output devices. These abstract devices allow the same code to handle input/output to files, memory streams, or custom adaptor devices that perform arbitrary operations (e.g. compression) on the fly.

Most of the classes are templated, so they can be adapted to any basic character type. Separate typedefs are provided for the most common basic character types ({{c|char}} and {{c|wchar_t}}).  The classes are organized into the following hierarchy:

{{inheritance diagram/std-io-complete}}

{{dsc begin}}
{{dsc h2 | Abstraction}}
{{dsc class | cpp/io/ios_base | manages formatting flags and input/output exceptions}}
{{dsc tclass | cpp/io/basic_ios | manages an arbitrary stream buffer}}
{{dsc tclass | cpp/io/basic_streambuf | abstracts a raw device}}
{{dsc tclass | cpp/io/basic_istream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input interface}}
{{dsc tclass | cpp/io/basic_ostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level output interface}}
{{dsc tclass | cpp/io/basic_iostream | wraps a given abstract device ({{lc|std::basic_streambuf}})&lt;br/&gt; and provides high-level input/output interface}}
{{dsc h2 | File I/O implementation}}
{{dsc tclass | cpp/io/basic_filebuf | implements raw file device}}
{{dsc tclass | cpp/io/basic_ifstream | implements high-level file stream input operations}}
{{dsc tclass | cpp/io/basic_ofstream | implements high-level file stream output operations}}
{{dsc tclass | cpp/io/basic_fstream | implements high-level file stream input/output operations}}
{{dsc h2 | String I/O implementation}}
{{dsc tclass | cpp/io/basic_stringbuf | implements raw string device}}
{{dsc tclass | cpp/io/basic_istringstream | implements high-level string stream input operations}}
{{dsc tclass | cpp/io/basic_ostringstream | implements high-level string stream output operations}}
{{dsc tclass | cpp/io/basic_stringstream | implements high-level string stream input/output operations}}
{{dsc h2 | Array I/O implementations}}
{{dsc class | cpp/io/strstreambuf | notes={{mark deprecated}} | implements raw character array device}}
{{dsc class | cpp/io/istrstream | notes={{mark deprecated}} | implements character array input operations}}
{{dsc class | cpp/io/ostrstream | notes={{mark deprecated}} | implements character array output operations}}
{{dsc class | cpp/io/strstream | notes={{mark deprecated}} | implements character array input/output operations}}
{{dsc end}}

====Typedefs====

The following typedefs for common character types are provided:

&lt;source lang=&quot;cpp&quot;&gt;
typedef basic_ios&lt;char&gt;                ios;
typedef basic_ios&lt;wchar_t&gt;            wios;

typedef basic_streambuf&lt;char&gt;     streambuf;
typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
typedef basic_filebuf&lt;char&gt;         filebuf;
typedef basic_filebuf&lt;wchar_t&gt;     wfilebuf;
typedef basic_stringbuf&lt;char&gt;     stringbuf;
typedef basic_stringbuf&lt;wchar_t&gt; wstringbuf;

typedef basic_istream&lt;char&gt;         istream;
typedef basic_istream&lt;wchar_t&gt;     wistream;
typedef basic_ostream&lt;char&gt;         ostream;
typedef basic_ostream&lt;wchar_t&gt;     wostream;
typedef basic_iostream&lt;char&gt;       iostream;
typedef basic_iostream&lt;wchar_t&gt;   wiostream;

typedef basic_ifstream&lt;char&gt;       ifstream;
typedef basic_ifstream&lt;wchar_t&gt;   wifstream;
typedef basic_ofstream&lt;char&gt;       ofstream;
typedef basic_ofstream&lt;wchar_t&gt;   wofstream;
typedef basic_fstream&lt;char&gt;         fstream;
typedef basic_fstream&lt;wchar_t&gt;     wfstream;

typedef basic_istringstream&lt;char&gt;     istringstream;
typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
typedef basic_ostringstream&lt;char&gt;     ostringstream;
typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
typedef basic_stringstream&lt;char&gt;       stringstream;
typedef basic_stringstream&lt;wchar_t&gt;   wstringstream;
&lt;/source&gt;

Predefined standard stream objects:
&lt;source lang=&quot;cpp&quot;&gt;
extern  istream  cin;   //standard input (stdin)
extern wistream wcin;
extern  ostream  cout;  //standard output (stdout)
extern wostream wcout;
extern  ostream  cerr;  //standard error (stderr)
extern wostream wcerr;
extern  ostream  clog;  //standard log (stdlog)
extern wostream wclog;
&lt;/source&gt;

====[[cpp/io/manip|I/O Manipulators]]====

The stream-based I/O library uses [[cpp/io/manip| I/O manipulators]] (e.g. {{lc|std::boolalpha}}, {{lc|std::hex}}, etc.) to control how streams behave.

====Types====

The following auxiliary types are defined:
{{dsc begin}}
{{dsc header | ios }}
{{dsc typedef | cpp/io/streamoff | represents relative file/stream position (offset from fpos), sufficient to represent any file size }}
{{dsc typedef | cpp/io/streamsize | represents the number of characters transferred in an I/O operation or the size of an I/O buffer}}
{{dsc tclass  | cpp/io/fpos | represents absolute position in a stream or a file}}
{{dsc end}}

Four specializations of {{lc|std::fpos}} are provided: 
{{dsc begin}}
{{dsc header | ios}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char&gt;::state_type&gt;}}}}
{{dsc | {{tt|u16streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char16_t&gt;::state_type&gt;}}}}
{{dsc | {{tt|u32streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char32_t&gt;::state_type&gt;}}}}
{{dsc | {{tt|wstreampos}} | {{c|std::fpos&lt;std::char_traits&lt;wchar_t&gt;::state_type&gt;}}}}
{{dsc end}}

====Error category interface====
{{dsc begin}}
{{dsc header | ios }}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc inc | cpp/io/dsc iostream_category}}
&lt;!-- TODO: these three specializations go inside the io_errc page 
{{dcl list ptfun | cpp/io/is_error_code_enum  | title=is_error_code_enum{{dsc small|(std::io_errc)}}| notes={{mark c++11}} | extends the type trait {{lc|std::is_error_code_enum}} to identify iostream error codes}}
{{dsc fun | cpp/io/make_error_code | title=make_error_code{{dsc small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error code}}
{{dsc fun | cpp/io/make_error_condition  | title=make_error_condition{{dsc small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error_condition}}
--&gt;
{{dsc end}}

===[[cpp/io/c | C-style IO]]===

C++ also includes the [[cpp/io/c | input/output functions defined by C]], such as {{lc|std::fopen}}, {{lc|std::getc}}, etc.

[[ar:cpp/io]]
[[de:cpp/io]]
[[es:cpp/io]]
[[fr:cpp/io]]
[[it:cpp/io]]
[[ja:cpp/io]]
[[pl:cpp/io]]
[[pt:cpp/io]]
[[ru:cpp/io]]
[[zh:cpp/io]]</text>
      <sha1>5fez9dkpqc3y02xe7ruzep3xij04n0o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf</title>
    <ns>0</ns>
    <id>485</id>
    <revision>
      <id>71817</id>
      <parentid>71796</parentid>
      <timestamp>2014-06-25T13:34:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>charT =&gt; CharT</comment>
      <text xml:space="preserve" bytes="2695">{{cpp/title|basic_filebuf}}
{{cpp/io/basic_filebuf/navbar}}

{{ddcl | header=fstream | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_filebuf : public std::basic_streambuf&lt;CharT, Traits&gt;
}}

{{tt|std::basic_filebuf}} is a {{lc|std::basic_streambuf}} whose associated character sequence is a file. Both the input sequence and the output sequence are associated with the same file, and a joint file position is maintained for both operations.

The functions underflow() and overflow()/sync() perform the actual I/O between the file and the get and put areas of the buffer. When {{tt|CharT}} is not {{c|char}}, most implementations store multibyte characters in the file and a {{lc|std::codecvt}} facet is used to perform wide/multibyte character conversion.

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | streambuf}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|filebuf}} | {{c|basic_filebuf&lt;char&gt;}}}}
{{dsc | {{tt|wfilebuf}} | {{c|basic_filebuf&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc | {{tt|pos_type}} | {{c|Traits::pos_type}} which is required to be {{c|std::fpos&lt;Traits::state_type&gt;}}}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h1 | Public member functions}}
{{dsc inc | cpp/io/basic_filebuf/dsc basic_filebuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap}}
{{dsc inc | cpp/io/basic_filebuf/dsc ~basic_filebuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc is_open}}
{{dsc inc | cpp/io/basic_filebuf/dsc open}}
{{dsc inc | cpp/io/basic_filebuf/dsc close}}
{{dsc h1 | Protected member functions}}
{{dsc inc | cpp/io/basic_filebuf/dsc showmanyc}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc uflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_filebuf/dsc sync}}
{{dsc inc | cpp/io/basic_filebuf/dsc imbue}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap2}}
{{dsc end}}

{{cpp/io/basic_streambuf/inherit}}

[[de:cpp/io/basic filebuf]]
[[es:cpp/io/basic filebuf]]
[[fr:cpp/io/basic filebuf]]
[[it:cpp/io/basic filebuf]]
[[ja:cpp/io/basic filebuf]]
[[pt:cpp/io/basic filebuf]]
[[ru:cpp/io/basic filebuf]]
[[zh:cpp/io/basic filebuf]]</text>
      <sha1>9iwpvd54jz8vjwu1xdb0g1saaidwwkk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/basic filebuf</title>
    <ns>0</ns>
    <id>5653</id>
    <revision>
      <id>64256</id>
      <parentid>64203</parentid>
      <timestamp>2013-08-15T16:05:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1928">{{cpp/io/basic_filebuf/title |basic_filebuf}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{dcl| num=1 |
basic_filebuf();
}}
{{dcl| num=2 | since=c++11 |1=
basic_filebuf( const std::basic_filebuf&amp; rhs ) = delete;
}}
{{dcl| num=3 | since=c++11 |
basic_filebuf( std::basic_filebuf&amp;&amp; rhs );
}}
{{dcl end}}

Contructs new {{tt|std::basic_filebuf}} object.

@1@ Constructs a {{tt|std::basic_filebuf}} object, initializing the base class by calling the default constructor of {{lc|std::basic_streambuf}}. The created {{tt|basic_filebuf}} is not associated with a file, and {{lc|is_open()}} returns {{c|false}}.

@2@ The copy constructor is deleted; {{tt|std::basic_filebuf}} is not {{concept|CopyConstructible}}

@3@ Move-constructs a {{tt|std::basic_filebuf}} object by moving all contents from another {{tt|std::basic_filebuf}} object {{tt|rhs}}, including the buffers, the associated file, the locale, the openmode, the is_open variable, and all other state. After move, {{tt|rhs}} is not associated with a file and {{c|1=rhs.is_open()==false}}. The member pointers of the base class {{lc|std::basic_streambuf}} of {{tt|rhs}} and of the base class of {{tt|*this}} are guaranteed to point to different buffers (unless null).

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|basic_filebuf}} }}
{{par end}}

===Notes===
Typically called by the constructor of {{lc|std::basic_fstream}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc ~basic_filebuf}}
{{dsc end}}

[[de:cpp/io/basic filebuf/basic filebuf]]
[[es:cpp/io/basic filebuf/basic filebuf]]
[[fr:cpp/io/basic filebuf/basic filebuf]]
[[it:cpp/io/basic filebuf/basic filebuf]]
[[ja:cpp/io/basic filebuf/basic filebuf]]
[[pt:cpp/io/basic filebuf/basic filebuf]]
[[ru:cpp/io/basic filebuf/basic filebuf]]
[[zh:cpp/io/basic filebuf/basic filebuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/close</title>
    <ns>0</ns>
    <id>5647</id>
    <revision>
      <id>64260</id>
      <parentid>57563</parentid>
      <timestamp>2013-08-15T16:08:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1923">{{cpp/io/basic_filebuf/title | close }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
std::basic_filebuf&lt;CharT, Traits&gt;* close();
}}

If a put area exist (e.g. file was opened for writing), first calls {{c|overflow(Traits::eof())}} to write all pending output to the file, including any unshift sequences.

If the most recently called function, out of {{lc|underflow()}}, {{lc|overflow()}}, {{lc|seekpos()}}, and {{lc|seekoff()}}, was {{lc|overflow()}}, then calls {{c|std::codecvt::unshift()}}, perhaps multiple times, to determine the unshift sequence according to the imbued locale, and writes that sequence to file with {{c|overflow(Traits::eof())}}.

Then, closes the file as if by calling {{lc|std::fclose()}}, regardless of whether any of the preceding calls succeeded or failed.

If any of the function calls made, including the call to {{lc|std::fclose()}}, fails, returns a null pointer.  If any of the function calls made throws an exception, the exception is caught and rethrown after calling {{lc|std::fclose()}}. If the file is already closed, returns a null pointer right away.

In any case, updates the private member variable that is accessed by {{lc|is_open()}}.

===Parameters===
(none)

===Return value===
{{c|*this}} on success, a null pointer on failure.

===Notes===
{{tt|close()}} is typically called through the destructor of {{lc|std::basic_filebuf}} (which, in turn, is typically called by the destructor of {{lc|std::basic_fstream}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc is_open}}
{{dsc inc | cpp/io/basic_filebuf/dsc ~basic_filebuf}}
{{dsc end}}

[[de:cpp/io/basic filebuf/close]]
[[es:cpp/io/basic filebuf/close]]
[[fr:cpp/io/basic filebuf/close]]
[[it:cpp/io/basic filebuf/close]]
[[ja:cpp/io/basic filebuf/close]]
[[pt:cpp/io/basic filebuf/close]]
[[ru:cpp/io/basic filebuf/close]]
[[zh:cpp/io/basic filebuf/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/imbue</title>
    <ns>0</ns>
    <id>5657</id>
    <revision>
      <id>57564</id>
      <parentid>49607</parentid>
      <timestamp>2013-06-01T05:56:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1105">{{cpp/io/basic_filebuf/title | imbue }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual void imbue( const std::locale&amp; loc )
}}

Changes the associated locale so that all characters inserted or extracted after this call (and until another call to {{tt|imbue()}}) are converted using the {{lc|std::codecvt}} facet of {{tt|loc}}.

If the old locale's encoding is state-dependent and file is not positioned at the beginning, then the new locale must have the same {{lc|std::codecvt}} facet as the one previously imbued.

===Parameters===
{{par begin}}
{{par | loc | the locale to imbue the stream with}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc imbue}}
{{dsc inc | cpp/io/basic_ios/dsc imbue}}
{{dsc end}}

[[de:cpp/io/basic filebuf/imbue]]
[[es:cpp/io/basic filebuf/imbue]]
[[fr:cpp/io/basic filebuf/imbue]]
[[it:cpp/io/basic filebuf/imbue]]
[[ja:cpp/io/basic filebuf/imbue]]
[[pt:cpp/io/basic filebuf/imbue]]
[[ru:cpp/io/basic filebuf/imbue]]
[[zh:cpp/io/basic filebuf/imbue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/is open</title>
    <ns>0</ns>
    <id>5648</id>
    <revision>
      <id>64259</id>
      <parentid>57567</parentid>
      <timestamp>2013-08-15T16:07:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1344">{{cpp/io/basic_filebuf/title |is_open}}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
bool is_open() const;
}}

Returns {{c|true}} if the most recent call to {{lc|open()}} succeeded and there has been no call to {{lc|close()}} since then.

===Parameters===
(none)

===Return value===
{{c|true}} if the associated file is open, {{c|false}} otherwise.

===Notes===
This function is typically called by {{lc|std::basic_fstream::is_open()}}.

===Example===
{{example
 |
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::ifstream fs(&quot;test.txt&quot;);
    std::filebuf fb;
    fb.open(&quot;test.txt&quot;, std::ios_base::in);
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;direct call: &quot; &lt;&lt; fb.is_open() &lt;&lt; '\n'
              &lt;&lt; &quot;through streambuf: &quot; &lt;&lt; fs.rdbuf()-&gt;is_open() &lt;&lt; '\n'
              &lt;&lt; &quot;through fstream: &quot; &lt;&lt; fs.is_open() &lt;&lt; '\n';
}
 | output=
direct call: true
through streambuf: true
through fstream: true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc open}}
{{dsc inc | cpp/io/basic_filebuf/dsc close}}
{{dsc end}}

[[de:cpp/io/basic filebuf/is open]]
[[es:cpp/io/basic filebuf/is open]]
[[fr:cpp/io/basic filebuf/is open]]
[[it:cpp/io/basic filebuf/is open]]
[[ja:cpp/io/basic filebuf/is open]]
[[pt:cpp/io/basic filebuf/is open]]
[[ru:cpp/io/basic filebuf/is open]]
[[zh:cpp/io/basic filebuf/is open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/open</title>
    <ns>0</ns>
    <id>5649</id>
    <revision>
      <id>67949</id>
      <parentid>64258</parentid>
      <timestamp>2014-03-07T21:07:09Z</timestamp>
      <contributor>
        <ip>156.56.177.162</ip>
      </contributor>
      <comment>Return value is a pointer, not a reference.</comment>
      <text xml:space="preserve" bytes="2526">{{cpp/io/basic_filebuf/title |open}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |
std::basic_filebuf&lt;CharT, Traits&gt;* open( const char* s, std::ios_base::openmode mode )
}}
{{dcl | num=2 | since=c++11 |
std::basic_filebuf&lt;CharT, Traits&gt;* open( const std::string&amp; str, std::ios_base::openmode mode ) 
}}
{{dcl end}}

Opens the file with the given name - either {{tt|s}} or {{c|str.c_str()}}.

The file is opened as if by calling {{c|std::fopen(s, modestring)}}, where {{tt|modestring}} is determined as follows:

{{dsc begin}}
{{dsc hitem | modestring | openmode &amp; ~ate }}
{{dsc | &quot;r&quot; | {{tt|in}} }}
{{dsc | &quot;w&quot; | {{tt|out}}, {{c|out{{!}}trunc}} }}
{{dsc | &quot;a&quot; | {{tt|app}}, {{c|out{{!}}app}} }}
{{dsc | &quot;r+&quot; | {{c|out{{!}}in}} }}
{{dsc | &quot;w+&quot; | {{c|out{{!}}in{{!}}trunc}} }}
{{dsc | &quot;a+&quot; | {{c|out{{!}}in{{!}}app}}, {{c|in{{!}}app}} }}
{{dsc | &quot;rb&quot; | {{c|binary{{!}}in}} }}
{{dsc | &quot;wb&quot; | {{c|binary{{!}}out}}, {{c|binary{{!}}out{{!}}trunc}} }}
{{dsc | &quot;ab&quot; | {{c|binary{{!}}app}}, {{c|binary{{!}}out{{!}}app}} }}
{{dsc | &quot;r+b&quot; | {{c|binary{{!}}out{{!}}in}} }}
{{dsc | &quot;w+b&quot; | {{c|binary{{!}}out{{!}}in{{!}}trunc}} }}
{{dsc | &quot;a+b&quot; | {{c|binary{{!}}out{{!}}in{{!}}app}}, {{c|binary{{!}}in{{!}}app}} }}
{{dsc end}}

If {{tt|openmode}} is not one of the modes listed, the {{tt|open()}} fails.

If the open operation succeeds and {{c|1=openmode &amp; std::ios_base::ate != 0}} (the {{tt|ate}} bit is set), repositions the file position to the end of file, as if by calling {{c|std::fseek(file, 0, SEEK_END)}}. If the repositioning fails, calls {{lc|close()}} and returns a null pointer to indicate failure.

If the associated file was already open, returns a null pointer right away.

===Parameters===
{{par begin}}
{{par | s, str | the file name to open }}
{{par | openmode | the file opening mode, a binary OR of the {{lc|std::ios_base}} modes}}
{{par end}}

===Return value===
{{c|this}} on success, a null pointer on failure.

===Notes===
{{tt|open()}} is typically called through the constructor or the {{tt|open()}} member function of {{lc|std::basic_fstream}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc is_open}}
{{dsc inc | cpp/io/basic_filebuf/dsc close}}
{{dsc end}}

[[de:cpp/io/basic filebuf/open]]
[[es:cpp/io/basic filebuf/open]]
[[fr:cpp/io/basic filebuf/open]]
[[it:cpp/io/basic filebuf/open]]
[[ja:cpp/io/basic filebuf/open]]
[[pt:cpp/io/basic filebuf/open]]
[[ru:cpp/io/basic filebuf/open]]
[[zh:cpp/io/basic filebuf/open]]</text>
      <sha1>3qckk86h6sjgexlbfhifso1xmudysfs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/operator=</title>
    <ns>0</ns>
    <id>5651</id>
    <revision>
      <id>64257</id>
      <parentid>62725</parentid>
      <timestamp>2013-08-15T16:06:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, +lc</comment>
      <text xml:space="preserve" bytes="1816">{{cpp/io/basic_filebuf/title |operator{{=}}}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |1=
std::basic_filebuf&amp; operator=( std::basic_filebuf&amp;&amp; rhs );
}}
{{dcl | 1=
std::basic_filebuf&amp; operator=( const std::basic_filebuf&amp; rhs ) = delete;
}}
{{dcl end}}

Assigns another {{tt|basic_filebuf}} object.

@1@ First calls {{lc|close()}} to close the associated file, then moves the contents of {{tt|rhs}} into {{tt|*this}}: the put and get buffers, the associated file, the locale, the openmode, the is_open flag, and any other state. After the move, {{tt|rhs}} is not associated with a file and {{c|1=rhs.is_open() == false}}.

@2@ The copy assignment operator is deleted; {{tt|basic_filebuf}} is not {{concept|CopyAssignable}}.

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|basic_filebuf}} that will be moved from}}
{{par end}}

===Return value===
{{tt|*this}}

===Example===
{{example
 |
 | code=
#include &lt;fstream&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{

    std::ifstream fin(&quot;test.in&quot;); // read-only
    std::ofstream fout(&quot;test.out&quot;); // write-only

    std::string s;
    getline(fin, s);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // output

    *fin.rdbuf() = std::move(*fout.rdbuf());

    getline(fin, s);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // empty line

    std::cout &lt;&lt; std::boolalpha &lt;&lt; fout.is_open() &lt;&lt; '\n'; // prints &quot;false&quot;

}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc basic_filebuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap}}
{{dsc end}}

[[de:cpp/io/basic filebuf/operator=]]
[[es:cpp/io/basic filebuf/operator=]]
[[fr:cpp/io/basic filebuf/operator=]]
[[it:cpp/io/basic filebuf/operator=]]
[[ja:cpp/io/basic filebuf/operator=]]
[[pt:cpp/io/basic filebuf/operator=]]
[[ru:cpp/io/basic filebuf/operator=]]
[[zh:cpp/io/basic filebuf/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/overflow</title>
    <ns>0</ns>
    <id>5672</id>
    <revision>
      <id>63168</id>
      <parentid>62305</parentid>
      <timestamp>2013-07-04T00:46:50Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1492">{{cpp/io/basic_filebuf/title | overflow }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |1=
protected:
virtual int_type overflow ( int_type c = Traits::eof() );
}}

Writes some data from the put area to the associated character sequence (to the file).

Behaves like the base class {{c|std::basic_streambuf::overflow}}, except that to write the data, first uses {{ltt|cpp/locale/codecvt/out|codecvt::out()}} of the imbued locale to convert the characters into external (possibly multibyte) representation, stored in a temporary buffer (allocated as large as necessary), then uses file I/O to copy all fully-converted bytes into the file.

If the conversion fails with {{lc|std::codecvt_base::error}}, returns {{c|Traits::eof()}} without attempting any output.

If the associated file is not open ({{c|1=is_open() == false}}), returns {{c|Traits::eof()}} before doing anything.

===Parameters===
(none)

===Return value===
{{c|Traits::not_eof(c)}} to indicate success or {{c|Traits::eof()}} to indicate failure.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc end}}

[[de:cpp/io/basic filebuf/overflow]]
[[es:cpp/io/basic filebuf/overflow]]
[[fr:cpp/io/basic filebuf/overflow]]
[[it:cpp/io/basic filebuf/overflow]]
[[ja:cpp/io/basic filebuf/overflow]]
[[pt:cpp/io/basic filebuf/overflow]]
[[ru:cpp/io/basic filebuf/overflow]]
[[zh:cpp/io/basic filebuf/overflow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/pbackfail</title>
    <ns>0</ns>
    <id>5658</id>
    <revision>
      <id>57575</id>
      <parentid>49612</parentid>
      <timestamp>2013-06-01T05:56:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2642">{{cpp/io/basic_filebuf/title | pbackfail }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |1=
protected:
virtual int_type pbackfail( int_type c = Traits::eof() )
}}

This protected virtual function is called by the public functions {{l2tt|cpp/io/basic_streambuf/sungetc}} and {{l2tt|cpp/io/basic_streambuf/sputbackc}} (which, in turn, are called by {{l2tt|cpp/io/basic_istream/unget}} and {{l2tt|cpp/io/basic_istream/putback}}). 

@1@ The caller is requesting that the get area is backed up by one character ({{tt|pbackfail()}} is called with no arguments), in which case, this function re-reads the file starting one byte earlier and decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}, e.g. by calling {{c|gbump(-1)}}.
@2@ The caller attempts to putback a different character from the one retrieved earlier ({{tt|pbackfail()}} is called with the character that needs to be put back), in which case
:@a@ First, checks if there is a putback position, and if there isn't, backs up the get area by re-reading the file starting one byte earlier.
:@a@ Then checks what character is in the putback position. If the character held there is already equal to {{tt|c}}, as determined by {{c|Traits::eq(to_char_type(c), gptr()[-1])}}, then simply decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}.
:@b@ Otherwise, if the buffer is allowed to modify its own get area, decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}} and writes {{tt|c}} to the location pointed to gptr() after adjustment.

This function never modifies the file, only the get area of the in-memory buffer.

If the file is not open ({{c|1=is_open()==false}}, this function returns {{c|Traits::eof()}} immediately.

===Parameters===
{{par begin}}
{{par | c | the character to put back, or Traits::eof() to indicate that backing up of the get area is requested}}
{{par end}}

===Return value===
{{c|c}} on success except if {{tt|c}} was {{c|Traits::eof()}}, in which case {{c|Traits::not_eof(c)}} is returned.

{{c|Traits::eof()}} on failure.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc end}}

[[de:cpp/io/basic filebuf/pbackfail]]
[[es:cpp/io/basic filebuf/pbackfail]]
[[fr:cpp/io/basic filebuf/pbackfail]]
[[it:cpp/io/basic filebuf/pbackfail]]
[[ja:cpp/io/basic filebuf/pbackfail]]
[[pt:cpp/io/basic filebuf/pbackfail]]
[[ru:cpp/io/basic filebuf/pbackfail]]
[[zh:cpp/io/basic filebuf/pbackfail]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/seekoff</title>
    <ns>0</ns>
    <id>5674</id>
    <revision>
      <id>64194</id>
      <parentid>64193</parentid>
      <timestamp>2013-08-15T15:24:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="4905">{{cpp/io/basic_filebuf/title |seekoff}}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekoff( off_type off,
                          std::ios_base::seekdir way,
                          std::ios_base::openmode which = std::ios_base::in {{!}} std::ios_base::out );
}}

Repositions the file pointer, if possible, to the position that corresponds to exactly {{tt|off}} characters from beginning, end, or current position of the file (depending on the value of {{tt|way}}.

If the associated file is not open ({{c|1=is_open()==false}}, fails immediately.

If the multibyte character encoding is state-dependent ({{ltt|cpp/locale/codecvt/encoding|codecvt::encoding()}} returned {{c|-1}}) or variable-length ({{tt|codecvt::encoding()}} returned {{c|0}}) and the offset {{tt|off}} is not {{c|0}}, fails immediately: this function cannot determine the number of bytes that correspond to {{tt|off}} characters.

If {{tt|way}} is not {{lc|std::basic_ios::cur}} or the offset {{tt|off}} is not {{c|0}}, and the most resent operation done on this filebuf object was output (that is, either the put buffer is not empty, or the most recently called function was {{lc|overflow()}}), then calls {{c|std::codecvt::unshift}} to determine the unshift sequence necessary, and writes that sequence to the file by calling {{lc|overflow()}}.

Then converts the argument {{tt|way}} to a value {{tt|whence}} of type {{c|int}} as follows:

{{dsc begin}}
{{dsc hitem | value of {{tt|way}} | value of {{tt|whence}} }}
{{dsc | {{c|std::basic_ios::beg}} | {{lc|SEEK_SET}} }}
{{dsc | {{c|std::basic_ios::end}} | {{lc|SEEK_END}} }}
{{dsc | {{c|std::basic_ios::cur}} | {{lc|SEEK_CUR}} }}
{{dsc end}}

Then, if the character encoding is fixed-width ({{tt|codecvt::encoding()}} returns some positive number {{tt|width}}, moves the file pointer as if by {{c|std::fseek(file, width*off, whence)}}.

Otherwise, moves the file pointer as if by {{c|std::fseek(file, 0, whence)}}.

The {{tt|openmode}} argument, required by the base class function signature, is usually ignored, because {{tt|std::basic_filebuf}} maintains only one file position.

===Parameters===
{{par begin}}
{{par | off | relative position to set the position indicator to.}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par | which | defines which of the input and/or output sequences to affect. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
A newly constructed object of type {{c|pos_type}} which stores the resulting file position, or {{c|pos_type(off_type(-1))}} on failure.

===Notes===
{{tt|seekoff()}} is called by {{c|std::basic_streambuf::pubseekoff}}, which is called by {{c|std::basic_istream::seekg}}, {{c|std::basic_ostream::seekp}}, {{c|std::basic_istream::tellg}}, and {{c|std::basic_ostream::tellp}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;locale&gt;
int main()
{
    // prepare a 10-byte file holding 4 characters in UTF8
    std::ofstream(&quot;text.txt&quot;) &lt;&lt; u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                                           // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;

    // open using a non-converting encoding
    std::ifstream f1(&quot;text.txt&quot;);
    std::cout &lt;&lt; &quot;f1's locale's encoding() returns &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;char, char, std::mbstate_t&gt;&gt;(f1.getloc()).encoding() &lt;&lt; '\n'
              &lt;&lt; &quot;pubseekoff(3, beg) returns &quot; &lt;&lt; f1.rdbuf()-&gt;pubseekoff(3, std::ios_base::beg) &lt;&lt; '\n'
              &lt;&lt; &quot;pubseekoff(0, end) returns &quot; &lt;&lt; f1.rdbuf()-&gt;pubseekoff(0, std::ios_base::end) &lt;&lt; '\n';;

    // open using UTF-8
    std::wifstream f2(&quot;text.txt&quot;);
    f2.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    std::cout &lt;&lt; &quot;f2's locale's encoding() returns &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(f2.getloc()).encoding() &lt;&lt; '\n'
              &lt;&lt; &quot;pubseekoff(3, beg) returns &quot; &lt;&lt; f2.rdbuf()-&gt;pubseekoff(3, std::ios_base::beg) &lt;&lt; '\n'
              &lt;&lt; &quot;pubseekoff(0, end) returns &quot; &lt;&lt; f2.rdbuf()-&gt;pubseekoff(0, std::ios_base::end) &lt;&lt; '\n';

}
 | output=
f1's locale's encoding() returns 1
pubseekoff(3, beg) returns 3
pubseekoff(0, end) returns 10
f2's locale's encoding() returns 0
pubseekoff(3, beg) returns -1
pubseekoff(0, end) returns 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekoff}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekpos}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc end}}

[[de:cpp/io/basic filebuf/seekoff]]
[[es:cpp/io/basic filebuf/seekoff]]
[[fr:cpp/io/basic filebuf/seekoff]]
[[it:cpp/io/basic filebuf/seekoff]]
[[ja:cpp/io/basic filebuf/seekoff]]
[[pt:cpp/io/basic filebuf/seekoff]]
[[ru:cpp/io/basic filebuf/seekoff]]
[[zh:cpp/io/basic filebuf/seekoff]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/seekpos</title>
    <ns>0</ns>
    <id>5675</id>
    <revision>
      <id>65339</id>
      <parentid>64189</parentid>
      <timestamp>2013-09-09T19:22:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example</comment>
      <text xml:space="preserve" bytes="3570">{{cpp/io/basic_filebuf/title |seekpos}}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekpos( pos_type sp,
                          std::ios_base::openmode which = std::ios_base::in {{!}} std::ios_base::out );
}}

Repositions the file pointer, if possible, to the position indicated by {{tt|sp}}.

If the associated file is not open ({{c|1=is_open()==false}}), fails immediately.

If the file is open for writing, first writes the put area and any unshift sequences required by the currently imbued locale, using {{lc|overflow()}}

Then repositions the file pointer, as by calling {{lc|std::fseek()}}

If the file is open for reading, updates the get area if necessary.

If {{tt|sp}} was not obtained by calling {{lc|seekoff()}} or {{tt|seekpos()}} on the same file, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | sp | file position obtained by {{lc|seekoff()}} or {{tt|seekpos()}} called earlier on the same file }}
{{par | which | defines which of the input and/or output sequences to affect. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
{{tt|sp}} on success or {{c|pos_type(off_type(-1))}} on failure.

===Notes===
{{tt|seekpos()}} is called by {{lc|std::basic_streambuf::pubseekpos()}}, which is called by the single-argument versions of {{lc|std::basic_istream::seekg()}} and {{lc|std::basic_ostream::seekp()}}

Many implementations do not update the get area in {{tt|seekpos()}}, delegating to {{lc|underflow()}} that is called by the nest {{lc|sgetc()}}

===Example===
{{example
 | on some implementations, the get area is emptied by seekpos() and the second underflow() is necessary to observe the effects
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::filebuf
{
    pos_type seekpos(pos_type sp, std::ios_base::openmode which) {
         std::cout &lt;&lt; &quot;Before seekpos(&quot; &lt;&lt; sp &lt;&lt; &quot;), size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
         pos_type rc = std::filebuf::seekpos(sp, which);
         std::cout &lt;&lt; &quot;seekpos() returns &quot; &lt;&lt; rc &lt;&lt; &quot;.\nAfter the call, &quot;
                   &lt;&lt; &quot;size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
// uncomment if get area is emptied by seekpos()
//         std::filebuf::underflow();
//         std::cout &lt;&lt; &quot;after forced underflow(), size of the get area is &quot;
//                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
//                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
        return rc;
    }
};

int main()
{
    mybuf buf;
    buf.open(&quot;test.txt&quot;, std::ios_base::in);
    std::istream stream(&amp;buf);
    stream.get(); // read one char to force underflow()
    stream.seekg(2);
}
 | p=true
 | output=
Before seekpos(2), size of the get area is 110 with 109 read positions available
seekpos() returns 2.
After the call, size of the get area is 110 with 108 read positions available
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekoff}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc end}}

[[de:cpp/io/basic filebuf/seekpos]]
[[es:cpp/io/basic filebuf/seekpos]]
[[fr:cpp/io/basic filebuf/seekpos]]
[[it:cpp/io/basic filebuf/seekpos]]
[[ja:cpp/io/basic filebuf/seekpos]]
[[pt:cpp/io/basic filebuf/seekpos]]
[[ru:cpp/io/basic filebuf/seekpos]]
[[zh:cpp/io/basic filebuf/seekpos]]</text>
      <sha1>g5ez8zqwdzczi3pno5efb6q52g9qo82</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/setbuf</title>
    <ns>0</ns>
    <id>4565</id>
    <revision>
      <id>69877</id>
      <parentid>62415</parentid>
      <timestamp>2014-04-30T13:49:34Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Return value */ correcting</comment>
      <text xml:space="preserve" bytes="2932">{{cpp/io/basic_filebuf/title | setbuf }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual std::basic_streambuf&lt;CharT, Traits&gt;* setbuf( char_type* s, std::streamsize n )
}}

If {{tt|s}} is a null pointer and {{tt|n}} is zero, the filebuf becomes ''unbuffered'' for output, meaning {{tt|pbase()}} and {{tt|pptr()}} are null and any output is immediately sent to file.

Otherwise, a call to {{tt|setbuf()}} replaces the internal buffer (the controlled character sequence) with the user-supplied character array whose first element is pointed to by {{tt|s}} and allows this {{lc|std::basic_filebuf}} object to use up to {{tt|n}} bytes in that array for buffering.

This function is protected virtual, it may only be called through {{tt|pubsetbuf()}} or from member functions of a user-defined class derived from {{tt|std::basic_filebuf}}.

===Parameters===
{{par begin}}
{{par | s | pointer to the first byte in the user-provided buffer or null}}
{{par | n | the number of bytes in the user-provided buffer or zero}}
{{par end}}

===Return value===
{{c|this}}.

===Notes===
The conditions when this function may be used and the way in which the provided buffer is used is implementation-defined.

* GCC 4.6 libstdc++
: {{tt|setbuf()}} may only be called when the {{lc|std::basic_filebuf}} is not associated with a file (has no effect otherwise). With a user-provided buffer, reading from file reads {{tt|n-1}} bytes at a time.
* Clang++3.0 libc++
: {{tt|setbuf()}} may be called after opening the file, but before any I/O (may crash otherwise). With a user-provided buffer, reading from file reads largest multiples of 4096 that fit in the buffer. 
* Visual Studio 2010 
: {{tt|setbuf()}} may be called at any time, even after some I/O took place. Current contents of the buffer, if any, are lost.

The standard does not define any behavior for this function except that {{tt|setbuf(0, 0)}} called before any I/O has taken place is required to set unbuffered output.

===Example===
{{example
 | provide a 10k buffer for reading. On linux, the strace utility may be used to observe the actual number of bytes read
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
        int cnt = 0;
        std::ifstream file;
        char buf[10241];

        file.rdbuf()-&gt;pubsetbuf(buf, sizeof buf);
        file.open(&quot;/usr/share/dict/words&quot;);

        for (std::string line; getline(file, line); )
                ++cnt;
        std::cout &lt;&lt; cnt &lt;&lt; '\n';
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsetbuf | mem=std::basic_streambuf}}
{{dsc inc | cpp/io/c/dsc setvbuf}}
{{dsc end}}

[[de:cpp/io/basic filebuf/setbuf]]
[[es:cpp/io/basic filebuf/setbuf]]
[[fr:cpp/io/basic filebuf/setbuf]]
[[it:cpp/io/basic filebuf/setbuf]]
[[ja:cpp/io/basic filebuf/setbuf]]
[[pt:cpp/io/basic filebuf/setbuf]]
[[ru:cpp/io/basic filebuf/setbuf]]
[[zh:cpp/io/basic filebuf/setbuf]]</text>
      <sha1>gqd7qya0svkmnkssy7as846z8brrlds</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/showmanyc</title>
    <ns>0</ns>
    <id>5654</id>
    <revision>
      <id>57583</id>
      <parentid>49616</parentid>
      <timestamp>2013-06-01T05:56:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1504">{{cpp/io/basic_filebuf/title | showmanyc }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual std::streamsize showmanyc()
}}

If implemented, returns the number of characters left to read from the file.

===Parameters===
(none)

===Return value===
The number of characters available for reading from the file, or {{c|-1}} if the end of file was reached.

===Notes===
This function is optional. If not implemented, this function returns {{c|0}} (since the base class version {{c|std::basic_streambuf::showmanyc}} gets called)

Whether implemented or not, this function is normally called by {{c|std::basic_streambuf::in_avail}} if the get area is empty.

===Example===
{{example
 | implementation test to see if showmanyc() is implemented for filebuf
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::filebuf
{
     using std::filebuf::showmanyc;
};

int main()
{
    mybuf fin;
    fin.open(&quot;test.in&quot;, std::ios_base::in);
    std::cout &lt;&lt; &quot;showmanyc() returns &quot; &lt;&lt; fin.showmanyc() &lt;&lt; '\n';
}
 | output=
showmanyc() returns 6626
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc in_avail}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc end}}

[[de:cpp/io/basic filebuf/showmanyc]]
[[es:cpp/io/basic filebuf/showmanyc]]
[[fr:cpp/io/basic filebuf/showmanyc]]
[[it:cpp/io/basic filebuf/showmanyc]]
[[ja:cpp/io/basic filebuf/showmanyc]]
[[pt:cpp/io/basic filebuf/showmanyc]]
[[ru:cpp/io/basic filebuf/showmanyc]]
[[zh:cpp/io/basic filebuf/showmanyc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/swap</title>
    <ns>0</ns>
    <id>5650</id>
    <revision>
      <id>62726</id>
      <parentid>62409</parentid>
      <timestamp>2013-07-01T23:34:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1446">{{cpp/io/basic_filebuf/title |swap}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( std::basic_filebuf&amp; rhs )
}}
{{dcl end}}

Swaps the state and the contents of {{c|*this}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|basic_filebuf}} }}
{{par end}}

===Return value===
(none)

===Notes===
This function is called automatically when swapping {{lc|std::fstream}} objects, it is rarely necessary to call it directly.

===Example===
{{example
 |
 | code=
#include &lt;fstream&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::ifstream fin(&quot;test.in&quot;); // read-only
    std::ofstream fout(&quot;test.out&quot;); // write-only

    std::string s;
    getline(fin, s);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // outputs the first line of test.in

    fin.rdbuf()-&gt;swap(*fout.rdbuf()); //swap the underlying buffers

    getline(fin, s); // fails: cannot read from a write-only filebuf
    std::cout &lt;&lt; s &lt;&lt; '\n'; // prints empty line
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap2}}
{{dsc inc | cpp/io/basic_fstream/dsc swap | basic_fstream}}
{{dsc end}}

[[de:cpp/io/basic filebuf/swap]]
[[es:cpp/io/basic filebuf/swap]]
[[fr:cpp/io/basic filebuf/swap]]
[[it:cpp/io/basic filebuf/swap]]
[[ja:cpp/io/basic filebuf/swap]]
[[pt:cpp/io/basic filebuf/swap]]
[[ru:cpp/io/basic filebuf/swap]]
[[zh:cpp/io/basic filebuf/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/swap2</title>
    <ns>0</ns>
    <id>5676</id>
    <revision>
      <id>63141</id>
      <parentid>62727</parentid>
      <timestamp>2013-07-03T08:00:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1040">{{cpp/title | swap&lt;small&gt;(std::basic_filebuf)&lt;/small&gt;}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class CharT, class Traits &gt;
void swap( std::basic_filebuf&lt;CharT,Traits&gt;&amp; lhs,
           std::basic_filebuf&lt;CharT,Traits&gt;&amp; rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::basic_filebuf}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | {{lc|std::basic_filebuf}} objects whose states to swap}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc end}}

[[de:cpp/io/basic filebuf/swap2]]
[[es:cpp/io/basic filebuf/swap2]]
[[fr:cpp/io/basic filebuf/swap2]]
[[it:cpp/io/basic filebuf/swap2]]
[[ja:cpp/io/basic filebuf/swap2]]
[[pt:cpp/io/basic filebuf/swap2]]
[[ru:cpp/io/basic filebuf/swap2]]
[[zh:cpp/io/basic filebuf/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/sync</title>
    <ns>0</ns>
    <id>5629</id>
    <revision>
      <id>64261</id>
      <parentid>57588</parentid>
      <timestamp>2013-08-15T16:08:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1198">{{cpp/io/basic_filebuf/title | sync }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual int sync()
}}

If a put area exists (e.g. the file was opened for writing), calls {{lc|overflow()}} to write all pending output to the file.

If a get area exists (e.g. the file was opened for reading), the effect is implementation-defined. Typical implementation may empty out the get area and move the current file position back by the corresponding number of bytes.

===Parameters===
(none)

===Return value===
{{c|0}} in case of success, {{c|-1}} in case of failure.

===Notes===
{{tt|sync()}} or its equivalent is implicitly called by {{lc|close()}}, {{lc|seekoff()}}, and {{lc|seekpos()}} and explicitly called by {{lc|std::basic_streambuf::pubsync()}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsync}}
{{dsc inc | cpp/io/c/dsc fflush}}
{{dsc end}}

[[de:cpp/io/basic filebuf/sync]]
[[es:cpp/io/basic filebuf/sync]]
[[fr:cpp/io/basic filebuf/sync]]
[[it:cpp/io/basic filebuf/sync]]
[[ja:cpp/io/basic filebuf/sync]]
[[pt:cpp/io/basic filebuf/sync]]
[[ru:cpp/io/basic filebuf/sync]]
[[zh:cpp/io/basic filebuf/sync]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/uflow</title>
    <ns>0</ns>
    <id>5656</id>
    <revision>
      <id>64195</id>
      <parentid>57591</parentid>
      <timestamp>2013-08-15T15:24:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1039">{{cpp/io/basic_filebuf/title | uflow }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual int_type uflow()
}}

Behaves like the {{lc|underflow()}}, except that if {{lc|underflow()}} succeeds (does not return {{c|Traits::eof()}}), then advances the next pointer for the get area. In other words, consumes one of the characters obtained by {{lc|underflow()}}.

===Parameters===
(none)

===Return value===
The value of the character that was read and consumed in case of success, or {{c|Traits::eof()}} in case of failure.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc uflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc end}}

[[de:cpp/io/basic filebuf/uflow]]
[[es:cpp/io/basic filebuf/uflow]]
[[fr:cpp/io/basic filebuf/uflow]]
[[it:cpp/io/basic filebuf/uflow]]
[[ja:cpp/io/basic filebuf/uflow]]
[[pt:cpp/io/basic filebuf/uflow]]
[[ru:cpp/io/basic filebuf/uflow]]
[[zh:cpp/io/basic filebuf/uflow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/underflow</title>
    <ns>0</ns>
    <id>5655</id>
    <revision>
      <id>65335</id>
      <parentid>62303</parentid>
      <timestamp>2013-09-09T17:44:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example and seealsos</comment>
      <text xml:space="preserve" bytes="2687">{{cpp/io/basic_filebuf/title | underflow }}
{{cpp/io/basic_filebuf/navbar}}
{{ddcl |
protected:
virtual int_type underflow()
}}

Reads more data into the input area. 

Behaves like the base class {{c|std::basic_streambuf::underflow}}, except that to read the data from the associated character sequence (the file) into the get area, first reads the bytes from the file into a temporary buffer (allocated as large as necessary), then uses {{c|std::codecvt::in}} of the imbued locale to convert the external (typically, multibyte) representation to the internal form which is then used to populate the get area. The conversion may be skipped if the locale's {{c|std::codecvt::always_noconv}} returns {{c|true}}

===Parameters===
(none)

===Return value===
{{c|Traits::to_int_type(*gptr())}} (the first character of the pending sequence) in case of success, or {{c|Traits::eof()}} in case of failure.

===Example===
{{example
 |
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::filebuf
{
    int underflow() {
         std::cout &lt;&lt; &quot;Before underflow(): size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
         int rc = std::filebuf::underflow();
         std::cout &lt;&lt; &quot;underflow() returns &quot; &lt;&lt; rc &lt;&lt; &quot;.\nAfter the call, &quot;
                   &lt;&lt; &quot;size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
        return rc;
    }
};

int main()
{
    mybuf buf;
    buf.open(&quot;test.txt&quot;, std::ios_base::in);
    std::istream stream(&amp;buf);
    while(stream.get()) ;
}
 | p=true
 | output=
Before underflow(): size of the get area is 0 with 0 read positions available
underflow() returns 73.
After the call, size of the get area is 110 with 110 read positions available
Before underflow(): size of the get area is 110 with 0 read positions available
underflow() returns -1.
After the call, size of the get area is 0 with 0 read positions available
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc underflow}}
{{dsc inc | cpp/io/strstreambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc uflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc end}}

[[de:cpp/io/basic filebuf/underflow]]
[[es:cpp/io/basic filebuf/underflow]]
[[fr:cpp/io/basic filebuf/underflow]]
[[it:cpp/io/basic filebuf/underflow]]
[[ja:cpp/io/basic filebuf/underflow]]
[[pt:cpp/io/basic filebuf/underflow]]
[[ru:cpp/io/basic filebuf/underflow]]
[[zh:cpp/io/basic filebuf/underflow]]</text>
      <sha1>hpibp8ksajsb2uc00pcgk356n56ni9z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic filebuf/~basic filebuf</title>
    <ns>0</ns>
    <id>5652</id>
    <revision>
      <id>64204</id>
      <parentid>57593</parentid>
      <timestamp>2013-08-15T15:29:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="992">{{cpp/io/basic_filebuf/title |~basic_filebuf}}
{{cpp/io/basic_filebuf/navbar}}
{{dcl begin}}
{{ddcl| 
virtual ~basic_filebuf();
}}
{{dcl end}}

Calls {{lc|close()}} to close the associated file and destructs all other members of {{tt|basic_filebuf}}. If an exception is thrown by {{lc|close()}}, it is caught and not rethrown.

===Parameters===
(none)

===Return value===
(none)

===Notes===
Typically called by the destructor of {{lc|std::basic_fstream}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc basic_filebuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc close}}
{{dsc end}}

[[de:cpp/io/basic filebuf/~basic filebuf]]
[[es:cpp/io/basic filebuf/~basic filebuf]]
[[fr:cpp/io/basic filebuf/~basic filebuf]]
[[it:cpp/io/basic filebuf/~basic filebuf]]
[[ja:cpp/io/basic filebuf/~basic filebuf]]
[[pt:cpp/io/basic filebuf/~basic filebuf]]
[[ru:cpp/io/basic filebuf/~basic filebuf]]
[[zh:cpp/io/basic filebuf/~basic filebuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream</title>
    <ns>0</ns>
    <id>486</id>
    <revision>
      <id>57596</id>
      <parentid>49623</parentid>
      <timestamp>2013-06-01T05:56:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2240">{{cpp/title|basic_fstream}}
{{cpp/io/basic_fstream/navbar}}
{{ddcl | header=fstream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_fstream : public std::basic_iostream&lt;CharT, Traits&gt;
}}

The class template {{tt|basic_fstream}} implements high-level input/output operations on file based streams. It interfaces a file-based streambuffer ({{lc|std::basic_filebuf}}) with the high-level interface of ({{lc|std::basic_iostream}}).

A typical implementation of {{tt|std::basic_fstream}} holds only one non-derived data member: an instance of {{c|std::basic_filebuf&lt;CharT, Traits&gt;}}.

{{inheritance diagram/std-basic_fstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | fstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|fstream}} | {{c|basic_fstream&lt;char&gt;}}}}
{{dsc | {{tt|wfstream}} | {{c|basic_fstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc constructor | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc destructor | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc operator{{=}} | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc rdbuf | basic_fstream}}

{{dsc h2 | File operations }}
{{dsc inc | cpp/io/basic_fstream/dsc is_open | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc open | basic_fstream}}
{{dsc inc | cpp/io/basic_fstream/dsc close | basic_fstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_fstream}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic fstream]]
[[es:cpp/io/basic fstream]]
[[fr:cpp/io/basic fstream]]
[[it:cpp/io/basic fstream]]
[[ja:cpp/io/basic fstream]]
[[pt:cpp/io/basic fstream]]
[[ru:cpp/io/basic fstream]]
[[zh:cpp/io/basic fstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/basic fstream</title>
    <ns>0</ns>
    <id>487</id>
    <revision>
      <id>50830</id>
      <parentid>44210</parentid>
      <timestamp>2013-06-01T03:41:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="400">{{include page|cpp/io/basic_fstream/constructor|basic_fstream}}

[[de:cpp/io/basic fstream/basic fstream]]
[[es:cpp/io/basic fstream/basic fstream]]
[[fr:cpp/io/basic fstream/basic fstream]]
[[it:cpp/io/basic fstream/basic fstream]]
[[ja:cpp/io/basic fstream/basic fstream]]
[[pt:cpp/io/basic fstream/basic fstream]]
[[ru:cpp/io/basic fstream/basic fstream]]
[[zh:cpp/io/basic fstream/basic fstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/close</title>
    <ns>0</ns>
    <id>488</id>
    <revision>
      <id>50831</id>
      <parentid>44205</parentid>
      <timestamp>2013-06-01T03:41:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/close|basic_fstream}}

[[de:cpp/io/basic fstream/close]]
[[es:cpp/io/basic fstream/close]]
[[fr:cpp/io/basic fstream/close]]
[[it:cpp/io/basic fstream/close]]
[[ja:cpp/io/basic fstream/close]]
[[pt:cpp/io/basic fstream/close]]
[[ru:cpp/io/basic fstream/close]]
[[zh:cpp/io/basic fstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/is open</title>
    <ns>0</ns>
    <id>489</id>
    <revision>
      <id>50832</id>
      <parentid>44201</parentid>
      <timestamp>2013-06-01T03:41:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="348">{{include page|cpp/io/basic_fstream/is_open|basic_fstream}}

[[de:cpp/io/basic fstream/is open]]
[[es:cpp/io/basic fstream/is open]]
[[fr:cpp/io/basic fstream/is open]]
[[it:cpp/io/basic fstream/is open]]
[[ja:cpp/io/basic fstream/is open]]
[[pt:cpp/io/basic fstream/is open]]
[[ru:cpp/io/basic fstream/is open]]
[[zh:cpp/io/basic fstream/is open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/open</title>
    <ns>0</ns>
    <id>490</id>
    <revision>
      <id>50833</id>
      <parentid>44195</parentid>
      <timestamp>2013-06-01T03:41:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="321">{{include page|cpp/io/basic_fstream/open|basic_fstream}}

[[de:cpp/io/basic fstream/open]]
[[es:cpp/io/basic fstream/open]]
[[fr:cpp/io/basic fstream/open]]
[[it:cpp/io/basic fstream/open]]
[[ja:cpp/io/basic fstream/open]]
[[pt:cpp/io/basic fstream/open]]
[[ru:cpp/io/basic fstream/open]]
[[zh:cpp/io/basic fstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/operator=</title>
    <ns>0</ns>
    <id>491</id>
    <revision>
      <id>72273</id>
      <parentid>44192</parentid>
      <timestamp>2014-08-02T09:07:26Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>use {{include page}}</comment>
      <text xml:space="preserve" bytes="370">{{include page|cpp/io/basic_fstream/operator{{=}}|basic_fstream}}

[[de:cpp/io/basic fstream/operator=]]
[[es:cpp/io/basic fstream/operator=]]
[[fr:cpp/io/basic fstream/operator=]]
[[it:cpp/io/basic fstream/operator=]]
[[ja:cpp/io/basic fstream/operator=]]
[[pt:cpp/io/basic fstream/operator=]]
[[ru:cpp/io/basic fstream/operator=]]
[[zh:cpp/io/basic fstream/operator=]]</text>
      <sha1>2sgcjye5lk93oalzor71n6drptpcipn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/rdbuf</title>
    <ns>0</ns>
    <id>492</id>
    <revision>
      <id>50834</id>
      <parentid>44187</parentid>
      <timestamp>2013-06-01T03:41:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/rdbuf|basic_fstream}}

[[de:cpp/io/basic fstream/rdbuf]]
[[es:cpp/io/basic fstream/rdbuf]]
[[fr:cpp/io/basic fstream/rdbuf]]
[[it:cpp/io/basic fstream/rdbuf]]
[[ja:cpp/io/basic fstream/rdbuf]]
[[pt:cpp/io/basic fstream/rdbuf]]
[[ru:cpp/io/basic fstream/rdbuf]]
[[zh:cpp/io/basic fstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/swap</title>
    <ns>0</ns>
    <id>493</id>
    <revision>
      <id>50835</id>
      <parentid>44182</parentid>
      <timestamp>2013-06-01T03:41:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="321">{{include page|cpp/io/basic_fstream/swap|basic_fstream}}

[[de:cpp/io/basic fstream/swap]]
[[es:cpp/io/basic fstream/swap]]
[[fr:cpp/io/basic fstream/swap]]
[[it:cpp/io/basic fstream/swap]]
[[ja:cpp/io/basic fstream/swap]]
[[pt:cpp/io/basic fstream/swap]]
[[ru:cpp/io/basic fstream/swap]]
[[zh:cpp/io/basic fstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic fstream/swap2</title>
    <ns>0</ns>
    <id>5489</id>
    <revision>
      <id>50836</id>
      <parentid>44177</parentid>
      <timestamp>2013-06-01T03:41:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/swap2|basic_fstream}}

[[de:cpp/io/basic fstream/swap2]]
[[es:cpp/io/basic fstream/swap2]]
[[fr:cpp/io/basic fstream/swap2]]
[[it:cpp/io/basic fstream/swap2]]
[[ja:cpp/io/basic fstream/swap2]]
[[pt:cpp/io/basic fstream/swap2]]
[[ru:cpp/io/basic fstream/swap2]]
[[zh:cpp/io/basic fstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream</title>
    <ns>0</ns>
    <id>494</id>
    <revision>
      <id>57599</id>
      <parentid>49624</parentid>
      <timestamp>2013-06-01T05:56:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2226">{{cpp/title|basic_ifstream}}
{{cpp/io/basic_ifstream/navbar}}
{{ddcl | header=fstream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_ifstream : public std::basic_istream&lt;CharT, Traits&gt;
}}

The class template {{tt|basic_ifstream}} implements high-level input operations on file based streams. It interfaces a file-based streambuffer ({{lc|std::basic_filebuf}}) with the high-level interface of ({{lc|std::basic_istream}}).

A typical implementation of {{tt|std::basic_ifstream}} holds only one non-derived data member: an instance of {{c|std::basic_filebuf&lt;CharT, Traits&gt;}}.

{{inheritance diagram/std-basic_ifstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | fstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|ifstream}} | {{c|basic_ifstream&lt;char&gt;}}}}
{{dsc | {{tt|wifstream}} | {{c|basic_ifstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc constructor | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc destructor | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc operator{{=}} | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc rdbuf | basic_ifstream}}

{{dsc h2 | File operations }}
{{dsc inc | cpp/io/basic_fstream/dsc is_open | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc open | basic_ifstream}}
{{dsc inc | cpp/io/basic_fstream/dsc close | basic_ifstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ifstream}}
{{dsc end}}


{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic ifstream]]
[[es:cpp/io/basic ifstream]]
[[fr:cpp/io/basic ifstream]]
[[it:cpp/io/basic ifstream]]
[[ja:cpp/io/basic ifstream]]
[[pt:cpp/io/basic ifstream]]
[[ru:cpp/io/basic ifstream]]
[[zh:cpp/io/basic ifstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/basic ifstream</title>
    <ns>0</ns>
    <id>495</id>
    <revision>
      <id>50837</id>
      <parentid>44167</parentid>
      <timestamp>2013-06-01T03:41:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="417">{{include page|cpp/io/basic_fstream/constructor|basic_ifstream}}

[[de:cpp/io/basic ifstream/basic ifstream]]
[[es:cpp/io/basic ifstream/basic ifstream]]
[[fr:cpp/io/basic ifstream/basic ifstream]]
[[it:cpp/io/basic ifstream/basic ifstream]]
[[ja:cpp/io/basic ifstream/basic ifstream]]
[[pt:cpp/io/basic ifstream/basic ifstream]]
[[ru:cpp/io/basic ifstream/basic ifstream]]
[[zh:cpp/io/basic ifstream/basic ifstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/close</title>
    <ns>0</ns>
    <id>496</id>
    <revision>
      <id>50838</id>
      <parentid>44162</parentid>
      <timestamp>2013-06-01T03:41:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/close|basic_ifstream}}

[[de:cpp/io/basic ifstream/close]]
[[es:cpp/io/basic ifstream/close]]
[[fr:cpp/io/basic ifstream/close]]
[[it:cpp/io/basic ifstream/close]]
[[ja:cpp/io/basic ifstream/close]]
[[pt:cpp/io/basic ifstream/close]]
[[ru:cpp/io/basic ifstream/close]]
[[zh:cpp/io/basic ifstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/is open</title>
    <ns>0</ns>
    <id>497</id>
    <revision>
      <id>50839</id>
      <parentid>44157</parentid>
      <timestamp>2013-06-01T03:41:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="357">{{include page|cpp/io/basic_fstream/is_open|basic_ifstream}}

[[de:cpp/io/basic ifstream/is open]]
[[es:cpp/io/basic ifstream/is open]]
[[fr:cpp/io/basic ifstream/is open]]
[[it:cpp/io/basic ifstream/is open]]
[[ja:cpp/io/basic ifstream/is open]]
[[pt:cpp/io/basic ifstream/is open]]
[[ru:cpp/io/basic ifstream/is open]]
[[zh:cpp/io/basic ifstream/is open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/open</title>
    <ns>0</ns>
    <id>498</id>
    <revision>
      <id>50840</id>
      <parentid>44152</parentid>
      <timestamp>2013-06-01T03:41:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/open|basic_ifstream}}

[[de:cpp/io/basic ifstream/open]]
[[es:cpp/io/basic ifstream/open]]
[[fr:cpp/io/basic ifstream/open]]
[[it:cpp/io/basic ifstream/open]]
[[ja:cpp/io/basic ifstream/open]]
[[pt:cpp/io/basic ifstream/open]]
[[ru:cpp/io/basic ifstream/open]]
[[zh:cpp/io/basic ifstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/operator=</title>
    <ns>0</ns>
    <id>499</id>
    <revision>
      <id>72274</id>
      <parentid>44147</parentid>
      <timestamp>2014-08-02T09:09:47Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>use {{include page}}</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/io/basic_fstream/operator{{=}}|basic_ifstream}}

[[de:cpp/io/basic ifstream/operator=]]
[[es:cpp/io/basic ifstream/operator=]]
[[fr:cpp/io/basic ifstream/operator=]]
[[it:cpp/io/basic ifstream/operator=]]
[[ja:cpp/io/basic ifstream/operator=]]
[[pt:cpp/io/basic ifstream/operator=]]
[[ru:cpp/io/basic ifstream/operator=]]
[[zh:cpp/io/basic ifstream/operator=]]</text>
      <sha1>nros7413jwe2nklf6nt9mx3orlvpr44</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/rdbuf</title>
    <ns>0</ns>
    <id>500</id>
    <revision>
      <id>50841</id>
      <parentid>44145</parentid>
      <timestamp>2013-06-01T03:41:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/rdbuf|basic_ifstream}}

[[de:cpp/io/basic ifstream/rdbuf]]
[[es:cpp/io/basic ifstream/rdbuf]]
[[fr:cpp/io/basic ifstream/rdbuf]]
[[it:cpp/io/basic ifstream/rdbuf]]
[[ja:cpp/io/basic ifstream/rdbuf]]
[[pt:cpp/io/basic ifstream/rdbuf]]
[[ru:cpp/io/basic ifstream/rdbuf]]
[[zh:cpp/io/basic ifstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/swap</title>
    <ns>0</ns>
    <id>501</id>
    <revision>
      <id>50842</id>
      <parentid>44140</parentid>
      <timestamp>2013-06-01T03:41:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/swap|basic_ifstream}}

[[de:cpp/io/basic ifstream/swap]]
[[es:cpp/io/basic ifstream/swap]]
[[fr:cpp/io/basic ifstream/swap]]
[[it:cpp/io/basic ifstream/swap]]
[[ja:cpp/io/basic ifstream/swap]]
[[pt:cpp/io/basic ifstream/swap]]
[[ru:cpp/io/basic ifstream/swap]]
[[zh:cpp/io/basic ifstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ifstream/swap2</title>
    <ns>0</ns>
    <id>5488</id>
    <revision>
      <id>50843</id>
      <parentid>44135</parentid>
      <timestamp>2013-06-01T03:41:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/swap2|basic_ifstream}}

[[de:cpp/io/basic ifstream/swap2]]
[[es:cpp/io/basic ifstream/swap2]]
[[fr:cpp/io/basic ifstream/swap2]]
[[it:cpp/io/basic ifstream/swap2]]
[[ja:cpp/io/basic ifstream/swap2]]
[[pt:cpp/io/basic ifstream/swap2]]
[[ru:cpp/io/basic ifstream/swap2]]
[[zh:cpp/io/basic ifstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios</title>
    <ns>0</ns>
    <id>502</id>
    <revision>
      <id>64358</id>
      <parentid>57600</parentid>
      <timestamp>2013-08-15T18:32:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc, std::</comment>
      <text xml:space="preserve" bytes="2519">{{cpp/title|basic_ios}}
{{cpp/io/basic_ios/navbar}}
{{ddcl | header=ios | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_ios : public ios_base
}}

The class {{tt|std::basic_ios}} provides facilities for interfacing with objects that have {{lc|std::basic_streambuf}} interface. Several {{tt|std::basic_ios}} objects can refer to one actual {{tt|std::basic_streambuf}} object. Character type dependent formatting flags and error state is stored in {{tt|std::basic_ios}} class.

{{inheritance diagram/std-basic_ios}}

Two specializations for common character types are also provided:

{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|ios}} | {{c|basic_ios&lt;char&gt;}}}}
{{dsc | {{tt|wios}} | {{c|basic_ios&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Public member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc constructor}}
{{dsc inc | cpp/io/basic_ios/dsc destructor}}
{{dsc mem fun | operator{{=}} | nolink=true | the copy assignment operator is deleted}}

{{dsc h2 | State functions}}
{{dsc inc | cpp/io/basic_ios/dsc good}}
{{dsc inc | cpp/io/basic_ios/dsc eof}}
{{dsc inc | cpp/io/basic_ios/dsc fail}}
{{dsc inc | cpp/io/basic_ios/dsc bad}}
{{dsc inc | cpp/io/basic_ios/dsc operator!}}
{{dsc inc | cpp/io/basic_ios/dsc operator bool}}
{{dsc inc | cpp/io/basic_ios/dsc rdstate}}
{{dsc inc | cpp/io/basic_ios/dsc setstate}}
{{dsc inc | cpp/io/basic_ios/dsc clear}}

{{dsc h2 | Formatting}}
{{dsc inc | cpp/io/basic_ios/dsc copyfmt}}
{{dsc inc | cpp/io/basic_ios/dsc fill}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/basic_ios/dsc exceptions}}
{{dsc inc | cpp/io/basic_ios/dsc imbue}}
{{dsc inc | cpp/io/basic_ios/dsc rdbuf}}
{{dsc inc | cpp/io/basic_ios/dsc tie}}
{{dsc inc | cpp/io/basic_ios/dsc narrow}}
{{dsc inc | cpp/io/basic_ios/dsc widen}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc init}}
{{dsc inc | cpp/io/basic_ios/dsc move}}
{{dsc inc | cpp/io/basic_ios/dsc swap}}
{{dsc inc | cpp/io/basic_ios/dsc set_rdbuf}}
{{dsc end}}

{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic ios]]
[[es:cpp/io/basic ios]]
[[fr:cpp/io/basic ios]]
[[it:cpp/io/basic ios]]
[[ja:cpp/io/basic ios]]
[[pt:cpp/io/basic ios]]
[[ru:cpp/io/basic ios]]
[[zh:cpp/io/basic ios]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/bad</title>
    <ns>0</ns>
    <id>503</id>
    <revision>
      <id>63876</id>
      <parentid>49626</parentid>
      <timestamp>2013-07-29T20:29:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to the list of conditions that set badbit</comment>
      <text xml:space="preserve" bytes="855">{{cpp/io/basic_ios/title | bad}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
bool bad() const;
}}
{{dcl end}}

Returns {{c|true}} if non-recoverable error has occurred on the associated stream. Specifically, returns {{c|true}} if {{ltt|cpp/io/ios_base/iostate|badbit}} is set in {{c|rdstate()}}.

See {{l2tt|cpp/io/ios_base/iostate}} for the list of conditions that set {{tt|badbit}}.

===Parameters===
(none)

===Return value===
{{c|true}} if a non-recoverable error has occurred, {{c|false}} otherwise.

===Example===
{{example template|cpp/io/basic_ios/example1}}

===See also===
{{cpp/io/basic ios/iostate accessors}}

[[de:cpp/io/basic ios/bad]]
[[es:cpp/io/basic ios/bad]]
[[fr:cpp/io/basic ios/bad]]
[[it:cpp/io/basic ios/bad]]
[[ja:cpp/io/basic ios/bad]]
[[pt:cpp/io/basic ios/bad]]
[[ru:cpp/io/basic ios/bad]]
[[zh:cpp/io/basic ios/bad]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/basic ios</title>
    <ns>0</ns>
    <id>5534</id>
    <revision>
      <id>64264</id>
      <parentid>61894</parentid>
      <timestamp>2013-08-15T16:10:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1287">{{cpp/io/basic_ios/title | basic_ios}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num = 1 | 
protected:
basic_ios();
}}
{{dcl | num = 2 | 
public:
explicit basic_ios( std::basic_streambuf&lt;CharT,Traits&gt;* sb );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
private:
basic_ios(const basic_ios&amp;);
}}
{{dcl | since=c++11 | 1=
public:
basic_ios(const basic_ios&amp; ) = delete;
}}
{{dcl rev end}}
{{dcl end}}

Constructs new {{tt|basic_ios}} object. 

@1@ Default constructor. The internal state is not initialized. {{lc|init()}} must be called before the first use of the object or before destructor, otherwise the behavior is undefined.

@2@ Initializes the internal state by calling {{c|init(sb)}}. The associated stream buffer is set to {{tt|sb}}. 

@3@ The copy constructor was declared {{tt|private:}} and not defined until C++11 and is declared as deleted in C++11: I/O streams are not {{concept|CopyConstructible}}.

===Parameters===
{{par begin}}
{{par | sb | stream buffer to associate to}}
{{par end}}

[[de:cpp/io/basic ios/basic ios]]
[[es:cpp/io/basic ios/basic ios]]
[[fr:cpp/io/basic ios/basic ios]]
[[it:cpp/io/basic ios/basic ios]]
[[ja:cpp/io/basic ios/basic ios]]
[[pt:cpp/io/basic ios/basic ios]]
[[ru:cpp/io/basic ios/basic ios]]
[[zh:cpp/io/basic ios/basic ios]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/clear</title>
    <ns>0</ns>
    <id>504</id>
    <revision>
      <id>63720</id>
      <parentid>62066</parentid>
      <timestamp>2013-07-22T20:43:42Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1455">{{cpp/io/basic_ios/title | clear}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
void clear( std::ios_base::iostate state = std::ios_base::goodbit );
}}
{{dcl end}}

Clears the stream error state flags by assigning them the value of {{tt|state}}. If {{c|rdbuf() {{==}} 0}} then {{c|state {{!}} badbit}} is assigned. May throw an exception.

===Parameters===
{{par begin}}
{{par | state | new error state flags setting. It can be a combination of the following constants:
{{cpp/io/ios_base/iostate consts}}
}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | clear() without arguments can be used to unset the failbit after unexpected input
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    double n;
    while( std::cout &lt;&lt; &quot;Please, enter a number\n&quot;
           &amp;&amp; ! (std::cin &gt;&gt; n) )
    {
        std::cin.clear();
        std::string line;
        std::getline(std::cin, line);
        std::cout &lt;&lt; &quot;I am sorry, but '&quot; &lt;&lt; line &lt;&lt; &quot;' is not a number\n&quot;;
    }
    std::cout &lt;&lt; &quot;Thank you for entering the number &quot; &lt;&lt; n &lt;&lt; '\n';
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc setstate}}
{{dsc inc | cpp/io/basic_ios/dsc rdstate}}
{{dsc end}}

[[de:cpp/io/basic ios/clear]]
[[es:cpp/io/basic ios/clear]]
[[fr:cpp/io/basic ios/clear]]
[[it:cpp/io/basic ios/clear]]
[[ja:cpp/io/basic ios/clear]]
[[pt:cpp/io/basic ios/clear]]
[[ru:cpp/io/basic ios/clear]]
[[zh:cpp/io/basic ios/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/copyfmt</title>
    <ns>0</ns>
    <id>505</id>
    <revision>
      <id>66910</id>
      <parentid>64159</parentid>
      <timestamp>2014-01-07T13:39:15Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <comment>Corrected minor misspellings</comment>
      <text xml:space="preserve" bytes="2259">{{cpp/io/basic_ios/title | copyfmt}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 
basic_ios&amp; copyfmt(const basic_ios&amp; other);
}}
{{dcl end}}

Copies the state of the stream {{tt|other}} into {{c|*this}}. This is done in the following sequence:

@1@ Calls every callback registered by {{lc|register_callback()}} passing {{ltt|cpp/io/ios_base/event | erase_event}} as parameter

@2@ Copies all member objects from {{tt|other}} to {{c|*this}} except for {{lc|rdstate()}}, the exception mask, and {{lc|rdbuf()}}. In particular, makes copies of the locale, the formatting flags, the contents of the arrays {{lc|std::ios_base::iword}} and {{lc|std::ios_base::pword}} (but not the {{tt|iword}} and {{tt|pword}} pointers themselves), the callbacks, and the tied stream.

@3@ Calls every callback registered by {{lc|register_callback()}} passing {{ltt|cpp/io/ios_base/event | copyfmt_event}} as parameter

@4@ Copies the exception mask from {{tt|other}} to {{c|*this}} as if by calling {{c|exceptions(other.exceptions())}}

===Parameters===
{{par begin}}
{{par | other | another stream to use as source}}
{{par end}}

===Return value===
{{c|*this}}

===Notes===
The second pass through the callbacks may be used to deep-copy the user-defined objects pointed to by the pointers in {{lc|std::ios_base::pword}}

{{tt|copyfmt()}} may be used to save and restore the state of a stream. Boost provides a more fine-grained [http://www.boost.org/doc/libs/release/libs/io/doc/ios_state.html IO state savers] library for the same purpose.

===Example===
{{example
 | makes the ofstream object &quot;out&quot; behave exactly like std::cout, including formatting, tie() to std::cin, etc.
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;

int main()
{
    std::ofstream out;

    out.copyfmt(std::cout); // copy everything except rdstate and rdbuf
    out.clear(std::cout.rdstate()); // copy rdstate
    out.basic_ios&lt;char&gt;::rdbuf(std::cout.rdbuf()); // share the buffer

    out &lt;&lt; &quot;Hello, world\n&quot;;
}
 | output=
Hello, world
}}

[[de:cpp/io/basic ios/copyfmt]]
[[es:cpp/io/basic ios/copyfmt]]
[[fr:cpp/io/basic ios/copyfmt]]
[[it:cpp/io/basic ios/copyfmt]]
[[ja:cpp/io/basic ios/copyfmt]]
[[pt:cpp/io/basic ios/copyfmt]]
[[ru:cpp/io/basic ios/copyfmt]]
[[zh:cpp/io/basic ios/copyfmt]]</text>
      <sha1>eifoe3wcc6aewpi341ytgwgkbwvz4ba</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/eof</title>
    <ns>0</ns>
    <id>506</id>
    <revision>
      <id>63875</id>
      <parentid>57604</parentid>
      <timestamp>2013-07-29T20:28:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to the list of conditions that set eofbit</comment>
      <text xml:space="preserve" bytes="1415">{{cpp/io/basic_ios/title | eof}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
bool eof() const;
}}
{{dcl end}}

Returns {{c|true}} if the associated stream has reached end-of-file. Specifically, returns {{c|true}} if {{tt|eofbit}} is set in {{c|rdstate()}}.

See {{l2tt|cpp/io/ios_base/iostate}} for the list of conditions that set {{tt|eofbit}}.

===Parameters===
(none)

===Return value===
{{c|true}} if an end-of-file has occurred, {{c|false}} otherwise.

===Notes===
This function only reports the stream state as set by the most recent I/O operation, it does not examine the associated data source. For example, if the most recent I/O was a {{tt|get()}}, which returned the last byte of a file, {{tt|eof()}} returns {{c|false}}. The next {{tt|get()}} fails to read anything and sets the {{tt|eofbit}}. Only then {{tt|eof()}} returns {{c|true}}.

In typical usage, input stream processing stops on any error; {{tt|eof()}} and {{c|fail()}} are then used to distinguish between different error conditions.

===Example===
{{example template|cpp/io/basic_ios/example1}}

===See also===
{{cpp/io/basic ios/iostate accessors}}
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc feof}}
{{dsc end}}

[[de:cpp/io/basic ios/eof]]
[[es:cpp/io/basic ios/eof]]
[[fr:cpp/io/basic ios/eof]]
[[it:cpp/io/basic ios/eof]]
[[ja:cpp/io/basic ios/eof]]
[[pt:cpp/io/basic ios/eof]]
[[ru:cpp/io/basic ios/eof]]
[[zh:cpp/io/basic ios/eof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/exceptions</title>
    <ns>0</ns>
    <id>5224</id>
    <revision>
      <id>62359</id>
      <parentid>49631</parentid>
      <timestamp>2013-06-27T00:47:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+desc</comment>
      <text xml:space="preserve" bytes="1207">{{cpp/io/basic_ios/title | exceptions}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num=1 |
std::ios_base::iostate exceptions() const;
}}
{{dcl | num=2 |
void exceptions( std::ios_base::iostate except );
}}
{{dcl end}}

Gets and sets the exception mask of the stream. The exception mask determines the error states, on occurrence of which the stream throws exception of type {{lc|failure}}. 

@1@ Returns the exception mask.

@2@ Sets the exception mask to {{tt|except}}.

===Parameters===
{{par begin}}
{{par | except | exception mask}}
{{par end}}

===Return value===
@1@ The current exception mask.

@2@ (none)

===Example===
{{example | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;

int main() 
{
    int ivalue;
    try {
        std::ifstream in(&quot;in.txt&quot;);
        in.exceptions(std::ifstream::failbit);
        in &gt;&gt; ivalue;
    } catch (std::ios_base::failure &amp;fail) {
        // handle exception here
    }
}
}}

[[de:cpp/io/basic ios/exceptions]]
[[es:cpp/io/basic ios/exceptions]]
[[fr:cpp/io/basic ios/exceptions]]
[[it:cpp/io/basic ios/exceptions]]
[[ja:cpp/io/basic ios/exceptions]]
[[pt:cpp/io/basic ios/exceptions]]
[[ru:cpp/io/basic ios/exceptions]]
[[zh:cpp/io/basic ios/exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/fail</title>
    <ns>0</ns>
    <id>507</id>
    <revision>
      <id>64160</id>
      <parentid>63873</parentid>
      <timestamp>2013-08-15T14:54:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="910">{{cpp/io/basic_ios/title | fail}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
bool fail() const;
}}
{{dcl end}}

Returns {{c|true}} if an error has occurred on the associated stream. Specifically, returns {{c|true}} if {{tt|badbit}} or {{tt|failbit}} is set in {{lc|rdstate()}}. 

See {{l2tt|cpp/io/ios_base/iostate}} for the list of conditions that set {{tt|failbit}} or {{tt|badbit}}.

===Parameters===
(none)

===Return value===
{{c|true}} if an error has occurred, {{c|false}} otherwise.

===Example===
{{example template|cpp/io/basic_ios/example1}}

===See also===
{{cpp/io/basic ios/iostate accessors}}
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc ferror}}
{{dsc end}}

[[de:cpp/io/basic ios/fail]]
[[es:cpp/io/basic ios/fail]]
[[fr:cpp/io/basic ios/fail]]
[[it:cpp/io/basic ios/fail]]
[[ja:cpp/io/basic ios/fail]]
[[pt:cpp/io/basic ios/fail]]
[[ru:cpp/io/basic ios/fail]]
[[zh:cpp/io/basic ios/fail]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/fill</title>
    <ns>0</ns>
    <id>508</id>
    <revision>
      <id>49633</id>
      <parentid>44090</parentid>
      <timestamp>2013-06-01T02:49:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="843">{{cpp/io/basic_ios/title | fill}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num=1 |
CharT fill() const;
}}
{{dcl | num=2 |
CharT fill( CharT ch );
}}
{{dcl end}}

Manages the fill character used to pad the output conversions to the specified field width.

1) returns the current fill character

2) sets the fill character to {{tt|ch}}, returns previous value of the fill character 

===Parameters===
{{par begin}}
{{par | ch | the character to use as fill character}}
{{par end}}

===Return value===
the fill character before the call to the function.

===Example===
{{example
 |
 | code=
 | output=
}}

[[de:cpp/io/basic ios/fill]]
[[es:cpp/io/basic ios/fill]]
[[fr:cpp/io/basic ios/fill]]
[[it:cpp/io/basic ios/fill]]
[[ja:cpp/io/basic ios/fill]]
[[pt:cpp/io/basic ios/fill]]
[[ru:cpp/io/basic ios/fill]]
[[zh:cpp/io/basic ios/fill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/good</title>
    <ns>0</ns>
    <id>509</id>
    <revision>
      <id>63874</id>
      <parentid>49634</parentid>
      <timestamp>2013-07-29T20:27:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to the list of conditions that set bits</comment>
      <text xml:space="preserve" bytes="828">{{cpp/io/basic_ios/title | good}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
bool good() const;
}}
{{dcl end}}

Returns {{c|true}} if the the most recent I/O operation on the stream completed successfully. Specifically, returns result of {{c|rdstate() {{==}} 0}}. 

See {{l2tt|cpp/io/ios_base/iostate}} for the list of conditions that set the stream status bits.

===Parameters===
(none)

===Return value===
{{c|true}} if the stream has no errors occurred, {{c|false}} otherwise.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{cpp/io/basic ios/iostate accessors}}

[[de:cpp/io/basic ios/good]]
[[es:cpp/io/basic ios/good]]
[[fr:cpp/io/basic ios/good]]
[[it:cpp/io/basic ios/good]]
[[ja:cpp/io/basic ios/good]]
[[pt:cpp/io/basic ios/good]]
[[ru:cpp/io/basic ios/good]]
[[zh:cpp/io/basic ios/good]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/imbue</title>
    <ns>0</ns>
    <id>5471</id>
    <revision>
      <id>67265</id>
      <parentid>66259</parentid>
      <timestamp>2014-01-31T15:07:05Z</timestamp>
      <contributor>
        <ip>91.223.202.5</ip>
      </contributor>
      <comment>fix return type</comment>
      <text xml:space="preserve" bytes="1138">{{cpp/io/basic_ios/title|imbue}}
{{cpp/io/basic_ios/navbar}}
{{ddcl |
std::locale imbue( const std::locale&amp; loc );
}}

Replaces the current locale. Effectively calls {{c|ios_base::imbue(loc)}} and if there is an associated stream buffer ({{c|rdbuf() !{{=}} 0}}), then calls {{c|rdbuf()-&gt;pubimbue(loc)}}.

===Parameters===
{{par begin}}
{{par | loc | the new locale}}
{{par end}}

===Return value===
The previous locale, as returned by {{c|ios_base::imbue(loc)}}.

===Exceptions===
(none)

===Example===
{{example|
|code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
 
int main()
{
    std::istringstream iss;
    iss.imbue(std::locale(&quot;en_US.UTF8&quot;));
    
    std::cout &lt;&lt; &quot;Current locale: &quot; &lt;&lt; iss.getloc().name() &lt;&lt; '\n';
    
    iss.imbue(std::locale());
    std::cout &lt;&lt; &quot;Global locale : &quot; &lt;&lt; iss.getloc().name() &lt;&lt; '\n';
}
|output=
Current locale: en_US.UTF8
Global locale : C
}}

[[de:cpp/io/basic ios/imbue]]
[[es:cpp/io/basic ios/imbue]]
[[fr:cpp/io/basic ios/imbue]]
[[it:cpp/io/basic ios/imbue]]
[[ja:cpp/io/basic ios/imbue]]
[[pt:cpp/io/basic ios/imbue]]
[[ru:cpp/io/basic ios/imbue]]
[[zh:cpp/io/basic ios/imbue]]</text>
      <sha1>mizhflub6cpfug7i2c47ghjxflzft46</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/init</title>
    <ns>0</ns>
    <id>5535</id>
    <revision>
      <id>64263</id>
      <parentid>57608</parentid>
      <timestamp>2013-08-15T16:09:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1767">{{cpp/io/basic_ios/title | init}}
{{cpp/io/basic_ios/navbar}}
{{ddcl |
protected:
void init( std::basic_streambuf&lt;CharT,Traits&gt;* sb );
}}

Sets the associated stream buffer to {{tt|sb}} and initializes the internal state.

The postconditions are as follows:

{| class=&quot;wikitable&quot;
|-
! Element
! Value
|-
| {{lc|rdbuf()}} || {{tt|sb}}
|-
| {{lc|tie()}} || {{lc|NULL}}
|-
| {{lc|rdstate()}} || {{tt|goodbit}} if {{tt|sb}} is not {{lc|NULL}}, otherwise {{tt|badbit}}
|-
| {{lc|exceptions()}} || {{tt|goodbit}}
|-
| {{ltf|cpp/io/ios_base/flags}} || {{c|skipws {{!}} dec}}
|-
| {{ltf|cpp/io/ios_base/width}} || {{c|0}}
|-
| {{ltf|cpp/io/ios_base/precision}} || {{c|6}}
|-
| {{lc|fill()}} || {{c|widen(' ')}}
|-
| {{ltf|cpp/io/ios_base/getloc}} || a copy of the value returned by {{c|std::locale()}}
|}

This member function is protected: it is called by the constructors of the derived stream classes {{lc|std::basic_istream}} and {{lc|std::basic_ostream}} once the associated stream buffer is known. Until this function is called, every member function (other than the destructor) of the default-constructed {{lc|std::basic_ios}} invokes undefined behavior. Note that {{tt|basic_ios}} is a virtual base class, and therefore its constructor is not called by the constructors of those directly derived classes, which is why two-stage initialization is necessary.

===Parameters===
{{par begin}}
{{par | sb | stream buffer to associate to}}
{{par end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc constructor}}
{{dsc end}}

[[de:cpp/io/basic ios/init]]
[[es:cpp/io/basic ios/init]]
[[fr:cpp/io/basic ios/init]]
[[it:cpp/io/basic ios/init]]
[[ja:cpp/io/basic ios/init]]
[[pt:cpp/io/basic ios/init]]
[[ru:cpp/io/basic ios/init]]
[[zh:cpp/io/basic ios/init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/move</title>
    <ns>0</ns>
    <id>8762</id>
    <revision>
      <id>64308</id>
      <parentid>62728</parentid>
      <timestamp>2013-08-15T16:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1341">{{cpp/io/basic_ios/title|move}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
protected:
void move( basic_ios&amp; other );
}}
{{dcl | since=c++11 |
protected:
void move( basic_ios&amp;&amp; other );
}}
{{dcl end}}

Replaces the current state with that of {{tt|other}}, except for the associated {{tt|rdbuf}}. {{tt|other}} is in valid, but unspecified state after the call. After the call to this function, {{lc|rdbuf()}} returns {{lc|NULL}}, and {{c|other.rdbuf()}} returns the same value as before the call.

This member function is protected: it is called by the protected move constructors of the derived stream classes {{lc|std::basic_ostream}} and {{lc|std::basic_istream}}, which, in turn, are called by the public move constructors of the further derived stream classes such as {{lc|std::basic_ofstream}}, which know how to correctly move the associated streambuffer.


===Parameters===
{{par begin}}
{{par | other | the {{tt|basic_ios}} object to transfer the state from}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc swap}}
{{dsc end}}

[[de:cpp/io/basic ios/move]]
[[es:cpp/io/basic ios/move]]
[[fr:cpp/io/basic ios/move]]
[[it:cpp/io/basic ios/move]]
[[ja:cpp/io/basic ios/move]]
[[pt:cpp/io/basic ios/move]]
[[ru:cpp/io/basic ios/move]]
[[zh:cpp/io/basic ios/move]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/narrow</title>
    <ns>0</ns>
    <id>5483</id>
    <revision>
      <id>57612</id>
      <parentid>49638</parentid>
      <timestamp>2013-06-01T05:57:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1157">{{cpp/io/basic_ios/title | narrow}}
{{cpp/io/basic_ios/navbar}}
{{ddcl |
char narrow( char_type c, char dfault ) const;
}}

Converts a current locale-specific character {{tt|c}} to its standard equivalent. The result is converted from {{tt|char_type}} to {{tt|char}} if needed. If no conversion can be performed, the function returns {{tt|dfault}}.

Effectively calls {{c|std::use_facet&lt; std::ctype&lt;char_type&gt; &gt;(getloc()).narrow(c, dfault);}}.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par | dfault | character to return if the conversion was unsuccessful}}
{{par end}}

===Return value===
Character converted to its standard equivalent and then to {{c|char}}. {{tt|dfault}} is returned if the conversion fails.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc widen}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc inc | cpp/string/multibyte/dsc wctob}}
{{dsc end}}

[[de:cpp/io/basic ios/narrow]]
[[es:cpp/io/basic ios/narrow]]
[[fr:cpp/io/basic ios/narrow]]
[[it:cpp/io/basic ios/narrow]]
[[ja:cpp/io/basic ios/narrow]]
[[pt:cpp/io/basic ios/narrow]]
[[ru:cpp/io/basic ios/narrow]]
[[zh:cpp/io/basic ios/narrow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/operator!</title>
    <ns>0</ns>
    <id>510</id>
    <revision>
      <id>49639</id>
      <parentid>44059</parentid>
      <timestamp>2013-06-01T02:49:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="791">{{cpp/io/basic_ios/title | operator!}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
bool operator!() const;
}}
{{dcl end}}

Returns {{c|true}} if an error has occurred on the associated stream. Specifically, returns {{c|true}} if {{tt|badbit}} or {{tt|failbit}} is set in {{c|rdstate()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if an error has occurred, {{c|false}} otherwise.

===Example===
{{example template|cpp/io/basic_ios/example1}}

===See also===
{{cpp/io/basic ios/iostate accessors}}

[[de:cpp/io/basic ios/operator!]]
[[es:cpp/io/basic ios/operator!]]
[[fr:cpp/io/basic ios/operator!]]
[[it:cpp/io/basic ios/operator!]]
[[ja:cpp/io/basic ios/operator!]]
[[pt:cpp/io/basic ios/operator!]]
[[ru:cpp/io/basic ios/operator!]]
[[zh:cpp/io/basic ios/operator!]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/operator bool</title>
    <ns>0</ns>
    <id>511</id>
    <revision>
      <id>66987</id>
      <parentid>62379</parentid>
      <timestamp>2014-01-15T15:05:54Z</timestamp>
      <contributor>
        <username>Goldfish</username>
        <id>2792</id>
      </contributor>
      <minor/>
      <comment>A few very minor typo fixes &amp; grammar tweaks.</comment>
      <text xml:space="preserve" bytes="1762">{{cpp/io/basic_ios/title | operator bool}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num=1 | until=c++11 |
operator void*() const;
}}
{{dcl | num=2 | since=c++11 |
explicit operator bool() const;
}}
{{dcl end}}

Checks whether the stream has no errors. 

@1@ Returns a null pointer if {{c|fail()}} returns {{c|true}}, otherwise returns a non-null pointer. This pointer is implicitly convertible to {{c|bool}} and may be used in boolean contexts.

@2@ Returns {{c|true}} if the stream has no errors and is ready for I/O operations. Specifically, returns {{c|!fail()}}. 

This operator makes it possible to use streams and functions that return references to streams as loop conditions, resulting in the idiomatic C++ input loops such as {{c|while(stream &gt;&gt; value) {...} }} or {{c|while(getline(stream, string)){...} }}. Such loops execute the loop's body only if the input operation succeeded.

===Parameters===
(none)

===Return value===
{{c|true}} if the stream has no errors, {{c|false}} otherwise.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::istringstream s(&quot;1 2 3 error&quot;);
    int n;
    std::cout &lt;&lt; std::boolalpha &lt;&lt; &quot;(bool)s is &quot; &lt;&lt; (bool)s &lt;&lt; '\n';
    while (s &gt;&gt; n) {
        std::cout &lt;&lt; n &lt;&lt; '\n';
    }
    std::cout &lt;&lt; std::boolalpha &lt;&lt; &quot;(bool)s is &quot; &lt;&lt; (bool)s &lt;&lt; '\n';
}
 | output=
(bool)s is true
1
2
3
(bool)s is false
}}

===See also===
{{cpp/io/basic ios/iostate accessors}}

[[de:cpp/io/basic ios/operator bool]]
[[es:cpp/io/basic ios/operator bool]]
[[fr:cpp/io/basic ios/operator bool]]
[[it:cpp/io/basic ios/operator bool]]
[[ja:cpp/io/basic ios/operator bool]]
[[pt:cpp/io/basic ios/operator bool]]
[[ru:cpp/io/basic ios/operator bool]]
[[zh:cpp/io/basic ios/operator bool]]</text>
      <sha1>ar4obp3dz2kplcsyha38fow0ow58p20</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/rdbuf</title>
    <ns>0</ns>
    <id>5529</id>
    <revision>
      <id>66636</id>
      <parentid>65388</parentid>
      <timestamp>2013-12-18T08:38:57Z</timestamp>
      <contributor>
        <ip>212.71.19.37</ip>
      </contributor>
      <text xml:space="preserve" bytes="1906">{{cpp/io/basic_ios/title|rdbuf}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num = 1 |
std::basic_streambuf&lt;CharT, Traits&gt;* rdbuf() const;
}}
{{dcl | num = 2 |
std::basic_streambuf&lt;CharT, Traits&gt;* rdbuf( std::basic_streambuf&lt;CharT, Traits&gt;* sb );
}}
{{dcl end}}

Manages the associated stream buffer.

@1@ Returns the associated stream buffer. If there is no associated stream buffer, returns {{lc|NULL}}.

@2@ Sets the associated stream buffer to {{tt|sb}}. The error state is cleared by calling {{c|clear()}}. Returns the associated stream buffer before the operation. If there is no associated stream buffer, returns {{lc|NULL}}.

===Parameters===
{{par begin}}
{{par | sb | stream buffer to associate to}}
{{par end}}

===Return value===
The associated stream buffer, or {{lc|NULL}} if there was no associated stream buffer.

===Exceptions===
(none)

===Example===
{{example|
|code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::ostringstream local;
    auto cout_buff = std::cout.rdbuf(); // save pointer to std::cout buffer

    std::cout.rdbuf(local.rdbuf()); // substitute internal std::cout buffer with
        // buffer of 'local' object

    // now std::cout work with 'local' buffer
    // you don't see this message
    std::cout &lt;&lt; &quot;some message&quot;;

    // go back to old buffer
    std::cout.rdbuf(cout_buff);

    // you will see this message
    std::cout &lt;&lt; &quot;back to default buffer\n&quot;;

    // print 'local' content
    std::cout &lt;&lt; &quot;local content: &quot; &lt;&lt; local.str() &lt;&lt; &quot;\n&quot;;
}
|output=
back to default buffer
local content: some message
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc set_rdbuf}}
{{dsc end}}

[[de:cpp/io/basic ios/rdbuf]]
[[es:cpp/io/basic ios/rdbuf]]
[[fr:cpp/io/basic ios/rdbuf]]
[[it:cpp/io/basic ios/rdbuf]]
[[ja:cpp/io/basic ios/rdbuf]]
[[pt:cpp/io/basic ios/rdbuf]]
[[ru:cpp/io/basic ios/rdbuf]]
[[zh:cpp/io/basic ios/rdbuf]]</text>
      <sha1>c63rcshmbdho3fntlkzeofff41reepp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/rdstate</title>
    <ns>0</ns>
    <id>512</id>
    <revision>
      <id>65243</id>
      <parentid>65242</parentid>
      <timestamp>2013-09-05T12:27:35Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>I want to show, that there is no other bits (unlike when you, for example, reading file by getline)</comment>
      <text xml:space="preserve" bytes="1227">{{cpp/io/basic_ios/title | rdstate}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 1=
iostate rdstate() const;
}}
{{dcl end}}

Returns the current stream error state.

===Parameters===
(none)

===Return value===
current stream error state. It is a bitmask type and can be a combination of the following constants:
{{cpp/io/ios_base/iostate consts}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
  std::ostringstream stream;

  if (stream.rdstate() == std::ios_base::goodbit) {
    std::cout &lt;&lt; &quot;stream state is goodbit\n&quot;;
  }

  stream.setstate(std::ios_base::eofbit);

  // check state is exactly eofbit (no failbit and no badbit)
  if (stream.rdstate() == std::ios_base::eofbit) {
    std::cout &lt;&lt; &quot;stream state is eofbit\n&quot;;
  }
}
 | output=
stream state is goodbit
stream state is eofbit
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc setstate}}
{{dsc inc | cpp/io/basic_ios/dsc clear}}
{{dsc end}}

[[de:cpp/io/basic ios/rdstate]]
[[es:cpp/io/basic ios/rdstate]]
[[fr:cpp/io/basic ios/rdstate]]
[[it:cpp/io/basic ios/rdstate]]
[[ja:cpp/io/basic ios/rdstate]]
[[pt:cpp/io/basic ios/rdstate]]
[[ru:cpp/io/basic ios/rdstate]]
[[zh:cpp/io/basic ios/rdstate]]</text>
      <sha1>d1yqgo27ozca2xfnornnmz2007xle1t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/set rdbuf</title>
    <ns>0</ns>
    <id>5531</id>
    <revision>
      <id>66637</id>
      <parentid>57617</parentid>
      <timestamp>2013-12-18T08:41:31Z</timestamp>
      <contributor>
        <ip>212.71.19.37</ip>
      </contributor>
      <text xml:space="preserve" bytes="1236">{{cpp/io/basic_ios/title|set_rdbuf}}
{{cpp/io/basic_ios/navbar}}
{{ddcl |
protected:
void set_rdbuf( std::basic_streambuf&lt;CharT,Traits&gt;* sb );
}}

Sets the associated stream buffer to {{tt|sb}} without clearing the error state.

This member function is protected: it is called by the move constructors of the derived streams such as {{lc|std::basic_ofstream}} or {{lc|std::basic_istringstream}}, as the final step after constructing the base class and after moving the stream buffer: only the most derived stream class knows how to correctly move the stream buffer, but {{lc|std::basic_ios}} needs to be made aware of the stream's new location so that its public member functions can access it.

===Parameters===
{{par begin}}
{{par | sb | stream buffer to associate to}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example|
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc rdbuf}}
{{dsc end}}

[[de:cpp/io/basic ios/set rdbuf]]
[[es:cpp/io/basic ios/set rdbuf]]
[[fr:cpp/io/basic ios/set rdbuf]]
[[it:cpp/io/basic ios/set rdbuf]]
[[ja:cpp/io/basic ios/set rdbuf]]
[[pt:cpp/io/basic ios/set rdbuf]]
[[ru:cpp/io/basic ios/set rdbuf]]
[[zh:cpp/io/basic ios/set rdbuf]]</text>
      <sha1>nnot8snzm98fawdjv2tjbmct77razjb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/setstate</title>
    <ns>0</ns>
    <id>513</id>
    <revision>
      <id>67268</id>
      <parentid>65239</parentid>
      <timestamp>2014-02-01T00:47:16Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1373">{{cpp/io/basic_ios/title | setstate}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | 
void setstate( iostate state );
}}
{{dcl end}}

Sets the stream error flags {{tt|state}} in addition to currently set flags. Essentially calls {{c|clear(rdstate() {{!}} state)}}. May throw an exception.

===Parameters===
{{par begin}}
{{par | state | stream error state flags to set. It can be a combination of the following constants:
{{cpp/io/ios_base/iostate consts}}
}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::ostringstream stream;

    if (!stream.fail()) {
        std::cout &lt;&lt; &quot;stream is not fail\n&quot;;
    }

    stream.setstate(std::ios_base::failbit);

    if (stream.fail()) {
        std::cout &lt;&lt; &quot;now stream is fail\n&quot;;
    }

    if (!stream.good()) {
        std::cout &lt;&lt; &quot;and stream is not good\n&quot;;
    }
}
 | output=
stream is not fail
now stream is fail
and stream is not good
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc rdstate}}
{{dsc inc | cpp/io/basic_ios/dsc clear}}
{{dsc end}}

[[de:cpp/io/basic ios/setstate]]
[[es:cpp/io/basic ios/setstate]]
[[fr:cpp/io/basic ios/setstate]]
[[it:cpp/io/basic ios/setstate]]
[[ja:cpp/io/basic ios/setstate]]
[[pt:cpp/io/basic ios/setstate]]
[[ru:cpp/io/basic ios/setstate]]
[[zh:cpp/io/basic ios/setstate]]</text>
      <sha1>hbf5eycuu0tzx1lggo4lrq93pu3ntpo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/swap</title>
    <ns>0</ns>
    <id>8763</id>
    <revision>
      <id>64305</id>
      <parentid>63322</parentid>
      <timestamp>2013-08-15T16:28:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1043">{{cpp/io/basic_ios/title|swap}}
{{cpp/io/basic_ios/navbar}}
{{ddcl | since=c++11 |
protected:
void swap( basic_ios&amp; other );
}}

Exchanges the states of {{c|*this}} and {{tt|other}}, except for the associated {{tt|rdbuf}} objects. {{lc|rdbuf()}} and {{c|other.rdbuf()}} returns the same values as before the call.

This swap function is protected: it is called by the swap member functions of the derived stream classes such as {{lc|std::basic_ofstream}} or {{lc|std::basic_istringstream}}, which know how to correctly swap the associated streambuffers.

===Parameters===
{{par begin}}
{{par | other | the {{tt|basic_ios}} object to exchange the state with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc move}}
{{dsc end}}

[[de:cpp/io/basic ios/swap]]
[[es:cpp/io/basic ios/swap]]
[[fr:cpp/io/basic ios/swap]]
[[it:cpp/io/basic ios/swap]]
[[ja:cpp/io/basic ios/swap]]
[[pt:cpp/io/basic ios/swap]]
[[ru:cpp/io/basic ios/swap]]
[[zh:cpp/io/basic ios/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/tie</title>
    <ns>0</ns>
    <id>5528</id>
    <revision>
      <id>67180</id>
      <parentid>67179</parentid>
      <timestamp>2014-01-25T16:42:55Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1875">{{cpp/io/basic_ios/title|tie}}
{{cpp/io/basic_ios/navbar}}
{{dcl begin}}
{{dcl | num = 1 |
std::basic_ostream&lt;CharT,Traits&gt;* tie() const;
}}
{{dcl | num = 2 |
std::basic_ostream&lt;CharT,Traits&gt;* tie( std::basic_ostream&lt;CharT,Traits&gt;* str );
}}
{{dcl end}}

Manages the tied stream. A tied stream is an output stream which is synchronized with the sequence controlled by the stream buffer ({{lc|rdbuf()}}), that is, {{c|flush()}} is called on the tied stream before any input/output operation on {{c|*this}}.

@1@ Returns the current tied stream. If there is no tied stream, {{lc|NULL}} is returned.

@2@ Sets the current tied stream to {{tt|str}}. Returns the tied stream before the operation. If there is no tied stream, {{lc|NULL}} is returned.

===Parameters===
{{par begin}}
{{par | str | an output stream to set as the tied stream}}
{{par end}}

===Return value===
The tied stream, or {{lc|NULL}} if there was no tied stream.

===Exceptions===
(none)

===Notes===
By default, the standard streams {{tt|cin}}, {{tt|cerr}} and {{tt|clog}} are tied to {{tt|cout}}. Similarly, their wide counterparts {{tt|wcin}}, {{tt|wcerr}} and {{tt|wclog}} are tied to {{tt|wcout}}.

===Example===
{{example|
|code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;string&gt;

int main()
{
    std::ofstream os(&quot;test.txt&quot;);
    std::ifstream is(&quot;test.txt&quot;);
    std::string value(&quot;0&quot;);

    os &lt;&lt; &quot;Hello&quot;;
    is &gt;&gt; value;

    std::cout &lt;&lt; &quot;Result before tie(): \&quot;&quot; &lt;&lt; value &lt;&lt; &quot;\&quot;\n&quot;;
    is.clear();
    is.tie(&amp;os);

    is &gt;&gt; value;

    std::cout &lt;&lt; &quot;Result after tie(): \&quot;&quot; &lt;&lt; value &lt;&lt; &quot;\&quot;\n&quot;;
}
|output=
Result before tie(): &quot;0&quot;
Result after tie(): &quot;Hello&quot;
}}

[[de:cpp/io/basic ios/tie]]
[[es:cpp/io/basic ios/tie]]
[[fr:cpp/io/basic ios/tie]]
[[it:cpp/io/basic ios/tie]]
[[ja:cpp/io/basic ios/tie]]
[[pt:cpp/io/basic ios/tie]]
[[ru:cpp/io/basic ios/tie]]
[[zh:cpp/io/basic ios/tie]]</text>
      <sha1>n9ykmvan3k2emaosbm23zsvcub8l1w3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/widen</title>
    <ns>0</ns>
    <id>5484</id>
    <revision>
      <id>69915</id>
      <parentid>57622</parentid>
      <timestamp>2014-05-01T14:18:52Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>make use of [[Template:cpp/locale/ctype/dsc do_widen]]</comment>
      <text xml:space="preserve" bytes="909">{{cpp/io/basic_ios/title | widen}}
{{cpp/io/basic_ios/navbar}}
{{ddcl |
char_type widen( char c ) const;
}}

Converts a character {{tt|c}} to its equivalent in the current locale. The result is converted from {{c|char}} to character type used within the stream if needed.

Effectively calls {{c|std::use_facet&lt; std::ctype&lt;char_type&gt; &gt;(getloc()).widen(c)}}.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par end}}

===Return value===
Character converted to {{tt|char_type}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc narrow}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc inc | cpp/string/multibyte/dsc btowc}}
{{dsc end}}

[[de:cpp/io/basic ios/widen]]
[[es:cpp/io/basic ios/widen]]
[[fr:cpp/io/basic ios/widen]]
[[it:cpp/io/basic ios/widen]]
[[ja:cpp/io/basic ios/widen]]
[[pt:cpp/io/basic ios/widen]]
[[ru:cpp/io/basic ios/widen]]
[[zh:cpp/io/basic ios/widen]]</text>
      <sha1>j419vv3hs6iftx37mm3066exvfho903</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ios/~basic ios</title>
    <ns>0</ns>
    <id>514</id>
    <revision>
      <id>63797</id>
      <parentid>46906</parentid>
      <timestamp>2013-07-25T17:14:11Z</timestamp>
      <contributor>
        <username>MooingDuck</username>
        <id>2242</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="617">{{cpp/io/basic_ios/title | ~basic_ios}}
{{cpp/io/basic_ios/navbar}}
{{ddcl | 
virtual ~basic_ios();
}}

Destroys the {{tt|basic_ios}} object. No operations on {{tt|rdbuf}} are performed, it is not destroyed.

===Notes===
This destructor is {{tt|virtual}} because the base class destructor, {{l2tt|cpp/io/ios_base/~ios_base}} is virtual.

[[de:cpp/io/basic ios/~basic ios]]
[[es:cpp/io/basic ios/~basic ios]]
[[fr:cpp/io/basic ios/~basic ios]]
[[it:cpp/io/basic ios/~basic ios]]
[[ja:cpp/io/basic ios/~basic ios]]
[[pt:cpp/io/basic ios/~basic ios]]
[[ru:cpp/io/basic ios/~basic ios]]
[[zh:cpp/io/basic ios/~basic ios]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic iostream</title>
    <ns>0</ns>
    <id>515</id>
    <revision>
      <id>57625</id>
      <parentid>49648</parentid>
      <timestamp>2013-06-01T05:57:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1760">{{cpp/title|basic_iostream}}
{{cpp/io/basic_iostream/navbar}}
{{ddcl | header=istream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_iostream;
}}
The class template {{tt|basic_iostream}} provides support for high level input/output operations on streams. The supported operations include sequential reading or writing and formatting. This functionality is implemented over the interface, provided by the {{tt|basic_streambuf}} class. It is accessed through {{tt|basic_ios}} class.

{{inheritance diagram/std-basic_iostream}}

Two specializations for common character types are defined:

{{dsc begin}}
{{dsc header | istream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|iostream}} | {{c|basic_iostream&lt;char&gt;}}}}
{{dsc | {{tt|wiostream}} | {{c|basic_iostream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_iostream/dsc constructor}}
{{dsc inc | cpp/io/basic_iostream/dsc destructor}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_iostream/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_iostream/dsc swap}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic iostream]]
[[es:cpp/io/basic iostream]]
[[fr:cpp/io/basic iostream]]
[[it:cpp/io/basic iostream]]
[[ja:cpp/io/basic iostream]]
[[pt:cpp/io/basic iostream]]
[[ru:cpp/io/basic iostream]]
[[zh:cpp/io/basic iostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic iostream/basic iostream</title>
    <ns>0</ns>
    <id>8768</id>
    <revision>
      <id>62729</id>
      <parentid>57626</parentid>
      <timestamp>2013-07-01T23:34:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1945">{{cpp/io/basic_iostream/title|basic_iostream}}
{{cpp/io/basic_iostream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
explicit basic_iostream( std::basic_streambuf&lt;CharT,Traits&gt;* sb );
}}
{{dcl | num=2 | since=c++11 | 1=
basic_iostream( const basic_iostream&amp; other ) = delete;
}}
{{dcl | num=3 | since=c++11 | 1=
protected:
basic_iostream( basic_iostream&amp;&amp; other );
}}
{{dcl end}}

Constructs new stream object.

@1@ Initializes with streambuf {{tt|sb}}. The base classes are initialized as {{c|basic_istream&lt;CharT,Traits&gt;(sb)}} and {{c|basic_ostream&lt;CharT,Traits&gt;(sb)}}. After the call {{c|1=rdbuf() == sb}} and {{c|1=gcount() == 0}}.

@2@ Copy construction is not allowed.

@3@ Move constructor: move-constructs the first base class {{tt|basic_istream}} as {{c|basic_istream&lt;CharT,Traits&gt;(std::move(rhs));}}, which in turn move-constructs and initializes the virtual base {{lc|std::basic_ios}}. The initialization of the other base, {{tt|basic_ostream}}, is implementation-defined (e.g., a protected default constructor may be added to {{lc|std::basic_ostream}}, which does nothing) because move-construction cannot use {{tt|rhs}} twice. This move constructor is protected: it is called by the move constructors of the derived stream classes {{lc|std::basic_fstream}} and {{lc|std::basic_stringstream}} before they move-construct and associate the stream buffer.

===Parameters===
{{par begin}}
{{par | sb | streambuf to initialize with}}
{{par | other | another stream to initialize with}}
{{par end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_iostream/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/io/basic iostream/basic iostream]]
[[es:cpp/io/basic iostream/basic iostream]]
[[fr:cpp/io/basic iostream/basic iostream]]
[[it:cpp/io/basic iostream/basic iostream]]
[[ja:cpp/io/basic iostream/basic iostream]]
[[pt:cpp/io/basic iostream/basic iostream]]
[[ru:cpp/io/basic iostream/basic iostream]]
[[zh:cpp/io/basic iostream/basic iostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic iostream/operator=</title>
    <ns>0</ns>
    <id>8773</id>
    <revision>
      <id>62730</id>
      <parentid>57629</parentid>
      <timestamp>2013-07-01T23:34:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1223">{{cpp/io/basic_iostream/title|operator{{=}}}}
{{cpp/io/basic_iostream/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
basic_iostream&amp; operator=( const basic_iostream&amp; other ) = delete;
}}
{{dcl | num=2 | since=c++11 | 1=
protected:
basic_iostream&amp; operator=( basic_iostream&amp;&amp; other );
}}
{{dcl end}}

Assigns another stream object.

@1@ Copy assignment is not allowed.
@2@ Move assigns another stream object. Effectively calls {{c|swap(rhs)}}. This move assignment operator is protected: it is called by the move assignment operators of the derived stream classes {{lc|std::basic_stringstream}} and {{lc|std::basic_fstream}} which know how to properly move-assign the associated stream buffers.

===Parameters===
{{par begin}}
{{par | other | another stream to assign state of}}
{{par end}}

===Return value===
{{c|*this}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_iostream/dsc constructor}}
{{dsc end}}

[[de:cpp/io/basic iostream/operator=]]
[[es:cpp/io/basic iostream/operator=]]
[[fr:cpp/io/basic iostream/operator=]]
[[it:cpp/io/basic iostream/operator=]]
[[ja:cpp/io/basic iostream/operator=]]
[[pt:cpp/io/basic iostream/operator=]]
[[ru:cpp/io/basic iostream/operator=]]
[[zh:cpp/io/basic iostream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic iostream/swap</title>
    <ns>0</ns>
    <id>8774</id>
    <revision>
      <id>63323</id>
      <parentid>49651</parentid>
      <timestamp>2013-07-10T01:28:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="917">{{cpp/io/basic_iostream/title|swap}}
{{cpp/io/basic_iostream/navbar}}
{{ddcl | since=c++11 | 1=
protected:
void swap( basic_iostream&amp; other );
}}

Exchanges the state with another input/output stream object. Effectively calls {{c|basic_istream&lt;CharT,Traits&gt;::swap(other)}}.

This member function is protected: it is called by the swap member functions of the derived stream classes {{lc|std::basic_stringstream}} and {{lc|std::basic_fstream}}, which know how to correctly swap the associated stream buffers.


===Parameters===
{{par begin}}
{{par | other | another stream to exchange the state with}}
{{par end}}

===Return value===
{{c|*this}}

[[de:cpp/io/basic iostream/swap]]
[[es:cpp/io/basic iostream/swap]]
[[fr:cpp/io/basic iostream/swap]]
[[it:cpp/io/basic iostream/swap]]
[[ja:cpp/io/basic iostream/swap]]
[[pt:cpp/io/basic iostream/swap]]
[[ru:cpp/io/basic iostream/swap]]
[[zh:cpp/io/basic iostream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic iostream/~basic iostream</title>
    <ns>0</ns>
    <id>8772</id>
    <revision>
      <id>49652</id>
      <parentid>43987</parentid>
      <timestamp>2013-06-01T02:49:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="803">{{cpp/io/basic_iostream/title | ~basic_iostream}}
{{cpp/io/basic_iostream/navbar}}
{{ddcl |
virtual ~basic_iostream();
}}

Destructs the input/output stream.

===Notes===
This destructor does not perform any operation on the underlying stream buffer ({{tt|rdbuf()}}): the destructors of the derived streams such as {{lc|std::basic_fstream}} and {{lc|std::basic_stringstream}} are responsible for calling the destructors of the stream buffers.

[[de:cpp/io/basic iostream/~basic iostream]]
[[es:cpp/io/basic iostream/~basic iostream]]
[[fr:cpp/io/basic iostream/~basic iostream]]
[[it:cpp/io/basic iostream/~basic iostream]]
[[ja:cpp/io/basic iostream/~basic iostream]]
[[pt:cpp/io/basic iostream/~basic iostream]]
[[ru:cpp/io/basic iostream/~basic iostream]]
[[zh:cpp/io/basic iostream/~basic iostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream</title>
    <ns>0</ns>
    <id>516</id>
    <revision>
      <id>57630</id>
      <parentid>49653</parentid>
      <timestamp>2013-06-01T05:57:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3060">{{cpp/title|basic_istream}}
{{cpp/io/basic_istream/navbar}}
{{ddcl | header=istream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_istream : virtual public std::basic_ios&lt;CharT, Traits&gt;
}}

The class template {{tt|basic_istream}} provides support for high level input operations on character streams. The supported operations include formatted input (e.g. integer values or whitespace-separated characters and characters strings) and unformatted input (e.g. raw characters and character arrays). This functionality is implemented in terms of the interface provided by the underlying {{tt|basic_streambuf}} class, accessed through the {{tt|basic_ios}} base class. The only non-inherited data member of {{tt|basic_istream}}, in most implementations, is the value returned by {{ltt|cpp/io/basic_istream/gcount|basic_istream::gcount()}}.

{{inheritance diagram/std-basic_istream}}

Two specializations for common character types are defined:

{{dsc begin}}
{{dsc header | istream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|istream}} | {{c|basic_istream&lt;char&gt;}}}}
{{dsc | {{tt|wistream}} | {{c|basic_istream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Global objects===
Two global basic_istream objects are provided by the standard library.

{{dsc begin}}
{{dsc header | iostream}}
{{dsc inc | cpp/io/dsc cin}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc constructor}}
{{dsc inc | cpp/io/basic_istream/dsc destructor}}
{{dsc inc | cpp/io/basic_istream/dsc operator{{=}}}}

{{dsc h2 | Formatted input}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}

{{dsc h2 | Unformatted input}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc peek}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc inc | cpp/io/basic_istream/dsc getline}}
{{dsc inc | cpp/io/basic_istream/dsc ignore}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc inc | cpp/io/basic_istream/dsc gcount}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_istream/dsc tellg}}
{{dsc inc | cpp/io/basic_istream/dsc seekg}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/basic_istream/dsc sync}}
{{dsc inc | cpp/io/basic_istream/dsc swap}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc sentry}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc end}}

{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic istream]]
[[es:cpp/io/basic istream]]
[[fr:cpp/io/basic istream]]
[[it:cpp/io/basic istream]]
[[ja:cpp/io/basic istream]]
[[pt:cpp/io/basic istream]]
[[ru:cpp/io/basic istream]]
[[zh:cpp/io/basic istream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/basic istream</title>
    <ns>0</ns>
    <id>517</id>
    <revision>
      <id>70119</id>
      <parentid>70049</parentid>
      <timestamp>2014-05-10T11:13:03Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2168">{{cpp/io/basic_istream/title | basic_istream}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
explicit basic_istream( std::basic_streambuf&lt;CharT, Traits&gt;* sb);
}}
{{dcl | num=2 | since=c++11 |1=
protected:
basic_istream( const basic_istream&amp; rhs ) = delete;
}}
{{dcl | num=3 | since=c++11 |1=
protected:
basic_istream( basic_istream&amp;&amp; rhs );
}}
{{dcl end}}

1) Constructs the {{tt|basic_istream}} object, assigning initial values to the base class by calling {{c|basic_ios::init(sb)}}. The value of {{tt|gcount()}} is initialized to zero.

2) The copy constructor is protected, and is deleted. Input streams are not copyable.

3) The move constructor copies the value of {{tt|gcount()}} from {{tt|rhs}}, sets the gcount() value of rhs to zero, and uses {{tt|basic_ios&lt;CharT, Traits&gt;::move(rhs)}} to move all basic_ios members, except for the {{tt|rdbuf()}}, from {{tt|rhs}} into {{tt|*this}}. This move constructor is protected: it is called by the move constructors of movable input stream classes {{lc|std::basic_ifstream}} and {{lc|std::basic_istringstream}}, which know how to correctly move the associated stream buffer.

===Parameters===
{{par begin}}
{{par | sb | streambuffer to use as underlying device}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::istringstream s1(&quot;hello&quot;);
    std::istream s2(s1.rdbuf());                        // OK: s2 shares the buffer with s1

//    std::istream s3(std::istringstream(&quot;test&quot;));      // ERROR: move constructor is protected
//    std::istream s4(s2);                              // ERROR: copy constructor is deleted
    std::istringstream s5(std::istringstream(&quot;world&quot;)); // OK: move ctor called by derived class

    std::cout &lt;&lt; s2.rdbuf() &lt;&lt; ' ' &lt;&lt; s5.rdbuf() &lt;&lt; '\n';
}
| output=
hello world
}}

[[de:cpp/io/basic istream/basic istream]]
[[es:cpp/io/basic istream/basic istream]]
[[fr:cpp/io/basic istream/basic istream]]
[[it:cpp/io/basic istream/basic istream]]
[[ja:cpp/io/basic istream/basic istream]]
[[pt:cpp/io/basic istream/basic istream]]
[[ru:cpp/io/basic istream/basic istream]]
[[zh:cpp/io/basic istream/basic istream]]</text>
      <sha1>mlm2z41wb0wko4etjwlxqfyhozu951h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/gcount</title>
    <ns>0</ns>
    <id>518</id>
    <revision>
      <id>64368</id>
      <parentid>64357</parentid>
      <timestamp>2013-08-15T18:41:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1386">{{cpp/io/basic_istream/title | gcount}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl |
std::streamsize gcount() const;
}}
{{dcl end}}

Returns the number of characters extracted by the last unformatted input operation.

The following member functions of {{tt|basic_istream}} change the value of subsequent {{tt|gcount()}} calls:

* {{rlp|basic_istream|move constructor}}
* {{lc|swap()}}
* {{lc|get()}}
* {{lc|getline()}}
* {{lc|ignore()}}
* {{lc|read()}}
* {{lc|readsome()}}
* {{lc|operator&gt;&gt;|operator&gt;&gt;(basic_streambuf*)}}

The following functions set {{tt|gcount()}} to zero:

* {{rlp|basic_istream|constructor}}
* {{lc|putback()}}
* {{lc|unget()}}
* {{lc|peek()}}

===Parameters===
(none)

===Return value===
The number of characters extracted by the last unformatted input operation

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
 
int main()
{
    char x[20];
    std::istringstream stream(&quot;Hello World&quot;);
    
    stream.read(x, sizeof x);
    std::cout &lt;&lt; &quot;Characters extracted: &quot; &lt;&lt; stream.gcount();
}
 | output=Characters extracted: 11
}}

===See also===
{{todo}}

[[de:cpp/io/basic istream/gcount]]
[[es:cpp/io/basic istream/gcount]]
[[fr:cpp/io/basic istream/gcount]]
[[it:cpp/io/basic istream/gcount]]
[[ja:cpp/io/basic istream/gcount]]
[[pt:cpp/io/basic istream/gcount]]
[[ru:cpp/io/basic istream/gcount]]
[[zh:cpp/io/basic istream/gcount]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/get</title>
    <ns>0</ns>
    <id>519</id>
    <revision>
      <id>67055</id>
      <parentid>61999</parentid>
      <timestamp>2014-01-19T02:17:16Z</timestamp>
      <contributor>
        <username>SeizeF</username>
        <id>2420</id>
      </contributor>
      <minor/>
      <comment>indent bullets</comment>
      <text xml:space="preserve" bytes="4780">{{cpp/io/basic_istream/title | get}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
int_type get();
}}
{{dcl | num=2 |
basic_istream&amp; get( char_type&amp; ch );
}}
{{dcl | num=3 |
basic_istream&amp; get( char_type* s, std::streamsize count );
}}
{{dcl | num=4 |
basic_istream&amp; get( char_type* s, std::streamsize count, char_type delim );
}}
{{dcl | num=5 |
basic_istream&amp; get( basic_streambuf&amp; strbuf );
}}
{{dcl | num=6 |
basic_istream&amp; get( basic_streambuf&amp; strbuf, char_type delim );
}}
{{dcl end}}

Extracts character or characters from stream.

All versions behave as {{concept|UnformattedInputFunction}}s. After constructing and checking the sentry object, these functions perform the following:

@1@ Reads one character and returns it if available. Otherwise, returns {{c|Traits::eof()}} and sets {{lc|failbit}} and {{lc|eofbit}}.

@2@ Reads one character and stores it to {{tt|ch}} if available. Otherwise, leaves {{tt|ch}} unmodified and sets {{lc|failbit}} and {{lc|eofbit}}. Note that this function is not overloaded on the types {{c|signed char}} and {{c|unsigned char}}, unlike the formatted character input operator&gt;&gt;.

@3@ Same as {{c|get(s, count, widen('\n'))}}, that is, reads at most {{c|count-1}} characters and stores them into character string pointed to by {{tt|s}} until {{c|'\n'}} is found.

@4@ Reads characters and stores them into the successive locations of the character array whose first element is pointed to by {{tt|s}}. Characters are extracted and stored until any of the following occurs:

::* n-1 characters have been stored

::* end of file condition occurs in the input sequence ({{c|setstate(eofbit)}} is called)

::* the next available input character {{tt|c}} equals {{tt|delim}}, as determined by {{c|Traits::eq(c, delim)}}. This character is not extracted (unlike {{ltt|cpp/io/basic_istream/getline|basic_istream::getline()}})

@@ If no characters were extracted, calls {{c|setstate(failbit)}}. In any case, if {{tt|count&gt;0}}, a null character ({{c|CharT()}} is stored in the next successive location of the array.

@5@ same as {{c|get(strbuf, widen('\n'))}}, that is, reads available characters and inserts them to the given {{ltt|cpp/io/basic_streambuf}} object until {{c|'\n'}} is found.

@6@ reads characters and inserts them to the output sequence controlled by the given {{ltt|cpp/io/basic_streambuf}} object. Characters are extracted and inserted into {{tt|strbuf}} until any of the following occurs:

::* end of file condition occurs in the input sequence

::* insert into the output sequence fails (in which case the character that could not be inserted, is not extracted)

::* the next available input character {{tt|c}} equals {{tt|delim}}, as determined by {{c|Traits::eq(c, delim)}}. This character is not extracted.

::* an exception occurs (in which case the exception is caught and not rethrown)

@@ If no characters were extracted, calls {{c|setstate(failbit)}}. 

All versions set the value of {{lc|gcount()}} to the number of characters extracted.

===Parameters===
{{par begin}}
{{par | ch | reference to the character to write the result to}}
{{par | s | pointer to the character string to store the characters to}}
{{par | count | size of character string pointed to by {{tt|s}}}}
{{par | delim | delimiting character to stop the extraction at. It is not extracted and not stored.}}
{{par | strbuf | stream buffer to read the content to}}
{{par end}}

===Return value===
@1@ the extracted character or {{c|Traits::eof()}}

@2-6@ {{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::istringstream s1(&quot;Hello, world.&quot;);
    char c1 = s1.get(); // reads 'H'
    std::cout &lt;&lt; &quot;after reading &quot; &lt;&lt; c1 &lt;&lt; &quot;, gcount() == &quot; &lt;&lt;  s1.gcount() &lt;&lt; '\n';
    char c2;
    s1.get(c2);         // reads 'e'
    char str[5];
    s1.get(str, 5);     // reads &quot;llo,&quot;
    std::cout &lt;&lt; &quot;after reading &quot; &lt;&lt; str &lt;&lt; &quot;, gcount() == &quot; &lt;&lt;  s1.gcount() &lt;&lt; '\n';
    std::cout &lt;&lt; c1 &lt;&lt; c2 &lt;&lt; str;
    s1.get(*std::cout.rdbuf()); // reads the rest, not including '\n'
    std::cout &lt;&lt; &quot;\nAfter the last get(), gcount() == &quot; &lt;&lt; s1.gcount() &lt;&lt; '\n';
}

 | output=
after reading H, gcount() == 1
after reading llo,, gcount() == 4
Hello, world.
After the last get(), gcount() == 7

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc end}}

[[de:cpp/io/basic istream/get]]
[[es:cpp/io/basic istream/get]]
[[fr:cpp/io/basic istream/get]]
[[it:cpp/io/basic istream/get]]
[[ja:cpp/io/basic istream/get]]
[[pt:cpp/io/basic istream/get]]
[[ru:cpp/io/basic istream/get]]
[[zh:cpp/io/basic istream/get]]</text>
      <sha1>bh1e45xc3qf6p3es35uqlddcazevchx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/getline</title>
    <ns>0</ns>
    <id>520</id>
    <revision>
      <id>69048</id>
      <parentid>67208</parentid>
      <timestamp>2014-03-25T14:04:43Z</timestamp>
      <contributor>
        <ip>90.227.25.67</ip>
      </contributor>
      <comment>Fixed wrong types of quotes</comment>
      <text xml:space="preserve" bytes="3193">{{cpp/io/basic_istream/title | getline}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_istream&amp; getline( char_type* s, std::streamsize count );
}}
{{dcl | num=2 |
basic_istream&amp; getline( char_type* s, std::streamsize count, char_type delim );
}}
{{dcl end}}

Extracts characters from stream until end of line or the specified delimiter {{tt|delim}}.

The first version is equivalent to {{c|getline(s, count, widen('\n'))}}.

Behaves as {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, extracts characters from {{tt|*this}} and stored them in successive locations of the array whose first element is pointed to by {{tt|s}} until any of the following occurs: (tested in the order shown)

* end of file condition occurs in the input sequence (in which case {{c|setstate(eofbit)}} is executed)

* the next available character {{tt|c}} is the delimiter, as determined by {{c|Traits::eq(c, delim)}}. The delimiter is extracted (unlike {{ltt|cpp/io/basic_istream/get|basic_istream::get()}}) and counted towards {{tt|gcount()}}, but is not stored.

* {{c|count-1}} characters have been extracted (in which case {{c|setstate(failbit)}} is executed).

If the function extracts no characters (e.g. if {{c|count &lt; 1}}), {{c|setstate(failbit)}} is executed.

In any case, if {{tt|count&gt;0}}, it then stores a null character {{tt|CharT()}} into the next successive location of the array and updates {{tt|gcount()}}.

===Notes===
Because condition #2 is tested before condition #3, the input line that exactly fits the buffer does not trigger failbit.

Because the terminating character is counted as an extracted character, an empty input line does not trigger failbit.

===Parameters===
{{par begin}}
{{par | s | pointer to the character string to store the characters to}}
{{par | count | size of character string pointed to by {{tt|s}}}}
{{par | delim | delimiting character to stop the extraction at. It is extracted but not stored.}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;vector&gt;
#include &lt;array&gt;

int main()
{
    std::istringstream input(&quot;abc{{!}}def{{!}}gh&quot;);
    std::vector&lt;std::array&lt;char, 4&gt;&gt; v;

    // note: the following loop terminates when std::ios_base::operator bool()
    // on the stream returned from getline() returns false
    for (std::array&lt;char, 4&gt; a; input.getline(&amp;a[0], 4, '{{!}}'); ) {
        v.push_back(a);
    }

    for (auto&amp; a : v) {
        std::cout &lt;&lt; &amp;a[0] &lt;&lt; '\n';
    }
}
 | output=
abc
def
gh
}}

===See also===
{{dsc begin}}
{{dsc fun | cpp/string/basic_string/getline | read data from an I/O stream into a string}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc end}}

[[de:cpp/io/basic istream/getline]]
[[es:cpp/io/basic istream/getline]]
[[fr:cpp/io/basic istream/getline]]
[[it:cpp/io/basic istream/getline]]
[[ja:cpp/io/basic istream/getline]]
[[pt:cpp/io/basic istream/getline]]
[[ru:cpp/io/basic istream/getline]]
[[zh:cpp/io/basic istream/getline]]</text>
      <sha1>7ii7ga8z3rurbhc53d1tqkkc1a4ny9y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/ignore</title>
    <ns>0</ns>
    <id>521</id>
    <revision>
      <id>62004</id>
      <parentid>57637</parentid>
      <timestamp>2013-06-14T13:31:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+exceptions</comment>
      <text xml:space="preserve" bytes="2418">{{cpp/io/basic_istream/title | ignore}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl |1=
basic_istream&amp; ignore( std::streamsize count = 1, int_type delim = Traits::eof() );
}}
{{dcl end}}

Extracts and discards characters from the input stream until and including {{tt|delim}}.

{{tt|ignore}} behaves as an {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, it extracts characters from the stream and discards them until any one of the following conditions occurs:

* {{tt|count}} characters were extracted. This test is disabled in the special case when {{tt|count}} equals {{c|std::numeric_limits&lt;std::streamsize&gt;::max()}}

* end of file conditions occurs in the input sequence, in which case the function calls {{c|setstate(eofbit)}}

* the next available character {{tt|c}} in the input sequence is {{tt|delim}}, as determined by {{c|Traits::eq_int_type(Traits::to_int_type(c), delim)}}. The delimiter character is extracted and discarded. This test is disabled if {{tt|delim}} is {{c|Traits::eof()}}

===Parameters===
{{par begin}}
{{par | count | number of characters to extract}}
{{par | delim | delimiting character to stop the extraction at. It is also extracted.}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | The following example uses {{tt|ignore}} to skip over non-numeric input:
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;limits&gt;

int main()
{
    std::istringstream input(&quot;1\n&quot;
                             &quot;some non-numeric input\n&quot;
                             &quot;2\n&quot;);
    for(;;) {
        int n;
        input &gt;&gt; n;

        if (input.eof() {{!!}} input.bad()) {
            break;
        } else if (input.fail()) {
            input.clear(); // unset failbit
            input.ignore(std::numeric_limits&lt;std::streamsize&gt;::max(), '\n'); // skip bad input
        } else {
            std::cout &lt;&lt; n &lt;&lt; '\n';
        }
    }
}
 | output=
1
2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc getline}}
{{dsc end}}

[[de:cpp/io/basic istream/ignore]]
[[es:cpp/io/basic istream/ignore]]
[[fr:cpp/io/basic istream/ignore]]
[[it:cpp/io/basic istream/ignore]]
[[ja:cpp/io/basic istream/ignore]]
[[pt:cpp/io/basic istream/ignore]]
[[ru:cpp/io/basic istream/ignore]]
[[zh:cpp/io/basic istream/ignore]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/operator=</title>
    <ns>0</ns>
    <id>4028</id>
    <revision>
      <id>63204</id>
      <parentid>62732</parentid>
      <timestamp>2013-07-05T18:52:06Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1518">{{cpp/io/basic_istream/title | operator{{=}}}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
protected:
basic_istream&amp; operator=( const basic_istream&amp; rhs ) = delete;
}}
{{dcl | num=2 | since=c++11 | 1=
protected:
basic_istream&amp; operator=( basic_istream&amp;&amp; rhs );
}}
{{dcl end}}

1) The copy assignment operator is protected, and is deleted. Input streams are not CopyAssignable.

2) The move assignment operator exchanges the gcount() values and all data members of the base class, except for {{tt|rdbuf()}}, with {{tt|rhs}}, as if by calling {{c|swap(*rhs)}}. This move assignment operator is protected: it is only called by the move assignment operators of the derived movable input stream classes {{lc|std::basic_ifstream}} and {{lc|std::basic_istringstream}}, which know how to correctly move-assign the associated streambuffers.

===Parameters===
{{par begin}}
{{par | rhs | the basic_istream object from which to assign to {{c|*this}}}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::istringstream s1;
    s1 = std::istringstream(&quot;test&quot;); // OK

    std::cin = std::istringstream(&quot;test&quot;); // ERROR: 'operator=' is protected
}
}}

[[de:cpp/io/basic istream/operator=]]
[[es:cpp/io/basic istream/operator=]]
[[fr:cpp/io/basic istream/operator=]]
[[it:cpp/io/basic istream/operator=]]
[[ja:cpp/io/basic istream/operator=]]
[[pt:cpp/io/basic istream/operator=]]
[[ru:cpp/io/basic istream/operator=]]
[[zh:cpp/io/basic istream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/operator gtgt</title>
    <ns>0</ns>
    <id>522</id>
    <revision>
      <id>65554</id>
      <parentid>64161</parentid>
      <timestamp>2013-09-19T00:58:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++11 since/until was flipped</comment>
      <text xml:space="preserve" bytes="5379">{{cpp/io/basic_istream/title | operator&gt;&gt;}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_istream&amp; operator&gt;&gt;( short&amp; value );
basic_istream&amp; operator&gt;&gt;( unsigned short&amp; value );
}}
{{dcl | num=2 |
basic_istream&amp; operator&gt;&gt;( int&amp; value );
basic_istream&amp; operator&gt;&gt;( unsigned int&amp; value );
}}
{{dcl | num=3 |
basic_istream&amp; operator&gt;&gt;( long&amp; value );
basic_istream&amp; operator&gt;&gt;( unsigned long&amp; value );
}}
{{dcl | num=4 | since=c++11 |
basic_istream&amp; operator&gt;&gt;( long long&amp; value );
basic_istream&amp; operator&gt;&gt;( unsigned long long&amp; value );
}}
{{dcl | num=5 |
basic_istream&amp; operator&gt;&gt;( float&amp; value );
basic_istream&amp; operator&gt;&gt;( double&amp; value );
basic_istream&amp; operator&gt;&gt;( long double&amp; value );
}}
{{dcl | num=6 | 
basic_istream&amp; operator&gt;&gt;( bool&amp; value );
}}
{{dcl | num=7 |
basic_istream&amp; operator&gt;&gt;( void*&amp; value );
}}
{{dcl | num=8 |
basic_istream&amp; operator&gt;&gt;( basic_istream&amp; st, 
                           std::ios_base&amp; (*func)(std::ios_base&amp;) );
basic_istream&amp; operator&gt;&gt;( basic_istream&amp; st, 
                           std::basic_ios&lt;CharT,Traits&gt;&amp; (*func)(std::basic_ios&lt;CharT,Traits&gt;&amp;) );
basic_istream&amp; operator&gt;&gt;( basic_istream&amp; st, 
                           std::basic_istream&amp; (*func)(std::basic_istream&amp;) );
}}
{{dcl | num=9 | 
basic_istream&amp; operator&gt;&gt;( basic_istream&amp; st, 
                           std::basic_streambuf&lt;CharT,Traits&gt;* sb );
}}

{{dcl end}}

1-4) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts an integer value by calling {{lc|std::num_get::get()}}

5) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts a floating point value by calling {{lc|std::num_get::get()}}

6) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts {{c|bool}} value by calling {{lc|std::num_get::get()}}

7) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts a generic pointer value by calling {{lc|std::num_get::get()}}

8) Calls {{c|func(*this);}}, where {{tt|func}} is an I/O manipulator.

9) Behaves as an {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, extracts all data from the input stream and stores it to {{tt|sb}}. The extraction stops if one of the following conditions are met:
:* end-of-file occurs on the input sequence;
:* inserting in the output sequence fails (in which case the character to be inserted is not extracted);
:* an exception occurs (in which case the exception is caught, and only rethrown exceptions on {{tt|failbit}} are enabled).
In either case, stores the number of characters extracted in the member variable accessed by subsequent calls to {{lc|gcount()}}. If {{tt|sb}} is a null pointer or if no characters are inserted into {{tt|sb}}, sets {{tt|eofbit}}.

{{rev begin}}
{{rev | until=c++11 | If extraction fails (e.g. if a letter was entered where a digit is expected), {{tt|value}} is left unmodified and {{tt|failbit}} is set.
}}
{{rev | since=c++11 | If extraction fails, zero is written to {{tt|value}} and {{tt|failbit}} is set. If extraction results in the value too large or too small to fit in {{tt|value}}, {{c|std::numeric_limits&lt;T&gt;::max()}} or {{c|std::numeric_limits&lt;T&gt;::min()}} is written and {{tt|failbit}} flag is set. 
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | value | reference to an integer or floating-point value to store the extracted value to}}
{{par | func | pointer to I/O manipulator function}}
{{par | sb | pointer to the streambuffer to write all the data to}}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;sstream&gt;

int main()
{
    std::string input = &quot;41 3.14 false hello world&quot;;
    std::istringstream stream(input);
    int n;
    double f;
    bool b;

    stream &gt;&gt; n &gt;&gt; f &gt;&gt; std::boolalpha &gt;&gt; b;
    std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n'
              &lt;&lt; &quot;f = &quot; &lt;&lt; f &lt;&lt; '\n'
              &lt;&lt; &quot;b = &quot; &lt;&lt; std::boolalpha &lt;&lt; b &lt;&lt; '\n';

    // extract the rest using the streambuf overload
    stream &gt;&gt; std::cout.rdbuf();
    std::cout &lt;&lt; '\n';
}
 | output=
n = 41
f = 3.14
b = false
hello world
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc inc | cpp/string/basic_string/dsc operator_ltltgtgt}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt2}}
{{dsc inc | cpp/numeric/complex/dsc operator_ltltgtgt}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt | linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | uniform_int_distribution}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc getline}}
{{dsc end}}

[[de:cpp/io/basic istream/operator gtgt]]
[[es:cpp/io/basic istream/operator gtgt]]
[[fr:cpp/io/basic istream/operator gtgt]]
[[it:cpp/io/basic istream/operator gtgt]]
[[ja:cpp/io/basic istream/operator gtgt]]
[[pt:cpp/io/basic istream/operator gtgt]]
[[ru:cpp/io/basic istream/operator gtgt]]
[[zh:cpp/io/basic istream/operator gtgt]]</text>
      <sha1>gc1p5uf81ulp7r330ex5fi6qryszha8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/operator gtgt2</title>
    <ns>0</ns>
    <id>3766</id>
    <revision>
      <id>62734</id>
      <parentid>57641</parentid>
      <timestamp>2013-07-01T23:35:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="4213">{{title|operator&gt;&gt;{{small|(std::basic_istream)}}}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
template&lt; class CharT, class Traits &gt;
basic_istream&lt;CharT,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;CharT,Traits&gt;&amp; st, CharT&amp; ch );

template&lt; class Traits &gt;
basic_istream&lt;char,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;char,Traits&gt;&amp; st, signed char&amp; ch );

template&lt; class Traits &gt;
basic_istream&lt;char,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;char,Traits&gt;&amp; st, unsigned char&amp; ch );
}}
{{dcl | num=2 |
template&lt; class CharT, class Traits&gt;
basic_istream&lt;CharT,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;CharT,Traits&gt;&amp; st, CharT* s );

template&lt; class Traits &gt;
basic_istream&lt;char,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;char,Traits&gt;&amp; st, signed char* s );

template&lt; class Traits &gt;
basic_istream&lt;char,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;char,Traits&gt;&amp; st, unsigned char* s );
}}
{{dcl | num=3 | since=c++11 |
template&lt; class CharT, class Traits, class T &gt;
basic_istream&lt;CharT,Traits&gt;&amp; operator&gt;&gt;( basic_istream&lt;CharT,Traits&gt;&amp;&amp; st, T&amp; value );
}}
{{dcl end}}

Performs character input operations.

1) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts a character and stores it to {{tt|ch}}. If no character is available, sets {{ltt|cpp/io/ios_base/iostate|failbit}} (in addition to {{ltt|cpp/io/ios_base/iostate|eofbit}} that is set as required of a {{concept|FormattedInputFunction}}).

2) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts successive characters and stores them at successive locations of a character array whose first element is pointed to by {{tt|s}}. The extraction stops if one of the following conditions are met:
:* a whitespace character (as determined by the {{ltt|cpp/locale/ctype|ctype&lt;CharT&gt;}} facet) is found. The whitespace character is not extracted. 
:* {{c|this-&gt;width() - 1}} characters are extracted
:* end of file occurs in the input sequence (this also sets {{ltt|cpp/io/ios_base/iostate|eofbit}})
In either case, an additional null character value {{c|CharT()}} is stored at the end of the output. If no characters were extracted, sets {{ltt|cpp/io/ios_base/iostate|failbit}} (the null character is still written, to the first position in the output). Finally, calls {{c|st.width(0)}} to cancel the effects of {{lc|std::setw}}, if any.

3) Calls the appropriate extraction operator, given an rvalue reference to an input stream object (equivalent to {{c|st &gt;&gt; value}}).

===Notes===
Extracting a single character that is the last character of the stream does not set {{tt|eofbit}}: this is different from other formatted input functions, such as extracting the last integer with {{c|operator&gt;&gt;}}, but this behavior matches the behavior of {{lc|std::scanf}} with {{c|&quot;%c&quot;}} format specifier. &lt;!-- prooflink: http://cplusplus.github.com/LWG/lwg-closed.html#2036 --&gt;

===Parameters===

{{par begin}}
{{par | st | input stream to extract the data from}}
{{par | ch | reference to a character to store the extracted character to}}
{{par | s | pointer to a character string to store the extracted characters to}}
{{par end}}

===Return value===
{{tt|st}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;sstream&gt;

int main()
{
    std::string input = &quot;n greetings&quot;;
    std::istringstream stream(input);
    char c;
    const int MAX = 6;
    char cstr[MAX];

    stream &gt;&gt; c &gt;&gt; std::setw(MAX) &gt;&gt; cstr;
    std::cout &lt;&lt; &quot;c = &quot; &lt;&lt; c &lt;&lt; '\n'
              &lt;&lt; &quot;cstr = &quot; &lt;&lt; cstr &lt;&lt; '\n';

    double f;
    std::istringstream(&quot;1.23&quot;) &gt;&gt; f; // rvalue stream extraction
    std::cout &lt;&lt; &quot;f = &quot; &lt;&lt; f &lt;&lt; '\n';
}

| output=
c = n
cstr = greet
f = 1.23
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc end}}

[[de:cpp/io/basic istream/operator gtgt2]]
[[es:cpp/io/basic istream/operator gtgt2]]
[[fr:cpp/io/basic istream/operator gtgt2]]
[[it:cpp/io/basic istream/operator gtgt2]]
[[ja:cpp/io/basic istream/operator gtgt2]]
[[pt:cpp/io/basic istream/operator gtgt2]]
[[ru:cpp/io/basic istream/operator gtgt2]]
[[zh:cpp/io/basic istream/operator gtgt2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/peek</title>
    <ns>0</ns>
    <id>523</id>
    <revision>
      <id>64970</id>
      <parentid>62001</parentid>
      <timestamp>2013-08-28T17:45:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso to sgetc</comment>
      <text xml:space="preserve" bytes="1219">{{cpp/io/basic_istream/title | peek}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
int_type peek();
}}

Behaves as {{concept|UnformattedInputFunction}}. After constructing and testing the sentry object, reads the next character from the input stream without extracting it. 

===Parameters===
(none)

===Return value===
If {{c|good() {{==}} true}}, returns the next character as obtained by {{c|rdbuf()-&gt;sgetc()}}

Otherwise, returns {{c|Traits::eof()}}.

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
int main()
{
    std::istringstream s1(&quot;Hello, world.&quot;);
    char c1 = s1.peek();
    char c2 = s1.get();
    std::cout &lt;&lt; &quot;Peeked: &quot; &lt;&lt; c1 &lt;&lt; &quot; got: &quot; &lt;&lt; c2 &lt;&lt; '\n';
}
 | output=
Peeked: H got: H
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc end}}

[[de:cpp/io/basic istream/peek]]
[[es:cpp/io/basic istream/peek]]
[[fr:cpp/io/basic istream/peek]]
[[it:cpp/io/basic istream/peek]]
[[ja:cpp/io/basic istream/peek]]
[[pt:cpp/io/basic istream/peek]]
[[ru:cpp/io/basic istream/peek]]
[[zh:cpp/io/basic istream/peek]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/putback</title>
    <ns>0</ns>
    <id>524</id>
    <revision>
      <id>69810</id>
      <parentid>62411</parentid>
      <timestamp>2014-04-25T18:26:15Z</timestamp>
      <contributor>
        <username>Jankowalski25</username>
        <id>2468</id>
      </contributor>
      <comment>missing parameter</comment>
      <text xml:space="preserve" bytes="2184">{{cpp/io/basic_istream/title | putback}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
basic_istream&amp; putback( char_type ch );
}}

Puts the character {{tt|ch}} back to the input stream so the next extracted character will be {{tt|ch}}. 

First clears {{tt|eofbit}}, then behaves as {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, if {{tt|rdbuf()}} is not null, calls {{c|rdbuf()-&gt;sputbackc(ch)}}, which calls {{c|rdbuf()-&gt;pbackfail(ch)}} if {{tt|ch}} does not equal the most recently extracted character.

If {{tt|rdbuf()}} is null or if {{c|rdbuf-&gt;sputbackc(ch)}} returns {{c|Traits::eof()}}, calls {{c|setstate(badbit)}}.

In any case, sets the {{tt|gcount()}} counter to zero.

===Parameters===
{{par begin}}
{{par | ch | character to put into input stream}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | demonstrates the difference between modifying and non-modifying putback()
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::stringstream s1(&quot;Hello, world&quot;); // IO stream
    s1.get();
    if (s1.putback('Y')) // modifies the buffer
        std::cout &lt;&lt; s1.rdbuf() &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;putback failed\n&quot;;

    std::istringstream s2(&quot;Hello, world&quot;); // input-only stream
    s2.get();
    if (s2.putback('Y')) // cannot modify input-only buffer
        std::cout &lt;&lt; s2.rdbuf() &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;putback failed\n&quot;;

    s2.clear();
    if (s2.putback('H')) // non-modifying putback
        std::cout &lt;&lt; s2.rdbuf() &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;putback failed\n&quot;;
}
 | output=
Yello, world
putback failed
Hello, world
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc peek}}
{{dsc end}}

[[de:cpp/io/basic istream/putback]]
[[es:cpp/io/basic istream/putback]]
[[fr:cpp/io/basic istream/putback]]
[[it:cpp/io/basic istream/putback]]
[[ja:cpp/io/basic istream/putback]]
[[pt:cpp/io/basic istream/putback]]
[[ru:cpp/io/basic istream/putback]]
[[zh:cpp/io/basic istream/putback]]</text>
      <sha1>3khbkindv4bhtjol096zlglgz2ve1bi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/read</title>
    <ns>0</ns>
    <id>525</id>
    <revision>
      <id>65947</id>
      <parentid>62005</parentid>
      <timestamp>2013-10-16T12:29:42Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <comment>/* Example */</comment>
      <text xml:space="preserve" bytes="2778">{{cpp/io/basic_istream/title | read}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
basic_istream&amp; read( char_type* s, std::streamsize count );
}}

Extracts characters from stream.

Behaves as {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, extracts characters and stores them into successive locations of the character array whose first element is pointed to by {{tt|s}}. Characters are extracted and stored until any of the following conditions occurs:

* {{tt|count}} characters were extracted and stored

* end of file condition occurs on the input sequence (in which case, {{c|setstate(failbit{{!}}eofbit)}} is called. The number of successfully extracted characters can be queried using {{lc|gcount()}}.

===Parameters===
{{par begin}}
{{par | s | pointer to the character array to store the characters to}}
{{par | count | number of characters to read}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;sstream&gt;
#include &lt;string&gt;
#include &lt;cstdint&gt;

int main()
{
    // read() is often used for binary I/O
    std::string bin = {'\x12', '\x12', '\x12', '\x12'};
    std::istringstream raw(bin);
    std::uint32_t n;
    raw.read(reinterpret_cast&lt;char*&gt;(&amp;n), sizeof n);
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; n &lt;&lt; '\n';

    // prepare file for next snippet
    std::ofstream os(&quot;test.txt&quot;, std::ofstream::binary);
    for (unsigned i = 0; i &lt; 10; i++) { // prepare stream
        os &lt;&lt; &quot;abcd&quot; &lt;&lt; i &lt;&lt; &quot;\n&quot;;
    }
    os.close();

    // read entire file into string
    std::ifstream is(&quot;test.txt&quot;, std::ifstream::binary);
    if (is) {
        // get length of file:
        is.seekg(0, is.end);
        int length = is.tellg();
        is.seekg(0, is.beg);

        std::string str;
        str.resize(length, ' '); // reserve space
        char* begin = &amp;*str.begin();

        is.read(begin, length);
        is.close();

        std::cout &lt;&lt; str &lt;&lt; &quot;\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;Could not open test.txt\n&quot;;
    }
}
 | output=
0x12121212
abcd0
abcd1
abcd2
abcd3
abcd4
abcd5
abcd6
abcd7
abcd8
abcd9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc write}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc getline}}
{{dsc inc | cpp/io/c/dsc fread}}
{{dsc end}}

[[de:cpp/io/basic istream/read]]
[[es:cpp/io/basic istream/read]]
[[fr:cpp/io/basic istream/read]]
[[it:cpp/io/basic istream/read]]
[[ja:cpp/io/basic istream/read]]
[[pt:cpp/io/basic istream/read]]
[[ru:cpp/io/basic istream/read]]
[[zh:cpp/io/basic istream/read]]</text>
      <sha1>i09fbrvar92ip6won5dc236zi5q8uch</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/readsome</title>
    <ns>0</ns>
    <id>526</id>
    <revision>
      <id>69843</id>
      <parentid>69842</parentid>
      <timestamp>2014-04-28T20:46:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>explanatory comments to the new example</comment>
      <text xml:space="preserve" bytes="2647">{{cpp/io/basic_istream/title | readsome}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
std::streamsize readsome( char_type* s, std::streamsize count );
}}

Extracts up to {{tt|count}} immediately available characters from the input stream. The extracted characters are stored into the character array pointed to by {{tt|s}}. 

Behaves as {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, 

* If {{c|1=rdbuf()-&gt;in_avail() == -1}}, calls {{c|setstate(eofbit)}} and extracts no characters.

* If {{c|1=rdbuf()-&gt;in_avail() == 0}}, extracts no characters.

* If {{c|1=rdbuf()-&gt;in_avail() &gt; 0}}, extracts {{c|std::min(rdbuf()-&gt;in_avail(), count)}} characters and stores them into successive locations of the characater array whose first element is pointed to by {{tt|s}}.

===Parameters===
{{par begin}}
{{par | s | pointer to the character array to store the characters to}}
{{par | count | maximum number of characters to read}}
{{par end}}

===Return value===
The number of characters actually extracted.

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Notes===
The behavior of this function is highly implementation-specific. For example, when used with {{lc|std::ifstream}}, some library implementations fill the underlying filebuf with data as soon as the file is opened (and readsome() on such implementations reads data, potentially, but not necessarily, the entire file), while other implementations only read from file when an actual input operation is requested (and readsome() issued after file opening never extracts any characters). Likewise, a call to {{c|std::cin.readsome()}} may return all pending unprocessed console input, or may always return zero and extract no characters.

===Example===
{{example
 | code=#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    char c[10] = {};
    std::istringstream input(&quot;This is sample text.&quot;); // std::stringbuf makes its entire
                                                      // buffer available for unblocking read
    input.readsome(c, 5); // reads 'This ' and stores in c[0] .. c[4]
    input.readsome(c, 9); // reads 'is sample' and stores in c[0] .. c[8]
    std::cout &lt;&lt; c;
}
 | output=is sample
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc inc | cpp/io/basic_streambuf/dsc in_avail}}
{{dsc end}}

[[de:cpp/io/basic istream/readsome]]
[[es:cpp/io/basic istream/readsome]]
[[fr:cpp/io/basic istream/readsome]]
[[it:cpp/io/basic istream/readsome]]
[[ja:cpp/io/basic istream/readsome]]
[[pt:cpp/io/basic istream/readsome]]
[[ru:cpp/io/basic istream/readsome]]
[[zh:cpp/io/basic istream/readsome]]</text>
      <sha1>2p601q1hkcu4lqkjkmk57njjbgz4q7z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/seekg</title>
    <ns>0</ns>
    <id>527</id>
    <revision>
      <id>62009</id>
      <parentid>62008</parentid>
      <timestamp>2013-06-14T15:08:20Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>lc</comment>
      <text xml:space="preserve" bytes="2347">{{cpp/io/basic_istream/title | seekg}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | 1=
basic_istream&amp; seekg( pos_type pos );
}}
{{dcl | 1=
basic_istream&amp; seekg( off_type off, std::ios_base::seekdir dir);
}}
{{dcl end}}

Sets input position indicator of the current associated {{tt|streambuf}} object. In case of failure, calls {{c|setstate(std::ios_base::failbit)}}.

{{rev begin}}
{{rev|since=c++11|Before doing anything else, {{tt|seekg}} clears {{tt|eofbit}}.}}
{{rev end}}

{{tt|seekg}} behaves as {{concept|UnformattedInputFunction}}, except that {{lc|gcount()}} is not affected. After constructing and checking the sentry object,

@1@ sets the input position indicator to absolute (relative to the beginning of the file) value {{tt|pos}}. Specifically, executes {{c|rdbuf()-&gt;pubseekpos(pos, std::ios_base::in)}}.
@2@ sets the input position indicator to position {{tt|off}}, relative to position, defined by {{tt|dir}}. Specifically, executes {{c|rdbuf()-&gt;pubseekoff(off, dir, std::ios_base::in)}}. 

===Parameters===
{{par begin}}
{{par | pos | absolute position to set the input position indicator to.}}
{{par | off | relative position to set the input position indicator to.}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;sstream&gt;

int main()
{
    std::string str = &quot;Hello, world&quot;;
    std::istringstream in(str);
    std::string word1, word2;

    in &gt;&gt; word1;
    in.seekg(0); // rewind
    in &gt;&gt; word2;

    std::cout &lt;&lt; &quot;word1 = &quot; &lt;&lt; word1 &lt;&lt; '\n'
              &lt;&lt; &quot;word2 = &quot; &lt;&lt; word2 &lt;&lt; '\n';
}
 | output=
word1 = Hello,
word2 = Hello,
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc tellg}}
{{dsc inc | cpp/io/basic_ostream/dsc tellp | mem=std::basic_ostream}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/basic istream/seekg]]
[[es:cpp/io/basic istream/seekg]]
[[fr:cpp/io/basic istream/seekg]]
[[it:cpp/io/basic istream/seekg]]
[[ja:cpp/io/basic istream/seekg]]
[[pt:cpp/io/basic istream/seekg]]
[[ru:cpp/io/basic istream/seekg]]
[[zh:cpp/io/basic istream/seekg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/sentry</title>
    <ns>0</ns>
    <id>528</id>
    <revision>
      <id>69993</id>
      <parentid>69987</parentid>
      <timestamp>2014-05-05T10:28:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>not doing something isn't a list of actions.. reworded again</comment>
      <text xml:space="preserve" bytes="4140">{{cpp/io/basic_istream/title | sentry}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | 1=
class sentry;
}}
{{dcl end}}

An object of class {{tt|basic_istream::sentry}} is constructed in local scope at the beginning of each member function of {{lc|std::basic_istream}} that performs input (both formatted and unformatted). Its constructor prepares the input stream: checks if the stream is already in a failed state, flushes the tie()'d output streams, skips leading whitespace unless {{tt|noskipws}} flag is set, and performs other implementation-defined tasks if necessary. All cleanup, if necessary, is performed in the destructor, so that it is guaranteed to happen if exceptions are thrown during input.

===Member types===
{{dsc begin}}
{{dsc | {{tt|traits_type}} | {{c|Traits}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/sentry/dsc constructor}}
{{dsc inc | cpp/io/basic_istream/sentry/dsc destructor}}
{{dsc mem fun | operator{{=}} | nolink=true | notes={{cmark deleted}} | not copy assignable}}
{{dsc inc | cpp/io/basic_istream/sentry/dsc operator bool}}
{{dsc end}}

{{member | {{small|std::basic_istream::sentry::}}sentry | 2=
{{ddcl | 1=
explicit sentry(std::basic_istream&lt;CharT,Traits&gt;&amp; is, bool noskipws = false);
}}

Prepares the stream for formatted input.

If {{c|is.good()}} is {{c|false}}, calls {{c|is.setstate(failbit)}}{{mark|since c++11}} and returns. Otherwise, if {{c|is.tie()}} is not a null pointer, calls {{c|is.tie()-&gt;flush()}} to synchronize the output sequence with external streams. This call can be suppressed if the put area of {{c|is.tie()}} is empty. The implementation may defer the call to {{c|flush}} until a call of {{c|is.rdbuf()-&gt;underflow()}} occurs. If no such call occurs before the sentry object is destroyed, it may be eliminated entirely.

If {{tt|noskipws}} is zero and {{c|is.flags() &amp; ios_base::skipws}} is nonzero, the function extracts and discards all whitespace characters until the next available character is not a whitespace character (as determined by the currently imbued locale in {{tt|is}}). If {{c|is.rdbuf()-&gt;sbumpc()}} or {{c|is.rdbuf()-&gt;sgetc()}} returns {{c|traits::eof()}}, the function calls {{c|setstate(failbit {{!}} eofbit)}} (which may throw {{lc|std::ios_base::failure}}).

Additional implementation-defined preparation may take place, which may call {{c|setstate(failbit)}} (which may throw {{lc|std::ios_base::failure}}).

If after preparation is completed, {{c|is.good() {{==}} true}}, then any subsequent calls to {{c|operator bool}} will return {{c|true}}.

===Parameters===
{{par begin}}
{{par | is | input stream to prepare}}
{{par | noskipws | {{c|true}} if whitespace should not be skipped}}
{{par end}}

===Exceptions===
{{lc|std::ios_base::failure}} if the end of file condition occurs when skipping whitespace.
}}


{{member | {{small|std::basic_istream::sentry::}}~sentry | 2=
{{ddcl | 1=
~sentry();
}}
Does nothing.
}}


{{member | {{small|std::basic_istream::sentry::}}operator bool | 2=
{{ddcl | 1=
explicit operator bool() const;
}}
Checks whether the preparation of the input stream was successful.

===Parameters===
(none)

===Return value===
{{c|true}} if the initialization of the input stream was successful, {{c|false}} otherwise.
}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

struct Foo
{
   char n[5];
};

std::istream&amp; operator&gt;&gt;(std::istream&amp; is, Foo&amp; f)
{
    std::istream::sentry s(is);
    if (s)
        is.read(f.n, 5);
    return is;
}

int main()
{
    std::string input = &quot;   abcde&quot;;
    std::istringstream stream(input);
    Foo f;
    stream &gt;&gt; f;
    std::cout.write(f.n, 5);
    std::cout &lt;&lt; '\n';
}
| output=
abcde
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc end}}

[[de:cpp/io/basic istream/sentry]]
[[es:cpp/io/basic istream/sentry]]
[[fr:cpp/io/basic istream/sentry]]
[[it:cpp/io/basic istream/sentry]]
[[ja:cpp/io/basic istream/sentry]]
[[pt:cpp/io/basic istream/sentry]]
[[ru:cpp/io/basic istream/sentry]]
[[zh:cpp/io/basic istream/sentry]]</text>
      <sha1>s7c88x49m3p23kxmvufxtet1utjz733</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/swap</title>
    <ns>0</ns>
    <id>4029</id>
    <revision>
      <id>64220</id>
      <parentid>62735</parentid>
      <timestamp>2013-08-15T15:34:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1368">{{cpp/io/basic_istream/title | swap}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |1=
protected:
void swap(basic_istream&amp; rhs);
}}
{{dcl end}}

Calls {{c|basic_ios::swap(rhs)}} to swap all data members of the base class except for {{c|rdbuf()}}, and swaps the values of the {{lc|gcount()}} counters between {{c|*this}} and {{tt|rhs}}. This swap function is protected: it is called by the swap functions of the swappable input stream classes {{lc|std::basic_ifstream}} and {{lc|std::basic_istringstream}}, which know how to correctly swap the associated streambuffers.

===Parameters===
{{par begin}}
{{par | rhs | different basic_istream object of the same type to swap with}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;
int main()
{
    std::istringstream s1(&quot;hello&quot;);
    std::istringstream s2(&quot;bye&quot;);

    s1.swap(s2); // OK, istringstream has a public swap()
    std::swap(s1, s2); // OK, calls s1.swap(s2)
//  std::cin.swap(s2); // ERROR: swap is a protected member

    std::cout &lt;&lt; s1.rdbuf();
}
| output=
hello
}}

[[de:cpp/io/basic istream/swap]]
[[es:cpp/io/basic istream/swap]]
[[fr:cpp/io/basic istream/swap]]
[[it:cpp/io/basic istream/swap]]
[[ja:cpp/io/basic istream/swap]]
[[pt:cpp/io/basic istream/swap]]
[[ru:cpp/io/basic istream/swap]]
[[zh:cpp/io/basic istream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/sync</title>
    <ns>0</ns>
    <id>529</id>
    <revision>
      <id>64164</id>
      <parentid>64163</parentid>
      <timestamp>2013-08-15T14:58:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2697">{{cpp/io/basic_istream/title | sync}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
int sync();
}}

Synchronizes the input buffer with the associated data source.

Behaves as {{concept|UnformattedInputFunction}}, except that {{lc|gcount()}} is not affected. After constructing and checking the sentry object,

if {{lc|rdbuf()}} is a null pointer, returns {{c|-1}}

Otherwise, calls {{c|rdbuf()-&gt;pubsync()}}. If that function returns {{c|-1}}, calls {{c|setstate(badbit)}} and returns {{c|-1}}. Otherwise, returns {{c|0}}.

===Parameters===
(none)

===Return value===
{{c|0}} on success, {{c|-1}} on failure or if the stream does not support this operation (is unbuffered).

===Notes===
As with {{lc|readsome()}}, it is implementation-defined whether this function does anything with library-supplied streams. The intent is typically for the next read operation to pick up any changes that may have been made to the associated input sequence after the stream buffer last filled its get area. To achieve that, {{tt|sync()}} may empty the get area, or it may refill it, or it may do nothing. A notable exception is Visual Studio, where this operation discards the unprocessed input when called with a standard input stream.

===Example===
{{example
 | Demonstrates the use of input stream sync() with file input, as implemented on some platforms.
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;

void file_abc()
{
    std::ofstream f(&quot;test.txt&quot;);
    f &lt;&lt; &quot;abc\n&quot;;
}

void file_123()
{
    std::ofstream f(&quot;test.txt&quot;);
    f &lt;&lt; &quot;123\n&quot;;
}

int main()
{
    file_abc(); // file now contains &quot;abc&quot;
    std::ifstream f(&quot;test.txt&quot;);
    std::cout &lt;&lt; &quot;Reading from the file\n&quot;;
    char c;
    f &gt;&gt; c; std::cout &lt;&lt; c;
    file_123(); // file now contains &quot;123&quot;
    f &gt;&gt; c; std::cout &lt;&lt; c;
    f &gt;&gt; c; std::cout &lt;&lt; c &lt;&lt; '\n';
    f.close();

    file_abc(); // file now contains &quot;abc&quot;
    f.open(&quot;test.txt&quot;);
    std::cout &lt;&lt; &quot;Reading from the file, with sync()\n&quot;;
    f &gt;&gt; c; std::cout &lt;&lt; c;
    file_123(); // file now contains &quot;123&quot;
    f.sync();
    f &gt;&gt; c; std::cout &lt;&lt; c;
    f &gt;&gt; c; std::cout &lt;&lt; c &lt;&lt; '\n';
}
 | p=true
 | output= &lt;!-- Note: output as seen on on Sun and IBM, but the Linux/gcc that was tested printed &quot;abc&quot; both times --&gt;
Reading from the file
abc
Reading from the file, with sync()
a23
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sync}}
{{dsc inc | cpp/io/basic_ostream/dsc flush}}
{{dsc end}}

[[de:cpp/io/basic istream/sync]]
[[es:cpp/io/basic istream/sync]]
[[fr:cpp/io/basic istream/sync]]
[[it:cpp/io/basic istream/sync]]
[[ja:cpp/io/basic istream/sync]]
[[pt:cpp/io/basic istream/sync]]
[[ru:cpp/io/basic istream/sync]]
[[zh:cpp/io/basic istream/sync]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/tellg</title>
    <ns>0</ns>
    <id>530</id>
    <revision>
      <id>65957</id>
      <parentid>65942</parentid>
      <timestamp>2013-10-16T13:40:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 65942 by [[Special:Contributions/Eendy|Eendy]] ([[User talk:Eendy|talk]]) unless you mean that &quot;-1&quot;  is &quot;correct value&quot;?</comment>
      <text xml:space="preserve" bytes="1550">{{cpp/io/basic_istream/title | tellg}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
pos_type tellg();
}}

Returns input position indicator of the current associated {{tt|streambuf}} object.

Behaves as {{concept|UnformattedInputFunction}}, except that {{lc|gcount()}} is not affected. After constructing and checking the sentry object, if {{c|1=fail() == true}}, returns {{c|pos_type(-1)}}. Otherwise, returns {{c|rdbuf()-&gt;pubseekoff(0, std::ios_base::cur, std::ios_base::in)}}.

===Parameters===
(none)

===Return value===
The current position of the get pointer on success, {{c|pos_type(-1)}} on failure

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;sstream&gt;

int main()
{
    std::string str = &quot;Hello, world&quot;;
    std::istringstream in(str);
    std::string word;
    in &gt;&gt; word;
    std::cout &lt;&lt; &quot;After reading the word \&quot;&quot; &lt;&lt; word
              &lt;&lt; &quot;\&quot; tellg() returns &quot; &lt;&lt; in.tellg() &lt;&lt; '\n';
}
 | output=
After reading the word &quot;Hello,&quot; tellg() returns 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc seekg}}
{{dsc inc | cpp/io/basic_ostream/dsc tellp | mem=std::basic_ostream}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/basic istream/tellg]]
[[es:cpp/io/basic istream/tellg]]
[[fr:cpp/io/basic istream/tellg]]
[[it:cpp/io/basic istream/tellg]]
[[ja:cpp/io/basic istream/tellg]]
[[pt:cpp/io/basic istream/tellg]]
[[ru:cpp/io/basic istream/tellg]]
[[zh:cpp/io/basic istream/tellg]]</text>
      <sha1>t36xl68948h0g8miwnt6izoiuhrqj4d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/unget</title>
    <ns>0</ns>
    <id>531</id>
    <revision>
      <id>65956</id>
      <parentid>65950</parentid>
      <timestamp>2013-10-16T13:36:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix pre-c++11 behavior (it didn't check just eofbit, it checked them all , and not before sentry but after (that after-sentry wording remains in c++11, although it's redundant there)</comment>
      <text xml:space="preserve" bytes="1602">{{cpp/io/basic_istream/title | unget}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
basic_istream&amp; unget();
}}

Makes the most recently extracted character available again.

{{rev begin}}
{{rev | since=c++11 | 
First clears {{ltt|cpp/io/ios_base/iostate|eofbit}}.
}}
{{rev end}}

Then the function behaves as {{concept|UnformattedInputFunction}}. After constructing and checking the sentry object, if any {{lc|ios_base::iostate}} flags are set, the function sets {{tt|failbit}} and returns. Otherwise, calls {{c|rdbuf()-&gt;sungetc()}}.

If {{c|rdbuf()-&gt;sungetc()}} returns {{c|Traits::eof()}}, calls {{c|setstate(badbit)}}.

In any case, sets the {{tt|gcount()}} counter to zero.

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
{{include|cpp/io/stream_exceptions}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::istringstream s1(&quot;Hello, world.&quot;);
    char c1 = s1.get();
    if (s1.unget())
    {
        char c2 = s1.get();
        std::cout &lt;&lt; &quot;Got: &quot; &lt;&lt; c1 &lt;&lt; &quot; got again: &quot; &lt;&lt; c2 &lt;&lt; '\n';
    }
}
 | output=
Got: H got again: H
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc peek}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc end}}

[[de:cpp/io/basic istream/unget]]
[[es:cpp/io/basic istream/unget]]
[[fr:cpp/io/basic istream/unget]]
[[it:cpp/io/basic istream/unget]]
[[ja:cpp/io/basic istream/unget]]
[[pt:cpp/io/basic istream/unget]]
[[ru:cpp/io/basic istream/unget]]
[[zh:cpp/io/basic istream/unget]]</text>
      <sha1>fc2n7s2igpylnl8y64rp1x0sayezcj1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istream/~basic istream</title>
    <ns>0</ns>
    <id>532</id>
    <revision>
      <id>49671</id>
      <parentid>43863</parentid>
      <timestamp>2013-06-01T02:50:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1221">{{cpp/io/basic_istream/title | ~basic_istream}}
{{cpp/io/basic_istream/navbar}}
{{ddcl |
virtual ~basic_istream();
}}

Destructs the input stream.

===Notes===
This destructor does not perform any operation on the underlying streambuffer ({{tt|rdbuf()}}): the destructors of the derived input streams such as {{lc|std::basic_ifstream}} and {{lc|std::basic_istringstream}} are responsible for calling the destructors of the streambuffers.

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

void print_stringbuf(std::streambuf* p)
{
    std::istream buf(p); // buf shares the buffer with s1
    int n;
    buf &gt;&gt; n;
    std::cout &lt;&lt; n;
} // calls the destructor of buf. p remains unaffected

int main()
{
    std::istringstream s1(&quot;10 20&quot;);
    print_stringbuf(s1.rdbuf());
    int n;
    s1 &gt;&gt; n;
    std::cout &lt;&lt; ',' &lt;&lt; n &lt;&lt; '\n';
}
| output = 
10,20
}}

[[de:cpp/io/basic istream/~basic istream]]
[[es:cpp/io/basic istream/~basic istream]]
[[fr:cpp/io/basic istream/~basic istream]]
[[it:cpp/io/basic istream/~basic istream]]
[[ja:cpp/io/basic istream/~basic istream]]
[[pt:cpp/io/basic istream/~basic istream]]
[[ru:cpp/io/basic istream/~basic istream]]
[[zh:cpp/io/basic istream/~basic istream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream</title>
    <ns>0</ns>
    <id>533</id>
    <revision>
      <id>64356</id>
      <parentid>62096</parentid>
      <timestamp>2013-08-15T18:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc, std</comment>
      <text xml:space="preserve" bytes="2398">{{cpp/title|basic_istringstream}}
{{cpp/io/basic_istringstream/navbar}}
{{dcl begin}}
{{dcl header | sstream}}
{{dcl rev begin}}
{{dcl | until=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_istringstream;
}}
{{dcl | since=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;,
    class Allocator = std::allocator&lt;CharT&gt;
&gt; class basic_istringstream;
}}
{{dcl rev end}}
{{dcl end}}

The class template {{tt|std::basic_istringstream}} implements input operations on memory ({{lc|std::basic_string}}) based streams. It essentially wraps a raw string device implementation ({{lc|std::basic_stringbuf}}) into a higher-level interface ({{lc|std::basic_istream}}). The complete interface to unique {{tt|std::basic_stringbuf}} members is provided.

{{inheritance diagram/std-basic_istringstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | sstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|istringstream}} | {{c|basic_istringstream&lt;char&gt;}}}}
{{dsc | {{tt|wistringstream}} | {{c|basic_istringstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc inc | cpp/io/dsc allocator_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc constructor | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc operator{{=}} | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap | basic_istringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc rdbuf | basic_istringstream}}

{{dsc h2 | String operations }}
{{dsc inc | cpp/io/basic_stringstream/dsc str | basic_istringstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic istringstream]]
[[es:cpp/io/basic istringstream]]
[[fr:cpp/io/basic istringstream]]
[[it:cpp/io/basic istringstream]]
[[ja:cpp/io/basic istringstream]]
[[pt:cpp/io/basic istringstream]]
[[ru:cpp/io/basic istringstream]]
[[zh:cpp/io/basic istringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/basic istringstream</title>
    <ns>0</ns>
    <id>534</id>
    <revision>
      <id>50844</id>
      <parentid>43852</parentid>
      <timestamp>2013-06-01T03:41:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="507">{{include page|cpp/io/basic_stringstream/constructor|basic_istringstream}}

[[de:cpp/io/basic istringstream/basic istringstream]]
[[es:cpp/io/basic istringstream/basic istringstream]]
[[fr:cpp/io/basic istringstream/basic istringstream]]
[[it:cpp/io/basic istringstream/basic istringstream]]
[[ja:cpp/io/basic istringstream/basic istringstream]]
[[pt:cpp/io/basic istringstream/basic istringstream]]
[[ru:cpp/io/basic istringstream/basic istringstream]]
[[zh:cpp/io/basic istringstream/basic istringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/operator=</title>
    <ns>0</ns>
    <id>535</id>
    <revision>
      <id>43846</id>
      <parentid>1069</parentid>
      <timestamp>2012-11-03T04:01:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="416">{{cpp/io/basic_stringstream/operator{{=}}|basic_istringstream}}

[[de:cpp/io/basic istringstream/operator=]]
[[es:cpp/io/basic istringstream/operator=]]
[[fr:cpp/io/basic istringstream/operator=]]
[[it:cpp/io/basic istringstream/operator=]]
[[ja:cpp/io/basic istringstream/operator=]]
[[pt:cpp/io/basic istringstream/operator=]]
[[ru:cpp/io/basic istringstream/operator=]]
[[zh:cpp/io/basic istringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/rdbuf</title>
    <ns>0</ns>
    <id>536</id>
    <revision>
      <id>50845</id>
      <parentid>43840</parentid>
      <timestamp>2013-06-01T03:41:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="389">{{include page|cpp/io/basic_stringstream/rdbuf|basic_istringstream}}

[[de:cpp/io/basic istringstream/rdbuf]]
[[es:cpp/io/basic istringstream/rdbuf]]
[[fr:cpp/io/basic istringstream/rdbuf]]
[[it:cpp/io/basic istringstream/rdbuf]]
[[ja:cpp/io/basic istringstream/rdbuf]]
[[pt:cpp/io/basic istringstream/rdbuf]]
[[ru:cpp/io/basic istringstream/rdbuf]]
[[zh:cpp/io/basic istringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/str</title>
    <ns>0</ns>
    <id>537</id>
    <revision>
      <id>50846</id>
      <parentid>43834</parentid>
      <timestamp>2013-06-01T03:41:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/io/basic_stringstream/str|basic_istringstream}}

[[de:cpp/io/basic istringstream/str]]
[[es:cpp/io/basic istringstream/str]]
[[fr:cpp/io/basic istringstream/str]]
[[it:cpp/io/basic istringstream/str]]
[[ja:cpp/io/basic istringstream/str]]
[[pt:cpp/io/basic istringstream/str]]
[[ru:cpp/io/basic istringstream/str]]
[[zh:cpp/io/basic istringstream/str]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/swap</title>
    <ns>0</ns>
    <id>538</id>
    <revision>
      <id>50847</id>
      <parentid>43827</parentid>
      <timestamp>2013-06-01T03:41:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="380">{{include page|cpp/io/basic_stringstream/swap|basic_istringstream}}

[[de:cpp/io/basic istringstream/swap]]
[[es:cpp/io/basic istringstream/swap]]
[[fr:cpp/io/basic istringstream/swap]]
[[it:cpp/io/basic istringstream/swap]]
[[ja:cpp/io/basic istringstream/swap]]
[[pt:cpp/io/basic istringstream/swap]]
[[ru:cpp/io/basic istringstream/swap]]
[[zh:cpp/io/basic istringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic istringstream/swap2</title>
    <ns>0</ns>
    <id>5492</id>
    <revision>
      <id>50848</id>
      <parentid>43822</parentid>
      <timestamp>2013-06-01T03:41:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="389">{{include page|cpp/io/basic_stringstream/swap2|basic_istringstream}}

[[de:cpp/io/basic istringstream/swap2]]
[[es:cpp/io/basic istringstream/swap2]]
[[fr:cpp/io/basic istringstream/swap2]]
[[it:cpp/io/basic istringstream/swap2]]
[[ja:cpp/io/basic istringstream/swap2]]
[[pt:cpp/io/basic istringstream/swap2]]
[[ru:cpp/io/basic istringstream/swap2]]
[[zh:cpp/io/basic istringstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream</title>
    <ns>0</ns>
    <id>539</id>
    <revision>
      <id>57664</id>
      <parentid>49673</parentid>
      <timestamp>2013-06-01T05:58:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2226">{{cpp/title|basic_ofstream}}
{{cpp/io/basic_ofstream/navbar}}
{{ddcl | header=fstream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_ofstream : public std::basic_ostream&lt;CharT, Traits&gt;
}}

The class template {{tt|basic_ofstream}} implements high-level output operations on file based streams. It interfaces a file-based streambuffer ({{lc|std::basic_filebuf}}) with the high-level interface of ({{lc|std::basic_ostream}}).

A typical implementation of {{tt|std::basic_ofstream}} holds only one non-derived data member: an instance of {{c|std::basic_filebuf&lt;CharT, Traits&gt;}}.

{{inheritance diagram/std-basic_ofstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | fstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|ofstream}} | {{c|basic_ofstream&lt;char&gt;}}}}
{{dsc | {{tt|wofstream}} | {{c|basic_ofstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc constructor | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc destructor | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc operator{{=}} | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc swap | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc rdbuf | basic_ofstream}}

{{dsc h2 | File operations }}
{{dsc inc | cpp/io/basic_fstream/dsc is_open | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc open | basic_ofstream}}
{{dsc inc | cpp/io/basic_fstream/dsc close | basic_ofstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc swap2 | basic_ofstream}}
{{dsc end}}

{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic ofstream]]
[[es:cpp/io/basic ofstream]]
[[fr:cpp/io/basic ofstream]]
[[it:cpp/io/basic ofstream]]
[[ja:cpp/io/basic ofstream]]
[[pt:cpp/io/basic ofstream]]
[[ru:cpp/io/basic ofstream]]
[[zh:cpp/io/basic ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/basic ofstream</title>
    <ns>0</ns>
    <id>540</id>
    <revision>
      <id>50849</id>
      <parentid>43808</parentid>
      <timestamp>2013-06-01T03:41:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="417">{{include page|cpp/io/basic_fstream/constructor|basic_ofstream}}

[[de:cpp/io/basic ofstream/basic ofstream]]
[[es:cpp/io/basic ofstream/basic ofstream]]
[[fr:cpp/io/basic ofstream/basic ofstream]]
[[it:cpp/io/basic ofstream/basic ofstream]]
[[ja:cpp/io/basic ofstream/basic ofstream]]
[[pt:cpp/io/basic ofstream/basic ofstream]]
[[ru:cpp/io/basic ofstream/basic ofstream]]
[[zh:cpp/io/basic ofstream/basic ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/close</title>
    <ns>0</ns>
    <id>541</id>
    <revision>
      <id>50850</id>
      <parentid>43802</parentid>
      <timestamp>2013-06-01T03:41:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/close|basic_ofstream}}

[[de:cpp/io/basic ofstream/close]]
[[es:cpp/io/basic ofstream/close]]
[[fr:cpp/io/basic ofstream/close]]
[[it:cpp/io/basic ofstream/close]]
[[ja:cpp/io/basic ofstream/close]]
[[pt:cpp/io/basic ofstream/close]]
[[ru:cpp/io/basic ofstream/close]]
[[zh:cpp/io/basic ofstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/is open</title>
    <ns>0</ns>
    <id>542</id>
    <revision>
      <id>50851</id>
      <parentid>43795</parentid>
      <timestamp>2013-06-01T03:41:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="357">{{include page|cpp/io/basic_fstream/is_open|basic_ofstream}}

[[de:cpp/io/basic ofstream/is open]]
[[es:cpp/io/basic ofstream/is open]]
[[fr:cpp/io/basic ofstream/is open]]
[[it:cpp/io/basic ofstream/is open]]
[[ja:cpp/io/basic ofstream/is open]]
[[pt:cpp/io/basic ofstream/is open]]
[[ru:cpp/io/basic ofstream/is open]]
[[zh:cpp/io/basic ofstream/is open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/open</title>
    <ns>0</ns>
    <id>543</id>
    <revision>
      <id>50852</id>
      <parentid>43789</parentid>
      <timestamp>2013-06-01T03:41:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/open|basic_ofstream}}

[[de:cpp/io/basic ofstream/open]]
[[es:cpp/io/basic ofstream/open]]
[[fr:cpp/io/basic ofstream/open]]
[[it:cpp/io/basic ofstream/open]]
[[ja:cpp/io/basic ofstream/open]]
[[pt:cpp/io/basic ofstream/open]]
[[ru:cpp/io/basic ofstream/open]]
[[zh:cpp/io/basic ofstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/operator=</title>
    <ns>0</ns>
    <id>544</id>
    <revision>
      <id>72275</id>
      <parentid>43783</parentid>
      <timestamp>2014-08-02T09:10:31Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>use {{include page}}</comment>
      <text xml:space="preserve" bytes="379">{{include page|cpp/io/basic_fstream/operator{{=}}|basic_ofstream}}

[[de:cpp/io/basic ofstream/operator=]]
[[es:cpp/io/basic ofstream/operator=]]
[[fr:cpp/io/basic ofstream/operator=]]
[[it:cpp/io/basic ofstream/operator=]]
[[ja:cpp/io/basic ofstream/operator=]]
[[pt:cpp/io/basic ofstream/operator=]]
[[ru:cpp/io/basic ofstream/operator=]]
[[zh:cpp/io/basic ofstream/operator=]]</text>
      <sha1>gzmfs4ev027o7vdi6uam0gidw1sx2qo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/rdbuf</title>
    <ns>0</ns>
    <id>545</id>
    <revision>
      <id>50853</id>
      <parentid>43777</parentid>
      <timestamp>2013-06-01T03:41:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/rdbuf|basic_ofstream}}

[[de:cpp/io/basic ofstream/rdbuf]]
[[es:cpp/io/basic ofstream/rdbuf]]
[[fr:cpp/io/basic ofstream/rdbuf]]
[[it:cpp/io/basic ofstream/rdbuf]]
[[ja:cpp/io/basic ofstream/rdbuf]]
[[pt:cpp/io/basic ofstream/rdbuf]]
[[ru:cpp/io/basic ofstream/rdbuf]]
[[zh:cpp/io/basic ofstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/swap</title>
    <ns>0</ns>
    <id>546</id>
    <revision>
      <id>50854</id>
      <parentid>43772</parentid>
      <timestamp>2013-06-01T03:41:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{include page|cpp/io/basic_fstream/swap|basic_ofstream}}

[[de:cpp/io/basic ofstream/swap]]
[[es:cpp/io/basic ofstream/swap]]
[[fr:cpp/io/basic ofstream/swap]]
[[it:cpp/io/basic ofstream/swap]]
[[ja:cpp/io/basic ofstream/swap]]
[[pt:cpp/io/basic ofstream/swap]]
[[ru:cpp/io/basic ofstream/swap]]
[[zh:cpp/io/basic ofstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ofstream/swap2</title>
    <ns>0</ns>
    <id>5490</id>
    <revision>
      <id>50855</id>
      <parentid>43765</parentid>
      <timestamp>2013-06-01T03:42:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="339">{{include page|cpp/io/basic_fstream/swap2|basic_ofstream}}

[[de:cpp/io/basic ofstream/swap2]]
[[es:cpp/io/basic ofstream/swap2]]
[[fr:cpp/io/basic ofstream/swap2]]
[[it:cpp/io/basic ofstream/swap2]]
[[ja:cpp/io/basic ofstream/swap2]]
[[pt:cpp/io/basic ofstream/swap2]]
[[ru:cpp/io/basic ofstream/swap2]]
[[zh:cpp/io/basic ofstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream</title>
    <ns>0</ns>
    <id>547</id>
    <revision>
      <id>57665</id>
      <parentid>49674</parentid>
      <timestamp>2013-06-01T05:58:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2657">{{cpp/title|basic_ostream}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl | header=ostream |
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;
&gt; class basic_ostream : virtual public std::basic_ios&lt;CharT, Traits&gt;
}}

The class template {{tt|basic_ostream}} provides support for high level output operations on character streams. The supported operations include formatted output (e.g. integer values) and unformatted output (e.g. raw characters and character arrays). This functionality is implemented in terms of the interface provided by the {{tt|basic_streambuf}} class, accessed through the {{tt|basic_ios}} base class. In typical implementations, {{tt|basic_ostream}} has no non-inherited data members.

{{inheritance diagram/std-basic_ostream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | ostream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|ostream}} | {{c|basic_ostream&lt;char&gt;}}}}
{{dsc | {{tt|wostream}} | {{c|basic_ostream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Global objects===
Six global basic_ostream objects are provided by the standard library.

{{dsc begin}}
{{dsc header | iostream}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc inc | cpp/io/dsc cerr}}
{{dsc inc | cpp/io/dsc clog}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc constructor}}
{{dsc inc | cpp/io/basic_ostream/dsc destructor}}
{{dsc inc | cpp/io/basic_ostream/dsc operator{{=}}}}

{{dsc h2 | Formatted output }}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}

{{dsc h2 | Unformatted output }}
{{dsc inc | cpp/io/basic_ostream/dsc put}}
{{dsc inc | cpp/io/basic_ostream/dsc write}}

{{dsc h2 | Positioning }}
{{dsc inc | cpp/io/basic_ostream/dsc tellp}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp}}

{{dsc h2 | Miscellaneous }}
{{dsc inc | cpp/io/basic_ostream/dsc flush}}
{{dsc inc | cpp/io/basic_ostream/dsc swap}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc sentry}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc end}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic ostream]]
[[es:cpp/io/basic ostream]]
[[fr:cpp/io/basic ostream]]
[[it:cpp/io/basic ostream]]
[[ja:cpp/io/basic ostream]]
[[pt:cpp/io/basic ostream]]
[[ru:cpp/io/basic ostream]]
[[zh:cpp/io/basic ostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/basic ostream</title>
    <ns>0</ns>
    <id>4283</id>
    <revision>
      <id>65102</id>
      <parentid>62736</parentid>
      <timestamp>2013-08-30T16:07:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt example</comment>
      <text xml:space="preserve" bytes="2016">{{cpp/io/basic_ostream/title | basic_ostream}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
explicit basic_ostream( std::basic_streambuf&lt;CharT, Traits&gt;* sb );
}}
{{dcl | num=2 | since=c++11 |1=
protected:
basic_ostream( const basic_ostream&amp; rhs ) = delete;
}}
{{dcl | num=3 | since=c++11 |1=
protected:
basic_ostream( basic_ostream&amp;&amp; rhs );
}}
{{dcl end}}

1) Constructs the {{tt|basic_ostream}} object, assigning initial values to the base class by calling {{c|basic_ios::init(sb)}}.

2) The copy constructor is protected, and is deleted. Output streams are not copyable.

3) The move constructor uses {{tt|basic_ios&lt;CharT, Traits&gt;::move(rhs)}} to move all basic_ios members, except for the {{tt|rdbuf()}}, from {{tt|rhs}} into {{tt|*this}}. This move constructor is protected: it is called by the move constructors of movable output stream classes {{lc|std::basic_ofstream}} and {{lc|std::basic_ostringstream}}, which know how to correctly move the associated streambuffer.

===Parameters===
{{par begin}}
{{par | sb | streambuffer to use as output sequence}}
{{par | rhs | basic_ostream to initialize from}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;utility&gt;
#include &lt;iostream&gt;

int main()
{
    // ERROR: copy ctor is deleted
//  std::ostream myout(std::cout);

    // OK: shares buffer with cout
    std::ostream myout(std::cout.rdbuf());

    // ERROR: move constructor is protected
//  std::ostream s2(std::move(std::ostringstream() &lt;&lt; 7.1));    

    // OK: move ctor called through the derived class
    std::ostringstream s2(std::move(std::ostringstream() &lt;&lt; 7.1)); 
    myout &lt;&lt; s2.str() &lt;&lt; '\n';
}
| output=
7.1
}}

[[de:cpp/io/basic ostream/basic ostream]]
[[es:cpp/io/basic ostream/basic ostream]]
[[fr:cpp/io/basic ostream/basic ostream]]
[[it:cpp/io/basic ostream/basic ostream]]
[[ja:cpp/io/basic ostream/basic ostream]]
[[pt:cpp/io/basic ostream/basic ostream]]
[[ru:cpp/io/basic ostream/basic ostream]]
[[zh:cpp/io/basic ostream/basic ostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/flush</title>
    <ns>0</ns>
    <id>548</id>
    <revision>
      <id>66233</id>
      <parentid>57668</parentid>
      <timestamp>2013-11-10T00:31:10Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1621">{{cpp/io/basic_ostream/title | flush}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl |
basic_ostream&amp; flush();
}}

Writes uncommitted changes to the underlying output sequence. 

If rdbuf() is a null pointer, does nothing

Otherwise, behaves as an {{concept|UnformattedOutputFunction}} {{mark since c++11}}. After constructing and checking the sentry object, calls {{c|rdbuf()-&gt;pubsync()}}. If the call returns {{c|-1}}, calls {{c|setstate(badbit)}}.

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
May throw {{lc|std::ios_base::failure}} if {{c|1=exceptions()&amp;badbit!=0}}.

===Example===
{{example
 | code=
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;chrono&gt;
void f()
{
    std::cout &lt;&lt; &quot;Output from thread...&quot;;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout &lt;&lt; &quot;...thread calls flush()\n&quot;;
    std::cout.flush();
}

int main()
{
    std::thread t1(f);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::clog &lt;&lt; &quot;Output from main\n&quot;;
    t1.join();
}
 | output=
Output from main
Output from thread.....thread calls flush()
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc sync | mem=std::basic_istream}}
{{dsc tfun | cpp/io/manip/flush | flushes the output stream}}
{{dsc tfun | cpp/io/manip/endl | outputs {{c|'\n'}} and flushes the output stream}}
{{dsc end}}

[[de:cpp/io/basic ostream/flush]]
[[es:cpp/io/basic ostream/flush]]
[[fr:cpp/io/basic ostream/flush]]
[[it:cpp/io/basic ostream/flush]]
[[ja:cpp/io/basic ostream/flush]]
[[pt:cpp/io/basic ostream/flush]]
[[ru:cpp/io/basic ostream/flush]]
[[zh:cpp/io/basic ostream/flush]]</text>
      <sha1>p3albe1hhu8g5zwdhvsnu2xp4oueykl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/operator=</title>
    <ns>0</ns>
    <id>4284</id>
    <revision>
      <id>62737</id>
      <parentid>49677</parentid>
      <timestamp>2013-07-01T23:35:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1702">{{cpp/io/basic_ostream/title | operator{{=}}}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
protected:
basic_istream&amp; operator=( const basic_ostream&amp; rhs ) = delete;
}}
{{dcl | num=2 | since=c++11 | 1=
protected:
basic_ostream&amp; operator=( basic_ostream&amp;&amp; rhs );
}}
{{dcl end}}

1) The copy assignment operator is protected, and is deleted. Output streams are not CopyAssignable.

2) The move assignment operator exchanges all data members of the base class, except for {{tt|rdbuf()}}, with {{tt|rhs}}, as if by calling {{c|swap(*rhs)}}. This move assignment operator is protected: it is only called by the move assignment operators of the derived movable output stream classes {{lc|std::basic_ofstream}} and {{lc|std::basic_ostringstream}}, which know how to correctly move-assign the associated streambuffers.

===Parameters===
{{par begin}}
{{par | rhs | the basic_ostream object from which to assign to {{c|*this}}}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;utility&gt;
#include &lt;iostream&gt;
int main()
{
    std::ostringstream s;
//  std::cout = s;                             // ERROR: copy assignment operator is deleted
//  std::cout = std::move(s);                  // ERROR: move assignment operator is protected
    s = std::move(std::ostringstream() &lt;&lt; 42); // OK, moved through derived
    std::cout &lt;&lt; s.str() &lt;&lt; '\n';
}
| output=
42
}}

[[de:cpp/io/basic ostream/operator=]]
[[es:cpp/io/basic ostream/operator=]]
[[fr:cpp/io/basic ostream/operator=]]
[[it:cpp/io/basic ostream/operator=]]
[[ja:cpp/io/basic ostream/operator=]]
[[pt:cpp/io/basic ostream/operator=]]
[[ru:cpp/io/basic ostream/operator=]]
[[zh:cpp/io/basic ostream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/operator ltlt</title>
    <ns>0</ns>
    <id>549</id>
    <revision>
      <id>71950</id>
      <parentid>66792</parentid>
      <timestamp>2014-07-04T11:00:58Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>use {{v}}</comment>
      <text xml:space="preserve" bytes="5283">{{cpp/io/basic_ostream/title | operator&lt;&lt;}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_ostream&amp; operator&lt;&lt;( short value );
basic_ostream&amp; operator&lt;&lt;( unsigned short value );
}}
{{dcl | num=2 |
basic_ostream&amp; operator&lt;&lt;( int value );
basic_ostream&amp; operator&lt;&lt;( unsigned int value );
}}
{{dcl | num=3 |
basic_ostream&amp; operator&lt;&lt;( long value );
basic_ostream&amp; operator&lt;&lt;( unsigned long value );
}}
{{dcl | num=4 | since=c++11 |
basic_ostream&amp; operator&lt;&lt;( long long value );
basic_ostream&amp; operator&lt;&lt;( unsigned long long value );
}}
{{dcl | num=5 |
basic_ostream&amp; operator&lt;&lt;( float value );
basic_ostream&amp; operator&lt;&lt;( double value );
basic_ostream&amp; operator&lt;&lt;( long double value );
}}
{{dcl | num=6 | 
basic_ostream&amp; operator&lt;&lt;( bool value );
}}
{{dcl | num=7 |
basic_ostream&amp; operator&lt;&lt;( const void* value );
}}
{{dcl | num=8 |
basic_ostream&amp; operator&lt;&lt;( std::basic_streambuf&lt;CharT, Traits&gt;* sb);
}}
{{dcl rev begin | num=9}}
{{dcl |
basic_ostream&amp; operator&lt;&lt;( std::ios_base&amp; (*func)(std::ios_base&amp;) );
}}
{{dcl |
basic_ostream&amp; operator&lt;&lt;( std::basic_ios&lt;CharT,Traits&gt;&amp; (*func)(std::basic_ios&lt;CharT,Traits&gt;&amp;) );
}}
{{dcl |
basic_ostream&amp; operator&lt;&lt;( std::basic_ostream&amp; (*func)(std::basic_ostream&amp;) );
}}
{{dcl rev end}}
{{dcl end}}

Inserts data into the stream. 

@1-2@ Behaves as an {{concept|FormattedOutputFunction}}. After constructing and checking the sentry object, if {{tt|value}} is {{c|short}} or {{c|int}}, then casts it to {{c|unsigned short}} or {{c|unsigned int}} if {{c|ios_base::flags() &amp; ios_base::basefield}} is {{c|ios_base::oct}} or {{c|ios_base::hex}}. After that, casts to {{c|long}} in any case and outputs as in {{v|3}}. If {{tt|value}} is {{c|unsigned short}} or {{c|unsigned int}}, casts to {{c|unsigned long}} and outputs as in {{v|3}}.

@3-7@ Behaves as an {{concept|FormattedOutputFunction}}. After constructing and checking the sentry object, inserts an integer, floating point, boolean or generic pointer value by calling {{ltt|cpp/locale/num_put/put|num_put::put()}}. If the end of file condition was encountered during output ({{c|1=put().failed() == true}}), sets {{c|ios::badbit}}.

@8@ Behaves as an {{concept|UnformattedOutputFunction}}. After constructing and checking the sentry object, checks if {{tt|sb}} is a null pointer. If it is, executes {{c|setstate(badbit)}} and exits. Otherwise, extracts characters from the input sequence controlled by {{tt|sb}} and inserts them into {{c|*this}} until one of the following conditions are met:
:* end-of-file occurs on the input sequence;
:* inserting in the output sequence fails (in which case the character to be inserted is not extracted);
:* an exception occurs (in which case the exception is caught).
If no characters were inserted, executes {{c|setstate(badbit)}}. If an exception was thrown while extracting, sets {{c|failbit}}

@9@ Calls {{c|func(*this);}}. This overload is used to implement output I/O manipulators such as {{lc|std::endl}}.

===Parameters===
{{par begin}}
{{par | value | integer, floating-point, boolean, or pointer value to insert}}
{{par | func | function to call }}
{{par | sb | pointer to the streambuffer to read the data from}}
{{par end}}

===Return value===

{{c|*this}}

===Notes===
There are no overload for pointers to volatile or function pointers (other than the ones with signatures accepted by the {{v|9}} overload). Attempting to output such objects invokes implicit conversion to {{c|bool}}, and, for any non-null pointer value, the value {{c|1}} is printed (unless {{c|boolalpha}} was set).

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;sstream&gt;
int main()
{
    std::istringstream input(&quot; \&quot;Some text.\&quot; &quot;);
    volatile int n = 42;
    double f = 3.14;
    bool b = true;;
    std::cout &lt;&lt; n   // int overload
              &lt;&lt; ' ' // non-member overload
              &lt;&lt; std::boolalpha &lt;&lt; b // bool overload
              &lt;&lt; &quot; &quot; // non-member overload
              &lt;&lt; std::fixed &lt;&lt; f // double overload
              &lt;&lt; input.rdbuf() // streambuf overload
              &lt;&lt; &amp;n // bool overload
              &lt;&lt; std::endl; // function overload
}
 | output=
42 true 3.140000 &quot;Some text.&quot; true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc tfun | cpp/string/basic_string/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream I/O of strings }}
{{dsc fun | cpp/utility/bitset/operator_ltltgtgt2 | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output of bitsets}}
{{dsc tfun | cpp/numeric/complex/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | serializes and deserializes a complex number }}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | uniform_int_distribution}}
{{dsc inc | cpp/io/basic_ostream/dsc put}}
{{dsc inc | cpp/io/basic_ostream/dsc write}}
{{dsc end}}

[[de:cpp/io/basic ostream/operator ltlt]]
[[es:cpp/io/basic ostream/operator ltlt]]
[[fr:cpp/io/basic ostream/operator ltlt]]
[[it:cpp/io/basic ostream/operator ltlt]]
[[ja:cpp/io/basic ostream/operator ltlt]]
[[pt:cpp/io/basic ostream/operator ltlt]]
[[ru:cpp/io/basic ostream/operator ltlt]]
[[zh:cpp/io/basic ostream/operator ltlt]]</text>
      <sha1>l1hcxjof66ks68g6h92t09a0r5954kk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/operator ltlt2</title>
    <ns>0</ns>
    <id>3765</id>
    <revision>
      <id>68000</id>
      <parentid>66707</parentid>
      <timestamp>2014-03-12T13:18:09Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="5185">{{title|operator&lt;&lt;{{small|(std::basic_ostream)}}}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | 
template&lt; class CharT, class Traits&gt;
basic_ostream&lt;CharT,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp; os,
                                         CharT ch );
}}
{{dcl |
template&lt; class CharT, class Traits&gt;
basic_ostream&lt;CharT,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp; os,
                                         char ch );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,Traits&gt;&amp; os,
                                        char ch );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,Traits&gt;&amp; os,
                                        signed char ch );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,Traits&gt;&amp; os,
                                        unsigned char ch );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl |
template&lt; class CharT, class Traits &gt;
basic_ostream&lt;CharT,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp; os, 
                                         const CharT* s );
}}
{{dcl |
template&lt; class CharT, class Traits &gt;
basic_ostream&lt;CharT,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp; os, 
                                         const char* s );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,Traits&gt;&amp; os,  
                                        const char* s );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,Traits&gt;&amp; os, 
                                        const signed char* s );
}}
{{dcl |
template&lt; class Traits &gt;
basic_ostream&lt;char,Traits&gt;&amp; operator&lt;&lt;( basic_ostream&lt;char,traits&gt;&amp; os, 
                                        const unsigned char* s );
}}
{{dcl rev end}}
{{dcl | num=3 | since=c++11 |
template&lt; class CharT, class Traits, class T &gt;
basic_ostream&lt; CharT, Traits &gt;&amp; operator&lt;&lt;( basic_ostream&lt;CharT,Traits&gt;&amp;&amp; os, 
                                            const T&amp; value );
}}
{{dcl end}}

Inserts a character or a character string.

@1@ Behaves as an {{concept|FormattedOutputFunction}}. After constructing and checking the sentry object, inserts the character {{tt|ch}}. If the type of the character is not {{tt|CharT}}, it is first converted with {{c|os.widen(ch)}}. Padding is determined as follows: if {{tt|os.width()&gt;1}}, then {{tt|os.width()-1}} copies of {{tt|os.fill()}} are added  to the output character to form the output character sequence.
If {{c|(out.flags()&amp;std::ios_base::adjustfield) {{==}} std::ios_base::left}}, the fill characters are placed after the output character, otherwise before. After insertion, {{c|os.width(0)}} is called to cancel the effects of {{lc|std::setw}}, if any.

@2@ Behaves as an {{concept|FormattedOutputFunction}}. After constructing and checking the sentry object, inserts successive characters from the character array whose first element is pointed to by {{tt|s}}.
* for the first and third overloads (where {{tt|CharT}} matches the type of {{tt|ch}}), exactly {{tt|traits::length(s)}} characters are inserted.
* for the second overload, exactly {{c|std::char_traits&lt;char&gt;::length(s)}} characters are inserted.
* for the last two overloads, exactly {{c|traits::length(reinterpret_cast&lt;const char*&gt;(s))}} are inserted. 
Before insertion, first, all characters are widened using {{c|os.widen()}}, then padding is determined as follows: if the number of characters to insert is less than {{tt|os.width()}}, then enough copies of {{tt|os.fill()}} are added to the character sequence to make its length equal {{tt|os.width()}}. If {{c|(out.flags()&amp;std::ios_base::adjustfield) {{==}} std::ios_base::left}}, the fill characters are added at the end of the output sequence, otherwise they are added before the output sequence.
After insertion, {{c|width(0)}} is called to cancel the effects of {{lc|std::setw}}, if any.

@3@ Calls the appropriate insertion operator, given an rvalue reference to an output stream object (equivalent to {{c|os &lt;&lt; value}}).

===Parameters===
{{par begin}}
{{par | os | output stream to insert data to}}
{{par | ch | reference to a character to insert}}
{{par | s | pointer to a character string to insert}}
{{par end}}

===Return value===
{{tt|st}}

===Example===
{{example 
| code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::cout &lt;&lt; &quot;Hello, world&quot; // the const char* overload
              &lt;&lt; '\n';          // the char overload
    std::string s = (std::ostringstream() &lt;&lt; 1.2).str(); // rvalue overload
    std::cout &lt;&lt; s &lt;&lt; '\n';
}
| output=
Hello, world
1.2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}
{{dsc inc | cpp/io/basic_ios/dsc widen}}
{{dsc end}}

[[de:cpp/io/basic ostream/operator ltlt2]]
[[es:cpp/io/basic ostream/operator ltlt2]]
[[fr:cpp/io/basic ostream/operator ltlt2]]
[[it:cpp/io/basic ostream/operator ltlt2]]
[[ja:cpp/io/basic ostream/operator ltlt2]]
[[pt:cpp/io/basic ostream/operator ltlt2]]
[[ru:cpp/io/basic ostream/operator ltlt2]]
[[zh:cpp/io/basic ostream/operator ltlt2]]</text>
      <sha1>39lrd0plorfewgg7rinmslh3a381yip</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/put</title>
    <ns>0</ns>
    <id>550</id>
    <revision>
      <id>63130</id>
      <parentid>57673</parentid>
      <timestamp>2013-07-02T00:16:06Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1909">{{cpp/io/basic_ostream/title | put}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl |
basic_ostream&amp; put( char_type ch );
}}

Behaves as an {{concept|UnformattedOutputFunction}}. After constructing and checking the sentry object, writes the character {{tt|ch}} to the output stream.

If the output fails for any reason, sets {{tt|badbit}}.

===Parameters===
{{par begin}}
{{par | ch | character to write}}
{{par end}}

===Return value===
{{c|*this}}

===Notes===
This function is not overloaded for the types {{c|signed char}} or {{c|unsigned char}}, unlike the formatted {{rlp|operator_ltlt2|operator&lt;&lt;}}

Unlike formatted output functions, this function does not set the {{tt|failbit}} if the output fails.

===Example===
{{example
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout.put('a'); // normal usage
    std::cout.put('\n');

    std::ofstream s(&quot;/does/not/exist/&quot;);
    s.clear(); // pretend the stream is good
    std::cout &lt;&lt; &quot;Unformatted output: &quot;;
    s.put('c'); // this will set badbit, but not failbit
    std::cout &lt;&lt; &quot; fail=&quot; &lt;&lt; bool(s.rdstate() &amp; s.failbit);
    std::cout &lt;&lt; &quot; bad=&quot; &lt;&lt; s.bad() &lt;&lt; '\n';
    s.clear();
    std::cout &lt;&lt; &quot;Formatted output:   &quot;;
    s &lt;&lt; 'c'; // this will set badbit and failbit
    std::cout &lt;&lt; &quot; fail=&quot; &lt;&lt; bool(s.rdstate() &amp; s.failbit);
    std::cout &lt;&lt; &quot; bad=&quot; &lt;&lt; s.bad() &lt;&lt; '\n';
}
 | output=
a
Unformatted output:  fail=0 bad=1
Formatted output:    fail=1 bad=1 &lt;!-- note: few compilers implement this correctly. Works in CLang++ --&gt;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc inc | cpp/io/basic_ostream/dsc write}}
{{dsc end}}

[[de:cpp/io/basic ostream/put]]
[[es:cpp/io/basic ostream/put]]
[[fr:cpp/io/basic ostream/put]]
[[it:cpp/io/basic ostream/put]]
[[ja:cpp/io/basic ostream/put]]
[[pt:cpp/io/basic ostream/put]]
[[ru:cpp/io/basic ostream/put]]
[[zh:cpp/io/basic ostream/put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/seekp</title>
    <ns>0</ns>
    <id>551</id>
    <revision>
      <id>68854</id>
      <parentid>66960</parentid>
      <timestamp>2014-03-22T19:07:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2341</comment>
      <text xml:space="preserve" bytes="2624">{{cpp/io/basic_ostream/title | seekp}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl | num=1| 1=
basic_ostream&amp; seekp( pos_type pos );
}}
{{dcl | num=2| 1=
basic_ostream&amp; seekp( off_type off, std::ios_base::seekdir dir);
}}
{{dcl end}}

Sets the output position indicator of the current associated {{tt|streambuf}} object. 

{{rev begin}}
{{rev | since=c++11 |
Behaves as {{concept|UnformattedOutputFunction}} (except without actually performing output). After constructing and checking the sentry object, 
}}
{{rev end}}

@1@ sets the output position indicator to absolute (relative to the beginning of the file) value {{tt|pos}} by calling {{c|rdbuf()-&gt;pubseekpos(pos, std::ios_base::out)}}. If the call returns {{c|(pos_type)-1}}, executes {{c|setstate(failbit)}}.
@2@ sets the output position indicator to offset {{tt|off}} relative to {{tt|dir}} by calling {{c|rdbuf()-&gt;pubseekoff(off, dir, std::ios_base::out)}}. {{rev begin}}
{{rev|until=c++14|Does not report errors.}}
{{rev|since=c++14|If the call returns {{c|(pos_type)-1}}, executes {{c|setstate(failbit)}}.}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | pos | absolute position to set the output position indicator to.}}
{{par | off | relative position to set the output position indicator to.}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ May throw {{lc|std::ios_base::failure}} in case of failure, if {{c|1=exceptions() &amp; failbit != 0}}.
@2@{{rev begin}}
{{rev|until=c++14| Does not throw unless {{c|rdbuf()-&gt;pubseekoff()}} throws}}
{{rev|since=c++14| May throw {{lc|std::ios_base::failure}} in case of failure, if {{c|1=exceptions() &amp; failbit != 0}}.}}
{{rev end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::ostringstream os(&quot;hello, world&quot;);
    os.seekp(7);
    os &lt;&lt; 'W';
    os.seekp(0, std::ios_base::end);
    os &lt;&lt; '!';
    os.seekp(0);
    os &lt;&lt; 'H';
    std::cout &lt;&lt; os.str() &lt;&lt; '\n';
}
 | output=
Hello, World!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc tellp}}
{{dsc inc | cpp/io/basic_istream/dsc tellg | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_istream/dsc seekg | mem=std::basic_istream}}
{{dsc end}}

[[de:cpp/io/basic ostream/seekp]]
[[es:cpp/io/basic ostream/seekp]]
[[fr:cpp/io/basic ostream/seekp]]
[[it:cpp/io/basic ostream/seekp]]
[[ja:cpp/io/basic ostream/seekp]]
[[pt:cpp/io/basic ostream/seekp]]
[[ru:cpp/io/basic ostream/seekp]]
[[zh:cpp/io/basic ostream/seekp]]</text>
      <sha1>nod5a21x410mcv790lw81vhe7wdmk9w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/sentry</title>
    <ns>0</ns>
    <id>552</id>
    <revision>
      <id>67409</id>
      <parentid>67406</parentid>
      <timestamp>2014-02-08T01:44:55Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <comment>Fully-qualified std::uncaught_exception()</comment>
      <text xml:space="preserve" bytes="3286">{{cpp/io/basic_ostream/title | sentry}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl |1=
class sentry;
}}
{{dcl end}}

An object of class {{tt|basic_ostream::sentry}} is constructed in local scope at the beginning of each member function of {{lc|std::basic_ostream}} that performs output (both formatted and unformatted). Its constructor prepares the output stream: checks if the stream is already in a failed state, flushes the tie()'d output streams, and performs other implementation-defined tasks if necessary. Implementation-defined cleanup, as well as flushing of the output stream if necessary, is performed in the destructor, so that it is guaranteed to happen if exceptions are thrown during output.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/sentry/dsc constructor}}
{{dsc mem dtor | cpp/io/basic_ostream/sentry | inlinemem=true | finalizes the stream object after formatted output or after exception, if necessary}}
{{dsc mem fun | operator{{=}}| nolink=true | the assignment operator is deleted}}
{{dsc inc | cpp/io/basic_ostream/sentry/dsc operator bool}}
{{dsc end}}

{{member | {{small|std::basic_ostream::sentry::}}sentry | 2=
{{ddcl | 1=
explicit sentry( std::basic_ostream&lt;CharT,Traits&gt;&amp; os );
}}

Prepares the stream for formatted output.

If {{c|os.good()}} is {{c|false}}, returns. Otherwise, if {{c|os.tie()}} is not a null pointer, calls {{c|os.tie()-&gt;flush()}} to synchronize the output sequence with external streams. During preparation, the constructor may call {{c|setstate(failbit)}} (which may throw {{lc|std::ios_base::failure}}).

If after preparation is completed, {{c|is.good() {{==}} true}}, then any subsequent calls to {{c|operator bool}} will return {{c|true}}.

===Parameters===
{{par begin}}
{{par | os | output stream to prepare}}
{{par end}}

===Exceptions===
{{lc|std::ios_base::failure}} if the end of file condition occurs.
}}


{{member | {{small|std::basic_ostream::sentry::}}~sentry | 2=
{{ddcl | 1=
~sentry();
}}
If {{c|(os.flags() &amp; std::ios_base::unitbuf) &amp;&amp; !std::uncaught_exception() &amp;&amp; os.good())}} is {{c|true}}, calls {{c|os.rdbuf()-&gt;pubsync()}}. If that function returns {{c|-1}}, sets {{c|badbit}} in {{c|os.rdstate()}} without propagating an exception.
}}


{{member | {{small|std::basic_ostream::sentry::}}operator bool | 2=
{{ddcl | 1=
explicit operator bool() const;
}}
Checks whether the preparation of the output stream was successful.

===Parameters===
(none)

===Return value===
{{c|true}} if the preparation of the output stream was successful, {{c|false}} otherwise.
}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

struct Foo
{
    char n[6];
};

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; is, Foo&amp; f)
{
    std::ostream::sentry s(is);
    if (s) {
        is.write(f.n, 5);
    }
    return is;
}

int main()
{
    Foo f = { &quot;abcde&quot; };
    std::cout &lt;&lt; f &lt;&lt; '\n';
}
| output=
abcde
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}
{{dsc end}}

[[de:cpp/io/basic ostream/sentry]]
[[es:cpp/io/basic ostream/sentry]]
[[fr:cpp/io/basic ostream/sentry]]
[[it:cpp/io/basic ostream/sentry]]
[[ja:cpp/io/basic ostream/sentry]]
[[pt:cpp/io/basic ostream/sentry]]
[[ru:cpp/io/basic ostream/sentry]]
[[zh:cpp/io/basic ostream/sentry]]</text>
      <sha1>6xucuhyfg4gwmqeerimhbo6el2znnod</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/swap</title>
    <ns>0</ns>
    <id>4328</id>
    <revision>
      <id>62739</id>
      <parentid>49683</parentid>
      <timestamp>2013-07-01T23:35:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1310">{{cpp/io/basic_ostream/title | swap}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |1=
protected:
void swap(basic_ostream&amp; rhs);
}}
{{dcl end}}

Calls {{c|basic_ios::swap(rhs)}} to swap all data members of the base class, except for {{c|rdbuf()}}, between {{c|*this}} and {{tt|rhs}}. This swap function is protected: it is called by the swap functions of the swappable output stream classes {{lc|std::basic_ofstream}} and {{lc|std::basic_ostringstream}}, which know how to correctly swap the associated streambuffers.

===Parameters===
{{par begin}}
{{par | rhs | a basic_ostream of the same type to swap with}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;
int main()
{
    std::ostringstream s1(&quot;hello&quot;);
    std::ostringstream s2(&quot;bye&quot;);

    s1.swap(s2); // OK, ostringstream has a public swap()
    std::swap(s1, s2); // OK, calls s1.swap(s2)

//  std::cout.swap(s2); // ERROR: swap is a protected member

    std::cout &lt;&lt; s1.str() &lt;&lt; '\n';
}
| output=
hello
}}

[[de:cpp/io/basic ostream/swap]]
[[es:cpp/io/basic ostream/swap]]
[[fr:cpp/io/basic ostream/swap]]
[[it:cpp/io/basic ostream/swap]]
[[ja:cpp/io/basic ostream/swap]]
[[pt:cpp/io/basic ostream/swap]]
[[ru:cpp/io/basic ostream/swap]]
[[zh:cpp/io/basic ostream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/tellp</title>
    <ns>0</ns>
    <id>553</id>
    <revision>
      <id>61962</id>
      <parentid>57680</parentid>
      <timestamp>2013-06-12T15:55:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>rev box, link to concept</comment>
      <text xml:space="preserve" bytes="1534">{{cpp/io/basic_ostream/title | tellp}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl |
pos_type tellp();
}}

Returns the output position indicator of the current associated {{tt|streambuf}} object.

{{rev begin}}
{{rev | since=c++11 |
Behaves as {{concept|UnformattedOutputFunction}} (except without actually performing output). After constructing and checking the sentry object, 
}}
{{rev end}}
If {{c|1=fail()==true}}, returns {{c|pos_type(-1)}}. Otherwise, returns {{c|rdbuf()-&gt;pubseekoff(0, std::ios_base::cur, std::ios_base::out)}}.

===Parameters===
(none)

===Return value===
current output position indicator on success, {{c|pos_type(-1)}} if a failure occurs.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
int main()
{
    std::ostringstream s;
    std::cout &lt;&lt; s.tellp() &lt;&lt; '\n';
    s &lt;&lt; 'h';
    std::cout &lt;&lt; s.tellp() &lt;&lt; '\n';
    s &lt;&lt; &quot;ello, world &quot;;
    std::cout &lt;&lt; s.tellp() &lt;&lt; '\n';
    s &lt;&lt; 3.14 &lt;&lt; '\n';
    std::cout &lt;&lt; s.tellp() &lt;&lt; '\n' &lt;&lt; s.str();
}
 | output=
0
1
13
18
hello, world 3.14
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp}}
{{dsc inc | cpp/io/basic_istream/dsc tellg | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_istream/dsc seekg | mem=std::basic_istream}}
{{dsc end}}

[[de:cpp/io/basic ostream/tellp]]
[[es:cpp/io/basic ostream/tellp]]
[[fr:cpp/io/basic ostream/tellp]]
[[it:cpp/io/basic ostream/tellp]]
[[ja:cpp/io/basic ostream/tellp]]
[[pt:cpp/io/basic ostream/tellp]]
[[ru:cpp/io/basic ostream/tellp]]
[[zh:cpp/io/basic ostream/tellp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/write</title>
    <ns>0</ns>
    <id>554</id>
    <revision>
      <id>72069</id>
      <parentid>69656</parentid>
      <timestamp>2014-07-11T11:55:57Z</timestamp>
      <contributor>
        <username>Jankowalski25</username>
        <id>2468</id>
      </contributor>
      <comment>example: writing a character string</comment>
      <text xml:space="preserve" bytes="1994">{{cpp/io/basic_ostream/title | write}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl |
basic_ostream&amp; write( const char_type* s, std::streamsize count );
}}

Behaves as an {{concept|UnformattedOutputFunction}}. After constructing and checking the sentry object, outputs the characters from successive locations in the character array whose first element is pointed to by {{tt|s}}. Characters are inserted into the output sequence until one of the following occurs:
* exactly {{tt|count}} characters are inserted
* inserting into the output sequence fails (in which case {{c|setstate(badbit)}} is called)

===Parameters===
{{par begin}}
{{par | s | pointer to the character string to write}}
{{par | count | number of characters to write}}
{{par end}}

===Return value===
{{c|*this}}

===Notes===
This function is not overloaded for the types {{c|signed char}} or {{c|unsigned char}}, unlike the formatted {{rlp|operator_ltlt2|operator&lt;&lt;}}

Also, unlike the formatted output functions, this function does not set the {{tt|failbit}} on failure.

===Exceptions===
If an exception occurs during output and {{c|1=exceptions() &amp; badbit != 0}}, rethrows that exception.

If output fails and {{c|1=exceptions() &amp; badbit != 0}}, throws {{c|ios_base::failure}}.

===Example===
{{example
 | This function may be used to output object representations, i.e. binary output
 | code=
#include &lt;iostream&gt;

int main()
{
    int n = 0x41424344;
    std::cout.write(reinterpret_cast&lt;char*&gt;(&amp;n), sizeof n) &lt;&lt; '\n';

    char c[]=&quot;This is sample text.&quot;;
    std::cout.write(c,4)&lt;&lt;'\n';
}
 | output=
DCBA
This
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc inc | cpp/io/basic_ostream/dsc put}}
{{dsc end}}

[[de:cpp/io/basic ostream/write]]
[[es:cpp/io/basic ostream/write]]
[[fr:cpp/io/basic ostream/write]]
[[it:cpp/io/basic ostream/write]]
[[ja:cpp/io/basic ostream/write]]
[[pt:cpp/io/basic ostream/write]]
[[ru:cpp/io/basic ostream/write]]
[[zh:cpp/io/basic ostream/write]]</text>
      <sha1>pbnnxqffwswek4y7l8et099k00pvvzq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostream/~basic ostream</title>
    <ns>0</ns>
    <id>556</id>
    <revision>
      <id>49686</id>
      <parentid>43682</parentid>
      <timestamp>2013-06-01T02:51:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1196">{{cpp/io/basic_ostream/title | ~basic_ostream}}
{{cpp/io/basic_ostream/navbar}}
{{ddcl | 
virtual ~basic_ostream();
}}

Destroys the {{tt|basic_ostream}} object. This destructor does not perform any operation on the underlying streambuffer ({{tt|rdbuf()}}): the destructors of the derived output streams such as {{lc|std::basic_ofstream}} and {{lc|std::basic_ostringstream}} are responsible for calling the destructors of the streambuffers.

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
void add_words(std::streambuf* p)
{
    std::ostream buf(p); // buf shares the buffer with s
    buf &lt;&lt; &quot; is the answer&quot;;
} // calls the destructor of buf. p remains unaffected
int main()
{
    std::ostringstream s;
    s &lt;&lt; 42;
    add_words(s.rdbuf());
    s &lt;&lt; &quot;.&quot;;
    std::cout &lt;&lt; s.str() &lt;&lt; '\n';
}
| output = 
42 is the answer.
}}

[[de:cpp/io/basic ostream/~basic ostream]]
[[es:cpp/io/basic ostream/~basic ostream]]
[[fr:cpp/io/basic ostream/~basic ostream]]
[[it:cpp/io/basic ostream/~basic ostream]]
[[ja:cpp/io/basic ostream/~basic ostream]]
[[pt:cpp/io/basic ostream/~basic ostream]]
[[ru:cpp/io/basic ostream/~basic ostream]]
[[zh:cpp/io/basic ostream/~basic ostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream</title>
    <ns>0</ns>
    <id>557</id>
    <revision>
      <id>71794</id>
      <parentid>64354</parentid>
      <timestamp>2014-06-24T03:34:42Z</timestamp>
      <contributor>
        <username>JohnTobey</username>
        <id>3177</id>
      </contributor>
      <minor/>
      <comment>Typo</comment>
      <text xml:space="preserve" bytes="2399">{{cpp/title|basic_ostringstream}}
{{cpp/io/basic_ostringstream/navbar}}
{{dcl begin}}
{{dcl header | sstream}}
{{dcl rev begin}}
{{dcl | until=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_ostringstream;
}}
{{dcl | since=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;,
    class Allocator = std::allocator&lt;CharT&gt;
&gt; class basic_ostringstream;
}}
{{dcl rev end}}
{{dcl end}}

The class template {{tt|std::basic_ostringstream}} implements output operations on memory ({{lc|std::basic_string}}) based streams. It essentially wraps a raw string device implementation ({{lc|std::basic_stringbuf}}) into a higher-level interface ({{lc|std::basic_ostream}}). The complete interface to unique {{tt|std::basic_stringbuf}} members is provided.

{{inheritance diagram/std-basic_ostringstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | sstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|ostringstream}} | {{c|basic_ostringstream&lt;char&gt;}}}}
{{dsc | {{tt|wostringstream}} | {{c|basic_ostringstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc inc | cpp/io/dsc allocator_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc constructor | basic_ostringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc operator{{=}} | basic_ostringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap | basic_ostringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc rdbuf | basic_ostringstream}}

{{dsc h2 | String operations }}
{{dsc inc | cpp/io/basic_stringstream/dsc str | basic_ostringstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_ostringstream}}
{{dsc end}}

{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic ostringstream]]
[[es:cpp/io/basic ostringstream]]
[[fr:cpp/io/basic ostringstream]]
[[it:cpp/io/basic ostringstream]]
[[ja:cpp/io/basic ostringstream]]
[[pt:cpp/io/basic ostringstream]]
[[ru:cpp/io/basic ostringstream]]
[[zh:cpp/io/basic ostringstream]]</text>
      <sha1>ht253d8vh8x51hxjzu7fsq3qbuy2geb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/basic ostringstream</title>
    <ns>0</ns>
    <id>558</id>
    <revision>
      <id>50856</id>
      <parentid>43668</parentid>
      <timestamp>2013-06-01T03:42:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="507">{{include page|cpp/io/basic_stringstream/constructor|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/basic ostringstream]]
[[es:cpp/io/basic ostringstream/basic ostringstream]]
[[fr:cpp/io/basic ostringstream/basic ostringstream]]
[[it:cpp/io/basic ostringstream/basic ostringstream]]
[[ja:cpp/io/basic ostringstream/basic ostringstream]]
[[pt:cpp/io/basic ostringstream/basic ostringstream]]
[[ru:cpp/io/basic ostringstream/basic ostringstream]]
[[zh:cpp/io/basic ostringstream/basic ostringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/operator=</title>
    <ns>0</ns>
    <id>559</id>
    <revision>
      <id>43663</id>
      <parentid>1117</parentid>
      <timestamp>2012-11-03T03:26:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="416">{{cpp/io/basic_stringstream/operator{{=}}|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/operator=]]
[[es:cpp/io/basic ostringstream/operator=]]
[[fr:cpp/io/basic ostringstream/operator=]]
[[it:cpp/io/basic ostringstream/operator=]]
[[ja:cpp/io/basic ostringstream/operator=]]
[[pt:cpp/io/basic ostringstream/operator=]]
[[ru:cpp/io/basic ostringstream/operator=]]
[[zh:cpp/io/basic ostringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/rdbuf</title>
    <ns>0</ns>
    <id>560</id>
    <revision>
      <id>50857</id>
      <parentid>43657</parentid>
      <timestamp>2013-06-01T03:42:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="389">{{include page|cpp/io/basic_stringstream/rdbuf|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/rdbuf]]
[[es:cpp/io/basic ostringstream/rdbuf]]
[[fr:cpp/io/basic ostringstream/rdbuf]]
[[it:cpp/io/basic ostringstream/rdbuf]]
[[ja:cpp/io/basic ostringstream/rdbuf]]
[[pt:cpp/io/basic ostringstream/rdbuf]]
[[ru:cpp/io/basic ostringstream/rdbuf]]
[[zh:cpp/io/basic ostringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/str</title>
    <ns>0</ns>
    <id>561</id>
    <revision>
      <id>50858</id>
      <parentid>43651</parentid>
      <timestamp>2013-06-01T03:42:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/io/basic_stringstream/str|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/str]]
[[es:cpp/io/basic ostringstream/str]]
[[fr:cpp/io/basic ostringstream/str]]
[[it:cpp/io/basic ostringstream/str]]
[[ja:cpp/io/basic ostringstream/str]]
[[pt:cpp/io/basic ostringstream/str]]
[[ru:cpp/io/basic ostringstream/str]]
[[zh:cpp/io/basic ostringstream/str]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/swap</title>
    <ns>0</ns>
    <id>562</id>
    <revision>
      <id>50859</id>
      <parentid>43645</parentid>
      <timestamp>2013-06-01T03:42:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="380">{{include page|cpp/io/basic_stringstream/swap|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/swap]]
[[es:cpp/io/basic ostringstream/swap]]
[[fr:cpp/io/basic ostringstream/swap]]
[[it:cpp/io/basic ostringstream/swap]]
[[ja:cpp/io/basic ostringstream/swap]]
[[pt:cpp/io/basic ostringstream/swap]]
[[ru:cpp/io/basic ostringstream/swap]]
[[zh:cpp/io/basic ostringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic ostringstream/swap2</title>
    <ns>0</ns>
    <id>5493</id>
    <revision>
      <id>50860</id>
      <parentid>43639</parentid>
      <timestamp>2013-06-01T03:42:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="389">{{include page|cpp/io/basic_stringstream/swap2|basic_ostringstream}}

[[de:cpp/io/basic ostringstream/swap2]]
[[es:cpp/io/basic ostringstream/swap2]]
[[fr:cpp/io/basic ostringstream/swap2]]
[[it:cpp/io/basic ostringstream/swap2]]
[[ja:cpp/io/basic ostringstream/swap2]]
[[pt:cpp/io/basic ostringstream/swap2]]
[[ru:cpp/io/basic ostringstream/swap2]]
[[zh:cpp/io/basic ostringstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf</title>
    <ns>0</ns>
    <id>563</id>
    <revision>
      <id>57685</id>
      <parentid>49688</parentid>
      <timestamp>2013-06-01T05:58:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="6343">{{cpp/title|basic_streambuf}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | header=streambuf | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_streambuf;
}}

The class {{tt|basic_streambuf}} controls input and output to a character sequence. It includes and provides access to
@1@ The ''controlled character sequence'', also called the ''buffer'', which may contain ''input sequence'' (also called ''get area'') for buffering the input operations and/or ''output sequence'' (also called ''put area'') for buffering the output operations.
@2@ The ''associated character sequence'', also called ''source'' (for input) or ''sink'' (for output). This may be an entity that is accessed through OS API (file, TCP socket, serial port, other character device), or it may be an object (std::vector, array, string literal), that can be interpreted as a character source or sink.

The I/O stream objects {{lc|std::basic_istream}} and {{lc|std::basic_ostream}}, as well as all objects derived from them ({{lc|std::ofstream}}, {{lc|std::stringstream}}, etc), are implemented entirely in terms of {{lc|std::basic_streambuf}}.

The controlled character sequence is an array of {{tt|CharT}} which, at all times, represents a subsequence, or a &quot;window&quot; into the associated character sequence. Its state is described by three pointers:

@1@ The ''beginning pointer'', always points at the lowest element of the buffer
@2@ The ''next pointer'', points at the element that is the next candidate for reading or writing
@3@ The ''end pointer'', points one past the end of the buffer.

A {{tt|basic_streambuf}} object may support input (in which case the buffer described by the beginning, next, and end pointers is called ''get area''), output (''put area''), or input and output simultaneously. In latter case, six pointers are tracked, which may all point to elements of the same character array or two individual arrays.

If the next pointer is less than the end pointer in the put area, a ''write position'' is available. The next pointer can be dereferenced and assigned to.

If the next pointer is less than the end pointer in the get area, a ''read position'' is available. The next pointer can be dereferenced and read from.

If the next pointer is greater than the beginning pointer in a get area, a ''putback position'' is available, and the next pointer may be decremented, dereferenced, and assigned to, in order to put a character back into the get area.

The character representation and encoding in the controlled sequence may be different from the character representations in the associated sequence, in which case a {{lc|std::codecvt}} locale facet is typically used to perform the conversion. Common examples are UTF-8 (or other multibyte) files accessed through {{lc|std::wfstream}} objects: the controlled sequence consists of {{c|wchar_t}} characters, but the associated sequence consists of bytes.

Typical implementation of the {{tt|std::basic_streambuf}} base class holds only the six {{tt|CharT*}} pointers and a copy of {{lc|std::locale}} as data members. In addition, implementations may keep cached copies of locale facets, which are invalidated whenever {{tt|imbue()}} is called. The concrete buffers such as {{lc|std::basic_filebuf}} or {{lc|std::basic_stringbuf}} are derived from {{tt|std::basic_streambuf}}.

{{image|std-streambuf.svg}}

Two convenience typedefs are provided by the standard library

{{dsc begin}}
{{dsc header | streambuf}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|streambuf}} | {{c|basic_streambuf&lt;char&gt;}}}}
{{dsc | {{tt|wstreambuf}} | {{c|basic_streambuf&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc ~basic_streambuf}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubimbue}}
{{dsc inc | cpp/io/basic_streambuf/dsc getloc}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsetbuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekoff}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsync}}

{{dsc h2 | Get area}}
{{dsc inc | cpp/io/basic_streambuf/dsc in_avail}}
{{dsc inc | cpp/io/basic_streambuf/dsc snextc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sbumpc}}
{{dsc inc | cpp/io/basic_streambuf/dsc stossc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetn}}

{{dsc h2 | Put area}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputn}}

{{dsc h2 | Putback}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}

{{dsc h1 | Protected member functions}}
{{dsc inc | cpp/io/basic_streambuf/dsc basic_streambuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_streambuf/dsc swap}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/basic_streambuf/dsc imbue}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_streambuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc sync}}

{{dsc h2 | Get area}}
{{dsc inc | cpp/io/basic_streambuf/dsc showmanyc}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc uflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc xsgetn}}
{{dsc inc | cpp/io/basic_streambuf/dsc gptr}}
{{dsc inc | cpp/io/basic_streambuf/dsc gbump}}
{{dsc inc | cpp/io/basic_streambuf/dsc setg}}

{{dsc h2 | Put area}}
{{dsc inc | cpp/io/basic_streambuf/dsc xsputn}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc pptr}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbump}}
{{dsc inc | cpp/io/basic_streambuf/dsc setp}}

{{dsc h2 | Putback}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbackfail}}
{{dsc end}}

[[de:cpp/io/basic streambuf]]
[[es:cpp/io/basic streambuf]]
[[fr:cpp/io/basic streambuf]]
[[it:cpp/io/basic streambuf]]
[[ja:cpp/io/basic streambuf]]
[[pt:cpp/io/basic streambuf]]
[[ru:cpp/io/basic streambuf]]
[[zh:cpp/io/basic streambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/basic streambuf</title>
    <ns>0</ns>
    <id>9699</id>
    <revision>
      <id>63942</id>
      <parentid>62740</parentid>
      <timestamp>2013-08-01T15:42:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="1679">{{cpp/io/basic_streambuf/title | basic_streambuf}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
protected:
basic_streambuf();
}}
{{dcl | num=2 | since=c++11 | |1=
protected:
basic_streambuf(const basic_streambuf&amp; rhs);
}}
{{dcl end}}

@1@ Constructs the {{tt|basic_streambuf}} object, initializes the six pointer members ({{tt|eback()}}, {{tt|gptr()}}, {{tt|egptr()}}, {{tt|pbase()}}, {{tt|pptr()}}, and {{tt|epptr()}}) to null pointer values, and the locale member to {{c|std::locale()}}, a copy of the global C++ locale at the time of construction.
@2@ Constructs a copy of {{tt|rhs}}, initializing the six pointers and the locale object with the copies of the values held by {{tt|rhs}}. Note that this is a shallow copy: the pointers of the newly-constructed basic_streambuf are pointing into the same character array as the pointers of {{tt|rhs}}.

Both constructors are protected, and are only called by the concrete streambuf classes, such as {{lc|std::basic_filebuf}}, {{lc|std::basic_stringbuf}}, or {{c|std::strstreambuf}}.

===Parameters===
{{par begin}}
{{par | rhs | a streambuf object to copy}}
{{par end}}

===Notes===
Until C++11, it was unspecified whether {{tt|basic_streambuf}} or any of its derived classes is {{concept|CopyConstructible}} ([http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#421 LWG issue 421]), and different C++ library implementations provided different options.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc basic_filebuf}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc inc | cpp/io/strstreambuf/dsc strstreambuf}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/eback</title>
    <ns>0</ns>
    <id>4894</id>
    <redirect title="cpp/io/basic streambuf/gptr" />
    <revision>
      <id>17633</id>
      <timestamp>2012-01-17T21:17:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/gptr]]</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_streambuf/gptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/egptr</title>
    <ns>0</ns>
    <id>4893</id>
    <redirect title="cpp/io/basic streambuf/gptr" />
    <revision>
      <id>17632</id>
      <timestamp>2012-01-17T21:17:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/gptr]]</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_streambuf/gptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/epptr</title>
    <ns>0</ns>
    <id>4891</id>
    <redirect title="cpp/io/basic streambuf/pptr" />
    <revision>
      <id>17630</id>
      <timestamp>2012-01-17T21:16:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>let's have a single page for these functions</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_streambuf/pptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/gbump</title>
    <ns>0</ns>
    <id>4897</id>
    <revision>
      <id>61081</id>
      <parentid>57689</parentid>
      <timestamp>2013-06-05T10:41:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="813">{{cpp/io/basic_streambuf/title|gbump}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
void gbump( int count );
}}

Skips {{tt|count}} characters in the get area. This is done by advancing the ''get pointer'' by {{tt|count}} characters. No checks are done for underflow.

===Parameters===
{{par begin}}
{{par | count | number of characters to skip}}
{{par end}}

===Return value===
(none)

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbump}}
{{dsc end}}

[[de:cpp/io/basic streambuf/gbump]]
[[es:cpp/io/basic streambuf/gbump]]
[[fr:cpp/io/basic streambuf/gbump]]
[[it:cpp/io/basic streambuf/gbump]]
[[ja:cpp/io/basic streambuf/gbump]]
[[pt:cpp/io/basic streambuf/gbump]]
[[ru:cpp/io/basic streambuf/gbump]]
[[zh:cpp/io/basic streambuf/gbump]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/getloc</title>
    <ns>0</ns>
    <id>4872</id>
    <revision>
      <id>64235</id>
      <parentid>61071</parentid>
      <timestamp>2013-08-15T15:55:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="880">{{cpp/io/basic_streambuf/title|getloc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl |
std::locale getloc() const;
}}

Returns the associated locale.

The associated locale is the value supplied to {{lc|pubimbue()}} on the last call, or, if that function has not been called, the value of the global locale ({{lc|std::locale}}) at the time of the construction of the streambuf.

===Parameters===
(none)

===Return value===
The associated locale.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubimbue}}
{{dsc end}}

[[de:cpp/io/basic streambuf/getloc]]
[[es:cpp/io/basic streambuf/getloc]]
[[fr:cpp/io/basic streambuf/getloc]]
[[it:cpp/io/basic streambuf/getloc]]
[[ja:cpp/io/basic streambuf/getloc]]
[[pt:cpp/io/basic streambuf/getloc]]
[[ru:cpp/io/basic streambuf/getloc]]
[[zh:cpp/io/basic streambuf/getloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/gptr</title>
    <ns>0</ns>
    <id>4895</id>
    <revision>
      <id>62371</id>
      <parentid>57693</parentid>
      <timestamp>2013-06-27T01:01:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1109">{{cpp/io/basic_streambuf/title|eback, gptr, egptr}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |
char_type* eback() const;
}}
{{dcl | num=2 |
char_type* gptr() const;
}}
{{dcl | num=3 |
char_type* egptr() const;
}}
{{dcl end}}

Returns pointers defining the get area.

1) Returns the pointer to the beginning of the get area.

2) Returns the pointer to the current character (''get pointer'') in the get area.

3) Returns the pointer to the end of the get area.

===Parameters===
(none)

===Return value===
1) The pointer to the beginning of the get area.

2) The pointer to the current character (''get pointer'') in the get area.

3) The pointer to the end of the get area.

===Example===
{{example |
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pptr}}
{{dsc end}}

[[de:cpp/io/basic streambuf/gptr]]
[[es:cpp/io/basic streambuf/gptr]]
[[fr:cpp/io/basic streambuf/gptr]]
[[it:cpp/io/basic streambuf/gptr]]
[[ja:cpp/io/basic streambuf/gptr]]
[[pt:cpp/io/basic streambuf/gptr]]
[[ru:cpp/io/basic streambuf/gptr]]
[[zh:cpp/io/basic streambuf/gptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/imbue</title>
    <ns>0</ns>
    <id>4871</id>
    <redirect title="cpp/io/basic streambuf/pubimbue" />
    <revision>
      <id>17583</id>
      <timestamp>2012-01-17T12:15:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/pubimbue]]</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/io/basic streambuf/pubimbue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/in avail</title>
    <ns>0</ns>
    <id>4878</id>
    <revision>
      <id>64242</id>
      <parentid>57694</parentid>
      <timestamp>2013-08-15T15:59:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1564">{{cpp/io/basic_streambuf/title|in_avail}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
std::streamsize in_avail();
}}

Returns the number of characters available in the get area. If a read position is available, effectively returns {{c|egptr() - gptr()}}, the size of the get area. In this case, the number of bytes returned is the number of bytes that can be extracted from the buffer without calling {{lc|underflow()}}.

If the get area is empty, calls {{lc|showmanyc()}} to determine the number of bytes available in the associated character sequence. In this case, the value returned is the number of bytes that can be extracted from the buffer while it's guaranteed that {{lc|underflow()}} would not return {{tt|Traits::eof}}.

===Parameters===
(none)

===Return value===
The number of characters available for non-blocking read (either the size of the get area or the number of characters ready for reading from the associated character sequence), or {{c|-1}} if no characters are available in the associated sequence as far as {{lc|showmanyc()}} can tell.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc showmanyc}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc end}}

[[de:cpp/io/basic streambuf/in avail]]
[[es:cpp/io/basic streambuf/in avail]]
[[fr:cpp/io/basic streambuf/in avail]]
[[it:cpp/io/basic streambuf/in avail]]
[[ja:cpp/io/basic streambuf/in avail]]
[[pt:cpp/io/basic streambuf/in avail]]
[[ru:cpp/io/basic streambuf/in avail]]
[[zh:cpp/io/basic streambuf/in avail]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/operator=</title>
    <ns>0</ns>
    <id>12583</id>
    <revision>
      <id>61083</id>
      <timestamp>2013-06-05T10:48:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="444">{{cpp/io/basic_streambuf/title|operator{{=}}}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
basic_streambuf&amp; operator=( const basic_streambuf&amp; other );
}}
{{dcl end}}

Assigns the data members of {{tt|other}} to {{c|*this}}.

===Parameters===
{{par begin}}
{{par | other | stream buffer to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
(none)

===Example===
{{example|
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/overflow</title>
    <ns>0</ns>
    <id>4890</id>
    <revision>
      <id>72224</id>
      <parentid>71948</parentid>
      <timestamp>2014-07-24T13:33:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>wikilink put area to basic_streambuf, consistent naming of the put area</comment>
      <text xml:space="preserve" bytes="3684">{{cpp/io/basic_streambuf/title|overflow}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
virtual int_type overflow( int_type ch = traits::eof() );
}}

Ensures that there is space at the [[cpp/io/basic_streambuf|put area]] for at least one character by saving some initial subsequence of characters starting at {{lc|pbase()}} to the output sequence and updating the pointers to the put area (if needed). If {{tt|ch}} is not {{c|Traits::eof()}} (i.e. {{c|1=Traits::eq_int_type(ch, Traits::eof()) != true}}), it is either put to the put area or directly saved to the output sequence.

The function may update {{tt|pptr}}, {{tt|epptr}} and {{tt|pbase}} pointers to define the location to write more data. On failure, the function ensures that either {{c|pptr() {{==}} nullptr}} or {{c|pptr() {{==}} epptr}}.

The base class version of the function does nothing. The derived classes may override this function to allow updates to the put area in the case of exhaustion.

===Parameters===
{{par begin}}
{{par | ch | the character to store in the put area}}
{{par end}}

===Return value===
Returns unspecified value not equal to {{c|Traits::eof()}} on success, {{c|Traits::eof()}} on failure.

The base class version of the function returns {{c|Traits::eof()}}.

===Note===
The {{lc|sputc()}} and {{lc|sputn()}} call this function in case of an overflow ({{c|1=pptr() == nullptr}} or {{c|1=pptr() &gt;= epptr()}}).

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;array&gt;

// Buffer for std::ostream implemented by std::array
template&lt;std::size_t SIZE, class CharT = char&gt;
class ArrayedStreamBuffer : public std::basic_streambuf&lt;CharT&gt; {
public:

    using Base = std::basic_streambuf&lt;CharT&gt;;
    using char_type = typename Base::char_type;
    using int_type = typename Base::int_type;

    ArrayedStreamBuffer() : buffer_{} // value-initialize buffer_ to all zeroes
    {
        Base::setp(buffer_.begin(), buffer_.end()); // set std::basic_streambuf
            // put area pointers to work with 'buffer_'
    }

    int_type overflow(int_type ch) 
    {
        std::cout &lt;&lt; &quot;overflow\n&quot;;
        return Base::overflow(ch);
    }

    void print_buffer()
    {
        for (const auto&amp; i: buffer_) {
            if (i == 0) {
                std::cout &lt;&lt; &quot;NULL&quot;;
            } else {
                std::cout &lt;&lt; i;
            }
            std::cout &lt;&lt; &quot; &quot;;
        }
        std::cout &lt;&lt; &quot;\n&quot;;
    }

private:
    std::array&lt;char_type, SIZE&gt; buffer_;
};

int main()
{
    ArrayedStreamBuffer&lt;10&gt; streambuf;
    std::ostream stream(&amp;streambuf);

    stream &lt;&lt; &quot;hello&quot;;
    streambuf.print_buffer();
    if (stream.good()) {
        std::cout &lt;&lt; &quot;stream is good\n&quot;;
    }

    stream &lt;&lt; &quot;world&quot;;
    streambuf.print_buffer();
    if (stream.good()) {
        std::cout &lt;&lt; &quot;stream is good\n&quot;;
    }

    stream &lt;&lt; &quot;!&quot;;
    streambuf.print_buffer();
    if (!stream.good()) {
        std::cout &lt;&lt; &quot;stream is not good\n&quot;;
    }
}
 | output=
h e l l o NULL NULL NULL NULL NULL 
stream is good
h e l l o w o r l d 
stream is good
overflow
h e l l o w o r l d 
stream is not good
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc uflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc overflow}}
{{dsc inc | cpp/io/strstreambuf/dsc overflow}}
{{dsc end}}

[[de:cpp/io/basic streambuf/overflow]]
[[es:cpp/io/basic streambuf/overflow]]
[[fr:cpp/io/basic streambuf/overflow]]
[[it:cpp/io/basic streambuf/overflow]]
[[ja:cpp/io/basic streambuf/overflow]]
[[pt:cpp/io/basic streambuf/overflow]]
[[ru:cpp/io/basic streambuf/overflow]]
[[zh:cpp/io/basic streambuf/overflow]]</text>
      <sha1>7gzbj2fhwobgm9p27staz6z9oppk9v8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pbackfail</title>
    <ns>0</ns>
    <id>9693</id>
    <revision>
      <id>64276</id>
      <parentid>64275</parentid>
      <timestamp>2013-08-15T16:17:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2533">{{cpp/io/basic_streambuf/title | pbackfail}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | 1=
protected:
virtual int_type pbackfail( int_type c = Traits::eof() );
}}
{{dcl end}}

This protected virtual function is called by the public functions {{lc|sungetc()}} and {{lc|sputbackc()}} (which, in turn, are called by {{l2tt|cpp/io/basic_istream/unget}} and {{l2tt|cpp/io/basic_istream/putback}}) when either:
@1@ There is no putback position in the get area ({{tt|pbackfail()}} is called with no arguments). In this situation, the purpose of {{tt|pbackfail()}} is to back up the get area by one character, if the associated character sequence allows this (e.g. a file-backed streambuf may reload the buffer from a file, starting one character earlier). 
@2@ The caller attempts to putback a different character from the one retrieved earlier ({{tt|pbackfail()}} is called with the character that needs to be put back). In this situation, the purpose of {{tt|pbackfail()}} is to place the character {{tt|c}} into the get area at the position just before {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}, and, if possible, to modify the associated character sequence to reflect this change. This may involve backing up the get area as in the first variant.

The default base class version of this function does nothing and returns {{c|Traits::eof()}} in all situations. This function is overloaded by the derived classes: {{l2tt|cpp/io/basic_stringbuf/pbackfail}}, {{l2tt|cpp/io/basic_filebuf/pbackfail}}, {{l2tt|cpp/io/strstreambuf/pbackfail}}, and is expected to be overloaded by user-defined and third-party library stream classes.

===Parameters===
{{par begin}}
{{par | ch | character to put back or {{c|Traits::eof()}} if only back out is requested}}
{{par end}}

===Return value===
{{c|Traits::eof()}} in case of failure, some other value to indicate success. The base class version always fails.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_stringbuf/dsc pbackfail}}
{{dsc inc | cpp/io/strstreambuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sputn]]
[[es:cpp/io/basic streambuf/sputn]]
[[fr:cpp/io/basic streambuf/sputn]]
[[it:cpp/io/basic streambuf/sputn]]
[[ja:cpp/io/basic streambuf/sputn]]
[[pt:cpp/io/basic streambuf/sputn]]
[[ru:cpp/io/basic streambuf/sputn]]
[[zh:cpp/io/basic streambuf/sputn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pbase</title>
    <ns>0</ns>
    <id>4892</id>
    <redirect title="cpp/io/basic streambuf/pptr" />
    <revision>
      <id>17634</id>
      <parentid>17631</parentid>
      <timestamp>2012-01-17T21:20:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[cpp/io/basic streambuf/pback]] to [[cpp/io/basic streambuf/pbase]]: typo in title</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_streambuf/pptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pbump</title>
    <ns>0</ns>
    <id>4898</id>
    <revision>
      <id>64245</id>
      <parentid>57699</parentid>
      <timestamp>2013-08-15T16:00:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1740">{{cpp/io/basic_streambuf/title|pbump}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
void pbump( int count );
}}

Repositions the ''put pointer'' ({{lc|pptr()}}) by {{tt|count}} characters, where {{tt|count}} may be positive or negative. No checks are done for moving the pointer outside the put area {{tt|[pbase(), epptr())}}.

If the pointer is advanced and then {{lc|overflow()}} is called to flush the put area to the associated character sequence, the effect is that extra {{tt|count}} characters with undefined values are output.

===Parameters===
{{par begin}}
{{par | count | number to add to the put pointer}}
{{par end}}

===Return value===
(none)

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;fstream&gt;

struct showput_streambuf : std::filebuf
{
    using std::filebuf::pbump; // expose protected
    std::string showput() const {
        return std::string(pbase(), pptr());
    }
};

int main()
{
    showput_streambuf mybuf;
    mybuf.open(&quot;test.txt&quot;, std::ios_base::out);
    std::ostream str(&amp;mybuf);
    str &lt;&lt; &quot;This is a test&quot; &lt;&lt; std::flush &lt;&lt; &quot;1234&quot;;
    std::cout &lt;&lt; &quot;The put area contains: &quot; &lt;&lt; mybuf.showput() &lt;&lt; '\n';
    mybuf.pbump(10);
    std::cout &lt;&lt; &quot;after pbump(10), it contains &quot; &lt;&lt; mybuf.showput() &lt;&lt; '\n';
}
 | output=
The put area contains: 1234
after pbump(10), it contains 1234 is a test
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc gbump}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pbump]]
[[es:cpp/io/basic streambuf/pbump]]
[[fr:cpp/io/basic streambuf/pbump]]
[[it:cpp/io/basic streambuf/pbump]]
[[ja:cpp/io/basic streambuf/pbump]]
[[pt:cpp/io/basic streambuf/pbump]]
[[ru:cpp/io/basic streambuf/pbump]]
[[zh:cpp/io/basic streambuf/pbump]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pptr</title>
    <ns>0</ns>
    <id>4896</id>
    <revision>
      <id>57702</id>
      <parentid>49697</parentid>
      <timestamp>2013-06-01T05:59:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1107">{{cpp/io/basic_streambuf/title|pbase|pptr|epptr}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |
char_type* pbase() const;
}}
{{dcl | num=2 |
char_type* pptr() const;
}}
{{dcl | num=3 |
char_type* epptr() const;
}}
{{dcl end}}

Returns pointers defining the put area.

1) Returns the pointer to the beginning of the put area.

2) Returns the pointer to the current character (''put pointer'') in the put area.

3) Returns the pointer to the end of the put area.

===Parameters===
(none)

===Return value===
1) The pointer to the beginning of the put area.

2) The pointer to the current character (''put pointer'') in the put area.

3) The pointer to the end of the put area.

===Example===
{{example |
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc gptr}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pptr]]
[[es:cpp/io/basic streambuf/pptr]]
[[fr:cpp/io/basic streambuf/pptr]]
[[it:cpp/io/basic streambuf/pptr]]
[[ja:cpp/io/basic streambuf/pptr]]
[[pt:cpp/io/basic streambuf/pptr]]
[[ru:cpp/io/basic streambuf/pptr]]
[[zh:cpp/io/basic streambuf/pptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pubimbue</title>
    <ns>0</ns>
    <id>4873</id>
    <revision>
      <id>67243</id>
      <parentid>57703</parentid>
      <timestamp>2014-01-29T13:06:10Z</timestamp>
      <contributor>
        <ip>94.107.252.113</ip>
      </contributor>
      <text xml:space="preserve" bytes="1188">{{cpp/io/basic_streambuf/title | pubimbue | imbue}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
std::locale pubimbue( const std::locale&amp; loc );
}}
{{dcl | num=2 |1=
protected:
virtual void imbue( const std::locale&amp; loc );
}}
{{dcl end}}

Changes the associated locale.

1) Calls {{tt|imbue(loc)}} of the most derived class

2) The base class version of this function has no effect. The derived classes may override this function in order to be informed about the changes of the locale. The derived class may cache the locale and member facets between calls to {{tt|imbue()}}.

===Parameters===
{{par begin}}
{{par | loc | locale object to associate}}
{{par end}}

===Return value===
1) Previous associated locale.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc getloc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pubimbue]]
[[es:cpp/io/basic streambuf/pubimbue]]
[[fr:cpp/io/basic streambuf/pubimbue]]
[[it:cpp/io/basic streambuf/pubimbue]]
[[ja:cpp/io/basic streambuf/pubimbue]]
[[pt:cpp/io/basic streambuf/pubimbue]]
[[ru:cpp/io/basic streambuf/pubimbue]]
[[zh:cpp/io/basic streambuf/pubimbue]]</text>
      <sha1>e3nex7czyp0r8glathk2dj8395qagaw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pubseekoff</title>
    <ns>0</ns>
    <id>4875</id>
    <revision>
      <id>57706</id>
      <parentid>49699</parentid>
      <timestamp>2013-06-01T05:59:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2355">{{cpp/io/basic_streambuf/title | pubseekoff | seekoff}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
pos_type pubseekoff( off_type off, ios_base::seekdir dir,
                     ios_base::openmode which = ios_base::in {{!}} ios_base::out );
}}
{{dcl | num=2 |1=
protected:
virtual pos_type seekoff( off_type off, ios_base::seekdir dir,
                          ios_base::openmode which = ios_base::in {{!}} ios_base::out );
}}
{{dcl end}}

Sets the position indicator of the input and/or output sequence relative to some other position.

1) Calls {{tt|seekoff(off, dir, which)}} of the most derived class

2) The base class version of this function has no effect. The derived classes may override this function to allow relative positioning of the position indicator.

===Parameters===
{{par begin}}
{{par | off | relative position to set the position indicator to.}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par | which | defines which of the input and/or output sequences to affect. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Note===
Not all combinations of parameters are valid. All the sequences denoted by {{tt|which}} must match the sequences denoted by the instantiation of the {{c|basic_streambuf}}. When modifying both the input and output sequences together, {{tt|dir}} may only be {{ltt|cpp/io/ios_base/seekdir|beg}} or {{ltt|cpp/io/ios_base/seekdir|end}}. Otherwise, the positioning operation fails, and {{c|pos_type(off_type(-1))}} is returned.

===Return value===
1) The return value of {{tt|seekoff(off, dir, which)}}

2) The resulting absolute position as defined by the position indicator. The base class version returns {{c|pos_type(off_type(-1))}}.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pubseekoff]]
[[es:cpp/io/basic streambuf/pubseekoff]]
[[fr:cpp/io/basic streambuf/pubseekoff]]
[[it:cpp/io/basic streambuf/pubseekoff]]
[[ja:cpp/io/basic streambuf/pubseekoff]]
[[pt:cpp/io/basic streambuf/pubseekoff]]
[[ru:cpp/io/basic streambuf/pubseekoff]]
[[zh:cpp/io/basic streambuf/pubseekoff]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pubseekpos</title>
    <ns>0</ns>
    <id>4876</id>
    <revision>
      <id>57707</id>
      <parentid>49700</parentid>
      <timestamp>2013-06-01T05:59:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1707">{{cpp/io/basic_streambuf/title | pubseekpos | seekpos}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
pos_type pubseekpos( pos_type pos,
                     ios_base::openmode which = ios_base::in {{!}} ios_base::out );
}}
{{dcl | num=2 |1=
protected:
virtual pos_type seekpos( pos_type pos,
                          ios_base::openmode which = ios_base::in {{!}} ios_base::out);
}}
{{dcl end}}

Sets the position indicator of the input and/or output sequence to an absolute position.

1) Calls {{tt|seekpos(pos, which)}} of the most derived class

2) The base class version of this function has no effect. The derived classes may override this function to allow absolute positioning of the position indicator.

===Parameters===
{{par begin}}
{{par | pos | absolute position to set the position indicator to.}}
{{par | which | defines which of the input and/or output sequences to affect. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
1) The return value of {{tt|seekpos(pos, which)}}

2) The resulting absolute position as defined by the position indicator. The base class version returns {{c|pos_type(off_type(-1))}}.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekoff}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pubseekpos]]
[[es:cpp/io/basic streambuf/pubseekpos]]
[[fr:cpp/io/basic streambuf/pubseekpos]]
[[it:cpp/io/basic streambuf/pubseekpos]]
[[ja:cpp/io/basic streambuf/pubseekpos]]
[[pt:cpp/io/basic streambuf/pubseekpos]]
[[ru:cpp/io/basic streambuf/pubseekpos]]
[[zh:cpp/io/basic streambuf/pubseekpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pubsetbuf</title>
    <ns>0</ns>
    <id>4568</id>
    <revision>
      <id>69876</id>
      <parentid>65333</parentid>
      <timestamp>2014-04-30T13:45:19Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Return value */ correcting</comment>
      <text xml:space="preserve" bytes="1938">{{cpp/io/basic_streambuf/title | pubsetbuf | setbuf}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
basic_streambuf&lt;CharT, Traits&gt;* pubsetbuf( char_type* s, std::streamsize n )
}}
{{dcl | num=2 |1=
protected:
virtual basic_streambuf&lt;CharT, Traits&gt;* setbuf( char_type* s, std::streamsize n )
}}
{{dcl end}}

@1@ Calls {{tt|setbuf(s, n)}} of the most derived class

@2@ The base class version of this function has no effect. The derived classes may override this function to allow removal or replacement of the controlled character sequence (the buffer) with a user-provided array, or for any other implementation-specific purpose.

===Parameters===
{{par begin}}
{{par | s | pointer to the first byte in the user-provided buffer}}
{{par | n | the number of bytes in the user-provided buffer}}
{{par end}}

===Return value===
@1@ The return value of {{tt|setbuf(s, n)}}
@2@ {{c|this}}

===Example===
{{example
 | provide a 10k buffer for reading. On linux, the strace utility may be used to observe the actual number of bytes read
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    int cnt = 0;
    std::ifstream file;
    char buf[10241];

    file.rdbuf()-&gt;pubsetbuf(buf, sizeof buf);

    file.open(&quot;/usr/share/dict/words&quot;);

    for (std::string line; getline(file, line);) {
        cnt++;
    }
    
    std::cout &lt;&lt; cnt &lt;&lt; '\n';
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc setbuf}}
{{dsc inc | cpp/io/strstreambuf/dsc setbuf}}
{{dsc inc | cpp/io/c/dsc setbuf}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pubsetbuf]]
[[es:cpp/io/basic streambuf/pubsetbuf]]
[[fr:cpp/io/basic streambuf/pubsetbuf]]
[[it:cpp/io/basic streambuf/pubsetbuf]]
[[ja:cpp/io/basic streambuf/pubsetbuf]]
[[pt:cpp/io/basic streambuf/pubsetbuf]]
[[ru:cpp/io/basic streambuf/pubsetbuf]]
[[zh:cpp/io/basic streambuf/pubsetbuf]]</text>
      <sha1>4ohve9qjsaurl7aekojob7d9arcs3bj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/pubsync</title>
    <ns>0</ns>
    <id>4877</id>
    <revision>
      <id>57711</id>
      <parentid>49702</parentid>
      <timestamp>2013-06-01T05:59:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1553">{{cpp/io/basic_streambuf/title | pubsync | sync}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
int pubsync();
}}
{{dcl | num=2 |1=
protected:
virtual int sync();
}}
{{dcl end}}

Synchronizes the controlled character sequence (the buffers) with the associated character sequence.

1) Calls {{tt|sync()}} of the most derived class

2) The base class version of this function has no effect. The derived classes may override this function to allow synchronizing the underlying device with the buffers.

For output streams, this typically results in writing the contents of the put area into the associated sequence, i.e. flushing of the output buffer. For input streams, this typically empties the get area and forces a re-read from the associated sequence to pick up recent changes. The default behavior (found, for example, in {{lc|std::basic_stringbuf}}), is to do nothing.

===Parameters===
(none)

===Return value===
1) The return value of {{tt|sync()}}.

2) Returns {{c|0}} on success, {{c|-1}} otherwise. The base class version returns {{c|0}}.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc sync}}
{{dsc inc | cpp/io/basic_filebuf/dsc sync}}
{{dsc end}}

[[de:cpp/io/basic streambuf/pubsync]]
[[es:cpp/io/basic streambuf/pubsync]]
[[fr:cpp/io/basic streambuf/pubsync]]
[[it:cpp/io/basic streambuf/pubsync]]
[[ja:cpp/io/basic streambuf/pubsync]]
[[pt:cpp/io/basic streambuf/pubsync]]
[[ru:cpp/io/basic streambuf/pubsync]]
[[zh:cpp/io/basic streambuf/pubsync]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sbumpc</title>
    <ns>0</ns>
    <id>4880</id>
    <revision>
      <id>64240</id>
      <parentid>57712</parentid>
      <timestamp>2013-08-15T15:57:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc, fmt</comment>
      <text xml:space="preserve" bytes="963">{{cpp/io/basic_streambuf/title|sbumpc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type sbumpc();
}}

Reads one character and advances the input sequence by one character.

If the input sequence read position is not available, returns {{lc|uflow()}}. Otherwise returns {{c|Traits::to_int_type(*gptr())}}.

===Parameters===
(none)

===Return value===
The value of the character pointed to by the ''get pointer'', or {{c|Traits::eof()}} if the read position is not available.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc snextc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sbumpc]]
[[es:cpp/io/basic streambuf/sbumpc]]
[[fr:cpp/io/basic streambuf/sbumpc]]
[[it:cpp/io/basic streambuf/sbumpc]]
[[ja:cpp/io/basic streambuf/sbumpc]]
[[pt:cpp/io/basic streambuf/sbumpc]]
[[ru:cpp/io/basic streambuf/sbumpc]]
[[zh:cpp/io/basic streambuf/sbumpc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/seekoff</title>
    <ns>0</ns>
    <id>4870</id>
    <redirect title="cpp/io/basic streambuf/pubseekoff" />
    <revision>
      <id>17582</id>
      <timestamp>2012-01-17T12:15:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/io/basic streambuf/pubseekoff]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/seekpos</title>
    <ns>0</ns>
    <id>4869</id>
    <redirect title="cpp/io/basic streambuf/pubseekpos" />
    <revision>
      <id>17581</id>
      <timestamp>2012-01-17T12:15:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/pubseekpos]]</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/io/basic streambuf/pubseekpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/setbuf</title>
    <ns>0</ns>
    <id>4867</id>
    <redirect title="cpp/io/basic streambuf/pubsetbuf" />
    <revision>
      <id>17569</id>
      <timestamp>2012-01-17T12:10:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/io/basic streambuf/setbuf]] to [[cpp/io/basic streambuf/pubsetbuf]]</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/io/basic streambuf/pubsetbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/setg</title>
    <ns>0</ns>
    <id>4899</id>
    <revision>
      <id>57713</id>
      <parentid>49704</parentid>
      <timestamp>2013-06-01T05:59:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1017">{{cpp/io/basic_streambuf/title|setg}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
void setg( char_type* gbeg, char_type* gcurr, char_type* gend );
}}

Sets the values of the pointers defining the get area. Specifically, after the call {{c|1=eback() == gbeg}}, {{c|1=gptr() == gcurr}}, {{c|1=egptr() == gend}}

===Parameters===
{{par begin}}
{{par | gbeg | pointer to the new beginning of the get area}}
{{par | gcurr | pointer to the new current character (''get pointer'') in the get area}}
{{par | gend | pointer to the new end of the get area}}
{{par end}}

===Return value===
(none)

===Example===
{{include| cpp/io/basic_streambuf/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc setp}}
{{dsc end}}

[[de:cpp/io/basic streambuf/setg]]
[[es:cpp/io/basic streambuf/setg]]
[[fr:cpp/io/basic streambuf/setg]]
[[it:cpp/io/basic streambuf/setg]]
[[ja:cpp/io/basic streambuf/setg]]
[[pt:cpp/io/basic streambuf/setg]]
[[ru:cpp/io/basic streambuf/setg]]
[[zh:cpp/io/basic streambuf/setg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/setp</title>
    <ns>0</ns>
    <id>4900</id>
    <revision>
      <id>65387</id>
      <parentid>65174</parentid>
      <timestamp>2013-09-10T21:22:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt example</comment>
      <text xml:space="preserve" bytes="1957">{{cpp/io/basic_streambuf/title|setp}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
void setp( char_type* pbeg, char_type* pend );
}}

Sets the values of the pointers defining the put area. Specifically, after the call {{c|1=pbase() == pbeg}}, {{c|1=pptr() == pbeg}}, {{c|1=epptr() == pend}}

===Parameters===
{{par begin}}
{{par | pbeg | pointer to the new beginning of the put area}}
{{par | pend | pointer to the new end of the put area}}
{{par end}}

===Return value===
(none)

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;array&gt;

// Buffer for std::ostream implemented by std::array
template&lt;std::size_t SIZE, class CharT = char&gt;
class ArrayedStreamBuffer : public std::basic_streambuf&lt;CharT&gt;
{
public:
    using Base = std::basic_streambuf&lt;CharT&gt;;
    using char_type = typename Base::char_type;

    ArrayedStreamBuffer() : buffer_{} // value-initialize buffer_ to all zeroes
    {
        Base::setp(buffer_.begin(), buffer_.end()); // set std::basic_streambuf
            // put area pointers to work with 'buffer_'
    }

    void print_buffer()
    {
        for (const auto&amp; i: buffer_) {
            if (i == 0) {
                std::cout &lt;&lt; &quot;NULL&quot;;
            } else {
                std::cout &lt;&lt; i;
            }
            std::cout &lt;&lt; &quot; &quot;;
        }
        std::cout &lt;&lt; &quot;\n&quot;;
    }

private:
    std::array&lt;char_type, SIZE&gt; buffer_;
};

int main()
{
    ArrayedStreamBuffer&lt;10&gt; streambuf;
    std::ostream stream(&amp;streambuf);

    stream &lt;&lt; &quot;hello&quot;;
    stream &lt;&lt; &quot;,&quot;;

    streambuf.print_buffer();
}
 | output=
h e l l o , NULL NULL NULL NULL
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc setg}}
{{dsc end}}

[[de:cpp/io/basic streambuf/setp]]
[[es:cpp/io/basic streambuf/setp]]
[[fr:cpp/io/basic streambuf/setp]]
[[it:cpp/io/basic streambuf/setp]]
[[ja:cpp/io/basic streambuf/setp]]
[[pt:cpp/io/basic streambuf/setp]]
[[ru:cpp/io/basic streambuf/setp]]
[[zh:cpp/io/basic streambuf/setp]]</text>
      <sha1>1drx4tq8en68ma227elqe6r5zm10j6t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sgetc</title>
    <ns>0</ns>
    <id>4881</id>
    <revision>
      <id>64971</id>
      <parentid>64239</parentid>
      <timestamp>2013-08-28T17:52:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+trivial example</comment>
      <text xml:space="preserve" bytes="1249">{{cpp/io/basic_streambuf/title|sgetc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type sgetc();
}}

Reads one character from the input sequence.

If the input sequence read position is not available, returns {{lc|underflow()}}. Otherwise returns {{c|Traits::to_int_type(*gptr())}}.

===Parameters===
(none)

===Return value===
The value of the character pointed to by the ''get pointer''.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::stringstream stream(&quot;Hello, world&quot;);
    std::cout &lt;&lt; &quot;sgetc() returned '&quot; &lt;&lt; (char)stream.rdbuf()-&gt;sgetc() &lt;&lt; &quot;'\n&quot;
              &lt;&lt; &quot;peek() returned '&quot; &lt;&lt; (char)stream.peek() &lt;&lt; &quot;'\n&quot;
              &lt;&lt; &quot;get() returned '&quot; &lt;&lt; (char)stream.get() &lt;&lt; &quot;'\n&quot;;
}
 | output=
sgetc() returned 'H'
peek() returned 'H'
get() returned 'H'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sbumpc}}
{{dsc inc | cpp/io/basic_streambuf/dsc snextc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sgetc]]
[[es:cpp/io/basic streambuf/sgetc]]
[[fr:cpp/io/basic streambuf/sgetc]]
[[it:cpp/io/basic streambuf/sgetc]]
[[ja:cpp/io/basic streambuf/sgetc]]
[[pt:cpp/io/basic streambuf/sgetc]]
[[ru:cpp/io/basic streambuf/sgetc]]
[[zh:cpp/io/basic streambuf/sgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sgetn</title>
    <ns>0</ns>
    <id>4884</id>
    <revision>
      <id>64238</id>
      <parentid>62380</parentid>
      <timestamp>2013-08-15T15:56:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1227">{{cpp/io/basic_streambuf/title | sgetn | xsgetn}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
std::streamsize sgetn( char_type* s, std::streamsize count );
}}
{{dcl | num=2 | 1=
protected:
virtual std::streamsize xsgetn( char_type* s, std::streamsize count );
}}
{{dcl end}}

@1@ Calls {{tt|xsgetn(s, count)}} of the most derived class.

@2@ Reads {{tt|count}} characters from the input sequence and stores them into a character array pointed to by {{tt|s}}. The characters are read as if by repeated calls to {{lc|sbumpc()}}. That is, if less than {{tt|count}} characters are immediately available, the function calls {{lc|uflow()}} to provide more until {{c|traits::eof()}} is returned.

===Parameters===
(none)

===Return value===
The number of characters successfully read.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputn}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sgetn]]
[[es:cpp/io/basic streambuf/sgetn]]
[[fr:cpp/io/basic streambuf/sgetn]]
[[it:cpp/io/basic streambuf/sgetn]]
[[ja:cpp/io/basic streambuf/sgetn]]
[[pt:cpp/io/basic streambuf/sgetn]]
[[ru:cpp/io/basic streambuf/sgetn]]
[[zh:cpp/io/basic streambuf/sgetn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/showmanyc</title>
    <ns>0</ns>
    <id>4887</id>
    <revision>
      <id>64243</id>
      <parentid>63793</parentid>
      <timestamp>2013-08-15T15:59:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1353">{{cpp/io/basic_streambuf/title|showmanyc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
protected:
virtual std::streamsize showmanyc();
}}

Estimates the number of characters available for input in the associated character sequence. {{lc|underflow()}} is guaranteed not to return {{c|Traits::eof()}} until at least that many characters are extracted.

===Parameters===
(none)

===Return value===
The number of characters that are certainly available in the associated character sequence, or {{c|-1}} if {{tt|showmanyc}} can determine, without blocking, that no characters are available. If {{tt|showmanyc}} returns {{c|-1}}, {{lc|underflow()}} and {{lc|uflow()}} will definitely return {{c|Traits::eof}}.

The base class version returns {{c|0}}, which has the meaning of &quot;unsure if there are characters available in the associated sequence&quot;.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc in_avail}}
{{dsc inc | cpp/io/basic_filebuf/dsc showmanyc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/showmanyc]]
[[es:cpp/io/basic streambuf/showmanyc]]
[[fr:cpp/io/basic streambuf/showmanyc]]
[[it:cpp/io/basic streambuf/showmanyc]]
[[ja:cpp/io/basic streambuf/showmanyc]]
[[pt:cpp/io/basic streambuf/showmanyc]]
[[ru:cpp/io/basic streambuf/showmanyc]]
[[zh:cpp/io/basic streambuf/showmanyc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/snextc</title>
    <ns>0</ns>
    <id>4879</id>
    <revision>
      <id>64241</id>
      <parentid>57724</parentid>
      <timestamp>2013-08-15T15:58:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc, fmt</comment>
      <text xml:space="preserve" bytes="1122">{{cpp/io/basic_streambuf/title|snextc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type snextc();
}}

Advances the input sequence by one character and reads one character.

The function calls {{lc|sbumpc()}} to advance the input sequence. If that function returns {{c|Traits::eof()}} meaning that input sequence has been exhausted and {{lc|uflow()}} could not retrieve more data, {{c|Traits::eof()}} is returned. Otherwise {{lc|sgetc()}} is called in order to read the character.

===Parameters===
(none)

===Return value===
The value of the next character. If the input sequence has been exhausted, {{c|Traits::eof()}} is returned.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sbumpc}}
{{dsc end}}

[[de:cpp/io/basic streambuf/snextc]]
[[es:cpp/io/basic streambuf/snextc]]
[[fr:cpp/io/basic streambuf/snextc]]
[[it:cpp/io/basic streambuf/snextc]]
[[ja:cpp/io/basic streambuf/snextc]]
[[pt:cpp/io/basic streambuf/snextc]]
[[ru:cpp/io/basic streambuf/snextc]]
[[zh:cpp/io/basic streambuf/snextc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sputbackc</title>
    <ns>0</ns>
    <id>9695</id>
    <revision>
      <id>70080</id>
      <parentid>70069</parentid>
      <timestamp>2014-05-09T12:42:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>adjusted the comments in the example</comment>
      <text xml:space="preserve" bytes="2414">{{cpp/io/basic_streambuf/title | sputbackc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type sputbackc( char_type c );
}}

Puts back a character back to the get area.

If a putback position is available in the get area ({{c|gptr() &gt; eback()}}), and the character {{tt|c}} is equal to the character one position to the left of {{lc|gptr()}} (as determined by {{c|Traits::eq(c, gptr()[-1])}}, then simply decrements the next pointer ({{lc|gptr()}}).

Otherwise, calls {{c|pbackfail(Traits::to_int_type(c))}} to either back up the get area or to modify both the get area and possibly the associated character sequence.

The I/O stream function {{l2tt|cpp/io/basic_istream/putback}} is implemented in terms of this function.

===Parameters===
(none)

===Return value===
If putback position was available, returns the character that the next pointer is now pointing at, converted to {{tt|int_type}} with {{c|Traits::to_int_type(*gptr())}}. The next single-character input from this streambuf will return this character.

If putback position was not available, returns what {{lc|pbackfail()}} returns, which is  {{c|Traits::eof()}} on failure.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::stringstream s(&quot;abcdef&quot;); // gptr() points to 'a' in &quot;abcdef&quot;
    std::cout &lt;&lt; &quot;Before putback, string holds &quot; &lt;&lt; s.str() &lt;&lt; '\n';
    char c1 = s.get(); // c1 = 'a', gptr() now points to 'b' in &quot;abcdef&quot;
    char c2 = s.rdbuf()-&gt;sputbackc('z'); // same as s.putback('z')
                                         // gptr() now points to 'z' in &quot;zbcdef&quot;
    std::cout &lt;&lt; &quot;After putback, string holds &quot; &lt;&lt; s.str() &lt;&lt; '\n';
    char c3 = s.get(); // c3 = 'z', gptr() now points to 'b' in &quot;zbcdef&quot;
    char c4 = s.get(); // c4 = 'b', gptr() now points to 'c' in &quot;zbcdef&quot;
    std::cout &lt;&lt; c1 &lt;&lt; c2 &lt;&lt; c3 &lt;&lt; c4 &lt;&lt; '\n';

    s.rdbuf()-&gt;sputbackc('b');  // gptr() now points to 'b' in &quot;zbcdef&quot;
    s.rdbuf()-&gt;sputbackc('z');  // gptr() now points to 'z' in &quot;zbcdef&quot;
    int eof = s.rdbuf()-&gt;sputbackc('x');  // nothing to unget: pbackfail() fails
    if (eof == EOF)
        std::cout &lt;&lt; &quot;No room to putback after 'z'\n&quot;;
}
 | output=
Before putback, string holds abcdef
After putback, string holds zbcdef
azzb
No room to putback after 'z'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc end}}</text>
      <sha1>cmc22q4899s4ywg7dd92uo4fbzfkfyn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sputc</title>
    <ns>0</ns>
    <id>4886</id>
    <revision>
      <id>64236</id>
      <parentid>62414</parentid>
      <timestamp>2013-08-15T15:55:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1113">{{cpp/io/basic_streambuf/title | sputc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type sputc( char_type ch );
}}

Writes one character to the output sequence.

If the output sequence write position is not available (the buffer is full), then calls {{c|overflow(ch)}}.

===Parameters===
{{par begin}}
{{par | ch | character to write}}
{{par end}}

===Return value===
The written character, converted to {{tt|int_type}} with {{c|Traits::to_int_type(ch)}}. on success.

{{c|Traits::eof()}} (as returned by {{lc|overflow()}}) on failure.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::ostringstream s;
    s.rdbuf()-&gt;sputc('a');
    std::cout &lt;&lt; s.str() &lt;&lt; '\n';
}
 | output=
a
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputn}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sputc]]
[[es:cpp/io/basic streambuf/sputc]]
[[fr:cpp/io/basic streambuf/sputc]]
[[it:cpp/io/basic streambuf/sputc]]
[[ja:cpp/io/basic streambuf/sputc]]
[[pt:cpp/io/basic streambuf/sputc]]
[[ru:cpp/io/basic streambuf/sputc]]
[[zh:cpp/io/basic streambuf/sputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sputn</title>
    <ns>0</ns>
    <id>4885</id>
    <revision>
      <id>64237</id>
      <parentid>62416</parentid>
      <timestamp>2013-08-15T15:56:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1986">{{cpp/io/basic_streambuf/title | sputn | xsputn}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
std::streamsize sputn( const char_type* s, std::streamsize count );
}}
{{dcl | num=2 | 1=
protected:
virtual std::streamsize xsputn( const char_type* s, std::streamsize count );
}}
{{dcl end}}

@1@ Calls {{tt|xsputn(s, count)}} of the most derived class.

@2@ Writes {{tt|count}} characters to the output sequence from the character array whose first element is pointed to by {{tt|s}}. The characters are written as if by repeated calls to {{lc|sputc()}}. Writing stops when either {{tt|count}} characters are written or a call to {{lc|sputc()}} would have returned {{c|Traits::eof()}}.

If the put area becomes full ({{c|1=pptr() == epptr()}}), this function may call {{lc|overflow()}}, or achieve the effect of calling {{tt|overflow()}} by some other, unspecified, means.

===Parameters===
(none)

===Return value===
The number of characters successfully written.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
 
int main()
{
    std::ostringstream s1;
    std::streamsize sz = s1.rdbuf()-&gt;sputn(&quot;This is a test&quot;, 14);
    s1 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;The call to sputn() returned &quot; &lt;&lt; sz &lt;&lt; '\n'
              &lt;&lt; &quot;The output sequence contains &quot; &lt;&lt; s1.str();

    std::istringstream s2;
    sz = s2.rdbuf()-&gt;sputn(&quot;This is a test&quot;, 14);
    std::cout &lt;&lt; &quot;The call to sputn() on an input stream returned &quot; &lt;&lt; sz &lt;&lt; '\n';
}
 | output=
The call to sputn() returned 14
The output sequence contains This is a test
The call to sputn() on an input stream returned 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetn}}
{{dsc end}}

[[de:cpp/io/basic streambuf/sputn]]
[[es:cpp/io/basic streambuf/sputn]]
[[fr:cpp/io/basic streambuf/sputn]]
[[it:cpp/io/basic streambuf/sputn]]
[[ja:cpp/io/basic streambuf/sputn]]
[[pt:cpp/io/basic streambuf/sputn]]
[[ru:cpp/io/basic streambuf/sputn]]
[[zh:cpp/io/basic streambuf/sputn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sungetc</title>
    <ns>0</ns>
    <id>9691</id>
    <revision>
      <id>64277</id>
      <parentid>63940</parentid>
      <timestamp>2013-08-15T16:18:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1803">{{cpp/io/basic_streambuf/title | sungetc}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
int_type sungetc();
}}

If a putback position is available in the get area ({{c|gptr() &gt; eback()}}), then decrements the next pointer ({{lc|gptr()}}) and returns the character it now points to.

If a putback position is not available, then calls {{lc|pbackfail()}} to back up the input sequence if possible.

The I/O stream function {{l2tt|cpp/io/basic_istream/unget}} is implemented in terms of this function.

===Parameters===
(none)

===Return value===
If putback position was available, returns the character that the next pointer is now pointing at, converted to {{tt|int_type}} with {{c|Traits::to_int_type(*gptr())}}. The next single-character input from this streambuf will return this character.

If putback position was not available, returns what {{lc|pbackfail()}} returns, which is  {{c|Traits::eof()}} on failure.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::stringstream s(&quot;abcdef&quot;); // gptr() poitns to 'a'
    char c1 = s.get(); // c = 'a', gptr() now points to 'b' 
    char c2 = s.rdbuf()-&gt;sungetc(); // same as s.unget(): gptr() points to 'a' again 
    char c3 = s.get(); // c3 = 'a', gptr() now points to 'b'
    char c4 = s.get(); // c4 = 'b', gptr() now points to 'c'
    std::cout &lt;&lt; c1 &lt;&lt; c2 &lt;&lt; c3 &lt;&lt; c4 &lt;&lt; '\n';

    s.rdbuf()-&gt;sungetc();  // back to 'b'
    s.rdbuf()-&gt;sungetc();  // back to 'a'
    int eof = s.rdbuf()-&gt;sungetc();  // nothing to unget: pbackfail() fails
    if (eof == EOF)
            std::cout &lt;&lt; &quot;Nothing to unget after 'a'\n&quot;;
}
 | output=
aaab
Nothing to unget after 'a'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/swap</title>
    <ns>0</ns>
    <id>12582</id>
    <revision>
      <id>61082</id>
      <timestamp>2013-06-05T10:46:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="440">{{cpp/io/basic_streambuf/title|swap}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void swap( basic_streambuf&amp; other );
}}
{{dcl end}}

Exchanges  the contents of the stream buffer with those of {{tt|other}}. 

===Parameters===
{{par begin}}
{{par | other | stream buffer to exchange contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example|
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/sync</title>
    <ns>0</ns>
    <id>4868</id>
    <redirect title="cpp/io/basic streambuf/pubsync" />
    <revision>
      <id>17580</id>
      <timestamp>2012-01-17T12:15:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/pubsync]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/io/basic streambuf/pubsync]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/uflow</title>
    <ns>0</ns>
    <id>4889</id>
    <revision>
      <id>64360</id>
      <parentid>64341</parentid>
      <timestamp>2013-08-15T18:33:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1766">{{cpp/io/basic_streambuf/title|uflow}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
virtual int_type uflow();
}}

Ensures that at least one character is available in the input area by updating the pointers to the input area (if needed). On success returns the value of that character and advances the value of the ''get pointer'' by one character. On failure returns {{c|traits::eof()}}. 

The function may update {{tt|gptr}}, {{tt|egptr}} and {{tt|eback}} pointers to define the location of newly loaded data (if any). On failure, the function ensures that either {{c|gptr() {{==}} nullptr}} or {{c|gptr() {{==}} egptr}}.

The base class version of the function calls {{lc|underflow()}} and increments {{lc|gptr()}}. 

===Parameters===
(none)

===Return value===
The value of the character that was pointed to by the ''get pointer'' before it was advanced by one, or {{c|traits::eof()}} otherwise.

The base class version of the function returns the value returned by {{lc|underflow()}}.

===Note===
The public functions of {{lc|std::streambuf}} call this function only if {{c|1=gptr() == nullptr}} or {{c|1=gptr() &gt;= egptr()}}.

The custom streambuf classes that do not use the get area and do not set the get area pointers in basic_streambuf are required to override this function.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc end}}

[[de:cpp/io/basic streambuf/uflow]]
[[es:cpp/io/basic streambuf/uflow]]
[[fr:cpp/io/basic streambuf/uflow]]
[[it:cpp/io/basic streambuf/uflow]]
[[ja:cpp/io/basic streambuf/uflow]]
[[pt:cpp/io/basic streambuf/uflow]]
[[ru:cpp/io/basic streambuf/uflow]]
[[zh:cpp/io/basic streambuf/uflow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/underflow</title>
    <ns>0</ns>
    <id>4888</id>
    <revision>
      <id>67238</id>
      <parentid>67237</parentid>
      <timestamp>2014-01-29T02:54:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+to_int_type</comment>
      <text xml:space="preserve" bytes="1897">{{cpp/io/basic_streambuf/title|underflow}}
{{cpp/io/basic_streambuf/navbar}}
{{ddcl | 1=
virtual int_type underflow();
}}

Ensures that at least one character is available in the input area by updating the pointers to the input area (if needed) and reading more data in from the input sequence (if applicable). Returns the value of that character (converted to {{tt|int_type}} with {{c|Traits::to_int_type(c)}}) on success or {{c|Traits::eof()}} on failure.

The function may update {{tt|gptr}}, {{tt|egptr}} and {{tt|eback}} pointers to define the location of newly loaded data (if any). On failure, the function ensures that either {{c|gptr() {{==}} nullptr}} or {{c|gptr() {{==}} egptr}}.

The base class version of the function does nothing. The derived classes may override this function to allow updates to the get area in the case of exhaustion.

===Parameters===
(none)

===Return value===
The value of the character pointed to by the ''get pointer'' after the call on success, or {{c|Traits::eof()}} otherwise.

The base class version of the function returns {{c|traits::eof()}}.

===Note===
The public functions of {{lc|std::streambuf}} call this function only if {{c|1=gptr() == nullptr}} or {{c|1=gptr() &gt;= egptr()}}.

===Example===
{{include| cpp/io/basic_streambuf/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc uflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc underflow}}
{{dsc inc | cpp/io/strstreambuf/dsc underflow}}
{{dsc end}}

[[de:cpp/io/basic streambuf/underflow]]
[[es:cpp/io/basic streambuf/underflow]]
[[fr:cpp/io/basic streambuf/underflow]]
[[it:cpp/io/basic streambuf/underflow]]
[[ja:cpp/io/basic streambuf/underflow]]
[[pt:cpp/io/basic streambuf/underflow]]
[[ru:cpp/io/basic streambuf/underflow]]
[[zh:cpp/io/basic streambuf/underflow]]</text>
      <sha1>n5ebhbndd6sm5iagemh3k8l2o1wx947</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/xsgetn</title>
    <ns>0</ns>
    <id>4882</id>
    <redirect title="cpp/io/basic streambuf/sgetn" />
    <revision>
      <id>17611</id>
      <timestamp>2012-01-17T17:04:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/sgetn]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_streambuf/sgetn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/xsputn</title>
    <ns>0</ns>
    <id>4883</id>
    <redirect title="cpp/io/basic streambuf/sputn" />
    <revision>
      <id>17612</id>
      <timestamp>2012-01-17T17:04:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic streambuf/sputn]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_streambuf/sputn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic streambuf/~basic streambuf</title>
    <ns>0</ns>
    <id>6342</id>
    <revision>
      <id>57737</id>
      <parentid>49716</parentid>
      <timestamp>2013-06-01T05:59:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1418">{{cpp/io/basic_streambuf/title|~basic_streambuf}}
{{cpp/io/basic_streambuf/navbar}}
{{dcl begin}}
{{dcl |1=
virtual ~basic_streambuf();
}}
{{dcl end}}

This destruction is empty: the members of this {{tt|basic_streambuf}} (the pointers and the locale) are destructed in accordance with the usual object destruction sequence after this destructor returns. However, since it is declared public virtual, it allows the objects that are derived from {{tt|std::basic_streambuf}} to be deleted through a pointer to base class.

===Parameters===
(none)

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;

int main()
{
    std::filebuf* fbp = new std::filebuf;
    fbp-&gt;open(&quot;test.txt&quot;, std::ios_base::out);
    fbp-&gt;sputn(&quot;Hello\n&quot;, 6);
    std::streambuf* sbp = fbp;
    delete sbp; // the file is closed, output flushed and written
    std::ifstream f(&quot;test.txt&quot;);
    std::cout &lt;&lt; f.rdbuf(); // proof
}
 | output=
Hello
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc basic_streambuf}}
{{dsc end}}

[[de:cpp/io/basic streambuf/~basic streambuf]]
[[es:cpp/io/basic streambuf/~basic streambuf]]
[[fr:cpp/io/basic streambuf/~basic streambuf]]
[[it:cpp/io/basic streambuf/~basic streambuf]]
[[ja:cpp/io/basic streambuf/~basic streambuf]]
[[pt:cpp/io/basic streambuf/~basic streambuf]]
[[ru:cpp/io/basic streambuf/~basic streambuf]]
[[zh:cpp/io/basic streambuf/~basic streambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf</title>
    <ns>0</ns>
    <id>564</id>
    <revision>
      <id>64376</id>
      <parentid>64060</parentid>
      <timestamp>2013-08-15T18:46:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="2972">{{cpp/title|basic_stringbuf}}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl | header=sstream | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;, 
    class Allocator = std::allocator&lt;CharT&gt; 
&gt; class basic_stringbuf : public std::basic_streambuf&lt;CharT, Traits&gt;
}}

{{tt|std::basic_stringbuf}} is a {{lc|std::basic_streambuf}} whose associated character sequence is a memory-resident sequence of arbitrary characters, which can be initialized from or made available as an instance of {{lc|std::basic_string}}.

Typical implementations of {{tt|std::basic_stringbuf}} hold an object of type {{lc|std::basic_string}} or equivalent resizeable sequence container directly as a data member and use it as both the controlled character sequence (the array where the six pointers of {{lc|std::basic_streambuf}} are pointing to) and as the associated character sequence (the source of characters for all input operations and the target for the output).

In addition, a typical implementation holds a data member of type {{lc|std::ios_base::openmode}} to indicate the status of the stream (input-only, output-only, input/output, at-end, etc).
{{rev begin}}
{{rev|since=c++11|if over-allocation strategy is used by {{lc|overflow()}}, an additional high-watermark pointer may be stored to track the last initialized character}}
{{rev end}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | sstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|stringbuf}} | {{c|basic_stringbuf&lt;char&gt;}}}}
{{dsc | {{tt|wstringbuf}} | {{c|basic_stringbuf&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc inc | cpp/io/dsc allocator_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h1 | Public member functions}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc inc | cpp/io/basic_stringbuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap}}
{{dsc inc | cpp/io/basic_stringbuf/dsc destructor}}
{{dsc inc | cpp/io/basic_stringbuf/dsc str}}

{{dsc h1 | Protected member functions}}
{{dsc inc | cpp/io/basic_stringbuf/dsc underflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_stringbuf/dsc overflow}}

{{dsc inc | cpp/io/basic_stringbuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_stringbuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_stringbuf/dsc seekpos}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap2}}
{{dsc end}}

{{cpp/io/basic_streambuf/inherit}}

[[de:cpp/io/basic stringbuf]]
[[es:cpp/io/basic stringbuf]]
[[fr:cpp/io/basic stringbuf]]
[[it:cpp/io/basic stringbuf]]
[[ja:cpp/io/basic stringbuf]]
[[pt:cpp/io/basic stringbuf]]
[[ru:cpp/io/basic stringbuf]]
[[zh:cpp/io/basic stringbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/basic stringbuf</title>
    <ns>0</ns>
    <id>9414</id>
    <revision>
      <id>64299</id>
      <parentid>62741</parentid>
      <timestamp>2013-08-15T16:25:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="3845">{{cpp/io/basic_stringbuf/title |basic_stringbuf}}
{{cpp/io/basic_stringbuf/navbar}}
{{dcl begin}}
{{dcl| num=1 |1=
explicit basic_stringbuf(std::ios_base::openmode which = std::ios_base::in
                                                       {{!}} std::ios_base::out);
}}
{{dcl| num=2 |1=
explicit basic_stringbuf (const std::basic_string&lt;CharT, traits, Allocator&gt;&amp; new_str,
                          std::ios_base::openmode which = std::ios_base::in
                                                        {{!}} std::ios_base::out);
}}
{{dcl| num=3 | since=c++11 |1=
basic_stringbuf(const basic_stringbuf&amp; rhs) = delete;
}}
{{dcl| num=4 | since=c++11 |1=
basic_stringbuf(basic_stringbuf&amp;&amp; rhs);
}}
{{dcl end}}

@1@ Constructs a {{tt|std::basic_stringbuf}} object: initializes the base class by calling the default constructor of {{lc|std::basic_streambuf}}, initializes the character sequence with an empty string, and sets the mode to {{tt|which}}.

@2@ Constructs a {{tt|std::basic_stringbuf}} object by performing the same initialization as 1), followed by initializing the associated character sequence as if by calling {{lc|str|str(new_str)}}.

@3@ The copy constructor is deleted; {{tt|std::basic_stringbuf}} is not {{concept|CopyConstructible}}

@4@ Move-constructs a {{tt|std::basic_stringbuf}} object by moving all state from another {{tt|std::basic_stringbuf}} object {{tt|rhs}}, including the associated string, the open mode, the locale, and all other state. After the move, the six pointers of {{lc|std::basic_streambuf}} in {{c|*this}} are guaranteed to be different from the corresponding pointers in the moved-from {{tt|rhs}} unless null.

===Parameters===
{{par begin}}
{{par | new_str | a {{tt|basic_string}} used to initialize the buffer }}
{{par | rhs | another {{tt|basic_stringbuf}} }}
{{par | mode | specifies stream open mode. It is bitmask type, the following constants are defined: 
{{cpp/io/ios_base/openmode consts}}}}
{{par end}}

===Notes===
Typically called by the constructor of {{lc|std::basic_stringstream}}.

The level of support for the open modes other than {{lc|std::ios_base::in}} and {{lc|std::ios_base::out}} varies among implementations. C++11 explicitly specifies the support for {{lc|std::ios_base::ate}} in {{lc|str()}} and in this constructor, but {{lc|std::ios_base::app}}, {{lc|std::ios_base::trunc}}, and {{lc|std::ios_base::binary}} have different effects on different implementations.

===Example===
{{example
 | Demonstrates calling the constructor of basic_stringbuf directly.
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    // default constructor (mode = in{{!}}out)
    std::stringbuf buf1;
    buf1.sputc('1');
    std::cout &lt;&lt; &amp;buf1 &lt;&lt; '\n';

    // string constructor in at-end mode (C++11)
    std::stringbuf buf2(&quot;test&quot;, std::ios_base::in
                              {{!}} std::ios_base::out
                              {{!}} std::ios_base::ate);
    buf2.sputc('1');
    std::cout &lt;&lt; &amp;buf2 &lt;&lt; '\n';

    // append mode test (results differ among compilers)
    std::stringbuf buf3(&quot;test&quot;, std::ios_base::in
                              {{!}} std::ios_base::out
                              {{!}} std::ios_base::app);
    buf3.sputc('1');
    buf3.pubseekpos(1);
    buf3.sputc('2');
    std::cout &lt;&lt; &amp;buf3 &lt;&lt; '\n';
}
 | output=
1
test1
est12 (Sun Studio) 2st1 (GCC)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc constructor | basic_stringstream}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/basic stringbuf]]
[[es:cpp/io/basic stringbuf/basic stringbuf]]
[[fr:cpp/io/basic stringbuf/basic stringbuf]]
[[it:cpp/io/basic stringbuf/basic stringbuf]]
[[ja:cpp/io/basic stringbuf/basic stringbuf]]
[[pt:cpp/io/basic stringbuf/basic stringbuf]]
[[ru:cpp/io/basic stringbuf/basic stringbuf]]
[[zh:cpp/io/basic stringbuf/basic stringbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/operator=</title>
    <ns>0</ns>
    <id>9445</id>
    <revision>
      <id>62364</id>
      <parentid>57742</parentid>
      <timestamp>2013-06-27T00:56:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>versioning</comment>
      <text xml:space="preserve" bytes="1891">{{cpp/io/basic_stringbuf/title |operator{{=}}}}
{{cpp/io/basic_stringbuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |1=
std::basic_stringbuf&amp; operator=( std::basic_stringbuf&amp;&amp; rhs );
}}
{{dcl | num=2 |1=
std::basic_stringbuf&amp; operator=( const std::basic_stringbuf&amp; rhs ) = delete;
}}
{{dcl end}}

@1@ Move assignment operator: Moves the contents of {{tt|rhs}} into {{tt|*this}}. After the move, {{tt|lhs}} has the associated string, the open mode, the locale, and all other state formerly held by {{tt|rhs}}. The six pointers of {{lc|std::basic_streambuf}} in {{tt|lhs}} are guaranteed to be different from the corresponding pointers in the moved-from {{tt|rhs}} unless null.
@2@ The copy assignment operator is deleted; {{tt|basic_stringbuf}} is not {{concept|CopyAssignable}}.

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|basic_stringbuf}} that will be moved from}}
{{par end}}

===Return value===
{{tt|*this}}

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{

    std::istringstream one(&quot;one&quot;);
    std::ostringstream two(&quot;two&quot;);

    std::cout &lt;&lt; &quot;Before move, one = \&quot;&quot; &lt;&lt; one.str() &lt;&lt; '&quot;'
              &lt;&lt; &quot; two = \&quot;&quot; &lt;&lt; two.str() &lt;&lt; &quot;\&quot;\n&quot;;

    *one.rdbuf() = std::move(*two.rdbuf());

    std::cout &lt;&lt; &quot;Before move, one = \&quot;&quot; &lt;&lt; one.str() &lt;&lt; '&quot;'
              &lt;&lt; &quot; two = \&quot;&quot; &lt;&lt; two.str() &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
Before move, one = &quot;one&quot; two = &quot;two&quot;
Before move, one = &quot;two&quot; two = &quot;&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/operator=]]
[[es:cpp/io/basic stringbuf/operator=]]
[[fr:cpp/io/basic stringbuf/operator=]]
[[it:cpp/io/basic stringbuf/operator=]]
[[ja:cpp/io/basic stringbuf/operator=]]
[[pt:cpp/io/basic stringbuf/operator=]]
[[ru:cpp/io/basic stringbuf/operator=]]
[[zh:cpp/io/basic stringbuf/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/overflow</title>
    <ns>0</ns>
    <id>12869</id>
    <revision>
      <id>64061</id>
      <parentid>64042</parentid>
      <timestamp>2013-08-07T17:49:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>comment on the overallocation in the example</comment>
      <text xml:space="preserve" bytes="4170">{{cpp/io/basic_stringbuf/title | overflow }}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |1=
protected:
virtual int_type overflow ( int_type c = Traits::eof() );
}}

Appends the character {{tt|c}} to the output character sequence.

If {{tt|c}} is the end-of-file indicator {{c|traits::eq_int_type(c,traits::eof()) {{==}} true}}, then there is no character to append. The function does nothing and returns an unspecified value other than {{c|traits::eof()}}.

Otherwise, if the output sequence has a write position available or this function can successfully make a write position available, then calls {{c|sputc(c)}} and returns {{tt|c}}.

This function can make a write position available if the stringbuf is open for output ({{c|mode &amp; ios_base::out) !{{=}} 0}}): in this case, it reallocates (or initially allocates) the buffer big enough to hold the entire current buffer plus at least one more character. If the stringbuf is also open for input ({{c|(mode &amp; ios_base::in) !{{=}} 0}}, then {{tt|overflow}} also increases the size of the get area by moving {{c|egptr()}} to point just past the new write position.

===Parameters===
(none)

===Return value===
{{c|Traits::eof()}} to indicate failure, {{tt|c}} if the character {{tt|c}} was successfully appended, or some value other than {{c|Traits::eof()}} if called with {{c|Traits::eof()}} as the argument.

===Notes===
This function is different from a typical {{tt|overflow()}} which moves the contents of the buffer to the associated character sequence because for a {{c|std::basic_stringbuf}}, the buffer and the associated sequence are one and the same.


===Example===
{{example
 | In the implementation used to execute this example, overflow() over-allocates the put area to 512 bytes: a call to str() would only return the four initialized bytes, but the next 508 calls to sputc() would not require new calls to overflow()
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::stringbuf
{
    mybuf(const std::string&amp; new_str,
          std::ios_base::openmode which = std::ios_base::in{{!}}std::ios_base::out)
           : std::stringbuf(new_str, which) {}
    int_type overflow(int_type c = EOF) override
    {
        std::cout &lt;&lt; &quot;stringbuf::overflow('&quot; &lt;&lt; char(c) &lt;&lt; &quot;') called\n&quot;
                  &lt;&lt; &quot;Before: size of get area: &quot; &lt;&lt; egptr() - eback() &lt;&lt; '\n'
                  &lt;&lt; &quot;        size of put area: &quot; &lt;&lt; epptr() - pbase() &lt;&lt; '\n';
        int_type ret = std::stringbuf::overflow(c);
        std::cout &lt;&lt; &quot;After : size of get area: &quot; &lt;&lt; egptr() - eback() &lt;&lt; '\n'
                  &lt;&lt; &quot;        size of put area: &quot; &lt;&lt; epptr() - pbase() &lt;&lt; '\n';
        return ret;
    }
};

int main()
{
    std::cout &lt;&lt; &quot;read-write stream:\n&quot;;
    mybuf sbuf(&quot;   &quot;); // read-write stream
    std::iostream stream(&amp;sbuf);
    stream &lt;&lt; 1234;
    std::cout &lt;&lt; sbuf.str() &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;\nread-only stream:\n&quot;;
    mybuf ro_buf(&quot;   &quot;, std::ios_base::in); // read-only stream
    std::iostream ro_stream(&amp;ro_buf);
    ro_stream &lt;&lt; 1234;

    std::cout &lt;&lt; &quot;\nwrite-only stream:\n&quot;;
    mybuf wr_buf(&quot;   &quot;, std::ios_base::out); // write-only stream
    std::iostream wr_stream(&amp;wr_buf);
    wr_stream &lt;&lt; 1234;
}
 | p = true
 | output=
read-write stream:
stringbuf::overflow('4') called
Before: size of get area: 3
        size of put area: 3
After : size of get area: 4
        size of put area: 512
1234

read-only stream:
stringbuf::overflow('1') called
Before: size of get area: 3
        size of put area: 0
After : size of get area: 3
        size of put area: 0

write-only stream:
stringbuf::overflow('4') called
Before: size of get area: 0
        size of put area: 3
After : size of get area: 0
        size of put area: 512
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc underflow}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/overflow]]
[[es:cpp/io/basic stringbuf/overflow]]
[[fr:cpp/io/basic stringbuf/overflow]]
[[it:cpp/io/basic stringbuf/overflow]]
[[ja:cpp/io/basic stringbuf/overflow]]
[[pt:cpp/io/basic stringbuf/overflow]]
[[ru:cpp/io/basic stringbuf/overflow]]
[[zh:cpp/io/basic stringbuf/overflow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/pbackfail</title>
    <ns>0</ns>
    <id>9696</id>
    <revision>
      <id>63939</id>
      <parentid>57745</parentid>
      <timestamp>2013-08-01T15:42:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="2373">{{cpp/io/basic_stringbuf/title | pbackfail }}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |1=
protected:
virtual int_type pbackfail( int_type c = Traits::eof() )
}}

This protected virtual function is called by the public functions {{l2tt|cpp/io/basic_streambuf/sungetc}} and {{l2tt|cpp/io/basic_streambuf/sputbackc}} (which, in turn, are called by {{l2tt|cpp/io/basic_istream/unget}} and {{l2tt|cpp/io/basic_istream/putback}}). 

@1@ The caller is requesting that the get area is backed up by one character ({{tt|pbackfail()}} is called with no arguments or with {{c|Traits::eof()}} as the argument)
:@a@ First, checks if there is a putback position, and if there really isn't, fails. (stringbuf has no external character source to re-read)
:@b@ If the caller was wrong and the putback position is in fact available, simply decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}, e.g. by calling {{c|gbump(-1)}}. 
@2@ The caller attempts to putback a different character from the one retrieved earlier ({{tt|pbackfail()}} is called with the character that needs to be put back), in which case
:@a@ First, checks if there is a putback position, and if there isn't, fails.
:@b@ Then checks what character is in the putback position. If the character held there is already equal to {{tt|c}}, as determined by {{c|Traits::eq(to_char_type(c), gptr()[-1])}}, then simply decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}.
:@c@ Otherwise, if the buffer is open for reading only, fails.
:@d@ Otherwise, if the buffer is open for writing ({{c|mode &amp;&amp; std::ios_base::out}} is nonzero), then decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}} and writes {{tt|c}} to the location pointed to gptr() after adjustment.

===Parameters===
{{par begin}}
{{par | c | the character to put back, or Traits::eof() to indicate that backing up of the get area is requested}}
{{par end}}

===Return value===
{{c|c}} on success except if {{tt|c}} was {{c|Traits::eof()}}, in which case {{c|Traits::not_eof(c)}} is returned.

{{c|Traits::eof()}} on failure.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/seekoff</title>
    <ns>0</ns>
    <id>12871</id>
    <revision>
      <id>70270</id>
      <parentid>65340</parentid>
      <timestamp>2014-05-14T18:09:42Z</timestamp>
      <contributor>
        <ip>119.236.139.207</ip>
      </contributor>
      <text xml:space="preserve" bytes="5181">{{cpp/io/basic_stringbuf/title | seekoff }}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekoff(off_type off,
                         ios_base::seekdir way,
                         ios_base::openmode which = ios_base::in {{!}} ios_base::out);}}

Repositions {{lc|std::basic_streambuf::gptr}} and/or {{lc|std::basic_streambuf::pptr}}, if possible, to the position that corresponds to exactly {{tt|off}} characters from beginning, end, or current position of the get and/or put area of the buffer.

* If {{tt|which}} includes {{tt|ios_base::in}} and this buffer is open for reading (that is, if {{c|((which &amp; ios_base::in) {{==}} ios_base::in}}), then repositions the read pointer {{lc|std::basic_streambuf::gptr}} inside the get area as described below
* If {{tt|which}} includes {{tt|ios_base::out}} and this buffer is open for writing (that is, {{c|(which &amp; ios_base::out) {{==}} ios_base::out}}), then repositions the write pointer {{lc|std::basic_streambuf::pptr}} inside the put area as described below
* If {{tt|which}} includes both  {{tt|ios_base::in}} and  {{tt|ios_base::out}} and the buffer is open for both reading and writing ({{c|1=(which &amp; (ios_base::in{{!}}ios_base::out)) ==(ios_base::in{{!}}ios_base::out)}}), and {{tt|way}} is either {{c|ios_base::beg}} or {{c|ios_base::end}}, then repositions both read and write pointers as described below.
* Otherwise, this function fails.

If the pointer (either {{tt|gptr}} or {{tt|pptr}} or both) is repositioned, it is done as follows:
@1@ If the pointer to be repositioned is a null pointer and the new offset {{tt|newoff}} would be non-zero, this function fails.
@2@ The new pointer offset {{tt|newoff}} of type {{tt|off_type}} is determined
:@a@ if {{c|way {{==}} ios_base::beg}}, then {{tt|newoff}} is zero
:@b@ if {{c|way {{==}} ios_base::cur}}, then {{tt|newoff}} is the current position of the pointer ({{c|gptr()-eback()}} or {{c|pptr()-pbase()}})
:@c@ if {{c|way {{==}} ios_base::end}}, then {{tt|newoff}} is the length of the entire initialized part of the buffer (if overallocation is used, the high watermark pointer minus the beginning pointer)
@3@ If {{c|newoff + off &lt; 0}} (the repositioning would move the pointer to before the beginning of the buffer) or if {{c|newoff + off}} would point past the end of the buffer (or past the last initialized character in the buffer if overallocation is used), the function fails
@4@ Otherwise, the pointer is assigned as if by {{c|gptr() {{=}} eback() + newoff + off}} or {{c|pptr() {{=}} pbase() + newoff + off}}

===Parameters===
{{par begin}}
{{par | off | relative position to set the next pointer(s) to}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par | which | defines whether the input sequences, the output sequence, or both are affected. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
{{c|pos_type(newoff)}} on success, {{c|pos_type(off_type(-1))}} on failure and if pos_type cannot represent the resulting stream position.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::stringstream ss(&quot;123&quot;); // in/out
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // absolute positioning both pointers
    ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::beg); // move both 1 forward
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // try to move both pointers 1 forward from current position
    if(-1 == ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::cur))
        std::cout &lt;&lt; &quot;moving both pointers from current position failed\n&quot;;
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // move the write pointer 1 forward, but not the read pointer
    // can also be called as ss.seekp(1, std::ios_base::cur);
    ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::cur, std::ios_base::out);
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    ss &lt;&lt; 'a'; // write at put position
    std::cout &lt;&lt; &quot;Wrote 'a' at put position, the buffer is now &quot; &lt;&lt; ss.str() &lt;&lt; '\n';
    char ch;
    ss &gt;&gt; ch;
    std::cout &lt;&lt; &quot;reading at get position gives '&quot; &lt;&lt; ch &lt;&lt; &quot;'\n&quot;;
}
 | output=
put pos = 0 get pos = 0
put pos = 1 get pos = 1
moving both pointers from current position failed
put pos = 1 get pos = 1
put pos = 2 get pos = 1
Wrote 'a' at put position, the buffer is now 12a
reading at get position gives '2'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekoff}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/seekoff]]
[[es:cpp/io/basic stringbuf/seekoff]]
[[fr:cpp/io/basic stringbuf/seekoff]]
[[it:cpp/io/basic stringbuf/seekoff]]
[[ja:cpp/io/basic stringbuf/seekoff]]
[[pt:cpp/io/basic stringbuf/seekoff]]
[[ru:cpp/io/basic stringbuf/seekoff]]
[[zh:cpp/io/basic stringbuf/seekoff]]</text>
      <sha1>eyxsf1trhbjblpk00p0bxuiwm83bx4d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/seekpos</title>
    <ns>0</ns>
    <id>12872</id>
    <revision>
      <id>65338</id>
      <parentid>65337</parentid>
      <timestamp>2013-09-09T18:54:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealsos</comment>
      <text xml:space="preserve" bytes="2682">{{cpp/io/basic_stringbuf/title |seekpos}}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekpos(pos_type sp,
                         std::ios_base::openmode which = std::ios_base::in {{!}} std::ios_base::out );
}}

Repositions {{lc|std::basic_streambuf::gptr}} and/or {{lc|std::basic_streambuf::pptr}}, if possible, to the position indicated by {{tt|sp}}

Effectively executes {{c|seekoff(off_type(sp), std::ios_base::beg, which)}}

===Parameters===
{{par begin}}
{{par | sp | stream position, such as one obtained by {{lc|seekoff()}} or {{tt|seekpos()}}}}
{{par | which | defines whether the input sequences, the output sequence, or both are affected. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
{{tt|sp}} on success or {{c|pos_type(off_type(-1))}} on failure.

===Notes===
{{tt|seekpos()}} is called by {{lc|std::basic_streambuf::pubseekpos()}}, which is called by the single-argument versions of {{lc|std::basic_istream::seekg()}} and {{lc|std::basic_ostream::seekp()}}

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::stringbuf
{
    mybuf(const std::string&amp; str) : std::stringbuf(str) {}
    pos_type seekpos(pos_type sp, std::ios_base::openmode which) {
         std::cout &lt;&lt; &quot;Before seekpos(&quot; &lt;&lt; sp &lt;&lt; &quot;), size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
         pos_type rc = std::stringbuf::seekpos(sp, which);
         std::cout &lt;&lt; &quot;seekpos() returns &quot; &lt;&lt; rc &lt;&lt; &quot;.\nAfter the call, &quot;
                   &lt;&lt; &quot;size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
        return rc;
    }
};

int main()
{
    mybuf buf(&quot;12345&quot;);
    std::iostream stream(&amp;buf);
    stream.seekg(2);
}
 | output=
Before seekpos(2), size of the get area is 5 with 5 read positions available
seekpos() returns 2.
After the call, size of the get area is 5 with 3 read positions available
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc inc | cpp/io/basic_stringbuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekpos}}
{{dsc inc | cpp/io/strstreambuf/dsc seekpos}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/seekpos]]
[[es:cpp/io/basic stringbuf/seekpos]]
[[fr:cpp/io/basic stringbuf/seekpos]]
[[it:cpp/io/basic stringbuf/seekpos]]
[[ja:cpp/io/basic stringbuf/seekpos]]
[[pt:cpp/io/basic stringbuf/seekpos]]
[[ru:cpp/io/basic stringbuf/seekpos]]
[[zh:cpp/io/basic stringbuf/seekpos]]</text>
      <sha1>bcelho7k3qx0vv2m2ibcu4s35nwspjp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/setbuf</title>
    <ns>0</ns>
    <id>4576</id>
    <revision>
      <id>69879</id>
      <parentid>62420</parentid>
      <timestamp>2014-04-30T13:54:55Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Return value */ correcting</comment>
      <text xml:space="preserve" bytes="2146">{{cpp/io/basic_stringbuf/title | setbuf }}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |
protected:
virtual std::basic_streambuf&lt;CharT, Traits&gt;* setbuf( char_type* s, std::streamsize n )
}}

If {{tt|s}} is a null pointer and {{tt|n}} is zero, this function has no effect.

Otherwise, the effect is implementation-defined: some implementations do nothing, while some implementations clear the {{lc|std::string}} member currently used as the buffer and begin using the user-supplied character array of size {{tt|n}}, whose first element is pointed to by {{tt|s}}, as the buffer and the input/output character sequence.

This function is protected virtual, it may only be called through {{tt|pubsetbuf()}} or from member functions of a user-defined class derived from {{tt|std::basic_stringbuf}}.

===Parameters===
{{par begin}}
{{par | s | pointer to the first byte in the user-provided buffer or null}}
{{par | n | the number of bytes in the user-provided buffer or zero}}
{{par end}}

===Return value===
{{c|this}}.

===Notes===
The deprecated stream buffer {{c|std::strstreambuf}} or the boost.IOStreams device [http://www.boost.org/doc/libs/release/libs/iostreams/doc/classes/array.html#array {{tt|boost::basic_array}}] may be used to implement I/O buffering over a user-provided char array in portable manner.

===Example===
{{example
 | Test for the stringstream's setbuf functionality
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::ostringstream ss;
    char c[1024] = {};
    ss.rdbuf()-&gt;pubsetbuf(c, 1024);
    ss &lt;&lt; 3.14 &lt;&lt; '\n';
    std::cout &lt;&lt; c &lt;&lt; '\n';
}
 | output=
3.14 (on GNU g++/libstdc++ and SunPro C++/roguewave)
&lt;nothing&gt; (on MS Visual Studio 2010, SunPro C++/stlport4, CLang++/libc++)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsetbuf | mem=std::basic_streambuf}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/setbuf]]
[[es:cpp/io/basic stringbuf/setbuf]]
[[fr:cpp/io/basic stringbuf/setbuf]]
[[it:cpp/io/basic stringbuf/setbuf]]
[[ja:cpp/io/basic stringbuf/setbuf]]
[[pt:cpp/io/basic stringbuf/setbuf]]
[[ru:cpp/io/basic stringbuf/setbuf]]
[[zh:cpp/io/basic stringbuf/setbuf]]</text>
      <sha1>t4tej5j4278kvocuohv8cb7jhbjab5c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/str</title>
    <ns>0</ns>
    <id>9413</id>
    <revision>
      <id>64059</id>
      <parentid>64055</parentid>
      <timestamp>2013-08-07T17:43:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>11, not 14</comment>
      <text xml:space="preserve" bytes="4197">{{cpp/io/basic_stringbuf/title | str }}
{{cpp/io/basic_stringbuf/navbar}}
{{dcl begin}}
{{dcl | num=1 |
std::basic_string&lt;CharT, Traits, Allocator&gt; str() const;
}}
{{dcl | num=2 |
void str( const std::basic_string&lt;CharT, Traits, Allocator&gt;&amp; s);
}}
{{dcl end}}

Gets and sets the underlying string.

@1@ Creates and returns a {{lc|std::basic_string}} object containing a copy of this {{tt|std::basic_stringbuf}}'s underlying character sequence. For input-only streams, the returned string contains the characters from the range {{c|[eback(), egptr())}}. For input/output or output-only streams, contains the characters from {{c|pbase()}} to the last character in the sequence regardless of {{c|egptr()}} and {{c|epptr()}}.

{{rev begin}}
{{rev | since=c++11 |
The member character sequence in a buffer open for writing can be over-allocated for efficiency purposes. In that case, only the ''initialized characters'' are returned: these characters are the ones that were obtained from the string argument of the constructor, the string argument of the most recent call to the second overload of {{tt|str()}}, or from an write operation. Typical implementation that uses over-allocation maintains a high-watermark pointer to track the end of the initialized part of the buffer and this overload returns the characters from {{c|pbase()}} to the high-watermark pointer}}
{{rev end}}

@2@ Deletes the entire underlying character sequence of this {{tt|std::basic_stringbuf}} and then configures a new underlying character sequence containing a copy of the contents of {{tt|s}}. The pointers of {{lc|std::basic_streambuf}} are initialized as follows:
: For input streams ({{c|mode &amp; ios_base::in {{==}} true}}), {{c|eback()}} points at the first character, {{c|gptr() {{==}} eback()}}, and {{c|egptr() {{==}} eback() + s.size()}}: the subsequent input will read the first character copied from {{tt|s}}.
: For output streams ({{c|mode &amp; ios_base::out {{==}} true}}), {{c|pbase()}} points at the first character and {{c|epptr() &gt;{{=}} pbase() + s.size()}} (epptr is allowed to point farther so that the following {{tt|sputc()}} wouldn't immediately call {{tt|overflow()}})
:: For append streams ({{c|mode &amp; ios_base::ate {{==}} true}}), {{c|pptr() {{==}} pbase() + s.size()}}, so that subsequent output will be appended to the last character copied from {{tt|s}} {{mark since c++11}}
:: For no-appending output streams, {{c|pptr() {{==}} pbase()}}, so that subsequent output will overwrite the characters copied from {{tt|s}}.

===Parameters===
{{par begin}}
{{par | s | a string object holding the replacement character sequence}}
{{par end}}

===Return value===
@1@ A string object holding a copy of this buffer's underlying character sequence.
@2@ (none)

===Notes===
This function is typically accessed through {{c|std::basic_stringstream::str()}}.

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
int main()
{
    int n;

    std::istringstream in;  // could also use in(&quot;1 2&quot;)
    in.rdbuf()-&gt;str(&quot;1 2&quot;); // set the get area
    in &gt;&gt; n;
    std::cout &lt;&lt; &quot;after reading the first int from \&quot;1 2\&quot;, the int is &quot; 
              &lt;&lt; n &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; in.rdbuf()-&gt;str() &lt;&lt; &quot;\&quot;\n&quot;; // or in.str()

    std::ostringstream out(&quot;1 2&quot;);
    out &lt;&lt; 3;
    std::cout &lt;&lt; &quot;after writing the int '3' to output stream \&quot;1 2\&quot;&quot;
              &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; out.str() &lt;&lt; &quot;\&quot;\n&quot;;

    std::ostringstream ate(&quot;1 2&quot;, std::ios_base::ate); // C++11
    ate &lt;&lt; 3;
    std::cout &lt;&lt; &quot;after writing the int '3' to append stream \&quot;1 2\&quot;&quot;
              &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; ate.str() &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
after reading the first int from &quot;1 2&quot;, the int is 1, str() = &quot;1 2&quot;
after writing the int '3' to output stream &quot;1 2&quot;, str() = &quot;3 2&quot;
after writing the int '3' to append stream &quot;1 2&quot;, str() = &quot;1 23&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc str | basic_stringstream}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/str]]
[[es:cpp/io/basic stringbuf/str]]
[[fr:cpp/io/basic stringbuf/str]]
[[it:cpp/io/basic stringbuf/str]]
[[ja:cpp/io/basic stringbuf/str]]
[[pt:cpp/io/basic stringbuf/str]]
[[ru:cpp/io/basic stringbuf/str]]
[[zh:cpp/io/basic stringbuf/str]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/swap</title>
    <ns>0</ns>
    <id>9446</id>
    <revision>
      <id>62742</id>
      <parentid>57750</parentid>
      <timestamp>2013-07-01T23:35:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1472">{{cpp/io/basic_stringbuf/title |swap}}
{{cpp/io/basic_stringbuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( std::basic_stringbuf&amp; rhs )
}}
{{dcl end}}

Swaps the state and the contents of {{c|*this}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|basic_stringbuf}} }}
{{par end}}

===Return value===
(none)

===Notes===
This function is called automatically when swapping {{lc|std::stringstream}} objects, it is rarely necessary to call it directly.

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{

    std::istringstream one(&quot;one&quot;);
    std::ostringstream two(&quot;two&quot;);

    std::cout &lt;&lt; &quot;Before swap, one = \&quot;&quot; &lt;&lt; one.str() &lt;&lt; '&quot;'
              &lt;&lt; &quot; two = \&quot;&quot; &lt;&lt; two.str() &lt;&lt; &quot;\&quot;\n&quot;;

    *one.rdbuf()-&gt;swap(*two.rdbuf());

    std::cout &lt;&lt; &quot;Before swap, one = \&quot;&quot; &lt;&lt; one.str() &lt;&lt; '&quot;'
              &lt;&lt; &quot; two = \&quot;&quot; &lt;&lt; two.str() &lt;&lt; &quot;\&quot;\n&quot;;
}
| output=
Before swap, one = &quot;one&quot; two = &quot;two&quot;
Before swap, one = &quot;two&quot; two = &quot;one&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap | basic_stringstream}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/swap]]
[[es:cpp/io/basic stringbuf/swap]]
[[fr:cpp/io/basic stringbuf/swap]]
[[it:cpp/io/basic stringbuf/swap]]
[[ja:cpp/io/basic stringbuf/swap]]
[[pt:cpp/io/basic stringbuf/swap]]
[[ru:cpp/io/basic stringbuf/swap]]
[[zh:cpp/io/basic stringbuf/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/swap2</title>
    <ns>0</ns>
    <id>12801</id>
    <revision>
      <id>63143</id>
      <parentid>63142</parentid>
      <timestamp>2013-07-03T08:02:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="781">{{cpp/title | swap&lt;small&gt;(std::basic_stringbuf)&lt;/small&gt;}}
{{cpp/io/basic_stringbuf/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class CharT, class Traits &gt;
void swap( std::basic_stringbuf&lt;CharT,Traits&gt;&amp; lhs,
           std::basic_stringbuf&lt;CharT,Traits&gt;&amp; rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::basic_stringbuf}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | {{lc|std::basic_stringbuf}} objects whose states to swap}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringbuf/underflow</title>
    <ns>0</ns>
    <id>12870</id>
    <revision>
      <id>65334</id>
      <parentid>65021</parentid>
      <timestamp>2013-09-09T17:34:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso</comment>
      <text xml:space="preserve" bytes="4809">{{cpp/io/basic_stringbuf/title | underflow }}
{{cpp/io/basic_stringbuf/navbar}}
{{ddcl |
protected:
virtual int_type underflow()
}}

Reads the next character from the get area of the buffer.

Specifically:

@1@ If the input sequence has a read position available ({{c|egptr() &gt; gptr()}}), returns {{c|Traits::to_int_type(*gptr())}}

@2@ Otherwise, if {{c|pptr() &gt; egptr()}} (some characters were inserted into the stream since the last time {{lc|overflow()}} changed {{lc|egptr()}}) then extends the end of the get area to include the most recently inserted characters, by changing {{lc|egptr()}} to equal {{lc|pptr()}}, and then returns {{c|Traits::to_int_type(*gptr())}}

@3@ Otherwise, returns {{c|Traits::eof()}}.

Any character in the buffer which has been initialized, regardless of whether it originated from the string passed in the constructor or was appended by {{lc|overflow()}}, is considered to be part of the input sequence.

===Parameters===
(none)

===Return value===
{{c|Traits::to_int_type(*gptr())}} (the next character to read in the get area) in case of success, or {{c|Traits::eof()}} in case of failure.

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::stringbuf
{
    mybuf(const std::string&amp; new_str,
          std::ios_base::openmode which = std::ios_base::in{{!}}std::ios_base::out)
           : std::stringbuf(new_str, which) {}

    int_type overflow(int_type c) {
        std::cout &lt;&lt; &quot;Before overflow(): get area size is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; the put area size is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        int_type rc = std::stringbuf::overflow(c);
        std::cout &lt;&lt; &quot;After overflow(): get area size is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; put area size is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        return rc;
    }

    int_type underflow() {
        std::cout &lt;&lt; &quot;Before underflow(): get area size is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; put area size is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        int_type ch = std::stringbuf::underflow();
        std::cout &lt;&lt; &quot;After underflow(): get area size is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; put area size is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        if(ch == EOF)
            std::cout &lt;&lt; &quot;underflow() returns EOF\n&quot;;
        else
            std::cout &lt;&lt; &quot;underflow() returns '&quot; &lt;&lt; char(ch) &lt;&lt; &quot;'\n&quot;;
        return ch;
    }
};

int main()
{
    mybuf sbuf(&quot;123&quot;); // read-write stream
    std::iostream stream(&amp;sbuf);
    int n;
    stream &gt;&gt; n; // calls sgetc() four times
                 // three calls return the characters '1', '2', '3'
                 // the fourth call, gptr() == egptr() and underflow() is called
                 // underflow returns EOF
    std::cout &lt;&lt; n &lt;&lt; '\n';
    stream.clear(); // clear the eofbit

    stream &lt;&lt; &quot;123456&quot;; // sputc() is called 6 times
                        // first three calls store &quot;123&quot; in the existing buffer
                        // 4th call finds that pptr() == epptr() and calls overflow()
                        // overflow() grows the buffer and sets egptr() to 4
                        // 5th and 6th calls store '5' and '6', advancing pptr()
    stream &gt;&gt; n; // calls sgetc() 4 times
                 // 1st call returns the '4' that was made available by overflow()
                 // on the 2nd call, egptr() == egptr() and underflow() is called
                 // underflow advances egptr() to equal pptr() (which is 6)
                 // 3rd sgetc() returns '6'
                 // 4th sgetc() finds gptr() == egptr(), calls underflow()
                 // underflow() returns EOF
    std::cout &lt;&lt; n &lt;&lt; '\n';
}
 | p=true
 | output=
Before underflow(): get area size is 3  put area size is 3
After underflow(): get area size is 3  put area size is 3
underflow() returns EOF
123
Before overflow(): get area size is 3  the put area size is 3
After overflow(): get area size is 4  put area size is 35
Before underflow(): get area size is 4  put area size is 35
After underflow(): get area size is 6  put area size is 35
underflow() returns '5'
Before underflow(): get area size is 6  put area size is 35
After underflow(): get area size is 6  put area size is 35
underflow() returns EOF
456
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/io/strstreambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc end}}

[[de:cpp/io/basic stringbuf/underflow]]
[[es:cpp/io/basic stringbuf/underflow]]
[[fr:cpp/io/basic stringbuf/underflow]]
[[it:cpp/io/basic stringbuf/underflow]]
[[ja:cpp/io/basic stringbuf/underflow]]
[[pt:cpp/io/basic stringbuf/underflow]]
[[ru:cpp/io/basic stringbuf/underflow]]
[[zh:cpp/io/basic stringbuf/underflow]]</text>
      <sha1>s5n8lro55dmp1x3ulllis5mvnvyz0yi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream</title>
    <ns>0</ns>
    <id>565</id>
    <revision>
      <id>64355</id>
      <parentid>64353</parentid>
      <timestamp>2013-08-15T18:30:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="2416">{{cpp/title|basic_stringstream}}
{{cpp/io/basic_stringstream/navbar}}
{{dcl begin}}
{{dcl header | sstream}}
{{dcl rev begin}}
{{dcl | until=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;
&gt; class basic_stringstream;
}}
{{dcl | since=c++11 | 1=
template&lt; 
    class CharT, 
    class Traits = std::char_traits&lt;CharT&gt;,
    class Allocator = std::allocator&lt;CharT&gt;
&gt; class basic_stringstream;
}}
{{dcl rev end}}
{{dcl end}}

The class template {{tt|std::basic_stringstream}} implements input/output operations on memory ({{lc|std::basic_string}}) based streams. It essentially wraps a raw string device implementation ({{lc|std::basic_stringbuf}}) into a higher-level interface ({{lc|std::basic_iostream}}). The complete interface to unique {{tt|std::basic_stringbuf}} members is provided.

{{inheritance diagram/std-basic_stringstream}}

Two specializations for common character types are also defined:

{{dsc begin}}
{{dsc header | sstream}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|stringstream}} | {{c|basic_stringstream&lt;char&gt;}}}}
{{dsc | {{tt|wstringstream}} | {{c|basic_stringstream&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc inc | cpp/io/dsc allocator_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc constructor | basic_stringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc operator{{=}} | basic_stringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap | basic_stringstream}}
{{dsc inc | cpp/io/basic_stringstream/dsc rdbuf | basic_stringstream}}

{{dsc h2 | String operations }}
{{dsc inc | cpp/io/basic_stringstream/dsc str | basic_stringstream}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap2 | basic_istringstream}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/basic stringstream]]
[[es:cpp/io/basic stringstream]]
[[fr:cpp/io/basic stringstream]]
[[it:cpp/io/basic stringstream]]
[[ja:cpp/io/basic stringstream]]
[[pt:cpp/io/basic stringstream]]
[[ru:cpp/io/basic stringstream]]
[[zh:cpp/io/basic stringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/basic stringstream</title>
    <ns>0</ns>
    <id>566</id>
    <revision>
      <id>50861</id>
      <parentid>43413</parentid>
      <timestamp>2013-06-01T03:42:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="490">{{include page|cpp/io/basic_stringstream/constructor|basic_stringstream}}

[[de:cpp/io/basic stringstream/basic stringstream]]
[[es:cpp/io/basic stringstream/basic stringstream]]
[[fr:cpp/io/basic stringstream/basic stringstream]]
[[it:cpp/io/basic stringstream/basic stringstream]]
[[ja:cpp/io/basic stringstream/basic stringstream]]
[[pt:cpp/io/basic stringstream/basic stringstream]]
[[ru:cpp/io/basic stringstream/basic stringstream]]
[[zh:cpp/io/basic stringstream/basic stringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/operator=</title>
    <ns>0</ns>
    <id>567</id>
    <revision>
      <id>43406</id>
      <parentid>1133</parentid>
      <timestamp>2012-11-03T02:39:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="407">{{cpp/io/basic_stringstream/operator{{=}}|basic_stringstream}}

[[de:cpp/io/basic stringstream/operator=]]
[[es:cpp/io/basic stringstream/operator=]]
[[fr:cpp/io/basic stringstream/operator=]]
[[it:cpp/io/basic stringstream/operator=]]
[[ja:cpp/io/basic stringstream/operator=]]
[[pt:cpp/io/basic stringstream/operator=]]
[[ru:cpp/io/basic stringstream/operator=]]
[[zh:cpp/io/basic stringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/rdbuf</title>
    <ns>0</ns>
    <id>568</id>
    <revision>
      <id>50862</id>
      <parentid>43398</parentid>
      <timestamp>2013-06-01T03:42:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="380">{{include page|cpp/io/basic_stringstream/rdbuf|basic_stringstream}}

[[de:cpp/io/basic stringstream/rdbuf]]
[[es:cpp/io/basic stringstream/rdbuf]]
[[fr:cpp/io/basic stringstream/rdbuf]]
[[it:cpp/io/basic stringstream/rdbuf]]
[[ja:cpp/io/basic stringstream/rdbuf]]
[[pt:cpp/io/basic stringstream/rdbuf]]
[[ru:cpp/io/basic stringstream/rdbuf]]
[[zh:cpp/io/basic stringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/str</title>
    <ns>0</ns>
    <id>569</id>
    <revision>
      <id>50863</id>
      <parentid>43392</parentid>
      <timestamp>2013-06-01T03:42:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="362">{{include page|cpp/io/basic_stringstream/str|basic_stringstream}}

[[de:cpp/io/basic stringstream/str]]
[[es:cpp/io/basic stringstream/str]]
[[fr:cpp/io/basic stringstream/str]]
[[it:cpp/io/basic stringstream/str]]
[[ja:cpp/io/basic stringstream/str]]
[[pt:cpp/io/basic stringstream/str]]
[[ru:cpp/io/basic stringstream/str]]
[[zh:cpp/io/basic stringstream/str]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/swap</title>
    <ns>0</ns>
    <id>570</id>
    <revision>
      <id>50864</id>
      <parentid>43385</parentid>
      <timestamp>2013-06-01T03:42:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{include page|cpp/io/basic_stringstream/swap|basic_stringstream}}

[[de:cpp/io/basic stringstream/swap]]
[[es:cpp/io/basic stringstream/swap]]
[[fr:cpp/io/basic stringstream/swap]]
[[it:cpp/io/basic stringstream/swap]]
[[ja:cpp/io/basic stringstream/swap]]
[[pt:cpp/io/basic stringstream/swap]]
[[ru:cpp/io/basic stringstream/swap]]
[[zh:cpp/io/basic stringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/basic stringstream/swap2</title>
    <ns>0</ns>
    <id>5494</id>
    <revision>
      <id>50865</id>
      <parentid>43378</parentid>
      <timestamp>2013-06-01T03:42:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="380">{{include page|cpp/io/basic_stringstream/swap2|basic_stringstream}}

[[de:cpp/io/basic stringstream/swap2]]
[[es:cpp/io/basic stringstream/swap2]]
[[fr:cpp/io/basic stringstream/swap2]]
[[it:cpp/io/basic stringstream/swap2]]
[[ja:cpp/io/basic stringstream/swap2]]
[[pt:cpp/io/basic stringstream/swap2]]
[[ru:cpp/io/basic stringstream/swap2]]
[[zh:cpp/io/basic stringstream/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c</title>
    <ns>0</ns>
    <id>571</id>
    <revision>
      <id>71031</id>
      <parentid>71001</parentid>
      <timestamp>2014-06-04T20:11:01Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>descriptive name</comment>
      <text xml:space="preserve" bytes="6012">{{title|C-style file input/output}}
{{cpp/io/c/navbar}}
The C I/O subset of the C++ standard library implements C-style stream input/output operations.  The {{tt|&lt;cstdio&gt;}} header provides generic file operation support and supplies functions with narrow and multibyte character input/output capabilities, and the {{tt|&lt;cwchar&gt;}} header provides functions with wide character input/output capabilities.  

C streams are objects of type {{lc|std::FILE}} that can only be accessed and manipulated through pointers of type {{c|std::FILE*}} (Note: while it may be possible to create a local object of type {{lc|std::FILE}} by dereferencing and copying a valid {{c|std::FILE*}}, using the address of such copy in the I/O functions is undefined behavior). Each C stream is associated with an external physical device (file, standard input stream, printer, serial port, etc).

C streams can be used for both unformatted and formatted input and output. They are locale-sensitive and may perform wide/multibyte conversions as necessary. Unlike C++ streams, where each stream is associated with its own locale, all C streams access the same locale object: the one most recently installed with {{lc|std::setlocale}}.

Besides the system-specific information necessary to access the device (e.g. a POSIX file descriptor), each C stream object holds the following:
@1@ Character width: narrow or wide
@2@ Buffering state: unbuffered, line-buffered, fully buffered.
@3@ The buffer, which may be replaced by an external, user-provided buffer.
@4@ I/O mode: input, output, or update (both input and output).
@5@ Binary/text mode indicator.
@6@ End-of-file status indicator.
@7@ Error status indicator.
@8@ File position indicator (an object of type {{lc|std::fpos_t}}), which, for wide character streams, includes the parse state (an object of type {{lc|std::mbstate_t}}).

===Functions===
{{dsc begin}}
{{dsc h2 | File access}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc inc | cpp/io/c/dsc freopen}}
{{dsc inc | cpp/io/c/dsc fclose}}
{{dsc inc | cpp/io/c/dsc fflush}}
{{dsc inc | cpp/io/c/dsc fwide}}
{{dsc inc | cpp/io/c/dsc setbuf}}
{{dsc inc | cpp/io/c/dsc setvbuf}}

{{dsc h2 | Direct input/output}}
{{dsc inc | cpp/io/c/dsc fread}}
{{dsc inc | cpp/io/c/dsc fwrite}}

{{dsc h2 | Unformatted input/output}}
{{dsc h2 | {{small|Narrow character}}}}
{{dsc inc | cpp/io/c/dsc fgetc}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc inc | cpp/io/c/dsc fputc}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc getchar}}
{{dsc inc | cpp/io/c/dsc gets}}
{{dsc inc | cpp/io/c/dsc putchar}}
{{dsc inc | cpp/io/c/dsc puts}}
{{dsc inc | cpp/io/c/dsc ungetc}}

{{dsc h2 | {{small|Wide character}}}}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc inc | cpp/io/c/dsc fgetws}}
{{dsc inc | cpp/io/c/dsc fputwc}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc inc | cpp/io/c/dsc getwchar}}
{{dsc inc | cpp/io/c/dsc putwchar}}
{{dsc inc | cpp/io/c/dsc ungetwc}}

{{dsc h2 | Formatted input/output}}
{{dsc h2 | {{small|Narrow/multibyte character}}}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc vfscanf}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc inc | cpp/io/c/dsc vfprintf}}

{{dsc h2 | {{small|Wide character}}}}
{{dsc inc | cpp/io/c/dsc fwscanf}}
{{dsc inc | cpp/io/c/dsc vfwscanf}}
{{dsc inc | cpp/io/c/dsc fwprintf}}
{{dsc inc | cpp/io/c/dsc vfwprintf}}

{{dsc h2 | File positioning}}
{{dsc inc | cpp/io/c/dsc ftell}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc inc | cpp/io/c/dsc fsetpos}}
{{dsc inc | cpp/io/c/dsc rewind}}

{{dsc h2 | Error handling}}
{{dsc inc | cpp/io/c/dsc clearerr}}
{{dsc inc | cpp/io/c/dsc feof}}
{{dsc inc | cpp/io/c/dsc ferror}}
{{dsc inc | cpp/io/c/dsc perror}}

{{dsc h2 | Operations on files}}
{{dsc inc | cpp/io/c/dsc remove}}
{{dsc inc | cpp/io/c/dsc rename}}
{{dsc inc | cpp/io/c/dsc tmpfile}}
{{dsc inc | cpp/io/c/dsc tmpnam}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | cstdio}}
{{dsc hitem | Type | Definition}}
{{dsc | {{c|FILE}} | type, capable of holding all information needed to control a C I/O stream}}
{{dsc | {{c|fpos_t}} | non-array type, capable of uniquely specifying a position in a file, including its multibyte parse state}}
{{dsc end}}

===Macros===

{{dsc begin}}
{{dsc header | cstdio}}
{{dsc macro const | stdin | nolink=true| title=stdin&lt;br&gt;stdout&lt;br&gt;stderr | expression of type {{c|FILE*}} associated with the input stream&lt;br&gt;expression of type {{c|FILE*}} associated with the output stream&lt;br&gt;expression of type {{c|FILE*}} associated with the error output stream}}
{{dsc macro const | EOF | nolink=true| integer constant expression of type {{c|int}} and negative value }}
{{dsc macro const | FOPEN_MAX | nolink=true| number of files that can be open simultaneously }}
{{dsc macro const | FILENAME_MAX | nolink=true| size needed for an array of char to hold the longest supported file name}}
{{dsc macro const | BUFSIZ | nolink=true| size of the buffer used by {{lc|std::setbuf}} }}
{{dsc macro const | _IOFBF| nolink=true| title=_IOFBF&lt;br&gt;_IOLBF&lt;br&gt;_IONBF|argument to {{lc|std::setbuf}} indicating fully buffered I/O&lt;br&gt;argument to {{lc|std::setbuf}} indicating line buffered I/O&lt;br&gt;argument to {{lc|std::setbuf}} indicating unbuffered I/O}}
{{dsc macro const | SEEK_SET | nolink=true| title=SEEK_SET&lt;br&gt;SEEK_CUR&lt;br&gt;SEEK_END | argument to {{lc|std::fseek}} indicating seeking from beginning of the file&lt;br&gt;argument to {{lc|std::fseek}} indicating seeking from the current file position&lt;br&gt;argument to {{lc|std::fseek}} indicating seeking from end of the file}}
{{dsc macro const | TMP_MAX | nolink=true| maximum number of unique filenames that can be generated by {{lc|std::tmpnam}} }}
{{dsc macro const | L_tmpnam |nolink=true|  size needed for an array of char to hold the result of {{lc|std::tmpnam}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/io |File input/output}}
{{dsc end}}

[[cs:cpp/io/c]]
[[de:cpp/io/c]]
[[es:cpp/io/c]]
[[fr:cpp/io/c]]
[[it:cpp/io/c]]
[[ja:cpp/io/c]]
[[pt:cpp/io/c]]
[[ru:cpp/io/c]]
[[zh:cpp/io/c]]</text>
      <sha1>smai2ee75bh0how68bbt3zbuutai2j0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/clearerr</title>
    <ns>0</ns>
    <id>572</id>
    <revision>
      <id>67594</id>
      <parentid>57757</parentid>
      <timestamp>2014-02-12T21:31:43Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="763">{{cpp/title | clearerr}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
void clearerr( std::FILE* stream );
}}

Resets the error flags and the {{tt|EOF}} indicator for the given file stream.

===Parameters===
{{par begin}}
{{par | stream | the file to reset the error flags for }}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc feof}}
{{dsc inc | cpp/io/c/dsc perror}}
{{dsc inc | cpp/io/c/dsc ferror}}
{{dsc see c | c/io/clearerr}}
{{dsc end}}

[[cs:cpp/io/c/clearerr]]
[[de:cpp/io/c/clearerr]]
[[es:cpp/io/c/clearerr]]
[[fr:cpp/io/c/clearerr]]
[[it:cpp/io/c/clearerr]]
[[ja:cpp/io/c/clearerr]]
[[pt:cpp/io/c/clearerr]]
[[ru:cpp/io/c/clearerr]]
[[zh:cpp/io/c/clearerr]]</text>
      <sha1>jjcb269v8smuf0gg503f447sohtosif</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fclose</title>
    <ns>0</ns>
    <id>573</id>
    <revision>
      <id>67577</id>
      <parentid>57758</parentid>
      <timestamp>2014-02-12T20:55:32Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1052">{{cpp/title | fclose}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fclose( std::FILE* stream );
}}

Closes the given file stream. Any unwritten buffered data are flushed to the OS. Any unread buffered data are discarded.

Whether or not the operation succeeds, the stream is no longer associated with a file, and the buffer allocated by {{lc|std::setbuf}} or {{lc|std::setvbuf}}, if any, is also disassociated and deallocated if automatic allocation was used.

===Parameters===
{{par begin}}
{{par | stream | the file stream to close}}
{{par end}}

===Return value===
{{c|0}} on success, {{lc|EOF}} otherwise

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc inc | cpp/io/c/dsc freopen}}
{{dsc inc | cpp/io/basic_filebuf/dsc close}}
{{dsc see c | c/io/fclose}}
{{dsc end}}

[[cs:cpp/io/c/fclose]]
[[de:cpp/io/c/fclose]]
[[es:cpp/io/c/fclose]]
[[fr:cpp/io/c/fclose]]
[[it:cpp/io/c/fclose]]
[[ja:cpp/io/c/fclose]]
[[pt:cpp/io/c/fclose]]
[[ru:cpp/io/c/fclose]]
[[zh:cpp/io/c/fclose]]</text>
      <sha1>dicuhg8ccvdp6hlpp2dte1vq8hciujj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/feof</title>
    <ns>0</ns>
    <id>574</id>
    <revision>
      <id>57761</id>
      <parentid>49728</parentid>
      <timestamp>2013-06-01T06:00:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1374">{{cpp/title | feof}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int feof( std::FILE* stream );
}}

Checks if the end of the given file stream has been reached.

===Parameters===
{{par begin}}
{{par | stream | the file stream to check }}
{{par end}}

===Return value===
Nonzero value if the end of the stream has been reached, otherwise {{c|0}}.

===Notes===
This function only reports the stream state as reported by the most recent I/O operation, it does not examine the associated data source. For example, if the most recent I/O was a {{lc|std::fgetc}}, which returned the last byte of a file, {{tt|std::feof}} returns zero. The next {{lc|std::fgetc}} fails and changes the stream state to ''end-of-file''. Only then {{tt|std::feof}} returns non-zero.

In typical usage, input stream processing stops on any error; {{tt|feof}} and {{lc|std::ferror}} are then used to distinguish between different error conditions.

===Example===
{{example template|cpp/io/c/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc eof}}
{{dsc inc | cpp/io/c/dsc clearerr}}
{{dsc inc | cpp/io/c/dsc perror}}
{{dsc inc | cpp/io/c/dsc ferror}}
{{dsc see c | c/io/feof}}
{{dsc end}}

[[cs:cpp/io/c/feof]]
[[de:cpp/io/c/feof]]
[[es:cpp/io/c/feof]]
[[fr:cpp/io/c/feof]]
[[it:cpp/io/c/feof]]
[[ja:cpp/io/c/feof]]
[[pt:cpp/io/c/feof]]
[[ru:cpp/io/c/feof]]
[[zh:cpp/io/c/feof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/ferror</title>
    <ns>0</ns>
    <id>575</id>
    <revision>
      <id>67595</id>
      <parentid>57762</parentid>
      <timestamp>2014-02-12T21:33:52Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="733">{{cpp/title | ferror}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int ferror( std::FILE* stream );
}}

Checks the given stream for errors.

===Parameters===
{{par begin}}
{{par | stream | the file stream to check }}
{{par end}}

===Return value===
Nonzero value if the file stream has errors occurred, {{c|0}} otherwise 

===Example===
{{example template|cpp/io/c/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc clearerr}}
{{dsc inc | cpp/io/c/dsc feof}}
{{dsc inc | cpp/io/c/dsc perror}}
{{dsc see c | c/io/ferror}}
{{dsc end}}

[[de:cpp/io/c/ferror]]
[[es:cpp/io/c/ferror]]
[[fr:cpp/io/c/ferror]]
[[it:cpp/io/c/ferror]]
[[ja:cpp/io/c/ferror]]
[[pt:cpp/io/c/ferror]]
[[ru:cpp/io/c/ferror]]
[[zh:cpp/io/c/ferror]]</text>
      <sha1>s4z2vlyag9fii53a3f6a6pwkgegm4v2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fflush</title>
    <ns>0</ns>
    <id>576</id>
    <revision>
      <id>67578</id>
      <parentid>65952</parentid>
      <timestamp>2014-02-12T20:56:08Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="969">{{cpp/title | fflush}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fflush( std::FILE* stream );
}}

Causes the output file stream to be synchronized with the actual contents of the file.

The behavior is undefined if the given stream is of the input type or if the given stream is of the update type, but the last I/O operation was not an output operation.

If {{tt|stream}} is {{c|NULL}}, all open streams are flushed.

===Parameters===
{{par begin}}
{{par | stream | the file stream to synchronize}}
{{par end}}

===Return value===
Returns zero on success. Otherwise {{lc|EOF}} is returned and the error indicator of the file stream is set.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc inc | cpp/io/c/dsc fclose}}
{{dsc see c | c/io/fflush}}
{{dsc end}}

[[de:cpp/io/c/fflush]]
[[es:cpp/io/c/fflush]]
[[fr:cpp/io/c/fflush]]
[[it:cpp/io/c/fflush]]
[[ja:cpp/io/c/fflush]]
[[pt:cpp/io/c/fflush]]
[[ru:cpp/io/c/fflush]]
[[zh:cpp/io/c/fflush]]</text>
      <sha1>7ui1zltjnmp08csm2elsjxfb65a984p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fgetc</title>
    <ns>0</ns>
    <id>577</id>
    <revision>
      <id>67969</id>
      <parentid>67585</parentid>
      <timestamp>2014-03-10T13:47:12Z</timestamp>
      <contributor>
        <ip>31.0.210.168</ip>
      </contributor>
      <comment>indicators are set on stream passed as arg; not on stdin</comment>
      <text xml:space="preserve" bytes="1038">{{cpp/title | fgetc | getc}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fgetc( std::FILE* stream );
int getc( std::FILE* stream );
}}

Reads the next character from the given input stream. {{c|getc()}} may be implemented as a macro. 

===Parameters===
{{par begin}}
{{par | stream | to read the character from }}
{{par end}}

===Return value===
The obtained character on success or {{lc|EOF}} on failure. 

If the failure has been caused by end of file condition, additionally sets the ''eof'' indicator (see {{lc|std::feof()}}) on {{tt|stream}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|std::ferror()}}) on {{tt|stream}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc gets}}
{{dsc inc | cpp/io/c/dsc fputc}}
{{dsc inc | cpp/io/c/dsc ungetc}}
{{dsc see c | c/io/fgetc | fgetc | getc}}
{{dsc end}}

[[de:cpp/io/c/fgetc]]
[[es:cpp/io/c/fgetc]]
[[fr:cpp/io/c/fgetc]]
[[it:cpp/io/c/fgetc]]
[[ja:cpp/io/c/fgetc]]
[[pt:cpp/io/c/fgetc]]
[[ru:cpp/io/c/fgetc]]
[[zh:cpp/io/c/fgetc]]</text>
      <sha1>a1sy04u8155ije0xuqdtm26i87t9c4q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fgetpos</title>
    <ns>0</ns>
    <id>578</id>
    <revision>
      <id>57767</id>
      <parentid>49732</parentid>
      <timestamp>2013-06-01T06:00:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1050">{{cpp/title | fgetpos}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fgetpos( std::FILE* stream, std::fpos_t* pos );
}}

Obtains the file position indicator and the current parse state (if any) for the file stream {{tt|stream}} and stores them in the object pointed to by {{tt|pos}}. The value stored is only meaningful as the input to {{lc|std::fsetpos}}.

===Parameters===
{{par begin}}
{{par | stream | file stream to examine}}
{{par | pos | pointer to a {{c|fpos_t}} object to store the file position indicator to}}
{{par end}}

===Return value===
{{c|0}} upon success, nonzero value otherwise. Also sets {{lc|errno}} on failure.

===Example===
{{example |
| code=
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc ftell}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc inc | cpp/io/c/dsc fsetpos}}
{{dsc see c | c/io/fgetpos}}
{{dsc end}}

[[de:cpp/io/c/fgetpos]]
[[es:cpp/io/c/fgetpos]]
[[fr:cpp/io/c/fgetpos]]
[[it:cpp/io/c/fgetpos]]
[[ja:cpp/io/c/fgetpos]]
[[pt:cpp/io/c/fgetpos]]
[[ru:cpp/io/c/fgetpos]]
[[zh:cpp/io/c/fgetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fgets</title>
    <ns>0</ns>
    <id>579</id>
    <revision>
      <id>67586</id>
      <parentid>65792</parentid>
      <timestamp>2014-02-12T21:13:50Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1777">{{cpp/title | fgets}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
char* fgets( char* str, int count, std::FILE* stream );
}}

Reads at most {{c|count - 1}} characters from the given file stream and stores them in {{tt|str}}. The produced character string is always null-terminated. Parsing stops if end-of-file occurs or a newline character is found, in which case {{tt|str}} will contain that newline character.

===Parameters===
{{par begin}}
{{par | str | string to read the characters to}}
{{par | count | the length of {{tt|str}}}}
{{par | stream | file stream to read the data from}}
{{par end}}

===Return value===
{{tt|str}} on success, {{lc|NULL}} on failure.

If the failure has been caused by end of file condition, additionally sets the ''eof'' indicator (see {{lc|std::feof()}}) on {{lc|stdin}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|std::ferror()}}) on {{lc|stdin}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;

int main()
{
    std::FILE* tmpf = std::tmpfile();
    std::fputs(&quot;Alan Turing\n&quot;, tmpf);
    std::fputs(&quot;John von Neumann\n&quot;, tmpf);
    std::fputs(&quot;Alonzo Church\n&quot;, tmpf);

    std::rewind(tmpf);
    char buf[8];
    while (std::fgets(buf, sizeof buf, tmpf) != NULL) {
        std::cout &lt;&lt; '&quot;' &lt;&lt; buf &lt;&lt; '&quot;' &lt;&lt; '\n';
    }
}
 | output=
&quot;Alan Tu&quot;
&quot;ring
&quot;
&quot;John vo&quot;
&quot;n Neuma&quot;
&quot;nn
&quot;
&quot;Alonzo &quot;
&quot;Church
&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc gets}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc see c | c/io/fgets}}
{{dsc end}}

[[de:cpp/io/c/fgets]]
[[es:cpp/io/c/fgets]]
[[fr:cpp/io/c/fgets]]
[[it:cpp/io/c/fgets]]
[[ja:cpp/io/c/fgets]]
[[pt:cpp/io/c/fgets]]
[[ru:cpp/io/c/fgets]]
[[zh:cpp/io/c/fgets]]</text>
      <sha1>ahi9m309egxajkfxfet308mepiyhg0g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fgetwc</title>
    <ns>0</ns>
    <id>2638</id>
    <revision>
      <id>67589</id>
      <parentid>62365</parentid>
      <timestamp>2014-02-12T21:22:34Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1029">{{cpp/title | fgetwc }}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
wint_t fgetwc( std::FILE* stream );
}}
{{dcl |
wint_t getwc( std::FILE* stream );
}}
{{dcl end}}

Reads the next wide character from the given input stream. {{c|getwc()}} may be implemented as a macro and may evaluate {{tt|stream}} more than once.

===Parameters===
{{par begin}}
{{par | stream | to read the wide character from }}
{{par end}}

===Return value===
The next wide character from the stream or {{c|WEOF}} if an error has occurred or the end of file has been reached. If an encoding error occurred, {{lc|errno}} is set to {{tt|EILSEQ}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fgetc}}
{{dsc inc | cpp/io/c/dsc fgetws}}
{{dsc inc | cpp/io/c/dsc fputwc}}
{{dsc inc | cpp/io/c/dsc ungetwc}}
{{dsc see c | c/io/fgetwc}}
{{dsc end}}

[[de:cpp/io/c/fgetwc]]
[[es:cpp/io/c/fgetwc]]
[[fr:cpp/io/c/fgetwc]]
[[it:cpp/io/c/fgetwc]]
[[ja:cpp/io/c/fgetwc]]
[[pt:cpp/io/c/fgetwc]]
[[ru:cpp/io/c/fgetwc]]
[[zh:cpp/io/c/fgetwc]]</text>
      <sha1>p0h3buqcowah721tvared7awtooslks</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fgetws</title>
    <ns>0</ns>
    <id>2639</id>
    <revision>
      <id>67600</id>
      <parentid>57774</parentid>
      <timestamp>2014-02-12T21:40:27Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1057">{{cpp/title | fwgets}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
wchar_t* fgetws( wchar_t* str, int count, std::FILE* stream );
}}

Reads at most {{c|count - 1}} wide characters from the given file stream and stores them in {{tt|str}}. The produced wide string is always {{lc|NULL}}-terminated. Parsing stops if end-of-file occurs or a newline wide character is found, in which case {{tt|str}} will contain that wide newline character.

===Parameters===
{{par begin}}
{{par | str | wide string to read the characters to}}
{{par | count | the length of {{tt|str}}}}
{{par | stream | file stream to read the data from}}
{{par end}}

===Return value===
{{tt|str}} on success, {{lc|NULL}} on an error

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fwscanf}}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc see c | c/io/fgetws}}
{{dsc end}}

[[de:cpp/io/c/fgetws]]
[[es:cpp/io/c/fgetws]]
[[fr:cpp/io/c/fgetws]]
[[it:cpp/io/c/fgetws]]
[[ja:cpp/io/c/fgetws]]
[[pt:cpp/io/c/fgetws]]
[[ru:cpp/io/c/fgetws]]
[[zh:cpp/io/c/fgetws]]</text>
      <sha1>g0lnbgjjliito7oe84m636jynsgmbp7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fopen</title>
    <ns>0</ns>
    <id>580</id>
    <revision>
      <id>72342</id>
      <parentid>72339</parentid>
      <timestamp>2014-08-13T14:23:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note on file naming</comment>
      <text xml:space="preserve" bytes="1711">{{cpp/title | fopen}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
std::FILE* fopen( const char* filename, const char* mode );
}}

Opens a file indicated by {{tt|filename}} and returns a file stream associated with that file. {{tt|mode}} is used to determine the file access mode. 

===Parameters===
{{par begin}}
{{par | filename | file name to associate the file stream to}}
{{par | mode | null-terminated character string determining file access mode

{{cpp/io/c/file access flags}}}}
{{par end}}

===Return value===
If successful, returns a pointer to the object that controls the opened file stream, with both eof and error bits cleared. The stream is fully buffered unless {{spar|filename}} refers to an interactive device.

On error, returns a {{lc|null pointer}}. [http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html POSIX requires] that {{lc|errno}} is set in this case.

===Notes===
The format of {{tt|filename}} is implementation-defined, and does not necessarily refer to a file (e.g. it may be the console or another device accessible though filesystem API). On platforms that support them, {{tt|filename}} may include absolute or relative filesystem path.

For portable directory and file naming, see [[cpp/experimental/fs|C++ filesystem TS]] or [http://www.boost.org/doc/libs/1_56_0/libs/filesystem/doc/index.htm boost.filesystem]

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fclose}}
{{dsc inc | cpp/io/c/dsc fflush}}
{{dsc inc | cpp/io/c/dsc freopen}}
{{dsc see c | c/io/fopen}}
{{dsc end}}

[[de:cpp/io/c/fopen]]
[[es:cpp/io/c/fopen]]
[[fr:cpp/io/c/fopen]]
[[it:cpp/io/c/fopen]]
[[ja:cpp/io/c/fopen]]
[[pt:cpp/io/c/fopen]]
[[ru:cpp/io/c/fopen]]
[[zh:cpp/io/c/fopen]]</text>
      <sha1>j7f1o0hpdu23ru1mtsytrsn64d14edh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fprintf</title>
    <ns>0</ns>
    <id>581</id>
    <revision>
      <id>72208</id>
      <parentid>69738</parentid>
      <timestamp>2014-07-23T22:58:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention that POSIX version sets errno</comment>
      <text xml:space="preserve" bytes="4706">{{cpp/title | printf | fprintf | sprintf | snprintf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cstdio}}
{{dcl | num=1 | 
int printf( const char* format, ... );
}}
{{dcl | num=2 |
int fprintf( std::FILE* stream, const char* format, ... );
}}
{{dcl | num=3 |
int sprintf( char* buffer, const char* format, ... );
}}
{{dcl | num=4 | since=c++11 |
int snprintf( char* buffer, std::size_t buf_size, const char* format, ... );
}}
{{dcl end}}

Loads the data from the given locations, converts them to character string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a character string {{tt|buffer}}.
@4@ Writes the results to a character string {{tt|buffer}}. At most {{tt|buf_size}} - 1 characters are written. The resulting character string will be terminated with a null character, unless {{tt|buf_size}} is zero. 

===Parameters===
{{par begin}}
{{par | stream | output file stream to write to}}
{{par | buffer | pointer to a character string to write to}}
{{par | buf_size | up to buf_size - 1 characters may be written, plus the null terminator}}
{{par | format | pointer to a null-terminated multibyte string specifying how to interpret the data.
{{cpp/io/c/printf format}}
}}
{{par | ... | arguments specifying data to print. If any argument is not the type expected by the corresponding conversion specifier, or if there are less arguments than required by {{tt|format}}, the behavior is undefined. If there are more arguments than required by {{tt|format}}, the extraneous arguments are evaluated and ignored}}
{{par end}}

===Return value===
@1-2@ Number of characters written if successful or negative value if an error occurred.

@3@ Number of characters written if successful (not including the terminating null-byte) or negative value if an error occurred.

@4@ Number of characters written if successful (not including the terminating null-byte) or negative value if an error occurred. If the resulting string gets truncated due to {{tt|buf_size}} limit, function returns the total number of characters (not including the terminating null-byte) which would have been written, if the limit was not imposed. 

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fprintf.html POSIX specifies] that {{lc|errno}} is set on error.

===Example===
{{example
 | code=
#include &lt;cstdio&gt;
#include &lt;limits&gt;
#include &lt;cstdint&gt;
#include &lt;cinttypes&gt;

int main()
{
    std::printf(&quot;Strings:\n&quot;);

    const char* s = &quot;Hello&quot;;
    std::printf(&quot;\t.%10s.\n\t.%-10s.\n\t.%*s.\n&quot;, s, s, 10, s);

    std::printf(&quot;Characters:\t%c %%\n&quot;, 65);

    std::printf(&quot;Integers\n&quot;);
    std::printf(&quot;Decimal:\t%i %d %.6i %i %.0i %+i %u\n&quot;, 1, 2, 3, 0, 0, 4, -1);
    std::printf(&quot;Hexadecimal:\t%x %x %X %#x\n&quot;, 5, 10, 10, 6);
    std::printf(&quot;Octal:\t%o %#o %#o\n&quot;, 10, 10, 4);

    std::printf(&quot;Floating point\n&quot;);
    std::printf(&quot;Rounding:\t%f %.0f %.32f\n&quot;, 1.5, 1.5, 1.3);
    std::printf(&quot;Padding:\t%05.2f %.2f %5.2f\n&quot;, 1.5, 1.5, 1.5);
    std::printf(&quot;Scientific:\t%E %e\n&quot;, 1.5, 1.5);
    std::printf(&quot;Hexadecimal:\t%a %A\n&quot;, 1.5, 1.5);
    std::printf(&quot;Special values:\t0/0=%g 1/0=%g\n&quot;, 0./0, 1./0);

    std::printf(&quot;Variable width control:\n&quot;);
    std::printf(&quot;right-justified variable width: '%*c'\n&quot;, 5, 'x');
    int r = std::printf(&quot;left-justified variable width : '%*c'\n&quot;, -5, 'x');
    std::printf(&quot;(the last printf printed %d characters)\n&quot;, r);

    // fixed-width types
    std::uint32_t val = std::numeric_limits&lt;std::uint32_t&gt;::max();
    std::printf(&quot;Largest 32-bit value is %&quot; PRIu32 &quot; or %#&quot; PRIx32 &quot;\n&quot;, val, val);
}
 | output=
Strings:
        .     Hello.
        .Hello     .
        .     Hello.
Characters:     A %
Integers
Decimal:        1 2 000003 0  +4 4294967295
Hexadecimal:    5 a A 0x6
Octal:  12 012 04
Floating point
Rounding:       1.500000 2 1.30000000000000004440892098500626
Padding:        01.50 1.50  1.50
Scientific:     1.500000E+00 1.500000e+00
Hexadecimal:    0x1.8p+0 0X1.8P+0
Special values: 0/0=nan 1/0=inf
Variable width control:
right-justified variable width: '    x'
left-justified variable width : 'x    '
(the last printf printed 40 characters)
Largest 32-bit value is 4294967295 or 0xffffffff
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc vfprintf}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc see c | c/io/fprintf | printf | fprintf | sprintf | snprintf}}
{{dsc end}}

[[de:cpp/io/c/fprintf]]
[[es:cpp/io/c/fprintf]]
[[fr:cpp/io/c/fprintf]]
[[it:cpp/io/c/fprintf]]
[[ja:cpp/io/c/fprintf]]
[[pt:cpp/io/c/fprintf]]
[[ru:cpp/io/c/fprintf]]
[[zh:cpp/io/c/fprintf]]</text>
      <sha1>75a1pjebn8kibkfeoi71tsgzjeak9zx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fputc</title>
    <ns>0</ns>
    <id>582</id>
    <revision>
      <id>69825</id>
      <parentid>69817</parentid>
      <timestamp>2014-04-27T12:33:17Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <text xml:space="preserve" bytes="1419">{{cpp/title | fputc | putc}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fputc( int ch, std::FILE* stream );
int putc( int ch, std::FILE* stream );
}}

Writes a character {{tt|ch}} to the given output stream {{tt|stream}}.

Internally, the character is converted to {{c|unsigned char}} just before being written.

In C, {{c|putc()}} may be implemented as a macro, which is disallowed in C++. Therefore calls to {{c|std::fputc()}} and {{c|std::putc()}} always have the same effect.

===Parameters===
{{par begin}}
{{par | ch | character to be written}}
{{par end}}

===Return value===
On success, returns the written character.

On failure, returns {{lc|EOF}} and sets the ''error'' indicator (see {{lc|std::ferror()}}) on {{lc|stream}}.

===Example===
{{example
|code=
#include &lt;cstdio&gt;

int main()
{
    for (char c = 'a'; c != 'z'; c++)
        std::putc(c, stdout);
    std::putc('\n', stdout);

    // putchar return value is not equal to the argument
    int r = 0x1070;
    std::printf(&quot;\n0x%x\n&quot;, r);
    r = std::putchar(r);
    std::printf(&quot;\n0x%x\n&quot;, r);
}
|output=
abcdefghijklmnopqrstuvwxy
0x1070
p
0x70
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc putchar}}
{{dsc see c | c/io/fputc | fputc | putc}}
{{dsc end}}

[[de:cpp/io/c/fputc]]
[[es:cpp/io/c/fputc]]
[[fr:cpp/io/c/fputc]]
[[it:cpp/io/c/fputc]]
[[ja:cpp/io/c/fputc]]
[[pt:cpp/io/c/fputc]]
[[ru:cpp/io/c/fputc]]
[[zh:cpp/io/c/fputc]]</text>
      <sha1>93q6q9wyd1mvav057sd9rz52geodftn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fputs</title>
    <ns>0</ns>
    <id>583</id>
    <revision>
      <id>67588</id>
      <parentid>57782</parentid>
      <timestamp>2014-02-12T21:17:49Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="755">{{cpp/title | fputs}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fputs( const char* str, std::FILE* stream );
}}

Writes given null-terminated character string to the given output stream. 

===Parameters===
{{par begin}}
{{par | str | null-terminated character string to be written}}
{{par | stream | output stream}}
{{par end}}

===Return value===
Non-negative integer on success, {{lc|EOF}} on failure

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc inc | cpp/io/c/dsc puts}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc see c | c/io/fputs}}
{{dsc end}}

[[de:cpp/io/c/fputs]]
[[es:cpp/io/c/fputs]]
[[fr:cpp/io/c/fputs]]
[[it:cpp/io/c/fputs]]
[[ja:cpp/io/c/fputs]]
[[pt:cpp/io/c/fputs]]
[[ru:cpp/io/c/fputs]]
[[zh:cpp/io/c/fputs]]</text>
      <sha1>izvrdc7qmlicuoczm4uh2uy5smuaflh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fputwc</title>
    <ns>0</ns>
    <id>2640</id>
    <revision>
      <id>67601</id>
      <parentid>62366</parentid>
      <timestamp>2014-02-12T21:43:04Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="992">{{cpp/title | fputwc }}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | 
wint_t fputwc( wchar_t ch, std::FILE* stream );
}}
{{dcl |
wint_t putwc( wchar_t ch, std::FILE* stream );
}}
{{dcl end}}

Writes a wide character {{tt|ch}} to the given output stream {{tt|stream}}. {{c|putwc()}} may be implemented as a macro and may evaluate {{tt|stream}} more than once.

===Parameters===
{{par begin}}
{{par | ch | wide character to be written}}
{{par | stream | the output stream}}
{{par end}}

===Return value===
{{tt|ch}} on success, {{c|WEOF}} on failure. If an encoding error occurs, {{lc|errno}} is set to {{tt|EILSEQ}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fputc}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc see c | c/io/fputwc}}
{{dsc end}}

[[de:cpp/io/c/fputwc]]
[[es:cpp/io/c/fputwc]]
[[fr:cpp/io/c/fputwc]]
[[it:cpp/io/c/fputwc]]
[[ja:cpp/io/c/fputwc]]
[[pt:cpp/io/c/fputwc]]
[[ru:cpp/io/c/fputwc]]
[[zh:cpp/io/c/fputwc]]</text>
      <sha1>0e3dlx8uvggc26782aslhe1c7akkl39</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fputws</title>
    <ns>0</ns>
    <id>2641</id>
    <revision>
      <id>67602</id>
      <parentid>57786</parentid>
      <timestamp>2014-02-12T21:44:06Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="796">{{cpp/title | fputws}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
int fputws( const wchar_t* str, std::FILE* stream );
}}

Writes given null-terminated wide string to the given output stream. 

===Parameters===
{{par begin}}
{{par | str | null-terminated wide string to be written}}
{{par | stream | output stream}}
{{par end}}

===Return value===
Non-negative integer on success, {{c|WEOF}} on failure

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc fwprintf}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc inc | cpp/io/c/dsc fgetws}}
{{dsc see c | c/io/fputws}}
{{dsc end}}

[[de:cpp/io/c/fputws]]
[[es:cpp/io/c/fputws]]
[[fr:cpp/io/c/fputws]]
[[it:cpp/io/c/fputws]]
[[ja:cpp/io/c/fputws]]
[[pt:cpp/io/c/fputws]]
[[ru:cpp/io/c/fputws]]
[[zh:cpp/io/c/fputws]]</text>
      <sha1>puawnj4nwfnqn81yni796p18w77va5n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fread</title>
    <ns>0</ns>
    <id>584</id>
    <revision>
      <id>57789</id>
      <parentid>49742</parentid>
      <timestamp>2013-06-01T06:01:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2225">{{cpp/title | fread}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
std::size_t fread( void* buffer, std::size_t size, std::size_t count, std::FILE* stream );
}}

Reads up to {{tt|count}} objects into the array {{tt|buffer}} from the given input stream {{tt|stream}} as if by calling {{lc|std::fgetc}} {{tt|size}} times for each object, and storing the results, in the order obtained, into the successive positions of {{tt|buffer}}, which is reinterpreted as an array of {{c|unsigned char}}. The file position indicator for the stream is advanced by the number of characters read.

If the objects are not {{concept|TriviallyCopyable}}, the behavior is undefined.

If an error occurs, the resulting value of the file position indicator for the stream is
indeterminate. If a partial element is read, its value is indeterminate

===Parameters===
{{par begin}}
{{par | buffer | pointer to the first object in the array to be read}}
{{par | size | size of each object in bytes}}
{{par | count | the number of the objects to be read}}
{{par end}}

===Return value===
Number of objects read successfully, which may be less than {{tt|count}} if an error or end-of-file condition occurs. 

If {{tt|size}} or {{tt|count}} is zero, {{tt|fread}} returns zero and performs no other action.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;fstream&gt;
#include &lt;vector&gt;
int main()
{
    // prepare file
    std::ofstream(&quot;test.txt&quot;) &lt;&lt; 1 &lt;&lt; ' ' &lt;&lt; 2 &lt;&lt; '\n';
    std::FILE* f = std::fopen(&quot;test.txt&quot;, &quot;r&quot;);

    std::vector&lt;char&gt; buf(4); // char is trivally copyable
    std::fread(&amp;buf[0], sizeof buf[0], buf.size(), f);

    for(char n : buf)
        std::cout &lt;&lt; n;

    std::vector&lt;std::string&gt; buf2; // string is not trivially copyable
// this would result in undefined behavior
//    std::fread(&amp;buf2[0], sizeof buf2[0], buf2.size(), f);
}
| output=
1 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc inc | cpp/io/c/dsc fwrite}}
{{dsc see c | c/io/fread}}
{{dsc end}}

[[de:cpp/io/c/fread]]
[[es:cpp/io/c/fread]]
[[fr:cpp/io/c/fread]]
[[it:cpp/io/c/fread]]
[[ja:cpp/io/c/fread]]
[[pt:cpp/io/c/fread]]
[[ru:cpp/io/c/fread]]
[[zh:cpp/io/c/fread]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/freopen</title>
    <ns>0</ns>
    <id>585</id>
    <revision>
      <id>70867</id>
      <parentid>67576</parentid>
      <timestamp>2014-05-31T12:56:03Z</timestamp>
      <contributor>
        <ip>89.64.227.30</ip>
      </contributor>
      <comment>Added missing whitespace.</comment>
      <text xml:space="preserve" bytes="1335">{{cpp/title | freopen}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
std::FILE* freopen( const char* filename, const char* mode, std::FILE* stream );
}}

Reassigns an existing file stream {{tt|stream}} to a different file identified by {{tt|filename}} using specified mode. {{tt|mode}} is used to determine the new file access mode. 

===Parameters===
{{par begin}}
{{par | filename | file name to associate the file stream to}}
{{par | mode | null-terminated character string determining new file access mode

{{cpp/io/c/file access flags}}}}
{{par | stream | the file stream to modify}}
{{par end}}

===Return value===
{{tt|stream}} on success, {{lc|NULL}} on failure

===Example===
{{example | The following code redirects {{tt|stdout}} to a file
 | code=
#include &lt;cstdio&gt;

int main()
{
    std::printf(&quot;stdout is printed to console&quot;);
    std::freopen(&quot;redir.txt&quot;, &quot;w&quot;, stdout);
    std::printf(&quot;stdout is redirected to a file&quot;);
    std::fclose(stdout);
}
 | output=
stdout is printed to console
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc inc | cpp/io/c/dsc fclose}}
{{dsc see c | c/io/freopen}}
{{dsc end}}

[[de:cpp/io/c/freopen]]
[[es:cpp/io/c/freopen]]
[[fr:cpp/io/c/freopen]]
[[it:cpp/io/c/freopen]]
[[ja:cpp/io/c/freopen]]
[[pt:cpp/io/c/freopen]]
[[ru:cpp/io/c/freopen]]
[[zh:cpp/io/c/freopen]]</text>
      <sha1>olvsmdqvobzi56foin35xezgcinmdxb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fscanf</title>
    <ns>0</ns>
    <id>586</id>
    <revision>
      <id>67590</id>
      <parentid>57793</parentid>
      <timestamp>2014-02-12T21:24:25Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="2710">{{cpp/title | scanf | fscanf | sscanf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cstdio}}
{{dcl | num=1 |
​int scanf( const char* format, ... );​
}}
{{dcl | num=2 |
int fscanf( std::FILE* stream, const char* format, ... );
}}
{{dcl | num=3 |
int sscanf( const char* buffer, const char* format, ... );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into given locations.

@1@ Reads the data from {{lc|stdin}}
@2@ Reads the data from file stream {{tt|stream}}
@3@ Reads the data from null-terminated character string {{tt|buffer}}

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated character string to read from}}
{{par | format | pointer to a null-terminated character string specifying how to read the input.
{{cpp/io/c/scanf format}}
}}
{{par | ... | receiving arguments}}
{{par end}}

===Return value===
Number of receiving arguments successfully assigned, or {{lc|EOF}} if read failure occurs before the first receiving argument was assigned.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cstdio&gt;

int main()
{
    int i, j;
    float x, y;
    char str1[10], str2[4];
    wchar_t warr[2];

    char input[] = u8&quot;25 54.32E-1 Thompson 56789 0123 56ß水&quot;;

    // parse as follows:
    // an integer, a floating-point value, a word,
    // two-digit integer (digits 5 and 6)
    // a floating-point value (digits 7, 8, 9)
    // an integer which isn't stored anywhere
    // a string of integers (digits 5 and 6)
    // two wide characters, using multibyte to wide conversion

    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    int ret = std::sscanf(input, &quot;%d%f%9s%2d%f%*d %3[0-9]%2lc&quot;,
                     &amp;i, &amp;x, str1, &amp;j, &amp;y, str2, warr);

    std::cout &lt;&lt; &quot;Converted &quot; &lt;&lt; ret &lt;&lt; &quot; fields:\n&quot;
              &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; &quot;\nx = &quot; &lt;&lt; x &lt;&lt; '\n'
              &lt;&lt; &quot;str1 = &quot; &lt;&lt; str1 &lt;&lt; &quot;\nj = &quot; &lt;&lt; j &lt;&lt; '\n'
              &lt;&lt; &quot;y = &quot; &lt;&lt; y &lt;&lt; &quot;\nstr2 = &quot; &lt;&lt; str2 &lt;&lt; '\n'
              &lt;&lt; std::hex &lt;&lt; &quot;warr[0] = U+&quot; &lt;&lt; warr[0]
              &lt;&lt; &quot; warr[1] = U+&quot; &lt;&lt; warr[1] &lt;&lt; '\n';
}
 | output=
Converted 7 fields:
i = 25
x = 5.432
str1 = Thompson
j = 56
y = 789
str2 = 56
warr[0] = U+df warr[1] = U+6c34
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc vfscanf}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc see c | c/io/fscanf | scanf | fscanf | sscanf}}
{{dsc end}}

[[cs:cpp/io/c/fscanf]]
[[de:cpp/io/c/fscanf]]
[[es:cpp/io/c/fscanf]]
[[fr:cpp/io/c/fscanf]]
[[it:cpp/io/c/fscanf]]
[[ja:cpp/io/c/fscanf]]
[[pt:cpp/io/c/fscanf]]
[[ru:cpp/io/c/fscanf]]
[[zh:cpp/io/c/fscanf]]</text>
      <sha1>7onolu3z2tf83yyac6dn6zl51xswpcs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fseek</title>
    <ns>0</ns>
    <id>587</id>
    <revision>
      <id>62309</id>
      <parentid>57794</parentid>
      <timestamp>2013-06-26T04:56:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce</comment>
      <text xml:space="preserve" bytes="1962">{{cpp/title | fseek }}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fseek( std::FILE* stream, long offset, int origin );
}}

Sets the file position indicator for the file stream {{tt|stream}}.

If the {{tt|stream}} is open in binary mode, the new position is exactly {{tt|offset}} bytes measured from the beginning of the file if {{tt|origin}} is {{lc|SEEK_SET}}, from the current file position if {{tt|origin}} is {{lc|SEEK_CUR}}, and from the end of the file if {{tt|origin}} is {{lc|SEEK_END}}. Some binary streams may not support the {{lc|SEEK_END}}.

If the {{tt|stream}} is open in text mode, the only supported values for {{tt|offset}} are zero (which works with any {{tt|origin}}) and a value returned by an earlier call to {{lc|std::ftell}} on a stream associated with the same file (which only works with {{tt|origin}} of {{lc|SEEK_SET}}.

In addition to changing the file position indicator, {{tt|fseek}} undoes the effects of {{lc|std::ungetc}} and clears the end-of-file status, if applicable.

If a read or write error occurs, the error indicator for the stream ({{lc|std::ferror}}) is set and the file position is unaffected.

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par | offset | number of characters to shift the position relative to origin}} 
{{par | origin | position to which {{tt|offset}} is added. It can have one of the following values: {{lc|SEEK_SET}}, {{lc|SEEK_CUR}}, {{lc|SEEK_END}}}} 
{{par end}}

===Return value===
{{c|0}} upon success, nonzero value otherwise.

===Example===
{{example |
| code=
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fsetpos}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc inc | cpp/io/c/dsc ftell}}
{{dsc inc | cpp/io/c/dsc rewind}}
{{dsc see c | c/io/fseek}}
{{dsc end}}

[[de:cpp/io/c/fseek]]
[[es:cpp/io/c/fseek]]
[[fr:cpp/io/c/fseek]]
[[it:cpp/io/c/fseek]]
[[ja:cpp/io/c/fseek]]
[[pt:cpp/io/c/fseek]]
[[ru:cpp/io/c/fseek]]
[[zh:cpp/io/c/fseek]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fsetpos</title>
    <ns>0</ns>
    <id>588</id>
    <revision>
      <id>57797</id>
      <parentid>49746</parentid>
      <timestamp>2013-06-01T06:01:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1237">{{cpp/title | fsetpos}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int fsetpos( std::FILE* stream, const std::fpos_t* pos );
}}

Sets the file position indicator and the multibyte parsing state (if any) for the C file stream {{tt|stream}} according to the value pointed to by {{tt|pos}}. 

Besides establishing new parse state and position, a call to this function undoes the effects of {{lc|std::ungetc}} and clears the end-of-file state, if it is set.

If a read or write error occurs, the error indicator ({{lc|std::ferror}})for the stream is set.

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par | pos | pointer to a {{c|fpos_t}} object obtained from {{lc|std::fgetpos}} called on a stream associated with the same file}}
{{par end}}

===Return value===
{{c|0}} upon success, nonzero value otherwise. Also, sets {{lc|errno}} on failure.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc inc | cpp/io/c/dsc ftell}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc see c | c/io/fsetpos}}
{{dsc end}}

[[de:cpp/io/c/fsetpos]]
[[es:cpp/io/c/fsetpos]]
[[fr:cpp/io/c/fsetpos]]
[[it:cpp/io/c/fsetpos]]
[[ja:cpp/io/c/fsetpos]]
[[pt:cpp/io/c/fsetpos]]
[[ru:cpp/io/c/fsetpos]]
[[zh:cpp/io/c/fsetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/ftell</title>
    <ns>0</ns>
    <id>589</id>
    <revision>
      <id>57798</id>
      <parentid>49747</parentid>
      <timestamp>2013-06-01T06:01:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1165">{{cpp/title | ftell}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
long ftell( std::FILE* stream );
}}

Returns the current value of the file position indicator for the file stream {{tt|stream}}.

If the stream is open in binary mode, the value obtained by this function is the number of bytes from the beginning of the file.

If the stream is open in text mode, the value returned by this function is unspecified and is only meaningful as the input to {{lc|std::fseek}}

===Parameters===
{{par begin}}
{{par | stream | file stream to examine}}
{{par end}}

===Return value===
File position indicator on success or {{c|-1L}} if failure occurs. Also sets {{lc|errno}} on failure.

===Example===
{{example |
| code=
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc inc | cpp/io/c/dsc fsetpos}}
{{dsc inc | cpp/io/basic_istream/dsc tellg}}
{{dsc inc | cpp/io/basic_ostream/dsc tellp}}
{{dsc see c | c/io/ftell}}
{{dsc end}}

[[de:cpp/io/c/ftell]]
[[es:cpp/io/c/ftell]]
[[fr:cpp/io/c/ftell]]
[[it:cpp/io/c/ftell]]
[[ja:cpp/io/c/ftell]]
[[pt:cpp/io/c/ftell]]
[[ru:cpp/io/c/ftell]]
[[zh:cpp/io/c/ftell]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fwide</title>
    <ns>0</ns>
    <id>2936</id>
    <revision>
      <id>67580</id>
      <parentid>57801</parentid>
      <timestamp>2014-02-12T21:06:21Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1045">{{cpp/title | fwide}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
int fwide( std::FILE* stream, int mode );
}}

If {{tt|mode &gt; 0}}, attempts to make {{tt|stream}} wide-oriented. If {{tt|mode &lt; 0}}, attempts to make {{tt|stream}} byte-oriented. If {{c|1=mode==0}}, only queries the current orientation of the stream.

===Parameters===
{{par begin}}
{{par | stream | pointer to the C I/O stream to modify or query}}
{{par | mode | integer value greater than zero to set the stream wide, less than zero to set the stream narrow, or zero to query only }}
{{par end}}

===Return value===
An integer greater than zero if the stream is wide-oriented after this call, less than zero if the stream is byte-oriented after this call, and zero if the stream has no orientation.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fopen}}
{{dsc see c | c/io/fwide}}
{{dsc end}}

[[de:cpp/io/c/fwide]]
[[es:cpp/io/c/fwide]]
[[fr:cpp/io/c/fwide]]
[[it:cpp/io/c/fwide]]
[[ja:cpp/io/c/fwide]]
[[pt:cpp/io/c/fwide]]
[[ru:cpp/io/c/fwide]]
[[zh:cpp/io/c/fwide]]</text>
      <sha1>8rtyi9luzd3re9lvmie3w4f8alqx5ad</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fwprintf</title>
    <ns>0</ns>
    <id>4020</id>
    <revision>
      <id>72437</id>
      <parentid>68695</parentid>
      <timestamp>2014-08-22T02:01:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix size usage in the example</comment>
      <text xml:space="preserve" bytes="2409">{{cpp/title | wprintf | fwprintf | swprintf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | num=1 |
int wprintf( const wchar_t* format, ... );
}}
{{dcl | num=2 |
int fwprintf( std::FILE* stream, const wchar_t* format, ... );
}}
{{dcl | num=3 |
int swprintf( wchar_t* buffer, std::size_t size, const wchar_t* format, ... );
}}
{{dcl end}}

Loads the data from the given locations, converts them to wide string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a wide string {{tt|buffer}}. At most {{c|size-1}} wide characters are written. The resulting wide character string will be terminated with a null character, unless {{tt|size}} is zero.

===Parameters===
{{par begin}}
{{par | stream | output file stream to write to}}
{{par | buffer | pointer to a wide character string to write to}}
{{par | size | up to {{tt|size - 1}} characters may be written, plus the null terminator}}
{{par | format | pointer to a null-terminated wide string specifying how to interpret the data.
{{cpp/io/c/printf format}}
}}
{{par | ... | arguments specifying data to print }}
{{par end}}

===Return value===
Number of wide characters written if successful (not counting the terminating null character) or negative value if an error occurred.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;clocale&gt;
#include &lt;cwchar&gt;

int main()
{
    char narrow_str[] = &quot;z\u00df\u6c34\U0001f34c&quot;;
                    // or &quot;zß水🍌&quot;
                    // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9f\x8d\x8c&quot;;
    wchar_t warr[29]; // the expected string is 28 characters plus 1 null terminator
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);

    std::swprintf(warr, sizeof warr/sizeof *warr,
                  L&quot;Converted from UTF-8: '%s'&quot;, narrow_str);

    std::wcout.imbue(std::locale(&quot;en_US.utf8&quot;));
    std::wcout &lt;&lt; warr &lt;&lt; '\n';
}
 | output=
Converted from UTF-8: 'zß水🍌'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc vfwprintf}}
{{dsc inc | cpp/io/c/dsc fputws}}
{{dsc see c | c/io/fwprintf | wprintf | fwprintf | swprintf}}
{{dsc end}}

[[de:cpp/io/c/fwprintf]]
[[es:cpp/io/c/fwprintf]]
[[fr:cpp/io/c/fwprintf]]
[[it:cpp/io/c/fwprintf]]
[[ja:cpp/io/c/fwprintf]]
[[pt:cpp/io/c/fwprintf]]
[[ru:cpp/io/c/fwprintf]]
[[zh:cpp/io/c/fwprintf]]</text>
      <sha1>as6uk41s3xg8qnqm5wagoidf47ttvf7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fwrite</title>
    <ns>0</ns>
    <id>590</id>
    <revision>
      <id>67573</id>
      <parentid>65937</parentid>
      <timestamp>2014-02-12T20:29:15Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Fixed return type of std::fwrite(); std::size_t instead of int.</comment>
      <text xml:space="preserve" bytes="2187">{{cpp/title | fwrite}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
std::size_t fwrite( const void* buffer, std::size_t size, std::size_t count, std::FILE* stream );
}}

Writes up to {{tt|count}} binary objects from the given array {{tt|buffer}} to the output stream {{tt|stream}}. The objects are written as if by reinterepreting each object as an array of {{c|unsigned char}} and calling {{lc|std::fputc}} {{tt|size}} times for each object to write those {{c|unsigned char}}s into {{tt|stream}}, in order. The file position indicator for the stream is advanced by the number of characters written.

If the objects are not {{concept|TriviallyCopyable}}, the behavior is undefined.

If an error occurs, the resulting value of the file position indicator for the stream is
indeterminate.

===Parameters===
{{par begin}}
{{par | buffer | pointer to the first object object in the array to be written}}
{{par | size | size of each object}}
{{par | count | the number of the objects to be written}}
{{par end}}

===Return value===
Number of objects written successfully, which may be less than {{tt|count}} if an error occurred.

If {{tt|size}} or {{tt|count}} is zero, {{tt|fwrite}} returns zero and performs no other action.

===Example===
{{example|
| code=
#include &lt;cstdio&gt;

int main ()
{
    // write buffer to file
    std::FILE *f1;
    char buffer[] = { 'x' , 'y' , 'z' };
    f1 = std::fopen(&quot;file.bin&quot;, &quot;wb&quot;);
    std::fwrite(buffer, sizeof(char), sizeof(buffer), f1);
    std::fclose(f1);

    // read the same data and print it to the standard output
    std::FILE *f2;
    char rbuf[10];
    f2 = std::fopen(&quot;file.bin&quot;, &quot;rb&quot;);
    const char* res = std::fgets(rbuf, sizeof(rbuf), f2);
    std::fclose(f2);

    if (res) { // points to rbuf on read success, NULL on failure
        std::puts(res);
    }
}
| output=
xyz
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc fread}}
{{dsc see c | c/io/fwrite}}
{{dsc end}}

[[de:cpp/io/c/fwrite]]
[[es:cpp/io/c/fwrite]]
[[fr:cpp/io/c/fwrite]]
[[it:cpp/io/c/fwrite]]
[[ja:cpp/io/c/fwrite]]
[[pt:cpp/io/c/fwrite]]
[[ru:cpp/io/c/fwrite]]
[[zh:cpp/io/c/fwrite]]</text>
      <sha1>rbmj0oiumbn7qmeg5hcjpjzx3yvrnly</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/fwscanf</title>
    <ns>0</ns>
    <id>4023</id>
    <revision>
      <id>67597</id>
      <parentid>62744</parentid>
      <timestamp>2014-02-12T21:36:53Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1492">{{cpp/title | wscanf | fwscanf | swscanf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | num=1 | since=c++11 |
int wscanf( const wchar_t* format, ... );
}}
{{dcl | num=2 | since=c++11 |
int fwscanf( std::FILE* stream, const wchar_t* format, ... );
}}
{{dcl | num=3 | since=c++11 |
int swscanf( const wchar_t* buffer, const wchar_t* format, ... );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into given locations.

@1@ Reads the data from {{lc|stdin}}.
@2@ Reads the data from file stream {{tt|stream}}.
@3@ Reads the data from null-terminated wide string {{tt|buffer}}.

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated wide string to read from}}
{{par | format | pointer to a null-terminated wide string specifying how to read the input. {{todo}}
}}
{{par | ... | receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs before the first receiving argument was assigned.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc vfwscanf}}
{{dsc see c | c/io/fwscanf | wscanf | fwscanf | swscanf}}
{{dsc end}}

[[de:cpp/io/c/fwscanf]]
[[es:cpp/io/c/fwscanf]]
[[fr:cpp/io/c/fwscanf]]
[[it:cpp/io/c/fwscanf]]
[[ja:cpp/io/c/fwscanf]]
[[pt:cpp/io/c/fwscanf]]
[[ru:cpp/io/c/fwscanf]]
[[zh:cpp/io/c/fwscanf]]</text>
      <sha1>b6zvvt2mnikad65sqeva9u8mrm7022l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/getc</title>
    <ns>0</ns>
    <id>3666</id>
    <redirect title="cpp/io/c/fgetc" />
    <revision>
      <id>13757</id>
      <parentid>13756</parentid>
      <timestamp>2011-11-12T12:01:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>syntax</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/io/c/fgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/getchar</title>
    <ns>0</ns>
    <id>591</id>
    <revision>
      <id>65787</id>
      <parentid>57807</parentid>
      <timestamp>2013-10-08T09:24:22Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="826">{{cpp/title| getchar}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int getchar();
}}
Reads the next character from {{lc|stdin}}.

Equivalent to {{c|std::getc(stdin)}}.

===Parameters===
(none)

===Return value===
The obtained character on success or {{lc|EOF}} on failure. 

If the failure has been caused by end of file condition, additionally sets the ''eof'' indicator (see {{lc|feof()}}) on {{lc|stdin}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|ferror()}}) on {{lc|stdin}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fgetc}}
{{dsc see c | c/io/getchar}}
{{dsc end}}

[[de:cpp/io/c/getchar]]
[[es:cpp/io/c/getchar]]
[[fr:cpp/io/c/getchar]]
[[it:cpp/io/c/getchar]]
[[ja:cpp/io/c/getchar]]
[[pt:cpp/io/c/getchar]]
[[ru:cpp/io/c/getchar]]
[[zh:cpp/io/c/getchar]]</text>
      <sha1>igcabmjthmzvgygmcbly61nb7kzcjwz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/gets</title>
    <ns>0</ns>
    <id>592</id>
    <revision>
      <id>68215</id>
      <parentid>65794</parentid>
      <timestamp>2014-03-18T04:31:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>removed in c++14</comment>
      <text xml:space="preserve" bytes="1213">{{cpp/title | gets}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio | until=c++14 |
char* gets( char* str );
}}

Reads {{lc|stdin}} into given character string until a newline character is found or end-of-file occurs.

===Parameters===
{{par begin}}
{{par | str | character string to be written}}
{{par end}}

===Return value===
{{tt|str}} on success, {{lc|NULL}} on failure.

If the failure has been caused by end of file condition, additionally sets the ''eof'' indicator (see {{lc|std::feof()}}) on {{lc|stdin}}. If the failure has been caused by some other error, sets the ''error'' indicator (see {{lc|std::ferror()}}) on {{lc|stdin}}.

===Notes===
The function provides no means to prevent buffer overflow of the destination array, given sufficiently long input string. {{tt|std::gets}} was deprecated in C++11 and removed from C++14.

{{lc|std::fgets}} can be used instead.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc fgets}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc see c | c/io/gets}}
{{dsc end}}

[[de:cpp/io/c/gets]]
[[es:cpp/io/c/gets]]
[[fr:cpp/io/c/gets]]
[[it:cpp/io/c/gets]]
[[ja:cpp/io/c/gets]]
[[pt:cpp/io/c/gets]]
[[ru:cpp/io/c/gets]]
[[zh:cpp/io/c/gets]]</text>
      <sha1>j92c3l6nfiwa4dxe69mwho45bpqp7sk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/getwc</title>
    <ns>0</ns>
    <id>3668</id>
    <redirect title="cpp/io/c/fgetwc" />
    <revision>
      <id>13759</id>
      <timestamp>2011-11-12T12:03:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fgetwc]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/io/c/fgetwc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/getwchar</title>
    <ns>0</ns>
    <id>2642</id>
    <revision>
      <id>62367</id>
      <parentid>57811</parentid>
      <timestamp>2013-06-27T00:58:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="620">{{cpp/title| getwchar}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
wint_t getwchar();
}}
Reads the next wide character from {{lc|stdin}}.

===Parameters===
(none)

===Return value===
The obtained wide character or {{c|WEOF}} if an error has occurred or the end of file reached

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc getchar}}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc see c | c/io/getwchar}}
{{dsc end}}

[[de:cpp/io/c/getwchar]]
[[es:cpp/io/c/getwchar]]
[[fr:cpp/io/c/getwchar]]
[[it:cpp/io/c/getwchar]]
[[ja:cpp/io/c/getwchar]]
[[pt:cpp/io/c/getwchar]]
[[ru:cpp/io/c/getwchar]]
[[zh:cpp/io/c/getwchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/perror</title>
    <ns>0</ns>
    <id>593</id>
    <revision>
      <id>65688</id>
      <parentid>65378</parentid>
      <timestamp>2013-09-26T13:42:21Z</timestamp>
      <contributor>
        <ip>200.14.84.164</ip>
      </contributor>
      <text xml:space="preserve" bytes="1342">{{cpp/title | perror}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
void perror( const char  *s );
}}

Prints a textual description of the error code currently stored in the system variable {{lc|errno}} to {{lc|stderr}}.

The description is formed by concatenating the following components:
* the contents of the null-terminated byte string pointed to by {{tt|s}} (unless {{tt|s}} is a null pointer)
* {{c|&quot;: &quot;}}
* implementation-defined error message describing the error code stored in {{tt|errno}}. This message is identical to the output of {{c|std::strerror(errno)}}.
* {{c|'\n'}}.

===Parameters===
{{par begin}}
{{par | s | pointer to a null-terminated string with explanatory message}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstdio&gt;

int main()
{
    double not_a_number = std::log(-1.0);
    if (errno == EDOM) {
        std::perror(&quot;log(-1) failed&quot;);
    }
}
 | output=
log(-1) failed: Numerical argument out of domain
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc errno}}
{{dsc inc | cpp/string/byte/dsc strerror}}
{{dsc see c | c/io/perror}}
{{dsc end}}

[[de:cpp/io/c/perror]]
[[es:cpp/io/c/perror]]
[[fr:cpp/io/c/perror]]
[[it:cpp/io/c/perror]]
[[ja:cpp/io/c/perror]]
[[pt:cpp/io/c/perror]]
[[ru:cpp/io/c/perror]]
[[zh:cpp/io/c/perror]]</text>
      <sha1>t3wiw1pxvxf5hdul48lt9zqsj4xqgu4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/printf</title>
    <ns>0</ns>
    <id>2461</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>8716</id>
      <timestamp>2011-08-16T07:05:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/putc</title>
    <ns>0</ns>
    <id>3667</id>
    <redirect title="cpp/io/c/fputc" />
    <revision>
      <id>13758</id>
      <timestamp>2011-11-12T12:02:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fputc]]</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/io/c/fputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/putchar</title>
    <ns>0</ns>
    <id>594</id>
    <revision>
      <id>65969</id>
      <parentid>65968</parentid>
      <timestamp>2013-10-16T14:55:21Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="1188">{{cpp/title| putchar}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int putchar( int ch );
}}
Writes a character {{tt|ch}} to {{tt|stdout}}. Internally, the character is converted to {{c|unsigned char}} just before being written.

Equivalent to {{c|putc(ch, stdout)}}.

===Parameters===
{{par begin}}
{{par | ch | character to be written}}
{{par end}}

===Return value===
On success, returns the written character.

On failure, returns {{lc|EOF}} and sets the ''error'' indicator (see {{lc|ferror()}}) on {{lc|stdout}}.

===Example===
{{example
|code=
#include &lt;cstdio&gt;

int main()
{
    for (char c = 'a'; c != 'z'; c++)
        std::putchar(c);
    std::putchar('\n');

    // putchar return value is not equal to the argument
    int r = 0x1070;
    std::printf(&quot;\n0x%x\n&quot;, r);
    r = std::putchar(r);
    std::printf(&quot;\n0x%x\n&quot;, r);
}
|output=
abcdefghijklmnopqrstuvwxy
0x1070
p
0x70
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fputc}}
{{dsc see c | c/io/putchar}}
{{dsc end}}

[[de:cpp/io/c/putchar]]
[[es:cpp/io/c/putchar]]
[[fr:cpp/io/c/putchar]]
[[it:cpp/io/c/putchar]]
[[ja:cpp/io/c/putchar]]
[[pt:cpp/io/c/putchar]]
[[ru:cpp/io/c/putchar]]
[[zh:cpp/io/c/putchar]]</text>
      <sha1>fke065rbi0aaavfswo9fovoqq54ur27</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/puts</title>
    <ns>0</ns>
    <id>595</id>
    <revision>
      <id>65175</id>
      <parentid>57816</parentid>
      <timestamp>2013-09-04T15:08:33Z</timestamp>
      <contributor>
        <ip>109.12.67.237</ip>
      </contributor>
      <comment>added const</comment>
      <text xml:space="preserve" bytes="633">{{cpp/title| puts}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int puts( const char *str );
}}
Writes character string {{tt|str}} and a newline to {{tt|stdout}}

===Parameters===
{{par begin}}
{{par | str | character string to be written}}
{{par end}}

===Return value===
Non-negative number on success or {{lc|EOF}} otherwise

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fputs}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc see c | c/io/puts}}
{{dsc end}}

[[de:cpp/io/c/puts]]
[[es:cpp/io/c/puts]]
[[fr:cpp/io/c/puts]]
[[it:cpp/io/c/puts]]
[[ja:cpp/io/c/puts]]
[[pt:cpp/io/c/puts]]
[[ru:cpp/io/c/puts]]
[[zh:cpp/io/c/puts]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/putwc</title>
    <ns>0</ns>
    <id>3669</id>
    <redirect title="cpp/io/c/fputwc" />
    <revision>
      <id>13760</id>
      <timestamp>2011-11-12T12:03:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fputwc]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/io/c/fputwc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/putwchar</title>
    <ns>0</ns>
    <id>2643</id>
    <revision>
      <id>57819</id>
      <parentid>49758</parentid>
      <timestamp>2013-06-01T06:01:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="648">{{cpp/title| putwchar}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
wint_t putwchar( wchar_t ch );
}}
Writes a wide character {{tt|ch}} to {{tt|stdout}}

===Parameters===
{{par begin}}
{{par | ch | wide character to be written}}
{{par end}}

===Return value===
{{tt|ch}} on success, {{c|WEOF}} on failure.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc putchar}}
{{dsc inc | cpp/io/c/dsc fputwc}}
{{dsc see c | c/io/putwchar}}
{{dsc end}}

[[de:cpp/io/c/putwchar]]
[[es:cpp/io/c/putwchar]]
[[fr:cpp/io/c/putwchar]]
[[it:cpp/io/c/putwchar]]
[[ja:cpp/io/c/putwchar]]
[[pt:cpp/io/c/putwchar]]
[[ru:cpp/io/c/putwchar]]
[[zh:cpp/io/c/putwchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/remove</title>
    <ns>0</ns>
    <id>596</id>
    <revision>
      <id>64919</id>
      <parentid>57820</parentid>
      <timestamp>2013-08-28T07:33:56Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <comment>http://www.open-std.org/JTC1/SC22/WG15/docs/rr/9945-1/9945-1-59.html</comment>
      <text xml:space="preserve" bytes="1177">{{cpp/title | remove}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int remove( const char *fname );
}}

Deletes the file identified by character string pointed to by {{tt|fname}}.

===Parameters===
{{par begin}}
{{par | fname | pointer to a null-terminated string containing the path identifying the file to delete}}
{{par end}}

===Return value===
{{c|0}} upon success or non-zero value on error.

===Notes===
In POSIX the behavior for file types other than regular files is unspecified.

===Example===
{{example
 | p=true
 | code=
#include &lt;cstdio&gt;
#include &lt;iostream&gt;

int main()
{
    const char* file_name = &quot;C:\\file.txt&quot;;
    int ret_code = std::remove(file_name);
    if (ret_code == 0) {
        std::cout &lt;&lt; &quot;File was successfully deleted\n&quot;;
    } else {
        std::cerr &lt;&lt; &quot;Error during the deletion: &quot; &lt;&lt; ret_code &lt;&lt; '\n';
    }
}
 | output=Error during the deletion: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc rename}}
{{dsc see c | c/io/remove}}
{{dsc end}}

[[de:cpp/io/c/remove]]
[[es:cpp/io/c/remove]]
[[fr:cpp/io/c/remove]]
[[it:cpp/io/c/remove]]
[[ja:cpp/io/c/remove]]
[[pt:cpp/io/c/remove]]
[[ru:cpp/io/c/remove]]
[[zh:cpp/io/c/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/rename</title>
    <ns>0</ns>
    <id>597</id>
    <revision>
      <id>57821</id>
      <parentid>49760</parentid>
      <timestamp>2013-06-01T06:01:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="992">{{cpp/title | rename}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int rename( const char *old_filename, const char *new_filename );
}}

Changes the filename of a file. The file is identified by character string pointed to by {{tt|old_filename}}. The new filename is identified by character string pointed to by {{tt|new_filename}}.

===Parameters===
{{par begin}}
{{par | old_filename | pointer to a null-terminated string containing the path identifying the file to rename}}
{{par | new_filename | pointer to a null-terminated string containing the new path of the file}}
{{par end}}

===Return value===
{{c|0}} upon success or non-zero value on error.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc remove}}
{{dsc see c | c/io/rename}}
{{dsc end}}

[[de:cpp/io/c/rename]]
[[es:cpp/io/c/rename]]
[[fr:cpp/io/c/rename]]
[[it:cpp/io/c/rename]]
[[ja:cpp/io/c/rename]]
[[pt:cpp/io/c/rename]]
[[ru:cpp/io/c/rename]]
[[zh:cpp/io/c/rename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/rewind</title>
    <ns>0</ns>
    <id>598</id>
    <revision>
      <id>70168</id>
      <parentid>66019</parentid>
      <timestamp>2014-05-11T05:02:00Z</timestamp>
      <contributor>
        <username>汪育振</username>
        <id>532</id>
      </contributor>
      <text xml:space="preserve" bytes="1350">{{cpp/title | rewind }}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
void rewind( std::FILE* stream );
}}

Moves the file position indicator to the beginning of the given file stream. 

The function is equivalent to {{c|std::fseek(stream, 0, SEEK_SET);}}, except that end-of-file and error indicators are cleared. 

The function drops any effects from previous calls to {{lc|ungetc}}.

===Parameters===
{{par begin}}
{{par | stream | file stream to modify}}
{{par end}}

===Return value===
(none)

===Example===
{{example|
| code=
#include &lt;cstdio&gt;
 
int main()
{
    std::FILE *f;
    char ch;
    char str[20];
 
    f = std::fopen(&quot;file.txt&quot;, &quot;w&quot;);
    for (ch = '0'; ch &lt;= '9'; ch++) {
        std::fputc(ch, f);
    }
    std::fclose(f);
 
 
    std::FILE* f2 = std::fopen(&quot;file.txt&quot;, &quot;r&quot;);
    unsigned int size = std::fread(str, 1, 10, f2);
    std::puts(str);
    std::printf(&quot;\n%u\n&quot;,size);
 
    std::rewind(f2);
    unsigned int size2 = std::fread(str, 1, 10, f2);
    std::puts(str);
    std::printf(&quot;\n%u&quot;,size2);
    std::fclose(f2);
}
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fseek}}
{{dsc see c | c/io/rewind}}
{{dsc end}}

[[de:cpp/io/c/rewind]]
[[es:cpp/io/c/rewind]]
[[fr:cpp/io/c/rewind]]
[[it:cpp/io/c/rewind]]
[[ja:cpp/io/c/rewind]]
[[pt:cpp/io/c/rewind]]
[[ru:cpp/io/c/rewind]]
[[zh:cpp/io/c/rewind]]</text>
      <sha1>29kop0wc1i4dv384dffbcayvevirua3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/scanf</title>
    <ns>0</ns>
    <id>2120</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>4541</id>
      <timestamp>2011-06-20T20:16:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>create redirect</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/setbuf</title>
    <ns>0</ns>
    <id>599</id>
    <revision>
      <id>67582</id>
      <parentid>57825</parentid>
      <timestamp>2014-02-12T21:07:20Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1025">{{cpp/title | setbuf}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
void setbuf( std::FILE* stream, char* buffer );
}}

Sets the internal buffer to use for I/O operations performed on the C stream {{tt|stream}}.

If {{tt|buffer}} is not null, equivalent to {{c|std::setvbuf(stream, buffer, _IOFBF, BUFSIZ)}}

If {{tt|buffer}} is null, equivalent to {{c|std::setvbuf(stream, NULL, _IONBF, 0)}}, which turns off buffering.

===Parameters===
{{par begin}}
{{par | stream | the file stream to set the buffer to.}}
{{par | buffer | pointer to a buffer for the stream to use. If {{lc|NULL}} is supplied, the buffering is turned off. If not null, must be able to hold at least {{tt|BUFSIZ}} characters}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc setvbuf}}
{{dsc see c | c/io/setbuf}}
{{dsc end}}

[[de:cpp/io/c/setbuf]]
[[es:cpp/io/c/setbuf]]
[[fr:cpp/io/c/setbuf]]
[[it:cpp/io/c/setbuf]]
[[ja:cpp/io/c/setbuf]]
[[pt:cpp/io/c/setbuf]]
[[ru:cpp/io/c/setbuf]]
[[zh:cpp/io/c/setbuf]]</text>
      <sha1>szcibis0hkii3w049bz835m8gc9c2aq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/setvbuf</title>
    <ns>0</ns>
    <id>600</id>
    <revision>
      <id>67583</id>
      <parentid>67574</parentid>
      <timestamp>2014-02-12T21:07:51Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1150">{{cpp/title | setvbuf}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int setvbuf( std::FILE* stream, char* buffer, int mode, std::size_t size );
}}

Sets the internal buffer of the given file stream {{tt|stream}}. 

===Parameters===
{{par begin}}
{{par | stream | the file stream to set the buffer to}}
{{par | buffer | pointer to a buffer for the stream to use}}
{{par | mode |2= buffering mode to use. It can be one of the following values:

{{cpp/io/c/buffering modes}}
}}
{{par | size | size of the buffer}}
{{par end}}

===Return value===
{{c|0}} on success or nonzero on failure.

===Notes===
This function may only be used after {{tt|stream}} has been associated with an open file, but before any other operation.

{{tt|buffer}} may be null, in which case this call only resizes the internal buffer.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc setbuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc setbuf}}
{{dsc see c | c/io/setvbuf}}
{{dsc end}}

[[de:cpp/io/c/setvbuf]]
[[es:cpp/io/c/setvbuf]]
[[fr:cpp/io/c/setvbuf]]
[[it:cpp/io/c/setvbuf]]
[[ja:cpp/io/c/setvbuf]]
[[pt:cpp/io/c/setvbuf]]
[[ru:cpp/io/c/setvbuf]]
[[zh:cpp/io/c/setvbuf]]</text>
      <sha1>1yco9oo7dvg7uw9d7rg1pcnixk9uco2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/snprintf</title>
    <ns>0</ns>
    <id>2459</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>8714</id>
      <timestamp>2011-08-16T07:04:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/sprintf</title>
    <ns>0</ns>
    <id>2460</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>8715</id>
      <timestamp>2011-08-16T07:05:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/sscanf</title>
    <ns>0</ns>
    <id>2462</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>8717</id>
      <timestamp>2011-08-16T07:06:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+redirect</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/swprintf</title>
    <ns>0</ns>
    <id>3680</id>
    <redirect title="cpp/io/c/fwprintf" />
    <revision>
      <id>13771</id>
      <timestamp>2011-11-12T12:09:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fwprintf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/fwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/swscanf</title>
    <ns>0</ns>
    <id>3676</id>
    <redirect title="cpp/io/c/fwscanf" />
    <revision>
      <id>13767</id>
      <timestamp>2011-11-12T12:07:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fwscanf]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/io/c/fwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/tmpfile</title>
    <ns>0</ns>
    <id>601</id>
    <revision>
      <id>67596</id>
      <parentid>57829</parentid>
      <timestamp>2014-02-12T21:35:18Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="2206">{{cpp/title | tmpfile}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
std::FILE* tmpfile();
}}

Creates and opens a temporary file with unique auto-generated filename. 

The file is opened as binary file for update (as by {{lc|std::fopen}} with access mode {{tt|&quot;wb+&quot;}}). At least {{lc|TMP_MAX}} files may be opened during the lifetime of a program (this limit may be shared with {{lc|std::tmpnam}} and may be further limited by {{lc|FOPEN_MAX}})

If the program closes the file, e.g. by executing {{lc|std::fclose}}, the file is automatically deleted.

If the program terminates normally (by calling {{lc|std::exit}}, returning from {{c|main}}, etc), all files that were opened by calling {{tt|std::tmpfile}} are also automatically deleted.

If the program terminates abnormally, it is implementation-defined if these temporary files are deleted.

===Parameters===
(none)

===Return value===
The associated file stream or {{lc|NULL}} if an error has occurred

===Notes===
On some implementations (e.g. Linux), this function actually creates, opens, and immediately deletes the file from the file system: as long as an open file descriptor to a deleted file is held by a program, the file exists, but since it was deleted, its name does not appear in any directory, so that no other process can open it. Once the file descriptor is closed, the space occupied by the file is reclaimed by the filesystem.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;

int main()
{
    std::FILE* tmpf = std::tmpfile();
    std::fputs(&quot;Hello, world&quot;, tmpf);
    std::rewind(tmpf);
    char buf[6];
    std::fgets(buf, sizeof buf, tmpf);
    std::cout &lt;&lt; buf &lt;&lt; '\n';

    // Linux-specific method to display the tmpfile name
    std::system(&quot;ls -l /proc/self/fd/3&quot;);
}
 | p=true
 | output=
Hello
lrwx------ 1 user group 64 Jun 27 00:28 /proc/self/fd/3 -&gt; /tmp/tmpfXu58Zi (deleted)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc tmpnam}}
{{dsc see c | c/io/tmpfile}}
{{dsc end}}

[[de:cpp/io/c/tmpfile]]
[[es:cpp/io/c/tmpfile]]
[[fr:cpp/io/c/tmpfile]]
[[it:cpp/io/c/tmpfile]]
[[ja:cpp/io/c/tmpfile]]
[[pt:cpp/io/c/tmpfile]]
[[ru:cpp/io/c/tmpfile]]
[[zh:cpp/io/c/tmpfile]]</text>
      <sha1>661ag2wlcvutarn4y0u9maic0zfz26q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/tmpnam</title>
    <ns>0</ns>
    <id>602</id>
    <revision>
      <id>65064</id>
      <parentid>65063</parentid>
      <timestamp>2013-08-30T15:37:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2448">{{cpp/title | tmpnam}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
char* tmpnam( char* filename );
}}

Creates an unique filename that does not name a currently existing file, and stores it in the character string pointed to by {{tt|filename}}. The function is capable of generating up to {{lc|TMP_MAX}} of unique filenames, but some or all of them may already be in use, and thus not suitable return values. 

{{tt|std::tmpnam}} is not reentrant and thus not thread-safe.

===Parameters===
{{par begin}}
{{par | filename | pointer to the character array capable of holding at least {{lc|L_tmpnam}} bytes, to be used as a result buffer. If {{tt|NULL}} is passed, a pointer to an internal static buffer is returned.}}
{{par end}}

===Return value===
{{tt|filename}} if {{tt|filename}} was not {{lc|NULL}}. Otherwise a pointer to an internal static buffer is returned. If no suitable filename can be generated, {{lc|NULL}} is returned.

===Notes===
Although the names generated by {{tt|std::tmpnam}} are difficult to guess, it is possible that a file with that name is created by another process between the moment {{tt|std::tmpnam}} returns and the moment this program attempts to use the returned name to create a file. The standard function {{lc|std::tmpfile}} and the POSIX function [http://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdtemp.html mkstemp] do not have this problem.

POSIX systems additionally define the similarly named function {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tempnam.html tempnam()]}}, which offers the choice of a directory (which defaults to the optionally defined macro {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/stdio.h.html P_tmpdir])}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;string&gt;

int main()
{
    std::string name1 = std::tmpnam(nullptr);
    std::cout &lt;&lt; &quot;temporary file name: &quot; &lt;&lt; name1 &lt;&lt; '\n';

    char name2[L_tmpnam];
    if (std::tmpnam(name2)) {
        std::cout &lt;&lt; &quot;temporary file name: &quot; &lt;&lt; name2 &lt;&lt; '\n';
    }
}
 | p=true
 | output=
temporary file name: /tmp/fileDjwifs
temporary file name: /tmp/fileEv2bfW
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc tmpfile}}
{{dsc see c | c/io/tmpnam}}
{{dsc end}}

[[de:cpp/io/c/tmpnam]]
[[es:cpp/io/c/tmpnam]]
[[fr:cpp/io/c/tmpnam]]
[[it:cpp/io/c/tmpnam]]
[[ja:cpp/io/c/tmpnam]]
[[pt:cpp/io/c/tmpnam]]
[[ru:cpp/io/c/tmpnam]]
[[zh:cpp/io/c/tmpnam]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/ungetc</title>
    <ns>0</ns>
    <id>603</id>
    <revision>
      <id>63968</id>
      <parentid>57833</parentid>
      <timestamp>2013-08-03T02:05:51Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="732">{{cpp/title| ungetc}}
{{cpp/io/c/navbar}}
{{ddcl | header=cstdio |
int ungetc( int ch, std::FILE *stream );
}}
Puts the character {{tt|ch}} back to the given file stream. 

===Parameters===
{{par begin}}
{{par | ch | character to be put back}}
{{par | stream | file stream to put the character back to}}
{{par end}}

===Return value===
On success {{tt|ch}} is returned.

On failure {{lc|EOF}} is returned and the given stream remains unchanged.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fgetc}}
{{dsc see c | c/io/ungetc}}
{{dsc end}}

[[de:cpp/io/c/ungetc]]
[[es:cpp/io/c/ungetc]]
[[fr:cpp/io/c/ungetc]]
[[it:cpp/io/c/ungetc]]
[[ja:cpp/io/c/ungetc]]
[[pt:cpp/io/c/ungetc]]
[[ru:cpp/io/c/ungetc]]
[[zh:cpp/io/c/ungetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/ungetwc</title>
    <ns>0</ns>
    <id>2644</id>
    <revision>
      <id>67603</id>
      <parentid>62368</parentid>
      <timestamp>2014-02-12T21:45:08Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="847">{{cpp/title| ungetwc}}
{{cpp/io/c/navbar}}
{{ddcl | header=cwchar |
wint_t ungetwc( wint_t ch, std::FILE* stream );
}}
Puts the wide character {{tt|ch}} back to the given file stream. 
Only one wide character pushback is guaranteed.

===Parameters===
{{par begin}}
{{par | ch | wide character to be put back}}
{{par | stream | file stream to put the wide character back to}}
{{par end}}

===Return value===
On success {{tt|ch}} is returned.

On failure {{c|WEOF}} is returned and the given stream remains unchanged.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc ungetc}}
{{dsc inc | cpp/io/c/dsc fgetwc}}
{{dsc see c | c/io/ungetwc}}
{{dsc end}}

[[de:cpp/io/c/ungetwc]]
[[es:cpp/io/c/ungetwc]]
[[fr:cpp/io/c/ungetwc]]
[[it:cpp/io/c/ungetwc]]
[[ja:cpp/io/c/ungetwc]]
[[pt:cpp/io/c/ungetwc]]
[[ru:cpp/io/c/ungetwc]]
[[zh:cpp/io/c/ungetwc]]</text>
      <sha1>czanuj4f7u21qb1f8jx6ut9dhwyjale</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vfprintf</title>
    <ns>0</ns>
    <id>604</id>
    <revision>
      <id>67593</id>
      <parentid>66108</parentid>
      <timestamp>2014-02-12T21:29:30Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="2283">{{cpp/title | vprintf | vfprintf | vsprintf | vsnprintf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cstdio}}
{{dcl | num=1 |
int vprintf( const char* format, va_list vlist );
}}
{{dcl | num=2 |
int vfprintf( std::FILE* stream, const char* format, va_list vlist );
}}
{{dcl | num=3 |
int vsprintf( char* buffer, const char* format, va_list vlist );
}}
{{dcl | num=4 | since=c++11 |
int vsnprintf( char* buffer, std::size_t buf_size, const char* format, va_list vlist );
}}
{{dcl end}}

Loads the data from the locations, defined by {{tt|vlist}}, converts them to character string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a character string {{tt|buffer}}.
@4@ Writes the results to a character string {{tt|buffer}}. At most {{tt|buf_size}} characters are written. The resulting character string will be terminated with a null character, unless {{tt|buf_size}} is zero. 

===Parameters===
{{par begin}}
{{par | stream | output file stream to write to}}
{{par | buffer | pointer to a character string to write to}}
{{par | buf_size | maximum number of characters to write}}
{{par | format | pointer to a null-terminated character string specifying how to interpret the data.
{{cpp/io/c/printf format}}
}}
{{par | vlist | variable argument list containing the data to print }}
{{par end}}

===Return value===
@1-3@ Number of characters written if successful or negative value if an error occurred.

@4@ Number of characters written if successful or negative value if an error occurred. If the resulting string gets truncated due to {{tt|buf_size}} limit, function returns the total number of characters (not including the terminating null-byte) which would have been written, if the limit was not imposed. 

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fprintf}}
{{dsc inc | cpp/io/c/dsc vfscanf}}
{{dsc see c | c/io/vfprintf | vprintf | vfprintf | vsprintf | vsnprintf}}
{{dsc end}}

[[de:cpp/io/c/vfprintf]]
[[es:cpp/io/c/vfprintf]]
[[fr:cpp/io/c/vfprintf]]
[[it:cpp/io/c/vfprintf]]
[[ja:cpp/io/c/vfprintf]]
[[pt:cpp/io/c/vfprintf]]
[[ru:cpp/io/c/vfprintf]]
[[zh:cpp/io/c/vfprintf]]</text>
      <sha1>1d9nlcnfwlkhrs2yeqii2d29zrwrmdl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vfscanf</title>
    <ns>0</ns>
    <id>605</id>
    <revision>
      <id>67591</id>
      <parentid>62746</parentid>
      <timestamp>2014-02-12T21:26:06Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="2332">{{cpp/title | vscanf | vfscanf | vsscanf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cstdio}}
{{dcl | num=1 | since=c++11 |
​int vscanf( const char* format, va_list vlist );​
}}
{{dcl | num=2 | since=c++11 |
int vfscanf( std::FILE* stream, const char* format, va_list vlist );
}}
{{dcl | num=3 | since=c++11 |
int vsscanf( const char* buffer, const char* format, va_list vlist );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into locations defined by {{tt|vlist}}.

@1@ Reads the data from {{lc|stdin}}.
@2@ Reads the data from file stream {{tt|stream}}.
@3@ Reads the data from null-terminated character string {{tt|buffer}}.

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated character string to read from}}
{{par | format | pointer to a null-terminated character string specifying how to read the input.
{{cpp/io/c/scanf format}}
}}
{{par | vlist | variable argument list containing the receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;
#include &lt;cstdarg&gt;
#include &lt;stdexcept&gt;

void checked_sscanf(int count, const char* buf, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    if(std::vsscanf(buf, fmt, ap) != count)
        throw std::runtime_error(&quot;parsing error&quot;);
    va_end(ap);
}

int main()
{
    try {
        int n, m;
        std::cout &lt;&lt; &quot;Parsing '1 2'...&quot;;
        checked_sscanf(2, &quot;1 2&quot;, &quot;%d %d&quot;, &amp;n, &amp;m);
        std::cout &lt;&lt; &quot;success\n&quot;;
        std::cout &lt;&lt; &quot;Parsing '1 a'...&quot;;
        checked_sscanf(2, &quot;1 a&quot;, &quot;%d %d&quot;, &amp;n, &amp;m);
        std::cout &lt;&lt; &quot;success\n&quot;;
    } catch(const std::exception&amp; e)
    {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Parsing '1 2'...success
Parsing '1 a'...parsing error
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fscanf}}
{{dsc inc | cpp/io/c/dsc vfprintf}}
{{dsc see c | c/io/vfscanf | vscanf | vfscanf | vsscanf}}
{{dsc end}}

[[de:cpp/io/c/vfscanf]]
[[es:cpp/io/c/vfscanf]]
[[fr:cpp/io/c/vfscanf]]
[[it:cpp/io/c/vfscanf]]
[[ja:cpp/io/c/vfscanf]]
[[pt:cpp/io/c/vfscanf]]
[[ru:cpp/io/c/vfscanf]]
[[zh:cpp/io/c/vfscanf]]</text>
      <sha1>5kl4ddpx4b7e8n7ddmxlbma906c3191</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vfwprintf</title>
    <ns>0</ns>
    <id>4021</id>
    <revision>
      <id>67599</id>
      <parentid>57839</parentid>
      <timestamp>2014-02-12T21:39:06Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1232">{{cpp/title | vwprintf | vfwprintf | vswprintf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | num=1 |
int vwprintf( const wchar_t* format, va_list vlist );
}}
{{dcl | num=2 |
int vfwprintf( std::FILE* stream, const wchar_t* format, va_list vlist );
}}
{{dcl | num=3 |
int vswprintf( const wchar_t* buffer, std::size_t size, const wchar_t* format, va_list vlist );
}}
{{dcl end}}

Loads the data from locations, defined by {{tt|vlist}},, converts them to wide string equivalents and writes the results to a variety of sinks.

@1@ Writes the results to {{lc|stdout}}.
@2@ Writes the results to a file stream {{tt|stream}}.
@3@ Writes the results to a wide string {{tt|buffer}}.

===Parameters===
{{todo}}

===Return value===
Number of wide characters written if successful or negative value if an error occurred.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fwprintf}}
{{dsc see c | c/io/vfwprintf | vwprintf | vfwprintf | vswprintf}}
{{dsc end}}

[[de:cpp/io/c/vfwprintf]]
[[es:cpp/io/c/vfwprintf]]
[[fr:cpp/io/c/vfwprintf]]
[[it:cpp/io/c/vfwprintf]]
[[ja:cpp/io/c/vfwprintf]]
[[pt:cpp/io/c/vfwprintf]]
[[ru:cpp/io/c/vfwprintf]]
[[zh:cpp/io/c/vfwprintf]]</text>
      <sha1>chy3lqtd07ol9k6jtt52lqqq0y5rnj7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vfwscanf</title>
    <ns>0</ns>
    <id>4022</id>
    <revision>
      <id>67598</id>
      <parentid>62747</parentid>
      <timestamp>2014-02-12T21:38:08Z</timestamp>
      <contributor>
        <username>Edmundv</username>
        <id>2670</id>
      </contributor>
      <comment>Use std namespace for FILE*.</comment>
      <text xml:space="preserve" bytes="1545">{{cpp/title | vwscanf | vfwscanf | vswscanf}}
{{cpp/io/c/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | num=1 | since=c++11 |
int vwscanf( const wchar_t* format, va_list vlist );
}}
{{dcl | num=2 | since=c++11 |
int vfwscanf( std::FILE* stream, const wchar_t* format, va_list vlist );
}}
{{dcl | num=3 | since=c++11 |
int vswscanf( const wchar_t* buffer, const wchar_t* format, va_list vlist );
}}
{{dcl end}}

Reads data from the a variety of sources, interprets it according to {{tt|format}} and stores the results into locations defined by {{tt|vlist}}.

@1@ Reads the data from {{lc|stdin}}
@2@ Reads the data from file stream {{tt|stream}}
@3@ Reads the data from null-terminated wide string {{tt|buffer}}

===Parameters===
{{par begin}}
{{par | stream | input file stream to read from}}
{{par | buffer | pointer to a null-terminated wide string to read from}}
{{par | format | pointer to a null-terminated wide string specifying how to read the input. {{todo}}
}}
{{par | vlist | variable argument list containing the receiving arguments}}
{{par end}}

===Return value===
Number of arguments successfully read, or {{lc|EOF}} if failure occurs.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/c/dsc fwscanf}}
{{dsc see c | c/io/vfwscanf | vwscanf | vfwscanf | vswscanf}}
{{dsc end}}

[[de:cpp/io/c/vfwscanf]]
[[es:cpp/io/c/vfwscanf]]
[[fr:cpp/io/c/vfwscanf]]
[[it:cpp/io/c/vfwscanf]]
[[ja:cpp/io/c/vfwscanf]]
[[pt:cpp/io/c/vfwscanf]]
[[ru:cpp/io/c/vfwscanf]]
[[zh:cpp/io/c/vfwscanf]]</text>
      <sha1>4loy70adhq15k3vlvi9022o43ww8tyt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vprintf</title>
    <ns>0</ns>
    <id>3672</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>13763</id>
      <timestamp>2011-11-12T12:05:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfprintf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vscanf</title>
    <ns>0</ns>
    <id>3670</id>
    <redirect title="cpp/io/c/vfscanf" />
    <revision>
      <id>13761</id>
      <timestamp>2011-11-12T12:04:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfscanf]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/io/c/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vsnprintf</title>
    <ns>0</ns>
    <id>3674</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>13765</id>
      <timestamp>2011-11-12T12:06:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfprintf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vsprintf</title>
    <ns>0</ns>
    <id>3673</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>13764</id>
      <timestamp>2011-11-12T12:05:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfprintf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vsscanf</title>
    <ns>0</ns>
    <id>3671</id>
    <redirect title="cpp/io/c/vfscanf" />
    <revision>
      <id>13762</id>
      <timestamp>2011-11-12T12:04:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfscanf]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/io/c/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vswprintf</title>
    <ns>0</ns>
    <id>3681</id>
    <redirect title="cpp/io/c/vfwprintf" />
    <revision>
      <id>13773</id>
      <parentid>13772</parentid>
      <timestamp>2011-11-12T12:09:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfwprintf]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/io/c/vfwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vswscanf</title>
    <ns>0</ns>
    <id>3677</id>
    <redirect title="cpp/io/c/vfwscanf" />
    <revision>
      <id>13768</id>
      <timestamp>2011-11-12T12:08:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfwscanf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/vfwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vwprintf</title>
    <ns>0</ns>
    <id>3682</id>
    <redirect title="cpp/io/c/vfwprintf" />
    <revision>
      <id>13774</id>
      <timestamp>2011-11-12T12:09:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfwprintf]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/io/c/vfwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/vwscanf</title>
    <ns>0</ns>
    <id>3678</id>
    <redirect title="cpp/io/c/vfwscanf" />
    <revision>
      <id>13769</id>
      <timestamp>2011-11-12T12:08:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/vfwscanf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/vfwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/wprintf</title>
    <ns>0</ns>
    <id>3679</id>
    <redirect title="cpp/io/c/fwprintf" />
    <revision>
      <id>13770</id>
      <timestamp>2011-11-12T12:08:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fwprintf]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/io/c/fwprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/c/wscanf</title>
    <ns>0</ns>
    <id>3675</id>
    <redirect title="cpp/io/c/fwscanf" />
    <revision>
      <id>13766</id>
      <timestamp>2011-11-12T12:07:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/c/fwscanf]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/io/c/fwscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/cerr</title>
    <ns>0</ns>
    <id>4060</id>
    <revision>
      <id>64529</id>
      <parentid>57843</parentid>
      <timestamp>2013-08-19T15:47:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>reword to mention that &lt;iostream&gt; needs to be included to output in static ctors/dtors</comment>
      <text xml:space="preserve" bytes="2434">{{cpp/title|cerr|wcerr}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl header | iostream }}
{{dcl | num=1 | 1=
extern std::ostream cerr;
}}
{{dcl | num=2| 1=
extern std::wostream wcerr;
}}
{{dcl end}}

The global objects {{lc|std::cerr}} and {{lc|std::wcerr}} control output to a stream buffer of implementation-defined type (derived from {{lc|std::streambuf}} and {{lc|std::wstreambuf}}, respectively), associated with the standard C error output stream {{lc|stderr}}.

These objects are guaranteed to be initialized during or before the first time an object of type {{lc|std::ios_base::Init}} is constructed and are available for use in the constructors and destructors of static objects (as long as {{tt|&lt;iostream&gt;}} is included).

Unless {{c|sync_with_stdio(false)}} has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted output.

Once initialized, {{c|1=(std::cerr.flags() &amp; unitbuf) != 0}} (same for {{tt|wcerr}}) meaning that any output sent to these stream objects is immediately flushed to the OS (via {{lc|std::basic_ostream::sentry}}'s destructor).

In addition, {{c|std::cerr.tie()}} returns {{c|&amp;std::cout}} (same for {{tt|wcerr}} and {{tt|wcout}}), meaning that any output operation on {{lc|std::cerr}} first executes {{c|std::cout.flush()}} (via {{lc|std::basic_ostream::sentry}}'s constructor) {{mark since c++11}}

===Example===
{{example
 | output to stderr via cerr flushes out the pending output on cout, while output to stderr via clog does not
 | code=
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;chrono&gt;
void f()
{
    std::cout &lt;&lt; &quot;Output from thread...&quot;;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout &lt;&lt; &quot;...thread calls flush()&quot; &lt;&lt; std::endl;
}

int main()
{
    std::thread t1(f);
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::clog &lt;&lt; &quot;This output from main is not tie()'d to cout\n&quot;;
    std::cerr &lt;&lt; &quot;This output is tie()'d to cout\n&quot;;
    t1.join();
}
 | output=
This output from main is not tie()'d to cout
Output from thread...This output is tie()'d to cout
...thread calls flush()
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc inc | cpp/io/dsc clog}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc end}}

[[de:cpp/io/cerr]]
[[es:cpp/io/cerr]]
[[fr:cpp/io/cerr]]
[[it:cpp/io/cerr]]
[[ja:cpp/io/cerr]]
[[pt:cpp/io/cerr]]
[[ru:cpp/io/cerr]]
[[zh:cpp/io/cerr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/cin</title>
    <ns>0</ns>
    <id>3761</id>
    <revision>
      <id>57844</id>
      <parentid>49773</parentid>
      <timestamp>2013-06-01T06:02:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1696">{{cpp/title|cin|wcin}}
{{cpp/io/basic_istream/navbar}}
{{dcl begin}}
{{dcl header | iostream}}
{{dcl | num=1 | 1=
extern std::istream cin;
}}
{{dcl | num=2| 1=
extern std::wistream wcin;
}}
{{dcl end}}

The global objects {{lc|std::cin}} and {{lc|std::wcin}} control input from a stream buffer of implementation-defined type (derived from {{lc|std::streambuf}}), associated with the standard C input stream {{lc|stdin}}.

These objects are guaranteed to be constructed before the first constructor of a static object is called and they are guaranteed to outlive the last destructor of a static object, so that it is always possible to read from {{lc|std::cin}} in user code.

Unless {{c|sync_with_stdio(false)}} has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted input.

Once {{lc|std::cin}} is constructed, {{c|std::cin.tie()}} returns {{c|&amp;std::cout}}, and likewise, {{c|std::wcin.tie()}} returns {{c|&amp;std::wcout}}. This means that any formatted input operation on {{lc|std::cin}} forces a call to {{c|std::cout.flush()}} if any characters are pending for output.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
struct Foo {
    int n;
    Foo() {
       std::cout &lt;&lt; &quot;Enter n: &quot;; // no flush needed
       std::cin &gt;&gt; n;
    }
};
Foo f; // static object
int main()
{
    std::cout &lt;&lt; &quot;f.n is &quot; &lt;&lt; f.n &lt;&lt; '\n';
}
 | input=
10
 | output=
Enter n: 10
f.n is 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc end}}

[[de:cpp/io/cin]]
[[es:cpp/io/cin]]
[[fr:cpp/io/cin]]
[[it:cpp/io/cin]]
[[ja:cpp/io/cin]]
[[pt:cpp/io/cin]]
[[ru:cpp/io/cin]]
[[zh:cpp/io/cin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/clog</title>
    <ns>0</ns>
    <id>4274</id>
    <revision>
      <id>64531</id>
      <parentid>57847</parentid>
      <timestamp>2013-08-19T15:48:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>reword to mention that &lt;iostream&gt; needs to be included to output in static ctors/dtors</comment>
      <text xml:space="preserve" bytes="1634">{{cpp/title|clog|wclog}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl header | iostream }}
{{dcl | num=1 | 1=
extern std::ostream clog;
}}
{{dcl | num=2| 1=
extern std::wostream wclog;
}}
{{dcl end}}

The global objects {{lc|std::clog}} and {{lc|std::wclog}} control output to a stream buffer of implementation-defined type (derived from {{lc|std::streambuf}}), associated with the standard C output stream {{lc|stderr}}, but, unlike {{lc|std::cerr}}/{{lc|std::wcerr}}, these streams are not automatically flushed and not automatically tie()'d with cout.

These objects are guaranteed to be initialized during or before the first time an object of type {{lc|std::ios_base::Init}} is constructed and are available for use in the constructors and destructors of static objects (as long as {{tt|&lt;iostream&gt;}} is included).

Unless {{c|sync_with_stdio(false)}} has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted output.

===Example===
{{example
 | code=
#include &lt;iostream&gt;

struct Foo {
    int n;
    Foo() {
       std::clog &lt;&lt; &quot;static constructor\n&quot;;
    }
    ~Foo() {
       std::clog &lt;&lt; &quot;static destructor\n&quot;;
    }
};

Foo f; // static object

int main()
{
    std::clog &lt;&lt; &quot;main function\n&quot;;
}
 | output=
static constructor
main function
static destructor
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc inc | cpp/io/dsc cerr}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc end}}

[[de:cpp/io/clog]]
[[es:cpp/io/clog]]
[[fr:cpp/io/clog]]
[[it:cpp/io/clog]]
[[ja:cpp/io/clog]]
[[pt:cpp/io/clog]]
[[ru:cpp/io/clog]]
[[zh:cpp/io/clog]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/cout</title>
    <ns>0</ns>
    <id>4032</id>
    <revision>
      <id>64530</id>
      <parentid>57848</parentid>
      <timestamp>2013-08-19T15:48:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>reword to mention that &lt;iostream&gt; needs to be included to output in static ctors/dtors</comment>
      <text xml:space="preserve" bytes="2047">{{cpp/title|cout|wcout}}
{{cpp/io/basic_ostream/navbar}}
{{dcl begin}}
{{dcl header | iostream }}
{{dcl | num=1 | 1=
extern std::ostream cout;
}}
{{dcl | num=2| 1=
extern std::wostream wcout;
}}
{{dcl end}}

The global objects {{lc|std::cout}} and {{lc|std::wcout}} control output to a stream buffer of implementation-defined type (derived from {{lc|std::streambuf}}), associated with the standard C output stream {{lc|stdout}}.

These objects are guaranteed to be initialized during or before the first time an object of type {{lc|std::ios_base::Init}} is constructed and are available for use in the constructors and destructors of static objects (as long as {{tt|&lt;iostream&gt;}} is included).

Unless {{c|sync_with_stdio(false)}} has been issued, it is safe to concurrently access these objects from multiple threads for both formatted and unformatted output.

Once initialized, {{lc|std::cout}} is tie()'d to {{lc|std::cin}} and {{lc|std::wcout}} is tie()'d to {{lc|std::wcin}}, meaning that any input operation on {{lc|std::cin}} executes {{c|std::cout.flush()}} (via {{lc|std::basic_istream::sentry}}'s constructor).

Once initialized, {{lc|std::cout}} is also tie()'d to {{lc|std::cerr}} and {{lc|std::wcout}} is tie()'d to {{lc|std::wcerr}}, meaning that any output operation on {{lc|std::cerr}} executes {{c|std::cout.flush()}} (via {{lc|std::basic_ostream::sentry}}'s constructor) {{mark since c++11}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
struct Foo {
    int n;
    Foo() {
       std::cout &lt;&lt; &quot;static constructor\n&quot;;
    }
    ~Foo() {
       std::cout &lt;&lt; &quot;static destructor\n&quot;;
    }
};
Foo f; // static object
int main()
{
    std::cout &lt;&lt; &quot;main function\n&quot;;
}
 | output=
static constructor
main function
static destructor
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc inc | cpp/io/dsc clog}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc end}}

[[de:cpp/io/cout]]
[[es:cpp/io/cout]]
[[fr:cpp/io/cout]]
[[it:cpp/io/cout]]
[[ja:cpp/io/cout]]
[[pt:cpp/io/cout]]
[[ru:cpp/io/cout]]
[[zh:cpp/io/cout]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/fpos</title>
    <ns>0</ns>
    <id>3744</id>
    <revision>
      <id>72076</id>
      <parentid>57851</parentid>
      <timestamp>2014-07-12T05:45:44Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>todo</comment>
      <text xml:space="preserve" bytes="2851">{{cpp/title | fpos}}
{{cpp/io/navbar}}
{{dcl begin}}
{{dcl header | ios}}
{{dcl | 1=
template&lt; class State &gt;
class fpos;
}}
{{dcl end}}

Specializations of the class template {{lc|std::fpos}} identify absolute positions in a stream or in a file. Each object of type {{tt|fpos}} holds the byte position in the stream (typically as a private member of type {{lc|std::streamoff}}) and the current shift state, a value of type {{tt|State}} (typically {{lc|std::mbstate_t}}).

The following specializations of {{lc|std::fpos}} are provided: 

{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char&gt;::state_type&gt;}}}}&lt;!--
I didn't find &lt;iosfwd&gt;/&lt;ios&gt; declares or defines u16streampos &amp; u32streampos
{{dsc | {{tt|u16streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char16_t&gt;::state_type&gt;}}}}
{{dsc | {{tt|u32streampos}} | {{c|std::fpos&lt;std::char_traits&lt;char32_t&gt;::state_type&gt;}}}}
--&gt;{{dsc | {{tt|wstreampos}} | {{c|std::fpos&lt;std::char_traits&lt;wchar_t&gt;::state_type&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/io/fpos/state | gets/sets the value of the shift state}}
{{dsc end}}

In addition, the following member functions and operators must be provided, although it's unspecified if they are members or non-member.

* A constructor that accepts an argument of type {{c|int}}.

* A constructor that accepts an argument of type {{lc|std::streamoff}}. This constructor must also accept the special value {{c|std::streamoff(-1)}}: the {{tt|std::fpos}} constructed in this manner is returned by some stream operations to indicate errors.

* A conversion operator that converts {{tt|fpos}} to {{lc|std::streamoff}} with the value equal to the offset from {{tt|std::fpos(0)}}.

* {{c|1=operator==}} that compares two objects of type {{tt|std::fpos}} and returns a value of type convertible to {{c|bool}}

* {{c|1=operator!=}} that compares two objects of type {{tt|std::fpos}} and returns a value of type convertible to {{c|bool}}

* {{c|operator+}} and {{c|1=operator+=}} which can add {{lc|std::streamoff}} to {{tt|std::fpos}}

* {{c|operator-}} and {{c|1=operator-=}} which can subtract {{lc|std::streamoff}} from an {{tt|std::fpos}}

* {{c|operator-}} which can subtract two objects of type {{tt|std::fpos}} producing an {{lc|std::streamoff}}

{{todo|What's the relationship between std::fpos and [[cpp/concept/pos_type]]?}}
===See also===
{{dsc begin}}
{{dsc typedef | cpp/io/streamoff | represents relative file/stream position (offset from fpos), sufficient to represent any file size }}
{{dsc inc | cpp/io/basic_ostream/dsc tellp}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp}}
{{dsc inc | cpp/io/c/dsc fgetpos}}
{{dsc end}}

[[de:cpp/io/fpos]]
[[es:cpp/io/fpos]]
[[fr:cpp/io/fpos]]
[[it:cpp/io/fpos]]
[[ja:cpp/io/fpos]]
[[pt:cpp/io/fpos]]
[[ru:cpp/io/fpos]]
[[zh:cpp/io/fpos]]</text>
      <sha1>9zuunz03bfjrrukc1f6sh4c9c58cv76</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/fpos/state</title>
    <ns>0</ns>
    <id>9651</id>
    <revision>
      <id>62370</id>
      <parentid>62369</parentid>
      <timestamp>2013-06-27T01:00:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1017">{{cpp/io/fpos/title | state}}
{{cpp/io/fpos/navbar}}

{{dcl begin}}
{{dcl | num=1 |
State state() const;
}}
{{dcl | num=2 |
void state( State st );
}}
{{dcl end}}

Manages the file position state.

@1@ Returns the value of the file position state
@2@ Replaces the file position state with the value of {{tt|st}}.

For the specializations of {{lc|std::fpos}} that are used in the standard library, {{tt|State}} is always {{lc|std::mbstate_t}}

===Parameters===
{{par begin}}
{{par | st | new value for the state}}
{{par end}}

===Return value===
@1@ the current value of the fpos state

@2@ (none)

===Example===
{{example|
|code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;cwchar&gt;

int main()
{
    std::istringstream s(&quot;test&quot;);
    std::mbstate_t st = s.tellg().state();

    if(std::mbsinit(&amp;st))
        std::cout &lt;&lt; &quot;The stream is in the initial shift state\n&quot;;
}
|output=
The stream is in the initial shift state
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbstate_t}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/io errc</title>
    <ns>0</ns>
    <id>4788</id>
    <revision>
      <id>62748</id>
      <parentid>61377</parentid>
      <timestamp>2013-07-01T23:35:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1809">{{cpp/title|io_errc}}
{{cpp/io/io_errc/navbar}}
{{dcl begin}}
{{dcl header | ios}}
{{dcl | since=c++11 | 1=
enum class io_errc;
}}
{{dcl end}}

The scoped enumeration {{tt|std::io_errc}} defines the error codes reported by I/O streams in {{lc|std::ios_base::failure}} exception objects. Only one error code ({{tt|std::io_errc::stream}}) is required, although the implementation may define additional error codes. Because the appropriate specialization of std::is_error_code_enum is provided, values of type {{tt|std::io_errc}} are implicitly convertible to {{lc|std::error_code}}.

===Member constants===
{{dsc begin}}
{{dsc hitem | Enumeration constant | Value}}
{{dsc | {{tt|stream}} | {{c|1}} }}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/io/io_errc/dsc make_error_code}}
{{dsc inc | cpp/io/io_errc/dsc make_error_condition}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/io/io_errc/dsc is_error_code_enum}}
{{dsc end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
int main()
{
    std::ifstream f(&quot;doesn't exist&quot;);
    try {
        f.exceptions(f.failbit);
    } catch (const std::ios_base::failure&amp; e) {
        std::cout &lt;&lt; &quot;Caught an ios_base::failure.\n&quot;;
        if(e.code() == std::io_errc::stream)
            std::cout &lt;&lt; &quot;The error code is std::io_errc::stream\n&quot;;
    }
}
 | output=
Caught an ios_base::failure.
The error code is std::io_errc::stream
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/io/ios_base/dsc failure | mem=std::ios_base}}
{{dsc end}}

[[de:cpp/io/io errc]]
[[es:cpp/io/io errc]]
[[fr:cpp/io/io errc]]
[[it:cpp/io/io errc]]
[[ja:cpp/io/io errc]]
[[pt:cpp/io/io errc]]
[[ru:cpp/io/io errc]]
[[zh:cpp/io/io errc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/io errc/is error code enum</title>
    <ns>0</ns>
    <id>4804</id>
    <revision>
      <id>62749</id>
      <parentid>61347</parentid>
      <timestamp>2013-07-01T23:35:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1693">{{cpp/title|is_error_code_enum&lt;small&gt;&lt;std::io_errc&gt;&lt;/small&gt;}}
{{cpp/io/io_errc/navbar}}
{{dcl begin}}
{{dcl header | ios}}
{{dcl | since=c++11 |
template&lt; &gt;
struct is_error_code_enum&lt;std::io_errc&gt; : public std::true_type { };
}}
{{dcl end}}

This specialization of {{lc|std::is_error_code_enum}} informs other library components that values of type {{lc|std::io_errc}} are enumerations that hold error codes, which makes them implicitly convertible and assignable to objects of type {{lc|std::error_code}}.

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===Example===
{{example
 | The comparison between {{c|e.code()}} and {{lc|std::io_errc::stream}} compiles because {{c|std::is_error_code_enum&lt;std::io_errc&gt;::value {{==}} true}}
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
int main()
{
    std::ifstream f(&quot;doesn't exist&quot;);
    try {
        f.exceptions(f.failbit);
    } catch (const std::ios_base::failure&amp; e) {
        std::cout &lt;&lt; &quot;Caught an ios_base::failure.\n&quot;;
        if(e.code() == std::io_errc::stream)
            std::cout &lt;&lt; &quot;The error code is std::io_errc::stream\n&quot;;
    }
}
 | output=
Caught an ios_base::failure.
The error code is std::io_errc::stream
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc is_error_code_enum}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc end}}

[[de:cpp/io/io errc/is error code enum]]
[[es:cpp/io/io errc/is error code enum]]
[[fr:cpp/io/io errc/is error code enum]]
[[it:cpp/io/io errc/is error code enum]]
[[ja:cpp/io/io errc/is error code enum]]
[[pt:cpp/io/io errc/is error code enum]]
[[ru:cpp/io/io errc/is error code enum]]
[[zh:cpp/io/io errc/is error code enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/io errc/make error code</title>
    <ns>0</ns>
    <id>4805</id>
    <revision>
      <id>66205</id>
      <parentid>63324</parentid>
      <timestamp>2013-11-09T22:43:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 (noexcept, implemented that way in every C++11 anyway)</comment>
      <text xml:space="preserve" bytes="1489">{{cpp/title|make_error_code{{dsc small|(std::io_errc)}}}}
{{cpp/io/io_errc/navbar}}
{{ddcl | header=ios | since=c++11 |
std::error_code make_error_code( std::io_errc e );
}}

Constructs an {{lc|std::error_code}} object from a value of type {{lc|std::io_errc}} as if by {{c|return std::error_code(static_cast&lt;int&gt;(e), std::iostream_category())}}. This function is called by the constructor of {{lc|std::error_code}} when given an {{lc|std::io_errc}} argument.

===Parameters===
{{par begin}}
{{par | e | error code number}}
{{par end}}

===Return value===
A value of type {{lc|std::error_code}} that holds the error code number from {{tt|e}} associated with the error category {{c|&quot;iostream&quot;}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;
int main()
{
    std::error_code ec = std::make_error_code(std::io_errc::stream);
    std::cout &lt;&lt; &quot;Error code from io_errc::stream has category &quot;
              &lt;&lt; ec.category().name() &lt;&lt; '\n';
}
 | output=
Error code from io_errc::stream has category iostream
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc end}}

[[de:cpp/io/io errc/make error code]]
[[es:cpp/io/io errc/make error code]]
[[fr:cpp/io/io errc/make error code]]
[[it:cpp/io/io errc/make error code]]
[[ja:cpp/io/io errc/make error code]]
[[pt:cpp/io/io errc/make error code]]
[[ru:cpp/io/io errc/make error code]]
[[zh:cpp/io/io errc/make error code]]</text>
      <sha1>sds1anea7jxud4blq4str80vpqygyxw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/io errc/make error condition</title>
    <ns>0</ns>
    <id>4806</id>
    <revision>
      <id>69156</id>
      <parentid>66206</parentid>
      <timestamp>2014-03-28T17:39:10Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1556">{{cpp/title|make_error_condition{{dsc small|(std::io_errc)}}}}
{{cpp/io/io_errc/navbar}}
{{ddcl | header=ios | since=c++11 |
std::error_condition make_error_condition( std::io_errc e );
}}

Constructs an {{lc|std::error_condition}} object from a value of type {{lc|std::io_errc}} as if by {{c|return std::error_condition(static_cast&lt;int&gt;(e), std::iostream_category())}}.

===Parameters===
{{par begin}}
{{par | e | error code number}}
{{par end}}

===Return value===
A value of type {{lc|std::error_condition}} that holds the error code number from {{tt|e}} associated with the error category {{c|&quot;iostream&quot;}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;system_error&gt;
#include &lt;string&gt;

int main()
{
    std::error_condition ec  = std::make_error_condition(std::io_errc::stream);
    std::cout &lt;&lt; &quot;error condition for io_errc::stream has value &quot; &lt;&lt; ec.value()
              &lt;&lt; &quot;\nand message \&quot;&quot; &lt;&lt; ec.message() &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
error condition for io_errc::stream has value 1
and message &quot;unspecified iostream_category error&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc end}}

[[de:cpp/io/io errc/make error condition]]
[[es:cpp/io/io errc/make error condition]]
[[fr:cpp/io/io errc/make error condition]]
[[it:cpp/io/io errc/make error condition]]
[[ja:cpp/io/io errc/make error condition]]
[[pt:cpp/io/io errc/make error condition]]
[[ru:cpp/io/io errc/make error condition]]
[[zh:cpp/io/io errc/make error condition]]</text>
      <sha1>7g6lzhania9bfb6pm3ubu2qbqe5li6d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base</title>
    <ns>0</ns>
    <id>606</id>
    <revision>
      <id>57861</id>
      <parentid>49782</parentid>
      <timestamp>2013-06-01T06:02:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3193">{{cpp/title|ios_base}}
{{cpp/io/ios_base/navbar}}
{{ddcl | header=ios |
class ios_base;
}}

The class {{tt|ios_base}} is a multipurpose class that serves as the base class for all I/O stream classes. It maintains several kinds of data:

@1@ state information: stream status flags
@2@ control information: flags that control formatting of both input and output sequences and the imbued locale
@3@ private storage: indexed extensible data structure that allows both {{c|long}} and {{c|void*}} members, which may be implemented as two arbitrary-length arrays or a single array of two-element structs or another container.
@4@ callbacks: arbitrary number of user-defined functions to be called from imbue(), copyfmt(), and ~ios_base()

Typical implementation holds member constants corresponding to all values of fmtflags, iostate, openmode, and seekdir shown below, member variables to maintain current precision, width, and formatting flags, the exception mask, the buffer error state, a resizeable container holding the callbacks, the currently imbued locale, the private storage, and a static integer variable for xalloc().

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc constructor}}
{{dsc inc | cpp/io/ios_base/dsc destructor}}

{{dsc h2 | Formatting}}
{{dsc inc | cpp/io/ios_base/dsc flags}}
{{dsc inc | cpp/io/ios_base/dsc setf}}
{{dsc inc | cpp/io/ios_base/dsc unsetf}}
{{dsc inc | cpp/io/ios_base/dsc precision}}
{{dsc inc | cpp/io/ios_base/dsc width}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/ios_base/dsc imbue}}
{{dsc inc | cpp/io/ios_base/dsc getloc}}

{{dsc h2 | Internal extensible array}}
{{dsc inc | cpp/io/ios_base/dsc xalloc}}
{{dsc inc | cpp/io/ios_base/dsc iword}}
{{dsc inc | cpp/io/ios_base/dsc pword}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/ios_base/dsc register_callback}}
{{dsc inc | cpp/io/ios_base/dsc sync_with_stdio}}

{{dsc h1 | Member classes}}
{{dsc inc | cpp/io/ios_base/dsc failure}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc end}}

{{dsc begin}}
{{dsc h1 | Member types and constants}}
{{dsc hitem | Type | Explanation}}
{{dsc inc | cpp/io/ios_base/dsc openmode}}
{{dsc inc | cpp/io/ios_base/dsc fmtflags}}
{{dsc inc | cpp/io/ios_base/dsc iostate}}
{{dsc inc | cpp/io/ios_base/dsc seekdir}}
{{dsc inc | cpp/io/ios_base/dsc event}}
{{dsc inc | cpp/io/ios_base/dsc event_callback}}
{{dsc h2 | Deprecated member types }}
{{dsc hitem | Type | Explanation}}
{{dsc | {{tt|io_state}}{{mark deprecated}} | integer type that may be used like {{tt|iostate}}}}
{{dsc | {{tt|open_mode}}{{mark deprecated}} | integer type that may be used like {{tt|openmode}}}}
{{dsc | {{tt|seek_dir}}{{mark deprecated}} | integer type that may be used like {{tt|seekdir}}}}
{{dsc | {{tt|streamoff}}{{mark deprecated}} | unspecified type that may be used like {{tt|off_type}}, not necessarily {{lc|std::streamoff}}}}
{{dsc | {{tt|streampos}}{{mark deprecated}} | unspecified type that may be used like {{tt|pos_type}}, not necessarily {{lc|std::streampos}}}}
{{dsc end}}

[[de:cpp/io/ios base]]
[[es:cpp/io/ios base]]
[[fr:cpp/io/ios base]]
[[it:cpp/io/ios base]]
[[ja:cpp/io/ios base]]
[[pt:cpp/io/ios base]]
[[ru:cpp/io/ios base]]
[[zh:cpp/io/ios base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/Init</title>
    <ns>0</ns>
    <id>607</id>
    <revision>
      <id>66647</id>
      <parentid>57862</parentid>
      <timestamp>2013-12-18T22:38:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention the definition in iostream (technically C++11, was implicit before)</comment>
      <text xml:space="preserve" bytes="1455">{{cpp/io/ios_base/title | Init }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
class Init;
}}

This class is used to ensure that the default C++ streams ({{lc|std::cin}}, {{lc|std::cout}}, etc.) are properly initialized and destructed. The class tracks how many instances of it are created and initializes the C++ streams when the first instance is constructed as well as flushes the output streams when the last instance is destructed.

The header {{tt|&lt;iostream&gt;}} declares (directly or indirectly) an instance of {{c|std::ios_base::Init}} with static storage duration, whose definition is provided by the C++ library: this makes it safe to access the standard I/O streams in the constructors and destructors of static objects (as long as {{tt|#include &lt;iostream&gt;}} is present in the translation unit)

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | if {{c|*this}} is the first instance created, initializes the default C++ streams}}
{{dsc mem dtor | nolink=true | if {{c|*this}} is the last instance created, flushes the default C++ streams}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/dsc cin}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc inc | cpp/io/dsc cerr}}
{{dsc inc | cpp/io/dsc clog}}
{{dsc end}}

[[de:cpp/io/ios base/Init]]
[[es:cpp/io/ios base/Init]]
[[fr:cpp/io/ios base/Init]]
[[it:cpp/io/ios base/Init]]
[[ja:cpp/io/ios base/Init]]
[[pt:cpp/io/ios base/Init]]
[[ru:cpp/io/ios base/Init]]
[[zh:cpp/io/ios base/Init]]</text>
      <sha1>i5pggzkop1b00mdd79es4k6uwiw58ek</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/event</title>
    <ns>0</ns>
    <id>5469</id>
    <revision>
      <id>64265</id>
      <parentid>49784</parentid>
      <timestamp>2013-08-15T16:10:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="978">{{cpp/io/ios_base/title|event}}
{{cpp/io/ios_base/navbar}}
{{ddcl | 
enum event;
}}

Specifies the event type which is passed to functions registered by {{lc|register_callback()}} on specific events. The following constants are defined:

{{dsc begin}}
{{dsc hitem | Constant | Explanation }}
{{dsc | {{tt|erase_event}} | issued on {{lc|~ios_base()}} or {{ltt|cpp/io/basic_ios/copyfmt|basic_ios::copyfmt()}} (before the copy of members takes place)}}
{{dsc | {{tt|imbue_event}} | issued on {{lc|imbue()}}}}
{{dsc | {{tt|copyfmt_event}} | issued on {{ltt|cpp/io/basic_ios/copyfmt|basic_ios::copyfmt()}} (after the copy of members takes place, but before the exception settings are copied)}}
{{dsc end}}

===Example===
{{example|
|code=
|output=
}}

[[de:cpp/io/ios base/event]]
[[es:cpp/io/ios base/event]]
[[fr:cpp/io/ios base/event]]
[[it:cpp/io/ios base/event]]
[[ja:cpp/io/ios base/event]]
[[pt:cpp/io/ios base/event]]
[[ru:cpp/io/ios base/event]]
[[zh:cpp/io/ios base/event]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/event callback</title>
    <ns>0</ns>
    <id>5470</id>
    <revision>
      <id>64267</id>
      <parentid>57865</parentid>
      <timestamp>2013-08-15T16:11:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1248">{{cpp/io/ios_base/title|event_callback}}
{{cpp/io/ios_base/navbar}}
{{ddcl | 
typedef void (*event_callback)(event type, ios_base&amp; ios, int index);
}}

The type of function callbacks that can be registered using {{lc|register_callback()}} to be called on specific events.

{{tt|type}} is a value of type {{l2tt|cpp/io/ios_base/event}} which indicates the type of the event that will invoke this callback.

{{tt|ios}} refers to the stream object for which the callback is invoked: {{c|*this}} is passed as the argument when callbacks are invoked by {{lc|std::ios_base}} and {{lc|std::basic_ios}} member functions.

{{tt|index}} is the user-provided value passed to {{lc|register_callback()}} when registering the function.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc copyfmt}}
{{dsc inc | cpp/io/ios_base/dsc imbue}}
{{dsc inc | cpp/io/ios_base/dsc destructor}}
{{dsc inc | cpp/io/ios_base/dsc register_callback}}
{{dsc end}}

[[de:cpp/io/ios base/event callback]]
[[es:cpp/io/ios base/event callback]]
[[fr:cpp/io/ios base/event callback]]
[[it:cpp/io/ios base/event callback]]
[[ja:cpp/io/ios base/event callback]]
[[pt:cpp/io/ios base/event callback]]
[[ru:cpp/io/ios base/event callback]]
[[zh:cpp/io/ios base/event callback]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/failure</title>
    <ns>0</ns>
    <id>608</id>
    <revision>
      <id>62100</id>
      <parentid>62093</parentid>
      <timestamp>2013-06-22T02:05:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update inherited info</comment>
      <text xml:space="preserve" bytes="2198">{{cpp/io/ios_base/title | failure}}
{{cpp/io/ios_base/navbar}}
{{ddcl | header=ios | 
class failure;
}}

The class {{lc|std::ios_base::failure}} defines an exception object that is thrown on failure by the functions in the Input/Output library.

{{rev begin}}
{{rev | until=c++11 |
{{inheritance diagram/std-ios_base-failure-2003}}
}}
{{rev | since=c++11 |
{{inheritance diagram/std-ios_base-failure}}
}}
{{rev end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/failure/dsc constructor}}
{{dsc end}}

{{member | {{small|std::ios_base::failure::}}::failure |
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
explicit failure( const std::string&amp; message );
}}
{{dcl | since=c++11 | 1=
explicit failure( const std::string&amp; message, 
                  const std::error_code&amp; ec = std::io_errc::stream );
}}
{{dcl rev end}}
{{dcl | since=c++11 | 1=
explicit failure( const char* message,
                  const std::error_code&amp; ec = std::io_errc::stream );
}}
{{dcl end}}

Constructs the exception object using {{tt|message}} as explanation string which can later be retrieved using {{ltf|cpp/error/exception/what}}. 

===Parameters===
{{par begin}}
{{par | message | explanatory string}}
{{par end}}
}}

{{cpp/error/system_error/inherit}}
{{cpp/error/runtime_error/inherit}}
{{cpp/error/exception/inherit}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
int main()
{
    std::ifstream f(&quot;doesn't exist&quot;);
    try {
        f.exceptions(f.failbit);
    } catch (const std::ios_base::failure&amp; e)
    {
        std::cout &lt;&lt; &quot;Caught an ios_base::failure.\n&quot;
                  &lt;&lt; &quot;Explanatory string: &quot; &lt;&lt; e.what() &lt;&lt; '\n'
                  &lt;&lt; &quot;Error code: &quot; &lt;&lt; e.code() &lt;&lt; '\n';
    }
}
 | output=
Caught an ios_base::failure.
Explanatory string: ios_base::clear: unspecified iostream_category error
Error code: iostream:1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc end}}

[[de:cpp/io/ios base/failure]]
[[es:cpp/io/ios base/failure]]
[[fr:cpp/io/ios base/failure]]
[[it:cpp/io/ios base/failure]]
[[ja:cpp/io/ios base/failure]]
[[pt:cpp/io/ios base/failure]]
[[ru:cpp/io/ios base/failure]]
[[zh:cpp/io/ios base/failure]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/failure/failure</title>
    <ns>0</ns>
    <id>609</id>
    <redirect title="cpp/io/ios base/failure" />
    <revision>
      <id>62092</id>
      <parentid>62090</parentid>
      <timestamp>2013-06-22T01:56:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/ios base/failure]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/failure]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/flags</title>
    <ns>0</ns>
    <id>610</id>
    <revision>
      <id>63726</id>
      <parentid>63721</parentid>
      <timestamp>2013-07-23T13:20:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 63721 by [[Special:Contributions/SuperBoi45|SuperBoi45]] ([[User talk:SuperBoi45|talk]]) fmtflags fmtflags flags() ?</comment>
      <text xml:space="preserve" bytes="948">{{cpp/io/ios_base/title | flags }}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | num=1 |
fmtflags flags() const;
}}
{{dcl | num=2 |
fmtflags flags( fmtflags flags );
}}
{{dcl end}}

Manages format flags. 

1) returns current formatting setting

2) replaces current settings with given ones. 

===Parameters===
{{par begin}}
{{par | flags | new formatting setting. It can be a combination of the following constants:
{{cpp/io/ios_base/fmtflags consts}}
}}
{{par end}}

===Return value===
the formatting flags before the call to the function

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc setf}}
{{dsc inc | cpp/io/ios_base/dsc unsetf}}
{{dsc end}}

[[de:cpp/io/ios base/flags]]
[[es:cpp/io/ios base/flags]]
[[fr:cpp/io/ios base/flags]]
[[it:cpp/io/ios base/flags]]
[[ja:cpp/io/ios base/flags]]
[[pt:cpp/io/ios base/flags]]
[[ru:cpp/io/ios base/flags]]
[[zh:cpp/io/ios base/flags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/fmtflags</title>
    <ns>0</ns>
    <id>611</id>
    <revision>
      <id>65796</id>
      <parentid>57870</parentid>
      <timestamp>2013-10-08T09:53:30Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <comment>/* Example */</comment>
      <text xml:space="preserve" bytes="3567">{{cpp/io/ios_base/title | fmtflags}}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | 
typedef /*implementation defined*/ fmtflags;
}}
{{dcl | 1=
static constexpr fmtflags dec = /*implementation defined*/
static constexpr fmtflags oct = /*implementation defined*/
static constexpr fmtflags hex = /*implementation defined*/
static constexpr fmtflags basefield = /*implementation defined (dec {{!}} oct {{!}} hex)*/
}}
{{dcl | 1=
static constexpr fmtflags left = /*implementation defined*/
static constexpr fmtflags right = /*implementation defined*/
static constexpr fmtflags internal = /*implementation defined*/
static constexpr fmtflags adjustfield = /*implementation defined (left {{!}} right {{!}} internal)*/
}}
{{dcl | 1=
static constexpr fmtflags scientific = /*implementation defined*/
static constexpr fmtflags fixed = /*implementation defined*/
static constexpr fmtflags floatfield = /*implementation defined (scientific {{!}} fixed)*/
}}
{{dcl | 1=
static constexpr fmtflags boolalpha = /*implementation defined*/
static constexpr fmtflags showbase = /*implementation defined*/
static constexpr fmtflags showpoint = /*implementation defined*/
static constexpr fmtflags showpos = /*implementation defined*/
static constexpr fmtflags skipws = /*implementation defined*/
static constexpr fmtflags unitbuf = /*implementation defined*/
static constexpr fmtflags uppercase = /*implementation defined*/
}}
{{dcl end}}

Specifies available formatting flags. It is a {{concept|BitmaskType}}, the following constants are defined: 
{{cpp/io/ios_base/fmtflags consts}}

===Example===
{{example
 | The following example shows several different ways to print the same result.
 | code=
#include &lt;iostream&gt;

int main() 
{
    int num = 150;

    // using fmtflags as class member constants:
    std::cout.setf(std::ios_base::hex, std::ios_base::basefield);
    std::cout.setf(std::ios_base::showbase);
    std::cout &lt;&lt; num &lt;&lt; '\n';

    // using fmtflags as inherited class member constants:
    std::cout.setf (std::ios::hex , std::ios::basefield);
    std::cout.setf (std::ios::showbase);
    std::cout &lt;&lt; num &lt;&lt; '\n';

    // using fmtflags as object member constants:
    std::cout.setf(std::cout.hex, std::cout.basefield);
    std::cout.setf(std::cout.showbase);
    std::cout &lt;&lt; num &lt;&lt; '\n';

    // using fmtflags as a type:
    std::ios_base::fmtflags ff;
    ff = std::cout.flags();
    ff &amp;= ~std::cout.basefield;   // unset basefield bits
    ff {{!}}= std::cout.hex;          // set hex
    ff {{!}}= std::cout.showbase;     // set showbase
    std::cout.flags(ff);
    std::cout &lt;&lt; num &lt;&lt; '\n';

    // not using fmtflags, but using manipulators:
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; num &lt;&lt; '\n';
}
 | output=
0x96
0x96
0x96
0x96
0x96
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc flags}}
{{dsc inc | cpp/io/ios_base/dsc setf}}
{{dsc inc | cpp/io/ios_base/dsc unsetf}}
{{dsc inc | cpp/io/manip/dsc setbase}}
{{dsc inc | cpp/io/manip/dsc setfill}}
{{dsc inc | cpp/io/manip/dsc fixed}}
{{dsc inc | cpp/io/manip/dsc showbase}}
{{dsc inc | cpp/io/manip/dsc boolalpha}}
{{dsc inc | cpp/io/manip/dsc showpos}}
{{dsc inc | cpp/io/manip/dsc showpoint}}
{{dsc inc | cpp/io/manip/dsc unitbuf}}
{{dsc inc | cpp/io/manip/dsc skipws}}
{{dsc inc | cpp/io/manip/dsc uppercase}}
{{dsc end}}

[[de:cpp/io/ios base/fmtflags]]
[[es:cpp/io/ios base/fmtflags]]
[[fr:cpp/io/ios base/fmtflags]]
[[it:cpp/io/ios base/fmtflags]]
[[ja:cpp/io/ios base/fmtflags]]
[[pt:cpp/io/ios base/fmtflags]]
[[ru:cpp/io/ios base/fmtflags]]
[[zh:cpp/io/ios base/fmtflags]]</text>
      <sha1>ns0b6bdwmgwl0bhyt0flsgndlqr9l7a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/getloc</title>
    <ns>0</ns>
    <id>612</id>
    <revision>
      <id>66543</id>
      <parentid>65431</parentid>
      <timestamp>2013-12-04T17:01:12Z</timestamp>
      <contributor>
        <username>Ashish20</username>
        <id>519</id>
      </contributor>
      <minor/>
      <comment>getloc is a const member function (ios.base.locales)</comment>
      <text xml:space="preserve" bytes="1081">{{cpp/io/ios_base/title | getloc }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
std::locale getloc() const;
}}

Returns the current locale associated with the stream.

===Parameters===
(none)

===Return value===
the locale object associated with the stream.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ctime&gt;
#include &lt;iomanip&gt;
#include &lt;codecvt&gt;

int main()
{
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv(std::cout.rdbuf());
    std::wostream out(&amp;conv);

    out.imbue(std::locale(out.getloc(),
                          new std::time_put_byname&lt;wchar_t&gt;(&quot;ja_JP&quot;)));

    std::time_t t = std::time(NULL);
    out &lt;&lt; std::put_time(std::localtime(&amp;t), L&quot;%A %c&quot;) &lt;&lt; '\n';
}
 | output=
土曜日 2013年09月14日 11時31分15秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc imbue}}
{{dsc end}}

[[de:cpp/io/ios base/getloc]]
[[es:cpp/io/ios base/getloc]]
[[fr:cpp/io/ios base/getloc]]
[[it:cpp/io/ios base/getloc]]
[[ja:cpp/io/ios base/getloc]]
[[pt:cpp/io/ios base/getloc]]
[[ru:cpp/io/ios base/getloc]]
[[zh:cpp/io/ios base/getloc]]</text>
      <sha1>1hwth5ho2yhfjqa9nzscyaq3szipa5x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/imbue</title>
    <ns>0</ns>
    <id>613</id>
    <revision>
      <id>64165</id>
      <parentid>57874</parentid>
      <timestamp>2013-08-15T14:58:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="855">{{cpp/io/ios_base/title | imbue }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
std::locale imbue( const std::locale&amp; loc );
}}

Sets the associated locale of the stream to the given one. Before returning, each function, registered by {{lc|register_callback()}} is called with {{tt|imbue_event}} as a parameter. 

===Parameters===
{{par begin}}
{{par | loc | new locale to associate the stream to}}
{{par end}}

===Return value===
The locale object, associated with the stream before the operation

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc getloc}}
{{dsc end}}

[[de:cpp/io/ios base/imbue]]
[[es:cpp/io/ios base/imbue]]
[[fr:cpp/io/ios base/imbue]]
[[it:cpp/io/ios base/imbue]]
[[ja:cpp/io/ios base/imbue]]
[[pt:cpp/io/ios base/imbue]]
[[ru:cpp/io/ios base/imbue]]
[[zh:cpp/io/ios base/imbue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/ios base</title>
    <ns>0</ns>
    <id>5536</id>
    <revision>
      <id>66006</id>
      <parentid>61895</parentid>
      <timestamp>2013-10-20T08:10:34Z</timestamp>
      <contributor>
        <username>SneakySnake</username>
        <id>2552</id>
      </contributor>
      <minor/>
      <comment>Fix incorrect numbering in declaration list</comment>
      <text xml:space="preserve" bytes="1331">{{cpp/io/ios_base/title|ios_base}}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
private:
ios_base( const ios_base&amp; );
}}
{{dcl | since=c++11 | 1=
public:
ios_base( const ios_base&amp; ) = delete;
}}
{{dcl rev end}}
{{dcl | num=2 |
protected:
ios_base();
}}
{{dcl end}}

1) The copy constuctor is deleted: streams are not copyable

2) The default constructor is protected: only derived classes may construct {{tt|std::ios_base}}. The internal state is undefined after the construction. The derived class must call {{ltf|cpp/io/basic_ios/init|basic_ios::init}} to complete initialization before first use or before destructor, otherwise the behavior is undefined.

===Notes===
The same applies to the constructors of the next class in the I/O hierarchy, {{lc|std::basic_ios}}. Further-derived classes ({{lc|std::istream}} and {{lc|std::ostream}}) are always constructed with a concrete streambuffer object and call {{ltf|cpp/io/basic_ios/init|basic_ios::init}}, possibly more than once, to complete initialization of their virtual base.

[[de:cpp/io/ios base/ios base]]
[[es:cpp/io/ios base/ios base]]
[[fr:cpp/io/ios base/ios base]]
[[it:cpp/io/ios base/ios base]]
[[ja:cpp/io/ios base/ios base]]
[[pt:cpp/io/ios base/ios base]]
[[ru:cpp/io/ios base/ios base]]
[[zh:cpp/io/ios base/ios base]]</text>
      <sha1>1fdguuqkqvqi5qxee1uvoed8xoqlagv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/iostate</title>
    <ns>0</ns>
    <id>614</id>
    <revision>
      <id>63618</id>
      <parentid>49793</parentid>
      <timestamp>2013-07-10T16:50:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>peek is unformatted input function too</comment>
      <text xml:space="preserve" bytes="8851">{{cpp/io/ios_base/title | iostate}}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | 
typedef /*implementation defined*/ iostate;
}}
{{dcl | 1=
static constexpr iostate goodbit = 0;
}}
{{dcl | 1=
static constexpr iostate badbit = /*implementation defined*/
static constexpr iostate failbit = /*implementation defined*/
static constexpr iostate eofbit = /*implementation defined*/
}}
{{dcl end}}

Specifies stream state flags. It is a {{concept|BitmaskType}}, the following constants are defined: 
{{cpp/io/ios_base/iostate consts}}

====The eofbit====
The eofbit is set by the following standard library functions:
* The string input function {{lc|std::getline}} if it completes by reaching the end of the stream, as opposed to reaching the specified terminating character.
* The numeric input overloads of {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;}} if the end of the stream was encountered while reading the next character, on Stage 2 of {{l2tt|cpp/locale/num_get/get}} processing. Depending on the parsing state, {{tt|failbit}} may or may not be set at the same time: for example, {{c|1=int n; istringstream buf(&quot;1&quot;); buf &gt;&gt; n;}} sets {{tt|eofbit}}, but not {{tt|failbit}}: the integer {{c|1}} was successfully parsed and stored in {{tt|n}}. On the other hand, {{c|1=bool b; istringstream buf(&quot;tr&quot;); buf &gt;&gt; boolalpha &gt;&gt; b;}} sets both {{tt|eofbit}} and {{tt|failbit}}: there was not enough characters to complete the parsing of the boolean {{c|true}}.
* The character extraction overloads of {{ltt|cpp/io/basic_istream/operator_gtgt2|operator&gt;&gt;{{dsc small|std::basic_istream}}}}, if the end of the stream is reached before the limit (if any) on the number of characters to be extracted.
* The {{lc|std::get_time}} I/O manipulator and any of the {{lc|std::time_get}} parsing functions: {{l2tt|cpp/locale/time_get/get}}, {{l2tt|cpp/locale/time_get/get_time}}, {{l2tt|cpp/locale/time_get/get_date}}, etc., if the end of the stream is reached before the last character needed to parse the expected date/time value was processed.
* The {{lc|std::get_money}} I/O manipulator and {{l2tt|cpp/locale/money_get/get}} function, if the end of the stream is reached before the last character needed to parse the expected monetary value was processed.
* The {{l2tt|cpp/io/basic_istream/sentry}} constructor, executed at the beginning of every formatted input function: unless the {{tt|skipws}} bit is unset (e.g. by issuing {{lc|std::noskipws}}), sentry reads and discards the leading whitespace characters. If the end of the input stream is reached during this operation, both {{tt|eofbit}} and {{tt|failbit}} are set, and no input takes place.
* The I/O manipulator {{lc|std::ws}}, if it reaches the end of the stream while consuming whitespace (but, unlike the formatted input sentry, it does not set {{tt|failbit}} in this case)
* The unformatted input functions {{l2tt|cpp/io/basic_istream/read}}, {{l2tt|cpp/io/basic_istream/get}}, {{l2tt|cpp/io/basic_istream/peek}}, and {{l2tt|cpp/io/basic_istream/getline}}, when reaching the end of the stream.
* The discard input function {{l2tt|cpp/io/basic_istream/ignore}}, when reaching the end of the stream before reaching the specified delimiter character.
* The immediate input function {{l2tt|cpp/io/basic_istream/readsome}}, if {{l2tt|cpp/io/basic_streambuf/in_avail}} returns {{c|-1}}

The following functions clear {{tt|eofbit}} as a side-effect:
* {{l2tt|cpp/io/basic_istream/putback}}
* {{l2tt|cpp/io/basic_istream/unget}}
* {{l2tt|cpp/io/basic_istream/seekg}}

====The failbit====
The failbit is set by the following standard library functions:
* The {{l2tt|cpp/io/basic_istream/sentry}} constructor, executed at the beginning of every input function, if either {{tt|eofbit}} or {{tt|badbit}} is already set on the stream, or if the end of stream is encountered while consuming leading whitespace.
* The {{l2tt|cpp/io/basic_ostream/sentry}} constructor, executed at the beginning of every output function, under implementation-defined conditions.
* {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&gt;&gt;{{dsc small|(std::basic_string&lt;&gt;)}}}} if the function extracts no characters from the input stream.
* {{ltt|cpp/numeric/complex/operator_ltltgtgt|operator&gt;&gt;{{dsc small|(std::complex&lt;&gt;)}}}} if the function fails to extract a valid complex number.
* The character array and single character overloads of {{ltt|cpp/io/basic_istream/operator_gtgt2|operator&gt;&gt;}} if they fail to extract any characters.
* The streambuf overload of {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;}} if the streambuf argument is a null pointer or if no characters were inserted into the streambuf.
* The streambuf overload of {{l2tt|cpp/io/basic_ostream/operator_ltlt|operator&lt;&lt;}} if the function inserts no characters.
* {{ltt|cpp/utility/bitset/operator_ltltgtgt2|operator&gt;&gt;{{dsc small|(std::bitset&lt;&gt;)}}}} if the function extracts no characters from the input stream.
* {{lc|std::getline}} if the function extracts no characters or if it manages to extract {{l2tt|cpp/string/basic_string/max_size}} characters from the input stream.
* The numeric, pointer, and boolean input overloads of {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;}} (technically, the overloads of {{l2tt|cpp/locale/num_get/get}} they call), if the input cannot be parsed as a valid value or if the value parsed does not fit in the destination type.
* The time input manipulator {{lc|std::get_time}} (technically, {{l2tt|cpp/locale/time_get/get}} it calls}}, if the input cannot be unambiguously parsed as a time value according to the given format string.
* The currency input manipulator {{lc|std::get_money}} (technically, {{l2tt|cpp/locale/money_get/get}} it calls), if the input cannot be unambiguously parsed as a monetary value according to the locale rules.
* The extraction operators of all {{concept|RandomNumberEngine}}s, if bad input is encountered.
* The extraction operators of all {{concept|RandomNumberDistribution}}s, if bad input is encountered.
* The unformatted input functions {{l2tt|cpp/io/basic_istream/get}} if they fails to extract any characters.
* {{l2tt|cpp/io/basic_istream/getline}}, if it extracts no characters, if it fills in the provided buffer without encountering the delimiter, or if the provided buffer size is less than 1.
* {{l2tt|cpp/io/basic_istream/read}}, if the end-of-file condition occurs on the input stream before all requested characters could be extracted.
* {{l2tt|cpp/io/basic_istream/seekg}} on failure
* {{l2tt|cpp/io/basic_ostream/tellp}} on failure
* The constructors of {{lc|std::basic_fstream}}, {{lc|std::basic_ifstream}}, and {{lc|std::basic_ofstream}} that takes a filename argument, if the file cannot be opened.
* {{l2tt|cpp/io/basic_fstream/open}}, {{l2tt|cpp/io/basic_ifstream/open}}, and {{l2tt|cpp/io/basic_ofstream/open}} if the file cannot be opened.
* {{l2tt|cpp/io/basic_fstream/close}}, {{l2tt|cpp/io/basic_ifstream/close}}, and {{l2tt|cpp/io/basic_ofstream/close}} if the file cannot be closed.

====The badbit====
The badbit is set by the following standard library functions:

* {{l2tt|cpp/io/basic_ostream/put}} if it fails to insert a character into the output stream, for any reason.
* {{l2tt|cpp/io/basic_ostream/write}} if it fails to insert a character into the output stream, for any reason.
* Formatted output functions [[cpp/io/basic_ostream/operator_ltlt|operator&lt;&lt;]], {{lc|std::put_money}}, and {{lc|std::put_time}}, if they encounter the end of the output stream before completing output.
* {{l2tt|cpp/io/basic_ios/init}} when called to initialize a stream with a null pointer for {{tt|rdbuf()}}
* {{l2tt|cpp/io/basic_istream/putback}} and {{l2tt|cpp/io/basic_istream/unget}} when called on a stream with a null {{tt|rdbuf()}}
* {{l2tt|cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;{{dsc small|(basic_streambuf*)}}}} when a null pointer is passed as the argument.
* {{l2tt|cpp/io/basic_istream/putback}} and {{l2tt|cpp/io/basic_istream/unget}} if 
{{c|rdbuf()-&gt;sputbackc()}} or {{c|rdbuf()-&gt;sungetc()}} return {{c|traits::eof()}}.
* {{l2tt|cpp/io/basic_istream/sync}}, {{l2tt|cpp/io/basic_ostream/flush}}, and every output function on a {{tt|unitbuf}} output stream, if {{c|rdbuf()-&gt;pubsync()}} returns {{c|-1}}
* Every stream I/O function if an exception is thrown by any member function of the associated stream buffer (e.g. sbumpc(), xsputn(), sgetc(), overflow(), etc)
* {{l2tt|cpp/io/ios_base/iword}} and {{l2tt|cpp/io/ios_base/pword}} on failure (e.g. failure to allocate memory)

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{cpp/io/basic ios/iostate accessors}}

[[de:cpp/io/ios base/iostate]]
[[es:cpp/io/ios base/iostate]]
[[fr:cpp/io/ios base/iostate]]
[[it:cpp/io/ios base/iostate]]
[[ja:cpp/io/ios base/iostate]]
[[pt:cpp/io/ios base/iostate]]
[[ru:cpp/io/ios base/iostate]]
[[zh:cpp/io/ios base/iostate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/iword</title>
    <ns>0</ns>
    <id>615</id>
    <revision>
      <id>64166</id>
      <parentid>57875</parentid>
      <timestamp>2013-08-15T14:59:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}, fmt</comment>
      <text xml:space="preserve" bytes="2748">{{cpp/io/ios_base/title | iword }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
long&amp; iword( int index );
}}

First, allocates or resizes the private storage (dynamic array of {{c|long}} or another indexable data structure) sufficiently to make {{tt|index}} a valid index, then returns a reference to the {{c|long}} element of the private storage with the index {{tt|index}}. 

The reference may be invalidated by any operation on this {{tt|ios_base}} object, including another call to {{tt|iword()}}, but the stored values are retained, so that reading from {{c|iword(index)}} with the same index later will produce the same value (until the next call to {{lc|std::basic_ios::copyfmt()}}). The value can be used for any purpose. The index of the element must be obtained by {{lc|xalloc()}}, otherwise collisions with other users of this {{tt|ios_base}} may occur. New elements are initialized to {{c|0}}.

If allocation fails, calls {{c|std::basic_ios&lt;&gt;::setstate(badbit)}} which may throw {{lc|std::basic_ios::failure}}

===Notes===
Typical use of iword storage is to pass information (e.g. custom formatting flags) from user-defined I/O manipulators to user-defined {{tt|operator&lt;&lt;}} and {{tt|operator&gt;&gt;}} or to user-defined formatting facets imbued into standard streams.

===Parameters===
{{par begin}}
{{par | index | index value of the element}}
{{par end}}

===Return value===
A reference to the element.

===Exceptions===
May throw {{lc|std::ios_base::failure}} when setting the badbit.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

struct Foo {
    static int foo_xalloc;
    std::string data; 
    Foo(const std::string&amp; s) : data(s) {}
};

// allocates the iword storage for use with Foo objects
int Foo::foo_xalloc = std::ios_base::xalloc();

// This user-defined operator&lt;&lt; prints the string in reverse if the iword holds 1
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, Foo&amp; f)
{
    if(os.iword(Foo::foo_xalloc) == 1)
        return os &lt;&lt; std::string(f.data.rbegin(), f.data.rend());
    else
        return os &lt;&lt; f.data;
}

// This I/O manipulator flips the number stored in iword between 0 and 1
std::ios_base&amp; rev(std::ios_base&amp; os)
{
    os.iword(Foo::foo_xalloc) = !os.iword(Foo::foo_xalloc);
    return os;
}

int main()
{
    Foo f(&quot;example&quot;);
    std::cout &lt;&lt; f &lt;&lt; '\n' &lt;&lt; rev &lt;&lt; f &lt;&lt; '\n' &lt;&lt; rev &lt;&lt; f &lt;&lt; '\n';
}
 | output=
example
elpmaxe
example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc pword}}
{{dsc inc | cpp/io/ios_base/dsc xalloc}}
{{dsc end}}

[[de:cpp/io/ios base/iword]]
[[es:cpp/io/ios base/iword]]
[[fr:cpp/io/ios base/iword]]
[[it:cpp/io/ios base/iword]]
[[ja:cpp/io/ios base/iword]]
[[pt:cpp/io/ios base/iword]]
[[ru:cpp/io/ios base/iword]]
[[zh:cpp/io/ios base/iword]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/openmode</title>
    <ns>0</ns>
    <id>616</id>
    <revision>
      <id>57878</id>
      <parentid>49795</parentid>
      <timestamp>2013-06-01T06:03:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1110">{{cpp/io/ios_base/title | openmode}}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | 
typedef /*implementation defined*/ openmode;
}}
{{dcl | 1=
static constexpr openmode app = /*implementation defined*/
static constexpr openmode binary = /*implementation defined*/
static constexpr openmode in = /*implementation defined*/
static constexpr openmode out = /*implementation defined*/
static constexpr openmode trunc = /*implementation defined*/
static constexpr openmode ate = /*implementation defined*/
}}
{{dcl end}}

Specifies available file open flags. It is a {{concept|BitmaskType}}, the following constants are defined: 
{{cpp/io/ios_base/openmode consts}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc open}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc end}}

[[de:cpp/io/ios base/openmode]]
[[es:cpp/io/ios base/openmode]]
[[fr:cpp/io/ios base/openmode]]
[[it:cpp/io/ios base/openmode]]
[[ja:cpp/io/ios base/openmode]]
[[pt:cpp/io/ios base/openmode]]
[[ru:cpp/io/ios base/openmode]]
[[zh:cpp/io/ios base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/precision</title>
    <ns>0</ns>
    <id>617</id>
    <revision>
      <id>66542</id>
      <parentid>57879</parentid>
      <timestamp>2013-12-04T15:59:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example</comment>
      <text xml:space="preserve" bytes="1083">{{cpp/io/ios_base/title | precision }}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | num=1 |
streamsize precision() const;
}}
{{dcl | num=2 |
streamsize precision( streamsize new_precision );
}}
{{dcl end}}

Manages the precision (i.e. how many digits are generated) of certain numeric output conversions.

1) Returns the current precision. 

2) Sets the precision to the given one. 

===Parameters===
{{par begin}}
{{par | new_precision | new precision setting}}
{{par end}}

===Return value===
the precision before the call to the function

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;The default precision is &quot; &lt;&lt; std::cout.precision() &lt;&lt; '\n';
}
 | output=
The default precision is 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc width}}
{{dsc end}}

[[de:cpp/io/ios base/precision]]
[[es:cpp/io/ios base/precision]]
[[fr:cpp/io/ios base/precision]]
[[it:cpp/io/ios base/precision]]
[[ja:cpp/io/ios base/precision]]
[[pt:cpp/io/ios base/precision]]
[[ru:cpp/io/ios base/precision]]
[[zh:cpp/io/ios base/precision]]</text>
      <sha1>mx24fxi31v8n053ii9x9y06gshzbre3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/pword</title>
    <ns>0</ns>
    <id>618</id>
    <revision>
      <id>64167</id>
      <parentid>57880</parentid>
      <timestamp>2013-08-15T15:01:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Use {{lc}}</comment>
      <text xml:space="preserve" bytes="1817">{{cpp/io/ios_base/title | pword }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
void*&amp; pword( int index );
}}

First, allocates or resizes the private storage (dynamic array of {{c|void*}} or another indexable data structure) sufficiently to make {{tt|index}} a valid index, then returns a reference to the {{c|void*}} element of the private storage with the index {{tt|index}}. 

The reference may be invalidated by any operation on this {{tt|ios_base}} object, including another call to {{tt|pword()}}, but the stored values are retained, so that reading from {{c|pword(index)}} with the same index later will produce the same value (until the next call to {{c|copyfmt()}}). The value can be used for any purpose. The index of the element must be obtained by {{lc|xalloc()}}, otherwise collisions with other users of this {{tt|ios_base}} may occur. New elements are initialized to {{lc|NULL}}.

If allocation fails, calls {{c|std::basic_ios&lt;&gt;::setstate(badbit)}} which may throw {{c|std::basic_ios::failure}}

===Parameters===
{{par begin}}
{{par | index | index value of the element}}
{{par end}}

===Return value===
A reference to the element.

===Exceptions===
May throw {{lc|std::ios_base::failure}} when setting the badbit.

===Notes===
If the pointers stored in {{tt|pword}} require management, {{lc|register_callback()}} may be used to install handlers that execute deep copy or deallocation as needed.

===Example===
{{include| cpp/io/ios_base/xalloc_example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc iword}}
{{dsc inc | cpp/io/ios_base/dsc xalloc}}
{{dsc end}}

[[de:cpp/io/ios base/pword]]
[[es:cpp/io/ios base/pword]]
[[fr:cpp/io/ios base/pword]]
[[it:cpp/io/ios base/pword]]
[[ja:cpp/io/ios base/pword]]
[[pt:cpp/io/ios base/pword]]
[[ru:cpp/io/ios base/pword]]
[[zh:cpp/io/ios base/pword]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/register callback</title>
    <ns>0</ns>
    <id>619</id>
    <revision>
      <id>66096</id>
      <parentid>64171</parentid>
      <timestamp>2013-10-27T14:54:08Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <comment>Class std::hash is included with &lt;functional&gt;</comment>
      <text xml:space="preserve" bytes="4224">{{cpp/io/ios_base/title | register_callback }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
void register_callback( event_callback function, int index );
}}

Registers a user-defined function which will be called by {{lc|imbue()}}, {{lc|std::basic_ios::copyfmt()}} and {{lc|~ios_base()}}. Every registered callback is called every time: the event type (a value of type {{lc|event}}) is passed as its first argument, and may be used to distinguish between the callers.

The callbacks are called in the reverse order of registration (in other words, {{tt|register_callback()}} pushes a callback pair on the callback stack). If {{tt|register_callback()}} is called from within a callback function to add a new callback, the new callback is only called on the next event.

The user-defined callback function is not allowed to throw exceptions.

===Parameters===
{{par begin}}
{{par | function | the function which will be called on event, supplied as a function pointer of type {{rlp|event_callback}} }}
{{par | index | custom parameter which will be passed to the function}}
{{par end}}

===Return value===
(none)

===Notes===
Once registered, a callback cannot be deregistered: it remains a part of the stream object for the rest of its lifetime. If the behavior of a callback needs to change, it may be controlled through {{lc|iword()}} or {{lc|pword()}}.

If the same function is registered multiple times, it is called multiple times.

The integer value that is stored together with the callback is typically an index obtained from {{lc|xalloc()}}

===Example===
{{example| demonstrates the use of register_callback to update locale-dependent cached values that are used by a custom output operator
|code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;functional&gt;

// cached locale-specific message and its hash
typedef std::pair&lt;std::string, std::size_t&gt; cache_t;

// populate the cached message and its hash from the locale
void update_cache(cache_t&amp; cache, std::locale loc)
{
    auto&amp; fct = std::use_facet&lt; std::messages&lt;char&gt; &gt;(loc);
    std::messages_base::catalog cat = fct.open(&quot;sed&quot;, loc);
    cache.first = cat &lt; 0 ? &quot;&quot; : fct.get(cat, 0, 0, &quot;Memory exhausted&quot;);
    cache.second = std::hash&lt;std::string&gt;()(cache.first);
}

// update the cache if the locale changed
void true_callback(std::ios_base::event evt, std::ios_base&amp; str, int idx)
{
    if (evt == std::ios_base::imbue_event) 
    {
        cache_t* ptr = static_cast&lt;cache_t*&gt;(str.pword(idx));
        update_cache(*ptr, str.getloc());
    }
}

// registers the cache in pword() and sets up the callback
struct CacheSetup
{
    CacheSetup(std::ostream&amp; os, std::ios_base::event_callback f, cache_t* cache)
    {
        int index = std::ostream::xalloc();
        os.pword(index) = cache; // store pointer to cache in the stream
        os.register_callback(f, index); // store callback and the index to the pointer
        update_cache(*cache, os.getloc()); // initialize cache
    };
};

// some custom class 
struct S { };
// some custom class's operator&lt;&lt; that needs fast access to hashed message
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const S&amp;)
{
   static cache_t cache;
   static CacheSetup setup(os, true_callback, &amp;cache);
   return os &lt;&lt; cache.first &lt;&lt; &quot; : &quot; &lt;&lt; cache.second;
}

int main()
{
    std::locale loc(&quot;en_US.utf8&quot;);
    
    S s;
    std::cout.imbue(loc);
    std::cout &lt;&lt; s &lt;&lt; '\n';
    
    std::cout.imbue(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;de_DE.utf8&quot;)));
    std::cout &lt;&lt; s &lt;&lt; '\n';

    std::cout.imbue(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;ja_JP.utf8&quot;)));
    std::cout &lt;&lt; s &lt;&lt; '\n';

    std::cout.imbue(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;ru_RU.utf8&quot;)));
    std::cout &lt;&lt; s &lt;&lt; '\n';
}
|output=
Memory exhausted : 2,295,079,096
Speicher erschöpft : 3,139,423,551
メモリーが足りません : 3,837,351,114
Память исчерпана : 3,742,732,851
}}

[[de:cpp/io/ios base/register callback]]
[[es:cpp/io/ios base/register callback]]
[[fr:cpp/io/ios base/register callback]]
[[it:cpp/io/ios base/register callback]]
[[ja:cpp/io/ios base/register callback]]
[[pt:cpp/io/ios base/register callback]]
[[ru:cpp/io/ios base/register callback]]
[[zh:cpp/io/ios base/register callback]]</text>
      <sha1>60038lgzceew489vu3qaevdym9cijls</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/seekdir</title>
    <ns>0</ns>
    <id>620</id>
    <revision>
      <id>49799</id>
      <parentid>42833</parentid>
      <timestamp>2013-06-01T02:56:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="745">{{cpp/io/ios_base/title | seekdir}}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | 
typedef /*implementation defined*/ seekdir;
}}
{{dcl | 1=
static constexpr seekdir beg = /*implementation defined*/
static constexpr seekdir end = /*implementation defined*/
static constexpr seekdir cur = /*implementation defined*/
}}
{{dcl end}}

Specifies file seeking direction type. The following constants are defined: 
{{cpp/io/ios_base/seekdir consts}}

===Example===
{{example
 |
 | code=
 | output=
}}

[[de:cpp/io/ios base/seekdir]]
[[es:cpp/io/ios base/seekdir]]
[[fr:cpp/io/ios base/seekdir]]
[[it:cpp/io/ios base/seekdir]]
[[ja:cpp/io/ios base/seekdir]]
[[pt:cpp/io/ios base/seekdir]]
[[ru:cpp/io/ios base/seekdir]]
[[zh:cpp/io/ios base/seekdir]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/setf</title>
    <ns>0</ns>
    <id>621</id>
    <revision>
      <id>65050</id>
      <parentid>65040</parentid>
      <timestamp>2013-08-30T14:49:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2421">{{cpp/io/ios_base/title | setf }}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | num=1 |
fmtflags setf( fmtflags flags );
}}
{{dcl | num=2 |
fmtflags setf( fmtflags flags, fmtflags mask );
}}
{{dcl end}}

Sets the formatting flags to specified settings.

@1@ Sets the formatting flags identified by {{tt|flags}}. Effectively the following operation is performed {{c|fl {{=}} fl {{!}} flags}} where {{tt|fl}} defines the state of internal formatting flags. 

@2@ Clears the formatting flags under {{tt|mask}}, and sets the cleared flags to those specified by {{tt|flags}}. Effectively the following operation is performed {{c|fl {{=}} (fl &amp; ~mask) {{!}} (flags &amp; mask)}} where {{tt|fl}} defines the state of internal formatting flags.

===Parameters===
{{par begin}}
{{par | flags, mask | new formatting setting. {{tt|mask}} defines which flags can be altered, {{tt|flags}} defines which flags of those to be altered should be set (others will be cleared). Both parameters can be a combination of the following constants:
{{cpp/io/ios_base/fmtflags consts}}
}}
{{par end}}

===Return value===
the formatting flags before the call to the function

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

const double PI = 3.1415926535;

int main() 
{
    const int WIDTH = 15;

    std::cout.setf(std::ios::right);  //equivalent: cout &lt;&lt; right;
    std::cout &lt;&lt; std::setw(WIDTH/2) &lt;&lt; &quot;radius&quot;
              &lt;&lt; std::setw(WIDTH) &lt;&lt; &quot;circumference&quot; &lt;&lt; '\n';
	
    std::cout.setf(std::ios::fixed);
    for (double radius = 1; radius &lt;= 6; radius += 0.5) {
        std::cout &lt;&lt; std::setprecision(1) &lt;&lt; std::setw(WIDTH/2) 
                  &lt;&lt; radius
                  &lt;&lt; std::setprecision(2) &lt;&lt; std::setw(WIDTH) 
                  &lt;&lt; (2 * PI * radius) &lt;&lt; '\n';
    }
}
 | output=
 radius  circumference
    1.0           6.28
    1.5           9.42
    2.0          12.57
    2.5          15.71
    3.0          18.85
    3.5          21.99
    4.0          25.13
    4.5          28.27
    5.0          31.42
    5.5          34.56
    6.0          37.70
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc flags}}
{{dsc inc | cpp/io/ios_base/dsc unsetf}}
{{dsc end}}

[[de:cpp/io/ios base/setf]]
[[es:cpp/io/ios base/setf]]
[[fr:cpp/io/ios base/setf]]
[[it:cpp/io/ios base/setf]]
[[ja:cpp/io/ios base/setf]]
[[pt:cpp/io/ios base/setf]]
[[ru:cpp/io/ios base/setf]]
[[zh:cpp/io/ios base/setf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/sync with stdio</title>
    <ns>0</ns>
    <id>622</id>
    <revision>
      <id>67982</id>
      <parentid>66004</parentid>
      <timestamp>2014-03-10T21:41:19Z</timestamp>
      <contributor>
        <username>Goto</username>
        <id>2925</id>
      </contributor>
      <comment>No stdlog in C</comment>
      <text xml:space="preserve" bytes="2330">{{cpp/io/ios_base/title | sync_with_stdio }}
{{cpp/io/ios_base/navbar}}
{{ddcl |1=
static bool sync_with_stdio( bool sync = true );
}}

Sets whether the standard C++ streams are synchronized to the standard C streams after each input/output operation. 

The standard C++ streams are the following: {{lc|std::cin}}, {{lc|std::cout}}, {{lc|std::cerr}}, {{lc|std::clog}}, {{lc|std::wcin}}, {{lc|std::wcout}}, {{lc|std::wcerr}} and {{lc|std::wclog}}

The standard C streams are the following: {{lc|stdin}}, {{lc|stdout}} and {{lc|stderr}}

For a standard stream {{tt|str}}, synchronized with the C stream {{tt|f}}, the following pairs of functions have identical effect:
@1@ {{c|std::fputc(f, c)}} and {{c|str.rdbuf()-&gt;sputc(c)}}
@2@ {{c|std::fgetc(f)}} and {{c|str.rdbuf()-&gt;sbumpc()}}
@3@ {{c|std::ungetc(c, f)}} and {{c|str.rdbuf()-&gt;sputbackc(c)}}

In practice, this means that the C++ and the C streams use the same buffer, and therefore, can be mixed freely. In addition, synchronized C++ streams are guaranteed to be thread-safe (individual characters output from multiple threads may interleave, but no data races occur)

If the synchronization is turned off, the C++ standard streams are allowed to buffer their I/O independently, which may be  considerably faster in some cases. 

By default, all eight standard C++ streams are synchronized with their respective C streams.

It is implementation-defined if this function has any effect if called after some I/O occurred on the standard stream.

===Parameters===
{{par begin}}
{{par | sync | the new synchronization setting}}
{{par end}}

===Return value===
synchronization state before the call to the function

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdio&gt;

int main()
{
    std::cout.sync_with_stdio(false);
    std::cout &lt;&lt; &quot;a\n&quot;;
    std::printf(&quot;b\n&quot;);
    std::cout &lt;&lt; &quot;c\n&quot;;
}
 | output=
b
a
c
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/dsc cout}}
{{dsc inc | cpp/io/dsc cerr}}
{{dsc inc | cpp/io/dsc clog}}
{{dsc end}}

[[de:cpp/io/ios base/sync with stdio]]
[[es:cpp/io/ios base/sync with stdio]]
[[fr:cpp/io/ios base/sync with stdio]]
[[it:cpp/io/ios base/sync with stdio]]
[[ja:cpp/io/ios base/sync with stdio]]
[[pt:cpp/io/ios base/sync with stdio]]
[[ru:cpp/io/ios base/sync with stdio]]
[[zh:cpp/io/ios base/sync with stdio]]</text>
      <sha1>ibgd79szhbmmytusjx052wynookqka9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/unsetf</title>
    <ns>0</ns>
    <id>623</id>
    <revision>
      <id>65038</id>
      <parentid>57887</parentid>
      <timestamp>2013-08-29T19:57:34Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="781">{{cpp/io/ios_base/title | unsetf }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
void unsetf( fmtflags flags );
}}

Unsets the formatting flags identified by {{tt|flags}}. 

===Parameters===
{{par begin}}
{{par | flags | formatting flags to unset. It can be a combination of the following constants:
{{cpp/io/ios_base/fmtflags consts}}
}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc flags}}
{{dsc inc | cpp/io/ios_base/dsc setf}}
{{dsc end}}

[[de:cpp/io/ios base/unsetf]]
[[es:cpp/io/ios base/unsetf]]
[[fr:cpp/io/ios base/unsetf]]
[[it:cpp/io/ios base/unsetf]]
[[ja:cpp/io/ios base/unsetf]]
[[pt:cpp/io/ios base/unsetf]]
[[ru:cpp/io/ios base/unsetf]]
[[zh:cpp/io/ios base/unsetf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/width</title>
    <ns>0</ns>
    <id>624</id>
    <revision>
      <id>64712</id>
      <parentid>64709</parentid>
      <timestamp>2013-08-26T12:23:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>that's exactly what the previous sentence said.. merged</comment>
      <text xml:space="preserve" bytes="1160">{{cpp/io/ios_base/title | width }}
{{cpp/io/ios_base/navbar}}
{{dcl begin}}
{{dcl | num=1 |
streamsize width() const;
}}
{{dcl | num=2 |
streamsize width( streamsize new_width );
}}
{{dcl end}}

Manages the minimum number of characters to generate on certain output operations and the maximum number of character to generate on certain input operations.

@1@ Returns the current field width. 

@2@ Sets the field width to the given one. 

===Parameters===
{{par begin}}
{{par | new_width | new field width setting}}
{{par end}}

===Return value===
The field width before the call to the function

===Notes===
Some I/O functions call {{c|width(0)}} before returning, see {{lc|std::setw}} (this results in this field having effect on the next I/O function only, and not on any subsequent I/O)

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc precision}}
{{dsc end}}

[[de:cpp/io/ios base/width]]
[[es:cpp/io/ios base/width]]
[[fr:cpp/io/ios base/width]]
[[it:cpp/io/ios base/width]]
[[ja:cpp/io/ios base/width]]
[[pt:cpp/io/ios base/width]]
[[ru:cpp/io/ios base/width]]
[[zh:cpp/io/ios base/width]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/xalloc</title>
    <ns>0</ns>
    <id>625</id>
    <revision>
      <id>71076</id>
      <parentid>71073</parentid>
      <timestamp>2014-06-05T10:31:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="1298">{{cpp/io/ios_base/title | xalloc }}
{{cpp/io/ios_base/navbar}}
{{ddcl |
static int xalloc();
}}

Returns a unique (program-wide) index value that can be used to access one {{c|long}} and one {{c|void*}} elements in the private storage of {{tt|std::ios_base}} by calling {{lc|iword()}} and {{lc|pword()}}. The call to {{tt|xalloc}} does not allocate memory.

{{rev inl|since=c++14|
This function is thread-safe; concurrent access by multiple threads does not result in a data race.}}

Effectively increments a private static data member of {{tt|std::ios_base}}, as if by executing {{c|return index++;}}, if {{tt|index}} is the name of that static member {{rev inl|since=c++14|(which may be {{lc|std::atomic}} to support concurrent access by multiple threads, or otherwise synchronized)}}

===Parameters===
(none)

===Return value===
Unique integer for use as pword/iword index.

===Example===
{{include| cpp/io/ios_base/xalloc_example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc pword}}
{{dsc inc | cpp/io/ios_base/dsc iword}}
{{dsc end}}

[[de:cpp/io/ios base/xalloc]]
[[es:cpp/io/ios base/xalloc]]
[[fr:cpp/io/ios base/xalloc]]
[[it:cpp/io/ios base/xalloc]]
[[ja:cpp/io/ios base/xalloc]]
[[pt:cpp/io/ios base/xalloc]]
[[ru:cpp/io/ios base/xalloc]]
[[zh:cpp/io/ios base/xalloc]]</text>
      <sha1>9mmdyiio8qmv0k4y50tnsu66inuvkyd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ios base/~ios base</title>
    <ns>0</ns>
    <id>5537</id>
    <revision>
      <id>42789</id>
      <parentid>33863</parentid>
      <timestamp>2012-11-03T00:27:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="672">{{cpp/io/ios_base/title|~ios_base}}
{{cpp/io/ios_base/navbar}}
{{ddcl |
virtual ~ios_base();
}}

Destroys the {{tt|ios_base}} object. 

Before any of the member functions would yield undefined results, calls callbacks, registered by {{ltf|cpp/io/ios_base/register_callback}} passing {{ltt|cpp/io/ios_base/event | erase_event}} as parameter.

No operations on {{tt|rdbuf}} are performed, it is not destroyed.

[[de:cpp/io/ios base/~ios base]]
[[es:cpp/io/ios base/~ios base]]
[[fr:cpp/io/ios base/~ios base]]
[[it:cpp/io/ios base/~ios base]]
[[ja:cpp/io/ios base/~ios base]]
[[pt:cpp/io/ios base/~ios base]]
[[ru:cpp/io/ios base/~ios base]]
[[zh:cpp/io/ios base/~ios base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/iostream category</title>
    <ns>0</ns>
    <id>4774</id>
    <revision>
      <id>68700</id>
      <parentid>63326</parentid>
      <timestamp>2014-03-19T16:29:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>add code.message to output</comment>
      <text xml:space="preserve" bytes="1612">{{cpp/title|iostream_category}}
{{cpp/io/navbar}}
{{ddcl | header=ios | since=c++11 |
const std::error_category&amp; iostream_category();
}}

Obtains a reference to the static error category object for iostream errors. The object is required to override the virtual function {{c|error_category::name()}} to return a pointer to the string {{c|&quot;iostream&quot;}}. It is used to identify error codes provided in the exceptions of type {{lc|std::ios_base::failure}}.

===Parameters===
(none)

===Return value===
A reference to the static object of unspecified runtime type, derived from {{lc|std::error_category}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
 
int main()
{
    std::ifstream f(&quot;doesn't exist&quot;);
    try {
        f.exceptions(f.failbit);
    } catch (const std::ios_base::failure&amp; e) {
        std::cout &lt;&lt; &quot;Caught an ios_base::failure.\n&quot;
                  &lt;&lt; &quot;Error code: &quot; &lt;&lt; e.code().value() 
                  &lt;&lt; &quot; (&quot; &lt;&lt; e.code().message() &lt;&lt; &quot;)\n&quot;
                  &lt;&lt; &quot;Error category: &quot; &lt;&lt; e.code().category().name() &lt;&lt; '\n';

    }
}
 | p=true
 | output=
Caught an ios_base::failure.
Error code: 1 (unspecified iostream_category error)
Error category: iostream
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc failure}}
{{dsc inc | cpp/io/dsc io_errc}}
{{dsc end}}

[[de:cpp/io/iostream category]]
[[es:cpp/io/iostream category]]
[[fr:cpp/io/iostream category]]
[[it:cpp/io/iostream category]]
[[ja:cpp/io/iostream category]]
[[pt:cpp/io/iostream category]]
[[ru:cpp/io/iostream category]]
[[zh:cpp/io/iostream category]]</text>
      <sha1>q24j6lh5ddoddp894q2tuxzf845jhq6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/is error code enum</title>
    <ns>0</ns>
    <id>5597</id>
    <redirect title="cpp/io/io errc/is error code enum" />
    <revision>
      <id>20634</id>
      <timestamp>2012-03-28T18:07:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/io/is error code enum]] to [[cpp/io/io errc/is error code enum]]: better title</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/io/io errc/is error code enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/istrstream</title>
    <ns>0</ns>
    <id>4696</id>
    <revision>
      <id>61848</id>
      <parentid>57893</parentid>
      <timestamp>2013-06-09T15:59:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dsc end</comment>
      <text xml:space="preserve" bytes="1364">{{cpp/title|istrstream}}
{{cpp/io/istrstream/navbar}}
{{dcl begin}}
{{dcl header|strstream}}
{{dcl | notes={{mark deprecated}} | 1=
class istrstream : public std::istream
}}
{{dcl end}}

The class {{tt|istrstream}} implements input operations on array-backed streams. It essentially wraps a raw array I/O device implementation ({{c|std::strstreambuf}}) into the higher-level interface of {{lc|std::basic_istream}}. 

The typical implementation of {{tt|istrstream}} holds only one non-derived data member: an object of type {{c|std::strstreambuf}}.

===Notes===
{{tt|istrstream}} has been deprecated since C++98, {{lc|std::istringstream}} and [http://www.boost.org/doc/libs/release/libs/iostreams/doc/classes/array.html#array_source boost::iostreams::array_source] are the recommended replacements.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc constructor | istrstream}}
{{dsc inc | cpp/io/strstream/dsc destructor | istrstream}}
{{dsc inc | cpp/io/strstream/dsc rdbuf | istrstream}}
{{dsc inc | cpp/io/strstream/dsc str | istrstream}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/istrstream]]
[[es:cpp/io/istrstream]]
[[fr:cpp/io/istrstream]]
[[it:cpp/io/istrstream]]
[[ja:cpp/io/istrstream]]
[[pt:cpp/io/istrstream]]
[[ru:cpp/io/istrstream]]
[[zh:cpp/io/istrstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/istrstream/istrstream</title>
    <ns>0</ns>
    <id>12950</id>
    <revision>
      <id>65177</id>
      <timestamp>2013-09-04T16:36:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1770">{{cpp/io/istrstream/title | istrstream}}
{{cpp/io/istrstream/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
explicit istrstream(const char* s);
}}
{{dcl | num=2 | 1=
explicit istrstream(char* s);
}}
{{dcl | num=3 | 1=
istrstream(const char* s, std::streamsize n);
}}
{{dcl | num=4 | 1=
istrstream(char* s, std::streamsize n);
}}
{{dcl end}}

Constructs new istrstream and its underlying {{lc|std::strstreambuf}}.

@1,2@ Constructs the underlying {{lc|std::strstreambuf}} by calling {{c|strstreambuf(s,0)}} and initializes the base class with the address of the strstreambuf. The behavior is undefined if {{tt|s}} is not pointing at an element of a null-terminated array.

@3,4@ Constructs the underlying {{lc|std::strstreambuf}} by calling {{c|strstreambuf(s,n)}} and initializes the base class with the address of the strstreambuf. The behavior is undefined if {{tt|s}} is not pointing at an element of an array whose length is at least {{tt|n}} elements.

===Parameters===
{{par begin}}
{{par | s | C-string or char array to use as the contents of the stream}}
{{par | n | size of the array }}
{{par end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;strstream&gt;

int main()
{
    std::istrstream s1(&quot;1 2 3&quot;); // string literal
    int n1,n2,n3;
    if(s1 &gt;&gt; n1 &gt;&gt; n2 &gt;&gt; n3)
        std::cout &lt;&lt; n1 &lt;&lt; &quot;, &quot; &lt;&lt; n2 &lt;&lt; &quot;, &quot; &lt;&lt; n3 &lt;&lt; '\n';

    char arr[] = {'4', ' ', '5', ' ', '6'};
    std::istrstream s2(arr, sizeof arr);
    if(s2 &gt;&gt; n1 &gt;&gt; n2 &gt;&gt; n3)
        std::cout &lt;&lt; n1 &lt;&lt; &quot;, &quot; &lt;&lt; n2 &lt;&lt; &quot;, &quot; &lt;&lt; n3 &lt;&lt; '\n';
}
 | output=
1, 2, 3
4, 5, 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc strstreambuf}}
{{dsc inc | cpp/io/strstream/dsc constructor | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc constructor | strstream}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/istrstream/rdbuf</title>
    <ns>0</ns>
    <id>9732</id>
    <revision>
      <id>63938</id>
      <parentid>50866</parentid>
      <timestamp>2013-08-01T15:42:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="50">{{include page|cpp/io/strstream/rdbuf|istrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/istrstream/str</title>
    <ns>0</ns>
    <id>9727</id>
    <revision>
      <id>63937</id>
      <parentid>50867</parentid>
      <timestamp>2013-08-01T15:42:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="48">{{include page|cpp/io/strstream/str|istrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/istrstream/~istrstream</title>
    <ns>0</ns>
    <id>12954</id>
    <revision>
      <id>65184</id>
      <timestamp>2013-09-04T17:25:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1074">{{cpp/io/istrstream/title|~istrstream}}
{{cpp/io/istrstream/navbar}}
{{dcl begin}}
{{dcl | 1=
virtual ~istrstream();
}}
{{dcl end}}

Destroys a {{tt|std::istrstream}} object, which also destroys the member {{lc|std::strstreambuf}}.

===Parameters===
(none)

===Notes===
The constructors of {{lc|std::istrstream}} do not create the underlying {{lc|std::strstreambuf}} in dynamically allocated mode, so the memory leaks that are possible with {{lc|std::ostrstream::~ostrstream}} or {{lc|std::strstream::~strstream}} do not apply.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    {
        std::istrstream s(&quot;1.234&quot;);
        double d;
        s &gt;&gt; d;
        std::cout &lt;&lt; d &lt;&lt; '\n';
    } // destructor called
}
 | output=
1.234
}}

[[de:cpp/io/istrstream/~istrstream]]
[[es:cpp/io/istrstream/~istrstream]]
[[fr:cpp/io/istrstream/~istrstream]]
[[it:cpp/io/istrstream/~istrstream]]
[[ja:cpp/io/istrstream/~istrstream]]
[[pt:cpp/io/istrstream/~istrstream]]
[[ru:cpp/io/istrstream/~istrstream]]
[[zh:cpp/io/istrstream/~istrstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/make error code</title>
    <ns>0</ns>
    <id>5598</id>
    <redirect title="cpp/io/io errc/make error code" />
    <revision>
      <id>20637</id>
      <timestamp>2012-03-28T18:09:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/io/make error code]] to [[cpp/io/io errc/make error code]]: consistency for helper classes/functions</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/io/io errc/make error code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/make error condition</title>
    <ns>0</ns>
    <id>5599</id>
    <redirect title="cpp/io/io errc/make error condition" />
    <revision>
      <id>20639</id>
      <timestamp>2012-03-28T18:09:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/io/make error condition]] to [[cpp/io/io errc/make error condition]]: consistency for member classes/functions</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/io/io errc/make error condition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip</title>
    <ns>0</ns>
    <id>2973</id>
    <revision>
      <id>57896</id>
      <parentid>49807</parentid>
      <timestamp>2013-06-01T06:03:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2151">{{title|Input/output manipulators}}
{{cpp/io/manip/navbar}}

Manipulators are helper functions that make it possible to control input/output streams using {{c|operator&lt;&lt;}} or {{c|operator&gt;&gt;}}. 

The manipulators that are invoked without arguments (e.g. {{c|std::cout &lt;&lt; std::boolalpha;}} or {{c|std::cin &gt;&gt; std::hex;}}) are implemented as functions that take a reference to a stream as their only argument. The special overloads of {{ltt|cpp/io/basic_ostream/operator_ltlt | basic_ostream::operator&lt;&lt;}} and {{ltt|cpp/io/basic_istream/operator_gtgt | basic_istream::operator&gt;&gt;}} accept pointers to these functions.

The manipulators that are invoked with arguments (e.g. {{c|std::cout &lt;&lt; std::setw(10);}}) are implemented as functions returning objects of unspecified type.  These manipulators define their own {{tt|operator&lt;&lt;}} or {{tt|operator&gt;&gt;}} which perform the requested manipulation.

{{dsc begin}}
{{dsc header | ios }}
{{dsc inc | cpp/io/manip/dsc boolalpha}}
{{dsc inc | cpp/io/manip/dsc showbase}}
{{dsc inc | cpp/io/manip/dsc showpoint}}
{{dsc inc | cpp/io/manip/dsc showpos}}
{{dsc inc | cpp/io/manip/dsc skipws}}
{{dsc inc | cpp/io/manip/dsc uppercase}}
{{dsc inc | cpp/io/manip/dsc unitbuf}}
{{dsc inc | cpp/io/manip/dsc left}}
{{dsc inc | cpp/io/manip/dsc hex}}
{{dsc inc | cpp/io/manip/dsc fixed}}
{{dsc header | istream}}
{{dsc inc | cpp/io/manip/dsc ws}}
{{dsc header | ostream}}
{{dsc inc | cpp/io/manip/dsc ends}}
{{dsc inc | cpp/io/manip/dsc flush}}
{{dsc inc | cpp/io/manip/dsc endl}}
{{dsc header | iomanip}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc inc | cpp/io/manip/dsc setbase}}
{{dsc inc | cpp/io/manip/dsc setfill}}
{{dsc inc | cpp/io/manip/dsc setprecision}}
{{dsc inc | cpp/io/manip/dsc setw}}
{{dsc inc | cpp/io/manip/dsc get_money}}
{{dsc inc | cpp/io/manip/dsc put_money}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc inc | cpp/io/manip/dsc quoted}}
{{dsc end}}

[[de:cpp/io/manip]]
[[es:cpp/io/manip]]
[[fr:cpp/io/manip]]
[[it:cpp/io/manip]]
[[ja:cpp/io/manip]]
[[pt:cpp/io/manip]]
[[ru:cpp/io/manip]]
[[zh:cpp/io/manip]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/boolalpha</title>
    <ns>0</ns>
    <id>4690</id>
    <revision>
      <id>62325</id>
      <parentid>62314</parentid>
      <timestamp>2013-06-26T18:46:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>caps</comment>
      <text xml:space="preserve" bytes="2132">{{cpp/title|boolalpha|noboolalpha}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; boolalpha( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; noboolalpha( std::ios_base&amp; str );
}}
{{dcl end}}

@1@ Enables the {{tt|boolalpha}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::boolalpha)}}

@2@ Disables the {{tt|boolalpha}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::boolalpha)}}

{{tt|std::boolalpha}} is an I/O manipulator, so it may be called with an expression such as {{c|out &lt;&lt; std::boolalpha}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::boolalpha}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iostream&gt;
int main()
{
    // boolalpha output
    std::cout &lt;&lt; std::boolalpha 
              &lt;&lt; &quot;boolalpha true: &quot; &lt;&lt; true &lt;&lt; '\n'
              &lt;&lt; &quot;boolalpha false: &quot; &lt;&lt; false &lt;&lt; '\n';
    std::cout &lt;&lt; std::noboolalpha 
              &lt;&lt; &quot;noboolalpha true: &quot; &lt;&lt; true &lt;&lt; '\n'
              &lt;&lt; &quot;noboolalpha false: &quot; &lt;&lt; false &lt;&lt; '\n';
    // booalpha parse
    bool b1, b2;
    std::istringstream is(&quot;true false&quot;);
    is &gt;&gt; std::boolalpha &gt;&gt; b1 &gt;&gt; b2;
    std::cout &lt;&lt; '\&quot;' &lt;&lt; is.str() &lt;&lt; &quot;\&quot; parsed as &quot; &lt;&lt; b1 &lt;&lt; ' ' &lt;&lt; b2 &lt;&lt; '\n';
}
 | output=
boolalpha true: true
boolalpha false: false
noboolalpha true: 1
noboolalpha false: 0
&quot;true false&quot; parsed as 1 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc inc | cpp/locale/numpunct/dsc do_truefalsename | mem=std::numpunct&lt;CharT&gt;}}
{{dsc end}}

[[de:cpp/io/manip/boolalpha]]
[[es:cpp/io/manip/boolalpha]]
[[fr:cpp/io/manip/boolalpha]]
[[it:cpp/io/manip/boolalpha]]
[[ja:cpp/io/manip/boolalpha]]
[[pt:cpp/io/manip/boolalpha]]
[[ru:cpp/io/manip/boolalpha]]
[[zh:cpp/io/manip/boolalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/endl</title>
    <ns>0</ns>
    <id>4674</id>
    <revision>
      <id>69994</id>
      <parentid>62014</parentid>
      <timestamp>2014-05-05T12:20:44Z</timestamp>
      <contributor>
        <ip>141.162.101.50</ip>
      </contributor>
      <comment>s/a endline/a newline/</comment>
      <text xml:space="preserve" bytes="3368">{{cpp/title|endl}}
{{cpp/io/manip/navbar}}
{{ddcl | header=ostream |
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;charT,traits&gt;&amp; endl( std::basic_ostream&lt;CharT, Traits&gt;&amp; os );
}}

Inserts a newline character into the output sequence {{tt|os}} and flushes it as if by calling {{c|os.put(os.widen('\n'))}} followed by {{c|os.flush()}}. 

This is an output-only I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::endl}} for any {{tt|out}} of type {{lc|std::basic_ostream}}.

===Notes===
This manipulator may be used to produce a line of output immediately, e.g. when displaying output from a long-running process, logging activity of multiple threads or logging activity of a program that may crash unexpectedly. An explicit flush  of {{lc|std::cout}} is also necessary before a call to {{lc|std::system}}, if the spawned process performs any screen I/O (a common example is {{c|std::system(&quot;pause&quot;)}} on Windows). In most other usual interactive I/O scenarios, {{lc|std::endl}} is redundant when used with {{lc|std::cout}} because any input from {{lc|std::cin}}, output to {{lc|std::cerr}}, or program termination forces a call to {{c|std::cout.flush()}}. Use of {{lc|std::endl}} in place of {{c|'\n'}}, encouraged by some sources, may significantly degrade output performance.

In many implementations, standard output is line-buffered, and writing {{c|'\n'}} causes a flush anyway, unless {{c|std::cout.sync_with_stdio(false)}} was executed. In those situations, unnecessary {{tt|endl}} only degrades the performance of file output, not standard output.

The code samples on this wiki [http://www.stroustrup.com/3rd_code.html follow Bjarne Stroustrup] in flushing the standard output only where necessary.

When an incomplete line of output needs to be flushed, the {{lc|std::flush}} manipulator may be used.

When every character of output needs to be flushed, the {{lc|std::unitbuf}} manipulator may be used.

===Parameters===
{{par begin}}
{{par | os | reference to output stream }}
{{par end}}

===Return value===

{{tt|os}} (reference to the stream after manipulation)

===Example===
{{example
 | With \n instead of endl, the output would be the same, but may not appear in real time.
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

template&lt;typename Diff&gt;
void log_progress(Diff d)
{
    std::cout &lt;&lt; std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(d).count()
              &lt;&lt; &quot; ms passed&quot; &lt;&lt; std::endl;
}

int main()
{
    std::cout.sync_with_stdio(false); // on some platforms, stdout flushes on \n
    volatile int sink = 0;

    auto t1 = std::chrono::high_resolution_clock::now();
    for (int j=0; j&lt;5; ++j)
    {
        for (int n=0; n&lt;10000; ++n)
            for (int m=0; m&lt;20000; ++m)
                sink += m*n; // do some work
        auto now = std::chrono::high_resolution_clock::now();
        log_progress(now - t1);
    }
}
 | output=
487 ms passed
974 ms passed
1470 ms passed
1965 ms passed
2455 ms passed
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc unitbuf}}
{{dsc inc | cpp/io/manip/dsc flush}}
{{dsc inc | cpp/io/basic_ostream/dsc flush | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/manip/endl]]
[[es:cpp/io/manip/endl]]
[[fr:cpp/io/manip/endl]]
[[it:cpp/io/manip/endl]]
[[ja:cpp/io/manip/endl]]
[[pt:cpp/io/manip/endl]]
[[ru:cpp/io/manip/endl]]
[[zh:cpp/io/manip/endl]]</text>
      <sha1>notg1nzkvx403kcnz0rr0sycja138tv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/ends</title>
    <ns>0</ns>
    <id>4673</id>
    <revision>
      <id>49810</id>
      <parentid>42735</parentid>
      <timestamp>2013-06-01T02:56:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1509">{{cpp/title|ends}}
{{cpp/io/manip/navbar}}
{{ddcl | header=ostream |
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;charT,traits&gt;&amp; ends( std::basic_ostream&lt;CharT, Traits&gt;&amp; os );
}}

Inserts a null character into the output sequence {{tt|os}} as if by calling {{c|os.put(CharT())}}. 

This is an output-only I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::ends}} for any {{tt|out}} of type {{lc|std::basic_ostream}}.

===Notes===
This manipulator is typically used with {{c|std::ostrstream}}, when the associated output buffer needs to be null-terminated to be processed as a C string.

Unlike {{lc|std::endl}}, this manipulator does not flush the stream.

===Parameters===
{{par begin}}
{{par | os | reference to output stream }}
{{par end}}

===Return value===

{{tt|os}} (reference to the stream after insertion of the null character)

===Example===
{{example
 |
 | code=
#include &lt;cstdio&gt;
#include &lt;strstream&gt;
int main()
{
    std::ostrstream oss;
    oss &lt;&lt; &quot;Sample text: &quot; &lt;&lt; 42 &lt;&lt; std::ends;
    std::printf(&quot;%s\n&quot;, oss.str());
    oss.freeze(false); // enable memory deallocation
}
 | output=
Sample text: 42
}}

===See also===
{{dsc begin}}
{{dsc class | cpp/io/ostrstream | notes={{mark deprecated}} | implements character array output operations}}
{{dsc end}}

[[de:cpp/io/manip/ends]]
[[es:cpp/io/manip/ends]]
[[fr:cpp/io/manip/ends]]
[[it:cpp/io/manip/ends]]
[[ja:cpp/io/manip/ends]]
[[pt:cpp/io/manip/ends]]
[[ru:cpp/io/manip/ends]]
[[zh:cpp/io/manip/ends]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/fixed</title>
    <ns>0</ns>
    <id>4770</id>
    <revision>
      <id>62750</id>
      <parentid>62315</parentid>
      <timestamp>2013-07-01T23:38:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2826">{{cpp/title|fixed|scientific|hexfloat|defaultfloat}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; fixed( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; scientific( std::ios_base&amp; str );
}}
{{dcl | num = 3 | since=c++11 |
std::ios_base&amp; hexfloat( std::ios_base&amp; str );
}}
{{dcl | num = 4 | since=c++11 |
std::ios_base&amp; defaultfloat( std::ios_base&amp; str );
}}
{{dcl end}}

Modifies the default formatting for floating-point input/output.

@1@ Sets the {{tt|floatfield}} of the stream {{tt|str}} to {{tt|fixed}} as if by calling {{c|str.setf(std::ios_base::fixed, std::ios_base::floatfield)}}

@2@ Sets the {{tt|floatfield}} of the stream {{tt|str}} to {{tt|scientific}} as if by calling {{c|str.setf(std::ios_base::scientific, std::ios_base::floatfield)}}

@3@ Sets the {{tt|floatfield}} of the stream {{tt|str}} to {{tt|fixed}} and {{tt|scientific}} simultaneously as if by calling {{c|str.setf(std::ios_base::fixed {{!}} std::ios_base::scientific, std::ios_base::floatfield)}}. This enables hexadecimal floating-point formatting.

@4@ Sets the {{tt|floatfield}} of the stream {{tt|str}} to zero, as if by calling {{c|str.unsetf(std::ios_base::floatfield)}}. This enables the default floating-point formatting, which is different from fixed and scientific.

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::fixed}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::scientific}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::cout &lt;&lt; &quot;The number 0.01 in fixed:      &quot; &lt;&lt; std::fixed &lt;&lt; 0.01 &lt;&lt; '\n'
              &lt;&lt; &quot;The number 0.01 in scientific: &quot; &lt;&lt; std::scientific &lt;&lt; 0.01 &lt;&lt; '\n'
              &lt;&lt; &quot;The number 0.01 in hexfloat:   &quot; &lt;&lt; std::hexfloat &lt;&lt; 0.01 &lt;&lt; '\n'
              &lt;&lt; &quot;The number 0.01 in default:    &quot; &lt;&lt; std::defaultfloat &lt;&lt; 0.01 &lt;&lt; '\n';
    double f;
    std::istringstream(&quot;0x1P-1022&quot;) &gt;&gt; std::hexfloat &gt;&gt; f;
    std::cout &lt;&lt; &quot;Parsing 0x1P-1022 as hex gives &quot; &lt;&lt; f &lt;&lt; '\n';
}
 | output=
The number 0.01 in fixed:      0.010000
The number 0.01 in scientific: 1.000000e-02
The number 0.01 in hexfloat:   0x1.47ae147ae147bp-7
The number 0.01 in default:    0.01
Parsing 0x1P-1022 as hex gives 2.22507e-308
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc setprecision}}
{{dsc end}}

[[de:cpp/io/manip/fixed]]
[[es:cpp/io/manip/fixed]]
[[fr:cpp/io/manip/fixed]]
[[it:cpp/io/manip/fixed]]
[[ja:cpp/io/manip/fixed]]
[[pt:cpp/io/manip/fixed]]
[[ru:cpp/io/manip/fixed]]
[[zh:cpp/io/manip/fixed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/flush</title>
    <ns>0</ns>
    <id>4675</id>
    <revision>
      <id>57904</id>
      <parentid>49812</parentid>
      <timestamp>2013-06-01T06:03:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2691">{{cpp/title|flush}}
{{cpp/io/manip/navbar}}
{{ddcl | header=ostream |
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;charT,traits&gt;&amp; flush( std::basic_ostream&lt;CharT, Traits&gt;&amp; os );
}}

Flushes the output sequence {{tt|os}} as if by calling {{c|os.flush()}}. 

This is an output-only I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::flush}} for any {{tt|out}} of type {{lc|std::basic_ostream}}.

===Notes===
This manipulator may be used to produce an incomplete line of output immediately, e.g. when displaying output from a long-running process, logging activity of multiple threads or logging activity of a program that may crash unexpectedly. An explicit flush of {{lc|std::cout}} is also necessary before a call to {{lc|std::system}}, if the spawned process performs any screen I/O (a common example is {{c|std::system(&quot;pause&quot;)}} on Windows). In most other usual interactive I/O scenarios, {{lc|std::endl}} is redundant when used with {{lc|std::cout}} because any input from {{lc|std::cin}}, output to {{lc|std::cerr}}, or program termination forces a call to {{c|std::cout.flush()}}. 

When a complete line of output needs to be flushed, the {{lc|std::endl}} manipulator may be used.

When every output operation needs to be flushed, the {{lc|std::unitbuf}} manipulator may be used.

===Parameters===
{{par begin}}
{{par | os | reference to output stream }}
{{par end}}

===Return value===

{{tt|os}} (reference to the stream after manipulation)

===Example===
{{example
 | Without std::flush, the output would be the same, but may not appear in real time.
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
template&lt;typename Diff&gt;
void log_progress(Diff d)
{
    std::cout &lt;&lt; &quot;..(&quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(d).count()
              &lt;&lt; &quot; ms)..&quot; &lt;&lt; std::flush;
}
int main()
{
    volatile int sink=0;

    auto t1 = std::chrono::high_resolution_clock::now();
    for(int j=0; j&lt;5; ++j)
    {
        for(int n=0; n&lt;10000; ++n)
            for(int m=0; m&lt;20000; ++m)
                sink += m*n; // do some work
        auto now = std::chrono::high_resolution_clock::now();
        log_progress(now - t1);
    }
    std::cout &lt;&lt; '\n';
}
 | output=
..(450 ms)....(901 ms)....(1350 ms)....(1800 ms)....(2250 ms)..
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc unitbuf}}
{{dsc inc | cpp/io/manip/dsc endl}}
{{dsc inc | cpp/io/basic_ostream/dsc flush | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/manip/flush]]
[[es:cpp/io/manip/flush]]
[[fr:cpp/io/manip/flush]]
[[it:cpp/io/manip/flush]]
[[ja:cpp/io/manip/flush]]
[[pt:cpp/io/manip/flush]]
[[ru:cpp/io/manip/flush]]
[[zh:cpp/io/manip/flush]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/get money</title>
    <ns>0</ns>
    <id>4821</id>
    <revision>
      <id>63327</id>
      <parentid>57905</parentid>
      <timestamp>2013-07-10T01:28:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2266">{{cpp/title|get_money}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip | since=c++11 |1=
template&lt; class MoneyT &gt;
/*unspecified*/ get_money( MoneyT&amp; mon, bool intl = false );
}}

When used in an expression {{c|in &gt;&gt; get_money(mon, intl)}}, parses the character input as a monetary value, as specified by the {{lc|std::money_get}} facet of the locale currently imbued in {{tt|in}}, and stores the value in {{tt|mon}}.

This function behaves as a {{concept|FormattedInputFunction}}.

===Parameters===
{{par begin}}
{{par | mon | variable where monetary value will be written. Can be either {{c|long double}} or {{c|basic_string}}}}
{{par | intl | expects to find required international currency strings if {{c|true}}, expects optional currency symbols otherwise}} 
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|in}} is the name of an output stream of type {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|in &gt;&gt; get_money(mon, intl)}} behaves as if the following code was executed:

{{c|1=
typedef std::istreambuf_iterator&lt;CharT, Traits&gt; Iter;
typedef std::money_get&lt;CharT, Iter&gt; MoneyGet;
std::ios_base::iostate err = std::ios_base::goodbit;
const MoneyGet &amp;mg = std::use_facet&lt;MoneyGet&gt;(in.getloc());
mg.get(Iter(in.rdbuf()), Iter(), intl, in, err, mon);
if (std::ios_base::goodbit != err)
    out.setstate(err);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;
int main()
{
    std::istringstream in(&quot;$1,234.56 2.22 USD  3.33&quot;);
    long double v1, v2;
    std::string v3;
    in.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    in &gt;&gt; std::get_money(v1) &gt;&gt; std::get_money(v2) &gt;&gt; std::get_money(v3, true);

    std::cout &lt;&lt; '&quot;' &lt;&lt; in.str() &lt;&lt; &quot;\&quot; parsed as: &quot;
              &lt;&lt; v1 &lt;&lt; &quot;, &quot; &lt;&lt; v2 &lt;&lt; &quot;, &quot; &lt;&lt; v3 &lt;&lt; '\n';
}
 | output=
&quot;$1,234.56 2.22 USD  3.33&quot; parsed as: 123456, 222, 333
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/io/manip/dsc put_money}}
{{dsc end}}

[[de:cpp/io/manip/get money]]
[[es:cpp/io/manip/get money]]
[[fr:cpp/io/manip/get money]]
[[it:cpp/io/manip/get money]]
[[ja:cpp/io/manip/get money]]
[[pt:cpp/io/manip/get money]]
[[ru:cpp/io/manip/get money]]
[[zh:cpp/io/manip/get money]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/get time</title>
    <ns>0</ns>
    <id>4822</id>
    <revision>
      <id>66696</id>
      <parentid>63328</parentid>
      <timestamp>2013-12-26T18:53:01Z</timestamp>
      <contributor>
        <username>Roysc</username>
        <id>2387</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2131">{{cpp/title|get_time}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip | since=c++11 |
template&lt; class CharT &gt;
/*unspecified*/ get_time( std::tm* tmb, const CharT* fmt);
}}

When used in an expression {{c|in &gt;&gt; get_time(tmb, fmt)}}, parses the character input as a date/time value according to format string {{tt|fmt}} according to the {{lc|std::time_get}} facet of the locale currently imbued in the output stream {{tt|out}}. The resultant value is stored in a {{lc|std::tm}} object pointed to by {{tt|tmb}}.

===Parameters===
{{par begin}}
{{par | tmb | valid pointer to the std::tm object where the result will be stored}}
{{par | fmt | pointer to a null-terminated CharT string specifying the conversion format
{{cpp/locale/time_get/time_get format}}
}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|in}} is the name of an input stream of type {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|in &gt;&gt; get_time(tmb, fmt)}} behaves as if the following code was executed:

{{c|1=
typedef std::istreambuf_iterator&lt;CharT, Traits&gt; Iter;
typedef std::time_get&lt;CharT, Iter&gt; TimeGet;
std::ios_base::iostate err = std::ios_base::goodbit;
const TimeGet&amp; tg = std::use_facet&lt;TimeGet&gt;(in.getloc());
tg.get(Iter(in.rdbuf()), Iter(), in, err, tmb, fmt, fmt + traits::length(fmt));
if (err != std::ios_base::goodbit)
    in.setstate(err);
}}


===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

int main()
{
    std::tm t;
    std::istringstream ss(&quot;2011-Februar-18 23:12:34&quot;);
    ss.imbue(std::locale(&quot;de_DE&quot;));
    ss &gt;&gt; std::get_time(&amp;t, &quot;%Y-%b-%d %H:%M:%S&quot;);
    std::cout &lt;&lt; std::put_time(&amp;t, &quot;%c&quot;) &lt;&lt; '\n';
}
 | output=
Sun Feb 18 23:12:34 2011
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc time_get}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc end}}

[[de:cpp/io/manip/get time]]
[[es:cpp/io/manip/get time]]
[[fr:cpp/io/manip/get time]]
[[it:cpp/io/manip/get time]]
[[ja:cpp/io/manip/get time]]
[[pt:cpp/io/manip/get time]]
[[ru:cpp/io/manip/get time]]
[[zh:cpp/io/manip/get time]]</text>
      <sha1>787ytf5mk3ajecosoh0kzyhkxf1568c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/hex</title>
    <ns>0</ns>
    <id>4676</id>
    <revision>
      <id>57909</id>
      <parentid>49815</parentid>
      <timestamp>2013-06-01T06:03:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2070">{{cpp/title|dec|hex|oct}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; dec( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; hex( std::ios_base&amp; str );
}}
{{dcl | num = 3|
std::ios_base&amp; oct( std::ios_base&amp; str );
}}
{{dcl end}}

Modifies the default numeric base for integer I/O

1) sets the {{tt|basefield}} of the stream {{tt|str}} to {{tt|dec}} as if by calling {{c|str.setf(std::ios_base::dec, std::ios_base::basefield)}}

2) sets the {{tt|basefield}} of the stream {{tt|str}} to {{tt|hex}} as if by calling {{c|str.setf(std::ios_base::hex, std::ios_base::basefield)}}

3) sets the {{tt|basefield}} of the stream {{tt|str}} to {{tt|oct}} as if by calling {{c|str.setf(std::ios_base::oct, std::ios_base::basefield)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::hex}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::hex}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
int main()
{
    std::cout &lt;&lt; &quot;The number 42 in octal:   &quot; &lt;&lt; std::oct &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;The number 42 in decimal: &quot; &lt;&lt; std::dec &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;The number 42 in hex:     &quot; &lt;&lt; std::hex &lt;&lt; 42 &lt;&lt; '\n';
    int n;
    std::istringstream(&quot;2A&quot;) &gt;&gt; std::hex &gt;&gt; n;
    std::cout &lt;&lt; std::dec &lt;&lt; &quot;Parsing \&quot;2A\&quot; as hex gives &quot; &lt;&lt; n &lt;&lt; '\n';
}
 | output=
The number 42 in octal:   52
The number 42 in decimal: 42
The number 42 in hex:     2a
Parsing &quot;2A&quot; as hex gives 42
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc setbase}}
{{dsc inc | cpp/io/manip/dsc showbase}}
{{dsc end}}

[[de:cpp/io/manip/hex]]
[[es:cpp/io/manip/hex]]
[[fr:cpp/io/manip/hex]]
[[it:cpp/io/manip/hex]]
[[ja:cpp/io/manip/hex]]
[[pt:cpp/io/manip/hex]]
[[ru:cpp/io/manip/hex]]
[[zh:cpp/io/manip/hex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/left</title>
    <ns>0</ns>
    <id>4801</id>
    <revision>
      <id>62013</id>
      <parentid>57912</parentid>
      <timestamp>2013-06-16T15:35:38Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2723">{{cpp/title|left|right|internal}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; left( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; right( std::ios_base&amp; str );
}}
{{dcl | num = 3|
std::ios_base&amp; internal( std::ios_base&amp; str );
}}
{{dcl end}}

Modifies the default positioning of the fill characters. {{tt|left}} and {{tt|right}} apply to any output, {{tt|internal}} applies to integer, floating-point, and monetary output. Has no effect on input.

1) sets the {{tt|adjustfield}} of the stream {{tt|str}} to {{tt|left}} as if by calling {{c|str.setf(std::ios_base::left, std::ios_base::adjustfield)}}

2) sets the {{tt|adjustfield}} of the stream {{tt|str}} to {{tt|right}} as if by calling {{c|str.setf(std::ios_base::right, std::ios_base::adjustfield)}}

3) sets the {{tt|adjustfield}} of the stream {{tt|str}} to {{tt|internal}} as if by calling {{c|str.setf(std::ios_base::internal, std::ios_base::adjustfield)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::left}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::left}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;

int main()
{
    std::cout.imbue(std::locale(&quot;en_US.utf8&quot;));
    std::cout &lt;&lt; &quot;Left fill:\n&quot; &lt;&lt; std::left &lt;&lt; std::setfill('*')
              &lt;&lt; std::setw(12) &lt;&lt; -1.23  &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; std::put_money(123, true) &lt;&lt; &quot;\n\n&quot;;

    std::cout &lt;&lt; &quot;Internal fill:\n&quot; &lt;&lt; std::internal
              &lt;&lt; std::setw(12) &lt;&lt; -1.23  &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; std::put_money(123, true) &lt;&lt; &quot;\n\n&quot;;

    std::cout &lt;&lt; &quot;Right fill:\n&quot; &lt;&lt; std::right
              &lt;&lt; std::setw(12) &lt;&lt; -1.23  &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; std::setw(12) &lt;&lt; std::put_money(123, true) &lt;&lt; '\n';
}
 | output=
Left fill:
-1.23*******
0x2a********
USD *1.23***

Internal fill:
-*******1.23
0x********2a
USD ****1.23

Right fill:
*******-1.23
********0x2a
***USD *1.23
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc setw}}
{{dsc inc | cpp/io/manip/dsc setfill}}
{{dsc end}}

[[de:cpp/io/manip/left]]
[[es:cpp/io/manip/left]]
[[fr:cpp/io/manip/left]]
[[it:cpp/io/manip/left]]
[[ja:cpp/io/manip/left]]
[[pt:cpp/io/manip/left]]
[[ru:cpp/io/manip/left]]
[[zh:cpp/io/manip/left]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/put money</title>
    <ns>0</ns>
    <id>4800</id>
    <revision>
      <id>63329</id>
      <parentid>62267</parentid>
      <timestamp>2013-07-10T01:28:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2349">{{cpp/title|put_money}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip | since=c++11 |1=
template&lt; class MoneyT &gt;
/*unspecified*/ put_money( const MoneyT&amp; mon, bool intl = false );
}}

When used in an expression {{c|out &lt;&lt; put_money(mon, intl)}}, converts the monetary value {{tt|mon}} to its character representation as specified by the {{lc|std::money_put}} facet of the locale currently imbued in {{tt|out}}.

This function behaves as a {{concept|FormattedOutputFunction}}

===Parameters===
{{par begin}}
{{par | mon | a monetary value, either {{c|long double}} or {{c|basic_string}}}}
{{par | intl | use international currency strings if {{c|true}}, use currency symbols otherwise}} 
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|out}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}}, then the expression {{c|out &lt;&lt; put_money(mon, intl)}} behaves as if the following code was executed:

{{c|1=
typedef std::ostreambuf_iterator&lt;CharT, Traits&gt; Iter;
typedef std::money_put&lt;CharT, Iter&gt; MoneyPut;
const MoneyPut&amp; mp = std::use_facet&lt;MoneyPut&gt;(out.getloc());
const Iter end = mp.put(Iter(out.rdbuf()), intl, out, out.fill(), mon);
if (end.failed())
    out.setstate(std::ios::badbit);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

int main()
{
    long double mon = 123.45; // or std::string mon = &quot;123.45&quot;;
    std::cout.imbue(std::locale(&quot;en_US.utf8&quot;));
    std::cout &lt;&lt; std::showbase
              &lt;&lt; &quot;en_US: &quot; &lt;&lt; std::put_money(mon) &lt;&lt; &quot; or &quot; &lt;&lt; std::put_money(mon, true) &lt;&lt; '\n';
    std::cout.imbue(std::locale(&quot;ru_RU.utf8&quot;));
    std::cout &lt;&lt; &quot;ru_RU: &quot; &lt;&lt; std::put_money(mon) &lt;&lt; &quot; or &quot; &lt;&lt; std::put_money(mon, true) &lt;&lt; '\n';
    std::cout.imbue(std::locale(&quot;ja_JP.utf8&quot;));
    std::cout &lt;&lt; &quot;ja_JP: &quot; &lt;&lt; std::put_money(mon) &lt;&lt; &quot; or &quot; &lt;&lt; std::put_money(mon, true) &lt;&lt; '\n';
}
 | output=
en_US: $1.23 or USD  1.23
ru_RU: 1.23 руб or 1.23 RUB 
ja_JP: ￥123 or JPY  123
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc inc | cpp/io/manip/dsc get_money}}
{{dsc end}}

[[de:cpp/io/manip/put money]]
[[es:cpp/io/manip/put money]]
[[fr:cpp/io/manip/put money]]
[[it:cpp/io/manip/put money]]
[[ja:cpp/io/manip/put money]]
[[pt:cpp/io/manip/put money]]
[[ru:cpp/io/manip/put money]]
[[zh:cpp/io/manip/put money]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/put time</title>
    <ns>0</ns>
    <id>4649</id>
    <revision>
      <id>63330</id>
      <parentid>61007</parentid>
      <timestamp>2013-07-10T01:28:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2356">{{cpp/title|put_time}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip | since=c++11 |
template&lt; class CharT &gt;
/*unspecified*/ put_time( const std::tm* tmb, const CharT* fmt );
}}

When used in an expression {{c|out &lt;&lt; put_time(tmb, fmt)}}, converts the date and time information from a given calendar time {{tt|tmb}} to a character string according to format string {{tt|fmt}}, as if by calling {{lc|std::strftime}}, {{lc|std::wcsftime}}, or analog (depending on {{tt|CharT}}), according to the {{lc|std::time_put}} facet of the locale currently imbued in the output stream {{tt|out}}.

===Parameters===
{{par begin}}
{{par | tmb | pointer to the calendar time structure as obtained from localtime() or gmtime()}}
{{par | fmt | pointer to a null-terminated CharT string specifying the format of conversion. 
{{cpp/chrono/c/strftime format}}
}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|out}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}}, then the expression {{c|out &lt;&lt; put_time(tmb, fmt)}} behaves as if the following code was executed:

{{c|1=
typedef std::ostreambuf_iterator&lt;CharT, Traits&gt; Iter;
typedef std::time_put&lt;CharT, Iter&gt; TimePut;
const TimePut&amp; tp = std::use_facet&lt;TimePut&gt;(out.getloc());
const Iter end = tp.put(Iter(out.rdbuf()), out, out.fill(), tmb, fmt, fmt + Traits::length(fmt));
if (end.failed())
    out.setstate(std::ios_base::badbit);
}}


===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

int main()
{
    std::time_t t = std::time(nullptr);
    std::tm tm = *std::localtime(&amp;t);
    std::cout.imbue(std::locale(&quot;ru_RU.utf8&quot;));
    std::cout &lt;&lt; &quot;ru_RU: &quot; &lt;&lt; std::put_time(&amp;tm, &quot;%c %Z&quot;) &lt;&lt; '\n';
    std::cout.imbue(std::locale(&quot;ja_JP.utf8&quot;));
    std::cout &lt;&lt; &quot;ja_JP: &quot; &lt;&lt; std::put_time(&amp;tm, &quot;%c %Z&quot;) &lt;&lt; '\n';
}
 | output=
ru_RU: Ср. 28 дек. 2011 10:21:16 EST
ja_JP: 2011年12月28日 10時21分16秒 EST
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc time_put}}
{{dsc inc | cpp/chrono/c/dsc strftime}}
{{dsc inc | cpp/chrono/c/dsc wcsftime}}
{{dsc end}}

[[de:cpp/io/manip/put time]]
[[es:cpp/io/manip/put time]]
[[fr:cpp/io/manip/put time]]
[[it:cpp/io/manip/put time]]
[[ja:cpp/io/manip/put time]]
[[pt:cpp/io/manip/put time]]
[[ru:cpp/io/manip/put time]]
[[zh:cpp/io/manip/put time]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/quoted</title>
    <ns>0</ns>
    <id>12913</id>
    <revision>
      <id>69838</id>
      <parentid>68970</parentid>
      <timestamp>2014-04-27T21:00:59Z</timestamp>
      <contributor>
        <username>Langlaw</username>
        <id>3037</id>
      </contributor>
      <comment>Fix apostroph symbol: ’ -&gt; '</comment>
      <text xml:space="preserve" bytes="4468">{{cpp/title|quoted}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|iomanip}}
{{dcl item | since=c++14 |num = 1 | 1=
template&lt; class CharT &gt;
/*unspecified*/ quoted(const CharT* s,
                       CharT delim=CharT('&quot;'), CharT escape=CharT('\\'));
}}
{{dcl item | since=c++14 |num = 2 | 1=
template&lt; class CharT, class Traits, class Allocator &gt;
/*unspecified*/ quoted(const std::basic_string&lt;CharT, Traits, Allocator&gt;&amp; s,
                       CharT delim=CharT('&quot;'), CharT escape=CharT('\\'));
}}
{{dcl item | since=c++14 |num = 3 | 1=
template&lt; class CharT, class Traits, class Allocator &gt;
/*unspecified*/ quoted(std::basic_string&lt;CharT, Traits, Allocator&gt;&amp; s,
                       CharT delim=CharT('&quot;'), CharT escape=CharT('\\'));
}}
{{dcl end}}

Allows insertion and extraction of quoted strings, such as the ones found in CSV or XML.

@1,2@ When used in an expression {{c|out &lt;&lt; quoted(s, delim, escape)}}, where {{tt|out}} is an output stream with {{tt|char_type}} equal to {{tt|CharT}} and, for overload 2, {{tt|traits_type}} equal to {{tt|Traits}}, behaves as a {{concept|FormattedOutputFunction}}, which inserts into {{c|out}} a sequence of characters {{tt|seq}} constructed as follows:
:@a@ First, the character {{tt|delim}} is added to the sequence
:@b@ Then every character from {{tt|s}}, except if the next character to output equals {{tt|delim}} or equals {{tt|escape}} (as determined by the stream's {{tt|traits_type::eq}}), then first appends an extra copy of {{tt|escape}}
:@c@ In the end, {{tt|delim}} is appended to {{tt|seq}} once more
:Then, if {{tt|seq.size() &lt; out.width()}}, adds {{tt|out.width()-seq.size()}} copies of the fill character {{tt|out.fill()}} either at the end of the sequence (if {{tt|ios_base::left}} is set in {{tt|out.flags()}}) or at the beginning of the sequence (in all other cases). 
:Finally, outputs each character from the resulting sequence as if by calling {{c|out.rdbuf()-&gt;sputn(seq, n)}}, where {{c|1=n=std::max(out.width(), seq.size())}} and {{c|out.width(0)}} to cancel the effects of {{lc|std::setw}}, if any.
@3@ When used in an expression {{c|in &gt;&gt; quoted(s, delim, escape)}}, where {{tt|in}} is an input stream with {{tt|char_type}} equal to {{tt|CharT}} and {{tt|traits_type}} equal to {{tt|Traits}}, extracts characters from {{c|in}}, using {{lc|std::basic_istream::operator&gt;&gt;}}, according to the following rules:
:@a@ If the first character extracted does not equal {{tt|delim}} (as determined by the stream's {{tt|traits_type::eq}}), then simply performs {{c|in &gt;&gt; s}}.
:@b@ Otherwise (if the first character is the delimiter):
::@1@ Turns off the {{lc|skipws}} flag on the input stream
::@2@ Empties the destination string by calling {{c|s.clear()}}
::@3@ Extracts characters from {{tt|in}} and appends them to {{tt|s}}, except that whenever an {{tt|escape}} character is extracted, it is ignored and the next character is appended to {{tt|s}}. Extraction stops when {{c|!in{{==}}true}} or when an unescaped {{tt|delim}} character is found.
::@4@ Discards the final (unescaped) {{tt|delim}} character.
::@5@ Restores the {{lc|skipws}} flag on the input stream to its original value.

===Parameters===
{{par begin}}
{{par | s | the string to insert or extract }}
{{par | delim | the character to use as the delimiter, defaults to {{tt|&quot;}} }} 
{{par | escape | the character to use as the escape character, defaults to {{tt|\}} }} 
{{par end}}

===Return value===
Returns an object of unspecified type such that the described behavior takes place.

===Exceptions===
Throws {{lc|std::ios_base::failure}} if {{tt|operator&gt;&gt;}} or {{tt|operator&lt;&lt;}} throws.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;sstream&gt;

int main()
{
    std::stringstream ss;
    std::string in = &quot;String with spaces, and embedded \&quot;quotes\&quot; too&quot;;
    std::string out;

    ss &lt;&lt; std::quoted(in);
    std::cout &lt;&lt; &quot;in:  '&quot; &lt;&lt; in &lt;&lt; &quot;'\n&quot;
              &lt;&lt; &quot;stored as '&quot; &lt;&lt; ss.str() &lt;&lt; &quot;'\n&quot;;

    ss &gt;&gt; std::quoted(out);
    std::cout &lt;&lt; &quot;out: '&quot; &lt;&lt; out &lt;&lt; &quot;'\n&quot;;
}
 | output=
in:  'String with spaces, and embedded &quot;quotes&quot; too'
stored as '&quot;String with spaces, and embedded \&quot;quotes\&quot; too&quot;'
out:  'String with spaces, and embedded &quot;quotes&quot; too'
}}

===See also===

[[de:cpp/io/manip/quoted]]
[[es:cpp/io/manip/quoted]]
[[fr:cpp/io/manip/quoted]]
[[it:cpp/io/manip/quoted]]
[[ja:cpp/io/manip/quoted]]
[[pt:cpp/io/manip/quoted]]
[[ru:cpp/io/manip/quoted]]
[[zh:cpp/io/manip/quoted]]</text>
      <sha1>k1u3n9a392h0wzjwmsklvpku8nky4k6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/resetiosflags</title>
    <ns>0</ns>
    <id>4825</id>
    <revision>
      <id>57917</id>
      <parentid>49819</parentid>
      <timestamp>2013-06-01T06:03:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1966">{{cpp/title|resetiosflags}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
/*unspecified*/ resetiosflags( std::ios_base::fmt_flags mask );
}}

When used in an expression {{c|out &lt;&lt; resetiosflags(mask)}} or {{c|in &gt;&gt; resetiosflags(mask)}}, clears all format flags of the stream {{tt|out}} or {{tt|in}} as specified by the {{tt|mask}}.

===Parameters===
{{par begin}}
{{par | mask | bitmask of the flags to clear}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|str}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}} or {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|str &lt;&lt; resetiosflags(mask)}} or {{c|str &gt;&gt; resetiosflags(mask)}} behaves as if the following code was executed:

{{c|1=
str.setf(std::ios_base::fmtflags(0), mask);
}}

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
int main()
{
    std::istringstream in(&quot;10 010 10 010 10 010&quot;);
    int n1, n2;
    in &gt;&gt; std::oct &gt;&gt; n1 &gt;&gt; n2;
    std::cout &lt;&lt; &quot;Parsing \&quot;10 010\&quot; with std::oct gives:  &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; '\n';
    in &gt;&gt; std::dec &gt;&gt; n1 &gt;&gt; n2;
    std::cout &lt;&lt; &quot;Parsing \&quot;10 010\&quot; with std::dec gives:  &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; '\n';
    in &gt;&gt; std::resetiosflags(std::ios_base::basefield) &gt;&gt; n1 &gt;&gt; n2;
    std::cout &lt;&lt; &quot;Parsing \&quot;10 010\&quot; with autodetect gives: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; '\n';
}
 | output=
Parsing &quot;10 010&quot; with std::oct gives:  8 8
Parsing &quot;10 010&quot; with std::dec gives:  10 10
Parsing &quot;10 010&quot; with autodetect gives: 10 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc setf | mem=std::ios_base}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/resetiosflags]]
[[es:cpp/io/manip/resetiosflags]]
[[fr:cpp/io/manip/resetiosflags]]
[[it:cpp/io/manip/resetiosflags]]
[[ja:cpp/io/manip/resetiosflags]]
[[pt:cpp/io/manip/resetiosflags]]
[[ru:cpp/io/manip/resetiosflags]]
[[zh:cpp/io/manip/resetiosflags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/setbase</title>
    <ns>0</ns>
    <id>4677</id>
    <revision>
      <id>65685</id>
      <parentid>65683</parentid>
      <timestamp>2013-09-26T10:15:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>&quot;source&quot; seems to be the recommended template</comment>
      <text xml:space="preserve" bytes="2428">{{cpp/title|setbase}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
/*unspecified*/ setbase( int base );
}}

Sets the numeric base of the stream. When used in an expression {{c|out &lt;&lt; setbase(base)}} or {{c|in &gt;&gt; setbase(base)}}, changes the {{tt|basefield}} flag of the stream {{tt|out}} or {{tt|in}}, depending on the value of {{tt|base}}: 

* the value {{c|16}} sets {{tt|basefield}} to {{lc|std::ios_base::hex}}
* the value {{c|8}} sets {{lc|std::ios_base::oct}}
* the value {{c|10}} sets {{lc|std::ios_base::dec}}.

Values of {{tt|base}} other than 8, 10, or 16 reset {{tt|basefield}} to zero, which corresponds to decimal output and prefix-dependent input.

===Parameters===
{{par begin}}
{{par | base | new value for basefield}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|str}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}} or {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|str &lt;&lt; setbase(base)}} or {{c|str &gt;&gt; setbase(base)}} behaves as if the following code was executed:

{{source|1=
str.setf(base ==  8 ? std::ios_base::oct :
            base == 10 ? std::ios_base::dec :
                base == 16 ? std::ios_base::hex :
                     std::ios_base::fmtflags(0),
         std::ios_base::basefield);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;iomanip&gt;
int main()
{
    std::cout &lt;&lt; &quot;Parsing string \&quot;10 0x10 010\&quot;\n&quot;;

    int n1, n2, n3;
    std::istringstream s(&quot;10 0x10 010&quot;);
    s &gt;&gt; std::setbase(16) &gt;&gt; n1 &gt;&gt; n2 &gt;&gt; n3;
    std::cout &lt;&lt; &quot;hexadecimal parse: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';

    s.clear();
    s.seekg(0);
    s &gt;&gt; std::setbase(0) &gt;&gt; n1 &gt;&gt; n2 &gt;&gt; n3;
    std::cout &lt;&lt; &quot;prefix-dependent parse: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;hex output: &quot; &lt;&lt; std::setbase(16)
              &lt;&lt; std::showbase &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';
}
 | output=
Parsing string &quot;10 0x10 010&quot;
hexadecimal parse: 16 16 16
prefix-dependent parse: 10 16 8
hex output: 0xa 0x10 0x8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc hex}}
{{dsc inc | cpp/io/manip/dsc showbase}}
{{dsc end}}

[[de:cpp/io/manip/setbase]]
[[es:cpp/io/manip/setbase]]
[[fr:cpp/io/manip/setbase]]
[[it:cpp/io/manip/setbase]]
[[ja:cpp/io/manip/setbase]]
[[pt:cpp/io/manip/setbase]]
[[ru:cpp/io/manip/setbase]]
[[zh:cpp/io/manip/setbase]]</text>
      <sha1>ajnvppdwv4oabvncf2y6fccv5w3gfqf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/setfill</title>
    <ns>0</ns>
    <id>4802</id>
    <revision>
      <id>57921</id>
      <parentid>49821</parentid>
      <timestamp>2013-06-01T06:03:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1359">{{cpp/title|setfill}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
template&lt; class CharT &gt;
/*unspecified*/ setfill( CharT c );
}}

When used in an expression {{c|out &lt;&lt; setfill(c)}} sets the fill character of the stream {{tt|out}} to {{tt|c}}.

===Parameters===
{{par begin}}
{{par | c | new value for the fill character}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|out}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}}, then the expression {{c|out &lt;&lt; setfill(n)}} behaves as if the following code was executed:

{{c|1=
out.fill(n);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
int main()
{
    std::cout &lt;&lt; &quot;default fill: &quot; &lt;&lt; std::setw(10) &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;setfill('*'): &quot; &lt;&lt; std::setfill('*')
                                  &lt;&lt; std::setw(10) &lt;&lt; 42 &lt;&lt; '\n';
}
 | output=
default fill:         42
setfill('*'): ********42
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ios/dsc fill | mem=std::basic_ios}}
{{dsc inc | cpp/io/manip/dsc left}}
{{dsc inc | cpp/io/manip/dsc setw}}
{{dsc end}}

[[de:cpp/io/manip/setfill]]
[[es:cpp/io/manip/setfill]]
[[fr:cpp/io/manip/setfill]]
[[it:cpp/io/manip/setfill]]
[[ja:cpp/io/manip/setfill]]
[[pt:cpp/io/manip/setfill]]
[[ru:cpp/io/manip/setfill]]
[[zh:cpp/io/manip/setfill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/setiosflags</title>
    <ns>0</ns>
    <id>4826</id>
    <revision>
      <id>57924</id>
      <parentid>49822</parentid>
      <timestamp>2013-06-01T06:04:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1556">{{cpp/title|setiosflags}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
/*unspecified*/ setiosflags( std::ios_base::fmt_flags mask );
}}

When used in an expression {{c|out &lt;&lt; setiosflags(mask)}} or {{c|in &gt;&gt; setiosflags(mask)}}, sets all format flags of the stream {{tt|out}} or {{tt|in}} as specified by the {{tt|mask}}.

===Parameters===
{{par begin}}
{{par | mask | bitmask of the flags to set}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|str}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}} or {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|str &lt;&lt; setiosflags(mask)}} or {{c|str &gt;&gt; setiosflags(mask)}} behaves as if the following code was executed:

{{c|1=
str.setf(mask);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

int main()
{
    std::cout &lt;&lt;  std::resetiosflags(std::ios_base::dec) 
              &lt;&lt;  std::setiosflags(  std::ios_base::hex
                                   {{!}} std::ios_base::uppercase
                                   {{!}} std::ios_base::showbase) &lt;&lt; 42 &lt;&lt; '\n';
}
 | output=
0X2A
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc setf | mem=std::ios_base}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc end}}

[[de:cpp/io/manip/setiosflags]]
[[es:cpp/io/manip/setiosflags]]
[[fr:cpp/io/manip/setiosflags]]
[[it:cpp/io/manip/setiosflags]]
[[ja:cpp/io/manip/setiosflags]]
[[pt:cpp/io/manip/setiosflags]]
[[ru:cpp/io/manip/setiosflags]]
[[zh:cpp/io/manip/setiosflags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/setprecision</title>
    <ns>0</ns>
    <id>4803</id>
    <revision>
      <id>57925</id>
      <parentid>49823</parentid>
      <timestamp>2013-06-01T06:04:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1700">{{cpp/title|setprecision}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
/*unspecified*/ setprecision( int n );
}}

When used in an expression {{c|out &lt;&lt; setprecision(n)}} or {{c|in &gt;&gt; setprecision(n)}}, sets the {{tt|precision}} parameter of the stream {{tt|out}} or {{tt|in}} to exactly {{tt|n}}. 

===Parameters===
{{par begin}}
{{par | n | new value for precision}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|str}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}} or an input stream of type {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|str &lt;&lt; setprecision(n)}} or {{c|str &gt;&gt; setprecision(n)}} behaves as if the following code was executed:

{{c|1=
str.precision(n);
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;cmath&gt;
#include &lt;limits&gt;
int main()
{
    const long double pi = std::acos(-1.L);
    std::cout &lt;&lt; &quot;default precision (6): &quot; &lt;&lt; pi &lt;&lt; '\n'
              &lt;&lt; &quot;std::precision(10):    &quot; &lt;&lt; std::setprecision(10) &lt;&lt; pi &lt;&lt; '\n'
              &lt;&lt; &quot;max precision:         &quot;
              &lt;&lt; std::setprecision(std::numeric_limits&lt;long double&gt;::digits10)
              &lt;&lt; pi &lt;&lt; '\n';
}
 | output=
default precision (6): 3.14159
std::precision(10):    3.141592654
max precision:         3.14159265358979324
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc fixed}}
{{dsc end}}

[[de:cpp/io/manip/setprecision]]
[[es:cpp/io/manip/setprecision]]
[[fr:cpp/io/manip/setprecision]]
[[it:cpp/io/manip/setprecision]]
[[ja:cpp/io/manip/setprecision]]
[[pt:cpp/io/manip/setprecision]]
[[ru:cpp/io/manip/setprecision]]
[[zh:cpp/io/manip/setprecision]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/setw</title>
    <ns>0</ns>
    <id>4691</id>
    <revision>
      <id>69227</id>
      <parentid>68857</parentid>
      <timestamp>2014-03-31T00:36:07Z</timestamp>
      <contributor>
        <ip>128.252.20.177</ip>
      </contributor>
      <comment>typo in third output case for width resetting, &quot;osteam&quot; changed to &quot;ostream&quot;</comment>
      <text xml:space="preserve" bytes="2542">{{cpp/title|setw}}
{{cpp/io/manip/navbar}}
{{ddcl | header=iomanip |
/*unspecified*/ setw( int n );
}}

When used in an expression {{c|out &lt;&lt; setw(n)}} or {{c|in &gt;&gt; setw(n)}}, sets the {{tt|width}} parameter of the stream {{tt|out}} or {{tt|in}} to exactly {{tt|n}}. 

===Parameters===
{{par begin}}
{{par | n | new value for width}}
{{par end}}

===Return value===

Returns an object of unspecified type such that if {{tt|str}} is the name of an output stream of type {{c|std::basic_ostream&lt;CharT, Traits&gt;}} or {{c|std::basic_istream&lt;CharT, Traits&gt;}}, then the expression {{c|str &lt;&lt; setw(n)}} or {{c|str &gt;&gt; setw(n)}} behaves as if the following code was executed:

{{c|1=
str.width(n);
}}

===Notes===

The width property of the stream will be reset to zero (meaning &quot;unspecified&quot;) if any of the following functions are called:
* Input
:* {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&gt;&gt;(basic_istream&amp;, basic_string&amp;)}}
:* {{ltt|cpp/io/basic_istream/operator_gtgt2|operator&gt;&gt;(basic_ostream&amp;, char*)}}
* Output
:* Overloads 1-7 of {{ltt|cpp/io/basic_ostream/operator_ltlt|basic_ostream::operator&lt;&lt;()}} (at Stage 3 of {{ltt|cpp/locale/num_put/put|num_put::put()}})
:* {{ltt|cpp/io/basic_ostream/operator_ltlt2|operator&lt;&lt;(basic_ostream&amp;, char)}} and {{ltt|cpp/io/basic_ostream/operator_ltlt2|operator&lt;&lt;(basic_ostream&amp;, char*)}}
:* {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&lt;&lt;(basic_ostream&amp;, basic_string&amp;)}}
:* {{lc|std::put_money}} (inside {{ltt|cpp/locale/money_put/put|money_put::put()}})
:* {{lc|std::quoted}} (when used with an output stream)

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

int main()
{
    std::cout &lt;&lt; &quot;no setw:&quot; &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;setw(6):&quot; &lt;&lt; std::setw(6) &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;setw(6), several elements: &quot; &lt;&lt; 89 &lt;&lt; std::setw(6) &lt;&lt; 12 &lt;&lt; 34 &lt;&lt; '\n';
    std::istringstream is(&quot;hello, world&quot;);
    char arr[10];
    is &gt;&gt; std::setw(6) &gt;&gt; arr;
    std::cout &lt;&lt; &quot;Input from \&quot;&quot; &lt;&lt; is.str() &lt;&lt; &quot;\&quot; with setw(6) gave \&quot;&quot;
              &lt;&lt; arr &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
no setw:42
setw(6):    42
setw(6), several elements: 89    1234
Input from &quot;hello, world&quot; with setw(6) gave &quot;hello&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/ios_base/dsc width | mem=std::ios_base}}
{{dsc inc | cpp/io/manip/dsc setfill}}
{{dsc end}}

[[de:cpp/io/manip/setw]]
[[es:cpp/io/manip/setw]]
[[fr:cpp/io/manip/setw]]
[[it:cpp/io/manip/setw]]
[[ja:cpp/io/manip/setw]]
[[pt:cpp/io/manip/setw]]
[[ru:cpp/io/manip/setw]]
[[zh:cpp/io/manip/setw]]</text>
      <sha1>1eizbyo1x4igxts3z5ezi0b3nurbj84</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/showbase</title>
    <ns>0</ns>
    <id>3069</id>
    <revision>
      <id>57929</id>
      <parentid>49825</parentid>
      <timestamp>2013-06-01T06:04:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2189">{{cpp/title|showbase|noshowbase}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; showbase( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; noshowbase( std::ios_base&amp; str );
}}
{{dcl end}}

1) enables the {{tt|showbase}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::showbase)}}

2) disables the {{tt|showbase}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::showbase)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::showbase}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::showbase}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
int main()
{
    // showbase affects the output of octals and hexadecimals
    std::cout &lt;&lt; std::hex
              &lt;&lt; &quot;showbase: &quot; &lt;&lt; std::showbase &lt;&lt; 42 &lt;&lt; '\n'
              &lt;&lt; &quot;noshowbase: &quot; &lt;&lt; std::noshowbase &lt;&lt; 42 &lt;&lt; '\n';

    // and both input and output of monetary values
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    long double val = 0;
    std::istringstream is(&quot;3.14&quot;);
    is &gt;&gt; std::showbase &gt;&gt; std::get_money(val);
    std::cout &lt;&lt; &quot;With showbase, parsing 3.14 as money gives &quot; &lt;&lt; val &lt;&lt; '\n';
    is.seekg(0);
    is &gt;&gt; std::noshowbase &gt;&gt; std::get_money(val);
    std::cout &lt;&lt; &quot;Without showbase, parsing 3.14 as money gives &quot; &lt;&lt; val &lt;&lt; '\n';
}
 | output=
showbase: 0x2a
noshowbase: 2a
With showbase, parsing 3.14 as money gives 0
Without showbase, parsing 3.14 as money gives 314
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/showbase]]
[[es:cpp/io/manip/showbase]]
[[fr:cpp/io/manip/showbase]]
[[it:cpp/io/manip/showbase]]
[[ja:cpp/io/manip/showbase]]
[[pt:cpp/io/manip/showbase]]
[[ru:cpp/io/manip/showbase]]
[[zh:cpp/io/manip/showbase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/showpoint</title>
    <ns>0</ns>
    <id>4694</id>
    <revision>
      <id>57930</id>
      <parentid>49826</parentid>
      <timestamp>2013-06-01T06:04:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1703">{{cpp/title|showpoint|noshowpoint}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; showpoint( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; noshowpoint( std::ios_base&amp; str );
}}
{{dcl end}}

Enables or disables the unconditional inclusion of the decimal point character in floating-point output. Has no effect on input.

1) enables the {{tt|showpoint}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::showpoint)}}

2) disables the {{tt|showpoint}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::showpoint)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::showpoint}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::showpoint}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;1.0 with showpoint: &quot; &lt;&lt; std::showpoint &lt;&lt; 1.0 &lt;&lt; '\n'
              &lt;&lt; &quot;1.0 with noshowpoint: &quot; &lt;&lt; std::noshowpoint &lt;&lt; 1.0 &lt;&lt; '\n';
}
 | output=
1.0 with showpoint: 1.00000
1.0 with noshowpoint: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/showpoint]]
[[es:cpp/io/manip/showpoint]]
[[fr:cpp/io/manip/showpoint]]
[[it:cpp/io/manip/showpoint]]
[[ja:cpp/io/manip/showpoint]]
[[pt:cpp/io/manip/showpoint]]
[[ru:cpp/io/manip/showpoint]]
[[zh:cpp/io/manip/showpoint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/showpos</title>
    <ns>0</ns>
    <id>4692</id>
    <revision>
      <id>57931</id>
      <parentid>49827</parentid>
      <timestamp>2013-06-01T06:04:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1678">{{cpp/title|showpos|noshowpos}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; showpos( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; noshowpos( std::ios_base&amp; str );
}}
{{dcl end}}

Enables or disables the display of the plus sign {{c|'+'}} in non-negative integer output. Has no effect on input.

1) enables the {{tt|showpos}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::showpos)}}

2) disables the {{tt|showpos}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::showpos)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::showpos}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::showpos}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
        std::cout &lt;&lt; &quot;showpos: &quot; &lt;&lt; std::showpos &lt;&lt; 42 &lt;&lt; ' ' &lt;&lt; 3.14 &lt;&lt; ' ' &lt;&lt; 0 &lt;&lt; '\n'
                  &lt;&lt; &quot;noshowpos: &quot; &lt;&lt; std::noshowpos &lt;&lt; 42 &lt;&lt; ' ' &lt;&lt; 3.14 &lt;&lt; ' ' &lt;&lt; 0 &lt;&lt; '\n';
}
 | output=
showpos: +42 +3.14 +0
noshowpos: 42 3.14 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/showpos]]
[[es:cpp/io/manip/showpos]]
[[fr:cpp/io/manip/showpos]]
[[it:cpp/io/manip/showpos]]
[[ja:cpp/io/manip/showpos]]
[[pt:cpp/io/manip/showpos]]
[[ru:cpp/io/manip/showpos]]
[[zh:cpp/io/manip/showpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/skipws</title>
    <ns>0</ns>
    <id>4824</id>
    <revision>
      <id>57934</id>
      <parentid>49828</parentid>
      <timestamp>2013-06-01T06:04:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2103">{{cpp/title|skipws|noskipws}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; skipws( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; noskipws( std::ios_base&amp; str );
}}
{{dcl end}}

Enables or disables skipping of leading whitespace by the formatted input functions (enabled by default). Has no effect on output.

1) enables the {{tt|skipws}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::skipws)}}

2) disables the {{tt|skipws}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::skipws)}}

The whitespace skipping is performed by the constructor of {{lc|std::basic_istream::sentry}}, which reads and discards the characters classified as whitespace by the {{lc|std::ctype}} facet of the stream's imbued locale.

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::noskipws}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::noskipws}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
int main()
{
    char c1, c2, c3;
    std::istringstream(&quot;a b c&quot;) &gt;&gt; c1 &gt;&gt; c2 &gt;&gt; c3;
    std::cout &lt;&lt; &quot;Default  behavior: c1 = &quot; &lt;&lt; c1 &lt;&lt; &quot; c2 = &quot; &lt;&lt; c2 &lt;&lt; &quot; c3 = &quot; &lt;&lt; c3 &lt;&lt; '\n';
    std::istringstream(&quot;a b c&quot;) &gt;&gt; std::noskipws &gt;&gt; c1 &gt;&gt; c2 &gt;&gt; c3;
    std::cout &lt;&lt; &quot;noskipws behavior: c1 = &quot; &lt;&lt; c1 &lt;&lt; &quot; c2 = &quot; &lt;&lt; c2 &lt;&lt; &quot; c3 = &quot; &lt;&lt; c3 &lt;&lt; '\n';
}
 | output=
Default  behavior: c1 = a c2 = b c3 = c
noskipws behavior: c1 = a c2 =   c3 = b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/skipws]]
[[es:cpp/io/manip/skipws]]
[[fr:cpp/io/manip/skipws]]
[[it:cpp/io/manip/skipws]]
[[ja:cpp/io/manip/skipws]]
[[pt:cpp/io/manip/skipws]]
[[ru:cpp/io/manip/skipws]]
[[zh:cpp/io/manip/skipws]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/unitbuf</title>
    <ns>0</ns>
    <id>4820</id>
    <revision>
      <id>57935</id>
      <parentid>49829</parentid>
      <timestamp>2013-06-01T06:04:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2559">{{cpp/title|unitbuf|nounitbuf}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; unitbuf( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; nounitbuf( std::ios_base&amp; str );
}}
{{dcl end}}

Enables or disables automatic flushing of the output stream after any output operation. Has no effect on input.

1) enables the {{tt|unitbuf}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::unitbuf)}}

2) disables the {{tt|unitbuf}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::unitbuf)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::unitbuf}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::unitbuf}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Notes===
Flushing is performed in the destructor of the {{lc|std::basic_ostream::sentry}} object, which calls {{c|str.rdbuf()-&gt;pubsync()}} if {{c|1=str.flags() &amp; std::ios_base::unitbuf == true}}.

The standard output objects {{lc|std::cerr}} and {{lc|std::wcerr}} have their {{tt|unitbuf}} bit set by default.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 | Without std::unitbuf or another explicit flush, the output is the same, but does not appear in real time.
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;

template&lt;typename Diff&gt;
void log_progress(Diff d)
{
    std::cout &lt;&lt; &quot;..(&quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::milliseconds&gt;(d).count()
              &lt;&lt; &quot; ms)..&quot;;
}

int main()
{
    volatile int sink = 0;
    std::cout &lt;&lt; std::unitbuf; // enable automatic flushing

    auto t1 = std::chrono::high_resolution_clock::now();
    for (int j = 0; j &lt; 5; ++j)
    {
        for (int n = 0; n &lt; 10000; ++n)
            for (int m = 0; m &lt; 20000; ++m)
                sink += m * n; // do some work
        auto now = std::chrono::high_resolution_clock::now();
        log_progress(now - t1);
    }
    std::cout &lt;&lt; '\n';
}
 | output=
..(450 ms)....(902 ms)....(1352 ms)....(1802 ms)....(2252 ms)..
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc flush}}
{{dsc inc | cpp/io/manip/dsc endl}}
{{dsc end}}

[[de:cpp/io/manip/unitbuf]]
[[es:cpp/io/manip/unitbuf]]
[[fr:cpp/io/manip/unitbuf]]
[[it:cpp/io/manip/unitbuf]]
[[ja:cpp/io/manip/unitbuf]]
[[pt:cpp/io/manip/unitbuf]]
[[ru:cpp/io/manip/unitbuf]]
[[zh:cpp/io/manip/unitbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/uppercase</title>
    <ns>0</ns>
    <id>4799</id>
    <revision>
      <id>57938</id>
      <parentid>49830</parentid>
      <timestamp>2013-06-01T06:04:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1953">{{cpp/title|uppercase|nouppercase}}
{{cpp/io/manip/navbar}}
{{dcl begin}}
{{dcl header|ios}}
{{dcl | num = 1|
std::ios_base&amp; uppercase( std::ios_base&amp; str );
}}
{{dcl | num = 2|
std::ios_base&amp; nouppercase( std::ios_base&amp; str );
}}
{{dcl end}}

Enables the use of uppercase characters in floating-point and hexadecimal integer output. Has no effect on input.

1) enables the {{tt|uppercase}} flag in the stream {{tt|str}} as if by calling {{c|str.setf(std::ios_base::uppercase)}}

2) disables the {{tt|uppercase}} flag in the stream {{tt|str}} as if by calling {{c|str.unsetf(std::ios_base::uppercase)}}

This is an I/O manipulator, it may be called with an expression such as {{c|out &lt;&lt; std::uppercase}} for any {{tt|out}} of type {{lc|std::basic_ostream}} or with an expression such as {{c|in &gt;&gt; std::uppercase}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | str | reference to I/O stream }}
{{par end}}

===Return value===

{{tt|str}} (reference to the stream after manipulation)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase
              &lt;&lt; &quot;0x2a with uppercase: &quot; &lt;&lt; std::uppercase &lt;&lt; 0x2a &lt;&lt; '\n'
              &lt;&lt; &quot;0x2a with nouppercase: &quot; &lt;&lt; std::nouppercase &lt;&lt; 0x2a &lt;&lt; '\n'
              &lt;&lt; &quot;1e-10 with uppercase: &quot; &lt;&lt; std::uppercase &lt;&lt; 1e-10 &lt;&lt; '\n'
              &lt;&lt; &quot;1e-10 with nouppercase: &quot; &lt;&lt; std::nouppercase &lt;&lt; 1e-10 &lt;&lt; '\n';
}
 | output=
0x2a with uppercase: 0X2A
0x2a with nouppercase: 0x2a
1e-10 with uppercase: 1E-10
1e-10 with nouppercase: 1e-10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc resetiosflags}}
{{dsc inc | cpp/io/manip/dsc setiosflags}}
{{dsc end}}

[[de:cpp/io/manip/uppercase]]
[[es:cpp/io/manip/uppercase]]
[[fr:cpp/io/manip/uppercase]]
[[it:cpp/io/manip/uppercase]]
[[ja:cpp/io/manip/uppercase]]
[[pt:cpp/io/manip/uppercase]]
[[ru:cpp/io/manip/uppercase]]
[[zh:cpp/io/manip/uppercase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/manip/ws</title>
    <ns>0</ns>
    <id>4749</id>
    <revision>
      <id>66423</id>
      <parentid>63269</parentid>
      <timestamp>2013-11-21T21:15:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>slicker example</comment>
      <text xml:space="preserve" bytes="1769">{{cpp/title|ws}}
{{cpp/io/manip/navbar}}
{{ddcl | header=istream |
template&lt; class CharT, class Traits &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; ws( std::basic_istream&lt;CharT, Traits&gt;&amp; is );
}}

Discards leading whitespace from an input stream.

Behaves as an {{concept|UnformattedInputFunction}}, except that {{c|is.gcount()}} is not modified. After constructing and checking the sentry object, extracts characters from the stream and discards them until any one of the following conditions occurs:

* end of file condition occurs in the input sequence (in which case the function calls {{c|setstate(eofbit)}} but does not set {{tt|failbit}}.

* the next available character {{tt|c}} in the input sequence is not whitespace as determined by {{c|std::isspace(c, is.getloc())}}. The non-whitespace character is not extracted.

This is an input-only I/O manipulator, it may be called with an expression such as {{c|in &gt;&gt; std::ws}} for any {{tt|in}} of type {{lc|std::basic_istream}}.

===Parameters===
{{par begin}}
{{par | is | reference to input stream }}
{{par end}}

===Return value===

{{tt|is}} (reference to the stream after extraction of consecutive whitespace)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::istringstream s(&quot;     this is a test&quot;);
    std::string line;
    getline(s &gt;&gt; std::ws, line);
    std::cout &lt;&lt; &quot;ws + getline returns: \&quot;&quot; &lt;&lt; line &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
ws + getline returns: &quot;this is a test&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc ignore| mem=std::basic_istream}}
{{dsc end}}

[[de:cpp/io/manip/ws]]
[[es:cpp/io/manip/ws]]
[[fr:cpp/io/manip/ws]]
[[it:cpp/io/manip/ws]]
[[ja:cpp/io/manip/ws]]
[[pt:cpp/io/manip/ws]]
[[ru:cpp/io/manip/ws]]
[[zh:cpp/io/manip/ws]]</text>
      <sha1>qqfimuknpkcdtzn2gwk88xidzi0ruxv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ofstream</title>
    <ns>0</ns>
    <id>10280</id>
    <redirect title="cpp/io/basic ofstream" />
    <revision>
      <id>48771</id>
      <timestamp>2013-05-31T21:57:31Z</timestamp>
      <contributor>
        <ip>91.113.114.44</ip>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic ofstream]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/io/basic_ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream</title>
    <ns>0</ns>
    <id>4700</id>
    <revision>
      <id>57942</id>
      <parentid>49832</parentid>
      <timestamp>2013-06-01T06:04:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1610">{{cpp/title|ostrstream}}
{{cpp/io/ostrstream/navbar}}
{{dcl begin}}
{{dcl header|strstream}}
{{dcl | notes={{mark deprecated}} | 1=
class ostrstream : public std::ostream
}}
{{dcl end}}

The class {{tt|ostrstream}} implements output operations on array-backed streams. It essentially wraps a raw array I/O device implementation ({{c|std::strstreambuf}}) into the higher-level interface of {{lc|std::basic_ostream}}. 

The typical implementation of {{tt|ostrstream}} holds only one non-derived data member: an object of type {{c|std::strstreambuf}}.

===Notes===
After any call to {{tt|str()}}, a call to {{tt|freeze(false)}} is required to allow the destructor to deallocate the buffer as necessary.

{{tt|ostrstream}} has been deprecated since C++98, {{lc|std::ostringstream}} and [http://www.boost.org/doc/libs/release/libs/iostreams/doc/classes/array.html#array_sink boost::iostreams::array_sink] are the recommended replacements.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc constructor | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc destructor | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc rdbuf | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc str | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc freeze | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc pcount | ostrstream}}
{{dsc end}}

{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/ostrstream]]
[[es:cpp/io/ostrstream]]
[[fr:cpp/io/ostrstream]]
[[it:cpp/io/ostrstream]]
[[ja:cpp/io/ostrstream]]
[[pt:cpp/io/ostrstream]]
[[ru:cpp/io/ostrstream]]
[[zh:cpp/io/ostrstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/freeze</title>
    <ns>0</ns>
    <id>9724</id>
    <revision>
      <id>63936</id>
      <parentid>50868</parentid>
      <timestamp>2013-08-01T15:42:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="51">{{include page|cpp/io/strstream/freeze|ostrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/ostrstream</title>
    <ns>0</ns>
    <id>12951</id>
    <revision>
      <id>65182</id>
      <parentid>65179</parentid>
      <timestamp>2013-09-04T17:15:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+openmode in params</comment>
      <text xml:space="preserve" bytes="2351">{{cpp/io/ostrstream/title | ostrstream}}
{{cpp/io/ostrstream/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
ostrstream();
}}
{{dcl | num=2 | 1=
ostrstream(char* s, int n, std::ios_base::openmode mode = std::ios_base::out);
}}
{{dcl end}}

Constructs new output strstream and its underlying {{lc|std::strstreambuf}}.

@1@ Default-constructs the underlying {{lc|std::strstreambuf}}, which creates a dynamically growing buffer, and initializes the base class with the address of the strstreambuf member.

@2@ Initialized the base class with the address of the underlying {{lc|std::strstreambuf}} member, which is initialized in one of the two possible ways, both of which write to user-provided fixed-size array:
:@a@ if the {{tt|app}} bit is not set in {{tt|mode}}, constructs the buffer by calling {{c|strstreambuf(s, n, s)}}. The behavior is undefined if there are less than {{tt|n}} elements in the array whose first element is pointed to by {{tt|s}}
:@b@ if the {{tt|app}} bit is set in {{tt|mode}}, constructs the buffer by calling {{c|strstreambuf(s, n, s + std::strlen(s))}}. The behavior is undefined if there are less than {{tt|n}} elements in the array whose first element is pointed to by {{tt|s}} or if the array does not contain a valid null-terminated character sequence.

===Parameters===
{{par begin}}
{{par | s | char array to use as the output buffer}}
{{par | n | size of the array to be used as the output buffer}}
{{par | mode | specifies stream open mode. It is a bitmask type, the following constants are defined (although only {{tt|app}} is used): 
{{cpp/io/ios_base/openmode consts}} }}
{{par end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;strstream&gt;

int main()
{
    std::ostrstream s1; // dynamic buffer
    s1 &lt;&lt; 1 &lt;&lt; ' ' &lt;&lt; 3.14 &lt;&lt; &quot; example\n&quot; &lt;&lt; std::ends;
    std::cout &lt;&lt; s1.str();
    s1.freeze(false);

    char arr[15] = &quot;Hello&quot;;

    std::ostrstream s2(arr, sizeof arr, std::ios_base::app);
    s2 &lt;&lt; &quot;, world!&quot; &lt;&lt; std::ends;
    std::cout &lt;&lt; s2.str() &lt;&lt; '\n';
    std::cout &lt;&lt; arr &lt;&lt; '\n'; // streams use the provided arrays
}
 | output=
1 3.14 example
Hello, world!
Hello, world!
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc strstreambuf}}
{{dsc inc | cpp/io/strstream/dsc constructor | istrstream}}
{{dsc inc | cpp/io/strstream/dsc constructor | strstream}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/pcount</title>
    <ns>0</ns>
    <id>9721</id>
    <revision>
      <id>63935</id>
      <parentid>50869</parentid>
      <timestamp>2013-08-01T15:42:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="51">{{include page|cpp/io/strstream/pcount|ostrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/rdbuf</title>
    <ns>0</ns>
    <id>9731</id>
    <revision>
      <id>63934</id>
      <parentid>50870</parentid>
      <timestamp>2013-08-01T15:42:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="50">{{include page|cpp/io/strstream/rdbuf|ostrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/str</title>
    <ns>0</ns>
    <id>9726</id>
    <revision>
      <id>63933</id>
      <parentid>50871</parentid>
      <timestamp>2013-08-01T15:42:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="48">{{include page|cpp/io/strstream/str|ostrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/ostrstream/~ostrstream</title>
    <ns>0</ns>
    <id>12953</id>
    <revision>
      <id>69157</id>
      <parentid>65183</parentid>
      <timestamp>2014-03-28T17:41:18Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1278">{{cpp/io/ostrstream/title|~ostrstream}}
{{cpp/io/ostrstream/navbar}}
{{dcl begin}}
{{dcl | 1=
virtual ~ostrstream();
}}
{{dcl end}}

Destroys a {{tt|std::ostrstream}} object, which also destroys the member {{lc|std::strstreambuf}}, which may call the deallocation function if the underlying buffer was dynamically-allocated and not frozen.

===Parameters===
(none)

===Notes===
If {{lc|str()}} was called on a dynamic ostrstream and {{rlp|freeze|freeze(false)}} was not called after that, this destructor leaks memory.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    {
        std::ostrstream s; // dynamic buffer 
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; s.str() &lt;&lt; '\n';
        s.freeze(false);
    } // destructor called, buffer deallocated 

    {
        std::ostrstream s;
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; s.str() &lt;&lt; '\n';
//        buf.freeze(false);
    } // destructor called, memory leaked
}
 | output=
1.23
1.23
}}

[[de:cpp/io/ostrstream/~ostrstream]]
[[es:cpp/io/ostrstream/~ostrstream]]
[[fr:cpp/io/ostrstream/~ostrstream]]
[[it:cpp/io/ostrstream/~ostrstream]]
[[ja:cpp/io/ostrstream/~ostrstream]]
[[pt:cpp/io/ostrstream/~ostrstream]]
[[ru:cpp/io/ostrstream/~ostrstream]]
[[zh:cpp/io/ostrstream/~ostrstream]]</text>
      <sha1>ahc7ve4ub3rtn5m3x7wcfi6clly1rp3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/streamoff</title>
    <ns>0</ns>
    <id>4792</id>
    <revision>
      <id>64730</id>
      <parentid>64729</parentid>
      <timestamp>2013-08-26T14:22:31Z</timestamp>
      <contributor>
        <ip>86.149.50.166</ip>
      </contributor>
      <comment>Corrected last correction.</comment>
      <text xml:space="preserve" bytes="1528">{{cpp/title | streamoff}}
{{cpp/io/navbar}}
{{dcl begin}}
{{dcl header | ios}}
{{dcl | 1=
typedef /*unspecified*/ streamoff;
}}
{{dcl end}}

The type {{tt|std::streamoff}} is a signed integral type of sufficient size to represent the maximum possible file size supported by the operating system. Typically, this is a typedef to {{c|long long}}.

It is used to represent offsets from stream positions (values of type {{lc|std::fpos}}). A {{tt|std::streamoff}} value of {{c|-1}} is also used to represent error conditions by some of the I/O library functions.

===Relationship with std::fpos ===
* the difference between two {{lc|std::fpos}} objects is a value of type {{lc|std::streamoff}}

* a value of type {{lc|std::streamoff}} may be added or subtracted from {{lc|std::fpos}} yielding a different {{lc|std::fpos}}.

* a value of type {{lc|std::fpos}} is implicitly convertible to {{lc|std::streamoff}} (the conversion result is the offset from the beginning of the file).

* a value of type {{lc|std::fpos}} is constructible from a value of type {{lc|std::streamoff}}

===See also===
{{dsc begin}}
{{dsc tclass  | cpp/io/fpos | represents absolute position in a stream or a file}}
{{dsc inc | cpp/io/basic_istream/dsc seekg | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/streamoff]]
[[es:cpp/io/streamoff]]
[[fr:cpp/io/streamoff]]
[[it:cpp/io/streamoff]]
[[ja:cpp/io/streamoff]]
[[pt:cpp/io/streamoff]]
[[ru:cpp/io/streamoff]]
[[zh:cpp/io/streamoff]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/streamsize</title>
    <ns>0</ns>
    <id>4793</id>
    <revision>
      <id>57946</id>
      <parentid>49834</parentid>
      <timestamp>2013-06-01T06:04:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1043">{{cpp/title | streamsize}}
{{cpp/io/navbar}}
{{dcl begin}}
{{dcl header | ios}}
{{dcl | 1=
typedef /*unspecified*/ streamsize;
}}
{{dcl end}}

The type {{tt|std::streamsize}} is a signed integral type used to represent the number of characters transferred in an I/O operation or the size of an I/O buffer. It is used as a signed counterpart of {{lc|std::size_t}}, similar to the POSIX type {{tt|ssize_t}}.

Except in the constructors of {{c|std::strstreambuf}}, negative values of {{tt|std::streamsize}} are never used.

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc gcount | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_istream/dsc ignore | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_istream/dsc read | mem=std::basic_istream}}
{{dsc inc | cpp/io/basic_ostream/dsc write | mem=std::basic_ostream}}
{{dsc end}}

[[de:cpp/io/streamsize]]
[[es:cpp/io/streamsize]]
[[fr:cpp/io/streamsize]]
[[it:cpp/io/streamsize]]
[[ja:cpp/io/streamsize]]
[[pt:cpp/io/streamsize]]
[[ru:cpp/io/streamsize]]
[[zh:cpp/io/streamsize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream</title>
    <ns>0</ns>
    <id>4795</id>
    <revision>
      <id>57947</id>
      <parentid>49835</parentid>
      <timestamp>2013-06-01T06:04:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1624">{{cpp/title|strstream}}
{{cpp/io/strstream/navbar}}
{{dcl begin}}
{{dcl header|strstream}}
{{dcl | notes={{mark deprecated}} | 1=
class strstream : public std::iostream
}}
{{dcl end}}

The class {{tt|strstream}} implements input and output operations on array-backed streams. It essentially wraps a raw array I/O device implementation ({{c|std::strstreambuf}}) into the higher-level interface of {{lc|std::basic_iostream}}. 

The typical implementation of {{tt|strstream}} holds only one non-derived data member: an object of type {{c|std::strstreambuf}}.

===Notes===
After any call to {{tt|str()}}, a call to {{tt|freeze(false)}} is required to allow the destructor to deallocate the buffer as necessary.

{{tt|strstream}} has been deprecated since C++98, {{lc|std::stringstream}} and [http://www.boost.org/doc/libs/release/libs/iostreams/doc/classes/array.html#array boost::iostreams::array] are the recommended replacements.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc constructor | strstream}}
{{dsc inc | cpp/io/strstream/dsc destructor | strstream}}
{{dsc inc | cpp/io/strstream/dsc rdbuf | strstream}}
{{dsc inc | cpp/io/strstream/dsc str | strstream}}
{{dsc inc | cpp/io/strstream/dsc freeze | strstream}}
{{dsc inc | cpp/io/strstream/dsc pcount | strstream}}
{{dsc end}}

{{cpp/io/basic_istream/inherit}}
{{cpp/io/basic_ostream/inherit}}
{{cpp/io/basic_ios/inherit}}
{{cpp/io/ios_base/inherit}}

[[de:cpp/io/strstream]]
[[es:cpp/io/strstream]]
[[fr:cpp/io/strstream]]
[[it:cpp/io/strstream]]
[[ja:cpp/io/strstream]]
[[pt:cpp/io/strstream]]
[[ru:cpp/io/strstream]]
[[zh:cpp/io/strstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/freeze</title>
    <ns>0</ns>
    <id>9723</id>
    <revision>
      <id>63932</id>
      <parentid>50872</parentid>
      <timestamp>2013-08-01T15:42:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="50">{{include page|cpp/io/strstream/freeze|strstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/pcount</title>
    <ns>0</ns>
    <id>9720</id>
    <revision>
      <id>63931</id>
      <parentid>50873</parentid>
      <timestamp>2013-08-01T15:42:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="50">{{include page|cpp/io/strstream/pcount|strstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/rdbuf</title>
    <ns>0</ns>
    <id>9730</id>
    <revision>
      <id>63930</id>
      <parentid>50874</parentid>
      <timestamp>2013-08-01T15:42:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="49">{{include page|cpp/io/strstream/rdbuf|strstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/str</title>
    <ns>0</ns>
    <id>9728</id>
    <revision>
      <id>63929</id>
      <parentid>50875</parentid>
      <timestamp>2013-08-01T15:42:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="47">{{include page|cpp/io/strstream/str|strstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/strstream</title>
    <ns>0</ns>
    <id>12952</id>
    <revision>
      <id>69158</id>
      <parentid>65181</parentid>
      <timestamp>2014-03-28T17:43:42Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2846">{{cpp/io/strstream/title | strstream}}
{{cpp/io/strstream/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
strstream();
}}
{{dcl | num=2 | 1=
strstream(char* s, int n, std::ios_base::openmode mode
                           = std::ios_base::in {{!}} std::ios_base::out);
}}
{{dcl end}}

Constructs new input/output strstream and its underlying {{lc|std::strstreambuf}}.

@1@ Default-constructs the underlying {{lc|std::strstreambuf}}, which creates a dynamically growing buffer, and initializes the base class with the address of the strstreambuf member.

@2@ Initialized the base class with the address of the underlying {{lc|std::strstreambuf}} member, which is initialized in one of the two possible ways, both of which use a user-provided fixed-size array:
:@a@ if the {{tt|app}} bit is not set in {{tt|mode}}, constructs the buffer by calling {{c|strstreambuf(s, n, s)}}. The behavior is undefined if there are less than {{tt|n}} elements in the array whose first element is pointed to by {{tt|s}}
:@b@ if the {{tt|app}} bit is set in {{tt|mode}}, constructs the buffer by calling {{c|strstreambuf(s, n, s + std::strlen(s))}}. The behavior is undefined if there are less than {{tt|n}} elements in the array whose first element is pointed to by {{tt|s}} or if the array does not contain a valid null-terminated character sequence.

===Parameters===
{{par begin}}
{{par | s | char array to use as the output buffer}}
{{par | n | size of the array to be used for output}}
{{par | mode | specifies stream open mode. It is a bitmask type, the following constants are defined (although only {{tt|app}} is used): 
{{cpp/io/ios_base/openmode consts}} }}
{{par end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;strstream&gt;
#include &lt;string&gt;

int main()
{
    // dynamic buffer
    std::strstream s1; // dynamic buffer
    s1 &lt;&lt; 1 &lt;&lt; ' ' &lt;&lt; 3.14 &lt;&lt; &quot; example&quot; &lt;&lt; std::ends;
    std::cout &lt;&lt; &quot;buffer holds '&quot; &lt;&lt; s1.str() &lt;&lt; &quot;'\n&quot;;
    s1.freeze(false);

    int n; double d;
    std::string w;
    s1 &gt;&gt; n &gt;&gt; d &gt;&gt; w;
    std::cout &lt;&lt; &quot;Read back: n = &quot; &lt;&lt; n
              &lt;&lt; &quot; d = &quot; &lt;&lt; d
              &lt;&lt; &quot; w = '&quot; &lt;&lt; w &lt;&lt; &quot;'\n&quot;;

    // static buffer
    char arr[20] = &quot;-1 -3.14 &quot;;
    std::strstream s2(arr, sizeof arr, std::ios_base::app);
    s2 &lt;&lt; &quot;another&quot; &lt;&lt; std::ends;
    std::cout &lt;&lt; &quot;buffer holds: '&quot; &lt;&lt; s2.str() &lt;&lt; &quot;'\n&quot;;
    s2 &gt;&gt; n &gt;&gt; d &gt;&gt; w;
    std::cout &lt;&lt; &quot;Read back: n = &quot; &lt;&lt; n
              &lt;&lt; &quot; d = &quot; &lt;&lt; d
              &lt;&lt; &quot; w = '&quot; &lt;&lt; w &lt;&lt; &quot;'\n&quot;;
}
 | output=
buffer holds '1 3.14 example'
Read back: n = 1 d = 3.14 w = 'example'
buffer holds: '-1 -3.14 another'
Read back: n = -1 d = -3.14 w = 'another'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc strstreambuf}}
{{dsc inc | cpp/io/strstream/dsc constructor | istrstream}}
{{dsc inc | cpp/io/strstream/dsc constructor | ostrstream}}
{{dsc end}}</text>
      <sha1>rgdzqromlmuq813tncffypknxcazcyu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstream/~strstream</title>
    <ns>0</ns>
    <id>12884</id>
    <revision>
      <id>64185</id>
      <parentid>64112</parentid>
      <timestamp>2013-08-15T15:19:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1438">{{cpp/io/strstream/title|~strstream}}
{{cpp/io/strstream/navbar}}
{{dcl begin}}
{{dcl | 1=
virtual ~strstream();
}}
{{dcl end}}

Destroys a {{tt|std::strstream}} object, which also destroys the member {{lc|std::strstreambuf}}, which may call the deallocation function if the underlying buffer was dynamically-allocated and not frozen.

===Parameters===
(none)

===Notes===
If {{lc|str()}} was called on a dynamic strstream and {{rlp|freeze|freeze(false)}} was not called after that, this destructor leaks memory.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    {
        std::ostrstream s; // dynamic buffer 
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; s.str() &lt;&lt; '\n';
        s.freeze(false);
    } // destructor called, buffer deallocated 

    {
        std::ostrstream s;
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; s.str() &lt;&lt; '\n';
//        buf.freeze(false);
    } // destructor called, memory leaked

    {
        std::istrstream s(&quot;1.23&quot;); // constant buffer
        double d;
        s &gt;&gt; d;
        std::cout &lt;&lt; d &lt;&lt; '\n';
    } // destructor called, nothing to deallocate
}
 | output=
1.23
1.23
1.23
}}

[[de:cpp/io/strstream/~strstream]]
[[es:cpp/io/strstream/~strstream]]
[[fr:cpp/io/strstream/~strstream]]
[[it:cpp/io/strstream/~strstream]]
[[ja:cpp/io/strstream/~strstream]]
[[pt:cpp/io/strstream/~strstream]]
[[ru:cpp/io/strstream/~strstream]]
[[zh:cpp/io/strstream/~strstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf</title>
    <ns>0</ns>
    <id>4373</id>
    <revision>
      <id>64974</id>
      <parentid>57950</parentid>
      <timestamp>2013-08-28T19:13:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>wording, mention where the start of the buffer lives</comment>
      <text xml:space="preserve" bytes="2323">{{cpp/title|strstreambuf}}
{{cpp/io/strstreambuf/navbar}}
{{ddcl | header=strstream | notes={{mark deprecated}} | 1=
class strstreambuf : public std::basic_streambuf&lt;char&gt;
}}

{{tt|std::strstreambuf}} is a {{lc|std::basic_streambuf}} whose associated character sequence is a character array, which may be constant (e.g. a string literal), modifyable but not dynamic (e.g. a stack-allocated array), or dynamic, in which case the {{tt|std::strstreambuf}} may be allowed to reallocate the array as necessary to accomodate output (e.g. by calling {{c|delete[]}} and {{c|new[]}} or user-provided functions).

Typical implementation of a {{tt|std::strstreambuf}} holds four private data members:

@1@ buffer state, a bitmask type which can represent any combination of the four values &quot;allocated&quot; (destructor will deallocate), &quot;constant&quot; (output not allowed), &quot;dynamic&quot; (output may reallocate), or &quot;frozen&quot; (deallocation and reallocation are not allowed)
@2@ allocated buffer size (the beginning of the buffer does not need a special data member, it may be stored in the inherited pointer {{lc|std::streambuf::eback|eback()}})
@3@ pointer to user-provided allocation function
@4@ pointer to user-provided deallocation function.

===Notes===
After any call to {{tt|str()}} on a stream with a dynamic buffer, a call to {{tt|freeze(false)}} is required to allow the {{tt|strstreambuf}} destructor to deallocate the buffer when necessary.

===Member functions===
{{dsc begin}}
{{dsc h1 | Public member functions}}
{{dsc inc | cpp/io/strstreambuf/dsc strstreambuf}}
{{dsc inc | cpp/io/strstreambuf/dsc ~strstreambuf}}
{{dsc inc | cpp/io/strstreambuf/dsc freeze}}
{{dsc inc | cpp/io/strstreambuf/dsc str}}
{{dsc inc | cpp/io/strstreambuf/dsc pcount}}
{{dsc h1 | Protected member functions}}
{{dsc inc | cpp/io/strstreambuf/dsc underflow}}
{{dsc inc | cpp/io/strstreambuf/dsc pbackfail}}
{{dsc inc | cpp/io/strstreambuf/dsc overflow}}
{{dsc inc | cpp/io/strstreambuf/dsc setbuf}}
{{dsc inc | cpp/io/strstreambuf/dsc seekoff}}
{{dsc inc | cpp/io/strstreambuf/dsc seekpos}}
{{dsc end}}

{{cpp/io/basic_streambuf/inherit}}

[[de:cpp/io/strstreambuf]]
[[es:cpp/io/strstreambuf]]
[[fr:cpp/io/strstreambuf]]
[[it:cpp/io/strstreambuf]]
[[ja:cpp/io/strstreambuf]]
[[pt:cpp/io/strstreambuf]]
[[ru:cpp/io/strstreambuf]]
[[zh:cpp/io/strstreambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/freeze</title>
    <ns>0</ns>
    <id>12927</id>
    <revision>
      <id>64973</id>
      <parentid>64972</parentid>
      <timestamp>2013-08-28T18:11:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso to dtor and overflow</comment>
      <text xml:space="preserve" bytes="2886">{{cpp/io/strstreambuf/title|freeze}}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |
void freeze(bool freezefl {{=}} true);
}}

If the buffer uses dynamic allocation, sets the frozen status of the stream to {{tt|freezefl}}.

While the stream is frozen, {{lc|overflow()}} will not reallocate the buffer and the {{lc|~strstreambuf|destructor}} will not deallocate the buffer (thereby causing a memory leak). 

===Parameters===
{{par begin}}
{{par | freezefl | new value to set the freeze status to}}
{{par end}}


===Return value===
(none)

===Notes===
Every call to {{lc|str()}} freezes the stream to preserve the validity of the pointer it returns. To allow the destructor to deallocate the buffer, {{lc|freeze|freeze(false)}} needs to be called explicitly.

===Example===
{{example
 | in this example, initial allocation of the underlying array was for 16 bytes
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    {
        std::strstream dyn; // dynamically-allocated read/write buffer
        dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
        std::cout &lt;&lt; &quot;dynamic buffer holds &quot;
                  &lt;&lt; dyn.pcount() &lt;&lt; &quot; characters: '&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;'\n&quot;;
        // the buffer is now frozen, further output will not make the buffer grow
        dyn &lt;&lt; &quot;more output, hopefully enough to run out of the allocated space&quot;;
        std::cout &lt;&lt; &quot;After more output, it holds &quot;
                  &lt;&lt; dyn.pcount() &lt;&lt; &quot; characters: '&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;'\n&quot;;
        dyn.freeze(false); // unfreeze before destructor
    } // memory freed by the destructor

    {
        char arr[20];
        std::ostrstream st(arr, sizeof arr); // fixed-size buffer
        st &lt;&lt; 1.23;
        std::cout &lt;&lt; &quot;static buffer holds &quot;
                  &lt;&lt; st.pcount() &lt;&lt; &quot; characters: '&quot;;
        std::cout.write(st.str(), st.pcount());
        std::cout &lt;&lt; &quot;'\n&quot;;
        st &lt;&lt; &quot;more output, hopefully enough to run out of the allocated space&quot;;
        std::cout &lt;&lt; &quot;static buffer holds &quot;
                  &lt;&lt; st.pcount() &lt;&lt; &quot; characters: '&quot;;
        std::cout.write(st.str(), st.pcount());
        std::cout &lt;&lt; &quot;'\n&quot;;
    } // nothing to deallocate, no need to unfreeze,
}
 | output=
dynamic buffer holds 10 characters: 'Test: 1.23'
After more output, it holds 16 characters: 'Test: 1.23more o'
static buffer holds 4 characters: '1.23'
static buffer holds 20 characters: '1.23more output, hop'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc freeze | strstream}}
{{dsc inc | cpp/io/strstream/dsc freeze | ostrstream}}
{{dsc inc | cpp/io/strstreambuf/dsc ~strstreambuf}}
{{dsc inc | cpp/io/strstreambuf/dsc overflow}}
{{dsc end}}

[[de:cpp/io/strstreambuf/freeze]]
[[es:cpp/io/strstreambuf/freeze]]
[[fr:cpp/io/strstreambuf/freeze]]
[[it:cpp/io/strstreambuf/freeze]]
[[ja:cpp/io/strstreambuf/freeze]]
[[pt:cpp/io/strstreambuf/freeze]]
[[ru:cpp/io/strstreambuf/freeze]]
[[zh:cpp/io/strstreambuf/freeze]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/overflow</title>
    <ns>0</ns>
    <id>12968</id>
    <revision>
      <id>65329</id>
      <parentid>65328</parentid>
      <timestamp>2013-09-09T15:15:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3079">{{cpp/io/strstreambuf/title | overflow }}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual int_type overflow (int_type c = EOF);
}}

Appends the character {{tt|c}} to the put area of the buffer, reallocating if possible.

@1@ If {{tt|c{{==}}EOF}}, does nothing
@2@ Otherwise, if the put area has a write position available ({{c|pptr() &lt; epptr()}}), stores the character as if by {{c|*pptr()++ {{=}} c}}
@3@ Otherwise, if the stream buffer mode is not dynamic or the stream buffer is currently frozen, the function fails and returns {{c|EOF}}
@4@ Otherwise, the function reallocates (or initially allocates) a dynamic array large enough to hold the contents of the current dynamic array (if any) plus at least one additional write position. If a pointer to the allocator function {{tt|palloc}} was used in the constructor, that function is called with {{c|(*palloc)[n]}} where {{tt|n}} is the number of bytes to allocate, otherwise {{c|new char[n]}} is used. If a pointer to the deallocating function {{tt|pfree}} was used in the constructor, that function is called with {{c|(*pfree)(p)}} to deallocate the previous array, if needed, otherwise {{c|delete[] p}} is used. If allocation fails, the function fails and returns {{c|EOF}}. 

===Parameters===
{{par begin}}
{{par | c | the character to store in the put area}}
{{par end}}

===Return value===
If {{c|c{{==}}EOF}}, returns some value other than {{c|EOF}}. Otherwise, returns {{c|(unsigned char)(c)}} on success, {{lc|EOF}} on failure.

===Example===
{{example
 |
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::strstreambuf
{
    int_type overflow(int_type c) 
    {
        std::cout &lt;&lt; &quot;Before overflow(): size of the put area is &quot; &lt;&lt; epptr()-pbase()
                  &lt;&lt; &quot; with &quot; &lt;&lt; epptr()-pptr() &lt;&lt; &quot; write positions available\n&quot;;
        int_type rc = std::strstreambuf::overflow(c);
        std::cout &lt;&lt; &quot;After overflow(): size of the put area is &quot; &lt;&lt; epptr()-pbase()
                  &lt;&lt; &quot; with &quot; &lt;&lt; epptr()-pptr() &lt;&lt; &quot; write positions available\n&quot;;
        return rc;
    }
};

int main()
{
    mybuf sbuf; // read-write dynamic strstreambuf
    std::iostream stream(&amp;sbuf);

    stream &lt;&lt; &quot;Sufficiently long string to overflow the initial allocation, at least &quot;
           &lt;&lt; &quot; on some systems.&quot;;
}
 | p=true
 | output=
Before overflow(): size of the put area is 16 with 0 write positions available
After overflow(): size of the put area is 32 with 15 write positions available
Before overflow(): size of the put area is 32 with 0 write positions available
After overflow(): size of the put area is 64 with 31 write positions available
Before overflow(): size of the put area is 64 with 0 write positions available
After overflow(): size of the put area is 128 with 63 write positions available
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc overflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputc}}
{{dsc inc | cpp/io/basic_ostream/dsc put}}
{{dsc end}}</text>
      <sha1>qdyh5wqdw3dwdt89vog6l7lgmq01r4n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/pbackfail</title>
    <ns>0</ns>
    <id>9697</id>
    <revision>
      <id>63928</id>
      <parentid>57951</parentid>
      <timestamp>2013-08-01T15:42:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="2286">{{cpp/io/strstreambuf/title | pbackfail }}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual int_type pbackfail( int_type c = EOF );
}}

This protected virtual function is called by the public functions {{l2tt|cpp/io/basic_streambuf/sungetc}} and {{l2tt|cpp/io/basic_streambuf/sputbackc}} (which, in turn, are called by {{l2tt|cpp/io/basic_istream/unget}} and {{l2tt|cpp/io/basic_istream/putback}}). 

@1@ The caller is requesting that the get area is backed up by one character ({{tt|pbackfail()}} is called with no arguments or with {{lc|EOF}} as the argument)
:@a@ First, checks if there is a putback position, and if there really isn't, fails. (strstreambuf has no external character source to re-read)
:@b@ If the caller was wrong and the putback position is in fact available, simply decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}, e.g. by calling {{c|gbump(-1)}}. 
@2@ The caller attempts to putback a different character from the one retrieved earlier ({{tt|pbackfail()}} is called with the character that needs to be put back), in which case
:@a@ First, checks if there is a putback position, and if there isn't, fails.
:@b@ Then checks what character is in the putback position. If the character held there is already equal to {{tt|(char)c}}, then simply decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}}.
:@c@ Otherwise, if the buffer is unmodifiable (this strstreambuf was constructed with a string literal or some other {{c|const}} array), fails.
:@d@ Otherwise, decrements {{l2tt|cpp/io/basic_streambuf/gptr|gptr()}} and writes {{tt|c}} to the location pointed to gptr() after adjustment.

===Parameters===
{{par begin}}
{{par | c | the character to put back, or Traits::eof() to indicate that backing up of the get area is requested}}
{{par end}}

===Return value===
{{c|c}} on success except if {{tt|c}} was {{lc|EOF}}, in which case unspecified value other than {{lc|EOF}} is returned.

{{lc|EOF}} on failure.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbackfail}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/pcount</title>
    <ns>0</ns>
    <id>12916</id>
    <revision>
      <id>64748</id>
      <parentid>64735</parentid>
      <timestamp>2013-08-26T21:02:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>better link to pptr</comment>
      <text xml:space="preserve" bytes="1939">{{cpp/io/strstreambuf/title|pcount}}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |
int pcount() const;
}}


Returns the number of characters written to the output sequence.

If the next pointer for the put area ({{lc|std::streambuf::pptr()}}) is a null pointer, returns zero.

Otherwise, returns the next pointer in the put area minus the beginning pointer in the put area, that is {{c|pptr() - pbase()}}

===Parameters===
(none)

===Return value===
The number of characters written to the put area.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::strstream dyn; // dynamically-allocated output buffer
    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::strstreambuf* buf = dyn.rdbuf();
    std::cout &lt;&lt; &quot;The size of the output is &quot;
              &lt;&lt; buf-&gt;pcount() // or just buf.pcount()
              &lt;&lt; &quot; and it holds \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    dyn.freeze(false); // after calling .str() on a dynamic strstream

    char arr[10];
    std::ostrstream user(arr, 10); // user-provided output buffer
    buf = user.rdbuf();
    user &lt;&lt; 1.23; // note: no std::ends
    std::cout.write(arr, buf-&gt;pcount()); // or just user.pcount()
    std::cout &lt;&lt; '\n';

    std::istrstream lit(&quot;1 2 3&quot;); // read-only fixed-size buffer
    buf = lit.rdbuf();
    // istrstream has no member pcount(), so lit.pcount() won't work
    std::cout &lt;&lt; &quot;Input-only pcount() = &quot; &lt;&lt; buf-&gt;pcount() &lt;&lt; '\n';
}
 | output=
The size of the output is 10 and it holds &quot;Test: 1.23&quot;
1.23
Input-only pcount() = 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc pcount | strstream}}
{{dsc inc | cpp/io/strstream/dsc pcount | ostrstream}}
{{dsc end}}

[[de:cpp/io/strstreambuf/pcount]]
[[es:cpp/io/strstreambuf/pcount]]
[[fr:cpp/io/strstreambuf/pcount]]
[[it:cpp/io/strstreambuf/pcount]]
[[ja:cpp/io/strstreambuf/pcount]]
[[pt:cpp/io/strstreambuf/pcount]]
[[ru:cpp/io/strstreambuf/pcount]]
[[zh:cpp/io/strstreambuf/pcount]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/seekoff</title>
    <ns>0</ns>
    <id>12971</id>
    <revision>
      <id>65341</id>
      <timestamp>2013-09-09T19:44:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="4892">{{cpp/io/strstreambuf/title | seekoff }}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekoff(off_type off,
                         ios_base::seekdir way,
                         ios_base::openmode which = ios_base::in {{!}} ios_base::out);}}

Repositions {{lc|std::basic_streambuf::gptr}} and/or {{lc|std::basic_streambuf::pptr}}, if possible, to the position that corresponds to exactly {{tt|off}} characters from beginning, end, or current position of the get and/or put area of the buffer.

* If {{tt|which}} includes {{tt|ios_base::in}} and this buffer is open for reading, then repositions the read pointer {{lc|std::basic_streambuf::gptr}} inside the get area as described below
* If {{tt|which}} includes {{tt|ios_base::out}} and this buffer is open for writing, then repositions the write pointer {{lc|std::basic_streambuf::pptr}} inside the put area as described below
* If {{tt|which}} includes both  {{tt|ios_base::in}} and  {{tt|ios_base::out}} and the buffer is open for both reading and writing, and {{tt|when}} is either {{c|ios_base::beg}} or {{c|ios_base::end}}, then repositions both read and write pointers as described below.
* Otherwise, this function fails.

If the pointer (either {{tt|gptr}} or {{tt|pptr}} or both) is repositioned, it is done as follows:
@1@ If the pointer to be repositioned is a null pointer and the new offset {{tt|newoff}} would be non-zero, this function fails.
@2@ The new pointer offset {{tt|newoff}} of type {{tt|off_type}} is determined
:@a@ if {{c|way {{==}} ios_base::beg}}, then {{tt|newoff}} is zero
:@b@ if {{c|way {{==}} ios_base::cur}}, then {{tt|newoff}} is the current position of the pointer ({{c|gptr()-eback()}} or {{c|pptr()-pbase()}})
:@c@ if {{c|way {{==}} ios_base::end}}, then {{tt|newoff}} is the length of the entire initialized part of the buffer (if overallocation is used, the high watermark pointer minus the beginning pointer)
@3@ If {{c|newoff + off}} is negative or out of bounds of the initialized part of the buffer, the function fails
@4@ Otherwise, the pointer is assigned as if by {{c|gptr() {{=}} eback() + newoff + off}} or {{c|pptr() {{=}} pbase() + newoff + off}}

===Parameters===
{{par begin}}
{{par | off | relative position to set the next pointer(s) to}}
{{par | dir | defines base position to apply the relative offset to. It can be one of the following constants:
{{cpp/io/ios_base/seekdir consts}} }}
{{par | which | defines whether the input sequences, the output sequence, or both are affected. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
{{c|pos_type(newoff)}} on success, {{c|pos_type(off_type(-1))}} on failure and if pos_type cannot represent the resulting stream position.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;strstream&gt;

int main()
{
    char a[] = &quot;123&quot;;
    std::strstream ss(a, sizeof a); // in/out
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // absolute positioning both pointers
    ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::beg); // move both forward
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // try to move both pointers 1 forward from current position
    if(-1 == ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::cur))
        std::cout &lt;&lt; &quot;moving both pointers from current position failed\n&quot;;
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    // move the write pointer 1 forward, but not the read pointer
    // can also be called as ss.seekp(1, std::ios_base::cur);
    ss.rdbuf()-&gt;pubseekoff(1, std::ios_base::cur, std::ios_base::out);
    std::cout &lt;&lt; &quot;put pos = &quot; &lt;&lt; ss.tellp()
              &lt;&lt; &quot; get pos = &quot; &lt;&lt; ss.tellg() &lt;&lt; '\n';

    ss &lt;&lt; 'a'; // write at put position
    std::cout &lt;&lt; &quot;Wrote 'a' at put position, the buffer is now: '&quot;;
    std::cout.write(a, sizeof a);
    std::cout &lt;&lt; &quot;'\n&quot;;
    char ch;
    ss &gt;&gt; ch;
    std::cout &lt;&lt; &quot;reading at get position gives '&quot; &lt;&lt; ch &lt;&lt; &quot;'\n&quot;;
}
 | output=
put pos = 0 get pos = 0
put pos = 1 get pos = 1
moving both pointers from current position failed
put pos = 1 get pos = 1
put pos = 2 get pos = 1
Wrote 'a' at put position, the buffer is now: '12a'
reading at get position gives '2'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_stringbuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekoff}}
{{dsc end}}

[[de:cpp/io/strstreambuf/seekoff]]
[[es:cpp/io/strstreambuf/seekoff]]
[[fr:cpp/io/strstreambuf/seekoff]]
[[it:cpp/io/strstreambuf/seekoff]]
[[ja:cpp/io/strstreambuf/seekoff]]
[[pt:cpp/io/strstreambuf/seekoff]]
[[ru:cpp/io/strstreambuf/seekoff]]
[[zh:cpp/io/strstreambuf/seekoff]]</text>
      <sha1>427unszzj2779s9nd4oouox5zeunihz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/seekpos</title>
    <ns>0</ns>
    <id>12970</id>
    <revision>
      <id>65336</id>
      <timestamp>2013-09-09T18:47:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="3399">{{cpp/io/strstreambuf/title|seekpos}}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual pos_type seekpos(pos_type sp,
                         std::ios_base::openmode which = std::ios_base::in {{!}} std::ios_base::out );
}}

Repositions {{lc|std::basic_streambuf::gptr}} and/or {{lc|std::basic_streambuf::pptr}}, if possible, to the position indicated by {{tt|sp}}

If {{lc|std::ios_base::in}} is set in {{tt|which}}, attempts to reposition {{tt|gptr()}} (the next pointer in the get area). If {{lc|std::ios_base::out}} is set in {{tt|which}}, attempts to reposition {{tt|pptr()}} (the next pointer in the put area). If neither bit is set in {{tt|which}}, the operation fails.

Each next pointer is repositioned as follows:
@1@ If the next pointer is null, the operation fails
@2@ Otherwise, the new offset {{tt|newoff}} (of type {{tt|off_type}}) is determined by calling {{c|sp.offset()}}. If {{tt|newoff}} is negative, out of bounds of the buffer, or invalid, the operation fails.
@3@ Otherwise, the next pointer is assigned as if by {{c|gptr() {{=}} eback()+newoff}} or {{c|pptr() {{=}} pbase()+newoff}}.


===Parameters===
{{par begin}}
{{par | sp | stream position, such as one obtained by {{lc|seekoff()}} or {{tt|seekpos()}}}}
{{par | which | defines whether the input sequences, the output sequence, or both are affected. It can be one or a combination of the following constants:
{{cpp/io/ios_base/openmode streambuf consts}} }}
{{par end}}

===Return value===
The resultant offset converted to {{tt|pos_type}} on success or {{c|pos_type(off_type(-1))}} on failure.

===Notes===
{{tt|seekpos()}} is called by {{lc|std::basic_streambuf::pubseekpos()}}, which is called by the single-argument versions of {{lc|std::basic_istream::seekg()}} and {{lc|std::basic_ostream::seekp()}}

===Example===
{{example
 |
 | code=
#include &lt;strstream&gt;
#include &lt;cstring&gt;
#include &lt;iostream&gt;

struct mybuf : std::strstreambuf
{
    mybuf(const char* str) : std::strstreambuf(str, std::strlen(str)) {}
    pos_type seekpos(pos_type sp, std::ios_base::openmode which) {
         std::cout &lt;&lt; &quot;Before seekpos(&quot; &lt;&lt; sp &lt;&lt; &quot;), size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
         pos_type rc = std::strstreambuf::seekpos(sp, which);
         std::cout &lt;&lt; &quot;seekpos() returns &quot; &lt;&lt; rc &lt;&lt; &quot;.\nAfter the call, &quot;
                   &lt;&lt; &quot;size of the get area is &quot;
                   &lt;&lt; egptr()-eback() &lt;&lt; &quot; with &quot;
                   &lt;&lt; egptr()-gptr() &lt;&lt; &quot; read positions available\n&quot;;
        return rc;
    }
};

int main()
{
    mybuf buf(&quot;12345&quot;);
    std::iostream stream(&amp;buf);
    stream.seekg(2);
}
 | output=
Before seekpos(2), size of the get area is 5 with 5 read positions available
seekpos() returns 2.
After the call, size of the get area is 5 with 3 read positions available
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc inc | cpp/io/basic_stringbuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_filebuf/dsc seekpos}}
{{dsc inc | cpp/io/strstreambuf/dsc seekoff}}
{{dsc end}}

[[de:cpp/io/strstreambuf/seekpos]]
[[es:cpp/io/strstreambuf/seekpos]]
[[fr:cpp/io/strstreambuf/seekpos]]
[[it:cpp/io/strstreambuf/seekpos]]
[[ja:cpp/io/strstreambuf/seekpos]]
[[pt:cpp/io/strstreambuf/seekpos]]
[[ru:cpp/io/strstreambuf/seekpos]]
[[zh:cpp/io/strstreambuf/seekpos]]</text>
      <sha1>9hpkbh19vya4e3bfzzyhe1951inagoq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/setbuf</title>
    <ns>0</ns>
    <id>12969</id>
    <revision>
      <id>69878</id>
      <parentid>65332</parentid>
      <timestamp>2014-04-30T13:54:50Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Return value */ correcting</comment>
      <text xml:space="preserve" bytes="1594">{{cpp/io/strstreambuf/title | underflow }}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual streambuf&lt;char&gt;* setbuf(char* s, std::streamsize n);
}}

If {{tt|s}} is a null pointer and {{tt|n}} is zero, this function has no effect.

Otherwise, the effect is implementation-defined: some implementations do nothing, while some implementations deallocate the dynamic member array used as the buffer and begin using the user-supplied character array of size {{tt|n}}, whose first element is pointed to by {{tt|s}}.

This function is protected virtual, it may only be called through {{tt|pubsetbuf()}} or from member functions of a user-defined class derived from {{tt|std::strstreambuf}}.

===Parameters===
{{par begin}}
{{par | s | pointer to the first byte in the user-provided buffer}}
{{par | n | the number of bytes in the user-provided buffer}}
{{par end}}

===Return value===
{{c|this}}

===Example===
{{example
 | Implementation test to check if setbuf() is supported on a dynamic strstream (output obtained with Sun Studio)
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    char a[100] = {};
    std::strstream str;
    str.rdbuf()-&gt;pubsetbuf(a, sizeof a);
    str &lt;&lt; &quot;Test string&quot; &lt;&lt; std::ends;
    std::cout &lt;&lt; &quot;user-provided buffer holds '&quot; &lt;&lt; a &lt;&lt; &quot;'\n&quot;;
}
 | p=true
 | output=
user-provided buffer holds 'Test string'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsetbuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_stringbuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_filebuf/dsc setbuf}}
{{dsc end}}</text>
      <sha1>rosoilfsf1f0iq6p5vdz8az5h1y334s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/str</title>
    <ns>0</ns>
    <id>12917</id>
    <revision>
      <id>64754</id>
      <timestamp>2013-08-26T21:31:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+ (I'll never get tired of mentioning freeze(false) after str())</comment>
      <text xml:space="preserve" bytes="2431">{{cpp/io/strstreambuf/title|str}}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |
char* str() const;
}}

Calls {{lc|freeze()}}, then returns a copy of start pointer of the get area, {{lc|std::streambuf::eback()}}.

The start of the get area, for all writeable {{tt|std::strstreambuf}} objects constructed through the interface provided by {{lc|std::strstream}}, is also the start of the put area.

===Parameters===
(none)

===Return value===
A copy of {{lc|eback()}}, which may be a null pointer.

===Notes===
This function is typically called through the {{lc|std::strstream}} interface.

The call to {{lc|freeze()}} guarantees that the returned pointer remains valid until the next explicit call to {{lc|freeze(false)}}: otherwise (on a dynamic buffer) any output operation could trigger buffer reallocation which would invalidate the pointer. It also causes a memory leak in the destructor of {{tt|std::strstreambuf}}, unless {{lc|freeze(false)}} is called before the buffer (or, more commonly, the {{c|std::strstream}} that manages it) is destroyed.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::strstream dyn; // dynamically-allocated read/write buffer
    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::strstreambuf* buf = dyn.rdbuf();
    std::cout &lt;&lt; &quot;R/W buffer holds \&quot;&quot; &lt;&lt; buf-&gt;str() // or dyn.str()
              &lt;&lt; &quot;\&quot;\n&quot;;
    dyn.freeze(false); // after calling .str() on a dynamic strstream

    char arr[10];
    std::ostrstream user(arr, 10); // fixed-size write-only buffer
    buf = user.rdbuf();
    user &lt;&lt; 1.23 &lt;&lt; std::ends;
    std::cout &lt;&lt; &quot;Write-only buffer holds \&quot;&quot; &lt;&lt; buf-&gt;str() // or user.str()
              &lt;&lt; &quot;\&quot;\n&quot;;

    std::istrstream lit(&quot;1 2 3&quot;); // fixed-size read-only buffer
    buf = lit.rdbuf();
    std::cout &lt;&lt; &quot;Read-only buffer holds \&quot;&quot; &lt;&lt; buf-&gt;str() // or lit.str()
              &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
R/W buffer holds &quot;Test: 1.23&quot;
Write-only buffer holds &quot;1.23&quot;
Read-only buffer holds &quot;1 2 31 2 3&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstream/dsc str | strstream}}
{{dsc inc | cpp/io/strstream/dsc str | ostrstream}}
{{dsc inc | cpp/io/strstream/dsc str | istrstream}}
{{dsc end}}

[[de:cpp/io/strstreambuf/str]]
[[es:cpp/io/strstreambuf/str]]
[[fr:cpp/io/strstreambuf/str]]
[[it:cpp/io/strstreambuf/str]]
[[ja:cpp/io/strstreambuf/str]]
[[pt:cpp/io/strstreambuf/str]]
[[ru:cpp/io/strstreambuf/str]]
[[zh:cpp/io/strstreambuf/str]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/strstreambuf</title>
    <ns>0</ns>
    <id>9447</id>
    <revision>
      <id>49838</id>
      <parentid>42508</parentid>
      <timestamp>2013-06-01T02:58:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="4379">{{cpp/io/strstreambuf/title|strstreambuf}}
{{cpp/io/strstreambuf/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
explicit strstreambuf( std::streamsize alsize = 0 );
}}
{{dcl | num=2 | 1=
strstreambuf( void* (*palloc)(std::size_t), void (*pfree)(void*) );
}}
{{dcl | num=3 | 1=
strstreambuf( char* gnext, std::streamsize n, char* pbeg = 0 );
}}
{{dcl | num=4 | 1=
strstreambuf( signed char* gnext, std::streamsize n, signed char* pbeg = 0 );
}}
{{dcl | num=5 | 1=
strstreambuf( unsigned char* gnext, std::streamsize n, unsigned char* pbeg = 0 );
}}
{{dcl | num=6 | 1=
strstreambuf( const char* gnext, std::streamsize n );
}}
{{dcl | num=7 | 1=
strstreambuf( const signed char* gnext, std::streamsize n);
}}
{{dcl | num=8 | 1=
strstreambuf( const unsigned char* gnext, std::streamsize n );
}}
{{dcl end}}

@1@ Constructs a {{tt|std::strstreambuf}} object: initializes the base class by calling the default constructor of {{lc|std::streambuf}}, initializes the buffer state to &quot;dynamic&quot; (the buffer will be allocated as needed), initializes allocated size to the provided {{tt|alsize}}, initializes the allocation and the deallocation functions to null (will use {{c|new[]}} and {{c|delete[]}})

@2@ Constructs a {{tt|std::strstreambuf}} object: initializes the base class by calling the default constructor of {{lc|std::streambuf}}, initializes the buffer state to &quot;dynamic&quot; (the buffer will be allocated as needed), initializes allocated size to unspecified value, initializes the allocation function to {{tt|palloc}} and the deallocation function to {{tt|pfree}}

@3-5@ Constructs a {{tt|std::strstreambuf}} object in following steps:
:@a@ Initializes the base class by calling the default constructor of {{lc|std::streambuf}}
:@b@ Initializes the buffer state to &quot;constant&quot; (the buffer is a user-provided fixed-size buffer)
:@c@ Determines the number of elements in the user-provided array as follows: if {{tt|n}} is greater than zero, {{tt|n}} is used. If {{tt|n}} is zero, {{c|std::strlen(gnext)}} is executed to determine the buffer size. If {{tt|n}} is negative, {{lc|INT_MAX}} is used.
:@d@ Configures the {{lc|std::basic_streambuf}} pointers as follows: If {{tt|pbeg}} is a null pointer, calls {{c|setg(gnext, gnext, gnext + N)}}. If {{tt|pbeg}} is not a null pointer, executes {{c|setg(gnext, gnext, pbeg)}} and {{c|setp(pbeg, pbeg+N)}}, where N is the number of elements in the array as determined earlier.

@6-8@ Same as {{c|strstreambuf((char*)gnext, n)}}, except the &quot;constant&quot; bit is set in the buffer state bitmask (output to this buffer is not allowed)

===Parameters===
{{par begin}}
{{par | alsize | the initial size of the dynamically allocated buffer}}
{{par | palloc | pointer to user-provided allocation function }}
{{par | pfree | pointer to user-provided deallocation function }}
{{par | gnext | pointer to the start of the get area in the user-provided array}}
{{par | pbeg | pointer to the start of the put area in the user-provided array}}
{{par | n | the number of bytes in the get area (if pbeg is null) or in the put area (if pbeg is not null) of the user-provided array}}
{{par end}}

===Notes===
These constructors are typically called by the constructors of {{c|std::strstream}}

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::strstreambuf dyn; // dynamic
    std::strstream dyn_s; // equivalent stream
    dyn_s &lt;&lt; 1.23;
    std::cout &lt;&lt; dyn_s.str() &lt;&lt; '\n'; dyn_s.freeze(false);

    char buf[10];
    std::strstreambuf user(buf, 10, buf); // user-provided output buffer
    std::ostrstream user_s(buf, 10); // equivalent stream
    user_s &lt;&lt; 1.23 &lt;&lt; std::ends;
    std::cout &lt;&lt; buf &lt;&lt; '\n';

    std::strstreambuf lit(&quot;1 2 3&quot;, 5); // constant
    std::istrstream lit_s(&quot;1 2 3&quot;); // equivalent stream
    int i, j, k;
    lit_s &gt;&gt; i &gt;&gt; j &gt;&gt; k;
    std::cout &lt;&lt; i &lt;&lt; ' ' &lt;&lt; j &lt;&lt; ' ' &lt;&lt; k &lt;&lt; '\n';
}
 | output=
1.23
1.23
1 2 3
}}

===See also===
{{dsc begin}}
{{dsc mem ctor | cpp/io/strstream/strstream | constructs an strstream, optionally allocating the buffer}}
{{dsc end}}

[[de:cpp/io/strstreambuf/strstreambuf]]
[[es:cpp/io/strstreambuf/strstreambuf]]
[[fr:cpp/io/strstreambuf/strstreambuf]]
[[it:cpp/io/strstreambuf/strstreambuf]]
[[ja:cpp/io/strstreambuf/strstreambuf]]
[[pt:cpp/io/strstreambuf/strstreambuf]]
[[ru:cpp/io/strstreambuf/strstreambuf]]
[[zh:cpp/io/strstreambuf/strstreambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/underflow</title>
    <ns>0</ns>
    <id>12932</id>
    <revision>
      <id>65051</id>
      <parentid>65023</parentid>
      <timestamp>2013-08-30T14:50:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt example</comment>
      <text xml:space="preserve" bytes="3255">{{cpp/io/strstreambuf/title | underflow }}
{{cpp/io/strstreambuf/navbar}}
{{ddcl |1=
protected:
virtual int_type underflow();
}}

Reads the next character from the get area of the buffer.

If the input sequence has a read position available ({{c|gptr() &lt; egptr()}}, returns {{c|(unsigned char)(*gptr())}}.

Otherwise, if {{lc|pptr()}} is not null and {{c|pptr() &gt; egptr()}} (there is a put area and it is located after the get area), extends the end of the get area to include the characters that were recently written into the put area by incrementing {{lc|egptr()}} to some value between {{c|gptr()}} and {{lc|pptr()}}, and then returns {{c|(unsigned char)(*gptr())}}.

Otherwise, returns {{lc|EOF}} to indicate failure.

===Parameters===
(none)

===Return value===
The next character in the get area, {{c|(unsigned char)(*gptr())}} on success, {{lc|EOF}} on failure

===Example===
{{example
 |
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

struct mybuf : std::strstreambuf
{
    int_type overflow(int_type c) 
    {
        std::cout &lt;&lt; &quot;Before overflow(): size of the get area is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; size of the put area is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        int_type rc = std::strstreambuf::overflow(c);
        std::cout &lt;&lt; &quot;After overflow(): size of the get area is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; size of the put area is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        return rc;
    }

    int_type underflow() 
    {
        std::cout &lt;&lt; &quot;Before underflow(): size of the get area is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; size of the put area is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        int_type ch = std::strstreambuf::underflow();
        std::cout &lt;&lt; &quot;After underflow(): size of the get area is &quot; &lt;&lt; egptr()-eback() &lt;&lt; ' '
                  &lt;&lt; &quot; size of the put area is &quot; &lt;&lt; epptr()-pbase() &lt;&lt; '\n';
        if (ch == EOF) {
            std::cout &lt;&lt; &quot;underflow() returns EOF\n&quot;;
        } else {
            std::cout &lt;&lt; &quot;underflow() returns '&quot; &lt;&lt; char(ch) &lt;&lt; &quot;'\n&quot;;
        }
        return ch;
    }
};

int main()
{
    mybuf sbuf; // read-write dynamic strstreambuf
    std::iostream stream(&amp;sbuf);

    int n;
    stream &gt;&gt; n;
    stream.clear();
    stream &lt;&lt; &quot;123&quot;;
    stream &gt;&gt; n;
    std::cout &lt;&lt; n &lt;&lt; '\n';
}
 | p=true
 | output=
Before underflow(): size of the get area is 0  size of the put area is 0
After underflow(): size of the get area is 0  size of the put area is 0
underflow() returns EOF
Before overflow(): size of the get area is 0  size of the put area is 0
After overflow(): size of the get area is 0  size of the put area is 32
Before underflow(): size of the get area is 0  size of the put area is 32
After underflow(): size of the get area is 3  size of the put area is 32
underflow() returns '1'
Before underflow(): size of the get area is 3  size of the put area is 32
After underflow(): size of the get area is 3  size of the put area is 32
underflow() returns EOF
123
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_stringbuf/dsc underflow}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/io/strstreambuf/~strstreambuf</title>
    <ns>0</ns>
    <id>12883</id>
    <revision>
      <id>64335</id>
      <parentid>64184</parentid>
      <timestamp>2013-08-15T18:24:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1838">{{cpp/io/strstreambuf/title|~strstreambuf}}
{{cpp/io/strstreambuf/navbar}}
{{dcl begin}}
{{dcl | 1=
virtual ~strstreambuf();
}}
{{dcl end}}

Destroys a {{tt|std::strstreambuf}} object. if the object is managing a dynamically-allocated buffer (the buffer state is &quot;allocated&quot;) and if the object is not frozen, then deallocates the buffer using the deallocation function provided at construction or {{c|delete[]}} if none was provided.

===Parameters===
(none0

===Notes===
This destructor is typically called by the destructor of {{lc|std::strstream}}

If {{lc|str()}} was called on a dynamic strstream and {{lc|freeze|freeze(false)}} was not called after that, this destructor leaks memory.

===Example===
{{example
 | 
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

void* my_alloc(size_t n)
{
    std::cout &lt;&lt; &quot;my_alloc(&quot; &lt;&lt; n &lt;&lt; &quot;) called\n&quot;;
    return new char[n];
}

void my_free(void* p)
{
    std::cout &lt;&lt; &quot;my_free() called\n&quot;;
    delete[] (char*)p;
}

int main()
{
    {
        std::strstreambuf buf(my_alloc, my_free);
        std::ostream s(&amp;buf);
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; buf.str() &lt;&lt; '\n';
        buf.freeze(false);
    } // destructor called here, buffer deallocated

    {
        std::strstreambuf buf(my_alloc, my_free);
        std::ostream s(&amp;buf);
        s &lt;&lt; 1.23;
        std::cout &lt;&lt; buf.str() &lt;&lt; '\n';
//        buf.freeze(false);
    } // destructor called here, memory leak!
}
 | output=
my_alloc(4096) called
1.23
my_free() called
my_alloc(4096) called
1.23
}}

[[de:cpp/io/strstreambuf/~strstreambuf]]
[[es:cpp/io/strstreambuf/~strstreambuf]]
[[fr:cpp/io/strstreambuf/~strstreambuf]]
[[it:cpp/io/strstreambuf/~strstreambuf]]
[[ja:cpp/io/strstreambuf/~strstreambuf]]
[[pt:cpp/io/strstreambuf/~strstreambuf]]
[[ru:cpp/io/strstreambuf/~strstreambuf]]
[[zh:cpp/io/strstreambuf/~strstreambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator</title>
    <ns>0</ns>
    <id>626</id>
    <revision>
      <id>67806</id>
      <parentid>66013</parentid>
      <timestamp>2014-02-28T16:48:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+make_reverse_iterator from C++14</comment>
      <text xml:space="preserve" bytes="3634">{{title|Iterator library}}
{{cpp/iterator/navbar}}

The iterator library provides definitions for five kinds of iterators as well as iterator traits, adapters, and utility functions. 

===Iterator categories===

There are five kinds of iterators: {{concept|InputIterator}}, {{concept|OutputIterator}}, {{concept|ForwardIterator}}, {{concept|BidirectionalIterator}}, and {{concept|RandomAccessIterator}}.

Instead of being defined by specific types, each category of iterator is defined by the operations that can be performed on it.  This definition means that any type that supports the necessary operations can be used as an iterator -- for example, a pointer supports all of the operations required by {{concept|RandomAccessIterator}}, so a pointer can be used anywhere a {{concept|RandomAccessIterator}} is expected.

Four of the five iterator categories can be organized into a hierarchy, where more powerful iterator categories (e.g. {{concept|RandomAccessIterator}}) support the operations of less powerful categories (e.g. {{concept|InputIterator}}). If an iterator falls into one of these categories and also satisfies the requirements of {{concept|OutputIterator}}, then it is called a ''mutable'' iterator and supports ''both'' input and output. Non-mutable iterators are called ''constant'' iterators.

{| class=&quot;wikitable&quot;
!colspan=&quot;4&quot;|Iterator category
!Defined operations
|-
|rowspan=&quot;4&quot;|{{concept|RandomAccessIterator}}
|rowspan=&quot;3&quot;|{{concept|BidirectionalIterator}}
|rowspan=&quot;2&quot;|{{concept|ForwardIterator}}
|{{concept|InputIterator}}
| 
* read
* increment (without multiple passes)
|-
|
|
* increment (with multiple passes)
|-
|colspan=&quot;2&quot;|
|
* decrement
|-
|colspan=&quot;3&quot;|
|
* random access
|-
| colspan=&quot;5&quot; style=&quot;text-align:center;&quot; |
Iterators that fall into one of the above categories and also meet the requirements of {{concept|OutputIterator}} are called mutable iterators.
|-
|{{concept|OutputIterator}}
|colspan=&quot;3&quot;|
|
* write
* increment (without multiple passes)
|}

=== Iterator primitives ===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc iterator_traits}}
{{dsc inc | cpp/iterator/dsc iterator_tags}}
{{dsc inc | cpp/iterator/dsc iterator}}
{{dsc end}}

=== Iterator adaptors ===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc reverse_iterator}}
{{dsc inc | cpp/iterator/dsc make_reverse_iterator}}
{{dsc inc | cpp/iterator/dsc move_iterator}}
{{dsc inc | cpp/iterator/dsc make_move_iterator}}
{{dsc inc | cpp/iterator/dsc back_insert_iterator}}
{{dsc inc | cpp/iterator/dsc back_inserter}}
{{dsc inc | cpp/iterator/dsc front_insert_iterator}}
{{dsc inc | cpp/iterator/dsc front_inserter}}
{{dsc inc | cpp/iterator/dsc insert_iterator}}
{{dsc inc | cpp/iterator/dsc inserter}}
{{dsc end}}

=== Stream iterators ===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc istream_iterator}}
{{dsc inc | cpp/iterator/dsc ostream_iterator}}
{{dsc inc | cpp/iterator/dsc istreambuf_iterator}}
{{dsc inc | cpp/iterator/dsc ostreambuf_iterator}}
{{dsc end}}

=== Iterator operations ===
{{dsc begin}}
{{dsc header | iterator}}
{{dsc inc | cpp/iterator/dsc advance}}
{{dsc inc | cpp/iterator/dsc distance}}
{{dsc inc | cpp/iterator/dsc next}}
{{dsc inc | cpp/iterator/dsc prev}}
{{dsc end}}

=== Range access ===
{{dsc begin}}
{{dsc header | iterator}}
{{dsc inc | cpp/iterator/dsc begin}}
{{dsc inc | cpp/iterator/dsc end}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc rend}}
{{dsc end}}

[[ar:cpp/iterator]]
[[de:cpp/iterator]]
[[es:cpp/iterator]]
[[fr:cpp/iterator]]
[[it:cpp/iterator]]
[[ja:cpp/iterator]]
[[ko:cpp/iterator]]
[[pt:cpp/iterator]]
[[ru:cpp/iterator]]
[[tr:cpp/iterator]]
[[zh:cpp/iterator]]</text>
      <sha1>7iwuzvztnwefgaltzk1hf42u7mpfpqi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/advance</title>
    <ns>0</ns>
    <id>2671</id>
    <revision>
      <id>57955</id>
      <parentid>49840</parentid>
      <timestamp>2013-06-01T06:04:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1377">{{cpp/title| advance}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl |
template&lt; class InputIt, class Distance &gt;
void advance( InputIt&amp; it, Distance n );
}}
{{dcl end}}

Increments given iterator {{tt|it}} by {{tt|n}} elements.

If {{tt|n}} is negative, the iterator is decremented. In this case, {{tt|InputIt}} must meet the requirements of {{concept|BidirectionalIterator}}, otherwise the behavior is undefined.

===Parameters===
{{par begin}}
{{par | it | iterator to be advanced }}
{{par | n | number of elements {{tt|it}} should be advanced}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
(none)

===Complexity===
Linear. 

However, if {{tt|InputIt}} additionally meets the requirements of {{concept|RandomAccessIterator}}, complexity is constant.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v{ 3, 1, 4 };
    
    auto vi = v.begin();

    std::advance(vi, 2);

    std::cout &lt;&lt; *vi &lt;&lt; '\n';
}
 | output=4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc distance}}
{{dsc end}}

[[de:cpp/iterator/advance]]
[[es:cpp/iterator/advance]]
[[fr:cpp/iterator/advance]]
[[it:cpp/iterator/advance]]
[[ja:cpp/iterator/advance]]
[[pt:cpp/iterator/advance]]
[[ru:cpp/iterator/advance]]
[[zh:cpp/iterator/advance]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back insert iterator</title>
    <ns>0</ns>
    <id>4949</id>
    <revision>
      <id>69159</id>
      <parentid>62435</parentid>
      <timestamp>2014-03-28T17:44:55Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2370">{{cpp/title|back_insert_iterator}}
{{cpp/iterator/back_insert_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class Container &gt;
class back_insert_iterator : public std::iterator&lt; std::output_iterator_tag,
                                                   void, void, void, void &gt;
}}
{{dcl end}}

{{tt|std::back_insert_iterator}} is an {{concept|OutputIterator}} that appends to a container for which it was constructed. The container's {{tt|push_back()}} member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the {{tt|std::back_insert_iterator}} is a no-op.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|container_type}} | {{tt|Container}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/inserter/dsc constructor | back_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator{{=}} | back_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | back_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | back_insert_iterator}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Definition}}
{{dsc | {{tt|container}} {{mark|protected}} | a pointer of type {{tt|Container*}} }}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;cstdlib&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v;
    std::generate_n(std::back_insert_iterator&lt;std::vector&lt;int&gt;&gt;(v), // can be simplified
                    10, [](){ return std::rand() % 10; });        // with std::back_inserter
    for (int n : v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
3 6 7 5 3 5 6 2 9 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc back_inserter}}
{{dsc inc | cpp/iterator/dsc front_insert_iterator}}
{{dsc inc | cpp/iterator/dsc insert_iterator}}
{{dsc end}}

[[de:cpp/iterator/back insert iterator]]
[[es:cpp/iterator/back insert iterator]]
[[fr:cpp/iterator/back insert iterator]]
[[it:cpp/iterator/back insert iterator]]
[[ja:cpp/iterator/back insert iterator]]
[[pt:cpp/iterator/back insert iterator]]
[[ru:cpp/iterator/back insert iterator]]
[[zh:cpp/iterator/back insert iterator]]</text>
      <sha1>67qb4mjtw13o2mfcb3vzbdhm867erw5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back insert iterator/back insert iterator</title>
    <ns>0</ns>
    <id>8756</id>
    <revision>
      <id>50876</id>
      <parentid>42475</parentid>
      <timestamp>2013-06-01T03:42:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="568">{{include page|cpp/iterator/inserter/constructor|back_insert_iterator}}

[[de:cpp/iterator/back insert iterator/back insert iterator]]
[[es:cpp/iterator/back insert iterator/back insert iterator]]
[[fr:cpp/iterator/back insert iterator/back insert iterator]]
[[it:cpp/iterator/back insert iterator/back insert iterator]]
[[ja:cpp/iterator/back insert iterator/back insert iterator]]
[[pt:cpp/iterator/back insert iterator/back insert iterator]]
[[ru:cpp/iterator/back insert iterator/back insert iterator]]
[[zh:cpp/iterator/back insert iterator/back insert iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back insert iterator/operator*</title>
    <ns>0</ns>
    <id>8747</id>
    <revision>
      <id>42467</id>
      <parentid>36902</parentid>
      <timestamp>2012-11-02T23:24:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="465">{{cpp/iterator/inserter/operator*|back_insert_iterator}}

[[de:cpp/iterator/back insert iterator/operator*]]
[[es:cpp/iterator/back insert iterator/operator*]]
[[fr:cpp/iterator/back insert iterator/operator*]]
[[it:cpp/iterator/back insert iterator/operator*]]
[[ja:cpp/iterator/back insert iterator/operator*]]
[[pt:cpp/iterator/back insert iterator/operator*]]
[[ru:cpp/iterator/back insert iterator/operator*]]
[[zh:cpp/iterator/back insert iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back insert iterator/operator++</title>
    <ns>0</ns>
    <id>8746</id>
    <revision>
      <id>42458</id>
      <parentid>36901</parentid>
      <timestamp>2012-11-02T23:22:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="474">{{cpp/iterator/inserter/operator++|back_insert_iterator}}

[[de:cpp/iterator/back insert iterator/operator++]]
[[es:cpp/iterator/back insert iterator/operator++]]
[[fr:cpp/iterator/back insert iterator/operator++]]
[[it:cpp/iterator/back insert iterator/operator++]]
[[ja:cpp/iterator/back insert iterator/operator++]]
[[pt:cpp/iterator/back insert iterator/operator++]]
[[ru:cpp/iterator/back insert iterator/operator++]]
[[zh:cpp/iterator/back insert iterator/operator++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back insert iterator/operator=</title>
    <ns>0</ns>
    <id>8757</id>
    <revision>
      <id>42452</id>
      <parentid>36912</parentid>
      <timestamp>2012-11-02T23:21:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="469">{{cpp/iterator/inserter/operator{{=}}|back_insert_iterator}}

[[de:cpp/iterator/back insert iterator/operator=]]
[[es:cpp/iterator/back insert iterator/operator=]]
[[fr:cpp/iterator/back insert iterator/operator=]]
[[it:cpp/iterator/back insert iterator/operator=]]
[[ja:cpp/iterator/back insert iterator/operator=]]
[[pt:cpp/iterator/back insert iterator/operator=]]
[[ru:cpp/iterator/back insert iterator/operator=]]
[[zh:cpp/iterator/back insert iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/back inserter</title>
    <ns>0</ns>
    <id>4834</id>
    <revision>
      <id>62340</id>
      <parentid>62339</parentid>
      <timestamp>2013-06-27T00:03:47Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1609">{{cpp/title|back_inserter}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl |
template&lt; class Container &gt;
std::back_insert_iterator&lt;Container&gt; back_inserter( Container&amp; c );
}}
{{dcl end}}

{{tt|back_inserter}} is a convenience function template that constructs a {{lc|std::back_insert_iterator}} for the container {{tt|c}} with the type deduced from the type of the argument.

===Parameters===
{{par begin}}
{{par | c | container that supports a push_back operation}}
{{par end}}

===Return value===
A {{lc|std::back_insert_iterator}} which can be used to add elements to the end of the container {{tt|c}}

===Possible implementation===
{{eq fun | 1=
template&lt; class Container &gt;
std::back_insert_iterator&lt;Container&gt; back_inserter( Container&amp; c )
{
    return std::back_insert_iterator&lt;Container&gt;(c);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    std::vector&lt;int&gt; v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::fill_n(std::back_inserter(v), 3, -1);
    for (int n : v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
 | output=
1 2 3 4 5 6 7 8 9 10 -1 -1 -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc back_insert_iterator}}
{{dsc inc | cpp/iterator/dsc front_inserter}}
{{dsc inc | cpp/iterator/dsc inserter}}
{{dsc end}}

[[de:cpp/iterator/back inserter]]
[[es:cpp/iterator/back inserter]]
[[fr:cpp/iterator/back inserter]]
[[it:cpp/iterator/back inserter]]
[[ja:cpp/iterator/back inserter]]
[[pt:cpp/iterator/back inserter]]
[[ru:cpp/iterator/back inserter]]
[[zh:cpp/iterator/back inserter]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/begin</title>
    <ns>0</ns>
    <id>2532</id>
    <revision>
      <id>71994</id>
      <parentid>71053</parentid>
      <timestamp>2014-07-07T05:37:25Z</timestamp>
      <contributor>
        <username>Marc van Leeuwen</username>
        <id>3164</id>
      </contributor>
      <minor/>
      <comment>English</comment>
      <text xml:space="preserve" bytes="3299">{{cpp/title| begin}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | num=1 | since=c++11 |
template&lt; class C &gt; 
auto begin( C&amp; c ) -&gt; decltype(c.begin());
}}
{{dcl | num=1 | since=c++11 |
template&lt; class C &gt; 
auto begin( const C&amp; c ) -&gt; decltype(c.begin());
}}
{{dcl rev begin|num=2}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, size_t N &gt; 
T* begin( T (&amp;array)[N] );
}}
{{dcl | since=c++14 |
template&lt; class T, size_t N &gt; 
constexpr T* begin( T (&amp;array)[N] );
}}
{{dcl rev end}}
{{dcl | num=3 | since=c++14 |
template&lt; class C &gt; 
constexpr auto cbegin( const C&amp; c ) -&gt; decltype(std::begin(c));
}}
{{dcl end}}

Returns an iterator to the beginning of the given container {{tt|c}} or array {{tt|array}}.

@1@ Returns a possibly const-qualified iterator to the beginning of the container {{tt|c}}.
@2@ Returns a pointer to the beginning of the array {{tt|array}}.
@3@ Returns a const-qualified iterator to the beginning of the container {{tt|c}}.

{{image|range-begin-end.svg}}

===Parameters===
{{par begin}}
{{par | c | a container with a {{tt|begin}} method}}
{{par | array | an array of arbitrary type}}
{{par end}}

===Return value===
An iterator to the beginning of {{tt|c}} or {{tt|array}}

===Exceptions===
@2@ {{noexcept}}{{mark since c++14}}
@3@ {{noexcept|noexcept(std::begin(c))}}

===Notes===
In addition to being included in {{tt|&lt;iterator&gt;}}, {{tt|std::begin}} is guaranteed to become available if any of the following headers are included: {{tt|&lt;array&gt;}}, {{tt|&lt;deque&gt;}}, {{tt|&lt;forward_list&gt;}}, {{tt|&lt;list&gt;}}, {{tt|&lt;map&gt;}}, {{tt|&lt;regex&gt;}}, {{tt|&lt;set&gt;}}, {{tt|&lt;string&gt;}}, {{tt|&lt;unordered_map&gt;}}, {{tt|&lt;unordered_set&gt;}}, and {{tt|&lt;vector&gt;}}.

===User-defined overloads===
Custom overloads of {{tt|std::begin}} may be provided for classes that do not expose a suitable {{tt|begin()}} member function, yet can be iterated. The following overloads are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc begin2}}
{{dsc inc | cpp/numeric/valarray/dsc begin2}}
{{dsc end}}

Similar to the use of {{tt|swap}} (described in {{concept|Swappable}}), typical use of the {{tt|begin}} function in generic context is an equivalent of {{c|using std::begin; begin(arg);}}, which allows both the [[cpp/language/adl|ADL]]-selected overloads for user-defined types and the standard library function templates to appear in the same overload set.
{{source|1=
template&lt;typename Container, typename Function&gt;
void for_each(Container&amp;&amp; cont, Function f) {
    using std::begin;
    auto it = begin(cont);
    using std::end;
    auto end_it = end(cont);
    while (it != end_it) {
        f(*it);
        ++it;
    }
}
}}

===Example===
{{example
 |
 | code=#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;

int main() 
{
    std::vector&lt;int&gt; v = { 3, 1, 4 };
    auto vi = std::begin(v);
    std::cout &lt;&lt; *vi &lt;&lt; '\n'; 

    int a[] = { -5, 10, 15 };
    auto ai = std::begin(a);
    std::cout &lt;&lt; *ai &lt;&lt; '\n';
}
 | output=
3
-5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc end}}
{{dsc end}}

[[de:cpp/iterator/begin]]
[[es:cpp/iterator/begin]]
[[fr:cpp/iterator/begin]]
[[it:cpp/iterator/begin]]
[[ja:cpp/iterator/begin]]
[[pt:cpp/iterator/begin]]
[[ru:cpp/iterator/begin]]
[[zh:cpp/iterator/begin]]</text>
      <sha1>cfprd7olzjf67wtzkzbpe72r7jkuxnk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/concepts</title>
    <ns>0</ns>
    <id>2151</id>
    <redirect title="cpp/concept" />
    <revision>
      <id>31711</id>
      <parentid>22876</parentid>
      <timestamp>2012-06-06T20:29:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/concept#Iterator]]</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/concept#Iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/distance</title>
    <ns>0</ns>
    <id>2672</id>
    <revision>
      <id>72103</id>
      <parentid>57963</parentid>
      <timestamp>2014-07-15T20:47:24Z</timestamp>
      <contributor>
        <ip>96.255.140.87</ip>
      </contributor>
      <comment>&quot;last&quot; might not point to an element at all (e.g. when obtained from std::vector&lt;int&gt;::end())</comment>
      <text xml:space="preserve" bytes="1588">{{cpp/title| distance}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl |
template&lt; class InputIt &gt;
typename std::iterator_traits&lt;InputIt&gt;::difference_type 
    distance( InputIt first, InputIt last );
}}
{{dcl end}}

Returns the number of elements between {{tt|first}} and {{tt|last}}.

The behavior is undefined if {{tt|last}} is not reachable from {{tt|first}} by (possibly repeatedly) incrementing {{tt|first}}.

===Parameters===
{{par begin}}
{{par | first | iterator pointing to the first element}}
{{par | last | iterator pointing to the end of the range}}
{{par hreq}}
{{par req concept | InputIt | InputIterator | notes=The operation is more efficient if {{tt|InputIt}} additionally meets the requirements of {{concept|RandomAccessIterator}}}}
{{par end}}

===Return value===
The number of elements between {{tt|first}} and {{tt|last}}.

===Complexity===
Linear. 

However, if {{tt|InputIt}} additionally meets the requirements of {{concept|RandomAccessIterator}}, complexity is constant.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v{ 3, 1, 4 };

    auto distance = std::distance(v.begin(), v.end());

    std::cout &lt;&lt; distance &lt;&lt; '\n';
}
 | output=
3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc advance}}
{{dsc end}}

[[de:cpp/iterator/distance]]
[[es:cpp/iterator/distance]]
[[fr:cpp/iterator/distance]]
[[it:cpp/iterator/distance]]
[[ja:cpp/iterator/distance]]
[[pt:cpp/iterator/distance]]
[[ru:cpp/iterator/distance]]
[[zh:cpp/iterator/distance]]</text>
      <sha1>20ozkdgafionx6iivqzwk2xx8yyu27w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/end</title>
    <ns>0</ns>
    <id>2533</id>
    <revision>
      <id>71054</id>
      <parentid>71050</parentid>
      <timestamp>2014-06-05T01:18:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/specializations/overloads</comment>
      <text xml:space="preserve" bytes="3522">{{cpp/title| end}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | num=1 | since=c++11 |
template&lt; class C &gt; 
auto end( C&amp; c ) -&gt; decltype(c.end());
}}
{{dcl | num=1 | since=c++11 |
template&lt; class C &gt; 
auto end( const C&amp; c ) -&gt; decltype(c.end());
}}
{{dcl rev begin|num=2}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T, size_t N &gt; 
T* end( T (&amp;array)[N] );
}}
{{dcl | since=c++14 |
template&lt; class T, size_t N &gt; 
constexpr T* end( T (&amp;array)[N] );
}}
{{dcl rev end}}
{{dcl | num=3 | since=c++14 |
template&lt; class C &gt; 
constexpr auto cend( const C&amp; c ) -&gt; decltype(std::end(c));
}}
{{dcl end}}

Returns an iterator to the end (i.e. the element after the last element) of the given container {{tt|c}} or array {{tt|array}}.

@1@ Returns a possibly const-qualified iterator to the end of the container {{tt|c}}.
@2@ Returns a pointer to the end of the array {{tt|array}}.
@3@ Returns a const-qualified iterator to the end of the container {{tt|c}}.

{{image|range-begin-end.svg}}

===Parameters===
{{par begin}}
{{par | c | a container with an {{tt|end}} method}}
{{par | array | an array of arbitrary type}}
{{par end}}

===Return value===
An iterator to the end of {{tt|c}} or {{tt|array}}.  Note that the end of a container or array is defined as the element following the last valid element.

===Exceptions===
@2@ {{noexcept}}{{mark since c++14}}
@3@ {{noexcept|noexcept(std::end(c))}}

===Notes===
In addition to being included in {{tt|&lt;iterator&gt;}}, {{tt|std::end}} is guaranteed to become available if any of the following headers are included: {{tt|&lt;array&gt;}}, {{tt|&lt;deque&gt;}}, {{tt|&lt;forward_list&gt;}}, {{tt|&lt;list&gt;}}, {{tt|&lt;map&gt;}}, {{tt|&lt;regex&gt;}}, {{tt|&lt;set&gt;}}, {{tt|&lt;string&gt;}}, {{tt|&lt;unordered_map&gt;}}, {{tt|&lt;unordered_set&gt;}}, and {{tt|&lt;vector&gt;}}.

===User-defined overloads===
Custom overloads of {{tt|std::end}} may be provided for classes that do not expose a suitable {{tt|end()}} member function, yet can be iterated. The following overloads are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc end2}}
{{dsc inc | cpp/numeric/valarray/dsc end2}}
{{dsc end}}

Similar to the use of {{tt|swap}} (described in {{concept|Swappable}}), typical use of the {{tt|end}} function in generic context is an equivalent of {{c|using std::end; end(arg);}}, which lets both the [[cpp/language/adl|ADL]]-selected overloads for user-defined types and the standard library function templates to appear in the same overload set.
{{source|1=
template&lt;typename Container, typename Function&gt;
void for_each(Container&amp;&amp; cont, Function f) {
    using std::begin;
    auto it = begin(cont);
    using std::end;
    auto end_it = end(cont);
    while (it != end_it) {
        f(*it);
        ++it;
    }
}
}}

===Example===
{{example
 |
 | code=#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;

int main() 
{
    std::vector&lt;int&gt; v = { 3, 1, 4 };
    if (std::find(std::begin(v), std::end(v), 5) != std::end(v)) {
        std::cout &lt;&lt; &quot;found a 5 in vector v!\n&quot;;
    }

    int a[] = { 5, 10, 15 };
    if (std::find(std::begin(a), std::end(a), 5) != std::end(a)) {
        std::cout &lt;&lt; &quot;found a 5 in array a!\n&quot;;
    }
}
 | output=found a 5 in array a!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc begin}}
{{dsc end}}

[[de:cpp/iterator/end]]
[[es:cpp/iterator/end]]
[[fr:cpp/iterator/end]]
[[it:cpp/iterator/end]]
[[ja:cpp/iterator/end]]
[[pt:cpp/iterator/end]]
[[ru:cpp/iterator/end]]
[[zh:cpp/iterator/end]]</text>
      <sha1>1hvudbx9mkpl6o16hqnqoa3a82tsfno</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front insert iterator</title>
    <ns>0</ns>
    <id>4953</id>
    <revision>
      <id>72450</id>
      <parentid>62317</parentid>
      <timestamp>2014-08-22T15:04:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link concept</comment>
      <text xml:space="preserve" bytes="2359">{{cpp/title|front_insert_iterator}}
{{cpp/iterator/front_insert_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class Container &gt;
class front_insert_iterator : public std::iterator&lt; std::output_iterator_tag,
                                                   void,void,void,void &gt;
}}
{{dcl end}}

{{tt|std::front_insert_iterator}} is an {{concept|OutputIterator}} that prepends elements to a container for which it was constructed. The container's {{tt|push_front()}} member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the {{tt|std::front_insert_iterator}} is a no-op.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|container_type}} | {{tt|Container}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/inserter/dsc constructor | front_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator{{=}} | front_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | front_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | front_insert_iterator}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Definition}}
{{dsc | {{tt|container}} {{mark|protected}} | a pointer of type {{tt|Container*}} }}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 | 
 | code=
#include &lt;vector&gt;
#include &lt;deque&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
int main()
{
    std::vector&lt;int&gt; v{1,2,3,4,5};
    std::deque&lt;int&gt; d;
    std::copy(v.begin(), v.end(),
              std::front_insert_iterator&lt;std::deque&lt;int&gt;&gt;(d)); // or std::front_inserter(d)
    for(int n : d)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
5 4 3 2 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc front_inserter}}
{{dsc inc | cpp/iterator/dsc back_insert_iterator}}
{{dsc inc | cpp/iterator/dsc insert_iterator}}
{{dsc end}}

[[de:cpp/iterator/front insert iterator]]
[[es:cpp/iterator/front insert iterator]]
[[fr:cpp/iterator/front insert iterator]]
[[it:cpp/iterator/front insert iterator]]
[[ja:cpp/iterator/front insert iterator]]
[[pt:cpp/iterator/front insert iterator]]
[[ru:cpp/iterator/front insert iterator]]
[[zh:cpp/iterator/front insert iterator]]</text>
      <sha1>pgucn60mchdhtd83mxp8hpbefvdtusn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front insert iterator/front insert iterator</title>
    <ns>0</ns>
    <id>8748</id>
    <revision>
      <id>50877</id>
      <parentid>42418</parentid>
      <timestamp>2013-06-01T03:42:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="585">{{include page|cpp/iterator/inserter/constructor|front_insert_iterator}}

[[de:cpp/iterator/front insert iterator/front insert iterator]]
[[es:cpp/iterator/front insert iterator/front insert iterator]]
[[fr:cpp/iterator/front insert iterator/front insert iterator]]
[[it:cpp/iterator/front insert iterator/front insert iterator]]
[[ja:cpp/iterator/front insert iterator/front insert iterator]]
[[pt:cpp/iterator/front insert iterator/front insert iterator]]
[[ru:cpp/iterator/front insert iterator/front insert iterator]]
[[zh:cpp/iterator/front insert iterator/front insert iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front insert iterator/operator*</title>
    <ns>0</ns>
    <id>8750</id>
    <revision>
      <id>42410</id>
      <parentid>36905</parentid>
      <timestamp>2012-11-02T23:12:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="474">{{cpp/iterator/inserter/operator*|front_insert_iterator}}

[[de:cpp/iterator/front insert iterator/operator*]]
[[es:cpp/iterator/front insert iterator/operator*]]
[[fr:cpp/iterator/front insert iterator/operator*]]
[[it:cpp/iterator/front insert iterator/operator*]]
[[ja:cpp/iterator/front insert iterator/operator*]]
[[pt:cpp/iterator/front insert iterator/operator*]]
[[ru:cpp/iterator/front insert iterator/operator*]]
[[zh:cpp/iterator/front insert iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front insert iterator/operator++</title>
    <ns>0</ns>
    <id>8751</id>
    <revision>
      <id>42402</id>
      <parentid>36906</parentid>
      <timestamp>2012-11-02T23:10:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="483">{{cpp/iterator/inserter/operator++|front_insert_iterator}}

[[de:cpp/iterator/front insert iterator/operator++]]
[[es:cpp/iterator/front insert iterator/operator++]]
[[fr:cpp/iterator/front insert iterator/operator++]]
[[it:cpp/iterator/front insert iterator/operator++]]
[[ja:cpp/iterator/front insert iterator/operator++]]
[[pt:cpp/iterator/front insert iterator/operator++]]
[[ru:cpp/iterator/front insert iterator/operator++]]
[[zh:cpp/iterator/front insert iterator/operator++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front insert iterator/operator=</title>
    <ns>0</ns>
    <id>8749</id>
    <revision>
      <id>42392</id>
      <parentid>36904</parentid>
      <timestamp>2012-11-02T23:08:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="478">{{cpp/iterator/inserter/operator{{=}}|front_insert_iterator}}

[[de:cpp/iterator/front insert iterator/operator=]]
[[es:cpp/iterator/front insert iterator/operator=]]
[[fr:cpp/iterator/front insert iterator/operator=]]
[[it:cpp/iterator/front insert iterator/operator=]]
[[ja:cpp/iterator/front insert iterator/operator=]]
[[pt:cpp/iterator/front insert iterator/operator=]]
[[ru:cpp/iterator/front insert iterator/operator=]]
[[zh:cpp/iterator/front insert iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/front inserter</title>
    <ns>0</ns>
    <id>4853</id>
    <revision>
      <id>66366</id>
      <parentid>66365</parentid>
      <timestamp>2013-11-13T00:23:31Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1630">{{cpp/title|front_inserter}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl |
template&lt; class Container &gt;
std::front_insert_iterator&lt;Container&gt; front_inserter( Container&amp; c );
}}
{{dcl end}}

{{tt|front_inserter}} is a convenience function template that constructs a {{lc|std::front_insert_iterator}} for the container {{tt|c}} with the type deduced from the type of the argument.

===Parameters===
{{par begin}}
{{par | c | container that supports a {{tt|push_front}} operation}}
{{par end}}

===Return value===
A {{lc|std::front_insert_iterator}} which can be used to add elements to the beginning of the container {{tt|c}}

===Possible implementation===
{{eq fun | 1=
template&lt; class Container &gt;
std::front_insert_iterator&lt;Container&gt; front_inserter( Container&amp; c )
{
    return std::front_insert_iterator&lt;Container&gt;(c);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;deque&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;

int main()
{
    std::deque&lt;int&gt; v{1,2,3,4,5,6,7,8,9,10};
    std::fill_n(std::front_inserter(v), 3, -1);
    for (int n : v)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
 | output=
-1 -1 -1 1 2 3 4 5 6 7 8 9 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc front_insert_iterator}}
{{dsc inc | cpp/iterator/dsc back_inserter}}
{{dsc inc | cpp/iterator/dsc inserter}}
{{dsc end}}

[[de:cpp/iterator/front inserter]]
[[es:cpp/iterator/front inserter]]
[[fr:cpp/iterator/front inserter]]
[[it:cpp/iterator/front inserter]]
[[ja:cpp/iterator/front inserter]]
[[pt:cpp/iterator/front inserter]]
[[ru:cpp/iterator/front inserter]]
[[zh:cpp/iterator/front inserter]]</text>
      <sha1>bghhq35dwkiy65okawk4wh3l5o36kjq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/insert iterator</title>
    <ns>0</ns>
    <id>4957</id>
    <revision>
      <id>72451</id>
      <parentid>63622</parentid>
      <timestamp>2014-08-22T15:05:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link concept</comment>
      <text xml:space="preserve" bytes="2439">{{cpp/title|insert_iterator}}
{{cpp/iterator/insert_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class Container &gt;
class insert_iterator : public std::iterator&lt; std::output_iterator_tag,
                                              void,void,void,void &gt;
}}
{{dcl end}}

{{tt|std::insert_iterator}} is an {{concept|OutputIterator}} that inserts elements into a container for which it was constructed, at the position pointed to by the supplied iterator. The container's {{tt|insert()}} member function is called whenever the iterator (whether dereferenced or not) is assigned to. Incrementing the {{tt|std::insert_iterator}} is a no-op.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|container_type}} | {{tt|Container}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/inserter/dsc constructor | insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator{{=}} | insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | insert_iterator}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Definition}}
{{dsc | {{tt|container}} {{mark|protected}} | a pointer of type {{tt|Container*}} }}
{{dsc | {{tt|iter}} {{mark|protected}} | an iterator of type {{tt|Container::iterator}} }}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 | 
 | code=
#include &lt;vector&gt;
#include &lt;list&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;

int main()
{
    std::vector&lt;int&gt; v{1,2,3,4,5};
    std::list&lt;int&gt; l{-1,-2,-3};
    std::copy(v.begin(), v.end(), // may be simplified with std::inserter
              std::insert_iterator&lt;std::list&lt;int&gt;&gt;(l, std::next(l.begin()))); 
    for (int n : l)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
-1 1 2 3 4 5 -2 -3 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc inserter}}
{{dsc inc | cpp/iterator/dsc back_insert_iterator}}
{{dsc inc | cpp/iterator/dsc front_insert_iterator}}
{{dsc end}}

[[de:cpp/iterator/insert iterator]]
[[es:cpp/iterator/insert iterator]]
[[fr:cpp/iterator/insert iterator]]
[[it:cpp/iterator/insert iterator]]
[[ja:cpp/iterator/insert iterator]]
[[pt:cpp/iterator/insert iterator]]
[[ru:cpp/iterator/insert iterator]]
[[zh:cpp/iterator/insert iterator]]</text>
      <sha1>ajn3jfskfuar4r65aratryxbf6iivy2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/insert iterator/insert iterator</title>
    <ns>0</ns>
    <id>8752</id>
    <revision>
      <id>50878</id>
      <parentid>42357</parentid>
      <timestamp>2013-06-01T03:42:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="483">{{include page|cpp/iterator/inserter/constructor|insert_iterator}}

[[de:cpp/iterator/insert iterator/insert iterator]]
[[es:cpp/iterator/insert iterator/insert iterator]]
[[fr:cpp/iterator/insert iterator/insert iterator]]
[[it:cpp/iterator/insert iterator/insert iterator]]
[[ja:cpp/iterator/insert iterator/insert iterator]]
[[pt:cpp/iterator/insert iterator/insert iterator]]
[[ru:cpp/iterator/insert iterator/insert iterator]]
[[zh:cpp/iterator/insert iterator/insert iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/insert iterator/operator*</title>
    <ns>0</ns>
    <id>8754</id>
    <revision>
      <id>42353</id>
      <parentid>36909</parentid>
      <timestamp>2012-11-02T22:58:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="420">{{cpp/iterator/inserter/operator*|insert_iterator}}

[[de:cpp/iterator/insert iterator/operator*]]
[[es:cpp/iterator/insert iterator/operator*]]
[[fr:cpp/iterator/insert iterator/operator*]]
[[it:cpp/iterator/insert iterator/operator*]]
[[ja:cpp/iterator/insert iterator/operator*]]
[[pt:cpp/iterator/insert iterator/operator*]]
[[ru:cpp/iterator/insert iterator/operator*]]
[[zh:cpp/iterator/insert iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/insert iterator/operator++</title>
    <ns>0</ns>
    <id>8755</id>
    <revision>
      <id>42347</id>
      <parentid>36910</parentid>
      <timestamp>2012-11-02T22:57:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="429">{{cpp/iterator/inserter/operator++|insert_iterator}}

[[de:cpp/iterator/insert iterator/operator++]]
[[es:cpp/iterator/insert iterator/operator++]]
[[fr:cpp/iterator/insert iterator/operator++]]
[[it:cpp/iterator/insert iterator/operator++]]
[[ja:cpp/iterator/insert iterator/operator++]]
[[pt:cpp/iterator/insert iterator/operator++]]
[[ru:cpp/iterator/insert iterator/operator++]]
[[zh:cpp/iterator/insert iterator/operator++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/insert iterator/operator=</title>
    <ns>0</ns>
    <id>8753</id>
    <revision>
      <id>42338</id>
      <parentid>36908</parentid>
      <timestamp>2012-11-02T22:55:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="424">{{cpp/iterator/inserter/operator{{=}}|insert_iterator}}

[[de:cpp/iterator/insert iterator/operator=]]
[[es:cpp/iterator/insert iterator/operator=]]
[[fr:cpp/iterator/insert iterator/operator=]]
[[it:cpp/iterator/insert iterator/operator=]]
[[ja:cpp/iterator/insert iterator/operator=]]
[[pt:cpp/iterator/insert iterator/operator=]]
[[ru:cpp/iterator/insert iterator/operator=]]
[[zh:cpp/iterator/insert iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/inserter</title>
    <ns>0</ns>
    <id>4854</id>
    <revision>
      <id>63256</id>
      <parentid>57972</parentid>
      <timestamp>2013-07-07T15:02:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>expand example</comment>
      <text xml:space="preserve" bytes="1956">{{cpp/title|inserter}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl |
template&lt; class Container &gt;
std::insert_iterator&lt;Container&gt; inserter( Container&amp; c, typename Container::iterator i );
}}
{{dcl end}}

{{tt|inserter}} is a convenience function template that constructs a {{lc|std::insert_iterator}} for the container {{tt|c}} and its iterator {{tt|i}} with the type deduced from the type of the argument.

===Parameters===
{{par begin}}
{{par | c | container that supports a {{tt|insert}} operation}}
{{par | i | iterator in {{tt|c}} indicating the insertion position}}
{{par end}}

===Return value===
A {{lc|std::insert_iterator}} which can be used to insert elements into the container {{tt|c}} at the position indicated by {{tt|i}}.

===Possible implementation===
{{eq fun | 1=
template&lt; class Container &gt;
std::insert_iterator&lt;Container&gt; inserter( Container&amp; c, typename Container::iterator i )
{
    return std::insert_iterator&lt;Container&gt;(c, i);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;list&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;set&gt;

int main()
{
    std::list&lt;int&gt; l{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::multiset&lt;int&gt; s;

    std::fill_n(std::inserter(l, std::next(l.begin())), 3, -1);
    std::fill_n(std::inserter(s, s.begin()), 3, -1);

    for (int n : l) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    for (int n : s) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
1 -1 -1 -1 2 3 4 5 6 7 8 9 10 
-1 -1 -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc insert_iterator}}
{{dsc inc | cpp/iterator/dsc back_inserter}}
{{dsc inc | cpp/iterator/dsc front_inserter}}
{{dsc end}}

[[de:cpp/iterator/inserter]]
[[es:cpp/iterator/inserter]]
[[fr:cpp/iterator/inserter]]
[[it:cpp/iterator/inserter]]
[[ja:cpp/iterator/inserter]]
[[pt:cpp/iterator/inserter]]
[[ru:cpp/iterator/inserter]]
[[zh:cpp/iterator/inserter]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istream iterator</title>
    <ns>0</ns>
    <id>4909</id>
    <revision>
      <id>67605</id>
      <parentid>67572</parentid>
      <timestamp>2014-02-12T23:58:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo in the note</comment>
      <text xml:space="preserve" bytes="3362">{{cpp/title|istream_iterator}}
{{cpp/iterator/istream_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class T,
          class CharT = char,
          class Traits = std::char_traits&lt;CharT&gt;,
          class Distance = std::ptrdiff_t &gt;
class istream_iterator: public std::iterator&lt;std::input_iterator_tag,
                                             T, Distance, const T*, const T&amp;&gt;
}}
{{dcl end}}

{{tt|std::istream_iterator}} is a single-pass input iterator that reads successive objects of type {{tt|T}} from the {{lc|std::basic_istream}} object for which it was constructed, by calling the appropriate {{tt|operator&gt;&gt;}}. The actual read operation is performed when the iterator is incremented, not when it is dereferenced. The first object may be read when the iterator is constructed or when the first dereferencing is done. Otherwise, dereferencing only returns a copy of the most recently read object.

The default-constructed {{tt|std::istream_iterator}} is known as the ''end-of-stream'' iterator. When a valid {{tt|std::istream_iterator}} reaches the end of the underlying stream, it becomes equal to the end-of-stream iterator. Dereferencing or incrementing it further invokes undefined behavior.

A typical implementation of {{tt|std::istream_iterator}} holds two data members: a pointer to the associated {{lc|std::basic_istream}} object and the most recently read value of type {{tt|T}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}}}}
{{dsc | {{tt|istream_type}} | {{c|std::basic_istream&lt;CharT, Traits&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/istream_iterator/dsc constructor}}
{{dsc inc | cpp/iterator/istream_iterator/dsc destructor}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator_arith}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator_cmp}}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::input_iterator_tag|T|Distance|const T*|const T&amp;}}

===Notes===
When reading characters, {{tt|std::istream_iterator}} skips whitespace by default (unless disabled with {{lc|std::noskipws}} or equivalent), while {{lc|std::istreambuf_iterator}} does not. In addition, {{lc|std::istreambuf_iterator}} is more efficient, since it avoids the overhead of constructing and destructing the sentry object once per character.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;
#include &lt;numeric&gt;

int main()
{
    std::istringstream str(&quot;0.1 0.2 0.3 0.4&quot;);
    std::partial_sum(std::istream_iterator&lt;double&gt;(str),
                     std::istream_iterator&lt;double&gt;(),
                     std::ostream_iterator&lt;double&gt;(std::cout, &quot; &quot;));
}
 | output=
0.1 0.3 0.6 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc ostream_iterator}}
{{dsc inc | cpp/iterator/dsc istreambuf_iterator}}
{{dsc end}}

[[de:cpp/iterator/istream iterator]]
[[es:cpp/iterator/istream iterator]]
[[fr:cpp/iterator/istream iterator]]
[[it:cpp/iterator/istream iterator]]
[[ja:cpp/iterator/istream iterator]]
[[pt:cpp/iterator/istream iterator]]
[[ru:cpp/iterator/istream iterator]]
[[zh:cpp/iterator/istream iterator]]</text>
      <sha1>14ifyt3elg3yq6zol7iu31qoxy1gbcc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istream iterator/istream iterator</title>
    <ns>0</ns>
    <id>9904</id>
    <revision>
      <id>61403</id>
      <parentid>49851</parentid>
      <timestamp>2013-06-05T23:05:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1317">{{cpp/iterator/istream_iterator/title|istream_iterator}}
{{cpp/iterator/istream_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|notes=&lt;br&gt;{{mark|since C++11, only if T is literal type}}|1=
istream_iterator();
constexpr istream_iterator();
}}
{{dcl |num=2|1=
istream_iterator( istream_type&amp; stream );
}}
{{dcl |num=3|1=
istream_iterator( const istream_iterator&amp; other ) = default;
}}
{{dcl end}}

@1@ Constructs the end-of-stream iterator.
@2@ Initializes the iterator and stores the address of {{tt|stream}} in a data member. Optionally, performs the first read from the input stream to initialize the cached value data member (although it may be delayed until the first access)
@3@ Constructs a copy of {{tt|other}}. If {{tt|T}} is a literal type, this copy constructor is a trivial copy constructor.

===Parameters===
{{par begin}}
{{par | stream | stream to initialize the istream_iterator with}}
{{par | other | another istream_iterator of the same type}}
{{par end}}

===Examples===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;sstream&gt;
int main()
{
    std::istringstream stream(&quot;1 2 3 4 5&quot;);
    std::copy(
        std::istream_iterator&lt;int&gt;(stream),
        std::istream_iterator&lt;int&gt;(),
        std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;)
    );
}
|output=
1 2 3 4 5
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istream iterator/operator*</title>
    <ns>0</ns>
    <id>12655</id>
    <revision>
      <id>61415</id>
      <timestamp>2013-06-06T00:00:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="468">{{cpp/iterator/istream_iterator/title|operator*, operator-&gt;}}
{{cpp/iterator/istream_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|
const T&amp; operator*() const;
}}
{{dcl |num=2|1=
const T* operator-&gt;() const;
}}
{{dcl end}}

Returns a pointer or a reference to the current element.

The behavior is undefined if the iterator is end-of-stream iterator.

===Parameters===
(none)

===Return value===
A pointer or a reference to the current element.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istream iterator/operator arith</title>
    <ns>0</ns>
    <id>12656</id>
    <revision>
      <id>61416</id>
      <timestamp>2013-06-06T00:04:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="549">{{cpp/iterator/istream_iterator/title|operator++, operator++{{small|(int)}}}}
{{cpp/iterator/istream_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|
istream_iterator&amp; operator++();
}}
{{dcl |num=2|1=
istream_iterator operator++(int);
}}
{{dcl end}}

Reads a value from the underlying stream and stores it into the iterator object. 

The behavior is undefined if the iterator is end-of-stream iterator.

===Parameters===
(none)

===Return value===
@1@ {{c|*this}}.

@2@ An {{tt|istream_iterator}} that holds an unchanged value.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istream iterator/operator cmp</title>
    <ns>0</ns>
    <id>12657</id>
    <revision>
      <id>61418</id>
      <timestamp>2013-06-06T00:07:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1135">{{title | 1=operator==,!={{small|(std::istream_iterator)}}}}
{{cpp/iterator/istream_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1| 1=
template&lt; class T, class CharT, class Traits, class Dist &gt;
bool operator==( const istream_iterator&lt;T,CharT,Traits,Dist&gt;&amp; lhs,
                 const istream_iterator&lt;T,CharT,Traits,Dist&gt;&amp; rhs );
}}
{{dcl |num=2|1=
template&lt; class CharT, class Traits &gt;
bool operator!=( const istream_iterator&lt;T,CharT,Traits,Dist&gt;&amp; lhs,
                 const istream_iterator&lt;T,CharT,Traits,Dist&gt;&amp; rhs );
}}
{{dcl end}}

Checks whether both {{tt|lhs}} and {{tt|rhs}} are equal. Two stream iterators are equal if both of them are end-of-stream iterators or both of them refer to the same stream.

@1@ Checks whether {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

@2@ Checks whether {{tt|lhs}} is ''not equal to'' {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | stream iterators to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}, {{c|false}} otherwise.

@2@ {{c|true}} if {{tt|lhs}} is ''not equal to'' {{tt|rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator</title>
    <ns>0</ns>
    <id>4856</id>
    <revision>
      <id>57978</id>
      <parentid>49852</parentid>
      <timestamp>2013-06-01T06:05:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4232">{{cpp/title|istreambuf_iterator}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class CharT, class Traits = std::char_traits&lt;CharT&gt; &gt;
class istreambuf_iterator : public std::iterator&lt; std::input_iterator_tag,
                                                  CharT,
                                                  typename Traits::off_type,
                                                  /* unspecified, usually CharT* */,
                                                  CharT &gt;
}}
{{dcl end}}

{{tt|std::istreambuf_iterator}} is a single-pass input iterator that reads successive characters from the {{lc|std::basic_streambuf}} object for which it was constructed. The actual read operation is performed when the iterator is incremented, not when it is dereferenced. The first character may be read when the iterator is constructed or when the first dereferencing is done. Otherwise, dereferencing only returns a copy of the most recently read character.

The default-constructed {{tt|std::istreambuf_iterator}} is known as the ''end-of-stream'' iterator. When a valid {{tt|std::istreambuf_iterator}} reaches the end of the underlying stream, it becomes equal to the end-of-stream iterator. Dereferencing or incrementing it further invokes undefined behavior.

{{tt|std::istreambuf_iterator}} has a trivial copy constructor, a constexpr default constructor, and a trivial destructor.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}}}}
{{dsc | {{tt|int_type}} | {{c|typename traits::int_type}}}}
{{dsc | {{tt|streambuf_type}} | {{c|std::basic_streambuf&lt;CharT, Traits&gt;}}}}
{{dsc | {{tt|istream_type}} | {{c|std::basic_istream&lt;CharT, Traits&gt;}}}}
{{dsc end}}

{{todo|the proxy member type}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc constructor}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc destructor}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc equal}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator_cmp}}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::input_iterator_tag|CharT|Traits::off_type|/* unspecified, usually CharT* */|CharT}}

===Example===
{{example
 | 
 | code=
#include &lt;vector&gt;
#include &lt;sstream&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    // typical use case: an input stream represented as a pair of iterators
    std::istringstream in(&quot;Hello, world&quot;);
    std::vector&lt;char&gt; v( (std::istreambuf_iterator&lt;char&gt;(in)),
                          std::istreambuf_iterator&lt;char&gt;() );
    std::cout &lt;&lt; &quot;v has &quot; &lt;&lt; v.size() &lt;&lt; &quot; bytes. &quot;;
    v.push_back('\0');
    std::cout &lt;&lt; &quot;it holds \&quot;&quot; &lt;&lt; &amp;v[0] &lt;&lt; &quot;\&quot;\n&quot;;


    // demonstration of the single-pass nature
    std::istringstream s(&quot;abc&quot;);
    std::istreambuf_iterator&lt;char&gt; i1(s), i2(s);
    std::cout &lt;&lt; &quot;i1 returns &quot; &lt;&lt; *i1 &lt;&lt; '\n'
              &lt;&lt; &quot;i2 returns &quot; &lt;&lt; *i2 &lt;&lt; '\n';
    ++i1;
    std::cout &lt;&lt; &quot;after incrementing i1, but not i2\n&quot;
              &lt;&lt; &quot;i1 returns &quot; &lt;&lt; *i1 &lt;&lt; '\n'
              &lt;&lt; &quot;i2 returns &quot; &lt;&lt; *i2 &lt;&lt; '\n';
    ++i2; // this makes the apparent value of *i2 to jump from 'a' to 'c'
    std::cout &lt;&lt; &quot;after incrementing i2, but not i1\n&quot;
              &lt;&lt; &quot;i1 returns &quot; &lt;&lt; *i1 &lt;&lt; '\n'
              &lt;&lt; &quot;i2 returns &quot; &lt;&lt; *i2 &lt;&lt; '\n';

}
 | output=
v has 12 bytes. it holds &quot;Hello, world&quot;
i1 returns a
i2 returns a
after incrementing i1, but not i2
i1 returns b
i2 returns a
after incrementing i2, but not i1
i1 returns b
i2 returns c
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc ostreambuf_iterator}}
{{dsc inc | cpp/iterator/dsc istream_iterator}}
{{dsc end}}

[[de:cpp/iterator/istreambuf iterator]]
[[es:cpp/iterator/istreambuf iterator]]
[[fr:cpp/iterator/istreambuf iterator]]
[[it:cpp/iterator/istreambuf iterator]]
[[ja:cpp/iterator/istreambuf iterator]]
[[pt:cpp/iterator/istreambuf iterator]]
[[ru:cpp/iterator/istreambuf iterator]]
[[zh:cpp/iterator/istreambuf iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator/equal</title>
    <ns>0</ns>
    <id>12653</id>
    <revision>
      <id>61410</id>
      <timestamp>2013-06-05T23:30:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="558">{{cpp/iterator/istreambuf_iterator/title|equal}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl |
bool equal( const istreambuf_iterator&amp; it ) const;
}}
{{dcl end}}

Checks whether both {{c|*this}} and {{tt|it}} are valid, or both are invalid, regardless of the stream buffer objects they use.

===Parameters===
{{par begin}}
{{par | it | another stream buffer iterator to compare to}}
{{par end}}

===Return value===
{{c|true}} if both {{c|*this}} and {{tt|it}} are valid, or both are invalid, {{c|false}} otherwise.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator/istreambuf iterator</title>
    <ns>0</ns>
    <id>12650</id>
    <revision>
      <id>69625</id>
      <parentid>69624</parentid>
      <timestamp>2014-04-15T18:25:12Z</timestamp>
      <contributor>
        <username>Ruediger</username>
        <id>752</id>
      </contributor>
      <comment>Undo revision 69624 by [[Special:Contributions/Ruediger|Ruediger]] ([[User talk:Ruediger|talk]])</comment>
      <text xml:space="preserve" bytes="960">{{cpp/iterator/istreambuf_iterator/title|istreambuf_iterator}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|
constexpr istreambuf_iterator();
}}
{{dcl |num=2|1=
istreambuf_iterator( std::basic_istream&lt;CharT,Traits&gt;&amp; is );
}}
{{dcl |num=3|1=
istreambuf_iterator( std::basic_streambuf&lt;CharT,Traits&gt;* s );
}}
{{dcl |since=c++11|num=4|1=
istreambuf_iterator(const istreambuf_iterator&amp;) noexcept = default;
}}
{{dcl end}}

@1@ Constructs the end-of-stream iterator.

@2@ Initializes the iterator and stores the address of {{c|is.rdbuf()}} in a data member. If {{c|is.rdbuf()}} is null, then end-of-stream iterator is constructed. 

@3@ Initializes the iterator and stores the address of {{tt|s}} in a data member.

@4@ Default copy constructor

===Parameters===
{{par begin}}
{{par | is | stream to obtain the stream buffer from}}
{{par | s | stream buffer to initialize the iterator with}}
{{par end}}

===Exceptions===
@1-4@ {{noexcept}}</text>
      <sha1>p68j5q74ba6g1kz5nqeocbuzztgg4ux</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator/operator*</title>
    <ns>0</ns>
    <id>12651</id>
    <revision>
      <id>70123</id>
      <parentid>61412</parentid>
      <timestamp>2014-05-10T13:04:26Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>since=c++11 for operator-&gt;()</comment>
      <text xml:space="preserve" bytes="639">{{cpp/iterator/istreambuf_iterator/title|operator*, operator-&gt;}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|
CharT operator*() const;
}}
{{dcl |num=2|since=c++11|1=
CharT* operator-&gt;() const;
}}
{{dcl end}}

Reads a single character.

@1@ Returns the result of {{c|sbuf_-&gt;sgetc()}} where {{c|sbuf_}} is the stored stream buffer.

@2@ Returns a pointer to the result of {{tt|operator*()}}.

The behavior is undefined if the iterator is end-of-stream iterator.

===Parameters===
(none)

===Return value===
@1@ The value of the obtained character.

@2@ A pointer to the obtained character.

===Exceptions===
(none)</text>
      <sha1>hbnj7hbh5dxyiqivzej9hk5vg08s4r6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator/operator arith</title>
    <ns>0</ns>
    <id>12652</id>
    <revision>
      <id>61413</id>
      <parentid>61408</parentid>
      <timestamp>2013-06-05T23:57:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+UB</comment>
      <text xml:space="preserve" bytes="831">{{cpp/iterator/istreambuf_iterator/title|operator++, operator++{{small|(int)}}}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1|
istreambuf_iterator&amp; operator++();
}}
{{dcl |num=2|1=
/* unspecified */ operator++(int);
}}
{{dcl end}}

Advances the iterator by calling {{c|sbuf_-&gt;sbumpc()}} where {{tt|sbuf_}} is the stored pointer to the stream buffer.

The behavior is undefined if the iterator is end-of-stream iterator.

===Parameters===
(none)

===Return value===
@1@ {{c|*this}}.

@2@ An unspecified struct {{tt|proxy}} holding the current character obtained via {{lc|operator*()}} for later retrieval. {{tt|proxy}} is implicitly convertible to {{tt|CharT}}.

@@ {{tt|proxy}} also holds the value of {{tt|sbuf_}}. {{tt|istreambuf_iterator}} can be constructed from {{tt|proxy}}.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/istreambuf iterator/operator cmp</title>
    <ns>0</ns>
    <id>12654</id>
    <revision>
      <id>61417</id>
      <parentid>61411</parentid>
      <timestamp>2013-06-06T00:06:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="943">{{title | 1=operator==,!={{small|(std::istreambuf_iterator)}}}}
{{cpp/iterator/istreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl |num=1| 1=
template&lt; class CharT, class Traits &gt;
bool operator==( const istreambuf_iterator&lt;CharT,Traits&gt;&amp; lhs,
                 const istreambuf_iterator&lt;CharT,Traits&gt;&amp; rhs );
}}
{{dcl |num=2|1=
template&lt; class CharT, class Traits &gt;
bool operator!=( const istreambuf_iterator&lt;CharT,Traits&gt;&amp; lhs,
                 const istreambuf_iterator&lt;CharT,Traits&gt;&amp; rhs );
}}
{{dcl end}}

Checks whether both {{tt|lhs}} and {{tt|rhs}} are valid, or both are invalid, regardless of the stream buffer objects they use.

@1@ Equivalent to {{c|lhs.equal(rhs)}}.

@2@ Equivalent to {{c|!lhs.equal(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | stream buffer iterators to compare}}
{{par end}}

===Return value===
@1@ The result of {{c|lhs.equal(rhs)}}.

@2@ The result of {{c|!lhs.equal(rhs)}}.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/iterator</title>
    <ns>0</ns>
    <id>4907</id>
    <revision>
      <id>63259</id>
      <parentid>57979</parentid>
      <timestamp>2013-07-07T18:48:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1614">{{cpp/title|iterator}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; 
    class Category,
    class T,
    class Distance = std::ptrdiff_t,
    class Pointer = T*,
    class Reference = T&amp; 
&gt; struct iterator;
}}
{{dcl end}}

{{tt|std::iterator}} is the base class provided to simplify definitions of the required types for iterators.

===Template parameters===
{{par begin}}
{{par | Category | the category of the iterator. Must be one of [[cpp/iterator/iterator_tags|iterator category tags]].}}
{{par | T | the type of the values that can be obtained by dereferencing the iterator. This type should be {{tt|void}} for output iterators.}}
{{par | Distance | a type that can be used to identify distance between iterators}}
{{par | Pointer | defines a pointer to the type iterated over ({{tt|T}}) }}
{{par | Reference | defines a reference to the type iterated over ({{tt|T}}) }}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}}}}
{{dsc | {{tt|difference_type}} | {{tt|Distance}}}}
{{dsc | {{tt|pointer}} | {{tt|Pointer}}}}
{{dsc | {{tt|reference}} | {{tt|Reference}}}}
{{dsc | {{tt|iterator_category}} | {{tt|Category}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc iterator_traits}}
{{dsc inc | cpp/iterator/dsc iterator_tags}}
{{dsc end}}

[[de:cpp/iterator/iterator]]
[[es:cpp/iterator/iterator]]
[[fr:cpp/iterator/iterator]]
[[it:cpp/iterator/iterator]]
[[ja:cpp/iterator/iterator]]
[[pt:cpp/iterator/iterator]]
[[ru:cpp/iterator/iterator]]
[[zh:cpp/iterator/iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/iterator tags</title>
    <ns>0</ns>
    <id>4934</id>
    <revision>
      <id>63643</id>
      <parentid>62319</parentid>
      <timestamp>2013-07-14T11:43:44Z</timestamp>
      <contributor>
        <ip>76.250.60.119</ip>
      </contributor>
      <text xml:space="preserve" bytes="2825">{{cpp/title|input_iterator_tag|output_iterator_tag|forward_iterator_tag|bidirectional_iterator_tag|random_access_iterator_tag}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | | 1=
struct input_iterator_tag { };
}}
{{dcl | | 1=
struct output_iterator_tag { };
}}
{{dcl | | 1=
struct forward_iterator_tag : public input_iterator_tag { };
}}
{{dcl | | 1=
struct bidirectional_iterator_tag : public forward_iterator_tag { };
}}
{{dcl | | 1=
struct random_access_iterator_tag : public bidirectional_iterator_tag { };
}}
{{dcl end}}

Defines the category of an iterator. Each tag is an empty type and corresponds to one of the five iterator categories:
* {{tt|input_iterator_tag}} corresponds to {{concept|InputIterator}}.
* {{tt|output_iterator_tag}} corresponds to {{concept|OutputIterator}}.
* {{tt|forward_iterator_tag}} corresponds to {{concept|ForwardIterator}}.
* {{tt|bidirectional_iterator_tag}} corresponds to {{concept|BidirectionalIterator}}.
* {{tt|random_access_iterator_tag}} corresponds to {{concept|RandomAccessIterator}}.

Iterator category tags carry information that can be used to select the most efficient algorithms for the specific requirement set that is implied by the category.

For every iterator type, a typedef {{c|std::iterator_traits&lt;Iterator&gt;::iterator_category}} is available, which is an alias to one of these five tag types.

===Example===
{{example
 | Common technique for algorithm selection based on iterator category tags is to use a dispatcher function (the alternative is {{lc|std::enable_if}})
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;list&gt;
#include &lt;iterator&gt;

template&lt; class BDIter &gt;
void alg(BDIter, BDIter, std::bidirectional_iterator_tag)
{
    std::cout &lt;&lt; &quot;alg() called for bidirectional iterator\n&quot;;
}

template &lt;class RAIter&gt;
void alg(RAIter, RAIter, std::random_access_iterator_tag)
{
    std::cout &lt;&lt; &quot;alg() called for random-access iterator\n&quot;;
}

template&lt; class Iter &gt;
void alg(Iter first, Iter last)
{
    alg(first, last,
        typename std::iterator_traits&lt;Iter&gt;::iterator_category());
}

int main()
{
    std::vector&lt;int&gt; v;
    alg(v.begin(), v.end());

    std::list&lt;int&gt; l;
    alg(l.begin(), l.end());

//    std::istreambuf_iterator&lt;char&gt; i1(std::cin), i2;
//    alg(i1, i2); // compile error: no matching function for call
}
 | output=
alg() called for random-access iterator
alg() called for bidirectional iterator
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc iterator}}
{{dsc inc | cpp/iterator/dsc iterator_traits}}
{{dsc end}}

[[de:cpp/iterator/iterator tags]]
[[es:cpp/iterator/iterator tags]]
[[fr:cpp/iterator/iterator tags]]
[[it:cpp/iterator/iterator tags]]
[[ja:cpp/iterator/iterator tags]]
[[pt:cpp/iterator/iterator tags]]
[[ru:cpp/iterator/iterator tags]]
[[zh:cpp/iterator/iterator tags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/iterator traits</title>
    <ns>0</ns>
    <id>4935</id>
    <revision>
      <id>63260</id>
      <parentid>63258</parentid>
      <timestamp>2013-07-07T18:52:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>expand</comment>
      <text xml:space="preserve" bytes="4281">{{cpp/title|iterator_traits}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class Iterator&gt;
struct iterator_traits;
}}
{{dcl | 1=
template&lt; class T &gt;
struct iterator_traits&lt;T*&gt;;
}}
{{dcl | 1=
template&lt; class T &gt;
struct iterator_traits&lt;const T*&gt;;
}}
{{dcl end}}

{{tt|std::iterator_traits}} is the type trait class that provides uniform interface to the properties of iterator types. This makes it possible to implement algorithms only in terms of iterators.

The class defines the following types that correspond to the typedefs provided by {{lc|std::iterator}}:

* {{tt|difference_type}} - a type that can be used to identify distance between iterators
* {{tt|value_type}} - the type of the values that can be obtained by dereferencing the iterator. This type is {{tt|void}} for output iterators.
* {{tt|pointer}} -  defines a pointer to the type iterated over ({{tt|value_type}}) 
* {{tt|reference}} -  defines a reference to the type iterated over ({{tt|value_type}}) 
* {{tt|iterator_category}} - the category of the iterator. Must be one of [[cpp/iterator/iterator_tags|iterator category tags]]. 

The template can be specialized for user-defined iterators so that the information about the iterator can be retrieved even if the type does not provide the usual typedefs.

===Template parameters===
{{par begin}}
{{par | Iterator | the iterator type to retrieve properties for}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|difference_type}} | {{tt|Iterator::difference_type}}}}
{{dsc | {{tt|value_type}} | {{tt|Iterator::value_type}}}}
{{dsc | {{tt|pointer}} | {{tt|Iterator::pointer}}}}
{{dsc | {{tt|reference}} | {{tt|Iterator::reference}}}}
{{dsc | {{tt|iterator_category}} | {{tt|Iterator::iterator_category}}}}
{{dsc end}}

===Specializations===

This type trait may be specialized for user-provided types that may be used as iterators. The standard library provides two partial specializations for pointer types T*, which makes it possible to use all iterator-based algorithms with raw pointers.

===={{tt|T*}} specialization member types====
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}}}}
{{dsc | {{tt|value_type}} | {{tt|T}}}}
{{dsc | {{tt|pointer}} | {{tt|T*}}}}
{{dsc | {{tt|reference}} | {{tt|T&amp;}}}}
{{dsc | {{tt|iterator_category}} | {{lc|std::random_access_iterator_tag}}}}
{{dsc end}}

===={{tt|const T*}} specialization member types====
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}}}}
{{dsc | {{tt|value_type}} | {{tt|T}}}}
{{dsc | {{tt|pointer}} | {{tt|const T*}}}}
{{dsc | {{tt|reference}} | {{tt|const T&amp;}}}}
{{dsc | {{tt|iterator_category}} | {{lc|std::random_access_iterator_tag}}}}
{{dsc end}}

===Example===
{{example
 | The following example shows a general-purpose {{tt|reverse()}} implementation for bidirectional iterators
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;
#include &lt;list&gt;

template&lt;class BidirIt&gt;
void my_reverse(BidirIt first, BidirIt last)
{
    typename std::iterator_traits&lt;BidirIt&gt;::difference_type n = std::distance(first, last);
    --n;
    while(n &gt; 0) {
        typename std::iterator_traits&lt;BidirIt&gt;::value_type tmp = *first;
        *first++ = *--last;
        *last = tmp;
        n -= 2;
    }
}

int main()
{
    std::vector&lt;int&gt; v{1, 2, 3, 4, 5};
    my_reverse(v.begin(), v.end());
    for (int n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    std::list&lt;int&gt; l{1, 2, 3, 4, 5};
    my_reverse(l.begin(), l.end());
    for (auto n : l) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

//    std::istreambuf_iterator&lt;char&gt; i1(std::cin), i2;
//    my_reverse(i1, i2); // compilation error

}
 | output=
5 4 3 2 1
5 4 3 2 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc iterator}}
{{dsc inc | cpp/iterator/dsc iterator_tags}}
{{dsc end}}

[[de:cpp/iterator/iterator traits]]
[[es:cpp/iterator/iterator traits]]
[[fr:cpp/iterator/iterator traits]]
[[it:cpp/iterator/iterator traits]]
[[ja:cpp/iterator/iterator traits]]
[[pt:cpp/iterator/iterator traits]]
[[ru:cpp/iterator/iterator traits]]
[[zh:cpp/iterator/iterator traits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/make move iterator</title>
    <ns>0</ns>
    <id>4855</id>
    <revision>
      <id>64727</id>
      <parentid>64715</parentid>
      <timestamp>2013-08-26T14:02:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>dcl rev</comment>
      <text xml:space="preserve" bytes="2302">{{cpp/title|make_move_iterator}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl rev begin}}
{{dcl| since=c++11 | until=c++14 |
template&lt; class Iterator &gt;
std::move_iterator&lt;Iterator&gt; make_move_iterator( const Iterator&amp; i );
}}
{{dcl| since=c++14 |
template&lt; class Iterator &gt;
std::move_iterator&lt;Iterator&gt; make_move_iterator( Iterator i );
}}
{{dcl rev end}}
{{dcl end}}

{{tt|make_move_iterator}} is a convenience function template that constructs a {{lc|std::move_iterator}} for the given iterator {{tt|i}} with the type deduced from the type of the argument.

===Parameters===
{{par begin}}
{{par | i | input iterator to be converted to move iterator}}
{{par end}}

===Return value===
A {{lc|std::move_iterator}} which can be used to move from the elements accessed through {{tt|i}}

===Possible implementation===
{{eq fun | 1=
template&lt; class Iterator &gt;
std::move_iterator&lt;Iterator&gt; make_move_iterator( Iterator i )
{
    return std::move_iterator&lt;Iterator&gt;(i);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;list&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;iterator&gt;

int main()
{
    std::list&lt;std::string&gt; s{&quot;one&quot;, &quot;two&quot;, &quot;three&quot;};

    std::vector&lt;std::string&gt; v1(s.begin(), s.end()); // copy

    std::vector&lt;std::string&gt; v2(std::make_move_iterator(s.begin()),
                                std::make_move_iterator(s.end())); // move

    std::cout &lt;&lt; &quot;v1 now holds: &quot;;
    for (auto str : v1)
            std::cout &lt;&lt; &quot;\&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot; &quot;;
    std::cout &lt;&lt; &quot;\nv2 now holds: &quot;;
    for (auto str : v2)
            std::cout &lt;&lt; &quot;\&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot; &quot;;
    std::cout &lt;&lt; &quot;\noriginal list now holds: &quot;;
    for (auto str : s)
            std::cout &lt;&lt; &quot;\&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot; &quot;;
    std::cout &lt;&lt; '\n';
}
 | output=
v1 now holds: &quot;one&quot; &quot;two&quot; &quot;three&quot;
v2 now holds: &quot;one&quot; &quot;two&quot; &quot;three&quot;
original list now holds: &quot;&quot; &quot;&quot; &quot;&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc move_iterator}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc end}}

[[de:cpp/iterator/make move iterator]]
[[es:cpp/iterator/make move iterator]]
[[fr:cpp/iterator/make move iterator]]
[[it:cpp/iterator/make move iterator]]
[[ja:cpp/iterator/make move iterator]]
[[pt:cpp/iterator/make move iterator]]
[[ru:cpp/iterator/make move iterator]]
[[zh:cpp/iterator/make move iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/make reverse iterator</title>
    <ns>0</ns>
    <id>13175</id>
    <revision>
      <id>67915</id>
      <timestamp>2014-03-05T18:07:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1335">{{cpp/title|make_reverse_iterator}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl| since=c++14 |
template &lt;class Iterator&gt;
std::reverse_iterator&lt;Iterator&gt; make_reverse_iterator( Iterator i );
}}
{{dcl end}}

{{tt|make_reverse_iterator}} is a convenience function template that constructs a {{lc|std::reverse_iterator}} for the given iterator {{tt|i}} with the type deduced from the type of the argument.

===Parameters===
{{par begin}}
{{par | i | input iterator to be converted to reverse iterator}}
{{par end}}

===Return value===
A {{lc|std::reverse_iterator}} constructed from {{tt|i}}

===Possible implementation===
{{eq fun | 1=
template&lt; class Iterator &gt;
std::reverse_iterator&lt;Iterator&gt; make_reverse_iterator( Iterator i )
{
    return std::reverse_iterator&lt;Iterator&gt;(i);
}
}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc reverse_iterator}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc rend}}
{{dsc end}}

[[de:cpp/iterator/make reverse iterator]]
[[es:cpp/iterator/make reverse iterator]]
[[fr:cpp/iterator/make reverse iterator]]
[[it:cpp/iterator/make reverse iterator]]
[[ja:cpp/iterator/make reverse iterator]]
[[pt:cpp/iterator/make reverse iterator]]
[[ru:cpp/iterator/make reverse iterator]]
[[zh:cpp/iterator/make reverse iterator]]</text>
      <sha1>mvhxs34qy2wxs9icsfd23oi3tm45ntg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator</title>
    <ns>0</ns>
    <id>4930</id>
    <revision>
      <id>69160</id>
      <parentid>62754</parentid>
      <timestamp>2014-03-28T17:47:04Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3139">{{cpp/title|move_iterator}}
{{cpp/iterator/move_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | since=c++11 | 1=
template&lt; class Iterator &gt;
class move_iterator;
}}
{{dcl end}}

{{tt|std::move_iterator}} is an iterator adaptor which behaves exactly like the underlying iterator (which must be at least an {{concept|InputIterator}}), except that dereferencing converts the value returned by the underlying iterator into an rvalue. If this iterator is used as an input iterator, the effect is that the values are moved from, rather than copied from.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|iterator_type}} | {{tt|Iterator}}}}
{{dsc | {{tt|difference_type}} | {{c|std::iterator_traits&lt;Iterator&gt;::difference_type}}}}
{{dsc | {{tt|pointer}} | {{tt|Iterator}}}}
{{dsc | {{tt|value_type}} | {{c|std::iterator_traits&lt;Iterator&gt;::value_type}}}}
{{dsc | {{tt|iterator_category}} | {{c|std::iterator_traits&lt;Iterator&gt;::iterator_category}}}}
{{dsc | {{tt|reference}} | {{tt|value_type&amp;&amp;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc constructor | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator{{=}} | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc base | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator* | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_arith | move_iterator}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_cmp | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator+ | move_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator- | move_iterator}}
{{dsc end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;
#include &lt;numeric&gt;
#include &lt;string&gt;

int main()
{
    std::vector&lt;std::string&gt; v{&quot;this&quot;, &quot;is&quot;, &quot;an&quot;, &quot;example&quot;};

    std::cout &lt;&lt; &quot;Old contents of the vector: &quot;;
    for (auto&amp; s : v)
        std::cout &lt;&lt; '&quot;' &lt;&lt; s &lt;&lt; &quot;\&quot; &quot;;

    typedef std::vector&lt;std::string&gt;::iterator iter_t;
    std::string concat = std::accumulate(
                             std::move_iterator&lt;iter_t&gt;(v.begin()),
                             std::move_iterator&lt;iter_t&gt;(v.end()),
                             std::string());  // Can be simplified with std::make_move_iterator

    std::cout &lt;&lt; &quot;\nConcatenated as string: &quot; &lt;&lt; concat &lt;&lt; '\n'
              &lt;&lt; &quot;New contents of the vector: &quot;;
    for (auto&amp; s : v)
        std::cout &lt;&lt; '&quot;' &lt;&lt; s &lt;&lt; &quot;\&quot; &quot;;
    std::cout &lt;&lt; '\n';
}
 | output=
Old contents of the vector: &quot;this&quot; &quot;is&quot; &quot;an&quot; &quot;example&quot;
Concatenated as string: thisisanexample
New contents of the vector: &quot;&quot; &quot;&quot; &quot;&quot; &quot;&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc make_move_iterator}}
{{dsc end}}

[[de:cpp/iterator/move iterator]]
[[es:cpp/iterator/move iterator]]
[[fr:cpp/iterator/move iterator]]
[[it:cpp/iterator/move iterator]]
[[ja:cpp/iterator/move iterator]]
[[pt:cpp/iterator/move iterator]]
[[ru:cpp/iterator/move iterator]]
[[zh:cpp/iterator/move iterator]]</text>
      <sha1>8av0ram09nn9blcvro6w5rfkexjaowe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/base</title>
    <ns>0</ns>
    <id>8726</id>
    <revision>
      <id>50879</id>
      <parentid>42254</parentid>
      <timestamp>2013-06-01T03:42:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="369">{{include page|cpp/iterator/adaptor/base|move_iterator}}

[[de:cpp/iterator/move iterator/base]]
[[es:cpp/iterator/move iterator/base]]
[[fr:cpp/iterator/move iterator/base]]
[[it:cpp/iterator/move iterator/base]]
[[ja:cpp/iterator/move iterator/base]]
[[pt:cpp/iterator/move iterator/base]]
[[ru:cpp/iterator/move iterator/base]]
[[zh:cpp/iterator/move iterator/base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/move iterator</title>
    <ns>0</ns>
    <id>8716</id>
    <revision>
      <id>50880</id>
      <parentid>42245</parentid>
      <timestamp>2013-06-01T03:43:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/iterator/adaptor/constructor|move_iterator}}

[[de:cpp/iterator/move iterator/move iterator]]
[[es:cpp/iterator/move iterator/move iterator]]
[[fr:cpp/iterator/move iterator/move iterator]]
[[it:cpp/iterator/move iterator/move iterator]]
[[ja:cpp/iterator/move iterator/move iterator]]
[[pt:cpp/iterator/move iterator/move iterator]]
[[ru:cpp/iterator/move iterator/move iterator]]
[[zh:cpp/iterator/move iterator/move iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator*</title>
    <ns>0</ns>
    <id>8728</id>
    <revision>
      <id>57988</id>
      <parentid>49858</parentid>
      <timestamp>2013-06-01T06:05:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="964">{{cpp/iterator/move_iterator/title | operator*,-&gt; }}
{{cpp/iterator/move_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 |
reference operator* () const;
}}
{{dcl | num=2 | 
pointer   operator-&gt;() const;
}}
{{dcl end}}

Returns a rvalue-reference or pointer to the current element.

@1@ Equivalent to {{c|1=std::move(*current)}};
@2@ Equivalent to {{c|current}}.

===Parameters===
(none)

===Return value===
Rvalue-reference or pointer to the current element.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at|move_iterator}}
{{dsc end}}

[[de:cpp/iterator/move iterator/operator*]]
[[es:cpp/iterator/move iterator/operator*]]
[[fr:cpp/iterator/move iterator/operator*]]
[[it:cpp/iterator/move iterator/operator*]]
[[ja:cpp/iterator/move iterator/operator*]]
[[pt:cpp/iterator/move iterator/operator*]]
[[ru:cpp/iterator/move iterator/operator*]]
[[zh:cpp/iterator/move iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator+</title>
    <ns>0</ns>
    <id>8741</id>
    <revision>
      <id>42226</id>
      <parentid>36887</parentid>
      <timestamp>2012-11-02T22:32:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="401">{{cpp/iterator/adaptor/operator+|move_iterator}}

[[de:cpp/iterator/move iterator/operator+]]
[[es:cpp/iterator/move iterator/operator+]]
[[fr:cpp/iterator/move iterator/operator+]]
[[it:cpp/iterator/move iterator/operator+]]
[[ja:cpp/iterator/move iterator/operator+]]
[[pt:cpp/iterator/move iterator/operator+]]
[[ru:cpp/iterator/move iterator/operator+]]
[[zh:cpp/iterator/move iterator/operator+]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator-</title>
    <ns>0</ns>
    <id>8737</id>
    <revision>
      <id>50881</id>
      <parentid>42218</parentid>
      <timestamp>2013-06-01T03:43:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="414">{{include page|cpp/iterator/adaptor/operator-|move_iterator}}

[[de:cpp/iterator/move iterator/operator-]]
[[es:cpp/iterator/move iterator/operator-]]
[[fr:cpp/iterator/move iterator/operator-]]
[[it:cpp/iterator/move iterator/operator-]]
[[ja:cpp/iterator/move iterator/operator-]]
[[pt:cpp/iterator/move iterator/operator-]]
[[ru:cpp/iterator/move iterator/operator-]]
[[zh:cpp/iterator/move iterator/operator-]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator=</title>
    <ns>0</ns>
    <id>8722</id>
    <revision>
      <id>42209</id>
      <parentid>36844</parentid>
      <timestamp>2012-11-02T22:28:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="405">{{cpp/iterator/adaptor/operator{{=}}|move_iterator}}

[[de:cpp/iterator/move iterator/operator=]]
[[es:cpp/iterator/move iterator/operator=]]
[[fr:cpp/iterator/move iterator/operator=]]
[[it:cpp/iterator/move iterator/operator=]]
[[ja:cpp/iterator/move iterator/operator=]]
[[pt:cpp/iterator/move iterator/operator=]]
[[ru:cpp/iterator/move iterator/operator=]]
[[zh:cpp/iterator/move iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator arith</title>
    <ns>0</ns>
    <id>8735</id>
    <revision>
      <id>50882</id>
      <parentid>42201</parentid>
      <timestamp>2013-06-01T03:43:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="459">{{include page|cpp/iterator/adaptor/operator_arith|move_iterator}}

[[de:cpp/iterator/move iterator/operator arith]]
[[es:cpp/iterator/move iterator/operator arith]]
[[fr:cpp/iterator/move iterator/operator arith]]
[[it:cpp/iterator/move iterator/operator arith]]
[[ja:cpp/iterator/move iterator/operator arith]]
[[pt:cpp/iterator/move iterator/operator arith]]
[[ru:cpp/iterator/move iterator/operator arith]]
[[zh:cpp/iterator/move iterator/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator at</title>
    <ns>0</ns>
    <id>8730</id>
    <revision>
      <id>50883</id>
      <parentid>42190</parentid>
      <timestamp>2013-06-01T03:43:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="432">{{include page|cpp/iterator/adaptor/operator_at|move_iterator}}

[[de:cpp/iterator/move iterator/operator at]]
[[es:cpp/iterator/move iterator/operator at]]
[[fr:cpp/iterator/move iterator/operator at]]
[[it:cpp/iterator/move iterator/operator at]]
[[ja:cpp/iterator/move iterator/operator at]]
[[pt:cpp/iterator/move iterator/operator at]]
[[ru:cpp/iterator/move iterator/operator at]]
[[zh:cpp/iterator/move iterator/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/move iterator/operator cmp</title>
    <ns>0</ns>
    <id>8731</id>
    <revision>
      <id>50884</id>
      <parentid>42182</parentid>
      <timestamp>2013-06-01T03:43:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="441">{{include page|cpp/iterator/adaptor/operator_cmp|move_iterator}}

[[de:cpp/iterator/move iterator/operator cmp]]
[[es:cpp/iterator/move iterator/operator cmp]]
[[fr:cpp/iterator/move iterator/operator cmp]]
[[it:cpp/iterator/move iterator/operator cmp]]
[[ja:cpp/iterator/move iterator/operator cmp]]
[[pt:cpp/iterator/move iterator/operator cmp]]
[[ru:cpp/iterator/move iterator/operator cmp]]
[[zh:cpp/iterator/move iterator/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/next</title>
    <ns>0</ns>
    <id>2735</id>
    <revision>
      <id>62755</id>
      <parentid>57991</parentid>
      <timestamp>2013-07-01T23:39:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1368">{{cpp/title| next}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | since=c++11 |
template&lt; class ForwardIt &gt;
ForwardIt next( ForwardIt it, 
                typename std::iterator_traits&lt;ForwardIt&gt;::difference_type n {{=}} 1 );
}}
{{dcl end}}

Return the {{c|n}}th successor of iterator {{c|it}}.

===Parameters===
{{par begin}}
{{par | it | an iterator }}
{{par | n | number of elements to advance}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
The {{c|n}}th successor of iterator {{c|it}}.

===Possible implementation===
{{eq fun |
template&lt;class ForwardIt&gt;
ForwardIt next(ForwardIt it, typename std::iterator_traits&lt;ForwardIt&gt;::difference_type n {{=}} 1)
{
    std::advance(it, n);
    return it;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v{ 3, 1, 4 };
    
    auto it = v.begin();

    auto nx = std::next(it, 2);

    std::cout &lt;&lt; *it &lt;&lt; ' ' &lt;&lt; *nx &lt;&lt; '\n';
}
 | output=3 4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc prev}}
{{dsc inc | cpp/iterator/dsc advance}}
{{dsc end}}

[[de:cpp/iterator/next]]
[[es:cpp/iterator/next]]
[[fr:cpp/iterator/next]]
[[it:cpp/iterator/next]]
[[ja:cpp/iterator/next]]
[[pt:cpp/iterator/next]]
[[ru:cpp/iterator/next]]
[[zh:cpp/iterator/next]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator</title>
    <ns>0</ns>
    <id>4913</id>
    <revision>
      <id>72454</id>
      <parentid>69474</parentid>
      <timestamp>2014-08-22T15:06:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link concept</comment>
      <text xml:space="preserve" bytes="2725">{{cpp/title|ostream_iterator}}
{{cpp/iterator/ostream_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class T,
          class CharT = char,
          class Traits = std::char_traits&lt;CharT&gt;&gt;
class ostream_iterator : public std::iterator&lt;std::output_iterator_tag,
                                              void, void, void, void&gt;
}}
{{dcl end}}

{{tt|std::ostream_iterator}} is a single-pass {{concept|OutputIterator}} that writes successive objects of type {{tt|T}} into the {{lc|std::basic_ostream}} object for which it was constructed, using {{tt|operator&lt;&lt;}}. Optional delimiter string is written to the output stream after every write operation. The write operation is performed when the iterator (whether dereferenced or not) is assigned to. Incrementing the {{tt|std::ostream_iterator}} is a no-op.

In a typical implementation, the only data members of {{tt|std::ostream_iterator}} are a pointer to the associated {{tt|std::basic_ostream}} and a pointer to the first character in the delimiter string.

When writing characters, {{lc|std::ostreambuf_iterator}} is more efficient, since it avoids the overhead of constructing and destructing the sentry object once per character.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}}}}
{{dsc | {{tt|ostream_type}} | {{c|std::basic_ostream&lt;CharT, Traits&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc constructor}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc destructor}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc operator_arith}}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;
#include &lt;numeric&gt;

int main()
{
    std::istringstream str(&quot;0.1 0.2 0.3 0.4&quot;);
    std::partial_sum(std::istream_iterator&lt;double&gt;(str),
                      std::istream_iterator&lt;double&gt;(),
                      std::ostream_iterator&lt;double&gt;(std::cout, &quot; &quot;));
}
 | output=
0.1 0.3 0.6 1 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc ostreambuf_iterator}}
{{dsc inc | cpp/iterator/dsc istream_iterator}}
{{dsc end}}

[[de:cpp/iterator/ostream iterator]]
[[es:cpp/iterator/ostream iterator]]
[[fr:cpp/iterator/ostream iterator]]
[[it:cpp/iterator/ostream iterator]]
[[ja:cpp/iterator/ostream iterator]]
[[pt:cpp/iterator/ostream iterator]]
[[ru:cpp/iterator/ostream iterator]]
[[zh:cpp/iterator/ostream iterator]]</text>
      <sha1>q7ohfpxaiu45dtjlofyshfkm62g81yi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/operator*</title>
    <ns>0</ns>
    <id>9129</id>
    <revision>
      <id>42161</id>
      <parentid>38283</parentid>
      <timestamp>2012-11-02T22:19:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="429">{{cpp/iterator/inserter/operator*|ostream_iterator}}

[[de:cpp/iterator/ostream iterator/operator*]]
[[es:cpp/iterator/ostream iterator/operator*]]
[[fr:cpp/iterator/ostream iterator/operator*]]
[[it:cpp/iterator/ostream iterator/operator*]]
[[ja:cpp/iterator/ostream iterator/operator*]]
[[pt:cpp/iterator/ostream iterator/operator*]]
[[ru:cpp/iterator/ostream iterator/operator*]]
[[zh:cpp/iterator/ostream iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/operator++</title>
    <ns>0</ns>
    <id>10170</id>
    <redirect title="cpp/iterator/ostream iterator/operator arith" />
    <revision>
      <id>48476</id>
      <timestamp>2013-05-29T15:54:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/iterator/ostream iterator/operator++]] to [[cpp/iterator/ostream iterator/operator arith]]: move to correct location</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[cpp/iterator/ostream iterator/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/operator=</title>
    <ns>0</ns>
    <id>9130</id>
    <revision>
      <id>49861</id>
      <parentid>42145</parentid>
      <timestamp>2013-06-01T02:58:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1505">{{cpp/iterator/ostream_iterator/title|operator{{=}}}}
{{cpp/iterator/ostream_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
ostream_iterator&amp; operator=( const T&amp; value )
}}
{{dcl end}}

Inserts {{tt|value}} into the associated stream, then inserts the delimiter, if one was specified at construction time.

If {{tt|out_stream}} is the private member pointer to the associated {{lc|std::basic_ostream}} and {{tt|delim}} is the pointer to the first character in the delimiter, the effect is equivalent to

{{c|1=
*out_stream &lt;&lt; value;
if(delim != 0)
    *out_stream &lt;&lt; delim;
return *this;
}}

===Parameters===
{{par begin}}
{{par | value | the object to insert}}
{{par end}}

===Return value===
{{c|*this}}

===Notes===
{{tt|T}} can be any class with a user-defined operator&lt;&lt;

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    std::ostream_iterator&lt;int&gt; i1(std::cout, &quot;, &quot;);
    *i1++ = 1; // usual form, used by standard algorithms
    *++i1 = 2;
    i1 = 3; // neither * nor ++ are necessary
    std::ostream_iterator&lt;double&gt; i2(std::cout);
    i2 = 3.14;
}
 | output=
1, 2, 3, 3.14
}}

[[de:cpp/iterator/ostream iterator/operator=]]
[[es:cpp/iterator/ostream iterator/operator=]]
[[fr:cpp/iterator/ostream iterator/operator=]]
[[it:cpp/iterator/ostream iterator/operator=]]
[[ja:cpp/iterator/ostream iterator/operator=]]
[[pt:cpp/iterator/ostream iterator/operator=]]
[[ru:cpp/iterator/ostream iterator/operator=]]
[[zh:cpp/iterator/ostream iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/operator arith</title>
    <ns>0</ns>
    <id>9128</id>
    <revision>
      <id>48475</id>
      <parentid>42153</parentid>
      <timestamp>2013-05-29T15:54:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[cpp/iterator/ostream iterator/operator++]] to [[cpp/iterator/ostream iterator/operator arith]]: move to correct location</comment>
      <text xml:space="preserve" bytes="438">{{cpp/iterator/inserter/operator++|ostream_iterator}}

[[de:cpp/iterator/ostream iterator/operator++]]
[[es:cpp/iterator/ostream iterator/operator++]]
[[fr:cpp/iterator/ostream iterator/operator++]]
[[it:cpp/iterator/ostream iterator/operator++]]
[[ja:cpp/iterator/ostream iterator/operator++]]
[[pt:cpp/iterator/ostream iterator/operator++]]
[[ru:cpp/iterator/ostream iterator/operator++]]
[[zh:cpp/iterator/ostream iterator/operator++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/ostream iterator</title>
    <ns>0</ns>
    <id>9131</id>
    <revision>
      <id>49862</id>
      <parentid>42140</parentid>
      <timestamp>2013-06-01T02:59:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1559">{{cpp/iterator/ostream_iterator/title|ostream_iterator}}
{{cpp/iterator/ostream_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
ostream_iterator(ostream_type&amp; stream, const CharT* delim)
}}
{{dcl | num=2 | 1=
ostream_iterator(ostream_type&amp; stream)
}}
{{dcl end}}

1) Constructs the iterator with the private {{c|ostream_type*}} member initialized with {{tt|&amp;stream}} and the private delimiter pointer initialized with {{tt|delim}}.

2) Constructs the iterator with the private {{c|ostream_type*}} member initialized with {{tt|&amp;stream}} and the private delimiter pointer initialized with null pointer value.

===Parameters===
{{par begin}}
{{par | stream | the output stream to be accessed by this iterator}}
{{par | delim | the null-terminated character string to be inserted into the stream after each output}}
{{par end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
int main()
{
    std::ostream_iterator&lt;int&gt; i1(std::cout, &quot;, &quot;);
    std::fill_n(i1, 5, -1);
    std::ostream_iterator&lt;double&gt; i2(std::cout);
    *i2++ = 3.14;
}
 | output=
-1, -1, -1, -1, -1, 3.14
}}

[[de:cpp/iterator/ostream iterator/ostream iterator]]
[[es:cpp/iterator/ostream iterator/ostream iterator]]
[[fr:cpp/iterator/ostream iterator/ostream iterator]]
[[it:cpp/iterator/ostream iterator/ostream iterator]]
[[ja:cpp/iterator/ostream iterator/ostream iterator]]
[[pt:cpp/iterator/ostream iterator/ostream iterator]]
[[ru:cpp/iterator/ostream iterator/ostream iterator]]
[[zh:cpp/iterator/ostream iterator/ostream iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostream iterator/~ostream iterator</title>
    <ns>0</ns>
    <id>9132</id>
    <revision>
      <id>49863</id>
      <parentid>42125</parentid>
      <timestamp>2013-06-01T02:59:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="670">{{cpp/iterator/ostream_iterator/title|~ostream_iterator}}
{{cpp/iterator/ostream_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
~ostream_iterator()
}}
{{dcl end}}

Destructs the iterator. Does not affect the associated output stream.

[[de:cpp/iterator/ostream iterator/~ostream iterator]]
[[es:cpp/iterator/ostream iterator/~ostream iterator]]
[[fr:cpp/iterator/ostream iterator/~ostream iterator]]
[[it:cpp/iterator/ostream iterator/~ostream iterator]]
[[ja:cpp/iterator/ostream iterator/~ostream iterator]]
[[pt:cpp/iterator/ostream iterator/~ostream iterator]]
[[ru:cpp/iterator/ostream iterator/~ostream iterator]]
[[zh:cpp/iterator/ostream iterator/~ostream iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator</title>
    <ns>0</ns>
    <id>4903</id>
    <revision>
      <id>72453</id>
      <parentid>57995</parentid>
      <timestamp>2014-08-22T15:06:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link concept</comment>
      <text xml:space="preserve" bytes="2509">{{cpp/title|ostreambuf_iterator}}
{{cpp/iterator/ostreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class CharT, class Traits = std::char_traits&lt;CharT&gt;&gt;
class ostreambuf_iterator : public std::iterator&lt;std::output_iterator_tag,
                                                 void, void, void, void&gt;
}}
{{dcl end}}

{{tt|std::ostreambuf_iterator}} is a single-pass {{concept|OutputIterator}} that writes successive characters into the {{lc|std::basic_streambuf}} object for which it was constructed. The actual write operation is performed when the iterator (whether dereferenced or not) is assigned to. Incrementing the {{tt|std::ostreambuf_iterator}} is a no-op.

In a typical implementation, the only data members of {{tt|std::ostreambuf_iterator}} are a pointer to the associated {{tt|std::basic_streambuf}} and a boolean flag indicating if the the end of file condition has been reached.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}}}}
{{dsc | {{tt|streambuf_type}} | {{c|std::basic_streambuf&lt;CharT, Traits&gt;}}}}
{{dsc | {{tt|ostream_type}} | {{c|std::basic_ostream&lt;CharT, Traits&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc constructor}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc destructor}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc failed}}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 | 
 | code=
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;

int main()
{
    std::string s = &quot;This is an example\n&quot;;
    std::copy(s.begin(), s.end(), std::ostreambuf_iterator&lt;char&gt;(std::cout));
}
 | output=
This is an example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc istreambuf_iterator}}
{{dsc inc | cpp/iterator/dsc ostream_iterator}}
{{dsc end}}

[[de:cpp/iterator/ostreambuf iterator]]
[[es:cpp/iterator/ostreambuf iterator]]
[[fr:cpp/iterator/ostreambuf iterator]]
[[it:cpp/iterator/ostreambuf iterator]]
[[ja:cpp/iterator/ostreambuf iterator]]
[[pt:cpp/iterator/ostreambuf iterator]]
[[ru:cpp/iterator/ostreambuf iterator]]
[[zh:cpp/iterator/ostreambuf iterator]]</text>
      <sha1>qn8cnk1ndlfk1os53owrqjlsyl3gxd9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/failed</title>
    <ns>0</ns>
    <id>9124</id>
    <revision>
      <id>69772</id>
      <parentid>64886</parentid>
      <timestamp>2014-04-23T22:27:06Z</timestamp>
      <contributor>
        <username>Ericwf</username>
        <id>2945</id>
      </contributor>
      <minor/>
      <comment>Remove erroneous braces</comment>
      <text xml:space="preserve" bytes="1051">{{cpp/iterator/ostreambuf_iterator/title|failed}}
{{cpp/iterator/ostreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
bool failed() const
}}
{{dcl end}}

Returns {{c|true}} if the iterator encountered the end-of-file condition, that is, if an earlier call to {{c|std::basic_streambuf::sputc}} (made by [[cpp/iterator/ostreambuf_iterator/operator=|operator=]]) returned {{c|Traits::eof}} .

===Parameters===
(none)

===Return value===
{{c|true}} if this iterator has encountered the end-of-file condition on output, {{c|false}} otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{todo}}

[[de:cpp/iterator/ostreambuf iterator/failed]]
[[es:cpp/iterator/ostreambuf iterator/failed]]
[[fr:cpp/iterator/ostreambuf iterator/failed]]
[[it:cpp/iterator/ostreambuf iterator/failed]]
[[ja:cpp/iterator/ostreambuf iterator/failed]]
[[pt:cpp/iterator/ostreambuf iterator/failed]]
[[ru:cpp/iterator/ostreambuf iterator/failed]]
[[zh:cpp/iterator/ostreambuf iterator/failed]]</text>
      <sha1>fcykyy4u7yyotpki2621z3oyq7wwyez</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/operator*</title>
    <ns>0</ns>
    <id>9125</id>
    <revision>
      <id>42098</id>
      <parentid>38276</parentid>
      <timestamp>2012-11-02T22:05:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="456">{{cpp/iterator/inserter/operator*|ostreambuf_iterator}}

[[de:cpp/iterator/ostreambuf iterator/operator*]]
[[es:cpp/iterator/ostreambuf iterator/operator*]]
[[fr:cpp/iterator/ostreambuf iterator/operator*]]
[[it:cpp/iterator/ostreambuf iterator/operator*]]
[[ja:cpp/iterator/ostreambuf iterator/operator*]]
[[pt:cpp/iterator/ostreambuf iterator/operator*]]
[[ru:cpp/iterator/ostreambuf iterator/operator*]]
[[zh:cpp/iterator/ostreambuf iterator/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/operator++</title>
    <ns>0</ns>
    <id>10164</id>
    <redirect title="cpp/iterator/ostreambuf iterator/operator arith" />
    <revision>
      <id>48460</id>
      <parentid>48458</parentid>
      <timestamp>2013-05-29T15:50:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix redirect</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[cpp/iterator/ostreambuf iterator/operator_arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/operator=</title>
    <ns>0</ns>
    <id>9123</id>
    <revision>
      <id>70904</id>
      <parentid>64301</parentid>
      <timestamp>2014-06-02T08:33:02Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1163">{{cpp/iterator/ostreambuf_iterator/title|operator{{=}}}}
{{cpp/iterator/ostreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
ostreambuf_iterator&amp; operator=( CharT c )
}}
{{dcl end}}

If {{lc|failed()}} returns {{c|false}}, inserts the character {{tt|c}} into the associated stream buffer by calling {{c|pbuf-&gt;sputc(c)}}, where {{tt|pbuf}} is the private member of type {{tt|streambuf_type*}}. Otherwise, does nothing.

If the call to {{c|pbuf-&gt;sputc(c)}} returns {{c|Traits::eof}}, sets the failed() flag to true.

===Parameters===
{{par begin}}
{{par | c | the character to insert}}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{example|
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputc}}
{{dsc end}}

[[de:cpp/iterator/ostreambuf iterator/operator=]]
[[es:cpp/iterator/ostreambuf iterator/operator=]]
[[fr:cpp/iterator/ostreambuf iterator/operator=]]
[[it:cpp/iterator/ostreambuf iterator/operator=]]
[[ja:cpp/iterator/ostreambuf iterator/operator=]]
[[pt:cpp/iterator/ostreambuf iterator/operator=]]
[[ru:cpp/iterator/ostreambuf iterator/operator=]]
[[zh:cpp/iterator/ostreambuf iterator/operator=]]</text>
      <sha1>mcxl65naihmaxjxbcj6rnj3s3xtpm8r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/operator arith</title>
    <ns>0</ns>
    <id>9126</id>
    <revision>
      <id>48459</id>
      <parentid>48457</parentid>
      <timestamp>2013-05-29T15:50:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[cpp/iterator/ostreambuf iterator/operator]] to [[cpp/iterator/ostreambuf iterator/operator arith]]: move to proper location</comment>
      <text xml:space="preserve" bytes="465">{{cpp/iterator/inserter/operator++|ostreambuf_iterator}}

[[de:cpp/iterator/ostreambuf iterator/operator++]]
[[es:cpp/iterator/ostreambuf iterator/operator++]]
[[fr:cpp/iterator/ostreambuf iterator/operator++]]
[[it:cpp/iterator/ostreambuf iterator/operator++]]
[[ja:cpp/iterator/ostreambuf iterator/operator++]]
[[pt:cpp/iterator/ostreambuf iterator/operator++]]
[[ru:cpp/iterator/ostreambuf iterator/operator++]]
[[zh:cpp/iterator/ostreambuf iterator/operator++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/ostreambuf iterator/ostreambuf iterator</title>
    <ns>0</ns>
    <id>9127</id>
    <revision>
      <id>64887</id>
      <parentid>49867</parentid>
      <timestamp>2013-08-27T01:45:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept, fmt</comment>
      <text xml:space="preserve" bytes="1638">{{cpp/iterator/ostreambuf_iterator/title|ostreambuf_iterator}}
{{cpp/iterator/ostreambuf_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
ostreambuf_iterator(streambuf_type* buffer)
}}
{{dcl | num=2 | 1=
ostreambuf_iterator(ostream_type&amp; stream)
}}
{{dcl end}}

@1@ Constructs the iterator with the private {{c|streambuf_type*}} member set to {{tt|buffer}} and the failed() bit set to {{c|false}}. The behavior is undefined if {{c|buffer}} is a null pointer.

@2@ Same as {{c|ostreambuf_iterator(stream.rdbuf())}}

===Parameters===
{{par begin}}
{{par | stream | the output stream whose rdbuf() will be accessed by this iterator}}
{{par | buffer | the output stream buffer to be accessed by this iterator}}
{{par end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;iterator&gt;
int main()
{
    std::basic_filebuf&lt;char&gt; f;
    f.open(&quot;test.txt&quot;, std::ios::out);

    std::ostreambuf_iterator&lt;char&gt; out1(&amp;f);

    std::ostreambuf_iterator&lt;wchar_t&gt; out2(std::wcout);

    *out1 = 'a';
    *out2 = L'a';
}
}}

[[de:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[es:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[fr:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[it:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[ja:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[pt:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[ru:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]
[[zh:cpp/iterator/ostreambuf iterator/ostreambuf iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/prev</title>
    <ns>0</ns>
    <id>2736</id>
    <revision>
      <id>62756</id>
      <parentid>57999</parentid>
      <timestamp>2013-07-01T23:39:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1358">{{cpp/title| prev}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | since=c++11 |
template&lt; class BidirIt &gt;
BidirIt prev( BidirIt it, 
              typename std::iterator_traits&lt;BidirIt&gt;::difference_type n {{=}} 1 );
}}
{{dcl end}}

Return the {{c|n}}th predecessor of iterator {{c|it}}.

===Parameters===
{{par begin}}
{{par | it | an iterator}}
{{par | n | number of elements {{c|it}} should be descended}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Return value===
The {{c|n}}th predecessor of iterator {{c|it}}.

===Possible implementation===
{{eq fun |
template&lt;class BidirIt&gt;
BidirIt prev(BidirIt it, typename std::iterator_traits&lt;BidirIt&gt;::difference_type n {{=}} 1)
{
    std::advance(it, -n);
    return it;
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v{ 3, 1, 4 };
    
    auto it = v.end();

    auto pv = std::prev(it, 2);

    std::cout &lt;&lt; *pv &lt;&lt; '\n';
}
 | output=1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc next}}
{{dsc inc | cpp/iterator/dsc advance}}
{{dsc end}}

[[de:cpp/iterator/prev]]
[[es:cpp/iterator/prev]]
[[fr:cpp/iterator/prev]]
[[it:cpp/iterator/prev]]
[[ja:cpp/iterator/prev]]
[[pt:cpp/iterator/prev]]
[[ru:cpp/iterator/prev]]
[[zh:cpp/iterator/prev]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/rbegin</title>
    <ns>0</ns>
    <id>9999</id>
    <revision>
      <id>66731</id>
      <parentid>66727</parentid>
      <timestamp>2013-12-28T17:33:12Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>rbegin gives us the last element, not the first</comment>
      <text xml:space="preserve" bytes="2342">{{cpp/title| rbegin}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | num=1 | since=c++14 |
template&lt; class C &gt; 
auto rbegin( C&amp; c ) -&gt; decltype(c.rbegin());
}}
{{dcl | num=1 | since=c++14 |
template&lt; class C &gt; 
auto rbegin( const C&amp; c ) -&gt; decltype(c.rbegin());
}}
{{dcl | num=2 | since=c++14 |
template&lt; class T, size_t N &gt; 
reverse_iterator&lt;T*&gt; rbegin( T (&amp;array)[N] );
}}
{{dcl | num=3 | since=c++14 |
template&lt; class C &gt; 
auto crbegin( const C&amp; c ) -&gt; decltype(std::rbegin(c));
}}
{{dcl end}}

Returns an iterator to the reverse-beginning of the given container {{tt|c}} or array {{tt|array}}.

@1@ Returns a possibly const-qualified iterator to the reverse-beginning of the container {{tt|c}}.
@2@ Returns {{c|std::reverse_iterator&lt;T*&gt;}} to the reverse-beginning of the array {{tt|array}}.
@3@ Returns a const-qualified iterator to the reverse-beginning of the container {{tt|c}}.

{{image|range-rbegin-rend.svg}}

===Parameters===
{{par begin}}
{{par | c | a container with a {{tt|rbegin}} method}}
{{par | array | an array of arbitrary type}}
{{par end}}

===Return value===
An iterator to the reverse-beginning of {{tt|c}} or {{tt|array}}

===Notes===
In addition to being included in {{tt|&lt;iterator&gt;}}, {{tt|std::rbegin}} is guaranteed to become available if any of the following headers are included: {{tt|&lt;array&gt;}}, {{tt|&lt;deque&gt;}}, {{tt|&lt;forward_list&gt;}}, {{tt|&lt;list&gt;}}, {{tt|&lt;map&gt;}}, {{tt|&lt;regex&gt;}}, {{tt|&lt;set&gt;}}, {{tt|&lt;string&gt;}}, {{tt|&lt;unordered_map&gt;}}, {{tt|&lt;unordered_set&gt;}}, and {{tt|&lt;vector&gt;}}.

===Specializations===
Custom specializations of {{tt|std::rbegin}} may be provided for classes that do not expose a suitable {{tt|rbegin()}} member function, yet can be iterated. The following specialization is already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc rbegin2}}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;

int main() 
{
    std::vector&lt;int&gt; v = { 3, 1, 4 };
    auto vi = std::rbegin(v);
    std::cout &lt;&lt; *vi &lt;&lt; '\n'; 

    int a[] = { -5, 10, 15 };
    auto ai = std::rbegin(a);
    std::cout &lt;&lt; *ai &lt;&lt; '\n';
}
 | output=
4
15
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc begin}}
{{dsc inc | cpp/iterator/dsc end}}
{{dsc inc | cpp/iterator/dsc rend}}
{{dsc end}}</text>
      <sha1>6ok4d7sk4f2hbgge0zelszttx32p4hr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/rend</title>
    <ns>0</ns>
    <id>10000</id>
    <revision>
      <id>70124</id>
      <parentid>70122</parentid>
      <timestamp>2014-05-10T13:54:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>std::rend was nowhere in the new example</comment>
      <text xml:space="preserve" bytes="2510">{{cpp/title| rend}}
{{cpp/iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | num=1 | since=c++14 |
template&lt; class C &gt; 
auto rend( C&amp; c ) -&gt; decltype(c.rend());
}}
{{dcl | num=1 | since=c++14 |
template&lt; class C &gt; 
auto rend( const C&amp; c ) -&gt; decltype(c.rend());
}}
{{dcl | num=2 | since=c++14 |
template&lt; class T, size_t N &gt; 
reverse_iterator&lt;T*&gt; rend( T (&amp;array)[N] );
}}
{{dcl | num=3 | since=c++14 |
template&lt; class C &gt; 
auto crend( const C&amp; c ) -&gt; decltype(std::rend(c));
}}
{{dcl end}}

Returns an iterator to the reverse-end of the given container {{tt|c}} or array {{tt|array}}.

@1@ Returns a possibly const-qualified iterator to the reverse-end of the container {{tt|c}}.
@2@ Returns {{c|std::reverse_iterator&lt;T*&gt;}} to the reverse-end of the array {{tt|array}}.
@3@ Returns a const-qualified iterator to the reverse-end of the container {{tt|c}}.

{{image|range-rbegin-rend.svg}}

===Parameters===
{{par begin}}
{{par | c | a container with a {{tt|rend}} method}}
{{par | array | an array of arbitrary type}}
{{par end}}

===Return value===
An iterator to the reverse-end of {{tt|c}} or {{tt|array}}

===Notes===
In addition to being included in {{tt|&lt;iterator&gt;}}, {{tt|std::rend}} is guaranteed to become available if any of the following headers are included: {{tt|&lt;array&gt;}}, {{tt|&lt;deque&gt;}}, {{tt|&lt;forward_list&gt;}}, {{tt|&lt;list&gt;}}, {{tt|&lt;map&gt;}}, {{tt|&lt;regex&gt;}}, {{tt|&lt;set&gt;}}, {{tt|&lt;string&gt;}}, {{tt|&lt;unordered_map&gt;}}, {{tt|&lt;unordered_set&gt;}}, and {{tt|&lt;vector&gt;}}.

===Specializations===
Custom specializations of {{tt|std::rend}} may be provided for classes that do not expose a suitable {{tt|rend()}} member function, yet can be iterated. The following specializations are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc rend2}}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;

int main()
{
    int a[] = {4, 6, -3, 9, 10};
    std::cout &lt;&lt; &quot;Array backwards: &quot;;
    std::copy(std::rbegin(a), std::rend(a), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));

    std::cout &lt;&lt; &quot;\nVector backwards: &quot;;
    std::vector&lt;int&gt; v = {4, 6, -3, 9, 10};
    std::copy(std::rbegin(v), std::rend(v), std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
 | output=
Array backwards: 10 9 -3 6 4 
Vector backwards: 10 9 -3 6 4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc end}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc begin}}
{{dsc end}}</text>
      <sha1>jtcss92w2zvv28jstnoegkcuj3t2kde</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator</title>
    <ns>0</ns>
    <id>4936</id>
    <revision>
      <id>72410</id>
      <parentid>67842</parentid>
      <timestamp>2014-08-19T21:31:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note that the equation shown doesn't hold for non-dereferenceable r (that is, the one constructed from begin)</comment>
      <text xml:space="preserve" bytes="3681">{{cpp/title|reverse_iterator}}
{{cpp/iterator/reverse_iterator/navbar}}
{{dcl begin}}
{{dcl header | iterator}}
{{dcl | 1=
template&lt; class Iterator &gt;
class reverse_iterator : public std::iterator&lt;
                           typename std::iterator_traits&lt;Iterator&gt;::iterator_category,
                           typename std::iterator_traits&lt;Iterator&gt;::value_type,
                           typename std::iterator_traits&lt;Iterator&gt;::difference_type,
                           typename std::iterator_traits&lt;Iterator&gt;::pointer,
                           typename std::iterator_traits&lt;Iterator&gt;::reference &gt;
}}
{{dcl end}}

{{tt|std::reverse_iterator}} is an iterator adaptor that reverses the direction of a given iterator.  In other words, when provided with a bidirectional iterator, {{tt|std::reverse_iterator}} produces a new iterator that moves from the end to the beginning of the sequence defined by the underlying bidirectional iterator.

For a reverse iterator {{tt|r}} constructed from an iterator {{tt|i}}, the relationship {{c|1=&amp;*r == &amp;*(i-1)}} is always true (as long as {{tt|r}} is dereferenceable); thus a reverse iterator constructed from a one-past-the-end iterator dereferences to the last element in a sequence. 

This is the iterator returned by member functions {{tt|rbegin()}} and {{tt|rend()}} of the standard library containers.

{{image|range-rbegin-rend.svg}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|iterator_type}} | {{tt|Iterator}}}}
{{dsc | {{tt|difference_type}} | {{c|std::iterator_traits&lt;Iterator&gt;::difference_type}}}}
{{dsc | {{tt|pointer}} | {{c|std::iterator_traits&lt;Iterator&gt;::pointer}}}}
{{dsc | {{tt|reference}} | {{c|std::iterator_traits&lt;Iterator&gt;::reference}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc constructor | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator{{=}} | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc base | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator* | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_arith | reverse_iterator}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Definition}}
{{dsc | {{tt|current}} {{mark|protected}} | a copy of the base() iterator}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_cmp | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator+ | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator- | reverse_iterator}}
{{dsc end}}

{{cpp/iterator/iterator/inherit
| std::iterator_traits&lt;Iterator&gt;::iterator_category
| std::iterator_traits&lt;Iterator&gt;::value_type
| std::iterator_traits&lt;Iterator&gt;::difference_type
| std::iterator_traits&lt;Iterator&gt;::pointer
| std::iterator_traits&lt;Iterator&gt;::reference
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;iterator&gt;

int main()
{
    std::string s = &quot;Hello, world&quot;;
    std::reverse_iterator&lt;std::string::iterator&gt; r = s.rbegin();
    r[7] = 'O'; // replaces 'o' with 'O' 
    r += 7; // iterator now points at 'O'
    std::string rev(r, s.rend());
    std::cout &lt;&lt; rev &lt;&lt; '\n';
}
 | output=
OlleH
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc iterator}}
{{dsc end}}

[[de:cpp/iterator/reverse iterator]]
[[es:cpp/iterator/reverse iterator]]
[[fr:cpp/iterator/reverse iterator]]
[[it:cpp/iterator/reverse iterator]]
[[ja:cpp/iterator/reverse iterator]]
[[pt:cpp/iterator/reverse iterator]]
[[ru:cpp/iterator/reverse iterator]]
[[zh:cpp/iterator/reverse iterator]]</text>
      <sha1>m1gyzyr28lgi0renntp3i5rl05oajh1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/base</title>
    <ns>0</ns>
    <id>5615</id>
    <revision>
      <id>72260</id>
      <parentid>72259</parentid>
      <timestamp>2014-08-01T05:51:12Z</timestamp>
      <contributor>
        <username>Vinipsmaker</username>
        <id>3281</id>
      </contributor>
      <comment>Add more comments to ease understanding</comment>
      <text xml:space="preserve" bytes="1460">{{cpp/iterator/reverse_iterator/title| base}}
{{cpp/iterator/reverse_iterator/navbar}}
{{dcl begin}}
{{dcl | 
Iterator base() const;
}}
{{dcl end}}

Returns the underlying base iterator. That is {{c|std::reverse_iterator(it).base() {{==}} it}}.

The base iterator refers to the element that is next (from the {{c|std::reverse_iterator::iterator_type}} perspective) to the element the {{tt|reverse_iterator}} is currently pointing to. That is {{c|&amp;*(rit.base() - 1) {{==}} &amp;*rit}}.

===Parameters===
(none)

===Return value===
The underlying iterator.

===Exceptions===
(none)

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v = { 0, 1, 2, 3, 4, 5 };
    
    using RevIt = std::reverse_iterator&lt;std::vector&lt;int&gt;::iterator&gt;;
    RevIt r_end(v.begin());
    RevIt r_begin(v.end());

    for (auto it = r_end.base(); it != r_begin.base(); ++it) {
        std::cout &lt;&lt; *it &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; &quot;\n&quot;;
}
 | output=
0 1 2 3 4 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator*|reverse_iterator}}
{{dsc end}}


[[de:cpp/iterator/reverse iterator/base]]
[[es:cpp/iterator/reverse iterator/base]]
[[fr:cpp/iterator/reverse iterator/base]]
[[it:cpp/iterator/reverse iterator/base]]
[[ja:cpp/iterator/reverse iterator/base]]
[[pt:cpp/iterator/reverse iterator/base]]
[[ru:cpp/iterator/reverse iterator/base]]
[[zh:cpp/iterator/reverse iterator/base]]</text>
      <sha1>1dlolvyumomkq53c5romeswm0bo0odc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator*</title>
    <ns>0</ns>
    <id>5616</id>
    <revision>
      <id>68841</id>
      <parentid>67843</parentid>
      <timestamp>2014-03-22T17:00:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2188</comment>
      <text xml:space="preserve" bytes="1304">{{cpp/iterator/reverse_iterator/title | operator*,-&gt; }}
{{cpp/iterator/reverse_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 |
reference operator*() const;
}}
{{dcl | num=2 | 
pointer operator-&gt;() const;
}}
{{dcl end}}

Returns a reference or pointer to the element previous to {{tt|current}}.

@1@ Equivalent to {{c|1=Iterator tmp = current; return *--tmp;}}
@2@ Equivalent to {{c|std::addressof(operator*())}}.

===Parameters===
(none)

===Return value===
Reference or pointer to the element previous to {{tt|current}}.

===Notes===
Prior to the introduction of multithreading in C++11, implementations of {{tt|reverse_iterator}} commonly stored a decremented copy of {{tt|current}} as a member, see [http://cplusplus.github.io/LWG/lwg-defects.html#2360 defect 2360].

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at|reverse_iterator}}
{{dsc end}}

[[de:cpp/iterator/reverse iterator/operator*]]
[[es:cpp/iterator/reverse iterator/operator*]]
[[fr:cpp/iterator/reverse iterator/operator*]]
[[it:cpp/iterator/reverse iterator/operator*]]
[[ja:cpp/iterator/reverse iterator/operator*]]
[[pt:cpp/iterator/reverse iterator/operator*]]
[[ru:cpp/iterator/reverse iterator/operator*]]
[[zh:cpp/iterator/reverse iterator/operator*]]</text>
      <sha1>jhgkvcjwzs27wuwecmeldumofyf4azt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator+</title>
    <ns>0</ns>
    <id>8740</id>
    <revision>
      <id>50885</id>
      <parentid>47393</parentid>
      <timestamp>2013-06-01T03:43:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="441">{{include page|cpp/iterator/adaptor/operator+|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator+]]
[[es:cpp/iterator/reverse iterator/operator+]]
[[fr:cpp/iterator/reverse iterator/operator+]]
[[it:cpp/iterator/reverse iterator/operator+]]
[[ja:cpp/iterator/reverse iterator/operator+]]
[[pt:cpp/iterator/reverse iterator/operator+]]
[[ru:cpp/iterator/reverse iterator/operator+]]
[[zh:cpp/iterator/reverse iterator/operator+]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator++</title>
    <ns>0</ns>
    <id>5618</id>
    <redirect title="cpp/iterator/reverse iterator/operator arith" />
    <revision>
      <id>36872</id>
      <parentid>33816</parentid>
      <timestamp>2012-07-02T19:04:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/iterator/reverse iterator/operator arith]]</comment>
      <text xml:space="preserve" bytes="58">#redirect [[cpp/iterator/reverse_iterator/operator_arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator-</title>
    <ns>0</ns>
    <id>8736</id>
    <revision>
      <id>50886</id>
      <parentid>42025</parentid>
      <timestamp>2013-06-01T03:43:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="441">{{include page|cpp/iterator/adaptor/operator-|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator-]]
[[es:cpp/iterator/reverse iterator/operator-]]
[[fr:cpp/iterator/reverse iterator/operator-]]
[[it:cpp/iterator/reverse iterator/operator-]]
[[ja:cpp/iterator/reverse iterator/operator-]]
[[pt:cpp/iterator/reverse iterator/operator-]]
[[ru:cpp/iterator/reverse iterator/operator-]]
[[zh:cpp/iterator/reverse iterator/operator-]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator--</title>
    <ns>0</ns>
    <id>5619</id>
    <redirect title="cpp/iterator/reverse iterator/operator arith" />
    <revision>
      <id>36869</id>
      <parentid>33927</parentid>
      <timestamp>2012-07-02T18:46:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/iterator/reverse iterator/operator arith]]</comment>
      <text xml:space="preserve" bytes="58">#redirect [[cpp/iterator/reverse_iterator/operator_arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator=</title>
    <ns>0</ns>
    <id>5614</id>
    <revision>
      <id>42017</id>
      <parentid>36842</parentid>
      <timestamp>2012-11-02T21:47:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="432">{{cpp/iterator/adaptor/operator{{=}}|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator=]]
[[es:cpp/iterator/reverse iterator/operator=]]
[[fr:cpp/iterator/reverse iterator/operator=]]
[[it:cpp/iterator/reverse iterator/operator=]]
[[ja:cpp/iterator/reverse iterator/operator=]]
[[pt:cpp/iterator/reverse iterator/operator=]]
[[ru:cpp/iterator/reverse iterator/operator=]]
[[zh:cpp/iterator/reverse iterator/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator arith</title>
    <ns>0</ns>
    <id>8733</id>
    <revision>
      <id>50887</id>
      <parentid>42005</parentid>
      <timestamp>2013-06-01T03:43:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="486">{{include page|cpp/iterator/adaptor/operator_arith|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator arith]]
[[es:cpp/iterator/reverse iterator/operator arith]]
[[fr:cpp/iterator/reverse iterator/operator arith]]
[[it:cpp/iterator/reverse iterator/operator arith]]
[[ja:cpp/iterator/reverse iterator/operator arith]]
[[pt:cpp/iterator/reverse iterator/operator arith]]
[[ru:cpp/iterator/reverse iterator/operator arith]]
[[zh:cpp/iterator/reverse iterator/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator at</title>
    <ns>0</ns>
    <id>5617</id>
    <revision>
      <id>50888</id>
      <parentid>42002</parentid>
      <timestamp>2013-06-01T03:43:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="459">{{include page|cpp/iterator/adaptor/operator_at|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator at]]
[[es:cpp/iterator/reverse iterator/operator at]]
[[fr:cpp/iterator/reverse iterator/operator at]]
[[it:cpp/iterator/reverse iterator/operator at]]
[[ja:cpp/iterator/reverse iterator/operator at]]
[[pt:cpp/iterator/reverse iterator/operator at]]
[[ru:cpp/iterator/reverse iterator/operator at]]
[[zh:cpp/iterator/reverse iterator/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator cmp</title>
    <ns>0</ns>
    <id>5623</id>
    <revision>
      <id>50889</id>
      <parentid>41990</parentid>
      <timestamp>2013-06-01T03:43:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="468">{{include page|cpp/iterator/adaptor/operator_cmp|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/operator cmp]]
[[es:cpp/iterator/reverse iterator/operator cmp]]
[[fr:cpp/iterator/reverse iterator/operator cmp]]
[[it:cpp/iterator/reverse iterator/operator cmp]]
[[ja:cpp/iterator/reverse iterator/operator cmp]]
[[pt:cpp/iterator/reverse iterator/operator cmp]]
[[ru:cpp/iterator/reverse iterator/operator cmp]]
[[zh:cpp/iterator/reverse iterator/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/operator eq</title>
    <ns>0</ns>
    <id>5622</id>
    <redirect title="cpp/iterator/reverse iterator/operator cmp" />
    <revision>
      <id>36867</id>
      <parentid>33931</parentid>
      <timestamp>2012-07-02T18:34:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/iterator/reverse iterator/operator cmp]]</comment>
      <text xml:space="preserve" bytes="56">#redirect [[cpp/iterator/reverse_iterator/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/iterator/reverse iterator/reverse iterator</title>
    <ns>0</ns>
    <id>5613</id>
    <revision>
      <id>50890</id>
      <parentid>41985</parentid>
      <timestamp>2013-06-01T03:43:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="499">{{include page|cpp/iterator/adaptor/constructor|reverse_iterator}}

[[de:cpp/iterator/reverse iterator/reverse iterator]]
[[es:cpp/iterator/reverse iterator/reverse iterator]]
[[fr:cpp/iterator/reverse iterator/reverse iterator]]
[[it:cpp/iterator/reverse iterator/reverse iterator]]
[[ja:cpp/iterator/reverse iterator/reverse iterator]]
[[pt:cpp/iterator/reverse iterator/reverse iterator]]
[[ru:cpp/iterator/reverse iterator/reverse iterator]]
[[zh:cpp/iterator/reverse iterator/reverse iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword</title>
    <ns>0</ns>
    <id>627</id>
    <revision>
      <id>71858</id>
      <parentid>71857</parentid>
      <timestamp>2014-06-28T17:30:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>really link</comment>
      <text xml:space="preserve" bytes="3943">{{title|C++ keywords}}
{{cpp/keyword/navbar}}

This is a list of reserved keywords in C++. Since they are used by the language, these keywords are not available for re-definition or overloading. 

{| class=&quot;wikitable&quot;
|-
|
{{rlt|alignas}} {{mark since c++11}}&lt;br&gt;
{{rlt|alignof}} {{mark since c++11}}&lt;br&gt;
{{rlt|and}}&lt;br&gt;
{{rlt|and_eq}}&lt;br&gt;
{{rlt|asm}}&lt;br&gt;
{{rlt|auto}}{{mark|1}}&lt;br&gt;
{{rlt|bitand}}&lt;br&gt;
{{rlt|bitor}}&lt;br&gt;
{{rlt|bool}}&lt;br&gt;
{{rlt|break}}&lt;br&gt;
{{rlt|case}}&lt;br&gt;
{{rlt|catch}}&lt;br&gt;
{{rlt|char}}&lt;br&gt;
{{rlt|char16_t}} {{mark since c++11}}&lt;br&gt;
{{rlt|char32_t}} {{mark since c++11}}&lt;br&gt;
{{rlt|class}}&lt;br&gt;
{{rlt|compl}}&lt;br&gt;
{{rlt|const}}&lt;br&gt;
{{rlt|constexpr}} {{mark since c++11}}&lt;br&gt;
{{rlt|const_cast}}&lt;br&gt;
{{rlt|continue}}&lt;br&gt;
{{rlt|decltype}} {{mark since c++11}}&lt;br&gt;
{{rlt|default}}{{mark|1}}&lt;br&gt;
{{rlt|delete}}{{mark|1}}&lt;br&gt;
{{rlt|do}}&lt;br&gt;
{{rlt|double}}&lt;br&gt;
{{rlt|dynamic_cast}}&lt;br&gt;
{{rlt|else}}&lt;br&gt;
|
{{rlt|enum}}&lt;br&gt;
{{rlt|explicit}}&lt;br&gt;
{{rlt|export}}{{mark|1}}&lt;br&gt; 
{{rlt|extern}}&lt;br&gt;
{{rlt|false}}&lt;br&gt;
{{rlt|float}}&lt;br&gt;
{{rlt|for}}&lt;br&gt;
{{rlt|friend}}&lt;br&gt;
{{rlt|goto}}&lt;br&gt;
{{rlt|if}}&lt;br&gt;
{{rlt|inline}}&lt;br&gt;
{{rlt|int}}&lt;br&gt;
{{rlt|long}}&lt;br&gt;
{{rlt|mutable}}&lt;br&gt;
{{rlt|namespace}}&lt;br&gt;
{{rlt|new}}&lt;br&gt;
{{rlt|noexcept}} {{mark since c++11}}&lt;br&gt;
{{rlt|not}}&lt;br&gt;
{{rlt|not_eq}}&lt;br&gt;
{{rlt|nullptr}} {{mark since c++11}}&lt;br&gt;
{{rlt|operator}}&lt;br&gt;
{{rlt|or}}&lt;br&gt;
{{rlt|or_eq}}&lt;br&gt;
{{rlt|private}}&lt;br&gt;
{{rlt|protected}}&lt;br&gt;
{{rlt|public}}&lt;br&gt;
{{rlt|register}}&lt;br&gt;
{{rlt|reinterpret_cast}}&lt;br&gt;
|
{{rlt|return}}&lt;br&gt;
{{rlt|short}}&lt;br&gt;
{{rlt|signed}}&lt;br&gt;
{{rlt|sizeof}}&lt;br&gt;
{{rlt|static}}&lt;br&gt;
{{rlt|static_assert}} {{mark since c++11}}&lt;br&gt;
{{rlt|static_cast}}&lt;br&gt;
{{rlt|struct}}&lt;br&gt;
{{rlt|switch}}&lt;br&gt;
{{rlt|template}}&lt;br&gt;
{{rlt|this}}&lt;br&gt;
{{rlt|thread_local}} {{mark since c++11}}&lt;br&gt;
{{rlt|throw}}&lt;br&gt;
{{rlt|true}}&lt;br&gt;
{{rlt|try}}&lt;br&gt;
{{rlt|typedef}}&lt;br&gt;
{{rlt|typeid}}&lt;br&gt;
{{rlt|typename}}&lt;br&gt;
{{rlt|union}}&lt;br&gt;
{{rlt|unsigned}}&lt;br&gt;
{{rlt|using}}{{mark|1}}&lt;br&gt;
{{rlt|virtual}}&lt;br&gt;
{{rlt|void}}&lt;br&gt;
{{rlt|volatile}}&lt;br&gt;
{{rlt|wchar_t}}&lt;br&gt;
{{rlt|while}}&lt;br&gt;
{{rlt|xor}}&lt;br&gt;
{{rlt|xor_eq}}
|}

* (1) - meaning changed in C++11
Note that {{rlt|and}}, {{rlt|bitor}}, {{rlt|or}}, {{rlt|xor}}, {{rlt|compl}}, {{rlt|bitand}}, {{rlt|and_eq}}, {{rlt|or_eq}}, {{rlt|xor_eq}}, {{rlt|not}}, and {{rlt|not_eq}} (along with the digraphs {{tt|&lt;%}}, {{tt|%&gt;}}, {{tt|&lt;:}}, {{tt|:&gt;}}, {{tt|%:}}, and {{tt|%:%:}}) provide an [[cpp/language/operator_alternative|alternative way to represent standard tokens]].

In addition to keywords, there are two ''identifiers with special meaning'', which may be used as names of objects or functions, but have special meaning in certain contexts.

{| class=&quot;wikitable&quot;
|-
|{{rlt|override}} {{mark c++11}}&lt;br&gt;
{{rlt|final}} {{mark c++11}}
|}

Also, each name that contains a double underscore __ or begins with an underscore followed by an uppercase letter is always reserved to the implementation and should not be used as an identifier.

Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace; such names may be used as identifiers in user-defined namespaces, as names of class members, etc. {{todo|+other contents of C++03 17.4.3.1 [lib.reserved.names] &amp; C++11/14 17.6.4.3 [reserved.names]}}

The namespace {{tt|std}} is used to place names of the standard C++ library. See [[cpp/language/extending_std|Extending namespace std]] for the rules about adding names to it.

{{rev begin}}
{{rev|since=c++11|The name {{tt|posix}} is reserved for a future top-level namespace. The behavior is undefined if a program declares or defines anything in that namespace.}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc see c | c/keyword |C keywords}}
{{dsc end}}

[[ar:cpp/keyword]]
[[de:cpp/keyword]]
[[es:cpp/keyword]]
[[fr:cpp/keyword]]
[[it:cpp/keyword]]
[[ja:cpp/keyword]]
[[ko:cpp/keyword]]
[[pl:cpp/keyword]]
[[pt:cpp/keyword]]
[[ru:cpp/keyword]]
[[zh:cpp/keyword]]</text>
      <sha1>3sfw1gss3042q15y9uldew3iiuq1cj4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/alignas</title>
    <ns>0</ns>
    <id>3520</id>
    <revision>
      <id>44545</id>
      <parentid>33934</parentid>
      <timestamp>2012-11-03T07:11:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="379">{{cpp/keyword/title|alignas {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/alignas | {{tt|alignas}} specifier]] {{mark since c++11}}

[[de:cpp/keyword/alignas]]
[[es:cpp/keyword/alignas]]
[[fr:cpp/keyword/alignas]]
[[it:cpp/keyword/alignas]]
[[ja:cpp/keyword/alignas]]
[[pt:cpp/keyword/alignas]]
[[ru:cpp/keyword/alignas]]
[[zh:cpp/keyword/alignas]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/alignof</title>
    <ns>0</ns>
    <id>2478</id>
    <revision>
      <id>44544</id>
      <parentid>33935</parentid>
      <timestamp>2012-11-03T07:10:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="463">{{cpp/keyword/title|alignof {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/alignof | {{tt|alignof}} operator]] {{mark since c++11}}

===Example===

{{example|code=

std::cout &lt;&lt; alignof(std::max_align_t) &lt;&lt; '\n';

}}

[[de:cpp/keyword/alignof]]
[[es:cpp/keyword/alignof]]
[[fr:cpp/keyword/alignof]]
[[it:cpp/keyword/alignof]]
[[ja:cpp/keyword/alignof]]
[[pt:cpp/keyword/alignof]]
[[ru:cpp/keyword/alignof]]
[[zh:cpp/keyword/alignof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/and</title>
    <ns>0</ns>
    <id>628</id>
    <revision>
      <id>44543</id>
      <parentid>33936</parentid>
      <timestamp>2012-11-03T07:09:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="449">{{cpp/keyword/title|and}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|&amp;&amp;}}

===Example===

{{example|code=

if(n &gt; 0 and n &lt; 5)
{
    std::cout &lt;&lt; &quot;n is small and positive\n&quot;;
}
}}

[[de:cpp/keyword/and]]
[[es:cpp/keyword/and]]
[[fr:cpp/keyword/and]]
[[it:cpp/keyword/and]]
[[ja:cpp/keyword/and]]
[[pt:cpp/keyword/and]]
[[ru:cpp/keyword/and]]
[[zh:cpp/keyword/and]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/and eq</title>
    <ns>0</ns>
    <id>629</id>
    <revision>
      <id>44542</id>
      <parentid>33937</parentid>
      <timestamp>2012-11-03T07:08:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="607">{{cpp/keyword/title|and_eq}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|&lt;nowiki&gt;&amp;=&lt;/nowiki&gt;}}

===Example===

{{example|code=

#include &lt;iostream&gt;
#include &lt;bitset&gt;
int main()
{
    std::bitset&lt;4&gt; mask(&quot;1100&quot;);
    std::bitset&lt;4&gt; val(&quot;0111&quot;);
    val and_eq mask;
    std::cout &lt;&lt; val &lt;&lt; '\n';
}
| output=
0100
}}

[[de:cpp/keyword/and eq]]
[[es:cpp/keyword/and eq]]
[[fr:cpp/keyword/and eq]]
[[it:cpp/keyword/and eq]]
[[ja:cpp/keyword/and eq]]
[[pt:cpp/keyword/and eq]]
[[ru:cpp/keyword/and eq]]
[[zh:cpp/keyword/and eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/asm</title>
    <ns>0</ns>
    <id>5058</id>
    <revision>
      <id>44541</id>
      <parentid>33938</parentid>
      <timestamp>2012-11-03T07:08:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/asm]], [[es:cpp/keyword/asm]], [[zh:cpp/keyword/asm]]</comment>
      <text xml:space="preserve" bytes="450">{{cpp/keyword/title|asm}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/asm | Declaration of an inline assembly block]]


===Example===

{{example|code=
// call exit(0) on 32-bit x86 Linux
asm(&quot;movl $1,%%eax;
     xorl %%ebx,%%ebx;
     int  $0x80&quot;
    );
}}

[[de:cpp/keyword/asm]]
[[es:cpp/keyword/asm]]
[[fr:cpp/keyword/asm]]
[[it:cpp/keyword/asm]]
[[ja:cpp/keyword/asm]]
[[pt:cpp/keyword/asm]]
[[ru:cpp/keyword/asm]]
[[zh:cpp/keyword/asm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/auto</title>
    <ns>0</ns>
    <id>630</id>
    <revision>
      <id>67534</id>
      <parentid>44540</parentid>
      <timestamp>2014-02-11T11:36:43Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>syntax</comment>
      <text xml:space="preserve" bytes="451">{{cpp/keyword/title|auto}}
{{cpp/keyword/navbar}}
===Usage===
{{rev begin}}
{{rev | until=c++11 |
* [[cpp/language/storage duration | automatic storage duration specifier]]
}}{{rev | since=c++11|
* [[cpp/language/auto | {{tt|auto}} specifier]]
}}
{{rev end}}

[[de:cpp/keyword/auto]]
[[es:cpp/keyword/auto]]
[[fr:cpp/keyword/auto]]
[[it:cpp/keyword/auto]]
[[ja:cpp/keyword/auto]]
[[pt:cpp/keyword/auto]]
[[ru:cpp/keyword/auto]]
[[zh:cpp/keyword/auto]]</text>
      <sha1>n3tw2vsa5bxcde1evfay73ovu29b861</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/bitand</title>
    <ns>0</ns>
    <id>631</id>
    <revision>
      <id>44539</id>
      <parentid>33940</parentid>
      <timestamp>2012-11-03T07:06:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="369">{{cpp/keyword/title|bitand}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|&amp;}}

[[de:cpp/keyword/bitand]]
[[es:cpp/keyword/bitand]]
[[fr:cpp/keyword/bitand]]
[[it:cpp/keyword/bitand]]
[[ja:cpp/keyword/bitand]]
[[pt:cpp/keyword/bitand]]
[[ru:cpp/keyword/bitand]]
[[zh:cpp/keyword/bitand]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/bitor</title>
    <ns>0</ns>
    <id>632</id>
    <revision>
      <id>44538</id>
      <parentid>33194</parentid>
      <timestamp>2012-11-03T07:05:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="364">{{cpp/keyword/title|bitor}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|{{!}}}}

[[de:cpp/keyword/bitor]]
[[es:cpp/keyword/bitor]]
[[fr:cpp/keyword/bitor]]
[[it:cpp/keyword/bitor]]
[[ja:cpp/keyword/bitor]]
[[pt:cpp/keyword/bitor]]
[[ru:cpp/keyword/bitor]]
[[zh:cpp/keyword/bitor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/bool</title>
    <ns>0</ns>
    <id>633</id>
    <revision>
      <id>44537</id>
      <parentid>33941</parentid>
      <timestamp>2012-11-03T07:05:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/bool]], [[ru:cpp/keyword/bool]], [[zh:cpp/keyword/bool]]</comment>
      <text xml:space="preserve" bytes="331">{{cpp/keyword/title|bool}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|bool}} type]]: as the declaration of the type

[[de:cpp/keyword/bool]]
[[es:cpp/keyword/bool]]
[[fr:cpp/keyword/bool]]
[[it:cpp/keyword/bool]]
[[ja:cpp/keyword/bool]]
[[pt:cpp/keyword/bool]]
[[ru:cpp/keyword/bool]]
[[zh:cpp/keyword/bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/break</title>
    <ns>0</ns>
    <id>634</id>
    <revision>
      <id>44536</id>
      <parentid>40104</parentid>
      <timestamp>2012-11-03T07:03:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, ru, zh</comment>
      <text xml:space="preserve" bytes="404">{{cpp/keyword/title|break}}
{{cpp/keyword/navbar}}
{{cpp/keyword/title | break}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/break | {{tt|break}} statement]]: as the declaration of the statement

[[de:cpp/keyword/break]]
[[es:cpp/keyword/break]]
[[fr:cpp/keyword/break]]
[[it:cpp/keyword/break]]
[[ja:cpp/keyword/break]]
[[pt:cpp/keyword/break]]
[[ru:cpp/keyword/break]]
[[zh:cpp/keyword/break]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/case</title>
    <ns>0</ns>
    <id>635</id>
    <revision>
      <id>44534</id>
      <parentid>33943</parentid>
      <timestamp>2012-11-03T07:02:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="346">{{cpp/keyword/title|case}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/switch | {{tt|switch}} statement]]: as the declaration of the case labels

[[de:cpp/keyword/case]]
[[es:cpp/keyword/case]]
[[fr:cpp/keyword/case]]
[[it:cpp/keyword/case]]
[[ja:cpp/keyword/case]]
[[pt:cpp/keyword/case]]
[[ru:cpp/keyword/case]]
[[zh:cpp/keyword/case]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/catch</title>
    <ns>0</ns>
    <id>636</id>
    <revision>
      <id>44533</id>
      <parentid>33944</parentid>
      <timestamp>2012-11-03T07:02:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="318">{{cpp/keyword/title|catch}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/try catch | {{tt|try-catch}} block]]

[[de:cpp/keyword/catch]]
[[es:cpp/keyword/catch]]
[[fr:cpp/keyword/catch]]
[[it:cpp/keyword/catch]]
[[ja:cpp/keyword/catch]]
[[pt:cpp/keyword/catch]]
[[ru:cpp/keyword/catch]]
[[zh:cpp/keyword/catch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/char</title>
    <ns>0</ns>
    <id>637</id>
    <revision>
      <id>44531</id>
      <parentid>33945</parentid>
      <timestamp>2012-11-03T07:01:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="331">{{cpp/keyword/title|char}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|char}} type]]: as the declaration of the type

[[de:cpp/keyword/char]]
[[es:cpp/keyword/char]]
[[fr:cpp/keyword/char]]
[[it:cpp/keyword/char]]
[[ja:cpp/keyword/char]]
[[pt:cpp/keyword/char]]
[[ru:cpp/keyword/char]]
[[zh:cpp/keyword/char]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/char16 t</title>
    <ns>0</ns>
    <id>638</id>
    <revision>
      <id>44529</id>
      <parentid>33946</parentid>
      <timestamp>2012-11-03T07:00:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="414">{{cpp/keyword/title|char16_t {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/types | {{tt|char16_t}} type]]: as the declaration of the type {{mark since c++11}}

[[de:cpp/keyword/char16 t]]
[[es:cpp/keyword/char16 t]]
[[fr:cpp/keyword/char16 t]]
[[it:cpp/keyword/char16 t]]
[[ja:cpp/keyword/char16 t]]
[[pt:cpp/keyword/char16 t]]
[[ru:cpp/keyword/char16 t]]
[[zh:cpp/keyword/char16 t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/char32 t</title>
    <ns>0</ns>
    <id>639</id>
    <revision>
      <id>44527</id>
      <parentid>33947</parentid>
      <timestamp>2012-11-03T06:59:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="414">{{cpp/keyword/title|char32_t {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/types | {{tt|char32_t}} type]]: as the declaration of the type {{mark since c++11}}

[[de:cpp/keyword/char32 t]]
[[es:cpp/keyword/char32 t]]
[[fr:cpp/keyword/char32 t]]
[[it:cpp/keyword/char32 t]]
[[ja:cpp/keyword/char32 t]]
[[pt:cpp/keyword/char32 t]]
[[ru:cpp/keyword/char32 t]]
[[zh:cpp/keyword/char32 t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/class</title>
    <ns>0</ns>
    <id>3526</id>
    <revision>
      <id>65375</id>
      <parentid>44525</parentid>
      <timestamp>2013-09-10T20:34:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention template template</comment>
      <text xml:space="preserve" bytes="1137">{{cpp/keyword/title|class}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/class | declaration of a class]]
* In a [[cpp/language/class_template | class template]] or [[cpp/language/function_template | function template]], {{c|class}} can be used as an alternative to [[cpp/keyword/typename | typename]] to introduce type template parameters and is required to introduce template template parameters.
* If a function or a variable exists in scope with the name identical to the name of a class type, {{tt|class}} can be prepended to the name for disambiguation, resulting in an ''elaborated type specifier''

===Example===

{{example|code=
class Foo;  // forward declaration of a class

class Bar { // definition of a class
  public:
    Bar(int i) : m_i(i) {}
  private:
    int m_i;
};

template &lt;class T&gt; // template argument
void qux() {
    T t;
}

int main()
{
    Bar Bar(1);
    class Bar Bar2(2); // elaborated type
}
}}

[[de:cpp/keyword/class]]
[[es:cpp/keyword/class]]
[[fr:cpp/keyword/class]]
[[it:cpp/keyword/class]]
[[ja:cpp/keyword/class]]
[[pt:cpp/keyword/class]]
[[ru:cpp/keyword/class]]
[[zh:cpp/keyword/class]]</text>
      <sha1>rlhfu42tvk6u2d7sr3tzubrj1hpgljm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/compl</title>
    <ns>0</ns>
    <id>640</id>
    <revision>
      <id>44522</id>
      <parentid>33949</parentid>
      <timestamp>2012-11-03T06:57:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="360">{{cpp/keyword/title|compl}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|~}}

[[de:cpp/keyword/compl]]
[[es:cpp/keyword/compl]]
[[fr:cpp/keyword/compl]]
[[it:cpp/keyword/compl]]
[[ja:cpp/keyword/compl]]
[[pt:cpp/keyword/compl]]
[[ru:cpp/keyword/compl]]
[[zh:cpp/keyword/compl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/const</title>
    <ns>0</ns>
    <id>641</id>
    <revision>
      <id>44520</id>
      <parentid>33951</parentid>
      <timestamp>2012-11-03T06:57:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, zh</comment>
      <text xml:space="preserve" bytes="316">{{cpp/keyword/title|const}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/cv | {{tt|const}} type specifier]]

[[de:cpp/keyword/const]]
[[es:cpp/keyword/const]]
[[fr:cpp/keyword/const]]
[[it:cpp/keyword/const]]
[[ja:cpp/keyword/const]]
[[pt:cpp/keyword/const]]
[[ru:cpp/keyword/const]]
[[zh:cpp/keyword/const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/const cast</title>
    <ns>0</ns>
    <id>642</id>
    <revision>
      <id>44518</id>
      <parentid>33952</parentid>
      <timestamp>2012-11-03T06:56:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="424">{{cpp/keyword/title|const_cast}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/const_cast | {{tt|const_cast}} type conversion expression]]: as the declaration of the expression

[[de:cpp/keyword/const cast]]
[[es:cpp/keyword/const cast]]
[[fr:cpp/keyword/const cast]]
[[it:cpp/keyword/const cast]]
[[ja:cpp/keyword/const cast]]
[[pt:cpp/keyword/const cast]]
[[ru:cpp/keyword/const cast]]
[[zh:cpp/keyword/const cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/constexpr</title>
    <ns>0</ns>
    <id>643</id>
    <revision>
      <id>44516</id>
      <parentid>33953</parentid>
      <timestamp>2012-11-03T06:55:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="413">{{cpp/keyword/title|constexpr {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/constexpr | {{tt|constexpr}} declaration specifier]] {{mark since c++11}}

[[de:cpp/keyword/constexpr]]
[[es:cpp/keyword/constexpr]]
[[fr:cpp/keyword/constexpr]]
[[it:cpp/keyword/constexpr]]
[[ja:cpp/keyword/constexpr]]
[[pt:cpp/keyword/constexpr]]
[[ru:cpp/keyword/constexpr]]
[[zh:cpp/keyword/constexpr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/continue</title>
    <ns>0</ns>
    <id>644</id>
    <revision>
      <id>44514</id>
      <parentid>33954</parentid>
      <timestamp>2012-11-03T06:55:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="412">{{cpp/keyword/title|continue}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/continue | {{tt|continue}} statement]]: as the declaration of the statement

[[de:cpp/keyword/continue]]
[[es:cpp/keyword/continue]]
[[fr:cpp/keyword/continue]]
[[it:cpp/keyword/continue]]
[[ja:cpp/keyword/continue]]
[[pl:cpp/keyword/continue]]
[[pt:cpp/keyword/continue]]
[[ru:cpp/keyword/continue]]
[[zh:cpp/keyword/continue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/decltype</title>
    <ns>0</ns>
    <id>3103</id>
    <revision>
      <id>44512</id>
      <parentid>33955</parentid>
      <timestamp>2012-11-03T06:54:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="347">{{cpp/keyword/title|decltype}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/decltype | {{tt|decltype}} specifier]]

[[de:cpp/keyword/decltype]]
[[es:cpp/keyword/decltype]]
[[fr:cpp/keyword/decltype]]
[[it:cpp/keyword/decltype]]
[[ja:cpp/keyword/decltype]]
[[pt:cpp/keyword/decltype]]
[[ru:cpp/keyword/decltype]]
[[zh:cpp/keyword/decltype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/default</title>
    <ns>0</ns>
    <id>645</id>
    <revision>
      <id>44510</id>
      <parentid>33956</parentid>
      <timestamp>2012-11-03T06:53:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="541">{{cpp/keyword/title|default}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/switch | {{tt|switch}} statement]]: as the declaration of the default case label
* {{todo}} as an explicit instruction to the compiler to generate default constructor, copy constructor or assignment operator for a class. {{mark since c++11}}

[[de:cpp/keyword/default]]
[[es:cpp/keyword/default]]
[[fr:cpp/keyword/default]]
[[it:cpp/keyword/default]]
[[ja:cpp/keyword/default]]
[[pt:cpp/keyword/default]]
[[ru:cpp/keyword/default]]
[[zh:cpp/keyword/default]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/delete</title>
    <ns>0</ns>
    <id>646</id>
    <revision>
      <id>44508</id>
      <parentid>33957</parentid>
      <timestamp>2012-11-03T06:52:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, ru, zh</comment>
      <text xml:space="preserve" bytes="487">{{cpp/keyword/title|delete}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/delete | {{tt|delete}} expression]]
* [[cpp/memory/new/operator_delete | allocation functions]] as the name of operator-like functions
* {{todo}} implicitly deleted functions {{mark since c++11}}

[[de:cpp/keyword/delete]]
[[es:cpp/keyword/delete]]
[[fr:cpp/keyword/delete]]
[[it:cpp/keyword/delete]]
[[ja:cpp/keyword/delete]]
[[pt:cpp/keyword/delete]]
[[ru:cpp/keyword/delete]]
[[zh:cpp/keyword/delete]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/do</title>
    <ns>0</ns>
    <id>647</id>
    <revision>
      <id>44505</id>
      <parentid>33959</parentid>
      <timestamp>2012-11-03T06:51:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="314">{{cpp/keyword/title|do}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/do | {{tt|do-while}} loop]]: as the declaration of the loop

[[de:cpp/keyword/do]]
[[es:cpp/keyword/do]]
[[fr:cpp/keyword/do]]
[[it:cpp/keyword/do]]
[[ja:cpp/keyword/do]]
[[pt:cpp/keyword/do]]
[[ru:cpp/keyword/do]]
[[zh:cpp/keyword/do]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/double</title>
    <ns>0</ns>
    <id>648</id>
    <revision>
      <id>44502</id>
      <parentid>33960</parentid>
      <timestamp>2012-11-03T06:50:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="351">{{cpp/keyword/title|double}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|double}} type]]: as the declaration of the type

[[de:cpp/keyword/double]]
[[es:cpp/keyword/double]]
[[fr:cpp/keyword/double]]
[[it:cpp/keyword/double]]
[[ja:cpp/keyword/double]]
[[pt:cpp/keyword/double]]
[[ru:cpp/keyword/double]]
[[zh:cpp/keyword/double]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/dynamic cast</title>
    <ns>0</ns>
    <id>649</id>
    <revision>
      <id>44500</id>
      <parentid>33961</parentid>
      <timestamp>2012-11-03T06:49:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, ru, zh</comment>
      <text xml:space="preserve" bytes="446">{{cpp/keyword/title|dynamic_cast}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/dynamic_cast | {{tt|dynamic_cast}} type conversion expression]]: as the declaration of the expression

[[de:cpp/keyword/dynamic cast]]
[[es:cpp/keyword/dynamic cast]]
[[fr:cpp/keyword/dynamic cast]]
[[it:cpp/keyword/dynamic cast]]
[[ja:cpp/keyword/dynamic cast]]
[[pt:cpp/keyword/dynamic cast]]
[[ru:cpp/keyword/dynamic cast]]
[[zh:cpp/keyword/dynamic cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/else</title>
    <ns>0</ns>
    <id>650</id>
    <revision>
      <id>44498</id>
      <parentid>33962</parentid>
      <timestamp>2012-11-03T06:48:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/else]], [[ru:cpp/keyword/else]], [[zh:cpp/keyword/else]]</comment>
      <text xml:space="preserve" bytes="345">{{cpp/keyword/title|else}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/if | {{tt|if}} statement]]: as the declaration of the alternative branch

[[de:cpp/keyword/else]]
[[es:cpp/keyword/else]]
[[fr:cpp/keyword/else]]
[[it:cpp/keyword/else]]
[[ja:cpp/keyword/else]]
[[pt:cpp/keyword/else]]
[[ru:cpp/keyword/else]]
[[zh:cpp/keyword/else]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/enum</title>
    <ns>0</ns>
    <id>3527</id>
    <revision>
      <id>44496</id>
      <parentid>33963</parentid>
      <timestamp>2012-11-03T06:47:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/enum]], [[pt:cpp/keyword/enum]], [[zh:cpp/keyword/enum]]</comment>
      <text xml:space="preserve" bytes="341">{{cpp/keyword/title|enum}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/enum | declaration of an enumeration type]]

[[ar:cpp/keyword/enum]]
[[de:cpp/keyword/enum]]
[[es:cpp/keyword/enum]]
[[fr:cpp/keyword/enum]]
[[it:cpp/keyword/enum]]
[[ja:cpp/keyword/enum]]
[[pt:cpp/keyword/enum]]
[[ru:cpp/keyword/enum]]
[[zh:cpp/keyword/enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/explicit</title>
    <ns>0</ns>
    <id>5063</id>
    <revision>
      <id>44493</id>
      <parentid>33964</parentid>
      <timestamp>2012-11-03T06:46:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[pt:cpp/keyword/explicit]], [[ru:cpp/keyword/explicit]]</comment>
      <text xml:space="preserve" bytes="366">{{cpp/keyword/title|explicit}}
{{cpp/keyword/navbar}}
===Usage===
*[[cpp/language/explicit | explicit specifier]]

[[de:cpp/keyword/explicit]]
[[es:cpp/keyword/explicit]]
[[fr:cpp/keyword/explicit]]
[[it:cpp/keyword/explicit]]
[[ja:cpp/keyword/explicit]]
[[pl:cpp/keyword/explicit]]
[[pt:cpp/keyword/explicit]]
[[ru:cpp/keyword/explicit]]
[[zh:cpp/keyword/explicit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/export</title>
    <ns>0</ns>
    <id>5076</id>
    <revision>
      <id>66787</id>
      <parentid>66785</parentid>
      <timestamp>2013-12-29T23:05:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+c++11</comment>
      <text xml:space="preserve" bytes="551">{{cpp/keyword/title|export}}
{{cpp/keyword/navbar}}
===Usage===
{{rev begin}}
{{rev|until=c++11|
Used to mark a [[cpp/language/class template|template definition]] ''exported'', which  allows the same template to be declared, but not defined, in other translation units.}}
{{rev|since=c++11|
The keyword is unused and reserved.
}}
{{rev end}}

[[de:cpp/keyword/export]]
[[es:cpp/keyword/export]]
[[fr:cpp/keyword/export]]
[[it:cpp/keyword/export]]
[[ja:cpp/keyword/export]]
[[pt:cpp/keyword/export]]
[[ru:cpp/keyword/export]]
[[zh:cpp/keyword/export]]</text>
      <sha1>2geu8akea95z6o1cxhz3api67fs7hoe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/extern</title>
    <ns>0</ns>
    <id>651</id>
    <revision>
      <id>46895</id>
      <parentid>44490</parentid>
      <timestamp>2013-04-16T19:26:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+language linkage (as in extern &quot;C&quot; { ....), plus already-existing extern templates</comment>
      <text xml:space="preserve" bytes="565">{{cpp/keyword/title|extern}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/storage_duration | static storage duration with ''external'' linkage specifier]]
* [[cpp/language/language_linkage|language linkage]] specification
* [[cpp/language/class_template|explicit template instantiation declaration]] (or &quot;extern template&quot;)

[[ar:cpp/keyword/extern]]
[[de:cpp/keyword/extern]]
[[es:cpp/keyword/extern]]
[[fr:cpp/keyword/extern]]
[[it:cpp/keyword/extern]]
[[ja:cpp/keyword/extern]]
[[pt:cpp/keyword/extern]]
[[ru:cpp/keyword/extern]]
[[zh:cpp/keyword/extern]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/false</title>
    <ns>0</ns>
    <id>652</id>
    <revision>
      <id>44487</id>
      <parentid>33967</parentid>
      <timestamp>2012-11-03T06:44:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru</comment>
      <text xml:space="preserve" bytes="345">{{cpp/keyword/title|false}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|false}} boolean literal]]

[[de:cpp/keyword/false]]
[[es:cpp/keyword/false]]
[[fr:cpp/keyword/false]]
[[it:cpp/keyword/false]]
[[ja:cpp/keyword/false]]
[[pl:cpp/keyword/false]]
[[pt:cpp/keyword/false]]
[[ru:cpp/keyword/false]]
[[zh:cpp/keyword/false]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/final</title>
    <ns>0</ns>
    <id>5070</id>
    <revision>
      <id>44484</id>
      <parentid>33968</parentid>
      <timestamp>2012-11-03T06:42:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="326">{{cpp/keyword/title|final {{mark since c++11}}}}
{{cpp/keyword/navbar}}
===Usage===
*[[cpp/language/final | final specifier]]

[[de:cpp/keyword/final]]
[[es:cpp/keyword/final]]
[[fr:cpp/keyword/final]]
[[it:cpp/keyword/final]]
[[ja:cpp/keyword/final]]
[[pt:cpp/keyword/final]]
[[ru:cpp/keyword/final]]
[[zh:cpp/keyword/final]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/float</title>
    <ns>0</ns>
    <id>653</id>
    <revision>
      <id>44482</id>
      <parentid>33969</parentid>
      <timestamp>2012-11-03T06:42:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="341">{{cpp/keyword/title|float}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|float}} type]]: as the declaration of the type

[[de:cpp/keyword/float]]
[[es:cpp/keyword/float]]
[[fr:cpp/keyword/float]]
[[it:cpp/keyword/float]]
[[ja:cpp/keyword/float]]
[[pt:cpp/keyword/float]]
[[ru:cpp/keyword/float]]
[[zh:cpp/keyword/float]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/for</title>
    <ns>0</ns>
    <id>654</id>
    <revision>
      <id>44480</id>
      <parentid>33970</parentid>
      <timestamp>2012-11-03T06:41:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="431">{{cpp/keyword/title|for}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/for | {{tt|for}} loop]]: as the declaration of the loop
* [[cpp/language/range-for | range-based {{tt|for}} loop]]: as the declaration of the loop {{mark since c++11}}

[[de:cpp/keyword/for]]
[[es:cpp/keyword/for]]
[[fr:cpp/keyword/for]]
[[it:cpp/keyword/for]]
[[ja:cpp/keyword/for]]
[[pt:cpp/keyword/for]]
[[ru:cpp/keyword/for]]
[[zh:cpp/keyword/for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/friend</title>
    <ns>0</ns>
    <id>3082</id>
    <revision>
      <id>44478</id>
      <parentid>33972</parentid>
      <timestamp>2012-11-03T06:40:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="325">{{cpp/keyword/title|friend}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/friend | {{tt|friend}} specifier]]

[[de:cpp/keyword/friend]]
[[es:cpp/keyword/friend]]
[[fr:cpp/keyword/friend]]
[[it:cpp/keyword/friend]]
[[ja:cpp/keyword/friend]]
[[pt:cpp/keyword/friend]]
[[ru:cpp/keyword/friend]]
[[zh:cpp/keyword/friend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/goto</title>
    <ns>0</ns>
    <id>655</id>
    <revision>
      <id>44475</id>
      <parentid>33973</parentid>
      <timestamp>2012-11-03T06:39:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="340">{{cpp/keyword/title|goto}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/goto | {{tt|goto}} statement]]: as the declaration of the statement

[[de:cpp/keyword/goto]]
[[es:cpp/keyword/goto]]
[[fr:cpp/keyword/goto]]
[[it:cpp/keyword/goto]]
[[ja:cpp/keyword/goto]]
[[pt:cpp/keyword/goto]]
[[ru:cpp/keyword/goto]]
[[zh:cpp/keyword/goto]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/if</title>
    <ns>0</ns>
    <id>656</id>
    <revision>
      <id>44472</id>
      <parentid>33974</parentid>
      <timestamp>2012-11-03T06:39:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/if]], [[fr:cpp/keyword/if]], [[zh:cpp/keyword/if]]</comment>
      <text xml:space="preserve" bytes="328">{{cpp/keyword/title|if}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/if | {{tt|if}} statement]]: as the declaration of the {{tt|if}} statement

[[de:cpp/keyword/if]]
[[es:cpp/keyword/if]]
[[fr:cpp/keyword/if]]
[[it:cpp/keyword/if]]
[[ja:cpp/keyword/if]]
[[pt:cpp/keyword/if]]
[[ru:cpp/keyword/if]]
[[zh:cpp/keyword/if]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/inline</title>
    <ns>0</ns>
    <id>3083</id>
    <revision>
      <id>44929</id>
      <parentid>44928</parentid>
      <timestamp>2012-12-04T14:40:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>self-reword</comment>
      <text xml:space="preserve" bytes="426">{{cpp/keyword/title|inline}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/inline | {{tt|inline}} specifier]] for functions
* [[cpp/language/namespace | {{tt|inline namespace}}]] definition {{mark since c++11}}

[[de:cpp/keyword/inline]]
[[es:cpp/keyword/inline]]
[[fr:cpp/keyword/inline]]
[[it:cpp/keyword/inline]]
[[ja:cpp/keyword/inline]]
[[pt:cpp/keyword/inline]]
[[ru:cpp/keyword/inline]]
[[zh:cpp/keyword/inline]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/int</title>
    <ns>0</ns>
    <id>657</id>
    <revision>
      <id>44466</id>
      <parentid>33976</parentid>
      <timestamp>2012-11-03T06:37:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="344">{{cpp/keyword/title|int}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|int}} type]]: as the declaration of the type

[[de:cpp/keyword/int]]
[[es:cpp/keyword/int]]
[[fr:cpp/keyword/int]]
[[it:cpp/keyword/int]]
[[ja:cpp/keyword/int]]
[[pl:cpp/keyword/int]]
[[pt:cpp/keyword/int]]
[[ru:cpp/keyword/int]]
[[zh:cpp/keyword/int]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/long</title>
    <ns>0</ns>
    <id>658</id>
    <revision>
      <id>44463</id>
      <parentid>33977</parentid>
      <timestamp>2012-11-03T06:36:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="308">{{cpp/keyword/title|long}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|long}} type modifier]]

[[de:cpp/keyword/long]]
[[es:cpp/keyword/long]]
[[fr:cpp/keyword/long]]
[[it:cpp/keyword/long]]
[[ja:cpp/keyword/long]]
[[pt:cpp/keyword/long]]
[[ru:cpp/keyword/long]]
[[zh:cpp/keyword/long]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/mutable</title>
    <ns>0</ns>
    <id>659</id>
    <revision>
      <id>66625</id>
      <parentid>44461</parentid>
      <timestamp>2013-12-16T14:12:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+c++11 meaning</comment>
      <text xml:space="preserve" bytes="481">{{cpp/keyword/title|mutable}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/cv | {{tt|mutable}} type specifier]]
* [[cpp/language/lambda | ''lambda-declarator'' ]] that removes {{tt|const}} qualification from parameters captured by copy {{mark since c++11}}

[[de:cpp/keyword/mutable]]
[[es:cpp/keyword/mutable]]
[[fr:cpp/keyword/mutable]]
[[it:cpp/keyword/mutable]]
[[ja:cpp/keyword/mutable]]
[[pt:cpp/keyword/mutable]]
[[ru:cpp/keyword/mutable]]
[[zh:cpp/keyword/mutable]]</text>
      <sha1>ftxax60179izl3idpuarz31jd3sjps2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/namespace</title>
    <ns>0</ns>
    <id>3525</id>
    <revision>
      <id>68817</id>
      <parentid>44458</parentid>
      <timestamp>2014-03-22T02:10:14Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <text xml:space="preserve" bytes="484">{{cpp/keyword/title|namespace}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/namespace | namespace declaration]]
* [[cpp/language/namespace_alias | namespace alias definition]]
* [[cpp/language/namespace#Using-directives | using-directives ]]

[[de:cpp/keyword/namespace]]
[[es:cpp/keyword/namespace]]
[[fr:cpp/keyword/namespace]]
[[it:cpp/keyword/namespace]]
[[ja:cpp/keyword/namespace]]
[[pt:cpp/keyword/namespace]]
[[ru:cpp/keyword/namespace]]
[[zh:cpp/keyword/namespace]]</text>
      <sha1>ad8thit99rou2hr5hi1k1tcgi6l345q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/new</title>
    <ns>0</ns>
    <id>660</id>
    <revision>
      <id>44455</id>
      <parentid>33981</parentid>
      <timestamp>2012-11-03T06:33:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="389">{{cpp/keyword/title|new}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/new | {{tt|new}} expression]]
* [[cpp/memory/new/operator_new | allocation functions]] as the name of operator-like functions

[[de:cpp/keyword/new]]
[[es:cpp/keyword/new]]
[[fr:cpp/keyword/new]]
[[it:cpp/keyword/new]]
[[ja:cpp/keyword/new]]
[[pt:cpp/keyword/new]]
[[ru:cpp/keyword/new]]
[[zh:cpp/keyword/new]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/noexcept</title>
    <ns>0</ns>
    <id>661</id>
    <revision>
      <id>44452</id>
      <parentid>33982</parentid>
      <timestamp>2012-11-03T06:33:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="428">{{cpp/keyword/title|noexcept {{mark since c++11}}}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/noexcept | {{tt|noexcept}} operator]]
* [[cpp/language/noexcept_spec | {{tt|noexcept}} specifier]]

[[de:cpp/keyword/noexcept]]
[[es:cpp/keyword/noexcept]]
[[fr:cpp/keyword/noexcept]]
[[it:cpp/keyword/noexcept]]
[[ja:cpp/keyword/noexcept]]
[[pt:cpp/keyword/noexcept]]
[[ru:cpp/keyword/noexcept]]
[[zh:cpp/keyword/noexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/not</title>
    <ns>0</ns>
    <id>662</id>
    <revision>
      <id>44449</id>
      <parentid>33984</parentid>
      <timestamp>2012-11-03T06:32:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="342">{{cpp/keyword/title|not}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|!}}

[[de:cpp/keyword/not]]
[[es:cpp/keyword/not]]
[[fr:cpp/keyword/not]]
[[it:cpp/keyword/not]]
[[ja:cpp/keyword/not]]
[[pt:cpp/keyword/not]]
[[ru:cpp/keyword/not]]
[[zh:cpp/keyword/not]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/not eq</title>
    <ns>0</ns>
    <id>663</id>
    <revision>
      <id>44446</id>
      <parentid>33985</parentid>
      <timestamp>2012-11-03T06:31:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="374">{{cpp/keyword/title|not_eq}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|!{{=}}}}

[[de:cpp/keyword/not eq]]
[[es:cpp/keyword/not eq]]
[[fr:cpp/keyword/not eq]]
[[it:cpp/keyword/not eq]]
[[ja:cpp/keyword/not eq]]
[[pt:cpp/keyword/not eq]]
[[ru:cpp/keyword/not eq]]
[[zh:cpp/keyword/not eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/nullptr</title>
    <ns>0</ns>
    <id>3519</id>
    <revision>
      <id>44443</id>
      <parentid>33987</parentid>
      <timestamp>2012-11-03T06:30:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="385">{{cpp/keyword/title|nullptr {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/nullptr | {{tt|nullptr}} pointer literal]] {{mark since c++11}}

[[de:cpp/keyword/nullptr]]
[[es:cpp/keyword/nullptr]]
[[fr:cpp/keyword/nullptr]]
[[it:cpp/keyword/nullptr]]
[[ja:cpp/keyword/nullptr]]
[[pt:cpp/keyword/nullptr]]
[[ru:cpp/keyword/nullptr]]
[[zh:cpp/keyword/nullptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/operator</title>
    <ns>0</ns>
    <id>4064</id>
    <revision>
      <id>44440</id>
      <parentid>33988</parentid>
      <timestamp>2012-11-03T06:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="360">{{cpp/keyword/title|operator}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/operators | declaration of an overloaded operator]]

[[de:cpp/keyword/operator]]
[[es:cpp/keyword/operator]]
[[fr:cpp/keyword/operator]]
[[it:cpp/keyword/operator]]
[[ja:cpp/keyword/operator]]
[[pt:cpp/keyword/operator]]
[[ru:cpp/keyword/operator]]
[[zh:cpp/keyword/operator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/or</title>
    <ns>0</ns>
    <id>664</id>
    <revision>
      <id>44437</id>
      <parentid>33989</parentid>
      <timestamp>2012-11-03T06:29:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="338">{{cpp/keyword/title|or}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|{{!!}}}}

[[de:cpp/keyword/or]]
[[es:cpp/keyword/or]]
[[fr:cpp/keyword/or]]
[[it:cpp/keyword/or]]
[[ja:cpp/keyword/or]]
[[pt:cpp/keyword/or]]
[[ru:cpp/keyword/or]]
[[zh:cpp/keyword/or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/or eq</title>
    <ns>0</ns>
    <id>665</id>
    <revision>
      <id>44435</id>
      <parentid>33990</parentid>
      <timestamp>2012-11-03T06:28:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="365">{{cpp/keyword/title|or_eq}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|{{!=}}}}

[[de:cpp/keyword/or eq]]
[[es:cpp/keyword/or eq]]
[[fr:cpp/keyword/or eq]]
[[it:cpp/keyword/or eq]]
[[ja:cpp/keyword/or eq]]
[[pt:cpp/keyword/or eq]]
[[ru:cpp/keyword/or eq]]
[[zh:cpp/keyword/or eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/override</title>
    <ns>0</ns>
    <id>5072</id>
    <revision>
      <id>44432</id>
      <parentid>33991</parentid>
      <timestamp>2012-11-03T06:28:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="359">{{cpp/keyword/title|override {{mark since c++11}}}}
{{cpp/keyword/navbar}}
===Usage===
*[[cpp/language/override | override specifier]]

[[de:cpp/keyword/override]]
[[es:cpp/keyword/override]]
[[fr:cpp/keyword/override]]
[[it:cpp/keyword/override]]
[[ja:cpp/keyword/override]]
[[pt:cpp/keyword/override]]
[[ru:cpp/keyword/override]]
[[zh:cpp/keyword/override]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/private</title>
    <ns>0</ns>
    <id>3522</id>
    <revision>
      <id>44429</id>
      <parentid>33992</parentid>
      <timestamp>2012-11-03T06:27:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="343">{{cpp/keyword/title|private}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/access | {{tt|private}} access specifier]]

[[de:cpp/keyword/private]]
[[es:cpp/keyword/private]]
[[fr:cpp/keyword/private]]
[[it:cpp/keyword/private]]
[[ja:cpp/keyword/private]]
[[pt:cpp/keyword/private]]
[[ru:cpp/keyword/private]]
[[zh:cpp/keyword/private]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/protected</title>
    <ns>0</ns>
    <id>3523</id>
    <revision>
      <id>44426</id>
      <parentid>33993</parentid>
      <timestamp>2012-11-03T06:26:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="363">{{cpp/keyword/title|protected}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/access | {{tt|protected}} access specifier]]

[[de:cpp/keyword/protected]]
[[es:cpp/keyword/protected]]
[[fr:cpp/keyword/protected]]
[[it:cpp/keyword/protected]]
[[ja:cpp/keyword/protected]]
[[pt:cpp/keyword/protected]]
[[ru:cpp/keyword/protected]]
[[zh:cpp/keyword/protected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/public</title>
    <ns>0</ns>
    <id>3524</id>
    <revision>
      <id>44423</id>
      <parentid>33994</parentid>
      <timestamp>2012-11-03T06:25:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="333">{{cpp/keyword/title|public}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/access | {{tt|public}} access specifier]]

[[de:cpp/keyword/public]]
[[es:cpp/keyword/public]]
[[fr:cpp/keyword/public]]
[[it:cpp/keyword/public]]
[[ja:cpp/keyword/public]]
[[pt:cpp/keyword/public]]
[[ru:cpp/keyword/public]]
[[zh:cpp/keyword/public]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/register</title>
    <ns>0</ns>
    <id>666</id>
    <revision>
      <id>44420</id>
      <parentid>33995</parentid>
      <timestamp>2012-11-03T06:25:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="366">{{cpp/keyword/title|register}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/storage_duration | automatic storage duration specifier]]

[[de:cpp/keyword/register]]
[[es:cpp/keyword/register]]
[[fr:cpp/keyword/register]]
[[it:cpp/keyword/register]]
[[ja:cpp/keyword/register]]
[[pt:cpp/keyword/register]]
[[ru:cpp/keyword/register]]
[[zh:cpp/keyword/register]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/reinterpret cast</title>
    <ns>0</ns>
    <id>667</id>
    <revision>
      <id>44417</id>
      <parentid>33997</parentid>
      <timestamp>2012-11-03T06:24:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[fr:cpp/keyword/reinterpret cast]], [[pt:cpp/keyword/reinterpret cast]], [[zh:cpp/keyword/reinterpret cast]]</comment>
      <text xml:space="preserve" bytes="490">{{cpp/keyword/title|reinterpret_cast}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/reinterpret_cast | {{tt|reinterpret_cast}} type conversion expression]]: as the declaration of the expression

[[de:cpp/keyword/reinterpret cast]]
[[es:cpp/keyword/reinterpret cast]]
[[fr:cpp/keyword/reinterpret cast]]
[[it:cpp/keyword/reinterpret cast]]
[[ja:cpp/keyword/reinterpret cast]]
[[pt:cpp/keyword/reinterpret cast]]
[[ru:cpp/keyword/reinterpret cast]]
[[zh:cpp/keyword/reinterpret cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/return</title>
    <ns>0</ns>
    <id>668</id>
    <revision>
      <id>44416</id>
      <parentid>33999</parentid>
      <timestamp>2012-11-03T06:24:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="414">{{cpp/keyword/title|return}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/return | {{tt|return}} statement]]: as the declaration of the statement

[[ar:cpp/keyword/return]]
[[de:cpp/keyword/return]]
[[es:cpp/keyword/return]]
[[fr:cpp/keyword/return]]
[[it:cpp/keyword/return]]
[[ja:cpp/keyword/return]]
[[pl:cpp/keyword/return]]
[[pt:cpp/keyword/return]]
[[ru:cpp/keyword/return]]
[[zh:cpp/keyword/return]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/short</title>
    <ns>0</ns>
    <id>669</id>
    <revision>
      <id>44412</id>
      <parentid>34000</parentid>
      <timestamp>2012-11-03T06:22:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="318">{{cpp/keyword/title|short}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|short}} type modifier]]

[[de:cpp/keyword/short]]
[[es:cpp/keyword/short]]
[[fr:cpp/keyword/short]]
[[it:cpp/keyword/short]]
[[ja:cpp/keyword/short]]
[[pt:cpp/keyword/short]]
[[ru:cpp/keyword/short]]
[[zh:cpp/keyword/short]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/signed</title>
    <ns>0</ns>
    <id>670</id>
    <revision>
      <id>44409</id>
      <parentid>34001</parentid>
      <timestamp>2012-11-03T06:21:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="328">{{cpp/keyword/title|signed}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|signed}} type modifier]]

[[de:cpp/keyword/signed]]
[[es:cpp/keyword/signed]]
[[fr:cpp/keyword/signed]]
[[it:cpp/keyword/signed]]
[[ja:cpp/keyword/signed]]
[[pt:cpp/keyword/signed]]
[[ru:cpp/keyword/signed]]
[[zh:cpp/keyword/signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/sizeof</title>
    <ns>0</ns>
    <id>671</id>
    <revision>
      <id>44406</id>
      <parentid>34002</parentid>
      <timestamp>2012-11-03T06:20:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="403">{{cpp/keyword/title|sizeof}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/sizeof | {{tt|sizeof}} operator]]

* [[cpp/language/sizeof... | {{tt|sizeof...}} operator]] {{mark since c++11}}

[[de:cpp/keyword/sizeof]]
[[es:cpp/keyword/sizeof]]
[[fr:cpp/keyword/sizeof]]
[[it:cpp/keyword/sizeof]]
[[ja:cpp/keyword/sizeof]]
[[pt:cpp/keyword/sizeof]]
[[ru:cpp/keyword/sizeof]]
[[zh:cpp/keyword/sizeof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/static</title>
    <ns>0</ns>
    <id>672</id>
    <revision>
      <id>44403</id>
      <parentid>34004</parentid>
      <timestamp>2012-11-03T06:20:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="459">{{cpp/keyword/title|static}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/storage_duration | static storage duration with ''internal'' linkage specifier]]
* [[cpp/language/static|declarations of class members not bound to specific instances]]

[[de:cpp/keyword/static]]
[[es:cpp/keyword/static]]
[[fr:cpp/keyword/static]]
[[it:cpp/keyword/static]]
[[ja:cpp/keyword/static]]
[[pt:cpp/keyword/static]]
[[ru:cpp/keyword/static]]
[[zh:cpp/keyword/static]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/static assert</title>
    <ns>0</ns>
    <id>3521</id>
    <revision>
      <id>44400</id>
      <parentid>34005</parentid>
      <timestamp>2012-11-03T06:19:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="447">{{cpp/keyword/title|static_assert {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/static_assert | {{tt|static_assert}} declaration]] {{mark since c++11}}

[[de:cpp/keyword/static assert]]
[[es:cpp/keyword/static assert]]
[[fr:cpp/keyword/static assert]]
[[it:cpp/keyword/static assert]]
[[ja:cpp/keyword/static assert]]
[[pt:cpp/keyword/static assert]]
[[ru:cpp/keyword/static assert]]
[[zh:cpp/keyword/static assert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/static cast</title>
    <ns>0</ns>
    <id>673</id>
    <revision>
      <id>44397</id>
      <parentid>34006</parentid>
      <timestamp>2012-11-03T06:18:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="435">{{cpp/keyword/title|static_cast}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/static_cast | {{tt|static_cast}} type conversion expression]]: as the declaration of the expression

[[de:cpp/keyword/static cast]]
[[es:cpp/keyword/static cast]]
[[fr:cpp/keyword/static cast]]
[[it:cpp/keyword/static cast]]
[[ja:cpp/keyword/static cast]]
[[pt:cpp/keyword/static cast]]
[[ru:cpp/keyword/static cast]]
[[zh:cpp/keyword/static cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/struct</title>
    <ns>0</ns>
    <id>3528</id>
    <revision>
      <id>44394</id>
      <parentid>34007</parentid>
      <timestamp>2012-11-03T06:18:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="332">{{cpp/keyword/title|struct}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/class | declaration of a compound type]]

[[de:cpp/keyword/struct]]
[[es:cpp/keyword/struct]]
[[fr:cpp/keyword/struct]]
[[it:cpp/keyword/struct]]
[[ja:cpp/keyword/struct]]
[[pt:cpp/keyword/struct]]
[[ru:cpp/keyword/struct]]
[[zh:cpp/keyword/struct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/switch</title>
    <ns>0</ns>
    <id>674</id>
    <revision>
      <id>44390</id>
      <parentid>34009</parentid>
      <timestamp>2012-11-03T06:17:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="362">{{cpp/keyword/title|switch}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/switch | {{tt|switch}} statement]]: as the declaration of the statement

[[de:cpp/keyword/switch]]
[[es:cpp/keyword/switch]]
[[fr:cpp/keyword/switch]]
[[it:cpp/keyword/switch]]
[[ja:cpp/keyword/switch]]
[[pt:cpp/keyword/switch]]
[[ru:cpp/keyword/switch]]
[[zh:cpp/keyword/switch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/template</title>
    <ns>0</ns>
    <id>3530</id>
    <revision>
      <id>44756</id>
      <parentid>44387</parentid>
      <timestamp>2012-11-22T17:54:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>dependent name disambiguators deserve a page with examples</comment>
      <text xml:space="preserve" bytes="573">{{cpp/keyword/title|template}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/class_template | Declaration of a class template]]
* [[cpp/language/function_template | Declaration of a function template]]
* Inside a template definition, {{c|template}} can be used to declare that a [[cpp/language/dependent_name|dependent name]] is a template.

[[de:cpp/keyword/template]]
[[es:cpp/keyword/template]]
[[fr:cpp/keyword/template]]
[[it:cpp/keyword/template]]
[[ja:cpp/keyword/template]]
[[pt:cpp/keyword/template]]
[[ru:cpp/keyword/template]]
[[zh:cpp/keyword/template]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/this</title>
    <ns>0</ns>
    <id>3532</id>
    <revision>
      <id>44384</id>
      <parentid>34013</parentid>
      <timestamp>2012-11-03T06:15:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="302">{{cpp/keyword/title|this}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/this | {{tt|this}} pointer]]

[[de:cpp/keyword/this]]
[[es:cpp/keyword/this]]
[[fr:cpp/keyword/this]]
[[it:cpp/keyword/this]]
[[ja:cpp/keyword/this]]
[[pt:cpp/keyword/this]]
[[ru:cpp/keyword/this]]
[[zh:cpp/keyword/this]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/thread local</title>
    <ns>0</ns>
    <id>675</id>
    <revision>
      <id>44381</id>
      <parentid>34015</parentid>
      <timestamp>2012-11-03T06:14:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="447">{{cpp/keyword/title|thread_local {{mark since c++11}}}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/storage_duration | thread local storage duration specifier]] {{mark since c++11}}

[[de:cpp/keyword/thread local]]
[[es:cpp/keyword/thread local]]
[[fr:cpp/keyword/thread local]]
[[it:cpp/keyword/thread local]]
[[ja:cpp/keyword/thread local]]
[[pt:cpp/keyword/thread local]]
[[ru:cpp/keyword/thread local]]
[[zh:cpp/keyword/thread local]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/throw</title>
    <ns>0</ns>
    <id>676</id>
    <revision>
      <id>44378</id>
      <parentid>34017</parentid>
      <timestamp>2012-11-03T06:13:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, zh</comment>
      <text xml:space="preserve" bytes="373">{{cpp/keyword/title|throw}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/throw | {{tt|throw}} expression]]
* [[cpp/language/except_spec | exception specifications]]

[[de:cpp/keyword/throw]]
[[es:cpp/keyword/throw]]
[[fr:cpp/keyword/throw]]
[[it:cpp/keyword/throw]]
[[ja:cpp/keyword/throw]]
[[pt:cpp/keyword/throw]]
[[ru:cpp/keyword/throw]]
[[zh:cpp/keyword/throw]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/true</title>
    <ns>0</ns>
    <id>677</id>
    <revision>
      <id>44376</id>
      <parentid>34018</parentid>
      <timestamp>2012-11-03T06:12:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[de:cpp/keyword/true]], [[pt:cpp/keyword/true]], [[ru:cpp/keyword/true]]</comment>
      <text xml:space="preserve" bytes="334">{{cpp/keyword/title|true}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|true}} boolean literal]]

[[de:cpp/keyword/true]]
[[es:cpp/keyword/true]]
[[fr:cpp/keyword/true]]
[[it:cpp/keyword/true]]
[[ja:cpp/keyword/true]]
[[pl:cpp/keyword/true]]
[[pt:cpp/keyword/true]]
[[ru:cpp/keyword/true]]
[[zh:cpp/keyword/true]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/try</title>
    <ns>0</ns>
    <id>678</id>
    <revision>
      <id>44373</id>
      <parentid>34020</parentid>
      <timestamp>2012-11-03T06:12:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="300">{{cpp/keyword/title|try}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/try catch | {{tt|try-catch}} block]]

[[de:cpp/keyword/try]]
[[es:cpp/keyword/try]]
[[fr:cpp/keyword/try]]
[[it:cpp/keyword/try]]
[[ja:cpp/keyword/try]]
[[pt:cpp/keyword/try]]
[[ru:cpp/keyword/try]]
[[zh:cpp/keyword/try]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/typedef</title>
    <ns>0</ns>
    <id>2852</id>
    <revision>
      <id>44370</id>
      <parentid>34021</parentid>
      <timestamp>2012-11-03T06:11:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, zh</comment>
      <text xml:space="preserve" bytes="338">{{cpp/keyword/title|typedef}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/typedef | {{tt|typedef}} declaration]]

[[de:cpp/keyword/typedef]]
[[es:cpp/keyword/typedef]]
[[fr:cpp/keyword/typedef]]
[[it:cpp/keyword/typedef]]
[[ja:cpp/keyword/typedef]]
[[pt:cpp/keyword/typedef]]
[[ru:cpp/keyword/typedef]]
[[zh:cpp/keyword/typedef]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/typeid</title>
    <ns>0</ns>
    <id>679</id>
    <revision>
      <id>44367</id>
      <parentid>34022</parentid>
      <timestamp>2012-11-03T06:10:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="324">{{cpp/keyword/title|typeid}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/typeid | {{tt|typeid}} operator]]

[[de:cpp/keyword/typeid]]
[[es:cpp/keyword/typeid]]
[[fr:cpp/keyword/typeid]]
[[it:cpp/keyword/typeid]]
[[ja:cpp/keyword/typeid]]
[[pt:cpp/keyword/typeid]]
[[ru:cpp/keyword/typeid]]
[[zh:cpp/keyword/typeid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/typename</title>
    <ns>0</ns>
    <id>5064</id>
    <revision>
      <id>67952</id>
      <parentid>67940</parentid>
      <timestamp>2014-03-08T12:38:51Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="683">{{cpp/keyword/title|typename}}
{{cpp/keyword/navbar}}

===Usage===

* In a [[cpp/language/templates | template declaration]], {{c|typename}} can be used as an alternative to [[cpp/keyword/class | class]] to declare [[cpp/language/template_parameters#Type template parameter|type template parameters]].
* Inside a declaration or a definition of a template, {{c|typename}} can be used to declare that a [[cpp/language/dependent_name|dependent name]] is a type.

[[de:cpp/keyword/typename]]
[[es:cpp/keyword/typename]]
[[fr:cpp/keyword/typename]]
[[it:cpp/keyword/typename]]
[[ja:cpp/keyword/typename]]
[[pt:cpp/keyword/typename]]
[[ru:cpp/keyword/typename]]
[[zh:cpp/keyword/typename]]</text>
      <sha1>pra6rbd4l1ndfnw8m6qniscwl6294t7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/union</title>
    <ns>0</ns>
    <id>3533</id>
    <revision>
      <id>44362</id>
      <parentid>34025</parentid>
      <timestamp>2012-11-03T06:09:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="320">{{cpp/keyword/title|union}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/union | declaration of a union type]]

[[de:cpp/keyword/union]]
[[es:cpp/keyword/union]]
[[fr:cpp/keyword/union]]
[[it:cpp/keyword/union]]
[[ja:cpp/keyword/union]]
[[pt:cpp/keyword/union]]
[[ru:cpp/keyword/union]]
[[zh:cpp/keyword/union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/unsigned</title>
    <ns>0</ns>
    <id>680</id>
    <revision>
      <id>44359</id>
      <parentid>34026</parentid>
      <timestamp>2012-11-03T06:08:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="348">{{cpp/keyword/title|unsigned}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|unsigned}} type modifier]]

[[de:cpp/keyword/unsigned]]
[[es:cpp/keyword/unsigned]]
[[fr:cpp/keyword/unsigned]]
[[it:cpp/keyword/unsigned]]
[[ja:cpp/keyword/unsigned]]
[[pt:cpp/keyword/unsigned]]
[[ru:cpp/keyword/unsigned]]
[[zh:cpp/keyword/unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/using</title>
    <ns>0</ns>
    <id>3529</id>
    <revision>
      <id>66676</id>
      <parentid>46643</parentid>
      <timestamp>2013-12-23T20:47:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>more pedantic about aliases</comment>
      <text xml:space="preserve" bytes="575">{{cpp/keyword/title|using}}
{{cpp/keyword/navbar}}

===Usage===

* [[cpp/language/namespace | using-directives ]] for namespaces and [[cpp/language/namespace | using-declarations]] for namespace members
* [[cpp/language/using_declaration | using-declarations ]] for class members
* [[cpp/language/type_alias | type alias and alias template declaration]] {{mark since c++11}}

[[de:cpp/keyword/using]]
[[es:cpp/keyword/using]]
[[fr:cpp/keyword/using]]
[[it:cpp/keyword/using]]
[[ja:cpp/keyword/using]]
[[pt:cpp/keyword/using]]
[[ru:cpp/keyword/using]]
[[zh:cpp/keyword/using]]</text>
      <sha1>3xdvds9955ce7lwyr8541fu17siylle</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/virtual</title>
    <ns>0</ns>
    <id>4063</id>
    <revision>
      <id>48511</id>
      <parentid>44353</parentid>
      <timestamp>2013-05-30T17:33:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+inheritance</comment>
      <text xml:space="preserve" bytes="402">{{cpp/keyword/title|virtual}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/virtual | virtual function specifier]]
* [[cpp/language/derived_class | virtual base class specifier]]

[[de:cpp/keyword/virtual]]
[[es:cpp/keyword/virtual]]
[[fr:cpp/keyword/virtual]]
[[it:cpp/keyword/virtual]]
[[ja:cpp/keyword/virtual]]
[[pt:cpp/keyword/virtual]]
[[ru:cpp/keyword/virtual]]
[[zh:cpp/keyword/virtual]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/void</title>
    <ns>0</ns>
    <id>3087</id>
    <revision>
      <id>67170</id>
      <parentid>44351</parentid>
      <timestamp>2014-01-25T10:55:36Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ void*</comment>
      <text xml:space="preserve" bytes="387">{{cpp/keyword/title|void}}
{{cpp/keyword/navbar}}

===Usage===
* [[cpp/language/function | {{tt|void}} specifier]]
* used to declare [[cpp/language/pointer#Pointers to void | {{tt|void*}} type]]

[[de:cpp/keyword/void]]
[[es:cpp/keyword/void]]
[[fr:cpp/keyword/void]]
[[it:cpp/keyword/void]]
[[ja:cpp/keyword/void]]
[[pt:cpp/keyword/void]]
[[ru:cpp/keyword/void]]
[[zh:cpp/keyword/void]]</text>
      <sha1>m2cduy2lkifgmiern2mhj16gulg0zjn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/volatile</title>
    <ns>0</ns>
    <id>681</id>
    <revision>
      <id>44348</id>
      <parentid>34030</parentid>
      <timestamp>2012-11-03T06:01:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="346">{{cpp/keyword/title|volatile}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/cv | {{tt|volatile}} type specifier]]

[[de:cpp/keyword/volatile]]
[[es:cpp/keyword/volatile]]
[[fr:cpp/keyword/volatile]]
[[it:cpp/keyword/volatile]]
[[ja:cpp/keyword/volatile]]
[[pt:cpp/keyword/volatile]]
[[ru:cpp/keyword/volatile]]
[[zh:cpp/keyword/volatile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/wchar t</title>
    <ns>0</ns>
    <id>682</id>
    <revision>
      <id>44345</id>
      <parentid>34031</parentid>
      <timestamp>2012-11-03T06:00:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="361">{{cpp/keyword/title|wchar_t}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/types | {{tt|wchar_t}} type]]: as the declaration of the type

[[de:cpp/keyword/wchar t]]
[[es:cpp/keyword/wchar t]]
[[fr:cpp/keyword/wchar t]]
[[it:cpp/keyword/wchar t]]
[[ja:cpp/keyword/wchar t]]
[[pt:cpp/keyword/wchar t]]
[[ru:cpp/keyword/wchar t]]
[[zh:cpp/keyword/wchar t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/while</title>
    <ns>0</ns>
    <id>683</id>
    <revision>
      <id>44342</id>
      <parentid>34032</parentid>
      <timestamp>2012-11-03T05:59:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="497">{{cpp/keyword/title|while}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/while | {{tt|while}} loop]]: as the declaration of the loop
* [[cpp/language/do | {{tt|do-while}} loop]]: as the declaration of the terminating condition of the loop

[[de:cpp/keyword/while]]
[[es:cpp/keyword/while]]
[[fr:cpp/keyword/while]]
[[it:cpp/keyword/while]]
[[ja:cpp/keyword/while]]
[[pl:cpp/keyword/while]]
[[pt:cpp/keyword/while]]
[[ru:cpp/keyword/while]]
[[tr:cpp/keyword/while]]
[[zh:cpp/keyword/while]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/xor</title>
    <ns>0</ns>
    <id>684</id>
    <revision>
      <id>44339</id>
      <parentid>34033</parentid>
      <timestamp>2012-11-03T05:58:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="342">{{cpp/keyword/title|xor}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|^}}

[[de:cpp/keyword/xor]]
[[es:cpp/keyword/xor]]
[[fr:cpp/keyword/xor]]
[[it:cpp/keyword/xor]]
[[ja:cpp/keyword/xor]]
[[pt:cpp/keyword/xor]]
[[ru:cpp/keyword/xor]]
[[zh:cpp/keyword/xor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keyword/xor eq</title>
    <ns>0</ns>
    <id>685</id>
    <revision>
      <id>44336</id>
      <parentid>34034</parentid>
      <timestamp>2012-11-03T05:58:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru</comment>
      <text xml:space="preserve" bytes="371">{{cpp/keyword/title|xor}}
{{cpp/keyword/navbar}}
===Usage===

* [[cpp/language/operator alternative | alternative operators]]: as an alternative for {{tt|^{{=}}}}

[[de:cpp/keyword/xor eq]]
[[es:cpp/keyword/xor eq]]
[[fr:cpp/keyword/xor eq]]
[[it:cpp/keyword/xor eq]]
[[ja:cpp/keyword/xor eq]]
[[pt:cpp/keyword/xor eq]]
[[ru:cpp/keyword/xor eq]]
[[zh:cpp/keyword/xor eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords</title>
    <ns>0</ns>
    <id>5328</id>
    <redirect title="cpp/keyword" />
    <revision>
      <id>19419</id>
      <timestamp>2012-03-11T12:10:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords]] to [[cpp/keyword]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="25">#REDIRECT [[cpp/keyword]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/alignas</title>
    <ns>0</ns>
    <id>5329</id>
    <redirect title="cpp/keyword/alignas" />
    <revision>
      <id>19421</id>
      <timestamp>2012-03-11T12:10:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/alignas]] to [[cpp/keyword/alignas]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/alignas]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/alignof</title>
    <ns>0</ns>
    <id>5330</id>
    <redirect title="cpp/keyword/alignof" />
    <revision>
      <id>19423</id>
      <timestamp>2012-03-11T12:11:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/alignof]] to [[cpp/keyword/alignof]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/alignof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/and</title>
    <ns>0</ns>
    <id>5331</id>
    <redirect title="cpp/keyword/and" />
    <revision>
      <id>19425</id>
      <timestamp>2012-03-11T12:11:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/and]] to [[cpp/keyword/and]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/and]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/and eq</title>
    <ns>0</ns>
    <id>5332</id>
    <redirect title="cpp/keyword/and eq" />
    <revision>
      <id>19427</id>
      <timestamp>2012-03-11T12:11:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/and eq]] to [[cpp/keyword/and eq]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/and eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/asm</title>
    <ns>0</ns>
    <id>5333</id>
    <redirect title="cpp/keyword/asm" />
    <revision>
      <id>19429</id>
      <timestamp>2012-03-11T12:11:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/asm]] to [[cpp/keyword/asm]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/asm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/auto</title>
    <ns>0</ns>
    <id>5334</id>
    <redirect title="cpp/keyword/auto" />
    <revision>
      <id>19431</id>
      <timestamp>2012-03-11T12:11:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/auto]] to [[cpp/keyword/auto]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/auto]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/bitand</title>
    <ns>0</ns>
    <id>5335</id>
    <redirect title="cpp/keyword/bitand" />
    <revision>
      <id>19433</id>
      <timestamp>2012-03-11T12:11:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/bitand]] to [[cpp/keyword/bitand]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/bitand]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/bitor</title>
    <ns>0</ns>
    <id>5336</id>
    <redirect title="cpp/keyword/bitor" />
    <revision>
      <id>19435</id>
      <timestamp>2012-03-11T12:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/bitor]] to [[cpp/keyword/bitor]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/bitor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/bool</title>
    <ns>0</ns>
    <id>5337</id>
    <redirect title="cpp/keyword/bool" />
    <revision>
      <id>19437</id>
      <timestamp>2012-03-11T12:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/bool]] to [[cpp/keyword/bool]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/break</title>
    <ns>0</ns>
    <id>5338</id>
    <redirect title="cpp/keyword/break" />
    <revision>
      <id>19439</id>
      <timestamp>2012-03-11T12:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/break]] to [[cpp/keyword/break]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/break]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/case</title>
    <ns>0</ns>
    <id>5339</id>
    <redirect title="cpp/keyword/case" />
    <revision>
      <id>19441</id>
      <timestamp>2012-03-11T12:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/case]] to [[cpp/keyword/case]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/case]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/catch</title>
    <ns>0</ns>
    <id>5340</id>
    <redirect title="cpp/keyword/catch" />
    <revision>
      <id>19443</id>
      <timestamp>2012-03-11T12:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/catch]] to [[cpp/keyword/catch]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/catch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/char</title>
    <ns>0</ns>
    <id>5341</id>
    <redirect title="cpp/keyword/char" />
    <revision>
      <id>19445</id>
      <timestamp>2012-03-11T12:11:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/char]] to [[cpp/keyword/char]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/char]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/char16 t</title>
    <ns>0</ns>
    <id>5342</id>
    <redirect title="cpp/keyword/char16 t" />
    <revision>
      <id>19447</id>
      <timestamp>2012-03-11T12:11:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/char16 t]] to [[cpp/keyword/char16 t]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/char16 t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/char32 t</title>
    <ns>0</ns>
    <id>5343</id>
    <redirect title="cpp/keyword/char32 t" />
    <revision>
      <id>19449</id>
      <timestamp>2012-03-11T12:11:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/char32 t]] to [[cpp/keyword/char32 t]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/char32 t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/class</title>
    <ns>0</ns>
    <id>5344</id>
    <redirect title="cpp/keyword/class" />
    <revision>
      <id>19451</id>
      <timestamp>2012-03-11T12:11:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/class]] to [[cpp/keyword/class]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/class]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/compl</title>
    <ns>0</ns>
    <id>5345</id>
    <redirect title="cpp/keyword/compl" />
    <revision>
      <id>19453</id>
      <timestamp>2012-03-11T12:11:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/compl]] to [[cpp/keyword/compl]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/compl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/const</title>
    <ns>0</ns>
    <id>5346</id>
    <redirect title="cpp/keyword/const" />
    <revision>
      <id>19455</id>
      <timestamp>2012-03-11T12:11:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/const]] to [[cpp/keyword/const]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/const cast</title>
    <ns>0</ns>
    <id>5347</id>
    <redirect title="cpp/keyword/const cast" />
    <revision>
      <id>19457</id>
      <timestamp>2012-03-11T12:11:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/const cast]] to [[cpp/keyword/const cast]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/keyword/const cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/constexpr</title>
    <ns>0</ns>
    <id>5348</id>
    <redirect title="cpp/keyword/constexpr" />
    <revision>
      <id>19459</id>
      <timestamp>2012-03-11T12:11:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/constexpr]] to [[cpp/keyword/constexpr]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/keyword/constexpr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/continue</title>
    <ns>0</ns>
    <id>5349</id>
    <redirect title="cpp/keyword/continue" />
    <revision>
      <id>19461</id>
      <timestamp>2012-03-11T12:11:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/continue]] to [[cpp/keyword/continue]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/continue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/decltype</title>
    <ns>0</ns>
    <id>5350</id>
    <redirect title="cpp/keyword/decltype" />
    <revision>
      <id>19463</id>
      <timestamp>2012-03-11T12:11:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/decltype]] to [[cpp/keyword/decltype]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/decltype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/default</title>
    <ns>0</ns>
    <id>5351</id>
    <redirect title="cpp/keyword/default" />
    <revision>
      <id>19465</id>
      <timestamp>2012-03-11T12:11:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/default]] to [[cpp/keyword/default]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/default]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/delete</title>
    <ns>0</ns>
    <id>5352</id>
    <redirect title="cpp/keyword/delete" />
    <revision>
      <id>19467</id>
      <timestamp>2012-03-11T12:11:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/delete]] to [[cpp/keyword/delete]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/delete]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/do</title>
    <ns>0</ns>
    <id>5353</id>
    <redirect title="cpp/keyword/do" />
    <revision>
      <id>19469</id>
      <timestamp>2012-03-11T12:11:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/do]] to [[cpp/keyword/do]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/keyword/do]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/double</title>
    <ns>0</ns>
    <id>5354</id>
    <redirect title="cpp/keyword/double" />
    <revision>
      <id>19471</id>
      <timestamp>2012-03-11T12:11:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/double]] to [[cpp/keyword/double]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/double]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/dynamic cast</title>
    <ns>0</ns>
    <id>5355</id>
    <redirect title="cpp/keyword/dynamic cast" />
    <revision>
      <id>19473</id>
      <timestamp>2012-03-11T12:11:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/dynamic cast]] to [[cpp/keyword/dynamic cast]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/keyword/dynamic cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/else</title>
    <ns>0</ns>
    <id>5356</id>
    <redirect title="cpp/keyword/else" />
    <revision>
      <id>19475</id>
      <timestamp>2012-03-11T12:11:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/else]] to [[cpp/keyword/else]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/else]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/enum</title>
    <ns>0</ns>
    <id>5357</id>
    <redirect title="cpp/keyword/enum" />
    <revision>
      <id>19477</id>
      <timestamp>2012-03-11T12:11:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/enum]] to [[cpp/keyword/enum]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/explicit</title>
    <ns>0</ns>
    <id>5358</id>
    <redirect title="cpp/keyword/explicit" />
    <revision>
      <id>19479</id>
      <timestamp>2012-03-11T12:11:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/explicit]] to [[cpp/keyword/explicit]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/explicit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/export</title>
    <ns>0</ns>
    <id>5359</id>
    <redirect title="cpp/keyword/export" />
    <revision>
      <id>19481</id>
      <timestamp>2012-03-11T12:11:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/export]] to [[cpp/keyword/export]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/export]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/extern</title>
    <ns>0</ns>
    <id>5360</id>
    <redirect title="cpp/keyword/extern" />
    <revision>
      <id>19483</id>
      <timestamp>2012-03-11T12:11:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/extern]] to [[cpp/keyword/extern]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/extern]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/false</title>
    <ns>0</ns>
    <id>5361</id>
    <redirect title="cpp/keyword/false" />
    <revision>
      <id>19485</id>
      <timestamp>2012-03-11T12:11:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/false]] to [[cpp/keyword/false]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/false]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/final</title>
    <ns>0</ns>
    <id>5362</id>
    <redirect title="cpp/keyword/final" />
    <revision>
      <id>19487</id>
      <timestamp>2012-03-11T12:11:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/final]] to [[cpp/keyword/final]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/final]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/float</title>
    <ns>0</ns>
    <id>5363</id>
    <redirect title="cpp/keyword/float" />
    <revision>
      <id>19489</id>
      <timestamp>2012-03-11T12:11:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/float]] to [[cpp/keyword/float]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/float]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/for</title>
    <ns>0</ns>
    <id>5364</id>
    <redirect title="cpp/keyword/for" />
    <revision>
      <id>19491</id>
      <timestamp>2012-03-11T12:11:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/for]] to [[cpp/keyword/for]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/friend</title>
    <ns>0</ns>
    <id>5365</id>
    <redirect title="cpp/keyword/friend" />
    <revision>
      <id>19493</id>
      <timestamp>2012-03-11T12:11:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/friend]] to [[cpp/keyword/friend]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/friend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/goto</title>
    <ns>0</ns>
    <id>5366</id>
    <redirect title="cpp/keyword/goto" />
    <revision>
      <id>19495</id>
      <timestamp>2012-03-11T12:11:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/goto]] to [[cpp/keyword/goto]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/goto]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/if</title>
    <ns>0</ns>
    <id>5367</id>
    <redirect title="cpp/keyword/if" />
    <revision>
      <id>19497</id>
      <timestamp>2012-03-11T12:11:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/if]] to [[cpp/keyword/if]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/keyword/if]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/inline</title>
    <ns>0</ns>
    <id>5368</id>
    <redirect title="cpp/keyword/inline" />
    <revision>
      <id>19499</id>
      <timestamp>2012-03-11T12:11:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/inline]] to [[cpp/keyword/inline]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/inline]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/int</title>
    <ns>0</ns>
    <id>5369</id>
    <redirect title="cpp/keyword/int" />
    <revision>
      <id>19501</id>
      <timestamp>2012-03-11T12:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/int]] to [[cpp/keyword/int]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/int]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/long</title>
    <ns>0</ns>
    <id>5370</id>
    <redirect title="cpp/keyword/long" />
    <revision>
      <id>19503</id>
      <timestamp>2012-03-11T12:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/long]] to [[cpp/keyword/long]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/long]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/mutable</title>
    <ns>0</ns>
    <id>5371</id>
    <redirect title="cpp/keyword/mutable" />
    <revision>
      <id>19505</id>
      <timestamp>2012-03-11T12:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/mutable]] to [[cpp/keyword/mutable]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/mutable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/namespace</title>
    <ns>0</ns>
    <id>5372</id>
    <redirect title="cpp/keyword/namespace" />
    <revision>
      <id>19507</id>
      <timestamp>2012-03-11T12:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/namespace]] to [[cpp/keyword/namespace]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/keyword/namespace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/new</title>
    <ns>0</ns>
    <id>5373</id>
    <redirect title="cpp/keyword/new" />
    <revision>
      <id>19509</id>
      <timestamp>2012-03-11T12:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/new]] to [[cpp/keyword/new]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/new]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/noexcept</title>
    <ns>0</ns>
    <id>5374</id>
    <redirect title="cpp/keyword/noexcept" />
    <revision>
      <id>19511</id>
      <timestamp>2012-03-11T12:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/noexcept]] to [[cpp/keyword/noexcept]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/noexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/not</title>
    <ns>0</ns>
    <id>5375</id>
    <redirect title="cpp/keyword/not" />
    <revision>
      <id>19513</id>
      <timestamp>2012-03-11T12:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/not]] to [[cpp/keyword/not]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/not]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/not eq</title>
    <ns>0</ns>
    <id>5376</id>
    <redirect title="cpp/keyword/not eq" />
    <revision>
      <id>19515</id>
      <timestamp>2012-03-11T12:11:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/not eq]] to [[cpp/keyword/not eq]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/not eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/nullptr</title>
    <ns>0</ns>
    <id>5377</id>
    <redirect title="cpp/keyword/nullptr" />
    <revision>
      <id>19517</id>
      <timestamp>2012-03-11T12:11:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/nullptr]] to [[cpp/keyword/nullptr]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/nullptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/operator</title>
    <ns>0</ns>
    <id>5378</id>
    <redirect title="cpp/keyword/operator" />
    <revision>
      <id>19519</id>
      <timestamp>2012-03-11T12:11:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/operator]] to [[cpp/keyword/operator]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/operator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/or</title>
    <ns>0</ns>
    <id>5379</id>
    <redirect title="cpp/keyword/or" />
    <revision>
      <id>19521</id>
      <timestamp>2012-03-11T12:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/or]] to [[cpp/keyword/or]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[cpp/keyword/or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/or eq</title>
    <ns>0</ns>
    <id>5380</id>
    <redirect title="cpp/keyword/or eq" />
    <revision>
      <id>19523</id>
      <timestamp>2012-03-11T12:11:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/or eq]] to [[cpp/keyword/or eq]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/or eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/override</title>
    <ns>0</ns>
    <id>5381</id>
    <redirect title="cpp/keyword/override" />
    <revision>
      <id>19525</id>
      <timestamp>2012-03-11T12:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/override]] to [[cpp/keyword/override]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/override]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/private</title>
    <ns>0</ns>
    <id>5382</id>
    <redirect title="cpp/keyword/private" />
    <revision>
      <id>19527</id>
      <timestamp>2012-03-11T12:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/private]] to [[cpp/keyword/private]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/private]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/protected</title>
    <ns>0</ns>
    <id>5383</id>
    <redirect title="cpp/keyword/protected" />
    <revision>
      <id>19529</id>
      <timestamp>2012-03-11T12:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/protected]] to [[cpp/keyword/protected]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/keyword/protected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/public</title>
    <ns>0</ns>
    <id>5384</id>
    <redirect title="cpp/keyword/public" />
    <revision>
      <id>19531</id>
      <timestamp>2012-03-11T12:11:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/public]] to [[cpp/keyword/public]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/public]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/register</title>
    <ns>0</ns>
    <id>5385</id>
    <redirect title="cpp/keyword/register" />
    <revision>
      <id>19533</id>
      <timestamp>2012-03-11T12:11:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/register]] to [[cpp/keyword/register]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/register]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/reinterpret cast</title>
    <ns>0</ns>
    <id>5386</id>
    <redirect title="cpp/keyword/reinterpret cast" />
    <revision>
      <id>19535</id>
      <timestamp>2012-03-11T12:11:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/reinterpret cast]] to [[cpp/keyword/reinterpret cast]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/keyword/reinterpret cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/return</title>
    <ns>0</ns>
    <id>5387</id>
    <redirect title="cpp/keyword/return" />
    <revision>
      <id>19537</id>
      <timestamp>2012-03-11T12:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/return]] to [[cpp/keyword/return]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/return]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/short</title>
    <ns>0</ns>
    <id>5388</id>
    <redirect title="cpp/keyword/short" />
    <revision>
      <id>19539</id>
      <timestamp>2012-03-11T12:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/short]] to [[cpp/keyword/short]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/short]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/signed</title>
    <ns>0</ns>
    <id>5389</id>
    <redirect title="cpp/keyword/signed" />
    <revision>
      <id>19541</id>
      <timestamp>2012-03-11T12:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/signed]] to [[cpp/keyword/signed]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/sizeof</title>
    <ns>0</ns>
    <id>5390</id>
    <redirect title="cpp/keyword/sizeof" />
    <revision>
      <id>19543</id>
      <timestamp>2012-03-11T12:11:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/sizeof]] to [[cpp/keyword/sizeof]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/sizeof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/static</title>
    <ns>0</ns>
    <id>5391</id>
    <redirect title="cpp/keyword/static" />
    <revision>
      <id>19545</id>
      <timestamp>2012-03-11T12:11:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/static]] to [[cpp/keyword/static]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/static]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/static assert</title>
    <ns>0</ns>
    <id>5392</id>
    <redirect title="cpp/keyword/static assert" />
    <revision>
      <id>19547</id>
      <timestamp>2012-03-11T12:11:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/static assert]] to [[cpp/keyword/static assert]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/keyword/static assert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/static cast</title>
    <ns>0</ns>
    <id>5393</id>
    <redirect title="cpp/keyword/static cast" />
    <revision>
      <id>19549</id>
      <timestamp>2012-03-11T12:11:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/static cast]] to [[cpp/keyword/static cast]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/keyword/static cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/struct</title>
    <ns>0</ns>
    <id>5394</id>
    <redirect title="cpp/keyword/struct" />
    <revision>
      <id>19551</id>
      <timestamp>2012-03-11T12:11:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/struct]] to [[cpp/keyword/struct]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/struct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/switch</title>
    <ns>0</ns>
    <id>5395</id>
    <redirect title="cpp/keyword/switch" />
    <revision>
      <id>19553</id>
      <timestamp>2012-03-11T12:11:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/switch]] to [[cpp/keyword/switch]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/switch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/template</title>
    <ns>0</ns>
    <id>5396</id>
    <redirect title="cpp/keyword/template" />
    <revision>
      <id>19555</id>
      <timestamp>2012-03-11T12:11:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/template]] to [[cpp/keyword/template]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/template]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/this</title>
    <ns>0</ns>
    <id>5397</id>
    <redirect title="cpp/keyword/this" />
    <revision>
      <id>19557</id>
      <timestamp>2012-03-11T12:11:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/this]] to [[cpp/keyword/this]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/this]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/thread local</title>
    <ns>0</ns>
    <id>5398</id>
    <redirect title="cpp/keyword/thread local" />
    <revision>
      <id>19559</id>
      <timestamp>2012-03-11T12:11:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/thread local]] to [[cpp/keyword/thread local]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/keyword/thread local]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/throw</title>
    <ns>0</ns>
    <id>5399</id>
    <redirect title="cpp/keyword/throw" />
    <revision>
      <id>19561</id>
      <timestamp>2012-03-11T12:11:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/throw]] to [[cpp/keyword/throw]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/throw]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/true</title>
    <ns>0</ns>
    <id>5400</id>
    <redirect title="cpp/keyword/true" />
    <revision>
      <id>19563</id>
      <timestamp>2012-03-11T12:11:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/true]] to [[cpp/keyword/true]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/true]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/try</title>
    <ns>0</ns>
    <id>5401</id>
    <redirect title="cpp/keyword/try" />
    <revision>
      <id>19565</id>
      <timestamp>2012-03-11T12:11:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/try]] to [[cpp/keyword/try]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/try]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/typedef</title>
    <ns>0</ns>
    <id>5402</id>
    <redirect title="cpp/keyword/typedef" />
    <revision>
      <id>19567</id>
      <timestamp>2012-03-11T12:11:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/typedef]] to [[cpp/keyword/typedef]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/typedef]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/typeid</title>
    <ns>0</ns>
    <id>5403</id>
    <redirect title="cpp/keyword/typeid" />
    <revision>
      <id>19569</id>
      <timestamp>2012-03-11T12:11:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/typeid]] to [[cpp/keyword/typeid]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/typeid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/typename</title>
    <ns>0</ns>
    <id>5404</id>
    <redirect title="cpp/keyword/typename" />
    <revision>
      <id>19571</id>
      <timestamp>2012-03-11T12:11:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/typename]] to [[cpp/keyword/typename]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/typename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/union</title>
    <ns>0</ns>
    <id>5405</id>
    <redirect title="cpp/keyword/union" />
    <revision>
      <id>19573</id>
      <timestamp>2012-03-11T12:11:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/union]] to [[cpp/keyword/union]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/unsigned</title>
    <ns>0</ns>
    <id>5406</id>
    <redirect title="cpp/keyword/unsigned" />
    <revision>
      <id>19575</id>
      <timestamp>2012-03-11T12:11:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/unsigned]] to [[cpp/keyword/unsigned]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/using</title>
    <ns>0</ns>
    <id>5407</id>
    <redirect title="cpp/keyword/using" />
    <revision>
      <id>19577</id>
      <timestamp>2012-03-11T12:11:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/using]] to [[cpp/keyword/using]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/using]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/virtual</title>
    <ns>0</ns>
    <id>5408</id>
    <redirect title="cpp/keyword/virtual" />
    <revision>
      <id>19579</id>
      <timestamp>2012-03-11T12:11:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/virtual]] to [[cpp/keyword/virtual]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/virtual]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/void</title>
    <ns>0</ns>
    <id>5409</id>
    <redirect title="cpp/keyword/void" />
    <revision>
      <id>19581</id>
      <timestamp>2012-03-11T12:11:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/void]] to [[cpp/keyword/void]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[cpp/keyword/void]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/volatile</title>
    <ns>0</ns>
    <id>5410</id>
    <redirect title="cpp/keyword/volatile" />
    <revision>
      <id>19583</id>
      <timestamp>2012-03-11T12:11:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/volatile]] to [[cpp/keyword/volatile]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/keyword/volatile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/wchar t</title>
    <ns>0</ns>
    <id>5411</id>
    <redirect title="cpp/keyword/wchar t" />
    <revision>
      <id>19585</id>
      <timestamp>2012-03-11T12:11:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/wchar t]] to [[cpp/keyword/wchar t]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/keyword/wchar t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/while</title>
    <ns>0</ns>
    <id>5412</id>
    <redirect title="cpp/keyword/while" />
    <revision>
      <id>19587</id>
      <timestamp>2012-03-11T12:11:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/while]] to [[cpp/keyword/while]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/keyword/while]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/xor</title>
    <ns>0</ns>
    <id>5413</id>
    <redirect title="cpp/keyword/xor" />
    <revision>
      <id>19589</id>
      <timestamp>2012-03-11T12:11:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/xor]] to [[cpp/keyword/xor]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/keyword/xor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/keywords/xor eq</title>
    <ns>0</ns>
    <id>5414</id>
    <redirect title="cpp/keyword/xor eq" />
    <revision>
      <id>19591</id>
      <timestamp>2012-03-11T12:11:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/keywords/xor eq]] to [[cpp/keyword/xor eq]]: Singular is used in most pages</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/keyword/xor eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language</title>
    <ns>0</ns>
    <id>686</id>
    <revision>
      <id>72162</id>
      <parentid>72003</parentid>
      <timestamp>2014-07-19T14:34:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no #warning in C++</comment>
      <text xml:space="preserve" bytes="7914">{{title|C++ language}}
{{cpp/language/navbar}}

This is a brief reference of available C++ language constructs.

{| cellpadding=&quot;5&quot;
|- valign=&quot;top&quot;
|

'''[[cpp/language/basic_concepts | Basic concepts]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/comment | Comments]]&lt;br&gt;
[[cpp/language/ascii | ASCII chart]]&lt;br&gt;
[[cpp/language/identifiers | Names and identifiers]]&lt;br&gt;
[[cpp/language/type | Types]] - 
[[cpp/language/types | Fundamental types]]&lt;br&gt;
[[cpp/language/object | Object]] -
[[cpp/language/scope | Scope]] -
[[cpp/language/lifetime | Lifetime]]&lt;br&gt;
[[cpp/language/definition | Definitions and ODR]]&lt;br&gt;
[[cpp/language/lookup | Name lookup ]]&lt;br&gt;
[[cpp/language/memory_model | Memory model and data races]]&lt;br&gt;
[[cpp/language/translation_phases | Phases of translation]]&lt;br&gt;
[[cpp/language/main_function | The main() function]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/keyword | C++ Keywords]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
&lt;!--  --&gt;
&lt;/div&gt;

'''[[cpp/preprocessor | Preprocessor]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/preprocessor/conditional | #if - #ifdef - #ifndef]]&lt;br&gt;
[[cpp/preprocessor/replace | #define]] -
[[cpp/preprocessor/include | #include]]&lt;br&gt;
[[cpp/preprocessor/error | #error]]&lt;br&gt;
[[cpp/preprocessor/impl | #pragma]] -
[[cpp/preprocessor/line | #line]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/expressions | Expressions]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/expressions#Operators | Operators]]&lt;br&gt;
[[cpp/language/expressions#Conversions | Conversions]]&lt;br&gt;
[[cpp/language/expressions#Literals | Literals]]&lt;br&gt;
[[cpp/language/operator_precedence | Operator precedence]]&lt;br&gt;
[[cpp/language/value_category | Value categories]]&lt;br&gt;
[[cpp/language/eval_order | Evaluation order and sequencing]]&lt;br&gt;
[[cpp/language/sizeof | {{tt|sizeof}}]] -
[[cpp/language/alignof | {{tt|alignof}}]]{{mark c++11}} -
[[cpp/language/typeid | {{tt|typeid}}]]&lt;br&gt;
[[cpp/language/new | {{tt|new}}]] -
[[cpp/language/delete | {{tt|delete}}]]&lt;br&gt;
[[cpp/language/constant_expression | Constant expressions]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/statements | Statements]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/if | {{tt|if}}]] -
[[cpp/language/switch | {{tt|switch}}]]&lt;br&gt;
[[cpp/language/for | {{tt|for}}]] -
[[cpp/language/range-for | range-{{tt|for}}]]{{mark c++11}}&lt;br&gt;
[[cpp/language/while | {{tt|while}}]] - [[cpp/language/do | {{tt|do}}-{{tt|while}}]]&lt;br&gt;
[[cpp/language/continue | {{tt|continue}}]] -
[[cpp/language/break | {{tt|break}}]] -
[[cpp/language/goto | {{tt|goto}}]] -
[[cpp/language/return | {{tt|return}}]]&lt;br&gt;
&lt;/div&gt;

|

'''[[cpp/language/declarations | Declaration]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/namespace | Namespace declaration]]&lt;br&gt;
[[cpp/language/namespace_alias | Namespace alias]]&lt;br&gt;
[[cpp/language/reference | Lvalue and rvalue references]]&lt;br&gt;
[[cpp/language/pointer | Pointers]] -
[[cpp/language/array | Arrays]]&lt;br&gt;
[[cpp/language/enum | Enumerations and enumerators]]&lt;br&gt;
[[cpp/language/storage_duration | Storage duration and linkage]]&lt;br&gt;
[[cpp/language/cv | const/volatile]] -
[[cpp/language/constexpr | {{tt|constexpr}}]]{{mark c++11}}&lt;br&gt;
[[cpp/language/decltype | {{tt|decltype}}]]{{mark c++11}} -
[[cpp/language/auto | {{tt|auto}}]]{{mark c++11}} &lt;br&gt;
[[cpp/language/alignas | {{tt|alignas}}]]{{mark c++11}} &lt;br&gt;
[[cpp/language/typedef | {{tt|typedef}}]] -
[[cpp/language/type_alias | Type alias]]{{mark c++11}}&lt;br&gt;
[[cpp/language/attributes | Attributes]]{{mark c++11}}&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/initialization | Initialization]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/default_initialization | Default initialization]]&lt;br&gt;
[[cpp/language/value_initialization | Value initialization]]&lt;br&gt;
[[cpp/language/copy_initialization | Copy initialization]]&lt;br&gt;
[[cpp/language/direct_initialization | Direct initialization]]&lt;br&gt;
[[cpp/language/aggregate_initialization | Aggregate initialization]]&lt;br&gt;
[[cpp/language/list_initialization | List initialization]]{{mark c++11}}&lt;br&gt;
[[cpp/language/reference_initialization | Reference initialization]]&lt;br&gt;
[[cpp/language/constant_initialization | Constant initialization]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/functions | Functions]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/function | Function declaration]]&lt;br&gt;
[[cpp/language/default_arguments | Default arguments]]&lt;br&gt;
[[cpp/language/variadic_arguments | Variadic arguments]]&lt;br&gt;
[[cpp/language/lambda | Lambda expression]]{{mark c++11}}&lt;br&gt;
[[cpp/language/inline | {{tt|inline}} specifier]]&lt;br&gt;
[[cpp/language/adl | Argument-dependent lookup]]&lt;br&gt;
[[cpp/language/overload_resolution | Overload resolution]]&lt;br&gt;
[[cpp/language/operators | Operator overloading]]&lt;br&gt;
[[cpp/language/overloaded_address | Address of an overload set]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/exceptions | Exceptions]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/throw | {{tt|throw-expression}}]]&lt;br&gt;
[[cpp/language/try_catch | {{tt|try}}-{{tt|catch}} block]]&lt;br&gt;
[[cpp/language/function-try-block | {{tt|function-try-block}}]]&lt;br&gt;
[[cpp/language/noexcept_spec | {{tt|noexcept}} specifier]]{{mark c++11}}&lt;br&gt;
[[cpp/language/noexcept | {{tt|noexcept}} operator]]{{mark c++11}}&lt;br&gt;
[[cpp/language/except_spec | Exception specification]]&lt;br&gt;
&lt;/div&gt;

|

'''[[cpp/language/classes | Classes]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/class | Class types]] -
[[cpp/language/union | Union types]]&lt;br&gt;
[[cpp/language/data_members | Data members]] -
[[cpp/language/member_functions | Member functions]]&lt;br&gt;
[[cpp/language/static | Static members]] -
[[cpp/language/nested_types | Nested classes]]&lt;br&gt;
[[cpp/language/derived_class | Derived class]] -
[[cpp/language/using_declaration | {{tt|using}}-declaration]]&lt;br&gt;
[[cpp/language/virtual | Virtual function]] -
[[cpp/language/abstract_class | Abstract class]]&lt;br&gt;
[[cpp/language/bit_field | Bit fields]]&lt;br&gt;
[[cpp/language/this | {{tt|this}}]]&lt;br&gt;
[[cpp/language/access | Access specifiers]] &lt;br&gt;
[[cpp/language/friend | {{tt|friend}} specifier]]&lt;br&gt;
[[cpp/language/default_constructor | Default constructor]] -
[[cpp/language/copy_constructor | Copy constructor]]&lt;br&gt;
[[cpp/language/as_operator | Copy assignment]] -
[[cpp/language/destructor | Destructor]]&lt;br&gt;
[[cpp/language/move_constructor | Move constructor]]{{mark c++11}} -
[[cpp/language/move_operator | Move assignment]]{{mark c++11}}&lt;br&gt;
[[cpp/language/initializer_list | Member initializer lists]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/templates | Templates]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/template_parameters | Template parameters and arguments]]&lt;br&gt;
[[cpp/language/class_template | Class template]]&lt;br&gt;
[[cpp/language/function_template | Function template]]&lt;br&gt;
[[cpp/language/member_template | Class member template]]&lt;br&gt;
[[cpp/language/variable_template | Variable template]]{{mark c++14}}&lt;br&gt;
[[cpp/language/template_argument_deduction | Template argument deduction]]&lt;br&gt;
[[cpp/language/template_specialization | Explicit specialization]]&lt;br&gt;
[[cpp/language/partial_specialization | Partial specialization]]&lt;br&gt;
[[cpp/language/dependent_name | Dependent names]]&lt;br&gt;
[[cpp/language/parameter_pack | Parameter packs]]{{mark c++11}} -
[[cpp/language/sizeof... | {{tt|sizeof...}}]]{{mark c++11}}&lt;br&gt;
[[cpp/language/sfinae | SFINAE]]&lt;br&gt;
&lt;/div&gt;

'''[[cpp/language/misc | Miscellaneous]]'''
&lt;div class=&quot;mainpagediv&quot;&gt;
[[cpp/language/history | History of C++]]&lt;br&gt;
[[cpp/language/asm | Inline assembly]]&lt;br&gt;
[[cpp/language/extending_std | Extending the namespace std]]&lt;br&gt;
[[cpp/language/raii | RAII]] -
[[cpp/language/rule_of_three | Rule of three/five/zero]]&lt;br&gt;
[[cpp/language/as_if | As-if rule]] -
[[cpp/language/copy_elision | Copy elision]]&lt;br&gt;
[[cpp/language/ebo | Empty base optimization]]&lt;br&gt;
&lt;/div&gt;

|}

===See also===
{{dsc begin}}
{{dsc see c | c/language |C language constructs}}
{{dsc end}}


[[ar:cpp/language]]
[[de:cpp/language]]
[[es:cpp/language]]
[[fr:cpp/language]]
[[it:cpp/language]]
[[ja:cpp/language]]
[[ko:cpp/language]]
[[pt:cpp/language]]
[[ru:cpp/language]]
[[tr:cpp/language]]
[[zh:cpp/language]]</text>
      <sha1>c2ugzyvso5iidx102vxqc3t3sttbfmq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/abstract class</title>
    <ns>0</ns>
    <id>12924</id>
    <revision>
      <id>67483</id>
      <parentid>67385</parentid>
      <timestamp>2014-02-09T21:23:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="3795">{{title|abstract class}}
{{cpp/language/classes/navbar}}

Defines an abstract type which cannot be instantiated, but can be used as a base class.

===Syntax===
{{spar|pure virtual}} function is a {{rlp|virtual|virtual function}} whose {{rlp|function|declarator}} has the following syntax:

{{sdsc begin}}
{{sdsc | {{spar|declarator}} {{spar|virt-specifier}}{{mark optional}} {{ttb|{{=}}}} {{ttb|0}} }}
{{sdsc end}}

Here the sequence {{ttb|{{=}} 0}} is known as {{spar|pure-specifier}}, and appears either immediately after the {{spar|declarator}} or after the optional {{spar|virt-specifier}} ({{rlp|override}} or {{rlp|final}}).

{{spar|pure-specifier}} cannot appear in a member function definition.

{{source|1=
struct Base { virtual int g(); virtual ~Base() {};};
struct A : Base{
    // ok, declares three member virtual functions, two of them pure
    virtual int f() = 0, g() override = 0, h();
    // ok, destructor can be pure too
    ~A() = 0;
    // error: pure-specifier on a function definition
    virtual int b()=0 {}
};
}}

An {{spar|abstract class}} is a class that either defines or inherits at least one function for which {{rlp|virtual|the final overrider}} is {{spar|pure virtual}}.

===Explanation===
Abstract classes are used to represent general concepts (for example, Shape), which can be used as base classes for concrete classes (for example, Circle).

No objects of an abstract class can be created. Abstract types cannot be used as parameter types, as function return types, or as the type of an explicit conversion. Pointers and references to an abstract class can be declared.

{{source|1=
struct Abstract {
    virtual void f() = 0; // pure virtual
}; // &quot;Abstract&quot; is abstract

struct Concrete : Abstract {
    void f() override {}; // non-pure virtual
    virtual void g();     // non-pure virtual
}; // &quot;Concrete&quot; is non-abstract

struct Abstract2 : Concrete {
    void g() override = 0; // pure virtual overrider
}; // &quot;Abstract2&quot; is abstract

int main()
{
    // Abstract a; // Error: abstract class
    Concrete b; // OK
    Abstract&amp; a = b; // OK to reference abstract base
    a.f(); // virtual dispatch to Concrete::f()
    // Abstract2 a2; // Error: abstract class (final overrider of g() is pure)
}
}}

The definition of a pure virtual function may be provided (and must be provided if the pure virtual is the {{rlp|destructor}}): the member functions of the derived class are free to call the abstract base's pure virtual function using qualified function id. This definition must be provided outside of the class body (the syntax of a function declaration doesn't allow both the pure specifier {{ttb|{{=}} 0}} and a function body)

Making a virtual call to a pure virtual function from a constructor or the destructor of the abstract class is undefined behavior (regardless of whether it has a definition or not)

{{source|1=struct Abstract {
    virtual void f() = 0; // pure virtual
    virtual void g() {}; // non-pure virtual
    ~Abstract() {
        g(); // okay, calls Abstract::g()
        // f(); // undefined behavior!
        Abstract::f(); // okay, non-virtual call
    }
};

//definition of the pure virtual function
void Abstract::f() { std::cout &lt;&lt; &quot;A::f()\n&quot;; }

struct Concrete : Abstract {
    void f() override {
        Abstract::f(); // OK: calls pure virtual function
    }
    void g() override {}
    ~Concrete() {
        g(); // okay, calls Concrete::g()
        f(); // okay, calls Concrete::f()
    }
};
}}

===See also===
* {{rlp|virtual}}

[[de:cpp/language/abstract_class]]
[[es:cpp/language/abstract_class]]
[[fr:cpp/language/abstract_class]]
[[it:cpp/language/abstract_class]]
[[ja:cpp/language/abstract_class]]
[[pt:cpp/language/abstract_class]]
[[ru:cpp/language/abstract_class]]
[[zh:cpp/language/abstract_class]]</text>
      <sha1>dhktcbmpkdwn9fquuoi3ljptkhvuvyd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/access</title>
    <ns>0</ns>
    <id>5293</id>
    <revision>
      <id>67469</id>
      <parentid>66599</parentid>
      <timestamp>2014-02-09T21:18:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="3830">{{title|access specifiers}}
{{cpp/language/classes/navbar}}
In a {{c|class}} or {{c|struct}} body define the visibility of following declarators
In a inheritance list, define the maximum visibility of inherited members
===Syntax===
{{sdsc begin}}
{{sdsc |num=1| {{c|public:}} {{spar|declarators}} }}
{{sdsc |num=2| {{c|protected:}} {{spar|declarators}} }}
{{sdsc |num=3| {{c|private:}} {{spar|declarators}} }}
{{sdsc |num=4| {{c|class}} {{spar|identifier}} {{tt|:}} {{c|public}} {{spar|class_name}} }}
{{sdsc |num=5| {{c|class}} {{spar|identifier}} {{tt|:}} {{c|protected}} {{spar|class_name}} }}
{{sdsc |num=6| {{c|class}} {{spar|identifier}} {{tt|:}} {{c|private}} {{spar|class_name}} }}
{{sdsc end}}

===Explanation===
# The symbols declared after the specifier have public accessibility
# The symbols declared after the specifier have protected accessibility
# The symbols declared after the specifier have private accessibility
# The inherited members have the same accessibility as the base class ( either protected or public as private won't be visible in the derived class )
# The inherited members have protected accessibility in the derived class
# The inherited members have private accessibility in the derived class

====Member accessibility by specifier====
;public
:public members are accessible everywhere, within and outside the class scope
;protected
:protected members are accessible within the class and its methods and in its descendants
;private
:private members can be only accessed within the class and its methods

To grant access to external functions or classes to protected or private members, a [[cpp/language/friend|friendship declaration]] must be present in the class body

Inherited private members are still present in the class data but cannot be accessed directly

A {{c|class}} has default private accessibility for inheritance and members, a {{c|struct}} has instead a default public accessibility

===Public member access===
{{todo}}

===Protected member access===
Protected members form the interface for the derived classes (which is distinct from the public interface of the class).

A protected member of a class {{tt|Base}} can only be accessed
@1@ by the member functions and friend functions of {{tt|Base}} 
@2@ by the member functions and friend functions of any class derived from {{tt|Base}}, but only when operating on an object of a type that is derived from {{tt|Base}} (including {{tt|this}})

{{source|
struct Base {
 protected:
    int i;
 private:
    void g(Base&amp; b, struct Derived&amp; d);
};

struct Derived : Base {
    void f(Base&amp; b, Derived&amp; d) // member function of a derived class
    {
        ++d.i; // okay: the type of d is Derived
        ++i; // okay: the type of the implied '*this' is Derived
//      ++b.i; // error: can't access a protected member through Base
    }
};
 
void Base::g(Base&amp; b, Derived&amp; d) // member function of Base
{
    ++i; // okay
    ++b.i; // okay
    ++d.i; // okay
}

void x(Base&amp; b, Derived&amp; d) // non-member non-friend
{
//    ++b.i; // error: no access from non-member
//    ++d.i; // error: no access from non-member
}
}}

When a pointer to a protected member is formed, it must use a derived class in its declaration:

{{source|1=
struct Base {
 protected:
    int i;
};

struct Derived : Base {
    void f()
    {
//      int Base::* ptr = &amp;Base::i;    // error: must name using Derived
        int Base::* ptr = &amp;Derived::i; // okay
    }
};
}}

===Private member access===
{{todo}}

===Public inheritance===
{{todo}}

===Protected inheritance===
{{todo}}

===Private inheritance===
{{todo}}

{{todo|example}}


[[de:cpp/language/access]]
[[es:cpp/language/access]]
[[fr:cpp/language/access]]
[[it:cpp/language/access]]
[[ja:cpp/language/access]]
[[pt:cpp/language/access]]
[[ru:cpp/language/access]]
[[zh:cpp/language/access]]</text>
      <sha1>10q9uuc2immxyo2t239c0qdztbmb9q5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/adl</title>
    <ns>0</ns>
    <id>9974</id>
    <revision>
      <id>69973</id>
      <parentid>69807</parentid>
      <timestamp>2014-05-04T13:46:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+interaction with function templates</comment>
      <text xml:space="preserve" bytes="9740">{{title|Argument-dependent lookup}}
{{cpp/language/functions/navbar}}

Argument-dependent lookup, also known as ADL, or Koenig lookup, is the set of rules for looking up the unqualified function names in {{rlp|operator_other|function-call expressions}}, including implicit function calls to {{rlp|operators|overloaded operators}}. These function names are looked up in the namespaces of their arguments in addition to the scopes and namespaces considered by the usual {{rlp|lookup|unqualified name lookup}}.

{{example|
Argument-dependent lookup makes it possible to use operators defined in a different namespace
|code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;Test\n&quot;; // There is no operator&lt;&lt; in global namespace, but ADL
                           // examines std namespace because the left argument is in
                           // std and finds std::operator&lt;&lt;(std::ostream&amp;, const char*)
    operator&lt;&lt;(std::cout, &quot;Test\n&quot;); // same, using function call notation

    // however,
    std::cout &lt;&lt; endl; // Error: 'endl' is not declared in this namespace.
                       // This is not a function call to endl(), so ADL does not apply

    endl(std::cout); // OK: this is a function call: ADL examines std namespace
                     // because the argument of endl is in std, and finds std::endl

    (endl)(std::cout); // Error: 'endl' is not declared in this namespace.
                       // The sub-expression (endl) is not a function call expression
}
}}

===Details===
First, if the lookup set produced by usual {{rlp|lookup|unqualified lookup}} contains any of the following:
@1@ a declaration of a class member
@2@ a declaration of a function at block scope (that's not a {{rlp|namespace#Using-declarations|using-declaration}})
@3@ any declaration that is not a function or a function template (e.g. a function object or another variable whose name conflicts with the name of the function that's being looked up)

Then the argument-dependent lookup is not considered.

Otherwise, for every argument in a function call expression and for every template template argument of a template function, its type is examined to determine the ''associated set of namespaces and classes'' that it will add to the lookup
@1@ For arguments of fundamental type, the associated set of namespaces and classes is empty
@2@ For arguments of class type (including union), the set consists of
:@a@ The class itself
:@b@ All of its direct and indirect base classes
:@c@ If the class is a {{rlp|nested_types|member of another class}}, the class of which it is a member
:@d@ The innermost enclosing namespaces in the classes added to the set
@3@ For arguments whose type is a class template specialization, in addition to the class rules, the following types are examined and their associated classes and namespaces are added to the set
:@a@ The types of all template arguments provided for type template parameters (skipping non-type template parameters and skipping template template parameters)
:@b@ The namespaces in which any template template arguments are members
:@c@ The classes in which any template template arguments are members (if they happen to be class member templates)
@4@ For arguments of enumeration type, the namespace in which the enumeration is defined is added to the set. If the enumeration type is a member of a class, that class is added to the set.
@5@ For arguments of type pointer to T or pointer to an array of T, the type T is examined and its associated set of classes and namespaces is added to the set.
@6@ For arguments of function type, the function parameter types and the function return type are examined and their associated set of classes and namespaces are added to the set.
@7@ For arguments of type pointer to member function F of class X, the function parameter types, the function return type, and the class X are examined and their associated set of classes and namespaces are added to the set.
@8@ For arguments of type pointer to data member T of class X, the member type and the type X are both examined and their associated set of classes and namespaces are added to the set.
@9@ If the argument is the name or the {{rlp|overloaded address|address-of expression for a set of overloaded functions}} (or function templates), every function in the overload set is examined and its associated set of classes and namespaces is added to the set.
:@a@ Additionally, if the set of overloads is named by a template-id (template name with template arguments), all of its type template arguments and template template arguments (but not non-type template arguments) are examined and their associated set of classes and namespaces are added to the set.

If any namespace in the associated set of classes and namespaces is an {{rlp|namespace|inline namespace}}, its enclosing namespace is also added to the set.

If any namespace in the associated set of classes and namespaces directly contains an inline namespace, that inline namespace is added to the set.

After the associated set of classes and namespaces is determined, the set of declarations found by ordinary {{rlp|lookup|unqualified lookup}} and the set of declarations found in the associated set of classes and namespaces produced by ADL are merged, with the following special rules
@1@ {{rlp|namespace#Using-directives|using-directives}} in the associated namespaces are ignored
@2@ namespace-scoped friend functions (and function templates) that are declared in an associated namespace are visible through ADL even if they are not visible through ordinary lookup
@3@ all names except for the functions and function templates are ignored (no collision with variables)

===Notes===
Because of argument-dependent lookup, non-member functions and non-member operators defined in the same namespace as a class are considered part of the public interface of that class (if they are found through ADL) &lt;ref&gt; H. Sutter (1998) [http://www.gotw.ca/publications/mill02.htm &quot;What's In a Class? - The Interface Principle&quot;] in C++ Report, 10(3)&lt;/ref&gt;.

ADL is the reason behind the established idiom for swapping two objects in generic code:{{source|using std::swap;
swap(obj1, obj2);
}}because calling {{c|std::swap(obj1, obj2)}} directly would not consider the user-defined swap() functions that could be defined in the same namespace as the types of obj1 or obj2, and just calling the unqualified {{c|swap(obj1, obj2)}} would call nothing if no user-defined overload was provided. In particular, {{lc|std::iter_swap}} and all other standard library algorithms use this approach when dealing with {{concept|Swappable}} types.

Name lookup rules make it impractical to declare operators in global or user-defined namespace that operate on types from the std namespace, e.g. a custom {{c|operator&gt;&gt;}} or {{c|operator+}} for {{lc|std::vector}} or for {{lc|std::pair}} (unless the element types of the vector/pair are user-defined types, which would add their namespace to ADL). Such operators would not be looked up from template instantiations, such as the standard library algorithms. See {{rlp|dependent_name|dependent names}} for further details.

ADL can find a {{rlp|friend|friend function}} (typically, an overloaded operator) that is defined entirely within a class or class template, even if it was never declared at namespace level.
{{source|1=
template&lt;typename T&gt;
struct number
{
    number(int);
    friend number gcd(number x, number y) { return 0; }; // definition within
                                                         // a class template
};
// unless a matching declaration is provided gcd is an invisible (except through ADL)
// member of this namespace
void g() {
    number&lt;double&gt; a(3), b(4);
    a = gcd(a,b); // finds gcd because number&lt;double&gt; is an associated class,
                  // making gcd visible in its namespace (global scope)
//  b = gcd(3,4); // Error; gcd is not visible
}
}}

Although a function call can be resolved through ADL even if ordinary lookup finds nothing, a function call to a {{rlp|function template}} with explicitly-specified template arguments requires that there is a declaration of the template found by ordinary lookup (otherwise, it is a syntax error to encounter an unknown name followed by a less-than character)
{{source|1=
namespace N1 {
  struct S {};
  template&lt;int X&gt; void f(S);
}
namespace N2 {
  template&lt;class T&gt; void f(T t);
}
void g(N1::S s) {
  f&lt;3&gt;(s);      // Syntax error (unqualified lookup finds no f)
  N1::f&lt;3&gt;(s);  // OK, qualified lookup finds the template 'f'
  N2::f&lt;3&gt;(s);  // Error: N2::f does not take a non-type parameter
                //        N1::f is not looked up because ADL only works
                //              with unqualified names
  using N2::f;
  f&lt;3&gt;(s); // OK: Unqualified lookup now finds N2::f
           //     then ADL kicks in because this name is unqualified
           //     and finds N1::f
}
}}

===Examples===
{{todo|more examples}}
{{example|Example from http://www.gotw.ca/gotw/030.htm
|code =
namespace A {
      struct X;
      struct Y;
      void f(int);
      void g(X);
}

namespace B {
    void f(int i) {
        f(i);   // calls B::f (endless recursion)
    }
    void g(A::X x) {
        g(x);   // Error: ambiguous between B::g (ordinary lookup)
                //        and A::g (argument-dependent lookup)
    }
    void h(A::Y y) {
        h(y);   // calls B::h (endless recursion): ADL examines the A namespace
                // but finds no A::h, so only B::h from ordinary lookup is used
    }
}
}}

===See also===
* {{rlp|lookup|Name lookup}} 
* {{rlp|function_template|Template argument deduction}}
* {{rlp|overload_resolution|Overload resolution}}

===References===
&lt;references/&gt;</text>
      <sha1>9q9r8bimyb6gd5e2xbdqxj04ewnxp37</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/aggregate initialization</title>
    <ns>0</ns>
    <id>8871</id>
    <revision>
      <id>71812</id>
      <parentid>71652</parentid>
      <timestamp>2014-06-25T03:58:57Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6967">{{title|aggregate initialization}}
{{cpp/language/initialization/navbar}}
Initializes an aggregate from braced-init-list

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{spar|object}} {{ttb|{{=}} {}}{{spar|arg1, arg2, ...}}{{ttb|};}} }}
{{sdsc | num=2 | {{spar|T}} {{spar|object}} {{ttb| {}}{{spar|arg1, arg2, ...}}{{ttb|};}}|notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===

Aggregate initialization is a form of [[cpp/language/list_initialization|list-initialization]], which initializes ''aggregates''

An aggregate is an object of the type that is one of the following

* array type
* class type (typically, {{c|struct}} or {{c|union}}), that has
:* no private or protected members
:* no user-provided constructors {{rev inl|since=c++11|(explicitly defaulted or deleted constructors are allowed)}}
:* no base classes
:* no virtual member functions
{{rev begin}}
{{rev|since=c++11|until=c++14|
:* no brace-or-equal initializers for non-static members
}}
{{rev end}}

The effects of aggregate initialization are:

* Each array element or non-static class member, in order of array subscript/appearance in the class definition, is [[cpp/language/copy_initialization|copy-initialized]] from the corresponding clause of the initializer list. 

* If the initializer clause is an expression, implicit conversions are allowed as per copy-initialization, except {{mark since c++11}} if they are narrowing (as in [[cpp/language/list_initialization|list-initialization]]).

* If the initializer clause is a nested braced-init-list, the corresponding class member is itself an aggregate: aggregate initialization is recursive.

* If the object is an array of unknown size, and the supplied brace-enclosed initializer list has {{tt|n}} clauses, the size of the array is {{tt|n}}

* Static data members and anonymous bit-fields are skipped during aggregate initialization.

* If the number of initializer clauses exceeds the number of members to initialize, the program is ill-formed (compiler error)

* If the number of initializer clauses is less than the number of members or initializer clauses is completely empty, the remaining members are initialized {{rev inl|since=c++14|by their {{rlp|data members#Member_initialization|brace-or-equal initializers}}, if provided in the class definition, and otherwise}} by empty lists, which performs [[cpp/language/value_initialization|value-initialization]]. If a member of a reference type is one of these remaining members, the program is ill-formed (references cannot be value-initialized)

* {{rev inl|until=c++14|If the aggregate initialization uses the form with the equal sign ({{c|T a {{=}} {args..} }}),}} the braces around the nested initializer lists may be elided (omitted), in which case as many initializer clauses as necessary are used to initialize every member or element of the corresponding subaggregate, and the subsequent initializer clauses are used to initialize the following members of the object. However, if the object has a sub-aggregate without any members (an empty struct, or a struct holding only static members), brace elision is not allowed, and an empty nested list {{ttb|{} }} must be used.

* When a union is initialized by aggregate initialization, only its first non-static data members is initialized.

===Character arrays===
Arrays of character types ({{tt|char}}, {{tt|signed char}}, {{tt|unsigned char}}, {{tt|char16_t}}, {{tt|char32_t}}, {{tt|wchar_t}}) can be initialized from an appropriate {{rlp|string literal}}, optionally enclosed in braces. Successive characters of the the string literal (which includes the implicit terminating null character) initialize the elements of the array. If the size of the array is specified and it is larger than the number of characters in the string literal, the remaining characters are zero-initialized.

{{source|1=
char a[] = &quot;abc&quot;;
// equivalent to char a[4] = {'a', 'b', 'c', '\0'};

//  unsigned char b[3] = &quot;abc&quot;; // Error: initialzer string too long
unsigned char b[5]{&quot;abc&quot;};
// equivalent to unsigned char a[5] = {'a', 'b', 'c', '\0', '\0'};

wchar_t c[] = {L&quot;кошка&quot;}; // optional braces
// equivalent to wchar_t c[6] = {L'к', L'о', L'ш', L'к', L'а', L'\0'};
}}

===Notes===
Until C++11, narrowing conversions were permitted in aggregate initialization, but they are no longer allowed.

Until C++11, aggregate initialization could not be used in a constructor initializer list due to syntax restrictions.

Until C++14, the direct-initialization form {{c|T a {args..} }} did not permit brace elision.

In C, character array of size one less than the size of the string literal may be initialized from a string literal; the resulting array is not null-terminated. This is not allowed in C++.

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;array&gt;
struct S {
    int x;
    struct Foo {
        int i;
        int j;
        int a[3];
    } b;
};

union U {
    int a;
    const char* b;
};
int main()
{
    S s1 = { 1, { 2, 3, {4, 5, 6} } };
    S s2 = { 1, 2, 3, 4, 5, 6}; // same, but with brace elision
    S s3{1, {2, 3, {4, 5, 6} } }; // same, using direct-list-initialization syntax
//  S s4{1, 2, 3, 4, 5, 6}; // error: brace-elision only allowed with equals sign

    int ar[] = {1,2,3}; // ar is int[3]
//  char cr[3] = {'a', 'b', 'c', 'd'}; // too many initializer clauses
    char cr[3] = {'a'}; // array initialized as {'a', '\0', '\0'}

    int ar2d1[2][2] = {{1, 2}, {3, 4}}; // fully-braced 2D array: {1, 2}
                                        //                        {3, 4}
    int ar2d2[2][2] = {1, 2, 3, 4}; // brace elision: {1, 2}
                                    //                {3, 4}
    int ar2d3[2][2] = {{1}, {2}};   // only first column: {1, 0}
                                    //                    {2, 0}

    std::array&lt;int, 3&gt; std_ar2{ {1,2,3} };    // std::array is an aggregate
    std::array&lt;int, 3&gt; std_ar1 = {1, 2, 3}; // brace-elision okay

    int ai[] = { 1, 2.0 }; // narrowing conversion from double to int:
                           // error in C++11, okay in C++03

    std::string ars[] = {std::string(&quot;one&quot;), // copy-initialization
                         &quot;two&quot;,              // conversion, then copy-initialization
                         {'t', 'h', 'r', 'e', 'e'} }; // list-initialization

    U u1 = {1}; // OK, first member of the union
//    U u2 = { 0, &quot;asdf&quot; }; // error: too many initializers for union
//    U u3 = { &quot;asdf&quot; }; // error: invalid conversion to int

}
 | output=
}}

===See also===
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/aggregate initialization]]
[[es:cpp/language/aggregate initialization]]
[[fr:cpp/language/aggregate initialization]]
[[it:cpp/language/aggregate initialization]]
[[ja:cpp/language/aggregate initialization]]
[[pt:cpp/language/aggregate initialization]]
[[ru:cpp/language/aggregate initialization]]
[[zh:cpp/language/aggregate initialization]]</text>
      <sha1>ndjjyzo053mx8x7a4mqzogr5tw4yikp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/alignas</title>
    <ns>0</ns>
    <id>8371</id>
    <revision>
      <id>72015</id>
      <parentid>72008</parentid>
      <timestamp>2014-07-08T14:24:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>deleted &quot;specifier&quot;</comment>
      <text xml:space="preserve" bytes="2276">{{title|alignas specifier}}
{{cpp/language/declarations/navbar}}

Specifies the alignment requirement of a type or an object.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|alignas(}} {{spar|expression}} {{ttb|)}} | notes={{mark since c++11}}}}
{{sdsc | {{ttb|alignas(}} {{spar|type-id}} {{ttb|)}} | notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===

The {{c|alignas}} specifier may be applied to the declaration of a variable or a class data member, or it can be applied to the definition of a class/struct/union or enum.

When used in form {{c|alignas(expression)}}, and {{spar|expression}} is an integral constant expression that evaluates to a positive value, the declared entity will have its alignment requirement set to exactly the result of the {{spar|expression}}, except if it would weaken the natural alignment requirement of the type.

When used in form {{c|alignas(type)}}, is exactly equivalent to {{c|alignas(alignof(type))}}, that is, the alignment requirement of the declared entity will be equal the alignment requirement of {{spar|type}}.

===Notes===
{{c|alignas(0)}} has no effect.

When multiple {{c|alignas}} specifiers are applied to the same variable or class, the strictest one is used.

As of the ISO C11 standard, the C language has the {{c|_Alignas}} keyword and defines {{c|alignas}} as a preprocessor macro expanding to the keyword in the header {{c|&lt;stdalign.h&gt;}}, but in C++ this is a keyword, and the headers {{c|&lt;stdalign.h&gt;}} and {{c|&lt;cstdalign&gt;}} do not define such macro. They do, however, define the macro constant {{c|__alignas_is_defined}}.

===Keywords===

{{ltt|cpp/keyword/alignas}}

===Example===

{{example|code=

// every object of type sse_t will be aligned to 16-byte boundary
struct alignas(16) sse_t
{
  float sse_data[4];
};

// the array &quot;cacheline&quot; will be aligned to 128-byte boundary
alignas(128) char cacheline[128];

}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc alignof}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc see c | c/align/alignas | alignas}}
{{dsc end}}

[[de:cpp/language/alignas]]
[[es:cpp/language/alignas]]
[[fr:cpp/language/alignas]]
[[it:cpp/language/alignas]]
[[ja:cpp/language/alignas]]
[[pt:cpp/language/alignas]]
[[ru:cpp/language/alignas]]
[[zh:cpp/language/alignas]]</text>
      <sha1>bo6rwkj1d2rfkb254c339u9yd9vai2h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/alignof</title>
    <ns>0</ns>
    <id>1984</id>
    <revision>
      <id>67242</id>
      <parentid>67003</parentid>
      <timestamp>2014-01-29T12:12:15Z</timestamp>
      <contributor>
        <ip>217.151.194.8</ip>
      </contributor>
      <comment>Fix typo</comment>
      <text xml:space="preserve" bytes="1884">{{title|alignof operator {{mark since c++11}}}}
{{cpp/language/expressions/navbar}}
Queries alignment requirements of a type

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|alignof(}} {{spar|type-id}} {{ttb|)}}}}
{{sdsc end}}

Returns a value of type {{lc|std::size_t}}.

===Explanation===
Returns {{rlp|object#Alignment|the alignment}}, in bytes, required for any instance of the type indicated by [[cpp/language/type#Type_naming|type-id]], which is either complete type, an array type, or a reference type. 

If the type is reference type, the operator returns the alignment of ''referenced'' type; if the type is array type, alignment requirement of the element type is returned.

The types {{c|char}}, {{c|signed char}}, and {{c|unsigned char}} have the weakest (smallest) alignment supported by the implementation.

===Keywords===
{{ltt|cpp/keyword/alignof}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

struct Empty {};

struct Foo {
     int f2;
     float f1;
     char c;
};

int main()
{
    std::cout &lt;&lt; &quot;alignment of empty class: &quot; &lt;&lt; alignof(Empty) &lt;&lt; '\n'
              &lt;&lt; &quot;alignment of pointer : &quot;    &lt;&lt; alignof(int*)  &lt;&lt; '\n'
              &lt;&lt; &quot;alignment of char : &quot;       &lt;&lt; alignof(char)  &lt;&lt; '\n'
              &lt;&lt; &quot;alignment of Foo : &quot;        &lt;&lt; alignof(Foo)   &lt;&lt; '\n' ;
}
 | output=
alignment of empty class: 1
alignment of pointer : 8
alignment of char : 1
alignment of Foo : 4
}}

===See also===
{{dsc begin}}
{{dsc | [[cpp/language/object#Alignment | alignment requirement ]] | restricts the addresses at which an object may be allocated }}
{{dsc inc | cpp/language/dsc alignas}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc end}}

[[de:cpp/language/alignof]]
[[es:cpp/language/alignof]]
[[fr:cpp/language/alignof]]
[[it:cpp/language/alignof]]
[[ja:cpp/language/alignof]]
[[pt:cpp/language/alignof]]
[[ru:cpp/language/alignof]]
[[zh:cpp/language/alignof]]</text>
      <sha1>3jfht1ng7wk09sne896a9v6yhfvdxqc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/array</title>
    <ns>0</ns>
    <id>9956</id>
    <revision>
      <id>71441</id>
      <parentid>70021</parentid>
      <timestamp>2014-06-11T03:43:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+cv rules, with clarifications from cwg 1059</comment>
      <text xml:space="preserve" bytes="5616">{{title|Array declaration}}
{{cpp/language/declarations/navbar}}

Declares an object of array type.

===Syntax===

An array declaration is any simple declaration whose {{rlp|declarations|declarator}} has the form

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|noptr-declarator}} {{ttb|[}} {{spar|constexpr}}{{mark optional}} {{ttb|]}} {{spar|attr}}{{mark optional}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|noptr-declarator}} | any valid {{spar|declarator}}, but if it begins with *, &amp;, or &amp;&amp;, it has to be surrounded by parentheses. }}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}} }}
{{par | {{spar|constexpr}} | a {{rlp|constant expression|converted constant expression}} of type {{lc|std::size_t}}, which evaluates to a value greater than zero }}
{{par end}}

A declaration of the form {{c|T a[N];}}, declares {{tt|a}} as an array object that consists of {{tt|N}} contiguously allocated objects of type {{tt|T}}. The elements of an array are numbered {{tt|0...N-1}}, and may be accessed with the {{rlp|operator_member_access|member access operator []}}, as in {{c|a[0] ... a[N-1]}}.

Arrays can be constructed from any fundamental type (except {{c|void}}), pointers, pointers
to members, classes, enumerations, or from other arrays (in which case the array is said to be multi-dimensional). There are no arrays of references, arrays of functions, or arrays of incomplete types.

Applying {{rlp|cv|cv-qualifiers}} to an array type (through typedef or template type manipulation) applies the qualifiers to the element type, but any array type whose elements are of cv-qualified type is considered to have the same cv-qualification.
{{source|1=
// arr1 and arr2 have the same const-qualified type &quot;array of 5 const char&quot;
typedef const char CC;
CC arr1[5] = {}; 
typedef char CA[5];
const CA arr2 = {};
}}

====Assignment====
Objects of array type cannot be modified: even though they are {{rlp|value_category|lvalues}} (e.g. an address of array can be taken), they cannot appear on the left hand side of an assignment operator:

{{source|1=
int a[3] = {1,2,3}, b[3] = {4,5,6};
int (*p)[3] = &amp;a; // okay, address of a can be taken
a = b;            // error, a is an array
struct { int c[3]; } s1, s2 = {3,4,5};
s1 = s2; // okay: implicity-defined copy assignment operator
         // can assign data members of array type
}}

====Array to pointer decay====
There is an {{rlp|implicit_cast|implicit conversion}} from lvalues and rvalues of array type to rvalues of pointer type: it constructs a pointer to the first element of an array. This conversion is used whenever arrays appear in context where arrays are not expected, but pointers are:

{{example|code=
#include &lt;iostream&gt;
#include &lt;numeric&gt;
#include &lt;iterator&gt;

void g(int (&amp;a)[3])
{
    std::cout &lt;&lt; a[0] &lt;&lt; '\n';
}
void f(int* p) {
    std::cout &lt;&lt; *p &lt;&lt; '\n';
}

int main()
{
    int a[3] = {1,2,3};
    int* p = a;

    std::cout &lt;&lt; sizeof a &lt;&lt; '\n'  // prints size of array
              &lt;&lt; sizeof p &lt;&lt; '\n'; // prints size of a pointer

    // where arrays are acceptable, but pointers aren't, only arrays may be used
    g(a); // OK: function takes an array by reference
//  g(p); // Error

    for(int n: a)              // OK: arrays can be used in range for loops
        std::cout &lt;&lt; n &lt;&lt; ' '; // prints elements of the array
//    for(int n: p)            // Error
//        std::cout &lt;&lt; n &lt;&lt; ' '; 

    std::iota(std::begin(a), std::end(a), 7); // OK: begin/end take arrays
//  std::iota(std::begin(p), std::end(p), 7); // Error

    // where pointers are acceptable, but arrays aren't, both may be used:
    f(a); // OK: function takes a pointer
    f(p); // OK: function takes a pointer

    std::cout &lt;&lt; *a &lt;&lt; '\n' // prints the first element
              &lt;&lt; *p &lt;&lt; '\n' // same
              &lt;&lt; *(a+1) &lt;&lt; ' ' &lt;&lt; a[1] &lt;&lt; '\n' // prints the second
              &lt;&lt; *(p+1) &lt;&lt; ' ' &lt;&lt; p[1] &lt;&lt; '\n';
}
}}

====Multidimensional arrays====
When the element type of an array is another array, it is said that the array is multidimensional:
{{source|1=// array of 2 arrays of 3 ints each
int a[2][3] = {{1,2,3},  // can be viewed as a 2x3 matrix
               {4,5,6}}; // with row-major layout
}}

Note that when array-to-pointer conversion is applied, a multidimensional array is converted to a pointer to its first element, e.g., pointer to the first row:

{{source|1=
int a[2][3]; // 2x3 matrix
int (*p1)[3] = a; // pointer to the first 3-element row
int b[3][3][3]; // 3x3x3 cube
int (*p2)[3][3] = a; // pointer to the first 3x3 plane
}}

====Arrays of unknown bound====
If {{spar|constexpr}} is omitted in the declaration of an array, the type declared is &quot;array of unknown bound of T&quot;, which is a kind of {{rlp|incomplete_type|incomplete type}}, except when used in a declaration with an {{rlp|aggregate_initialization|aggregate initializer}}:

{{source|1=
extern int x[]; // the type of x is &quot;array of unknown bound of int&quot;
int a[] = {1,2,3}; // the type of a is &quot;array of 3 int&quot;
}}

====Array rvalues====
An array rvalue expression may be formed by accessing an array member of a class rvalue or by using an identity template to construct an array temporary directly:

{{example|code=#include &lt;iostream&gt;
#include &lt;type_traits&gt;

void f(int (&amp;&amp;x)[2][3])
{
    std::cout &lt;&lt; sizeof x &lt;&lt; '\n';
}

struct X {
    int i[2][3];
} x;

template&lt;typename T&gt; using identity = T;

int main()
{
    std::cout &lt;&lt; sizeof X().i &lt;&lt; '\n'; // size of the array
    f(X().i); // OK, binds to rvalue
//  f(x.i);   // Error: cannot bind to lvalue

    f(identity&lt;int[][3]&gt;{{1,2,3},{4,5,6}}); // OK, binds to rvalue
}
| output=
24
24
24
}}</text>
      <sha1>ib82q475a5wihxct68iirwd0b1o804o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/as if</title>
    <ns>0</ns>
    <id>8874</id>
    <revision>
      <id>72352</id>
      <parentid>72350</parentid>
      <timestamp>2014-08-14T01:48:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stealing the explanation of &quot;behavior according to the abstract machine&quot; from C.</comment>
      <text xml:space="preserve" bytes="4993">{{title|The as-if rule}}
{{cpp/language/navbar}}
Allows any and all code transformations that do not change the observable behavior of the program

===Explanation===

The C++ compiler is permitted to perform any changes to the program as long as the following remains true:

{{rev begin}}
{{rev|until=c++11|
@1@ At every {{rlp|eval_order|sequence point}}, the values of all {{rlp|cv|volatile}} objects are stable (previous evaluations are complete, new evaluations not started)
}}{{rev|since=c++11|
@1@ Accesses (reads and writes) to {{rlp|cv|volatile}} objects occur strictly according to the semantics of the expressions in which they occur. In particular, they are [[cpp/atomic/memory_order|not reordered]].
}}
{{rev end}}

@2@ At program termination, data written to files is exactly as if the program was executed as written.

@3@ Prompting text which is sent to an interactive devices will be shown before the program waits for input.

@4@ If {{ltt|cpp/preprocessor/impl|#pragma STDC FENV_ACCESS}} is set to {{tt|ON}}, the changes to the [[cpp/numeric/fenv|floating-point environment]] (floating-point exceptions and rounding modes) are guaranteed to be observed by the floating-point arithmetic operators and function calls as if executed as written.

===Notes===

Because the compiler is (usually) unable to analyze the code of an external library to determine whether it does or does not perform I/O or volatile access, third-party library calls also aren't affected by optimization. However, standard library calls may be replaced by other calls, eliminated, or added to the program during optimization. Statically-linked third-party library code may be subject to link-time optimization.

Programs with undefined behavior, e.g. due to access to an array out of bounds, modification of a const object, [[cpp/language/eval_order|evaluation order]] violations, etc, are free from the as-if rule: they often change observable behavior when recompiled with different optimization settings. For example, if a test for signed integer overflow relies on the result of that overflow, e.g. {{c|if(n+1 &lt; n) abort();}}, [http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html it is removed entirely by some compilers] because [[cpp/language/operator_arithmetic#Overflows|signed overflow is undefined behavior]] and the optimizer is free to assume it never happens and the test is redundant.

[[cpp/language/copy_elision|Copy elision]] is the only well-defined exception from the as-if rule.

The count and order of floating-point exceptions can be changed by optimization as long as the state as observed by the next floating-point operation is as if no optimization took place:
{{source|1=
#pragma STDC FENV_ACCESS ON
for (i = 0; i &lt; n; i++) x + 1; // x+1 is dead code, but may raise FP exceptions
// (unless the optimizer can prove otherwise). However, executing it n times will
// raise the same exception over and over. So this can be optimized to:
if (0 &lt; n) x + 1; 
}}
===Example===

{{example
 |
 | code=
int&amp; preinc(int&amp; n) { return ++n; }
int add(int n, int m) { return n+m; }

// volatile input to prevent constant folding
volatile int input = 7;

// volatile output to make the result a visible side-effect
volatile int result;

int main()
{
    int n = input;
// using built-in operators would invoke undefined behavior
//    int m = ++n + ++n;
// but using functions makes sure the code executes as-if 
// the functions were not overlapped
    int m = add(preinc(n), preinc(n));
    result = m;
}
 | output=
# full code of the main() function as produced by the GCC compiler
# x86 (Intel) platform:
        movl    input(%rip), %eax   # eax = input
        leal    3(%rax,%rax), %eax  # eax = 3 + eax + eax
        movl    %eax, result(%rip)  # result = eax
        xorl    %eax, %eax          # eax = 0 (the return value of main())
        ret

# PowerPC (IBM) platform:
        lwz 9,LC..1(2)
        li 3,0          # r3 = 0 (the return value of main())
        lwz 11,0(9)     # r11 = input;
        slwi 11,11,1    # r11 = r11 &lt;&lt; 1;
        addi 0,11,3     # r0 = r11 + 3;
        stw 0,4(9)      # result = r0;
        blr

# Sparc (Sun) platform:
        sethi   %hi(result), %g2
        sethi   %hi(input), %g1
        mov     0, %o0                 # o0 = 0 (the return value of main)
        ld      [%g1+%lo(input)], %g1  # g1 = input
        add     %g1, %g1, %g1          # g1 = g1 + g1
        add     %g1, 3, %g1            # g1 = 3 + g1
        st      %g1, [%g2+%lo(result)] # result = g1
        jmp     %o7+8
        nop

# in all cases, the side effects of preinc() were eliminated, and the
# entire main() function was reduced to the equivalent of result = 2*input + 3;
}}

===See also===
* [[cpp/language/copy_elision|copy elision]]

[[de:cpp/language/as if]]
[[es:cpp/language/as if]]
[[fr:cpp/language/as if]]
[[it:cpp/language/as if]]
[[ja:cpp/language/as if]]
[[pt:cpp/language/as if]]
[[ru:cpp/language/as if]]
[[zh:cpp/language/as if]]</text>
      <sha1>emnbivonzccq048yggm8kvh8fo2suvo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/as operator</title>
    <ns>0</ns>
    <id>9136</id>
    <revision>
      <id>71632</id>
      <parentid>71436</parentid>
      <timestamp>2014-06-17T04:38:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>defaulted can be trivial, and also cwg 1333</comment>
      <text xml:space="preserve" bytes="8792">{{title|Copy assignment operator}}
{{cpp/language/classes/navbar}}

A copy assignment operator of class {{tt|T}} is a non-template non-static member function with the name {{c|operator{{=}}}} that takes exactly one parameter of type {{c|T}}, {{c|T&amp;}}, {{c|const T&amp;}}, {{c|volatile T&amp;}}, or {{c|const volatile T&amp;}}. A type with a public copy assignment operator is {{concept|CopyAssignable}}.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( {{spar|class_name}} ) }} 
{{sdsc |num=2| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( const {{spar|class_name}} {{tt|&amp;}} ) }} 
{{sdsc |num=3|notes={{mark since c++11}}| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( const {{spar|class_name}} {{tt|&amp;}} ) {{=}} {{c|default;}} }}
{{sdsc |num=4|notes={{mark since c++11}}| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( const {{spar|class_name}} {{tt|&amp;}} ) {{=}} {{c|delete;}} }}
{{sdsc end}}

===Explanation===
# Typical declaration of a copy assignment operator when [http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Copy-and-swap copy-and-swap idiom] can be used
# Typical declaration of a copy assignment operator when copy-and-swap idiom cannot be used
# Forcing a copy assignment operator to be generated by the compiler
# Avoiding implicit copy assignment

The copy assignment operator is called whenever selected by [[cpp/language/overload_resolution|overload resolution]], e.g. when an object appears on the left side of an assignment expression.

===Implicitly-declared copy assignment operator===
If no user-defined copy assignment operators are provided for a class type ({{c|struct}}, {{c|class}}, or {{c|union}}), the compiler will always declare one as an inline public member of the class. This implicitly-declared copy assignment operator has the form {{c|1=T&amp; T::operator=(const T&amp;)}} if all of the following is true:
* each direct base {{tt|B}} of {{tt|T}} has a copy assignment operator whose parameters are {{tt|B}} or {{tt|const B&amp;}} or {{c|const volatile B&amp;}}
* each non-static data member {{tt|M}} of {{tt|T}} of class type or array of class type has a copy assignment operator whose parameters are {{tt|M}} or {{tt|const M&amp;}} or {{c|const volatile M&amp;}}
Otherwise the implicitly-declared copy assignment operator is declared as {{c|1=T&amp; T::operator=(T&amp;)}}. (Note that due to these rules, the implicitly-declared copy assignment operator cannot bind to a volatile lvalue argument)

A class can have multiple copy assignment operators, e.g. both {{c|1=T&amp; T::operator=(const T&amp;)}} and {{c|1=T&amp; T::operator=(T)}}. {{rev inl|since=c++11|If some user-defined copy assignment operators are present, the user may still force the generation of the implicitly declared copy assignment operator with the keyword {{tt|default}}.}}

Because the copy assignment operator is always declared for any class, the base class assignment operator is always hidden. If a {{rlp|using declaration#In class definition|using-declaration}} is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

===Deleted implicitly-declared copy assignment operator===
The implicitly-declared or defaulted copy assignment operator for class {{tt|T}} is defined as ''deleted'' in any of the following is true:
* {{tt|T}} has a non-static data member that is {{c|const}}
* {{tt|T}} has a non-static data member of a reference type.
* {{tt|T}} has a non-static data member that cannot be copy-assigned (has deleted, inaccessible, or ambiguous copy assignment operator)
* {{tt|T}} has direct or virtual base class that cannot be copy-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
* {{tt|T}} has a user-declared move constructor
* {{tt|T}} has a user-declared move assignment operator

===Trivial copy assignment operator===
The copy assignment operator for class {{tt|T}} is trivial if all of the following is true:
* The operator is not user-provided (meaning, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
* {{tt|T}} has no virtual member functions
* {{tt|T}} has no virtual base classes
* The copy assignment operator selected for every direct base of {{tt|T}} is trivial
* The copy assignment operator selected for every non-static class type (or array of class type) memeber of {{tt|T}} is trivial
{{rev begin}}
{{rev | since=c++14 |
* {{tt|T}} has no non-static data members of {{rlp|cv|volatile}}-qualified type
}}
{{rev end}}
A trivial copy assignment operator makes a copy of the object representation as if by {{lc|std::memmove}}. All data types compatible with the C language (POD types) are trivially copy-assignable.

===Implicitly-defined copy assignment operator===
If the implicitly-declared copy assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For {{c|union}} types, the implicitly-defined copy assignment copies the object representation (as by {{lc|std::memmove}}). For non-union class types ({{c|class}} and {{c|struct}}), the operator performs member-wise copy assignment of the object's bases and non-static members, in their initialization order, using, using built-in assignment for the scalars and copy assignment operator for class types.

The generation of the implicitly-defined copy assignment operator is deprecated{{mark since c++11}} if {{tt|T}} has a user-declared destructor or user-declared copy constructor.

===Notes===
If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an ''rvalue'' (either ''prvalue'' such as a nameless temporary or ''xvalue'' such as the result of {{lc|std::move}}), and selects the copy assignment if the argument is ''lvalue'' (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

===Copy and swap===
Copy assignment operator can be expressed in terms of copy constructor, destructor, and the swap() member function, if one is provided:

{{c|1=T&amp; T::operator=(T arg) { // copy/move constructor is called to construct arg
    swap(arg);    // resources exchanged between *this and arg
    return *this;
}  // destructor is called to release the resources formerly held by *this
}}

For non-throwing swap(), this form provides [[cpp/language/throw|strong exception guarantee]]. For rvalue arguments, this form automatically invokes the move constructor, and is sometimes referred to as &quot;unifying assignment operator&quot; (as in, both copy and move).

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;

struct A {
    int n;
    std::string s1;
    // user-defined copy assignment, copy-and-swap form
    A&amp; operator=(A other) {
        std::cout &lt;&lt; &quot;copy assignment of A\n&quot;;
        std::swap(n, other.n);
        std::swap(s1, other.s1);
        return *this;
    }
};

struct B : A {
    std::string s2;
    // implicitly-defined copy assignment
};

struct C {
     std::unique_ptr&lt;int[]&gt; data;
     std::size_t size;
     // non-copy-and-swap assignment
     C&amp; operator=(const C&amp; other) {
         // check for self-assignment
         if(&amp;other == this)
             return *this;
         // reuse storage when possible
         if(size != other.size)
             data.reset(new int[other.size]);
         std::copy(&amp;other.data[0],
                   &amp;other.data[0] + std::min(size, other.size),
                   &amp;data[0]);
         return *this;
     }
     // note: copy-and-swap would always cause a reallocation
};

int main()
{
    A a1, a2;
    std::cout &lt;&lt; &quot;a1 = a2 calls &quot;;
    a1 = a2; // user-defined copy assignment

    B b1, b2;
    b2.s1 = &quot;foo&quot;;
    b2.s2 = &quot;bar&quot;;
    std::cout &lt;&lt; &quot;b1 = b2 calls &quot;;
    b1 = b2; // implicitly-defined copy assignment
    std::cout &lt;&lt; &quot;b1.s1 = &quot; &lt;&lt; b1.s1 &lt;&lt; &quot; b1.s2 = &quot; &lt;&lt; b1.s2 &lt;&lt;  '\n';
}
| output=
a1 = a2 calls copy assignment of A
b1 = b2 calls copy assignment of A
b1.s1 = foo b1.s2 = bar
}}

[[de:cpp/language/as operator]]
[[es:cpp/language/as operator]]
[[fr:cpp/language/as operator]]
[[it:cpp/language/as operator]]
[[ja:cpp/language/as operator]]
[[pt:cpp/language/as operator]]
[[ru:cpp/language/as operator]]
[[zh:cpp/language/as operator]]</text>
      <sha1>ic86ftoi6qinuphcwe2kykghi9ygjx2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/ascii</title>
    <ns>0</ns>
    <id>687</id>
    <revision>
      <id>44311</id>
      <parentid>34039</parentid>
      <timestamp>2012-11-03T05:51:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding [[ar:cpp/language/ascii]], [[es:cpp/language/ascii]]</comment>
      <text xml:space="preserve" bytes="521">{{title|ASCII Chart}}
{{cpp/language/navbar}}
The following chart contains all 128 ASCII decimal '''(dec)''', octal '''(oct)''', hexadecimal '''(hex)''' and character '''(ch)''' codes.

{{cpp/language/ascii}}

[[ar:cpp/language/ascii]]
[[cs:cpp/language/ascii]]
[[de:cpp/language/ascii]]
[[es:cpp/language/ascii]]
[[fr:cpp/language/ascii]]
[[it:cpp/language/ascii]]
[[ja:cpp/language/ascii]]
[[pl:cpp/language/ascii]]
[[pt:cpp/language/ascii]]
[[ru:cpp/language/ascii]]
[[tr:cpp/language/ascii]]
[[zh:cpp/language/ascii]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/asm</title>
    <ns>0</ns>
    <id>5289</id>
    <revision>
      <id>71046</id>
      <parentid>71045</parentid>
      <timestamp>2014-06-04T23:52:24Z</timestamp>
      <contributor>
        <ip>82.193.103.183</ip>
      </contributor>
      <comment>Undo revision 71045 by [[Special:Contributions/82.193.103.183|82.193.103.183]] ([[User talk:82.193.103.183|talk]])</comment>
      <text xml:space="preserve" bytes="2584">{{title|asm declaration}}
{{cpp/language/declarations/navbar}}

It can be used to pass information to the back-end of the compiler.&lt;br/&gt;

This declaration is conditionally-supported and implementation defined, 
meaning that it may not be present and, even when provided by the implementation, it does not have a fixed meaning

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|asm (}} {{spar|string_literal}} {{ttb|)}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===
The {{spar|string_literal}} is typically a short program written in assembly language, which is executed whenever this declaration is executed. Different C++ compilers have wildly varying rules for asm-declarations, and different conventions for the interaction with the surrounding C++ code.

As other {{rlp|declarations|block declarations}}, this declaration can only appear inside a block (a function body or another compound statement).

{{todo|write a note on GCC extended assembly syntax, since it is now supported by Intel, IBM, Sun (as of v12), etc}}

===Examples===
{{example| Demonstrates two kinds of inline assembly syntax offered by the GCC compiler. This program will only work correctly on x86_64 platform under Linux.
|code=
#include &lt;iostream&gt;
int main()
{
    int n = 7;
    // extended inline assembly
    asm (&quot;leal (%0,%0,4),%0&quot;
         : &quot;=r&quot; (n)
         : &quot;0&quot; (n));
    std::cout &lt;&lt; &quot;7*5 = &quot; &lt;&lt; n &lt;&lt; '\n';

    // standard inline assembly
    asm (&quot;movq $60, %rax\n\t&quot; // the exit syscall number on Linux
         &quot;movq $2,  %rdi\n\t&quot; // this program returns 2
         &quot;syscall&quot;);
}
|output=
7*5 = 35
}}

===External links===
*[http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html GCC Inline Assembly HOWTO]
*[http://pic.dhe.ibm.com/infocenter/comphelp/v121v141/topic/com.ibm.xlcpp121.aix.doc/language_ref/asm.html IBM XL C/C++ Inline Assembly]
*[http://software.intel.com/sites/products/documentation/doclib/stdxe/2013/composerxe/compiler/cpp-lin/GUID-5100C4FC-BC2F-4E36-943A-120CFFFB4285.htm Intel C++ Inline Assembly]
*[http://msdn.microsoft.com/en-us/library/4ks26t93(v=vs.120).aspx Visual Studio 2013 Inline Assembler]
*[https://blogs.oracle.com/x86be/entry/gcc_style_asm_inlining_support Sun Studio 12 Asm Statements]
*[http://h21007.www2.hp.com/portal/site/dspp/menuitem.863c3e4cbcdc3f3515b49c108973a801?ciid=4308e2f5bde02110e2f5bde02110275d6e10RCRD Inline assembly for Itanium-based HP-UX]

[[de:cpp/language/asm]]
[[es:cpp/language/asm]]
[[fr:cpp/language/asm]]
[[it:cpp/language/asm]]
[[ja:cpp/language/asm]]
[[pt:cpp/language/asm]]
[[ru:cpp/language/asm]]
[[zh:cpp/language/asm]]</text>
      <sha1>1b4geyt1avzs9uan885lsebsc2t12bx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/attributes</title>
    <ns>0</ns>
    <id>8703</id>
    <revision>
      <id>70760</id>
      <parentid>70756</parentid>
      <timestamp>2014-05-29T21:11:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+ill-formed if carries_dependency mismatched between TUs</comment>
      <text xml:space="preserve" bytes="4470">{{title|attribute specifier sequence{{mark since c++11}}}}
{{cpp/language/declarations/navbar}}

Introduces implementation-defined attributes for types, objects, code, etc.

:{{ttb|&lt;nowiki&gt;[[&lt;/nowiki&gt;}}{{spar|attr}}{{ttb|]]}} {{ttb|&lt;nowiki&gt;[[&lt;/nowiki&gt;}}{{spar|attr1}}, {{spar|attr2}}, {{spar|attr3}}{{ttb|(}}{{spar|args}}{{ttb|)}}{{ttb|]]}} {{ttb|&lt;nowiki&gt;[[&lt;/nowiki&gt;}}{{spar|namespace}}{{ttb|::}}{{spar|attr}}{{ttb|(}}{{spar|args}}{{ttb|)}}{{ttb|]]}} {{spar|alignas_specifier}}

===Explanation===

Attributes provide the unified standard syntax for implementation-defined language extensions, such as the GNU and IBM language extensions {{tt|__attribute__((...))}}, Microsoft extension {{tt|__declspec()}}, etc.

An attribute can be used almost everywhere in the C++ program, and can be applied to almost everything: to types, to variables, to functions, to names, to code blocks, to entire translation units, although each particular attribute is only valid where it is permitted by the implementation: {{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;probably(true)]]}} can only be used with an {{c|if}}, and not with an class declaration. {{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;omp::parallel()]]}} can apply to a code block or to a {{c|for}} loop, but not to the type {{tt|int}}, etc.

In declarations, attributes may appear both before and directly after the name of the entity that is declared, in which case they are combined. In most other situations, attributes apply to the directly preceding entity.

[[cpp/language/alignas|alignas_specifier]] is a part of the attribute specifier sequence, although it has different syntax. It may appear where the {{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;...]]}} attributes appear and may mix with them (provided it is used where {{c|alignas}} is permitted)

===Standard attributes===
Only the following attributes are defined by the C++ standard. All other attributes are implementation-specific.

{{dsc begin}}
{{dsc|{{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;noreturn]]}} | Indicates that the function does not return. &lt;br&gt; This attribute applies to function declarations only. The behavior is undefined if the function with this attribute actually returns. &lt;br&gt;The following standard functions have this attribute: {{lc|std::_Exit}}, {{lc|std::abort}}, {{lc|std::exit}}, {{lc|std::quick_exit}}, {{lc|std::unexpected}}, {{lc|std::terminate}}, {{lc|std::rethrow_exception}}, {{lc|std::throw_with_nested}}, {{lc|std::nested_exception::rethrow_nested}} }}

{{dsc|{{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;carries_dependency]]}} | Indicates that dependency chain in release-consume {{lc|std::memory_order}} propagates in and out of the function, which allows the compiler to skip unnecessary memory fence instructions.&lt;br&gt;This attribute may appear in two situations:&lt;br&gt;
1) it may apply to the parameter declarations of a function or lambda-expressions, in which case it indicates that initialization of the parameter carries dependency into lvalue-to-rvalue conversion of that object.&lt;br&gt;
2) It may apply to the function declaration as a whole, in which case it indicates that the return value carries dependency to the evaluation of the function call expression.

This attribute must appear on the first declaration of a function or one of its parameters in any translation unit. If it is not used on the first declaration of a function or one of its parameters in another translation unit, the program is ill-formed; no diagnostic required.

See  {{lc|std::kill_dependency}}  for example usage
}}

{{dsc|{{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;deprecated]]}}{{mark c++14}}&lt;br&gt;{{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;deprecated(&quot;reason&quot;)]]}}{{mark c++14}} | Indicates that the use of the name or entity declared with this attribute is allowed, but discouraged for some {{spar|reason}}. This attribute is allowed in declarations of classes, typedef-names, variables, non-static data members, functions, enumerations, and template specializations. A name declared non-deprecated may be redeclared deprecated. A name declared deprecated cannot be un-deprecated by redeclaring it without this attribute.}}
{{dsc end}}

===Example===
{{example |
 | code=
 | output=
}}

===External links===
[http://clang.llvm.org/docs/LanguageExtensions.html#non-standard-c-11-attributes C++ attributes supported by Clang]

[[de:cpp/language/attributes]]
[[es:cpp/language/attributes]]
[[fr:cpp/language/attributes]]
[[it:cpp/language/attributes]]
[[ja:cpp/language/attributes]]
[[pt:cpp/language/attributes]]
[[ru:cpp/language/attributes]]
[[zh:cpp/language/attributes]]</text>
      <sha1>6fospt6in7hsix9fj14fagi3m03msnv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/auto</title>
    <ns>0</ns>
    <id>5060</id>
    <revision>
      <id>71855</id>
      <parentid>71620</parentid>
      <timestamp>2014-06-28T11:55:19Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4547">{{title|auto specifier {{mark since c++11}}}}
{{cpp/language/declarations/navbar}}

Specifies that the type of the variable that is being declared will be automatically deduced from its initializer. For functions, specifies that the return type is a trailing return type {{rev inl|since=c++14|or will be deduced from its return statements}}.

===Syntax===
{{sdsc begin}}
{{sdsc | num=1 | {{c|auto}} {{spar|variable}} {{spar|initializer}} | notes={{mark since c++11}} }}
{{sdsc | num=2 | {{c|auto}} {{spar|function}} -&gt; {{spar|return type}} | notes={{mark since c++11}} }}
{{sdsc | num=3 | {{c|auto}} {{spar|function}} | notes={{mark since c++14}} }}
{{sdsc | num=4 | {{c|decltype(auto)}} {{spar|variable}} {{spar|initializer}} | notes={{mark since c++14}} }}
{{sdsc | num=5 | {{c|decltype(auto)}} {{spar|function}} | notes={{mark since c++14}} }}
{{sdsc end}}

===Explanation===
@1@ When declaring variables in block scope, in namespace scope, in init statements of for loops, etc, the keyword {{c|auto}} may be used as the type specifier.
@@Once the type of the initializer has been determined, the compiler determines the type that will replace the keyword {{c|auto}} using the rules for {{rlp|template argument deduction}} from a function call (see {{rlp|template argument deduction#Other contexts}} for details). The keyword {{c|auto}} may be accompanied by modifiers, such as {{c|const}} or {{c|&amp;}}, which will participate in the type deduction. For example, given {{c|1=const auto&amp; i = expr;}}, the type of {{tt|i}} is exactly the type of the argument {{tt|u}} in an imaginary template {{c|template&lt;class U&gt; void f(const U&amp; u)}} if the function call {{c|f(expr)}} was compiled. Therefore, `auto&amp;&amp;` may be deduced either as an lvalue reference or rvalue reference according to the initializer, which is used in range-based for loop.

@2@ In a {{rlp|function|function declaration}} that uses the trailing return type syntax, the keyword {{c|auto}} does not perform automatic type detection. It only serves as a part of the syntax.

@3@ In a {{rlp|function|function declaration}} which does not use the trailing return type syntax, the keyword {{c|auto}} indicates that the return type will be deduced from the operand of its {{rlp|return|return statement}} using the rules for {{rlp|template argument deduction#Other contexts|template argument deduction}}.

@4@ If the declared type of the variable is {{c|decltype(auto)}}, the keyword {{c|auto}} is replaced with its initializer, and the actual type is deduced using the rules for {{rlp|decltype}}.

@5@ If the return type of the function is declared {{c|decltype(auto)}}, the keyword {{c|auto}} is replaced with the operand of its return statement, and the actual return type is deduced using the rules for {{rlp|decltype}}.
===Notes===
Until C++11, {{c|auto}} had the semantic of a {{rlp|storage_duration|storage duration specifier}}.

Mixing {{tt|auto}} variables and functions in one declaration, as in {{c|auto f() -&gt; int, i {{=}} 0;}} is not allowed. &lt;!-- cwg 1265 --&gt;

===Example===
{{example | the example showing output using one of the implementations where typeinfo::name prints full type names; filter through c++filt -t if using gcc or similar 
  |code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;typeinfo&gt;

template&lt;class T, class U&gt;
auto add(T t, U u) -&gt; decltype(t + u) // the return type is the type of operator+(T,U)
{
    return t + u;
}

auto get_fun(int arg)-&gt;double(*)(double) // same as double (*get_fun(int))(double)
{
    switch (arg) {
        case 1: return std::fabs;
        case 2: return std::sin;
        default: return std::cos;
    }
}

int main()
{
    auto a = 1 + 2;
    std::cout &lt;&lt; &quot;type of a: &quot; &lt;&lt; typeid(a).name() &lt;&lt; '\n';
    auto b = add(1, 1.2);
    std::cout &lt;&lt; &quot;type of b: &quot; &lt;&lt; typeid(b).name() &lt;&lt; '\n';
    //auto int c; //compile-time error
    auto d = {1, 2};
    std::cout &lt;&lt; &quot;type of d: &quot; &lt;&lt; typeid(d).name() &lt;&lt; '\n';

    auto my_lambda = [](int x) { return x + 3; };
    std::cout &lt;&lt; &quot;my_lambda: &quot; &lt;&lt; my_lambda(5) &lt;&lt; '\n';

    auto my_fun = get_fun(2);
    std::cout &lt;&lt; &quot;type of my_fun: &quot; &lt;&lt; typeid(my_fun).name() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;my_fun: &quot; &lt;&lt; my_fun(3) &lt;&lt; '\n';
}
 |p=true
 |output=
type of a: int
type of b: double
type of d: std::initializer_list&lt;int&gt;
my_lambda: 8
type of my_fun: double (*)(double)
my_fun: 0.14112
}}

[[de:cpp/language/auto]]
[[es:cpp/language/auto]]
[[fr:cpp/language/auto]]
[[it:cpp/language/auto]]
[[ja:cpp/language/auto]]
[[pt:cpp/language/auto]]
[[ru:cpp/language/auto]]
[[zh:cpp/language/auto]]</text>
      <sha1>0er0zd8qeiqtf9fz11wgb802r5c4vy0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/basic concepts</title>
    <ns>0</ns>
    <id>13040</id>
    <revision>
      <id>69191</id>
      <parentid>68985</parentid>
      <timestamp>2014-03-29T03:04:13Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="2171">{{title|Basic concepts}}
{{cpp/language/basics/navbar}}

This section provides definitions for the specific terminology and the concepts used when describing the C++ programming language.

A C++ program is a sequence of text files (typically header and source files) that contain {{rlp|declarations}}. They undergo {{rlp|translation phases|translation}} to become an executable program, which is executed when the OS calls its {{rlp|main function}}.

Certain words in a C++ program have special meaning, they are [[cpp/keyword|keywords]]. Others can be used as {{rlp|identifiers}}. [[cpp/comment|Comments]] are ignored during translation. Certain characters in the program have to be represented with {{rlp|escape|escape sequences}}.

The ''entities'' of a C++ program are values, {{rlp|objects}}, {{rlp|reference}}s, {{rlp|functions}}, {{rlp|enum|enumerators}}, {{rlp|type}}s, class members, {{rlp|templates}}, {{rlp|template specialization}}s, {{rlp|namespace}}s, {{rlp|parameter pack}}s, and the {{c|this}} pointer.

Entities are introduced by {{rlp|declarations}}, which associate them with {{rlp|name}}s and define their properties. The declarations that define all properties required to use an entity are {{rlp|definition}}s. A program must contain only one definition of any non-inline function or variable that is {{rlp|definition|odr-used}}. 

Definitions of functions include sequences of {{rlp|statements}}, some of which include {{rlp|expressions}}, which specify the computations to be performed by the program.

Names encountered in a program are associated with the declarations that introduced them using {{rlp|lookup|name lookup}}. Each name is only valid within a part of the program called its {{rlp|scope}}. Some names have {{rlp|storage duration|linkage}} which makes them refer to the same entities when they appear in different scopes or translation units.

Each object, reference, and function in C++ is associated with a {{rlp|type}}, which may be {{rlp|types|fundamental}}, compound, or {{rlp|classes|user-defined}}, complete or {{rlp|incomplete type|incomplete}}, etc.

Named objects and named references to objects are known as ''variables''.</text>
      <sha1>03s4amtv2fpzpz6ysud2ldu9tw5plqb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/basics</title>
    <ns>0</ns>
    <id>9654</id>
    <redirect title="cpp/language/basic concepts" />
    <revision>
      <id>68983</id>
      <parentid>68824</parentid>
      <timestamp>2014-03-23T15:53:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>orphan page, all contents moved and split between different language pages</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/language/basic_concepts]]</text>
      <sha1>tb88b0jayxupnd00rrax28s241r65m3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/bit field</title>
    <ns>0</ns>
    <id>9905</id>
    <revision>
      <id>72388</id>
      <parentid>70821</parentid>
      <timestamp>2014-08-18T15:26:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note that C prohibits int n : 1000</comment>
      <text xml:space="preserve" bytes="4310">{{title|Bit field}}
{{cpp/language/classes/navbar}}
Declares a class data member with explicit size, in bits. Adjacent bit field members may be packed to share and straddle the individual bytes.

A bit field declaration is a {{rlp|data_members|class data member declaration}} which uses the following declarator:

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|identifier}}{{mark optional}} {{spar|attr}}{{mark optional}} {{ttb|:}} {{spar|size}}
}}
{{sdsc end}}

The ''type'' of the bit field is introduced by the {{spar|decl-specifier-seq}} of the {{rlp|declarations|declaration syntax}}.

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|identifier}} | the name of the bit field that is being declared. The name is optional: nameless bitfields introduce the specified number of bits of padding}}
{{par | {{spar|size}} | an integral constant expression with a value greater or equal to zero. When greater than zero, this is the number of bits that this bit field will occupy. The value zero is only allowed for nameless bitfields and has special meaning: it specifies that the next bit field in the class definition will begin at an allocation unit's boundary.}}
{{par end}}

===Explanation===
The number of bits in a bit field sets the limit to the range of values it can hold:

{{source|1=#include &lt;iostream&gt;
struct S {
 // three-bit unsigned field,
 // allowed values are 0...7
 unsigned int b : 3;
};
int main()
{
    S s = {7};
    ++s.b; // unsigned overflow
    std::cout &lt;&lt; s.b &lt;&lt; '\n'; // output: 0
}
}}

Multiple adjacent bit fields are usually packed together (although this behavior is implementation-defined):

{{source|#include &lt;iostream&gt;
struct S {
    // will usually occupy 2 bytes:
    // 3 bits: value of b1
    // 2 bits: unused
    // 6 bits: value of b2
    // 2 bits: value of b3
    // 3 bits: unused
    unsigned char b1 : 3, : 2, b2 : 6, b3 : 2;
};
int main()
{
    std::cout &lt;&lt; sizeof(S) &lt;&lt; '\n'; // usually prints 2
}
}}

The special unnamed bit field of size zero can be forced to break up padding. It specifies that the next bit field begins at the beginning of its allocation unit:

{{source|#include &lt;iostream&gt;
struct S {
    // will usually occupy 2 bytes:
    // 3 bits: value of b1
    // 5 bits: unused
    // 6 bits: value of b2
    // 2 bits: value of b3
    unsigned char b1 : 3;
    unsigned char :0; // start a new byte
    unsigned char b2 : 6;
    unsigned char b3 : 2;
};
int main()
{
    std::cout &lt;&lt; sizeof(S) &lt;&lt; '\n'; // usually prints 2
}
}}

If the specified size of the bit field is greater than the size of its type, the value is limited by the type: a {{c|std::uint8_t b : 1000;}} would still hold values between 0 and 255. the extra bits become unused padding.

Because bit fields do not necessarily begin at the beginning of a byte, address of a bit field cannot be taken. Pointers and non-const references to bit fields are not possible. When {{rlp|reference_initialization|initializing a const reference}} from a bit field, a temporary is created (its type is the type of the bit field), copy initialized with the value of the bit field, and the reference is bound to that temporary.

The type of a bit field can only be integral or enumeration type.

A bit field cannot be a {{rlp|static|static data member}}.

===Notes===
The following properties of bit fields are ''implementation-defined''
* Everything about the actual allocation details of bit fields within the class object
:* For example, on some platforms, bit fields don't straddle bytes, on others they do
:* Also, on some platforms, bit fields are packed left-to-right, on others right-to-left
{{rev begin}}
{{rev|until=c++14|
* Whether {{c|char}}, {{c|short}}, {{c|int}}, {{c|long}}, and {{c|long long}} bit fields that aren't explicitly {{c|signed}} or {{c|unsigned}} are signed or unsigned.
:* For example, {{c|int b:3;}} may have the range of values {{c|0..7}} or {{c|-4..3}}.
}}
{{rev end}}

In the C programming language, the width of a bit field cannot exceed the width of the underlying type.

===References===
{{ref std c++11}}
{{ref std | section=9.6 | title=Bit-fields | id=class.bit}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=9.6 | title=Bit-fields | id=class.bit}}
{{ref std end}}</text>
      <sha1>kfmihsi5xfelqkzqvq32zc727k41vdl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/bool literal</title>
    <ns>0</ns>
    <id>5204</id>
    <revision>
      <id>69162</id>
      <parentid>67107</parentid>
      <timestamp>2014-03-28T17:56:58Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="955">{{title|bool literal}}
{{cpp/language/expressions/navbar}}
===Syntax===
{{sdsc begin}}
{{sdsc | num = 1 | true }}
{{sdsc | num = 2 | false }}
{{sdsc end}}
===Explanation===
#boolean {{tt|true}} (a {{rlp|value_category|prvalue}} of type {{tt|bool}}, implicitly convertible to the value 1 of type {{tt|int}}.)
#boolean {{tt|false}} (a prvalue of type {{tt|bool}}, implicitly convertible to the value 0 of type {{tt|int}}.)
===Example===
{{example|code=
#include &lt;iostream&gt;

int main()
{
  std::cout &lt;&lt; std::boolalpha
            &lt;&lt; true &lt;&lt; '\n'
            &lt;&lt; false &lt;&lt; '\n'
            &lt;&lt; std::noboolalpha
            &lt;&lt; true &lt;&lt; '\n'
            &lt;&lt; false &lt;&lt; '\n';
}
|output=
true
false
1
0
}}

[[de:cpp/language/bool literal]]
[[es:cpp/language/bool literal]]
[[fr:cpp/language/bool literal]]
[[it:cpp/language/bool literal]]
[[ja:cpp/language/bool literal]]
[[pt:cpp/language/bool literal]]
[[ru:cpp/language/bool literal]]
[[zh:cpp/language/bool literal]]</text>
      <sha1>0zhvbj8pouluc0kc2nmy0jvt3zwru5x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/break</title>
    <ns>0</ns>
    <id>688</id>
    <revision>
      <id>67161</id>
      <parentid>49886</parentid>
      <timestamp>2014-01-24T10:59:54Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ range-for</comment>
      <text xml:space="preserve" bytes="1635">{{title|break statement}}
{{cpp/language/statements/navbar}}
Causes the enclosing {{rlp|for}}, {{rlp|range-for}}, {{rlp|while}} or {{rlp|do|do-while}} loop or {{rlp|switch| switch statement}} to terminate.

Used when it is otherwise awkward to terminate the loop using the condition expression and conditional statements.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|break}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===

After this statement the control is transferred to the statement immediately following the enclosing loop. All automatic storage objects declared in enclosing loop are destroyed before the execution of the first line following the enclosing loop.

===Keywords===

{{ltt|cpp/keyword/break}}

===Example===
{{example 
 | code=
#include &lt;iostream&gt;

int main()
{
    int i = 2;
    switch (i) {
        case 1: std::cout &lt;&lt; &quot;1&quot;;
        case 2: std::cout &lt;&lt; &quot;2&quot;;   //execution starts at this case label
        case 3: std::cout &lt;&lt; &quot;3&quot;;
        case 4:
        case 5: std::cout &lt;&lt; &quot;45&quot;;
                break;              //execution of subsequent statements is terminated
        case 6: std::cout &lt;&lt; &quot;6&quot;;
    }

    std::cout &lt;&lt; '\n';
 
    for (int j = 0; j &lt; 2; j++) {
        for (int k = 0; k &lt; 5; k++) {         //only this loop is affected by break
            if (k == 2) break;
            std::cout &lt;&lt; j &lt;&lt; k &lt;&lt; &quot; &quot;;
        }
    }
}
 | output=
2345
00 01 10 11
}}

[[de:cpp/language/break]]
[[es:cpp/language/break]]
[[fr:cpp/language/break]]
[[it:cpp/language/break]]
[[ja:cpp/language/break]]
[[pt:cpp/language/break]]
[[ru:cpp/language/break]]
[[zh:cpp/language/break]]</text>
      <sha1>epf9coohqg4h2hxopkysd93yvj93sh0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/cast operator</title>
    <ns>0</ns>
    <id>13115</id>
    <revision>
      <id>72146</id>
      <parentid>72145</parentid>
      <timestamp>2014-07-19T03:25:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>type aliases also work here</comment>
      <text xml:space="preserve" bytes="5626">{{title|user-defined conversion}}
{{cpp/language/expressions/navbar}}
Enables {{rlp|implicit_cast|implicit conversion}} or {{rlp|explicit_cast|explicit conversion}} from a {{rlp|class|class type}} to another type.

===Syntax===
Conversion function is declared like a {{rlp|member functions|non-static member function}} or member {{rlp|function template}} with no return type and with the name of the form:
{{sdsc begin}}
{{sdsc | num=1 | {{ttb|operator}} {{spar|conversion-type-id}} }}
{{sdsc | num=2 | notes={{mark since c++11}} | {{ttb|explicit}} {{ttb|operator}} {{spar|conversion-type-id}} }}
{{sdsc end}}
@1@ Declares a user-defined conversion function that participates in all implicit and explicit conversions
@2@ Declares a user-defined conversion function that participates in {{rlp|direct_initialization|direct-initialization}} and {{rlp|explicit cast|explicit conversions}} only.

{{spar|conversion-type-id}} is a {{rlp|type#Type_naming|type-id}} except that function and array operators {{ttb|[]}} or {{ttb|()}} are not allowed in its declarator (thus conversion to types such as pointer to array requires a type alias/typedef or an identity template: see below). Regardless of typedef, {{spar|conversion-type-id}} cannot represent an array or a function type.


When such member function is declared in class X, it performs conversion from X to 
{{spar|conversion-type-id}}:
{{source|1=
struct X {
    //implicit conversion
    operator int() const { return 7; }

    // explicit conversion
    explicit operator int*() const { return nullptr; }

//   Error: array operator not allowed in conversion-type-id
//   operator int(*)[3]() const { return nullptr; }
    using arr_t = int[3];
    operator arr_t*() const { return nullptr; } // OK if done through typedef
//  operator arr_t () const; // Error: conversion to array not allowed in any case
};

int main()
{
    X x;

    int n = static_cast&lt;int&gt;(x);   // OK: sets n to 7
    int m = x;                     // OK: sets m to 7

    int* p = static_cast&lt;int*&gt;(x);  // OK: sets p to null
//  int* q = x; // Error: no implicit conversion

    int (*pa)[3] = x;  // OK
}
}}

===Explanation===
User-defined conversion function is invoked on the second stage of the {{rlp|implicit_cast|implicit conversion}}, which consists of zero or one single-argument (converting) constructor or zero or one user-defined conversion function.

If both conversion functions and converting constructors can be used to perform some user-defined conversion, the conversion functions and constructors are both considered by {{rlp|overload resolution}} in {{rlp|copy_initialization|copy-initialization}} and {{rlp|reference_initialization|reference-initialization}} contexts, but only the constructors are considered in {{rlp|direct_initialization|direct-initialization}} contexts.
{{source|1=
struct To {
    To() = default;
    To(const struct From&amp;) {} // converting constructor
};

struct From {
    operator To() const {return To();} // conversion function
};

int main()
{
    From f;
    To t1(f); // direct-initialization: calls the constructor
// (note, if converting constructor is not available, implicit copy constructor
//  will be selected, and conversion function will be called to prepare its argument)
    To t2 = f; // copy-initialization: ambiguous
// (note, if conversion function is from a non-const type, e.g.
//  From::operator To();, it will be selected instead of the ctor in this case)
    To t3 = static_cast&lt;To&gt;(f); // direct-initialization: calls the constructor
    const To&amp; r = f; // reference-initialization: ambiguous
}
}}

Conversion function to its own (possibly cv-qualified) class (or to a reference to it), to the base of its own class (or to a reference to it), and to the type {{c|void}} can be defined, but can not be executed as part of the conversion sequence, except, in some cases, through {{rlp|virtual}} dispatch:
{{source|1=
struct D;
struct B {
    virtual operator D() = 0;
};
struct D : B
{
    operator D() override { return D(); }
};

int main()
{
    D obj;
    D obj2 = obj; // does not call D::operator D()
    B&amp; br = obj;
    D obj3 = br; // calls D::operator D() through virtual dispatch
}
}}

It can also be called using member function call syntax:
{{source|1=
struct B {};
struct X : B {
    operator B&amp;() { return *this; };
};

int main()
{
    X x;
    B&amp; b1 = x;                  // does not call X::operatorB&amp;()
    B&amp; b2 = static_cast&lt;B&amp;&gt;(x); // does not call X::operatorB&amp;
    B&amp; b3 = x.operator B&amp;();    // calls X::operator&amp;
}
}}

When making an explicit call to the conversion function, the type-id is greedy: it is the longest possible sequence of tokens that is a valid type id:
{{source|
&amp; x.operator int * a; // parsed as &amp; (x.operator int*) a
                      // not as &amp; (x.operator int) * a
}}

Conversion functions can be inherited and can be {{rlp|virtual}}, but cannot be {{rlp|static}}. A conversion function in the derived class does not hide a conversion function in the base class unless they are converting to the same type.

Conversion function can be a template member function, for example, [[cpp/memory/auto_ptr/operator_auto_ptr|std::auto_ptr&lt;T&gt;::operator auto_ptr&lt;Y&gt;]]. See {{rlp|member_template#Conversion function templates|member template}} and {{rlp|template argument deduction}} for applicable special rules.

[[de:cpp/language/cast_operator]]
[[es:cpp/language/cast_operator]]
[[fr:cpp/language/cast_operator]]
[[it:cpp/language/cast_operator]]
[[ja:cpp/language/cast_operator]]
[[pt:cpp/language/cast_operator]]
[[ru:cpp/language/cast_operator]]
[[zh:cpp/language/cast_operator]]</text>
      <sha1>6d7u7zsar9fu1ycs69jhu90x8ukvfu6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/character literal</title>
    <ns>0</ns>
    <id>5083</id>
    <revision>
      <id>71236</id>
      <parentid>66837</parentid>
      <timestamp>2014-06-08T20:50:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail</comment>
      <text xml:space="preserve" bytes="2723">{{title|character literal}}
{{cpp/language/expressions/navbar}}
===Syntax===
{{sdsc begin}}
{{sdsc | num = 1| {{ttb|'}} {{spar|c-char}} {{ttb|'}} }}
{{sdsc | num = 2| {{ttb|u}} {{ttb|'}} {{spar|c-char}} {{ttb|'}} {{mark since c++11}} }}
{{sdsc | num = 3| {{ttb|U}} {{ttb|'}} {{spar|c-char}} {{ttb|'}} {{mark since c++11}} }}
{{sdsc | num = 4| {{ttb|L}} {{ttb|'}} {{spar|c-char}} {{ttb|'}} }}
{{sdsc | num = 5| {{ttb|'}} {{spar|c-char-sequence}} {{ttb|'}} }}
{{sdsc end}}
where
* {{spar|c-char}} is either
:* a character from the basic source character set minus single-quote ({{ttb|'}}), backslash ({{ttb|\}}, or the newline character, 
:* escape sequence, as defined in [[cpp/language/escape|escape sequences]]
:* universal character name, as defined in [[cpp/language/escape|escape sequences]]
* {{spar|c-char-sequence}} is a sequence of two or more {{spar|c-char}}s.

@1@ narrow character literal or ordinary character literal, e.g. {{c|'a'}} or {{c|'\n'}} or {{c|'\13'}}. Such literal has type {{c|char}} and the value equal to the representation of {{spar|c-char}} in the execution character set. If {{spar|c-char}} is not representable in the execution character set, the literal has type {{c|int}} and implementation-defined value
@2@ UCS-2 character literal, e.g. {{c|u'貓'}}, but not {{c|u'🍌'}} ({{c|u'\U0001f34c'}}). Such literal has type {{c|char16_t}} and the value equal to the value of {{spar|c-char}} in Unicode, if it is a part of the basic multilingual plane. If {{spar|c-char}} is not part of the BMP, the program is ill-formed.
@3@ UCS-4 character literal, e.g. {{c|U'貓'}} or {{c|U'🍌'}}. Such literal has type {{c|char32_t}} and the value equal to the value of {{spar|c-char}} in Unicode.
@4@ wide character literal, e.g. {{c|L'β'}} or {{c|L'貓}}. Such literal has type {{c|wchar_t}} and the value equal to the value of {{spar|c-char}} in the execution wide character set. If {{spar|c-char}} is not representable in the execution character set (e.g. a non-BMP value on Windows where wchar_t is 16-bit), the value of the literal is implementation-defined.
@5@ Multicharacter literal, e.g. {{c|'AB'}}, has type {{c|int}} and implementation-defined value.

===Notes===
Many implementations of multicharacter literals use the values of each char in the literal to initialize successive bytes of the resulting integer, in big-endian order, e.g. the value of {{c|'\1\2\3\4'}} is {{c|0x1020304}}

[[de:cpp/language/character literal]]
[[es:cpp/language/character literal]]
[[fr:cpp/language/character literal]]
[[it:cpp/language/character literal]]
[[ja:cpp/language/character literal]]
[[pt:cpp/language/character literal]]
[[ru:cpp/language/character literal]]
[[zh:cpp/language/character literal]]</text>
      <sha1>sqbu2tg3xuhd31yg313cc9pl3k9odls</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/class</title>
    <ns>0</ns>
    <id>5296</id>
    <revision>
      <id>71168</id>
      <parentid>67456</parentid>
      <timestamp>2014-06-07T07:05:55Z</timestamp>
      <contributor>
        <ip>91.115.11.61</ip>
      </contributor>
      <comment>Closed opened parentheses in section &quot;Local classes&quot;</comment>
      <text xml:space="preserve" bytes="7742">{{title|Class declaration}}
{{cpp/language/classes/navbar}}
Classes and structs are user-defined types, defined by class-specifier, which appears in {{spar|decl-specifier-seq}} of the {{rlp|declarations|declaration}} syntax. The class specifier has the following syntax:

{{sdsc begin}}
{{sdsc|1=
{{spar|class-key}} {{spar|attr}} {{spar|class-head-name}} {{spar|base-clause}} {{ttb|{ }} {{spar|member-specification}} {{ttb|} }}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|class-key}} | one of [[cpp/keyword/class|class]] or [[cpp/keyword/struct|struct]].  The keywords are identical except for the default {{rlp|access|member access}} and the default {{rlp|derived class|base class access}}.}} 
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|class-head-name}} | the name of the class that's being defined. Optionally prepended by {{spar|nested-name-specifier}} (sequence of names and scope-resolution operators, ending with scope-resolution operator), optionally followed by keyword [[cpp/keyword/final|final]]. The name may be omitted, in which case the class is unnamed (note that unnamed class cannot be final) }}
{{par | {{spar|base-clause}} | optional list of one or more parent classes and the model of inheritance used for each (see {{rlp|derived_class|derived class}}) }}
{{par | {{spar|member-specification}} | list of access specifiers, member object and member function declarations and definitions (see below)}}
{{par end}}

See {{rlp|classes}} for general overview of the syntax. If {{spar|class-key}} is {{tt|union}}, the declaration introduces a {{rlp|union|union type}}. 

===Forward declaration===
A declaration of the following form
{{sdsc begin}}
{{sdsc|1=
{{spar|class-key}} {{spar|attr}} {{spar|identifier}} {{ttb|;}}
}}
{{sdsc end}}

Declares a class or struct which will be defined later in this scope. Until the definition appears, this class name has {{rlp|incomplete type}}. This allows classes that refer to each other:
{{source|class Vector; // forward declaration
class Matrix {
    // ...
    friend Vector operator*(const Matrix&amp;, const Vector&amp;);
};
class Vector {
    // ...
    friend Vector operator*(const Matrix&amp;, const Vector&amp;);
};
}}
and if a particular source file only uses pointers and references to the class, this makes it possible to reduce #include dependencies:
{{source|// in MyStruct.h 
#include &lt;iosfwd&gt; // contains forward declaration of std::ostream
struct MyStruct {
    int value;
    friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const S&amp; s);
    // definition provided in MyStruct.cpp file which uses #include &lt;ostream&gt;
};
}}

If forward declaration appears in local scope, it ''hides'' previously declared class, variable, function, and all other declarations of the same name that may appear in enclosing scopes:
{{source|struct s { int a; };
struct s; // does nothing (s already defined in this scope)
void g() {
    struct s; // forward declaration of a new, local struct &quot;s&quot;
              // this hides global struct s until the end of this block
    s* p;     // pointer to local struct s
    struct s { char* p; }; // definitions of the local struct s
}
}}

A forward declaration may also appear as part of another declaration, in particular, in a parameter declaration of a function or in a {{spar|decl-specifier-seq}} of a {{rlp|declarations|simple declaration}}.
{{source|1=
class Y f(class T p); // declares function f and forward-declares T and Y
Y* p; // Y is a forward-declared class
T* q; // T is a forward-declared class
}}
{{source|1=
std::array&lt;class T, 2&gt;* p; // forward-declares class T
T* q; // pointers to T can be defined
}}

===Member specification===
The member specification, or the ''body'' of a class definition, is a brace-enclosed sequence of any number of the following:
@1@ Member declarations, which are {{rlp|declarations}} of {{rlp|static}} and non-static {{rlp|data members}} and {{rlp|member functions}}, {{rlp|typedef}} declarations, scoped and unscoped {{rlp|enum|enumerations}}, and other, {{rlp|nested_types|nested}}, class declarations. 
{{source|1=class S {
    int d1; // non-static data member
    int a[10] = {1,2}; // non-static data member with initializer (C++11)
    static const int d2 = 1; // static data member with initializer
    virtual void f1(int) = 0; // pure virtual member function
    std::string d3, *d4, f2(int); // two data members and a member function
    enum {NORTH, SOUTH, EAST, WEST};
    struct NestedS {
        std::string s;
    } d5, *d6;
    typedef NestedS value_type, *pointer_type;
};
}}
@2@ Function definitions, which both declare and define {{rlp|member functions}}. A semicolon after a member function definition is optional. All member functions that are defined inside a class body are automaticaly {{rlp|inline}}.
{{source|class M {
    std::size_t C;
    std::vector&lt;int&gt; data;
 public:
    M(std::size_t R, std::size_t C) : C(C), data(R*C) {} // constructor definition 
    int operator()(size_t r, size_t c) const { // member function definition
        return data[r*C+c];
    }
    int&amp; operator()(size_t r, size_t c) {  // another member function definition
        return data[r*C+c];
    }
};
}}
@3@ {{rlp|access|Access specifiers}} {{tt|public:}}, {{tt|protected:}}, and {{tt|private:}}
{{source|class S {
 public:
    S();          // public constructor
    S(const S&amp;);  // public copy constructor
    virtual ~S(); // public virtual destructor
 private:
    int* ptr; // private data member
};}}
@4@ {{rlp|using_declaration|Using-declarations}}
{{source|class Base {
 protected:
     int d;
};
class Derived : public Base {
 public:
    using Base::d; // make Base's protected member d a public member of Derived
    using Base::Base; // inherit all parent's constructors (C++11)
};
}}
@5@ {{rlp|static_assert}} declarations
{{source|template&lt;typename T&gt;
struct Foo {
  static_assert(std::is_floating_point&lt;T&gt;::value, &quot;Foo&lt;T&gt;: T must be floating point&quot;);
};
}}
@6@ {{rlp|member_template|member template declarations}}
{{source|struct S {
    template&lt;typename T&gt;
    void f(T&amp;&amp; n);

    template&lt;class CharT&gt;
    struct NestedS {
        std::basic_string&lt;CharT&gt; s;
    };
};
}}
@7@ {{rlp|type_alias|alias declarations}}
{{source|1=template &lt;typename T&gt;
struct identity
{
    using type = T;
};
}}

===Local classes===
A class declaration can appear in namespace scope (in which case it defines an ordinary class), inside another class definition (in which case it defines a {{rlp|nested_types|nested type}}), and inside the body of a function, in which case it defines a ''local class''. This class only exists within the function scope, and is not accessible outside.

* A local class cannot have static members
* Member functions of a local class have no linkage
* Member functions of a local class have to be defined entirely inside the class body
* Local classes cannot have member templates or friend templates
* A local class inside a function (including member function) can access the same names that the enclosing function can access.
{{rev begin}}
{{rev | until=c++11 |
* local classes could not be used as template arguments
}}
{{rev end}}
{{example
 |code=
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;int&gt; v{1,2,3};
    struct Local {
       bool operator()(int n, int m) {
           return n &gt; m;
       }
    };
    std::sort(v.begin(), v.end(), Local()); // since C++11
    for(int n: v) std::cout &lt;&lt; n &lt;&lt; ' ';
}
|output=3 2 1
}}

[[de:cpp/language/class]]
[[es:cpp/language/class]]
[[fr:cpp/language/class]]
[[it:cpp/language/class]]
[[ja:cpp/language/class]]
[[pt:cpp/language/class]]
[[ru:cpp/language/class]]
[[zh:cpp/language/class]]</text>
      <sha1>25w3znhtx1qa0g29lqohg1cnx7b7zkg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/class template</title>
    <ns>0</ns>
    <id>5065</id>
    <revision>
      <id>72401</id>
      <parentid>72398</parentid>
      <timestamp>2014-08-19T14:17:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mirror other template ledes</comment>
      <text xml:space="preserve" bytes="6949">{{title|Class template}}
{{cpp/language/templates/navbar}}

A class template defines a family of classes.

===Syntax===
{{sdsc begin}}
{{sdsc|num=1|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|declaration}} }}
{{sdsc|num=2|{{ttb|export}} {{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|declaration}}|notes={{mark until c++11}}}}
{{sdsc end}}

===Explanation===
{{spar|declaration}} defines or declares a class (including struct and union), a {{rlp|member template|member class or member enumeration type}}, a {{rlp|function template|function}} or {{rlp|member template|member function}}, a static data member at namespace scope, {{rev inl|since=c++14|{{rlp|variable template|a variable or static data member at class scope}},}} {{rev inl|since=c++11|or a [[cpp/language/type_alias|alias template]]}} It may also define a [[cpp/language/template_specialization|template specialization]]. This page focuses on class templates.

{{spar|parameter-list}} is a non-empty comma-separated list of the {{rlp|template parameters}}, each of which is either non-type parameter, a type parameter, a template parameter, or a [[cpp/language/parameter_pack|parameter pack]] of any of those.

{{mark until c++11}}{{tt|export}} was an optional modifier which declared the template as ''exported'' (when used with a class template, it declared all of its members exported as well). Files that instantiated exported templates did not need to include their definitions: the declaration was sufficient. Implementations of {{tt|export}} were rare and disagreed with each other on details.

===Class template instantiation===
A class template by itself is not a type, or an object, or any other entity. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated: the template arguments must be provided so that the compiler can generate an actual class (or function, from a function template).
====Explicit instantiation====
{{sdsc begin}}
{{sdsc|num=1|{{ttb|template}} {{spar|class}} {{spar|name}} {{ttb|&lt;}} {{spar|argument-list}} {{ttb|&gt; ;}} }}
{{sdsc|num=2|{{ttb|extern}} {{ttb|template}} {{spar|class}} {{spar|name}} {{ttb|&lt;}} {{spar|argument-list}} {{ttb|&gt; ;}}|notes={{mark since c++11}}}}
{{sdsc end}}
@1@ Explicit instantiation definition
@2@ Explicit instantiation declaration

An explicit instantiation definition forces instantiation of the class, struct, or union they refer to. It may appear in the program anywhere after the template definition, and for a given argument-list, is only allowed to appear once in the entire program.

{{rev begin}}
{{rev|since=c++11|
An explicit instantiation declaration (an extern template) prevents implicit instantiations: the code that would otherwise cause an implicit instantiation has to use the explicit instantiation definition provided somewhere else in the program (typically, in another file: this can be used to reduce compilation times)}}
{{rev end}}

Classes, functions, variables, and member template specializations can be explicitly instantiated from their templates. Member functions, member classes, and static data members of class templates can be explicitly instantiated from their member definitions.

Explicit instantiation can only appear in the enclosing namespace of the template, unless it uses qualified-id:
{{source|1=
namespace N {
  template&lt;class T&gt; class Y { void mf() { } }; // template definition
}
// template class Y&lt;int&gt;; // error: class template Y not visible in the global namespace
using N::Y;
// template class Y&lt;int&gt;; // error: explicit instantiation outside 
                          // of the namespace of the template
template class N::Y&lt;char*&gt;;      // OK: explicit instantiation
template void N::Y&lt;double&gt;::mf(); // OK: explicit instantiation
}}

Explicit instantiation has no effect if an {{rlp|template specialization|explicit specialization}} appeared before for the same set of template arguments.

Only the declaration is required to be visible when explicitly instantiating a function template, a variable template, a member function or static data member of a class template, 
or a member function template. The complete definition must appear before the explicit instantiation of a class template, a member class of a class template, or a member class
template, unless an explicit specialization with the same template arguments appeared before.

If a function template, variable template, member function template, or member function or static data member of a class template is explicitly instantiated with an explicit instantiation definition, the template definition must be present in the same translation unit.

When an explicit instantiation names a class template specialization, it serves as an explicit instantiation of the same kind (declaration or definition) of each of its non-inherited non-template members that has not been previously explicitly specialized in the translation unit. If this explicit instantiation is a definition, is is also an explicit instantiation definition only for the members that have been defined at this point.

Explicit instantiation definitions ignore member access specifiers: parameter types and return types may be private.

====Implicit instantiation====
When code refers to a template in context that requires a completely defined type, or when the completeness of the type affects the code, and this particular type has not been explicitly instantiated, implicit instantiation occurs. For example, when an object of this type is constructed, but not when a pointer to this type is constructed.

This applies to the members of the class template: unless the member is used in the program, it is not instantiated, and does not require a definition.

{{source|1=
template&lt;class T&gt; struct Z {
    void f() {}
    void g(); // never defined
}; // template definition
template struct Z&lt;double&gt;; // explicit instantiation of Z&lt;double&gt;
Z&lt;int&gt; a; // implicit instantiation of Z&lt;int&gt;
Z&lt;char&gt;* p; // nothing is instantiated here
p-&gt;f(); // implicit instantiation of Z&lt;char&gt; and Z&lt;char&gt;::f() occurs here.
// Z&lt;char&gt;::g() is never needed and never instantiated: it does not have to be defined
}}

===See also===
* {{rlp|template_parameters | template parameters and arguments}} allow templates to be parametrized
* {{rlp|function_template | function template declaration}} declares a function template
* {{rlp|template_specialization | template specialization}} defines an existing template for a specific type
* {{rlp|parameter_pack | parameter packs}} allows the use of lists of types in templates {{mark since c++11}}

[[de:cpp/language/class template]]
[[es:cpp/language/class template]]
[[fr:cpp/language/class template]]
[[it:cpp/language/class template]]
[[ja:cpp/language/class template]]
[[pt:cpp/language/class template]]
[[ru:cpp/language/class template]]
[[zh:cpp/language/class template]]</text>
      <sha1>duisfo6574zoffyh1n4sqgc3j6zdlnj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/classes</title>
    <ns>0</ns>
    <id>9899</id>
    <revision>
      <id>67454</id>
      <parentid>65296</parentid>
      <timestamp>2014-02-09T21:08:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+navbar</comment>
      <text xml:space="preserve" bytes="3744">{{title|Classes}}
{{cpp/language/classes/navbar}}
A class is a user-defined type.

A class type is defined by class-specifier, which appears in {{spar|decl-specifier-seq}} of the {{rlp|declarations|declaration}} syntax. The class specifier has the following syntax:

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|class-key}} {{spar|attr}} {{spar|class-head-name}} {{spar|base-clause}} {{ttb|{ }} {{spar|member-specification}} {{ttb|} }}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|class-key}} | one of [[cpp/keyword/class|class]], [[cpp/keyword/struct|struct]], [[cpp/keyword/union|union]]}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|class-head-name}} | the name of the class that's being defined. Optionally prepended by {{spar|nested-name-specifier}} (sequence of names and scope-resolution operators, ending with scope-resolution operator), optionally followed by keyword [[cpp/keyword/final|final]]. The name may be omitted, in which case the class is unnamed (note that unnamed class cannot be final) }}
{{par | {{spar|base-clause}} | optional list of one or more parent classes and the model of inheritance used for each (see {{rlp|derived_class|derived class}}) }}
{{par | {{spar|member-specification}} | list of access specifiers, member object and member function declarations and definitions (see {{rlp|class|class definition}})}}
{{par end}}

The class keys {{tt|struct}} and {{tt|class}} are indistinguishable in C++, except that the default {{rlp|access|access mode}} and default {{rlp|derived class|inheritance mode}} are {{tt|public}} if class declaration uses the {{tt|struct}} class-key and {{tt|private}} if the class declaration uses the {{tt|class}} class-key. Both {{tt|class}} and {{tt|struct}} can be used in a {{rlp|class|class definition}}.

The use of the class key {{tt|union}} results in a {{rlp|union|union definition}}, which defines a class that holds only one of its data members at a time.

A class can have four kinds of members
@1@ {{rlp|data_members|data members}}
:@a@ non-static data members, including {{rlp|bit_field|bit fields}}.
:@b@ {{rlp|static}} data members
@2@ {{rlp|member_functions|member functions}}
:@a@ non-static member functions
:@b@ {{rlp|static}} member functions
@3@ {{rlp|nested_types|nested types}}
:@a@ nested classes and enumerations defined within the class definition
:@b@ aliases of existing types, defined with typedef or type alias declarations
@4@ {{rlp|enum|enumerators}} from all unscoped enumerations defined within the class

All members are defined at once in the class definition, they cannot be added later.

A class with at least one declared or inherited {{rlp|virtual}} member function is ''polymorphic''. Objects of this type have runtime type information stored as part of the object, which may be queried with {{rlp|dynamic_cast}} and {{rlp|typeid}}, and the virtual member functions participate in dynamic binding.

A class with at least one declared or inherited pure virtual member function is an {{rlp|abstract_class|abstract class}}. Objects of this type cannot be created.

A class with a {{rlp|constexpr}} constructor is a ''literal type'': objects of this type can be manipulated by {{rlp|constexpr}} functions at compile time.

Some member functions are special: under certain circumstances they are defined by the compiler even if not defined by the user. They are:
* {{rlp|default_constructor|Default constructor}}
* {{rlp|copy_constructor|Copy constructor}}
* {{rlp|move_constructor|Move constructor}} {{mark since c++11}}
* {{rlp|as_operator|Copy assignment operator}}
* {{rlp|move_operator|Move assignment operator}} {{mark since c++11}}
* {{rlp|destructor|Destructor}}</text>
      <sha1>lfo87doni3msayvni3xr1xwja8ccdj7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/const cast</title>
    <ns>0</ns>
    <id>2741</id>
    <revision>
      <id>72372</id>
      <parentid>72371</parentid>
      <timestamp>2014-08-16T02:20:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>long line</comment>
      <text xml:space="preserve" bytes="2981">{{title|const_cast conversion}}
{{cpp/language/expressions/navbar}}
Converts between types with different cv-qualification.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|const_cast &amp;lt;}} {{spar|new_type}} {{ttb|&amp;gt; (}} {{spar|expression}} {{ttb|)}} }}
{{sdsc end}}

Returns a value of type {{tt|new_type}}.

===Explanation===

Only the following conversions can be done with {{c|const_cast}}. In particular, only {{c|const_cast}} may be used to cast away (remove) constness or volatility.

@1@ Two possibly multilevel pointers to the same type may be converted between each other, regardless of cv-qualifiers at each level.
@2@ lvalue of any type {{tt|T}} may be converted to a lvalue or rvalue reference to the same type {{tt|T}}, more or less cv-qualified. Likewise, an rvalue may be converted to a more or less cv-qualified rvalue reference.
@3@ Same rules apply to possibly multilevel pointers to data members.
@4@ null pointer value may be converted to the null pointer value of {{spar|new_type}}

{{cpp/language/cast_return}}

===Notes===
Pointers to functions and pointers to member functions are not subject to {{c|const_cast}}

Even though {{c|const_cast}} may remove constness or volatility from any pointer or reference, using the resulting pointer or reference to write to an object that was declared {{c|const}} or to access an object that was declared {{c|volatile}} invokes undefined behavior.

===Keywords===

{{ltt|cpp/keyword/const_cast}}

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;

struct type {
    type() :i(3) {}
    void m1(int v) const {
        // this-&gt;i = v;                 // compile error: this is a pointer to const
        const_cast&lt;type*&gt;(this)-&gt;i = v; // OK as long as the type object isn't const
    }
    int i;
};

int main() 
{
    int i = 3;                    // i is not declared const
    const int&amp; cref_i = i; 
    const_cast&lt;int&amp;&gt;(cref_i) = 4; // OK: modifies i
    std::cout &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; '\n';

    type t; // note, if this is const type t;, then t.m1(4); is UB
    t.m1(4);
    std::cout &lt;&lt; &quot;type::i = &quot; &lt;&lt; t.i &lt;&lt; '\n';

    const int j = 3; // j is declared const
    int* pj = const_cast&lt;int*&gt;(&amp;j);
    *pj = 4;         // undefined behavior!

    void (type::*mfp)(int) const = &amp;type::m1; // pointer to member function
//  const_cast&lt;void(type::*)(int)&gt;(mfp); // compiler error: const_cast does not
                                         // work on function pointers
}
 | output=
i = 4
type::i = 4
}}

===See also===
* [[cpp/language/static_cast|static_cast]]
* [[cpp/language/dynamic_cast|dynamic_cast]]
* [[cpp/language/reinterpret_cast|reinterpret_cast]]
* [[cpp/language/explicit_cast|explicit cast]]
* [[cpp/language/implicit_cast|implicit conversions]]

[[de:cpp/language/const cast]]
[[es:cpp/language/const cast]]
[[fr:cpp/language/const cast]]
[[it:cpp/language/const cast]]
[[ja:cpp/language/const cast]]
[[pt:cpp/language/const cast]]
[[ru:cpp/language/const cast]]
[[zh:cpp/language/const cast]]</text>
      <sha1>80r603etsuax7emo89ay9qhaljxecpu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/constant expression</title>
    <ns>0</ns>
    <id>12830</id>
    <revision>
      <id>72460</id>
      <parentid>72459</parentid>
      <timestamp>2014-08-22T22:10:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>that made it more confusing I think.. let's see if this can be made more colloquial without losing clarity</comment>
      <text xml:space="preserve" bytes="6144">{{title|Constant expressions}}
{{cpp/language/expressions/navbar}}

Defines an {{rlp|expressions|expression}} that can be evaluated at compile time.

Such expressions can be used as non-type template arguments, array sizes, and in other contexts that require constant expressions, e.g.
{{source|1=
int n = 1;
std::array&lt;int, n&gt; a1; // error, n is not a constant expression
const int cn = 2;
std::array&lt;int, cn&gt; a2; // OK, cn is a constant expression
}}

===Core constant expressions===
A ''core constant expression'' is any expression that ''does not'' have any one of the following in any subexpression (ignoring the unevaluated arguments of {{c|&amp;&amp;}}, {{c|{{!!}}}}, and {{c|?:}})
@1@ A function call expression that calls a function (or a constructor) that is not declared {{rlp|constexpr}} 
{{source|1=
constexpr int n = std::numeric_limits&lt;int&gt;::max(); // OK, max() is constexpr
constexpr int m = std::time(NULL); // Error: std::time() is not constexpr
}}
@2@ A function call to a {{tt|constexpr}} function which is declared, but not defined, if the function call itself is not made inside the body of a {{tt|constexpr}} function.
@3@ A function call to a {{tt|constexpr}} function with arguments that do not produce a constant expression when substituted
{{source|1=
constexpr const int* addr(const int&amp; ir) { return &amp;ir; }
static const int x = 5;
constexpr const int* xp = addr(x); // OK
constexpr const int* tp = addr(5); // error: &amp;5 is not a constant expression
}}
@4@ A function call to a {{tt|constexpr}} function with arguments that do not produce constant expressions in member-initializer lists that are called from this function
{{source|1=
int x;
struct A {
    constexpr A(bool b) : m(b?42:x) { }
    int m;
};
constexpr int v = A(true).m; // OK
constexpr int w = A(false).m; // error: non-const x 
}}
@5@ A function call to a recursive {{tt|constexpr}} function that would exceed compile-time recursion depth limit (implementation-defined)
@6@ The {{rlp|this}} pointer except if used for class member access inside a non-static member function.

{{rev begin}}
{{rev|until=c++14|
@7@ An expression whose result is not mathematically defined or is out of range for its type.
{{source|1=
constexpr double d1 = 2.0/1.0; // OK
constexpr double d2 = 2.0/0.0; // Error: not defined
constexpr int n = std::numeric_limits&lt;int&gt;::max() + 1; // Error: overflow
}}
}}
{{rev|since=c++14|
@7@ An expression whose evaluation leads to any form of undefined behavior (including signed integer overflow, division by zero, pointer arithmetic outside array bounds, etc)
}}
{{rev end}}
@8@ A {{rlp|lambda|lambda expression}}
@9@ An lvalue-to-rvalue {{rlp|implicit_cast|implicit conversion}} applied to a non-active member of a {{rlp|union}} or its subobject
@10@ Any other lvalue-to-rvalue {{rlp|implicit_cast|implicit conversion}}, unless the lvalue...
:@a@ has integral or enumeration type, is non-volatile const, and is initialized with a constant expression, or an array of such (including a string literal)
:@b@ has literal type and refers to a non-volatile object defined with {{tt|constexpr}} or to its non-mutable subobject
:@c@ has literal type and refers to a non-volatile temporary, initialized with a constant expression
@11@ a reference to a variable unless it was initialized with a constant expression or is a non-static data member of a temporary object whose lifetime begain within this expression

{{rev begin}}
{{rev|since=c++14|
@12@ conversion from ''cv'' {{c|void*}} to any pointer-to-object type
}}
{{rev end}}
@13@ {{rlp|dynamic_cast}}
@14@ {{rlp|reinterpret_cast}}
@15@ pseudo-destructor call
@16@ an increment or a decrement operator
@17@ a {{rlp|typeid}} expression applied to a glvalue of polymorphic type
@18@ a new-expression or a delete-expression
@19@ a subtraction operator between two pointers
@20@ an equality or relational operator when the result is unspecified
@21@ an assignment or a compount assignment operator
@22@ a throw expression

{{todo|needs more mini-examples and less standardese}}

===Constant expression===
* ''Integral constant expression'' is an expression of integral or unscoped enumeration type implicitly converted to a prvalue, where the converted expression is a core constant expression.
: only integral constant expressions can be used as {{rlp|bit_field|bit-field lengths}}, enumeration initializers when the underlying type is not fixed, null-pointer constants, and alignments
* ''Converted constant expression'' is an expression implicitly converted to prvalye of type T, where the converted expression is a core constant expression. If the literal constant expression has class type, it is {{rlp|implicit cast|contextually implicitly converted}} to the expected integral or unscoped enumeration type with a {{tt|constexpr}} user-defined conversion function.
: only converted constant expressions can be used as case expressions, enumerator initializers when the underlying type is fixed, array bounds, the dimensions in new-expressions other than the first, and as integral and enumeration non-type template arguments

* ''Literal constant expression'' is a prvalue ''core constant expression'' of non-pointer literal type (after conversions as required by context). A literal constant expression of array or class type requires that each subobject is initialized with a constant expression.
* ''Reference constant expression'' is an lvalue core constant expression that designates an object with static storage duration or a function
* ''Address constant expression'' is a prvalue core constant expression (after conversions required by context) of type {{c|std::nullptr_t}} or of a pointer type, which points to an object with static storage duration, one past the end of an array with static storage duration, to a function, or is a null pointer. 

===Notes===
{{rev begin}}
{{rev|since=c++14|Implementations are not permitted to declare library functions as {{tt|constexpr}} unless the standard says the function is {{tt|constexpr}} }} &lt;!-- this was LWG #2013 --&gt;
{{rev end}}

{{todo|examples}}

===See also===
* {{rlp|constexpr|constexpr specifier}}
* {{c|std::is_literal_type}}</text>
      <sha1>plb41k27f6ijshxpxdtcs6q3laxmbex</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/constant initialization</title>
    <ns>0</ns>
    <id>8870</id>
    <revision>
      <id>71426</id>
      <parentid>69043</parentid>
      <timestamp>2014-06-11T02:42:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>CWG 1489 (clarification of existing rule, no need to tag c++14)</comment>
      <text xml:space="preserve" bytes="3247">{{title|constant initialization}}
{{cpp/language/initialization/navbar}}
Sets the initial values of the static constants

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|static}} {{spar|T}} {{ttb|&amp;}} {{spar|ref}} {{ttb|{{=}} {{spar|constexpr}};}}}}
{{sdsc | num=2 | {{ttb|static}} {{spar|T}} {{spar| object}} {{ttb|{{=}} {{spar|constexpr}};}}}}
{{sdsc end}}

===Explanation===

Constant initialization is performed after zero initialization of the static and thread-local objects and before all other initialization. Only the following variables are constant initialized:
@1@ Static or thread-local references, if it is bound to static lvalue, to a temporary, or to a function. and if every expression (including implicit conversions) in [[cpp/language/reference_initialization|the initializer]] of the reference is a [[cpp/language/constant_expression|constant expression]].
@2@ Static or thread-local object of class type that is initialized by a constructor call, if the constructor is {{c|constexpr}} and all constructor arguments (including implicit conversions) are constant expressions, and if the initializers in the constructor's initializer list and the brace-or-equal initializers of the class memebers only contain constant expressions.
@3@ Static or thread-local object (not necessarily of class type), that is not initialized by a constructor call, if the object is {{rlp|value initialization|value-initialized}} or if every expression in its initializer is a constant expression.

The effects of constant initialization are the same as the effects of the corresponding initialization, except that it's guaranteed that it is complete before any other initialization of a static or thread-local object begins, and it may be performed at compile time.

The object that was initialized by constant initialization can be used in constant expressions, e.g. in an array declaration.

===Notes===
The compiler is permitted to initialize other static and thread-local objects using constant initialization, if it can guarantee that the value would be the same as if the standard order of initialization was followed. Such objects can be used in constant expressions, but this use is not portable.

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;array&gt;

struct S {
    static const int c;
};
const int d = 10 * S::c; // not a constant expression: S::c has no preceding
                         // initializer, this initialization happens after const
const int S::c = 5;      // constant initialization, guaranteed to happen first
int main()
{
    std::cout &lt;&lt; &quot;d = &quot; &lt;&lt; d &lt;&lt; '\n';
    std::array&lt;int, S::c&gt; a1; // OK: S::c is a constant expression
//  std::array&lt;int, d&gt; a2;    // error: d is not a constant expression
}
 | output=
d = 50
}}

===See also===
* [[cpp/language/constexpr|constexpr specifier]]
* [[cpp/language/zero_initialization|zero initialization]]

[[de:cpp/language/constant initialization]]
[[es:cpp/language/constant initialization]]
[[fr:cpp/language/constant initialization]]
[[it:cpp/language/constant initialization]]
[[ja:cpp/language/constant initialization]]
[[pt:cpp/language/constant initialization]]
[[ru:cpp/language/constant initialization]]
[[zh:cpp/language/constant initialization]]</text>
      <sha1>6a1n3x2sfws0kzs9wtemlvqr83zeag8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/constexpr</title>
    <ns>0</ns>
    <id>689</id>
    <revision>
      <id>72138</id>
      <parentid>72133</parentid>
      <timestamp>2014-07-18T11:47:42Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Explanation */ wording</comment>
      <text xml:space="preserve" bytes="6699">{{title|constexpr specifier {{mark since c++11}}}}
{{cpp/language/declarations/navbar}}
:*{{ttb|constexpr}} - specifies that the value of a variable or function can appear in {{rlp|constant expression}}s

===Explanation===

The {{tt|constexpr}} specifier declares that it is possible to evaluate the value of the function or variable at compile time. Such variables and functions can then be used where only compile time {{rlp|constant_expression|constant expressions}} are allowed. A {{c|constexpr}} specifier used in an object declaration implies {{c|const}}. A {{c|constexpr}} specifier used in an function declaration implies {{c|inline}}.

A '''{{c|constexpr}} variable''' must satisfy the following requirements:

:* its type must be a {{concept|LiteralType}}.
:* it must be immediately constructed or assigned a value.
:* the constructor parameters or the value to be assigned must contain only literal values, {{tt|constexpr}} variables and functions.
:* the constructor used to construct the object (either implicit or explicit) must satisfy the requirements of {{tt|constexpr}} constructor. In the case of explicit constructor, it must have {{c|constexpr}} specified. 

A '''{{c|constexpr}} function''' must satisfy the following requirements:

:* it must not be {{rlp|virtual}}
:* its return type must be {{concept|LiteralType}}
:* each of its parameters must be literal type
{{rev begin}}
{{rev|until=c++14|
:* the function body must be either deleted or defaulted or contain only the following:
::* null statements
::* {{rlp|static_assert}} declarations
::* {{rlp|typedef}} declarations and {{rlp|type_alias|alias}} declarations that do not define classes or enumerations
::* {{rlp|namespace#Using-declarations|using declarations}}
::* {{rlp|namespace#Using-directives|using directives}}
::* exactly one {{rlp|return}} statement.
}}{{rev|since=c++14|
:* the function body must be either deleted or defaulted or contain '''any statements except''':
::* an {{rlp|asm|asm declaration}}
::* a {{rlp|goto}} statement
::* a {{rlp|try catch|try-block}}
::* a definition of a variable of non-literal type or of static or thread {{rlp|storage duration}} or for which no initialization is performed.
}}
{{rev end}}

A '''{{c|constexpr}} constructor''' must satisfy the following requirements:

:* each of its parameters must be literal type
:* the class must have no virtual base classes
:* the constructor must not have a {{rlp|function-try-block}}
{{rev begin}}
{{rev|until=c++14|
:* the constructor body must be either deleted or defaulted or contain only the following:
::* null statements
::* {{rlp|static_assert}} declarations
::* {{rlp|typedef}} declarations and {{rlp|type_alias|alias}} declarations that do not define classes or enumerations
::* using declarations
::* using directives
:* every base class and every non-static member must be initialized, either in the constructors initialization list or by a member brace-or-equal initializer. In addition, every constructor involved must be a constexpr constructor and every clause of every brace-or-equal initializer must be a constant expression
}}{{rev|since=c++14|
:* the constructor body must be either deleted or defaulted or satisfy the following constraints:
::* the compound statement of the constructor body must satisfy the constraints for the body of a constexpr function
::* for the constructor of a {{rlp|class|class or struct}}, every base class sub-object and every {{rlp|union#Union-like classes|non-variant}} non-static data member must be initialized. If the class is a {{rlp|union#Union-like classes|union-like class}}, for each of its non-empty anonymous union members, exactly one variant member must be initialized
::* for the constructor of a non-empty {{rlp|union}}, exactly one non-static data member must be initialized
::* every constructor selected to initializing non-static members and base class must be a constexpr constructor.
}}
{{rev end}}

A non-template, non-defaulted {{tt|constexpr}} function or a non-template, non-defaulted, non-inheriting {{tt|constexpr}} constructor must yield a {{rlp|constant expression#Core constant expressions|core constant expression}} when appropriate arguments are provided. 

At least one specialization of a {{tt|constexpr}} {{rlp|function template}} must satisfy the above requirements. Other specializations are still considered {{tt|constexpr}} even though it is impossible to call them in a constant expression.

Note that if a {{tt|constexpr}} function is called in an constant expression, its executed branch must meet the requirements for {{rlp|constant expression}}s. For example, the executed branch must not contain an invocation of a non-{{tt|constexpr}} function.

===Keywords===

{{ltt|cpp/keyword/constexpr}}

===Example===
{{example |
Definition of a constexpr function which computes factorials and a literal type that extends string literals:
 | code=
#include &lt;iostream&gt;
#include &lt;stdexcept&gt;

// constexpr functions use recursion rather than iteration
constexpr int factorial(int n)
{
    return n &lt;= 1 ? 1 : (n * factorial(n-1));
}

// literal class
class conststr {
    const char * p;
    std::size_t sz;
 public:
    template&lt;std::size_t N&gt;
    constexpr conststr(const char(&amp;a)[N]) : p(a), sz(N-1) {}
    // constexpr functions signal errors by throwing exceptions from operator ?:
    constexpr char operator[](std::size_t n) const {
        return n &lt; sz ? p[n] : throw std::out_of_range(&quot;&quot;);
    }
    constexpr std::size_t size() const { return sz; }
};

constexpr std::size_t countlower(conststr s, std::size_t n = 0,
                                             std::size_t c = 0) {
    return n == s.size() ? c :
           s[n] &gt;= 'a' &amp;&amp; s[n] &lt;= 'z' ? countlower(s, n+1, c+1) :
           countlower(s, n+1, c);
}

// output function that requires a compile-time constant, for testing
template&lt;int n&gt; struct constN {
    constN() { std::cout &lt;&lt; n &lt;&lt; '\n'; }
};

int main()
{
    std::cout &lt;&lt; &quot;4! = &quot; ;
    constN&lt;factorial(4)&gt; out1; // computed at compile time

    volatile int k = 8; // disallow optimization using volatile
    std::cout &lt;&lt; k &lt;&lt; &quot;! = &quot; &lt;&lt; factorial(k) &lt;&lt; '\n'; // computed at run time

    std::cout &lt;&lt; &quot;Number of lowercase letters in \&quot;Hello, world!\&quot; is &quot;;
    constN&lt;countlower(&quot;Hello, world!&quot;)&gt; out2; // implicitly converted to conststr
}
 | output=
4! = 24
8! = 40320
Number of lowercase letters in &quot;Hello, world!&quot; is 9
}}

===See also===
* {{rlp|constant expression}}

[[de:cpp/language/constexpr]]
[[es:cpp/language/constexpr]]
[[fr:cpp/language/constexpr]]
[[it:cpp/language/constexpr]]
[[ja:cpp/language/constexpr]]
[[pt:cpp/language/constexpr]]
[[ru:cpp/language/constexpr]]
[[zh:cpp/language/constexpr]]</text>
      <sha1>m1t37pjjnej8s4qm0secsows49y7jn9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/continue</title>
    <ns>0</ns>
    <id>690</id>
    <revision>
      <id>67160</id>
      <parentid>49893</parentid>
      <timestamp>2014-01-24T10:59:25Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>syntax fixed</comment>
      <text xml:space="preserve" bytes="1678">{{title|continue statement}}
{{cpp/language/statements/navbar}}
Causes the remaining portion of the enclosing {{rlp|for}}, {{rlp|range-for}}, {{rlp|while}} or {{rlp|do | do-while}} loop body skipped.

Used when it is otherwise awkward to ignore the remaining portion of the loop using conditional statements.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|continue}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===

This statement works as a shortcut to the end of the enclosing loop body. 

In case of {{rlp|while}} or {{rlp|do | do-while}} loops, the next statement executed is the condition check ({{spar|cond_expression}}). In case of {{rlp|for}} loop, the next statements executed are the iteration expression and condition check ({{spar|iteration_expression}}, {{spar|cond_expression}}). After that the loop continues as normal.

===Keywords===

{{ltt|cpp/keyword/continue}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

int main() 
{
    for (int i = 0; i &lt; 10; i++) {
        if (i != 5) continue;
        std::cout &lt;&lt; i &lt;&lt; &quot; &quot;;       //this statement is skipped each time i!=5
    }
    
    std::cout &lt;&lt; '\n';

    for (int j = 0; j &lt; 2; j++) {
        for (int k = 0; k &lt; 5; k++) {   //only this loop is affected by continue
            if (k == 3) continue;
            std::cout &lt;&lt; j &lt;&lt; k &lt;&lt; &quot; &quot;; //this statement is skipped each time k==3
        }
    }
}
 | output=
5
00 01 02 04 10 11 12 14
}}

[[de:cpp/language/continue]]
[[es:cpp/language/continue]]
[[fr:cpp/language/continue]]
[[it:cpp/language/continue]]
[[ja:cpp/language/continue]]
[[pt:cpp/language/continue]]
[[ru:cpp/language/continue]]
[[zh:cpp/language/continue]]</text>
      <sha1>2m11fqqieo4y32lh51h7e2nuap0goaq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/copy constructor</title>
    <ns>0</ns>
    <id>5295</id>
    <revision>
      <id>71660</id>
      <parentid>71630</parentid>
      <timestamp>2014-06-18T14:54:24Z</timestamp>
      <contributor>
        <ip>24.106.184.123</ip>
      </contributor>
      <comment>fixed typo</comment>
      <text xml:space="preserve" bytes="6343">{{title|Copy constructors}}
{{cpp/language/classes/navbar}}

A copy constructor of class {{tt|T}} is a non-template constructor whose first parameter is {{c|T&amp;}}, {{c|const T&amp;}}, {{c|volatile T&amp;}}, or {{c|const volatile T&amp;}}, and either there are no other parameters, or the rest of the parameters all have default values. A type with a public copy constructor is {{concept|CopyConstructible}}.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1| {{spar|class_name}} ( {{c|const}} {{spar|class_name}} {{tt|&amp;}} ) }}
{{sdsc |num=2|note={{mark since c++11}}| {{spar|class_name}} ( {{c|const}} {{spar|class_name}} {{tt|&amp;}} ) {{=}} {{c|default;}} }}
{{sdsc |num=3|note={{mark since c++11}}| {{spar|class_name}} ( {{c|const}} {{spar|class_name}} {{tt|&amp;}} ) {{=}} {{c|delete;}} }}
{{sdsc end}}

===Explanation===
# Typical declaration of a copy constructor
# Forcing a copy constructor to be generated by the compiler
# Avoiding implicit default constructor

The copy constructor is called whenever an object is initialized from another object of the same type, which includes 
* initialization, {{c|1=T a = b;}} or {{c|1=T a(b);}}, where b is of type {{tt|T}}
* function argument passing: {{c|f(a);}}, where {{tt|a}} is of type {{tt|T}} and {{tt|f}} is {{c|void f(T t)}}
* function return: {{c|return a;}} inside a function such as {{c|T f()}}, where {{tt|a}} is of type {{tt|T}}, which has no move constructor.

===Implicitly-declared copy constructor===
If no user-defined copy constructors are provided for a class type ({{c|struct}}, {{c|class}}, or {{c|union}}), the compiler will always declare a copy constructor as an {{tt|inline public}} member of its class. This implicitly-declared copy constructor has the form {{tt|T::T(const T&amp;)}} if all of the following is true:
* all direct and virtual bases of {{tt|T}} have copy constructors with references to const or to const volatile as their first parameters
* all non-static members of {{tt|T}} have copy constructors with references to const or to const volatile as their first parameters
Otherwise, the implicitly-declared copy constructor is {{c|T::T(T&amp;)}}. (Note that due to these rules, the implicitly-declared copy constructor cannot bind to a volatile lvalue argument)

{{rev begin}}
{{rev | since=c++11 |
A class can have multiple copy constructors, e.g. both {{c|T::T(const T&amp;)}} and {{c|T::T(T&amp;)}}. If some user-defined copy constructors are present, the user may still force the generation of the implicitly declared copy constructor with the keyword {{tt|default}}
}}
{{rev end}}

===Deleted implicitly-declared copy constructor===
{{rev begin}}
{{rev | until=c++11 | the implicitly-declared copy constructor for class {{tt|T}} is undefined if any of the following conditions are true:
}}
{{rev | since=c++11 | the implicitly-declared or defaulted copy constructor for class {{tt|T}} is  defined as ''deleted'' if any of the following conditions are true:
}}
{{rev end}}

* {{tt|T}} has non-static data members that cannot be copied (have deleted, inaccessible, or ambiguous copy constructors)
* {{tt|T}} has direct or virtual base class that cannot be copied (has deleted, inaccessible, or ambiguous copy constructors)
* {{tt|T}} has direct or virtual base class with a deleted or inaccessible destructor
{{rev begin}}
{{rev | since=c++11 |
* {{tt|T}} has a user-defined move constructor or move assignment operator
* {{tt|T}} is a union and has a variant member with non-trivial copy constructor
* {{tt|T}} has a data member of rvalue reference type
}}
{{rev end}}

===Trivial copy constructor===
The copy constructor for class {{tt|T}} is trivial if all of the following is true:
* The constructor is not user-provided (that is, implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
* {{tt|T}} has no virtual member functions
* {{tt|T}} has no virtual base classes
* The copy constructor selected for every direct base of {{tt|T}} is trivial
* The copy constructor selected for every non-static class type (or array of class type) member of {{tt|T}} is trivial
{{rev begin}}
{{rev | since=c++14 |
* {{tt|T}} has no non-static data members of {{rlp|cv|volatile}}-qualified type
}}
{{rev end}}
A trivial copy constructor is a constructor that creates a bytewise copy of the object representation of the argument, and performs no other action. Objects with trivial copy constructors can be copied by copying their object representations manually, e.g. with {{lc|std::memmove}}. All data types compatible with the C language (POD types) are trivially copyable.

===Implicitly-defined copy constructor===
If the implicitly-declared copy constructor is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For {{c|union}} types, the implicitly-defined copy constructor copies the object representation (as by {{lc|std::memmove}}). For non-union class types ({{c|class}} and {{c|struct}}), the constructor performs full member-wise copy of the object's bases and non-static members, in their initialization order, using direct initialization.

{{rev begin}}
{{rev | since=c++11 |
The generation of the implicitly-defined copy constructor is deprecated if {{tt|T}} has a user-defined destructor or user-defined copy assignment operator.
}}
{{rev end}}

===Notes===
In many situations, copy constructors are optimized out even if they would produce observable side-effects, see [[cpp/language/copy_elision|copy elision]]

===Example===
{{source|code=
struct A {
    int n;
    A(int n=1) : n(n) {}
    A(const A&amp; a) : n(a.n) {} // user-defined copy ctor
};

struct B : A {
    // implicit default ctor B::B()
    // implicit copy ctor B::B(const B&amp;) 
};

struct C : B {
     C() : B() {}
 private:
     C(const C&amp;); // non-copiable, C++98 style
};

int main()
{
    A a1(7);
    A a2(a1); // calls the copy ctor
    B b;
    B b2 = b;
    A a3 = b; // conversion to A&amp; and copy ctor
    volatile A va(10);
    // A a4 = va; // compile error

    C c;
    // C c2 = c; // compile error
}
}}

[[de:cpp/language/copy constructor]]
[[es:cpp/language/copy constructor]]
[[fr:cpp/language/copy constructor]]
[[it:cpp/language/copy constructor]]
[[ja:cpp/language/copy constructor]]
[[pt:cpp/language/copy constructor]]
[[ru:cpp/language/copy constructor]]
[[zh:cpp/language/copy constructor]]</text>
      <sha1>r1kgrmmh08tvfmncdsucd3t0a36b3t5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/copy elision</title>
    <ns>0</ns>
    <id>8872</id>
    <revision>
      <id>69169</id>
      <parentid>69053</parentid>
      <timestamp>2014-03-28T18:18:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no move from exception object, also +the exception to that rule</comment>
      <text xml:space="preserve" bytes="4261">{{title|copy elision}}
{{cpp/language/navbar}}
Optimizes out copy- and move-constructors, resulting in zero-copy pass-by-value semantics.

===Explanation===

Under the following circumstances, the compilers are permitted to omit the copy- and move-constructors of class objects even if copy/move constructor and the destructor have observable side-effects.

* If a function returns a class type by value, and the {{rlp|return|return statement}}'s expression is the name of a non-volatile object with automatic storage duration, which isn't the function parameter, or a catch clause parameter, and which has the same [[cpp/language/cv|cv-unqualified]] type as the return type of the function, then copy/move is omitted. When that local variable is constructed, it is constructed directly in the storage where the function's return value would otherwise be moved or copied to. This variant of copy elision is known as NRVO, &quot;named return value optimization&quot;.

* When a nameless temporary, not bound to any references, would be moved or copied into an object of the same cv-unqualified type, the copy/move is omitted. When that temporary is constructed, it is constructed directly in the storage where it would otherwise be moved or copied to. When the nameless temporary is the argument of a return statement, this variant of copy elision is known as RVO, &quot;return value optimization&quot;.
{{rev begin}}
{{rev|since=c++11|
* In a {{rlp|throw|throw-expression}}, if the operand is the name of a non-volatile object with automatic storage duration, which isn't the function parameter, or a catch clause parameter, and whose scope does not extend past the innermost try-block (if there is a try-block), then copy/move is omitted. When that local variable is constructed, it is constructed directly in the storage where the exception object would otherwise be moved or copied to.

* When handling an exception, if the argument of the {{rlp|try_catch|catch clause}} is of the same type (except for cv-qualification) as the exception object thrown, the copy is omitted and the body of the catch clause accesses the exception object directly, as if caught by reference. This is disabled if such copy elision would change the observable behavior of the program for any reason other than skipping copy constructor and the destructor of the catch clause's parameter. 
}}
{{rev end}}
Multiple copy elisions may be chained to eliminate multiple copies.

===Notes===
Copy elision is the only allowed form of optimization that can change the observable side-effects. Because some compilers do not perform copy elision in every situation where it is allowed, programs that rely on the side-effects of copy/move constructors and destructors are not portable.

Even when copy elision takes place and the copy-/move-constructor is not called, it must be present and accessible, otherwise the program is ill-formed.

===Example===

{{example
 |
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;

struct Noisy {
    Noisy() {std::cout &lt;&lt; &quot;constructed\n&quot;; }
    Noisy(const Noisy&amp;) { std::cout &lt;&lt; &quot;copied\n&quot;; }
    Noisy(Noisy&amp;&amp;) { std::cout &lt;&lt; &quot;moved\n&quot;; }
    ~Noisy() {std::cout &lt;&lt; &quot;destructed\n&quot;; }
};

std::vector&lt;Noisy&gt; f()
{
    std::vector&lt;Noisy&gt; v = std::vector&lt;Noisy&gt;(3); // copy elision from temporary to v
    return v; // NRVO from v to the nameless temporary that is returned
}

void fn_by_val(std::vector&lt;Noisy&gt; arg)
{
    std::cout &lt;&lt; &quot;arg.size() = &quot; &lt;&lt; arg.size() &lt;&lt; '\n';
}

int main()
{
    std::vector&lt;Noisy&gt; v = f(); // copy elision from returned temporary to v
    fn_by_val(f());             // and from temporary to the argument of fn_by_val()
}
 | p=true
 | output=
constructed
constructed
constructed
constructed
constructed
constructed
arg.size() = 3
destructed
destructed
destructed
destructed
destructed
destructed
}}

===See also===
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/copy_constructor|copy constructor]]
* [[cpp/language/move_constructor|move constructor]]

[[de:cpp/language/copy elision]]
[[es:cpp/language/copy elision]]
[[fr:cpp/language/copy elision]]
[[it:cpp/language/copy elision]]
[[ja:cpp/language/copy elision]]
[[pt:cpp/language/copy elision]]
[[ru:cpp/language/copy elision]]
[[zh:cpp/language/copy elision]]</text>
      <sha1>5jh3wq9j6yqb2xrfag2s02njp0mg3o1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/copy initialization</title>
    <ns>0</ns>
    <id>8866</id>
    <revision>
      <id>72136</id>
      <parentid>72128</parentid>
      <timestamp>2014-07-17T16:30:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>&quot;may be a prvalue&quot; doesn't convey any information. specify when, and also add the missing clause that this can be converting to a derived from</comment>
      <text xml:space="preserve" bytes="4551">{{title|copy initialization}}
{{cpp/language/initialization/navbar}}
Initializes an object from another object

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{spar| object}} {{ttb|{{=}} }} {{spar|other}} {{ttb|;}} }}
{{sdsc | num=2 | {{spar|f}}{{ttb|(}}{{spar|other}}{{ttb|)}}{{ttb|;}} }}
{{sdsc | num=3 | {{ttb|return }} {{spar|other}}{{ttb|;}} }}
{{sdsc | num=4 | {{ttb|catch (}} {{spar|T}} {{spar|other}}{{ttb|) ;}} }}
{{sdsc | num=5 | {{spar|T}} {{spar|array}} {{ttb|[}} {{spar|N}} {{ttb|] {{=}} { }} {{spar|other}} {{ttb|};}}}}
{{sdsc end}}

===Explanation===

Copy initialization is performed in the following situations:
@1@ when a named variable (automatic, static, or thread-local) of a non-reference type {{tt|T}} is declared with the initializer consisting of an equals sign followed by an expression.
@2@ when passing an argument to a function by value
@3@ when returning from a function that returns by value
@4@ when catching an exception by value
@5@ as part of [[cpp/language/aggregate_initialization|aggregate initialization]], to initialize each element for which an initializer is provided

The effects of copy initialization are:

* If {{tt|T}} is a class type and the type of {{spar|other}} is cv-unqualified version of {{tt|T}} or a class derived from {{tt|T}}, the constructors of {{tt|T}} are examined and the best match is selected by overload resolution. The constructor is then called to initialize the object.

* If {{tt|T}} is a class type, and the type of {{spar|other}} is different, or if {{tt|T}} is non-class type, but the type of {{spar|other}} is a class type, [[cpp/language/implicit_cast|user-defined conversion sequences]] that can convert from the type of {{spar|other}} to {{tt|T}} (or to a type derived from T if T is a class type and a conversion function is available) are examined and the best one is selected through overload resolution. The result of the conversion, which is a prvalue temporary if a converting constructor was used, is then used to [[cpp/language/direct_initialization|direct-initialize]] the object. The last step is usually [[cpp/language/copy_elision|optimized out]] and the result of the conversion is constructed directly in the memory allocated for the target object, but the appropriate constructor (move or copy) is required to be accessible even though it's not used.

* Otherwise (if neither {{tt|T}} nor the type of {{spar|other}} are class types), [[cpp/language/implicit_cast|standard conversions]] are used, if necessary, to convert the value of {{spar|other}} to the cv-unqualified version of {{tt|T}}.

===Notes===
Copy-initialization is less permissive than direct-initialization: copy-initialization only considers non-explicit constructors and user-defined conversion functions.

If {{spar|other}} is an rvalue expression, [[cpp/language/move_constructor|move constructor]] will be selected by overload resolution and called during copy-initialization. There is no such term as move-initialization.

[[cpp/language/implicit_cast|Implicit conversion]] is defined in terms of copy-initialization: if an object of type {{tt|T}} can be copy-initialized with expression {{tt|E}}, then {{tt|E}} is implicitly convertible to {{tt|T}}.

The equals sign, {{ttb|{{=}}}}, in copy-initialization of a named variable is not related to the assignment operator. Assignment operator overloads have no effect on copy-initialization.

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;utility&gt;
#include &lt;memory&gt;

int main()
{
    std::string s = &quot;test&quot;; // OK: constructor is non-explicit
    std::string s2 = std::move(s); // this copy-initialization performs a move

//  std::unique_ptr&lt;int&gt; p = new int(1); // error: constructor is explicit
    std::unique_ptr&lt;int&gt; p(new int(1)); // OK: direct-initialization

    int n = 3.14;    // floating-integral conversion
    const int b = n; // const doesn't matter
    int c = b;       // ...either way
}
 | output=
}}

===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/aggregate_initialization|aggregate initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/copy initialization]]
[[es:cpp/language/copy initialization]]
[[fr:cpp/language/copy initialization]]
[[it:cpp/language/copy initialization]]
[[ja:cpp/language/copy initialization]]
[[pt:cpp/language/copy initialization]]
[[ru:cpp/language/copy initialization]]
[[zh:cpp/language/copy initialization]]</text>
      <sha1>gdz0m2yx0394huotjtolf70oandpdyb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/cv</title>
    <ns>0</ns>
    <id>691</id>
    <revision>
      <id>72026</id>
      <parentid>71444</parentid>
      <timestamp>2014-07-09T14:34:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link signal handling</comment>
      <text xml:space="preserve" bytes="5794">{{title|cv ({{small|const-volatility}}) specifiers and qualifiers}}
{{cpp/language/declarations/navbar}}

Appear in any type specifier, including {{spar|decl-specifier-seq}} of  {{rlp|declarations|declaration grammar}}, to specify constness or volatility of the type being declared.

:*{{ttb|const}} - defines that the type is ''constant''.
:*{{ttb|volatile}} - defines that the type is ''volatile''.
:*{{ttb|mutable}} - defines that a member of a class does not affect the externally visible state of the class. {{tt|mutable}} members can be modified in ''constant'' classes, that is ''constness'' is essentially ignored for the particular member.

===Explanation===
For any type {{tt|T}} (including incomplete types), other than {{rlp|functions|function type}} or {{rlp|reference|reference type}}, there are three more distinct types in the C++ type system: {{spar|const-qualified}} {{tt|T}}, {{spar|volatile-qualified}} {{tt|T}}, and {{spar|const-volatile-qualified}} {{tt|T}}.

:Note: {{spar|cv-qualifiers}} and {{spar|cv-specifiers}} are not the same thing: cv-qualifiers are the properties of a type whereas cv-specifiers are the language keywords used to define cv-qualifiers.

:Note: {{rlp|array|array types}} are considered to have the same cv-qualification as their element types.

When an object is first created, the cv-specifiers used (which could be part of {{spar|decl-specifier-seq}} or part of a {{spar|declarator}} in a {{rlp|declarations|declaration}}, or part of {{spar|type-id}} in a {{rlp|new|new-expression}}) determine the constness or volatility of the object, as follows:

*'''''const object''''' - an object whose type is {{spar|const-qualified}}, or a non-mutable subobject of a const object. Such object cannot be modified: attempt to do so directly is a compile-time error, and attempt to do so indirectly (e.g., by modifying the const object through a reference or pointer to non-const type) results in undefined behavior.
*'''''volatile object''''' - an object whose type is {{spar|volatile-qualified}}, or a subobject of a volatile object, or a mutable subobject of a const-volatile object. Every access (read or write operation, member function call, etc.) on the volatile object is treated as a visible side-effect for the {{rlp|as_if|purposes of optimization}} (that is, within a single thread of execution, volatile accesses cannot be reordered or optimized out. This makes volatile objects suitable for communication with a [[cpp/utility/program/signal|signal handler]], but not with another thread of execution, see {{lc|std::memory_order}}). Any attempt to refer to a volatile object through a non-volatile glvalue (e.g. through a reference or pointer to non-volatile type) results in undefined behavior.
*'''''const volatile object''''' - an object whose type is {{spar|const-volatile-qualified}}, a non-mutable subobject of a const volatile object, a const subobject of a volatile object, or a non-mutable volatile subobject of a const object. Behaves as both a const object and as a volatile object.

There is partial ordering of cv-qualifiers by the order of increasing restrictions. The type can be said ''more'' or ''less'' cv-qualified then:

:* ''unqualified'' &lt; {{tt|const}}
:* ''unqualified'' &lt; {{tt|volatile}}
:* ''unqualified'' &lt; {{tt|const volatile}}
:* {{tt|const}} &lt; {{tt|const volatile}}
:* {{tt|volatile}} &lt; {{tt|const volatile}}

References and pointers to cv-qualified types may be {{rlp|implicit_cast#Qualification_conversions | implicitly converted}} to references and pointers to ''more cv-qualified'' types. In particular, the following conversions are allowed:

:* ''unqualified'' type can be converted to {{tt|const}}
:* ''unqualified'' type can be converted to {{tt|volatile}}
:* ''unqualified'' type can be converted to {{tt|const volatile}}
:* {{tt|const}} type can be converted to {{tt|const volatile}}
:* {{tt|volatile}} type can be converted to {{tt|const volatile}}

:Note: {{rlp|implicit_cast#Qualification_conversions | additional restrictions}} are imposed on multi-level pointers.

To convert a reference or a pointer to a cv-qualified type to a reference or pointer to a ''less cv-qualified'' type, {{rlp|const_cast}} must be used.

===Keywords===

{{ltt|cpp/keyword/const}}, 
{{ltt|cpp/keyword/volatile}},
{{ltt|cpp/keyword/mutable}}

===Example===
{{example
|code=int main()
{
    int n1 = 0;           // non-const object
    const int n2 = 0;     // const object
    int const n3 = 0;     // const object (same as n2)
    volatile int n4 = 0;  // volatile object
    const struct X {
        int n1;
        mutable int n2;
    } x = {0, 0};      // const object with mutable member

    n1 = 1; // ok, modifiable obejct
//  n2 = 2; // error: non-modifiable object
    n4 = 3; // ok, treated as a side-effect.
//  x.n1 = 4; // error: member of a const object is const
    x.n2 = 4; // ok, mutable member of a const object isn't const

    const int&amp; r1 = n1; // reference to const bound to non-const object
//  r1 = 2; // error: attempt to modify through reference to const
    const_cast&lt;int&amp;&gt;(r1) = 2; // ok, modifies n1

    const int&amp; r2 = n2; // reference to const bound to const object
//  r2 = 2; // error: attempt to modify through reference to const
//  const_cast&lt;int&amp;&gt;(r2) = 2; // undefined behavior: attempt to modify const object
}
| output=
# typical machine code produced on an x86_64 platform
# (only the code that contributes to observable side-effects is emitted)
main:
    movl    $0, -4(%rsp) # volatile int n4 = 0;
    movl    $3, -4(%rsp) # n4 = 3;
    xorl    %eax, %eax   # return 0 (implicit)
    ret
}}

[[de:cpp/language/cv]]
[[es:cpp/language/cv]]
[[fr:cpp/language/cv]]
[[it:cpp/language/cv]]
[[ja:cpp/language/cv]]
[[pt:cpp/language/cv]]
[[ru:cpp/language/cv]]
[[zh:cpp/language/cv]]</text>
      <sha1>iq94n1cjd3spcn9h33bubx5drf7cd5b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/data members</title>
    <ns>0</ns>
    <id>9910</id>
    <revision>
      <id>71667</id>
      <parentid>71043</parentid>
      <timestamp>2014-06-19T02:31:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>cwg 1425 (pointer to standard-layout type can be cast to base, not just member)</comment>
      <text xml:space="preserve" bytes="6348">{{title|Non-static data members}}
{{cpp/language/classes/navbar}}
Non-static data members are the variables that are declared in a {{rlp|class|member specification}} of a class.

{{source|1=class S {
    int n; // non-static data member
    int&amp; r; // non-static data member of reference type
    int a[10] = {1,2}; // non-static data member with initializer (C++11)
    std::string s, *ps; // two non-static data members
    struct NestedS {
        std::string s;
    } d5, *d6; // two non-static data members of nested type
    char bit : 2; // two-bit bitfield
};
}}

Any {{rlp|declarations|simple declarations}} are allowed, except
* [[cpp/keyword/extern|extern]] and [[cpp/keyword/register|register]] storage class specifiers are not allowed
* [[cpp/keyword/thread_local|thread_local]] storage class specifier is not allowed (but it is allowed for {{rlp|static}} data members)
* {{rlp|incomplete_type|incomplete types}} are not allowed: in particular, a class {{tt|C}} cannot have a non-static data member of class {{tt|C}}, although it can have a non-static data member of type {{tt|C&amp;}} (reference to C) or {{tt|C*}} (pointer to C)
* a non-static data member cannot have the same name as the name of the class if at least one user-declared constructor is present.
In addition, {{rlp|bit_field|bit field declarations}} are allowed.

===Layout===
When an object of some class {{tt|C}} is created, each non-static data member of non-reference type is allocated in some part of the object representation of {{tt|C}}. Whether reference members occupy any storage is implementation-defined.

For non-{{rlp|union}} class types, members with the same {{rlp|access|member access}} are always allocated so that the members declared later have higher addresses within a class object. Members with different access control are allocated in unspecified order (the compiler may group them together). Alignment requirements may necessitate padding between members, or after the last member of a class.

===Standard layout===
A class where all non-static data members have the same access control and certain other conditions are satisfied is known as ''standard layout type'' (see {{concept|StandardLayoutType}} for the list of requirements).

Two standard-layout struct types are called ''layout-compatible'' if they have the same number of non-static data members and the corresponding non-static data members, in declaration order, are themselves layout-compatible.

Two standard-layout struct types have a common initial sequence of non-static data members, if, for a sequence of one or more initial members (in order of declaration), the members have layout-compatible types.

Standard layout types have the following special properties:
:* If a standard-layout {{rlp|union}} holds two (or more) standard-layout structs as members, and these stucts have a common initial sequence of data members, it is well-defined to examine any member of that common initial sequence regardless of which member of the union is active.
:* A pointer to an object of standard-layout struct type can be {{rlp|reinterpret_cast}} to pointer to its first non-static data member (if it has non-static data members) or otherwise its first base class subobject (if it has any), and vice versa. (padding is not allowed before the first data member). Note that [[cpp/language/reinterpret_cast#Type_aliasing|strict aliasing]] rules still apply to the result of such cast.
:* The macro {{lc|offsetof}} may be used to determine the offset of any member from the beginning of a standard-layout struct

===Member initialization===
Non-static data members may be initialized in one of two ways:

@1@ In the {{rlp|initializer_list|member initializer list}} of the constructor.
{{source|1=struct S {
    int n;
    std::string s;
    S() : n(7) // direct-initializes n, default-initializes s
    { }
};
}}

{{rev begin}}
{{rev |since=c++11|
@2@ Through a brace-or-equal initializer, which is simply an {{rlp|initialization|initializer}} included in the member declaration, which is used if the member is omitted in the member initializer list
{{source|1=struct S {
    int n = 7;
    std::string s{'a', 'b', 'c'};
    S() // copy-initializes n, list-initializes s
    { }
};
}}

If a member has a brace-or-equal initializer and also appears in the member initialization list in a constructor, the brace-or-equal initializer is ignored.
{{source|1=#include &lt;iostream&gt;
int x = 0;
struct S {
    int n = ++x;
    S() {} // uses brace-or-equal initializer
    S(int arg) : n(arg) {} // uses member initializer list
};
int main()
{
    std::cout &lt;&lt; x &lt;&lt; '\n'; // prints 0
    S s1;
    std::cout &lt;&lt; x &lt;&lt; '\n'; // prints 1
    S s2(7);
    std::cout &lt;&lt; x &lt;&lt; '\n'; // prints 1
}
}}
}}
{{rev end}}

===Usage===
The name of a non-static data member or a non-static member function can only appear in the following three situations:
@1@ As a part of class member access expression, in which the class either has this member or is derived from a class that has this member, including the implicit {{tt|this-&gt;}} member access expressions that appear when a non-static member name is used in any of the contexts where {{rlp|this}} is allowed (inside member function bodies, in member initializer lists, in the in-class brace-or-equal initializers)
{{source|1=
struct S {
   int m;
   int n;
   int x = m;  // OK: implicit this allowed in brace-or-equal initializers (C++11)
   S(int init) : m(init),
                 n(m) // OK:implicit this allowed in member initializer lists
   {
       this-&gt;f();  // explicit member access expression
       f(); // implicit this allowed in member functions
   }
   void f();
};
}}
@2@ To form a {{rlp|pointer|pointer to member}}
{{source|1=
struct S {
   int m;
   void f();
};
int S::*p = &amp;S::m; // OK, use of m to make a pointer to member
void (S::*fp)() = &amp;S::f; // OK, use of f to make a pointer to member
}}

{{rev begin}}
{{rev|since=c++11|
@3@ in unevaluated operands
{{source|1=
struct S {
   int m;
   static const std::size_t sz = sizeof m; // OK, m in unevaluated operand
};
std::size_t j = sizeof(S::m + 42); // OK, even though there is no &quot;this&quot; object for m
}}
}}
{{rev end}}

===See also===
*{{rlp|classes|classes}}
*{{rlp|static|static data members}}
*{{rlp|member_functions|member functions}}
*{{lc|std::is_standard_layout}}
*{{lc|offsetof}}</text>
      <sha1>b5segunr98rxeugmg6u9ms0l4f9ivt7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/declarations</title>
    <ns>0</ns>
    <id>9896</id>
    <revision>
      <id>71993</id>
      <parentid>71621</parentid>
      <timestamp>2014-07-06T12:45:19Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Specifiers */ +{{rev}}</comment>
      <text xml:space="preserve" bytes="12995">{{title|Declarations}}
{{cpp/language/declarations/navbar}}
''Declarations'' introduce (or re-introduce) names into the C++ program. Each kind of entity is declared differently. {{rlp|definition|Definitions}} are declarations that are sufficient to use the entity identified by the name. 

A declaration is one of the following:

* [[cpp/language/function|Function declaration]]
* [[cpp/language/templates|Template declaration]]
* [[cpp/language/class_template#Explicit_instantiation|Explicit template instantiation]]
* [[cpp/language/template_specialization|Explicit template specialization]]
* [[cpp/language/namespace|Namespace definition]]
* [[cpp/language/language_linkage|Linkage specification]]
* Attribute declaration ({{spar|[[cpp/language/attributes|attr]]}} {{ttb|;}}) {{mark since c++11}}
* Empty declaration ({{ttb|;}})
* Block declaration (a declaration that can appear inside a [[cpp/language/statements#Compound_statement|block]]), which, in turn, can be one of the following:
:*[[cpp/language/asm|asm definition]]
:*[[cpp/language/type_alias|type alias declaration]]
:*[[cpp/language/namespace_alias|namespace alias definition]]
:*[[cpp/language/using_declaration|using declaration]]
:*[[cpp/language/namespace#Using-directives|using directive]]
:*{{rlp|static_assert}} declaration
:*[[cpp/language/enum|opaque enum declaration]]
:*simple declaration

Simple declaration is a statement that introduces, creates, and optionally initializes one or several identifiers, typically variables.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}}{{mark optional}} {{spar|init-declarator-list}}{{mark optional}} {{ttb|;}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|decl-specifier-seq}} | sequence of type specifiers including the type name. It is only optional in the declarations of constructors, destructors, and user-defined type {{rlp|cast_operator|conversion functions}}}}
{{par | {{spar|init-declarator-list}} | comma-separated list of ''declarators'' with optional ''initializers''. Init-declarator-list is optional when declaring a named class/struct/union or a named enumeration }}
{{par end}}

===Specifiers===

{{spar|decl-specifier-seq}} is a sequence of the following whitespace-separated specifiers:

* {{rlp|typedef|typedef specifier}}. If present, the entire declaration is a [[cpp/language/typedef|typedef declaration]] and each declarator introduces a new type name, not an object or a function.
* function specifier ([[cpp/keyword/inline|inline]], [[cpp/keyword/virtual|virtual]], [[cpp/keyword/explicit|explicit]]), only allowed in {{rlp|function|function declarations}}
* {{rlp|friend|friend specifier}}, allowed in class and function declarations.
* {{rlp|constexpr|constexpr specifier}}, only allowed in variable definitions, function and function template declarations, and the declaration of static data members of literal type.
* {{rlp|storage duration|storage class specifier}} ([[cpp/keyword/register|register]], [[cpp/keyword/static|static]], {{rev inl|since=c++11|[[cpp/keyword/thread_local|thread_local]]}}, [[cpp/keyword/extern|extern]], [[cpp/keyword/mutable|mutable]]). Only one storage class specifier is allowed, except that {{tt|thread_local}} may appear together with {{tt|extern}} or {{tt|static}}.
* type specifier sequence, which can be any one of the following:
:* {{rlp|class|class specifier}}
:* {{rlp|enum|enum specifier}}
:* simple type specifier
::*any keyword that names a {{rlp|types|fundamental type}}: [[cpp/keyword/char|char]]{{rev inl|since=c++11|, [[cpp/keyword/char16_t|char16_t]], [[cpp/keyword/char32_t|char32_t]]}}, [[cpp/keyword/wchar_t|wchar_t]], [[cpp/keyword/bool|bool]], [[cpp/keyword/short|short]], [[cpp/keyword/int|int]], [[cpp/keyword/long|long]], [[cpp/keyword/signed|signed]], [[cpp/keyword/unsigned|unsigned]], [[cpp/keyword/float|float]], [[cpp/keyword/double|double]], [[cpp/keyword/void|void]]
{{rev begin}}
{{rev|since=c++11|
::*{{rlp|auto}}
::*{{rlp|decltype|decltype specifier}}
}}{{rev end}}
::* previously declared class name (optionally {{rlp|identifiers#Qualified identifiers|qualified}})
::* previously declared enum name (optionally {{rlp|identifiers#Qualified identifiers|qualified}})
::* previously declared {{rlp|typedef|typedef-name}}{{rev inl|since=c++11| or {{rlp|type alias}}}} (optionally {{rlp|identifiers#Qualified identifiers|qualified}})
::* template name with template arguments (optionally {{rlp|identifiers#Qualified identifiers|qualified}}, optionally using {{rlp|dependent_name|template disambiguator}})
:* elaborated type specifier
::* the keyword [[cpp/keyword/class|class]], [[cpp/keyword/struct|struct]], or [[cpp/keyword/union|union]], followed by the identifier (optionally {{rlp|identifiers#Qualified identifiers|qualified}}), previously defined as the name of a class, struct, or union.
::* the keyword [[cpp/keyword/class|class]], [[cpp/keyword/struct|struct]], or [[cpp/keyword/union|union]], followed by template name with template arguments (optionally {{rlp|identifiers#Qualified identifiers|qualified}}, optionally using {{rlp|dependent_name|template disambiguator}}), previously defined as the name of a class template.
::* the keyword [[cpp/keyword/enum|enum]] followed by the identifier (optionally {{rlp|identifiers#Qualified identifiers|qualified}}), previously declared as the name of an enumeration.
:* {{rlp|dependent_name|typename specifier}}
:* {{rlp|cv|cv qualifier}}
:only one type specifier is allowed in a decl-specifier-seq, with the following exceptions:
:- {{tt|const}} can be combined with any type specifier except itself.
:- {{tt|volatile}} can be combined with any type specifier except itself.
:- {{tt|signed}} or {{tt|unsigned}} can be combined with {{tt|char}}, {{tt|long}}, {{tt|short}}, or {{tt|int}}.
:- {{tt|short}} or {{tt|long}} can be combined with {{tt|int}}.
:- {{tt|long}} can be combined with {{tt|double}}.
{{rev begin}}
{{rev|since=c++11|
:- {{tt|long}} can be combined with {{tt|long}} itself.
}}{{rev end}}

[[cpp/language/attributes|Attributes]] may appear in decl-specifier-seq, in which case they apply to the type determined by the preceding specifiers.

===Declarators===
{{spar|init-declarator-seq}} is a comma-separated sequence of one or more {{spar|init-declarators}}, which have the following syntax:

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|declarator}} {{spar|initializer}}{{mark optional}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|declarator}} | the declarator}}
{{par | {{spar|initializer}} | optional initializer (except where required, such as when initializing references or const objects). See [[cpp/language/initialization|Initialization]] for details.}}
{{par end}}

Each {{spar|init-declaractor}} in a init-declarator sequence {{c|S D1, D2, D3;}} is processed as if it were a standalone declaration with the same specifiers: {{c|S D1; S D2; S D3;}}.

Each declarator introduces exactly one object, function, or (for typedef declarations) type alias, whose type is provided by {{spar|decl-specifier-seq}} and optionally modified by operators such as {{c|&amp;}} (reference to) or {{c|[]}} (array of) or {{c|()}} (function returning) in the declarator. These operators can be applied recursively, as shown below,

A {{spar|declarator}} is one of the following:
{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|identifier}} {{spar|attr}}{{mark optional}}
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{ttb|...}} {{spar|identifier}} {{spar|attr}}{{mark optional}}
}}
{{sdsc|num=3|1=
{{ttb|*}} {{spar|attr}}{{mark optional}} {{spar|cv}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=4|1=
{{spar|nested-name-specifier}} {{ttb|*}} {{spar|attr}}{{mark optional}} {{spar|cv}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=5|1=
{{ttb|&amp;}} {{spar|attr}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=6|notes={{mark since c++11}}|1=
{{ttb|&amp;&amp;}} {{spar|attr}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=7|1=
{{spar|noptr-declarator}} {{ttb|[}} {{spar|constexpr}}{{mark optional}} {{ttb|]}} {{spar|attr}}{{mark optional}}
}}
{{sdsc|num=8|1=
{{spar|noptr-declarator}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{spar|attr}}{{mark optional}} {{spar|cv}}{{mark optional}} {{spar|ref}}{{mark optional}} {{spar|except}}
}}
{{sdsc end}}

@1@ The identifier that is declared. A declarator that consist of just an identifier, declares an object of exactly the type provided by {{spar|decl-specifier-seq}}.
@2@ [[cpp/language/parameter pack|Parameter pack]], only appears in function parameter lists for variadic function templates.
@3@ [[cpp/language/pointer|Pointer declarator]]: the declaration {{c|S * D;}} declares {{tt|D}} as a pointer to the type determined by {{spar|decl-specifier-seq}} {{tt|S}}.
@4@ [[cpp/language/pointer|Pointer to member declaration]]: the declaration {{c|S C::*D;}} declares {{tt|D}} as a pointer to member of {{tt|C}} of type determined by {{spar|decl-specifier-seq}} {{tt|S}}. {{spar|nested-name-specifier}} is a {{rlp|identifiers#Qualified identifiers|sequence of names and scope resolution operators {{ttb|::}}}}
@5@ [[cpp/language/reference|Lvalue reference declarator]]: the declaration {{c|S &amp; D;}} declares the object {{tt|D}} with type lvalue reference to the type determined by {{spar|decl-specifier-seq}} {{tt|S}}.
@6@ [[cpp/language/reference|Rvalue reference declarator]]: the declaration {{c|S &amp;&amp; D;}} declares the object {{tt|D}} with type rvalue reference to the type determined by {{spar|decl-specifier-seq}} {{tt|S}}.
@7@ [[cpp/language/array|Array declarator]]. {{spar|noptr-declarator}} any valid declarator, but if it begins with *, &amp;, or &amp;&amp;, it has to be surrounded by parentheses.
@8@ [[cpp/language/function|Function declarator]]. {{spar|noptr-declarator}} any valid declarator, but if it begins with *, &amp;, or &amp;&amp;, it has to be surrounded by parentheses. Note that the outermost function declarator may end with the optional trailing return type. 

In all cases, {{spar|attr}} is an optional sequence of {{rlp|attributes}}. When appearing immediately after the identifier, it applies to the object being declared.

{{spar|cv}} is a sequence of {{rlp|cv|const and volatile}} qualifiers, where either qualifier may appear at most once in the sequence.

{{todo|explain declaration name hiding rules; how a variable/function declaration hides a class (but not a typedef) with the same name}}
===Notes===
When a block declaration appears {{rlp|statements#Compound statement|inside a block}}, and an identifier introduced by a declaration was previously declared in an outer block, the {{rlp|scope|outer declaration is hidden}} for the remainder of the block. 

If a declaration introduces a variable with automatic storage duration, it is initialized when its declaration statement is executed. All automatic variables declared in a block are destroyed on exit from the block (regardless how the block is exited: via {{rlp|exceptions|exception}}, {{rlp|goto}}, or by reaching its end), in order opposite to their order of initialization.

===Examples===
{{example|
|code=
class C {
    std::string member; // decl-specifier-seq is &quot;std::string&quot;
                        // declarator is &quot;member&quot;
} obj, *pObj(&amp;obj);
// decl-specifier-seq is &quot;class C { std::string member; }&quot;
// declarator &quot;obj&quot; defines an object of type C
// declarator &quot;*pObj(&amp;obj)&quot; declares and initializes a pointer to C

int a = 1, *p = NULL, f(), (*pf)(double);
// decl-specifier-seq is int
// declarator a=1 defines and initializes a variable of type int
// declarator *p=NULL defines and initializes a variable of type int*
// declarator (f)() declares (but doesn't define)
//                  a function taking no arguments and returning int
// declarator (*pf)(double) defines a pointer to function
//                  taking double and returning int

int (*(*foo)(double))[3] = NULL;
// decl-specifier-seq is int
// 1. declarator &quot;(*(*foo)(double))[3]&quot; is an array declarator:
//    the type declared is &quot;/nested declarator/ array of 3 int&quot;
// 2. the nested declarator is &quot;*(*foo)(double))&quot;, which is a pointer declarator
//    the type declared is &quot;/nested declarator/ pointer to array of 3 int&quot;
// 3. the nested declarator is &quot;(*foo)(double)&quot;, which is a function declarator
//    the type declared is &quot;/nested declarator/ function taking double and returning
//        pointer to array of 3 int&quot;
// 4. the nested declarator is &quot;(*foo)&quot; which is a (parenthesized, as required by
//        function declarator syntax) pointer declarator.
//    the type declared is &quot;/nested declarator/ pointer to function taking double
//        and returning pointer to array of 3 int&quot;
// 5. the nested declarator is &quot;foo&quot;, which is an identifier.
// The declaration declares the object foo of type &quot;pointer to function taking double 
//     and returning pointer to array of 3 int&quot;
// The initializer &quot;= NULL&quot; provides the initial value of this pointer.
}}</text>
      <sha1>ptar8gnydqgp0cjzfjhwy49jul9b089</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/decltype</title>
    <ns>0</ns>
    <id>3275</id>
    <revision>
      <id>72360</id>
      <parentid>69199</parentid>
      <timestamp>2014-08-14T16:19:12Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ 7.1.6.2/5 special rule for decltype and function call</comment>
      <text xml:space="preserve" bytes="2998">{{title|decltype specifier}}
{{cpp/language/declarations/navbar}}

Inspects the declared type of an entity or queries the return type of an expression.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|decltype (}} {{spar|entity}} {{ttb|)}} | num=1 | notes={{mark since c++11}}}}
{{sdsc | {{ttb|decltype (}} {{spar|expression}} {{ttb|)}} | num=2| notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===

@1@ If the argument is either the unparenthesised name of an object/function, or is a member access expression ({{tt|object.member}} or {{tt|pointer-&gt;member}}), then the decltype specifies the declared type of the {{spar|entity}} specified by this expression.
@2@ If the argument is any other expression of type {{tt|T}}, then
:@a@ if the [[cpp/language/value_category|value category]] of {{spar|expression}} is ''xvalue'', then the decltype specifies {{tt|T&amp;&amp;}}
:@b@ if the value category of {{spar|expression}} is ''lvalue'', then the decltype specifies {{tt|T&amp;}}
:@c@ otherwise, decltype specifies {{tt|T}}

If {{spar|expression}} is a function call which returns a prvalue of class type or is a {{rlp|operator other|comma expression}} whose right operand is such a function call, a temporary object is not introduced for that prvalue. The class type need not be {{rlp|incomplete type|complete}} or have an available {{rlp|destructor}}. This rule doesn't apply to sub-expressions:in {{c|decltype(f(g()))}},  {{c|g()}} must have a complete type, but {{c|f()}} need not.

Note that if the name of an object is parenthesised, it becomes an lvalue expression, thus {{c|decltype(arg)}} and {{c|decltype((arg))}} are often different types.

{{tt|decltype}} is useful when declaring types that are difficult or impossible to declare using standard notation, like lambda-related types or types that depend on template parameters.

===Keywords===

{{ltt|cpp/keyword/decltype}}

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;

struct A {
   double x;
};
const A* a = new A{0};

decltype( a-&gt;x ) x3;       // type of x3 is double (declared type)
decltype((a-&gt;x)) x4 = x3;  // type of x4 is const double&amp; (lvalue expression)

template &lt;class T, class U&gt;
auto add(T t, U u) -&gt; decltype(t + u); // return type depends on template parameters

int main() 
{
    int i = 33;
    decltype(i) j = i*2;
   
    std::cout &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;j = &quot; &lt;&lt; j &lt;&lt; '\n';

    auto f = [](int a, int b) -&gt; int {
       return a*b;
    };
   
    decltype(f) f2 = f; // the type of a lambda function is unique and unnamed
    i = f(2, 2);
    j = f2(3, 3);
   
    std::cout &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;j = &quot; &lt;&lt; j &lt;&lt; '\n';
}
 | output=
i = 33, j = 66
i = 4, j = 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc declval}}
{{dsc end}}

[[de:cpp/language/decltype]]
[[es:cpp/language/decltype]]
[[fr:cpp/language/decltype]]
[[it:cpp/language/decltype]]
[[ja:cpp/language/decltype]]
[[pt:cpp/language/decltype]]
[[ru:cpp/language/decltype]]
[[zh:cpp/language/decltype]]</text>
      <sha1>7wbrx6ljmrsg0rar038a1l72amri15b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/default arguments</title>
    <ns>0</ns>
    <id>13509</id>
    <revision>
      <id>70975</id>
      <parentid>70973</parentid>
      <timestamp>2014-06-04T17:21:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention that non-virtual interface avoids the trap with virtuals</comment>
      <text xml:space="preserve" bytes="7003">{{title|Default arguments}}
{{cpp/language/functions/navbar}}

Allows a function to be called without providing one or more trailing arguments.

Indicated by using the following syntax for a parameter in the {{spar|parameter-list}} of a {{rlp|function|function declaration}}.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|declarator}} {{ttb|{{=}} }} {{spar|initializer}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|abstract-declarator}}{{mark optional}} {{ttb|{{=}} }} {{spar|initializer}}
}}
{{sdsc end}}

Default arguments are used in place of the missing trailing arguments in a function call:
{{source|1=
void point(int x = 3, int y = 4);

point(1,2); // calls point(1,2)
point(1);   // calls point(1,4)
point();    // calls point(3,4)
}}

No other parameters can appear in a function declaration after a default parameter (except for the ellipsis parameter)

{{source|1=
int f(int = 1, int); // error
int g(int n = 0, ...); // ok
}}

Default arguments are only allowed in function declarations, and are not allowed in the declarations of pointers to functions, references to functions, or in {{rlp|typedef}} declarations.

For non-template functions, default arguments can be added to a function that was already declared if the function is redeclared in the same scope. At the point of a function call, the defaults are a union of the defaults provided in all visible declarations for the function. A redeclaration cannot introduce a default for an argument for which a default is already visible (even if the value is the same). A re-declaration in an inner scope does not acquire the default arguments from outer scopes.
{{source|1=
void f(int, int);     // #1 
void f(int, int = 7); // #2 OK: adds a default

void h() {
    f(3); // #1 and #2 are in scope; makes a call to f(3,7)
    void f(int =1, int); // Error: inner scope declarations don't acquire defaults
}

void m() { // new scope begins
    void f(int, int); // inner scope declaration; has no defaults.
    f(4); // Error: not enough arguments to call f(int, int)
    void f(int, int = 6); 
    f(4); // OK: calls f(4,6);
    void f(int, int = 6); // Error: cannot redeclare a default in the same scope
}

void f(int = 1, int); // #3 OK, adds a default to #2

void n() { // new scope begins 
    f(); // #1, #2, and #3 are in scope: calls f(1, 7);
}
}}

If an {{rlp|inline}} function is declared in different translation units, the accumulated sets of default arguments must be the same at the end of each translation unit.

If a {{rlp|friend}} declaration specifies a default, it must be a friend function definition, and no other declarations of this function are allowed in the translation unit.

The {{rlp|namespace#Using-declarations|using-declaration}} carries over the set of known default arguments, and if more arguments are added later to the function's namespace, those defaults are also visible anywhere the using-declaration is visible
{{source|1=
namespace N {
    void f(int, int = 1);
}
using N::f;
void g() {
    f(7); // calls f(7, 1);
    f();  // error
}
namespace N {
    void f(int = 2, int);
}
void h() {
    f();  // calls f(2, 1);
}
}}

The names used in the default arguments are looked up and bound at the point of declaration, but are executed at the point of the function call:
{{source|1=
int a = 1;
int f(int);
int g(int x = f(a)); // lookup for f finds ::f, lookup for a finds ::a
                     // the value of ::a, which is 1 at this point, is not used
void h()
{
  a = 2;  // changes the value of ::a
  {
     int a = 3;
     g();       // calls f(2), then calls g() with the result
  }
}

}}

For a {{rlp|member functions|member function}} of a non-template class, the default arguments are allowed on the out-of-class definition, and are combined with the default arguments provided by the declaration inside the class body. If these out-of-class defaults would turn a member function into a default, copy, or move constructor the program is ill-formed. For member functions of class templates, all defaults must be provided in the initial declaration of the member function.
{{source|1=
class C {
    void f(int i = 3);
    void g(int i, int j = 99);
    C(int arg); // non-default constructor
};
void C::f(int i = 3) {         // error: default argument already
}                              // specified in class scope
void C::g(int i = 88, int j) { // OK: in this translation unit,
}                              // C::g can be called with no argument
C::C(int arg = 1) {   // Error: turns this into a default constructor
}
}}

The overriders of {{rlp|virtual}} functions do not acquire the default arguments from the base class declarations, and when the virtual function call is made, the default arguments are decided based on the static type of the object (note: this can be avoided with [http://www.gotw.ca/publications/mill18.htm non-virtual interface] pattern).
{{source|1=
struct Base {
    virtual void f(int a = 7);
};
struct Derived : Base {
    void f(int a) override;
};
void m() {
    Derived d;
    Base&amp; b = d;
    b.f(); // OK: calls Derived::f(7) 
    d.f(); // Error: no default 
}
}}

Local variables are not allowed in default arguments:
{{source|1=
void f() 
{
    int n = 1;
    extern void g(int x = n); // error: local variable cannot be a default
}
}}

The {{rlp|this}} pointer is not allowed in default arguments:
{{source|1=
class A {
  void f(A* p = this) { } // error: this is not allowed
};
}}

Non-static class members are not allowed in default arguments (even if they are not evaluated), except when used to form a pointer-to-member or in a member access expression.
{{source|1=
int b;
class X {
  int a;
  int mem1(int i = a); // error: non-static member cannot be used
  int mem2(int i = b); // OK: lookup finds X::b, the static member
  static int b;
};
}}

Function parameters are not allowed in default arguments (even if they are not evaluated). Note that parameters that appear earlier in the parameter list are in {{rlp|scope}}:
{{source|1=
int a;
int f(int a, int b = a); // Error: the parameter a used in a default argument
int g(int a, int b = sizeof(a)); // Error: parameter a is used in a default argument
}}

The default arguments are not part of the function type
{{source|1=
int f(int = 0);
void h() {
  int j = f(1);
  int k = f();  // calls f(0);
}
int (*p1)(int) = &amp;f;
int (*p2)()    = &amp;f; //Error: the type of f is int(int)
}}


If a {{rlp|lambda|lambda-expression}} appears in a default argument, it cannot explicitly or implicitly capture anything.
{{source|1=
void f2() {
    int i = 1;
    void g1(int = ([i]{ return i; })()); // error: captures something
    void g2(int = ([i]{ return 0; })()); // error: captures something
    void g3(int = ([=]{ return i; })()); // error: captures something
    void g4(int = ([=]{ return 0; })());       // OK: capture-less
    void g5(int = ([]{ return sizeof i; })()); // OK: capture-less
}
}}</text>
      <sha1>p63l5jc9qn2g8xgu03eceka32jufa41</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/default constructor</title>
    <ns>0</ns>
    <id>5292</id>
    <revision>
      <id>71629</id>
      <parentid>71628</parentid>
      <timestamp>2014-06-17T04:36:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-part about signature is only for copy/move/as</comment>
      <text xml:space="preserve" bytes="5136">{{title|Default constructors}}
{{cpp/language/classes/navbar}}

A default constructor is a constructor which can be called with no arguments (either defined with an empty parameter list, or with default arguments provided for every parameter). A type with a public default constructor is {{concept|DefaultConstructible}}.

===Syntax===
{{sdsc begin}}
{{sdsc|num=1|{{ttb|ClassName}} {{ttb|(}} {{ttb|)}} {{ttb|;}} }}
{{sdsc|num=2|{{ttb|ClassName}} {{ttb|::}} {{ttb|ClassName}} {{ttb|(}} {{ttb|)}} {{spar|body}} }}
{{sdsc|num=3|{{ttb|ClassName()}} {{ttb|{{=}}}} {{ttb|delete}} {{ttb|;}}|notes={{mark since c++11}} }}
{{sdsc|num=4|{{ttb|ClassName()}} {{ttb|{{=}}}} {{ttb|default}} {{ttb|;}}|notes={{mark since c++11}} }}
{{sdsc end}}

===Explanation===
@1@ Declaration of a default constructor
@2@ Definition of the constructor outside the class body
@3@ Inhibiting the automatic generation of a default constructor
@4@ Explicitly forcing the automatic generation of a default constructor

{{ttb|ClassName}} is the identifier of the enclosing class

The default constructors are called during {{rlp|default initialization}}s and {{rlp|value initialization}}s.

===Implicitly-declared default constructor===
If no user-defined constructors of any kind are provided for a class type ({{c|struct}}, {{c|class}}, or {{c|union}}), the compiler will always declare a default constructor as an {{tt|inline public}} member of its class. 

{{rev begin}}
{{rev|since=c++11|If some user-defined constructors are present, the user may still force the generation of the implicitly declared constructor with the keyword {{tt|default}}}}
{{rev end}}

If the implicitly-declared default constructor is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler, and it has exactly the same effect as a user-defined constructor with empty body and empty initializer list. That is, it calls the default constructors of the bases and of the non-static members of this class.

===Deleted implicitly-declared default constructor===
The implicitly-declared or defaulted default constructor for class {{tt|T}} is {{rev inl|until=c++11| undefined }}{{rev inl|since=c++11|defined as ''deleted''}} if any of the following is true:
* {{tt|T}} has a member of reference type {{rev inl|since=c++11|without a brace-or-equal initializer.}}
* {{tt|T}} has a {{c|const}} member without user-defined default constructor {{rev inl|since=c++11|or a brace-or-equal initializer}}.
* {{tt|T}} has a member {{rev inl|since=c++11|(without a brace-or-equal initializer)}}, which has a deleted default constructor, or its default constructor is ambiguous or inaccessible from this constructor.
* {{tt|T}} has a direct or virtual base which has a deleted default constructor, or it is ambiguous or inaccessible from this constructor.
* {{tt|T}} has a direct or virtual base which has a deleted destructor, or a destructor that is inaccessible from this constructor.
{{rev begin}}
{{rev|since=c++11|
* {{tt|T}} is a {{c|union}} with at least one variant member with non-trivial default constructor.}}
{{rev end}}
* {{tt|T}} is a {{c|union}} and all of its variant members are {{c|const}}.

===Trivial default constructor===
The default constructor for class {{tt|T}} is trivial (i.e. performs no action) if all of the following is true:
* The constructor is not user-provided (that is, implicitly-defined or defaulted)
* {{tt|T}} has no virtual member functions
* {{tt|T}} has no virtual base classes
{{rev begin}}
{{rev | since=c++11 |
* {{tt|T}} has no non-static members with brace-or-equal initializers.
}}
{{rev end}}
* Every direct base of {{tt|T}} has a trivial default constructor
* Every non-static member of class type has a trivial default constructor

A trivial default constructor is a constructor that performs no action. Objects with trivial default constructors can be created by using [[cpp/language/reinterpret_cast|reinterpret_cast]] on any suitably aligned storage, e.g. on memory allocated with {{lc|std::malloc}}. All data types compatible with the C language (POD types) are trivially default-constructible.

===Example===
{{source|code=
struct A {
    int x;
    A(int x = 1) : x(x) {} // user-defined default ctor
};
struct B : A {
    // B::B() is implicitly-defined, calls A::A()
};
struct C {
    A obj;
    // C::C() is implicitly-defined, calls A::A()
};
struct D : A {
    D(int y) : A(y) {}
    // D::D() is not declared because another constructor exists
};
struct E : A
{
    E(int y) : A(y) {}
    E() = default; // explicitly defaulted, calls A::A()
};

struct F {
    int&amp; ref; // reference member
    const int c; // const member
    // F::F() is implicitly declared as deleted
};

int main()
{
    A a;
    B b;
//  D d; // compile error
    E e;
//  F f; // compile error
}
}}

[[de:cpp/language/default constructor]]
[[es:cpp/language/default constructor]]
[[fr:cpp/language/default constructor]]
[[it:cpp/language/default constructor]]
[[ja:cpp/language/default constructor]]
[[pt:cpp/language/default constructor]]
[[ru:cpp/language/default constructor]]
[[zh:cpp/language/default constructor]]</text>
      <sha1>bkyq19o18bob40vw42a1dzwzegwm53q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/default initialization</title>
    <ns>0</ns>
    <id>8863</id>
    <revision>
      <id>71805</id>
      <parentid>71803</parentid>
      <timestamp>2014-06-24T17:49:01Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <comment>Made the summary a complete sentence rather than just an expression.</comment>
      <text xml:space="preserve" bytes="4142">{{title|default initialization}}
{{cpp/language/initialization/navbar}}
This is the initialization performed when a variable is constructed with no initializer.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{spar| object}} {{ttb|;}}}}
{{sdsc | num=2 |{{ttb|new }} {{spar|T}} {{ttb|;}}}}
{{sdsc end}}

===Explanation===

Default initialization is performed in three situations:
@1@ when a variable with automatic, static, or thread-local {{rlp|storage duration}} is declared with no initializer
@2@ when an object with dynamic storage duration is created by a new-expression without an initializer
@3@ when a base class or a non-static data member is not mentioned in a constructor [[cpp/language/initializer_list|initializer list]] and that constructor is called.

The effects of default initialization are:

* If {{tt|T}} is a class type, the [[cpp/language/default_constructor|default constructor]] is called to provide the initial value for the new object.

* If {{tt|T}} is an array type, every element of the array is default-initialized.

* Otherwise, nothing is done.

If {{tt|T}} is a const-qualified type, it must be a class type with a user-provided default constructor.

{{rev begin}}
{{rev|since=c++14|
Use of an indeterminate value obtained by default-initializing a non-class variable of any type is ''undefined behavior'', except in the following cases:
* if the indeterminate value of unsigned narrow character type is assigned to another variable with unsigned narrow character type (the value of the variable becomes indeterminate, but the behavior is not undefined)
* if the indeterminate value of unsigned narrow character type is used to initialize another variable with unsigned narrow character type
* if the indeterminate value of unsigned narrow character type results from
:* the second or third operand of a conditional expression
:* the right operand of the comma operator
:* the operand of a cast or conversion to an unsigned narrow character type
:* a discarded-value expression
{{source|1=
int f(bool b)
{
    int x; // value of x is indeterminate
    int y = x; // undefined behavior
    unsigned char c; // value of c is indeterminate
    unsigned char d = c; // OK, value of d is indeterminate
    int e = d; // undefined behavior
    return b ? d : 0; // undefined behavior if b is true
}
}}
}}
{{rev end}}

===Notes===
Default initialization of non-class variables with automatic and dynamic storage duration produces objects with indeterminate values (static and thread-local objects get [[cpp/language/zero_initialization|zero initialized]])

Reference cannot be default-initialized.

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
struct T1 {};
class T2 { 
    int mem;
 public:
    T2() {} // &quot;mem&quot; not in initializer list
};
int n; // A two-phase initialization is done
       // In the first phase, zero initialization initializes n to zero
       // In the second phase, default initialization does nothing, leaving n being zero
int main()
{
    int n;            // non-class: the value is undeterminate
    std::string s;    // calls default ctor, the value is &quot;&quot; (empty string)
    std::string a[2]; // calls default ctor, creates two empty strings
//    int&amp; r;         // error: default-initializing a reference
//    const int n;    // error: const non-class type
//    const T1 nd;    // error: const class type with implicit ctor
    T1 t1; // ok, calls implicit default ctor
    const T2 t2; // ok, calls the user-provided default ctor 
                 // t2.mem is default-initialized (to indeterminate value)
}
 | output=
}}

===See also===
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/default initialization]]
[[es:cpp/language/default initialization]]
[[fr:cpp/language/default initialization]]
[[it:cpp/language/default initialization]]
[[ja:cpp/language/default initialization]]
[[pt:cpp/language/default initialization]]
[[ru:cpp/language/default initialization]]
[[zh:cpp/language/default initialization]]</text>
      <sha1>hwjy76qnvlxtpdmieie31q5uu2ocfuy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/definition</title>
    <ns>0</ns>
    <id>13180</id>
    <revision>
      <id>72332</id>
      <parentid>69683</parentid>
      <timestamp>2014-08-11T21:58:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>wip</comment>
      <text xml:space="preserve" bytes="6025">{{title|Definitions and ODR}}
{{cpp/language/basics/navbar}}
''Definitions'' are {{rlp|declarations}} that fully define the entity introduced by the declaration. Every declaration is a definition, except for the following:

@1@ Any declaration with an {{c|extern}} {{rlp|storage_duration|storage class specifier}} or with a {{rlp|language linkage}} specifier (such as {{c|extern &quot;C&quot;}}) without an initializer
{{source|1=
extern const int a; // declares, but doesn't define a
extern const int b = 1; // defines b
}}
@2@ Function declaration without a function body
{{source|int f(int); // declares, but doesn't define f}}
@3@ Parameter declaration in a function declaration that isn't a definition
{{source|
int f(int x); // declares, but doesn't define f and x
int f(int x) { // defines f and x
     return x+a;
}
}}
@4@ Declaration of a {{rlp|static|static data member}} inside a class definition
{{source|
struct S {    // defines S
    int n;        // defines S::n
    static int i; // declares, but doesn't define S::i
};
int S::i; // defines S::i
}}
@5@ Declaration of a class name (by {{rlp|class#Forward declaration|forward declaration}} or by the use of the elaborated type specifier in another declaration)
{{source|
struct S; // declares, but doesn't define S
class Y f(class T p); // declares, but doesn't define Y and T (and also f and p)
}}
@6@ Declaration of a {{rlp|template parameters|template parameter}}
{{source|
template&lt;typename T&gt; // declares, but doesn't define T
}}
@7@ {{rlp|typedef}} declaration
{{source|1=
typedef S S2; // declares, but doesn't define S2 (S may be incomplete)
}}
* {{mark c++11}} {{rlp|type alias|alias-declaration}}
{{source|1=
using S2 = S; // declares, but doesn't define S2 (S may be incomplete)
}}
* {{mark c++11}} {{rlp|enum|Opaque declaration}} of an enumeration.
{{source|
enum Color : int; // declares, but doesn't define Color
}}
* {{rlp|using declaration|using-declaration}}
{{source|1=
using N::d; // declares, but doesn't define d
}}
* {{rlp|namespace#Using-directives|using-directive}} (does not define any entities)
* {{mark c++11}} {{rlp|static_assert}} declaration (does not define any entities)
* {{mark c++11}} {{rlp|declarations|Attribute declaration}} (does not define any entities)
* {{rlp|declarations|Empty declaration}} (does not define any entities)

Although {{rlp|asm|asm declaration}} does not define any entities as well, it is a definition.

Where necessary, the compiler may implicitly define the {{rlp|default constructor}}, {{rlp|copy constructor}}, {{rlp|move constructor}}, {{rlp|as_operator|copy assignment operator}}, {{rlp|move_operator|move assignment operator}}, and the {{rlp|destructor}}.

If the definition of any object results in an object of {{rlp|incomplete type}}, the program is ill-formed.

===One Definition Rule===
Only one definition of any variable, function, class type, enumeration type, or template is allowed in any one translation unit.

One and only one definition of every non-{{rlp|inline}} function or variable that is ''odr-used'' (see below) is required to appear in the entire program (including any standard and user-defined libraries). The compiler is not required to diagnose this violation, but the behavior of the program that violates it is undefined.

For an inline function, a definition is required in every translation unit where it is ''odr-used''

One and only one definition of a class is required to appear in any translation unit where the class is used in a way that requires it to be {{rlp|incomplete type|complete}}.

There can be more than one definition in a program, as long as each definition appears in a different translation unit, of each of the following: class type, enumeration type, inline function with external linkage, class template, non-static function template, static data member of a class template, member function of a class template, partial template specialization, as long as all of the following is true:
* each definition consists of the same sequence of tokens (typically, appears in the same header file)
* name lookup from within each definition finds the same entities (after overload-resolution), except that constants with internal or no linkage may refer to different objects as long as they are not ODR-used and have the same values in every definition.
* overloaded operators, including conversion, allocation, and deallocation functions refer to the same function from each definition (unless referring to one defined within the definition)
* the language linkage is the same (e.g. the include file isn't inside an extern &quot;C&quot; block)
* the three rules above apply to every default argument used in each definition
* if the definition is for a class with an implicitly-declared constructor, every translation unit where it is odr-used must call the same constructor for the base and members
* if the definition is for a template, then all these requirements apply to both names at the point of definition and dependent names at the point of instantiation

If all these requirements are satisfied, the program behaves as if there is only one definition in the entire program. Otherwise, the behavior is undefined. 

====ODR-use====

* a variable is odr-used if its name appears as a potentially-evaluated expression, except if all of the following is true:
:* applying lvalue-to-rvalue conversion to the exression yields a constant expression that doesn't invoke non-trivial functions
:* the expression is either discarded-value expression or an lvalue-to-rvalue conversion
* {{rlp|this}} is odr-used if it appears as a potentially-evaluated expression (including the implicit this in a non-static member function call expression)
* virtual member function is odr-used if it is not a pure virtual member function
A function whose name appears as a potentially-evaluated expression is odr-used if it is
the unique lookup result or the selected member of a set of overloaded functions
{{todo|work in progress: rest of 3.2 and templates, micro-examples as needed}}</text>
      <sha1>2x2ay6izskhy0etxjigcobw2bjolvxa</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/delete</title>
    <ns>0</ns>
    <id>692</id>
    <revision>
      <id>72367</id>
      <parentid>70014</parentid>
      <timestamp>2014-08-15T17:52:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>&quot;Otherwise, the delete-expression will not call a deallocation function&quot; 5.3.5/7</comment>
      <text xml:space="preserve" bytes="3994">{{title|delete expression}}
{{cpp/language/expressions/navbar}}

Destructs object(s) previously allocated by the {{rlp|new | new expression}} and releases obtained memory area

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|::}}{{mark optional}} &amp;nbsp;&amp;nbsp; {{ttb|delete &amp;nbsp;&amp;nbsp;}} {{spar|expression}} }}
{{sdsc | num=2 | {{ttb|::}}{{mark optional}} &amp;nbsp;&amp;nbsp; {{ttb|delete []}} {{spar|expression}} }}
{{sdsc end}}

@1@ Destroys one non-array object created by a {{rlp|new|new-expression}}
@2@ Destroys an array created by a {{rlp|new|new[]-expression}}

===Explanation===
For the first (non-array) form, {{spar|expression}} must be a pointer or a class type {{rlp|implicit cast|contextually implicitly convertible}} to a pointer, and its value must be either ''null'' or pointer to a non-array object created by a {{rlp|new|new-expression}}, or a pointer to a base subobject of a non-array object created by a {{rlp|new|new-expression}} (if it's anything else, the behavior is undefined).

For the second (array) form, {{spar|expression}} must be a null pointer value or a pointer value previously obtained by an array form of {{rlp|new|new-expression}}.

If {{spar|expression}} is not a null pointer, the {{tt|delete}} expression invokes the {{rlp|destructor}} (if any) for the object that's being destroyed, or for every element of the array being destroyed (proceeding from the last element to the first element of the array). 

After that, {{rev inl|since=c++14|unless the matching new-expression was combined with another}} the delete expression invokes the [[cpp/memory/new/operator_delete | deallocation function]], either {{c|operator delete}} (for the first version of the expression) or {{c|operator delete[]}} (for the second version of the expression).

The deallocation function's name is {{rlp|lookup|looked up}} in the scope of the dynamic type of the object pointed to by {{spar|expression}}, which means class-specific deallocation functions, if present, are found before the global ones. If {{ttb|::}} is present in the {{tt|delete}} expression, only the global namespace is looked up. The prototype of the function must look like the following:

{{dcl begin}}
{{dcl | notes=for the first version |
void operator delete  (void *ptr);
}}
{{dcl | notes=for the second version |
void operator delete[](void *ptr);
}}
{{dcl end}}

When overridden in class scope (and, since C++14, in global scope as well), optional second parameter may be used, in which the ''delete-expression'' will pass the size of the object that is being deallocated.
{{dcl begin}}
{{dcl | notes=for the first version |
void operator delete  (void *ptr, std::size_t sz);
}}
{{dcl | notes=for the second version |
void operator delete[](void *ptr, std::size_t sz);
}}
{{dcl end}}

These functions are implicitly declared in each translation unit and implicit implementations are provided by the compiler by default, unless the program has explicitly implemented them. See [[cpp/memory/new/operator_delete | deallocation functions]] for more information.

{{rev begin}}
{{rev|until=c++14|
If {{spar|expression}} evaluates to a null pointer value, no destructors are called, and
the deallocation function may or may not be called (it's implementation-defined), but the default deallocation functions are guaranteed to do nothing when handed a null pointer.
}}
{{rev|since=c++14|
If {{spar|expression}} evaluates to a null pointer value, no destructors are called, and the deallocation function is not called.
}}
{{rev end}}

If {{spar|expression}} evaluates to a pointer to the base class subobject of the object that was allocated with {{rlp|new}}, the destructor of the base class must be virtual, otherwise the behavior is undefined.

===Keywords===

{{ltt|cpp/keyword/delete}}

[[de:cpp/language/delete]]
[[es:cpp/language/delete]]
[[fr:cpp/language/delete]]
[[it:cpp/language/delete]]
[[ja:cpp/language/delete]]
[[pt:cpp/language/delete]]
[[ru:cpp/language/delete]]
[[zh:cpp/language/delete]]</text>
      <sha1>on6tmq9njw7vszyaok1gnqqv42r6lgt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/dependent name</title>
    <ns>0</ns>
    <id>9611</id>
    <revision>
      <id>71717</id>
      <parentid>71715</parentid>
      <timestamp>2014-06-21T20:40:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>reviewed dependency definitions, applied cwg 1413</comment>
      <text xml:space="preserve" bytes="18078">{{title|Dependent names}}
{{cpp/language/templates/navbar}}

Inside the definition of a template (both {{rlp|class template}} and {{rlp|function template}}), the contents of some types and the values and the types of some expressions are not known until the template is instantiated, because they depend on template parameters.

===Dependent types===

The following types are dependent types:

* template parameter
* a member of an ''unknown specialization'' (see below)
* a nested class/enum that is a dependent member of ''unknown specialization'' (see below)
* a cv-qualified version of a dependent type
* a compound type constructed from a dependent type
* an array type constructed from a dependent type, or whose size is a value-dependent constant expression (see below)
* a template-id where either the template name is a template parameter, or any of template arguments is type- or value-dependent
* the result of {{rlp|decltype}} applied to a type-dependent expression

Note: a typedef member of a current instantiation is only dependent the type it refers to is.

===Type-dependent expressions===

The following expressions are type-dependent

* an expression whose any subexpression is a type-dependent expression
* {{c|this}}, if the class is a dependent type.
* an {{rlp|identifiers|id-expression}} that
:* contains an identifier for which name lookup finds at least one dependent declaration
:* contains a dependent template-id
:* contains the name of {{rlp|cast operator|conversion function}} to a dependent type
:* contains a nested name specifier or {{rlp|identifiers|qualified-id}} that is a member of ''unknown specialization''
:* names a dependent member of the ''current instantiation'' which is a static data member of type &quot;array of unknown bound&quot;
* any cast expression to a dependent type
* {{rlp|new|new-expression}} that creates an object of a dependent type
* member access expression that refers to a member of the ''current instantiation'' whose type is dependent
* member access expression that refers to a member of ''unknown specialization''

Note: literals, pseudo-destructor calls, {{rlp|sizeof}}, {{rlp|alignof}}, {{rlp|typeid}}, {{rlp|delete}}-expressions, {{rlp|throw}}-expressions, and {{rlp|noexcept}}-expressions are never type-dependent because the types of these expressions cannot be.

===Value-dependent expressions===

* a {{rlp|constant expression}} whose any subexpression is value-dependent
* an {{rlp|identifiers|id-expression}} that
:* is a name declared with a dependent type
:* is a name of a non-type template parameter
:* names a member of ''unknown specialization''

{{rev begin}}
{{rev|since=c++14|
:* names a static data member that is a dependent member of the ''current instantiation'' and is not initialized.
:* names a static member function that is a depndent member of the ''current instantiation''
}}
{{rev end}}
:* is a constant with a literal type, initialized from a value-dependent expression
* {{rlp|sizeof}}, {{rlp|alignof}}, {{rlp|typeid}}, {{rlp|noexcept}}-expressions where the argument is a type-dependent expression or a dependent type-id
* any cast expression to a dependent type or from a value-dependent expression

{{rev begin}}
{{rev|since=c++14|
* address-of expression where the argument is {{rlp|identifiers|qualified-id}} that names a dependent member of the ''current instantiation''
}}
{{rev end}}

===Binding rules===
Non-dependent names are looked up and bound at the point of template definition. This binding holds even if at the point of template instantiation there is a better match: 

{{example
| code=
#include &lt;iostream&gt;
void g(double) { std::cout &lt;&lt; &quot;g(double)\n&quot;; }

template&lt;class T&gt;
struct S {
    void f() const {
        g(1); // non-dependent expression, bound now
    }
};

void g(int) { std::cout &lt;&lt; &quot;g(int)\n&quot;; }

int main()
{
    g(1); // calls g(int)

    S&lt;int&gt; s;
    s.f(); // calls g(double)
}
}}

===Lookup rules===
As discussed in {{rlp|lookup}}, the lookup of a dependent name used in a template is postponed until the template arguments are known, at which time
* non-ADL lookup examines function declarations with external linkage that are visible from the ''template definition'' context
* {{rlp|adl|ADL}} examines function declarations with external linkage that are visible from both the ''template definition'' context and the ''template instantiation'' context
(in other words, adding a new function declaration after template definition does not make it visible, except via ADL).

The purpose of this is rule is to help guard against violations of the {{rlp|odr|ODR}} for template instantiations:
{{source|1=
// an external libary
namespace E {
  template&lt;typename T&gt;
  void writeObject(const T&amp; t) {
    std::cout &lt;&lt; &quot;Value = &quot; &lt;&lt; t &lt;&lt; '\n';
  }
}

// translation unit 1:
// Programmer 1 wants to allow E::writeObject to work with vector&lt;int&gt;
namespace P1 {
  std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const std::vector&lt;int&gt;&amp; v) {
      for(int n: v) os &lt;&lt; n; return os;
  }
  void doSomething() {
    std::vector&lt;int&gt; v;
    E::writeObject(v); // error: will not find P1::operator&lt;&lt;
  }
}

// translation unit 2:
// Programmer 2 wants to allow E::writeObject to work with vector&lt;int&gt;
namespace P2 {
  std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const std::vector&lt;int&gt;&amp; v) {
      for(int n: v) os &lt;&lt; n; return os;
  }
  void doSomethingElse() {
    std::vector&lt;int&gt; v;
    E::writeObject(v); // error: will not find P2::operator&lt;&lt;
  }
}
}}
In the above example, if non-ADL lookup for operator&lt;&lt; were allowed from the instantiation context, the instantiation of {{c|E::writeObject&lt;vector&lt;int&gt;&gt;}} would have two different definitions: one using {{c|P1::operator&lt;&lt;}} and one using {{c|P2::operator&lt;&lt;}}. Such ODR violation may not be detected by the linker, leading to one or the other being used in both instances.

To make argument-dependent lookup examine a user-defined namespace, either {{tt|std::vector}} should be replaced by a user-defined class or its element type should be a user-defined class:
{{source|1=
namespace P1 {
  // if C is a class defined in the P1 namespace
  std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const std::vector&lt;C&gt;&amp; v) {
      for(C n: v) os &lt;&lt; n; return os;
  }
  void doSomething() {
    std::vector&lt;C&gt; v;
    E::writeObject(v); // OK: instantiates writeObject(std::vector&lt;P1::C&gt;)
                       //     which finds P1::operator&lt;&lt; via ADL
  }
}
}}

Note: this rule makes it impractical to overload operators for standard library types
{{example|code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;
#include &lt;utility&gt;

// Bad idea: operator in global namespace, but its arguments are in std::
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, std::pair&lt;int, double&gt; p)
{
    return os &lt;&lt; p.first &lt;&lt; ',' &lt;&lt; p.second;
}

int main()
{
    typedef std::pair&lt;int, double&gt; elem_t;
    std::vector&lt;elem_t&gt; v(10);
    std::cout &lt;&lt; v[0] &lt;&lt; '\n'; // OK, ordinary lookup finds ::operator&lt;&lt;
    std::copy(v.begin(), v.end(),
              std::ostream_iterator&lt;elem_t&gt;(std::cout, &quot; &quot;)); // Error: both ordinary 
    // lookup from the point of definition of std::ostream_iterator and ADL will 
    // only consider the std namespace, and will find many overloads of
    // std::operator&lt;&lt;, so the lookup will be done. Overload resolution will then
    // fail to find operator&lt;&lt; for elem_t in the set found by the lookup.
}
}}

=== Current instantiation ===

Within the definition of a template class or nested class of a template class (or member function thereof), some names will be immediately bound to members of that class.

In such a context, the term ''current instantiation'' simply refers to the instantiation of that class template with its given parameters as arguments (i.e. the class or member that is actually being defined):

{{example|code=
template &lt; typename T1, typename T2 &gt; struct C {

  C *p1;                // C is the current instantiation
  C&lt; T1, T2 &gt; *p2;      // C&lt; T1, T2 &gt; is the current instantiation
  C&lt; T1 *, T2 * &gt; *p3;  // C&lt; T1 *, T2 * &gt; is not the current instantiation
  C&lt; T2, T1 &gt; *p4;      // C&lt; T2, T1 &gt; is not the current instantiation

  struct D {
    D *q0;                  // D is the current instantiation
    C::D *q1;               // C::D is the current instantiation
    C&lt; T1, T2 &gt;::D *q2;     // C&lt; T1, T2 &gt;::D is the current instantiation
    C&lt; T1 *, T2 * &gt;::D *q3; // C&lt; T1 *, T2 * &gt;::D is not the current instantiation
    C&lt; T2, T1 &gt;::D *q4;     // C&lt; T2, T1 &gt;::D is not the current instantiation
  };
};

template &lt; typename T1, typename T2 &gt; struct C&lt; T1 *, T2 * &gt; {
  C *p1;                // C is the current instantiation
  C&lt; T1 *, T2 * &gt; *p2;  // C&lt; T1 *, T2 * &gt; is the current instantiation
  C&lt; T1, T2 &gt; *p3;      // C&lt; T1, T2 &gt; is not the current instantiation
};
}}

Specifically, the current instantiation is referenced within a class template by one of:

* the template name [''Ex:'' {{c|C}} in both templates above]
* the template name with its formal parameters as arguments [''Ex:'' {{c|C&lt; T1, T2 &gt;}} within the primary template above, {{c|C&lt; T1 *, T2 * &gt;}} within the partial specialization above]

Or, within a nested class of a class template:

* the nested class name referenced as a member of the current instantiation [''Ex:'' {{c|D}}, {{c|C::D}}, {{c|C&lt; T1, T2 &gt;::D}} above].

A name used within a template class or class member, though dependent, may be understood to reference a member of the current instantiation:

{{example|code=
struct Z { int z; };
template &lt; typename T &gt; struct Y { int y; };
template &lt; typename T &gt; struct A: public B&lt; T &gt;, public Z {
  int i;
  int getI() const { return i; }            // refers to i declared above
  int getI2() const { return A::i; }        // refers to i declared above
  int getI3() const { return A&lt; T &gt;::i; }   // refers to i declared above
  int getJ() const { return A&lt; T &gt;::j; }    // could perhaps be B&lt; T &gt;::j
  int getK() const { return A&lt; T * &gt;::k; }  // could perhaps be B&lt; T &gt;::k
                                            //  or a member k of a 
                                            //  partial or explicit 
                                            //  specializaton of A
  int getZ() const { return z; }            // refers to Z::z
  int getY() const { return Y&lt; T &gt;::y; }    // refers to Y&lt; T &gt;::y	      

  static int getI(A *a) { return a-&gt;i; }        // refers to A::i in (*a)
  static int getJ(A *a) { return a-&gt;j; }        // could perhaps be B&lt; T &gt;::j in (*a)
  static int getK(A&lt; T &gt; *a) { return a-&gt;k; }   // could perhaps be B&lt; T &gt;::k in (*a)
                                                //  or a member k of a partial or 
                                                //  explicit specializaton of A in (*a)
  static int getZ(A *a) const { return a-&gt;z; }  // refers to Z::z in (*a)	
};
}}

A name is a ''member of the current instantiation'' if it is either:
* an unqualified class member name [''Ex:'' {{c|i}} above]
* an unqualified member name of a non-[[cpp/language/dependent name#Dependent types|dependent]] base class [''Ex:'' {{c|z}} above]
* a qualified class member name, where the class name is the current instantiation [''Ex:'' {{c|A::i}} or {{c|A&lt; T &gt;::i}} above]
* an object member reference, where the object type is the current instantiation [''Ex:'' {{c|a-&gt;i}} above]

Note that it is implicit in these requirements that name lookup finds a declaration of the name within the scope of the class.

=== Unknown specializations ===

Within a template class or function definition, lookup of a qualified name or object member reference may be delayed until instantiation if it is deemed to be a member of an ''unknown specialization'' (i.e. belonging to a template specialization whose definition is not yet known).  Such a specialization could be:

* a [[cpp/language/dependent name#Dependent types|dependent]] base class
* a partial or explicit specialization of the given template
* a specialization of an entirely different template

Referring to the second example in the section on [[cpp/language/dependent name#Current instantiation|Current instantiation]], within a class scope, a qualified name or object member reference is a ''member of an unknown specialization'' if the qualifying class or object type (call it ''QT'') is [[cpp/language/dependent name#Dependent types|dependent]] and either:

* ''QT'' is not the current instantiation [''Ex:'' {{c|A&lt; T * &gt;::k}}, {{c|Y&lt; T &gt;::y}}, {{c|a-&gt;k}} above]
* ''QT'' is the current instantiation, ''but'' does not contain a declaration of the name ''and'' has at least one [[cpp/language/dependent name#Dependent types|dependent]] base [''Ex:'' {{c|A&lt; T &gt;::j}}, {{c|a-&gt;j}} above]

The latter case implies that when the qualified name or object type is the current instantiation, then either the name must be declared within the class or the class must have a [[cpp/language/dependent name#Dependent types|dependent]] base.

[''Note:'' Within a non-member function template, all such names with [[cpp/language/dependent name#Dependent types|dependent]] qualifying/object types are considered to be members of unknown specializations, since obviously there are no members to speak of in such a scope.]

An attempt to refer to a name whose qualifier is the current instantiation, but which is neither a member of current instantiation nor a member of unknown specialization can be reported as an error immediately:

{{source|1=template&lt;typename T&gt; struct Base {};

template&lt;typename T&gt;
struct Derived : Base&lt;T&gt; {
    void f() {
        // unknown_type is a member of unknown specialization of Base&lt;T&gt;
        // lookup deferred
        typename Derived&lt;T&gt;::unknown_type z;
    }
};

template&lt;&gt; struct Base&lt;int&gt; { // this specialization provides it
    typedef int unknown_type; 
};

template&lt;typename T&gt;
struct A {
   void f() {
       // error_type is not a member of unknown specialization
       // (there is no base that could define it)
       // and not a member of current instantiation either
       // Error (may be) detected immediately
       typename A&lt;T&gt;::error_type y;
   }
};

}}

===The {{c|typename}} disambiguator for dependent names===

In a declaration or a definition of a template, including alias template, a name that is not a member of the current instantiation and is dependent on a template parameter is not considered to be a type unless the keyword {{c|typename}} is used or unless it was already established as a type name, e.g. with a typedef declaration or by being used to name a base class.

{{example|code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

int p = 1;
template &lt;typename T&gt;
void foo (const std::vector&lt;T&gt; &amp;v)
{

    // std::vector&lt;T&gt;::const_iterator is a dependent name,
    typename std::vector&lt;T&gt;::const_iterator it = v.begin();

    // without 'typename', the following is parsed as multiplication 
    // of the type-dependent member variable 'const_iterator' 
    // and some variable 'p'. Since there is a global 'p' visible
    // at this point, this template definition compiles.
    std::vector&lt;T&gt;::const_iterator* p; 

    typedef typename std::vector&lt;T&gt;::const_iterator iter_t;
    iter_t * p2; // iter_t is a dependent name, but it's known to be a type name
}

template&lt;typename T&gt;
struct S {
    typedef int value_t; // member of current instantiation
    void f() {
        S&lt;T&gt;::value_t n{};  // S&lt;T&gt; is dependenent, but 'typename' not needed
        std::cout &lt;&lt; n &lt;&lt; '\n';
    }
};

int main()
{
    std::vector&lt;int&gt; v;
    foo(v); // template instantiation fails: there is no member variable
            // called 'const_iterator' in the type std::vector&lt;int&gt;
    S&lt;int&gt;().f();
}
}}

The keyword {{c|typename}} may only be used in this way before qualified names, e.g. {{c|T::x}}.

Usual qualified {{rlp|lookup|name lookup}} is used for the identifier prefixed by {{tt|typename}}, the rules do not change despite the qualifier:

{{source|1=
struct A { // A has a nested variable X and a nested type struct X
   struct X {};
   int X;
};
struct B {
    struct X { }; // B has a nested type struct X
};
template&lt;class T&gt; void f(T t) {
    typename T::X x;
}
void foo() {
    A a;
    B b;
    f(b); // OK: instantiates f&lt;B&gt;, T::X refers to B::X
    f(a); // error: cannot instantiate f&lt;A&gt;:
          // because qualified name lookup for A::X finds the data member
}
}}

===The {{c|template}} disambiguator for dependent names===

Similarly, in a template definition, a dependent name that is not a member of the current instantiation is not considered to be a template name unless the disambiguation keyword {{c|template}} is used:

{{example|code=
template&lt;typename T&gt;
struct S {
    template&lt;typename U&gt; void foo(){}
};

template&lt;typename T&gt;
void bar()
{
    S&lt;T&gt; s;
    s.foo&lt;T&gt;(); // error: &lt; parsed as less than operator
    s.template foo&lt;T&gt;(); // OK
}
}}

The keyword {{c|template}} may only be used in this way after operators {{c|::}} (scope resolution), {{c|-&gt;}} (member access through pointer), and {{c|.}} (member access), the following are all valid examples:

* {{c|T::template foo&lt;X&gt;();}}
* {{c|s.template foo&lt;X&gt;();}}
* {{c|this-&gt;template foo&lt;X&gt;();}}
* {{c|typename T::template iterator&lt;int&gt;::value_type v;}}

Due to the special rules for {{rlp|lookup|unqualified name lookup}} for template names in member access expressions, when a template name appears in a member access expression (after {{c|-&gt;}} or after {{c|.}}), the disambiguator is unnecessary if there is a template with the same name found by ordinary lookup in the context of the expression. {{rev inl|until=c++11|However, if the template found by lookup in the context of the expression differs from the one found in the context of the class, the program is ill-formed}}
{{source|
#include &lt;set&gt;
using std::set; // makes 'set' visible to lookup from bar

template&lt;typename T&gt; 
struct S { 
    template&lt;typename U&gt; void set(){}
};

template&lt;typename T&gt;
void bar()
{
    S&lt;T&gt; s;
    s.set&lt;T&gt;(); // not an error if ::set is visible:
                // (and since C++11, this is well-formed)
    s.template set&lt;T&gt;(); // works with and without ::set
}
}}</text>
      <sha1>6y55z9qivvllp2oerky8qu783w6rwch</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/derived class</title>
    <ns>0</ns>
    <id>10177</id>
    <revision>
      <id>67478</id>
      <parentid>65884</parentid>
      <timestamp>2014-02-09T21:21:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="4881">{{title|Derived classes}}
{{cpp/language/classes/navbar}}

Any class type (whether declared with {{spar|class-key}} {{tt|class}} or {{tt|struct}}) may be declared as ''derived'' from one or more ''base classes'' which, in turn, may be derived from their own base classes, forming an inheritance hierarchy.

The list of base classes is provided in the {{spar|base-clause}} of the  {{rlp|class|class declaration syntax}}. The {{spar|base-clause}} consists of the character {{ttb|:}} followed by a comma-separated list of one or more {{spar|base-specifier}}s.

{{sdsc begin}}
{{sdsc|1=
{{spar|attr}}{{mark optional}} {{spar|access-specifier}}{{mark optional}} {{spar|virtual-specifier}}{{mark optional}} {{spar|class-or-decltype}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|access-specifier}} | one of {{tt|private}}, {{tt|public}}, or {{tt|protected}}}}
{{par | {{spar|virtual-specifier}} | the keyword {{tt|virtual}}}}
{{par end}}

{{spar|virtual-specifier}} and {{spar|access-specifier}} may appear in any order

The last {{spar|base-specifier}} in a {{spar|base-clause}} may be a {{rlp|parameter_pack|pack expansion}}.

If {{spar|access-specifier}} is omitted, it defaults to {{tt|public}} for classes declared with class-key {{tt|struct}} and to {{tt|private}} for classes declared with class-key {{tt|class}}.

{{source|struct Base {
    int a, b, c;
};
// every object of type Derived includes Base as a subobject
struct Derived : Base {
    int b;
};
// every object of type Derived2 includes Derived and Base as subobjects
struct Derived2 : Derived {
    int c;
};
}}

The classes listed in the {{spar|base-clause}} are direct base classes. Their bases are indirect base classes. The same class cannot be specified as a direct base class more than once, but the same class can be both direct and indirect base class.

Each direct and indirect base class is present, as ''base class subobject'', within the object representation of the derived class at implementation-defined offset. Empty base classes usually do not increase the size of the derived object due to {{rlp|ebo|empty base optimization}}. The constructors of base class subobjects are called by the constructor of the derived class: arguments may be provided to those constructors in the {{rlp|initializer_list|member initializer list}}. 

===Virtual base classes===
For each distinct base class that is specified {{tt|virtual}}, the most derived object contains only one base class subobject of that type, even if the class appears many times in the inheritance hierarchy (as long as it is inherited {{tt|virtual}} every time).

{{source|1=struct B { int n; };
class X : public virtual B {};
class Y : virtual public B {};
class Z : public B {};
// every object of type AA has one X, one Y, one Z, and two B's:
// one that is the base of Z and one that is shared by X and Y
struct AA : X, Y, Z {
    void f() {
        X::n = 1; // modifies the virtual B subobject's member
        Y::n = 2; // modifies the same virtual B subobject's member
        Z::n = 3; // modifies the non-virtual B subobject's member

        std::cout &lt;&lt; X::n &lt;&lt; Y::n &lt;&lt; Z::n &lt;&lt; '\n'; // prints 223
    }
};
}}

An example of an inheritance hierarchy with virtual base classes is the iostreams hierarchy of the standard library: {{lc|std::istream}} and {{lc|std::ostream}} are derived from {{c|std::ios}} using virtual inheritance. {{lc|std::iostream}} is derived from both {{lc|std::istream}} and {{lc|std::ostream}}, so every instance of {{lc|std::iostream}} contains a {{lc|std::ostream}} subobject, a {{lc|std::istream}} subobject, and just one {{c|std::ios}} subobject (and, consequently, one {{lc|std::ios_base}}).

All virtual base subobjects are initialized before any non-virtual base subobject, so only the most derived class calls the constructors of the virtual bases in its {{rlp|initializer_list|member initializer list}}:

{{source|1=struct B {
    int n;
    B(int x) : n(x) {}
};
struct X : virtual B { X() : B(1) {} };
struct Y : virtual B { Y() : B(2) {} };
struct AA : X, Y     { AA() : B(3), X(), Y() {} };

// the default constructor of AA calls the default constructors of X and Y
// but those constructors do not call the constructor of B because B is a virtual base
AA a; // a.n == 3
// the default constructor of X calls the constructor of B
X x; // x.n == 1
}}

The are special rules for unqualified name lookup for class members when virtual inheritance is involved (sometimes referred to as the rules of dominance), see {{rlp|lookup}}

===Member access===
{{todo}}

===Member name lookup===
Unqualified and qualified name lookup rules for class members are detailed in {{rlp|lookup|name lookup}}.

===See also===
* {{rlp|virtual|virtual functions}}
* {{rlp|abstract_class|abstract classes}}</text>
      <sha1>7lzkwrmhbi5joe8qwr536oyldvw89of</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/destructor</title>
    <ns>0</ns>
    <id>6540</id>
    <revision>
      <id>71634</id>
      <parentid>71503</parentid>
      <timestamp>2014-06-17T04:41:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>trivial can be defaulted</comment>
      <text xml:space="preserve" bytes="7748">{{title|Destructors}}
{{cpp/language/classes/navbar}}

A destructor is a special member function that is called when the {{rlp|lifetime|lifetime of an object}} ends. The purpose of the destructor is to free the resources that the object may have acquired during its lifetime.

===Syntax===
{{sdsc begin}}
{{sdsc|num=1|{{ttb|~class_name}} {{ttb|();}}}}
{{sdsc|num=2|{{spar|virtual}} {{ttb|~class_name}} {{ttb|();}}}}
{{sdsc|num=3|notes={{mark since c++11}}|{{ttb|~class_name}} {{ttb|() {{=}} default;}}}}
{{sdsc|num=4|notes={{mark since c++11}}|{{ttb|~class_name}} {{ttb|() {{=}} delete;}}}}
{{sdsc end}}
# Typical declaration of a destructor
# Virtual destructor is usually required in a base class
# Forcing a destructor to be generated by the compiler
# Disabling the implicit destructor
{{todo|syntax details from 12.4/1-3}}
{{rev begin}}
{{rev|since=c++11|
If no {{spar|exception-specification}} is provided, the exception-specification is one that that would be used by the implicitly-declared destructor (see below). In most cases, this is {{c|noexcept(true)}}.
}}
{{rev end}}

===Explanation===
The destructor is called whenever an object's {{rlp|lifetime}} ends, which includes 
* [[cpp/utility/program/exit|program termination]], for objects with static {{rlp|storage duration}}
* thread exit, for objects with thread-local storage duration {{mark since c++11}}
* end of scope, for objects with automatic storage duration and for temporaries whose life was extended by binding to a reference
* {{rlp|delete|delete-expression}}, for objects with dynamic storage duration
* end of the full {{rlp|expressions|expression}}, for nameless temporaries
* {{rlp|throw|stack unwinding}}, for objects with automatic storage duration when an exception escapes their block, uncaught.

The destructor may also be called directly, e.g. to destroy an object that was constructed using {{rlp|new|placement-new}} or through an allocator member function such as [[cpp/memory/allocator/destroy|std::allocator::destroy()]], to destroy an object that was constructed through the allocator. Note that calling a destructor directly for an ordinary object, such as a local variable, invokes undefined behavior when the destructor is called again, at the end of scope.

===Implicitly-declared destructor===
If no user-defined destructor is provided for a {{rlp|class|class type}} ({{c|struct}}, {{c|class}}, or {{c|union}}), the compiler will always declare a destructor as an {{tt|inline public}} member of its class. 

===Deleted implicitly-declared destructor===
The implicitly-declared or defaulted destructor for class {{tt|T}} is {{rev inl|until=c++11| undefined }}{{rev inl|since=c++11|defined as ''deleted''}} if any of the following is true:
* {{tt|T}} has a non-static data member that cannot be destructed (has deleted or inaccessible destructor)
* {{tt|T}} has direct or virtual base class that cannot be destructed (has deleted or inaccessible destructors)
{{rev begin}}
{{rev | since=c++11 |
* {{tt|T}} is a union and has a variant member with non-trivial destructor.
}}
{{rev end}}
* The implicitly-declared destructor is virtual (because the base class has a virtual destructor) and the lookup for the deallocation function ({{c|operator delete()}} results in a call to ambiguous, deleted, or inaccessible function.

===Trivial destructor===
The destructor for class {{tt|T}} is trivial if all of the following is true:
* The destructor is not user-provided (meaning, it is implicitly-defined or defaulted)
* The destructor is not virtual (that is, the base class destructor is not virtual)
* All direct base classes have trivial destructors
* All non-static data members of class type (or array of class type) have trivial destructors
A trivial destructor is a destructor that performs no action. Objects with trivial destructors don't require a delete-expression and may be disposed of by simply deallocating their storage. All data types compatible with the C language (POD types) are trivially destructible.

===Implicitly-defined destructor===
If the implicitly-declared destructor is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler. This implicitly-defined destructor has an empty body.

{{rev begin}}
{{rev|since=c++11|
As with any implicitly-defined special member function, the exception specification of the implicitly-defined destructor is {{c|noexcept(true)}} unless it must call a user-defined destructor for a member or a base subobject with a different exception specification.}}
{{rev end}}

===Destruction sequence===
For both user-defined or implicitly-defined destructors, after the body of the destructor is executed, the compiler calls the destructors for all non-static non-variant members of the class, in reverse order of declaration, then it calls the destructors of all direct base classes in {{rlp|initializer_list#Initialization_order|reverse order of construction}} (which in turn call the destructors of their members and their base classes, etc), and then, if this object is of most-derived class, it calls the destructors of all virtual bases.

Even when the destructor is called directly (e.g. {{c|obj.~Foo();}}), the return statement in {{c|~Foo()}} does not return control to the caller immediately: it calls all those member and base destructors first.

===Virtual destructors===
Deleting an object through pointer to base invokes undefined behavior unless the destructor in the base class is {{rlp|virtual}}:

{{source|1=
class Base {
 public:
    virtual ~Base() {}
};
class Derived : public Base {};
Base* b = new Derived;
delete b; // safe
}}

A common guideline is that a destructor for a base class must be [http://www.gotw.ca/publications/mill18.htm either public and virtual or protected and nonvirtual]

===Pure virtual destructors===
A destructor may be declared {{rlp|abstract class|pure virtual}}, for example in a base class which needs to be made abstract, but has no other suitable functions that could be declared pure virtual. Such destructor must have a definition, since all base class destructors are always called when the derived class is destroyed:

{{source|1=
class AbstractBase {
 public:
    virtual ~AbstractBase() = 0;
};
AbstractBase::~AbstractBase() {}
class Derived : public AbstractBase {};
// AbstractBase obj;   // compiler error
Derived obj;           // OK
}}

===Exceptions===
As any other function, a destructor may terminate by throwing an {{rlp|exceptions|exception}} {{rev inl|since=c++11|(this usually requires it to be explicitly declared {{c|noexcept(false)}})}}, however if this destructor happens to be called during {{rlp|throw|stack unwinding}}, {{lc|std::terminate}} is called instead.

Although {{lc|std::uncaught_exception}} may sometimes be used to detect stack unwinding in progress, it is generally considered bad practice to allow any destructor to terminate by throwing an exception. One example where this functionality is used is the library [http://soci.sourceforge.net SOCI], which relies on the ability of the destructors of certain nameless temporaries to throw exceptions.

===Example===
{{example|code=
#include &lt;iostream&gt;

struct A
{
    int i;

    A ( int i ) : i ( i ) {}

    ~A()
    {
        std::cout &lt;&lt; &quot;~a&quot; &lt;&lt; i &lt;&lt; std::endl;
    }
};

int main()
{
    A a1(1);
    A* p;

    { // nested scope
        A a2(2);
        p = new A(3);
    } // a2 out of scope

    delete p; // calls the destructor of a3
}
|output=
~a2
~a3
~a1
}}

[[de:cpp/language/destructor]]
[[es:cpp/language/destructor]]
[[fr:cpp/language/destructor]]
[[it:cpp/language/destructor]]
[[ja:cpp/language/destructor]]
[[pt:cpp/language/destructor]]
[[ru:cpp/language/destructor]]
[[zh:cpp/language/destructor]]</text>
      <sha1>5ubq458uixvlsz6yqpopcusrhy4kdrd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/direct initialization</title>
    <ns>0</ns>
    <id>8867</id>
    <revision>
      <id>72476</id>
      <parentid>66554</parentid>
      <timestamp>2014-08-25T14:27:31Z</timestamp>
      <contributor>
        <ip>81.14.208.18</ip>
      </contributor>
      <text xml:space="preserve" bytes="4031">{{title|direct initialization}}
{{cpp/language/initialization/navbar}}
Initializes an object from explicit set of constructor arguments.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{spar| object}} {{ttb|( }} {{spar|arg}} {{ttb|);}}
{{spar|T}} {{spar| object}} {{ttb|( }} {{spar|arg1, arg2, ...}} {{ttb|);}}
}}
{{sdsc | num=2 | {{spar|T}} {{spar| object}} {{ttb|{ }} {{spar|arg}} {{ttb|};}}
{{spar|T}} {{spar| object}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}}
|notes={{mark since c++11}}}}
{{sdsc | num=3 | {{spar|T}} {{ttb|( }} {{spar|other}} {{ttb|)}}
{{spar|T}} {{ttb|( }} {{spar|arg1, arg2, ...}} {{ttb|);}}
}}
{{sdsc | num=4 | {{ttb|static_cast&lt;}} {{spar|T}} {{ttb|&gt;(}} {{spar|other}} {{ttb|)}} }}
{{sdsc | num=5 | {{ttb|new}} {{spar|T}}{{ttb|(}}{{spar|args, ...}}{{ttb|)}} }}
{{sdsc | num=6 | {{spar|Class}}{{ttb|::}}{{spar|Class}}{{ttb|() : }}{{spar|member}}{{ttb|(}}{{spar|args, ...}}{{ttb|) {...}} }}
{{sdsc | num=7 | {{ttb|[}}arg{{ttb|](){...}} | notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===

Direct initialization is performed in the following situations:
@1@ initialization with a nonempty parenthesized list of expressions
@2@ during [[cpp/language/list_initialization|list-initialization]] sequence, if no initializer-list constructors are provided and a matching constructor is accessible, and all necessary implicit conversions are non-narrowing.
@3@ initialization of a prvalue temporary by [[cpp/language/explicit_cast|functional cast]] or with a parenthesized expression list
@4@ initialization of a prvalue temporary by a [[cpp/language/static_cast|static_cast]] expession
@5@ initialization of an object with dynamic storage duration by a new-expression with a non-empty initializer
@6@ initialization of a base or a non-static member by constructor [[cpp/language/initializer_list|initializer list]]
@7@ initialization of closure object members from the variables caught by copy in a lambda-expression

The effects of direct initialization are:

* If {{tt|T}} is a class type, the constructors of {{tt|T}} are examined and the best match is selected by overload resolution. The constructor is then called to initialize the object.

* Otherwise, if {{tt|T}} is a non-class type, [[cpp/language/implicit_cast|standard conversions]] are used, if necessary, to convert the value of {{spar|other}} to the cv-unqualified version of {{tt|T}}.

===Notes===
Direct-initialization is more permissive than copy-initialization: copy-initialization only considers non-explicit constructors and user-defined conversion functions, while direct-initialization considers all constructors and implicit conversion sequences.

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo {
    int mem;
    explicit Foo(int n) : mem(n) {}
};

int main()
{
    std::string s1(&quot;test&quot;); // constructor from const char*
    std::string s2(10, 'a');

    std::unique_ptr&lt;int&gt; p(new int(1)); // OK: explicit constructors allowed
//  std::unique_ptr&lt;int&gt; p = new int(1); // error: constructor is explicit

    Foo f(2); // f is direct-initialized:
              // constructor parameter n is copy-initialized from the rvalue 2
              // f.mem is direct-initialized from the parameter n
//  Foo f2 = 2; // error: constructor is explicit

    std::cout &lt;&lt; s1 &lt;&lt; ' ' &lt;&lt; s2 &lt;&lt; ' ' &lt;&lt; *p &lt;&lt; ' ' &lt;&lt; f.mem  &lt;&lt; '\n';
}
 | output=
test aaaaaaaaaa 1 2
}}

===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/aggregate_initialization|aggregate initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/direct initialization]]
[[es:cpp/language/direct initialization]]
[[fr:cpp/language/direct initialization]]
[[it:cpp/language/direct initialization]]
[[ja:cpp/language/direct initialization]]
[[pt:cpp/language/direct initialization]]
[[ru:cpp/language/direct initialization]]
[[zh:cpp/language/direct initialization]]</text>
      <sha1>c0tcbu613mn3gy9iehmaljyp9jq4wte</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/do</title>
    <ns>0</ns>
    <id>693</id>
    <revision>
      <id>49905</id>
      <parentid>47408</parentid>
      <timestamp>2013-06-01T03:03:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1976">{{title|do-while loop}}
{{cpp/language/statements/navbar}}
Executes a {{spar|statement}} repeatedly, until the value of {{spar|condition}} becomes false. The test takes place after each iteration.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|do}} {{spar|statement}} {{ttb|while (}} {{spar|expression}} {{ttb|)}}  {{ttb|;}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} }}
{{par | {{spar|expression}} | any {{rlp|expressions|expression}} which is {{rlp|implicit_cast|contextually convertible}} to bool. This expression is evaluated after each iteration, and if it yields {{c|false}}, the loop is exited.}}
{{par | {{spar|statement}} | any {{rlp|statements|statement}}, typically a compound statement, which is the body of the loop }}
{{par end}}


===Notes===

{{spar|statement}} is always executed at least once, even if {{spar|expression}} always yields false. If it should not execute in this case, {{rlp|while}} or {{rlp|for}} loop may be used.

If the execution of the loop needs to be terminated at some point, {{rlp|break | break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut.

===Keywords===

{{ltt|cpp/keyword/do}},
{{ltt|cpp/keyword/while}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

int main()
{
    int i = 0;
    do i++;
    while (i &lt; 10);
    
    std::cout &lt;&lt; i &lt;&lt; '\n';
    
    i = 11;
    do i = i + 10;
    while (i &lt; 10); // the condition is false before the loop
    
    std::cout &lt;&lt; i &lt;&lt; '\n';
    
    int j = 2;
    do {
        j += 2;
        std::cout &lt;&lt; j &lt;&lt; &quot; &quot;;
    } while (j &lt; 9);
}
 | output=
10
21
4 6 8 10
}}

[[de:cpp/language/do]]
[[es:cpp/language/do]]
[[fr:cpp/language/do]]
[[it:cpp/language/do]]
[[ja:cpp/language/do]]
[[pt:cpp/language/do]]
[[ru:cpp/language/do]]
[[zh:cpp/language/do]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/dynamic cast</title>
    <ns>0</ns>
    <id>2739</id>
    <revision>
      <id>67933</id>
      <parentid>66865</parentid>
      <timestamp>2014-03-06T15:29:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+restrictions on value-ness and types of the operands.</comment>
      <text xml:space="preserve" bytes="5966">{{title|dynamic_cast conversion}}
{{cpp/language/expressions/navbar}}
Safely converts pointers and references to classes up, down, and sideways along the inheritance hierarchy.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|dynamic_cast &amp;lt;}} {{spar|new_type}} {{ttb|&amp;gt; (}} {{spar|expression}} {{ttb|)}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|new_type}} | pointer to complete class type, reference to complete class type, or pointer to (optionally cv-qualified) void}}
{{par | {{spar|expression}} | lvalue of a complete class type if {{spar|new_type}} is a reference, prvalue of a pointer to complete class type if {{spar|new_type}} is a pointer.}}
{{par end}}

Returns a value of type {{tt|new_type}} or throws an exception.

===Explanation===

Only the following conversions can be done with {{c|dynamic_cast}}, except when such conversions would cast away ''constness'' or ''volatility''.

@1@ If the type of {{spar|expression}} is exactly {{spar|new_type}} or a less cv-qualified version of {{spar|new_type}}, the result is the value of {{spar|expression}}, with type {{spar|new_type}}. (In other words, {{c|dynamic_cast}} can be used to add constness. An implicit cast and {{c|static_cast}} can perform this conversion as well.)
@2@ If the value of {{spar|expression}} is the null pointer value, the result is the null pointer value of type {{spar|new_type}}.
@3@ If {{spar|new_type}} is a pointer or reference to {{tt|Base}}, and the type of {{spar|expression}} is a pointer or reference to {{tt|Derived}}, where {{tt|Base}} is a unique, accessible base class of {{tt|Derived}}, the result is a pointer or reference to the {{tt|Base}} class subobject within the {{tt|Derived}} object pointed or identified by {{spar|expression}}. (Note: an implicit cast and {{c|static_cast}} can perform this conversion as well.)
@4@ If {{spar|expression}} is a pointer or reference to a polymorphic type, and {{tt|new_type}} is a pointer to {{c|void}}, the result is a pointer to the most derived object pointed or referenced by {{spar|expression}}.
@5@ If {{spar|expression}} is a pointer or reference to a polymorphic type {{tt|Base}}, and {{tt|new_type}} is a pointer or reference to the type {{tt|Derived}} a run-time check is performed:
:@a@ The most derived object pointed/identified by {{spar|expression}} is examined. If, in that object, {{spar|expression}} points/refers to a public base of {{tt|Derived}}, and if only one subobject of {{tt|Derived}} type is derived from the subobject pointed/identified by {{spar|expression}}, then the result of the cast points/refers to that {{tt|Derived}} subobject. (This is known as a &quot;downcast&quot;.)
:@b@ Otherwise, if {{spar|expression}} points/refers to a public base of the most derived object, and, simultaneously, the most derived object has an unambiguous public base class of type {{tt|Derived}}, the result of the cast points/refers to that {{tt|Derived}} (This is known as a &quot;sidecast&quot;.)
:@c@ Otherwise, the runtime check fails. If the {{c|dynamic_cast}} is used on pointers, the null pointer value of type {{spar|new_type}} is returned. If it was used on references, the exception {{lc|std::bad_cast}} is thrown.
@6@ When {{c|dynamic_cast}} is used in a constructor or a destructor (directly or indirectly), and {{spar|expression}} refers to the object that's currently under construction/destruction, the object is considered to be the most derived object. If {{spar|new_type}} is not a pointer or reference to the construction's/destructor's own class or one of its bases, the behavior is undefined.

Similar to other cast expressions, the result is:
* an lvalue if {{spar|new_type}} is an lvalue reference type ({{spar|expression}} must be an lvalue)
* an xvalue if {{spar|new_type}} is an rvalue reference type ({{spar|expression}} may be lvalue or rvalue)
* a prvalue otherwise (in this case, if {{spar|new_type}} is a pointer type)

===Note===
A downcast can also be performed with {{c|static_cast}}, which avoids the cost of the runtime check, but it's only safe if the program can guarantee (through some other logic) that the object pointed to by {{spar|expression}} is definitely {{tt|Derived}}.

===Keywords===
{{ltt|cpp/keyword/dynamic_cast}}

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;

struct V {
    virtual void f() {};  // must be polymorphic to use runtime-checked dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // casts during construction
    dynamic_cast&lt;B*&gt;(v); // well-defined: v of type V*, V base of B, results in B*
    dynamic_cast&lt;B*&gt;(a); // undefined behavior: a has type A*, A not a base of B
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};

struct Base {
    virtual ~Base() {}
};

struct Derived: Base {
    virtual void name() {}
};

int main()
{
    D d; // the most derived object
    A&amp; a = d; // upcast, dynamic_cast may be used, but unnecessary
    D&amp; new_d = dynamic_cast&lt;D&amp;&gt;(a); // downcast
    B&amp; new_b = dynamic_cast&lt;B&amp;&gt;(a); // sidecast


    Base* b1 = new Base;
    if(Derived* d = dynamic_cast&lt;Derived*&gt;(b1))
    {
        std::cout &lt;&lt; &quot;downcast from b1 to d successful\n&quot;;
        d-&gt;name(); // safe to call
    }

    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast&lt;Derived*&gt;(b2))
    {
        std::cout &lt;&lt; &quot;downcast from b2 to d successful\n&quot;;
        d-&gt;name(); // safe to call
    }
    
    delete b1;
    delete b2;
}
 | output=
downcast from b2 to d successful
}}

===See also===
* [[cpp/language/const_cast|const_cast]]
* [[cpp/language/static_cast|static_cast]]
* [[cpp/language/reinterpret_cast|reinterpret_cast]]
* [[cpp/language/explicit_cast|explicit cast]]
* [[cpp/language/implicit_cast|implicit conversions]]

[[de:cpp/language/dynamic cast]]
[[es:cpp/language/dynamic cast]]
[[fr:cpp/language/dynamic cast]]
[[it:cpp/language/dynamic cast]]
[[ja:cpp/language/dynamic cast]]
[[pt:cpp/language/dynamic cast]]
[[ru:cpp/language/dynamic cast]]
[[zh:cpp/language/dynamic cast]]</text>
      <sha1>61fh1qe32jzw2bd40vg25ow4qjh4ugi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/ebo</title>
    <ns>0</ns>
    <id>13018</id>
    <revision>
      <id>66608</id>
      <parentid>65729</parentid>
      <timestamp>2013-12-13T17:32:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link object and class</comment>
      <text xml:space="preserve" bytes="4029">{{title|Empty base optimization}}
{{cpp/language/navbar}}
Allows the size of an empty base subobject to be zero.

===Explanation===

The size of any {{rlp|object}} or member subobject is required to be at least 1 even if the type is an empty {{rlp|class|class type}} (that is, a class or struct that has no non-static data members), in order to be able to guarantee that the addresses of distinct objects of the same type are always distinct.

However, base class subobjects are not so constrained, and can be completely optimized out from the object layout:

{{source|1=
#include &lt;cassert&gt;

struct Base {}; // empty class

struct Derived1 : Base {
    int i;
};

int main()
{
    // the size of any object of empty class type is at least 1
    assert(sizeof(Base) == 1);

    // empty base optimization applies
    assert(sizeof(Derived1) == sizeof(int));
}
}}

Empty base optimization is prohibited if one of the empty base classes is also the type of the first non-static data member, or the base of the type of the first non-static data member since the two base subobjects have the same type, and therefore are required to have different addresses within the object representation of the most derived type.

A typical example of such situation is the naive implementation of {{lc|std::reverse_iterator}} (derived from the empty base {{lc|std::iterator}}), which holds the underlying iterator (also derived from {{lc|std::iterator}}) as its first non-static data member. 

{{source|1=
#include &lt;cassert&gt;

struct Base {}; // empty class

struct Derived1 : Base {
    int i;
};

struct Derived2 : Base {
    Base c; // Base, occupies 1 byte, followed by padding for i
    int i;
};

struct Derived3 : Base {
    Derived1 c; // derived from Base, occupies sizeof(int) bytes
    int i;
};

int main()
{
    // empty base optimization does not apply,
    // base occupies 1 byte, Base member occupies 1 byte
    // followed by 2 bytes of padding to satisfy int alignment requirements
    assert(sizeof(Derived2) == 2*sizeof(int));

    // empty base optimization does not apply,
    // base takes up at least 1 byte plus the padding
    // to satisfy alignment requirement of the first member (whose
    // alignment is the same as int)
    assert(sizeof(Derived3) == 3*sizeof(int));
}
}}

{{rev begin}}
{{rev | since=c++11|
Empty base optimization is ''required'' for {{concept|StandardLayoutType}}s in order to maintain the requirement that the pointer to a standard-layout object, converted using {{rlp|reinterpret_cast}}, points to its initial member, which is why one of the requirements for a standard layout type is &quot;has no base classes with non-static data members and has no base classes of the same type as the first non-static data member&quot;.
}}
{{rev end}}

===Notes===
Empty base optimization is commonly used by allocator-aware standard library classes ({{lc|std::vector}}, {{lc|std::function}}, {{lc|std::shared_ptr}}, etc) to avoid occupying any additional storage for its allocator member if the allocator is stateless. This is achieved by storing one of the required data members (e.g., begin, end, or capacity pointer for the vector) in an equivalent of [http://www.boost.org/doc/libs/release/libs/utility/compressed_pair.htm boost::compressed_pair] with the allocator.


===References===
{{ref std c++11}}
{{ref std | section=5.10 | title=Equality operators | id=expr.eq | p=2}}
{{ref std | section=5.3.3 | title=Sizeof | id=expr.sizeof | p=2}}
{{ref std | section=9 | title=Classes | id=class | p=4,7}}
{{ref std | section=9.2 | title=Class members | id=class.mem | p=20}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=5.10 | title=Equality operators | id=expr.eq | p=2}}
{{ref std | section=5.3.3 | title=Sizeof | id=expr.sizeof | p=2}}
{{ref std | section=9 | title=Classes | id=class | p=3}}
{{ref std end}}

[[de:cpp/language/ebo]]
[[es:cpp/language/ebo]]
[[fr:cpp/language/ebo]]
[[it:cpp/language/ebo]]
[[ja:cpp/language/ebo]]
[[pt:cpp/language/ebo]]
[[ru:cpp/language/ebo]]
[[zh:cpp/language/ebo]]</text>
      <sha1>sf6n1tjltkw8i47p0i46mw8x2c9x8pf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/enum</title>
    <ns>0</ns>
    <id>4564</id>
    <revision>
      <id>70764</id>
      <parentid>70690</parentid>
      <timestamp>2014-05-30T00:31:38Z</timestamp>
      <contributor>
        <ip>66.114.129.162</ip>
      </contributor>
      <comment>Typo fix</comment>
      <text xml:space="preserve" bytes="8684">{{title|enumeration declaration}}
{{cpp/language/declarations/navbar}}

An ''enumeration'' is a distinct type whose value is restricted to one of several explicitly named constants (&quot;''enumerators''&quot;). The values of the constants are values of an integral type known as the ''underlying type'' of the enumeration.

An enumeration is defined by ''enum-specifier'', which appears in {{spar|decl-specifier-seq}} of the {{rlp|declarations|declaration}} syntax. The ''enum-specifier'' has the following syntax:

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|enum-key}} {{spar|attr}}{{mark optional}} {{spar|identifier}}{{mark optional}} {{spar|enum-base}}{{mark optional}} {{ttb|{ }} {{spar|enumerator-list}}{{mark optional}} {{ttb|} }}
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{spar|enum-key}} {{spar|attr}}{{mark optional}} {{spar|identifier}} {{spar|enum-base}}{{mark optional}} {{ttb|; }} 
}}
{{sdsc end}}
@1@ definition of an enumeration type
@2@ ''opaque enum declaration'': defines the enumeration type but not its enumerators: after this declaration, the type is a complete type and its size is known.

{{par begin}}
{{par | {{spar|enum-key}} | one of {{ttb|enum}}, {{ttb|enum class}}{{mark since c++11}}, or {{ttb|enum struct}}{{mark since c++11}}}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|identifier}} | the name of the enumeration that's being declared. If present, and if this declaration is a re-declaration, it may be preceded by {{spar|nested-name-specifier}}{{mark since c++11}}: sequence of names and scope-resolution operators {{tt|::}}, ending with scope-resolution operator. The name can be omitted only in unscoped enumeration declarations.}}
{{par | {{spar|enum-base}}{{mark c++11}} | colon ({{ttb|:}}), followed by a {{spar|type-specifier-seq}} that names an integral type (if it is cv-qualified, qualifications are ignored)}}
{{par | {{spar|enumerator-list}} | comma-separated list of enumerator definitions, each of which is either simply an {{spar|identifier}}, which becomes the name of the enumerator, or an identifier with an initializer: {{spar|identifier}} {{ttb|{{=}}}} {{spar|constexpr}} }}
{{par end}}

There are two distinct kinds of enumerations: ''unscoped enumeration'' (declared with the {{spar|enum-key}} {{ttb|enum}} and ''scoped enumeration'' (declared with the {{spar|enum-key}} {{ttb|enum class}} or {{ttb|enum struct}}).

===Unscoped enumeration===

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|enum}} {{spar|name}} {{ttb|{}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} ... {{ttb|}}} 
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{ttb|enum}} {{spar|name}} {{ttb|:}} {{spar|type}} {{ttb|{}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} ... {{ttb|}}} 
}}
{{sdsc|num=3|notes={{mark since c++11}}|1=
{{ttb|enum}} {{spar|name}} {{ttb|:}} {{spar|type}} {{ttb|; }} 
}}
{{sdsc end}}
@1@ declares an unscoped enumeration type whose underlying type is not fixed (in this case, the underlying type is either {{c|int}} or, if not all enumerator values can be represented as {{c|int}}, an implementation-defined larger integral type that can represent all enumerator values. If the enumerator-list is empty, the underlying type is as if the enumeration had a single enumerator with value 0)
@2@ declares an unscoped enumeration type whose underlying type is fixed
@3@ opaque enum declaration for an unscoped enumeration must specify the underlying type

Each {{spar|enumerator}} becomes a named constant of the enumeration's type (that is, {{spar|name}}), visible in the enclosing scope, and can be used whenever constants are required.
{{source|1=
enum Color { RED, GREEN, BLUE};
Color r = RED;
switch(r) {
     case RED   : std::cout &lt;&lt; &quot;red\n&quot;; break;
     case GREEN : std::cout &lt;&lt; &quot;green\n&quot;; break;
     case BLUE  : std::cout &lt;&lt; &quot;blue\n&quot;; break;
}
}}

Each enumerator is associated with a value of the underlying type. When initializers are provided in the {{spar|enumerator-list}}, the values of enumerators are defined by those initializers. If the first enumerator does not have an initializer, the associated value is zero. For any other enumerator whose definition does not have an initializer, the associated value is the value of the previous enumerator plus one.
{{source|1=enum Foo { A, B, C=10, D, E=1, F, G=F+C};
//A=0, B=1, C=10, D=11, E=1, F=2, G=12 }}

Values of unscoped enumeration type are {{rlp|implicit_cast|implicitly-convertible}} to integral types. If the underlying type is not fixed, the value is convertible to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, or {{c|unsigned long long}}. If the underlying type is fixed, the values can be converted to their promoted underlying type. 
{{source|1=enum color { red, yellow, green=20, blue };
color col = red;
int n = blue; // n == 21}}

The {{spar|name}} of an unscoped enumeration may be omitted: such declaration only introduces the enumerators into the enclosing scope:
{{source|1=enum { A, B, C=0, D=A+2 }; // defines A = 0, B = 1, C = 0, D = 2}}

When an unscoped enumeration is a class member, its enumerators may be accessed using class member access operators {{ttb|.}} and {{ttb|-&gt;}}:
{{source|1=
struct X {
    enum direction { left='l', right='r'};
};
X x;
X* p = &amp;x;

int b = X::direction::left;
int a = X::left;
int b = x.left;
int c = p-&gt;left;
}}


===Scoped enumerations{{mark since c++11}}===
{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|enum}} {{ttb|struct{{!}}class}} {{spar|name}} {{ttb|{}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} ... {{ttb|}}} 
}}
{{sdsc|num=2|1=
{{ttb|enum}} {{ttb|struct{{!}}class}} {{spar|name}} {{ttb|:}} {{spar|type}} {{ttb|{}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} {{spar|enumerator}} {{ttb|{{=}}}} {{spar|constexpr}} {{ttb|,}} ... {{ttb|}}} 
}}
{{sdsc|num=3|1=
{{ttb|enum}} {{ttb|struct{{!}}class}} {{spar|name}} {{ttb|:}} {{spar|type}} {{ttb|; }} 
}}
{{sdsc end}}

@1@ declares a scoped enumeration type whose underlying type is {{c|int}} (the keywords {{c|class}} and {{c|struct}} are exactly equivalent)
@2@ declares a scoped enumeration type whose underlying type is fixed
@3@ opaque enum declaration for an unscoped enumeration

Each {{spar|enumerator}} becomes a named constant of the enumeration's type (that is, {{spar|name}}), which is contained within the scope of the enumeration, and can be accessed using scope resolution operator. There are no implicit conversions from the values of a scoped enumerator to integral types, although {{rlp|static_cast}} may be used to obtain the numeric value of the enumerator.
{{source|1=
enum class Color { RED, GREEN=20, BLUE};
Color r = Color::BLUE;
switch(r) {
    case Color::RED : std::cout &lt;&lt; &quot;red\n&quot;; break;
    case Color::GREEN : std::cout &lt;&lt; &quot;green\n&quot;; break;
    case Color::BLUE : std::cout &lt;&lt; &quot;blue\n&quot;; break;
}
// int n = r; // error: no scoped enum to int conversion
int n = static_cast&lt;int&gt;(r); // OK, n = 21
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
// color may be red (value 0), yellow (value 1), green (value 20), or blue (value 21)
enum color {
    red,
    yellow,
    green = 20,
    blue
};

// altitude may be altitude::high or altitude::low
enum class altitude : char { 
     high='h',
     low='l', // C++11 allows the extra comma
}; 

// the constant d is 0, the constant e is 1, the constant f is 3
enum { d, e, f=e+2 };

//enumeration types (both scoped and unscoped) can have overloaded operators
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, color c)
{
    switch(c) {
         case red    : os &lt;&lt; &quot;red&quot;; break;
         case yellow : os &lt;&lt; &quot;yellow&quot;; break;
         case green  : os &lt;&lt; &quot;green&quot;; break;
         case blue   : os &lt;&lt; &quot;blue&quot;; break;
         default : os.setstate(std::ios_base::failbit);
    }
    return os;
}
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, altitude al)
{
    return os &lt;&lt; static_cast&lt;char&gt;(al);
}

int main()
{
    color col = red;
    altitude a;
    a = altitude::low;

    std::cout &lt;&lt; &quot;col = &quot; &lt;&lt; col &lt;&lt; '\n'
              &lt;&lt; &quot;a = &quot; &lt;&lt; a &lt;&lt; '\n'
              &lt;&lt; &quot;f = &quot; &lt;&lt; f &lt;&lt; '\n';
}
 | output=
col = red
a = l
f = 3
}}

[[ar:cpp/language/enum]]
[[de:cpp/language/enum]]
[[es:cpp/language/enum]]
[[fr:cpp/language/enum]]
[[it:cpp/language/enum]]
[[ja:cpp/language/enum]]
[[pt:cpp/language/enum]]
[[ru:cpp/language/enum]]
[[zh:cpp/language/enum]]</text>
      <sha1>043rn1ojevstrs51lzibnnem30vzr9i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/escape</title>
    <ns>0</ns>
    <id>694</id>
    <revision>
      <id>72050</id>
      <parentid>71235</parentid>
      <timestamp>2014-07-10T11:31:33Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>wording, correction</comment>
      <text xml:space="preserve" bytes="3746">{{title|Escape sequences}}
{{cpp/language/expressions/navbar}}
Escape sequences are used to represent certain special characters within {{rlp|string literal}}s and {{rlp|character literal}}s. 

The following escape sequences are available, extra escape sequences may be provided with implementation-defined semantics:

{| class=&quot;wikitable&quot;
|-
! Escape&lt;br&gt; sequence
! Description
! Representation
|-
| {{tt|'''&lt;nowiki&gt;\'&lt;/nowiki&gt;'''}} 
| single quote 
| byte {{tt|0x27}} in ASCII encoding
|-
| {{tt|'''\&quot;'''}} 
| double quote
| byte {{tt|0x22}} in ASCII encoding
|-
| {{tt|'''\?'''}} 
| question mark
| byte {{tt|0x3f}} in ASCII encoding
|-
| {{tt|'''\\'''}} 
| backslash
| byte {{tt|0x5c}} in ASCII encoding
|-
| {{tt|'''\a'''}} 
| audible bell
| byte {{tt|0x07}} in ASCII encoding
|-
| {{tt|'''\b'''}} 
| backspace
| byte {{tt|0x08}} in ASCII encoding
|-
| {{tt|'''\f'''}} 
| form feed - new page
| byte {{tt|0x0c}} in ASCII encoding
|-
| {{tt|'''\n'''}} 
| line feed - new line
| byte {{tt|0x0a}} in ASCII encoding
|-
| {{tt|'''\r'''}} 
| carriage return 
| byte {{tt|0x0d}} in ASCII encoding
|-
| {{tt|'''\t'''}} 
| horizontal tab 
| byte {{tt|0x09}} in ASCII encoding
|-
| {{tt|'''\v'''}} 
| vertical tab 
| byte {{tt|0x0b}} in ASCII encoding
|-
| {{tt|'''\{{small|nnn}}'''}} 
| arbitrary octal value 
| byte {{tt|nnn}}
|-
| {{tt|'''\x{{small|nn}}'''}} 
| arbitrary hexadecimal value
| byte {{tt|nn}}
|-
| {{tt|'''\u{{small|nnnn}}'''}} 
| arbitrary [[enwiki:Unicode | Unicode]] value.&lt;br&gt;May result in several characters.
| code point {{tt|U+nnnn}}
|-
| {{tt|'''\U{{small|nnnnnnnn}}'''}} 
| arbitrary [[enwiki:Unicode | Unicode]] value.&lt;br&gt;May result in several characters.
| code point {{tt|U+nnnnnnnn}}
|}

===Notes===
Among all octal escape sequences,{{ttb|\0}} is most useful, for it represents the terminating null character in [[cpp/string#Null-terminated strings|null-terminated strings]].

The new-line character {{ttb|\n}} has special meaning when used in text mode I/O, it is converted to the OS-specific newline byte or byte sequence.

Octal escape sequences have a limit of three octal digits, but terminate at the first character that is not a valid octal digit if encountered sooner.

Hexadecimal escape sequences have no length limit and terminate at the first character that is not a valid hexadecimal digit. If the value represented by a single hexadecimal escape sequence does not fit the range of values represented by the character type used in this string literal ({{c|char}}, {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}}), the result is unspecified.

A universal character name in a narrow string literal or a 16-bit string literal may map to more than one character, e.g. {{c|\U0001f34c}} is 4 {{c|char}} code units in UTF-8 ({{c|\xF0\x9F\x8D\x8C}}) and 2 {{c|char16_t}} code units in UTF-16 ({{c|\xD83C\xDF4C}}))

The question mark escape sequence {{c|\?}} is used to prevent [[cpp/language/operator_alternative|trigraphs]] from being interpreted inside string literals: a string such as {{c|&quot;??/&quot;}} is compiled as {{c|&quot;\&quot;}}, but if the second question mark is escaped, as in {{c|&quot;?\?/&quot;}}, it becomes {{c|&quot;??/&quot;}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

int main()
{
    std::printf(&quot;This\nis\na\ntest\n\nShe said, \&quot;How are you?\&quot;\n&quot;);
}
 | output=
This
is
a
test

She said, &quot;How are you?&quot;
}}

===See also===
* [[cpp/language/ascii | ASCII chart]]

[[ar:cpp/language/escape]]
[[cs:cpp/language/escape]]
[[de:cpp/language/escape]]
[[es:cpp/language/escape]]
[[fr:cpp/language/escape]]
[[it:cpp/language/escape]]
[[ja:cpp/language/escape]]
[[ko:cpp/language/escape]]
[[pl:cpp/language/escape]]
[[pt:cpp/language/escape]]
[[ru:cpp/language/escape]]
[[tr:cpp/language/escape]]
[[zh:cpp/language/escape]]</text>
      <sha1>gvwq236ql2jlqjmybfo3lppsnoy99ug</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/eval order</title>
    <ns>0</ns>
    <id>4693</id>
    <revision>
      <id>71141</id>
      <parentid>69892</parentid>
      <timestamp>2014-06-07T02:17:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use dsc see for the cross-language see-also</comment>
      <text xml:space="preserve" bytes="9622">{{title|Order of evaluation}}
{{cpp/language/expressions/navbar}}

Order of evaluation of the operands of any C++ operator, including the order of evaluation of function arguments in a function-call expression, and the order of evaluation of the subexpressions within any expression is unspecified (except where noted below). The compiler will evaluate them in any order, and may choose another order when the same expression is evaluated again.

There is no concept of left-to-right or right-to-left evaluation in C++, which is not to be confused with left-to-right and right-to-left associativity of operators: the expression {{tt|f1() + f2() + f3()}} is parsed as {{tt|(f1() + f2()) + f3()}} due to left-to-right associativity of operator+, but the function call to {{tt|f3}} may be evaluated first, last, or between {{tt|f1()}} or {{tt|f2()}} at run time.

==Sequenced-before rules {{mark since c++11}}==

===Definitions===
====Evaluations====
There are two kinds of evaluations performed by the compiler for each expression or subexpression (both of which are optional):
* ''value computation'': calculation of the value that is returned by the expression. This may involve determination of the identity of the object (glvalue evaluation, e.g. if the expression returns a reference to some object) or reading the value previously assigned to an object (prvalue evaluation, e.g. if the expression returns a number, or some other value) 
* ''side effect'': access (read or write) to an object designated by a volatile glvalue, modification (writing) to an object, calling a library I/O function, or calling a function that does any of those operations.

====Ordering====
&quot;sequenced-before&quot; is an asymmetric, transitive, pair-wise relationship between evaluations within the same thread (it may extend across threads if atomic types are involved with suitable {{lc|std::memory_order}}).

* If A is sequenced before B, then evaluation of A will be complete before evaluation of B begins.
* If A is not sequenced before B and B is sequenced before A, then evaluation of B will be complete before evaluation of A begins.
* If A is not sequenced before B and B is not sequenced before A, then two possibilities exist:
** evaluations of A and B are unsequenced: they may be performed in any order and may overlap (within a single thread of execution, the compiler may interleave the CPU instructions that comprise A and B)
** evaluations of A and B are indeterminably-sequenced: they may be performed in any order but may not overlap: either A will be complete before B, or B will be complete before A. The order may be the opposite the next time the same expression is evaluated.

===Rules===
1) Each value computation and side effect of a full expression (an expression that is not part of another expression, typically one that ends with a semicolon) is sequenced before each value computation and side effect of the next full expression.

2) The value computations (but not the side-effects) of the operands to any operator are sequenced before the value computation of the result of the operator (but not its side-effects).

3) When calling a function (whether or not the function is inline, and whether or not explicit function call syntax is used), every value computation and side effect associated with any argument expression, or with the postfix expression designating the called function, is sequenced before execution of every expression or statement in the body of the called function.

4) The value computation of the built-in postincrement and postdecrement operators is sequenced before its side-effect.

5) The side effect of the built-in preincrement and predecrement operators is sequenced before its value computation (implicit rule due to definition as compound assignment)

6) Every value computation and side effect of the first (left) argument of the built-in logical AND operator {{c|&amp;&amp;}} and the built-in logical OR operator {{c|{{!!}}}} is sequenced before every value computation and side effect of the second (right) argument.

7) Every value computation and side effect associated with the first expression in the logical {{c|?:}} operator is sequenced before every value computation and side effect associated with the second or third expression.

8) The side effect (modification of the left argument) of the built-in assignment operator and of all built-in compound assignment operators is sequenced after the value computation (but not the side effects) of both left and right arguments, and is sequenced before the value computation of the assignment expression (that is, before returning the reference to the modified object)

9) Every value computation and side effect of the first (left) argument of the built-in comma operator {{c|,}} is sequenced before every value computation and side effect of the second (right) argument.

10) In [[cpp/language/list_initialization|list-initialization]], every value computation and side effect of a given initializer clause is sequenced before every value computation and side effect associated with any initializer clause that follows it in the comma-separated list of the initializer list.

11) A function call that is not sequenced before or sequenced after another function call is indeterminately sequenced (the program must behave [[cpp/language/as_if|as if]] the CPU instructions that constitute different function calls were not interleaved, even if the functions were inlined)

12) The call to the allocation function (operator new) is indeterminately sequenced with respect to the evaluation of the constructor arguments in a new-expression

===Undefined behavior===

1) If a side effect on a scalar object is unsequenced relative to another side effect on the same scalar object, the behavior is undefined.

{{c|1=
i = ++i + i++; // undefined behavior
i = i++ + 1; // undefined behavior (but i = ++i + 1; is well-defined)
f(++i, ++i); // undefined behavior
f(i = -1, i = -1); // undefined behavior
}}

2) If a side effect on a scalar object is unsequenced relative to a value computation using the value of the same scalar object, the behavior is undefined.

{{c|1=
cout &lt;&lt; i &lt;&lt; i++; // undefined behavior
a[i] = i++; // undefined behavior
}}

==Sequence point rules {{mark until c++11}}==
===Definitions===
Evaluation of an expression might produce side effects, which are: accessing an object designated by a volatile lvalue, modifying an object, calling a library I/O function, or calling a function that does any of those operations.

A ''sequence point'' is a point in the execution sequence where all side effects from the previous evaluations in the sequence are complete, and no side effects of the subsequent evaluations started.

===Rules===
1) There is a sequence point at the end of each full expression (typically, at the semicolon)

2) When calling a function (whether or not the function is inline and whether or not function call syntax was used), there is a sequence point after the evaluation of all function arguments (if any) which takes place before execution of any expressions or statements in the function body

3) There is a sequence point after the copying of a returned value of a function and before the execution of any expressions outside the function.

4) Once the execution of a function begins, no expressions from the calling function are evaluated until execution of the called function has completed (functions cannot be interleaved)
 
5) In the evaluation of each of the following four expressions, using the built-in (non-overloaded) operators, there is a sequence point after the evaluation of the expression {{tt|a}}.

{{c|1=
a &amp;&amp; b
a {{!!}} b
a ? b : c
a , b
}}

===Undefined behavior===
1) Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression.

{{c|1=
i = ++i + i++; // undefined behavior
i = i++ + 1; // undefined behavior
i = ++i + 1; // undefined behavior (well-defined in C++11)
++ ++i; // undefined behavior (well-defined in C++11)
f(++i, ++i); // undefined behavior
f(i = -1, i = -1); // undefined behavior
}}

2) Between the previous and next sequence point , the prior value of a scalar object that is modified by the evaluation of the expression, shall be accessed only to determine the value to be stored.

{{c|1=
cout &lt;&lt; i &lt;&lt; i++; // undefined behavior
a[i] = i++; // undefined behavior
}}

===See also===
* [[cpp/language/operator_precedence|Operator precedence]] which defines how expressions are built from their source code representation.
{{dsc begin}}
{{dsc see c | c/language/eval_order | Order of evaluation}}
{{dsc end}}

===References===
{{ref std c++11}}
{{ref std | section=1.9 | title=Program execution | id=intro.execution}}
{{ref std | section=5.2.6 | title=Increment and decrement | id=expr.post.incr}}
{{ref std | section=5.3.4 | title=New | id=expr.new}}
{{ref std | section=5.14 | title=Logical AND operator | id=expr.log.and}}
{{ref std | section=5.15 | title=Logical OR operator | id=expr.log.or}}
{{ref std | section=5.16 | title=Conditional operator | id=expr.cond}}
{{ref std | section=5.17 | title=Assignment and compound assignment operators | id=expr.ass}}
{{ref std | section=5.18 | title=Comma operator | id=expr.comma}}
{{ref std | section=8.5.4 | title=List-initialization | id=dcl.init.list}}
{{ref std end}}

[[de:cpp/language/eval order]]
[[es:cpp/language/eval order]]
[[fr:cpp/language/eval order]]
[[it:cpp/language/eval order]]
[[ja:cpp/language/eval order]]
[[pt:cpp/language/eval order]]
[[ru:cpp/language/eval order]]
[[zh:cpp/language/eval order]]</text>
      <sha1>0appu2xpcdgpdjcttveu6kochye0736</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/except spec</title>
    <ns>0</ns>
    <id>3413</id>
    <revision>
      <id>71869</id>
      <parentid>69068</parentid>
      <timestamp>2014-06-29T17:21:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention which types aren't allowed</comment>
      <text xml:space="preserve" bytes="1949">{{title|exception specification}}
{{cpp/language/exceptions/navbar}}

Lists the exceptions that a function might directly or indirectly throw.

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|throw(}}{{spar|typeid, typeid, ...}}{{ttb|)}} | notes={{mark deprecated}}}}
{{sdsc end}}

===Explanation===

If a function is declared with type {{tt|T}} listed in its exception specification, the function may throw exceptions of that type or a type derived from it.

{{rlp|incomplete type|Incomplete types}}, pointers or references to incomplete types other than cv {{tt|void*}}, and rvalue reference types are not allowed in the exception specification. Array and function types, if used, are adjusted to corresponding pointer types.

If the function throws an exception of the type not listed in its exception specification, the function {{lc|std::unexpected}} is called. The default function calls {{lc|std::terminate}}, but it may be replaced by a user-provided function (via {{lc|std::set_unexpected}}) which may call {{lc|std::terminate}} or throw an exception. If the exception thrown from {{lc|std::unexpected}} is accepted by the exception specification, stack unwinding continues as usual. If it isn't, but {{lc|std::bad_exception}} is allowed by the exception specification, {{lc|std::bad_exception}} is thrown. Otherwise, {{lc|std::terminate}} is called.

===Example===

{{example
 | 
 | code=
class X {};
class Y {};
class Z : public X {};
class W {};

void f() throw(X, Y) 
{
    int n = 0;
    if (n) throw X(); // OK
    if (n) throw Z(); // also OK
    throw W(); // will call std::unexpected()
}
 | output=
}}

===See also===

*[[cpp/language/noexcept_spec | {{tt|noexcept}} specifier]]

[[de:cpp/language/except spec]]
[[es:cpp/language/except spec]]
[[fr:cpp/language/except spec]]
[[it:cpp/language/except spec]]
[[ja:cpp/language/except spec]]
[[pt:cpp/language/except spec]]
[[ru:cpp/language/except spec]]
[[zh:cpp/language/except spec]]</text>
      <sha1>fxm3y3eivnkueofoocwnwbcqs7wka55</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/exceptions</title>
    <ns>0</ns>
    <id>9898</id>
    <revision>
      <id>69320</id>
      <parentid>69061</parentid>
      <timestamp>2014-04-03T02:10:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>distinguish nofail and nothrow</comment>
      <text xml:space="preserve" bytes="4965">{{title|Exceptions}}
{{cpp/language/exceptions/navbar}}
Exception handling provides a way of transferring control and information from some point in the execution of a program to a handler associated with a point previously passed by the execution (in other words, exception handling transfers control up the call stack)

An exception can be thrown by a {{rlp|throw|throw-expression}}, {{rlp|dynamic_cast}}, {{rlp|typeid}}, {{rlp|new|new-expression}}, [[cpp/memory/new/operator_new|allocation function]], and any of the standard library functions that are specified to throw exceptions to signal certain error conditions (e.g. {{lc|std::vector::at}}, {{lc|std::string::substr}}, etc).

In order for exception to be caught, the throw-expression has to be inside a {{rlp|try_catch|try-block}} or inside a function called from a try-block, and there has to be a {{rlp|try_catch|catch clause}} that matches the type of the exception object.

When declaring a function, {{rlp|except_spec | exception specifications}} and {{rlp|noexcept_spec | noexcept specifiers}} may be provided to limit the types of the exceptions a function may throw.

Errors that arise during exception handling are handled by {{lc|std::terminate}} and {{lc|std::unexpected}}.

===Usage===

While throw-expression can be used to transfer control to an arbitrary block of code up the execution stack, for arbitrary reasons (similar to {{lc|std::longjmp}}), its intended usage is error handling. 

====Error handling====

Throwing an exception is used to signal errors from functions, where &quot;errors&quot; are typically limited to only the following&lt;ref&gt; H. Sutter (2004) [http://www.drdobbs.com/when-and-how-to-use-exceptions/184401836 &quot;When and How to Use Exceptions&quot;] in Dr. Dobb's&lt;/ref&gt;&lt;ref&gt;H.Sutter, A. Alexandrescu (2004), &quot;C++ Coding Standards&quot;, Item 70&lt;/ref&gt;:
# Failures to establish invariants 
# Failures to meet the postconditions
# Failures to meet the preconditions of the caller

In particular, this implies that the failures of constructors and most operators should be reported by throwing exceptions.

====Exception safety====

After the error condition is reported by a function, additional guarantees may be provided with regards to the state of the program. The following four levels of exception guarantee are generally recognized&lt;ref&gt;B. Stroustrup (2000), &quot;The C++ Programming Language&quot;[http://www2.research.att.com/~bs/3rd_safe.pdf Appendix E&quot;]&lt;/ref&gt;&lt;ref&gt;H. Sutter (2000) &quot;Exceptional C++&quot;&lt;/ref&gt;&lt;ref&gt;D. Abrahams (2001) [http://www.boost.org/community/exception_safety.html &quot;Exception Safety in Generic Components&quot;]&lt;/ref&gt;, which are strict supersets of each other:

# ''Nothrow (or nofail) exception guarantee'' -- the function never throws exceptions. Nothrow (errors are reported by other means or concealed) is expected of {{rlp|destructor}}s and other functions that may be called during stack unwinding. {{rev inl|since=c++11|The {{rlp|destructor}}s are {{rlp|noexcept}} by default.}} Nofail (the function always succeeds) is expected of swaps, {{rlp|move constructor}}s, and other functions used by those that provide strong exception guarantee.
# ''Strong exception guarantee'' -- If the function throws an exception, the state of the program is rolled back to the state just before the function call. (for example, {{lc|std::vector::push_back}})
# ''Basic exception guarantee'' -- If the function throws an exception, the program is in a valid state. It may require cleanup, but all invariants are intact.
# ''No exception guarantee'' -- If the function throws an exception, the program may not be in a valid state: resource leaks, memory corruption, or other invariant-destroying errors may have occurred.

Generic components may, in addition, offer ''exception-neutral guarantee'': if an exception is thrown from a template parameter (e.g. from the {{tt|Compare}} function object of {{lc|std::sort}} or from the constructor of {{tt|T}} in {{lc|std::make_shared}}), it is propagated, unchanged, to the caller. 

===Exception objects===

While objects of any complete type and cv pointers to void may be thrown as exception objects, all standard library functions throw anonymous temporary objects by value, and the types of those objects are derived (directly or indirectly) from {{lc|std::exception}}. User-defined exceptions usually follow this pattern.&lt;ref&gt;D. Abrahams (2001) [http://www.boost.org/community/error_handling.html &quot;Error and Exception Handling&quot;]&lt;/ref&gt;&lt;ref&gt;M. Cline, C++FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.11 17.11]&lt;/ref&gt;

To avoid unnecessary copying of the exception object and object slicing, the best practice for catch clauses is to catch by reference.&lt;ref&gt;S. Meyers (1996) &quot;More Effective C++&quot; Item 13&lt;/ref&gt;&lt;ref&gt;M. Cline, C++FAQ Lite [http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.12 17.12]&lt;/ref&gt;&lt;ref&gt;H.Sutter, A. Alexandrescu (2004) &quot;C++ Coding Standards&quot; Item 73&lt;/ref&gt;

===References===
&lt;references/&gt;</text>
      <sha1>ogxoe3q5aopda5khxdiyll0qsg246nq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/explicit</title>
    <ns>0</ns>
    <id>5075</id>
    <revision>
      <id>67702</id>
      <parentid>49911</parentid>
      <timestamp>2014-02-21T18:59:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>todo</comment>
      <text xml:space="preserve" bytes="1550">{{title|explicit specifier}}
{{cpp/language/navbar}}

Specifies constructors and {{mark since c++11}} conversion operators that don't allow [[cpp/language/implicit_cast|implicit conversions]] or [[cpp/language/copy_initialization|copy-initialization]].

===Syntax===
{{sdsc begin}}
{{sdsc  | {{c|explicit}} {{spar|class_name}} ( {{spar|params}} ) }}
{{sdsc  | {{c|explicit operator}} {{spar|type}} ( ) {{mark since c++11}} }}
{{sdsc end}}

@1@ specifies that this constructor is only considered for {{rlp|direct initialization}}
@2@ specifies that this {{rlp|cast_operator|user-defined conversion function}} is only considered for {{rlp|direct initialization}}

{{todo}}

===Example===
{{example|code=
struct A
{
    A(int) {}
    operator int() const { return 0; }
};

struct B
{
    explicit B(int) {}
    explicit operator int() const { return 0; }
};

int main()
{
    // A has no explicit ctor / conversion, everything is fine
    A a1 = 1;
    A a2 ( 2 );
    A a3 { 3 };
    int na1 = a1;
    int na2 = static_cast&lt;int&gt;( a1 );
 
    B b1 = 1; // Error: implicit conversion from int to B
    B b2 ( 2 ); // OK: explicit constructor call
    B b3 { 3 }; // OK: explicit constructor call
    int nb1 = b2; // Error: implicit conversion from B to int
    int nb2 = static_cast&lt;int&gt;( b2 ); // OK: explicit cast
}
}}

[[de:cpp/language/explicit]]
[[es:cpp/language/explicit]]
[[fr:cpp/language/explicit]]
[[it:cpp/language/explicit]]
[[ja:cpp/language/explicit]]
[[pt:cpp/language/explicit]]
[[ru:cpp/language/explicit]]
[[zh:cpp/language/explicit]]</text>
      <sha1>m6aurnuuan7irimcm4n0ewtl5aph7iu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/explicit cast</title>
    <ns>0</ns>
    <id>695</id>
    <revision>
      <id>66866</id>
      <parentid>58016</parentid>
      <timestamp>2014-01-03T15:17:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="3062">{{title|explicit type conversion}}
{{cpp/language/expressions/navbar}}
Converts between types using a combination of explicit and implicit conversions.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|(}} {{spar|new_type}} {{ttb|) }} {{spar|expression}} | num=1 }} 
{{sdsc | {{spar|new_type}} {{ttb|( }} {{spar|expression}} {{ttb|)}}  | num=2 }} 
{{sdsc end}}

Returns a value of type {{tt|new_type}}.

===Explanation===

@1@ When the C-style cast expression is encountered, the compiler attempts the following cast expressions, in this order:
:@a@ {{c|const_cast&lt;new_type&gt;(expression)}}
:@b@ {{c|static_cast&lt;new_type&gt;(expression)}}, with extensions: pointer or reference to a derived class is additionally allowed to be cast to pointer or reference to unambiguous base class (and vice versa) even if the base class is inaccessible (that is, this cast ignores the private inheritance specifier). Same applies to casting pointer to member to pointer to member of unambigous non-virtual base
:@c@ {{c|static_cast}} (with extensions) followed by {{c|const_cast}}
:@d@ {{c|reinterpret_cast&lt;new_type&gt;(expression)}}
:@e@ {{c|reinterpret_cast}} followed by {{c|const_cast}}
@@ The first choice that satisfies the requirements of the respective cast operator is selected, even if it cannot be compiled (see example).
@@ In addition, C-style cast notation is allowed to cast from, to, and between pointers to incomplete class type. If both {{spar|expression}} and {{spar|new_type}} are pointers to incomplete class types, it's unspecified whether static_cast or reinterpret_cast gets selected.
@2@ The functional cast consists of a simple type specifier or a typedef specifier (in other words, a single-word type name: {{c|unsigned int(expression)}} or {{c|int*(expression)}} are not valid), followed by a single expression in parentheses. This cast is exactly equivalent to the corresponding C-style cast expression.

{{cpp/language/cast_return}}

===Example===

{{example
 | code=

double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-style cast
unsigned int n2 = unsigned(f);     // functional cast

class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // casts incomplete type to incomplete type
}

// In this example, C-style cast is interpreted as static_cast
// even though it would work as reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};

int main()
{
   D* d = nullptr;
   A* a = (A*)d;                   // compile-time error
   A* a = reinterpret_cast&lt;A*&gt;(d); // this compiles
}
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc const_cast}}
{{dsc inc | cpp/language/dsc static_cast}}
{{dsc inc | cpp/language/dsc dynamic_cast}}
{{dsc inc | cpp/language/dsc reinterpret_cast}}
{{dsc inc | cpp/language/dsc implicit_cast}}
{{dsc end}}

[[de:cpp/language/explicit cast]]
[[es:cpp/language/explicit cast]]
[[fr:cpp/language/explicit cast]]
[[it:cpp/language/explicit cast]]
[[ja:cpp/language/explicit cast]]
[[pt:cpp/language/explicit cast]]
[[ru:cpp/language/explicit cast]]
[[zh:cpp/language/explicit cast]]</text>
      <sha1>k706hir3g6filgflp9rdssiecx1epoo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/expressions</title>
    <ns>0</ns>
    <id>9881</id>
    <revision>
      <id>71533</id>
      <parentid>71448</parentid>
      <timestamp>2014-06-13T04:02:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>cwg 1354</comment>
      <text xml:space="preserve" bytes="5564">{{title|Expressions}}
{{cpp/language/expressions/navbar}}
An expression is a sequence of ''operators'' and their ''operands'', that specifies a computation.

Expression evaluation may produce a result (e.g., evaluation of {{c|2+2}} produces the result {{c|4}}) and may generate side-effects (e.g. evaluation of {{c|std::printf(&quot;%d&quot;,4)}} prints the character {{c|'4'}} on the standard output).

====General====
* {{rlp|value_category|value categories}} (lvalue, rvalue, glvalue, prvalue, xvalue) classify expressions by their values
* {{rlp|eval_order|order of evaluation}} of arguments and subexpressions specify the order in which intermediate results are obtained

===Operators===

{{cpp/language/operators}}

* {{rlp|operator_precedence | operator precedence}} defines the order in which operators are bound to their arguments
* {{rlp|operator_alternative | alternative representations}} are alternative spellings for some operators 
* {{rlp|operators|operator overloading}} makes it possible to specify the behavior of the operators with user-defined classes.

====Conversions====
* {{rlp|implicit_cast | standard conversions}} implicit conversions from one type to another
* {{rlp|const_cast | {{tt|const_cast}} conversion}}
* {{rlp|static_cast | {{tt|static_cast}} conversion}}
* {{rlp|dynamic_cast | {{tt|dynamic_cast}} conversion}}
* {{rlp|reinterpret_cast | {{tt|reinterpret_cast}} conversion}}
* {{rlp|explicit_cast | explicit cast }} conversion using C-style cast notation and functional notation
* {{rlp|cast_operator|user-defined conversion}} makes it possible to specify conversion from user-defined classes

====Memory allocation====
* {{rlp|new | new expression}} allocates memory dynamically
* {{rlp|delete | delete expression}} deallocates memory dynamically

====Other====
* {{rlp|constant_expression | constant expressions }} can be evaluated at compile time and used in compile-time context (template arguments, array sizes, etc)
* {{rlp|sizeof | {{tt|sizeof}} }}
* {{rlp|alignof | {{tt|alignof}} }}
* {{rlp|typeid | {{tt|typeid}} }}
* {{rlp|throw | throw-expression }}


===Primary expressions===

The operands of any operator may be other expressions or primary expressions (e.g. in {{c|1+2*3}}, the operands of operator+ are the subexpression {{c|2*3}} and the primary expression {{c|1}}).

Primary expressions are any of the following:
@1@ Literals (e.g. {{c|2}} or {{c|&quot;Hello, world&quot;}})
@2@ Suitably declared {{rlp|identifiers|unqualified identifiers}} (e.g. {{c|n}} or {{c|cout}})
@3@ Suitably declared {{rlp|identifiers|qualified identifiers}} (e.g. {{lc|std::string::npos}})
@4@ {{rlp|lambda|Lambda-expressions}}

Any expression in parentheses is also classified as a primary expression: this guarantees that the parentheses have higher precedence than any operator.

====Literals====

Literals are the tokens of a C++ program that represent constant values embedded in the source code.

* {{rlp|integer_literal|integer literals}} are decimal, octal, hexadecimal or binary numbers of integer type.
* {{rlp|character_literal|character literals}} are individual characters of type {{c|char}}, {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}}
* {{rlp|floating_literal|floating-point literals}} are values of type {{c|float}}, {{c|double}}, or {{c|long double}}
* {{rlp|string_literal|string literals}} are sequences of characters, which may be narrow, multibyte, or wide
* {{rlp|bool_literal|boolean literals}} are values of type {{c|bool}}, that is {{c|true}} and {{c|false}}
* {{rlp|nullptr}} is the pointer literal which specifies a null pointer value {{mark since c++11}}
* {{rlp|user_literal|user-defined literals}} are constant values of user-specified type {{mark since c++11}}

===Unevaluated expressions===
The operands of the four operators {{ltt|cpp/language/typeid}}, {{ltt|cpp/language/sizeof}}, {{ltt|cpp/language/noexcept}}, and {{ltt|cpp/language/decltype}} are expressions that are not evaluated, since these operators only query the compile-time properties of their operands. Thus, {{c|std::size_t n {{=}} sizeof(std::cout &lt;&lt; 42);}} does not perform console output.

{{rev begin}}
{{rev|since=c++14|
The unevaluated operands are considered to be ''full expressions'' even though they are syntactically operands in a larger expression (for example, this means that {{c|sizeof(T())}} requires an accessible {{tt|T::~T}})
}}
{{rev end}}

===Discarded-value expressions===
A ''discarded-value expression'' is an expression that is used for its side-effects only. The value calculated from such expression is discarded. Such expressions include the full expression of any {{rlp|statements#Expression_statements|expression statement}}, the left-hand argument of the comma operator, or the argument of a cast-expression that casts to the type {{c|void}}.

Array-to-pointer and function-to-pointer conversions are never applied to the value calculated by a discarded-value expression. The lvalue-to-rvalue conversion (in other words, a memory read), however, is applied, but only if the expression is a {{rlp|cv|volatile-qualified}} glvalue and has one of the following forms (possibly parenthesized)
* id-expression
* array subscript expression
* class member access expression
* indirection
* pointer-to-member operation 
* conditional expression where both the second and the third operands are one of these expressions,
* comma expression where the right operand is one of these expressions.

In addition, if the expression is of class type, it needs a volatile copy-constructor to initialize the resulting rvalue temporary.</text>
      <sha1>sc2u02fyjhwuaf20qhgir2zrdwwjumr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/extending std</title>
    <ns>0</ns>
    <id>13097</id>
    <revision>
      <id>69470</id>
      <parentid>66516</parentid>
      <timestamp>2014-04-11T12:39:34Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>format</comment>
      <text xml:space="preserve" bytes="2710">{{title|Extending the namespace {{tt|std}}}}
{{cpp/language/navbar}}

===Adding declarations to {{tt|std}}===
It is undefined behavior to add declarations or definitions to {{tt|namespace std}} or to any namespace nested within {{tt|std}}, with a few exceptions noted below

{{source|
#include &lt;utility&gt;
namespace std {
    // a function definition added to namespace std: undefined behavior
    pair&lt;int, int&gt; operator+(pair&lt;int, int&gt; a, pair&lt;int, int&gt; b) {
        return {a.first+b.first, a.second+b.second};
    }
}
}}

It is allowed to add template specializations for any standard library template to the namespace {{tt|std}} only if the declaration depends on a user-defined type and the specialization satisfies all requirements for the original template, except where such specializations are prohibited.

{{todo|mini-example}}

* It is undefined behavior to declare a full specialization of any member function of a standard library class template
{{todo|mini-example}}

* It is undefined behavior to declare a full specialization of any member function template of a standard library class or class template
{{todo|mini-example}}

* It is undefined behavior to declare an full or partial specialization of any member class template of a standard library class or class template.
{{todo|mini-example}}

* None of the [[cpp/types|type traits]] defined in {{header|type_traits}} may be specialized for a user-defined type, except for {{lc|std::common_type}}.

* Specializing the template {{lc|std::complex}} for any type other than float, double, and long double is unspecified.

* Specializations of {{lc|std::hash}} for user-defined types must satisfy {{concept|Hash}} requirements.

* Specializations of {{lc|std::atomic}} must have a deleted copy constructor, a deleted copy assignment operator, and a constexpr value constructor.

* Specializations of {{lc|std::shared_ptr}} and {{lc|std::weak_ptr}} must be {{concept|CopyConstructible}} and {{concept|CopyAssignable}}. In addition, specializations of {{lc|std::shared_ptr}} must be {{concept|LessThanComparable}}, and convertible to {{c|bool}}.

* Specializations of {{lc|std::istreambuf_iterator}} must have a trivial copy constructor, a constexpr default constructor, and a trivial destructor.

* {{lc|std::unary_function}} and {{lc|std::binary_function}} may not be specialized.

It is allowed to explicitly instantiate a template defined in the standard library only if the declaration depends on the name of a user-defined type and the instantiation meets the standard library requirements for the original template.
{{todo|mini-example}}

===Other restrictions===

The namespace {{tt|std}} may not be declared as an {{tt|inline}} namespace.</text>
      <sha1>ln7gub9ml5x2c6kzjvsm17a9qs81z81</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/final</title>
    <ns>0</ns>
    <id>5074</id>
    <revision>
      <id>67913</id>
      <parentid>67482</parentid>
      <timestamp>2014-03-05T17:27:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention final unions</comment>
      <text xml:space="preserve" bytes="3264">{{title|final specifier}}
{{cpp/language/classes/navbar}}

Specifies that a {{rlp|virtual|virtual function}} can not be overridden in a derived class or that a class cannot be {{rlp|derived class|inherited from}}.

===Syntax===
The identifier {{tt|final}}, if used, appears immediately after the {{rlp|function|declarator}} in the syntax of a member function declaration or a member function definition.

{{sdsc begin}}
{{sdsc | num=1 | {{spar|declarator}} {{spar|virt-specifier-seq}}{{mark optional}} {{spar|pure-specifier}}{{mark optional}} }}
{{sdsc | num=2 | {{spar|declarator}} {{spar|virt-specifier-seq}}{{mark optional}} {{spar|function-body}} }}
{{sdsc | num=3 | {{spar|class-key}} {{spar|attr}}{{mark optional}} {{spar|class-head-name}} {{spar|class-virt-specifier}}{{mark optional}} {{ttb|:}}{{spar|base-specifier-list}}{{mark optional}} }}
{{sdsc end}}
@1@ In a member function declaration, {{tt|final}} may appear in {{spar|virt-specifier-seq}} immediately after the declarator, and before the {{rlp|abstract_class|pure-specifier}}, if used.
@2@ In a member function definition, {{tt|final}} may appear in {{spar|virt-specifier-seq}} immediately after the declarator and just before {{spar|function-body}} (which may begin with a {{rlp|initializer list|member initializer list}})
@3@ In a class definition, {{tt|final}} may appear as {{spar|class-virt-specifier}} immediately after the name of the class, just before the colon that begins the {{spar|base-specifier-list}}, if used.

In the cases (1,2), {{spar|virt-specifier-seq}}, if used, is either {{rlp|override}} or {{tt|final}}, or {{tt|final override}} or {{tt|override final}}. In the case (3), the only allowed value of {{spar|class-virt-specifier}}, if used, is {{tt|final}}

===Explanation===
When used in a virtual function declaration or definition, {{tt|final}} ensures that the function is virtual and specifies that it may not be overridden by derived classes. The program is ill-formed (a compile-time error is generated) otherwise

When used in a class definition, {{tt|final}} specifies that this class may not appear in the {{spar|base-specifier-list}} of another class definition (in other words, cannot be derived from). The program is ill-formed (a compile-time error is generated) otherwise. {{tt|final}} can also be used with a {{rlp|union}} definition, in which case it has no effect (other than on the outcome of {{lc|std::is_final}}), since unions cannot be derived from)

{{c|final}} is an identifier with a special meaning when used in a member function declaration or class head.  In other contexts it is not reserved and may be used to name objects and functions.

===Example===
{{source|
struct A
{
    virtual void foo() final; // A::foo is final
    void bar() final; // Error: non-virtual function cannot be final
};

struct B final : A // struct B is final
{
    void foo(); // Error: foo cannot be overridden as it's final in A
};

struct C : B // Error: B is final
{
};
}}
===See also===
*[[cpp/language/override|override specifier]] {{mark since c++11}}

[[de:cpp/language/final]]
[[es:cpp/language/final]]
[[fr:cpp/language/final]]
[[it:cpp/language/final]]
[[ja:cpp/language/final]]
[[pt:cpp/language/final]]
[[ru:cpp/language/final]]
[[zh:cpp/language/final]]</text>
      <sha1>e3iqao2hogzdkf04q3wn5loooxlrwj7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/floating literal</title>
    <ns>0</ns>
    <id>5286</id>
    <revision>
      <id>69163</id>
      <parentid>67532</parentid>
      <timestamp>2014-03-28T17:59:45Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2558">{{title|floating point literal}}
{{cpp/language/expressions/navbar}}

Floating point literal defines a compile-time constant whose value is specified in the source file.

===Syntax===
A floating-point literals have two syntaxes. The first one consists of the following parts:
:* nonempty sequence of decimal digits containing a decimal point character (defines significand)
:* {{mark optional}} {{ttb|e}} or {{ttb|E}} followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent)
:* {{mark optional}} a suffix type specifier as a {{ttb|l}}, {{ttb|f}}, {{ttb|L}} or {{ttb|F}}

The second one consists of the following parts:
:* nonempty sequence of decimal digits (defines significant)
:* {{ttb|e}} or {{ttb|E}} followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent)
:* {{mark optional}} a suffix type specifier as a {{ttb|l}}, {{ttb|f}}, {{ttb|L}} or {{ttb|F}}

The suffix type specifier defines the actual type of the floating-point literal:

:* (no suffix) defines {{c|double}}
:* {{ttb|f F}} defines {{c|float}}
:* {{ttb|l L}} defines {{c|long double}}
{{rev begin}}
{{rev | since = c++14 |Optional single quotes({{tt|'}}) can be inserted between the digits as a separator, they are ignored when compiling.}}
{{rev end}}

===Explanation===
A decimal scientific notation is used, meaning that the exponent is the power of 10 by which the significant is multiplied.&lt;br/&gt;
The mathematical meaning of {{c|123e4}} is ''123×10&lt;sup&gt;4&lt;/sup&gt;''

===Example===
{{example|code=
#include &lt;iostream&gt;
int main()
{
  std::cout &lt;&lt; 123.456e-67 &lt;&lt; '\n'
            &lt;&lt; .1E4f       &lt;&lt; '\n'
            &lt;&lt; 58.         &lt;&lt; '\n'
            &lt;&lt; 4e2         &lt;&lt; '\n';
}
|output=
1.23456e-65
1000
58
400
}}

===Notes===
The hexadecimal floating-point constants (e.g. {{tt|0x1p-5}}, {{tt|0x1.0Ap-2}}, {{tt|0x1.8p-1}}), which are allowed in the C programming language, cannot be used as floating point literals in C++ (although some C++ compilers might interpret them). However, they may be parsed and printed by the I/O functions: both C++ I/O streams when {{c|std::hexfloat}} is enabled and the C I/O streams: {{c|std::printf}}, {{c|std::scanf}}, etc. See {{c|std::strtof}} for the format description 

[[de:cpp/language/floating literal]]
[[es:cpp/language/floating literal]]
[[fr:cpp/language/floating literal]]
[[it:cpp/language/floating literal]]
[[ja:cpp/language/floating literal]]
[[pt:cpp/language/floating literal]]
[[ru:cpp/language/floating literal]]
[[zh:cpp/language/floating literal]]</text>
      <sha1>ni3inl7a03rpkdq5gy430gk3xj4qa0l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/for</title>
    <ns>0</ns>
    <id>696</id>
    <revision>
      <id>71598</id>
      <parentid>71586</parentid>
      <timestamp>2014-06-14T16:12:36Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+note (can we use another equivalent grammar description?)</comment>
      <text xml:space="preserve" bytes="5140">{{title|for loop}}
{{cpp/language/statements/navbar}}
Executes {{spar|init-statement}} once, then executes {{spar|statement}} and {{spar|iteration_expression}} repeatedly, until the value of {{spar|condition}} becomes false. The test takes place before each iteration.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|for (}} {{spar|init-statement}} {{spar|condition}}{{mark optional}} {{ttb|;}} {{spar|iteration_expression}}{{mark optional}} {{ttb|)}} {{spar|statement}} }}
{{sdsc end}}
&lt;!--

another (more apparent) way to write the syntax is
{{sdsc begin}}
{{sdsc |num=1| {{spar|attr}}{{mark optional}} {{ttb|for (}} {{spar|expression}}{{mark optional}} {{ttb|;}} {{spar|condition}}{{mark optional}} {{ttb|;}} {{spar|iteration_expression}}{{mark optional}} {{ttb|)}} {{spar|statement}} }}
{{sdsc |num=2| {{spar|attr}}{{mark optional}} {{ttb|for (}} {{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|init-declarator-list}}{{mark optional}} {{ttb|;}} {{spar|condition}}{{mark optional}} {{ttb|;}} {{spar|iteration_expression}}{{mark optional}} {{ttb|)}} {{spar|statement}} }}
{{sdsc end}}

--&gt;
{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} }}
{{par | {{spar|init-statement}} | either an {{rlp|statements|expression statement}} or a  {{rlp|declarations|declaration statement}}, typically a declaration of a loop counter variable with initializer. Note that an {{spar|init-statement}} must end with a semicolon. }}
{{par | {{spar|condition}} | any {{rlp|expressions|expression}} which is {{rlp|implicit_cast|contextually convertible}} to bool or a {{rlp|declarations|declaration}} of a single variable with a brace-or-equals {{rlp|initialization|initializer}}. This expression is evaluated before each iteration, and if it yields {{c|false}}, the loop is exited. If this is a declaration, the initializer is evaluated before each iteration, and if the value of the declared variable converts to {{c|false}}, the loop is exited.}}
{{par | {{spar|iteration_expression}} | any {{rlp|expressions|expression}}, which is executed after every iteration of the loop and before re-evaluating {{spar|condition}}. Typically, this is the expression that increments the loop counter  }}
{{par | {{spar|statement}} | any {{rlp|statements|statement}}, typically a compound statement, which is the body of the loop }}
{{par end}}

===Explanation===

The above syntax produces code equivalent to:

{{sdsc begin}}
{{sdsc | 
{{ttb|{}}&lt;br&gt;
:{{spar|init_statement}} &lt;br&gt;
:{{ttb|while (}} {{spar|condition}} {{ttb|) {}} &lt;br&gt;
::{{spar|statement}} &lt;br&gt;
::{{spar|iteration_expression}} {{ttb|;}} &lt;br&gt;
:{{ttb|} }}
{{ttb|} }}
}}
{{sdsc end}}

Except that 
@1@ Names declared by the {{spar|init-statement}} (if {{spar|init-statement}} is a declaration) and names declared by {{spar|condition}} (if condition is a declaration) are in the same scope.
@2@ {{rlp|continue}} in the {{spar|statement}} will execute {{spar|iteration_expression}}
@3@ Empty {{spar|condition}} is equivalent to {{c|while(true)}}

If the execution of the loop needs to be terminated at some point, {{rlp|break | break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut.

As is the case with {{rlp|while}} loop, if {{spar|statement}} is a single statement (not a compound statement), the scope of variables declared in it is limited to the loop body as if it was a compound statement.
{{source|
for(;;)
    int n;
// n goes out of scope
}}
===Keywords===

{{ltt|cpp/keyword/for}}

===Example===

{{example
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
    // typical loop with a single statement as the body
    for (int i = 0; i &lt; 10; ++i)
        std::cout &lt;&lt; i &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    // init-statement can declare multiple names, as long as they
    // can use the same decl-specifier-seq
    for (int i=0, *p = &amp;i; i &lt; 9; i+=2) {
        std::cout &lt;&lt; i &lt;&lt; ':' &lt;&lt; *p &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    // condition may be a declaration
    char cstr[] = &quot;Hello&quot;;
    for(int n = 0; char c = cstr[n]; ++n)
        std::cout &lt;&lt; c;
    std::cout &lt;&lt; '\n';

    // init-statement can use the auto type specifier
    std::vector&lt;int&gt; v = {3, 1, 4, 1, 5, 9};
    for (auto iter = v.begin(); iter != v.end(); ++iter) {
        std::cout &lt;&lt; *iter &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

   // init-statement can be an expression
    int n = 0;
    for (std::cout &lt;&lt; &quot;Loop start\n&quot;;
         std::cout &lt;&lt; &quot;Loop test\n&quot;;
         std::cout &lt;&lt; &quot;Iteration &quot; &lt;&lt; ++n &lt;&lt; '\n')
        if(n &gt; 1)
            break;
    std::cout &lt;&lt; '\n';
}
 | output=
0 1 2 3 4 5 6 7 8 9 
0:0 2:2 4:4 6:6 8:8 
Hello
3 1 4 1 5 9 
Loop start
Loop test
Iteration 1
Loop test
Iteration 2
Loop test
}}

===See Also===
* [[cpp/language/range-for|Range-based for loop]] {{mark c++11}}

[[de:cpp/language/for]]
[[es:cpp/language/for]]
[[fr:cpp/language/for]]
[[it:cpp/language/for]]
[[ja:cpp/language/for]]
[[pt:cpp/language/for]]
[[ru:cpp/language/for]]
[[zh:cpp/language/for]]</text>
      <sha1>1mdj1t60l18e5k062mwbd7r99wub6er</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/friend</title>
    <ns>0</ns>
    <id>3084</id>
    <revision>
      <id>70294</id>
      <parentid>69968</parentid>
      <timestamp>2014-05-17T15:28:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <text xml:space="preserve" bytes="10786">{{title|friend declaration}}
{{cpp/language/classes/navbar}}
The friend declaration appears in a {{rlp|class|class body}} and grants a function or another class access to private and protected members of the class where the friend declaration appears.

===Syntax===
{{sdsc begin}}
{{sdsc|num=1| {{ttb|friend}} {{spar|function-declaration}} }}
{{sdsc|num=2| {{ttb|friend}} {{spar|function-definition}} }}
{{sdsc|num=3| {{ttb|friend}} {{spar|elaborated-class-name}} {{ttb|;}}}}
{{sdsc|num=4|notes={{mark since c++11}}|
{{ttb|friend}} {{spar|simple-type-specifier}} {{ttb|;}}
{{ttb|friend}} {{spar|typename-specifier}} {{ttb|;}}
}}
{{sdsc end}}

===Description===
@1@ Designates a function or several functions as friends of this class
{{source|
class Y {
    int data; // private member
    // the non-member function operator&lt;&lt; will have access to Y's private members
    friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const Y&amp; o);
    friend char* X::foo(int); // members of other classes can be friends too
    friend X::X(char), X::~X(); // constructors and destructors can be friends
};
// friend declaration does not declare a member function
// this operator&lt;&lt; still needs to be defined, as a non-member
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const Y&amp; y)
{
    return out &lt;&lt; y.data; // can access private member Y::data
}
}}
@2@ (only allowed in non-local class definitions) Defines a non-member function, and makes it a friend of this class at the same time. Such non-member function is always {{rlp|inline}}.
{{source|1=class X {
    int a;
    friend void friend_set(X&amp; p, int i) {
        p.a = i; // this is a non-member function
    }
 public:
    void member_set(int i) {
        a = i; // this is a member function
    }
};
}}
@3@ Designates the class, struct, or union named by the {{spar|elaborated-class-name}} as a friend of this class. This means that the friend's member declarations and definitions can access private and protected members of this class and also that the {{rlp|nested_types|nested classes}} of the friend can inherit from private and protected members of this class. {{rev inl|since=c++11|The friend itself can also inherit from private and protected members of this class.}}
If the name of the class that is used in the friend declaration is not yet declared, it is forward declared on the spot.
@4@ Designates the type named by the {{spar|simple-type-specifier}} or {{spar|typename-specifier}} as a friend of this class if that type is a (possibly {{rlp|cv|cv-qualified}}) class, struct, or union, otherwise the {{tt|friend}} declaration is ignored. This declaration will not forward declare new type.
{{source|1=
class Y {};
class A {
    int data; // private data member
    class B { }; // private nested type
    enum { a = 100 }; // private enumerator
    friend class X; // friend class forward declaration
    friend Y; // friend class declaration (since c++11)
};

class X : A::B // Error until C++11: the base-clause is not part of member declarations
               // allowed in C++11
{
    A::B mx; // OK: A::B accessible to member of friend
    class Y : A::B { // OK: A::B accessible to base-clause of nested member of friend
    };
    int v[A::a]; // OK: A::a accessible to member of friend
};
}}

===Notes===
Friendship is not transitive (a friend of your friend is not your friend)

Friendship is not inherited (your friend's children are not your friends)

Prior C++11, member declarations and definitions inside the nested class of the friend of class {{tt|T}} cannot access the private and protected members of class {{tt|T}}, but some compilers&lt;!-- cl &amp; gcc &amp; clang --&gt; accept it even in pre-C++11 mode.

Storage class specifiers are not allowed in friend function declarations. A function that is defined in the friend declaration has external linkage, a function that was previously defined, keeps the linkage it was defined with.

{{rlp|access|Access specifiers}} have no effect on the meaning of friend declarations (they can appear in {{tt|private:}} or in {{tt|public:}} sections, with no difference)

A friend class declaration cannot define a new class ({{c|friend class X {};}} is an error)

When a local class declares an unqualified function or class as a friend, only functions and classes in the innermost non-class scope are {{rlp|lookup|looked up}}, not the global functions:
{{source|class F {};
int f();
int main()
{
    extern int g();
    class Local { // Local class in the main() function
        friend int f(); // Error, no such function declared in main()
        friend int g(); // OK, there is a declaration for g in main()
        friend class F; // friends a local F (defined later)
        friend class ::F; // friends the global F
    };
    class F {}; // local F
}
}}

A name first declared in a friend declaration within class or class template X becomes a member of the innermost enclosing namespace of X, but is not accessible for lookup (except argument-dependent lookup that considers X) unless a matching declaration at the namespace scope is provided - see {{rlp|namespace#Namespaces|namespaces}} for details.

===Template friends===
Both {{rlp|function template}} and {{rlp|class template}} declarations may appear with the {{tt|friend}} specifier in any non-local class or class template (although only function templates may be defined within the class or class template that is granting friendship). In this case, every specialization of the template becomes a friend, whether it is implicitly instantiated, partially specialized, or explicitly specialized.

{{source|class A {
    template&lt;typename T&gt;
    friend class B; // every B&lt;T&gt; is a friend of A

    template&lt;typename T&gt;
    friend void f(T) {} // every f&lt;T&gt; is a friend of A
};
}}

Friend declarations cannot refer to partial specializations, but can refer to full specializations:

{{source|
template&lt;class T&gt; class A {}; // primary
template&lt;class T&gt; class A&lt;T*&gt; {}; // partial
template&lt;&gt; class A&lt;int&gt; {}; // full
class X {
    template&lt;class T&gt; friend class A&lt;T*&gt;; // error!
    friend class A&lt;int&gt;; // OK
};
}}

When a friend declaration refers to a full specialization of a function template, the keyword {{tt|inline}} and default arguments cannot be used.

{{source|1=
template&lt;class T&gt; void f(int);
template&lt;&gt; void f&lt;int&gt;(int);

class X {
    friend void f&lt;int&gt;(int x = 1); // error: default args not allowed
};
}}

If a member of a class template A is declared to be a friend of a non-template class B, the corresponding member of every specialization of A becomes a friend of B. If A is explicitly specialized, as long as there is a member of the same name, same kind (type, function, class template, function template), same parameters/signature, it will be a friend of B.

{{source|
template&lt;typename T&gt; // primary template
struct A
{
    struct C {};
    void f();
    struct D {
        void g();
    };
};

template&lt;&gt; // full specialization
struct A&lt;int&gt;
{
    struct C {};
    int f();
    struct D {
        void g();
    };
};

class B // non-template class
{
    template&lt;class T&gt;
    friend struct A&lt;T&gt;::C; // A&lt;int&gt;::C is a friend, as well as all A&lt;T&gt;::C

    template&lt;class T&gt;
    friend void A&lt;T&gt;::f(); // A&lt;int&gt;::f() is not a friend, because the
                           // signatures do not match, but A&lt;char&gt;::f() is

    template&lt;class T&gt;
    friend void A&lt;T&gt;::D::g(); // A&lt;int&gt;::D::g() is not a friend: it is not a member
                              // of A, and A&lt;int&gt;::D is not a specialization of A&lt;T&gt;::D
};
}}

===Template friend operators===
A common use case for template friends is declaration of a non-member operator overload that acts on a class template, e.g. {{c|operator&lt;&lt;(std::ostream&amp;, const Foo&lt;T&gt;&amp;)}} for some user-defined {{c|Foo&lt;T&gt;}}

Such operator can be defined in the class body, which has the effect of generating a separate non-template {{tt|operator&lt;&lt;}} for each {{tt|T}} and makes that non-template {{tt|operator&lt;&lt;}} a friend of its {{tt|Foo&lt;T&gt;}}

{{example|code=#include &lt;iostream&gt;

template&lt;typename T&gt;
class Foo {
 public:
    Foo(const T&amp; val) : data(val) {}
 private:
    T data;

    // generates a non-template operator&lt;&lt; for this T
    friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const Foo&amp; obj)
    {
        return os &lt;&lt; obj.data;
    }
};

int main()
{
    Foo&lt;double&gt; obj(1.23);
    std::cout &lt;&lt; obj &lt;&lt; '\n';
}
|output=1.23
}}

or the function template has to be declared as a template before the class body, in which case the friend declaration within {{tt|Foo&lt;T&gt;}} can refer to the full specialization of {{tt|operator&lt;&lt;}} for its {{tt|T}}:

{{example|code=
#include &lt;iostream&gt;

template&lt;typename T&gt;
class Foo; // forward declare to make function declaration possible

template&lt;typename T&gt; // declaration
std::ostream&amp; operator&lt;&lt;(std::ostream&amp;, const Foo&lt;T&gt;&amp;);

template&lt;typename T&gt;
class Foo {
 public:
    Foo(const T&amp; val) : data(val) {}
 private:
    T data;

    // refers to a full specialization for this particular T 
    friend std::ostream&amp; operator&lt;&lt; &lt;&gt; (std::ostream&amp;, const Foo&amp;);
    // note: this relies on template argument deduction in declarations
    // can also specify the template argument with operator&lt;&lt; &lt;T&gt;&quot;
};

// definition
template&lt;typename T&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const Foo&lt;T&gt;&amp; obj)
{
    return os &lt;&lt; obj.data;
}

int main()
{
    Foo&lt;double&gt; obj(1.23);
    std::cout &lt;&lt; obj &lt;&lt; '\n';
}
}}

===Example===
{{example
| stream insertion and extraction operators are often declared as non-member friends
| code=#include &lt;iostream&gt;
#include &lt;sstream&gt;

class MyClass {
    int i;

    friend std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const MyClass&amp; o);
    friend std::istream&amp; operator&gt;&gt;(std::istream&amp; in, MyClass&amp; o);
 public:
    MyClass(int i = 0) : i(i) {}
};

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const MyClass&amp; mc)
{
    return out &lt;&lt; mc.i;
}

std::istream&amp; operator&gt;&gt;(std::istream&amp; in, MyClass&amp; mc)
{
    return in &gt;&gt; mc.i;
}

int main()
{
    MyClass mc(7);
    std::cout &lt;&lt; mc &lt;&lt; '\n';
    std::istringstream(&quot;100&quot;) &gt;&gt; mc;
    std::cout &lt;&lt; mc &lt;&lt; '\n';
}
|output=
7
100
}}

===References===
{{ref std c++11}}
{{ref std | section=11.3 | title=Friends | id=class.friend}}
{{ref std | section=14.5.4 | title=Friends | id=temp.friend}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=11.3 | title=Friends | id=class.friend}}
{{ref std | section=14.5.3 | title=Friends | id=temp.friend}}
{{ref std end}}

===See Also===
{{dsc begin}}
{{dsc | [[cpp/language/class | Class declaration ]] }}
{{dsc | [[cpp/language/access | Access specifiers ]] }}
{{dsc end}}

[[de:cpp/language/friend]]
[[es:cpp/language/friend]]
[[fr:cpp/language/friend]]
[[it:cpp/language/friend]]
[[ja:cpp/language/friend]]
[[pt:cpp/language/friend]]
[[ru:cpp/language/friend]]
[[zh:cpp/language/friend]]</text>
      <sha1>etilcpeqmayo3i7bmud7r7ego83g84l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/function</title>
    <ns>0</ns>
    <id>3127</id>
    <revision>
      <id>72210</id>
      <parentid>71708</parentid>
      <timestamp>2014-07-24T03:15:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mark __func__ C++11</comment>
      <text xml:space="preserve" bytes="16064">{{title|Declaring functions}}
{{cpp/language/functions/navbar}}

A function declaration introduces the function name and its type. A function definition associates the function name/type with the function body.

===Function declaration===
Function declarations may appear in any scope. A function declaration at class scope introduces a class member function (unless the friend specifier is used), see {{rlp|member_functions|member functions}} and {{rlp|friend|friend functions}} for details.

The type of the function being declared is composed from the ''return type'' (provided by the {{spar|decl-specifier-seq}} of the {{rlp|declarations|declaration syntax}}) and the  function {{spar|declarator}}

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|noptr-declarator}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{spar|cv}}{{mark optional}} {{spar|ref}}{{mark optional}} {{spar|except}}{{mark optional}}  {{spar|attr}}{{mark optional}}
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{spar|noptr-declarator}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{spar|cv}}{{mark optional}} {{spar|ref}}{{mark optional}} {{spar|except}}{{mark optional}}  {{spar|attr}}{{mark optional}} {{ttb|-&gt;}} {{spar|trailing}}
}}
{{sdsc end}}

(see {{rlp|declarations|Declarations}} for the other forms of the {{spar|declarator}} syntax)

@1@ Regular function declarator syntax
@2@ Trailing return type declaration: trailing return type is only allowed on the outermost function declarator. The decl-specifier-seq in this case must contain the keyword {{tt|auto}} 

{{par begin}}
{{par | {{spar|noptr-declarator}} | any valid {{spar|declarator}}, but if it begins with *, &amp;, or &amp;&amp;, it has to be surrounded by parentheses. }}
{{par | {{spar|parameter-list}} | possibly empty, comma-separated list of the function parameters (see below for details)}}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}} }}
{{par | {{spar|cv}} | const/volatile qualification, only allowed in non-static member function declarations}}
{{par | {{spar|ref}}{{mark c++11}} | ref-qualification, only allowed in non-static member function declarations}}
{{par | {{spar|except}} | either {{rlp|except_spec|dynamic exception specification}}{{mark deprecated}} or {{rlp|noexcept_spec|noexcept specification}}{{mark c++11}}}}
{{par | {{spar|trailing}}{{mark c++11}} | Trailing return type, useful if the return type depends on argument names, such as {{c|1=template &lt;class T, class U&gt; auto add(T t, U u) -&gt; decltype(t + u);}} or is complicated, such as in {{c|1=auto fpif(int)-&gt;int(*)(int)}}}}
{{par end}}

Function declarators can be mixed with other declarators, where decl-specifier-seq allows:
{{source|1=
// declares an int, an int*, a function, and a pointer to a function
int a = 1, *p = NULL, f(), (*pf)(double);
// decl-specifier-seq is int
// declarator f() declares (but doesn't define)
//                a function taking no arguments and returning int

struct S {
    virtual int f(char) const, g(int) &amp;&amp;; // declares two non-static member functions
    virtual int f(char), x; // compile-time error: virtual (in decl-specifier-seq)
                            // is only allowed in declarations of non-static
                            // member functions
};
}}

{{rev begin}}
{{rev|since=c++14|
===Return type deduction {{mark since c++14}}===
If the ''decl-specifier-seq'' of the function declaration contains the keyword {{tt|auto}}, trailing return type may be omitted, and will be deduced by the compiler from the type of the expression used in the {{rlp|return}} statement. If the return type does not use {{tt|decltype(auto)}}, the deduction follows the rules of {{rlp|template argument deduction#Other_contexts|template argument deduction}}.
{{source|1=
int x = 1;
auto f() { return x; } // return type is int
const auto&amp; f() { return x; } // return type is const int&amp;
}}
If the return type is {{tt|decltype(auto)}}, the return type is as what would be obtained if the expression used in the return statement were wrapped in {{rlp|decltype}}.
{{source|1=
int x = 1;
decltype(auto) f() { return x; } // return type is int, same as decltype(x)
decltype(auto) f() { return(x); } // return type is int&amp;, same as decltype((x))
}}
(note: &quot;{{tt|const decltype(auto)&amp;}}&quot; is an error, {{tt|decltype(auto)}} must be used on its own)

If there are multiple return statements, they must all deduce to the same type
{{source|1=
auto f(bool val)
{
  if(val) return 123; // deduces return type int
  else    return 3.14f; // deduces return type float: error
} 
}}

If there is no return statement, the type deduced is {{c|void}}
{{source|1=
auto f() { } // returns void
auto* f() { } // error: cannot deduce auto* from void
}}

Once a return statement has been seen in a function, the return type deduced from that statement can be used in the rest of the function, including in other return statements.
{{source|1=
auto sum(int i)
{
    if (i == 1)
        return i; // sum’s return type is int
    else
        return sum(i-1)+i; // OK, sum’s return type is already known
}
}}

If the return statement uses a brace-init-list, deduction is not allowed:
{{source|auto func () { return {1,2,3}; }  // error}}

{{rlp|virtual|Virtual functions}} cannot use return type deduction.
{{source|1=struct F {
    virtual auto f() { return 2; } // error
};
}}

If a function uses return type deduction, it cannot be redeclared using the type that it deduces to, or another kind of return type deduction even if it deduces to the same type
{{source|1=
auto f();               // declared, not yet defined
auto f() { return 42; } // defined, return type is int
int f();                // error, cannot use the deduced type
decltype(auto) f();     // error, different kind of deduction
auto f();               // re-declared, OK

template &lt;typename T&gt; struct A {
  friend T frf(T);
};
auto frf(int i) { return i; } // not a friend of A&lt;int&gt;
}}

{{rlp|function template|Function templates}} can use return type deduction. The deduction takes place at instantiation even if the expression in the return statement is not {{rlp|dependent name|dependent}}. This instantiation is not in an immediate context for the purposes of {{rlp|sfinae|SFINAE}}.
{{source|1=
template &lt;class T&gt; auto f(T t) { return t; }
typedef decltype(f(1)) fint_t; // instantiates f&lt;int&gt; to deduce return type
template&lt;class T&gt; auto f(T* t) { return *t; }
void g() { int (*p)(int*) = &amp;f; } // instantiates both fs to determine return types,
                                  // chooses second template overload
}}

Specializations of function templates that use return type deduction must use the same return type placeholders
{{source|1=
template &lt;typename T&gt; auto g(T t) { return t; } // #1
template auto g(int);      // OK, return type is int
//template char g(char);   // error, no matching template

template&lt;&gt; auto g(double); // OK, forward declaration with unknown return type
template &lt;typename T&gt; T g(T t) { return t; } // OK, not equivalent to #1
template char g(char);     // OK, now there is a matching template
template auto g(float);    // still matches #1
// void h() { return g(42); } // error, ambiguous 
}}

{{rlp|function template#Explicit_instantiation|Explicit instantiation declarations}} do not themselves instantiate function templates that use return type deduction
{{source|1=
template &lt;typename T&gt; auto f(T t) { return t; }
extern template auto f(int); // does not instantiate f&lt;int&gt;
int (*p)(int) = f; // instantiates f&lt;int&gt; to determine its return type,
                   // but an explicit instantiation definition 
                   // is still required somewhere in the program
}}
}}
{{rev end}}

===Parameter list===
Parameter list determines the arguments that can be specified when the function is called. It is a comma-separated list of ''parameter declarations'', each of which has the following syntax

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|declarator}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|declarator}} {{ttb|{{=}} }} {{spar|initializer}}
}}
{{sdsc|num=3|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|abstract-declarator}}{{mark optional}}
}}
{{sdsc|num=4|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}} {{spar|abstract-declarator}}{{mark optional}} {{ttb|{{=}} }} {{spar|initializer}}
}}
{{sdsc|num=5|1=
{{ttb|...}}
}}
{{sdsc|num=6|1=
{{ttb|void}}
}}
{{sdsc end}}

@1@ Declares a named (formal) parameter. For the meanings of {{spar|decl-specifier-seq}} and {{spar|declarator}}, see {{rlp|declarations}}.
{{source|
int f(int a, int *p, int (*(*x)(double))[3]);
}}
@2@ Declares a named (formal) parameter with a {{rlp|default_arguments|default value}}.
{{source|1=
int f(int a = 7, int *p = nullptr, int (*(*x)(double))[3] = nullptr);
}}
@3@ Declares an unnamed parameter
{{source|
int f(int, int *, int (*(*)(double))[3]);
}}
@4@ Declares an unnamed parameter with a {{rlp|default_arguments|default value}}
{{source|1=
int f(int = 7, int * = nullptr, int (*(*)(double))[3] = nullptr);
}}
@5@ Declares a {{rlp|variadic_arguments|variadic function}}, may only appear as the last parameter in a parameter list.
{{source|
int printf(const char* fmt, ...);
}}
@6@ Indicates that the function takes no parameters, it is the exact synonym for an empty parameter list: {{c|int f(void);}} and {{c|int f();}} declare the same function. Note that the type {{tt|void}} cannot be used in a parameter list otherwise: {{c|int f(void, int);}}  and {{c|int f(const void);}} are errors (although derived types, such as {{tt|void*}} can be used). In a template, only non-dependent void type can be used (a function taking a single parameter of type {{tt|T}} does not become a no-parameter function if instantiated with {{tt|T {{=}} void}})

Although {{spar|decl-specifier-seq}} implies there can exist {{rlp|declarations#Specifiers|specifiers}} other than type specifiers, the only other specifier allowed is {{c|register}} {{rev inl|until=c++11|as well as {{c|auto}} }}, and it has virtually no effect.

Parameter names declared in function declarations are usually for only self-documenting purposes. &lt;!--they are sometimes significant when trailing return type is used--&gt;They are used (but remain optional) in function definitions.

The type of each function parameter in the parameter list is determined according to the following rules:
@1@ First, {{spar|decl-specifier-seq}} and the declarator are combined as in any {{rlp|declarations|declaration}} to determine the type.
@2@ If the type is &quot;array of T&quot; or &quot;array of unknown bound of T&quot;, it is replaced by the type &quot;pointer to T&quot;
@3@ If the type is a function type F, it is replaced by the type &quot;pointer to F&quot;
@4@ Top-level cv-qualifiers are dropped from the parameter type (This adjustment&lt;!--unlike the above three rules--&gt; only affects the function type, but doesn't modify the property of the parameter: {{c|int f(const int p, decltype(p)*);}} and {{c|int f(int, const int*);}} declare the same function)&lt;!-- cwg 1130 --&gt;

Because of these rules, the following function declarations declare exactly the same function:
{{source|
int f(char s[3]);
int f(char[]);
int f(char* s);
int f(char* const);
int f(char* volatile s);
}}
The following declarations also declare exactly the same function
{{source|
int f(int());
int f(int (*g)());
}}

The comma before the ellipsis parameter that indicates {{rlp|variadic arguments}} is optional, even if it follows the ellipsis that indicates a {{rlp|parameter pack}} expansion, so the following function templates are exactly the same:
{{source|
template&lt;typename ...Args&gt; void f(Args..., ...);
template&lt;typename ...Args&gt; void f(Args... ...);
template&lt;typename ...Args&gt; void f(Args......);
}}
An example of when such declaration is used is the implementation of {{c|std::is_function}}

===Function definition===

A non-member function definition may appear at namespace scope only (there are no nested functions). A {{rlp|member functions|member function}} definition may also appear in the body of a {{rlp|class|class definition}}. They have the following syntax:

{{sdsc begin}}
{{sdsc|1=
{{spar|attr}}{{mark optional}} {{spar|decl-specifier-seq}}{{mark optional}} {{spar|declarator}} {{spar|virt-specifier-seq}}{{mark optional}} {{spar|function-body}}
}}
{{sdsc end}}
where {{spar|function-body}} is one of the following
{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|ctor-initializer}}{{mark optional}} {{spar|compound-statement}} }}
{{sdsc|num=2|1=
{{spar|function-try-block}} }}
{{sdsc|num=3|notes={{mark since c++11}}|1=
{{ttb|{{=}}}} {{ttb|delete}} {{ttb|;}} }}&lt;!--Semicolon is a part of the grammar--&gt;
{{sdsc|num=4|notes={{mark since c++11}}|1=
{{ttb|{{=}}}} {{ttb|default}} {{ttb|;}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}} }}
{{par | {{spar|decl-specifier-seq}} | the return type with specifiers, as in the {{rlp|declarations|declaration grammar}}}}
{{par | {{spar|declarator}} | function declarator, same as in the function declaration grammar above}}
{{par | {{spar|virt-specifier-seq}}{{mark c++11}} | {{rlp|override}}, {{rlp|final}}, or their combination in any order (only allowed for member functions)}}
{{par | {{spar|ctor-initializer}} | {{rlp|initializer_list|member initializer list}}, only allowed in constructors}}
{{par | {{spar|compound-statement}} | the brace-enclosed {{rlp|statements#Compound_statement|sequence of statements}} that constututes the body of a function}}
{{par end}}

@1@ regular function body
@2@ {{rlp|function-try-block}} (which is a regular function body wrapped in a try/catch block)
@3@ explicitly deleted function definition
@4@ explicitly defaulted function definition, only allowed for {{rlp|member_functions#Special_member_functions|special member functions}}

The parameter types, as well as the return type of a function cannot be {{rlp|incomplete type|incomplete}} {{rlp|class|class types}}, {{rev inl|since=c++14|except for deleted functions}}. An exception is made for {{rlp|member functions}}, which can use the class in which they are defined (or its enclosing class), even if it's incomplete at the point of definition.

{{todo}}

{{rev begin}}
{{rev|since=c++11|
===__func__===
Within the function body, the function-local predefined variable {{lc|__func__}} is defined as if by
{{source|1=static const char __func__[] = &quot;function-name&quot;;}}
This variable has block scope and static storage duration:
{{source|1=
struct S {
    S() : s(__func__) {} // OK: initializer-list is part of function body
    const char* s;
};
void f(const char* s = __func__); // error: parameter-list is part of declarator
}}
}}
{{rev end}}

===Example 1: non-member functions===
{{todo|move/cleanup}}
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

// declaration in namespace(file) scope
// (the definition is provided later)
int f1();

// simple function with a default argument, returning nothing
void f0(const std::string&amp; arg = &quot;world&quot;) {
    std::cout &lt;&lt; &quot;Hello, &quot; &lt;&lt; arg &lt;&lt; '\n';
}

// function returning a pointer to f0
auto fp11() -&gt; void(*)(const std::string&amp;) {
    return f0;
}

// function returning a pointer to f0, pre-C++11 style
void (*fp03())(const std::string&amp;) {
    return f0;
}

int main()
{
    f0();
    fp11()(&quot;test&quot;);
    fp03()(&quot;again&quot;);
    int f2(std::string); // declaration in function scope
    std::cout &lt;&lt; f2(&quot;bad12&quot;) &lt;&lt; '\n';
}

// simple non-member function returning int
int f1() {
    return 42;
}

// function with an exception specification and a function try block
int f2(std::string str) noexcept try { 
    return std::stoi(str);
} catch(const std::exception&amp; e) {
    std::cerr &lt;&lt; &quot;stoi() failed!\n&quot;;
    return 0;
}
 | output=
Hello, world
Hello, test
Hello, again
stoi() failed!
0
}}

[[de:cpp/language/function]]
[[es:cpp/language/function]]
[[fr:cpp/language/function]]
[[it:cpp/language/function]]
[[ja:cpp/language/function]]
[[pt:cpp/language/function]]
[[ru:cpp/language/function]]
[[zh:cpp/language/function]]</text>
      <sha1>qzfc2x46qpe6bgup7vqhmjlybff6v5z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/function-try-block</title>
    <ns>0</ns>
    <id>13494</id>
    <revision>
      <id>69262</id>
      <parentid>69125</parentid>
      <timestamp>2014-04-01T20:09:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>c++11 for the delegating ctor</comment>
      <text xml:space="preserve" bytes="4486">{{title|Function-try-block}}
{{cpp/language/exceptions/navbar}}
Establishes an exception handler around the body of a function.

===Syntax===
The function-try-block is one of the alternative syntax forms for {{spar|function-body}}, which is a part of {{rlp|function|function definition}}.
{{sdsc begin}}
{{sdsc|1=
{{ttb|try}} {{spar|ctor-initializer}}{{mark optional}} {{spar|compound-statement}} {{spar|handler-sequence}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|ctor-initializer}} | member {{rlp|initializer list}}, only allowed in constructors}}
{{par | {{spar|compound-statement}} | the brace-enclosed {{rlp|statements#Compound_statement|sequence of statements}} that constututes the body of a function}}
{{par | {{spar|handler-sequence}} | sequence of one or more {{rlp|try_catch|catch-clauses}} }}
{{par end}}

===Explanation===
A ''function-try-block'' associates a sequence of catch clauses with the entire function body, and with the {{rlp|initializer list|member initializer list}} (if used in a constructor) as well. Every exception thrown from any statement in the function body, or (for constructors) from any member or base constructor, or (for destructors) from any member or base destructor, transfers control to the {{spar|handler-sequence}} the same way an exception thrown in a regular {{rlp|try_catch|try block}} would.
{{source|1=struct S {
    std::string m;
    S(const std::string&amp; arg) try : m(arg, 100) {
        std::cout &lt;&lt; &quot;constructed, mn = &quot; &lt;&lt; m &lt;&lt; '\n';
    } catch(const std::exception&amp; e) {
        std::cerr &lt;&lt; &quot;arg=&quot; &lt;&lt; arg &lt;&lt; &quot; failed: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    } // implicit throw; here
};
}}

Before any catch clauses of a function-try-block on a constructor are entered, all fully-constructed members and bases have already been destroyed.

{{rev begin}}
{{rev |since=c++11| If the function-try-block is on a delegating constructor, which called a non-delegating constructor that completed successfully, but then the body of the delegating constructor throws, the destructor of this object will be completed before any catch clauses of the function-try-block are entered.}}
{{rev end}}

Before any catch clauses of a function-try-block on a destructor are entered, all bases and non-variant members have already been destroyed.

The behavior is undefined if the catch-clause of a function-try-block used on a constructor or a destructor accesses a base or a non-static member of the object.

Every catch-clause in the function-try-block for a constructor must terminate by throwing an exception. If the control reaches the end of such handler, the current exception is automatically rethrown as if by {{c|throw;}}. The return statement is not allowed in any catch clause of a constructor's function-try-block.

Reaching the end of a catch clause for a function-try-block on a destructor also automatically rethrows the current exception as if by {{c|throw;}}, but a return statement is allowed.

For all other functions, reaching the end of a catch clause is equivalent to {{c|return;}} (which means undefined behavior if the function is not returning {{c|void}})

===Notes===
The primary purpose of function-try-blocks is to log or modify, and then rethrow the exceptions thrown from the member initializer list in a constructor. They are rarely used with destructors or with regular functions.

Function-try-block does not catch the exceptions thrown by the copy/move constructors and the destructors of the function parameters passed by value: those exceptions are thrown in context of the caller.

{{rev begin}}
{{rev|since=c++11|
Function-try-block of the top-level function of a thread does not catch the exceptions thrown from the constructors and destructors of {{rlp|storage_duration|thread-local}} objects (except for the constructors of function-scoped thread-locals). }}
{{rev end}}
Likewise, function-try-block of the {{rlp|main_function|main() function}} does not catch the exceptions thrown from the constructors and destructors of {{rlp|storage_duration|static}} objects (except for the constructors of function-local statics).

{{rlp|scope#Block_scope|The scope}} and lifetime of the function parameters (but not any objects declared in the function itself), extend to the end of the {{spar|handler-sequence}}.
{{source|1=
int f(int n = 2) try {
   ++n; // increments the function parameter
   throw n;
} catch(...) {
   ++n; // n is in scope and still refers to the function parameter
   assert(n == 4);
   return n;
}
}}</text>
      <sha1>p1i27pq4rgn4d55y3zbg0wuvedq8kzl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/function template</title>
    <ns>0</ns>
    <id>5067</id>
    <revision>
      <id>72400</id>
      <parentid>72396</parentid>
      <timestamp>2014-08-19T14:16:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>break up static data member mention in the intro into pre and post-c++14</comment>
      <text xml:space="preserve" bytes="28931">{{title|Function template}}
{{cpp/language/templates/navbar}}

A function template defines a family of functions.

===Syntax===
{{sdsc begin}}
{{sdsc|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|declaration}} }}
{{sdsc end}}

===Explanation===
{{spar|declaration}} defines or declares a [[cpp/language/class_template|class (including struct and union), a member class or member enumeration type]], a function or member function, a static data member at namespace scope, {{rev inl|since=c++14|{{rlp|variable template|a variable or static data member at class scope}},}} {{rev inl|since=c++11|or a [[cpp/language/type_alias|alias template]]}}. It may also define a [[cpp/language/template_specialization|template specialization]]. This page focuses on function templates.

{{spar|parameter-list}} is a non-empty comma-separated list of the template parameters, each of which is either non-type parameter, a type parameter, a template parameter, or a [[cpp/language/parameter_pack|parameter pack]] of any of those. For function templates, template parameters are declared in the same manner as for class templates: see [[cpp/language/class_template|class template]] page for details.

===Function template instantiation===
A function template by itself is not a type, or a function, or any other entity. No code is generated from a source file that contains only template definitions. In order for any code to appear, a template must be instantiated: the template arguments must be determined so that the compiler can generate an actual function (or class, from a class template).

====Explicit instantiation====
{{sdsc begin}}
{{sdsc|num=1|{{ttb|template}} {{spar|return-type}} {{spar|name}} {{ttb|&lt;}}  {{spar|argument-list}} {{ttb|&gt;}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{ttb|;}}  }}
{{sdsc|num=2|{{ttb|template}} {{spar|return-type}} {{spar|name}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{ttb|;}}  }}
{{sdsc|num=3|{{ttb|extern}} {{ttb|template}} {{spar|return-type}} {{spar|name}} {{ttb|&lt;}} {{spar|argument-list}} {{ttb|&gt;}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{ttb|;}} | notes={{mark since c++11}} }}
{{sdsc|num=4|{{ttb|extern}} {{ttb|template}} {{spar|return-type}} {{spar|name}} {{ttb|(}} {{spar|parameter-list}} {{ttb|)}} {{ttb|;}} | notes={{mark since c++11}} }}
{{sdsc end}}
@1@ Explicit instantiation definition (without {{rlp|template argument deduction}} if every non-default template parameter is explicitly specified)
@2@ Explicit instantiation definition with template argument deduction for all parameters
@3@ Explicit instantiation declaration (without template argument deduction if every non-default template parameter is explicitly specified)
@4@ Explicit instantiation declaration with template argument deduction for all parameters

An explicit instantiation definition forces instantiation of the function or member function they refer to. It may appear in the program anywhere after the template definition, and for a given argument-list, is only allowed to appear once in the program.

An explicit instantiation declaration (an extern template) prevents implicit instantiations: the code that would otherwise cause an implicit instantiation has to use the explicit instantiation definition provided somewhere else in the program.


A trailing template-argument can be left unspecified in an explicit instantiation of a function template specialization or of a member function template specialization if it can be {{rlp|template argument deduction|deduced}} from the function parameter
{{source|1=
template&lt;typename T&gt;
void f(T s)
{
    std::cout &lt;&lt; s &lt;&lt; '\n';
}

template void f&lt;double&gt;(double); // instantiates f&lt;double&gt;(double)
template void f&lt;&gt;(char); // instantiates f&lt;char&gt;(char), template argument deduced
template void f(int); // instantiates f&lt;int&gt;(int), template argument deduced
}}

Explicit instantiation of a function template or of a member function of a class template cannot use {{tt|inline}} or {{tt|constexpr}}. If the declaration of the explicit instantiation names an implicitly-declared special member function, the program is ill-formed.

Explicit instantiation declarations do not suppress the implicit instantiation of {{rlp|inline}} functions, {{rlp|auto}}-declarations, references, and class template specializations. (thus, when the inline function that is a subject of explicit instantiation declaration is ODR-used, it is implicitly instantiated for inlining, but its out-of-line copy is not generated in this TU)

Explicit instantiation definition of a function template with {{rlp|default arguments}} is not a use of the arguments, and does not attempt to initialize them:
{{source|1=
char* p = 0;
template&lt;class T&gt; T g(T x = &amp;p) { return x; }
template int g&lt;int&gt;(int);   // OK even though &amp;p isn’t an int.
}}

====Implicit instantiation====
When code refers to a function in context that requires the function definition to exist, and this particular function has not been explicitly instantiated, implicit instantiation occurs. The list of template arguments does not have to be supplied if it can be {{rlp|template_argument_deduction|deduced}} from context

{{example
|code=
#include &lt;iostream&gt;

template&lt;typename T&gt;
void f(T s)
{
    std::cout &lt;&lt; s &lt;&lt; '\n';
}

int main()
{
    f&lt;double&gt;(1); // instantiates and calls f&lt;double&gt;(double)
    f&lt;&gt;('a'); // instantiates and calls f&lt;char&gt;(char)
    f(7); // instantiates and calls f&lt;int&gt;(int)
    void (*ptr)(std::string) = f; // instantiates f&lt;string&gt;(string)
}
}}

Note: omitting {{tt|&lt;&gt;}} entirely allows {{rlp|overload resolution}} to examine both template and non-template overloads.

===Template argument deduction===
In order to instantiate a {{rlp|function template}}, every template argument must be known, but not every template argument has to be specified. When possible, the compiler will deduce the missing template arguments from the function arguments. This occurs when a function call is attempted and when an address of a function template is taken.

{{source|1=
template&lt;typename To, typename From&gt; To convert(From f);

void g(double d) 
{
    int i = convert&lt;int&gt;(d); // calls convert&lt;int,double&gt;(double)
    char c = convert&lt;char&gt;(d); // calls convert&lt;char,double&gt;(double)
    int(*ptr)(float) = convert; // instantiates convert&lt;int, float&gt;(float)
}
}}

This mechanism makes it possible to use template operators, since there is no syntax to specify template arguments for an operator other than by re-writing it as a function call expression.

{{source|1=
#include &lt;iostream&gt;
int main() 
{
    std::cout &lt;&lt; &quot;Hello, world&quot; &lt;&lt; std::endl;
    // operator&lt;&lt; is looked up via ADL as std::operator&lt;&lt;,
    // then deduced to operator&lt;&lt;&lt;char, std::char_traits&lt;char&gt;&gt; both times
    // std::endl is deduced to &amp;std::endl&lt;char, std::char_traits&lt;char&gt;&gt;
}
}}

Template argument deduction takes place after the function template {{rlp|lookup|name lookup}} (which may involve {{rlp|adl|argument-dependent lookup}}) and before {{rlp|overload_resolution|overload resolution}}.

See {{rlp|template argument deduction}} for details.

===Explicit template arguments===
Template arguments of a function template may be obtained from
* template argument deduction
* default template arguments
:* specified explicitly in a function call expression
:* specified explicitly when an address of a function is taken
:* specified explicitly when a reference to function is initialized
:* specified explicitly when a pointer to member function is formed
:* specified in an explicit specialization
:* specified in an explicit instantiation
:* specified in a friend declaration

There is no way to explicitly specify template arguments to operators, conversion functions, and constructors, because they are called without the use of the function name.

The specified template arguments must match the template parameters in kind (i.e., type for type, non-type for non-type, and template for template). There cannot be more arguments than there are parameters (unless one parameter is a parameter pack, in which case there has to be an argument for each non-pack parameter)

The specified non-type arguments must either match the types of the corresponding non-type template parameters, or be {{rlp|template_parameters#Template_non-type_arguments|convertible to them}}.

The function parameters that do not participate in template argument deduction (e.g. if the corresponding template arguments are explicitly specified) are subject to implicit conversions to the type of the corresponding function parameter (as in the usual {{rlp|overload resolution}}).

A template parameter pack that is explicitly specified may be extended by template argument deduction if there are additional arguments:
{{source|1=
template&lt;class ... Types&gt; void f(Types ... values);
void g() {
  f&lt;int*, float*&gt;(0, 0, 0); // Types = {int*, float*, int}
}
}}

===Template argument substitution===
When all template arguments have been specified, deduced or obtained from default template arguments, every uses of a template parameter in the function parameter list is replaced with the corresponding template arguments.

Substitution failure (that is, failure to replace template parameters with the deduced or provided template arguments) of a function template removes the function template from the {{rlp|overload resolution|overload set}}. This allows a number of ways to manipulate overload sets using template metaprogramming: see {{rlp|sfinae|SFINAE}} for details.

After substitution, all function parameters of array and function type are adjusted to pointers and all top-level cv-qualifiers are dropped from function parameters (as in a regular {{rlp|function#Function_declaration|function declaration}}).

The removal of the top-level cv-qualifiers does not affect the type of the parameter as it appears within the function:
{{source|1=
template &lt;class T&gt; void f(T t);
template &lt;class X&gt; void g(const X x);
template &lt;class Z&gt; void h(Z z, Z* zp);

// two different functions with the same type, but 
// within the function, t has different cv qualifications
f&lt;int&gt;(1);       // function type is void(int), t is int
f&lt;const int&gt;(1); // function type is void(int), t is const const

// two different functions with the same type and the same x
// (pointers to these two functions are not equal,
//  and function-local statics would have different addresses)
g&lt;int&gt;(1);       // function type is void(int), x is const int
g&lt;const int&gt;(1); // function type is void(int), x is const int

// only top-level cv-qualifiers are dropped:
h&lt;const int&gt;(1, NULL); // function type is void(int, const int*) 
                       // z is const int, zp is const int* 
}}

===Function template overloading===
More than one function templates and non-template functions may be overloaded.

A non-template function is always distinct from a template specialization with the same type. Specializations of different function templates are always distinct from each other even if they have the same type. Two function templates with the same return type and the same parameter list are distinct and can be distinguished with explicit template argument list.

When an expression that uses type or non-type template parameters appears in the function parameter list or in the return type, that expression remains a part of the function template signature for the purpose of overloading:
{{source|1=
template&lt;int I, int J&gt; A&lt;I+J&gt; f(A&lt;I&gt;, A&lt;J&gt;); // overload #1
template&lt;int K, int L&gt; A&lt;K+L&gt; f(A&lt;K&gt;, A&lt;L&gt;); // same as #1
template&lt;int I, int J&gt; A&lt;I-J&gt; f(A&lt;I&gt;, A&lt;J&gt;); // overload #2
}}

Two expressions involving template parameters are called ''equivalent'' if two function definitions that contain these expressions would be the same under {{rlp|definition#One_Definition_Rule|ODR rules}}, that is, the two expressions contain the same sequence of tokens whose names are resolved to same entities via name lookup, except template parameters may be differently named.
{{source|1=
template &lt;int I, int J&gt; void f(A&lt;I+J&gt;);  // template overload #1
template &lt;int K, int L&gt; void f(A&lt;K+L&gt;);  // equivalent to #1
}}

{{rev begin}}
{{rev|since=c++14|
When determining if two {{rlp|dependent name|dependent expressions}} are equivalent, only the dependent names involved are considered, not the results of name lookup. If multiple declarations of the same template differ in the result of name lookup, the first such declaration is used:
{{source|1=
template &lt;class T&gt; decltype(g(T())) h(); // decltype(g(T())) is a dependent type
int g(int);
template &lt;class T&gt; decltype(g(T())) h() { // redeclaration of h() uses earlier lookup
    return g(T());                     // ...although the lookup here does find g(int)
}
int i = h&lt;int&gt;();   // template argument substitution fails; g(int)
                    // was not in scope at the first declaration of h()
}}
}}
{{rev end}}

Two function templates are considered ''equivalent'' if
* they are declared in the same scope
* they have the same name
* they have identical template parameter lists
* the expressions involving template parameters in their return types and parameter lists are ''equivalent''

Two expressions involving template parameters are called ''functionally equivalent'' if they are not ''equivalent'', but for any given set of template arguments, the evaluation of the two expressions results in the same value.

Two function templates are considered ''functionally equivalent'' if they are ''equivalent'', except that one or more expressions that involve template parameters in the 
* they are ''equivalent'' (as above) except that one or more expressions that involve template  parameters in their return types and parameter lists are ''functionally equivalent''

If a program contains declarations of function templates that are ''functionally equivalent'' but not ''equivalent'', the program is ill-formed; no diagnostic is required.
{{source|1=
// equivalent
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+10&gt;); // overload #1
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+10&gt;); // redeclaration of overload #1

// not equivalent
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+10&gt;); // overload #1
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+11&gt;); // overload #2

// functionally-equivalent but not equivalent
// This program is ill-formed, no diagnostic required
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+10&gt;); // overload #1
template &lt;int I&gt; void f(A&lt;I&gt;, A&lt;I+1+2+3+4&gt;); // functionally equivalent
}}

When the same function template specialization matches more than one overloaded function template (this often results from {{rlp|template argument deduction}}), ''partial ordering of overloaded function templates'' is performed to select the best match. 

Specifically, partial ordering takes place in the following situations:
@1@ overload resolution for a call to a function template specialization
{{todo|mini-example}}
@2@ when the address of a function template specialization is taken
{{todo|mini-example}}
@3@ when a [[cpp/memory/new/operator_delete|placement operator delete]] that is a function template specialization is selected to match a placement operator new
{{todo|mini-example}}
@4@ when a {{rlp|friend#Template_friends|friend function declaration}}, an {{rlp|function_template#Explicit_instantiation|explicit instantiation}}, or an {{rlp|template specialization|explicit specialization}} refers to a function template specialization
{{source|1=
template&lt;class X&gt; void f(X a);  // first template f
template&lt;class X&gt; void f(X* a); // second template f
template&lt;&gt; void f&lt;&gt;(int *a) {} // explicit specialization
 // template argument deduction comes up with two candidates:
 // foo&lt;int*&gt;(int*) and f&lt;int&gt;(int*)
 // partial ordering selects f&lt;int&gt;(int*) as more specialized
}}

To determine which of any two function templates is more specialized, the partial ordering process first transforms one of the two templates as follows:
* For each type, non-type, and template parameter, including parameter packs, a unique fictitious type, value, or template is generated and substituted into function type of the template
* If only one of the two function templates being compared is a non-static member of some class {{tt|A}}, a new first parameter is inserted into its parameter list, whose type is {{tt|cv A&amp;&amp;}} if the member function template is &amp;&amp;-qualified and {{tt|cv A&amp;}} otherwise (cv is the cv-qualification of the member function template) -- this helps the ordering of operators, which are looked up both as member and as non-member functions:
{{source|1=
struct A {};
template&lt;class T&gt; struct B {
  template&lt;class R&gt; int operator*(R&amp;);                     // #1
};
template&lt;class T, class R&gt; int operator*(T&amp;, R&amp;);          // #2
int main() {
  A a;
  B&lt;A&gt; b;
  b * a; // template argument deduction for int B&lt;A&gt;::operator*(R&amp;) gives R=A 
         //                             for int operator*(T&amp;, R&amp;), T=B&lt;A&gt;, R=A
// For the purpose of partial ordering, the member template B&lt;A&gt;::operator*
// is transformed into template&lt;class R&gt; int operator*(B&lt;A&gt;&amp;, R&amp;);
// partial ordering between 
//     int operator*(   T&amp;, R&amp;)  T=B&lt;A&gt;, R=A
// and int operator*(B&lt;A&gt;&amp;, R&amp;)  R=A 
// selects int operator*(B&lt;A&gt;&amp;, A&amp;) as more specialized
}}

After one of the two templates was transformed as described above, {{rlp|template argument deduction}} is executed using the transformed template as the argument template and the original template type of the other template as the parameter template. The process is then repeated using the second template (after transformations) as the argument and the first template in its original form as the parameter.

The types used to determine the order depend on the context:
* in the context of a function call, the types are those function parameter types for which the function call has arguments (default function arguments, parameter packs, and ellipsis parameters are not considered -- see examples below)
* in the context of a call to a user-defined conversion function, the return types of the conversion function templates are used
* in other contexts, the function template type is used

Each type from the list above from the parameter template is deduced. Before deduction begins, each parameter {{ttb|P}} of the parameter template and the corresponding argument {{ttb|A}} of the argument template is adjusted as follows:

* If both {{ttb|P}} and {{ttb|A}} are reference types before, determine which is more cv-qualified (in all other cases, cv-qualificiations are ignored for partial ordering purposes)
* If {{ttb|P}} is a reference type, it is replaced by the type referred to
* If {{ttb|A}} is a reference type, it is replaced by the type referred to
* If {{ttb|P}} is cv-qualified, {{ttb|P}} is replaced with cv-unqualified version of itself
* If {{ttb|A}} is cv-qualified, {{ttb|A}} is replaced with cv-unqualified version of itself
* If {{ttb|A}} was transformed from a function parameter pack and {{tt|P}} is not a parameter pack, deduction fails

After these adjustments, deduction of {{ttb|P}} from {{ttb|A}} is done following {{rlp|template argument deduction#Deduction_from_a_type|template argument deduction from a type}}.

If the argument {{ttb|A}} of the transformed template-1 can be used to deduce the corresponding parameter {{ttb|P}} of template-2, but not vice versa, then this {{ttb|A}} is more specialized than {{ttb|P}} with regards to the type(s) that are deduced by this P/A pair.

If deduction succeeds in both directions, and the original {{ttb|P}} and {{ttb|A}} were reference types, then additional tests are made:
* If {{ttb|A}} was lvalue reference and {{ttb|P}} was rvalue reference, A is considered to be more specialized than P
* If {{ttb|A}} was more cv-qualified than {{ttb|P}}, A is considered to be more specialized than P

In all other cases, neither template is more specialized than the other with regards to the type(s) deduced by this P/A pair.

After considering every P and A in both directions, if, for each type that was considered,
* template-1 is at least as specialized as template-2 for all types
* template-1 is more specialized than template-2 for some types
* template-2 is not more specialized than template-1 for any types OR is not at least as specialized for any types

Then template-1 is more specialized than template-2. If the conditions above are true after switching template order, than template-2 is more specialized than template-1. Otherwise, neither template is more specialized than the other.

If, after considering all pairs of overloaded templates, there is one that is unambiguously more specialized than all others, that template's specialization is selected, otherwise compilation fails.

In the following examples, the fictitious arguments will be called U1, U2
{{source|1=
template&lt;class T&gt; void f(T);        // template #1
template&lt;class T&gt; void f(T*);       // template #2
template&lt;class T&gt; void f(const T*); // template #3
void m() {
  const int* p;
  f(p); // overload resolution picks: #1: void f(T ) [T = const int *]
        //                            #2: void f(T*) [T = const int]
        //                            #3: void f(const T *) [T = int]
// partial ordering
// #1 from transformed #2: void(T) from void(U1*): P=T A=U1*: deduction ok: T=U1*
// #2 from transformed #1: void(T*) from void(U1): P=T* A=U1: deduction fails
// #2 is more specialized than #1 with regards to T
// #1 from transformed #3: void(T) from void(const U1*): P=T, A=const U1*: ok
// #3 from transformed #1: void(const T*) from void(U1): P=const T*, A=U1: fails
// #3 is more specialized than #1 with regards to T
// #2 from transformed #3: void(T*) from void(const U1*): P=T* A=const U1*: ok
// #3 from transformed #2: void(const T*) from void(U1*): P=const T* A=U1*: fails
// #3 is more specialized than #2 with regards to T
// result: #3 is selected
// in other words, f(const T*) is more specialized than f(T) or f(T*)
}
}}

{{source|1=
template&lt;class T&gt; void f(T, T*);    // #1
template&lt;class T&gt; void f(T, int*);  // #2
void m(int* p) {
    f(0, p); // deduction for #1: void f(T, T*) [T = int]
             // deduction for #2: void f(T, int*) [T = int]
 // partial ordering:
 // #1 from #2: void(T,T*) from void(U1,int*): P1=T, A1=U1: T=U1
 //                                            P2=T*, A2=int*: T=int: fails
 // #2 from #1: void(T,int*) from void(U1,U2*) : P1=T A1=U1: T=U1
 //                                              P2=int* A2=U2*: fails
 // neither is more specialized w.r.t T, the call is ambiguous
}
}}

{{source|1=
template&lt;class T&gt; void g(T);  // template #1
template&lt;class T&gt; void g(T&amp;); // template #2
void m() {
  float x;
  g(x); // deduction from #1: void g(T ) [T = float]
        // deduction from #2: void g(T&amp;) [T = float]
// partial ordering
// #1 from #2: void(T) from void(U1&amp;): P=T, A=U1 (after adjustment), ok
// #2 from #1: void(T&amp;) from void(U1): P=T (after adjustment), A=U1: ok
// neither is more specialized w.r.t T, the call is ambiguous
}
}}

{{source|1=
template&lt;class T&gt; struct A { A(); };

template&lt;class T&gt; void h(const T&amp;); // #1
template&lt;class T&gt; void h(A&lt;T&gt;&amp;);    // #2
void m() {
  A&lt;int&gt; z;
  h(z);  // deduction from #1: void h(const T &amp;) [T = A&lt;int&gt;]
         // deduction from #2: void h(A&lt;T&gt; &amp;) [T = int]
 // partial ordering
 // #1 from #2: void(const T&amp;) from void(A&lt;U1&gt;&amp;): P=T A=A&lt;U1&gt;: ok T=A&lt;U1&gt;
 // #2 from #1: void(A&lt;T&gt;&amp;) from void(const U1&amp;): P=A&lt;T&gt; A=const U1: fails
 // #2 is more specialized than #1 w.r.t T

  const A&lt;int&gt; z2;
  h(z2); // deduction from #1: void h(const T&amp;) [T = A&lt;int&gt;]
         // deduction from #2: void h(A&lt;T&gt;&amp;) [T = int], but substitution fails
 // only one overload to choose from, partial ordering not tried, #1 is called
}
}}

Since in a call context considers only parameters for which there are explicit call arguments, those function parameter packs, ellipsis parameters, and parameters with default arguments, for which there is no explicit call argument, are ignored:
{{source|1=
template&lt;class T&gt;  void  f(T);               // #1
template&lt;class T&gt;  void  f(T*, int=1);       // #2
void m(int* ip) {
  int* ip;
  f(ip);     // calls #2 (T* is more specialized than T)
}
}}

{{source|1=
template&lt;class  T&gt;  void  g(T);               // #1
template&lt;class  T&gt;  void  g(T*, ...);         // #2
void m(int* ip) {
   g(ip);     // calls #2 (T* is more specialized than T)
}
}}

{{source|1=
template&lt;class T, class U&gt; struct A { };
template&lt;class T, class U&gt; void f(U, A&lt;U,T&gt;* p = 0); // #1
template&lt;         class U&gt; void f(U, A&lt;U,U&gt;* p = 0); // #2
void h() {
  f&lt;int&gt;(42, (A&lt;int, int&gt;*)0);  // calls #2
  f&lt;int&gt;(42);                   // error: ambiguous
}
}}

{{source|1=
template&lt;class T           &gt;  void g(T, T = T());  // #1
template&lt;class T, class... U&gt; void g(T, U ...);    // #2
void h() {
  g(42);  // error: ambiguous
}
}}

{{source|1=
template&lt;class  T, class... U&gt; void f(T, U...);           // #1
template&lt;class  T            &gt; void f(T);                 // #2
void h(int i) {
  f(&amp;i);        // error: ambiguous
}
}}

{{source|1=
template&lt;class  T, class... U&gt; void g(T*, U...);          // #1
template&lt;class  T            &gt; void g(T);                 // #2
void h(int i) {
  g(&amp;i);        // OK: calls #1 (T* is more specialized than T)
}
}}

{{source|1=
template&lt;class... Args&gt;           void f(Args... args);               // #1
template&lt;class T1, class... Args&gt; void f(T1 a1, Args... args);        // #2
template&lt;class T1, class T2&gt;      void f(T1 a1, T2 a2);               // #3
f();                  // calls #1
f(1, 2, 3);           // calls #2
f(1, 2);              // calls #3; non-variadic template #3 is more
                      // specialized than the variadic templates #1 and #2
}}

During template argument deduction within the partial ordering process, template parameters don't require to be matched with arguments, if the argument is not used in any of the types considered for partial ordering
{{source|1=
template &lt;class T&gt;          T f(int);  // #1
template &lt;class T, class U&gt; T f(U);    // #2
void g() {
  f&lt;int&gt;(1);  // specialization of #1 is explicit: T f(int) [T = int]
              // specialization of #2 is deduced:  T f(U) [T = int, U = int]
// partial ordering (only considering the argument type)
// #1 from #2: T(int) from U1(U2): fails
// #2 from #1: T(U) from U1(int): ok: U=int, T unused
// calls #1
}
}}

Partial ordering of function templates containing template parameter packs is independent of the number of deduced arguments for those template parameter packs.
{{source|1=
template&lt;class...&gt; struct Tuple { };
template&lt;          class... Types&gt; void g(Tuple&lt;Types ...&gt;);        // #1
template&lt;class T1, class... Types&gt; void g(Tuple&lt;T1, Types ...&gt;);    // #2
template&lt;class T1, class... Types&gt; void g(Tuple&lt;T1, Types&amp; ...&gt;);   // #3

g(Tuple&lt;&gt;());                     // calls #1
g(Tuple&lt;int, float&gt;());           // calls #2
g(Tuple&lt;int, float&amp;&gt;());          // calls #3
g(Tuple&lt;int&gt;());                  // calls #3
}}



{{todo|14.8.3[temp.over]}}
To compile a call to a function template, the compiler has to decide between non-template overloads, template overloads, and the specializations of the template overloads.

{{source|1=
template&lt; class T &gt; void f(T);              // #1: template overload
template&lt; class T &gt; void f(T*);             // #2: template overload
void                     f(double);         // #3: nontemplate overload
template&lt;&gt;          void f(int);            // #4: specialization of #1

f('a');        // calls #1
f(new int(1)); // calls #2
f(1.0);        // calls #3
f(1);          // calls #4
}}

Note that only non-template and primary template overloads participate in overload resolution. The specializations are not overloads and are not considered. Only after the overload resolution selects the best-matching primary function template, its specializations are examined to see if one is a better match.

{{source|1=
template&lt; class T &gt; void f(T);    // #1: overload for all types
template&lt;&gt;          void f(int*); // #2: specialization of #1 for pointers to int
template&lt; class T &gt; void f(T*);   // #3: overload for all pointer types

f(new int(1)); // calls #3, even though specialization of #1 would be a perfect match
}}

For detailed rules on overload resolution, see {{rlp|overload_resolution|overload resolution}}

===Function template specialization===
{{todo|14.8[temp.fct.spec] (note that 14.8.1[temp.arg.explicit] is already in full specialization article: either function specifics go here: lack of partials, interaction with function overloads, or just refer to that}}

==See Also==
* [[cpp/language/class template|class template]]
* [[cpp/language/function|function declaration]]

[[de:cpp/language/function template]]
[[es:cpp/language/function template]]
[[fr:cpp/language/function template]]
[[it:cpp/language/function template]]
[[ja:cpp/language/function template]]
[[pt:cpp/language/function template]]
[[ru:cpp/language/function template]]
[[zh:cpp/language/function template]]</text>
      <sha1>9tbsakdrmho2089og8d8vd4mndodum2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/functions</title>
    <ns>0</ns>
    <id>9921</id>
    <revision>
      <id>69664</id>
      <parentid>69216</parentid>
      <timestamp>2014-04-18T07:59:11Z</timestamp>
      <contributor>
        <ip>76.182.90.8</ip>
      </contributor>
      <text xml:space="preserve" bytes="3461">{{title|Functions}}
{{cpp/language/functions/navbar}}

Functions are C++ entities that associate a sequence of {{rlp|statements}} (a ''function body'') with a ''name'' and a list of zero or more ''function parameters''.

{{source|
// function name: &quot;isodd&quot;
// parameter list has one parameter, with name &quot;n&quot; and type int
// the return type is bool
bool isodd(int n)
{                      // the body of the function begins
    return n % 2;
}                      // the body of the function ends
}}

When a function is invoked, e.g. in a {{rlp|operator_other#Built-in_function_call_operator|function-call expression}}, the parameters are initialized from the arguments (either provided at the place of call or {{rlp|default_arguments|defaulted}}) and the statements in the function body are executed.

{{source|
int main()
{
    for(int arg : {-3, -2, -1, 0, 1, 2, 3})
        std::cout &lt;&lt; isodd(arg) &lt;&lt; ' '; // isodd called 7 times, each
                                        // time n is copy-initialized from arg
}
}}

A function can terminate by {{rlp|return|returning}} or by {{rlp|throw|throwing}} an {{rlp|exceptions|exception}}.

A {{rlp|function|function declaration}} may appear in any scope, but a {{rlp|function|function definition}} may only appear in namespace scope or, for {{rlp|member_functions|member}} and {{rlp|friend}} functions, in class scope. A function that is declared in a class body without a friend specifier is a class member function. Such functions have many additional properties, see {{rlp|member_functions|member functions}} for details.

Functions are not objects: there are no arrays of functions and functions cannot be passed by value or returned from other functions. Pointers and references to functions are allowed, and may be used where functions themselves cannot.

Each function has a type, which consists of the function's return type, the types of all parameters (after array-to-pointer and function-to-pointer transformations, see {{rlp|function#Parameter list|parameter list}}), and, for member functions, cv-qualification and ref-qualification. Function types also have {{rlp|language_linkage|language linkage}}. There are no cv-qualified function types (not to be confused with the types of {{rlp|member_functions|cv-qualified functions}} such as {{c|int f() const;}} or functions returning {{rlp|cv|cv-qualified types}}, such as {{c|std::string const f();}})

Unnamed functions can be generated by {{rlp|lambda|lambda-expressions}}.

Multiple functions in the same scope may have the same name, as long as their parameter lists and, for member functions, cv/ref qualifications are different. This is known as {{rlp|overload_resolution|function overloading}}.

{{todo|links to other Function subpages}}

===Function objects===
Besides function lvalues, the function call expression supports pointers to functions, dereferenced pointers to member functions, {{rlp|lambda|lambda-expressions}}, and any variable of class type that overloads the function-call operator. Together, these types are known as {{concept|FunctionObject}}s, and they are used ubiquitously through the C++ standard library, see for example, usages of {{concept|BinaryPredicate}} and {{concept|Compare}}.

The standard library also provides a number of pre-defined [[cpp/utility/functional|function object templates]] as well as the methods to compose new ones (including {{lc|std::mem_fn}}, {{lc|std::bind}}, and {{lc|std::function}}).</text>
      <sha1>41dxqqeprl8bc3wmg0xx9cy2hmwojnk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/goto</title>
    <ns>0</ns>
    <id>697</id>
    <revision>
      <id>69091</id>
      <parentid>49919</parentid>
      <timestamp>2014-03-27T03:59:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+try/catch interaction</comment>
      <text xml:space="preserve" bytes="3097">{{title|goto statement}}
{{cpp/language/statements/navbar}}

Transfers control unconditionally.

Used when it is otherwise impossible to transfer control to the desired location using other statements.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|goto}} {{spar|label}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===

The goto statement transfers control to the location specified by {{spar|label}}. The goto statement must be in the same function as the {{spar|label}} it is referring, it may appear before or after the label.

If transfer of control exits the scope of any automatic variables (e.g. by jumping backwards to a point before the declarations of such variables or by jumping forward out of a compound statement where the variables are scoped), the destructors are called for all variables whose scope was exited, in the order opposite to the order of their construction.

The {{tt|goto}} statement cannot transfer control into a {{rlp|try_catch|try-block}} or into a catch-clause, but can transfer control out of a try-block or a catch-clause (the rules above regarding automatic variables in scope are followed)

If transfer of control enters the scope of any automatic variables (e.g. by jumping forward over a declaration statement), the program is ill-formed (cannot be compiled), unless all variables whose scope is entered have
@1@ scalar types declared without initializers
@2@ class types with trivial default constructors and trivial destructors declared without initializers
@3@ cv-qualified versions of one of the above
@4@ arrays of one of the above

(Note: the same rules apply to all forms of transfer of control)

===Keywords===

{{ltt|cpp/keyword/goto}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

struct Object {
    // non-trivial destructor
    ~Object() { std::cout &lt;&lt; &quot;d&quot;; }
};

struct Trivial {
    double d1;
    double d2;
}; // trivial ctor and dtor

int main()
{
    int a = 10;
    
    // loop using goto
label:
    Object obj;
    std::cout &lt;&lt; a &lt;&lt; &quot; &quot;;
    a = a - 2;

    if (a != 0) {
        goto label;  // jumps out of scope of obj, calls obj destructor
    }
    std::cout &lt;&lt; '\n';

    // goto can be used to leave a multi-level loop easily
    for (int x = 0; x &lt; 3; x++) {
        for (int y = 0; y &lt; 3; y++) {
            std::cout &lt;&lt; &quot;(&quot; &lt;&lt; x &lt;&lt; &quot;;&quot; &lt;&lt; y &lt;&lt; &quot;) &quot; &lt;&lt; '\n';
            if (x + y &gt;= 3) {
                goto endloop;
            }
        }
    }
endloop:
    std::cout &lt;&lt; '\n';

    goto label2; // jumps into the scope of n and t
    int n; // no initializer
    Trivial t; // trivial ctor/dtor, no initializer
//  int x = 1; // error: has initializer
//  Object obj2; // error: non-trivial dtor
label2:

    {
        Object obj3;
        goto label3; // jumps forward, out of scope of obj3
    }
label3: ;

}
 | output=
10 d8 d6 d4 d2
(0;0) 
(0;1) 
(0;2) 
(1;0) 
(1;1) 
(1;2) 

dd
}}

[[de:cpp/language/goto]]
[[es:cpp/language/goto]]
[[fr:cpp/language/goto]]
[[it:cpp/language/goto]]
[[ja:cpp/language/goto]]
[[pt:cpp/language/goto]]
[[ru:cpp/language/goto]]
[[zh:cpp/language/goto]]</text>
      <sha1>oiz4ipux1x0nk615izpoi87omihln0k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/history</title>
    <ns>0</ns>
    <id>4470</id>
    <revision>
      <id>72386</id>
      <parentid>72385</parentid>
      <timestamp>2014-08-18T14:37:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/next//</comment>
      <text xml:space="preserve" bytes="11201">{{title|History of C++}}
{{cpp/language/navbar}}

==Early C++==
* 1979: C with Classes first implemented
# New features: {{rlp|classes}}, {{rlp|member functions}}, {{rlp|derived class}}es, separate compilation, {{rlp|access|public and private access control}}, {{rlp|friend}}s, type checking of function arguments, {{rlp|default arguments}}, {{rlp|inline|inline functions}}, {{rlp|as operator|overloaded assignment operator}}, {{rlp|constructor}}s, {{rlp|destructor}}s, f() same as f(void), call-function and return-function (synchronization features, not in C++)
# Libraries: the concurrent task library (not in C++)
* 1982: C with Classes reference manual published
* 1984: C84 implemented, reference manual published
* 1985: Cfront 1.0
# New features: {{rlp|virtual|virtual functions}}, function and {{rlp|operators|operator overloading}}, {{rlp|reference|references}}, [[cpp/memory/new/operator_new|new]] and [[cpp/memory/new/operator_delete|delete]] operators, {{rlp|cv|the keyword const}}, scope resolution operator
# Library additions: [[cpp/numeric/complex|complex]], [[cpp/string/basic_string|string]], [[cpp/header/iostream|iostream]]
* 1985: The C++ Programming Language, 1st edition
* 1989: Cfront 2.0
# New features: {{rlp|derived_class|multiple inheritance}}, {{rlp|pointer|pointers to members}}, {{rlp|access|protected access}}, type-safe linkage, {{rlp|abstract class}}es, [[cpp/language/static#Static_member_functions|static]] and [[cpp/language/member_functions#const-,_volatile-,_and_ref-qualified_member_functions|const]] member functions, class-specific [[cpp/memory/new/operator_new#Replacing_and_overloading|new]] and [[cpp/memory/new/operator_delete#Replacing_and_overloading|delete]]
# Library additions: [[cpp/io/manip|I/O manipulators]]
* 1990: The Annotated C++ Reference Manual
This book described the language as designed, including some features that were not yet implemented. It served as the de-facto standard until the ISO.
# New features: {{rlp|namespace}}s, {{rlp|exceptions|exception handling}}, {{rlp|nested classes}}
* 1991: Cfront 3.0
* 1991: The C++ Programming Language, 2nd edition

==Standard C++==

* 1990 ANSI C++ Committee founded
* 1991 ISO C++ Committee founded
* 1998 {{ttb|C++98}} (ISO/IEC 14882:1998)
# New features: RTTI ({{rlp|dynamic_cast}}, {{rlp|typeid|typeid}}), {{rlp|virtual|covariant return types}}, {{rlp|cast operator}}s, [[cpp/language/cv|mutable]], {{rlp|types#Boolean_type|bool}}, declarations in conditions, {{rlp|templates|template instantiations}}, {{rlp|member template}}s, export
# Library additions: [[cpp/container|containers]], [[cpp/algorithm|algorithms]], [[cpp/iterator|iterators]], [[cpp/utility/functional|function objects]] (based on STL), [[cpp/locale|locales]], [[cpp/utility/bitset|bitset]], [[cpp/numeric/valarray|valarray]], [[cpp/memory/auto_ptr|auto_ptr]], [[cpp/string/basic_string|templatized string]], [[cpp/header/iostream|iostream]], and [[cpp/numeric/complex|complex]].
* 1998 The C++ Programming Language, 3rd edition
* 1999 [http://www.boost.org Boost] founded by the committee members to produce new high-quality candidate libraries for the standard.
* 2003 {{ttb|C++03}} (ISO/IEC 14882:2003)
This was a minor revision, intended to be little more than a technical corrigendum
# New features: {{rlp|value initialization}}
# Defect Reports fixed: [http://cplusplus.github.com/LWG/lwg-status.html#TC1 125 defects], including defect [http://cplusplus.github.com/LWG/lwg-defects.html#69 69], which made {{lc|std::vector}} contiguous.
* 2006 Performance TR (ISO/IEC TR 18015:2006) ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=43351 ISO Store]) ([http://www.open-std.org/jtc1/sc22/wg21/docs/TR18015.pdf 2006 draft]) 
* 2007 Library extension TR1 (ISO/IEC TR 19768:2007)  ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=43289 ISO store]) ([http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1745.pdf 2005 draft]).
This TR is a C++ library extension, which adds the following to the C++ standard library:
# From Boost: [[cpp/utility/functional/reference_wrapper|Reference wrapper]], [[cpp/memory#Smart_pointers|Smart pointers]], [[cpp/utility/functional/mem_fn|Member function]], [[cpp/types/result_of|Result Of]], [[cpp/utility/functional/bind|Bind]], [[cpp/utility/functional/function|Function]], [[cpp/types|Type Traits]], [[cpp/numeric/random|Random]], Mathematical Special Functions, [[cpp/utility/tuple|Tuple]], [[cpp/container/array|Array]], [[cpp/container#Unordered_associative_containers|Unordered Containers]] (including [[cpp/utility/hash|Hash]]), and [[cpp/regex|Regular Expressions]].
# From C99: mathematical functions from math.h that were new in C99, [[cpp/string/byte/isblank|blank character class]], [[cpp/numeric/fenv|Floating-point environment]], [[cpp/io/manip/fixed|hexfloat I/O Manipulator]], [[cpp/types/integer|fixed-size integral types]], [[cpp/language/types#Integer_types|the long long type]], [[cpp/utility/variadic/va_copy|va_copy]], the {{lc|snprintf()}} and {{ltf|cpp/io/c/vfscanf}} families of functions, and the C99 conversion specifies for {{ltf|cpp/io/c/printf}} and {{ltf|cpp/io/c/scanf}} families of functions. 
All of TR1 except for the special functions was included in C++11, with minor changes.
* 2010 Mathematical special functions TR (ISO/IEC 29124:2010) ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=50511 ISO Store]) ([http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3060.pdf 2010 draft])
This TR is a C++ standard library extension, which adds the special functions that were part of TR1, but were not included in C++11: elliptic integrals, exponential integral, Laguerre polynomials, Legendre polynomials, Hermite polynomials, Bessel functions, Newmann functions, beta function, and Riemann zeta function.
* 2011 {{ttb|C++11}} (ISO/IEC 14882:2011) ([http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372 ISO Store]) ([http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS%2FISO%2FIEC+14882-2012 ANSI Store]) ([http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3337.pdf Post-publication draft]).
A large number of changes were introduced to both standardize existing practices and improve the abstractions available to the C++ programmers
# New language features: {{rlp|auto}} and {{rlp|decltype}}, defaulted and deleted functions, {{rlp|final}} and {{rlp|override}}, [[cpp/language/function#Function_declaration|trailing return type]], {{rlp|reference|rvalue references}}, {{rlp|move constructor}}s/{{rlp|move_operator|move assignment}}, {{rlp|enum|scoped enums}}, {{rlp|constexpr}} and [[cpp/concept/LiteralType|literal types]], {{rlp|list initialization}}, {{rlp|initializer list#Delegating constructor|delegating}} and {{rlp|using declaration|inherited}} constructors, brace-or-equal initializers, {{rlp|nullptr}}, [[cpp/language/types#Integer_types|long long]], [[cpp/language/types#Character_types|char16_t and char32_t]], {{rlp|type_alias|type alias}}es, {{rlp|parameter_pack|variadic templates}}, {{rlp|union|generalized unions}}, [[cpp/concept/PODType|generalized PODs]], {{rlp|string_literal|Unicode string literals}}, {{rlp|user_literal|user-defined literals}}, {{rlp|attributes}}, {{rlp|lambda|lambda expressions}}, {{rlp|noexcept_spec|noexcept}}, {{rlp|alignof}} and {{rlp|alignas}}, multithreaded memory model, [[cpp/language/storage_duration#Storage_duration|thread-local storage]], [[cpp/memory#Garbage_collector_support|GC interface]], {{rlp|range-for|range for}} (based on a Boost library), {{rlp|static_assert|static assertions}} (based on a Boost library)
# New library features: [[cpp/atomic|atomic operations library]], emplace() and other use of rvalue references throughout all parts of the existing library, [[cpp/utility/initializer_list|std::initializer_list]], stateful and [[cpp/memory/scoped_allocator_adaptor|scoped]] allocators, [[cpp/container/forward_list|forward_list]], [[cpp/chrono|chrono library]], [[cpp/numeric/ratio|ratio library]], new algorithms, [[cpp/locale#Locale-independent_unicode_conversion_facets|Unicode conversion facets]]
# From TR1: all of TR1 except Special Functions.
# From Boost: [[cpp/thread|The thread library]], [[cpp/error/exception_ptr|exception_ptr]], [[cpp/error/error_code|error_code]] and [[cpp/error/error_condition|error_condition]], iterator improvements ([[cpp/iterator/begin|std::begin]], [[cpp/iterator/end|std::end]], [[cpp/iterator/next|std::next]], [[cpp/iterator/prev|std::prev]])
# From C: C-style Unicode conversion functions
# Defect Reports fixed: [http://cplusplus.github.com/LWG/lwg-status.html#CD1 363 defects] resolved by the 2008 draft and [http://cplusplus.github.com/LWG/lwg-status.html#C++11 322 defects] resolved after. Notable defects include [http://cplusplus.github.com/LWG/lwg-defects.html#530 530], which made {{lc|std::basic_string}} objects contiguous.
* 2011 Decimal floating-point TR (ISO/IEC TR 24733:2011) ([http://www.iso.org/iso/home/store/catalogue_tc/catalogue_detail.htm?csnumber=38843 ISO Store]) ([http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2849.pdf 2009 draft])
This TR implements the decimal floating-point types from IEEE 754-2008 Standard for Floating-Point Arithmetic: std::decimal::decimal32, std::decimal::decimal64, and std::decimal::decimal128.
* 2012 [http://isocpp.org The Standard C++ Foundation] founded
* 2013 The C++ Programming Language, 4th edition
* 2014 C++14 ([http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3936.pdf 2014 final draft])
Minor revision of the C++ standard
# New language features: {{rlp|variable template}}s, {{rlp|lambda|polymorphic lambdas}}, lambda captures expressions, new/delete elision&lt;!-- 5.3.4[expr.new]/10 &quot;An implementation is allowed to omit a call...&quot; --&gt;, {{rlp|constexpr|relaxed restrictions on constexpr functions}}, {{rlp|integer literal|binary literals}}, digit separators, {{rlp|function#Return type deduction (since C++14)|return type deduction for functions}}, {{rlp|aggregate initialization}} for classes with brace-or-equal initializers.
# New library features: {{lc|std::make_unique}}, {{lc|std::shared_timed_mutex}} and {{lc|std::shared_lock}}, {{lc|std::integer_sequence}}, {{lc|std::exchange}}, {{lc|std::quoted}}, and many small improvements to existing library facilities, such as two-range overloads for some algorithms, type alias versions of type traits, user-defined string, duration, and complex number literals, etc.
# Defect Reports fixed: [http://cplusplus.github.io/LWG/lwg-status.html#C++14 149 library issues]

===Future development===
* Library fundamentals TS, Filesystem TS, and other [[cpp/experimental|experimental technical specifications]]
* 2017 C++17
The next major revision of the C++ standard

===External links===
*[http://isocpp.org Standard C++ foundation]
*[[:enwiki:C++#History | C++ on Wikipedia]]
*[http://www.open-std.org/jtc1/sc22/wg21/ C++ Standards Committee]

[[de:cpp/language/history]]
[[es:cpp/language/history]]
[[fr:cpp/language/history]]
[[it:cpp/language/history]]
[[ja:cpp/language/history]]
[[pt:cpp/language/history]]
[[ru:cpp/language/history]]
[[zh:cpp/language/history]]</text>
      <sha1>0er8y5wr1xq0wn3ae5gl7uu0yxztqcn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/identifiers</title>
    <ns>0</ns>
    <id>9902</id>
    <revision>
      <id>68993</id>
      <parentid>67972</parentid>
      <timestamp>2014-03-23T16:04:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="4386">{{title|Identifiers}}
{{cpp/language/basics/navbar}}
An ''identifier'' is an arbitrarily long sequence of letters, digits, and underscores, which begins a non-digit. Identifiers are case-sensitive.

===In declarations===

Identifiers can be used {{rlp|declarations|to name}} objects, types, namespaces, and other entities, with the following exceptions:
* The identifiers that are [[cpp/keyword|keywords]] cannot be used for other purposes.
* All identifiers with a double underscore anywhere are reserved
* All identifiers that begin with an underscore followed by an uppercase letter are reserved.
* All identifiers that begin with an underscore are reserved for use at global namespace.

('reserved' means that standard library headers #define or declare such names for their internal needs, and if the programmer uses such names, a name collision may occur)

===In expressions===

An identifier that names a variable or a function can be used as an {{rlp|expressions}}. The expression consisting of just the identifier returns the entity named by the identifier and its {{rlp|value_category|value category}} is ''lvalue'' if the identifier names a function, a variable, or a data member, and it is ''prvalue'' otherwise (e.g. the identifier {{c|nullptr}} is a prvalue expression)

Within the body of a non-static {{rlp|member_functions|member function}}, each identifier that names a non-static member is implicitly transformed to a class member access expression.

Besides simple names of objects and functions, the following language constructs can be used in expressions in the same role (together with identifiers they are known as ''id-expressions'')
* name of an operator function, such as {{c|operator +}} or {{c|operator new}}
* name of a user-defined conversion function, such as {{c|operator bool}}
* name of a user-defined literal operator, such as {{c|operator &quot;&quot; _km}}
* the character {{c|~}} followed by class name, such as {{c|~MyClass}}
* the character {{c|~}} followed by {{rlp|decltype}} specifier, such as {{c|~decltype(str)}}
* a template identifier, such as {{c|MyTemplate&lt;int&gt;}}
* ''qualified identifiers'', such as {{lc|std::string}} or {{c|::tolower}}

===Names===
A ''name'' is the use of one of the following to refer to an entity or to a label:
* identifier
* operator in function notation ({{c|operator+}}, {{c|operator new}})
* user-defined literal operator ({{c|operator &quot;&quot; _km}})
* {{rlp|cast operator|user-defined conversion function}} ({{c|operator bool}})
* template id ({{tt|name&lt;arg, arg&gt;}})

Every name that denotes an entity is introduced into the program by a {{rlp|declarations|declaration}}. Every name that denotes a label is introduced into the program either by a {{rlp|goto}} statement or by a {{rlp|statements#Labels|labeled statement}}. A name used in more than one translation unit may refer to the same or different entities, depending on {{rlp|storage_duration#Linkage|linkage}}.

When the compiler encounters an unknown name in a program, it associates it with the declaration that introduced the name by means of {{rlp|lookup|name lookup}}, except for the {{rlp|dependent_name|dependent names}} in template declarations and definitions (for those names, the compiler determines whether they name a type, a template, or some other entity, which may require [[cpp/language/dependent_name|explicit disambiguation]])

===Qualified identifiers===
A ''qualified identifier'' is an identifier, operator function name, literal operator name, or a template identifier that is prepended by a scope resolution operator {{c|::}}, and optionally, a sequence of class or namespace names separated by scope resolution operators:

For example, the expression {{lc|std::string::npos}} is an id-expression that names the static member {{c|npos}} in the class {{c|string}} in namespace {{c|std}}. The expression {{c|::tolower}} names the function {{c|tolower}} in the global namespace. The expression {{c|::std::cout}} names the global variable {{c|cout}} in namespace {{c|std}}, which is a top-level namespace. The qualified identifier {{c|boost::signals2::connection}} names the type {{c|connection}} declared in namespace {{c|signals2}}, which is declared in namespace {{c|boost}}.

The keyword {{ltt|cpp/keyword/template|template}} may appear in qualified identifiers as necessary to disambiguate {{rlp|dependent_name|dependent template names}}.</text>
      <sha1>n8u116amdkf5lv65psdkntbeed3xrt7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/if</title>
    <ns>0</ns>
    <id>698</id>
    <revision>
      <id>71590</id>
      <parentid>71589</parentid>
      <timestamp>2014-06-14T04:33:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missing {</comment>
      <text xml:space="preserve" bytes="3723">{{title|if statement}}
{{cpp/language/statements/navbar}}
Conditionally executes code.

Used where code needs to be executed only if some condition is present.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|if (}} {{spar|condition}} {{ttb|)}} {{spar|statement_true}} }}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|if (}} {{spar|condition}} {{ttb|)}} {{spar|statement_true}} {{ttb|else}} {{spar|statement_false}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} }}
{{par | {{spar|condition}} | any {{rlp|expressions|expression}} which is {{rlp|implicit_cast|contextually convertible}} to bool or a {{rlp|declarations|declaration}} of a single non-array variable with a brace-or-equals {{rlp|initialization|initializer}}.}}
{{par | {{spar|statement_true}} | any {{rlp|statements|statement}} often a compound statement, which is executed if {{spar|condition}} evaluates to {{c|true}} }}
{{par | {{spar|statement_false}} | any {{rlp|statements|statement}} often a compound statement, which is executed if {{spar|condition}} evaluates to {{c|false}} }}
{{par end}}

===Explanation===

If the {{spar|condition}} yields {{c|true}}, {{spar|statement_true}} is executed.

If the else part of the if statement is present and {{spar|condition}} yields {{c|false}}, {{spar|statement_false}} is executed.

In the second form of if statement (the one including else), if {{spar|statement_true}} is  also an if statement then that inner if statement must contain an else part as well (in other words, in nested if-statements, the else is associated with the closest if that doesn't have an else)

===Notes===
If {{spar|statement_true}} or {{spar|statement_false}} is not a compound statement, it is treated as if it was:
{{source|if(x)
    int i;
// i is no longer in scope
}}
is the same as
{{source|if(x) {
    int i;
} // i is no longer in scope
}}

The scope of the name introduced by {{spar|condition}}, if it is a declaration, is the same as the scope of the body of the statements:

{{source|1=if (int x = f()) {
    int x; // error: redeclaration of x
}
else {
    int x; // error: redeclaration of x
}
}}

{{rev begin}}
{{rev|since=c++14|
If {{spar|statement_true}} is entered by {{rlp|goto}} or {{lc|longjmp}}, {{spar|statement_false}} is not executed.
}}
{{rev end}}

===Keywords===

{{ltt|cpp/keyword/if}},
{{ltt|cpp/keyword/else}}

===Example===
{{example
 | The following example demonstrates several usage cases of the {{tt|if}} statement
 | code=
#include &lt;iostream&gt;

int main()
{
    // simple if-statement with an else clause
    int i = 2;
    if (i &gt; 2) {
        std::cout &lt;&lt; i &lt;&lt; &quot; is greater than 2\n&quot;;
    } else {
        std::cout &lt;&lt; i &lt;&lt; &quot; is not greater than 2\n&quot;;
    }

    // nested if-statement
    int j = 1;
    if (i &gt; 1)
        if(j &gt; 2)
            std::cout &lt;&lt; i &lt;&lt; &quot; &gt; 1 and &quot; &lt;&lt; j &lt;&lt; &quot; &gt; 2\n&quot;;
        else // this else is part of if(j&gt;2), not part of if(i&gt;1) 
            std::cout &lt;&lt; i &lt;&lt; &quot; &gt; 1 and &quot; &lt;&lt; j &lt;&lt; &quot; &lt;= 2\n&quot;;

   // declarations can be used as conditions with dynamic_cast
   struct Base {
        virtual ~Base() {}
   };
   struct Derived : Base {
       void df() { std::cout &lt;&lt; &quot;df()\n&quot;; }
   };
   Base* bp1 = new Base;
   Base* bp2 = new Derived;

   if(Derived* p = dynamic_cast&lt;Derived*&gt;(bp1)) // cast fails, returns NULL
       p-&gt;df();  // not executed

   if(auto p = dynamic_cast&lt;Derived*&gt;(bp2)) // cast succeeds
       p-&gt;df();  // executed
}
 | output=
2 is not greater than 2
2 &gt; 1 and 1 &lt;= 2
df()
}}

[[de:cpp/language/if]]
[[es:cpp/language/if]]
[[fr:cpp/language/if]]
[[it:cpp/language/if]]
[[ja:cpp/language/if]]
[[pt:cpp/language/if]]
[[ru:cpp/language/if]]
[[zh:cpp/language/if]]</text>
      <sha1>p2p1bdu6r9sgyfasajcd55lnukpxkrw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/implicit cast</title>
    <ns>0</ns>
    <id>699</id>
    <revision>
      <id>72176</id>
      <parentid>72175</parentid>
      <timestamp>2014-07-20T11:28:12Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Pointer-to-member conversions */</comment>
      <text xml:space="preserve" bytes="17900">{{title|Implicit conversions}}
{{cpp/language/expressions/navbar}}

Implicit conversions are performed whenever an expression of some type {{tt|T1}} is used in context that does not accept that type, but accepts some other type {{tt|T2}}, in particular:
* When the expression is used as the argument when calling a function that is declared with {{tt|T2}} as parameter.
* When the expression is used as an operand with an operator that expects {{tt|T2}}
* When initializing a new object of type {{tt|T2}}, including {{tt|return}} statement in a function returning {{tt|T2}}.
* When the expression is used in a {{tt|switch}} statement ({{tt|T2}} is integral type)
* When the expression is used in an {{tt|if}} statement or a loop ({{tt|T2}} is {{c|bool}})
The program is well-formed (compiles) only if there exists one unambiguous ''implicit conversion sequence'' from {{tt|T1}} to {{tt|T2}}. 

If there are multiple overloads of the function or operator being called, after the implicit conversion sequence is built from T1 to each available T2, [[cpp/language/overload_resolution|overload resolution]] rules decide which overload is compiled.

===Order of the conversions===

Implicit conversion sequence consists of the following, in this order:
@1@ zero or one ''standard conversion sequence''
@2@ zero or one ''user-defined conversion''
@3@ zero or one ''standard conversion sequence''

When considering the argument to a constructor or to a user-defined conversion function, only one standard conversion sequence is allowed (otherwise user-defined conversions could be effectively chained). When converting from one built-in type to another built-in type, only one standard conversion sequence is allowed.

A standard conversion sequence consists of the following, in this order:
@1@ zero or one ''lvalue transformation''
@2@ zero or one ''numeric promotion'' or ''numeric conversion''
@3@ zero or one ''qualification adjustment''

A user-defined conversion consists of:
@*@ zero or one non-explicit single-argument constructor or non-explicit {{rlp|cast_operator|conversion function}} call

An expression {{tt|e}} is said to be ''implicitly convertible to {{tt|T2}}'' if and only if {{tt|T2}} can be [[cpp/language/copy_initialization|copy-initialized]] from {{tt|e}}, that is the declaration {{c|1=T2 t=e;}} is well-formed (can be compiled), for some invented temporary {{tt|t}}. Note that this is different from [[cpp/language/direct_initialization|direct initialization]] ({{c|1=T2 t(e)}}), where explicit constructors and conversion functions would additionally be considered.

{{rev begin}}
{{rev|since=c++11|
One exception in the above rule is the special implicit conversion invoked in the following five contexts, where type {{c|bool}} is expected:
:* controlling expression of {{tt|if}}, {{tt|while}}, {{tt|for}}
:* the logical operators {{tt|!}}, {{tt|&amp;&amp;}} and {{tt|{{!!}}}}
:* the conditional operator {{tt|?:}}
:* {{tt|static_assert}}
:* {{tt|noexcept}}
in such contexts, implicit conversion sequence is built if the declaration {{c|1=bool t(e);}} is well-formed. that is, the explicit user-defined conversion function such as {{tt|explicit T::operator bool() const;}} is considered. Such expression {{tt|e}} is said to be ''contextually convertible to bool''.
}}{{rev end}}

{{rev begin}}
{{rev|since=c++14|
In the following contexts, a context-specific type {{tt|T}} is expected, and the expression {{tt|e}} of class type {{tt|E}} is only allowed if {{tt|E}} has a single {{rlp|cast operator|user-defined conversion function}} whose return type is {{tt|cv T}} or a reference to {{tt|cv T}}.
* the array bound in a {{rlp|new|new-expression}} (T is {{lc|std::size_t}})
* the array bound in an {{rlp|array|array declaration}} (T is {{lc|std::size_t}})
* the argument of the {{rlp|delete|delete-expression}} (T is any object pointer type)
* integral constant expression, where a literal class is used (T is any integral or unscoped enumeration type and the selected user-defined conversion function is constexpr)
* the controlling expression of the {{rlp|switch}} statement (T is any integral or enumeration type)
Such expression {{tt|e}} is said to be ''contextually implicitly converted'' to the specified type {{tt|T}}. (Note: this requirement existed before C++14, but was not worded precisely and (in C++11) required that the conversion function was non-explicit)
}}{{rev end}}

===Lvalue transformations===

Lvalue transformations are applied when [[cpp/language/value_category|lvalue]] argument (e.g. reference to an object) is used in context where [[cpp/language/value_category|rvalue]] (e.g. a number) is expected. 

====Lvalue to rvalue conversion====

A glvalue of any non-function, non-array type {{tt|T}} can be implicitly converted to prvalue of the same type. If {{tt|T}} is a non-class type, this conversion also removes cv-qualifiers. Unless encountered in unevaluated context (in an operand of sizeof, typeid, noexcept, or decltype), this conversion effectively copy-constructs a temporary object of type {{tt|T}} using the original glvalue as the constructor argument, and that temporary object is returned as a prvalue. If the glvalue has the type {{lc|std::nullptr_t}}, the resulting prvalue is the null pointer constant {{c|nullptr}}.

====Array to pointer conversion====

A lvalue or rvalue of type &quot;array of {{tt|N}} {{tt|T}}&quot; or &quot;array of unknown bound of {{tt|T}}&quot; can be implicitly converted to a prvalue of type &quot;pointer to {{tt|T}}&quot;. The resulting pointer refers to the first element of the array.

====Function to pointer====

An lvalue of function type {{tt|T}} can be implicitly converted to a prvalue pointer to that function. This does not apply to non-static member functions because lvalues that refer to non-static member functions do not exist.

===Numeric promotions===

====Integral promotion====

Prvalues of small integral types (such as {{c|char}}) may be converted to prvalues of larger integral types (such as {{c|int}}). In particular, [[cpp/language/operator_arithmetic|arithmetic operators]] do not accept types smaller than {{c|int}} as arguments, and integral promotions are automatically applied after lvalue-to-rvalue conversion, if applicable. This conversion always preserves the value.

The following implicit conversions are classified as integral promotions:

:*{{ttb|signed char}} or {{ttb|signed short}} can be converted to {{c|int}}.

:*{{ttb|unsigned char}} or {{ttb|unsigned short}} can be converted to {{c|int}} if it can hold its entire value range, and {{c|unsigned int}} otherwise.

:*{{ttb|char}} can be converted to {{c|int}} or {{c|unsigned int}} depending on the underlying type: {{c|signed char}} or {{c|unsigned char}} (see above)

:*{{ttb|wchar_t}}, {{ttb|char16_t}}, and {{ttb|char32_t}} can be converted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, {{c|unsigned long long}}.

:* An {{rlp|enum|''unscoped enumeration''}} type whose underlying type is not fixed can be converted to the first type from the following list able to hold their entire value range: {{c|int}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, or {{c|unsigned long long}}. If the value range is greater, no integral promotions apply.
{{rev begin}}
{{rev|since=c++11|
:* An ''unscoped enumeration'' type whose underlying type is fixed can be converted to its promoted underlying type.
}}{{rev end}}
:* A {{rlp|bit field|''bit field type''}} can be converted to {{c|int}} if it can represent entire value range of the bit field, otherwise to {{c|unsigned int}} if it can represent entire value range of the bit field, otherwise no integral promotions apply.

:* The type {{c|bool}} can be converted to {{c|int}} with the value {{c|false}} becoming {{c|0}} and {{c|true}} becoming {{c|1}}.

====Floating point promotion====

A prvalue of type {{c|float}} can be converted to prvalue of type {{c|double}}. The value does not change.

===Numeric conversions===

Unlike the promotions, numeric conversions may change the values, with potential loss of precision.

====Integral conversions====

A prvalue of an integer type or of an unscoped enumeration type can be converted to any other integer type. If the conversion is listed under integral promotions, it is a promotion and not a conversion.

:* If the destination type is unsigned, the resulting value is the smallest unsigned value equal to the source value [[enwiki: Modular_arithmetic | modulo]] {{math|2{{su|p=n}}}} where {{math|n}} is the number of bits used to represent the destination type. 

:: That is, depending on whether the destination type is wider or narrower, signed integers are sign-extended&lt;ref group=&quot;footnote&quot;&gt;This only applies if the arithmetic is two's complement which is only required for the [[cpp/types/integer|exact-width integer types]]. Note, however, that at the moment all platforms with a C++ compiler use two's complement arithmetic&lt;/ref&gt; or truncated and unsigned integers are zero-extended or truncated respectively.

:* If the destination type is signed, the value does not change if the source integer can be represented in the destination type. Otherwise the result is implementation-defined.

:* If the source type is {{c|bool}}, the value {{c|false}} is converted to zero and the value {{c|true}} is converted to the value one of the destination type (note that if the destination type is {{c|int}}, this is an integer promotion, not an integer conversion)

:* If the destination type is {{c|bool}}, this is a boolean conversion (see below)

====Floating point conversions====

A prvalue of an floating-point type can be converted to prvalue of any other floating-point type. If the conversion is listed under floating-point promotions, it is a promotion and not a conversion.

:* If the source value can be represented exactly in the destination type, it does not change.

:* If the source value is between two representable values of the destination type, the result is one of those two values (it is implementation-defined which one)

:* Otherwise, the behavior is undefined.

====Floating - integral conversions====

:* A prvalue of floating-point type can be converted to prvalue of any integer type. The fractional part is truncated, that is, the fractional part is discarded. If the value can not fit into the destination type, the behavior is undefined. If the destination type is {{c|bool}}, this is a boolean conversion (see below).

:* A prvalue of integer or unscoped enumeration type can be converted to prvalue of any floating-point type. If the value can not be represented correctly, it is implementation defined whether the closest higher or the closest lower representable value will be selected. If the value can not fit into the destination type, the behavior is undefined. If the source type is {{c|bool}}, the value {{c|false}} is converted to zero, and the value {{c|true}} is converted to one.

====Pointer conversions====

:* A ''null pointer constant'' (see {{lc|NULL}}), can be converted to any pointer type, and the result is the null pointer value of that type. Such conversion (known as ''null pointer conversion'') is allowed to convert to a cv-qualified type as a single conversion, that is, it's not considered a combination of numeric and qualifying conversions.

:* A prvalue pointer to any (optionally cv-qualified) object type {{tt|T}} can be converted to a prvalue pointer to (identically cv-qualified) {{c|void}}. The resulting pointer represents the same byte in memory as the original pointer value. If the original pointer is a null pointer value, the result is a null pointer value of the destination type.

:* A prvalue pointer to a (optionally cv-qualified) derived class type can be converted to prvalue pointer to its accessible, unambiguous (identically cv-qualified) base class. The result of the conversion is a pointer to the base class subobject within the pointed-to object. The null pointer value is converted to the null pointer value of the destination type.

====Pointer-to-member conversions====

:* A ''null pointer constant'' (see {{lc|NULL}}) can be converted to any pointer-to-member type, and the result is the null member pointer value of that type. Such conversion (known as ''null member pointer conversion'') is allowed to convert to a cv-qualified type as a single conversion, that is, it's not considered a combination of numeric and qualifying conversions.

:* Prvalue pointer to member of some type {{tt|T}} in a base class {{tt|B}} can be converted to prvalue pointer to member of the same type {{tt|T}} in its derived class {{tt|D}}. If {{tt|B}} is inaccessible, ambiguous, or virtual base of {{tt|D}} or is a base of some intermediate virtual base of {{tt|D}}, the conversion is ill-formed (won't compile). The resulting pointer can be dereferenced with a {{tt|D}} object, and it will access the member within the {{tt|B}} base subobject of that {{tt|D}} object. The null pointer value is converted to the null pointer value of the destination type.

====Boolean conversions====

Prvalues of integral, floating-point, unscoped enumeration, pointer, and pointer-to-member types can be converted to prvalues of type {{c|bool}}.

The value zero (for integral, floating-point, and unscoped enumeration) and the null pointer and the null pointer-to-member values become {{c|false}}. All other values become {{c|true}}.
{{rev begin}}
{{rev|since=c++11|
Prvalue of type {{lc|std::nullptr_t}}, including {{c|nullptr}}, can be converted to prvalue of type {{c|bool}} {{rev inl|since=c++14|in context of {{rlp|direct initialization|direct-initialization}}}}. The resulting value is {{c|false}}.}}
{{rev end}}

===Qualification conversions===

:* A prvalue of type pointer to {{rlp|cv|cv-qualified}} type {{tt|T}} can be converted to prvalue pointer to a more cv-qualified same type {{tt|T}} (in other words, constness can be added)

:* A prvalue of type pointer to member of cv-qualified type {{tt|T}} in class {{tt|X}} can be converted to prvalue pointer to member of more cv-qualified type {{tt|T}} in class {{tt|X}}.

&quot;More&quot; cv-qualified means that
:* ''unqualified'' type can be converted to {{tt|const}}
:* ''unqualified'' type can be converted to {{tt|volatile}}
:* ''unqualified'' type can be converted to {{tt|const volatile}}
:* {{tt|const}} type can be converted to {{tt|const volatile}}
:* {{tt|volatile}} type can be converted to {{tt|const volatile}}

For multi-level pointers, the following restrictions apply:

A multilevel pointer {{tt|P1}} which is {{math|cv{{su|b=0|p=1}}}}-qualified pointer to {{math|cv{{su|b=1|p=1}}}}-qualified pointer to ... {{math|cv{{su|b=n-1|p=1}}}}-qualified pointer to {{math|cv{{su|b=n|p=1}}}}-qualified {{tt|T}} is convertible to a multilevel pointer {{tt|P2}} which is {{math|cv{{su|b=0|p=2}}}}-qualified pointer to {{math|cv{{su|b=1|p=2}}}}-qualified pointer to ... {{math|cv{{su|b=n-1|p=2}}}}-qualified pointer to {{math|cv{{su|b=n|p=2}}}}-qualified {{tt|T}} only if

:* The number of levels {{tt|n}} is the same for both pointers
:* If there is a {{c|const}} in the {{math|cv{{su|b=k|p=1}}}} qualification at some level (other than level zero) of P1, there is a {{c|const}} in the same level {{math|cv{{su|b=k|p=2}}}} of P2
:* If there is a {{c|volatile}} in the {{math|cv{{su|b=k|p=1}}}} qualification at some level (other than level zero) of P1, there is a {{c|volatile}} in the same {{math|cv{{su|b=k|p=2}}}}level of P2
:* If at some level {{tt|k}} the cv-qualifications are different between {{tt|P1}} and {{tt|P2}}, then there must be a const at every single level (other than level zero) of {{tt|P2}} up until k: {{math|cv{{su|b=1|p=2}}, cv{{su|b=2|p=2}} ... cv{{su|b=k|p=2}}}}.
:* Same rules apply to multi-level pointers to members and multi-level mixed pointers to objects and pointers to members.
:* Level zero is addressed by the rules for non-multilevel qualification conversions.

In particular, this forbids the conversion from {{tt|T**}} to {{tt|const T**}}, but conversion to {{tt|const T* const*}} is allowed.

===The safe bool problem===
Until the introduction of explicit conversion functions in C++11, designing a class that should be usable in boolean contexts (e.g. {{c|if(obj) { ... } }}) presented a problem: given a user-defined conversion function, such as {{c|T::operator bool() const;}}, the implicit conversion sequence allowed one additional standard conversion sequence after that function call, which means the resultant {{c|bool}} could be converted to {{c|int}}, allowing such code as {{c|obj &lt;&lt; 1;}} or {{c|1=int i = obj;}}.

One early solution for this can be seen in {{lc|std::basic_ios}}, which defines {{c|operator!}} and {{c|operator void*}}{{mark until c++11}}, so that the code such as {{c|if(std::cin) {...} }} compiles because {{c|void*}} is convertible to {{c|bool}}, but {{c|1=int n = std::cout;}} does not compile because {{c|void*}} is not convertible to {{c|int}}. This still allows nonsense code such as {{c|delete std::cout;}} to compile, and many pre-C++11 third party libraries were designed with a more elaborate solution, known as the [http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Safe_bool Safe Bool idiom].

===Footnotes===
&lt;references group=&quot;footnote&quot;/&gt;

===See also===
* [[cpp/language/const_cast|const_cast]]
* [[cpp/language/static_cast|static_cast]]
* [[cpp/language/dynamic_cast|dynamic_cast]]
* [[cpp/language/reinterpret_cast|reinterpret_cast]]
* [[cpp/language/explicit_cast|explicit cast]]
* [[cpp/language/cast_operator|user-defined conversion]]

[[de:cpp/language/implicit cast]]
[[es:cpp/language/implicit cast]]
[[fr:cpp/language/implicit cast]]
[[it:cpp/language/implicit cast]]
[[ja:cpp/language/implicit cast]]
[[pt:cpp/language/implicit cast]]
[[ru:cpp/language/implicit cast]]
[[zh:cpp/language/implicit cast]]</text>
      <sha1>ppjzpdcru4mibpwatie705yjl6uu318</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/incomplete type</title>
    <ns>0</ns>
    <id>13108</id>
    <redirect title="cpp/language/type" />
    <revision>
      <id>66711</id>
      <timestamp>2013-12-27T15:00:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>redirect to type#Incomplete type for now</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/language/type#Incomplete type]]</text>
      <sha1>544ylwz3ngc7qcw6l2f89c1d3k813wd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/initialization</title>
    <ns>0</ns>
    <id>9897</id>
    <revision>
      <id>67334</id>
      <parentid>66549</parentid>
      <timestamp>2014-02-05T15:22:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link storage duration</comment>
      <text xml:space="preserve" bytes="4325">{{title|Initialization}}
{{cpp/language/initialization/navbar}}
''Initialization'' of a variable provides its initial value at the time of construction. 

The initial value may be provided in the initializer section of a {{rlp|declarations|declarator}}. It also takes place during function calls: function parameters and the function return values are also initialized.

For each declarator, the initializer may be one of the following:

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|(}} {{spar|expression-list}} {{ttb|)}}
}}
{{sdsc|num=2|1=
{{ttb|{{=}}}} {{spar|expression}}
}}
{{sdsc|num=3|1=
{{ttb|{ }} {{spar|initializer-list}} {{ttb|} }}
}}
{{sdsc end}}

@1@ comma-separated list of arbitrary expressions in parentheses
@2@ the equals sign followed by an expression
@3@ braced-init-list: possibly empty, comma-separated list of expressions and other braced-init-lists

Depending on context, initializer may invoke one of the following:
* {{rlp|value_initialization|Value initialization}}, e.g. {{c|std::string s{};}}
* {{rlp|direct_initialization|Direct initialization}}, e.g. {{c|std::string s(&quot;hello&quot;);}}
* {{rlp|copy_initialization|Copy initialization}}, e.g. {{c|std::string s {{=}} &quot;hello&quot;;}}
* {{rlp|list_initialization|List initialization}}, e.g. {{c|std::string s{'a', 'b', 'c'};}}
* {{rlp|aggregate_initialization|Aggregate initialization}}, e.g. {{c|char a[3] {{=}} {'a', 'b'};}}
* {{rlp|reference_initialization|Reference initialization}}, e.g. {{c|char&amp; c {{=}} a[0];}}

If no initializer is provided, the rules of {{rlp|default_initialization|default initialization}} apply.

===Non-local variables===
All variables with static {{rlp|storage duration}} are initialized as part of program startup, before the execution of the {{rlp|main function}} begins. All variables with thread-local storage duration are initialized as part of thread launch, before the execution of the thread function begins. For both of these classes of variables, initialization occurs in stages:
@1@ Static initialization of non-local variables happens first, and consists of two steps
:@a@ {{rlp|zero_initialization|Zero initialization}} takes place before anything else (in practice, variables that are going to be zero-initialized, are typically placed in the {{tt|.bss}} segment, which is zeroed out by the OS when loading the program)
:@b@ {{rlp|constant_initialization|Constant initialization}} takes place where applicable. (in practice, this stage is usually performed at compile time, and pre-calculated values are stored as part of the program image. If the compiler doesn't do that, it still has to guarantee that this takes place before any dynamic initialization)
@2@ Dynamic initialization of non-local variables, which takes place after all static initialization is completed, can be one of:
:@b@ Unordered dynamic initialization, which applies only to (static/thread-local) class template data members that aren't explicitly specialized. Initialization of such static variables is undeterminately sequenced with respect to all other dynamic initialization. Initialization of such thread-local variables is unsequenced with respect to all other dynamic initialization.
:@a@ Ordered dynamic initialization, which applies to all other non-local variables: within a single translation unit, these variables are initialized in exact order their definitions appear in the source code. Initialization of static variables in different translation units is indeterminately sequenced. Initialization of thread-local variables in different translation units is unsequenced.

The compilers are allowed to initialize dynamically-initialized variables as part of static initialization (essentially, at compile time), if both of these are true:
@1@ the dynamic version of the initialization does not change the value of any other object of namespace scope prior to its initialization
@2@ the static version of the initialization produces the same value in the initialized variable as would be produced by the dynamic initialization if all variables not required to be initialized statically were initialized dynamically.
{{todo|when ambiguous, examples}}

===Class members===
Non-static data members can be initialized with {{rlp|initializer_list|member initializer list}} or with a in-class {{rlp|data_members|brace-or-equal initializer}}.</text>
      <sha1>oa6cifoke43oci40ysxkcz1zhb48enh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/initializer list</title>
    <ns>0</ns>
    <id>5432</id>
    <revision>
      <id>68187</id>
      <parentid>67470</parentid>
      <timestamp>2014-03-17T13:21:23Z</timestamp>
      <contributor>
        <ip>91.89.152.83</ip>
      </contributor>
      <comment>improved formatting</comment>
      <text xml:space="preserve" bytes="7139">{{title|Member initializer list}}
{{cpp/language/classes/navbar}}

In the definition of a constructor of a class, specifies initializers for direct and virtual base subobjects and non-static data members.
( Not to be confused with [[cpp/utility/initializer_list|std::initializer_list]] )

==Syntax==
Appears as part of {{rlp|function|function definition}} syntax, for class {{rlp|constructor}}s only, as the first part of the function body (before the opening brace of the compound statement)

The first character is the colon {{ttb|:}}, followed by the comma-separated list of one or more {{spar|member-initializers}}, each of which has the following syntax
{{sdsc begin}}
{{sdsc|num=1| {{spar|class-or-identifier}} {{ttb|(}} {{spar|expression-list}}{{mark optional}} {{ttb|)}} }}
{{sdsc|num=2|notes={{mark since c++11}}| {{spar|class-or-identifier}} {{spar|brace-init-list}} }}
{{sdsc|num=3|notes={{mark since c++11}}| {{spar|parameter-pack}} {{ttb|...}} }}
{{sdsc end}}

@1@ Initializes the base or member named by {{spar|class-or-identifier}} using {{rlp|direct_initialization|direct initialization}} or, if {{spar|expression-list}} is empty, {{rlp|value_initialization|value-initialization}}
@2@ Initializes the base or member named by {{spar|class-or-identifier}} using {{rlp|list_initialization|list-initialization}} (which becomes {{rlp|value_initialization|value-initialization}} if the list is empty and {{rlp|aggregate_initialization|aggregate-initialization}} when initializing an aggregate)
@3@ Initializes multiple bases using a {{rlp|parameter_pack|pack expansion}}

{{par begin}}
{{par | {{spar|class-or-identifier}} | any identifier, class name, or {{c|decltype}} expression that names a non-static data member, a direct or virtual base, or (for delegating constructors) the class itself }}
{{par | {{spar|expression-list}} | possibly empty, comma-separated list of the parameters to pass to the constructor of the base or member }}
{{par | {{spar|brace-init-list}} | brace-enclosed list of comma-separated initializers and nested braced-init-lists }}
{{par | {{spar|parameter-pack}} | name of a variadic template parameter pack }}
{{par end}}

==Explanation==
Before the compound statement that forms the function body of the constructor begins executing, initialization of all direct bases, virtual bases, and non-static data members is finished. Member initializer list is the place where non-default initialization of these objects can be specified. For members that cannot be default-initialized, such as members of reference and const-qualified types, member initializers must be specified.

The initializers where {{spar|class-or-identifier}} names a {{rlp|derived_class|virtual base class}} are ignored  during execution of constructors of any class that is not the most derived class of the object that's being constructed.

Names that appear in {{spar|expression-list}} or {{spar|brace-init-list}} are evaluated in scope of the constructor:
{{source|class X {
    int a, b, i, j;
public:
    const int&amp; r;
    X(int i)
      : r(a) // initializes X::r to refer to X::a
      , b(i) // initializes X::b to the value of the parameter i
      , i(i) // initializes X::i to the value of the parameter i
      , j(this-&gt;i) // initializes X::j to the value of X::i
    { }
};
}}

Member functions (including virtual member functions) can be called from member initializers, but the behavior is undefined if not all direct bases are initialized at that point.

For virtual calls (if the bases are initialized), the same rules apply as the rules for the virtual calls from constructors and destructors: virtual member functions behave as if the dynamic type of {{c|*this}} is the class that's being constructed (dynamic dispatch does not propagate down the inheritance hierarchy) and virtual calls (but not static calls) to {{rlp|abstract class|pure virtual}} member functions are undefined behavior.

{{rev begin}}
{{rev | since=c++11 |
If a non-static data member has an {{rlp|data_members#Member initialization|in-class brace-or-equal initializer}} and also appears in a member initializer list, then member initializer list is executed and brace-or-equal initializer is ignored:
{{source|1=struct S {
    int n = 42;
    S() : n(7) {} // will set n to 7, not 42
};}}
}}
{{rev end}}

{{rev begin}}
{{rev | since=c++11 |
==Delegating constructor==
If the name of the class itself appears as {{spar|class-or-identifier}} in the member initializer list, then the list must consist of that one member initializer only; such constructor is known as the ''delegating constructor'', and the constructor selected by the only member of the initializer list is the ''target constructor''

In this case, the target constructor is selected by overload resolution and executed first, then the control returns to the delegating constructor and its body is executed.

Delegating constructors cannot be recursive.}}
{{rev end}}

==Initialization order==
The order of member initializers in the list is irrelevant: the actual order of initialization is as follows:

@1@ If the constructor is for the most-derived class, virtual base classes are initialized in the order in which they appear in depth-first left-to-right traversal of the base class declarations (left-to-right refers to the appearance in base-specifier lists)
@2@ Then, direct base classes are initialized in left-to-right order as they appear in this class's base-specifier list
@3@ Then, non-static data members are initialized in order of declaration in the class definition.
@4@ Finally, the body of the constructor is executed

(Note: if initialization order was controlled by the appearance in the member initializer lists of different constructors, then the destructor wouldn't be able to ensure that the order of destruction is the reverse of the order of construction)

==Example==
{{source|code=
struct Class : public Base
{
    int x;
    int y;

    Class ( int x )
      : Base ( 123 ), // initialize base class
        x ( x ),      // x (member) is initialized with x (parameter)
        y ( 0 )       // y initialized to 0
    {}                // empty constructor body

    Class ( double a )
      : y ( a+1 ),
        x ( y ) // x will be initialized before y, this means that its value here is undefined
    {}          // No base class constructor in list, this is the same as calling Base()

    Class()
    try
      : Base ( 789 ),
        x ( 0 ),
        y ( 0 )
    {
        // no exception
    }
    catch (...)
    {
        // exception occurred on initialization
    }
};
}}

===References===
{{ref std c++11}}
{{ref std | section=12.6.2 | title=Initializing bases and members | id=class.base.init}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=12.6.2 | title=Initializing bases and members | id=class.base.init}}
{{ref std end}}

[[de:cpp/language/initializer list]]
[[es:cpp/language/initializer list]]
[[fr:cpp/language/initializer list]]
[[it:cpp/language/initializer list]]
[[ja:cpp/language/initializer list]]
[[pt:cpp/language/initializer list]]
[[ru:cpp/language/initializer list]]
[[zh:cpp/language/initializer list]]</text>
      <sha1>qfktowj985a9euk60s1y5beg3iz3vlz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/inline</title>
    <ns>0</ns>
    <id>3085</id>
    <revision>
      <id>69686</id>
      <parentid>69219</parentid>
      <timestamp>2014-04-19T17:40:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention default arguments rule</comment>
      <text xml:space="preserve" bytes="3872">{{title|inline specifier}}
{{cpp/language/functions/navbar}}

Declares an inline function.
===Syntax===
{{sdsc begin}}
{{sdsc  | num=1 | {{c|inline}} {{spar|function_declaration}} }}
{{sdsc  | num=2 | {{spar|class}} {{ttb|{}} {{spar|function_definition}} {{ttb|};}} }}
{{sdsc  | num=3 | {{c|constexpr}} {{spar|function_declaration}} | notes={{mark since c++11}}}}
{{sdsc end}}

@1@ A function at global scope can be declared inline using the keyword {{c|inline}}
@2@ A function defined entirely inside a class/struct/union definition, whether it's a member function or a non-member {{c|friend}} function, is always inline.
@3@ A function declared {{c|constexpr}} is always inline.

===Description===
An ''inline function'' is a function with the following properties:

@1@ There may be more than one definition of an inline function in the program. For example, an inline function may be defined in a header file that is #include'd in multiple source files.
@2@ The definition of an inline function must be present in the translation unit where it is called (not necessarily before the point of call).
@3@ An inline function with [[cpp/language/storage_duration|external linkage]] (e.g. not declared {{c|static}}) has the following additional properties:
:@1@ It must be declared {{c|inline}} in every translation unit.
:@2@ It has the same address in every translation unit.
:@3@ Function-local static objects in all function definitions are shared across all translation units (they all refer to the same object defined in one translation unit)
:@4@ String literals in all function definitions are shared (they are all the same string literal defined in just one translation unit)
:@5@ Types defined in all function definitions are also the same in all translation units.

The intent of the inline keyword is to serve as an indicator to the optimizer that inline substitution of the function is preferred over function call, that is, instead of executing the call CPU instruction to transfer control to the function body, a copy of the function body is executed without generating the call. This avoids extra overhead created by the function call (copying the arguments and retrieving the result) but it may result in a larger executable as the code for the function has to be repeated multiple times.

Since this meaning of the keyword {{c|inline}} is non-binding, compilers are free to use inline substitution for any function that's not marked inline, and are free to generate function calls to any function marked inline. Those choices do not change the rules regarding multiple definitions and shared statics listed above.

====Notes====
If an inline function is defined differently in different translation units, the behavior is undefined.

The inline specifier cannot be used with a function declaration at block scope (inside another function)

The inline specifier cannot re-declare a function that was already defined in the translation unit as non-inline.

The implicitly-generated member functions and any member function declared as deleted are inline just like any other function defined inside a class definition.

If an inline function is declared in different translation units, the accumulated sets of {{rlp|default arguments}} must be the same at the end of each translation unit.
===Example===
{{example
|code=
// header file
#ifndef EXAMPLE_H
#define EXAMPLE_H
// function included in multiple source files must be inline
inline int sum(int a, int b) 
{
    return a + b;
}
#endif

// source file #2
#include &quot;example.h&quot;
int a()
{
    return sum(1, 2);
}

// source file #1
#include &quot;example.h&quot;
int b()
{
    return sum(3, 4);
}
}}

[[de:cpp/language/inline]]
[[es:cpp/language/inline]]
[[fr:cpp/language/inline]]
[[it:cpp/language/inline]]
[[ja:cpp/language/inline]]
[[pt:cpp/language/inline]]
[[ru:cpp/language/inline]]
[[zh:cpp/language/inline]]</text>
      <sha1>ggx9iwgrhns22fctev9rj23xq8x2txp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/integer literal</title>
    <ns>0</ns>
    <id>5082</id>
    <revision>
      <id>67075</id>
      <parentid>66836</parentid>
      <timestamp>2014-01-21T13:42:34Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+N3781&quot;Single-Quotation-Mark as a Digit Separator&quot; accepted in N3797</comment>
      <text xml:space="preserve" bytes="6556">{{title|integer literal}}
{{cpp/language/expressions/navbar}}
Allows values of integer type to be used in expressions directly.
===Syntax===
An integer literal is a {{rlp|expressions#Primary_expressions|primary expression}} of the form
{{sdsc begin}}
{{sdsc | num = 1 | {{spar|decimal-literal}} {{spar|integer-suffix}}{{mark optional}} }}
{{sdsc | num = 2 | {{spar|octal-literal}} {{spar|integer-suffix}}{{mark optional}} }}
{{sdsc | num = 3 | {{spar|hex-literal}} {{spar|integer-suffix}}{{mark optional}} }}
{{sdsc | num = 4 | notes={{mark since c++14}} | {{spar|binary-literal}} {{spar|integer-suffix}}{{mark optional}} }}
{{sdsc end}}
where
* {{spar|decimal-literal}} is a non-zero decimal digit ({{tt|1}}, {{tt|2}}, {{tt|3}}, {{tt|4}}, {{tt|5}}, {{tt|6}}, {{tt|7}}, {{tt|8}}, {{tt|9}}), followed by zero or more decimal digits ({{tt|0}}, {{tt|1}}, {{tt|2}}, {{tt|3}}, {{tt|4}}, {{tt|5}}, {{tt|6}}, {{tt|7}}, {{tt|8}}, {{tt|9}})
* {{spar|octal-literal}} is the digit zero ({{tt|0}}) followed by zero or more octal digits ({{tt|0}}, {{tt|1}}, {{tt|2}}, {{tt|3}}, {{tt|4}}, {{tt|5}}, {{tt|6}}, {{tt|7}})
* {{spar|hex-literal}} is the character sequence {{tt|0x}} or the character sequence {{tt|0X}} followed by one or more hexadecimal digits ({{tt|0}}, {{tt|1}}, {{tt|2}}, {{tt|3}}, {{tt|4}}, {{tt|5}}, {{tt|6}}, {{tt|7}}, {{tt|8}}, {{tt|9}}, {{tt|a}}, {{tt|A}}, {{tt|b}}, {{tt|B}}, {{tt|c}}, {{tt|C}}, {{tt|d}}, {{tt|D}}, {{tt|e}}, {{tt|E}}, {{tt|f}}, {{tt|F}})
* {{spar|binary-literal}} is the character sequence {{tt|0b}} or the character sequence {{tt|0B}} followed by one or more binary digits ({{tt|0}}, {{tt|1}})
* {{spar|integer-suffix}}, if provided, may contain one or both of the following (if both are provided, they may appear in any order:
:* {{spar|unsigned-suffix}} (the character {{tt|u}} or the character {{tt|U}})
:* either the {{spar|long-suffix}} (the character {{tt|l}} or the character {{tt|L}}) or the {{spar|long-long-suffix}} (the character sequence {{tt|ll}} or the character {{tt|LL}})
{{rev begin}}
{{rev | since = c++14 |Optional single quotes({{tt|'}}) may be inserted between the digits as a separator, they are ignored by the compiler.}}
{{rev end}}
===Explanation===
@1@ Decimal integer literal (base 10, the first digit is the most significant)
@2@ Octal integer literal (base 8, the first digit is the most significant)
@3@ Hexadecimal integer literal (base 16, the first digit is the most significant, the letters 'a' through 'f' represent values (decimal) 10 through 15)
@4@ Binary integer literal (base 2, the first digit is the most significant)

The following variables are initialized to the same value:
{{source|1=
int d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010;
}}

The following variables are also initialized to the same value:
{{source|1=
unsigned long long l1 = 18446744073709550592ull;
unsigned long long l2 = 18'446'744'073'709'550'592llu;
unsigned long long l3 = 1844'6744'0737'0955'0592uLL;
unsigned long long l4 = 184467'440737'0'95505'92LLU;
}}

===The type of the literal===
The type of the integer literal is the first type in which the value can fit, from the list of types which depends on which numeric base and which {{spar|integer-suffix}} was used.

{| class=&quot;wikitable&quot;
|- style=&quot;text-align:center&quot;
! colspan=&quot;3&quot; | Types allowed for integer literals
|- style=&quot;text-align:center&quot;
| suffix
| decimal bases
| hexadecimal or octal bases
|- style=&quot;text-align:left&quot;
| no suffix
| {{c|
int
long int
long long int}}
| {{c|
int
unsigned int
long int
unsigned long int
long long int
unsigned long long int}}
|-
| {{tt|u}} or {{tt|U}}
| {{c|
unsigned int
unsigned long int
unsigned long long int}}
| {{c|
unsigned int
unsigned long int
unsigned long long int}}
|-
| {{tt|l}} or {{tt|L}}
| {{c|
long int (until C++11)
unsigned long int (until C++11)
long int (since C++11)
long long int (since C++11)}}
| {{c|
long int
unsigned long int
long long int
unsigned long long int}}
|-
| both {{tt|l}}/{{tt|L}} and {{tt|u}}/{{tt|U}}
| {{c|
unsigned long int
unsigned long long int}}
| {{c|
unsigned long int
unsigned long long int}}
|-
| {{tt|ll}} or {{tt|LL}}
| {{c|long long int}}
| {{c|
unsigned long int
unsigned long long int}}
|-
| both {{tt|ll}}/{{tt|LL}} and {{tt|u}}/{{tt|U}}
| {{c|unsigned long long int}}
| {{c|unsigned long long int}}
|}

If the value of the integer literal is too big to fit in any of the types allowed by suffix/base combination and the compiler supports extended integer types (such as {{c|__int128}}) the literal may be given the extended integer type -- otherwise the program is ill-formed.

===Notes===
Letters in the integer literals are case-insensitive: {{tt|0xDeAdBaBeU}} and {{tt|0XdeadBABEu}} represent the same number (one exception is the {{spar|long-long-suffix}}, which is either {{tt|ll}} or {{tt|LL}}, never {{tt|lL}} or {{tt|Ll}})

There are no negative integer literals. Expressions such as {{c|-1}} apply the {{rlp|operator_arithmetic|unary minus operator}} to the value represented by the literal, which may involve implicit type conversions.

In C prior to C99 (but not in C++), unsuffixed decimal values that do not fit in {{c|long int}} are allowed to have the type {{c|unsigned long int}}.

===Example===
{{example|code=
#include &lt;iostream&gt;

int main()
{
std::cout &lt;&lt; 123    &lt;&lt; '\n'
          &lt;&lt; 0123   &lt;&lt; '\n'
          &lt;&lt; 0x123  &lt;&lt; '\n'
          &lt;&lt; 0b10   &lt;&lt; '\n'
          &lt;&lt; 12345678901234567890ull &lt;&lt; '\n'
          &lt;&lt; 12345678901234567890u   &lt;&lt; '\n'; // the type is unsigned long long even
                                              // without a long long suffix

//   std::cout &lt;&lt; -9223372036854775808 &lt;&lt; '\n'; // error: the value
                // 9223372036854775808 cannot fit in signed long long, which is the
                // biggest type allowed for unsuffixed decimal integer literal
     std::cout &lt;&lt; -9223372036854775808u &lt;&lt; '\n'; // unary minus applied to unsigned
                // value subtracts it from 2^64, this gives 9223372036854775808
     std::cout &lt;&lt; -9223372036854775807 - 1 &lt;&lt; '\n'; // correct way to calculate
                                                    // the value -9223372036854775808
}
|output=
123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808
}}

[[de:cpp/language/integer literal]]
[[es:cpp/language/integer literal]]
[[fr:cpp/language/integer literal]]
[[it:cpp/language/integer literal]]
[[ja:cpp/language/integer literal]]
[[pt:cpp/language/integer literal]]
[[ru:cpp/language/integer literal]]
[[zh:cpp/language/integer literal]]</text>
      <sha1>jcmh95u5trlj5xblrabndyeoyu7p7rh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/lambda</title>
    <ns>0</ns>
    <id>5059</id>
    <revision>
      <id>71861</id>
      <parentid>70976</parentid>
      <timestamp>2014-06-29T10:45:59Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>escape one '=', fix a link</comment>
      <text xml:space="preserve" bytes="20056">{{title|Lambda functions {{mark since c++11}}}}
{{cpp/language/functions/navbar}}

Constructs a [[enwiki:Closure (computer science)|closure]]: an unnamed function object capable of capturing variables in scope.

===Syntax===
{{sdsc begin}}
{{sdsc | num=1 |
{{ttb|[}} {{spar|capture-list}} {{ttb|]}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{ttb|mutable}}{{mark optional}} {{spar|exception}} {{spar|attribute}} {{ttb|-&gt;}} {{spar|ret}} {{ttb|{}} {{spar|body}} {{ttb|&lt;nowiki&gt;}&lt;/nowiki&gt;}}
}}
{{sdsc | num=2 |
{{ttb|[}} {{spar|capture-list}} {{ttb|]}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{ttb|-&gt;}} {{spar|ret}} {{ttb|{}} {{spar|body}} {{ttb|&lt;nowiki&gt;}&lt;/nowiki&gt;}}
}}
{{sdsc | num=3 |
{{ttb|[}} {{spar|capture-list}} {{ttb|]}} {{ttb|(}} {{spar|params}} {{ttb|)}} {{ttb|{}} {{spar|body}} {{ttb|&lt;nowiki&gt;}&lt;/nowiki&gt;}}
}}
{{sdsc | num=4 |
{{ttb|[}} {{spar|capture-list}} {{ttb|]}} {{ttb|{}} {{spar|body}} {{ttb|&lt;nowiki&gt;}&lt;/nowiki&gt;}}
}}
{{sdsc end}}

1) Full declaration

2) Declaration of a const lambda: the objects captured by copy cannot be modified.

3) Omitted trailing-return-type: the return type of the closure's {{tt|operator()}} is deduced according to the following rules:
{{rev begin}}
{{rev|until=c++14|
* if the {{spar|body}} consists of the single {{c|return}} statement, the return type is the type of the returned expression (after rvalue-to-lvalue, array-to-pointer, or function-to-pointer implicit conversion)

* otherwise, the return type is {{c|void}}
}}{{rev|since=c++14|
The return type is {{rlp|template argument deduction|deduced}} from {{ltt|cpp/language/return}} statements as if for a function whose {{rlp|function#Return_type_deduction|return type is declared auto}}.
}}
{{rev end}}

4) Omitted parameter list: function takes no arguments, as if the parameter list was {{ttb|()}}

===Explanation===

{{par begin}}
{{par | mutable | allows {{spar|body}} to modify the parameters captured by copy, and to call their non-const member functions}}
{{par | {{spar|exception}} | provides the [[cpp/language/except_spec|exception specification]] or the [[cpp/language/noexcept_spec|noexcept clause]] for operator() of the closure type}}
{{par | {{spar|attribute}} | provides the [[cpp/language/attributes|attribute specification]] for operator() of the closure type}}
{{par | {{spar|capture-list}} | specifies which symbols visible in the scope where the function is declared will be visible inside the function body.
A list of symbols can be passed as follows: 
*{{ttb|[a,&amp;b]}} where ''a'' is captured by value and ''b'' is captured by reference.
*{{ttb|[this]}} captures the [[cpp/language/this|{{ttb|this}} pointer]] by value
*{{ttb|[&amp;]}} captures all [[cpp/language/storage_duration|automatic]] variables mentioned in the body of the lambda by reference
*{{ttb|[{{=}}]}} captures all [[cpp/language/storage_duration|automatic]] variables mentioned in the body of the lambda by value
*{{ttb|[]}} captures nothing }}
{{par | {{spar|params}} | The list of parameters, as in [[cpp/language/function|named functions]]. {{rev inl|since=c++14|if {{tt|auto}} is used as a type of a parameter, the lambda is a ''generic lambda''}}}}
{{par | {{spar|ret}} | Return type. If not present it's implied by the function return statements ( or void if it doesn't return any value)}}
{{par | {{spar|body}} | Function body}}
{{par end}}

The lambda expression constructs an unnamed prvalue temporary object of unique unnamed non-union non-aggregate type, known as ''closure type'', which is declared (for the purposes of {{rlp|adl|ADL}}) in the smallest block scope, class scope, or namespace scope that contains the lambda expression. The closure type has the following members:

{{member | {{small|ClosureType::}}operator()(params) | 2=
{{dcl begin}}
{{dcl | notes={{mark|the keyword mutable was not used}} | 1=
ret operator()(params) const { body }
}}
{{dcl | notes={{mark|the keyword mutable was used}} | 1=
ret operator()(params) { body }
}}
{{dcl | since=c++14 | notes={{mark|generic lambda}} | 1=
template&lt;template-params&gt;
ret operator()(params) { body }
}}
{{dcl end}}
Executes the body of the lambda-expression, when invoked. When accessing a variable, accesses its captured copy (for the entities captured by copy), or the original object (for the entities captured by reference). Unless the keyword {{c|mutable}} was used in the lambda-expression, the function-call operator is const-qualified and the objects that were captured by copy are non-modifiable from inside this {{c|operator()}}. The function-call operator is never volatile-qualified and not virtual.
{{rev begin}}
{{rev |since=c++14|
For every parameter in {{spar|params}} whose type is specified as {{tt|auto}}, an invented template parameter is added to {{spar|template-params}}, in order of appearance. The invented template parameter may be a {{rlp|parameter pack}} if the corresponding function member of {{spar|params}} is a function parameter pack.
{{source|1=
// generic lambda, operator() is a template with two parameters
auto glambda = [](auto a, auto&amp;&amp; b) { return a &lt; b; };
bool b = glambda(3, 3.14); // OK
// generic lambda, operator() is a template with one parameter
auto vglambda = [](auto printer) {
    return [=](auto&amp;&amp;... ts) { // generic lambda, ts is a parameter pack
        printer(std::forward&lt;decltype(ts)&gt;(ts)...);
        return [=]() { printer(ts...); }; // capture-less lambda
    };
};
auto p = vglambda( [](auto v1, auto v2, auto v3) {
                          std::cout &lt;&lt; v1 &lt;&lt; v2 &lt;&lt; v3;
                      } );
auto q = p(1, ’a’, 3.14); // outputs 1a3.14
q();                      // outputs 1a3.14
}}
}}
{{rev end}}
the exception specification {{spar|exception}} on the lambda-expression applies to the function-call operator or operator template.

For the purpose of {{rlp|lookup|name lookup}}, determining the type and value of the {{rlp|this|this pointer}} and for accessing non-static class members, the body of the closure type's function call operator is considered in the context of the lambda-expression.

{{source|1=
struct X {
   int x, y;
   int operator()(int);
   void f() {
     // the context of the following lambda is the member function X::f
     [=]()-&gt;int {
         return operator()(this-&gt;x + y); // X::operator()(this-&gt;x + (*this).y)
                                         // this has type x*
         };
    }
};
}}

===Dangling references===
If an entity is captured by reference, implicitly or explicitly, and the function call operator of the closure object is invoked after the entity's lifetime has ended, undefined behavior occurs. The C++ closures do not extend the lifetimes of the captured references.
}}

{{member | {{small|ClosureType::}}operator ret(*)(params)() | 2=

{{dcl begin}}
{{dcl | notes={{mark|capture-less non-generic lambda}}| 1=
typedef ret(*F)(params);
operator F() const; 
}}
{{dcl | since=c++14|notes={{mark|capture-less generic lambda}}| 1=
template&lt;template-params&gt; using fptr_t = /*see below*/;
template&lt;template-params&gt;
operator fptr_t&lt;template-params&gt;() const; 
}}
{{dcl end}}

This {{rlp|cast operator|user-defined conversion function}} is only defined if the capture list of the lambda-expression is empty. 
{{rev begin}}
{{rev|since=c++14|
A generic captureless lambda has user-defined conversion function template with the same invented template parameter list as the function-call operator template. If the return type is empty or auto, it is obtained by return type deduction on the function template specialization, which, in turn, is obtained by {{rlp|template argument deduction}} for conversion function templates.
{{source|1=
void f1(int (*)(int)) { }
void f2(char (*)(int)) { }
void h(int (*)(int)) { } // #1
void h(char (*)(int)) { } // #2
auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // error: not convertible
h(glambda); // OK: calls #1 since #2 is not convertible

int&amp; (*fpi)(int*) = [](auto* a) -&gt; auto&amp; { return *a; }; // OK
}}
}}
{{rev end}}

The value returned by this conversion function is a pointer to a function with C++ {{rlp|language linkage}} that, when invoked, has the same effect as invoking the closure object's function call operator directly.
}}

{{member | {{small|ClosureType::}}ClosureType() | 2=
{{dcl begin}}
{{dcl | 1=
ClosureType() = delete;
}}
{{dcl | 1=
ClosureType(const ClosureType&amp; ) = default;
}}
{{dcl | 1=
ClosureType(ClosureType&amp;&amp; ) = default;
}}
{{dcl end}}
Closure types are not {{concept|DefaultConstructible}}. The copy constructor and the move constructor are implicitly-declared and may be implicitly-defined according to the usual rules for implicit [[cpp/language/copy_constructor|copy constructors]] and [[cpp/language/move_constructor|move constructors]].
}}

{{member | {{small|ClosureType::}}operator{{=}}(const ClosureType&amp;) | 2=
{{ddcl |1=
ClosureType&amp; operator=(const ClosureType&amp;) = delete;
}}
Closure types are not {{concept|CopyAssignable}}.
}}

{{member | {{small|ClosureType::}}~ClosureType() | 2=
{{ddcl |1=
~ClosureType() = default;
}}
The destructor is implicitly-declared.
}}

{{member | {{small|ClosureType::}}CapturedParam | 2=
{{ddcl |1=
T1 a;
T2 b;
...
}}
If the lambda-expression captures anything by copy (either implicitly with capture clause {{ttb|[{{=}}]}} or explicitly with a capture that does not include the character &amp;, e.g. {{ttb|[a, b, c]}}), the closure type includes unnamed non-static data members, declared in unspecified order, that hold copies of all entities that were so captured.

Those data members that correspond to captures without initializers are {{rlp|direct initialization|direct-initialized}} when the lambda-expression is evaluated. Those that correspond to captures with initializers are initialized as the initializer requires (could be copy- or direct-initialization). If an array is captured, array elements are direct-initialized in increasing index order. The order in which the data memebrs are initialized is the order in which they are declared (which is unspecified).

The type of each data member is the type of the corresponding captured entity, except if the entity has reference type (in that case, references to functions are captured as-is, and references to objects are captured as copies of the referenced objects).

For the entities that are captured by reference (with the default capture {{ttb|[&amp;]}} or when using the character &amp;, e.g. {{ttb|[&amp;a, &amp;b, &amp;c]}}), it is unspecified if additional data members are declared in the closure type.
}}

Lambda-expressions are not allowed in {{rlp|expressions#Unevaluated_expressions|unevaluated expressions}}, {{rlp|template parameters|template arguments}}, {{rlp|type alias|alias declarations}}, {{rlp|typedef|typedef declarations}}, and anywhere in a function (or function template) declaration except the function body and the function's {{rlp|default arguments}}.

===Lambda capture===
The {{spar|capture-list}} is a comma-separated list of zero or more ''captures'', optionally beginning with the {{spar|capture-default}}. The only capture defaults are {{ttb|&amp;}} (implicitly catch the odr-used automatic variables and {{tt|this}} by reference) and {{ttb| {{=}} }} (implicitly catch the odr-used automatic variables and {{tt|this}} by value).

The syntax of an individual capture in {{spar|capture-list}} is
{{sdsc begin}}
{{sdsc | num=1 | {{spar|identifier}} }}
{{sdsc | num=2 | {{spar|identifier}} {{ttb|...}} }}
{{sdsc | num=3 |notes={{mark c++14}}| {{spar|identifier}} {{spar|initializer}} }}
{{sdsc | num=4 |{{ttb|&amp;}} {{spar|identifier}} }}
{{sdsc | num=5 |{{ttb|&amp;}} {{spar|identifier}} {{ttb|...}} }}
{{sdsc | num=6 |notes={{mark c++14}}| {{ttb|&amp;}} {{spar|identifier}} {{spar|initializer}} }}
{{sdsc | num=7 | {{ttb|this}} }}
{{sdsc end}}
@1@ simple by-copy capture
@2@ by-copy capture that is a {{rlp|parameter pack|pack expansion}}
@3@ by-copy capture with an initializer
@4@ simple by-reference capture
@5@ by-reference capture that is a {{rlp|parameter pack|pack expansion}}
@6@ by-reference capture with an initializer
@7@ capture for the {{rlp|this|this pointer}}

If a capture-default is used, no other captures may use the same capture type. Any capture may appear only once.
{{source|1=
struct S2 { void f(int i); };
void S2::f(int i) {
    [&amp;, i]{ }; // OK
    [&amp;, &amp;i]{ }; // error: i preceded by &amp; when &amp; is the default
    [=, this]{ }; // error: this when = is the default
    [i, i]{ }; // error: i repeated
}
}}

Only lamdbda-expressions defined at block scope may have a capture-default or captures without initializers. For such lambda-expression, the ''reaching scope'' is defined as the set of enclosing scopes up to and including the innermost enclosing function (and its parameters). This includes nested block scopes and the scopes of enclosing lambdas if this lambda is nested.

The {{spar|identifier}} in any capture without an initializer (other than the {{tt|this}}-capture) is looked up using usual {{rlp|lookup|unqualified name lookup}} in the ''reaching scope'' of the lambda. Such name is ''explicitly captured'

{{rev begin}}
{{rev|since=c++14|
A capture with an initializer acts as if it declares and explicitly captures a variable declared with type {{rlp|auto}}, whose declarative region is the body of the lambda expression (that is, it is not in scope within its initializer), except that:
* if the capture is by-copy, the non-static data member of the closure object is another way to refer to that auto variable.
* if the capture is by-reference, the reference variable's lifetime ends when the lifetime of the closure object ends

This is used to capture move-only types with a capture such as {{c|1=x = std::move(x)}}

{{source|1=
int x = 4;
auto y = [&amp;r = x, x = x+1]()-&gt;int {
                r += 2;
                return x+2;
          }(); // updates ::x to 6
               // initializes y to 7.
}}
}}
{{rev end}}

If a capture list has a capture-default and does not explicitly capture {{tt|this}} or an automatic variable, captures it ''implicitly'' if
* the body of the lambda {{rlp|definition|odr-uses}} the variable or {{tt|this}}
{{rev begin}}
{{rev |since=c++14|
* or the variable or {{tt|this}} is named in a potentially-evaluated expression within an expression that depends on a generic lambda parameter
{{source|1=
void f(int, const int (&amp;)[2] = {}) { } // #1
void f(const int&amp;, const int (&amp;)[1]) { } // #2
void test() {
    const int x = 17;
    auto g = [](auto a) {
                  f(x); // OK: calls #1, does not capture x
             };
    auto g2 = [=](auto a) {
                  int selector[sizeof(a) == 1 ? 1 : 2]{};
                  f(x, selector); // OK: is a dependent expression, so captures x
             };
}
}}
}}
{{rev end}}

If the body of a lambda odr-uses an entity captured by copy, the member of the closure type is accessed. If it is not odr-using the entity, the access is to the original object:
{{source|1=
void f(const int*);
void g() {
    const int N = 10;
    [=] { 
        int arr[N]; // not an odr-use: refers to g's const int N
        f(&amp;N); // odr-use: causes N to be captured (by copy)
               // &amp;N is the address of the closure object's member N, not g's N
    };
}
}}

Within the body of a lambda, any use of {{rlp|decltype}} on any variable with automatic storage duration is as if it were captured and odr-used, even though decltype itself isn't an odr-use and no actual capture takes place:
{{source|1=
void f3() {
    float x, &amp;r = x;
    [=] { // x and r are not captured (appearance in a decltype operand is not an odr-use)
        decltype(x) y1; // y1 has type float
        decltype((x)) y2 = y1; // y2 has type float const&amp; because this lambda
                               // is not mutable and x is an lvalue
        decltype(r) r1 = y1;   // r1 has type float&amp; (transformation not considered)
        decltype((r)) r2 = y2; // r2 has type float const&amp;
    };
}
}}

Any entity captured by a lambda (implicitly or explicitly) is odr-used by the lambda-expression (therefore, Implicit capture by a nested lambda triggers implicit capture in the enclosing lambda)

All implicitly-captured variables must be declared within the ''reaching scope'' of the lambda.

If a lambda captures {{tt|this}}, the nearest enclosing function must be a non-static member function.

If a generic lambda (or an instantiation of a generic capture-less lambda's conversion operator) ODR-uses {{tt|this}} or any variable, it is captured by the lambda expression.

{{source|1=
void f1(int i) {
    int const N = 20;
    auto m1 = [=]{
            int const M = 30;
            auto m2 = [i]{
                  int x[N][M]; // N and M are not odr-used (OK that they are not captured)
                  x[0][0] = i; // i is explicitly captured by m2
                               // and implicitly captured by m1
            };
     };

    struct s1 { // local class within f()
        int f;
        void work(int n) { // non-static member function
            int m = n*n;
            int j = 40;
            auto m3 = [this,m] {
                auto m4 = [&amp;,j] { // error: j not captured by m3
                    int x = n; // error: n implicitly captured by m4
                               // but not captured by m3
                    x += m; // OK: m implicitly captured by m4
                            // and explicitly captured by m3
                    x += i; // error: i is outside of the reaching scope (which ends at work())
                    x += f; // OK: this captured implicitly by m4
                            // and explicitly by m3
                };
            };
       }
    };
}
}}

If a lambda-expression appears in a {{rlp|default arguments|default argument}}, it cannot explicitly or implicitly capture anything.

Members of {{rlp|union|anonymous unions}} cannot be captured.

If a nested lambda {{tt|m2}} captures something that is also captured by the immediately enclosing lambda {{tt|m1}}, then {{tt|m2}}'s capture is transformed as follows:
* if the enclosing lambda {{tt|m1}} captures by copy, {{tt|m2}} is capturing the non-static member of {{tt|m1}}'s closure type, not the original variable or {{tt|this}}.
* if the enclosing lambda {{tt|m1}} by reference, {{tt|m2}} is capturing the original variable or {{tt|this}}.
{{example
|code=
#include &lt;iostream&gt;
int main() 
{
    int a = 1, b = 1, c = 1;
    auto m1 = [a, &amp;b, &amp;c]() mutable { 
      auto m2 = [a, b, &amp;c]() mutable {
        std::cout &lt;&lt; a &lt;&lt; b &lt;&lt; c;
        a = 4; b = 4; c = 4;
      };
      a = 3; b = 3; c = 3;
      m2(); 
    };
    a = 2; b = 2; c = 2;
    m1();                     // calls m2() and prints 123
    std::cout &lt;&lt; a &lt;&lt; b &lt;&lt; c; // prints 234
}
}}

{{todo|consider rearranging the layout for readability}}

===Example===
{{example
 | This example shows (a) how to pass a lambda to a generic algorithm and (b) how objects resulting from a lambda declaration can be stored in {{lc|std::function}} objects.
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;

int main()
{
    std::vector&lt;int&gt; c { 1,2,3,4,5,6,7 };
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n &lt; x; } ), c.end());

    std::cout &lt;&lt; &quot;c: &quot;;
    for (auto i: c) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    // the type of a closure cannot be named, but can be inferred with auto
    auto func1 = [](int i) { return i+4; };
    std::cout &lt;&lt; &quot;func1: &quot; &lt;&lt; func1(6) &lt;&lt; '\n'; 
 
    // like all callable objects, closures can be captured in std::function
    // (this may incur unnecessary overhead)
    std::function&lt;int(int)&gt; func2 = [](int i) { return i+4; };
    std::cout &lt;&lt; &quot;func2: &quot; &lt;&lt; func2(6) &lt;&lt; '\n'; 
}
 | output= 
c: 5 6 7
func1: 10
func2: 10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc auto}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc end}}

[[de:cpp/language/lambda]]
[[es:cpp/language/lambda]]
[[fr:cpp/language/lambda]]
[[it:cpp/language/lambda]]
[[ja:cpp/language/lambda]]
[[pt:cpp/language/lambda]]
[[ru:cpp/language/lambda]]
[[zh:cpp/language/lambda]]</text>
      <sha1>kgsuvpytlmjthisejjbl7j32recdr66</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/language linkage</title>
    <ns>0</ns>
    <id>9919</id>
    <revision>
      <id>67723</id>
      <parentid>65981</parentid>
      <timestamp>2014-02-21T19:20:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="4785">{{title|Language linkage}}
{{cpp/language/declarations/navbar}}
Provides for linkage between modules written in different programming languages.

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|extern}} {{spar|string-literal}} {{ttb|{}} {{spar|declaration-seq}}{{mark optional}} {{ttb|} }}
}}
{{sdsc|num=2|1=
{{ttb|extern}} {{spar|string-literal}} {{spar|declaration}}
}}
{{sdsc end}}
@1@ Applies the language specification {{spar|string-literal}} to all function types, function names with external linkage and variables with external linkage declared in {{spar|declaration-seq}}
@2@ Applies the language specification {{spar|string-literal}} to a single declaration or definition.

{{par begin}}
{{par | {{spar|string-literal}} | The name of the required language linkage }}
{{par | {{spar|declaration-seq}} | a sequence of declarations, which may include nested linkage specifications }}
{{par | {{spar|declaration}} | a declaration }}
{{par end}}

===Explanation===
Every function type, every function name with {{rlp|storage_duration|external linkage}}, and every variable name with {{rlp|storage_duration|external linkage}}, has a property called ''language linkage''. Language linkage encapsulates the set of requirements necessary to link with a module written in another programming language: [[enwiki:Calling_convention|calling convention]], [[enwiki::Name_mangling|name mangling]] algorithm, etc.

Only two language linkages are guaranteed to be supported:
@1@ {{c|&quot;C++&quot;}}, the default language linkage.
@2@ {{c|&quot;C&quot;}}, which makes it possible to link with functions written in the C programming language, and to define, in a C++ program, functions that can be called from the modules written in C.

{{source|1=
extern &quot;C&quot; {
    int open(const char *pathname, int flags); // C function declaration
}

int main()
{
    int fd = open(&quot;test.txt&quot;, 0); // calls a C function from a C++ program
}

// This C++ function can be called from C code
extern &quot;C&quot; void handler(int) {
    std::cout &lt;&lt; &quot;Callback invoked\n&quot;; // It can use C++
} 
}}

Since language linkage is part of every function type, pointers to functions maintain language linkage as well. Language linkage of function types (which represents calling convention) and language linkage of function names (which represents name mangling) are independent of each other:

{{source|1=
extern &quot;C&quot; void f1(void(*pf)(int)); // declares a function f1 with C linkage,
                             // which returns void and takes a pointer to a C function
                             // which returns void and takes no parameters
extern &quot;C&quot; typedef void FUNC(); // declares FUNC as a C function type that returns void
                                // and takes no parameters
FUNC f2;            // the name f2 has C++ linkage, but its type is C function
extern &quot;C&quot; FUNC f3; // the name f3 has C linkage and its type is C function void()
void (*pf2)(FUNC*); // the name pf2 has C++ linkage, and its type is
                    // &quot;pointer to a C++ function which returns void and takes one
                    // argument of type 'pointer to the C function which returns void
                    // and takes no parameters'&quot;
extern &quot;C&quot; {
    static void f4();  // the name of the function f4 has internal linkage (no language)
                      // but the function's type has C language linkage
}
}}

Two functions with the same name and the same parameter list in the same namespace cannot have two different language linkages. Likewise, two variables in the same namespace cannot have two different language linkages.

====Special rules for &quot;C&quot; linkage====
@1@ When class member declarations and member function type declarations appear in a {{c|&quot;C&quot;}} language block, their linkage remains {{c|&quot;C++&quot;}}
@2@ When two functions with the same unqualified name are declared in different namespaces, and both have {{c|&quot;C&quot;}} language linkage, the declarations refer to the same function
@3@ When two variables with {{c|&quot;C&quot;}} language linkage and the same name that appear in different namespaces, they refer to the same variable.
@4@ A {{c|&quot;C&quot;}} variable and a {{c|&quot;C&quot;}} function cannot have the same name, regardless if they are defined in the same or different namespaces.

===Notes===

Language specifications can only appear in namespace scope

The braces of the language specification do not establish a scope.

When language specifications nest, the innermost specification is the one that is in effect.

A function can be re-declared without a linkage specification after it was declared with a language specification, the second declaration will reuse the first language linkage. The opposite is not true: if the first declaration has no language linkage, it is assumed {{c|&quot;C++&quot;}}, and redeclaring with another language is an error.</text>
      <sha1>7e7og7hvoy2ziuiy46bp7fxy7n3k7po</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/lifetime</title>
    <ns>0</ns>
    <id>13096</id>
    <revision>
      <id>71430</id>
      <parentid>69000</parentid>
      <timestamp>2014-06-11T03:06:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>moving out-of-lifetime block from the page about references. After all, this is about lvalues</comment>
      <text xml:space="preserve" bytes="5627">{{title|Object lifetime}}
{{cpp/language/basics/navbar}}
Every {{rlp|object}} has a ''lifetime'', which is a runtime property: for any object, there is a moment during the execution of a program when its lifetime begins, and there is a moment when it ends.

* For objects of class or aggregate types that are not {{rlp|default_constructor#Trivial_default_constructor|trivially-constructible}}, lifetime begins when initialization ends.
* For objects of class types that are not {{rlp|destructor#Trivial_destructor|trivially-destructible}}, lifetime ends when the execution of the destructor begins.
* For all other objects (trivial class objects, non-class objects, array objects, etc), lifetime begins when the properly-aligned storage for the object is allocated and ends when the storage is deallocated or reused by another object.

Lifetime of an object is equal to or is nested within the lifetime of its storage, see {{rlp|storage duration}}.

Lifetime of a {{rlp|reference}} is exactly its storage duration (which makes {{rlp|reference#Dangling_references|dangling references}} possible)

Lifetimes of member objects and base subobjects begin and end following {{rlp|initializer_list#Initialization order|class initialization order}}.

===Temporary object lifetime===
Temporary objects are created in various situations: binding a reference to a prvalue, returning a prvalue from a function, cast to a prvalue, throwing an exception, entering an exception handler, and in some initializations. In every case, all temporaries are destroyed as the last step in evaluating the full-expression that (lexically) contains the point where they were created, and if multiple temporaries were created, they are destroyed in the order opposite to the order of creation. This is true even if that evaluation ends in throwing an exception.

There are two exceptions from that:

1. The lifetime of a temporary object may be extended by binding to a const lvalue reference {{rev inl|since=c++11|or to an rvalue reference}}, see {{rlp|reference_initialization#Lifetime_of_a_temporary|reference initialization}} for details.
{{rev begin}}
{{rev|since=c++11|
2. The lifetime of a temporary created when evaluating the default arguments of a default constructor used to initialize an element of an array ends before the next element of the array begins initialization.}}
{{rev end}}

===Storage reuse===
A program is not required to call the destructor of an object to end its lifetime if the object is {{rlp|destructor#Trivial_destructor|trivially-destructible}} or if the program does not rely on the side effects of the destructor. However, if a program ends the lifetime of an non-trivial object, it must ensure that a new object of the same type is constructed in-place (e.g. via placement new) before the destructor may be called implicitly, i.e. due to scope exit or exception for automatic objects, due to thread exit for thread-local objects, or due to program exit for static objects; otherwise the behavior is undefined.

{{source|1=
class T {}; // trivial
struct B {
    ~B() {} // non-trivial
};
void x() {
    long long n; // automatic, trivial
    new (&amp;n) double(3.14); // reuse with a different type okay
} // okay
void h() {
    B b; // automatic non-trivially destructible
    b.~B(); // end lifetime (not required, since no side-effects)
    new (&amp;b) T; // wrong type: okay until the destructor is called
} // destructor is called: undefined behavior
}}

It is undefined behavior to reuse storage that is or was occupied by a const object of static, thread-local, or automatic storage duration.

{{source|1=
struct B {
    B(); // non-trivial
    ~B(); // non-trivial
};
const B b; // const static
void h() {
    b.~B(); // end the lifetime of b
    new (const_cast&lt;B*&gt;(&amp;b)) const B; // undefined behavior: attempted reuse of a const
}
}}

===Access outside of lifetime===
If an object was destroyed (e.g. by explicit destructor call), but the storage was not deallocated, the following uses of the glvalue expression that identifies that object are undefined:
@1@ lvalue to rvalue conversion (e.g. function call to a function that takes a value)
@2@ access to a non-static data member or a call to a non-static member function
@3@ binding to reference to a virtual base class subobject
@5@ {{c|dynamic_cast}} or {{c|typeid}} expressions

If an object is recreated at the same memory location (e.g. by placement new), the glvalue becomes valid once again, if all of the following is true:
@1@ the storage occupied by the new object exactly overlays the storage occupied by the old object
@2@ the new object has the same type as the old object, ignoring top-level cv-qualifiers
@3@ the original object's type was not const-qualified
@4@ the original object was not a class with const or reference non-static data members
@5@ both the original and the new objects are the most-derived objects of their type

The above rules apply to pointers as well (binding a reference to virtual base is replaced by implicit conversion to a pointer to virtual base), with two additional rules:
* {{rlp|static_cast}} of a pointer to storage without an object is only allowed when casting to (possibly cv-qualified) {{c|void*}}
* pointers to storage without an object that were cast to possibly cv-qualified {{c|void*}} can only be {{rlp|static_cast}} to pointers to possibly cv-qualified {{c|char}} or pointer to possibly cv-qualified {{c|unsigned char}}


During construction and destruction, other restrictions apply, see {{rlp|virtual#During construction and destruction|virtual function calls during construction and destruction}}.</text>
      <sha1>mumfjfw2l7kc7baraxyt7da9g3yf1qj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/list initialization</title>
    <ns>0</ns>
    <id>8868</id>
    <revision>
      <id>71840</id>
      <parentid>71680</parentid>
      <timestamp>2014-06-27T09:01:12Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <comment>Corrected an error.</comment>
      <text xml:space="preserve" bytes="8148">{{title|list initialization {{mark since c++11}}}}
{{cpp/language/initialization/navbar}}
Initializes an object from braced-init-list

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{spar| object}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}} }}
{{sdsc | num=2 | {{spar|T}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}} }}
{{sdsc | num=3 | {{ttb|new}} {{spar|T}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}} }}
{{sdsc | num=4 | {{ttb|return { }} {{spar|arg1, arg2, ...}} {{ttb|} ;}} }}
{{sdsc | num=5 | {{spar|function}}{{ttb|( { }} {{spar|arg1, arg2, ...}} {{ttb|} ) ;}} }}
{{sdsc | num=6 | {{spar|object}}{{ttb|[ { }} {{spar|arg1, arg2, ...}} {{ttb|} ] ;}} }}
{{sdsc | num=7 | {{spar|T}}{{ttb|( { }} {{spar|arg1, arg2, ...}} {{ttb|} ) }} }}
{{sdsc | num=8 | {{spar|Class}} {{ttb|{}} {{spar|T}} {{spar|member}} {{ttb|{{=}}}} {{ttb|{ }}{{spar|arg1, arg2, ...}} {{ttb|}; }; }}}}
{{sdsc | num=9 | {{spar|Class}}{{ttb|::}}{{spar|Class}}{{ttb|() : }}{{spar|member}}{{ttb|{}}{{spar|arg1, arg2, ...}}{{ttb|} {...}} }}
{{sdsc | num=10 | {{spar|T}} {{spar|object}} {{ttb|{{=}} {}}{{spar|arg1, arg2, ...}}{{ttb|};}} }}
{{sdsc end}}

===Explanation===

List initialization is performed in the following situations:
@1@ initialization of a named variable with a brace-enclosed list of expressions or nested lists (''braced-init-list'')
@2@ initialization of an unnamed temporary with a braced-init-list
@3@ initialization of an object with dynamic storage duration with a new-expression, where the initializer is a brace-init-list
@4@ in a {{c|return}} statement with braced-init-list used as the return expression
@5@ in a function call expression, with braced-init-list used as an argument
@6@ in a subscript expression with a user-defined operator[]
@7@ in a functional cast expression or other direct-initialization, with braced-init-list used as the constructor argument
@8@ in a non-static data member initializer
@9@ in a constructor initializer list
@10@ on the right-hand-side of the equals sign (similar to [[cpp/language/copy_initialization|copy-initialization]])

The effects of list initialization of an object of type {{tt|T}} are:
{{rev begin}}
{{rev|until=c++14|
* If the braced-init-list is empty and {{tt|T}} is a class type with a default constructor, [[cpp/language/value_initialization|value-initialization]] is performed.

* Otherwise, if {{tt|T}} is an aggregate type, [[cpp/language/aggregate_initialization|aggregate initialization]] is performed.
}}
{{rev|since=c++14|
* If {{tt|T}} is an aggregate type, [[cpp/language/aggregate_initialization|aggregate initialization]] is performed.

* Otherwise, If the braced-init-list is empty and {{tt|T}} is a class type with a default constructor, [[cpp/language/value_initialization|value-initialization]] is performed.
}}
{{rev end}}

* Otherwise, if {{tt|T}} is a specialization of {{lc|std::initializer_list}}, a new {{tt|std::initializer_list}} prvalue of the same type is constructed and used to direct-initialize or copy-initialize the object of type {{tt|T}}, depending on context.

* Otherwise, the constuctors of {{tt|T}} are considered, in two phases:

:* All constructors that take {{lc|std::initializer_list}} as the only argument, or as the first argument if the remaining arguments have default values, are examined, and matched by overload resolution against a single argument of type {{lc|std::initializer_list}}

:* If the previous stage does not produce a match, all constructors of {{tt|T}} participate in overload resolution against the set of arguments that consists of the elements of the braced-init-list, with the restriction that only non-narrowing conversions are allowed. If this stage produces an explicit constructor as the best match for a copy-list-initialization, compilation fails (note, in simple copy-initialization, explicit constructors are not considered at all)

* Otherwise, if the braced-init-list has only one element and either {{tt|T}} isn't a reference type or is reference type that isn't compatible with the type of the element, {{tt|T}} is [[cpp/language/value_initialization|direct-initialized]] or [[cpp/language/copy_initialization|copy-initialized]], depending on context, except that narrowing conversions are not allowed.

* Otherwise, if {{tt|T}} is reference type, a prvalue temporary of the referenced type is list-initialized, and the reference is bound to that temporary. (this fails if the reference is a non-const lvalue reference)

* Otherwise, if the braced-init-list has no elements, {{tt|T}} is [[cpp/language/value_initialization|value-initialized]].

===Narrowing conversions===
list-initialization limits the allowed [[cpp/language/implicit_cast|implicit conversions]] by prohibiting the following:

* conversion from a floating-point type to an integer type

* conversion from a {{c|long double}} to {{c|double}} or to {{c|float}} and conversion from {{c|double}} to {{c|float}}, except where the source is a constant expression whose value can be stored exactly in the target type

* conversion from integer or unscoped enumeration type to integer type that cannot represent all values of the original, except where source is a constant expression whose value can be stored exactly in the target type

===Notes===
Braced-init-list is not an expression and has no type on its own: {{c|decltype({1,2})}} is illegal.&lt;!--&lt;code&gt;template&lt;class T&gt; void f(std::initializer_list&lt;T&gt;);f({1,2,3});&lt;/code&gt; is perfectly legal --&gt;  A special exception is made for the keyword {{c|auto}}, which deduces any braced-init-list as {{lc|std::initializer_list}}.

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;map&gt;
#include &lt;string&gt;

struct Foo {
    std::vector&lt;int&gt; mem = {1,2,3}; // list-initialization of a non-static member
    std::vector&lt;int&gt; mem2;
    Foo() : mem2{-1, -2, -3} {} // list-initialization of a member in constructor
};

std::pair&lt;std::string, std::string&gt; f(std::pair&lt;std::string, std::string&gt; p)
{
    return {p.second, p.first}; // list-initialization in return statement
}

int main()
{
    int n0{};     // value-initialization (to zero)
    int n1{1};    // direct-list-initialization
    std::string s1{'a', 'b', 'c', 'd'}; // initializer-list constructor call
    std::string s2{s1, 2, 2};           // regular constructor call
    std::string s3{0x61, 'a'}; // initializer-list ctor is preferred to (int, char)

    int n2 = {1}; // copy-list-initialization
    double d = double{1.2}; // list-initialization of a temporary, then copy-init
                     
    std::map&lt;int, std::string&gt; m = { // nested list-initialization
           {1, &quot;a&quot;},
           {2, {'a', 'b', 'c'} },
           {3, s1}
    };

    std::cout &lt;&lt; f({&quot;hello&quot;, &quot;world&quot;}).first // list-initialization in function call
              &lt;&lt; '\n';

    const int (&amp;ar)[2] = {1,2}; // binds a lvalue reference to a temporary array
    int&amp;&amp; r1 = {1}; // binds a rvalue reference to a temporary int
//  int&amp; r2 = {2}; // error: cannot bind rvalue to a non-const lvalue ref

//  int bad{1.0}; // error: narrowing conversion
    unsigned char uc1{10}; // okay
//  unsigned char uc2{-1}; // error: narrowing conversion

    Foo f;

    std::cout &lt;&lt; n0 &lt;&lt; ' ' &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; '\n'
              &lt;&lt; s1 &lt;&lt; ' ' &lt;&lt; s2 &lt;&lt; ' ' &lt;&lt; s3 &lt;&lt; '\n';
    for(auto p: m)
        std::cout &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; p.second &lt;&lt; '\n';
    for(auto n: f.mem)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    for(auto n: f.mem2)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
 | output=
world
0 1 1
abcd cd aa
1 a
2 abc
3 abcd
1 2 3 -1 -2 -3 
}}


===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/aggregate_initialization|aggregate initialization]]
* [[cpp/language/copy_initialization|copy initialization]]

[[de:cpp/language/list initialization]]
[[es:cpp/language/list initialization]]
[[fr:cpp/language/list initialization]]
[[it:cpp/language/list initialization]]
[[ja:cpp/language/list initialization]]
[[pt:cpp/language/list initialization]]
[[ru:cpp/language/list initialization]]
[[zh:cpp/language/list initialization]]</text>
      <sha1>quromyfhqfiwr6t3pdwij03zm9v3bej</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/lookup</title>
    <ns>0</ns>
    <id>13015</id>
    <revision>
      <id>71716</id>
      <parentid>71570</parentid>
      <timestamp>2014-06-21T20:01:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link back to dependent names</comment>
      <text xml:space="preserve" bytes="21311">{{title|Name lookup}}
{{cpp/language/basics/navbar}}
Name lookup is the procedure by which a {{rlp|name}}, when encountered in a program, is associated with the {{rlp|declarations|declaration}} that introduced it.

For function names, name lookup can associate multiple declarations with the same name, and may obtain additional declarations from {{rlp|adl|argument-dependent lookup}}. {{rlp|function template|Template argument deduction}} may also apply, and the set of declarations is passed to {{rlp|overload resolution}}, which selects the declaration that will be used. {{rlp|access|Member access}} rules, if applicable, are considered only after name lookup and overload resolution.

For all other names (variables, namespaces, classes, etc), name lookup must produce a single declaration in order for the program to compile.

For example, to compile {{c|std::cout &lt;&lt; std::endl;}}, the compiler performs:
* unqualified name lookup for the name {{tt|std}}, which finds the declaration of namespace std in the header {{tt|&lt;iostream&gt;}}
* qualified name lookup for the name {{tt|cout}}, which finds a variable declaration in the namespace {{tt|std}}
* qualified name lookup for the name {{tt|endl}}, which finds a function template declaration in the namespace {{tt|std}}
* {{rlp|adl|argument-dependent lookup}} for the name {{tt|operator &lt;&lt;}}, which finds multiple function template declarations in the namespace std

==Unqualified name lookup==
For an ''unqualified'' name, that is name that does not appear to the right of a scope resolution operator {{ttb|::}}, name lookup examines the {{rlp|scope|scopes}} as described below, until it finds at least one declaration of any kind, at which time the lookup stops and no further scopes are examined. (Note: lookup from some contexts skips some declarations, for example, lookup of the name used to the left of {{ttb|::}} ignores function, variable, and enumerator declarations, lookup of a name used a base class specifier ignores all non-type declarations)

For the purpose of unqualified name lookup, all declarations from a namespace nominated by a {{rlp|namespace|using directive}} appear as if declared in the nearest enclosing namespace which contains, directly or indirectly, both the using-directive and the nominated namespace.

Unqualified name lookup of the name used to the left of the function-call operator (and, equivalently, operator in an expression) is described in {{rlp|adl|argument-dependent lookup}}.

@1@ For a name used in global (top-level namespace) scope, outside of any function, class, or user-declared namespace, the global scope before the use of the name is examined:
{{source|1=
int n = 1;     // declaration of n
int x = n + 1; // OK: lookup finds ::n

int z = y - 1; // Error: lookup fails
int y = 2;     // declaration of y

int main() {}
}}

@2@ For a name used in a user-declared namespace outside of any function or class, this namespace is searched before the use of the name, then the namespace enclosing this namespace before the declaration of this namespace, etc until the global namespace is reached.
{{source|1=
int n = 1; // declaration
namespace N {
  int m = 2;
  namespace Y {
    int x = n; // OK, lookup finds ::n
    int y = m; // OK, lookup finds ::N::m
    int z = k; // Error: lookup fails
  }
  int k = 3;
}
}}

@3@ For a name used in the definition of a function, either in its body or as part of default argument, where the function is a member of user-declared or global namespace, the block in which the name is used is searched before the use of the name, then the enclosing block is searched before the start of that block, etc, until reaching the block that is the function body. Then the namespace in which the function is declared is searched until the definition (not necessarily the declaration) of the function that uses the name, then the enclosing namespaces, etc.
{{source|1=
namespace A {
   namespace N {
       void f();
       int i=3; // found 3rd (if 2nd is not present)
    }
    int i=4; // found 4th (if 3rd is not present)
}

int i=5; // found 5th (if 4th is not present)

void A::N::f() {
    int i = 2; // found 2nd (if 1st is not present)
    while(true) {
       int i = 1; // found 1st: lookup is done
       std::cout &lt;&lt; i;
    }
}

// int i; // not found

namespace A {
  namespace N {
    // int i; // not found
  }
}
}}

@4@ For a name used anywhere in {{rlp|class|class definition}}, except inside a member function body, a default argument of a member function, exception specification of a member function, in-class brace-or-equal initializer of a data member, or inside a nested class definition (including names of the bases from which the nested class is derived), the following scopes are searched:
:@a@ the body of the class in which the name is used until the point of use and the entire body of its base class(es)
:@b@ if this class is {{rlp|nested types|nested}}, the body of the enclosing class until the declaration of this class and the entire body of the base class(es) of the enclosing class.
:@c@ if this class is {{rlp|class#Local classes|local}}, or nested within a local class, the block scope in which the class is defined until the point of definition
:@d@ if this class is a member of a namespace, or is nested in a class that is a member of a namespace, or is a local class in a function that is a member of a namespace, the scope of the namespace is searched until the definition of the class, enclosing class, or function. if the lookup of for a name introduced by a {{rlp|friend}} declaration: in this case only the innermost enclosing namespace is considered, otherwise lookup continues to enclosing namespaces until the global scope as usual.
{{source|1=
namespace M {
    // const int i = 1; // never found
    class B {
        // const const int i = 3; // found 3nd (but later rejected by access check)
    };
}
// const int i = 5; // found 5th
namespace N {
    // const int i = 4; // found 4th
    class Y : public M::B {
        // static const int i = 2; // found 2nd
        class X {
            // static const int i = 1; // found 1st
            int a[i]; // use of i
            // static const int i = 1; // never found
        };
        // static const int i = 2; // never found
    };
    // const int i = 4; // never found
}
// const int i = 5; // never found
}}

@5@ For a name used inside a member function body, a default argument of a member function, exception specification of a member function, in-class brace-or-equal initializer of a data member, or inside a nested class definition (including names of the bases from which the nested class is derived), the scopes searched are the same as in (4), except that the entire scope of the class is considered, not just the part prior to the declaration that uses the name. For nested classes the entire body of the enclosing class is searched.
{{source|1=
class B {
    // int i; // found 3rd
};
namespace M {
    // int i; // found 5th
    namespace N {
        // int i; // found 4th
        class X : public B {
            // int i; // found 2nd
            void f();
            // int i; // found 2nd as well
        };
        // int i; // found 4th
    }
}
// int i; // found 6th
void M::N::X::f()
{
    // int i; // found 1st
    i = 16;
    // int i; // never found
}
namespace M {
  namespace N {
    // int i; // never found
  }
}
}}

:: Either way, when examining the bases from which the class is derived, the following rules, sometime referred to as [[enwiki:Dominance_(C++)|dominance in virtual inheritance]], are followed:
{{rev begin}}
{{rev|until=c++11|A member name found in a sub-object {{tt|B}} hides the same member name in any sub-object {{tt|A}} if {{tt|A}} is a base class sub-object of {{tt|B}}. (note that this does not hide the name in any additional, non-virtual, copies of {{tt|A}} on the inheritance lattice that aren't bases of {{tt|B}}: this rule only has an effect on virtual inheritance). Names introduced by using-declarations are treated as names in the class containing the declaration. After examining each base, the resulting set must either include declarations of a static member from subobjects of the same type, or declarations of non-static members from the same subobject}}
{{rev|since=c++11|A ''lookup set'' is constructed, which consists of the declarations and the subobjects in which these declarations were found. Using-declarations are replaced by the members they represent and type declarations, including injected-class-names are replaced by the types they represent. If {{tt|C}} is the class in whose scope the name was used, {{tt|C}} is examined first. If the list of declarations in {{tt|C}} is empty, lookup set is built for each of its direct bases {{tt|Bi}} (recursively applying these rules if {{tt|Bi}} has its own bases). Once built, the lookup sets for the direct bases are merged into the lookup set in {{tt|C}} as follows
::* if the set of declarations in {{tt|Bi}} is empty, it is discarded
::* if the lookup set of {{tt|C}} built so far is empty, it is replaced by the lookup set of {{tt|Bi}}
::* if every subobject in the lookup set of {{tt|Bi}} is a base of at least one of the subobjects already added to the lookup set of {{tt|C}}, the lookup set of {{tt|Bi}} is discarded.
::* if every subobject already added to the lookup set of {{tt|C}} is a base of at least one subobject in the lookup set of {{tt|Bi}}, then the lookup set of {{tt|C}} is discarded and replaced with the lookup set of {{tt|Bi}}
::* otherwise, if the declaration sets in {{tt|Bi}} and in {{tt|C}} are different, the result is an ambiguous merge: the new lookup set of {{tt|C}} has an invalid declaration and a union of the subobjects ealier merged into {{tt|C}} and introduced from {{tt|Bi}}. This invalid lookup set may not be an error if it is discarded later.
::* otherwise, the new lookup set of {{tt|C}} has the shared declaration sets and the union of the subobjects ealier merged into {{tt|C}} and introduced from {{tt|Bi}}
}}
{{rev end}} 
{{source|
struct X { void f(); };
struct B1: virtual X { void f(); };
struct B2: virtual X {};
struct D : B1, B2 {
    void foo() {
        X::f(); // OK, calls X::f (qualified lookup)
        f(); // OK, calls B1::f (unqualified lookup)
// C++98 rules: B1::f hides X::f, so even though X::f can be reached from D
// through B2, it is not found by name lookup from D.
// C++11 rules: lookup set for f in D finds nothing, proceeds to bases
//  lookup set for f in B1 finds B1::f, and is completed
// merge replaces the empty set, now lookup set for f in C has B1::f in B1
//  lookup set for f in B2 finds nothing, proceeds to bases
//    lookup for f in X finds X::f
//  merge replaces the empty set, now lookup set for f in B2 has X::f in X
// merge into C finds that every subobject (X) in the lookup set in B2 is a base
// of every subobject (B1) already merged, so the B2 set is discareded
// C is left with just B1::f found in B1
// (if struct D : B2, B1 was used, then the last merge would *replace* C's 
//  so far merged X::f in X because every subobject already added to C (that is X)
//  would be a base of at least one subobject in the new set (B1), the end
//  result would be the same: lookup set in C holds just B1::f found in B1)
    }
};
}}
:: Unqualified name lookup that finds static members of {{tt|B}}, nested types of {{tt|B}}, and enumerators declared in {{tt|B}} is unambiguous even if there are multiple non-virtual base subobjects of type {{tt|B}} in the inheritance tree of the class being examined:
{{source|1=
struct V { int v; };
struct A {
        int a;
        static int s;
        enum { e };
};
struct B : A, virtual V { };
struct C : A, virtual V { };
struct D : B, C { };

void f(D&amp; pd) {
        ++pd.v; // OK: only one v because only one virtual base subobject
        ++pd.s; // OK: only one static A::s, even though found in B and in C
        int i = pd.e; // OK: only one enumerator A::e, even though found in B and C
        ++pd.a; // error, ambiguous: A::a in B and A::a in C 
}
}}

@6@ For a name used in a {{rlp|friend}} function definition inside the body of the class that is granting friendship, unqualified name lookup proceeds the same way as for a member function. For a name used in a {{rlp|friend}} function which is defined outside the body of a class, unqualified name lookup proceeds the same way as for a function in a namespace.
{{source|1=
int i = 3; // found 3rd for f1, found 2nd for f2
struct X {
    static const int i = 2; // found 2nd for f1, never found for f2
    friend void f1(int x)
    {
        // int i; // found 1st
        i = x; // finds and modifies X::i
    }
    friend int f2();
    // static const int i = 2; // found 2nd for f1 anywhere in class scope
};
void f2(int x) {
    // int i; // found 1st
    i = x; // finds and modifies ::i
}
}}

@7@ For a name used in the declarator of a {{rlp|friend}} function declaration that friends a member function from another class, if the name isn't a part of any template argument, the unqualified lookup first examines the entire scope of the member function's class. If not found in that scope (or if the name is a part of a template argument), the lookup continues as if for a member function of the class that is granting friendship
{{source|1=
// the class whose member functions are friended
struct A { 
    typedef int AT;
    void f1(AT);
    void f2(float);
    template &lt;class T&gt; void f3();
};

// the class that is granting friendship
struct B {
    typedef char AT;
    typedef float BT;
    friend void A::f1(AT); // lookup for AT finds A::AT
    friend void A::f2(BT); // lookup for BT finds B::BT 
    friend void A::f3&lt;AT&gt;(); // lookup for AT finds B::AT 
};
}}

@8@ For a name used in a {{rlp|default arguments|default argument}} in a function declaration, or name used in the {{spar|expression}} part of a {{rlp|initializer list|member-initializer}} of a constructor, the function parameter names are found first, before the enclosing block, class, or namespace scopes are examined:
{{source|1=
class X {
    int a, b, i, j;
public:
    const int&amp; r;
    X(int i): r(a), // initializes X::r to refer to X::a
              b(i), // initializes X::b to the value of the parameter i
              i(i), // initializes X::i to the value of the parameter i
              j(this-&gt;i) // initializes X::j to the value of X::i
    { }
}

int a;
int f(int a, int b = a); // error: lookup for a finds the parameter a, not ::a
                         // and parameters are not allowed as default arguments
}}

@9@ For a name used in the initializer part of the {{rlp|enum|enumerator declaration}}, previously declared enumerators in the same enumeration are found first, before the unqualified name lookup proceeds to examine the enclosing block, class, or namespace scope.
{{source|1=
const int RED = 7;
enum class color {
    RED,
    GREEN = RED+2, // RED finds color::RED, not ::RED, so GREEN = 2
    BLUE = ::RED+4 // qualified lookup finds ::RED, BLUE = 11
};
}}

@10@ For a name used in the definition of a {{rlp|static|static data member}}, lookup proceeds the same way as for a name used in the definition of a member function.
{{source|1=
struct X {
    static int x;
    static const int n = 1; // found 1st
};
int n = 2; // found 2nd.
int X::x = n; // finds X::n, sets X::x to 1, not 2
}}

@11@ For a name used in the definition of a namespace-member variable outside the namespace, lookup proceeds the same way as for a name used inside the namespace:
{{source|1=
namespace X {
    extern int x; // declaration, not definition
    int n = 1; // found 1st
};
int n = 2; // found 2nd.
int X::x = n; // finds X::n, sets X::x to 1
}}

@12@ For a name used in the catch-clause of a function-try block, lookup proceeds as if for a name used in the very beginning of the outermost block of the function body (in particular, function parameters are visible, but names declared in that outermost block are not)
{{source|1=
int n = 3; // found 3rd
int f(int n = 2) // found 2nd
try {
   int n = -1;  // never found
} catch(...) {
   // int n = 1; // found 1st
   assert(n == 2); // loookup for n finds function parameter f
   throw;
}
}}

@13@ For an {{rlp|expressions#Operators|operator}} used in expression (e.g., {{tt|operator+}} used in {{tt|a+b}}), the lookup rules are slightly different from the operator used in an explicit function-call expression such as {{tt|operator+(a,b)}}: when parsing an expression, two separate lookups are performed: for the non-member operator overloads and for the member operator overloads (for the operators where both forms are permitted). Those sets are then merged with the built-in operator overloads on equal grounds as described in {{rlp|overload resolution}}. If explicit function call syntax is used, regular unqualified name lookup is performed:
{{source|1=
struct A {};
void operator+(A, A); // user-defined non-member operator+

struct B {
    void operator+(B); // user-defined member operator+
    void f ();
};

A a;

void B::f() // definition of a member function of B
{
    operator+(a,a); // error: regular name lookup from a member function
                    // finds the declaration of operator+ in the scope of B
                    // and stops there, never reaching the global scope
    a + a; // OK: member lookup finds B::operator+, non-member lookup
           // finds ::operator+(A,A), overload resolution selects ::operator+(A,A)
}
}}

@14@ For a {{rlp|dependent name|non-dependent name}} used in a template definition, unqualified name lookup takes place when the template definition is examined. The binding to the declarations made at that point is not affected by declarations visible at the point of instantiation. For a {{rlp|dependent name}} used in a template definition, the lookup is postponed until the template arguments are known, at which time {{rlp|adl|ADL}} examines function declarations {{rev inl|until=c++11|with external linkage}} that are visible from the template definition context as well as in the template instantiation context, while non-ADL lookup only examines function declarations {{rev inl|until=c++11|with external linkage}} that are visible from the template definition context (in other words, adding a new function declaration after template definition does not make it visible except via ADL). The behavior is undefined if there is a better match with external linkage in the namespaces examined by the ADL lookup, declared in some other translation unit, or if the lookup would have been ambiguous if those translation units were examined. In any case, if a base class depends on a template parameter, its scope is not examined by unqualified name lookup (neither at the point of definition nor at the point of instantiation).
{{source|1=
void f(char); // first declaration of f

template&lt;class T&gt; 
void g(T t) {
    f(1);    // non-dependent name: lookup finds ::f(char) and binds it now
    f(T(1)); // dependent name: lookup postponed
    f(t);    // dependent name: lookup postponed
//  dd++;    // non-dependent name: lookup finds no declaration
}

enum E { e };
void f(E);   // second declaration of f
void f(int); // third declaration of f
double dd;

void h() {
    g(e);  // instantiates g&lt;E&gt;, at which point
           // the second and the third uses of the name 'f'
           // are looked up and find ::f(char) (by lookup) and ::f(E) (by ADL)
           // then overload resolution chooses ::f(E).
           // This calls f(char), then f(E) twice
    g(32); // instantiates g&lt;int&gt;, at which point
           // the second and the third uses of the name 'f'
           // are looked up and find ::f(char) only
           // then overload resolution chooses ::f(char)
           // This calls f(char) three times
}

typedef double A;
template&lt;class T&gt; class B {
   typedef int A;
};
template&lt;class T&gt; struct X : B&lt;T&gt; {
   A a; // lookup for A finds ::A (double), not B&lt;T&gt;::A
};
}}
Note: see {{rlp|dependent name#Lookup rules|dependent name lookup rules}} for the reasoning and implications of this rule.
@15@ For the name of a class or class template used within the definition of that class or template, unqualified name lookup finds the class that's being defined as if the name was introduced by a member declaration (with public member access)

{{todo|lookup of injected-class-name, lookup in out-of-body members of class templates}}

{{todo|dual-scope lookup of the template name after -&gt; and . &lt;!-- see http://stackoverflow.com/a/10426708/273767 for the example where it makes sense --&gt;}}


==Qualified name lookup==
{{todo}}

===References===
{{ref std c++11}}
{{ref std | section=3.4 | title=Name lookup | id=basic.lookup}}
{{ref std | section=10.2 | title=Member name lookup | id=class.member.lookup}}
{{ref std | section=14.6 | title=Name resolution | id=temp.res}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=3.4 | title=Name lookup | id=basic.lookup}}
{{ref std | section=10.2 | title=Member name lookup | id=class.member.lookup}}
{{ref std | section=14.6 | title=Name resolution | id=temp.res}}
{{ref std end}}

===See also===
* {{rlp|scope|Scope}} 
* {{rlp|adl|Argument-dependent lookup}} 
* {{rlp|function_template|Template argument deduction}}
* {{rlp|overload_resolution|Overload resolution}}</text>
      <sha1>niw3szrog6807826g2hgppf2slrwehh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/main function</title>
    <ns>0</ns>
    <id>9805</id>
    <revision>
      <id>72095</id>
      <parentid>70165</parentid>
      <timestamp>2014-07-14T14:44:21Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>initial cap, period</comment>
      <text xml:space="preserve" bytes="4509">{{title|Main function}}
{{cpp/language/basics/navbar}}

A program shall contain a global function called {{ttb|main}}, which is the designated start of the program.

{{sdsc begin}}
{{sdsc|num=1|1=
{{c|int}} {{ttb|main}} {{ttb|()}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc|num=2|1=
{{c|int}} {{ttb|main}} {{ttb|(}}{{c|int}} {{spar|argc}}{{ttb|,}} {{c|char}} {{c|*}}{{spar|argv}}{{c|[]}}{{ttb|)}} {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc|num=3|1=
{{c|int}} {{ttb|main}} {{ttb|(}}{{c|int}} {{spar|argc}}{{ttb|,}} {{c|char}} {{c|*}}{{spar|argv}}{{c|[]}}  {{ttb|,}} {{spar|other_parameters}} {{ttb|)}}  {{ttb|{}} {{spar|body}} {{ttb|} }}
}}
{{sdsc end}}

{{par begin}}
{{par | argc | Non-negative value representing the number of arguments passed to the program from the environment in which the program is run.}}
{{par | argv | Pointer to an array of pointers to [[cpp/string/multibyte|null-terminated multibyte strings]] that represent the arguments passed to the program from the execution environment ({{c|argv[0]}} through {{c|argv[argc-1]}}). The value of {{c|argv[argc]}} is guaranteed to be {{c|0}}.}}
{{par | body | The body of the main function}}
{{par | {{spar|other_parameters}} | Implementations may allow additional forms of the main function as long as the return type remains {{tt|int}}. A very common extension is passing a third argument of type {{tt|char*[]}} pointing at [http://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html an array of pointers to the execution environment variables].}}
{{par end}}

The names {{tt|argc}} and {{tt|argv}} are arbitrary, as well as the representation of the types of the parameters: {{c|int main(int ac, char** av)}} is equally valid.

===Explanation===
The {{tt|main}} function is called at program startup after {{rlp|initialization}} of the non-local objects with static {{rlp|storage duration}}. It is the designated entry point to a program that is executed in ''hosted'' environment (that is, with an operating system). The entry points to ''freestanding'' programs (boot loaders, OS kernels, etc) are implementation-defined.

The parameters of the two-parameter form of the main function allow arbitrary multibyte character strings to be passed from the execution environment (these are typically known as ''command line arguments''), the pointers {{tt|argv[1] .. argv[argc-1]}} point at the first characters in each of these strings. {{tt|argv[0]}} is the pointer to the initial character of a null-terminated multibyte strings that represents the name used to invoke the program itself (or an empty string {{c|&quot;&quot;}} if this is not supported by the execution environment). The strings are modifiable, although these modifications do not propagate back to the execution environment: they can be used, for example, with {{lc|std::strtok}}. The size of the array pointed to by {{tt|argv}} is at least {{tt|argc+1}}, and the last element, {{tt|argv[argc]}}, is guaranteed to be a null pointer.

The {{tt|main}} function has several special properties:
@1@ It cannot be used anywhere in the program
:@a@ in particular, it cannot be called recursively
:@b@ its address cannot be taken
@2@ It cannot be predefined and cannot be overloaded: effectively, the name {{tt|main}} in the global namespace is reserved for functions (although it can be used to name classes, namespaces, enumerations, and any entity in a non-global namespace)
@3@ It cannot be defined as deleted or declared {{rlp|inline}}, {{rlp|static}}, or {{rlp|constexpr}}
@4@ The body of the main function does not need to contain the {{rlp|return|return statement}}: if control reaches the end of {{tt|main}} without encountering a return statement, the effect is that of executing {{c|return 0;}}.
@5@ Execution of the return (or the implicit return upon reaching the end of main) is equivalent to first leaving the function normally (which destroys the objects with automatic storage duration) and then calling {{c|std::exit}} with the same argument as the argument of the {{rlp|return}}. ({{c|std::exit}} then destroys static objects and terminates the program)
@6@ If the main function is defined with a {{rlp|function-try-block}}, the exceptions thrown by the destructors of static objects (which are destroyed by the implied {{lc|std::exit}}) are not caught by it.
@7@ {{mark since c++14}} The return type of the main function cannot be deduced ({{c|auto main() {...}} is not allowed)

===See also===
{{dsc begin}}
{{dsc see c | c/language/main function}}
{{dsc end}}</text>
      <sha1>bp3qfnp6tzs5t53sgigrklun4y8306m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/member functions</title>
    <ns>0</ns>
    <id>12757</id>
    <revision>
      <id>71673</id>
      <parentid>71670</parentid>
      <timestamp>2014-06-19T03:06:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>extend todo</comment>
      <text xml:space="preserve" bytes="7452">{{title|Non-static member functions}}
{{cpp/language/classes/navbar}}
Non-static member functions are the functions that are declared in a {{rlp|class|member specification}} of a class without a {{rlp|static}} or {{rlp|friend}} specifier.

{{source|1=
class S {
    int mf1(); // non-static member function declaration
    void mf2() volatile, mf3() &amp;&amp;; // can be cv-qualified and reference-qualifie
    int mf4() const { return data; } // can be defined inline
    virtual void mf5() final; // can be virtual, can use final/override
    S() : data(12) {} // constructors are member functions too
    int data;
};
int S::mf1() { return 7; } // if not defined inline, has to be defined at namespace
}}

Any {{rlp|function|function declarations}} are allowed, with additional syntax elements that are only available for non-static member functions: {{rlp|final}} and {{rlp|override}} specifiers, {{rlp|abstract class|pure-specifiers}}, cv-qualifiers, ref-qualifiers, and {{rlp|initializer_list|member initialization lists}}.

A non-static member function of class X may be called
@1@ For an object of type X using the class member access operator
@2@ For an object of a class {{rlp|derived_class|derived}} from X
@3@ Directly from within the body of a member function of X
@4@ Directly from within the body of a member function of a class derived from X

Calling a member function of class X on an object of any other type invokes undefined behavior.

Within the body of a non-static member function of X, any {{rlp|expressions|id-expression}} E (e.g. an identifier) that resolves to a non-type non-static member of X or of a base class of X, is transformed to a member access expression {{c|(*this).E}} (unless it's already a part of a member access expression)
{{source|1=
struct S {
    int n;
    void f();
};
void S::f() {
    n = 1; // transformed to (*this).n = 1;
}
int main() {
    S s1, s2;
    s1.f(); // changes s1.n
}
}}

Within the body of a non-static member function of X, any unqualified-id that resolves to a static member, an enumerator or a nested type of X or of a base class of X, is transformed to the corresponding qualified-id.

{{source|1=
struct S {
    static int n;
    void f();
};
void S::f() {
    n = 1; // transformed to S::n = 1;
}
int main() {
    S s1, s2;
    s1.f(); // changes S::n
}
}}

===const-, volatile-, and ref-qualified member functions===
A non-static member function can be declared with a const, volatile, or const volatile qualifier (this qualifier appears after the name of the function in {{rlp|function|function declaration}}). Differently cv-qualified functions have different types and so may overload each other.

In the body of a cv-qualified function, the {{rlp|this}} pointer is cv-qualified, e.g. in a {{c|const}} member function, only other const member functions may be called normally. (a non-const member function may still be called if {{rlp|const_cast}} is applied or through an access path that does not involve {{rlp|this}})

{{source|1=
#include &lt;vector&gt;
struct Array {
    std::vector&lt;int&gt; data;
    Array(int sz) : data(sz) {}
    // const member function
    int operator[](int idx) const {
                          // this has type const Array*
        return data[idx]; // transformed to (*this).data[idx];
    }
    // non-const member function
    int&amp; operator[](int idx) {
                          // this has type Array*
        return data[idx]; // transformed to (*this).data[idx]
    }
};
int main()
{
    Array a(10);
    a[1] = 1; // OK: the type of a[1] is int&amp;
    const Array ca(10);
    ca[1] = 2; // Error: the type of ca[1] is int
}
}}

{{rev begin}}
{{rev|since=c++11|
A non-static member function can be declared with either an lvalue ref-qualifier (the character {{tt|&amp;}} after the function name) or rvalue ref-qualifier (the character {{tt|&amp;&amp;}} after the function name. During {{rlp|overload_resolution|overload resolution}}, non-static cv-qualified member function of class X is treated as a function that takes an implicit parameter of type lvalue reference to cv-qualified X if it has no ref-qualifiers or if it has the lvalue ref-qualifier. Otherwise (if it has rvalue ref-qualifier), it is treated as a function taking an implicit parameter of type rvalue reference to cv-qualified X.

{{source|1=#include &lt;iostream&gt;
struct S {
    void f() &amp; { std::cout &lt;&lt; &quot;lvalue\n&quot;; }
    void f() &amp;&amp;{ std::cout &lt;&lt; &quot;rvalue\n&quot;; }
};

int main(){
    S s;
    s.f();            // prints &quot;lvalue&quot;
    std::move(s).f(); // prints &quot;rvalue&quot;
    S().f();          // prints &quot;rvalue&quot;
}
}}
Note: unlike cv-qualification, ref-qualification does not change the properties of the {{rlp|this}} pointer: within a rvalue ref-qualified function, {{c|*this}} remains an lvalue expression.
}}
{{rev end}}

===Virtual and pure virtual functions===
A non-static member function may be declared ''virtual'' or ''pure virtual''. See {{rlp|virtual|virtual functions}} and {{rlp|abstract_class|abstract classes}} for details.

===Special member functions===
{{todo|probably needs its own page. Needs details on explicitly-defaulted/deleted defs. Needs details on non-default/non-copy constructors (e.g. converting), don't forget that in C++11, converting constructors can take more than one non-default argument}}
Some member functions are special: under certain circumstances they are defined by the compiler even if not defined by the user. They are:
* {{rlp|default_constructor|Default constructor}}
* {{rlp|copy_constructor|Copy constructor}}
* {{rlp|move_constructor|Move constructor}} {{mark since c++11}}
* {{rlp|as_operator|Copy assignment operator}}
* {{rlp|move_operator|Move assignment operator}} {{mark since c++11}}
* {{rlp|destructor|Destructor}}

===Example===
{{example
 |
 | code= 
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;utility&gt;
#include &lt;exception&gt;

struct S {
    int data;

    // simple converting constructor (declaration)
    S(int val);

    // simple explicit constructor (declaration)
    explicit S(std::string str);

    // const member function (definition)
    virtual int getData() const { return data; }
    
};

// definition of the constructor
S::S(int val) : data(val) {
    std::cout &lt;&lt; &quot;ctor1 called, data = &quot; &lt;&lt; data &lt;&lt; '\n';
}

// this constructor has a catch clause
S::S(std::string str) try : data(std::stoi(str)) {
    std::cout &lt;&lt; &quot;ctor2 called, data = &quot; &lt;&lt; data &lt;&lt; '\n';
} catch(const std::exception&amp;) {
    std::cout &lt;&lt; &quot;ctor2 failed, string was '&quot; &lt;&lt; str &lt;&lt; &quot;'\n&quot;;
    throw; // ctor's catch clause should always rethrow
}

struct D : S {
    int data2;
    // constructor with a default argument
    D(int v1, int v2 = 11) : S(v1), data2(v2) {}

    // virtual member function
    int getData() const override { return data*data2; }

    // lvalue-only assignment operator
    D&amp; operator=(D other) &amp; {
        std::swap(other.data, data);
        std::swap(other.data2, data2);
        return *this;
    }
};

int main()
{
    D d1 = 1;
    S s2(&quot;2&quot;);
    try {
         S s3(&quot;not a number&quot;);
    } catch(const std::exception&amp;) {}
    std::cout &lt;&lt; s2.getData() &lt;&lt; '\n';
    
   D d2(3, 4);
   d2 = d1; // OK: assignment to lvalue
//   D(5) = d1; // ERROR: no suitable overload of operator=
}
 | output=
ctor1 called, data = 1
ctor2 called, data = 2
ctor2 failed, string was 'not a number'
2
ctor1 called, data = 3
}}


===See also===
*{{rlp|classes|classes}}
*{{rlp|data_members|data members}}
*{{rlp|static|static data members}}</text>
      <sha1>ot257fhedqlo9o2f2zpi03xui1dn0sn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/member template</title>
    <ns>0</ns>
    <id>12799</id>
    <revision>
      <id>72403</id>
      <parentid>71998</parentid>
      <timestamp>2014-08-19T14:32:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+static data member template</comment>
      <text xml:space="preserve" bytes="4248">{{title|Member templates}}
{{cpp/language/templates/navbar}}
Template declarations ({{rlp|class_template|class}}, {{rlp|function_template|function}}{{rev inl|since=c++14|, and {{rlp|variable template|variables}}}}) can appear inside a {{rlp|class|member specification}} of any class, stuct, or union that aren't {{rlp|class#Local classes|local class}}

{{example|code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

struct Printer { // generic functor
    std::ostream&amp; os;
    Printer(std::ostream&amp; os) : os(os) {}
    template&lt;typename T&gt;
    void operator()(const T&amp; obj) { os &lt;&lt; obj &lt;&lt; ' '; } // member template
};

int main()
{
    std::vector&lt;int&gt; v = {1,2,3};
    std::for_each(v.begin(), v.end(), Printer(std::cout));
    std::string s = &quot;abc&quot;;
    std::for_each(s.begin(), s.end(), Printer(std::cout));
}
|output=1 2 3 a b c 
}}

If the enclosing class declaration is, in turn, a template itself, when member template is defined out of body, it takes two sets of template parameters: one for the enclosing class, and another for itself:
{{source|1=
template&lt;typename T&gt;
struct string {
    // member template function
    template&lt;typename T2&gt;
    int compare(const T2&amp;);
    // constructors can be templates too
    template&lt;typename T2&gt;
    string(const std::basic_string&lt;T2&gt;&amp; s) { /*...*/ }
};
// out of class definition of string&lt;T1&gt;::compare&lt;T2&gt; 
template&lt;typename T1&gt; // for the enclosing class template
template&lt;typename T2&gt; // for the member template
int string&lt;T1&gt;::compare(const T2&amp; s) { /* ... */ }
}}

===Member function templates===

Destructor and copy constructor cannot be templates, but other special member functions can be. If a template constructor is declared which could be instantiated with the type signature of a {{rlp|copy_constructor|copy constructor}}, the implicitly-declared copy constructor is used instead.

A member function template cannot be virtual, and a member function template in a derived class cannot override a virtual member function from the base class.
{{source|1=class Base {
    virtual void f(int);
};
struct Derived : Base {
    // this member template does not override B::f
    template &lt;class T&gt; void f(T);

    // non-member override can call the template:
    void f(int i) override {
         f&lt;&gt;(i);
    }
};
}}

A non-template member function and a template member function with the same name may be declared. In case of conflict (when some template specialization matches the non-template function signature exactly), use of that name and type refers to the non-template member unless an explicit template argument list is supplied.

{{source|1=template&lt;typename T&gt;
struct A {
    void f(int); // non-template member
    template&lt;typename T2&gt; void f(T2); // member template
};

int main()
{
    A&lt;char&gt; ac;
    ac.f('c'); // calls template function A&lt;char&gt;::f&lt;char&gt;(int)
    ac.f(1);   // calls non-template function A&lt;char&gt;::f(int)
    ac.f&lt;&gt;(1); // calls template function A&lt;char&gt;::f&lt;int&gt;(inf)
}
}}

===Conversion function templates===
A user-defined {{rlp|cast operator|conversion function}} can be a template.

{{source|1=
struct A {
    template&lt;typename T&gt;
    operator T*(); // conversion to pointer to any type
};

// out-of-class definition
template&lt;typename T&gt;
A::operator T*() {return nullptr;}

// explicit specialization for char*
template&lt;&gt;
A::operator char*() {return nullptr;}

// explicit instantiation
template A::operator void*();

int main() {
    A a;
    int* ip = a.operator int*(); // explicit call to A::operator int*()
}
}}

During {{rlp|overload_resolution|overload resolution}}, specialization of conversion function templates are not found by {{rlp|lookup|name lookup}}. Instead, all visible conversion function templates are considered, and every specialization produced by {{rlp|template argument deduction}} (which has special rules for conversion function templates) is used as if found by name lookup.

Using-declarations in derived classes cannot refer to specializations of template conversion functions from base classes.

{{rev begin}}
{{rev|since=c++14|
A variable template declaration may appear at class scope, in which case it declares a static data member template. See {{rlp|variable template}}s for details.
}}
{{rev end}}</text>
      <sha1>ge4vc1i69wliymsq1l08x3im0bu8aag</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/memory model</title>
    <ns>0</ns>
    <id>13490</id>
    <revision>
      <id>69010</id>
      <parentid>69008</parentid>
      <timestamp>2014-03-23T18:33:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link thread creation functions</comment>
      <text xml:space="preserve" bytes="3078">{{title|Memory model}}
{{cpp/language/basics/navbar}}
Defines the semantics of computer memory storage for the purpose of the C++ abstract machine.

The memory available to a C++ program is one or more contiguous sequences of ''bytes''. Each byte in memory has a unique ''address'.

===Byte===
A ''byte'' is the smallest addressable unit of memory. It is defined as a contiguous sequence of bits, large enough to hold the value of any {{tt|UTF-8}} code point and of any character in the ''execution character set''. Similar to C, C++ supports bytes of sizes 8 bits and greater.

The {{rlp|types}} {{c|char}}, {{c|unsigned char}}, and {{c|signed char}} use one byte for both storage and {{rlp|object|value representation}}. The number of bits in a byte is accessible as {{lc|CHAR_BIT}} or {{c|std::numeric_limits&lt;unsigned char&gt;::digits}}.

===Memory location===
A ''memory location'' is 
* an object of {{rlp|type|scalar type}} (arithmetic type, pointer type, enumeration type, or std::nullptr_t)
* or the largest contiguous sequence of {{rlp|bit field}}s of non-zero length

{{source|
struct S {
    char a;     // memory location #1
    int b : 5;  // memory location #2
    int c : 11, // memory location #2 (continued)
          : 0,
        d : 8;  // memory location #3
    struct {
        int ee : 8; // memory location #4
    } e;
} obj; // The object 'obj' consists of 4 separate memory locations
}}

===Threads and data races===
A thread of execution is a flow of control within a program that begins with the invocation of a top-level function by {{lc|std::thread::thread}}, {{lc|std::async}}, or other means.

Any thread can potentially access any object in the program (objects with automatic and thread-local {{rlp|storage duration}} may still be accessed by another thread through a pointer or by reference).

Different threads of execution are always allowed to access (read and modify) different ''memory locations'' concurrently, with no interference and no synchronization requirements.

When an {{rlp|eval_order|evaluation}} of an expression writes to a memory location and another evaluation reads or modifies the same memory location, the expressions are said to ''conflict''. A program that has two conflicting evaluations has a ''data race'' unless either
* both conflicting evaluations are atomic operations (see {{lc|std::atomic}})
* one of the conflicting evaluations ''happens-before'' another (see {{lc|std::memory_order}})

If a data race occurs, the behavior of the program is undefined.

(in particular, release of a {{lc|std::mutex}} is ''synchronized-with'', and therefore, ''happens-before'' acquisition of the same mutex by another thread, which makes it possible to use mutex locks to guard against data races) {{todo|small example or two}}

===Memory order===
When a thread reads a value from a memory location, it may see the initial value, the value written in the same thread, or the value written in another thread. See {{lc|std::memory_order}} for details on the order in which writes made from threads become visible to other threads.</text>
      <sha1>cta1g7yoh7c3k6f9suvu8gg2ntsz8sc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/move constructor</title>
    <ns>0</ns>
    <id>8540</id>
    <revision>
      <id>71631</id>
      <parentid>71435</parentid>
      <timestamp>2014-06-17T04:37:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>defaulted can be trivial, and also cwg 1333</comment>
      <text xml:space="preserve" bytes="8480">{{title|Move constructors}}
{{cpp/language/classes/navbar}}

A move constructor of class {{tt|T}} is a non-template constructor whose first parameter is {{c|T&amp;&amp;}}, {{c|const T&amp;&amp;}}, {{c|volatile T&amp;&amp;}}, or {{c|const volatile T&amp;&amp;}}, and either there are no other parameters, or the rest of the parameters all have default values. A type with a public move constructor is {{concept|MoveConstructible}}.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1|notes={{mark since c++11}}| {{spar|class_name}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) }} 
{{sdsc |num=2|notes={{mark since c++11}}|note={{mark since c++11}}| {{spar|class_name}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) {{=}} {{c|default;}} }}
{{sdsc |num=3|notes={{mark since c++11}}|note={{mark since c++11}}| {{spar|class_name}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) {{=}} {{c|delete;}} }}
{{sdsc end}}

===Explanation===
# Typical declaration of a move constructor
# Forcing a move constructor to be generated by the compiler
# Avoiding implicit move constructor

The move constructor is called whenever an object is initialized from [[cpp/language/value_category#xvalue|xvalue]] of the same type, which includes 
* initialization, {{c|1=T a = std::move(b);}} or {{c|1=T a(std::move(b));}}, where b is of type {{tt|T}}
* function argument passing: {{c|f(std::move(a));}}, where {{tt|a}} is of type {{tt|T}} and {{tt|f}} is {{c|void f(T t)}}
* function return: {{c|return a;}} inside a function such as {{c|T f()}}, where {{tt|a}} is of type {{tt|T}} which has a move constructor.

Move constructors typically &quot;steal&quot; the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, moving from a {{lc|std::string}} or from a {{lc|std::vector}} may result in the argument being left empty. However, this behaviour should not be relied upon.

===Implicitly-declared move constructor===
If no user-defined move constructors are provided for a class type ({{c|struct}}, {{c|class}}, or {{c|union}}), and all of the following is true:
* there are no user-declared copy constructors
* there are no user-declared copy assignment operators
* there are no user-declared move assignment operators
* there are no user-declared destructors
* {{mark until c++14}} the implicitly-declared move constructor is not defined as ''deleted'' due to conditions detailed in the next section

then the compiler will declare a move constructor as an {{tt|inline public}} member of its class with the signature {{tt|T::T(T&amp;&amp;)}} 

A class can have multiple move constructors, e.g. both {{c|T::T(const T&amp;&amp;)}} and {{c|T::T(T&amp;&amp;)}}. If some user-defined move constructors are present, the user may still force the generation of the implicitly declared move constructor with the keyword {{tt|default}}.

===Deleted implicitly-declared move constructor===
The implicitly-declared or defaulted move constructor for class {{tt|T}} is defined as ''deleted'' in any of the following is true:
* {{tt|T}} has non-static data members that cannot be moved (have deleted, inaccessible, or ambiguous move constructors)
* {{tt|T}} has direct or virtual base class that cannot be moved (has deleted, inaccessible, or ambiguous move constructors)
* {{tt|T}} has direct or virtual base class with a deleted or inaccessible destructor
* {{tt|T}} is a union and has a variant member with non-trivial copy constructor
* {{mark until c++14}}{{tt|T}} has a non-static data member or a direct or virtual base without a move constructor that is not trivially copyable.

{{mark since c++14}}The deleted implicitly-declared move constructor is ignored by {{rlp|overload resolution}} (otherwise it would prevent copy-initialization from rvalue)

===Trivial move constructor===
The move constructor for class {{tt|T}} is trivial if all of the following is true:
* The constructor is not user-provided (meaning, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
* {{tt|T}} has no virtual member functions
* {{tt|T}} has no virtual base classes
* The move constructor selected for every direct base of {{tt|T}} is trivial
* The move constructor selected for every non-static class type (or array of class type) member of {{tt|T}} is trivial
{{rev begin}}
{{rev | since=c++14 |
* {{tt|T}} has no non-static data members of {{rlp|cv|volatile}}-qualified type
}}
{{rev end}}
A trivial move constructor is a constructor that performs the same action as the trivial copy constructor, that is, makes a copy of the object representation as if by {{lc|std::memmove}}. All data types compatible with the C language (POD types) are trivially movable.

===Implicitly-defined move constructor===
If the implicitly-declared move constructor is neither deleted nor trivial, it is defined (that is, a function body is generated and compiled) by the compiler. For {{c|union}} types, the implicitly-defined move constructor copies the object representation (as by {{lc|std::memmove}}). For non-union class types ({{c|class}} and {{c|struct}}), the move constructor performs full member-wise move of the object's bases and non-static members, in their initialization order, using direct initialization with an [[cpp/language/value_category#xvalue|xvalue]] argument.

===Notes===
To make strong exception guarantee possible, user-defined move constructors should not throw exceptions. In fact, standard containers typically rely on {{lc|std::move_if_noexcept}} to choose between move and copy when container elements need to be relocated.

If both copy and move constructors are provided, overload resolution selects the move constructor if the argument is an ''rvalue'' (either ''prvalue'' such as a nameless temporary or ''xvalue'' such as the result of {{lc|std::move}}), and selects the copy constructor if the argument is ''lvalue'' (named object or a function/operator returning lvalue reference). If only the copy constructor is provided, all argument categories select it (as long as it takes reference to const, since rvalues can bind to const references), which makes copying the fallback for moving, when moving is unavailable.

In many situations, move constructors are optimized out even if they would produce observable side-effects, see [[cpp/language/copy_elision|copy elision]]

A constructor is called a 'move constructor' when it takes an rvalue reference as a parameter. It is not obligated to move anything, the class is not required to have a resource to be moved and a 'move constructor' may not be able to move a resource as in the allowable (but maybe not sensible) case where the parameter is a const rvalue reference (const T&amp;&amp;).

===Example===
{{example
| code=
#include &lt;string&gt;
#include &lt;iostream&gt;

struct A {
    std::string s;
    A() : s(&quot;test&quot;) {}
    A(const A&amp; o) : s(o.s) { std::cout &lt;&lt; &quot;move failed!\n&quot;;}
    A(A&amp;&amp; o) : s(std::move(o.s)) {}
};

A f(A a) {
    return a;
}

struct B : A {
     std::string s2; 
     int n;
     // implicit move contructor B::(B&amp;&amp;)
     // calls A's move constructor
     // calls s2's move constructor
     // and makes a bitwise copy of n
};

struct C : B {
    ~C() {}; // destructor prevents implicit move ctor C::(C&amp;&amp;)
};

struct D : B {
    D() {}
    ~D() {}; // destructor would prevent implicit move ctor D::(D&amp;&amp;)
    D(D&amp;&amp;) = default; // force a move ctor anyway
};

int main()
{
    std::cout &lt;&lt; &quot;Trying to move A\n&quot;;
    A a1 = f(A()); // move-construct from rvalue temporary
    A a2 = std::move(a1); // move-construct from xvalue

    std::cout &lt;&lt; &quot;Trying to move B\n&quot;;
    B b1;
    std::cout &lt;&lt; &quot;Before move, b1.s = \&quot;&quot; &lt;&lt; b1.s &lt;&lt; &quot;\&quot;\n&quot;;
    B b2 = std::move(b1); // calls implicit move ctor
    std::cout &lt;&lt; &quot;After move, b1.s = \&quot;&quot; &lt;&lt; b1.s &lt;&lt; &quot;\&quot;\n&quot;;

    std::cout &lt;&lt; &quot;Trying to move C\n&quot;;
    C c1;
    C c2 = std::move(c1); // calls the copy constructor

    std::cout &lt;&lt; &quot;Trying to move D\n&quot;;
    D d1;
    D d2 = std::move(d1);
}
| output=
Trying to move A
Trying to move B
Before move, b1.s = &quot;test&quot;
After move, b1.s = &quot;&quot;
Trying to move C
move failed!
Trying to move D
}}

[[de:cpp/language/move constructor]]
[[es:cpp/language/move constructor]]
[[fr:cpp/language/move constructor]]
[[it:cpp/language/move constructor]]
[[ja:cpp/language/move constructor]]
[[pt:cpp/language/move constructor]]
[[ru:cpp/language/move constructor]]
[[zh:cpp/language/move constructor]]</text>
      <sha1>pmjil42k4raxryq00pel59vlp4ia95u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/move operator</title>
    <ns>0</ns>
    <id>9134</id>
    <revision>
      <id>71633</id>
      <parentid>71437</parentid>
      <timestamp>2014-06-17T04:38:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>defaulted can be trivial, and also cwg 1333</comment>
      <text xml:space="preserve" bytes="9960">{{title|Move assignment operator}}
{{cpp/language/classes/navbar}}

A move assignment operator of class {{tt|T}} is a non-template non-static member function with the name {{c|operator{{=}}}} that takes exactly one parameter of type {{c|T&amp;&amp;}}, {{c|const T&amp;&amp;}}, {{c|volatile T&amp;&amp;}}, or {{c|const volatile T&amp;&amp;}}. A type with a public move assignment operator is {{concept|MoveAssignable}}.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1|notes={{mark since c++11}}| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) }} 
{{sdsc |num=2|notes={{mark since c++11}}|note={{mark since c++11}}| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) {{=}} {{c|default;}} }}
{{sdsc |num=3|notes={{mark since c++11}}|note={{mark since c++11}}| {{spar|class_name}} {{ttb|&amp;}} {{spar|class_name}} {{ttb|:: operator{{=}}}} ( {{spar|class_name}} {{tt|&amp;&amp;}} ) {{=}} {{c|delete;}} }}
{{sdsc end}}

===Explanation===
# Typical declaration of a move assignment operator
# Forcing a move assignment operator to be generated by the compiler
# Avoiding implicit move assignment

The move assignment operator is called whenever it is selected by [[cpp/language/overload_resolution|overload resolution]], e.g. when an object appears on the left side of an assignment expression, where the right-hand side is an rvalue of the same or implicitly convertible type.

Move assignment operators typically &quot;steal&quot; the resources held by the argument (e.g. pointers to dynamically-allocated objects, file descriptors, TCP sockets, I/O streams, running threads, etc), rather than make copies of them, and leave the argument in some valid but otherwise indeterminate state. For example, move-assigning from a {{lc|std::string}} or from a {{lc|std::vector}} leaves the right-hand side argument empty.

===Implicitly-declared move assignment operator===
If no user-defined move assignment operators are provided for a class type ({{c|struct}}, {{c|class}}, or {{c|union}}), and all of the following is true:
* there are no user-declared copy constructors
* there are no user-declared move constructors
* there are no user-declared copy assignment operators
* there are no user-declared destructors
* {{mark until c++14}} the implicitly-declared move assignment operator would not be defined as deleted
then the compiler will declare a move assignment operator as an {{tt|inline public}} member of its class with the signature {{tt|T&amp; T::operator{{=}} (T&amp;&amp;)}} 

A class can have multiple move assignment operators, e.g. both {{c|1=T&amp; T::operator=(const T&amp;&amp;)}} and {{c|1=T&amp; T::operator=(T&amp;&amp;)}}. If some user-defined move assignment operators are present, the user may still force the generation of the implicitly declared move assignment operator with the keyword {{tt|default}}.

Because some assignment operator (move or copy) is always declared for any class, the base class assignment operator is always hidden. If a using-declaration is used to bring in the assignment operator from the base class, and its argument type could be the same as the argument type of the implicit assignment operator of the derived class, the using-declaration is also hidden by the implicit declaration.

===Deleted implicitly-declared move assignment operator===
The implicitly-declared or defaulted move assignment operator for class {{tt|T}} is defined as ''deleted'' in any of the following is true:
* {{tt|T}} has a non-static data member that is {{c|const}}
* {{tt|T}} has a non-static data member of a reference type.
* {{tt|T}} has a non-static data member that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
* {{tt|T}} has direct or virtual base class that cannot be move-assigned (has deleted, inaccessible, or ambiguous move assignment operator)
* {{mark until c++14}} {{tt|T}} has a non-static data member or a direct or virtual base without a move assignment operator that is not trivially copyable.
* {{mark until c++14}} {{tt|T}} has a direct or indirect virtual base class

{{mark since c++14}} A deleted implicitly-declared move assignment operator is ignored by {{rlp|overload resolution}}

===Trivial move assignment operator===
The move assignment operator for class {{tt|T}} is trivial if all of the following is true:
* The operator is not user-provided (meaning, it is implicitly-defined or defaulted), and if it is defaulted, its signature is the same as implicitly-defined
* {{tt|T}} has no virtual member functions
* {{tt|T}} has no virtual base classes
* The move assignment operator selected for every direct base of {{tt|T}} is trivial
* The move assignment operator selected for every non-static class type (or array of class type) member of {{tt|T}} is trivial
{{rev begin}}
{{rev | since=c++14 |
* {{tt|T}} has no non-static data members of {{rlp|cv|volatile}}-qualified type
}}
{{rev end}}
A trivial move assignment operator performs the same action as the trivial copy assignment operator, that is, makes a copy of the object representation as if by {{lc|std::memmove}}. All data types compatible with the C language (POD types) are trivially move-assignable.

===Implicitly-defined move assignment operator===
If the implicitly-declared move assignment operator is not deleted or trivial, it is defined (that is, a function body is generated and compiled) by the compiler.

For {{c|union}} types, the implicitly-defined move assignment operator copies the object representation (as by {{lc|std::memmove}}).

For non-union class types ({{c|class}} and {{c|struct}}), the move assignment operator performs full member-wise move assignment of the object's direct bases and immediate non-static members, in their declaration order, using built-in assignment for the scalars, memberwise move-assignment for arrays, and move assignment operator for class types (called non-virtually).

{{rev begin}}
{{rev|since=c++14|
As with copy assignment, it is unspecified whether virtual base class subobjects that are accessible through more than one path in the inheritance lattice, are assigned more than once by the implicitly-defined move assignment operator:
{{source|1=
struct V {
    V&amp; operator=(V&amp;&amp; other) {
        // this may be called once or twice. 
        // if called twice, 'other' is the just-moved-from V subobject
        return *this;
    }
};
struct A : virtual V { }; // operator= calls V::operator=
struct B : virtual V { }; // operator= calls V::operator=
struct C : B, A { }; // operator= calls B::operator=, then A::operator=
                     // but they may only called V::operator= once

int main()
{
  C c1, c2;
  c2 = std::move(c1);
}
}}
}}
{{rev end}}

===Notes===
If both copy and move assignment operators are provided, overload resolution selects the move assignment if the argument is an [[cpp/language/value_category|''rvalue'']] (either ''prvalue'' such as a nameless temporary or ''xvalue'' such as the result of {{lc|std::move}}), and selects the copy assignment if the argument is ''lvalue'' (named object or a function/operator returning lvalue reference). If only the copy assignment is provided, all argument categories select it (as long as it takes its argument by value or as reference to const, since rvalues can bind to const references), which makes copy assignment the fallback for move assignment, when move is unavailable.

The copy-and-swap assignment operator

{{c|1=T&amp; T::operator=(T arg) {
    swap(arg);
    return *this;
}
}}

performs an equivalent of move assignment for rvalue arguments at the cost of one additional call to the move constructor of T, which is often acceptable.

===Example===
{{example
| code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;

struct A {
    std::string s;
    A() : s(&quot;test&quot;) {}
    A(const A&amp; o) : s(o.s) { std::cout &lt;&lt; &quot;move failed!\n&quot;;}
    A(A&amp;&amp; o) : s(std::move(o.s)) {}
    A&amp; operator=(const A&amp;) { std::cout &lt;&lt; &quot;copy assigned\n&quot;; return *this; }
    A&amp; operator=(A&amp;&amp; other) {
         s = std::move(other.s);
         std::cout &lt;&lt; &quot;move assigned\n&quot;;
         return *this;
    }
};

A f(A a) { return a; }

struct B : A {
     std::string s2; 
     int n;
     // implicit move assignment operator B&amp; B::operator=(B&amp;&amp;)
     // calls A's move assignment operator
     // calls s2's move assignment operator
     // and makes a bitwise copy of n
};

struct C : B {
    ~C() {}; // destructor prevents implicit move assignment
};

struct D : B {
    D() {}
    ~D() {}; // destructor would prevent implicit move assignment
    D&amp; operator=(D&amp;&amp;) = default; // force a move assignment anyway 
};

int main()
{
    A a1, a2;
    std::cout &lt;&lt; &quot;Trying to move-assign A from rvalue temporary\n&quot;;
    a1 = f(A()); // move-assignment from rvalue temporary
    std::cout &lt;&lt; &quot;Trying to move-assign A from xvalue\n&quot;;
    a2 = std::move(a1); // move-assignment from xvalue

    std::cout &lt;&lt; &quot;Trying to move-assign B\n&quot;;
    B b1, b2;
    std::cout &lt;&lt; &quot;Before move, b1.s = \&quot;&quot; &lt;&lt; b1.s &lt;&lt; &quot;\&quot;\n&quot;;
    b2 = std::move(b1); // calls implicit move assignment
    std::cout &lt;&lt; &quot;After move, b1.s = \&quot;&quot; &lt;&lt; b1.s &lt;&lt; &quot;\&quot;\n&quot;;

    std::cout &lt;&lt; &quot;Trying to move-assign C\n&quot;;
    C c1, c2;
    c2 = std::move(c1); // calls the copy assignment operator

    std::cout &lt;&lt; &quot;Trying to move-assign D\n&quot;;
    D d1, d2;
    d2 = std::move(d1);
}
| output=
Trying to move-assign A from rvalue temporary
move assigned
Trying to move-assign A from xvalue
move assigned
Trying to move-assign B
Before move, b1.s = &quot;test&quot;
move assigned
After move, b1.s = &quot;&quot; &lt;!-- note, gcc 4.7.1 still prints &quot;test&quot;, clang 3.1 works --&gt;
Trying to move-assign C
copy assigned
Trying to move-assign D
move assigned
}}

[[de:cpp/language/move operator]]
[[es:cpp/language/move operator]]
[[fr:cpp/language/move operator]]
[[it:cpp/language/move operator]]
[[ja:cpp/language/move operator]]
[[pt:cpp/language/move operator]]
[[ru:cpp/language/move operator]]
[[zh:cpp/language/move operator]]</text>
      <sha1>j7c0vixswfwzky19gkzvim8i5cm7wmj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/name</title>
    <ns>0</ns>
    <id>13179</id>
    <redirect title="cpp/language/identifiers" />
    <revision>
      <id>67970</id>
      <parentid>67956</parentid>
      <timestamp>2014-03-10T14:26:01Z</timestamp>
      <contributor>
        <ip>60.55.10.139</ip>
      </contributor>
      <comment>Redirected page to [[cpp/language/identifiers#Names]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/language/identifiers#Names]]</text>
      <sha1>jr6rbdgtw2cmwdp893rwexjbs3zuzww</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/namespace</title>
    <ns>0</ns>
    <id>5741</id>
    <revision>
      <id>72298</id>
      <parentid>71677</parentid>
      <timestamp>2014-08-05T22:27:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix terminology</comment>
      <text xml:space="preserve" bytes="19550">{{title|Namespaces}}
{{cpp/language/declarations/navbar}}

Namespaces provide a method for preventing name conflicts in large projects.

Symbols declared inside a namespace block are placed in a named scope that prevents them from being mistaken for identically-named symbols in other scopes.

Multiple declarations of namespaces with the same name are allowed, resulting in a namespace including all symbols from all such declarations.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1|
{{ttb|namespace}} {{spar|ns_name}} { {{spar|declarations}} }
}}
{{sdsc |num=2|notes={{mark since c++11}}|
  {{ttb|inline}} {{ttb|namespace}} {{spar|ns_name}} { {{spar|declarations}} }
}}
{{sdsc |num=3|
{{ttb|namespace}} { {{spar|declarations}} }
}}
{{sdsc |num=4|
{{spar|ns_name}}{{ttb|::}}{{spar|name}}
}}
{{sdsc |num=5|
{{ttb|using}} {{ttb|namespace}} {{spar|ns_name}}{{ttb|;}}
}}
{{sdsc |num=6|
{{ttb|using}} {{spar|ns_name}}{{ttb|::}}{{spar|name}}{{ttb|;}}
}}
{{sdsc | num=7|
{{ttb|namespace}} {{spar|name}} {{ttb|{{=}}}} {{spar|qualified-namespace}} {{ttb|;}}
}}
{{sdsc end}}

@1@ {{rlp|namespace#Namespaces|Namespace definition}} for the namespace {{spar|ns_name}}.
@2@ {{rlp|namespace#Inline_namespaces|Inline namespace definition}} for the namespace {{spar|ns_name}}. Declarations inside {{spar|ns_name}} will be visible in its enclosing namespace.
@3@ {{rlp|namespace#Unnamed_namespaces|Unnamed namespace definition}}. Its members have potential scope from their point of declaration to the end of the translation unit, and have {{rlp|storage duration|internal linkage}}.
@4@ Namespace names (along with class names) can appear on the left hand side of the scope resolution operator, as part of {{rlp|lookup|qualified name lookup}}.
@5@ {{rlp|namespace#Using-directives|using-directive}}: From the point of view of unqualified {{rlp|lookup|name lookup}} of any name after a using-directive and until the end of the scope in which it appears, every name from {{spar|namespace-name}} is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive and {{spar|namespace-name}}.
@6@ {{rlp|namespace#Using-declarations|using-declaration}}: makes the symbol {{spar|name}} from the namespace {{spar|ns_name}} accessible for {{rlp|lookup|unqualified lookup}} as if declared in the same namespace as where this using-declaration appears.
@7@ {{spar|namespace-alias-definition}}: makes {{spar|name}} a synonym for another namespace: see {{rlp|namespace alias}}

===Explanation===
====Namespaces====
{{sdsc begin}}
{{sdsc|1=
{{ttb|inline}}{{mark optional}} {{ttb|namespace}} {{spar|identifier}} {{ttb|{ }} {{spar|namespace-body}} {{ttb|} }} }}
{{sdsc end}}
{{par begin}}
{{par | {{tt|inline}} | if present, makes this an inline namespace (see below). Cannot appear on the ''extension-namespace-definition'' if the ''original-namespace-definition'' did not use {{tt|inline}} }}
{{par | {{spar|identifier}} | either a previously unused identifier, in which case this is ''original-namespace-definition'' or the name of a namespace, in which case this is ''extension-namespace-definition''}}
{{par | {{spar|namespace-body}} | possibly empty sequence of {{rlp|declarations}} of any kind (including class and function definitions as well as nested namespaces) }}
{{par end}}

Namespace definitions are only allowed at namespace scope, including the global scope.

The {{spar|namespace-body}} defines a {{rlp|scope|namespace scope}}, which affects {{rlp|lookup|name lookup}}.

All names introduced by the declarations that appear within {{spar|namespace-body}} (including nested namespace definitions) become members of the namespace {{spar|identifier}}, whether this namespace definition is the original namespace definition (which introduced {{spar|identifier}}), or an extension namespace definition (which &quot;reopened&quot; the already defined namespace)

A namespace member that was declared within a namespace body may be defined outside of it using explicit qualification
{{source|1=
namespace Q {
  namespace V { // V is a member of Q, and is fully defined within Q
    class C { void m(); }; // C is a member of V and is fully defined within V
                           // C::m is only declared
    void f(); // f is a member of V, but is only declared here
  }
  void V::f() // definition of V's member f outside of V
              // f's enclosing namespaces are still the global namespace, Q, and Q::V
  {
      extern void h(); // This declares ::Q::V::h
  }
  void V::C::m() // definition of V::C::m outside of the namespace (and the class body)
                 // enclosing namespaces are the global namespace, Q, and Q::V
  {
  }
}
}}

Out-of-namespace definitions are only allowed after the point of declaration, and only in the namespaces that enclose the original namespace (including the global namespace)

{{source|1=
namespace Q {
  namespace V { // original-namespace-definition for V
    void f(); // declaration of Q::V::f
  }
  void V::f() {} // OK
  void V::g() {} // Error: g() is not yet a member of V
  namespace V { // extension-namespace-definition for V
    void g(); // declaration of Q::V::g
  }
}
namespace R { // not a enclosing namespace for Q
   void Q::V::g() {} // Error: cannot define Q::V::g inside R
}
void Q::V::g() {} // OK: global namespace encloses Q
}}

Names introduced by {{rlp|friend}} declarations within a non-local class X become members of the innermost enclosing namespace of X, but they do not become visible to {{rlp|lookup}} (neither unqualified nor qualified) unless a matching declaration is provided at namespace scope, either before or after the class definition. Such name may be found through {{rlp|adl|ADL}} which considers both namespaces and classes.

Only the innermost enclosing namespace is considered by such friend declaration when deciding whether the name would conflict with a peviously declared name.

{{source|1=
void h(int);
namespace A {
  class X {
    friend void f(X); // A::f is a friend
    class Y {
        friend void g(); // A::g is a friend
        friend void h(int); // A::h is a friend, no conflict with ::h
    };
  };
  // A::f, A::g and A::h are not visible at namespace scope
  // even though they are members of the namespace A
  X x;
  void g() {  // definition of A::g
     f(x); // A::X::f is found through ADL
  }
  void f(X) {}       // definition of A::f
  void h(int) {}     // definition of A::h
  // A::f, A::g and A::h are now visible at namespace scope
  // and they are also friends of A::X and A::X::Y
}
}}

{{rev begin}}
{{rev|since=c++11|
====Inline namespaces====
An inline namespace is a namespace that uses the optional keyword {{tt|inline}} in its ''original-namespace-definition''. 

Members of an inline namespace are treated as if they are members of the enclosing namespace in many situations (listed below). This property is transitive: if a namespace N contains an inline namespace M, which in turn contains an inline namespace O, then the members of O can be used as though they were members of M or N. 

* A ''using-directive'' that names the inline namespace is implicitly inserted in the enclosing namespace (similar to the implicit using-directive for the unnamed namespace)
* In {{rlp|adl|argument-dependent lookup}}, when a namespace is added to the set of associated namespaces, its inline namespaces are added as well, and if an inline namespace is added to the list of associated namespaces, its enclosing namespace is added as well.
* Each member of an inline namespace can be explicitly instantiated or explicitly specialized as if it were a member of the enclosing namespace.
* Qualified {{rlp|lookup|name lookup}} that examines the enclosing namespace will include the names from the inline namespaces even if the same name is present in the enclosing namespace.

{{source|1=
{ // in C++14, std::literals and its member namespaces are inline
   using namespace std::string_literals; // makes visible operator&quot;&quot;s 
                                         // from std::literals::string_literals
   auto str = &quot;abc&quot;s;
}
{
   using namespace std::literals; // makes visible both
                                  // std::literals::string_literals::operator&quot;&quot;s
                                  // and std::literals::chrono_literals::operator&quot;&quot;s
   auto str = &quot;abc&quot;s;
   auto min = 60s;
}
{
   using std::operator&quot;&quot;s; // makes both std::literals::string_literals::operator&quot;&quot;s
                           // and std::literals::chrono_literals::operator&quot;&quot;s visible
   auto str = &quot;abc&quot;s;
   auto min = 60s;
}
}}

Note: the rule about specializations allows library versioning: different implementations of a library template may be defined in different inline namespaces, while still allowing the user to extend the parent namespace with an explicit specialization of the primary template.
}}
{{rev end}}

====Unnamed namespaces====
The ''unnamed-namespace-definition'' is a namespace definition of the form
{{sdsc begin}}
{{sdsc|1=
{{ttb|inline}}{{mark optional}} {{ttb|namespace}} {{ttb|{ }} {{spar|namespace-body}} {{ttb|} }} }}
{{sdsc end}}

This definition is treated as a definition of a namespace with unique name and a ''using-directive'' in the current scope that nominates this unnamed namespace.

{{source|
namespace {
    int i;  // defines ::(unique)::i
}
void f() {
    i++;  // increments ::(unique)::i
}

namespace A {
    namespace {
        int i; // A::(unique)::i
        int j; // A::(unique)::j
    }
    void g() { i++; } // A::unique::i++
}

using namespace A; // introduces all names from A into global namespace
void h() {
    i++;    // error: ::(unique)::i and ::A::(unique)::i are both in scope
    A::i++; // ok, increments ::A::(unique)::i
    j++;    // ok, increments ::A::(unique)::j
}
}}

Unnamed namespaces as well as all namespaces declared directly or indirectly within an unnamed namespace have {{rlp|storage_duration#Linkage|internal linkage}}, which means that any name that is declared within an unnamed namespace has internal linkage by default. Even if some name in an unnamed namespace is declared with external linkage (e.g. with {{tt|extern}}), it is never accessible from other translation units because its namespace name is unique.

====Using-declarations====
Introduces a name that is defined elsewhere into the declarative region where this using-declaration appears.

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|using}} {{ttb|typename}}{{mark optional}} {{spar|nested-name-specifier}} {{spar|unqualified-id}} {{ttb|;}}
}}
{{sdsc|num=2|1=
{{ttb|using}} {{ttb|::}} {{spar|unqualified-id}} {{ttb|;}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|nested-name-specifier}} | a sequence of names and scope resolution operators {{tt|::}}, ending with a scope resolution operator. A single {{tt|::}} refers to the global namespace.}}
{{par | {{spar|unqualified-id}} | an {{rlp|identifiers|id-expression}} }}
{{par | {{spar|typename}} | the keyword {{tt|typename}} may be used as necessary to resolve {{rlp|dependent_name|dependent names}}, when the using-declaration introduces a member type from a base class into a class template}}
{{par end}}

Using-declarations can be used to introduce namespace members into other namespaces and block scopes, or to introduce base class members into derived class definitions.

For the use in derived class definitions, see {{rlp|using declaration}}.

Names introduced into a namespace scope by a using-declaration can be used just like any other names, including qualified lookup from other scopes:
{{source|1=
void f();
namespace A {
    void g();
}
namespace X {
    using ::f; // global f is now visible as ::X::f
    using A::g; // A::g is now visilbe as ::X::g
}
void h()
{
    X::f(); // calls ::f
    X::g(); // calls A::g
}
}}

If, after the using-declaration was used to take a member from a namespace, the namespace is extended and additional declarations for the same name are introduced, those additional declarations do not become visible through the using-declaration (in contrast with using-directive). One exception is when a using-declaration names a class template: partial specializations introduced later are effectively visible, because their {{rlp|lookup}} proceeds through the primary template.
{{source|1=
namespace A {
    void f(int);
}
using A::f; // ::f is now a synonym for A::f(int)

namespace A { // namespace extension
   void f(char); // does not change what ::f means
}
void foo() {
    f(’a’); // calls f(int), even though f(char) exists.
} 
void bar() {
   using A::f; // this f is a synonym for both A::f(int) and A::f(char)
   f(’a’); // calls f(char)
}
}}

Using-declarations cannot name template-id, namespace, or a scoped enumerator. Each using-declaration introduces one and only one name, for example using-declaration for an {{rlp|enum|enumeration}} does not introduce any of its enumerators.

All restrictions on regular declarations of the same names, hiding, and overloading rules apply to using-declarations:

{{source|1=
namespace A {
    int x;
}
namespace B {
    int i;
    struct g { };
    struct x { };
    void f(int);
    void f(double);
    void g(char); // OK: function name g hides struct g
}
void func() {
    int i;
    using B::i; // error: i declared twice

    void f(char);
    using B::f; // OK: f(char), f(int), f(double) are overloads
    f(3.5); // calls B::f(double)

    using B::g;
    g(’a’);      // calls B::g(char)
    struct g g1; // declares g1 to have type struct B::g

    using B::x;
    using A::x;  // OK: hides struct B::x
    x = 99;      // assigns to A::x
    struct x x1; // declares x1 to have type struct B::x
}
}}

If a function was introduced by a using-declaration, declaring a function with the same name and parameter list is ill-formed (unless the declaration is for the same function). If a function template was introduced by a using-declaration, declaring a function template with the same name, parameter type list, return type, and template parameter list is ill-formed.
Two using-declarations can introduce functions with the same name and parameter list, but if a call to that function is attempted, the program is ill-formed. 

{{source|1=
namespace B {
    void f(int);
    void f(double);
}
namespace C {
    void f(int);
    void f(double);
    void f(char);
}
void h() {
    using B::f; // introduces B::f(int), B::f(double)
    using C::f; // introduces C::f(int), C::f(double), and C::f(char)
    f(’h’);      // calls C::f(char)
    f(1);        // error: B::f(int) or C::f(int)?
    void f(int); // error: f(int) conflicts with C::f(int) and B::f(int)
}
}}

====Using-directives====
A ''using-directive'' is a {{rlp|declarations|block-declaration}} with the following syntax:
{{sdsc begin}}
{{sdsc |num=1|
{{spar|attr}}{{mark optional}} {{ttb|using}} {{ttb|namespace}} {{spar|nested-name-specifier}}{{mark optional}} {{spar|namespace-name}} {{ttb|;}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} that apply to this using-directive}}
{{par | {{spar|nested-name-specifier}} | a sequence of names and scope resolution operators {{tt|::}}, ending with a scope resolution operator. A single {{tt|::}} refers to the global namespace.}}
{{par | {{spar|namespace-name}} | a name of a namespace. When looking up this name, {{rlp|lookup}} considers namespace declarations only}}
{{par end}}

Using-directives are allowed only in namespace {{rlp|scope}} and in block scope. From the point of view of unqualified {{rlp|lookup|name lookup}} of any name after a using-directive and until the end of the scope in which it appears, every name from {{spar|namespace-name}} is visible as if it were declared in the nearest enclosing namespace which contains both the using-directive and {{spar|namespace-name}}.

Using-directive does not add any names to the declarative region in which it appears (unlike the using-declaration), and thus does not prevent identical names from being declared.

Using-directives are transitive for the purposes of {{rlp|lookup|unqualified lookup}}: if a scope contains a using-directive that nominates a {{spar|namespace-name}}, which itself contains using-directive for some {{spar|namespace-name-2}}, the effect is as if the using directives from the second namespace appear within the first. The order in which these transitive namespaces occur does not influence name lookup.
{{source|1=
namespace A {
    int i;
}
namespace B {
    int i;
    int j;
    namespace C {
        namespace D {
            using namespace A; // all names from A injected into global namespace
            int j;
            int k;
            int a = i; // i is B::i, because A::i is hidden by B::i
        }
        using namespace D; // names from D are injected into C
                           // names from A are injected into global namespace
        int k = 89; // OK to declare name identical to one introduced by a using
        int l = k;  // ambiguous: C::k or D::k
        int m = i;  // ok: B::i hides A::i
        int n = j;  // ok: D::j hides B::j
    }
}
}}

If, after a using-directive was used to nominate some namespace, the namespace is extended an additional members and/or using-directives are added to it, those additional members and the additional namespaces are visible through the using-directive (in contrast with using-declaration)

{{source|
namespace D {
   int d1;
   void f(char);
}
using namespace D; // introduces D::d1, D::f, D::d2, D::f,
                   //  E::e, and E::f into global namespace!

int d1; // OK: no conflict with D::d1 when declaring
namespace E {
    int e;
    void f(int);
}
namespace D { // namespace extension
    int d2;
    using namespace E; // transitive using-directive
    void f(int);
}
void f() {
    d1++; // error: ambiguous ::d1 or D::d1?
    ::d1++; // OK
    D::d1++; // OK
    d2++; // OK, d2 is D::d2
    e++; // OK: e is E::e due to transitive using
    f(1); // error: ambiguous: D::f(int) or E::f(int)?
    f(’a’); // OK: the only f(char) is D::f(char)
}
}}

===Notes===
The using-directive {{tt|using namespace std;}} at any namespace scope introduces every name from the namespace {{tt|std}} into the global namespace (since the global namespace is the nearest namespace that contains both {{tt|std}} and any user-declared namespace), which may lead to undesirable name collisions. This, and other using directives are generally considered bad practice at file scope of a header file&lt;!-- TODO: reference to Sutter/Alexandrescu's book--&gt;.

===Example===

{{example
 | This example shows how to use a namespace to create a class that already has been named in the {{tt|std}} namespace. 
 | code=
#include &lt;vector&gt;

namespace vec {

    template&lt; typename T &gt;
    class vector {
        // ...
    };

} // of vec

int main()
{
    std::vector&lt;int&gt; v1; // Standard vector.
    vec::vector&lt;int&gt; v2; // User defined vector.

    v1 = v2; // Error: v1 and v2 are different object's type.

    {
        using namespace std;
        vector&lt;int&gt; v3; // Same as std::vector
        v1 = v3; // OK
    }

    {
        using vec::vector;
        vector&lt;int&gt; v4; // Same as vec::vector
        v2 = v4; // OK
    }
        
    return 0;
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc namespace_alias}}
{{dsc end}}

[[de:cpp/language/namespace]]
[[es:cpp/language/namespace]]
[[fr:cpp/language/namespace]]
[[it:cpp/language/namespace]]
[[ja:cpp/language/namespace]]
[[pt:cpp/language/namespace]]
[[ru:cpp/language/namespace]]
[[zh:cpp/language/namespace]]</text>
      <sha1>jnfqids4o8ylgl41rztaxszqn4gpj58</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/namespace alias</title>
    <ns>0</ns>
    <id>8401</id>
    <revision>
      <id>67707</id>
      <parentid>58021</parentid>
      <timestamp>2014-02-21T19:11:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="1483">{{title|Namespace aliases}}
{{cpp/language/declarations/navbar}}

Namespace aliases allow the programmer to define an alternate name for a namespace.  

They are commonly used as a convenient shortcut for long or deeply-nested namespaces.

===Syntax===
{{sdsc begin}}
{{sdsc |num=1|
{{ttb|namespace}} {{spar|alias_name}} {{=}} {{spar|ns_name}}{{ttb|;}}
}}
{{sdsc |num=2|
{{ttb|namespace}} {{spar|alias_name}} {{=}} {{ttb|::}}{{spar|ns_name}}{{ttb|;}} 
}}
{{sdsc |num=3|
{{ttb|namespace}} {{spar|alias_name}} {{=}} {{spar|nested_name}}{{ttb|::}}{{spar|ns_name}}{{ttb|;}}
}}
{{sdsc end}}

===Explanation===

The new alias {{spar|alias_name}} provides an alternate method of accessing {{spar|ns_name}}.  

{{spar|alias_name}} must be a name not previously used.  {{spar|alias_name}} is valid for the duration of the scope in which it is introduced.

===Example===

{{example
 | code=
#include &lt;iostream&gt;
 
namespace foo {
    namespace bar {
         namespace baz {
             int qux = 42;
         }
    }
}
 
namespace fbz = foo::bar::baz;
 
int main()
{
    std::cout &lt;&lt; fbz::qux &lt;&lt; '\n';
}
 | output=
42
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc namespace}}
{{dsc end}}

[[de:cpp/language/namespace alias]]
[[es:cpp/language/namespace alias]]
[[fr:cpp/language/namespace alias]]
[[it:cpp/language/namespace alias]]
[[ja:cpp/language/namespace alias]]
[[pt:cpp/language/namespace alias]]
[[ru:cpp/language/namespace alias]]
[[zh:cpp/language/namespace alias]]</text>
      <sha1>inxo7hnsmnrp99ni06gbj9eglwn0iyx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/nested classes</title>
    <ns>0</ns>
    <id>13548</id>
    <redirect title="cpp/language/nested types" />
    <revision>
      <id>70460</id>
      <timestamp>2014-05-23T11:13:33Z</timestamp>
      <contributor>
        <ip>115.231.76.55</ip>
      </contributor>
      <comment>Redirected page to [[cpp/language/nested types]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/language/nested_types]]</text>
      <sha1>0cteqy5peydoecvf4aqtfxva3z1iex3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/nested types</title>
    <ns>0</ns>
    <id>13013</id>
    <revision>
      <id>70392</id>
      <parentid>69714</parentid>
      <timestamp>2014-05-21T19:02:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>&quot;nested classes&quot; per talk (other nested types are described in cpp/language/class#Member_specification )</comment>
      <text xml:space="preserve" bytes="3779">{{title|nested classes}}
{{cpp/language/classes/navbar}}

A declaration of a {{rlp|class|class/struct}} or {{rlp|union}} may appear in within another class. Such declaration declares a ''nested class''

===Explanation===
The name of the nested class exists in the scope of the enclosing class, and name lookup from a member function of a nested class visits the scope of the enclosing class after examining the scope of the nested class. As any member of its enclosing class, nested class has access to all names (private, protected, etc) to which the enclosing class has access, but it is otherwise independent and has no special access to the {{rlp|this}} pointer of the enclosing class.
{{rev begin}}
{{rev|until=c++11|Declarations in a nested class can use only type names, static members, and enumerators from the enclosing class
}}
{{rev|since=c++11|
Declarations in a nested class can use any members of the enclosing class, following the {{rlp|data members#Usage|usual usage rules}} for the non-static members.
}}
{{rev end}}

{{source|1=
int x,y; // globals
class enclose { // enclosing class
    int x; // note: private members
    static int s;
 public:
    struct inner { // nested class
        void f(int i) {
            x = i; // Error: can't write to non-static enclose::x without instance
            int a = sizeof x; // Error until C++11,
                              // OK in C++11: operand of sizeof is unevaluated,
                              // this use of the non-static enclose::x is allowed.
            s = i;   // OK: can assign to the static enclose::s
            ::x = i; // OK: can assign to global x
            y = i;   // OK: can assign to global y
        }
        void g(enclose* p, int i) {
            p-&gt;x = i; // OK: assign to enclose::x
        }
    };
};
}}

A {{rlp|friend}} functions defined within a nested class has no special access to the members of the enclosing class even if lookup from the body of a name function that is defined within a nested class can find the private members of the enclosing class.

Out-of-class definitions of the members of a nested class appear in the namespace of the enclosing class:

{{source|1=
struct enclose {
    struct inner {
        static int x;
        void f(int i);
    };
};
int enclose::inner::x = 1; // definition
void enclose::inner::f(int i) {} // definition
}}

Nested classes can be forward-declared and later defined, either within the same enclosing class body, or outside of it:

{{source|1=
class enclose {
    class nested1; // forward declaration
    class nested2; // forward declaration
    class nested1 {}; // definition of nested class
};
class enclose::nested2 { }; // definition of nested class
}}

Nested class declarations obey {{rlp|access|member access}} specifiers, a private member class cannot be named outside the scope of the enclosing class, although objects of that class may be manipulated:

{{source|1=
class enclose {
    struct nested { // private member
        void g() {}
    };
 public:
    static nested f() { return nested{}; }
};

int main()
{
    //enclose::nested n1 = e.f(); // error: 'nested' is private

    enclose::f().g(); // OK: does not name 'nested'
    auto n2 = enclose::f(); // OK: does not name 'nested'
    n2.g();
}
}}

===References===
{{ref std c++11}}
{{ref std | section=9.7 | title=Nested class declarations | id=class.nest}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=9.7 | title=Nested class declarations | id=class.nest}}
{{ref std end}}

[[de:cpp/language/nested types]]
[[es:cpp/language/nested types]]
[[fr:cpp/language/nested types]]
[[it:cpp/language/nested types]]
[[ja:cpp/language/nested types]]
[[pt:cpp/language/nested types]]
[[ru:cpp/language/nested types]]
[[zh:cpp/language/nested types]]</text>
      <sha1>bp7selwgmcqx4llb2t6dk8p40yyjh7z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/new</title>
    <ns>0</ns>
    <id>700</id>
    <revision>
      <id>71512</id>
      <parentid>71445</parentid>
      <timestamp>2014-06-12T04:19:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>cwg 292.</comment>
      <text xml:space="preserve" bytes="10160">{{title|new expression}}
{{cpp/language/expressions/navbar}}

Creates and initializes objects with dynamic [[cpp/language/storage_duration|storage duration]], that is, objects whose lifetime is not limited by the scope in which they were created.

===Syntax===
{{sdsc begin}} 
{{sdsc | num=1 |1= 
{{ttb|::}}{{mark optional}} {{ttb|new}} {{ttb|(}}{{spar|placement_params}}{{ttb|)}}{{mark optional}} {{ttb|(}} {{spar|type}} {{ttb|)}} {{spar|initializer}}{{mark optional}}
}}
{{sdsc | num=2 |1= 
{{ttb|::}}{{mark optional}} {{ttb|new}} {{ttb|(}}{{spar|placement_params}}{{ttb|)}}{{mark optional}} {{spar|type}} {{spar|initializer}}{{mark optional}}
}}
{{sdsc end}}

@1@ Attempts to create an object of type, denoted by the {{rlp|type#Type_naming|type-id}} {{tt|type}}, which may be array type, and may include the type specifier {{tt|auto}}{{mark since c++11}}.
@2@ Same, but {{tt|type}} cannot include parentheses:
{{source|1=
new int(*[10])(); // parser error: parsed as (new int) (*[10]) ()
new (int (*[10])()); // OK: allocates an array of 10 pointers to functions
}}
In addition, unparenthesized {{spar|type}} is greedy: it will include every token that can be a part of a declarator:
{{source|1=
new int + 1; // OK: parsed as (new int) + 1, increments a pointer returned by new int
new int * 1; // Error: parsed as (new int*) (1)
}}

Note: If {{tt|auto}} is used in {{tt|type}}, then {{tt|initializer}} is not optional: it is required to deduce the type to use in place of {{tt|auto}}:
{{c|1=auto p = new auto('c'); // creates a single object of type char. p is a char*}}

===Explanation===

The {{tt|new}} expression attempts to allocate storage and then attempts to construct and initialize either a single unnamed object, or an unnamed array of objects in the allocated storage. The new-expression returns a prvalue pointer to the constructed object or, if an array of objects was constructed, a pointer to the initial element of the array.

If {{tt|type}} is an array type, all dimensions other than the first must be specified as positive {{rlp|constant expression|converted constant expression}} of type {{lc|std::size_t}}, but the first dimension may be any expression convertible to {{lc|std::size_t}}. This is the only way to directly create an array with size defined at runtime, such arrays are often referred to as ''dynamic arrays'':

{{source|1=
int n = 42;
double a[n][5]; // Error
auto p1 = new double[n][5]; // OK
auto p2 = new double[5][n]; // Error
}}
In the following cases the expression specifying the first dimension is erroneous:
* the expression is of non-class type and its value before conversion to {{lc|std::size_t}} is negative
* the expression is of class type and its value after user-defined conversion function and before the {{rlp|implicit cast|second standard conversion}} is negative
* the value of the expression is larger than some implementation-defined limit
* the value is smaller than the number of array elements provided in the brace-enclosed initializer (including the terminating '\0' on a string literal)

If the value in the first dimension is erroneous for any of these reasons, 
* if, after conversion to {{lc|std::size_t}}, the first dimension is a {{rlp|constant expression|core constant expression}}, the program is ill-formed.
* Otherwise, the new expression does not call the allocation function, and instead throws an excetion of type {{lc|std::bad_array_new_length}} or derived from it {{mark since c++11}}.

The first dimension of zero is acceptable, and the allocation function is called.

Note: {{lc|std::vector}} offers similar functionality for one-dimensional dynamic arrays.

====Allocation====
The new-expression allocates storage by calling the appropriate [[cpp/memory/new/operator_new | allocation function]]. If {{tt|type}} is a non-array type, the name of the function is {{tt|operator new()}}. If {{tt|type}} is an array type, the name of the function is {{tt|operator new[]()}}. 

As described in [[cpp/memory/new/operator_new | allocation function]], the C++ program may provide global and class-specific replacements for these functions. If the new-expression begins with the optional {{c|::}} operator, as in {{c|::new T}} or {{c|::new T[n]}}, class-specific replacements will be ignored (the function is {{rlp|lookup|looked up}} in global {{rlp|scope}}). Otherwise, if {{tt|T}} is a class type, it is looked up in the scope of {{tt|T}} first.

When calling the allocation function, the new-expression passes the number of bytes requested as the first argument, of type {{tt|size_t}}, which is exactly {{c|sizeof(T)}} for non-array {{tt|T}}.

Array allocation may supply unspecified overhead, which may vary from one call to new to the next. The pointer returned by the new-expression will be offset by that value from the pointer returned by the allocation function. Many implementations use the array overhead to store the number of objects in the array which is used by {{c|operator delete[]}} to call the correct number of destructors. In addition, if the new-expression is used to allocate an array of {{c|char}} or an array {{c|unsigned char}}, it may request additional memory from the allocation function if necessary to guarantee correct alignment of objects of all types no larger than the requested array size, if one is later placed into the allocated array. 

{{rev begin}}
{{rev|since=c++14|
New expressions are allowed to combine allocations made through replaceable allocation functions: the allocation made by a new-expression E1 may be extended to provide additional storage for another new-expression E2 if all of the following is true:
@1@ The lifetime of the object allocated by E1 strictly contains the lifetime of the object allocated by E2,
@2@ E1 and E2 would invoke the same replaceable global allocation function
@3@ For a throwing allocation function, exceptions in E1 and E2 would be first caught in the same handler.
}}
{{rev end}}

If {{tt|placement_params}} are provided, they are passed to the allocation function as additional arguments:

{{source|1=
new T;      //  calls operator new( sizeof(T) )
new T[5];   //  calls operator new[]( sizeof(T)*5 + overhead)
new(2,f) T; //  calls operator new( sizeof(T), 2, f)
}}

Such allocation functions are known as &quot;placement new&quot;, after the standard allocation function {{c|void* operator new(std::size_t, void*)}}, which simply returns its second argument unchanged. This is used to construct objects in allocated storage:

{{source|1=
char* ptr = new char[sizeof(T)]; // allocate memory
T* tptr = new(ptr) T; // construct in allocated storage (&quot;place&quot;)
tptr-&gt;~T();   // destruct
delete[] ptr; // deallocate
}}

Note: this functionality is encapsulated by the member functions of the {{concept|Allocator}} classes.

If the allocation function return a null pointer, which is possible if the non-throwing overload was selected, e.g. with {{c|new(std::nothrow) T;}}, then the new-expression returns immediately, it does not attempt to initialize an object or to call a deallocation function.

====Construction====
The object created by a new expression is initialized according to the following rules:

* For non-array {{tt|type}}, the single object is constructed in the acquired memory area.
:* If {{spar|initializer}} is absent, the object is [[cpp/language/default_initialization|default-initialized]].
:* If {{spar|initializer}} is a parenthesized list of arguments, the object is [[cpp/language/direct_initialization|direct-initialized]].
:* If {{spar|initializer}} is a brace-enclosed list of arguments{{mark since c++11}}, the object is [[cpp/language/list_initialization|list-initialized]].
* If {{spar|type}} is an array type, an array of objects is initialized.
:* If {{spar|initializer}} is absent, each element is [[cpp/language/default_initialization|default-initialized]]
:* If {{spar|initializer}} is an empty pair of parentheses, each element is [[cpp/language/value_initialization|value-initialized]].
:* If {{spar|initializer}} is a brace-enclosed list of arguments{{mark since c++11}}, the elements of the array are [[cpp/language/aggregate_initialization|aggregate-initialized]].

If initialization terminates by throwing an exception (e.g. from the constructor), if new-expression allocated any storage, it calls the appropriate [[cpp/memory/new/operator_delete|deallocation function]]: {{c|operator delete()}} for non-array {{tt|type}}, {{c|operator delete[]()}} for array {{tt|type}}. The deallocation function is looked up in global scope if the new expression used the {{c|::new}} syntax, otherwise it is looked up in the scope of {{tt|T}} first, if {{tt|T}} is a class type. If no deallocation function is found, memory is not deallocated. The value obtained earlier from the allocation function is passed as the first argument to the deallocation function. 

===Memory leaks===
The objects created by new expressions (objects with dynamic storage duration) persist until the pointer returned by the new expression is used in a matching [[cpp/language/delete|delete-expression]]. If the original value of pointer is lost, the object becomes unreachable and cannot be deallocated: a ''memory leak'' occurs.

This may happen if the pointer is assigned to:

{{source|1=
int* p = new int(7); // dynamically allocated int with value 7
p = NULL; // memory leak
}}

or if the pointer goes out of scope:

{{source|1=
void f()
{
    int* p = new int(7);
} // memory leak
}}

or due to exception

{{source|1=
void f()
{
   int* p = new int(7);
   g();      // may throw
   delete p; // OK if no exception
} // memory leak if g() throws
}}

To simplify management of dynamically-allocated objects, the result of a new-expression is often stored in a ''smart pointer'': {{lc|std::unique_ptr}}, {{lc|std::shared_ptr}}, or {{lc|std::auto_ptr}}{{mark deprecated}}. These pointers guarantee that the delete expression is executed in the situations shown above.

===Keywords===

{{ltt|cpp/keyword/new}}

[[de:cpp/language/new]]
[[es:cpp/language/new]]
[[fr:cpp/language/new]]
[[it:cpp/language/new]]
[[ja:cpp/language/new]]
[[pt:cpp/language/new]]
[[ru:cpp/language/new]]
[[zh:cpp/language/new]]</text>
      <sha1>dpjedtpjt4f6772hyp62dkra8e6xe67</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/noexcept</title>
    <ns>0</ns>
    <id>701</id>
    <revision>
      <id>71171</id>
      <parentid>71165</parentid>
      <timestamp>2014-06-07T07:34:06Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>I don't think it is a misspelling, link value category to explanation prvalue</comment>
      <text xml:space="preserve" bytes="3342">{{title|noexcept operator {{mark since c++11}}}}
{{cpp/language/exceptions/navbar}}

The {{tt|noexcept}} operator performs a compile-time check that returns true if an expression is declared to not throw any exceptions.

It can be used within a function template's {{rlp|noexcept_spec | noexcept specifier}} to declare that the function will throw exceptions for some types but not others.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|noexcept(}} {{spar|expression}} {{ttb|)}}}}
{{sdsc end}}

Returns a {{rlp|value category|prvalue}} of type {{c|bool}}. 

===Explanation===

The {{tt|noexcept}} operator does not evaluate {{spar|expression}}. The result is {{ttb|false}} if the {{spar|expression}} contains at least one of the following potentially evaluated constructs:

:* call to any type of function that does not have non-throwing exception specification, unless it is a {{rlp|constexpr | constant expression}}.
:* {{rlp|throw|{{tt|throw}} expression}}.
:* {{rlp|dynamic_cast|{{tt|dynamic_cast}} expression}} when the target type is a reference type, and conversion needs a run time check
:* {{rlp|typeid|{{tt|typeid}} expression}} when argument type is polymorphic class type 

In all other cases the result is {{ttb|true}}.

===Keywords===

{{ltt|cpp/keyword/noexcept}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;

void may_throw();
void no_throw() noexcept;
auto lmay_throw = []{};
auto lno_throw = []() noexcept {};
class T{
public:
  ~T(){} // dtor prevents move ctor
         // copy ctor is noexcept
};
class U{
public:
  ~U(){} // dtor prevents move ctor
         // copy ctor is noexcept(false)
  std::vector&lt;int&gt; v;
};
class V{
public:
  std::vector&lt;int&gt; v;
};
 
int main()
{
 T t;
 U u;
 V v;
 
 std::cout &lt;&lt; std::boolalpha
            &lt;&lt; &quot;Is may_throw() noexcept? &quot; &lt;&lt; noexcept(may_throw()) &lt;&lt; '\n'
            &lt;&lt; &quot;Is no_throw() noexcept? &quot; &lt;&lt; noexcept(no_throw()) &lt;&lt; '\n'
            &lt;&lt; &quot;Is lmay_throw() noexcept? &quot; &lt;&lt; noexcept(lmay_throw()) &lt;&lt; '\n'
            &lt;&lt; &quot;Is lno_throw() noexcept? &quot; &lt;&lt; noexcept(lno_throw()) &lt;&lt; '\n'
            &lt;&lt; &quot;Is ~T() noexcept? &quot; &lt;&lt; noexcept(std::declval&lt;T&gt;().~T()) &lt;&lt; '\n'
            &lt;&lt; &quot;Is T(rvalue T) noexcept? &quot; &lt;&lt; noexcept(T(std::declval&lt;T&gt;())) &lt;&lt; '\n'
            &lt;&lt; &quot;Is T(lvalue T) noexcept? &quot; &lt;&lt; noexcept(T(t)) &lt;&lt; '\n'
            &lt;&lt; &quot;Is U(rvalue U) noexcept? &quot; &lt;&lt; noexcept(U(std::declval&lt;U&gt;())) &lt;&lt; '\n'
            &lt;&lt; &quot;Is U(lvalue U) noexcept? &quot; &lt;&lt; noexcept(U(u)) &lt;&lt; '\n'  
            &lt;&lt; &quot;Is V(rvalue V) noexcept? &quot; &lt;&lt; noexcept(V(std::declval&lt;V&gt;())) &lt;&lt; '\n'
            &lt;&lt; &quot;Is V(lvalue V) noexcept? &quot; &lt;&lt; noexcept(V(v)) &lt;&lt; '\n';  
}
|output=
Is may_throw() noexcept? false
Is no_throw() noexcept? true
Is lmay_throw() noexcept? false
Is lno_throw() noexcept? true
Is ~T() noexcept? true
Is T(rvalue T) noexcept? true
Is T(lvalue T) noexcept? true
Is U(rvalue U) noexcept? false
Is U(lvalue U) noexcept? false
Is V(rvalue V) noexcept? true
Is V(lvalue V) noexcept? false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc noexcept_spec}}
{{dsc inc | cpp/language/dsc except_spec}}
{{dsc end}}

[[de:cpp/language/noexcept]]
[[es:cpp/language/noexcept]]
[[fr:cpp/language/noexcept]]
[[it:cpp/language/noexcept]]
[[ja:cpp/language/noexcept]]
[[pt:cpp/language/noexcept]]
[[ru:cpp/language/noexcept]]
[[zh:cpp/language/noexcept]]</text>
      <sha1>jew6bs3kleo0d3n40i6beh6bswo2069</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/noexcept spec</title>
    <ns>0</ns>
    <id>2458</id>
    <revision>
      <id>71811</id>
      <parentid>69066</parentid>
      <timestamp>2014-06-25T02:34:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail including cwg 1330.</comment>
      <text xml:space="preserve" bytes="6952">{{title|noexcept specifier  {{mark since c++11}}}}
{{cpp/language/exceptions/navbar}}

Specifies whether a function will throw exceptions or not.

===Syntax===
{{sdsc begin}}
{{sdsc | num=1 | {{ttb|noexcept}}}}
{{sdsc | num=2 | {{ttb|noexcept(}}{{spar|expression}}{{ttb|)}}}}
{{sdsc end}}
@1@ Same as {{ttb|noexcept}} {{ttb|(}} {{ttb|true}} {{ttb|)}}
@2@ If {{spar|expression}} is true, the function is declared to not throw any exceptions.
{{par begin}}
{{par | {{spar|expression}} | {{rlp|constant expression}}, contextually convertible to {{c|bool}} }}
{{par end}}

===Explanation===
The noexcept-specification (just like {{rlp|except spec|exception specification}}) can appear as a part of a {{rlp|function|function declarator}} when declaring functions, pointer to functions, references to functions, or pointers to member function type, and also when declaring a parameter or a return type of a function that happens to be a pointer or reference to function. It cannot appear in a {{rlp|typedef}} or {{rlp|type alias}} declaration.
{{source|1=
void f() noexcept; // the function f() does not throw
void (*fp)() noexcept(false); // fp points to a function that may throw
void g(void pfa() noexcept);  // g takes a pointer to function that doesn't throw
// typedef int (*pf)() noexcept; // error
}}

The noexcept-specification is not a part of the function type. However, if any declaration of a function has a noexcept specification that isn't {{tt|noexcept(false)}}, other declarations of the same function has to have the same noexcept-specification. Similar restrictions apply to overriders of a {{rlp|virtual|virtual function}} and to initialization and  assignment of pointers to functions (target entity has to have identical or more permissive exception specification).
{{source|1=
void f() noexcept;
void f(); // error, incompatible exception specifications
void g() noexcept(false);
void g(); // ok
}}

If a search for a matching {{rlp|try catch|exception handler}} leaves a function marked {{c|noexcept}} or {{c|noexcept(true)}}, {{lc|std::terminate}} is called immediately.

{{rlp|using declaration|Inheriting constructors}} and the implicitly-declared {{rlp|default constructor}}s, {{rlp|copy constructor}}s, {{rlp|move constructor}}s, {{rlp|destructor}}s, {{rlp|as operator|copy-assignment}} operators, {{rlp|move operator|move-assignment}} operators are all {{tt|noexcept(true)}} by default, unless they are required to call a function that is {{tt|noexcept(false)}}, in which case these functions are {{tt|noexcept(false)}}.

Any user-defined {{rlp|destructor}} is {{tt|noexcept(true)}} by default, unless the declaration specifies otherwise, or the destructor of any base or member is {{tt|noexcept(false)}}.

Any [[cpp/memory/new/operator_delete|deallocation function]] is {{tt|noexcept(true)}} by default, unless the declaration specifies otherwise.

{{rev begin}}
{{rev|since=c++14|
An noexcept-specification of a function is considered to be ''needed'' in the following contexts
* in an expression, where the function is selected by overload resolution
* the function is odr-used
* the function would be odr-used but appears in an unevaluated operand
{{source|1=
template&lt;class T&gt; T f() noexcept(sizeof(T) &lt; 4);
int main() {
    decltype(f&lt;void&gt;()) *p; // f unevaluated, but noexcept-spec is needed
}
}}
* the specification is needed to compare to another function declaration (e.g. on an virtual function overrider or on an explicit specialization of a function template)
* in a function definition
* the specification is needed because a defaulted special member function needs to check it in order to decide its own exception specification (this takes place only when the specification of the defaulted special member function is, itself, needed).

The exception specification of a function template specialization is not instantiated along with the function declaration; it is instantiated only when ''needed'' (as defined above).

The exception-specification of an implicitly-declared special member function is also evaluated as needed (in particular, implicit declaration of a member function of a derived class does not require the exception-specification of a base member function to be instantiated)

When the noexcept-specification of a function template specialization is ''needed'', but hasn't yet been instantiated, the dependent names are looked up and any templates used in the {{spar|expression}} are instantiated as if for the declaration of the specialization.
}}
{{rev end}}
===Notes===
One of the uses of the constant {{spar|expression}} is (along with the [[cpp/language/noexcept|{{tt|noexcept}} operator]]) to define function templates that declare {{ttb|noexcept}} for some types but not others.

Note that a {{ttb|noexcept}} specification on a function is not a compile-time check; it is merely a method for a programmer to inform the compiler whether or not a function should throw exceptions.  The compiler can use this information to enable certain optimizations on non-throwing functions as well as enable the [[cpp/language/noexcept|{{tt|noexcept}} operator]], which can check at compile time if a particular expression is declared to throw any exceptions. For example, containers such as {{lc|std::vector}} will move their elements if the elements' move constructor is {{ttb|noexcept}}, and copy otherwise (unless the copy constructor is not accessible, but a potentially throwing move constructor is, in which case the strong exception guarantee is waived).

====Deprecates====
{{ttb|noexcept}} is an improved version of [[cpp/language/except_spec|{{c|throw()}}]], which is deprecated in C++11.  Unlike [[cpp/language/except_spec|{{c|throw()}}]], {{ttb|noexcept}} will not call {{lc|std::unexpected}} and may or may not unwind the stack, which potentially allows the compiler to implement {{ttb|noexcept}} without the runtime overhead of [[cpp/language/except_spec|{{c|throw()}}]]. 

===Keywords===
{{ltt|cpp/keyword/noexcept}}

===Example===
{{example
 | code=
// whether foo is declared noexcept depends on if the expression
// T() will throw any exceptions
template &lt;class T&gt;
  void foo() noexcept(noexcept(T())) {}

void bar() noexcept(true) {}
void baz() noexcept { throw 42; }  // noexcept is the same as noexcept(true)

int main() 
{
    foo&lt;int&gt;();  // noexcept(noexcept(int())) =&gt; noexcept(true), so this is fine

    bar();  // fine
    baz();  // compiles, but at runtime this calls std::terminate
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc noexcept}}
{{dsc inc | cpp/language/dsc except_spec}}
{{dsc inc | cpp/language/dsc throw}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc end}}

[[de:cpp/language/noexcept spec]]
[[es:cpp/language/noexcept spec]]
[[fr:cpp/language/noexcept spec]]
[[it:cpp/language/noexcept spec]]
[[ja:cpp/language/noexcept spec]]
[[pt:cpp/language/noexcept spec]]
[[ru:cpp/language/noexcept spec]]
[[zh:cpp/language/noexcept spec]]</text>
      <sha1>jl58d8wd7fg9q0tnr76fxithkvmpoxy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/nullptr</title>
    <ns>0</ns>
    <id>3537</id>
    <revision>
      <id>71392</id>
      <parentid>66843</parentid>
      <timestamp>2014-06-10T04:39:41Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>Add references to C++ standard</comment>
      <text xml:space="preserve" bytes="1615">{{title|nullptr pointer literal}}
{{cpp/language/expressions/navbar}}

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|nullptr}}| notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===
The keyword {{tt|nullptr}} denotes the null pointer literal. It is an unspecified [[cpp/language/value_category|prvalue]] of type {{lc|std::nullptr_t}}. There exist {{rlp|implicit_cast|implicit conversions}} from {{tt|nullptr}} to null pointer value of any pointer type and any pointer to member type. Similar conversions exist for any value of type {{lc|std::nullptr_t}} as well as for the macro {{lc|NULL}}, the null pointer constant.

===Example===
{{example
 | Demonstrates how nullptr allows forwarding via a template function.
 | code=
#include &lt;cstddef&gt;
#include &lt;iostream&gt;

template&lt;class F, class A&gt;
void Fwd(F f, A a)
{
    f(a);
}

void g(int* i)
{
    std::cout &lt;&lt; &quot;Function g called\n&quot;;
}

int main()
{
    g(NULL);           // Fine
    g(0);              // Fine

    Fwd(g, nullptr);   // Fine
//  Fwd(g, NULL);  // ERROR: No function g(int)
}
| output=
Function g called
Function g called
Function g called
}}

===Keywords===
{{ltt|cpp/keyword/nullptr}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc inc | cpp/types/dsc nullptr_t}}
{{dsc end}}

[[de:cpp/language/nullptr]]
[[es:cpp/language/nullptr]]
[[fr:cpp/language/nullptr]]
[[it:cpp/language/nullptr]]
[[ja:cpp/language/nullptr]]
[[pt:cpp/language/nullptr]]
[[ru:cpp/language/nullptr]]
[[zh:cpp/language/nullptr]]

===References===
{{ref std c++11}}
{{ref std | section=4.10 | title=Pointer conversions | id=conv.ptr}}
{{ref std end}}</text>
      <sha1>kum51dirmgvxqclblx2ge4fm7w4hg26</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/object</title>
    <ns>0</ns>
    <id>13083</id>
    <revision>
      <id>68998</id>
      <parentid>68997</parentid>
      <timestamp>2014-03-23T16:10:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>clarify &quot;stricter&quot; and &quot;weakest&quot;, mention that custom alloc can work well, too</comment>
      <text xml:space="preserve" bytes="8199">{{title|Object}}
{{cpp/language/basics/navbar}}

C++ programs create, destroy, refer to, access, and manipulate ''objects''

An object, in C++, is a ''region of storage'' that has
* size (can be determined with {{rlp|sizeof}})
* alignment requirement (can be determined by {{rlp|alignof}})
* {{rlp|storage duration}} (automatic, static, dynamic, thread-local)
* {{rlp|lifetime}} (bounded by storage duration or temporary)
* {{rlp|type}}
* value (which may be indeterminate, e.g. for {{rlp|default_initialization|default-initialized}} non-class types)
* optionally, a {{rlp|name}}

Functions, references, classes and other types, namespaces, enumerators, and templates are not objects.

Objects are created by {{rlp|definition}}s, {{rlp|new|new-expressions}}, and in several  other situations where temporary objects are required: {{rlp|reference_initialization|binding a reference to a prvalue}}, returning a prvalue from a function, {{rlp|expressions#Conversions|a conversion}} that creates a prvalue, {{rlp|throw|throwing}} an exception, entering an exception handler, and in some {{rlp|initialization}} contexts.

===Object representation and value representation===
For an object of type {{tt|T}}, ''object representation'' is the sequence of {{c|sizeof(T)}} objects of type {{c|unsigned char}} beginning at the same address as the {{tt|T}} object.

The ''value representation'' of an object is the set of bits that hold the value of its type {{tt|T}}.

For {{concept|TriviallyCopyable}} types, value representation is a part of the object representation, which means that copying the bytes occupied by the object in the storage is sufficient to produce another object with the same value.

Some bits of the object representation may not participate in the value representation; such bits may be padding introduced to satisfy {{rlp|object#Alignment|alignment requirements}}, {{rlp|bit field}} sizes, etc.

{{source|1=
#include &lt;cassert&gt;
struct S {
    char c;  // 1 byte value
             // 3 bytes padding
    float f; // 4 bytes value
    bool operator==(const S&amp; arg) const { // value-based equality
        return c == arg.c &amp;&amp; f == arg.f;
    }
};
assert(sizeof(S) == 8);
S s1 = {'a', 3.14};
S s2 = s1;
reinterpret_cast&lt;char*&gt;(&amp;s1)[2] = 'b'; // change 2nd byte
assert(s1 == s2); // value did not change
}}

For the objects of type {{c|char}}, {{c|signed char}}, and {{c|unsigned char}}, every bit of the object representation is required to participate in the value representation (no padding allowed)

===Subobjects===
An object can contain other objects, which are called ''subobjects''. These include
* member objects
* base class subobjects
* array elements
An object that is not a subobject of another object is called ''complete object''

Complete objects, member objects, and array elements are also known as ''most derived objects'', to distinguish them from base class subobjects. The size of a ''most derived object'' that is not a {{rlp|bit field}} is required to be non-zero (the size of a base class subobject may be zero: see {{rlp|ebo|empty base optimization}})

Any two objects (that are not {{rlp|bit field}}s) are guaranteed to have different addresses unless one of them is a subobject of another, or if they are subobjects of different type within the same complete object, and one of them is a zero-size base.

{{source|1=static const char c1 = ’x’;
static const char c2 = ’x’;
assert(&amp;c1 != &amp;c2); // same values, different addresses
}}

===Polymorphic objects===
Objects of class type that declare or inherit at least one virtual function are polymorphic objects. Within each polymorphic object, the implementation stores additional information (in every existing implementation, it is one pointer unless optimized out), which is used by {{rlp|virtual|virtual function}} calls and by the RTTI features ({{rlp|dynamic_cast}} and {{rlp|typeid}}) to determine, at run time, the type with which the object was created, regardless of the expression it is used in.

For non-polymorphic objects, the interpretation of the value is determined from the expression in which the object is used, and is decided at compile time.

{{example
|code=
#include &lt;iostream&gt;
#include &lt;typeinfo&gt;
struct Base1 {
    // polymorphic type: declares a virtual member
    virtual ~Base1() {}
};
struct Derived1 : Base1 {
     // polymorphic type: inherits a virtual member
};

struct Base2 {
     // non-polymorphic type
};
struct Derived2 : Base2 {
     // non-polymorphic type
};

int main()
{
    Derived1 obj1; // object1 created with type Derived1
    Derived2 obj2; // object2 created with type Derived2

    Base1&amp; b1 = obj1; // b1 refers to the object obj1
    Base2&amp; b2 = obj2; // b2 refers to the object obj2

    std::cout &lt;&lt; &quot;Expression type of b1: &quot; &lt;&lt; typeid(decltype(b1)).name() &lt;&lt; ' '
              &lt;&lt; &quot;Expression type of b2: &quot; &lt;&lt; typeid(decltype(b2)).name() &lt;&lt; '\n'
              &lt;&lt; &quot;Object type of b1: &quot; &lt;&lt; typeid(b1).name() &lt;&lt; ' '
              &lt;&lt; &quot;Object type of b2: &quot; &lt;&lt; typeid(b2).name() &lt;&lt; '\n'
              &lt;&lt; &quot;size of b1: &quot; &lt;&lt; sizeof b1 &lt;&lt; ' '
              &lt;&lt; &quot;size of b2: &quot; &lt;&lt; sizeof b2 &lt;&lt; '\n';
}
|output=
Expression type of b1: Base1 Expression type of b2: Base2
Object type of b1: Derived1 Object type of b2: Base2
size of b1: 8 size of b2: 1
}}

===Strict aliasing===
Accessing an object using an expression of a type other than the type which which it was created is undefined behavior in many cases, see {{rlp|reinterpret_cast#Type aliasing|reinterpret_cast}} for the list of exceptions and examples.

===Alignment===
Every {{rlp|type|object type}} has the property called ''alignment requirement'', which is an integer value (of type {{lc|std::size_t}}, always a power of 2) representing the number of bytes between successive addresses at which objects of this type can be allocated. The alignment requirement of a type can be queried with {{rlp|alignof}} or {{lc|std::alignment_of}}. The pointer alignment function {{lc|std::align}} can be used to obtain a suitably-aligned pointer within some buffer, and {{lc|std::aligned_storage}} can be used to obtain suitably-aligned storage.

Each object type imposes its alignment requirement on every object of that type; stricter alignment (with larger alignment requirement) can be requested using {{rlp|alignas}}.

In order to satisfy alignment requirements of all non-static members of a {{rlp|class}}, ''padding'' may be inserted after some of its members.

{{example|code=
#include &lt;iostream&gt;

// objects of type S can be allocated at any address
// because both S.a and S.b can be allocated at any address
struct S {
  char a; // size: 1, alignment: 1
  char b; // size: 1, alignment: 1
}; // size: 2, alignment: 1

// objects of type X must be allocated at 4-byte boundaries
// because X.n must be allocated at 4-byte boundaries
// because int's alignment requirement is (usually) 4
struct X {
  int n;  // size: 4, alignment: 4
  char c; // size: 1, alignment: 1
  // three bytes padding
}; // size: 8, alignment: 4 

int main()
{
    std::cout &lt;&lt; &quot;sizeof(S) = &quot; &lt;&lt; sizeof(S)
              &lt;&lt; &quot; alignof(S) = &quot; &lt;&lt; alignof(S) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;sizeof(X) = &quot; &lt;&lt; sizeof(X)
              &lt;&lt; &quot; alignof(X) = &quot; &lt;&lt; alignof(X) &lt;&lt; '\n';
}
|output=
sizeof(S) = 2 alignof(S) = 1
sizeof(X) = 8 alignof(X) = 4
}}

The weakest alignment (the smallest alignment requirement) is the alignment of {{c|char}} (typically 1), the largest ''fundamental alignment'' of any type is the alignment of {{lc|std::max_align_t}}. If a type's alignment is made stricter (larger) than {{lc|std::max_align_t}} using {{rlp|alignas}}, it is known as a type with ''extended alignment'' requirement. A type whose alignment is extended or a class type whose non-static data member has extended alignment is an ''over-aligned type''. It is implementation-defined if {{rlp|new|new-expression}}, {{lc|std::allocator::allocate}}, and {{lc|std::get_temporary_buffer}} support over-aligned types. {{concept|Allocator}}s instantiated with over-aligned types are allowed to fail to instantiate at compile time, to throw {{lc|std::bad_alloc}} at runtime, to silently ignore unsupported alignment requirement, or to handle them correctly.</text>
      <sha1>loxts8afhv6c9mwou6ir6hqmvy4x4o7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/objects</title>
    <ns>0</ns>
    <id>13087</id>
    <redirect title="cpp/language/object" />
    <revision>
      <id>66415</id>
      <timestamp>2013-11-21T14:28:08Z</timestamp>
      <contributor>
        <username>ArbyCoder</username>
        <id>2649</id>
      </contributor>
      <comment>Redirected page to [[cpp/language/object]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/language/object]]</text>
      <sha1>kmjxbvjvzltmq6y8ch3jscz0szwayhb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator alternative</title>
    <ns>0</ns>
    <id>702</id>
    <revision>
      <id>72243</id>
      <parentid>72240</parentid>
      <timestamp>2014-07-28T22:25:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-confusing comment</comment>
      <text xml:space="preserve" bytes="3983">{{title|Alternative operator representations}}
{{cpp/language/expressions/navbar}}

C++ (and C) source code may be written in any non-ASCII 7-bit character set that includes the [[enwiki:ISO 646|ISO 646:1983]] invariant character set. However, several C++ operators and punctuators require characters that are outside of the ISO 646 codeset: {{tt|{, }, [, ], #, \, ^, {{!}}, ~}}. To be able to use character encodings where some or all of these symbols do not exist (such as the German [http://de.wikipedia.org/wiki/DIN_66003 DIN 66003]), C++ defines two kinds of alternatives: additional keywords that correspond to the operators that use these characters and special combinations of two or three ISO 646 compatible characters that are interpreted as if they were a single non-ISO 646 character.

==Alternative keywords==

There are alternative spellings for several operators defined as keywords in the C++ standard. 

{| class=&quot;wikitable&quot;
|-
! Primary
! Alternative
|-
| {{tt|&amp;&amp;}}
| {{tt|and}}
|-
| {{tt|&amp;{{=}}}}
| {{tt|and_eq}}
|-
| {{tt|&amp;}}
| {{tt|bitand}}
|-
| {{tt|&amp;#124;}}
| {{tt|bitor}}
|-
| {{tt|~}}
| {{tt|compl}}
|-
| {{tt|!}}
| {{tt|not}}
|-
| {{tt|!{{=}}}}
| {{tt|not_eq}}
|-
| {{tt|&amp;#124;&amp;#124;
| {{tt|or
|-
| {{tt|&amp;#124;{{=}}}}
| {{tt|or_eq}}
|-
| {{tt|^}}
| {{tt|xor}}
|-
| {{tt|^{{=}}}}
| {{tt|xor_eq}}
|}

===Compatibility with C===
The same words are defined in the C programming language in the include file {{c|&lt;iso646.h&gt;}} as macros. Because in C++ these are language keywords, the C++ version of {{c|&lt;iso646.h&gt;}}, as well as {{c|&lt;ciso646&gt;}}, does not define anything.

==Digraphs and trigraphs==

The following combinations of two and three characters (digraphs and trigraphs) are valid substitutions for their respective primary characters:

{| class=&quot;wikitable&quot;
|- style=&quot;text-align: left;&quot;
! Primary
! Digraph
! Trigraph
|-
| {{tt|{}} || {{tt|&lt;%}} || {{tt|??&lt;}}
|-
| {{tt|}}} || {{tt|%&gt;}} || {{tt|??&gt;}}
|-
| {{tt|[}} || {{tt|&lt;:}} || {{tt|??(}}
|-
| {{tt|]}} || {{tt|:&gt;}} || {{tt|??)}}
|-
| {{tt|#}} || {{tt|%:}} || {{tt|??{{=}}}}
|-
| {{tt|\}} || || {{tt|??/}}
|-
| {{tt|^}} || || {{tt|??'}}
|-
| {{tt|&lt;nowiki&gt;|&lt;/nowiki&gt;}} || || {{tt|??!}}
|-
| {{tt|~}} || || {{tt|??-}}
|}

Note that trigraphs (but not digraphs) are {{rlp|translation_phases|parsed before comments and string literals are recognized}}, so a comment such as {{c|// Will the next line be executed?????/}} will effectively comment out the following line, and the string literal such as {{c|&quot;Enter date ??/??/??&quot;}} is parsed as {{c|&quot;Enter date \\??&quot;}}.

{{rev begin}}
{{rev|since=c++11|
When the parser meets the charater sequence {{c|&lt;::}} and the subsequent character is neither {{c|:}} nor {{c|&gt;}}, the {{c|&lt;}} is treated as a preprocessor token by itself and not as the first character of the alternative token {{c|&lt;:}}. Thus {{c|std::vector&lt;::std::string&gt;}} won't be wrongly treated as {{c|std::vector[:std::string&gt;}}.
}}
{{rev end}}

===Keywords===

{{ltt|cpp/keyword/and}},
{{ltt|cpp/keyword/and_eq}},
{{ltt|cpp/keyword/bitand}},
{{ltt|cpp/keyword/bitor}},
{{ltt|cpp/keyword/compl}},
{{ltt|cpp/keyword/not}},
{{ltt|cpp/keyword/not_eq}},
{{ltt|cpp/keyword/or}},
{{ltt|cpp/keyword/or_eq}},
{{ltt|cpp/keyword/xor}},
{{ltt|cpp/keyword/xor_eq}}

===Example===

{{example
 | The following example demonstrates the use of several alternative keywords.
 | code=
%:include &lt;iostream&gt;

int main(int argc, char *argv&lt;::&gt;) 
&lt;%
    if (argc &gt; 1 and argv&lt;:1:&gt; not_eq NULL) &lt;%
        std::cout &lt;&lt; &quot;Hello, &quot; &lt;&lt; argv&lt;:1:&gt; &lt;&lt; '\n';
    %&gt;
%&gt;
}}

===See also===
{{dsc begin}}
{{dsc see c | c/language/operator_alternative | Alternative operator representations}}
{{dsc end}}

[[de:cpp/language/operator alternative]]
[[es:cpp/language/operator alternative]]
[[fr:cpp/language/operator alternative]]
[[it:cpp/language/operator alternative]]
[[ja:cpp/language/operator alternative]]
[[pt:cpp/language/operator alternative]]
[[ru:cpp/language/operator alternative]]
[[zh:cpp/language/operator alternative]]</text>
      <sha1>132ngdkbpohtmxdwh6yoj1gisx1t8hi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator arithmetic</title>
    <ns>0</ns>
    <id>703</id>
    <revision>
      <id>72045</id>
      <parentid>71539</parentid>
      <timestamp>2014-07-10T02:38:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>adjust rounding direction link</comment>
      <text xml:space="preserve" bytes="20324">{{title|Arithmetic operators}}
{{cpp/language/expressions/navbar}}
Returns the result of specific arithmetic operation.

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| unary plus
| {{tt|+a}}
| {{yes}}
| {{c|T T::operator+() const;}}
| {{c|T operator+(const T &amp;a);}}
|-
| unary minus
| {{tt|-a}}
| {{yes}}
| {{c|T T::operator-() const;}}
| {{c|T operator-(const T &amp;a);}}
|-
| addition
| {{tt|a + b}}
| {{yes}}
| {{c|T T::operator+(const T2 &amp;b) const;}}
| {{c|T operator+(const T &amp;a, const T2 &amp;b);}}
|-
| subtraction 
| {{tt|a - b}}
| {{yes}}
| {{c|T T::operator-(const T2 &amp;b) const;}}
| {{c|T operator-(const T &amp;a, const T2 &amp;b);}}
|-
| multiplication
| {{tt|a * b}}
| {{yes}}
| {{c|T T::operator*(const T2 &amp;b) const;}}
| {{c|T operator*(const T &amp;a, const T2 &amp;b);}}
|-
| division 
| {{tt|a / b}}
| {{yes}}
| {{c|T T::operator/(const T2 &amp;b) const;}}
| {{c|T operator/(const T &amp;a, const T2 &amp;b);}}
|-
| modulo 
| {{tt|a % b}}
| {{yes}}
| {{c|T T::operator%(const T2 &amp;b) const;}}
| {{c|T operator%(const T &amp;a, const T2 &amp;b);}}
|-
| bitwise NOT
| {{tt|~a}}
| {{yes}}
| {{c|T T::operator~() const;}}
| {{c|T operator~(const T &amp;a);}}
|-
| bitwise AND 
| {{tt|a &amp; b}}
| {{yes}}
| {{c|T T::operator&amp;(const T2 &amp;b) const;}}
| {{c|T operator&amp;(const T &amp;a, const T2 &amp;b);}}
|-
| bitwise OR 
| {{tt|a &amp;#124; b}}
| {{yes}}
| {{c|T T::operator{{!}}(const T2 &amp;b) const;}}
| {{c|T operator{{!}}(const T &amp;a, const T2 &amp;b);}}
|-
| bitwise XOR 
| {{tt|a ^ b}}
| {{yes}}
| {{c|T T::operator^(const T2 &amp;b) const;}}
| {{c|T operator^(const T &amp;a, const T2 &amp;b);}}
|-
| bitwise left shift 
| {{tt|a &lt;&lt; b}}
| {{yes}}
| {{c|T T::operator&lt;&lt;(const T2 &amp;b) const;}}
| {{c|T operator&lt;&lt;(const T &amp;a, const T2 &amp;b);}}
|-
| bitwise right shift 
| {{tt|a &gt;&gt; b}}
| {{yes}}
| {{c|T T::operator&gt;&gt;(const T2 &amp;b) const;}}
| {{c|T operator&gt;&gt;(const T &amp;a, const T2 &amp;b);}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* All built-in operators return values, and most user-defined overloads also return values so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}). In particular, stream insertion and stream extraction overloads of {{tt|operator&lt;&lt;}} and {{tt|operator&gt;&gt;}} return {{tt|T&amp;}}.
* {{tt|T2}} can be any type including {{tt|T}}
|}

===Explanation===

All arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.

====Conversions====
If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoes [[cpp/language/implicit_cast#integral promotion|integral promotion]]. If an operand has array or function type, array-to-pointer and function-to-pointer conversions are applied.

For the binary operators (except shifts), if the promoted operands have different types, additional set of implicit conversions is applied, known as ''usual arithmetic conversions'' with the goal to produce the ''common type'' (also accessible via the {{lc|std::common_type}} type trait)

* If either operand has scoped enumeration type, no conversion is performed: the other operand and the return type must have the same type

* Otherwise, if either operand is {{c|long double}}, the other operand is converted to {{c|long double}}

* Otherwise, if either operand is {{c|double}}, the other operand is converted to {{c|double}}

* Otherwise, if either operand is {{c|float}}, the other operand is converted to {{c|float}}

* Otherwise, the operand has integer type (because bool, char, char16_t, char32_t, wchar_t, and unscoped enumeration were promoted at this point) and [[cpp/language/implicit_cast#integral conversions|integral conversions]] are applied to produce the common type, as follows:

:* If both operands are signed or both are unsigned, the operand with lesser ''conversion rank'' is converted to the operand with the greater integer conversion rank

:* Otherwise, if the unsigned operand's conversion rank is greater or equal to the conversion rank of the signed operand, the signed operand is converted to the unsigned operand's type.

:* Otherwise, if the signed operand's type can represent all values of the unsigned operand, the unsigned operand is converted to the signed operand's type

:* Otherwise, both operands are converted to the unsigned counterpart of the signed operand's type.

The ''conversion rank'' above increases in order {{c|bool}}, {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}}, {{c|long long}}. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of {{c|char}} is equal to the rank of {{c|signed char}} and {{c|unsigned char}}. The ranks of {{c|char16_t}}, {{c|char32_t}}, and {{c|wchar_t}} are equal to the ranks of their underlying types.

====Overflows====
Unsigned integer arithmetic is always performed {{math|modulo 2{{su|p=n}}}} where n is the number of bits in that particular integer. E.g. for {{c|unsigned int}}, adding one to {{lc|UINT_MAX}} gives {{c|0}}, and subtracting one from {{c|0}} gives {{lc|UINT_MAX}}.

When signed integer arithmetic operation overflows (the result does not fit in the result type), the behavior is undefined: it may wrap around according to the rules of the representation (typically 2's complement), it may trap on some platforms or due to compiler options (e.g. {{tt|-ftrapv}} in GCC and Clang), or may be completely [http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html optimized out by the compiler].

====Floating-point environment====
If {{ltt|cpp/preprocessor/impl|#pragma STDC FENV_ACCESS}} is set to {{tt|ON}}, all floating-point arithmetic operators obey the current floating-point [[cpp/numeric/fenv/FE_round|rounding direction]] and report floating-point arithmetic errors as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]] unless part of a [[cpp/language/initialization#Non-local_variables|static initializer]] (in which case floating-point exceptions are not raised and the rounding mode is to nearest)

====Unary arithmetic operators====
For every promoted arithmetic type {{tt|A}} and for every type {{tt|T}}, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | A operator+(A)}}
{{dcl | T* operator+(T*)}}
{{dcl | A operator-(A)}} 
{{dcl end}}

The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts {{c|char}} to {{c|int}} or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.

The builtin unary minus operator calculates the negative of its operand. For unsigned {{tt|a}}, the value of {{tt|-a}} is {{math|2{{su|p=b}}-a}}, where {{tt|b}} is the number of bits after promotion.

{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    char c = 0x6a;
    int n1 = 1;
    unsigned char n2 = 1;
    unsigned int n3 = 1;
    std::cout &lt;&lt; &quot;char: &quot; &lt;&lt; c &lt;&lt; &quot; int: &quot; &lt;&lt; +c &lt;&lt; '\n'
              &lt;&lt; &quot;-1, where 1 is signed: &quot; &lt;&lt; -n1 &lt;&lt; '\n'
              &lt;&lt; &quot;-1, where 1 is unsigned char: &quot; &lt;&lt; -n2 &lt;&lt; '\n'
              &lt;&lt; &quot;-1, where 1 is unsigned int: &quot; &lt;&lt; -n3 &lt;&lt; '\n';
    char a[3];
    std::cout &lt;&lt; &quot;size of array: &quot; &lt;&lt; sizeof a &lt;&lt; '\n'
              &lt;&lt; &quot;size of pointer: &quot; &lt;&lt; sizeof +a &lt;&lt; '\n';
}
 | output=
char: j int: 106
-1, where 1 is signed: -1
-1, where 1 is unsigned char: -1
-1, where 1 is unsigned int: 4294967295
size of array: 3
size of pointer: 8
}}

====Additive operators====
For every pair of promoted arithmetic types {{tt|L}} and {{tt|R}} and for every object type {{tt|T}}, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | LR operator+(L, R)}}
{{dcl | LR operator-(L, R)}}
{{dcl | T* operator+(T*, std::ptrdiff_t)}}
{{dcl | T* operator+(std::ptrdiff_t, T*)}}
{{dcl | T* operator-(T*, std::ptrdiff_t)}}
{{dcl | std::ptrdiff_t operator-(T*, T*)}}
{{dcl end}}
where {{tt|LR}} is the result of usual arithmetic conversions on {{tt|L}} and {{tt|R}}

With operands of arithmetic or enumeration type, the result of binary plus is the sum of the operands (after usual arithmetic converesions), and the result of the binary minus operator is the result of subtracting the second operand from the first (after usual arithmetic conversions).

If any of the operands is a pointer, the following rules apply:
* A pointer to non-array object is treated as a pointer to the first element of an array with size 1.
* If the pointer {{tt|P}} points to the {{tt|i}}th element of an array, then the expressions {{tt|P+n}}, {{tt|n+P}}, and {{tt|P-n}} are pointers of the same type that point to the {{tt|i+n}}th, {{tt|i+n}}th, and {{tt|i-n}}th element of the same array, respectively. The result of pointer addition may also be a one-past-the-end pointer (that is, pointer {{tt|P}} such that the expression {{tt|P-1}} points to the last element of the array). Any other situations (that is, attempts to generate a pointer that isn't pointing at an element of the same array or one past the end) invoke undefined behavior.
* If the pointer {{tt|P}} points to the {{tt|i}}th element of an array, and the pointer {{tt|Q}} points at the {{tt|j}}th element of the same array, the expression {{tt|P-Q}} has the value {{c|i-j}}, if the value fits in {{lc|std::ptrdiff_t}}. Both operands must point to the elements of the same array (or one past the end), otherwise the behavior is undefined. If the result does not fit in {{lc|std::ptrdiff_t}}, the behavior is undefined.
* In any case, if the type of the pointer is different from the array element type (in particular, pointer to base, pointing at an element of an array of derived objects), the behavior of pointer arithmetic is undefined.
* If the value {{c|0}} is added or subtracted from a pointer, the result is the pointer, unchanged. If two pointers point at the same object or are both one past the end of the same array, or both are null pointers, then the result of subtraction is equal to {{c|(std::ptrdiff_t)0}}.
These pointer arithmetic operators allow pointers to satisfy the {{concept|RandomAccessIterator}} concept.

{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout &lt;&lt;  &quot; 2 + (-10), where 2 is a char    = &quot; &lt;&lt; c + n &lt;&lt; '\n'
              &lt;&lt;  &quot; 2 + (-10), where 2 is unsigned  = &quot; &lt;&lt; un + n &lt;&lt; '\n'
              &lt;&lt;  &quot; -10 - 2.12  = &quot; &lt;&lt; n - 2.12 &lt;&lt; '\n';

    char a[4] = {'a', 'b', 'c', 'd'};
    char* p = &amp;a[1];
    std::cout &lt;&lt; &quot;Pointer addition examples: &quot; &lt;&lt; *p &lt;&lt; *(p + 2)
              &lt;&lt; *(2 + p) &lt;&lt; *(p - 1) &lt;&lt; '\n';
    char* p2 = &amp;a[4];
    std::cout &lt;&lt; &quot;Pointer difference: &quot; &lt;&lt; p2 - p &lt;&lt; '\n';
}
 | output=
 2 + (-10), where 2 is a char    = -8
 2 + (-10), where 2 is unsigned  = 4294967288
 -10 - 2.12  = -12.12
Pointer addition examples: bdda
Pointer difference: 3
}}

====Multiplicative operators====

For every pair of promoted arithmetic types {{tt|LA}} and {{tt|RA}} and for every pair of promoted integral types {{tt|LI}} and {{tt|RI}} the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | LRA operator*(LA, RA)}}
{{dcl | LRA operator/(LA, RA)}}
{{dcl | LRI operator%(LI, RI)}}
{{dcl end}}
where {{tt|LRx}} is the result of usual arithmetic conversions on {{tt|Lx}} and {{tt|Rx}}

The binary operator * performs multiplication of its operands (after usual arithmetic conversions).

The binary operator / divides the first operand by the second (after usual arithmetic conversions).If the second operand is zero, the behavior is undefined. For integral operands, it yields the algebraic quotient.
{{rev begin}}
{{rev | until=c++11 | The quotient is rounded in implementation-defined direction. }}
{{rev | since=c++11 | The quotient is truncated towards zero (fractional part is discarded).}}
{{rev end}}

The binary operator % yields the remainder of the division of the first operand by the second (after usual arithmetic conversions). If the quotient {{tt|a/b}} is representible in the result type, {{c|1=(a/b)*b + a%b == a}}. If the second operand is zero, the behavior is undefined. If the quotient {{tt|a/b}} is not representible in the result type, the behavior of both {{tt|a/b}} and {{tt|a%b}} is undefined (that means {{c|INT_MIN%-1}} is undefined on 2's complement systems)

Note: Until C++11, if one or both operands to binary operator % were negative, the sign of the remainder was implementation-defined, as it depends on the rounding direction of integer division. The function {{lc|std::div}} provided well-defined behavior in that case.

{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout &lt;&lt;  &quot;2 * (-10), where 2 is a char    = &quot; &lt;&lt; c * n &lt;&lt; '\n'
              &lt;&lt;  &quot;2 * (-10), where 2 is unsigned  = &quot; &lt;&lt; un * n &lt;&lt; '\n'
              &lt;&lt;  &quot;-10 / 2.12  = &quot; &lt;&lt; n / 2.12 &lt;&lt; '\n'
              &lt;&lt;  &quot;-10 / 21  = &quot; &lt;&lt; n / 21 &lt;&lt; '\n'
              &lt;&lt;  &quot;-10 % 21  = &quot; &lt;&lt; n % 21 &lt;&lt; '\n';
}
 | output=
2 * (-10), where 2 is a char    = -20
2 * (-10), where 2 is unsigned  = 4294967276
-10 / 2.12  = -4.71698
-10 / 21  = 0
-10 % 21  = -10
}}

====Bitwise logic operators====
For every pair of promoted integral types {{tt|L}} and {{tt|R}} the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl |R operator~(R)}}
{{dcl |LR operator&amp;(L, R)}}
{{dcl |LR operator^(L, R)}}
{{dcl |LR operator{{!}}(L, R)}}
{{dcl end}}
where {{tt|LR}} is the result of usual arithmetic conversions on {{tt|L}} and {{tt|R}}

The result of operator~ is the bitwise NOT (one's complement) value of the argument (after promotion). The result of operator&amp; is the bitwise AND value of the operands (after usual arithmetic conversions). The result of operator| is the bitwise OR value of the operands (after usual arithmetic conversions). The result of operator^ is the bitwise XOR value of the operands (after usual arithmetic conversions)

{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    uint16_t mask = 0x00f0;
    uint32_t a = 0x12345678;
    std::cout &lt;&lt; &quot;Value: &quot; &lt;&lt; a &lt;&lt; &quot; mask: &quot; &lt;&lt; mask &lt;&lt; '\n'
              &lt;&lt; &quot;Setting bits: &quot; &lt;&lt; (a {{!}} mask) &lt;&lt; '\n'
              &lt;&lt; &quot;Clearing bits: &quot; &lt;&lt; (a &amp; ~mask) &lt;&lt; '\n'
              &lt;&lt; &quot;Selecting bits: &quot; &lt;&lt; (a &amp; mask) &lt;&lt; '\n';
}
 | output=
Value: 0x12345678 mask: 0xf0
Setting bits: 0x123456f8
Clearing bits: 0x12345608
Selecting bits: 0x70
}}

====Bitwise shift operators====
For every pair of promoted integral types {{tt|L}} and {{tt|R}}, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | L operator&lt;&lt;(L, R)}}
{{dcl | L operator&gt;&gt;(L, R)}} 
{{dcl end}}
The operands of the built-in bitwise shift operators have either integral types or unscoped enumeration type. Integral promotions are performed on both operands before evaluation. The return type is the type of the left operand after integral promotions. 

For unsigned {{tt|a}}, the value of {{tt|a &lt;&lt; b}} is the value of {{math|a * 2{{su|p=b}}}}, reduced modulo maximum value of the return type plus 1 (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded). For signed {{tt|a}}, the value of {{tt|a &lt;&lt; b}} is {{math|a * 2{{su|p=b}}}} if it is representable in the unsigned version of the return type (which is then converted to signed: this makes it legal to create {{lc|INT_MIN}} as {{c|1&lt;&lt;31}}), otherwise the behavior is undefined.

For unsigned {{tt|a}} and for signed {{tt|a}} with nonnegative values, the value of {{tt|a &gt;&gt; b}} is the integer part of {{math|a/2{{su|p=b}}}}. For negative {{tt|a}}, the value of {{tt|a &gt;&gt; b}} is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative)

In any case, if the value of the right operand is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.

{{example
 |
 | code=
#include &lt;iostream&gt;
enum {ONE=1, TWO=2};
int main()
{
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    char c = 0x10;
    unsigned long long ull = 0x123;
    std::cout &lt;&lt; &quot;0x123 &lt;&lt; 1 = &quot; &lt;&lt; (ull &lt;&lt; 1) &lt;&lt; '\n'
              &lt;&lt; &quot;0x123 &lt;&lt; 63 = &quot; &lt;&lt; (ull &lt;&lt; 63) &lt;&lt; '\n' // overflow in unsigned
              &lt;&lt; &quot;0x10 &lt;&lt; 10 = &quot; &lt;&lt; (c &lt;&lt; 10) &lt;&lt; '\n';   // char is promoted to int
    long long ll = -1000;
    std::cout &lt;&lt; std::dec &lt;&lt; &quot;-1000 &gt;&gt; 1 = &quot; &lt;&lt; (ll &gt;&gt; ONE) &lt;&lt; '\n';
}
 | output=
0x123 &lt;&lt; 1 = 0x246
0x123 &lt;&lt; 63 = 0x8000000000000000
0x10 &lt;&lt; 10 = 0x4000
-1000 &gt;&gt; 1 = -500
}}

===Standard library===
Arithmetic operators are overloaded for many standard library types.

====Unary arithmetic operators====
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith2}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith}}
{{dsc end}}

====Additive operators====
{{dsc begin}}
{{dsc inc | cpp/chrono/time_point/dsc operator_arith2}}
{{dsc inc | cpp/string/basic_string/dsc operator+}}
{{dsc mem fun | cpp/iterator/reverse_iterator/operator_arith | title=operator+&lt;br&gt;operator- | advances or decrements the iterator }}
{{dsc mem fun | cpp/iterator/move_iterator/operator_arith | title=operator+&lt;br/&gt;operator- | advances or decrements the iterator }}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith3}}
{{dsc end}}

====Multiplicative operators====
{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith4}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith3}}
{{dsc end}}

====Bitwise logic operators====
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic2}}
{{dsc mem fun | cpp/numeric/valarray/operator_arith | title=operator~ | applies a unary arithmetic operator to each element of the valarray}}
{{dsc tfun | cpp/numeric/valarray/operator_arith3 | title=operator^&lt;br&gt;operator&amp;&lt;br&gt;operator{{!}}| applies binary operators to each element of two valarrays, or a valarray and a value }}
{{dsc end}}

====Bitwise shift operators====
{{dsc begin}}
{{dsc tfun | cpp/numeric/valarray/operator_arith3 | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | applies binary operators to each element of two valarrays, or a valarray and a value }}
{{dsc mem fun | cpp/utility/bitset/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs binary shift left and shift right}}
{{dsc end}}

====Stream insertion/extraction operators====
Throughout the standard library, bitwise shift operators are commonly overloaded with I/O stream ({{c|std::ios_base&amp;}} or one of the classes derived from it) as both the left operand and return type. Such operators are known as ''stream insertion'' and ''stream extraction'' operators:

{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt2}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt2}}
{{dsc inc | cpp/numeric/complex/dsc operator_ltltgtgt}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt2}}
{{dsc inc | cpp/string/basic_string/dsc operator_ltltgtgt}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | uniform_int_distribution}}
{{dsc end}}

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator arithmetic]]
[[es:cpp/language/operator arithmetic]]
[[fr:cpp/language/operator arithmetic]]
[[it:cpp/language/operator arithmetic]]
[[ja:cpp/language/operator arithmetic]]
[[pt:cpp/language/operator arithmetic]]
[[ru:cpp/language/operator arithmetic]]
[[zh:cpp/language/operator arithmetic]]</text>
      <sha1>q4in20e9b38iw2i9x3xdtmbtc3stw94</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator assignment</title>
    <ns>0</ns>
    <id>704</id>
    <revision>
      <id>72416</id>
      <parentid>71853</parentid>
      <timestamp>2014-08-20T18:50:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mark up braced-init-list right-hand arguments with c++11 and mention them more consistently</comment>
      <text xml:space="preserve" bytes="8946">{{title|Assignment operators}}
{{cpp/language/expressions/navbar}}
Assignment operators modify the value of the object. 

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| simple assignment 
| {{tt|1=a = b}} 
| {{yes}}
| {{c|1=T&amp; T::operator =(const T2&amp; b);}} 
| {{n/a}}
|-
| addition assignment 
| {{tt|1=a += b}}
| {{yes}}
| {{c|1=T&amp; T::operator +=(const T2&amp; b);}}
| {{c|1=T&amp; operator +=(T&amp; a, const T2&amp; b);}}
|-
| subtraction assignment 
| {{tt|1=a -= b}}
| {{yes}}
| {{c|1=T&amp; T::operator -=(const T2&amp; b);}}
| {{c|1=T&amp; operator -=(T&amp; a, const T2&amp; b);}}
|-
| multiplication assignment 
| {{tt|1=a *= b}}
| {{yes}}
| {{c|1=T&amp; T::operator *=(const T2&amp; b);}}
| {{c|1=T&amp; operator *=(T&amp; a, const T2&amp; b);}}
|-
| division assignment 
| {{tt|1=a /= b}}
| {{yes}}
| {{c|1=T&amp; T::operator /=(const T2&amp; b);}}
| {{c|1=T&amp; operator /=(T&amp; a, const T2&amp; b);}}
|-
| modulo assignment 
| {{tt|1=a %= b}}
| {{yes}}
| {{c|1=T&amp; T::operator %=(const T2&amp; b);}}
| {{c|1=T&amp; operator %=(T&amp; a, const T2&amp; b);}}
|-
| bitwise AND assignment 
| {{tt|1=a &amp;= b}}
| {{yes}}
| {{c|1=T&amp; T::operator &amp;=(const T2&amp; b);}}
| {{c|1=T&amp; operator &amp;=(T&amp; a, const T2&amp; b);}}
|-
| bitwise OR assignment 
| {{tt|1=a &amp;#124;= b}}
| {{yes}}
| {{c|1=T&amp; T::operator {{!}}=(const T2&amp; b);}}
| {{c|1=T&amp; operator {{!}}=(T&amp; a, const T2&amp; b);}}
|-
| bitwise XOR assignment 
| {{tt|1=a ^= b}}
| {{yes}}
| {{c|1=T&amp; T::operator ^=(const T2&amp; b);}}
| {{c|1=T&amp; operator ^=(T&amp; a, const T2&amp; b);}}
|-
| bitwise left shift assignment 
| {{tt|1=a &lt;&lt;= b}}
| {{yes}}
| {{c|1=T&amp; T::operator &lt;&lt;=(const T2&amp; b);}}
| {{c|1=T&amp; operator &lt;&lt;=(T&amp; a, const T2&amp; b);}}
|-
| bitwise right shift assignment 
| {{tt|1=a &gt;&gt;= b}}
| {{yes}}
| {{c|1=T&amp; T::operator &gt;&gt;=(const T2&amp; b);}}
| {{c|1=T&amp; operator &gt;&gt;=(T&amp; a, const T2&amp; b);}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* All built-in assignment operators return {{c|*this}}, and most user-defined overloads also return {{c|*this}} so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}).
* {{tt|T2}} can be any type including {{tt|T}}
|}

===Explanation===

''copy assignment'' operator replaces the contents of the object {{tt|a}} with a copy of the contents of {{tt|b}} ({{tt|b}} is not modified). For class types, this is a special member function, described in [[cpp/language/as_operator|copy assignment operator]].

''move assignment'' operator replaces the contents of the object {{tt|a}} with the contents of {{tt|b}}, avoiding copying if possible ({{tt|b}} may be modified). For class types, this is a special member function, described in [[cpp/language/move_operator|move assignment operator]].  {{mark since c++11}} 

For non-class types, copy and move assignment are indistinguishable and are referred to as ''direct assignment''.

''compound assignment'' operators replace the contents the contents of the object {{tt|a}} with the result of a binary operation between the previous value of {{tt|a}} and the value of {{tt|b}}.

====Builtin direct assignment====

For every type {{tt|T}}, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | T*&amp; operator{{=}}(T*&amp;, T*);}}
{{dcl | T*volatile &amp; operator{{=}}(T*volatile &amp;, T*);}}
{{dcl end}}

For every enumeration or pointer to member type {{tt|T}}, optionally volatile-qualified, the following function signature participates in overload resolution:
{{dcl begin}}
{{dcl | T&amp; operator{{=}}(T&amp;, T );}}
{{dcl end}}

For every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signature participates in overload resolution:
{{dcl begin}}
{{dcl | A1&amp; operator{{=}}(A1&amp;, A2);}}
{{dcl end}}

For expressions E1 of any scalar type {{tt|T}}, the following additional forms of the builtin assignment expression are allowed:
{{dcl begin}}
{{dcl | E1 {{=}} {} | notes={{mark since c++11}}}}
{{dcl | E1 {{=}} {E2} | notes={{mark since c++11}}}}
{{dcl end}}

Note: the above includes all non-class types except reference types, array types, function types, and the type {{c|void}}, which are not directly assignable.

The direct assignment operator expects a modifiable lvalue as its left operand and an rvalue expression {{rev inl|since=c++11|or a ''braced-init-list''}} as its right operand, and returns an lvalue identifying the left operand after modification.

For non-class types, the right operand is first [[cpp/language/implicit_cast|implicitly converted]] to the cv-unqualified type of the left operand, and then its value is copied into the object identified by left operand.

When the left operand has reference type, the assignment operator modifies the referred-to object.

If the left and the right operands identify overlapping objects, the behavior is undefined (unless the overlap is exact and the type is the same)

{{rev begin}}
{{rev|since=c++11|
If the right operand is a ''braced-init-list''
* the expression {{c|1=E1 = {} }} is equivalent to {{c|1=E1 = T{} }}, where {{tt|T}} is the type of {{tt|E1}}.
* the expression {{c|1=E1 = {E2} }} is equivalent to {{c|1=E1 = T{E2} }}, where {{tt|T}} is the type of {{tt|E1}}.

For class types, the syntax {{tt|E {{=}} {e1, e2, e3} }} generates a call to the assignment operator with the ''braced-init-list'' as the argument, which then selects the appropriate assignment operator following the rules of {{rlp|overload resolution}}
}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    int n = 0;  // not an assignment
    n = 1;      // direct assignment
    std::cout &lt;&lt; n &lt;&lt; ' ';
    n = {};     // zero-initialization, then assignment
    std::cout &lt;&lt; n &lt;&lt; ' ';
    n = 'a';    // integral promotion, then assignment
    std::cout &lt;&lt; n &lt;&lt; ' ';
    n = {'b'};   // explicit cast, then assignment
    std::cout &lt;&lt; n &lt;&lt; ' ';
    n = 1.0;    // floating-point conversion, then assignment
    std::cout &lt;&lt; n &lt;&lt; ' ';
//    n = {1.0}; // compiler error (narrowing conversion)

    int&amp; r = n;  // not an assignment
    int* p;

    r = 2;       // assignment through reference
    std::cout &lt;&lt; n &lt;&lt; '\n';
    p = &amp;n;      // direct assignment
    p = nullptr; // null-pointer conversion, then assignment 

    struct {int a; std::string s;} obj;
    obj = {1, &quot;abc&quot;}; // assignment from a braced-init-list
    std::cout &lt;&lt; obj.a &lt;&lt; ':' &lt;&lt; obj.s &lt;&lt; '\n';
}
 | output=
1 0 97 98 1 2
1:abc
}}

====Builtin compound assignment====

For every pair A1 and A2, where A1 is an arithmetic type (optionally volatile-qualified) and A2 is a promoted arithmetic type, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl |A1&amp; operator*{{=}}(A1&amp;, A2);}}
{{dcl |A1&amp; operator/{{=}}(A1&amp;, A2);}}
{{dcl |A1&amp; operator+{{=}}(A1&amp;, A2);}}
{{dcl |A1&amp; operator-{{=}}(A1&amp;, A2);}}
{{dcl end}}

For every pair I1 and I2, where I1 is an integral type (optionally volatile-qualified) and I2 is a promoted integral type, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl |I1&amp; operator%{{=}}(I1&amp;, I2);}}
{{dcl |I1&amp; operator&lt;&lt;{{=}}(I1&amp;, I2);}}
{{dcl |I1&amp; operator&gt;&gt;{{=}}(I1&amp;, I2);}}
{{dcl |I1&amp; operator&amp;{{=}}(I1&amp;, I2);}}
{{dcl |I1&amp; operator^{{=}}(I1&amp;, I2);}}
{{dcl |I1&amp; operator{{!}}{{=}}(I1&amp;, I2);}}
{{dcl end}}

For every optionally cv-qualified object type {{tt|T}}, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl |T*&amp; operator+{{=}}(T*&amp;, std::ptrdiff_t);}}
{{dcl |T*&amp; operator-{{=}}(T*&amp;, std::ptrdiff_t);}}
{{dcl |T*volatile &amp; operator+{{=}}(T*volatile &amp;, std::ptrdiff_t);}}
{{dcl |T*volatile &amp; operator-{{=}}(T*volatile &amp;, std::ptrdiff_t);}}
{{dcl end}}

The behavior of every builtin compound-assignment expression {{c|1=E1 op= E2}} (where E1 is a modifiable lvalue expression and E2 is an rvalue expression {{rev inl|since=c++11|or a ''braced-init-list''}}) is exactly the same as the behavior of the expression {{c|1=E1 = E1 op E2}}, except that the expression {{tt|E1}} is evaluated only once and that it behaves as a single operation with respect to indeterminately-sequenced function calls (e.g. in {{c|1=f(a += b, g())}}, the += is either not started at all or is completed as seen from inside {{c|g()}}).

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator assignment]]
[[es:cpp/language/operator assignment]]
[[fr:cpp/language/operator assignment]]
[[it:cpp/language/operator assignment]]
[[ja:cpp/language/operator assignment]]
[[pt:cpp/language/operator assignment]]
[[ru:cpp/language/operator assignment]]
[[zh:cpp/language/operator assignment]]</text>
      <sha1>nhay1q28opoq3llzeex17f74t6k5c5m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator comparison</title>
    <ns>0</ns>
    <id>705</id>
    <revision>
      <id>72313</id>
      <parentid>71540</parentid>
      <timestamp>2014-08-07T15:31:53Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Notes */ about equivalence vs. equality, copyed from the page [[cpp/concept/EqualityComparable]]</comment>
      <text xml:space="preserve" bytes="13060">{{title|Comparison operators}}
{{cpp/language/expressions/navbar}}
Compares the arguments.

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| equal to
| {{tt|1=a == b}}
| {{yes}}
| {{c|1=bool T::operator ==(const T2 &amp;b) const;}}
| {{c|1=bool operator ==(const T &amp;a, const T2 &amp;b);}}
|-
| not equal to
| {{tt|1=a != b}}
| {{yes}}
| {{c|1=bool T::operator !=(const T2 &amp;b) const;}}
| {{c|1=bool operator !=(const T &amp;a, const T2 &amp;b);}}
|-
| less than
| {{tt|1=a &lt; b}}
| {{yes}}
| {{c|1=bool T::operator &lt;(const T2 &amp;b) const;}}
| {{c|1=bool operator &lt;(const T &amp;a, const T2 &amp;b);}}
|-
| greater than
| {{tt|1=a &gt; b}}
| {{yes}}
| {{c|1=bool T::operator &gt;(const T2 &amp;b) const;}}
| {{c|1=bool operator &gt;(const T &amp;a, const T2 &amp;b);}}
|-
| less than or equal to
| {{tt|1=a &lt;= b}}
| {{yes}}
| {{c|1=bool T::operator &lt;=(const T2 &amp;b) const;}}
| {{c|1=bool operator &lt;=(const T &amp;a, const T2 &amp;b);}}
|-
| greater than or equal to
| {{tt|1=a &gt;= b}}
| {{yes}}
| {{c|1=bool T::operator &gt;=(const T2 &amp;b) const;}}
| {{c|1=bool operator &gt;=(const T &amp;a, const T2 &amp;b);}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* All built-in operators return {{c|bool}}, and most user-defined overloads also return {{c|bool}} so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}).
* {{tt|T2}} can be any type including {{tt|T}}
|}

===Explanation===

Returns the boolean result of comparison of the values of the arguments, which are not modified.

====Arithmetic comparison operators====
For every pair of promoted arithmetic types {{tt|L}} and {{tt|R}}, including enumeration types, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | bool operator&lt;(L, R);}}
{{dcl | bool operator&gt;(L, R);}}
{{dcl |1= bool operator&lt;=(L, R);}}
{{dcl |1= bool operator&gt;=(L, R);}}
{{dcl |1= bool operator==(L, R);}}
{{dcl |1= bool operator!=(L, R);}}
{{dcl end}}
If the operands has arithmetic or enumeration type (scoped or unscoped), ''usual arithmetic conversions'' are performed following the rules for [[cpp/language/operator_arithmetic|arithmetic operators]]. The values are compared after conversions:
===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::boolalpha;
    int n = -1;

    int n2 = 1;
    std::cout &lt;&lt; &quot; -1 == 1? &quot; &lt;&lt; (n == n2) &lt;&lt; '\n'
              &lt;&lt; &quot;Comparing two signed values:\n&quot;
              &lt;&lt; &quot; -1  &lt; 1? &quot; &lt;&lt; (n &lt; n2) &lt;&lt; '\n'
              &lt;&lt; &quot; -1  &gt; 1? &quot; &lt;&lt; (n &gt; n2) &lt;&lt; '\n';

    unsigned int u = 1;
    std::cout &lt;&lt; &quot;Comparing signed and unsigned:\n&quot;
              &lt;&lt; &quot; -1  &lt; 1? &quot; &lt;&lt; (n &lt; u) &lt;&lt; '\n'
              &lt;&lt; &quot; -1  &gt; 1? &quot; &lt;&lt; (n &gt; u) &lt;&lt; '\n';

    unsigned char uc = 1;
    std::cout &lt;&lt; &quot;Comparing signed and smaller unsigned:\n&quot;
              &lt;&lt; &quot; -1  &lt; 1? &quot; &lt;&lt; (n &lt; uc) &lt;&lt; '\n'
              &lt;&lt; &quot; -1  &gt; 1? &quot; &lt;&lt; (n &gt; uc) &lt;&lt; '\n';
}
 | output=
 -1 == 1? false
Comparing two signed values:
 -1  &lt; 1? true
 -1  &gt; 1? false
Comparing signed and unsigned:
 -1  &lt; 1? false
 -1  &gt; 1? true
Comparing signed and smaller unsigned:
 -1  &lt; 1? true
 -1  &gt; 1? false
}}

====Pointer comparison operators====
For every type {{tt|P}} which is either pointer to object or pointer to function or {{lc|std::nullptr_t}}, and for every type {{tt|MP}} that is a pointer to member object or pointer to member function, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | bool operator&lt;(P, P);}}
{{dcl | bool operator&gt;(P, P);}}
{{dcl |1= bool operator&lt;=(P, P);}}
{{dcl |1= bool operator&gt;=(P, P);}}
{{dcl |1= bool operator==(P, P);}}
{{dcl |1= bool operator!=(P, P);}}
{{dcl |1= bool operator==(MP, MP);}}
{{dcl |1= bool operator!=(MP, MP);}}
{{dcl end}}
{{todo|n3498 needs to be applied}}
Comparison operators can be used to compare two pointers (or pointers-to-members, for {{c|1=operator==}} and {{c|1=operator!=}} only), or a pointer and a null pointer constant, or two null pointer constants (but only as long as at least one of them is {{lc|std::nullptr_t}}: comparison of NULL and NULL follows arithmetic comparison rules). [[cpp/language/implicit_cast|Pointer conversions]] (pointer to member conversions if the arguments are pointers to members) and [[cpp/language/implicit_cast|qualification conversions]] are applied to both operands to obtain the ''composite pointer type'', as follows
@1@ If both operands are null pointer constants, the composite pointer type is {{lc|std::nullptr_t}}
@2@ If one operand a null pointer constant and the other is a pointer, the composite type is exactly the pointer type
@3@ If both operands are pointers to the same type, with different cv-qualification, the composite is pointer to the same type with cv-qualification that is a union of the cv-qualifications of the arguments.
Note that this implies that any pointer can be compared with {{c|void*}}.

Results of comparing two pointers (after conversions) are determined as follows:
@1@ If the pointers {{tt|p}} and {{tt|q}} 
:@a@ point to the same object or function
:@b@ or point one past the end of the same array
:@c@ or are both null pointers

:then the pointers ''compare equal'': {{c|1=p==q}}, {{c|1=p&lt;=q}}, and {{c|1=p&gt;=q}} return {{c|true}}, while {{c|1=p!=q}}, {{c|p&lt;q}}, and {{c|p&gt;q}} return {{c|false}},
@2@ If one of the operands is a null pointer and the other is not, they compare unequal: {{c|1=p==q}} returns {{c|true}}, {{c|1=p!=q}} returns {{c|false}}, the behavior of other operators is unspecified.
@3@ If the pointers {{tt|p}} and {{tt|q}} point to members of the same array {{c|a[i]}} and {{c|a[j]}} or one past the end of the array, they results of comparing the pointers is the same as the result of comparing the indexes: if {{c|1=i&lt;j==true}} then {{c|p&lt;q {{==}} true}}.
@4@ If the pointers {{tt|p}} and {{tt|q}} point to non-static data members within the same class or different base subobjects within the same derived class, or to their members or subobjects, recursively, and if the pointed-to members/subobjects have the same access control (e.g. both {{tt|public:}}), and the class is not a union, then the pointer to the later declared subobject/member compares greater than the pointer to the earlier declared subobject/member. In other words, class members in each of the three access  modes are positioned in memory in order of declaration.
@6@ If the pointers {{tt|p}} and {{tt|q}} point to members of the same {{c|union}}, they compare equal (typically an explicit conversion to {{c|void*}} is required for one of the operands)
@7@ If one of the pointers is a pointer to {{c|void}} and both pointers point to the same address or are both null pointers, they compare equal.
@8@ If two null pointer constants are compared, they compare equal.
@9@ If both operands are pointers to member (object or function), they compare equal if they both point to the same member of the most derived class.
@10@ Otherwise (if the pointers point to objects in different arrays, or to different functions, or to members of some object with different access control, etc), the results of {{c|p&lt;q}}, {{c|p&gt;q}}, {{c|1=p&lt;=q}}, and {{c|1=p&gt;=q}} are unspecified, and {{c|1=p!=q}} returns {{c|false}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
struct Foo  { int n1; int n2; };
union Union { int n; double d; };
int main()
{
    std::cout &lt;&lt; std::boolalpha;

    char a[4] = &quot;abc&quot;;

    char* p1 = &amp;a[1];
    char* p2 = &amp;a[2];
    std::cout &lt;&lt; &quot;Pointers to array elements: p1 == p2 &quot; &lt;&lt; (p1 == p2)
              &lt;&lt; &quot;, p1 &lt; p2 &quot;  &lt;&lt; (p1 &lt; p2) &lt;&lt; '\n';

    Foo f;
    int* p3 = &amp;f.n1;
    int* p4 = &amp;f.n2;
    std::cout &lt;&lt; &quot;Pointers to members of a class: p3 == p4 &quot; &lt;&lt; (p3 == p4)
              &lt;&lt; &quot;, p3 &lt; p4 &quot;  &lt;&lt; (p3 &lt; p4) &lt;&lt; '\n';

    Union u;
    int* p5 = &amp;u.n;
    double* p6 = &amp;u.d;
    std::cout &lt;&lt; &quot;Pointers to members of a union: p5 == (void*)p6 &quot; &lt;&lt; (p5 == (void*)p6)
              &lt;&lt; &quot;, p5 &lt; p6 &quot;  &lt;&lt; (p5 &lt; (void*)p6) &lt;&lt; '\n';
}
 | output=
Pointers to array elements: p1 == p2 false, p1 &lt; p2 true
Pointers to members of a class: p3 == p4 false, p3 &lt; p4 true
Pointers to members of a union: p5 == (void*)p6 true, p5 &lt; p6 false
}}

===Notes===
Because these operators group left-to-right, the expression {{c|a&lt;b&lt;c}} is parsed {{c|(a&lt;b)&lt;c}}, and not {{c|a&lt;(b&lt;c)}} or {{c|(a&lt;b)&amp;&amp;(b&lt;c)}}.

A common requirement for user-defined {{tt|operator&lt;}} is [[enwiki:Strict weak ordering|strict weak ordering]]. In particular, this is required by the standard algorithms and containers that work with {{concept|Compare}} types: {{lc|std::sort}}, {{lc|std::max_element}}, {{lc|std::map}}, etc.

Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations provide [[enwiki:Total order#Strict total order|strict total ordering]] of pointers, e.g. if they are implemented as addresses within continuous virtual address space. Those implementations that do not (e.g. where not all bits of the pointer are part of a memory address and have to be ignored for comparison, or an additional calculation is required or otherwise pointer and integer is not a 1 to 1 relationship), provide a specialization of {{lc|std::less}} for pointers that has that guarantee. This makes it possible to use all pointers of random origin as keys in standard associative containers such as {{lc|std::set}} or {{lc|std::map}}.

For the types that are both {{concept|EqualityComparable}} and {{concept|LessThanComparable}}, the C++ standard library makes a distinction between ''equality'', which is the value of the expression {{c|a {{==}} b}} and ''equivalence'', which is the value of the expression {{c|!(a &lt; b) &amp;&amp; !(b &lt; a)}}.

===Standard library===
Comparison operators are overloaded for many classes in the standard library.

{{dsc begin}}
{{dsc inc | cpp/types/type_info/dsc operator_cmp}}
{{dsc inc | cpp/error/error_code/dsc operator_cmp}}
{{dsc inc | cpp/error/error_condition/dsc operator_cmp}}
{{dsc inc | cpp/utility/pair/dsc operator_cmp}}
{{dsc inc | cpp/utility/tuple/dsc operator_cmp}}
{{dsc inc | cpp/utility/bitset/dsc operator_cmp}}
{{dsc inc | cpp/memory/allocator/dsc operator_cmp}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator_cmp}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator_cmp}}
{{dsc inc | cpp/utility/functional/function/dsc operator_cmp}}
{{dsc inc | cpp/chrono/duration/dsc operator_cmp}}
{{dsc inc | cpp/chrono/time_point/dsc operator_cmp}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc operator_cmp}}
{{dsc inc | cpp/types/type_index/dsc operator_cmp}}
{{dsc inc | cpp/string/basic_string/dsc operator_cmp}}
{{dsc inc | cpp/locale/locale/dsc operator_cmp}}
{{dsc inc | cpp/container/dsc operator_cmp | array}}
{{dsc inc | cpp/container/dsc operator_cmp | deque}}
{{dsc inc | cpp/container/dsc operator_cmp | forward_list}}
{{dsc inc | cpp/container/dsc operator_cmp | list}}
{{dsc inc | cpp/container/dsc operator_cmp | vector}}
{{dsc inc | cpp/container/dsc operator_cmp | map}}
{{dsc inc | cpp/container/dsc operator_cmp | multimap}}
{{dsc inc | cpp/container/dsc operator_cmp | set}}
{{dsc inc | cpp/container/dsc operator_cmp | multiset}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_map}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multimap}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_set}}
{{dsc inc | cpp/container/dsc operator_cmp_unord | unordered_multiset}}
{{dsc inc | cpp/container/dsc operator_cmp | queue}}
{{dsc inc | cpp/container/dsc operator_cmp | stack}}
{{dsc inc | cpp/iterator/adaptor/dsc operator cmp|reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator cmp|move_iterator}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator_cmp}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator_cmp}}
{{dsc inc | cpp/numeric/complex/dsc operator_cmp}}
{{dsc inc | cpp/numeric/valarray/dsc operator_cmp}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_cmp |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | poisson_distribution }}
{{dsc inc | cpp/regex/sub_match/dsc operator_cmp}}
{{dsc inc | cpp/regex/match_results/dsc operator_cmp}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator_cmp}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator_cmp}}
{{dsc inc | cpp/thread/thread/id/dsc operator_cmp}}
{{dsc inc | cpp/utility/rel_ops/dsc operator_cmp}}
{{dsc end}}

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator comparison]]
[[es:cpp/language/operator comparison]]
[[fr:cpp/language/operator comparison]]
[[it:cpp/language/operator comparison]]
[[ja:cpp/language/operator comparison]]
[[pt:cpp/language/operator comparison]]
[[ru:cpp/language/operator comparison]]
[[zh:cpp/language/operator comparison]]</text>
      <sha1>720h1d7cjfaw41f7pv6i3niwb64joh7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator incdec</title>
    <ns>0</ns>
    <id>706</id>
    <revision>
      <id>67219</id>
      <parentid>66832</parentid>
      <timestamp>2014-01-27T17:32:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link lvalue and object type</comment>
      <text xml:space="preserve" bytes="6854">{{title|Increment/decrement operators}}
{{cpp/language/expressions/navbar}}
Increment/decrement operators increments or decrements the value of the object. 

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| pre-increment
| {{tt|++a}} 
| {{yes}}
| {{c|T&amp; T::operator++();}} 
| {{c|T&amp; operator++(T&amp; a);}}
|-
| pre-decrement
| {{tt|--a}} 
| {{yes}}
| {{c|T&amp; T::operator--();}} 
| {{c|T&amp; operator--(T&amp; a);}}
|-
| post-increment
| {{tt|a++}} 
| {{yes}}
| {{c|T T::operator++(int);}} 
| {{c|T operator++(T&amp; a, int);}}
|-
| post-decrement
| {{tt|a--}} 
| {{yes}}
| {{c|T T::operator--(int);}} 
| {{c|T operator--(T&amp; a, int);}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* Prefix forms of the built-in operators return references and postfix forms return values, and typical user-defined overloads follow the pattern so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}).
* The {{c|int}} parameter is a dummy parameter used to differentiate between pre- and post- in versions of the operators. When the user-defined postfix operator is called, the value passed in that parameter is always zero, although it may be changed by calling the operator using function call notation, e.g. {{c|a.operator++(2)}}.
|}

===Explanation===

''pre-increment'' and ''pre-decrement'' operators increments or decrements the value of the object and returns a reference to the result.

''post-increment'' and ''post-decrement'' creates a copy of the object, increments or decrements the value of the object and returns the copy from before the increment or decrement.

====Built-in prefix operators====

For every optionally volatile-qualified arithmetic type {{tt|A}} other than {{c|bool}}, and for every optionally volatile-qualified pointer {{tt|P}} to optionally cv-qualified object type, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | A&amp; operator++(A&amp;)}}
{{dcl | bool&amp; operator++(bool&amp;) | notes={{mark deprecated}}}}
{{dcl | P&amp; operator++(P&amp;)}}
{{dcl | A&amp; operator--(A&amp;)}}
{{dcl | P&amp; operator--(P&amp;)}}
{{dcl end}}

The operand of a built-in prefix increment or decrement operator must be a modifiable (non-const) {{rlp|value category|lvalue}} of non-boolean arithmetic type or pointer to complete {{rlp|type|object type}}. For these operands, the expression {{c|++x}} is exactly equivalent to {{c|1=x+=1}}, and the expression {{c|--x}} is exactly equivalent to {{c|1=x-=1}}, that is, the result is the updated operand, returned as lvalue, and all arithmetic conversion rules and pointer arithmetic rules defined for [[cpp/language/operator_arithmetic|arithmetic operators]] apply.

If the operand of the preincrement operator is of type {{c|bool}}, it is set to {{c|true}} {{mark deprecated}}.

====Built-in postfix operators====

For every optionally volatile-qualified arithmetic type {{tt|A}} other than {{c|bool}}, and for every optionally volatile-qualified pointer {{tt|P}} to optionally cv-qualified object type, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | A operator++(A&amp;, int)}}
{{dcl | bool operator++(bool&amp;, int) | notes={{mark deprecated}}}}
{{dcl | P operator++(P&amp;, int)}}
{{dcl | A operator--(A&amp;, int)}}
{{dcl | P operator--(P&amp;, int)}}
{{dcl end}}

The operand of a built-in postfix increment or decrement operator must be a modifiable (non-const) {{rlp|value category|lvalue}} of non-boolean arithmetic type or pointer to complete {{rlp|type|object type}}. The result is a prvalue, which is a copy the original value of the operand. As a side-effect, this operator modifies the value of its argument {{tt|arg}} as if by evaluating {{c|1=arg += 1}} or {{c|1=arg -= 1}}, for increment and decrement respectively. All arithmetic conversion rules and pointer arithmetic rules defined for [[cpp/language/operator_arithmetic|arithmetic operators]] apply.

If the operand of the postincrement operator is of type {{c|bool}}, it is set to {{c|true}} {{mark deprecated}}.

====Example====
{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    int n = 1;
    int n2 = ++n;
    int n3 = ++ ++n;
    int n4 = n++;
//    int n5 = n++ ++; // compile error
//    int n5 = n + ++n; // undefined behavior
    std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n'
              &lt;&lt; &quot;n2 = &quot; &lt;&lt; n2 &lt;&lt; '\n'
              &lt;&lt; &quot;n3 = &quot; &lt;&lt; n3 &lt;&lt; '\n'
              &lt;&lt; &quot;n4 = &quot; &lt;&lt; n4 &lt;&lt; '\n';
}
 | output=
n = 5
n2 = 2
n3 = 4
n4 = 4
}}

===Notes===
Because of the side-effects involved, built-in increment and decrement operators must be used with care to avoid undefined behavior due to violations of [[cpp/language/eval_order|sequencing rules]].

Because a temporary copy of the object is constructed during the operation, ''pre-increment'' or ''pre-decrement'' operators are usually more efficient in contexts where the returned value is not used.

===Standard library===
Increment and decrement operators are overloaded for many standard library types. In particular, every {{concept|Iterator}} overloads operator++ and every {{concept|BidirectionalIterator}} overloads operator--, even if those operators are no-ops for the particular iterator.

{{dsc begin}}
{{dsc h2 | overloads for arithmetic types}}
{{dsc inc | cpp/atomic/atomic/dsc operator_arith}}
{{dsc inc | cpp/chrono/duration/dsc operator_arith2}}
{{dsc h2 | overloads for iterator types}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_arith | reverse_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_arith | move_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | front_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | back_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator_arith | insert_iterator}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator_arith}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc operator_arith}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator_arith}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator_arith}}
{{dsc end}}

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator incdec]]
[[es:cpp/language/operator incdec]]
[[fr:cpp/language/operator incdec]]
[[it:cpp/language/operator incdec]]
[[ja:cpp/language/operator incdec]]
[[pt:cpp/language/operator incdec]]
[[ru:cpp/language/operator incdec]]
[[zh:cpp/language/operator incdec]]</text>
      <sha1>e5tsf3e25e2nhpvrkwhntlckqu1iu83</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator logical</title>
    <ns>0</ns>
    <id>5287</id>
    <revision>
      <id>66846</id>
      <parentid>58038</parentid>
      <timestamp>2014-01-03T15:07:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="5480">{{title|Logical operators}}
{{cpp/language/expressions/navbar}}
Returns the result of a boolean operation.

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| negation
| {{c|not a}}
{{tt|!a}}
| {{yes}}
| {{c|bool T::operator!() const;}}
| {{c|bool operator!(const T &amp;a);}}
|-
| AND
| {{c|a and b}}
{{tt|a&amp;nbsp;&amp;&amp;&amp;nbsp;b}}
| {{yes}}
| {{c|bool T::operator&amp;&amp;(const T2 &amp;b) const;}}
| {{c|bool operator&amp;&amp;(const T &amp;a, const T2 &amp;b);}}
|-
| inclusive OR
| {{c|a or b}}
{{tt|&lt;nowiki&gt;a&amp;nbsp;||&amp;nbsp;b&lt;/nowiki&gt;}}
| {{yes}}
| {{c|bool T::operator{{!!}}(const T2 &amp;b) const;}}
| {{c|bool operator{{!!}}(const T &amp;a, const T2 &amp;b);}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* The keyword-like forms ({{c|and}},{{c|or}},{{c|not}}) and the symbol-like forms ({{c|&amp;&amp;}},{{c|{{!!}}}},{{c|!}}) can be used interchangeably (See [[cpp/language/operator_alternative|alternative representations]]) 
* All built-in operators return {{c|bool}}, and most user-defined overloads also return {{c|bool}} so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}).
* Builtin operators {{ttb|&amp;&amp;}} and {{ttb|{{!!}}}} perform short-circuit evaluation (do not evaluate the second operand if the result is known after evaluating the first), but overloaded operators behave like regular function calls and always evaluate both operands
|}

===Explanation===

The logical operators apply logic functions (NOT, AND, and inclusive OR) to boolean arguments (or types contextually-convertible to {{c|bool}}), with a boolean result. Unlike the [[cpp/language/operator_arithmetic|bitwise logic operators]], these operators (in their built-in form) do not evaluate the second operand if the result is known after evaluating the first.

====Builtin operators====

The following built-in function signatures participate in overload resolution:
{{dcl begin}}
{{dcl |bool operator!(bool)}}
{{dcl |bool operator&amp;&amp;(bool, bool)}}
{{dcl |bool operator{{!!}}(bool, bool)}}
{{dcl end}}

If the operand is not {{c|bool}}, it is converted to {{c|bool}} using [[cpp/language/implicit_cast|contextual conversion to bool]]: it is only well-formed if the declaration {{tt|bool t(arg)}} is well-formed, for some invented temporary {{tt|t}}.

For the built-in logical NOT operator, the result is {{c|true}} if the operand is {{c|false}}. Otherwise, the result is {{c|false}}.

For the built-in logical AND operator, the result is {{c|true}} if both operands are {{c|true}}. Otherwise, the result is {{c|false}}. If the first operand is {{c|false}}, the second operand is not evaluated.

For the built-in logical OR operator, the result is {{c|true}} if either the first or the second operand (or both) is {{c|true}}. If the firstoperand is {{c|true}}, the second operand is not evaluated.

===Results===
{|table class=wikitable
!{{c|a}}
|{{c|true}}
|{{c|false}}
|-
!{{c|!a}}
|{{c|false}}
|{{c|true}}
|}
{|table class=wikitable
!colspan=2 rowspan=2|{{c|and}}
!colspan=2|{{c|a}}
|-
|{{c|true}} &lt;!--a--&gt;
|{{c|false}} &lt;!--a--&gt;
|-
!rowspan=2|{{c|b}}
|{{c|true}} &lt;!--b--&gt;
|{{c|true}} &lt;!--true&amp;&amp;true--&gt;
|{{c|false}}&lt;!--true&amp;&amp;false--&gt;
|-
|{{c|false}}&lt;!--b--&gt;
|{{c|false}}&lt;!--true&amp;&amp;false--&gt;
|{{c|false}}&lt;!--false&amp;&amp;false--&gt;
|}
{|table class=wikitable
!colspan=2 rowspan=2|{{c|or}}
!colspan=2|{{c|a}}
|-
|{{c|true}} &lt;!--a--&gt;
|{{c|false}}&lt;!--a--&gt;
|-
!rowspan=2|{{c|b}}
|{{c|true}}&lt;!--b--&gt;
|{{c|true}}&lt;!--true||true--&gt;
|{{c|true}}&lt;!--true||false--&gt;
|-
|{{c|false}}&lt;!--b--&gt;
|{{c|true}}&lt;!--false||true--&gt;
|{{c|false}}&lt;!--false||false--&gt;
|}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
int main()
{
    int n = 2;
    int* p = &amp;n;
    // pointers are convertible to bool
    if(    p &amp;&amp; *p == 2   // &quot;*p&quot; is safe to use after &quot;p &amp;&amp;&quot;
       {{!!}} !p &amp;&amp;  n != 2 ) // {{!!}} has lower precedence than &amp;&amp;
        std::cout &lt;&lt; &quot;true\n&quot;;

    // streams are also convertible to bool
    std::cout &lt;&lt; &quot;Enter 'quit' to quit.\n&quot;;
    for(std::string line;    std::cout &lt;&lt; &quot;&gt; &quot;
                          &amp;&amp; std::getline(std::cin, line)
                          &amp;&amp; line != &quot;quit&quot;; )
        ;
}
 | output=
true
Enter 'quit' to quit.
&gt; test
&gt; quit
}}

===Standard library===
Because the short-circuiting properties of {{tt|operator&amp;&amp;}} and {{tt|operator{{!!}}}} do not apply to overloads, and because types with boolean semantics are uncommon, only two standard library classes overload these operators:

{{dsc begin}}
{{dsc mem fun | cpp/numeric/valarray/operator_arith | title=operator! | applies a unary arithmetic operator to each element of the valarray}}
{{dsc tfun | cpp/numeric/valarray/operator_arith3 | title=operator&amp;&amp;&lt;br&gt;operator&lt;nowiki&gt;||&lt;/nowiki&gt; | applies binary operators to each element of two valarrays, or a valarray and a value }}
{{dsc inc | cpp/io/basic_ios/dsc operator!}}
{{dsc end}}

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator logical]]
[[es:cpp/language/operator logical]]
[[fr:cpp/language/operator logical]]
[[it:cpp/language/operator logical]]
[[ja:cpp/language/operator logical]]
[[pt:cpp/language/operator logical]]
[[ru:cpp/language/operator logical]]
[[zh:cpp/language/operator logical]]</text>
      <sha1>5evbl3dwa6hoy2ak92mj1h8sj16mnr4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator member access</title>
    <ns>0</ns>
    <id>707</id>
    <revision>
      <id>72334</id>
      <parentid>72051</parentid>
      <timestamp>2014-08-12T15:01:26Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Built-in member access operators */</comment>
      <text xml:space="preserve" bytes="15337">{{title|Member access operators}}
{{cpp/language/expressions/navbar}}
Accesses a member of an object.

{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| array subscript
| {{tt|a[b]}}
| {{yes}}
| {{c|R&amp; T::operator[](const T2&amp; b);}}
| {{n/a}}
|-
| indirection (variable pointed to by {{tt|a}})
| {{tt|*a}}
| {{yes}}
| {{c|1=R&amp; T::operator*();}}
| {{c|1=R&amp; operator*(T &amp;a);}}
|-
| address of
| {{tt|&amp;a}}
| {{yes}}
| {{c|R* T::operator&amp;();}}
| {{c|R* operator&amp;(T &amp;a);}}
|-
| member of object
| {{tt|a.b}}
| {{no}}
| {{n/a}}
| {{n/a}}
|-
| member of pointer
| {{tt|1=a-&gt;b}}
| {{yes}}
| {{c|R* T::operator-&gt;()}}
| {{n/a}}
|-
| pointer to member of object
| {{tt|a.*b}}
| {{no}}
| {{n/a}}
| {{n/a}}
|-
| pointer to member of pointer
| {{tt|1=a-&gt;*b}}
| {{yes}}
| {{c|R* T::operator-&gt;*(R)}}
| {{c|R* T::operator-&gt;*(T, R)}}
|-
| colspan=&quot;5&quot; |
:'''Notes'''&lt;br&gt;
* As with most user-defined overloads, return types should match return types provided by the builtin operators so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including {{c|void}}). One exception is {{tt|operator-&gt;}}, which must return a pointer or another class with overloaded {{tt|operator-&gt;}}.
|}

===Explanation===

''array subscript'' operator provides access to the elements in the internal array

''indirection'', ''member of pointer'' and ''pointer to member of pointer'' operators provide pointer semantics for any object. 

''member of pointer'' and ''pointer to member of pointer'' operators return a pointer to the actual object which will be used for member access.

====Built-in subscript operator====

For every object type {{tt|T}} (possibly cv-qualified), the following function signature participates in overload resolution:
{{dcl begin}}
{{dcl | T&amp; operator[](T*, std::ptrdiff_t); }}
{{dcl | T&amp; operator[](std::ptrdiff_t, T*); }}
{{dcl end}}

The non-pointer operand may be any expression of integral or unscoped enumeration type, it is [[cpp/language/implicit_cast|implicitly converted]] to {{lc|std::ptrdiff_t}}. The expression {{c|A[B]}} is exactly identical to the expression {{c|*(A+B)}}, that is, the pointer operand (which may be a result of array-to-pointer conversion, and which must point to an element of some array or one past the end) is adjusted to point at another element of the same array, following the rules of [[cpp/language/operator_arithmetic|pointer arithmetics]], and is then dereferenced.

When applied to an array, the subscript expression is an lvalue if the array is an lvalue, and xvalue if it isn't. When applied to a pointer, the subscript expression is always lvalue.

The type {{tt|T}} is not allowed to be an {{rlp|incomplete type}}, even if the size or internal structure of {{tt|T}} is never used, as in {{c|&amp;x[0]}}.

{{example
 |
 | code=
#include &lt;iostream&gt;

int main()
{
    int a[4] = {1,2,3,4};
    int* p = &amp;a[2];
    std::cout &lt;&lt; p[1] &lt;&lt; p[-1] &lt;&lt; 1[p] &lt;&lt; (-1)[p] &lt;&lt; '\n';
}
 | output=
4242
}}

====Built-in indirection operator====

For every type {{tt|T}} that is either object type (possibly cv-qualified) or function type (not const- or ref-qualified), the following function signature participates in overload resolution:
{{dcl begin}}
{{dcl | T&amp; operator*(T*); }}
{{dcl end}}

The operand of the built-in indirection operator is a pointer to object or function, and the result is the lvalue that the pointer is pointing at. Note that a pointer to incomplete type can be dereferenced, e.g. when initializing a reference.

{{example
 |
 | code=
#include &lt;iostream&gt;
int f() { return 42; }
int main()
{
    int n = 1;
    int* pn = &amp;n;

    int&amp; r = *pn;  // lvalue can be bound to a reference
    int m = *pn;   // indirection + lvalue-to-rvalue conversion

    int (*fp)() = &amp;f;
    int (&amp;fr)() = *fp; // function lvalue can be bound to a reference 
}
}}

====Built-in address-of operator====

The operand of the built-in {{tt|operator&amp;}} is either an lvalue expression of any type or the qualified name of a non-static member function/object in some class. This operator does not participate in overload resolution. If there are no {{rlp|overload resolution#Viable functions|viable functions}}, special rules are used: 

If the operand is an lvalue expression of some type {{tt|T}}, {{tt|operator&amp;}} creates and returns a prvalue of type {{tt|T*}}, with the same cv qualification, that is pointing at the object designated by the operand. If the operand has incomplete type, the pointer can be formed, but if that incomplete type happens to be a class that defines its own {{tt|operator&amp;}}, {{rev inl|until=c++14|the behavior is undefined}} {{rev inl|since=c++14|it is unspecified whether the built-in or the overload is used}}. For the operands of type with user-defined {{tt|operator&amp;}}, {{lc|std::addressof}} may be used to obtain the true pointer.

If the operand is the name of an overloaded function, the address may be taken only if the overload can be resolved due to context. See {{rlp|overloaded_address|Address of an overloaded function}} for details.

If the operand is a qualified name of a non-static member, e.g. {{c|&amp;Class::member}}, the result is a prvalue pointer to member function or pointer to member object of type {{tt|T}} in class {{tt|C}}. Note that neither {{c|&amp;member}} nor {{c|Class::member}} nor even {{c|&amp;(Class::member)}} may be used to initialize a pointer to member.

{{example
 |
 | code=
void f(int) {}
void f(double) {}
struct A { int i; };
struct B { void f(); };
int main()
{
    int n = 1;
    int* pn = &amp;n; // pointer
    int A::* mp = &amp;A::i;  // pointer to member object
    void (B::*mpf)() = &amp;B::f; // pointer to member function
 
//    auto pf2 = &amp;f; // error: ambiguous overloaded function type
    void (*pf)(int) = &amp;f; // overload resolution due to initialization
    auto pf2 = static_cast&lt;void(*)(int)&gt;(&amp;f); // overload resolution due to cast
}
}}

====Built-in member access operators====

The left operand of the built-in {{tt|operator.}} and {{tt|operator-&gt;}} is an expression of complete scalar type {{tt|T}} (for {{tt|operator.}}) or pointer to complete scalar type {{tt|T*}} (for {{tt|operator-&gt;}}), which is evaluated before the operator can be called. The right operand is the name of a member object or member function of {{tt|T}} or of one of {{tt|T}}'s base classes, e.g. {{c|expr.member}}, optionally {{rlp|identifiers#Qualified_identifiers|qualified}}, e.g. {{c|expr.name::member}}, optionally using {{rlp|dependent_name|template disambiguator}}, e.g. {{c|expr.template member}}.

The expression {{c|A-&gt;B}} is exactly equivalent to {{c|(*A).B}} for builtin types. If a user-defined {{tt|operator-&gt;}} is provided, {{tt|operator-&gt;}} is called again on the value that it returns, recursively, until the {{tt|operator-&gt;}} is reached that returns a plain pointer. After that, builtin semantics are applied to that pointer.

In the expression {{c|expr.B}},
@1@ if {{tt|B}} is a {{rlp|static|static data member}} of type {{tt|T}}, the result is an {{rlp|value category|lvalue}} {{tt|T}} designating that static data member.
@2@ if {{tt|B}} is a {{rlp|data members|non-static data member}} of type {{tt|T}}, the result is an lvalue of type {{tt|T}} if {{tt|B}} has type {{c|T&amp;}} or {{c|T&amp;&amp;}}, otherwise the result is an lvalue if {{tt|expr}} is an lvalue, or the result is a xvalue if {{tt|expr}} is an rvalue. If {{tt|B}} is not declared to be a ''mutable'' member, the {{rlp|cv|cv-qualification}} of the result is the union of cv-qualifications of {{tt|expr}} and {{tt|B}}. If {{tt|B}} is mutable, the cv-qualification of the result is the union of volatile-qualifications.
@3@ if {{tt|B}} is a static member function, the result is an lvalue designating the static memeber function. Essentially, {{tt|expr}} is evaluated and discarded in this case.
@4@ if {{tt|B}} is a {{rlp|member functions|non-static member function}} including a {{rlp|destructor}}, the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose.
@5@ if {{tt|B}} is a member enumeration, the result is a prvalue of the enum type.
@6@ if {{tt|B}} is a nested type, the program is ill-formed (won't compile)
@7@ if {{tt|expr}} has non-class scalar type and B is a {{ttb|~}} followed by the {{rlp|type#Type naming|type name}} or {{rlp|decltype|decltype specifier}} designating the same type (minus cv-qualifications), optionally {{rlp|identifiers#Qualified_identifiers|qualified}}, then the result is a special kind of prvalue that can only be used as the left-hand operand in a function-call expression, and for no other purpose. The function call is called ''pseudo destructor call'', it takes no arguments, returns void, and performs no action other than initial evaluation of expr. &lt;br /&gt;This is the only case where the left operand of {{tt|operator.}} has non-class type. Allowing pseudo destructor call makes it possible to write code without having to know if a destructor exists for a given type.

{{example
 |
 | code=
#include &lt;iostream&gt;

struct P {
    template&lt;typename T&gt;
    static T* ptr() noexcept {return new T;}
};
template&lt;typename T&gt;
struct A {
    class B {};
    enum E {RED = 1, BLUE = 2};
    int n;
    static int sn;
    int f() { return 10+n; }
    static int fs() { return 4; }
    A(int n) : n(n) {}
 
    // keyword template needed to refer to a dependent template member
    void g() {
        typedef int U;
        int* p = T().template ptr&lt;U&gt;();
        p-&gt;~U(); // U is int, this calls int's pseudo destructor
        delete p;
    }
};
template&lt;&gt; int A&lt;P&gt;::sn = 2;

int main()
{
    A&lt;P&gt; a(1);
    std::cout &lt;&lt; a.n &lt;&lt; ' '
              &lt;&lt; a.sn &lt;&lt; ' ' // &lt;&lt; A::sn also works
              &lt;&lt; a.f() &lt;&lt; ' ' 
              &lt;&lt; a.fs() &lt;&lt; ' ' // A::fs() also works
              &lt;&lt; a.RED &lt;&lt; ' '  // enumerator
//            &lt;&lt; a.B  // nested type not allowed
              ;
}
 | output=
1 2 11 4 1
}}

====Built-in pointer-to-member access operators====

The right operand of both {{tt|operator.*}} and {{tt|operator-&gt;*}} is an expression of type pointer to member in class {{tt|T}}. For {{tt|operator.*}}, the left operand is an expression of class type {{tt|T}}, or of some derived class in which {{tt|T}} is unambiguous accessible base. For {{tt|operator-&gt;*}}, the left operand is a pointer to {{tt|T}} or to its base. 

For every combination of types {{tt|B}}, {{tt|D}}, {{tt|T}}, where {{tt|D}} is either the same as {{tt|B}} or a class derived from {{tt|B}}, and {{tt|T}} is either object or function type, the following function signature participates in overload resolution:
{{dcl begin}}
{{dcl | T&amp; operator-&gt;*(B*, T D::*); }}
{{dcl end}}
where both operands may be cv-qualified, in which case the return type's cv-qualification is the union of the cv-qualification of the operands.

The expression {{c|E1-&gt;*E2}} is exactly equivalent to {{c|(*E1).*E2}} for built-in types.

For the expression {{c|expr.*ptr}}, 
@1@ If the {{rlp|type#Dynamic type|dynamic type}} of {{tt|expr}} does not contain the member to which {{tt|ptr}} refers, the behavior is undefined
@2@ cv-qualification rules are the same as for member access operator, with one additional rule: a pointer to member that refers to a mutable member cannot be used to modify that member in a const object.
@4@ If {{tt|expr}} is rvalue and {{tt|ptr}} points to a member function with &amp; ref-qualifier, the program is ill-formed
@5@ If {{tt|expr}} is lvalue and {{tt|ptr}} points to a member function with &amp;&amp; ref-qualifier, the program is ill-formed
@6@ The result of {{c|expr.*ptr}} where {{tt|ptr}} is a pointer to data member has the same value category as {{tt|expr}}.
@7@ The result of {{c|expr.*ptr}} where {{tt|ptr}} is a pointer to member function is a special kind of prvalue that may only be used as the left-hand argument of a function call expression and for no other purpose.
@8@ If {{tt|ptr}} is a null pointer value, the behavior is undefined

{{example
 |
 | code=
#include &lt;iostream&gt;
struct S
{
    mutable int mi;
    int f(int n) { return mi+n; }
    S(int n) : mi(n) {}
};
struct D : public S {
        D(int n) : S(n) {}
};

int main()
{
    int S::* pmi = &amp;S::mi;
    int (S::*mpf)(int) = &amp;S::f;

    const S s(7);
//    s.*pmi = 10; // cannot modify through mutable
    std::cout &lt;&lt; s.*pmi &lt;&lt; '\n';

    D d(7); // base pointers work with derived object
    D* dp = &amp;d;
    std::cout &lt;&lt; (d.*mpf)(7) &lt;&lt; ' '
              &lt;&lt; (dp-&gt;*mpf)(8) &lt;&lt; '\n';
}
 | output=
7
14 15
}}

===Standard library===
Subscript operator is overloaded by many standard container classes
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_at}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator_at}}
{{dsc inc | cpp/string/basic_string/dsc operator_at}}
{{dsc inc | cpp/container/dsc operator_at | array}}
{{dsc inc | cpp/container/dsc operator_at | deque}}
{{dsc inc | cpp/container/dsc operator_at | vector}}
{{dsc inc | cpp/container/dsc operator_at | map}}
{{dsc inc | cpp/container/dsc operator_at | unordered_map}}
{{dsc inc | cpp/iterator/reverse_iterator/dsc operator_at}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at | move_iterator}}
{{dsc inc | cpp/numeric/valarray/dsc operator_at}}
{{dsc inc | cpp/regex/match_results/dsc operator_at}}
{{dsc end}}

The indirection and member access operators are overloaded by many iterators and smart pointer classes
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator*}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator*}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator*}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/reverse_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | back_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | front_insert_iterator}}
{{dsc inc | cpp/iterator/inserter/dsc operator* | insert_iterator}}
{{dsc inc | cpp/iterator/adaptor/dsc operator* | move_iterator}}
{{dsc inc | cpp/iterator/istream_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/ostream_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/istreambuf_iterator/dsc operator*}}
{{dsc inc | cpp/iterator/ostreambuf_iterator/dsc operator*}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator*}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator*}}

No standard library classes overload {{tt|operator&amp;}} or {{tt|operator-&gt;*}}. The best known example of overloaded {{tt|operator&amp;}} is the Microsoft COM class [http://msdn.microsoft.com/en-us/library/31k6d0k7(v=vs.100).aspx CComPtr]. {{tt|operator-&gt;*}} is sometimes overloaded by third-party [http://www.aristeia.com/Papers/DDJ_Oct_1999.pdf custom smart pointers].

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator member access]]
[[es:cpp/language/operator member access]]
[[fr:cpp/language/operator member access]]
[[it:cpp/language/operator member access]]
[[ja:cpp/language/operator member access]]
[[pt:cpp/language/operator member access]]
[[ru:cpp/language/operator member access]]
[[zh:cpp/language/operator member access]]</text>
      <sha1>fepeb52yevl3bsaog18h5zdlb03kshz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator other</title>
    <ns>0</ns>
    <id>708</id>
    <revision>
      <id>72353</id>
      <parentid>71816</parentid>
      <timestamp>2014-08-14T11:23:36Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Built-in function call operator */ link decltype, this should be further explained there</comment>
      <text xml:space="preserve" bytes="14141">{{title|Other operators}}
{{cpp/language/expressions/navbar}}
{| class=&quot;wikitable&quot; style=&quot;font-size:85%;&quot;
|-
! rowspan=&quot;2&quot; | Operator name
! rowspan=&quot;2&quot; | Syntax
! rowspan=&quot;2&quot; | Over&amp;#8203;load&amp;#8203;able
! colspan=&quot;2&quot; | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| function call
| {{tt|a(a1, a2)}}
| {{yes}}
| {{c|R T::operator()(Arg1 &amp;a1, Arg2 &amp;a2, ... ...);}}
| {{n/a}}
|-
| comma
| {{tt|a, b}}
| {{yes}}
| {{c|T2&amp; T::operator,(T2 &amp;b);}}
| {{c|T2&amp; operator,(const T &amp;a, T2 &amp;b);}}
|-
| conversion
| {{tt|(''type'') a
| {{yes}}
| {{c|operator type()}}
| {{n/a}}
|-
| ternary conditional
| {{tt|a ? b : c}}
| {{no}}
| {{n/a}}
| {{n/a}}
|}

===Explanation===

''function call'' operator provides function semantics for any object.

''conversion operator'' converts given type to another type. The name of the operator must be the same as the type intended to be returned.

''ternary conditional'' operator checks the boolean value of the first expression and replaces entire operator clause with the second or the third expression depending on the resulting value.

====Built-in function call operator====

A function call expression, such as {{c|E(A1, A2, A3)}}, consists of an expression that names the {{rlp|functions|function}}, {{tt|E}}, followed by a possibly empty list of expressions {{tt|A1, A2, A3, ...}}, in parentheses.

The expression that names the function can be
@a@ lvalue expression that refers to a function
@b@ pointer to function
@c@ explicit [[cpp/language/operator_member_access|class member access]] expression that selects a member function
@d@ implicit class member access expression, e.g. member function name used within another member function.

The function (or member) name specified by {{tt|E}} can be overloaded, [[cpp/language/overload_resolution|overload resolution]] rules used to decide which overload is to be called.

If {{tt|E}} specifies a member function, it may be virtual, in which case the final overrider of that function will be called, using dynamic dispatch at runtime.

To call the function, all expressions {{tt|A1}}, {{tt|A2}}, {{tt|A3}}, etc, provided as arguments are evaluated in arbitrary order, and each function parameter is initialized with its corresponding argument after [[cpp/language/implicit_cast|implicit conversion]] if neccessary. If the call is made to a member function, then the {{c|this}} pointer to current object is converted as if by explicit cast to the {{c|this}} pointer expected by the function. The initialization and destruction of each parameter occurs in the context of the caller, which means, for example, that if constructor of a parameter throws an exception, the exception handlers defined within the function, even as a function-try block, are not considered. If the function is a variadic function, [[cpp/utility/variadic#Default conversions|default argument promotions]] are applied to all arguments matched by the ellipsis parameter.

The return type of a function call expression is the return type of the chosen function, decided using static binding (ignoring the {{tt|virtual}} keyword), even if the overriding function that's actually called returns a different type. This allows the overriding functions to return pointers or references to classes that are derived from the return type returned by the base function, i.e. C++ supports [[enwiki:Covariant return type|covariant return types]]. If {{tt|E}} specifies a destructor, the return type is {{c|void}}.

The value category of a function call expression is lvalue if the function returns an lvalue reference or an rvalue reference to function, is an xvalue if the function returns an rvalue reference to object, and is a prvalue otherwise. If the function call expression is a prvalue of object type, it must have complete type except when used as an operand to {{rlp|decltype}}.

Function call expression is similar in syntax to value initialization {{c|T()}}, to [[cpp/language/explicit_cast|function-style cast]] expression {{c|T(A1)}}, and to direct initialization of a temporary {{c|T(A1, A2, A3, ...)}}, where {{tt|T}} is the name of a type.

{{example
 |
 | code=
#include &lt;cstdio&gt;
struct S
{
    int f1(double d) {
        printf(&quot;%f \n&quot;, d); // variable argument function call
    }
    int f2() {
        f1(7); // member function call, same as this-&gt;f1()
               // integer argument converted to double
    }
};
void f() {
   puts(&quot;function called&quot;); // function call
}
int main()
{
    f(); // function call
    S s;
    s.f2(); // member function call
}
 | output=
function called
7.000000 
}}

====Built-in comma operator====

In a comma expression {{c|E1, E2}}, the expression {{tt|E1}} is evaluated, its return value is discarded, and its side effects are completed before evaluation of the expression {{tt|E2}} begins (note that a user-defined {{tt|operator,}} cannot guarantee sequencing). 

The return type and value category of the comma operator are exactly the return type and the value category of the second operand, {{tt|E2}}. If {{tt|E2}} is a temporary, the result of the comma operator is that temporary.

The comma in various comma-separated lists, such as function argument lists ({{c|f(a, b, c)}}), initializer lists {{c|1=int a[] = {1,2,3} }}, or initialization statements ({{c|int i, j;}}) is not the comma operator. If the comma operator needs to be used in that context, it has to be parenthesized: {{c|f(a, (n++, n+b), c)}}

{{example
 |
 | code=
#include &lt;iostream&gt;
int main()
{
    int n = 1;
    int m = (++n, std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n', ++n, 2*n);
    std::cout &lt;&lt; &quot;m = &quot; &lt;&lt; (++m, m) &lt;&lt; '\n';
}
 | output=
n = 2
m = 7
}}

====Built-in conversion operator====

The built-in conversion operator {{c|(T)expr}} evaluates the expression {{tt|expr}} and performs explicit cast to the type {{tt|T}}. 

See {{rlp|explicit_cast|explicit cast}} and {{rlp|cast_operator|user-defined conversion function}} for detailed description.

====Conditional operator====

For every pair of promoted arithmetic types L and R and for every type P, where P is a pointer, pointer-to-member, or scoped enumeration type, the following function signatures participate in overload resolution:
{{dcl begin}}
{{dcl | LR operator?:(bool, L, R );}}
{{dcl | P operator?:(bool, P, P );}}
{{dcl end}}
where LR is the result of [[cpp/language/operator_arithmetic|usual arithmetic conversions]] performed on {{tt|L}} and {{tt|R}}. The operator “?:” cannot be overloaded, these function signatures only exist for the purpose of overload resolution.

The first operand of the conditional operator is evaluated and {{rlp|implicit_cast|contextually converted}} to {{c|bool}}. After both the value evaluation and all side effects of the first operand are completed, if the result was {{c|true}}, the second operand is evaluated. If the result was {{c|false}}, the third operand is evaluated.

In the conditional expression {{c|E1 ? E2 : E3}}, the following rules and limitations apply:

@1@If either {{tt|E2}} or {{tt|E3}} is a {{rlp|throw|throw-expression}}, the result of the conditional operator is the result has the type and the value of the other (not throw) expression. Such conditional operator is commonly used in C++11 [[cpp/language/constexpr|constexpr programming]].
@2@If both {{tt|E2}} or {{tt|E3}} are of type {{c|void}}, the result is a prvalue of type {{c|void}}.
@3@{{tt|E2}} and {{tt|E3}} have different class types (or same type with different cv-qualification) and the same value category. In this case, an attempt is made to convert one (and only one) of the operands to the type of the other, as follows:
:@a@ If they are lvalues, an implicit conversion to the lvalue reference type is attempted
:@b@ If they are xvalues, an implicit conversion to the rvalue reference type is attempted
:@c@ If they are rvalues, and have the same base class (or one is a base class of the other), the operand(s) are converted to the base type by copy-initializing a temporary object of the base type.
:@d@ If they are rvalues, and have no common base class, then an implicit conversion is attempted to the type of the other operand.
@4@Both {{tt|E2}} or {{tt|E3}} are glvalues of the same type. In this case, the result has the same type and value category.
@5@If all cases listed above fail, and either {{tt|E2}} or {{tt|E3}} has class type: overload resolution is attempted to select the best conversion from one type to the other.
@6@If all cases listed above fail, and neither {{tt|E2}} nor {{tt|E3}} have class type: first, lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied. Then, 
:@a@ if both {{tt|E2}} and {{tt|E3}} now have the same type, the result is a prvalue temporary of that type, copy-initialized from whatever operand was selected after evaluating {{tt|E1}}
:@b@ {{tt|E2}} and {{tt|E3}} have arithmetic or enumeration type: usual arithmetic conversions are applied to bring them to common type, that type is the result.
:@c@ {{tt|E2}} and {{tt|E3}} are pointers, or a pointer and a null constant, or a both null pointer constants, one of which is a {{lc|std::nullptr_t}}, then pointer conversions and qualification conversions are applied to bring them to common type, that type is the result.
:@d@ {{tt|E2}} and {{tt|E3}} are pointers to members, or a pointer to member and a null constant: then pointer-to-member conversions and qualification conversions are applied to bring them to common type, that type is the result.

The return type of a conditional operator is also accessible as the binary type trait {{lc|std::common_type}}

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;stdexcept&gt;
struct Node
{
    Node* next;
    int data;
    // deep-copying copy constructor
    Node(const Node&amp; other)
      : next(other.next ? new Node(*other.next) : NULL)
      , data(other.data)
    {}
    Node(int d) : next(NULL), data(d) {}
    ~Node() { delete next ; }
};
int main()
{   
    // simple rvalue example
    int n = 1&gt;2 ? 10 : 11;  // 1&gt;2 is false, so n = 11
    // simple lvalue example
    int m = 10; 
    (n == m ? n : m) = 7; // n == m is false, so m = 7
    // throw example
    std::string str = 2+2==4 ? &quot;ok&quot; : throw std::logic_error(&quot;2+2 != 4&quot;);
}
 | output=
}}

===Standard library===
Many classes in the standard library override {{tt|operator()}} to be used as function objects.
{{dsc begin}}
{{dsc inc | cpp/memory/default_delete/dsc operator()}}
{{dsc inc | cpp/utility/functional/plus/dsc operator()}}
{{dsc inc | cpp/utility/functional/minus/dsc operator()}}
{{dsc inc | cpp/utility/functional/multiplies/dsc operator()}}
{{dsc inc | cpp/utility/functional/divides/dsc operator()}}
{{dsc inc | cpp/utility/functional/modulus/dsc operator()}}
{{dsc inc | cpp/utility/functional/negate/dsc operator()}}
{{dsc inc | cpp/utility/functional/equal_to/dsc operator()}}
{{dsc inc | cpp/utility/functional/not_equal_to/dsc operator()}}
{{dsc inc | cpp/utility/functional/greater/dsc operator()}}
{{dsc inc | cpp/utility/functional/less/dsc operator()}}
{{dsc inc | cpp/utility/functional/greater_equal/dsc operator()}}
{{dsc inc | cpp/utility/functional/less_equal/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_and/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_or/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_not/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_and/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_or/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_xor/dsc operator()}}
{{dsc inc | cpp/utility/functional/unary_negate/dsc operator()}}
{{dsc inc | cpp/utility/functional/binary_negate/dsc operator()}}

{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator()}}
{{dsc inc | cpp/utility/functional/function/dsc operator()}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc inc | cpp/container/value_compare/dsc operator() | map }}
{{dsc inc | cpp/container/value_compare/dsc operator() | multimap }}
{{dsc inc | cpp/thread/packaged_task/dsc operator()}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() |linear_congruential_engine}} &lt;!-- and all other engines --&gt;
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | uniform_int_distribution}} &lt;!-- and all other distributions --&gt;
&lt;!-- also the deprecated pointer_to_unary_function, pointer_to_binary_function, mem_fun_t, mem_fun_ref_t, mem_fun1_ref_t, const_mem_fun_t, const_mem_fun1_t, const_mem_fun_ref_t, const_mem_fun1_ref_t, binder1st, binder2nd --&gt;
{{dsc end}}

Several standard library classes provide user-defined conversion functions
{{dsc begin}}
{{dsc inc | cpp/error/error_code/dsc operator bool}}
{{dsc inc | cpp/error/error_condition/dsc operator bool}}
{{dsc inc | cpp/utility/bitset/reference/dsc operator bool}}
{{dsc inc | cpp/container/vector_bool/reference/dsc operator bool}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator bool}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator bool}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc get}}
{{dsc inc | cpp/utility/functional/function/dsc operator_bool}}
{{dsc inc | cpp/types/integral_constant/dsc operator value_type}}
{{dsc inc | cpp/io/basic_ios/dsc operator bool}}
{{dsc inc | cpp/regex/sub_match/dsc str}}
{{dsc inc | cpp/atomic/atomic/dsc operator T}}
{{dsc inc | cpp/thread/unique_lock/dsc operator bool}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator auto_ptr}}
{{dsc end}}

The comma operator is not overloaded by any class in the standard library. The boost library uses {{tt|operator,}} in [http://www.boost.org/doc/libs/release/libs/assign/doc/index.html#intro boost.assign], boost.spirit, and other libraries. The database access library [http://soci.sourceforge.net/doc.html SOCI] also overloads {{tt|operator,}}.

===See also===

[[cpp/language/operator precedence | Operator precedence]]
{{cpp/language/operators}}

[[de:cpp/language/operator other]]
[[es:cpp/language/operator other]]
[[fr:cpp/language/operator other]]
[[it:cpp/language/operator other]]
[[ja:cpp/language/operator other]]
[[pt:cpp/language/operator other]]
[[ru:cpp/language/operator other]]
[[zh:cpp/language/operator other]]</text>
      <sha1>mpeb9oajoxdg41xqkrx39idual1ga5q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operator precedence</title>
    <ns>0</ns>
    <id>709</id>
    <revision>
      <id>72147</id>
      <parentid>71940</parentid>
      <timestamp>2014-07-19T03:53:05Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ function style type cast, + notes about 'sizeof (int) * p'</comment>
      <text xml:space="preserve" bytes="8751">{{title|C++ Operator Precedence}}
{{cpp/language/expressions/navbar}}

The following table lists the precedence and associativity of C++ operators. Operators are listed top to bottom, in descending precedence. 

{| class=&quot;wikitable&quot;
|-
! style=&quot;text-align: left&quot; | Precedence
! style=&quot;text-align: left&quot; | Operator
! style=&quot;text-align: left&quot; | Description
! style=&quot;text-align: left&quot; | Associativity
|-
! 1
| &lt;code&gt;::&lt;/code&gt;
| Scope resolution
| style=&quot;vertical-align: top&quot; rowspan=&quot;7&quot; | Left-to-right
|-
! rowspan=6| 2
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;++&lt;/code&gt;   &lt;code&gt;--&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Suffix/postfix increment and decrement
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;''type''()&lt;/code&gt;   &lt;code&gt;''type''{}&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Function-style type cast
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;()&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Function call
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;[]&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Array subscripting
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;.&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Element selection by reference
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;-&amp;gt;&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Element selection through pointer
|-
! rowspan=9| 3
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;++&lt;/code&gt;   &lt;code&gt;--&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Prefix increment and decrement
| style=&quot;vertical-align: top&quot; rowspan=&quot;9&quot; | Right-to-left
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;+&lt;/code&gt;   &lt;code&gt;-&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Unary plus and minus
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;!&lt;/code&gt;   &lt;code&gt;~&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Logical NOT and bitwise NOT
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;(''type'')&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | C-style type cast
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;*&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Indirection (dereference)
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;&amp;&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Address-of 
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;sizeof&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Size-of&lt;ref group=&quot;note&quot;&gt;The operand of {{tt|sizeof}} can't be a C-style type cast: the expression {{tt|sizeof (int) * p}} is unambiguously interpreted as {{tt|(sizeof(int)) * p}}, but not {{tt|sizeof((int)*p)}}.&lt;/ref&gt;
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;new&lt;/code&gt;, &lt;code&gt;new[]&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Dynamic memory allocation
|-
| style=&quot;border-top-style: none&quot; | &lt;code&gt;delete&lt;/code&gt;, &lt;code&gt;delete[]&lt;/code&gt;
| style=&quot;border-top-style: none&quot; | Dynamic memory deallocation
|-
! 4
| &lt;code&gt;.*&lt;/code&gt;   &lt;code&gt;-&gt;*&lt;/code&gt;
| Pointer to member
| style=&quot;vertical-align: top&quot; rowspan=&quot;12&quot; | Left-to-right
|-
! 5
| &lt;code&gt;*&lt;/code&gt;   &lt;code&gt;/&lt;/code&gt;   &lt;code&gt;%&lt;/code&gt;
| Multiplication, division, and remainder
|-
! 6
| &lt;code&gt;+&lt;/code&gt;   &lt;code&gt;-&lt;/code&gt;
| Addition and subtraction
|-
! 7
| &lt;code&gt;&amp;lt;&amp;lt;&lt;/code&gt;   &lt;code&gt;&amp;gt;&amp;gt;&lt;/code&gt;
| Bitwise left shift and right shift
|-
! rowspan=2| 8
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;&amp;lt;&lt;/code&gt;   &lt;code&gt;&amp;lt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | For relational operators &lt; and ≤ respectively
|-
| style=&quot;border-top-style: none&quot; | &lt;code&gt;&amp;gt;&lt;/code&gt;   &lt;code&gt;&amp;gt;=&lt;/code&gt;
| style=&quot;border-top-style: none&quot; | For relational operators &gt; and ≥ respectively
|-
! 9
| &lt;code&gt;==&lt;/code&gt;   &lt;code&gt;!=&lt;/code&gt;
| For relational = and ≠ respectively
|-
! 10
| &lt;code&gt;&amp;amp;&lt;/code&gt;
| Bitwise AND
|-
! 11
| &lt;code&gt;^&lt;/code&gt;
| Bitwise XOR (exclusive or)
|-
! 12
| &lt;code&gt;&lt;nowiki&gt;|&lt;/nowiki&gt;&lt;/code&gt;
| Bitwise OR (inclusive or)
|-
! 13
| &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;
| Logical AND
|-
! 14
| &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;
| Logical OR
|-
! rowspan=6| 15
| style=&quot;border-bottom-style: none&quot; | &lt;code&gt;?:&lt;/code&gt;
| style=&quot;border-bottom-style: none&quot; | Ternary conditional&lt;ref group=&quot;note&quot;&gt;The expression in the middle of the conditional operator (between {{ttb|?}} and {{ttb|:}}) is parsed as if parenthesized: its precedence relative to {{tt|?:}} is ignored.&lt;/ref&gt;
| style=&quot;vertical-align: top&quot; rowspan=&quot;7&quot; | Right-to-left
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Direct assignment (provided by default for C++ classes)
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;+=&lt;/code&gt;   &lt;code&gt;-=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by sum and difference
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;*=&lt;/code&gt;   &lt;code&gt;/=&lt;/code&gt;   &lt;code&gt;%=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by product, quotient, and remainder
|-
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | &lt;code&gt;&amp;lt;&amp;lt;=&lt;/code&gt;   &lt;code&gt;&amp;gt;&amp;gt;=&lt;/code&gt;
| style=&quot;border-bottom-style: none; border-top-style: none&quot; | Assignment by bitwise left shift and right shift
|-
| style=&quot;border-top-style: none&quot; | &lt;code&gt;&amp;amp;=&lt;/code&gt;   &lt;code&gt;^=&lt;/code&gt;   &lt;code&gt;&lt;nowiki&gt;|&lt;/nowiki&gt;=&lt;/code&gt;
| style=&quot;border-top-style: none&quot; | Assignment by bitwise AND, XOR, and OR
|-
! 16
| &lt;code&gt;throw&lt;/code&gt;
| Throw operator (for exceptions)
|-
! 17
| &lt;code&gt;,&lt;/code&gt;
| Comma
| Left-to-right
|}
&lt;references group=&quot;note&quot; /&gt;

When parsing an expression, an operator which is listed on some row will be bound tighter (as if by parentheses) to its arguments than any operator that is listed on a row further below it. For example, the expressions {{c|std::cout&lt;&lt;a&amp;b}} and  {{c|*p++}} are parsed as {{c|(std::cout&lt;&lt;a)&amp;b}} and {{c|*(p++)}}, and not as {{c|std::cout&lt;&lt;(a&amp;b)}} or {{c|(*p)++}}.

Operators that are in the same cell (there may be several rows of operators listed in a cell) are evaluated with the same precedence, in the given direction. For example, the expression {{c|1=a=b=c}} is parsed as {{c|1=a=(b=c)}}, and not as {{c|1=(a=b)=c}} because of right-to-left associativity.

Operator precedence is unaffected by {{rlp|operators|operator overloading}}.

===Notes===
Precedence and associativity are independent from [[cpp/language/eval_order|order of evaluation]].

The standard itself doesn't specify precedence levels. They are derived from the grammar.

{{ltt|cpp/language/const_cast}}, {{ltt|cpp/language/static_cast}}, {{ltt|cpp/language/dynamic_cast}}, {{ltt|cpp/language/reinterpret_cast}}, {{ltt|cpp/language/typeid}}, {{ltt|cpp/language/sizeof...}}, {{ltt|cpp/language/noexcept}} and {{ltt|cpp/language/alignof}} are not included since they are never ambiguous.

Some of the operators have [[cpp/language/operator_alternative|alternate spellings]] (e.g., {{c|and}} for &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;, {{c|or}} for &lt;code&gt;&lt;nowiki&gt;||&lt;/nowiki&gt;&lt;/code&gt;, {{c|not}} for &lt;code&gt;!&lt;/code&gt;, etc.).

Relative precedence of the conditional and assignment operators differs between C and C++: in C, assignment is not allowed on the right hand side of a conditional operator, so {{c|1=e = a &lt; d ? a++ : a = d}} cannot be parsed. Many C compilers use a modified grammar where {{tt|?:}} has higher precedence than {{tt|{{=}}}}, which parses that as {{c|1=e = ( ((a &lt; d) ? (a++) : a) = d )}} (which then fails to compile because {{tt|?:}} is never lvalue in C and {{tt|{{=}}}} requires lvalue on the left). In C++, {{tt|?:}} and {{tt|{{=}}}} have equal precedence and group right-to-left, so that {{c|1=e = a &lt; d ? a++ : a = d}} parses as {{c|1=e = ((a &lt; d) ? (a++) : (a = d))}}.

===See also===
{{cpp/language/operators}}
{{dsc begin}}
{{dsc see c | c/language/operator_precedence | C operator precedence}}
{{dsc end}}

[[ar:cpp/language/operator precedence]]
[[cs:cpp/language/operator precedence]]
[[de:cpp/language/operator precedence]]
[[es:cpp/language/operator precedence]]
[[fr:cpp/language/operator precedence]]
[[it:cpp/language/operator precedence]]
[[ja:cpp/language/operator precedence]]
[[ko:cpp/language/operator precedence]]
[[pt:cpp/language/operator precedence]]
[[ru:cpp/language/operator precedence]]
[[tr:cpp/language/operator precedence]]
[[zh:cpp/language/operator precedence]]</text>
      <sha1>rebq32jj9zk166yuv0xb4suasy3aouc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/operators</title>
    <ns>0</ns>
    <id>4062</id>
    <revision>
      <id>72197</id>
      <parentid>72196</parentid>
      <timestamp>2014-07-22T13:49:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention basic exception safety in the non-copyswap assignment.</comment>
      <text xml:space="preserve" bytes="12488">{{title|operator overloading}}
{{cpp/language/expressions/navbar}}

Customizes the C++ operators for operands of user-defined types.

===Syntax===

Overloaded operators are {{rlp|functions}} with special function names:

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|operator}} {{spar|op}} }}
{{sdsc | num=2 | {{ttb|operator}} {{spar|type}} }}
{{sdsc | num=3 | {{ttb|operator}} {{ttb|new}} }} 
{{sdsc | num=4 | {{ttb|operator}} {{ttb|delete}} }}
{{sdsc | num=5 | notes={{mark since c++11}} | {{ttb|operator}} {{ttb|&quot;&quot;}} {{spar|suffix-identifier}} }}
{{sdsc end}}

@1@ overloaded operator
@2@ {{rlp|cast_operator|user-defined conversion function}}
@3@ [[cpp/memory/new/operator_new|allocation function]]
@4@ [[cpp/memory/new/operator_delete|deallocation function]]
@5@ {{rlp|user_literal|user-defined literal}}

===Overloaded operators===
When an operator appears in an {{rlp|expressions|expression}}, and at least one of its operands has a {{rlp|class|class type}} or an {{rlp|enum|enumeration type}}, then {{rlp|overload_resolution|overload resolution}} is used to determine the user-defined function to be called among all the functions whose signatures match the following:

{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:left;&quot;
|-
! Expression
! As member function 
! As non-member function
! Example
|-
| @a
| (a).operator@ ( )
| operator@ (a)
| {{c|!std::cin}} calls {{c|std::cin.operator!()}}
|-
| a@b
| (a).operator@ (b)
| operator@ (a, b)
| {{c|std::cout &lt;&lt; 42}} calls {{c|std::cout.operator&lt;&lt;(int)}}
|-
| a=b
| (a).operator= (b)
| {{no|cannot be non-member}}
| {{c|1=std::string s; s = &quot;abc&quot;;}} calls {{c|1=std::string.operator=(const char*)}}
|-
| a[b]
| (a).operator[](b)
| {{no|cannot be non-member}}
| {{c|1=std::map&lt;int, int&gt; m; m[1] = 2;}} calls {{c|m.operator[](int)}}
|-
| a-&gt;
| (a).operator-&gt; ( )
| {{no|cannot be non-member}}
| {{c|std::unique_ptr&lt;S&gt; ptr(new S); ptr-&gt;bar()}} calls {{c|ptr.operator-&gt;()}}
|-
| a@
| (a).operator@ (0)
| operator@ (a, 0)
| {{c|1=std::vector&lt;int&gt;::iterator i = v.begin(); i++}} calls {{c|i.operator++(0)}}
|}
Note: for overloading {{rlp|cast_operator|user-defined conversion functions}}, {{rlp|user_literal|user-defined literals}}, [[cpp/memory/new/operator_new|allocation]] and [[cpp/memory/new/operator_new|deallocation]] see their respective articles.

Overloaded operators (but not the built-in operators) can be called using function notation:

{{source|1=
std::string str = &quot;Hello, &quot;;
str.operator+=(&quot;world&quot;);                       // same as str += &quot;world&quot;;
operator&lt;&lt;(operator&lt;&lt;(std::cout, str) , '\n'); // same as std::cout &lt;&lt; str &lt;&lt; '\n';
}}

===Restrictions===
* The operators {{tt|::}} (scope resolution), {{tt|.}} (member access), {{tt|.*}} (member access through pointer to member), and {{tt|?:}} (ternary conditional) cannot be overloaded
* New operators such as {{ttb|**}}, {{ttb|&lt;&gt;}}, or {{ttb|&amp;{{!}}}} cannot be created
* The overloads of operators {{tt|&amp;&amp;}}, {{tt|{{!!}}}}, and {{tt|,}} (comma) lose their special properties: short-circuit evaluation and {{rlp|eval_order|sequencing}}.

===Canonical implementations===
The language puts no restrictions on what the overloaded operators do, or on the return type (it does not participate in overload resolution), but in general, overloaded operators are expected to behave as similar as possible to the built-in operators: {{c|operator+}} is expected to add, rather than multiply its arguments, {{c|operator{{=}}}} is expected to assign, etc. The related operators are expected to behave similarly ({{c|operator+}} and {{c|operator+{{=}}}} do the same addition-like operation). The return types are limited by the expressions in which the operator is expected to be used: for example, assignment operators return by reference to make it possible to write {{c|1=a=b=c=d}}, because the built-in operators allow that.
Commonly overloaded operators have the following typical, canonical forms:&lt;ref&gt;[http://stackoverflow.com/questions/4421706/operator-overloading/4421708#4421708 Operator Overloading] on StackOverflow C++ FAQ&lt;/ref&gt;
====Assignment operator====
The assignment operator ({{c|1=operator=}}) has special properties: see {{rlp|as_operator|copy assignment}} and {{rlp|move_operator|move_assignment}} for details. To summarize, the canonical &quot;universal assignment operator&quot; implementation is
{{source|1=T&amp; T::operator=(T arg) { // copy/move constructor is called to construct arg
    swap(arg);    // resources exchanged between *this and arg
    return *this;
}  // destructor is called to release the resources formerly held by *this
}}
When there are resources that can be reused in assignment, for example, if the class owns a heap-allocated array, then copy-assignment between arrays of the same size can avoid allocation and deallocation:
{{source|1=
T&amp; operator=(const T&amp; other) // copy assignment
{
    if (this != &amp;other) { // self-assignment check expected
        if (/* storage cannot be reused (e.g. different sizes) */)
        { 
            delete[] mArray;            // destroy storage in this
            /* reset size to zero and mArray to null, in case allocation throws */
            mArray = new int[/*size*/]; // create storage in this
        }
        /* copy data from other's storage to this storage */
    }
    return *this;
}
T&amp; operator=(T&amp;&amp; other) // move assignment
{
    assert(this != &amp;other); // self-assignment check not required
    delete[] mArray;        // delete this storage
    mArray = other.mArray;  // move
    other.mArray = nullptr; // leave moved-from in valid state
    return *this;
}
}}
====Stream extraction and insertion====
The overloads of {{tt|operator&gt;&gt;}} and {{tt|operator&lt;&lt;}} that take a {{c|std::istream&amp;}} or {{c|std::ostream&amp;}} as the left hand argument are known as insertion and extraction operators. Since they take the user-defined type as the right argument ({{tt|b}} in {{spar|a@b}}), they must be implemented as non-members. 
{{source|1=
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const T&amp; obj)
{
  // write obj to stream
  return os;
}
std::istream&amp; operator&gt;&gt;(std::istream&amp; is, T&amp; obj)
{
  // read obj from stream
  if( /* T could not be constructed */ )
    is.setstate(std::ios::failbit);
  return is;
}
}}
These operators are sometimes implemented as {{rlp|friend|friend functions}}.
====Function call operator====
When a user-defined class overloads the function call operator, {{c|operator()}}, it becomes a {{concept|FunctionObject}} type. Many standard algorithms, from {{c|std::sort}} to {{c|std::accumulate}} accept objects of such types to customize behavior. There are no particularly notable canonical forms of {{c|operator()}}, but to illustrate the usage
{{source|1=
struct Sum {
    int sum;
    Sum() : sum(0) {}
    void operator()(int n) { sum += n; }
};
Sum s = std::for_each(v.begin(), v.end(), Sum());
}}
====Increment and decrement====
When the postfix increment and decrement appear in an expression, the corresponding user-defined function ({{c|operator++}} or {{c|operator--}}) is called with an integer argument {{tt|0}}. Typically, it is implemented as {{c|T operator++(int)}}, where the argument is ignored. The postfix increment and decrement operator is usually implemented in terms of the prefix version:
{{source|struct X {
    X&amp; operator++() {
        // actual increment takes place here
        return *this;
    }
    X operator++(int) {
        X tmp(*this); // copy
        operator++(); // pre-increment
        return tmp;   // return old value
    }
};
}}
Although canonical form of preincrement/predecrement returns a reference, as with any operator overload, the return type is user-defined; for example the overloads of these operators for {{lc|std::atomic}} return by value.
====Binary arithmetic operators====
Binary operators are typically implemented as non-members to maintain symmetry (for example, when adding a complex number and an integer, if {{tt|operator+}} is a member function of the complex type, then only {{c|complex+integer}} would compile, and not {{c|integer+complex}}). Since for every binary arithmetic operator there exists a corresponding compound assignment operator, canonical forms of binary operators are implemented in terms of their compound assignments:
{{source|1=
class X {
 public:
  X&amp; operator+=(const X&amp; rhs) // compound assignment (does not need to be a member,
  {                           // but often is, to modify the private members)
    /* addition of rhs to *this takes place here */
    return *this; // return the result by reference
  }

  // friends defined inside class body are inline and are hidden from non-ADL lookup
  friend X operator+(X lhs,       // passing first arg by value helps optimize chained a+b+c
                    const X&amp; rhs) // alternatively, both parameters may be const references.
  {
     return lhs += rhs; // reuse compound assignment and return the result by value
  }
};
}}
====Relational operators====
Standard algorithms such as {{c|std::sort}} and containers such as {{c|std::set}} expect {{c|operator&lt;}} to be defined, by default, for the user-provided types. Typically, {{c|operator&lt;}} is provided and the other relational operators are implemented in terms of {{c|operator&lt;}}.
{{source|1=
inline bool operator&lt; (const X&amp; lhs, const X&amp; rhs){ /* do actual comparison */ }
inline bool operator&gt; (const X&amp; lhs, const X&amp; rhs){return rhs &lt; lhs;}
inline bool operator&lt;=(const X&amp; lhs, const X&amp; rhs){return !(lhs &gt; rhs);}
inline bool operator&gt;=(const X&amp; lhs, const X&amp; rhs){return !(lhs &lt; rhs);}
}}

Likewise, the inequality operator is typically implemented in terms of {{c|1=operator==}}:
{{source|1=
inline bool operator==(const X&amp; lhs, const X&amp; rhs){ /* do actual comparison */ }
inline bool operator!=(const X&amp; lhs, const X&amp; rhs){return !(lhs == rhs);}
}}
====Array subscript operator====
User-defined classes that provide array-like access typically define two overloads for {{c|operator[]}}: one which can be called in rvalue context such as {{c|1=x = a[i];}}, and one which can be used in lvalue context, such as {{c|1=a[i] = x;}}.
{{source|
struct T {
    value_t&amp; operator[](std::size_t idx) {
         /* actual access, e.g. return mVector[idx]; */
    };
    const value_t&amp; operator[](std::size_t idx) const {
        // either actual access, or reuse non-const overload
        // for example, as follows:
        return const_cast&lt;T&amp;&gt;(*this)[idx];
    };
};
}}

To provide multidimensional array access semantics, e.g. to implement a 3D array access {{c|a[i][j][k] {{=}} x;}}, operator[] has to return a reference to a 2D plane, which has to have its own operator[] which returns a reference to a 1D row, which has to have operator[] which returns a reference to the element. To avoid this complexity, some libraries opt for overloading {{c|operator()}} instead, so that 3D access expressions have the Fortran-like syntax {{c|a(i,j,k) {{=}} x;}}

=== Example ===
{{example
 | code=
#include &lt;iostream&gt;

class Fraction
{
    int gcd(int a, int b) {return b==0 ? a : gcd(b,a%b); }
    int n, d;
 public:
    Fraction(int n, int d = 1) : n(n/gcd(n,d)), d(d/gcd(n,d)) {}
    int num() const { return n; }
    int den() const { return d; }
    Fraction&amp; operator*=(const Fraction&amp; rhs) {
        int new_n = n*rhs.n / gcd(n*rhs.n, d*rhs.d);
        d = d*rhs.d / gcd(n*rhs.n, d*rhs.d);
        n = new_n;
        return *this;
    }
};
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; out, const Fraction&amp; f){
   return out &lt;&lt; f.num() &lt;&lt; '/' &lt;&lt; f.den() ;
}
bool operator==(const Fraction&amp; lhs, const Fraction&amp; rhs) {
    return lhs.num() == rhs.num() &amp;&amp; lhs.den() == rhs.den();
}
bool operator!=(const Fraction&amp; lhs, const Fraction&amp; rhs) {
    return !(lhs == rhs);
}
Fraction operator*(Fraction lhs, const Fraction&amp; rhs)
{
    return lhs *= rhs;
}

int main()
{
   Fraction f1(3,8), f2(1,2), f3(10,2);
   std::cout &lt;&lt; f1 &lt;&lt; '*' &lt;&lt; f2 &lt;&lt; '=' &lt;&lt; f1*f2 &lt;&lt; '\n'
             &lt;&lt; f2 &lt;&lt; '*' &lt;&lt; f3 &lt;&lt; '=' &lt;&lt; f2*f3 &lt;&lt; '\n'
             &lt;&lt; 2  &lt;&lt; '*' &lt;&lt; f1 &lt;&lt; '=' &lt;&lt; 2 *f1 &lt;&lt; '\n';
}
 | output=
3/8*1/2=3/16
1/2*5/1=5/2
2*3/8=3/4
}}

===See Also===
* [[cpp/language/operator precedence | Operator precedence]]
* [[cpp/language/operator alternative | Alternative operator syntax]]
{{cpp/language/operators}}

===References===
&lt;references/&gt;

[[de:cpp/language/operators]]
[[es:cpp/language/operators]]
[[fr:cpp/language/operators]]
[[it:cpp/language/operators]]
[[ja:cpp/language/operators]]
[[pt:cpp/language/operators]]
[[ru:cpp/language/operators]]
[[zh:cpp/language/operators]]</text>
      <sha1>m18f71qg5td80fuicpied2d99erxkse</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/overload resolution</title>
    <ns>0</ns>
    <id>12784</id>
    <revision>
      <id>71710</id>
      <parentid>71709</parentid>
      <timestamp>2014-06-21T05:32:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>cwg 1410 (reference tie-breakers work for all references)</comment>
      <text xml:space="preserve" bytes="29052">{{title|Overload resolution}}
{{cpp/language/functions/navbar}}

In order to compile a function call, the compiler must first perform {{rlp|lookup|name lookup}}, which, for functions, may involve {{rlp|adl|argument-dependent lookup}}, and for function templates may be followed by {{rlp|template argument deduction}}. If these steps produce more than one ''candidate function'', then ''overload resolution'' is performed to select the function that will actually be called.

In general, the candidate function whose parameters match the arguments most closely is the one that is called.

===Details===
Before overload resolution begins, the functions selected by name lookup and template argument deduction are combined to form the set of ''candidate functions'' (the exact criteria depend on the context in which overload resolution takes place, see below).

If any candidate function is a {{rlp|member_functions|member function}} (static or non-static), but not a constructor, it is treated as if it has an extra parameter (''implicit object parameter'') which represents the object for which they are called and appears before the first of the actual parameters.

Similarly, the object on which a member function is being called, is prepended to the argument list as the ''implied object argument''

For member functions of class {{tt|X}}, the type of the implicit object parameter is affected by cv-qualifications and ref-qualifications of the member function as described in {{rlp|member_functions}}

The user-defined conversion functions are considered to be members of the ''implied object argument'' for the purpose of determining the type of the ''implicit object parameter''.

The member functions introduced by a using-declaration into a derived class are considered to be members of the derived class for the purpose of defining the type of the ''implicit
object parameter''.

For the static member functions, the ''implicit object parameter'' is considered to match any
object: its type is not examined and no conversion sequence is attempted for it.

For the rest of overload resolution, the ''implied object argument'' is indistinguishable from other arguments, but the following special rules apply to the ''implicit object parameter'':
@1@ the argument for the implicit object parameter cannot be held in a temporary object
@2@ user-defined conversions cannot be applied to the implicit object parameter
@3@ rvalues can be bound to non-const implicit object parameter (unless this is for a ref-qualified member function) and does not affect the ranking of the implicit conversions.

{{todo|small illustrative examples}}

===Candidate functions===
The set of candidate functions and the list of arguments is prepared in a unique way for each of the contexts where overload resolution is used:
====Call to a named function====
If {{tt|E}} in a {{rlp|operator_other#Built-in_function_call_operator|function call expression}} {{tt|E(args)}} names a set of overloaded functions and/or function templates (but not callable objects), the following rules are followed:
* If the expression {{tt|E}} has the form {{tt|PA-&gt;B}} or {{tt|A.B}} (where A has class type cv T), then {{tt|B}} is {{rlp|lookup|looked up}} as a member function of {{tt|T}}. The function declarations found by that lookup are the candidate functions. The argument list for the purpose of overload resolution has the implied object argument of type cv T.
* If the expression {{tt|E}} is a {{rlp|expressions#Primary_expressions|primary expression}}, the name is {{rlp|lookup|looked up}} following normal rules for function calls (which may involve {{rlp|adl|ADL}}). The function declarations found by this lookup are (due to the way lookup works) either:
:a) all non-member functions (in which case the argument list for the purpose of overload resolution is exactly the argument list used in the function call expression)
:b) all member functions of some class {{tt|T}}, in which case, if {{rlp|this}} is in scope and refers to {{tt|T}}, {{tt|*this}} is used as the implied object argument. Otherwise (if {{tt|this}} is not in scope or does not point to {{tt|T}}, a fake object of type {{tt|T}} is used as the implied object argument, and if overload resolution subsequently selects a non-static member function, the program is ill-formed.
====Call to a class object====
If {{tt|E}} in a {{rlp|operator_other#Built-in_function_call_operator|function call expression}} {{tt|E(args)}} has class type cv {{tt|T}}, then
* The function-call operators of T are obtained by ordinary {{rlp|lookup}} of the name {{c|operator()}} in the context of the expression {{tt|(E).operator()}}, and every declaration found is added to the set of candidate functions. 
* For each non-explicit {{rlp|cast operator|user-defined conversion function}} in {{tt|T}} or in a base of {{tt|T}} (unless hidden), whose cv-qualifiers is same or greater than {{tt|T}}'s cv-qualifiers, and where the conversion function converts to:
:* to pointer-to-function
:* to reference-to-pointer-to-function
:* to reference-to-function
:then a surrogate function with a unique name whose first parameter is the result of the conversion, the remaining parameters are the parameter-list accepted by the result of the conversion, and the return type is the return type of the result of the conversion, is added to the set of candidate functions. If this surrogate function is selected by the subsequent overload resolution, then the user-defined conversion function will be called and then the result of the conversion will be called.

In any case, the argument list for the purpose of overload resolution is the argument list of the function call expression preceded by the implied object argument {{tt|E}} (when matching against the surrogate function, the user-defined conversion will automatically convert the implied object argument to the first argument of the surrogate function).
{{source|1=
int f1(int);
int f2(float);
struct A {
    using fp1 = int(*)(int);
    operator fp1() { return f1; } // conversion function to pointer to function
    using fp2 = int(*)(float);
    operator fp2() { return f2; } // conversion function to pointer to function
} a;
int i = a(1); // calls f1 via pointer returned from conversion function
}}
====Call to an overloaded operator====
If at least one of the arguments to an operator in an expression has a class type or an enumeration type, both {{rlp|expressions#Operators|builtin operators}} and {{rlp|operators|user-defined operator overloads}} participate in overload resolution, with the set of candidate functions selected as follows:

For a unary operator {{ttb|@}} whose argument has type {{tt|T1}} (after removing cv-qualifications), or binary operator {{ttb|@}} whose left operand has type {{tt|T1}} and right operand of type {{tt|T2}} (after removing cv-qualifications), three sets of candidate functions are prepared:
@1@ ''member candidates'': if {{tt|T1}} is a complete class or a class currently being defined, the set of member candidates is the result of {{rlp|lookup|qualified name lookup}} of {{tt|T1::operator@}}. In all other cases, the set of member candidates is empty. 
@2@ ''non-member candidates'': For the operators where {{rlp|operators|operator overloading}} permits non-member forms, all declarations found by {{rlp|lookup|unqualified name lookup}} of {{tt|operator@}} in the context of the expression (which may involve {{rlp|adl|ADL}}), except that member function declarations are ignored and do not prevent the lookup from continuing into the next enclosing scope. If both operands of a binary operator or the only operand of a unary operator has enumeration type, the only functions from the lookup set that become non-member candidates are the ones whose parameter has that enumeration type (or reference to that enumeration type)
@3@ ''built-in candidates'': For {{c|operator,}}, the unary {{c|operator&amp;}}, and the {{c|operator-&gt;}}, the set of built-in candidates is empty. For other operators built-in candidates are the ones listed in {{rlp|expressions#Operators|built-in operator pages}} as long as all operands can be implicitly converted to their parameters. If any built-in candidate has the same parameter list as a non-member candidate that isn't a function template specialization, it is not added to the list of built-in candidates. When the built-in assignment operators are considered, the conversions from their left-hand arguments are restricted: user-defined conversions and conversions that involve a temporary are not considered.

The set of candidate functions to be submitted for overload resolution is a union of the three sets above. The argument list for the purpose of overload resolution consists of the operands of the operator except for {{tt|operator-&gt;}}, where the second operand is not an argument for the function call (see {{rlp|operator_member_access#Built-in_member_access_operators|member access operator}}). 
{{source|
struct A {
    operator int(); // user-defined conversion
};
A operator+(const A&amp;, const A&amp;); // non-member user-defined operator
void m()
{
    A a, b;
    a + b; // member-candidates: none
           // non-member candidates: operator+(a,b)
           // built-in candidates: int(a) + int(b)
           // overload resolution chooses operator+(a,b)
}
}}

If the overload resolution selects a built-in candidate, the {{rlp|implicit cast|user-defined conversion sequence}} from an operand of class type is not allowed to have a second standard conversion sequence: the user-defined conversion function must give the expected operand type directly:
{{source|1=
struct Y { operator int*(); };  // Y is convertible to int*
int *a = Y() + 100.0; // error: no operator+ between pointer and double
}}

For {{c|operator,}}, the unary {{c|operator&amp;}}, and {{c|operator-&gt;}}, if there are no viable functions (see below) in the set of candidate functions, then the operator is reinterpreted as a built-in.

====Initialization by constructor====
When an object of class type is {{rlp|direct_initialization|direct-initialized}}, the candidate functions are all constructors of the class being initialized. The argument list is the expression list of the initializer.

When an object of class type is {{rlp|copy_initialization|copy-initialized}} from an object of the same or derived class type, the candidate functions are all converting constructors of the class being initialized. The argument list is the expression of the initializer.

====Copy-initialization by conversion====
If {{rlp|copy_initialization|copy-initialization}} of an object of class type requires that a {{rlp|cast operator|user-defined conversion function}} is called to convert the initializer expression of type cv {{tt|S}} to the type cv {{tt|T}} of the object being initialized, the following functions are candidate functions:
* all converting constructors of {{tt|T}}
* the non-explicit conversion functions from {{tt|S}} and its base classes (unless hidden) to {{tt|T}} or class derived from {{tt|T}} or a reference to such. If this copy-initialization is part of the direct-initialization sequence of ''cv'' {{tt|T}} (initializing a reference to be bound to the first parameter of a constructor that takes a reference to cv {{tt|T}}), then explicit conversion functions are also considered.

Either way, the argument list for the purpose of overload resolution consists of a single argument which is the initializer expression, which will be compared against the first argument of the constructor or against the implicit object argument of the conversion function.
====Non-class initialization by conversion====
When initialization of an object of non-class type cv1 {{tt|T}} requires a {{rlp|cast operator|user-defined conversion function}} to convert from an initializer expression of class type cv {{tt|S}}, the following functions are candidates:
* the non-explicit user-defined conversion functions of {{tt|S}} and its base classes (unless hidden) that produce type {{tt|T}} or a type convertible to {{tt|T}} by a {{rlp|implicit cast|standard conversion sequence}}, or a reference to such type. cv qualifiers on the returned type are ignored for the purpose of selecting candidate functions.
* if this is {{rlp|direct initialization|direct-initialization}}, the explicit user-defined conversion functions of {{tt|S}} and its base classes (unless hidden) that produce type {{tt|T}} or a type convertible to {{tt|T}} by a {{rlp|implicit cast|qualification conversion}}, , or a reference to such type, are also considered.

Either way, the argument list for the purpose of overload resolution consists of a single argument which is the initializer expression, which will be compared against the implicit object argument of the conversion function.
====Reference initialization by conversion====
During {{rlp|reference initialization}}, where the reference to cv1 {{tt|T}} is bound to the glvalue or class prvalue result of a conversion from the initializer expression from the class type cv2 {{tt|S}}, the following functions are selected for the candidate set:
* the non-explicit user-defined conversion functions of {{tt|S}} and its base classes (unless hidden) to the type
:* (when initializing lvalue reference or rvalue reference to function) lvalue reference to cv2 {{tt|T2}}
:* (when initializing rvalue reference or lvalue reference to function) cv2 {{tt|T2}} or rvalue reference to cv2 {{tt|T2}}
:where cv2 T2 is reference-compatible with cv1 T
* for direct initializaton, the explicit user-defined conversion functions are also considered if T2 is the same type as T or can be converted to type T with a qualification conversion.

Either way, the argument list for the purpose of overload resolution consists of a single argument which is the initializer expression, which will be compared against the implicit object argument of the conversion function.
====List-initialization====
When an object of non-aggregate class type {{tt|T}} is {{rlp|list initialization|list-initialized}}, two-phase overload resolution takes place.
* at phase 1, the candidate functions are all initializer-list constructors of {{tt|T}} and the argument list for the purpose of overload resolution consists of a single initializer list argument
* if overload resolution fails at phase 1, phase 2 is entered, where the candidate functions are all constructors of {{tt|T}} and the argument list for the purpose of overload resolution consists of the individual elements of the initializer list. 

If the initializer list is empty and {{tt|T}} has a default constructor, phase 1 is skipped.

In copy-list-initialization, if phase 2 selects an explicit constructor, the initialization is ill-formed (as opposed to all over copy-initializations where explicit constructors are not even considered).

===Viable functions===
Given the set of candidate functions, constructed as described above, the next step of overload resolution is examining arguments and parameters to reduce the set to the set of ''viable functions''

To be included in the set of viable functions, the candidate function must satisfy the following:
@1@ If there are {{tt|M}} arguments, the candidate function that has exactly {{tt|M}} parameters is viable
@2@ If the candidate function has less than {{tt|M}} parameters, but has an {{rlp|variadic arguments|ellipsis parameter}}, it is viable.
@3@ If the candidate function has more than {{tt|M}} parameters and the {{tt|M+1}}'st parameter and all parameters that follow must have default arguments, it is viable. For the rest of overload resolution, the parameter list is truncated at M.
@4@ For every argument there must be at least one implicit conversion sequence that converts it to the corresponding parameter.
@5@ If any parameter has reference type, reference binding is accounted for at this step: if an rvalue argument corresponds to non-const lvalue reference parameter or an lvalue argument corresponds to rvalue reference parameter, the function is not viable.

===Best viable function===
For each pair of viable function {{tt|F1}} and {{tt|F2}}, the implicit conversion sequences from the {{tt|i}}-th parameter to {{tt|i}}-th argument are ranked to determine which one is better (except the first argument, the ''implicit object argument'' for static member functions has no effect on the ranking)

{{tt|F1}} is determined to be a better function than {{tt|F2}} if implicit conversions for all arguments of F1 are ''not worse'' than the implicit conversions for all arguments of F2, and
@1@ there is at least one argument of F1 whose implicit conversion is ''better'' than the corresponding implicit conversion for that argument of F2
@2@ or. if not that, (only in context of non-class initialization by conversion), the standard conversion sequence from the return type of F1 to the type being initialized is ''better'' than the standard conversion sequence from the return type of F2
@3@ or, if not that, F1 is a non-template function while F2 is a template specialization
@4@ or, if not that, F1 and F2 are both template specializations and F1 is ``more specialized`` according to the partial ordering rules for template specializations

These pair-wise comparisons are applied to all viable functions. If exactly one viable function is better than all others, overload resolution succeeds and this function is called. Otherwise, compilation fails.

{{source|1=
void Fcn(const int*, short); // overload #1
void Fcn(int*, int); // overload #2
int i;
short s = 0;
void f() {
    Fcn(&amp;i, 1L);  // 1st argument: &amp;i -&gt; int* is better than &amp;i -&gt; const int*
                  // 2nd argument: 1L -&gt; short and 1L -&gt; int are equivalent
                  // calls Fcn(int*, int)

    Fcn(&amp;i,’c’);  // 1st argument: &amp;i -&gt; int* is better than &amp;i -&gt; const int*
                  // 2nd argument: 'c' -&gt; int is better than 'c' -&gt; short
                  // calls Fcn(int*, int)

    Fcn(&amp;i, s);   // 1st argument: &amp;i -&gt; int* is better than &amp;i -&gt; const int*
                  // 2nd argument: s -&gt; short is better than s -&gt; int
                  // no winner, compilation error
}
}}

===Ranking of implicit conversion sequences===
The argument-parameter implicit conversion sequences considered by overload resolution correspond to {{rlp|implicit_cast|implicit conversions}} used in {{rlp|copy_initialization|copy initialization}} (for non-reference parameters), except that when considering conversion to the implicit object parameter or to the left-hand side of assignment operator, conversions that create temporary objects are not considered.

Each {{rlp|implicit_cast|type of standard conversion sequence}} is assigned one of three ranks:
@1@ '''Exact match''': no conversion required, lvalue-to-rvalue conversion, qualification conversion, user-defined conversion of class type to the same class
@2@ '''Promotion''': integral promotion, floating-point promotion
@3@ '''Conversion''': integral conversion, floating-point conversion, floating-integral conversion, pointer conversion, pointer-to-member conversion, boolean conversion, user-defined conversion of a derived class to its base

The rank of the standard conversion sequence is the worst of the ranks of the standard conversions it holds (there may be up to {{rlp|implicit_cast|three conversions}})

Binding of a reference parameter directly to the argument expression is either Identity or a derived-to-base Conversion:
{{source|1=
struct Base {};
struct Derived : Base {} d;
int f(Base&amp;);    // overload #1
int f(Derived&amp;); // overload #2
int i = f(d); // d -&gt; Derived&amp; has rank Exact Match
              // d -&gt; Base&amp; has rank Conversion
              // calls f(Derived&amp;)
}}
Since ranking of conversion sequences operates with types and value categories only, a {{rlp|bit_field|bit field}} can bind to a reference argument for the purpose of ranking, but if that function gets selected, it will be ill-formed.

@1@ A standard conversion sequence is always ''better'' than a user-defined conversion sequence or an ellipsis conversion sequence.
@2@ A user-defined conversion sequence is always ''better'' than an {{rlp|variadic arguments|ellipsis conversion}} sequence
@3@ A standard conversion sequence {{tt|S1}} is ''better'' than a standard conversion sequence {{tt|S2}} if
:@a@ {{tt|S1}} is a subsequence of {{tt|S2}}, excluding lvalue transformations. The identity conversion sequence is considered a subsequence of any other conversion
:@b@ Or, if not that, the rank of {{tt|S1}} is better thank the rank of {{tt|S2}}
:@c@ or, if not that, both {{tt|S1}} and {{tt|S2}} are binding to a reference parameter to something other than the implicit object parameter of a ref-qualified member function, and {{tt|S1}} binds an rvalue reference to an rvalue while {{tt|S2}} binds an rvalue reference to an rvalue
{{source|1=
int i;
int f1();
int g(const int&amp;);  // overload #1
int g(const int&amp;&amp;); // overload #2
int j = g(i);    // lvalue int -&gt; const int&amp; is the only valid conversion
int k = g(f1()); // rvalue int -&gt; const int&amp;&amp; better than rvalue int -&gt; const int&amp;
}}
:@d@ or, if not that, both {{tt|S1}} and {{tt|S2}} are binding to a reference parameter and {{tt|S1}} binds an lvalue reference to function while {{tt|S2}} binds an rvalue reference to function.
{{source|1=
int f(void(&amp;)());  // overload #1
int f(void(&amp;&amp;)()); // overload #2
void g();
int i1 = f(g);     // calls #1
}}
:@e@ or, if not that, both {{tt|S1}} and {{tt|S2}} are binding to a reference parameters only different in top-level cv-qualification, and {{tt|S1}}'s type is ''less'' cv-qualified than {{tt|S2}}'s.
{{source|1=
int f(const int &amp;); // overload #1
int f(int &amp;);       // overload #2 (both references)
int g(const int &amp;); // overload #1
int g(int);         // overload #2
int i;
int j = f(i); // lvalue i -&gt; int&amp; is better than lvalue int -&gt; const int&amp;
              // calls f(int&amp;)
int k = g(i); // lvalue i -&gt; const int&amp; ranks Exact Match
              // lvalue i -&gt; rvalue int ranks Exact Match
              // ambiguous overload: compilation error
}}
:@f@ Or, if not that, S1 and S2 only differ in qualification conversion, and the cv-qualification of the result of {{tt|S1}} is a subset of the cv-qualification of the result of {{tt|S2}}
{{source|1=
int f(const int*);
int f(int*);
int i;
int j = f(&amp;i); // &amp;i -&gt; int* is better than &amp;i -&gt; const int*, calls f(int*)
}}
@4@ A user-defined conversion sequence {{tt|U1}} is ''better'' than a user-defined conversion sequence {{tt|U2}} if they call the same constructor/user-defined conversion function or initialize the same class with aggregate-initialization, and in either case the second standard conversion sequence in {{tt|U1}} is better than the second standard conversion sequence in {{tt|U2}}
{{source|1=
struct A {
    operator short(); // user-defined conversion function
} a;
int f(int);   // overload #1
int f(float); // overload #2
int i = f(a); // A -&gt; short, followed by short -&gt; int (rank Promotion)
              // A -&gt; short, followed by short -&gt; float (rank Conversion)
              // calls f(int)
}}
@5@ A list-initialization sequence {{tt|L1}} is ''better'' than list-initialization sequence {{tt|L2}} if {{tt|L1}} initializes an {{c|std::initializer_list}} parameter, while {{tt|L2}} does not.
{{source|
std::vector&lt;std::size_t&gt; v{10, 20}; // calls vector&lt;size_t&gt;(initializer_list&lt;size_t&gt;)
                                    // not vector&lt;size_t&gt;(size_t, size_t)
}}

If two conversion sequences are indistinguishable because they have the same rank, the following additional rules apply:
@1@ Conversion that involves pointer-to-bool, pointer-to-member to bool, or std::nullptr_t to bool conversion is worse than the one that doesn't
@2@ Conversion that converts pointer-to-derived to pointer-to-base is better than the conversion of pointer-to-derived to pointer-to-void, and conversion of pointer-to-base to void is better than pointer-to-derived to void.
@3@ If {{tt|Mid}} is derived (directly or indirectly) from {{tt|Base}}, and {{tt|Derived}} is derived (directly or indirectly) from {{tt|Mid}}
:@a@ {{c|Derived*}} to {{c|Mid*}} is better than {{c|Derived*}} to {{c|Base*}}
:@b@ {{c|Derived}} to {{c|Mid&amp;}} or {{c|Mid&amp;&amp;}} is better than {{c|Derived}} to {{c|Base&amp;}} or {{c|Base&amp;&amp;}}
:@c@ {{c|Base::*}} to {{c|Mid::*}} is better than {{c|Base::*}} to {{c|Derived::*}}
:@d@ {{c|Derived}} to {{c|Mid}} is better than {{c|Derived}} to {{c|Base}}
:@e@ {{c|Mid*}} to {{c|Base*}} is better than {{c|Derived*}} to {{c|Base*}}
:@f@ {{c|Mid}} to {{c|Base&amp;}} or {{c|Base&amp;&amp;}} is better than {{c|Derived}} to {{c|Base&amp;}} or {{c|Base&amp;&amp;}}
:@g@ {{c|Mid::*}} to {{c|Derived::*}} is better than {{c|Base::*}} to {{c|Derived::*}}
:@h@ {{c|Mid}} to {{c|Base}} is better than {{c|Derived}} to {{c|Base}}

Ambiguous conversion sequences are ranked as user-defined conversion sequences because multiple conversion sequences for an argument can exist only if they involve different user-defined conversions:
{{source|1=
class B;
class A { A (B&amp;);}; // converting constructor
class B { operator A (); }; // user-defined conversion function
class C { C (B&amp;); }; // converting constructor
void f(A) { } // overload #1
void f(C) { } // overload #2
B b;
f(b); // B -&gt; A via ctor or B -&gt; A via function (ambiguous conversion)
      // b -&gt; C via ctor (user-defined conversion)
      // the conversions for overload #1 and for overload #2
      // are indistinguishable; compilation fails 
}}

===Implicit conversion sequence in list-initialization===
In {{rlp|list initialization}}, the argument is a {{spar|braced-init-list}}, which isn't an expression, so the implicit conversion sequence into the parameter type for the purpose of overload resolution is decided by the following special rules:
* If the parameter type is {{c|std::initializer_list&lt;X&gt;}}, and there is an non-narrowing implicit conversion from every element of the initializer list to {{tt|X}}, the implicit conversion sequence for the purpose of overload resolution is the worst conversion necessary. If the braced-init-list is empty, the conversion sequence is the identity conversion.
{{source|1=
struct A {
    A(std::initializer_list&lt;double&gt;);                    // #1
    A(std::initializer_list&lt;complex&lt;double&gt;&gt;);           // #2
    A(std::initializer_list&lt;std::string&gt;);               // #3
};
A a{1.0,2.0}; // selects #1 (rvalue double -&gt; double: identity conv)
void g(A);
g({&quot;foo&quot;,&quot;bar&quot;}); // selects #3 (lvalue const char[4] -&gt; std::string: user-def conv)
}}
* Otherwise, if the parameter type is {{c|T[N]}} (this only happens for references to arrays), the initializer list must have N or less elements (and if it's less, T must be default-constructible), and the worst implicit conversion necessary to convert every element of the list to {{tt|T}} is the one used.
{{source|1=
typedef int IA[3];
void h(const IA&amp;);
h({1,2,3});        // int-&gt;int identity conversion
}}
* Otherwise, if the parameter type is a non-aggregate class type {{tt|X}}, overload resolution picks the constructor of X to initialize from the argument initializer list, and then the implicit conversion sequence is a user-defined conversion sequence with the second standard conversion sequence an identity conversion. If multiple constructors are viable but none is better than the others, the implicit conversion sequence is the ambiguous conversion sequence.
{{source|1=
struct A { A(std::initializer_list&lt;int&gt;); };
void f(A);
struct B { B(int, double); };
void g(B);
g({’a’,’b’});  // calls g(B(int,double)), user-defined conversion
// g({1.0, 1,0}); // error: double-&gt;int is narrowing, not allowed in list-init
void f(B);
// f({’a’,’b’}); // f(A) and f(B) both user-defined conversions
}}
* Otherwise, if the parameter type is an aggregate which can be initialized from the initializer list according by {{rlp|aggregate initialization}}, the implicit conversion sequence is a user-defined conversion sequence with the second standard conversion sequence an identity conversion.
{{source|1=
struct A { int m1; double m2;};
void f(A);
f({’a’,’b’});  // calls f(A(int,double)), user-defined conversion
}}
* Otherwise, if the parameter is a reference, reference initialization rules apply
{{source|1=
struct A { int m1; double m2; };
void f(const A&amp;);
f({’a’,’b’});  // temporary created, f(A(int,double)) called. User-defined conversion
}}
* Otherwise, if the parameter type is not a class and the initializer list has one element, the implicit conversion sequence is the one required to convert the element to the parameter type
* Otherwise, if the parameter type is not a class type and if the initializer list has no elements, the implicit conversion sequence is the identity conversion.

===See also===
* {{rlp|lookup|Name lookup}} 
* {{rlp|adl|Argument-dependent lookup}} 
* {{rlp|template argument deduction|Template argument deduction}}
* {{rlp|sfinae|SFINAE}}

===References===
{{ref std c++11}}
{{ref std | section=13.3.3.2 | title=Ranking implicit conversion sequences | id=over.ics.rank}}
{{ref std end}}</text>
      <sha1>bss0510kek0vkziszdr29vom8d3l7k6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/overloaded address</title>
    <ns>0</ns>
    <id>13003</id>
    <revision>
      <id>72399</id>
      <parentid>69224</parentid>
      <timestamp>2014-08-19T14:13:50Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+links</comment>
      <text xml:space="preserve" bytes="3668">{{title|Address of an overloaded function}}
{{cpp/language/functions/navbar}}

Besides {{rlp|operator_other|function-call expressions}}, where {{rlp|overload resolution}} takes place, the name of an overloaded function may appear in the following 7 contexts:

@1@ {{rlp|initialization|initializer}} in a {{rlp|declarations|declaration}} of an object or {{rlp|reference initialization|reference}}
@2@ on the right-hand-side of an assignment expression
@3@ as a function call argument
@4@ as a user-defined operator argument
@5@ the {{rlp|return}} statement
@6@ {{rlp|explicit cast}} or {{rlp|static cast}} argument
@7@ non-type {{rlp|template parameters|template argument}}

In each context, the name of an overloaded function may be preceded by address-of operator {{ttb|&amp;}} and may be enclosed in a redundant set of parentheses.

In all these contexts, the function selected from the overload set is the function whose type matches the pointer to function, reference to function, or pointer to member function type that is expected by ''target'': the object or reference being initialized, the left-hand side of the assignment, function or operator parameter, the return type of a function, the target type of a cast, or the type of the template parameter, respectively.

The type of the function must match the target exactly, no implicit conversions are considered (e.g. a function returning a pointer to derived won't get selected when initializing a pointer to function returning a pointer to base)

If the function name names a function template, then, first, {{rlp|function template|template argument deduction}} is done, and if it succeeds, it produces a single template specialization which is added to the list of overloads to consider. If more than one function from the set matches the target, and at least one function is non-template, the template specializations are eliminated from consideration. If all candidates are template specializations, {{rlp|partial specialization|less specialized}} ones are removed if more specialized are available. If more than one candidate remains after the removals, the program is ill-formed.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;string&gt;
#include &lt;cctype&gt; // int std::toupper(int)
#include &lt;locale&gt; // template&lt;class CharT&gt; CharT std::toupper(CharT,const locale&amp;)

int f(int) { return 1; }
int f(double) { return 2; }

void g( int(&amp;f1)(int), int(*f2)(double) ) {}

template&lt; int(*F)(int) &gt;
struct Templ {};

struct Foo {
    int mf(int) { return 3; }
    int mf(double) { return 4; }
};

// 5. return value
int (*(foo)(void))(int) {
    return f; // selects int f(int)
}

int main()
{
    // 1. initialization
    int (*pf)(double) = f; // selects int f(double)
    int (&amp;rf)(int) = f; // selects int f(int)
    int (Foo::*mpf)(int) = &amp;Foo::mf; // selects int mf(int)

    // 2. assignment
    pf = nullptr;
    pf = &amp;f; // selects int f(double)

    // 3. function argument
    g(f, f); // selects int f(int) for the 1st argument
             // and int f(double) for the second

    // 4. user-defined operator

    // 6. cast
    std::string str = &quot;example&quot;;
    std::transform(str.begin(), str.end(), str.begin(),
                   static_cast&lt;int(*)(int)&gt;(std::toupper)); // selects int toupper(int)
    std::cout &lt;&lt; str &lt;&lt; '\n';

    // 7. template argument
    Templ&lt;f&gt; t;  // selects int f(int)
}
|output=EXAMPLE
}}

===References===
{{ref std c++11}}
{{ref std | section=13.4 | title=Address of overloaded function | id=over.over}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=13.4 | title=Address of overloaded function | id=over.over}}
{{ref std end}}</text>
      <sha1>8cgix1m8sylhjbnmi9hov4tb4m2kfrk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/override</title>
    <ns>0</ns>
    <id>5073</id>
    <revision>
      <id>67481</id>
      <parentid>67398</parentid>
      <timestamp>2014-02-09T21:23:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="2240">{{title|override specifier}}
{{cpp/language/classes/navbar}}

Specifies that a {{rlp|virtual|virtual function}} overrides another virtual function. 

===Syntax===
The identifier {{tt|override}}, if used, appears immediately after the {{rlp|function|declarator}} in the syntax of a member function declaration or a member function definition.

{{sdsc begin}}
{{sdsc | num=1 | {{spar|declarator}} {{spar|virt-specifier-seq}}{{mark optional}} {{spar|pure-specifier}}{{mark optional}} }}
{{sdsc | num=2 | {{spar|declarator}} {{spar|virt-specifier-seq}}{{mark optional}} {{spar|function-body}} }}
{{sdsc end}}
@1@ In a member function declaration, {{tt|override}} may appear in {{spar|virt-specifier-seq}} immediately after the declarator, and before the {{rlp|abstract_class|pure-specifier}}, if used.
@2@ In a member function definition, {{tt|override}} may appear in {{spar|virt-specifier-seq}} immediately after the declarator and just before {{spar|function-body}} (which may begin with a {{rlp|initializer list|member initializer list}})

In both cases, {{spar|virt-specifier-seq}}, if used, is either {{tt|override}} or {{rlp|final}}, or {{tt|final override}} or {{tt|override final}}.

===Explanation===
In a member function declaration or definition, {{tt|override}} ensures that the function is virtual and is overriding a virtual function from the base class. The program is ill-formed (a compile-time error is generated) if this is not true.

{{c|override}} is an identifier with a special meaning when used after member function declarators: it's not a reserved keyword otherwise.

===Example===
{{source|
struct A
{
    virtual void foo();
    void bar();
};

struct B : A
{
    void foo() const override; // Error: B::foo does not override A::foo
                               // (signature mismatch)
    void foo() override; // OK: B::foo overrides A::foo
    void bar() override; // Error: B::bar is not virtual
};
}}

===See also===
*[[cpp/language/final|final specifier]] {{mark since c++11}}

[[de:cpp/language/override]]
[[es:cpp/language/override]]
[[fr:cpp/language/override]]
[[it:cpp/language/override]]
[[ja:cpp/language/override]]
[[pt:cpp/language/override]]
[[ru:cpp/language/override]]
[[zh:cpp/language/override]]</text>
      <sha1>ks1306671qacvuhi1pbylyon14qd2cz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/parameter pack</title>
    <ns>0</ns>
    <id>9639</id>
    <revision>
      <id>72233</id>
      <parentid>72232</parentid>
      <timestamp>2014-07-25T01:29:49Z</timestamp>
      <contributor>
        <ip>173.252.71.2</ip>
      </contributor>
      <comment>It was a bit confusing to use Ts in both places.</comment>
      <text xml:space="preserve" bytes="11100">{{title|Parameter pack}}
{{cpp/language/templates/navbar}}

A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function parameter that accepts zero or more function arguments.

A template with at least one parameter pack is called a ''variadic template''.

===Syntax===
Template parameter pack (appears in a [[cpp/language/class template|class template]] and in a [[cpp/language/function template|function template]] parameter list)
{{sdsc begin}}
{{sdsc|num=1|{{spar|type}} {{ttb|...}} {{spar|Args}} | notes={{mark since c++11}}}}
{{sdsc|num=2|{{ttb|typename{{!}}class}} {{ttb|...}} {{spar|Args}} | notes={{mark since c++11}}}}
{{sdsc|num=3|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{ttb|class}} {{ttb|...}} {{spar|Args}} | notes={{mark since c++11}}}}
{{sdsc end}}
Function parameter pack (a form of {{rlp|declarations|declarator}}, appears in a function parameter list of a variadic function template)
{{sdsc begin}}
{{sdsc|num=4|{{spar|Args}} {{ttb|...}} {{spar|args}} | notes={{mark since c++11}}}}
{{sdsc end}}
Parameter pack expansion (appears in a body of a variadic template)
{{sdsc begin}}
{{sdsc|{{spar|pattern}} {{ttb|...}} | num=5 | notes={{mark since c++11}} }}
{{sdsc end}}

@1@ A non-type template parameter pack with an optional name
@2@ A type template parameter pack with an optional name
@3@ A template template parameter pack with an optional name
@4@ A function parameter pack
@5@ Parameter pack expansion: expands to comma-separated list of zero or more {{tt|pattern}}s. Pattern must include at least one parameter pack.

===Explanation===

A variadic class template can be instantiated with any number of template arguments:
{{source|
template&lt;class ... Types&gt; struct Tuple {};
Tuple&lt;&gt; t0;           // Types contains no arguments
Tuple&lt;int&gt; t1;        // Types contains one argument: int
Tuple&lt;int, float&gt; t2; // Types contains two arguments: int and float
Tuple&lt;0&gt; error;       // error: 0 is not a type
}}
{{todo|mention that it must be last in class template, but not function}}

A variadic function template can be called with any number of function arguments (the template arguments are deduced through {{rlp|template argument deduction}}):
{{source|
template&lt;class ... Types&gt; void f(Types ... args);
f();       // OK: args contains no arguments
f(1);      // OK: args contains one argument: int
f(2, 1.0); // OK: args contains two arguments: int and double
}}

===Pack expansion===
A pattern followed by an ellipsis, in which the name of at least one parameter pack appears at least once, is ''expanded'' into zero or more comma-separated instantiations of the pattern, where the name of the parameter pack is replaced by each of the types from the pack, in order.

{{source|
template&lt;class ...Us&gt; void f(Us... pargs) {}
template&lt;class ...Ts&gt; void g(Ts... args) {
    f(&amp;args...); // “&amp;args...” is a pack expansion
                 // “&amp;args” is its pattern
}
g(1, 0.2, &quot;a&quot;); // Ts... args expand to int E1, double E2, const char* E3
                // &amp;args... expands to &amp;E1, &amp;E2, &amp;E3
                // Us... pargs expand to int* E1, double* E2, const char** E3
}}

If the names of two parameter packs appear in the same pattern, they are expanded simultaneously, and they must have the same length:

{{source|
template&lt;typename...&gt; struct Tuple {};
template&lt;typename T1, typename T2&gt; struct Pair {};

template&lt;class ...Args1&gt; struct zip {
    template&lt;class ...Args2&gt; struct with {
        typedef Tuple&lt;Pair&lt;Args1, Args2&gt;...&gt; type;
//        Pair&lt;Args1, Args2&gt;... is the pack expansion
//        Pair&lt;Args1, Args2&gt; is the pattern
    };
};

typedef zip&lt;short, int&gt;::with&lt;unsigned short, unsigned&gt;::type T1;
// Pair&lt;Args1, Args2&gt;... expands to
// Pair&lt;short, unsigned short&gt;, Pair&lt;int, unsigned int&gt; 
// T1 is Tuple&lt;Pair&lt;short, unsigned short&gt;, Pair&lt;int, unsigned&gt;&gt;

typedef zip&lt;short&gt;::with&lt;unsigned short, unsigned&gt;::type T2;
// error: pack expansion contains parameter packs of different lengths
}}

If a pack expansion is nested within another pack expansion, the parameter packs that appear inside the innermost pack expansion are expanded by it, and there must be another pack mentioned in the enclosing pack expansion, but not in the innermost one:

{{source|template&lt;class ...Args&gt;
    void g(Args... args) {
        f(const_cast&lt;const Args*&gt;(&amp;args)...); 
 // const_cast&lt;const Args*&gt;(&amp;args) is the pattern, it expands two packs
 // (Args and args) simultaneously

        f(h(args...) + args...); // Nested pack expansion:
   // inner pack expansion is &quot;args...&quot;, it is expanded first
   // outer pack expansion is h(E1, E2, E3) + args..., it is expanded
   // second (as h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3
}
}}

===Expansion loci===
Depending on where the expansion takes place, the resulting comma-separated list is a different kind of list: function parameter list, member initializer list, attribute list, etc. The following is the list of all allowed contexts

====Function argument lists====
A pack expansion may appear inside the parantheses of a function call operator, in which case the largest expression to the left of the ellipsis is the pattern that is expanded.

{{source|
f(&amp;args...); // expands to f(&amp;E1, &amp;E2, &amp;E3)
f(n, ++args...); // expands to f(n, ++E1, ++E2, ++E3);
f(++args..., n); // expands to f(++E1, ++E2, ++E3, n);
f(const_cast&lt;const Args*&gt;(&amp;args)...);
// f(const_cast&lt;const E1*&gt;(&amp;X1), const_cast&lt;const E2*&gt;(&amp;X2), const_cast&lt;const E3*&gt;(&amp;X3)
f(h(args...) + args...); // expands to 
// f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3)
}}

====Template argument lists====
Pack expansions can be used anywhere in a template argument list, provided the template has the parameters to match the expansion.

{{source|
template&lt;class A, class B, class...C&gt; void func(A arg1, B arg2, C...arg3)
{
    container&lt;A,B,C...&gt; t1;  // expands to container&lt;A,B,E1,E2,E3&gt; 
    container&lt;C...,A,B&gt; t2;  // expands to container&lt;E1,E2,E3,A,B&gt; 
    container&lt;A,C...,B&gt; t3;  // expands to container&lt;A,E1,E2,E3,B&gt; 
}
}}

====Function parameter list====
In a function parameter list, if an ellipsis appears in a parameter declaration (whether it names a function parameter pack (as in,  {{spar|Args}} {{ttb|...}} {{spar|args}}) or not) the parameter declaration is the pattern:
{{source|
template&lt;typename ...Ts&gt; void f(Ts...) {}
f('a', 1);  // Ts... expands to void f(char, int)
f(0.1);     // Ts... expands to void f(double)

template&lt;typename ...Ts, int... N&gt; void g(Ts (&amp;...arr)[N]) {}
int n[1];
g&lt;const char, int&gt;(&quot;a&quot;, n); // Ts (&amp;...arr)[N] expands to 
                            // const char (&amp;)[2], int(&amp;)[1]
}}
Note: in this pattern, the ellipsis is the innermost element, not the last element as in all other pack expansions.

Note: {{tt|Ts (&amp;...)[N]}} is not allowed because C++11 grammar requires the parenthesized ellipsis to have a name: [http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1488 CWG #1488] 

====Template parameter list====
Pack expansion may appear in a template parameter list:

{{source|
template&lt;typename... T&gt; struct value_holder
{
    template&lt;T... Values&gt; // expands to a non-type template parameter 
    struct apply { };     // list, such as &lt;int, char, int(&amp;)[5]&gt;
};
}}

====Base specifiers and member initializer lists====
A pack expansion may designate the list of base classes in a {{rlp|class|class declaration}}. Typically, this also means that the constructor needs to use a pack expansion in the {{rlp|initializer list|member initializer list}} to call the constructors of these bases:

{{source|
template&lt;class... Mixins&gt;
class X : public Mixins... {
 public:
    X(const Mixins&amp;... mixins) : Mixins(mixins)... { }
};
}}

====Braced init lists====
In a braced-init-list (brace-enclosed list of initializers and other braced-init-lists, used in {{rlp|list_initialization|list-initialization}} and some other contexts), a pack expansion may appear as well:

{{source|1=
template&lt;typename... Ts&gt; void func(Ts... args){
    const int size = sizeof...(args) + 2;
    int res[size] = {1,args...,2};
    // since initializer lists guarantee sequencing, this can be used to
    // call a function on each element of a pack, in order:
    int dummy[sizeof...(Ts)] = { (std::cout &lt;&lt; args, 0)... };
}
}}

====Lambda captures====
A parameter pack may appear in the capture clause of a {{rlp|lambda}} expression
{{source|1=
template&lt;class ...Args&gt;
void f(Args... args) {
    auto lm = [&amp;, args...] { return g(args...); };
    lm();
}
}}

====The sizeof... operator====
The {{rlp|sizeof...}} operator is classified as a pack expansion as well

{{source|1=template&lt;class... Types&gt;
struct count {
    static const std::size_t value = sizeof...(Types);
};
}}

====Dynamic exception specifications====
The list of exceptions in a {{rlp|except_spec|dynamic exception specification}} may also be a pack expansion

{{source|template&lt;class...X&gt; void func(int arg) throw(X...)
{
 // ... throw different Xs in different situations
}
}}

====Alignment specifier====
Pack expansions are allowed in both the lists of types and the lists of expressions used by the keyword {{rlp|alignas}} 

====Attribute list====
Pack expansions are allowed in the lists of {{rlp|attributes}}, as in {{c|[[attributes...]]}}. For example: {{c|void [[attributes...]] function()}}

{{todo|a few words about partial specializations and other ways to access individual elements?}}

===Example===
{{example|code=
#include &lt;iostream&gt;

void tprintf(const char* format) // base function
{
    std::cout &lt;&lt; format;
}

template&lt;typename T, typename... Targs&gt;
void tprintf(const char* format, T value, Targs... Fargs) // recursive variadic function
{
    for ( ; *format != '\0'; format++ ) {
        if ( *format == '%' ) {
           std::cout &lt;&lt; value;
           tprintf(format+1, Fargs...); // recursive call
           return;
        }
        std::cout &lt;&lt; *format;
    }
}

int main()
{
    tprintf(&quot;% world% %\n&quot;,&quot;Hello&quot;,'!',123);
    return 0;
}
| output=
Hello world! 123
}}
The above example defines a function similar to {{lc|std::printf}}, that replace each occurrence of the character % in the format string with a value.

The first overload is called when only the format string is passed and there is no parameter expansion.

The second overload contains a separate template parameter for the head of the arguments and a parameter pack, this allows the recursive call to pass only the tail of the parameters until it becomes empty.

{{ttb|Targs}} is the template parameter pack and {{ttb|Fargs}} is the function parameter pack

===See also===
{{dsc begin}}
{{dsc | [[cpp/language/function_template|function template]] }}
{{dsc | [[cpp/language/class_template|class template]] }}
{{dsc | {{ltt|cpp/language/sizeof...}} | Queries the number of elements in a parameter pack.  }}
{{dsc | [[cpp/utility/variadic|C-style variadic functions]] }}
{{dsc | [[cpp/preprocessor/replace | Preprocessor macros]] | Can be variadic as well }}
{{dsc end}}

[[zh:cpp/language/parameter pack]]</text>
      <sha1>dzl6eyoz44ekloo5ibdri22m4oknqlt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/partial specialization</title>
    <ns>0</ns>
    <id>12828</id>
    <revision>
      <id>71713</id>
      <parentid>69982</parentid>
      <timestamp>2014-06-21T18:39:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>rev-box cwg 1495 that snuck in</comment>
      <text xml:space="preserve" bytes="9344">{{title|partial template specialization}}
{{cpp/language/templates/navbar}}
Allows customizing class templates for a given category of template arguments.

===Syntax===

{{sdsc begin}}
{{sdsc|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|class-key}} {{spar|class-head-name}} {{ttb|&lt;}} {{spar|argument-list}} {{ttb|&gt;}} {{spar|declaration}} }}
{{sdsc end}}

where {{spar|class-head-name}} identifies the name of a previously declared {{rlp|class_template|class template}}.

For example,
{{source|
template&lt;class T1, class T2, int I&gt;
class A {}; // primary template

template&lt;class T, int I&gt;
class A&lt;T, T*, I&gt; {}; // partial specialization where T2 is a pointer to T1

template&lt;class T, class T2, int I&gt;
class A&lt;T*, T2, I&gt; {}; // partial specialization where T1 is a pointer

template&lt;class T&gt;
class A&lt;int, T*, 5&gt; {}; // partial specialization where T1 is int, I is 5,
                        // and T2 is a pointer

template&lt;class X, class T, int I&gt;
class A&lt;X, T*, I&gt; {}; // partial specialization where T2 is a pointer
}}

Examples of partial specializations in the standard library include {{c|std::unique_ptr}}, which has a partial specialization for array types.

===The argument list===
The following restrictions apply to the {{spar|argument-list}} of a partial template specialization:
@1@ The argument list cannot be identical to the non-specialized argument list (it must specialize something)
{{source|
template&lt;class T1, class T2, int I&gt; class A {}; // primary template
template&lt;class X, class Y, int N&gt; class A&lt;X,Y,N&gt; {}; // error
}}
@2@ Default arguments cannot appear in the argument list

{{rev begin}}
{{rev|since=c++14|
@3@ The specialization has to be more specialized than the primary template
{{source|1=
template&lt;int B, typename T1, typename... Ts&gt; struct A;
template&lt;typename... Ts&gt; struct A&lt;0, Ts...&gt; { }; // Error: not more specialized
}}
}}
{{rev end}}
@4@ If any argument is a pack expansion, it must be the last argument in the list
@5@ Non-type argument expression cannot use the name of the template parameter except when it is exactly the name of the template parameter
{{source|1=
template &lt;int I, int J&gt; struct A {}; // primary template
template &lt;int I&gt; struct A&lt;I+5, I*2&gt; {}; // error
template &lt;int I&gt; struct A&lt;I, I&gt; {}; // OK
}}
@6@ Non-type template argument cannot specialize a template parameter whose type depends on a parameter of the specialization:
{{source|1=
template &lt;class T, T t&gt; struct C {}; // primary template
template &lt;class T&gt; struct C&lt;T, 1&gt;; // error: type of the argument 1 is T,
                                   // which depends on the parameter T

template&lt; int X, int (*array_ptr)[X] &gt; class A {}; // primary template
int array[5];
template&lt; int X &gt; class A&lt;X,&amp;array&gt; { }; // error: type of the argument &amp;array
                             // is int(*)[X], which depends on the parameter X
}}

===Name lookup===
Partial template specializations are not found by name lookup. Only if the primary template is found by name lookup, its partial specializations are considered. In particular, a using declaration that makes a primary template visible, makes partial specializations visible as well:
{{source|1=
namespace N {
    template&lt;class T1, class T2&gt; class A { }; // primary template
}
using N::A; // refers to the primary template
namespace N {
    template&lt;class T&gt; class A&lt;T, T*&gt; { }; // partial specialization
}
A&lt;int,int*&gt; a; // name lookup finds N::A (the primary template),
               // the partial specialization with T = int is then used
}}

===Partial ordering===
When a class template is instantiated, and there are partial specializations avaiable, the compiler has to decide if the primary template is going to be used or one of its partial specializations. 

@1@ If only one specialization matches the template arguments, that specialization is used
@2@ If more than one specialization matches, partial order rules are used to determine which specialization is more specialized. The most specialized specialization is used, if it is unique (if it is not unique, the program cannot be compiled)
@3@ If no specializations match, the primary template is used
{{source|1=
// given the template A as defined above
A&lt;int, int, 1&gt; a1;   // no specializations match, uses primary template
A&lt;int, int*, 1&gt; a2;  // uses partial specialization #1 (T=int, I=1)
A&lt;int, char*, 5&gt; a3; // uses partial specialization #3, (T=char)
A&lt;int, char*, 1&gt; a4; // uses partial specialization #4, (X=int, T=char, I=1)
A&lt;int*, int*, 2&gt; a5; // error: matches #2 (T=int, T2=int*, I=2)
                     //        matches #4 (X=int*, T=int, I=2)
                     // neither one is more specialized than the other
}}

To establish more-specialized-than relationship between partial specializations, each is first converted to a fictitious function template as follows:
* the first function template has the same template parameters as the first partial specialization and has just one function parameter, whose type is a class template specialization with all the template arguments from the first partial specialization
* the second function template has the same template parameters as the second partial specialization and has just one function parameter whose type is a class template specialization with all the template arguments from the second partial specialization.

The function templates are then ranked as if for {{rlp|function_template#Function_template_overloading|function template overloading}}.

{{source|1=
template&lt;int I, int J, class T&gt; struct X { }; // primary template
template&lt;int I, int J&gt;          struct X&lt;I, J, int&gt; {
        static const int s = 1;
}; // partial specialization #1
// fictitious function template for #1 is
// template&lt;int I, int J&gt; void f(X&lt;I, J, int&gt;); #A

template&lt;int I&gt;                 struct X&lt;I, I, int&gt; {
        static const int s = 2;
}; // partial specialization #2
// fictitious function template for #2 is 
// template&lt;int I&gt;        void f(X&lt;I, I, int&gt;); #B

int main()
{
    X&lt;2, 2, int&gt; x; // both #1 and #2 match
// partial ordering for function templates:
// #A from #B: void(X&lt;I,J,int&gt;) from void(X&lt;U1, U1, int&gt;): deduction ok
// #B from #A: void(X&lt;I,I,int&gt;) from void(X&lt;U1, U2, int&gt;): deduction fails
// #B is more specialized
// #2 is the specialization that is instantiated
    std::cout &lt;&lt; x.s &lt;&lt; '\n'; // prints 2
}
}}

===Members of partial specializations===
The template parameter list and the template argument list of a member of a partial specialization must match the parameter list and the argument list of the partial specialization. 

Just like with members of primary templates, they only need to be defined if used in the program.

Members of partial specializations are not related to the members of the primary template.

Explicit (full) specialization of a member of a partial specialization is declared the same way as an explicit specialization of the primary template.

{{source|1=
template&lt;class T, int I&gt;  // primary template
struct A {
    void f(); // member declaration
};

template&lt;class T, int I&gt;
void A&lt;T,I&gt;::f() { } // primary template member definition

// partial specialization
template&lt;class T&gt;
struct A&lt;T,2&gt; {
    void f();
    void g();
    void h();
};

// member of partial specialization
template&lt;class T&gt;
void A&lt;T,2&gt;::g() { }

// explicit (full) specialization
// of a member of partial specialization
template&lt;&gt;
void A&lt;char,2&gt;::h() {}

int main() {
    A&lt;char,0&gt; a0;
    A&lt;char,2&gt; a2;
    a0.f(); // OK, uses primary template’s member definition
    a2.g(); // OK, uses partial specialization's member definition
    a2.h(); // OK, uses fully-specialized definition of
            // the member of a partial specialization
    a2.f(); // error: no definition of f() in the partial
            // specialization A&lt;T,2&gt; (the primary template is not used)
}
}}

If a class template is a member of another class template, and it has partial specializations, these specializations are members of the enclosing class template. If the enclosing template is instantiated, the declarations of each member partial specialization is instantiated as well (the same way declarations, but not definitions, of all other members of a template are instantiated)

If the primary member template is explicitly (fully) specialized for a given (implicit) specialization of the enclosing class template, the partial specializations of the member
template are ignored for this specialization of the enclosing class template.

If a partial specialization of the member template is explicitly specialized for a given (implicit) specialization of the enclosing class template, the primary member template and its other partial specializations are still considered for this specialization
of the enclosing class template.

{{source|1=
template&lt;class T&gt; struct A { // enclosing class template
  template&lt;class T2&gt;
  struct B {}; // primary member template
  template&lt;class T2&gt;
  struct B&lt;T2*&gt; {}; // partial specialization of member template
};

template&lt;&gt;
template&lt;class T2&gt;
struct A&lt;short&gt;::B {}; // full specialization of primary member template
                       // (will ignore the partial)

A&lt;char&gt;::B&lt;int*&gt; abcip; // uses partial specialization T2=int
A&lt;short&gt;::B&lt;int*&gt; absip; // uses full specialization of the primary (ignores partial)
A&lt;char&gt;::B&lt;int&gt; abci; // uses primary
}}</text>
      <sha1>ny233trqxo581yatak256ckw5qadcrd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/pointer</title>
    <ns>0</ns>
    <id>5596</id>
    <revision>
      <id>67709</id>
      <parentid>66693</parentid>
      <timestamp>2014-02-21T19:13:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="15756">{{title|Pointer declaration}}
{{cpp/language/declarations/navbar}}

Declares a variable of a pointer or pointer-to-member type.

===Syntax===

A pointer declaration is any simple declaration whose {{rlp|declarations|declarator}} has the form

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|*}} {{spar|attr}}{{mark optional}} {{spar|cv}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=2|1=
{{spar|nested-name-specifier}} {{ttb|*}} {{spar|attr}}{{mark optional}} {{spar|cv}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc end}}

@1@ '''Pointer declarator''': the declaration {{c|S * D;}} declares {{tt|D}} as a pointer to the type determined by {{spar|decl-specifier-seq}} {{tt|S}}.
@2@ '''Pointer to member declarator''': the declaration {{c|S C::*D;}} declares {{tt|D}} as a pointer to member of {{tt|C}} of type determined by {{spar|decl-specifier-seq}} {{tt|S}}.

{{par begin}}
{{par | {{spar|declarator}} | any {{rlp|declarations|declarator}} other than a reference declarator (there are no pointers to references). It can be another pointer declarator (pointer to pointers are allowed) }}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}} }}
{{par | {{spar|cv}} | const/volatile qualification which apply to the pointer that is being declared (not to the pointed-to type, whose qualifications are part of {{spar|decl-specifier-seq}}) }}
{{par | {{spar|nested-name-specifier}} | a {{rlp|identifiers#Qualified identifiers|sequence of names and scope resolution operators {{ttb|::}} }} }}
{{par end}}

There are no pointers to {{rlp|reference}}s and there are no pointers to {{rlp|bit field}}s.

====Pointers to objects====
A pointer to object can be initialized with the return value of the {{rlp|operator_member_access|address-of operator}} applied to any expression of object type, including another pointer type:

{{source|1=
int n;
int* np = &amp;n; // pointer to int
int* const * npp = &amp;np; // non-const pointer to const pointer to non-const int

int a[2];
int (*ap)[2] = &amp;a; // pointer to array of int

struct S { int n; };
S s = {1};
int* sp = &amp;s.n; // pointer to the int that is a member of s
}}

Pointers may appear as operands to the built-in indirection operator (unary {{tt|operator*}}), which returns {{rlp|value category|the lvalue}} identifying the pointed-to object:

{{source|1=
int n;
int* p = &amp;n;     // pointer p is pointing to n
int&amp; ref = *p;   // the lvalue expression that identifies n is bound to a reference
ref = 7;         // stores 7 in n
std::cout &lt;&lt; *p; // lvalue-to-rvalue conversion reads the value from n
}}

Pointers to class objects may also appear as the left-hand operands of the member access through pointer operators {{tt|operator-&gt;}} and {{tt|operator-&gt;*}}

Because of the {{rlp|implicit_cast|array-to-pointer}} implicit conversion, pointer to the first element of an array can be initialized with an expression of array type:

{{source|1=
int a[2];
int *p = a; // pointer to a[0]

int b[3][3];
int (*row)[3] = b; // pointer to b[0]
}}

Because of the derived-to-base {{rlp|implicit_cast|implicit conversion}} for pointers, pointer to a base class can be initialized with the address of a derived class.

{{source|1=
struct Base {};
struct Derived : Base {};

Derived d;
Base* p = &amp;d;
}}

If {{tt|Derived}} is polymorphic, such pointer may be used to make {{rlp|virtual|virtual function calls}}.

Certain {{rlp|operator_arithmetic|arithmetic operators}} are defined for pointers to elements of arrays: such pointers satisfy the {{concept|RandomAccessIterator}} requirements and allow the C++ library [[cpp/algorithm|algorithms]] to work with raw arrays.

====Pointers to functions====
A pointer to function can be initialized with an address of a non-member function or a static member function. Because of the {{rlp|implicit_cast|function-to-pointer}} conversion, the address-of operator is optional:

{{source|1=
void f(int);
void (*pf1)(int) = &amp;f;
void (*pf2)(int) = f; // same as &amp;f
}}

Unlike functions or references to functions, pointers to functions are objects and thus can be stored in arrays, copied, assigned, etc.

A pointer to function can be used on the left-hand side of the {{rlp|operator_other|function call operator}}, this invokes the pointed-to function.

{{source|1=
#include &lt;iostream&gt;

int f(int n)
{
    std::cout &lt;&lt; n &lt;&lt; '\n';
    return n*n;
}
int main()
{
    int (*p)(int) = f;
    int x = p(7);
}
}}

Dereferencing a function pointer yields the lvalue identifying the pointed-to function:

{{source|1=
int f();
int (*p)() = f;    // pointer p is pointing to f
int (&amp;ref)() = *p; // the lvalue that identifies f is bound to a reference
ref();  // function f invoked through lvalue reference
(*p)(); // function f invoked through the function lvalue
p();    // function f invoked directly through the pointer
}}

A pointer to function may be initialized from an overload set which may include functions, function template specializations, and function templates, if only one overload matches the type of the pointer (see {{rlp|overloaded address|address of an overloaded function}} for more detail)

{{source|1=
template&lt;typename T&gt; T f(T n) {}
double f(double n) {}

int main()
{
    int (*p)(int) = f; // instantiates and selects f&lt;int&gt;
}
}}

====Pointers to data members====
A pointer to non-static data member {{tt|m}} which is a member of class {{tt|C}} can be initialized with the expression {{tt|&amp;C::m}} exactly. Expressions such as {{tt|&amp;(C::m)}} or {{tt|&amp;m}} inside C's member function do not form pointers to members.

Such pointer may be used as the right-hand argument of the {{rlp|operator member access|pointer-to-member access operators}} {{tt|operator.*}} and {{tt|operator-&gt;*}}.

{{source|1=
struct C {
    int m;
};
int main()
{
    int C::*p = &amp;C::m; // p points at member m of class C
    C c = {7};
    std::cout &lt;&lt; c.*p &lt;&lt; '\n'; // prints 7
    C* cptr = &amp;c;
    cptr-&gt;m = 10;
    std::cout &lt;&lt; cptr-&gt;*p &lt;&lt; '\n'; // prints 10
}
}}

Pointer to member of a base class can be {{rlp|implicit cast|implicitly converted}} to pointer to the same member of a derived class.

{{source|1=
struct Base {
    int m;
};
struct Derived : Base {
};
int main()
{
    int Base::* pb = &amp;Base::m;
    int Derived::* pd = pb;
    Derived d;
    d.m = 1;
    std::cout &lt;&lt; d.*pd &lt;&lt; ' ' &lt;&lt; d.*pb &lt;&lt; '\n'; // prints 1 1
}
}}

Conversion in the opposite direction, from a pointer to member of a derived class to a pointer to member of an unambiguous non-virtual base class, is allowed with {{rlp|static_cast}} and {{rlp|explicit cast}}, even if the base class does not have that member (but the most-derived class does, when the pointer is used for access)

{{source|1=
struct Base {
};
struct Derived : Base {
    int m;
};
int main()
{
    int Derived::* pd = &amp;Derived::m;
    int Base::* pb = static_cast&lt;int Base::*&gt;(pd);

    Derived d;
    d.m = 7;
    std::cout &lt;&lt; d.*pb &lt;&lt; '\n'; // OK: prints 7

    Base b;
    std::cout &lt;&lt; b.*pb &lt;&lt; '\n'; // undefined behavior
}
}}

The pointed-to type of a pointer-to-member may be a pointer-to-member itself: pointers to members can be multilevel, and can be cv-qualifed differently at every level. Mixed multi-level combinations of pointers and pointers to members are also allowed

{{source|1=
struct A {
    int m;
    // const pointer to non-const member
    int A::* const p;
};
int main()
{
    // non-const pointer to member which is a const pointer to non-const member
    int A::* const A::* p1 = &amp;A::p;

    const A a = {1, &amp;A::m};
    std::cout &lt;&lt; a.*(a.*p1) &lt;&lt; '\n'; // prints 1

    // regular non-const pointer to a const pointer-to-member
    int A::* const * p2 = &amp;a.p;
    std::cout &lt;&lt; a.**p2 &lt;&lt; '\n'; // prints 1
}
}}

====Pointers to member functions====
A pointer to non-static member function {{tt|f}} which is a member of class {{tt|C}} can be initialized with the expression {{tt|&amp;C::f}} exactly. Expressions such as {{tt|&amp;(C::f)}} or {{tt|&amp;f}} inside C's member function do not form pointers to member functions.

Such pointer may be used as the right-hand argument of the {{rlp|operator member access|pointer-to-member access operators}} {{tt|operator.*}} and {{tt|operator-&gt;*}}. {{rlp|value category#Pending member function call|The resulting expression}} can be used only as the left-hand operand of a function-call operator:

{{source|1=
struct C {
    void f(int n) { std::cout &lt;&lt; n &lt;&lt; '\n'; }
};
int main()
{
    void (C::*p)(int) = &amp;C::f; // p points at member f of class C
    C c;
    (c.*p)(1); // prints 1
    C* cptr = &amp;c;
    (cptr-&gt;*p)(2); // prints 2
}
}}


Pointer to member function of a base class can be {{rlp|implicit cast|implicitly converted}} to pointer to the same member function of a derived class.

{{source|1=
struct Base {
    void f(int n) { std::cout &lt;&lt; n &lt;&lt; '\n'; }
};
struct Derived : Base {
};
int main()
{
    void (Base::* pb)(int) = &amp;Base::f;
    void (Derived::* pd)(int) = pb;
    Derived d;
    (d.*pd)(1);
    (d.*pb)(2);
}
}}

Conversion in the opposite direction, from a pointer to member function of a derived class to a pointer to member function of an unambiguous non-virtual base class, is allowed with {{rlp|static_cast}} and {{rlp|explicit cast}}, even if the base class does not have that member function (but the most-derived class does, when the pointer is used for access)

{{source|1=
struct Base {
};
struct Derived : Base {
    void f(int n) { std::cout &lt;&lt; n &lt;&lt; '\n'; }
};
int main()
{
    void (Derived::* pd)(int) = &amp;Derived::f;
    void (Base::* pb)(int) = static_cast&lt;void (Base::*)(int)&gt;(pd);

    Derived d;
    (d.*pb)(1); // OK, prints 1

    Base b;
    (b.*pb)(2); // Undefined behavior
}
}}

Pointers to member functions may be used as callbacks or as function objects, often after applying {{lc|std::mem_fn}} or {{lc|std::bind}}.

{{example|
code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;
int main()
{
    std::vector&lt;std::string&gt; v = {&quot;a&quot;, &quot;ab&quot;, &quot;abc&quot;};
    std::vector&lt;std::size_t&gt; l;
    transform(v.begin(), v.end(), std::back_inserter(l),
                std::mem_fn(&amp;std::string::size));
    for(std::size_t n : l)
        std::cout &lt;&lt; n &lt;&lt; ' ';
}
| output=
1 2 3
}}

===Pointers to void===
Pointer to object of any type can be {{rlp|implicit cast|implicitly converted}} to pointer to {{c|void}} (optionally {{rlp|cv|cv-qualified}}). The reverse conversion, which requires {{rlp|static_cast}} or {{rlp|explicit cast}}, yields the original pointer value:

{{source|1=
int n = 1;
int* p = &amp;n;
void* pv = p;

int* p2 = static_cast&lt;int*&gt;(pv);
std::cout &lt;&lt; *p2 &lt;&lt; '\n'; // prints 1
}}

If the original pointer is pointing to a base class subobject within an object of some polymorphic type, {{rlp|dynamic_cast}} may be used to obtain a {{tt|void*}} that is pointing at the complete object of the most derived type.

Pointers to void are used to pass objects of unknown type, which is common in C interfaces: {{lc|std::malloc}} returns {{c|void*}}, {{lc|std::qsort}} expects a user-provided callback that accepts two {{c|const void*}} arguments. [http://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_create.html pthread_create] expects a user-provided callback that accepts and returns {{c|void*}}. In all cases, it is the caller's responsibility to cast the pointer to the correct type before use.

===Null pointers===
Pointers of every type have a special value known as ''null pointer value'' of that type. A pointer whose value is null does not point to an object or a function (dereferencing a null pointer is undefined behavior), and compares equal to all pointers of the same type whose value is also ''null''.

To initialize a pointer to null or to assign the null value to an existing pointer, the null pointer literal {{c|nullptr}}, the null pointer constant {{lc|NULL}}, or the {{rlp|implicit_cast|implicit conversion}} from the integer value {{c|0}} may be used.

{{rlp|zero_initialization|Zero-}} and {{rlp|value_initialization|value-initialization}} also initialize pointers to their null values.

Null pointers can be used to indicate the absence of an object (e.g. {{l2tt|cpp/utility/functional/function/target|target()}}), or as other error condition indicators (e.g. {{rlp|dynamic_cast}}). In general, a function that receives a pointer argument almost always needs to check if the value is null and handle that case differently (for example, the {{rlp|delete|delete expression}} does nothing when a null pointer is passed)

===Constness===
* If {{spar|cv}} appears before {{ttb|*}} in the pointer declaration, it is part of {{spar|decl-specifier-seq}} and applies to the the pointed-to object.
* If {{spar|cv}} appears after {{ttb|*}} in the pointer declaration, it is part of {{spar|declarator}} and applies to the pointer that's being declared.
{| class=&quot;wikitable&quot;
|-
! Syntax || meaning
|-
| {{c|const T *}} || pointer to constant object
|-
| {{c|T const *}} || pointer to constant object
|-
| {{c|T * const}} || constant pointer to object
|-
| {{c|const T * const}} || constant pointer to constant object
|-
|}

{{source|1=
// pc is a non-const pointer to const int
// cpc is a const pointer to const int
// ppc is a non-const pointer to non-const pointer to const int
const int ci = 10, *pc = &amp;ci, *const cpc = pc, **ppc;
// p is a non-const pointer to non-const int
// cp is a const pointer to non-const int
int i, *p, *const cp = &amp;i;

i = ci;    // okay, value of const int copied into non-const int
*cp = ci;  // okay, non-const int pointed-to by cp can be changed
pc++;      // okay, non-const pointer (to const int) can be changed
pc = cpc;  // okay, non-const pointer (to const int) can be changed
pc = p;    // okay, non-const pointer (to const int) can be changed
ppc = &amp;pc; // okay, address of a pointer to const is a pointer to pointer to const

ci = 1;   // error: const int cannot be changed
ci++;     // error: const int cannot be changed
*pc = 2;  // error: the pointed-to const int cannot be changed
cp = &amp;ci; // error: const pointer (to non-const int) cannot be changed
cpc++;    // error: const pointer (to whatever) cannot be changed
p = pc;   // error: pointer to non-const cannot be pointed to a const object
ppc = &amp;p; // error: pointer to pointer to const cannot be pointed
          //  to pointer to non-const
}}

In general, implicit conversion from one multi-level pointer to another follows the rules described in {{rlp|implicit_cast#Qualification_conversions|qualification conversions}}.

===Example===
{{todo|drop/reuse this example}}
{{example|code=
#include &lt;iostream&gt;

struct Class
{
    int data_member;

    void member_function(int i) const
    {
        std::cout &lt;&lt; &quot;Member function: &quot; &lt;&lt; i &lt;&lt; std::endl;
    }

    static void static_member_function ( int i )
    {
        std::cout &lt;&lt; &quot;Static member function: &quot; &lt;&lt; i &lt;&lt; std::endl;
    }
};

void global_function ( int i )
{
        std::cout &lt;&lt; &quot;Global function: &quot; &lt;&lt; i &lt;&lt; std::endl;
}

int main()
{
    Class object;

    Class *ptr {{=}} &amp;object;
    ptr-&gt;member_function(1);

    Class &amp;ref {{=}} object;
    ref.data_member {{=}} 2;
    std::cout &lt;&lt; &quot;object.data_member {{=}} &quot; &lt;&lt; object.data_member &lt;&lt; std::endl;

    void (Class::*ptr_to_memfun)(int) const {{=}} &amp;Class::member_function;
    (object.*ptr_to_memfun)(3);
    (ptr-&gt;*ptr_to_memfun)(4);

    void (*ptr_to_fun)(int) {{=}} Class::static_member_function;
    ptr_to_fun(5);

    ptr_to_fun {{=}} global_function;
    ptr_to_fun(6);

} 

|output= 
Member function: 1
object.data_member {{=}} 2
Member function: 3
Member function: 4
Static member function: 5
Global function: 6
}}

[[de:cpp/language/pointer]]
[[es:cpp/language/pointer]]
[[fr:cpp/language/pointer]]
[[it:cpp/language/pointer]]
[[ja:cpp/language/pointer]]
[[pt:cpp/language/pointer]]
[[ru:cpp/language/pointer]]
[[zh:cpp/language/pointer]]</text>
      <sha1>iv3ayukpeyli87g5il149n8u49uq490</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/raii</title>
    <ns>0</ns>
    <id>13513</id>
    <revision>
      <id>69726</id>
      <parentid>69725</parentid>
      <timestamp>2014-04-21T18:48:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>~</comment>
      <text xml:space="preserve" bytes="2613">{{title|RAII}}
{{cpp/language/navbar}}

&quot;Resource Acquisition Is Initialization&quot; or RAII, is a C++ programming technique&lt;ref&gt;[http://www.stroustrup.com/bs_faq2.html#finally RAII in Stroustrup's C++ FAQ]&lt;/ref&gt; which binds the life cycle of a resource (memory allocation, socket, open file, mutex, database connection - anything that exists in limited supply) to the {{rlp|lifetime}} of an object with automatic {{rlp|storage duration}}, which guarantees that all resources are cleaned up when the object goes out of {{rlp|scope}}, in reverse order of acquisition. This leverages the language to eliminate resource leaks and guarantee exception safety. Another name for this technique is &quot;Scope-bound resource management&quot; (SBRM).

RAII can be summarized as follows:

* encapsulate each resource into a class, where
:* the constructor acquires the resource and establishes all class invariants or throws an exception if that cannot be done
:* the destructor always releases the resource
* always use the resource via an instance of a RAII-class that either
:* has automatic storage duration
:* is a non-static member of a class whose instance has automatic storage duration

Classes with open()/close(), lock()/unlock(), or init()/copyFrom()/destroy() member functions are typical examples of non-RAII classes:
{{source|1=
std::mutex m;
void bad() 
{
    m.lock(); // acquire the mutex
    f();      // if f() throws an exception, the mutex is never released
    if(!good()) return; // early return, the mutex is never released
    m.unlock(); // only if the code reaches this statement, the mutex is released
}
void good()
{
    std::lock_guard&lt;std::mutex&gt; lk(m); // RAII class: mutex acquisition is initialization
    f(); // if f() throws an exception, the mutex is released
    if(!good()) return; // early return, the mutex is released
} // if the function returns normally, the mutex is released
}}

===The standard library===
The C++ library classes that manage their own resources follow RAII: {{lc|std::string}}, {{lc|std::vector}}, {{lc|std::thread}}, and many others allocate their resources in constructors (which throw exceptions on errors), release them in their destructors, and don't require explicit cleanup.

In addition, the standard library offers several RAII wrappers to manage user-provided resources:
* {{lc|std::unique_ptr}} and {{lc|std::shared_ptr}} to manage dynamically-allocated memory or, with a user-provided deleter, any resource represented by a plain pointer
* {{lc|std::lock_guard}}, {{lc|std::unique_lock}}, {{lc|std::shared_lock}} to manage mutexes

==References==
&lt;references/&gt;</text>
      <sha1>n8r40rd5sm7k3gfdhvcuyz4shlwrp2d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/range-for</title>
    <ns>0</ns>
    <id>2146</id>
    <revision>
      <id>72374</id>
      <parentid>72373</parentid>
      <timestamp>2014-08-16T11:09:10Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>sorry but begin_expr and end_expr are not the same as std::begin/end,see C++11 6.5.4. Undo revision 72373 by [[Special:Contributions/Yejianfei|Yejianfei]] ([[User talk:Yejianfei|talk]])</comment>
      <text xml:space="preserve" bytes="3432">{{title|Range-based for loop  {{mark since c++11}}}}
{{cpp/language/statements/navbar}}
Executes a for loop over a range.

Used as a more readable equivalent to the traditional  {{rlp|for | for loop}} operating over a range of values, such as all elements in a container.

===Syntax===

{{sdsc begin}}
{{sdsc |
{{spar|attr}}{{mark optional}} {{ttb|for (}} {{spar|range_declaration}} {{ttb|:}} {{spar|range_expression}} {{ttb|)}} {{spar|loop_statement}} }}
{{sdsc end}}

===Explanation===

The above syntax produces code similar to the following ('''{{tt|__range}}''', '''{{tt|__begin}}''' and '''{{tt|__end}}''' are for exposition only):

{{sdsc begin}}
{{sdsc | 
{{ttb|{}}&lt;br&gt;
:{{ttb|auto &amp;amp;&amp;amp; __range {{=}}}} {{spar|range_expression}} {{ttb|;}} &lt;br&gt;
:{{ttb|for (auto __begin {{=}}}} ''begin_expr''{{ttb|,}}&lt;br&gt;
::::{{ttb|__end {{=}}}} ''end_expr''{{ttb|;}} &lt;br&gt;
:::{{ttb|__begin !{{=}} __end; ++__begin) {}} &lt;br&gt;
::{{spar|range_declaration}} {{ttb|{{=}} *__begin;}} &lt;br&gt;
::{{spar|loop_statement}} &lt;br&gt;
:{{ttb|} }} &lt;br&gt;
{{ttb|} }} &lt;br&gt;
}}
{{sdsc end}}

{{spar|range_expression}} is evaluated to determine the sequence or range to iterate. Each element of the sequence, in turn, is dereferenced and assigned to the variable with the type and name given in {{spar|range_declaration}}.

''{{tt|begin_expr}}'' and ''{{tt|end_expr}}'' are defined as follows:
* If {{c|__range}} is an array, then ''{{tt|begin_expr}}'' is {{c|__range}} and ''{{tt|end_expr}}'' is {{c|(__range + __bound)}}, where {{tt|__bound}} is the number of elements in the array (if the array has unknown size or is of an incomplete type, the program is ill-formed)
* If {{c|__range}}'s type is a class type with either or both a {{c|begin}} or an {{c|end}} member function, then ''{{tt|begin_expr}}'' is {{tt|__range.begin()}} and ''{{tt|end_expr}}'' is {{tt|__range.end()}};
* Otherwise, ''{{tt|begin_expr}}'' is {{c|begin(__range)}} and ''{{tt|end_expr}}'' is {{c|end(__range)}}, which are found via {{rlp|adl|argument-dependent lookup}} (non-ADL lookup is not performed).

If {{spar|range_expression}} returns a temporary, its lifetime is extended until the end of the loop, as indicated by binding to the rvalue reference '''{{tt|__range}}''', but beware that the lifetime of any temporary within {{spar|range_expression}} ''is not'' extended.

Just as with a traditional loop, a {{rlp|break | break statement}} can be used to exit the loop early and a {{rlp|continue | continue statement}} can be used to restart the loop with the next element.

{{spar|attr}} represents an optional number of {{rlp|attributes}}.

===Keywords===

{{ltt|cpp/keyword/for}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main() 
{
    std::vector&lt;int&gt; v = {0, 1, 2, 3, 4, 5};

    for (int &amp;i : v) // access by reference (const allowed)
        std::cout &lt;&lt; i &lt;&lt; ' ';
    
    std::cout &lt;&lt; '\n';
    
    for (auto i : v) // compiler uses type inference to determine the right type
        std::cout &lt;&lt; i &lt;&lt; ' ';
    
    std::cout &lt;&lt; '\n';
    
    for (int i : v) // access by value as well
        std::cout &lt;&lt; i &lt;&lt; ' ';
    
    std::cout &lt;&lt; '\n';
}
 | output=
0 1 2 3 4 5
0 1 2 3 4 5
0 1 2 3 4 5
}}

[[de:cpp/language/range-for]]
[[es:cpp/language/range-for]]
[[fr:cpp/language/range-for]]
[[it:cpp/language/range-for]]
[[ja:cpp/language/range-for]]
[[pt:cpp/language/range-for]]
[[ru:cpp/language/range-for]]
[[zh:cpp/language/range-for]]</text>
      <sha1>3czvndvvfv0kp2m80y7czt3p3rt7qdf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/reference</title>
    <ns>0</ns>
    <id>9955</id>
    <revision>
      <id>72301</id>
      <parentid>71623</parentid>
      <timestamp>2014-08-06T17:58:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link overload resolution</comment>
      <text xml:space="preserve" bytes="7318">{{title|Reference declaration}}
{{cpp/language/declarations/navbar}}

Declares a named variable as a reference, that is, an alias to an already-existing object or function.

===Syntax===

A reference variable declaration is any simple declaration whose {{rlp|declarations|declarator}} has the form

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|&amp;}} {{spar|attr}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{ttb|&amp;&amp;}} {{spar|attr}}{{mark optional}} {{spar|declarator}}
}}
{{sdsc end}}

@1@ '''Lvalue reference declarator''': the declaration {{c|S &amp; D;}} declares {{tt|D}} as an ''lvalue reference'' to the type determined by {{spar|decl-specifier-seq}} {{tt|S}}.
@2@ '''Rvalue reference declarator''': the declaration {{c|S &amp;&amp; D;}} declares {{tt|D}} as an ''rvalue reference'' to type determined by {{spar|decl-specifier-seq}} {{tt|S}}.

{{par begin}}
{{par | {{spar|declarator}} | any {{rlp|declarations|declarator}} except another reference declarator (there are no references to references) }}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}} }}
{{par end}}

A declaration of a reference (except for class members and function parameters) is required to contain an initializer: see {{rlp|reference_initialization|reference initialization}} which must identify a valid object or function.

There are no references to {{c|void}} and no references to references.

Reference types cannot be {{rlp|cv|cv-qualified}} at the top level; there is no syntax for that in declaration, and if a qualification is introduced through a typedef, decltype, or template type argument, it is ignored.

References are not objects; they do not necessarily occupy storage, although the compiler may allocate storage if it is necessary to implement the desired semantics (e.g. a non-static data member of reference type usually increases the size of the class by the amount necessary to store a memory address)

Because references are not objects, there are no arrays of references, no pointers to references, and no references to references:
{{source|
int&amp; a[3]; // error
int&amp;* p; // error
int&amp; &amp;r; // error
}}
{{rev begin}}
{{rev|since=c++11|
It is permitted to form references to references through type manipulations in templates or typedefs, in which case the ''reference collapsing'' rules apply: rvalue reference to rvalue reference collapses to rvalue reference, all other combinations form lvalue reference:
{{source|1=
typedef int&amp;  lref;
typedef int&amp;&amp; rref;
int n;
lref&amp;  r1 = n; // type of r1 is int&amp;
lref&amp;&amp; r2 = n; // type of r2 is int&amp;
rref&amp;  r3 = n; // type of r3 is int&amp;
rref&amp;&amp; r4 = 1; // type of r4 is int&amp;&amp;
}}
(this, along with special rules for {{rlp|template argument deduction}} when {{tt|T&amp;&amp;}} is used in a function template, forms the rules that make {{lc|std::forward}} possible)
}}
{{rev end}}
====Lvalue references====
Lvalue references can be used to alias an existing object (optionally with different cv-qualification)
{{example|code=
#include &lt;iostream&gt;
#include &lt;string&gt;
int main()
{
    std::string s = &quot;Ex&quot;;
    std::string&amp; r1 = s;
    const std::string&amp; r2 = s;

    r1 += &quot;ample&quot;; // modifies s
//  r2 += &quot;!&quot;; // error: cannot modify through reference to const
    std::cout &lt;&lt; r2 &lt;&lt; '\n'; // prints s, which now holds &quot;Example&quot;
}
}}

They can also be used to implement pass-by-reference semantics in function calls:

{{example|code=
#include &lt;iostream&gt;
#include &lt;string&gt;
void double_string(std::string&amp; s)
{
    s += s; // 's' is the same object as main()'s 'str'
}
int main()
{
    std::string str = &quot;Test&quot;;
    double_string(str);
    std::cout &lt;&lt; str &lt;&lt; '\n';
}
}}

When a function's return type is lvalue reference, the function call expression becomes an {{rlp|value_category|lvalue expression}}:

{{example|code=
#include &lt;iostream&gt;
#include &lt;string&gt;
char&amp; char_number(std::string&amp; s, std::size_t n)
{
    return s.at(n); // string::at() returns a reference to char
}
int main()
{
    std::string str = &quot;Test&quot;;
    char_number(str, 1) = 'a'; // the function call is lvalue, can be assigned to
    std::cout &lt;&lt; str &lt;&lt; '\n';
}
}}
{{rev begin}}
{{rev|since=c++11|
====Rvalue references====
Rvalue references can be used to extend the lifetime of a modifiable temporary (note, lvalue references to const can {{rlp|reference_initialization|extend lifetimes}} too, but they are not modifiable)

{{example|code=
#include &lt;iostream&gt;
#include &lt;string&gt;
int main()
{
    std::string s1 = &quot;Test&quot;;
//    std::string&amp;&amp; r1 = s1; // error: can't bind to lvalue

    const std::string&amp; r2 = s1 + s1; // OK, lvalue ref to const extends lifetime
//    r2 += &quot;Test&quot;; // error: can't modify through reference to const

    std::string&amp;&amp; r3 = s1 + s1; // OK, rvalue ref extends lifetime
    r3 += &quot;Test&quot;; // this rvalue can be modified
    std::cout &lt;&lt; r3 &lt;&lt; '\n';
}
}}
More importantly, when a function has both rvalue reference and lvalue reference {{rlp|overload resolution|overloads}}, the rvalue reference overload binds to rvalues, while the lvalue reference overload binds to lvalues.

{{example|code=
#include &lt;iostream&gt;
void f(int&amp; x)
{
     std::cout &lt;&lt; &quot;lvalue reference overload f(&quot; &lt;&lt; x &lt;&lt; &quot;)\n&quot;;
}
void f(const int&amp; x)
{
     std::cout &lt;&lt; &quot;lvalue reference to const overload f(&quot; &lt;&lt; x &lt;&lt; &quot;)\n&quot;;
}
void f(int&amp;&amp; x)
{
     std::cout &lt;&lt; &quot;rvalue reference overload f(&quot; &lt;&lt; x &lt;&lt; &quot;)\n&quot;;
}
int main()
{
    int n = 1;
    const int x = 2;
    f(n); // calls f(int&amp;)
    f(x); // calls f(const int&amp;)
    f(3); // calls f(int&amp;&amp;)
          // would call f(const int&amp;) if f(int&amp;&amp;) overload wasn't provided
}
}}

This allows {{rlp|move_constructor|move constructors}}, {{rlp|move_operator|move assignment}} operators, and other move-aware functions (e.g. {{ltf|cpp/container/vector/push_back|vector::push_back}} to be automatically selected when suitable.
}}
{{rev end}}
====Dangling references====
Although references, once initialized, always refer to valid objects or functions, it is possible to create a program where the life time of the referred-to object ends, but the reference remains accessible (''dangling''). Accessing such reference is undefined behavior.
A common example a function returning a reference to an automatic variable:
{{source|1=
std::string&amp; f() {
    std::string str = &quot;Example&quot;;
    return str; // exits the scope of str: str's destructor is called
}               // stack storage deallocated
...
std::string&amp; r = f(); // r is a dangling reference
std::cout &lt;&lt; r;      // Undefined: reads from a dangling reference
std::string s = f(); // Undefined: uses a dangling reference to copy-initialize s
}}

Note that rvalue references and lvalue references to const extend the lifetimes of temporary objects, see {{rlp|reference initialization}} for rules and exceptions.

If the referred-to object was destroyed (e.g. by explicit destructor call), but the storage was not deallocated, a reference to the out-of-lifetime object may be used in limited ways, and may become valid if the object is recreated in the same storage, see {{rlp|lifetime#Access_outside_of_lifetime|Access outside of lifetime}} for details.

[[de:cpp/language/pointer]]
[[es:cpp/language/pointer]]
[[fr:cpp/language/pointer]]
[[it:cpp/language/pointer]]
[[ja:cpp/language/pointer]]
[[pt:cpp/language/pointer]]
[[ru:cpp/language/pointer]]
[[zh:cpp/language/pointer]]</text>
      <sha1>d5vya0mynwjyq4b1p87h11uw0004v6j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/reference initialization</title>
    <ns>0</ns>
    <id>8869</id>
    <revision>
      <id>72131</id>
      <parentid>72126</parentid>
      <timestamp>2014-07-17T10:10:26Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <comment>Added new syntax for list initialization.</comment>
      <text xml:space="preserve" bytes="8088">{{title|reference initialization}}
{{cpp/language/initialization/navbar}}
Binds a reference to an object

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}} {{ttb|&amp;}} {{spar|ref}} {{ttb|{{=}}}} {{spar|object}} ;

{{spar|T}} {{ttb|&amp;}} {{spar|ref}} {{ttb|{{=}}}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}}

{{spar|T}} {{ttb|&amp;}} {{spar|ref}} {{ttb|(}} {{spar|object}} {{ttb|) }};

{{spar|T}} {{ttb|&amp;}} {{spar|ref}} {{ttb|{ }} {{spar|object}} {{ttb|} }};
}}
{{sdsc | num=2 | {{spar|T}} {{ttb|&amp;&amp;}} {{spar|ref}} {{ttb|{{=}}}} {{spar|object}} ;

{{spar|T}} {{ttb|&amp;&amp;}} {{spar|ref}} {{ttb|{{=}}}} {{ttb|{ }} {{spar|arg1, arg2, ...}} {{ttb|};}}

{{spar|T}} {{ttb|&amp;&amp;}} {{spar|ref}} {{ttb|(}} {{spar|object}} {{ttb|) }};

{{spar|T}} {{ttb|&amp;&amp;}} {{spar|ref}} {{ttb|{}} {{spar|object}} {{ttb|} }};
|notes={{mark since c++11}}
}}
{{sdsc | num=3 | {{spar|R}} {{spar|fn}} {{ttb|(}} {{spar|T}} {{ttb|&amp;}} {{spar|arg}} {{ttb|);}}
{{spar|or}}

{{spar|R}} {{spar|fn}} {{ttb|(}} {{spar|T}} {{ttb|&amp;&amp;}} {{spar|arg}} {{ttb|);}}

{{spar|fn}} {{ttb|(}} {{spar|object}} {{ttb|)}} }}
{{sdsc | num=4 | {{spar|T}} {{ttb|&amp;}} {{spar|fn}} {{ttb|() { }}
{{spar|or}}

{{spar|T}} {{ttb|&amp;&amp;}} {{spar|fn}} {{ttb|() { }}

{{ttb|return}} {{spar|object}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===

A reference to {{tt|T}} can be initialized with an object of type {{tt|T}}, a function of type {{tt|T}}, or an object implicitly convertible to {{tt|T}}. Once initialized, a reference cannot be changed to refer to another object.

References are initialized in the following situations:
@1@ When a named {{rlp|reference#Lvalue_references|lvalue reference}} variable is declared with an initializer
@2@ When a named {{rlp|reference#Rvalue_references|rvalue reference}} variable is declared with an initializer
@3@ In a function call expression, when the function parameter has reference type
@4@ In the {{c|return}} statement, when the function returns a reference type

The effects of reference initialization are:

* If the reference is an lvalue reference:

:* If {{spar|object}} is an lvalue expression, and its type is {{tt|T}} or derived from {{tt|T}}, and is equally or less cv-qualified, then the reference is bound to the object identified by the lvalue or to its base class subobject.

:* If {{spar|object}} is an lvalue expression, and its type is implicitly convertible to a type that is either {{tt|T}} or derived from {{tt|T}}, equally or less cv-qualified, then the non-explicit conversion functions of the source type and its base classes that return lvalue references are considered and the best one is selected by overload resolution. The reference is then bound to the object identified by the lvalue returned by the conversion function (or to its base class subobject)

* Otherwise, if the reference is either rvalue reference or lvalue reference to {{c|const}}:

:* If {{spar|object}} is an xvalue, a class prvalue, an array prvalue, or a function lvalue  type that is either {{tt|T}} or derived from {{tt|T}}, equally or less cv-qualified, then the reference is bound to the value of the initializer expression or to its base subobject.

:* If {{spar|object}} is a class type expression that can be implicitly converted to an xvalue, a class prvalue, or a function value of type that is either {{tt|T}} or derived from {{tt|T}}, equally or less cv-qualified, then the reference is bound to the result of the conversion or to its base subobject.

:* Otherwise, a temporary of type {{tt|T}} is constructed and [[cpp/language/copy_initialization|copy-initialized]] from {{spar|object}}. The reference is then bound to this temporary. Copy-initialization rules apply (explicit constructors are not considered).

===Lifetime of a temporary===
Whenever a reference is bound to a temporary or to a base subobject of a temporary, the lifetime of the temporary is extended to match the lifetime of the reference, with the following exceptions:
* a temporary bound to a return value of a function in a {{c|return}} statement is not extended: it is destroyed immediately at the end of the return expression. Such function always returns a dangling reference.
* a temporary bound to a reference member in a constructor [[cpp/language/initializer_list|initializer list]] persists only until the constructor exits, not as long as the object exists.
* a temporary bound to a reference parameter in a function call exists until the end of the full expression containing that function call: if the function returns a reference, which outlives the full expression, it becomes a dangling reference.
* a temporary bound to a reference in the initializer used in a new-expression exists until the end of the full expression containing that new-expression, not as long as the initialized object. If the initialized object outlives the full expression, its reference member becomes a dangling reference.

In general, the lifetime of a temporary cannot be further extended by &quot;passing it on&quot;: a second reference, initialized from the reference to which the temporary was bound, does not affect its lifetime.

===Notes===
References appear without initializers only in function parameter declaration, in function return type declaration, in the declaration of a class member, and with the {{tt|extern}} specifier.

===Example===

{{example
 |
 | code=
#include &lt;utility&gt;
#include &lt;sstream&gt;
struct S {
 int mi;
 const std::pair&lt;int,int&gt;&amp; mp; // reference member
};

void foo(int) {}

struct A {};
struct B : A {
   int n;
   operator int&amp;() { return n; };
};

B bar() {return B(); }

//int&amp; bad_r; // error: no initializer
extern int&amp; ext_r; // OK

int main()
{
 // lvalues
    int n = 1;
    int&amp; r1 = n;  // lvalue reference to the object n
    const int&amp; cr(n); // reference can be more cv-qualified
    volatile int&amp; cv{n}; // any initializer syntax can be used
    int&amp; r2 = r1; // another lvalue reference to the object n
//    int&amp; bad = cr; // error: less cv-qualified
    int&amp; r3 = const_cast&lt;int&amp;&gt;(cr); // const_cast is needed

    void (&amp;rf)(int) = foo; // lvalue reference to function
    int ar[3];
    int (&amp;ra)[3] = ar; // lvalue reference to array

    B b;
    A&amp; base_ref = b; // reference to base subobject
    int&amp; converted_ref = b; // reference to the result of a conversion

// rvalues
//  int&amp; bad = 1; // error: cannot bind lvalue ref to rvalue
    const int&amp; cref = 1; // bound to rvalue
    int&amp;&amp; rref = 1; // bound to rvalue

    const A&amp; cref2 = bar(); // reference to A subobject of B temporary
    A&amp;&amp; rref2 = bar();      // same

    int&amp;&amp; xref = static_cast&lt;int&amp;&amp;&gt;(n); // bind directly to n
//  int&amp;&amp; copy_ref = n; // error: can't bind to an lvalue
    double&amp;&amp; copy_ref = n; // bind to an rvalue temporary with value 1.0

// restrictions on temporary lifetimes
    std::ostream&amp; buf_ref = std::ostringstream() &lt;&lt; 'a'; // the ostringstream temporary
                      // was bound to the left operand of operator&lt;&lt;, but its lifetime
                      // ended at the semicolon: buf_ref is now a dangling reference.

    S a { 1, {2,3} }; // temporary pair {2,3} bound to the reference member
                      // a.mp and its lifetime is extended to match a
    S* p = new S{ 1, {2,3} }; // temporary pair {2,3} bound to the reference
                      // member a.mp, but its lifetime ended at the semicolon
                      //  p-&gt;mp is a dangling reference
    delete p;
}
 | output=
}}

===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/value_initialization|value initialization]]
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/reference initialization]]
[[es:cpp/language/reference initialization]]
[[fr:cpp/language/reference initialization]]
[[it:cpp/language/reference initialization]]
[[ja:cpp/language/reference initialization]]
[[pt:cpp/language/reference initialization]]
[[ru:cpp/language/reference initialization]]
[[zh:cpp/language/reference initialization]]</text>
      <sha1>bz68604mxc6dsdkr2tqo3h96km4zvgm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/reinterpret cast</title>
    <ns>0</ns>
    <id>2742</id>
    <revision>
      <id>71507</id>
      <parentid>70255</parentid>
      <timestamp>2014-06-12T03:43:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>the new description for pointer to pointer in the std is through two static_casts</comment>
      <text xml:space="preserve" bytes="7701">{{title|reinterpret_cast conversion}}
{{cpp/language/expressions/navbar}}

Converts between types by reinterpreting the underlying bit pattern.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|reinterpret_cast &amp;lt;}} {{spar|new_type}} {{ttb|&amp;gt; (}} {{spar|expression}} {{ttb|)}} }}
{{sdsc end}}

Returns a value of type {{tt|new_type}}.

===Explanation===

Unlike {{c|static_cast}}, but like {{c|const_cast}}, the {{c|reinterpret_cast}} expression does not compile to any CPU instructions. It is purely a compiler directive which instructs the compiler to treat the sequence of bits (object representation) of {{spar|expression}} as if it had the type {{spar|new_type}}.

Only the following conversions can be done with {{c|reinterpret_cast}}, except when such conversions would cast away ''constness'' or ''volatility''.

@1@ An expression of integral, enumeration, pointer, or pointer-to-member type can be converted to its own type. The resulting value is the same as the value of {{tt|expression}}. {{mark since c++11}}
@2@ Any pointer can be converted to any integral type large enough to hold the value of the pointer (e.g. to {{lc|std::uintptr_t}})
@3@ A value of any integral or enumeration type can be converted to a pointer type. A pointer converted to an integer of sufficient size and back to the same pointer type is guaranteed to have its original value, otherwise the resulting pointer cannot be dereferenced safely. The null pointer constant {{lc|NULL}} or integer zero is not guaranteed to yield the null pointer value of the target type; {{rlp|static_cast}} or {{rlp|implicit_cast|implicit conversion}} should be used for this purpose.
@4@ Any value of type {{lc|std::nullptr_t}}, including {{c|nullptr}} can be converted to any integral type as if it was {{c|(void*)0}}, but no value, not even {{c|nullptr}} can be converted to {{lc|std::nullptr_t}}: {{c|static_cast}} should be used for that purpose. {{mark since c++11}}
@5@ Any pointer to object of type {{tt|T1}} can be converted to pointer to object of another type ''cv'' {{tt|T2}}. This is exactly equivalent to {{c|static_cast&lt;cv T2*&gt;(static_cast&lt;cv void*&gt;(expression))}} (which implies that if {{tt|T2}}'s alignment requirement is not stricter than {{tt|T1}}'s, the value of the pointer does not change and conversion of the resulting pointer back to its original type yields the original value). In any case, the resulting pointer may only be dereferenced safely if allowed by the ''type aliasing'' rules (see below) 
@6@ An lvalue expression of type {{tt|T1}} can be converted to reference to another type {{tt|T2}}. The result is an lvalue or xvalue referring to the same object as the original lvalue, but with a different type. No temporary is created, no copy is made, no constructors or conversion functions are called. The resulting reference can only be accessed safely if allowed by the ''type aliasing'' rules (see below)
@7@ Any pointer to function can be converted to a pointer to a different function type. Calling the function through a pointer to a different function type is undefined, but converting such pointer back to pointer to the original function type yields the pointer to the original function.
@8@ On some implementations (in particular, on any POSIX compatible system), a function pointer can be converted to an object pointer or vice versa. If the implementation supports conversion in both directions, conversion to the original type yields the original value, otherwise the resulting pointer cannot be dereferenced or called safely.
@9@ The null pointer value of any pointer type can be converted to any other pointer type, resulting in the null pointer value of that type. Note that the null pointer constant {{c|nullptr}} or any other value of type {{lc|std::nullptr_t}} cannot be converted to a pointer with {{c|reinterpret_cast}}: implicit conversion or {{c|static_cast}} should be used for this purpose.
@10@ An rvalue pointer to member function can be converted to pointer to a different member function of a different type. Conversion to the original type yields the original value, otherwise the resulting pointer cannot be used safely.
@11@ An rvalue pointer to member object of some class {{tt|T1}} can be converted to a pointer to another member object of another class {{tt|T2}}. If {{tt|T2}}'s alignment is not stricter than {{tt|T1}}'s, conversion to the original type yields the original value, otherwise the resulting pointer cannot be used safely.

{{cpp/language/cast_return}}

===Keywords===

{{ltt|cpp/keyword/reinterpret_cast}}

===Type aliasing===

When a pointer or reference to object of type {{tt|T1}} is {{tt|reinterpret_cast}} (or C-style cast) to a pointer or reference to object of a different type {{tt|T2}}, the cast always succeeds, but the resulting pointer or reference may only be accessed if one of the following is true:

* T2 is the (possibly cv-qualified) dynamic type of the object

* T2 and T1 are both (possibly multi-level, possibly cv-qualified at each level) pointers to the same type T3 {{mark since c++11}}

* T2 is the (possibly cv-qualified) signed or unsigned variant of the dynamic type of the object

* T2 is an aggregate type or a union type which holds one of the aforementioned types as an element or non-static member (including, recursively, elements of subaggregates and non-static data members of the contained unions): this makes it safe to cast from the first member of a struct and from an element of a union to the struct/union that contains it.

* T2 is a (possibly cv-qualified) base class of the dynamic type of the object

* T2 is {{c|char}} or {{c|unsigned char}}

If T2 does not satisfy these requirements, accessing the object through the new pointer or reference invokes undefined behavior. This is known as the ''strict aliasing'' rule and applies to both C++ and C programming languages.

Note that many compilers implement disable this rule, as a non-standard language extension, if the wrong-type access is made through the inactive member of a {{rlp|union}}.

===Example===

{{example
 | Demonstrates some uses of reinterpret_cast:
 | code=
#include &lt;cstdint&gt;
#include &lt;cassert&gt;
#include &lt;iostream&gt;
int f() { return 42; }
int main()
{
    int i = 7;

    // pointer to integer and back
    uintptr_t v1 = reinterpret_cast&lt;uintptr_t&gt;(&amp;i); // static_cast is an error
    std::cout &lt;&lt; &quot;The value of &amp;i is 0x&quot; &lt;&lt; std::hex &lt;&lt; v1 &lt;&lt; '\n';
    int* p1 = reinterpret_cast&lt;int*&gt;(v1);
    assert(p1 == &amp;i);

    // pointer to function to another and back
    void(*fp1)() = reinterpret_cast&lt;void(*)()&gt;(f);
    // fp1(); undefined behavior
    int(*fp2)() = reinterpret_cast&lt;int(*)()&gt;(fp1);
    std::cout &lt;&lt; std::dec &lt;&lt; fp2() &lt;&lt; '\n'; // safe

    // type aliasing through pointer
    char* p2 = reinterpret_cast&lt;char*&gt;(&amp;i);
    if(p2[0] == '\x7')
        std::cout &lt;&lt; &quot;This system is little-endian\n&quot;;
    else
        std::cout &lt;&lt; &quot;This system is big-endian\n&quot;;

    // type aliasing through reference
    reinterpret_cast&lt;unsigned int&amp;&gt;(i) = 42;
    std::cout &lt;&lt; i &lt;&lt; '\n';
}
 | p=true
 | output=
The value of &amp;i is 0x7fff352c3580
42
This system is little-endian
42
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc const_cast}}
{{dsc inc | cpp/language/dsc static_cast}}
{{dsc inc | cpp/language/dsc dynamic_cast}}
{{dsc inc | cpp/language/dsc explicit_cast}}
{{dsc inc | cpp/language/dsc implicit_cast}}
{{dsc end}}

[[de:cpp/language/reinterpret cast]]
[[es:cpp/language/reinterpret cast]]
[[fr:cpp/language/reinterpret cast]]
[[it:cpp/language/reinterpret cast]]
[[ja:cpp/language/reinterpret cast]]
[[pt:cpp/language/reinterpret cast]]
[[ru:cpp/language/reinterpret cast]]
[[zh:cpp/language/reinterpret cast]]</text>
      <sha1>sdr5xrr06g5zsq9yve4shsxxjq8fs4u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/return</title>
    <ns>0</ns>
    <id>710</id>
    <revision>
      <id>67777</id>
      <parentid>67776</parentid>
      <timestamp>2014-02-26T19:58:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/is/names</comment>
      <text xml:space="preserve" bytes="3736">{{title|return statement}}
{{cpp/language/statements/navbar}}
Terminates current function and returns specified value to the caller function.

===Syntax===

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|return}} {{spar|expression}}{{mark optional}} {{ttb|;}}
}}
{{sdsc|num=2|notes={{mark since c++11}}|1=
{{spar|attr}}{{mark optional}} {{ttb|return}} {{spar|braced-init-list}} {{ttb|;}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of {{rlp|attributes}}}}
{{par | {{spar|expression}} | {{rlp|expressions|expression}}, convertible to the function return type}}
{{par | {{spar|braced-init-list}} | brace-enclosed list of initializers and other braced-init-lists}}
{{par end}}

===Explanation===
@1@ Evaluates the {{spar|expression}}, terminates the current function and returns the result of the {{spar|expression}} to the caller, after {{rlp|implicit_cast|implicit conversion}} to the function return type. The {{spar|expression}} is optional in functions whose return type is (possibly cv-qualified) {{c|void}}, in constructors and in destructors.

@2@ Uses {{rlp|list_initialization|copy-list-initialization}} to construct the return value of the function.

===Notes===
If control reaches the end of a function without encountering a return statement, {{c|return;}} is executed (except in the {{rlp|main function}}, where {{c|return 0;}} is executed).

Flowing off the end of a value-returning function (except {{c|main}}) without a return statement is undefined behavior.

In a function returning {{c|void}}, the return statement with {{spar|expression}} can be used, if the expression type is {{c|void}}.

Returning by value may involve construction and copy/move of a temporary object, unless {{rlp|copy_elision|copy elision}} is used.

{{rev begin}}
{{rev|since=c++11|
If {{spar|expression}} is an lvalue expression and the conditions for {{rlp|copy_elision|copy elision}} are met, or would be met, except that {{spar|expression}} names a function parameter, then {{rlp|overload resolution}} to select the constructor to use for initialization of the returned value is performed ''twice'': first as if {{spar|expression}} were an rvalue expression (thus it may select the move constructor or a copy constructor taking reference to const), and if no suitable conversion is available, overload resolution is performed the second time, with lvalue {{spar|expression}} (so it may select the copy constructor taking a reference to non-const).
}}
{{rev|since=c++14|
The above rule applies even if the function return type is different from the type of {{spar|expression}} (copy elision requires same type)
}}
{{rev end}}

===Keywords===

{{ltt|cpp/keyword/return}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;utility&gt;

void fa(int i)
{
    if (i == 2)
         return;
    std::cout &lt;&lt; i &lt;&lt; '\n';
} // implied return;

int fb(int i)
{
    if (i &gt; 4)
         return 4;
    std::cout &lt;&lt; i &lt;&lt; '\n';
    return 2;
}

std::pair&lt;std::string, int&gt; fc(const char* p, int x)
{
    return {p, x};
}

void fd()
{
    return fa(10); // fa(10) is a void expression
}

int main()
{
    fa(2); // returns, does nothing when i==2
    fa(1); // prints its argument, then returns
    int i = fb(5); // prints its argument, returns 2
    i = fb(i); // prints its argument, returns 4
    std::cout &lt;&lt; i &lt;&lt; '\n'
              &lt;&lt; fc(&quot;Hello&quot;, 7).second &lt;&lt; '\n';;
    fd();
}
 | output=
1
4
2
7
10
}}

[[ar:cpp/language/return]]
[[de:cpp/language/return]]
[[es:cpp/language/return]]
[[fr:cpp/language/return]]
[[it:cpp/language/return]]
[[ja:cpp/language/return]]
[[pt:cpp/language/return]]
[[ru:cpp/language/return]]
[[zh:cpp/language/return]]</text>
      <sha1>6yojb4b2adscnid86rkx3egekbycma8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/rule of three</title>
    <ns>0</ns>
    <id>13512</id>
    <revision>
      <id>69723</id>
      <parentid>69722</parentid>
      <timestamp>2014-04-21T17:04:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+public, +ctor for the Ro0</comment>
      <text xml:space="preserve" bytes="5744">{{title|The rule of three/five/zero}}
{{cpp/language/navbar}}

===Rule of three===
If a class requires a user-defined {{rlp|destructor}}, a user-defined {{rlp|copy constructor}}, or a user-defined {{rlp|as_operator|copy assignment operator}}, it almost certainly requires all three.

Because C++ copies and copy-assigns objects of user-defined types in various situations (passing/returning by value, manipulating a container, etc), these special member functions will be called, if accessible, and if they are not user-defined, they are implicitly-defined by the compiler.

The implicitly-defined special member functions are typically incorrect if the class is managing a resource whose handle is an object of non-class type (raw pointer, POSIX file descriptor, etc), whose destructor does nothing and copy constructor/assignment operator performs a &quot;shallow copy&quot; (copy the value of the handle, without duplicating the underlying resource). 

{{source|1=
class rule_of_three
{
    char* cstring; // raw pointer used as a handle to a dynamically-allocated memory block
 public:
    rule_of_three(const char* arg)
    : cstring(new char[std::strlen(arg)+1]) // allocate
    {
        std::strcpy(cstring, arg); // populate
    }
    ~rule_of_three()
    {
        delete[] cstring;  // deallocate
    }
    rule_of_three(const rule_of_three&amp; other) // copy constructor
    {
        cstring = new char[std::strlen(other.cstring) + 1];
        std::strcpy(cstring, other.cstring);
    }
    rule_of_three&amp; operator=(const rule_of_three&amp; other) // copy assignment
    {
        char* tmp_cstring = new char[std::strlen(other.cstring) + 1];
        std::strcpy(tmp_cstring, other.cstring);
        delete[] cstring;
        cstring = tmp_cstring;
        return *this;
    }
// alternatively, reuse destructor and copy ctor
//  rule_of_three&amp; operator=(rule_of_three other)
//  {
//      std::swap(cstring, other.cstring);
//      return *this;
//  }
};
}}

Classes that manage non-copyable resources through copyable handles may have to declare copy assignment and copy constructor private and not provide their definitions or define them as deleted. This is another application of the rule of three: deleting one and leaving the other to be implicitly-defined will most likely result in errors.

===Rule of five===
Because the presence of a user-defined destructor, copy-constructor, or copy-assignment operator prevents implicit definition of the {{rlp|move constructor}} and the {{rlp|move operator|move assignment operator}}, any class for which move semantics are desirable, has to declare all five special member functions:

{{source|1=
class rule_of_five
{
    char* cstring; // raw pointer used as a handle to a dynamically-allocated memory block
 public:
    rule_of_five(const char* arg)
    : cstring(new char[std::strlen(arg)+1]) // allocate
    {
        std::strcpy(cstring, arg); // populate
    }
    ~rule_of_five()
    {
        delete[] cstring;  // deallocate
    }
    rule_of_five(const rule_of_five&amp; other) // copy constructor
    {
        cstring = new char[std::strlen(other.cstring) + 1];
        std::strcpy(cstring, other.cstring);
    }
    rule_of_five(rule_of_five&amp;&amp; other) : cstring(other.cstring) // move constructor
    {
        other.cstring = nullptr;
    }
    rule_of_five&amp; operator=(const rule_of_five&amp; other) // copy assignment
    {
        char* tmp_cstring = new char[std::strlen(other.cstring) + 1];
        std::strcpy(tmp_cstring, other.cstring);
        delete[] cstring;
        cstring = tmp_cstring;
        return *this;
    }
    rule_of_five&amp; operator=(rule_of_five&amp;&amp; other) // move assignment
    {
        delete[] cstring;
        cstring = other.cstring;
        other.cstring = nullptr;
        return *this;
    }
// alternatively, replace both assignment operators with 
//  rule_of_five&amp; operator=(rule_of_five other)
//  {
//      std::swap(cstring, other.cstring);
//      return *this;
//  }
};
}}

Unlike Rule of Three, failing to provide move constructor and move assignment is usually not an error, but a missed optimization opportunity.

===Rule of zero===
Classes that have custom destructors, copy/move constructors or copy/move assignment operators should deal exclusively with ownership. Other classes should not have custom destructors, copy/move constructors or copy/move assignment operators.&lt;ref&gt;[http://flamingdangerzone.com/cxx11/2012/08/15/rule-of-zero.html &quot;Rule of Zero&quot;, R. Martinho Fernandes 8/15/2012]&lt;/ref&gt;
{{source|1=
class rule_of_zero
{
    std::string cppstring;
 public:
    rule_of_zero(const std::string&amp; arg) : cppstring(arg) {}
};
}}

When a base class is intended for polymorphic use, its destructor may have to be declared public and virtual. This blocks implicit moves (and deprecates implicit copies), and so the special member functions have to be declared as defaulted&lt;ref&gt;[http://scottmeyers.blogspot.fr/2014/03/a-concern-about-rule-of-zero.html &quot;A Concern about the Rule of Zero&quot;, Scott Meyers, 3/13/2014]&lt;/ref&gt;
{{source|1=
class base_of_five_defaults
{
 public:
    base_of_five_defaults(const base_of_five_defaults&amp;) = default;
    base_of_five_defaults(base_of_five_defaults&amp;&amp;) = default;
    base_of_five_defaults&amp; operator=(const base_of_five_defaults&amp;) = default;
    base_of_five_defaults&amp; operator=(base_of_five_defaults&amp;&amp;) = default;
    virtual ~base_of_five_defaults() = default;
};
}}
however, this can be avoided if the objects of the derived class are not dynamically allocated, or are dynamically allocated only to be stored in a {{lc|std::shared_ptr}} (such as by {{lc|std::make_shared}}): shared pointers invoke the derived class destructor even after casting to {{tt|std::shared_ptr&lt;Base&gt;}}.

===References===
&lt;references/&gt;</text>
      <sha1>o0niqi3bsofrmpj8ead6jl9f0i9vk4f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/scope</title>
    <ns>0</ns>
    <id>13085</id>
    <revision>
      <id>71081</id>
      <parentid>69928</parentid>
      <timestamp>2014-06-05T16:08:02Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>/* Function prototype scope */  compare 'int (*(*f2)(int n))[n];' with 'auto (*f3)(int n)-&gt;int (*)[n];'</comment>
      <text xml:space="preserve" bytes="14230">{{title|Scope}}
{{cpp/language/basics/navbar}}
Each {{rlp|name}} that appears in a C++ program is only valid in some possibly discontiguous
portion of the source code called its ''scope''.

Within a scope, {{rlp|lookup|unqualified name lookup}} can be used to associate the name with its declaration.

===Block scope===
The potential scope of a variable introduced by a declaration in a {{rlp|statements#Compound statement|block (compound statement)}} begins at the point of declaration and ends at the end of the block. Actual scope is the same as potential scope unless there is a nested block with a declaration that introduces identical name (in which case, the entire potential scope of the nested declaration is excluded from the scope of the outer declaration)

{{source|1=
int main()
{
    int a = 0; // scope of the first 'a' begins
    ++a; // the name 'a' is in scope and refers to the first 'a'
    {
        int a = 1; // scope of the second 'a' begins
                   // scope of the first 'a' is interrupted
        a = 42;    // 'a' is in scope and refers to the second 'a'                 
    } // block ends, scope of the second 'a' ends
      //             scope of the first 'a' resumes
} // block ends, scope of the first 'a' ends
int b = a; // Error: name 'a' is not in scope
}}

The potential scope of a function parameter (including parameters of a lambda expression) begins at the point of declaration and ends at the end of the last exception handler of the {{rlp|function-try-block}}, or at the end of the function body if a function try block was not used.

{{source|1=
int f(int n = 2)  // scope of 'n' begins
try // function try block
{         // the body of the function begins
   ++n;   // 'n' is in scope and refers to the function parameter
   int n = 2; // scope of the local variable 'n' begins
              // scope of function parameter 'n' interrupted
} // scope of local variable 'n' ends
  // scope of function parameter 'n' resumes
 catch(...) {
   ++n; // n is in scope and refers to the function parameter
   throw;
} // last exception handler ends, scope of 'n' ends
int a = n; // Error: name 'n' is not in scope
}}

The potential scope of a name declared in an exception handler begins at the point of declaration and ends when the exception handler ends, and is not in scope in another exception handler or in the enclosing block.

{{source|1=
try {   
    f();
} catch(const std::runtime_error&amp; re) { // scope of re begins
    int n = 1; // scope of n begins
    std::cout &lt;&lt; re.what(); // re is in scope
} // scope of re ends, scope of n ends
 catch(std::exception&amp; e) {
    std::cout &lt;&lt; re.what(); // error: re is not in scope
    ++n; // error: n is not in scope
}
}}

The potential scope of a name declared in the ''init-statement'' of the {{rlp|for|for loop}}, in the ''condition'' of a {{rlp|for|for loop}}, in the ''range_declaration'' of a {{rlp|range-for|range for loop}}, in the ''condition'' of the {{rlp|if|if statement}}, {{rlp|while|while loop}}, or {{rlp|switch|switch statement}} begins at the point of declaration and ends at the end of the controlled statement.

{{source|1=
Base* bp = new Derived;
if(Derived* dp = dynamic_cast&lt;Derived*&gt;(bp))
{
    dp-&gt;f(); // dp is in scope
} // scope of dp ends
        
for(int n = 0; // scope of n begins
    n &lt; 10;    // n is in scope
    ++n)       // n is in scope
{
    std::cout &lt;&lt; n &lt;&lt; ' '; // n is in scope
} // scope of n ends
}}

===Function prototype scope===
The scope of a name introduced in the parameter list of a function declaration that is not a definition ends at the end of the function declarator. If there are multiple or nested declarators in the declaration, the scope ends at the end of the nearest enclosing function declarator.

{{source|1=
const int n = 3;

int f1(int n,     // scope of global 'n' interrupted,
                  // scope of the parameter 'n' begins
       int y = n); // error: default argument references a parameter

int (*(*f2)(int n))[n]; // OK: the scope of the function parameter 'n'
                        // ends at the end of its function declarator
                        // in the array declarator, global n is in scope
// (this declares a pointer to function returning a pointer to an array of 3 int

// by contrast
auto (*f3)(int n)-&gt;int (*)[n]; // error: parameter 'n' as array bound
}}

===Function scope===
A {{rlp|statements#Labels|label (and only a label)}} declared inside a function is in scope everywhere in that function, in all nested blocks, before and after its own declaration.

{{source|1=
void f()
{
   {   
       goto label; // label in scope even though declared later
label:;
   }
   goto label; // label ignores block scope
}

void g()
{
    goto label; // error: label not in scope in g()
}
}}

===Namespace scope===
The potential scope of any entity declared in a {{rlp|namespace}} begins at the declaration and consists of the concatenation of all namespace definitions for the same namespace name that follow, plus, for any {{rlp|namespace|using-directive}} that introduced this name or its entire namespace into another scope, the rest of that scope.

The top-level scope of a translation unit (&quot;file scope&quot; or &quot;global scope&quot;) is also a namespace and is properly called &quot;global namespace scope&quot;. The potential scope of any entity declared in the global namespace scope begins at the declaration and continues to the end of the translation unit. 

The scope of an entity declared in an unnamed namespace or in an inline namespace includes the enclosing namespace;

{{source|1=
namespace N { // scope of N begins (as a member of global namespace)
    int i; // scope of i begins
    int g(int a) { return a; } // scope of g begins
    int j(); // scope of j begins
    void q(); // scope of q begins
    namespace {
        int x; // scope of x begins
    } // scope of x does not end
    inline namespace inl { // scope of inl begins
      int y; // scope of y begins
    } // scope of y does not end
} // scope of i,g,j,q,inl,x,y interrupted

namespace {
    int l=1; // scope of l begins
} // scope of l does not end (it's a member of unnamed namespace)

namespace N { // scope of i,g,j,q,inl,x,y continues
    int g(char a) {  // overloads N::g(int)
        return l+a;  // l from unnamed namespace is in scope
    }
    int i; // error: duplicate definition (i is already in scope)
    int j(); // OK: repeat function declaration is allowed
    int j() { // OK: definition of the earlier-declared N::j()
        return g(i); // calls N::g(int)
    }
    int q(); // error: q is already in scope with different return type
} // scope of i,g,j,q,inl,x,y interrupted

int main() {
    using namespace N; // scope of i,g,j,q,inl,x,y resumes
    i = 1; // N::i is in scope
    x = 1; // N::(anonymous)::x is in scope
    y = 1; // N::inl::y is in scope
    inl::y = 2; // N::inl is also in scope
} // scope of i,g,j,q,inl,x,y interrupted

}}
===Class scope===
The potential scope of a name declared in a {{rlp|class}} begins at the point of declaration and includes the rest of the class body and all function bodies (even if defined outside the class definition or before the declaration of the name), default arguments, exception specifications, in-class brace-or-equal initializers, and all these things in nested classes, recursively.

{{source|1=
class X {
    int f(int a = n) { // X::n is in scope inside default parameter
         return a*n;   // X::n is in scope inside function body
    }
    int g();
    int i = n*2;   // X::n is in scope inside initializer

//  int x[n];      // Error: n is not in scope in class body
    static const int n = 1;
    int x[n];      // OK: n is now in scope in class body
};
int X::g() { return n; } // X::n is in scope in out-of-class member function body
}}

If a name is used in a class body before it is declared, and another declaration for that name is in scope, the program is ill-formed

{{source|1=
typedef int c; // ::c
enum { i = 1 }; // ::i
class X {
    char v[i]; // Error: at this point, i refers to ::i
               // but there is also X::i
    int f() {
         return sizeof(c); // OK: X::c, not ::c is in scope inside a member function
    }
    char c; // X::c
    enum { i = 2 }; // X::i
};

typedef char* T;
struct Y {
    T a; // error: at this point, T refers to ::T
         // but there is also Y::T
    typedef long T;
    T b;
};
}}

Names of any class members can only be used in four contexts:
* in its own class scope or in the class scope of a derived class
* after the {{ttb|.}} operator applied to an expression of the type of its class or a class derived from it
* after the {{ttb|-&gt;}} operator applied to an expression of the type of pointer to its class or pointers to a class derived from it
* after the {{ttb|::}} operator applied to the name of its class or the name of a class derived from it

===Enumeration scope===
The name of an enumerator introduced in a {{rlp|enum|scoped enumeration}} begins at the point of declaration and ends at the end of the enum specifier (in contrast, unscoped enumerators are in scope after the end of the enum specifier)

{{source|1=
enum e1_t { // unscoped enumeration
  A,
  B = A*2
}; // scope of A and B does not end

enum class e2_t { // scoped enumeration
    SA,
    SB = SA*2 // SA is in scope
}; // scope of SA and SB ends

e1_t e1 = B; // OK, B is in scope
// e2_t e2 = SB; // Error: SB is not in scope
e2_t e2 = e2_t::SB; // OK

}}
===Template parameter scope===
The potential scope of a template parameter name begins immediately at the point of declaration and continues to the end of the smallest template declaration in which it was introduced.  In particular, a template parameter can be used in the declarations of subsequent template parameters and in the specifications of base classes, but can't be used in the declarations of the preceding template parameters.

{{source|1=
template&lt; typename T, // scope of T begins
          T* p,       // T can be used for a non-type parameter
          class U = T // T can be used for a default type
        &gt;
class X : public Array&lt;T&gt; // T can be used in base class name
{
   // T can be used inside the body as well
}; // scopes of T and U end, scope of X continues
}}

The potential scope of the name of the parameter of a template template parameter is the smallest template parameter list in which that name appears

{{source|1=
template&lt; template&lt; // template template parameter
                    typename Y,     // scope of Y begins
                    typename G = Y // Y is in scope
                  &gt; // scopes of Y and G end
          class T,
//          typename U = Y // Error: Y is not in scope
          typename U
        &gt;
class X
{
}; // scopes of T and U end
}}

Similar to other nested scopes, the name of a template parameter hides the same name from the outer scope for the duration of its own:

{{source|1=
typedef int N;
template&lt; N X, // non-type parameter of type int
          typename N, // scope of this N begins, scope of ::N interrupted
          template&lt;N Y&gt; class T // N here is the template parameter, not int
         &gt; struct A;
}}

===Point of declaration===
Scope begins at the ''point of declaration'', which is located as follows:

For variables and other names introduced by simple declarations, the point of declaration is immediately after that name's {{rlp|declarations#Declarators|declarator}} and before its initializer, if any:

{{source|1=
unsigned char x = 32; // scope of the first 'x' begins
{
    unsigned char x = x; // scope of the second 'x' begins before the initializer (= x)
                         // this does not initialize the second 'x' with the value 12, 
                         // this initializes the second 'x' with its own, indeterminate, value
}
std::function&lt;int(int)&gt; f = [&amp;](int n){return n&gt;1 ? n*f(n-1) : n;};
           // the name of the function 'f' is in scope within the lambda, and can
           // be correctly captured by reference, giving a recursive function
}}

{{source|1=
const int x = 2; // scope of the first 'x' begins
{
    int x[x] = {}; // scope of the second x begins before the initializer (= {})
                   // but after the declarator (x[x]). Within the declarator, the outer
                   // 'x' is still in scope. This declares an array of 2 int.
}
}}

The point of declaration of a class or template is immediately after the identifier that names the class (or the template-id that names the template) appears in its {{rlp|classes|class-head}}, and is already in scope in the list of the base classes:

{{source|1=
// the name 'S' is in scope immediately after it appears, 
// so it can be used in the list of base classes
struct S: std::enable_shared_from_this&lt;S&gt; 
{
};
}}

The point of declaration of an enumeration is immediately after the identifier that names it appears in the {{rlp|enum|enum specifier}} or opaque enum declaration, whichever is used first.

{{source|1=
enum E : int { // E is already in scope
    A = sizeof(E)
};
}}

The point of declaration of a {{rlp|type alias|type alias or alias template}} is immediately after the type-id to which the alias refers.

{{source|1=
using T = int; // point of declaration of T is at the semicolon
using T = T;   // same as T = int
}}

The point of declaration of an enumerator is immediately after its definition (not before the initializer as it is for variables):

{{source|1=
const int x = 12;
{
    enum { x = x + 1, // point of declaration is at the comma, x is initialized to 13
           y = x + 1  // the enumerator x is now in scope, y is initialized to 14
         };
}
}}

The point of declaration for an {{spar|injected-class-name}} is immediately following the opening brace of its class (or class template) definition

{{source|1=
template&lt;typename T&gt;
struct Array
{ // the injected class name Array is now in scope as if a public member name
    Array* p; // pointer to Array&lt;T&gt;
};
}}

{{todo|remainder of [basic.scope.pdecl]}}


===References===
{{ref std c++11}}
{{ref std | section=3.3 | title=Scope | id=basic.scope}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=3.3 | title=Declarative regions and scopes | id=basic.scope}}
{{ref std end}}</text>
      <sha1>24lw93eop3me6ieyj27xueie4enuf2j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/sfinae</title>
    <ns>0</ns>
    <id>13155</id>
    <revision>
      <id>72251</id>
      <parentid>69621</parentid>
      <timestamp>2014-07-30T03:03:20Z</timestamp>
      <contributor>
        <username>Nestal</username>
        <id>3274</id>
      </contributor>
      <text xml:space="preserve" bytes="7733">{{title|SFINAE}}
{{cpp/language/templates/navbar}}

&quot;Substitution Failure Is Not An Error&quot;


This rule applies during overload resolution of function templates: When substituting the deduced type for the template parameter fails, the specialization is discarded from the {{rlp|overload resolution|overload set}} instead of causing a compile error.

This feature is used in template metaprogramming.

===Explanation===
Function template parameters are substituted (replaced by template arguments) twice:

* explicitly specified template arguments are substituted before template argument deduction
* deduced arguments and the arguments obtained from the defaults are substituted after template argument deduction

Substitution occurs in
* all types used in the function type (which includes return type and the types of all parameters)
* all types used in the template parameter declarations
{{rev begin}}
{{rev|since=c++11|
* all expressions used in the function type
* all expressions used in a template parameter declaration
}}
{{rev end}}

A ''substitution failure'' is any situation when the type or expression above would be ill-formed (with a required diagnostic), if written using the substituted arguments.

Only the failures in the types and expressions in the ''immediate context'' of the function type or its template parameter types are SFINAE errors. If the evaluation of a substituted type/expression causes a side-effect such as instantiation of some template specialization, generation of an implicitly-defined member function, etc, errors in those side-effects are treated as hard errors.
{{todo|mini-example where this matters}}

{{rev begin}}
{{rev | since=c++14|
Substitution proceeds in lexical order and stops when a failure is encountered.
{{source|1=
template&lt;typename SomeType&gt;
struct inner_type { typedef typename SomeType::type type; };
template &lt;
  class T,
  class   = typename T::type,            // SFINAE failure if T has no member type
  class U = typename inner_type&lt;T&gt;::type // hard error if T has no member type (never occurs)
&gt; void foo (int);
}}}}{{rev end}}

===Type SFINAE===
The following type errors are SFINAE errors:

{{rev begin}}
{{rev|since=c++11|
* attempting to instantiate a pack expansion containing multiple packs of different lengths
}}
{{rev end}}
* attempting to create an array of void, array of reference, array of function, array of abstract class types, array of negative size, or array of size zero.
{{source|1=
template&lt;int I&gt; void div(char(*)[I % 2 == 0] = 0) {
    // this overload is selected when I is even
}
template&lt;int I&gt; void div(char(*)[I % 2 == 1] = 0) {
    // this overload is selected  when I is odd
}
}}
* attempting to use a type that is not a class or enumeration on the left of a scope resolution operator {{ttb|::}}
{{source|1=
template &lt;class T&gt; int f(typename T::B*);
int i = f&lt;int&gt;(0); // failure: int cannot be used to the left of ::
// todo: needs to demonstrate overload resolution, not just failure
}}
* attempting to use a member of a type, where
:* the type does not contain the specified member
:* the specified member is not a type where a type is required
:* the specified member is not a template where a template is required
:* the specified member is not a non-type where a non-type is required
{{source|1=
template &lt;int I&gt; struct X { };
template &lt;template &lt;class T&gt; class&gt; struct Z { };
template &lt;class T&gt; void f(typename T::Y*){}
template &lt;class T&gt; void g(X&lt;T::N&gt;*){}
template &lt;class T&gt; void h(Z&lt;T::template TT&gt;*){}
struct A {};
struct B { int Y; };
struct C { typedef int N; };
struct D { typedef int TT; };
int main() {
    // Deduction fails in each of these cases:
    f&lt;A&gt;(0); // A does not contain a member Y
    f&lt;B&gt;(0); // The Y member of B is not a type
    g&lt;C&gt;(0); // The N member of C is not a non-type
    h&lt;D&gt;(0); // The TT member of D is not a template
}
// todo: needs to demonstrate overload resolution, not just failure
}}
* attempting to create a pointer to reference
* attempting to create a reference to void
* attempting to create pointer to member of T, where T is not a class type
{{source|1=
template&lt;typename T&gt;
class is_class {
    typedef char yes[1];
    typedef char no [2];
    template&lt;typename C&gt; static yes&amp; test(int C::*); // selected if C is a class type
    template&lt;typename C&gt; static no&amp;  test(...);      // selected otherwise
  public:
    static bool const value = sizeof(test&lt;T&gt;(0)) == sizeof(yes);
};
}}
* attempting to give an invalid type to a non-type template parameter
{{source|1=
template &lt;class T, T&gt; struct S {};
template &lt;class T&gt; int f(S&lt;T, T()&gt;*);
struct X {};
int i0 = f&lt;X&gt;(0);
// todo: needs to demonstrate overload resolution, not just failure
}}
* attempting to perform an invalid conversion in 
:* in a template argument expression
:* in an expression used in function declaration
{{source|1=
template &lt;class T, T*&gt; int f(int);
int i2 = f&lt;int,1&gt;(0); // can’t conv 1 to int*
// todo: needs to demonstrate overload resolution, not just failure
}}
* attempting to create a function type with a parameter of type void
* attempting to create a function type which returns an array type or a function type
{{rev begin}}
{{rev | until=c++11|
* attempting to create a cv-qualified function type
}}{{rev |since=c++11|
* attempting to create a function type with a parameter or return type that is an {{rlp|abstract class}}.
}}{{rev end}}

===Expression SFINAE===
{{rev begin}}
{{rev | since=c++11 |
The following expression errors are SFINAE errors

* Ill-formed expression used in a template parameter type
* Ill-formed expression used in the function type
{{source|1=
struct X {};
struct Y { Y(X){} }; // X is convertible to Y

template &lt;class T&gt;
auto f(T t1, T t2) -&gt; decltype(t1 + t2); // overload #1

X f(Y, Y);  // overload #2

X x1, x2;
X x3 = f(x1, x2);  // deduction fails on #1 (expression x1+x2 is ill-formed)
                   // only #2 is in the overload set, and is called
}}

}}
{{rev | until=c++11|
Only constant expressions that are used in types (such as array bounds) were required to be treated as SFINAE (and not hard errors) before C++11.
}}
{{rev end}}

===Library support===
The standard library component {{lc|std::enable_if}} allows for creating a substitution failure in order to enable or disable particular overloads based on a condition evaluated at compile time.

In addition, many [[cpp/types|type traits]] are implemented using SFINAE.

===Examples===
{{example|A common idiom is to use expression SFINAE on the return type, where the expression uses the comma operator, whose left subexpression is the one that is being examined (cast to void to ensure the user-defined operator comma on the returned type is not selected), and the right subexpression has the type that the function is supposed to return.
|code=
#include &lt;iostream&gt;
struct not_a_type{};

// this overload is always in the set of overloads
// ellipsis parameter has the lowest ranking for overload resolution
void test(...)
{
    std::cout &lt;&lt; &quot;Catch-all overload called\n&quot;;
}

// this overload is added to the set of overloads if
// C is a reference-to-class type and F is a member function pointer
template&lt;class C, class F&gt;
auto test(C c, F f) -&gt; decltype((void)(c.*f)(), void())
{
    std::cout &lt;&lt; &quot;Reference overload called\n&quot;;
}

// this overload is added to the set of overloads if
// C is a pointer-to-class type and F is a member function pointer
template&lt;class C, class F&gt;
auto test(C c, F f) -&gt; decltype((void)((c-&gt;*f)()), void())
{
    std::cout &lt;&lt; &quot;Pointer overload called\n&quot;;
}

struct X { void f() {} };

int main(){
  X x;
  test( x, &amp;X::f);
  test(&amp;x, &amp;X::f);
  test(42, 1337);
}
|output=
Reference overload called
Pointer overload called
Catch-all overload called
}}</text>
      <sha1>6jj9y3z2rw67mge86qa9kfie52ni5sg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/sizeof</title>
    <ns>0</ns>
    <id>711</id>
    <revision>
      <id>72180</id>
      <parentid>71511</parentid>
      <timestamp>2014-07-21T13:42:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link object representation</comment>
      <text xml:space="preserve" bytes="2346">{{title|sizeof operator}}
{{cpp/language/expressions/navbar}}
Queries size of the object or type

Used when actual size of the object must be known

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|sizeof(}} {{spar|type}} {{ttb|)}}}}
{{sdsc | {{ttb|sizeof}} {{spar|expression}} {{ttb|}}}}
{{sdsc end}}

Both versions return a constant of type {{lc|std::size_t}}. 

===Explanation===

1) returns size in bytes of the {{rlp|object|object representation}} of {{spar|type}}.

2) returns size in bytes of the object representation of the type, that would be returned by {{spar|expression}}, if evaluated.

===Notes===
Depending on the computer architecture, a [[enwiki:Byte|byte]] may consist of 8 ''or more'' bits, the exact number being recorded in {{lc|CHAR_BIT}}.

{{c|sizeof(char)}}, {{c|sizeof(signed char)}}, and {{c|sizeof(unsigned char)}} always return {{c|1}}.

sizeof cannot be used with function types, incomplete types, or bit-field glvalues.

When applied to a reference type, the result is the size of the referenced type.

When applied to a class type, the result is the size of an object of that class plus any additional padding required to place such object in an array.

When applied to an empty class type, always returns 1.

===Keywords===

{{ltt|cpp/keyword/sizeof}}

===Example===
{{example
 | The example output corresponds to a system with 64-bit pointers and 32-bit int.
 | code=
#include &lt;iostream&gt;
struct Empty {};
struct Bit {unsigned bit:1; };
int main()
{
    Empty e;
    Bit b;
    std::cout &lt;&lt; &quot;size of empty class: &quot;     &lt;&lt; sizeof e        &lt;&lt; '\n'
              &lt;&lt; &quot;size of pointer : &quot;        &lt;&lt; sizeof &amp;e       &lt;&lt; '\n'
//            &lt;&lt; &quot;size of function: &quot;        &lt;&lt; sizeof(void())  &lt;&lt; '\n'  // compile error
//            &lt;&lt; &quot;size of incomplete type: &quot; &lt;&lt; sizeof(int[])   &lt;&lt; '\n'  // compile error
//            &lt;&lt; &quot;size of bit field: &quot;       &lt;&lt; sizeof b.bit    &lt;&lt; '\n'  // compile error
              &lt;&lt; &quot;size of array of 10 int: &quot; &lt;&lt; sizeof(int[10]) &lt;&lt; '\n';
}
 | output=
size of empty class: 1
size of pointer : 8
size of array of 10 int: 40
}}

===See also===
* {{rlp|alignof}}
* {{rlp|sizeof...}}

[[de:cpp/language/sizeof]]
[[es:cpp/language/sizeof]]
[[fr:cpp/language/sizeof]]
[[it:cpp/language/sizeof]]
[[ja:cpp/language/sizeof]]
[[pt:cpp/language/sizeof]]
[[ru:cpp/language/sizeof]]
[[zh:cpp/language/sizeof]]</text>
      <sha1>k0qyjq01lrou5vof785u4h1rv6cyiug</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/sizeof...</title>
    <ns>0</ns>
    <id>2428</id>
    <revision>
      <id>69620</id>
      <parentid>66857</parentid>
      <timestamp>2014-04-15T17:10:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="1028">{{title|sizeof... operator}}
{{cpp/language/templates/navbar}}
Queries the number of elements in a [[cpp/language/parameter_pack|parameter pack]].

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|sizeof...(}} {{spar|parameter_pack}} {{ttb|)}} | notes={{mark since c++11}}}}
{{sdsc end}}

Returns an object of type {{lc|std::size_t}}.

===Explanation===

Returns the number of elements in a [[cpp/language/parameter_pack|parameter pack]].

===Keywords===

{{ltt|cpp/keyword/sizeof}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

template&lt;class... Args&gt;
std::size_t f()
{
    return sizeof...(Args);
}

int main()
{
    std::cout &lt;&lt; f&lt;&gt;() &lt;&lt; '\n'
              &lt;&lt; f&lt;int&gt;() &lt;&lt; '\n'
              &lt;&lt; f&lt;char, int, double&gt;() &lt;&lt; '\n';
}
 | output=
0
1
3
}}

===See also===
* {{rlp|sizeof}}

[[de:cpp/language/sizeof...]]
[[es:cpp/language/sizeof...]]
[[fr:cpp/language/sizeof...]]
[[it:cpp/language/sizeof...]]
[[ja:cpp/language/sizeof...]]
[[pt:cpp/language/sizeof...]]
[[ru:cpp/language/sizeof...]]
[[zh:cpp/language/sizeof...]]</text>
      <sha1>i1x0zwkzvo790gp7e4cnwjbnyxhmwgs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/statements</title>
    <ns>0</ns>
    <id>9895</id>
    <revision>
      <id>71581</id>
      <parentid>63691</parentid>
      <timestamp>2014-06-14T04:06:11Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>syntax</comment>
      <text xml:space="preserve" bytes="6597">{{title|Statements}}
{{cpp/language/statements/navbar}}
Statements are fragments of the C++ program that are executed in sequence. The body of any function is a sequence of statements. For example:

{{source|1=
int main()
{
    int n = 1; // declaration statement
    n = n+1; // expression statement
    std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n'; // expression statement
    return 0; // return statement
}  
}}


There are seven types of statements:

@1@ expression statement
@2@ compound statement
@3@ selection statement
@4@ iteration statement
@5@ jump statement
@6@ declaration statement
@7@ try block

===Labels===
Any statement can be ''labeled'', by providing a label followed by a colon before the statement itself:

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{spar|identifier}} {{ttb|:}} {{spar|statement}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{ttb|case}} {{spar|constexpr}} {{ttb|:}} {{spar|statement}}
}}
{{sdsc|num=3|1=
{{spar|attr}}{{mark optional}} {{ttb|default}} {{ttb|:}} {{spar|statement}}
}}
{{sdsc end}}
@1@ Target for {{rlp|goto}}.
@2@ Case label in a {{rlp|switch}} statement.
@3@ Default label in a {{rlp|switch}} statement.

An [[cpp/language/attributes|attribute]] sequence {{spar|attr}} may appear just before the label (in which case it applies to the label), or just before any statement itself, in which case it applies to the entire statement. A statement may carry multiple labels.

===Expression statements===
An expression followed by a semicolon is a statement.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{spar|expression}}{{mark optional}} {{ttb|;}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|expression}} | an [[cpp/language/expressions|expression]]}}
{{par end}}

Most statements in a typical C++ program are expression statements, such as assignments or function calls.

An expression statement without an expression is called a ''null statement''. It is often used to provide an empty body to a {{rlp|for}} or {{rlp|while}} loop. It can also be used to carry a label in the end of a compound statement.

===Compound statement===
A compound statement or ''block'' is a brace-enclosed sequence of statements. 

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|{}} {{spar|statement...}}{{mark optional}} {{ttb|}}}
}}
{{sdsc end}}

When one statement is expected, but multiple statements need to be executed in sequence (for example, in an {{rlp|if}} statement or a loop), a compound statement may be used:

{{source|1=
if (expr) // start of if-statement
{ // start of block
  int n =1; // declaration statement
  cout &lt;&lt; n; // expression statement
} // end of block, end of if-statement
}}

Each compound statement introduces its own block {{rlp|scope}}: variables declared inside a block are destroyed at the closing brace in reverse order.

{{source|1=
int main()
{
    { // start of block
       std::ofstream f(&quot;test.txt&quot;); // declaration statment
       f &lt;&lt; &quot;hi\n&quot;; // expression statement
    } // end of block, f is flushed and closed by ofstream's destructor
    std::ifstream f(&quot;test.txt&quot;); 
    std::string str;
    f &gt;&gt; str; 
}
}}

===Selection statements===
The selection statements choose between one of several flows of control

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|if}} {{ttb|(}} {{spar|condition}} {{ttb|)}} {{spar|statement}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{ttb|if}} {{ttb|(}} {{spar|condition}} {{ttb|)}} {{spar|statement}} {{ttb|else}} {{spar|statement}}
}}
{{sdsc|num=3|1=
{{spar|attr}}{{mark optional}} {{ttb|switch}} {{ttb|(}} {{spar|condition}} {{ttb|)}} {{spar|statement}} 
}}
{{sdsc end}}

@1@ {{rlp|if}} statement
@2@ {{rlp|if}} statement with an else clause
@3@ {{rlp|switch}} statement

===Iteration statements===
The iteration statements repeatedly execute some code.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|while}} {{ttb|(}} {{spar|condition}} {{ttb|)}} {{spar|statement}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{ttb|do}} {{spar|statement}} {{ttb|while}} {{ttb|(}} {{spar|expression}} {{ttb|)}} {{ttb|;}} 
}}
{{sdsc|num=3|1=
{{spar|attr}}{{mark optional}} {{ttb|for}} {{ttb|(}} {{spar|for-init-statement}} {{spar|condition}}{{mark optional}} {{ttb|;}} {{spar|expression}}{{mark optional}} {{ttb|)}} {{spar|statement}}
}}
{{sdsc|num=4|notes={{mark since c++11}}|1=
{{spar|attr}}{{mark optional}} {{ttb|for}} {{ttb|(}} {{spar|for-range-decl}} {{ttb|:}} {{spar|for-range-init}} {{ttb|)}} {{spar|statement}}
}}
{{sdsc end}}

@1@ {{rlp|while}} loop
@2@ {{rlp|do|do-while}} loop
@3@ {{rlp|for|for}} loop
@4@ {{rlp|range-for|range for}} loop

===Jump statements===
The jump statements unconditionally transfer flow control

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|break}} {{ttb|;}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{ttb|continue}} {{ttb|;}}
}}
{{sdsc|num=3|1=
{{spar|attr}}{{mark optional}} {{ttb|return}} {{spar|expression}}{{mark optional}} {{ttb|;}}
}}
{{sdsc|num=4|notes={{mark since c++11}}|1=
{{spar|attr}}{{mark optional}} {{ttb|return}} {{spar|braced-init-list}} {{ttb|;}}
}}
{{sdsc|num=5|1=
{{spar|attr}}{{mark optional}} {{ttb|goto}} {{spar|identifier}} {{ttb|;}}
}}
{{sdsc end}}

@1@ {{rlp|break}} statement
@2@ {{rlp|continue}} statement
@3@ {{rlp|return}} statement with an optional expression
@4@ {{rlp|return}} statement using [[cpp/language/list_initialization|list initialization]]
@5@ {{rlp|goto}} statement

Note: for all jump statements, transfer out of a loop, out of a block, or back past an initialized variable with automatic storage duration involves the destruction of objects with automatic storage duration that are in scope at the point transferred from but not at the point transferred to. If multiple objects were initialized, the order of destruction is the opposite of the order of initialization.

===Declaration statement===
Declaration statements introduce one or more identifiers into a block.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|block-declaration}} {{ttb|;}}
}}
{{sdsc end}}
@1@ See [[cpp/language/declarations|Declarations]] and [[cpp/language/initialization|Initialization]] for details.

===Try block===
The try block statement provides the ability to catch exceptions thrown when executing other statements.

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|try}} {{spar|compound-statement}} {{spar|handler-sequence}}
}}
{{sdsc end}}
@1@ See {{rlp|try_catch|try/catch}} for details.</text>
      <sha1>pullxry6mzcnwiilzwcc6f61qe8ndb0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/static</title>
    <ns>0</ns>
    <id>5288</id>
    <revision>
      <id>72376</id>
      <parentid>71897</parentid>
      <timestamp>2014-08-17T15:34:54Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>mention constant static members need a definition whenever they are odr-used; also add some links</comment>
      <text xml:space="preserve" bytes="5038">{{title|static specifier}}
{{cpp/language/classes/navbar}}

Inside a class, declares members not bound to specific instances.

===Syntax===
{{sdsc begin}}
{{sdsc | num=1 | {{c|static}} {{spar|data_member}} }}
{{sdsc | num=2 | {{c|static}} {{spar|member_function}} }}
{{sdsc end}}

@1@ Declares a static data member
@2@ Declares a static member function.

===Explanation===
Static members of a class are not associated with the objects of the class: they are independent objects with [[cpp/language/storage_duration|static storage duration]] or regular functions defined in namespace scope, only once in the program.

The {{c|static}} keyword is only used with the declaration of a static member, inside the class definition, but not with the definition:

{{source|1=
class X {
    static int n; // declaration (uses 'static')
};
int X::n = 1; // definition (does not use 'static')
}}

The declaration inside the class body is not a definition and may declare the member to be of {{rlp|incomplete type}} (other than {{c|void}}), including the type in which the member is declared.

{{source|
struct Foo;
struct S {
   static int a[]; // incomplete type
   static Foo x; // incomplete type
   static S s; // incomplete type (inside its own definition)
};

int S::a[10]; // definition, complete type
struct Foo {};
Foo S::x; // definition, complete type
S S::s; // definition, complete type
}}

To refer to a static member {{tt|n}} of class {{tt|T}}, two forms may be used: qualified name {{tt|T::m}} or member access expression {{tt|e.m}} or {{tt|e-&gt;m}}, where {{tt|e}} is an expression that evaluates to {{tt|T}} or {{tt|T*}} respectively. When in the same class scope, the qualification is unnecessary:

{{source|1=
struct X {
    static void f(); // function declaration
    static int n; // member declaration
};

X g() { return X(); } // some function returning X

void f() {
    X::f();  // qualified name access to static function
    g().f(); // expression member access to static function
}

int X::n = 7; // definition

void X::f() { // definiton
    n = 1; // X::n is accessible as just n in this scope.
}
}}

Static members obey the {{rlp|access|class member access rules (private, protected, public)}}.

====Static member functions====
Static member functions are not associated with any object. When called, they have no {{c|this}} pointer. They cannot be {{c|virtual}}, {{c|const}}, or {{c|volatile}}. They cannot access non-static data members of the class. Address of a static member function may be stored in a regular {{rlp|pointer#Pointers to functions|pointer to function}}, but not in a {{rlp|pointer#Pointers to member functions|pointer to member function}}.

====Static data members====
The static member objects are not part of the object. If the static member is declared thread_local{{mark since c++11}}, there is one such object per thread. Otherwise, there is only one instance of the static member object in the entire program, with static {{rlp|storage duration}}. The static members exist even if no objects of the class have been defined.

Static data members cannot be {{c|mutable}}.

Static data members of a class in namespace scope have {{rlp|storage duration|external linkage}} if the class itself has external linkage (i.e. it's not a member of {{rlp|namespace#Unnamed_namespaces|unnamed namespace}})

Local classes (classes defined inside functions) and unnamed classes, including member classes of unnamed classes, cannot have static data members.

====Constant static members====
If a static data member of integral or enumeration type is declared {{c|const}} (and not {{c|volatile}}), it can be initialized with a {{rlp|data_members#Member initialization|brace-or-equal initializer}} that is a {{rlp|constexpr|constant expression}}, right inside the class definition:

{{source|1=
struct X {
    const static int n = 1;
    const static int m{2}; // since C++11
};
}}

{{rev begin}}
{{rev|since=c++11|
If a static data member of {{concept|LiteralType}} is declared {{c|constexpr}}, it can be initialized with a brace-or-equal initializer that is a constant expression inside the class definition:

{{source|1=
struct X {
    constexpr static int n = 1;
};
}}
}}
{{rev end}}
If such a member is {{rlp|definition#ODR-use|odr-used}}, a definition at namespace scope is still required, but it should not have an initializer.
{{source|1=
struct X {
    const static int n = 1;
};
const int* p = &amp;X::n; // X::n is odr-used
const int X::n;       // ... so a definition is necessary
}}

===References===
{{ref std c++11}}
{{ref std | section=9.4 | title=Static members | id=class.static}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=9.4 | title=Static members | id=class.static}}
{{ref std end}}

===See also===
* [[cpp/language/storage_duration|{{c|static}} storage specifier]]

[[de:cpp/language/static]]
[[es:cpp/language/static]]
[[fr:cpp/language/static]]
[[it:cpp/language/static]]
[[ja:cpp/language/static]]
[[pt:cpp/language/static]]
[[ru:cpp/language/static]]
[[zh:cpp/language/static]]</text>
      <sha1>njf9vtzgwsicuj9it5cdtn28t4myhsk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/static assert</title>
    <ns>0</ns>
    <id>6480</id>
    <revision>
      <id>69387</id>
      <parentid>69385</parentid>
      <timestamp>2014-04-04T15:00:49Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2505">{{title|Static Assertion}}
{{cpp/language/declarations/navbar}}
Performs compile-time assertion checking
===Syntax===
{{sdsc begin}}
{{sdsc|notes={{mark since c++11}}|{{ttb|static_assert}} {{ttb|(}} {{spar|bool_constexpr}} {{ttb|,}} {{spar|message}} {{ttb|)}} }} 
{{sdsc end}}
===Explanation===
{{par begin}}
{{par | {{spar|bool_constexpr}} | a constant expression that is contextually convertible to bool}}
{{par | {{spar|message}} | string literal that will appear as compiler error if {{spar|bool_constexpr}} is false}}
{{par end}}

A static assert declaration may appear at block scope (as a {{rlp|declarations|block declaration}}) and inside a class body (as a {{rlp|class|member declaration}})

===Note===
Since {{spar|message}} has to be a string literal, it cannot contain dynamic information or even a {{rlp|constant expression}} that is not a string literal itself. Typically, it cannot contain the {{rlp|name}} of the {{rlp|template parameters|template type argument}}.

===Example===
{{example|code=
#include &lt;type_traits&gt;

template &lt;class T&gt;
void swap( T&amp; a, T&amp; b)
{
    static_assert(std::is_copy_constructible&lt;T&gt;::value,
                  &quot;Swap requires copying&quot;);
    static_assert(noexcept(std::is_nothrow_move_constructible&lt;T&gt;::value
                        &amp;&amp; std::is_nothrow_move_assignable&lt;T&gt;::value),
                  &quot;Swap may throw&quot;);
    auto c {{=}} b;
    b {{=}} a;
    a {{=}} c;
}

template &lt;class T&gt;
struct data_structure
{
    static_assert(std::is_default_constructible&lt;T&gt;::value,
                  &quot;Data Structure requires default-constructible elements&quot;);
};

struct no_copy
{
    no_copy ( const no_copy&amp; ) {{=}} delete;
    no_copy () {{=}} default;
};

struct no_default
{
    no_default () {{=}} delete;
};

int main()
{
    int a, b;
    swap(a, b);

    no_copy nc_a, nc_b;
    swap(nc_a, nc_b); // 1

    data_structure&lt;int&gt; ds_ok;
    data_structure&lt;no_default&gt; ds_error; // 2
}
|output=
1: error: static assertion failed: Swap requires copying
2: error: static assertion failed: Data Structure requires 
                                   default-constructible elements
|p=true
}}
===See also===
* [[cpp/error/assert|assert]]
* [[cpp/types#Type_traits_.28since_C.2B.2B11.29|type traits]]

[[de:cpp/language/static assert]]
[[es:cpp/language/static assert]]
[[fr:cpp/language/static assert]]
[[it:cpp/language/static assert]]
[[ja:cpp/language/static assert]]
[[pt:cpp/language/static assert]]
[[ru:cpp/language/static assert]]
[[zh:cpp/language/static assert]]</text>
      <sha1>1szww8jpg6ss70qtjpopcyp9tkepyly</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/static cast</title>
    <ns>0</ns>
    <id>2740</id>
    <revision>
      <id>71508</id>
      <parentid>71506</parentid>
      <timestamp>2014-06-12T04:00:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>expand on casts to rvalue refs, including cwg 1447</comment>
      <text xml:space="preserve" bytes="6185">{{title|static_cast conversion}}
{{cpp/language/expressions/navbar}}
Converts between types using a combination of implicit and user-defined conversions.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|static_cast &amp;lt;}} {{spar|new_type}} {{ttb|&amp;gt; (}} {{spar|expression}} {{ttb|)}} }}
{{sdsc end}}

Returns a value of type {{tt|new_type}}.

===Explanation===

Only the following conversions can be done with {{c|static_cast}}, except when such conversions would cast away ''constness'' or ''volatility''.

@1@ If a temporary object of type {{spar|new_type}} can be declared and initialized with {{spar|expression}}, as by {{c|new_type Temp(expression);}}, which may involve implicit conversions, a call to the constructor of {{spar|new_type}} or a call to a user-defined conversion operator, then {{c|static_cast&lt;type&gt;(expression)}} computes and returns the value of that temporary object.
@2@ If {{spar|new_type}} is a pointer or reference to some class {{tt|D}} and the type of {{spar|expression}} is a pointer or reference to its non-virtual base {{tt|B}}, {{tt|static_cast}} performs a ''downcast''. Such {{tt|static_cast}} makes no runtime checks to ensure that the object's runtime type is actually {{tt|D}}, and may only be used safely if this precondition is guaranteed by other means, such as when implementing [[enwiki:Curiously recurring template pattern#Static polymorphism|static polymorphism]]. Safe downcast may be done with {{c|dynamic_cast}}.
@3@ If {{spar|new_type}} is an rvalue reference type, {{tt|static_cast}} converts the value of {{spar|expression}} to ''xvalue'' referring to the same object as the expression, or to its base sub-object (depending on {{spar|new_type}}. If the target type is an inaccessible or ambiguous base of the type of the expression, the program is ill-formed. If the expression is a {{rlp|bit field}} lvalue, it is first converted to prvalue of the underlying type. This type of {{tt|static_cast}} is used to implement move semantics in {{lc|std::move}}. {{mark since c++11}}
@4@ If {{spar|new_type}} is the type {{c|void}} (possibly cv-qualified), {{tt|static_cast}} discards the value of {{spar|expression}} after evaluating it.
@5@ If an {{rlp|implicit_cast |implicit conversion}} sequence from {{spar|new_type}} to the type of {{spar|expression}} exists, that does not include lvalue-to-rvalue, array-to-pointer, function-to-pointer, null pointer, null member pointer, or boolean conversion, then {{tt|static_cast}} can perform the inverse of that implicit conversion.
@6@ If conversion of {{spar|expression}} to {{spar|new_type}} involves lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion, it can be performed explicitly by {{tt|static_cast}}.
@7@ Scoped enumeration type can be converted to an integer or floating-point type. When the target type is ''cv'' {{c|bool}}, the result is {{c|false}} if the original value is zero and {{c|true}} for all other values. For the remaining integral types, the result is the value of the enum if it can be represented by the target type and unspecified otherwise. {{mark since c++11}}
@8@ Integer, floating-point, or enumeration type can be converted to any enumeration type (the result is unspecified if the value of {{spar|expression}}, converted to the enumeration's underlying type, is not one of the target enumeration values)
@9@ A pointer to member of some class {{tt|D}} can be upcast to a pointer to member of its base class {{tt|B}}. This {{tt|static_cast}} makes no checks to ensure the member actually exists in the runtime type of the pointed-to object.
@10@ A prvalue of type pointer to {{c|void}} (possibly cv-qualified) can be converted to pointer to any type. If the value of the original pointer satisfies the alignment requirement of the target type, then the resulting pointer value is unchanged, otherwise it is unspecified. Conversion of any pointer to pointer to void and back to pointer to the original (or more cv-qualified) type preserves its original value.

{{cpp/language/cast_return}}

===Notes===
{{c|static_cast}} may also be used to disambiguate function overloads by performing a function-to-pointer conversion to specific type, as in {{c|std::transform(s.begin(), s.end(), s.begin(), static_cast&lt;int(*)(int)&gt;(std::toupper));}}

===Keywords===
{{ltt|cpp/keyword/static_cast}}

===Example===
{{example
 |
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;

struct B {};
struct D : B {};

enum class E { ONE, TWO, THREE };
enum EU { ONE, TWO, THREE };

int main()
{
    // 1: initializing conversion
    int n = static_cast&lt;int&gt;(3.14); 
    std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n';
    std::vector&lt;int&gt; v = static_cast&lt;std::vector&lt;int&gt;&gt;(10);
    std::cout &lt;&lt; &quot;v.size() = &quot; &lt;&lt; v.size() &lt;&lt; '\n';

    // 2: static downcast
    D d;
    B&amp; br = d; // upcast via implicit conversion
    D&amp; another_d = static_cast&lt;D&amp;&gt;(br); // downcast

    // 3: lvalue to xvalue
    std::vector&lt;int&gt; v2 = static_cast&lt;std::vector&lt;int&gt;&amp;&amp;&gt;(v);
    std::cout &lt;&lt; &quot;after move, v.size() = &quot; &lt;&lt; v.size() &lt;&lt; '\n';

    // 4: discarded-value expression
    static_cast&lt;void&gt;(v2.size());

    // 5. inverse of implicit conversion
    // todo
    
    // 6. array-to-pointer followed by upcast
    D a[10];
    B* dp = static_cast&lt;B*&gt;(a);

    // 7. scoped enum to int or float
    E e = E::ONE;
    int one = static_cast&lt;int&gt;(e);

    // 8. int to enum, enum to another enum
    E e2 = static_cast&lt;E&gt;(one);
    EU eu = static_cast&lt;EU&gt;(e2);

    // 9. pointer to member upcast
    // todo
   
    // 10. void* to any type
    void* voidp = &amp;e;
    std::vector&lt;int&gt;* p = static_cast&lt;std::vector&lt;int&gt;*&gt;(voidp);
}
 | output=
n = 3
v.size() = 10
after move, v.size() = 0
}}

===See also===
* [[cpp/language/const_cast|const_cast]]
* [[cpp/language/dynamic_cast|dynamic_cast]]
* [[cpp/language/reinterpret_cast|reinterpret_cast]]
* [[cpp/language/explicit_cast|explicit cast]]
* [[cpp/language/implicit_cast|implicit conversions]]

[[de:cpp/language/static cast]]
[[es:cpp/language/static cast]]
[[fr:cpp/language/static cast]]
[[it:cpp/language/static cast]]
[[ja:cpp/language/static cast]]
[[pt:cpp/language/static cast]]
[[ru:cpp/language/static cast]]
[[zh:cpp/language/static cast]]</text>
      <sha1>5l08cx9pmwjbpq3b56h3iq5y8w8rhzt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/storage duration</title>
    <ns>0</ns>
    <id>712</id>
    <revision>
      <id>71898</id>
      <parentid>71895</parentid>
      <timestamp>2014-07-01T10:03:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 71895 by [[Special:Contributions/Lingxi|Lingxi]] ([[User talk:Lingxi|talk]]) it's in terms of scopes (3.5[basic.link]/2)</comment>
      <text xml:space="preserve" bytes="10202">{{title|Storage class specifiers}}
{{cpp/language/declarations/navbar}}

The storage class specifiers are a part of the {{spar|decl-specifier-seq}} of a {{rlp|declarations|declaration syntax}}. They control two independent properties of the names introduced by the declaration: their ''storage duration'' and their ''linkage''. 

{{rev begin}}
{{rev | until=c++11 |
:*{{ttb|auto}} - ''automatic'' storage duration.
}}
{{rev end}}
:*{{ttb|register}} - ''automatic'' storage duration. Also hints to the compiler to place the variable in the processor's register. {{mark deprecated}}
:*{{ttb|static}} - ''static'' or ''thread'' storage duration and ''internal'' linkage
:*{{ttb|extern}} - ''static'' or ''thread'' storage duration and ''external'' linkage
{{rev begin}}
{{rev | since=c++11 |
:*{{ttb|thread_local}} - ''thread'' storage duration.
}}
{{rev end}}


Only one storage class specifier may appear in a declaration (except that {{tt|thread_local}} may be combined with {{tt|static}} or with {{tt|extern}})

===Explanation===
{{rev begin}}
{{rev | until=c++11 |
@1@ The {{tt|auto}} specifier was only allowed for variables declared at block scope or in function parameter lists. It indicated automatic storage duration, which is the default for these kinds of declarations. The meaning of this keyword was changed in C++11.
}}
{{rev end}}
@2@ {{mark deprecated}} The {{tt|register}} specifier is only allowed for variables declared at block scope and in function parameter lists. It indicates automatic storage duration, which is the default for these kinds of declarations. Additionally, the presence of this keyword may be used as a hint for the optimizer to store the value of this variable in a CPU register. This keyword was deprecated in C++11.
@3@ The {{tt|static}} specifier is only allowed in the declarations of variables (except in function parameter lists), declarations of functions (except at block scope), and declarations of anonymous unions. When used in a declaration of a class member, it declares a {{rlp|static|static member}}. When used in a declaration of a variable, it specifies static storage duration (except if accompanied by {{tt|thread_local}}). When used in a declaration at namespace scope, it specifies internal linkage.
@4@ The {{tt|extern}} specifier is only allowed in the declarations of variables and functions (except class members or function parameters). It specifies external linkage, and does not technically affect storage duration, but it cannot be used in a definition of an automatic storage duration variable, so all {{tt|extern}} variables have static or thread durations

{{rev begin}}
{{rev | since=c++11 |
@5@ The {{tt|thread_local}} keyword is only allowed for variables declared at namespace scope, variables declared at block scope, and static data members. It indicates that the variable has thread storage duration. It can be combined with {{tt|static}} or {{tt|extern}} to specify internal or external linkage (except for static data members which always have external linkage), respectively, but that additional {{tt|static}} doesn't affect the storage duration.
}}
{{rev end}}

====Storage duration====

All variables in a program have one of the following storage durations:

:*'''''automatic''''' storage duration. The variable is allocated at the beginning of the enclosing code block and deallocated on end. All non-global variables have this storage duration, except those declared {{tt|static}}, {{tt|extern}} or {{tt|thread_local}}.

:*'''''static''''' storage duration. The storage for the variable is allocated when the program begins and deallocated when the program ends. Only one instance of the variable exists. All variables declared at namespace scope (including global namespace) have this storage duration, plus those declared with {{tt|static}} or {{tt|extern}}.

{{rev begin}}
{{rev | since=c++11 |
:*'''''thread''''' storage duration. The variable is allocated when the thread begins and deallocated when the thread ends. Each thread has its own instance of the variable. Only variables declared {{tt|thread_local}} have this storage duration.  {{tt|thread_local}} can appear together with {{tt|static}} or {{tt|extern}} to adjust linkage.
}}
{{rev end}}

:*'''''dynamic''''' storage duration. The variable is allocated and deallocated per request by using [[cpp/memory|dynamic memory allocation]] functions.

====Linkage====

A name that denotes object, reference, function, type, template, namespace, or value, may have ''linkage''. If a name has linkage, it refers to the same entity as the same name introduced by a declaration in another scope. If a variable, function, or another entity with the same name is declared in several scopes, but does not have sufficient linkage, then several instances of the entity are generated.

The following linkages are recognized:

:*'''''no linkage'''''. The name can be referred to only from the scope it is in.
:: Any of the following names declared at block scope have no linkage:
::* Variables that aren't explicitly declared {{tt|extern}} (regardless of the {{tt|static}} modifier)
::* {{rlp|class#Local_classes|Local classes}} and their member functions
::* Other names declared at block scope such as typedefs, enumerations, and enumerators

:*'''''internal linkage'''''. The name can be referred to from all scopes in the current translation unit.
:: Any of the following names declared at namespace scope have internal linkage
::* variables, functions, or function templates declared {{tt|static}}
::* variables declared {{tt|const}} or {{tt|constexpr}} but not {{tt|extern}}
::* data members of {{rlp|union|anonymous unions}}
:: In addition, all names declared in {{rlp|namespace|unnamed namespace}} or a namespace within an unnamed namespace, that aren't explicitly declared {{tt|extern}}, have internal linkage.

:*'''''external linkage'''''. The variable can be referred to from the scopes in the other translation units. Variables and functions with external linkage also have {{rlp|language_linkage|language linkage}}, which makes it possible to link translation units written in different programming languages.
:: Any of the following names declared at namespace scope have external linkage
::* variables and functions, not listed above (that is, not declared {{tt|static}}, and declared {{tt|const}} but not {{tt|extern}})
::* enumerations and enumerators
::* names of classes, their member functions, static data members (const or not), nested classes and enumerations, and functions first introduced with {{rlp|friend}} declarations inside class bodies
::* names of all templates not listed above (that is, not function templates declared {{tt|static}})
:: Any of the following names first declared at block scope have external linkage
::* names of variables declared {{tt|extern}}
::* names of functions

===Static local variables===
Static variables declared at block scope are initialized the first time control passes through their declaration (unless their initialization is {{rlp|zero_initialization|zero-}} or {{rlp|constant_initialization|constant-initialization}}, which can be performed before the block is first entered). On all further calls, the declaration is skipped.

If the initialization {{rlp|throw|throws an exception}}, the variable is not considered to be initialized, and initialization will be attempted again the next time control passes through the declaration.

If the initialization recursively enters the block in which the variable is being initialized, the behavior is undefined.

{{rev begin}}
{{rev |since=c++11|
If multiple threads attempt to initialize the same static local variable concurrently, the initialization occurs exactly once (similar behavior can be obtained for arbitrary functions with {{lc|std::call_once}})}}
{{rev end}}

The destructor for a block-scope static variable [[cpp/utility/program/exit|is called at program exit]], but only if the initialization took place successfully.
===Notes===
Names at the top-level namespace scope (file scope in C) that are {{tt|const}} and not {{tt|extern}} have external linkage in C, but internal linkage in C++.

In C, the address of a {{tt|register}} variable cannot be taken, but in C++, a variable declared {{tt|register}} is semantically indistinguishable from a variable declared without any storage class specifiers.

Names of {{tt|thread_local}} variables with internal or external linkage referred from different scopes may refer to the same or to different instances depending on whether the code is executing in the same or in different threads.

The {{tt|extern}} keyword can also be used to specify {{rlp|language_linkage|language linkage}} and {{rlp|class_template|explicit template instantiation declarations}}, but it's not a storage class specifier in those cases.

{{rlp|cv|The keyword {{tt|mutable}}}} is a storage class specifier in the C++ language grammar, although it doesn't affect storage duration or linkage.

{{todo|the rules about re-declaring names in the same TU}}

===Keywords===

{{ltt|cpp/keyword/auto}},
{{ltt|cpp/keyword/register}},
{{ltt|cpp/keyword/static}},
{{ltt|cpp/keyword/extern}},
{{ltt|cpp/keyword/thread_local}}

===Example===

{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;

thread_local unsigned int rage = 1; 
std::mutex cout_mutex;

void increase_rage(const std::string&amp; thread_name)
{
    ++rage;
    std::lock_guard&lt;std::mutex&gt; lock(cout_mutex);
    std::cout &lt;&lt; &quot;Rage counter for &quot; &lt;&lt; thread_name &lt;&lt; &quot;: &quot; &lt;&lt; rage &lt;&lt; '\n';
}

int main()
{
    std::thread a(increase_rage, &quot;a&quot;), b(increase_rage, &quot;b&quot;);

    {
        std::lock_guard&lt;std::mutex&gt; lock(cout_mutex);
        std::cout &lt;&lt; &quot;Rage counter for main: &quot; &lt;&lt; rage &lt;&lt; '\n';
    }

    a.join();
    b.join();

    return 0;
}
 | output=
Rage counter for a: 2
Rage counter for main: 1
Rage counter for b: 2
}}

[[de:cpp/language/storage duration]]
[[es:cpp/language/storage duration]]
[[fr:cpp/language/storage duration]]
[[it:cpp/language/storage duration]]
[[ja:cpp/language/storage duration]]
[[pt:cpp/language/storage duration]]
[[ru:cpp/language/storage duration]]
[[zh:cpp/language/storage duration]]</text>
      <sha1>9yes8b8if102mmcjii5ziqau9g8c61z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/string literal</title>
    <ns>0</ns>
    <id>5078</id>
    <revision>
      <id>66842</id>
      <parentid>66654</parentid>
      <timestamp>2014-01-03T15:05:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="4811">{{title|string literal}}
{{cpp/language/expressions/navbar}}
===Syntax===
{{sdsc begin}}
{{sdsc | num = 1| {{ttb|&quot;}} ({{spar|unescaped_character}}{{!}}{{spar|escaped_character}})* {{ttb|&quot;}} }}
{{sdsc | num = 2| {{ttb|L}} {{ttb|&quot;}} ({{spar|unescaped_character}}{{!}}{{spar|escaped_character}})* {{ttb|&quot;}} }}
{{sdsc | num = 3| {{ttb|u8}} {{ttb|&quot;}} ({{spar|unescaped_character}}{{!}}{{spar|escaped_character}})* {{ttb|&quot;}} | notes={{mark since c++11}} }}
{{sdsc | num = 4| {{ttb|u}} {{ttb|&quot;}} ({{spar|unescaped_character}}{{!}}{{spar|escaped_character}})* {{ttb|&quot;}} | notes={{mark since c++11}} }}
{{sdsc | num = 5| {{ttb|U}} {{ttb|&quot;}} ({{spar|unescaped_character}}{{!}}{{spar|escaped_character}})* {{ttb|&quot;}} | notes={{mark since c++11}} }}
{{sdsc | num = 6| notes={{mark since c++11}} |
{{spar|prefix}}{{mark optional}} {{ttb|R}} {{ttb|&quot;}}{{spar|delimiter}}{{ttb|(}} {{spar|raw_character}}* {{ttb|)}}{{spar|delimiter}}{{ttb|&quot;}} }}
{{sdsc end}}
===Explanation===
{{par begin}}
{{par | unescaped_character | Any valid character}}
{{par | escaped_character | See [[cpp/language/escape|escape sequences]] }}
{{par | prefix |One of {{ttb|L}}, {{ttb|u8}}, {{ttb|u}}, {{ttb|U}} }}
{{par | delimiter | A string made of any source character but parentheses, backslash and [[cpp/string/byte/isspace|spaces]] (can be empty) }}
{{par | raw_character | Must not contain the closing sequence {{ttb|)}}{{spar|delimiter}}{{ttb|&quot;}} }}
{{par end}}


@1@ Narrow multibyte string literal. The type of an unprefixed string literal is {{c|const char[]}}
@2@ Wide string literal. The type of a {{c|L&quot;...&quot;}} string literal is {{c|const wchar_t[]}}
@3@ UTF-8 encoded string literal. The type of a {{c|u8&quot;...&quot;}} string literal is {{c|const char[]}}
@4@ UTF-16 encoded string literal. The type of a {{c|u&quot;...&quot;}} string literal is {{c|const char16_t[]}}
@5@ UTF-32 encoded string literal. The type of a {{c|U&quot;...&quot;}} string literal is {{c|const char32_t[]}}
@6@ Raw string literal. Used to avoid escaping of any character, anything between the delimiters becomes part of the string, if {{spar|prefix}} is present has the same meaning as described above.

===Notes===
* The null character ({{c|'\0'}}, {{c|L'\0'}}, {{c|char16_t()}}, etc) is always appended to the string literal: thus, a string literal {{c|&quot;Hello&quot;}} is a {{c|const char[6]}} holding the characters {{c|'H'}}, {{c|'e'}}, {{c|'l'}}, {{c|'l'}}, {{c|'o'}}, and {{c|'\0'}}.
* String literals placed side-by-side are concatenated at [[cpp/language/translation_phases|translation phase 6]] (after the preprocessor).  That is, {{c|&quot;Hello,&quot;  &quot; world!&quot;}} yields the (single) string {{c|&quot;Hello, world!&quot;}}.
** If the two strings have the same encoding prefix (or neither has one), the resulting string will have the same encoding prefix (or no prefix).
**{{mark since c++11}} If one of the strings has an encoding prefix and the other doesn't, the one that doesn't will be considered to have the same encoding prefix as the other.
**{{mark since c++11}}  If a UTF-8 string literal and a wide string literal are side by side, the program is ill-formed.
** Any other combination of encoding prefixes may or may not be supported by the implementation. The result of such a concatenation is implementation-defined.
* String literals have static storage duration, and thus exist in memory for the life of the program.
* String literals can be used to [[cpp/language/aggregate_initialization|initialize character arrays]].  If an array is initialized like {{c|1=char str[] = &quot;foo&quot;;}}, {{c|str}} will contain a copy of the string {{c|&quot;foo&quot;}}.
* The compiler is allowed, ''but not required'', to merge string literals.  That means that identical string literals may or may not compare equal when compared by pointer.  Even whether the expression {{c|1=&quot;foo&quot; == &quot;foo&quot;}} returns true is implementation-defined.
* In C, string literals are of type {{c|char[]}}, and can be assigned directly to a (non-const) {{c|char*}}. C++03 allowed it as well (but deprecated it, as literals are {{c|const}} in C++).  C++11 no longer allows such assignments without a cast.
* Attempting to modify a string literal results in undefined behavior.

===Example===
{{example| code=
#include &lt;iostream&gt;

char array1[] = &quot;Foo&quot; &quot;bar&quot;;
// same as
char array2[] = { 'F', 'o', 'o', 'b', 'a', 'r', '\0' };

const char* s1 = R&quot;foo(
Hello
World
)foo&quot;;
//same as
const char* s2 = &quot;\nHello\nWorld\n&quot;;

int main()
{
    std::cout &lt;&lt; array1 &lt;&lt; '\n' &lt;&lt; array2 &lt;&lt; '\n';

    std::cout &lt;&lt; s1 &lt;&lt; s2;
}
| output= 
Foobar
Foobar

Hello
World

Hello
World
}}

[[de:cpp/language/string literal]]
[[es:cpp/language/string literal]]
[[fr:cpp/language/string literal]]
[[it:cpp/language/string literal]]
[[ja:cpp/language/string literal]]
[[pt:cpp/language/string literal]]
[[ru:cpp/language/string literal]]
[[zh:cpp/language/string literal]]</text>
      <sha1>smxbloxc3ml3kmkjde63lp6h2s0t7hx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/switch</title>
    <ns>0</ns>
    <id>713</id>
    <revision>
      <id>70016</id>
      <parentid>69760</parentid>
      <timestamp>2014-05-07T03:00:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>contextually implicitly convertible</comment>
      <text xml:space="preserve" bytes="5073">{{title|switch statement}}
{{cpp/language/statements/navbar}}
Transfers control to one of the several statements, depending on the value of a condition.

===Syntax===
{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|switch (}} {{spar|condition}} {{ttb|)}} {{spar|statement}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} }}
{{par | {{spar|condition}} | any {{rlp|expressions|expression}} of integral or enumeration type, or of a class type {{rlp|implicit cast|contextually implicitly convertible}} to an integral or enumeration type, or a {{rlp|declarations|declaration}} of a single non-array variable of such type with a brace-or-equals {{rlp|initialization|initializer}}.}}
{{par | {{spar|statement}} | any {{rlp|statements|statement}} (typically a compound statement). {{ttb|case:}} and {{ttb|default:}} labels are permitted in {{spar|statement}} and {{c|break;}} statement has special meaning.}}
{{par end}}

{{sdsc begin}}
{{sdsc|num=1|1=
{{spar|attr}}{{mark optional}} {{ttb|case}} {{spar|constant_expression}} {{ttb|:}} {{spar|statement}}
}}
{{sdsc|num=2|1=
{{spar|attr}}{{mark optional}} {{ttb|default}} {{ttb|:}} {{spar|statement}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|constant_expression}} | a constant expression of the same type as the type of {{spar|condition}} after conversions and {{rlp|implicit_cast|integral promotions}} }}
{{par end}}

===Explanation===
The body of a switch statement may have an arbitrary number of {{tt|case:}} labels, as long as the values of all {{spar|constant_expressions}} are unique (after conversions/promotions).

If {{spar|condition}} evaluates to the value that is equal to the value of one of {{spar|constant_expression}}s, then control is transferred to the statement that is labeled with that {{spar|constant_expression}}.

If {{spar|condition}} evaluates to the value that doesn't match any of the {{tt|case:}} labels, and the {{tt|default:}} label is present, control is transferred to the statement labeled with the {{tt|default:}} label.

The {{rlp|break}} statement, when encountered in {{spar|statement}} exits the switch statement:

{{source|switch(1) {
    case 1 : cout &lt;&lt; '1'; // prints &quot;1&quot;,
    case 2 : cout &lt;&lt; '2'; // then prints &quot;2&quot;
}
}}
{{source|switch(1) {
    case 1 : cout &lt;&lt; '1'; // prints &quot;1&quot;
             break;       // and exits the switch
    case 2 : cout &lt;&lt; '2';
             break;
}
}}

Because transfer of control is {{rlp|goto|not permitted to enter the scope}} of a variable, if a declaration statement is encountered inside the {{spar|statement}}, it has to be scoped in its own compound statement:

{{source|1=switch(1) {
    case 1: int x = 0; // initialization
            std::cout &lt;&lt; x &lt;&lt; '\n';
            break;
    default: // compilation error: jump to default: would enter the scope of 'x'
             // without initializing it
             std::cout &lt;&lt; &quot;default\n&quot;;
             break;
}
}}

{{source|1=switch(1) {
    case 1: {  int x = 0;
               std::cout &lt;&lt; x &lt;&lt; '\n';
               break;
            } // scope of 'x' ends here
    default: std::cout &lt;&lt; &quot;default\n&quot;; // no error
             break;
}
}}

===Keywords===

{{ltt|cpp/keyword/switch}},
{{ltt|cpp/keyword/case}},
{{ltt|cpp/keyword/default}}

===Example===
{{example
 | The following code shows several usage cases of the ''switch'' statement
 | code=
#include &lt;iostream&gt;

int main()
{
    int i = 2;
    switch (i) {
        case 1: std::cout &lt;&lt; &quot;1&quot;;
        case 2: std::cout &lt;&lt; &quot;2&quot;;   //execution starts at this case label
        case 3: std::cout &lt;&lt; &quot;3&quot;;
        case 4:
        case 5: std::cout &lt;&lt; &quot;45&quot;;
                break;              //execution of subsequent statements is terminated
        case 6: std::cout &lt;&lt; &quot;6&quot;;
    }
    
    std::cout &lt;&lt; '\n';
    
    switch (i) {
        case 4: std::cout &lt;&lt; &quot;a&quot;;
        default: std::cout &lt;&lt; &quot;d&quot;; //there are no applicable constant_expressions 
                                   //therefore default is executed
    }

    std::cout &lt;&lt; '\n';

    switch (i) {
        case 4: std::cout &lt;&lt; &quot;a&quot;;  //nothing is executed
    }

    // when enumerations are used in a switch statement, many compilers
    // issue warnings if one of the enumerators is not handled
    enum color {RED, GREEN, BLUE};
    switch(RED) {
        case RED:   std::cout &lt;&lt; &quot;red\n&quot;; break;
        case GREEN: std::cout &lt;&lt; &quot;green\n&quot;; break;
        case BLUE:  std::cout &lt;&lt; &quot;blue\n&quot;; break;
    }

    // pathological examples

    // the statement doesn't have to be a compound statement
    switch(0)
        std::cout &lt;&lt; &quot;this does nothing\n&quot;;

    // labels don't require a compound statement either
    switch(int n = 1)
        case 0:
        case 1: std::cout &lt;&lt; n &lt;&lt; '\n';

    // Duff's Device: http://en.wikipedia.org/wiki/Duff's_device
}
 | output=
2345
d
red
1
}}

[[de:cpp/language/switch]]
[[es:cpp/language/switch]]
[[fr:cpp/language/switch]]
[[it:cpp/language/switch]]
[[ja:cpp/language/switch]]
[[pt:cpp/language/switch]]
[[ru:cpp/language/switch]]
[[zh:cpp/language/switch]]</text>
      <sha1>p47y47ykl3fcxp8nhpy9g37xrn0p83i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/template argument deduction</title>
    <ns>0</ns>
    <id>13515</id>
    <revision>
      <id>71865</id>
      <parentid>70607</parentid>
      <timestamp>2014-06-29T17:00:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>decltype became non-deducible in C++14 (cwg 1387)</comment>
      <text xml:space="preserve" bytes="28634">{{title|Template argument deduction}}
{{cpp/language/templates/navbar}}

In order to instantiate a {{rlp|function template}}, every template argument must be known, but not every template argument has to be specified. When possible, the compiler will deduce the missing template arguments from the function arguments. This occurs when a function call is attempted and when an address of a function template is taken.

{{source|1=
template&lt;typename To, typename From&gt; To convert(From f);

void g(double d) 
{
    int i = convert&lt;int&gt;(d); // calls convert&lt;int,double&gt;(double)
    char c = convert&lt;char&gt;(d); // calls convert&lt;char,double&gt;(double)
    int(*ptr)(float) = convert; // instantiates convert&lt;int, float&gt;(float)
}
}}

This mechanism makes it possible to use template operators, since there is no syntax to specify template arguments for an operator other than by re-writing it as a function call expression.

{{source|1=
#include &lt;iostream&gt;
int main() 
{
    std::cout &lt;&lt; &quot;Hello, world&quot; &lt;&lt; std::endl;
    // operator&lt;&lt; is looked up via ADL as std::operator&lt;&lt;,
    // then deduced to operator&lt;&lt;&lt;char, std::char_traits&lt;char&gt;&gt; both times
    // std::endl is deduced to &amp;std::endl&lt;char, std::char_traits&lt;char&gt;&gt;
}
}}

Template argument deduction takes place after the function template {{rlp|lookup|name lookup}} (which may involve {{rlp|adl|argument-dependent lookup}}) and before {{rlp|function template#Template argument substitution|template argument substitution}} (which may involve {{rlp|sfinae|SFINAE}}) and {{rlp|overload_resolution|overload resolution}}.

===Deduction from a function call===
Template argument deduction attempts to determine template arguments (types for type template parameters {{ttb|T}}i, templates for template template parameters {{ttb|TT}}i, and values for non-type template parameters {{ttb|I}}i), which can be substituted into each parameter {{ttb|P}} to produce the type ''deduced A'', which is the same as the type of the argument {{ttb|A}}, after adjustments listed below.

If there are multiple parameters, each P/A pair is deduced separately and the deduced template arguments are then combined. If deduction fails or is ambiguous for any P/A pair or if different pairs yield different deduced template arguments, or if any template argument remains neither deduced nor explicitly specified, compilation fails.

If removing references and cv-qualifiers from P gives std::initializer_list&lt;P'&gt; and A is a {{rlp|list_initialization|braced-init-list}}, then deduction is performed for every element of the initializer list, taking P' as the parameter and the list element as the argument.
{{source|1=
template&lt;class T&gt; void f(std::initializer_list&lt;T&gt;);
f({1,2,3});   // P=std::initializer_list&lt;T&gt;, A={1,2,3}
              // P'1=T, A'1=1: deduces T=int
              // P'2=T, A'2=2: deduces T=int
              // P'3=T, A'3=3: deduces T=int
              // deduction succeeds, T = int
f({1,&quot;asdf&quot;}); // P=std::initializer_list&lt;T&gt;, A={1,&quot;asdf&quot;}
               // P'1=T, A'1=1: deduces T=int
               // P'2=T, A'2=&quot;asdf&quot;, deduces T=const char*
               // deduction fails, T ambiguous
}}

If a {{rlp|parameter pack}} appears as the last P, then the type P is matched against the type A of each remaining argument of the call. Each match deduces the template arguments for the next position int the pack expansion.
{{source|1=
template&lt;class ... Types&gt; void f(Types&amp; ...);
void h(int x, float&amp; y) {
   const int z = x;
   f(x, y, z); // P=Types&amp;..., A1=x: deduces the first member of Types... to int
               // P=Types&amp;..., A2=y: deduces the second member of Types... to float
               // P=Types&amp;..., A3=z: deduces the third member of Types... to const int
               // calls f&lt;int, float, const int&gt;
}}

If {{ttb|P}} is a function type, pointer to function type, or pointer to member function type and if {{ttb|A}} is a {{rlp|overloaded address|set of overloaded functions}} not containing function templates, template argument deduction is attempted with each overload. If only one succeeds, that successful deduction is used. If none or more than one succeeds, the template parameter is non-deduced context (see below).
{{source|1=
template &lt;class T&gt; int f(T (*p)(T));
int g(int);
int g(char);

f(g); // P=T(*)(T), A=overload set
      //  P=T(*)(T), A1=int(int): deduces T=int
      //  P=T(*)(T), A2=int(char): fails to deduce T
      // only one overload works, deduction succeeds
}}


Before deduction begins, the following adjustments to {{ttb|P}} and {{ttb|A}} are made:
@1@ If {{ttb|P}} is not a reference type, 
:@a@ If {{ttb|A}} is an array type, {{ttb|A}} is replaced by the pointer type obtained from array-to-pointer conversion
:@b@ Otherwise, if {{ttb|A}} is a function type, {{ttb|A}} is replaced by the pointer type obtained from function-to-pointer conversion
:@c@ Otherwise, if {{ttb|A}} is a cv-qualified type, the top-level cv-qualifiers are ignored for deduction
{{source|1=
template &lt;class T&gt; void f(T);

int a[3];
f(a); // P = T, A = int[3], adjusted to int*. Deduces T = int*
const int b = 13;
f(b); // P = T, A = const int, adjusted to int. Deduces T = int
void g(int);
f(g); // P = T, A = void(int), adjusted to void(*)(int). Deduces T = void(*)(int)
}}
@2@ If {{tt|P}} is a cv-qualified type, the top-level cv qualifiers are ignored for deduction.
@3@ If {{tt|P}} is a reference type, the type referred to by {{tt|P}} is used for deduction.
@4@ If {{tt|P}} is an rvalue reference to a cv-unqualified template parameter (so-called &quot;universal reference&quot;), and the corresponding function call argument is an lvalue, the type lvalue reference to {{tt|A}} is used in place of {{tt|A}} for deduction (Note: this is the basis for the action of {{lc|std::forward}})
{{source|1=
template &lt;class T&gt;
int f(T&amp;&amp;); // P is rvalue reference to cv-unqualified T (&quot;universal reference&quot;)

template &lt;class T&gt;
int g(const T&amp;&amp;); // P is rvalue reference to cv-qualified T (not special)

int main()
{
    int i;
    int n1 = f(i); // argument is lvalue:     calls f&lt;int&amp;&gt;(int&amp;) (special case)
    int n2 = f(0); // argument is not lvalue: calls f&lt;int&gt;(int&amp;&amp;)

//  int n3 = g(i); // error: deduces to g&lt;int&gt;(const int&amp;&amp;), which
                   // cant bind an rvalue reference to an lvalue:
}
}}

After these transformations, the deduction process as described below (in &quot;Deduction from type&quot;), and attempts to find such template arguments that would make ''deduced A'' (that is, {{tt|P}} after adjustments listed above and the substitution of the deduced template parameters) identical to the ''transformed A'', that is {{ttb|A}} after the adjustments listed above.

If the usual deduction from {{ttb|P}} and {{ttb|A}} fails, the following alternatives are additionally considered: 
@1@ If the original {{ttb|P}} is a ''reference'' type, the ''deduced A'' (i.e., the type referred to by the reference) can be more cv-qualified than the ''transformed A''.
{{source|1=
template&lt;typename T&gt; void f1(const T&amp; t);
bool a = false;
f1(a); // P=const T&amp;, adjusted to const T, A=bool, 
       // deduced T = bool, deduced A = const bool
       // deduced A is more cv-qualified than A
}}
@2@ The ''transformed A'' can be another pointer or pointer to member type that can be converted to the ''deduced A'' via a {{rlp|implicit_cast#Qualification_conversions|qualification conversions}}.
{{source|1=
template&lt;typename T&gt; void f(const T*);
int* p;
f(p); // P=T, A=int*
      // deduces T=int, deduced A = const int*
      // qualification conversion applies (from int* to const int*)
}}
@3@ If {{tt|P}} is a class and {{tt|P}} has the form ''simple-template-id'', then the ''transformed A'' can be a derived class of the ''deduced A''. Likewise, if {{tt|P}} is a pointer to a class of the form ''simple-template-id'', the ''transformed A'' can be a pointer to a derived class pointed to by the ''deduced A''.
{{source|1=
template &lt;class T&gt; struct B { };
template &lt;class T&gt; struct D : public B&lt;T&gt; {};

template &lt;class T&gt; void f(B&lt;T&gt;&amp;){}

void f() {
    D&lt;int&gt; d;
    f(d);  // P = B&lt;T&gt;&amp;, adjusted P = B&lt;T&gt; (a simple-template-id)
           // A = D&lt;int&gt;
           // deduced T = int, deduced A = B&lt;int&gt;
           // A is derived from deduced A
}
}}

====Non-deduced contexts====
In the following cases, the types, templates, and non-type values that are used to compose {{ttb|P}} do not participate in template argument deduction, but instead ''use'' the template arguments that were either deduced elsewhere or explicitly specified. If a template parameter is used only in non-deduced contexts and is not explicitly specified, template argument deduction fails

@1@ The {{spar|nested-name-specifier}} (everything to the left of the scope resolution operator {{c|::}}) of a type that was specified using a {{rlp|identifiers#Qualified_identifiers|qualified-id}}. {{source|1=
// the identity template, often used to exclude specific arguments from deduction
template &lt;typename T&gt; struct identity { typedef T type; };

template &lt;typename T&gt;
void bad(std::vector&lt;T&gt; x, T value = 1);

template &lt;typename T&gt;
void good(std::vector&lt;T&gt; x, typename identity&lt;T&gt;::type value = 1);

std::vector&lt;std::complex&lt;double&gt;&gt; x;
bad(x, 1.2); // P1 = std::vector&lt;T&gt;, A1 = std::vector&lt;std::complex&lt;double&gt;&gt;
             // P1/A1 deduction determines T = std::complex&lt;double&gt;
             // P2 = T, A2 = double
             // P2/A2 deduction determines T = double -- Error
good(x, 1.2); // P1/A1 deduces T = std::complex&lt;double&gt;
              // P2 = identity&lt;T&gt;::type, T is to the left of ::, non-deduced
}}

{{rev begin}}
{{rev|since=c++14|
@2@ The expression of a {{rlp|decltype}}-specifier.
{{source|1=
template&lt;typename T&gt; void f(decltype(*std::declval&lt;T&gt;()) arg);
int n; f&lt;int*&gt;(n); // P = decltype(*declval&lt;T&gt;()), A=int. T is not deducible
}}
}}{{rev end}}
@3@ A non-type template argument or an array bound in which a subexpression references a template
parameter
{{source|1=
template&lt;std::size_t N&gt; void f(std::array&lt;int, 2*N&gt; a);
std::array&lt;int, 10&gt; a;
f(a); // P=std::array&lt;int, 2*N&gt;, &quot;2*N&quot; is non-deduced context, N cannot be deduced
      // (note: &quot;f(std::array&lt;int, N&gt; a)&quot; would be able to deduce N)
}}
@4@ A template parameter used in the parameter type of a function parameter that has a default argument that is being used in the call for which argument deduction is being done
{{source|1=
template&lt;typename T, typename F&gt;
void f(const std::vector&lt;T&gt; &amp;arr, const F&amp; comp = std::less&lt;T&gt;());
std::vector&lt;std::string&gt; arr(3);
f(arr); // P1 = const std::vector&lt;T&gt; &amp;, A1=std::vector&lt;std::string&gt; lvalue,
        // P1/A1 deduces T = std::string
        // P2 = non-deduced context for F (template parameter) used in the
        // parameter type const F&amp; of the function parameter comp,
        // that has a default argument that is being used in the call f(arr)
}}
@5@ The parameter {{ttb|P}}, whose {{ttb|A}} is a function or a set of overloads such that more than one function matches {{ttb|P}} or no function matches {{ttb|P}} or the set of overloads includes one or more function templates
{{source|1=
template&lt;typename T&gt; void out(const T&amp; value) { std::cout &lt;&lt; value; }

out(&quot;12345&quot;);   // P=const T&amp;, A=const char[6] lvalue, T is deduced to be &quot;char[6]&quot;
out(std::endl); // P=const T&amp;, A=function template, T is non-deducible, error.
}}
@6@ The parameter {{ttb|P}}, whose {{ttb|A}} is a braced-init-list, but {{ttb|P}} is not std::initializer_list or a reference to one.
{{source|1=
template&lt;class T&gt; void g1(std::vector&lt;T&gt;);
g1({1,2,3}); // P=std::vector&lt;T&gt;, A={1,2,3}, this P is non-deduced context
             // Error: T is not explicitly specified or deduced from another P/A

template&lt;class T&gt; void g2(std::vector&lt;T&gt;, T x);
g2({1,2,3}, 10); // P1=std::vector&lt;T,&gt; A1={1,2,3}, this P is non-deduced context
                 // P2=T, A2=int, this P/A pair deduces T = int

}}
@7@ The parameter {{ttb|P}} which is a parameter pack and does not occur at the end of the parameter list.
{{source|1=
template&lt;class... Ts, class T&gt; void f1(T n, Ts... args) {}
template&lt;class... Ts, class T&gt; void f2(Ts... args, T n) {}

f1(1,2,3,4); // P1=T, A1=1: T is deduced to be int
             // P2=Ts..., A2=2, A3=3, A4=4: Ts is deduced to be [int, int, int]
f2(1,2,3,4); // P1=Ts..., non-deducible
}}
@8@ The template parameter list that appears within the parameter {{ttb|P}}, and which includes a pack expansion that is not at the very end of the template parameter list.
{{source|1=
template&lt;int...&gt; struct T {};

template&lt;int... Ts1, int N, int... Ts2&gt;
void good(const T&lt;N, Ts1...&gt;&amp; arg1, const T&lt;N, Ts2...&gt;&amp;) {}

template&lt;int... Ts1, int N, int... Ts2&gt;
void bad(const T&lt;Ts1..., N&gt;&amp; arg1, const T&lt;Ts2..., N&gt;&amp;) {}

T&lt;1,2&gt; t1; T&lt;1,-1,0&gt; t2;

good(t1, t2); // P1=const T&lt;N, Ts1...&gt;&amp;, A1=T&lt;1,2&gt;: deduces N=1, Ts1=[2]
              // P2=const T&lt;N, Ts2...&gt;&amp;, A2=T&lt;1,-1,0&gt;: deduces N=1, Ts2=[-1, 0]

bad(t1, t2); // P1=const T&lt;Ts1..., N&gt;&amp;, A1=T&lt;1,2&gt;:  &lt;Ts1..., N&gt; is non-deduced
             // P2=const T&lt;Ts2..., N&gt;&amp;, A2=T&lt;1,-1,0&gt;: &lt;Ts2..., N&gt; is non-deduced
}}
@9@ For {{ttb|P}} of array type (but not reference to array or pointer to array), the major array bound.
{{source|1=
template&lt;int i&gt; void f1(int a[10][i]);
template&lt;int i&gt; void f2(int a[i][20]); // P = int[i][20], array type
template&lt;int i&gt; void f3(int (&amp;a)[i][20]); // P =int(&amp;)[i][20], reference to array
void g() {
  int v[10][20];
  f1(v);            // OK: i deduced to be 20
  f1&lt;20&gt;(v);        // OK
  f2(v);            // error: cannot deduce template-argument i
  f2&lt;10&gt;(v);        // OK
  f3(v);            // OK: i deduced to be 10
}
}}

In any case, if any part of a type name is non-deduced context, the entire type name is non-deduced. However, compound types can include both deduced and non-deduced type names. For example, in {{c|A&lt;T&gt;::B&lt;T2&gt;}}, {{tt|T}} is non-deduced because of rule #1 (nested name specifier), and {{tt|T2}} is non-deduced because it is part of the same type name, but in {{c|void(*f)(typename A&lt;T&gt;::B, A&lt;T&gt;)}}, the {{tt|T}} in {{c|A&lt;T&gt;::B}} is non-deduced (because of the same rule), while the {{tt|T}} in {{c|A&lt;T&gt;}} is deduced.

====Deduction from a type====
Given a function parameter {{ttb|P}} that depends on one or more type template parameters {{ttb|T}}i, template template parameters {{ttb|TT}}i, or non-type template parameters {{ttb|I}}i, and the corresponding argument {{ttb|A}}, deduction takes place if {{ttb|P}} has one of the following forms:

{{todo|possibly a table with micro-examples}}
* {{tt|T}}
* {{tt|cv-list T}}
* {{tt|T*}}
* {{tt|T&amp;}}
* {{tt|T&amp;&amp;}}
* {{tt|T[integer-constant]}}
* {{tt|class-template-name&lt;T&gt;}}
* {{tt|type(T)}}
* {{tt|T()}}
* {{tt|T(T)}}
* {{tt|T type::*}}
* {{tt|type T::*}}
* {{tt|T T::*}}
* {{tt|T(type::*)()}}
* {{tt|type(T::*)()}}
* {{tt|type(type::*)(T)}}
* {{tt|type(T::*)(T)}}
* {{tt|T (type::*)(T)}}
* {{tt|T (T::*)()}}
* {{tt|T (T::*)(T)}}
* {{tt|type[i]}}
* {{tt|class-template-name&lt;nowiki&gt;&lt;&lt;/nowiki&gt;I&gt;}}
* {{tt|TT&lt;T&gt;}}
* {{tt|TT&lt;nowiki&gt;&lt;&lt;/nowiki&gt;I&gt;}}
* {{tt|TT&lt;&gt;}}

where
* {{tt|(T)}} is a function parameter type list where at least one parameter type contains T
* {{tt|()}} is a function parameter type list where no parameters contain T
* {{tt|&lt;T&gt;}} is a template argument list where at least one argument contains T
* {{tt|&lt;nowiki&gt;&lt;&lt;/nowiki&gt;I&gt;}} is a template argument list where at least one argument contains I
* {{tt|&lt;&gt;}} is a template argument list where no arguments contain T or I

If {{ttb|P}} has one of the forms that include a template parameter list {{ttb|&lt;T&gt;}} or {{ttb|&lt;nowiki&gt;&lt;&lt;/nowiki&gt;I&gt;}}, then each element {{ttb|P}}i of that template argument list is matched against the corresponding template argument {{ttb|A}}i of its {{ttb|A}}. If the last {{ttb|P}}i is a pack expansion, then its pattern is compared against each remaining argument in the template argument list of {{ttb|A}}. A trailing parameter pack that is not otherwise deduced, is deduced to an empty parameter pack.

If {{ttb|P}} has one of the forms that include a function parameter list {{ttb|(T)}}, then each parameter {{ttb|P}}i from that list is compared with the corresponding argument {{ttb|A}}i from {{ttb|A}}'s function parameter list. If the last {{ttb|P}}i is a pack expansion, then its declarator is compared with each remaining {{ttb|A}}i in the parameter type list of {{ttb|A}}.

Forms can be nested and processed recursively: {{tt|X&lt;int&gt;(*)(char[6])}} is an example of {{tt|type(*)(T)}}, where ''type'' is {{tt|class-template-name&lt;T&gt;}} and T is {{tt|type[i]}}, which is, in turn, an example of {{tt|class-template-name&lt;T&gt;}}

Template type argument cannot be deduced from the type of a non-type template argument.
{{source|1=
template&lt;typename T, T i&gt; void f(double a[10][i]);
double v[10][20];
f(v); // P=double[10][i] A=double[10][20]:
      // i can be deduced to equal 20
      // but T cannot be deduced from the type of i
}}

If a non-type template parameter is used in the parameter list, and the corresponding template argument is deduced, the type of the deduced template argument must match the type of the non-type template parameter exactly (except that cv-qualifiers are dropped, and except where the template argument is deduced from an array bound -- in that case any integral type is allowed, even bool though it would always become true)
{{source|1=
template&lt;int i&gt; class A {};
template&lt;short s&gt; void f(A&lt;s&gt;); // the type of the non-type template param is short
void k1() {
  A&lt;1&gt; a; // the type of the non-type template param of a is int
  f(a);  // P=A&lt;(short)s&gt;, A=A&lt;(int)1&gt;, Error: deduced non-type template argument 
         // does not have the same type as its corresponding template argument
  f&lt;1&gt;(a); // OK, the template argument is not deduced, 
           // this calls f&lt;(short)1&gt;(A&lt;(short)1&gt;)
}
}}

Template type parameter cannot be deduced from the type of a function default argument
{{source|1=
template&lt;typename T&gt; void f(T = 5, T = 7);
void g() {
  f(1);      // OK: calls f&lt;int&gt;(1,7)
  f();       // error: cannot deduce T
  f&lt;int&gt;();  // OK: calls f&lt;int&gt;(5,7)
}
}}

Deduction of template template parameter can use the type used in the template specialization used in the function call
{{source|1=
template &lt;template&lt;typename&gt; class X&gt; struct A {}; // A is a template with a TT param
template &lt;template&lt;typename&gt; class TT&gt; void f(A&lt;TT&gt;) {} 
template&lt;class T&gt; struct B { }; 
A&lt;B&gt; ab;
f(ab); // P=A&lt;TT&gt;, A=A&lt;B&gt;. This deduces TT=B and calls f(A&lt;B&gt;)
}}

===Other contexts===
Besides function call expressions and an operator expressions, template argument deduction is used in the following situations:

@1@ In {{rlp|declarations}} of variables, when deducing the meaning of the {{rlp|auto}} specifier from the variable's initializer.
@@The parameter {{ttb|P}} is obtained as follows: in {{tt|T}}, the declared type of the variable that includes {{tt|auto}}, every occurrence of {{tt|auto}} is replaced with an imaginary type template parameter {{tt|U}} or, if the initializer is a brace-init-list, with {{tt|std::initializer_list&lt;nowiki&gt;&lt;&lt;/nowiki&gt;U&gt;}}. The argument {{ttb|A}} is the initializer expression. After deduction of {{tt|U}} from {{ttb|P}} and {{ttb|A}} following the rules described above, the deduced {{tt|U}} is substituted into {{tt|T}} to get the actual variable type.
{{source|1=
const auto&amp; x = 1+2; // P = const U&amp;, A = 1+2
  // same rules as for calling f(1+2) where f is
  // template &lt;class U&gt; void f(const U&amp; u)
  // U is deduced to be int, and the type of x is const int&amp;
auto l = {1, 2}; // P = std::initializer_list&lt;U&gt;, A = {1,2}
   // U is deduced to be int, the type of l is std::initializer_list&lt;int&gt;
}}
{{rev begin}}
{{rev|since=c++14|
@2@ In declarations of {{rlp|functions}}, when deducing the meaning of the {{rlp|auto}} specifier in the function's return type, from the return statement.
@@For auto-returning functions, the parameter {{ttb|P}} is obtained as follows: in {{tt|T}}, the declared return type of the function that includes {{tt|auto}}, every occurrence of {{tt|auto}} is replaced with an imaginary type template parameter {{tt|U}}. The argument {{ttb|A}} is the expression of the {{rlp|return}} statement, and if the return statement has no operand, {{ttb|A}} is {{c|void()}}. After deduction of {{tt|U}} from {{ttb|P}} and {{ttb|A}} following the rules described above, the deduced {{tt|U}} is substituted into {{tt|T}} to get the actual return type.
@@If such function has multiple return statements, the deduction is performed for each return statement. All the resulting types must be the same and become the actual return type.
@@If such function has no return statement, {{ttb|A}} is {{c|void()}} when deducing.
{{source|1=
auto f() { return 42; } // P = auto, A = 42
 // U is deduced to be int, the return type of f is int
}}
@@ Note: the meaning of {{c|decltype(auto)}} placeholder in variable and function declarations does not use template argument deduction
}}
{{rev end}}
@3@ During {{rlp|overload resolution}}, when generating specializations from a candidate template function.
@@ {{ttb|P}} and {{ttb|A}} are the same as in a regular function call
{{source|1=
std::string s;
std::getline(std::cin, s); // &quot;std::getline&quot; names 4 function templates, 
  // 2 of which are candidate functions (correct number of parameters)
  // 1st candidate template:
  // P1 = std::basic_istream&lt;CharT,Traits&gt;&amp;, A1 = std::cin
  // P2 = std::basic_string&lt;CharT,Traits,Allocator&gt;&amp;, A2 = s
  // deduction determines the type template parameters CharT, Traits, and Allocator
  // specialization std::getline&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt;&gt;
  // 2nd candidate template:
  // P1 = std::basic_istream&lt;CharT,Traits&gt;&amp;&amp;, A1 = std::cin
  // P2 = std::basic_string&lt;CharT,Traits,Allocator&gt;&amp;, A2 = s
  // deduction determines the type template parameters CharT, Traits, and Allocator
  // specialization std::getline&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt;&gt;
  // overload resolution ranks reference binding from lvalue std::cin and picks
  // the first of the two candidate specializations
}}
@4@ When taking an {{rlp|overloaded address|address of a overload set}}, which includes function templates
@@ The function type of the function template is {{ttb|P}}. The {{rlp|overloaded address|target type}} is the type of {{ttb|A}}
{{source|1=
std::cout &lt;&lt; std::endl; // std::endl names a function template
 // P = std::basic_ostream&lt;CharT,Traits&gt;&amp;(std::basic_ostream&lt;CharT,Traits&gt;&amp;)
 // the type of A is std::basic_ios&lt;CharT,Traits&gt;&amp;(*)(std::basic_ios&lt;CharT,Traits&gt;&amp;)
 // (other overloads of operator&lt;&lt; are not viable)
 // deduction determines the type template parameters CharT and Traits
}}
An additional rule is applied to the deduction in this case: when comparing function parameters {{ttb|P}}i and {{ttb|A}}i, if any {{ttb|P}}i is an rvalue reference to cv-unqualified template parameter (a &quot;universal reference&quot;) and the corresponding {{ttb|A}}i is an lvalue reference, then {{ttb|P}}i is adjusted to the template parameter type (T&amp;&amp; becomes T)
@5@ During {{rlp|function template|partial ordering of overloaded function templates}}
@@ {{todo|mini-example}} &lt;!-- don't lose the paragraph from 14.8.2.5/8 about matching a pack expansion against Ai which was originally a pack expansion, and 14.8.2.5/10 about the same for pack expansions in function parameter lists. it will go into the partial ordering text since this one is overcrowded.--&gt;
@6@ When selecting {{rlp|cast operator|user-defined conversion function}} template arguments
@@{{ttb|A}} is the type that is required as the result of the conversion. {{ttb|P}} is the return type of the conversion function template, except that
:@a@ If the return type is a reference type then {{ttb|P}} is the referred type
:@b@ If the return type is an array type and {{ttb|A}} is not a reference type, then {{ttb|P}} is the pointer type obtained by array-to-pointer conversion
:@c@ If the return type is a function type and {{ttb|A}} is not a reference type, then {{ttb|P}} is the function pointer type obtained by array-to-pointer conversion
:@d@ If {{ttb|P}} is cv-qualified, the top-level cv qualifiers are ignored.
@@If {{ttb|A}} is cv-qualified, the top-level cv qualifiers are ignored. If {{ttb|A}} is a reference type, the referred type is used by deduction.
@@If, the usual deduction from {{ttb|P}} and {{ttb|A}} (as described above) fails, the following alternatives are additionally considered:
:@a@ If the original A is a reference type, A can be more cv-qualified than the deduced A
:@b@ If A is a pointer or pointer to member type, the deduced A is allowed to be any pointer that can be converted to A by qualification conversion.
{{source|1=
struct A {
    template &lt;class T&gt; operator T***();
};
A a;
const int * const * const * p1 = a; // A = const int * const * const *
                                    // P = T***
 // regular function-call deduction for 
 // template&lt;class T&gt; void f(T*** p) as if called with the argument
 // of type const int * const * const * fails
 // additional deduction for conversion functions determines T = int 
 // (deduced A is int***, convertible to const int * const * const *)
}}
@7@ In {{rlp|function_template#Explicit_instantiation|explicit instantiations}}, {{rlp|template specialization|explicit specializations}}, and those {{rlp|friend#Template_friends|friend declarations}} where the declarator-id happens to refer to a specialization of a function template (for example, {{c|friend ostream&amp; operator&lt;&lt; &lt;&gt; (...)}}), if not all template arguments are explicitly specified or defaulted, template argument deduction is used to determine which template's specialization is referred to. {{ttb|P}} is the type of the function template that is being considered as a potential match, and {{ttb|A}} is the function type from the declaration. If there are no matches or more than one match (after partial ordering), the function declaration is ill-formed.
@@{{source|1=
template&lt;class X&gt; void f(X a);  // first template f
template&lt;class X&gt; void f(X* a); // second template f

template&lt;&gt; void f&lt;&gt;(int *a) {} // explicit specialization of f
 // P1 = void(X),  A1=void(int*): deduces X=int*
 // P2 = void(X*), A2=void(int*): deduces X=int
 // foo&lt;int*&gt;(int*) and f&lt;int&gt;(int*) are then submitted to partial ordering
 // which selects f&lt;int&gt;(int*) as the more specialized
}}
@@An additional rule is applied to the deduction in this case: when comparing function parameters {{ttb|P}}i and {{ttb|A}}i, if any {{ttb|P}}i is an rvalue reference to cv-unqualified template parameter (a &quot;universal reference&quot;) and the corresponding {{ttb|A}}i is an lvalue reference, then {{ttb|P}}i is adjusted to the template parameter type (T&amp;&amp; becomes T)
@8@ When determining if a [[cpp/memory/new/operator_delete|deallocation function]] template specialization matches a given placement form of {{tt|operator new}}. {{ttb|P}} is the type of the function template that is being considered as a potential match, and {{ttb|A}} is the function type of the deallocation function that would be the match for the placement operator new under consideration. If there is no match or more than one match (after overload resolution), the placement deallocation function is not called (memory leak may occur).
{{source|1=
struct X {
    X() { throw std::runtime_error(&quot;&quot;); }
    static void* operator new(std::size_t sz, bool b) { return ::operator new(sz); }
    static void* operator new(std::size_t sz, double f) { return ::operator new(sz); }
    template&lt;typename T&gt; static void operator delete(void* ptr, T arg) {
        ::operator delete(ptr);
    }
};
int main() {
   try {
     X* p1 = new (true) X; // when X() throws, operator delete is looked up
                           // P1=void(void*, T), A1=void(void*, bool): deduces T=bool
                           // P2=void(void*, T), A2=void(void*, double): T=double
                           // overload resolution picks operator delete&lt;bool&gt;
   } catch(const std::exception&amp;) { }
   try {
     X* p1 = new (13.2) X; // same lookup, picks operator delete&lt;double&gt;
   } catch(const std::exception&amp;) { }
}
}}

===Alias templates===
{{rlp|type alias|Alias templates}} are never deduced
{{source|1=
template&lt;class T&gt; struct Alloc {};
template&lt;class T&gt; using Vec = vector&lt;T, Alloc&lt;T&gt;&gt;;
Vec&lt;int&gt; v;

template&lt;template&lt;class,class&gt; class TT&gt; void g(TT&lt;int, Alloc&lt;int&gt;&gt;);
g(v); // ok: deduces TT = vector

template&lt;template&lt;class&gt; class TT&gt; void f(TT&lt;int&gt;);
f(v); // error: TT cannot be deduced as &quot;Vec&quot; because Vec is an alias template
}}

===Notes===
Type deduction does not consider implicit conversions (other than type adjustments listed above): that's the job for {{rlp|overload resolution}}, which happens later.</text>
      <sha1>q4qdrxsbueuczm81kbmvt817xrr3xvz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/template parameters</title>
    <ns>0</ns>
    <id>13162</id>
    <revision>
      <id>72192</id>
      <parentid>71712</parentid>
      <timestamp>2014-07-22T02:21:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link storage duration/linkage</comment>
      <text xml:space="preserve" bytes="11863">{{title|Template parameters and template arguments}}
{{cpp/language/templates/navbar}}
Every {{rlp|templates|template}} is parametrized by one or more template parameters, indicated in the {{spar|parameter-list}} of the template declaration syntax:

{{sdsc begin}}
{{sdsc|num=1|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|declaration}} }}
{{sdsc end}}

Each parameter in {{spar|parameter-list}} may be one of 
* non-type template parameter
* type template parameter
* template template parameter

====Non-type template parameter====
{{sdsc begin}}
{{sdsc|num=1|{{spar|type}} {{spar|name}}{{mark optional}} }}
{{sdsc|num=2|{{spar|type}} {{spar|name}}{{mark optional}} {{ttb|{{=}} }} {{spar|default}} }}
{{sdsc|num=3|{{spar|type}} {{ttb|...}} {{spar|name}}{{mark optional}} | notes={{mark since c++11}}}}
{{sdsc end}}
@1@ A non-type template parameter with an optional name
@2@ A non-type template parameter with an optional name and a default value
@3@ A non-type template [[cpp/language/parameter_pack|parameter pack]] with an optional name

{{spar|type}} is one of the following types (optionally cv-qualified, the qualifiers are ignored)
* integral type
* enumeration
* pointer to object or to function
* lvalue reference to object or to function
* pointer to member object or to member function
* {{lc|std::nullptr_t}} {{mark since c++11}}

Array and function types may be written in a template declaration, but they are automatically replaced by pointer to data and pointer to function as appropriate.

When the name of a non-type template parameter is used in an expression within the body of the class template, it is an unmodifiable prvalue unless its type was an lvalue reference type.

====Type template parameter====
{{sdsc begin}}
{{sdsc|num=1|{{ttb|typename}} {{spar|name}}{{mark optional}} }}
{{sdsc|num=2|{{ttb|class}} {{spar|name}}{{mark optional}} }}
{{sdsc|num=3|{{ttb|typename{{!}}class}} {{spar|name}}{{mark optional}} {{ttb|{{=}} }} {{spar|default}}  }}
{{sdsc|num=4|{{ttb|typename{{!}}class}} {{ttb|...}} {{spar|name}}{{mark optional}} | notes={{mark since c++11}}}}
{{sdsc end}}
@1@ A type template parameter with an optional name
@2@ Exactly the same as 1)
@3@ A type template parameter with an optional name and a default
@4@ A type template [[cpp/language/parameter_pack|parameter pack]] with an optional name

In the body of the template declaration, the name of a type parameter is a typedef-name which aliases the type supplied when the template is instantiated.

There is no difference between the keywords {{ttb|class}} and {{ttb|typename}} in a type template parameter declaration.

====Template template parameter====
{{sdsc begin}}
{{sdsc|num=1|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{ttb|class}} {{spar|name}}{{mark optional}} }}
{{sdsc|num=2|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{ttb|class}} {{spar|name}}{{mark optional}} {{ttb|{{=}}}} {{spar|default}} }}
{{sdsc|num=3|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{ttb|class}} {{ttb|...}} {{spar|name}}{{mark optional}} | notes={{mark since c++11}}}}
{{sdsc end}}
@1@ A template template parameter with an optional name
@2@ A template template parameter with an optional name and a default
@3@ A template template [[cpp/language/parameter_pack|parameter pack]] with an optional name

Unlike type template parameter declaration, template template parameter declaration can only use the keyword {{ttb|class}} and not {{ttb|typename}}.

In the body of the template declaration, the name of this parameter is a template-name (and needs arguments to be instantiated)

{{source|1=
template&lt;class T&gt; class myarray {};

// two type template parameters and one template template parameter:
template&lt;class K, class V, template&lt;typename&gt; class C = myarray&gt;
class Map {
  C&lt;K&gt; key;
  C&lt;V&gt; value;
};
}}

===Template arguments===
In order for a template to be instantiated, every template parameter (type, non-type, or template) must be replaced by a corresponding template argument. For {{rlp|class template}}s, the arguments are either explicitly provided or defaulted. For {{rlp|function template}}s, the arguments are explicitly provided, defaulted, or {{rlp|template argument deduction|deduced from context}}.

====Template non-type arguments====
The following limitations apply when instantiating templates that have non-type template parameters:
* For integral and arithmetic types, the template argument provided during instantiation must be a {{rlp|constexpr|converted constant expression}} of the template parameter's type.
* For pointers to objects, the template arguments have to designate the address of an object with static {{rlp|storage duration}} and a {{rlp|storage_duration#Linkage|linkage}} (either internal or external), or a constant expression that evaluates to the appropriate null pointer or {{lc|std::nullptr_t}} value.
* For pointers to functions, the valid arguments are pointers to functions with linkage (or constant expressions that evaluate to null pointer values).
* For lvalue reference parameters, the argument provided at instantiation cannot be a temporary, an unnamed lvalue, or a named lvalue with no linkage.
* For pointers to members, the argument has to be a pointer to member expressed as {{c|&amp;Class::Member}} or a constant expression that evaluates to null pointer or {{lc|std::nullptr_t}} value.

In particular, this implies that string literals, addresses of array elements, and addresses of non-static members cannot be used as template arguments to instantiate templates whose corresponding non-type template parameters are pointers to data.

====Template type arguments====
A template argument for a type template parameter must be a {{rlp|type#Type_naming|type-id}}, which may name an incomplete type:
{{source|
template &lt;class T&gt; class X { }; // class template

struct A; // incomplete type
typedef struct {} B; // type alias to an unnamed type
int main() {
   X&lt;A&gt; x1; // OK, 'A' names a type
   X&lt;A*&gt; x2; // OK, 'A*' names a type
   X&lt;B&gt; x3; // OK, 'B' names a type
}
}}

====Template template arguments====
A template argument for a template template parameter must be an {{rlp|identifiers#In_expressions|id-expression}} which names a class template or a template alias.

When the argument is a class template, only the primary template is considered when matching the parameter. The partial specializations, if any, are only considered when a specialization based on this template template parameter happens to be instantiated.

{{source|1=
template&lt;class T&gt; class A { // primary template
    int x;
};
template&lt;class T&gt; class A&lt;T*&gt; { // partial specialization
    long x;
};

// class template with a template template parameter V
template&lt; template&lt;typename&gt; class V&gt; class C {
    V&lt;int&gt; y; // uses the primary template
    V&lt;int*&gt; z; // uses the partial specialization
};

C&lt;A&gt; c; // c.y.x has type int, c.z.x has type long
}}

To match a template template argument {{tt|A}} to a template template parameter {{tt|P}}, each of the template parameters of {{tt|A}} must match corresponding template parameters of {{tt|P}}. If {{tt|P}}'s parameter list includes a {{rlp|parameter_pack|parameter pack}}, zero or more template parameters (or parameter packs) from {{tt|A}}'s template parameter list are matched by it.

{{source|1=
template&lt;class T&gt; struct eval; // primary template 

template&lt; template&lt;class, class...&gt; class TT, class T1, class... Rest&gt;
struct eval&lt;TT&lt;T1, Rest...&gt;&gt; {}; // partial specialization of eval

template &lt;class T1&gt; struct A;
template &lt;class T1, class T2&gt; struct B;
template &lt;int N&gt; struct C;
template &lt;class T1, int N&gt; struct D;
template &lt;class T1, class T2, int N = 17&gt; struct E;

eval&lt;A&lt;int&gt;&gt; eA; // OK: matches partial specialization of eval
eval&lt;B&lt;int, float&gt;&gt; eB; // OK: matches partial specialization of eval
eval&lt;C&lt;17&gt;&gt; eC; // error: C does not match TT in partial specialization because
                // TT's first parameter is a type template parameter,
                // while 17 does not name a type
eval&lt;D&lt;int, 17&gt;&gt; eD; // error: D does not match TT in partial specialization
                     // because TT's second parameter is a type parameter pack,
                     // while 17 does not name a type
eval&lt;E&lt;int, float&gt;&gt; eE; // error: E does not match TT in partial specialization
                        // because E's third (default) parameter is a non-type
}}

====Default template arguments====
Default template arguments are specified in the parameter lists after the {{c|{{=}}}} sign. Defaults can be specified for any kind of template parameter (type, non-type, or template), but not to parameter packs.

If the default is specified for a template parameter of a primary class template, each subsequent template parameter must have a default argument, except the very last one may be a template parameter pack. In a function template, a parameter pack may be followed by more type parameters only if they have defaults or can be deduced from the function arguments.

Default parameters are not allowed
* in the out-of-class definition of a {{rlp|member template}} (they have to be provided in the declaration inside the class body)
* in {{rlp|friend#Template_friends|friend class template}} declarations

On a friend function template declaration, default template arguments are allowed only if the declaration is a definition, and no other declarations of this function appear in this translation unit.

Default template arguments that appear in the declarations and the definition are merged similarly to default function arguments:
{{source|1=
template&lt;class T1, class T2 = int&gt; class A;
template&lt;class T1 = int, class T2&gt; class A;
// the above is the same as the following:
template&lt;class T1 = int, class T2 = int&gt; class A;
}}
But the same parameter cannot be given default arguments twice in the same scope
{{source|1=
template&lt;class T = int&gt; class X;
template&lt;class T = int&gt; class X { /* ... */ }; // error
}}

The template parameter lists of template template parameters can have their own default arguments, which are only in effect where the template template parameter itself is in scope:

{{source|1=
// class template, with a type template parameter with a default
template &lt;class T = float&gt; struct B {};

// template template parameter T has a parameter list, which 
// consists of one type template parameter with a default
template &lt;template &lt;class = float&gt; class T&gt; struct A {
    void f();
    void g();
};
// out-of-body member function template definitions
template &lt;template &lt;class TT&gt; class T&gt;
void A&lt;T&gt;::f() {
    T&lt;&gt; t; // error - TT has no default in scope
}
template &lt;template &lt;class TT = char&gt; class T&gt;
void A&lt;T&gt;::g() {
    T&lt;&gt; t; // OK, t is T&lt;char&gt;
}
}}

===Examples===
====Non-type template parameters====
{{example
|code=
#include &lt;iostream&gt;

// simple non-type template parameter
template&lt;int N&gt;
struct S {
    int a[N];
};

template&lt;const char*&gt;
struct S2 {};

// complicated non-type example
template &lt;
    char c, // integral type
    int (&amp;ra)[5], // lvalue reference to object (of array type)
    int (*pf)(int), // pointer to function
    int (S&lt;10&gt;::*a)[10] // pointer to member object (of type int[10])
&gt; struct Complicated {
    // calls the function selected at compile time
    // and stores the result in the array selected at compile time
    void foo(char base) {
        ra[4] = pf(c - base);
    }
};

//  S2&lt;&quot;fail&quot;&gt; s2; // Error: string literal cannot be used
char okay[] = &quot;okay&quot;; // static object with linkage
// S2&lt; &amp;okay[0] &gt; s2; // Error: array element has no linkage
S2&lt;okay&gt; s2; // works

int a[5];
int f(int n) { return n;}
int main()
{
    S&lt;10&gt; s; // s.a is an array of 10 int
    s.a[9] = 4;

    Complicated&lt;'2', a, f, &amp;S&lt;10&gt;::a&gt; c;
    c.foo('0');

    std::cout &lt;&lt; s.a[9] &lt;&lt; a[4] &lt;&lt; '\n';
}
|output=
42
}}
{{todo|more examples}}</text>
      <sha1>6qkl3tuvzq58fbjv3u4uhgxjzkithe2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/template specialization</title>
    <ns>0</ns>
    <id>5143</id>
    <revision>
      <id>72424</id>
      <parentid>69960</parentid>
      <timestamp>2014-08-21T20:50:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+variable template</comment>
      <text xml:space="preserve" bytes="8701">{{title|explicit (full) template specialization}}
{{cpp/language/templates/navbar}}
Allows customizing the template code for a given set of template arguments.

===Syntax===
{{sdsc begin}}
{{sdsc|{{ttb|template}} {{ttb|&lt;&gt;}} {{spar|declaration}} }}
{{sdsc end}}

Any of the following can be fully specialized:
# {{rlp|function template}}
# {{rlp|class template}}
# {{mark since c++14}}{{rlp|variable template}}
# {{rlp|member functions|member function}} of a class template
# {{rlp|static|static data member}} of a class template
# {{rlp|nested types|member class}} of a class template
# member {{rlp|enum|enumeration}} of a class template
# {{rlp|member template|member class template}} of a class or class template
# {{rlp|member template#Member function templates|member function template}} of a class or class template

For example, 
{{example|code=
#include &lt;iostream&gt;
template&lt;typename T&gt;   // primary template
struct is_void : std::false_type
{
};
template&lt;&gt;  // explicit specialization for T = void
struct is_void&lt;void&gt; : std::true_type
{
};
int main()
{
    // for any type T other than void, the 
    // class is derived from false_type
    std::cout &lt;&lt; is_void&lt;char&gt;::value &lt;&lt; '\n'; 
    // but when T is void, the class is derived
    // from true_type
    std::cout &lt;&lt; is_void&lt;void&gt;::value &lt;&lt; '\n';
}

}}

===In detail===
Explicit specialization can only appear in the same {{rlp|namespace}} as the primary template, and has to appear after the non-specialized template declaration. It is always in the scope of that namespace:

{{source|
namespace N {
    template&lt;class T&gt; class X { /*...*/ }; // primary template
    template&lt;&gt; class X&lt;int&gt; { /*...*/ }; // specialization in same namespace

    template&lt;class T&gt; class Y { /*...*/ }; // primary template
    template&lt;&gt; class Y&lt;double&gt;; // forward declare specialization for double
}
template&lt;&gt;
class N::Y&lt;double&gt; { /*...*/ }; // OK: specialization in same namespace
}}

Specialization must be declared before the first use that would cause implicit instantiation, in every translation unit where such use occurs:

{{source|
class String {};
template&lt;class T&gt; class Array { /*...*/ };
template&lt;class T&gt; void sort(Array&lt;T&gt;&amp; v) { /*...*/ } // primary template

void f(Array&lt;String&gt;&amp; v) {
    sort(v); // implicitly instantiates sort(Array&lt;String&gt;&amp;), 
}            // using the primary template for sort()

template&lt;&gt;  // ERROR: explicit specialization of sort(Array&lt;String&gt;)
void sort&lt;String&gt;(Array&lt;String&gt;&amp; v); // after implicit instantiation
}}

A template specialization that was declared but not defined can be used just like any other {{rlp|incomplete type}} (e.g. pointers and references to it may be used)
{{source|
template&lt;class T&gt; class X; // primary template
template&lt;&gt; class X&lt;int&gt;; // specialization (declared, not defined)
X&lt;int&gt;* p; // OK: pointer to incomplete type
X&lt;int&gt; x; // error: object of incomplete type
}}

===Explicit specializations of function templates===
When specializing a function template, its template arguments can be omitted if {{rlp|template argument deduction}} can provide them from the function arguments:
{{source|1=
template&lt;class T&gt; class Array { /*...*/ };
template&lt;class T&gt; void sort(Array&lt;T&gt;&amp; v); // primary template
template&lt;&gt; void sort(Array&lt;int&gt;&amp;); // specialization for T = int
// no need to write
// template&lt;&gt; void sort&lt;int&gt;(Array&lt;int&gt;&amp;);
}}

A function with the same name and the same argument list as a specialization is not a specialization (see template overloading in {{rlp|function_template}})

An explicit specialization of a function template is inline only if it is declared with the {{rlp|inline|inline specifier}} (or defined as deleted), it doesn't matter if the primary template is inline.

{{rlp|default arguments|Default function arguments}} cannot be specified in explicit specializations of function templates, member function templates, and member functions of class templates when the class is implicitly instantiated.

An explicit specialization cannot be a {{rlp|friend|friend declaration}}.

====Members of specializations====
When defining a member of an explicitly specialized class template outside the body of the class, the syntax {{c|template &lt;&gt;}} is not used, except if it's a member of an explicitly specialized member class template, which is specialized as a class template, because otherwise, the syntax would require such definition to begin with {{c|template&lt;parameters&gt;}} required by the nested template

{{source|1=
template&lt; typename T&gt;
struct A {
    struct B {};  // member class 
    template&lt;class U&gt; struct C { }; // member class template
};

template&lt;&gt; // specialization
struct A&lt;int&gt; {
    void f(int); // member function of a specialization
};
// template&lt;&gt; not used for a member of a specialization
void A&lt;int&gt;::f(int) { /* ... */ }

template&lt;&gt; // specialization of a member class
struct A&lt;char&gt;::B {
    void f();
};
// template&lt;&gt; not used for a member of a specialized member class either
void A&lt;char&gt;::B::f() { /* ... */ }

template&lt;&gt; // specialization of a member class template
template&lt;class U&gt; struct A&lt;char&gt;::C {
    void f();
};

// template&lt;&gt; is used when defining a member of an explicitly
// specialized member class template specialized as a class template
template&lt;&gt;
template&lt;class U&gt; void A&lt;char&gt;::C&lt;U&gt;::f() { /* ... */ }
}}


An explicit specialization of a static data member of a template is a definition if the declaration includes an initializer; otherwise, it is a declaration. These definitions must use braces for default initialization:
{{source|
template&lt;&gt; X Q&lt;int&gt;::x; // declaration of a static member
template&lt;&gt; X Q&lt;int&gt;::x (); // error: function declaration
template&lt;&gt; X Q&lt;int&gt;::x {}; // definition of a default-initialized static member
}}

A member or a member template of a class template may be explicitly specialized for a given implicit instantiation of the class template, even if the member or member template is defined in the class template definition.

{{source|1=
template&lt;typename T&gt;
struct A {
    void f(T); // member, declared in the primary template
    void h(T) {} // member, defined in the primary template
    template&lt;class X1&gt; void g1(T, X1); // member template
    template&lt;class X2&gt; void g2(T, X2); // member template
};

// specialization of a member
template&lt;&gt; void A&lt;int&gt;::f(int);
// member specialization OK even if defined in-class
template&lt;&gt; void A&lt;int&gt;::h(int) {}

// out of class member template definition
template&lt;class T&gt;
template&lt;class X1&gt; void A&lt;T&gt;::g1(T, X1) { }

// member template specialization
template&lt;&gt;
template&lt;class X1&gt; void A&lt;int&gt;::g1(int, X1);

// member template specialization
template&lt;&gt;
template&lt;&gt; void A&lt;int&gt;::g2&lt;char&gt;(int, char); // for X2 = char
// same, using template argument deduction (X1 = char)
template&lt;&gt; 
template&lt;&gt; void A&lt;int&gt;::g1(int, char); 
}}

Member or a member template may be nested within many enclosing class templates. In an explicit specialization for such a member, there's a {{c|template&lt;&gt;}} for every
enclosing class template that is explicitly specialized.

{{source|
template&lt;class T1&gt; class A {
    template&lt;class T2&gt; class B {
        void mf();
    };
};
template&lt;&gt; template&lt;&gt; class A&lt;int&gt;::B&lt;double&gt;;
template&lt;&gt; template&lt;&gt; void A&lt;char&gt;::B&lt;char&gt;::mf();
}}

In such a nested declaration, some of the levels may remain unspecialized (except that it can't specialize a class member template if its enclosing class is unspecialized). For each of those levels, the declaration needs {{c|template&lt;arguments&gt;}}, because such specializations are themselves templates:
{{source|
template &lt;class T1&gt; class A {
    template&lt;class T2&gt; class B {
        template&lt;class T3&gt; void mf1(T3); // member template
        void mf2(); // non-template member
     };
};

// specialization
template&lt;&gt; // for the specialized A
template&lt;class X&gt; // for the unspecialized B
class A&lt;int&gt;::B {
    template &lt;class T&gt; void mf1(T);
};

// specialization
template&lt;&gt; // for the specialized A
template&lt;&gt; // for the specialized B
template&lt;class T&gt; // for the unspecialized mf1
void A&lt;int&gt;::B&lt;double&gt;::mf1(T t) { }

// ERROR: B&lt;double&gt; is specialized and is a member template, so its enclosing A
// must be specialized also
template&lt;class Y&gt;
template&lt;&gt; void A&lt;Y&gt;::B&lt;double&gt;::mf2() { }
}}

===See also===
* {{rlp|templates}}
* {{rlp|class template}}
* {{rlp|function template}}
* {{rlp|partial specialization}}


[[de:cpp/language/template specialization]]
[[es:cpp/language/template specialization]]
[[fr:cpp/language/template specialization]]
[[it:cpp/language/template specialization]]
[[ja:cpp/language/template specialization]]
[[pt:cpp/language/template specialization]]
[[ru:cpp/language/template specialization]]
[[zh:cpp/language/template specialization]]</text>
      <sha1>ph8r4msvvn1b5b3p6fnpppxq8yt4wla</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/templates</title>
    <ns>0</ns>
    <id>13160</id>
    <revision>
      <id>69609</id>
      <parentid>67750</parentid>
      <timestamp>2014-04-15T16:51:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="2218">{{title|Templates}}
{{cpp/language/templates/navbar}}
A template is a C++ entity that defines one of the following:
* a family of classes ({{rlp|class template}}), which may be {{rlp|member template|nested classes}}
* a family of functions ({{rlp|function template}}), which may be {{rlp|member template|member functions}}
* an alias to a family of types ({{rlp|type alias|alias template}}) {{mark since c++11}}
* a family of variables ({{rlp|variable template}}) {{mark since c++14}}

Templates are parametrized by one or more {{rlp|template parameters}}, of three kinds: type template parameters, non-type template parameters, and template template parameters.

When template arguments are provided or, for function templates only, {{rlp|function_template#Template argument deduction|deduced}}, they are substituted for the template parameters to obtain a ''specialization'' of the template, that is, a specific type or a specific function lvalue. Specializations may also be provided explicitly: {{rlp|template specialization|full specializations}} are allowed for both class and function templates, {{rlp|partial_specialization|partial specializations}} are only allowed for class templates.

When a class template specialization is referenced in context that requires a complete object type, or when a function template specialization is referenced in context that requires a function definition to exist, the template is ''instantiated'' (the code for it is actually compiled), unless the template was already explicitly specialized or explicitly instantiated. Instantiation of a class template doesn't instantiate any of its member functions unless they are also used. At link time, identical instantiations generated by different translation units are merged.

The definition of a template must be visible at the point of implicit instantiation, which is why template libraries typically provide all template definitions in the headers (e.g. [http://www.boost.org/doc/libs/release/more/getting_started/unix-variants.html#header-only-libraries most boost libraries are header-only])

{{todo|core syntax, template parameters, and instantiations, take content common between class_template and function_template}}</text>
      <sha1>t2uj4v2s6c4w2r2rdj75e8lld7xm9xd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/this</title>
    <ns>0</ns>
    <id>5291</id>
    <revision>
      <id>70865</id>
      <parentid>70838</parentid>
      <timestamp>2014-05-31T12:36:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>expand on what's after cv-qual</comment>
      <text xml:space="preserve" bytes="3844">{{title|this pointer}}
{{cpp/language/classes/navbar}}

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|this}} }}
{{sdsc end}}

The keyword {{tt|this}} is a {{rlp|value_category|prvalue}} {{rlp|expressions|expression}} whose value is the address of the object, on which the member function is being called. It can appear in the following contexts:
@1@ Within the body of any non-static {{rlp|member functions|member function}}, including {{rlp|initializer list|member initializer list}}
@2@ within the {{rlp|function|declaration}} of a non-static member function anywhere after the (optional) cv-qualifier sequence, including {{rlp|except_spec|dynamic exception specification}}{{mark deprecated}}, {{rlp|noexcept_spec|noexcept specification}}{{mark c++11}}, and the trailing return type{{mark since c++11}}
@3@ within {{rlp|data_members#Member_initialization|brace-or-equal initializer}} of a non-static data member {{mark since c++11}}

The type of {{tt|this}} in a member function of class {{tt|X}} is {{tt|X*}} (pointer to X). If the member function is {{rlp|member_functions|cv-qualified}}, the type of {{tt|this}} is {{tt|cv X*}} (pointer to identically cv-qualified X). Since constructors and destructors cannot be cv-qualified, the type of {{tt|this}} in them is always {{tt|X*}}, even when constructing or destroying a const object.

When a non-static class member is used in any of the contexts where the {{tt|this}} keyword is allowed (non-static member function bodies, member initializer lists, in-class brace-or-equal initializers), the implicit {{ttb|this-&gt;}} is automatically added before the name, resulting in a member access expression (which, if the member is a virtual member function, results in a virtual function call).

In class templates, {{tt|this}} is a {{rlp|dependent name|dependent expression}}, and explicit {{tt|this-&gt;}} may be used to force another expression to become dependent.

It is possible to execute {{c|delete this;}}, if the program can guarantee that the object was allocated by {{c|new}}, however, this renders every pointer to the deallocated object invalid, including the {{tt|this}} pointer itself: after {{c|delete this;}} returns, such member function cannot refer to a member of a class (since this involves an implicit dereference of {{tt|this}}) and no other member function may be called. This is used, for example, in the member function of the control block of {{lc|std::shared_ptr}} responsible for decrementing the reference count, when the last reference to the managed object goes out of scope.

===Example===
{{source|code=
class T
{
    int x;

    void foo()
    {
        x = 6;       // same as this-&gt;x = 6;
        this-&gt;x = 5; // explicit use of this-&gt;
    }

    void foo() const
    {
//        x = 7; // Error: *this is constant
    }

    void foo(int x) // parameter x shadows the member with the same name
    {
        this-&gt;x = x; // unqualified x refers to the parameter
                     // 'this-&gt;' required for disambiguation
    }

    int y;
    T(int x) : x(x), // uses parameter x to initialize member x
               y(this-&gt;x) // uses member x to initialize member y
    {}

    T&amp; operator= ( const T&amp; b )
    {
        x = b.x;
        return *this; // many overloaded operators return *this
    }
};

class Outer {
    int a[sizeof(*this)]; // error: not inside a member function
    unsigned int sz = sizeof(*this); // OK: in brace-or-equal-initializer
    void f() {
        int b[sizeof(*this)]; // OK
        struct Inner {
            int c[sizeof(*this)]; // error: not inside a member function of Inner
        };
    }
}
int main()
{
    T t;
}

}}

[[de:cpp/language/this]]
[[es:cpp/language/this]]
[[fr:cpp/language/this]]
[[it:cpp/language/this]]
[[ja:cpp/language/this]]
[[pt:cpp/language/this]]
[[ru:cpp/language/this]]
[[zh:cpp/language/this]]</text>
      <sha1>8weq5sm5jl2l6h9wnyakvp26fp34lfw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/throw</title>
    <ns>0</ns>
    <id>714</id>
    <revision>
      <id>71866</id>
      <parentid>69605</parentid>
      <timestamp>2014-06-29T17:07:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>clarify that it's not only the destructors that can terminate stack unwinding</comment>
      <text xml:space="preserve" bytes="6256">{{title|throw expression}}
{{cpp/language/exceptions/navbar}}
Signals an erroneous condition and executes an error handler.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|throw}} {{spar|expression}} }}
{{sdsc | num=2 | {{ttb|throw}} }}
{{sdsc end}}

===Explanation===

:{{small|See {{rlp|try_catch | try-catch block}} for more information about ''try'' and ''catch'' (exception handler) blocks}} 

@1@ First, {{rlp|copy initialization|copy-initializes}} the ''exception object'' from {{spar|expression}} (this may call the move constructor for rvalue expression, and the copy/move may be subject to {{rlp|copy elision}}), then transfers control to the  {{rlp|try_catch|exception handler}} with the matching type whose compound statement or member initializer list was most recently entered and not exited by this thread of execution.
@2@ Rethrows the currently handled exception. Abandons the execution of the current catch block and passes control to the next matching exception handler (but not to another catch clause after the same try block: its compound-statement is considered to have been 'exited'), reusing the existing exception object: no new objects are made. This form is only allowed inside a catch block (it calls {{lc|std::terminate}} if used otherwise). The catch clause associated with a {{rlp|function-try-block}} must exit via rethrowing if used on a constructor.

See {{lc|std::terminate}} and {{lc|std::unexpected}} for the handling of errors that arise during exception handling.

===The exception object===
The exception object is a temporary object in unspecified storage that is constructed by the {{tt|throw}} expression. 

The type of the ''exception object'' is the static type of {{spar|expression}} with top-level {{rlp|cv|cv-qualifiers}} removed. Array and function types are adjusted to pointer and pointer to function types, respectively. If the type of the exception object would be an {{rlp|incomplete type}} or pointer to incomplete type other than pointer to (cv-qualified) void, the throw-expression is a compile-time error. If the type of {{spar|expression}} is a class type, its copy/move constructor and destructor must be accessible even if {{rlp|copy elision}} takes place.

Unlike other temporary objects, the exception object is considered to be an lvalue argument when initializing the catch clause parameters, so it can be caught by lvalue reference, modified, and rethrown.

The exception object persists until the last catch clause exits other than by rethrowing (in which case it is destroyed immediately after the destruction of the catch clause's parameter), or until the last {{lc|std::exception_ptr}} that references this object is destroyed (in which case the exception object is destroyed just before the destructor of {{lc|std::exception_ptr}} returns.

===Stack unwinding===
Once the exception object is constructed, the control flow works backwards (up the call stack) until it reaches the start of a {{rlp|try_catch|try block}}, at which point the parameters of all associated {{tt|catch}} blocks are compared, in order of appearance, with the type of the exception object to find a match (see {{rlp|try_catch|try-catch}} for details on this process). If no match is found, the control flow continues to unwind the stack until the next {{tt|try}} block, and so on. If a match is found, the control flow jumps to the matching {{tt|catch}} block.

As the control flow moves up the call stack, destructors are invoked for all objects with {{rlp|storage_duration|automatic storage duration}} constructed since the corresponding try-block was entered, in reverse order of completion of their constructors.

If an exception is thrown from a constructor or (rare) from a destructor of an object (regardless of the object's storage duration), destructors are called for all fully-constructed non-static non-variant members and base classes, in reverse order of completion of their constructors.
{{rev begin}}
{{rev|since=c++11| If a delegating constructor exits with an exception after the non-delegating constructor successfully completed, the destructor for this object is called.}}
{{rev end}}
If the exception is thrown from a constructor that is invoked by a {{rlp|new|new-expression}}, the matching [[cpp/memory/new/operator_delete|deallocation function]] is called, if available.

This process is called ''stack unwinding''.

If any function that is called during stack unwinding, after initialization of the exception object and before the start of the exception handler, exits with an exception, {{lc|std::terminate}} is called. Such functions include {{rlp|destructor}}s of objects with automatic storage duration whose scopes are exited, and the copy constructor of the exception object that is called ({{rlp|copy elision|if not elided}}) to initialize catch-by-value arguments.

===Notes===
When rethrowing exceptions, the second form must be used to avoid object slicing in the (typical) case where exception objects use inheritance:
{{source|
try {
    std::string(&quot;abc&quot;).substr(10); // throws std::length_error
} catch(const std::exception&amp; e) {
    std::cout &lt;&lt; e.what() &lt;&lt; '\n';
//  throw e; // copy-initializes a new exception object of type std::exception
    throw;   // rethrows the exception object of type std::length_error
}
}}

The throw-expression is classified as {{rlp|value_category|prvalue expression}} of type {{c|void}}. Like any other expression, it may be a sub-expression in another expression, most commonly in the {{rlp|operator_other#Conditional_operator|conditional operator}}:
{{source|1=
double f(double d)
{
    return d &gt; 1e7 ? throw std::overflow_error(&quot;too big&quot;) : d;
}
int main()  
{
    try {
        std::cout &lt;&lt; f(1e10) &lt;&lt; '\n';
    } catch (const std::overflow_error&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
}}

===Keywords===

{{ltt|cpp/keyword/throw}}

===Example===

{{todo}}

===See also===
* {{rlp|try_catch | try-catch block}}
* {{rlp|noexcept_spec | noexcept specifier}}
* {{rlp|except_spec | exception specifications}}

[[de:cpp/language/throw]]
[[es:cpp/language/throw]]
[[fr:cpp/language/throw]]
[[it:cpp/language/throw]]
[[ja:cpp/language/throw]]
[[pt:cpp/language/throw]]
[[ru:cpp/language/throw]]
[[zh:cpp/language/throw]]</text>
      <sha1>bghxk60p38rrbb3nvfgquhlixm06uy9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/translation phases</title>
    <ns>0</ns>
    <id>9900</id>
    <revision>
      <id>68988</id>
      <parentid>67567</parentid>
      <timestamp>2014-03-23T16:01:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="5118">{{title|Phases of translation}}
{{cpp/language/basics/navbar}}
The C++ source file is processed by the compiler as if the following phases take place, in this exact order:

===Phase 1===
@1@ The individual bytes of the source code file are mapped (in implementation defined manner) to the characters of the ''basic source character set''. In particular, OS-dependent end-of-line indicators are replaced by newline characters.
:The ''basic source character set'' consists of 96 characters:
:@a@ 5 whitespace characters (space, horizontal tab, vertical tab, form feed, new-line)
:@b@ 10 digit characters from {{c|'0'}} to {{c|'9'}}
:@c@ 52 letters from {{c|'a'}} to {{c|'z'}} and from {{c|'A'}} to {{c|'Z'}}
:@d@ 29 punctuation characters: {{c|_ { } [ ] # ( ) &lt; &gt; % : ; . ? * + - / ^ &amp; {{!}} ~ ! {{=}} , \ &quot; ’}}
@2@ {{rlp|operator_alternative|Trigraph sequences}} are replaced by corresponding single-character representations.
@3@ Any source file character that cannot be mapped to a character in basic source character set, is replaced by its universal character name ({{c|\uXXX}}) or by some internal form that is handled equivalently.

===Phase 2===
@1@ Whenever backslash appears at the end of a line (immediately followed by the newline character), both backslash and newline are deleted, combining two physical source lines into one logical source line. This is a single-pass operation, a line ending in two backslashes followed by an empty line does not combine three lines into one). If a universal character name ({{c|\uXXX}}) is formed on this phase, the behavior is undefined.
@2@ If a non-empty source file does not end with a newline character after this step (whether it had no newline originally, or it ended with a backslash)
:*the behavior is undefined {{mark until c++11}}
:*a terminating newline character is added {{mark since c++11}}

===Phase 3===
@1@ The source file is decomposed into [[cpp/comment|comments]], sequences of whitespace characters (space, horizontal tab, new-line, vertical tab, and form-feed), and ''preprocessing tokens'', which are the following
:@a@ header names: {{c|&lt;iostream&gt;}} or {{c|&quot;myfile.h&quot;}}
:@b@ {{rlp|identifiers|identifiers}}
:@c@ numbers
:@d@ {{rlp|character_literal|character}} and {{rlp|string_literal|string}} literals, including {{rlp|user_literal|user-defined}}
:@e@ operators and punctuators (including {{rlp|operator_alternative|alternative tokens}}), such as {{c|+}}, {{c|&lt;&lt;{{=}}}}, {{c|new}}, {{c|&lt;%}}, {{c|##}}, or {{c|and}}.
:@f@ individual non-whitespace characters that do not fit in any other category
@2@ Each comment is replaced by one space character
@3@ Newlines are kept, and it's unspecified whether non-newline whitespace sequences may be collapsed into single space characters.

===Phase 4===
@1@ [[cpp/preprocessor|Preprocessor]] is executed.
@2@ Each file introduced with the [[cpp/preprocessor/include|#include]] directive goes through phases 1 through 4, recursively.
@3@ At the end of this phase, all preprocessor directives are removed from the source.

===Phase 5===
@1@ All characters in {{rlp|character_literal|character literals}} and {{rlp|string_literal|string literals}} are converted from source character set to execution character set.
@2@ {{rlp|escape|Escape sequences}} and universal character names in character literals and non-raw string literals are expanded and converted to execution character set.
If the character specified by universal character name isn't a member of the execution character set, the result is implementation-defined, but is guaranteed to not be a null (wide) character.

===Phase 6===
Adjacent {{rlp|string literal|string literals}} are concatenated.

===Phase 7===
Compilation takes place: the tokens are syntactically and semantically analyzed and translated as a translation unit.

===Phase 8===
Each translation unit is examined to produce a list of required template instantiations, including the ones requested by {{rlp|class_template|explicit instantiations}}). The definitions of the templates are located, the required instantiations are performed to produce ''instantiation units''

===Phase 9===
Translation units, instantiation units, and library components needed to satisfy external references are collected into a program image which contains information needed for execution in its execution environment.

===Notes===
Some compilers don't implement instantiation units (also known as [http://docs.oracle.com/cd/E18659_01/html/821-1383/bkagr.html#scrolltoc template repositories] or [http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=/com.ibm.xlcpp8l.doc/compiler/ref/ruopttrg.htm template registries]) and simply compile each template instantiation at Phase 7, storing the code in the object file where it is implicitly or explicitly requested, and then the linker collapses these compiled instantiations into one at Phase 9

===References===
{{ref std c++11}}
{{ref std | section=2.2 | title=Phases of translation | id=lex.phases}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=2.1 | title=Phases of translation | id=lex.phases}}
{{ref std end}}</text>
      <sha1>2z2dfd031lh4qmahsdnq491lns4balq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/try catch</title>
    <ns>0</ns>
    <id>5203</id>
    <revision>
      <id>71868</id>
      <parentid>69860</parentid>
      <timestamp>2014-06-29T17:17:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>reference to pointer must be reference to const (and it was also a C++14 addition, cwg 388)</comment>
      <text xml:space="preserve" bytes="9239">{{title|try-block}}
{{cpp/language/exceptions/navbar}}

Associates one or more exception handlers (catch-clauses) with a compound statement.

===Syntax===
{{sdsc begin}}
{{sdsc|1=
{{ttb|try}} {{spar|compound-statement}} {{spar|handler-sequence}}
}}
{{sdsc end}}

where {{spar|handler-sequence}} is a sequence of one or more {{spar|handler}}s, which have the following syntax:

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|catch}} {{ttb|(}} {{spar|attr}}{{mark optional}} {{spar|type-specifier-seq}} {{spar|declarator}} {{ttb|)}} {{spar|compound-statement}}
}}
{{sdsc|num=2|1=
{{ttb|catch}} {{ttb|(}} {{spar|attr}}{{mark optional}} {{spar|type-specifier-seq}} {{spar|abstract-declarator}}{{mark optional}} {{ttb|)}} {{spar|compound-statement}}
}}
{{sdsc|num=3|1=
{{ttb|catch}} {{ttb|(}} {{ttb|...}} {{ttb|)}} {{spar|compound-statement}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|compound-statement}} | the brace-enclosed {{rlp|statements#Compound_statement|sequence of statements}} that constututes the body of a function}}
{{par | {{spar|attr}}{{mark c++11}} | optional list of {{rlp|attributes}}, applies to the formal parameter}}
{{par | {{spar|type-specifier-seq}} | part of a formal parameter declaration, same as in a {{rlp|function}} parameter list }}
{{par | {{spar|declarator}} | part of a formal parameter declaration, same as in a {{rlp|function}} parameter list }}
{{par | {{spar|abstract-declarator}} | part of an unnamed formal parameter declaration, same as in {{rlp|function}} parameter list }}
{{par end}}

@1@ Catch-clause that declares a named formal parameter
{{source|try { /* */ } catch(const std::exception&amp; e) { /* */ }
}}
@2@ Catch-clause that declares an unnamed parameter
{{source|try { /* */ } catch(const std::exception&amp;) { /* */ }
}}
@3@ Catch-all handler, which is activated for any exception
{{source|try { /* */ } catch(...) { /* */ }
}}

===Explanation===
:{{small|See {{rlp|throw | throw exceptions}} for more information about throw-expressions}}

A try-block is a {{rlp|statements|statement}}, and as such, can appear anywhere a statement can appear (that is, as one of the statements in a compound statement, including the function body compound statement). See {{rlp|function-try-block}} for the try blocks around function bodies. The following description applies to both try-blocks and {{rlp|function-try-block}}s.

The formal parameter of the catch clause ({{spar|type-specifier-seq}} and {{spar|declarator}} or {{spar|type-specifier-seq}} and {{spar|abstract-declarator}}) determines which types of exceptions cause this catch clause to be entered. It cannot be an {{rlp|reference|rvalue reference type}}, {{rlp|abstract class}}, {{rlp|incomplete type}}, or pointer to incomplete type (except that pointers to (possibly {{rlp|cv}}-qualified) {{c|void}} are allowed). If the type of the formal parameter is array type or function type, it is treated as the corresponding pointer type (similar to {{rlp|function|function declration}})

When an exception of type {{tt|E}} is thrown by any statement in {{spar|compound-statement}}, it is matched against the types of the formal parameters {{tt|T}} of each catch-clause in {{spar|handler-seq}}, in the order in which the catch clauses are listed. The exception is a match if any of the following is true:
* {{tt|E}} and {{tt|T}} are the same type (ignoring top-level cv-qualifiers on {{tt|T}})
* {{tt|T}} is an lvalue-reference to (possibly cv-qualified) {{tt|E}}
* {{tt|T}} is an unambiguous public base class of {{tt|E}}
* {{tt|T}} is a reference to an unambiguous public base class of {{tt|E}}
* {{tt|T}} is a (possibly cv-qualified) pointer {{rev inl|since=c++14|or a reference to a const pointer}}, and {{tt|E}} is also a pointer, which is implicitly convertible to T either by
:* a standard {{rlp|implicit_cast|pointer conversion}}
:* a {{rlp|implicit_cast|qualification conversion}}
* {{tt|T}} is a pointer or a pointer to member {{rev inl|since=c++14|or a reference to a const pointer}}, while {{tt|E}} is {{lc|std::nullptr_t}}.

{{source|
try {
  f();
} catch(const std::overflow_error&amp; e) {
    // this executes if f() throws std::overflow_error (same type rule)
} catch(const std::runtime_error&amp; e) {
    // this executes if f() throws std::underflow_error (base class rule)
} catch(const std::exception&amp; e) {
    // this executes if f() throws std::logic_error (base class rule)
} catch(...) {
    // this executes if f() throws std::string or int or any other unrelated type
}
}}

The catch-all clause {{c|catch(...)}} matched exceptions of any type. If present, it has to be the last catch clause in the {{spar|handler-seq}}. Catch-all block may be used to ensure that no uncaught exceptions can possibly escape from a function that offers  {{rlp|exceptions|nothrow exception guarantee}}.

If no matches are found after all catch-clauses were examined, the exception propagation continues to the containing try-block, as described in {{rlp|throw|throw-expression}}. If there are no containing try-blocks left, {{lc|std::terminate}} is executed.

When entering a catch clause, if its formal parameter is a base class of the exception type, it is {{rlp|copy_initialization|copy-initialized}} from the base class subobject of the exception object. Otherwise, it is copy-initialized from the exception object (this copy is subject to {{rlp|copy elision}}).
{{source|1=
try {
   std::string(&quot;abc&quot;).substr(10); // throws std::length_error
// } catch( std::exception e ) { // copy-initialization from the std::exception base
//     std::cout &lt;&lt; e.what(); // information from length_error is lost
// }
} catch( const std::exception&amp; e ) { // reference to the base of a polymorphic object
     std::cout &lt;&lt; e.what(); // information from length_error printed
}
}}

If the parameter of the catch-clase is a reference type, any changes made to it are reflected in the exception object, and can be observed by another handler if the exception is rethrown with {{c|throw;}}. If the parameter is not a reference, any changes made to it are are local and its lifetime ends when the handler exits.

{{rev begin}}
{{rev |since=c++11|
Within a catch-clause, {{lc|std::current_exception}} can be used to capture the exception in an {{lc|std::exception_ptr}}, and {{lc|std::throw_with_nested}} may be used to build nested exceptions.}}
{{rev end}}

Other than by throwing or rethrowing the exception, the catch-clause after a regular try block (not {{rlp|function-try-block}}) may be exited with a {{rlp|return}}, {{rlp|continue}}, {{rlp|break}}, {{rlp|goto}}, or by reaching the end of its {{spar|compound-statement}}. In any case, this destroys the exception object (unless an instance of {{lc|std::exception_ptr}} exists that refers to it).

===Notes===
The throw-expression {{c|throw NULL;}} is not matched by a pointer catch clause, because the exception object type is {{c|int}}, but {{c|throw nullptr;}} is matched by any pointer or pointer-to-member catch clause.

If a catch-clause for a derived class is placed after the catch-clause for a base class, the derived catch-clause will never be executed.
{{source|1=try {
   f();
} catch(const std::exception&amp; e) {
  // will be executed if f() throws std::runtime_error
} catch(const std::runtime_error&amp; e) {
  // dead code!
}
}}

If {{rlp|goto}} is used to exit a try-block and if any of the destructors of block-scoped automatic variables that are executed by the {{tt|goto}} throw exceptions, those exceptions are caught by the try blocks in which the variables are defined:
{{source|1=
label: try {
          T1 t1;
          try {
              T2 t2;
              if(condition)
                  goto label; // destroys t2, then destroys t1, then jumps to label
           } catch(...) {  } // catches the exception from the destructor of t2
        } catch(...) {  } // catches the exception from the destructor of t1
}}
===Keywords===

{{ltt|cpp/keyword/try}},
{{ltt|cpp/keyword/catch}},
{{ltt|cpp/keyword/throw}}

===Example===
{{example
 | The following example demonstrates several usage cases of the {{tt|try-catch}} block
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
    try {
        std::cout &lt;&lt; &quot;Throwing an integer exception...\n&quot;;
        throw 42;
    } catch( int i ) {
        std::cout &lt;&lt; &quot; the integer exception was caught, with value: &quot; &lt;&lt; i &lt;&lt; '\n';
    }

    try {
        std::cout &lt;&lt; &quot;Creating a vector of size 5... \n&quot;;
        std::vector&lt;int&gt; v(5);
        std::cout &lt;&lt; &quot;Accessing the 11th element of the vector...\n&quot;;
        std::cout &lt;&lt; v.at(10);  // vector::at() throws std::out_of_range
    } catch( const std::exception&amp; e) { // caught by reference to base
        std::cout &lt;&lt; &quot; a standard exception was caught, with message '&quot;
                  &lt;&lt; e.what() &lt;&lt; &quot;'\n&quot;;
    }

}
 | output=
Throwing an integer exception...
 the integer exception was caught, with value: 42
Creating a vector of size 5...
Accessing the 11th element of the vector...
 a standard exception was caught, with message 'out_of_range'
}}

[[de:cpp/language/try catch]]
[[es:cpp/language/try catch]]
[[fr:cpp/language/try catch]]
[[it:cpp/language/try catch]]
[[ja:cpp/language/try catch]]
[[pt:cpp/language/try catch]]
[[ru:cpp/language/try catch]]
[[zh:cpp/language/try catch]]</text>
      <sha1>15ve2gzfjwwrv3cbkipcquscr9sih6f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/type</title>
    <ns>0</ns>
    <id>13105</id>
    <revision>
      <id>72365</id>
      <parentid>72337</parentid>
      <timestamp>2014-08-15T14:33:59Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Incomplete type */</comment>
      <text xml:space="preserve" bytes="8911">{{title|Type}}
{{cpp/language/basics/navbar}}
{{rlp|object|Objects}}, {{rlp|reference}}s, {{rlp|functions}} including {{rlp|template specialization|function template specializations}}, and {{rlp|expressions}} have a property called ''type'', which both restricts the operations that are permitted for those entities and provides semantic meaning to the otherwise generic sequences of bits.

===Type classification===
The C++ type system consists of the following types:
* {{rlp|types|Fundamental types}} (see also {{lc|std::is_fundamental}})
:* The type {{c|void}} (see also {{lc|std::is_void}})
:* The type {{lc|std::nullptr_t}} (see also {{lc|std::is_null_pointer}})
:* Arithmetic types (see also {{lc|std::is_arithmetic}})
::* Floating-point types ({{c|float}}, {{c|double}}, {{c|long double}}) (see also {{lc|std::is_floating_point}})
::* Integral types (see also {{lc|std::is_integral}})
:::* The type {{c|bool}}
:::* Character types
::::* Narrow character types ({{c|char}}, {{c|signed char}}, {{c|unsigned char}})
::::* Wide character types ({{c|char16_t}}, {{c|char32_t}}, {{c|wchar_t}})
:::* Signed integer types ({{c|short}}, {{c|int}}, {{c|long}}, {{c|long long}})
:::* Unsigned integer types ({{c|unsigned short}}, {{c|unsigned int}}, {{c|unsigned long}}, {{c|unsigned long long}})
* Compound types (see also {{lc|std::is_compound}})
:* Reference (see also {{lc|std::is_reference}})
::* {{rlp|reference#Lvalue references|Lvalue reference}} (see also {{lc|std::is_lvalue_reference}})
::* {{rlp|reference#Rvalue references|Rvalue reference}} (see also {{lc|std::is_rvalue_reference}})
:* Pointer (see also {{lc|std::is_pointer}})
::* {{rlp|pointer#Pointers to objects|Pointer to object}}
::* {{rlp|pointer#Pointers to functions|Pointer to function}}
:* Pointer to member (see also {{lc|std::is_member_pointer}})
::* {{rlp|pointer#Pointers to data members|Pointer to data member}} (see also {{lc|std::is_member_object_pointer}})
::* {{rlp|pointer#Pointers to member functions|Pointer to member function}} (see also {{lc|std::is_member_function_pointer}})
:* {{rlp|array|Array}} (see also {{lc|std::is_array}})
:* {{rlp|function|Function}} (see also {{lc|std::is_function}})
:* {{rlp|enum|Enumeration}} (see also {{lc|std::is_enum}})
:* {{rlp|class|Class types}}
::* Non-union class types (see also {{lc|std::is_class}})
::* {{rlp|union|Unions}} (see also {{lc|std::is_union}})

For every type other than reference and function, the type system supports three additional {{rlp|cv|cv-qualified versions}} of that type ({{c|const}}, {{c|volatile}}, and {{c|const volatile}})

Types are grouped in various categories based on their properties:
* ''object type'': any type other than void, function, or reference (that is, a type that an {{rlp|object}} may have). (see also {{lc|std::is_object}})
* ''scalar type'': arithmetic, pointer, enumeration, {{tt|std::nullptr_t}} (see also {{lc|std::is_scalar}})
* {{lc|std::is_trivial}}, {{lc|std::is_pod}}, {{lc|std::is_literal_type}}, and other categories listed in the [[cpp/types | the type traits library]] or as [[cpp/concept|named type requirements]].

===Type naming===
A {{rlp|name}} can be declared to refer to a type by means of
* {{rlp|class}} declaration
* {{rlp|enum}} declaration
* {{rlp|typedef}} declaration
* {{rlp|type alias}} declaration

Types that do not have names often need to be referred to in C++ programs; the syntax for that is known as ''type-id''. The syntax of the type-id that names type T is exactly the syntax of a {{rlp|declarations|declaration}} of a variable or function of type T, with the identifier omitted, except that ''decl-specifier-seq'' of the declaration grammar is constrained to ''type-specifier-seq'', and that new types may not be declared.
{{source|1=
int* p;               // declration of a pointer to int
static_cast&lt;int*&gt;(p); // type-id is &quot;int*&quot;

int a[3];   // declaration of an array of 3 int
new int[3]; // type-id is &quot;int[3]&quot;

int (*(*x[2])())[3];      // declaration of an array of 2 pointers to functions
                          // returning pointer to array of 3 int
new (int (*(*[2])())[3]); // type-id is &quot;int (*(*[2])())[3]&quot;

void f(int); // declaration of a function that takes int and returns void
std::function&lt;void(int)&gt; x = f; // type template parameter is a type-id &quot;void(int)&quot;

std::vector&lt;int&gt; v;       // declaration of a vector of int
sizeof(std::vector&lt;int&gt;); // type-id is &quot;std::vector&lt;int&gt;&quot;

struct { int x; } b;       // creates a new type and declares an object b of that type
sizeof(struct{ int x; });  // error: cannot declare new types

sizeof(static int); // error: storage class specifiers not part of type-specifier-seq
std::function&lt;inline void(int)&gt; f; // error: function specifiers aren't either
}}
The ''declarator'' part of the declaration grammar with the name removed is referred to as ''abstract-declarator''.


''type-id'' may be used in the following situations:
* To specify the target type in {{rlp|expressions#Conversions|cast expressions}}
* As arguments to {{rlp|sizeof}}, {{rlp|alignof}}, {{rlp|alignas}}, {{rlp|new}}, and {{rlp|typeid}}
* On the right hand side of an {{rlp|type alias}} declaration
* As the trailing return type of a {{rlp|function}} declaration
* As the default argument of a {{rlp|class template#Type template parameter|template type parameter}}
* As the template argument for a {{rlp|class template#Template type arguments|template type parameter}}
* in {{rlp|except_spec|dynamic exception specification}}

''type-id'' can be used with some modifications in the following situations:
* In the parameter list of a {{rlp|function#Parameter list|function}} (when the parameter name is omitted), type-id uses ''decl-specifier-seq'' instead of ''type-specifier-seq'' (in particular, some storage class specifiers are allowed)
* In the name of a {{rlp|cast operator|user-defined conversion function}}, the abstract declarator cannot include function or array operators

{{todo|maybe also elaborated type specifier}}
{{todo|8.2[dcl.ambig.res] if it can be compactly summarized}}
{{todo|mention and link to decltype and auto}}

===Static type===
The type of an expression that results from the compile-time analysis of the program is known as the ''static type'' of the expression. The static type does not change while the program is executing.

===Dynamic type===
If some {{rlp|value category|glvalue expression}} refers to a {{rlp|object|polymorphic object}}, the type of its most derived object is known as the dynamic type.
{{source|1=
// given
struct B { virtual ~B() {} }; // polymorphic type
struct D : B {}; // polymorphic type
D d; // most-derived object
B* ptr = &amp;d;
// The static type of (*ptr) is B
// The dynamic type of (*ptr) is D
}}

For prvalue expressions, the dynamic type is always the same as the static type.

===Incomplete type===
The following types are ''incomplete types''
* the type {{c|void}}
* class type that has been declared (e.g. by {{rlp|class#Forward declaration|forward declaration}}) but not defined
* array of unknown size
* array of elements of incomplete type
* {{rlp|enum|enumeration type}} from the point of declaration until its underlying type is determined

Any of the following contexts requires class {{tt|T}} to be complete:
* {{rlp|function|definition}} or function call to a function with return type {{tt|T}} or argument type {{tt|T}}&lt;!-- there are exceptions, e.g., when the function call is the operand of decltype --&gt;
* {{rlp|definition}} of an object of type {{tt|T}}
* declaration of a {{rlp|data members|non-static class data member}} of type {{tt|T}}
* {{rlp|new|new-expression}} for an object of type {{tt|T}} or an array whose element type is {{tt|T}}
* {{rlp|implicit cast#Lvalue to rvalue conversion|lvalue-to-rvalue conversion}} applied to a glvalue of type {{tt|T}}
* an {{rlp|implicit cast|implicit}} or {{rlp|explicit cast|explicit}} conversion to type {{tt|T}}
* a {{rlp|implicit cast|standard conversion}}, {{rlp|dynamic_cast}}, or {{rlp|static_cast}} to type {{tt|T*}} or {{tt|T&amp;}}, except when converting from the [[cpp/types/NULL|null pointer constant]] or from a {{rlp|pointer#Pointers to void|pointer to void}}
* {{rlp|operator member access|class member access operator}} applied to an expression of type {{tt|T}}
* {{rlp|typeid}}, {{rlp|sizeof}}, or {{rlp|alignof}} operator applied to type {{tt|T}}
* {{rlp|operator arithmetic|arithmetic operator}} applied to a pointer to {{tt|T}}
* definition of a class with base class {{tt|T}}
* assignment to an lvalue of type {{tt|T}}
* a {{rlp|try catch|catch-clause}} for an exception of type {{tt|T}}, {{tt|T&amp;}}, or {{tt|T*}}
(In general, when the size and layout of {{tt|T}} must be known)

If any of these situations occur in a translation unit, the definition of the type must appear in the same translation unit. Otherwise, it is not required.

{{todo|rules for completing the incomplete types from §3.9[basic.types]/6}}</text>
      <sha1>j4hj64y7hcij6wst3x2lt9f2fqqkri6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/type alias</title>
    <ns>0</ns>
    <id>5426</id>
    <revision>
      <id>67718</id>
      <parentid>66683</parentid>
      <timestamp>2014-02-21T19:17:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>navbar</comment>
      <text xml:space="preserve" bytes="4619">{{title|Type alias, alias template {{mark since c++11}}}}
{{cpp/language/declarations/navbar}}

Type alias is a name that refers to a previously defined type (similar to {{rlp|typedef}})

Alias template is a name that refers to a family of types.

===Syntax===

Alias declarations are {{rlp|declarations|block declarations}} with the following syntax

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|using}} {{spar|identifier}} {{spar|attr}}{{mark optional}} {{ttb|{{=}}}} {{spar|type-id}} {{ttb|;}}
}}
{{sdsc |num=2| {{ttb|template}} {{ttb|&lt;}} {{spar|template-parameter-list}} {{ttb|&gt;}}
{{ttb|using}} {{spar|identifier}} {{spar|attr}}{{mark optional}} {{ttb|{{=}}}} {{spar|type-id}} {{ttb|;}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of [[cpp/language/attributes|attributes]]}}
{{par | {{spar|identifiers}} | the name that is introduced by this declaration, which becomes either a type name (1) or a template name (2) }}
{{par | {{spar|template-parameter-list}} | template parameter list, as in {{rlp|class template|template declaration}} }}
{{par | {{spar|type-id}} | abstract declarator or any other valid {{rlp|type|type-id}}. For alias template declaration, {{spar|type_id}} cannot directly or indirectly refer to {{spar|identifier}} }}
{{par end}}

===Explanation===

@1@ A type alias declaration introduces a name which can be used as a synonym for the type denoted by {{spar|type-id}}. It does not introduce a new type and it cannot change the meaning of an existing type name. There is no difference between a type alias declaration and {{rlp|typedef}} declaration.
@2@ An alias template is a template which, when specialized, is equivalent to the result of substituting the template arguments of the alias template for the template parameters in the {{spar|type-id}}
{{source|1=
template&lt;class T&gt; struct Alloc {};
template&lt;class T&gt; using Vec = vector&lt;T, Alloc&lt;T&gt;&gt;; // type-id is vector&lt;T, Alloc&lt;T&gt;&gt;
Vec&lt;int&gt; v; // Vec&lt;int&gt; is the same as vector&lt;int, Alloc&lt;int&gt;&gt;
}}
The type produced when specializing an alias template is not allowed to directly or indirectly make use of its own type:
{{source|1=
template &lt;class T&gt; struct A;
template &lt;class T&gt; using B = typename A&lt;T&gt;::U; // type-id is A&lt;T&gt;::U
template &lt;class T&gt; struct A {
    typedef B&lt;T&gt; U;
};
B&lt;short&gt; b; // error: B&lt;short&gt; uses its own type via A&lt;short&gt;::U
}}
Alias templates are never deduced by {{rlp|function_template#Template argument deduction|template argument deduction}} when deducing a template template parameter.
It is not possible to {{rlp|partial specialization|partially}} or {{rlp|template specialization|fully specialize}} an alias template.

===Example===

{{example
  |
  | code=
#include &lt;string&gt;
#include &lt;ios&gt;
#include &lt;vector&gt;
#include &lt;type_traits&gt;

// type alias, identical to
// typedef std::ios_base::fmtflags flags;
using flags = std::ios_base::fmtflags;
// the name 'flags' now denotes a type:
flags fl = std::ios_base::dec;

// type alias, identical to
// typedef void (*func)(int, int);
using func = void (*) (int,int);
// the name 'func' now denotes a pointer to function:
void example(int, int) {}
func fn = example;

// template type alias
template&lt;class T&gt; using ptr = T*; 
// the name 'ptr&lt;T&gt;' is now an alias for pointer to T
ptr&lt;int&gt; x;

// type alias used to hide a template parameter 
template &lt;class CharT&gt; using mystring = 
    std::basic_string&lt;CharT,std::char_traits&lt;CharT&gt;&gt;;
mystring&lt;char&gt; str;

// type alias can introduce a member typedef name
template&lt;typename T&gt;
struct Container {
    using value_type = T;
};
// which can be used in generic programming
template&lt;typename Container&gt;
void fn2(const Container&amp; c)
{
    typename Container::value_type n;
}

// type alias used to simplify the syntax of std::enable_if
template &lt;typename T&gt; using Invoke =
    typename T::type;
template &lt;typename Condition&gt; using EnableIf =
    Invoke&lt;std::enable_if&lt;Condition::value&gt;&gt;;
template &lt;typename T, typename = EnableIf&lt;std::is_polymorphic&lt;T&gt;&gt;&gt;
int fpoly_only(T t) { return 1; } 

struct S { virtual ~S() {} };
int main() 
{
    Container&lt;int&gt; c;
    fn2(c); // Container::value_type will be int in this function

//    fpoly_only(c); // error, enable_if prohibits this
    S s;
    fpoly_only(s); // okay, enable_if allows this
} 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc typedef}}
{{dsc end}}

[[de:cpp/language/type alias]]
[[es:cpp/language/type alias]]
[[fr:cpp/language/type alias]]
[[it:cpp/language/type alias]]
[[ja:cpp/language/type alias]]
[[pt:cpp/language/type alias]]
[[ru:cpp/language/type alias]]
[[zh:cpp/language/type alias]]</text>
      <sha1>tsgkhc4lv1vlyn02yr0o7ffg56xvfgo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/typedef</title>
    <ns>0</ns>
    <id>2396</id>
    <revision>
      <id>72098</id>
      <parentid>67717</parentid>
      <timestamp>2014-07-14T17:42:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="2488">{{title|Typedef declaration}}
{{cpp/language/declarations/navbar}}

The typedef declaration provides a way to create an alias that can be used anywhere in place of a (possibly complex) type name.

===Syntax===

{{sdsc begin}}
{{sdsc |
{{ttb|typedef}} {{spar|type_declaration}}{{ttb|;}}
}}
{{sdsc end}}

===Explanation===
The declaration that follows the keyword {{c|typedef}} is otherwise usual {{rlp|declarations|simple declaration}} (except that other type specifiers, e.g. {{c|static}}, cannot be used). It may declare one or many identifiers on the same line (e.g. int and a pointer to int), it may declare array and function types, pointers and references, class types, etc. Every identifier introduced in this declaration becomes a typedef-name rather than an object that it would become if the keyword {{c|typedef}} was removed.

The typedef-names are aliases for existing types, and are not declarations of new types. Typedef cannot be used to change the meaning of an existing type name (including a typedef-name). Once declared, a typedef-name may only be redeclared to refer to the same type again. Typedef names are only in effect in the scope where they are visible: different functions or class declarations may define identically-named types with different meaning.

===Keywords===
{{ltt|cpp/keyword/typedef}}

===Example===
{{source|code=
// simple typedef
typedef unsigned long ulong;

// the following two objects have the same type
unsigned long l1;
ulong l2;

// more complicated typedef
typedef int int_t, *intp_t, (&amp;fp)(int, ulong), arr_t[10];

// the following two objects have the same type
int a1[10];
arr_t a2;

// common C idiom to avoid having to write &quot;struct S&quot;
typedef struct {int a; int b;} S, *pS;

// the following two objects have the same type
pS ps1;
S* ps2;

// error: conflicting type specifier
// typedef static unsigned int uint;

// std::add_const, like many other metafunctions, use member typedefs
template&lt; class T&gt;
struct add_const {
    typedef const T type;
};
}}

===See also===
{{dsc begin}}
[[cpp/language/type_alias|type aliases]] provide the same functionality as typedefs using a different syntax, and are also applicable to template names.
{{dsc see c | c/language/typedef | Typedef declaration}}
{{dsc end}}

[[de:cpp/language/typedef]]
[[es:cpp/language/typedef]]
[[fr:cpp/language/typedef]]
[[it:cpp/language/typedef]]
[[ja:cpp/language/typedef]]
[[pt:cpp/language/typedef]]
[[ru:cpp/language/typedef]]
[[zh:cpp/language/typedef]]</text>
      <sha1>6opg6260e5dqhmt90z4yh98ey6s8mt9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/typeid</title>
    <ns>0</ns>
    <id>715</id>
    <revision>
      <id>69398</id>
      <parentid>69397</parentid>
      <timestamp>2014-04-05T18:41:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 69397 by [[Special:Contributions/Chraac|Chraac]] ([[User talk:Chraac|talk]]) see comment before the example</comment>
      <text xml:space="preserve" bytes="5483">{{title|typeid operator}}
{{cpp/language/expressions/navbar}}
Queries information of a type.

Used where the [[cpp/language/type#Dynamic type|dynamic type]] of a [[cpp/language/object#Polymorphic objects|polymorphic object]] must be known and for static type identification.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|typeid(}} {{spar|type}} {{ttb|)}}}}
{{sdsc | num=2 | {{ttb|typeid(}} {{spar|expression}} {{ttb|)}}}}
{{sdsc end}}

The header [[cpp/header/typeinfo|&lt;typeinfo&gt;]] must be included before using {{tt|typeid}} (if the header is not included, every use of the keyword {{tt|typeid}} makes the program ill-formed.)

The typeid expression is {{rlp|value_category|lvalue expression}} which refers to an object with {{rlp|static|static storage duration}}, of the polymorphic type {{c|const std::type_info}} or of some type derived from it.

===Explanation===

@1@ Refers to a {{c|std::type_info}} object representing the type {{spar|type}}. If {{spar|type}} is a reference type, the result refers to the referenced type.

@2@ Examines the expression {{spar|expression}}

:@a@ If {{spar|expression}} is a {{rlp|value category|glvalue expression}} that identifies an object of a polymorphic type (that is, a class that declares or inherits at least one {{rlp|virtual|virtual function}}), the {{tt|typeid}} expression evaluates the expression and then refers to the {{c|std::type_info}} object that represents the dynamic type of the expression. If the result of the evaluated expression is a null pointer, an exception of type {{lc|std::bad_typeid}} or a type derived from {{lc|std::bad_typeid}} is thrown.

:@b@ If {{spar|expression}} is not a glvalue expression of polymorphic type, {{tt|typeid}} does not evaluate the expression, and the {{c|std::type_info}} object it identifies represents the static type of the expression. Lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversions are not performed.

In all cases, cv-qualifiers are ignored by typeid (that is, {{c|typeid(T){{==}}typeid(const T)}})

{{tt|typeid}} cannot be applied to an {{rlp|incomplete type}}.

If {{tt|typeid}} is used on an object under construction or destruction (in a destructor or in a constructor, including constructor's {{rlp|initializer_list|initializer list}} or {{rlp|data_members#Member_initialization|brace-or-equal initializers}}), then the {{c|std::type_info}} object referred to by this {{tt|typeid}} represents the class that is being constructed or destroyed even if it is not the most-derived class.

===Keywords===
{{ltt|cpp/keyword/typeid}}

===Notes===
When applied to an expression of polymorphic type, evaluation of a typeid expression may involve runtime overhead (a virtual table lookup), otherwise typeid expression is resolved at compile time.

It is unspecified whether the destructor for the object referred to by {{tt|typeid}} is executed at the end of the program.

===Example===
{{example | the example showing output using one of the implementations where typeinfo::name prints full type names; filter through c++filt -t if using gcc or similar
| p=true
| code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;typeinfo&gt;

struct Base {}; // non-polymorphic
struct Derived : Base {};

struct Base2 { virtual void foo() {} }; // polymorphic
struct Derived2 : Base2 {};

int main()
{
    int myint = 50;
    std::string mystr = &quot;string&quot;;
    double *mydoubleptr = nullptr;

    std::cout &lt;&lt; &quot;myint has type: &quot; &lt;&lt; typeid(myint).name() &lt;&lt; '\n'
              &lt;&lt; &quot;mystr has type: &quot; &lt;&lt; typeid(mystr).name() &lt;&lt; '\n'
              &lt;&lt; &quot;mydoubleptr has type: &quot; &lt;&lt; typeid(mydoubleptr).name() &lt;&lt; '\n';

    // std::cout &lt;&lt; myint is a glvalue expression of polymorphic type; it is evaluated
    const std::type_info&amp; r1 = typeid(std::cout &lt;&lt; myint);
    std::cout &lt;&lt; &quot;std::cout&lt;&lt;myint has type : &quot; &lt;&lt; r1.name() &lt;&lt; '\n';

    // std::printf() is not a glvalue expression of polymorphic type; NOT evaluated
    const std::type_info&amp; r2 = typeid(std::printf(&quot;%d\n&quot;, myint));
    std::cout &lt;&lt; &quot;printf(\&quot;%d\\n\&quot;,myint) has type : &quot; &lt;&lt; r2.name() &lt;&lt; '\n';

    // Non-polymorphic lvalue is a static type
    Derived d1;
    Base&amp; b1 = d1;
    std::cout &lt;&lt; &quot;reference to non-polymorphic base: &quot; &lt;&lt; typeid(b1).name() &lt;&lt; '\n';

    Derived2 d2;
    Base2&amp; b2 = d2;
    std::cout &lt;&lt; &quot;reference to polymorphic base: &quot; &lt;&lt; typeid(b2).name() &lt;&lt; '\n';

    try {
        // dereferencing a null pointer: okay for a non-polymoprhic expression
        std::cout &lt;&lt; &quot;mydoubleptr points to &quot; &lt;&lt; typeid(*mydoubleptr).name() &lt;&lt; '\n'; 
        // dereferencing a null pointer: not okay for a polymorphic lvalue
        Derived2* bad_ptr = NULL;
        std::cout &lt;&lt; &quot;bad_ptr points to... &quot;;
        std::cout &lt;&lt; typeid(*bad_ptr).name() &lt;&lt; '\n';
    } catch(const std::bad_typeid&amp; e) {
         std::cout &lt;&lt; &quot; caught &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
myint has type: int
mystr has type: std::basic_string&lt;char, std::char_traits&lt;char&gt;, std::allocator&lt;char&gt; &gt;
mydoubleptr has type: double*
50std::cout&lt;&lt;myint has type : std::basic_ostream&lt;char, std::char_traits&lt;char&gt; &gt;
printf(&quot;%d\n&quot;,myint) has type : int
reference to non-polymorphic base: Base
reference to polymorphic base: Derived2
mydoubleptr points to double
bad_ptr points to...  caught std::bad_typeid
}}

[[de:cpp/language/typeid]]
[[es:cpp/language/typeid]]
[[fr:cpp/language/typeid]]
[[it:cpp/language/typeid]]
[[ja:cpp/language/typeid]]
[[pt:cpp/language/typeid]]
[[ru:cpp/language/typeid]]
[[zh:cpp/language/typeid]]</text>
      <sha1>3pqg7s6vpghi2pwpwrhuzdijtlq8nbm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/types</title>
    <ns>0</ns>
    <id>716</id>
    <revision>
      <id>72000</id>
      <parentid>70229</parentid>
      <timestamp>2014-07-08T11:25:41Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>void deserves its part here or anywhere</comment>
      <text xml:space="preserve" bytes="9894">{{title|Fundamental types}}
{{cpp/language/basics/navbar}}

&lt;small&gt;(See also {{rlp|type}} for type system overview and [[cpp/types | the list of type-related utilities]] that are provided by the C++ library)&lt;/small&gt;

===Void type===

:{{c|void}} - type with an empty set of values. It is an {{rlp|incomplete type}} that cannot be completed (consequently, objects of type {{tt|void}} are disallowed). There are no {{rlp|array}}s of {{tt|void}}, nor {{rlp|reference}}s to {{tt|void}}. However, {{rlp|pointer#Pointers to void|pointers to {{tt|void}}}} and {{rlp|function}}s returning type {{tt|void}} (''procedures'' in other languages) are permitted.

==={{lc|std::nullptr_t}}===

===Boolean type===

:{{c|bool}} - type, capable of holding one of the two values: {{c|true}} or {{c|false}}.

===Character types===

:{{c|signed char}} - type for signed character representation.
:{{c|unsigned char}} - type for unsigned character representation.
:{{c|char}} - type for character representation which can be most efficiently processed on the target system (equivalent to either {{c|signed char}} or {{c|unsigned char}}, but still different type).

:{{c|wchar_t}} - type for wide character representation
{{rev begin}}
{{rev|since=c++11|
:{{c|char16_t}} - type for UTF-16 character representation
:{{c|char32_t}} - type for UTF-32 character representation
}}{{rev end}}

===Integer types===

:{{c|int}} - basic integer type. Can be omitted if any of the modifiers are present. If no length modifiers are present, guaranteed to have width of at least 16 bits. However, on 32/64 bit systems it is almost exclusively guaranteed to have width of at least 32 bits (see below).

====Modifiers====

Modifies the integer type. Can be mixed in any order. Only one of each group can be present in type name.

'''Signedness'''

:{{c|signed}} - target type will have signed representation (this is the default if omitted)
:{{c|unsigned}} - target type will have unsigned representation

'''Size'''

:{{c|short}} - target type will be optimized for space and will have width of at least 16 bits.
:{{c|long}} - target type will have width of at least 32 bits.
{{rev begin}}
{{rev|since=c++11|
:{{c|long long}} - target type will have width of at least 64 bits.
}}{{rev end}}

====Properties====

The following table summarizes all available integer types and their properties:

{| class=&quot;wikitable&quot; style=&quot;text-align:center;&quot;
|-
! rowspan=&quot;2&quot; | Type specifier 
! rowspan=&quot;2&quot; | Equivalent type 
! colspan=&quot;5&quot; | Width in bits by data model
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
! C++ standard 
! LP32
! ILP32
! LLP64
! LP64
|-
| {{left|{{c|short}}}}
| rowspan=&quot;4&quot; | {{c|short int}}
| rowspan=&quot;6&quot; | at least&lt;br&gt; '''16'''  
| rowspan=&quot;6&quot; | '''16'''  
| rowspan=&quot;6&quot; | '''16'''  
| rowspan=&quot;6&quot; | '''16'''  
| rowspan=&quot;6&quot; | '''16'''  
|-
| {{left|{{c|short int}}}}
|-
| {{left|{{c|signed short}}}}
|-
| {{left|{{c|signed short int}}}}
|-
| {{left|{{c|unsigned short}}}}
| rowspan=&quot;2&quot; | {{c|unsigned short int}}
|-
| {{left|{{c|unsigned short int}}}}
|-
| {{left|{{c|int}}}}
| rowspan=&quot;3&quot; | {{c|int}}  
| rowspan=&quot;5&quot; | at least&lt;br&gt; '''16'''  
| rowspan=&quot;5&quot; | '''16'''  
| rowspan=&quot;5&quot; | '''32'''  
| rowspan=&quot;5&quot; | '''32'''  
| rowspan=&quot;5&quot; | '''32''' 
|-
| {{left|{{c|signed}}}}
|-
| {{left|{{c|signed int}}}}
|-
| {{left|{{c|unsigned}}}}
| rowspan=&quot;2&quot; | {{c|unsigned int}}
|-
| {{left|{{c|unsigned int}}}}
|-
| {{left|{{c|long}}}}
| rowspan=&quot;4&quot; | {{c|long int}}  
| rowspan=&quot;6&quot; | at least&lt;br&gt; '''32'''  
| rowspan=&quot;6&quot; | '''32'''  
| rowspan=&quot;6&quot; | '''32'''  
| rowspan=&quot;6&quot; | '''32'''  
| rowspan=&quot;6&quot; | '''64'''  
|-
| {{left|{{c|long int}}}}
|-
| {{left|{{c|signed long}}}}
|-
| {{left|{{c|signed long int}}}}
|-
| {{left|{{c|unsigned long}}}}
| rowspan=&quot;2&quot; | {{c|unsigned long int}}
|-
| {{left|{{c|unsigned long int}}}}
|-
| {{left|{{c|long long}}}}
| rowspan=&quot;4&quot; | {{c|long long int}} &lt;br&gt; {{mark c++11}}
| rowspan=&quot;6&quot; | at least&lt;br&gt; '''64'''  
| rowspan=&quot;6&quot; | '''64'''  
| rowspan=&quot;6&quot; | '''64'''  
| rowspan=&quot;6&quot; | '''64'''  
| rowspan=&quot;6&quot; | '''64'''  
|-
| {{left|{{c|long long int}}}}
|-
| {{left|{{c|signed long long}}}}
|-
| {{left|{{c|signed long long int}}}}
|-
| {{left|{{c|unsigned long long}}}}
| rowspan=&quot;2&quot; | {{c|unsigned long long int}} &lt;br&gt; {{mark c++11}}
|-
| {{left|{{c|unsigned long long int}}}}
|}

Besides the minimal bit counts, the C++ Standard guarantees that

:{{c|1=1 == sizeof(char) &lt;= sizeof(short) &lt;= sizeof(int) &lt;= sizeof(long) &lt;= sizeof(long long)}}.

Note: this allows the extreme case in which [[enwiki:Byte|bytes]] are sized 64 bits, all types (including {{c|char}}) are 64 bits wide, and {{c|sizeof}} returns 1 for every type.

Note: integer arithmetic is defined differently for the signed and unsigned integer types. See {{rlp|operator_arithmetic|arithmetic operators}}, in particular  {{rlp|operator_arithmetic#Overflows|integer overflows}}.

====Data models====

The choices made by each implementation about the sizes of the fundamental types are collectively known as ''data model''. Four data models found wide acceptance:

32 bit systems:

:*'''LP32''' or '''2/4/4''' (int is 16-bit, long and pointer are 32-bit)
::* Win16 API
:*'''ILP32''' or '''4/4/4''' (int, long, and pointer are 32-bit);
::* Win32 API
::* Unix and Unix-like systems (Linux, Mac OS X)

64 bit systems:

:* '''LLP64''' or '''4/4/8''' (int and long are 32-bit, pointer is 64-bit)
::* Win64 API
:* '''LP64''' or '''4/8/8''' (int is 32-bit, long and pointer are 64-bit)
::* Unix and Unix-like systems (Linux, Mac OS X)

Other models are very rare. For example, '''ILP64''' ('''8/8/8''': int, long, and pointer are 64-bit) only appeared in some early 64-bit Unix systems (e.g. Unicos on Cray).

===Floating point types===

:{{c|float}} - single precision floating point type. Usually IEEE-754 32 bit floating point type

:{{c|double}} - double precision floating point type. Usually IEEE-754 64 bit floating point type

:{{c|long double}} - extended precision floating point type. Does not necessarily map to types mandated by IEEE-754. Usually 80-bit x87 floating point type on x86 and x86-64 architectures.

===Range of values===

The following table provides a reference for the limits of common numeric representations. As the C++ Standard allows any signed integer representation, the table gives both the minimum guaranteed requirements (which correspond to the limits of [[enwiki:One's complement|one's complement]] or [[enwiki:Signed_number_representations#Sign-and-magnitude_method|sign-and-magnitude]]) and the limits of the most commonly used implementation, [[enwiki:Two's complement|two's complement]]. All popular data models (including all of ILP32, LP32, LP64, LLP64) use two's complement representation, though.

{| class=&quot;wikitable&quot; style=&quot;text-align:center;&quot;
|-
! rowspan=2 | Type
! rowspan=2 | Size in bits
! rowspan=2 | Format
! colspan=2 | Value range
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
! Approximate
! Exact
|-
! rowspan=3 | character
| rowspan=3 | 8 
| signed {{small|(one's complement)}}
| colspan=2 | '''-127''' to '''127'''{{mark until c++14}}&lt;!-- CWG 1759, u8 string literals require 256 distinct values --&gt;
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| signed {{small|(two's complement)}}
| colspan=2 | '''-128''' to '''127'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| unsigned
| colspan=2 | '''0''' to '''255'''
|-
|-
! rowspan=9 | integral
| rowspan=3 | 16
| signed {{small|(one's complement)}}
| rowspan=2 | '''± 3.27 · 10&lt;sup&gt;4&lt;/sup&gt;'''
| '''-32767''' to '''32767'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| signed {{small|(two's complement)}}
&lt;!-- --&gt;
| '''-32768''' to '''32767'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| unsigned
| '''0''' to '''6.55 · 10&lt;sup&gt;4&lt;/sup&gt;'''  
| '''0''' to '''65535'''
|-
&lt;!-- --&gt;
| rowspan=3 | 32 
| signed {{small|(one's complement)}}
| rowspan=2 | '''± 2.14 · 10&lt;sup&gt;9&lt;/sup&gt;'''
| '''-2,147,483,647''' to '''2,147,483,647'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| signed {{small|(two's complement)}}
&lt;!-- --&gt;
| '''-2,147,483,648''' to '''2,147,483,647'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| unsigned
| '''0''' to '''4.29 · 10&lt;sup&gt;9&lt;/sup&gt;'''   
| '''0''' to '''4,294,967,295'''
|-
&lt;!-- --&gt;
| rowspan=3 | 64 
| signed {{small|(one's complement)}}
| rowspan=2 | '''± 9.22 · 10&lt;sup&gt;18&lt;/sup&gt;'''
| '''-9,223,372,036,854,775,807''' to '''9,223,372,036,854,775,807'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| signed {{small|(two's complement)}}
&lt;!-- --&gt;
| '''-9,223,372,036,854,775,808''' to '''9,223,372,036,854,775,807'''
|-
&lt;!-- --&gt;
&lt;!-- --&gt;
| unsigned
| '''0''' to '''1.84 · 10&lt;sup&gt;19&lt;/sup&gt;'''
| '''0''' to '''18,446,744,073,709,551,615'''
|-
! rowspan=&quot;2&quot; | floating&lt;br&gt; point
| 32 
| [[enwiki:IEEE-754|IEEE-754]]
| '''± 3.4 · 10&lt;sup&gt;± 38&lt;/sup&gt;'''&lt;br&gt; {{small|(~7 digits)}}
|&lt;div&gt;
*min subnormal: '''± 1.401,298,4 · 10&lt;sup&gt;-47&lt;/sup&gt;'''
*min normal: '''± 1.175,494,3 · 10&lt;sup&gt;-38&lt;/sup&gt;'''
*max: '''± 3.402,823,4 · 10&lt;sup&gt;38&lt;/sup&gt;
&lt;/div&gt;
|-
&lt;!-- --&gt;
| 64 
| IEEE-754
| '''± 1.7 · 10&lt;sup&gt;± 308&lt;/sup&gt;'''&lt;br&gt; {{small|(~15 digits)}}
| &lt;div&gt;
*min subnormal: '''± 4.940,656,458,412 · 10&lt;sup&gt;-324&lt;/sup&gt;'''
*min normal: '''± 2.225,073,858,507,201,4 · 10&lt;sup&gt;-308&lt;/sup&gt;'''
*max: '''± 1.797,693,134,862,315,7 · 10&lt;sup&gt;308&lt;/sup&gt;
&lt;/div&gt;
|}

===Keywords===

{{ltt|cpp/keyword/bool}}, 
{{ltt|cpp/keyword/true}}, 
{{ltt|cpp/keyword/false}}, 
{{ltt|cpp/keyword/char}}, 
{{ltt|cpp/keyword/wchar_t}},
{{ltt|cpp/keyword/char16_t}},
{{ltt|cpp/keyword/char32_t}},
{{ltt|cpp/keyword/int}},
{{ltt|cpp/keyword/short}},
{{ltt|cpp/keyword/long}},
{{ltt|cpp/keyword/signed}},
{{ltt|cpp/keyword/unsigned}},
{{ltt|cpp/keyword/float}},
{{ltt|cpp/keyword/double}}

===See also===
* {{rlp | type             | the C++ type system overview}} 
* {{rlp | cv               | const-volatility (cv) specifiers and qualifiers}}
* {{rlp | storage_duration | storage duration specifiers}}

[[ar:cpp/language/types]]
[[de:cpp/language/types]]
[[es:cpp/language/types]]
[[fr:cpp/language/types]]
[[it:cpp/language/types]]
[[ja:cpp/language/types]]
[[pt:cpp/language/types]]
[[ru:cpp/language/types]]
[[zh:cpp/language/types]]</text>
      <sha1>jml0pvrt88fxn73h5isyiu7pacy3yt0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/union</title>
    <ns>0</ns>
    <id>5526</id>
    <revision>
      <id>71671</id>
      <parentid>68029</parentid>
      <timestamp>2014-06-19T02:47:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>cwg 1375 (no references to anon unions)</comment>
      <text xml:space="preserve" bytes="6139">{{title|Union declaration}}
{{cpp/language/navbar}}

A union is a special class type that can hold only one of its non-static {{rlp|data_members|data members}} at a time.

The class specifier for a union declaration is similar to {{rlp|class|class or struct}} declaration:

{{sdsc begin}}
{{sdsc|1=
{{ttb|union}} {{spar|attr}} {{spar|class-head-name}} {{ttb|{ }} {{spar|member-specification}} {{ttb|} }}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | optional sequence of any number of {{rlp|attributes}} }}
{{par | {{spar|class-head-name}} | the name of the union that's being defined. Optionally prepended by {{spar|nested-name-specifier}} (sequence of names and scope-resolution operators, ending with scope-resolution operator). The name may be omitted, in which case the union is ''unnamed''}}
{{par | {{spar|member-specification}} | list of access specifiers, member object and member function declarations and definitions.}}
{{par end}}

A union can have member functions (including constructors and destructors), but not virtual functions. 

A union cannot have base classes and cannot be used as a base class.

A union cannot have data members of reference types.
{{rev begin}}
{{rev | until=c++11 | Unions cannot contain a non-static data member with a non-trivial special member function ({{rlp|copy_constructor|copy constructor}}, {{rlp|as_operator|copy-assignment}} operator, or {{rlp|destructor}}).
}}
{{rev | since=c++11 | If a union contains a non-static data member with a non-trivial special member function ({{rlp|copy_constructor|copy}}/{{rlp|move_constructor|move}} constructor, {{rlp|as_operator|copy}}/{{rlp|move_operator|move}} assignment, or {{rlp|destructor}}) that function is  deleted by default in the union and needs to be defined explicitly by the programmer.
At most one data member can have a {{rlp|data_members|brace-or-equals initializer}}
}}
{{rev end}}

Just like in {{rlp|classes|struct}} declaration, the default member access in a union is {{rlp|access|public:}}.

===Explanation===
The union is only as big as necessary to hold its largest data member. The other data members are allocated in the same bytes as part of that largest member. The details of that allocation are implementation-defined, and it's undefined behavior to read from the member of the union that wasn't most recently written as it violates {{rlp|reinterpret_cast#Type aliasing|type aliasing}}. Many compilers implement, as a non-standard language extension, the ability to read inactive members of a union.

{{source|1=
#include &lt;iostream&gt;
union S {
    std::int32_t n; // occupies 4 bytes
    std::uint16_t s[2]; // occupies 4 bytes
    std::uint8_t c; // occupies 1 byte
}; // the whole union occupies 4 bytes

int main()
{
    S s = {0x12345678}; // initalizes the first member, s.n is now the active member
    // at this point, reading from s.s or s.c is UB
    std::cout &lt;&lt; std::hex &lt;&lt; &quot;s.n = &quot; &lt;&lt; s.n &lt;&lt; '\n';
    s.s[0] = 0x0011; // s.s is now the active member
    // at this point, reading from n or c is UB but most compilers define this
    std::cout &lt;&lt; &quot;s.c is now &quot; &lt;&lt; +s.c &lt;&lt; '\n' // 11 or 00, depending on platform
              &lt;&lt; &quot;s.n is now &quot; &lt;&lt; s.n &lt;&lt; '\n'; // 12340011 or 00115678 
}
}}

Each member is allocated as if it is the only member of the class, which is why {{tt|s.c}} in the example above aliases the first byte of {{tt|s.s[0]}}.

{{rev begin}}
{{rev|since=c++11|
If members of a union are classes with user-defined constructors and destructors, to switch the active member, explicit destructor and placement new are generally needed:

{{source|1=#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
union S {
    std::string str;
    std::vector&lt;int&gt; vec;
    ~S() {} // needs to know which member is active, only possible in union-like class 
}; // the whole union occupies max(sizeof(string), sizeof(vector&lt;int&gt;)

int main()
{
    S s = {&quot;Hello, world&quot;};
    // at this point, reading from s.vec is UB
    std::cout &lt;&lt; &quot;s.str = &quot; &lt;&lt; s.str &lt;&lt; '\n';
    s.str.~basic_string&lt;char&gt;();
    new (&amp;s.vec) std::vector&lt;int&gt;;
    // now, s.vec is the active member of the union
    s.vec.push_back(10);
    std::cout &lt;&lt; s.vec.size() &lt;&lt; '\n';
    s.vec.~vector&lt;int&gt;();
}
}}
}}
{{rev end}}

If two union members are standard-layout types, it's well-defined to examine their common subsequence on any compiler.

====Anonymous unions====
An unnamed union definition that does not define any objects, pointers, or references is an ''anonymous union'' definition.

{{sdsc begin}}
{{sdsc|1=
{{ttb|union}} {{ttb|{ }} {{spar|member-specification}} {{ttb|} }} {{ttb|;}}
}}
{{sdsc end}}

Anonymous unions have further restrictions: they cannot have member functions, cannot have static data members, and all their non-static data members must be public.

Members of an anonymous union are injected in the enclosing scope (and must not conflict with other names declared there).

{{source|1=int main()
{
    union { int a; const char* p; };
    a = 1;
    p = &quot;Jennifer&quot;;
}
}}

Namespace-scope anonymous unions must be static.

====Union-like classes====
A ''union-like'' class is any class with at least one anonymous union as a member. The members of that anonymous union are called ''variant members''. Union-like classes can be used to implement [[enwiki:Tagged union|tagged unions]].

{{source|1=#include &lt;iostream&gt;
// S has one non-static data member (tag), three enumerator members, 
// and three variant members (c, n, d)
struct S
{
    enum {CHAR, INT, DOUBLE} tag;
    union {
        char c;
        int n;
        double d;
    };
};

void print_s(const S&amp; s)
{
    switch(s.tag)
    {
        case S::CHAR: std::cout &lt;&lt; s.c &lt;&lt; '\n'; break;
        case S::INT: std::cout &lt;&lt; s.n &lt;&lt; '\n'; break;
        case S::DOUBLE: std::cout &lt;&lt; s.d &lt;&lt; '\n'; break;
    }
}
int main()
{
    S s = {S::CHAR, 'a'};
    print_s(s);
    s.tag = S::INT; s.n = 123;
    print_s(s);
}
}}

[[de:cpp/language/union]]
[[es:cpp/language/union]]
[[fr:cpp/language/union]]
[[it:cpp/language/union]]
[[ja:cpp/language/union]]
[[pt:cpp/language/union]]
[[ru:cpp/language/union]]
[[zh:cpp/language/union]]</text>
      <sha1>oqak053v86zim8qtarupsmr6hfvmo2u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/user literal</title>
    <ns>0</ns>
    <id>5061</id>
    <revision>
      <id>71459</id>
      <parentid>71142</parentid>
      <timestamp>2014-06-11T07:16:25Z</timestamp>
      <contributor>
        <ip>91.217.120.91</ip>
      </contributor>
      <comment>string and character literals was swapped.</comment>
      <text xml:space="preserve" bytes="12327">{{title|User-defined literals {{mark since c++11}}}}
{{cpp/language/expressions/navbar}}

Allows integer, floating-point, character, and string literals to produce objects of user-defined type by defining a user-defined suffix.

===Syntax===
A user-defined literal is an expression of any of the following forms
{{sdsc begin}}
{{sdsc | since=c++11 | num=1 | {{spar|decimal-literal}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=2 | {{spar|octal-literal}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=3 | {{spar|hex-literal}} {{spar|ud-suffix}} }}
{{sdsc | since=c++14 | num=4 | {{spar|binary-literal}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=5 | {{spar|fractional-constant}} {{spar|exponent-part}}{{mark optional}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=6 | {{spar|digit-sequence}} {{spar|exponent-part}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=7 | {{spar|character-literal}} {{spar|ud-suffix}} }}
{{sdsc | since=c++11 | num=8 | {{spar|string-literal}} {{spar|ud-suffix}} }}
{{sdsc end}}
@1-4@ user-defined integer literals, such as {{c|12_km}}
@5-6@ user-defined floating-point literals, such as {{c|0.5_Pa}}
@7@ user-defined character literal, such as {{c|'c'_X}}
@8@ user-defined string literal, such as {{c|&quot;abd&quot;_L}} or {{c|u16&quot;xyz&quot;_M}}

{{par begin}}
{{par | {{spar|decimal-literal}} | same as in {{rlp|integer literal}}, a non-zero decimal digit followed by zero or more decimal digits}}
{{par | {{spar|octal-literal}} | same as in {{rlp|integer literal}}, a zero followed by zero or more octal digits}}
{{par | {{spar|hex-literal}} | same as in {{rlp|integer literal}}, {{tt|0x}} or {{tt|0X}} followed by one or more hexadecimal digits}}
{{par | {{spar|binary-literal}} | same as in {{rlp|integer literal}}, {{tt|0b}} or {{tt|0B}} followed by one or more binary digits}}
{{par | {{spar|digit-sequence}} | same as in {{rlp|floating literal}}, a sequence of decimal digits }}
{{par | {{spar|fractional-constant}} | same as in {{rlp|floating literal}}, either a {{spar|digit-sequence}} followed by a dot ({{c|123.}}) or an optional {{spar|digit-sequence}} followed by a dot and another {{spar|digit-sequence}} ({{c|1.0}} or {{c|.12}}) }}
{{par | {{spar|exponent-part}} | same as in {{rlp|floating literal}}, the letter {{tt|e}} or the letter {{tt|E}} followed by optional sign, followed by {{spar|digit-sequence}}}}
{{par | {{spar|character-literal}} | same as in {{rlp|character literal}} }}
{{par | {{spar|string-literal}} | same as in {{rlp|string literal}}, including raw string literals }}
{{par | {{spar|ud-suffix}} | an identifier, introduced by a ''literal operator'' or a ''literal operator template'' declaration (see below). All {{spar|ud-suffix}}es introduced by a program must begin with the underscore character {{ttb|_}}. The standard library {{spar|ud-suffix}}es do not begin with underscores.  }}
{{par end}}

{{rev begin}}
{{rev|since=c++14|
In the integer and floating-point digit sequences, optional separators {{ttb|'}} are allowed between any two digits and are ignored}}
{{rev end}}

If a token matches a user-defined literal syntax and a regular literal syntax, it is assumed to be a regular literal (that is, it's impossible to overload {{c|LL}} in {{c|123LL}})

When the compiler encounters a user-defined literal with {{spar|ud-suffix}} {{tt|X}}, it performs {{rlp|lookup|unqualified name lookup}}, looking for a function with the name {{tt|operator &quot;&quot; X}}. If the lookup does not find a declaration, the program is ill-formed. Otherwise,
@1@ For user-defined integer literals
:@a@ if the overload set includes a literal operator with the parameter type {{c|unsigned long long}}, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X(nULL)}}, where n is the literal without {{spar|ud-suffix}}
:@b@ otherwise, the overload set must include either, but not both, a raw literal operator or a raw literal operator template. If the overload set includes a raw literal operator, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X(&quot;n&quot;)}}
:@c@ otherwise, if the overload set includes a raw literal operator template, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X&lt;'c1', 'c2', 'c3'..., 'ck'&gt;()}}, where c1..ck are the individual characters of {{tt|n}}.
@2@ For user-defined floating-point literals,
:@a@ If the overload set includes a literal operator with the parameter type {{c|long double}}, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X(fL)}}, where {{tt|f}} is the literal without {{spar|ud-suffix}}
:@b@ otherwise, the overload set must include either, but not both, a raw literal operator or a raw literal operator template. If the overload set includes a raw literal operator, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X(&quot;f&quot;)}}
:@c@ otherwise, if the overload set includes a raw literal operator template, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X&lt;'c1', 'c2', 'c3'..., 'ck'&gt;()}}, where c1..ck are the individual characters of {{tt|f}}.
@3@ For user-defined string literals, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X (str, len)}}, where {{tt|str}} is the literal without {{spar|ud-suffix}} and {{tt|len}} is its length excluding the terminating null character
@4@ For user-defined character literals, the user-defined literal expression is treated as a function call {{c|operator &quot;&quot; X (ch)}}, where {{tt|ch}} is the literal without {{spar|ud-suffix}}

{{source|1=
long double operator &quot;&quot; _w(long double);
std::string operator &quot;&quot; _w(const char16_t*, size_t);
unsigned operator &quot;&quot; _w(const char*);
int main() {
    1.2_w; // calls operator &quot;&quot; _w(1.2L)
    u&quot;one&quot;_w; // calls operator &quot;&quot; _w(u&quot;one&quot;, 3)
    12_w; // calls operator &quot;&quot; _w(&quot;12&quot;)
    &quot;two&quot;_w; // error: no applicable literal operator
}
}}

When string literal concatenation takes place in {{rlp|translation phases|translation phase 6}}, user-defined string literals are concatenated as well, and their {{spar|ud-suffix}}es are ignored for the purpose of concatenation, except that only one suffix may appear on all concatenated literals:
{{source|1=
int main() {
    L&quot;A&quot; &quot;B&quot; &quot;C&quot;_x; // OK: same as L&quot;ABC&quot;_x
    &quot;P&quot;_x &quot;Q&quot; &quot;R&quot;_y;// error: two different ud-suffixes (_x and _y)
}
}}

===Literal operators===
The function called by a user-defined literal is known as ''literal operator'' (or, if it's a template, ''literal operator template''). It is declared just like any other {{rlp|function}} or {{rlp|function template}} at namespace scope (it may also be a friend function, an explicit instantiation or specialization of a function template, or introduced by a using-declaration), except for the following restrictions:

The name of this function can have one of the two forms:

{{sdsc begin}}
{{sdsc | {{ttb|operator}} {{ttb|&quot;&quot;}} {{spar|identifier}} }}
{{sdsc | since=c++14 | {{ttb|operator}} {{spar|user-defined-string-literal}} }}
{{sdsc end}}
{{par begin}}
{{par | {{spar|identifier}} | the identifier to use as the {{spar|ud-suffix}} for the user-defined literals that will call this function. Must begin with the underscore {{ttb|_}}: the suffixes that do not begin with the underscore are reserved for the literal operators provided by the standard library.}}
{{par | {{spar|user-defined-string-literal}} | the character sequence {{ttb|&quot;&quot;}} followed, without a space, by the character sequence that becomes the {{spar|ud-suffix}}. This special syntax makes it possible to use language keywords and [[cpp/keywords|reserved identifiers]] as ud-suffixes, and is used by the declaration of {{c|operator &quot;&quot;if}} from the header {{c|&lt;complex&gt;}}. }}
{{par end}}

If the literal operator is a template, it must have an empty parameter list and can have only one template parameter, which must be a non-type template parameter pack with element type char
{{source|1=
template &lt;char...&gt; double operator &quot;&quot; _x();
}}

Only the following parameter lists are allowed on literal operators :
{{sdsc begin}}
{{sdsc | num=1 | {{ttb|(}} {{c|const char *}} {{ttb|)}} }}
{{sdsc | num=2 | {{ttb|(}} {{c|unsigned long long int}} {{ttb|)}} }}
{{sdsc | num=3 | {{ttb|(}} {{c|long double}} {{ttb|)}} }}
{{sdsc | num=4 | {{ttb|(}} {{c|char}} {{ttb|)}} }}
{{sdsc | num=5 | {{ttb|(}} {{c|wchar_t}} {{ttb|)}} }}
{{sdsc | num=6 | {{ttb|(}} {{c|char16_t}} {{ttb|)}} }}
{{sdsc | num=7 | {{ttb|(}} {{c|char32_t}} {{ttb|)}} }}
{{sdsc | num=8 | {{ttb|(}} {{c|const char *}} {{ttb|,}} {{c|std::size_t}} {{ttb|)}} }}
{{sdsc | num=9 | {{ttb|(}} {{c|const wchar_t *}} {{ttb|,}} {{c|std::size_t}} {{ttb|)}} }}
{{sdsc | num=10 | {{ttb|(}} {{c|const char16_t *}} {{ttb|,}} {{c|std::size_t}} {{ttb|)}} }}
{{sdsc | num=11 | {{ttb|(}} {{c|const char32_t *}} {{ttb|,}} {{c|std::size_t}} {{ttb|)}} }}
{{sdsc end}}
@1@ Literal operators with this parameter list are the ''raw literal operators'', used as fallbacks for integer and floating-point user-defined literals (see above)
@2@ Literal operators with these parameter lists are the first-choice literal operator for user-defined integer literals
@3@ Literal operators with these parameter lists are the first-choice literal operator for user-defined floating-point literals
@4-7@ Literal operators with these parameter lists are called by user-defined character literals
@8-11@ Literal operators with these parameter lists are called by user-defined string literals

{{rlp|default arguments|Default arguments}} are not allowed

C {{rlp|language linkage}} is not allowed

Other than the restrictions above, literal operators and literal operator templates are normal functions (and function templates), they can be declared inline or constexpr, they may have internal or external linkage, they can be called explicitly, their addresses can be taken, etc.

{{source|1=
void operator &quot;&quot; _km(long double); // OK, will be called for 1.0_km
std::string operator &quot;&quot; _i18n(const char*, std::size_t); // OK
template &lt;char...&gt; double operator &quot;&quot; _\u03C0(); // OK: (\u03C0 is π)
float operator &quot;&quot;_e(const char*); // OK

float operator &quot;&quot;E(const char*); // error: suffix must begin with underscore
double operator&quot;&quot; _E(double); // error: all names that begin with underscore
                              // followed by uppercase letter are reserved
double operator&quot;&quot;_E(double); // OK: even though _E is reserved &quot;&quot;_E is allowed
}}

===Notes===
Since the introduction of user-defined literals, the code that uses [[c/types/integer|format macro constants for fixed-width integer types]] with no space after the preceding string literal became invalid: {{c|std::printf(&quot;%&quot;PRId64&quot;\n&quot;,INT64_MIN);}} has to be replaced by {{c|std::printf(&quot;%&quot; PRId64&quot;\n&quot;,INT64_MIN);}}

===Examples===
{{example||code=
#include &lt;iostream&gt;

// used as conversion
constexpr long double operator&quot;&quot; _deg ( long double deg )
{
    return deg*3.141592/180;
}

// used with custom type
struct mytype
{
    mytype ( unsigned long long m):m(m){}
    unsigned long long m;
};
mytype operator&quot;&quot; _mytype ( unsigned long long n )
{
    return mytype(n);
}

// used for side-effects
void operator&quot;&quot; _print ( const char* str )
{
    std::cout &lt;&lt; str;
}

int main(){
    double x = 90.0_deg;
    std::cout &lt;&lt; std::fixed &lt;&lt; x &lt;&lt; '\n';
    mytype y = 123_mytype;
    std::cout &lt;&lt; y.m &lt;&lt; '\n';
    0x123ABC_print;
}
|output=
1.570796
123
0x123ABC
}}

===Standard library===
The following literal operators are defined in the standard library

{{dsc begin}}
{{dsc namespace | std::literals::complex_literals | inline=true }}
{{dsc inc | cpp/numeric/dsc operator&quot;&quot;i}}
{{dsc namespace | std::literals::chrono_literals | inline=true }}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;h}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;min}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;s}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;ms}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;us}}
{{dsc inc | cpp/chrono/dsc operator&quot;&quot;ns}}
{{dsc namespace | std::literals::string_literals | inline=true }}
{{dsc inc | cpp/string/basic_string/dsc operator&quot;&quot;s}}
{{dsc end}}



[[de:cpp/language/user literal]]
[[es:cpp/language/user literal]]
[[fr:cpp/language/user literal]]
[[it:cpp/language/user literal]]
[[ja:cpp/language/user literal]]
[[pt:cpp/language/user literal]]
[[ru:cpp/language/user literal]]
[[zh:cpp/language/user literal]]</text>
      <sha1>fbmts0jp1yjfi8wqjjctq7b7g3fv1ev</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/using declaration</title>
    <ns>0</ns>
    <id>9918</id>
    <revision>
      <id>70562</id>
      <parentid>67467</parentid>
      <timestamp>2014-05-25T02:12:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>and here</comment>
      <text xml:space="preserve" bytes="6053">{{title|Using-declaration}}
{{cpp/language/classes/navbar}}
Introduces a name that is defined elsewhere into the declarative region where this using-declaration appears.

{{sdsc begin}}
{{sdsc|num=1|1=
{{ttb|using}} {{ttb|typename}}{{mark optional}} {{spar|nested-name-specifier}} {{spar|unqualified-id}} {{ttb|;}}
}}
{{sdsc|num=2|1=
{{ttb|using}} {{ttb|::}} {{spar|unqualified-id}} {{ttb|;}}
}}
{{sdsc end}}

{{par begin}}
{{par | {{spar|nested-name-specifier}} | a sequence of names and scope resolution operators {{tt|::}}, ending with a scope resolution operator. A single {{tt|::}} refers to the global namespace.}}
{{par | {{spar|unqualified-id}} | an {{rlp|identifiers|id-expression}} }}
{{par | {{spar|typename}} | the keyword {{tt|typename}} may be used as necessary to resolve {{rlp|dependent_name|dependent names}}, when the using-declaration introduces a member type from a base class into a class template }}
{{par end}}

===Explanation===
Using-declarations can be used to introduce namespace members into other namespaces and block scopes, or to introduce base class members into derived class definitions.

====In namespace and block scope====
Using-declaration introduces a member of another namespace into current namespace or block scope
{{source|1=
#include &lt;iostream&gt;
#include &lt;string&gt;
using std::string;
int main()
{
    string str = &quot;Example&quot;;
    using std::cout;
    cout &lt;&lt; str;
}
}}
See {{rlp|namespace}} for details.
====In class definition====
@1@ Using-declaration introduces a member of a base class into the derived class definition, such as to expose a protected member of base as public member of derived. In this case, {{spar|nested-name-specifier}} must name a base class of the one being defined. If the name is the name of an overloaded member function of the base class, all base class member functions with that name are introduced. If the derived class already has a member with the same name, parameter list, and qualifications, the derived class member hides or overrides (doesn't conflict with) the member that is introduced from the base class.
{{example|
code=
#include &lt;iostream&gt;
struct B {
    virtual void f(int) { std::cout &lt;&lt; &quot;B::f\n&quot;; }
    void g(char)        { std::cout &lt;&lt; &quot;B::g\n&quot;; }
    void h(int)         { std::cout &lt;&lt; &quot;B::h\n&quot;; }
 protected:
    int m; // B::m is protected
    typedef int value_type;
};

struct D : B {
    using B::m; // D::m is public
    using B::value_type; // D::value_type is public

    using B::f;
    void f(int) { std::cout &lt;&lt; &quot;D::f\n&quot;; } // D::f(int) overrides B::f(int)
    using B::g;
    void g(int) { std::cout &lt;&lt; &quot;D::g\n&quot;; } // both g(int) and g(char) are visible
                                           // as members of D
    using B::h;
    void h(int) { std::cout &lt;&lt; &quot;D::h\n&quot;; } // D::h(int) hides B::h(int)
};

int main()
{
    D d;
    B&amp; b = d;

//    b.m = 2; // error, B::m is protected
    d.m = 1; // protected B::m is accessible as public D::m
    b.f(1); // calls derived f()
    d.f(1); // calls derived f()
    d.g(1); // calls derived g(int)
    d.g('a'); // calls base g(char)
    b.h(1); // calls base h()
    d.h(1); // calls derived h()
}
|output=
D::f
D::f
D::g
B::g
B::h
D::h
}}
@2@ {{mark since c++11}} If the using-declaration refers to a constructor of a direct base of the class being defined (e.g. {{c|using Base::Base;}}), constructors of that base class are inherited, according to the following rules:
:@a@ A set of ''inheriting constructors'' is composed of 
::@*@ All non-template constructors of the base class
::@*@ For each constructor with default arguments or the ellipsis parameter, all constructor signatures that are formed by dropping the ellipsis and omitting default arguments from the ends of argument lists one by one
::@*@ All constructor templates of the base class
::@*@ For each constructor template with default arguments or the ellipsis, all constructor signatures that are formed by dropping the ellipsis and omitting default arguments from the ends of argument lists one by one
:@b@ All inherited constructors that aren't the default constructor or the copy/move constructor and whose signatures do not match user-defined constructors in the derived class, are implicitly declared in the derived class. The default parameters are not inherited:
{{source|1=
struct B1 {
    B1(int);
};
struct D1 : B1 {
    using B1::B1;
// The set of inherited constructors is 
// 1. B1(const B1&amp;)
// 2. B1(B1&amp;&amp;)
// 3. B1(int)

// D1 has the following constructors:
// 1. D1()
// 2. D1(const D1&amp;) 
// 3. D1(D1&amp;&amp;)
// 4. D1(int) &lt;- inherited
};

struct B2 {
    B2(int = 13, int = 42);
};
struct D2 : B2 {
    using B2::B2;
// The set of inherited constructors is
// 1. B2(const B2&amp;)
// 2. B2(B2&amp;&amp;)
// 3. B2(int = 13, int = 42)
// 4. B2(int = 13)
// 5. B2()

// D2 has the following constructors:
// 1. D2()
// 2. D2(const D2&amp;)
// 3. D2(D2&amp;&amp;)
// 4. D2(int, int) &lt;- inherited
// 5. D2(int) &lt;- inherited
};
}}
The inherited constructors are equivalent to user-defined constructors with an empty body and with a {{rlp|initializer_list|member initializer list}} consisting of a single {{spar|nested-name-specifier}}, which forwards all of its arguments to the base class constructor. 

===Notes===
Only the name explicitly mentioned in the using-declaration is transferred into the declarative scope: in particular, enumerators are not transferred when the enumeration type name is using-declared.

A using-declaration cannot refer to a template-id, to a namespace, to a scoped enumerator, to a destructor of a base class or to a specialization of a member template for a user-defined conversion function.

If a using-declaration brings the base class assignment operator into derived class, whose signature happens to match the derived class's copy-assignment or move-assignment operator, that operator is hidden by the implicitly-declared copy/move assignment operator of the derived class.

If two using-declarations inherit the constructor with the same signature (from two direct base classes), the program is ill-formed.</text>
      <sha1>q21psgbqeu2sye6x29jf6u6sywsgpfq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/value category</title>
    <ns>0</ns>
    <id>4706</id>
    <revision>
      <id>72302</id>
      <parentid>71932</parentid>
      <timestamp>2014-08-06T18:23:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link string literal and overload resolution</comment>
      <text xml:space="preserve" bytes="10084">{{title|Value categories}}
{{cpp/language/expressions/navbar}}

Each C++ {{rlp|expressions|expression}} (an operator with its arguments, a literal, a variable name, etc) is characterized by two independent properties: a ''type'' and a ''value category''. Each expression has some non-reference type, and each expression belongs to exactly one of the three primary value categories.

==Primary categories==
===lvalue===
An ''lvalue'' is an expression that identifies a non-temporary object or a non-member function.

The following expressions are lvalues:
* The name of a variable or function in scope, regardless of type, such as {{tt|std::cin}} or {{tt|std::endl}}. Even if the variable's type is rvalue reference, the expression consisting of its name is an lvalue expression.
* Function call or overloaded operator expression if the function's or overloaded operator's return type is an lvalue reference, such as {{tt|std::getline(std::cin, str)}} or {{tt|std::cout &lt;&lt; 1}} or {{tt|str1 {{=}} str2}} or {{tt|++iter}}&lt;ref&gt;assuming the operators aren't {{rlp|operators|overloaded}} to return by value&lt;/ref&gt;
* Built-in {{rlp|operator_incdec#Built-in prefix_operators|pre-increment and pre-decrement}}, {{rlp|operator_member_access#Built-in_indirection_operator|dereference}}, {{rlp|operator_assignment|assignment and compound assignment}}, {{rlp|operator_member_access#Built-in_subscript_operator|subscript}} (except on an array xvalue), {{rlp|operator_member_access#Built-in member_access_operators|member access}} (except for non-static non-reference members of xvalues, member enumerators, and non-static member functions), {{rlp|operator_member_access#Built-in_pointer-to-member_access_operators|member access through pointer to data member}} if the left-hand operand is lvalue, {{rlp|operator_other#Built-in_comma_operator|comma operator}} if the right-hand operand is lvalue, {{rlp|operator_other#Conditional_operator|ternary conditional}} if the second and third operands are lvalues.
* Cast expression to lvalue reference type.
* String literal
{{rev begin}}
{{rev | since=c++11 |
* Function call expression if the function's return type is rvalue reference to function type (rare)
* Cast expression to rvalue reference to function.
}}
{{rev end}}

Properties:
* Same as glvalue (below)
* Address of an lvalue may be taken: {{tt|&amp;++i}}&lt;ref&gt;Assuming {{tt|i}} has built-in type or the pre-increment operator is not {{rlp|operators|overloaded}} to return by value&lt;/ref&gt; and {{tt|&amp;std::endl}} are valid expressions. 
* A modifiable lvalue may be used as the left-hand operand of the built-in assignment operator.
* An lvalue may be used to {{rlp|reference initialization|initialize an lvalue reference}}; this associates a new name with the object identified by the expression.
* An lvalue can have incomplete type, where permitted by the expression

===rvalue {{mark until c++11}} / prvalue {{mark since c++11}}===
A ''prvalue'' (&quot;pure&quot; rvalue) is an expression that identifies a temporary object (or a subobject thereof) or is a value not associated with any object.

The following expressions are prvalues:
* {{rlp|expressions#Literals|Literal}} (except {{rlp|string literal}}), such as {{c|42}} or {{c|true}} or {{c|nullptr}}.
* Function call or overloaded operator expression if the function's or the overloaded operator's return type is not a reference, such as {{tt|str.substr(1, 2)}} or {{tt|str1 + str2}}
* Built-in {{rlp|operator_incdec#Built-in_postfix_operators|post-increment and post-decrement }}, {{rlp|operator_arithmetic|arithmetic}} and {{rlp|operator_logical|logical}} operators, {{rlp|operator_comparison|comparison}} operators, {{rlp|operator_member_access#Built-in_address-of_operator|address-of operator}}, {{rlp|operator_member_access#Built-in_member_access operators|member access}} for a member enumerator, a non-static member function, or a non-static non-reference data member of an rvalue, {{rlp|operator_member_access#Built-in_pointer-to-member_access_operators|member access through pointer}} to a data member of rvalue or to a non-static member function, {{rlp|operator_other#Built-in_comma_operator|comma operator}} where the right-hand operand is rvalue, {{rlp|operator_other#Conditional_operator|ternary conditional}} where either second or third operands aren't lvalues.
* Cast expression to any type other than reference type.
{{rev begin}}
{{rev | since=c++11 |
* Lambda expressions, such as {{c| [](int x){return x*x;} }}
}}{{rev end}}

Properties:
* Same as rvalue (below)
* a prvalue cannot be {{rlp|object#Polymorphic_objects|polymorphic}}: the {{rlp|type#Dynamic_type|dynamic type}} of the object it identifies is always the type of the expression.
* a non-class non-array prvalue cannot be {{rlp|cv|const-qualified}}.
* a prvalue cannot have incomplete type (except for type void, see below)

{{rev begin}}
{{rev | since=c++11 |
===xvalue===
An ''xvalue'' is an expression that identifies an &quot;eXpiring&quot; object, that is, the object that may be moved from. The object identified by an xvalue expression may be a nameless temporary, it may be a named object in scope, or any other kind of object, but if used as a function argument, xvalue will always bind to the rvalue reference overload if available.

Only the following expressions are xvalues:
* A function call or overloaded operator expression if the function's or the overloaded operator's return type is an rvalue reference to object type, such as {{tt|std::move(val)}} 
* A cast expression to an rvalue reference to object type, such as {{tt|static_cast&lt;T&amp;&amp;&gt;(val)}} or {{tt|(T&amp;&amp;)val}}
* a non-static class member access expression, in which the object expression is an xvalue
* A pointer-to-member expression in which the first operand is an xvalue and the second operand is a pointer to data member.

Properties:
* Same as rvalue (below)
* Same as glvalue (below)

Like prvalues, xvalues bind to rvalue references, but unlike prvalues, an xvalue may be {{rlp|object#Polymorphic_objects|polymorphic}}, and a non-class xvalue may be {{rlp|cv|cv-qualified}}.
}}
{{rev end}}
==Mixed categories==

===glvalue===
A glvalue (&quot;generalized&quot; lvalue) is an expression that is either an lvalue or an xvalue.

Properties (note: these apply to pre-C++11 lvalues as well)
* A glvalue may be implicitly converted to prvalue with lvalue-to-rvalue, array-to-pointer, or function-to-pointer [[cpp/language/implicit_cast|implicit conversion]].
* A glvalue may be {{rlp|object#Polymorphic_objects|polymorphic}}: the {{rlp|type#Dynamic_type|dynamic type}} of the object it identifies is not necessarily the static type of the expression.

===rvalue===
An rvalue is an expression that is either a prvalue or an xvalue.

Properties (note, these apply to both xvalues and prvalues, which means they apply to the pre-C++11 rvalues as well)
* Address of an rvalue may not be taken: {{tt|&amp;int()}}, {{tt|&amp;i++}}&lt;ref&gt;Assuming {{tt|i}} has built-in type or the postincrement operator is not {{rlp|operators|overloaded}} to return by reference&lt;/ref&gt;, {{tt|&amp;42}}, and {{tt|&amp;std::move(val)}} are invalid.
* An rvalue may be used to [[cpp/language/reference_initialization|initialize a const lvalue reference]], in which case the lifetime of the object identified by the rvalue is extended until the scope of the reference ends.
{{rev begin}}
{{rev | since=c++11 |
* An rvalue may be used to [[cpp/language/reference_initialization|initialize an rvalue reference]], in which case the lifetime of the object identified by the rvalue is extended until the scope of the reference ends.
* When used as a function argument and when {{rlp|overload resolution|two overloads}} of the function are available, one taking rvalue reference parameter and the other taking lvalue reference to const parameter, rvalues bind to the rvalue reference overload (thus, if both copy and move constructors are available, rvalue arguments invoke the [[cpp/language/move constructor|move constructor]], and likewise with copy and move assignment operators).
}}
{{rev end}}

==Special categories==
===Pending member function call===
The expressions {{c|obj.func}} and {{c|ptr-&gt;func}}, where {{tt|func}} is a {{rlp|member functions|non-static member function}}, and the expressions {{c|obj.*mfp}} and {{c|ptr-&gt;*mfp}} where {{tt|mfp}} is a {{rlp|pointer#Pointers to member functions|pointer to member function}}, are classified as prvalue expressions, but they cannot be used to initialize references, as function arguments, or for any purpose at all, except as the left-hand argument of a function call expression, e.g. {{c|(pobj-&gt;*ptr)(args)}}.

===Void expressions===
Function call expressions returning {{c|void}}, cast expressions to {{c|void}}, and {{rlp|throw|throw-expressions}} are classified as prvalue expressions, but they cannot be used to initialize references or as function arguments. They can be used in some contexts (e.g. on a line of its own, as the left argument of the comma operator, etc) and in the {{c|return}} statement in a function returning {{c|void}}. In addition, throw-expressions may be used as the second and the third operands of the [[cpp/language/operator_other|conditional operator ?:]] (other void prvalues can only be used if appearing as both 2nd and 3rd operands).

===Bit fields===
An expression that designates a {{rlp|bit_field|bit field}} (e.g. {{tt|s.x}} where s is an object of type {{tt|struct S { int x:3; };}}) is an lvalue expression (or xvalue if {{tt|s}} is one): it may be used on the left hand side of the assignment operator, but its address cannot be taken and a non-const lvalue reference cannot be bound to it. A const lvalue reference can be initialized from a bit-field lvalue, but a temporary copy of the bit-field will be made: it won't bind to the bit field directly.

==footnotes==
&lt;references/&gt;

[[de:cpp/language/value category]]
[[es:cpp/language/value category]]
[[fr:cpp/language/value category]]
[[it:cpp/language/value category]]
[[ja:cpp/language/value category]]
[[pt:cpp/language/value category]]
[[ru:cpp/language/value category]]
[[zh:cpp/language/value category]]</text>
      <sha1>2e46h1x4uthalll7bil7aoop09ix1y9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/value initialization</title>
    <ns>0</ns>
    <id>8864</id>
    <revision>
      <id>71037</id>
      <parentid>70335</parentid>
      <timestamp>2014-06-04T20:54:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>clarify when it's zeroed out first (standardese sentence full of negatives is hard to follow)</comment>
      <text xml:space="preserve" bytes="6513">{{title|value initialization}}
{{cpp/language/initialization/navbar}}
Provides the default initial value to a new object.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{spar|T}}{{ttb|();}} }}
{{sdsc | num=2 | {{ttb|new }} {{spar|T}} {{ttb|();}} }}
{{sdsc | num=3 | {{spar|Class}}{{ttb|::}}{{spar|Class(...)}} {{ttb|:}} {{spar|member}}{{ttb|() {...}} }}
{{sdsc | num=4 | {{spar|T}} {{spar| object}} {{ttb|{};}}|notes={{mark since c++11}}}}
{{sdsc | num=5 | {{spar|T}}{{ttb|{};}}|notes={{mark since c++11}}}}
{{sdsc | num=6 | {{ttb|new }} {{spar|T}} {{ttb|{};}}|notes={{mark since c++11}}}}
{{sdsc | num=7 | {{spar|Class}}{{ttb|::}}{{spar|Class(...)}} {{ttb|:}}{{spar|member}}{{ttb|{} {...}} |notes={{mark since c++11}}}}
{{sdsc end}}

===Explanation===

Value initialization is performed in three situations:
@1,5@ when a nameless temporary object is created with the initializer consisting of an empty pair of parentheses {{rev inl|since=c++11|or braces}}.
@2,6@ when an object with dynamic storage duration is created by a {{rlp|new|new-expression}} with the initializer consisting of an empty pair of parentheses {{rev inl|since=c++11|or braces}}.

{{rev begin}}
{{rev | since=c++11 |
@4@ when a named variable (automatic, static, or thread-local) is declared with the initializer consisting of a pair of braces.
}}
{{rev end}}

@3,7@ when a non-static data member or a base class is initialized using a {{rlp|initializer_list|member initializer}} with an empty pair of parentheses {{rev inl|since=c++11|or braces}}

In all cases, if the empty pair of braces {{tt|{}}} is used and {{tt|T}} is an aggregate type {{rev inl|until=c++14|that is not a class type with a default constructor}}, {{rlp|aggregate_initialization|aggregate-initialization}} is performed instead of value-initialization.

If {{tt|T}} is a class type that has no default constructor but has a constructor taking {{c|std::initializer_list}}, {{rlp|list_initialization|list-initialization}} is performed. 


The effects of value initialization are:

{{rev begin}}
{{rev|until=c++14|
@1@ If {{tt|T}} is a class type with at least one user-provided constructor of any kind, the {{rlp|default constructor}} is called.
}}
{{rev|since=c++14|
@1@ If {{tt|T}} is a class type with no default constructor or with a user-provided default constructor or with a deleted default constructor, the object is {{rlp|default_initialization|default-initialized}}.
}}
{{rev end}}

{{rev begin}}
{{rev|until=c++11|
@2@ If {{tt|T}} is an non-union class type without any user-provided constructors, then every non-static data member and base-class component of T is value-initialized
}}
{{rev|since=c++11|until=c++14|
@2@ If {{tt|T}} is an non-union class type without any user-provided constructors, then the object is {{rlp|zero_initialization|zero-initialized}} and then the implicitly-declared default constructor is called (unless it's trivial)
}}
{{rev|since=c++14|
@2@ If {{tt|T}} is a class type without a user-provided or deleted default constructor (that is, it may be a class with a defaulted default constructor or with an implicitly-defined one) then the object is {{rlp|zero_initialization|zero-initialized}} and then it is default-initialized if it has a non-trivial default constructor
}}
{{rev end}}

@3@ If {{tt|T}} is an array type, each element of the array is value-initialized

@4@ Otherwise, the object is zero-initialized.

===Notes===
The syntax {{c|T object();}} does not initialize an object; it declares a function that takes no arguments and returns {{tt|T}}. The way to value-initialize a named variable before C++11 was {{c|1=T object = T();}}, which value-initializes a temporary and then copy-initializes the object: most compilers {{rlp|copy elision|optimize out the copy}} in this case.

References cannot be value-initialized.

All standard containers ({{lc|std::vector}}, {{lc|std::list}}, etc) value-initialize their elements when constructed with a single {{tt|size_type}} argument or when grown by a call to {{c|resize()}}.

Since C++11, value-initializing a class without a user-provided constructor, which has a member of a class type with a user-provided constructor zeroes out the member before calling its constructor:
{{source|1=
struct A {
    int i;
    A() {} // user-provided ctor, does not initialize i
};

struct B { A a; }; // no user-provided ctor

std::cout &lt;&lt; B().a.i &lt;&lt; '\n'; // value-initializes a B temporary
                              // leaves b.a.i uninitialized in C++03
                              // sets b.a.i to zero in C++11
// (note that B{}.a.i leaves b.a.i uninitialized in C++14, but for 
//  a different reason: C++14's B{} is aggregate-initialization)
}}

===Example===

{{example
 |
 | code=
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

struct T1 {
    int mem1;
    std::string mem2;
}; // no constructors
struct T2 { 
    int mem1;
    std::string mem2;
    T2(const T2&amp;) {} // a constructor, but no default
};
struct T3 { 
    int mem1;
    std::string mem2;
    T3() {} // user-provided default ctor
};

std::string s{}; // calls default ctor, the value is &quot;&quot; (empty string)
int main()
{
    int n{};     // non-class value-initialization, value is 0
    double f = double(); // non-class value-init, value is 0.0
    int* a = new int[10](); // array of 10 zeroes

    T1 t1{}; // no ctors: zero-initialized
             // t1.mem1 is zero-initialized
             // t1.mem2 is default-initialized
//    T2 t2{}; // error: has a ctor, but no default ctor
    T3 t3{}; // user-defined default ctor:
             // t3.mem1 is default-initialized (the value is indeterminate)
             // t3.mem2 is default-initialized

    std::vector&lt;int&gt; v(3); // value-initializes three ints

    std::cout &lt;&lt; s.size() &lt;&lt; ' ' &lt;&lt; n &lt;&lt; ' ' &lt;&lt; f &lt;&lt; ' ' &lt;&lt; a[9] &lt;&lt; ' ' &lt;&lt; v[2] &lt;&lt; '\n';
    std::cout &lt;&lt; t1.mem1 &lt;&lt; ' ' &lt;&lt; t3.mem1 &lt;&lt; '\n';
    delete[] a;
}
 | output=
0 0 0 0 0
0 4199376
}}

===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/value initialization]]
[[es:cpp/language/value initialization]]
[[fr:cpp/language/value initialization]]
[[it:cpp/language/value initialization]]
[[ja:cpp/language/value initialization]]
[[pt:cpp/language/value initialization]]
[[ru:cpp/language/value initialization]]
[[zh:cpp/language/value initialization]]</text>
      <sha1>1bapj73p5vah18gsz59h6ie07833ct6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/variable template</title>
    <ns>0</ns>
    <id>13729</id>
    <revision>
      <id>72402</id>
      <parentid>72395</parentid>
      <timestamp>2014-08-19T14:29:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail</comment>
      <text xml:space="preserve" bytes="3038">{{title|Variable template}}
{{cpp/language/templates/navbar}}

A variable template defines a family of variables or static data members.

===Syntax===
{{sdsc begin}}
{{sdsc|{{ttb|template}} {{ttb|&lt;}} {{spar|parameter-list}} {{ttb|&gt;}} {{spar|declaration}} }}
{{sdsc end}}

===Explanation===
{{spar|declaration}} defines or declares a [[cpp/language/class_template|class (including struct and union), a {{rlp|function template|function}} or {{rlp|member template|member function}}, a static data member at namespace scope, {{rev inl|since=c++14|{{rlp|variable template|a variable or static data member at class scope}},}} {{rev inl|since=c++11|or a [[cpp/language/type_alias|alias template]]}} It may also define a [[cpp/language/template_specialization|template specialization]]. This page focuses on variable templates.

A variable template may be introduced by a template declaration at namespace scope, where {{spar|declaration}} declares a variable.

{{source|1=
template&lt;class T&gt;
constexpr T pi = T(3.1415926535897932385);  // variable template

template&lt;class T&gt;
T circular_area(T r) // function template
{
    return pi&lt;T&gt; * r * r; // pi&lt;T&gt; is a variable template instantiation
}
}}

When used at class scope, variable template declares a static data member template.

{{source|1=
struct matrix_constants
{
    template&lt;class T&gt;
    using pauli = hermitian_matrix&lt;T, 2&gt;; // alias template

    template&lt;class T&gt;
    constexpr pauli&lt;T&gt; sigma1 = { { 0, 1 }, { 1, 0 } }; // static data member template

    template&lt;class T&gt;
    constexpr pauli&lt;T&gt; sigma2 = { { 0, -1i }, { 1i, 0 } };

    template&lt;class T&gt;
    constexpr pauli&lt;T&gt; sigma3 = { { 1, 0 }, { -1, 0 } };
};
}}

A definition of a static data member template may be provided outside the class definition. A template declaration of a static data member at namespace scope may also be a definition of a non-template {{rlp|member template|data member of a class template}}:

{{source|1=
struct limits {
    template&lt;typename T&gt;
    static const T min; // declaration of a static data member template
};
template&lt;typename T&gt;
const T limits::min = { }; // definition of a static data member template

template&lt;class T&gt;
class X {
   static T s; // declaration of a non-template static data member of a class template
};
template&lt;class T&gt;
T X&lt;T&gt;::s = 0; // definition of a non-template data member of a class template
}}

Unless a variable template was {{rlp|template specialization|explicitly specialized}} or explicitly instantiated, it is implicitly instantiated when a specialization of the variable template is used.

Default template argument of a variable template is implicitly instantiated when the variable template is used in the context that requires the value of the argument.

===Notes===
Until variable templates were introduced in C++14, parametrized variables were typically implemented as either static data members of class templates or as constexpr function templates returning the desired values.

Variable templates cannot be used as template template arguments.</text>
      <sha1>2rh33sgftpecfha7iy523y1esth0fqw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/variadic arguments</title>
    <ns>0</ns>
    <id>13164</id>
    <revision>
      <id>69440</id>
      <parentid>69439</parentid>
      <timestamp>2014-04-08T19:53:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to sfinae</comment>
      <text xml:space="preserve" bytes="3220">{{title|Variadic arguments}}
{{cpp/language/functions/navbar}}

Allows a function to accept any number of arguments.

Indicated by the parameter of the form {{c|...}} which must appear last in the {{spar|parameter-list}} of a {{rlp|function|function declaration}}.

Where syntactically correct, {{c|, ...}} may be replaced by {{c|...}}.

{{source|1=
// the function declared as follows
int printx(const char* fmt, ...);
// may be called with one or more arguments:
printx(&quot;hello world&quot;);
printx(&quot;a=%d b=%d&quot;, a, b);

int printx(const char* fmt...); // same as above (comma is optional)
int printy(..., const char* fmt); // error: ... must be the last
int printz(...); // valid, but the arguments cannot be accessed portably
}}

Note: this is different from a function {{rlp|parameter pack}} expansion, which is indicated by an ellipsis that is a part of a parameter declarator, rather than an ellipsis that appears as a parameter on its own. Both parameter pack expansion and the ellipsis parameter may appear in the declaration of a function template, as in the case of {{lc|std::is_function}}.

===Default conversions===

When a variadic function is called, after lvalue-to-rvalue, array-to-pointer, and function-to-pointer [[cpp/language/implicit_cast#Lvalue transformations|conversions]], each argument that is a part of the variable argument list undergoes additional conversions known as ''default argument promotions'': 

* {{lc|std::nullptr_t}} is converted to {{c|void*}}
* {{c|float}} arguments are converted to {{c|double}} as in [[cpp/language/implicit_cast#Floating point promotion|floating-point promotion]]
* {{c|bool}}, {{c|char}}, {{c|short}}, and unscoped enumerations are converted to {{c|int}} or wider integer types as in [[cpp/language/implicit_cast#Integer promotion|integer promotion]] 

Only arithmetic, enumeration, pointer, pointer to member, and class type arguments are allowed.

Because variadic parameters have the lowest rank for the purpose of {{rlp|overload resolution}}, they are commonly used as the catch-all fallbacks in {{rlp|sfinae|SFINAE}}.

Within the body of a function that uses variadic arguments, the values of these arguments may be accessed using the [[cpp/utility/variadic|&lt;cstdarg&gt; library facilities]]:
{{dsc begin}}
{{dsc header | cstdarg}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc inc | cpp/utility/variadic/dsc va_list}}
{{dsc end}}

===Alternatives===

* [[cpp/language/parameter_pack|Variadic templates]] can also be used to create functions that take variable number of arguments.  They are often the better choice because they do not impose restrictions on the types of the arguments, do not perform integral and floating-point promotions, and are type safe. {{mark since c++11}}
* If all variable arguments share a common type, a {{lc|std::initializer_list}} provides a convenient mechanism (albeit with a different syntax) for accessing variable arguments.

===Notes===
In the C programming language, at least one named parameter must appear before the ellipsis parameter, so {{tt|printz(...);}} is not valid.</text>
      <sha1>dmoe8mpd9xklb76opqgtokb8ym8p2sq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/virtual</title>
    <ns>0</ns>
    <id>4061</id>
    <revision>
      <id>70250</id>
      <parentid>70249</parentid>
      <timestamp>2014-05-12T18:23:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>snipped for final overriders  that covers more ground</comment>
      <text xml:space="preserve" bytes="12107">{{title|virtual function specifier}}
{{cpp/language/classes/navbar}}

Specifies that a non-static {{rlp|member functions|member function}} is ''virtual'' and supports dynamic binding.

===Syntax===
{{sdsc begin}}
{{sdsc | {{ttb|virtual}} {{spar|function_declaration}} {{ttb|;}} }}
{{sdsc end}}

===Explanation===
Virtual functions are member functions whose behavior can be overridden in derived classes. As opposed to non-virtual functions, the overridden behavior is preserved even if there is no compile-time information about the actual type of the class. If a derived class is handled using pointer or reference to the base class, a call to a overridden virtual function would invoke the behavior defined in the derived class. This behavior is suppressed if the function is selected using {{rlp|lookup|qualified name lookup}} (that is, if the function's name appears to the right of the scope resolution operator {{tt|::}})

{{example|code=
#include &lt;iostream&gt;
struct Base {
   virtual void f() {
       std::cout &lt;&lt; &quot;base\n&quot;;
   }
};
struct Derived : Base {
    void f() override { // 'override' is optional
        std::cout &lt;&lt; &quot;derived\n&quot;;
    }
};
int main()
{
    Base b;
    Derived d;

    // virtual function call through reference
    Base&amp; br = b; // the type of br is Base&amp;
    Base&amp; dr = d; // the type of dr is Base&amp; as  well
    br.f(); // prints &quot;base&quot;
    dr.f(); // prints &quot;derived&quot;

    // virtual function call through pointer
    Base* bp = &amp;b; // the type of bp is Base*
    Base* dp = &amp;d; // the type of dp is Base* as  well
    bp-&gt;f(); // prints &quot;base&quot;
    dp-&gt;f(); // prints &quot;derived&quot;

    // non-virtual function call
    br.Base::f(); // prints &quot;base&quot;
    dr.Base::f(); // prints &quot;base&quot;
}
}}

===In detail===
If some member function {{tt|vf}} is declared as {{tt|virtual}} in a class {{tt|Base}}, and some class {{tt|Derived}}, which is derived, directly or indirectly, from {{tt|Base}}, has a declaration for member function with the same 
* name
* parameter type list (but not the return type)
* cv-qualifiers
* ref-qualifiers
Then this function in the class {{tt|Derived}} is also ''virtual'' (whether or not the keyword {{tt|virtual}} is used in its declaration) and ''overrides'' Base::vf (whether or not the word {{tt|override}} is used in its declaration).

{{tt|Base::vf}} does not need to be visible (can be declared private, or inherited using private inheritance) to be overridden.

{{source|1=
class B {
    virtual void do_f(); // private member
 public:
    void f() { do_f(); }; // public interface
};
struct D : public B {
    void do_f() override; // overrides B::f
};

int main()
{
    D d;
    B* bp = &amp;d;
    bp-&gt;f(); // calls D::do_f();
}
}}

For every virtual function, there is the ''final overrider'', which is executed when a virtual function call is made. A virtual member function {{tt|vf}} of a base class {{tt|Base}} is the final overrider unless the derived class declares or inherits (through multiple inheritance) another function that overrides {{tt|vf}}.

{{source|1=
struct A { virtual void f(); };     // A::f is virtual
struct B : A { void f(); };         // B::f overrides A::f in B
struct C : virtual B { void f(); }; // C::f overrides A::f in C
struct D : virtual B {}; // D does not introduce an overrider, B::f is final in D
struct E : C, D  {       // E does not introduce an overrider, C::f is final in E
    using A::f; // not a function declaration, just makes A::f visible to lookup
};
int main() {
   E e;
   e.f();    // virtual call calls C::f, the final overrider in e
   e.E::f(); // non-virtual call calls A::f, which is visible in E
}
}}

If a function has more than one final overrider, the program is ill-formed:
{{source|1=
struct A {
    virtual void f();
};
struct VB1 : virtual A {
    void f(); // overrides A::f
};
struct VB2 : virtual A {
    void f(); // overrides A::f
};
// struct Error : VB1, VB2 {
//     // Error: A::f has two final overriders in Error
// };
struct Okay : VB1, VB2 {
    void f(); // OK: this is the final overrider for A::f
};
struct VB1a : virtual A {}; // does not declare an overrider
struct Da : VB1a, VB2 {
    // in Da, the final overrider of A::f is VB2::f
};
}}

A function with the same name but different parameter list does not override the base function of the same name, but ''hides'' it: when {{rlp|lookup|unqualified name lookup}} examines the scope of the derived class, the lookup finds the declaration and does not examine the base class.

{{source|1=
struct B {
    virtual void f();
};
struct D : B {
    void f(int); // D::f hides B::f (wrong parameter list)
};
struct D2 : D {
    void f(); // D2::f overrides B::f (doesn't matter that it's not visible)
};

int main()
{
    B b;   B&amp; b_as_b   = b;
    D d;   B&amp; d_as_b   = d;    D&amp; d_as_d = d;
    D2 d2; B&amp; d2_as_b  = d2;   D&amp; d2_as_d = d2;

    b_as_b.f(); // calls B::f()
    d_as_b.f(); // calls B::f()
    d2_as_b.f(); // calls D2::f()

    d_as_d.f(); // Error: lookup in D finds only f(int)
    d2_as_d.f(); // Error: lookup in D finds only f(int)
}
}}

{{rev begin}}
{{rev|since=c++11|
If a function is declared with the specifier {{tt|override}}, but does not override a virtual function, the program is ill-formed:
{{source|1=
struct B {
    virtual void f(int);
};
struct D : B {
    virtual void f(int) override; // OK, D::f(int) overrides B::f(int)
    virtual void f(long) override; // Error: f(long) does not override B(int)
};
}}

If a function is declared with the specifier {{tt|final}}, and another function attempts to override it, the program is ill-formed
{{source|1=
struct B {
    virtual void f() const final;
};
struct D : B {
    void f() const; // Error: D::f attempts to override final B::f
};
}}
}}
{{rev end}}

Non-member functions and static member functions cannot be virtual.

Functions templates cannot be declared {{tt|virtual}}. This applies only to functions that are themselves templates - a regular member function of a class template can be declared virtual.

====Covariant return types====
If the function {{tt|Derived::f}} overrides a function {{tt|Base::f}}, their return types must either be the same or be ''covariant''. Two types are covariant if they satisfy all of the following requirements:

* both types are pointers or references (lvalue or rvalue) to classes. Multi-level pointers or references are not allowed.
* the referenced/pointed-to class in the return type of {{tt|Base::f()}} must be a unambiguous and accessible direct or indirect base class of the referenced/pointed-to class of the return type of {{tt|Derived::f()}}.
* the return type of {{tt|Derived::f()}} must be equally or less [[cpp/language/cv | cv-qualified]] than the return type of {{tt|Base::f()}}.

The class in the return type of {{tt|Derived::f}} must be either {{tt|Derived}} itself, or must be a {{rlp|incomplete type|complete type}} at the point of declaration of {{tt|Derived::f}}.

When a virtual function call is made, the type returned by the final overrider is {{rlp|implicit cast|implicitly converted}} to the return type of the overridden function that was called:

{{source|1=
class B {};

struct Base {
    virtual void vf1();
    virtual void vf2();
    virtual void vf3();
    virtual B* vf4();
    virtual B* vf5();
};

class D : private B {
    friend struct Derived; // in Derived, B is an accessible base of D
};

class A; // forward-declared class is an incomplete type

struct Derived : public Base {
    void vf1();    // virtual, overrides Base::vf1()
    void vf2(int); // non-virtual, hides Base::vf2()
//  char vf3();    // Error: overrides Base::vf3, but has different
                   // and non-covariant return type
    D* vf4();      // overrides Base::vf4() and has covariant return type
//  A* vf5();      // Error: A is incomplete type
};

int main()
{
    Derived d;
    Base&amp; br = d;
    Derived&amp; dr = d;

    br.vf1(); // calls Derived::vf1()
    br.vf2(); // calls Base::vf2()
//  dr.vf2(); // Error: vf2(int) hides vf2()

    B* p = br.vf4(); // calls Derived::pf() and converts the result to B*
    D* q = dr.vf4(); // calls Derived::pf() and does not convert
                     //  the result to B*

}
}}

====Virtual destructor====
Even though destructors are not inherited, if a base class declares its destructor {{tt|virtual}}, the derived destructor always overrides it. This makes it possible to delete dynamically allocated objects of polymorphic type through pointers to base

{{source|1=
class Base {
 public:
    virtual ~Base() { /* releases Base's resources */ }
};

class Derived : public Base {
    ~Derived() { /* releases Derived's resources */ }
};

int main()
{
    Base* b = new Derived;
    delete b; // Makes a virtual function call to Base::~Base()
              // since it is virtual, it calls Derived::~Derived() which can
              // release resources of the derived class, and then calls
              // Base::~Base() following the usual order of destruction
}
}}

Moreover, if a class is ''polymorphic'' (declares or inherits at least one virtual function), and its destructor is not virtual, deleting it is ''undefined behavior'' regardless of whether there are resources that would be leaked if the derived destructor is not invoked.

A useful guideline is that the destructor of any base class must be [http://www.gotw.ca/publications/mill18.htm public and virtual or protected and non-virtual].

===During construction and destruction===
When a virtual function is called directly or indirectly from a constructor or from a destructor (including during the construction or destruction of the class’s non-static data members, e.g. in a member {{rlp|initializer list}}), and the object to which the call applies is the object under construction or destruction, the function called is the final overrider
in the constructor’s or destructor’s class and not one overriding it in a more-derived class. 
In other words, during construction or destruction, the more-derived classes do not exist.

When constructing a complex class with multiple branches, within a constructor that belongs to one branch, polymorphism is restricted to that class and its bases: if it obtains a pointer or reference to a base subobject outside this subhierarchy, and attempts to invoke a virtual function call (e.g. using explicit member access), the behavior is undefined:

{{source|1=
struct V {
    virtual void f();
    virtual void g();
};

struct A : virtual V {
    virtual void f(); // A::f is the final overrider of V::f in A
};
struct B : virtual V {
    virtual void g(); // B::g is the final overrider of V::g in B
    B(V*, A*);
};
struct D : A, B {
    virtual void f(); // D::f is the final overrider of V::f in D
    virtual void g(); // D::g is the final overrider of V::g in D

    // note: A is initialized before B
    D() : B((A*)this, this) 
    {
    }
};

// the constructor of B, called from the constructor of D 
B::B(V* v, A* a)
{
    f(); // virtual call to V::f (although D has the final overrider, D doesn't exist)
    g(); // virtual call to B::g, which is the final overrider in B 

    v-&gt;g(); // v's type V is base of B, virtual call calls B::g as before

    a-&gt;f(); // a’s type A is not a base of B. it belongs to a different branch of the
            // hierarchy. Attempting a virtual call through that branch causes
            // undefined behavior even though A was already fully constructed in this
            // case (it was constructed before B since it appears before B in the list
            // of the bases of D). In practice, the virtual call to A::f will be
            // attempted using B's virtual member function table, since that's what
            // is active during B's construction)
}
}}

===See also===
* [[cpp/language/override | override specifier]] {{mark since c++11}}
* [[cpp/language/final | final specifier]] {{mark since c++11}}

[[de:cpp/language/virtual]]
[[es:cpp/language/virtual]]
[[fr:cpp/language/virtual]]
[[it:cpp/language/virtual]]
[[ja:cpp/language/virtual]]
[[pt:cpp/language/virtual]]
[[ru:cpp/language/virtual]]
[[zh:cpp/language/virtual]]</text>
      <sha1>pe2f4qnifxmcz1x3n9zbenv9zmwhx9o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/while</title>
    <ns>0</ns>
    <id>717</id>
    <revision>
      <id>49975</id>
      <parentid>47433</parentid>
      <timestamp>2013-06-01T03:07:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2900">{{title|while loop}}
{{cpp/language/statements/navbar}}
Executes a {{spar|statement}} repeatedly, until the value of {{spar|condition}} becomes {{c|false}}. The test takes place before each iteration.

===Syntax===

{{sdsc begin}}
{{sdsc | {{spar|attr}}{{mark optional}} {{ttb|while (}} {{spar|condition}} {{ttb|)}} {{spar|statement}} }}
{{sdsc end}}

{{par begin}}
{{par | {{spar|attr}}{{mark c++11}} | any number of {{rlp|attributes}} }}
{{par | {{spar|condition}} | any {{rlp|expressions|expression}} which is {{rlp|implicit_cast|contextually convertible}} to bool or a {{rlp|declarations|declaration}} of a single variable with a brace-or-equals {{rlp|initialization|initializer}}. This expression is evaluated before each iteration, and if it yields {{c|false}}, the loop is exited. If this is a declaration, the initializer is evaluated before each iteration, and if the value of the declared variable converts to {{c|false}}, the loop is exited.}}
{{par | {{spar|statement}} | any {{rlp|statements|statement}}, typically a compound statement, which is the body of the loop }}
{{par end}}

===Notes===
If {{spar|statement}} is a single statement (not a compound statement), the scope of variables declared in it is limited to the while loop as if it was a compound statement, in other words,
{{source|1=while(--x &gt;= 0)
    int i;
// i goes out of scope
}}
is the same as
{{source|1=while(--x &gt;= 0) {
    int i;
} // i goes out of scope
}}

If {{spar|condition}} is a declaration such as {{c|T t {{=}} x}}, the declared variable is only in scope in the body of the loop, and is destroyed and recreated on every iteration, in other words, such while loop is equivalent to

{{source|1=label:
{ // start of condition scope
    T t = x;
    if (t) {
        statement
        goto label; // calls the destructor of t
    }
}
}}

If the execution of the loop needs to be terminated at some point, {{rlp |break| break statement}} can be used as terminating statement. 

If the execution of the loop needs to be continued at the end of the loop body, {{rlp|continue | continue statement}} can be used as shortcut.

===Keywords===

{{ltt|cpp/keyword/while}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;

int main()
{
    // while loop with a single statement
    int i = 0;
    while (i &lt; 10)
         i++;
    std::cout &lt;&lt; i &lt;&lt; '\n';

    // while loop with a compound statement
    int j = 2;
    while (j &lt; 9) {
        std::cout &lt;&lt; j &lt;&lt; ' ';
        j += 2;
    }
    std::cout &lt;&lt; '\n';

   // while loop with a declaration condition
   char cstr[] = &quot;Hello&quot;;
   int k = 0;
   while(char c = cstr[k++])
       std::cout &lt;&lt; c;
   std::cout &lt;&lt; '\n';
}
 | output=
10
2 4 6 8 
Hello
}}

[[de:cpp/language/while]]
[[es:cpp/language/while]]
[[fr:cpp/language/while]]
[[it:cpp/language/while]]
[[ja:cpp/language/while]]
[[pt:cpp/language/while]]
[[ru:cpp/language/while]]
[[zh:cpp/language/while]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/language/zero initialization</title>
    <ns>0</ns>
    <id>8865</id>
    <revision>
      <id>66665</id>
      <parentid>66559</parentid>
      <timestamp>2013-12-20T17:43:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link char array init from string literal</comment>
      <text xml:space="preserve" bytes="3291">{{title|zero initialization}}
{{cpp/language/initialization/navbar}}
Sets the initial value of an object to zero

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|static}} {{spar|T}} {{spar| object}} {{ttb|;}}}}
{{sdsc | num=2 | {{spar|int}} {{ttb|()}} {{ttb|;}}}}
{{sdsc | num=3 | {{ttb|char}} {{spar|array}} {{ttb|[}} {{spar|n}} {{ttb|]}} {{ttb|{{=}} &quot;&quot;;}}}}
{{sdsc end}}

===Explanation===

Zero initialization is performed in the following situations:
@1@ For every named variable with static or thread-local [[cpp/language/storage_duration|storage duration]], before any other initialization.
@2@ As part of [[cpp/language/value_initialization|value-initialization]] sequence for non-class types and for members of value-initialized class types that have no constructors.
@3@ When a character array is {{rlp|aggregate initialization#Character arrays|initialized with a string literal}} that is too short, the remainder of the array is zero-initialized.

The effects of zero initialization are:

* If {{tt|T}} is a scalar type, the object's initial value is the integral constant zero [[cpp/language/implicit_cast|implicitly converted]] to {{tt|T}}. 

* If {{tt|T}} is an non-union class type, all base classes and non-static data members are zero-initialized, and all padding is initialized to zero bits. The constructors, if any, are ignored.

* If {{tt|T}} is a union type, the first non-static named data member is zero-initialized and all padding is initialized to zero bits.

* If {{tt|T}} is array type, each element is zero-initialized

* If {{tt|T}} is reference type, nothing is done.

===Notes===
The static and thread-local variables are first zero-initialized and then initialized again as specified in the program, e.g. a function-local static is first zero-initialized at program startup, and then its constructor is called when the function is first entered. If the declaration of a non-class static has no initializer, then default initialization does nothing, leaving the result of the earlier zero-initialization unmodified.

A zero-initialized pointer is the null pointer value of its type, even if the value of the null pointer is not integral zero.

===Example===

{{example
 |
 | code=
#include &lt;string&gt;

double f[3]; // zero-initialized to three 0.0's
int* p;   // zero-initialized to null pointer value
std::string s; // zero-initialized to indeterminate value
               // then default-initialized to &quot;&quot;
int main(int argc, char* argv[])
{
    static int n = argc; // zero-initialized to 0
                         // then copy-initialized to argc
    delete p; // safe to delete a null pointer
}
 | output=
}}

===See also===
* [[cpp/language/default_initialization|default initialization]]
* [[cpp/language/direct_initialization|direct initialization]]
* [[cpp/language/value_initialization|value initialization]]
* [[cpp/language/copy_initialization|copy initialization]]
* [[cpp/language/list_initialization|list initialization]]

[[de:cpp/language/zero initialization]]
[[es:cpp/language/zero initialization]]
[[fr:cpp/language/zero initialization]]
[[it:cpp/language/zero initialization]]
[[ja:cpp/language/zero initialization]]
[[pt:cpp/language/zero initialization]]
[[ru:cpp/language/zero initialization]]
[[zh:cpp/language/zero initialization]]</text>
      <sha1>7z4b9fmwqats99mvyhmc8e7qgmvuv1i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/links</title>
    <ns>0</ns>
    <id>6541</id>
    <revision>
      <id>68969</id>
      <parentid>66788</parentid>
      <timestamp>2014-03-23T07:21:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>isocpp made a FAQ</comment>
      <text xml:space="preserve" bytes="3519">{{title|Useful resources}}
*[http://isocpp.org/ The Standard C++ Foundation] - Non-profit hub for C++ news, articles, and events

===C++ FAQs===
*[http://isocpp.org/faq isocpp.org C++ FAQ] - unified FAQ by the Standard C++ Foundation.
*[http://www.stroustrup.com/bs_faq.html Bjarne Stroustrup FAQ] - Answers to the frequently asked questions from the creator of the language
*[http://www.stroustrup.com/C++11FAQ.html Bjarne Stroustrup C++11 FAQ] - Additional FAQ regarding the recent changes to the C++ language standards
*[http://stackoverflow.com/questions/tagged/c%2b%2b-faq?sort{{=}}votes Stackoverflow.com C++ FAQ ] - Best answers to the frequently asked C++ questions on the programmers' Q&amp;A website stackoverflow.com
*[http://www.parashift.com/c++-faq-lite/ C++ FAQ Lite] - Answers to the frequently asked questions from the Usenet newsgorup comp.lang.c++

===C++ Language and library references===
*[http://www.open-std.org/jtc1/sc22/wg21/ JTC1/SC22/WG21] - The C++ Standards Committee, includes draft C++ language standards, proposals, and defect reports
**[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3691.pdf n3691.pdf] - Standard for Programming Language C++  (Working Draft, May 16, 2013)
**[http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3797.pdf n3797.pdf] - Committee Draft for the C++14 standard
*[http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS%2FISO%2FIEC+14882-2012 ansi.org] Official C++ ISO/IEC 14882:2011 for purchase
*[http://stdcxx.apache.org/doc/stdlibref/index.html Apache] - Reference manual for the Apache implementation of the C++ standard library 
*[http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/topic/com.ibm.vacpp7a.doc/language/ref/clrc00about_this_reference.htm#about_this_reference IBM] - Reference manual for the IBM implementations of C and C++
*[http://msdn.microsoft.com/en-us/library/cscc687y MSDN] - Reference manual for the Microsoft implementation of the C++ library
**[http://web.archive.org/web/20120204111500/http://www.dinkumware.com/manuals/default.aspx dinkumware] - C++ Standard Library implementation that ships with Microsoft Visual C++
*[http://gcc.gnu.org/onlinedocs/libstdc++/api.html GNU libstdc++] - Reference manual for the GNU implementation of the C++ libary  
*[http://h30097.www3.hp.com/cplus/cxxstdlib_intro_3c__std.htm HP] - Reference manual for the HP implementation of the C++ library
*[http://www.freescale.com/infocenter/nav/1_2_3 EWL] - Reference manual for the Embedded Warrior implementation of the C++ library
*[http://cplusplus.com/reference cplusplus.com] - Unofficial C++ standard library reference 
*[http://www.sgi.com/tech/stl/ SGI STL ] - Reference for the library STL, large parts of which were included in C++ standard library in 1998. Of historic interest only. 

===Related standards===
*[http://www.open-std.org/jtc1/sc22/wg14/ JTC1/SC22/WG14] - the C Standards Committee, includes draft C language standards, proposals, and defect reports
*[http://pubs.opengroup.org/onlinepubs/9699919799/functions/contents.html POSIX.1-2008] - The operating system API of the Unix-compatible systems
*[http://www.unicode.org/versions/Unicode6.1.0/ Unicode] - The universal encoding standard for written characters 
*[http://refspecs.linuxbase.org/cxxabi-1.83.html C++ ABI] for Itanium, revision 1.83

===Might be also useful===
* [[cpp/links/libs | List of C++ libraries]]

[[de:cpp/links]]
[[es:cpp/links]]
[[fr:cpp/links]]
[[it:cpp/links]]
[[ja:cpp/links]]
[[pt:cpp/links]]
[[ru:cpp/links]]
[[zh:cpp/links]]</text>
      <sha1>fvmoysixbg61b9gg94d020bockvohek</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/links/libs</title>
    <ns>0</ns>
    <id>8399</id>
    <revision>
      <id>72473</id>
      <parentid>72471</parentid>
      <timestamp>2014-08-25T08:14:34Z</timestamp>
      <contributor>
        <ip>68.6.91.164</ip>
      </contributor>
      <comment>added a few GPU libraries</comment>
      <text xml:space="preserve" bytes="14509">{{title|A list of open source C++ libraries}}
&lt;div style=&quot;border: 1px solid silver; border-radius: 5px; padding: 0.5em;&quot;&gt;
The objective of this page is to build a comprehensive list of open source C++ libraries, so that when one needs an implementation of particular functionality, he doesn't need to waste time searching on Google.
 
If you know a library that might be useful to others, please add a link to it here. There are no restrictions on what can be included except that the source of the library must be readily available to download.

The page is provided 'as is' - with the hope of being useful, but without any warranties. Outdated, misleading or wrong links might appear here. If you've noticed one of these, it would be great if you fixed the error.
&lt;/div&gt;

==Generic==

*{{lib|Boost|http://www.boost.org/doc/libs | large collection of generic libraries}}
*{{lib|BDE|https://github.com/bloomberg/bde | The BDE Development Environment from Bloomberg L.P.}}
*{{lib|Dlib|http://dlib.net | networking, threads, graphical interfaces, data structures, linear algebra, machine learning, XML and text parsing, numerical optimization, Bayesian nets, and numerous other tasks}}
*{{lib|JUCE|http://www.juce.com/ | An extensive, mature, cross-platform C++ toolkit}}
*{{lib|Loki|http://loki-lib.sourceforge.net/ | design patterns}}
*{{lib|Reason|http://code.google.com/p/reason/ | xml, xpath, regex, threads, sockets, http, sql, date-time, streams, encoding and decoding, filesystem, compression}}
*{{lib|Yomm11|http://www.yorel.be/mm/ | Open multi-methods for C++11}}
*{{lib|Folly|https://github.com/facebook/folly | Facebook Open-source LibrarY. Library of C++11 components designed with practicality and efficiency in mind.}}
*{{lib|cxxomfort|http://ryan.gulix.cl/fossil.cgi/cxxomfort/|Backports of C++ features (C++11 to C++03 and C++1y proposals to C++11/C++03).}}
*{{lib|libsourcey|http://sourcey.com/libsourcey/ | Cross-platform C++11 library for high speed networking and media encoding. HTTP, WebSockets, TURN, STUN, Symple and more...}}
*{{lib|Neu|http://neu.andrometa.net | C++11 framework for AI, networking and distributed objects, simulation and modeling, languages and compiler construction, concurrency, and more.}}

==Communication==
*{{lib|C++ RESTful framework|https://bitbucket.org/Corvusoft/restbed/wiki/Home| C++ micro-framework designed to be embedded into a wide range of applications.}}
*{{lib|C++ REST SDK|http://casablanca.codeplex.com/|asynchronous HTTP client and listener, asynchronous Stream, URI, JSON}}
*{{lib|cpp-netlib|http://cpp-netlib.org/|cpp-netlib: The C++ Network Library}}
*{{lib|Boost.Asio|http://boost.org/libs/asio/|asynchronous and synchronous networking, timers, serial I/O}}
*{{lib|POCO|http://pocoproject.org/ | networking: encryption, HTTP; Zip files }}
*{{lib|ACE|http://www.cs.wustl.edu/~schmidt/ACE.html | asynchronous networking, event demultiplexing, messaging, CORBA}}
*{{lib| wvstreams | http://alumnit.ca }}
*{{lib| gsoap | http://gsoap2.sourceforge.net/ }}
*{{lib| Unicomm|http://libunicomm.org | asynchronous networking, high-level TCP communication framework}}
*{{lib|restful_mapper|https://github.com/logandk/restful_mapper|ORM for consuming RESTful JSON APIs in C++}}

==Graphic user interface==

*{{lib|FLTK|http://www.fltk.org/}}
*{{lib| nana | http://nanapro.sourceforge.net/ }}
*{{lib| WxWidgets|http://wxwidgets.org/|doc=http://docs.wxwidgets.org|src=http://wxwidgets.org/downloads}}

; GTK+

*{{lib| glibmm | http://www.gtkmm.org/ }}
*{{lib| gtkmm | http://www.gtkmm.org/ }}
*{{lib| goocanvasmm | http://live.gnome.org/GooCanvas }}
*{{lib| libglademm | http://www.gtkmm.org/ }}
*{{lib| libgnomecanvasmm | http://www.gtkmm.org/ }}
*{{lib| webkitgtk | http://webkitgtk.org/ }}
*{{lib| flowcanvas | http://drobilla.net/software/flowcanvas/ }}
*{{lib| evince | http://www.gnome.org/projects/evince/ }}

; Qt

*{{lib| Qt|http://qt-project.org/|doc=http://qt-project.org/doc/|src=http://qt-project.org/downloads}}
*{{lib| qwtplot3d | http://qwtplot3d.sourceforge.net }}
*{{lib| qwt5 | http://qwt.sourceforge.net }}
*{{lib| libdbusmenu-qt | https://launchpad.net/libdbusmenu-qt }}

== General Multimedia ==

*{{lib| SFML (Simple and Fast Multimedia Library) | http://www.sfml-dev.org/index.php }}
*{{lib | SDL (Simple DirectMedia Layer) | http://www.libsdl.org/ }}

==Graphics==

*{{lib| cairomm | http://cairographics.org/cairomm/ }}
*{{lib| nux | http://launchpad.net/nux }}
*{{lib| pangomm | http://gtkmm.org }}
*{{lib| gegl | http://gegl.org/ }}

; Plotting
*{{lib| plotutils | http://www.gnu.org/software/plotutils/ }}

; Formats
*{{lib| libraw | http://www.libraw.org/ }}
*{{lib| openexr | http://www.openexr.com }}
*{{lib| qimageblitz | http://www.kde.org/ }}
*{{lib| imagemagick | http://www.imagemagick.org/ }}
*{{lib| djvulibre | http://djvu.sourceforge.net/ }}
*{{lib| poppler | http://poppler.freedesktop.org/ }}

==Audio==
*{{lib| soundtouch | http://www.surina.net/soundtouch/ }}

; Fingerprinting
*{{lib| chromaprint | http://acoustid.org/chromaprint }}
*{{lib| libofa | http://code.google.com/p/musicip-libofa/ }}
*{{lib| libmusicbrainz | http://musicbrainz.org }}

; Formats
*{{lib| audiofile | http://audiofile.68k.org/ }}
*{{lib| flac | http://flac.sourceforge.net/ }}

; Tagging
*{{lib| id3lib | http://id3lib.sourceforge.net/ }}
*{{lib| taglib | http://developer.kde.org/~wheeler/taglib.html }}

; CD
*{{lib| libkcompactdisc | http://www.kde.org/ }}

==Video==
*{{lib| crystalhd | http://www.broadcom.com/support/crystal_hd/ }}
*{{lib| mjpegtools | http://mjpeg.sourceforge.net/ }}
*{{lib| libmatroska | http://www.matroska.org/ }}
*{{lib| libVLC | http://wiki.videolan.org/LibVLC }}
*{{lib| gstreamermm | http://gstreamer.freedesktop.org/ }}

==3D Graphics==
*{{lib|Ogre3D|http://www.ogre3d.org/docs/manual/}}
*{{lib|OpenGL|http://www.opengl.org/}}
*{{lib|GLEW|http://glew.sourceforge.net/}} OpenGL function loading
*{{lib|GLFW|http://www.glfw.org/}} OpenGL window manager
*{{lib|assimp|http://assimp.sourceforge.net/}} 3D model loading

== Game Engine Architecture ==
*{{lib|EntityX|https://github.com/alecthomas/entityx}}
*{{lib|Anax|https://github.com/miguelishawt/anax}}


==Internationalization==
*{{lib|IBM ICU|http://site.icu-project.org/}}
*{{lib| gettext | http://www.gnu.org/software/gettext/ }}

==Math==
*{{lib|GNU MP bignum C++ interface|http://gmplib.org/manual/C_002b_002b-Class-Interface.html#C_002b_002b-Class-Interface}}
*{{lib|Boost.Multiprecision|http://www.boost.org/doc/libs/release/libs/multiprecision/doc/html/index.html}}
*{{lib|Boost.Math.Special Functions and Statistical Distributions|http://www.boost.org/doc/libs/release/libs/math/doc/sf_and_dist/html/}}
*{{lib|Boost.Random|http://www.boost.org/doc/libs/release/doc/html/boost_random.html}}

;Linear algebra
*{{lib|Boost.uBLAS|http://www.boost.org/doc/libs/release/libs/numeric/ublas/doc/index.htm}} 
*{{lib|Eigen|http://eigen.tuxfamily.org/index.php?title{{=}}Main_Page#Documentation}}
*{{lib|Armadillo|http://arma.sourceforge.net/}}
*{{lib|Blitz++|http://sourceforge.net/projects/blitz/}}
*{{lib|IT++|http://sourceforge.net/projects/itpp/}}
*{{lib| Dlib - linear algebra tools | http://dlib.net/linear_algebra.html }}

;Graph theory
*{{lib|Boost.Graph|http://www.boost.org/doc/libs/release/libs/graph/doc/index.html}}
*{{lib|LEMON|http://lemon.cs.elte.hu/trac/lemon}}
*{{lib| alglib | http://www.alglib.net/ }}
*{{lib|OGDF - Open Graph Drawing Framework|http://www.ogdf.net/}}

; Class Library for Numbers
*{{lib| cln | http://www.ginac.de/CLN/ }}

; Machine Learning
*{{lib| liblinear | http://www.csie.ntu.edu.tw/~cjlin/liblinear/ }}
*{{lib| Dlib - machine learning tools | http://dlib.net/ml.html }}
*{{lib| MLPACK - machine learning package | http://mlpack.org }}

; Computational geometry
*{{lib|CGAL - Computational geometry algorithms library |http://www.cgal.org/}}
*{{lib|Wykobi - Computational geometry library | http://www.wykobi.com}}


==Concurrency==
*{{lib|Intel TBB|http://threadingbuildingblocks.org/documentation.php}}
*{{lib|OpenMP|http://openmp.org/wp/openmp-specifications/}}
*{{lib|Thrust|http://thrust.github.io/}} STL-like algorithms and data-structures for CUDA
*{{lib|ViennaCL|http://viennacl.sourceforge.net/}} Linear algebra and algorithms with OpenMP, CUDA, and OpenCL backends
*{{lib|VexCL|https://github.com/ddemidov/vexcl}} C++ expression templates library for OpenCL and CUDA
*{{lib|Boost.Compute|https://github.com/kylelutz/compute}} (unofficial) STL-like algorithms and data-structures for OpenCL
*{{lib|Boost.Interprocess|http://www.boost.org/doc/libs/release/doc/html/interprocess.html}}
*{{lib|Boost.Thread|http://www.boost.org/doc/libs/release/doc/html/thread.html}}
*{{lib|Boost.Atomic|http://www.boost.org/doc/libs/release/doc/html/atomic.html}}
*{{lib|Boost.Lockfree|http://www.boost.org/doc/libs/release/doc/html/lockfree.html}}
*{{lib|Boost.MPI|http://www.boost.org/doc/libs/release/doc/html/mpi.html}}
*{{lib|Boost.Context|http://www.boost.org/doc/libs/release/libs/context/doc/html/index.html}}
*{{lib|libopenmpi | http://www.open-mpi.org/ }}
*{{lib|libsimdpp | https://github.com/p12tic/libsimdpp }} &lt;!-- would fit better in &quot;parallelism&quot; section, if one appears some day--&gt;
*{{lib|HPX|https://github.com/STEllAR-GROUP/hpx/}} A general purpose C++ runtime system for parallel and distributed applications of any scale

==Containers==
*{{lib|Boost.Any|http://www.boost.org/doc/libs/release/libs/any/}}
*{{lib|Boost.Array|http://www.boost.org/doc/libs/release/libs/array/}}
*{{lib|Boost.Bimap|http://www.boost.org/doc/libs/release/libs/bimap/}}
*{{lib|Boost.Container|http://www.boost.org/doc/libs/release/libs/container/}}
*{{lib|Boost.Fusion|http://www.boost.org/doc/libs/release/libs/fusion/}}
*{{lib|Boost.Heap|http://www.boost.org/doc/libs/release/libs/heap/}}
*{{lib|Boost.Pointer Container|http://www.boost.org/doc/libs/release/libs/ptr_container/}}
*{{lib|Boost.Tuple|http://www.boost.org/doc/libs/release/libs/tuple/}}
*{{lib|Boost.Variant|http://www.boost.org/doc/libs/release/libs/variant/}}
*{{lib|cpp-btree|https://code.google.com/p/cpp-btree/| btree_map, btree_set, btree_multimap, btree_multiset.}}

==Serialization==
*{{lib|Boost.Serialization|http://www.boost.org/doc/libs/release/libs/serialization/}}
*{{lib|libs11n|http://www.s11n.net}}
*{{lib|sweet_persist|http://www.sweetsoftware.co.nz/persist_overview.html}}
*{{lib|protobuf | http://code.google.com/p/protobuf/ }}
*{{lib|C++ XML objects | http://cppxmlobj.sourceforge.net}}
*{{lib|yaml-cpp| http://code.google.com/p/yaml-cpp/ }}
*{{lib|YAS (Yet Another Serialization)|https://github.com/niXman/yas}}
*{{lib|cereal (C++11 serialization)|http://uscilab.github.io/cereal/}}

==Testing==
*{{lib| Boost.Test | http://www.boost.org/libs/test/ }}
*{{lib| cppunit | http://sourceforge.net/projects/cppunit/}}
*{{lib| Google Test | http://code.google.com/p/googletest/}}
*{{lib| Catch | https://github.com/philsquared/Catch}}

==Benchmarking==
*{{lib| Celero | https://github.com/DigitalInBlue/Celero/ }}

==XML==
*{{lib| libxml++ | http://libxmlplusplus.sourceforge.net/}}
*{{lib| pugixml | http://pugixml.org/}}
*{{lib| tinyxml | http://www.grinninglizard.com/tinyxml/}}
*{{lib| Xerces | http://xerces.apache.org/xerces-c/}}

==JSON==
*{{lib|jsonme--|https://github.com/pibara/jsonme--}}
*{{lib|ThorsSerializer|https://github.com/Loki-Astari/ThorsSerializer}}
*{{lib|JsonBox|https://github.com/anhero/JsonBox}}
*{{lib|jsoncpp|http://sourceforge.net/projects/jsoncpp/}}
*{{lib|zoolib|http://www.zoolib.org/doc/}}
*{{lib|JOST|http://ddsbench.svn.sourceforge.net/viewvc/ddsbench/trunk/jost/}}
*{{lib|CAJUN|http://cajun-jsonapi.sourceforge.net/}}
*{{lib|libjson|http://sourceforge.net/projects/libjson/}}
*{{lib|nosjob|http://fossil.wanderinghorse.net/repos/nosjob/index.cgi/index}}
*{{lib|rapidjson|http://code.google.com/p/rapidjson/}}
*{{lib|jsoncons|http://sourceforge.net/projects/jsoncons/}}
*{{lib|JSON++|https://bitbucket.org/tunnuz/json}}
*{{lib|qjson|http://qjson.sourceforge.net/}}
*{{lib|json-cpp|https://github.com/ascheglov/json-cpp}}

==Web==
*{{lib| libmusicbrainz5 | http://musicbrainz.org/doc/libmusicbrainz }}
*{{lib| liblastfm | http://www.last.fm/ }}
*{{lib| libkcddb | http://www.kde.org/ }}
*{{lib| Chromium Embedded | https://code.google.com/p/chromiumembedded/ }}
*{{lib| Wt|http://www.webtoolkit.eu/wt/|doc=http://www.webtoolkit.eu/wt/doc/reference/html/index.html|src=http://www.webtoolkit.eu/wt/download}}

==GPS==
*{{lib| gpsd | http://www.catb.org/gpsd/ }}

==Databases==
*{{lib| mysql++ | http://dev.mysql.com/ }}
*{{lib| libpqxx | http://pqxx.org/development/libpqxx/ }}
*{{lib| sqlapi  | http://www.sqlapi.com/ }}
*{{lib| brig  | http://code.google.com/p/brig/ }}
*{{lib| SOCI | http://soci.sourceforge.net/ }}
*{{lib| DTL | http://dtemplatelib.sourceforge.net/ }}
*{{lib|sqlpp11|https://github.com/rbock/sqlpp11}}
*{{lib| ODB - C++ Object-Relational Mapping (ORM)|  http://www.codesynthesis.com/products/odb/}}

==Cryptography==
*{{lib| Botan | http://botan.randombit.net/ }}
*{{lib| gnutls | http://www.gnutls.org/ }}
*{{lib| openssl | http://www.openssl.org/ }}
*{{lib| crypto++ | http://www.cryptopp.com/ }}

==File metadata==
*{{lib| libkexiv2 | http://www.kde.org/ }}
*{{lib| exiv2 | http://www.exiv2.org }}
*{{lib| exempi | http://libopenraw.freedesktop.org/wiki/Exempi }}
*{{lib| rarian | http://rarian.freedesktop.org/ }}

==Text==
; Search
*{{lib| clucene | http://clucene.sourceforge.net }}
*{{lib| xapian | http://xapian.org/ }}

==Terminal==
*{{lib| cwidget | http://cwidget.alioth.debian.org }}

==Configuration==
*{{lib| gconfmm | http://www.gtkmm.org/ }}
*{{lib| libconfig| http://www.hyperrealm.com/libconfig/}}
*{{lib| Boost.Program_options | http://www.boost.org/doc/libs/1_51_0/doc/html/program_options.html}}

==Embedded languages bindings==
*{{lib| ExprTk | http://partow.net/programming/exprtk/index.html }}
*{{lib| mozjs | http://www.mozilla.org/js/spidermonkey/ }}
*{{lib| lua | http://www.lua.org }}
*{{lib| muparser | http://muparser.sourceforge.net }}
*{{lib| PythonQt | http://pythonqt.sourceforge.net/ }}

==Embedded/realtime==
*{{lib| QP/C++ | http://sourceforge.net/projects/qpc/files/QP_C%2B%2B/4.5.04/ | RTOS kernel, dual GPL }}
*{{lib| FreeRTOS C++ Handler | https://github.com/yuriykulikov/Event-driven_Framework_for_Embedded_Systems | handler, looper, state machine, CLI, portable }}

[[de:cpp/links/libs]]
[[es:cpp/links/libs]]
[[fr:cpp/links/libs]]
[[it:cpp/links/libs]]
[[ja:cpp/links/libs]]
[[pt:cpp/links/libs]]
[[ru:cpp/links/libs]]
[[zh:cpp/links/libs]]</text>
      <sha1>i3j6berxouuatgtu9jffpd2nptovs9d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale</title>
    <ns>0</ns>
    <id>718</id>
    <revision>
      <id>71006</id>
      <parentid>71005</parentid>
      <timestamp>2014-06-04T18:48:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="3266">{{title|Localization library}}
{{cpp/locale/navbar}}

The locale facility includes internationalization support for character classification and string collation, numeric, monetary, and date/time formatting and parsing, and message retrieval. Locale settings control the behavior of stream I/O, regular expression library, and other components of the C++ standard library.

=== Locales ===
{{dsc begin}}
{{dsc header | locale }}

{{dsc h2 | Locales and facets }}
{{dsc inc | cpp/locale/dsc locale}}
{{dsc inc | cpp/locale/dsc use_facet}}
{{dsc inc | cpp/locale/dsc has_facet}}

{{dsc h2 | Character classification }}
{{dsc inc | cpp/locale/dsc isspace}}
{{dsc inc | cpp/locale/dsc isblank}}
{{dsc inc | cpp/locale/dsc iscntrl}}
{{dsc inc | cpp/locale/dsc isupper}}
{{dsc inc | cpp/locale/dsc islower}}
{{dsc inc | cpp/locale/dsc isalpha}}
{{dsc inc | cpp/locale/dsc isdigit}}
{{dsc inc | cpp/locale/dsc ispunct}}
{{dsc inc | cpp/locale/dsc isxdigit}}
{{dsc inc | cpp/locale/dsc isalnum}}
{{dsc inc | cpp/locale/dsc isprint}}
{{dsc inc | cpp/locale/dsc isgraph}}

{{dsc h2 | Character conversions }}
{{dsc inc | cpp/locale/dsc toupper}}
{{dsc inc | cpp/locale/dsc tolower}}

{{dsc h2 | String and stream conversions }}
{{dsc inc | cpp/locale/dsc wstring_convert}}
{{dsc inc | cpp/locale/dsc wbuffer_convert}}

{{dsc h2 | Facet category base classes }}
{{dsc inc | cpp/locale/dsc ctype_base}}
{{dsc inc | cpp/locale/dsc codecvt_base}}
{{dsc inc | cpp/locale/dsc messages_base}}
{{dsc inc | cpp/locale/dsc time_base}}
{{dsc inc | cpp/locale/dsc money_base}}

{{dsc h2 | Facet categories }}
{{dsc inc | cpp/locale/dsc ctype}}
{{dsc inc | cpp/locale/dsc ctype_char}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc collate}}
{{dsc inc | cpp/locale/dsc messages}}
{{dsc inc | cpp/locale/dsc time_get}}
{{dsc inc | cpp/locale/dsc time_put}}
{{dsc inc | cpp/locale/dsc num_get}}
{{dsc inc | cpp/locale/dsc num_put}}
{{dsc inc | cpp/locale/dsc numpunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc inc | cpp/locale/dsc moneypunct}}

{{dsc h2 | Locale-specific facet categories }}
{{dsc inc | cpp/locale/dsc ctype_byname}}
{{dsc inc | cpp/locale/dsc codecvt_byname}}
{{dsc inc | cpp/locale/dsc messages_byname}}
{{dsc inc | cpp/locale/dsc collate_byname}}
{{dsc inc | cpp/locale/dsc time_get_byname}}
{{dsc inc | cpp/locale/dsc time_put_byname}}
{{dsc inc | cpp/locale/dsc numpunct_byname}}
{{dsc inc | cpp/locale/dsc moneypunct_byname}}
{{dsc end}}

=== Locale-independent unicode conversion facets ===
{{dsc begin}}
{{dsc header | codecvt }}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_mode}}
{{dsc end}}

=== C library locales ===
{{dsc begin}}
{{dsc header | clocale }}
{{dsc inc | cpp/locale/dsc setlocale}}
{{dsc inc | cpp/locale/dsc LC_categories}}
{{dsc inc | cpp/locale/dsc localeconv}}
{{dsc inc | cpp/locale/dsc lconv}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/locale | Localization support}}
{{dsc end}}

[[ar:cpp/locale]]
[[de:cpp/locale]]
[[es:cpp/locale]]
[[fr:cpp/locale]]
[[it:cpp/locale]]
[[ja:cpp/locale]]
[[pt:cpp/locale]]
[[ru:cpp/locale]]
[[zh:cpp/locale]]</text>
      <sha1>3tzbcks4ty8izsl0z8144d77z5lwajn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC ALL</title>
    <ns>0</ns>
    <id>4405</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15779</id>
      <parentid>15762</parentid>
      <timestamp>2011-12-15T17:05:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC COLLATE</title>
    <ns>0</ns>
    <id>4406</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15778</id>
      <parentid>15763</parentid>
      <timestamp>2011-12-15T17:05:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC CTYPE</title>
    <ns>0</ns>
    <id>4407</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15777</id>
      <parentid>15764</parentid>
      <timestamp>2011-12-15T17:05:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC MONETARY</title>
    <ns>0</ns>
    <id>4408</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15776</id>
      <parentid>15765</parentid>
      <timestamp>2011-12-15T17:05:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC NUMERIC</title>
    <ns>0</ns>
    <id>4409</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15773</id>
      <parentid>15766</parentid>
      <timestamp>2011-12-15T17:04:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC TIME</title>
    <ns>0</ns>
    <id>4410</id>
    <redirect title="cpp/locale/LC categories" />
    <revision>
      <id>15772</id>
      <parentid>15767</parentid>
      <timestamp>2011-12-15T17:04:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/LC categories]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/locale/LC_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/LC categories</title>
    <ns>0</ns>
    <id>4562</id>
    <revision>
      <id>60940</id>
      <parentid>58052</parentid>
      <timestamp>2013-06-01T17:16:54Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2565">{{title|&lt;small&gt;LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME&lt;/small&gt;}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header|clocale}}
{{dcl |
#define LC_ALL      /*implementation defined*/
}}
{{dcl |
#define LC_COLLATE  /*implementation defined*/
}}
{{dcl |
#define LC_CTYPE    /*implementation defined*/
}}
{{dcl |
#define LC_MONETARY /*implementation defined*/
}}
{{dcl |
#define LC_NUMERIC  /*implementation defined*/
}}
{{dcl |
#define LC_TIME     /*implementation defined*/
}}
{{dcl end}}

Each of the above macro constants expand to integer constant expressions with distinct values that are suitable for use as the first argument of {{lc|std::setlocale}}.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|LC_ALL}}      | selects the entire C locale}}
{{dsc | {{tt|LC_COLLATE}}  | selects the collation category of the C locale}}
{{dsc | {{tt|LC_CTYPE}}    | selects the character classification category of the C locale}}
{{dsc | {{tt|LC_MONETARY}} | selects the monetary formatting category of the C locale}}
{{dsc | {{tt|LC_NUMERIC}}  | selects the numeric formatting category of the C locale}}
{{dsc | {{tt|LC_TIME}}     | selects the time formatting category of the C locale}}
{{dsc end}}

Additional macro constants, with names that begin with {{tt|LC_}} followed by at least one uppercase letter, may be defined in {{tt|&lt;clocale&gt;}}. For example, the POSIX specification requires LC_MESSAGES and the GNU C library additionally defines LC_PAPER, LC_NAME, LC_ADDRESS, LC_TELEPHONE, LC_MEASUREMENT, and LC_IDENTIFICATION.

===Example===
{{example
 | 
 | code=
#include &lt;cstdio&gt;
#include &lt;clocale&gt;
#include &lt;ctime&gt;
#include &lt;cwchar&gt;

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.UTF-8&quot;); // the C locale will be the UTF-8 enabled English
    std::setlocale(LC_NUMERIC, &quot;de_DE&quot;);   // decimal dot will be German
    std::setlocale(LC_TIME, &quot;ja_JP&quot;);      // date/time formatting will be Japanese
    wchar_t str[100];
    std::time_t t = std::time(NULL);
    std::wcsftime(str, 100, L&quot;%A %c&quot;, std::localtime(&amp;t));
    std::wprintf(L&quot;Number: %.2f\nDate: %Ls\n&quot;, 3.14, str);
}
 | output=
Number: 3,14
Date: 月曜日 2011年12月19日 18時04分40秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc setlocale}}
{{dsc inc | cpp/locale/dsc locale}}
{{dsc end}}

[[de:cpp/locale/LC categories]]
[[es:cpp/locale/LC categories]]
[[fr:cpp/locale/LC categories]]
[[it:cpp/locale/LC categories]]
[[ja:cpp/locale/LC categories]]
[[pt:cpp/locale/LC categories]]
[[ru:cpp/locale/LC categories]]
[[zh:cpp/locale/LC categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt</title>
    <ns>0</ns>
    <id>2926</id>
    <revision>
      <id>65846</id>
      <parentid>65762</parentid>
      <timestamp>2013-10-10T12:46:15Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="5224">{{cpp/title | codecvt}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class InternT, 
    class ExternT, 
    class State
&gt; class codecvt;
}}
{{dcl end}}

Class {{lc|std::codecvt}} encapsulates conversion of character strings, including wide and multibyte, from one encoding to another. All file I/O operations performed through {{c|std::basic_fstream&lt;CharT&gt;}} use the {{c|std::codecvt&lt;CharT, char, std::mbstate_t&gt;}} facet of the locale imbued in the stream.

{{inheritance diagram/std-codecvt}}

Four standalone (locale-independent) specializations are provided by the standard library:

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} | identity conversion }}
{{dsc | {{c|std::codecvt&lt;char16_t, char, std::mbstate_t&gt;}} | conversion between UTF-16 and UTF-8 {{mark since c++11}}}}
{{dsc | {{c|std::codecvt&lt;char32_t, char, std::mbstate_t&gt;}} | conversion between UTF-32 and UTF-8 {{mark since c++11}}}}
{{dsc | {{c|std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;}} | conversion between the system's native wide and multibyte encodings}}
{{dsc end}}

In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these four specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|intern_type}} | {{tt|InternT}}}}
{{dsc | {{tt|extern_type}} | {{tt|ExternT}}}}
{{dsc | {{tt|state_type}} | {{tt|State}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/codecvt/codecvt | constructs a new codecvt facet }}
{{dsc prot mem dtor | cpp/locale/codecvt/~codecvt | destructs a codecvt facet }}
{{dsc inc | cpp/locale/codecvt/dsc out}}
{{dsc inc | cpp/locale/codecvt/dsc in}}
{{dsc inc | cpp/locale/codecvt/dsc unshift}}
{{dsc inc | cpp/locale/codecvt/dsc encoding}}
{{dsc inc | cpp/locale/codecvt/dsc always_noconv}}
{{dsc inc | cpp/locale/codecvt/dsc length}}
{{dsc inc | cpp/locale/codecvt/dsc max_length}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc inc | cpp/locale/codecvt/dsc do_unshift}}
{{dsc inc | cpp/locale/codecvt/dsc do_encoding}}
{{dsc inc | cpp/locale/codecvt/dsc do_always_noconv}}
{{dsc inc | cpp/locale/codecvt/dsc do_length}}
{{dsc inc | cpp/locale/codecvt/dsc do_max_length}}
{{dsc end}}

{{cpp/locale/codecvt_base/inherit}}

===Example===

{{example
 | The following examples reads a UTF-8 file using a locale which implements UTF-8 conversion in codecvt&lt;wchar_t, char, mbstate_t&gt; and converts a UTF-8 string to UTF-16 using one of the standard specializations of std::codecvt
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;codecvt&gt;

// utility wrapper to adapt locale-bound facets for wstring/wbuffer convert
template&lt;class Facet&gt;
struct deletable_facet : Facet
{
    template&lt;class ...Args&gt;
    deletable_facet(Args&amp;&amp; ...args) : Facet(std::forward&lt;Args&gt;(args)...) {}
    ~deletable_facet() {}
};

int main()
{
    // UTF-8 narrow multibyte encoding
    std::string data = u8&quot;z\u00df\u6c34\U0001f34c&quot;;
                       // or u8&quot;zß水🍌&quot;
                       // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9f\x8d\x8c&quot;;

    std::ofstream(&quot;text.txt&quot;) &lt;&lt; data;

    // using system-supplied locale's codecvt facet
    std::wifstream fin(&quot;text.txt&quot;);
    // reading from wifstream willl use codecvt&lt;wchar_t, char, mbstate_t&gt;
    // this locale's codecvt converts UTF-8 to UCS4 (on systems such as Linux)
    fin.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    std::cout &lt;&lt; &quot;The UTF-8 file contains the following UCS4 code points: \n&quot;;
    for (wchar_t c; fin &gt;&gt; c; )
        std::cout &lt;&lt; &quot;U+&quot; &lt;&lt; std::hex &lt;&lt; std::setw(4) &lt;&lt; std::setfill('0') &lt;&lt; c &lt;&lt; '\n';

    // using standard (locale-independent) codecvt facet
    std::wstring_convert&lt;
        deletable_facet&lt;std::codecvt&lt;char16_t, char, std::mbstate_t&gt;&gt;, char16_t&gt; conv16;
    std::u16string str16 = conv16.from_bytes(data);

    std::cout &lt;&lt; &quot;The UTF-8 file contains the following UTF-16 code points: \n&quot;;
    for (char16_t c : str16)
        std::cout &lt;&lt; &quot;U+&quot; &lt;&lt; std::hex &lt;&lt; std::setw(4) &lt;&lt; std::setfill('0') &lt;&lt; c &lt;&lt; '\n';
}
 | output=
The UTF-8 file contains the following UCS4 code points:
U+007a
U+00df
U+6c34
U+1f34c
The UTF-8 file contains the following UTF-16 code points:
U+007a
U+00df
U+6c34
U+d83c
U+df4c
}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc tclass | cpp/locale/codecvt_base | defines character conversion errors }}
{{dsc tclass | cpp/locale/codecvt_byname | creates a codecvt facet for the named locale }}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/codecvt]]
[[es:cpp/locale/codecvt]]
[[fr:cpp/locale/codecvt]]
[[it:cpp/locale/codecvt]]
[[ja:cpp/locale/codecvt]]
[[pt:cpp/locale/codecvt]]
[[ru:cpp/locale/codecvt]]
[[zh:cpp/locale/codecvt]]</text>
      <sha1>toyymex43x3u4aimt1g41a5vln03d70</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/always noconv</title>
    <ns>0</ns>
    <id>5170</id>
    <revision>
      <id>64838</id>
      <parentid>63166</parentid>
      <timestamp>2013-08-27T01:20:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, noexcept</comment>
      <text xml:space="preserve" bytes="2142">{{cpp/codecvt/title|always_noconv, do_always_noconv}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
bool always_noconv() const;
}}
{{dcl | num=2 | 1=
protected:
bool do_always_noconv() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_always_noconv}} of the most derived class.

@2@ Returns {{c|true}} if both {{lc|do_in()}} and {{lc|do_out()}} return {{tt|std::codecvt_base::noconv}} for all valid inputs.

===Return value===
{{c|true}} if this conversion facet performs no conversions, {{c|false}} otherwise.

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} returns {{c|true}}

===Notes===
This function may be used e.g. in the implementation of {{c|std::basic_filebuf::underflow}} to use bulk character copy instead of calling {{c|std::codecvt::in}} if it is known that the locale imbued in the {{lc|std::basic_filebuf}} does not perform any conversions.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; &quot;The non-converting char&lt;-&gt;char codecvt::always_noconv() returns &quot; 
              &lt;&lt; std::boolalpha
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;char, char, std::mbstate_t&gt;&gt;(
                    std::locale()
                 ).always_noconv() &lt;&lt; &quot;\n&quot;
              &lt;&lt; &quot;while wchar_t&lt;-&gt;char codecvt::always_noconv() returns &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale()
                 ).always_noconv() &lt;&lt; &quot;\n&quot;;

}
 | output=
The non-converting char&lt;-&gt;char codecvt::always_noconv() returns true
while wchar_t&lt;-&gt;char codecvt::always_noconv() returns false
}}

[[de:cpp/locale/codecvt/always noconv]]
[[es:cpp/locale/codecvt/always noconv]]
[[fr:cpp/locale/codecvt/always noconv]]
[[it:cpp/locale/codecvt/always noconv]]
[[ja:cpp/locale/codecvt/always noconv]]
[[pt:cpp/locale/codecvt/always noconv]]
[[ru:cpp/locale/codecvt/always noconv]]
[[zh:cpp/locale/codecvt/always noconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/codecvt</title>
    <ns>0</ns>
    <id>4383</id>
    <revision>
      <id>43797</id>
      <parentid>15732</parentid>
      <timestamp>2012-11-03T03:52:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="313">{{cpp/locale/facet/constructor|codecvt}}

[[de:cpp/locale/codecvt/codecvt]]
[[es:cpp/locale/codecvt/codecvt]]
[[fr:cpp/locale/codecvt/codecvt]]
[[it:cpp/locale/codecvt/codecvt]]
[[ja:cpp/locale/codecvt/codecvt]]
[[pt:cpp/locale/codecvt/codecvt]]
[[ru:cpp/locale/codecvt/codecvt]]
[[zh:cpp/locale/codecvt/codecvt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do always noconv</title>
    <ns>0</ns>
    <id>9458</id>
    <redirect title="cpp/locale/codecvt/always noconv" />
    <revision>
      <id>40292</id>
      <timestamp>2012-10-12T18:42:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do always noconv]] to [[cpp/locale/codecvt/always noconv]]</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/locale/codecvt/always noconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do encoding</title>
    <ns>0</ns>
    <id>9459</id>
    <redirect title="cpp/locale/codecvt/encoding" />
    <revision>
      <id>40294</id>
      <timestamp>2012-10-12T18:42:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do encoding]] to [[cpp/locale/codecvt/encoding]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[cpp/locale/codecvt/encoding]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do in</title>
    <ns>0</ns>
    <id>9461</id>
    <redirect title="cpp/locale/codecvt/in" />
    <revision>
      <id>40298</id>
      <timestamp>2012-10-12T18:42:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do in]] to [[cpp/locale/codecvt/in]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/locale/codecvt/in]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do length</title>
    <ns>0</ns>
    <id>9457</id>
    <redirect title="cpp/locale/codecvt/length" />
    <revision>
      <id>40290</id>
      <timestamp>2012-10-12T18:42:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do length]] to [[cpp/locale/codecvt/length]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/locale/codecvt/length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do max length</title>
    <ns>0</ns>
    <id>9456</id>
    <redirect title="cpp/locale/codecvt/max length" />
    <revision>
      <id>40288</id>
      <timestamp>2012-10-12T18:42:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do max length]] to [[cpp/locale/codecvt/max length]]</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/locale/codecvt/max length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do out</title>
    <ns>0</ns>
    <id>9462</id>
    <redirect title="cpp/locale/codecvt/out" />
    <revision>
      <id>40300</id>
      <timestamp>2012-10-12T18:42:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do out]] to [[cpp/locale/codecvt/out]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/locale/codecvt/out]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/do unshift</title>
    <ns>0</ns>
    <id>9460</id>
    <redirect title="cpp/locale/codecvt/unshift" />
    <revision>
      <id>40296</id>
      <timestamp>2012-10-12T18:42:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/codecvt/do unshift]] to [[cpp/locale/codecvt/unshift]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/locale/codecvt/unshift]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/encoding</title>
    <ns>0</ns>
    <id>5175</id>
    <revision>
      <id>64837</id>
      <parentid>63165</parentid>
      <timestamp>2013-08-27T01:20:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, noexcept</comment>
      <text xml:space="preserve" bytes="2447">{{cpp/codecvt/title|encoding, do_encoding}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
int encoding() const
}}
{{dcl | num=2 | 1=
protected:
int do_encoding() const
}}
{{dcl end}}

@1@ public member function, calls the member function {{tt|do_encoding}} of the most derived class.

@2@ if the encoding represented by this codecvt facet maps each internal character to the same, constant number of external characters, returns that number. If the encoding is variable-length (e.g. UTF-8 or UTF-16), returns {{c|0}}. If the encoding is state-dependent, returns {{c|-1}}.

===Return value===
The exact number of {{tt|externT}} characters that correspond to one {{tt|internT}} character, if constant. {{c|0}} if the number varies, {{c|-1}} if the encoding is state-dependent.

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} returns {{c|1}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; &quot;en_US.utf8 is a variable-length encoding, encoding() returns &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;en_US.utf8&quot;)
              ).encoding() &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;zh_CN.gb18030 is also variable-length, encoding() == &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;zh_CN.gb18030&quot;)
              ).encoding() &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;ru_RU.koi8r is a single-byte encoding encoding() == &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;ru_RU.koi8r&quot;)
              ).encoding() &lt;&lt; '\n';
}
 | output=
en_US.utf8 is a variable-length encoding, encoding() returns 0
zh_CN.gb18030 is also variable-length, encoding() == 0
ru_RU.koi8r is a single-byte encoding encoding() == 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc MB_CUR_MAX}}
{{dsc inc | cpp/locale/codecvt/dsc do_max_length}}
{{dsc end}}

[[de:cpp/locale/codecvt/encoding]]
[[es:cpp/locale/codecvt/encoding]]
[[fr:cpp/locale/codecvt/encoding]]
[[it:cpp/locale/codecvt/encoding]]
[[ja:cpp/locale/codecvt/encoding]]
[[pt:cpp/locale/codecvt/encoding]]
[[ru:cpp/locale/codecvt/encoding]]
[[zh:cpp/locale/codecvt/encoding]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/in</title>
    <ns>0</ns>
    <id>5181</id>
    <revision>
      <id>63164</id>
      <parentid>62382</parentid>
      <timestamp>2013-07-04T00:08:22Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4012">{{cpp/codecvt/title|in|do_in}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
result in( stateT&amp; state,
           const externT* from,
           const externT* from_end,
           const externT*&amp; from_next,
           internT* to,
           internT* to_end,
           internT*&amp; to_next ) const;
}}
{{dcl | num=2 | 1=
protected:
result do_in( stateT&amp; state,
              const externT* from,
              const externT* from_end,
              const externT*&amp; from_next,
              internT* to,
              internT* to_end,
              internT*&amp; to_next ) const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_in}} of the most derived class.

@2@ If this {{tt|codecvt}} facet defines a conversion, translates the external characters from the source range {{tt|[from, from_end)}} to internal characters, placing the results in the subsequent locations starting at {{tt|to}}. Converts no more than {{c|from_end - from}} external characters and writes no more than {{c|to_end - to}} internal characters. Leaves {{tt|from_next}} and {{tt|to_next}} pointing one beyond the last element successfully converted.

If this {{tt|codecvt}} facet does not define a conversion, no characters are converted. {{tt|to_next}} is set to be equal to {{tt|to}}, {{tt|state}} is unchanged, and {{lc|std::codecvt_base::noconv}} is returned.

===Return value===
A value of type {{lc|std::codecvt_base::result}}, indicating the success status as follows:
{{dsc begin}}
{{dsc | {{tt|ok}} | conversion completed}}
{{dsc | {{tt|partial}} | not enough space in the output buffer or unexpected end of source buffer}}
{{dsc | {{tt|error}} | encountered a character that could not be converted}}
{{dsc | {{tt|noconv}} | this facet is non-converting, no output written}}
{{dsc end}}

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} always returns {{lc|std::codecvt_base::noconv}}

===Notes===
Requires that {{c|1=from &lt;= from_end &amp;&amp; to &lt;= to_end}} and that {{tt|state}} either representing the initial shift state or obtained by converting the preceding characters in the sequence.

The effect on {{tt|state}} is deliberately unspecified. In standard facets, it is used to maintain shift state like when calling {{lc|std::mbsrtowcs}}, and is therefore updated to reflect the conversion state after the last processed external character, but a user-defined facet is free to use it to maintain any other state, e.g. count the number of special characters encountered.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    auto&amp; f = std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(std::locale());
    std::string external = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                          // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;

    // note that the following can be done with wstring_convert
    std::mbstate_t mb = std::mbstate_t(); // initial shift state
    std::wstring internal(external.size(), '\0'); 
    const char* from_next;
    wchar_t* to_next;
    f.in(mb, &amp;external[0], &amp;external[external.size()], from_next,
             &amp;internal[0], &amp;internal[internal.size()], to_next);
    // error checking skipped for brevity
    internal.resize(to_next - &amp;internal[0]);

    std::wcout &lt;&lt; L&quot;The string in wide encoding: &quot; &lt;&lt; internal &lt;&lt; '\n';
}
 | output=
The string in wide encoding: zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc underflow}}
{{dsc inc | cpp/locale/wstring_convert/dsc from_bytes}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc end}}

[[de:cpp/locale/codecvt/in]]
[[es:cpp/locale/codecvt/in]]
[[fr:cpp/locale/codecvt/in]]
[[it:cpp/locale/codecvt/in]]
[[ja:cpp/locale/codecvt/in]]
[[pt:cpp/locale/codecvt/in]]
[[ru:cpp/locale/codecvt/in]]
[[zh:cpp/locale/codecvt/in]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/length</title>
    <ns>0</ns>
    <id>5163</id>
    <revision>
      <id>71513</id>
      <parentid>64247</parentid>
      <timestamp>2014-06-12T07:01:21Z</timestamp>
      <contributor>
        <ip>98.207.250.35</ip>
      </contributor>
      <comment>Fix typo</comment>
      <text xml:space="preserve" bytes="2511">{{cpp/codecvt/title|length, do_length}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
int length( StateT&amp; state,
            const ExternT* from,
            const ExternT* from_end,
            std::size_t max ) const
}}
{{dcl | num=2 | 1=
protected:
int do_length( StateT&amp; state,
               const ExternT* from,
               const ExternT* from_end,
               std::size_t max ) const
}}
{{dcl end}}

@1@ public member function, calls the member function {{tt|do_length}} of the most derived class.

@2@ attempts to convert the {{tt|externT}} characters from the character array defined by {{tt|[from, from_end)}}, given initial conversion state {{tt|state}}, to at most {{tt|max}} {{tt|internT}} characters, and returns the number of {{tt|externT}} characters that such conversion would consume. Modifies {{tt|state}} as if by executing {{c|do_in(state, from, from_end, from, to, to+max, to)}} for some imaginary {{tt|[to, to+max)}} output buffer.

===Return value===
The number of {{tt|externT}} characters that would be consumed if converted by {{lc|do_in()}} until either all {{c|from_end-from}} characters were consumed or {{tt|max}} {{tt|internT}} characters were produced, or a conversion error occurred.

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} returns {{c|std::min(max, from_end-from)}}

===Example===

{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{
    //  narrow multibyte encoding
    std::string s = &quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                      // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    std::mbstate_t mb = std::mbstate_t();
    std::cout &lt;&lt; &quot;Only the first &quot; &lt;&lt;
              std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;en_US.utf8&quot;)
              ).length(mb, &amp;s[0], &amp;s[s.size()], 2)
              &lt;&lt; &quot; bytes out of &quot; &lt;&lt; s.size() &lt;&lt; &quot; would be consumed &quot;
                 &quot; to produce the first 2 characters\n&quot;;
}
 | output=
Only the first 3 bytes out of 10 would be consumed to produce the first 2 characters
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc end}}

[[de:cpp/locale/codecvt/length]]
[[es:cpp/locale/codecvt/length]]
[[fr:cpp/locale/codecvt/length]]
[[it:cpp/locale/codecvt/length]]
[[ja:cpp/locale/codecvt/length]]
[[pt:cpp/locale/codecvt/length]]
[[ru:cpp/locale/codecvt/length]]
[[zh:cpp/locale/codecvt/length]]</text>
      <sha1>hhcddx60x52yu34obwg895rctfulnmv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/max length</title>
    <ns>0</ns>
    <id>5166</id>
    <revision>
      <id>64839</id>
      <parentid>64248</parentid>
      <timestamp>2013-08-27T01:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="2865">{{cpp/codecvt/title|max_length, do_max_length}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
int max_length() const
}}
{{dcl | num=2 | 1=
protected:
int do_max_length() const
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_max_length}} of the most derived class.

@2@ Returns the maximum value that {{c|do_length(state, from, from_end, 1)}} can return for any valid range {{tt|[from, from_end)}} and any valid {{tt|state}}.

===Return value===
The maximum number of {{tt|ExternT}} characters that could be consumed if converted by {{lc|in()}} to produce one {{tt|InternT}} character.

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} returns {{c|1}}

===Notes===
If the encoding is state-dependent ({{c|1=encoding() == -1}}), then more than {{tt|max_length()}} external characters may be consumed to produce one internal character

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===

{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;codecvt&gt;

int main()
{
    std::cout &lt;&lt; &quot;In codecvt_utf8, the longest multibyte character is &quot;
              &lt;&lt; std::codecvt_utf8&lt;wchar_t&gt;().max_length() &lt;&lt; &quot; bytes long\n&quot;;

    std::cout &lt;&lt; &quot;In header-consuming codecvt_utf8, the longest multibyte character is &quot;
              &lt;&lt; std::codecvt_utf8&lt;wchar_t,
                                   0x10ffff,
                                   std::consume_header&gt;().max_length() &lt;&lt; &quot; bytes long\n&quot;;

    std::cout &lt;&lt; &quot;In this system's en_US.utf8, the longest multibyte character is &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;en_US.utf8&quot;)
              ).max_length() &lt;&lt; &quot; bytes long\n&quot;;

    std::cout &lt;&lt; &quot;In this system's zh_CN.gb18030, the longest multibyte character is &quot;
              &lt;&lt; std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(
                    std::locale(&quot;zh_CN.gb18030&quot;)
              ).max_length() &lt;&lt; &quot; bytes long\n&quot;;
}
 | output=
In codecvt_utf8, the longest multibyte character is 4 bytes long
In header-consuming codecvt_utf8, the longest multibyte character is 7 bytes long
In this system's en_US.utf8, the longest multibyte character is 6 bytes long
In this system's zh_CN.gb18030, the longest multibyte character is 4 bytes long
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc MB_CUR_MAX}}
{{dsc inc | cpp/locale/codecvt/dsc do_encoding}}
{{dsc end}}

[[de:cpp/locale/codecvt/max length]]
[[es:cpp/locale/codecvt/max length]]
[[fr:cpp/locale/codecvt/max length]]
[[it:cpp/locale/codecvt/max length]]
[[ja:cpp/locale/codecvt/max length]]
[[pt:cpp/locale/codecvt/max length]]
[[ru:cpp/locale/codecvt/max length]]
[[zh:cpp/locale/codecvt/max length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/out</title>
    <ns>0</ns>
    <id>5179</id>
    <revision>
      <id>62444</id>
      <parentid>62387</parentid>
      <timestamp>2013-06-30T01:21:08Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4691">{{cpp/codecvt/title|out, do_out}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
result out( StateT&amp; state,
            const InternT* from,
            const InternT* from_end,
            const InternT*&amp; from_next,
            ExternT* to,
            ExternT* to_end,
            ExternT*&amp; to_next ) const;
}}
{{dcl | num=2 | 1=
protected:
result do_out( StateT&amp; state,
               const InternT* from,
               const InternT* from_end,
               const InternT*&amp; from_next,
               ExternT* to,
               ExternT* to_end,
               ExternT*&amp; to_next ) const;

}}
{{dcl end}}

@1@ public member function, calls the member function {{tt|do_out}} of the most derived class.

@2@ If this {{tt|codecvt}} facet defines a conversion, translates the internal characters from the source range {{tt|[from, from_end)}} to external characters, placing the results in the subsequent locations starting at {{tt|to}}. Converts no more than {{c|from_end - from}} internal characters and writes no more than {{c|to_end - to}} external characters. Leaves {{tt|from_next}} and {{tt|to_next}} pointing one beyond the last element successfully converted.

If this {{tt|codecvt}} facet does not define a conversion, no characters are converted. {{tt|to_next}} is set to be equal to {{tt|to}}, {{tt|state}} is unchanged, and {{lc|std::codecvt_base::noconv}} is returned.

===Return value===
A value of type {{lc|std::codecvt_base::result}}, indicating the success status as follows:
{{dsc begin}}
{{dsc | {{tt|ok}} | conversion completed}}
{{dsc | {{tt|partial}} | not enough space in the output buffer or unexpected end of source buffer}}
{{dsc | {{tt|error}} | encountered a character that could not be converted}}
{{dsc | {{tt|noconv}} | this facet is non-converting, no output written}}
{{dsc end}}

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} always returns {{lc|std::codecvt_base::noconv}}

===Notes===
Requires that {{c|1=from &lt;= from_end &amp;&amp; to &lt;= to_end}} and that {{tt|state}} either representing the initial shift state or obtained by converting the preceding characters in the sequence.

While {{tt|codecvt}} supports N:M conversions (e.g. UTF-16 to UTF-8, where two internal characters may be necessary to decide what external characters to output), {{lc|std::basic_filebuf}} can only use {{tt|codecvt}} facets that define a 1:N conversion, that is it must be able to process one internal character at a time when writing to a file.

When performing N:M conversions, this function may return {{lc|std::codecvt_base::partial}} after consuming all source characters ({{tt|from_next {{==}} from_end}}). This means that another internal character is needed to complete the conversion (e.g. when converting UTF-16 to UTF-8, if the last character in the source buffer is a high surrogate).

The effect on {{tt|state}} is deliberately unspecified. In standard facets, it is used to maintain shift state like when calling {{c|std::wcsrtombs}}, and is therefore updated to reflect the shift state after the last successfully converted character, but a user-defined facet is free to use it to maintain any other state, e.g. count the number of special characters encountered.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    auto&amp; f = std::use_facet&lt;std::codecvt&lt;wchar_t, char, std::mbstate_t&gt;&gt;(std::locale());
    std::wstring internal = L&quot;z\u00df\u6c34\U0001d10b&quot;; // L&quot;zß水𝄋&quot;

    // note that the following can be done with wstring_convert
    std::mbstate_t mb = std::mbstate_t(); // initial shift state
    std::string external(internal.size() * f.max_length(), '\0'); 
    const wchar_t* from_next;
    char* to_next;
    f.out(mb, &amp;internal[0], &amp;internal[internal.size()], from_next,
              &amp;external[0], &amp;external[external.size()], to_next);
    // error checking skipped for brevity
    external.resize(to_next - &amp;external[0]);

    std::cout &lt;&lt; &quot;The string in narrow multibyte encoding: &quot; &lt;&lt; external &lt;&lt; '\n';
}
 | output=
The string in narrow multibyte encoding: zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_filebuf/dsc overflow}}
{{dsc inc | cpp/locale/wstring_convert/dsc to_bytes}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc end}}

[[de:cpp/locale/codecvt/out]]
[[es:cpp/locale/codecvt/out]]
[[fr:cpp/locale/codecvt/out]]
[[it:cpp/locale/codecvt/out]]
[[ja:cpp/locale/codecvt/out]]
[[pt:cpp/locale/codecvt/out]]
[[ru:cpp/locale/codecvt/out]]
[[zh:cpp/locale/codecvt/out]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/unshift</title>
    <ns>0</ns>
    <id>5176</id>
    <revision>
      <id>62383</id>
      <parentid>58065</parentid>
      <timestamp>2013-06-27T01:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2275">{{cpp/codecvt/title|unshift, do_unshift}}
{{cpp/locale/codecvt/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
result unshift( StateT&amp; state,
                ExternT* to,
                ExternT* to_end,
                ExternT*&amp; to_next) const
}}
{{dcl | num=2 | 1=
protected:
result do_unshift( StateT&amp; state,
                   ExternT* to,
                   ExternT* to_end,
                   ExternT*&amp; to_next) const
}}
{{dcl end}}

@1@ public member function, calls the member function {{tt|do_unshift}} of the most derived class.

@2@ if the encoding represented by this {{tt|codecvt}} facet is state-dependent, and {{tt|state}} represents a conversion state that is not the initial shift state, writes the characters necessary to return to the initial shift state. The characters are written to a character array whose first element is pointed to by {{tt|to}}. No more than {{tt|to_end-to}} characters are written. The parameter {{tt|to_next}} is updated to point one past the last character written.

===Return value===
A value of type {{lc|std::codecvt_base::result}}, indicating the success status as follows:
{{dsc begin}}
{{dsc | {{tt|ok}} | all necessary characters were written. {{tt|state}} now represents initial shift state}}
{{dsc | {{tt|partial}} | not enough space in the output buffer. {{c|1=to_next == to_end}}}}
{{dsc | {{tt|error}} | unspecified error occurred}}
{{dsc | {{tt|noconv}} | the encoding is not state-dependent, no termination sequence necessary}}
{{dsc end}}

The non-converting specialization {{c|std::codecvt&lt;char, char, std::mbstate_t&gt;}} always returns {{lc|std::codecvt_base::noconv}}

===Notes===
This function is called by {{c|std::basic_filebuf::close()}} and in other situations when finalizing a state-dependent multibyte character sequence.

===Example===

{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc end}}

[[de:cpp/locale/codecvt/unshift]]
[[es:cpp/locale/codecvt/unshift]]
[[fr:cpp/locale/codecvt/unshift]]
[[it:cpp/locale/codecvt/unshift]]
[[ja:cpp/locale/codecvt/unshift]]
[[pt:cpp/locale/codecvt/unshift]]
[[ru:cpp/locale/codecvt/unshift]]
[[zh:cpp/locale/codecvt/unshift]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt/~codecvt</title>
    <ns>0</ns>
    <id>4437</id>
    <revision>
      <id>43753</id>
      <parentid>15809</parentid>
      <timestamp>2012-11-03T03:44:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="320">{{cpp/locale/facet/destructor|codecvt}}

[[de:cpp/locale/codecvt/~codecvt]]
[[es:cpp/locale/codecvt/~codecvt]]
[[fr:cpp/locale/codecvt/~codecvt]]
[[it:cpp/locale/codecvt/~codecvt]]
[[ja:cpp/locale/codecvt/~codecvt]]
[[pt:cpp/locale/codecvt/~codecvt]]
[[ru:cpp/locale/codecvt/~codecvt]]
[[zh:cpp/locale/codecvt/~codecvt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt base</title>
    <ns>0</ns>
    <id>3605</id>
    <revision>
      <id>58068</id>
      <parentid>49987</parentid>
      <timestamp>2013-06-01T06:07:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1370">{{cpp/title | codecvt_base}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class codecvt_base;
}}
{{dcl end}}

The class {{lc|std::codecvt_base}} provides the conversion status constants which are inherited and used by the {{lc|std::codecvt}} facets.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|enum result { ok, partial, error, noconv };}} | Unscoped enumeration type}}
{{dsc end}}

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | {{tt|ok}}      | conversion was completed with no error}}
{{dsc | {{tt|partial}} | not all source characters were converted}}
{{dsc | {{tt|error}}   | encountered an invalid character}}
{{dsc | {{tt|noconv}}  | no conversion required, input and output types are the same}}
{{dsc end}}

===Notes===
The value {{lc|std::codecvt_base::partial}} is used to indicate that either the destination range is too short to receive the results of the conversion or the input is truncated in the middle of an otherwise valid multibyte character.

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc end}}

[[de:cpp/locale/codecvt base]]
[[es:cpp/locale/codecvt base]]
[[fr:cpp/locale/codecvt base]]
[[it:cpp/locale/codecvt base]]
[[ja:cpp/locale/codecvt base]]
[[pt:cpp/locale/codecvt base]]
[[ru:cpp/locale/codecvt base]]
[[zh:cpp/locale/codecvt base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt byname</title>
    <ns>0</ns>
    <id>2958</id>
    <revision>
      <id>62465</id>
      <parentid>61616</parentid>
      <timestamp>2013-06-30T19:13:16Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2634">{{cpp/title | codecvt_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class InternT, class ExternT, class State &gt;
class codecvt_byname : public std::codecvt&lt;InternT, ExternT, State&gt;;
}}
{{dcl end}}

{{lc|std::codecvt_byname}} is a {{lc|std::codecvt}} facet which encapsulates multibyte/wide character conversion rules of a locale specified at its construction.

Four specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::codecvt_byname&lt;char, char, std::mbstate_t&gt;}} | identity conversion }}
{{dsc | {{c|std::codecvt_byname&lt;char16_t, char, std::mbstate_t&gt;}} | conversion between UTF-16 and UTF-8 {{mark since c++11}}}}
{{dsc | {{c|std::codecvt_byname&lt;char32_t, char, std::mbstate_t&gt;}} | conversion between UTF-32 and UTF-8 {{mark since c++11}}}}
{{dsc | {{c|std::codecvt_byname&lt;wchar_t, char, std::mbstate_t&gt;}} | locale-specific conversion between wide string and narrow, possibly multibyte, string}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | codecvt_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | codecvt_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | codecvt_byname}}
{{include | cpp/locale/byname/destructor | codecvt_byname}}

{{cpp/locale/codecvt/inherit}}
{{cpp/locale/codecvt_base/inherit}}

===Example===
{{example
 | This example demonstrates reading a GB18030-encoded file using the codecvt facet from a GB18030-aware locale
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;

int main()
{
    // GB18030 narrow multibyte encoding
    std::ofstream(&quot;text.txt&quot;) &lt;&lt; &quot;\x7a&quot;              // letter 'z', U+007a
                                 &quot;\x81\x30\x89\x38&quot;  // letter 'ß', U+00df
                                 &quot;\xcb\xae&quot;          // CJK ideogram '水' (water), U+6c34
                                 &quot;\x94\x32\xbc\x35&quot;; // musical sign '𝄋' (segno), U+1d10b
    std::wifstream fin(&quot;text.txt&quot;);
    fin.imbue(std::locale(fin.getloc(),
              new std::codecvt_byname&lt;wchar_t, char, std::mbstate_t&gt;(&quot;zh_CN.gb18030&quot;)));
    for (wchar_t c; fin.get(c); )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
}
 | output=
0x7a
0xdf
0x6c34
0x1d10b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc end}}

[[de:cpp/locale/codecvt byname]]
[[es:cpp/locale/codecvt byname]]
[[fr:cpp/locale/codecvt byname]]
[[it:cpp/locale/codecvt byname]]
[[ja:cpp/locale/codecvt byname]]
[[pt:cpp/locale/codecvt byname]]
[[ru:cpp/locale/codecvt byname]]
[[zh:cpp/locale/codecvt byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt mode</title>
    <ns>0</ns>
    <id>2924</id>
    <revision>
      <id>62445</id>
      <parentid>58072</parentid>
      <timestamp>2013-06-30T01:26:13Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2512">{{cpp/title | codecvt_mode}}
{{cpp/locale/navbar}}
{{ddcl | header=locale | 1=
enum codecvt_mode {
    consume_header = 4,
    generate_header = 2,
    little_endian = 1
};
}}

The facets {{lc|std::codecvt_utf8}}, {{lc|std::codecvt_utf16}}, and {{lc|std::codecvt_utf8_utf16}} accept an optional value of type {{lc|std::codecvt_mode}} as a template argument, which specifies optional features of the unicode string conversion.

===Constants===

{{dsc begin}}
{{dsc header | locale}}
{{dsc hitem | Value | Meaning }}
{{dsc | {{tt|little_endian}}  | assume the input is in little-endian byte order (applies to UTF-16 input only, the default is big-endian) }}
{{dsc | {{tt|consume_header}} | consume the byte order mark, if present at the start of input sequence, and (in case of UTF-16), rely on the byte order it specifies for decoding the rest of the input}}
{{dsc | {{tt|generate_header}} | output the byte order mark at the start of the output sequence }}
{{dsc end}}

The recognized byte order marks are:
{{dsc begin}}
{{dsc | {{tt|0xfe 0xff}} | UTF-16 big-endian }}
{{dsc | {{tt|0xff 0xfe}} | UTF-16 little-endian }}
{{dsc | {{tt|0xef 0xbb 0xbf}} | UTF-8 (no effect on endianness)}}
{{dsc end}}

If {{lc|std::consume_header}} is not selected when reading a file beginning with byte order mark, the Unicode character U+FEFF (Zero width non-breaking space) will be read as the first character of the string content.

===Example===
{{example
 | The following example demonstrates consuming the UTF-8 BOM
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

int main()
{
    // UTF-8 data with BOM
    std::ofstream(&quot;text.txt&quot;) &lt;&lt; u8&quot;\ufeffz\u6c34\U0001d10b&quot;;
    // read the UTF8 file, skipping the BOM
    std::wifstream fin(&quot;text.txt&quot;);
    fin.imbue(std::locale(fin.getloc(),
                          new std::codecvt_utf8&lt;wchar_t, 0x10ffff, std::consume_header&gt;));
    for (wchar_t c; fin.get(c); )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
}
 | output=
0x7a
0x6c34
0x1d10b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/codecvt mode]]
[[es:cpp/locale/codecvt mode]]
[[fr:cpp/locale/codecvt mode]]
[[it:cpp/locale/codecvt mode]]
[[ja:cpp/locale/codecvt mode]]
[[pt:cpp/locale/codecvt mode]]
[[ru:cpp/locale/codecvt mode]]
[[zh:cpp/locale/codecvt mode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt utf16</title>
    <ns>0</ns>
    <id>2910</id>
    <revision>
      <id>64475</id>
      <parentid>62462</parentid>
      <timestamp>2013-08-18T02:47:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>ctor/dtor (LWG 2229/C++14</comment>
      <text xml:space="preserve" bytes="3508">{{cpp/title | codecvt_utf16 }}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | codecvt }}
{{dcl | 1=
template&lt; class Elem,
          unsigned long Maxcode = 0x10ffff,
          std::codecvt_mode Mode = (std::codecvt_mode)0 &gt;
class codecvt_utf16 : public std::codecvt&lt;Elem, char, std::mbstate_t&gt;;;
}}
{{dcl end}}

{{lc|std::codecvt_utf16}} is a {{lc|std::codecvt}} facet which encapsulates conversion between a UTF-16 encoded byte string and UCS2 or UCS4 character string (depending on the type of {{tt|Elem}}). This codecvt facet can be used to read and write UTF-16 files in binary mode. 

===Template Parameters===
{{par begin}}
{{par | Elem | either {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}} }}
{{par | Maxcode | the largest value of {{tt|Elem}} that this facet will read or write without error }}
{{par | Mode | a constant of type {{lc|std::codecvt_mode}} }}
{{par end}} 

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/codecvt_utf16 | inlinemem=true | constructs a new {{tt|codecvt_utf16}} facet }}
{{dsc mem dtor | cpp/locale/codecvt_utf16 | inlinemem=true | destroys a {{tt|codecvt_utf16}} facet }}
{{dsc end}}

{{member | {{small|std::codecvt_utf16::}}codecvt_utf16 |
{{dcl begin}}
{{dcl | 1=
explicit codecvt_utf16( std::size_t refs = 0 );
}}
{{dcl end}}

Constructs a new {{tt|std::codecvt_utf16}} facet, passes the initial reference counter {{tt|refs}} to the base class.

===Parameters===
{{par begin}}
{{par | refs | the number of references that link to the facet}}
{{par end}}
}}

{{member | {{small|std::codecvt_utf16::}}~codecvt_utf16 |
{{dcl begin}}
{{dcl | 1=
~codecvt_utf16();
}}
{{dcl end}}

Destroys the facet. Unlike the locale-managed facets, this facet's destructor is public.
}}

{{cpp/locale/codecvt/inherit}}
{{cpp/locale/codecvt_base/inherit}}

===Example===

{{example
 | The following example demonstrates decoding of UTF-16le file on a system with 32-bit {{c|wchar_t}}. On a system with 16-bit {{c|wchar_t}}, decoding of the third character will fail because {{c|std::codecvt_utf16&lt;char16_t&gt;}} produces UCS2, not UTF-16.
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

void prepare_file()
{
    // UTF-16le data (if host system is little-endian)
    char16_t utf16le[4] ={0x007a,          // latin small letter 'z' U+007a
                          0x6c34,          // CJK ideograph &quot;water&quot;  U+6c34
                          0xd834, 0xdd0b}; // musical sign segno U+1d10b
    // store in a file
    std::ofstream fout(&quot;text.txt&quot;);
    fout.write( reinterpret_cast&lt;char*&gt;(utf16le), sizeof utf16le);
}

int main()
{
    prepare_file();
    // open as a byte stream
    std::wifstream fin(&quot;text.txt&quot;, std::ios::binary);
    // apply facet
    fin.imbue(std::locale(fin.getloc(),
       new std::codecvt_utf16&lt;wchar_t, 0x10ffff, std::little_endian&gt;));

    for (wchar_t c; fin.get(c); )
            std::cout &lt;&lt; std::showbase &lt;&lt; std::hex &lt;&lt; c &lt;&lt; '\n';
}
 | output=
0x7a
0x6c34
0x1d10b
}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc codecvt_mode}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/codecvt utf16]]
[[es:cpp/locale/codecvt utf16]]
[[fr:cpp/locale/codecvt utf16]]
[[it:cpp/locale/codecvt utf16]]
[[ja:cpp/locale/codecvt utf16]]
[[pt:cpp/locale/codecvt utf16]]
[[ru:cpp/locale/codecvt utf16]]
[[zh:cpp/locale/codecvt utf16]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt utf8</title>
    <ns>0</ns>
    <id>2900</id>
    <revision>
      <id>64474</id>
      <parentid>58076</parentid>
      <timestamp>2013-08-18T02:46:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+ctor/dtor (LWG 2229/C++14)</comment>
      <text xml:space="preserve" bytes="3730">{{cpp/title | codecvt_utf8 }}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | codecvt }}
{{dcl | 1=
template&lt; 
    class Elem,
    unsigned long Maxcode = 0x10ffff,
    std::codecvt_mode Mode = (std::codecvt_mode)0 
&gt; class codecvt_utf8 : public std::codecvt&lt;Elem, char, std::mbstate_t&gt;;
}}
{{dcl end}}

{{lc|std::codecvt_utf8}} is a {{lc|std::codecvt}} facet which encapsulates conversion between a UTF-8 encoded byte string and UCS2 or UCS4 character string (depending on the type of {{tt|Elem}}). This codecvt facet can be used to read and write UTF-8 files, both text and binary. 

===Template Parameters===
{{par begin}}
{{par | Elem | either {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}} }}
{{par | Maxcode | the largest value of {{tt|Elem}} that this facet will read or write without error }}
{{par | Mode | a constant of type {{lc|std::codecvt_mode}} }}
{{par end}} 

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/codecvt_utf8 | inlinemem=true | constructs a new {{tt|codecvt_utf8}} facet }}
{{dsc mem dtor | cpp/locale/codecvt_utf8 | inlinemem=true | destroys a {{tt|codecvt_utf8}} facet }}
{{dsc end}}

{{member | {{small|std::codecvt_utf8::}}codecvt_utf8 |
{{dcl begin}}
{{dcl | 1=
explicit codecvt_utf8( std::size_t refs = 0 );
}}
{{dcl end}}

Constructs a new {{tt|std::codecvt_utf8}} facet, passes the initial reference counter {{tt|refs}} to the base class.

===Parameters===
{{par begin}}
{{par | refs | the number of references that link to the facet}}
{{par end}}
}}

{{member | {{small|std::codecvt_utf8::}}~codecvt_utf8 |
{{dcl begin}}
{{dcl | 1=
~codecvt_utf8();
}}
{{dcl end}}

Destroys the facet. Unlike the locale-managed facets, this facet's destructor is public.
}}

{{cpp/locale/codecvt/inherit}}
{{cpp/locale/codecvt_base/inherit}}

===Example===

{{example
 | The following example demonstrates the difference between UCS2/UTF-8 and UTF-16/UTF-8 conversions: the third character in the string is not a valid UCS2 character.
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

int main()
{
    // UTF-8 data. The character U+1d10b, musical sign segno, does not fit in UCS2
    std::string utf8 = u8&quot;z\u6c34\U0001d10b&quot;;

    // the UTF-8 / UTF-16 standard conversion facet
    std::wstring_convert&lt;std::codecvt_utf8_utf16&lt;char16_t&gt;, char16_t&gt; utf16conv;
    std::u16string utf16 = utf16conv.from_bytes(utf8);
    std::cout &lt;&lt; &quot;UTF16 conversion produced &quot; &lt;&lt; utf16.size() &lt;&lt; &quot; code points:\n&quot;;
    for (char16_t c : utf16)
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';

    // the UTF-8 / UCS2 standard conversion facet
    std::wstring_convert&lt;std::codecvt_utf8&lt;char16_t&gt;, char16_t&gt; ucs2conv;
    try {
        std::u16string ucs2 = ucs2conv.from_bytes(utf8);
    } catch(const std::range_error&amp; e) {
        std::u16string ucs2 = ucs2conv.from_bytes(utf8.substr(0, ucs2conv.converted()));
        std::cout &lt;&lt; &quot;UCS2 failed after producing &quot; &lt;&lt; std::dec &lt;&lt; ucs2.size()&lt;&lt;&quot; characters:\n&quot;;
        for (char16_t c : ucs2)
            std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
    }
}
 | output=
UTF16 conversion produced 4 code points:
0x7a
0x6c34
0xd834
0xdd0b
UCS2 failed after producing 2 characters:
0x7a
0x6c34
}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc codecvt_mode}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/codecvt utf8]]
[[es:cpp/locale/codecvt utf8]]
[[fr:cpp/locale/codecvt utf8]]
[[it:cpp/locale/codecvt utf8]]
[[ja:cpp/locale/codecvt utf8]]
[[pt:cpp/locale/codecvt utf8]]
[[ru:cpp/locale/codecvt utf8]]
[[zh:cpp/locale/codecvt utf8]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/codecvt utf8 utf16</title>
    <ns>0</ns>
    <id>2911</id>
    <revision>
      <id>64476</id>
      <parentid>62475</parentid>
      <timestamp>2013-08-18T02:49:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+ctor/dtor (LWG 2229/C++14</comment>
      <text xml:space="preserve" bytes="3551">{{cpp/title | codecvt_utf8_utf16 }}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | codecvt }}
{{dcl | 1=
template&lt; class Elem,
          unsigned long Maxcode = 0x10ffff,
          std::codecvt_mode Mode = (std::codecvt_mode)0 &gt;
class codecvt_utf8_utf16 : public std::codecvt&lt;Elem, char, std::mbstate_t&gt;;
}}
{{dcl end}}

{{lc|std::codecvt_utf8_utf16}} is a {{lc|std::codecvt}} facet which encapsulates conversion between a UTF-8 encoded byte string and UTF-16 encoded character string. If {{tt|Elem}} is a 32-bit type, one UTF-16 codepoint will be stored in each 32-bit character of the output sequence. This codecvt facet can be used to read and write UTF-8 files, both text and binary.

===Template Parameters===
{{par begin}}
{{par | Elem | either {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}} }}
{{par | Maxcode | the largest value of {{tt|Elem}} that this facet will read or write without error }}
{{par | Mode | a constant of type {{lc|std::codecvt_mode}} }}
{{par end}} 

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/codecvt_utf8_utf16 | inlinemem=true | constructs a new {{tt|codecvt_utf8_utf16}} facet }}
{{dsc mem dtor | cpp/locale/codecvt_utf8_utf16 | inlinemem=true | destroys a {{tt|codecvt_utf8_utf16}} facet }}
{{dsc end}}

{{member | {{small|std::codecvt_utf8_utf16::}}codecvt_utf8_utf16 |
{{dcl begin}}
{{dcl | 1=
explicit codecvt_utf8_utf16( std::size_t refs = 0 );
}}
{{dcl end}}

Constructs a new {{tt|std::codecvt_utf8_utf16}} facet, passes the initial reference counter {{tt|refs}} to the base class.

===Parameters===
{{par begin}}
{{par | refs | the number of references that link to the facet}}
{{par end}}
}}

{{member | {{small|std::codecvt_utf8_utf16::}}~codecvt_utf8_utf16 |
{{dcl begin}}
{{dcl | 1=
~codecvt_utf8_utf16();
}}
{{dcl end}}

Destroys the facet. Unlike the locale-managed facets, this facet's destructor is public.
}}

{{cpp/locale/codecvt/inherit}}
{{cpp/locale/codecvt_base/inherit}}

===Example===
{{example
 | The following example demonstrates reading a UTF-8 file into a UTF-16 string on a system with 32-bit {{c|wchar_t}}
 | code=
#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

int main()
{
    std::ofstream(&quot;text.txt&quot;) &lt;&lt; u8&quot;z\u6c34\U0001d10b&quot;;

    std::wifstream file1(&quot;text.txt&quot;);
    file1.imbue(std::locale(&quot;en_US.UTF8&quot;));
    std::cout &lt;&lt; &quot;Normal read from file (using default UTF-8/UTF-32 codecvt)\n&quot;;
    for (wchar_t c; file1 &gt;&gt; c; )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';

    std::wifstream file2(&quot;text.txt&quot;);
    file2.imbue(std::locale(file2.getloc(), new std::codecvt_utf8_utf16&lt;wchar_t&gt;));
    std::cout &lt;&lt; &quot;UTF-16 read from the same file (using codecvt_utf8_utf16)\n&quot;;
    for (wchar_t c; file2 &gt;&gt; c; )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
}
 | output=
Normal read from file (using default UTF-8/UTF-32 codecvt)
0x7a
0x6c34
0x1d10b
UTF-16 read from the same file (using codecvt_utf8_utf16)
0x7a
0x6c34
0xd834
0xdd0b
}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc inc | cpp/locale/dsc codecvt}}
{{dsc inc | cpp/locale/dsc codecvt_mode}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf16}}
{{dsc end}}

[[de:cpp/locale/codecvt utf8 utf16]]
[[es:cpp/locale/codecvt utf8 utf16]]
[[fr:cpp/locale/codecvt utf8 utf16]]
[[it:cpp/locale/codecvt utf8 utf16]]
[[ja:cpp/locale/codecvt utf8 utf16]]
[[pt:cpp/locale/codecvt utf8 utf16]]
[[ru:cpp/locale/codecvt utf8 utf16]]
[[zh:cpp/locale/codecvt utf8 utf16]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate</title>
    <ns>0</ns>
    <id>2976</id>
    <revision>
      <id>65764</id>
      <parentid>61772</parentid>
      <timestamp>2013-10-07T18:12:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>this wasn't as wrong as codecvt, but fix description of the required specializations for consistency</comment>
      <text xml:space="preserve" bytes="3325">{{cpp/title | collate}}
{{cpp/locale/collate/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class collate;
}}
{{dcl end}}

Class {{lc|std::collate}} encapsulates locale-specific collation (comparison) and hashing of strings. This facet is used by {{lc|std::basic_regex}} and can be applied, by means of {{c|std::locale::operator()}}, directly to all standard algorithms that expect a string comparison predicate.

{{inheritance diagram/std-collate}}

Two standalone (locale-independent) specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::collate&lt;char&gt;}}   | implements lexicographical ordering of byte strings }}
{{dsc | {{c|std::collate&lt;wchar_t&gt;}} | implements lexicographical ordering of wide strings }}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/collate/collate | constructs a new collate facet }}
{{dsc prot mem dtor | cpp/locale/collate/~collate | destructs a collate facet }}
{{dsc inc | cpp/locale/collate/dsc compare}}
{{dsc inc | cpp/locale/collate/dsc transform}}
{{dsc inc | cpp/locale/collate/dsc hash}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/collate/dsc do_compare}}
{{dsc inc | cpp/locale/collate/dsc do_transform}}
{{dsc inc | cpp/locale/collate/dsc do_hash}}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

int main()
{
    std::wcout.imbue(std::locale(&quot;&quot;));
    std::vector&lt;std::wstring&gt; v = {L&quot;ar&quot;, L&quot;zebra&quot;, L&quot;\u00f6grupp&quot;, L&quot;Zebra&quot;, L&quot;\u00e4ngel&quot;,
                                   L&quot;\u00e5r&quot;, L&quot;f\u00f6rnamn&quot;};

    std::wcout &lt;&lt; &quot;Default locale collation order: &quot;;
    std::sort(v.begin(), v.end());
    for (auto s : v) std::wcout &lt;&lt; s &lt;&lt; ' '; std::wcout &lt;&lt; '\n';

    std::wcout &lt;&lt; &quot;English locale collation order: &quot;;
    std::sort(v.begin(), v.end(), std::locale(&quot;en_US.UTF-8&quot;));
    for (auto s : v) std::wcout &lt;&lt; s &lt;&lt; ' '; std::wcout &lt;&lt; '\n';

    std::wcout &lt;&lt; &quot;Swedish locale collation order: &quot;;
    std::sort(v.begin(), v.end(), std::locale(&quot;sv_SE.UTF-8&quot;));
    for (auto s : v) std::wcout &lt;&lt; s &lt;&lt; ' '; std::wcout &lt;&lt; '\n';
}
 | output=
Default locale collation order: Zebra ar förnamn zebra ängel år ögrupp
English locale collation order: ängel ar år förnamn ögrupp zebra Zebra
Swedish locale collation order: ar förnamn zebra Zebra år ängel ögrupp
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc tclass | cpp/locale/collate_byname | creates a collate facet for the named locale }}
{{dsc end}}

[[de:cpp/locale/collate]]
[[es:cpp/locale/collate]]
[[fr:cpp/locale/collate]]
[[it:cpp/locale/collate]]
[[ja:cpp/locale/collate]]
[[pt:cpp/locale/collate]]
[[ru:cpp/locale/collate]]
[[zh:cpp/locale/collate]]</text>
      <sha1>qy30w1xovsdf4a1va1gubu0n5yoztql</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/collate</title>
    <ns>0</ns>
    <id>4391</id>
    <revision>
      <id>43704</id>
      <parentid>15744</parentid>
      <timestamp>2012-11-03T03:33:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="313">{{cpp/locale/facet/constructor|collate}}

[[de:cpp/locale/collate/collate]]
[[es:cpp/locale/collate/collate]]
[[fr:cpp/locale/collate/collate]]
[[it:cpp/locale/collate/collate]]
[[ja:cpp/locale/collate/collate]]
[[pt:cpp/locale/collate/collate]]
[[ru:cpp/locale/collate/collate]]
[[zh:cpp/locale/collate/collate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/compare</title>
    <ns>0</ns>
    <id>9255</id>
    <revision>
      <id>62391</id>
      <parentid>58083</parentid>
      <timestamp>2013-06-27T01:34:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="3102">{{cpp/locale/collate/title|compare|do_compare}}
{{cpp/locale/collate/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
int compare( const CharT* low1, const CharT* high1,
             const CharT* low2, const CharT* high2 ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual int do_compare( const CharT* low1, const CharT* high1,
                        const CharT* low2, const CharT* high2 ) const;
}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_compare}} of the most derived class.

@2@ Compares the character sequence {{tt|[low1, high1)}} to the character sequence {{tt|[low2, high2)}}, using this locale's collation rules, and returns 1 if the first string follows the second, -1 if the first string precedes the second, zero if the two strings are equivalent.

===Parameters===
{{par begin}}
{{par | low1 | pointer to the first character of the first string }}
{{par | high1 | one past the end pointer for the first string }}
{{par | low2 | pointer to the first character of the second string }}
{{par | high2 | one past the end pointer for the second string }}
{{par end}}

===Return value===
1 if the first string is greater than the second (that is, follows the second in the collation order), -1 if the first string is less than the second (precedes the second in the collation order), zero if the two strings are equivalent.

===Notes===
{{cpp/locale/collate/collation_note}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;

template&lt;typename CharT&gt;
void try_compare(const std::locale&amp; l, const CharT* p1, const CharT* p2)
{
    auto&amp; f = std::use_facet&lt;std::collate&lt;CharT&gt;&gt;(l);

    std::basic_string&lt;CharT&gt; s1(p1), s2(p2);
    if(f.compare(&amp;s1[0], &amp;s1[0] + s1.size(),
                 &amp;s2[0], &amp;s2[0] + s2.size() ) &lt; 0)
         std::wcout &lt;&lt; p1 &lt;&lt; &quot; before &quot; &lt;&lt; p2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; p2 &lt;&lt; &quot; before &quot; &lt;&lt; p1 &lt;&lt; '\n';
}

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());

    std::wcout &lt;&lt; &quot;In the American locale: &quot;;
    try_compare(std::locale(), &quot;hrnec&quot;, &quot;chrt&quot;);
    std::wcout &lt;&lt; &quot;In the Czech locale: &quot;;
    try_compare(std::locale(&quot;cs_CZ.utf8&quot;), &quot;hrnec&quot;, &quot;chrt&quot;);

    std::wcout &lt;&lt; &quot;In the American locale: &quot;;
    try_compare(std::locale(), L&quot;år&quot;, L&quot;ängel&quot;);
    std::wcout &lt;&lt; &quot;In the Swedish locale: &quot;;
    try_compare(std::locale(&quot;sv_SE.utf8&quot;), L&quot;år&quot;, L&quot;ängel&quot;);
}
 | output=
In the American locale: chrt before hrnec
In the Czech locale: hrnec before chrt
In the American locale: ängel before år
In the Swedish locale: år before ängel
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc end}}

[[de:cpp/locale/collate/compare]]
[[es:cpp/locale/collate/compare]]
[[fr:cpp/locale/collate/compare]]
[[it:cpp/locale/collate/compare]]
[[ja:cpp/locale/collate/compare]]
[[pt:cpp/locale/collate/compare]]
[[ru:cpp/locale/collate/compare]]
[[zh:cpp/locale/collate/compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/do compare</title>
    <ns>0</ns>
    <id>9454</id>
    <redirect title="cpp/locale/collate/compare" />
    <revision>
      <id>40272</id>
      <timestamp>2012-10-12T18:37:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/collate/do compare]] to [[cpp/locale/collate/compare]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/locale/collate/compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/do transform</title>
    <ns>0</ns>
    <id>9455</id>
    <redirect title="cpp/locale/collate/transform" />
    <revision>
      <id>40274</id>
      <timestamp>2012-10-12T18:37:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/collate/do transform]] to [[cpp/locale/collate/transform]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/locale/collate/transform]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/hash</title>
    <ns>0</ns>
    <id>9839</id>
    <revision>
      <id>63922</id>
      <parentid>62389</parentid>
      <timestamp>2013-08-01T15:38:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="2663">{{cpp/locale/collate/title|hash, do_hash}}
{{cpp/locale/collate/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
long hash( const CharT* beg, const CharT* end ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual long do_hash( const CharT* beg, const CharT* end ) const;
}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_hash}} of the most derived class.

@2@ Converts the character sequence {{tt|[beg, end)}} to an integer value that is equal to the hash obtained for all strings that collate equivalent in this locale ({{lc|compare()}} returns {{c|0}}). For two strings that do not collate equivalent, the probability that their hashes are equal should be very small, approaching {{c|1=1.0/std::numeric_limits&lt;unsigned long&gt;::max()}}.

===Parameters===
{{par begin}}
{{par | beg | pointer to the first character in the sequence to hash }}
{{par | end | one past the end pointer for the sequence to hash }}
{{par end}}

===Return value===
The hash value that respects collation order

===Note===
The system-supplied locales normally do not collate two strings as equivalent ({{lc|compare()}} does not return {{c|0}}) if {{l2tt|cpp/string/basic_string/operator_cmp|operator{{==}}|basic_string}} returns {{c|false}}, but a user-installed {{lc|std::collate}} facet may provide different collation rules, for example, it may treat strings as equivalent if they have the same Unicode normalized form.

===Example===
{{example
 | Demonstrates a locale-aware unordered container
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;unordered_set&gt;

struct CollateHash {
    template&lt;typename CharT&gt;
    std::size_t operator()(const std::basic_string&lt;CharT&gt;&amp; s) const
    {
        return std::use_facet&lt;std::collate&lt;CharT&gt;&gt;(std::locale()).hash(
                   &amp;s[0], &amp;s[0] + s.size()
               );
    }
};
struct CollateEq {
    template&lt;typename CharT&gt;
    bool operator()(const std::basic_string&lt;CharT&gt;&amp; s1,
                    const std::basic_string&lt;CharT&gt;&amp; s2) const
    {
        return std::use_facet&lt;std::collate&lt;CharT&gt;&gt;(std::locale()).compare(
                     &amp;s1[0], &amp;s1[0] + s1.size(),
                     &amp;s2[0], &amp;s2[0] + s2.size()
               ) == 0;
    }
};

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());

    std::unordered_set&lt;std::wstring, CollateHash, CollateEq&gt; s2 = {L&quot;Foo&quot;, L&quot;Bar&quot;};
    for(auto&amp; str: s2)
        std::wcout &lt;&lt; str &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | p=true
 | output=
Bar Foo
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc hash}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/transform</title>
    <ns>0</ns>
    <id>9250</id>
    <revision>
      <id>64300</id>
      <parentid>62390</parentid>
      <timestamp>2013-08-15T16:27:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="2914">{{cpp/locale/collate/title|transform, do_transform}}
{{cpp/locale/collate/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
string_type transform( const CharT* low, const CharT* high ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual string_type do_transform( const CharT* low, const CharT* high ) const;
}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_transform}} of the most derived class.

@2@ Converts the character sequence {{tt|[low, high)}} to a string that, compared lexicographically (e.g. with {{tt|operator&lt;}} for strings) with the result of calling {{tt|transform()}} on another string, produces the same result as calling {{lc|do_compare()}} on the same two strings.

===Parameters===
{{par begin}}
{{par | low | pointer to the first character in the sequence to transform }}
{{par | high | one past the end pointer for the sequence to transform }}
{{par end}}

===Return value===
The string transformed so that lexicographic comparison of the transformed strings may be used instead of collating of the originals. In the &quot;C&quot; locale, the returned string is the exact copy of {{tt|[low, high)}}. In other locales, the contents of the returned string are implementation-defined, and the size may be considerably longer.

===Notes===
In addition to the the use in collation, the implementation-specific format of the transformed string is known to [[cpp/regex/regex_traits/transform_primary|std::regex_traits&lt;&gt;::transform_primary]], which is able to extract the equivalence class information.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;

int main()
{
    std::locale::global(std::locale(&quot;sv_SE.utf8&quot;));
    auto&amp; f = std::use_facet&lt;std::collate&lt;wchar_t&gt;&gt;(std::locale());

    std::wstring in1 = L&quot;\u00e4ngel&quot;;
    std::wstring in2 = L&quot;\u00e5r&quot;;

    std::wstring out1 = f.transform(&amp;in1[0], &amp;in1[0] + in1.size());
    std::wstring out2 = f.transform(&amp;in2[0], &amp;in2[0] + in2.size());

    std::wcout &lt;&lt; &quot;In the Swedish locale: &quot;;
    if(out1 &lt; out2)
         std::wcout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

    std::wcout &lt;&lt; &quot;In lexicographic comparison: &quot;;
    if(in1 &lt; in2)
         std::wcout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

}
 | output=
In the Swedish locale: år before ängel
In lexicographic comparison: ängel before år
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strxfrm}}
{{dsc inc | cpp/string/wide/dsc wcsxfrm}}
{{dsc end}}

[[de:cpp/locale/collate/transform]]
[[es:cpp/locale/collate/transform]]
[[fr:cpp/locale/collate/transform]]
[[it:cpp/locale/collate/transform]]
[[ja:cpp/locale/collate/transform]]
[[pt:cpp/locale/collate/transform]]
[[ru:cpp/locale/collate/transform]]
[[zh:cpp/locale/collate/transform]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate/~collate</title>
    <ns>0</ns>
    <id>4448</id>
    <revision>
      <id>43684</id>
      <parentid>15821</parentid>
      <timestamp>2012-11-03T03:30:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="320">{{cpp/locale/facet/destructor|collate}}

[[de:cpp/locale/collate/~collate]]
[[es:cpp/locale/collate/~collate]]
[[fr:cpp/locale/collate/~collate]]
[[it:cpp/locale/collate/~collate]]
[[ja:cpp/locale/collate/~collate]]
[[pt:cpp/locale/collate/~collate]]
[[ru:cpp/locale/collate/~collate]]
[[zh:cpp/locale/collate/~collate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/collate byname</title>
    <ns>0</ns>
    <id>9313</id>
    <revision>
      <id>61618</id>
      <parentid>58088</parentid>
      <timestamp>2013-06-06T07:21:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+inline descriptions</comment>
      <text xml:space="preserve" bytes="1809">{{cpp/title|collate_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class collate_byname : public std::collate&lt;CharT&gt;;
}}
{{dcl end}}

{{lc|std::collate_byname}} is a {{lc|std::collate}} facet which encapsulates locale-specific collation (comparison) and hashing of strings. Just like {{lc|std::collate}}, it can be imbued in {{lc|std::regex}} and applied, by means of {{c|std::locale::operator()}}, directly to all standard algorithms that expect a string comparison predicate.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::collate_byname&lt;char&gt;}} | locale-specific collation of multibyte strings }}
{{dsc | {{c|std::collate_byname&lt;wchar_t&gt;}} | locale-specific collation of wide strings}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | collate_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | collate_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | collate_byname}}
{{include | cpp/locale/byname/destructor | collate_byname}}

{{cpp/locale/collate/inherit}}

===Notes===
{{cpp/locale/collate/collation_note}}

===Example===
{{example
 | &lt;!-- TODO: a useful example would probably be a regex, check on clang --&gt;
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc collate}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc end}}

[[de:cpp/locale/collate byname]]
[[es:cpp/locale/collate byname]]
[[fr:cpp/locale/collate byname]]
[[it:cpp/locale/collate byname]]
[[ja:cpp/locale/collate byname]]
[[pt:cpp/locale/collate byname]]
[[ru:cpp/locale/collate byname]]
[[zh:cpp/locale/collate byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype</title>
    <ns>0</ns>
    <id>2779</id>
    <revision>
      <id>65763</id>
      <parentid>63662</parentid>
      <timestamp>2013-10-07T18:10:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>this wasn't as wrong as codecvt, but fix description of the required specializations for consistency</comment>
      <text xml:space="preserve" bytes="4133">{{cpp/title | ctype}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class ctype;
}}
{{dcl end}}

Class ctype encapsulates character classification features. All stream input operations performed through {{c|std::basic_istream&lt;charT&gt;}} use the {{c|std::ctype&lt;charT&gt;}} of the locale imbued in the stream to identify whitespace characters for input tokenization. Stream output operations apply {{c|std::ctype&lt;charT&gt;::widen()}} to narrow-character arguments prior to output.

{{inheritance diagram/std-ctype}}

Two standalone (locale-independent) specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{ltt|cpp/locale/ctype_char|std::ctype&lt;char&gt;}} | provides narrow character equivalents of the minimal &quot;C&quot; locale classification. This specialization uses table lookup for character classification }}
{{dsc | {{c|std::ctype&lt;wchar_t&gt;}} | provides wide character classification appropriate to the native character set }}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/ctype/ctype | constructs a new ctype facet }}
{{dsc prot mem dtor | cpp/locale/ctype/~ctype | destructs a ctype facet }}
{{dsc inc | cpp/locale/ctype/dsc is}}
{{dsc inc | cpp/locale/ctype/dsc scan_is}}
{{dsc inc | cpp/locale/ctype/dsc scan_not}}
{{dsc inc | cpp/locale/ctype/dsc toupper}}
{{dsc inc | cpp/locale/ctype/dsc tolower}}
{{dsc inc | cpp/locale/ctype/dsc widen}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_is}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_is}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_not}}
{{dsc inc | cpp/locale/ctype/dsc do_toupper}}
{{dsc inc | cpp/locale/ctype/dsc do_tolower}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc inc | cpp/locale/ctype/dsc do_narrow}}
{{dsc end}}

{{cpp/locale/ctype_base/inherit}}

===Example===

{{example
 | The following example demonstrates modification of a ctype other than ctype&lt;char&gt; to tokenize a CSV file
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
 
struct csv_whitespace : std::ctype&lt;wchar_t&gt;
{
    bool do_is(mask m, char_type c) const
    {   
        if ((m &amp; space) &amp;&amp; c == L' ') {
            return false; // space will NOT be classified as whitespace
        }
        if ((m &amp; space) &amp;&amp; c == L',') {
            return true; // comma will be classified as whitespace
        }
        return ctype::do_is(m, c); // leave the rest to the parent class
    } 
};
 
int main()
{
    std::wstring in = L&quot;Column 1,Column 2,Column 3\n123,456,789&quot;;
    std::wstring token;
 
    std::wcout &lt;&lt; &quot;default locale:\n&quot;;
    std::wistringstream s1(in);
    while (s1 &gt;&gt; token) {
        std::wcout &lt;&lt; &quot;  &quot; &lt;&lt; token &lt;&lt; '\n';
    }
 
    std::wcout &lt;&lt; &quot;locale with modified ctype:\n&quot;;
    std::wistringstream s2(in);
    s2.imbue(std::locale(s2.getloc(), new csv_whitespace()));
    while (s2 &gt;&gt; token) {
        std::wcout &lt;&lt; &quot;  &quot; &lt;&lt; token&lt;&lt; '\n';
    }
}
 | output=
default locale:
  Column
  1,Column
  2,Column
  3
  123,456,789
locale with modified ctype:
  Column 1
  Column 2
  Column 3
  123
  456
  789
}}

===See also===
{{dsc begin}}
{{dsc ptclass | cpp/locale/ctype_char | title=ctype{{small|&lt;char&gt;}} | specialization of {{lc|std::ctype}} for type {{c|char}} }}
{{dsc tclass | cpp/locale/ctype_base | defines character classification categories }}
{{dsc tclass | cpp/locale/ctype_byname | creates a ctype facet for the named locale }}
{{dsc end}}

[[de:cpp/locale/ctype]]
[[es:cpp/locale/ctype]]
[[fr:cpp/locale/ctype]]
[[it:cpp/locale/ctype]]
[[ja:cpp/locale/ctype]]
[[pt:cpp/locale/ctype]]
[[ru:cpp/locale/ctype]]
[[zh:cpp/locale/ctype]]</text>
      <sha1>q3q6lebnwmktiv1mu63bi0rrpzczcm4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/ctype</title>
    <ns>0</ns>
    <id>3609</id>
    <revision>
      <id>43662</id>
      <parentid>15731</parentid>
      <timestamp>2012-11-03T03:26:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="279">{{cpp/locale/facet/constructor|ctype}}

[[de:cpp/locale/ctype/ctype]]
[[es:cpp/locale/ctype/ctype]]
[[fr:cpp/locale/ctype/ctype]]
[[it:cpp/locale/ctype/ctype]]
[[ja:cpp/locale/ctype/ctype]]
[[pt:cpp/locale/ctype/ctype]]
[[ru:cpp/locale/ctype/ctype]]
[[zh:cpp/locale/ctype/ctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/is</title>
    <ns>0</ns>
    <id>9572</id>
    <revision>
      <id>63651</id>
      <parentid>62055</parentid>
      <timestamp>2013-07-16T00:20:34Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2869">{{cpp/locale/ctype/title|is|do_is}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
bool is(mask m, CharT c) const;
}}
{{dcl | num=2 | 1=
public:
const CharT* is(const CharT* low, const CharT* high, mask* vec) const;
}}
{{dcl | num=3 | 1=
protected:
virtual bool do_is(mask m, CharT c) const;
}}
{{dcl | num=4 | 1=
protected:
virtual const CharT* do_is(const CharT* low, const CharT* high, mask* vec) const;
}}
{{dcl end}}

@1,2@ public member function, calls the protected virtual member function {{tt|do_is}} of the most derived class.
@3@ Checks if the character {{tt|c}} is classified by the mask {{tt|m}} 
@4@ For every character in the character array {{tt|[low, high)}}, identifies the complete classification mask (e.g. {{c|digit{{!}}xdigit{{!}}alnum{{!}}print{{!}}graph}} for the digit {{c|'0'}} in the default locale), and stores the masks in the corresponding elements of the array pointed to by {{tt|vec}}

===Parameters===
{{par begin}}
{{par | c | character to classify}}
{{par | m | mask to use for classifying a single character}}
{{par | low | pointer to the first character in an array of characters to classify }}
{{par | high | one past the end pointer for the array of characters to classify }}
{{par | vec | pointer to the first element of the array of masks to fill }}
{{par end}}

===Return value===
@1,3@ {{c|true}} if {{tt|c}} is classified by {{tt|m}}
@2,4@ {{tt|high}}

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;

// utility wrapper to make locale-bound facets destructible
template&lt;class Facet&gt;
struct deletable_facet : Facet
{
    template&lt;class ...Args&gt;
    deletable_facet(Args&amp;&amp; ...args) : Facet(std::forward&lt;Args&gt;(args)...) {}
    ~deletable_facet() {}
};

int main()
{
    // classify a single character using the default locale
    auto&amp; f = std::use_facet&lt;std::ctype&lt;char&gt;&gt;(std::locale());
    char c = '0';
    if (f.is(std::ctype_base::digit, c)) // or isdigit(c, locale());
    {
        std::cout &lt;&lt; &quot;'&quot; &lt;&lt; c &lt;&lt; &quot;' is a digit\n&quot;;
    }

    // classify every character in a string using a named locale
    deletable_facet&lt;std::ctype_byname&lt;wchar_t&gt;&gt; f2(&quot;en_US.utf8&quot;);
    std::wstring str = L&quot;z\u00df\u6c34\U0001d10b&quot;;
    std::vector&lt;std::ctype_base::mask&gt; vec(str.size());
    f2.is(&amp;str[0], &amp;str[0] + str.size(), &amp;vec[0]);

    for (std::size_t n = 0; n &lt; str.size(); ++n) {
       std::cout &lt;&lt; std::hex &lt;&lt; &quot;U+&quot; &lt;&lt; str[n] &lt;&lt; &quot; is: &quot;;
       if (vec[n] &amp; std::ctype_base::alnum) 
          std::cout &lt;&lt; &quot; alnum &quot;;
       if (vec[n] &amp; std::ctype_base::punct) 
          std::cout &lt;&lt; &quot; punct &quot;;
       std::cout &lt;&lt; '\n';
    }
}
 | output=
'0' is a digit
U+7a is:  alnum 
U+df is:  alnum 
U+6c34 is:  alnum 
U+1d10b is:  punct 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc iswctype}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/narrow</title>
    <ns>0</ns>
    <id>9777</id>
    <revision>
      <id>64197</id>
      <parentid>58095</parentid>
      <timestamp>2013-08-15T15:27:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="3465">{{cpp/locale/ctype/title|narrow, do_narrow}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
char narrow( CharT c, char dflt ) const;
}}
{{dcl | num=2 | 1=
public:
const CharT* narrow( const CharT* beg, const CharT* end, 
                     char dflt, char* dst ) const;
}}
{{dcl | num=3 | 1=
protected:
virtual char do_narrow( CharT c, char dflt ) const;
}}
{{dcl | num=4 | 1=
protected:
virtual const CharT* do_narrow( const CharT* beg, const CharT* end, 
                                char dflt, char* dst ) const;
}}
{{dcl end}}

@1,2@ Public member function, calls the protected virtual member function {{tt|do_narrow}} of the most derived class.

@3@ Converts the (possibly wide) character {{tt|c}} to multibyte representation if the character can be represented with a single byte (for example, ASCII characters in UTF-8 encoding are single bytes). Returns {{c|dflt}} if such conversion does not exist.

@4@ For every character in the character array {{tt|[beg, end)}}, writes narrowed characters (or {{tt|dflt}} whenever narrowing fails) to the successive locations in the character array pointed to by {{tt|dst}}.

Narrowing is always successful and is always reversible (by calling {{lc|widen()}}) for all characters from the basic source character set (latin letters, digits, and punctuations required to write a C++ program)

Narrowing, if successful, preserves all character classification categories known to {{lc|is()}}.

Narrowing of any digit character guarantees that if the result is subtracted from the character literal {{c|'0'}}, the difference equals the digit value of the original character.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par | dflt | default value to produce if the conversion fails}}
{{par | beg | pointer to the first character in an array of characters to convert }}
{{par | end | one past the end pointer for the array of characters to convert }}
{{par | dst | pointer to the first element of the array of char to fill }}
{{par end}}

===Return value===
@1,3@ narrowed character or {{tt|dflt}} if narrowing fails
@2,4@ {{tt|end}}

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

void try_narrow(const std::ctype&lt;wchar_t&gt;&amp; f, wchar_t c)
{
    char n = f.narrow(c, 0);
    if (n) {
        std::wcout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' narrowed to &quot; &lt;&lt; +(unsigned char)n &lt;&lt; '\n';
    } else {
        std::wcout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' could not be narrowed\n&quot;;
    }
}
 
int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());
    std::wcout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; &quot;In US English UTF-8 locale:\n&quot;;
    auto&amp; f = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    try_narrow(f, L'A');
    try_narrow(f, L'Ａ');
    try_narrow(f, L'ě');
 
    std::locale::global(std::locale(&quot;cs_CZ.iso88592&quot;));
    auto&amp; f2 = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    std::wcout &lt;&lt; &quot;In Czech ISO-8859-2 locale:\n&quot;;
    try_narrow(f2, L'A');
    try_narrow(f2, L'Ａ');
    try_narrow(f2, L'ě');
}
 | output=
In US English UTF-8 locale:
'A' narrowed to 0x41
'Ａ' could not be narrowed
'ě' could not be narrowed
In Czech ISO-8859-2 locale:
'A' narrowed to 0x41
'Ａ' could not be narrowed
'ě' narrowed to 0xec
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc widen}}
{{dsc inc | cpp/io/basic_ios/dsc narrow}}
{{dsc inc | cpp/string/multibyte/dsc wctob}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/scan is</title>
    <ns>0</ns>
    <id>9826</id>
    <revision>
      <id>58096</id>
      <parentid>50001</parentid>
      <timestamp>2013-06-01T06:07:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1738">{{cpp/locale/ctype/title|scan_is|do_scan_is}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
const CharT* scan_is( mask m, const CharT* beg, const CharT* end ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual const CharT* do_scan_is( mask m, const CharT* beg, const CharT* end) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_scan_is}} of the most derived class.
@2@ Locates the first character in the character array {{tt|[beg, end)}} that satisfies the classification mask {{tt|m}}, that is, the first character {{tt|c}} such that {{c|is(m, c)}} would return {{c|true}}.

===Parameters===
{{par begin}}
{{par | m | mask to search for}}
{{par | beg | pointer to the first character in an array of characters to search }}
{{par | end | one past the end pointer for the array of characters to search }}
{{par end}}

===Return value===
Pointer to the first character in {{tt|[beg, end)}} that satisfies the mask, or {{tt|end}} if no such character was found.

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    auto&amp; f = std::use_facet&lt;std::ctype&lt;char&gt;&gt;(std::locale(&quot;&quot;));

    // skip until the first letter
    char s1[] = &quot;      \t\t\n  Test&quot;;
    const char* p1 = f.scan_is(std::ctype_base::alpha, std::begin(s1), std::end(s1));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p1 &lt;&lt; &quot;'\n&quot;;

    // skip until the first letter
    char s2[] = &quot;123456789abcd&quot;;
    const char* p2 = f.scan_is(std::ctype_base::alpha, std::begin(s2), std::end(s2));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p2 &lt;&lt; &quot;'\n&quot;;
}
 | output=
'Test'
'abcd'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_not}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/scan not</title>
    <ns>0</ns>
    <id>9827</id>
    <revision>
      <id>62069</id>
      <parentid>58099</parentid>
      <timestamp>2013-06-20T20:32:37Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1746">{{cpp/locale/ctype/title|scan_not|do_scan_not}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
const CharT* scan_not( mask m, const CharT* beg, const CharT* end ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual const CharT* do_scan_not( mask m, const CharT* beg, const CharT* end) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_scan_not}} of the most derived class.
@2@ Locates the first character in the character array {{tt|[beg, end)}} that does not satisfy the classification mask {{tt|m}}, that is, the first character {{tt|c}} such that {{c|is(m, c)}} would return {{c|false}}.

===Parameters===
{{par begin}}
{{par | m | mask to search for}}
{{par | beg | pointer to the first character in an array of characters to search }}
{{par | end | one past the end pointer for the array of characters to search }}
{{par end}}

===Return value===
Pointer to the first character in {{tt|[beg, end)}} that doesn't satisfy the mask, or {{tt|end}} if no such character was found.

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    auto&amp; f = std::use_facet&lt;std::ctype&lt;char&gt;&gt;(std::locale(&quot;&quot;));

    // skip leading whitespace
    char s1[] = &quot;      \t\t\n  Test&quot;;
    const char* p1 = f.scan_not(std::ctype_base::space, std::begin(s1), std::end(s1));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p1 &lt;&lt; &quot;'\n&quot;;

    // skip leading digits
    char s2[] = &quot;123456789abcd&quot;;
    const char* p2 = f.scan_not(std::ctype_base::digit, std::begin(s2), std::end(s2));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p2 &lt;&lt; &quot;'\n&quot;;
}
 | output=
'Test'
'abcd'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_is}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/tolower</title>
    <ns>0</ns>
    <id>9823</id>
    <revision>
      <id>58100</id>
      <parentid>50003</parentid>
      <timestamp>2013-06-01T06:07:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2688">{{cpp/locale/ctype/title|tolower|do_tolower}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
CharT tolower( CharT c) const;
}}
{{dcl | num=2 | 1=
public:
const CharT* tolower( CharT* beg, const CharT* end ) const;
}}
{{dcl | num=3 | 1=
protected:
virtual CharT do_tolower( CharT c ) const;
}}
{{dcl | num=4 | 1=
protected:
virtual const CharT* do_tolower( CharT* beg, const CharT* end ) const;
}}
{{dcl end}}

@1,2@ public member function, calls the protected virtual member function {{tt|do_tolower}} of the most derived class.
@3@ Converts the character {{tt|c}} to lower case if a lower case form is defined by this locale.
@4@ For every character in the character array {{tt|[beg, end)}}, for which a lower case form exists, replaces the character with that lower case form.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par | beg | pointer to the first character in an array of characters to convert }}
{{par | end | one past the end pointer for the array of characters to convert }}
{{par end}}

===Return value===
@1,3@ lower case character or {{tt|c}} if no lower case form is listed by this locale.
@2,4@ {{tt|end}}.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the Greek uppercase letter 'Σ' has two lowercase forms, depending on the position in a word: 'σ' and 'ς'. A call to {{tt|do_tolower}} cannot be used to obtain the correct lowercase form in this case. 

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

void try_lower(const std::ctype&lt;wchar_t&gt;&amp; f, wchar_t c)
{
    wchar_t up = f.tolower(c);
    if (up != c) {
        std::wcout &lt;&lt; &quot;Lower case form of \'&quot; &lt;&lt; c &lt;&lt; &quot;' is &quot; &lt;&lt; up &lt;&lt; '\n';
    } else {
        std::wcout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' has no lower case form\n&quot;;
    }
}

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());
    std::wcout &lt;&lt; &quot;In US English UTF-8 locale:\n&quot;;
    auto&amp; f = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    try_lower(f, L'Σ');
    try_lower(f, L'Ɛ');
    try_lower(f, L'Ａ');

    std::wstring str = L&quot;HELLo, wORLD!&quot;;
    std::wcout &lt;&lt; &quot;Lowercase form of the string '&quot; &lt;&lt; str &lt;&lt; &quot;' is &quot;;
    f.tolower(&amp;str[0], &amp;str[0] + str.size());
    std::wcout &lt;&lt; &quot;'&quot; &lt;&lt; str &lt;&lt; &quot;'\n&quot;;
}
 | output=
In US English UTF-8 locale:
Lower case form of 'Σ' is σ
Lower case form of 'Ɛ' is ɛ
Lower case form of 'Ａ' is ａ
Lowercase form of the string 'HELLo, wORLD!' is 'hello, world!'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc toupper}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/toupper</title>
    <ns>0</ns>
    <id>9824</id>
    <revision>
      <id>62056</id>
      <parentid>58103</parentid>
      <timestamp>2013-06-20T03:03:53Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2609">{{cpp/locale/ctype/title|toupper|do_toupper}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
CharT toupper( CharT c ) const;
}}
{{dcl | num=2 | 1=
public:
const CharT* toupper( CharT* beg, const CharT* end ) const;
}}
{{dcl | num=3 | 1=
protected:
virtual CharT do_toupper( CharT c ) const;
}}
{{dcl | num=4 | 1=
protected:
virtual const CharT* do_toupper( CharT* beg, const CharT* end ) const;
}}
{{dcl end}}

@1,2@ public member function, calls the protected virtual member function {{tt|do_toupper}} of the most derived class.
@3@ Converts the character {{tt|c}} to upper case if an upper case form is defined by this locale.
@4@ For every character in the character array {{tt|[beg, end)}}, for which an upper case form exists, replaces the character with that upper case form.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par | beg | pointer to the first character in an array of characters to convert }}
{{par | end | one past the end pointer for the array of characters to convert }}
{{par end}}

===Return value===
@1,3@ upper case character or {{tt|c}} if no upper case form is listed by this locale.
@2,4@ {{tt|end}}.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the uppercase form of 'ß' is (with some exceptions) the two-character string &quot;SS&quot;, which cannot be obtained by {{tt|do_toupper}}.

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

void try_upper(const std::ctype&lt;wchar_t&gt;&amp; f, wchar_t c)
{
    wchar_t up = f.toupper(c);
    if (up != c) {
        std::wcout &lt;&lt; &quot;Upper case form of \'&quot; &lt;&lt; c &lt;&lt; &quot;' is &quot; &lt;&lt; up &lt;&lt; '\n';
    } else {
        std::wcout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' has no upper case form\n&quot;;
    }
}

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());
    std::wcout &lt;&lt; &quot;In US English UTF-8 locale:\n&quot;;
    auto&amp; f = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    try_upper(f, L's');
    try_upper(f, L'ſ');
    try_upper(f, L'ß');

    std::wstring str = L&quot;Hello, World!&quot;;
    std::wcout &lt;&lt; &quot;Uppercase form of the string '&quot; &lt;&lt; str &lt;&lt; &quot;' is &quot;;
    f.toupper(&amp;str[0], &amp;str[0] + str.size());
    std::wcout &lt;&lt; &quot;'&quot; &lt;&lt; str &lt;&lt; &quot;'\n&quot;;
}
 | output=
In US English UTF-8 locale:
Upper case form of 's' is S
Upper case form of 'ſ' is S
'ß' has no upper case form
Uppercase form of the string 'Hello, World!' is 'HELLO, WORLD!'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc tolower}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/widen</title>
    <ns>0</ns>
    <id>9778</id>
    <revision>
      <id>64199</id>
      <parentid>64198</parentid>
      <timestamp>2013-08-15T15:27:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="3582">{{cpp/locale/ctype/title|widen, do_widen}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
CharT widen( char c ) const;
}}
{{dcl | num=2 | 1=
public:
const char* widen( const char* beg, const char* end, CharT* dst ) const;
}}
{{dcl | num=3 | 1=
protected:
virtual CharT do_widen( char c ) const;
}}
{{dcl | num=4 | 1=
protected:
virtual const char* do_widen( const char* beg, const char* end, CharT* dst ) const;
}}
{{dcl end}}

@1,2@ public member function, calls the protected virtual member function {{tt|do_widen}} of the most derived class.
@3@ Converts the single-byte character {{tt|c}} to the corresponding wide character representation using the simplest reasonable transformation. Typically, this applies only to the characters whose multibyte encoding is a single byte (e.g. U+0000-U+007F in UTF-8).
@4@ For every character in the character array {{tt|[beg, end)}}, writes the corresponding widened character to the successive locations in the character array pointed to by {{tt|dst}}.

Widening always returns a wide character, but only the characters from the basic source character set (latin letters, digits, and punctuations required to write a C++ program) are guaranteed to have a unique, well-defined, widening transformation, which is also guaranteed to be reversible (by {{lc|narrow()}}). In practice, all characters whose multibyte representation is a single byte are usually widened to their wide character counterparts, and the rest of the possible single-byte values are usually mapped into the same placeholder value, typically {{c|CharT(-1)}}.

Widening, if successful, preserves all character classification categories known to {{lc|is()}}.

===Parameters===
{{par begin}}
{{par | c | character to convert}}
{{par | dflt | default value to produce if the conversion fails}}
{{par | beg | pointer to the first character in an array of characters to convert }}
{{par | end | one past the end pointer for the array of characters to convert }}
{{par | dst | pointer to the first element of the array of char to fill }}
{{par end}}

===Return value===
@1,3@ widened character
@2,4@ {{tt|end}}

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;

void try_widen(const std::ctype&lt;wchar_t&gt;&amp; f, char c)
{
    wchar_t w = f.widen(c);
    std::cout &lt;&lt; &quot;The single-byte character &quot; &lt;&lt; +(unsigned char)c
              &lt;&lt; &quot; widens to &quot; &lt;&lt; +w &lt;&lt; '\n';
}
 
int main()
{
    std::locale::global(std::locale(&quot;cs_CZ.iso88592&quot;));
    auto&amp; f = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; &quot;In Czech ISO-8859-2 locale:\n&quot;;
    try_widen(f, 'a');
    try_widen(f, '\xdf'); // German letter ß (U+00df) in ISO-8859-2
    try_widen(f, '\xec'); // Czech letter ě (U+011b) in ISO-8859-2
 
    std::locale::global(std::locale(&quot;cs_CZ.utf8&quot;));
    auto&amp; f2 = std::use_facet&lt;std::ctype&lt;wchar_t&gt;&gt;(std::locale());
    std::cout &lt;&lt; &quot;In Czech UTF-8 locale:\n&quot;;
    try_widen(f2, 'a');
    try_widen(f2, '\xdf'); 
    try_widen(f2, '\xec'); 
}
 | output=
In Czech ISO-8859-2 locale:
The single-byte character 0x61 widens to 0x61
The single-byte character 0xdf widens to 0xdf
The single-byte character 0xec widens to 0x11b
In Czech UTF-8 locale:
The single-byte character 0x61 widens to 0x61
The single-byte character 0xdf widens to 0xffffffff
The single-byte character 0xec widens to 0xffffffff
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc inc | cpp/io/basic_ios/dsc widen}}
{{dsc inc | cpp/string/multibyte/dsc btowc}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype/~ctype</title>
    <ns>0</ns>
    <id>3614</id>
    <revision>
      <id>43656</id>
      <parentid>15807</parentid>
      <timestamp>2012-11-03T03:24:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="286">{{cpp/locale/facet/destructor|ctype}}

[[de:cpp/locale/ctype/~ctype]]
[[es:cpp/locale/ctype/~ctype]]
[[fr:cpp/locale/ctype/~ctype]]
[[it:cpp/locale/ctype/~ctype]]
[[ja:cpp/locale/ctype/~ctype]]
[[pt:cpp/locale/ctype/~ctype]]
[[ru:cpp/locale/ctype/~ctype]]
[[zh:cpp/locale/ctype/~ctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype base</title>
    <ns>0</ns>
    <id>3097</id>
    <revision>
      <id>58107</id>
      <parentid>50006</parentid>
      <timestamp>2013-06-01T06:08:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2202">{{cpp/title | ctype_base}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class ctype_base;
}}
{{dcl end}}

The class {{lc|std::ctype_base}} lists the character classification categories which are inherited by the {{lc|std::ctype}} facets.

===Member types ===
{{dsc begin}}
{{dsc begin}}
{{dsc typedef | mask | nolink=true | unspecified {{concept|BitmaskType}} (enumeration, integer type, or bitset)}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | space | nolink=true | the value of {{tt|mask}} identifying whitespace character classification }}
{{dsc mem sconst | print | nolink=true | the value of {{tt|mask}} identifying printable character classification }}
{{dsc mem sconst | cntrl | nolink=true | the value of {{tt|mask}} identifying control character classification }}
{{dsc mem sconst | upper | nolink=true | the value of {{tt|mask}} identifying uppercase character classification }}
{{dsc mem sconst | lower | nolink=true | the value of {{tt|mask}} identifying lowercase character classification }}
{{dsc mem sconst | alpha | nolink=true | the value of {{tt|mask}} identifying alphabetic character classification }}
{{dsc mem sconst | digit | nolink=true | the value of {{tt|mask}} identifying digit character classification  }}
{{dsc mem sconst | punct | nolink=true | the value of {{tt|mask}} identifying punctuation character classification }}
{{dsc mem sconst | xdigit | nolink=true | the value of {{tt|mask}} identifying hexadecimal digit character classification }}
{{dsc mem sconst | blank | nolink=true | the value of {{tt|mask}} identifying blank character classification | notes={{mark c++11}}}}
{{dsc mem sconst | alnum | nolink=true | {{c|alpha {{!}} digit}} }}
{{dsc mem sconst | graph | nolink=true | {{c|alnum {{!}} punct}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc ctype}}
{{dsc inc | cpp/locale/dsc ctype_char}}
{{dsc inc | cpp/locale/dsc ctype_byname}}
{{dsc end}}

[[de:cpp/locale/ctype base]]
[[es:cpp/locale/ctype base]]
[[fr:cpp/locale/ctype base]]
[[it:cpp/locale/ctype base]]
[[ja:cpp/locale/ctype base]]
[[pt:cpp/locale/ctype base]]
[[ru:cpp/locale/ctype base]]
[[zh:cpp/locale/ctype base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype byname</title>
    <ns>0</ns>
    <id>9241</id>
    <revision>
      <id>65365</id>
      <parentid>61607</parentid>
      <timestamp>2013-09-10T16:44:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note about &lt;char&gt;</comment>
      <text xml:space="preserve" bytes="2506">{{cpp/title | ctype_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class ctype_byname : public std::ctype&lt;CharT&gt;;
}}
{{dcl end}}

{{lc|std::ctype_byname}} is a {{lc|std::ctype}} facet which encapsulates character classification rules of the locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{tt|std::ctype_byname&lt;char&gt;}} | provides narrow character classification. This specialization uses table lookup for character classification }}
{{dsc | {{tt|std::ctype_byname&lt;wchar_t&gt;}} | provides wide character classification }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|mask}} | {{tt|ctype&lt;CharT&gt;::mask}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | ctype_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | ctype_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | ctype_byname}}
{{include | cpp/locale/byname/destructor | ctype_byname}}

{{cpp/locale/ctype/inherit}}
{{cpp/locale/ctype_base/inherit}}

===Notes===
The explicit specialization {{tt|std::ctype_byname&lt;char&gt;}} was listed as a separate entry in the header file {{tt|&lt;locale&gt;}} until C++11. it was removed in C++11 as [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#1298 defect #1298], but it remains a required specialization, just like {{tt|std::ctype_byname&lt;wchar_t&gt;}}.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    wchar_t c = L'\u00de'; // capital letter thorn
 
    std::locale loc(&quot;C&quot;);

    std::cout &lt;&lt; &quot;isupper('Þ', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc) &lt;&lt; '\n';

    loc = std::locale(loc, new std::ctype_byname&lt;wchar_t&gt;(&quot;en_US.utf8&quot;));
 
    std::cout &lt;&lt; &quot;isupper('Þ', C locale with Unicode ctype) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc) &lt;&lt; '\n';
}
 | output=
isupper('Þ', C locale) returned false
isupper('Þ', C locale with Unicode ctype) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc ctype}}
{{dsc inc | cpp/locale/dsc ctype_char}}
{{dsc end}}

[[de:cpp/locale/ctype byname]]
[[es:cpp/locale/ctype byname]]
[[fr:cpp/locale/ctype byname]]
[[it:cpp/locale/ctype byname]]
[[ja:cpp/locale/ctype byname]]
[[pt:cpp/locale/ctype byname]]
[[ru:cpp/locale/ctype byname]]
[[zh:cpp/locale/ctype byname]]</text>
      <sha1>awwbcue87s33nqv2ilqdk99no750sjb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype byname char</title>
    <ns>0</ns>
    <id>9243</id>
    <revision>
      <id>58111</id>
      <parentid>50008</parentid>
      <timestamp>2013-06-01T06:08:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2238">{{cpp/title | ctype_byname{{dsc small|&lt;char&gt;}}}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt;&gt;
class ctype_byname : public std::ctype&lt;char&gt;;
}}
{{dcl end}}

This specialization of {{lc|std::ctype_byname}} encapsulates character classification features for type {{c|char}}. Like its base class {{tt|std::ctype&lt;char&gt;}} and unlike general-purpose {{lc|std::ctype_byname}}, table lookup is used to classify characters

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|mask}} | {{tt|ctype&lt;char&gt;::mask}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/ctype_byname_char/ctype_byname_char | constructs a new ctype_byname&lt;char&gt; facet }}
{{dsc prot mem dtor | cpp/locale/ctype_byname_char/~ctype_byname_char | destructs a ctype_byname&lt;char&gt; facet }}
{{dsc end}}

{{cpp/locale/ctype_char/inherit}}
{{cpp/locale/ctype_base/inherit}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    char c = '\xde'; // capital letter thorn
 
    std::locale loc(&quot;C&quot;);

    std::cout &lt;&lt; &quot;isupper('Þ', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc) &lt;&lt; '\n';

    loc = std::locale(loc, new std::ctype_byname&lt;char&gt;(&quot;en_US.utf8&quot;));
 
    std::cout &lt;&lt; &quot;isupper('Þ', C locale with Unicode ctype&lt;char&gt;) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc) &lt;&lt; '\n';

    loc = std::locale(loc, new std::ctype_byname&lt;char&gt;(&quot;is_IS.iso88591&quot;));
 
    std::cout &lt;&lt; &quot;isupper('Þ', C locale with Islandic ctype&lt;char&gt;) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc) &lt;&lt; '\n';
}
 | output=
isupper('Þ', C locale) returned false
isupper('Þ', C locale with Unicode ctype&lt;char&gt;) returned false
isupper('Þ', C locale with Islandic ctype&lt;char&gt;) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc ctype}}
{{dsc inc | cpp/locale/dsc ctype_char}}
{{dsc end}}

[[de:cpp/locale/ctype byname char]]
[[es:cpp/locale/ctype byname char]]
[[fr:cpp/locale/ctype byname char]]
[[it:cpp/locale/ctype byname char]]
[[ja:cpp/locale/ctype byname char]]
[[pt:cpp/locale/ctype byname char]]
[[ru:cpp/locale/ctype byname char]]
[[zh:cpp/locale/ctype byname char]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char</title>
    <ns>0</ns>
    <id>2782</id>
    <revision>
      <id>66370</id>
      <parentid>65369</parentid>
      <timestamp>2013-11-14T11:25:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>make example description a bit more precise</comment>
      <text xml:space="preserve" bytes="4126">{{cpp/title | ctype{{small|&lt;char&gt;}}}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt;&gt;
class ctype&lt;char&gt;;
}}
{{dcl end}}

This specialization of {{lc|std::ctype}} encapsulates character classification features for type {{c|char}}. Unlike general-purpose {{lc|std::ctype}}, which uses virtual functions, this specialization uses table lookup to classify characters (which is generally faster).

The base class {{c|std::ctype&lt;char&gt;}} implements character classification equivalent to the minimal &quot;C&quot; locale. The classification rules can be extended or modified if constructed with a non-default classification table argument, if constructed as {{c|std::ctype_byname&lt;char&gt;}} or as a user-defined derived facet. All {{lc|std::istream}} formatted input functions are required to use {{c|std::ctype&lt;char&gt;}} for character classing during input parsing. 

{{inheritance diagram/std-ctype_char}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|char}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype_char/dsc constructor}}
{{dsc inc | cpp/locale/ctype_char/dsc destructor}}
{{dsc inc | cpp/locale/ctype_char/dsc table}}
{{dsc inc | cpp/locale/ctype_char/dsc classic_table}}
{{dsc inc | cpp/locale/ctype_char/dsc is}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_is}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_not}}
{{dsc inc | cpp/locale/ctype/dsc toupper}}
{{dsc inc | cpp/locale/ctype/dsc tolower}}
{{dsc inc | cpp/locale/ctype/dsc widen}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_toupper}}
{{dsc inc | cpp/locale/ctype/dsc do_tolower}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc inc | cpp/locale/ctype/dsc do_narrow}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc mem sconst | nolink=true | {{dsc small|static const std::size_t }} table_size | size of the classification table, at least 256 }}
{{dsc end}}

{{cpp/locale/ctype_base/inherit}}

===Example===

{{example
 | The following example demonstrates modification of ctype&lt;char&gt; to tokenize comma-separated values &lt;!-- for a real CSV, it would have to handle quotes and escapes --&gt;
 | code=#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;

// This ctype facet classifies commas and endlines as whitespace
struct csv_whitespace : std::ctype&lt;char&gt; {
    static const mask* make_table()
    {
        // make a copy of the &quot;C&quot; locale table
        static std::vector&lt;mask&gt; v(classic_table(), classic_table() + table_size);
        v[','] {{!}}=  space;  // comma will be classified as whitespace
        v[' '] &amp;= ~space;      // space will not be classified as whitespace
        return &amp;v[0];
    }
    csv_whitespace(std::size_t refs = 0) : ctype(make_table(), false, refs) {}
};

int main()
{
    std::string in = &quot;Column 1,Column 2,Column 3\n123,456,789&quot;;
    std::string token;

    std::cout &lt;&lt; &quot;default locale:\n&quot;;
    std::istringstream s1(in);
    while(s1 &gt;&gt; token)
            std::cout &lt;&lt; &quot;  &quot; &lt;&lt; token &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;locale with modified ctype:\n&quot;;
    std::istringstream s2(in);
    s2.imbue(std::locale(s2.getloc(), new csv_whitespace));
    while(s2 &gt;&gt; token)
            std::cout &lt;&lt; &quot;  &quot; &lt;&lt; token&lt;&lt; '\n';
}
 | output=
default locale:
  Column
  1,Column
  2,Column
  3
  123,456,789
locale with modified ctype:
  Column 1
  Column 2
  Column 3
  123
  456
  789
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/locale/ctype | defines character classification tables }}
{{dsc tclass | cpp/locale/ctype_base | defines character classification categories }}
{{dsc tclass | cpp/locale/ctype_byname | creates a ctype facet for the named locale }}
{{dsc end}}

[[de:cpp/locale/ctype char]]
[[es:cpp/locale/ctype char]]
[[fr:cpp/locale/ctype char]]
[[it:cpp/locale/ctype char]]
[[ja:cpp/locale/ctype char]]
[[pt:cpp/locale/ctype char]]
[[ru:cpp/locale/ctype char]]
[[zh:cpp/locale/ctype char]]</text>
      <sha1>76zz8inmnzztgxq5d4oiqomiw27v6k6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/classic table</title>
    <ns>0</ns>
    <id>12834</id>
    <revision>
      <id>64871</id>
      <parentid>63685</parentid>
      <timestamp>2013-08-27T01:43:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="673">{{cpp/locale/ctype_char/title|classic_table}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
static const mask* classic_table();
}}
{{dcl end}}

Returns the classification table that matches the classification used by the minimal &quot;C&quot; locale.

===Parameters===
(none)

===Return value===
A pointer to the first element in the classification table (which an array of size {{tt|std::ctype&lt;char&gt;::table_size}})

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Notes===
Default-constructed {{c|std::ctype&lt;char&gt;}} facets use this table for classification.

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/ctype</title>
    <ns>0</ns>
    <id>12837</id>
    <revision>
      <id>64179</id>
      <parentid>63694</parentid>
      <timestamp>2013-08-15T15:16:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1100">{{cpp/locale/ctype_char/title | ctype}}
{{cpp/locale/ctype/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
explicit ctype( const mask* tbl = 0, bool del = false, std::size_t refs = 0);
}}
{{dcl end}}

Creates a {{c|std::ctype&lt;char&gt;}} facet and forwards the starting reference count {{tt|refs}} to the base class constructor, {{ltt|cpp/locale/locale/facet/facet|locale::facet::facet()}}.

If {{tt|tbl}} is null, {{lc|classic_table()}} is used by all classification member functions. Otherwise, {{tt|tbl}} must be a pointer to the first element of an array of masks, at least {{c|std::ctype&lt;char&gt;::table_size}} in size, and that array is used by all of this facet's classification member functions.

If {{tt|del}} is {{c|true}}, it is assumed that the array was allocated with {{c|new[]}}, and the destructor of this facet will call {{c|delete[] tbl}}

===Parameters===
{{par begin}}
{{par | tbl | classification table to use or a null pointer}}
{{par | del | indicator whether the table needs to be deleted.}}
{{par | refs | starting reference count}}
{{par end}}

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/is</title>
    <ns>0</ns>
    <id>12831</id>
    <revision>
      <id>64201</id>
      <parentid>63695</parentid>
      <timestamp>2013-08-15T15:28:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1872">{{cpp/locale/ctype_char/title|is}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
bool is(mask m, char c) const;
}}
{{dcl | num=2 | 1=
const char* is(const char* low, const char* high, mask* vec) const;
}}
{{dcl end}}

@1@ Checks if the character {{tt|c}} is classified by the mask {{tt|m}} according to the classification table returned by the member function {{lc|table()}}. Effectively calculates {{c|table()[(unsigned char)c] &amp; m}}
@2@ For every character in the character array {{tt|[low, high)}}, reads its full classification mask from the classification table returned by the member function {{lc|table()}} (that is, evaluates {{c|table()[ (unsigned char)*p]}} and stores it in the corresponding element of the array pointed to by {{tt|vec}}

If {{c|(unsigned char)c &gt;{{=}} std::ctype&lt;char&gt;::table_size}}, then an implementation-defined value is substituted instead of {{c|table()[(unsigned char)c]}}, possibly different for different values of {{c|c}}.

===Parameters===
{{par begin}}
{{par | c | character to classify}}
{{par | m | mask to use for classifying a single character}}
{{par | low | pointer to the first character in an array of characters to classify }}
{{par | high | one past the end pointer for the array of characters to classify }}
{{par | vec | pointer to the first element of the array of masks to fill }}
{{par end}}

===Return value===
@1@ {{c|true}} if {{tt|c}} is classified by {{tt|m}} in {{lc|table()}}
@2@ {{tt|high}}

===Notes===
Unlike the primary template {{c|std::ctype}}, this specialization does not perform a virtual function call when classifying characters. To customize the behavior, a derived class may provide a non-default classification table to the base class constructor.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_is}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/scan is</title>
    <ns>0</ns>
    <id>12835</id>
    <revision>
      <id>63697</id>
      <parentid>63696</parentid>
      <timestamp>2013-07-19T02:43:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2034">{{cpp/locale/ctype_char/title|scan_is}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
const char* scan_is (mask m, const char* beg, const char* end) const;
}}
{{dcl end}}

Locates the first character in the character array {{tt|[beg, end)}} that satisfies the classification mask {{tt|m}}, that is, the first character {{tt|c}} such that {{c|table()[(unsigned char) c] &amp; m}} would return {{c|true}}.

If {{c|(unsigned char)c &gt;{{=}} std::ctype&lt;char&gt;::table_size}}, then an implementation-defined value is substituted instead of {{c|table()[(unsigned char)c]}}, possibly different for different values of {{c|c}}.

===Parameters===
{{par begin}}
{{par | m | mask to search for}}
{{par | beg | pointer to the first character in an array of characters to search }}
{{par | end | one past the end pointer for the array of characters to search }}
{{par end}}

===Return value===
Pointer to the first character in {{tt|[beg, end)}} that satisfies the mask, or {{tt|end}} if no such character was found.

===Notes===
Unlike the primary template {{c|std::ctype}}, this specialization does not perform a virtual function call when classifying characters. To customize the behavior, a derived class may provide a non-default classification table to the base class constructor.

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    auto&amp; f = std::use_facet&lt;std::ctype&lt;char&gt;&gt;(std::locale(&quot;&quot;));

    // skip until the first letter
    char s1[] = &quot;      \t\t\n  Test&quot;;
    const char* p1 = f.scan_is(std::ctype_base::alpha, std::begin(s1), std::end(s1));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p1 &lt;&lt; &quot;'\n&quot;;

    // skip until the first letter
    char s2[] = &quot;123456789abcd&quot;;
    const char* p2 = f.scan_is(std::ctype_base::alpha, std::begin(s2), std::end(s2));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p2 &lt;&lt; &quot;'\n&quot;;
}
 | output=
'Test'
'abcd'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_is}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_not}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/scan not</title>
    <ns>0</ns>
    <id>12836</id>
    <revision>
      <id>63698</id>
      <parentid>63693</parentid>
      <timestamp>2013-07-19T02:44:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note on past-the-end chars</comment>
      <text xml:space="preserve" bytes="2039">{{cpp/locale/ctype_char/title|scan_is}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
const char* scan_not (mask m, const char* beg, const char* end) const;
}}
{{dcl end}}

Locates the first character in the character array {{tt|[beg, end)}} that does not satisfy the classification mask {{tt|m}}, that is, the first character {{tt|c}} such that {{c|table()[(unsigned char)c] &amp; m}} would return {{c|false}}.

If {{c|(unsigned char)c &gt;{{=}} std::ctype&lt;char&gt;::table_size}}, then an implementation-defined value is substituted instead of {{c|table()[(unsigned char)c]}}, possibly different for different values of {{c|c}}.

===Parameters===
{{par begin}}
{{par | m | mask to search for}}
{{par | beg | pointer to the first character in an array of characters to search }}
{{par | end | one past the end pointer for the array of characters to search }}
{{par end}}

===Return value===
Pointer to the first character in {{tt|[beg, end)}} that does not satisfy the mask, or {{tt|end}} if no such character was found.

===Notes===
Unlike the primary template {{c|std::ctype}}, this specialization does not perform a virtual function call when classifying characters. To customize the behavior, a derived class may provide a non-default classification table to the base class constructor.

===Example===
{{example
 |
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;

int main()
{
    auto&amp; f = std::use_facet&lt;std::ctype&lt;char&gt;&gt;(std::locale(&quot;&quot;));

    // skip leading whitespace
    char s1[] = &quot;      \t\t\n  Test&quot;;
    const char* p1 = f.scan_not(std::ctype_base::space, std::begin(s1), std::end(s1));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p1 &lt;&lt; &quot;'\n&quot;;

    // skip leading digits
    char s2[] = &quot;123456789abcd&quot;;
    const char* p2 = f.scan_not(std::ctype_base::digit, std::begin(s2), std::end(s2));
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; p2 &lt;&lt; &quot;'\n&quot;;
}
 | output=
'Test'
'abcd'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_not}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_is}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/table</title>
    <ns>0</ns>
    <id>12832</id>
    <revision>
      <id>64872</id>
      <parentid>64202</parentid>
      <timestamp>2013-08-27T01:43:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="650">{{cpp/locale/ctype_char/title|table}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
const mask* table() const;
}}
{{dcl end}}

Returns the classification table that was provided in the constructor of this instance of {{c|std::ctype&lt;char&gt;}}, or returns a copy of {{lc|classic_table()}} if none was provided.

===Parameters===
(none)

===Return value===
A pointer to the first element in the classification table (which an array of size {{tt|std::ctype&lt;char&gt;::table_size}}).

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ctype char/~ctype</title>
    <ns>0</ns>
    <id>12838</id>
    <revision>
      <id>63699</id>
      <timestamp>2013-07-19T02:47:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="828">{{cpp/locale/ctype_char/title | ~ctype}}
{{cpp/locale/ctype/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
protected: ~ctype();
}}
{{dcl end}}

Destructs a {{c|std::ctype&lt;char&gt;}} facet. This destructor is protected and virtual (due to [[cpp/locale/locale/facet|base class]] destructor being virtual). An object of type {{c|std::ctype&lt;char&gt;}}, like most facets, can only be destroyed when the last {{lc|std::locale}} object that implements this facet goes out of scope or if a user-defined class is derived from {{c|std::ctype&lt;char&gt;}} and implements a public destructor.

If, when this instance of {{c|std::ctype&lt;char&gt;}} was constructed, a custom classification table was provided and the second argument to the constructor (the boolean {{tt|del}}) was {{c|true}}, then this destructor executes {{c|delete[] table()}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/has facet</title>
    <ns>0</ns>
    <id>2834</id>
    <revision>
      <id>64830</id>
      <parentid>64829</parentid>
      <timestamp>2013-08-27T01:14:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1668">{{cpp/title | has_facet}}
{{cpp/locale/navbar}}
{{ddcl | header=locale |
template&lt; class Facet &gt;
bool has_facet( const locale&amp; loc );
}}

Checks if the locale {{tt|loc}} implements the facet {{tt|Facet}}.

===Parameters===
{{par begin}}
{{par | loc | the locale object to query }}
{{par end}}

===Return value===
Returns {{c|true}} if the facet {{tt|Facet}} was installed in the locale {{tt|loc}}, {{c|false}} otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

// minimal custom facet
struct myfacet : public std::locale::facet {
    static std::locale::id id;
};

std::locale::id myfacet::id;

int main()
{
    // loc is a &quot;C&quot; locale with myfacet added
    std::locale loc(std::locale::classic(), new myfacet);
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;Can loc classify chars? &quot;
              &lt;&lt; std::has_facet&lt;std::ctype&lt;char&gt;&gt;(loc) &lt;&lt; '\n'
              &lt;&lt; &quot;Can loc classify char32_t? &quot;
              &lt;&lt; std::has_facet&lt;std::ctype&lt;char32_t&gt;&gt;(loc) &lt;&lt; '\n'
              &lt;&lt; &quot;Does loc implement myfacet? &quot;
              &lt;&lt; std::has_facet&lt;myfacet&gt;(loc) &lt;&lt; '\n';
}
 | output=
Can loc classify chars? true
Can loc classify char32_t? false
Does loc implement myfacet? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc locale}}
{{dsc inc | cpp/locale/dsc use_facet}}
{{dsc end}}

[[de:cpp/locale/has facet]]
[[es:cpp/locale/has facet]]
[[fr:cpp/locale/has facet]]
[[it:cpp/locale/has facet]]
[[ja:cpp/locale/has facet]]
[[pt:cpp/locale/has facet]]
[[ru:cpp/locale/has facet]]
[[zh:cpp/locale/has facet]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isalnum</title>
    <ns>0</ns>
    <id>2938</id>
    <revision>
      <id>58116</id>
      <parentid>50011</parentid>
      <timestamp>2013-06-01T06:08:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1671">{{cpp/title | isalnum{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isalnum( charT ch, const locale&amp; loc );
}}

Checks if the given character classified as an alphanumeric character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as alphanumeric, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isalnum( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::alnum, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isalnum() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u2135'; // mathematical symbol aleph

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;isalnum('ℵ', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isalnum(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF-8&quot;);
    std::cout &lt;&lt; &quot;isalnum('ℵ', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isalnum(c, loc2) &lt;&lt; '\n';
}
 | output=
isalpha('ℵ​', C locale) returned false
isalpha('ℵ', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isalnum}}
{{dsc inc | cpp/string/wide/dsc iswalnum}}
{{dsc end}}

[[de:cpp/locale/isalnum]]
[[es:cpp/locale/isalnum]]
[[fr:cpp/locale/isalnum]]
[[it:cpp/locale/isalnum]]
[[ja:cpp/locale/isalnum]]
[[pt:cpp/locale/isalnum]]
[[ru:cpp/locale/isalnum]]
[[zh:cpp/locale/isalnum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isalpha</title>
    <ns>0</ns>
    <id>2812</id>
    <revision>
      <id>58119</id>
      <parentid>50012</parentid>
      <timestamp>2013-06-01T06:08:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1666">{{cpp/title | isalpha{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isalpha( charT ch, const locale&amp; loc );
}}

Checks if the given character classified as an alphabetic character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as alphabetic, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isalpha( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::alpha, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isalpha() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u042f'; // cyrillic capital letter ya

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;isalpha('Я​', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isalpha(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF8&quot;);
    std::cout &lt;&lt; &quot;isalpha('Я', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isalpha(c, loc2) &lt;&lt; '\n';
}
 | output=
isalpha('Я​', C locale) returned false
isalpha('Я', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isalpha}}
{{dsc inc | cpp/string/wide/dsc iswalpha}}
{{dsc end}}

[[de:cpp/locale/isalpha]]
[[es:cpp/locale/isalpha]]
[[fr:cpp/locale/isalpha]]
[[it:cpp/locale/isalpha]]
[[ja:cpp/locale/isalpha]]
[[pt:cpp/locale/isalpha]]
[[ru:cpp/locale/isalpha]]
[[zh:cpp/locale/isalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isblank</title>
    <ns>0</ns>
    <id>2933</id>
    <revision>
      <id>63761</id>
      <parentid>63331</parentid>
      <timestamp>2013-07-24T13:04:35Z</timestamp>
      <contributor>
        <ip>81.68.113.129</ip>
      </contributor>
      <comment>what was the template trying to catch?</comment>
      <text xml:space="preserve" bytes="1663">{{cpp/title | isblank{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale | since=c++11 |
template&lt; class charT &gt;
bool isblank( charT ch, const locale&amp; loc );
}}


Checks if the given character is classified as a blank character by the given locale's ctype facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as a blank character, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isblank( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::blank, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isblank() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

void try_with(wchar_t c, const char* loc)
{
    std::wcout &lt;&lt; &quot;isblank('&quot; &lt;&lt; c &lt;&lt; &quot;', locale(\&quot;&quot; &lt;&lt; loc &lt;&lt; &quot;\&quot;)) returned &quot; &lt;&lt; std::boolalpha
               &lt;&lt; std::isblank(c, std::locale(loc)) &lt;&lt; '\n';
}
int main()
{
    const wchar_t IDEO_SPACE = L'\u3000'; // Unicode character 'IDEOGRAPHIC SPACE'
    try_with(IDEO_SPACE, &quot;C&quot;);
    try_with(IDEO_SPACE, &quot;en_US.UTF-8&quot;);
}
 | output=
isblank(' ', locale(&quot;C&quot;)) returned false
isblank(' ', locale(&quot;en_US.UTF-8&quot;)) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isblank}}
{{dsc inc | cpp/string/wide/dsc iswblank}}
{{dsc end}}

[[de:cpp/locale/isblank]]
[[es:cpp/locale/isblank]]
[[fr:cpp/locale/isblank]]
[[it:cpp/locale/isblank]]
[[ja:cpp/locale/isblank]]
[[pt:cpp/locale/isblank]]
[[ru:cpp/locale/isblank]]
[[zh:cpp/locale/isblank]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/iscntrl</title>
    <ns>0</ns>
    <id>2808</id>
    <revision>
      <id>58121</id>
      <parentid>50014</parentid>
      <timestamp>2013-06-01T06:08:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1673">{{cpp/title | iscntrl{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool iscntrl( charT ch, const locale&amp; loc );
}}


Checks if the given character classified as a control character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as a control character, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool iscntrl( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::cntrl, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of iscntrl() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t CCH = L'\u0094'; // Destructive Backspace in Unicode

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;iscntrl(CCH, C locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::iscntrl(CCH, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF8&quot;);
    std::cout &lt;&lt; &quot;iscntrl(CCH, Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::iscntrl(CCH, loc2) &lt;&lt; '\n';
}
 | output=
iscntrl(CCH, C locale) returned false
iscntrl(CCH, Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc iscntrl}}
{{dsc inc | cpp/string/wide/dsc iswcntrl}}
{{dsc end}}

[[de:cpp/locale/iscntrl]]
[[es:cpp/locale/iscntrl]]
[[fr:cpp/locale/iscntrl]]
[[it:cpp/locale/iscntrl]]
[[ja:cpp/locale/iscntrl]]
[[pt:cpp/locale/iscntrl]]
[[ru:cpp/locale/iscntrl]]
[[zh:cpp/locale/iscntrl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isdigit</title>
    <ns>0</ns>
    <id>2927</id>
    <revision>
      <id>63904</id>
      <parentid>63903</parentid>
      <timestamp>2013-08-01T01:40:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>bool main?? anyway, let's show an example that actually makes use of the locale</comment>
      <text xml:space="preserve" bytes="2043">{{cpp/title | isdigit{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isdigit( charT ch, const locale&amp; loc );
}}

Checks if the given character is classified as a digit by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as a digit, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isdigit( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::digit, ch);
}
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;string&gt;
#include &lt;set&gt;

struct jdigit_ctype : std::ctype&lt;wchar_t&gt;
{
    std::set&lt;wchar_t&gt; jdigits{L'一',L'二',L'三',L'四',L'五',L'六',L'七',L'八',L'九',L'十'};
    bool do_is(mask m, char_type c) const {
        if ((m &amp; digit) &amp;&amp; jdigits.count(c))
            return true; // Japanese digits will be classified as digits
        return ctype::do_is(m, c); // leave the rest to the parent class
    }
};

int main()
{

    std::wstring text = L&quot;123一二三１２３&quot;;
    std::locale loc(std::locale(&quot;&quot;), new jdigit_ctype);

    std::locale::global(std::locale(&quot;&quot;));
    std::wcout.imbue(std::locale());

    for(wchar_t c : text)
        if(std::isdigit(c, loc))
            std::wcout &lt;&lt; c &lt;&lt; &quot; is a digit\n&quot;;
        else
            std::wcout &lt;&lt; c &lt;&lt; &quot; is NOT a digit\n&quot;;
}
 | output=
1 is a digit
2 is a digit
3 is a digit
一 is a digit
二 is a digit
三 is a digit
１ is NOT a digit
２ is NOT a digit
３ is NOT a digit
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isdigit}}
{{dsc inc | cpp/string/wide/dsc iswdigit}}
{{dsc end}}

[[de:cpp/locale/isdigit]]
[[es:cpp/locale/isdigit]]
[[fr:cpp/locale/isdigit]]
[[it:cpp/locale/isdigit]]
[[ja:cpp/locale/isdigit]]
[[pt:cpp/locale/isdigit]]
[[ru:cpp/locale/isdigit]]
[[zh:cpp/locale/isdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isgraph</title>
    <ns>0</ns>
    <id>2940</id>
    <revision>
      <id>58125</id>
      <parentid>50016</parentid>
      <timestamp>2013-06-01T06:08:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1684">{{cpp/title | isgraph{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isgraph( charT ch, const locale&amp; loc );
}}

Checks if the given character classified as a graphic character (i.e. printable, excluding space) by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as graphic, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isgraph( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::graph, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isgraph() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u2a0c'; // quadruple integral

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;isgraph('⨌', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isgraph(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF-8&quot;);
    std::cout &lt;&lt; &quot;isgraph('⨌', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isgraph(c, loc2) &lt;&lt; '\n';
}
 | output=
isgraph('⨌', C locale) returned false
isgraph('⨌', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isgraph}}
{{dsc inc | cpp/string/wide/dsc iswgraph}}
{{dsc end}}

[[de:cpp/locale/isgraph]]
[[es:cpp/locale/isgraph]]
[[fr:cpp/locale/isgraph]]
[[it:cpp/locale/isgraph]]
[[ja:cpp/locale/isgraph]]
[[pt:cpp/locale/isgraph]]
[[ru:cpp/locale/isgraph]]
[[zh:cpp/locale/isgraph]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/islower</title>
    <ns>0</ns>
    <id>2810</id>
    <revision>
      <id>58126</id>
      <parentid>50017</parentid>
      <timestamp>2013-06-01T06:08:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1678">{{cpp/title | islower{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool islower( charT ch, const locale&amp; loc );
}}


Checks if the given character classified as a lowercase alphabetic character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as lowercase, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool islower( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::lower, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of islower() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u03c0'; // greek small letter pi
 
    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;islower('π​', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::islower(c, loc1) &lt;&lt; '\n';
 
    std::locale loc2(&quot;en_US.UTF8&quot;);
    std::cout &lt;&lt; &quot;islower('π​', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::islower(c, loc2) &lt;&lt; '\n';
}
 | output=
islower('π​', C locale) returned false
islower('π​', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc islower}}
{{dsc inc | cpp/string/wide/dsc iswlower}}
{{dsc end}}

[[de:cpp/locale/islower]]
[[es:cpp/locale/islower]]
[[fr:cpp/locale/islower]]
[[it:cpp/locale/islower]]
[[ja:cpp/locale/islower]]
[[pt:cpp/locale/islower]]
[[ru:cpp/locale/islower]]
[[zh:cpp/locale/islower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isprint</title>
    <ns>0</ns>
    <id>2939</id>
    <revision>
      <id>58129</id>
      <parentid>50018</parentid>
      <timestamp>2013-06-01T06:08:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1668">{{cpp/title | isprint{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isprint( charT ch, const locale&amp; loc );
}}

Checks if the given character classified as a printable character (including space) by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as printable, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isprint( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::print, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isprint() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u2122'; // trademark sign

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;isprint('™', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isprint(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF-8&quot;);
    std::cout &lt;&lt; &quot;isprint('™', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isprint(c, loc2) &lt;&lt; '\n';
}
 | output=
isprint('™', C locale) returned false
isprint('™', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isprint}}
{{dsc inc | cpp/string/wide/dsc iswprint}}
{{dsc end}}

[[de:cpp/locale/isprint]]
[[es:cpp/locale/isprint]]
[[fr:cpp/locale/isprint]]
[[it:cpp/locale/isprint]]
[[ja:cpp/locale/isprint]]
[[pt:cpp/locale/isprint]]
[[ru:cpp/locale/isprint]]
[[zh:cpp/locale/isprint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/ispunct</title>
    <ns>0</ns>
    <id>2934</id>
    <revision>
      <id>58130</id>
      <parentid>50019</parentid>
      <timestamp>2013-06-01T06:08:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1665">{{cpp/title | ispunct{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool ispunct( charT ch, const locale&amp; loc );
}}

Checks if the given character is classified as an punctuation character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as punctuation, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool ispunct( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::punct, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of ispunct() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u214b'; // upside-down ampersand

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;ispunct('⅋', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::ispunct(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF-8&quot;);
    std::cout &lt;&lt; &quot;ispunct('⅋', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::ispunct(c, loc2) &lt;&lt; '\n';
}
 | output=
isalpha('⅋', C locale) returned false
isalpha('⅋', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc ispunct}}
{{dsc inc | cpp/string/wide/dsc iswpunct}}
{{dsc end}}

[[de:cpp/locale/ispunct]]
[[es:cpp/locale/ispunct]]
[[fr:cpp/locale/ispunct]]
[[it:cpp/locale/ispunct]]
[[ja:cpp/locale/ispunct]]
[[pt:cpp/locale/ispunct]]
[[ru:cpp/locale/ispunct]]
[[zh:cpp/locale/ispunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isspace</title>
    <ns>0</ns>
    <id>2774</id>
    <revision>
      <id>62463</id>
      <parentid>58133</parentid>
      <timestamp>2013-06-30T18:57:14Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1640">{{cpp/title | isspace{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isspace( charT ch, const locale&amp; loc );
}}


Checks if the given character classified as a whitespace character by the given locale's ctype facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as a whitespace character, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isspace( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::space, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isspace() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

void try_with(wchar_t c, const char* loc)
{
    std::wcout &lt;&lt; &quot;isspace('&quot; &lt;&lt; c &lt;&lt; &quot;', locale(\&quot;&quot; &lt;&lt; loc &lt;&lt; &quot;\&quot;)) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isspace(c, std::locale(loc)) &lt;&lt; '\n';
}

int main()
{
    const wchar_t EM_SPACE = L'\u2003'; // Unicode character 'EM SPACE'
    try_with(EM_SPACE, &quot;C&quot;);
    try_with(EM_SPACE, &quot;en_US.UTF8&quot;);
}
 | output=
isspace(' ', locale(&quot;C&quot;)) returned false
isspace(' ', locale(&quot;en_US.UTF8&quot;)) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isspace}}
{{dsc inc | cpp/string/wide/dsc iswspace}}
{{dsc end}}

[[de:cpp/locale/isspace]]
[[es:cpp/locale/isspace]]
[[fr:cpp/locale/isspace]]
[[it:cpp/locale/isspace]]
[[ja:cpp/locale/isspace]]
[[pt:cpp/locale/isspace]]
[[ru:cpp/locale/isspace]]
[[zh:cpp/locale/isspace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isupper</title>
    <ns>0</ns>
    <id>2809</id>
    <revision>
      <id>58134</id>
      <parentid>50021</parentid>
      <timestamp>2013-06-01T06:08:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1664">{{cpp/title | isupper{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isupper( charT ch, const locale&amp; loc );
}}


Checks if the given character classified as an uppercase alphabetic character by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as uppercase, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isupper( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::upper, ch);
}
}}

===Example===
{{example
 | Demonstrates the use of isupper() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const wchar_t c = L'\u00de'; // capital letter thorn

    std::locale loc1(&quot;C&quot;);
    std::cout &lt;&lt; &quot;isupper('Þ', C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc1) &lt;&lt; '\n';

    std::locale loc2(&quot;en_US.UTF8&quot;);
    std::cout &lt;&lt; &quot;isupper('Þ', Unicode locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; std::isupper(c, loc2) &lt;&lt; '\n';
}
 | output=
isupper('Þ', C locale) returned false
isupper('Þ', Unicode locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isupper}}
{{dsc inc | cpp/string/wide/dsc iswupper}}
{{dsc end}}

[[de:cpp/locale/isupper]]
[[es:cpp/locale/isupper]]
[[fr:cpp/locale/isupper]]
[[it:cpp/locale/isupper]]
[[ja:cpp/locale/isupper]]
[[pt:cpp/locale/isupper]]
[[ru:cpp/locale/isupper]]
[[zh:cpp/locale/isupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/isxdigit</title>
    <ns>0</ns>
    <id>2937</id>
    <revision>
      <id>58137</id>
      <parentid>50022</parentid>
      <timestamp>2013-06-01T06:08:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1102">{{cpp/title | isxdigit{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
bool isxdigit( charT ch, const locale&amp; loc );
}}

Checks if the given character is classified as a hexadecimal digit by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===

Returns {{c|true}} if the character is classified as a hexadecimal digit, {{c|false}} otherwise.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
bool isxdigit( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).is(std::ctype_base::xdigit, ch);
}
}}

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc isxdigit}}
{{dsc inc | cpp/string/wide/dsc iswxdigit}}
{{dsc end}}

[[de:cpp/locale/isxdigit]]
[[es:cpp/locale/isxdigit]]
[[fr:cpp/locale/isxdigit]]
[[it:cpp/locale/isxdigit]]
[[ja:cpp/locale/isxdigit]]
[[pt:cpp/locale/isxdigit]]
[[ru:cpp/locale/isxdigit]]
[[zh:cpp/locale/isxdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/lconv</title>
    <ns>0</ns>
    <id>5136</id>
    <revision>
      <id>58138</id>
      <parentid>50023</parentid>
      <timestamp>2013-06-01T06:08:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="6215">{{cpp/title | lconv}}
{{cpp/locale/locale/navbar}}
{{dcl begin}}
{{dcl header | clocale}}
{{dcl | 1=
struct lconv;
}}
{{dcl end}}

The class {{tt|std::lconv}} contains numeric and monetary formatting rules as defined by a C locale. Objects of this struct may be obtained with {{lc|std::localeconv}}. The members of {{tt|std::lconv}} are values of type {{c|char}} and of type {{c|char*}}. Each {{c|char*}} member except {{tt|decimal_point}} may be pointing at a null character (that is, at an empty C-string). The members of type {{c|char}} are all non-negative numbers, any of which may be {{lc|CHAR_MAX}} if the corresponding value is not available in the current C locale.

===Member objects===
====Non-monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} decimal_point | the character used as the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} thousands_sep | the character used to separate groups of digits before the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} grouping | a string whose elements indicate the sizes of digit groups}}
{{dsc end}}
====Monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_decimal_point | the character used as the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_thousands_sep | the character used to separate groups of digits before the decimal point}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} mon_grouping | a string whose elements indicate the sizes of digit groups}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} positive_sign | a string used to indicate non-negative monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} negative_sign | a string used to indicate negative monetary quantity}}
{{dsc end}}
====Local monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} currency_symbol | the symbol used for currency in the current C locale}}
{{dsc mem obj | nolink=true | {{dsc small|char}} frac_digits | the number of digits after the decimal point to display in a monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_cs_precedes | {{c|1}} if currency_symbol is placed before non-negative value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_cs_precedes | {{c|1}} if currency_symbol is placed before negative value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|positive_sign}}, and the non-negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|negative_sign}}, and the negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} p_sign_posn | indicates the position of {{tt|positive_sign}} in a non-negative monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} n_sign_posn | indicates the position of {{tt|negative_sign}} in a negative monetary value}}
{{dsc end}}
====International monetary numeric formatting parameters====
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|char*}} int_curr_symbol | the string used as international currency name in the current C locale}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_frac_digits | the number of digits after the decimal point to display in an international monetary quantity}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_cs_precedes | {{c|1}} if currency_symbol is placed before non-negative international monetary value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_cs_precedes | {{c|1}} if currency_symbol is placed before negative international monetary value, {{c|0}} if after}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|positive_sign}}, and the non-negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_sep_by_space | indicates the separation of {{tt|currency_symbol}}, {{tt|negative_sign}}, and the negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_p_sign_posn | indicates the position of {{tt|positive_sign}} in a non-negative international monetary value}}
{{dsc mem obj | nolink=true | {{dsc small|char}} int_n_sign_posn | indicates the position of {{tt|negative_sign}} in a negative international monetary value}}
{{dsc end}}


The characters of the C-strings pointed to by {{tt|grouping}} and {{tt|mon_grouping}} are interpreted according to their numeric values. When the terminating {{c|'\0'}} is encountered, the last value seen is assumed to repeat for the remainder of digits. If {{lc|CHAR_MAX}} is encountered, no further digits are grouped. the typical grouping of three digits at a time is {{c|&quot;\003&quot;}}.

The values of {{tt|p_sep_by_space}}, {{tt|n_sep_by_space}}, {{tt|int_p_sep_by_space}}, {{tt|int_n_sep_by_space}} are interpreted as follows:
{{dsc begin}}
{{dsc|0|no space separates the currency symbol and the value}}
{{dsc|1|sign sticks to the currency symbol, value is separated by a space}}
{{dsc|2|sign sticks to the value. Currency symbol is separated by a space}}
{{dsc end}}

The values of {{tt|p_sign_posn}}, {{tt|n_sign_posn}}, {{tt|int_p_sign_posn}}, {{tt|int_n_sign_posn}} are interpreted as follows:
{{dsc begin}}
{{dsc|0|parentheses around the value and the currency symbol are used to represent the sign}}
{{dsc|1|sign before the value and the currency symbol}}
{{dsc|2|sign after the value and the currency symbol}}
{{dsc|3|sign before the currency symbol}}
{{dsc|4|sign after the currency symbol}}
{{dsc end}}

===Example===
{{include| cpp/locale/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc localeconv}}
{{dsc inc | cpp/locale/dsc numpunct}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc see c | c/locale/lconv}}
{{dsc end}}

[[de:cpp/locale/lconv]]
[[es:cpp/locale/lconv]]
[[fr:cpp/locale/lconv]]
[[it:cpp/locale/lconv]]
[[ja:cpp/locale/lconv]]
[[pt:cpp/locale/lconv]]
[[ru:cpp/locale/lconv]]
[[zh:cpp/locale/lconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale</title>
    <ns>0</ns>
    <id>2786</id>
    <revision>
      <id>58141</id>
      <parentid>50024</parentid>
      <timestamp>2013-06-01T06:08:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4850">{{cpp/title | locale}}
{{cpp/locale/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class locale;
}}
{{dcl end}}

An object of class {{lc|std::locale}} is an indexed set of reference-counted pointers to facets. Each stream object of the C++ input/output library is associated with an {{lc|std::locale}} and uses its facets for parsing and formatting of all data. In addition, a locale object is associated with each basic_regex object. Locale objects can also be used as predicates that perform string collation with the standard containers and algorithms and can be accessed directly to obtain or modify the facets they hold.

Each locale constructed in a C++ program holds at least the following standard facets, but a program may define additional specializations or completely new facets and add them to any existing locale object. 

{| class=&quot;wikitable&quot; style=&quot;font-size:0.85em&quot;
! colspan=2 | Supported facets
|-
| {{c|std::collate&lt;char&gt;}}
| {{c|std::collate&lt;wchar_t&gt;}}
|-
| {{c|std::ctype&lt;char&gt;}}
| {{c|std::ctype&lt;wchar_t&gt;}}
|-
| {{c|std::codecvt&lt;char,char,mbstate_t&gt;}}&lt;br&gt;{{c|std::codecvt&lt;char16_t,char,mbstate_t&gt;}} 
| {{c|std::codecvt&lt;char32_t,char,mbstate_t&gt;}}&lt;br&gt; {{c|std::codecvt&lt;wchar_t,char,mbstate_t&gt;}}
|-
| {{c|std::moneypunct&lt;char&gt;}} &lt;br&gt;{{c|std::moneypunct&lt;char,true&gt;}}
| {{c|std::moneypunct&lt;wchar_t&gt;}}&lt;br&gt; {{c|std::moneypunct&lt;wchar_t,true&gt;}}
|-
| {{c|std::money_get&lt;char&gt;}}
| {{c|std::money_get&lt;wchar_t&gt;}}
|-
| {{c|std::money_put&lt;char&gt;}}
| {{c|std::money_put&lt;wchar_t&gt;}}
|-
| {{c|std::numpunct&lt;char&gt;}}
| {{c|std::numpunct&lt;wchar_t&gt;}}
|- 
| {{c|std::num_get&lt;char&gt;}}
| {{c|std::num_get&lt;wchar_t&gt;}}
|-
| {{c|std::num_put&lt;char&gt;}}
| {{c|std::num_put&lt;wchar_t&gt;}}
|-
| {{c|std::time_get&lt;char&gt;}}
| {{c|std::time_get&lt;wchar_t&gt;}}
|-
| {{c|std::time_put&lt;char&gt;}}
| {{c|std::time_put&lt;wchar_t&gt;}}
|-
| {{c|std::messages&lt;char&gt;}}
| {{c|std::messages&lt;wchar_t&gt;}}
|}

Locale objects are immutable: since each facet may be shared among many locale objects, altering a facet in one locale would change the behavior of unrelated locale objects.

===Member types===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc id}}
{{dsc inc | cpp/locale/locale/dsc facet}}
{{dsc typedef | nolink=true | category | {{c|int}} }}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | none | a zero value of type {{tt|category}} indicating no facet category }}
{{dsc mem sconst | nolink=true | collate | a bitmask value of type {{tt|category}} indicating the collate facet category }}
{{dsc mem sconst | nolink=true | ctype | a bitmask value of type {{tt|category}} indicating the ctype facet category }}
{{dsc mem sconst | nolink=true | monetary | a bitmask value of type {{tt|category}} indicating the monetary facet category }}
{{dsc mem sconst | nolink=true | numeric | a bitmask value of type {{tt|category}} indicating the numeric facet category }}
{{dsc mem sconst | nolink=true | time | a bitmask value of type {{tt|category}} indicating the time facet category }}
{{dsc mem sconst | nolink=true | messages | a bitmask value of type {{tt|category}} indicating the messages facet category }}
{{dsc mem sconst | nolink=true | all | {{c|collate {{!}} ctype {{!}} monetary {{!}} numeric {{!}} time {{!}} messages}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc inc | cpp/locale/locale/dsc ~locale}}
{{dsc inc | cpp/locale/locale/dsc operator{{=}} }}
{{dsc inc | cpp/locale/locale/dsc combine}}
{{dsc inc | cpp/locale/locale/dsc name}}
{{dsc inc | cpp/locale/locale/dsc operator_cmp}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc inc | cpp/locale/locale/dsc global}}
{{dsc inc | cpp/locale/locale/dsc classic}}
{{dsc end}}

===Example===
{{example
 | Demonstrates the typical prologue of a locale-sensitive program (cross-platform)
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    std::wcout &lt;&lt; &quot;User-preferred locale setting is &quot; &lt;&lt; std::locale(&quot;&quot;).name().c_str() &lt;&lt; '\n';
    // on startup, the global locale is the &quot;C&quot; locale
    std::wcout &lt;&lt; 1000.01 &lt;&lt; '\n';
    // replace the C++ global locale as well as the C locale with the user-preferred locale
    std::locale::global(std::locale(&quot;&quot;));
    // use the new global locale for future wide character output
    std::wcout.imbue(std::locale());
    // output the same number again
    std::wcout &lt;&lt; 1000.01 &lt;&lt; '\n';
}
 | output=
User-preferred locale setting is en_US.UTF8
1000.01
1,000.01
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc use_facet}}
{{dsc inc | cpp/locale/dsc has_facet}}
{{dsc inc | cpp/io/ios_base/dsc imbue}}
{{dsc inc | cpp/io/ios_base/dsc getloc}}
{{dsc end}}

[[de:cpp/locale/locale]]
[[es:cpp/locale/locale]]
[[fr:cpp/locale/locale]]
[[it:cpp/locale/locale]]
[[ja:cpp/locale/locale]]
[[pt:cpp/locale/locale]]
[[ru:cpp/locale/locale]]
[[zh:cpp/locale/locale]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/classic</title>
    <ns>0</ns>
    <id>2880</id>
    <revision>
      <id>58142</id>
      <parentid>50025</parentid>
      <timestamp>2013-06-01T06:08:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1086">{{cpp/locale/locale/title | classic}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale |
static const locale&amp; classic();
}}

Obtains a reference to the C++ locale that implements the classic &quot;C&quot; locale semantics. This locale, unlike the global locale, cannot be altered. 

===Parameters===
none

===Return value===
Returns a reference to the &quot;C&quot; locale.

===Notes===
Some of the standard-required facets, such as the UTF-8/UTF-32 conversion facet {{c|std::codecvt&lt;char32_t, char, std::mbstate_t&gt;}}, have no equivalents in the &quot;C&quot; locale, but they are nevertheless present in the locale returned by {{c|std::locale::classic()}}, as in any other locale constructed in a C++ program.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc global}}
{{dsc end}}

[[de:cpp/locale/locale/classic]]
[[es:cpp/locale/locale/classic]]
[[fr:cpp/locale/locale/classic]]
[[it:cpp/locale/locale/classic]]
[[ja:cpp/locale/locale/classic]]
[[pt:cpp/locale/locale/classic]]
[[ru:cpp/locale/locale/classic]]
[[zh:cpp/locale/locale/classic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/combine</title>
    <ns>0</ns>
    <id>2925</id>
    <revision>
      <id>58145</id>
      <parentid>50026</parentid>
      <timestamp>2013-06-01T06:08:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1237">{{cpp/locale/locale/title | combine}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale |
template&lt; class Facet &gt;
locale combine( const locale&amp; other ) const;
}}

Constructs a locale object which is a copy of {{c|*this}} except for the facet of type {{tt|Facet}}, which is copied from {{tt|other}}.

===Return value===
The new, nameless, locale.

===Exceptions===
{{lc|std::runtime_error}} if {{tt|other}} does not implement {{tt|Facet}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    const double number = 1000.25;
    std::cout &lt;&lt; &quot;\&quot;C\&quot; locale: &quot; &lt;&lt; number &lt;&lt; '\n';
    std::locale loc = std::locale().combine&lt;std::numpunct&lt;char&gt;&gt;(std::locale(&quot;en_US.UTF8&quot;));
    std::cout.imbue(loc);
    std::cout &lt;&lt; &quot;\&quot;C\&quot; locale with en_US numpunct: &quot; &lt;&lt; number &lt;&lt; '\n';
}
 | output=
&quot;C&quot; locale: 1000.25
&quot;C&quot; locale with en_US numpunct: 1,000.25
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc end}}

[[de:cpp/locale/locale/combine]]
[[es:cpp/locale/locale/combine]]
[[fr:cpp/locale/locale/combine]]
[[it:cpp/locale/locale/combine]]
[[ja:cpp/locale/locale/combine]]
[[pt:cpp/locale/locale/combine]]
[[ru:cpp/locale/locale/combine]]
[[zh:cpp/locale/locale/combine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/facet</title>
    <ns>0</ns>
    <id>2953</id>
    <revision>
      <id>58146</id>
      <parentid>50027</parentid>
      <timestamp>2013-06-01T06:08:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1523">{{cpp/locale/locale/title | facet}}
{{cpp/locale/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class locale::facet;
}}
{{dcl end}}

{{lc|std::locale::facet}} is the base class for facets. It provides a common base class so that locales could store pointers to the facets they implement in a single indexed container, and it abstracts support for facet reference counting. Whenever a facet is added to a locale, the locale increments the reference count in the facet (through an implementation-specific mechanism). Whenever a locale is destructed or modified, it decrements the reference count in each facet it no longer implements. Whenever a facet's reference count becomes zero, the locale performs {{c|delete static_cast&lt;std::locale::facet*&gt;(f)}} where {{tt|f}} is the pointer to the facet.

===Member functions===
{{dsc begin}}
{{dsc prot mem ctor | cpp/locale/locale/facet/facet | constructs a new facet with specified reference count }}
{{dsc prot mem fun | nolink=true | operator{{=}} | the copy assignment operator is deleted }}
{{dsc prot mem vdtor | nolink=true | the destructor is protected virtual}}
{{dsc end}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc id}}
{{dsc end}}

[[de:cpp/locale/locale/facet]]
[[es:cpp/locale/locale/facet]]
[[fr:cpp/locale/locale/facet]]
[[it:cpp/locale/locale/facet]]
[[ja:cpp/locale/locale/facet]]
[[pt:cpp/locale/locale/facet]]
[[ru:cpp/locale/locale/facet]]
[[zh:cpp/locale/locale/facet]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/facet/facet</title>
    <ns>0</ns>
    <id>2954</id>
    <revision>
      <id>50028</id>
      <parentid>43501</parentid>
      <timestamp>2013-06-01T03:09:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="883">{{cpp/locale/facet/title | facet}}
{{cpp/locale/locale/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
explicit facet( std::size_t refs = 0 );
}}
{{dcl | num=2 | 1=
facet(const facet&amp;) = delete;
}}
{{dcl end}}

1) creates a facet with starting reference count {{tt|refs}}. If {{tt|refs}} is non-zero, the facet will not be deleted when the last locale referencing it goes out of scope. A facet with static or dynamic storage duration should always be constructed with a non-zero {{tt|refs}}.

2) copy constructor is deleted; {{lc|std::locale::facet}} is not copyable.

[[de:cpp/locale/locale/facet/facet]]
[[es:cpp/locale/locale/facet/facet]]
[[fr:cpp/locale/locale/facet/facet]]
[[it:cpp/locale/locale/facet/facet]]
[[ja:cpp/locale/locale/facet/facet]]
[[pt:cpp/locale/locale/facet/facet]]
[[ru:cpp/locale/locale/facet/facet]]
[[zh:cpp/locale/locale/facet/facet]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/global</title>
    <ns>0</ns>
    <id>2891</id>
    <revision>
      <id>58147</id>
      <parentid>50029</parentid>
      <timestamp>2013-06-01T06:09:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1186">{{cpp/locale/locale/title | global}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale |
static locale global( const locale&amp; loc );
}}

Replaces the global C++ locale with {{tt|loc}}, which means all future calls to the {{lc|std::locale}} default constructor will now return a copy of {{tt|loc}}. If {{tt|loc}} has a name, also replaces the C locale as if by {{c|1=std::setlocale(LC_ALL, loc.name().c_str());}}. This function is the only way to modify the global C++ locale, which is otherwise equivalent to {{c|std::locale::classic()}} at program startup.

===Parameters===
{{par begin}}
{{par | loc | the new global C++ locale}}
{{par end}}

===Return value===
The previous value of the global C++ locale.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc inc | cpp/locale/locale/dsc classic}}
{{dsc inc | cpp/locale/dsc setlocale}}
{{dsc end}}

[[de:cpp/locale/locale/global]]
[[es:cpp/locale/locale/global]]
[[fr:cpp/locale/locale/global]]
[[it:cpp/locale/locale/global]]
[[ja:cpp/locale/locale/global]]
[[pt:cpp/locale/locale/global]]
[[ru:cpp/locale/locale/global]]
[[zh:cpp/locale/locale/global]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/id</title>
    <ns>0</ns>
    <id>2944</id>
    <revision>
      <id>63974</id>
      <parentid>62054</parentid>
      <timestamp>2013-08-04T07:37:22Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <text xml:space="preserve" bytes="1640">{{cpp/locale/locale/title | id}}
{{cpp/locale/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class locale::id;
}}
{{dcl end}}

The class {{lc|std::locale::id}} provides implementation-specific identification of a locale facet. Each class derived from {{lc|std::locale::facet}} must have a public static member of type {{lc|std::locale::id}} and each {{lc|std::locale}} object maintains a list of facets it implements, indexed by their {{tt|id}}s.

Facets with the same {{tt|id}} belong to the same facet category and replace each other when added to a locale object.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/locale/id/id | constructs a new id }}
{{dsc mem fun | operator{{=}} | nolink=true | copy assignment operator is deleted}}
{{dsc end}}

===Example===
{{example
 | The following example shows how to construct a minimal custom facet.
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

struct myfacet : std::locale::facet
{
    myfacet(std::size_t refs = 0) : facet(refs) {}
    static std::locale::id id;
};

std::locale::id myfacet::id;

int main()
{
    std::locale myloc(std::locale(), new myfacet);
    std::cout &lt;&lt; &quot;has_facet&lt;myfacet&gt;(myloc) returns &quot; &lt;&lt; std::boolalpha
              &lt;&lt; std::has_facet&lt;myfacet&gt;(myloc) &lt;&lt; '\n';
}
 | output=
has_facet&lt;myfacet&gt;(myloc) returns true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc facet}}
{{dsc end}}

[[de:cpp/locale/locale/id]]
[[es:cpp/locale/locale/id]]
[[fr:cpp/locale/locale/id]]
[[it:cpp/locale/locale/id]]
[[ja:cpp/locale/locale/id]]
[[pt:cpp/locale/locale/id]]
[[ru:cpp/locale/locale/id]]
[[zh:cpp/locale/locale/id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/id/id</title>
    <ns>0</ns>
    <id>2945</id>
    <revision>
      <id>50031</id>
      <parentid>43481</parentid>
      <timestamp>2013-06-01T03:09:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1065">{{cpp/locale/id/title | id}}
{{cpp/locale/locale/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
id();
}}
{{dcl | num=2 | 1=
id(const id&amp;) = delete;
}}
{{dcl end}}

1) default constructor: creates an object of type {{lc|std::locale::id}} with implementation-specific content.

2) copy constructor is deleted; {{lc|std::locale::id}} is not copyable.

===Notes===
Because locales and facets must be available for the IO stream objects with static storage duration, such as {{lc|std::cout}}, typical implementations let implicit default constructor zero-initialize the contents of {{lc|std::locale::id}} during static initialization (before constructors run for static objects), and when a facet is added to any locale for the first time, the locale completes initialization of the facet's {{tt|id}}.

[[de:cpp/locale/locale/id/id]]
[[es:cpp/locale/locale/id/id]]
[[fr:cpp/locale/locale/id/id]]
[[it:cpp/locale/locale/id/id]]
[[ja:cpp/locale/locale/id/id]]
[[pt:cpp/locale/locale/id/id]]
[[ru:cpp/locale/locale/id/id]]
[[zh:cpp/locale/locale/id/id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/locale</title>
    <ns>0</ns>
    <id>2943</id>
    <revision>
      <id>64819</id>
      <parentid>63715</parentid>
      <timestamp>2013-08-27T01:13:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, fix noexcept</comment>
      <text xml:space="preserve" bytes="4355">{{cpp/locale/locale/title | locale}}
{{cpp/locale/locale/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
locale();
}}
{{dcl | num=2 | 1=
locale( const locale&amp; other );
}}
{{dcl | num=3 | 1=
explicit locale( const char* std_name );
}}
{{dcl | num=4 | 1=
explicit locale( const std::string&amp; std_name );
}}
{{dcl | num=5 | 1=
locale( const locale&amp; other, const char* std_name, category cat );
}}
{{dcl | num=6 | 1=
locale( const locale&amp; other, const std::string&amp; std_name, category cat );
}}
{{dcl | num=7 | 1=
template&lt; class Facet &gt;
locale( const locale&amp; other, Facet* f );
}}
{{dcl | num=8 | 1=
locale( const locale&amp; other, const locale&amp; one, category cat );
}}
{{dcl end}}

Contstructs a new locale object.

@1@ Default constructor. Constructs a copy of the global C++ locale, which is the locale most recently used as the argument to {{c|std::locale::global}} or a copy of {{c|std::locale::classic}} if no call to {{c|std::locale::global}} has been made.

@2@ Copy constructor. Constructs a copy of {{tt|other}}.

@3-4@ Constructs a copy of the system locale with specified {{tt|std_name}} (such as &quot;C&quot;, or &quot;POSIX&quot;, or &quot;en_US.UTF-8&quot;, or &quot;English_US.1251&quot;), if such locale is supported by the operating system. The locale constructed in this manner has a name.

@5-6@ Constructs a copy of {{tt|other}} except for all the facets identified by the {{tt|cat}} argument, which are copied from the system locale identified by its {{tt|std_name}}. The locale constructed in this manner has the same name as {{tt|other}}.

@7@ Constructs a copy of {{tt|other}} except for the facet of type {{tt|Facet}} (typically deduced from the type of the argument) which is installed from the argument {{tt|facet}}. If {{tt|facet}} is {{lc|NULL}}, the constructed locale is a full copy of {{tt|other}}. The locale constructed in this manner has no name.

@8@ Constructs a copy of {{tt|other}} except for all the facets identified by the {{tt|cat}} argument, which are copied from {{tt|one}}. If both {{tt|other}} and {{tt|one}} have names, then the resulting locale also has a name.

===Parameters===
{{par begin}}
{{par | other | another locale to copy}}
{{par | std_name | name of the system locale to use}}
{{par | f | pointer to a facet to merge with {{tt|other}} }}
{{par | cat | the locale category used to identify the facets to merge with {{tt|other}} }}
{{par | one | another locale to take facets from}}
{{par end}}

===Exceptions===
@1-2@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

@3@ {{lc|std::runtime_error}} if the operating system has no locale named {{tt|std_name}} or if {{tt|std_name}} is {{lc|NULL}}.

@4@ {{lc|std::runtime_error}} if the operating system has no locale named {{tt|std_name}}.

@5@ {{lc|std::runtime_error}} if the operating system has no locale named {{tt|std_name}} or if {{tt|std_name}} is {{lc|NULL}}.

@6@ {{lc|std::runtime_error}} if the operating system has no locale named {{tt|std_name}}.

@7-8@ (none)

===Notes===
Overload 7 is typically called with its second argument, {{tt|f}}, obtained directly from a new-expression: the locale is responsible for calling the matching {{tt|delete}} from its own destructor.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

int main()
{
    std::locale l1;  // l1 is a copy of the classic &quot;C&quot; locale
    std::locale l2(&quot;en_US.UTF-8&quot;); // l2 is a unicode locale
    std::locale l3(l1, l2, std::locale::ctype); // l3 is &quot;C&quot; except for ctype, which is unicode
    std::locale l4(l1, new std::codecvt_utf8&lt;wchar_t&gt;); // l4 is &quot;C&quot; except for codecvt
    std::cout &lt;&lt; &quot;Locale names:\nl1: &quot; &lt;&lt; l1.name() &lt;&lt; &quot;\nl2: &quot; &lt;&lt; l2.name()
               &lt;&lt; &quot;\nl3: &quot; &lt;&lt; l3.name() &lt;&lt; &quot;\nl4: &quot; &lt;&lt; l4.name() &lt;&lt; '\n';
}
 | output=
Locale names:
l1: C
l2: en_US.UTF-8
l3: LC_CTYPE=en_US.UTF-8;LC_NUMERIC=C;LC_TIME=C;LC_COLLATE=C;LC_MONETARY=C;LC_MESSAGES=C;LC_PAPER=C;LC_NAME=C;LC_ADDRESS=C;LC_TELEPHONE=C;LC_MEASUREMENT=C;LC_IDENTIFICATION=C
l4: *
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc ~locale}}
{{dsc end}}

[[de:cpp/locale/locale/locale]]
[[es:cpp/locale/locale/locale]]
[[fr:cpp/locale/locale/locale]]
[[it:cpp/locale/locale/locale]]
[[ja:cpp/locale/locale/locale]]
[[pt:cpp/locale/locale/locale]]
[[ru:cpp/locale/locale/locale]]
[[zh:cpp/locale/locale/locale]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/name</title>
    <ns>0</ns>
    <id>2909</id>
    <revision>
      <id>58154</id>
      <parentid>50033</parentid>
      <timestamp>2013-06-01T06:09:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1227">{{cpp/locale/locale/title | name}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale |
std::string name() const;
}}

Returns the name of the locale, which is the name by which it is known to the operating system, such as &quot;POSIX&quot; or &quot;en_US.UTF8&quot; or &quot;English_United States.1252&quot;. If the locale is not a copy of a system-supplied locale, the string &quot;*&quot; is returned.

===Return value===
The name of the locale or &quot;*&quot; if unnamed.

===Example===
{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::locale loc(std::locale(), new std::ctype&lt;char&gt;);
    std::cout &lt;&lt; &quot;The default locale is &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n'
              &lt;&lt; &quot;The user's locale is &quot; &lt;&lt; std::locale(&quot;&quot;).name() &lt;&lt; '\n'
              &lt;&lt; &quot;A nameless locale is &quot; &lt;&lt; loc.name() &lt;&lt; '\n';
}
 | output=
The default locale is C
The user's locale is en_US.UTF8
A nameless locale is *
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc end}}

[[de:cpp/locale/locale/name]]
[[es:cpp/locale/locale/name]]
[[fr:cpp/locale/locale/name]]
[[it:cpp/locale/locale/name]]
[[ja:cpp/locale/locale/name]]
[[pt:cpp/locale/locale/name]]
[[ru:cpp/locale/locale/name]]
[[zh:cpp/locale/locale/name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/operator()</title>
    <ns>0</ns>
    <id>2892</id>
    <revision>
      <id>58155</id>
      <parentid>50034</parentid>
      <timestamp>2013-06-01T06:09:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2187">{{cpp/locale/locale/title | operator()}}
{{cpp/locale/locale/navbar}}
{{ddcl |
template&lt; class CharT, class Traits, class Alloc &gt;
bool operator()( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; s1,
                 const basic_string&lt;CharT,Traits,Alloc&gt;&amp; s2) const;
}}

Compares two string arguments {{tt|s1}} and {{tt|s2}} according to the lexicographic comparison rules defined by this locale's {{c|std::collate&lt;charT&gt;}} facet. This operator allows any locale object that has a collate facet to be used as a binary predicate in the standard algorithms (such as {{lc|std::sort}}) and ordered containers (such as {{lc|std::set}})

===Parameters===
{{par begin}}
{{par | s1 | the first string to compare}}
{{par | s2 | the second string to compare}}
{{par end}}

===Return value===
{{c|true}} if {{tt|s1}} is lexicographically less than {{tt|s2}}, {{c|false}} otherwise.

===Possible implementation===

{{eq fun
 | 1=
template&lt;class CharT, class Traits, class Alloc &gt;
bool operator()(const std::basic_string&lt;CharT,Traits,Alloc&gt;&amp; s1,
                const std::basic_string&lt;CharT,Traits,Alloc&gt;&amp; s2) const;
{
    return std::use_facet&lt;std::collate&lt;CharT&gt;&gt;(*this).compare(
                                         s1.data(), s1.data() + s1.size(),
                                         s2.data(), s2.data() + s2.size()   ) &lt; 0;
}
}}

===Example===
{{example
 | A vector of strings can be sorted according to a non-default locale by using the locale object as comparator:
 | code=
#include &lt;locale&gt;
#include &lt;algorithm&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;cassert&gt;

int main()
{
    std::vector&lt;std::wstring&gt; v = {L&quot;жил&quot;, L&quot;был&quot;, L&quot;кот&quot;};
    std::sort(v.begin(), v.end(), std::locale(&quot;ru_RU.UTF8&quot;));
    assert(v[0] == L&quot;был&quot;);
    assert(v[1] == L&quot;жил&quot;);
    assert(v[2] == L&quot;кот&quot;);
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc collate}}
{{dsc end}}

[[de:cpp/locale/locale/operator()]]
[[es:cpp/locale/locale/operator()]]
[[fr:cpp/locale/locale/operator()]]
[[it:cpp/locale/locale/operator()]]
[[ja:cpp/locale/locale/operator()]]
[[pt:cpp/locale/locale/operator()]]
[[ru:cpp/locale/locale/operator()]]
[[zh:cpp/locale/locale/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/operator=</title>
    <ns>0</ns>
    <id>2941</id>
    <revision>
      <id>64828</id>
      <parentid>58156</parentid>
      <timestamp>2013-08-27T01:14:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1053">{{cpp/locale/locale/title | operator{{=}}}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale | 1=
const locale&amp; operator=( const locale&amp; other );
}}

Creates a copy of {{tt|other}}, replacing the contents of {{c|*this}}. The reference counts of all facets held by {{tt|other}} are incremented. The reference counts of all facets previously held by {{c|*this}} are decremented, and those facets whose reference count becomes zero are deleted.

===Return value===
Returns {{c|*this}}, which is now a copy of {{tt|other}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc end}}

[[de:cpp/locale/locale/operator=]]
[[es:cpp/locale/locale/operator=]]
[[fr:cpp/locale/locale/operator=]]
[[it:cpp/locale/locale/operator=]]
[[ja:cpp/locale/locale/operator=]]
[[pt:cpp/locale/locale/operator=]]
[[ru:cpp/locale/locale/operator=]]
[[zh:cpp/locale/locale/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/operator cmp</title>
    <ns>0</ns>
    <id>2894</id>
    <revision>
      <id>58159</id>
      <parentid>50036</parentid>
      <timestamp>2013-06-01T06:09:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1249">{{cpp/locale/locale/title | 1=operator==, operator!= }}
{{cpp/locale/locale/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
bool operator==( const locale&amp; other ) const;
}}
{{dcl | num=2 | 1=
bool operator!=( const locale&amp; other ) const;
}}
{{dcl end}}

Tests two locales for equality. Named locales are considered equal if their names are equal. Unnamed locales are considered equal if they are copies of each other. 

===Parameters===
{{par begin}}
{{par | other | a {{lc|std::locale}} object to compare}}
{{par end}}

===Return value===
1) {{c|true}} if {{tt|other}} is a copy of {{c|*this}} or has an identical name, {{c|false}} otherwise.

2) {{c|false}} if {{tt|other}} is a copy of {{c|*this}} or has an identical name, {{c|true}} otherwise.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc inc | cpp/locale/locale/dsc name}}
{{dsc end}}

[[de:cpp/locale/locale/operator cmp]]
[[es:cpp/locale/locale/operator cmp]]
[[fr:cpp/locale/locale/operator cmp]]
[[it:cpp/locale/locale/operator cmp]]
[[ja:cpp/locale/locale/operator cmp]]
[[pt:cpp/locale/locale/operator cmp]]
[[ru:cpp/locale/locale/operator cmp]]
[[zh:cpp/locale/locale/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/operator eq</title>
    <ns>0</ns>
    <id>4248</id>
    <redirect title="cpp/locale/locale/operator cmp" />
    <revision>
      <id>15382</id>
      <timestamp>2011-12-08T17:18:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/locale/operator eq]] to [[cpp/locale/locale/operator cmp]]: eq-&gt;cmp</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/locale/locale/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/locale/~locale</title>
    <ns>0</ns>
    <id>2942</id>
    <revision>
      <id>58160</id>
      <parentid>50037</parentid>
      <timestamp>2013-06-01T06:09:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="718">{{cpp/locale/locale/title | ~locale}}
{{cpp/locale/locale/navbar}}

{{ddcl | header=locale | 1=
~locale();
}}

Non-virtual destructor which decrements reference counts of all facets held by {{tt|*this}}. Those facets whose reference count becomes zero are deleted.

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/locale/dsc locale}}
{{dsc end}}

[[de:cpp/locale/locale/~locale]]
[[es:cpp/locale/locale/~locale]]
[[fr:cpp/locale/locale/~locale]]
[[it:cpp/locale/locale/~locale]]
[[ja:cpp/locale/locale/~locale]]
[[pt:cpp/locale/locale/~locale]]
[[ru:cpp/locale/locale/~locale]]
[[zh:cpp/locale/locale/~locale]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/localeconv</title>
    <ns>0</ns>
    <id>5135</id>
    <revision>
      <id>58163</id>
      <parentid>50038</parentid>
      <timestamp>2013-06-01T06:09:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/title|localeconv}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header|clocale}}
{{dcl |
std::lconv* localeconv();
}}
{{dcl end}}

The {{tt|localeconv}} function obtains a pointer to a static object of type {{lc|std::lconv}}, which represents numeric and monetary formatting rules of the current C locale.

===Parameters===
(none)

===Return value===
Pointer to the current {{lc|std::lconv}} object. 

===Notes===
Modifying the object references through the returned pointer is undefined behavior.

{{tt|std::localeconv}} modifies a static object, calling it from different threads without synchronization is undefined behavior.

===Example===
{{include| cpp/locale/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc setlocale}}
{{dsc inc | cpp/locale/dsc lconv}}
{{dsc see c | c/locale/localeconv}}
{{dsc end}}

[[de:cpp/locale/localeconv]]
[[es:cpp/locale/localeconv]]
[[fr:cpp/locale/localeconv]]
[[it:cpp/locale/localeconv]]
[[ja:cpp/locale/localeconv]]
[[pt:cpp/locale/localeconv]]
[[ru:cpp/locale/localeconv]]
[[zh:cpp/locale/localeconv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages</title>
    <ns>0</ns>
    <id>2977</id>
    <revision>
      <id>65766</id>
      <parentid>65765</parentid>
      <timestamp>2013-10-07T18:13:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>~</comment>
      <text xml:space="preserve" bytes="2427">{{cpp/title | messages}}
{{cpp/locale/messages/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class messages;
}}
{{dcl end}}

Class template {{lc|std::messages}} is a standard locale facet that encapsulates retrieval of strings from message catalogs, such as the ones provided by GNU [http://www.gnu.org/s/gettext/ gettext] or by POSIX [http://pubs.opengroup.org/onlinepubs/9699919799/functions/catgets.html catgets].

The source of the messages is implementation-defined.

{{inheritance diagram/std-messages}}

Two standalone (locale-independent) specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::messages&lt;char&gt;}} | accesses narrow string message catalog }}
{{dsc | {{c|std::messages&lt;wchar_t&gt;}} | accesses wide string message catalog }}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/messages/messages | constructs a new messages facet }}
{{dsc prot mem dtor | cpp/locale/messages/~messages | destructs a messages facet }}
{{dsc inc | cpp/locale/messages/dsc open}}
{{dsc inc | cpp/locale/messages/dsc get}}
{{dsc inc | cpp/locale/messages/dsc close}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/messages/dsc do_open}}
{{dsc inc | cpp/locale/messages/dsc do_get}}
{{dsc inc | cpp/locale/messages/dsc do_close}}
{{dsc end}}

{{ inherited | {{small|std::}}messages_base |
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|catalog}} | int }}
{{dsc end}}
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/locale/messages_base | defines messages catalog type }}
{{dsc tclass | cpp/locale/messages_byname | creates a messages facet for the named locale }}
{{dsc end}}

[[de:cpp/locale/messages]]
[[es:cpp/locale/messages]]
[[fr:cpp/locale/messages]]
[[it:cpp/locale/messages]]
[[ja:cpp/locale/messages]]
[[pt:cpp/locale/messages]]
[[ru:cpp/locale/messages]]
[[zh:cpp/locale/messages]]</text>
      <sha1>8mpxcfb331a3grqv4p33enx9s267pii</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages/close</title>
    <ns>0</ns>
    <id>9864</id>
    <revision>
      <id>63921</id>
      <parentid>63812</parentid>
      <timestamp>2013-08-01T15:38:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="1126">{{cpp/locale/messages/title|close|do_close}}
{{cpp/locale/messages/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
void close( catalog c ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual void do_close( catalog c ) const;
}}
{{dcl end}}

1) public member function, calls the protected virtual member function {{tt|do_close}} of the most derived class.

2) Releases the implementation-defined resources associated with an open catalog that is designated by the value {{tt|c}} of type {{tt|catalog}} (inherited from {{lc|std::messages_base}}), which was obtained from {{lc|open()}}.

===Parameters===
{{par begin}}
{{par | c | a valid open catalog identifier, on which {{tt|close()}} has not yet been called}}
{{par end}}

===Return value===
(none)

===Notes===
On POSIX systems, this function call usually translates to a call to {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/functions/catclose.html catclose()]}}. In GNU libstdc++, which is implemented in terms of GNU {{tt|gettext()}}, it does nothing. 

===Example===
{{cpp/locale/messages/example}}

===See also===
{{dsc begin}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages/get</title>
    <ns>0</ns>
    <id>9865</id>
    <revision>
      <id>64200</id>
      <parentid>63920</parentid>
      <timestamp>2013-08-15T15:27:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1757">{{cpp/locale/messages/title|get, do_get}}
{{cpp/locale/messages/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
string_type get( catalog cat, int set, int msgid, const string_type&amp; dfault ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual string_type do_get( catalog cat, int set, int msgid, const string_type&amp; dfault ) const;
}}
{{dcl end}}

1) Public member function, calls the protected virtual member function {{tt|do_get}} of the most derived class.

2) Obtains a message from the open message catalog {{tt|cat}} using the values {{tt|set}}, {{tt|msgid}} and {{tt|dfault}} in implementation-defined manner. If the expected message is not found in the catalog, returns a copy of {{tt|dfault}}.

===Parameters===
{{par begin}}
{{par | cat | identifier of message catalog obtained from {{lc|open()}} and not yet passed to {{lc|close()}} }}
{{par | set | implementation-defined argument, message set in POSIX}}
{{par | msgid | implementation-defined argument, message id in POSIX}}
{{par | dfault | the string to look up in the catalog (if the catalog uses string look-up) and also the string to return in case of a failure}}
{{par end}}

===Return value===
The message from the catalog or a copy of {{tt|dfault}} if none was found.

===Notes===
On POSIX systems, this function call usually translates to a call to {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/functions/catgets.html catgets()]}}, and the parameters {{tt|set}}, {{tt|msgid}}, and {{tt|dfault}} are passed to {{tt|catgets()}} as-is. In GNU libstdc++, this function ignores {{tt|set}} and {{tt|msgid}} and simply calls GNU {{tt|gettext(dfault)}} in the required locale.

===Example===
{{cpp/locale/messages/example}}

===See also===
{{dsc begin}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages/messages</title>
    <ns>0</ns>
    <id>4396</id>
    <revision>
      <id>43401</id>
      <parentid>15750</parentid>
      <timestamp>2012-11-03T02:38:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="330">{{cpp/locale/facet/constructor|messages}}

[[de:cpp/locale/messages/messages]]
[[es:cpp/locale/messages/messages]]
[[fr:cpp/locale/messages/messages]]
[[it:cpp/locale/messages/messages]]
[[ja:cpp/locale/messages/messages]]
[[pt:cpp/locale/messages/messages]]
[[ru:cpp/locale/messages/messages]]
[[zh:cpp/locale/messages/messages]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages/open</title>
    <ns>0</ns>
    <id>9856</id>
    <revision>
      <id>63919</id>
      <parentid>60950</parentid>
      <timestamp>2013-08-01T15:38:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="1921">{{cpp/locale/messages/title|open|do_open}}
{{cpp/locale/messages/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
catalog open( const std::basic_string&lt;char&gt;&amp; name, const std::locale&amp; loc ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual catalog do_open( const std::basic_string&lt;char&gt;&amp; name, const std::locale&amp; loc ) const;
}}
{{dcl end}}

1) Public member function, calls the protected virtual member function {{tt|do_open}} of the most derived class.

2) Obtains a value of type {{tt|catalog}} (inherited from {{lc|std::messages_base}}), which can be passed to {{lc|get()}} to retrieve messages from the message catalog named by {{tt|name}}. This value is usable until passed to {{lc|close()}}.

===Parameters===
{{par begin}}
{{par | name | name of the message catalog to open}}
{{par | loc | a locale object that provides additional facets that may be required to read messages from the catalog, such as {{lc|std::codecvt}} to perform wide/multibyte conversions }}
{{par end}}

===Return value===
The non-negative value of type {{tt|catalog}} that can be used with {{lc|get()}} and {{lc|close()}}. Returns a negative value if the catalog could not be opened.

===Notes===
On POSIX systems, this function call usually translates to a call to {{tt|[http://pubs.opengroup.org/onlinepubs/9699919799/functions/catopen.html catopen()]}}. In GNU libstdc++, it calls {{tt|[http://gcc.gnu.org/onlinedocs/libstdc++/manual/facets.html textdomain]}}. 

The actual catalog location is implementation-defined: for the catalog {{c|&quot;sed&quot;}} (message catalogs installed with the Unix utility {{tt|'sed'}}) in German locale, for example, the file opened by this function call may be {{tt|/usr/lib/nls/msg/de_DE/sed.cat}}, {{tt|/usr/lib/locale/de_DE/LC_MESSAGES/sed.cat}}, or {{tt|/usr/share/locale/de/LC_MESSAGES/sed.mo}}.

===Example===
{{cpp/locale/messages/example}}

===See also===
{{dsc begin}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages/~messages</title>
    <ns>0</ns>
    <id>4447</id>
    <revision>
      <id>43396</id>
      <parentid>15820</parentid>
      <timestamp>2012-11-03T02:38:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/locale/facet/destructor|messages}}

[[de:cpp/locale/messages/~messages]]
[[es:cpp/locale/messages/~messages]]
[[fr:cpp/locale/messages/~messages]]
[[it:cpp/locale/messages/~messages]]
[[ja:cpp/locale/messages/~messages]]
[[pt:cpp/locale/messages/~messages]]
[[ru:cpp/locale/messages/~messages]]
[[zh:cpp/locale/messages/~messages]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages base</title>
    <ns>0</ns>
    <id>3606</id>
    <revision>
      <id>64133</id>
      <parentid>58167</parentid>
      <timestamp>2013-08-15T03:04:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>defect/c++14</comment>
      <text xml:space="preserve" bytes="963">{{cpp/title | messages_base}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class messages_base;
}}
{{dcl end}}

The class {{lc|std::messages_base}} provides a type definition which is inherited and used by the {{lc|std::messages}} facets.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|catalog}} | {{c|/*unspecified signed integer type*/}}}}
{{dsc end}}

===Notes===
{{tt|catalog}} was erroneously specified as {{tt|int}} in C++11, this was corrected in [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2028 LWG issue #2028] and included in C++14

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc messages}}
{{dsc end}}

[[de:cpp/locale/messages base]]
[[es:cpp/locale/messages base]]
[[fr:cpp/locale/messages base]]
[[it:cpp/locale/messages base]]
[[ja:cpp/locale/messages base]]
[[pt:cpp/locale/messages base]]
[[ru:cpp/locale/messages base]]
[[zh:cpp/locale/messages base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/messages byname</title>
    <ns>0</ns>
    <id>9246</id>
    <revision>
      <id>61617</id>
      <parentid>58168</parentid>
      <timestamp>2013-06-06T07:21:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+inline descriptions</comment>
      <text xml:space="preserve" bytes="2718">{{cpp/title | messages_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class messages_byname : public std::messages&lt;CharT&gt;;
}}
{{dcl end}}

{{lc|std::messages_byname}} is a {{lc|std::messages}} facet which encapsulates retrieval of strings from message catalogs of the locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::messages_byname&lt;char&gt;}} | narrow/multibyte message catalog access }}
{{dsc | {{c|std::messages_byname&lt;wchar_t&gt;}} | wide string message catalog access }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|catalog}} | {{tt|std::messages_base&lt;CharT&gt;::catalog}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | messages_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | messages_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | messages_byname}}
{{include | cpp/locale/byname/destructor | messages_byname}}

{{cpp/locale/messages/inherit}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
 
void try_with(const std::locale&amp; loc)
{
    const std::messages&lt;char&gt;&amp; facet = std::use_facet&lt;std::messages&lt;char&gt; &gt;(loc)
;
    std::messages&lt;char&gt;::catalog cat = facet.open(&quot;sed&quot;, std::cout.getloc());
    if(cat &lt; 0 )
        std::cout &lt;&lt; &quot;Could not open \&quot;sed\&quot; message catalog\n&quot;;
    else
        std::cout &lt;&lt; &quot;\&quot;No match\&quot; &quot;
                  &lt;&lt; facet.get(cat, 0, 0, &quot;No match&quot;) &lt;&lt; '\n'
                  &lt;&lt; &quot;\&quot;Memory exhausted\&quot; &quot; 
                  &lt;&lt; facet.get(cat, 0, 0, &quot;Memory exhausted&quot;) &lt;&lt; '\n';
    facet.close(cat);
}
int main()
{
    std::locale loc(&quot;en_US.utf8&quot;);
    std::cout.imbue(loc);

    try_with(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;de_DE.utf8&quot;)));
    try_with(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;fr_FR.utf8&quot;)));
    try_with(std::locale(loc, new std::messages_byname&lt;char&gt;(&quot;ja_JP.utf8&quot;)));
}
 | p=true
 | output=
&quot;No match&quot; Keine Übereinstimmung
&quot;Memory exhausted&quot; Speicher erschöpft
&quot;No match&quot; Pas de concordance
&quot;Memory exhausted&quot; Mémoire épuisée
&quot;No match&quot; 照合しません
&quot;Memory exhausted&quot; メモリーが足りません
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc messages}}
{{dsc end}}

[[de:cpp/locale/messages byname]]
[[es:cpp/locale/messages byname]]
[[fr:cpp/locale/messages byname]]
[[it:cpp/locale/messages byname]]
[[ja:cpp/locale/messages byname]]
[[pt:cpp/locale/messages byname]]
[[ru:cpp/locale/messages byname]]
[[zh:cpp/locale/messages byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money base</title>
    <ns>0</ns>
    <id>3607</id>
    <revision>
      <id>69678</id>
      <parentid>64436</parentid>
      <timestamp>2014-04-19T12:32:22Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2062">{{cpp/title | money_base}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class money_base;
}}
{{dcl end}}

The class {{lc|std::money_base}} provides constants which are inherited and used by the {{lc|std::moneypunct}}, {{lc|std::money_get}} and {{lc|std::money_put}} facets.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|enum part { none, space, symbol, sign, value };}} | unscoped enumeration type}}
{{dsc | {{c|struct pattern { char field[4]; };}} | the monetary format type}}
{{dsc end}}

{{dsc begin}}
{{dsc hitem | Enumeration constant | Definition}}
{{dsc | {{tt|none}}     | whitespace is permitted but not required except in the last position, where whitespace is not permitted}}
{{dsc | {{tt|space}}    | one or more whitespace characters are required}}
{{dsc | {{tt|symbol}}   | the sequence of characters returned by moneypunct::curr_symbol is required}}
{{dsc | {{tt|sign}}     | the first of the characters returned by moneypunct::positive_sign or moneypunct::negative_sign is required}}
{{dsc | {{tt|value}}    | the absolute numeric monetary value is required}}
{{dsc end}}

===Notes===
The monetary format is an array of four {{c|char}}s convertible to {{lc|std::money_base::part}}. In that sequence, each of {{tt|symbol}}, {{tt|sign}}, and {{tt|value}} appears exactly once, and either {{tt|space}} or {{tt|none}} appears in the remaining position. The value {{tt|none}}, if present, is not first; the value {{tt|space}}, if present, is neither first nor last.

The default format, returned by the standard specializations of {{lc|std::moneypunct}} is {{c|{symbol, sign, none, value} }}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc end}}

[[de:cpp/locale/money base]]
[[es:cpp/locale/money base]]
[[fr:cpp/locale/money base]]
[[it:cpp/locale/money base]]
[[ja:cpp/locale/money base]]
[[pt:cpp/locale/money base]]
[[ru:cpp/locale/money base]]
[[zh:cpp/locale/money base]]</text>
      <sha1>72hhnfihqyro35h3pgj1psyxaak2np6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money get</title>
    <ns>0</ns>
    <id>3760</id>
    <revision>
      <id>65774</id>
      <parentid>64431</parentid>
      <timestamp>2013-10-07T18:36:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3624">{{cpp/title|money_get}}
{{cpp/locale/money_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT,
    class InputIt = std::istreambuf_iterator&lt;CharT&gt;
&gt; class money_get;
}}
{{dcl end}}

Class template {{tt|std::money_get}} encapsulates the rules for parsing monetary values from character streams. The standard I/O manipulator {{lc|std::get_money}} uses the {{tt|std::money_get}} facet of the I/O stream's locale.

{{inheritance diagram/std-money_get}}

===Type requirements===
{{par begin}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Specializations===
Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::money_get&lt;char&gt;}} | parses narrow string representations of monetary values}}
{{dsc | {{c|std::money_get&lt;wchar_t&gt;}} | parses wide string representations of monetary values}}
{{dsc | {{c|std::money_get&lt;char, InputIt&gt;}} | parses narrow string representations of monetary values using custom input iterator}}
{{dsc | {{c|std::money_get&lt;wchar_t, InputIt&gt;}} | parses wide string representations of monetary values using custom input iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;CharT&gt;}}}}
{{dsc | {{tt|iter_type}} | {{tt|InputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/money_get/money_get | constructs a new money_get facet }}
{{dsc prot mem dtor | cpp/locale/money_get/~money_get | destructs a money_get facet }}
{{dsc mem fun | cpp/locale/money_get/get | invokes {{tt|do_get}} }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/money_get/dsc do_get}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;
#include &lt;iterator&gt;
int main()
{
    std::string str = &quot;$1.11 $2.22 $3.33&quot;;
    std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(2);

    std::cout &lt;&lt; '&quot;' &lt;&lt; str &lt;&lt; &quot;\&quot; parsed with the I/O manipulator: &quot;;
    std::istringstream s1(str);
    s1.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    long double val;
    while(s1 &gt;&gt; std::get_money(val))
        std::cout &lt;&lt; val/100 &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    str = &quot;USD  1,234.56&quot;;
    std::cout &lt;&lt; '&quot;' &lt;&lt; str &lt;&lt; &quot;\&quot; parsed with the facet directly: &quot;;
    std::istringstream s2(str);
    s2.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    auto&amp; f = std::use_facet&lt;std::money_get&lt;char&gt;&gt;(s2.getloc());
    std::ios_base::iostate err;
    std::istreambuf_iterator&lt;char&gt; beg(s2), end;
    f.get(beg, end, true, s2, err, val);
    std::cout &lt;&lt; val/100 &lt;&lt; '\n';
}
 | output=
&quot;$1.11 $2.22 $3.33&quot; parsed with the I/O manipulator: 1.11 2.22 3.33
&quot;USD  1,234.56&quot; parsed with the facet directly: 1234.56
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc tfun | cpp/io/manip/get_money | parses a monetary value| notes={{mark c++11}}}}
{{dsc end}}

[[de:cpp/locale/money get]]
[[es:cpp/locale/money get]]
[[fr:cpp/locale/money get]]
[[it:cpp/locale/money get]]
[[ja:cpp/locale/money get]]
[[pt:cpp/locale/money get]]
[[ru:cpp/locale/money get]]
[[zh:cpp/locale/money get]]</text>
      <sha1>q7rkucny3gdea1qdime5x957nn34d6s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money get/get</title>
    <ns>0</ns>
    <id>12906</id>
    <revision>
      <id>64593</id>
      <timestamp>2013-08-22T14:17:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="7198">{{cpp/locale/money_get/title | get, do_get}}
{{cpp/locale/money_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type get(iter_type beg, iter_type end, bool intl, std::ios_base&amp; str,
              std::ios_base::iostate&amp; err, long double&amp; units) const;}}
{{dcl | num=2 | 1=
iter_type get(iter_type beg, iter_type end, bool intl, std::ios_base&amp; str,
              std::ios_base::iostate&amp; err, string_type&amp; digits) const;}}
{{dcl | num=3 | 1=
protected:
virtual iter_type get(iter_type beg, iter_type end, bool intl, std::ios_base&amp; str,
                      std::ios_base::iostate&amp; err, long double&amp; units) const;}}
{{dcl | num=4 | 1=
virtual iter_type get(iter_type beg, iter_type end, bool intl, std::ios_base&amp; str,
                      std::ios_base::iostate&amp; err, string_type&amp; digits) const;
}}
{{dcl end}}

Parses monetary value from an input iterator and writes the result to a {{tt|long double}} or string.

@1-2@ Public member functions, call the member function {{tt|do_get}} of the most derived class.

@3-4@ Reads characters from the input iterator {{tt|beg}}, expecting to find a monetary value formatted according to the rules specified by the {{c|std::ctype}} facet imbued in {{c|str.getloc()}} ({{tt|ct}} for the rest of this page), the {{c|std::moneypunct&lt;CharT, intl&gt;}} facet imbued in {{c|str.getloc()}} ({{tt|mp}} for the rest of this page), and the stream formatting flags obtained from {{c|str.flags()}}.

If the input iterator {{tt|beg}} becomes equal to {{tt|end}} before the parsing was completed, sets both {{lc|failbit}} and {{lc|eofbit}} in {{tt|err}}. If parsing fails for another reason, sets the {{tt|failbit}} in {{tt|err}}. Either way, does not modify the output parameter (({{tt|units}} or {{tt|digits}}) on error.

If the parsing succeeds, does not change {{tt|err}}, and stores the result in {{tt|units}} or {{tt|digits}}.

The formatting {{lc|pattern}} used by this function is always {{c|mp.neg_format()}}.

If {{c|mp.grouping()}} does not permit thousands separators, the first separator encountered is treated as a parsing error, otherwise they are treated as optional.

If {{lc|money_base::space}} or {{lc|money_base::none}} is the last element in the {{lc|pattern}}, the parser does not attempt to consume any whitespace after the other components of the monetary value were parsed. Otherwise, one or more whitespace characters are consumed where {{lc|money_base::space}} appears.

If {{tt|showbase}} flag is set in {{c|str.flags()}}, the currency symbol or currency string is required, if it is not set, the currency symbol is optional.

If the first character of the string returned by {{c|mp.positive_sign()}} or {{c|mp.negative_sign()}} is found in the {{lc|money_base::sign}} position of the formatting pattern, it is consumed, and the rest of the characters in that string are expected and consumed after all other components of the monetary value. If both {{c|mp.positive_sign()}} and  {{c|mp.negative_sign()}} are non-empty, the sign is required and must match the first character of one of these strings. If one of theses strings is empty, the sign is optional (and if it is absent, the sign of the result corresponds to the string that was empty). If both strings are empty, or have the same first character, the result is given the positive sign. If the output parameter is a string ({{tt|digits}}) and the result is negative, the value {{c|ct.widen('-')}} is stored as the first character of the result.

Digits from the input are extracted in order in which they appear and are placed in {{tt|digits}} (after widening by {{c|ct.widen()}} as necessary), or into a temporary buffer {{tt|buf1}}, from which the value of {{tt|units}} is constructed as if by 

{{source|1=static const char src[] = &quot;0123456789-&quot;;
CharT atoms[sizeof(src)];
ct.widen(src, src + sizeof(src) - 1, atoms);
for (int i = 0; i &lt; n; ++i)
buf2[i] = src[find(atoms, atoms+sizeof(src), buf1[i]) - atoms];
buf2[n] = 0;
sscanf(buf2, &quot;%Lf&quot;, &amp;units);
}}
(where {{tt|n}} is the number of characters extracted from the input and stored in {{tt|buf1}} and {{tt|buf2}} is another sufficiently large character buffer)

===Return value===
An iterator pointing immediately after the last character recognized as a valid part of the monetary string input.

===Notes===
The currency units are assumed to be the smallest non-fractional units of the currency: cents in the U.S, yen in Japan. Thus, the input sequence {{c|&quot;$1,056.23&quot;}} in a U.S. locale produces the number {{c|105623.0}} in {{tt|units}} or a string {{c|&quot;105623&quot;}} in {{tt|digits}}

Because currency symbol is optional if {{tt|showbase}} is off but the entire multicharacter {{tt|negative_sign()}} is required, given the formatting pattern {{c|{sign, value, space, symbol} }} with {{tt|showbase}} off and negative_sign of {{c|&quot;-&quot;}}, the string {{c|&quot;-1.23 €&quot;}} parses as {{c|-123}} and leaves &quot;€&quot; unconsumed on the input stream, but if negative_sign is {{c|&quot;()&quot;}}, the string {{c|&quot;(1.23 €)&quot;}} is consumed completely.

The I/O manipulator {{lc|std::get_money}} offers a simpler interface to this function.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;

void demo_money_get(std::locale loc, const std::string&amp; input)
{
    std::istringstream str(input);
    str.imbue(loc);
    long double units;
// note, the following can be written simple with std::get_money(units)
    std::ios_base::iostate err = std::ios_base::goodbit;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::money_get&lt;char&gt;&gt;(loc).get(
                 std::istreambuf_iterator&lt;char&gt;(str),
                 std::istreambuf_iterator&lt;char&gt;(),
                 false, str, err, units);
    str.setstate(err);
    if(str) {
        std::cout &lt;&lt; &quot;Successfully parsed '&quot; &lt;&lt; str.str() &lt;&lt; &quot;' as &quot;
                  &lt;&lt; units/100 &lt;&lt; &quot; units\n&quot;;
        if(ret != std::istreambuf_iterator&lt;char&gt;()) {
            std::cout &lt;&lt; &quot;Remaining content: '&quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                           std::ostreambuf_iterator&lt;char&gt;(std::cout));
            std::cout &lt;&lt; &quot;'\n&quot;;
        } else {
            std::cout &lt;&lt; &quot;The input was fully consumed\n&quot;;
        }
    } else {
            std::cout &lt;&lt; &quot;Parse failed. Unparsed string: '&quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                           std::ostreambuf_iterator&lt;char&gt;(std::cout));
            std::cout &lt;&lt; &quot;'\n&quot;;
    }
}

int main()
{
    demo_money_get(std::locale(&quot;en_US.utf8&quot;), &quot;-$5.12 abc&quot;);
    demo_money_get(std::locale(&quot;ms_MY.utf8&quot;), &quot;(RM5.12) def&quot;);
}
 | output=
Successfully parsed '-$5.12 abc' as -5.12 units
Remaining content: ' abc'
Successfully parsed '(RM5.12) def' as -5.12 units
Remaining content: ' def'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/io/manip/dsc get_money}}
{{dsc end}}

[[de:cpp/locale/money_get/get]]
[[es:cpp/locale/money_get/get]]
[[fr:cpp/locale/money_get/get]]
[[it:cpp/locale/money_get/get]]
[[ja:cpp/locale/money_get/get]]
[[pt:cpp/locale/money_get/get]]
[[ru:cpp/locale/money_get/get]]
[[zh:cpp/locale/money_get/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money get/money get</title>
    <ns>0</ns>
    <id>4427</id>
    <revision>
      <id>43364</id>
      <parentid>15796</parentid>
      <timestamp>2012-11-03T02:32:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="347">{{cpp/locale/facet/constructor|money_get}}

[[de:cpp/locale/money get/money get]]
[[es:cpp/locale/money get/money get]]
[[fr:cpp/locale/money get/money get]]
[[it:cpp/locale/money get/money get]]
[[ja:cpp/locale/money get/money get]]
[[pt:cpp/locale/money get/money get]]
[[ru:cpp/locale/money get/money get]]
[[zh:cpp/locale/money get/money get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money get/~money get</title>
    <ns>0</ns>
    <id>4440</id>
    <revision>
      <id>43358</id>
      <parentid>15813</parentid>
      <timestamp>2012-11-03T02:30:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="354">{{cpp/locale/facet/destructor|money_get}}

[[de:cpp/locale/money get/~money get]]
[[es:cpp/locale/money get/~money get]]
[[fr:cpp/locale/money get/~money get]]
[[it:cpp/locale/money get/~money get]]
[[ja:cpp/locale/money get/~money get]]
[[pt:cpp/locale/money get/~money get]]
[[ru:cpp/locale/money get/~money get]]
[[zh:cpp/locale/money get/~money get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money put</title>
    <ns>0</ns>
    <id>3751</id>
    <revision>
      <id>65775</id>
      <parentid>64434</parentid>
      <timestamp>2013-10-07T18:38:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3304">{{cpp/title|money_put}}
{{cpp/locale/money_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT,
    class OutputIt = std::ostreambuf_iterator&lt;CharT&gt;
&gt; class money_put;
}}
{{dcl end}}

Class {{tt|std::money_put}} encapsulates the rules for formatting monetary values as strings. The standard I/O manipulator {{lc|std::put_money}} uses the {{tt|std::money_put}} facet of the I/O stream's locale.

{{inheritance diagram/std-money_put}}

===Type requirements===
{{par begin}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Specializations===
Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::money_put&lt;char&gt;}} | creates narrow string representations of monetary values}}
{{dsc | {{c|std::money_put&lt;wchar_t&gt;}} | creates wide string representations of monetary values}}
{{dsc | {{c|std::money_put&lt;char, OutputIt&gt;}} | creates narrow string representations of monetary values using custom output iterator}}
{{dsc | {{c|std::money_put&lt;wchar_t, OutputIt&gt;}} | creates wide string representations of monetary values using custom output iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;CharT&gt;}}}}
{{dsc | {{tt|iter_type}} | {{tt|OutputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/money_put/money_put | constructs a new money_put facet }}
{{dsc prot mem dtor | cpp/locale/money_put/~money_put | destructs a money_put facet }}
{{dsc mem fun | cpp/locale/money_put/put | invokes {{tt|do_put}} }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/money_put/dsc do_put}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;
#include &lt;iterator&gt;
int main()
{
    // using the IO manipulator
    std::cout.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    std::cout &lt;&lt; &quot;american locale: &quot;
               &lt;&lt; std::showbase &lt;&lt; std::put_money(12345678.9)&lt;&lt; '\n';

    // using the facet directly
    std::cout.imbue(std::locale(&quot;de_DE&quot;));
    std::cout &lt;&lt; &quot;german locale: &quot; ;
    std::ostreambuf_iterator&lt;char&gt; out(std::cout);
    auto&amp; f = std::use_facet&lt;std::money_put&lt;char&gt;&gt;(std::cout.getloc());
    f.put(out, false, std::cout, std::cout.fill(), 12345678.9 );
    std::cout &lt;&lt; '\n';
}
 | output=
american locale: $123,456.79
german locale: 123.456,79 EUR
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc tfun | cpp/io/manip/put_money | formats and outputs a monetary value| notes={{mark c++11}}}}
{{dsc end}}

[[de:cpp/locale/money put]]
[[es:cpp/locale/money put]]
[[fr:cpp/locale/money put]]
[[it:cpp/locale/money put]]
[[ja:cpp/locale/money put]]
[[pt:cpp/locale/money put]]
[[ru:cpp/locale/money put]]
[[zh:cpp/locale/money put]]</text>
      <sha1>gb2q51d6hp6hp11xymdlx8p2viqt73c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money put/money put</title>
    <ns>0</ns>
    <id>4432</id>
    <revision>
      <id>43343</id>
      <parentid>15802</parentid>
      <timestamp>2012-11-03T02:28:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="347">{{cpp/locale/facet/constructor|money_put}}

[[de:cpp/locale/money put/money put]]
[[es:cpp/locale/money put/money put]]
[[fr:cpp/locale/money put/money put]]
[[it:cpp/locale/money put/money put]]
[[ja:cpp/locale/money put/money put]]
[[pt:cpp/locale/money put/money put]]
[[ru:cpp/locale/money put/money put]]
[[zh:cpp/locale/money put/money put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money put/put</title>
    <ns>0</ns>
    <id>12898</id>
    <revision>
      <id>64444</id>
      <parentid>64443</parentid>
      <timestamp>2013-08-17T16:45:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="5747">{{cpp/locale/money_put/title | put, do_put}}
{{cpp/locale/money_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type put(iter_type out, bool intl, std::ios_base&amp; f,
              char_type fill, long double quant) const; }}
{{dcl | num=2 | 1=
iter_type put(iter_type out, bool intl, std::ios_base&amp; f,
             char_type fill, const string_type&amp; quant) const;}}
{{dcl | num=3 | 1=
protected:
virtual iter_type do_put(iter_type out, bool intl, std::ios_base&amp; str,
                         char_type fill, long double units) const;}}
{{dcl | num=4 | 1=
virtual iter_type do_put(iter_type out, bool intl, std::ios_base&amp; str,
                         char_type fill, const string_type&amp; digits) const;
}}
{{dcl end}}

Formats monetary value and writes the result to output stream.

@1-2@ Public member functions, call the member function {{tt|do_put}} of the most derived class.

@3@ The numeric arguments {{tt|units}} is converted to a wide character string as if by
{{c|ct.widen(buf1, buf1 + std::sprintf(buf1, &quot;%.0Lf&quot;, units), buf2)}}, where {{tt|ct}} is the {{c|std::ctype}} facet imbued in {{c|str.getloc()}} and {{tt|buf1}} and {{tt|buf2}} are sufficiently large character buffers. The resulting character string {{tt|buf2}} is processed, formatted, and output to {{tt|out}} as desribed below.

@4@ From the string argument {{tt|digits}}, only the optional leading minus sign (as determined by comparing to {{tt|ct.widen('-')}}, where {{tt|ct}} is the {{c|std::ctype}} facet imbued in {{c|str.getloc()}}) and the immediately following digit characters (as classified by {{tt|ct}}) are taken as the character sequence to be processed, formatted, and output to {{tt|out}} as described below.

Given the character sequence from the previous steps, if the first character equals {{c|ct.widen('-')}}, calls {{c|mp.neg_format()}} to obtain the formatting {{lc|pattern}}, otherwise calls {{c|mp.pos_format()}}, where {{tt|mp}} is the {{c|std::moneypunct&lt;CharT, intl&gt;}} facet imbued in {{c|str.getloc()}}.

Thousands separator and decimal point characters are inserted as required by {{tt|mp.grouping()}}, {{tt|mp.frac_digits()}}, {{tt|mp.decimal_point()}}, and {{tt|mp.thousands_sep()}}, and the resulting string is placed in the output sequence where {{lc|value}} appears in the formatting pattern.

If {{c|str.flags() &amp; str.showbase}} is non-zero (the {{c|std::showbase}} manipulator was used), then the currency symbol or string is generated by calling {{c|mp.curr_symbol()}} and placed in the output sequence where {{lc|symbol}} appears in the formatting pattern.

If {{c|mp.positive_sign()}} (in case positive format pattern is used) or {{c|mp.negative_sign()}} (in case negative format pattern is used) returns a string with more than one character, the first character returned is placed in the output sequence where {{lc|sign}} appears in the formatting pattern, and the rest of the characters are placed after all other characters, for example, formatting pattern {{c|{sign, value, space, symbol}} with units {{c|123}} and negative_sign of {{c|&quot;-&quot;}} may result in {{c|&quot;-1.23 €&quot;}}, while negative_sign of {{c|&quot;()&quot;}} would generate {{c|&quot;(1.23 €)&quot;}}.

If the number of characters generated for the specified format is less than the value returned by {{c|str.width()}}, then copies of {{tt|fill}} are inserted to bring the total length of the output sequence to exactly {{c|str.width()}}, as follows:
* If {{c|str.flags() &amp; str.adjustfield}} equals {{c|str.internal}}, the fill characters are inserted where {{tt|none}} or {{tt|space}} appears in the formatting pattern.
* Otherwise, if {{c|str.flags() &amp; str.adjustfield}} equals {{c|str.left}}, the copies of {{tt|fill}} are appended after all other characters
* Otherwise, the fill characters are placed before all other characters.

In the end, calls {{c|str.width(0)}} to cancel the effects of any {{c|std::setw}}.

===Return value===
An iterator pointing immediately after the last character produced

===Notes===
The currency units are assumed to be the smallest non-fractional units of the currency: cents in the U.S, yen in Japan.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;

struct my_punct : std::moneypunct_byname&lt;char, false&gt; {
    my_punct(const char* name) : moneypunct_byname(name) {}
    string_type do_negative_sign() const { return &quot;()&quot;; }
};

int main()
{
    std::locale loc(&quot;ru_RU.utf8&quot;);
    std::cout.imbue(loc);
    long double units = -123.45;
    std::cout &lt;&lt; &quot;In Russian locale, &quot; &lt;&lt; units &lt;&lt; &quot; prints as &quot;
              &lt;&lt; std::showbase;
// note, the following is equivalent to simply std::put_money(units)
    std::use_facet&lt;std::money_put&lt;char&gt;&gt;(loc).put(
             std::ostreambuf_iterator&lt;char&gt;(std::cout),
             false, std::cout, std::cout.fill(), units);
    std::cout &lt;&lt; '\n';

    std::cout.imbue(std::locale(std::cout.getloc(), new my_punct(&quot;ru_RU.utf8&quot;)));
    std::cout &lt;&lt; &quot;With negative_sign set to \&quot;()\&quot;, it prints  as &quot;;
    std::use_facet&lt;std::money_put&lt;char&gt;&gt;(loc).put(
             std::ostreambuf_iterator&lt;char&gt;(std::cout),
             false, std::cout, std::cout.fill(), units);
    std::cout &lt;&lt; '\n';
}
 | output=
In Russian locale, -123,45 prints as -1.23 руб
With negative_sign set to &quot;()&quot;, it prints  as (1.23 руб)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/io/manip/dsc put_money}}
{{dsc end}}

[[de:cpp/locale/money_put/put]]
[[es:cpp/locale/money_put/put]]
[[fr:cpp/locale/money_put/put]]
[[it:cpp/locale/money_put/put]]
[[ja:cpp/locale/money_put/put]]
[[pt:cpp/locale/money_put/put]]
[[ru:cpp/locale/money_put/put]]
[[zh:cpp/locale/money_put/put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/money put/~money put</title>
    <ns>0</ns>
    <id>4439</id>
    <revision>
      <id>43336</id>
      <parentid>15811</parentid>
      <timestamp>2012-11-03T02:27:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="354">{{cpp/locale/facet/destructor|money_put}}

[[de:cpp/locale/money put/~money put]]
[[es:cpp/locale/money put/~money put]]
[[fr:cpp/locale/money put/~money put]]
[[it:cpp/locale/money put/~money put]]
[[ja:cpp/locale/money put/~money put]]
[[pt:cpp/locale/money put/~money put]]
[[ru:cpp/locale/money put/~money put]]
[[zh:cpp/locale/money put/~money put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct</title>
    <ns>0</ns>
    <id>3608</id>
    <revision>
      <id>65776</id>
      <parentid>64429</parentid>
      <timestamp>2013-10-07T18:39:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3286">{{cpp/title | moneypunct}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT, bool International = false &gt;
class moneypunct;
}}
{{dcl end}}

The facet {{lc|std::moneypunct}} encapsulates monetary value format preferences. Stream I/O manipulators {{lc|std::get_money}} and {{lc|std::put_money}} use {{lc|std::moneypunct}} through {{lc|std::money_get}} and {{lc|std::money_put}} for parsing monetary value input and formatting monetary value output. 

{{inheritance diagram/std-moneypunct}}

Four standalone (locale-independent) specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::moneypunct&lt;char&gt;}}          | provides equivalents of the &quot;C&quot; locale preferences }}
{{dsc | {{c|std::moneypunct&lt;wchar_t&gt;}}       | provides wide character equivalents of the &quot;C&quot; locale preferences }}
{{dsc | {{c|std::moneypunct&lt;char, true&gt;}}    | provides equivalents of the &quot;C&quot; locale preferences, with international currency symbols }}
{{dsc | {{c|std::moneypunct&lt;wchar_t, true&gt;}} | provides wide character equivalents of the &quot;C&quot; locale preferences, with international currency symbols }}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc constructor}}
{{dsc inc | cpp/locale/moneypunct/dsc destructor}}
{{dsc inc | cpp/locale/moneypunct/dsc decimal_point}}
{{dsc inc | cpp/locale/moneypunct/dsc thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc grouping}}
{{dsc inc | cpp/locale/moneypunct/dsc curr_symbol}}
{{dsc inc | cpp/locale/moneypunct/dsc positive_sign}}
{{dsc inc | cpp/locale/moneypunct/dsc frac_digits}}
{{dsc inc | cpp/locale/moneypunct/dsc pos_format}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_decimal_point}}
{{dsc inc | cpp/locale/moneypunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc do_grouping}}
{{dsc inc | cpp/locale/moneypunct/dsc do_curr_symbol}}
{{dsc inc | cpp/locale/moneypunct/dsc do_positive_sign}}
{{dsc inc | cpp/locale/moneypunct/dsc do_frac_digits}}
{{dsc inc | cpp/locale/moneypunct/dsc do_pos_format}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc hitem | Member | Definition}}
{{dsc | {{dsc small|const bool}} {{tt|intl}} {{mark|static}} | {{tt|International}} }}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

{{include | cpp/locale/money_base/inherit}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc money_base}}
{{dsc inc | cpp/locale/dsc moneypunct_byname}}
{{dsc inc | cpp/locale/dsc money_get}}
{{dsc inc | cpp/locale/dsc money_put}}
{{dsc end}}

[[de:cpp/locale/moneypunct]]
[[es:cpp/locale/moneypunct]]
[[fr:cpp/locale/moneypunct]]
[[it:cpp/locale/moneypunct]]
[[ja:cpp/locale/moneypunct]]
[[pt:cpp/locale/moneypunct]]
[[ru:cpp/locale/moneypunct]]
[[zh:cpp/locale/moneypunct]]</text>
      <sha1>sy4qienrtpnd17p3iencybuhy6ixeew</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/curr symbol</title>
    <ns>0</ns>
    <id>12881</id>
    <revision>
      <id>64099</id>
      <parentid>64094</parentid>
      <timestamp>2013-08-08T23:56:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-neg</comment>
      <text xml:space="preserve" bytes="2177">{{cpp/locale/moneypunct/title | curr_symbol, do_curr_symbol}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
string_type curr_symbol() const;
}}
{{dcl | num=2 | 1=
protected:
virtual string_type do_curr_symbol() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_curr_symbol}} of the most derived class.

@2@ Returns the string used as the currency identifier by this locale. If {{tt|International}} (the second template parameter of {{tt|std::moneypunct}}) is {{c|false}}, the identifier is usually a single (wide) character, such as {{c|&quot;￥&quot;}} or {{c|&quot;$&quot;}}. If {{tt|International}} is {{c|true}}, the identifier is usually a four-character string holding the three-character international currency code followed by a space ({{c|&quot;JPY &quot;}} or {{c|&quot;USD &quot;}})

===Return value===
The object of type {{tt|string_type}} holding the currency symbol or code.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
void show_ccy(const char* locname)
{
    std::locale loc(locname);
    std::cout &lt;&lt; locname &lt;&lt; &quot; currency symbol is &quot;
              &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char, true&gt;&gt;(loc).curr_symbol()
              &lt;&lt; &quot;or &quot; &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char&gt;&gt;(loc).curr_symbol()
              &lt;&lt; &quot; for short\n&quot;;
}
int main()
{
    show_ccy(&quot;en_US.utf8&quot;);
    show_ccy(&quot;ja_JP.utf8&quot;);
    show_ccy(&quot;sv_SE.utf8&quot;);
    show_ccy(&quot;ru_RU.utf8&quot;);
    show_ccy(&quot;vi_VN.utf8&quot;);
}
 | output=
en_US.utf8 currency symbol is USD or $ for short
ja_JP.utf8 currency symbol is JPY or ￥ for short
sv_SE.utf8 currency symbol is SEK or kr for short
ru_RU.utf8 currency symbol is RUB or руб for short
vi_VN.utf8 currency symbol is VND or ₫ for short
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_pos_format}}
{{dsc end}}

[[de:cpp/locale/moneypunct/curr_symbol]]
[[es:cpp/locale/moneypunct/curr_symbol]]
[[fr:cpp/locale/moneypunct/curr_symbol]]
[[it:cpp/locale/moneypunct/curr_symbol]]
[[ja:cpp/locale/moneypunct/curr_symbol]]
[[pt:cpp/locale/moneypunct/curr_symbol]]
[[ru:cpp/locale/moneypunct/curr_symbol]]
[[zh:cpp/locale/moneypunct/curr_symbol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/decimal point</title>
    <ns>0</ns>
    <id>12893</id>
    <revision>
      <id>65575</id>
      <parentid>64420</parentid>
      <timestamp>2013-09-20T22:59:03Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2081">{{cpp/locale/moneypunct/title | decimal_point, do_decimal_point}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
CharT decimal_point() const;
}}
{{dcl | num=2 | 1=
protected:
virtual CharT do_decimal_point() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_decimal_point}} of the most derived class.

@2@ Returns the character to use as the decimal point separator in monetary I/O if the format uses fractions (that is, if {{lc|do_frac_digits()}} is greater than zero). For typical U.S. locales, it is the character {{c|'.'}} (or {{c|L'.'}})

===Return value===
The object of type {{tt|CharT}} holding the decimal point character. 

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;

void show_dpt(const char* locname)
{
    std::locale loc(locname);
    std::cout.imbue(loc);
    std::cout &lt;&lt; locname &lt;&lt; &quot; decimal point is '&quot;
              &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char&gt;&gt;(loc).decimal_point()
              &lt;&lt; &quot;' for example: &quot; &lt;&lt; std::showbase &lt;&lt; std::put_money(123);
    if (std::use_facet&lt;std::moneypunct&lt;char&gt;&gt;(loc).frac_digits() == 0)
        std::cout &lt;&lt; &quot; (does not use frac digits) &quot;;

    std::cout &lt;&lt; '\n';
}

int main()
{
    show_dpt(&quot;en_US.utf8&quot;);
    show_dpt(&quot;ja_JP.utf8&quot;);
    show_dpt(&quot;sv_SE.utf8&quot;);
    show_dpt(&quot;de_DE.utf8&quot;);

}
 | output=
en_US.utf8 decimal point is '.' for example: $1.23
ja_JP.utf8 decimal point is '.' for example: ￥123 (does not use frac digits)
sv_SE.utf8 decimal point is ',' for example: 1,23 kr
de_DE.utf8 decimal point is ',' for example: 1,23 €
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_frac_digits}}
{{dsc end}}

[[de:cpp/locale/moneypunct/decimal_point]]
[[es:cpp/locale/moneypunct/decimal_point]]
[[fr:cpp/locale/moneypunct/decimal_point]]
[[it:cpp/locale/moneypunct/decimal_point]]
[[ja:cpp/locale/moneypunct/decimal_point]]
[[pt:cpp/locale/moneypunct/decimal_point]]
[[ru:cpp/locale/moneypunct/decimal_point]]
[[zh:cpp/locale/moneypunct/decimal_point]]</text>
      <sha1>tfitk5gh5mn7l7j6he29nm98qgg5zag</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/do thousands sep</title>
    <ns>0</ns>
    <id>9465</id>
    <redirect title="cpp/locale/moneypunct/thousands sep" />
    <revision>
      <id>40316</id>
      <timestamp>2012-10-12T18:54:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/moneypunct/do thousands sep]] to [[cpp/locale/moneypunct/thousands sep]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/locale/moneypunct/thousands sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/frac digits</title>
    <ns>0</ns>
    <id>12876</id>
    <revision>
      <id>69693</id>
      <parentid>69676</parentid>
      <timestamp>2014-04-20T03:37:13Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1144">{{cpp/locale/moneypunct/title | frac_digits, do_frac_digits}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
int frac_digits() const;
}}
{{dcl | num=2 | 1=
protected:
virtual int do_frac_digits() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_frac_digits}} of the most derived class.

@2@ Returns the number of digits to be displayed after the decimal point when printing monetary values

===Return value===
The number of digits to be displayed after the decimal point. In common U.S. locales, this is the value {{c|2}}.

===Example===
{{cpp/locale/moneypunct/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc do_decimal_point}}
{{dsc end}}

[[de:cpp/locale/moneypunct/frac digits]]
[[es:cpp/locale/moneypunct/frac digits]]
[[fr:cpp/locale/moneypunct/frac digits]]
[[it:cpp/locale/moneypunct/frac digits]]
[[ja:cpp/locale/moneypunct/frac digits]]
[[pt:cpp/locale/moneypunct/frac digits]]
[[ru:cpp/locale/moneypunct/frac digits]]
[[zh:cpp/locale/moneypunct/frac digits]]</text>
      <sha1>i3u0lhk2k3kpm9lpobv6ulx155j8e14</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/grouping</title>
    <ns>0</ns>
    <id>12877</id>
    <revision>
      <id>64069</id>
      <timestamp>2013-08-07T22:59:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1314">{{cpp/locale/moneypunct/title | grouping, do_grouping}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
std::string grouping() const;
}}
{{dcl | num=2 | 1=
protected:
virtual std::string do_grouping() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_grouping}} of the most derived class.

@2@ Returns the pattern that determines the grouping of the digits in the monetary output, with the same exact meaning as {{lc|std::numpunct::do_grouping}}

===Return value===
The object of type {{lc|std::string}} holding the groups. The standard specializations of {{tt|std::numpunct}} return an empty string, indicating no grouping. Typical groupings (e.g. the {{tt|en_US}} locale) return {{c|&quot;\003&quot;}}.

===Example===
{{cpp/locale/moneypunct/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc do_decimal_point}}
{{dsc end}}

[[de:cpp/locale/moneypunct/frac digits]]
[[es:cpp/locale/moneypunct/frac digits]]
[[fr:cpp/locale/moneypunct/frac digits]]
[[it:cpp/locale/moneypunct/frac digits]]
[[ja:cpp/locale/moneypunct/frac digits]]
[[pt:cpp/locale/moneypunct/frac digits]]
[[ru:cpp/locale/moneypunct/frac digits]]
[[zh:cpp/locale/moneypunct/frac digits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/moneypunct</title>
    <ns>0</ns>
    <id>4434</id>
    <revision>
      <id>43321</id>
      <parentid>15805</parentid>
      <timestamp>2012-11-03T02:24:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="364">{{cpp/locale/facet/constructor|moneypunct}}

[[de:cpp/locale/moneypunct/moneypunct]]
[[es:cpp/locale/moneypunct/moneypunct]]
[[fr:cpp/locale/moneypunct/moneypunct]]
[[it:cpp/locale/moneypunct/moneypunct]]
[[ja:cpp/locale/moneypunct/moneypunct]]
[[pt:cpp/locale/moneypunct/moneypunct]]
[[ru:cpp/locale/moneypunct/moneypunct]]
[[zh:cpp/locale/moneypunct/moneypunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/neg format</title>
    <ns>0</ns>
    <id>12897</id>
    <redirect title="cpp/locale/moneypunct/pos format" />
    <revision>
      <id>64435</id>
      <timestamp>2013-08-16T19:35:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/locale/moneypunct/pos_format]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/pos format</title>
    <ns>0</ns>
    <id>12882</id>
    <revision>
      <id>64432</id>
      <parentid>64101</parentid>
      <timestamp>2013-08-16T19:32:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso</comment>
      <text xml:space="preserve" bytes="2652">{{cpp/locale/moneypunct/title | pos_format, do_pos_format, neg_format, do_neg_format}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
pattern pos_format() const;
}}
{{dcl | num=2 | 1=
public:
pattern neg_format() const;
}}
{{dcl | num=3 | 1=
protected:
virtual pattern do_pos_format() const;
}}
{{dcl | num=4 | 1=
protected:
virtual pattern do_neg_format() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_pos_format}} of the most derived class.
@2@ Public member function, calls the member function {{tt|do_neg_format}} of the most derived class.
@3@ Returns the format structure (of type {{ltt|cpp/locale/money_base|std::money_base::format}}) which describes the formatting of positive monetary values.
@4@ Returns the format structure (of type {{ltt|cpp/locale/money_base|std::money_base::format}}) which describes the formatting of negative monetary values.

The standard specializations of {{c|std::moneypunct}} return the pattern {{c|{symbol, sign, none, value} }}

===Return value===
The object of type {{ltt|cpp/locale/money_base|std::money_base::format}} describing the formatting used by this locale.

===Example===
{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

struct my_punct : std::moneypunct_byname&lt;char, false&gt; {
    my_punct(const char* name) : moneypunct_byname(name) {}
    pattern do_pos_format() const { return { {value, space, symbol, sign} };}
    pattern do_neg_format() const { return { {value, space, symbol, sign} };}
};
int main()
{
    std::cout.imbue(std::locale(&quot;en_US.utf8&quot;));
    std::cout &lt;&lt; &quot;american locale: &quot; &lt;&lt; std::showbase
              &lt;&lt; std::put_money(12345678.0) &lt;&lt; '\n';

    std::cout.imbue(std::locale(std::cout.getloc(), new my_punct(&quot;en_US.utf8&quot;)));
    std::cout &lt;&lt; &quot;locale with modified moneypunct:\n&quot;
              &lt;&lt; std::put_money(12345678.0)  &lt;&lt; '\n'
              &lt;&lt; std::put_money(-12345678.0) &lt;&lt; '\n';
}
 | output=
american locale: $123,456.78
locale with modified moneypunct:
123,456.78 $
123,456.78 $-
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_curr_symbol}}
{{dsc inc | cpp/locale/moneypunct/dsc do_positive_sign}}
{{dsc inc | cpp/locale/money_get/dsc do_get}}
{{dsc inc | cpp/locale/money_put/dsc do_put}}
{{dsc end}}

[[de:cpp/locale/moneypunct/pos_format]]
[[es:cpp/locale/moneypunct/pos_format]]
[[fr:cpp/locale/moneypunct/pos_format]]
[[it:cpp/locale/moneypunct/pos_format]]
[[ja:cpp/locale/moneypunct/pos_format]]
[[pt:cpp/locale/moneypunct/pos_format]]
[[ru:cpp/locale/moneypunct/pos_format]]
[[zh:cpp/locale/moneypunct/pos_format]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/positive sign</title>
    <ns>0</ns>
    <id>12894</id>
    <revision>
      <id>64441</id>
      <parentid>64425</parentid>
      <timestamp>2013-08-17T05:42:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix copypaste typo in example and expand slightly</comment>
      <text xml:space="preserve" bytes="3030">{{cpp/locale/moneypunct/title | positive_sign, do_positive_sign, negative_sign, do_negative_sign}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
string_type positive_sign() const;
}}
{{dcl | num=2 | 1=
public:
string_type negative_sign() const;
}}
{{dcl | num=3 | 1=
protected:
virtual string_type do_positive_sign() const;
}}
{{dcl | num=4 | 1=
protected:
virtual string_type do_negative_sign() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_positive_sign}} of the most derived class.
@2@ Public member function, calls the member function {{tt|do_negative_sign}} of the most derived class.
@3@ Returns the string that is used for formatting of positive monetary values.
@3@ Returns the string that is used for formatting of negative monetary values.

Only the first character of the string returned is the character that appears in the {{lc|pos_format()}}/{{lc|neg_format()}} position indicated by the value {{c|sign}}. The rest of the characters appear ''after'' the rest of the monetary string.

In particular, for negative_sign of {{c|&quot;-&quot;}}, the formatting may appear as {{c|&quot;-1.23 €&quot;}}, while for negative_sign of {{c|&quot;()&quot;}} it would appear as {{c|&quot;(1.23 €)&quot;}}.

===Return value===
The string of type {{tt|string_type}} holding the characters to be used as positive or negative sign.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;

struct my_punct : std::moneypunct_byname&lt;char, false&gt; {
    my_punct(const char* name) : moneypunct_byname(name) {}
    string_type do_negative_sign() const { return &quot;()&quot;; }
};

int main()
{
    std::locale loc(&quot;de_DE.utf8&quot;);
    std::cout.imbue(loc);
    std::cout &lt;&lt; loc.name() &lt;&lt; &quot; negative sign is '&quot;
              &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char&gt;&gt;(loc).negative_sign()
              &lt;&lt; &quot;' for example: &quot; &lt;&lt; std::showbase &lt;&lt; std::put_money(-1234) &lt;&lt; '\n';

    std::locale loc2(&quot;ms_MY.utf8&quot;);
    std::cout.imbue(loc2);
    std::cout &lt;&lt; loc2.name() &lt;&lt; &quot; negative sign is '&quot;
              &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char&gt;&gt;(loc2).negative_sign()
              &lt;&lt; &quot;' for example: &quot; &lt;&lt; std::put_money(-1234) &lt;&lt; '\n';

    std::cout.imbue(std::locale(std::cout.getloc(), new my_punct(&quot;de_DE.utf8&quot;)));
    std::cout &lt;&lt; &quot;de_DE.utf8 with negative_sign set to \&quot;()\&quot;: &quot;
              &lt;&lt; std::put_money(-1234) &lt;&lt; '\n';

}
 | output=
de_DE.utf8 negative sign is '-' for example: -12,34 €
ms_MY.utf8 negative sign is '()' for example: (RM12.34)
de_DE.utf8 with negative_sign set to &quot;()&quot;: (12,34 €)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_pos_format}}
{{dsc end}}

[[de:cpp/locale/moneypunct/decimal_point]]
[[es:cpp/locale/moneypunct/decimal_point]]
[[fr:cpp/locale/moneypunct/decimal_point]]
[[it:cpp/locale/moneypunct/decimal_point]]
[[ja:cpp/locale/moneypunct/decimal_point]]
[[pt:cpp/locale/moneypunct/decimal_point]]
[[ru:cpp/locale/moneypunct/decimal_point]]
[[zh:cpp/locale/moneypunct/decimal_point]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/thousands sep</title>
    <ns>0</ns>
    <id>3756</id>
    <revision>
      <id>69677</id>
      <parentid>64067</parentid>
      <timestamp>2014-04-19T11:27:10Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>wording</comment>
      <text xml:space="preserve" bytes="1182">{{cpp/locale/moneypunct/title | thousands_sep, do_thousands_sep}}
{{cpp/locale/moneypunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
char_type thousands_sep() const;
}}
{{dcl | num=2 | 1=
protected:
virtual char_type do_thousands_sep() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_thousands_sep}} of the most derived class.

@2@ Returns the character to be used as the separator between digit groups when parsing or formatting the integral parts of monetary values. 

===Return value===
The object of type {{tt|char_type}} to use as the thousands separator. In common U.S. locales, this is {{c|’,’}} or {{c|L’,’}}.

===Example===
{{cpp/locale/moneypunct/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_grouping}}
{{dsc end}}

[[de:cpp/locale/moneypunct/thousands sep]]
[[es:cpp/locale/moneypunct/thousands sep]]
[[fr:cpp/locale/moneypunct/thousands sep]]
[[it:cpp/locale/moneypunct/thousands sep]]
[[ja:cpp/locale/moneypunct/thousands sep]]
[[pt:cpp/locale/moneypunct/thousands sep]]
[[ru:cpp/locale/moneypunct/thousands sep]]
[[zh:cpp/locale/moneypunct/thousands sep]]</text>
      <sha1>4puegg9k5yrkumecvcs11moeo9xo9ah</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct/~moneypunct</title>
    <ns>0</ns>
    <id>4438</id>
    <revision>
      <id>43306</id>
      <parentid>15810</parentid>
      <timestamp>2012-11-03T02:21:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="371">{{cpp/locale/facet/destructor|moneypunct}}

[[de:cpp/locale/moneypunct/~moneypunct]]
[[es:cpp/locale/moneypunct/~moneypunct]]
[[fr:cpp/locale/moneypunct/~moneypunct]]
[[it:cpp/locale/moneypunct/~moneypunct]]
[[ja:cpp/locale/moneypunct/~moneypunct]]
[[pt:cpp/locale/moneypunct/~moneypunct]]
[[ru:cpp/locale/moneypunct/~moneypunct]]
[[zh:cpp/locale/moneypunct/~moneypunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/moneypunct byname</title>
    <ns>0</ns>
    <id>6346</id>
    <revision>
      <id>61628</id>
      <parentid>61622</parentid>
      <timestamp>2013-06-06T07:30:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+inherited members</comment>
      <text xml:space="preserve" bytes="2537">{{cpp/title | moneypunct_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT, bool Intl = false &gt;
class moneypunct_byname : public std::moneypunct&lt;CharT, Intl&gt;;
}}
{{dcl end}}

{{lc|std::moneypunct_byname}} is a {{lc|std::moneypunct}} facet which encapsulates monetary formatting preferences of a locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::moneypunct_byname&lt;char, Intl&gt;}} | locale-specific {{lc|std::moneypunct}} facet for narrow character I/O }}
{{dsc | {{c|std::moneypunct_byname&lt;wchar_t, Intl&gt;}} | locale-specific {{lc|std::moneypunct}} facet for wide character I/O }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|pattern}} | {{lc|std::money_base::pattern}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | moneypunct_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | moneypunct_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | moneypunct_byname}}
{{include | cpp/locale/byname/destructor | moneypunct_byname}}

{{include | cpp/locale/moneypunct/inherit}}
{{include | cpp/locale/money_base/inherit}}
===Example===

{{example
 | This example demonistrates how to apply monetary formatting rules of another language without changing the rest of the locale. 
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;locale&gt;
int main()
{
    long double mon = 1234567;
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::wcout.imbue(std::locale());
    std::wcout &lt;&lt; L&quot;american locale : &quot; &lt;&lt; std::showbase
               &lt;&lt; std::put_money(mon) &lt;&lt; '\n';
    std::wcout.imbue(std::locale(std::wcout.getloc(),
                                 new std::moneypunct_byname&lt;wchar_t&gt;(&quot;ru_RU.utf8&quot;)));
    std::wcout &lt;&lt; L&quot;american locale with russian moneypunct: &quot;
               &lt;&lt; std::put_money(mon) &lt;&lt; '\n';
}
 | output=
american locale : $12,345.67
american locale with russian moneypunct: 12 345.67 руб
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc moneypunct}}
{{dsc end}}

[[de:cpp/locale/moneypunct byname]]
[[es:cpp/locale/moneypunct byname]]
[[fr:cpp/locale/moneypunct byname]]
[[it:cpp/locale/moneypunct byname]]
[[ja:cpp/locale/moneypunct byname]]
[[pt:cpp/locale/moneypunct byname]]
[[ru:cpp/locale/moneypunct byname]]
[[zh:cpp/locale/moneypunct byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num get</title>
    <ns>0</ns>
    <id>3759</id>
    <revision>
      <id>65769</id>
      <parentid>62442</parentid>
      <timestamp>2013-10-07T18:25:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3950">{{cpp/title|num_get}}
{{cpp/locale/num_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT,
    class InputIt = std::istreambuf_iterator&lt;CharT&gt;
&gt; class num_get;
}}
{{dcl end}}

Class {{tt|std::num_get}} encapsulates the rules for parsing string representations of numeric values. Specifically, types {{c|bool}}, {{c|unsigned short}}, {{c|unsigned int}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, {{c|unsigned long long}}, {{c|float}}, {{c|double}}, {{c|long double}}, and {{c|void*}} are supported. The standard formatting input operators (such as {{c|cin &gt;&gt; n;}}) use the {{tt|std::num_get}} facet of the I/O stream's locale to parse the text representations of the numbers.

{{inheritance diagram/std-num_get}}

===Type requirements===
{{par begin}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Specializations===
Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::num_get&lt;char&gt;}} | creates narrow string parsing of numbers}}
{{dsc | {{c|std::num_get&lt;wchar_t&gt;}} | creates wide string parsing of numbers}}
{{dsc | {{c|std::num_get&lt;char, InputIt&gt;}} | creates narrow string parsing of numbers using custom input iterator}}
{{dsc | {{c|std::num_get&lt;wchar_t, InputIt&gt;}} | creates wide string parsing of numbers using custom input iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|InputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/num_get/num_get | constructs a new num_get facet }}
{{dsc prot mem dtor | cpp/locale/num_get/~num_get | destructs a num_get facet }}
{{dsc mem fun | cpp/locale/num_get/get | invokes {{tt|do_get}} }}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc prot mem vfun | cpp/locale/num_get/get | title=do_get | parses a number from an input stream}}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;string&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;

int main()
{
    std::string de_double = &quot;1.234.567,89&quot;;
    std::string us_double = &quot;1,234,567.89&quot;;

    // parse using streams
    std::istringstream de_in(de_double);
    de_in.imbue(std::locale(&quot;de_DE&quot;));
    double f1;
    de_in &gt;&gt; f1;

    std::istringstream us_in(de_double);
    us_in.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    double f2;
    us_in &gt;&gt; f2;

    std::cout &lt;&lt; &quot;Parsing &quot; &lt;&lt; de_double &lt;&lt; &quot; as double gives &quot; &lt;&lt; std::fixed
              &lt;&lt; f1 &lt;&lt; &quot; in de_DE locale and &quot; &lt;&lt; f2 &lt;&lt; &quot; in en_US\n&quot;;

    // use the facet directly
    std::istringstream s3(us_double);
    s3.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    auto&amp; f = std::use_facet&lt;std::num_get&lt;char&gt;&gt;(s3.getloc());
    std::istreambuf_iterator&lt;char&gt; beg(s3), end;
    double f3;
    std::ios::iostate err;
    f.get(beg, end, s3, err, f3);
    std::cout &lt;&lt; &quot;parsing &quot; &lt;&lt; us_double
              &lt;&lt; &quot; as double using raw en_US facet gives &quot; &lt;&lt; f3 &lt;&lt; '\n';
}
 | output=
Parsing 1.234.567,89 as double gives 1234567.890000 in de_DE locale and 1.234000 in en_US
parsing 1,234,567.89 as double using raw en_US facet gives 1234567.890000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc numpunct}}
{{dsc inc | cpp/locale/dsc num_put}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc end}}

[[de:cpp/locale/num get]]
[[es:cpp/locale/num get]]
[[fr:cpp/locale/num get]]
[[it:cpp/locale/num get]]
[[ja:cpp/locale/num get]]
[[pt:cpp/locale/num get]]
[[ru:cpp/locale/num get]]
[[zh:cpp/locale/num get]]</text>
      <sha1>lm7odiu6yaq9zegawdyd8gwnj0pgjkn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num get/do get</title>
    <ns>0</ns>
    <id>9463</id>
    <redirect title="cpp/locale/num get/get" />
    <revision>
      <id>40307</id>
      <timestamp>2012-10-12T18:48:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/num get/do get]] to [[cpp/locale/num get/get]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/locale/num get/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num get/get</title>
    <ns>0</ns>
    <id>4048</id>
    <revision>
      <id>65739</id>
      <parentid>65738</parentid>
      <timestamp>2013-10-03T15:51:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 65737 by [[Special:Contributions/SuperBoi45|SuperBoi45]] ([[User talk:SuperBoi45|talk]]) doing this is error for input and redundant for output</comment>
      <text xml:space="preserve" bytes="10975">{{cpp/num_get/title|get|do_get}}
{{cpp/locale/num_get/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl |
public:
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, bool&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, long&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, long long&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, unsigned short&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, unsigned int&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, unsigned long&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, unsigned long long&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, float&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, double&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, long double&amp; v ) const;
}}
{{dcl |
iter_type get( iter_type in, iter_type end, std::ios_base&amp; str, 
               std::ios_base::iostate&amp; err, void*&amp; v ) const;
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl |
protected:
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, bool&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, long&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, long long&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, unsigned short&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, unsigned int&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, unsigned long&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, unsigned long long&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, float&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, double&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, long double&amp; v ) const;
}}
{{dcl |
iter_type do_get( iter_type in, iter_type end, std::ios_base&amp; str, 
                  std::ios_base::iostate&amp; err, void*&amp; v ) const;
}}
{{dcl rev end}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_get}} of the most derived class.

@2@ Reads characters from the input iterator {{tt|in}} and generates the value of the type of {{tt|v}}, taking into account IO stream formatting flags from {{tt|str.flags()}}, character classification rules from {{c|std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(str.getloc())}}, and numeric punctuation characters from {{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc())}}. This function is called by all formatted input stream operators such as {{c|std::cin &gt;&gt; n;}}.

Conversion occurs in three stages

====Stage 1: conversion specifier selection==== 

* I/O format flags are obtained, as if by
: {{c|1=fmtflags basefield = (str.flags() &amp; std::ios_base::basefield);}}
: {{c|1=fmtflags boolalpha = (str.flags() &amp; std::ios_base::boolalpha);}}
* If the type of {{tt|v}} is an integer type, the the first applicable choice of the following five is selected:
: If {{c|1=basefield == oct}}, will use conversion specifier {{c|%o}}
: If {{c|1=basefield == hex}}, will use conversion specifier {{c|%X}}
: If {{c|1=basefield == 0}}, will use conversion specifier {{c|%i}}
: If the type of {{tt|v}} is signed, will use conversion specifier {{c|%d}}
: If the type of {{tt|v}} is unsigned, will use conversion specifier {{c|%u}}
* For integer types, length modifier is added to the conversion specification if necessary: {{c|h}} for {{c|short}} and {{c|unsigned short}}, {{c|l}} for {{c|long}} and {{c|unsigned long}}, {{c|ll}} for {{c|long long}} and {{c|unsigned long long}}
* If the type of {{tt|v}} is {{c|float}}, will use conversion specifier {{c|%g}}
* If the type of {{tt|v}} is {{c|double}}, will use conversion specifier {{c|%lg}}
* If the type of {{tt|v}} is {{c|long double}}, will use conversion specifier {{c|%Lg}}
* If the type of {{tt|v}} is {{c|void*}}, will use conversion specifier {{c|%p}}
* If the type of {{tt|v}} is {{c|bool}} and {{c|1=boolalpha==0}}, proceeds as if the type of {{tt|v}} is {{c|long}}, except for the value to be stored in {{tt|v}} in stage 3.
* If the type of {{tt|v}} is {{c|bool}} and {{c|1=boolalpha!=0}}, the following replaces stages 2 and 3:
** Successive characters obtained from the input iterator {{tt|in}} are matched against the character sequences obtained from {{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).falsename()}} and {{c|std::use_facet&lt;std::numpunct&lt;charT&gt; &gt;(str.getloc()).truename()}} only as necessary as to identify the unique match. The input iterator {{tt|in}} is compared to {{tt|end}} only when necessary to obtain a character.
** If the target sequence is uniquely matched, {{tt|v}} is set to the corresponding {{c|bool}} value. Otherwise {{c|false}} is stored in {{tt|v}} and {{lc|std::ios_base::failbit}} is assigned to {{tt|err}}. If unique match could not be found before the input ended ({{c|1=in==end}}), {{c|1=err{{!}}=std::ios_base::eofbit}} is executed.
====Stage 2: character extraction==== 
* If {{c|1=in==end}}, Stage 2 is terminated immediately, no further characters are extracted
* The next character is extracted from {{c|in}} as if by {{c|1=char_type ct = *in;}}
** If the character matches one of {{c|&quot;0123456789abcdefxABCDEFX+-&quot;}}, widened to the locale's char_type as if by {{c|std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(str.getloc()).widen()}}, it is converted to the corresponding {{c|char}}.
** If the character matches the decimal point separator ({{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).decimal_point())}}), it is replaced by {{c|'.'}}.
** If the character matches the thousands separator ({{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).thousands_sep()}}) and the thousands separation is in use at all {{c|1=std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).grouping().length() != 0}}, then if the decimal point {{c|'.'}} has not yet been accumulated, the position of the character is rememebered, but the character is otherwise ignored. If the decimal point has already been accumulated, the character is discarded and Stage 2 terminates.
** In any case, the check is made whether the {{c|char}} obtained from the previous steps is allowed in the input field that would be parsed by {{lc|std::scanf}} given the conversion specifier selected in Stage 1. If it is allowed, it is accumulated in a temporary buffer and Stage 2 repeats. If it is not allowed, Stage 2 terminates.
====Stage 3: conversion and storage====
* The sequence of {{c|char}}s accumulated in Stage 2 is converted to a numeric value
{{rev begin}}
{{rev | until=c++11 | 
:The input is parsed as if by {{lc|std::scanf}} with the conversion specifier selected in Stage 1 
}}
{{rev | since=c++11 | 
:The input is parsed as if by {{lc|std::strtoll}} for signed integer {{tt|v}}, {{lc|std::strtoull}} for unsigned integer {{tt|v}}, or {{lc|std::strtold}} for floating-point {{tt|v}}
}}
{{rev end}}
{{rev begin}}
{{rev | since=c++11 |
* If the conversion function fails to convert the entire field, the value {{c|0}} is stored in {{tt|v}}
* If the conversion function results in a positive value too large to fit in the type of {{tt|v}}, the most positive representable value is stored in {{tt|v}}
* If the conversion function results in a negative value too large to fit in the type of {{tt|v}}, the most negative representable value is stored in {{tt|v}}
}}
{{rev end}}
* In any case, if the conversion function fails {{lc|std::ios_base::failbit}} is assigned to {{tt|err}}
* Otherwise, the numeric result of the conversion is stored in {{tt|v}}
** If the type of {{tt|v}} is {{c|bool}} and boolalpha is not set, then if the value to be stored is {{c|0}}, {{c|false}} is stored, if the value to be stored is {{c|1}}, {{c|true}} is stored, for any other value {{lc|std::ios_base::failbit}} is assigned to {{tt|err}} and {{c|true}} is stored.
* After this, digit grouping is checked. if the position of any of the thousands separators discarded in Stage 2 does not match the grouping provided by {{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).grouping()}}, {{lc|std::ios_base::failbit}} is assigned to {{tt|err}}.
* If Stage 2 was terminated by the test {{c|1=in==end}}, {{c|1=err{{!}}=std::ios_base::eofbit}} is executed to set the eof bit.

===Return value===
{{tt|in}}

===Notes===
In C++98/C++03, if an error occurs, {{tt|v}} is left unchanged. In C++11, it is set to a value as described above.

===Example===

{{example
 | 
An implementation of {{lc|operator&gt;&gt;}} for a user-defined type.
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;locale&gt;
 
struct base { long x; };
 
template &lt;class CharT, class Traits&gt;
std::basic_istream&lt;CharT, Traits&gt;&amp;
    operator &gt;&gt;(std::basic_istream&lt;CharT, Traits&gt;&amp; is,
                base&amp; b)
{
    std::ios_base::iostate err = std::ios_base::goodbit;
    try // setting err could throw
    {
        typename std::basic_istream&lt;CharT, Traits&gt;::sentry s(is);
 
        if (s) // if stream is ready for input
        {
            std::istreambuf_iterator&lt;CharT, Traits&gt; end;
            std::use_facet&lt;std::num_get&lt;CharT&gt;&gt;(is.getloc()).get(is, end, is, err, b.x);
        }
    } catch(std::ios_base::failure&amp; error)
    {
        // handle the exception
    }
    return is;
}

int main()
{
    base b;
 
    std::cin &gt;&gt; b;
}

| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}
{{dsc end}}

[[de:cpp/locale/num get/get]]
[[es:cpp/locale/num get/get]]
[[fr:cpp/locale/num get/get]]
[[it:cpp/locale/num get/get]]
[[ja:cpp/locale/num get/get]]
[[pt:cpp/locale/num get/get]]
[[ru:cpp/locale/num get/get]]
[[zh:cpp/locale/num get/get]]</text>
      <sha1>lkhsq9ias4ds3ge64sutioza36ntk7b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num get/num get</title>
    <ns>0</ns>
    <id>4415</id>
    <revision>
      <id>43270</id>
      <parentid>15782</parentid>
      <timestamp>2012-11-03T02:14:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="313">{{cpp/locale/facet/constructor|num_get}}

[[de:cpp/locale/num get/num get]]
[[es:cpp/locale/num get/num get]]
[[fr:cpp/locale/num get/num get]]
[[it:cpp/locale/num get/num get]]
[[ja:cpp/locale/num get/num get]]
[[pt:cpp/locale/num get/num get]]
[[ru:cpp/locale/num get/num get]]
[[zh:cpp/locale/num get/num get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num get/~num get</title>
    <ns>0</ns>
    <id>4444</id>
    <revision>
      <id>43263</id>
      <parentid>15817</parentid>
      <timestamp>2012-11-03T02:13:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="320">{{cpp/locale/facet/destructor|num_get}}

[[de:cpp/locale/num get/~num get]]
[[es:cpp/locale/num get/~num get]]
[[fr:cpp/locale/num get/~num get]]
[[it:cpp/locale/num get/~num get]]
[[ja:cpp/locale/num get/~num get]]
[[pt:cpp/locale/num get/~num get]]
[[ru:cpp/locale/num get/~num get]]
[[zh:cpp/locale/num get/~num get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num put</title>
    <ns>0</ns>
    <id>3745</id>
    <revision>
      <id>65770</id>
      <parentid>62321</parentid>
      <timestamp>2013-10-07T18:26:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3666">{{cpp/title|num_put}}
{{cpp/locale/num_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT,
    class OutputIt = std::ostreambuf_iterator&lt;CharT&gt;
&gt; class num_put;
}}
{{dcl end}}

Class {{tt|std::num_put}} encapsulates the rules for formatting numeric values as strings. Specifically, the types {{c|bool}}, {{c|long}}, {{c|unsigned long}}, {{c|long long}}, {{c|unsigned long long}}, {{c|double}}, {{c|long double}}, {{c|void*}}, and of all types implicitly convertible to these (such as {{c|int}} or {{c|float}}) are supported. The standard formatting output operators (such as {{c|cout &lt;&lt; n;}}) use the {{tt|std::num_put}} facet of the I/O stream's locale to generate text representation of numbers.

{{inheritance diagram/std-num_put}}

===Type requirements===
{{par begin}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Specializations===
Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::num_put&lt;char&gt;}} | creates narrow string representations of numbers}}
{{dsc | {{c|std::num_put&lt;wchar_t&gt;}} | creates wide string representations of numbers}}
{{dsc | {{c|std::num_put&lt;char, OutputIt&gt;}} | creates narrow string representations of numbers using custom output iterator}}
{{dsc | {{c|std::num_put&lt;wchar_t, OutputIt&gt;}} | creates wide string representations of numbers using custom output iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|OutputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/num_put/num_put | constructs a new num_put facet }}
{{dsc prot mem dtor | cpp/locale/num_put/~num_put | destructs a num_put facet }}
{{dsc mem fun | cpp/locale/num_put/put | invokes {{tt|do_put}} }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc prot mem vfun | cpp/locale/num_put/put | title=do_put | formats a number and writes to output stream}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;string&gt;
#include &lt;iterator&gt;

int main()
{
    double n = 1234567.89;
    std::cout.imbue(std::locale(&quot;de_DE&quot;));
    std::cout &lt;&lt; &quot;Direct conversion to string:\n&quot;
              &lt;&lt; std::to_string(n) &lt;&lt; '\n'
              &lt;&lt; &quot;Output using a german locale:\n&quot;
              &lt;&lt; std::fixed &lt;&lt; n &lt;&lt; '\n'
              &lt;&lt; &quot;Output using an american locale:\n&quot;;
    // use the facet directly
    std::cout.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    auto&amp; f = std::use_facet&lt;std::num_put&lt;char&gt;&gt;(std::cout.getloc());
    f.put(std::ostreambuf_iterator&lt;char&gt;(std::cout), std::cout, ' ', n);
    std::cout &lt;&lt; '\n';
}
 | output=
Direct conversion to string:
1234567.890000
Output using a german locale:
1.234.567,890000
Output using an american locale:
1,234,567.890000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc numpunct}}
{{dsc inc | cpp/locale/dsc num_get}}
{{dsc inc | cpp/string/basic_string/dsc to_string}}
{{dsc inc | cpp/string/basic_string/dsc to_wstring}}
{{dsc end}}

[[de:cpp/locale/num put]]
[[es:cpp/locale/num put]]
[[fr:cpp/locale/num put]]
[[it:cpp/locale/num put]]
[[ja:cpp/locale/num put]]
[[pt:cpp/locale/num put]]
[[ru:cpp/locale/num put]]
[[zh:cpp/locale/num put]]</text>
      <sha1>rxfnle2o4tllf9idzieb3b2jkibeal4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num put/do put</title>
    <ns>0</ns>
    <id>9464</id>
    <redirect title="cpp/locale/num put/put" />
    <revision>
      <id>40312</id>
      <timestamp>2012-10-12T18:52:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/num put/do put]] to [[cpp/locale/num put/put]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/locale/num put/put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num put/num put</title>
    <ns>0</ns>
    <id>4422</id>
    <revision>
      <id>43249</id>
      <parentid>15790</parentid>
      <timestamp>2012-11-03T02:10:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="313">{{cpp/locale/facet/constructor|num_put}}

[[de:cpp/locale/num put/num put]]
[[es:cpp/locale/num put/num put]]
[[fr:cpp/locale/num put/num put]]
[[it:cpp/locale/num put/num put]]
[[ja:cpp/locale/num put/num put]]
[[pt:cpp/locale/num put/num put]]
[[ru:cpp/locale/num put/num put]]
[[zh:cpp/locale/num put/num put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num put/put</title>
    <ns>0</ns>
    <id>4254</id>
    <revision>
      <id>66414</id>
      <parentid>65741</parentid>
      <timestamp>2013-11-20T21:52:03Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="9899">{{cpp/locale/num_put/title|put|do_put}}
{{cpp/locale/num_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl rev begin | num=1}}
{{dcl |
public:
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, bool v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, long v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, long long v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, unsigned long v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, unsigned long long v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, double v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, long double v ) const;
}}
{{dcl |
iter_type put( iter_type out, std::ios_base&amp; str, char_type fill, const void* v ) const;
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl |
protected:
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, bool v ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, long v ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, long long v ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, unsigned long ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, unsigned long long ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, double v ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, long double v ) const;
}}
{{dcl |
iter_type do_put( iter_type out, std::ios_base&amp; str, char_type fill, const void* v ) const;
}}
{{dcl rev end}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_put}} of the most derived class.

@2@ Writes characters to the output sequence {{tt|out}} which represent the value of {{tt|v}}, formatted as requested by the formatting flags {{c|str.flags()}} and the {{lc|std::numpunct}} and {{lc|std::ctype}} facets of the locale imbued in the stream {{tt|str}}. This function is called by all formatted output stream operators, such as {{c|std::cout &lt;&lt; n;}}.

Conversion occurs in four stages

====Stage 1: conversion specifier selection==== 

* I/O format flags are obtained, as if by
: {{c|1=fmtflags basefield = (str.flags() &amp; std::ios_base::basefield);}}
: {{c|1=fmtflags uppercase = (str.flags() &amp; std::ios_base::uppercase);}}
: {{c|1=fmtflags floatfield = (str.flags() &amp; std::ios_base::floatfield);}}
: {{c|1=fmtflags showpos = (str.flags() &amp; std::ios_base::showpos);}}
: {{c|1=fmtflags showbase = (str.flags() &amp; std::ios_base::showbase);}}
* If the type of {{tt|v}} is {{c|bool}}
** If {{c|1=boolalpha == 0}}, then converts {{tt|v}} to type {{c|int}} and performs integer output.
** If {{c|1=boolalpha != 0}} obtains {{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).truename()}} if {{c|1=v == true}} or {{c|std::use_facet&lt;std::numpunct&lt;charT&gt;&gt;(str.getloc()).falsename()}} if {{c|1=v == false}}, and outputs each successive character {{tt|c}} of that string to {{tt|out}} with {{c|1=*out++ = c}}. No further processing is done in this case, the function returns {{tt|out}}.
* If the type of {{tt|v}} is an integer type, the the first applicable choice of the following five is selected:
: If {{c|1=basefield == oct}}, will use conversion specifier {{c|%o}}
: If {{c|1=basefield == hex &amp;&amp; !uppercase}}, will use conversion specifier {{c|%x}}
: If {{c|1=basefield == hex}}, will use conversion specifier {{c|%X}}
: If the type of {{tt|v}} is signed, will use conversion specifier {{c|%d}}
: If the type of {{tt|v}} is unsigned, will use conversion specifier {{c|%u}}
* For integer types, length modifier is added to the conversion specification if necessary: {{c|l}} for {{c|long}} and {{c|unsigned long}}, {{c|ll}} for {{c|long long}} and {{c|unsigned long long}}.
* If the type of {{tt|v}} is a floating-point type, the the first applicable choice of the following five is selected:
: If {{c|1=floatfield == std::ios_base::fixed}}, will use conversion specifier {{c|%f}}
: If {{c|1=floatfield == std::ios_base::scientific &amp;&amp; !uppercase}}, will use conversion specifier {{c|%e}}
: If {{c|1=floatfield == std::ios_base::scientific}}, will use conversion specifier {{c|%E}}
: If {{c|1=floatfield == (std::ios_base::fixed {{!}} std::ios_base::scientific) &amp;&amp; !uppercase}}, will use conversion specifier {{c|%a}}  {{mark since c++11}}
: If {{c|1=floatfield == std::ios_base::fixed {{!}} std::ios_base::scientific}}, will use conversion specifier {{c|%A}} {{mark since c++11}}
: If {{c|1=!uppercase}}, will use conversion specifier {{c|%g}}
: otherwise, will use conversion specifier {{c|%G}}
** If the type of {{tt|v}} is {{c|long double}}, the length modifier {{c|L}} is added to the conversion specifier.
** Additionally, if {{c|1=floatfield != (ios_base::fixed {{!}} ios_base::scientific)}}, then precision modifier is added, set to {{c|str.precision()}}
* For both integer and floating-point types, if {{c|showbase}} is set, the modifier {{c|#}} is prepended. If {{c|showpos}} is set, the modifier {{c|+}} is prepended.
* If the type of {{tt|v}} is {{c|void*}}, will use conversion specifier {{c|%p}}
* A narrow character string is created as if by a call to {{c|std::printf(spec, v)}} in the &quot;C&quot; locale, where {{tt|spec}} is the chosen conversion specifier.
====Stage 2: locale-specific conversion==== 
* Every character {{tt|c}} obtained in Stage 1, other than the decimal point {{c|'.'}}, is converted to {{tt|CharT}} by calling {{c|std::use_facet&lt;std::ctype&lt;CharT&gt;&gt;(str.getloc()).widen(c)}}.
* For arithmetic types, the thousands separator character, obtained from {{c|std::use_facet&lt;std::numpunct&lt;CharT&gt;&gt;(str.getloc()).thousands_sep()}}, is inserted into the sequence according to the grouping rules provided by {{c|std::use_facet&lt;std::numpunct&lt;CharT&gt;&gt;(str.getloc()).grouping()}}
* Decimal point characters ({{c|'.'}}) are replaced by {{c|std::use_facet&lt;std::numpunct&lt;CharT&gt;&gt;(str.getloc()).decimal_point()}}
====Stage 3: padding====
* The adjustment flag is obtained as if by {{c|1=std::fmtflags adjustfield = (flags &amp; (std::ios_base::adjustfield))}} and examined to identify padding location, as follows
: If {{c|1=adjustfield == std::ios_base::left}}, will pad after
: If {{c|1=adjustfield == std::ios_base::right}}, will pad before
: If {{c|1=adjustfield == std::ios_base::internal}} and a sign character occurs in the representation, will pad after the sign
: If {{c|1=adjustfield == std::ios_base::internal}} and Stage 1 representation began with 0x or 0X, will pad after the x or X
: otherwise, will pad before
* If {{c|str.width()}} is non-zero (e.g. {{lc|std::setw}} was just used) and the number of CharT's after Stage 2 is less than {{c|str.width()}}, then copies of the {{c|fill}} character are inserted at the position indicated by padding to bring the length of the sequence to {{c|str.width()}}.
In any case, {{c|str.width(0)}} is called to cancel the effects of {{lc|std::setw}}.

====Stage 4: output====
Every successive character {{tt|c}} from the sequence of CharT's from Stage 3 is output as if by {{c|1=*out++ = c}}.

===Parameters===
{{par begin}}
{{par | out | iterator pointing to the first character to be overwritten}}
{{par | str | stream to retrieve the formatting information from}}
{{par | fill | padding character used when the results needs to be padded to the field width}}
{{par | v | value to convert to string and output}}
{{par end}}

===Return value===
{{tt|out}}

===Notes===
The leading zero generated by the conversion specification {{c|#o}} (resulting from the combination of {{lc|std::showbase}} and {{lc|std::oct}} for example) is not counted as a padding character.

===Example===
{{example
 | Output a number using the facet directly, and demonstrate user-defined facet
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

// this custom num_put outputs squares of all integers (except long long)
struct squaring_num_put : std::num_put&lt;char&gt; {
    iter_type do_put(iter_type s, std::ios_base&amp; f,
                     char_type fill, long v) const
    {
        return std::num_put&lt;char&gt;::do_put(s, f, fill, v*v );
    }

    iter_type do_put(iter_type s, std::ios_base&amp; f,
                     char_type fill, unsigned long v) const
    {
        return std::num_put&lt;char&gt;::do_put(s, f, fill, v*v);
    }
};

int main()
{
    auto&amp; facet = std::use_facet&lt;std::num_put&lt;char&gt;&gt;(std::locale());
    facet.put(std::cout, std::cout, '0', 2.71);
    std::cout &lt;&lt; '\n';

    std::cout.imbue(std::locale(std::cout.getloc(), new squaring_num_put));
    std::cout &lt;&lt; 6 &lt;&lt; ' ' &lt;&lt; -12 &lt;&lt; '\n';
} 
 | output=
2.71
36 144
}}

 {{example |
An implementation of {{lc|operator&lt;&lt;}} for a user-defined type.
 |code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;locale&gt;

struct base { long x = 10; };

template &lt;class CharT, class Traits&gt;
std::basic_ostream&lt;CharT, Traits&gt;&amp;
    operator&lt;&lt; (std::basic_ostream&lt;CharT, Traits&gt;&amp; os, base const&amp; b)
{
    try {
        typename std::basic_ostream&lt;CharT, Traits&gt;::sentry s(os);
        if (s)
        {
            std::ostreambuf_iterator&lt;CharT, Traits&gt; it(os);
            std::use_facet&lt;std::num_put&lt;CharT&gt;&gt;(os.getloc())
                .put(it, os, os.fill(), b.x);
        }
    } catch (...) {
        // set badbit on os and rethrow if required
    }
    return os;
}

int main()
{
    base b;
    
    std::cout &lt;&lt; b;
}
 |output=
10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}
{{dsc end}}

[[de:cpp/locale/num put/put]]
[[es:cpp/locale/num put/put]]
[[fr:cpp/locale/num put/put]]
[[it:cpp/locale/num put/put]]
[[ja:cpp/locale/num put/put]]
[[pt:cpp/locale/num put/put]]
[[ru:cpp/locale/num put/put]]
[[zh:cpp/locale/num put/put]]</text>
      <sha1>od686tlsi5odr4hgxi3ab1ujz7y2g0n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/num put/~num put</title>
    <ns>0</ns>
    <id>4442</id>
    <revision>
      <id>43232</id>
      <parentid>15815</parentid>
      <timestamp>2012-11-03T02:06:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="320">{{cpp/locale/facet/destructor|num_put}}

[[de:cpp/locale/num put/~num put]]
[[es:cpp/locale/num put/~num put]]
[[fr:cpp/locale/num put/~num put]]
[[it:cpp/locale/num put/~num put]]
[[ja:cpp/locale/num put/~num put]]
[[pt:cpp/locale/num put/~num put]]
[[ru:cpp/locale/num put/~num put]]
[[zh:cpp/locale/num put/~num put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct</title>
    <ns>0</ns>
    <id>2784</id>
    <revision>
      <id>65771</id>
      <parentid>64374</parentid>
      <timestamp>2013-10-07T18:30:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3890">{{cpp/title | numpunct}}
{{cpp/locale/numpunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class numpunct;
}}
{{dcl end}}

The facet {{lc|std::numpunct}} encapsulates numeric punctuation preferences. Stream I/O operations use {{lc|std::numpunct}} through {{lc|std::num_get}} and {{lc|std::num_put}} for parsing numeric input and formatting numeric output. 

The numbers that are supported by {{lc|std::numpunct}} have the format described below. Here {{tt|digit}} represents the radix set specified by the {{tt|fmtflags}} argument value, {{tt|thousands-sep}} and {{tt|decimal-point}} are the results of {{lc|thousands_sep()}} and {{lc|decimal_point()}} functions respectively. The format of integer values is as follows:

{{source|lang=text|1=
integer     ::= [sign] units
sign        ::= plusminus
plusminus   ::= '+' {{!}} '-'
units       ::= digits [thousands-sep units]
digits      ::= digit [digits]
}}

The number of digits between the {{tt|thousand-sep}}s (maximum size of {{tt|digits}}) is specified by the result of {{lc|grouping()}}.

The format of floating-point values is as follows:
{{source|lang=text|1=
floatval    ::= [sign] units [decimal-point [digits]] [e [sign] digits] {{!}}
                [sign]        decimal-point  digits   [e [sign] digits]
e           ::= ’e’ {{!}} ’E’
}}

{{inheritance diagram/std-numpunct}}

Two standalone (locale-independent) specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::numpunct&lt;char&gt;}} | provides equivalents of the &quot;C&quot; locale preferences }}
{{dsc | {{c|std::numpunct&lt;wchar_t&gt;}} | provides wide character equivalents of the &quot;C&quot; locale preferences }}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|charT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;charT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc numpunct}}
{{dsc inc | cpp/locale/numpunct/dsc ~numpunct}}
{{dsc h2 |  }}
{{dsc inc | cpp/locale/numpunct/dsc decimal_point}}
{{dsc inc | cpp/locale/numpunct/dsc thousands_sep}}
{{dsc inc | cpp/locale/numpunct/dsc grouping}}
{{dsc inc | cpp/locale/numpunct/dsc truefalsename}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc do_decimal_point}}
{{dsc inc | cpp/locale/numpunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/numpunct/dsc do_grouping}}
{{dsc inc | cpp/locale/numpunct/dsc do_truefalsename}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Example===

{{example
 | The following example changes the string representations of {{c|true}} and {{c|false}}
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

struct french_bool : std::numpunct&lt;char&gt; {
    string_type do_truename() const { return &quot;oui&quot;; }
    string_type do_falsename() const { return &quot;non&quot;; }
};

int main()
{
    std::cout &lt;&lt; &quot;default locale: &quot;
              &lt;&lt; std::boolalpha &lt;&lt; true &lt;&lt; &quot;, &quot; &lt;&lt; false &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new french_bool));
    std::cout &lt;&lt; &quot;locale with modified numpunct: &quot;
              &lt;&lt; std::boolalpha &lt;&lt; true &lt;&lt; &quot;, &quot; &lt;&lt; false &lt;&lt; '\n';
}
 | output=
default locale: true, false
locale with modified numpunct: oui, non
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/locale/numpunct_byname | creates a numpunct facet for the named locale }}
{{dsc end}}

[[de:cpp/locale/numpunct]]
[[es:cpp/locale/numpunct]]
[[fr:cpp/locale/numpunct]]
[[it:cpp/locale/numpunct]]
[[ja:cpp/locale/numpunct]]
[[pt:cpp/locale/numpunct]]
[[ru:cpp/locale/numpunct]]
[[zh:cpp/locale/numpunct]]</text>
      <sha1>586xuzzledd8xyw3gtjyx993wsb574o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/decimal point</title>
    <ns>0</ns>
    <id>9922</id>
    <revision>
      <id>62397</id>
      <parentid>50056</parentid>
      <timestamp>2013-06-27T01:36:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1193">{{cpp/locale/numpunct/title | decimal_point, do_decimal_point}}
{{cpp/locale/numpunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
char_type decimal_point() const;
}}
{{dcl | num=2 | 1=
protected:
char_type virtual do_decimal_point() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_decimal_point}} of the most derived class.

@2@ Returns the character to be used as the decimal separator between integer and fractional parts. 

===Return value===
The object of type {{tt|char_type}} to use as the thousands separator. The standard specializations of {{tt|std::numpunct}} return {{c|’.’}} and {{c|L’.’}}.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

struct slash : std::numpunct&lt;char&gt; {
    char do_decimal_point()   const { return '/'; }  // separate with slash
};

int main()
{
    std::cout.precision(10);
    std::cout &lt;&lt; &quot;default locale: &quot; &lt;&lt; 1234.5678 &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new slash));
    std::cout &lt;&lt; &quot;locale with modified numpunct: &quot; &lt;&lt; 1234.5678 &lt;&lt; '\n';
}
 | output=
default locale: 1234.5678
locale with modified numpunct: 1234/5678
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/do thousands sep</title>
    <ns>0</ns>
    <id>9466</id>
    <redirect title="cpp/locale/numpunct/thousands sep" />
    <revision>
      <id>40319</id>
      <timestamp>2012-10-12T18:58:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/locale/numpunct/do thousands sep]] to [[cpp/locale/numpunct/thousands sep]]</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/locale/numpunct/thousands sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/falsename</title>
    <ns>0</ns>
    <id>9927</id>
    <redirect title="cpp/locale/numpunct/truefalsename" />
    <revision>
      <id>47034</id>
      <timestamp>2013-04-23T13:30:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/numpunct/truefalsename]]</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/locale/numpunct/truefalsename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/grouping</title>
    <ns>0</ns>
    <id>9920</id>
    <revision>
      <id>63918</id>
      <parentid>62395</parentid>
      <timestamp>2013-08-01T15:38:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="2369">{{cpp/locale/numpunct/title | grouping, do_grouping}}
{{cpp/locale/numpunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
std::string grouping() const;
}}
{{dcl | num=2 | 1=
protected:
virtual std::string do_grouping() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_grouping}} of the most derived class.

@2@ Returns an {{lc|std::string}} holding, in each {{c|char}} element, the number of digits in each group of the numeric output formatted by {{ltt|cpp/locale/num_put/put|num_put::put()}} (and, therefore, {{ltt|cpp/io/basic_ostream/operator_ltlt|basic_ostream::operator&lt;&lt;}})

The groups are stored as binary values: three-digit group is {{c|'\3'}}, and 51-digit group is {{c|'3'}}. The character at index zero of the returned string holds the number of digits in the rightmost group. The character at index 1 holds the number of digits in the second group from the right, etc. The grouping indicated by the last character in the returned string is reused to group all remaining digits in the (left part of) the number.

===Return value===
The object of type {{lc|std::string}} holding the groups. The standard specializations of {{tt|std::numpunct}} return an empty string, indicating no grouping. Typical groupings (e.g. the {{tt|en_US}} locale) return {{c|&quot;\003&quot;}}.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
#include &lt;locale&gt;

struct space_out : std::numpunct&lt;char&gt;
{
    char do_thousands_sep()   const { return ' ';  } // separate with spaces
    std::string do_grouping() const { return &quot;\1&quot;; } // groups of 1 digit
};

struct g123 : std::numpunct&lt;char&gt;
{
    std::string do_grouping() const { return &quot;\1\2\3&quot;; }
};

int main()
{
    std::cout &lt;&lt; &quot;default locale: &quot; &lt;&lt; 12345678 &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new space_out));
    std::cout &lt;&lt; &quot;locale with modified numpunct: &quot; &lt;&lt; 12345678 &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new g123));
    std::cout &lt;&lt; &quot;Locale with \\1\\2\\3 grouping: &quot; &lt;&lt; 
              std::numeric_limits&lt;unsigned long long&gt;::max() &lt;&lt; '\n';
}
 | output=
default locale: 12345678
locale with modified numpunct: 1 2 3 4 5 6 7 8
Locale with \1\2\3 grouping: 18,446,744,073,709,551,61,5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc do_thousands_sep}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/numpunct</title>
    <ns>0</ns>
    <id>4423</id>
    <revision>
      <id>43218</id>
      <parentid>15791</parentid>
      <timestamp>2012-11-03T02:02:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="330">{{cpp/locale/facet/constructor|numpunct}}

[[de:cpp/locale/numpunct/numpunct]]
[[es:cpp/locale/numpunct/numpunct]]
[[fr:cpp/locale/numpunct/numpunct]]
[[it:cpp/locale/numpunct/numpunct]]
[[ja:cpp/locale/numpunct/numpunct]]
[[pt:cpp/locale/numpunct/numpunct]]
[[ru:cpp/locale/numpunct/numpunct]]
[[zh:cpp/locale/numpunct/numpunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/thousands sep</title>
    <ns>0</ns>
    <id>3746</id>
    <revision>
      <id>62396</id>
      <parentid>58194</parentid>
      <timestamp>2013-06-27T01:36:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1727">{{cpp/locale/numpunct/title | thousands_sep, do_thousands_sep}}
{{cpp/locale/numpunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
char_type thousands_sep() const;
}}
{{dcl | num=2 | 1=
protected:
char_type virtual do_thousands_sep() const;
}}
{{dcl end}}

@1@ Public member function, calls the member function {{tt|do_thousands_sep}} of the most derived class.

@2@ Returns the character to be used as the separator between digit groups when parsing or formatting integers and integral parts of floating-point values. 

===Return value===
The object of type {{tt|char_type}} to use as the thousands separator. The standard specializations of {{tt|std::numpunct}} return {{c|’,’}} and {{c|L’,’}}.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

struct space_out : std::numpunct&lt;char&gt; {
    char do_thousands_sep()   const { return ' '; }  // separate with spaces
    std::string do_grouping() const { return &quot;\1&quot;; } // groups of 1 digit
};

int main()
{
    std::cout &lt;&lt; &quot;default locale: &quot; &lt;&lt; 12345678 &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new space_out));
    std::cout &lt;&lt; &quot;locale with modified numpunct: &quot; &lt;&lt; 12345678 &lt;&lt; '\n';
}
 | output=
default locale: 12345678
locale with modified numpunct: 1 2 3 4 5 6 7 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc do_grouping}}
{{dsc end}}

[[de:cpp/locale/numpunct/thousands sep]]
[[es:cpp/locale/numpunct/thousands sep]]
[[fr:cpp/locale/numpunct/thousands sep]]
[[it:cpp/locale/numpunct/thousands sep]]
[[ja:cpp/locale/numpunct/thousands sep]]
[[pt:cpp/locale/numpunct/thousands sep]]
[[ru:cpp/locale/numpunct/thousands sep]]
[[zh:cpp/locale/numpunct/thousands sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/truefalsename</title>
    <ns>0</ns>
    <id>9923</id>
    <revision>
      <id>62394</id>
      <parentid>62071</parentid>
      <timestamp>2013-06-27T01:36:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1683">{{cpp/locale/numpunct/title | truename, do_truename, falsename, do_falsename}}
{{cpp/locale/numpunct/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
string_type truename() const;
}}
{{dcl | num=2 | 1=
public:
string_type falsename() const;
}}
{{dcl | num=3 | 1=
protected:
virtual string_type do_truename() const;
}}
{{dcl | num=4 | 1=
protected:
virtual string_type do_falsename() const;
}}
{{dcl end}}

@1-2@ Public member function, calls the member function {{tt|do_truename}} and {{tt|do_falsename}} of the most derived class respectively.

@3-4@ Returns the string to be used as the representation of the boolean value {{c|true}}.

===Return value===
@1-2@ The object of type {{tt|string_type}} to use as the representation of {{c|true}}. The standard specializations of {{tt|std::numpunct}} return {{c|&quot;true&quot;}} and {{c|L&quot;true&quot;}}.

@3-4@ The object of type {{tt|string_type}} to use as the representation of {{c|false}}. The standard specializations of {{tt|std::numpunct}} return {{c|&quot;false&quot;}} and {{c|L&quot;false&quot;}}.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;

struct custom_tf : std::numpunct&lt;char&gt; {
    std::string do_truename()  const { return &quot;t&quot;; }
    std::string do_falsename() const { return &quot;f&quot;; }
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;default locale: &quot; &lt;&lt; true &lt;&lt; true &lt;&lt; false &lt;&lt; false &lt;&lt; '\n';
    std::cout.imbue(std::locale(std::cout.getloc(), new custom_tf));
    std::cout &lt;&lt; &quot;locale with modified numpunct: &quot; 
              &lt;&lt; true &lt;&lt; true &lt;&lt; false &lt;&lt; false &lt;&lt; '\n';
}
 | output=
default locale: truetruefalsefalse
locale with modified numpunct: ttff
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/truename</title>
    <ns>0</ns>
    <id>9926</id>
    <redirect title="cpp/locale/numpunct/truefalsename" />
    <revision>
      <id>47033</id>
      <timestamp>2013-04-23T13:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/locale/numpunct/truefalsename]]</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/locale/numpunct/truefalsename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct/~numpunct</title>
    <ns>0</ns>
    <id>4441</id>
    <revision>
      <id>43203</id>
      <parentid>15814</parentid>
      <timestamp>2012-11-03T01:59:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/locale/facet/destructor|numpunct}}

[[de:cpp/locale/numpunct/~numpunct]]
[[es:cpp/locale/numpunct/~numpunct]]
[[fr:cpp/locale/numpunct/~numpunct]]
[[it:cpp/locale/numpunct/~numpunct]]
[[ja:cpp/locale/numpunct/~numpunct]]
[[pt:cpp/locale/numpunct/~numpunct]]
[[ru:cpp/locale/numpunct/~numpunct]]
[[zh:cpp/locale/numpunct/~numpunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/numpunct byname</title>
    <ns>0</ns>
    <id>2785</id>
    <revision>
      <id>61629</id>
      <parentid>61621</parentid>
      <timestamp>2013-06-06T07:32:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+inherited members</comment>
      <text xml:space="preserve" bytes="2232">{{cpp/title | numpunct_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT &gt;
class numpunct_byname : public std::numpunct&lt;CharT&gt;;
}}
{{dcl end}}

{{lc|std::numpunct_byname}} is a {{lc|std::numpunct}} facet which encapsulates numeric punctuation preferences of a locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::numpunct_byname&lt;char&gt;}} | locale-specific {{lc|std::numpunct}} facet for narrow character I/O }}
{{dsc | {{c|std::numpunct_byname&lt;wchar_t&gt;}} | locale-specific {{lc|std::numpunct}} facet for wide characters I/O }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | numpunct_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | numpunct_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | numpunct_byname}}
{{include | cpp/locale/byname/destructor | numpunct_byname}}

{{include | cpp/locale/numpunct/inherit}}

===Example===

{{example
 | This example demonistrates how to apply numeric punctuation rules of another language without changing the rest of the locale. 
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
int main()
{
    const double number = 1000.25;
    std::wcout &lt;&lt; L&quot;default locale: &quot; &lt;&lt; number &lt;&lt; L'\n';
    std::wcout.imbue(std::locale(std::wcout.getloc(),
                                 new std::numpunct_byname&lt;wchar_t&gt;(&quot;ru_RU.UTF8&quot;)));
    std::wcout &lt;&lt; L&quot;default locale with russian numpunct: &quot; &lt;&lt; number &lt;&lt; L'\n';
}
 | output=
default locale: 1000.25
default locale with russian numpunct: 1 000,25
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/locale/numpunct | defines numeric punctuation rules }}
{{dsc end}}

[[de:cpp/locale/numpunct byname]]
[[es:cpp/locale/numpunct byname]]
[[fr:cpp/locale/numpunct byname]]
[[it:cpp/locale/numpunct byname]]
[[ja:cpp/locale/numpunct byname]]
[[pt:cpp/locale/numpunct byname]]
[[ru:cpp/locale/numpunct byname]]
[[zh:cpp/locale/numpunct byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/setlocale</title>
    <ns>0</ns>
    <id>4563</id>
    <revision>
      <id>65717</id>
      <parentid>58197</parentid>
      <timestamp>2013-10-01T06:01:09Z</timestamp>
      <contributor>
        <ip>92.76.83.26</ip>
      </contributor>
      <comment>how can an int be null???</comment>
      <text xml:space="preserve" bytes="3348">{{cpp/title|setlocale}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header|clocale}}
{{dcl |
char* setlocale( int category, const char* locale);
}}
{{dcl end}}

The {{tt|setlocale}} function installs the specified system locale or its portion as the new C locale. The modifications remain in effect and influences the execution of all locale-sensitive C library functions until the next call to {{tt|setlocale}}. If {{tt|locale}} is a null pointer, {{tt|setlocale}} queries the current C locale without modifying it.

===Parameters===
{{par begin}}
{{par | category | locale category identifier, one of the {{rlp|LC_categories|LC_xxx}} macros. May be 0.}}
{{par | locale | system-specific locale identifier. Can be {{c|&quot;&quot;}} for the user-preferred locale or {{c|&quot;C&quot;}} for the minimal locale }}
{{par end}}

===Return value===
Pointer to a narrow null-terminated string identifying the C locale after applying the changes, if any, or null pointer on failure.

===Notes===
During program startup, the equivalent of {{c|std::setlocale(LC_ALL, &quot;C&quot;);}} is executed before any user code is run.

Although the return type is {{c|char*}}, modifying the pointed-to characters is undefined behavior.

Because {{tt|setlocale}} modifies global state which affects execution of locale-dependent functions, it is undefined behavior to call it from one thread, while another thread is executing any of the following functions: {{lc|std::fprintf}}, {{lc|std::isprint}}, {{lc|std::iswdigit}}, {{lc|std::localeconv}}, {{lc|std::tolower}}, {{lc|std::fscanf}}, {{lc|std::ispunct}}, {{lc|std::iswgraph}}, {{lc|std::mblen}}, {{lc|std::toupper}}, {{lc|std::isalnum}}, {{lc|std::isspace}}, {{lc|std::iswlower}}, {{lc|std::mbstowcs}}, {{lc|std::towlower}}, {{lc|std::isalpha}}, {{lc|std::isupper}}, {{lc|std::iswprint}}, {{lc|std::mbtowc}}, {{lc|std::towupper}}, {{lc|std::isblank}}, {{lc|std::iswalnum}}, {{lc|std::iswpunct}}, {{lc|std::setlocale}}, {{lc|std::wcscoll}}, {{lc|std::iscntrl}}, {{lc|std::iswalpha}}, {{lc|std::iswspace}}, {{lc|std::strcoll}}, {{lc|std::wcstod}}, {{lc|std::isdigit}}, {{lc|std::iswblank}}, {{lc|std::iswupper}}, {{lc|std::strerror}}, {{lc|std::wcstombs}}, {{lc|std::isgraph}}, {{lc|std::iswcntrl}}, {{lc|std::iswxdigit}}, {{lc|std::strtod}}, {{lc|std::wcsxfrm}}, {{lc|std::islower}}, {{lc|std::iswctype}}, {{lc|std::isxdigit}}.

===Example===
{{example
 | 
 | code=
#include &lt;cstdio&gt;
#include &lt;clocale&gt;
#include &lt;ctime&gt;
#include &lt;cwchar&gt;

int main()
{
    // the C locale will be UTF-8 enabled English;
    // decimal dot will be German
    // date and time formatting will be Japanese
    std::setlocale(LC_ALL, &quot;en_US.UTF-8&quot;);
    std::setlocale(LC_NUMERIC, &quot;de_DE&quot;);
    std::setlocale(LC_TIME, &quot;ja_JP&quot;);

    wchar_t str[100];
    std::time_t t = std::time(NULL);
    std::wcsftime(str, 100, L&quot;%A %c&quot;, std::localtime(&amp;t));
    std::wprintf(L&quot;Number: %.2f\nDate: %Ls\n&quot;, 3.14, str);
}
 | output=
Number: 3,14
Date: 月曜日 2011年12月19日 18時04分40秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc LC_categories}}
{{dsc inc | cpp/locale/dsc locale}}
{{dsc see c | c/locale/setlocale}}
{{dsc end}}

[[de:cpp/locale/setlocale]]
[[es:cpp/locale/setlocale]]
[[fr:cpp/locale/setlocale]]
[[it:cpp/locale/setlocale]]
[[ja:cpp/locale/setlocale]]
[[pt:cpp/locale/setlocale]]
[[ru:cpp/locale/setlocale]]
[[zh:cpp/locale/setlocale]]</text>
      <sha1>0j2t4msjw3bcul2u83i3apa36jlgr14</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time base</title>
    <ns>0</ns>
    <id>3569</id>
    <revision>
      <id>58198</id>
      <parentid>50062</parentid>
      <timestamp>2013-06-01T06:10:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1117">{{cpp/title | time_base}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
class time_base;
}}
{{dcl end}}

The class {{lc|std::time_base}} provides the date order constants which are inherited by the {{lc|std::time_get}} facets.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|enum dateorder { no_order, dmy, mdy, ymd, ydm };}} | Unscoped enumeration type}}
{{dsc end}}

{{dsc begin}}
{{dsc hitem | Enumeration constant | Definition}}
{{dsc | {{tt|no_order}} | Unspecified order}}
{{dsc | {{tt|dmy}} | Day, month, year (european) order}}
{{dsc | {{tt|mdy}} | Month, day, year (american) order}}
{{dsc | {{tt|ymd}} | Year, month, day}}
{{dsc | {{tt|ydm}} | Year, day, month}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/time_get/dsc do_date_order}}
{{dsc inc | cpp/locale/time_get/dsc do_get_date}}
{{dsc end}}

[[de:cpp/locale/time base]]
[[es:cpp/locale/time base]]
[[fr:cpp/locale/time base]]
[[it:cpp/locale/time base]]
[[ja:cpp/locale/time base]]
[[pt:cpp/locale/time base]]
[[ru:cpp/locale/time base]]
[[zh:cpp/locale/time base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get</title>
    <ns>0</ns>
    <id>3567</id>
    <revision>
      <id>65767</id>
      <parentid>58201</parentid>
      <timestamp>2013-10-07T18:22:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="3843">{{cpp/title | time_get}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT, 
    class InputIt = std::istreambuf_iterator&lt;CharT&gt; 
&gt; class time_get;
}}
{{dcl end}}

Class template {{tt|std::time_get}} encapsulates date and time parsing rules. The I/O manipulator {{lc|std::get_time}} uses the {{tt|std::time_get}} facet of the I/O stream's locale to convert text input to a {{lc|std::tm}} object.

{{inheritance diagram/std-time_get}}

===Type requirements===
{{par begin}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Specializations===

Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::time_get&lt;char&gt;}} | parses narrow string representations of date and time }}
{{dsc | {{c|std::time_get&lt;wchar_t&gt;}} | parses wide string representations of date and time }}
{{dsc | {{c|std::time_get&lt;char, InputIt&gt;}} | parses narrow string representations of date and time using custom input iterator}}
{{dsc | {{c|std::time_get&lt;wchar_t, InputIt&gt;}} | parses wide string representations of date and time using custom input iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|InputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/locale/time_get/time_get | constructs a new time_get facet }}
{{dsc prot mem dtor | cpp/locale/time_get/~time_get | destructs a time_get facet }}
{{dsc inc | cpp/locale/time_get/dsc date_order}}
{{dsc inc | cpp/locale/time_get/dsc get_time}}
{{dsc inc | cpp/locale/time_get/dsc get_date}}
{{dsc inc | cpp/locale/time_get/dsc get_weekday}}
{{dsc inc | cpp/locale/time_get/dsc get_monthname}}
{{dsc inc | cpp/locale/time_get/dsc get_year}}
{{dsc inc | cpp/locale/time_get/dsc get}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_get/dsc do_date_order}}
{{dsc inc | cpp/locale/time_get/dsc do_get_time}}
{{dsc inc | cpp/locale/time_get/dsc do_get_date}}
{{dsc inc | cpp/locale/time_get/dsc do_get_weekday}}
{{dsc inc | cpp/locale/time_get/dsc do_get_monthname}}
{{dsc inc | cpp/locale/time_get/dsc do_get_year}}
{{dsc inc | cpp/locale/time_get/dsc do_get}}
{{dsc end}}

{{ inherited | {{small|std::}}time_base |
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|dateorder}} | date order enumeration type, defining the values {{tt|no_order}}, {{tt|dmy}}, {{tt|mdy}}, {{tt|ymd}}, and {{tt|ydm}}}}
{{dsc end}}
}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;ctime&gt;
#include &lt;iomanip&gt;
int main()
{
    std::wstring input = L&quot;2011-Februar-18 23:12:34&quot;;
    std::tm t;
    std::wistringstream ss(input);
    ss.imbue(std::locale(&quot;de_DE&quot;));
    ss &gt;&gt; std::get_time(&amp;t, L&quot;%Y-%b-%d %H:%M:%S&quot;); // uses std::time_get&lt;wchar_t&gt;
    std::cout &lt;&lt; std::asctime(&amp;t);
}
 | output=
Sun Feb 18 23:12:34 2011
}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/locale/time_put | formats contents of {{c|struct std::tm}} for output as character sequence}}
{{dsc tfun | cpp/io/manip/get_time | parses a date/time value of specified format| notes={{mark c++11}}}}
{{dsc end}}

[[de:cpp/locale/time get]]
[[es:cpp/locale/time get]]
[[fr:cpp/locale/time get]]
[[it:cpp/locale/time get]]
[[ja:cpp/locale/time get]]
[[pt:cpp/locale/time get]]
[[ru:cpp/locale/time get]]
[[zh:cpp/locale/time get]]</text>
      <sha1>jbfhkfk3jwyw2yxqzs0oymuejvfyfh4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/date order</title>
    <ns>0</ns>
    <id>9832</id>
    <revision>
      <id>64016</id>
      <parentid>60952</parentid>
      <timestamp>2013-08-06T14:20:19Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2706">{{cpp/locale/time_get/title|date_order|do_date_order}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
dateorder date_order() const;
}}
{{dcl | num=2 | 1=
protected:
virtual dateorder do_date_order() const;
}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_date_order}} of the most derived class.
@2@ Returns a value of type {{lc|std::time_base::dateorder}}, which describes the default date format used by this locale (expected by {{lc|get_date()}} and produced by {{lc|std::strftime()}} with format specifier {{c|'%x'}}).

The valid values (inherited from {{lc|std::time_base}}) are:

{{dsc begin}}
{{dsc | {{tt|no_order}} | the format contains variable items (week day, Julian day, etc), or this function is not implemented}}
{{dsc | {{tt|dmy}} | day, month, year (European locales)}}
{{dsc | {{tt|mdy}} | month, day, year (American locales)}}
{{dsc | {{tt|ymd}} | year, month, day (Asian locales)}}
{{dsc | {{tt|ydm}} | year, day, month (rare)}}
{{dsc end}}

===Parameters===
(none)

===Return value===
A value of type {{tt|dateorder}}

===Notes===
This function is optional, it may return {{tt|no_order}} in every case.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

void show_date_order()
{
    std::time_base::dateorder d = std::use_facet&lt;std::time_get&lt;char&gt;&gt;(
                                           std::locale()
                                  ).date_order();
    switch (d)
    {
        case std::time_base::no_order: std::cout &lt;&lt; &quot;no_order\n&quot;; break;
        case std::time_base::dmy: std::cout &lt;&lt; &quot;day, month, year\n&quot;; break;
        case std::time_base::mdy: std::cout &lt;&lt; &quot;month, day, year\n&quot;; break;
        case std::time_base::ymd: std::cout &lt;&lt; &quot;year, month, day\n&quot;; break;
        case std::time_base::ydm: std::cout &lt;&lt; &quot;year, day, month\n&quot;; break;
    }
}

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::cout &lt;&lt; &quot;In U.S. locale, the default date order is: &quot;;
    show_date_order();

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    std::cout &lt;&lt; &quot;In Japanese locale, the default date order is: &quot;;
    show_date_order();

    std::locale::global(std::locale(&quot;de_DE.utf8&quot;));
    std::cout &lt;&lt; &quot;In German locale, the default date order is: &quot;;
    show_date_order();
}
 | output=&lt;!-- works with LLVM libc++ --&gt;
In U.S. locale, the default date order is: month, day, year
In Japanese locale, the default date order is: year, month, day
In German locale, the default date order is: day, month, year
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/time_get/dsc do_get_date}}
{{dsc inc | cpp/locale/dsc time_base}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get</title>
    <ns>0</ns>
    <id>9835</id>
    <revision>
      <id>62759</id>
      <parentid>58205</parentid>
      <timestamp>2013-07-01T23:39:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="7280">{{cpp/locale/time_get/title|get|do_get}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | since=c++11 | 1=
public:
iter_type get(iter_type beg, iter_type end, std::ios_base&amp; str,
              std::ios_base::iostate&amp; err, std::tm* t,
              const char_type* fmtbeg, const char_type* fmtend) const;
}}
{{dcl | num=2 | since=c++11 | 1=
protected:
virtual iter_type do_get(iter_type neg, iter_type end, std::ios_base&amp; str,
                         std::ios_base::iostate&amp; err, std::tm *t,
                         char format, char modifier) const;
}}
{{dcl end}}

@1@ Parses the date and time from the input character sequence {{tt|[beg, end)}} according to the format provided in the character sequence {{c|[fmtbeg, fmtend)}}. The format is expected to follow the format described below, although actual processing of each format specifier can be customized by overriding {{tt|do_get}}. The {{tt|get}} function performs the following:
First, clears the error bits in {{tt|err}} by executing {{c|1=err = std::ios_base::goodbit}}. Then enters a loop, which terminates whenever any of the following conditions becomes true (checked in this order):
:@a@ All characters have been read from the format string ({{c|fmtbeg {{==}} fmtend}})
:@b@ There was a parsing error ({{c|err !{{=}} std::ios_base::goodbit}})
:@c@ All characters have been read from the input sequence ({{c|beg {{==}} end}}. If this condition terminates the loop, the function sets both {{tt|eofbit}} and {{tt|failbit}} in {{tt|err}}

::In the body of the loop, the following steps take place:
:@a@ if the next character in the format string is {{c|'%'}}, followed by one or two characters that form a valid {{lc|std::get_time}} conversion specifier (see below), these characters are used in the call {{c|do_get(beg, end, str, err, t, format, modifier)}}, where {{tt|format}} is the primary conversion specifier character, and {{tt|modifier}} is the optional modifier (which appears between {{tt|%}} and the format character, if present). If there is no modifier, the value {{c|'\0'}} is used. If the format string is ambiguous or ends too early to determine the conversion specifier after {{c|'%'}}, {{tt|eofbit}} is set in {{tt|err}} and the loop is terminated. If, after the call to {{tt|do_get}}, no error bits are set in {{tt|err}}, the function increments {{tt|fmtbeg}} to point right after the conversion specifier and continues the loop.
:@b@ If the next character is whitespace, as indicated by the locale provided in the stream {{tt|str}} (i.e. {{c|std::isspace(*fmtbeg, str.getloc()) {{==}} true}}, the function keeps incrementing {{tt|fmtbeg}} until it either becomes equal to {{tt|fmtend}} or points to a non-whitespace character.
:@c@ If the next character in the format string is equivalent to the next character in the input stream according to case-insensitive comparison, the function advances both sequences by one character {{c|++fmtbeg, ++beg;}} and continues the loop, Otherwise, it sets the {{tt|failbit}} in {{tt|err}}.

@2@ Parses one conversion specifier from the input sequence {{tt|[beg, end)}} and updates the {{lc|std::tm}} structure pointed to by {{tt|t}} accordingly.

::First, clears the error bits in {{tt|err}} by executing {{c|1=err = std::ios_base::goodbit}}. Then reads characters from the input sequence {{tt|[beg, end)}} that are expected by the {{lc|std::time_get}} format specifier formed by combining {{c|'%'}}, {{tt|modifier}} (if not {{c|'\0'}}), and {{tt|format}}. If the characters do not combine to form a valid conversion specifier, sets {{tt|failbit}} in {{tt|err}}. If the end of the input stream is reached after reading a character, sets {{tt|eofbit}} in {{tt|err}}. If the input string was parsed successfully, updates the corresponding fields of {{c|*t}}.

::For complex conversion specifiers, such as {{c|'%x'}} or {{c|'%c'}}, or the directives that use the modifiers {{c|'E'}} and {{c|'O'}}, the function may fail to determine some of the values to store in {{c|*t}}. In such case, it sets {{tt|eofbit}} in {{tt|err}} and leaves these fields in unspecified state.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace or {{lc|std::collate}} to compare strings}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par | fmtbeg | pointer to the first character of a sequence of char_type characters specifying the conversion format
{{cpp/locale/time_get/time_get format}}
}}
{{par | fmtend | pointer one past the last character of a sequence of char_type characters specifying the conversion format}}
{{par | format | the character that names a conversion specifier}}
{{par | modifier | the optional modifier that may appear between {{tt|%}} and the conversion specifier}}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was parsed successfully.

===Notes===
The case-insensitive comparison for the non-whitespace non-{{c|'%'}} characters in the format string, the {{lc|std::collate}} facet of the locale provided by {{tt|str}} is typically, but not necessarily, used.

If a parsing error is encountered, many implementations of this function leave {{tt|*t}} completely untouched.

It's unspecified if these functions zero out the fields in {{c|*t}} that they do not set directly: portable programs should initialize every field to zero before calling {{tt|get()}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;iomanip&gt;

int main()
{
    std::istringstream ss(&quot;2011-Februar-18 23:12:34&quot;);
    ss.imbue(std::locale(&quot;de_DE&quot;));

    auto&amp; f = std::use_facet&lt;std::time_get&lt;char&gt;&gt;(std::locale(&quot;de_DE&quot;));
    std::tm t{};
    std::string s = &quot;%Y-%b-%d %H:%M:%S&quot;;
    std::ios_base::iostate err = std::ios_base::goodbit;
    std::istreambuf_iterator&lt;char&gt; ret = f.get(std::istreambuf_iterator&lt;char&gt;(ss),
                                               std::istreambuf_iterator&lt;char&gt;(),
                                               ss, err, &amp;t, &amp;s[0], &amp;s[0] + s.size());
    ss.setstate(err);

    if(ss) {
        std::cout &lt;&lt; &quot;Successfully parsed as &quot; &lt;&lt; std::put_time(&amp;t, &quot;%c&quot;);
        if(ret != std::istreambuf_iterator&lt;char&gt;()) {
            std::cout &lt;&lt; &quot; Remaining content: &quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                           std::ostreambuf_iterator&lt;char&gt;(std::cout));
        } else {
                std::cout &lt;&lt; &quot; The input was fully consumed&quot;;
        }
    } else {
            std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                           std::ostreambuf_iterator&lt;char&gt;(std::cout));
    }
    std::cout &lt;&lt; '\n';
}
 | output=
Successfully parsed, as Sun Feb 18 23:12:34 2011 The input was fully consumed
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get date</title>
    <ns>0</ns>
    <id>9831</id>
    <revision>
      <id>60954</id>
      <parentid>60953</parentid>
      <timestamp>2013-06-03T11:09:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="4137">{{cpp/locale/time_get/title|get_date|do_get_date}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type get_date( iter_type beg, iter_type end, std::ios_base&amp; str,
                    std::ios_base::iostate&amp; err, std::tm* t ) const;
}}
{{dcl | num=2 | 1=
protected:
virtual iter_type do_get_date( iter_type beg, iter_type end, std::ios_base&amp; str,
                               std::ios_base::iostate&amp; err, std::tm* t ) const;
}}
{{dcl end}}

@1@ Public member function, calls the protected virtual member function {{tt|do_get_date()}} of the most derived class.
@2@ Reads successive characters from the sequence {{tt|[beg, end)}} and parses out the calendar date value using the default format expected by this locale, which is the same format as

{{rev begin}}
{{rev | until=c++11 | {{c|&quot;%x&quot;}} }}
{{rev | since=c++11 | {{c|&quot;%d/%m/%y&quot;}}, {{c|&quot;%m/%d/%y&quot;}}, {{c|&quot;%y/%m/%d&quot;}}, and {{c|&quot;%y/%d/%m&quot;}}, depending on {{lc|date_order()}} }}
{{rev end}}

@@ as used by the functions {{lc|std::get_time()}}, {{lc|get()}}, and the POSIX function {{tt|strptime()}}

@@ The parsed date is stored in the corresponding fields of the {{lc|std::tm}} structure pointed to by the argument {{tt|t}}.

@@ If the end iterator is reached before a valid date is read, the function sets {{lc|std::ios_base::eofbit}} in {{tt|err}}. If a parsing error is encountered, the function sets {{lc|std::ios_base::failbit}} in {{tt|err}}.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace or {{lc|std::collate}} to compare strings}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was recognized as a part of a valid date.

===Notes===
For the alphabetic components of the default date format (if any), this function is usually case-insensitive.

If a parsing error is encountered, most implementations of this function leave {{tt|*t}} unmodified.

The implementation may support other date formats besides the ones required by the standard.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;
#include &lt;ctime&gt;

void try_get_date(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Parsing the date out of '&quot; &lt;&lt; s &lt;&lt;
                 &quot;' in the locale &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n';
    std::istringstream str(s);
    std::ios_base::iostate err = std::ios_base::goodbit;

    std::tm t;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::time_get&lt;char&gt;&gt;(str.getloc()).get_date(
            std::istreambuf_iterator&lt;char&gt;(str),
            std::istreambuf_iterator&lt;char&gt;(),
            str, err, &amp;t
        );
    str.setstate(err);
    if(str) {
        std::cout &lt;&lt; &quot;Day: &quot;   &lt;&lt; t.tm_mday &lt;&lt; ' '
                  &lt;&lt; &quot;Month: &quot; &lt;&lt; t.tm_mon + 1 &lt;&lt; ' '
                  &lt;&lt; &quot;Year: &quot;  &lt;&lt; t.tm_year + 1900 &lt;&lt; '\n';
    } else {
        std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
        std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                  std::ostreambuf_iterator&lt;char&gt;(std::cout));
        std::cout &lt;&lt; '\n';
    }
}
int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    try_get_date(&quot;02/01/2013&quot;);
    try_get_date(&quot;02-01-2013&quot;);

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_get_date(&quot;2013年02月01日&quot;);
}
 | output=
Parsing the date out of '02/01/2013' in the locale en_US.utf8
Day: 1 Month: 2 Year: 2013
Parsing the date out of '02-01-2013' in the locale en_US.utf8
Parse failed. Unparsed string: -01-2013
Parsing the date out of '2013年02月01日' in the locale ja_JP.utf8
Day: 1 Month: 2 Year: 2013
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get monthname</title>
    <ns>0</ns>
    <id>9834</id>
    <revision>
      <id>58211</id>
      <parentid>50067</parentid>
      <timestamp>2013-06-01T06:10:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4878">{{cpp/locale/time_get/title|get_monthname|do_get_monthname}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type get_monthname( iter_type beg, iter_type end, std::ios_base&amp; str,
                         std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl | num=2 | 1=
protected:
virtual iter_type do_get_monthname( iter_type beg, iter_type end, std::ios_base&amp; str,
                                    std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_get_monthname}} of the most derived class.
@2@ Reads successive characters from the sequence {{tt|[beg, end)}} and parses out the month name (possibly abbreviated), using the default format for month names expected by this locale, which is the same format as {{c|&quot;%b&quot;}} as used by the functions {{lc|std::get_time}}, {{l2tt|cpp/locale/time_get/get}}, and the POSIX function {{tt|strptime()}}

If it finds abbreviated name, followed by the characters that are valid for the full name, it continues reading until it consumes all the characters for the full name or finds a character that isn't expected, in which case parsing fails even if the first few characters were a valid abbreviation.

The parsed month is stored in the {{lc|std::tm}} field {{c|t-&gt;tm_mon}}.

If the end iterator is reached before a valid month name is read, the function sets {{lc|std::ios_base::eofbit}} in {{tt|err}}. If a parsing error is encountered, the function sets {{lc|std::ios_base::failbit}} in {{tt|err}}.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace or {{lc|std::collate}} to compare strings}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was recognized as a part of a valid month name.

===Notes===
This function is usually case-insensitive.

If a parsing error is encountered, most implementations of this function leave {{tt|*t}} unmodified.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;
#include &lt;ctime&gt;

void try_get_mon(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Parsing the month out of '&quot; &lt;&lt; s &lt;&lt;
                 &quot;' in the locale &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n';
    std::istringstream str(s);
    std::ios_base::iostate err = std::ios_base::goodbit;

    std::tm t;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::time_get&lt;char&gt;&gt;(str.getloc()).get_monthname(
            std::istreambuf_iterator&lt;char&gt;(str),
            std::istreambuf_iterator&lt;char&gt;(),
            str, err, &amp;t
        );
    str.setstate(err);
    if(str) {
        std::cout &lt;&lt; &quot;Successfully parsed, month number is &quot; &lt;&lt; t.tm_mon;
        if(ret != std::istreambuf_iterator&lt;char&gt;()) {
            std::cout &lt;&lt; &quot;. Remaining content: &quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                      std::ostreambuf_iterator&lt;char&gt;(std::cout));
        } else {
            std::cout &lt;&lt; &quot;. The input was fully consumed&quot;;
        }
    } else {
        std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
        std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                  std::ostreambuf_iterator&lt;char&gt;(std::cout));
    }
    std::cout &lt;&lt; '\n';
}
int main()
{
    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_get_mon(&quot;2月&quot;);
    std::locale::global(std::locale(&quot;th_TH.utf8&quot;));
    try_get_mon(&quot;กุมภาพันธ์&quot;);
    std::locale::global(std::locale(&quot;el_GR.utf8&quot;));
    try_get_mon(&quot;Φεβ&quot;);
    try_get_mon(&quot;Φεβρουάριος&quot;);
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    try_get_mon(&quot;Febrile&quot;);
}
 | output=
Parsing the month out of '2月' in the locale ja_JP.utf8
Successfully parsed, month number is 1. The input was fully consumed
Parsing the month out of 'กุมภาพันธ์' in the locale th_TH.utf8
Successfully parsed, month number is 1. The input was fully consumed
Parsing the month out of 'Φεβ' in the locale el_GR.utf8
Successfully parsed, month number is 1. The input was fully consumed
Parsing the month out of 'Φεβρουάριος' in the locale el_GR.utf8
Successfully parsed, month number is 1. The input was fully consumed
Parsing the month out of 'Febrile' in the locale en_US.utf8
Parse failed. Unparsed string: ile
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get time</title>
    <ns>0</ns>
    <id>9836</id>
    <revision>
      <id>58212</id>
      <parentid>50068</parentid>
      <timestamp>2013-06-01T06:10:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3860">{{cpp/locale/time_get/title|get_time|do_get_time}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type get_time( iter_type beg, iter_type end, std::ios_base&amp; str,
                    std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl | num=2 | 1=
protected:
virtual iter_type get_time( iter_type beg, iter_type end, std::ios_base&amp; str,
                            std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_get_time}} of the most derived class.
@2@ Reads successive characters from the sequence {{tt|[beg, end)}} and parses out the time value following the same rules as the format specifier 

{{rev begin}}
{{rev | until=c++11 | {{c|'%X'}} }}
{{rev | since=c++11 | {{c|&quot;%H:%M:%S&quot;}} }}
{{rev end}}

@@ as used by the functions {{lc|std::get_time}}, {{l2tt|cpp/locale/time_get/get}}, and the POSIX function {{tt|strptime()}}

@@ The parsed time is stored in the corresponding fields of the {{lc|std::tm}} structure pointed to by the argument {{tt|t}}.

@@ If the end iterator is reached before a valid value is read, the function sets {{lc|std::ios_base::eofbit}} in {{tt|err}}. If a parsing error is encountered, the function sets {{lc|std::ios_base::failbit}} in {{tt|err}}.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was recognized as a part of a valid date.

===Notes===
For the alphabetic components of the default time format (if any), this function is usually case-insensitive.

If a parsing error is encountered, most implementations of this function leave {{tt|*t}} unmodified.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;

void try_get_time(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Parsing the time out of '&quot; &lt;&lt; s &lt;&lt;
                 &quot;' in the locale &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n';
    std::istringstream str(s);
    std::ios_base::iostate err = std::ios_base::goodbit;

    std::tm t;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::time_get&lt;char&gt;&gt;(str.getloc()).get_time(
            std::istreambuf_iterator&lt;char&gt;(str),
            std::istreambuf_iterator&lt;char&gt;(),
            str, err, &amp;t
        );
    str.setstate(err);
    if(str) {
        std::cout &lt;&lt; &quot;Hours: &quot;   &lt;&lt; t.tm_hour &lt;&lt; ' '
                  &lt;&lt; &quot;Minutes: &quot; &lt;&lt; t.tm_min  &lt;&lt; ' '
                  &lt;&lt; &quot;Seconds: &quot; &lt;&lt; t.tm_sec  &lt;&lt; '\n';
    } else {
        std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
        std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                  std::ostreambuf_iterator&lt;char&gt;(std::cout));
        std::cout &lt;&lt; '\n';
    }
}
int main()
{
    std::locale::global(std::locale(&quot;ru_RU.utf8&quot;));
    try_get_time(&quot;21:40:11&quot;);
    try_get_time(&quot;21-40-11&quot;);

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_get_time(&quot;21時37分58秒&quot;);
}
 | output=
Parsing the time out of '21:40:11' in the locale ru_RU.utf8
Hours: 21 Minutes: 40 Seconds: 11
Parsing the time out of '21-40-11' in the locale ru_RU.utf8
Parse failed. Unparsed string: -40-11
Parsing the time out of '21時37分58秒' in the locale ja_JP.utf8
Hours: 21 Minutes: 37 Seconds: 58
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get weekday</title>
    <ns>0</ns>
    <id>9833</id>
    <revision>
      <id>58215</id>
      <parentid>50069</parentid>
      <timestamp>2013-06-01T06:10:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="4635">{{cpp/locale/time_get/title|get_weekday|do_get_weekday}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type get_weekday( iter_type beg, iter_type end, std::ios_base&amp; str,
                       std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl | num=2 | 1=
protected:
virtual iter_type do_get_weekday( iter_type beg, iter_type end, std::ios_base&amp; str,
                                  std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_get_weekday}} of the most derived class.
@2@ Reads successive characters from the sequence {{tt|[beg, end)}} and parses out the weekday name (possibly abbreviated), using the default format for weekdays expected by this locale, which is the same format as {{c|&quot;%a&quot;}} as used by the functions {{lc|std::get_time}}, {{l2tt|cpp/locale/time_get/get}}, and the POSIX function {{tt|strptime()}}

If it finds abbreviated name, followed by the characters that are valid for the full name, it continues reading until it consumes all the characters for the full name or finds a character that isn't expected, in which case parsing fails even if the first few characters were a valid abbreviation.

The parsed weekday is stored in the {{lc|std::tm}} field {{c|t-&gt;tm_wday}}.

If the end iterator is reached before a valid weekday name is read, the function sets {{lc|std::ios_base::eofbit}} in {{tt|err}}. If a parsing error is encountered, the function sets {{lc|std::ios_base::failbit}} in {{tt|err}}.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace or {{lc|std::collate}} to compare strings}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was recognized as a part of a valid weekname.

===Notes===
This function is usually case-insensitive.

If a parsing error is encountered, most implementations of this function leave {{tt|*t}} unmodified.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;

void try_get_wday(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Parsing the weekday out of '&quot; &lt;&lt; s &lt;&lt;
                 &quot;' in the locale &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n';
    std::istringstream str(s);
    std::ios_base::iostate err = std::ios_base::goodbit;

    std::tm t;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::time_get&lt;char&gt;&gt;(str.getloc()).get_weekday(
            std::istreambuf_iterator&lt;char&gt;(str),
            std::istreambuf_iterator&lt;char&gt;(),
            str, err, &amp;t
        );
    str.setstate(err);
    if(str) {
        std::cout &lt;&lt; &quot;Successfully parsed, weekday number is &quot; &lt;&lt; t.tm_wday;
        if(ret != std::istreambuf_iterator&lt;char&gt;()) {
            std::cout &lt;&lt; &quot; Remaining content: &quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                      std::ostreambuf_iterator&lt;char&gt;(std::cout));
        } else {
            std::cout &lt;&lt; &quot; the input was fully consumed&quot;;
        }
    } else {
        std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
        std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                  std::ostreambuf_iterator&lt;char&gt;(std::cout));
    }
    std::cout &lt;&lt; '\n';
}
int main()
{
    std::locale::global(std::locale(&quot;lt_LT.utf8&quot;));
    try_get_wday(&quot;Št&quot;);
    try_get_wday(&quot;Šeštadienis&quot;);

    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    try_get_wday(&quot;SATELLITE&quot;);

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_get_wday(&quot;土曜日&quot;);
}
 | output=
Parsing the weekday out of 'Št' in the locale lt_LT.utf8
Successfully parsed, weekday number is 6 the input was fully consumed
Parsing the weekday out of 'Šeštadienis' in the locale lt_LT.utf8
Successfully parsed, weekday number is 6 the input was fully consumed
Parsing the weekday out of 'SATELLITE' in the locale en_US.utf8
Successfully parsed, weekday number is 6 Remaining content: ELLITE
Parsing the weekday out of '土曜日' in the locale ja_JP.utf8
Successfully parsed, weekday number is 6 the input was fully consumed
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/get year</title>
    <ns>0</ns>
    <id>9837</id>
    <revision>
      <id>62466</id>
      <parentid>60983</parentid>
      <timestamp>2013-06-30T19:21:38Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4337">{{cpp/locale/time_get/title|get_year|do_get_year}}
{{cpp/locale/time_get/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type do_get_year( iter_type s, iter_type end, std::ios_base&amp; str,
                       std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl | num=2 | 1=
protected:
virtual iter_type do_get_year( iter_type s, iter_type end, std::ios_base&amp; str,
                               std::ios_base::iostate&amp; err, std::tm* t) const;
}}
{{dcl end}}

@1@ public member function, calls the protected virtual member function {{tt|do_get_year}} of the most derived class.
@2@ Reads successive characters from the sequence {{tt|[beg, end)}} and parses out the year using some implementation-defined format. Depending on the locale, two-digit years may be accepted, and it is implementation-defined which century they belong to.

The parsed year is stored in the {{lc|std::tm}} structure field {{c|t-&gt;tm_year}}.

If the end iterator is reached before a valid date is read, the function sets {{lc|std::ios_base::eofbit}} in {{tt|err}}. If a parsing error is encountered, the function sets {{lc|std::ios_base::failbit}} in {{tt|err}}.

===Parameters===
{{par begin}}
{{par | beg | iterator designating the start of the sequence to parse}}
{{par | end | one past the end iterator for the sequence to parse }}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to skip whitespace or {{lc|std::collate}} to compare strings}}
{{par | err | stream error flags object that is modified by this function to indicate errors}}
{{par | t | pointer to the {{lc|std::tm}} object that will hold the result of this function call }}
{{par end}}

===Return value===
Iterator pointing one past the last character in {{tt|[beg, end)}} that was recognized as a part of a valid year.

===Notes===
For two-digit input values, many implementations use the same parsing rules as the conversion specifier {{c|'%y'}} as used by {{lc|std::get_time}}, {{lc|std::time_get::get()}}, and the POSIX function {{tt|strptime()}}: two-digit integer is expected, the values in the range [69,99] results in values 1969 to 1999, range [00,68] results in 2000-2068. Four-digit inputs are typically accepted as-is.

If a parsing error is encountered, most implementations of this function leave {{tt|*t}} unmodified.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;

void try_get_year(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Parsing the year out of '&quot; &lt;&lt; s &lt;&lt;
                 &quot;' in the locale &quot; &lt;&lt; std::locale().name() &lt;&lt; '\n';
    std::istringstream str(s);
    std::ios_base::iostate err = std::ios_base::goodbit;

    std::tm t;
    std::istreambuf_iterator&lt;char&gt; ret =
        std::use_facet&lt;std::time_get&lt;char&gt;&gt;(str.getloc()).get_year(
            std::istreambuf_iterator&lt;char&gt;(str),
            std::istreambuf_iterator&lt;char&gt;(),
            str, err, &amp;t
        );
    str.setstate(err);
    if (str) {
        std::cout &lt;&lt; &quot;Successfully parsed, year is &quot; &lt;&lt; 1900 + t.tm_year;
        if (ret != std::istreambuf_iterator&lt;char&gt;()) {
            std::cout &lt;&lt; &quot; Remaining content: &quot;;
            std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                      std::ostreambuf_iterator&lt;char&gt;(std::cout));
        } else {
            std::cout &lt;&lt; &quot; the input was fully consumed&quot;;
        }
    } else {
        std::cout &lt;&lt; &quot;Parse failed. Unparsed string: &quot;;
        std::copy(ret, std::istreambuf_iterator&lt;char&gt;(),
                  std::ostreambuf_iterator&lt;char&gt;(std::cout));
    }
    std::cout &lt;&lt; '\n';
}

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    try_get_year(&quot;13&quot;);
    try_get_year(&quot;2013&quot;);

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_get_year(&quot;2013年&quot;);
}
 | p=true
 | output=&lt;!--produced using LLVM libc++--&gt;
Parsing the year out of '13' in the locale en_US.utf8
Successfully parsed, year is 2013 the input was fully consumed
Parsing the year out of '2013' in the locale en_US.utf8
Successfully parsed, year is 2013 the input was fully consumed
Parsing the year out of '2013年' in the locale ja_JP.utf8
Successfully parsed, year is 2013 Remaining content: 年
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/time get</title>
    <ns>0</ns>
    <id>4401</id>
    <revision>
      <id>43163</id>
      <parentid>15756</parentid>
      <timestamp>2012-11-03T01:51:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="330">{{cpp/locale/facet/constructor|time_get}}

[[de:cpp/locale/time get/time get]]
[[es:cpp/locale/time get/time get]]
[[fr:cpp/locale/time get/time get]]
[[it:cpp/locale/time get/time get]]
[[ja:cpp/locale/time get/time get]]
[[pt:cpp/locale/time get/time get]]
[[ru:cpp/locale/time get/time get]]
[[zh:cpp/locale/time get/time get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get/~time get</title>
    <ns>0</ns>
    <id>4446</id>
    <revision>
      <id>43156</id>
      <parentid>15819</parentid>
      <timestamp>2012-11-03T01:50:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/locale/facet/destructor|time_get}}

[[de:cpp/locale/time get/~time get]]
[[es:cpp/locale/time get/~time get]]
[[fr:cpp/locale/time get/~time get]]
[[it:cpp/locale/time get/~time get]]
[[ja:cpp/locale/time get/~time get]]
[[pt:cpp/locale/time get/~time get]]
[[ru:cpp/locale/time get/~time get]]
[[zh:cpp/locale/time get/~time get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time get byname</title>
    <ns>0</ns>
    <id>9315</id>
    <revision>
      <id>63753</id>
      <parentid>61619</parentid>
      <timestamp>2013-07-24T00:01:00Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <text xml:space="preserve" bytes="1676">{{cpp/title | time_get_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt;
    class CharT,
    class InputIterator = std::istreambuf_iterator&lt;CharT&gt;
&gt; class time_get_byname : public std::time_get&lt;CharT, InputIterator&gt;
}}
{{dcl end}}

{{lc|std::time_get_byname}} is a {{lc|std::time_get}} facet which encapsulates time and date parsing rules of the locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::time_get_byname&lt;char, InputIterator&gt;}} | narrow/multibyte time parsing }}
{{dsc | {{c|std::time_get_byname&lt;wchar_t, InputIterator&gt;}} | wide string time parsing }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|OutputIterator}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | time_get_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | time_get_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | time_get_byname}}
{{include | cpp/locale/byname/destructor | time_get_byname}}

{{cpp/locale/time_get/inherit}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc time_get}}
{{dsc inc | cpp/io/manip/dsc get_time}}
{{dsc end}}

[[de:cpp/locale/time get byname]]
[[es:cpp/locale/time get byname]]
[[fr:cpp/locale/time get byname]]
[[it:cpp/locale/time get byname]]
[[ja:cpp/locale/time get byname]]
[[pt:cpp/locale/time get byname]]
[[ru:cpp/locale/time get byname]]
[[zh:cpp/locale/time get byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time put</title>
    <ns>0</ns>
    <id>3568</id>
    <revision>
      <id>65768</id>
      <parentid>58222</parentid>
      <timestamp>2013-10-07T18:23:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix description of the required specializations</comment>
      <text xml:space="preserve" bytes="2893">{{cpp/title | time_put}}
{{cpp/locale/time_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; 
    class CharT, 
    class OutputIt = std::ostreambuf_iterator&lt;CharT&gt; 
&gt; class time_put;
}}
{{dcl end}}

Class template {{tt|std::time_put}} encapsulates date and time formatting rules. The I/O manipulator {{lc|std::put_time}} uses the {{tt|std::time_put}} facet of the I/O stream's locale to generate text representation of an {{lc|std::tm}} object.

{{inheritance diagram/std-time_put}}

===Type requirements===
{{par begin}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Specializations===
Two standalone (locale-independent) full specializations and two partial specializations are provided by the standard library:
{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::time_put&lt;char&gt;}} | creates narrow string representations of date and time }}
{{dsc | {{c|std::time_put&lt;wchar_t&gt;}} | creates wide string representations of date and time }}
{{dsc | {{c|std::time_put&lt;char, OutputIt&gt;}} | creates narrow string representations of date and time using custom output iterator}}
{{dsc | {{c|std::time_put&lt;wchar_t, OutputIt&gt;}} | creates wide string representations of date and time using custom output iterator}}
{{dsc end}}
In addition, every locale object constructed in a C++ program implements its own (locale-specific) versions of these specializations.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|OutputIt}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_put/dsc constructor}}
{{dsc inc | cpp/locale/time_put/dsc destructor}}
{{dsc inc | cpp/locale/time_put/dsc put}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_put/dsc do_put}}
{{dsc end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;ctime&gt;
#include &lt;iomanip&gt;
#include &lt;codecvt&gt;

int main()
{
    std::time_t t = std::time(NULL);
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv(std::cout.rdbuf());
    std::wostream out(&amp;conv);
    out.imbue(std::locale(&quot;ja_JP&quot;));
    // this I/O manipulator std::put_time uses std::time_put&lt;wchar_t&gt;
    out &lt;&lt; std::put_time(std::localtime(&amp;t), L&quot;%A %c&quot;) &lt;&lt; '\n';
}
 | output=
水曜日 2011年11月09日 12時32分05秒
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc time_put_byname}}
{{dsc inc | cpp/locale/dsc time_get}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc end}}

[[de:cpp/locale/time put]]
[[es:cpp/locale/time put]]
[[fr:cpp/locale/time put]]
[[it:cpp/locale/time put]]
[[ja:cpp/locale/time put]]
[[pt:cpp/locale/time put]]
[[ru:cpp/locale/time put]]
[[zh:cpp/locale/time put]]</text>
      <sha1>4by5f2kz1jh8yzgt5ovoxymmqh3925l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time put/put</title>
    <ns>0</ns>
    <id>9838</id>
    <revision>
      <id>72354</id>
      <parentid>72348</parentid>
      <timestamp>2014-08-14T11:35:42Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>charT =&gt; CharT</comment>
      <text xml:space="preserve" bytes="5375">{{cpp/locale/time_put/title|put|do_put}}
{{cpp/locale/time_put/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
public:
iter_type put( iter_type out, std::ios_base&amp; str,
               char_type fill, const std::tm* t,
               const CharT* fmtbeg, const CharT* fmtend ) const;
}}
{{dcl | num=2 | 1=
public:
iter_type put( iter_type out, std::ios_base&amp; str,
               char_type fill, const std::tm* t,
               char format, char modifier = 0 ) const;
}}
{{dcl | num=3 | 1=
protected:
virtual iter_type do_put( iter_type out, std::ios_base&amp; str,
                          char_type fill, const std::tm* t,
                          char format, char modifier ) const;
}}
{{dcl end}}

Converts the calendar date and time stored in the {{lc|std::tm}} object pointed to by {{tt|t}} into a character string, according to the format string {{tt|[fmtbeg, fmtend)}}. The format string is the same as used by {{c|std::srtftime}}, but each format specifier is processed by an individual call to {{tt|do_put()}}, which can be customized by extending this facet.

@1@ Steps through the character sequence {{tt|[fmtbeg, fmtend)}}, examining the characters. Every character that is not a part of a format sequence is written to the output iterator {{tt|out}} immediately. To identify format sequences, this function narrows the next character {{tt|c}} in {{tt|[fmtbeg, fmtend)}} as if by {{c|std::ctype&lt;char_type&gt;(str.getloc()).narrow(c,0)}} and if it equals {{c|'%'}}, the next one or two characters are compared to the list of format sequences recognized by {{lc|std::strftime}} plus any additional implementation-defined formats supported by this locale. For each valid format sequence, a call to {{c|do_put(out, str, fill, t, format, modifier)}} is made, where {{tt|format}} is the format sequence character, and {{tt|modifier}} is the optional format sequence modifier ({{c|'E'}} or {{c|'O'}}). A value of {{c|'\0'}} is used if the modifier is absent.
@2@ Calls the {{tt|do_put}} member function of the most derived class.
@3@ Converts the calendar date and time stored in the {{lc|std::tm}} object pointed to by {{tt|t}} into a character string, according to the format conversion sequence formed by concatenating {{c|'%'}}, the value of {{tt|modifier}} if not {{c|'\0'}}, and the value of {{tt|format}}. The format is interpreted the same way as the function {{lc|std::strftime}}, except that the formats that are described as locale-dependent are defined by this locale, and additional format specifiers may be supported (the {{tt|fill}} argument is provided for these implementation-defined format specifiers to use). The string is written to the output iterator {{tt|out}}.

===Parameters===
{{par begin}}
{{par | out | output iterator where the result of the conversion is written}}
{{par | str | a stream object that this function uses to obtain locale facets when needed, e.g. {{lc|std::ctype}} to narrow characters}}
{{par | t | pointer to the {{lc|std::tm}} object from which the date/time values are obtained}}
{{par | fmtbeg | pointer to the first character of a sequence of char_type characters specifying the conversion format
{{cpp/chrono/c/strftime format}}
}}
{{par | fmtend | pointer one past the last character of a sequence of char_type characters specifying the conversion format}}
{{par | fill | fill character (usually space)}}
{{par | format | the character that names a conversion specifier}}
{{par | modifier | the optional modifier that may appear between {{tt|%}} and the conversion specifier}}
{{par end}}

===Return value===
Iterator pointing one past the last character that was produced .

===Notes===
No error handling is provided.

The {{tt|fill}} character is provided for those implementation-defined format specifiers and for the user-defined overrides of {{tt|do_put()}} that use padding and filling logic. Such implementations typically make use of the formatting flags from {{tt|str}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;iomanip&gt;
#include &lt;ctime&gt;

void try_time_put(const std::tm* t, const std::string&amp; fmt)
{
        std::cout.imbue(std::locale());
        std::cout &lt;&lt; &quot;In the locale '&quot; &lt;&lt; std::cout.getloc().name() &lt;&lt; &quot;' : '&quot;;

        std::use_facet&lt;std::time_put&lt;char&gt;&gt;(std::cout.getloc()).put(
                    std::ostreambuf_iterator&lt;char&gt;(std::cout),
                    std::cout, ' ', t, &amp;fmt[0], &amp;fmt[0] + fmt.size());

        std::cout &lt;&lt; &quot;'\n&quot;;
}

int main()
{
    std::time_t t = std::time(NULL);
    std::tm tm = *std::localtime(&amp;t);

    std::string fmt = &quot;%c&quot;;
    std::cout &lt;&lt; &quot;Using the format string '&quot; &lt;&lt; fmt
              &lt;&lt; &quot;' to format the time: &quot; &lt;&lt; std::ctime(&amp;t) &lt;&lt; '\n';

    std::locale::global(std::locale(&quot;de_DE.utf8&quot;));
    try_time_put(&amp;tm, fmt);

    std::locale::global(std::locale(&quot;el_GR.utf8&quot;));
    try_time_put(&amp;tm, fmt);

    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    try_time_put(&amp;tm, fmt);
}
 | output=
Using the format string '%c' to format the time: Mon Feb 11 22:58:50 2013

In the locale 'de_DE.utf8' : 'Mo 11 Feb 2013 23:02:38 EST'
In the locale 'el_GR.utf8' : 'Δευ 11 Φεβ 2013 11:02:38 μμ EST'
In the locale 'ja_JP.utf8' : '2013年02月11日 23時02分38秒'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/manip/dsc put_time}}
{{dsc inc | cpp/locale/time_get/dsc do_get}}
{{dsc end}}</text>
      <sha1>p5831fp98xflc13zaae0qt46fvn42he</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time put/time put</title>
    <ns>0</ns>
    <id>4413</id>
    <revision>
      <id>43134</id>
      <parentid>15771</parentid>
      <timestamp>2012-11-03T01:46:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="330">{{cpp/locale/facet/constructor|time_put}}

[[de:cpp/locale/time put/time put]]
[[es:cpp/locale/time put/time put]]
[[fr:cpp/locale/time put/time put]]
[[it:cpp/locale/time put/time put]]
[[ja:cpp/locale/time put/time put]]
[[pt:cpp/locale/time put/time put]]
[[ru:cpp/locale/time put/time put]]
[[zh:cpp/locale/time put/time put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time put/~time put</title>
    <ns>0</ns>
    <id>4445</id>
    <revision>
      <id>43127</id>
      <parentid>15818</parentid>
      <timestamp>2012-11-03T01:44:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="337">{{cpp/locale/facet/destructor|time_put}}

[[de:cpp/locale/time put/~time put]]
[[es:cpp/locale/time put/~time put]]
[[fr:cpp/locale/time put/~time put]]
[[it:cpp/locale/time put/~time put]]
[[ja:cpp/locale/time put/~time put]]
[[pt:cpp/locale/time put/~time put]]
[[ru:cpp/locale/time put/~time put]]
[[zh:cpp/locale/time put/~time put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/time put byname</title>
    <ns>0</ns>
    <id>9248</id>
    <revision>
      <id>61620</id>
      <parentid>58226</parentid>
      <timestamp>2013-06-06T07:21:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+inline descriptions</comment>
      <text xml:space="preserve" bytes="2674">{{cpp/title | time_put_byname}}
{{cpp/locale/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
template&lt; class CharT, class OutputIterator = std::ostreambuf_iterator&lt;CharT&gt; &gt;
class time_put_byname : public std::time_put&lt;CharT, OutputIterator&gt;;
}}
{{dcl end}}

{{lc|std::time_put_byname}} is a {{lc|std::time_put}} facet which encapsulates time and date formatting rules of the locale specified at its construction.

Two specializations are provided by the standard library

{{dsc begin}}
{{dsc header | locale }}
{{dsc | {{c|std::time_put_byname&lt;char, OutputIterator&gt;}} | narrow/multibyte time formatting }}
{{dsc | {{c|std::time_put_byname&lt;wchar_t, OutputIterator&gt;}} | wide string time formatting }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|OutputIterator}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/byname/dsc constructor | time_put_byname}}
{{dsc inc | cpp/locale/byname/dsc destructor | time_put_byname}}
{{dsc end}}

{{include | cpp/locale/byname/constructor | time_put_byname}}
{{include | cpp/locale/byname/destructor | time_put_byname}}

{{cpp/locale/time_put/inherit}}

===Example===
{{example
 | This example prints current time using the &quot;C&quot; locale with the time_put facet replaced by various time_put_byname facets
 | code=
#include &lt;iostream&gt;
#include &lt;ctime&gt;
#include &lt;iomanip&gt;
#include &lt;codecvt&gt;
 
int main()
{
    std::time_t t = std::time(NULL);
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv(std::cout.rdbuf());
    std::wostream out(&amp;conv);

    out.imbue(std::locale(out.getloc(),
                          new std::time_put_byname&lt;wchar_t&gt;(&quot;ja_JP&quot;)));
    out &lt;&lt; std::put_time(std::localtime(&amp;t), L&quot;%A %c&quot;) &lt;&lt; '\n';

    out.imbue(std::locale(out.getloc(),
                         new std::time_put_byname&lt;wchar_t&gt;(&quot;ru_RU.utf8&quot;)));
    out &lt;&lt; std::put_time(std::localtime(&amp;t), L&quot;%A %c&quot;) &lt;&lt; '\n'; 

    out.imbue(std::locale(out.getloc(),
                         new std::time_put_byname&lt;wchar_t&gt;(&quot;sv_SE.utf8&quot;)));
    out &lt;&lt; std::put_time(std::localtime(&amp;t), L&quot;%A %c&quot;) &lt;&lt; '\n'; 
}
 | p=true
 | output=
木曜日 2012年08月09日 21時41分02秒
Четверг Чт. 09 авг. 2012 21:41:02
torsdag tor  9 aug 2012 21:41:02
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc time_put}}
{{dsc end}}

[[de:cpp/locale/time put byname]]
[[es:cpp/locale/time put byname]]
[[fr:cpp/locale/time put byname]]
[[it:cpp/locale/time put byname]]
[[ja:cpp/locale/time put byname]]
[[pt:cpp/locale/time put byname]]
[[ru:cpp/locale/time put byname]]
[[zh:cpp/locale/time put byname]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/tolower</title>
    <ns>0</ns>
    <id>2960</id>
    <revision>
      <id>65551</id>
      <parentid>58227</parentid>
      <timestamp>2013-09-18T15:14:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>reused towlower example</comment>
      <text xml:space="preserve" bytes="1979">{{cpp/title | tolower{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
charT tolower( charT ch, const locale&amp; loc );
}}

Converts the character {{tt|ch}} to lowercase if possible, using the conversion rules specified by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===
Returns the lowercase form of {{tt|ch}} if one is listed in the locale, otherwise return {{tt|ch}} unchanged.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the Greek uppercase letter 'Σ' has two lowercase forms, depending on the position in a word: 'σ' and 'ς'. A call to {{lc|std::tolower}} cannot be used to obtain the correct lowercase form in this case.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
charT tolower( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).tolower(ch);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;locale&gt;

int main()
{
    wchar_t c = L'\u0190'; // Latin capital open E ('Ɛ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;

    std::cout &lt;&lt; &quot;in the default locale, tolower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::tolower(c, std::locale()) &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;in Unicode locale, tolower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::tolower(c, std::locale(&quot;en_US.utf8&quot;)) &lt;&lt; '\n';
}
 | output=
in the default locale, tolower(0x190) = 0x190
in Unicode locale, tolower(0x190) = 0x25b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc toupper}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc end}}

[[de:cpp/locale/tolower]]
[[es:cpp/locale/tolower]]
[[fr:cpp/locale/tolower]]
[[it:cpp/locale/tolower]]
[[ja:cpp/locale/tolower]]
[[pt:cpp/locale/tolower]]
[[ru:cpp/locale/tolower]]
[[zh:cpp/locale/tolower]]</text>
      <sha1>oz6en1hg2o8ha1l3i1w56rpv9i29rko</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/toupper</title>
    <ns>0</ns>
    <id>2959</id>
    <revision>
      <id>65550</id>
      <parentid>65549</parentid>
      <timestamp>2013-09-18T15:11:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missed the char</comment>
      <text xml:space="preserve" bytes="1911">{{cpp/title | toupper{{small|(std::locale)}}}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class charT &gt;
charT toupper( charT ch, const locale&amp; loc );
}}

Converts the character {{tt|ch}} to uppercase if possible, using the conversion rules specified by the given locale's {{lc|std::ctype}} facet.

===Parameters===
{{par begin}}
{{par | ch | character}}
{{par | loc | locale }}
{{par end}}

===Return value===
Returns the uppercase form of {{tt|ch}} if one is listed in the locale, otherwise return {{tt|ch}} unchanged.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the uppercase form of 'ß' is (with some exceptions) the two-character string &quot;SS&quot;, which cannot be obtained by {{lc|std::toupper}}.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class charT &gt;
charT toupper( charT ch, const std::locale&amp; loc ) {
    return std::use_facet&lt;std::ctype&lt;charT&gt;&gt;(loc).toupper(ch);
}
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;locale&gt;

int main()
{
    wchar_t c = L'\u017f'; // Latin small letter Long S ('ſ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;

    std::cout &lt;&lt; &quot;in the default locale, toupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::toupper(c, std::locale()) &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;in Unicode locale, toupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::toupper(c, std::locale(&quot;en_US.utf8&quot;)) &lt;&lt; '\n';
}
 | output=
in the default locale, toupper(0x17f) = 0x17f
in Unicode locale, toupper(0x17f) = 0x53
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc tolower}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc end}}

[[de:cpp/locale/toupper]]
[[es:cpp/locale/toupper]]
[[fr:cpp/locale/toupper]]
[[it:cpp/locale/toupper]]
[[ja:cpp/locale/toupper]]
[[pt:cpp/locale/toupper]]
[[ru:cpp/locale/toupper]]
[[zh:cpp/locale/toupper]]</text>
      <sha1>5n2xydaxzv3ng31lwvl47adi6iexa2o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/use facet</title>
    <ns>0</ns>
    <id>2835</id>
    <revision>
      <id>58231</id>
      <parentid>50077</parentid>
      <timestamp>2013-06-01T06:11:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1309">{{cpp/title | use_facet}}
{{cpp/locale/navbar}}

{{ddcl | header=locale |
template&lt; class Facet &gt;
const Facet&amp; use_facet( const std::locale&amp; loc );
}}

Obtains a reference to a facet implemented by {{tt|loc}}. 

===Parameters===
{{par begin}}
{{par | loc | the locale object to query }}
{{par end}}

===Return value===

Returns a reference the facet. The reference returned by this function is valid as long as any {{lc|std::locale}} object exists that implements {{tt|Facet}}.

===Exceptions===
{{lc|std::bad_cast}} if {{c|1=std::has_facet&lt;Facet&gt;(loc) == false}}.

===Example===
{{example
 | Display the 3-letter currency name used by the user's preferred locale
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    std::locale loc = std::locale(&quot;&quot;); // user's preferred locale
    std::cout &lt;&lt; &quot;Your currency string is &quot;
              &lt;&lt; std::use_facet&lt;std::moneypunct&lt;char, true&gt;&gt;(loc).curr_symbol() &lt;&lt; '\n';
}
 | output=
Your currency string is USD
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc locale}}
{{dsc inc | cpp/locale/dsc has_facet}}
{{dsc end}}

[[de:cpp/locale/use facet]]
[[es:cpp/locale/use facet]]
[[fr:cpp/locale/use facet]]
[[it:cpp/locale/use facet]]
[[ja:cpp/locale/use facet]]
[[pt:cpp/locale/use facet]]
[[ru:cpp/locale/use facet]]
[[zh:cpp/locale/use facet]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wbuffer convert</title>
    <ns>0</ns>
    <id>2957</id>
    <revision>
      <id>62760</id>
      <parentid>58234</parentid>
      <timestamp>2013-07-01T23:39:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2075">{{cpp/title | wbuffer_convert}}
{{cpp/locale/wbuffer_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | since=c++11 | 1=
template&lt;class Codecvt,
         class Elem = wchar_t,
         class Tr = std::char_traits&lt;Elem&gt; &gt;
class wbuffer_convert : public std::basic_streambuf&lt;Elem, Tr&gt;
}}
{{dcl end}}

{{lc|std::wbuffer_convert}} is a wrapper over stream buffer of type {{c|std::basic_streambuf&lt;char&gt;}} which gives it the appearance of {{c|std::basic_streambuf&lt;Elem&gt;}}. All I/O performed through {{lc|std::wbuffer_convert}} undergoes character conversion as defined by the facet {{tt|Codecvt}}. {{lc|std::wbuffer_convert}} assumes ownership of the conversion facet, and cannot use a facet managed by a locale. The standard facets suitable for use with {{lc|std::wbuffer_convert}} are {{lc|std::codecvt_utf8}} for UTF-8/UCS2 and UTF-8/UCS4 conversions and {{lc|std::codecvt_utf8_utf16}} for UTF-8/UTF-16 conversions.

This class template makes the implicit character conversion functionality of {{lc|std::basic_filebuf}} available for any {{lc|std::basic_streambuf}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|state_type}} | {{tt|Codecvt::state_type}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/wbuffer_convert/dsc wbuffer_convert}}
{{dsc mem fun | nolink=true | operator{{=}} | the copy assignment operator is deleted }}
{{dsc inc | cpp/locale/wbuffer_convert/dsc ~wbuffer_convert}}
{{dsc inc | cpp/locale/wbuffer_convert/dsc rdbuf}}
{{dsc inc | cpp/locale/wbuffer_convert/dsc state}}
{{dsc end}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc inc | cpp/locale/dsc wstring_convert}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/wbuffer convert]]
[[es:cpp/locale/wbuffer convert]]
[[fr:cpp/locale/wbuffer convert]]
[[it:cpp/locale/wbuffer convert]]
[[ja:cpp/locale/wbuffer convert]]
[[pt:cpp/locale/wbuffer convert]]
[[ru:cpp/locale/wbuffer convert]]
[[zh:cpp/locale/wbuffer convert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wbuffer convert/rdbuf</title>
    <ns>0</ns>
    <id>5299</id>
    <revision>
      <id>58235</id>
      <parentid>50079</parentid>
      <timestamp>2013-06-01T06:11:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1861">{{cpp/wbuffer_convert/title|rdbuf}}
{{cpp/locale/wbuffer_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1| 1=
std::streambuf* rdbuf() const;
}}
{{dcl | num=2|1=
std::streambuf* rdbuf( std::streambuf* bytebuf );
}}
{{dcl end}}

1) returns the pointer to the underlying byte stream

2) replaces the associated byte stream with {{tt|bytebuf}}
.

===Return value===
1) the current underlying byte stream

2) the previous byte stream

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;
int main()
{
    // convert UTF-8 to UCS4
    std::stringbuf utf8buf(u8&quot;z\u00df\u6c34\U0001d10b&quot;);  // or u8&quot;zß水𝄋&quot;
                       // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv(&amp;utf8buf);
    std::wistream ucsbuf(&amp;conv);
    std::cout &lt;&lt; &quot;Reading from a UTF-8 stringbuf via wbuffer_convert:\n&quot;;
    for(wchar_t c; ucsbuf.get(c); )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
 
    // reuse the same wbuffer_convert to handle UCS4 to UTF-8 output
    conv.rdbuf(std::cout.rdbuf());
    std::wostream out(&amp;conv);
    std::cout &lt;&lt; &quot;Sending UCS4 data to std::cout via wbuffer_convert:\n&quot;;
    out &lt;&lt; L&quot;z\u00df\u6c34\U0001d10b\n&quot;;
}
 | output=
Reading from a UTF-8 stringbuf via wbuffer_convert:
0x7a
0xdf
0x6c34
0x1d10b
Sending UCS4 data to std::cout via wbuffer_convert:
zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wbuffer_convert/dsc wbuffer_convert}}
{{dsc end}}

[[de:cpp/locale/wbuffer convert/rdbuf]]
[[es:cpp/locale/wbuffer convert/rdbuf]]
[[fr:cpp/locale/wbuffer convert/rdbuf]]
[[it:cpp/locale/wbuffer convert/rdbuf]]
[[ja:cpp/locale/wbuffer convert/rdbuf]]
[[pt:cpp/locale/wbuffer convert/rdbuf]]
[[ru:cpp/locale/wbuffer convert/rdbuf]]
[[zh:cpp/locale/wbuffer convert/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wbuffer convert/state</title>
    <ns>0</ns>
    <id>5200</id>
    <revision>
      <id>58236</id>
      <parentid>50080</parentid>
      <timestamp>2013-06-01T06:11:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="941">{{cpp/wbuffer_convert/title|state}}
{{cpp/locale/wbuffer_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
state_type state() const;
}}
{{dcl end}}

Returns the current value of the conversion state, which is stored in this {{tt|wbuffer_convert}} object. The conversion state may be explicitly set in the constructor and is updated by all conversion operations.

===Return value===
The current conversion state.

===Example===

{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc state}}
{{dsc inc | cpp/string/multibyte/dsc mbsinit}}
{{dsc end}}

[[de:cpp/locale/wbuffer convert/state]]
[[es:cpp/locale/wbuffer convert/state]]
[[fr:cpp/locale/wbuffer convert/state]]
[[it:cpp/locale/wbuffer convert/state]]
[[ja:cpp/locale/wbuffer convert/state]]
[[pt:cpp/locale/wbuffer convert/state]]
[[ru:cpp/locale/wbuffer convert/state]]
[[zh:cpp/locale/wbuffer convert/state]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wbuffer convert/wbuffer convert</title>
    <ns>0</ns>
    <id>5198</id>
    <revision>
      <id>64465</id>
      <parentid>64464</parentid>
      <timestamp>2013-08-17T23:57:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>actually, I think 🍌 looks better than the tiny 𝄋 when illustrating post-16bit unicode chars</comment>
      <text xml:space="preserve" bytes="2528">{{cpp/wbuffer_convert/title|wbuffer_convert}}
{{cpp/locale/wbuffer_convert/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
explicit wbuffer_convert( std::streambuf* bytebuf = 0,
                          Codecvt* pcvt = new Codecvt,
                          state_type state = state_type() );
}}
{{dcl | num=2 | since=c++14 | 1=
wbuffer_convert(const std::wbuffer_convert&amp;) = delete;
}}
{{dcl end}}

@1@ Constructs the {{tt|wbuffer_convert}} object with the specified underlying byte stream, specified {{tt|codecvt}} facet, and specified initial conversion state (all parameters are optional)
@2@ The copy constructor is deleted, {{tt|wbuffer_convert}} is not {{concept|CopyConstructible}}

===Parameters===
{{par begin}}
{{par | bytebuf | pointer to std::streambuf to serve as the underlying narrow character stream }}
{{par | pcvt | pointer to a standalone (not managed by a locale) {{lc|std::codecvt}} facet. The behavior is undefined if this pointer is null.}}
{{par | state | the initial value of the character conversion state}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;
int main()
{
    // wrap a UTF-8 string stream in a UCS4 wbuffer_convert
    std::stringbuf utf8buf(u8&quot;z\u00df\u6c34\U0001f34c&quot;);  // or u8&quot;zß水🍌&quot;
                       // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9f\x8d\x8c&quot;;
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv_in(&amp;utf8buf);
    std::wistream ucsbuf(&amp;conv_in);
    std::cout &lt;&lt; &quot;Reading from a UTF-8 stringbuf via wbuffer_convert:\n&quot;;
    for(wchar_t c; ucsbuf.get(c); )
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';

    // wrap a UTF-8 aware std::cout in a UCS4 wbuffer_convert to output UCS4
    std::wbuffer_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv_out(std::cout.rdbuf());
    std::wostream out(&amp;conv_out);
    std::cout &lt;&lt; &quot;Sending UCS4 data to std::cout via wbuffer_convert:\n&quot;;
    out &lt;&lt; L&quot;z\u00df\u6c34\U0001f34c\n&quot;;
}
 | output=
Reading from a UTF-8 stringbuf via wbuffer_convert produces
0x7a
0xdf
0x6c34
0x1f34c
Sending UCS4 data to std::cout via wbuffer_convert:
zß水🍌
}}

[[de:cpp/locale/wbuffer convert/wbuffer convert]]
[[es:cpp/locale/wbuffer convert/wbuffer convert]]
[[fr:cpp/locale/wbuffer convert/wbuffer convert]]
[[it:cpp/locale/wbuffer convert/wbuffer convert]]
[[ja:cpp/locale/wbuffer convert/wbuffer convert]]
[[pt:cpp/locale/wbuffer convert/wbuffer convert]]
[[ru:cpp/locale/wbuffer convert/wbuffer convert]]
[[zh:cpp/locale/wbuffer convert/wbuffer convert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wbuffer convert/~wbuffer convert</title>
    <ns>0</ns>
    <id>5300</id>
    <revision>
      <id>58239</id>
      <parentid>50082</parentid>
      <timestamp>2013-06-01T06:11:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2183">{{cpp/wbuffer_convert/title|~wbuffer_convert}}
{{cpp/locale/wbuffer_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
~wbuffer_convert();
}}
{{dcl end}}

Destroys the wbuffer_convert object and deletes the pointer to the conversion facet.

===Notes===
Some implementations are able to delete any facet, including the locale-specific facets with protected destructors. Other implementations require the facet to have a public destructor, similar to the the locale-independent facets from {{tt|&lt;codecvt&gt;}}. 

===Example===

{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;utility&gt;
#include &lt;iostream&gt;
#include &lt;codecvt&gt;

// utility wrapper to adapt locale-bound facets for wstring/wbuffer convert
template&lt;class Facet&gt;
struct deletable_facet : Facet
{
    template&lt;class ...Args&gt;
    deletable_facet(Args&amp;&amp; ...args) : Facet(std::forward&lt;Args&gt;(args)...) {}
    ~deletable_facet() {}
};

int main()
{
    // GB18030 / UCS4 conversion, using locale-based facet directly
    // typedef std::codecvt_byname&lt;char32_t, char, std::mbstate_t&gt; gbfacet_t;
    // Compiler error: &quot;calling a protected destructor of codecvt_byname&lt;&gt; in ~wbuffer_convert&quot;
    // std::wbuffer_convert&lt;gbfacet_t, char32_t&gt; gbto32(std::cout.rdbuf(),
    //                                        new gbfacet_t(&quot;zh_CN.gb18030&quot;));

    // GB18030 / UCS4 conversion facet using a facet with public destructor
    typedef deletable_facet&lt;std::codecvt_byname&lt;char32_t, char, std::mbstate_t&gt;&gt; gbfacet_t;
    std::wbuffer_convert&lt;gbfacet_t, char32_t&gt; gbto32(std::cout.rdbuf(),
                                           new gbfacet_t(&quot;zh_CN.gb18030&quot;));
} // destructor called here
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc ~wstring_convert}}
{{dsc end}}

[[de:cpp/locale/wbuffer convert/~wbuffer convert]]
[[es:cpp/locale/wbuffer convert/~wbuffer convert]]
[[fr:cpp/locale/wbuffer convert/~wbuffer convert]]
[[it:cpp/locale/wbuffer convert/~wbuffer convert]]
[[ja:cpp/locale/wbuffer convert/~wbuffer convert]]
[[pt:cpp/locale/wbuffer convert/~wbuffer convert]]
[[ru:cpp/locale/wbuffer convert/~wbuffer convert]]
[[zh:cpp/locale/wbuffer convert/~wbuffer convert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert</title>
    <ns>0</ns>
    <id>2956</id>
    <revision>
      <id>62762</id>
      <parentid>58240</parentid>
      <timestamp>2013-07-01T23:39:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2230">{{cpp/title | wstring_convert}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | since=c++11 | 1=
template&lt; class Codecvt,
          class Elem = wchar_t,
          class Wide_alloc = std::allocator&lt;Elem&gt;,
          class Byte_alloc = std::allocator&lt;char&gt; &gt;
class wstring_convert;
}}
{{dcl end}}

Class template {{lc|std::wstring_convert}} performs conversions between byte string {{lc|std::string}} and wide string {{c|std::basic_string&lt;Elem&gt;}}, using an individual code conversion facet {{tt|Codecvt}}. {{lc|std::wstring_convert}} assumes ownership of the conversion facet, and cannot use a facet managed by a locale. The standard facets suitable for use with {{lc|std::wstring_convert}} are {{lc|std::codecvt_utf8}} for UTF-8/UCS2 and UTF-8/UCS4 conversions and {{lc|std::codecvt_utf8_utf16}} for UTF-8/UTF-16 conversions.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|byte_string}} | {{tt|std::basic_string&lt;char, char_traits&lt;char&gt;, Byte_alloc&gt;}}}}
{{dsc | {{tt|wide_string}} | {{tt|std::basic_string&lt;Elem, char_traits&lt;Elem&gt;, Wide_alloc&gt;}}}}
{{dsc | {{tt|state_type}} | {{tt|Codecvt::state_type}}}}
{{dsc | {{tt|int_type}} | {{tt|wide_string::traits_type::int_type}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc wstring_convert}}
{{dsc mem fun | nolink=true | operator{{=}} | the copy assignment operator is deleted }}
{{dsc inc | cpp/locale/wstring_convert/dsc ~wstring_convert}}
{{dsc inc | cpp/locale/wstring_convert/dsc from_bytes}}
{{dsc inc | cpp/locale/wstring_convert/dsc to_bytes}}
{{dsc inc | cpp/locale/wstring_convert/dsc converted}}
{{dsc inc | cpp/locale/wstring_convert/dsc state}}
{{dsc end}}

===See also===
{{cpp/locale/unicode string conversions}}
{{dsc begin}}
{{dsc inc | cpp/locale/dsc wbuffer_convert}}
{{dsc inc | cpp/locale/dsc codecvt_utf8}}
{{dsc inc | cpp/locale/dsc codecvt_utf8_utf16}}
{{dsc end}}

[[de:cpp/locale/wstring convert]]
[[es:cpp/locale/wstring convert]]
[[fr:cpp/locale/wstring convert]]
[[it:cpp/locale/wstring convert]]
[[ja:cpp/locale/wstring convert]]
[[pt:cpp/locale/wstring convert]]
[[ru:cpp/locale/wstring convert]]
[[zh:cpp/locale/wstring convert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/converted</title>
    <ns>0</ns>
    <id>5189</id>
    <revision>
      <id>64834</id>
      <parentid>64462</parentid>
      <timestamp>2013-08-27T01:18:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1990">{{cpp/wstring_convert/title|converted}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
std::size_t converted() const;
}}
{{dcl end}}

Returns the number of source characters that were processed by the most recent {{lc|from_bytes()}} or {{lc|to_bytes()}}.

===Return value===
The number of characters consumed by the most recent conversion operation.

===Exceptions===
{{rev begin}}
{{rev | until=c++14 | (none)}}
{{rev | since=c++14 | {{noexcept}}}}
{{rev end}}

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;
int main()
{
    std::string utf8 =  u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                        // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    std::cout &lt;&lt; &quot;original UTF-8 string size: &quot; &lt;&lt; utf8.size() &lt;&lt; '\n';

    // the UTF-8 - UTF-32 standard conversion facet
    std::wstring_convert&lt;std::codecvt_utf8&lt;char32_t&gt;, char32_t&gt; cvt;

    // UTF-8 to UTF-32
    std::u32string utf32 = cvt.from_bytes(utf8);
    std::cout &lt;&lt; &quot;UTF-32 string size: &quot; &lt;&lt; utf32.size() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;converted() == &quot; &lt;&lt; cvt.converted() &lt;&lt; '\n';
    // UTF-32 to UTF-8
    utf8 = cvt.to_bytes(utf32);
    std::cout &lt;&lt; &quot;new UTF-8 string size: &quot; &lt;&lt; utf8.size() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;converted() == &quot; &lt;&lt; cvt.converted() &lt;&lt; '\n';
}
| output=
original UTF-8 string size: 10
UTF-32 string size: 4
converted() == 10
new UTF-8 string size: 10
converted() == 4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc to_bytes}}
{{dsc inc | cpp/locale/wstring_convert/dsc from_bytes}}
{{dsc end}}

[[de:cpp/locale/wstring convert/converted]]
[[es:cpp/locale/wstring convert/converted]]
[[fr:cpp/locale/wstring convert/converted]]
[[it:cpp/locale/wstring convert/converted]]
[[ja:cpp/locale/wstring convert/converted]]
[[pt:cpp/locale/wstring convert/converted]]
[[ru:cpp/locale/wstring convert/converted]]
[[zh:cpp/locale/wstring convert/converted]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/from bytes</title>
    <ns>0</ns>
    <id>5182</id>
    <revision>
      <id>64249</id>
      <parentid>62464</parentid>
      <timestamp>2013-08-15T16:02:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="3319">{{cpp/wstring_convert/title|from_bytes}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
wide_string from_bytes( char byte );
}}
{{dcl | num=2 | 1=
wide_string from_bytes( const char* ptr );
}}
{{dcl | num=3 | 1=
wide_string from_bytes( const byte_string&amp; str );
}}
{{dcl | num=4 | 1=
wide_string from_bytes( const char* first, const char* last);
}}
{{dcl end}}

Performs multibyte to wide conversion, using the codecvt facet supplied at construction.

1) Converts {{tt|byte}} as if it was a string of length {{c|1}} to wide_string

2) Converts the null-terminated multibyte character sequence beginning at the character pointed to by {{tt|ptr}} to wide_string

3) Converts the narrow string {{tt|str}} to wide_string.

4) Converts the narrow multibyte character sequence {{tt|[first, last)}} to wide_string

In all cases, the conversion begins in initial shift state, unless non-initial starting state was provided to this {{tt|wstring_convert}} constructor. The number of characters converted and the final value of the conversion state are remembered and can be accessed with {{lc|state()}} and {{lc|converted()}}

===Return value===
A {{tt|wide_string}} object containing the results of multibyte to wide conversion. If the conversion failed and there was a user-supplied wide-error string provided to the constructor of this {{tt|wstring_convert}}, returns that wide-error string.

===Exceptions===
If this {{tt|wstring_convert}} object was constructed without a user-supplied wide-error string, throws {{lc|std::range_error}} on conversion failure.

===Example===

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;

int main()
{
    std::string utf8 =  u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                        // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;

    // the UTF-8 / UTF-16 standard conversion facet
    std::wstring_convert&lt;std::codecvt_utf8_utf16&lt;char16_t&gt;, char16_t&gt; utf16conv;
    std::u16string utf16 = utf16conv.from_bytes(utf8.data());
    std::cout &lt;&lt; &quot;UTF16 conversion produced &quot; &lt;&lt; utf16.size() &lt;&lt; &quot; code points:\n&quot;;
    for (char16_t c : utf16)
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';

    // the UTF-8 / UTF-32 standard conversion facet
    std::wstring_convert&lt;std::codecvt_utf8&lt;char32_t&gt;, char32_t&gt; utf32conv;
    std::u32string utf32 = utf32conv.from_bytes(utf8);
    std::cout &lt;&lt; &quot;UTF32 conversion produced &quot; &lt;&lt; std::dec &lt;&lt; utf32.size() &lt;&lt; &quot; code points:\n&quot;;
    for (char32_t c : utf32)
        std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; c &lt;&lt; '\n';
}
 | output=
UTF16 conversion produced 5 code points:
0x7a
0xdf
0x6c34
0xd834
0xdd0b
UTF32 conversion produced 4 code points:
0x7a
0xdf
0x6c34
0x1d10b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc to_bytes}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc end}}

[[de:cpp/locale/wstring convert/from bytes]]
[[es:cpp/locale/wstring convert/from bytes]]
[[fr:cpp/locale/wstring convert/from bytes]]
[[it:cpp/locale/wstring convert/from bytes]]
[[ja:cpp/locale/wstring convert/from bytes]]
[[pt:cpp/locale/wstring convert/from bytes]]
[[ru:cpp/locale/wstring convert/from bytes]]
[[zh:cpp/locale/wstring convert/from bytes]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/state</title>
    <ns>0</ns>
    <id>5190</id>
    <revision>
      <id>58247</id>
      <parentid>50086</parentid>
      <timestamp>2013-06-01T06:11:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1000">{{cpp/wstring_convert/title|state}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
state_type state() const;
}}
{{dcl end}}

Returns the current value of the conversion state, which is stored in this {{tt|wstring_convert}} object. The conversion state may be explicitly set in the constructor and is updated by all conversion operations.

===Return value===
The current conversion state.

===Example===

{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc to_bytes}}
{{dsc inc | cpp/locale/wstring_convert/dsc from_bytes}}
{{dsc inc | cpp/string/multibyte/dsc mbsinit}}
{{dsc end}}

[[de:cpp/locale/wstring convert/state]]
[[es:cpp/locale/wstring convert/state]]
[[fr:cpp/locale/wstring convert/state]]
[[it:cpp/locale/wstring convert/state]]
[[ja:cpp/locale/wstring convert/state]]
[[pt:cpp/locale/wstring convert/state]]
[[ru:cpp/locale/wstring convert/state]]
[[zh:cpp/locale/wstring convert/state]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/to bytes</title>
    <ns>0</ns>
    <id>5183</id>
    <revision>
      <id>64250</id>
      <parentid>58248</parentid>
      <timestamp>2013-08-15T16:03:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, +lc</comment>
      <text xml:space="preserve" bytes="3311">{{cpp/wstring_convert/title|to_bytes}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | num=1 | 1=
byte_string to_bytes( Elem wchar );
}}
{{dcl | num=2 | 1=
byte_string to_bytes( const Elem* wptr );
}}
{{dcl | num=3 | 1=
byte_string to_bytes( const wide_string&amp; wstr );
}}
{{dcl | num=4 | 1=
byte_string to_bytes( const Elem* first, const Elem* last);
}}
{{dcl end}}

Performs wide to multibyte conversion, using the {{tt|codecvt}} facet supplied at construction.

@1@ Converts {{tt|wchar}} as if it was a string of length {{c|1}}, to {{tt|byte_string}}.

@2@ Converts the null-terminated wide character sequence beginning at the wide character pointed to by {{tt|wptr}}, to {{tt|byte_string}}.

@3@ Converts the wide string {{tt|str}} to {{tt|byte_string}}.

@4@ Converts the wide character sequence {{tt|[first, last)}} to {{tt|byte_string}}.

In all cases, the conversion begins in initial shift state, unless non-initial starting state was provided to this {{tt|wstring_convert}} constructor. The number of characters converted and the final value of the conversion state are remembered and can be accessed with {{lc|state()}} and {{lc|converted()}}

===Return value===
A {{tt|byte_string}} object containing the results of the wide to multibyte conversion. If the conversion failed and there was a user-supplied byte-error string provided to the constructor of this {{tt|wstring_convert}}, returns that byte-error string.

===Exceptions===
If this {{tt|wstring_convert}} object was constructed without a user-supplied byte-error string, throws {{lc|std::range_error}} on conversion failure.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;locale&gt;
#include &lt;codecvt&gt;
#include &lt;iomanip&gt;

// utility function for output
void hex_print(const std::string&amp; s)
{
    std::cout &lt;&lt; std::hex &lt;&lt; std::setfill('0');
    for(unsigned char c : s)
        std::cout &lt;&lt; std::setw(2) &lt;&lt; static_cast&lt;int&gt;(c) &lt;&lt; ' ';
    std::cout &lt;&lt; std::dec &lt;&lt; '\n';
}

int main()
{
    // wide character data
    std::wstring wstr =  L&quot;z\u00df\u6c34\U0001d10b&quot;; // or L&quot;zß水𝄋&quot;

    // wide to UTF-8
    std::wstring_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; conv1;
    std::string u8str = conv1.to_bytes(wstr);
    std::cout &lt;&lt; &quot;UTF-8 conversion produced &quot; &lt;&lt; u8str.size() &lt;&lt; &quot; bytes:\n&quot;;
    hex_print(u8str);

    // wide to UTF-16le
    std::wstring_convert&lt;std::codecvt_utf16&lt;wchar_t, 0x10ffff, std::little_endian&gt;&gt; conv2;
    std::string u16str = conv2.to_bytes(wstr);
    std::cout &lt;&lt; &quot;UTF-16le conversion produced &quot; &lt;&lt; u16str.size() &lt;&lt; &quot; bytes:\n&quot;;
    hex_print(u16str);
}
 | output=
UTF-8 conversion produced 10 bytes:
7a c3 9f e6 b0 b4 f0 9d 84 8b 
UTF-16le conversion produced 10 bytes:
7a 00 df 00 34 6c 34 d8 0b dd 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/wstring_convert/dsc from_bytes}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc end}}

[[de:cpp/locale/wstring convert/to bytes]]
[[es:cpp/locale/wstring convert/to bytes]]
[[fr:cpp/locale/wstring convert/to bytes]]
[[it:cpp/locale/wstring convert/to bytes]]
[[ja:cpp/locale/wstring convert/to bytes]]
[[pt:cpp/locale/wstring convert/to bytes]]
[[ru:cpp/locale/wstring convert/to bytes]]
[[zh:cpp/locale/wstring convert/to bytes]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/wstring convert</title>
    <ns>0</ns>
    <id>4574</id>
    <revision>
      <id>69306</id>
      <parentid>68746</parentid>
      <timestamp>2014-04-02T17:30:51Z</timestamp>
      <contributor>
        <ip>146.122.40.175</ip>
      </contributor>
      <comment>simplify deletable_facet constructors</comment>
      <text xml:space="preserve" bytes="2650">{{cpp/wstring_convert/title|wstring_convert}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl | num=1 |1=
explicit wstring_convert( Codecvt* pcvt = new Codecvt );
}}
{{dcl | num=2 |1=
wstring_convert( Codecvt* pcvt, state_type state);
}}
{{dcl | num=3 |1=
explicit wstring_convert( const byte_string&amp; byte_err,
                          const wide_string&amp; wide_err = wide_string() );
}}
{{dcl | num=4 | since=c++14 | 1=
wstring_convert(const std::wstring_convert&amp;) = delete;
}}
{{dcl end}}

@1@ Constructs the {{tt|wstring_convert}} object with a specified conversion facet, using default-constructed values for the shift state and the error strings 
@2@ Constructs the {{tt|wstring_convert}} object with a specified conversion facet and specified shift state, using default-constructed values for the error strings 
@3@ Constructs the {{tt|wstring_convert}} object with specified error strings, using {{c|new Codecvt}} as the conversion facet and the default-constructed {{tt|state_type}} as shift state.
@4@ The copy constructor is deleted, wstring_convert is not {{concept|CopyConstructible}}

===Parameters===
{{par begin}}
{{par | pcvt | pointer to the conversion facet of type {{tt|Codecvt}} (behavior is undefined if this pointer is null)}}
{{par | state | initial value of the conversion shift state}}
{{par | byte_err | narrow string to display on errors}}
{{par | wide_err | wide string to display on errors}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;locale&gt;
#include &lt;utility&gt;
#include &lt;codecvt&gt;

// utility wrapper to adapt locale-bound facets for wstring/wbuffer convert
template&lt;class Facet&gt;
struct deletable_facet : Facet
{
    using Facet::Facet; // inherit constructors
    ~deletable_facet() {}
};

int main()
{
    // UTF-16le / UCS4 conversion
    std::wstring_convert&lt;
         std::codecvt_utf16&lt;char32_t, 0x10ffff, std::little_endian&gt;
    &gt; u16to32;

    // UTF-8 / wide string conversion with custom messages
    std::wstring_convert&lt;std::codecvt_utf8&lt;wchar_t&gt;&gt; u8towide(&quot;Error!&quot;, L&quot;Error!&quot;);

    // GB18030 / wide string conversion facet
    typedef deletable_facet&lt;std::codecvt_byname&lt;wchar_t, char, std::mbstate_t&gt;&gt; F;
    std::wstring_convert&lt;F&gt; gbtowide(new F(&quot;zh_CN.gb18030&quot;));
}
 | output=
}}

[[de:cpp/locale/wstring convert/wstring convert]]
[[es:cpp/locale/wstring convert/wstring convert]]
[[fr:cpp/locale/wstring convert/wstring convert]]
[[it:cpp/locale/wstring convert/wstring convert]]
[[ja:cpp/locale/wstring convert/wstring convert]]
[[pt:cpp/locale/wstring convert/wstring convert]]
[[ru:cpp/locale/wstring convert/wstring convert]]
[[zh:cpp/locale/wstring convert/wstring convert]]</text>
      <sha1>fnw18mn4ahg1kg7w9ztklrjhulqu989</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/locale/wstring convert/~wstring convert</title>
    <ns>0</ns>
    <id>4575</id>
    <revision>
      <id>50089</id>
      <parentid>43010</parentid>
      <timestamp>2013-06-01T03:12:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1976">{{cpp/wstring_convert/title|~wstring_convert}}
{{cpp/locale/wstring_convert/navbar}}
{{dcl begin}}
{{dcl |1=
~wstring_convert();
}}
{{dcl end}}

Destroys the {{tt|wstring_convert}} object and deletes the pointer to the conversion facet.

===Notes===
Some implementations are able to delete any facet, including the locale-specific facets with protected destructors. Other implementations require the facet to have a public destructor, similar to the the locale-independent facets from {{tt|&lt;codecvt&gt;}}. This is [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-closed.html#721 LWG issue 721]

===Example===
{{example
 | code=
#include &lt;locale&gt;
#include &lt;utility&gt;
#include &lt;codecvt&gt;

// utility wrapper to adapt locale-bound facets for wstring/wbuffer convert
template&lt;class Facet&gt;
struct deletable_facet : Facet
{
    template&lt;class ...Args&gt;
    deletable_facet(Args&amp;&amp; ...args) : Facet(std::forward&lt;Args&gt;(args)...) {}
    ~deletable_facet() {}
};

int main()
{
    // GB18030 / UCS4 conversion, using locale-based facet directly
    // typedef std::codecvt_byname&lt;char32_t, char, std::mbstate_t&gt; gbfacet_t;
    // Compiler error: &quot;calling a protected destructor of codecvt_byname&lt;&gt; in ~wstring_convert&quot;
    // std::wstring_convert&lt;gbfacet_t&gt; gbto32(new gbfacet_t(&quot;zh_CN.gb18030&quot;));

    // GB18030 / UCS4 conversion facet using a facet with public destructor
    typedef deletable_facet&lt;std::codecvt_byname&lt;char32_t, char, std::mbstate_t&gt;&gt; gbfacet_t;
    std::wstring_convert&lt;gbfacet_t&gt; gbto32(new gbfacet_t(&quot;zh_CN.gb18030&quot;));
} // destructor called here
 | output=
}}

[[de:cpp/locale/wstring convert/~wstring convert]]
[[es:cpp/locale/wstring convert/~wstring convert]]
[[fr:cpp/locale/wstring convert/~wstring convert]]
[[it:cpp/locale/wstring convert/~wstring convert]]
[[ja:cpp/locale/wstring convert/~wstring convert]]
[[pt:cpp/locale/wstring convert/~wstring convert]]
[[ru:cpp/locale/wstring convert/~wstring convert]]
[[zh:cpp/locale/wstring convert/~wstring convert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory</title>
    <ns>0</ns>
    <id>719</id>
    <revision>
      <id>71013</id>
      <parentid>70957</parentid>
      <timestamp>2014-06-04T18:55:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 70957 by [[Special:Contributions/Newatthis|Newatthis]] ([[User talk:Newatthis|talk]]) wrong library</comment>
      <text xml:space="preserve" bytes="2687">{{title|Dynamic memory management}}
{{cpp/memory/navbar}}

===Smart pointers===

Smart pointers enable automatic, exception-safe, object lifetime management.

{{dsc begin}}
{{dsc header | memory}}
{{dsc h2 | Pointer categories}}
{{dsc inc | cpp/memory/dsc unique_ptr}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc inc | cpp/memory/dsc weak_ptr}}
{{dsc inc | cpp/memory/dsc auto_ptr}}
{{dsc h2 | Helper classes}}
{{dsc inc | cpp/memory/dsc owner_less}}
{{dsc inc | cpp/memory/dsc enable_shared_from_this}}
{{dsc inc | cpp/memory/dsc bad_weak_ptr}}
{{dsc inc | cpp/memory/dsc default_delete}}
{{dsc end}}

===Allocators===

Allocators are class templates encapsulating memory allocation strategy. This allows generic containers to decouple memory management from the data itself.

{{dsc begin}}
{{dsc header | memory}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc allocator_arg_t}}
{{dsc inc | cpp/memory/dsc allocator_arg}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc header | scoped_allocator}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc end}}

===Uninitialized storage===

Several utilities are provided to create and access raw storage

{{dsc begin}}
{{dsc header | memory}}
{{dsc inc | cpp/memory/dsc uninitialized_copy}}
{{dsc inc | cpp/memory/dsc uninitialized_copy_n}}
{{dsc inc | cpp/memory/dsc uninitialized_fill}}
{{dsc inc | cpp/memory/dsc uninitialized_fill_n}}
{{dsc inc | cpp/memory/dsc raw_storage_iterator}}
{{dsc inc | cpp/memory/dsc get_temporary_buffer}}
{{dsc inc | cpp/memory/dsc return_temporary_buffer}}
{{dsc end}}

===Garbage collector support===

{{dsc begin}}
{{dsc header | memory}}
{{dsc inc | cpp/memory/gc/dsc declare_reachable}}
{{dsc inc | cpp/memory/gc/dsc undeclare_reachable}}
{{dsc inc | cpp/memory/gc/dsc declare_no_pointers}}
{{dsc inc | cpp/memory/gc/dsc undeclare_no_pointers}}
{{dsc inc | cpp/memory/gc/dsc pointer_safety}}
{{dsc inc | cpp/memory/gc/dsc get_pointer_safety}}
{{dsc end}}

===Miscellaneous===

{{dsc begin}}
{{dsc header | memory}}
{{dsc inc | cpp/memory/dsc pointer_traits}}
{{dsc inc | cpp/memory/dsc addressof}}
{{dsc inc | cpp/memory/dsc align}}
{{dsc end}}

===[[cpp/memory/c|C-style memory management]]===

Includes e.g. {{lc|std::malloc}}, {{lc|std::free}}

===[[cpp/memory/new | Low level memory management]]===

Includes e.g. [[cpp/memory/new/operator_new|{{tt|operator new}} ]], [[cpp/memory/new/operator_delete| {{tt|operator delete}} ]], {{lc|std::set_new_handler}}

[[de:cpp/memory]]
[[es:cpp/memory]]
[[fr:cpp/memory]]
[[it:cpp/memory]]
[[ja:cpp/memory]]
[[ko:cpp/memory]]
[[pt:cpp/memory]]
[[ru:cpp/memory]]
[[zh:cpp/memory]]</text>
      <sha1>729gawppjvb4ivr09c96t8ru5rahxvw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/addressof</title>
    <ns>0</ns>
    <id>3381</id>
    <revision>
      <id>67885</id>
      <parentid>64902</parentid>
      <timestamp>2014-03-04T04:56:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to SO breakdown of a more serious implementation</comment>
      <text xml:space="preserve" bytes="2067">{{cpp/title|addressof}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 |1=
template&lt; class T &gt;
T* addressof(T&amp; arg);
}}
{{dcl end}}

Obtains the actual address of the object or function {{tt|arg}}, even in presence of overloaded {{tt|operator&amp;}}

===Parameters===
{{par begin}}
{{par | arg | lvalue object or function}}
{{par end}}

===Return value===
Pointer to {{tt|arg}}.

===Exceptions===
{{noexcept}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
T* addressof(T&amp; arg) 
{
    return reinterpret_cast&lt;T*&gt;(
               &amp;const_cast&lt;char&amp;&gt;(
                  reinterpret_cast&lt;const volatile char&amp;&gt;(arg)));
}
}}
Note: the above implementation [http://stackoverflow.com/a/6495205/273767 is oversimplified]

===Example===
{{example
 | operator&amp; may be overloaded for a pointer wrapper class to obtain a pointer to pointer:
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

template&lt;class T&gt;
struct Ptr {
    T* pad; // add pad to show difference between 'this' and 'data'
    T* data;
    Ptr(T* arg) : pad(nullptr), data(arg) 
    {
        std::cout &lt;&lt; &quot;Ctor this = &quot; &lt;&lt; this &lt;&lt; std::endl;
    }

    ~Ptr() { delete data; }
    T** operator&amp;() { return &amp;data; }
};

template&lt;class T&gt;
void f(Ptr&lt;T&gt;* p) 
{
    std::cout &lt;&lt; &quot;Ptr   overload called with p = &quot; &lt;&lt; p &lt;&lt; '\n';
}

void f(int** p) 
{
    std::cout &lt;&lt; &quot;int** overload called with p = &quot; &lt;&lt; p &lt;&lt; '\n';
}

int main() 
{
    Ptr&lt;int&gt; p(new int(42));
    f(&amp;p);                 // calls int** overload
    f(std::addressof(p));  // calls Ptr&lt;int&gt;* overload, (= this)
}
 | output=
Ctor this = 0x7fff59ae6e88
int** overload called with p = 0x7fff59ae6e90
Ptr   overload called with p = 0x7fff59ae6e88
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc inc | cpp/memory/dsc pointer_traits}}
{{dsc end}}

[[de:cpp/memory/addressof]]
[[es:cpp/memory/addressof]]
[[fr:cpp/memory/addressof]]
[[it:cpp/memory/addressof]]
[[ja:cpp/memory/addressof]]
[[pt:cpp/memory/addressof]]
[[ru:cpp/memory/addressof]]
[[zh:cpp/memory/addressof]]</text>
      <sha1>grm8p2dvbvm03virs49fi0i0tw8kc4o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/align</title>
    <ns>0</ns>
    <id>3437</id>
    <revision>
      <id>63332</id>
      <parentid>61653</parentid>
      <timestamp>2013-07-10T01:28:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2656">{{cpp/title|align}}
{{cpp/memory/navbar}}
{{ddcl | since=c++11 | header=memory | 
void* align( std::size_t alignment,
             std::size_t size,
             void*&amp; ptr,
             std::size_t&amp; space );
}}

If it is possible to fit {{tt|size}} bytes of storage aligned by {{tt|alignment}} into the buffer pointed to by {{tt|ptr}} with length {{tt|space}}, the function modifies {{tt|ptr}} to point to the first possible address of such aligned storage and decreases {{tt|space}} by the number of bytes used for alignment. If it is impossible (the buffer is too small), {{tt|align}} does nothing.

===Parameters===
{{par begin}}
{{par | alignment | the desired alignment }}
{{par | size | the size of the storage to be aligned}}
{{par | ptr | pointer to contiguous storage of at least {{tt|space}} bytes}}
{{par | space | the size of the buffer in which to operate}}
{{par end}}

===Return value===
The adjusted value of {{tt|ptr}}, or null pointer value if the space provided is too small.

===Example===
{{example | demonstrates the use of std::align to place objects of different type in memory
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

template &lt;std::size_t N&gt;
struct MyAllocator
{
    char data[N];
    void* p;
    std::size_t sz;
    MyAllocator() : p(data), sz(N) {}
    template &lt;typename T&gt;
    T* aligned_alloc(std::size_t a = alignof(T))
    {
        if (std::align(a, sizeof(T), p, sz))
        {
            T* result = reinterpret_cast&lt;T*&gt;(p);
            p = (char*)p + sizeof(T);
            sz -= sizeof(T);
            return result;
        }
        return nullptr;
    }
};

int main()
{
    MyAllocator&lt;64&gt; a;

    // allocate a char
    char* p1 = a.aligned_alloc&lt;char&gt;();
    if (p1)
        *p1 = 'a';
    std::cout &lt;&lt; &quot;allocated a char at &quot; &lt;&lt; (void*)p1 &lt;&lt; '\n';

    // allocate an int
    int* p2 = a.aligned_alloc&lt;int&gt;();
    if (p2)
        *p2 = 1;
    std::cout &lt;&lt; &quot;allocated an int at &quot; &lt;&lt; (void*)p2 &lt;&lt; '\n';

    // allocate an int, aligned at 32-byte boundary
    int* p3 = a.aligned_alloc&lt;int&gt;(32);
    if (p3)
        *p3 = 2;
    std::cout &lt;&lt; &quot;allocated an int at &quot; &lt;&lt; (void*)p3 &lt;&lt; &quot; (32 byte alignment)\n&quot;;
}
 | p = true
 | output=
allocated a char at 0x2ff21a08
allocated an int at 0x2ff21a0c
allocated an int at 0x2ff21a20 (32 byte alignment)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc alignof}}
{{dsc inc | cpp/language/dsc alignas}}
{{dsc inc | cpp/types/dsc aligned_storage}}
{{dsc end}}

[[de:cpp/memory/align]]
[[es:cpp/memory/align]]
[[fr:cpp/memory/align]]
[[it:cpp/memory/align]]
[[ja:cpp/memory/align]]
[[pt:cpp/memory/align]]
[[ru:cpp/memory/align]]
[[zh:cpp/memory/align]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator</title>
    <ns>0</ns>
    <id>3383</id>
    <revision>
      <id>63632</id>
      <parentid>58256</parentid>
      <timestamp>2013-07-12T03:13:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="4141">{{cpp/title|allocator}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl header| memory}}
{{dcl | num=1 |1=
template&lt; class T &gt;
struct allocator;
}}
{{dcl | num=2 |1=
template&lt;&gt;
struct allocator&lt;void&gt;;
}}
{{dcl end}}

The {{tt|std::allocator}} class template is the default {{concept|Allocator}} used by all standard library containers if no user-specified allocator is provided. The default allocator is stateless, that is, all instances of the given allocator are interchangeable, compare equal and can deallocate memory allocated by any other instance of the same allocator type.

Specialization for {{c|void}} lacks the member typedefs {{tt|reference}}, {{tt|const_reference}}, {{tt|size_type}} and {{tt|difference_type}}. This specialization declares no member functions.

{{rev begin}}
{{rev | until=c++11 | All custom allocators also must be stateless. }}
{{rev | since=c++11 | Custom allocators may contain state. Each container or another allocator-aware object stores an instance of the supplied allocator and controls allocator replacement through {{lc|std::allocator_traits}}. }}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|value_type}} | {{c|T}} }}
{{dsc | {{tt|pointer}} | {{c|T*}}}}
{{dsc | {{tt|const_pointer}} | {{c|const T*}} }}
{{dsc | {{tt|reference}} | {{c|T&amp;}} }}
{{dsc | {{tt|const_reference}} | {{c|const T&amp;}} }}
{{dsc | {{tt|size_type}} | {{lc|std::size_t}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc | {{tt|propagate_on_container_move_assignment}}{{mark c++14}} | {{c|std::true_type}} }}
{{dsc | {{tt|rebind}} | {{c|template&lt; class U &gt; struct rebind { typedef allocator&lt;U&gt; other; };}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc allocator}}
{{dsc inc | cpp/memory/allocator/dsc ~allocator}}
{{dsc inc | cpp/memory/allocator/dsc address}}
{{dsc inc | cpp/memory/allocator/dsc allocate}}
{{dsc inc | cpp/memory/allocator/dsc deallocate}}
{{dsc inc | cpp/memory/allocator/dsc max_size}}
{{dsc inc | cpp/memory/allocator/dsc construct}}
{{dsc inc | cpp/memory/allocator/dsc destroy}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc operator_cmp}}
{{dsc end}}

===Notes===
The member template class {{tt|rebind}} provides a way to obtain an allocator for a different type. For example,

{{rev begin}}
{{rev | until=c++11 | {{tt|std::list&lt;T, A&gt;}} allocates nodes of some internal type {{tt|Node&lt;T&gt;}}, using the allocator {{c|A::rebind&lt;Node&lt;T&gt;&gt;::other}} 
}}
{{rev | since=c++11 | {{tt|std::list&lt;T, A&gt;}} allocates nodes of some internal type {{tt|Node&lt;T&gt;}}, using the allocator {{c|std::allocator_traits&lt;A&gt;::rebind_alloc&lt;Node&lt;T&gt;&gt;}}, which is implemented in terms of {{c|A::rebind&lt;Node&lt;T&gt;&gt;::other}} if A is an {{tt|std::allocator}} 
}}
{{rev end}}

===Example===
{{example | 
| code=
#include &lt;memory&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::allocator&lt;int&gt; a1; // default allocator for ints
    int* a = a1.allocate(10); // space for 10 ints

    a[9] = 7;

    std::cout &lt;&lt; a[9] &lt;&lt; '\n';

    a1.deallocate(a, 10);

    // default allocator for strings
//    std::allocator&lt;std::string&gt; a2;

    // same, but obtained by rebinding from the type of a1
//    decltype(a1)::rebind&lt;std::string&gt;::other a2;
    
    // same, but obtained by rebinding from the type of a1 via allocator_traits
    std::allocator_traits&lt;decltype(a1)&gt;::rebind_alloc&lt;std::string&gt; a2;
    
    std::string* s = a2.allocate(2); // space for 2 string

    a2.construct(s, &quot;foo&quot;);
    a2.construct(s + 1, &quot;bar&quot;);

    std::cout &lt;&lt; s[0] &lt;&lt; ' ' &lt;&lt; s[1] &lt;&lt; '\n';

    a2.destroy(s);
    a2.destroy(s + 1);
    a2.deallocate(s, 2);
}   
| output=
7
foo bar
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/memory/allocator]]
[[es:cpp/memory/allocator]]
[[fr:cpp/memory/allocator]]
[[it:cpp/memory/allocator]]
[[ja:cpp/memory/allocator]]
[[pt:cpp/memory/allocator]]
[[ru:cpp/memory/allocator]]
[[zh:cpp/memory/allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/address</title>
    <ns>0</ns>
    <id>8999</id>
    <revision>
      <id>64875</id>
      <parentid>50094</parentid>
      <timestamp>2013-08-27T01:44:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="844">{{cpp/memory/allocator/title|address}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl | 1=
pointer address( reference x ) const;
}}
{{dcl | 1=
const_pointer address( const_reference x ) const;
}}
{{dcl end}}

Returns the actual address of {{tt|x}} even in presence of overloaded {{c|operator&amp;}}.

===Parameters===
{{par begin}}
{{par | x | the object to acquire address of}}
{{par end}}

===Return value===
The actual address of {{tt|x}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/memory/allocator/address]]
[[es:cpp/memory/allocator/address]]
[[fr:cpp/memory/allocator/address]]
[[it:cpp/memory/allocator/address]]
[[ja:cpp/memory/allocator/address]]
[[pt:cpp/memory/allocator/address]]
[[ru:cpp/memory/allocator/address]]
[[zh:cpp/memory/allocator/address]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/allocate</title>
    <ns>0</ns>
    <id>5693</id>
    <revision>
      <id>58259</id>
      <parentid>50095</parentid>
      <timestamp>2013-06-01T06:11:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1309">{{cpp/memory/allocator/title|allocate}}
{{cpp/memory/allocator/navbar}}
{{ddcl | 1=
pointer allocate( size_type n, std::allocator&lt;void&gt;::const_pointer hint = 0 );
}}

Allocates {{c|n * sizeof(T)}} bytes of uninitialized storage by calling {{c|::operator new(std::size_t)}}, but it is unspecified when and how this function is called. The pointer {{tt|hint}} may be used to provide locality of reference: the allocator, if supported by the implementation, will attempt to allocate the new memory block as close as possible to {{tt|hint}}.

===Parameters===
{{par begin}}
{{par | n | the number of objects to allocate storage for }}
{{par | hint | pointer to a nearby memory location }}
{{par end}}

===Return value===
Pointer to the first byte of a memory block suitably aligned and sufficient to hold an array of {{tt|n}} objects of type {{tt|T}}.

===Exceptions===
Throws {{lc|std::bad_alloc}} if allocation fails.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc allocate}}
{{dsc end}}

[[de:cpp/memory/allocator/allocate]]
[[es:cpp/memory/allocator/allocate]]
[[fr:cpp/memory/allocator/allocate]]
[[it:cpp/memory/allocator/allocate]]
[[ja:cpp/memory/allocator/allocate]]
[[pt:cpp/memory/allocator/allocate]]
[[ru:cpp/memory/allocator/allocate]]
[[zh:cpp/memory/allocator/allocate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/allocator</title>
    <ns>0</ns>
    <id>8997</id>
    <revision>
      <id>50096</id>
      <parentid>42962</parentid>
      <timestamp>2013-06-01T03:12:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="793">{{cpp/memory/allocator/title|allocator}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl| num=1 | 1=
allocator();
}}
{{dcl| num=2 | 1=
allocator( const allocator&amp; other );
}}
{{dcl| num=3 | 1=
template&lt; class U &gt; 
allocator( const allocator&lt;U&gt;&amp; other );
}}
{{dcl end}}

Constructs the default allocator. Since the default allocator is stateless, the constructors have no visible effect.

===Parameters===
{{par begin}}
{{par | other | another allocator to construct with}}
{{par end}}

[[de:cpp/memory/allocator/allocator]]
[[es:cpp/memory/allocator/allocator]]
[[fr:cpp/memory/allocator/allocator]]
[[it:cpp/memory/allocator/allocator]]
[[ja:cpp/memory/allocator/allocator]]
[[pt:cpp/memory/allocator/allocator]]
[[ru:cpp/memory/allocator/allocator]]
[[zh:cpp/memory/allocator/allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/construct</title>
    <ns>0</ns>
    <id>5671</id>
    <revision>
      <id>61902</id>
      <parentid>58260</parentid>
      <timestamp>2013-06-09T16:40:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="1249">{{cpp/memory/allocator/title|construct}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl rev begin}}
{{dcl | until=c++11 |
void construct( pointer p, const_reference val );
}}
{{dcl | since=c++11 |
template&lt; class U, class... Args &gt;
void construct( U* p, Args&amp;&amp;... args );
}}
{{dcl rev end}}
{{dcl end}}

Constructs an object of type {{tt|T}} in allocated uninitialized storage pointed to by {{tt|p}}, using placement-new

1) Calls {{c|new((void *)p) T(val)}}

2) Calls {{c|::new((void *)p) U(std::forward&lt;Args&gt;(args)...)}}

===Parameters===
{{par begin}}
{{par | p | pointer to allocated uninitialized storage }}
{{par | val | the value to use as the copy constructor argument }}
{{par | args... | the constructor arguments to use}}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc construct}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc end}}

[[de:cpp/memory/allocator/construct]]
[[es:cpp/memory/allocator/construct]]
[[fr:cpp/memory/allocator/construct]]
[[it:cpp/memory/allocator/construct]]
[[ja:cpp/memory/allocator/construct]]
[[pt:cpp/memory/allocator/construct]]
[[ru:cpp/memory/allocator/construct]]
[[zh:cpp/memory/allocator/construct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/deallocate</title>
    <ns>0</ns>
    <id>5713</id>
    <revision>
      <id>66680</id>
      <parentid>64187</parentid>
      <timestamp>2013-12-24T07:43:12Z</timestamp>
      <contributor>
        <ip>93.221.80.155</ip>
      </contributor>
      <text xml:space="preserve" bytes="1180">{{cpp/memory/allocator/title|deallocate}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl|1=
void deallocate( pointer p, size_type n );
}}
{{dcl end}}

Deallocates the storage referenced by the pointer {{tt|p}}, which must be a pointer obtained by an earlier call to {{lc|allocate()}}. The argument {{tt|n}} must be equal to the first argument of the call to {{lc|allocate()}} that originally produced {{tt|p}}.

Calls {{c|::operator delete(void*)}}, but it is unspecified when and how it is called.

===Parameters===
{{par begin}}
{{par | p | pointer obtained from {{tt|allocate()}} }}
{{par | n | number of objects earlier passed to {{tt|allocate()}} }}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc allocate}}
{{dsc inc | cpp/memory/allocator_traits/dsc deallocate}}
{{dsc end}}

[[de:cpp/memory/allocator/deallocate]]
[[es:cpp/memory/allocator/deallocate]]
[[fr:cpp/memory/allocator/deallocate]]
[[it:cpp/memory/allocator/deallocate]]
[[ja:cpp/memory/allocator/deallocate]]
[[pt:cpp/memory/allocator/deallocate]]
[[ru:cpp/memory/allocator/deallocate]]
[[zh:cpp/memory/allocator/deallocate]]</text>
      <sha1>gxb4ikjkb4jqz6moix5lklp98d95rg7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/destroy</title>
    <ns>0</ns>
    <id>5690</id>
    <revision>
      <id>61901</id>
      <parentid>58264</parentid>
      <timestamp>2013-06-09T16:40:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="910">{{cpp/memory/allocator/title|destroy}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl rev begin}}
{{dcl | until=c++11 |
void destroy( pointer p );
}}
{{dcl | since=c++11 |
template&lt; class U &gt;
void destroy( U* p );
}}
{{dcl rev end}}
{{dcl end}}

Calls the destructor of the object pointed to by {{tt|p}}

@1@ Calls {{c|((T*)p)-&gt;~T()}}
@2@ Calls {{c|p-&gt;~U()}}

===Parameters===
{{par begin}}
{{par | p | pointer to the object that is going to be destroyed }}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc destroy}}
{{dsc end}}

[[de:cpp/memory/allocator/destroy]]
[[es:cpp/memory/allocator/destroy]]
[[fr:cpp/memory/allocator/destroy]]
[[it:cpp/memory/allocator/destroy]]
[[ja:cpp/memory/allocator/destroy]]
[[pt:cpp/memory/allocator/destroy]]
[[ru:cpp/memory/allocator/destroy]]
[[zh:cpp/memory/allocator/destroy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/max size</title>
    <ns>0</ns>
    <id>5717</id>
    <revision>
      <id>64852</id>
      <parentid>58265</parentid>
      <timestamp>2013-08-27T01:27:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="951">{{cpp/memory/allocator/title|max_size}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl|1=
size_type max_size() const
}}
{{dcl end}}

Returns the maximum theoretically possible value of {{tt|n}}, for which the call {{tt|allocate(n, 0)}} could succeed. 

In most implementations, this returns {{c|std::numeric_limits&lt;size_type&gt;::max()}}.

===Parameters===
(none)

===Return value===
The maximum supported allocation size

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc max_size}}
{{dsc end}}

[[de:cpp/memory/allocator/max size]]
[[es:cpp/memory/allocator/max size]]
[[fr:cpp/memory/allocator/max size]]
[[it:cpp/memory/allocator/max size]]
[[ja:cpp/memory/allocator/max size]]
[[pt:cpp/memory/allocator/max size]]
[[ru:cpp/memory/allocator/max size]]
[[zh:cpp/memory/allocator/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/operator cmp</title>
    <ns>0</ns>
    <id>9000</id>
    <revision>
      <id>64876</id>
      <parentid>50101</parentid>
      <timestamp>2013-08-27T01:44:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1091">{{title|1=operator==,!={{small|(std::allocator)}}}}
{{cpp/memory/allocator/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class T1, class T2 &gt;
bool operator==( const allocator&lt;T1&gt;&amp; lhs, const allocator&lt;T2&gt;&amp; rhs );
}}
{{dcl | 1=
template&lt; class T1, class T2 &gt;
bool operator!=( const allocator&lt;T1&gt;&amp; lhs, const allocator&lt;T2&gt;&amp; rhs );
}}
{{dcl end}}

Compares two default allocators. Since default allocators are stateless, two default allocators are always equal.

@1@ Returns {{c|true}}
@2@ Returns {{c|false}}

===Parameters===
{{par begin}}
{{par | lhs, rhs | default allocators to compare}}
{{par end}}

===Return value===
@1@ {{c|true}}
@2@ {{c|false}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/memory/allocator/operator cmp]]
[[es:cpp/memory/allocator/operator cmp]]
[[fr:cpp/memory/allocator/operator cmp]]
[[it:cpp/memory/allocator/operator cmp]]
[[ja:cpp/memory/allocator/operator cmp]]
[[pt:cpp/memory/allocator/operator cmp]]
[[ru:cpp/memory/allocator/operator cmp]]
[[zh:cpp/memory/allocator/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator/~allocator</title>
    <ns>0</ns>
    <id>8998</id>
    <revision>
      <id>42923</id>
      <parentid>37868</parentid>
      <timestamp>2012-11-03T00:54:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="445">{{cpp/memory/allocator/title|~allocator}}
{{cpp/memory/allocator/navbar}}
{{ddcl |
~allocator();
}}

Destroys the default allocator.

[[de:cpp/memory/allocator/~allocator]]
[[es:cpp/memory/allocator/~allocator]]
[[fr:cpp/memory/allocator/~allocator]]
[[it:cpp/memory/allocator/~allocator]]
[[ja:cpp/memory/allocator/~allocator]]
[[pt:cpp/memory/allocator/~allocator]]
[[ru:cpp/memory/allocator/~allocator]]
[[zh:cpp/memory/allocator/~allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator arg</title>
    <ns>0</ns>
    <id>3385</id>
    <revision>
      <id>62765</id>
      <parentid>58268</parentid>
      <timestamp>2013-07-01T23:39:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="882">{{cpp/title|allocator_arg}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 |1=
constexpr std::allocator_arg_t allocator_arg = std::allocator_arg_t();
}}
{{dcl end}}

{{tt|std::allocator_arg}} is a constant of type {{lc|std::allocator_arg_t}} used to disambiguate, at call site, the overloads of the constructors and member functions of allocator-aware objects, such as {{lc|std::tuple}}, {{lc|std::function}}, {{lc|std::promise}}, and {{lc|std::packaged_task}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_arg_t}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/memory/allocator arg]]
[[es:cpp/memory/allocator arg]]
[[fr:cpp/memory/allocator arg]]
[[it:cpp/memory/allocator arg]]
[[ja:cpp/memory/allocator arg]]
[[pt:cpp/memory/allocator arg]]
[[ru:cpp/memory/allocator arg]]
[[zh:cpp/memory/allocator arg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator arg t</title>
    <ns>0</ns>
    <id>3384</id>
    <revision>
      <id>62766</id>
      <parentid>58269</parentid>
      <timestamp>2013-07-01T23:39:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="812">{{cpp/title|allocator_arg_t}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 |1=
struct allocator_arg_t {};
}}
{{dcl end}}

{{tt|std::allocator_arg_t}} is an empty class type used to disambiguate the overloads of constructors and member functions of allocator-aware objects, including {{lc|std::tuple}}, {{lc|std::function}}, {{lc|std::promise}}, and {{lc|std::packaged_task}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_arg}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/memory/allocator arg t]]
[[es:cpp/memory/allocator arg t]]
[[fr:cpp/memory/allocator arg t]]
[[it:cpp/memory/allocator arg t]]
[[ja:cpp/memory/allocator arg t]]
[[pt:cpp/memory/allocator arg t]]
[[ru:cpp/memory/allocator arg t]]
[[zh:cpp/memory/allocator arg t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits</title>
    <ns>0</ns>
    <id>3380</id>
    <revision>
      <id>63333</id>
      <parentid>58284</parentid>
      <timestamp>2013-07-10T01:28:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3235">{{cpp/title|allocator_traits}}
{{cpp/memory/allocator_traits/navbar}}

{{ddcl | header=memory | since=c++11 | 
template&lt; class Alloc &gt;
struct allocator_traits;
}}

The {{tt|allocator_traits}} class template provides the standardized way to access various properties of allocators. The standard containers and other standard library components access allocators through this template, which makes it possible to use any class type as an allocator, as long as the user-provided specialization of {{tt|allocator_traits}} implements all required functionality.

The default, non-specialized, {{tt|allocator_traits}} contains the following members:

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|allocator_type}} | {{c|Alloc}} }}
{{dsc | {{tt|value_type}} | {{c|Alloc::value_type}} }}
{{dsc | {{tt|pointer}} | {{c|Alloc::pointer}} if present, otherwise {{c|value_type*}} }}
{{dsc | {{tt|const_pointer}} | {{c|Alloc::const_pointer}} if present, otherwise {{c|std::pointer_traits&lt;pointer&gt;::rebind&lt;const value_type&gt;}} }}
{{dsc | {{tt|void_pointer}} | {{c|Alloc::void_pointer}} if present, otherwise {{c|std::pointer_traits&lt;pointer&gt;::rebind&lt;void&gt;}} }}
{{dsc | {{tt|const_void_pointer}} | {{c|Alloc::const_void_pointer}} if present, otherwise {{c|std::pointer_traits&lt;pointer&gt;::rebind&lt;const void&gt;}} }}
{{dsc | {{tt|difference_type}} | {{c|Alloc::difference_type}} if present, otherwise {{c|std::pointer_traits&lt;pointer&gt;::difference_type}} }}
{{dsc | {{tt|size_type}} | {{c|Alloc::size_type}} if present, otherwise {{c|std::make_unsigned&lt;difference_type&gt;::type}} }}
{{dsc | {{tt|propagate_on_container_copy_assignment}} | {{c|Alloc::propagate_on_container_copy_assignment}} if present, otherwise {{lc|std::false_type}} }}
{{dsc | {{tt|propagate_on_container_move_assignment}} | {{c|Alloc::propagate_on_container_move_assignment}} if present, otherwise {{lc|std::false_type}} }}
{{dsc | {{tt|propagate_on_container_swap}} | {{c|Alloc::propagate_on_container_swap}} if present, otherwise {{lc|std::false_type}} }}
{{dsc end}}

===Member alias templates===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|rebind_alloc&lt;T&gt;}} | {{c|Alloc::rebind&lt;T&gt;::other}} if present, otherwise {{c|Alloc&lt;T, Args&gt;}} if this Alloc is {{c|Alloc&lt;U, Args&gt;}} }}
{{dsc | {{tt|rebind_traits&lt;T&gt;}} | {{c|std::allocator_traits&lt;rebind_alloc&lt;T&gt;&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc allocate}}
{{dsc inc | cpp/memory/allocator_traits/dsc deallocate}}
{{dsc inc | cpp/memory/allocator_traits/dsc construct}}
{{dsc inc | cpp/memory/allocator_traits/dsc destroy}}
{{dsc inc | cpp/memory/allocator_traits/dsc max_size}}
{{dsc inc | cpp/memory/allocator_traits/dsc select_on_container_copy_construction}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc inc | cpp/memory/dsc pointer_traits}}
{{dsc end}}

[[de:cpp/memory/allocator traits]]
[[es:cpp/memory/allocator traits]]
[[fr:cpp/memory/allocator traits]]
[[it:cpp/memory/allocator traits]]
[[ja:cpp/memory/allocator traits]]
[[pt:cpp/memory/allocator traits]]
[[ru:cpp/memory/allocator traits]]
[[zh:cpp/memory/allocator traits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/allocate</title>
    <ns>0</ns>
    <id>5692</id>
    <revision>
      <id>62767</id>
      <parentid>62398</parentid>
      <timestamp>2013-07-01T23:39:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1373">{{cpp/memory/allocator_traits/title|allocate}}
{{cpp/memory/allocator_traits/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl|num=1 | since=c++11 | 
static pointer allocate( Alloc&amp; a, size_type n );
}}
{{dcl|num=2 | since=c++11 | 
static pointer allocate( Alloc&amp; a, size_type n, const_void_pointer hint );
}}
{{dcl end}}

Uses the allocator {{tt|a}} to allocate {{c|n*sizeof(Alloc::value_type)}} bytes of uninitialized storage.

@1@ Calls {{c|a.allocate(n)}}

@2@ Additionally passes memory locality hint {{tt|hint}}. Calls {{c|a.allocate(n, hint)}} if possible. If not possible (e.g. a has no two-argument member function allocate()), calls {{c|a.allocate(n)}}

===Parameters===
{{par begin}}
{{par | a | allocator to use}}
{{par | n | the number of objects to allocate storage for }}
{{par | hint | pointer to a nearby memory location }}
{{par end}}

===Return value===
The pointer returned by the call to {{tt|a.allocate(n)}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc allocate}}
{{dsc end}}

[[de:cpp/memory/allocator traits/allocate]]
[[es:cpp/memory/allocator traits/allocate]]
[[fr:cpp/memory/allocator traits/allocate]]
[[it:cpp/memory/allocator traits/allocate]]
[[ja:cpp/memory/allocator traits/allocate]]
[[pt:cpp/memory/allocator traits/allocate]]
[[ru:cpp/memory/allocator traits/allocate]]
[[zh:cpp/memory/allocator traits/allocate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/construct</title>
    <ns>0</ns>
    <id>5664</id>
    <revision>
      <id>63334</id>
      <parentid>58288</parentid>
      <timestamp>2013-07-10T01:28:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1605">{{cpp/memory/allocator_traits/title|construct}}
{{cpp/memory/allocator_traits/navbar}}
{{ddcl | header=memory | since=c++11 | 
template&lt; class T, class... Args &gt;
static void construct( Alloc&amp; a, T* p, Args&amp;&amp;... args );
}}

If possible, constructs an object of type {{tt|T}} in allocated uninitialized storage pointed to by {{tt|p}}, by calling

{{c|
a.construct(p, std::forward&lt;Args&gt;(args)...)
}}

If the above is not possible (e.g. {{tt|a}} does not have the member function {{tt|construct()}},), then calls placement-new as

{{c|
    ::new (static_cast&lt;void*&gt;(p)) T(std::forward&lt;Args&gt;(args)...)
}}

===Parameters===
{{par begin}}
{{par | a | allocator to use for construction}}
{{par | args... | the constructor arguments to pass to {{tt|a.construct()}} or to placement-new }}
{{par end}}

===Return value===
(none)

===Notes===
This function is used by the standard library containers when inserting, copying, or moving elements.

Because this function provides the automatic fall back to placement new, the member function {{tt|construct()}} is an optional {{concept|Allocator}} requirement since C++11.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/allocator/dsc construct}}
{{dsc end}}

[[de:cpp/memory/allocator traits/construct]]
[[es:cpp/memory/allocator traits/construct]]
[[fr:cpp/memory/allocator traits/construct]]
[[it:cpp/memory/allocator traits/construct]]
[[ja:cpp/memory/allocator traits/construct]]
[[pt:cpp/memory/allocator traits/construct]]
[[ru:cpp/memory/allocator traits/construct]]
[[zh:cpp/memory/allocator traits/construct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/deallocate</title>
    <ns>0</ns>
    <id>5714</id>
    <revision>
      <id>62768</id>
      <parentid>58289</parentid>
      <timestamp>2013-07-01T23:39:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1080">{{cpp/memory/allocator_traits/title|deallocate}}
{{cpp/memory/allocator_traits/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl| since=c++11 | 
static void deallocate( Alloc&amp; a, pointer p, size_type n );
}}
{{dcl end}}

Uses the allocator {{tt|a}} to deallocate the storage referenced by {{tt|p}}, by calling {{c|a.deallocate(p, n)}}


===Parameters===
{{par begin}}
{{par | a | allocator to use}}
{{par | p | pointer to the previously allocated storage }}
{{par | n | the number of objects the storage was allocated for }}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc allocate}}
{{dsc inc | cpp/memory/allocator/dsc deallocate}}
{{dsc end}}

[[de:cpp/memory/allocator traits/deallocate]]
[[es:cpp/memory/allocator traits/deallocate]]
[[fr:cpp/memory/allocator traits/deallocate]]
[[it:cpp/memory/allocator traits/deallocate]]
[[ja:cpp/memory/allocator traits/deallocate]]
[[pt:cpp/memory/allocator traits/deallocate]]
[[ru:cpp/memory/allocator traits/deallocate]]
[[zh:cpp/memory/allocator traits/deallocate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/destroy</title>
    <ns>0</ns>
    <id>5689</id>
    <revision>
      <id>63335</id>
      <parentid>58290</parentid>
      <timestamp>2013-07-10T01:28:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1254">{{cpp/memory/allocator_traits/title|destroy}}
{{cpp/memory/allocator_traits/navbar}}
{{ddcl | header=memory | since=c++11 | 
template&lt; class T &gt;
static void destroy( Alloc&amp; a, T* p );
}}

Calls the destructor of the object pointed to by {{tt|p}}. If possible, does so by calling {{c|a.destroy(p)}}. If not possible (e.g. {{tt|a}} does not have the member function {{tt|destroy()}}, then calls the destructor of {{tt|*p}} directly, as {{c|p-&gt;~T()}}.

===Parameters===
{{par begin}}
{{par | a | allocator to use for destruction}}
{{par | p | pointer to the object being destroyed }}
{{par end}}

===Return value===
(none)

===Notes===
Because this function provides the automatic fall back to direct call to the destructor, the member function {{tt|destroy()}} is an optional {{concept|Allocator}} requirement since C++11.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc destroy}}
{{dsc end}}

[[de:cpp/memory/allocator traits/destroy]]
[[es:cpp/memory/allocator traits/destroy]]
[[fr:cpp/memory/allocator traits/destroy]]
[[it:cpp/memory/allocator traits/destroy]]
[[ja:cpp/memory/allocator traits/destroy]]
[[pt:cpp/memory/allocator traits/destroy]]
[[ru:cpp/memory/allocator traits/destroy]]
[[zh:cpp/memory/allocator traits/destroy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/max size</title>
    <ns>0</ns>
    <id>5718</id>
    <revision>
      <id>66192</id>
      <parentid>63336</parentid>
      <timestamp>2013-11-09T20:05:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+const (in C++11 was present in 20.8.8, missing in 20.8.8.2, present in both places in C++14)</comment>
      <text xml:space="preserve" bytes="1081">{{cpp/memory/allocator_traits/title|max_size}}
{{cpp/memory/allocator_traits/navbar}}
{{ddcl | header=memory | since=c++11 | 
static size_type max_size( const Alloc&amp; a )
}}

If possible, obtains the maximum theoretically possible allocation size from the allocator {{tt|a}}, by calling

{{c|
a.max_size()
}}

If the above is not possible (e.g. {{tt|a}} does not have the member function {{tt|max_size()}},), then returns

{{c|
    std::numeric_limits&lt;size_type&gt;::max()
}}

===Parameters===
(none)

===Return value===
Theoretical maximum allocation size

===Exceptions===
{{noexcept}} &lt;!-- added between C++11 and C++14 as defect #2162 --&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc max_size}}
{{dsc end}}

[[de:cpp/memory/allocator traits/max size]]
[[es:cpp/memory/allocator traits/max size]]
[[fr:cpp/memory/allocator traits/max size]]
[[it:cpp/memory/allocator traits/max size]]
[[ja:cpp/memory/allocator traits/max size]]
[[pt:cpp/memory/allocator traits/max size]]
[[ru:cpp/memory/allocator traits/max size]]
[[zh:cpp/memory/allocator traits/max size]]</text>
      <sha1>bj3n7thu6epikk3223yr649qc13u9i7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/allocator traits/select on container copy construction</title>
    <ns>0</ns>
    <id>5734</id>
    <revision>
      <id>62769</id>
      <parentid>60994</parentid>
      <timestamp>2013-07-01T23:39:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1741">{{cpp/memory/allocator_traits/title|select_on_container_copy_construction}}
{{cpp/memory/allocator_traits/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl | since=c++11 | 
static Alloc select_on_container_copy_construction( const Alloc&amp; a )
}}
{{dcl end}}

If possible, obtains the copy-constructed version of the allocator {{tt|a}}, by calling {{c|a.select_on_container_copy_construction() }}. If the above is not possible (e.g. {{tt|a}} does not have the member function {{tt|select_on_container_copy_construction()}}, then returns {{c|a}}, unmodified.

This function is called by the copy constructors of all standard library containers. It allows the allocator used by the constructor's argument to become aware that the container is being copied and modify state if necessary.

===Parameters===
{{par begin}}
{{par | a | allocator used by a standard container passed as an argument to a container copy constructor }}
{{par end}}


===Return value===
The allocator to use by the copy-constructed standard containers.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc select_on_container_copy_construction}}
{{dsc end}}

[[de:cpp/memory/allocator traits/select on container copy construction]]
[[es:cpp/memory/allocator traits/select on container copy construction]]
[[fr:cpp/memory/allocator traits/select on container copy construction]]
[[it:cpp/memory/allocator traits/select on container copy construction]]
[[ja:cpp/memory/allocator traits/select on container copy construction]]
[[pt:cpp/memory/allocator traits/select on container copy construction]]
[[ru:cpp/memory/allocator traits/select on container copy construction]]
[[zh:cpp/memory/allocator traits/select on container copy construction]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr</title>
    <ns>0</ns>
    <id>3421</id>
    <revision>
      <id>58297</id>
      <parentid>50111</parentid>
      <timestamp>2013-06-01T06:12:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2299">{{cpp/title|auto_ptr}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | notes={{mark deprecated}} | num=1 | 1=
template&lt; class T &gt; class auto_ptr;
}}
{{dcl | notes={{mark deprecated}} | num=2 | 1=
template&lt;&gt; class auto_ptr&lt;void&gt;
}}
{{dcl end}}

{{tt|auto_ptr}} is a smart pointer that manages an object obtained via new and deletes that object when {{tt|auto_ptr}} itself is destroyed. It may be used to provide exception safety for dynamically-allocated objects, for passing ownership of dynamically-allocated objects into functions and for returning dynamically-allocated objects from functions.

Copying an {{tt|auto_ptr}} copies the pointer and transfers ownership to the destination: both copy construction and copy assignment of {{tt|auto_ptr}} modify their right hand arguments, and the &quot;copy&quot; is not equal to the original. Because of these unusual copy semantics, {{tt|auto_ptr}} may not be placed in standard containers. {{lc|std::unique_ptr}} is preferred for this and other uses.

2) Specialization for type {{c|void}} is provided, it declares the typedef {{tt|element_type}}, but no member functions.

An additional class template {{tt|auto_ptr_ref}} is referred to throughout the documentation. It is an implementation-defined type that holds a reference to {{tt|auto_ptr}}. The implementation is allowed to provide the template with a different name or implement the functions returning it or accepting it as parameter in other ways.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|element_type}} | {{c|T}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/auto_ptr/dsc auto_ptr}}
{{dsc inc | cpp/memory/auto_ptr/dsc ~auto_ptr}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator{{=}}}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator_auto_ptr}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/memory/auto_ptr/dsc get}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator*}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/memory/auto_ptr/dsc reset}}
{{dsc inc | cpp/memory/auto_ptr/dsc release}}
{{dsc end}}

[[de:cpp/memory/auto ptr]]
[[es:cpp/memory/auto ptr]]
[[fr:cpp/memory/auto ptr]]
[[it:cpp/memory/auto ptr]]
[[ja:cpp/memory/auto ptr]]
[[pt:cpp/memory/auto ptr]]
[[ru:cpp/memory/auto ptr]]
[[zh:cpp/memory/auto ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/auto ptr</title>
    <ns>0</ns>
    <id>9574</id>
    <revision>
      <id>71665</id>
      <parentid>70031</parentid>
      <timestamp>2014-06-18T21:35:49Z</timestamp>
      <contributor>
        <ip>88.165.212.193</ip>
      </contributor>
      <comment>presumably a typo, otherwise template parameter Y is unused here</comment>
      <text xml:space="preserve" bytes="1756">{{cpp/memory/auto_ptr/title|auto_ptr}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 | 1=
explicit auto_ptr( X* p = 0 );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
auto_ptr( auto_ptr&amp; r );
}}
{{dcl | notes={{mark deprecated}} | num=3 |
template&lt; class Y &gt;
auto_ptr( auto_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | notes={{mark deprecated}} | num=4 |
template&lt; class Y &gt;
auto_ptr( auto_ptr_ref&lt;Y&gt; m );
}}
{{dcl end}}

Constructs the {{tt|auto_ptr}} from a pointer that refers to the object to manage.

@1@ Constructs the {{tt|auto_ptr}} with pointer {{tt|p}}.

@2@ Constructs the {{tt|auto_ptr}} with the pointer held in {{tt|r}}. {{c|r.release()}} is called to acquire the ownership of the object.

@3@ Same as (2). {{c|Y*}} must be implicitly convertible to {{c|T*}}.

@4@ Constructs the {{tt|auto_ptr}} with the pointer held in the {{tt|auto_ptr}} instance referred to by {{tt|m}}. {{c|p.release()}} is called for the {{tt|auto_ptr p}} that {{tt|m}} holds to acquire the ownership of the object. 

@@ {{tt|auto_ptr_ref}} is an implementation-defined type that holds a reference to {{tt|auto_ptr}}. {{lc|std::auto_ptr}} is implicitly [[cpp/memory/auto_ptr/operator_auto_ptr|convertible to]] and [[cpp/memory/auto_ptr/operator{{=}}|assignable from]] this type. The implementation is allowed to provide the template with a different name or implement equivalent functionality in other ways.

===Parameters===
{{par begin}}
{{par | p | a pointer to an object to manage}}
{{par | r | another {{tt|auto_ptr}} to transfer the ownership of the object from}}
{{par | m | an implementation-defined type that holds a reference to {{tt|auto_ptr}}}}
{{par end}}

===Exceptions===
(none)

===Notes===
{{cpp/memory/auto_ptr/auto_ptr_ref_note}}</text>
      <sha1>457arcrnm8vu0li5g51hjv2qe1wr7b8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/get</title>
    <ns>0</ns>
    <id>9578</id>
    <revision>
      <id>58298</id>
      <parentid>50113</parentid>
      <timestamp>2013-06-01T06:12:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="389">{{cpp/memory/auto_ptr/title|get}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | 
T* get() const;
}}
{{dcl end}}

Returns the pointer that is held by {{c|*this}}.

===Parameters===
(none)

===Return value===
The pointer held by {{c|*this}}.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/auto_ptr/dsc operator*}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/operator*</title>
    <ns>0</ns>
    <id>9577</id>
    <revision>
      <id>58299</id>
      <parentid>50114</parentid>
      <timestamp>2013-06-01T06:12:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="530">{{cpp/memory/auto_ptr/title|operator*|operator-&gt;}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 |
T&amp; operator*() const;
}}
{{dcl | notes={{mark deprecated}} | num=2 |
T* operator-&gt;() const;
}}
{{dcl end}}

Dereferences a pointer to the managed object. The first version requires {{c|1=get() != 0}}.

===Parameters===
(none)

===Return value===
@1@ {{c|*get()}}.

@2@ {{c|get()}}.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/auto_ptr/dsc get}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/operator=</title>
    <ns>0</ns>
    <id>9576</id>
    <revision>
      <id>70033</id>
      <parentid>70029</parentid>
      <timestamp>2014-05-07T16:29:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note on how move semantics are implemented with auto_ptr_ref</comment>
      <text xml:space="preserve" bytes="1348">{{cpp/memory/auto_ptr/title|operator{{=}}}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 | 1=
auto_ptr&amp; operator=( auto_ptr&amp; r );
}}
{{dcl | notes={{mark deprecated}} | num=2 | 1=
template&lt; class Y &gt;
auto_ptr&amp; operator=( auto_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | notes={{mark deprecated}} | num=3 | 1=
auto_ptr&amp; operator=( auto_ptr_ref m );
}}
{{dcl end}}
 
Replaces the managed object with the one managed by {{tt|r}}. 

@1@ Effectively calls {{c|reset(r.release())}}. 

@2@ Effectively calls {{c|reset(r.release())}}. {{c|Y*}} must be implicitly convertible to {{c|T*}}.

@3@ Effectively calls {{c|reset(m.release())}}. {{tt|auto_ptr_ref}} is an implementation-defined type that holds a reference to {{tt|auto_ptr}}. {{lc|std::auto_ptr}} is implicitly [[cpp/memory/auto_ptr/operator_auto_ptr|convertible to]] and [[cpp/memory/auto_ptr/auto_ptr|from]] this type. The implementation is allowed to provide the template with a different name or implement equivalent functionality in other ways.

===Parameters===
{{par begin}}
{{par | r | another {{tt|auto_ptr}} to transfer the ownership of the object from}}
{{par | m | an implementation-defined type that holds a reference to {{tt|auto_ptr}}}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
(none)

===Notes===
{{cpp/memory/auto_ptr/auto_ptr_ref_note}}</text>
      <sha1>mrbhhnbouv3a70c1z04uakcxgus888p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/operator auto ptr</title>
    <ns>0</ns>
    <id>9581</id>
    <revision>
      <id>70035</id>
      <parentid>70028</parentid>
      <timestamp>2014-05-07T16:31:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note on how move semantics are implemented with auto_ptr_ref</comment>
      <text xml:space="preserve" bytes="1087">{{cpp/memory/auto_ptr/title|operator auto_ptr&lt;Y&gt;}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Y &gt;
operator auto_ptr_ref&lt;Y&gt;();
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Y &gt;
operator auto_ptr&lt;Y&gt;();
}}
{{dcl end}}

Converts {{c|*this}} to an {{tt|auto_ptr}} for a different type {{tt|Y}}.

@1@ Returns an implementation-defined type that holds a reference to {{c|*this}}. {{lc|std::auto_ptr}} is [[cpp/memory/auto_ptr/auto_ptr|convertible]] and [[cpp/memory/auto_ptr/operator{{=}}|assignable]] from this template. The implementation is allowed to provide the template with a different name or implement equivalent functionality in other ways.

@2@ Constructs a new {{tt|auto_ptr}} with a pointer obtained by calling {{lc|release()}}.

===Parameters===
(none)

===Return value===
@1@ An implementation-defined type that holds a reference to {{c|*this}}

@2@ A {{tt|auto_ptr}} with a pointer obtained by calling {{lc|release()}}.

===Exceptions===
(none)

===Notes===
{{cpp/memory/auto_ptr/auto_ptr_ref_note}}</text>
      <sha1>7om1agz67mts3cdj50xhfti3tsutp1n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/release</title>
    <ns>0</ns>
    <id>9579</id>
    <revision>
      <id>58302</id>
      <parentid>50117</parentid>
      <timestamp>2013-06-01T06:12:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="396">{{cpp/memory/auto_ptr/title|release}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | 
T* release();
}}
{{dcl end}}

Releases the held pointer. After the call {{c|*this}} holds the null pointer.

===Parameters===
(none)

===Return value===
{{c|get()}}.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/auto_ptr/dsc reset}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/reset</title>
    <ns>0</ns>
    <id>9580</id>
    <revision>
      <id>58303</id>
      <parentid>50118</parentid>
      <timestamp>2013-06-01T06:12:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="511">{{cpp/memory/auto_ptr/title|reset}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | 1= 
void reset( T* p = 0 );
}}
{{dcl end}}

Replaces the held pointer by {{tt|p}}. If the currently held pointer is not null pointer, {{c|delete get()}} is called.

===Parameters===
{{par begin}}
{{par | p | a pointer to an object to manage}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/auto_ptr/dsc release}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/auto ptr/~auto ptr</title>
    <ns>0</ns>
    <id>9575</id>
    <revision>
      <id>50119</id>
      <parentid>44580</parentid>
      <timestamp>2013-06-01T03:13:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="203">{{cpp/memory/auto_ptr/title|~auto_ptr}}
{{cpp/memory/auto_ptr/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} |
~auto_ptr()
}}
{{dcl end}}

Destroys the managed object. Calls {{c|delete get()}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/bad weak ptr</title>
    <ns>0</ns>
    <id>3429</id>
    <revision>
      <id>62770</id>
      <parentid>58304</parentid>
      <timestamp>2013-07-01T23:40:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1332">{{cpp/title|bad_weak_ptr}}
{{cpp/memory/bad_weak_ptr/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 | 1=
class bad_weak_ptr;
}}
{{dcl end}}

{{tt|std::bad_weak_ptr}} is the type of the object thrown as exceptions by the constructors of {{lc|std::shared_ptr}} that take {{lc|std::weak_ptr}} as the argument, when the {{lc|std::weak_ptr}} refers to an already deleted object.

{{inheritance diagram/std-bad_weak_ptr}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/memory/bad_weak_ptr/bad_weak_ptr | constructs the {{tt|bad_weak_ptr}} object}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;
int main()
{
    std::shared_ptr&lt;int&gt; p1(new int(42));
    std::weak_ptr&lt;int&gt; wp(p1);
    p1.reset();
    try {
        std::shared_ptr&lt;int&gt; p2(wp);
    } catch(const std::bad_weak_ptr&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
std::bad_weak_ptr
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc inc | cpp/memory/dsc weak_ptr}}
{{dsc end}}

[[de:cpp/memory/bad weak ptr]]
[[es:cpp/memory/bad weak ptr]]
[[fr:cpp/memory/bad weak ptr]]
[[it:cpp/memory/bad weak ptr]]
[[ja:cpp/memory/bad weak ptr]]
[[pt:cpp/memory/bad weak ptr]]
[[ru:cpp/memory/bad weak ptr]]
[[zh:cpp/memory/bad weak ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/bad weak ptr/bad weak ptr</title>
    <ns>0</ns>
    <id>8987</id>
    <revision>
      <id>64874</id>
      <parentid>42836</parentid>
      <timestamp>2013-08-27T01:43:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="719">{{cpp/memory/bad_weak_ptr/title | bad_weak_ptr}}
{{cpp/memory/bad_weak_ptr/navbar}}
{{ddcl |
bad_weak_ptr();
}}

Constructs new {{tt|bad_weak_ptr}} object. {{ltf|cpp/error/exception/what}} returns {{c|&quot;bad_weak_ptr&quot;}} afterwards.

===Parameters===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/memory/bad weak ptr/bad weak ptr]]
[[es:cpp/memory/bad weak ptr/bad weak ptr]]
[[fr:cpp/memory/bad weak ptr/bad weak ptr]]
[[it:cpp/memory/bad weak ptr/bad weak ptr]]
[[ja:cpp/memory/bad weak ptr/bad weak ptr]]
[[pt:cpp/memory/bad weak ptr/bad weak ptr]]
[[ru:cpp/memory/bad weak ptr/bad weak ptr]]
[[zh:cpp/memory/bad weak ptr/bad weak ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/c</title>
    <ns>0</ns>
    <id>2024</id>
    <revision>
      <id>71025</id>
      <parentid>50121</parentid>
      <timestamp>2014-06-04T19:53:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C with descriptive name</comment>
      <text xml:space="preserve" bytes="696">{{title|C memory management library}}
{{cpp/utility/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | cstdlib}}
{{dsc fun | cpp/memory/c/malloc | allocates memory}}
{{dsc fun | cpp/memory/c/calloc | allocates and zeroes memory}}
{{dsc fun | cpp/memory/c/realloc | expands previously allocated memory block}}
{{dsc fun | cpp/memory/c/free | deallocates previously allocated memory}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/memory | C memory management library}}
{{dsc end}}

[[cs:cpp/memory/c]]
[[de:cpp/memory/c]]
[[es:cpp/memory/c]]
[[fr:cpp/memory/c]]
[[it:cpp/memory/c]]
[[ja:cpp/memory/c]]
[[pl:cpp/memory/c]]
[[pt:cpp/memory/c]]
[[ru:cpp/memory/c]]
[[zh:cpp/memory/c]]</text>
      <sha1>b9tg1rb9lrzqm8np85o9betbav3x0ip</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/c/calloc</title>
    <ns>0</ns>
    <id>2020</id>
    <revision>
      <id>71407</id>
      <parentid>64211</parentid>
      <timestamp>2014-06-10T21:22:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note that all-bits-zero is not zero-initailziation</comment>
      <text xml:space="preserve" bytes="1504">{{cpp/title|calloc}}
{{cpp/memory/c/navbar}}
{{ddcl | header=cstdlib |
void* calloc( std::size_t num, std::size_t size );
}}

Allocates memory for an array of {{tt|num}} objects of size {{tt|size}} and initializes it to all bits zero.

If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any object type.

If {{tt|size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage)

===Parameters===
{{par begin}}
{{par | num | number of objects}}
{{par | size | size of each object}}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or {{lc|NULL}} if error has occurred. The pointer must be deallocated with {{lc|free()}}.

===Notes===
Due to the alignment requirements, the number of allocated bytes is not necessarily equal to {{tt|num*size}}.

Initialization to all bits zero does not guarantee that a floating-point or a pointer would be initialized to 0.0 and the null pointer value, respectively (although that is true on all common platforms)

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc see c | c/memory/calloc}}
{{dsc end}}

[[de:cpp/memory/c/calloc]]
[[es:cpp/memory/c/calloc]]
[[fr:cpp/memory/c/calloc]]
[[it:cpp/memory/c/calloc]]
[[ja:cpp/memory/c/calloc]]
[[pl:cpp/memory/c/calloc]]
[[pt:cpp/memory/c/calloc]]
[[ru:cpp/memory/c/calloc]]
[[zh:cpp/memory/c/calloc]]</text>
      <sha1>90pzssp35c1fod9bcpx2bjs7bv9wqqf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/c/free</title>
    <ns>0</ns>
    <id>2021</id>
    <revision>
      <id>64226</id>
      <parentid>64212</parentid>
      <timestamp>2013-08-15T15:52:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+std</comment>
      <text xml:space="preserve" bytes="1221">{{cpp/title|free}}
{{cpp/memory/c/navbar}}
{{ddcl | header=cstdlib |
void free( void* ptr );
}}

Deallocates the space previously allocated by {{lc|std::malloc()}}, {{lc|std::calloc()}} or {{lc|std::realloc()}}. If {{tt|ptr}} is null-pointer, the function does nothing.

The behavior is undefined if {{tt|ptr}} does not match a pointer returned earlier by {{lc|std::malloc()}}, {{lc|std::calloc()}} or {{lc|std::realloc()}}. Also, the behavior is undefined if the memory area referred to by {{tt|ptr}} has already been deallocated, that is, {{tt|free()}} or {{lc|std::realloc()}} has already been called with {{tt|ptr}} as the argument and no calls to {{lc|std::malloc()}}, {{lc|std::calloc()}} or {{lc|std::realloc()}} resulted in a pointer equal to {{tt|ptr}} afterwards.

===Parameters===
{{par begin}}
{{par | ptr | pointer to the memory to deallocate}}
{{par end}}

===Return value===
(none)

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc see c | c/memory/free}}
{{dsc end}}

[[de:cpp/memory/c/free]]
[[es:cpp/memory/c/free]]
[[fr:cpp/memory/c/free]]
[[it:cpp/memory/c/free]]
[[ja:cpp/memory/c/free]]
[[pl:cpp/memory/c/free]]
[[pt:cpp/memory/c/free]]
[[ru:cpp/memory/c/free]]
[[zh:cpp/memory/c/free]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/c/malloc</title>
    <ns>0</ns>
    <id>2023</id>
    <revision>
      <id>69890</id>
      <parentid>65534</parentid>
      <timestamp>2014-05-01T02:50:46Z</timestamp>
      <contributor>
        <ip>84.52.101.196</ip>
      </contributor>
      <text xml:space="preserve" bytes="1964">{{cpp/title|malloc}}
{{cpp/memory/c/navbar}}
{{ddcl | header=cstdlib |
void* malloc( std::size_t size );
}}

Allocates {{tt|size}} bytes of uninitialized storage.

If allocation succeeds, returns a pointer to the lowest (first) byte in the allocated memory block that is suitably aligned for any scalar type.

If {{tt|size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage)

===Parameters===
{{par begin}}
{{par | size | number of bytes to allocate }}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or null pointer if error has occurred. The pointer must be deallocated with {{lc|std::free()}}.

===Notes===
This function does not call constructors or initialize memory in any way. Thus preferred method of memory allocation is {{ltt|cpp/language/new}} expression.

===Example===
{{example
 |
 | p=true
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;

int main()
{
    // Allocate an array of 4 integers
    int *array = static_cast&lt;int *&gt;(std::malloc(4 * sizeof(int)));

    if (array != nullptr) {
        for (int arrayIdx = 0; arrayIdx &lt; 4; ++arrayIdx) {
            array[arrayIdx] = 2 * ( arrayIdx + 1 );
        }

        for (int arrayIdx = 0; arrayIdx &lt; 4; ++arrayIdx) {
            std::cout &lt;&lt; &quot;Array item &quot; &lt;&lt; ( arrayIdx + 1 ) &lt;&lt; &quot; = &quot; &lt;&lt; array[arrayIdx] &lt;&lt; '\n';
        }
        std::free(array);
    }
}
 | output=
Array item 1 = 2
Array item 2 = 4
Array item 3 = 6
Array item 4 = 8
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/dsc get_temporary_buffer}}
{{dsc see c | c/memory/malloc}}
{{dsc end}}

[[de:cpp/memory/c/malloc]]
[[es:cpp/memory/c/malloc]]
[[fr:cpp/memory/c/malloc]]
[[it:cpp/memory/c/malloc]]
[[ja:cpp/memory/c/malloc]]
[[pl:cpp/memory/c/malloc]]
[[pt:cpp/memory/c/malloc]]
[[ru:cpp/memory/c/malloc]]
[[zh:cpp/memory/c/malloc]]</text>
      <sha1>ei292pwyjro02e5rra0ifwt308nwkpy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/c/realloc</title>
    <ns>0</ns>
    <id>2022</id>
    <revision>
      <id>72292</id>
      <parentid>67167</parentid>
      <timestamp>2014-08-05T10:32:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention Relocatable/BitwiseMovable types (facebook and others use them)</comment>
      <text xml:space="preserve" bytes="2543">{{cpp/title|realloc}}
{{cpp/memory/c/navbar}}
{{ddcl | header=cstdlib |
void* realloc( void* ptr, std::size_t new_size );
}}

Reallocates the given area of memory. It must be previously allocated by {{lc|std::malloc()}}, {{lc|std::calloc()}} or {{tt|std::realloc()}} and not yet freed with {{lc|std::free()}}, otherwise, the results are undefined.

The reallocation is done by either:
@a@ expanding or contracting the existing area pointed to by {{tt|ptr}}, if possible. The contents of the area remain unchanged up to the lesser of the new and old sizes. If the area is expanded, the contents of the new part of the array are undefined. 
@b@ allocating a new memory block of size {{tt|new_size}} bytes, copying memory area with size equal the lesser of the new and the old sizes, and freeing the old block.

If there is not enough memory, the old memory block is not freed and null-pointer is returned.

If {{tt|ptr}} is {{lc|NULL}}, the behavior is the same as calling {{lc|std::malloc}}({{tt|new_size}}).

If {{tt|new_size}} is zero, the behavior is implementation defined (null pointer may be returned, or some non-null pointer may be returned that may not be used to access storage).

===Notes===
Because reallocation may involve bytewise copying (regardless of whether it's to expand or to contract), only the objects of {{concept|TriviallyCopyable}} types are safe to access in the preserved part of the memory block after a call to {{tt|realloc}}.

Some non-standard libraries define a type trait &quot;BitwiseMovable&quot; or &quot;Relocatable&quot;, which describes a type that
* does not have to register with an observer that maintains a pointer to this object (e.g. nodes of a list or a tree)
* has no members of pointer type that point to members of the same object

Objects of such type can be accessed after their storage is reallocated even if their copy constructors are not trivial.

===Parameters===
{{par begin}}
{{par | ptr | pointer to the memory area to be reallocated}}
{{par | new_size | new size of the array}}
{{par end}}

===Return value===
Pointer to the beginning of newly allocated memory or {{lc|NULL}} if error has occurred. The pointer must be deallocated with {{lc|std::free()}}.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see c | c/memory/realloc}}
{{dsc end}}

[[de:cpp/memory/c/realloc]]
[[es:cpp/memory/c/realloc]]
[[fr:cpp/memory/c/realloc]]
[[it:cpp/memory/c/realloc]]
[[ja:cpp/memory/c/realloc]]
[[pt:cpp/memory/c/realloc]]
[[ru:cpp/memory/c/realloc]]
[[zh:cpp/memory/c/realloc]]</text>
      <sha1>19ytnper146s2tftt10k51mgp4uqj80</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/default delete</title>
    <ns>0</ns>
    <id>3430</id>
    <revision>
      <id>72202</id>
      <parentid>72177</parentid>
      <timestamp>2014-07-23T11:02:23Z</timestamp>
      <contributor>
        <ip>61.164.214.38</ip>
      </contributor>
      <text xml:space="preserve" bytes="3356">{{cpp/title|default_delete}}
{{cpp/memory/default_delete/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class T &gt; struct default_delete
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class T &gt; struct default_delete&lt;T[]&gt;
}}
{{dcl end}}

{{tt|std::default_delete}} is the default destruction policy used by {{lc|std::unique_ptr}} when no deleter is specified. 

1) The non-specialized {{tt|default_delete}} uses {{c|delete}} to deallocate memory for a single object.

2) A partial specialization for array types that uses {{c|delete[]}} is also provided.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/default_delete/dsc constructor}}
{{dsc inc | cpp/memory/default_delete/dsc operator()}}
{{dsc end}}

{{member | {{small|std::default_delete::}}default_delete | 2=
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
constexpr default_delete() = default;
}}
{{dcl | num=2 | since=c++11 | notes={{mark|member only of generic {{tt|default_delete}} template}} | 1=
template &lt;class U&gt;
default_delete( const default_delete&lt;U&gt;&amp; d );
}}
{{dcl end}}

@1@ Constructs a {{tt|std::default_delete}} object.

@2@ Constructs a {{tt|std::default_delete}} object from another {{tt|std::default_delete}} object.  This constructor will only participate in overload resolution if {{tt|U*}} is implicitly convertible to {{tt|T*}}.

===Parameters===
{{par begin}}
{{par | d | a deleter to copy from}}
{{par end}}

===Exceptions===
{{noexcept}}

===Notes===
The converting constructor template of {{tt|std::default_delete}} makes possible the implicit conversion from {{c|std::unique_ptr&lt;Derived&gt;}} to {{c|std::unique_ptr&lt;Base&gt;}}.
}}

{{member | {{small|std::default_delete::}}operator() | 2=
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
void operator()(T* ptr) const;
}}
{{dcl | num=2 | since=c++11 | notes = {{mark|member only of {{tt|default_delete&lt;T[]&gt;}} template specialization}} | 1=
template &lt;class U&gt;
void operator()(U* ptr) const = delete;
}}
{{dcl end}}

Calls either {{tt|delete}} or {{tt|delete[]}} on {{tt|ptr}}.

===Parameters===
{{par begin}}
{{par | ptr | an object or array to delete}}
{{par end}}

===Exceptions===
No exception guarantees.

}}

===Example===
{{example | 
| code=
#include &lt;memory&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

int main()
{
//    {
//        std::shared_ptr&lt;int&gt; shared_bad(new int[10]);
//    } // the destructor calls delete, undefined behavior

    {
        std::shared_ptr&lt;int&gt; shared_good(new int[10], std::default_delete&lt;int[]&gt;
());
    } // the destructor calls delete[], ok

    {
        std::unique_ptr&lt;int&gt; ptr(new int(5));
    } // unique_ptr&lt;int&gt; uses default_delete&lt;int&gt;

    {
        std::unique_ptr&lt;int[]&gt; ptr(new int[10]);
    } // unique_ptr&lt;int[]&gt; uses default_delete&lt;int[]&gt;

   // default_delete can be used anywhere a delete functor is needed
   std::vector&lt;int*&gt; v;
   for(int n = 0; n &lt; 100; ++n)
      v.push_back(new int(n));
   std::for_each(v.begin(), v.end(), std::default_delete&lt;int&gt;());
}
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc unique_ptr}}
{{dsc end}}

[[de:cpp/memory/default delete]]
[[es:cpp/memory/default delete]]
[[fr:cpp/memory/default delete]]
[[it:cpp/memory/default delete]]
[[ja:cpp/memory/default delete]]
[[pt:cpp/memory/default delete]]
[[ru:cpp/memory/default delete]]
[[zh:cpp/memory/default delete]]</text>
      <sha1>hf49jn1bjqvwmu1opfv4ap2qt5j3oqo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/default delete/default delete</title>
    <ns>0</ns>
    <id>9606</id>
    <redirect title="cpp/memory/default delete" />
    <revision>
      <id>47140</id>
      <parentid>44706</parentid>
      <timestamp>2013-04-25T10:52:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/memory/default delete]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/memory/default delete]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/default delete/operator()</title>
    <ns>0</ns>
    <id>9607</id>
    <redirect title="cpp/memory/default delete" />
    <revision>
      <id>47141</id>
      <parentid>44707</parentid>
      <timestamp>2013-04-25T10:53:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/memory/default delete]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/memory/default delete]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/enable shared from this</title>
    <ns>0</ns>
    <id>3425</id>
    <revision>
      <id>69459</id>
      <parentid>66375</parentid>
      <timestamp>2014-04-09T22:37:09Z</timestamp>
      <contributor>
        <username>Kalaxy</username>
        <id>105</id>
      </contributor>
      <comment>Corrected notes about interaction between shared_ptr and enable_shared_from_this.</comment>
      <text xml:space="preserve" bytes="3725">{{cpp/title|enable_shared_from_this}}
{{cpp/memory/enable_shared_from_this/navbar}}
{{ddcl | header=memory | since=c++11 | 1=
template&lt; class T &gt; class enable_shared_from_this;
}}

{{tt|std::enable_shared_from_this}} allows an object {{tt|t}} that is currently managed by a {{lc|std::shared_ptr}} named {{tt|pt}} to safely generate additional {{lc|std::shared_ptr}} instances {{tt|pt1, pt2, ...}} that all share ownership of {{tt|t}} with {{tt|pt}}.

Inheriting from {{tt|std::enable_shared_from_this&lt;T&gt;}} provides the type {{tt|T}} with a member function {{tt|shared_from_this}}.  If an object {{tt|t}} of type {{tt|T}} is managed by a {{c|std::shared_ptr&lt;T&gt;}} named {{tt|pt}}, then calling {{tt|T::shared_from_this}} will return a new {{c|std::shared_ptr&lt;T&gt;}} that shares ownership of {{tt|t}} with {{tt|pt}}.

Note that prior to calling {{tt|shared_from_this}} on an object {{tt|t}}, there must be a {{lc|std::shared_ptr}} that owns {{tt|t}}.

Also note that {{tt|enable_shared_from_this}} provides an alternative to an expression like {{c|std::shared_ptr&lt;T&gt;(this)}}, which is likely to result in {{c|this}} being destructed more than once by multiple owners that are unaware of each other.

===Member functions===
{{dsc begin}}
{{dsc prot mem ctor | cpp/memory/enable_shared_from_this/enable_shared_from_this | constructs an {{tt|enabled_shared_from_this}} object }}
{{dsc prot mem dtor | cpp/memory/enable_shared_from_this/~enable_shared_from_this | destroys an {{tt|enable_shared_from_this}} object }}
{{dsc prot mem fun  | cpp/memory/enable_shared_from_this/operator{{=}} | returns a reference to {{c|this}} }}
{{dsc mem fun  | cpp/memory/enable_shared_from_this/shared_from_this | returns a {{c|shared_ptr}} which shares ownership of {{c|*this}} }}
{{dsc end}}

===Notes===
A common implementation for {{tt|enable_shared_from_this}} is to hold a weak reference (such as {{lc|std::weak_ptr}}) to {{c|this}}. The constructors of {{lc|std::shared_ptr}} detect the presence of an {{tt|enable_shared_from_this}} base and assign the newly created {{lc|std::shared_ptr}} to the internally stored weak reference.  Constructing a {{lc|std::shared_ptr}} for an object that is already managed by another {{lc|std::shared_ptr}} will not consult the internally stored weak reference and thus will lead to undefined behavior.

===Example===
{{example
 | 
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;

struct Good: std::enable_shared_from_this&lt;Good&gt;
{
    std::shared_ptr&lt;Good&gt; getptr() {
        return shared_from_this();
    }
};

struct Bad
{
    std::shared_ptr&lt;Bad&gt; getptr() {
        return std::shared_ptr&lt;Bad&gt;(this);
    }
    ~Bad() { std::cout &lt;&lt; &quot;Bad::~Bad() called\n&quot;; }
};

int main()
{
    // Good: the two shared_ptr's share the same object
    std::shared_ptr&lt;Good&gt; gp1(new Good);
    std::shared_ptr&lt;Good&gt; gp2 = gp1-&gt;getptr();
    std::cout &lt;&lt; &quot;gp2.use_count() = &quot; &lt;&lt; gp2.use_count() &lt;&lt; '\n';

    // Bad, each shared_ptr thinks it's the only owner of the object
    std::shared_ptr&lt;Bad&gt; bp1(new Bad);
    std::shared_ptr&lt;Bad&gt; bp2 = bp1-&gt;getptr();
    std::cout &lt;&lt; &quot;bp2.use_count() = &quot; &lt;&lt; bp2.use_count() &lt;&lt; '\n';
} // UB: double-delete of Bad
 | output=
gp2.use_count() = 2
bp2.use_count() = 1
Bad::~Bad() called
Bad::~Bad() called
*** glibc detected *** ./test: double free or corruption 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this]]
[[es:cpp/memory/enable shared from this]]
[[fr:cpp/memory/enable shared from this]]
[[it:cpp/memory/enable shared from this]]
[[ja:cpp/memory/enable shared from this]]
[[pt:cpp/memory/enable shared from this]]
[[ru:cpp/memory/enable shared from this]]
[[zh:cpp/memory/enable shared from this]]</text>
      <sha1>5nl89wjk8uj6pnvvrnzty0zvie87p5d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/enable shared from this/enable shared from this</title>
    <ns>0</ns>
    <id>8457</id>
    <revision>
      <id>64866</id>
      <parentid>58312</parentid>
      <timestamp>2013-08-27T01:36:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, missing since=</comment>
      <text xml:space="preserve" bytes="1505">{{cpp/memory/enable_shared_from_this/title | enable_shared_from_this}}
{{cpp/memory/enable_shared_from_this/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
constexpr enable_shared_from_this();
}}
{{dcl | num=2 | since=c++11 | 1= 
enable_shared_from_this( const enable_shared_from_this&lt;T&gt;&amp;obj );
}}
{{dcl end}}

Constructs new {{tt|enable_shared_from_this}} object. 

===Parameters===
{{par begin}}
{{par | obj | an {{tt|enable_shared_from_this}} to copy}}
{{par end}} 

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;memory&gt;

struct Foo : public std::enable_shared_from_this&lt;Foo&gt; {
    Foo() {}  // implicitly calls enable_shared_from_this constructor
    std::shared_ptr&lt;Foo&gt; getFoo() { return shared_from_this(); }
};

int main() {
    std::shared_ptr&lt;Foo&gt; pf1(new Foo);
    auto pf2 = pf1-&gt;getFoo();  // shares ownership of object with pf1
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this/enable shared from this]]
[[es:cpp/memory/enable shared from this/enable shared from this]]
[[fr:cpp/memory/enable shared from this/enable shared from this]]
[[it:cpp/memory/enable shared from this/enable shared from this]]
[[ja:cpp/memory/enable shared from this/enable shared from this]]
[[pt:cpp/memory/enable shared from this/enable shared from this]]
[[ru:cpp/memory/enable shared from this/enable shared from this]]
[[zh:cpp/memory/enable shared from this/enable shared from this]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/enable shared from this/operator=</title>
    <ns>0</ns>
    <id>8459</id>
    <revision>
      <id>64865</id>
      <parentid>58315</parentid>
      <timestamp>2013-08-27T01:36:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, missing since=</comment>
      <text xml:space="preserve" bytes="1932">{{cpp/memory/enable_shared_from_this/title | operator{{=}} }}
{{cpp/memory/enable_shared_from_this/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1= 
enable_shared_from_this&lt;T&gt;&amp; operator=( const enable_shared_from_this&lt;T&gt; &amp;obj );
}}
{{dcl end}}

Does nothing; returns {{c|*this}}.

===Parameters===
{{par begin}}
{{par | obj | an {{tt|enable_shared_from_this}} to assign to {{c|*this}} }}
{{par end}} 

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===Example===
Note: {{c|enable_shared_from_this::operator{{=}} }} is defined as {{tt|protected}} in order to prevent accidental slicing but allow derived classes to have default assignment operators.
{{example
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;
 
class SharedInt : public std::enable_shared_from_this&lt;SharedInt&gt;
{
public:
    explicit SharedInt(int n) : mNumber(n) {}
    SharedInt(const SharedInt&amp;) = default;
    SharedInt(SharedInt&amp;&amp;) = default;
    ~SharedInt() = default;
 
    // Both assignment operators use enable_shared_from_this::operator=
    SharedInt&amp; operator=(const SharedInt&amp;) = default;
    SharedInt&amp; operator=(SharedInt&amp;&amp;) = default;
 
    int number() const { return mNumber; }
    
private:
    int mNumber;
};
 
int main() {
    std::shared_ptr&lt;SharedInt&gt; a = std::make_shared&lt;SharedInt&gt;(2);
    std::shared_ptr&lt;SharedInt&gt; b = std::make_shared&lt;SharedInt&gt;(4);
    *a = *b;
 
    std::cout &lt;&lt; a-&gt;number() &lt;&lt; std::endl;
}
 | output=
4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this/operator=]]
[[es:cpp/memory/enable shared from this/operator=]]
[[fr:cpp/memory/enable shared from this/operator=]]
[[it:cpp/memory/enable shared from this/operator=]]
[[ja:cpp/memory/enable shared from this/operator=]]
[[pt:cpp/memory/enable shared from this/operator=]]
[[ru:cpp/memory/enable shared from this/operator=]]
[[zh:cpp/memory/enable shared from this/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/enable shared from this/shared from this</title>
    <ns>0</ns>
    <id>8460</id>
    <revision>
      <id>58316</id>
      <parentid>50130</parentid>
      <timestamp>2013-06-01T06:12:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1776">{{cpp/memory/enable_shared_from_this/title | shared_from_this}}
{{cpp/memory/enable_shared_from_this/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1= 
shared_ptr&lt;T&gt; shared_from_this();
}}
{{dcl | num=2 | 1= 
shared_ptr&lt;T const&gt; shared_from_this() const;
}}
{{dcl end}}

Returns a {{c|std::shared_ptr&lt;T&gt;}} that shares ownership of {{c|*this}} with all existing {{c|std::shared_ptr&lt;T&gt;}} that refer to {{c|*this}}.

===Notes===
Before calling {{tt|shared_from_this}}, there should be at least one {{c|std::shared_ptr&lt;T&gt;}} {{tt|p}} that owns {{c|*this}}.

===Return value===
{{c|std::shared_ptr&lt;T&gt;}} that shares ownership of {{c|*this}} with pre-existing {{c|std::shared_ptr&lt;T&gt;}}s

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo : public std::enable_shared_from_this&lt;Foo&gt; {
    Foo() { std::cout &lt;&lt; &quot;Foo::Foo\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;Foo::~Foo\n&quot;; } 
    std::shared_ptr&lt;Foo&gt; getFoo() { return shared_from_this(); }
};

int main() {
    Foo *f = new Foo;
    std::shared_ptr&lt;Foo&gt; pf1;

    {
        std::shared_ptr&lt;Foo&gt; pf2(f);
        pf1 = pf2-&gt;getFoo();  // shares ownership of object with pf2
    }

    std::cout &lt;&lt; &quot;pf2 is gone\n&quot;;   
}
 | output=
Foo::Foo
pf2 is gone
Foo::~Foo
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this/shared from this]]
[[es:cpp/memory/enable shared from this/shared from this]]
[[fr:cpp/memory/enable shared from this/shared from this]]
[[it:cpp/memory/enable shared from this/shared from this]]
[[ja:cpp/memory/enable shared from this/shared from this]]
[[pt:cpp/memory/enable shared from this/shared from this]]
[[ru:cpp/memory/enable shared from this/shared from this]]
[[zh:cpp/memory/enable shared from this/shared from this]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/enable shared from this/~enable shared from this</title>
    <ns>0</ns>
    <id>8458</id>
    <revision>
      <id>58317</id>
      <parentid>50131</parentid>
      <timestamp>2013-06-01T06:12:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="828">{{cpp/memory/enable_shared_from_this/title | ~enable_shared_from_this}}
{{cpp/memory/enable_shared_from_this/navbar}}
{{dcl begin}}
{{dcl | 1= 
~enable_shared_from_this();
}}
{{dcl end}}

Destroys {{c|*this}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc shared_ptr}}
{{dsc end}}

[[de:cpp/memory/enable shared from this/~enable shared from this]]
[[es:cpp/memory/enable shared from this/~enable shared from this]]
[[fr:cpp/memory/enable shared from this/~enable shared from this]]
[[it:cpp/memory/enable shared from this/~enable shared from this]]
[[ja:cpp/memory/enable shared from this/~enable shared from this]]
[[pt:cpp/memory/enable shared from this/~enable shared from this]]
[[ru:cpp/memory/enable shared from this/~enable shared from this]]
[[zh:cpp/memory/enable shared from this/~enable shared from this]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/declare no pointers</title>
    <ns>0</ns>
    <id>3433</id>
    <revision>
      <id>63338</id>
      <parentid>58320</parentid>
      <timestamp>2013-07-10T01:29:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1102">{{cpp/title|declare_no_pointers}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | since=c++11 |
void declare_no_pointers( char *p, std::size_t n )
}}

Informs the garbage collector or leak detector that the specified memory region ({{tt|n}} bytes beginning at the byte pointed to by {{tt|p}}) contains no traceable pointers. If any part of the region is within an allocated object, the entire region must be contained in the same object.

===Parameters===
{{par begin}}
{{par | p | pointer to the beginning of the range}}
{{par | n | the number of bytes in the range}}
{{par end}}

===Return value===
(none)

===Exceptions===
None

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc undeclare_no_pointers}}
{{dsc end}}

[[de:cpp/memory/gc/declare no pointers]]
[[es:cpp/memory/gc/declare no pointers]]
[[fr:cpp/memory/gc/declare no pointers]]
[[it:cpp/memory/gc/declare no pointers]]
[[ja:cpp/memory/gc/declare no pointers]]
[[pt:cpp/memory/gc/declare no pointers]]
[[ru:cpp/memory/gc/declare no pointers]]
[[zh:cpp/memory/gc/declare no pointers]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/declare reachable</title>
    <ns>0</ns>
    <id>3431</id>
    <revision>
      <id>63339</id>
      <parentid>58321</parentid>
      <timestamp>2013-07-10T01:29:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1361">{{cpp/title|declare_reachable}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | since=c++11 | 
void declare_reachable( void* p )
}}

Declares the object referenced by the pointer {{tt|p}} reachable. Reachable objects will not be deleted by the garbage collector or considered to be a leak by a leak detector even if all pointers to it are destroyed. An object may be declared reachable multiple times, in which case multiple calls to {{lc|std::undeclare_reachable}} would be needed to remove this property. For example, a [[enwiki:XOR linked list|XOR linked list]] needs to declare its nodes reachable if the implementation has garbage collection enabled.

===Parameters===
{{par begin}}
{{par | p | a safely-derived pointer or a null pointer}}
{{par end}}

===Return value===
(none)

===Exceptions===
May throw {{lc|std::bad_alloc}} if the system cannot allocate memory required to track reachable objects.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc undeclare_reachable}}
{{dsc end}}

[[de:cpp/memory/gc/declare reachable]]
[[es:cpp/memory/gc/declare reachable]]
[[fr:cpp/memory/gc/declare reachable]]
[[it:cpp/memory/gc/declare reachable]]
[[ja:cpp/memory/gc/declare reachable]]
[[pt:cpp/memory/gc/declare reachable]]
[[ru:cpp/memory/gc/declare reachable]]
[[zh:cpp/memory/gc/declare reachable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/get pointer safety</title>
    <ns>0</ns>
    <id>3436</id>
    <revision>
      <id>63340</id>
      <parentid>58322</parentid>
      <timestamp>2013-07-10T01:29:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="783">{{cpp/title|get_pointer_safety}}
{{cpp/memory/navbar}}
{{ddcl | since=c++11 | header=memory | 
std::pointer_safety get_pointer_safety()
}}

Obtains the implementation-defined pointer safety model, which is a value of type {{lc|std::pointer_safety}}.

===Parameters===
(none)

===Return value===
The pointer safety used by this implementation.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc pointer_safety}}
{{dsc end}}

[[de:cpp/memory/gc/get pointer safety]]
[[es:cpp/memory/gc/get pointer safety]]
[[fr:cpp/memory/gc/get pointer safety]]
[[it:cpp/memory/gc/get pointer safety]]
[[ja:cpp/memory/gc/get pointer safety]]
[[pt:cpp/memory/gc/get pointer safety]]
[[ru:cpp/memory/gc/get pointer safety]]
[[zh:cpp/memory/gc/get pointer safety]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/pointer safety</title>
    <ns>0</ns>
    <id>3435</id>
    <revision>
      <id>62772</id>
      <parentid>58325</parentid>
      <timestamp>2013-07-01T23:40:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1203">{{cpp/title|pointer_safety}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl  | since=c++11 |1=
enum class pointer_safety {
     relaxed,
     preferred,
     strict
};
}}
{{dcl end}}

The scoped enumeration type {{tt|pointer_safety}} lists the pointer safety modes supported by C++

===Enumeration constants===
{{dsc begin}}
{{dsc | pointer_safety::strict | Only safely-derived pointers (pointers to objects allocated with new or subobjects thereof) may be dereferenced or deallocated. Garbage collector may be active.}}
{{dsc | pointer_safety::preferred | All pointers are considered valid and may be dereferenced or deallocated. A reachability-based leak detector may be active}}
{{dsc | pointer_safety::relaxed | All pointers are considered valid and may be dereferenced or deallocated}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc get_pointer_safety}}
{{dsc end}}

[[de:cpp/memory/gc/pointer safety]]
[[es:cpp/memory/gc/pointer safety]]
[[fr:cpp/memory/gc/pointer safety]]
[[it:cpp/memory/gc/pointer safety]]
[[ja:cpp/memory/gc/pointer safety]]
[[pt:cpp/memory/gc/pointer safety]]
[[ru:cpp/memory/gc/pointer safety]]
[[zh:cpp/memory/gc/pointer safety]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/undeclare no pointers</title>
    <ns>0</ns>
    <id>3434</id>
    <revision>
      <id>63341</id>
      <parentid>58326</parentid>
      <timestamp>2013-07-10T01:29:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1038">{{cpp/title|undeclare_no_pointers}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | since=c++11 |
void undeclare_no_pointers( char *p, std::size_t n )
}}

Unregisters a range earlier registered with {{c|std::declare_no_pointers()}}.

===Parameters===
{{par begin}}
{{par | p | pointer to the beginning of the range previosly registered with {{lc|std::declare_no_pointers}}}}
{{par | n | the number of bytes in the range, same value as previously used with {{lc|std::declare_no_pointers}} }}
{{par end}}

===Return value===
(none)

===Exceptions===
None

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc declare_no_pointers}}
{{dsc end}}

[[de:cpp/memory/gc/undeclare no pointers]]
[[es:cpp/memory/gc/undeclare no pointers]]
[[fr:cpp/memory/gc/undeclare no pointers]]
[[it:cpp/memory/gc/undeclare no pointers]]
[[ja:cpp/memory/gc/undeclare no pointers]]
[[pt:cpp/memory/gc/undeclare no pointers]]
[[ru:cpp/memory/gc/undeclare no pointers]]
[[zh:cpp/memory/gc/undeclare no pointers]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/gc/undeclare reachable</title>
    <ns>0</ns>
    <id>3432</id>
    <revision>
      <id>63342</id>
      <parentid>58327</parentid>
      <timestamp>2013-07-10T01:29:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1281">{{cpp/title|undeclare_reachable}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | since=c++11 |
template&lt; class T &gt;
T* undeclare_reachable( T* p )
}}

Removes the reachable status of the object, referenced by the pointer {{tt|p}}, if it was previously set by {{lc|std::declare_reachable}}. If the object was declared reachable multiple times, equal number of calls to {{tt|undeclare_reachable}} would be needed to remove this status. Once the object is not declared reachable and has no pointers referencing it, it may be reclaimed by garbage collector or reported as a leak by a leak detector.

===Parameters===
{{par begin}}
{{par | p | a pointer to an object previously declared reachable and not destructed since then}}
{{par end}}

===Return value===
A safely-derived copy of {{tt|p}}.

===Exceptions===
None

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/gc/dsc declare_reachable}}
{{dsc end}}

[[de:cpp/memory/gc/undeclare reachable]]
[[es:cpp/memory/gc/undeclare reachable]]
[[fr:cpp/memory/gc/undeclare reachable]]
[[it:cpp/memory/gc/undeclare reachable]]
[[ja:cpp/memory/gc/undeclare reachable]]
[[pt:cpp/memory/gc/undeclare reachable]]
[[ru:cpp/memory/gc/undeclare reachable]]
[[zh:cpp/memory/gc/undeclare reachable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/get temporary buffer</title>
    <ns>0</ns>
    <id>3414</id>
    <revision>
      <id>64844</id>
      <parentid>58330</parentid>
      <timestamp>2013-08-27T01:20:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1241">{{cpp/title|get_temporary_buffer}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | 
template&lt; class T &gt;
std::pair&lt; T*, std::ptrdiff_t &gt; get_temporary_buffer( std::ptrdiff_t count )
}}

Allocates storage sufficient to store up to {{tt|count}} adjacent objects of type {{tt|T}}. If there is insufficient memory for all {{tt|count}} objects, allocates less than {{tt|count}}, if possible.

===Parameters===
{{par begin}}
{{par | count | the number of objects to allocate}}
{{par end}}

===Return value===
An {{lc|std::pair}} holding a pointer to the beginning of the allocated storage and the number of objects that fit in the storage that was actually allocated (may be zero).

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{include| cpp/memory/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc return_temporary_buffer}}
{{dsc end}}

[[de:cpp/memory/get temporary buffer]]
[[es:cpp/memory/get temporary buffer]]
[[fr:cpp/memory/get temporary buffer]]
[[it:cpp/memory/get temporary buffer]]
[[ja:cpp/memory/get temporary buffer]]
[[pt:cpp/memory/get temporary buffer]]
[[ru:cpp/memory/get temporary buffer]]
[[zh:cpp/memory/get temporary buffer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new</title>
    <ns>0</ns>
    <id>1329</id>
    <revision>
      <id>58331</id>
      <parentid>50139</parentid>
      <timestamp>2013-06-01T06:12:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1363">{{title|Low level memory management}}
{{cpp/memory/new/navbar}}

The [[cpp/language/new |new-expression]] is the only way to create an object or an array of objects with dynamic storage duration, that is, with lifetime not restricted to the scope in which it is created. A new-expression obtains storage by calling an allocation function. A [[cpp/language/delete |delete-expression]] destroys a most derived object or an array created by a new-expression and calls the deallocation function. The default allocation and deallocation functions, along with related functions, types, and objects, are declared in the header {{tt|&lt;new&gt;}}. 

{{dsc begin}}
{{dsc header |new}}
{{dsc h2 | Functions}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc operator_delete}}
{{dsc inc | cpp/memory/new/dsc get_new_handler}}
{{dsc inc | cpp/memory/new/dsc set_new_handler}}
{{dsc h2 | Classes }}
{{dsc inc | cpp/memory/new/dsc bad_alloc}}
{{dsc inc | cpp/memory/new/dsc bad_array_new_length}}
{{dsc inc | cpp/memory/new/dsc nothrow_t}}
{{dsc h2 | Types }}
{{dsc inc | cpp/memory/new/dsc new_handler}}
{{dsc h2 | Objects}}
{{dsc inc | cpp/memory/new/dsc nothrow}}
{{dsc end}}

[[de:cpp/memory/new]]
[[es:cpp/memory/new]]
[[fr:cpp/memory/new]]
[[it:cpp/memory/new]]
[[ja:cpp/memory/new]]
[[pt:cpp/memory/new]]
[[ru:cpp/memory/new]]
[[zh:cpp/memory/new]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad alloc</title>
    <ns>0</ns>
    <id>3353</id>
    <revision>
      <id>67172</id>
      <parentid>64845</parentid>
      <timestamp>2014-01-25T12:53:45Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ possible: std::bad_alloc().what() returns implementation-defined string</comment>
      <text xml:space="preserve" bytes="2595">{{cpp/title|bad_alloc}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl |1=
class bad_alloc : public std::exception;
}}
{{dcl end}}

{{tt|std::bad_alloc}} is the type of the object thrown as exceptions by the {{rlp|operator_new|allocation functions}} to report failure to allocate storage.

{{inheritance diagram/std-bad_alloc}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/memory/new/bad_alloc | inlinemem=true | constructs the bad_alloc object}}
{{dsc mem fun | cpp/memory/new/bad_alloc | title=operator{{=}} | inlinemem=true | replaces a bad_alloc object}}
{{dsc mem fun | cpp/memory/new/bad_alloc | title=what | inlinemem=true | returns explanatory string}}
{{dsc end}}

{{member | {{small|std::bad_alloc::}}bad_alloc |
{{ddcl |
bad_alloc();
}}

Constructs new {{tt|bad_alloc}} object with an implementation-defined null-terminated byte string which is accessible through {{ltf|cpp/error/exception/what}}.

===Parameters===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::bad_alloc::}}operator{{=}} |
{{dcl begin}}
{{dcl | 1=
bad_alloc&amp; operator=( const bad_alloc&amp; other );
}}
{{dcl end}}

Assigns the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another exception object to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::bad_alloc::}}what |
{{dcl begin}}
{{dcl | 
virtual const char* what() const;
}}
{{dcl end}}

Returns the explanatory string.

===Parameters===
(none)

===Return value===
Pointer to a null-terminated string with explanatory information. 

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;new&gt;

int main()
{
    try {
        while (true) {
            new int[100000000ul];
        }
    } catch (const std::bad_alloc&amp; e) {
        std::cout &lt;&lt; &quot;Allocation failed: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | p=true
 | output=
Allocation failed: std::bad_alloc
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc end}}

[[de:cpp/memory/new/bad alloc]]
[[es:cpp/memory/new/bad alloc]]
[[fr:cpp/memory/new/bad alloc]]
[[it:cpp/memory/new/bad alloc]]
[[ja:cpp/memory/new/bad alloc]]
[[pt:cpp/memory/new/bad alloc]]
[[ru:cpp/memory/new/bad alloc]]
[[zh:cpp/memory/new/bad alloc]]</text>
      <sha1>ra5cdqvv90ds6fgco78nr7ldnyz56kq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad alloc/bad alloc</title>
    <ns>0</ns>
    <id>5577</id>
    <redirect title="cpp/memory/new/bad alloc" />
    <revision>
      <id>61600</id>
      <parentid>42659</parentid>
      <timestamp>2013-06-06T06:53:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/memory/new/bad alloc]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/memory/new/bad_alloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad alloc/operator=</title>
    <ns>0</ns>
    <id>12758</id>
    <revision>
      <id>64873</id>
      <parentid>61598</parentid>
      <timestamp>2013-08-27T01:43:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="452">{{cpp/memory/new/bad alloc/title|operator{{=}}}}
{{cpp/memory/new/bad alloc/navbar}}
{{dcl begin}}
{{dcl | 1=
bad_alloc&amp; operator=( const bad_alloc&amp; other );
}}
{{dcl end}}

Assigns the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another exception object to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad alloc/what</title>
    <ns>0</ns>
    <id>8974</id>
    <redirect title="cpp/memory/new/bad alloc" />
    <revision>
      <id>61601</id>
      <parentid>42651</parentid>
      <timestamp>2013-06-06T06:53:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/memory/new/bad alloc]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/memory/new/bad_alloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad array length</title>
    <ns>0</ns>
    <id>12577</id>
    <revision>
      <id>63949</id>
      <parentid>61634</parentid>
      <timestamp>2013-08-01T15:46:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="1321">{{cpp/title|bad_array_length}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | since=c++14 | 1=
class bad_array_length : public std::bad_alloc;
}}
{{dcl end}}

{{tt|std::bad_array_length}} is the type of the object thrown as exceptions by the constructors of arrays of runtime bound and objects of type {{c|std::dynarray}} to report invalid array lengths if

@1@array length is negative or equal to zero (for arrays of runtime bound)
@2@total size of the new array would exceed implementation-defined maximum value (for both arrays of runtime bound and {{c|std::dynarray}})

{{todo|inheritance diagram}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/memory/new/bad_array_length | inlinemem=true | constructs the {{tt|bad_array_length}} object}}
{{dsc end}}

{{member | {{small|std::bad_array_length::}}bad_array_length |
{{dcl begin}}
{{dcl | since=c++14 |
bad_array_length();
}}
{{dcl end}}

Constructs new exception object.

===Parameters===
(none)

===Exceptions===
{{noexcept}}
}}

{{cpp/memory/new/bad_alloc/inherit}}
{{cpp/error/exception/inherit}}

===Notes===
The override for the virtual member function {{tt|what()}} may by provided, but is not required.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc bad_array_new_length}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad array new length</title>
    <ns>0</ns>
    <id>3354</id>
    <revision>
      <id>62773</id>
      <parentid>58335</parentid>
      <timestamp>2013-07-01T23:40:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2095">{{cpp/title|bad_array_new_length}}
{{cpp/memory/new/bad_array_new_length/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | since=c++11 | 1=
class bad_array_new_length;
}}
{{dcl end}}

{{tt|std::bad_array_new_length}} is the type of the object thrown as exceptions by the [[cpp/language/new|new-expressions]] to report invalid array lengths if

1) array length is negative

2) total size of the new array would exceed implementation-defined maximum value

3) the number of initializer-clauses exceeds the number of elements to initialize

Only the first array dimension may generate this exception; dimensions other than the first are constant expressions and are checked at compile time.

{{inheritance diagram/std-bad_array_new_length}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/memory/new/bad_array_new_length/bad_array_new_length | constructs the {{tt|bad_array_new_length}} object}}
{{dsc end}}

{{cpp/memory/new/bad_alloc/inherit}}
{{cpp/error/exception/inherit}}

===Notes===
The override for the virtual member function {{tt|what()}} may by provided, but is not required.

===Example===
{{example
 | Three conditions where {{lc|std::bad_array_new_length}} should be thrown:
 | code=
#include &lt;iostream&gt;
#include &lt;new&gt;
#include &lt;climits&gt;

int main()
{
    int negative = -1;
    int small = 1;
    int large = INT_MAX;
    try {
        new int[negative];           // negative size
        new int[small]{1,2,3};       // too many initializers
        new int[large][1000000];     // too large
    } catch(const std::bad_array_new_length &amp;e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc bad_alloc}}
{{dsc end}}

[[de:cpp/memory/new/bad array new length]]
[[es:cpp/memory/new/bad array new length]]
[[fr:cpp/memory/new/bad array new length]]
[[it:cpp/memory/new/bad array new length]]
[[ja:cpp/memory/new/bad array new length]]
[[pt:cpp/memory/new/bad array new length]]
[[ru:cpp/memory/new/bad array new length]]
[[zh:cpp/memory/new/bad array new length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/bad array new length/bad array new length</title>
    <ns>0</ns>
    <id>5578</id>
    <revision>
      <id>64850</id>
      <parentid>42636</parentid>
      <timestamp>2013-08-27T01:26:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=</comment>
      <text xml:space="preserve" bytes="906">{{cpp/memory/new/bad_array_new_length/title | bad_array_new_length}}
{{cpp/memory/new/bad_array_new_length/navbar}}
{{ddcl | since=c++11 |
bad_array_new_length();
}}

Constructs new {{tt|bad_array_new_length}} object with in implementation-defined null-terminated byte string which is accessible through {{ltf|cpp/error/exception/what}}.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/memory/new/bad array new length/bad array new length]]
[[es:cpp/memory/new/bad array new length/bad array new length]]
[[fr:cpp/memory/new/bad array new length/bad array new length]]
[[it:cpp/memory/new/bad array new length/bad array new length]]
[[ja:cpp/memory/new/bad array new length/bad array new length]]
[[pt:cpp/memory/new/bad array new length/bad array new length]]
[[ru:cpp/memory/new/bad array new length/bad array new length]]
[[zh:cpp/memory/new/bad array new length/bad array new length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/get new handler</title>
    <ns>0</ns>
    <id>3349</id>
    <revision>
      <id>72157</id>
      <parentid>62774</parentid>
      <timestamp>2014-07-19T14:23:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+thread safety</comment>
      <text xml:space="preserve" bytes="1109">{{cpp/title|get_new_handler}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | since=c++11 |1=
std::new_handler get_new_handler();
}}
{{dcl end}}

Returns the currently installed new-handler, which may be a null pointer.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Previous call to {{lc|std::set_new_handler}} ''synchronizes-with'' (see {{lc|std::memory_order}}) the subsequent calls to {{tt|std::get_new_handler}}.
}}
{{rev end}}

===Parameters===
(none)

===Return value===
The currently installed ''new-handler'', which may be a null pointer value.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc set_new_handler}}
{{dsc inc | cpp/memory/new/dsc new_handler}}
{{dsc end}}

[[de:cpp/memory/new/get new handler]]
[[es:cpp/memory/new/get new handler]]
[[fr:cpp/memory/new/get new handler]]
[[it:cpp/memory/new/get new handler]]
[[ja:cpp/memory/new/get new handler]]
[[pt:cpp/memory/new/get new handler]]
[[ru:cpp/memory/new/get new handler]]
[[zh:cpp/memory/new/get new handler]]</text>
      <sha1>2zmp7da844b8k9vw7z1l4gmzelgfwnn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/new handler</title>
    <ns>0</ns>
    <id>3350</id>
    <revision>
      <id>58337</id>
      <parentid>50143</parentid>
      <timestamp>2013-06-01T06:12:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="812">{{cpp/title|new_handler}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | |1=
typedef void (*new_handler)();
}}
{{dcl end}}

{{tt|std::new_handler}} is the function pointer type (pointer to function that takes no arguments and returns void), which is used by the functions {{lc|std::set_new_handler}} and {{lc|std::get_new_handler}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc set_new_handler}}
{{dsc inc | cpp/memory/new/dsc get_new_handler}}
{{dsc end}}

[[de:cpp/memory/new/new handler]]
[[es:cpp/memory/new/new handler]]
[[fr:cpp/memory/new/new handler]]
[[it:cpp/memory/new/new handler]]
[[ja:cpp/memory/new/new handler]]
[[pt:cpp/memory/new/new handler]]
[[ru:cpp/memory/new/new handler]]
[[zh:cpp/memory/new/new handler]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/nothrow</title>
    <ns>0</ns>
    <id>3352</id>
    <revision>
      <id>58340</id>
      <parentid>50144</parentid>
      <timestamp>2013-06-01T06:12:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1239">{{cpp/title|nothrow}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | |1=
extern const std::nothrow_t nothrow;
}}
{{dcl end}}

{{tt|std::nothrow}} is a constant of type {{lc|std::nothrow_t}} used to disambiguate the overloads of throwing and non-throwing {{rlp|operator_new|allocation functions}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;new&gt;

int main()
{
    try {
        while (true) {
            new int[100000000ul];   // throwing overload
        }
    } catch (const std::bad_alloc&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }

    while (true) {
        int* p = new(std::nothrow) int[100000000ul]; // non-throwing overload
        if (p == nullptr) {
            std::cout &lt;&lt; &quot;Allocation returned nullptr\n&quot;;
            break;
        }
    }
}
 | output=
std::bad_alloc
Allocation returned nullptr
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc nothrow_t}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc end}}

[[de:cpp/memory/new/nothrow]]
[[es:cpp/memory/new/nothrow]]
[[fr:cpp/memory/new/nothrow]]
[[it:cpp/memory/new/nothrow]]
[[ja:cpp/memory/new/nothrow]]
[[pt:cpp/memory/new/nothrow]]
[[ru:cpp/memory/new/nothrow]]
[[zh:cpp/memory/new/nothrow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/nothrow t</title>
    <ns>0</ns>
    <id>3351</id>
    <revision>
      <id>58341</id>
      <parentid>50145</parentid>
      <timestamp>2013-06-01T06:12:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="672">{{cpp/title|nothrow_t}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | |1=
struct nothrow_t {};
}}
{{dcl end}}

{{tt|std::nothrow_t}} is an empty class type used to disambiguate the overloads of throwing and non-throwing {{rlp|operator_new|allocation functions}}. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc nothrow}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc end}}

[[de:cpp/memory/new/nothrow t]]
[[es:cpp/memory/new/nothrow t]]
[[fr:cpp/memory/new/nothrow t]]
[[it:cpp/memory/new/nothrow t]]
[[ja:cpp/memory/new/nothrow t]]
[[pt:cpp/memory/new/nothrow t]]
[[ru:cpp/memory/new/nothrow t]]
[[zh:cpp/memory/new/nothrow t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/operator delete</title>
    <ns>0</ns>
    <id>1330</id>
    <revision>
      <id>71810</id>
      <parentid>71427</parentid>
      <timestamp>2014-06-25T02:18:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>noexcept true by default (15.4/14)</comment>
      <text xml:space="preserve" bytes="14029">{{title|{{small|operator}} delete{{small|, operator}} delete[]}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl h | replaceable deallocation functions}}
{{dcl | num=1 | void operator delete  ( void* ptr ); }}
{{dcl | num=2 | void operator delete[]( void* ptr ); }}
{{dcl | num=3 | void operator delete  ( void* ptr, const std::nothrow_t&amp; tag);}}
{{dcl | num=4 | void operator delete[]( void* ptr, const std::nothrow_t&amp; tag);}}
{{dcl | since=c++14 | num=5 | void operator delete(void* ptr, std::size_t sz) }}
{{dcl | since=c++14 | num=6 | void operator delete[](void* ptr, std::size_t sz) }}
{{dcl | since=c++14 | num=7 | void operator delete(void* ptr, std::size_t sz, const std::nothrow_t&amp; tag) }}
{{dcl | since=c++14 | num=8 | void operator delete[](void* ptr, std::size_t sz, const std::nothrow_t&amp; tag) }}
{{dcl h | placement deallocation functions}}
{{dcl | num=9 | void operator delete  ( void* ptr, void* place);}}
{{dcl | num=10 | void operator delete[]( void* ptr, void* place);}}
{{dcl | num=11 | void operator delete  ( void* ptr, user-defined-args...);}}
{{dcl | num=12 | void operator delete[] ( void* ptr, user-defined-args...);}}
{{dcl h | class-specific deallocation functions}}
{{dcl | num=13 | void T::operator delete  ( void* ptr ); }}
{{dcl | num=14 | void T::operator delete[]( void* ptr ); }}
{{dcl | num=15 | void T::operator delete ( void* ptr, std::size_t sz) }}
{{dcl | num=16 | void T::operator delete[]( void* ptr, std::size_t sz) }}
{{dcl | num=17 | void T::operator delete  ( void* ptr, user-defined-args... ); }}
{{dcl | num=18 | void T::operator delete[]( void* ptr, user-defined-args... ); }}
{{dcl end}}

Deallocates storage previously allocated by a matching {{lc|operator new}}. These deallocation functions are called by [[cpp/language/delete|delete-expressions]] and by  [[cpp/language/new|new-expressions]] to deallocate memory after destructing (or failing to construct) objects with dynamic storage duration. They may also be called using regular function call syntax.

@1@ Called by [[cpp/language/delete|delete-expressions]] to deallocate storage previously allocated for a single object. The behavior of the standard library implementation of this function is undefined unless {{tt|ptr}} is a null pointer or is a pointer previously obtained from the standard library implementation of {{c|operator new(size_t)}} or {{c|operator new(size_t, std::nothrow_t)}}.
@2@ Called by [[cpp/language/delete|delete[]-expressions]] to deallocate storage previously allocated for an array of objects. The behavior of the standard library implementation of this function is undefined unless {{tt|ptr}} is a null pointer or is a pointer previously obtained from the standard library implementation of {{c|operator new[](size_t)}} or {{c|operator new[](size_t, std::nothrow_t)}}.
@3@ Called by the non-throwing single-object [[cpp/language/new|new-expressions]] if a constructor of the object throws an exception. The standard library implementation behaves the same as (1)
@4@ Called by the non-throwing array [[cpp/language/new|new[]-expressions]] if a constructor of any object throws an exception (after executing the destructors of all objects in the array that were successfully constructed). The standard library implementation behaves the same as (2)
@5-8@ Called instead of (1-4) if a user-defined replacement is provided. The standard library implementations are identical to (1-4).
@9@ Called by the standard single-object [[cpp/language/new|placement new]] expression if the object's constructor throws an exception. The standard library implementation of this function does nothing.
@10@ Called by the standard array form of the [[cpp/language/new|placement new]] expression if any of the objects' constructors throws an exception (after executing the destructors of all objects that were constructed successfully). The standard library implementation of this function does nothing. 
@11@ If defined, called by the custom single-object [[cpp/language/new|placement new]] expression with the matching signature if the object's constructor throws an exception. If a class-specific version (16) is defined, it is called in preference to (11). If neither (16) nor (11) is provided by the user, no deallocation function is called.
@12@ If defined, called by the custom array form of [[cpp/language/new|placement new[] ]] expression with the matching signature if any of the objects' constructors throws an exception (after executing the destructors for all objects that were constructed successfully). If a class-specific version (17) is defined, it is called in preference to (12). If neither (17) nor (12) is provided by the user, no deallocation function is called
@13@ If defined, called by the usual single-object [[cpp/language/delete|delete-expressions]] if deallocating an object of type T.
@14@ If defined, called by the usual array [[cpp/language/delete|delete[]-expressions]] if deallocating an array of objects of type T.
@15@ If defined, and if (13) is not defined, called by the usual single-object [[cpp/language/delete|delete-expressions]] if deallocating an object of type T.
@16@ If defined, and if (14) is not defined, called by the usual array [[cpp/language/delete|delete[]-expressions]] if deallocating an array of objects of type T.
@17@ If defined, called by the custom single-object [[cpp/language/new|placement new]] expression with the matching signature if the object's constructor throws an exception. If this function is not provided, and a matching (11) is not provided either, no deallocation function is called.
@18@ If defined, called by the custom array form of [[cpp/language/new|placement new[] ]] expression with the matching signature if any of the objects' constructors throws an exception (after executing the destructors for all objects that were constructed successfully). If this function is not provided, and a matching (12) is not provided either, no deallocation function is called.

In all cases, if {{tt|ptr}} is a null pointer, the standard library deallocation functions do nothing. If the pointer passed to the standard library deallocation function was not obtained from the corresponding standard library allocation function, the behavior is undefined.

After the standard library deallocation function returns, all pointers referring to any part of the deallocated storage become invalid.
{{rev begin}}
{{rev|until=c++14|
Any use of a pointer that became invalid in this manner, even copying the pointer value into another variable, is undefined behavior.
}}
{{rev|since=c++14|
Indirection through a pointer that became invalid in this manner and passing it to a deallocation function (double-delete) is undefined behavior. Any other use is implementation-defined.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | ptr | pointer to a memory area to deallocate or a null pointer}}
{{par | sz | the size that was passed to the matching allocation function}}
{{par | place | pointer used as the placement parameter in the matching placement new}}
{{par | tag | overload disambiguation tag matching the tag used by non-throwing operator new}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Global replacements===
The versions (1-8) are implicitly declared in each translation unit even if the {{tt|&lt;new&gt;}} header is not included. These functions are ''replaceable'': a user-provided non-member function with the same signature defined anywhere in the program, in any source file, replaces the corresponding implicit version for the entire program. Its declaration does not need to be visible. 

The behavior is undefined if more than one replacement is provided in the program or if a replacement is defined with the {{tt|inline}} specifier, the program is ill-formed if a replacement is defined in namespace other than global namespace, or if it is defined as a static non-member function at global scope. 

{{rev begin}}
{{rev|since=c++11|
The single-object version (1) is called by the standard library implementations of all other versions (2-8), so replacing that one function is sufficient to handle all deallocations.}}
{{rev end}}

{{example|code=#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
// replacement of a minimal set of functions:
void* operator new(std::size_t sz) {
    std::printf(&quot;global op new called, size = %zu\n&quot;,sz);
    return std::malloc(sz);
}
void operator delete(void* ptr) noexcept
{
    std::puts(&quot;global op delete called&quot;);
    std::free(ptr);
}
int main() {
     int* p1 = new int;
     delete p1;

     int* p2 = new int[10]; // guaranteed to call the replacement in C++11
     delete[] p2;
}
|p=true
|output=
global op new called, size = 4
global op delete called
global op new called, size = 40
global op delete called

}}

Overloads of {{tt|operator delete}} and {{tt|operator delete[]}} with additional user-defined parameters (&quot;placement forms&quot;, version 11-12) may be declared at global scope as usual, and are called by the matching placement forms of ''new-expressions'' if a constructor of the object that is being allocated throws an exception.

The standard library placement forms of operator delete (9-10) cannot be replaced and can only be customized if the placement new-expression did not use the {{tt|::new}} syntax, by providing a class-specific placement delete (17,18) with matching signature: {{tt|void T::operator delete(void*, void*)}} or {{tt|void T::operator delete[](void*, void*)}}.

{{rev begin}}
{{rev|since=c++11|
All deallocation functions are {{tt|noexcept(true)}} unless specified otherwise in the declaration.}}
{{rev end}}

===Class-specific overloads===
Deallocation functions (versions 13-16) may be defined as static member functions of a class. These deallocation functions, if provided, are called by [[cpp/language/delete|delete-expressions]] when deleting objects (versions (13) and (15)) and arrays (versions (14) and (17)) of this class, unless the delete expression used the form {{tt|::delete}} which bypasses class-scope lookup. The keyword {{tt|static}} is optional for these function declarations: whether the keyword is used or not, the deallocation function is always a static member function.

The delete expression looks for appropriate deallocation function's name firstly in the class scope, starting from the most derived type if the class is [[cpp/language/object|polymorphic]], and after that in the global scope. Note, that as per [[cpp/language/lookup|name lookup rules]], any deallocation functions declared in class scope hides all global deallocation functions. When deleting a polymorphic object, even though a different function may be executed at run time, the statically visible version of operator delete must be accessible in order to compile.

If the single-argument overload (13,15) is not provided, but the two-argument overload taking {{tt|std::size_t}} as the second parameter (14,16) is provided, the two-argument form is called for normal deallocation, and the C++ runtime passes the size of the object to be deallocated as the second argument. If both forms are defined, the single-argument version is called.

{{example
|code=#include &lt;iostream&gt;
// sized class-specific deallocation functions
struct X {
    static void operator delete(void* ptr, std::size_t sz)
    {
        std::cout &lt;&lt; &quot;custom delete for size &quot; &lt;&lt; sz &lt;&lt; '\n';
        ::operator delete(ptr);
    }
    static void operator delete[](void* ptr, std::size_t sz)
    {
        std::cout &lt;&lt; &quot;custom delete for size &quot; &lt;&lt; sz &lt;&lt; '\n';
        ::operator delete(ptr);
    }
};
int main() {
     X* p1 = new X;
     delete p1;
     X* p2 = new X[10];
     delete[] p2;
}
|p=true
|output=
custom delete for size 1
custom delete for size 18
}}

Overloads of {{tt|operator delete}} and {{tt|operator delete[]}} with additional user-defined parameters (&quot;placement forms&quot;, versions 17 and 18) may also be defined as class members. When the placement new expression with the matching signature looks for the corresponding placement delete function to call, it begins at class scope before examining the global scope, and if the class-specific placement delete is provided, it is called.

{{example|code=
#include &lt;stdexcept&gt;
#include &lt;iostream&gt;
struct X {
    X() { throw std::runtime_error(&quot;&quot;); }
    // custom placement new
    static void* operator new(std::size_t sz, bool b) {
        std::cout &lt;&lt; &quot;custom placement new called, b = &quot; &lt;&lt; b &lt;&lt; '\n';
        return ::operator new(sz);
    }
    // custom placement delete
    static void operator delete(void* ptr, bool b)
    {
        std::cout &lt;&lt; &quot;custom placement delete called, b = &quot; &lt;&lt; b &lt;&lt; '\n';
        ::operator delete(ptr);
    }
};
int main() {
   try {
     X* p1 = new (true) X;
   } catch(const std::exception&amp;) { }
}
|output=
custom placement new called, b = 1
custom placement delete called, b = 1
}}

If class-level {{tt|operator delete}} is a template function, it must have the return type of {{tt|void}}, the first argument {{tt|void*}}, and it must have two or more parameters. In other words, only placement forms can be templates. The specialization of the template operator delete is chosen with [[cpp/language/template argument deduction|template argument deduction]].

===Notes===
The call to the class-specific {{tt|T::operator delete}} on a polymorphic class is the only case where a static member function is called through dynamic dispatch.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc fun | cpp/memory/return_temporary_buffer | releases uninitialized storage }}
{{dsc fun | cpp/memory/c/free | deallocates memory}}
{{dsc end}}

[[de:cpp/memory/new/operator delete]]
[[es:cpp/memory/new/operator delete]]
[[fr:cpp/memory/new/operator delete]]
[[it:cpp/memory/new/operator delete]]
[[ja:cpp/memory/new/operator delete]]
[[pt:cpp/memory/new/operator delete]]
[[ru:cpp/memory/new/operator delete]]
[[zh:cpp/memory/new/operator delete]]</text>
      <sha1>k0dsblkgkfxyn1f755xpbf3ouyvryat</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/operator new</title>
    <ns>0</ns>
    <id>1331</id>
    <revision>
      <id>69997</id>
      <parentid>69785</parentid>
      <timestamp>2014-05-06T08:55:22Z</timestamp>
      <contributor>
        <ip>139.149.31.230</ip>
      </contributor>
      <text xml:space="preserve" bytes="11579">{{title|{{small|operator}} new{{small|, operator}} new[]}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl h | replaceable allocation functions}}
{{dcl | num=1 | void* operator new  ( std::size_t count );}}
{{dcl | num=2 | void* operator new[]( std::size_t count );}}
{{dcl | num=3 | void* operator new  ( std::size_t count, const std::nothrow_t&amp; tag);}}
{{dcl | num=4 | void* operator new[]( std::size_t count, const std::nothrow_t&amp; tag);}}
{{dcl h | placement allocation functions}}
{{dcl | num=5 | void* operator new  ( std::size_t count, void* ptr );}}
{{dcl | num=6 | void* operator new[]( std::size_t count, void* ptr );}}
{{dcl | num=7 | void* operator new  ( std::size_t count, user-defined-args... );}}
{{dcl | num=8 | void* operator new[]( std::size_t count, user-defined-args... );}}
{{dcl h | class-specific allocation functions}}
{{dcl | num=9 | void* T::operator new  ( std::size_t count );}}
{{dcl | num=10 | void* T::operator new[]( std::size_t count );}}
{{dcl | num=11 | void* T::operator new  ( std::size_t count, user-defined-args... );}}
{{dcl | num=12 | void* T::operator new[]( std::size_t count, user-defined-args... );}}
{{dcl end}}

Allocates requested number of bytes. These allocation functions are called by [[cpp/language/new|new-expressions]] to allocate memory in which new object would then be initialized. They may also be called using regular function call syntax.

@1@ Called by non-array [[cpp/language/new|new-expressions]] to allocate storage required for a single object. The standard library implementation allocates {{tt|count}} bytes from free store. In case of failure, the standard library implementation calls the function pointer returned by {{lc|std::get_new_handler}} and repeats allocation attempts until new handler does not return or becomes a null pointer, at which time it throws {{lc|std::bad_alloc}}. This function is required to return a pointer suitably aligned to hold an object of any fundamental alignment.
@2@ Called by the array form of [[cpp/language/new|new[]-expressions]] to allocate all storage required for an array (including possible ''new-expression'' overhead). The standard library implementation calls version (1)
@3@ Called by the non-throwing non-array [[cpp/language/new|new-expressions]] . The standard library implementation calls the version (1) and returns a null pointer on failure instead of propagating the exception.
@4@ Called by the non-throwing array form of [[cpp/language/new|new[]-expressions]]. The standard library implementation calls the version (2) and returns a null pointer on failure instead of propagating the exception.
@5@ Called by the standard single-object [[cpp/language/new|placement new]] expression. The standard library implementation performs no action and returns {{tt|ptr}} unmodified.
@6@ Called by the standard array form [[cpp/language/new|placement new]] expression. The standard library implementation performs no action and returns {{tt|ptr}} unmodified.
@7@ If defined, called by the custom single-object [[cpp/language/new|placement new]] expression with the matching signature. If a class-specific version (11) is defined, it is called in preference to (7). If neither (7) nor (11) is provided by the user, the placement new expression is ill-formed.
@8@ If defined, called by the custom array form [[cpp/language/new|placement new]] expression with the matching signature. If a class-specific version (12) is defined, it is called in preference to (8). If neither (8) nor (12) is provided by the user, the placement new expression is ill-formed.
@9@ If defined, called by the usual single-object [[cpp/language/new|new-expressions]] if allocating an object of type T.
@10@ If defined, called by the usual array [[cpp/language/new|new[]-expressions]] if allocating an array of objects of type T.
@11@ If defined, called by the custom single-object [[cpp/language/new|placement new]] expression with the matching signature if allocating an object of type T.
@12@ If defined, called by the custom array form of [[cpp/language/new|placement new[] ]] expression with the matching signature if allocating an array of objects of type T.

===Parameters===
{{par begin}}
{{par | count | number of bytes to allocate}}
{{par | ptr | pointer to a memory area to initialize the object at}}
{{par | tag | disambiguation tag used to select non-throwing overloads}}
{{par end}}

===Return value===
non-null pointer to suitably aligned memory of size at least {{tt|size}}

===Exceptions===
@1-2,9-10@ throws {{lc|std::bad_alloc}} {{rev inl|since=c++11|or another exception derived from {{lc|std::bad_alloc}}}} on failure to allocate memory

@3-6@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Global replacements===
The versions (1-4) are implicitly declared in each translation unit even if the {{tt|&lt;new&gt;}} header is not included. These functions are ''replaceable'': a user-provided non-member function with the same signature defined anywhere in the program, in any source file, replaces the implicit version. Its declaration does not need to be visible.

The behavior is undefined if more than one replacement is provided in the program for any of the four implicit allocation function, or if a replacement is defined with the {{tt|inline}} specifier. The program is ill-formed if a replacement is defined in namespace other than global namespace, or if it is defined as a static non-member function at global scope.

{{rev begin}}
{{rev|since=c++11|
The single-object version (1) is directly called by the standard library implementations of all other versions (2-4), so replacing that one function is sufficient to handle all allocations.}}&lt;!--$C2.9[diff.cpp03.language.support]--&gt;
{{rev end}}

{{example|code=#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;
// replacement of a minimal set of functions:
void* operator new(std::size_t sz) {
    std::printf(&quot;global op new called, size = %zu\n&quot;,sz);
    return std::malloc(sz);
}
void operator delete(void* ptr) noexcept
{
    std::puts(&quot;global op delete called&quot;);
    std::free(ptr);
}
int main() {
     int* p1 = new int;
     delete p1;

     int* p2 = new int[10]; // guaranteed to call the replacement in C++11
     delete[] p2;
}
|p=true
|output=
global op new called, size = 4
global op delete called
global op new called, size = 40
global op delete called
}}

Overloads of {{tt|operator new}} and {{tt|operator new[]}} with additional user-defined parameters (&quot;placement forms&quot;, version 7-8) may be declared at global scope as usual, and are called by the matching placement forms of ''new-expressions''.

The standard library placement forms of operator new (5-6) cannot be replaced and can only be customized if the placement new-expression did not use the {{tt|::new}} syntax, by providing a class-specific placement new (11-12) with matching signature: {{tt|void* T::operator new(size_t, void*)}} or {{tt|void* T::operator new[](size_t, void*)}}.

{{rev begin}}
{{rev|since=c++14|
The placement form {{tt|void* operator new(size_t, size_t)}} is not allowed because the matching signature of the deallocation function, {{tt|void operator delete(void*, size_t)}}, is a usual (not placement) deallocation function.
}}
{{rev end}}

===Class-specific overloads===
Both single-object and array allocation functions may be defined as public static member functions of a class (versions 9-10). If defined, these allocation functions are called by [[cpp/language/new|new-expressions]] to allocate memory for single objects and arrays of this class, unless the new expression used the form {{tt|::new}} which bypasses class-scope lookup. The keyword {{tt|static}} is optional for these functions: whether used or not, the allocation function is a static member function.

The new expression looks for appropriate allocation function's name firstly in the class scope, and after that in the global scope. Note, that as per [[cpp/language/lookup|name lookup rules]], any allocation functions declared in class scope hides all global allocation functions for the new-expressions that attempt to allocate objects of this class.

{{example
|code=
#include &lt;iostream&gt;
// class-specific allocation functions
struct X {
    static void* operator new(std::size_t sz)
    {
        std::cout &lt;&lt; &quot;custom new for size &quot; &lt;&lt; sz &lt;&lt; '\n';
        return ::operator new(sz);
    }
    static void* operator new[](std::size_t sz)
    {
        std::cout &lt;&lt; &quot;custom new for size &quot; &lt;&lt; sz &lt;&lt; '\n';
        return ::operator new(sz);
    }
};
int main() {
     X* p1 = new X;
     delete p1;
     X* p2 = new X[10];
     delete[] p2;
}
|p=true
|output=
custom new for size 1
custom new for size 10
}}

Overloads of {{tt|operator new}} and {{tt|operator new[]}} with additional user-defined parameters (&quot;placement forms&quot;, versions 11 and 12) may also be defined as class members. When the placement new expression with the matching signature looks for the corresponding allocation function to call, it begins at class scope before examining the global scope, and if the class-specific placement new is provided, it is called.

{{example|code=
#include &lt;stdexcept&gt;
#include &lt;iostream&gt;
struct X {
    X() { throw std::runtime_error(&quot;&quot;); }
    // custom placement new
    static void* operator new(std::size_t sz, bool b) {
        std::cout &lt;&lt; &quot;custom placement new called, b = &quot; &lt;&lt; b &lt;&lt; '\n';
        return ::operator new(sz);
    }
    // custom placement delete
    static void operator delete(void* ptr, bool b)
    {
        std::cout &lt;&lt; &quot;custom placement delete called, b = &quot; &lt;&lt; b &lt;&lt; '\n';
        ::operator delete(ptr);
    }
};
int main() {
   try {
     X* p1 = new (true) X;
   } catch(const std::exception&amp;) { }
}
|output=
custom placement new called, b = 1
custom placement delete called, b = 1
}}

If class-level {{tt|operator new}} is a template function, it must have the return type of {{tt|void*}}, the first argument {{tt|size_t}}, and it must have two or more parameters. In other words, only placement forms can be templates.

===Notes===
Even though placement new (overloads 5 and 6) cannot be replaced, a function with the same signature may be defined at class scope as described above. In addition, global overloads that look like placement new but take a non-void pointer type as the second argument are allowed, so the code that wants to ensure that the true placement new is called (e.g. {{lc|std::allocator::construct}}), must use {{tt|::new}} and also cast the pointer to {{tt|void*}}.

===Example===
{{example | Custom placement forms of operator new can be used for any purpose, for example, to fill the allocated array
|code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;

void* operator new[](std::size_t sz, char c)
{
    void* p = operator new[](sz);
    std::fill_n(reinterpret_cast&lt;char*&gt;(p), sz, c);
    return p;
}

int main()
{
    char* p = new('*') char[6];
    p[5] = '\0';
    std::cout &lt;&lt; p &lt;&lt; '\n';
    delete[] p;
}
|output=
*****
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_delete}}
{{dsc inc | cpp/memory/new/dsc get_new_handler}}
{{dsc inc | cpp/memory/new/dsc set_new_handler}}
{{dsc fun | cpp/memory/get_temporary_buffer | obtains uninitialized storage }}
{{dsc fun | cpp/memory/c/malloc | allocates memory}}
{{dsc end}}

[[de:cpp/memory/new/operator new]]
[[es:cpp/memory/new/operator new]]
[[fr:cpp/memory/new/operator new]]
[[it:cpp/memory/new/operator new]]
[[ja:cpp/memory/new/operator new]]
[[pt:cpp/memory/new/operator new]]
[[ru:cpp/memory/new/operator new]]
[[zh:cpp/memory/new/operator new]]</text>
      <sha1>cndet5wdp6bgegs3lkvb3xjwsha8cl7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/new/set new handler</title>
    <ns>0</ns>
    <id>3348</id>
    <revision>
      <id>72156</id>
      <parentid>72155</parentid>
      <timestamp>2014-07-19T14:22:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix see-also to self</comment>
      <text xml:space="preserve" bytes="2890">{{cpp/title|set_new_handler}}
{{cpp/memory/new/navbar}}
{{dcl begin}}
{{dcl header | new}}
{{dcl | |1=
std::new_handler set_new_handler( std::new_handler new_p )
}}
{{dcl end}}

Makes {{tt|new_p}} the new global new-handler function and returns the previously installed new-handler.

The ''new-handler'' function is the function called by {{rlp|operator_new|allocation functions}} whenever a memory allocation attempt fails. Its intended purpose is one of three things:

@1@ make more memory available

@2@ terminate the program (e.g. by calling {{lc|std::terminate}})

@3@ throw exception of type {{lc|std::bad_alloc}} or derived from {{lc|std::bad_alloc}}.

The default implementation throws {{lc|std::bad_alloc}}. The user can install his own ''new-handler'', which may offer behavior different than the default one.

If ''new-handler'' returns, the allocation function repeats the previously-failed allocation attempt and calls the ''new-handler'' again if the allocation fails again. To end the loop, ''new-handler'' may call {{c|std::set_new_handler(nullptr)}}: if, after a failed allocation attempt, allocation function finds that  {{lc|std::get_new_handler}} returns a null pointer value, it will throw {{lc|std::bad_alloc}}.

At program startup, ''new-handler'' is a null pointer.

{{rev begin}}
{{rev|since=c++11|
This function is thread-safe. Every call to {{tt|std::set_new_handler}} ''synchronizes-with'' (see {{lc|std::memory_order}}) the subsequent {{tt|std::set_new_handler}} and {{lc|std::get_new_handler}} calls.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | new_p | pointer to function of type {{lc|std::new_handler}}, or null pointer}}
{{par end}}

===Return value===
The previously-installed new handler, or a null pointer value if none was installed.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;new&gt;

void handler()
{
    std::cout &lt;&lt; &quot;Memory allocation failed, terminating\n&quot;;
    std::set_new_handler(nullptr);
}

int main()
{
    std::set_new_handler(handler);
    try {
        while (true) {
            new int[100000000ul];
        }
    } catch (const std::bad_alloc&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Memory allocation failed, terminating
std::bad_alloc
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/new/dsc operator_new}}
{{dsc inc | cpp/memory/new/dsc get_new_handler}}
{{dsc inc | cpp/memory/new/dsc new_handler}}
{{dsc inc | cpp/memory/new/dsc bad_alloc}}
{{dsc end}}

[[de:cpp/memory/new/set new handler]]
[[es:cpp/memory/new/set new handler]]
[[fr:cpp/memory/new/set new handler]]
[[it:cpp/memory/new/set new handler]]
[[ja:cpp/memory/new/set new handler]]
[[pt:cpp/memory/new/set new handler]]
[[ru:cpp/memory/new/set new handler]]
[[zh:cpp/memory/new/set new handler]]</text>
      <sha1>pl1629xdxgzh02ed532rb4gdlep91pm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/owner less</title>
    <ns>0</ns>
    <id>3307</id>
    <revision>
      <id>65011</id>
      <parentid>62775</parentid>
      <timestamp>2013-08-28T23:56:33Z</timestamp>
      <contributor>
        <ip>85.229.45.98</ip>
      </contributor>
      <text xml:space="preserve" bytes="3397">{{cpp/title|owner_less}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct owner_less; /* undefined */
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct owner_less&lt;std::shared_ptr&lt;T&gt;&gt;;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct owner_less&lt;std::weak_ptr&lt;T&gt;&gt;;
}}
{{dcl end}}

This function object provides owner-based (as opposed to value-based) mixed-type ordering of both {{lc|std::weak_ptr}} and {{lc|std::shared_ptr}}. The order is such that two smart pointers compare equivalent only if they are both empty or if they both manage the same object, even if the values of the raw pointers obtained by {{tt|get()}} are different (e.g. because they point at different subobjects within the same object)

This class template is the preferred comparison predicate when building associative containers with {{lc|std::shared_ptr}} or {{lc|std::weak_ptr}} as keys, that is, 

{{c|std::map&lt;std::shared_ptr&lt;T&gt;, U, std::owner_less&lt;std::shared_ptr&lt;T&gt;&gt;&gt;}}

or

{{c|std::map&lt;std::weak_ptr&lt;T&gt;, U, std::owner_less&lt;std::weak_ptr&lt;T&gt;&gt;&gt;}}.

The default {{c|operator&lt;}} is not defined for weak pointers, and may wrongly consider two shared pointers for the same object non-equivalent (see {{l2tt|cpp/memory/shared_ptr/owner_before}})

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|bool}}}}
{{dsc | {{tt|first_argument_type}} | 1) T&lt;br&gt;2) {{c|std::shared_ptr&lt;T&gt;}}&lt;br&gt;3) {{c|std::weak_ptr&lt;T&gt;}}}}
{{dsc | {{tt|second_argument_type}} | 1) T&lt;br&gt;2) {{c|std::shared_ptr&lt;T&gt;}}&lt;br&gt;3) {{c|std::weak_ptr&lt;T&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc fun | cpp/memory/owner_less | title=operator() | inlinemem=true | compares its arguments using owner-based semantics}}
{{dsc end}}

{{member | {{small|std::owner_less::}}operator() |
{{dcl begin}}
{{dcl | since=c++11 | notes={{mark|member only of {{tt|shared_ptr&lt;T&gt;}} template specialization}} | 
bool operator()( const std::shared_ptr&lt;T&gt;&amp; lhs, 
                 const std::shared_ptr&lt;T&gt;&amp; rhs ) const;
}}
{{dcl | since=c++11 |
bool operator()( const std::shared_ptr&lt;T&gt;&amp; lhs, 
                 const std::weak_ptr&lt;T&gt;&amp; rhs ) const;
}}
{{dcl | since=c++11 |
bool operator()( const std::weak_ptr&lt;T&gt;&amp; lhs, 
                 const std::shared_ptr&lt;T&gt;&amp; rhs ) const;
}}
{{dcl | since=c++11 | notes={{mark|member only of {{tt|weak_ptr&lt;T&gt;}} template specialization}} | 
bool operator()( const std::weak_ptr&lt;T&gt;&amp; lhs, 
                 const std::weak_ptr&lt;T&gt;&amp; rhs ) const;
}}
{{dcl end}}

Compares {{tt|lhs}} and {{tt|rhs}} using owner-based semantics. Effectively calls {{c|lhs.owner_before(rhs)}}.

The ordering is strict weak ordering relation.

{{tt|lhs}} and {{tt|rhs}} are equivalent only if they are both empty or share ownership.

===Parameters===
{{par begin}}
{{par | lhs, rhs | shared-ownership pointers to compare}}
{{par end}}

===Return value===
{{c|true}} if {{tt|lhs}} is ''less than'' {{tt|rhs}} as determined by the owner-based ordering.

===Exceptions===
(none)

}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc owner_before}}
{{dsc end}}

[[de:cpp/memory/owner less]]
[[es:cpp/memory/owner less]]
[[fr:cpp/memory/owner less]]
[[it:cpp/memory/owner less]]
[[ja:cpp/memory/owner less]]
[[pt:cpp/memory/owner less]]
[[ru:cpp/memory/owner less]]
[[zh:cpp/memory/owner less]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/pointer traits</title>
    <ns>0</ns>
    <id>3438</id>
    <revision>
      <id>62776</id>
      <parentid>58352</parentid>
      <timestamp>2013-07-01T23:40:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="3656">{{cpp/title|pointer_traits}}
{{cpp/memory/navbar}}

{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 | num=1 | 1= 
template&lt; class Ptr &gt; struct pointer_traits;
}}
{{dcl | since=c++11 | num=2 | 1= 
template&lt; class T &gt; struct pointer_traits&lt;T*&gt;;
}}
{{dcl end}}

The {{tt|pointer_traits}} class template provides the standardized way to access certain properties of pointer-like types. The standard template {{lc|std::allocator_traits}} relies on {{tt|pointer_traits}} to determine the defaults for various typedefs required by {{concept|Allocator}}.

1) The non-specialized {{tt|pointer_traits}} declares the following types:

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|pointer}} | {{c|Ptr}} }}
{{dsc | {{tt|element_type}} | {{c|Ptr::element_type}} if present. Otherwise {{tt|T}} if {{tt|Ptr}} is a template instantiation {{c|Template&lt;T, Args...&gt;}}  }}
{{dsc | {{tt|difference_type}} | {{c|Ptr::difference_type}} if present, otherwise {{lc|std::ptrdiff_t}} }}
{{dsc end}}

===Member alias templates===
{{dsc begin}}
{{dsc hitem | Template  | Definition }}
{{dsc | template &lt;class U&gt; using rebind | {{c|Ptr::rebind&lt;U&gt;}} if exists, otherwise {{c|Template&lt;U, Args...&gt;}} if {{tt|Ptr}} is a template instantiation {{c|Template&lt;T, Args...&gt;}}  }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem sfun | cpp/memory/pointer_traits/pointer_to | obtains a dereferencable pointer to its argument  }}
{{dsc end}}

2) A specialization is provided for pointer types, {{tt|T*}}, which declares the following types

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|pointer}} | {{c|T*}} }}
{{dsc | {{tt|element_type}} | {{c|T}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc end}}

===Member alias templates===
{{dsc begin}}
{{dsc hitem | Template | Definition }}
{{dsc | template&lt; class U &gt; using rebind | {{c|U*}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem sfun | cpp/memory/pointer_traits/pointer_to | obtains a dereferenceable pointer to its argument} }}
{{dsc end}}

===Notes===
The rebind member template alias makes it possible, given a pointer-like type that points to T, to obtain the same pointer-like type that points to U. For example, 

{{source|
typedef std::pointer_traits&lt;std::shared_ptr&lt;int&gt;&gt;::rebind&lt;double&gt; another_pointer;
static_assert(std::is_same&lt;another_pointer, std::shared_ptr&lt;double&gt;&gt;::value, &quot;&quot;);
}}

===Example===
{{example|
| code= 
#include &lt;memory&gt;
#include &lt;iostream&gt;

template &lt;class Ptr&gt;
struct BlockList
{
   // Predefine a memory block 
   struct block;
   
   // Define a pointer to a memory block from the kind of pointer Ptr s
   // If Ptr is any kind of T*, block_ptr_t is block*
   // If Ptr is smart_ptr&lt;T&gt;, block_ptr_t is smart_ptr&lt;block&gt;
   typedef typename std::pointer_traits&lt;Ptr&gt;::template rebind&lt;block&gt; block_ptr_t;
            
   struct block
   {
      std::size_t size;
      block_ptr_t next_block;
   }; 
   
   block_ptr_t free_blocks;
}; 

int main()
{
    BlockList&lt;int*&gt; bl1;
    // The type of bl1.free_blocks is block*

    BlockList&lt;std::shared_ptr&lt;char&gt;&gt; bl2;
    // The type of bl2.free_blocks is std::shared_ptr&lt;block&gt;
    std::cout &lt;&lt; bl2.free_blocks.use_count() &lt;&lt; '\n';
}
| output=
0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc addressof}}
{{dsc end}}

[[de:cpp/memory/pointer traits]]
[[es:cpp/memory/pointer traits]]
[[fr:cpp/memory/pointer traits]]
[[it:cpp/memory/pointer traits]]
[[ja:cpp/memory/pointer traits]]
[[pt:cpp/memory/pointer traits]]
[[ru:cpp/memory/pointer traits]]
[[zh:cpp/memory/pointer traits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/pointer traits/pointer to</title>
    <ns>0</ns>
    <id>9322</id>
    <revision>
      <id>64891</id>
      <parentid>64890</parentid>
      <timestamp>2013-08-27T01:48:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1966">{{cpp/memory/pointer_traits/title|pointer_to}}
{{cpp/memory/pointer_traits/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 | num=1 | notes={{mark|member of {{tt|pointer_traits&lt;Ptr&gt;}} specialization}} |
static pointer pointer_to( element_type&amp; r );
}}
{{dcl | since=c++11 | num=2 | notes={{mark|member of {{tt|pointer_traits&lt;T*&gt;}} specialization}} |
static pointer pointer_to( element_type&amp; r );
}}
{{dcl end}}

Constructs a dereferenceable pointer to its argument.

@1@ The version of this function in the non-specialized {{lc|std::pointer_traits}} template simply calls {{c|Ptr::pointer_to(r)}}, and if Ptr does not provide a static member function {{tt|pointer_to}}, instantiation of this function is a compile-time error.
@2@ The version of this function in the specialization of {{lc|std::pointer_traits}} for pointer types returns {{c|std::addressof(r)}}

===Parameters===
{{par begin}}
{{par | r | reference to an object of type {{c|element_type&amp;}}, except if element_type is {{c|void}}, in which case the type of {{tt|r}} is unspecified }}
{{par end}}

===Return value===
A dereferenceable pointer to {{tt|r}}, of the type pointer_traits&lt;&gt;::pointer.

===Exceptions===
@1@ Unspecified (typically same as {{c|Ptr::pointer_to}})
@2@ {{noexcept}}

===Notes===
The [http://www.boost.org/doc/libs/release/doc/html/boost/intrusive/pointer_traits.html boost library version] of this function returns {{c|pointer(std::addressof(r))}} if Ptr::pointer_to does not exist.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc addressof}}
{{dsc inc | cpp/memory/allocator/dsc address}}
{{dsc end}}

[[de:cpp/memory/pointer traits/pointer to]]
[[es:cpp/memory/pointer traits/pointer to]]
[[fr:cpp/memory/pointer traits/pointer to]]
[[it:cpp/memory/pointer traits/pointer to]]
[[ja:cpp/memory/pointer traits/pointer to]]
[[pt:cpp/memory/pointer traits/pointer to]]
[[ru:cpp/memory/pointer traits/pointer to]]
[[zh:cpp/memory/pointer traits/pointer to]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/raw storage iterator</title>
    <ns>0</ns>
    <id>3406</id>
    <revision>
      <id>69759</id>
      <parentid>58356</parentid>
      <timestamp>2014-04-22T21:31:09Z</timestamp>
      <contributor>
        <username>Ericwf</username>
        <id>2945</id>
      </contributor>
      <minor/>
      <comment>spelling mistake</comment>
      <text xml:space="preserve" bytes="2435">{{cpp/title|raw_storage_iterator}}
{{cpp/memory/raw_storage_iterator/navbar}}
{{dcl begin}}
{{dcl header| memory}}
{{dcl | |1=
template&lt; class OutputIt, class T &gt;
class raw_storage_iterator
    : public std::iterator&lt;std::output_iterator_tag, void, void, void, void&gt;;
}}
{{dcl end}}

The output iterator {{tt|std::raw_storage_iterator}} makes it possible for standard algorithms to store results in uninitialized memory. Whenever the algorithm writes an object of type {{tt|T}} to the dereferenced iterator, the object is copy-constructed into the location in the uninitialized storage pointed to by the iterator. The template parameter {{tt|OutputIt}} is any type that meets the requirements of {{concept|OutputIterator}} and has {{c|operator*}} defined to return an object, for which {{c|operator&amp;}} returns an object of type {{tt|T*}}. Usually, the type {{tt|T*}} is used as {{tt|OutputIt}}.

===Type requirements===
{{par begin}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc constructor}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc operator*}}
{{dsc inc | cpp/memory/raw_storage_iterator/dsc operator_arith}}
{{dsc end}}

{{cpp/iterator/iterator/inherit|std::output_iterator_tag|void|void|void|void}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;memory&gt;
#include &lt;algorithm&gt;

int main()
{
    const std::string s[] = {&quot;This&quot;, &quot;is&quot;, &quot;a&quot;, &quot;test&quot;, &quot;.&quot;};
    std::string* p = std::get_temporary_buffer&lt;std::string&gt;(5).first;

    std::copy(std::begin(s), std::end(s),
              std::raw_storage_iterator&lt;std::string*, std::string&gt;(p));

    for(std::string* i = p; i!=p+5; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; '\n';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
 | output=
This
is
a
test
.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/memory/raw storage iterator]]
[[es:cpp/memory/raw storage iterator]]
[[fr:cpp/memory/raw storage iterator]]
[[it:cpp/memory/raw storage iterator]]
[[ja:cpp/memory/raw storage iterator]]
[[pt:cpp/memory/raw storage iterator]]
[[ru:cpp/memory/raw storage iterator]]
[[zh:cpp/memory/raw storage iterator]]</text>
      <sha1>nl8wjayr8za2ng9in5v87gnzbctnq7i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/raw storage iterator/operator*</title>
    <ns>0</ns>
    <id>12663</id>
    <revision>
      <id>61438</id>
      <timestamp>2013-06-06T00:28:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="251">{{cpp/memory/raw_storage_iterator/title|operator*}}
{{cpp/memory/raw_storage_iterator/navbar}}
{{dcl begin}}
{{dcl |
raw_storage_iterator&amp; operator*();
}}
{{dcl end}}

Dereferences the iterator.

===Parameters===
(none)

===Return value===
{{c|*this}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/raw storage iterator/operator=</title>
    <ns>0</ns>
    <id>12662</id>
    <revision>
      <id>61439</id>
      <parentid>61437</parentid>
      <timestamp>2013-06-06T00:28:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>1=</comment>
      <text xml:space="preserve" bytes="370">{{cpp/memory/raw_storage_iterator/title|operator{{=}}}}
{{cpp/memory/raw_storage_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
raw_storage_iterator&amp; operator=( const T&amp; el );
}}
{{dcl end}}

Constructs a value at the location the iterator points to from {{tt|el}}.

===Parameters===
{{par begin}}
{{par | el | the value to copy}}
{{par end}}

===Return value===
{{c|*this}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/raw storage iterator/operator arith</title>
    <ns>0</ns>
    <id>12664</id>
    <revision>
      <id>61440</id>
      <timestamp>2013-06-06T00:30:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="483">{{cpp/memory/raw_storage_iterator/title|operator++, operator++{{small|(int)}}}}
{{cpp/memory/raw_storage_iterator/navbar}}
{{dcl begin}}
{{dcl | 1=
raw_storage_iterator&amp; operator++();
}}
{{dcl | 1=
raw_storage_iterator operator++(int);
}}
{{dcl end}}

Advances the iterator.

@1@ Pre-increment. Returns the updated iterator. 

@2@ Post-increment. Returns the old value of the iterator. 

===Parameters===
(none)

===Return value===
@1@ {{c|*this}}

@2@ The old value of the iterator.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/raw storage iterator/raw storage iterator</title>
    <ns>0</ns>
    <id>12661</id>
    <revision>
      <id>61436</id>
      <timestamp>2013-06-06T00:25:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="342">{{cpp/memory/raw_storage_iterator/title|raw_storage_iterator}}
{{cpp/memory/raw_storage_iterator/navbar}}
{{dcl begin}}
{{dcl |
explicit raw_storage_iterator( OutputIt it );
}}
{{dcl end}}

Initializes the iterator to point to the same value as {{tt|it}} points.

===Parameters===
{{par begin}}
{{par | it | location to point to}}
{{par end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/return temporary buffer</title>
    <ns>0</ns>
    <id>3415</id>
    <revision>
      <id>58359</id>
      <parentid>50153</parentid>
      <timestamp>2013-06-01T06:13:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="856">{{cpp/title|return_temporary_buffer}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | 
template&lt; class T &gt;
void return_temporary_buffer( T* p )
}}

Deallocates storage previously allocated with {{lc|std::get_temporary_buffer}}.

===Parameters===
{{par begin}}
{{par | p | the pointer previously returned by {{lc|std::get_temporary_buffer}}}}
{{par end}}

===Return value===
(none)

===Example===
{{include| cpp/memory/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc get_temporary_buffer}}
{{dsc end}}

[[de:cpp/memory/return temporary buffer]]
[[es:cpp/memory/return temporary buffer]]
[[fr:cpp/memory/return temporary buffer]]
[[it:cpp/memory/return temporary buffer]]
[[ja:cpp/memory/return temporary buffer]]
[[pt:cpp/memory/return temporary buffer]]
[[ru:cpp/memory/return temporary buffer]]
[[zh:cpp/memory/return temporary buffer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor</title>
    <ns>0</ns>
    <id>3391</id>
    <revision>
      <id>62777</id>
      <parentid>58360</parentid>
      <timestamp>2013-07-01T23:40:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="4882">{{cpp/title|scoped_allocator_adaptor}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header| scoped_allocator}}
{{dcl | since=c++11 |1=
template&lt; class OuterAlloc, class... InnerAlloc &gt;
class scoped_allocator_adaptor : public OuterAlloc;
}}
{{dcl end}}

The {{tt|std::scoped_allocator_adaptor}} class template is an allocator which can be used with multilevel containers (vector of sets of lists of tuples of maps, etc). It is instantiated with one outer allocator type {{tt|OuterAlloc}} and zero or more inner allocator types {{tt|InnerAlloc...}}. A container constructed directly with a {{tt|scoped_allocator_adaptor}} uses {{tt|OuterAlloc}} to allocate its elements, but if an element is itself a container, it uses the first inner allocator. The elements of that container, if they are themselves containers, use the second inner allocator, etc. If there are more levels to the container than there are inner allocators, the last inner allocator is reused for all further nested containers.

For the purpose of {{tt|scoped_allocator_adaptor}}, if the next inner allocator is {{tt|A}}, any class {{tt|T}} for which {{c|1=std::uses_allocator&lt;T,A&gt;::value == true}} participates in the recursion as if it was a container. Additionally, {{lc|std::pair}} is treated as such a container by specific overloads of {{l2tt|cpp/memory/scoped_allocator_adaptor/construct}}.

Typical implementation holds an instance of a {{tt|std::scoped_allocator_adaptor&lt;InnerAllocs...&gt;}} as a member object.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|outer_allocator_type}} | {{c|OuterAlloc}} }}
{{dsc | {{tt|inner_allocator_type}} | {{c|scoped_allocator_adaptor&lt;InnerAllocs...&gt;}} or, if {{c|1=sizeof...(InnerAllocs) == 0}}, {{c|scoped_allocator_adaptor&lt;OuterAlloc&gt;}}}}
{{dsc | {{tt|value_type}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::value_type}} }}
{{dsc | {{tt|size_type}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::size_type}} }}
{{dsc | {{tt|difference_type}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::difference_type}} }}
{{dsc | {{tt|pointer}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::pointer}} }}
{{dsc | {{tt|const_pointer}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::const_pointer}} }}
{{dsc | {{tt|void_pointer}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::void_pointer}} }}
{{dsc | {{tt|const_void_pointer}} | {{c|std::allocator_traits&lt;OuterAlloc&gt;::const_void_pointer}} }}
{{dsc | {{tt|propagate_on_container_copy_assignment}}
::{{lc|std::true_type}} if {{c|std::allocator_traits&lt;A&gt;::propagate_on_container_copy_assignment::value}} is {{c|true}} for at least one allocator {{tt|A}} among {{tt|OuterAlloc}} and {{tt|InnerAlloc...}} }}
{{dsc | {{tt|propagate_on_container_move_assignment}}
::{{lc|std::true_type}} if {{c|std::allocator_traits&lt;A&gt;::propagate_on_container_move_assignment::value}} is {{c|true}} for at least one allocator {{tt|A}} among {{tt|OuterAlloc}} and {{tt|InnerAlloc...}} }}
{{dsc | {{tt|propagate_on_container_swap}}
::{{lc|std::true_type}} if {{c|std::allocator_traits&lt;A&gt;::propagate_on_container_swap::value}} is {{c|true}} for at least one allocator {{tt|A}} among {{tt|OuterAlloc}} and {{tt|InnerAlloc...}} }}
{{dsc | {{tt|rebind}}

&lt;div style{{=}}&quot;padding-left:3em; max-width: 50em; overflow: hidden;&quot;&gt;
{{source|template&lt; class T &gt;
struct rebind {
    typedef scoped_allocator_adaptor&lt;
        std::allocator_traits&lt;OuterAlloc&gt;::template rebind_alloc&lt;T&gt;, 
        InnerAllocs...
    &gt; other;
};
}} 
&lt;/div&gt;}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc scoped_allocator_adaptor}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc ~scoped_allocator_adaptor}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc inner_allocator}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc outer_allocator}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc allocate}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc deallocate}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc max_size}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc construct}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc destroy}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc select_on_container_copy_construction}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc operator_cmp}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor]]
[[es:cpp/memory/scoped allocator adaptor]]
[[fr:cpp/memory/scoped allocator adaptor]]
[[it:cpp/memory/scoped allocator adaptor]]
[[ja:cpp/memory/scoped allocator adaptor]]
[[pt:cpp/memory/scoped allocator adaptor]]
[[ru:cpp/memory/scoped allocator adaptor]]
[[zh:cpp/memory/scoped allocator adaptor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/allocate</title>
    <ns>0</ns>
    <id>5694</id>
    <revision>
      <id>62778</id>
      <parentid>62399</parentid>
      <timestamp>2013-07-01T23:40:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1376">{{cpp/memory/scoped_allocator_adaptor/title|allocate}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl|num=1 | since=c++11 | 
pointer allocate( size_type n );
}}
{{dcl|num=2 | since=c++11 | 
pointer allocate( size_type n, const_void_pointer hint );
}}
{{dcl end}}

Uses the outer allocator to allocate uninitialized storage.

@1@ Calls {{c|std::allocator_traits&lt;OuterAlloc&gt;::allocate(outer_allocator(), n) }}

@2@ Additionally provides memory locality hint, by calling {{c|std::allocator_traits&lt;OuterAlloc&gt;::allocate(outer_allocator(), n, hint) }}

===Parameters===
{{par begin}}
{{par | n | the number of objects to allocate storage for }}
{{par | hint | pointer to a nearby memory location }}
{{par end}}

===Return value===
The pointer to the allocated storage

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc allocate}}
{{dsc inc | cpp/memory/allocator_traits/dsc allocate}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/allocate]]
[[es:cpp/memory/scoped allocator adaptor/allocate]]
[[fr:cpp/memory/scoped allocator adaptor/allocate]]
[[it:cpp/memory/scoped allocator adaptor/allocate]]
[[ja:cpp/memory/scoped allocator adaptor/allocate]]
[[pt:cpp/memory/scoped allocator adaptor/allocate]]
[[ru:cpp/memory/scoped allocator adaptor/allocate]]
[[zh:cpp/memory/scoped allocator adaptor/allocate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/construct</title>
    <ns>0</ns>
    <id>5678</id>
    <revision>
      <id>58364</id>
      <parentid>50156</parentid>
      <timestamp>2013-06-01T06:13:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="7556">{{cpp/memory/scoped_allocator_adaptor/title|construct}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header | scoped_allocator}}
{{dcl | num=1 |
template &lt; class T, class... Args &gt;
void construct( T* p, Args&amp;&amp;... args )
}}
{{dcl | num=2 |
template&lt; class T1, class T2, class... Args1, class... Args2 &gt;
void construct( std::pair&lt;T1, T2&gt;* p,
                std::piecewise_construct_t,
                std::tuple&lt;Args1...&gt; x,
                std::tuple&lt;Args2...&gt; y )
}}
{{dcl | num=3 |
template&lt; class T1, class T2 &gt;
void construct( std::pair&lt;T1, T2&gt;* p )
}}
{{dcl | num=4|
template&lt; class T1, class T2, class U, class V &gt;
void construct( std::pair&lt;T1, T2&gt;* p, U&amp;&amp; x, V&amp;&amp; y )
}}
{{dcl | num=5|
template&lt; class T1, class T2, class U, class V &gt;
void construct( std::pair&lt;T1, T2&gt;* p, const std::pair&lt;U, V&gt;&amp; xy )
}}
{{dcl | num=6|
template&lt; class T1, class T2, class U, class V &gt;
void construct( std::pair&lt;T1, T2&gt;* p, std::pair&lt;U, V&gt;&amp;&amp; xy );
}}
{{dcl end}}

Constructs an object in allocated, but not initialized storage pointed to by {{tt|p}} using OuterAllocator and the provided constructor arguments. If the object is of type that itself uses allocators, or if it is std::pair, passes InnerAllocator down to the constructed object.

First, determines the outermost allocator type {{tt|OUTERMOST}}: it is the type that would be returned by calling {{c|this-&gt;outer_allocator()}}, and then calling the {{tt|outer_allocator()}} member function recursively on the result of this call until reaching the type that has no such member function. That type is the outermost allocator.

Then:

1) If {{c|1=std::uses_allocator&lt;T, inner_allocator_type&gt;::value==false}} (the type {{tt|T}} does not use allocators) and if {{c|1=std::is_constructible&lt;T, Args...&gt;::value==true}}, then calls

{{c|
std::allocator_traits&lt;OUTERMOST&gt;::construct( OUTERMOST(*this),
                                             p,
                                             std::forward&lt;Args&gt;(args)... );
}}

Otherwise, if {{c|1=std::uses_allocator&lt;T, inner_allocator_type&gt;::value==true}} (the type {{tt|T}} uses allocators, e.g. it is a container) and if {{c|1=std::is_constructible&lt;T, std::allocator_arg_t, inner_allocator_type, Args...&gt;::value==true}}, then calls 

{{c|
std::allocator_traits&lt;OUTERMOST&gt;::construct( OUTERMOST(*this),
                                             p,
                                             std::allocator_arg,
                                             inner_allocator(),
                                             std::forward&lt;Args&gt;(args)... );
}}

Otherwise, {{c|1=std::uses_allocator&lt;T, inner_allocator_type&gt;::value==true}} (the type {{tt|T}} uses allocators, e.g. it is a container) and if {{c|1=std::is_constructible&lt;T, Args..., inner_allocator_type&gt;::value==true}}, then calls

{{c|
std::allocator_traits&lt;OUTERMOST&gt;::construct( OUTERMOST(*this),
                                             p,
                                             std::forward&lt;Args&gt;(args)...,
                                             inner_allocator());
}}

Otherwise, compilation error is issued because although {{tt|std::uses_allocator&lt;T&gt;}} claimed that {{tt|T}} is allocator-aware, it lacks either form of allocator-accepting constructors.

2) First, if either {{tt|T1}} or {{tt|T2}} is allocator-aware, modifies the tuples {{tt|x}} and {{tt|y}} to include the appropriate inner allocator, resulting in the two new tuples {{tt|xprime}} and {{tt|yprime}}, according to the following three rules:

2a) if {{tt|T1}} is not allocator-aware ({{c|1=std::uses_allocator&lt;T1, inner_allocator_type&gt;::value==false}}, then {{tt|xprime}} is {{tt|x}}, unmodified. (it is also required that {{c|1=std::is_constructible&lt;T1, Args1...&gt;::value==true}})

2b) if {{tt|T1}} is allocator-aware ({{c|1=std::uses_allocator&lt;T1, inner_allocator_type&gt;::value==true}}), and its constructor takes an allocator tag ({{c|1=std::is_constructible&lt;T1, std::allocator_arg_t, inner_allocator_type, Args1...&gt;::value==true}}, then {{tt|xprime}} is
{{c|std::tuple_cat( std::tuple&lt;std::allocator_arg_t, inner_allocator_type&amp;&gt;( std::allocator_arg,
                                                                         inner_allocator()
                                                                       ), std::move(x))}}

2c) if {{tt|T1}} is allocator-aware ({{c|1=std::uses_allocator&lt;T1, inner_allocator_type&gt;::value==true}}), and its constructor takes the allocator as the last argument ({{c|1=std::is_constructible&lt;T1, Args1..., inner_allocator_type&gt;::value==true}}), then {{tt|xprime}} is  {{c|std::tuple_cat(std::move(x), std::tuple&lt;inner_allocator_type&amp;&gt;(inner_allocator()))}}.

Same rules apply to {{tt|T2}} and the replacement of {{tt|y}} with {{tt|yprime}}

Once {{tt|xprime}} and {{tt|yprime}} are constructed (this also requires that all types in Args1... and Args2... are {{concept|CopyConstructible}}), constructs the pair {{tt|p}} in allocated storage by calling

{{c|
std::allocator_traits&lt;OUTERMOST&gt;::construct( OUTERMOST(*this),
                                             p,
                                             std::piecewise_construct,
                                             std::move(xprime),
                                             std::move(yprime));
}}


3) Equivalent to {{c|construct(p, std::piecewise_construct, std::tuple&lt;&gt;(), std::tuple&lt;&gt;())}}, that is, passes the inner allocator on to the pair's member types if they accept them.

4) Equivalent to

{{c|
    construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward&lt;U&gt;(x)),
                                           std::forward_as_tuple(std::forward&lt;V&gt;(y)))
}}

5) Equivalent to

{{c|
    construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first),
                                           std::forward_as_tuple(xy.second))
}}

6) Equivalent to

{{c|
    construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward&lt;U&gt;(xy.first)),
                                           std::forward_as_tuple(std::forward&lt;V&gt;(xy.second)))
}}

===Parameters===
{{par begin}}
{{par | p | pointer to allocated, but not initialized storage }}
{{par | args... | the constructor arguments to pass to the constructor of {{tt|T}} }}
{{par | x | the constructor arguments to pass to the constructor of {{tt|T1}} }}
{{par | y | the constructor arguments to pass to the constructor of {{tt|T2}} }}
{{par | xy | the pair whose two members are the constructor arguments for {{tt|T1}} and {{tt|T2}} }}
{{par end}}

===Return value===
(none)

===Notes===
This function is called (through {{lc|std::allocator_traits}}) by any allocator-aware object, such as {{lc|std::vector}}, that was given a {{lc|std::scoped_allocator_adaptor}} as the allocator to use. Since {{tt|inner_allocator}} is itself an instance of {{lc|std::scoped_allocator_adaptor}}, this function will also be called when the allocator-aware objects constructed through this function start constructing their own members.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc construct}}
{{dsc inc | cpp/memory/allocator/dsc construct}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/construct]]
[[es:cpp/memory/scoped allocator adaptor/construct]]
[[fr:cpp/memory/scoped allocator adaptor/construct]]
[[it:cpp/memory/scoped allocator adaptor/construct]]
[[ja:cpp/memory/scoped allocator adaptor/construct]]
[[pt:cpp/memory/scoped allocator adaptor/construct]]
[[ru:cpp/memory/scoped allocator adaptor/construct]]
[[zh:cpp/memory/scoped allocator adaptor/construct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/deallocate</title>
    <ns>0</ns>
    <id>5715</id>
    <revision>
      <id>62779</id>
      <parentid>58367</parentid>
      <timestamp>2013-07-01T23:40:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1208">{{cpp/memory/scoped_allocator_adaptor/title|deallocate}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl | since=c++11 | 
void deallocate( pointer p, size_type n )
}}
{{dcl end}}

Uses the outer allocator to deallocate the storage referenced by {{tt|p}}, by calling {{c|std::allocator_traits&lt;OuterAlloc&gt;::deallocate(outer_allocator(), p, n) }}

===Parameters===
{{par begin}}
{{par | p | pointer to the previously allocated memory }}
{{par | n | the number of objects for which the memory was allocated }}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc deallocate}}
{{dsc inc | cpp/memory/allocator_traits/dsc deallocate}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/deallocate]]
[[es:cpp/memory/scoped allocator adaptor/deallocate]]
[[fr:cpp/memory/scoped allocator adaptor/deallocate]]
[[it:cpp/memory/scoped allocator adaptor/deallocate]]
[[ja:cpp/memory/scoped allocator adaptor/deallocate]]
[[pt:cpp/memory/scoped allocator adaptor/deallocate]]
[[ru:cpp/memory/scoped allocator adaptor/deallocate]]
[[zh:cpp/memory/scoped allocator adaptor/deallocate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/destroy</title>
    <ns>0</ns>
    <id>5691</id>
    <revision>
      <id>62780</id>
      <parentid>58368</parentid>
      <timestamp>2013-07-01T23:40:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1342">{{cpp/memory/scoped_allocator_adaptor/title|destroy}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header | scoped_allocator }}
{{dcl | since=c++11 | 
template&lt; class T &gt;
void destroy( T* p );
}}
{{dcl end}}

Uses the outer allocator to call the destructor of the object pointed to by {{tt|p}}, by calling

{{c|
std::allocator_traits&lt;OUTERMOST&gt;::destroy(OUTERMOST(*this), p)
}}

where OUTERMOST is the type that would be returned by calling {{c|this-&gt;outer_allocator()}}, and then calling the {{tt|outer_allocator()}} member function recursively on the result of this call until reaching the type that has no such member function.

===Parameters===
{{par begin}}
{{par | p | pointer to the object that is going to be destroyed }}
{{par end}}

===Return value===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc destroy}}
{{dsc inc | cpp/memory/allocator/dsc destroy}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/destroy]]
[[es:cpp/memory/scoped allocator adaptor/destroy]]
[[fr:cpp/memory/scoped allocator adaptor/destroy]]
[[it:cpp/memory/scoped allocator adaptor/destroy]]
[[ja:cpp/memory/scoped allocator adaptor/destroy]]
[[pt:cpp/memory/scoped allocator adaptor/destroy]]
[[ru:cpp/memory/scoped allocator adaptor/destroy]]
[[zh:cpp/memory/scoped allocator adaptor/destroy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/inner allocator</title>
    <ns>0</ns>
    <id>5731</id>
    <revision>
      <id>63623</id>
      <parentid>62781</parentid>
      <timestamp>2013-07-11T01:47:02Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1512">{{cpp/memory/scoped_allocator_adaptor/title|inner_allocator}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl | num=1 | since=c++11 | 
inner_allocator_type&amp; inner_allocator()
}}
{{dcl | num=2 | since=c++11 | 
const inner_allocator_type&amp; inner_allocator() const
}}
{{dcl end}}

Obtains a reference to the inner allocator used to declare this {{tt|scoped_allocator_adaptor}}.

If {{c|1=sizeof...(InnerAllocs) == 0}}, that is, no inner allocators were declared, returns {{c|*this}}. Otherwise returns a reference to {{c|std::scoped_allocator_adaptor&lt;InnerAllocs...&gt;}}, that is, a scoped allocator composed of all inner allocators of {{c|*this}}, with the first inner allocator becoming the outer allocator.

===Parameters===
(none)

===Return value===
A reference to the inner allocator, which is itself a {{tt|std::scoped_allocator_adaptor}}.

===Exceptions===
1-2) {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc outer_allocator}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/inner allocator]]
[[es:cpp/memory/scoped allocator adaptor/inner allocator]]
[[fr:cpp/memory/scoped allocator adaptor/inner allocator]]
[[it:cpp/memory/scoped allocator adaptor/inner allocator]]
[[ja:cpp/memory/scoped allocator adaptor/inner allocator]]
[[pt:cpp/memory/scoped allocator adaptor/inner allocator]]
[[ru:cpp/memory/scoped allocator adaptor/inner allocator]]
[[zh:cpp/memory/scoped allocator adaptor/inner allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/max size</title>
    <ns>0</ns>
    <id>5716</id>
    <revision>
      <id>62782</id>
      <parentid>58372</parentid>
      <timestamp>2013-07-01T23:40:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1015">{{cpp/memory/scoped_allocator_adaptor/title|max_size}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl | since=c++11 | 
size_type max_size() const
}}
{{dcl end}}

Reports the maximum allocation size supported by the outer allocator, by calling {{c|std::allocator_traits&lt;OuterAlloc&gt;::max_size(outer_allocator()) }}

===Parameters===
(none)

===Return value===
The maximum allocation size for OuterAlloc.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator/dsc max_size}}
{{dsc inc | cpp/memory/allocator_traits/dsc max_size}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/max size]]
[[es:cpp/memory/scoped allocator adaptor/max size]]
[[fr:cpp/memory/scoped allocator adaptor/max size]]
[[it:cpp/memory/scoped allocator adaptor/max size]]
[[ja:cpp/memory/scoped allocator adaptor/max size]]
[[pt:cpp/memory/scoped allocator adaptor/max size]]
[[ru:cpp/memory/scoped allocator adaptor/max size]]
[[zh:cpp/memory/scoped allocator adaptor/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/operator cmp</title>
    <ns>0</ns>
    <id>9239</id>
    <revision>
      <id>62783</id>
      <parentid>50161</parentid>
      <timestamp>2013-07-01T23:40:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1690">{{title|1=operator==,!={{small|(std::scoped_allocator_adaptor)}}}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class OuterAlloc1, class OuterAlloc2, class... InnerAllocs &gt;
bool operator==( const scoped_allocator_adaptor&lt;OuterAlloc1, InnerAllocs...&gt;&amp; lhs, 
                 const scoped_allocator_adaptor&lt;OuterAlloc2, InnerAllocs...&gt;&amp; rhs );
}}
{{dcl | since=c++11 | 1=
template&lt; class OuterAlloc1, class OuterAlloc2, class... InnerAllocs &gt;
bool operator!=( const scoped_allocator_adaptor&lt;OuterAlloc1, InnerAllocs...&gt;&amp; lhs, 
                 const scoped_allocator_adaptor&lt;OuterAlloc2, InnerAllocs...&gt;&amp; rhs );
}}
{{dcl end}}

Compares two scoped allocator adaptors. Two such allocators are equal if:

* {{c|lhs.outer_allocator() {{==}} rhs.outer_allocator()}}, and
* if {{c|sizeof...(InnerAllocs) &gt; 0}}, {{c|lhs.inner_allocator() {{==}} rhs.inner_allocator()}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | scoped allocator adaptors to compare}}
{{par end}}

===Return value===
@1@ Returns {{c|true}} if {{tt|lhs}} and {{tt|rhs}} are equal, {{c|false}} otherwise.
@2@ Returns {{c|true}} if {{tt|lhs}} and {{tt|rhs}} are not equal, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

[[de:cpp/memory/scoped allocator adaptor/operator cmp]]
[[es:cpp/memory/scoped allocator adaptor/operator cmp]]
[[fr:cpp/memory/scoped allocator adaptor/operator cmp]]
[[it:cpp/memory/scoped allocator adaptor/operator cmp]]
[[ja:cpp/memory/scoped allocator adaptor/operator cmp]]
[[pt:cpp/memory/scoped allocator adaptor/operator cmp]]
[[ru:cpp/memory/scoped allocator adaptor/operator cmp]]
[[zh:cpp/memory/scoped allocator adaptor/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/outer allocator</title>
    <ns>0</ns>
    <id>5730</id>
    <revision>
      <id>62784</id>
      <parentid>58375</parentid>
      <timestamp>2013-07-01T23:40:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1203">{{cpp/memory/scoped_allocator_adaptor/title|outer_allocator}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl | num=1 | since=c++11 | 
outer_allocator_type&amp; outer_allocator()
}}
{{dcl | num=2 | since=c++11 | 
const outer_allocator_type&amp; outer_allocator() const
}}
{{dcl end}}

Obtains a reference to the outer allocator used to declare this class.

1) returns {{c|static_cast&lt;OuterAlloc&amp;&gt;(*this)}}

2) returns {{c|static_cast&lt;const OuterAlloc&amp;&gt;(*this)}}

===Parameters===
(none)

===Return value===
A reference to {{tt|OuterAlloc}}

===Exceptions===
1-2) {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc inner_allocator}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/outer allocator]]
[[es:cpp/memory/scoped allocator adaptor/outer allocator]]
[[fr:cpp/memory/scoped allocator adaptor/outer allocator]]
[[it:cpp/memory/scoped allocator adaptor/outer allocator]]
[[ja:cpp/memory/scoped allocator adaptor/outer allocator]]
[[pt:cpp/memory/scoped allocator adaptor/outer allocator]]
[[ru:cpp/memory/scoped allocator adaptor/outer allocator]]
[[zh:cpp/memory/scoped allocator adaptor/outer allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/scoped allocator adaptor</title>
    <ns>0</ns>
    <id>5732</id>
    <revision>
      <id>62785</id>
      <parentid>58376</parentid>
      <timestamp>2013-07-01T23:40:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2543">{{cpp/memory/scoped_allocator_adaptor/title|scoped_allocator_adaptor}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl|num=1 | since=c++11 | 
scoped_allocator_adaptor()
}}
{{dcl|num=2 | since=c++11 | 
template&lt; class OuterA2 &gt;
scoped_allocator_adaptor( OuterA2&amp;&amp; outerAlloc, const InnerAllocs&amp;... innerAllocs)
}}
{{dcl|num=3 | since=c++11 | 
scoped_allocator_adaptor( const scoped_allocator_adaptor&amp; other )
}}
{{dcl|num=4 | since=c++11 | 
scoped_allocator_adaptor( scoped_allocator_adaptor&amp;&amp; other )
}}
{{dcl|num=5 | since=c++11 | 
template&lt; class OuterA2 &gt;
scoped_allocator_adaptor( const scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp; other )
}}
{{dcl|num=6 | since=c++11 | 
template&lt; class OuterA2 &gt;
scoped_allocator_adaptor( scoped_allocator_adaptor&lt;OuterA2, InnerAllocs...&gt;&amp;&amp; other )
}}
{{dcl end}}

1) Default constructor: value-initializes the {{tt|OuterAlloc}} base class and the inner allocator member object, if used by the implementation.

2) Constructs the base class {{tt|OuterAlloc}} from {{c|std::forward&lt;OuterA2&gt;(outerAlloc)}}, and the inner allocators with {{tt|innerAllocs...}}.

3) Copy-constructor: initializes each allocator from the corresponding allocator of {{tt|other}}

4) Move-constructor: moves each allocator from the corresponding allocator of {{tt|other}} into {{tt|*this}}

5) Initializes each allocator from the corresponding allocator of {{tt|other}}

6) Initializes each allocator from the corresponding allocator of {{tt|other}}, using move semantics.

===Parameters===
{{par begin}}
{{par | outerAlloc | constructor argument for the outer allocator}}
{{par | innerAllocs... | constructor arguments for the inner allocators }}
{{par | other | another {{tt|std::scoped_allocator_adaptor}}}}
{{par end}}

===Exceptions===
2-6) {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc allocate}}
{{dsc inc | cpp/memory/scoped_allocator_adaptor/dsc construct}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[es:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[fr:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[it:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[ja:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[pt:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[ru:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]
[[zh:cpp/memory/scoped allocator adaptor/scoped allocator adaptor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/select on container copy construction</title>
    <ns>0</ns>
    <id>5733</id>
    <revision>
      <id>62786</id>
      <parentid>58379</parentid>
      <timestamp>2013-07-01T23:40:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1436">{{cpp/memory/scoped_allocator_adaptor/title|select_on_container_copy_construction}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{dcl begin}}
{{dcl header|scoped_allocator}}
{{dcl | since=c++11 | 
scoped_allocator_adaptor select_on_container_copy_construction() const
}}
{{dcl end}}

Creates a new instance of {{tt|std::scoped_allocator_adaptor}}, where the outer allocator base class and each inner allocator subobject are obtained by calling {{c|std::allocator_traits&lt;A&gt;::select_on_container_copy_construction()}}.

===Parameters===
(none)

===Return value===
A new {{tt|std::scoped_allocator_adaptor}} object, constructed from correctly copied allocators.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/allocator_traits/dsc select_on_container_copy_construction}}
{{dsc end}}

[[de:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[es:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[fr:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[it:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[ja:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[pt:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[ru:cpp/memory/scoped allocator adaptor/select on container copy construction]]
[[zh:cpp/memory/scoped allocator adaptor/select on container copy construction]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/scoped allocator adaptor/~scoped allocator adaptor</title>
    <ns>0</ns>
    <id>9240</id>
    <revision>
      <id>63344</id>
      <parentid>42422</parentid>
      <timestamp>2013-07-10T01:29:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="767">{{cpp/memory/scoped_allocator_adaptor/title|~scoped_allocator_adaptor}}
{{cpp/memory/scoped_allocator_adaptor/navbar}}
{{ddcl | since=c++11 | 
~scoped_allocator_adaptor();
}}

Destroys the scoped allocator adaptor.

[[de:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[es:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[fr:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[it:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[ja:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[pt:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[ru:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]
[[zh:cpp/memory/scoped allocator adaptor/~scoped allocator adaptor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr</title>
    <ns>0</ns>
    <id>2177</id>
    <revision>
      <id>70073</id>
      <parentid>70072</parentid>
      <timestamp>2014-05-09T10:01:36Z</timestamp>
      <contributor>
        <username>Jwakely</username>
        <id>3078</id>
      </contributor>
      <minor/>
      <comment>formatting and punctuation</comment>
      <text xml:space="preserve" bytes="5669">{{cpp/title|shared_ptr}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl | header=memory | since=c++11 | 1=
template&lt; class T &gt; class shared_ptr;
}}

{{tt|std::shared_ptr}} is a smart pointer that retains shared ownership of an object through a pointer. Several {{tt|shared_ptr}} objects may own the same object. The object is destroyed and its memory deallocated when either of the following happens:

* the last remaining {{tt|shared_ptr}} owning the object is destroyed.

* the last remaining {{tt|shared_ptr}} owning the object is assigned another pointer via {{lc|operator{{=}}}} or {{lc|reset()}}. 

The object is destroyed using {{ltt|cpp/language/delete|delete-expression}} or a custom deleter that is supplied to {{tt|shared_ptr}} during construction.

A {{tt|shared_ptr}} can share ownership of an object while storing a pointer to another object. This feature can be used to point to member objects while owning the object they belong to.

A {{tt|shared_ptr}} may also own no objects, in which case it is called ''empty''.

{{tt|shared_ptr}} meets the requirements of {{concept|CopyConstructible}} and {{concept|CopyAssignable}}.

All member functions (including copy constructor and copy assignment) can be called by multiple threads on different instances of {{tt|shared_ptr}} without additional synchronization even if these instances are copies and share ownership of the same object. If multiple threads of execution access the same {{tt|shared_ptr}} without synchronization and any of those accesses uses a non-const member function of {{tt|shared_ptr}} then a data race will occur, the [[cpp/memory/shared_ptr/atomic|shared_ptr overloads of atomic functions]] can be used to prevent the data race.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|element_type}} | {{c|T}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc constructor}}
{{dsc inc | cpp/memory/shared_ptr/dsc destructor}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator{{=}}}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/memory/shared_ptr/dsc reset}}
{{dsc inc | cpp/memory/shared_ptr/dsc swap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/memory/shared_ptr/dsc get}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator*}}
{{dsc inc | cpp/memory/shared_ptr/dsc use_count}}
{{dsc inc | cpp/memory/shared_ptr/dsc unique}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator bool}}
{{dsc inc | cpp/memory/shared_ptr/dsc owner_before}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc make_shared}}
{{dsc inc | cpp/memory/shared_ptr/dsc allocate_shared}}
{{dsc inc | cpp/memory/shared_ptr/dsc pointer_cast}}
{{dsc inc | cpp/memory/shared_ptr/dsc get_deleter}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator_cmp}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator_ltlt}}
{{dsc inc | cpp/memory/shared_ptr/dsc swap2}}
{{dsc break}}
{{dsc inc | cpp/memory/shared_ptr/dsc atomic}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc hash}}
{{dsc end}}

===Notes===
The ownership of an object can only be shared with another {{tt|shared_ptr}} by copy constructing or copy assigning its value to another {{tt|shared_ptr}}. Constructing a new {{tt|shared_ptr}} using the raw underlying pointer owned by another {{tt|shared_ptr}} leads to undefined behavior.

{{tt|std::shared_ptr}} may be used with an [[cpp/language/incomplete_type|incomplete type]] {{tt|T}}, but {{tt|T}} must be complete at the point in code where the constructor from a raw pointer or the {{tt|reset(T*)}} member function is called (note that {{lc|std::unique_ptr}} may be constructed from a raw pointer to an incomplete type).

===Implementation notes===

In a typical implementation, {{lc|std::shared_ptr}} holds only two pointers:
* a pointer to the managed object
* a pointer to ''control block''

The control block is a dynamically-allocated object that holds:
* either a pointer to the managed object or the managed object itself
* the deleter (type-erased)
* the allocator (type-erased)
* the number of {{tt|shared_ptr}}s that own the managed object
* the number of {{tt|weak_ptr}}s that refer to the managed object

When {{tt|shared_ptr}} is created by calling {{lc|std::make_shared}} or {{lc|std::allocate_shared}}, the memory for both the control block and the managed object is created with a single allocation. The managed object is constructed in-place in a data member of the control block. When {{tt|shared_ptr}} is created via one of the {{tt|shared_ptr}} constructors, the managed object and the control block must be allocated separately.  In this case, the control block stores a pointer to the managed object.

The pointer held by the {{tt|shared_ptr}} directly is the one returned by {{lc|get()}}, while the pointer/object held by the control block is the one that will be deleted when the number of shared owners reaches zero.  These pointers are not necessarily equal.

The destructor of {{tt|shared_ptr}} decrements the number of shared owners of the control block. If that counter reaches zero, the control block calls the destructor of the managed object. The control block does not deallocate itself until the {{lc|std::weak_ptr}} counter reaches zero as well. 

To satisfy thread safety requirements, the reference counters are typically incremented and decremented using {{lc|std::atomic::fetch_add}} with {{lc|std::memory_order_relaxed}}.

[[de:cpp/memory/shared ptr]]
[[es:cpp/memory/shared ptr]]
[[fr:cpp/memory/shared ptr]]
[[it:cpp/memory/shared ptr]]
[[ja:cpp/memory/shared ptr]]
[[pt:cpp/memory/shared ptr]]
[[ru:cpp/memory/shared ptr]]
[[zh:cpp/memory/shared ptr]]</text>
      <sha1>fyog5mqst21vo8gohdlbudtbrv3p2qf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/allocate shared</title>
    <ns>0</ns>
    <id>5307</id>
    <revision>
      <id>58383</id>
      <parentid>50166</parentid>
      <timestamp>2013-06-01T06:13:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2007">{{cpp/title|allocate_shared}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl | header=memory | 
template&lt; class T, class Alloc, class... Args &gt;
shared_ptr&lt;T&gt; allocate_shared( const Alloc&amp; alloc, Args... args );
}}

Constructs an object of type {{tt|T}} and wraps it in a {{lc|std::shared_ptr}} using {{tt|args}} as the parameter list for the constructor of {{tt|T}}.

All memory allocation is done using a copy of {{c|alloc}}, which satisfies the {{concept|Allocator}} requirements. The copy constructor and the destructor of {{tt|Alloc}} must not throw exceptions.

===Parameters===
{{par begin}}
{{par | alloc | The {{concept|Allocator}} to use.}}
{{par | args... | list of arguments with which an instance of {{tt|T}} will be constructed.}}
{{par end}}

===Return value===
{{lc|std::shared_ptr}} of an instance of type {{tt|T}}.

===Exceptions===
Can throw the exceptions thrown from {{c|Alloc::allocate()}} or from the constructor of {{tt|T}}. If an exception is thrown, this function has no effect.

===Notes===
This function typically allocates memory for the T object and for the shared_ptr's control block with a single memory allocation (it is a non-binding requirement in the Standard). In contrast, the declaration {{tt|std::shared_ptr&lt;T&gt; p(new T(Args...))}} performs at least two memory allocations, which may incur unnecessary overhead.

A copy of {{tt|alloc}} is stored as part of the control block so that it can be used to deallocate it once both shared and weak reference counts reach zero.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc constructor}}
{{dsc inc | cpp/memory/shared_ptr/dsc make_shared}}
{{dsc end}}

[[de:cpp/memory/shared ptr/allocate shared]]
[[es:cpp/memory/shared ptr/allocate shared]]
[[fr:cpp/memory/shared ptr/allocate shared]]
[[it:cpp/memory/shared ptr/allocate shared]]
[[ja:cpp/memory/shared ptr/allocate shared]]
[[pt:cpp/memory/shared ptr/allocate shared]]
[[ru:cpp/memory/shared ptr/allocate shared]]
[[zh:cpp/memory/shared ptr/allocate shared]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/atomic</title>
    <ns>0</ns>
    <id>9323</id>
    <revision>
      <id>72276</id>
      <parentid>70074</parentid>
      <timestamp>2014-08-03T02:12:06Z</timestamp>
      <contributor>
        <ip>67.169.103.36</ip>
      </contributor>
      <comment>namespace qualification</comment>
      <text xml:space="preserve" bytes="6425">{{cpp/title | atomic_...{{dsc small|&lt;std::shared_ptr&gt;}}}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
template&lt; class T &gt;
bool atomic_is_lock_free( const std::shared_ptr&lt;T&gt;* p );
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class T &gt;
std::shared_ptr&lt;T&gt; atomic_load( const std::shared_ptr&lt;T&gt;* p );
}}
{{dcl | num=3 | since=c++11 | 1= 
template&lt; class T &gt;
std::shared_ptr&lt;T&gt; atomic_load_explicit( const std::shared_ptr&lt;T&gt;* p,
                                         std::memory_order mo );
}}
{{dcl | num=4 | since=c++11 | 1= 
template&lt; class T &gt;
void atomic_store( std::shared_ptr&lt;T&gt;* p,
                   std::shared_ptr&lt;T&gt; r );
}}
{{dcl | num=5 | since=c++11 | 1= 
template&lt; class T &gt;
void atomic_store_explicit( std::shared_ptr&lt;T&gt;* p,
                            std::shared_ptr&lt;T&gt; r,
                            std::memory_order mo);
}}
{{dcl | num=6 | since=c++11 | 1= 
template&lt; class T &gt;
std::shared_ptr&lt;T&gt; atomic_exchange( std::shared_ptr&lt;T&gt;* p,
                                    std::shared_ptr&lt;T&gt; r);
}}
{{dcl | num=7 | since=c++11 | 1= 
template&lt;class T&gt;
std::shared_ptr&lt;T&gt; atomic_exchange_explicit( std::shared_ptr&lt;T&gt;* p,
                                             std::shared_ptr&lt;T&gt; r,
                                             std::memory_order mo);
}}
{{dcl | num=8 | since=c++11 | 1= 
template&lt; class T &gt;
bool atomic_compare_exchange_weak( std::shared_ptr&lt;T&gt;* p,
                                   std::shared_ptr&lt;T&gt;* expected,
                                   std::shared_ptr&lt;T&gt; desired);
}}
{{dcl | num=9 | since=c++11 | 1= 
template&lt;class T&gt;
bool atomic_compare_exchange_strong( std::shared_ptr&lt;T&gt;* p,
                                     std::shared_ptr&lt;T&gt;* expected,
                                     std::shared_ptr&lt;T&gt; desired);
}}
{{dcl | num=10 | since=c++11 | 1= 
template&lt; class T &gt;
bool atomic_compare_exchange_strong_explicit( std::shared_ptr&lt;T&gt;* p,
                                              std::shared_ptr&lt;T&gt;* expected,
                                              std::shared_ptr&lt;T&gt; desired,
                                              std::memory_order success,
                                              std::memory_order failure);
}}
{{dcl | num=11 | since=c++11 | 1= 
template&lt; class T &gt;
bool atomic_compare_exchange_weak_explicit( std::shared_ptr&lt;T&gt;* p,
                                            std::shared_ptr&lt;T&gt;* expected,
                                            std::shared_ptr&lt;T&gt; desired,
                                            std::memory_order success,
                                            std::memory_order failure);
}}
{{dcl end}}

If multiple threads of execution access the same {{lc|std::shared_ptr}} object without synchronization and any of those accesses uses a non-const member function of {{lc|shared_ptr}} then a data race will occur unless all such access is performed through these functions, which are overloads of the corresponding atomic access functions ({{lc|std::atomic_load}}, {{lc|std::atomic_store}}, etc.)

Note that the control block of a shared_ptr is thread-safe: different {{lc|std::shared_ptr}} objects can be accessed using mutable operations, such as operator= or reset, simultaneously by multiple threads, even when these instances are copies, and share the same control block internally.

@1@ Determines whether atomic access to the shared pointer pointed-to by {{tt|p}} is lock-free.
@2@ Equivalent to {{c|atomic_load_explicit(p, std::memory_order_seq_cst)}}
@3@ Returns the shared pointer pointed-to by {{tt|p}}. As with the non-specialized {{lc|std::atomic_load_explicit}}, {{tt|mo}} cannot be {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}}
@4@ Equivalent to {{c|atomic_store_explicit(p, r, memory_order_seq_cst)}}
@5@ Swaps the shared pointers {{tt|p}} and {{tt|r}}, effectively executing {{c|p-&gt;swap(r)}}. As with the non-specialized {{lc|std::atomic_store_explicit}}, {{tt|mo}} cannot be {{lc|std::memory_order_acquire}} or {{lc|std::memory_order_acq_rel}}
@6@ Equivalent to {{c|atomic_exchange_explicit(p, r, memory_order_seq_cst)}}
@7@ Swaps the shared pointers {{tt|p}} and {{tt|r}}, effectively executing {{c|p-&gt;swap(r)}} and returns a copy of the shared pointer formerly pointed-to by {{tt|p}}
@8@ Equivalent to {{c|atomic_compare_exchange_weak_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)}}
@9@ Equivalent to {{c|atomic_compare_exchange_strong_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst)}}
@10@ Compares the shared pointers pointed-to by {{tt|p}} and {{tt|expected}}. If they are equivalent (share ownership of the same pointer and refer to the same pointer), assigns {{tt|desired}} into {{tt|*p}} using the memory ordering constraints specified by {{tt|success}} and returns {{c|true}}. If they are not equivalent, assigns {{tt|*p}} into {{tt|*expected}} using the memory ordering constraints specified by {{tt|failure}} and returns {{c|false}}.
@11@ Same as 10), but may fail spuriously.

All these functions invoke undefined behavior if {{tt|p}} is a null pointer.

===Parameters===
{{par begin}}
{{par | p, expected | a pointer to a {{lc|std::shared_ptr}} }}
{{par | r, desired | a {{lc|std::shared_ptr}} }}
{{par | mo, success, failure | memory ordering selectors of type {{lc|std::memory_order}} }}
{{par end}}

===Exceptions===
These functions do not throw exceptions.

===Return value===
@1@ {{c|true}} if atomic access is implemented using lock-free instructions
@2,3@ A copy of the pointed-to shared pointer.
@4,5@ (none)
@6,7@ A copy of the formerly pointed-to shared pointer
@8,9,10,11@ {{c|true}} if the shared pointers were equivalent and the exchange was performed, {{c|false}} otherwise.

===Example===
{{example}} &lt;!-- adapt from http://stackoverflow.com/a/16617935/273767 --&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/atomic/dsc atomic_is_lock_free}}
{{dsc inc | cpp/atomic/dsc atomic_store}}
{{dsc inc | cpp/atomic/dsc atomic_load}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc inc | cpp/atomic/dsc atomic_compare_exchange}}
{{dsc end}}

[[de:cpp/memory/shared ptr/atomic]]
[[es:cpp/memory/shared ptr/atomic]]
[[fr:cpp/memory/shared ptr/atomic]]
[[it:cpp/memory/shared ptr/atomic]]
[[ja:cpp/memory/shared ptr/atomic]]
[[pt:cpp/memory/shared ptr/atomic]]
[[ru:cpp/memory/shared ptr/atomic]]
[[zh:cpp/memory/shared ptr/atomic]]</text>
      <sha1>t12ha8668vkqb2uyaidutls5bfhzj1s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/get</title>
    <ns>0</ns>
    <id>2206</id>
    <revision>
      <id>67052</id>
      <parentid>67051</parentid>
      <timestamp>2014-01-18T18:47:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+since</comment>
      <text xml:space="preserve" bytes="1120">{{cpp/memory/shared_ptr/title | get}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl | since=c++11 |
T* get() const;
}}

Returns a pointer to the managed object.

===Parameters===
(none)

===Return value===
A pointer to the managed object.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;

typedef std::shared_ptr&lt;int&gt; IntPtr;

void output(const std::string&amp; msg, int* pInt)
{
    std::cout &lt;&lt; msg &lt;&lt; *pInt &lt;&lt; &quot;\n&quot;;
}

int main()
{
    int* pInt = new int(42);
    IntPtr pShared(new int(42));

    output(&quot;Naked pointer &quot;, pInt);
    // output(&quot;Shared pointer &quot;, pShared); // compiler error
    output(&quot;Shared pointer with get() &quot;, pShared.get());

    delete pInt;
}
 | output=
Naked pointer 42
Shared pointer with get() 42
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator*}}
{{dsc end}}

[[de:cpp/memory/shared ptr/get]]
[[es:cpp/memory/shared ptr/get]]
[[fr:cpp/memory/shared ptr/get]]
[[it:cpp/memory/shared ptr/get]]
[[ja:cpp/memory/shared ptr/get]]
[[pt:cpp/memory/shared ptr/get]]
[[ru:cpp/memory/shared ptr/get]]
[[zh:cpp/memory/shared ptr/get]]</text>
      <sha1>j8cn5cfr26x9c7t63lg9synthgxrjfr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/get deleter</title>
    <ns>0</ns>
    <id>5313</id>
    <revision>
      <id>67535</id>
      <parentid>67519</parentid>
      <timestamp>2014-02-11T12:16:05Z</timestamp>
      <contributor>
        <username>Retep998</username>
        <id>296</id>
      </contributor>
      <minor/>
      <comment>Type: poitner -&gt; pointer</comment>
      <text xml:space="preserve" bytes="2498">{{cpp/title | get_deleter}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
template&lt;class Deleter, class T&gt;
Deleter* get_deleter(const shared_ptr&lt;T&gt; &amp; p);
}}

Access to the {{tt|p}}'s deleter. If the shared pointer {{tt|p}} owns a deleter of type cv-unqualified D (e.g. if it was created with one of the constructors that take a deleter as a parameter), then returns a pointer to the deleter. Otherwise, returns a null pointer.

===Parameters===
{{par begin}}
{{par | p | a shared pointer whose deleter needs to be accessed}}
{{par end}} 

===Return value===
A pointer to the owned deleter or 0. The returned pointer is valid at least as long as there remains at least one {{tt|shared_ptr}} instance that owns it.

===Exceptions===
{{noexcept}}

===Notes===
The returned pointer may outlive the last {{tt|shared_ptr}} if, for example, {{lc|std::weak_ptr}}s remain and the implementation doesn't destroy the deleter until the entire control block is destroyed.

===Example===
{{example|demonstrates that shared_ptr deleter is independent of the shared_ptr's type
|code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo { int i; };
void foo_deleter(Foo * p)
{
    std::cout &lt;&lt; &quot;foo_deleter called!\n&quot;;
    delete p;
}

int main()
{
    std::shared_ptr&lt;int&gt; aptr;

    {
        // create a shared_ptr that owns a Foo and a deleter
        auto foo_p = new Foo;
        std::shared_ptr&lt;Foo&gt; r(foo_p, foo_deleter);
        aptr = std::shared_ptr&lt;int&gt;(r, &amp;r-&gt;i); // aliasing ctor
        // aptr is now pointing to an int, but managing the whole Foo
    } // r gets destroyed (deleter not called)

    // obtain pointer to the deleter:
    if(auto del_p = std::get_deleter&lt;void(*)(Foo*)&gt;(aptr))
    {
        std::cout &lt;&lt; &quot;shared_ptr&lt;int&gt; owns a deleter\n&quot;;
        if(*del_p == foo_deleter)
            std::cout &lt;&lt; &quot;...and it equals &amp;foo_deleter\n&quot;;
    } else
        std::cout &lt;&lt; &quot;The deleter of shared_ptr&lt;int&gt; is null!\n&quot;;
} // deleter called here
|output=
shared_ptr&lt;int&gt; owns a deleter
...and it equals &amp;foo_deleter
foo_deleter called!
}}
===See also===

{{dsc begin}}
{{dsc mem ctor| cpp/memory/shared_ptr/shared_ptr | {{lc|std::shared_ptr}} constructors }}
{{dsc end}}

[[de:cpp/memory/shared ptr/get deleter]]
[[es:cpp/memory/shared ptr/get deleter]]
[[fr:cpp/memory/shared ptr/get deleter]]
[[it:cpp/memory/shared ptr/get deleter]]
[[ja:cpp/memory/shared ptr/get deleter]]
[[pt:cpp/memory/shared ptr/get deleter]]
[[ru:cpp/memory/shared ptr/get deleter]]
[[zh:cpp/memory/shared ptr/get deleter]]</text>
      <sha1>owm3xwuxvwku6c4kcv1bvauhtlsl9ii</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/hash</title>
    <ns>0</ns>
    <id>5314</id>
    <revision>
      <id>62788</id>
      <parentid>58388</parentid>
      <timestamp>2013-07-01T23:40:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="854">{{cpp/title | hash}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt;class T&gt; struct hash&lt;shared_ptr&lt;T&gt;&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for {{c|std::shared_ptr&lt;T&gt;}} allows users to obtain hashes of objects of type {{c|std::shared_ptr&lt;T&gt;}}.

For a given {{c|1=std::shared_ptr&lt;T&gt; p}}, this specialization ensures that  {{c|1=std::hash&lt;std::shared_ptr&lt;T&gt;&gt;()(p) == std::hash&lt;T*&gt;()(p.get())}}.

===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

[[de:cpp/memory/shared ptr/hash]]
[[es:cpp/memory/shared ptr/hash]]
[[fr:cpp/memory/shared ptr/hash]]
[[it:cpp/memory/shared ptr/hash]]
[[ja:cpp/memory/shared ptr/hash]]
[[pt:cpp/memory/shared ptr/hash]]
[[ru:cpp/memory/shared ptr/hash]]
[[zh:cpp/memory/shared ptr/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/make shared</title>
    <ns>0</ns>
    <id>4940</id>
    <revision>
      <id>72214</id>
      <parentid>72152</parentid>
      <timestamp>2014-07-24T04:36:47Z</timestamp>
      <contributor>
        <username>Marc van Leeuwen</username>
        <id>3164</id>
      </contributor>
      <comment>the function foo needs no ownership of shared pointer, so passing by reference is more efficient (smaller, and avoids temporary changes to the ref count)</comment>
      <text xml:space="preserve" bytes="2324">{{cpp/title|make_shared}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl | header=memory | 
template&lt; class T, class... Args &gt;
shared_ptr&lt;T&gt; make_shared( Args&amp;&amp;... args );
}}

Constructs an object of type {{tt|T}} and wraps it in a {{lc|std::shared_ptr}} using {{tt|args}} as the parameter list for the constructor of {{tt|T}}.

===Parameters===
{{par begin}}
{{par | args | list of arguments with which an instance of {{tt|T}} will be constructed.}}
{{par end}}

===Return value===
{{lc|std::shared_ptr}} of an instance of type {{tt|T}}.

===Exceptions===
May throw {{lc|std::bad_alloc}} or any exception thrown by the constructor of {{tt|T}}. If an exception is thrown, this function has no effect.

===Notes===
This function is typically used to replace the construction {{c|std::shared_ptr&lt;T&gt;(new T(args...))}} of a shared pointer from the raw pointer returned by a call to {{tt|new}}. In contrast to that expression, {{c|std::make_shared&lt;T&gt;}} typically allocates memory for the {{tt|T}} object and for the {{c|std::shared_ptr}}'s control block with a single memory allocation (this is a non-binding requirement in the Standard), where {{c|std::shared_ptr&lt;T&gt;(new T(args...))}} performs at least two memory allocations.

Moreover, code such as {{c|f(std::shared_ptr&lt;int&gt;(new int(42)), g())}} can cause a memory leak if {{tt|g}} throws an exception because {{tt|g()}} may be called after {{tt|new int(42)}} and before the constructor of {{tt|shared_ptr&lt;int&gt;}}. This doesn't occur in {{c|f(std::make_shared&lt;int&gt;(42), g())}}, since two function calls are [[cpp/language/eval_order|never interleaved]].

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

void foo(const std::shared_ptr&lt;int&gt;&amp; i)
{
    (*i)++;
}

int main()
{
    auto sp = std::make_shared&lt;int&gt;(12);
    foo(sp);
    std::cout &lt;&lt; *sp &lt;&lt; std::endl;
}
 | output=
13
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc constructor}}
{{dsc inc | cpp/memory/shared_ptr/dsc allocate_shared}}
{{dsc end}}

[[de:cpp/memory/shared ptr/make shared]]
[[es:cpp/memory/shared ptr/make shared]]
[[fr:cpp/memory/shared ptr/make shared]]
[[it:cpp/memory/shared ptr/make shared]]
[[ja:cpp/memory/shared ptr/make shared]]
[[pt:cpp/memory/shared ptr/make shared]]
[[ru:cpp/memory/shared ptr/make shared]]
[[zh:cpp/memory/shared ptr/make shared]]</text>
      <sha1>2qx57mqs3a3yphdyu6rxo4tzdvnfo0m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/operator*</title>
    <ns>0</ns>
    <id>2207</id>
    <revision>
      <id>58392</id>
      <parentid>50172</parentid>
      <timestamp>2013-06-01T06:13:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="817">{{cpp/memory/shared_ptr/title | operator* | operator-&amp;gt;}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1= 
T&amp; operator*() const;
}}
{{dcl | num=2 | 1=
T* operator-&gt;() const;
}}
{{dcl end}}

Dereferences pointer to the managed object.

===Parameters===
(none)

===Return value===
1) reference to the managed object.

2) pointer to the managed object.

===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/shared ptr/operator*]]
[[es:cpp/memory/shared ptr/operator*]]
[[fr:cpp/memory/shared ptr/operator*]]
[[it:cpp/memory/shared ptr/operator*]]
[[ja:cpp/memory/shared ptr/operator*]]
[[pt:cpp/memory/shared ptr/operator*]]
[[ru:cpp/memory/shared ptr/operator*]]
[[zh:cpp/memory/shared ptr/operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/operator=</title>
    <ns>0</ns>
    <id>2203</id>
    <revision>
      <id>72091</id>
      <parentid>58393</parentid>
      <timestamp>2014-07-14T11:04:44Z</timestamp>
      <contributor>
        <username>Marc van Leeuwen</username>
        <id>3164</id>
      </contributor>
      <comment>Documented the assignment to shared-pointer from auto-pointer case</comment>
      <text xml:space="preserve" bytes="2744">{{cpp/memory/shared_ptr/title | operator{{=}}}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1= 
shared_ptr&amp; operator=( const shared_ptr&amp; r );
}}
{{dcl | num=1 | 1= 
template&lt; class Y &gt; 
shared_ptr&amp; operator=( const shared_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=2 | 1= 
shared_ptr&amp; operator=( shared_ptr&amp;&amp; r );
}}
{{dcl | num=2 | 1= 
template&lt; class Y &gt; 
shared_ptr&amp; operator=( shared_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl | num=3 | 1= 
template&lt; class Y &gt; 
shared_ptr&amp; operator=( std::auto_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl | num=4 | 1= 
template&lt; class Y, class Deleter &gt; 
shared_ptr&amp; operator=( std::unique_ptr&lt;Y,Deleter&gt;&amp;&amp; r );
}}
{{dcl end}}

Replaces the managed object with the one managed by {{tt|r}}.

1) Shares ownership of the object managed by {{tt|r}}. If {{tt|r}} manages no object, {{tt|*this}} manages no object too. The templated overload doesn't participate in the overload resolution if {{tt|Y*}} is not implicitly convertible to {{tt|T*}}. Equivalent to {{c|shared_ptr&lt;T&gt; p(r).swap(*this)}}.

2) Move-assigns a {{tt|shared_ptr}} from {{tt|r}}. After the assignment, {{c|*this}} contains a copy of the previous state of {{tt|r}}, {{tt|r}} is empty. The templated overload doesn't participate in the overload resolution if {{tt|Y*}} is not implicitly convertible to {{tt|T*}}. Equivalent to {{c|shared_ptr&lt;T&gt; p(std::move(r)).swap(*this)}}.

3) Transfers the ownership of the object managed by {{tt|r}} to {{tt|*this}}. If {{tt|r}} manages no object, {{tt|*this}} manages no object too. After the assignment, {{tt|*this}} contains the pointer previously held by {{tt|r}}, and {{c|use_count(){{==}}1}}; also {{tt|r}} is empty. Equivalent to {{c|shared_ptr&lt;T&gt; p(r).swap(*this)}}.

4) Transfers the ownership of the object managed by {{tt|r}} to {{c|*this}}. The deleter associated to {{tt|r}} is stored for future deletion of the managed object. {{tt|r}} manages no object after the call. Equivalent to {{c|shared_ptr&lt;T&gt; p(std::move(r)).swap(*this)}}.

===Parameters===
{{par begin}}
{{par | r | another smart pointer to share the ownership to or acquire the ownership from}}
{{par end}} 

===Return value===
{{c|*this}}

===Notes===
The implementation may meet the requirements without creating a temporary {{tt|shared_ptr}} object.

===Exceptions===
1-2) {{noexcept}}

3) (none)

4-5) {{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc reset}}
{{dsc end}}

[[de:cpp/memory/shared ptr/operator=]]
[[es:cpp/memory/shared ptr/operator=]]
[[fr:cpp/memory/shared ptr/operator=]]
[[it:cpp/memory/shared ptr/operator=]]
[[ja:cpp/memory/shared ptr/operator=]]
[[pt:cpp/memory/shared ptr/operator=]]
[[ru:cpp/memory/shared ptr/operator=]]
[[zh:cpp/memory/shared ptr/operator=]]</text>
      <sha1>sdjmh1cjmp27bqwy3krz7ifce5i3y6u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/operator bool</title>
    <ns>0</ns>
    <id>2210</id>
    <revision>
      <id>72082</id>
      <parentid>58396</parentid>
      <timestamp>2014-07-13T14:28:47Z</timestamp>
      <contributor>
        <ip>46.249.80.111</ip>
      </contributor>
      <text xml:space="preserve" bytes="1201">{{cpp/memory/shared_ptr/title | operator bool}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
explicit operator bool() const;
}}

Checks if {{c|*this}} manages an object, i.e. whether {{c|1=get() != nullptr}}.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} manages an object, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

typedef std::shared_ptr&lt;int&gt; IntPtr;

void report(IntPtr ptr) 
{
    if (ptr) {
        std::cout &lt;&lt; &quot;*ptr=&quot; &lt;&lt; *ptr &lt;&lt; &quot;\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;ptr is not a valid pointer.\n&quot;;
    }
}

int main()
{
    IntPtr ptr;
    report(ptr);

    ptr = IntPtr(new int(7));
    report(ptr);
}
 | output=
ptr is not a valid pointer.
*ptr=7
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/shared ptr/operator bool]]
[[es:cpp/memory/shared ptr/operator bool]]
[[fr:cpp/memory/shared ptr/operator bool]]
[[it:cpp/memory/shared ptr/operator bool]]
[[ja:cpp/memory/shared ptr/operator bool]]
[[pt:cpp/memory/shared ptr/operator bool]]
[[ru:cpp/memory/shared ptr/operator bool]]
[[zh:cpp/memory/shared ptr/operator bool]]</text>
      <sha1>a413kcv49carnrzj7npjbcs90np296t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/operator cmp</title>
    <ns>0</ns>
    <id>5738</id>
    <revision>
      <id>70121</id>
      <parentid>66467</parentid>
      <timestamp>2014-05-10T12:38:37Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="4295">{{cpp/memory/shared_ptr/title | operator{{==}}, !{{=}}, &amp;lt;, &amp;lt;{{=}}, &amp;gt;, &amp;gt;{{=}} }}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl h | Compare two {{tt|shared_ptr}} objects}}
{{dcl | num=1 | since=c++11 | 1= 
template &lt; class T, class U &gt; 
bool operator==( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
bool operator!=( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}
{{dcl | num=3 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
bool operator&lt;( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}
{{dcl | num=4 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
bool operator&gt;( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}
{{dcl | num=5 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
bool operator&lt;=( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}
{{dcl | num=6 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
bool operator&gt;=( const shared_ptr&lt;T&gt;&amp; lhs, const shared_ptr&lt;U&gt;&amp; rhs );
}}

{{dcl h | Compare a {{tt|shared_ptr}} with a null pointer }}
{{dcl | num=7 | since=c++11 | 1= 
template&lt; class T &gt; 
bool operator==( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=8 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator==( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}
{{dcl | num=9 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator!=( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=10 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator!=( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}
{{dcl | num=11 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&lt;( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=12 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&lt;( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}
{{dcl | num=13 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&lt;=( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=14 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&lt;=( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}
{{dcl | num=15 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&gt;( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=16 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&gt;( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}
{{dcl | num=17 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&gt;=( const shared_ptr&lt;T&gt;&amp; lhs, std::nullptr_t rhs );
}}
{{dcl | num=18 | since=c++11 | 1= 
template&lt; class T &gt;
bool operator&gt;=( std::nullptr_t lhs, const shared_ptr&lt;T&gt;&amp; rhs );
}}

{{dcl end}}

Compares two {{tt|shared_ptr&lt;T&gt;}} objects or compares {{tt|shared_ptr&lt;T&gt;}} with a null pointer.

Note that the comparison operators for {{tt|shared_ptr}} simply compare pointer values; the actual objects pointed to are ''not'' compared.  Having {{tt|operator&lt;}} defined for {{tt|shared_ptr}} allows {{tt|shared_ptr}}s to be used as keys in associative containers, like {{lc|std::map}} and {{lc|std::set}}.

===Parameters===
{{par begin}}
{{par | lhs | the left-hand {{tt|shared_ptr}} to compare }}
{{par | rhs | the right-hand {{tt|shared_ptr}} to compare }}
{{par end}} 

===Return value===
@1@ {{tt|lhs.get() {{==}} rhs.get()}}

@2@ {{c|1=!(lhs == rhs)}}

@3@ {{c|std::less&lt;V&gt;()(lhs.get(), rhs.get())}}, where V is the [[cpp/language/operator_comparison#Pointer comparison operators|composite pointer type]] of T* and U*

@4@ {{c|rhs &lt; lhs}}

@5@ {{c|!(rhs &lt; lhs)}}

@6@ {{c|!(lhs &lt; rhs)}}

@7@ {{c|!lhs}}

@8@ {{c|!rhs}}

@9@ {{c|(bool)lhs}}

@10@ {{c|(bool)rhs}} 

@11@ {{c|std::less&lt;T*&gt;()(lhs.get(), nullptr)}}

@12@ {{c|std::less&lt;T*&gt;()(nullptr, rhs.get())}}

@13@ {{c|nullptr &lt; lhs}}

@14@ {{c|rhs &lt; nullptr}}

@15@ {{c|!(nullptr &lt; lhs)}}

@16@ {{c|!(rhs &lt; nullptr)}}

@17@ {{c|!(lhs &lt; nullptr)}}

@18@ {{c|!(nullptr &lt; rhs)}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/shared ptr/operator cmp]]
[[es:cpp/memory/shared ptr/operator cmp]]
[[fr:cpp/memory/shared ptr/operator cmp]]
[[it:cpp/memory/shared ptr/operator cmp]]
[[ja:cpp/memory/shared ptr/operator cmp]]
[[pt:cpp/memory/shared ptr/operator cmp]]
[[ru:cpp/memory/shared ptr/operator cmp]]
[[zh:cpp/memory/shared ptr/operator cmp]]</text>
      <sha1>1hp2wmd8lwxop8mcyph51v322uacj3u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/operator ltlt</title>
    <ns>0</ns>
    <id>5739</id>
    <revision>
      <id>58400</id>
      <parentid>50176</parentid>
      <timestamp>2013-06-01T06:14:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1245">{{cpp/memory/shared_ptr/title | operator&amp;lt;&amp;lt;}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | 1= 
template &lt;class T, class U, class V&gt;
    basic_ostream&lt;U, V&gt;&amp; operator&lt;&lt;(basic_ostream&lt;U, V&gt;&amp; os, const shared_ptr&lt;T&gt;&amp; ptr);
}}
{{dcl end}}

Inserts a {{tt|shared_ptr&lt;T&gt;}} into a {{lc|std::basic_ostream}}.

Equivalent to {{tt|os &lt;&lt; ptr.get()}}.

===Parameters===
{{par begin}}
{{par | os | a {{lc|std::basic_ostream}} to insert {{tt|ptr}} into }}
{{par | ptr | the data to be inserted into {{tt|os}} }}
{{par end}} 

===Return value===
{{tt|os}}

===Example===
{{example
 | p=true 
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

class Foo {};

int main()
{
    auto sp = std::make_shared&lt;Foo&gt;();
    std::cout &lt;&lt; sp &lt;&lt; std::endl;
    std::cout &lt;&lt; sp.get() &lt;&lt; std::endl;
}
 | output=
0x6d9028
0x6d9028
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/shared ptr/operator ltlt]]
[[es:cpp/memory/shared ptr/operator ltlt]]
[[fr:cpp/memory/shared ptr/operator ltlt]]
[[it:cpp/memory/shared ptr/operator ltlt]]
[[ja:cpp/memory/shared ptr/operator ltlt]]
[[pt:cpp/memory/shared ptr/operator ltlt]]
[[ru:cpp/memory/shared ptr/operator ltlt]]
[[zh:cpp/memory/shared ptr/operator ltlt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/owner before</title>
    <ns>0</ns>
    <id>2211</id>
    <revision>
      <id>42299</id>
      <parentid>20929</parentid>
      <timestamp>2012-11-02T22:47:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="375">{{cpp/memory/owner_before|shared_ptr}}

[[de:cpp/memory/shared ptr/owner before]]
[[es:cpp/memory/shared ptr/owner before]]
[[fr:cpp/memory/shared ptr/owner before]]
[[it:cpp/memory/shared ptr/owner before]]
[[ja:cpp/memory/shared ptr/owner before]]
[[pt:cpp/memory/shared ptr/owner before]]
[[ru:cpp/memory/shared ptr/owner before]]
[[zh:cpp/memory/shared ptr/owner before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/pointer cast</title>
    <ns>0</ns>
    <id>5308</id>
    <revision>
      <id>66412</id>
      <parentid>62789</parentid>
      <timestamp>2013-11-20T15:24:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>grammar</comment>
      <text xml:space="preserve" bytes="1629">{{cpp/title | static_pointer_cast | dynamic_pointer_cast | const_pointer_cast}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
shared_ptr&lt;T&gt; static_pointer_cast( const shared_ptr&lt;U&gt;&amp; r );
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
shared_ptr&lt;T&gt; dynamic_pointer_cast( const shared_ptr&lt;U&gt;&amp; r );
}}
{{dcl | num=3 | since=c++11 | 1= 
template&lt; class T, class U &gt; 
shared_ptr&lt;T&gt; const_pointer_cast( const shared_ptr&lt;U&gt;&amp; r );
}}

{{dcl end}}
Creates a new instance of {{lc|std::shared_ptr}} whose managed object type is obtained from the {{tt|r}}'s managed object type using a cast expression. Both smart pointers will share the ownership of the managed object.

The resulting {{lc|std::shared_ptr}}'s managed object will be obtained by calling (in respective order):

@1@ {{tt|static_cast&lt;T*&gt;(r.get())}}.

@2@ {{tt|dynamic_cast&lt;T*&gt;(r.get())}} (If the result of the {{tt|dynamic_cast}} is 0, the returned shared_ptr will be empty).

@3@ {{tt|const_cast&lt;T*&gt;(r.get())}}.

In any case, if the parameter {{tt|r}} is an empty {{lc|std::shared_ptr}} the result will be a new empty {{lc|std::shared_ptr}}.

===Parameters===
{{par begin}}
{{par | r | The pointer to convert}}
{{par end}}

===Exceptions===
{{noexcept}}

[[de:cpp/memory/shared ptr/pointer cast]]
[[es:cpp/memory/shared ptr/pointer cast]]
[[fr:cpp/memory/shared ptr/pointer cast]]
[[it:cpp/memory/shared ptr/pointer cast]]
[[ja:cpp/memory/shared ptr/pointer cast]]
[[pt:cpp/memory/shared ptr/pointer cast]]
[[ru:cpp/memory/shared ptr/pointer cast]]
[[zh:cpp/memory/shared ptr/pointer cast]]</text>
      <sha1>blihiy7r8ulcks9br6yhndzwmchfkkc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/reset</title>
    <ns>0</ns>
    <id>2204</id>
    <revision>
      <id>72381</id>
      <parentid>72377</parentid>
      <timestamp>2014-08-18T13:51:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>edited example (slightly shorter, and print the value in ctors and dtors to show in which order it happens)</comment>
      <text xml:space="preserve" bytes="3949">{{cpp/memory/shared_ptr/title | reset}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
void reset();
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class Y &gt; 
void reset( Y* ptr );
}}
{{dcl | num=3 | since=c++11 | 1= 
template&lt; class Y, class Deleter &gt; 
void reset( Y* ptr, Deleter d );
}}
{{dcl | num=4 | since=c++11 | 1= 
template&lt; class Y, class Deleter, class Alloc &gt; 
void reset( Y* ptr, Deleter d, Alloc alloc );
}}
{{dcl end}}

Replaces the managed object with an object pointed to by {{tt|ptr}}. Optional deleter {{tt|d}} can be supplied, which is later used to destroy the new object when no {{tt|shared_ptr}} objects own it. By default, {{ltt|cpp/language/delete}} expression is used as deleter. Proper {{ltt|cpp/language/delete}} expression corresponding to the supplied type is always selected, this is the reason why the function is implemented as template using a separate parameter {{tt|Y}}.

If {{tt|*this}} already owns an object and it is the last {{tt|shared_ptr}} owning it, the object is destroyed through the owned deleter.

If the object pointed to by {{tt|ptr}} is already owned, the function results in undefined behavior.

@1@ Releases the ownership of the managed object, if any. After the call, {{c|*this}} manages no object. Equivalent to {{c|shared_ptr().swap(*this);}}

@2-4@ Replaces the managed object with an object pointed to by {{tt|ptr}}. {{tt|Y}} must be a complete type and implicitly convertible to {{tt|T}}. Additionally:

:@2@ Uses the delete expression as the deleter. A valid delete expression must be available, i.e. {{c|delete ptr}} must be well formed, have well-defined behavior and not throw any exceptions. Effectively calls {{c|shared_ptr&lt;T&gt;(ptr).swap(*this);}}.

:@3@ Uses the specified deleter {{tt|d}} as the deleter. {{tt|Deleter}} must be callable for the type {{tt|T}}, i.e. {{c|d(ptr)}} must be well formed, have well-defined behavior and not throw any exceptions. {{tt|Deleter}} must be {{concept|CopyConstructible}}. Effectively calls {{c|shared_ptr&lt;T&gt;(ptr, d).swap(*this);}}.

:@4@ Same as (3), but additionally uses a copy of {{tt|alloc}} for allocation of data for internal use. {{tt|Alloc}} must be a {{concept|Allocator}}. The copy constructor and destructor must not throw exceptions. Effectively calls {{c|shared_ptr&lt;T&gt;(ptr, d, alloc).swap(*this);}}.

===Parameters===
{{par begin}}
{{par | ptr | pointer to an object to acquire ownership of}}
{{par | d | deleter to store for deletion of the object}}
{{par | alloc | allocator to use for internal allocations}}
{{par end}} 

===Return value===
(none)

===Exceptions===
@1@ {{noexcept}}

@2-4@ As specified by the relevant constructor {{todo}}.

===Example===
{{example
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;

struct Foo {
    Foo(int n = 0) noexcept : bar(n) {
        std::cout &lt;&lt; &quot;Foo: constructor, bar = &quot; &lt;&lt; bar &lt;&lt; '\n';
    }
    ~Foo() {
         std::cout &lt;&lt; &quot;Foo: destructor, bar = &quot; &lt;&lt; bar &lt;&lt; '\n';
    }
    int getBar() const noexcept { return bar; }
private:
    int bar;
};

int main()
{
    std::shared_ptr&lt;Foo&gt; sptr = std::make_shared&lt;Foo&gt;(1);
    std::cout &lt;&lt; &quot;The first Foo's bar is &quot; &lt;&lt; sptr-&gt;getBar() &lt;&lt; &quot;\n&quot;;

    // reset the shared_ptr, hand it a fresh instance of Foo
    // (the old instance will be destroyed ater this call)
    sptr.reset(new Foo);
    std::cout &lt;&lt; &quot;The second Foo's bar is &quot; &lt;&lt; sptr-&gt;getBar() &lt;&lt; &quot;\n&quot;;
}
 | output=
Foo: constructor, bar = 1
The first Foo's bar is 1
Foo: constructor, bar = 0
Foo: destructor, bar = 1
The second Foo's bar is 0
Foo: destructor, bar = 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc constructor}}
{{dsc end}}

[[de:cpp/memory/shared ptr/reset]]
[[es:cpp/memory/shared ptr/reset]]
[[fr:cpp/memory/shared ptr/reset]]
[[it:cpp/memory/shared ptr/reset]]
[[ja:cpp/memory/shared ptr/reset]]
[[pt:cpp/memory/shared ptr/reset]]
[[ru:cpp/memory/shared ptr/reset]]
[[zh:cpp/memory/shared ptr/reset]]</text>
      <sha1>hji3y54i9g8tm016g9jzzz9g0101fiq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/shared ptr</title>
    <ns>0</ns>
    <id>2200</id>
    <revision>
      <id>67367</id>
      <parentid>67366</parentid>
      <timestamp>2014-02-06T15:08:52Z</timestamp>
      <contributor>
        <ip>199.172.169.97</ip>
      </contributor>
      <comment>T comes from templatized class</comment>
      <text xml:space="preserve" bytes="8452">{{cpp/memory/shared_ptr/title | shared_ptr}}
{{cpp/memory/shared_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1= 
constexpr shared_ptr();
}}
{{dcl | num=2 | 1= 
template&lt; class Y &gt; 
explicit shared_ptr( Y* ptr );
}}
{{dcl | num=3 | 1= 
template&lt; class Y, class Deleter &gt; 
shared_ptr( Y* ptr, Deleter d );
}}
{{dcl | num=4 | 1= 
template&lt; class Y, class Deleter, class Alloc &gt; 
shared_ptr( Y* ptr, Deleter d, Alloc alloc );
}}

{{dcl | num=5 | 1= 
constexpr shared_ptr( std::nullptr_t );
}}
{{dcl | num=6 | 1= 
template&lt; class Deleter &gt; 
shared_ptr( std::nullptr_t, Deleter d );
}}
{{dcl | num=7 | 1= 
template&lt; class Deleter, class Alloc &gt; 
shared_ptr( std::nullptr_t, Deleter d, Alloc alloc );
}}
{{dcl | num=8 | 1= 
template&lt; class Y &gt; 
shared_ptr( const shared_ptr&lt;Y&gt;&amp; r, T *ptr );
}}
{{dcl | num=9 | 1= 
shared_ptr( const shared_ptr&amp; r );
}}
{{dcl | num=9 | 1= 
template&lt; class Y &gt; 
shared_ptr( const shared_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=10 | 1= 
shared_ptr( shared_ptr&amp;&amp; r );
}}
{{dcl | num=10 | 1= 
template&lt; class Y &gt; 
shared_ptr( shared_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl | num=11 | 1= 
template&lt; class Y &gt; 
explicit shared_ptr( const std::weak_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=12 | 1= 
template&lt; class Y &gt; 
shared_ptr( std::auto_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl | num=13 | 1= 
template&lt; class Y, class Deleter &gt; 
shared_ptr( std::unique_ptr&lt;Y,Deleter&gt;&amp;&amp; r );
}}
{{dcl end}}

Constructs new {{tt|shared_ptr}} from a variety of pointer types that refer to an object to manage. 

An optional deleter {{tt|d}} can be supplied that is later used to destroy the object when no {{tt|shared_ptr}} objects own it. By default, a [[cpp/language/delete|delete-expression]] for type {{tt|Y}} is used as the deleter.

@1@ Default constructor constructs a {{tt|shared_ptr}} with no managed object, i.e. empty {{tt|shared_ptr}}

@2-4@ Constructs a {{tt|shared_ptr}} with {{tt|ptr}} as the pointer to the managed object. {{tt|Y}} must be a complete type and {{tt|ptr}} must be convertible to {{tt|T*}}. Additionally:

:@2@ Uses the delete expression as the deleter. A valid delete expression must be available, i.e. {{c|delete ptr}} must be well formed, have well-defined behavior and not throw any exceptions.

:@3@ Uses the specified deleter {{tt|d}} as the deleter. {{tt|Deleter}} must be callable for the type {{tt|T}}, i.e. {{c|d(ptr)}} must be well formed, have well-defined behavior and not throw any exceptions. {{tt|Deleter}} must be {{concept|CopyConstructible}}. The copy constructor and the destructor must not throw exceptions.

:@4@  Same as (3), but additionally uses a copy of {{tt|alloc}} for allocation of data for internal use. {{tt|Alloc}} must be a {{concept|Allocator}}. The copy constructor and destructor must not throw exceptions.

@5-7@ Analogous to (2), (3), (4) respectively, but constructs a {{tt|shared_ptr}} with no managed object, i.e. empty {{tt|shared_ptr}}.

@8@ Constructs a {{tt|shared_ptr}} which shares ownership information with {{tt|r}}, but holds an unrelated and unmanaged pointer {{tt|ptr}}. Even if this {{tt|shared_ptr}} is the last of the group to go out of scope, it will call the destructor for the object originally managed by {{tt|r}}. However, calling {{tt|get()}} on this will always return a copy of {{tt|ptr}}. It is the responsibility of the programmer to make sure that this {{tt|ptr}} remains valid as long as this shared_ptr exists, such as in the typical use cases where {{tt|ptr}} is a member of the object managed by {{tt|r}} or is an alias (e.g., downcast) of {{tt|r.get()}}

@9@ Constructs a {{tt|shared_ptr}} which shares ownership of the object managed by {{tt|r}}. If {{tt|r}} manages no object, {{tt|*this}} manages no object too. The templated overload doesn't participate in the overload resolution if {{tt|Y*}} is not implicitly convertible to {{tt|T*}}.

@10@ Move-constructs a {{tt|shared_ptr}} from {{tt|r}}. After the construction, {{c|*this}} contains a copy of the previous state of {{tt|r}}, {{tt|r}} is empty. The templated overload doesn't participate in the overload resolution if {{tt|Y*}} is not implicitly convertible to {{tt|T*}}.

@11@ Constructs a {{tt|shared_ptr}} which shares ownership of the object managed by {{tt|r}}. {{tt|Y*}} must be convertible to {{tt|T*}}. Note that {{c|r.lock()}} may be used for the same purpose: the difference is that this constructor throws an exception if the argument is empty, while {{c|std::weak_ptr&lt;T&gt;::lock()}} constructs an empty {{tt|std::shared_ptr}} in that case.

@12@ Constructs a {{tt|shared_ptr}} that stores and owns the object formerly owned by {{tt|r}}. {{tt|Y*}} must be convertible to {{tt|T*}}. After construction, {{tt|r}} is empty.

@13@ Constructs a {{tt|shared_ptr}} which manages the object currently managed by {{tt|r}}. The deleter associated to {{tt|r}} is stored for future deletion of the managed object. {{tt|r}} manages no object after the call. {{tt|Y*}} must be convertible to {{tt|T*}}.

===Notes===
When constructing a {{tt|shared_ptr}} from a raw pointer to an object of a type derived from {{lc|std::enable_shared_from_this}}, the constructors of {{tt|shared_ptr}} update the private {{tt|weak_ptr}} member of the {{lc|std::enable_shared_from_this}} base so that future calls to {{ltt|cpp/memory/enable_shared_from_this/shared_from_this|shared_from_this()}} would share ownership with the {{tt|shared_ptr}} created by this raw pointer constructor.

Constructing a {{tt|shared_ptr}} using the raw pointer overload for an object that is already managed by a {{tt|shared_ptr}} leads to undefined behavior, even if the object is of a type derived from {{lc|std::enable_shared_from_this}} (in other words, raw pointer overloads assume ownership of the pointed-to object).

===Parameters===
{{par begin}}
{{par | ptr | a pointer to an object to manage}}
{{par | d | a deleter to use to destroy the object}}
{{par | alloc | an allocator to use for allocations of data for internal use}}
{{par | r | another smart pointer to share the ownership to or acquire the ownership from}}
{{par end}} 

===Exceptions===
@1@ {{noexcept}}

@2@ {{lc|std::bad_alloc}} if required additional memory could not be obtained. May throw implementation-defined exception for other errors. {{c|delete ptr}} is called if an exception occurs.

@3-4@ {{lc|std::bad_alloc}} if required additional memory could not be obtained. May throw implementation-defined exception for other errors. {{c|d(ptr)}} is called if an exception occurs.

@5@ {{noexcept}}

@6-7@ {{lc|std::bad_alloc}} if required additional memory could not be obtained. May throw implementation-defined exception for other errors. If an exception is thrown, {{c|d(ptr)}} is executed.

@8-10@ {{noexcept}}

@11@ {{lc|std::bad_weak_ptr}} if {{c|r.expired {{==}} true}}. The constructor has no effect in this case.

@12@ {{lc|std::bad_alloc}} if required additional memory could not be obtained. May throw implementation-defined exception for other errors. This constructor has no effect if an exception occurs.

@13@ If an exception is thrown, the constructor has no effects.

===Example===
{{example
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;

struct Foo {
    Foo() { std::cout &lt;&lt; &quot;Foo...\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo...\n&quot;; }
};

struct D { 
    void operator()(Foo* p) const {
        std::cout &lt;&lt; &quot;Call delete for Foo object...\n&quot;;
        delete p;
    }
};

int main()
{
    {
        std::cout &lt;&lt; &quot;constructor with no managed object\n&quot;;
        std::shared_ptr&lt;Foo&gt; sh1;
    }

    {
        std::cout &lt;&lt; &quot;constructor with object\n&quot;;
        std::shared_ptr&lt;Foo&gt; sh2(new Foo);
        std::shared_ptr&lt;Foo&gt; sh3(sh2);
        std::cout &lt;&lt; sh2.use_count() &lt;&lt; '\n';
        std::cout &lt;&lt; sh3.use_count() &lt;&lt; '\n';
    }

    {
        std::cout &lt;&lt; &quot;constructor with object and deleter\n&quot;;
        std::shared_ptr&lt;Foo&gt; sh4(new Foo, D());
    }
}
 | output=
constructor with no managed object
constructor with object
Foo...
2
2
~Foo...
constructor with object and deleter
Foo...
Call delete for Foo object...
~Foo...
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc make_shared}}
{{dsc inc | cpp/memory/shared_ptr/dsc allocate_shared}}
{{dsc end}}

[[de:cpp/memory/shared ptr/shared ptr]]
[[es:cpp/memory/shared ptr/shared ptr]]
[[fr:cpp/memory/shared ptr/shared ptr]]
[[it:cpp/memory/shared ptr/shared ptr]]
[[ja:cpp/memory/shared ptr/shared ptr]]
[[pt:cpp/memory/shared ptr/shared ptr]]
[[ru:cpp/memory/shared ptr/shared ptr]]
[[zh:cpp/memory/shared ptr/shared ptr]]</text>
      <sha1>78c3djhcnfuwkt7i1chocgau4hiej6j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/swap</title>
    <ns>0</ns>
    <id>2205</id>
    <revision>
      <id>50180</id>
      <parentid>42266</parentid>
      <timestamp>2013-06-01T03:16:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="597">{{cpp/memory/shared_ptr/title | swap}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
void swap( shared_ptr&amp; r );
}}

Exchanges the contents of {{c|*this}} and {{tt|r}}

===Parameters===
{{par begin}}
{{par | r | smart pointer to exchange the contents with}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/memory/shared ptr/swap]]
[[es:cpp/memory/shared ptr/swap]]
[[fr:cpp/memory/shared ptr/swap]]
[[it:cpp/memory/shared ptr/swap]]
[[ja:cpp/memory/shared ptr/swap]]
[[pt:cpp/memory/shared ptr/swap]]
[[ru:cpp/memory/shared ptr/swap]]
[[zh:cpp/memory/shared ptr/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/swap2</title>
    <ns>0</ns>
    <id>5305</id>
    <revision>
      <id>42258</id>
      <parentid>19313</parentid>
      <timestamp>2012-11-02T22:39:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="312">{{cpp/memory/swap2|shared_ptr}}

[[de:cpp/memory/shared ptr/swap2]]
[[es:cpp/memory/shared ptr/swap2]]
[[fr:cpp/memory/shared ptr/swap2]]
[[it:cpp/memory/shared ptr/swap2]]
[[ja:cpp/memory/shared ptr/swap2]]
[[pt:cpp/memory/shared ptr/swap2]]
[[ru:cpp/memory/shared ptr/swap2]]
[[zh:cpp/memory/shared ptr/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/unique</title>
    <ns>0</ns>
    <id>2209</id>
    <revision>
      <id>58405</id>
      <parentid>50181</parentid>
      <timestamp>2013-06-01T06:14:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1197">{{cpp/memory/shared_ptr/title | unique}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
bool unique() const;
}}

Checks if {{c|*this}} is the only {{tt|shared_ptr}} instance managing the current object, i.e. whether {{c|1=use_count() == 1}}.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} is the only {{tt|shared_ptr}} instance managing the current object, {{c|false}} otherwise.

===Example===
{{example
 | code=
#include &lt;memory&gt; 
#include &lt;iostream&gt; 
  
int main() 
{ 
    std::shared_ptr&lt;int&gt; sp1 {std::make_shared&lt;int&gt;(5)};
    std::cout &lt;&lt; &quot;sp1.unique() == &quot; &lt;&lt; std::boolalpha &lt;&lt; sp1.unique() &lt;&lt; std::endl; 

    std::shared_ptr&lt;int&gt; sp2 {sp1}; 
    std::cout &lt;&lt; &quot;sp1.unique() == &quot; &lt;&lt; std::boolalpha &lt;&lt; sp1.unique() &lt;&lt; std::endl; 
} 
 | output=
sp1.unique() == true
sp1.unique() == false
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc use_count}}
{{dsc end}}

[[de:cpp/memory/shared ptr/unique]]
[[es:cpp/memory/shared ptr/unique]]
[[fr:cpp/memory/shared ptr/unique]]
[[it:cpp/memory/shared ptr/unique]]
[[ja:cpp/memory/shared ptr/unique]]
[[pt:cpp/memory/shared ptr/unique]]
[[ru:cpp/memory/shared ptr/unique]]
[[zh:cpp/memory/shared ptr/unique]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/use count</title>
    <ns>0</ns>
    <id>2208</id>
    <revision>
      <id>58408</id>
      <parentid>50182</parentid>
      <timestamp>2013-06-01T06:14:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1251">{{cpp/memory/shared_ptr/title | use_count}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
long use_count() const;
}}

Returns the number of different {{tt|shared_ptr}} instances ({{c|this}} included) managing the current object. If there is no managed object, {{c|0}} is returned.

===Parameters===
(none)

===Return value===
the number of {{tt|shared_ptr}} instances managing the current object or {{c|0}} if there is no managed object.

===Example===
{{example
 | code=
#include &lt;memory&gt; 
#include &lt;iostream&gt; 
  
void fun(std::shared_ptr&lt;int&gt; sp)
{
    std::cout &lt;&lt; &quot;fun: sp.use_count() == &quot; &lt;&lt; sp.use_count() &lt;&lt; std::endl; 
}

int main() 
{ 
    std::shared_ptr&lt;int&gt; sp1 {std::make_shared&lt;int&gt;(5)};
    std::cout &lt;&lt; &quot;sp1.use_count() == &quot; &lt;&lt; sp1.use_count() &lt;&lt; std::endl; 

    fun(sp1);
} 
 | output=
sp1.use_count() == 1
fun: sp.use_count() == 2
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/shared_ptr/dsc unique}}
{{dsc end}}

[[de:cpp/memory/shared ptr/use count]]
[[es:cpp/memory/shared ptr/use count]]
[[fr:cpp/memory/shared ptr/use count]]
[[it:cpp/memory/shared ptr/use count]]
[[ja:cpp/memory/shared ptr/use count]]
[[pt:cpp/memory/shared ptr/use count]]
[[ru:cpp/memory/shared ptr/use count]]
[[zh:cpp/memory/shared ptr/use count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/shared ptr/~shared ptr</title>
    <ns>0</ns>
    <id>2202</id>
    <revision>
      <id>50183</id>
      <parentid>42233</parentid>
      <timestamp>2013-06-01T03:16:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="680">{{cpp/memory/shared_ptr/title | ~shared_ptr}}
{{cpp/memory/shared_ptr/navbar}}
{{ddcl |
~shared_ptr();
}}

If {{tt|*this}} owns an object and it is the last {{tt|shared_ptr}} owning it, the object is destroyed through the owned deleter. Otherwise does nothing.

===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc end}}

[[de:cpp/memory/shared ptr/~shared ptr]]
[[es:cpp/memory/shared ptr/~shared ptr]]
[[fr:cpp/memory/shared ptr/~shared ptr]]
[[it:cpp/memory/shared ptr/~shared ptr]]
[[ja:cpp/memory/shared ptr/~shared ptr]]
[[pt:cpp/memory/shared ptr/~shared ptr]]
[[ru:cpp/memory/shared ptr/~shared ptr]]
[[zh:cpp/memory/shared ptr/~shared ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/uninitialized copy</title>
    <ns>0</ns>
    <id>2442</id>
    <revision>
      <id>69954</id>
      <parentid>69164</parentid>
      <timestamp>2014-05-03T04:40:49Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ exception handling</comment>
      <text xml:space="preserve" bytes="2405">{{cpp/title|uninitialized_copy}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | 
template&lt; class InputIt, class ForwardIt &gt;
ForwardIt uninitialized_copy( InputIt first, InputIt last, ForwardIt d_first );
}}

Copies elements from the range {{tt|[first, last)}} to an uninitialized memory area beginning at {{tt|d_first}}. If an exception is thrown during the initialization, the function has no effects. 

===Parameters===
{{par begin}}
{{par | first, last | the range of the elements to copy}}
{{par | d_first | the beginning of the destination range}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the element past the last element copied.

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class ForwardIt&gt;
ForwardIt uninitialized_copy(InputIt first, InputIt last, ForwardIt d_first)
{
    typedef typename std::iterator_traits&lt;ForwardIt&gt;::value_type Value;
    ForwardIt current = d_first;
    try {
        for (; first != last; ++first, ++current) {
            ::new (static_cast&lt;void*&gt;(&amp;*current)) Value(*first);
        }
        return current;
    } catch (...) {
        for (; d_first != current; ++d_first) {
            d_first-&gt;~Value();
        }
        throw;
    }
}
}}

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;tuple&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;std::string&gt; v = {&quot;This&quot;, &quot;is&quot;, &quot;an&quot;, &quot;example&quot;};

    std::string* p;
    std::size_t sz;
    std::tie(p, sz)  = std::get_temporary_buffer&lt;std::string&gt;(v.size());
    sz = std::min(sz, v.size());

    std::uninitialized_copy(v.begin(), v.begin() + sz, p);

    for (std::string* i = p; i != p+sz; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; ' ';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
 | output=
This is an example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uninitialized_copy_n}}
{{dsc end}}

[[de:cpp/memory/uninitialized copy]]
[[es:cpp/memory/uninitialized copy]]
[[fr:cpp/memory/uninitialized copy]]
[[it:cpp/memory/uninitialized copy]]
[[ja:cpp/memory/uninitialized copy]]
[[pt:cpp/memory/uninitialized copy]]
[[ru:cpp/memory/uninitialized copy]]
[[zh:cpp/memory/uninitialized copy]]</text>
      <sha1>ndzjg3dcisn3pp8ykf7tykb1xzou1ja</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/uninitialized copy n</title>
    <ns>0</ns>
    <id>2443</id>
    <revision>
      <id>69955</id>
      <parentid>69165</parentid>
      <timestamp>2014-05-03T04:52:26Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ exception handling</comment>
      <text xml:space="preserve" bytes="2477">{{cpp/title|uninitialized_copy_n}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | since=c++11 |
template&lt; class InputIt, class Size, class ForwardIt &gt;
ForwardIt uninitialized_copy_n( InputIt first, Size count, ForwardIt d_first);

}}
                                    
Copies {{tt|count}} elements from a range beginning at {{tt|first}} to an uninitialized memory area beginning at {{tt|d_first}}.

If an exception is thrown during the initialization, the function has no effects. 

===Parameters===
{{par begin}}
{{par | first | the beginning of the range of the elements to copy}}
{{par | d_first | the beginning of the destination range}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the element past the last element copied.

===Complexity===
Linear in {{tt|count}}.

===Possible implementation===
{{eq fun | 1=
template&lt;class InputIt, class Size, class ForwardIt&gt;
ForwardIt uninitialized_copy_n(InputIt first, Size count, ForwardIt d_first)
{
    typedef typename std::iterator_traits&lt;ForwardIt&gt;::value_type Value;
    ForwardIt current = d_first;
    try {
        for (; count &gt; 0; ++first, ++current, --count) {
            ::new (static_cast&lt;void*&gt;(&amp;*current)) Value(*first);
        }
    } catch (...) {
        for (; d_first != current; ++d_first) {
            d_first-&gt;~Value();
        }
        throw;
    }
    return current;
}
}}

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;tuple&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;std::string&gt; v = {&quot;This&quot;, &quot;is&quot;, &quot;an&quot;, &quot;example&quot;};

    std::string* p;
    std::size_t sz;
    std::tie(p, sz)  = std::get_temporary_buffer&lt;std::string&gt;(v.size());
    sz = std::min(sz, v.size());

    std::uninitialized_copy_n(v.begin(), sz, p);

    for (std::string* i = p; i != p+sz; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; ' ';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
 | output=
This is an example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uninitialized_copy}}
{{dsc end}}

[[de:cpp/memory/uninitialized copy n]]
[[es:cpp/memory/uninitialized copy n]]
[[fr:cpp/memory/uninitialized copy n]]
[[it:cpp/memory/uninitialized copy n]]
[[ja:cpp/memory/uninitialized copy n]]
[[pt:cpp/memory/uninitialized copy n]]
[[ru:cpp/memory/uninitialized copy n]]
[[zh:cpp/memory/uninitialized copy n]]</text>
      <sha1>g7x1kaot0w4x5b2qpglrt9r6tp5eh4q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/uninitialized fill</title>
    <ns>0</ns>
    <id>2444</id>
    <revision>
      <id>69959</id>
      <parentid>69956</parentid>
      <timestamp>2014-05-03T05:50:08Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2129">{{cpp/title|uninitialized_fill}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | 
template&lt; class ForwardIt, class T &gt;
void uninitialized_fill( ForwardIt first, ForwardIt last, const T&amp; value )
}}

Copies the given {{tt|value}} to an uninitialized memory area, defined by the range {{tt|[first, last)}}. If an exception is thrown during the initialization, the function has no effects. 

===Parameters===
{{par begin}}
{{par | first, last | the range of the elements to initialize}}
{{par | value | the value to construct the elements with}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
(none)

===Complexity===
Linear in the distance between {{tt|first}} and {{tt|last}}

===Possible implementation===
{{eq fun | 1=
template&lt;class ForwardIt, class T&gt;
void uninitialized_fill(ForwardIt first, ForwardIt last, const T&amp; value)
{
    typedef typename std::iterator_traits&lt;ForwardIt&gt;::value_type Value;
    ForwardIt current = first;
    try {
        for (; current != last; ++current) {
            ::new (static_cast&lt;void*&gt;(&amp;*current)) Value(value);
        }
    }  catch (...) {
        for (; first != current; ++first) {
            first-&gt;~Value();
        }
        throw;
    }
}
}}

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;tuple&gt;

int main()
{
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer&lt;std::string&gt;(4);

    std::uninitialized_fill(p, p+sz, &quot;Example&quot;);

    for (std::string* i = p; i != p+sz; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; '\n';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
 | output=
Example
Example
Example
Example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uninitialized_fill_n}}
{{dsc end}}

[[de:cpp/memory/uninitialized fill]]
[[es:cpp/memory/uninitialized fill]]
[[fr:cpp/memory/uninitialized fill]]
[[it:cpp/memory/uninitialized fill]]
[[ja:cpp/memory/uninitialized fill]]
[[pt:cpp/memory/uninitialized fill]]
[[ru:cpp/memory/uninitialized fill]]
[[zh:cpp/memory/uninitialized fill]]</text>
      <sha1>35hfpt8ium3feg2sa12nz5k8g2us5o8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/uninitialized fill n</title>
    <ns>0</ns>
    <id>2445</id>
    <revision>
      <id>70045</id>
      <parentid>70025</parentid>
      <timestamp>2014-05-08T14:28:22Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>linebreak for clarity</comment>
      <text xml:space="preserve" bytes="2265">{{cpp/title|uninitialized_fill_n}}
{{cpp/memory/navbar}}
{{ddcl | header=memory | 
template&lt; class ForwardIt, class Size, class T &gt;
void uninitialized_fill_n( ForwardIt first, Size count, const T&amp; value )
}}

Copies the given value {{tt|value}} to the first {{tt|count}} elements in an uninitialized memory area beginning at {{tt|first}}.

If an exception is thrown during the initialization, the function has no effects. 

===Parameters===
{{par begin}}
{{par | first | the beginning of the range of the elements to initialize}}
{{par | count | number of elements to construct}}
{{par | value | the value to construct the elements with}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
Iterator to the element past the last element copied.

===Complexity===
Linear in {{tt|count}}

===Possible implementation===
{{eq fun | 1=
template&lt; class ForwardIt, class Size, class T &gt;
void uninitialized_fill_n(ForwardIt first, Size count, const T&amp; value)
{
    typedef typename std::iterator_traits&lt;ForwardIt&gt;::value_type Value;
    ForwardIt current = first;
    try {
        for (; count &gt; 0; ++current, --count) {
            ::new (static_cast&lt;void*&gt;(&amp;*current)) Value(value);
        }
    } catch (...) {
        for (; first != current; ++first) {
            first-&gt;~Value();
        }
        throw;
    }
}
}}

===Example===
{{example
 | code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;tuple&gt;

int main()
{
    std::string* p;
    std::size_t sz;
    std::tie(p, sz)  = std::get_temporary_buffer&lt;std::string&gt;(4);
    std::uninitialized_fill_n(p, sz, &quot;Example&quot;);

    for (std::string* i = p; i != p+sz; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; '\n';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
 | output=
Example
Example
Example
Example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uninitialized_fill}}
{{dsc end}}

[[de:cpp/memory/uninitialized fill n]]
[[es:cpp/memory/uninitialized fill n]]
[[fr:cpp/memory/uninitialized fill n]]
[[it:cpp/memory/uninitialized fill n]]
[[ja:cpp/memory/uninitialized fill n]]
[[pt:cpp/memory/uninitialized fill n]]
[[ru:cpp/memory/uninitialized fill n]]
[[zh:cpp/memory/uninitialized fill n]]</text>
      <sha1>93yhgkay5ouy9m3cjr5vmdbsaxchc7x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr</title>
    <ns>0</ns>
    <id>2156</id>
    <revision>
      <id>70071</id>
      <parentid>70070</parentid>
      <timestamp>2014-05-09T09:59:26Z</timestamp>
      <contributor>
        <username>Jwakely</username>
        <id>3078</id>
      </contributor>
      <comment>type doesn't need to be complete in the move ctor</comment>
      <text xml:space="preserve" bytes="5632">{{cpp/title|unique_ptr}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl header|memory}}
{{dcl | since=c++11 | num=1 | 1=
template&lt;
    class T,
    class Deleter = std::default_delete&lt;T&gt;
&gt; class unique_ptr;
}}
{{dcl | since=c++11 | num=2 | 1=
template &lt;
    class T,
    class Deleter
&gt; class unique_ptr&lt;T[], Deleter&gt;;
}}
{{dcl end}}

{{tt|std::unique_ptr}} is a smart pointer that retains sole ownership of an object through a pointer and destroys that object when the {{tt|unique_ptr}} goes out of scope. No two {{tt|unique_ptr}} instances can manage the same object.

The object is destroyed and its memory deallocated when either of the following happens:
* {{tt|unique_ptr}} managing the object is destroyed 
* {{tt|unique_ptr}} managing the object is assigned another pointer via {{lc|operator{{=}}}} or {{lc|reset()}}.

The object is destroyed using a potentially user-supplied deleter by calling {{c|Deleter(ptr)}}. The deleter calls the destructor of the object and dispenses the memory. 

A {{tt|unique_ptr}} may also own no objects, in which case it is called ''empty''.

There are two versions of {{tt|std::unique_ptr}}:

@1@ Manages the lifetime of a single object (e.g. allocated with {{c|new}})

@2@ Manages the lifetime of a dynamically-allocated array of objects (e.g. allocated with {{c|new[]}})

The class satisfies the requirements of {{concept|MoveConstructible}} and {{concept|MoveAssignable}}, but not the requirements of either {{concept|CopyConstructible}} or {{concept|CopyAssignable}}.

{{par begin}}
{{par hreq}}
{{par req | {{tt|Deleter}} must be {{concept|FunctionObject}} or lvalue reference to a {{concept|FunctionObject}} or lvalue reference to function, callable with an argument of type {{tt|unique_ptr&lt;T, Deleter&gt;::pointer}}}}
{{par end}}

===Notes===
Only non-const {{tt|unique_ptr}} can transfer the ownership of the managed object to another {{tt|unique_ptr}}. The lifetime of an object managed by {{c|const std::unique_ptr}} is limited to the scope in which the pointer was created.

Typical uses of {{tt|std::unique_ptr}} include:

* providing exception safety to classes and functions that handle objects with dynamic lifetime, by guaranteeing deletion on both normal exit and exit through exception

* passing ownership of uniquely-owned objects with dynamic lifetime into functions

* acquiring ownership of uniquely-owned objects with dynamic lifetime from functions

* as the element type in move-aware containers, such as {{lc|std::vector}}, which hold pointers to dynamically-allocated objects (e.g. if polymorphic behavior is desired)

{{tt|std::unique_ptr}} may be constructed for an [[cpp/language/incomplete_type|incomplete type]] {{tt|T}}, such as to facilitate the use as a handle in the Pimpl idiom. If the default deleter is used, {{tt|T}} must be complete at the point in code where the deleter is invoked, which happens in the destructor, move assignment operator, and {{tt|reset}} member function of {{tt|std::unique_ptr}}. (Conversely,  {{lc|std::shared_ptr}} can't be constructed from a raw pointer to incomplete type, but can be destroyed where {{tt|T}} is incomplete.)

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|pointer}}      | {{c|std::remove_reference&lt;Deleter&gt;::type::pointer}} if that type exists, otherwise T*}}
{{dsc | {{c|element_type}} | {{tt|T}}, the type of the object managed by this {{tt|unique_ptr}}}}
{{dsc | {{c|deleter_type}} | {{tt|Deleter}}, the function object or lvalue reference to function or to function object, to be called from the destructor}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc constructor}}
{{dsc inc | cpp/memory/unique_ptr/dsc destructor}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator{{=}}}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/memory/unique_ptr/dsc release}}
{{dsc inc | cpp/memory/unique_ptr/dsc reset}}
{{dsc inc | cpp/memory/unique_ptr/dsc swap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc inc | cpp/memory/unique_ptr/dsc get_deleter}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator bool}}

{{dsc h2 | Single-object version, {{tt|unique_ptr&lt;T&gt;}}}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator*}}

{{dsc h2 | Array version, {{tt|unique_ptr&lt;T[]&gt;}}}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator_at}}

{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc make_unique}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator_cmp}}
{{dsc inc | cpp/memory/unique_ptr/dsc swap2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc hash}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo
{
    Foo()      { std::cout &lt;&lt; &quot;Foo::Foo\n&quot;;  }
    ~Foo()     { std::cout &lt;&lt; &quot;Foo::~Foo\n&quot;; }
    void bar() { std::cout &lt;&lt; &quot;Foo::bar\n&quot;;  }
};

void f(const Foo &amp;)
{
    std::cout &lt;&lt; &quot;f(const Foo&amp;)\n&quot;;
}

int main()
{
    std::unique_ptr&lt;Foo&gt; p1(new Foo);  // p1 owns Foo
    if (p1) p1-&gt;bar();

    {
        std::unique_ptr&lt;Foo&gt; p2(std::move(p1));  // now p2 owns Foo
        f(*p2);

        p1 = std::move(p2);  // ownership returns to p1
        std::cout &lt;&lt; &quot;destroying p2...\n&quot;;
    }

    if (p1) p1-&gt;bar();

    // Foo instance is destroyed when p1 goes out of scope
}

 | output=
Foo::Foo
Foo::bar
f(const Foo&amp;)
destroying p2...
Foo::bar
Foo::~Foo
}}

[[de:cpp/memory/unique ptr]]
[[es:cpp/memory/unique ptr]]
[[fr:cpp/memory/unique ptr]]
[[it:cpp/memory/unique ptr]]
[[ja:cpp/memory/unique ptr]]
[[pt:cpp/memory/unique ptr]]
[[ru:cpp/memory/unique ptr]]
[[zh:cpp/memory/unique ptr]]</text>
      <sha1>071tl41k26ff6la0ps2ztlvdqrtkc1g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/get</title>
    <ns>0</ns>
    <id>4861</id>
    <revision>
      <id>63347</id>
      <parentid>58418</parentid>
      <timestamp>2013-07-10T01:29:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="969">{{cpp/memory/unique_ptr/title|get}}
{{cpp/memory/unique_ptr/navbar}}
{{ddcl | since=c++11 | 1=
pointer get() const;
}}

Returns a pointer to the managed object or {{c|nullptr}} if no object is owned.

===Parameters===
(none)

===Return value===
Pointer to the managed object or {{c|nullptr}} if no object is owned.

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;memory&gt;

int main()
{
    std::unique_ptr&lt;std::string&gt; s_p(new std::string(&quot;Hello, world!&quot;));
    std::string *s = s_p.get();
    std::cout &lt;&lt; *s &lt;&lt; '\n';
}
 | output=
Hello, world!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc release}}
{{dsc end}}

[[de:cpp/memory/unique ptr/get]]
[[es:cpp/memory/unique ptr/get]]
[[fr:cpp/memory/unique ptr/get]]
[[it:cpp/memory/unique ptr/get]]
[[ja:cpp/memory/unique ptr/get]]
[[pt:cpp/memory/unique ptr/get]]
[[ru:cpp/memory/unique ptr/get]]
[[zh:cpp/memory/unique ptr/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/get deleter</title>
    <ns>0</ns>
    <id>4863</id>
    <revision>
      <id>62792</id>
      <parentid>50190</parentid>
      <timestamp>2013-07-01T23:41:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1307">{{cpp/memory/unique_ptr/title|get_deleter}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
      Deleter&amp; get_deleter();
}}
{{dcl | since=c++11 | 1=
const Deleter&amp; get_deleter() const;
}}
{{dcl end}}

Returns the deleter object which would be used for destruction of the managed object.

===Parameters===
(none)

===Return value===
The stored deleter object.

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo
{
    Foo() { std::cout &lt;&lt; &quot;Foo...\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo...\n&quot;; }
};
 
struct D
{
    void bar() { std::cout &lt;&lt; &quot;Call deleter D::bar()...\n&quot;; }
    void operator()(Foo* p) const
    {
        std::cout &lt;&lt; &quot;Call delete for Foo object...\n&quot;;
        delete p;
    }
};

int main()
{
    std::unique_ptr&lt;Foo, D&gt; up(new Foo(), D());
    D&amp; del = up.get_deleter();
    del.bar();
}
 | output=
Foo...
Call deleter D::bar()...
Call delete for Foo object...
~Foo...
}}

[[de:cpp/memory/unique ptr/get deleter]]
[[es:cpp/memory/unique ptr/get deleter]]
[[fr:cpp/memory/unique ptr/get deleter]]
[[it:cpp/memory/unique ptr/get deleter]]
[[ja:cpp/memory/unique ptr/get deleter]]
[[pt:cpp/memory/unique ptr/get deleter]]
[[ru:cpp/memory/unique ptr/get deleter]]
[[zh:cpp/memory/unique ptr/get deleter]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/hash</title>
    <ns>0</ns>
    <id>5315</id>
    <revision>
      <id>62793</id>
      <parentid>58421</parentid>
      <timestamp>2013-07-01T23:41:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1357">{{cpp/title | hash}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt;class T, class Deleter&gt; struct hash&lt;unique_ptr&lt;T, Deleter&gt;&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for {{c|std::unique_ptr&lt;T, Deleter&gt;}} allows users to obtain hashes of objects of type {{c|std::unique_ptr&lt;T, Deleter&gt;}}.

For a given {{c|1=std::unique_ptr&lt;T, Deleter&gt; p}}, this specialization ensures that  {{c|1=std::hash&lt;std::unique_ptr&lt;T, Deleter&gt;&gt;()(p) == std::hash&lt;T*&gt;()(p.get())}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;functional&gt;

struct Foo {
    Foo() { std::cout &lt;&lt; &quot;Foo...\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo...\n\n&quot;; }
};
 
int main()
{
    Foo* foo = new Foo();
    std::unique_ptr&lt;Foo&gt; up(foo);

    std::cout &lt;&lt; &quot;hash(up):  &quot; &lt;&lt; std::hash&lt;std::unique_ptr&lt;Foo&gt;&gt;()(up) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;hash(foo): &quot; &lt;&lt; std::hash&lt;Foo*&gt;()(foo) &lt;&lt; '\n';
}
 | output=
Foo...
hash(up):  3686401041
hash(foo): 3686401041
~Foo...
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

[[de:cpp/memory/unique ptr/hash]]
[[es:cpp/memory/unique ptr/hash]]
[[fr:cpp/memory/unique ptr/hash]]
[[it:cpp/memory/unique ptr/hash]]
[[ja:cpp/memory/unique ptr/hash]]
[[pt:cpp/memory/unique ptr/hash]]
[[ru:cpp/memory/unique ptr/hash]]
[[zh:cpp/memory/unique ptr/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/make unique</title>
    <ns>0</ns>
    <id>10006</id>
    <revision>
      <id>67951</id>
      <parentid>66638</parentid>
      <timestamp>2014-03-08T11:47:57Z</timestamp>
      <contributor>
        <ip>77.169.5.103</ip>
      </contributor>
      <text xml:space="preserve" bytes="1821">{{cpp/title|make_unique}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | num=1 | notes={{mark since c++14}}&lt;br/&gt;{{mark|only for non-array types}} |
template&lt; class T, class... Args &gt;
unique_ptr&lt;T&gt; make_unique( Args&amp;&amp;... args );
}}
{{dcl | num=2 | notes={{mark since c++14}}&lt;br/&gt;{{mark|only for array types with unknown bound}} |
template&lt; class T &gt;
unique_ptr&lt;T&gt; make_unique( std::size_t size );
}}
{{dcl | num=3 
 | notes={{mark since c++14}}&lt;br/&gt;{{mark|only for array types with known bound}} | 1=
template&lt; class T, class... Args &gt;
/* unspecified */ make_unique( Args&amp;&amp;... args ) = delete;
}}
{{dcl end}}

Constructs an object of type {{tt|T}} and wraps it in a {{lc|std::unique_ptr}}.

@1@ Constructs a non-array type {{tt|T}}. The arguments {{tt|args}} are passed to the constructor of {{tt|T}}. The function does not participate in the overload resolution if {{tt|T}} is an array type. The function is equivalent to:
{{source|unique_ptr&lt;T&gt;(new T(std::forward&lt;Args&gt;(args)...))}}

@2@ Constructs an array of unknown bound {{tt|T}}. The function does not participate in the overload resolution unless {{tt|T}} is an array of unknown bound. The function is equivalent to:
{{source|unique_ptr&lt;T&gt;(new typename std::remove_extent&lt;T&gt;::type[size]())}}

@3@ Construction of arrays of known bound is disallowed.

===Parameters===
{{par begin}}
{{par | args | list of arguments with which an instance of {{tt|T}} will be constructed.}}
{{par | size | the size of the array to construct}}
{{par end}}

===Return value===
{{lc|std::unique_ptr}} of an instance of type {{tt|T}}.

===Exceptions===
Any exception thrown by the contructor of {{tt|T}}. If an exception is thrown, this function has no effect.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc constructor}}
{{dsc end}}</text>
      <sha1>cm3s76ryw8l72gyitdqvoykhmhxc30j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/operator*</title>
    <ns>0</ns>
    <id>8590</id>
    <revision>
      <id>72439</id>
      <parentid>72425</parentid>
      <timestamp>2014-08-22T02:54:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>correct recent note</comment>
      <text xml:space="preserve" bytes="1436">{{cpp/memory/unique_ptr/title|operator*}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
typename std::add_lvalue_reference&lt;T&gt;::type operator*() const;
}}
{{dcl | since=c++11 | num=2 | 1=
pointer operator-&gt;() const;
}}
{{dcl end}}

{{tt|operator*}} and {{tt|operator-&gt;}} provide access to the object owned by {{c|*this}}.

The behavior is undefined if {{c|get() {{==}} nullptr}}

===Parameters===
(none)

===Return value===
1) Returns the object owned by {{c|*this}}, equivalent to {{c|*get()}}.

2) Returns a pointer to the object owned by {{c|*this}}, i.e. {{c|get()}}.

===Exceptions===
1) may throw, e.g. if {{tt|pointer}} defines a throwing {{tt|operator*}}

2) {{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo {
    void bar() { std::cout &lt;&lt; &quot;Foo::bar\n&quot;; }
};

void f(const Foo&amp; foo) 
{
    std::cout &lt;&lt; &quot;f(const Foo&amp;)\n&quot;;
}

int main() 
{
    std::unique_ptr&lt;Foo&gt; ptr(new Foo);

    ptr-&gt;bar();
    f(*ptr);
}
 | output=
Foo::bar
f(const Foo&amp;)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/unique ptr/operator*]]
[[es:cpp/memory/unique ptr/operator*]]
[[fr:cpp/memory/unique ptr/operator*]]
[[it:cpp/memory/unique ptr/operator*]]
[[ja:cpp/memory/unique ptr/operator*]]
[[pt:cpp/memory/unique ptr/operator*]]
[[ru:cpp/memory/unique ptr/operator*]]
[[zh:cpp/memory/unique ptr/operator*]]</text>
      <sha1>m6fitl9lxznako2si9oot8oeqy7vcsr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/operator=</title>
    <ns>0</ns>
    <id>3114</id>
    <revision>
      <id>69832</id>
      <parentid>69831</parentid>
      <timestamp>2014-04-27T15:22:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>and more indent fixing</comment>
      <text xml:space="preserve" bytes="2679">{{cpp/memory/unique_ptr/title | operator{{=}}}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
unique_ptr&amp; operator=( unique_ptr&amp;&amp; r );
}}
{{dcl | num=1 | since=c++11 | 1= 
template&lt; class U, class E &gt;
unique_ptr&amp; operator=( unique_ptr&lt;U,E&gt;&amp;&amp; r );
}}
{{dcl | num=2 | since=c++11 | 1= 
unique_ptr&amp; operator=( nullptr_t );
}}
{{dcl end}}

@1@ Transfers ownership from {{tt|r}} to {{c|*this}} as if by calling {{c|reset(r.release())}} followed by an assignment of {{lc|get_deleter()}} from {{c|std::forward&lt;E&gt;(r.get_deleter())}}. &lt;!-- The C++11 standard says &quot;forward&lt;D&gt;&quot;, that was a typo: http://lwg.github.com/issues/lwg-active.html#2047 --&gt; 
@@If {{tt|Deleter}} is not a reference type, requires that it is nothrow-{{concept|MoveAssignable}}. 
@@If {{tt|Deleter}} is a reference type, requires that {{tt|std::remove_reference&lt;Deleter&gt;::type}} is nothrow-{{concept|CopyAssignable}}. 
@@The template version of this assignment operator only participates in overload resolution if {{tt|U}} is not an array type and {{c|unique_ptr&lt;U,E&gt;::pointer}} is implicitly convertible to {{tt|pointer}}.
@2@ Effectively the same as calling {{c|reset()}}.

Note that {{tt|unique_ptr}}'s assignment operator only accepts [[cpp/language/value_category|rvalues]], which are typically generated by {{lc|std::move}}.  (The {{tt|unique_ptr}} class explicitly deletes its [[cpp/language/value_category|lvalue]] copy constructor and [[cpp/language/value_category|lvalue]] assignment operator.)

===Parameters===
{{par begin}}
{{par | r | smart pointer from which ownership will be transfered}}
{{par end}} 

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
 
struct Foo {
    Foo() { std::cout &lt;&lt; &quot;Foo\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo\n&quot;; }
};

int main() 
{
    std::unique_ptr&lt;Foo&gt; p1;

    {
        std::cout &lt;&lt; &quot;Creating new Foo...\n&quot;;
        std::unique_ptr&lt;Foo&gt; p2(new Foo);
        // p1 = p2; // Error ! can't copy unique_ptr
        p1 = std::move(p2);
        std::cout &lt;&lt; &quot;About to leave inner block...\n&quot;;

        // Foo instance will continue to live, 
        // despite p2 going out of scope
    }
  
    std::cout &lt;&lt; &quot;About to leave program...\n&quot;;
}
 | output=
Creating new Foo...
Foo
About to leave inner block...
About to leave program...
~Foo
}}

[[de:cpp/memory/unique ptr/operator=]]
[[es:cpp/memory/unique ptr/operator=]]
[[fr:cpp/memory/unique ptr/operator=]]
[[it:cpp/memory/unique ptr/operator=]]
[[ja:cpp/memory/unique ptr/operator=]]
[[pt:cpp/memory/unique ptr/operator=]]
[[ru:cpp/memory/unique ptr/operator=]]
[[zh:cpp/memory/unique ptr/operator=]]</text>
      <sha1>6szv57mqv9pxkn4oojcxjmzy0zx372a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/operator at</title>
    <ns>0</ns>
    <id>8591</id>
    <revision>
      <id>62796</id>
      <parentid>58426</parentid>
      <timestamp>2013-07-01T23:41:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1341">{{cpp/memory/unique_ptr/title|operator[]}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
T&amp; operator[](size_t i) const;
}}
{{dcl end}}

{{tt|operator[]}} provides access to elements of an array managed by a {{tt|unique_ptr}}.

The parameter {{tt|i}} is required to be a valid array index.

===Parameters===
{{par begin}}
{{par | i | the index of the element to be returned}}
{{par end}} 

===Return value===
Returns the element at index {{tt|i}}, i.e. {{c|get()[i]}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

int main() 
{
    const int size = 10; 
    std::unique_ptr&lt;int[]&gt; fact(new int[size]);

    for (int i = 0; i &lt; size; ++i) {
        fact[i] = (i == 0) ? 1 : i * fact[i-1];
    }

    for (int i = 0; i &lt; size; ++i) {
        std::cout &lt;&lt; i &lt;&lt; &quot;: &quot; &lt;&lt; fact[i] &lt;&lt; '\n';
    }
}
 | output=
0: 1
1: 1
2: 2
3: 6
4: 24
5: 120
6: 720
7: 5040
8: 40320
9: 362880
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/unique ptr/operator at]]
[[es:cpp/memory/unique ptr/operator at]]
[[fr:cpp/memory/unique ptr/operator at]]
[[it:cpp/memory/unique ptr/operator at]]
[[ja:cpp/memory/unique ptr/operator at]]
[[pt:cpp/memory/unique ptr/operator at]]
[[ru:cpp/memory/unique ptr/operator at]]
[[zh:cpp/memory/unique ptr/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/operator bool</title>
    <ns>0</ns>
    <id>4862</id>
    <revision>
      <id>63348</id>
      <parentid>58427</parentid>
      <timestamp>2013-07-10T01:29:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1122">{{cpp/memory/unique_ptr/title|operator bool}}
{{cpp/memory/unique_ptr/navbar}}
{{ddcl | since=c++11 | 1=
explicit operator bool() const;
}}

Checks whether {{c|*this}} owns an object, i.e. whether {{c|1=get() != nullptr}}.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} owns an object, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

int main()
{
    std::unique_ptr&lt;int&gt; ptr(new int(42));
  
    if (ptr) std::cout &lt;&lt; &quot;before reset, ptr is: &quot; &lt;&lt; *ptr &lt;&lt; '\n';
    ptr.reset();
    if (ptr) std::cout &lt;&lt; &quot;after reset, ptr is: &quot; &lt;&lt; *ptr &lt;&lt; '\n';
}

 | output=
before reset, ptr is: 42
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/unique ptr/operator bool]]
[[es:cpp/memory/unique ptr/operator bool]]
[[fr:cpp/memory/unique ptr/operator bool]]
[[it:cpp/memory/unique ptr/operator bool]]
[[ja:cpp/memory/unique ptr/operator bool]]
[[pt:cpp/memory/unique ptr/operator bool]]
[[ru:cpp/memory/unique ptr/operator bool]]
[[zh:cpp/memory/unique ptr/operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/operator cmp</title>
    <ns>0</ns>
    <id>8592</id>
    <revision>
      <id>62797</id>
      <parentid>58430</parentid>
      <timestamp>2013-07-01T23:41:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="4264">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::unique_ptr)&lt;/small&gt;}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator==(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator!=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator&lt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}
{{dcl | since=c++11 | num=4 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator&lt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}
{{dcl | since=c++11 | num=5 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator&gt;(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}
{{dcl | since=c++11 | num=6 | 1=
template&lt;class T1, class D1, class T2, class D2&gt;
bool operator&gt;=(const unique_ptr&lt;T1, D1&gt;&amp; x, const unique_ptr&lt;T2, D2&gt;&amp; y);
}}

{{dcl | since=c++11 | num=7 | 1=
template &lt;class T, class D&gt;
bool operator==(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
}}
{{dcl | since=c++11 | num=8 | 1=
template &lt;class T, class D&gt;
bool operator==(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;
}}
{{dcl | since=c++11 | num=9 | 1=
template &lt;class T, class D&gt;
bool operator!=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t) noexcept;
}}
{{dcl | since=c++11 | num=10 | 1=
template &lt;class T, class D&gt;
bool operator!=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; x) noexcept;
}}
{{dcl | since=c++11 | num=11 | 1=
template &lt;class T, class D&gt;
bool operator&lt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
}}
{{dcl | since=c++11 | num=12 | 1=
template &lt;class T, class D&gt;
bool operator&lt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
}}
{{dcl | since=c++11 | num=13 | 1=
template &lt;class T, class D&gt;
bool operator&lt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
}}
{{dcl | since=c++11 | num=14 | 1=
template &lt;class T, class D&gt;
bool operator&lt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
}}
{{dcl | since=c++11 | num=15 | 1=
template &lt;class T, class D&gt;
bool operator&gt;(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
}}
{{dcl | since=c++11 | num=16 | 1=
template &lt;class T, class D&gt;
bool operator&gt;(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
}}
{{dcl | since=c++11 | num=17 | 1=
template &lt;class T, class D&gt;
bool operator&gt;=(const unique_ptr&lt;T, D&gt;&amp; x, nullptr_t);
}}
{{dcl | since=c++11 | num=18 | 1=
template &lt;class T, class D&gt;
bool operator&gt;=(nullptr_t, const unique_ptr&lt;T, D&gt;&amp; y);
}}
{{dcl end}}

Compares the pointer values of two {{tt|unique_ptr}}s, or a {{tt|unique_ptr}} and {{c|nullptr}}.

@1-6@ Compares two {{tt|unique_ptr}}s

@7-18@ Compares a {{tt|unique_ptr}} and {{c|nullptr}}.

===Parameters===
{{par begin}}
{{par | x, y | {{tt|unique_ptr}}s to compare }}
{{par end}} 

===Return value===
1) {{c|x.get() {{==}} y.get()}}

2) {{c|x.get() !{{=}} y.get()}}

3) {{c|std::less&lt;CT&gt;()(x.get(), y.get())}}, where {{tt|CT}} is {{c|std::common_type&lt;unique_ptr&lt;T1, D1&gt;::pointer, unique_ptr&lt;T2, D2&gt;::pointer&gt;::type}}

4) {{c|!(y &lt; x)}}

5) {{c|y &lt; x}}

6) {{c|!(x &lt; y)}}

7-8) {{c|!x}}

9-10) {{c|(bool)x}}

11) {{c|std::less&lt;unique_ptr&lt;T,D&gt;::pointer&gt;()(x.get(), nullptr)}} 

12) {{c|std::less&lt;unique_ptr&lt;T,D&gt;::pointer&gt;()(nullptr, y.get())}} 

13) {{c|nullptr &lt; x}}

14) {{c|y &lt; nullptr}}

15) {{c|!(nullptr &lt; x)}}

16) {{c|!(y &lt; nullptr)}}

17) {{c|!(x &lt; nullptr)}}

18) {{c|!(nullptr &lt; y)}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

int main() 
{
    std::unique_ptr&lt;int&gt; p1(new int(42));
    std::unique_ptr&lt;int&gt; p2(new int(42));

    std::cout &lt;&lt; &quot;p1 == p1: &quot; &lt;&lt; (p1 == p1) &lt;&lt; '\n';

    // p1 and p2 point to different memory locations, so p1 != p2
    std::cout &lt;&lt; &quot;p1 == p2: &quot; &lt;&lt; (p1 == p2) &lt;&lt; '\n';
}
 | output=
p1 == p1: 1
p1 == p2: 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc end}}

[[de:cpp/memory/unique ptr/operator cmp]]
[[es:cpp/memory/unique ptr/operator cmp]]
[[fr:cpp/memory/unique ptr/operator cmp]]
[[it:cpp/memory/unique ptr/operator cmp]]
[[ja:cpp/memory/unique ptr/operator cmp]]
[[pt:cpp/memory/unique ptr/operator cmp]]
[[ru:cpp/memory/unique ptr/operator cmp]]
[[zh:cpp/memory/unique ptr/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/release</title>
    <ns>0</ns>
    <id>4860</id>
    <revision>
      <id>64228</id>
      <parentid>63349</parentid>
      <timestamp>2013-08-15T15:53:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1439">{{cpp/memory/unique_ptr/title|release}}
{{cpp/memory/unique_ptr/navbar}}
{{ddcl | since=c++11 | 1=
pointer release();
}}

Releases the ownership of the managed object if any. {{lc|get()}} returns {{c|nullptr}} after the call.

===Parameters===
(none)

===Return value===
Pointer to the managed object or {{c|nullptr}} if there was no managed object, i.e. the value which would be returned by {{lc|get()}} before the call.

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;

struct Foo {
    Foo() { std::cout &lt;&lt; &quot;Foo\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo\n&quot;; }
};

int main()
{
    std::cout &lt;&lt; &quot;Creating new Foo...\n&quot;;
    std::unique_ptr&lt;Foo&gt; up(new Foo());

    std::cout &lt;&lt; &quot;About to release Foo...\n&quot;;
    Foo* fp = up.release();

    if (up.get() == nullptr)
        std::cout &lt;&lt; &quot;Foo is no longer owned by unique_ptr...\n&quot;;

    delete fp;
}

 | output=
Creating new Foo...
Foo
About to release Foo...
Foo is no longer owned by unique_ptr...
~Foo
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc get}}
{{dsc inc | cpp/memory/unique_ptr/dsc reset}}
{{dsc end}}

[[de:cpp/memory/unique ptr/release]]
[[es:cpp/memory/unique ptr/release]]
[[fr:cpp/memory/unique ptr/release]]
[[it:cpp/memory/unique ptr/release]]
[[ja:cpp/memory/unique ptr/release]]
[[pt:cpp/memory/unique ptr/release]]
[[ru:cpp/memory/unique ptr/release]]
[[zh:cpp/memory/unique ptr/release]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/reset</title>
    <ns>0</ns>
    <id>2422</id>
    <revision>
      <id>64451</id>
      <parentid>64449</parentid>
      <timestamp>2013-08-17T21:40:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, use new templates</comment>
      <text xml:space="preserve" bytes="3491">{{cpp/memory/unique_ptr/title|reset}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
void reset( pointer ptr = pointer() );
}}
{{dcl | num=2 | notes={{mark|member of specialization unique_ptr&lt;T[]&gt; only}} | since=c++11 | 1=
template&lt; class U &gt; 
void reset( U ) = delete;
}}
{{dcl | num=3 | notes={{mark|member of specialization unique_ptr&lt;T[]&gt; only}} | since=c++11 | 1=
void reset( std::nullptr_t p );
}}
{{dcl end}}

Replaces the managed object.

@1@ Given {{tt|current_ptr}}, the pointer that was managed by {{tt|*this}}, performs the following actions, in this order:
# Saves a copy of the current pointer {{c|1=old_ptr = current_ptr}} 
# Overwrites the current pointer with the argument {{c|1=current_ptr = ptr}}
# If the old pointer was non-empty, deletes the previously managed object {{c|1=if(old_ptr != nullptr) get_deleter()(old_ptr)}}.
@2@ In the specialization for dynamic arrays, {{c|std::unique_ptr&lt;T[]&gt;}}, this template member is provided to prevent using reset() with a pointer to derived (which would result in undefined behavior with arrays).
@3@ In the specialization for dynamic arrays, {{c|std::unique_ptr&lt;T[]&gt;}}, the third overload is necessary to allow reset to {{c|nullptr}} (which would otherwise be prohibited by the template overload). Equivalent to {{c|reset(pointer())}}

===Parameters===
{{par begin}}
{{par | ptr | pointer to a new object to manage}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Notes===
To replace the managed object while supplying a new deleter as well, move assignment operator may be used.

A test for self-reset, i.e. whether {{tt|ptr}} points to an object already managed by {{tt|*this}}, is not performed, except where provided as a compiler extension or as a debugging assert. Note that code such as {{c|p.reset(p.release())}} does not involve self-reset, only code like {{c|p.reset(p.get())}} does. 

Visual Studio's implementation of reset is currently (in VC10 and VC11) broken and non-conforming to the C++11 standard. [http://connect.microsoft.com/VisualStudio/feedback/details/771887/std-unique-ptr-deletes-owned-object-before-resetting-pointer-rather-than-after It deletes the managed object before resetting the pointer to the owned object.]

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo {
    Foo() { std::cout &lt;&lt; &quot;Foo...\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo...\n&quot;; }
};

struct D {
    void operator() (Foo* p) {
        std::cout &lt;&lt; &quot;Calling delete for Foo object... \n&quot;;
        delete p;
    }
};

int main()
{
    std::cout &lt;&lt; &quot;Creating new Foo...\n&quot;;
    std::unique_ptr&lt;Foo, D&gt; up(new Foo(), D());  // up owns the Foo pointer (deleter D)

    std::cout &lt;&lt; &quot;Replace owned Foo with a new Foo...\n&quot;;
    up.reset(new Foo());  // calls deleter for the old one

    std::cout &lt;&lt; &quot;Release and delete the owned Foo...\n&quot;;
    up.reset(nullptr);      
}
 | output=
Creating new Foo...
Foo...
Replace owned Foo with a new Foo...
Foo...
Calling delete for Foo object...
~Foo...
Release and delete the owned Foo...
Calling delete for Foo object...
~Foo...
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/memory/unique_ptr/dsc release}}
{{dsc end}}

[[de:cpp/memory/unique ptr/reset]]
[[es:cpp/memory/unique ptr/reset]]
[[fr:cpp/memory/unique ptr/reset]]
[[it:cpp/memory/unique ptr/reset]]
[[ja:cpp/memory/unique ptr/reset]]
[[pt:cpp/memory/unique ptr/reset]]
[[ru:cpp/memory/unique ptr/reset]]
[[zh:cpp/memory/unique ptr/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/swap</title>
    <ns>0</ns>
    <id>4864</id>
    <revision>
      <id>63351</id>
      <parentid>50200</parentid>
      <timestamp>2013-07-10T01:29:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1204">{{cpp/memory/unique_ptr/title|swap}}
{{cpp/memory/unique_ptr/navbar}}
{{ddcl | since=c++11 | 1=
void swap(unique_ptr&amp; other);
}}

Swaps the managed objects and associated deleters with another {{c|unique_ptr}} object {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another {{c|unique_ptr}} object to swap the managed object and the deleter with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo {
    Foo(int _val) : val(_val) { std::cout &lt;&lt; &quot;Foo...\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo...\n&quot;; }
    int val;
};

int main()
{
    std::unique_ptr&lt;Foo&gt; up1(new Foo(1));
    std::unique_ptr&lt;Foo&gt; up2(new Foo(2));

    up1.swap(up2);

    std::cout &lt;&lt; &quot;up1-&gt;val:&quot; &lt;&lt; up1-&gt;val &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;up2-&gt;val:&quot; &lt;&lt; up2-&gt;val &lt;&lt; std::endl;
}
 | output=
Foo...
Foo...
up1-&gt;val:2
up2-&gt;val:1
~Foo...
~Foo...
}}

[[de:cpp/memory/unique ptr/swap]]
[[es:cpp/memory/unique ptr/swap]]
[[fr:cpp/memory/unique ptr/swap]]
[[it:cpp/memory/unique ptr/swap]]
[[ja:cpp/memory/unique ptr/swap]]
[[pt:cpp/memory/unique ptr/swap]]
[[ru:cpp/memory/unique ptr/swap]]
[[zh:cpp/memory/unique ptr/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/swap2</title>
    <ns>0</ns>
    <id>5306</id>
    <revision>
      <id>42071</id>
      <parentid>19314</parentid>
      <timestamp>2012-11-02T21:59:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="312">{{cpp/memory/swap2|unique_ptr}}

[[de:cpp/memory/unique ptr/swap2]]
[[es:cpp/memory/unique ptr/swap2]]
[[fr:cpp/memory/unique ptr/swap2]]
[[it:cpp/memory/unique ptr/swap2]]
[[ja:cpp/memory/unique ptr/swap2]]
[[pt:cpp/memory/unique ptr/swap2]]
[[ru:cpp/memory/unique ptr/swap2]]
[[zh:cpp/memory/unique ptr/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/unique ptr</title>
    <ns>0</ns>
    <id>3112</id>
    <revision>
      <id>72178</id>
      <parentid>71676</parentid>
      <timestamp>2014-07-20T13:30:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention how the implicit derived to base conversion happens.</comment>
      <text xml:space="preserve" bytes="6961">{{cpp/memory/unique_ptr/title | unique_ptr}}
{{cpp/memory/unique_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
constexpr unique_ptr();
constexpr unique_ptr( nullptr_t );
}}
{{dcl | num=2 | since=c++11 | 1= 
explicit unique_ptr( pointer p );
}}
{{dcl | num=3 | since=c++11 | 1= 
unique_ptr( pointer p, /* see below */ d1 );
}}
{{dcl | num=4 | since=c++11 | 1= 
unique_ptr( pointer p, /* see below */ d2 );
}}
{{dcl | num=5 | since=c++11 | 1= 
unique_ptr( unique_ptr&amp;&amp; u );
}}
{{dcl | num=6 | since=c++11 | 1= 
template&lt; class U, class E &gt;
unique_ptr( unique_ptr&lt;U, E&gt;&amp;&amp; u );
}}
{{dcl | num=7 | since=c++11 | 1= 
template&lt; class U &gt;
unique_ptr( auto_ptr&lt;U&gt;&amp;&amp; u );
}}

{{dcl end}}

@1@ Constructs a {{tt|std::unique_ptr}} that owns nothing. Value-initializes the stored pointer and the stored deleter. Requires that {{tt|Deleter}} is {{concept|DefaultConstructible}} and that construction does not throw an exception.

@2@ Constructs a {{tt|std::unique_ptr}} which owns p, initializing the stored pointer with p and value-initializing the stored deleter. Requires that {{tt|Deleter}} is {{concept|DefaultConstructible}} and that construction does not throw an exception.

@3-4@ Constructs a {{tt|std::unique_ptr}} object which owns {{tt|p}}, initializing the stored pointer with {{tt|p}} and initializing a deleter {{tt|D}} as below (depends upon whether {{tt|D}} is a reference type)
:
:@a@ If {{tt|D}} is non-reference type {{c|A}}, then the signatures are:
: {{tt|unique_ptr(pointer p, const A&amp; d);}} (requires that {{tt|Deleter}} is nothrow-{{concept|CopyConstructible}})
: {{tt|unique_ptr(pointer p, A&amp;&amp; d);}} (requires that {{tt|Deleter}} is nothrow-{{concept|MoveConstructible}})
:
:@b@ If {{tt|D}} is an lvalue-reference type {{c|A&amp;}}, then the signatures are:
: {{tt|unique_ptr(pointer p, A&amp; d);}}
: {{tt|unique_ptr(pointer p, A&amp;&amp; d);}}
:
:@c@ If {{tt|D}} is an lvalue-reference type {{c|const A&amp;}}, then the signatures are:
: {{tt|unique_ptr(pointer p, const A&amp; d);}}
: {{tt|unique_ptr(pointer p, const A&amp;&amp; d);}}

@5@ Constructs a {{tt|unique_ptr}} by transferring ownership from {{tt|u}} to {{c|*this}}. If {{tt|Deleter}} is not a reference type, requires that it is nothrow-{{concept|MoveConstructible}} (if {{tt|Deleter}} is a reference, {{tt|get_deleter()}} and {{tt|u.get_deleter()}} after move construction reference the same value)

@6@ Constructs a {{tt|unique_ptr}} by transferring ownership from {{tt|u}} to {{c|*this}}, where {{tt|u}} is constructed with a specified deleter ({{tt|E}}). It depends upon whether {{tt|E}} is a reference type, as following:
:
:@a@ if {{tt|E}} is a reference type, this deleter is copy constructed from {{tt|u}}'s deleter (requires that this construction does not throw)
:@b@ if {{tt|E}} is a non-reference type, this deleter is move constructed from {{tt|u}}'s deleter (requires that this construction does not throw)
@@ This constructor only participates in overload resolution if all of the following is true:
:@a@ {{tt|unique_ptr&lt;U, E&amp;gt;::pointer}} is implicitly convertible to {{tt|pointer}}
:@b@ U is not an array type
:@c@ Either {{tt|Deleter}} is a reference type and {{tt|E}} is the same type as {{tt|D}}, or {{tt|Deleter is not a reference type}} and {{tt|E}} is implicitly convertible to {{tt|D}}

@7@ Constructs a {{tt|unique_ptr}} where the stored pointer is initialized with {{tt|u.release()}} and the stored deleter is value-initialized. This constructor only participates in overload resolution if {{tt|U*}} is implicitly convertible to {{tt|T*}} and {{tt|Deleter}} is the same type as {{tt|std::default_delete&lt;T&gt;}}.

===Parameters===
{{par begin}}
{{par | p | a pointer to an object to manage}}
{{par | d1,d2 | a deleter to use to destroy the object}}
{{par | u | another smart pointer to acquire the ownership from}}
{{par end}}

===Exceptions===
{{noexcept}}

===Notes===
{{c|std::unique_ptr&lt;Derived&gt;}} is implicitly convertible to {{c|std::unique_ptr&lt;Base&gt;}} through the overload {{v|6}} (because both the managed pointer and {{lc|std::default_delete}} are implicitly convertible)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

struct Foo { // object to manage
    Foo() { std::cout &lt;&lt; &quot;Foo ctor\n&quot;; }
    Foo(const Foo&amp;) { std::cout &lt;&lt; &quot;Foo copy ctor\n&quot;; }
    Foo(Foo&amp;&amp;) { std::cout &lt;&lt; &quot;Foo move ctor\n&quot;; }
    ~Foo() { std::cout &lt;&lt; &quot;~Foo dtor\n&quot;; }
};

struct D { // deleter
    D() {};
    D(const D&amp;) { std::cout &lt;&lt; &quot;D copy ctor\n&quot;; }
    D(D&amp;) { std::cout &lt;&lt; &quot;D non-const copy ctor\n&quot;;}
    D(D&amp;&amp;) { std::cout &lt;&lt; &quot;D move ctor \n&quot;; }
    void operator()(Foo* p) const {
        std::cout &lt;&lt; &quot;D is deleting a Foo\n&quot;;
        delete p;
    };
};

int main()
{
    std::cout &lt;&lt; &quot;Example constructor(1)...\n&quot;;
    std::unique_ptr&lt;Foo&gt; up1;  // up1 is empty
    std::unique_ptr&lt;Foo&gt; up1b(nullptr);  // up1b is empty

    std::cout &lt;&lt; &quot;Example constructor(2)...\n&quot;;
    {
        std::unique_ptr&lt;Foo&gt; up2(new Foo); //up2 now owns a Foo
    } // Foo deleted

    std::cout &lt;&lt; &quot;Example constructor(3)...\n&quot;;
    D d;
    {  // deleter type is not a reference
       std::unique_ptr&lt;Foo, D&gt; up3(new Foo, d); // deleter copied
    }
    {  // deleter type is a reference 
       std::unique_ptr&lt;Foo, D&amp;&gt; up3b(new Foo, d); // up3b holds a reference to d
    }

    std::cout &lt;&lt; &quot;Example constructor(4)...\n&quot;;
    {  // deleter is not a reference 
       std::unique_ptr&lt;Foo, D&gt; up4(new Foo, D()); // deleter moved
    }

    std::cout &lt;&lt; &quot;Example constructor(5)...\n&quot;;
    {
       std::unique_ptr&lt;Foo&gt; up5a(new Foo);
       std::unique_ptr&lt;Foo&gt; up5b(std::move(up5a)); // ownership transfer
    }

    std::cout &lt;&lt; &quot;Example constructor(6)...\n&quot;;
    {
        std::unique_ptr&lt;Foo, D&gt; up6a(new Foo, d); // D is copied
        std::unique_ptr&lt;Foo, D&gt; up6b(std::move(up6a)); // D is moved

        std::unique_ptr&lt;Foo, D&amp;&gt; up6c(new Foo, d); // D is a reference
        std::unique_ptr&lt;Foo, D&gt; up6d(std::move(up6c)); // D is copied
    }

    std::cout &lt;&lt; &quot;Example constructor(7)...\n&quot;;
    {
        std::auto_ptr&lt;Foo&gt; up7a(new Foo);
        std::unique_ptr&lt;Foo&gt; up7b(std::move(up7a)); // ownership transfer
    }
}
 | output=
Example constructor(1)...
Example constructor(2)...
Foo ctor
~Foo dtor
Example constructor(3)...
Foo ctor
D copy ctor
D is deleting a Foo
~Foo dtor
Foo ctor
D is deleting a Foo
~Foo dtor
Example constructor(4)...
Foo ctor
D move ctor 
D is deleting a Foo
~Foo dtor
Example constructor(5)...
Foo ctor
~Foo dtor
Example constructor(6)...
Foo ctor
D copy ctor
D move ctor 
Foo ctor
D non-const copy ctor
D is deleting a Foo
~Foo dtor
D is deleting a Foo
~Foo dtor
Example constructor(7)...
Foo ctor
~Foo dtor
}}


[[de:cpp/memory/unique ptr/unique ptr]]
[[es:cpp/memory/unique ptr/unique ptr]]
[[fr:cpp/memory/unique ptr/unique ptr]]
[[it:cpp/memory/unique ptr/unique ptr]]
[[ja:cpp/memory/unique ptr/unique ptr]]
[[pt:cpp/memory/unique ptr/unique ptr]]
[[ru:cpp/memory/unique ptr/unique ptr]]
[[zh:cpp/memory/unique ptr/unique ptr]]</text>
      <sha1>tsmfz0wbq9m1qi26xcswfet86f942w8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/unique ptr/~unique ptr</title>
    <ns>0</ns>
    <id>3113</id>
    <revision>
      <id>69644</id>
      <parentid>66609</parentid>
      <timestamp>2014-04-16T22:36:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>requirements and note on incomplete type</comment>
      <text xml:space="preserve" bytes="1459">{{cpp/memory/unique_ptr/title | ~unique_ptr}}
{{cpp/memory/unique_ptr/navbar}}
{{ddcl | since=c++11 |
~unique_ptr();
}}
If {{tt|get() {{==}} nullptr}} there are no effects. Otherwise, the owned object is destroyed via [[cpp/memory/unique_ptr/get_deleter|{{c|get_deleter()}}]][[cpp/memory/unique_ptr/get|{{c|(get())}}]].

Requires that {{tt|get_deleter()(get())}} does not throw exceptions.


===Notes===
Although {{tt|std::unique_ptr&lt;T&gt;}} with the default deleter may be constructed with [[cpp/language/incomplete_type|incomplete type]] {{tt|T}}, the type {{tt|T}} must be complete at the point of code where the destructor is called.

===Example===
{{example | The following program demonstrates usage of a custom deleter.
| code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
 
int main () 
{
    auto deleter = [](int* ptr){
        std::cout &lt;&lt; &quot;[deleter called]\n&quot;;
        delete ptr;
    };
 
    std::unique_ptr&lt;int,decltype(deleter)&gt; uniq(new int, deleter);
    std::cout &lt;&lt; (uniq ? &quot;not empty\n&quot; : &quot;empty\n&quot;);
    uniq.reset();
    std::cout &lt;&lt; (uniq ? &quot;not empty\n&quot; : &quot;empty\n&quot;);
}
| output=
not empty
[deleter called]
empty
}}

[[de:cpp/memory/unique ptr/~unique ptr]]
[[es:cpp/memory/unique ptr/~unique ptr]]
[[fr:cpp/memory/unique ptr/~unique ptr]]
[[it:cpp/memory/unique ptr/~unique ptr]]
[[ja:cpp/memory/unique ptr/~unique ptr]]
[[pt:cpp/memory/unique ptr/~unique ptr]]
[[ru:cpp/memory/unique ptr/~unique ptr]]
[[zh:cpp/memory/unique ptr/~unique ptr]]</text>
      <sha1>ki8rrcc2xdl0ireybice8aus9o3j2dv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/uses allocator</title>
    <ns>0</ns>
    <id>3390</id>
    <revision>
      <id>62799</id>
      <parentid>58435</parentid>
      <timestamp>2013-07-01T23:41:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2142">{{cpp/title|uses_allocator}}
{{cpp/memory/navbar}}
{{dcl begin}}
{{dcl header | memory}}
{{dcl | since=c++11 | 1=
template&lt; class T, class Alloc &gt;
struct uses_allocator
}}
{{dcl end}}

If {{tt|T}} has a member typedef {{tt|allocator_type}} which is convertible from {{tt|Alloc}}, provides the member constant {{tt|value}} equal to {{c|true}}. Otherwise {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} uses allocator {{tt|Alloc}}}}

===Specializations===

Custom specializations of the type trait {{lc|std::uses_allocator}} are allowed for types that do not have the member typedef {{tt|allocator_type}} but satisfy one of the following two requirements:

1) {{tt|T}} has a constructor which takes {{lc|std::allocator_arg_t}} as the first argument, and {{tt|Alloc}} as the second argument.

2) {{tt|T}} has a constructor which takes {{tt|Alloc}} as the last argument.

The following specializations are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc uses_allocator}}
{{dsc inc | cpp/container/dsc uses_allocator | queue}}
{{dsc inc | cpp/container/dsc uses_allocator | priority_queue}}
{{dsc inc | cpp/container/dsc uses_allocator | stack}}
{{dsc inc | cpp/utility/functional/function/dsc uses_allocator}}
{{dsc inc | cpp/thread/promise/dsc uses_allocator}}
{{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}}
{{dsc end}}

===Notes===

This type trait is used by {{lc|std::scoped_allocator_adaptor}} and may be used by custom allocators to determine whether the object being constructed is itself capable of using an allocator (e.g. is a container), in which case an allocator should be passed to its constructor.

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator_arg}}
{{dsc inc | cpp/memory/dsc allocator_arg_t}}
{{dsc inc | cpp/memory/dsc scoped_allocator_adaptor}}
{{dsc end}}

[[de:cpp/memory/uses allocator]]
[[es:cpp/memory/uses allocator]]
[[fr:cpp/memory/uses allocator]]
[[it:cpp/memory/uses allocator]]
[[ja:cpp/memory/uses allocator]]
[[pt:cpp/memory/uses allocator]]
[[ru:cpp/memory/uses allocator]]
[[zh:cpp/memory/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr</title>
    <ns>0</ns>
    <id>3417</id>
    <revision>
      <id>69991</id>
      <parentid>66882</parentid>
      <timestamp>2014-05-05T10:26:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>original s/weak/shared</comment>
      <text xml:space="preserve" bytes="2359">{{cpp/title|weak_ptr}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | header=memory | since=c++11 | 1=
template&lt; class T &gt; class weak_ptr;
}}

{{tt|std::weak_ptr}} is a smart pointer that holds a non-owning (&quot;weak&quot;) reference to an object that is managed by {{lc|std::shared_ptr}}. It must be converted to {{lc|std::shared_ptr}} in order to access the referenced object.

{{lc|std::weak_ptr}} models temporary ownership: when an object needs to be accessed only if it exists, and it may be deleted at any time by someone else, {{lc|std::weak_ptr}} is used to track the object, and it is converted to {{lc|std::shared_ptr}} to assume temporary ownership. If the original {{lc|std::shared_ptr}} is destroyed at this time, the object's lifetime is extended until the temporary {{lc|std::shared_ptr}} is destroyed as well.

In addition, {{lc|std::weak_ptr}} is used to break circular references of {{lc|std::shared_ptr}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|element_type}} | {{c|T}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc constructor}}
{{dsc inc | cpp/memory/weak_ptr/dsc destructor}}
{{dsc inc | cpp/memory/weak_ptr/dsc operator{{=}}}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/memory/weak_ptr/dsc reset}}
{{dsc inc | cpp/memory/weak_ptr/dsc swap}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/memory/weak_ptr/dsc use_count}}
{{dsc inc | cpp/memory/weak_ptr/dsc expired}}
{{dsc inc | cpp/memory/weak_ptr/dsc lock}}
{{dsc inc | cpp/memory/weak_ptr/dsc owner_before}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc swap2}}
{{dsc end}}

===Example===
{{example
 | Demonstrates how lock is used to ensure validity of the pointer.
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

std::weak_ptr&lt;int&gt; gw;

void f()
{
    if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usage
	std::cout &lt;&lt; *spt &lt;&lt; &quot;\n&quot;;
    }
    else {
        std::cout &lt;&lt; &quot;gw is expired\n&quot;;
    }
}
 
int main()
{
    {
        auto sp = std::make_shared&lt;int&gt;(42);
	gw = sp;

	f();
    }

    f();
}
 | output=
42
gw is expired
}}

[[de:cpp/memory/weak ptr]]
[[es:cpp/memory/weak ptr]]
[[fr:cpp/memory/weak ptr]]
[[it:cpp/memory/weak ptr]]
[[ja:cpp/memory/weak ptr]]
[[pt:cpp/memory/weak ptr]]
[[ru:cpp/memory/weak ptr]]
[[zh:cpp/memory/weak ptr]]</text>
      <sha1>8e2b12reiyrq3oshfq7y21h7nxo396r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/expired</title>
    <ns>0</ns>
    <id>5699</id>
    <revision>
      <id>64188</id>
      <parentid>63354</parentid>
      <timestamp>2013-08-15T15:20:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1302">{{cpp/memory/weak_ptr/title | expired}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 |
bool expired() const;
}}

Checks whether the managed object has already been deleted. Equivalent to {{c|1=use_count() == 0}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the managed object has already been deleted, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Notes===
{{tt|expired()}} may be faster than {{lc|use_count()}}.

===Example===
{{example
 | Demonstrates how expired is used to check validity of the pointer.
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;

std::weak_ptr&lt;int&gt; gw;

void f()
{
    if (!gw.expired()) {
	std::cout &lt;&lt; &quot;gw is valid\n&quot;;
    }
    else {
        std::cout &lt;&lt; &quot;gw is expired\n&quot;;
    }
}
 
int main()
{
    {
        auto sp = std::make_shared&lt;int&gt;(42);
	gw = sp;

	f();
    }

    f();
}
 | output=
gw is valid
gw is expired
}}



===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc lock}}
{{dsc inc | cpp/memory/weak_ptr/dsc use_count}}
{{dsc end}}

[[de:cpp/memory/weak ptr/expired]]
[[es:cpp/memory/weak ptr/expired]]
[[fr:cpp/memory/weak ptr/expired]]
[[it:cpp/memory/weak ptr/expired]]
[[ja:cpp/memory/weak ptr/expired]]
[[pt:cpp/memory/weak ptr/expired]]
[[ru:cpp/memory/weak ptr/expired]]
[[zh:cpp/memory/weak ptr/expired]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/lock</title>
    <ns>0</ns>
    <id>5698</id>
    <revision>
      <id>68206</id>
      <parentid>65836</parentid>
      <timestamp>2014-03-18T03:48:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2316</comment>
      <text xml:space="preserve" bytes="2288">{{cpp/memory/weak_ptr/title | lock}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 |
std::shared_ptr&lt;T&gt; lock() const
}}

Creates a new {{tt|shared_ptr}} that shares ownership of the managed object. If there is no managed object, i.e. {{c|*this}} is empty, then the returned {{tt|shared_ptr}} also is empty.

Effectively returns {{c|expired() ? shared_ptr&lt;T&gt;() : shared_ptr&lt;T&gt;(*this)}}, executed atomically.

===Parameters===
(none)

===Return value===
A {{tt|shared_ptr}} which shares ownership of the owned object.

===Exceptions===
{{noexcept}}

===Notes===
Both this function and the constructor of shared_ptr may be used to acquire temporary ownership of the managed object. The difference is that the constructor of {{c|std::shared_ptr&lt;T&gt;}} throws an exception when the {{lc|std::weak_ptr}} argument is empty, while {{c|std::weak_ptr&lt;T&gt;::lock()}} constructs an empty {{c|std::shared_ptr&lt;T&gt;}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;thread&gt;

void observe(std::weak_ptr&lt;int&gt; weak) 
{
    std::shared_ptr&lt;int&gt; observe(weak.lock());
    if (observe) {
        std::cout &lt;&lt; &quot;\tobserve() able to lock weak_ptr&lt;&gt;, value=&quot; &lt;&lt; *observe &lt;&lt; &quot;\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;\tobserve() unable to lock weak_ptr&lt;&gt;\n&quot;;
    }
}

int main()
{
    std::weak_ptr&lt;int&gt; weak;
    std::cout &lt;&lt; &quot;weak_ptr&lt;&gt; not yet initialized\n&quot;;
    observe(weak);
    
    {
        std::shared_ptr&lt;int&gt; shared(new int(42));
        weak = shared;
        std::cout &lt;&lt; &quot;weak_ptr&lt;&gt; initialized with shared_ptr.\n&quot;;
        observe(weak);
    }

    std::cout &lt;&lt; &quot;shared_ptr&lt;&gt; has been destructed due to scope exit.\n&quot;;
    observe(weak);
}
 | output=
weak_ptr&lt;&gt; not yet initialized
        observe() unable to lock weak_ptr&lt;&gt;
weak_ptr&lt;&gt; initialized with shared_ptr.
        observe() able to lock weak_ptr&lt;&gt;, value=42
shared_ptr&lt;&gt; has been destructed due to scope exit.
        observe() unable to lock weak_ptr&lt;&gt;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc expired}}
{{dsc end}}

[[de:cpp/memory/weak ptr/lock]]
[[es:cpp/memory/weak ptr/lock]]
[[fr:cpp/memory/weak ptr/lock]]
[[it:cpp/memory/weak ptr/lock]]
[[ja:cpp/memory/weak ptr/lock]]
[[pt:cpp/memory/weak ptr/lock]]
[[ru:cpp/memory/weak ptr/lock]]
[[zh:cpp/memory/weak ptr/lock]]</text>
      <sha1>2hm3az4kz2ei03u6sm1bwjkfx12arxb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/operator=</title>
    <ns>0</ns>
    <id>5703</id>
    <revision>
      <id>68205</id>
      <parentid>62800</parentid>
      <timestamp>2014-03-18T03:45:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2315 (move assignment)</comment>
      <text xml:space="preserve" bytes="1409">{{cpp/memory/weak_ptr/title | operator{{=}}}}
{{cpp/memory/weak_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
weak_ptr&amp; operator{{=}}( const weak_ptr&amp; r );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Y &gt; 
weak_ptr&amp; operator{{=}}( const weak_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=3 | since=c++11 |
template&lt; class Y &gt; 
weak_ptr&amp; operator{{=}}( const shared_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=4 | since=c++14 |
weak_ptr&amp; operator{{=}}( weak_ptr&amp;&amp; r );
}}
{{dcl | num=5 | since=c++14 |
template&lt; class Y &gt; 
weak_ptr&amp; operator{{=}}( weak_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl end}}

Replaces the managed object with the one managed by {{tt|r}}. The object is shared with {{tt|r}}. If {{tt|r}} manages no object, {{c|*this}} manages no object too. Equivalent to {{c|weak_ptr&lt;T&gt;(r).swap(*this)}}.

@4,5@ Equivalent to {{c|std::weak_ptr(std::move(r)).swap(*this)}}.

===Parameters===
{{par begin}}
{{par | r | smart pointer to share an object with}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

===Notes===
The implementation may meet the requirements without creating a temporary {{tt|weak_ptr}} object.

[[de:cpp/memory/weak ptr/operator=]]
[[es:cpp/memory/weak ptr/operator=]]
[[fr:cpp/memory/weak ptr/operator=]]
[[it:cpp/memory/weak ptr/operator=]]
[[ja:cpp/memory/weak ptr/operator=]]
[[pt:cpp/memory/weak ptr/operator=]]
[[ru:cpp/memory/weak ptr/operator=]]
[[zh:cpp/memory/weak ptr/operator=]]</text>
      <sha1>kgm8vmyuo40dfzd5mmml5veii3dl6h9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/owner before</title>
    <ns>0</ns>
    <id>5696</id>
    <revision>
      <id>41996</id>
      <parentid>20930</parentid>
      <timestamp>2012-11-02T21:41:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="357">{{cpp/memory/owner_before|weak_ptr}}

[[de:cpp/memory/weak ptr/owner before]]
[[es:cpp/memory/weak ptr/owner before]]
[[fr:cpp/memory/weak ptr/owner before]]
[[it:cpp/memory/weak ptr/owner before]]
[[ja:cpp/memory/weak ptr/owner before]]
[[pt:cpp/memory/weak ptr/owner before]]
[[ru:cpp/memory/weak ptr/owner before]]
[[zh:cpp/memory/weak ptr/owner before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/reset</title>
    <ns>0</ns>
    <id>5702</id>
    <revision>
      <id>63356</id>
      <parentid>41989</parentid>
      <timestamp>2013-07-10T01:29:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="553">{{cpp/memory/weak_ptr/title | reset}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 | 1= 
void reset();
}}

Releases the reference to the managed object. After the call {{c|*this}} manages no object.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/memory/weak ptr/reset]]
[[es:cpp/memory/weak ptr/reset]]
[[fr:cpp/memory/weak ptr/reset]]
[[it:cpp/memory/weak ptr/reset]]
[[ja:cpp/memory/weak ptr/reset]]
[[pt:cpp/memory/weak ptr/reset]]
[[ru:cpp/memory/weak ptr/reset]]
[[zh:cpp/memory/weak ptr/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/swap</title>
    <ns>0</ns>
    <id>5701</id>
    <revision>
      <id>64851</id>
      <parentid>50207</parentid>
      <timestamp>2013-08-27T01:27:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=</comment>
      <text xml:space="preserve" bytes="589">{{cpp/memory/weak_ptr/title | swap}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 |
void swap( weak_ptr&amp; r );
}}

Exchanges the contents of {{c|*this}} and {{tt|r}}

===Parameters===
{{par begin}}
{{par | r | smart pointer to exchange the contents with}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/memory/weak ptr/swap]]
[[es:cpp/memory/weak ptr/swap]]
[[fr:cpp/memory/weak ptr/swap]]
[[it:cpp/memory/weak ptr/swap]]
[[ja:cpp/memory/weak ptr/swap]]
[[pt:cpp/memory/weak ptr/swap]]
[[ru:cpp/memory/weak ptr/swap]]
[[zh:cpp/memory/weak ptr/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/swap2</title>
    <ns>0</ns>
    <id>5304</id>
    <revision>
      <id>41975</id>
      <parentid>19312</parentid>
      <timestamp>2012-11-02T21:36:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="294">{{cpp/memory/swap2|weak_ptr}}

[[de:cpp/memory/weak ptr/swap2]]
[[es:cpp/memory/weak ptr/swap2]]
[[fr:cpp/memory/weak ptr/swap2]]
[[it:cpp/memory/weak ptr/swap2]]
[[ja:cpp/memory/weak ptr/swap2]]
[[pt:cpp/memory/weak ptr/swap2]]
[[ru:cpp/memory/weak ptr/swap2]]
[[zh:cpp/memory/weak ptr/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/use count</title>
    <ns>0</ns>
    <id>5700</id>
    <revision>
      <id>64191</id>
      <parentid>64190</parentid>
      <timestamp>2013-08-15T15:22:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add link</comment>
      <text xml:space="preserve" bytes="970">{{cpp/memory/weak_ptr/title | use_count}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 |
long use_count() const;
}}

Returns the number of {{tt|shared_ptr}} instances that share ownership of the managed object, or {{c|0}} if the managed object has already been deleted, i.e. {{c|*this}} is empty.

===Parameters===
(none)

===Return value===
The number of {{tt|shared_ptr}} instances sharing the ownership of the managed object.

===Exceptions===
{{noexcept}}

===Notes===
{{lc|expired()}} may be faster than {{tt|use_count()}}.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc expired}}
{{dsc end}}

[[de:cpp/memory/weak ptr/use count]]
[[es:cpp/memory/weak ptr/use count]]
[[fr:cpp/memory/weak ptr/use count]]
[[it:cpp/memory/weak ptr/use count]]
[[ja:cpp/memory/weak ptr/use count]]
[[pt:cpp/memory/weak ptr/use count]]
[[ru:cpp/memory/weak ptr/use count]]
[[zh:cpp/memory/weak ptr/use count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/weak ptr</title>
    <ns>0</ns>
    <id>5659</id>
    <revision>
      <id>68204</id>
      <parentid>62801</parentid>
      <timestamp>2014-03-18T03:43:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2315 (move constructors)</comment>
      <text xml:space="preserve" bytes="2270">{{cpp/memory/weak_ptr/title | weak_ptr}}
{{cpp/memory/weak_ptr/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
constexpr weak_ptr();
}}
{{dcl | num=2 | since=c++11 | 1= 
weak_ptr( const weak_ptr&amp; r );
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class Y &gt; 
weak_ptr( const weak_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=2 | since=c++11 | 1= 
template&lt; class Y &gt; 
weak_ptr( const std::shared_ptr&lt;Y&gt;&amp; r );
}}
{{dcl | num=3 | since=c++14 | 1= 
weak_ptr( weak_ptr&amp;&amp; r );
}}
{{dcl | num=3 | since=c++14 | 1= 
template&lt; class Y &gt; 
weak_ptr( weak_ptr&lt;Y&gt;&amp;&amp; r );
}}
{{dcl end}}

Constructs new {{tt|weak_ptr}} that potentially shares an object with {{tt|r}}.

@1@ Default constructor. Constructs empty {{tt|weak_ptr}}.
@2@ Constructs new {{tt|weak_ptr}} which shares an object managed by {{tt|r}}. If {{tt|r}} manages no object, {{c|*this}} manages no object too. The templated overloads don't participate in the overload resolution unless {{tt|Y*}} is implicitly convertible to {{tt|T*}}. 
@3@ Move constructors. Moves a weak_ptr instance from {{tt|r}} into {{tt|*this}}. After this, {{tt|r}} is empty and {{c|1=r.use_count()==0}}. The templated overload doesn't participate in the overload resolution unless {{tt|Y*}} is implicitly convertible to {{tt|T*}}

===Parameters===
{{par begin}}
{{par | r | a {{lc|std::shared_ptr}} or {{lc|std::weak_ptr}} that will be viewed by this {{lc|std::weak_ptr}}}}
{{par end}} 

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;memory&gt;
#include &lt;iostream&gt;

struct Foo {};

int main()
{
   std::weak_ptr&lt;Foo&gt; w_ptr;

   {
      auto ptr = std::make_shared&lt;Foo&gt;();
      w_ptr = ptr;
      std::cout &lt;&lt; &quot;w_ptr.use_count() inside scope: &quot; &lt;&lt; w_ptr.use_count() &lt;&lt; '\n';
   }

   std::cout &lt;&lt; &quot;w_ptr.use_count() out of scope: &quot; &lt;&lt; w_ptr.use_count() &lt;&lt; '\n';
}
 | output=
w_ptr.use_count() inside scope: 1
w_ptr.use_count() out of scope: 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/weak_ptr/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/memory/weak ptr/weak ptr]]
[[es:cpp/memory/weak ptr/weak ptr]]
[[fr:cpp/memory/weak ptr/weak ptr]]
[[it:cpp/memory/weak ptr/weak ptr]]
[[ja:cpp/memory/weak ptr/weak ptr]]
[[pt:cpp/memory/weak ptr/weak ptr]]
[[ru:cpp/memory/weak ptr/weak ptr]]
[[zh:cpp/memory/weak ptr/weak ptr]]</text>
      <sha1>m1l5c1kwfkeroyx16tr1bwwv93o7fp1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/memory/weak ptr/~weak ptr</title>
    <ns>0</ns>
    <id>5695</id>
    <revision>
      <id>63358</id>
      <parentid>41961</parentid>
      <timestamp>2013-07-10T01:29:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="490">{{cpp/memory/weak_ptr/title | ~weak_ptr}}
{{cpp/memory/weak_ptr/navbar}}
{{ddcl | since=c++11 |
~weak_ptr();
}}

Destroys the {{tt|weak_ptr}} object. Results in no effect to the managed object.

[[de:cpp/memory/weak ptr/~weak ptr]]
[[es:cpp/memory/weak ptr/~weak ptr]]
[[fr:cpp/memory/weak ptr/~weak ptr]]
[[it:cpp/memory/weak ptr/~weak ptr]]
[[ja:cpp/memory/weak ptr/~weak ptr]]
[[pt:cpp/memory/weak ptr/~weak ptr]]
[[ru:cpp/memory/weak ptr/~weak ptr]]
[[zh:cpp/memory/weak ptr/~weak ptr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric</title>
    <ns>0</ns>
    <id>1332</id>
    <revision>
      <id>70997</id>
      <parentid>70995</parentid>
      <timestamp>2014-06-04T18:40:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="1986">{{title|Numerics library}}
{{cpp/numeric/navbar}}

The C++ numerics library includes common mathematical functions and types, as well as optimized numeric arrays and support for random number generation.

===[[cpp/numeric/math|Common mathematical functions]]===

The header {{tt|cmath}} provides [[cpp/numeric/math|standard C library mathematical functions]] such as {{lc|std::fabs}}, {{lc|std::sqrt}}, and {{lc|std::sin}}.

===Complex numbers===

{{dsc begin}}
{{dsc header | complex}}
{{dsc tclass | cpp/numeric/complex | a complex number type }}
{{dsc end}}

===Numeric arrays===

{{dsc begin}}
{{dsc header | valarray}}
{{dsc tclass | cpp/numeric/valarray | numeric arrays and array slices }}
{{dsc end}}

===Generic numeric operations===

{{dsc begin}}
{{dsc header | numeric}}
{{dsc inc | cpp/algorithm/dsc iota}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc inc | cpp/algorithm/dsc inner_product}}
{{dsc inc | cpp/algorithm/dsc adjacent_difference}}
{{dsc inc | cpp/algorithm/dsc partial_sum}}
{{dsc end}}

===[[cpp/numeric/random|Pseudo-random number generation]]===

The header {{tt|random}} defines [[cpp/numeric/random|pseudo-random number generators and numerical distributions]].  The header {{tt|cstdlib}} also includes C-style random number generation via {{lc|std::srand}} and {{lc|std::rand}}.

===[[cpp/numeric/ratio|Compile time rational arithmetic]] {{mark since c++11}}===

The header {{tt|ratio}} provides [[cpp/numeric/ratio|types and functions for manipulating and storing compile-time ratios]].

===[[cpp/numeric/fenv|Floating-point environment]]===

The header {{tt|fenv}} defines [[cpp/numeric/fenv|flags and functions related to exceptional floating-point state]], such as overflow and division by zero.

===See also===
{{dsc begin}}
{{dsc see c | c/numeric | Numerics}}
{{dsc end}}

[[ar:cpp/numeric]]
[[de:cpp/numeric]]
[[es:cpp/numeric]]
[[fr:cpp/numeric]]
[[it:cpp/numeric]]
[[ja:cpp/numeric]]
[[pt:cpp/numeric]]
[[ru:cpp/numeric]]
[[zh:cpp/numeric]]</text>
      <sha1>2a7tenzy9cpcwlvhzh69tko0rr3dhqv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex</title>
    <ns>0</ns>
    <id>2707</id>
    <revision>
      <id>71232</id>
      <parentid>71057</parentid>
      <timestamp>2014-06-08T20:02:15Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>use constructor template</comment>
      <text xml:space="preserve" bytes="3842">{{cpp/title|complex}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | 1=
template&lt; class T &gt;
class complex;
}}
{{dcl | num=2| 1=
template&lt;&gt; class complex&lt;float&gt;;
}}
{{dcl | num=3| 1=
template&lt;&gt; class complex&lt;double&gt;;
}}
{{dcl | num=4| 1=
template&lt;&gt; class complex&lt;long double&gt;;
}}
{{dcl end}}

The specializations {{c|std::complex&lt;float&gt;}}, {{c|std::complex&lt;double&gt;}}, and {{c|std::complex&lt;long double&gt;}} are literal types for representing and manipulating [[enwiki:Complex_number|complex numbers]]. 

The effect of instantiating the template {{tt|complex}} for any other type is unspecified.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc complex}}
{{dsc inc | cpp/numeric/complex/dsc operator{{=}}}}
{{dsc inc | cpp/numeric/complex/dsc real}}
{{dsc inc | cpp/numeric/complex/dsc imag}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith2}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc inc | cpp/numeric/complex/dsc operator_cmp}}
{{dsc inc | cpp/numeric/complex/dsc operator_ltltgtgt}}
{{dsc inc | cpp/numeric/complex/dsc real2}}
{{dsc inc | cpp/numeric/complex/dsc imag2}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc inc | cpp/numeric/complex/dsc norm}}
{{dsc inc | cpp/numeric/complex/dsc conj}}
{{dsc inc | cpp/numeric/complex/dsc proj}}
{{dsc inc | cpp/numeric/complex/dsc polar}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/complex/dsc exp}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc inc | cpp/numeric/complex/dsc log10}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/complex/dsc pow}}
{{dsc inc | cpp/numeric/complex/dsc sqrt}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc atan}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc end}}

===Non-static data members===
{{rev begin}}
{{rev|since=c++11|
For any object {{tt|z}} of type {{tt|complex&lt;T&gt;}}, {{c|reinterpret_cast&lt;T(&amp;)[2]&gt;(z)[0]}} is the real part of z and {{c|reinterpret_cast&lt;T(&amp;)[2]&gt;(z)[1]}} is the imaginary part of z.

For any pointer to an element of an array of {{tt|complex&lt;T&gt;}} named {{tt|p}} and any valid array index {{c|i}}, {{c|reinterpret_cast&lt;T*&gt;(p)[2*i]}} is the real part of the complex number {{c|p[i]}}, and {{c|reinterpret_cast&lt;T*&gt;(p)[2*i + 1]}} is the imaginary part of the complex number {{c|p[i]}}

These requirements essentially limit implementation of each of the three specializations of {{lc|std::complex}} to declaring two and only two non-static data members, of type {{tt|value_type}}, with the same member access, which hold the real and the imaginary components, respectively.
}}
{{rev end}}

===Literals===
{{dsc begin}}
{{dsc namespace | std::literals::complex_literals | inline=true }}
{{dsc inc | cpp/numeric/dsc operator&quot;&quot;i}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/numeric/complex | Complex number arithmetic}}
{{dsc end}}

[[de:cpp/numeric/complex]]
[[es:cpp/numeric/complex]]
[[fr:cpp/numeric/complex]]
[[it:cpp/numeric/complex]]
[[ja:cpp/numeric/complex]]
[[pt:cpp/numeric/complex]]
[[ru:cpp/numeric/complex]]
[[zh:cpp/numeric/complex]]</text>
      <sha1>jtps353opb0px0y1s92dqb13tr0pdg7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/abs</title>
    <ns>0</ns>
    <id>8523</id>
    <revision>
      <id>71278</id>
      <parentid>71271</parentid>
      <timestamp>2014-06-09T03:49:02Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to polar</comment>
      <text xml:space="preserve" bytes="908">{{cpp/title|abs{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
T abs( const complex&lt;T&gt;&amp; z );
}}

Returns the magnitude of the complex number {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the magnitude of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc inc | cpp/numeric/complex/dsc polar}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/math/dsc hypot}}
{{dsc inc | cpp/numeric/valarray/dsc abs}}
{{dsc see c | c/numeric/complex/cabs}}
{{dsc end}}

[[de:cpp/numeric/complex/abs]]
[[es:cpp/numeric/complex/abs]]
[[fr:cpp/numeric/complex/abs]]
[[it:cpp/numeric/complex/abs]]
[[ja:cpp/numeric/complex/abs]]
[[pt:cpp/numeric/complex/abs]]
[[ru:cpp/numeric/complex/abs]]
[[zh:cpp/numeric/complex/abs]]</text>
      <sha1>hxtnrgdbm5g9n8cmbccw4jn9hw1v5fz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/acos</title>
    <ns>0</ns>
    <id>4072</id>
    <revision>
      <id>70890</id>
      <parentid>70856</parentid>
      <timestamp>2014-05-31T20:41:21Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="1129">{{cpp/title|acos{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; acos( const complex&lt;T&gt;&amp; z );
}}

Computes complex arc cosine of a complex value {{tt|z}}. Branch cut exists outside the interval {{math|[−1 ; +1]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex arc cosine of {{tt|z}} in the range {{math|[0 ; &amp;infin;)}} along the real axis and in the range {{math|[−''i''&amp;pi; ; ''i''&amp;pi;]}} along the imaginary axis.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc atan}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc see c | c/numeric/complex/cacos}}
{{dsc end}}

[[de:cpp/numeric/complex/acos]]
[[es:cpp/numeric/complex/acos]]
[[fr:cpp/numeric/complex/acos]]
[[it:cpp/numeric/complex/acos]]
[[ja:cpp/numeric/complex/acos]]
[[pt:cpp/numeric/complex/acos]]
[[ru:cpp/numeric/complex/acos]]
[[zh:cpp/numeric/complex/acos]]</text>
      <sha1>lwp0j4wtvltka1koivavxets040no8n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/acosh</title>
    <ns>0</ns>
    <id>8519</id>
    <revision>
      <id>70843</id>
      <parentid>66429</parentid>
      <timestamp>2014-05-31T01:11:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to asinh(std::complex), atanh(std::complex), acosh, and C documentation, -2 links</comment>
      <text xml:space="preserve" bytes="909">{{cpp/title|acosh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; acosh( const complex&lt;T&gt;&amp; z );
}}

Computes complex area hyperbolic cosine of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex area hyperbolic cosine of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc see c | c/numeric/complex/cacosh}}
{{dsc end}}

[[de:cpp/numeric/complex/acosh]]
[[es:cpp/numeric/complex/acosh]]
[[fr:cpp/numeric/complex/acosh]]
[[it:cpp/numeric/complex/acosh]]
[[ja:cpp/numeric/complex/acosh]]
[[pt:cpp/numeric/complex/acosh]]
[[ru:cpp/numeric/complex/acosh]]
[[zh:cpp/numeric/complex/acosh]]</text>
      <sha1>mx9u2p1p0tvqu2s4cwc340vc8bdxc47</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/arg</title>
    <ns>0</ns>
    <id>8524</id>
    <revision>
      <id>71277</id>
      <parentid>66143</parentid>
      <timestamp>2014-06-09T03:47:21Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to abs(std::complex), atan2, atan2(std::valarray) and C documentation, - link to norm and conj</comment>
      <text xml:space="preserve" bytes="1361">{{cpp/title|arg{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | 1=
template&lt; class T &gt; 
T arg( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=2| since=c++11 | 1=
long double arg( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrIngeter &gt;
double arg( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
float arg( float z );
}}
{{dcl end}}

Returns the phase angle (in radians) of the complex number {{tt|z}}, i.e. {{c|atan2(std::imag(z), std::real(z))}}.

{{mark since c++11}}Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the phase angle of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc polar}}
{{dsc inc | cpp/numeric/math/dsc atan2}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}
{{dsc see c | c/numeric/complex/carg}}
{{dsc end}}

[[de:cpp/numeric/complex/arg]]
[[es:cpp/numeric/complex/arg]]
[[fr:cpp/numeric/complex/arg]]
[[it:cpp/numeric/complex/arg]]
[[ja:cpp/numeric/complex/arg]]
[[pt:cpp/numeric/complex/arg]]
[[ru:cpp/numeric/complex/arg]]
[[zh:cpp/numeric/complex/arg]]</text>
      <sha1>hm0bdl64jdi6gajh2i3vieczw526ap7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/asin</title>
    <ns>0</ns>
    <id>4071</id>
    <revision>
      <id>70889</id>
      <parentid>70855</parentid>
      <timestamp>2014-05-31T20:40:39Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="1044">{{cpp/title|asin{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; asin( const complex&lt;T&gt;&amp; z );
}}

Computes complex arc sine of a complex value {{tt|z}}. Branch cut exists outside the interval {{math|[−1 ; +1]}} along the real axis.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex arc sine of {{tt|z}} in the range {{math|[0 ; &amp;pi;)}} along the real axis.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc atan}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc see c | c/numeric/complex/casin}}
{{dsc end}}

[[de:cpp/numeric/complex/asin]]
[[es:cpp/numeric/complex/asin]]
[[fr:cpp/numeric/complex/asin]]
[[it:cpp/numeric/complex/asin]]
[[ja:cpp/numeric/complex/asin]]
[[pt:cpp/numeric/complex/asin]]
[[ru:cpp/numeric/complex/asin]]
[[zh:cpp/numeric/complex/asin]]</text>
      <sha1>h0bqbooma4eh2me30023ve3vn9lzxtw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/asinh</title>
    <ns>0</ns>
    <id>8518</id>
    <revision>
      <id>70842</id>
      <parentid>66431</parentid>
      <timestamp>2014-05-31T01:07:07Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to acosh(std::complex), atanh(std::complex), asinh and C documentation, -2 links</comment>
      <text xml:space="preserve" bytes="905">{{cpp/title|asinh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; asinh( const complex&lt;T&gt;&amp; z );
}}

Computes complex area hyperbolic sine of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex area hyperbolic sine of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc see c | c/numeric/complex/casinh}}
{{dsc end}}

[[de:cpp/numeric/complex/asinh]]
[[es:cpp/numeric/complex/asinh]]
[[fr:cpp/numeric/complex/asinh]]
[[it:cpp/numeric/complex/asinh]]
[[ja:cpp/numeric/complex/asinh]]
[[pt:cpp/numeric/complex/asinh]]
[[ru:cpp/numeric/complex/asinh]]
[[zh:cpp/numeric/complex/asinh]]</text>
      <sha1>6ruly5422hjllh4q4a62tsv7gndtnv6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/atan</title>
    <ns>0</ns>
    <id>4073</id>
    <revision>
      <id>70891</id>
      <parentid>70857</parentid>
      <timestamp>2014-05-31T20:42:11Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="1081">{{cpp/title|atan{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; atan( const complex&lt;T&gt;&amp; z );
}}

Computes complex arc tangent of a complex value {{tt|z}}. Branch cut exists outside the interval {{math|[−i ; +i]}} along the imaginary axis.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex arc tangent of {{tt|z}} in the range {{math|[−''i''&amp;pi;/2 ; +''i''&amp;pi;/2]}} along the imaginary axis.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc see c | c/numeric/complex/catan}}
{{dsc end}}

[[de:cpp/numeric/complex/atan]]
[[es:cpp/numeric/complex/atan]]
[[fr:cpp/numeric/complex/atan]]
[[it:cpp/numeric/complex/atan]]
[[ja:cpp/numeric/complex/atan]]
[[pt:cpp/numeric/complex/atan]]
[[ru:cpp/numeric/complex/atan]]
[[zh:cpp/numeric/complex/atan]]</text>
      <sha1>s1efm0aefr1v2l69codhdk40ssnqeh6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/atanh</title>
    <ns>0</ns>
    <id>8520</id>
    <revision>
      <id>70844</id>
      <parentid>66426</parentid>
      <timestamp>2014-05-31T01:14:17Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to asinh(std::complex), acosh(std::complex), atanh, and C documentation, -2 links</comment>
      <text xml:space="preserve" bytes="911">{{cpp/title|atanh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; atanh( const complex&lt;T&gt;&amp; z );
}}

Computes complex area hyperbolic tangent of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex area hyperbolic tangent of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}
{{dsc see c | c/numeric/complex/catanh}}
{{dsc end}}

[[de:cpp/numeric/complex/atanh]]
[[es:cpp/numeric/complex/atanh]]
[[fr:cpp/numeric/complex/atanh]]
[[it:cpp/numeric/complex/atanh]]
[[ja:cpp/numeric/complex/atanh]]
[[pt:cpp/numeric/complex/atanh]]
[[ru:cpp/numeric/complex/atanh]]
[[zh:cpp/numeric/complex/atanh]]</text>
      <sha1>tf88adbvaz029r4uk0hmx8jcbz7yoxh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/complex</title>
    <ns>0</ns>
    <id>3540</id>
    <revision>
      <id>71288</id>
      <parentid>71229</parentid>
      <timestamp>2014-06-09T04:13:49Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to operator&quot;&quot;i</comment>
      <text xml:space="preserve" bytes="3341">{{cpp/numeric/complex/title|complex}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl h|primary template complex&lt;T&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
complex( const T&amp; re = T(), const T&amp; im = T() );
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr complex( const T&amp; re = T(), const T&amp; im = T() );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | until=c++14 | 
complex( const complex&amp; other );
}}
{{dcl | num=2 | since=c++14 |
constexpr complex( const complex&amp; other );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++14 | 
template&lt; class X &gt;
complex( const complex&lt;X&gt;&amp; other);
}}
{{dcl | num=3 | since=c++14 |
template&lt; class X &gt;
constexpr complex( const complex&lt;X&gt;&amp;  other);
}}
{{dcl rev end}}
{{dcl h|specialization complex&lt;float&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 |1=
complex(float re = 0.0f, float im = 0.0f);
}}
{{dcl | num=1 | since=c++11 |1=
constexpr complex(float re = 0.0f, float im = 0.0f);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++11 |
explicit complex(const complex&lt;double&gt;&amp; other);
explicit complex(const complex&lt;long double&gt;&amp; other);
}}
{{dcl | num=3 | since=c++11 |
explicit constexpr complex(const complex&lt;double&gt;&amp; other);
explicit constexpr complex(const complex&lt;long double&gt;&amp; other);
}}
{{dcl rev end}}

{{dcl h|specialization complex&lt;double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 |1=
complex(double re = 0.0, double im = 0.0);
}}
{{dcl | num=1 | since=c++11 |1=
constexpr complex(double re = 0.0, double im = 0.0);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++11 |
complex(const complex&lt;float&gt;&amp; other);
explicit complex(const complex&lt;long double&gt;&amp; other);
}}
{{dcl | num=3 | since=c++11 |
constexpr complex(const complex&lt;float&gt;&amp; other);
explicit constexpr complex(const complex&lt;long double&gt;&amp; other);
}}

{{dcl h|specialization complex&lt;long double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 |1=
complex(long double re = 0.0L, long double im = 0.0L);
}}
{{dcl | num=1 | since=c++11 |1=
constexpr complex(long double re = 0.0L, long double im = 0.0L);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++11 |
complex(const complex&lt;float&gt;&amp; other);
complex(const complex&lt;double&gt;&amp; other);
}}
{{dcl | num=3 | since=c++11 |
constexpr complex(const complex&lt;float&gt;&amp; other);
constexpr complex(const complex&lt;double&gt;&amp; other);
}}


{{dcl end}}

Constructs the {{lc|std::complex}} object.

@1@ Constructs the complex number from real and imaginary parts.
@2@ Copy constructor. Constructs the object with the copy of the contents of {{tt|other}}. The copy constructor is implicit in the standard specializations.
@3@ Converting constructor. Constructs the object from a complex number of a different type.

===Parameters===
{{par begin}}
{{par | re | the real part}}
{{par | im | the imaginary part}}
{{par | other | another complex to use as source}}
{{par end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc operator{{=}}}}
{{dsc inc | cpp/numeric/dsc operator&quot;&quot;i}}
{{dsc see c | c/numeric/complex/CMPLX}}
{{dsc end}}

[[de:cpp/numeric/complex/complex]]
[[es:cpp/numeric/complex/complex]]
[[fr:cpp/numeric/complex/complex]]
[[it:cpp/numeric/complex/complex]]
[[ja:cpp/numeric/complex/complex]]
[[pt:cpp/numeric/complex/complex]]
[[ru:cpp/numeric/complex/complex]]
[[zh:cpp/numeric/complex/complex]]</text>
      <sha1>9axsfj9jcdi1mg6wkisoh14vmj8pax5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/conj</title>
    <ns>0</ns>
    <id>8526</id>
    <revision>
      <id>71702</id>
      <parentid>62803</parentid>
      <timestamp>2014-06-20T20:45:34Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C documentation</comment>
      <text xml:space="preserve" bytes="1336">{{cpp/title|conj{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; conj( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=2 | since=c++11 | 1=
std::complex&lt;long double&gt; conj( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrIngeter &gt;
std::complex&lt;double&gt; conj( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
std::complex&lt;float&gt; conj( float z );
}}
{{dcl end}}

Returns the complex conjugate of the complex number {{tt|z}}.

{{mark since c++11}}Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the complex conjugate of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc norm}}
{{dsc inc | cpp/numeric/complex/dsc polar}}
{{dsc see c | c/numeric/complex/conj}}
{{dsc end}}

[[de:cpp/numeric/complex/conj]]
[[es:cpp/numeric/complex/conj]]
[[fr:cpp/numeric/complex/conj]]
[[it:cpp/numeric/complex/conj]]
[[ja:cpp/numeric/complex/conj]]
[[pt:cpp/numeric/complex/conj]]
[[ru:cpp/numeric/complex/conj]]
[[zh:cpp/numeric/complex/conj]]</text>
      <sha1>0fmu9odhyfvxl9hnbbsjna6ktbsvt45</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/cos</title>
    <ns>0</ns>
    <id>4075</id>
    <revision>
      <id>70887</id>
      <parentid>70850</parentid>
      <timestamp>2014-05-31T20:39:07Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="878">{{cpp/title|cos{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; cos( const complex&lt;T&gt;&amp; z );
}}

Computes complex cosine of a complex value {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex cosine of {{tt|z}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc see c | c/numeric/complex/ccos}}
{{dsc end}}

[[de:cpp/numeric/complex/cos]]
[[es:cpp/numeric/complex/cos]]
[[fr:cpp/numeric/complex/cos]]
[[it:cpp/numeric/complex/cos]]
[[ja:cpp/numeric/complex/cos]]
[[pt:cpp/numeric/complex/cos]]
[[ru:cpp/numeric/complex/cos]]
[[zh:cpp/numeric/complex/cos]]</text>
      <sha1>4bxsmjfr7dpvyeurrxlcinii2f67vft</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/cosh</title>
    <ns>0</ns>
    <id>8516</id>
    <revision>
      <id>70884</id>
      <parentid>70840</parentid>
      <timestamp>2014-05-31T20:34:05Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="930">{{cpp/title|cosh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; cosh( const complex&lt;T&gt;&amp; z );
}}

Computes complex hyperbolic cosine of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex hyperbolic cosine of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc see c | c/numeric/complex/ccosh}}
{{dsc end}}

[[de:cpp/numeric/complex/cosh]]
[[es:cpp/numeric/complex/cosh]]
[[fr:cpp/numeric/complex/cosh]]
[[it:cpp/numeric/complex/cosh]]
[[ja:cpp/numeric/complex/cosh]]
[[pt:cpp/numeric/complex/cosh]]
[[ru:cpp/numeric/complex/cosh]]
[[zh:cpp/numeric/complex/cosh]]</text>
      <sha1>e8ci76kzx2j2o8q3nohx5ft5gcwy0i2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/exp</title>
    <ns>0</ns>
    <id>4067</id>
    <revision>
      <id>70895</id>
      <parentid>70878</parentid>
      <timestamp>2014-05-31T20:59:27Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="1130">{{cpp/title|exp{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; exp( const complex&lt;T&gt;&amp; z );
}}

Compute ''e'' (Euler's number, {{tt|2.7182818}}) raised to the complex base-e exponential of {{tt|x}}.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

''e'' raised to a complex power.

===Example===
{{example|code=
#include &lt;complex&gt;
#include &lt;iostream&gt;

int main()
{
   const double pi = std::acos(-1);
   const std::complex&lt;double&gt; i(0, 1);

   std::cout &lt;&lt; std::fixed &lt;&lt; &quot; exp(i*pi) = &quot; &lt;&lt; std::exp(i * pi) &lt;&lt; '\n';
}
|output=
exp(i*pi) = (-1.000000,0.000000)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/valarray/dsc exp}}
{{dsc see c | c/numeric/complex/cexp}}
{{dsc end}}

[[de:cpp/numeric/complex/exp]]
[[es:cpp/numeric/complex/exp]]
[[fr:cpp/numeric/complex/exp]]
[[it:cpp/numeric/complex/exp]]
[[ja:cpp/numeric/complex/exp]]
[[pt:cpp/numeric/complex/exp]]
[[ru:cpp/numeric/complex/exp]]
[[zh:cpp/numeric/complex/exp]]</text>
      <sha1>g46dgra4jhpltpoi1s5x4i6vxk2d81v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/imag</title>
    <ns>0</ns>
    <id>3545</id>
    <revision>
      <id>71600</id>
      <parentid>64695</parentid>
      <timestamp>2014-06-14T22:02:02Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to imag2</comment>
      <text xml:space="preserve" bytes="1931">{{cpp/numeric/complex/title|imag}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl h|primary template complex&lt;T&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
T imag() const;
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr T imag() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void imag( T value );
}}
{{dcl h|specialization complex&lt;float&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
float imag() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr float imag();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr float imag() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void imag( float value );
}}

{{dcl h|specialization complex&lt;double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
double imag() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr double imag();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr double imag() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void imag( double value );
}}

{{dcl h|specialization complex&lt;long double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
long double imag() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr long double imag();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr long double imag() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void imag( long double value );
}}

{{dcl end}}

Accesses the imaginary part of the complex number. 

@1@ Returns the imaginary part.
@2@ Sets the imaginary part to {{tt|value}}.

===Parameters===
{{par begin}}
{{par | value | the value to set the imaginary part to}}
{{par end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc imag2}}
{{dsc inc | cpp/numeric/complex/dsc real}}
{{dsc end}}

[[de:cpp/numeric/complex/imag]]
[[es:cpp/numeric/complex/imag]]
[[fr:cpp/numeric/complex/imag]]
[[it:cpp/numeric/complex/imag]]
[[ja:cpp/numeric/complex/imag]]
[[pt:cpp/numeric/complex/imag]]
[[ru:cpp/numeric/complex/imag]]
[[zh:cpp/numeric/complex/imag]]</text>
      <sha1>mzquttty9dai4b7kxubrcm8tm6pr6no</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/imag2</title>
    <ns>0</ns>
    <id>8522</id>
    <revision>
      <id>71602</id>
      <parentid>65470</parentid>
      <timestamp>2014-06-14T22:08:26Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C documentation, -link to real</comment>
      <text xml:space="preserve" bytes="1427">{{cpp/title|imag{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
template&lt; class T &gt; 
T imag( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=1 | since=c++14 | 1=
template&lt; class T &gt; 
constexpr T imag( const complex&lt;T&gt;&amp; z );
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 | 1=
long double imag( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrIngeter &gt;
double imag( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
float imag( float z );
}}
{{dcl end}}

Returns the imaginary component of the complex number {{tt|z}}, i.e. {{c|z.imag()}}.

{{rev inl|since=c++11|Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.}}

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the imaginary component of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc imag}}
{{dsc inc | cpp/numeric/complex/dsc real2}}
{{dsc see c | c/numeric/complex/cimag}}
{{dsc end}}

[[de:cpp/numeric/complex/imag2]]
[[es:cpp/numeric/complex/imag2]]
[[fr:cpp/numeric/complex/imag2]]
[[it:cpp/numeric/complex/imag2]]
[[ja:cpp/numeric/complex/imag2]]
[[pt:cpp/numeric/complex/imag2]]
[[ru:cpp/numeric/complex/imag2]]
[[zh:cpp/numeric/complex/imag2]]</text>
      <sha1>231be0n6m22muz18gfnb2g73wgrgyc2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/log</title>
    <ns>0</ns>
    <id>4068</id>
    <revision>
      <id>70896</id>
      <parentid>70879</parentid>
      <timestamp>2014-05-31T21:00:15Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="918">{{cpp/title|log{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; log( const complex&lt;T&gt;&amp; z );
}}

Computes complex natural (base ''e'') logarithm of a complex value {{tt|z}} with a branch cut along the negative real axis.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex natural logarithm of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc log10}}
{{dsc inc | cpp/numeric/complex/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc see c | c/numeric/complex/clog}}
{{dsc end}}

[[de:cpp/numeric/complex/log]]
[[es:cpp/numeric/complex/log]]
[[fr:cpp/numeric/complex/log]]
[[it:cpp/numeric/complex/log]]
[[ja:cpp/numeric/complex/log]]
[[pt:cpp/numeric/complex/log]]
[[ru:cpp/numeric/complex/log]]
[[zh:cpp/numeric/complex/log]]</text>
      <sha1>mdrzlspmurh1oz68kz9qyo2sp16rnn9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/log10</title>
    <ns>0</ns>
    <id>4069</id>
    <revision>
      <id>70897</id>
      <parentid>70880</parentid>
      <timestamp>2014-05-31T21:01:18Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="860">{{cpp/title|log10{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; log10( const complex&lt;T&gt;&amp; z );
}}

Computes complex common (base {{c|10}}) logarithm of a complex value {{tt|z}} with a branch cut along the negative real axis.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex common logarithm of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/valarray/dsc log10}}
{{dsc end}}

[[de:cpp/numeric/complex/log10]]
[[es:cpp/numeric/complex/log10]]
[[fr:cpp/numeric/complex/log10]]
[[it:cpp/numeric/complex/log10]]
[[ja:cpp/numeric/complex/log10]]
[[pt:cpp/numeric/complex/log10]]
[[ru:cpp/numeric/complex/log10]]
[[zh:cpp/numeric/complex/log10]]</text>
      <sha1>q7coao2k4qm45owphhpu4ncj8f6ckyj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/norm</title>
    <ns>0</ns>
    <id>8525</id>
    <revision>
      <id>69895</id>
      <parentid>62805</parentid>
      <timestamp>2014-05-01T10:50:03Z</timestamp>
      <contributor>
        <ip>31.182.134.185</ip>
      </contributor>
      <comment>Fixed typo (DoubleOrIngeter to DoubleOrInteger).</comment>
      <text xml:space="preserve" bytes="1246">{{cpp/title|norm{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | 1=
template&lt; class T &gt; 
T norm( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=2 | since=c++11 | 1=
long double norm( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrInteger &gt;
double norm( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
float norm( float z );
}}
{{dcl end}}

Returns the squared magnitude of the complex number {{tt|z}}.

{{mark since c++11}}Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the squared magnitude of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc conj}}
{{dsc inc | cpp/numeric/complex/dsc polar}}
{{dsc end}}

[[de:cpp/numeric/complex/norm]]
[[es:cpp/numeric/complex/norm]]
[[fr:cpp/numeric/complex/norm]]
[[it:cpp/numeric/complex/norm]]
[[ja:cpp/numeric/complex/norm]]
[[pt:cpp/numeric/complex/norm]]
[[ru:cpp/numeric/complex/norm]]
[[zh:cpp/numeric/complex/norm]]</text>
      <sha1>92swwotvpuz173h4x83yrvl3ue5p4ks</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator&quot;&quot;i</title>
    <ns>0</ns>
    <id>13555</id>
    <revision>
      <id>72328</id>
      <parentid>71289</parentid>
      <timestamp>2014-08-09T10:58:48Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>match the declarations with the explanations, Possible implementation</comment>
      <text xml:space="preserve" bytes="3439">{{cpp/title|n=literals::complex_literals::|operator&quot;&quot;i, operator&quot;&quot;if, operator&quot;&quot;il }}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | since=c++14 | 1=
constexpr complex&lt;double&gt; operator&quot;&quot;i(long double arg);
constexpr complex&lt;double&gt; operator&quot;&quot;i(unsigned long long arg);
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr complex&lt;float&gt; operator&quot;&quot;if(long double arg);
constexpr complex&lt;float&gt; operator&quot;&quot;if(unsigned long long arg);
}}
{{dcl | num=3 | since=c++14 | 1=
constexpr complex&lt;long double&gt; operator&quot;&quot;il(long double arg);
constexpr complex&lt;long double&gt; operator&quot;&quot;il(unsigned long long arg);
}}
{{dcl end}}

Forms a {{lc|std::complex}} literal representing an imaginary number.

@1@ forms a literal {{c|std::complex&lt;double&gt;}} with the real part zero and imaginary part {{tt|arg}}
@2@ forms a literal {{c|std::complex&lt;float&gt;}} with the real part zero and imaginary part {{tt|arg}}
@3@ forms a literal {{c|std::complex&lt;long double&gt;}} with the real part zero and imaginary part {{tt|arg}}

===Parameters===
{{par begin}}
{{par | arg | the value of the imaginary number}}
{{par end}}

===Return value===
The {{lc|std::complex}} literal with the real part zero and imaginary part {{tt|arg}}

===Notes===
These operators are declared in the namespace {{c|std::literals::complex_literals}}, where both {{tt|literals}} and {{tt|complex_literals}} are inline namespaces. Access to these operators can be gained with {{c|using namespace std::literals}} and {{c|using namespace std::literals::complex_literals}}.

Even though {{c|if}} is a [[cpp/keywords/if|keyword]] in C++, it is a {{spar|ud-suffix}} of the [[cpp/language/user_literal|literal operator]] of the form {{c|operator &quot;&quot;if}} and in the literal expressions such as {{c|1if}} or {{c|1.0if}} because it is not separated by whitespace and is not a standalone token.

===Possible implementation===
{{eq fun
 | 1=
constexpr std::complex&lt;double&gt; operator&quot;&quot;i(unsigned long long d)
{
    return std::complex&lt;double&gt;{0.0, static_cast&lt;double&gt;(d)};
}
constexpr std::complex&lt;double&gt; operator&quot;&quot;i(long double d)
{
    return std::complex&lt;double&gt;{0.0, static_cast&lt;double&gt;(d)};
}
 |2=
constexpr std::complex&lt;float&gt; operator&quot;&quot;if(unsigned long long d)
{
    return std::complex&lt;float&gt;{0.0f, static_cast&lt;float&gt;(d)};
}
constexpr std::complex&lt;float&gt; operator&quot;&quot;if(long double d)
{
    return std::complex&lt;float&gt;{0.0f, static_cast&lt;float&gt;(d)};
}
 |3=
constexpr std::complex&lt;long double&gt; operator&quot;&quot;il(unsigned long long d)
{
    return std::complex&lt;long double&gt;{0.0L, static_cast&lt;long double&gt;(d)};
}
constexpr std::complex&lt;long double&gt; operator&quot;&quot;il(long double d)
{
    return std::complex&lt;long double&gt;{0.0L, d};
}
}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;complex&gt;

int main()
{
    using namespace std::literals::complex_literals;
    std::complex&lt;double&gt; c = 1.0 + 1i;
    std::cout &lt;&lt; &quot;abs&quot; &lt;&lt; c &lt;&lt; &quot; = &quot; &lt;&lt; abs(c) &lt;&lt; '\n';
}
| output=
abs(1,1) = 1.41421
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc complex}}
{{dsc inc | cpp/numeric/complex/dsc operator{{=}}}}
{{dsc see c | c/numeric/complex/I}}
{{dsc end}}

[[de:cpp/numeric/complex/operator&quot;&quot;i]]
[[es:cpp/numeric/complex/operator&quot;&quot;i]]
[[fr:cpp/numeric/complex/operator&quot;&quot;i]]
[[it:cpp/numeric/complex/operator&quot;&quot;i]]
[[ja:cpp/numeric/complex/operator&quot;&quot;i]]
[[pt:cpp/numeric/complex/operator&quot;&quot;i]]
[[ru:cpp/numeric/complex/operator&quot;&quot;i]]
[[zh:cpp/numeric/complex/operator&quot;&quot;i]]</text>
      <sha1>akx93rbzexe9w6cjmu5dhy2xzt10ixf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator=</title>
    <ns>0</ns>
    <id>9939</id>
    <revision>
      <id>71290</id>
      <parentid>50230</parentid>
      <timestamp>2014-06-09T04:19:22Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to constructor and operator&quot;&quot;i</comment>
      <text xml:space="preserve" bytes="756">{{cpp/numeric/complex/title|operator{{=}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
complex&lt;T&gt;&amp; operator=( const T&amp; x );
}}
{{dcl | num=2 | 1=
complex&lt;T&gt;&amp; operator=( const complex&lt;T&gt;&amp; cx );
}}
{{dcl end}}

Assigns new values to the contents.

@1@ Assigns {{tt|x}} to the real part of the complex number. Imaginary part is set to zero.

@2@ Assigns {{tt|cx.real()}} and {{tt|cx.imag()}} to the real and the imaginary parts of the complex number respectively.

===Parameters===
{{par begin}}
{{par | x | value to assign}}
{{par | cx | complex value to assign}}
{{par end}}

===Return value===
{{c|*this}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc complex}}
{{dsc inc | cpp/numeric/dsc operator&quot;&quot;i}}
{{dsc end}}</text>
      <sha1>niyr7j1ca61kui9hh9vhhkp4i8r5wg7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator arith</title>
    <ns>0</ns>
    <id>9940</id>
    <revision>
      <id>67491</id>
      <parentid>58483</parentid>
      <timestamp>2014-02-10T06:38:39Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1402">{{cpp/numeric/complex/title|1=operator+=,-=,*=,/=}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
complex&lt;T&gt;&amp; operator+=( const T&amp; other );
}}
{{dcl | num=2 | 1=
complex&lt;T&gt;&amp; operator+=( const complex&lt;T&gt;&amp; other );
}}
{{dcl | num=3 | 1=
complex&lt;T&gt;&amp; operator-=( const T&amp; other );
}}
{{dcl | num=4 | 1=
complex&lt;T&gt;&amp; operator-=( const complex&lt;T&gt;&amp; other );
}}
{{dcl | num=5 | 1=
complex&lt;T&gt;&amp; operator*=( const T&amp; other );
}}
{{dcl | num=6 | 1=
complex&lt;T&gt;&amp; operator*=( const complex&lt;T&gt;&amp; other );
}}
{{dcl | num=7 | 1=
complex&lt;T&gt;&amp; operator/=( const T&amp; other );
}}
{{dcl | num=8 | 1=
complex&lt;T&gt;&amp; operator/=( const complex&lt;T&gt;&amp; other );
}}
{{dcl end}}

Implements the compound assignment operators for complex arithmetic and for mixed complex/scalar arithmetic. Scalar arguments are treated as complex numbers with the real part equal to the argument and the imaginary part set to zero.

@1-2@ Adds {{tt|other}} to {{c|*this}}.
@3-4@ Subtracts {{tt|other}} from {{c|*this}}.
@5-6@ Multiplies {{c|*this}} by {{tt|other}}.
@7-8@ Divides {{c|*this}} by {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | a complex or scalar value of matching type ({{c|float}}, {{c|double}}, {{c|long double}})}}
{{par end}}

===Return value===
{{c|*this}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith2}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc end}}</text>
      <sha1>75exjfjyy38h2j2gyt6joucyt2sgh1p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator arith2</title>
    <ns>0</ns>
    <id>5301</id>
    <revision>
      <id>58484</id>
      <parentid>50232</parentid>
      <timestamp>2013-06-01T06:15:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1133">{{cpp/numeric/complex/title|operator+{{dsc small|(unary)}}, operator-{{dsc small|(unary)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator+( const complex&lt;T&gt;&amp; val );
}}
{{dcl | num=2 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator-( const complex&lt;T&gt;&amp; val );
}}
{{dcl end}}

Implements the analogs of the unary arithmetic operators for complex numbers.
@1@ Returns the value of its argument
@2@ Negates the argument

===Parameters===
{{par begin}}
{{par | val | the complex number argument}}
{{par end}}

===Return value===
@1@ a copy of the argument, {{c|complex&lt;T&gt;(val)}}
@2@ negated argument, {{c|complex&lt;T&gt;(-val.real(), -val.imag())}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith3}}
{{dsc end}}

[[de:cpp/numeric/complex/operator arith2]]
[[es:cpp/numeric/complex/operator arith2]]
[[fr:cpp/numeric/complex/operator arith2]]
[[it:cpp/numeric/complex/operator arith2]]
[[ja:cpp/numeric/complex/operator arith2]]
[[pt:cpp/numeric/complex/operator arith2]]
[[ru:cpp/numeric/complex/operator arith2]]
[[zh:cpp/numeric/complex/operator arith2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator arith3</title>
    <ns>0</ns>
    <id>9265</id>
    <revision>
      <id>67490</id>
      <parentid>58487</parentid>
      <timestamp>2014-02-10T04:53:14Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>title format, as these operators are not member functions</comment>
      <text xml:space="preserve" bytes="3267">{{title|operator+,-,*,/ {{small|(std::complex)}} }}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator+( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=2 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator+( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=3 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator+( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=4 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator-( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=5 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator-( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=6 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator-( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=7 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator*( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=8 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator*( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=9 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator*( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=10 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator/( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=11 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator/( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=12 | 1=
template&lt; class T &gt;
complex&lt;T&gt; operator/( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl end}}

Implements the binary operators for complex arithmetic and for mixed complex/scalar arithmetic. Scalar arguments are treated as complex numbers with the real part equal to the argument and the imaginary part set to zero.

@1-3@ Returns the sum of its arguments
@4-6@ Returns the result of subtracting {{tt|rhs}} from {{tt|lhs}}
@7-9@ Multiplies its arguments
@10-12@ Divides {{tt|lhs}} by {{tt|rhs}}

===Parameters===
{{par begin}}
{{par | lhs, rhs | the arguments: either both complex numbers or one complex and one scalar of matching type ({{c|float}}, {{c|double}}, {{c|long double}})}}
{{par end}}

===Return value===
@1-3@ {{c|1= complex&lt;T&gt;(lhs) += rhs }}
@4-6@ {{c|1= complex&lt;T&gt;(lhs) -= rhs }}
@7-9@ {{c|1= complex&lt;T&gt;(lhs) *= rhs }}
@10-12@ {{c|1= complex&lt;T&gt;(lhs) /= rhs }}

===Example===
{{example | 
 | code=
#include &lt;iostream&gt;
#include &lt;complex&gt;
int main()
{
    std::complex&lt;double&gt; c2(2, 0);
    std::complex&lt;double&gt; ci(0, 1);

    std::cout &lt;&lt; ci &lt;&lt; &quot; + &quot; &lt;&lt; c2 &lt;&lt; &quot; = &quot; &lt;&lt; ci+c2 &lt;&lt; '\n'
              &lt;&lt; ci &lt;&lt; &quot; * &quot; &lt;&lt; ci &lt;&lt; &quot; = &quot; &lt;&lt; ci*ci &lt;&lt; '\n'
              &lt;&lt; ci &lt;&lt; &quot; + &quot; &lt;&lt; c2 &lt;&lt; &quot; / &quot; &lt;&lt; ci &lt;&lt; &quot; = &quot; &lt;&lt; ci+c2/ci &lt;&lt; '\n'
              &lt;&lt; 1  &lt;&lt; &quot; / &quot; &lt;&lt; ci &lt;&lt; &quot; = &quot; &lt;&lt; 1./ci &lt;&lt; '\n';

//    std::cout &lt;&lt; 1.f/ci; // compile error
//    std::cout &lt;&lt; 1/ci; // compile error
}
 | output=
(0,1) + (2,0) = (2,1)
(0,1) * (0,1) = (-1,0)
(0,1) + (2,0) / (0,1) = (0,-1)
1 / (0,1) = (0,-1)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith}}
{{dsc inc | cpp/numeric/complex/dsc operator_arith2}}
{{dsc end}}

[[de:cpp/numeric/complex/operator arith3]]
[[es:cpp/numeric/complex/operator arith3]]
[[fr:cpp/numeric/complex/operator arith3]]
[[it:cpp/numeric/complex/operator arith3]]
[[ja:cpp/numeric/complex/operator arith3]]
[[pt:cpp/numeric/complex/operator arith3]]
[[ru:cpp/numeric/complex/operator arith3]]
[[zh:cpp/numeric/complex/operator arith3]]</text>
      <sha1>dk44fufj2bpz8tn8g2bxnosn02n6abf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator cmp</title>
    <ns>0</ns>
    <id>9941</id>
    <revision>
      <id>64642</id>
      <parentid>64641</parentid>
      <timestamp>2013-08-24T13:18:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>-note</comment>
      <text xml:space="preserve" bytes="2423">{{title|1=operator==,!={{dsc small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
template&lt; class T &gt;
bool operator==( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=1 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator==( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | until=c++14 | 1=
template&lt; class T &gt;
bool operator==( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=2 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator==( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++14 | 1=
template&lt; class T &gt;
bool operator==( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=3 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator==( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=4 | until=c++14 | 1=
template&lt; class T &gt;
bool operator!=( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator!=( const complex&lt;T&gt;&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=5 | until=c++14 | 1=
template&lt; class T &gt;
bool operator!=( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl | num=5 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator!=( const complex&lt;T&gt;&amp; lhs, const T&amp; rhs);
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=6 | until=c++14 | 1=
template&lt; class T &gt;
bool operator!=( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl | num=6 | since=c++14 | 1=
template&lt; class T &gt;
constexpr bool operator!=( const T&amp; lhs, const complex&lt;T&gt;&amp; rhs);
}}
{{dcl rev end}}
{{dcl end}}
Compares two complex numbers. Scalar arguments are treated as complex numbers with the real part equal to the argument and the imaginary part set to zero.

@1-3@ Compares {{tt|lhs}} and {{tt|rhs}} for equality.
@4-6@ Compares {{tt|lhs}} and {{tt|rhs}} for inequality.

===Parameters===
{{par begin}}
{{par | lhs, rhs | the arguments to compare: either both complex numbers or one complex and one scalar of matching type ({{c|float}}, {{c|double}}, {{c|long double}})}}
{{par end}}

===Return value===
@1-3@ {{c|true}} if respective parts of {{tt|lhs}} are equal to {{tt|rhs}}, {{tt|false}} otherwise.
@4-6@ {{c|1=!(lhs == rhs)}}

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/operator ltltgtgt</title>
    <ns>0</ns>
    <id>9616</id>
    <revision>
      <id>63730</id>
      <parentid>50235</parentid>
      <timestamp>2013-07-23T18:14:26Z</timestamp>
      <contributor>
        <ip>79.210.59.110</ip>
      </contributor>
      <comment>corrected os to is in description of 2)</comment>
      <text xml:space="preserve" bytes="1911">{{title|operator&lt;&lt;,&gt;&gt;{{dsc small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 |
template &lt;class T, class CharT, class Traits&gt;
std::basic_ostream&lt;CharT, Traits&gt;&amp; 
    operator&lt;&lt;(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, 
               const std::complex&lt;T&gt;&amp; x);
}}
{{dcl | num=2 |
template &lt;class T, class CharT, class Traits&gt;
std::basic_istream&lt;CharT, Traits&gt;&amp; 
    operator&gt;&gt;(std::basic_istream&lt;CharT, Traits&gt;&amp; is, 
               std::complex&lt;T&gt;&amp; x);
}}
{{dcl end}}

@1@ Writes to {{c|os}} the complex number in the form {{c|(real,imaginary)}}.
@2@ Reads a complex number from {{c|is}}. The supported formats are 
*{{c|real}}
*{{c|(real)}}
*{{c|(real,imaginary)}}
Where the input for {{c|real}} and {{c|imaginary}} must be convertible to {{c|T}}.
If an error occurs calls {{c|is.setstate(ios_base::failbit)}}

===Exceptions===
May throw {{lc|std::ios_base::failure}} on stream errors.

===Parameters===
{{par begin}}
{{par | os | a character output stream}}
{{par | is | a character input stream}}
{{par | x | the complex number to be inserted or extracted}}
{{par end}}

===Return value===
@1@ {{c|os}}

@2@ {{c|is}}

===Notes===
@1@ As the comma may be used in the current locale as decimal separator, the output may be ambiguous. This can be solved with {{lc|std::showpoint}} which forces the decimal separator to be visible.
@2@ The input is performed as a series of simple formatted extractions. Whitespace skipping is the same for each of them.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T, class charT, class traits&gt;
basic_ostream&lt;charT, traits&gt;&amp; 
operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; o, const complex&lt;T&gt;&amp; x) {
    basic_ostringstream&lt;charT, traits&gt; s;
    s.flags(o.flags());
    s.imbue(o.getloc());
    s.precision(o.precision());
    s &lt;&lt; ’(’ &lt;&lt; x.real() &lt;&lt; &quot;,&quot; &lt;&lt; x.imag() &lt;&lt; ’)’;
    return o &lt;&lt; s.str();
}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/polar</title>
    <ns>0</ns>
    <id>8528</id>
    <revision>
      <id>71279</id>
      <parentid>58488</parentid>
      <timestamp>2014-06-09T03:53:39Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link swap</comment>
      <text xml:space="preserve" bytes="826">{{cpp/title|polar{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; polar( const T&amp; r, const T&amp; theta = 0 );
}}

Returns a complex number with magnitude {{tt|r}} and phase angle {{tt|theta}}.

===Parameters===
{{par begin}}
{{par | r | magnitude}}
{{par | theta | phase angle}}
{{par end}}

===Return value===

a complex number determined by {{tt|r}} and {{tt|theta}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc end}}

[[de:cpp/numeric/complex/polar]]
[[es:cpp/numeric/complex/polar]]
[[fr:cpp/numeric/complex/polar]]
[[it:cpp/numeric/complex/polar]]
[[ja:cpp/numeric/complex/polar]]
[[pt:cpp/numeric/complex/polar]]
[[ru:cpp/numeric/complex/polar]]
[[zh:cpp/numeric/complex/polar]]</text>
      <sha1>mazvfhh4xic4j50mtp2z0m75ecqp4wk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/pow</title>
    <ns>0</ns>
    <id>4070</id>
    <revision>
      <id>70893</id>
      <parentid>70881</parentid>
      <timestamp>2014-05-31T20:57:19Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="2160">{{cpp/title|pow{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | 1=
template&lt; class T &gt; 
complex&lt;T&gt; pow( const complex&lt;T&gt;&amp; x, const complex&lt;T&gt;&amp; y);
}}
{{dcl | 1=
template&lt; class T &gt; 
complex&lt;T&gt; pow( const complex&lt;T&gt;&amp; x, const T&amp; y);
}}
{{dcl | 1=
template&lt; class T &gt; 
complex&lt;T&gt; pow( const T&amp; x, const complex&lt;T&gt;&amp; y);
}}
{{dcl | since=c++11 | 1=
template&lt; class T, class U &gt; 
complex&lt;/*Promoted*/&gt; pow( const complex&lt;T&gt;&amp; x, const complex&lt;U&gt;&amp; y);
}}
{{dcl | since=c++11 | 1=
template&lt; class T, class U &gt; 
complex&lt;/*Promoted*/&gt; pow( const complex&lt;T&gt;&amp; x, const U&amp; y);
}}
{{dcl | since=c++11 | 1=
template&lt; class T, class U &gt; 
complex&lt;/*Promoted*/&gt; pow( const T&amp; x, const complex&lt;U&gt;&amp; y);
}}
{{dcl end}}

Computes complex {{tt|x}} raised to a complex power {{tt|y}}. The operation is defined as {{math|exp(''y'' &amp;middot; log(''x'') )}}. A branch cut exists along the negative real axis.

The result of {{c|pow(0, 0)}} is implementation-defined.

{{mark since c++11}}Additional overloads are provided for all arithmetic types, such that
:1. If either argument is {{c|long double}} or {{c|std::complex&lt;long double&gt;}}, then both arguments are cast to {{c|std::complex&lt;long double&gt;}} 
:2. Otherwise, if either argument is {{c|double}}, {{c|std::complex&lt;double&gt;}} or integer type, then both arguments are cast to {{c|std::complex&lt;double&gt;}} 
:3. Otherwise, if either argument is {{c|float}} or {{c|std::complex&lt;float&gt;}}, then both arguments are cast to {{c|std::complex&lt;float&gt;}} 

===Parameters===
{{par begin}}
{{par | x | base as a complex value}}
{{par | y | exponent as a complex value}}
{{par end}}

===Return value===

{{tt|x}} raised to a power {{tt|y}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/valarray/dsc pow}}
{{dsc see c | c/numeric/complex/cpow}}
{{dsc end}}

[[de:cpp/numeric/complex/pow]]
[[es:cpp/numeric/complex/pow]]
[[fr:cpp/numeric/complex/pow]]
[[it:cpp/numeric/complex/pow]]
[[ja:cpp/numeric/complex/pow]]
[[pt:cpp/numeric/complex/pow]]
[[ru:cpp/numeric/complex/pow]]
[[zh:cpp/numeric/complex/pow]]</text>
      <sha1>a3rzetjj77gua78i1cwvs7we0210fdr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/proj</title>
    <ns>0</ns>
    <id>8527</id>
    <revision>
      <id>71703</id>
      <parentid>62807</parentid>
      <timestamp>2014-06-20T20:46:30Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C documentation</comment>
      <text xml:space="preserve" bytes="2174">{{cpp/title|proj{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; proj( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=2 | since=c++11 | 1=
std::complex&lt;long double&gt; proj( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrIngeter &gt;
std::complex&lt;double&gt; proj( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
std::complex&lt;float&gt; proj( float z );
}}
{{dcl end}}

Returns the projection of the complex number {{tt|z}} onto the Riemann sphere.

For most {{tt|z}}, {{c|1=std::proj(z)==z}}, but all complex infinities, even the numbers where one component is infinite and the other is NaN, become positive real infinity, {{c|(INFINITY, 0)}} or {{c|(INFINITY, -0)}}. The sign of the imaginary (zero) component is the sign of {{c|std::imag(z)}}. 

{{mark since c++11}}Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the projection of {{tt|z}} onto the Riemann sphere

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;complex&gt;

int main()
{
    std::complex&lt;double&gt; c1(1, 2);
    std::cout &lt;&lt; &quot;proj&quot; &lt;&lt; c1 &lt;&lt; &quot; = &quot; &lt;&lt; std::proj(c1) &lt;&lt; '\n';

    std::complex&lt;double&gt; c2(INFINITY, -1);
    std::cout &lt;&lt; &quot;proj&quot; &lt;&lt; c2 &lt;&lt; &quot; = &quot; &lt;&lt; std::proj(c2) &lt;&lt; '\n';

    std::complex&lt;double&gt; c3(0, -INFINITY);
    std::cout &lt;&lt; &quot;proj&quot; &lt;&lt; c3 &lt;&lt; &quot; = &quot; &lt;&lt; std::proj(c3) &lt;&lt; '\n';
}
 | output=
proj(1,2) = (1,2)
proj(inf,-1) = (inf,-0)
proj(0,-inf) = (inf,-0)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/complex/dsc norm}}
{{dsc inc | cpp/numeric/complex/dsc polar}}
{{dsc see c | c/numeric/complex/cproj}}
{{dsc end}}

[[de:cpp/numeric/complex/proj]]
[[es:cpp/numeric/complex/proj]]
[[fr:cpp/numeric/complex/proj]]
[[it:cpp/numeric/complex/proj]]
[[ja:cpp/numeric/complex/proj]]
[[pt:cpp/numeric/complex/proj]]
[[ru:cpp/numeric/complex/proj]]
[[zh:cpp/numeric/complex/proj]]</text>
      <sha1>lgv92kbxwp4j2f90h8wkddouq2fpk36</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/real</title>
    <ns>0</ns>
    <id>3546</id>
    <revision>
      <id>71599</id>
      <parentid>64693</parentid>
      <timestamp>2014-06-14T22:01:08Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to real2</comment>
      <text xml:space="preserve" bytes="1963">{{cpp/numeric/complex/title|real}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl h|primary template complex&lt;T&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
T real() const;
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr T real() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void real( T value );
}}
{{dcl h|specialization complex&lt;float&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
float real() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr float real();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr float real() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void real( float value );
}}

{{dcl h|specialization complex&lt;double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
double real() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr double real();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr double real() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void real( double value );
}}

{{dcl h|specialization complex&lt;long double&gt;}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++11 | 1=
long double real() const;
}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
constexpr long double real();
}}
{{dcl | num=1 | since=c++14 | 1=
constexpr long double real() const;
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
void real( long double value );
}}

{{dcl end}}

Accesses the real part of the complex number. 

@1@ Returns the real part.

@2@ Sets the real part to {{tt|value}}.

===Parameters===
{{par begin}}
{{par | value | the value to set the real part to}}
{{par end}}

===Return value===
@1@ The real part.

@2@ (none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc real2}}
{{dsc inc | cpp/numeric/complex/dsc imag}}
{{dsc end}}

[[de:cpp/numeric/complex/real]]
[[es:cpp/numeric/complex/real]]
[[fr:cpp/numeric/complex/real]]
[[it:cpp/numeric/complex/real]]
[[ja:cpp/numeric/complex/real]]
[[pt:cpp/numeric/complex/real]]
[[ru:cpp/numeric/complex/real]]
[[zh:cpp/numeric/complex/real]]</text>
      <sha1>r20ttdkcf4wvzffd9os4z2j3t8krkxn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/real2</title>
    <ns>0</ns>
    <id>8521</id>
    <revision>
      <id>71601</id>
      <parentid>64643</parentid>
      <timestamp>2014-06-14T22:06:54Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to C documentation, -link to imag</comment>
      <text xml:space="preserve" bytes="1417">{{cpp/title|real{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
template&lt; class T &gt; 
T real( const complex&lt;T&gt;&amp; z );
}}
{{dcl | num=1 | since=c++14 | 1=
template&lt; class T &gt; 
constexpr T real( const complex&lt;T&gt;&amp; z );
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 | 1=
long double real( long double z );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class DoubleOrIngeter &gt;
double real( DoubleOrInteger z );
}}
{{dcl | num=4 | since=c++11 | 1=
float real( float z );
}}
{{dcl end}}

Returns the real component of the complex number {{tt|z}}, i.e. {{c|z.real()}}.

{{rev inl|since=c++11|Additional overloads are provided for {{c|float}}, {{c|double}}, {{c|long double}}, and all integer types, which are treated as complex numbers with zero imaginary component.}}

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

the real component of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc real}}
{{dsc inc | cpp/numeric/complex/dsc imag2}}
{{dsc see c | c/numeric/complex/creal}}
{{dsc end}}

[[de:cpp/numeric/complex/real2]]
[[es:cpp/numeric/complex/real2]]
[[fr:cpp/numeric/complex/real2]]
[[it:cpp/numeric/complex/real2]]
[[ja:cpp/numeric/complex/real2]]
[[pt:cpp/numeric/complex/real2]]
[[ru:cpp/numeric/complex/real2]]
[[zh:cpp/numeric/complex/real2]]</text>
      <sha1>mf9fjfdeis0kg0n4g6aaxpbbv5jzuyb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/sin</title>
    <ns>0</ns>
    <id>4074</id>
    <revision>
      <id>70886</id>
      <parentid>70849</parentid>
      <timestamp>2014-05-31T20:38:08Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="874">{{cpp/title|sin{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; sin( const complex&lt;T&gt;&amp; z );
}}

Computes complex sine of a complex value {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex sine of {{tt|z}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc see c | c/numeric/complex/csin}}
{{dsc end}}

[[de:cpp/numeric/complex/sin]]
[[es:cpp/numeric/complex/sin]]
[[fr:cpp/numeric/complex/sin]]
[[it:cpp/numeric/complex/sin]]
[[ja:cpp/numeric/complex/sin]]
[[pt:cpp/numeric/complex/sin]]
[[ru:cpp/numeric/complex/sin]]
[[zh:cpp/numeric/complex/sin]]</text>
      <sha1>av743xz0z3845mhgxbslw63ezqik9g0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/sinh</title>
    <ns>0</ns>
    <id>8515</id>
    <revision>
      <id>70883</id>
      <parentid>70839</parentid>
      <timestamp>2014-05-31T20:33:14Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="926">{{cpp/title|sinh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; sinh( const complex&lt;T&gt;&amp; z );
}}

Computes complex hyperbolic sine of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex hyperbolic sine of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc see c | c/numeric/complex/csinh}}
{{dsc end}}

[[de:cpp/numeric/complex/sinh]]
[[es:cpp/numeric/complex/sinh]]
[[fr:cpp/numeric/complex/sinh]]
[[it:cpp/numeric/complex/sinh]]
[[ja:cpp/numeric/complex/sinh]]
[[pt:cpp/numeric/complex/sinh]]
[[ru:cpp/numeric/complex/sinh]]
[[zh:cpp/numeric/complex/sinh]]</text>
      <sha1>g5v0jd1r0ea53jajw0m66el8gu9nwbe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/sqrt</title>
    <ns>0</ns>
    <id>8514</id>
    <revision>
      <id>70894</id>
      <parentid>70882</parentid>
      <timestamp>2014-05-31T20:58:06Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="1098">{{cpp/title|sqrt{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{dcl begin}}
{{dcl header | complex}}
{{dcl | 1=
template&lt; class T &gt; 
complex&lt;T&gt; sqrt( const complex&lt;T&gt;&amp; x );
}}
{{dcl end}}

Computes the square root of the complex number {{tt|x}}. 

The branch cuts are along the negative real axis.  {{tt|sqrt}} computes the square root in the range of the right half-plane.  If {{tt|x}} is a negative real number, the return value will lie on the positive imaginary axis.

===Parameters===
{{par begin}}
{{par | x | complex number to take the square root of}}
{{par end}}

===Return value===

the square root of {{tt|x}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/valarray/dsc sqrt}}
{{dsc see c | c/numeric/complex/csqrt}}
{{dsc end}}

[[de:cpp/numeric/complex/sqrt]]
[[es:cpp/numeric/complex/sqrt]]
[[fr:cpp/numeric/complex/sqrt]]
[[it:cpp/numeric/complex/sqrt]]
[[ja:cpp/numeric/complex/sqrt]]
[[pt:cpp/numeric/complex/sqrt]]
[[ru:cpp/numeric/complex/sqrt]]
[[zh:cpp/numeric/complex/sqrt]]</text>
      <sha1>mfb3lquagxklrcm610domg2uz8tlkus</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/tan</title>
    <ns>0</ns>
    <id>4076</id>
    <revision>
      <id>70888</id>
      <parentid>70851</parentid>
      <timestamp>2014-05-31T20:39:57Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="880">{{cpp/title|tan{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | 1=
template&lt; class T &gt; 
complex&lt;T&gt; tan( const complex&lt;T&gt;&amp; z );
}}

Computes complex tangent of a complex value {{tt|z}}.

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex tangent of {{tt|z}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc see c | c/numeric/complex/ctan}}
{{dsc end}}

[[de:cpp/numeric/complex/tan]]
[[es:cpp/numeric/complex/tan]]
[[fr:cpp/numeric/complex/tan]]
[[it:cpp/numeric/complex/tan]]
[[ja:cpp/numeric/complex/tan]]
[[pt:cpp/numeric/complex/tan]]
[[ru:cpp/numeric/complex/tan]]
[[zh:cpp/numeric/complex/tan]]</text>
      <sha1>130l430ehzqg1c17dvf4o87qpey53tt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/complex/tanh</title>
    <ns>0</ns>
    <id>8517</id>
    <revision>
      <id>70885</id>
      <parentid>70841</parentid>
      <timestamp>2014-05-31T20:35:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to valarray</comment>
      <text xml:space="preserve" bytes="932">{{cpp/title|tanh{{small|(std::complex)}}}}
{{cpp/numeric/complex/navbar}}
{{ddcl | header=complex | since=c++11 | 1=
template&lt; class T &gt; 
complex&lt;T&gt; tanh( const complex&lt;T&gt;&amp; z );
}}

Computes complex hyperbolic tangent of a complex value {{tt|z}}. 

===Parameters===
{{par begin}}
{{par | z | complex value}}
{{par end}}

===Return value===

Complex hyperbolic tangent of {{tt|z}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc see c | c/numeric/complex/ctanh}}
{{dsc end}}

[[de:cpp/numeric/complex/tanh]]
[[es:cpp/numeric/complex/tanh]]
[[fr:cpp/numeric/complex/tanh]]
[[it:cpp/numeric/complex/tanh]]
[[ja:cpp/numeric/complex/tanh]]
[[pt:cpp/numeric/complex/tanh]]
[[ru:cpp/numeric/complex/tanh]]
[[zh:cpp/numeric/complex/tanh]]</text>
      <sha1>b7hkvs8afy2r3kxziz3yoowv9vf2gdw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv</title>
    <ns>0</ns>
    <id>2710</id>
    <revision>
      <id>58506</id>
      <parentid>50246</parentid>
      <timestamp>2013-06-01T06:16:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3176">{{title|Floating-point environment}}
{{cpp/numeric/fenv/navbar}}

The floating-point environment is the set of floating-point status flags and control modes supported by the implementation. It is thread-local, each thread inherits the initial state of its floating-point environment from the parent thread. Floating-point operations modify the floating-point status flags to indicate abnormal results or auxiliary information. The state of floating-point control modes affects the outcomes of some floating-point operations.

The floating-point environment access and modification is only meaningful when {{ltt|cpp/preprocessor/impl|#pragma STDC FENV_ACCESS}} is set to {{tt|ON}}. Otherwise the implementation is free to assume that floating-point control modes are always the default ones and that floating-point status flags are never tested or modified. In practice, few current compilers support the {{tt|#pragma}} explicitly, but most compilers allow meaningful access to the floating-point environment anyway.

===Types===
{{dsc begin}}
{{dsc header | cfenv}}
{{dsc | {{c|fenv_t}}  | The type representing the entire floating-point environment }}
{{dsc | {{c|fexcept_t}} | The type representing all floating-point status flags collectively }}
{{dsc end}}

===Functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feclearexcept}}
{{dsc inc | cpp/numeric/fenv/dsc fetestexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feraiseexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feexceptflag}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc inc | cpp/numeric/fenv/dsc feenv}}
{{dsc inc | cpp/numeric/fenv/dsc feholdexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feupdateenv}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc FE_exceptions}}
{{dsc inc | cpp/numeric/fenv/dsc FE_round}}
{{dsc inc | cpp/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

===Notes===
The floating-point exceptions are not related to the C++ exceptions. When a floating-point operation raises a floating-point exception, the status of the floating-point environment changes, which can be tested with {{lc|std::fetestexcept}}, but the execution of a C++ program on most implementations continues uninterrupted.

There are compiler extensions that may be used to generate C++ exceptions automatically whenever a floating-point exception is raised:

* GNU libc function {{tt|[http://www.gnu.org/s/hello/manual/libc/Control-Functions.html feenableexcept()]}} enables trapping of the floating-point exceptions, which generates the signal {{tt|SIGFPE}}. If the compiler option {{tt|-fnon-call-exceptions}} was used, the handler for that signal may throw a user-defined C++ exception.
* Microsoft WinAPI function {{tt|[http://msdn.microsoft.com/en-us/library/e9b52ceh.aspx _control87()]}} enables trapping of the floating-point exceptions, which generates a hardware exception, which can be converted to C++ exceptions with {{tt|[http://msdn.microsoft.com/en-us/library/5z4bw5h5.aspx _set_se_translator]}}.

[[de:cpp/numeric/fenv]]
[[es:cpp/numeric/fenv]]
[[fr:cpp/numeric/fenv]]
[[it:cpp/numeric/fenv]]
[[ja:cpp/numeric/fenv]]
[[pt:cpp/numeric/fenv]]
[[ru:cpp/numeric/fenv]]
[[zh:cpp/numeric/fenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE ALL EXCEPT</title>
    <ns>0</ns>
    <id>4314</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15577</id>
      <parentid>15576</parentid>
      <timestamp>2011-12-13T18:03:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE DFL ENV</title>
    <ns>0</ns>
    <id>5260</id>
    <revision>
      <id>62809</id>
      <parentid>58507</parentid>
      <timestamp>2013-07-01T23:41:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2258">{{title|FE_DFL_ENV}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header|cfenv}}
{{dcl | since=c++11 |
#define FE_DFL_ENV  /*implementation defined*/
}}
{{dcl end}}

The macro constant {{lc|FE_DFL_ENV}} expands to an expression of type {{c|const std::fenv_t*}}, which points to a full copy of the default floating-point environment, that is, the environment as loaded at program startup.

Additional macros that begin with {{tt|FE_}} followed by uppercase letters, and have the type {{c|const std::fenv_t*}}, may be supported by an implementation.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON

void show_env()
{
    int e = std::fetestexcept(FE_ALL_EXCEPT);
    if(e &amp; FE_DIVBYZERO) std::cout &lt;&lt; &quot;division by zero is raised\n&quot;;
    if(e &amp; FE_INEXACT)   std::cout &lt;&lt; &quot;inexact is raised\n&quot;;
    if(e &amp; FE_INVALID)   std::cout &lt;&lt; &quot;invalid is raised\n&quot;;
    if(e &amp; FE_UNDERFLOW) std::cout &lt;&lt; &quot;underflow is raised\n&quot;;
    if(e &amp; FE_OVERFLOW)  std::cout &lt;&lt; &quot;overflow is raised\n&quot;;
    int r = std::fegetround();
    switch(r)
    {  
        case FE_DOWNWARD: std::cout &lt;&lt; &quot;rounding down\n&quot;; break;
        case FE_TONEAREST: std::cout &lt;&lt; &quot;rounding to nearest\n&quot;; break;
        case FE_TOWARDZERO: std::cout &lt;&lt; &quot;rounding to zero\n&quot;; break;
        case FE_UPWARD: std::cout &lt;&lt; &quot;rounding up\n&quot;; break;
    }
}

int main()
{
    std::cout &lt;&lt; &quot;On startup: \n&quot;;
    show_env();

    std::feraiseexcept(FE_UNDERFLOW {{!}} FE_OVERFLOW);
    std::fesetround(FE_UPWARD);

    std::cout &lt;&lt; &quot;\nBefore restoration: \n&quot;;
    show_env();

    std::fesetenv(FE_DFL_ENV);

    std::cout &lt;&lt; &quot;\nAfter reset to default: \n&quot;;
    show_env();
}
 | output=
On startup: 
rounding to nearest

Before restoration: 
underflow is raised
overflow is raised
rounding up

After reset to default: 
rounding to nearest
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feenv}}
{{dsc inc | cpp/numeric/fenv/dsc feupdateenv}}
{{dsc end}}

[[de:cpp/numeric/fenv/FE DFL ENV]]
[[es:cpp/numeric/fenv/FE DFL ENV]]
[[fr:cpp/numeric/fenv/FE DFL ENV]]
[[it:cpp/numeric/fenv/FE DFL ENV]]
[[ja:cpp/numeric/fenv/FE DFL ENV]]
[[pt:cpp/numeric/fenv/FE DFL ENV]]
[[ru:cpp/numeric/fenv/FE DFL ENV]]
[[zh:cpp/numeric/fenv/FE DFL ENV]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE DIVBYZERO</title>
    <ns>0</ns>
    <id>4305</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15567</id>
      <timestamp>2011-12-13T18:03:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE DOWNWARD</title>
    <ns>0</ns>
    <id>4310</id>
    <redirect title="cpp/numeric/fenv/FE round" />
    <revision>
      <id>15572</id>
      <timestamp>2011-12-13T18:03:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE round]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/numeric/fenv/FE_round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE INEXACT</title>
    <ns>0</ns>
    <id>4306</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15568</id>
      <timestamp>2011-12-13T18:03:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE INVALID</title>
    <ns>0</ns>
    <id>4307</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15569</id>
      <timestamp>2011-12-13T18:03:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE OVERFLOW</title>
    <ns>0</ns>
    <id>4308</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15570</id>
      <timestamp>2011-12-13T18:03:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE TONEAREST</title>
    <ns>0</ns>
    <id>4311</id>
    <redirect title="cpp/numeric/fenv/FE round" />
    <revision>
      <id>15573</id>
      <timestamp>2011-12-13T18:03:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE round]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/numeric/fenv/FE_round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE TOWARDZERO</title>
    <ns>0</ns>
    <id>4312</id>
    <redirect title="cpp/numeric/fenv/FE round" />
    <revision>
      <id>15574</id>
      <timestamp>2011-12-13T18:03:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE round]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/numeric/fenv/FE_round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE UNDERFLOW</title>
    <ns>0</ns>
    <id>4309</id>
    <redirect title="cpp/numeric/fenv/FE exceptions" />
    <revision>
      <id>15571</id>
      <timestamp>2011-12-13T18:03:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE exceptions]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/numeric/fenv/FE_exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE UPWARD</title>
    <ns>0</ns>
    <id>4313</id>
    <redirect title="cpp/numeric/fenv/FE round" />
    <revision>
      <id>15575</id>
      <timestamp>2011-12-13T18:03:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/FE round]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/numeric/fenv/FE_round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE exceptions</title>
    <ns>0</ns>
    <id>4319</id>
    <revision>
      <id>70180</id>
      <parentid>70179</parentid>
      <timestamp>2014-05-11T15:57:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to c</comment>
      <text xml:space="preserve" bytes="2748">{{title|&lt;small&gt;FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW, FE_UNDERFLOW, FE_ALL_EXCEPT&lt;/small&gt;}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header|cfenv}}
{{dcl | since=c++11 |
#define FE_DIVBYZERO    /*implementation defined power of 2*/
}}
{{dcl | since=c++11 |
#define FE_INEXACT      /*implementation defined power of 2*/
}}
{{dcl | since=c++11 |
#define FE_INVALID      /*implementation defined power of 2*/
}}
{{dcl | since=c++11 |
#define FE_OVERFLOW     /*implementation defined power of 2*/
}}
{{dcl | since=c++11 |
#define FE_UNDERFLOW    /*implementation defined power of 2*/
}}
{{dcl | since=c++11 |
#define FE_ALL_EXCEPT  FE_DIVBYZERO {{!}} FE_INEXACT {{!}} \
                       FE_INVALID {{!}} FE_OVERFLOW {{!}}  \
                       FE_UNDERFLOW
}}
{{dcl end}}

All these macro constants (except {{lc|FE_ALL_EXCEPT}}) expand to integer constant expressions that are distinct powers of 2, which uniquely identify all supported floating-point exceptions. Each macro is only defined if it is supported. 

The macro constant {{lc|FE_ALL_EXCEPT}}, which expands to the bitwise OR of all other {{tt|FE_*}}, is always defined and is zero if floating-point exceptions are not supported by the implementation.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FE_DIVBYZERO}} | pole error occurred in an earlier floating-point operation}}
{{dsc | {{tt|FE_INEXACT}}   | inexact result: rounding was necessary to store the result of an earlier floating-point operation}}
{{dsc | {{tt|FE_INVALID}}   | domain error occurred in an earlier floating-point operation}}
{{dsc | {{tt|FE_OVERFLOW}}  | the result of the earlier floating-point operation was too large to be representable}}
{{dsc | {{tt|FE_UNDERFLOW}} | the result of the earlier floating-point operation was subnormal with a loss of precision}}
{{dsc | {{tt|FE_ALL_EXCEPT}} | bitwise OR of all supported floating-point exceptions}}
{{dsc end}}

The implementation may define additional macro constants in {{tt|&lt;cfenv&gt;}} to identify additional floating-point exceptions. All such constants begin with {{tt|FE_}} followed by at least one uppercase letter.

See {{lc|math_errhandling}} for further details.

===Example===
{{include| cpp/numeric/fenv/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc math_errhandling}}
{{dsc see c | c/numeric/fenv/FE_exceptions | floating point exception macros | nomono=true}}
{{dsc end}}

[[de:cpp/numeric/fenv/FE exceptions]]
[[es:cpp/numeric/fenv/FE exceptions]]
[[fr:cpp/numeric/fenv/FE exceptions]]
[[it:cpp/numeric/fenv/FE exceptions]]
[[ja:cpp/numeric/fenv/FE exceptions]]
[[pt:cpp/numeric/fenv/FE exceptions]]
[[ru:cpp/numeric/fenv/FE exceptions]]
[[zh:cpp/numeric/fenv/FE exceptions]]</text>
      <sha1>nthtxq2h1vb4pys96c5vrtonus6totx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/FE round</title>
    <ns>0</ns>
    <id>5602</id>
    <revision>
      <id>72046</id>
      <parentid>69400</parentid>
      <timestamp>2014-07-10T03:09:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+rounding effects, more varied example (this isn't the nearbyint page)</comment>
      <text xml:space="preserve" bytes="4451">{{title|&lt;small&gt;FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO, FE_UPWARD&lt;/small&gt;}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header|cfenv}}
{{dcl | since=c++11 |
#define FE_DOWNWARD     /*implementation defined*/
}} 
{{dcl | since=c++11 |
#define FE_TONEAREST    /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FE_TOWARDZERO   /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FE_UPWARD       /*implementation defined*/
}}
{{dcl end}}

Each of these macro constants expands to a nonnegative integer constant expression, which can be used with {{lc|std::fesetround}} and {{lc|std::fegetround}} to indicate one of the supported floating-point rounding modes. The implementation may define additional rounding mode constants in {{tt|&lt;cfenv&gt;}}, which should all begin with {{tt|FE_}} followed by at least one uppercase letter. Each macro is only defined if it is supported.

On most implementations, these macro constants expand to the values equal to the values of {{lc|FLT_ROUNDS}} and {{lc|std::float_round_style}}

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FE_DOWNWARD}}  | rounding towards negative infinity}}
{{dsc | {{tt|FE_TONEAREST}} | rounding towards nearest integer}}
{{dsc | {{tt|FE_TOWARDZERO}} | rounding towards zero}}
{{dsc | {{tt|FE_UPWARD}}  | rounding towards positive infinity}}
{{dsc end}}

Additional rounding modes may be supported by an implementation.

The current rounding mode affects the following:
* results of floating-point [[cpp/language/operator_arithmetic|arithmetic operators]] outside of constant expressions
{{source|1=
double x = 1;
x/10; // 0.09999999999999999167332731531132594682276248931884765625
   // or 0.1000000000000000055511151231257827021181583404541015625
}}
* results of standard library [[cpp/numeric/math|mathematical functions]]
{{source|1=
std::sqrt(2); // 1.41421356237309492343001693370752036571502685546875
           // or 1.4142135623730951454746218587388284504413604736328125
}}
* floating-point to floating-point implicit conversion and casts
{{source|1=
double d = 1 + std::numeric_limits&lt;double&gt;::epsilon();
float f = d; //  1.00000000000000000000000
           // or 1.00000011920928955078125
}}
* string conversions such as {{lc|std::strtod}} or {{lc|std::printf}}
{{source|1=
std::stof(&quot;0.1&quot;); // 0.0999999940395355224609375
               // or 0.100000001490116119384765625
}}
* the library rounding functions {{lc|std::nearbyint}}, {{lc|std::rint}}, {{lc|std::lrint}}
{{source|1=
std::lrint(2.1); // 2 or 3
}}
The current rounding mode does NOT affect the following:
* floating-point to integer implicit conversion and casts (always towards zero)
* results of floating-point arithmetic operators in constant expressions (always to nearest)
* the library functions {{lc|std::round}}, {{lc|std::lround}}, {{lc|std::ceil}}, {{lc|std::floor}}, {{lc|std::trunc}}

As with any [[cpp/numeric/fenv|floating-point environment]] functionality, rounding is only guaranteed if {{tt|#pragma STDC FENV_ACCESS ON}} is set.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;cfenv&gt;
#include &lt;cmath&gt;
int main()
{
#pragma STDC FENV_ACCESS ON
    std::fesetround(FE_DOWNWARD);
    std::cout &lt;&lt; &quot;rounding down: \n&quot; &lt;&lt; std::setprecision(50)
              &lt;&lt; &quot;         pi = &quot; &lt;&lt; std::acos(-1.f) &lt;&lt; '\n'
              &lt;&lt; &quot;stof(\&quot;1.1\&quot;) = &quot; &lt;&lt; std::stof(&quot;1.1&quot;) &lt;&lt; '\n'
              &lt;&lt; &quot;  rint(2.1) = &quot; &lt;&lt; std::rint(2.3) &lt;&lt; &quot;\n\n&quot;;
    std::fesetround(FE_UPWARD);
    std::cout &lt;&lt; &quot;rounding up: \n&quot;
              &lt;&lt; &quot;         pi = &quot; &lt;&lt; std::acos(-1.f) &lt;&lt; '\n'
              &lt;&lt; &quot;stof(\&quot;1.1\&quot;) = &quot; &lt;&lt; std::stof(&quot;1.1&quot;) &lt;&lt; '\n'
              &lt;&lt; &quot;  rint(2.1) = &quot; &lt;&lt; std::rint(2.3) &lt;&lt; '\n';
}
|output=
rounding down: 
         pi = 3.141592502593994140625
stof(&quot;1.1&quot;) = 1.099999904632568359375
  rint(2.1) = 2

rounding up: 
         pi = 3.1415927410125732421875
stof(&quot;1.1&quot;) = 1.10000002384185791015625
  rint(2.1) = 3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc float_round_style}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc see c | c/numeric/fenv/FE_round | floating-point rounding macros | nomono=true}}
{{dsc end}}

[[de:cpp/numeric/fenv/FE round]]
[[es:cpp/numeric/fenv/FE round]]
[[fr:cpp/numeric/fenv/FE round]]
[[it:cpp/numeric/fenv/FE round]]
[[ja:cpp/numeric/fenv/FE round]]
[[pt:cpp/numeric/fenv/FE round]]
[[ru:cpp/numeric/fenv/FE round]]
[[zh:cpp/numeric/fenv/FE round]]</text>
      <sha1>6wjckz3xl2bm74fv6ayog5fqfu3u43q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feclearexcept</title>
    <ns>0</ns>
    <id>5252</id>
    <revision>
      <id>62812</id>
      <parentid>58512</parentid>
      <timestamp>2013-07-01T23:41:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1070">{{cpp/title|feclearexcept}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 |
int feclearexcept( int excepts );
}}
{{dcl end}}

Attempts to clear the floating-point exceptions that are listed in the bitmask argument {{tt|excepts}}, which is a bitwise OR of the [[cpp/numeric/fenv/FE_exceptions|floating point exception macros]].

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to clear}}
{{par end}}

===Return value===
{{c|0}} if all indicated exceptions were successfully cleared or if {{tt|excepts}} is zero. Returns a non-zero value on error.

===Example===
{{include| cpp/numeric/fenv/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc fetestexcept}}
{{dsc end}}

[[de:cpp/numeric/fenv/feclearexcept]]
[[es:cpp/numeric/fenv/feclearexcept]]
[[fr:cpp/numeric/fenv/feclearexcept]]
[[it:cpp/numeric/fenv/feclearexcept]]
[[ja:cpp/numeric/fenv/feclearexcept]]
[[pt:cpp/numeric/fenv/feclearexcept]]
[[ru:cpp/numeric/fenv/feclearexcept]]
[[zh:cpp/numeric/fenv/feclearexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feenv</title>
    <ns>0</ns>
    <id>5604</id>
    <revision>
      <id>62813</id>
      <parentid>62401</parentid>
      <timestamp>2013-07-01T23:41:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1571">{{cpp/title|fegetenv|fesetenv}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 | num=1|
int fegetenv( std::fenv_t* envp )
}}
{{dcl | since=c++11 | num=2|
int fesetenv( const std::fenv_t* envp );
}}
{{dcl end}}

Manages the status of the floating-point environment.

@1@ Attempts to store the status of the floating-point environment in the object pointed to by {{tt|envp}}.

@2@ Attempts to establish the floating-point environment from the object pointed to by {{tt|envp}}. The value of that object must be previously obtained by a call to {{lc|std::feholdexcept}} or {{tt|std::fegetenv}} or be a floating-point macro constant. If any of the floating-point status flags are set in {{tt|envp}}, they become set in the environment (and are then testable with {{lc|std::fetestexcept}}), but the corresponding floating-point exceptions are not raised (execution continues uninterrupted)

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|std::fenv_t}} which holds the status of the floating-point environment}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feholdexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feupdateenv}}
{{dsc inc | cpp/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

[[de:cpp/numeric/fenv/feenv]]
[[es:cpp/numeric/fenv/feenv]]
[[fr:cpp/numeric/fenv/feenv]]
[[it:cpp/numeric/fenv/feenv]]
[[ja:cpp/numeric/fenv/feenv]]
[[pt:cpp/numeric/fenv/feenv]]
[[ru:cpp/numeric/fenv/feenv]]
[[zh:cpp/numeric/fenv/feenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feexceptflag</title>
    <ns>0</ns>
    <id>5253</id>
    <revision>
      <id>62814</id>
      <parentid>50252</parentid>
      <timestamp>2013-07-01T23:41:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1715">{{cpp/title|fegetexceptflag|fesetexceptflag}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 | num=1|
int fegetexceptflag( std::fexcept_t* flagp, int excepts );
}}
{{dcl | since=c++11 | num=2|
int fesetexceptflag( const std::fexcept_t* flagp, int excepts );
}}
{{dcl end}}

1) Attempts to obtain the full contents of the floating-point exception flags that are listed in the bitmask argument {{tt|excepts}}, which is a bitwise OR of the [[cpp/numeric/fenv/FE_exceptions|floating point exception macros]]. 

2) Attempts to copy the full contents of the floating-point exception flags that are listed in {{tt|excepts}} from {{tt|flagp}} into the floating-point environment. Does not raise any exceptions, only modifies the flags.

The full contents of a floating-point exception flag is not necessarily a boolean value indicating whether the exception is raised or cleared. For example, it may be a struct which includes the boolean status and the address of the code that triggered the exception. These functions obtain all such content and obtain/store it in {{tt|flagp}} in implementation-defined format.

===Parameters===
{{par begin}}
{{par | flagp | pointer to an {{c|std::fexcept_t}} object where the flags will be stored or read from}}
{{par | excepts | bitmask listing the exception flags to get/set}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

[[de:cpp/numeric/fenv/feexceptflag]]
[[es:cpp/numeric/fenv/feexceptflag]]
[[fr:cpp/numeric/fenv/feexceptflag]]
[[it:cpp/numeric/fenv/feexceptflag]]
[[ja:cpp/numeric/fenv/feexceptflag]]
[[pt:cpp/numeric/fenv/feexceptflag]]
[[ru:cpp/numeric/fenv/feexceptflag]]
[[zh:cpp/numeric/fenv/feexceptflag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fegetenv</title>
    <ns>0</ns>
    <id>5595</id>
    <redirect title="cpp/numeric/fenv/feenv" />
    <revision>
      <id>20627</id>
      <timestamp>2012-03-28T17:37:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/feenv]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/fenv/feenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fegetexceptflag</title>
    <ns>0</ns>
    <id>5590</id>
    <redirect title="cpp/numeric/fenv/feexceptflag" />
    <revision>
      <id>20621</id>
      <timestamp>2012-03-28T17:35:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/numeric/fenv/fegetexceptflag]] to [[cpp/numeric/fenv/feexceptflag]]: better title</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/numeric/fenv/feexceptflag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fegetround</title>
    <ns>0</ns>
    <id>5593</id>
    <redirect title="cpp/numeric/fenv/feround" />
    <revision>
      <id>20625</id>
      <timestamp>2012-03-28T17:37:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/feround]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/fenv/feround]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feholdexcept</title>
    <ns>0</ns>
    <id>5606</id>
    <revision>
      <id>62815</id>
      <parentid>58516</parentid>
      <timestamp>2013-07-01T23:41:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1574">{{cpp/title|feholdexcept}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 |
int feholdexcept( std::fenv_t* envp )
}}
{{dcl end}}

First, saves the current floating-point environment to the object pointed to by {{tt|envp}} (similar to {{lc|std::fegetenv}}), then clears all floating-point status flags, and then installs the non-stop mode: future floating-point exceptions will not interrupt execution (will not trap), until the floating-point environment is restored by {{lc|std::feupdateenv}} or {{lc|std::fesetenv}}.

This function may be used in the beginning of a subroutine that must hide the floating-point exceptions it may raise from the caller. If only some exceptions must be suppressed, while others must be reported, the non-stop mode is usually ended with a call to {{lc|std::feupdateenv}} after clearing the unwanted exceptions.

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|std::fenv_t}} where the floating-point environment will be stored}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feupdateenv}}
{{dsc inc | cpp/numeric/fenv/dsc feenv}}
{{dsc inc | cpp/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

[[de:cpp/numeric/fenv/feholdexcept]]
[[es:cpp/numeric/fenv/feholdexcept]]
[[fr:cpp/numeric/fenv/feholdexcept]]
[[it:cpp/numeric/fenv/feholdexcept]]
[[ja:cpp/numeric/fenv/feholdexcept]]
[[pt:cpp/numeric/fenv/feholdexcept]]
[[ru:cpp/numeric/fenv/feholdexcept]]
[[zh:cpp/numeric/fenv/feholdexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feraiseexcept</title>
    <ns>0</ns>
    <id>5259</id>
    <revision>
      <id>62816</id>
      <parentid>58519</parentid>
      <timestamp>2013-07-01T23:41:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2118">{{cpp/title|feraiseexcept}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 |
int feraiseexcept( int excepts );
}}
{{dcl end}}

Attempts to raise all floating point exceptions listed in {{tt|excepts}} (a bitwise OR of the [[cpp/numeric/fenv/FE_exceptions|floating point exception macros]]). If one of the exceptions is {{lc|FE_OVERFLOW}} or {{c|FE_UNDERFLOW}}, this function may additionally raise {{lc|FE_INEXACT}}. The order in which the exceptions are raised is unspecified, except that {{lc|FE_OVERFLOW}} and {{c|FE_UNDERFLOW}} are always raised before {{lc|FE_INEXACT}}.

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to raise}}
{{par end}}

===Return value===
{{c|0}} if all listed exceptions were raised, non-zero value otherwise.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON

int main()
{
    std::feclearexcept(FE_ALL_EXCEPT);
    int r = std::feraiseexcept(FE_UNDERFLOW {{!}} FE_DIVBYZERO);
    std::cout &lt;&lt;  &quot;Raising divbyzero and underflow simultaneously &quot;
              &lt;&lt; (r?&quot;fails&quot;:&quot;succeeds&quot;) &lt;&lt; &quot; and results in\n&quot;;
    int e = std::fetestexcept(FE_ALL_EXCEPT);
    if (e &amp; FE_DIVBYZERO) {
        std::cout &lt;&lt; &quot;division by zero\n&quot;;
    }
    if (e &amp; FE_INEXACT) {
        std::cout &lt;&lt; &quot;inexact\n&quot;;
    }
    if (e &amp; FE_INVALID) {
        std::cout &lt;&lt; &quot;invalid\n&quot;;
    }
    if (e &amp; FE_UNDERFLOW) {
        std::cout &lt;&lt; &quot;underflow\n&quot;;
    }
    if (e &amp; FE_OVERFLOW) {
        std::cout &lt;&lt; &quot;overflow\n&quot;;
    }
}
 | output=
Raising divbyzero and underflow simultaneously succeeds and results in
division by zero
underflow
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feclearexcept}}
{{dsc inc | cpp/numeric/fenv/dsc fetestexcept}}
{{dsc end}}

[[de:cpp/numeric/fenv/feraiseexcept]]
[[es:cpp/numeric/fenv/feraiseexcept]]
[[fr:cpp/numeric/fenv/feraiseexcept]]
[[it:cpp/numeric/fenv/feraiseexcept]]
[[ja:cpp/numeric/fenv/feraiseexcept]]
[[pt:cpp/numeric/fenv/feraiseexcept]]
[[ru:cpp/numeric/fenv/feraiseexcept]]
[[zh:cpp/numeric/fenv/feraiseexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feround</title>
    <ns>0</ns>
    <id>5601</id>
    <revision>
      <id>72048</id>
      <parentid>71775</parentid>
      <timestamp>2014-07-10T03:10:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to FE_round</comment>
      <text xml:space="preserve" bytes="1679">{{cpp/title|fegetround|fesetround}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 | num=1|
int fesetround( int round )
}}
{{dcl | since=c++11 | num=2|
int fegetround()
}}
{{dcl end}}

Manages the floating-point rounding direction. 

@1@ Attempts to establish the floating-point rounding direction equal to the argument {{tt|round}}, which is expected to be one of the [[cpp/numeric/fenv/FE_round|floating point rounding macros]]. 

@2@ Returns the value of the [[cpp/numeric/fenv/FE_round|floating point rounding macro]] that corresponds to the current rounding direction. 

===Parameters===
{{par begin}}
{{par | round | rounding direction, one of [[cpp/numeric/fenv/FE_round|floating point rounding macros]]}}
{{par end}}

===Return value===
1) {{c|0}} on success, non-zero otherwise.

2) the [[cpp/numeric/fenv/FE_round|floating point rounding macro]] describing the current rounding direction or a negative value if the direction cannot be determined

===Notes===
The current rounding mode, reflecting the effects of the most recent {{tt|fesetround}}, can also be queried with {{lc|FLT_ROUNDS}}

See [[cpp/numeric/fenv/FE_round|floating-point rounding macros]] for the effects of rounding.

===Example===
{{include| cpp/numeric/math/example_nearbyint}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
{{dsc inc | cpp/numeric/math/dsc rint}}
{{dsc end}}

[[de:cpp/numeric/fenv/feround]]
[[es:cpp/numeric/fenv/feround]]
[[fr:cpp/numeric/fenv/feround]]
[[it:cpp/numeric/fenv/feround]]
[[ja:cpp/numeric/fenv/feround]]
[[pt:cpp/numeric/fenv/feround]]
[[ru:cpp/numeric/fenv/feround]]
[[zh:cpp/numeric/fenv/feround]]</text>
      <sha1>q6l9l35y1aczs9x8rkgmaafbjbyq94p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fesetenv</title>
    <ns>0</ns>
    <id>5594</id>
    <redirect title="cpp/numeric/fenv/feenv" />
    <revision>
      <id>20626</id>
      <timestamp>2012-03-28T17:37:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/feenv]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/fenv/feenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fesetexceptflag</title>
    <ns>0</ns>
    <id>5591</id>
    <redirect title="cpp/numeric/fenv/feexceptflag" />
    <revision>
      <id>20623</id>
      <parentid>20622</parentid>
      <timestamp>2012-03-28T17:36:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/feexceptflag]]</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/numeric/fenv/feexceptflag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fesetround</title>
    <ns>0</ns>
    <id>5592</id>
    <redirect title="cpp/numeric/fenv/feround" />
    <revision>
      <id>20624</id>
      <timestamp>2012-03-28T17:37:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/fenv/feround]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/fenv/feround]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/fetestexcept</title>
    <ns>0</ns>
    <id>5251</id>
    <revision>
      <id>62818</id>
      <parentid>58523</parentid>
      <timestamp>2013-07-01T23:42:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1094">{{cpp/title|fetestexcept}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 |
int fetestexcept( int excepts );
}}
{{dcl end}}

Determines which of the specified subset of the floating point exceptions are currently set. The argument {{tt|excepts}} is a bitwise OR of the [[cpp/numeric/fenv/FE_exceptions|floating point exception macros]].

===Parameters===
{{par begin}}
{{par | excepts | bitmask listing the exception flags to test}}
{{par end}}

===Return value===
Bitwise OR of the floating-point exception macros that are both included in {{tt|excepts}} and correspond to floating-point exceptions currently set.

===Example===
{{include| cpp/numeric/fenv/example1}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feclearexcept}}
{{dsc end}}

[[de:cpp/numeric/fenv/fetestexcept]]
[[es:cpp/numeric/fenv/fetestexcept]]
[[fr:cpp/numeric/fenv/fetestexcept]]
[[it:cpp/numeric/fenv/fetestexcept]]
[[ja:cpp/numeric/fenv/fetestexcept]]
[[pt:cpp/numeric/fenv/fetestexcept]]
[[ru:cpp/numeric/fenv/fetestexcept]]
[[zh:cpp/numeric/fenv/fetestexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/fenv/feupdateenv</title>
    <ns>0</ns>
    <id>5605</id>
    <revision>
      <id>62819</id>
      <parentid>58524</parentid>
      <timestamp>2013-07-01T23:42:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1270">{{cpp/title|feupdatedenv}}
{{cpp/numeric/fenv/navbar}}
{{dcl begin}}
{{dcl header | cfenv}}
{{dcl | since=c++11 |
int feupdateenv( const std::fenv_t* envp )
}}
{{dcl end}}

First, remembers the currently raised floating-point exceptions, then restores the floating-point environment from the object pointed to by {{tt|envp}} (similar to {{lc|std::fesetenv}}), then raises the floating-point exceptions that were saved.

This function may be used to end the non-stop mode established by an earlier call to {{lc|std::feholdexcept}}.

===Parameters===
{{par begin}}
{{par | envp | pointer to the object of type {{c|std::fenv_t}} set by an earlier call to {{lc|std::feholdexcept}} or {{tt|std::fegetenv}} or equal to {{lc|FE_DFL_ENV}}}}
{{par end}}

===Return value===
{{c|0}} on success, non-zero otherwise.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc feholdexcept}}
{{dsc inc | cpp/numeric/fenv/dsc feenv}}
{{dsc inc | cpp/numeric/fenv/dsc FE_DFL_ENV}}
{{dsc end}}

[[de:cpp/numeric/fenv/feupdateenv]]
[[es:cpp/numeric/fenv/feupdateenv]]
[[fr:cpp/numeric/fenv/feupdateenv]]
[[it:cpp/numeric/fenv/feupdateenv]]
[[ja:cpp/numeric/fenv/feupdateenv]]
[[pt:cpp/numeric/fenv/feupdateenv]]
[[ru:cpp/numeric/fenv/feupdateenv]]
[[zh:cpp/numeric/fenv/feupdateenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math</title>
    <ns>0</ns>
    <id>1333</id>
    <revision>
      <id>71890</id>
      <parentid>71825</parentid>
      <timestamp>2014-07-01T03:56:41Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>Use new templates</comment>
      <text xml:space="preserve" bytes="4401">{{title|Common mathematical functions}}
{{cpp/numeric/math/navbar}}

===Functions===
{{dsc begin}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc div}}

{{dsc header | cinttypes}}
{{dsc inc | cpp/numeric/math/dsc imaxabs}}
{{dsc inc | cpp/numeric/math/dsc imaxdiv}}

{{dsc header | cmath}}
{{dsc h2 | Basic operations}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/math/dsc fmod}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc inc | cpp/numeric/math/dsc fma}}
{{dsc inc | cpp/numeric/math/dsc fmax}}
{{dsc inc | cpp/numeric/math/dsc fmin}}
{{dsc inc | cpp/numeric/math/dsc fdim}}
{{dsc inc | cpp/numeric/math/dsc fnan}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc exp2}}
{{dsc inc | cpp/numeric/math/dsc expm1}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc inc | cpp/numeric/math/dsc log1p}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc cbrt}}
{{dsc inc | cpp/numeric/math/dsc hypot}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc atan2}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}

{{dsc h2 | Error and gamma functions}}
{{dsc inc | cpp/numeric/math/dsc erf}}
{{dsc inc | cpp/numeric/math/dsc erfc}}
{{dsc inc | cpp/numeric/math/dsc tgamma}}
{{dsc inc | cpp/numeric/math/dsc lgamma}}

{{dsc h2 | Nearest integer floating point operations}}
{{dsc inc | cpp/numeric/math/dsc ceil}}
{{dsc inc | cpp/numeric/math/dsc floor}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
{{dsc inc | cpp/numeric/math/dsc rint}}

{{dsc h2 | Floating point manipulation functions}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc ldexp}}
{{dsc inc | cpp/numeric/math/dsc modf}}
{{dsc inc | cpp/numeric/math/dsc scalbn}}
{{dsc inc | cpp/numeric/math/dsc ilogb}}
{{dsc inc | cpp/numeric/math/dsc logb}}
{{dsc inc | cpp/numeric/math/dsc nextafter}}
{{dsc inc | cpp/numeric/math/dsc copysign}}

{{dsc h2 | Classification and comparison}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc inc | cpp/numeric/math/dsc signbit}}

{{dsc inc | cpp/numeric/math/dsc isgreater}}
{{dsc inc | cpp/numeric/math/dsc isgreaterequal}}
{{dsc inc | cpp/numeric/math/dsc isless}}
{{dsc inc | cpp/numeric/math/dsc islessequal}}
{{dsc inc | cpp/numeric/math/dsc islessgreater}}
{{dsc inc | cpp/numeric/math/dsc isunordered}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | cstdlib }}
{{dsc inc | cpp/numeric/math/dsc div_t}}
{{dsc inc | cpp/numeric/math/dsc ldiv_t}}
{{dsc inc | cpp/numeric/math/dsc lldiv_t}}
{{dsc header | cinttypes }}
{{dsc inc | cpp/numeric/math/dsc imaxdiv_t}}
{{dsc header | cmath }}
{{dsc inc | cpp/numeric/math/dsc float_t}}
{{dsc inc | cpp/numeric/math/dsc double_t}}
{{dsc end}}

===Macro constants===
{{dsc begin}}
{{dsc header | cmath}}
{{dsc inc | cpp/numeric/math/dsc HUGE_VAL}}}
{{dsc inc | cpp/numeric/math/dsc INFINITY}}}
{{dsc inc | cpp/numeric/math/dsc NAN}}}
{{dsc inc | cpp/numeric/math/dsc math_errhandling}}
{{dsc h2 | Classification}}
{{dsc inc | cpp/numeric/math/dsc FP_categories}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/numeric/math | Common mathematical functions}}
{{dsc end}}

[[cs:cpp/numeric/math]]
[[de:cpp/numeric/math]]
[[es:cpp/numeric/math]]
[[fr:cpp/numeric/math]]
[[it:cpp/numeric/math]]
[[ja:cpp/numeric/math]]
[[pl:cpp/numeric/math]]
[[pt:cpp/numeric/math]]
[[ru:cpp/numeric/math]]
[[tr:cpp/numeric/math]]
[[zh:cpp/numeric/math]]</text>
      <sha1>ebm6z2d8qeoh0tfdj5c50s4k8fgxmu7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FLT EVAL METHOD</title>
    <ns>0</ns>
    <id>9517</id>
    <redirect title="cpp/types/climits/FLT EVAL METHOD" />
    <revision>
      <id>40403</id>
      <timestamp>2012-10-13T08:20:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/numeric/math/FLT EVAL METHOD]] to [[cpp/types/climits/FLT EVAL METHOD]]: already declared there</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/types/climits/FLT EVAL METHOD]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FLT ROUNDS</title>
    <ns>0</ns>
    <id>9519</id>
    <redirect title="cpp/types/climits/FLT ROUNDS" />
    <revision>
      <id>40407</id>
      <timestamp>2012-10-13T08:22:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/numeric/math/FLT ROUNDS]] to [[cpp/types/climits/FLT ROUNDS]]: already declared there</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/types/climits/FLT ROUNDS]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP INFINITE</title>
    <ns>0</ns>
    <id>1334</id>
    <redirect title="cpp/numeric/math/FP categories" />
    <revision>
      <id>13795</id>
      <parentid>8060</parentid>
      <timestamp>2011-11-12T14:53:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/FP categories]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/numeric/math/FP_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP NAN</title>
    <ns>0</ns>
    <id>1335</id>
    <redirect title="cpp/numeric/math/FP categories" />
    <revision>
      <id>13796</id>
      <parentid>8059</parentid>
      <timestamp>2011-11-12T14:53:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/FP categories]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/numeric/math/FP_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP NORMAL</title>
    <ns>0</ns>
    <id>1336</id>
    <redirect title="cpp/numeric/math/FP categories" />
    <revision>
      <id>13799</id>
      <parentid>8061</parentid>
      <timestamp>2011-11-12T14:53:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/FP categories]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/numeric/math/FP_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP SUBNORMAL</title>
    <ns>0</ns>
    <id>1337</id>
    <redirect title="cpp/numeric/math/FP categories" />
    <revision>
      <id>13797</id>
      <parentid>8062</parentid>
      <timestamp>2011-11-12T14:53:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/FP categories]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/numeric/math/FP_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP ZERO</title>
    <ns>0</ns>
    <id>1338</id>
    <redirect title="cpp/numeric/math/FP categories" />
    <revision>
      <id>13798</id>
      <parentid>8063</parentid>
      <timestamp>2011-11-12T14:53:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/FP categories]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/numeric/math/FP_categories]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/FP categories</title>
    <ns>0</ns>
    <id>3688</id>
    <revision>
      <id>70413</id>
      <parentid>70402</parentid>
      <timestamp>2014-05-22T02:42:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>-misleading example</comment>
      <text xml:space="preserve" bytes="1775">{{title|FP_NORMAL, FP_SUBNORMAL, FP_ZERO, FP_INFINITE, FP_NAN}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
#define FP_NORMAL    /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FP_SUBNORMAL /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FP_ZERO      /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FP_INFINITE  /*implementation defined*/
}}
{{dcl | since=c++11 |
#define FP_NAN       /*implementation defined*/
}}
{{dcl end}}

The {{tt|FP_NORMAL}}, {{tt|FP_SUBNORMAL}}, {{tt|FP_ZERO}}, {{tt|FP_INFINITE}}, {{tt|FP_NAN}} macros each represent a distinct category of floating-point numbers. They all expand to an integer constant expression.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|FP_NORMAL}} | indicates that the value is ''normal'', i.e. not an infinity, subnormal, not-a-number or zero}}
{{dsc | {{tt|FP_SUBNORMAL}} | indicates that the value is ''subnormal''}}
{{dsc | {{tt|FP_ZERO}} | indicates that the value is positive or negative zero}}
{{dsc | {{tt|FP_INFINITE}} | indicates that the value is not representable by the underlying type (positive or negative infinity)}}
{{dsc | {{tt|FP_NAN}} | indicates that the value is not-a-number (NaN)}}
{{dsc end}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc see c | c/numeric/math/FP_categories | ntitle=floating point number categories}}
{{dsc end}}

[[de:cpp/numeric/math/FP categories]]
[[es:cpp/numeric/math/FP categories]]
[[fr:cpp/numeric/math/FP categories]]
[[it:cpp/numeric/math/FP categories]]
[[ja:cpp/numeric/math/FP categories]]
[[pt:cpp/numeric/math/FP categories]]
[[ru:cpp/numeric/math/FP categories]]
[[zh:cpp/numeric/math/FP categories]]</text>
      <sha1>mt0tgpuqbu8uh27g9q8kr1v9faghwrb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/HUGE VAL</title>
    <ns>0</ns>
    <id>1339</id>
    <revision>
      <id>70382</id>
      <parentid>70377</parentid>
      <timestamp>2014-05-21T14:53:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link error handling</comment>
      <text xml:space="preserve" bytes="1614">{{title|HUGE_VALF|HUGE_VAL|HUGE_VALL}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
#define HUGE_VALF /*implementation defined*/
}}
{{dcl |
#define HUGE_VAL  /*implementation defined*/
}}
{{dcl | since=c++11 |
#define HUGE_VALL /*implementation defined*/
}}
{{dcl end}}

The {{tt|HUGE_VALF}}, {{tt|HUGE_VAL}} and {{tt|HUGE_VALL}} macros expand to positive floating point constant expressions which compare equal to the values returned by floating-point functions and operators in case of overflow (see {{lc|math_errhandling}}).

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|HUGE_VALF}} | Expands to positive {{c|float}} expression that indicates overflow}}
{{dsc | {{tt|HUGE_VAL}} | Expands to positive {{c|double}} expression that indicates overflow, not necessarily representable as a {{c|float}}}}
{{dsc | {{tt|HUGE_VALL}} | Expands to positive {{c|long double}} expression that indicates overflow, not necessarily representable as a {{c|float}} or {{c|double}}}}
{{dsc end}}

On implementations that support floating-point infinities, these macros always expand to the positive infinities of {{c|float}}, {{c|double}}, and {{c|long double}}, respectively.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc INFINITY}}}
{{dsc see c | c/numeric/math/HUGE_VAL}}
{{dsc end}}

[[de:cpp/numeric/math/HUGE VAL]]
[[es:cpp/numeric/math/HUGE VAL]]
[[fr:cpp/numeric/math/HUGE VAL]]
[[it:cpp/numeric/math/HUGE VAL]]
[[ja:cpp/numeric/math/HUGE VAL]]
[[pt:cpp/numeric/math/HUGE VAL]]
[[ru:cpp/numeric/math/HUGE VAL]]
[[zh:cpp/numeric/math/HUGE VAL]]</text>
      <sha1>oujx1rkjjeoigldmb6qxs5jjiwno6w6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/HUGE VALF</title>
    <ns>0</ns>
    <id>1340</id>
    <redirect title="cpp/numeric/math/HUGE VAL" />
    <revision>
      <id>13785</id>
      <parentid>12091</parentid>
      <timestamp>2011-11-12T12:44:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/HUGE VAL]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/numeric/math/HUGE_VAL]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/HUGE VALL</title>
    <ns>0</ns>
    <id>1341</id>
    <redirect title="cpp/numeric/math/HUGE VAL" />
    <revision>
      <id>13786</id>
      <parentid>12092</parentid>
      <timestamp>2011-11-12T12:45:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/HUGE VAL]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/numeric/math/HUGE_VAL]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/INFINITY</title>
    <ns>0</ns>
    <id>8463</id>
    <revision>
      <id>70544</id>
      <parentid>70384</parentid>
      <timestamp>2014-05-24T22:48:20Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to has_infinity</comment>
      <text xml:space="preserve" bytes="1130">{{title|INFINITY}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
#define INFINITY /*implementation defined*/
}}
{{dcl end}}

If the implementation supports floating-point infinities, the macro {{tt|INFINITY}} expands to constant expression of type {{c|float}} which evaluates to positive or unsigned infinity.

If the implementation does not support floating-point infinities, the macro {{tt|INFINITY}} expands to a positive value that is guaranteed to overflow a {{c|float}} at compile time, and the use of this macro generates a compiler warning.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc HUGE_VAL}}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc infinity}}
{{dsc see c | c/numeric/math/INFINITY}}
{{dsc end}}

[[de:cpp/numeric/math/INFINITY]]
[[es:cpp/numeric/math/INFINITY]]
[[fr:cpp/numeric/math/INFINITY]]
[[it:cpp/numeric/math/INFINITY]]
[[ja:cpp/numeric/math/INFINITY]]
[[pt:cpp/numeric/math/INFINITY]]
[[ru:cpp/numeric/math/INFINITY]]
[[zh:cpp/numeric/math/INFINITY]]</text>
      <sha1>2cnfjt8ydrfk9a8t0h0mbn99tq8afhq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/M PI</title>
    <ns>0</ns>
    <id>9614</id>
    <revision>
      <id>58532</id>
      <parentid>50262</parentid>
      <timestamp>2013-06-01T06:16:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1809">{{title|M_PI}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | A collection of useful of irrational numbers: |}}
{{dcl | notes= |
#define M_PI	   /* pi ~ 3.14159265358979323846 implementation defined*/
}}{{dcl | notes= |
#define M_PI_2	   /* pi / 2 ~ 1.570796326794896619231 implementation defined*/
}}{{dcl | notes= |
#define M_PI_4	   /* pi / 4 ~ 0.785398163397448309616 implementation defined*/
}}{{dcl | notes= |
#define M_1_PI	   /* 1 / pi ~ 0.318309886183790671538 implementation defined*/
}}{{dcl | notes= |
#define M_2_PI	   /* 2 / pi ~ 0.636619772367581343076 implementation defined*/
}}{{dcl | notes= |
#define M_E	   /* e ~ 2.718281828459045235360 implementation defined*/
}}{{dcl | notes= |
#define M_LN2	   /* loge(2) ~ 0.69314718055994530942 implementation defined*/
}}{{dcl | notes= |
#define M_LN10	   /* loge(10) ~ 2.30258509299404568402 implementation defined*/
}}{{dcl | notes= |
#define M_SQRT2	   /* sqrt(2) ~ 1.41421356237309504880 implementation defined*/
}}{{dcl | notes= |
#define M_LOG10E   /* log10(e) ~ 0.434294481903251827651 implementation defined*/
}}{{dcl | notes= |
#define M_LOG2E	   /* log2(pi) ~ 1.442695040888963407 implementation defined*/
}}{{dcl | notes= |
#define M_2_SQRTPI /* 2 8 sqrt(pi) ~ 1.12837916709551257390 implementation defined*/
}}
{{dcl end}}

The macro {{tt|M_PI}} expands to constant expression of type {{c|double}} which evaluates to the nearest floating point representation to the irrational number &amp;pi;. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet NaN}}
{{dsc end}}

[[de:cpp/numeric/math/NAN]]
[[es:cpp/numeric/math/NAN]]
[[fr:cpp/numeric/math/NAN]]
[[it:cpp/numeric/math/NAN]]
[[ja:cpp/numeric/math/NAN]]
[[pt:cpp/numeric/math/NAN]]
[[ru:cpp/numeric/math/NAN]]
[[zh:cpp/numeric/math/NAN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/NAN</title>
    <ns>0</ns>
    <id>8464</id>
    <revision>
      <id>70542</id>
      <parentid>70373</parentid>
      <timestamp>2014-05-24T22:41:52Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ NAN related links</comment>
      <text xml:space="preserve" bytes="976">{{title|NAN}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
#define NAN /*implementation defined*/
}}
{{dcl end}}

The macro {{tt|NAN}} expands to constant expression of type {{c|float}} which evaluates to a quiet not-a-number (QNaN) value. If the implementation does not support QNaNs, this macro constant is not defined. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fnan}}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc signaling_NaN}}
{{dsc see c | c/numeric/math/NAN}}
{{dsc end}}

[[de:cpp/numeric/math/NAN]]
[[es:cpp/numeric/math/NAN]]
[[fr:cpp/numeric/math/NAN]]
[[it:cpp/numeric/math/NAN]]
[[ja:cpp/numeric/math/NAN]]
[[pt:cpp/numeric/math/NAN]]
[[ru:cpp/numeric/math/NAN]]
[[zh:cpp/numeric/math/NAN]]</text>
      <sha1>j3if9ss3z3v9xxdjovh80veyrvpjhki</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/abs</title>
    <ns>0</ns>
    <id>1342</id>
    <revision>
      <id>71224</id>
      <parentid>64931</parentid>
      <timestamp>2014-06-08T18:32:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, example</comment>
      <text xml:space="preserve" bytes="1905">{{cpp/title|abs{{small|(int)}}|labs|llabs|imaxabs}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl |
int       abs( int n );
}}
{{dcl |
long      abs( long n );
}}
{{dcl | since=c++11 |
long long abs( long long n );
}}
{{dcl |
long       labs( long n );
}}
{{dcl | since=c++11 |
long long llabs( long long n );
}}
{{dcl header | cinttypes}}
{{dcl | since=c++11 |
std::intmax_t abs( std::intmax_t n );
}}
{{dcl | since=c++11 |
std::intmax_t imaxabs( std::intmax_t n );
}}
{{dcl end}}

Computes the absolute value of an integer number. The behavior is undefined if the result cannot be represented by the return type.

===Parameters===
{{par begin}}
{{par | n | integer value}}
{{par end}}

===Return value===
The absolute value of {{tt|n}} (i.e. {{tt|{{!}}n{{!}}}}), if it is representable.

===Notes===
In 2's complement systems, the absolute value of the most-negative value is out of range, e.g. for 32-bit 2's complement type int, INT_MIN is -2147483648, but the would-be result 2147483648 is greater than INT_MAX, which is 2147483647.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
#include &lt;climits&gt;

int main()
{
    std::cout &lt;&lt; &quot;abs(+3) = &quot; &lt;&lt; std::abs(3) &lt;&lt; '\n'
              &lt;&lt; &quot;abs(-3) = &quot; &lt;&lt; std::abs(-3) &lt;&lt; '\n';

//  std::cout &lt;&lt; abs(INT_MIN)); // undefined behavior on 2's complement systems
}
 | output=
abs(+3) = 3
abs(-3) = 3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/valarray/dsc abs}}
{{dsc see c | c/numeric/math/abs | abs | labs | llabs}}
{{dsc end}}

[[de:cpp/numeric/math/abs]]
[[es:cpp/numeric/math/abs]]
[[fr:cpp/numeric/math/abs]]
[[it:cpp/numeric/math/abs]]
[[ja:cpp/numeric/math/abs]]
[[pl:cpp/numeric/math/abs]]
[[pt:cpp/numeric/math/abs]]
[[ru:cpp/numeric/math/abs]]
[[tr:cpp/numeric/math/abs]]
[[zh:cpp/numeric/math/abs]]</text>
      <sha1>gd2r0922kqr95zjz7wiv9yxj5a1leq2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/acos</title>
    <ns>0</ns>
    <id>1343</id>
    <revision>
      <id>70519</id>
      <parentid>68805</parentid>
      <timestamp>2014-05-24T20:53:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+details</comment>
      <text xml:space="preserve" bytes="3013">{{cpp/title|acos}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       acos( float arg );
}}
{{dcl |num=2|
double      acos( double arg );
}}
{{dcl |num=3|
long double acos( long double arg );
}}
{{dcl |num=4|since=c++11 |
double      acos( Integral arg );
}}
{{dcl end}}

Computes the principal value of the arc cosine of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the arc cosine of {{tt|arg}} ({{math|arccos(arg)}}) in the range {{math|[0 ; &amp;pi;]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is outside the range {{tt|[-1.0; 1.0]}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is {{math|+1}}, the value {{tt|+0}} is returned.
* If {{math|{{!}}arg{{!}} &gt; 1}}, a domain error occurs and NaN is returned.
* if the argument is NaN, NaN is returned

===Example===
{{example
 | code=
#include &lt;cmath&gt;
#include &lt;iostream&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;acos(-1) = &quot; &lt;&lt; acos(-1) &lt;&lt; '\n'
              &lt;&lt; &quot;acos(0.0) = &quot; &lt;&lt; acos(0.0) &lt;&lt; &quot; 2*acos(0.0) = &quot; &lt;&lt; 2*acos(0) &lt;&lt; '\n'
              &lt;&lt; &quot;acos(0.5) = &quot; &lt;&lt; acos(0.5) &lt;&lt; &quot; 3*acos(0.5) = &quot; &lt;&lt; 3*acos(0.5) &lt;&lt; '\n'
              &lt;&lt; &quot;acos(1) = &quot; &lt;&lt; acos(1) &lt;&lt; '\n';
    // error handling 
    errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;acos(1.1) = &quot; &lt;&lt; acos(1.1) &lt;&lt; '\n';
    if(errno == EDOM)
        std::cout &lt;&lt; &quot;    errno == EDOM: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised&quot; &lt;&lt; '\n';
}
 | output=
acos(-1) = 3.14159
acos(0.0) = 1.5708 2*acos(0.0) = 3.14159
acos(0.5) = 1.0472 3*acos(0.5) = 3.14159
acos(1) = 0
acos(1.1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc atan2}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc see c | c/numeric/math/acos}}
{{dsc end}}

[[de:cpp/numeric/math/acos]]
[[es:cpp/numeric/math/acos]]
[[fr:cpp/numeric/math/acos]]
[[it:cpp/numeric/math/acos]]
[[ja:cpp/numeric/math/acos]]
[[pl:cpp/numeric/math/acos]]
[[pt:cpp/numeric/math/acos]]
[[ru:cpp/numeric/math/acos]]
[[zh:cpp/numeric/math/acos]]</text>
      <sha1>5hm6rgv2wzkhwsn4wr8wi9gj4x04fmg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/acosh</title>
    <ns>0</ns>
    <id>1344</id>
    <revision>
      <id>70597</id>
      <parentid>67144</parentid>
      <timestamp>2014-05-26T06:02:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+return, example, naming note</comment>
      <text xml:space="preserve" bytes="3406">{{cpp/title|acosh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float       acosh( float arg );
}}
{{dcl | since=c++11 | num=2|
double      acosh( double arg );
}}
{{dcl | since=c++11 | num=3|
long double acosh( long double arg );
}}
{{dcl | since=c++11 | num=4|
double      acosh( Integral arg );
}}
{{dcl end}}

Computes the inverse hyperbolic cosine of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic cosine of {{tt|arg}} ({{math|cosh{{su|p=-1}}(arg)}}, or {{math|arcosh(arg)}}) on the interval {{math|[0, +∞]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the argument is less than 1, a domain error occurs.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is less than 1, {{lc|FE_INVALID}} is raised an NaN is returned
* if the argument is 1, +0 is returned
* if the argument is +∞, +∞ is returned
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard (to which C++ refers for this function) names this function &quot;arc hyperbolic cosine&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic cosine&quot; (used by POSIX) or &quot;area hyperbolic cosine&quot;.

===Examples===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfloat&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;acosh(1) = &quot; &lt;&lt; std::acosh(1) &lt;&lt; '\n'
              &lt;&lt; &quot;acosh(10) = &quot; &lt;&lt; std::acosh(10) &lt;&lt; '\n'
              &lt;&lt; &quot;acosh(DBL_MAX) = &quot; &lt;&lt; std::acosh(DBL_MAX) &lt;&lt; '\n'
              &lt;&lt; &quot;acosh(Inf) = &quot; &lt;&lt;  std::acosh(INFINITY) &lt;&lt; '\n';
     // error handling 
     errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
     std::cout &lt;&lt; &quot;acosh(0.5) = &quot; &lt;&lt; std::acosh(0.5) &lt;&lt; '\n';
     if(errno == EDOM)
         std::cout &lt;&lt; &quot;    errno == EDOM: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
     if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
acosh(1) = 0
acosh(10) = 2.99322
acosh(DBL_MAX) = 710.476
acosh(Inf) = inf
acosh(0.5) = -nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc acosh}}
{{dsc see c | c/numeric/math/acosh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicCosine.html Weisstein, Eric W. &quot;Inverse Hyperbolic Cosine.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/acosh]]
[[es:cpp/numeric/math/acosh]]
[[fr:cpp/numeric/math/acosh]]
[[it:cpp/numeric/math/acosh]]
[[ja:cpp/numeric/math/acosh]]
[[pt:cpp/numeric/math/acosh]]
[[ru:cpp/numeric/math/acosh]]
[[zh:cpp/numeric/math/acosh]]</text>
      <sha1>n36z6070vr0rei3hpd0axu7urh61k1m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/asin</title>
    <ns>0</ns>
    <id>1345</id>
    <revision>
      <id>71098</id>
      <parentid>70517</parentid>
      <timestamp>2014-06-05T20:52:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>-</comment>
      <text xml:space="preserve" bytes="3079">{{cpp/title|asin}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       asin( float arg );
}}
{{dcl |num=2|
double      asin( double arg );
}}
{{dcl |num=3|
long double asin( long double arg );
}}
{{dcl |num=4| since=c++11 |
double      asin( Integral arg );
}}
{{dcl end}}

Computes the principal value of the arc sine of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the arc sine of {{tt|arg}} ({{math|arcsin(arg)}}) in the range {{math|[-{{mfrac|&amp;pi;|2}} ; +{{mfrac|&amp;pi;|2}}]}}, is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is outside the range {{tt|[-1.0; 1.0]}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If {{math|{{!}}arg{{!}} &gt; 1}}, a domain error occurs and NaN is returned.
* if the argument is NaN, NaN is returned

===Example===
{{example|code=
#include &lt;cmath&gt;
#include &lt;iostream&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;asin(1.0) = &quot; &lt;&lt; asin(1) &lt;&lt; '\n'
              &lt;&lt; &quot;2*asin(1.0) = &quot; &lt;&lt; 2*asin(1) &lt;&lt; '\n'
              &lt;&lt; &quot;asin(-0.5) = &quot; &lt;&lt; asin(-0.5) &lt;&lt; '\n'
              &lt;&lt; &quot;6*asin(-0.5) =&quot; &lt;&lt; 6*asin(-0.5) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;asin(0.0) = &quot; &lt;&lt; asin(0) &lt;&lt; &quot; asin(-0.0)=&quot; &lt;&lt; asin(-0.0) &lt;&lt; '\n';
    // error handling 
    errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;asin(1.1) = &quot; &lt;&lt; asin(1.1) &lt;&lt; '\n';
    if(errno == EDOM)
        std::cout &lt;&lt; &quot;    errno == EDOM: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised&quot; &lt;&lt; '\n';
}
|p=true
|output=
asin(1.0) = 1.5708
2*asin(1.0) = 3.14159
asin(-0.5) = -0.523599
6*asin(-0.5) = -3.14159
asin(0.0) = 0 asin(-0.0)=-0
asin(1.1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc atan2}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc see c | c/numeric/math/asin}}
{{dsc end}}

[[de:cpp/numeric/math/asin]]
[[es:cpp/numeric/math/asin]]
[[fr:cpp/numeric/math/asin]]
[[it:cpp/numeric/math/asin]]
[[ja:cpp/numeric/math/asin]]
[[pl:cpp/numeric/math/asin]]
[[pt:cpp/numeric/math/asin]]
[[ru:cpp/numeric/math/asin]]
[[zh:cpp/numeric/math/asin]]</text>
      <sha1>pe37s6ia8a1a7yeqlx3cmsvy1x1ciqy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/asinh</title>
    <ns>0</ns>
    <id>1346</id>
    <revision>
      <id>70595</id>
      <parentid>70568</parentid>
      <timestamp>2014-05-26T05:47:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2684">{{cpp/title|asinh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
float       asinh( float arg );
}}
{{dcl | since=c++11 | num=2 |
double      asinh( double arg );
}}
{{dcl | since=c++11 | num=3 |
long double asinh( long double arg );
}}
{{dcl | since=c++11 | num=4 |
double      asinh( Integral arg );
}}
{{dcl end}}

Computes the inverse hyperbolic sine of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic sine of {{tt|arg}} ({{math|sinh{{su|p=-1}}(arg)}}, or {{math|arsinh(arg)}}), is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned unmodified
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard (to which C++ refers for this function) names this function &quot;arc hyperbolic sine&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic sine&quot; (used by POSIX) or &quot;area hyperbolic sine&quot;.

===Examples===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;asinh(1) = &quot; &lt;&lt; std::asinh(1) &lt;&lt; '\n'
              &lt;&lt; &quot;asinh(-1) = &quot; &lt;&lt; std::asinh(-1) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;asinh(+0) = &quot; &lt;&lt; std::asinh(+0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;asinh(-0) = &quot; &lt;&lt;  std::asinh(-0.0) &lt;&lt; '\n';
}
|output=
asinh(1) = 0.881374
asinh(-1) = -0.881374
asinh(+0) = 0
asinh(-0) = -0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc asinh}}
{{dsc see c | c/numeric/math/asinh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicSine.html Weisstein, Eric W. &quot;Inverse Hyperbolic Sine.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/asinh]]
[[es:cpp/numeric/math/asinh]]
[[fr:cpp/numeric/math/asinh]]
[[it:cpp/numeric/math/asinh]]
[[ja:cpp/numeric/math/asinh]]
[[pt:cpp/numeric/math/asinh]]
[[ru:cpp/numeric/math/asinh]]
[[zh:cpp/numeric/math/asinh]]</text>
      <sha1>tdb3d5jtxvqhxd8egmtzppupst6iawq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/atan</title>
    <ns>0</ns>
    <id>1347</id>
    <revision>
      <id>71593</id>
      <parentid>70892</parentid>
      <timestamp>2014-06-14T04:48:28Z</timestamp>
      <contributor>
        <ip>68.106.218.183</ip>
      </contributor>
      <comment>Arg is not limited to the range [-1.0; 1.0]</comment>
      <text xml:space="preserve" bytes="2725">{{cpp/title|atan}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       atan( float arg );
}}
{{dcl |num=2|
double      atan( double arg );
}}
{{dcl |num=3|
long double atan( long double arg );
}}
{{dcl |num=4|since=c++11 |
double      atan( Integral arg );
}}
{{dcl end}}

Computes the principal value of the arc tangent of {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the arc tangent of {{tt|arg}} ({{math|arctan(arg)}}) in the range {{math|[-{{mfrac|&amp;pi;|2}} ; +{{mfrac|&amp;pi;|2}}]}} radians, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If the argument is +∞, +&amp;pi;/2 is returned
* If the argument is -∞, -&amp;pi;/2 is returned
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atan.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Examples===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;atan(1) = &quot; &lt;&lt; atan(1) &lt;&lt; &quot; 4*atan(1) = &quot; &lt;&lt; 4*atan(1) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;atan(Inf) = &quot; &lt;&lt; atan(INFINITY)
              &lt;&lt; &quot; 2*atan(Inf) = &quot; &lt;&lt; 2*atan(INFINITY) &lt;&lt; '\n'
              &lt;&lt; &quot;atan(-0.0) = &quot; &lt;&lt; atan(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;atan(+0.0) = &quot; &lt;&lt; atan(0) &lt;&lt; '\n';
}
|output=
atan(1) = 0.785398 4*atan(1) = 3.14159
atan(Inf) = 1.5708 2*atan(Inf) = 3.14159
atan(-0.0) = -0
atan(+0.0) = 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc atan2}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc see c | c/numeric/math/atan}}
{{dsc end}}

[[de:cpp/numeric/math/atan]]
[[es:cpp/numeric/math/atan]]
[[fr:cpp/numeric/math/atan]]
[[it:cpp/numeric/math/atan]]
[[ja:cpp/numeric/math/atan]]
[[pl:cpp/numeric/math/atan]]
[[pt:cpp/numeric/math/atan]]
[[ru:cpp/numeric/math/atan]]
[[zh:cpp/numeric/math/atan]]</text>
      <sha1>dfa2xzj6z2qzn854r7bipt9x0b3mzyv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/atan2</title>
    <ns>0</ns>
    <id>1348</id>
    <revision>
      <id>71265</id>
      <parentid>70547</parentid>
      <timestamp>2014-06-09T03:11:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to asin, acos and atan2(std::valarray), -link to tan and hypot</comment>
      <text xml:space="preserve" bytes="5066">{{cpp/title|atan2}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num = 1 |
float       atan2( float y, float x );
}}
{{dcl | num = 2 |
double      atan2( double y, double x );
}}
{{dcl | num = 3 |
long double atan2( long double y, long double x );
}}
{{dcl | num = 4 | since=c++11 |
Promoted    atan2( Arithmetic1 y, Arithmetic2 x );
}}
{{dcl end}}

Computes the arc tangent of {{tt|y/x}} using the signs of arguments to determine the correct quadrant.
@4@ A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any argument is {{c|long double}}, then the return type {{tt|Promoted}} is also {{c|long double}}, otherwise the return type is always {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If no errors occur, the arc tangent of {{tt|y/x}} ({{math|arctan({{mfrac|y|x}})}}) in the range {{math|[-&amp;pi; ; +&amp;pi;]}} radians, is returned.

{{plot | math-atan2.png | left=Y argument | bottom=X argument | right=Return value | size=x240px}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|x}} and {{tt|y}} are both zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|x}} and {{tt|y}} are both zero, domain error ''does not'' occur
* If {{tt|x}} and {{tt|y}} are both zero, range error does not occur either
* If {{tt|y}} is zero, pole error does not occur
* If {{tt|y}} is {{tt|±0}} and {{tt|x}} is negative or {{tt|-0}}, {{tt|±&amp;pi;}} is returned
* If {{tt|y}} is {{tt|±0}} and {{tt|x}} is negative or {{tt|+0}}, {{tt|±0}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is finite, {{tt|±&amp;pi;/2}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is {{tt|-∞}}, {{tt|±3&amp;pi;/4}} is returned
* If {{tt|y}} is {{tt|±∞}} and {{tt|x}} is {{tt|+∞}}, {{tt|±&amp;pi;/4}} is returned
* If {{tt|x}} is {{tt|±0}} and {{tt|y}} is negative, {{tt|-&amp;pi;/2}} is returned
* If {{tt|x}} is {{tt|±0}} and {{tt|y}} is positive, {{tt|+&amp;pi;/2}} is returned
* If {{tt|x}} is {{tt|-∞}} and {{tt|y}} is finite and positive, {{tt|+&amp;pi;}} is returned
* If {{tt|x}} is {{tt|-∞}} and {{tt|y}} is finite and negative, {{tt|-&amp;pi;}} is returned
* If {{tt|x}} is {{tt|+∞}} and {{tt|y}} is finite and positive, {{tt|+0}} is returned
* If {{tt|x}} is {{tt|+∞}} and {{tt|y}} is finite and negative, {{tt|-0}} is returned
* If either {{tt|x}} is NaN or {{tt|y}} is NaN, NaN is returned

===Notes===
{{c|std::atan2(y, x)}} is equivalent to {{c|std::arg(std::complex&lt;double&gt;(x,y))}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atan2.html POSIX specifies] that in case of underflow, {{tt|y/x}} is the value returned, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    // normal usage: the signs of the two arguments determine the quadrant
    std::cout &lt;&lt; &quot;(+1,+1) cartesian is (&quot; &lt;&lt; hypot(1,1)
              &lt;&lt; ',' &lt;&lt; atan2(1,1) &lt;&lt; &quot;) polar\n&quot;  // atan2(1,1) = +pi/4, Quad I
              &lt;&lt; &quot;(+1,-1) cartesian is (&quot; &lt;&lt; hypot(1,-1)
              &lt;&lt; ',' &lt;&lt; atan2(1,-1) &lt;&lt; &quot;) polar\n&quot; // atan2(1, -1) = +3pi/4, Quad II
              &lt;&lt; &quot;(-1,-1) cartesian is (&quot; &lt;&lt; hypot(-1,-1)
              &lt;&lt; ',' &lt;&lt; atan2(-1,-1) &lt;&lt; &quot;) polar\n&quot; // atan2(-1,-1) = -3pi/4, Quad III
              &lt;&lt; &quot;(-1,1) cartesian is (&quot; &lt;&lt; hypot(-1,1)
              &lt;&lt; ',' &lt;&lt; atan2(-1,1) &lt;&lt; &quot;) polar\n&quot;; // atan2(-1,-1) = -pi/4, Quad IV
    // special values
    std::cout &lt;&lt; &quot;atan2(0, 0) = &quot; &lt;&lt; atan2(0,0)
              &lt;&lt; &quot; atan2(0,-0) = &quot; &lt;&lt; atan2(0,-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;atan2(7, 0) = &quot; &lt;&lt; atan2(7,0)
              &lt;&lt; &quot; atan2(7,-0) = &quot; &lt;&lt; atan2(7,-0.0) &lt;&lt; '\n';
}
 | output=
(+1,+1) cartesian is (1.41421,0.785398) polar
(+1,-1) cartesian is (1.41421,2.35619) polar
(-1,-1) cartesian is (1.41421,-2.35619) polar
(-1,1) cartesian is (1.41421,-0.785398) polar
atan2(0, 0) = 0 atan2(0,-0) = 3.14159
atan2(7, 0) = 1.5708 atan2(7,-0) = 1.5708
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}
{{dsc see c | c/numeric/math/atan2}}
{{dsc end}}

[[de:cpp/numeric/math/atan2]]
[[es:cpp/numeric/math/atan2]]
[[fr:cpp/numeric/math/atan2]]
[[it:cpp/numeric/math/atan2]]
[[ja:cpp/numeric/math/atan2]]
[[pl:cpp/numeric/math/atan2]]
[[pt:cpp/numeric/math/atan2]]
[[ru:cpp/numeric/math/atan2]]
[[zh:cpp/numeric/math/atan2]]</text>
      <sha1>qwetki2t1ied9pnmnwxiv58utpgoxx2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/atanh</title>
    <ns>0</ns>
    <id>1349</id>
    <revision>
      <id>70604</id>
      <parentid>67145</parentid>
      <timestamp>2014-05-26T06:22:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail</comment>
      <text xml:space="preserve" bytes="3886">{{cpp/title|atanh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       atanh( float arg );
}}
{{dcl | since=c++11 |num=2|
double      atanh( double arg );
}}
{{dcl | since=c++11 |num=3|
long double atanh( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      atanh( Integral arg );
}}
{{dcl end}}

Computes the inverse hyperbolic tangent of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the inverse hyperbolic tangent of {{tt|arg}} ({{math|tanh{{su|p=-1}}(arg)}}, or {{math|artanh(arg)}}), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned (with the correct sign).

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the argument is not on the interval {{math|[-1, +1]}}, a range error occurs.

If the argument is ±1, a pole error occurs.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±1, ±∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* if {{math|{{!}}arg{{!}}&gt;1}}, NaN is returned and {{lc|FE_INVALID}} is raised.
* if the argument is NaN, NaN is returned

===Notes===
Although the C standard (to which C++ refers for this function) names this function &quot;arc hyperbolic tangent&quot;, the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct name is &quot;inverse hyperbolic tangent&quot; (used by POSIX) or &quot;area hyperbolic tangent&quot;.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/atanh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, an implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfloat&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;atanh(0) = &quot; &lt;&lt; std::atanh(0) &lt;&lt; '\n'
              &lt;&lt; &quot;atanh(-0) = &quot; &lt;&lt; std::atanh(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;atanh(0.9) = &quot; &lt;&lt; std::atanh(0.9) &lt;&lt; '\n';
     // error handling 
     errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
     std::cout &lt;&lt; &quot;atanh(-1) = &quot; &lt;&lt; std::atanh(-1) &lt;&lt; '\n';
     if(errno == ERANGE)
         std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
     if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
|p=true
|output=
atanh(0) = 0
atanh(-0) = -0
atanh(0.9) = 1.47222
atanh(-1) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc atanh}}
{{dsc see c | c/numeric/math/atanh}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/InverseHyperbolicTangent.html Weisstein, Eric W. &quot;Inverse Hyperbolic Tangent.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/atanh]]
[[es:cpp/numeric/math/atanh]]
[[fr:cpp/numeric/math/atanh]]
[[it:cpp/numeric/math/atanh]]
[[ja:cpp/numeric/math/atanh]]
[[pt:cpp/numeric/math/atanh]]
[[ru:cpp/numeric/math/atanh]]
[[zh:cpp/numeric/math/atanh]]</text>
      <sha1>qa4jy6u0c0366fu4v8ksm9lrwycgq3e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/cbrt</title>
    <ns>0</ns>
    <id>1350</id>
    <revision>
      <id>70629</id>
      <parentid>70459</parentid>
      <timestamp>2014-05-27T03:53:43Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to hypot</comment>
      <text xml:space="preserve" bytes="2207">{{cpp/title|cbrt}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num=1 | since=c++11 |
float       cbrt( float arg );
}}
{{dcl | num=2 |since=c++11 |
double      cbrt( double arg );
}}
{{dcl | num=3 |since=c++11 |
long double cbrt( long double arg );
}}
{{dcl | num=4 |since=c++11 |
double      cbrt( Integral arg );
}}
{{dcl end}}

Computes the cubic root of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the cubic root of {{tt|arg}} ({{math|{{mrad|arg|3}}}}), is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in {{lc|math_errhandling}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned, unchanged
* if the argument is NaN, NaN is returned.

===Notes===
{{c|std::cbrt(arg)}} is not equivalent to {{c|std::pow(arg, 1.0/3)}} because {{lc|std::pow}} cannot raise a negative base to a fractional exponent.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    // normal use
    std::cout &lt;&lt; &quot;cbrt(729) = &quot; &lt;&lt; std::cbrt(729) &lt;&lt; '\n'
              &lt;&lt; &quot;cbrt(-0.125) = &quot; &lt;&lt; std::cbrt(-0.125) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;cbrt(-0) = &quot; &lt;&lt; std::cbrt(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;cbrt(+inf) = &quot; &lt;&lt; std::cbrt(INFINITY) &lt;&lt; '\n';
}
 | output=
cbrt(729) = 9
cbrt(-0.125) = -0.5
cbrt(-0) = -0
cbrt(+inf) = inf
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc hypot}}
{{dsc see c | c/numeric/math/cbrt}}
{{dsc end}}

[[de:cpp/numeric/math/cbrt]]
[[es:cpp/numeric/math/cbrt]]
[[fr:cpp/numeric/math/cbrt]]
[[it:cpp/numeric/math/cbrt]]
[[ja:cpp/numeric/math/cbrt]]
[[pt:cpp/numeric/math/cbrt]]
[[ru:cpp/numeric/math/cbrt]]
[[zh:cpp/numeric/math/cbrt]]</text>
      <sha1>jj7b1qlstb1vvzjvwib3x7gj54tdvc3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/ceil</title>
    <ns>0</ns>
    <id>1351</id>
    <revision>
      <id>71846</id>
      <parentid>71844</parentid>
      <timestamp>2014-06-27T18:09:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>more common math chars for ceiling</comment>
      <text xml:space="preserve" bytes="3050">{{cpp/title|ceil}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num=1 |
float       ceil( float arg );
}}
{{dcl | num=2 |
double      ceil( double arg );
}}
{{dcl | num=3 |
long double ceil( long double arg );
}}
{{dcl | since=c++11 | num=4 |
double      ceil( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the smallest integer value not less than {{tt|arg}}. 
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the smallest integer value not less than {{tt|arg}}, that is {{math|⌈arg⌉}}, is returned.

{{plot | left=Return value | bottom=Argument | math-ceil.svg}}

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

This function (for double argument) behaves as if (except for the freedom to not raise {{lc|FE_INEXACT}}) implemented by

{{source|1=#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
double ceil(double x)
{
    double result;
    int save_round = std::fegetround();
    std::fesetround(FE_UPWARD);
    result = std::rint(x); // or std::nearbyint 
    std::fesetround(save_round);
    return result;
}
}}

===Example===
{{example
 | code=
#include &lt;cmath&gt;
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::fixed
              &lt;&lt; &quot;ceil(+2.4) = &quot; &lt;&lt; std::ceil(+2.4) &lt;&lt; '\n'
              &lt;&lt; &quot;ceil(-2.4) = &quot; &lt;&lt; std::ceil(-2.4) &lt;&lt; '\n'
              &lt;&lt; &quot;ceil(-0.0) = &quot; &lt;&lt; std::ceil(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;ceil(-Inf) = &quot; &lt;&lt; std::ceil(-INFINITY) &lt;&lt; '\n';
}
 | output=
ceil(+2.4) = 3.000000
ceil(-2.4) = -2.000000
ceil(-0.0) = -0.000000
ceil(-Inf) = -INF
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc floor}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
{{dsc inc | cpp/numeric/math/dsc rint}}
{{dsc see c | c/numeric/math/ceil}}
{{dsc end}}

[[de:cpp/numeric/math/ceil]]
[[es:cpp/numeric/math/ceil]]
[[fr:cpp/numeric/math/ceil]]
[[it:cpp/numeric/math/ceil]]
[[ja:cpp/numeric/math/ceil]]
[[pl:cpp/numeric/math/ceil]]
[[pt:cpp/numeric/math/ceil]]
[[ru:cpp/numeric/math/ceil]]
[[zh:cpp/numeric/math/ceil]]</text>
      <sha1>1danazuew583s3n8jni3olsysdujpct</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/copysign</title>
    <ns>0</ns>
    <id>1352</id>
    <revision>
      <id>70500</id>
      <parentid>65661</parentid>
      <timestamp>2014-05-24T19:31:32Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1316">{{cpp/title|copysign}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num = 1|
float       copysign( float x, float y );
}}
{{dcl | since=c++11 | num = 2|
double      copysign( double x, double y );
}}
{{dcl | since=c++11 | num = 3|
long double copysign( long double x, long double y );
}}
{{dcl | since=c++11 | num = 4|
Promoted    copysign( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

Composes a floating point value with the magnitude of {{tt|x}} and the sign of {{tt|y}}. 

4) If any argument has integral type, it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===

floating point value with the magnitude of {{tt|x}} and the sign of {{tt|y}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/math/dsc signbit}}
{{dsc see c | c/numeric/math/copysign}}
{{dsc end}}

[[de:cpp/numeric/math/copysign]]
[[es:cpp/numeric/math/copysign]]
[[fr:cpp/numeric/math/copysign]]
[[it:cpp/numeric/math/copysign]]
[[ja:cpp/numeric/math/copysign]]
[[pt:cpp/numeric/math/copysign]]
[[ru:cpp/numeric/math/copysign]]
[[zh:cpp/numeric/math/copysign]]</text>
      <sha1>fkzuec6w67olre7y4hywksxcqidpfaw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/cos</title>
    <ns>0</ns>
    <id>1353</id>
    <revision>
      <id>70511</id>
      <parentid>70210</parentid>
      <timestamp>2014-05-24T19:55:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>return values, details for overload 4</comment>
      <text xml:space="preserve" bytes="3120">{{cpp/title|cos}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num=1|
float       cos( float arg );
}}
{{dcl |num=2|
double      cos( double arg );
}}
{{dcl |num=3|
long double cos( long double arg );
}}
{{dcl | num=4| since=c++11 |
double      cos( Integral arg );
}}
{{dcl end}}

Computes the cosine of {{tt|arg}} (measured in radians).
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value representing angle in radians, of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the cosine of {{tt|arg}} ({{math|cos(arg)}}) in the range {{math|[-1 ; +1]}}, is returned.

{{rev begin}}
{{rev|until=c++11|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, the result is 1.0
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C, but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/cos.html domain error in POSIX]

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1);
int main()
{
    // typical usage
    std::cout &lt;&lt; &quot;cos(pi/3) = &quot; &lt;&lt; std::cos(pi/3) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi/2) = &quot; &lt;&lt; std::cos(pi/2) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(-3*pi/4) = &quot; &lt;&lt; std::cos(-3*pi/4) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;cos(+0) = &quot; &lt;&lt; std::cos(0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(-0) = &quot; &lt;&lt; std::cos(-0.0) &lt;&lt; '\n';
    // error handling 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;cos(INFINITY) = &quot; &lt;&lt; std::cos(INFINITY) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID)) std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
| p=true
| output=
cos(pi/3) = 0.5
cos(pi/2) = 6.12323e-17
cos(-3*pi/4) = -0.707107
cos(+0) = 1
cos(-0) = 1
cos(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc see c | c/numeric/math/cos}}
{{dsc end}}

[[de:cpp/numeric/math/cos]]
[[es:cpp/numeric/math/cos]]
[[fr:cpp/numeric/math/cos]]
[[it:cpp/numeric/math/cos]]
[[ja:cpp/numeric/math/cos]]
[[pl:cpp/numeric/math/cos]]
[[pt:cpp/numeric/math/cos]]
[[ru:cpp/numeric/math/cos]]
[[zh:cpp/numeric/math/cos]]</text>
      <sha1>9xvjs4padkvtjqky9p84m9kk4phxgpd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/cosh</title>
    <ns>0</ns>
    <id>1354</id>
    <revision>
      <id>70556</id>
      <parentid>67141</parentid>
      <timestamp>2014-05-25T01:27:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>return values, other details, example</comment>
      <text xml:space="preserve" bytes="2954">{{cpp/title|cosh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num=1 |
float       cosh( float arg );
}}
{{dcl | num=2 |
double      cosh( double arg );
}}
{{dcl | num=3 |
long double cosh( long double arg );
}}
{{dcl | since=c++11 | num=4 |
double      cosh( Integral arg );
}}
{{dcl end}}

Computes the hyperbolic cosine of {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic cosine of {{tt|arg}} ({{math|cosh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}+e{{su|p=-arg}}|2}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, 1 is returned
* If the argument is ±∞, +∞ is returned
* if the argument is NaN, NaN is returned

===Notes===
For the IEEE-compatible type {{c|double}}, if {{math|{{!}}arg{{!}} &gt; 710.5}}, then {{tt|cosh(arg)}} overflows.

===Example===
{{source|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;cosh(1) = &quot; &lt;&lt; std::cosh(1) &lt;&lt; '\n'
              &lt;&lt; &quot;cosh(-1) = &quot; &lt;&lt; std::cosh(-1) &lt;&lt; '\n'
              &lt;&lt; &quot;log(sinh(1)+cosh(1)=&quot; &lt;&lt; std::log(std::sinh(1)+std::cosh(1)) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;cosh(+0) = &quot; &lt;&lt; std::cosh(0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;cosh(-0) = &quot; &lt;&lt; std::cosh(-0.0) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;cosh(710.5) = &quot; &lt;&lt; std::cosh(710.5) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|p=true
|output=
cosh(1) = 1.54308
cosh(-1) = 1.54308
log(sinh(1)+cosh(1)=1
cosh(+0) = 1
cosh(-0) = 1
cosh(710.5) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc acosh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc see c | c/numeric/math/cosh}}
{{dsc end}}

[[de:cpp/numeric/math/cosh]]
[[es:cpp/numeric/math/cosh]]
[[fr:cpp/numeric/math/cosh]]
[[it:cpp/numeric/math/cosh]]
[[ja:cpp/numeric/math/cosh]]
[[pl:cpp/numeric/math/cosh]]
[[pt:cpp/numeric/math/cosh]]
[[ru:cpp/numeric/math/cosh]]
[[zh:cpp/numeric/math/cosh]]</text>
      <sha1>8i4x5uic5cwyg9qcie4q63sjbbbea82</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/div</title>
    <ns>0</ns>
    <id>1355</id>
    <revision>
      <id>71807</id>
      <parentid>71806</parentid>
      <timestamp>2014-06-24T19:58:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-dup word</comment>
      <text xml:space="preserve" bytes="3868">{{cpp/title|div|ldiv|lldiv}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl |num=1|
std::div_t     div( int x, int y );
}}
{{dcl |num=2|
std::ldiv_t    div( long x, long y );
}}
{{dcl | since=c++11 |num=3|
std::lldiv_t   div( long long x, long long y );
}}
{{dcl |num=4|
std::ldiv_t   ldiv( long x, long y );
}}
{{dcl | since=c++11 |num=5|
std::lldiv_t lldiv( long long x, long long y );
}}
{{dcl header | cinttypes}}
{{dcl | since=c++11 |num=6|
std::imaxdiv_t div( std::intmax_t x, std::intmax_t y );
}}
{{dcl | since=c++11 |num=7|
std::imaxdiv_t imaxdiv( std::intmax_t x, std::intmax_t y );
}}
{{dcl end}}

Computes both the quotient and the remainder of the division of the numerator {{tt|x}} by the denominator {{tt|y}}
{{rev begin}}
{{rev | until=c++11 |
The quotient is the algebraic quotient with any fractional part discarded (truncated towards zero). The remainder is such that {{c|1=quot * y + rem == x}}.
}}
{{rev | since=c++11 |
The quotient is the result of the expression {{c|x/y}}. The remainder is the result of the expression {{c|x%y}}.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | x, y | integer values}}
{{par end}}

===Return value===
If both the remainder and the quotient can be represented as objects of the corresponding type (int, long, long long, std::imaxdiv_t, respectively), returns both as an object of type {{tt|std::div_t}}, {{tt|std::ldiv_t}}, {{tt|std::ldiv_t}}, {{tt|std::imaxdiv_t}} defined as follows:

{{member | {{small|std::}}div_t | 2=
{{source|1=
struct div_t { int quot; int rem; };
}}
or
{{source|1=
struct div_t { int rem; int quot; };
}}
}}

{{member | {{small|std::}}ldiv_t | 2=
{{source|1=
struct ldiv_t { long quot; long rem; };
}}
or
{{source|1=
struct ldiv_t { long rem; long quot; };
}}
}}

{{member | {{small|std::}}lldiv_t | 2=
{{source|1=
struct lldiv_t { long long quot; long long rem; };
}}
or
{{source|1=
struct lldiv_t { long long rem; long long quot; };
}}
}}

{{member | {{small|std::}}imaxdiv_t | 2=
{{source|1=
struct imaxdiv_t { std::intmax_t quot; std::intmax_t rem; };
}}
or
{{source|1=
struct imaxdiv_t { std::intmax_t rem; std::intmax_t quot; };
}}
}}


If either the remainder or the quotient cannot be represented, the behavior is undefined.

===Notes===
Until C++11, the rounding direction of the quotient and the sign of the remainder in the [[cpp/language/operator_arithmetic|built-in division and remainder operators]] was implementation-defined if either of the operands was negative, but it was well-defined in {{lc|std::div}}.

On many platforms, a single CPU instruction obtains both the quotient and the remainder, and this function may leverage that, although compilers are generally able to merge nearby / and % where suitable.

===Example===
{{example
|code=
#include &lt;string&gt;
#include &lt;cmath&gt;
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;

std::string itoa(int n, int base)
{
    std::string buf;
    std::div_t dv{}; dv.quot = n;
    do {
        dv = std::div(dv.quot, base);
        buf += &quot;0123456789abcdef&quot;[std::abs(dv.rem)];  // the type of the string literal is 
                                                      // const char[17]
    } while(dv.quot);
    if(n&lt;0) buf += '-';
    return {buf.rbegin(), buf.rend()};
}

int main()
{
    std::cout &lt;&lt; itoa(12345, 10) &lt;&lt; '\n'
              &lt;&lt; itoa(-12345, 10) &lt;&lt; '\n'
              &lt;&lt; itoa(65535, 16) &lt;&lt; '\n';
}
|output=
12345
-12345
ffff
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fmod}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc see c | c/numeric/math/div}}
{{dsc end}}

[[de:cpp/numeric/math/div]]
[[es:cpp/numeric/math/div]]
[[fr:cpp/numeric/math/div]]
[[it:cpp/numeric/math/div]]
[[ja:cpp/numeric/math/div]]
[[pl:cpp/numeric/math/div]]
[[pt:cpp/numeric/math/div]]
[[ru:cpp/numeric/math/div]]
[[zh:cpp/numeric/math/div]]</text>
      <sha1>4qavgrjpyaclpoh7nspgaxa77b1nigl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/erf</title>
    <ns>0</ns>
    <id>2951</id>
    <revision>
      <id>71164</id>
      <parentid>71159</parentid>
      <timestamp>2014-06-07T06:03:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="3114">{{cpp/title|erf}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       erf( float arg );
}}
{{dcl | since=c++11 |num=2|
double      erf( double arg );
}}
{{dcl | since=c++11 |num=3|
long double erf( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      erf( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Error function|error function]] of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, value of the error function of {{tt|arg}}, that is {{math|{{mfrac|2|{{mrad|&amp;pi;}}}}{{minteg|0|arg|{{mexp|-t{{su|p=2}}}}d''t''}}}}, is returned.


If a range error occurs due to underflow, the correct result (after rounding), that is {{math|{{mfrac|2*arg|{{mrad|&amp;pi;}}}}}} is returned

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, ±0 is returned
* If the argument is ±∞, ±1 is returned
* If the argument is NaN, NaN is returned

===Notes===
Underflow is guaranteed if {{c|{{!}}arg{{!}} &lt; DBL_MIN*(sqrt(π)/2)}}

{{math|erf({{mfrac|x|&amp;sigma;{{mrad|2}}}})}} is the probability that a measurement whose errors are subject to a normal distribution with standard deviation {{math|&amp;sigma;}} is less than {{math|x}} away from the mean value.

===Example===
{{example
 | The following example calculates the probability that a normal variate is on the interval (x1, x2)
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;iomanip&gt;
double phi(double x1, double x2)
{
    return (std::erf(x2/std::sqrt(2)) - std::erf(x1/std::sqrt(2)))/2;
}
int main()
{
    std::cout &lt;&lt; &quot;normal variate probabilities:\n&quot;
              &lt;&lt; std::fixed &lt;&lt; std::setprecision(2);
    for(int n=-4; n&lt;4; ++n)
        std::cout &lt;&lt; &quot;[&quot; &lt;&lt; std::setw(2) &lt;&lt; n &lt;&lt; &quot;:&quot; &lt;&lt; std::setw(2) &lt;&lt; n+1 &lt;&lt; &quot;]: &quot;
                  &lt;&lt; std::setw(5) &lt;&lt; 100*phi(n, n+1) &lt;&lt; &quot;%\n&quot;;

    std::cout &lt;&lt; &quot;special values:\n&quot;
              &lt;&lt; &quot;erf(-0) = &quot; &lt;&lt; std::erf(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;erf(Inf) = &quot; &lt;&lt; std::erf(INFINITY) &lt;&lt; '\n';
}
 | output=
normal variate probabilities:
[-4:-3]:  0.13%
[-3:-2]:  2.14%
[-2:-1]: 13.59%
[-1: 0]: 34.13%
[ 0: 1]: 34.13%
[ 1: 2]: 13.59%
[ 2: 3]:  2.14%
[ 3: 4]:  0.13%
special values:
erf(-0) = -0.00
erf(Inf) = 1.00
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc erfc}}
{{dsc see c | c/numeric/math/erf}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/Erf.html Weisstein, Eric W. &quot;Erf.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/erf]]
[[es:cpp/numeric/math/erf]]
[[fr:cpp/numeric/math/erf]]
[[it:cpp/numeric/math/erf]]
[[ja:cpp/numeric/math/erf]]
[[pt:cpp/numeric/math/erf]]
[[ru:cpp/numeric/math/erf]]
[[zh:cpp/numeric/math/erf]]</text>
      <sha1>izd6q9prnthtn40dfu0icb3yrgvf8kc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/erfc</title>
    <ns>0</ns>
    <id>2952</id>
    <revision>
      <id>71179</id>
      <parentid>71166</parentid>
      <timestamp>2014-06-07T19:18:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>missing num=...</comment>
      <text xml:space="preserve" bytes="2999">{{cpp/title|erfc}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       erfc( float arg );
}}
{{dcl | since=c++11 |num=2|
double      erfc( double arg );
}}
{{dcl | since=c++11 |num=3|
long double erfc( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      erfc( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Complementary error function|complementary error function]] of {{tt|arg}}, that is {{tt|1.0-erf(arg)}}, but without loss of precision for large {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, value of the complementary error function of {{tt|arg}}, that is {{math|{{mfrac|2|{{mrad|&amp;pi;}}}}{{minteg|arg|∞|{{mexp|-t{{su|p=2}}}}d''t''}}}} or {{math|1-erf(arg)}}, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is +∞, +0 is returned
* If the argument is -∞, 2 is returned
* If the argument is NaN, NaN is returned

===Notes===
For the IEEE-compatible type {{tt|double}}, underflow is guaranteed if {{tt|arg}} &gt; 26.55.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;iomanip&gt;
double normalCDF(double x) // Phi(-∞, x) aka N(x)
{
    return std::erfc(-x*std::sqrt(2))/2;
}
int main()
{
    std::cout &lt;&lt; &quot;normal cumulative distribution function:\n&quot;
              &lt;&lt; std::fixed &lt;&lt; std::setprecision(2);
    for(double n=0; n&lt;1; n+=0.1)
        std::cout &lt;&lt; &quot;normalCDF(&quot; &lt;&lt; n &lt;&lt; &quot;) &quot; &lt;&lt; 100*normalCDF(n) &lt;&lt; &quot;%\n&quot;;

    std::cout &lt;&lt; &quot;special values:\n&quot;
              &lt;&lt; &quot;erfc(-Inf) = &quot; &lt;&lt; std::erfc(-INFINITY) &lt;&lt; '\n'
              &lt;&lt; &quot;erfc(Inf) = &quot; &lt;&lt; std::erfc(INFINITY) &lt;&lt; '\n';
}
|output=
normal cumulative distribution function:
normalCDF(0.00) 50.00%
normalCDF(0.10) 57.93%
normalCDF(0.20) 65.54%
normalCDF(0.30) 72.57%
normalCDF(0.40) 78.81%
normalCDF(0.50) 84.13%
normalCDF(0.60) 88.49%
normalCDF(0.70) 91.92%
normalCDF(0.80) 94.52%
normalCDF(0.90) 96.41%
normalCDF(1.00) 97.72%
special values:
erfc(-Inf) = 2.00
erfc(Inf) = 0.00
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc erf}}
{{dsc see c | c/numeric/math/erfc}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/Erfc.html Weisstein, Eric W. &quot;Erfc.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/erfc]]
[[es:cpp/numeric/math/erfc]]
[[fr:cpp/numeric/math/erfc]]
[[it:cpp/numeric/math/erfc]]
[[ja:cpp/numeric/math/erfc]]
[[pt:cpp/numeric/math/erfc]]
[[ru:cpp/numeric/math/erfc]]
[[zh:cpp/numeric/math/erfc]]</text>
      <sha1>3i5dp3uep8ldx0taj5iraamg7hj5zz4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/exp</title>
    <ns>0</ns>
    <id>1356</id>
    <revision>
      <id>70674</id>
      <parentid>70616</parentid>
      <timestamp>2014-05-28T04:25:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>tgmath, return values, error handling, posix note, example</comment>
      <text xml:space="preserve" bytes="3080">{{cpp/title|exp}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       exp( float arg );
}}
{{dcl |num=2|
double      exp( double arg );
}}
{{dcl |num=3|
long double exp( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      exp( Integral arg );
}}
{{dcl end}}

Computes the ''e'' (Euler's number, {{tt|2.7182818}}) raised to the given power {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the base-''e'' exponential of {{tt|arg}} ({{math|e{{su|p=arg}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, 1 is returned
* If the argument is -∞, +0 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
For IEEE-compatible type {{c|double}}, overflow is guaranteed if {{math|709.8 &lt; arg}}, and underflow is guaranteed if {{math|arg &lt; -708.4}}

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;exp(1) = &quot; &lt;&lt; std::exp(1) &lt;&lt; '\n'
              &lt;&lt; &quot;FV of $100, continuously compounded at 3% for 1 year = &quot;
              &lt;&lt; 100*std::exp(0.03) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;exp(-0) = &quot; &lt;&lt; std::exp(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;exp(-Inf) = &quot; &lt;&lt; std::exp(-INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;exp(710) = &quot; &lt;&lt; std::exp(710) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|p=true
|output=
exp(1) = 2.71828
FV of $100, continuously compounded at 3% for 1 year = 103.045
exp(-0) = 1
exp(-Inf) = 0
exp(710) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc exp2}}
{{dsc inc | cpp/numeric/math/dsc expm1}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/complex/dsc exp}}
{{dsc inc | cpp/numeric/valarray/dsc exp}}
{{dsc see c | c/numeric/math/exp}}
{{dsc end}}

[[de:cpp/numeric/math/exp]]
[[es:cpp/numeric/math/exp]]
[[fr:cpp/numeric/math/exp]]
[[it:cpp/numeric/math/exp]]
[[ja:cpp/numeric/math/exp]]
[[pl:cpp/numeric/math/exp]]
[[pt:cpp/numeric/math/exp]]
[[ru:cpp/numeric/math/exp]]
[[zh:cpp/numeric/math/exp]]</text>
      <sha1>93fq66ep2mnc3k38ytt1swck3dtt5j2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/exp2</title>
    <ns>0</ns>
    <id>3293</id>
    <revision>
      <id>70836</id>
      <parentid>70786</parentid>
      <timestamp>2014-05-31T00:35:20Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>for symmetry with exp and expm1: -link to log and pow and +link to expm1</comment>
      <text xml:space="preserve" bytes="2797">{{cpp/title|exp2}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
double      exp2( double n );
}}
{{dcl | since=c++11 |num=2|
float       exp2( float n );
}}
{{dcl | since=c++11 |num=3|
long double exp2( long double n );
}}
{{dcl | since=c++11 |num=4|
double      exp2( Integral n );
}}
{{dcl end}}

@1-3@ Computes 2 raised to the given power {{tt|n}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | n | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the base-''2'' exponential of {{tt|n}} ({{math|2{{su|p=n}}}}) is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, 1 is returned
* If the argument is -∞, +0 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;exp2(4) = &quot; &lt;&lt; std::exp2(4) &lt;&lt; '\n'
              &lt;&lt; &quot;exp2(0.5) = &quot; &lt;&lt; std::exp2(0.5) &lt;&lt; '\n'
              &lt;&lt; &quot;exp2(-4) = &quot; &lt;&lt; std::exp2(-4) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;exp2(-0) = &quot; &lt;&lt; std::exp2(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;exp2(-Inf) = &quot; &lt;&lt; std::exp2(-INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;exp2(1024) = &quot; &lt;&lt; std::exp2(1024) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|p=true
|output=
exp2(4) = 16
exp2(0.5) = 1.41421
exp2(-4) = 0.0625
exp2(-0) = 1
exp2(-Inf) = 0
exp2(1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc expm1}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc see c | c/numeric/math/exp2}}
{{dsc end}}

[[de:cpp/numeric/math/exp2]]
[[es:cpp/numeric/math/exp2]]
[[fr:cpp/numeric/math/exp2]]
[[it:cpp/numeric/math/exp2]]
[[ja:cpp/numeric/math/exp2]]
[[pt:cpp/numeric/math/exp2]]
[[ru:cpp/numeric/math/exp2]]
[[zh:cpp/numeric/math/exp2]]</text>
      <sha1>oz35cxw2dogcrzntqquo1n8zgm2rmgq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/expm1</title>
    <ns>0</ns>
    <id>3661</id>
    <revision>
      <id>70924</id>
      <parentid>70918</parentid>
      <timestamp>2014-06-03T15:08:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>std::</comment>
      <text xml:space="preserve" bytes="3690">{{cpp/title|expm1}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1 |
float       expm1( float arg );
}}
{{dcl | since=c++11 |num=2 |
double      expm1( double arg );
}}
{{dcl | since=c++11 |num=3 |
long double expm1( long double arg );
}}
{{dcl | since=c++11 |num=4 |
double      expm1( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the ''e'' (Euler's number, {{tt|2.7182818}}) raised to the given power {{tt|arg}}, minus {{c|1.0}}. This function is more accurate than the expression {{c|std::exp(arg)-1.0}} if {{tt|arg}} is close to zero.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur {{math|e{{su|p=arg}}-1}} is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned, unmodified
* If the argument is -∞, -1 is returned
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
The functions {{tt|std::expm1}} and {{lc|std::log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1+x){{su|p=n}}-1}} can be expressed as {{c|std::expm1(n * std::log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.

For IEEE-compatible type {{c|double}}, overflow is guaranteed if {{math|709.8 &lt; arg}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;expm1(1) = &quot; &lt;&lt; std::expm1(1) &lt;&lt; '\n'
              &lt;&lt; &quot;Interest earned in 2 days on on $100, compounded daily at 1%\n&quot;
              &lt;&lt; &quot; on a 30/360 calendar = &quot;
              &lt;&lt; 100*std::expm1(2*std::log1p(0.01/360)) &lt;&lt; '\n'
              &lt;&lt; &quot;exp(1e-16)-1 = &quot; &lt;&lt; std::exp(1e-16)-1
              &lt;&lt; &quot;, but expm1(1e-16) = &quot; &lt;&lt; std::expm1(1e-16) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;expm1(-0) = &quot; &lt;&lt; std::expm1(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;expm1(-Inf) = &quot; &lt;&lt; std::expm1(-INFINITY) &lt;&lt; '\n';
    // error handling
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;expm1(710) = &quot; &lt;&lt; std::expm1(710) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
 | p=true
 | output=
expm1(1) = 1.71828
Interest earned in 2 days on on $100, compounded daily at 1%
 on a 30/360 calendar = 0.00555563
exp(1e-16)-1 = 0 expm1(1e-16) = 1e-16
expm1(-0) = -0
expm1(-Inf) = -1
expm1(710) = inf
    errno == ERANGE: Result too large
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc exp2}}
{{dsc inc | cpp/numeric/math/dsc log1p}}
{{dsc see c | c/numeric/math/expm1}}
{{dsc end}}

[[de:cpp/numeric/math/expm1]]
[[es:cpp/numeric/math/expm1]]
[[fr:cpp/numeric/math/expm1]]
[[it:cpp/numeric/math/expm1]]
[[ja:cpp/numeric/math/expm1]]
[[pt:cpp/numeric/math/expm1]]
[[ru:cpp/numeric/math/expm1]]
[[zh:cpp/numeric/math/expm1]]</text>
      <sha1>flupnw0kl60bmv7lw2ino7k4fdey6dr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fabs</title>
    <ns>0</ns>
    <id>1357</id>
    <revision>
      <id>71300</id>
      <parentid>71239</parentid>
      <timestamp>2014-06-09T04:34:19Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to copysign</comment>
      <text xml:space="preserve" bytes="2537">{{cpp/title|abs{{small|(float)}}|fabs}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       abs( float arg );
}}
{{dcl |num=2|
double      abs( double arg );
}}
{{dcl |num=3|
long double abs( long double arg );
}}
{{dcl |num=4|
float       fabs( float arg ); 
}}
{{dcl |num=5|
double      fabs( double arg );
}}
{{dcl |num=6|
long double fabs( long double arg );
}}
{{dcl | since=c++11 |num=7|
double      fabs( Integral arg );
}}
{{dcl end}}

@1-6@ Computes the absolute value of a floating point value {{tt|arg}}.
@7@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 4-6). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

===Parameters===
{{par begin}}
{{par | arg | Value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If successful, returns the absolute value of {{tt|arg}} ({{tt|{{!}}arg{{!}}}}). The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, +0 is returned
* If the argument is ±∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;abs(+3.0) = &quot; &lt;&lt; std::abs(+3.0) &lt;&lt; '\n'
              &lt;&lt; &quot;abs(-3.0) = &quot; &lt;&lt; std::abs(-3.0) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;abs(-0.0) = &quot; &lt;&lt; std::abs(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;abs(-Inf) = &quot; &lt;&lt; std::abs(-INFINITY) &lt;&lt; '\n';
}
|p=true
|output=
abs(+3.0) = 3
abs(-3.0) = 3
abs(-0.0) = 0
abs(-Inf) = inf
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc copysign}}
{{dsc inc | cpp/numeric/math/dsc signbit}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc inc | cpp/numeric/valarray/dsc abs}}
{{dsc see c | c/numeric/math/fabs}}
{{dsc end}}

[[de:cpp/numeric/math/fabs]]
[[es:cpp/numeric/math/fabs]]
[[fr:cpp/numeric/math/fabs]]
[[it:cpp/numeric/math/fabs]]
[[ja:cpp/numeric/math/fabs]]
[[pl:cpp/numeric/math/fabs]]
[[pt:cpp/numeric/math/fabs]]
[[ru:cpp/numeric/math/fabs]]
[[zh:cpp/numeric/math/fabs]]</text>
      <sha1>k509u7yzajgca9iazepoqctx1cj3n3i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fdim</title>
    <ns>0</ns>
    <id>2661</id>
    <revision>
      <id>71200</id>
      <parentid>71198</parentid>
      <timestamp>2014-06-08T01:53:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-stray tt</comment>
      <text xml:space="preserve" bytes="2986">{{cpp/title|fdim}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
float       fdim( float x, float y );
}}
{{dcl | since=c++11 | num=2 |
double      fdim( double x, double y );
}}
{{dcl | since=c++11 | num=3 |
long double fdim( long double x, long double y );
}}
{{dcl | since=c++11 | num=4 |
Promoted    fdim( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

@1-3@ Returns the positive difference between {{c|x}} and {{c|y}}, that is, if {{c|x&gt;y}}, returns {{c|x-y}}, otherwise (if {{c|x≤y}}), returns +0.
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any argument is {{c|long double}}, then the return type {{tt|Promoted}} is also {{c|long double}}, otherwise the return type is always {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If successful, returns the positive difference between x and y.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If either argument is NaN, NaN is returned

===Notes===
Equivalent to {{c|std::fmax(x-y, 0)}},  except for the NaN handling requirements

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;fdim(4, 1) = &quot; &lt;&lt; std::fdim(4, 1)
              &lt;&lt; &quot; fdim(1, 4) = &quot; &lt;&lt; std::fdim(1, 4) &lt;&lt; '\n'
              &lt;&lt; &quot;fdim(4,-1) = &quot; &lt;&lt; std::fdim(4, -1)
              &lt;&lt; &quot; fdim(1,-4) = &quot; &lt;&lt; std::fdim(1, -4) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;fdim(1e308, -1e308) = &quot; &lt;&lt; std::fdim(1e308, -1e308) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|output=
fdim(4, 1) = 3 fdim(1, 4) = 0
fdim(4,-1) = 5 fdim(1,-4) = 5
fdim(1e308, -1e308) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc fmax}}
{{dsc see c | c/numeric/math/fdim}}
{{dsc end}}

[[de:cpp/numeric/math/fdim]]
[[es:cpp/numeric/math/fdim]]
[[fr:cpp/numeric/math/fdim]]
[[it:cpp/numeric/math/fdim]]
[[ja:cpp/numeric/math/fdim]]
[[pt:cpp/numeric/math/fdim]]
[[ru:cpp/numeric/math/fdim]]
[[zh:cpp/numeric/math/fdim]]</text>
      <sha1>hwhxyjgywu5e4bvutquu1t291pzwdt7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/floor</title>
    <ns>0</ns>
    <id>1358</id>
    <revision>
      <id>71874</id>
      <parentid>70503</parentid>
      <timestamp>2014-06-30T17:03:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, more example</comment>
      <text xml:space="preserve" bytes="2573">{{cpp/title|floor}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       floor( float arg );
}}
{{dcl |num=2|
double      floor( double arg );
}}
{{dcl |num=3|
long double floor( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      floor( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the largest integer value not greater than {{tt|arg}}. 
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the largest integer value not greater than {{tt|arg}}, that is {{math|⌊arg⌋}}, is returned.

{{plot | left=Return value | bottom=Argument | math-floor.svg}}

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

===Example===
{{example
 | code=
#include &lt;cmath&gt;
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::fixed
              &lt;&lt; &quot;floor(+2.7) = &quot; &lt;&lt; std::floor(+2.7) &lt;&lt; '\n'
              &lt;&lt; &quot;floor(-2.7) = &quot; &lt;&lt; std::floor(-2.7) &lt;&lt; '\n'
              &lt;&lt; &quot;floor(-0.0) = &quot; &lt;&lt; std::floor(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;floor(-Inf) = &quot; &lt;&lt; std::floor(-INFINITY) &lt;&lt; '\n';
}
 | output=
floor(+2.7) = 2.000000
floor(-2.7) = -3.000000
floor(-0.0) = -0.000000
floor(-Inf) = -inf
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc ceil}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc see c | c/numeric/math/floor}}
{{dsc end}}

[[de:cpp/numeric/math/floor]]
[[es:cpp/numeric/math/floor]]
[[fr:cpp/numeric/math/floor]]
[[it:cpp/numeric/math/floor]]
[[ja:cpp/numeric/math/floor]]
[[pl:cpp/numeric/math/floor]]
[[pt:cpp/numeric/math/floor]]
[[ru:cpp/numeric/math/floor]]
[[zh:cpp/numeric/math/floor]]</text>
      <sha1>t3a2e53qjv5p2lk5av56htl7a9j6gsf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fma</title>
    <ns>0</ns>
    <id>2653</id>
    <revision>
      <id>71228</id>
      <parentid>71221</parentid>
      <timestamp>2014-06-08T19:34:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>wikilink for fma/mac</comment>
      <text xml:space="preserve" bytes="5660">{{cpp/title|fma}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
float       fma( float x, float y, float z );
}}
{{dcl | since=c++11 | num=2 |
double      fma( double x, double y, double z );
}}
{{dcl | since=c++11 | num=3 |
long double fma( long double x, long double y, long double z );
}}
{{dcl | since=c++11 | num=4 |
Promoted    fma( Arithmetic1 x, Arithmetic2 y, Arithmetic3 z );
}}
{{dcl | since=c++11 | num=5 |
#define FP_FAST_FMA  /* implementation-defined */
}}
{{dcl | since=c++11 | num=6 |
#define FP_FAST_FMAF /* implementation-defined */
}}
{{dcl | since=c++11 | num=7 |
#define FP_FAST_FMAL /* implementation-defined */
}}
{{dcl end}}

@1-3@ Computes {{c|(x*y) + z}} as if to infinite precision and rounded only once to fit the result type.
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.
@5-7@ If the macro constants {{tt|FP_FAST_FMAF}}, {{tt|FP_FAST_FMA}}, or {{tt|FP_FAST_FMAL}} are defined, the function {{tt|std::fma}} evaluates faster (in addition to being more precise) than the expression {{c|x*y+z}} for {{c|float}}, {{c|double}}, and {{c|long double}} arguments, respectively. If defined, these macros evaluate to integer {{c|1}}.

===Parameters===
{{par begin}}
{{par | x, y, z | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If successful, returns the value of {{c|(x*y) + z}} as if calculated to infinite precision and rounded once to fit the result type (or, alternatively, calculated as a single ternary floating-point operation)

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If x is zero and y is infinite or if x is infinite and y is zero, and z is not a NaN, then NaN is returned and {{lc|FE_INVALID}} is raised
* If x is zero and y is infinite or if x is infinite and y is zero, and z is a NaN, then NaN is returned and {{lc|FE_INVALID}} may be raised
* If x*y is an exact infinity and z is an infinity with the opposite sign, NaN is returned and {{lc|FE_INVALID}} is raised
* If x or y are NaN, NaN is returned
* If z is NaN, and x*y aren't 0*Inf or Inf*0, then NaN is returned (without FE_INVALID)

===Notes===
This operation is commonly implemented in hardware as [[enwiki:Multiply%E2%80%93accumulate_operation|fused multiply-add]] CPU instruction. If supported by hardware, the appropriate FP_FAST_FMA* macros are expected to be defined, but many implementations make use of the CPU instruction even when the macros are not defined.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fma.html POSIX additionally specifies] that the situations specified to return {{lc|FE_INVALID}} are domain errors.

Due to its infinite intermediate precision, {{tt|fma}} is a common building block of other correctly-rounded mathematical operations, such as {{lc|std::sqrt}} or even the division (where not provided by the CPU, e.g. Itanium)

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    // demo the difference between fma and built-in operators
    double in = 0.1;
    std::cout &lt;&lt; &quot;0.1 double is &quot; &lt;&lt; std::setprecision(23) &lt;&lt; in
              &lt;&lt; &quot; (&quot; &lt;&lt; std::hexfloat &lt;&lt; in &lt;&lt; std::defaultfloat &lt;&lt; &quot;)\n&quot;
              &lt;&lt; &quot;0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3), &quot;
              &lt;&lt; &quot;or 1.0 if rounded to double\n&quot;;
    double expr_result = 0.1 * 10 - 1;
    double fma_result = fma(0.1, 10, -1);
    std::cout &lt;&lt; &quot;0.1 * 10 - 1 = &quot; &lt;&lt; expr_result
              &lt;&lt; &quot; : 1 subtracted after intermediate rounding\n&quot;
              &lt;&lt; &quot;fma(0.1, 10, -1) = &quot; &lt;&lt; std::setprecision(6) &lt;&lt; fma_result &lt;&lt; &quot; (&quot;
              &lt;&lt; std::hexfloat &lt;&lt; fma_result &lt;&lt; std::defaultfloat &lt;&lt; &quot;)\n\n&quot;;

    // fma is used in double-double arithmetic
    double high = 0.1 * 10;
    double low = fma(0.1, 10, -high);
    std::cout &lt;&lt; &quot;in double-double arithmetic, 0.1 * 10 is representable as &quot;
              &lt;&lt; high &lt;&lt; &quot; + &quot; &lt;&lt; low &lt;&lt; &quot;\n\n&quot;;

    // error handling 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;fma(+Inf, 10, -Inf) = &quot; &lt;&lt; std::fma(INFINITY, 10, -INFINITY) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
0.1 double is 0.10000000000000000555112 (0x1.999999999999ap-4)
0.1*10 is 1.0000000000000000555112 (0x8.0000000000002p-3), or 1.0 if rounded to double
0.1 * 10 - 1 = 0 : 1 subtracted after intermediate rounding
fma(0.1, 10, -1) = 5.55112e-17 (0x1p-54)

in double-double arithmetic, 0.1 * 10 is representable as 1 + 5.55112e-17

fma(+Inf, 10, -Inf) = -nan
    FE_INVALID raised

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc see c | c/numeric/math/fma}}
{{dsc end}}

[[de:cpp/numeric/math/fma]]
[[es:cpp/numeric/math/fma]]
[[fr:cpp/numeric/math/fma]]
[[it:cpp/numeric/math/fma]]
[[ja:cpp/numeric/math/fma]]
[[pt:cpp/numeric/math/fma]]
[[ru:cpp/numeric/math/fma]]
[[zh:cpp/numeric/math/fma]]</text>
      <sha1>fdvlf734vm9m0t3fwxw0i9ij0fveanv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fmax</title>
    <ns>0</ns>
    <id>2659</id>
    <revision>
      <id>71700</id>
      <parentid>71699</parentid>
      <timestamp>2014-06-20T20:34:47Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2654">{{cpp/title|fmax}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       fmax( float x, float y );
}}
{{dcl | since=c++11 |num=2|
double      fmax( double x, double y );
}}
{{dcl | since=c++11 |num=3|
long double fmax( long double x, long double y );
}}
{{dcl | since=c++11 |num=4|
Promoted    fmax( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

@1-3@ Returns the larger of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen)
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If successful, returns the larger of two floating point values. The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If one of the two arguments is NaN, the value of the other argument is returned
* Only if both arguments are NaN, NaN is returned

===Notes===
This function is not required to be sensitive to the sign of zero, although some implementations additionally enforce that if one argument is +0 and the other is -0, then +0 is returned.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;fmax(2,1)    = &quot; &lt;&lt; std::fmax(2,1) &lt;&lt; '\n'
              &lt;&lt; &quot;fmax(-Inf,0) = &quot; &lt;&lt; std::fmax(-INFINITY,0) &lt;&lt; '\n'
              &lt;&lt; &quot;fmax(NaN,-1) = &quot; &lt;&lt; std::fmax(NAN,-1) &lt;&lt; '\n';
}
|output=
fmax(2,1)    = 2
fmax(-Inf,0) = 0
fmax(NaN,-1) = -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isgreater}}
{{dsc inc | cpp/numeric/math/dsc fmin}}
{{dsc inc | cpp/algorithm/dsc max}}
{{dsc inc | cpp/algorithm/dsc max_element}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc see c | c/numeric/math/fmax}}
{{dsc end}}

[[de:cpp/numeric/math/fmax]]
[[es:cpp/numeric/math/fmax]]
[[fr:cpp/numeric/math/fmax]]
[[it:cpp/numeric/math/fmax]]
[[ja:cpp/numeric/math/fmax]]
[[pt:cpp/numeric/math/fmax]]
[[ru:cpp/numeric/math/fmax]]
[[zh:cpp/numeric/math/fmax]]</text>
      <sha1>eo19rg0x3k5oqh4djr1lx4h7nssjh16</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fmin</title>
    <ns>0</ns>
    <id>2660</id>
    <revision>
      <id>71701</id>
      <parentid>71215</parentid>
      <timestamp>2014-06-20T20:36:59Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to min, min_element, minmax and minmax_element</comment>
      <text xml:space="preserve" bytes="2666">{{cpp/title|fmin}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float       fmin( float x, float y );
}}
{{dcl | since=c++11 | num=2|
double      fmin( double x, double y );
}}
{{dcl | since=c++11 | num=3|
long double fmin( long double x, long double y );
}}
{{dcl | since=c++11 | num=4|
Promoted    fmin( Arithmetic x, Arithmetic y );
}}
{{dcl end}}

@1-3@ Returns the smaller of two floating point arguments, treating NaNs as missing data (between a NaN and a numeric value, the numeric value is chosen)
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If successful, returns the smaller of two floating point values. The value returned is exact and does not depend on any rounding modes.

===Error handling===
This function is not subject to any of the error conditions specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If one of the two arguments is NaN, the value of the other argument is returned
* Only if both arguments are NaN, NaN is returned

===Notes===
This function is not required to be sensitive to the sign of zero, although some implementations additionally enforce that if one argument is +0 and the other is -0, then -0 is returned.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;fmin(2,1)    = &quot; &lt;&lt; std::fmin(2,1) &lt;&lt; '\n'
              &lt;&lt; &quot;fmin(-Inf,0) = &quot; &lt;&lt; std::fmin(-INFINITY,0) &lt;&lt; '\n'
              &lt;&lt; &quot;fmin(NaN,-1) = &quot; &lt;&lt; std::fmin(NAN,-1) &lt;&lt; '\n';
}
|p=true
|output=
fmin(2,1)    = 1
fmin(-Inf,0) = -inf
fmin(NaN,-1) = -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isless}}
{{dsc inc | cpp/numeric/math/dsc fmax}}
{{dsc inc | cpp/algorithm/dsc min}}
{{dsc inc | cpp/algorithm/dsc min_element}}
{{dsc inc | cpp/algorithm/dsc minmax}}
{{dsc inc | cpp/algorithm/dsc minmax_element}}
{{dsc see c | c/numeric/math/fmin}}
{{dsc end}}

[[de:cpp/numeric/math/fmin]]
[[es:cpp/numeric/math/fmin]]
[[fr:cpp/numeric/math/fmin]]
[[it:cpp/numeric/math/fmin]]
[[ja:cpp/numeric/math/fmin]]
[[pt:cpp/numeric/math/fmin]]
[[ru:cpp/numeric/math/fmin]]
[[zh:cpp/numeric/math/fmin]]</text>
      <sha1>50vufzh171idz279vo18xwah1xhbkrt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fmod</title>
    <ns>0</ns>
    <id>1359</id>
    <revision>
      <id>71787</id>
      <parentid>71692</parentid>
      <timestamp>2014-06-24T01:50:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="4530">{{cpp/title|fmod}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       fmod( float x, float y );
}}
{{dcl |num=2|
double      fmod( double x, double y );
}}
{{dcl |num=3|
long double fmod( long double x, long double y );
}}
{{dcl | since=c++11 |num=4|
Promoted    fmod( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

@1-3@ Computes the floating-point remainder of the division operation {{c|x/y}}.
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3. If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

The floating-point remainder of the division operation {{c|x/y}} calculated by this function is exactly the value {{c|x - n*y}}, where {{tt|n}} is {{c|x/y}} with its fractional part truncated.

The returned value has the same sign as {{tt|x}} and is less or equal to {{tt|y}} in magnitude.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par end}}

===Return value===
If successful, returns the floating-point remainder of the division {{c|x/y}} as defined above.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|x}} is ±0 and {{tt|y}} is not zero, ±0 is returned
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±∞ and {{tt|x}} is finite, {{tt|x}} is returned. 
* If either argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fmod.html  POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

{{tt|std::fmod}}, but not {{lc|std::remainder}} is useful for doing silent wrapping of floating-point types to unsigned integer types: {{c|1=(0.0 &lt;= (y = std::fmod( std::rint(x), 65536.0 )) ? y : 65536.0 + y)}} is in the range {{tt|[-0.0 .. 65535.0]}}, which corresponds to {{c|unsigned short}}, but {{c|std::remainder(std::rint(x), 65536.0}} is in the range {{tt|[-32767.0, +32768.0]}}, which is outside of the range of {{c|signed short}}.

The double version of fmod behaves as if implemented as follows
{{source|1=
double fmod(double x, double y)
{
#pragma STDC FENV_ACCESS ON
    double result = std::remainder(std::fabs(x), (y = std::fabs(y)));
    if (std::signbit(result)) result += y;
    return std::copysign(result, x);
}
}}

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;fmod(+5.1, +3.0) = &quot; &lt;&lt; std::fmod(5.1,3) &lt;&lt; '\n'
              &lt;&lt; &quot;fmod(-5.1, +3.0) = &quot; &lt;&lt; std::fmod(-5.1,3) &lt;&lt; '\n'
              &lt;&lt; &quot;fmod(+5.1, -3.0) = &quot; &lt;&lt; std::fmod(5.1,-3) &lt;&lt; '\n'
              &lt;&lt; &quot;fmod(-5.1, -3.0) = &quot; &lt;&lt; std::fmod(-5.1,-3) &lt;&lt; '\n';

    // special values
    std::cout &lt;&lt; &quot;fmod(+0.0, 1.0) = &quot; &lt;&lt; std::fmod(0, 1) &lt;&lt; '\n'
              &lt;&lt; &quot;fmod(-0.0, 1.0) = &quot; &lt;&lt; std::fmod(-0.0, 1) &lt;&lt; '\n'
              &lt;&lt; &quot;fmod(5.1, Inf) = &quot; &lt;&lt; std::fmod(5.1, INFINITY) &lt;&lt; '\n';

    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;fmod(+5.1, 0) = &quot; &lt;&lt; std::fmod(5.1, 0) &lt;&lt; '\n';
    if(fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
fmod(+5.1, +3.0) = 2.1
fmod(-5.1, +3.0) = -2.1
fmod(+5.1, -3.0) = 2.1
fmod(-5.1, -3.0) = -2.1
fmod(+0.0, 1.0) = 0
fmod(-0.0, 1.0) = -0
fmod(5.1, Inf) = 5.1
fmod(+5.1, 0) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc div}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc see c | c/numeric/math/fmod}}
{{dsc end}}

[[de:cpp/numeric/math/fmod]]
[[es:cpp/numeric/math/fmod]]
[[fr:cpp/numeric/math/fmod]]
[[it:cpp/numeric/math/fmod]]
[[ja:cpp/numeric/math/fmod]]
[[ko:cpp/numeric/math/fmod]]
[[pl:cpp/numeric/math/fmod]]
[[pt:cpp/numeric/math/fmod]]
[[ru:cpp/numeric/math/fmod]]
[[zh:cpp/numeric/math/fmod]]</text>
      <sha1>52shhsipsonhcl6c9lqp59emm77j6jg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/fpclassify</title>
    <ns>0</ns>
    <id>1360</id>
    <revision>
      <id>70401</id>
      <parentid>62850</parentid>
      <timestamp>2014-05-21T21:26:55Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add example and link to C documentation</comment>
      <text xml:space="preserve" bytes="2386">{{cpp/title|fpclassify}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
int fpclassify( float arg );
}}
{{dcl | since=c++11 |
int fpclassify( double arg );
}}
{{dcl | since=c++11 |
int fpclassify( long double arg );
}}
{{dcl end}}

Categorizes floating point value {{tt|arg}} into the following categories: zero, subnormal, normal, infinite, NAN, or implementation-defined category. 

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

one of {{lc|FP_INFINITE}}, {{lc|FP_NAN}}, {{lc|FP_NORMAL}}, {{lc|FP_SUBNORMAL}}, {{lc|FP_ZERO}} or implementation-defined type, specifying the category of {{tt|arg}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfloat&gt;
 
int main() {
    std::cout&lt;&lt;&quot;FP_NAN       = &quot;&lt;&lt;FP_NAN      &lt;&lt;'\n';// 0
    std::cout&lt;&lt;&quot;FP_INFINITE  = &quot;&lt;&lt;FP_INFINITE &lt;&lt;'\n';// 1
    std::cout&lt;&lt;&quot;FP_ZERO      = &quot;&lt;&lt;FP_ZERO     &lt;&lt;'\n';// 2
    std::cout&lt;&lt;&quot;FP_SUBNORMAL = &quot;&lt;&lt;FP_SUBNORMAL&lt;&lt;'\n';// 3
    std::cout&lt;&lt;&quot;FP_NORMAL    = &quot;&lt;&lt;FP_NORMAL   &lt;&lt;'\n';// 4
    std::cout&lt;&lt;'\n';
    std::cout&lt;&lt;&quot;std::fpclassify(NAN)         = &quot;&lt;&lt;std::fpclassify(NAN)        &lt;&lt;'\n';
    std::cout&lt;&lt;&quot;std::fpclassify(INFINITY)    = &quot;&lt;&lt;std::fpclassify(INFINITY)   &lt;&lt;'\n';
    std::cout&lt;&lt;&quot;std::fpclassify(0.f)         = &quot;&lt;&lt;std::fpclassify(0.f)        &lt;&lt;'\n';
    std::cout&lt;&lt;&quot;std::fpclassify(FLT_MIN/2.f) = &quot;&lt;&lt;std::fpclassify(FLT_MIN/2.f)&lt;&lt;'\n';
    std::cout&lt;&lt;&quot;std::fpclassify(1.f)         = &quot;&lt;&lt;std::fpclassify(1.f)        &lt;&lt;'\n';
 
    return 0;
}
 | p=true
 | output=
FP_NAN       = 0
FP_INFINITE  = 1
FP_ZERO      = 2
FP_SUBNORMAL = 3
FP_NORMAL    = 4

fpclassify(NAN)         = 0
fpclassify(INFINITY)    = 1
fpclassify(0.f)         = 2
fpclassify(FLT_MIN/2.f) = 3
fpclassify(1.f)         = 4
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc inc | cpp/types/dsc numeric_limits}}
{{dsc see c | c/numeric/math/fpclassify}}
{{dsc end}}

[[de:cpp/numeric/math/fpclassify]]
[[es:cpp/numeric/math/fpclassify]]
[[fr:cpp/numeric/math/fpclassify]]
[[it:cpp/numeric/math/fpclassify]]
[[ja:cpp/numeric/math/fpclassify]]
[[pt:cpp/numeric/math/fpclassify]]
[[ru:cpp/numeric/math/fpclassify]]
[[zh:cpp/numeric/math/fpclassify]]</text>
      <sha1>aass0paukzkvi7uddiaejdem7j6vpni</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/frexp</title>
    <ns>0</ns>
    <id>1361</id>
    <revision>
      <id>70493</id>
      <parentid>69577</parentid>
      <timestamp>2014-05-24T19:22:29Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1226">{{cpp/title|frexp}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |
float       frexp( float x, int* exp );
}}
{{dcl |
double      frexp( double x, int* exp );
}}
{{dcl |
long double frexp( long double x, int* exp );
}}
{{dcl | since=c++11 |
double      frexp( Integral x, int* exp );
}}
{{dcl end}}

Decomposes given floating point value {{tt|x}} to significand and exponent. 

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | exp | pointer to integer value to store the exponent to}}
{{par end}}

===Return value===

Significand of the given floating point number in the range of {{tt|[0.5; 1)}}. The exponent is put into integer value pointed to by {{tt|exp}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc ldexp}}
{{dsc inc | cpp/numeric/math/dsc logb}}
{{dsc inc | cpp/numeric/math/dsc ilogb}}
{{dsc inc | cpp/numeric/math/dsc modf}}
{{dsc see c | c/numeric/math/frexp}}
{{dsc end}}

[[de:cpp/numeric/math/frexp]]
[[es:cpp/numeric/math/frexp]]
[[fr:cpp/numeric/math/frexp]]
[[it:cpp/numeric/math/frexp]]
[[ja:cpp/numeric/math/frexp]]
[[pt:cpp/numeric/math/frexp]]
[[ru:cpp/numeric/math/frexp]]
[[tr:cpp/numeric/math/frexp]]
[[zh:cpp/numeric/math/frexp]]</text>
      <sha1>p5iucod28elfme83j7wboaarp2o9i43</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/hypot</title>
    <ns>0</ns>
    <id>2949</id>
    <revision>
      <id>70631</id>
      <parentid>70437</parentid>
      <timestamp>2014-05-27T03:57:09Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to cbrt</comment>
      <text xml:space="preserve" bytes="4251">{{cpp/title|hypot}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       hypot( float x, float y );
}}
{{dcl | since=c++11 |num=2|
double      hypot( double x, double y );
}}
{{dcl | since=c++11 |num=3|
long double hypot( long double x, long double y );
}}
{{dcl | since=c++11 | num=4|
Promoted    hypot( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

@1-3@ Computes the square root of the sum of the squares of {{tt|x}} and {{tt|y}}, without undue overflow or underflow at intermediate stages of the computation.
@4@ A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

The value computed by this function is the length of the hypotenuse of a right-angled triangle with sides of length {{tt|x}} and {{tt|y}}, or the distance of the point {{tt|(x,y)}} from the origin {{tt|(0,0)}}, or the magnitude of a complex number {{tt|x+''i''y}}

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If no errors occur, the hypotenuse of a right-angled triangle, {{math|{{mrad|x{{su|p=2}}+y{{su|p=2}}}}}}, is returned.

If a range error due to overflow occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in {{lc|math_errhandling}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{c|hypot(x, y)}}, {{c|hypot(y, x)}}, and {{c|hypot(x, -y)}} are equivalent
* if one of the arguments is ±0, {{tt|hypot}} is equivalent to {{c|fabs}} called with the non-zero argument
* if one of the arguments is ±∞, {{tt|hypot}} returns +∞ even if the other argument is NaN
* otherwise, if any of the arguments is NaN, NaN is returned

===Notes===
Implementations usually guarantee precision of less than 1 ulp (units in the last place): [http://sourceware.org/git/?p=glibc.git;a=blob_plain;f=sysdeps/ieee754/dbl-64/e_hypot.c GNU], [http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/msun/src/e_hypot.c?rev=1.13.4.2;content-type=text%2Fplain BSD], [http://www.open64.net/doc/d5/d3f/hypot_8c-source.html Open64]

{{c|std::hypot(x, y)}} is equivalent to {{c|std::abs(std::complex&lt;double&gt;(x,y))}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/hypot.html POSIX specifies] that underflow may only occur when both arguments are subnormal and the correct result is also subnormal (this forbids naive implementations)
===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cfloat&gt;
#include &lt;cstring&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    // typical usage
    std::cout &lt;&lt; &quot;(1,1) cartesian is (&quot; &lt;&lt; std::hypot(1,1)
              &lt;&lt; ',' &lt;&lt; std::atan2(1,1) &lt;&lt; &quot;) polar\n&quot;;
    // special values
    std::cout &lt;&lt; &quot;hypot(NAN,INFINITY) = &quot; &lt;&lt; std::hypot(NAN,INFINITY) &lt;&lt; '\n';
    // error handling 
    errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;hypot(DBL_MAX,DBL_MAX) = &quot; &lt;&lt; std::hypot(DBL_MAX,DBL_MAX) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno = ERANGE &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
 | output=
(1,1) cartesian is (1.41421,0.785398) polar
hypot(NAN,INFINITY) = inf
hypot(DBL_MAX,DBL_MAX) = inf
    errno = ERANGE Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc cbrt}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc see c | c/numeric/math/hypot}}
{{dsc end}}

[[de:cpp/numeric/math/hypot]]
[[es:cpp/numeric/math/hypot]]
[[fr:cpp/numeric/math/hypot]]
[[it:cpp/numeric/math/hypot]]
[[ja:cpp/numeric/math/hypot]]
[[pt:cpp/numeric/math/hypot]]
[[ru:cpp/numeric/math/hypot]]
[[zh:cpp/numeric/math/hypot]]</text>
      <sha1>5o0s1hewcfirznkvuy6uuc5d378fhix</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/ilogb</title>
    <ns>0</ns>
    <id>3663</id>
    <revision>
      <id>72290</id>
      <parentid>72289</parentid>
      <timestamp>2014-08-04T20:39:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix return type of the template overload</comment>
      <text xml:space="preserve" bytes="5337">{{cpp/title|ilogb}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
int         ilogb( float arg );
}}
{{dcl | since=c++11 | num=2 |
int         ilogb( double arg );
}}
{{dcl | since=c++11 | num=3 |
int         ilogb( long double arg );
}}
{{dcl | since=c++11 | num=4 |
int         ilogb( Integral arg );
}}
{{dcl | since=c++11 | num=5 |
#define FP_ILOGB0 /*implementation-defined*/
}}
{{dcl | since=c++11 | num=6 |
#define FP_ILOGBNAN /*implementation-defined*/
}}
{{dcl end}}

@1-3@ Extracts the value of the unbiased exponent from the floating-point argument {{tt|arg}}, and returns it as a signed integer value. 
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} (the argument is cast to {{c|double}}).
@5@ Expands to integer constant expression whose value is either {{lc|INT_MIN}} or {{c|-INT_MAX}}.
@6@ Expands to integer constant expression whose value is either {{lc|INT_MIN}} or {{c|+INT_MAX}}.

Formally, the unbiased exponent is the integral part of {{math|log{{su|b=r}}{{!}}arg{{!}}}} as a signed integral value, for non-zero {{tt|arg}}, where {{tt|r}} is {{c|std::numeric_limits&lt;T&gt;::radix}} and {{tt|T}} is the floating-point type of {{tt|arg}}.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the unbiased exponent of {{tt|arg}} is returned as a signed int value.

If {{tt|arg}} is zero, {{lc|FP_ILOGB0}} is returned.

If {{tt|arg}} is infinite, {{lc|INT_MAX}} is returned.

If {{tt|arg}} is a NaN, {{lc|FP_ILOGBNAN}} is returned.

If the correct result is greater than {{lc|INT_MAX}} or smaller than {{lc|INT_MIN}}, the return value is unspecified.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

A domain error or range error may occur if {{tt|arg}} is zero, infinite, or NaN.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the correct result is greater than {{lc|INT_MAX}} or smaller than {{lc|INT_MIN}}, {{lc|FE_INVALID}} is raised.
* If {{tt|arg}} is ±0, ±∞, or NaN, {{lc|FE_INVALID}} is raised.
* In all other cases, the result is exact ({{lc|FE_INEXACT}} is never raised) and [[cpp/numeric/fenv/FE_round|the current rounding mode]] is ignored

===Notes===
If {{tt|arg}} is not zero, infinite, or NaN, the value returned is exactly equivalent to {{c|static_cast&lt;int&gt;(std::logb(arg))}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/ilogb.html POSIX requires] that a domain error occurs if {{tt|arg}} is zero, infinite, NaN, or if the correct result is outside of the range of {{c|int}}.

POSIX also requires that, on XSI-conformant systems, the value returned when the correct result is greater than {{lc|INT_MAX}} is {{lc|INT_MAX}} and the value returned when the correct result is less than {{lc|INT_MIN}} is {{lc|INT_MIN}}.

The correct result can be represented as {{c|int}} on all known implementations. For overflow to occur, {{lc|INT_MAX}} must be less than {{c|LDBL_MAX_EXP*log2(FLT_RADIX)}} or {{lc|INT_MIN}} must be greater than {{c|LDBL_MIN_EXP-LDBL_MANT_DIG)*log2(FLT_RADIX)}}.

The value of the exponent returned by {{tt|std::ilogb}} is always 1 less than the exponent retuned by {{lc|std::frexp}} because of the different normalization requirements: for the exponent {{tt|e}} returned by {{tt|std::ilogb}}, {{math|{{!}}arg*r{{su|p=-e}}{{!}}}} is between 1 and {{tt|r}} (typically between {{c|1}} and {{c|2}}), but for the exponent {{tt|e}} returned by {{lc|std::frexp}}, {{math|{{!}}arg*2{{su|p=-e}}{{!}}}} is between {{c|0.5}} and {{c|1}}.

===Example===
{{example
 | Compares different floating-point decomposition functions
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;limits&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    std::cout &lt;&lt; &quot;Given the number &quot; &lt;&lt; f &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat
              &lt;&lt; f &lt;&lt; std::defaultfloat &lt;&lt; &quot; in hex,\n&quot;;

    double f3;
    double f2 = std::modf(f, &amp;f3);
    std::cout &lt;&lt; &quot;modf() makes &quot; &lt;&lt; f3 &lt;&lt; &quot; + &quot; &lt;&lt; f2 &lt;&lt; '\n';

    int i;
    f2 = std::frexp(f, &amp;i);
    std::cout &lt;&lt; &quot;frexp() makes &quot; &lt;&lt; f2 &lt;&lt; &quot; * 2^&quot; &lt;&lt; i &lt;&lt; '\n';

    i = std::ilogb(f);
    std::cout &lt;&lt; &quot;logb()/ilogb() make &quot; &lt;&lt; f/std::scalbn(1.0, i) &lt;&lt; &quot; * &quot;
              &lt;&lt; std::numeric_limits&lt;double&gt;::radix
              &lt;&lt; &quot;^&quot; &lt;&lt; std::ilogb(f) &lt;&lt; '\n';

    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;ilogb(0) = &quot; &lt;&lt; std::ilogb(0) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
 | p=true
 | output=
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
ilogb(0) = -2147483648
    FE_INVALID raised
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc logb}}
{{dsc inc | cpp/numeric/math/dsc scalbn}}
{{dsc see c | c/numeric/math/ilogb}}
{{dsc end}}

[[de:cpp/numeric/math/ilogb]]
[[es:cpp/numeric/math/ilogb]]
[[fr:cpp/numeric/math/ilogb]]
[[it:cpp/numeric/math/ilogb]]
[[ja:cpp/numeric/math/ilogb]]
[[pt:cpp/numeric/math/ilogb]]
[[ru:cpp/numeric/math/ilogb]]
[[zh:cpp/numeric/math/ilogb]]</text>
      <sha1>9bjti72ac1698x0a28oi6kq35rfzax4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isfinite</title>
    <ns>0</ns>
    <id>1362</id>
    <revision>
      <id>70467</id>
      <parentid>62854</parentid>
      <timestamp>2014-05-23T22:24:49Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1104">{{cpp/title|isfinite}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isfinite( float arg );
}}
{{dcl | since=c++11 |
bool isfinite( double arg );
}}
{{dcl | since=c++11 |
bool isfinite( long double arg );
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} has finite value i.e. it is normal, subnormal or zero, but not infinite or {{tt|NAN}}. 

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

{{c|true}} value if {{tt|arg}} has finite value, {{c|false}} otherwise

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc see c | c/numeric/math/isfinite}}
{{dsc end}}

[[de:cpp/numeric/math/isfinite]]
[[es:cpp/numeric/math/isfinite]]
[[fr:cpp/numeric/math/isfinite]]
[[it:cpp/numeric/math/isfinite]]
[[ja:cpp/numeric/math/isfinite]]
[[pt:cpp/numeric/math/isfinite]]
[[ru:cpp/numeric/math/isfinite]]
[[zh:cpp/numeric/math/isfinite]]</text>
      <sha1>oa5i03n7s58rejpesg34vmvyboz7abj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isgreater</title>
    <ns>0</ns>
    <id>9214</id>
    <revision>
      <id>70472</id>
      <parentid>62855</parentid>
      <timestamp>2014-05-23T22:34:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1266">{{cpp/title|isgreater}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isgreater( float x, float y );
}}
{{dcl | since=c++11 |
bool isgreater( double x, double y );
}}
{{dcl | since=c++11 |
bool isgreater( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is greater than the floating-point number ({{tt|y}}), without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{c|x &gt; y}}, {{c|false}} otherwise

===Notes===
The built-in {{c|operator&gt;}} for floating-point numbers may set {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|operator&gt;}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc greater}}
{{dsc inc | cpp/numeric/math/dsc isless}}
{{dsc see c | c/numeric/math/isgreater}}
{{dsc end}}

[[de:cpp/numeric/math/isgreater]]
[[es:cpp/numeric/math/isgreater]]
[[fr:cpp/numeric/math/isgreater]]
[[it:cpp/numeric/math/isgreater]]
[[ja:cpp/numeric/math/isgreater]]
[[pt:cpp/numeric/math/isgreater]]
[[ru:cpp/numeric/math/isgreater]]
[[zh:cpp/numeric/math/isgreater]]</text>
      <sha1>n642v5apsresd1dgxdrpz1o42vmqbq8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isgreaterequal</title>
    <ns>0</ns>
    <id>9215</id>
    <revision>
      <id>70473</id>
      <parentid>62856</parentid>
      <timestamp>2014-05-23T22:36:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1363">{{cpp/title|isgreaterequal}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isgreaterequal( float x, float y );
}}
{{dcl | since=c++11 |
bool isgreaterequal( double x, double y );
}}
{{dcl | since=c++11 |
bool isgreaterequal( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is greater than or equal to the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{c|1=x &gt;= y}}, {{c|false}} otherwise

===Notes===
The built-in {{c|1=operator&gt;=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|1=operator&gt;=}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc greater_equal}}
{{dsc inc | cpp/numeric/math/dsc islessequal}}
{{dsc see c | c/numeric/math/isgreaterequal}}
{{dsc end}}

[[de:cpp/numeric/math/isgreaterequal]]
[[es:cpp/numeric/math/isgreaterequal]]
[[fr:cpp/numeric/math/isgreaterequal]]
[[it:cpp/numeric/math/isgreaterequal]]
[[ja:cpp/numeric/math/isgreaterequal]]
[[pt:cpp/numeric/math/isgreaterequal]]
[[ru:cpp/numeric/math/isgreaterequal]]
[[zh:cpp/numeric/math/isgreaterequal]]</text>
      <sha1>249x16pnktsf8o8bbvo43q7pgo7gaz1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isinf</title>
    <ns>0</ns>
    <id>1363</id>
    <revision>
      <id>70468</id>
      <parentid>62857</parentid>
      <timestamp>2014-05-23T22:26:02Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1004">{{cpp/title|isinf}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isinf( float arg );
}}
{{dcl | since=c++11 |
bool isinf( double arg );
}}
{{dcl | since=c++11 |
bool isinf( long double arg );
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is positive or negative infinity. 

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{tt|arg}} is infinite, {{c|false}} otherwise

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc see c | c/numeric/math/isinf}}
{{dsc end}}

[[de:cpp/numeric/math/isinf]]
[[es:cpp/numeric/math/isinf]]
[[fr:cpp/numeric/math/isinf]]
[[it:cpp/numeric/math/isinf]]
[[ja:cpp/numeric/math/isinf]]
[[pt:cpp/numeric/math/isinf]]
[[ru:cpp/numeric/math/isinf]]
[[zh:cpp/numeric/math/isinf]]</text>
      <sha1>90ndryvdsctbcfl94mwj7s1up0gizcv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isless</title>
    <ns>0</ns>
    <id>9216</id>
    <revision>
      <id>70474</id>
      <parentid>62858</parentid>
      <timestamp>2014-05-23T22:37:17Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1224">{{cpp/title|isless}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isless( float x, float y );
}}
{{dcl | since=c++11 |
bool isless( double x, double y );
}}
{{dcl | since=c++11 |
bool isless( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{c|x &lt; y}}, {{c|false}} otherwise

===Notes===
The built-in {{c|operator&lt;}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|operator&lt;}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc less}}
{{dsc inc | cpp/numeric/math/dsc isgreater}}
{{dsc see c | c/numeric/math/isless}}
{{dsc end}}

[[de:cpp/numeric/math/isless]]
[[es:cpp/numeric/math/isless]]
[[fr:cpp/numeric/math/isless]]
[[it:cpp/numeric/math/isless]]
[[ja:cpp/numeric/math/isless]]
[[pt:cpp/numeric/math/isless]]
[[ru:cpp/numeric/math/isless]]
[[zh:cpp/numeric/math/isless]]</text>
      <sha1>imkz4m6qpox00nryg16txr6rmytlupp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/islessequal</title>
    <ns>0</ns>
    <id>9217</id>
    <revision>
      <id>70475</id>
      <parentid>62859</parentid>
      <timestamp>2014-05-23T22:38:35Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1321">{{cpp/title|islessequal}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool islessequal( float x, float y );
}}
{{dcl | since=c++11 |
bool islessequal( double x, double y );
}}
{{dcl | since=c++11 |
bool islessequal( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than or equal to the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{c|1=x &lt;= y}}, {{c|false}} otherwise

===Notes===
The built-in {{c|1=operator&lt;=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of {{c|1=operator&lt;=}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc less_equal}}
{{dsc inc | cpp/numeric/math/dsc isgreaterequal}}
{{dsc see c | c/numeric/math/islessequal}}
{{dsc end}}

[[de:cpp/numeric/math/islessequal]]
[[es:cpp/numeric/math/islessequal]]
[[fr:cpp/numeric/math/islessequal]]
[[it:cpp/numeric/math/islessequal]]
[[ja:cpp/numeric/math/islessequal]]
[[pt:cpp/numeric/math/islessequal]]
[[ru:cpp/numeric/math/islessequal]]
[[zh:cpp/numeric/math/islessequal]]</text>
      <sha1>dtepfj6hqgqq9hucb1i481zatnzm8ls</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/islessgreater</title>
    <ns>0</ns>
    <id>9218</id>
    <revision>
      <id>70476</id>
      <parentid>62860</parentid>
      <timestamp>2014-05-23T22:42:35Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1384">{{cpp/title|islessgreater}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool islessgreater( float x, float y );
}}
{{dcl | since=c++11 |
bool islessgreater( double x, double y );
}}
{{dcl | since=c++11 |
bool islessgreater( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point number {{tt|x}} is less than or greater than the floating-point number {{tt|y}}, without setting floating-point exceptions.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{c|x &lt; y {{!!}} x &gt; y}}, {{c|false}} otherwise

===Notes===
The built-in {{c|operator&lt;}} and {{c|operator&gt;}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a &quot;quiet&quot; version of the expression {{c|x &lt; y {{!!}} x &gt; y}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isless}}
{{dsc inc | cpp/numeric/math/dsc isgreater}}
{{dsc see c | c/numeric/math/islessgreater}}
{{dsc end}}

[[de:cpp/numeric/math/islessgreater]]
[[es:cpp/numeric/math/islessgreater]]
[[fr:cpp/numeric/math/islessgreater]]
[[it:cpp/numeric/math/islessgreater]]
[[ja:cpp/numeric/math/islessgreater]]
[[pt:cpp/numeric/math/islessgreater]]
[[ru:cpp/numeric/math/islessgreater]]
[[zh:cpp/numeric/math/islessgreater]]</text>
      <sha1>o73mhsb8ka708vcvolrpfp42hh25saz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isnan</title>
    <ns>0</ns>
    <id>1364</id>
    <revision>
      <id>65687</id>
      <parentid>65686</parentid>
      <timestamp>2013-09-26T10:28:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to c too</comment>
      <text xml:space="preserve" bytes="1127">{{cpp/title|isnan}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isnan( float arg );
}}
{{dcl | since=c++11 |
bool isnan( double arg );
}}
{{dcl | since=c++11 |
bool isnan( long double arg );
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is not-a-number ({{tt|NaN}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{tt|arg}} is {{c|NaN}}, {{c|false}} otherwise

===Notes===
In C, {{c|isnan}} is a preprocessor macro, rather than a function.

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnormal}}
{{dsc inc | cpp/numeric/math/dsc isunordered}}
{{dsc see c | c/numeric/math/isnan}}
{{dsc end}}

[[de:cpp/numeric/math/isnan]]
[[es:cpp/numeric/math/isnan]]
[[fr:cpp/numeric/math/isnan]]
[[it:cpp/numeric/math/isnan]]
[[ja:cpp/numeric/math/isnan]]
[[pt:cpp/numeric/math/isnan]]
[[ru:cpp/numeric/math/isnan]]
[[zh:cpp/numeric/math/isnan]]</text>
      <sha1>jcebs3aiidmu8pre49sfmnnpqedul92</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isnormal</title>
    <ns>0</ns>
    <id>1365</id>
    <revision>
      <id>70470</id>
      <parentid>62862</parentid>
      <timestamp>2014-05-23T22:28:59Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1075">{{cpp/title|isnormal}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isnormal( float arg );
}}
{{dcl | since=c++11 |
bool isnormal( double arg );
}}
{{dcl | since=c++11 |
bool isnormal( long double arg );
}}
{{dcl end}}

Determines if the given floating point number {{tt|arg}} is normal, i.e. is neither zero, subnormal, infinite, nor {{tt|NaN}}.  

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{tt|arg}} is normal, {{c|false}} otherwise

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isfinite}}
{{dsc inc | cpp/numeric/math/dsc isinf}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc see c | c/numeric/math/isnormal}}
{{dsc end}}

[[de:cpp/numeric/math/isnormal]]
[[es:cpp/numeric/math/isnormal]]
[[fr:cpp/numeric/math/isnormal]]
[[it:cpp/numeric/math/isnormal]]
[[ja:cpp/numeric/math/isnormal]]
[[pt:cpp/numeric/math/isnormal]]
[[ru:cpp/numeric/math/isnormal]]
[[zh:cpp/numeric/math/isnormal]]</text>
      <sha1>k10eu7hly5dxyoo5pn5h7646grqgwdn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/isunordered</title>
    <ns>0</ns>
    <id>9219</id>
    <revision>
      <id>70477</id>
      <parentid>62863</parentid>
      <timestamp>2014-05-23T22:44:01Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1140">{{cpp/title|isunordered}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool isunordered( float x, float y );
}}
{{dcl | since=c++11 |
bool isunordered( double x, double y );
}}
{{dcl | since=c++11 |
bool isunordered( long double x, long double y );
}}
{{dcl end}}

Determines if the floating point numbers {{tt|x}} and {{tt|y}} are unordered, that is, one or both are NaN and thus cannot be meaningfully compared with each other.

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | y | floating point value}}
{{par end}}

===Return value===

{{c|true}} if either {{tt|x}} or {{tt|y}} is NaN, {{c|false}} otherwise

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc see c | c/numeric/math/isunordered}}
{{dsc end}}

[[de:cpp/numeric/math/isunordered]]
[[es:cpp/numeric/math/isunordered]]
[[fr:cpp/numeric/math/isunordered]]
[[it:cpp/numeric/math/isunordered]]
[[ja:cpp/numeric/math/isunordered]]
[[pt:cpp/numeric/math/isunordered]]
[[ru:cpp/numeric/math/isunordered]]
[[zh:cpp/numeric/math/isunordered]]</text>
      <sha1>fxbi50f05imttm0tiyycenrytna00el</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/labs</title>
    <ns>0</ns>
    <id>4037</id>
    <redirect title="cpp/numeric/math/abs" />
    <revision>
      <id>14893</id>
      <timestamp>2011-12-01T14:39:21Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/abs]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/ldexp</title>
    <ns>0</ns>
    <id>1366</id>
    <revision>
      <id>72168</id>
      <parentid>72072</parentid>
      <timestamp>2014-07-19T22:14:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3824">{{cpp/title|ldexp}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       ldexp( float x, int exp );
}}
{{dcl |num=2|
double      ldexp( double x, int exp );
}}
{{dcl |num=3|
long double ldexp( long double x, int exp );
}}
{{dcl | since=c++11 |num=4|
double      ldexp( Integral x, int exp );
}}
{{dcl end}}

@1-3@ Multiplies a floating point value {{tt|x}} by the number {{tt|2}} raised to the {{tt|exp}} power.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | exp | integer value}}
{{par end}}

===Return value===
If no errors occur, {{tt|x}} multiplied by 2 to the power of {{tt|exp}} ({{math|x&amp;times;2{{su|p=exp}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* Unless a range error occurs, {{lc|FE_INEXACT}} is never raised (the result is exact)
* Unless a range error occurs, [[cpp/numeric/fenv/FE_round|the current rounding mode]] is ignored
* If {{tt|x}} is ±0, it is returned, unmodified
* If {{tt|x}} is ±∞, it is returned, unmodified
* If {{tt|exp}} is 0, then {{tt|x}} is returned, unmodified
* If {{tt|x}} is NaN, NaN is returned

===Notes===
On binary systems (where {{lc|FLT_RADIX}} is {{tt|2}}), {{tt|std::ldexp}} is equivalent to {{lc|std::scalbn}}.

The function {{tt|std::ldexp}} (&quot;load exponent&quot;), together with its dual, {{lc|std::frexp}}, can be used to manipulate the representation of a floating-point number without direct bit manipulations.

On many implementations, {{tt|std::ldexp}} is less efficient than multiplication or division by a power of two using arithmetic operators.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;ldexp(7, -4) = &quot; &lt;&lt; std::ldexp(7, -4) &lt;&lt; '\n'
              &lt;&lt; &quot;ldexp(1, -1074) = &quot; &lt;&lt; std::ldexp(1, -1074)
              &lt;&lt; &quot; (minimum positive subnormal double)\n&quot;
              &lt;&lt; &quot;ldexp(nextafter(1,0), 1024) = &quot;
              &lt;&lt; std::ldexp(std::nextafter(1,0), 1024)
              &lt;&lt; &quot; (largest finite double)\n&quot;;
    // special values
    std::cout &lt;&lt; &quot;ldexp(-0, 10) = &quot; &lt;&lt; std::ldexp(-0.0, 10) &lt;&lt; '\n'
              &lt;&lt; &quot;ldexp(-Inf, -1) = &quot; &lt;&lt; std::ldexp(-INFINITY, -1) &lt;&lt; '\n';
    // error handling
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;ldexp(1, 1024) = &quot; &lt;&lt; std::ldexp(1, 1024) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|output=
ldexp(7, -4) = 0.4375
ldexp(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
ldexp(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
ldexp(-0, 10) = -0
ldexp(-Inf, -1) = -inf
ldexp(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc scalbn}}
{{dsc see c | c/numeric/math/ldexp}}
{{dsc end}}

[[de:cpp/numeric/math/ldexp]]
[[es:cpp/numeric/math/ldexp]]
[[fr:cpp/numeric/math/ldexp]]
[[it:cpp/numeric/math/ldexp]]
[[ja:cpp/numeric/math/ldexp]]
[[pt:cpp/numeric/math/ldexp]]
[[ru:cpp/numeric/math/ldexp]]
[[zh:cpp/numeric/math/ldexp]]</text>
      <sha1>ec1iz8itpzklohgbby39yzte2gt0cfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/ldiv</title>
    <ns>0</ns>
    <id>4039</id>
    <redirect title="cpp/numeric/math/div" />
    <revision>
      <id>14895</id>
      <timestamp>2011-12-01T14:39:32Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/div]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/lgamma</title>
    <ns>0</ns>
    <id>2948</id>
    <revision>
      <id>71181</id>
      <parentid>67148</parentid>
      <timestamp>2014-06-07T20:20:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, +example</comment>
      <text xml:space="preserve" bytes="4271">{{cpp/title|lgamma}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       lgamma( float arg );
}}
{{dcl | since=c++11 |num=2|
double      lgamma( double arg );
}}
{{dcl | since=c++11 |num=3|
long double lgamma( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      lgamma( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the natural logarithm of the absolute value of the [[enwiki:Gamma function|gamma function]] of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the value of the logarithm of the gamma function of {{tt|arg}}, that is {{math|log{{su|b=e}}{{!}}{{minteg|0|∞|''t''{{su|p=arg-1}} {{mexp|-t}} d''t''}}{{!}}}}, is returned.

If a pole error occurs, {{tt|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If {{tt|arg}} is zero or is an integer less than zero, a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is 1, +0 is returned
* If the argument is 2, +0 is returned
* If the argument is ±0, +∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is a negative integer, +∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is ±∞, +∞ is returned.
* If the argument is NaN, NaN is returned

===Notes===
If {{tt|arg}} is a natural number, {{c|std::lgamma(arg)}} is the logarithm of the factorial of {{tt|arg-1}}.

The [http://pubs.opengroup.org/onlinepubs/9699919799/functions/lgamma.html POSIX version of lgamma] is not thread-safe: each execution of the function stores the sign of the gamma function of {{tt|arg}} in the static external variable {{tt|signgam}}. Some implementations provide {{tt|lgamma_r}}, which takes a pointer to user-provided storage for singgam as the second parameter, and is thread-safe.

There is a non-standard function named {{tt|gamma}} in various implementations, but its definition is inconsistent. For example, glibc and 4.2BSD version of {{tt|gamma}} executes {{tt|lgamma}}, but 4.4BSD version of {{tt|gamma}} executes {{tt|tgamma}}.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1);
int main()
{
    std::cout &lt;&lt; &quot;lgamma(10) = &quot; &lt;&lt; std::lgamma(10)
              &lt;&lt; &quot;,  log(9!) = &quot; &lt;&lt; std::log(2*3*4*5*6*7*8*9) &lt;&lt; '\n'
              &lt;&lt; &quot;lgamma(0.5) = &quot; &lt;&lt; std::lgamma(0.5)
              &lt;&lt; &quot; , log(sqrt(pi)) = &quot; &lt;&lt; std::log(std::sqrt(pi)) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;lgamma(1) = &quot; &lt;&lt; std::lgamma(1) &lt;&lt; '\n'
              &lt;&lt; &quot;lgamma(+Inf) = &quot; &lt;&lt; std::lgamma(INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;lgamma(0) = &quot; &lt;&lt; std::lgamma(0) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
| output=
lgamma(10) = 12.8018,  log(9!) = 12.8018
lgamma(0.5) = 0.572365 , log(sqrt(pi)) = 0.572365
lgamma(1) = 0
lgamma(+Inf) = inf
lgamma(0) = inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc tgamma}}
{{dsc see c | c/numeric/math/lgamma}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/LogGammaFunction.html Weisstein, Eric W. &quot;Log Gamma Function.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/lgamma]]
[[es:cpp/numeric/math/lgamma]]
[[fr:cpp/numeric/math/lgamma]]
[[it:cpp/numeric/math/lgamma]]
[[ja:cpp/numeric/math/lgamma]]
[[pt:cpp/numeric/math/lgamma]]
[[ru:cpp/numeric/math/lgamma]]
[[zh:cpp/numeric/math/lgamma]]</text>
      <sha1>c60ndigf7i9q2tsymsr8a8q6dcfdutr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/llabs</title>
    <ns>0</ns>
    <id>4038</id>
    <redirect title="cpp/numeric/math/abs" />
    <revision>
      <id>14894</id>
      <timestamp>2011-12-01T14:39:26Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/abs]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/lldiv</title>
    <ns>0</ns>
    <id>4040</id>
    <redirect title="cpp/numeric/math/div" />
    <revision>
      <id>14896</id>
      <timestamp>2011-12-01T14:39:39Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/div]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/llrint</title>
    <ns>0</ns>
    <id>4033</id>
    <redirect title="cpp/numeric/math/rint" />
    <revision>
      <id>14889</id>
      <timestamp>2011-12-01T14:37:37Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/rint]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/rint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/llround</title>
    <ns>0</ns>
    <id>4035</id>
    <redirect title="cpp/numeric/math/round" />
    <revision>
      <id>14891</id>
      <timestamp>2011-12-01T14:38:25Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/round]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/log</title>
    <ns>0</ns>
    <id>1367</id>
    <revision>
      <id>70701</id>
      <parentid>70621</parentid>
      <timestamp>2014-05-29T01:40:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>detail, longer example</comment>
      <text xml:space="preserve" bytes="3099">{{cpp/title|log}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       log( float arg );
}}
{{dcl |num=2|
double      log( double arg );
}}
{{dcl |num=3|
long double log( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      log( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the the natural (base ''e'') logarithm of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the natural (base-''e'') logarithm of {{tt|arg}} ({{math|ln(arg)}} or {{math|log{{su|b=e}}(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;log(1) = &quot; &lt;&lt; std::log(1) &lt;&lt; '\n'
              &lt;&lt; &quot;base-5 logarithm of 125 = &quot; &lt;&lt; std::log(125)/std::log(5) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;log(1) = &quot; &lt;&lt; std::log(1) &lt;&lt; '\n'
              &lt;&lt; &quot;log(+Inf) = &quot; &lt;&lt; std::log(INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;log(0) = &quot; &lt;&lt; std::log(0) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
 | p=true
 | output=
log(1) = 0
base-5 logarithm of 125 = 3
log(1) = 0
log(+Inf) = inf
log(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc inc | cpp/numeric/math/dsc log1p}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc see c | c/numeric/math/log}}
{{dsc end}}

[[de:cpp/numeric/math/log]]
[[es:cpp/numeric/math/log]]
[[fr:cpp/numeric/math/log]]
[[it:cpp/numeric/math/log]]
[[ja:cpp/numeric/math/log]]
[[pl:cpp/numeric/math/log]]
[[pt:cpp/numeric/math/log]]
[[ru:cpp/numeric/math/log]]
[[zh:cpp/numeric/math/log]]</text>
      <sha1>7j09t4vqf2l9xlqxb39ikxfvqh7dguq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/log10</title>
    <ns>0</ns>
    <id>1368</id>
    <revision>
      <id>71148</id>
      <parentid>70633</parentid>
      <timestamp>2014-06-07T04:16:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, example</comment>
      <text xml:space="preserve" bytes="3202">{{cpp/title|log10}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       log10( float arg );
}}
{{dcl |num=2|
double      log10( double arg );
}}
{{dcl |num=3|
long double log10( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      log10( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the common (base-''10'') logarithm of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the common (base-''10'') logarithm of {{tt|arg}} ({{math|log{{su|b=10}}(arg)}} or {{math|lg(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;log10(1000) = &quot; &lt;&lt; std::log10(1000) &lt;&lt; '\n'
              &lt;&lt; &quot;log10(0.001) = &quot; &lt;&lt; std::log10(0.001) &lt;&lt; '\n'
              &lt;&lt; &quot;base-5 logarithm of 125 = &quot; &lt;&lt; std::log10(125)/std::log10(5) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;log10(1) = &quot; &lt;&lt; std::log10(1) &lt;&lt; '\n'
              &lt;&lt; &quot;log10(+Inf) = &quot; &lt;&lt; std::log10(INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;log10(0) = &quot; &lt;&lt; std::log10(0) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
|p=true
|output=
log10(1000) = 3
log10(0.001) = -3
base-5 logarithm of 125 = 3
log10(1) = 0
log10(+Inf) = inf
log10(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc inc | cpp/numeric/math/dsc log1p}}
{{dsc inc | cpp/numeric/complex/dsc log10}}
{{dsc inc | cpp/numeric/valarray/dsc log10}}
{{dsc see c | c/numeric/math/log10}}
{{dsc end}}

[[de:cpp/numeric/math/log10]]
[[es:cpp/numeric/math/log10]]
[[fr:cpp/numeric/math/log10]]
[[it:cpp/numeric/math/log10]]
[[ja:cpp/numeric/math/log10]]
[[pl:cpp/numeric/math/log10]]
[[pt:cpp/numeric/math/log10]]
[[ru:cpp/numeric/math/log10]]
[[zh:cpp/numeric/math/log10]]</text>
      <sha1>125i93yllf9kx1a35idh94pxfc9mj1s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/log1p</title>
    <ns>0</ns>
    <id>3662</id>
    <revision>
      <id>70938</id>
      <parentid>70937</parentid>
      <timestamp>2014-06-03T19:40:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>more self-fix</comment>
      <text xml:space="preserve" bytes="3859">{{cpp/title|log1p}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       log1p( float arg );
}}
{{dcl | since=c++11 |num=2|
double      log1p( double arg );
}}
{{dcl | since=c++11 |num=3|
long double log1p( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      log1p( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the natural (base {{c|e}}) logarithm of {{c|1+arg}}. This function is more precise than the expression {{c|std::log(1+arg)}} if {{tt|arg}} is close to zero.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur {{math|ln(1+arg)}} is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than {{math|-1}}.

Pole error may occur if {{tt|arg}} is {{math|-1}}.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, it is returned unmodified
* If the argument is -1, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is less than -1, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
The functions {{lc|std::expm1}} and {{tt|std::log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1+x){{su|p=n}}-1}} can be expressed as {{c|std::expm1(n * std::log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cfenv&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;log1p(0) = &quot; &lt;&lt; log1p(0) &lt;&lt; '\n'
              &lt;&lt; &quot;Interest earned in 2 days on on $100, compounded daily at 1%\n&quot;
              &lt;&lt; &quot; on a 30/360 calendar = &quot;
              &lt;&lt; 100*expm1(2*log1p(0.01/360)) &lt;&lt; '\n'
              &lt;&lt; &quot;log(1+1e-16) = &quot; &lt;&lt; std::log(1+1e-16)
              &lt;&lt; &quot; log1p(1e-16) = &quot; &lt;&lt; std::log1p(1e-16) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;log1p(-0) = &quot; &lt;&lt; std::log1p(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;log1p(+Inf) = &quot; &lt;&lt; std::log1p(INFINITY) &lt;&lt; '\n';
    // error handling
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;log1p(-1) = &quot; &lt;&lt; std::log1p(-1) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
|p=true
|output=
log1p(0) = 0
Interest earned in 2 days on on $100, compounded daily at 1%
 on a 30/360 calendar = 0.00555563
log(1+1e-16) = 0 log1p(1e-16) = 1e-16
log1p(-0) = -0
log1p(+Inf) = inf
log1p(-1) = -inf
    errno == ERANGE: Result too large
    FE_DIVBYZERO raised
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/math/dsc log2}}
{{dsc inc | cpp/numeric/math/dsc expm1}}
{{dsc see c | c/numeric/math/log1p}}
{{dsc end}}

[[de:cpp/numeric/math/log1p]]
[[es:cpp/numeric/math/log1p]]
[[fr:cpp/numeric/math/log1p]]
[[it:cpp/numeric/math/log1p]]
[[ja:cpp/numeric/math/log1p]]
[[pt:cpp/numeric/math/log1p]]
[[ru:cpp/numeric/math/log1p]]
[[zh:cpp/numeric/math/log1p]]</text>
      <sha1>sfxhjqjn5i38eocauwoxnureuyynjhe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/log2</title>
    <ns>0</ns>
    <id>4902</id>
    <revision>
      <id>71151</id>
      <parentid>70623</parentid>
      <timestamp>2014-06-07T04:33:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, +example</comment>
      <text xml:space="preserve" bytes="3441">{{cpp/title|log2}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       log2( float arg );
}}
{{dcl | since=c++11 |num=2|
double      log2( double arg );
}}
{{dcl | since=c++11 |num=3|
long double log2( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      log2( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the binary (base-''2'') logarithm of {{c|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the base-''2'' logarithm of {{tt|arg}} ({{math|log{{su|b=2}}(arg)}} or {{math|lb(arg)}}) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error occurs if {{tt|arg}} is less than zero.

Pole error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If the argument is 1, +0 is returned
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
* If the argument is +∞, +∞ is returned
* If the argument is NaN, NaN is returned

===Notes===
For integer {{tt|arg}}, the binary logarithm can be interpreted as the zero-based index of the most significant 1 bit in the input.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;log2(65536) = &quot; &lt;&lt; std::log2(65536) &lt;&lt; '\n'
              &lt;&lt; &quot;log2(0.125) = &quot; &lt;&lt; std::log2(0.125) &lt;&lt; '\n'
              &lt;&lt; &quot;log2(0x020f) = &quot; &lt;&lt; std::log2(0x020f)
              &lt;&lt; &quot; (highest set bit is in position 9)\n&quot;
              &lt;&lt; &quot;base-5 logarithm of 125 = &quot; &lt;&lt; std::log2(125)/std::log2(5) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;log2(1) = &quot; &lt;&lt; std::log2(1) &lt;&lt; '\n'
              &lt;&lt; &quot;log2(+Inf) = &quot; &lt;&lt; std::log2(INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;log2(0) = &quot; &lt;&lt; std::log2(0) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
|p=true
|output=
log2(65536) = 16
log2(0.125) = -3
log2(0x020f) = 9.04166 (highest set bit is in position 9)
base-5 logarithm of 125 = 3
log2(1) = 0
log2(+Inf) = inf
log2(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/math/dsc log1p}}
{{dsc inc | cpp/numeric/math/dsc exp2}}
{{dsc see c | c/numeric/math/log2}}
{{dsc end}}

[[de:cpp/numeric/math/log2]]
[[es:cpp/numeric/math/log2]]
[[fr:cpp/numeric/math/log2]]
[[it:cpp/numeric/math/log2]]
[[ja:cpp/numeric/math/log2]]
[[pt:cpp/numeric/math/log2]]
[[ru:cpp/numeric/math/log2]]
[[zh:cpp/numeric/math/log2]]</text>
      <sha1>1uczfastgrsrj0d4rufxncv1vtq6vjx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/logb</title>
    <ns>0</ns>
    <id>3664</id>
    <revision>
      <id>72316</id>
      <parentid>70499</parentid>
      <timestamp>2014-08-07T22:25:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail</comment>
      <text xml:space="preserve" bytes="4199">{{cpp/title|logb}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float       logb( float arg );
}}
{{dcl | since=c++11 | num=2|
double      logb( double arg );
}}
{{dcl | since=c++11 | num=3|
long double logb( long double arg );
}}
{{dcl | since=c++11 | num=4|
double      logb( Integral arg );
}}
{{dcl end}}

@1-3@ Extracts the value of the unbiased radix-independent exponent from the floating-point argument {{tt|arg}}, and returns it as a floating-point value.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} (the argument is cast to {{c|double}}).

Formally, the unbiased exponent is the signed integral part of {{math|log{{su|b=r}}{{!}}arg{{!}}}} (returned by this function as a floating-point value), for non-zero arg, where {{tt|r}} is {{c|std::numeic_limits&lt;T&gt;::radix}} and {{tt|T}} is the floating-point type of {{tt|arg}}. If {{tt|arg}} is subnormal, it is treated as though it was normalized.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the unbiased exponent of {{tt|arg}} is returned as a signed floating-point value.

If a domain error occurs, an implementation-defined value is returned

If a pole error occurs, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain or range error may occur if {{tt|arg}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If {{tt|arg}} is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
* If {{tt|arg}} is ±∞, +∞ is returned
* If {{tt|arg}} is NaN, NaN is returned.
* In all other cases, the result is exact ({{lc|FE_INEXACT}} is never raised) and [[cpp/numeric/fenv/FE_round|the current rounding mode]] is ignored

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/logb.html POSIX requires] that a pole error occurs if {{tt|arg}} is ±0.

The value of the exponent returned by {{tt|std::logb}} is always 1 less than the exponent retuned by {{lc|std::frexp}} because of the different normalization requirements: for the exponent {{tt|e}} returned by {{tt|std::logb}}, {{math|{{!}}arg*r{{su|p=-e}}{{!}}}} is between 1 and {{tt|r}} (typically between {{c|1}} and {{c|2}}), but for the exponent {{tt|e}} returned by {{lc|std::frexp}}, {{math|{{!}}arg*2{{su|p=-e}}{{!}}}} is between {{c|0.5}} and {{c|1}}.

===Example===
{{example
 | Compares different floating-point decomposition functions
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;limits&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    double f = 123.45;
    std::cout &lt;&lt; &quot;Given the number &quot; &lt;&lt; f &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat
              &lt;&lt; f &lt;&lt; std::defaultfloat &lt;&lt; &quot; in hex,\n&quot;;

    double f3;
    double f2 = std::modf(f, &amp;f3);
    std::cout &lt;&lt; &quot;modf() makes &quot; &lt;&lt; f3 &lt;&lt; &quot; + &quot; &lt;&lt; f2 &lt;&lt; '\n';

    int i;
    f2 = std::frexp(f, &amp;i);
    std::cout &lt;&lt; &quot;frexp() makes &quot; &lt;&lt; f2 &lt;&lt; &quot; * 2^&quot; &lt;&lt; i &lt;&lt; '\n';

    i = std::ilogb(f);
    std::cout &lt;&lt; &quot;logb()/ilogb() make &quot; &lt;&lt; f/std::scalbn(1.0, i) &lt;&lt; &quot; * &quot;
              &lt;&lt; std::numeric_limits&lt;double&gt;::radix
              &lt;&lt; &quot;^&quot; &lt;&lt; std::ilogb(f) &lt;&lt; '\n';

    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;logb(0) = &quot; &lt;&lt; std::logb(0) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
 | p=true
 | output=
Given the number 123.45 or 0x1.edccccccccccdp+6 in hex,
modf() makes 123 + 0.45
frexp() makes 0.964453 * 2^7
logb()/ilogb() make 1.92891 * 2^6
logb(0) = -Inf
    FE_DIVBYZERO raised
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc ilogb}}
{{dsc inc | cpp/numeric/math/dsc scalbn}}
{{dsc see c | c/numeric/math/logb}}
{{dsc end}}

[[de:cpp/numeric/math/logb]]
[[es:cpp/numeric/math/logb]]
[[fr:cpp/numeric/math/logb]]
[[it:cpp/numeric/math/logb]]
[[ja:cpp/numeric/math/logb]]
[[pt:cpp/numeric/math/logb]]
[[ru:cpp/numeric/math/logb]]
[[zh:cpp/numeric/math/logb]]</text>
      <sha1>ief9o2wbgv2vv87bq5qy0vw3sslny33</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/lrint</title>
    <ns>0</ns>
    <id>4034</id>
    <redirect title="cpp/numeric/math/rint" />
    <revision>
      <id>14890</id>
      <timestamp>2011-12-01T14:38:02Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/rint]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/rint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/lround</title>
    <ns>0</ns>
    <id>4036</id>
    <redirect title="cpp/numeric/math/round" />
    <revision>
      <id>14892</id>
      <timestamp>2011-12-01T14:38:53Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/round]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/numeric/math/round]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/math errhandling</title>
    <ns>0</ns>
    <id>9220</id>
    <revision>
      <id>70432</id>
      <parentid>70194</parentid>
      <timestamp>2014-05-22T15:23:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>inexact result isn't technically a range error</comment>
      <text xml:space="preserve" bytes="4258">{{title|MATH_ERRNO, MATH_ERREXCEPT, math_errhandling}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
#define MATH_ERRNO        1
}}
{{dcl | since=c++11 |
#define MATH_ERREXCEPT    2
}}
{{dcl | since=c++11 |
#define math_errhandling  /*implementation defined*/
}}
{{dcl end}}

The macro constant {{tt|math_errhandling}} expands to an expression of type {{c|int}} that is either equal to {{tt|MATH_ERRNO}}, or equal to {{tt|MATH_ERREXCEPT}}, or equal to their bitwise OR ({{c|MATH_ERRNO {{!}} MATH_ERREXCEPT}}).

The value of {{tt|math_errhandling}} indicates the type of error handling that is performed by the floating-point operators and [[cpp/numeric/math|functions]]:

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|MATH_ERREXCEPT}} | indicates that floating-point exceptions are used: at least {{lc|FE_DIVBYZERO}}, {{lc|FE_INVALID}}, and {{lc|FE_OVERFLOW}} are defined in {{c|&lt;cfenv&gt;}}.}}
{{dsc | {{tt|MATH_ERRNO}} | indicates that floating-point operations use the variable {{lc|errno}} to report errors.}}
{{dsc end}}

If the implementation supports IEEE floating-point arithmetic (IEC 60559), {{c|math_errhandling &amp; MATH_ERREXCEPT}} is required to be non-zero.

The following floating-point error conditions are recognized:

{|table class=wikitable
|-
!Condition||Explanation||errno||floating-point exception||Example
|-
|Domain error
|the argument is outside the range in which the operation is mathematically defined (the description of [[cpp/numeric/math|each function]] lists the required domain errors)
|{{lc|EDOM}}
|{{lc|FE_INVALID}}
|{{c|std::acos(2)}}
|-
|Pole error
|the mathematical result of the function is exactly infinite or undefined
|{{lc|ERANGE}}
|{{lc|FE_DIVBYZERO}}
|{{c|std::log(0.0)}}, {{c|1.0/0.0}}
|-
|Range error due to overflow
|the mathematical result is finite, but becomes infinite after rounding, or becomes the largest representable finite value after rounding down
|{{lc|ERANGE}}
|{{lc|FE_OVERFLOW}}
|{{c|std::pow(DBL_MAX,2)}}
|-
|Range error due to underflow
|the result is non-zero, but becomes zero after rounding, or becomes subnormal with a loss of precision
|{{lc|ERANGE}} or unchanged (implementation-defined)
|{{lc|FE_UNDERFLOW}} or nothing (implementation-defined)
|{{c|DBL_MIN/2}}
|-
|Inexact result
|the result has to be rounded to fit in the destination type
|unchanged
|{{lc|FE_INEXACT}} or nothing (unspecified)
|{{c|std::sqrt(2)}}, {{c|1.0/10.0}}
|}

===Notes===
Whether {{lc|FE_INEXACT}} is raised by the mathematical library functions is unspecified in general, but may be explicitly specified in the description of the function (e.g. {{lc|std::rint}} vs {{lc|std::nearbyint}})

Before C++11, floating-point exceptions were not specified, {{c|EDOM}} was required for any domain error, {{c|ERANGE}} was required for overflows and implementation-defined for underflows.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cfenv&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;MATH_ERRNO is &quot;
              &lt;&lt; (math_errhandling &amp; MATH_ERRNO ? &quot;set&quot; : &quot;not set&quot;) &lt;&lt; '\n'
              &lt;&lt; &quot;MATH_ERREXCEPT is &quot;
              &lt;&lt; (math_errhandling &amp; MATH_ERREXCEPT ? &quot;set&quot; : &quot;not set&quot;) &lt;&lt; '\n';
    std::feclearexcept(FE_ALL_EXCEPT);
    errno = 0;
    std::cout &lt;&lt;  &quot;log(0) = &quot; &lt;&lt; std::log(0) &lt;&lt; '\n';
    if(errno == ERANGE)
            std::cout &lt;&lt; &quot;errno = ERANGE (&quot; &lt;&lt; std::strerror(errno) &lt;&lt; &quot;)\n&quot;;
    if(std::fetestexcept(FE_DIVBYZERO))
        std::cout &lt;&lt; &quot;FE_DIVBYZERO (pole error) reported\n&quot;;
}
 | p=true
 | output=
MATH_ERRNO is set
MATH_ERREXCEPT is set
log(0) = -inf
errno = ERANGE (Numerical result out of range)
FE_DIVBYZERO (pole error) reported
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/fenv/dsc FE_exceptions}}
{{dsc inc | cpp/error/dsc errno}}
{{dsc see c | c/numeric/math/math_errhandling}}
{{dsc end}}

[[de:cpp/numeric/math/math errhandling]]
[[es:cpp/numeric/math/math errhandling]]
[[fr:cpp/numeric/math/math errhandling]]
[[it:cpp/numeric/math/math errhandling]]
[[ja:cpp/numeric/math/math errhandling]]
[[pt:cpp/numeric/math/math errhandling]]
[[ru:cpp/numeric/math/math errhandling]]
[[zh:cpp/numeric/math/math errhandling]]</text>
      <sha1>mwmpb25di328jg461koiatjzch8drqx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/modf</title>
    <ns>0</ns>
    <id>3665</id>
    <revision>
      <id>70495</id>
      <parentid>58626</parentid>
      <timestamp>2014-05-24T19:24:35Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="1743">{{cpp/title|modf}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |
float       modf( float x, float* iptr );
}}
{{dcl |
double      modf( double x, double* iptr );
}}
{{dcl |
long double modf( long double x, long double* iptr );
}}
{{dcl end}}

Decomposes given floating point value {{tt|x}} into integral and fractional parts, each having the same type and sign as {{tt|x}}. The integral part (in floating-point format) is stored in the object pointed to by {{tt|iptr}}.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par | iptr | pointer to floating point value to store the integral part to}}
{{par end}}

===Return value===

The fractional part of {{tt|x}} with the same sign as {{tt|x}}. The integral part is put into the value pointed to by {{tt|iptr}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
int main()
{
    double f = 123.45;
    double f3;
    double f2 = std::modf(f, &amp;f3);
    std::cout &lt;&lt; &quot;Given the number &quot; &lt;&lt; f  &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;modf() makes &quot; &lt;&lt; f3 &lt;&lt; &quot; and &quot; &lt;&lt; f2 &lt;&lt; '\n';

    f = -3.21;
    f2 = std::modf(f, &amp;f3);
    std::cout &lt;&lt; &quot;Given the number &quot; &lt;&lt; f  &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;modf() makes &quot; &lt;&lt; f3 &lt;&lt; &quot; and &quot; &lt;&lt; f2 &lt;&lt; '\n';
}
 | output=
Given the number 123.45, modf() makes 123 and 0.45
Given the number -3.21, modf() makes -3 and -0.21
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc see c | c/numeric/math/modf}}
{{dsc end}}

[[de:cpp/numeric/math/modf]]
[[es:cpp/numeric/math/modf]]
[[fr:cpp/numeric/math/modf]]
[[it:cpp/numeric/math/modf]]
[[ja:cpp/numeric/math/modf]]
[[pt:cpp/numeric/math/modf]]
[[ru:cpp/numeric/math/modf]]
[[tr:cpp/numeric/math/modf]]
[[zh:cpp/numeric/math/modf]]</text>
      <sha1>2huu1gsmwtkhfq4f46w6veckr3wo2my</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nan</title>
    <ns>0</ns>
    <id>3740</id>
    <revision>
      <id>71185</id>
      <parentid>70541</parentid>
      <timestamp>2014-06-07T22:22:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, +example that shows the difference</comment>
      <text xml:space="preserve" bytes="2240">{{cpp/title|nan|nanf|nanl}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
float nanf( const char* arg );
}}
{{dcl | since=c++11 |
double nan( const char* arg );
}}
{{dcl | since=c++11 |
long double nanl( const char* arg );
}}
{{dcl end}}

Converts the implementation-defined character string {{tt|arg}} into the corresponding quiet NaN value, as if by calling {{lc|std::strtod}}, {{lc|std::strtof}}, or {{lc|std::strtold}}, respectively, as follows:

The call {{c|std::nan(&quot;string&quot;)}} is equivalent to the call {{c|std::strtod(&quot;NAN(string)&quot;, (char**)NULL);}}.

The call {{c|std::nan(&quot;&quot;)}} is equivalent to the call {{c|std::strtod(&quot;NAN()&quot;, (char**)NULL);}}.

The call {{c|std::nan(NULL)}} is equivalent to the call {{c|std::strtod(&quot;NAN&quot;, (char**)NULL);}}.

===Parameters===
{{par begin}}
{{par | arg | narrow character string identifying the contents of a NaN}}
{{par end}}

===Return value===
The quiet NaN value that corresponds to the identifying string {{tt|arg}} or zero if the implementation does not support quiet NaNs. 

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cstdint&gt;
#include &lt;cstring&gt;

int main()
{
    double f1 = std::nan(&quot;1&quot;);
    std::uint64_t f1n; std::memcpy(&amp;f1n, &amp;f1, sizeof f1);
    std::cout &lt;&lt; &quot;nan(\&quot;1\&quot;) = &quot; &lt;&lt; f1 &lt;&lt; &quot; (&quot; &lt;&lt; std::hex &lt;&lt; f1n &lt;&lt; &quot;)\n&quot;;

    double f2 = std::nan(&quot;2&quot;);
    std::uint64_t f2n; std::memcpy(&amp;f2n, &amp;f2, sizeof f2);
    std::cout &lt;&lt; &quot;nan(\&quot;2\&quot;) = &quot; &lt;&lt; f2 &lt;&lt; &quot; (&quot; &lt;&lt; std::hex &lt;&lt; f2n &lt;&lt; &quot;)\n&quot;;
}
|p=true
|output=
nan(&quot;1&quot;) = nan (7ff0000000000001)
nan(&quot;2&quot;) = nan (7ff0000000000002)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc isnan}}
{{dsc inc | cpp/numeric/math/dsc NAN}}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc signaling_NaN}}
{{dsc see c | c/numeric/math/nan | nanf | nan | nanl}}
{{dsc end}}

[[de:cpp/numeric/math/nan]]
[[es:cpp/numeric/math/nan]]
[[fr:cpp/numeric/math/nan]]
[[it:cpp/numeric/math/nan]]
[[ja:cpp/numeric/math/nan]]
[[pt:cpp/numeric/math/nan]]
[[ru:cpp/numeric/math/nan]]
[[zh:cpp/numeric/math/nan]]</text>
      <sha1>def3zcjtjsne2y27c2lz5xby1nx8w25</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nanf</title>
    <ns>0</ns>
    <id>4041</id>
    <redirect title="cpp/numeric/math/nan" />
    <revision>
      <id>14897</id>
      <timestamp>2011-12-01T14:39:48Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/nan]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/nan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nanl</title>
    <ns>0</ns>
    <id>4042</id>
    <redirect title="cpp/numeric/math/nan" />
    <revision>
      <id>14898</id>
      <timestamp>2011-12-01T14:39:56Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/nan]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/nan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nearbyint</title>
    <ns>0</ns>
    <id>3741</id>
    <revision>
      <id>72063</id>
      <parentid>70506</parentid>
      <timestamp>2014-07-11T04:38:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, more varied example</comment>
      <text xml:space="preserve" bytes="3958">{{cpp/title|nearbyint}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
float       nearbyint( float arg );
}}
{{dcl | since=c++11 |num=2 |
double      nearbyint( double arg );
}}
{{dcl | since=c++11 |num=3 |
long double nearbyint( long double arg );
}}
{{dcl | since=c++11 |num=4 |
double      nearbyint( Integral arg );
}}
{{dcl end}}

@1-3@ Rounds the floating-point argument {{tt|arg}} to an integer value in floating-point format, using the [[cpp/numeric/fenv/FE_round|current rounding mode]].
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
The nearest integer value to {{tt|arg}}, according to the [[cpp/numeric/fenv/FE_round|current rounding mode]], is returned.

===Error handling===
This function is not subject to any of the errors specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{lc|FE_INEXACT}} is never raised
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned

===Notes===
The only difference between {{tt|std::nearbyint}} and {{lc|std::rint}} is that {{tt|std::nearbyint}} never raises {{lc|FE_INEXACT}}.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|std::nearbyint}} never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

If the current rounding mode is {{lc|FE_TONEAREST}}, this function rounds to even in halfway cases (like {{lc|rint}}, but unlike {{lc|round}}).

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;

int main()
{
#pragma STDC FENV_ACCESS ON
    std::fesetround(FE_TONEAREST);
    std::cout &lt;&lt; &quot;rounding to nearest: \n&quot;
              &lt;&lt; &quot;nearbyint(+2.3) = &quot; &lt;&lt; std::nearbyint(2.3)
              &lt;&lt; &quot;  nearbyint(+2.5) = &quot; &lt;&lt; std::nearbyint(2.5)
              &lt;&lt; &quot;  nearbyint(+3.5) = &quot; &lt;&lt; std::nearbyint(3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;nearbyint(-2.3) = &quot; &lt;&lt; std::nearbyint(-2.3)
              &lt;&lt; &quot;  nearbyint(-2.5) = &quot; &lt;&lt; std::nearbyint(-2.5)
              &lt;&lt; &quot;  nearbyint(-3.5) = &quot; &lt;&lt; std::nearbyint(-3.5) &lt;&lt; '\n';

    std::fesetround(FE_DOWNWARD);
    std::cout &lt;&lt; &quot;rounding down:\n&quot;
              &lt;&lt; &quot;nearbyint(+2.3) = &quot; &lt;&lt; std::nearbyint(2.3)
              &lt;&lt; &quot;  nearbyint(+2.5) = &quot; &lt;&lt; std::nearbyint(2.5)
              &lt;&lt; &quot;  nearbyint(+3.5) = &quot; &lt;&lt; std::nearbyint(3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;nearbyint(-2.3) = &quot; &lt;&lt; std::nearbyint(-2.3)
              &lt;&lt; &quot;  nearbyint(-2.5) = &quot; &lt;&lt; std::nearbyint(-2.5)
              &lt;&lt; &quot;  nearbyint(-3.5) = &quot; &lt;&lt; std::nearbyint(-3.5) &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;nearbyint(-0.0) = &quot; &lt;&lt; std::nearbyint(-0.0)  &lt;&lt; '\n'
              &lt;&lt; &quot;nearbyint(-Inf) = &quot; &lt;&lt; std::nearbyint(-INFINITY) &lt;&lt; '\n';
}
|output=
rounding to nearest: 
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 4
nearbyint(-2.3) = -2  nearbyint(-2.5) = -2  nearbyint(-3.5) = -4
rounding down:
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 3
nearbyint(-2.3) = -3  nearbyint(-2.5) = -3  nearbyint(-3.5) = -4
nearbyint(-0.0) = -0
nearbyint(-Inf) = -inf
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc rint}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc see c | c/numeric/math/nearbyint}}
{{dsc end}}

[[de:cpp/numeric/math/nearbyint]]
[[es:cpp/numeric/math/nearbyint]]
[[fr:cpp/numeric/math/nearbyint]]
[[it:cpp/numeric/math/nearbyint]]
[[ja:cpp/numeric/math/nearbyint]]
[[pt:cpp/numeric/math/nearbyint]]
[[ru:cpp/numeric/math/nearbyint]]
[[zh:cpp/numeric/math/nearbyint]]</text>
      <sha1>9luml5qwsohs3kf5rghbr618sw7h7zp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nextafter</title>
    <ns>0</ns>
    <id>2374</id>
    <revision>
      <id>69253</id>
      <parentid>69252</parentid>
      <timestamp>2014-04-01T16:05:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2717">{{cpp/title|nextafter|nexttoward}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float       nextafter( float from, float to );
}}
{{dcl | since=c++11 | num=2|
double      nextafter( double from, double to );
}}
{{dcl | since=c++11 | num=3|
long double nextafter( long double from, long double to );
}}
{{dcl | since=c++11 | num=4|
Promoted    nextafter( Arithmetic from, Arithmetic to );
}}
{{dcl | since=c++11 | num=5|
float       nexttoward( float from, long double to );
}}
{{dcl | since=c++11 | num=6|
double      nexttoward( double from, long double to );
}}
{{dcl | since=c++11 | num=7|
long double nexttoward( long double from, long double to );
}}
{{dcl | since=c++11 | num=8|
double      nexttoward( Integral from, long double to );
}}
{{dcl end}}

Returns the next representable value of {{tt|from}} in the direction of {{tt|to}}. If {{tt|from}} equals to {{tt|to}}, {{tt|to}} is returned.

@1-3@ If {{tt|from}} equals to {{tt|to}}, {{tt|to}} is returned.
@5-7@ If {{tt|from}} equals to {{tt|to}}, {{tt|to}} is returned, converted from {{c|long double}} to the return type of the function without loss of range or precision.
@4,8@ If any argument has integral type, it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}

If {{tt|from}} is finite, but the result of {{tt|nextafter}} or {{tt|nexttoward}} is infinite, range error occurs and {{lc|FE_OVERFLOW}} and {{lc|FE_INEXACT}} may be raised.

If the result is subnormal or zero and {{tt|from !{{=}} to}}, raises {{lc|FE_UNDERFLOW}} and {{lc|FE_INEXACT}}.

In any case, the returned value is independent of the current rounding mode.

===Parameters===
{{par begin}}
{{par | from, to | floating point values}}
{{par end}}

===Return value===
the next representable value of {{tt|from}} in the direction of {{tt|to}}.

===Example===
{{example|
 | code=#include &lt;cmath&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;

int main()
{
    std::cout &lt;&lt; &quot;0.1 lies between the doubles &quot; &lt;&lt; std::setprecision(100) &lt;&lt; '\n'
              &lt;&lt; 0.1 &lt;&lt; '\n' &lt;&lt; &quot; and\n&quot;
              &lt;&lt; std::nextafter(0.1, 0) &lt;&lt; '\n';
}
 | output=
0.1 lies between the doubles 
0.1000000000000000055511151231257827021181583404541015625
 and
0.09999999999999999167332731531132594682276248931884765625
}}

===See also===
{{dsc begin}}
{{dsc see c | c/numeric/math/nextafter}}
{{dsc end}}

[[de:cpp/numeric/math/nextafter]]
[[es:cpp/numeric/math/nextafter]]
[[fr:cpp/numeric/math/nextafter]]
[[it:cpp/numeric/math/nextafter]]
[[ja:cpp/numeric/math/nextafter]]
[[pt:cpp/numeric/math/nextafter]]
[[ru:cpp/numeric/math/nextafter]]
[[zh:cpp/numeric/math/nextafter]]</text>
      <sha1>m6f6as8lcq4pzyj93k721lwrln626c2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/nexttoward</title>
    <ns>0</ns>
    <id>2375</id>
    <redirect title="cpp/numeric/math/nextafter" />
    <revision>
      <id>5394</id>
      <timestamp>2011-07-27T11:43:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>redirect</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/numeric/math/nextafter]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/pow</title>
    <ns>0</ns>
    <id>1369</id>
    <revision>
      <id>71859</id>
      <parentid>71100</parentid>
      <timestamp>2014-06-28T17:33:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>label 1-6</comment>
      <text xml:space="preserve" bytes="6468">{{cpp/title|pow}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | num = 1 |
float       pow( float base, float exp );
}}
{{dcl | num = 2 |
double      pow( double base, double exp );
}}
{{dcl | num = 3 |
long double pow( long double base, long double exp );
}}
{{dcl rev begin}}
{{dcl | until=c++11 | num=4 |
float       pow( float base, int iexp );
}}
{{dcl | until=c++11 | num=5 |
double      pow( double base, int iexp );
}}
{{dcl | until=c++11 | num=6 |
long double pow( long double base, int iexp );
}}
{{dcl | since=c++11 | num=7 |
Promoted    pow( Arithmetic1 base, Arithmetic2 exp );
}}
{{dcl end}}

@1-6@ Computes the value of {{tt|base}} raised to the power {{tt|exp}} or {{tt|iexp}}.
@7@ A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by 1-3). If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any argument is {{c|long double}}, then the return type {{tt|Promoted}} is also {{c|long double}}, otherwise the return type is always {{c|double}}.

===Parameters===
{{par begin}}
{{par | base | base as a value of floating-point or [[cpp/types/is_integral|integral type]]}}
{{par | exp | exponent as a value of floating-point or [[cpp/types/is_integral|integral type]]}}
{{par | iexp | exponent as integer value}}
{{par end}}

===Return value===
If no errors occur, {{tt|base}} raised to the power of {{tt|exp}} (or {{tt|iexp}}) ({{math|base{{su|p=exp}}}}), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a pole error or a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If {{tt|base}} is finite and negative and {{tt|exp}} is finite and non-integer, a domain error occurs and a range error may occur.

If {{tt|base}} is zero and {{tt|exp}} is zero, a domain error may occur.

If {{tt|base}} is zero and {{tt|exp}} is negative, a domain error or a pole error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* {{c|pow(+0, exp)}}, where {{tt|exp}} is a negative odd integer, returns +∞ and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(-0, exp)}}, where {{tt|exp}} is a negative odd integer, returns -∞ and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(±0, exp)}}, where {{tt|exp}} is negative, finite, and is an even integer or a non-integer, returns +∞ and raises {{lc|FE_DIVBYZERO}}
* {{c|pow(±0, -∞)}} returns +∞ and may raise {{lc|FE_DIVBYZERO}}
* {{c|pow(+0, exp)}}, where {{tt|exp}} is a positive odd integer, returns +0
* {{c|pow(-0, exp)}}, where {{tt|exp}} is a positive odd integer, returns -0
* {{c|pow(±0, exp)}}, where {{tt|exp}} is positive non-integer or a positive even integer, returns +0
* {{c|pow(-1, ±∞)}} returns {{tt|1}}
* {{c|pow(+1, exp)}} returns {{tt|1}} for any {{tt|exp}}, even when {{tt|exp}} is {{tt|NaN}}
* {{c|pow(base, ±0)}} returns {{tt|1}} for any {{tt|base}}, even when {{tt|base}} is {{tt|NaN}}
* {{c|pow(base, exp)}} returns {{tt|NaN}} and raises {{lc|FE_INVALID}} if {{tt|base}} is finite and negative and {{tt|exp}} is finite and non-integer.
* {{c|pow(base, -∞)}} returns +∞ for any {{tt|{{!}}base{{!}}&lt;1}}
* {{c|pow(base, -∞)}} returns +0 for any {{tt|{{!}}base{{!}}&gt;1}}
* {{c|pow(base, +∞)}} returns +0 for any {{tt|{{!}}base{{!}}&lt;1}}
* {{c|pow(base, +∞)}} returns +∞ for any {{tt|{{!}}base{{!}}&gt;1}}
* {{c|pow(-∞, exp)}} returns -0 if {{tt|exp}} is a negative odd integer
* {{c|pow(-∞, exp)}} returns +0 if {{tt|exp}} is a negative non-integer or even integer
* {{c|pow(-∞, exp)}} returns -∞ if {{tt|exp}} is a positive odd integer
* {{c|pow(-∞, exp)}} returns +∞ if {{tt|exp}} is a positive non-integer or even integer
* {{c|pow(+∞, exp)}} returns +0 for any negative {{tt|exp}}
* {{c|pow(+∞, exp)}} returns +∞ for any positive {{tt|exp}}
* except where specified above, if any argument is NaN, NaN is returned

===Notes===
{{tt|pow(float, int)}} returns {{c|float}} until C++11 (per overload 4) but returns {{tt|double}} since C++11 (per overload 7)

Although {{tt|std::pow}} cannot be used to obtain a root of a negative number, {{lc|std::cbrt}} is provided for the common case where {{tt|exp}} is 1/3

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    // typical usage
    std::cout &lt;&lt; &quot;pow(2, 10) = &quot; &lt;&lt; std::pow(2,10) &lt;&lt; '\n'
              &lt;&lt; &quot;pow(2, 0.5) = &quot; &lt;&lt; std::pow(2,0.5) &lt;&lt; '\n'
              &lt;&lt; &quot;pow(-2, -3) = &quot; &lt;&lt; std::pow(-2,-3) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;pow(-1, NAN) = &quot; &lt;&lt; std::pow(-1,NAN) &lt;&lt; '\n'
              &lt;&lt; &quot;pow(+1, NAN) = &quot; &lt;&lt; std::pow(+1,NAN) &lt;&lt; '\n'
              &lt;&lt; &quot;pow(INFINITY, 2) = &quot; &lt;&lt; std::pow(INFINITY, 2) &lt;&lt; '\n'
              &lt;&lt; &quot;pow(INFINITY, -1) = &quot; &lt;&lt; std::pow(INFINITY, -1) &lt;&lt; '\n';
    // error handling 
    errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;pow(-1, 1/3) = &quot; &lt;&lt; std::pow(-1, 1.0/3) &lt;&lt; '\n';
    if(errno == EDOM) std::cout &lt;&lt; &quot;    errno == EDOM &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID)) std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;

    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;pow(-0, -3) = &quot; &lt;&lt; std::pow(-0.0, -3) &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO)) std::cout &lt;&lt; &quot;    FE_DIVBYZERO raised\n&quot;;
}
|p=true
|output=
pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc cbrt}}
{{dsc inc | cpp/numeric/math/dsc hypot}}
{{dsc inc | cpp/numeric/complex/dsc pow}}
{{dsc inc | cpp/numeric/valarray/dsc pow}}
{{dsc see c | c/numeric/math/pow}}
{{dsc end}}

[[de:cpp/numeric/math/pow]]
[[es:cpp/numeric/math/pow]]
[[fr:cpp/numeric/math/pow]]
[[it:cpp/numeric/math/pow]]
[[ja:cpp/numeric/math/pow]]
[[pl:cpp/numeric/math/pow]]
[[pt:cpp/numeric/math/pow]]
[[ru:cpp/numeric/math/pow]]
[[zh:cpp/numeric/math/pow]]</text>
      <sha1>dt6qf2vfc995hnztcfh9md632ef6hr2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/remainder</title>
    <ns>0</ns>
    <id>2645</id>
    <revision>
      <id>71792</id>
      <parentid>71791</parentid>
      <timestamp>2014-06-24T02:13:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>braces around =</comment>
      <text xml:space="preserve" bytes="4656">{{cpp/title|remainder}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       remainder( float x, float y );
}}
{{dcl | since=c++11 |num=2|
double      remainder( double x, double y );
}}
{{dcl | since=c++11 |num=3|
long double remainder( long double x, long double y );
}}
{{dcl | since=c++11 |num=4|
Promoted    remainder( Arithmetic1 x, Arithmetic2 y );
}}
{{dcl end}}

@1-3@ Computes the IEEE remainder of the floating point division operation {{c|x/y}}.
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3. If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

The IEEE floating-point remainder of the division operation {{c|x/y}} calculated by this function is exactly the value {{c|x - n*y}}, where the value {{tt|n}} is the integral value nearest the exact value {{c|x/y}}. When {{math|{{!}}n-x/y{{!}} {{=}} ½}}, the value {{tt|n}} is chosen to be even.

In contrast to {{lc|std::fmod()}}, the returned value is not guaranteed to have the same sign as {{tt|x}}.

If the returned value is {{tt|0}}, it will have the same sign as {{tt|x}}.

===Parameters===
{{par begin}}
{{par | x, y | values of floating-point or [[cpp/types/is_integral|integral types]]}}
{{par end}}

===Return value===
If successful, returns the IEEE floating-point remainder of the division {{c|x/y}} as defined above.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result is returned.

If {{tt|y}} is zero, but the domain error does not occur, zero is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* {{lc|FE_INEXACT}} is never raised, the result is always exact.
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If either argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/remainder.html POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

{{lc|std::fmod}}, but not {{tt|std::remainder}} is useful for doing silent wrapping of floating-point types to unsigned integer types: {{c|1=(0.0 &lt;= (y = std::fmod( std::rint(x), 65536.0 )) ? y : 65536.0 + y)}} is in the range {{tt|[-0.0 .. 65535.0]}}, which corresponds to {{c|unsigned short}}, but {{c|std::remainder(std::rint(x), 65536.0}} is in the range {{tt|[-32767.0, +32768.0]}}, which is outside of the range of {{c|signed short}}.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;remainder(+5.1, +3.0) = &quot; &lt;&lt; std::remainder(5.1,3) &lt;&lt; '\n'
              &lt;&lt; &quot;remainder(-5.1, +3.0) = &quot; &lt;&lt; std::remainder(-5.1,3) &lt;&lt; '\n'
              &lt;&lt; &quot;remainder(+5.1, -3.0) = &quot; &lt;&lt; std::remainder(5.1,-3) &lt;&lt; '\n'
              &lt;&lt; &quot;remainder(-5.1, -3.0) = &quot; &lt;&lt; std::remainder(-5.1,-3) &lt;&lt; '\n';

    // special values
    std::cout &lt;&lt; &quot;remainder(-0.0, 1.0) = &quot; &lt;&lt; std::remainder(-0.0, 1) &lt;&lt; '\n'
              &lt;&lt; &quot;remainder(5.1, Inf) = &quot; &lt;&lt; std::remainder(5.1, INFINITY) &lt;&lt; '\n';

    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;remainder(+5.1, 0) = &quot; &lt;&lt; std::remainder(5.1, 0) &lt;&lt; '\n';
    if(fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
remainder(+5.1, +3.0) = -0.9
remainder(-5.1, +3.0) = 0.9
remainder(+5.1, -3.0) = -0.9
remainder(-5.1, -3.0) = 0.9
remainder(-0.0, 1.0) = -0
remainder(5.1, Inf) = 5.1
remainder(+5.1, 0) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc div}}
{{dsc inc | cpp/numeric/math/dsc fmod}}
{{dsc inc | cpp/numeric/math/dsc remquo}}
{{dsc see c | c/numeric/math/remainder}}
{{dsc end}}

[[de:cpp/numeric/math/remainder]]
[[es:cpp/numeric/math/remainder]]
[[fr:cpp/numeric/math/remainder]]
[[it:cpp/numeric/math/remainder]]
[[ja:cpp/numeric/math/remainder]]
[[ko:cpp/numeric/math/remainder]]
[[pt:cpp/numeric/math/remainder]]
[[ru:cpp/numeric/math/remainder]]
[[zh:cpp/numeric/math/remainder]]</text>
      <sha1>57tn3s8fejwysondqagnyqnxqemesci</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/remquo</title>
    <ns>0</ns>
    <id>2652</id>
    <revision>
      <id>71789</id>
      <parentid>71755</parentid>
      <timestamp>2014-06-24T01:59:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>no rounding in underflow</comment>
      <text xml:space="preserve" bytes="5906">{{cpp/title|remquo}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       remquo( float x, float y, int* quo );
}}
{{dcl | since=c++11 |num=2|
double      remquo( double x, double y, int* quo );
}}
{{dcl | since=c++11 |num=3|
long double remquo( long double x, long double y, int* quo );
}}
{{dcl | since=c++11 | num=4|
Promoted    remquo( Arithmetic1 x, Arithmetic2 y, int* quo );
}}
{{dcl end}}

@1-3@ Computes the floating-point remainder of the division operation {{c|x/y}} as the {{lc|std::remainder()}} function does.  Additionally, the sign and at least the three of the last bits of {{c|x/y}} will be stored in {{c|quo}}, sufficient to determine the octant of the result within a period.
@4@ A set of overloads or a function template for all combinations of arguments of [[cpp/types/is_arithmetic|arithmetic type]] not covered by 1-3. If any non-pointer argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}. If any other non-pointer argument is {{c|long double}}, then the return type is {{c|long double}}, otherwise it is {{c|double}}.

===Parameters===
{{par begin}}
{{par | x, y | floating point values}}
{{par | quo | pointer to an integer value to store the sign and some bits of {{c|x/y}} }}
{{par end}}

===Return value===
If successful, returns the floating-point remainder of the division {{c|x/y}} as defined in {{lc|std::remainder}}, and a value whose sign is the sign of {{c|x/y}} and whose magnitude is congruent {{math|modulo 2{{su|p=n}}}} to the magnitude of the integral quotient of {{c|x/y}}, where {{math|n}} is an implementation-defined integer greater than or equal to {{math|3}}.

If {{tt|y}} is zero, the value stored in {{c|*quo}} is unspecified.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result is returned if subnormals are supported.

If {{tt|y}} is zero, but the domain error does not occur, zero is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

Domain error may occur if {{tt|y}} is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* {{lc|FE_INEXACT}} is never raised
* If {{tt|x}} is ±∞ and {{tt|y}} is not NaN, NaN is returned and {{lc|FE_INVALID}} is raised
* If {{tt|y}} is ±0 and {{tt|x}} is not NaN, NaN is returned  and {{lc|FE_INVALID}} is raised
* If either {{tt|x}} or {{tt|y}} is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/remquo.html POSIX requires] that a domain error occurs if {{tt|x}} is infinite or {{tt|y}} is zero.

This function is useful when implementing periodic functions with the period exactly representable as a floating-point value: when calculating {{math|sin(πx)}} for a very large {{tt|x}}, calling {{lc|std::sin}} directly may result in a large error, but if the function argument is first reduced with {{tt|std::remquo}}, the low-order bits of the quotient may be used to determine the sign and the octant of the result within the period, while the remainder may be used to calculate the value with high precision. 

On some platforms this operation is supported by hardware (and, for example, on Intel CPUs, {{tt|FPREM1}} leaves exactly 3 bits of precision in the quotient when complete).

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1);
double cos_pi_x_naive(double x) { return std::cos(pi * x); }
// the period is 2, values are (0;0.5) positive, (0.5;1.5) negative, (1.5,2) positive
double cos_pi_x_smart(double x)
{
    int quadrant;
    double rem = std::remquo(x, 1, &amp;quadrant);
    quadrant = (unsigned)quadrant % 4; // keep 2 bits to determine quadrant
    switch(quadrant) {
        case 0: return std::cos(pi * rem);
        case 1: return -std::cos(pi * rem);
        case 2: return -std::cos(pi * rem);
        case 3: return std::cos(pi * rem);
    };
}
int main()
{
    std::cout &lt;&lt; &quot;cos(pi * 0.25) = &quot; &lt;&lt; cos_pi_x_naive(0.25) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi * 1.25) = &quot; &lt;&lt; cos_pi_x_naive(1.25) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi * 1000000000000.25) = &quot;
              &lt;&lt; cos_pi_x_naive(1000000000000.25) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi * 1000000000001.25) = &quot;
              &lt;&lt; cos_pi_x_naive(1000000000001.25) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi * 1000000000000.25) = &quot;
              &lt;&lt; cos_pi_x_smart(1000000000000.25) &lt;&lt; '\n'
              &lt;&lt; &quot;cos(pi * 1000000000001.25) = &quot;
              &lt;&lt; cos_pi_x_smart(1000000000001.25) &lt;&lt; '\n';
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    int quo;
    std::cout &lt;&lt; &quot;remquo(+Inf, 1) = &quot; &lt;&lt; std::remquo(INFINITY, 1, &amp;quo) &lt;&lt; '\n';
    if(fetestexcept(FE_INVALID)) std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
cos(pi * 0.25) = 0.707107
cos(pi * 1.25) = -0.707107
cos(pi * 1000000000000.25) = 0.707123
cos(pi * 1000000000001.25) = -0.707117
cos(pi * 1000000000000.25) = 0.707107
cos(pi * 1000000000001.25) = -0.707107 &lt;!-- note: this is exact output from Intel C++ on Linux, Oracle and GNU C++ on sparc, and IBM and GNU C++ compilers on a power platform. Do not replace with the incorrect output obtained from GNU C++ on Linux --&gt;
remquo(+Inf, 1) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc div}}
{{dsc inc | cpp/numeric/math/dsc fmod}}
{{dsc inc | cpp/numeric/math/dsc remainder}}
{{dsc see c | c/numeric/math/remquo}}
{{dsc end}}

[[de:cpp/numeric/math/remquo]]
[[es:cpp/numeric/math/remquo]]
[[fr:cpp/numeric/math/remquo]]
[[it:cpp/numeric/math/remquo]]
[[ja:cpp/numeric/math/remquo]]
[[pt:cpp/numeric/math/remquo]]
[[ru:cpp/numeric/math/remquo]]
[[zh:cpp/numeric/math/remquo]]</text>
      <sha1>4xbwuker293tpnmu54fj2ofcy09969g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/rint</title>
    <ns>0</ns>
    <id>3743</id>
    <revision>
      <id>72061</id>
      <parentid>72043</parentid>
      <timestamp>2014-07-11T04:30:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>3.5 shows more than 2.7</comment>
      <text xml:space="preserve" bytes="6770">{{cpp/title|rint | lrint | llrint }}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float rint( float arg );
}}
{{dcl | since=c++11 | num=2|
double rint( double arg );
}}
{{dcl | since=c++11 | num=3|
long double rint( long double arg );
}}
{{dcl | since=c++11 | num=4|
double rint( Integral arg );
}}
{{dcl | since=c++11 | num=5|
long lrint( float arg );
}}
{{dcl | since=c++11 | num=6|
long lrint( double arg );
}}
{{dcl | since=c++11 | num=7|
long lrint( long double arg );
}}
{{dcl | since=c++11 | num=8|
long lrint( Integral arg );
}}
{{dcl | since=c++11 | num=9|
long long llrint( float arg );
}}
{{dcl | since=c++11 | num=10|
long long llrint( double arg );
}}
{{dcl | since=c++11 | num=11|
long long llrint( long double arg );
}}
{{dcl | since=c++11 | num=12|
long long llrint( Integral arg );
}}
{{dcl end}}

@1-3@ Rounds the floating-point argument {{tt|arg}} to an integer value (in floating-point format), using the [[cpp/numeric/fenv/FE_round|current rounding mode]].
@5-7, 9-11@ Rounds the floating-point argument {{tt|arg}} to an integer value, using the [[cpp/numeric/fenv/FE_round|current rounding mode]]. 
@4,8,12@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2,6,10}}, respectively (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value to {{tt|arg}}, according to the [[cpp/numeric/fenv/FE_round|current rounding mode]], is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the result of {{tt|std::lrint}} or {{tt|std::llrint}} is outside the range representable by the return type, a domain error or a range error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
: For the {{tt|std::rint}} function:
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned
: For {{tt|std::lrint}} and {{tt|std::llrint}} functions:
* If {{tt|arg}} is ±∞, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If the result of the rounding is outside the range of the return type, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If {{tt|arg}} is NaN, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/lrint.html POSIX specifies] that all cases where {{tt|std::lrint}} or {{tt|std::llrint}} raise {{lc|FE_INEXACT}} are domain errors.

As specified in [[cpp/numeric/math/math_errhandling|math_errhandling]], {{lc|FE_INEXACT}} may be (but isn't required to be on non-IEEE floating-point platforms) raised by {{tt|std::rint}} when rounding a non-integer finite value.

The only difference between {{tt|std::rint}} and {{lc|std::nearbyint}} is that {{lc|std::nearbyint}} never raises {{lc|FE_INEXACT}}.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|std::rint}} never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

If the current rounding mode is...
* {{lc|FE_DOWNWARD}}, then {{tt|std::rint}} is equivalent to {{lc|std::floor}}.
* {{lc|FE_UPWARD}}, then {{tt|std::rint}} is equivalent to {{lc|std::ceil}}.
* {{lc|FE_TOWARDZERO}}, then {{tt|std::rint}} is equivalent to {{lc|std::trunc}}
* {{lc|FE_TONEAREST}}, then {{tt|std::rint}} differs from {{lc|std::round}} in that halfway cases are rounded to even rather than away from zero.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#include &lt;climits&gt;
 
int main()
{
#pragma STDC FENV_ACCESS ON
    std::fesetround(FE_TONEAREST);
    std::cout &lt;&lt; &quot;rounding to nearest: \n&quot;
              &lt;&lt; &quot;rint(+2.3) = &quot; &lt;&lt; std::rint(2.3)
              &lt;&lt; &quot;  rint(+2.5) = &quot; &lt;&lt; std::rint(2.5)
              &lt;&lt; &quot;  rint(+3.5) = &quot; &lt;&lt; std::rint(3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;rint(-2.3) = &quot; &lt;&lt; std::rint(-2.3)
              &lt;&lt; &quot;  rint(-2.5) = &quot; &lt;&lt; std::rint(-2.5)
              &lt;&lt; &quot;  rint(-3.5) = &quot; &lt;&lt; std::rint(-3.5) &lt;&lt; '\n';

    std::fesetround(FE_DOWNWARD);
    std::cout &lt;&lt; &quot;rounding down:\n&quot; 
              &lt;&lt; &quot;rint(+2.3) = &quot; &lt;&lt; std::rint(2.3)
              &lt;&lt; &quot;  rint(+2.5) = &quot; &lt;&lt; std::rint(2.5)
              &lt;&lt; &quot;  rint(+3.5) = &quot; &lt;&lt; std::rint(3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;rint(-2.3) = &quot; &lt;&lt; std::rint(-2.3)
              &lt;&lt; &quot;  rint(-2.5) = &quot; &lt;&lt; std::rint(-2.5)
              &lt;&lt; &quot;  rint(-3.5) = &quot; &lt;&lt; std::rint(-3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;rounding down with lrint\n&quot; 
              &lt;&lt; &quot;lrint(+2.3) = &quot; &lt;&lt; std::lrint(2.3)
              &lt;&lt; &quot;  lrint(+2.5) = &quot; &lt;&lt; std::lrint(2.5)
              &lt;&lt; &quot;  lrint(+3.5) = &quot; &lt;&lt; std::lrint(3.5) &lt;&lt; '\n'
              &lt;&lt; &quot;lrint(-2.3) = &quot; &lt;&lt; std::lrint(-2.3)
              &lt;&lt; &quot;  lrint(-2.5) = &quot; &lt;&lt; std::lrint(-2.5)
              &lt;&lt; &quot;  lrint(-3.5) = &quot; &lt;&lt; std::lrint(-3.5) &lt;&lt; '\n';
 
    std::cout &lt;&lt; &quot;lrint(-0.0) = &quot; &lt;&lt; std::lrint(-0.0)  &lt;&lt; '\n'
              &lt;&lt; &quot;lrint(-Inf) = &quot; &lt;&lt; std::lrint(-INFINITY) &lt;&lt; '\n';
 
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;std::rint(0.1) = &quot; &lt;&lt; std::rint(.1) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INEXACT))
              std::cout &lt;&lt; &quot;    FE_INEXACT was raised\n&quot;;

    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;std::lrint(LONG_MIN-2048.0) = &quot;
              &lt;&lt; std::lrint(LONG_MIN-2048.0) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
              std::cout &lt;&lt; &quot;    FE_INVALID was raised\n&quot;;
}
 | p=true
 | output =
rounding to nearest: 
rint(+2.3) = 2  rint(+2.5) = 2  rint(+3.5) = 4
rint(-2.3) = -2  rint(-2.5) = -2  rint(-3.5) = -4
rounding down:
rint(+2.3) = 2  rint(+2.5) = 2  rint(+3.5) = 3
rint(-2.3) = -3  rint(-2.5) = -3  rint(-3.5) = -4
rounding down with lrint
lrint(+2.3) = 2  lrint(+2.5) = 2  lrint(+3.5) = 3
lrint(-2.3) = -3  lrint(-2.5) = -3  lrint(-3.5) = -4
lrint(-0.0) = 0
lrint(-Inf) = -9223372036854775808
std::rint(0.1) = 0
    FE_INEXACT was raised
std::lrint(LONG_MIN-2048.0) = -9223372036854775808
    FE_INVALID was raised
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc inc | cpp/numeric/math/dsc nearbyint}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc see c | c/numeric/math/rint}}
{{dsc end}}

[[de:cpp/numeric/math/rint]]
[[es:cpp/numeric/math/rint]]
[[fr:cpp/numeric/math/rint]]
[[it:cpp/numeric/math/rint]]
[[ja:cpp/numeric/math/rint]]
[[pt:cpp/numeric/math/rint]]
[[ru:cpp/numeric/math/rint]]
[[zh:cpp/numeric/math/rint]]</text>
      <sha1>2tjrqcfxoyenrkprq0j1mu654efb8r2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/round</title>
    <ns>0</ns>
    <id>1370</id>
    <revision>
      <id>71880</id>
      <parentid>70505</parentid>
      <timestamp>2014-06-30T19:36:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, +example</comment>
      <text xml:space="preserve" bytes="6227">{{cpp/title|round | lround | llround}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float round( float arg );
}}
{{dcl | since=c++11 | num=2|
double round( double arg );
}}
{{dcl | since=c++11 | num=3|
long double round( long double arg );
}}
{{dcl | since=c++11 | num=4|
double round( Integral arg );
}}
{{dcl | since=c++11 | num=5|
long lround( float arg );
}}
{{dcl | since=c++11 | num=6|
long lround( double arg );
}}
{{dcl | since=c++11 | num=7|
long lround( long double arg );
}}
{{dcl | since=c++11 | num=8|
long lround( Integral arg );
}}
{{dcl | since=c++11 | num=9|
long long llround( float arg );
}}
{{dcl | since=c++11 | num=10|
long long llround( double arg );
}}
{{dcl | since=c++11 | num=11|
long long llround( long double arg );
}}
{{dcl | since=c++11 | num=12|
long long llround( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the nearest integer value to {{tt|arg}} (in floating-point format), rounding halfway cases away from zero, regardless of the current rounding mode.
@5-7, 9-11@ Computes the nearest integer value to {{tt|arg}} (in integer format), rounding halfway cases away from zero, regardless of the current rounding mode.
@4,8,12@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2), 6), or 10), respectively (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value to {{tt|arg}}, rounding halfway cases away from zero, is returned.

{{plot | left=Return value | bottom=Argument | math-round_away_zero.svg}}

If a domain error occurs, an implementation-defined value is returned

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the result of {{tt|std::lround}} or {{tt|std::llround}} is outside the range representable by the return type, a domain error or a range error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
: For the {{tt|std::round}} function:
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If {{tt|arg}} is NaN, NaN is returned
: For {{tt|std::lround}} and {{tt|std::llround}} functions:
* {{lc|FE_INEXACT}} is never raised
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If the result of the rounding is outside the range of the return type, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned
* If {{tt|arg}} is NaN, {{lc|FE_INVALID}} is raised and an implementation-defined value is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised by {{tt|std::round}} when rounding a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so {{tt|std::round}} never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/lround.html POSIX specifies] that all cases where {{tt|std::lround}} or {{tt|std::llround}} raise {{lc|FE_INEXACT}} are domain errors.

The {{c|double}} version of {{tt|std::round}} behaves as if implemented as follows:
{{source|1=
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    std::fenv_t save_env;
    std::feholdexcept(&amp;save_env);
    double result = std::rint(x);
    if (std::fetestexcept(FE_INEXACT)) {
        std::fesetround(FE_TOWARDZERO);
        result = std::rint(std::copysign(0.5 + std::fabs(x), x));
    }
    std::feupdateenv(&amp;save_env);
    return result;
}
}}

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#include &lt;climits&gt;

#pragma STDC FENV_ACCESS ON

int main()
{
    // round
    std::cout &lt;&lt; &quot;round(+2.3) = &quot; &lt;&lt; std::round(2.3)
              &lt;&lt; &quot;  round(+2.5) = &quot; &lt;&lt; std::round(2.5)
              &lt;&lt; &quot;  round(+2.7) = &quot; &lt;&lt; std::round(2.7) &lt;&lt; '\n'
              &lt;&lt; &quot;round(-2.3) = &quot; &lt;&lt; std::round(-2.3)
              &lt;&lt; &quot;  round(-2.5) = &quot; &lt;&lt; std::round(-2.5)
              &lt;&lt; &quot;  round(-2.7) = &quot; &lt;&lt; std::round(-2.7) &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;round(-0.0) = &quot; &lt;&lt; std::round(-0.0)  &lt;&lt; '\n'
              &lt;&lt; &quot;round(-Inf) = &quot; &lt;&lt; std::round(-INFINITY) &lt;&lt; '\n';

    // lround
    std::cout &lt;&lt; &quot;lround(+2.3) = &quot; &lt;&lt; std::lround(2.3)
              &lt;&lt; &quot;  lround(+2.5) = &quot; &lt;&lt; std::lround(2.5)
              &lt;&lt; &quot;  lround(+2.7) = &quot; &lt;&lt; std::lround(2.7) &lt;&lt; '\n'
              &lt;&lt; &quot;lround(-2.3) = &quot; &lt;&lt; std::lround(-2.3)
              &lt;&lt; &quot;  lround(-2.5) = &quot; &lt;&lt; std::lround(-2.5)
              &lt;&lt; &quot;  lround(-2.7) = &quot; &lt;&lt; std::lround(-2.7) &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;lround(-0.0) = &quot; &lt;&lt; std::lround(-0.0)  &lt;&lt; '\n'
              &lt;&lt; &quot;lround(-Inf) = &quot; &lt;&lt; std::lround(-INFINITY) &lt;&lt; '\n';

    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;std::lround(LONG_MAX+1.5) = &quot;
              &lt;&lt; std::lround(LONG_MAX+1.5) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
              std::cout &lt;&lt; &quot;    FE_INVALID was raised\n&quot;;
}
|p=true
|output=
round(+2.3) = 2  round(+2.5) = 3  round(+2.7) = 3
round(-2.3) = -2  round(-2.5) = -3  round(-2.7) = -3
round(-0.0) = -0
round(-Inf) = -inf
lround(+2.3) = 2  lround(+2.5) = 3  lround(+2.7) = 3
lround(-2.3) = -2  lround(-2.5) = -3  lround(-2.7) = -3
lround(-0.0) = 0
lround(-Inf) = -9223372036854775808
std::lround(LONG_MAX+1.5) = -9223372036854775808
    FE_INVALID was raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc floor}}
{{dsc inc | cpp/numeric/math/dsc ceil}}
{{dsc inc | cpp/numeric/math/dsc trunc}}
{{dsc see c | c/numeric/math/round}}
{{dsc end}}

[[de:cpp/numeric/math/round]]
[[es:cpp/numeric/math/round]]
[[fr:cpp/numeric/math/round]]
[[it:cpp/numeric/math/round]]
[[ja:cpp/numeric/math/round]]
[[pt:cpp/numeric/math/round]]
[[ru:cpp/numeric/math/round]]
[[zh:cpp/numeric/math/round]]</text>
      <sha1>b7w7l5gqbsbb5iaxzy1jdroobqpa44c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/scalbln</title>
    <ns>0</ns>
    <id>4043</id>
    <redirect title="cpp/numeric/math/scalbn" />
    <revision>
      <id>14899</id>
      <timestamp>2011-12-01T14:40:25Z</timestamp>
      <contributor>
        <username>1exec1</username>
        <id>305</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/math/scalbn]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/numeric/math/scalbn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/scalbn</title>
    <ns>0</ns>
    <id>1371</id>
    <revision>
      <id>72169</id>
      <parentid>70496</parentid>
      <timestamp>2014-07-19T22:56:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, example</comment>
      <text xml:space="preserve" bytes="4681">{{cpp/title|scalbn | scalbln}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1 |
float       scalbn( float x, int exp );
}}
{{dcl | since=c++11 | num=2 |
double      scalbn( double x, int exp );
}}
{{dcl | since=c++11 | num=3 |
long double scalbn( long double x, int exp );
}}
{{dcl | since=c++11 |  num=4 |
double      scalbn( Integral x, int exp );
}}
{{dcl | since=c++11 |  num=5 |
float       scalbln( float x, long exp );
}}
{{dcl | since=c++11 | num=6 |
double      scalbln( double x, long exp );
}}
{{dcl | since=c++11 | num=7 |
long double scalbln( long double x, long exp );
}}
{{dcl | since=c++11 |  num=8 |
double      scalbln( Integral x, long exp );
}}
{{dcl end}}

@1-3,5-7@ Multiplies a floating point value {{tt|x}} by {{lc|FLT_RADIX}} raised to power {{tt|exp}}.
@4,8@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} or {{v|6}} (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | x | floating point value}}
{{par | exp | integer value}}
{{par end}}

===Return value===
If no errors occur, {{tt|x}} multiplied by {{lc|FLT_RADIX}} to the power of {{tt|arg}} ({{math|x&amp;times;FLT_RADIX{{su|p=exp}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* Unless a range error occurs, {{lc|FE_INEXACT}} is never raised (the result is exact)
* Unless a range error occurs, [[cpp/numeric/fenv/FE_round|the current rounding mode]] is ignored
* If {{tt|x}} is ±0, it is returned, unmodified
* If {{tt|x}} is ±∞, it is returned, unmodified
* If {{tt|exp}} is 0, then {{tt|x}} is returned, unmodified
* If {{tt|x}} is NaN, NaN is returned

===Notes===
On binary systems (where {{lc|FLT_RADIX}} is {{tt|2}}), {{tt|std::scalbn}} is equivalent to {{lc|std::ldexp}}.

Although {{tt|std::scalbn}} and {{tt|std::scalbln}} are specified to perform the operation efficiently, on many implementations they are less efficient than multiplication or division by a power of two using arithmetic operators.

The function name stands for &quot;new scalb&quot;, where {{tt|scalb}} was an older non-standard function whose second argument had floating-point type.

The {{tt|scalbln}} function is provided because the factor required to scale from the smallest positive floating-point value to the largest finite one may be greater than 32767, the standard-guaranteed {{lc|INT_MAX}}. In particular, for the 80-bit {{tt|long double}}, the factor is 32828.

The GNU implementation does not set {{tt|errno}} regardless of {{tt|math_errhandling}}

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;scalbn(7, -4) = &quot; &lt;&lt; std::scalbn(7, -4) &lt;&lt; '\n'
              &lt;&lt; &quot;scalbn(1, -1074) = &quot; &lt;&lt; std::scalbn(1, -1074)
              &lt;&lt; &quot; (minimum positive subnormal double)\n&quot;
              &lt;&lt; &quot;scalbn(nextafter(1,0), 1024) = &quot;
              &lt;&lt; std::scalbn(std::nextafter(1,0), 1024)
              &lt;&lt; &quot; (largest finite double)\n&quot;;
    // special values
    std::cout &lt;&lt; &quot;scalbn(-0, 10) = &quot; &lt;&lt; std::scalbn(-0.0, 10) &lt;&lt; '\n'
              &lt;&lt; &quot;scalbn(-Inf, -1) = &quot; &lt;&lt; std::scalbn(-INFINITY, -1) &lt;&lt; '\n';
    // error handling
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;scalbn(1, 1024) = &quot; &lt;&lt; std::scalbn(1, 1024) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|p=true
|output=
scalbn(7, -4) = 0.4375
scalbn(1, -1074) = 4.94066e-324 (minimum positive subnormal double)
scalbn(nextafter(1,0), 1024) = 1.79769e+308 (largest finite double)
scalbn(-0, 10) = -0
scalbn(-Inf, -1) = -inf
scalbn(1, 1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc frexp}}
{{dsc inc | cpp/numeric/math/dsc ldexp}}
{{dsc see c | c/numeric/math/scalbn}}
{{dsc end}}

[[de:cpp/numeric/math/scalbn]]
[[es:cpp/numeric/math/scalbn]]
[[fr:cpp/numeric/math/scalbn]]
[[it:cpp/numeric/math/scalbn]]
[[ja:cpp/numeric/math/scalbn]]
[[pt:cpp/numeric/math/scalbn]]
[[ru:cpp/numeric/math/scalbn]]
[[zh:cpp/numeric/math/scalbn]]</text>
      <sha1>07kzgglz7tlj3pby6yvamov2iaa9m4t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/signbit</title>
    <ns>0</ns>
    <id>1372</id>
    <revision>
      <id>70471</id>
      <parentid>62880</parentid>
      <timestamp>2014-05-23T22:30:05Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ link to C documentation</comment>
      <text xml:space="preserve" bytes="918">{{cpp/title|signbit}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |
bool signbit( float arg );
}}
{{dcl | since=c++11 |
bool signbit( double arg );
}}
{{dcl | since=c++11 |
bool signbit( long double arg );
}}
{{dcl end}}


Determines if the given floating point number {{tt|arg}} is negative.

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===

{{c|true}} if {{tt|arg}} is negative, {{c|false}} otherwise

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/math/dsc copysign}}
{{dsc see c | c/numeric/math/signbit}}
{{dsc end}}

[[de:cpp/numeric/math/signbit]]
[[es:cpp/numeric/math/signbit]]
[[fr:cpp/numeric/math/signbit]]
[[it:cpp/numeric/math/signbit]]
[[ja:cpp/numeric/math/signbit]]
[[pt:cpp/numeric/math/signbit]]
[[ru:cpp/numeric/math/signbit]]
[[zh:cpp/numeric/math/signbit]]</text>
      <sha1>kft4pka91qnc9pkda997ime68a8ohtj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/sin</title>
    <ns>0</ns>
    <id>1373</id>
    <revision>
      <id>70458</id>
      <parentid>70442</parentid>
      <timestamp>2014-05-23T10:40:40Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>num=4</comment>
      <text xml:space="preserve" bytes="3436">{{cpp/title|sin}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       sin( float arg );
}}
{{dcl |num=2|
double      sin( double arg );
}}
{{dcl |num=3|
long double sin( long double arg );
}}
{{dcl |num=4| since=c++11 |
double      sin( Integral arg );
}}
{{dcl end}}

Computes the sine of {{tt|arg}} (measured in radians).
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value representing angle in radians, of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the sine of {{tt|arg}} ({{math|sin(arg)}}) in the range {{math|[-1 ; +1]}}, is returned.

{{rev begin}}
{{rev|until=c++11|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised &lt;!-- not defined as a domain error in C or C++, although defined as a domain error in POSIX --&gt;
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C (to which C++ defers), but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/sin.html domain error in POSIX]

POSIX also specifies that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1);
int main()
{
    // typical usage
    std::cout &lt;&lt; &quot;sin(pi/6) = &quot; &lt;&lt; std::sin(pi/6) &lt;&lt; '\n'
              &lt;&lt; &quot;sin(pi/2) = &quot; &lt;&lt; std::sin(pi/2) &lt;&lt; '\n'
              &lt;&lt; &quot;sin(-3*pi/4) = &quot; &lt;&lt; std::sin(-3*pi/4) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;sin(+0) = &quot; &lt;&lt; std::sin(0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;sin(-0) = &quot; &lt;&lt; std::sin(-0.0) &lt;&lt; '\n';
    // error handling 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;sin(INFINITY) = &quot; &lt;&lt; std::sin(INFINITY) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID)) std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
sin(pi/6) = 0.5
sin(pi/2) = 1
sin(-3*pi/4) = -0.707107
sin(+0) = 0
sin(-0) = -0
sin(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc see c | c/numeric/math/sin}}
{{dsc end}}

[[de:cpp/numeric/math/sin]]
[[es:cpp/numeric/math/sin]]
[[fr:cpp/numeric/math/sin]]
[[it:cpp/numeric/math/sin]]
[[ja:cpp/numeric/math/sin]]
[[pl:cpp/numeric/math/sin]]
[[pt:cpp/numeric/math/sin]]
[[ru:cpp/numeric/math/sin]]
[[zh:cpp/numeric/math/sin]]</text>
      <sha1>0tjwv8x1lin3nacjgb07tlzokzdqd65</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/sinh</title>
    <ns>0</ns>
    <id>1374</id>
    <revision>
      <id>70554</id>
      <parentid>70553</parentid>
      <timestamp>2014-05-25T01:21:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/DBL_MAX/710.5</comment>
      <text xml:space="preserve" bytes="3186">{{cpp/title|sinh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       sinh( float arg );
}}
{{dcl |num=2|
double      sinh( double arg );
}}
{{dcl |num=3|
long double sinh( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      sinh( Integral arg );
}}
{{dcl end}}

Computes the hyperbolic sine of {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic sine of {{tt|arg}} ({{math|sinh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}-e{{su|p=-arg}}|2}}}}) is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0 or ±∞, it is returned unmodified
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/sinh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;sinh(1) = &quot; &lt;&lt; std::sinh(1) &lt;&lt; '\n'
              &lt;&lt; &quot;sinh(-1) = &quot; &lt;&lt; std::sinh(-1) &lt;&lt; '\n'
              &lt;&lt; &quot;log(sinh(1)+cosh(1)) = &quot;
              &lt;&lt; std::log(std::sinh(1)+std::cosh(1)) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;sinh(+0) = &quot; &lt;&lt; std::sinh(0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;sinh(-0) = &quot; &lt;&lt; std::sinh(-0.0) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;sinh(710.5) = &quot; &lt;&lt; std::sinh(710.5) &lt;&lt; '\n';
    if(errno == ERANGE)
        std::cout &lt;&lt; &quot;    errno == ERANGE: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_OVERFLOW))
        std::cout &lt;&lt; &quot;    FE_OVERFLOW raised\n&quot;;
}
|output=
sinh(1) = 1.1752
sinh(-1) = -1.1752
log(sinh(1)+cosh(1)) = 1
sinh(+0) = 0
sinh(-0) = -0
sinh(710.5) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc asinh}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc see c | c/numeric/math/sinh}}
{{dsc end}}

[[de:cpp/numeric/math/sinh]]
[[es:cpp/numeric/math/sinh]]
[[fr:cpp/numeric/math/sinh]]
[[it:cpp/numeric/math/sinh]]
[[ja:cpp/numeric/math/sinh]]
[[pl:cpp/numeric/math/sinh]]
[[pt:cpp/numeric/math/sinh]]
[[ru:cpp/numeric/math/sinh]]
[[zh:cpp/numeric/math/sinh]]</text>
      <sha1>1vyijdiljc654zd4oum2cq9lqhlqq03</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/sqrt</title>
    <ns>0</ns>
    <id>1375</id>
    <revision>
      <id>70847</id>
      <parentid>70845</parentid>
      <timestamp>2014-05-31T03:14:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>std:: rather than a using, so that the parser can pick them up</comment>
      <text xml:space="preserve" bytes="2837">{{cpp/title|sqrt}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       sqrt( float arg );
}}
{{dcl |num=2|
double      sqrt( double arg );
}}
{{dcl |num=3|
long double sqrt( long double arg );
}}
{{dcl |num=4| since=c++11 |
double      sqrt( Integral arg );
}}
{{dcl end}}

Computes the square root of {{tt|arg}}.

@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | Value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, square root of {{tt|arg}} ({{math|{{mrad|arg}}}}), is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in {{lc|math_errhandling}}

Domain error occurs if {{tt|arg}} is less than zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is less than -0, {{lc|FE_INVALID}} is raised and NaN is returned.
* If the argument is +∞ or ±0, it is returned, unmodified.
* If the argument is NaN, NaN is returned

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;
#include &lt;cstring&gt;

#pragma STDC FENV_ACCESS ON

int main()
{
    // normal use
    std::cout &lt;&lt; &quot;sqrt(100) = &quot; &lt;&lt; std::sqrt(100) &lt;&lt; '\n'
              &lt;&lt; &quot;sqrt(2) = &quot; &lt;&lt; std::sqrt(2) &lt;&lt; '\n'
              &lt;&lt; &quot;golden ratio = &quot; &lt;&lt; (1+std::sqrt(5))/2 &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;sqrt(-0) = &quot; &lt;&lt; std::sqrt(-0.0) &lt;&lt; '\n';
    // error handling
    errno = 0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;sqrt(-1.0) = &quot; &lt;&lt; std::sqrt(-1) &lt;&lt; '\n';
    if(errno == EDOM)
        std::cout &lt;&lt; &quot;    errno = EDOM &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
 | p=true
 | output=
sqrt(100) = 10
sqrt(2) = 1.41421
golden ratio = 1.61803
sqrt(-0) = -0
sqrt(-1.0) = -nan
    errno = EDOM Numerical argument out of domain
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc cbrt}}
{{dsc inc | cpp/numeric/math/dsc hypot}}
{{dsc inc | cpp/numeric/complex/dsc sqrt}}
{{dsc inc | cpp/numeric/valarray/dsc sqrt}}
{{dsc see c | c/numeric/math/sqrt}}
{{dsc end}}

[[de:cpp/numeric/math/sqrt]]
[[es:cpp/numeric/math/sqrt]]
[[fr:cpp/numeric/math/sqrt]]
[[it:cpp/numeric/math/sqrt]]
[[ja:cpp/numeric/math/sqrt]]
[[pl:cpp/numeric/math/sqrt]]
[[pt:cpp/numeric/math/sqrt]]
[[ru:cpp/numeric/math/sqrt]]
[[zh:cpp/numeric/math/sqrt]]</text>
      <sha1>kv0mp23enbfnxpaqmkexszup25r2szq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/tan</title>
    <ns>0</ns>
    <id>1376</id>
    <revision>
      <id>70512</id>
      <parentid>70266</parentid>
      <timestamp>2014-05-24T20:01:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>return values, details for 4)</comment>
      <text xml:space="preserve" bytes="3230">{{cpp/title|tan}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       tan( float arg );
}}
{{dcl |num=2|
double      tan( double arg );
}}
{{dcl |num=3|
long double tan( long double arg );
}}
{{dcl |num=4| since=c++11 |
double      tan( Integral arg );
}}
{{dcl end}}

Computes the tangent of {{tt|arg}} (measured in radians).
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value representing angle in radians, of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the tangent of {{tt|arg}} ({{math|tan(arg)}}) is returned.

{{rev begin}}
{{rev|until=c++11|
The result may have little or no significance if the magnitude of {{tt|arg}} is large
}}
{{rev end}}

If a domain error occurs, an implementation-defined value is returned (NaN where supported)

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[c/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, it is returned unmodified
* if the argument is ±∞, NaN is returned and {{lc|FE_INVALID}} is raised
* if the argument is NaN, NaN is returned

===Notes===
The case where the argument is infinite is not specified to be a domain error in C (to which C++ defers), but it is defined as a [http://pubs.opengroup.org/onlinepubs/9699919799/functions/tan.html domain error in POSIX]

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cfenv&gt;

#pragma STDC FENV_ACCESS ON
const double pi = std::acos(-1);
int main()
{
    // typical usage
    std::cout &lt;&lt; &quot;tan  (pi/4) = &quot; &lt;&lt; std::tan(  pi/4) &lt;&lt; '\n' // 45 deg.
              &lt;&lt; &quot;tan(3*pi/4) = &quot; &lt;&lt; std::tan(3*pi/4) &lt;&lt; '\n' // 135 deg
              &lt;&lt; &quot;tan(5*pi/4) = &quot; &lt;&lt; std::tan(5*pi/4) &lt;&lt; '\n' // -135 deg
              &lt;&lt; &quot;tan(7*pi/4) = &quot; &lt;&lt; std::tan(7*pi/4) &lt;&lt; '\n'; // -45 deg
    // special values
    std::cout &lt;&lt; &quot;tan(+0) = &quot; &lt;&lt; std::tan(0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;tan(-0) = &quot; &lt;&lt; std::tan(-0.0) &lt;&lt; '\n';
    // error handling 
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;tan(INFINITY) = &quot; &lt;&lt; std::tan(INFINITY) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID)) std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
tan  (pi/4) = 1
tan(3*pi/4) = -1
tan(5*pi/4) = 1
tan(7*pi/4) = -1
tan(+0) = 0
tan(-0) = -0
tan(INFINITY) = -nan
    FE_INVALID raised
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc see c | c/numeric/math/tan}}
{{dsc end}}

[[de:cpp/numeric/math/tan]]
[[es:cpp/numeric/math/tan]]
[[fr:cpp/numeric/math/tan]]
[[it:cpp/numeric/math/tan]]
[[ja:cpp/numeric/math/tan]]
[[pl:cpp/numeric/math/tan]]
[[pt:cpp/numeric/math/tan]]
[[ru:cpp/numeric/math/tan]]
[[zh:cpp/numeric/math/tan]]</text>
      <sha1>ofj4l21z1tdqb6mkhw45ksqb95vw4gh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/tanh</title>
    <ns>0</ns>
    <id>1377</id>
    <revision>
      <id>70566</id>
      <parentid>70564</parentid>
      <timestamp>2014-05-25T02:57:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>std::</comment>
      <text xml:space="preserve" bytes="2670">{{cpp/title|tanh}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl |num=1|
float       tanh( float arg );
}}
{{dcl |num=2|
double      tanh( double arg );
}}
{{dcl |num=3|
long double tanh( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      tanh( Integral arg );
}}
{{dcl end}}

Computes the hyperbolic tangent of {{tt|arg}}
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the hyperbolic tangent of {{tt|arg}} ({{math|tanh(arg)}}, or {{math|{{mfrac|e{{su|p=arg}}-e{{su|p=-arg}}|e{{su|p=arg}}+e{{su|p=-arg}}}}}}) is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* if the argument is ±0, ±0 is returned
* If the argument is ±∞, ±1 is returned
* if the argument is NaN, NaN is returned

===Notes===
[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tanh.html POSIX specifies] that in case of underflow, {{tt|arg}} is returned unmodified, and if that is not supported, and implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

===Examples===
{{example|
|code=#include &lt;iostream&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; &quot;tanh(1) = &quot; &lt;&lt; std::tanh(1) &lt;&lt; '\n'
              &lt;&lt; &quot;tanh(-1) = &quot; &lt;&lt; std::tanh(-1) &lt;&lt; '\n'
              &lt;&lt; &quot;tanh(0.1)*sinh(0.2)-cosh(0.2) = &quot;
              &lt;&lt; std::tanh(0.1) * std::sinh(0.2) - std::cosh(0.2) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;tanh(+0) = &quot; &lt;&lt; std::tanh(+0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;tanh(-0) = &quot; &lt;&lt;  std::tanh(-0.0) &lt;&lt; '\n';
}
|output=
tanh(1) = 0.761594
tanh(-1) = -0.761594
tanh(0.1)*sinh(0.2)-cosh(0.2) = -1
tanh(+0) = 0
tanh(-0) = -0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc atanh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc see c | c/numeric/math/tanh}}
{{dsc end}}

[[de:cpp/numeric/math/tanh]]
[[es:cpp/numeric/math/tanh]]
[[fr:cpp/numeric/math/tanh]]
[[it:cpp/numeric/math/tanh]]
[[ja:cpp/numeric/math/tanh]]
[[pl:cpp/numeric/math/tanh]]
[[pt:cpp/numeric/math/tanh]]
[[ru:cpp/numeric/math/tanh]]
[[zh:cpp/numeric/math/tanh]]</text>
      <sha1>cpsbk2uy1724wwc388fi7ncu1p5iqwi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/tgamma</title>
    <ns>0</ns>
    <id>2901</id>
    <revision>
      <id>71183</id>
      <parentid>70525</parentid>
      <timestamp>2014-06-07T21:45:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail, longer example</comment>
      <text xml:space="preserve" bytes="4512">{{cpp/title|tgamma}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 |num=1|
float       tgamma( float arg );
}}
{{dcl | since=c++11 |num=2|
double      tgamma( double arg );
}}
{{dcl | since=c++11 |num=3|
long double tgamma( long double arg );
}}
{{dcl | since=c++11 |num=4|
double      tgamma( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the [[enwiki:Gamma function|gamma function]] of {{tt|arg}}.
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | value of a floating-point or [[cpp/types/is_integral|Integral type]]}}
{{par end}}

===Return value===
If no errors occur, the value of the gamma function of {{tt|arg}}, that is {{math|{{minteg|0|∞|''t''{{su|p=arg-1}} {{mexp|-t}} d''t''}}}}, is returned

If a domain error occurs, an implementation-defined value (NaN where supported) is returned.

If a pole error occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to overflow occurs, {{tt|±HUGE_VAL}}, {{tt|±HUGE_VALF}}, or {{tt|±HUGE_VALL}} is returned.

If a range error due to underflow occurs, the correct value (after rounding) is returned.

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If {{tt|arg}} is zero or is an integer less than zero, a pole error or a domain error may occur.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* If the argument is ±0, ±∞ is returned and {{lc|FE_DIVBYZERO}} is raised
* If the argument is a negative integer, NaN is returned and {{lc|FE_INVALID}} is raised
* If the argument is -∞, NaN is returned and {{lc|FE_INVALID}} is raised
* If the argument is +∞, +∞ is returned.
* If the argument is NaN, NaN is returned

===Notes===
If {{tt|arg}} is a natural number, {{c|std::tgamma(arg)}} is the factorial of {{tt|arg-1}}. Many implementations calculate the exact integer-domain factorial if the argument is a sufficiently small integer.

For IEEE-compatible type {{c|double}}, overflow happens if {{tt|0 &lt; x &lt; 1/DBL_MAX}} or if {{tt|x &gt; 171.7}}

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/tgamma.html POSIX requires] that a pole error occurs if the argument is zero, but a domain error occurs when the argument is a negative integer. It also specifies that in future, domain errors may be replaced by pole errors for negative integer arguments (in which case the return value in those cases would change from NaN to ±∞).

There is a non-standard function named {{tt|gamma}} in various implementations, but its definition is inconsistent. For example, glibc and 4.2BSD version of {{tt|gamma}} executes {{tt|lgamma}}, but 4.4BSD version of {{tt|gamma}} executes {{tt|tgamma}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;
#include &lt;cfenv&gt;
#pragma STDC FENV_ACCESS ON
int main()
{
    std::cout &lt;&lt; &quot;tgamma(10) = &quot; &lt;&lt; std::tgamma(10)
              &lt;&lt; &quot;, 9! = &quot; &lt;&lt; 2*3*4*5*6*7*8*9 &lt;&lt; '\n'
              &lt;&lt; &quot;tgamma(0.5) = &quot; &lt;&lt; std::tgamma(0.5)
              &lt;&lt; &quot;, sqrt(pi) = &quot; &lt;&lt; std::sqrt(std::acos(-1)) &lt;&lt; '\n';
    // special values
    std::cout &lt;&lt; &quot;tgamma(1) = &quot; &lt;&lt; std::tgamma(1) &lt;&lt; '\n'
              &lt;&lt; &quot;tgamma(+Inf) = &quot; &lt;&lt; std::tgamma(INFINITY) &lt;&lt; '\n';
    // error handling 
    errno=0; std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;tgamma(-1) = &quot; &lt;&lt; std::tgamma(-1) &lt;&lt; '\n';
    if(errno == EDOM)
        std::cout &lt;&lt; &quot;    errno == EDOM: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID))
        std::cout &lt;&lt; &quot;    FE_INVALID raised\n&quot;;
}
|p=true
|output=
tgamma(10) = 362880, 9! = 362880
tgamma(0.5) = 1.77245, sqrt(pi) = 1.77245
tgamma(1) = 1
tgamma(+Inf) = inf
tgamma(-1) = nan
    errno == EDOM: Numerical argument out of domain
    FE_INVALID raised
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc lgamma}}
{{dsc see c | c/numeric/math/tgamma}}
{{dsc end}}

===External links===
[http://mathworld.wolfram.com/GammaFunction.html Weisstein, Eric W. &quot;Gamma Function.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/math/tgamma]]
[[es:cpp/numeric/math/tgamma]]
[[fr:cpp/numeric/math/tgamma]]
[[it:cpp/numeric/math/tgamma]]
[[ja:cpp/numeric/math/tgamma]]
[[pt:cpp/numeric/math/tgamma]]
[[ru:cpp/numeric/math/tgamma]]
[[zh:cpp/numeric/math/tgamma]]</text>
      <sha1>g2xu4a1bwa378ojefy283flnd33z45a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/math/trunc</title>
    <ns>0</ns>
    <id>1378</id>
    <revision>
      <id>71877</id>
      <parentid>70504</parentid>
      <timestamp>2014-06-30T18:08:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+details, +example</comment>
      <text xml:space="preserve" bytes="2834">{{cpp/title|trunc}}
{{cpp/numeric/math/navbar}}
{{dcl begin}}
{{dcl header | cmath}}
{{dcl | since=c++11 | num=1|
float       trunc( float arg );
}}
{{dcl | since=c++11 | num=2|
double      trunc( double arg );
}}
{{dcl | since=c++11 | num=3|
long double trunc( long double arg );
}}
{{dcl | since=c++11 | num=4|
double      trunc( Integral arg );
}}
{{dcl end}}

@1-3@ Computes the nearest integer not greater in magnitude than {{tt|arg}}. 
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).

===Parameters===
{{par begin}}
{{par | arg | floating point value}}
{{par end}}

===Return value===
If no errors occur, the nearest integer value not greater in magnitude than {{tt|arg}} (in other words, {{tt|arg}} rounded towards zero), is returned.

{{plot | left=Return value | bottom=Argument | math-trunc.svg}}

===Error handling===
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]

If the implementation supports IEEE floating-point arithmetic (IEC 60559),
* The current [[cpp/numeric/fenv/FE_round|rounding mode]] has no effect.
* If {{tt|arg}} is ±∞, it is returned, unmodified
* If {{tt|arg}} is ±0, it is returned, unmodified
* If arg is NaN, NaN is returned

===Notes===
{{lc|FE_INEXACT}} may be (but isn't required to be) raised when truncating a non-integer finite value.

The largest representable floating-point values are exact integers in all standard floating-point formats, so this function never overflows on its own; however the result may overflow any integer type (including {{lc|std::intmax_t}}), when stored in an integer variable.

The [[cpp/language/implicit_cast|implicit conversion]] from floating-point to integral types also rounds towards zero, but is limited to the values that can be represented by the target type.

===Example===
{{example
 | code=
#include &lt;cmath&gt;
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; std::fixed
              &lt;&lt; &quot;trunc(+2.7) = &quot; &lt;&lt; std::trunc(+2.7) &lt;&lt; '\n'
              &lt;&lt; &quot;trunc(-2.9) = &quot; &lt;&lt; std::trunc(-2.9) &lt;&lt; '\n'
              &lt;&lt; &quot;trunc(-0.0) = &quot; &lt;&lt; std::trunc(-0.0) &lt;&lt; '\n'
              &lt;&lt; &quot;trunc(-Inf) = &quot; &lt;&lt; std::trunc(-INFINITY) &lt;&lt; '\n';
}
 | p=true
 | output=
trunc(+2.7) = 2.000000
trunc(-2.9) = -2.000000
trunc(-0.0) = -0.000000
trunc(-Inf) = -inf
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc floor}}
{{dsc inc | cpp/numeric/math/dsc ceil}}
{{dsc inc | cpp/numeric/math/dsc round}}
{{dsc see c | c/numeric/math/trunc}}
{{dsc end}}

[[de:cpp/numeric/math/trunc]]
[[es:cpp/numeric/math/trunc]]
[[fr:cpp/numeric/math/trunc]]
[[it:cpp/numeric/math/trunc]]
[[ja:cpp/numeric/math/trunc]]
[[pt:cpp/numeric/math/trunc]]
[[ru:cpp/numeric/math/trunc]]
[[zh:cpp/numeric/math/trunc]]</text>
      <sha1>ghqgsja6czx765mx7hgeu6omccyunaf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random</title>
    <ns>0</ns>
    <id>2063</id>
    <revision>
      <id>72304</id>
      <parentid>71063</parentid>
      <timestamp>2014-08-06T19:58:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>dsc</comment>
      <text xml:space="preserve" bytes="9850">{{title|Pseudo-random number generation}}
{{cpp/numeric/random/navbar}}

The random number library provides classes that generate random and pseudo-random numbers.  These classes include:

* Random number engines (both pseudo-random number generators, which generate integer sequences with a uniform distribution, and true random number generators if available) 
* Random number distributions (e.g. [[cpp/numeric/random/uniform_int_distribution|uniform]], [[cpp/numeric/random/normal_distribution|normal]], or [[cpp/numeric/random/poisson_distribution|poisson distributions]]) which convert the output of random number engines into various statistical distributions 

Engines and distributions are designed to be used together to produce random values. All of the engines may be specifically seeded, serialized, and deserialized for use with repeatable simulators.

===Random number engines===

Random number engines generate pseudo-random numbers using seed data as entropy source. Several different classes of pseudo-random number generation algorithms are implemented as templates that can be customized.

The choice of which engine to use involves a number of tradeoffs:  the linear congruential engine is moderately fast and has a very small storage requirement for state.  The lagged Fibonacci generators are very fast even on processors without advanced arithmetic instruction sets, at the expense of greater state storage and sometimes less desirable spectral characteristics.  The Mersenne twister is slower and has greater state storage requirements but with the right parameters has the longest non-repeating sequence with the most desirable spectral characteristics (for a given definition of desirable).

{{dsc begin}}
{{dsc header | random}}
{{dsc tclass | cpp/numeric/random/linear_congruential_engine | implements [[enwiki:Linear_congruential_generator | linear congruential]] algorithm | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/mersenne_twister_engine | implements [[enwiki:Mersenne_twister | Mersenne twister]] algorithm | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/subtract_with_carry_engine | implements subtract with carry (a [[enwiki:Lagged_Fibonacci_generator | lagged Fibonacci]]) algorithm | notes={{mark c++11}}}}
{{dsc end}}

====Random number engine adaptors====

Random number engine adaptors generate pseudo-random numbers using another random number engine as entropy source.  They are generally used to alter the spectral characteristics of the underlying engine.

{{dsc begin}}
{{dsc header | random}}
{{dsc tclass | cpp/numeric/random/discard_block_engine | discards some output of a random number engine | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/independent_bits_engine | packs the output of a random number engine into blocks of specified number of bits | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/shuffle_order_engine | delivers the output of a random number engine in different order | notes={{mark c++11}}}}
{{dsc end}}

====Predefined random number generators====

Several specific popular algorithms are predefined.

{{dsc begin}}
{{dsc header | random}}
{{dsc hitem | Type | Definition}}
{{dsc inc | cpp/numeric/random/dsc minstd_rand0}}
{{dsc inc | cpp/numeric/random/dsc minstd_rand}}
{{dsc inc | cpp/numeric/random/dsc mt19937}}
{{dsc inc | cpp/numeric/random/dsc mt19937_64}}
{{dsc inc | cpp/numeric/random/dsc ranlux24_base}}
{{dsc inc | cpp/numeric/random/dsc ranlux48_base}}
{{dsc inc | cpp/numeric/random/dsc ranlux24}}
{{dsc inc | cpp/numeric/random/dsc ranlux48}}
{{dsc inc | cpp/numeric/random/dsc knuth_b}}
{{dsc | {{tt|default_random_engine}} | ''implementation-defined''}}
{{dsc end}}

====Non-deterministic random numbers====

{{lc|std::random_device}} is a non-deterministic random number engine, although implementations are allowed to implement {{lc|std::random_device}} using a pseudo-random number engine if there is no support for non-deterministic random number generation.

{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc random_device}}
{{dsc end}}

===Random number distributions===

A random number distribution post-processes the output of an random number engine in such a way that resulting output is distributed according to a defined statistical probability density function.

{{dsc begin}}
{{dsc header | random}}
{{dsc sep}}
{{dsc h2 | Uniform distributions}}
{{dsc inc | cpp/numeric/random/dsc uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/dsc uniform_real_distribution}}
{{dsc inc | cpp/numeric/random/dsc generate_canonical}}

{{dsc h2 | Bernoulli distributions}}
{{dsc class | cpp/numeric/random/bernoulli_distribution | produces {{c|bool}} values on a [[enwiki:Bernoulli_distribution | Bernoulli distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/binomial_distribution | produces integer values on a  [[enwiki:Binomial_distribution | binomial distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/negative_binomial_distribution | produces integer values on a  [[enwiki:Negative_binomial_distribution | negative binomial distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/geometric_distribution | produces integer values on a  [[enwiki:Geometric_distribution | geometric distribution]].  | notes={{mark c++11}}}}

{{dsc h2 | Poisson distributions}}
{{dsc tclass | cpp/numeric/random/poisson_distribution | produces integer values on a  [[enwiki:Poisson_distribution | poisson distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/exponential_distribution | produces real values on an  [[enwiki:Exponential_distribution | exponential distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/gamma_distribution | produces real values on an  [[enwiki:Gamma_distribution | gamma distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/weibull_distribution |produces real values on a  [[enwiki:Weibull_distribution | Weibull distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/extreme_value_distribution | produces real values on an  [[enwiki:Generalized_extreme_value_distribution | extreme value distribution]]. | notes={{mark c++11}}}}

{{dsc h2 | Normal distributions}}
{{dsc tclass | cpp/numeric/random/normal_distribution | produces real values on a  [[enwiki:Normal_distribution | standard normal (Gaussian) distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/lognormal_distribution | produces real values on a  [[enwiki:Lognormal_distribution | lognormal distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/chi_squared_distribution | produces real values on a  [[enwiki:Chi-squared_distribution | chi-squared distribution]].  | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/cauchy_distribution | produces real values on a  [[enwiki:Cauchy_distribution | Cauchy distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/fisher_f_distribution | produces real values on a  [[enwiki:F-distribution | Fisher's F-distribution]]. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/student_t_distribution | produces real values on a  [[enwiki:Student's t-distribution | Student's t-distribution]]. | notes={{mark c++11}}}}

{{dsc h2 | Sampling distributions}}
{{dsc tclass | cpp/numeric/random/discrete_distribution | produces random integers on a discrete distribution. | notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/piecewise_constant_distribution | produces real values distributed on constant subintervals.| notes={{mark c++11}}}}
{{dsc tclass | cpp/numeric/random/piecewise_linear_distribution | produces real values distributed on defined subintervals. | notes={{mark c++11}}}}
{{dsc end}}

===Utilities===

{{dsc begin}}
{{dsc header | random}}
{{dsc class | cpp/numeric/random/seed_seq | general-purpose bias-eliminating scrambled seed sequence generator | notes={{mark c++11}}}}
{{dsc end}}

===C random library===

In addition to the engines and distributions described above, the functions and constants from the C random library are also available though not recommended:

{{dsc begin}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/numeric/random/dsc rand}}
{{dsc inc | cpp/numeric/random/dsc srand}}
{{dsc inc | cpp/numeric/random/dsc RAND_MAX}}
{{dsc end}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
#include &lt;cmath&gt;

int main()
{
    // Seed with a real random value, if available
    std::random_device rd;

    // Choose a random mean between 1 and 6
    std::default_random_engine e1(rd());
    std::uniform_int_distribution&lt;int&gt; uniform_dist(1, 6);
    int mean = uniform_dist(e1);
    std::cout &lt;&lt; &quot;Randomly-chosen mean: &quot; &lt;&lt; mean &lt;&lt; '\n';
   
    // Generate a normal distribution around that mean
    std::mt19937 e2(rd());
    std::normal_distribution&lt;&gt; normal_dist(mean, 2);
 
    std::map&lt;int, int&gt; hist;
    for (int n = 0; n &lt; 10000; ++n) {
        ++hist[std::round(normal_dist(e2))];
    }
    std::cout &lt;&lt; &quot;Normal distribution around &quot; &lt;&lt; mean &lt;&lt; &quot;:\n&quot;;
    for (auto p : hist) {
        std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(1) &lt;&lt; std::setw(2)
                  &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/200, '*') &lt;&lt; '\n';
    }
}
 | output=
Randomly-chosen mean: 4
Normal distribution around 4:
-4 
-3 
-2 
-1 
 0 *
 1 ***
 2 ******
 3 ********
 4 *********
 5 ********
 6 ******
 7 ***
 8 *
 9 
10 
11 
12 
}}

===See also===
{{dsc begin}}
{{dsc see c | c/numeric/random | Pseudo-random number generation}}
{{dsc end}}

[[de:cpp/numeric/random]]
[[es:cpp/numeric/random]]
[[fr:cpp/numeric/random]]
[[it:cpp/numeric/random]]
[[ja:cpp/numeric/random]]
[[pt:cpp/numeric/random]]
[[ru:cpp/numeric/random]]
[[zh:cpp/numeric/random]]</text>
      <sha1>fl2ruemjv0zga3mk7eg35ju7213msh4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/RAND MAX</title>
    <ns>0</ns>
    <id>3320</id>
    <revision>
      <id>58660</id>
      <parentid>50331</parentid>
      <timestamp>2013-06-01T06:19:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="781">{{title|RAND_MAX}}
{{cpp/numeric/random/navbar}}
{{ddcl | header=cstdlib |
#define RAND_MAX /*implementation defined*/
}}

Expands to an integer constant expression equal to the maximum value returned by the function {{lc|std::rand}}. This value is implementation dependent. It's guaranteed that this value is at least {{c|32767}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc rand}}
{{dsc inc | cpp/numeric/random/dsc srand}}
{{dsc see c | c/numeric/random/RAND_MAX}}
{{dsc end}}

[[de:cpp/numeric/random/RAND MAX]]
[[es:cpp/numeric/random/RAND MAX]]
[[fr:cpp/numeric/random/RAND MAX]]
[[it:cpp/numeric/random/RAND MAX]]
[[ja:cpp/numeric/random/RAND MAX]]
[[pt:cpp/numeric/random/RAND MAX]]
[[ru:cpp/numeric/random/RAND MAX]]
[[zh:cpp/numeric/random/RAND MAX]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution</title>
    <ns>0</ns>
    <id>3911</id>
    <revision>
      <id>63368</id>
      <parentid>58663</parentid>
      <timestamp>2013-07-10T01:29:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2689">{{cpp/title|bernoulli_distribution}}
{{cpp/numeric/random/bernoulli_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
class bernoulli_distribution;
}}

Produces random boolean values, according to the discrete probability function. The probability of {{c|true}} is 

:{{math|P(b{{!}}p) {{=}}}}{{mparen|{||{{math|p}} if {{c|b {{==}} true }} | {{math|1 − p}} if {{c|b {{==}} false}}|style=text-align:right}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|bool}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | bernoulli_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | bernoulli_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | bernoulli_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/bernoulli_distribution/dsc p}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | bernoulli_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | bernoulli_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | bernoulli_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | bernoulli_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | bernoulli_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    // give &quot;true&quot; 1/4 of the time
    // give &quot;false&quot; 3/4 of the time
    std::bernoulli_distribution d(0.25);
 
    std::map&lt;bool, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::boolalpha &lt;&lt; std::setw(5) &lt;&lt; p.first
                  &lt;&lt; ' ' &lt;&lt; std::string(p.second/500, '*') &lt;&lt; '\n';
    }
}
 | output=
false ***************
 true ****
}}

===External links===
[http://mathworld.wolfram.com/BernoulliDistribution.html Weisstein, Eric W. &quot;Bernoulli Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/bernoulli distribution]]
[[es:cpp/numeric/random/bernoulli distribution]]
[[fr:cpp/numeric/random/bernoulli distribution]]
[[it:cpp/numeric/random/bernoulli distribution]]
[[ja:cpp/numeric/random/bernoulli distribution]]
[[pt:cpp/numeric/random/bernoulli distribution]]
[[ru:cpp/numeric/random/bernoulli distribution]]
[[zh:cpp/numeric/random/bernoulli distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/bernoulli distribution</title>
    <ns>0</ns>
    <id>4919</id>
    <revision>
      <id>65146</id>
      <parentid>62888</parentid>
      <timestamp>2013-09-02T08:35:28Z</timestamp>
      <contributor>
        <ip>216.170.11.13</ip>
      </contributor>
      <comment>Per Standard 26.5.8.3.1 the default parameter is 0.5</comment>
      <text xml:space="preserve" bytes="1263">{{cpp/numeric/random/bernoulli_distribution/title|bernoulli_distribution}}
{{cpp/numeric/random/bernoulli_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit bernoulli_distribution( double p = 0.5 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit bernoulli_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|p}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | p | the ''p'' distribution parameter (probability of generating {{c|true}})}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[es:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[fr:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[it:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[ja:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[pt:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[ru:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]
[[zh:cpp/numeric/random/bernoulli distribution/bernoulli distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/max</title>
    <ns>0</ns>
    <id>4002</id>
    <revision>
      <id>50891</id>
      <parentid>44149</parentid>
      <timestamp>2013-06-01T03:44:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/max|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/max]]
[[es:cpp/numeric/random/bernoulli distribution/max]]
[[fr:cpp/numeric/random/bernoulli distribution/max]]
[[it:cpp/numeric/random/bernoulli distribution/max]]
[[ja:cpp/numeric/random/bernoulli distribution/max]]
[[pt:cpp/numeric/random/bernoulli distribution/max]]
[[ru:cpp/numeric/random/bernoulli distribution/max]]
[[zh:cpp/numeric/random/bernoulli distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/min</title>
    <ns>0</ns>
    <id>3983</id>
    <revision>
      <id>50892</id>
      <parentid>44146</parentid>
      <timestamp>2013-06-01T03:44:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/min|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/min]]
[[es:cpp/numeric/random/bernoulli distribution/min]]
[[fr:cpp/numeric/random/bernoulli distribution/min]]
[[it:cpp/numeric/random/bernoulli distribution/min]]
[[ja:cpp/numeric/random/bernoulli distribution/min]]
[[pt:cpp/numeric/random/bernoulli distribution/min]]
[[ru:cpp/numeric/random/bernoulli distribution/min]]
[[zh:cpp/numeric/random/bernoulli distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/operator()</title>
    <ns>0</ns>
    <id>4100</id>
    <revision>
      <id>44141</id>
      <parentid>15049</parentid>
      <timestamp>2012-11-03T05:07:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="550">{{cpp/numeric/random/distribution/operator()|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/operator()]]
[[es:cpp/numeric/random/bernoulli distribution/operator()]]
[[fr:cpp/numeric/random/bernoulli distribution/operator()]]
[[it:cpp/numeric/random/bernoulli distribution/operator()]]
[[ja:cpp/numeric/random/bernoulli distribution/operator()]]
[[pt:cpp/numeric/random/bernoulli distribution/operator()]]
[[ru:cpp/numeric/random/bernoulli distribution/operator()]]
[[zh:cpp/numeric/random/bernoulli distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/operator cmp</title>
    <ns>0</ns>
    <id>4142</id>
    <revision>
      <id>50893</id>
      <parentid>44136</parentid>
      <timestamp>2013-06-01T03:44:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/operator_cmp|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[es:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[fr:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[it:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[ja:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[pt:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[ru:cpp/numeric/random/bernoulli distribution/operator cmp]]
[[zh:cpp/numeric/random/bernoulli distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4537</id>
    <revision>
      <id>50894</id>
      <parentid>44132</parentid>
      <timestamp>2013-06-01T03:44:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="626">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/bernoulli distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/p</title>
    <ns>0</ns>
    <id>5005</id>
    <revision>
      <id>65147</id>
      <parentid>63369</parentid>
      <timestamp>2013-09-02T08:37:53Z</timestamp>
      <contributor>
        <ip>216.170.11.13</ip>
      </contributor>
      <comment>Per Standard 26.5.8.3.1 the default parameter is 0.5</comment>
      <text xml:space="preserve" bytes="960">{{cpp/numeric/random/bernoulli_distribution/title|p}}
{{cpp/numeric/random/bernoulli_distribution/navbar}}
{{ddcl | since=c++11 | 1=
double p() const;
}}

Returns the {{math|p}} parameter the distribution was constructed with. It defines the probability of generating {{c|true}}. The default value is {{c|0.5}}.

===Parameters===
(none)

===Return value===
Floating point value identifying the {{math|p}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | bernoulli_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/bernoulli distribution/p]]
[[es:cpp/numeric/random/bernoulli distribution/p]]
[[fr:cpp/numeric/random/bernoulli distribution/p]]
[[it:cpp/numeric/random/bernoulli distribution/p]]
[[ja:cpp/numeric/random/bernoulli distribution/p]]
[[pt:cpp/numeric/random/bernoulli distribution/p]]
[[ru:cpp/numeric/random/bernoulli distribution/p]]
[[zh:cpp/numeric/random/bernoulli distribution/p]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/param</title>
    <ns>0</ns>
    <id>4123</id>
    <revision>
      <id>50895</id>
      <parentid>44118</parentid>
      <timestamp>2013-06-01T03:44:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/param|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/param]]
[[es:cpp/numeric/random/bernoulli distribution/param]]
[[fr:cpp/numeric/random/bernoulli distribution/param]]
[[it:cpp/numeric/random/bernoulli distribution/param]]
[[ja:cpp/numeric/random/bernoulli distribution/param]]
[[pt:cpp/numeric/random/bernoulli distribution/param]]
[[ru:cpp/numeric/random/bernoulli distribution/param]]
[[zh:cpp/numeric/random/bernoulli distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/bernoulli distribution/reset</title>
    <ns>0</ns>
    <id>4095</id>
    <revision>
      <id>50896</id>
      <parentid>44113</parentid>
      <timestamp>2013-06-01T03:44:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/reset|bernoulli_distribution}}

[[de:cpp/numeric/random/bernoulli distribution/reset]]
[[es:cpp/numeric/random/bernoulli distribution/reset]]
[[fr:cpp/numeric/random/bernoulli distribution/reset]]
[[it:cpp/numeric/random/bernoulli distribution/reset]]
[[ja:cpp/numeric/random/bernoulli distribution/reset]]
[[pt:cpp/numeric/random/bernoulli distribution/reset]]
[[ru:cpp/numeric/random/bernoulli distribution/reset]]
[[zh:cpp/numeric/random/bernoulli distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution</title>
    <ns>0</ns>
    <id>3912</id>
    <revision>
      <id>66968</id>
      <parentid>63370</parentid>
      <timestamp>2014-01-13T14:32:48Z</timestamp>
      <contributor>
        <ip>129.67.116.118</ip>
      </contributor>
      <text xml:space="preserve" bytes="3115">{{cpp/title|binomial_distribution}}
{{cpp/numeric/random/binomial_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class binomial_distribution;
}}

Produces random non-negative integer values {{math|i}}, distributed according to discrete probability function:

:{{math|P(i{{!}}t,p) {{=}}{{mparen|(|)|t|i}} · p{{su|p=i}} · (1 − p){{su|p=t−i}}}}

The value obtained is the number of successes in a sequence of {{math|t}} yes/no experiments, each of which succeeds with probability {{math|p}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | binomial_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | binomial_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | binomial_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | binomial_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | binomial_distribution}}
{{dsc end}}

===Example===
{{example
 | Plot of binomial distribution with probability of success of each trial exactly 0.5, illustrating the relationship with the pascal triangle (the probabilities that none, 1, 2, 3, or all four of the 4 trials will be successful in this case are 1:4:6:4:1)
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    // perform 4 trials, each succeeds 1 in 2 times
    std::binomial_distribution&lt;&gt; d(4, 0.5);

    std::map&lt;int, int&gt; hist;
    for (int n = 0; n &lt; 10000; ++n) {
        ++hist[d(gen)];
    }
    for (auto p : hist) {
        std::cout &lt;&lt; p.first &lt;&lt; ' '
                  &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 ******
1 ************************
2 *************************************
3 *************************
4 ******
}}

===External links===
[http://mathworld.wolfram.com/BinomialDistribution.html Weisstein, Eric W. &quot;Binomial Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/binomial distribution]]
[[es:cpp/numeric/random/binomial distribution]]
[[fr:cpp/numeric/random/binomial distribution]]
[[it:cpp/numeric/random/binomial distribution]]
[[ja:cpp/numeric/random/binomial distribution]]
[[pt:cpp/numeric/random/binomial distribution]]
[[ru:cpp/numeric/random/binomial distribution]]
[[zh:cpp/numeric/random/binomial distribution]]</text>
      <sha1>l6brnzrucxxmioa1pw8zx0oeg9hfowj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/binomial distribution</title>
    <ns>0</ns>
    <id>4920</id>
    <revision>
      <id>62889</id>
      <parentid>50336</parentid>
      <timestamp>2013-07-01T23:45:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1418">{{cpp/numeric/random/binomial_distribution/title|binomial_distribution}}
{{cpp/numeric/random/binomial_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit binomial_distribution( IntType t = 1, double p = 0.5 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit binomial_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|t}} and {{tt|p}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | t | the ''t'' distribution parameter (number of trials)}}
{{par | p | the ''p'' distribution parameter (probability of a trial generating {{c|true}})}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|0 ≤ p ≤ 1}} and {{math|0 ≤ t}}.

[[de:cpp/numeric/random/binomial distribution/binomial distribution]]
[[es:cpp/numeric/random/binomial distribution/binomial distribution]]
[[fr:cpp/numeric/random/binomial distribution/binomial distribution]]
[[it:cpp/numeric/random/binomial distribution/binomial distribution]]
[[ja:cpp/numeric/random/binomial distribution/binomial distribution]]
[[pt:cpp/numeric/random/binomial distribution/binomial distribution]]
[[ru:cpp/numeric/random/binomial distribution/binomial distribution]]
[[zh:cpp/numeric/random/binomial distribution/binomial distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/max</title>
    <ns>0</ns>
    <id>4003</id>
    <revision>
      <id>50897</id>
      <parentid>44100</parentid>
      <timestamp>2013-06-01T03:44:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/max|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/max]]
[[es:cpp/numeric/random/binomial distribution/max]]
[[fr:cpp/numeric/random/binomial distribution/max]]
[[it:cpp/numeric/random/binomial distribution/max]]
[[ja:cpp/numeric/random/binomial distribution/max]]
[[pt:cpp/numeric/random/binomial distribution/max]]
[[ru:cpp/numeric/random/binomial distribution/max]]
[[zh:cpp/numeric/random/binomial distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/min</title>
    <ns>0</ns>
    <id>3982</id>
    <revision>
      <id>50898</id>
      <parentid>44096</parentid>
      <timestamp>2013-06-01T03:44:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/min|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/min]]
[[es:cpp/numeric/random/binomial distribution/min]]
[[fr:cpp/numeric/random/binomial distribution/min]]
[[it:cpp/numeric/random/binomial distribution/min]]
[[ja:cpp/numeric/random/binomial distribution/min]]
[[pt:cpp/numeric/random/binomial distribution/min]]
[[ru:cpp/numeric/random/binomial distribution/min]]
[[zh:cpp/numeric/random/binomial distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/operator()</title>
    <ns>0</ns>
    <id>4101</id>
    <revision>
      <id>44091</id>
      <parentid>15050</parentid>
      <timestamp>2012-11-03T04:57:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="541">{{cpp/numeric/random/distribution/operator()|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/operator()]]
[[es:cpp/numeric/random/binomial distribution/operator()]]
[[fr:cpp/numeric/random/binomial distribution/operator()]]
[[it:cpp/numeric/random/binomial distribution/operator()]]
[[ja:cpp/numeric/random/binomial distribution/operator()]]
[[pt:cpp/numeric/random/binomial distribution/operator()]]
[[ru:cpp/numeric/random/binomial distribution/operator()]]
[[zh:cpp/numeric/random/binomial distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/operator cmp</title>
    <ns>0</ns>
    <id>4143</id>
    <revision>
      <id>50899</id>
      <parentid>44086</parentid>
      <timestamp>2013-06-01T03:44:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="572">{{include page|cpp/numeric/random/distribution/operator_cmp|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/operator cmp]]
[[es:cpp/numeric/random/binomial distribution/operator cmp]]
[[fr:cpp/numeric/random/binomial distribution/operator cmp]]
[[it:cpp/numeric/random/binomial distribution/operator cmp]]
[[ja:cpp/numeric/random/binomial distribution/operator cmp]]
[[pt:cpp/numeric/random/binomial distribution/operator cmp]]
[[ru:cpp/numeric/random/binomial distribution/operator cmp]]
[[zh:cpp/numeric/random/binomial distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4536</id>
    <revision>
      <id>50900</id>
      <parentid>44081</parentid>
      <timestamp>2013-06-01T03:44:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="617">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/binomial distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/binomial distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/p</title>
    <ns>0</ns>
    <id>5012</id>
    <redirect title="cpp/numeric/random/binomial distribution/params" />
    <revision>
      <id>61191</id>
      <parentid>58668</parentid>
      <timestamp>2013-06-05T12:27:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/binomial distribution/params]]</comment>
      <text xml:space="preserve" bytes="61">#redirect [[cpp/numeric/random/binomial_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/param</title>
    <ns>0</ns>
    <id>4124</id>
    <revision>
      <id>67889</id>
      <parentid>50901</parentid>
      <timestamp>2014-03-04T14:27:27Z</timestamp>
      <contributor>
        <username>Wanttoknow</username>
        <id>2904</id>
      </contributor>
      <text xml:space="preserve" bytes="1085">{{include page|cpp/numeric/random/distribution/param|binomial_distribution}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    using BinomialDist = std::binomial_distribution&lt;&gt;;
    BinomialDist bino_dis(1, 0.5);
    
    std::cout &lt;&lt; &quot;A sample of Binomial(  1, 0.5): &quot; &lt;&lt; bino_dis(gen) &lt;&lt; '\n';

    // Use another parameter set
    bino_dis.param(BinomialDist::param_type(100,0.9));
    std::cout &lt;&lt; &quot;A sample of Binomial(100, 0.9): &quot; &lt;&lt; bino_dis(gen) &lt;&lt; '\n';
}
 | output=
A sample of Binomial(  1, 0.5): 0
A sample of Binomial(100, 0.9): 94
}}

[[de:cpp/numeric/random/binomial distribution/param]]
[[es:cpp/numeric/random/binomial distribution/param]]
[[fr:cpp/numeric/random/binomial distribution/param]]
[[it:cpp/numeric/random/binomial distribution/param]]
[[ja:cpp/numeric/random/binomial distribution/param]]
[[pt:cpp/numeric/random/binomial distribution/param]]
[[ru:cpp/numeric/random/binomial distribution/param]]
[[zh:cpp/numeric/random/binomial distribution/param]]</text>
      <sha1>bvjtjbcjuhz5lzfhkhkd0jexowyosm2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/params</title>
    <ns>0</ns>
    <id>12600</id>
    <revision>
      <id>61266</id>
      <parentid>61242</parentid>
      <timestamp>2013-06-05T13:14:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce, default value</comment>
      <text xml:space="preserve" bytes="816">{{cpp/numeric/random/binomial_distribution/title|p, t}}
{{cpp/numeric/random/binomial_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
double p() const;
}}
{{dcl | since=c++11 | num=2 |
IntType t() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the {{math|p}} distribution parameter. It defines the probability of a trial generating {{c|true}}. The default value is {{c|0.5}}.

@2@ Returns the {{math|t}} distribution parameter. It identifies the number of trials. The default value is {{c|1}}.

===Parameters===
(none)

===Return value===
@1@ The {{math|p}} distribution parameter.

@2@ The {{math|t}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | binomial_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/reset</title>
    <ns>0</ns>
    <id>4078</id>
    <revision>
      <id>50902</id>
      <parentid>44065</parentid>
      <timestamp>2013-06-01T03:44:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{include page|cpp/numeric/random/distribution/reset|binomial_distribution}}

[[de:cpp/numeric/random/binomial distribution/reset]]
[[es:cpp/numeric/random/binomial distribution/reset]]
[[fr:cpp/numeric/random/binomial distribution/reset]]
[[it:cpp/numeric/random/binomial distribution/reset]]
[[ja:cpp/numeric/random/binomial distribution/reset]]
[[pt:cpp/numeric/random/binomial distribution/reset]]
[[ru:cpp/numeric/random/binomial distribution/reset]]
[[zh:cpp/numeric/random/binomial distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/binomial distribution/t</title>
    <ns>0</ns>
    <id>5013</id>
    <redirect title="cpp/numeric/random/binomial distribution/params" />
    <revision>
      <id>61192</id>
      <parentid>58669</parentid>
      <timestamp>2013-06-05T12:27:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/binomial distribution/params]]</comment>
      <text xml:space="preserve" bytes="61">#redirect [[cpp/numeric/random/binomial_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution</title>
    <ns>0</ns>
    <id>3923</id>
    <revision>
      <id>63371</id>
      <parentid>61122</parentid>
      <timestamp>2013-07-10T01:30:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2168">{{cpp/title|cauchy_distribution}}
{{cpp/numeric/random/cauchy_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class cauchy_distribution;
}}

Produces random numbers according to a Cauchy distribution (also called Lorentz distribution):

:{{math|f(x; a,b) {{=}} {{mparen|(|)|bπ {{mparen|[|]|1 + {{mparen|(|)|{{mfrac| |x - a|b}}}}{{su|p=2}}}}}}{{su|p=-1}} }}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | cauchy_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | cauchy_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | cauchy_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | cauchy_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | cauchy_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | cauchy_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | cauchy_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | cauchy_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | cauchy_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
[http://mathworld.wolfram.com/CauchyDistribution.html Weisstein, Eric W. &quot;Cauchy Distribution.&quot;] From MathWorld--A Wolfram Web Resource.
[https://en.wikipedia.org/wiki/Cauchy_distribution Cauchy Distribution.] From Wikipedia.

[[de:cpp/numeric/random/cauchy distribution]]
[[es:cpp/numeric/random/cauchy distribution]]
[[fr:cpp/numeric/random/cauchy distribution]]
[[it:cpp/numeric/random/cauchy distribution]]
[[ja:cpp/numeric/random/cauchy distribution]]
[[pt:cpp/numeric/random/cauchy distribution]]
[[ru:cpp/numeric/random/cauchy distribution]]
[[zh:cpp/numeric/random/cauchy distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/a</title>
    <ns>0</ns>
    <id>8875</id>
    <redirect title="cpp/numeric/random/cauchy distribution/params" />
    <revision>
      <id>61126</id>
      <parentid>58673</parentid>
      <timestamp>2013-06-05T11:57:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/cauchy distribution/params]]</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/numeric/random/cauchy_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/b</title>
    <ns>0</ns>
    <id>8876</id>
    <redirect title="cpp/numeric/random/cauchy distribution/params" />
    <revision>
      <id>61125</id>
      <parentid>58676</parentid>
      <timestamp>2013-06-05T11:57:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/cauchy distribution/params]]</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/numeric/random/cauchy_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/cauchy distribution</title>
    <ns>0</ns>
    <id>4962</id>
    <revision>
      <id>62890</id>
      <parentid>50342</parentid>
      <timestamp>2013-07-01T23:45:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1264">{{cpp/numeric/random/cauchy_distribution/title|cauchy_distribution}}
{{cpp/numeric/random/cauchy_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit cauchy_distribution( RealType a = 0.0, RealType b = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit cauchy_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|a}} and {{tt|b}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | a | the ''a'' distribution parameter (location)}}
{{par | b | the ''b'' distribution parameter (scale)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[es:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[fr:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[it:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[ja:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[pt:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[ru:cpp/numeric/random/cauchy distribution/cauchy distribution]]
[[zh:cpp/numeric/random/cauchy distribution/cauchy distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/max</title>
    <ns>0</ns>
    <id>4019</id>
    <revision>
      <id>50903</id>
      <parentid>44035</parentid>
      <timestamp>2013-06-01T03:44:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="473">{{include page|cpp/numeric/random/distribution/max|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/max]]
[[es:cpp/numeric/random/cauchy distribution/max]]
[[fr:cpp/numeric/random/cauchy distribution/max]]
[[it:cpp/numeric/random/cauchy distribution/max]]
[[ja:cpp/numeric/random/cauchy distribution/max]]
[[pt:cpp/numeric/random/cauchy distribution/max]]
[[ru:cpp/numeric/random/cauchy distribution/max]]
[[zh:cpp/numeric/random/cauchy distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/min</title>
    <ns>0</ns>
    <id>3972</id>
    <revision>
      <id>50904</id>
      <parentid>44031</parentid>
      <timestamp>2013-06-01T03:44:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="473">{{include page|cpp/numeric/random/distribution/min|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/min]]
[[es:cpp/numeric/random/cauchy distribution/min]]
[[fr:cpp/numeric/random/cauchy distribution/min]]
[[it:cpp/numeric/random/cauchy distribution/min]]
[[ja:cpp/numeric/random/cauchy distribution/min]]
[[pt:cpp/numeric/random/cauchy distribution/min]]
[[ru:cpp/numeric/random/cauchy distribution/min]]
[[zh:cpp/numeric/random/cauchy distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/operator()</title>
    <ns>0</ns>
    <id>4116</id>
    <revision>
      <id>44026</id>
      <parentid>15065</parentid>
      <timestamp>2012-11-03T04:37:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="523">{{cpp/numeric/random/distribution/operator()|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/operator()]]
[[es:cpp/numeric/random/cauchy distribution/operator()]]
[[fr:cpp/numeric/random/cauchy distribution/operator()]]
[[it:cpp/numeric/random/cauchy distribution/operator()]]
[[ja:cpp/numeric/random/cauchy distribution/operator()]]
[[pt:cpp/numeric/random/cauchy distribution/operator()]]
[[ru:cpp/numeric/random/cauchy distribution/operator()]]
[[zh:cpp/numeric/random/cauchy distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/operator cmp</title>
    <ns>0</ns>
    <id>4154</id>
    <revision>
      <id>50905</id>
      <parentid>44020</parentid>
      <timestamp>2013-06-01T03:44:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="554">{{include page|cpp/numeric/random/distribution/operator_cmp|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/operator cmp]]
[[es:cpp/numeric/random/cauchy distribution/operator cmp]]
[[fr:cpp/numeric/random/cauchy distribution/operator cmp]]
[[it:cpp/numeric/random/cauchy distribution/operator cmp]]
[[ja:cpp/numeric/random/cauchy distribution/operator cmp]]
[[pt:cpp/numeric/random/cauchy distribution/operator cmp]]
[[ru:cpp/numeric/random/cauchy distribution/operator cmp]]
[[zh:cpp/numeric/random/cauchy distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4525</id>
    <revision>
      <id>50906</id>
      <parentid>44015</parentid>
      <timestamp>2013-06-01T03:44:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/cauchy distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/param</title>
    <ns>0</ns>
    <id>4136</id>
    <revision>
      <id>50907</id>
      <parentid>44011</parentid>
      <timestamp>2013-06-01T03:44:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/param|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/param]]
[[es:cpp/numeric/random/cauchy distribution/param]]
[[fr:cpp/numeric/random/cauchy distribution/param]]
[[it:cpp/numeric/random/cauchy distribution/param]]
[[ja:cpp/numeric/random/cauchy distribution/param]]
[[pt:cpp/numeric/random/cauchy distribution/param]]
[[ru:cpp/numeric/random/cauchy distribution/param]]
[[zh:cpp/numeric/random/cauchy distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/params</title>
    <ns>0</ns>
    <id>12597</id>
    <revision>
      <id>61255</id>
      <parentid>61254</parentid>
      <timestamp>2013-06-05T13:02:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1052">{{cpp/numeric/random/cauchy_distribution/title|a, b}}
{{cpp/numeric/random/cauchy_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 
RealType a() const;
}}
{{dcl | since=c++11 | num=2 | 
RealType b() const;
}}
{{dcl end}}

Returns the distribution parameters with which the distribution was constructed.

@1@ Returns the ''a'' parameter. It specifies the location of the peak and is also called location parameter. The default value is {{c|0.0}}.

@2@ Returns the ''b'' parameter. It represents the half-width at half-maximum (HWHM) and is also called scale parameter. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
@1@ The value of the ''a'' parameter.

@2@ The value of the ''b'' parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | cauchy_distribution}}
{{dsc end}}

===External links===
* [https://en.wikipedia.org/wiki/Scale_parameter Scale parameter.] From Wikipedia.
* [https://en.wikipedia.org/wiki/Location_parameter Location parameter.] From Wikipedia.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/cauchy distribution/reset</title>
    <ns>0</ns>
    <id>4089</id>
    <revision>
      <id>50908</id>
      <parentid>44006</parentid>
      <timestamp>2013-06-01T03:44:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/reset|cauchy_distribution}}

[[de:cpp/numeric/random/cauchy distribution/reset]]
[[es:cpp/numeric/random/cauchy distribution/reset]]
[[fr:cpp/numeric/random/cauchy distribution/reset]]
[[it:cpp/numeric/random/cauchy distribution/reset]]
[[ja:cpp/numeric/random/cauchy distribution/reset]]
[[pt:cpp/numeric/random/cauchy distribution/reset]]
[[ru:cpp/numeric/random/cauchy distribution/reset]]
[[zh:cpp/numeric/random/cauchy distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution</title>
    <ns>0</ns>
    <id>3922</id>
    <revision>
      <id>63372</id>
      <parentid>58677</parentid>
      <timestamp>2013-07-10T01:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2470">{{cpp/title|chi_squared_distribution}}
{{cpp/numeric/random/chi_squared_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class chi_squared_distribution;
}}

The {{tt|chi_squared_distribution}} produces random numbers {{math|x&gt;0}} according to the [[enwiki:Chi-squared_distribution|Chi-squared distribution]]:

:{{math|f(x;n) {{=}} {{mfrac||x{{su|p=(n/2)-1}}  {{mexp|-x/2}} | Γ(n/2) 2{{su|p=n/2}} }} }}

{{math|Γ}} is the [[enwiki:Gamma_function|Gamma function]] (See also {{lc|std::tgamma}}) and {{math|n}} are the [[enwiki:Degrees_of_freedom_(statistics)|degrees of freedom]] (default 1).

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | chi_squared_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | chi_squared_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | chi_squared_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/chi_squared_distribution/dsc n}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | chi_squared_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | chi_squared_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | chi_squared_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | chi_squared_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | chi_squared_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
* [http://mathworld.wolfram.com/Chi-SquaredDistribution.html Weisstein, Eric W. &quot;Chi-Squared Distribution.&quot;] From MathWorld--A Wolfram Web Resource.
* [[enwiki:Chi-squared_distribution|Chi-squared distribution.]] From Wikipedia.

[[de:cpp/numeric/random/chi squared distribution]]
[[es:cpp/numeric/random/chi squared distribution]]
[[fr:cpp/numeric/random/chi squared distribution]]
[[it:cpp/numeric/random/chi squared distribution]]
[[ja:cpp/numeric/random/chi squared distribution]]
[[pt:cpp/numeric/random/chi squared distribution]]
[[ru:cpp/numeric/random/chi squared distribution]]
[[zh:cpp/numeric/random/chi squared distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/chi squared distribution</title>
    <ns>0</ns>
    <id>4961</id>
    <revision>
      <id>62891</id>
      <parentid>50344</parentid>
      <timestamp>2013-07-01T23:45:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1289">{{cpp/numeric/random/chi_squared_distribution/title|chi_squared_distribution}}
{{cpp/numeric/random/chi_squared_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit chi_squared_distribution( RealType n = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit chi_squared_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|n}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | n | the ''n'' distribution parameter (degrees of freedom)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[es:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[fr:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[it:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[ja:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[pt:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[ru:cpp/numeric/random/chi squared distribution/chi squared distribution]]
[[zh:cpp/numeric/random/chi squared distribution/chi squared distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/max</title>
    <ns>0</ns>
    <id>4014</id>
    <revision>
      <id>50909</id>
      <parentid>43990</parentid>
      <timestamp>2013-06-01T03:44:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/max|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/max]]
[[es:cpp/numeric/random/chi squared distribution/max]]
[[fr:cpp/numeric/random/chi squared distribution/max]]
[[it:cpp/numeric/random/chi squared distribution/max]]
[[ja:cpp/numeric/random/chi squared distribution/max]]
[[pt:cpp/numeric/random/chi squared distribution/max]]
[[ru:cpp/numeric/random/chi squared distribution/max]]
[[zh:cpp/numeric/random/chi squared distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/min</title>
    <ns>0</ns>
    <id>3971</id>
    <revision>
      <id>50910</id>
      <parentid>43986</parentid>
      <timestamp>2013-06-01T03:44:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/min|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/min]]
[[es:cpp/numeric/random/chi squared distribution/min]]
[[fr:cpp/numeric/random/chi squared distribution/min]]
[[it:cpp/numeric/random/chi squared distribution/min]]
[[ja:cpp/numeric/random/chi squared distribution/min]]
[[pt:cpp/numeric/random/chi squared distribution/min]]
[[ru:cpp/numeric/random/chi squared distribution/min]]
[[zh:cpp/numeric/random/chi squared distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/n</title>
    <ns>0</ns>
    <id>8892</id>
    <revision>
      <id>63373</id>
      <parentid>61256</parentid>
      <timestamp>2013-07-10T01:30:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="998">{{cpp/numeric/random/chi_squared_distribution/title|n}}
{{cpp/numeric/random/chi_squared_distribution/navbar}}
{{ddcl | since=c++11 | 1=
RealType n() const;
}}

Returns the {{math|n}} parameter the distribution was constructed with. It specifies the [[enwiki:Degrees of freedom (statistics)|degrees of freedom]] of the distribution. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
The {{math|n}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | chi_squared_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/chi squared distribution/n]]
[[es:cpp/numeric/random/chi squared distribution/n]]
[[fr:cpp/numeric/random/chi squared distribution/n]]
[[it:cpp/numeric/random/chi squared distribution/n]]
[[ja:cpp/numeric/random/chi squared distribution/n]]
[[pt:cpp/numeric/random/chi squared distribution/n]]
[[ru:cpp/numeric/random/chi squared distribution/n]]
[[zh:cpp/numeric/random/chi squared distribution/n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/operator()</title>
    <ns>0</ns>
    <id>4112</id>
    <revision>
      <id>43972</id>
      <parentid>15061</parentid>
      <timestamp>2012-11-03T04:25:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="568">{{cpp/numeric/random/distribution/operator()|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/operator()]]
[[es:cpp/numeric/random/chi squared distribution/operator()]]
[[fr:cpp/numeric/random/chi squared distribution/operator()]]
[[it:cpp/numeric/random/chi squared distribution/operator()]]
[[ja:cpp/numeric/random/chi squared distribution/operator()]]
[[pt:cpp/numeric/random/chi squared distribution/operator()]]
[[ru:cpp/numeric/random/chi squared distribution/operator()]]
[[zh:cpp/numeric/random/chi squared distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/operator cmp</title>
    <ns>0</ns>
    <id>4153</id>
    <revision>
      <id>50911</id>
      <parentid>43967</parentid>
      <timestamp>2013-06-01T03:45:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/operator_cmp|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/operator cmp]]
[[es:cpp/numeric/random/chi squared distribution/operator cmp]]
[[fr:cpp/numeric/random/chi squared distribution/operator cmp]]
[[it:cpp/numeric/random/chi squared distribution/operator cmp]]
[[ja:cpp/numeric/random/chi squared distribution/operator cmp]]
[[pt:cpp/numeric/random/chi squared distribution/operator cmp]]
[[ru:cpp/numeric/random/chi squared distribution/operator cmp]]
[[zh:cpp/numeric/random/chi squared distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4526</id>
    <revision>
      <id>50912</id>
      <parentid>43961</parentid>
      <timestamp>2013-06-01T03:45:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="644">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/chi squared distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/param</title>
    <ns>0</ns>
    <id>4132</id>
    <revision>
      <id>50913</id>
      <parentid>43955</parentid>
      <timestamp>2013-06-01T03:45:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/param|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/param]]
[[es:cpp/numeric/random/chi squared distribution/param]]
[[fr:cpp/numeric/random/chi squared distribution/param]]
[[it:cpp/numeric/random/chi squared distribution/param]]
[[ja:cpp/numeric/random/chi squared distribution/param]]
[[pt:cpp/numeric/random/chi squared distribution/param]]
[[ru:cpp/numeric/random/chi squared distribution/param]]
[[zh:cpp/numeric/random/chi squared distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/chi squared distribution/reset</title>
    <ns>0</ns>
    <id>4088</id>
    <revision>
      <id>50914</id>
      <parentid>43949</parentid>
      <timestamp>2013-06-01T03:45:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/reset|chi_squared_distribution}}

[[de:cpp/numeric/random/chi squared distribution/reset]]
[[es:cpp/numeric/random/chi squared distribution/reset]]
[[fr:cpp/numeric/random/chi squared distribution/reset]]
[[it:cpp/numeric/random/chi squared distribution/reset]]
[[ja:cpp/numeric/random/chi squared distribution/reset]]
[[pt:cpp/numeric/random/chi squared distribution/reset]]
[[ru:cpp/numeric/random/chi squared distribution/reset]]
[[zh:cpp/numeric/random/chi squared distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine</title>
    <ns>0</ns>
    <id>3700</id>
    <revision>
      <id>65497</id>
      <parentid>62165</parentid>
      <timestamp>2013-09-16T15:53:13Z</timestamp>
      <contributor>
        <ip>8.35.201.117</ip>
      </contributor>
      <text xml:space="preserve" bytes="2521">{{cpp/title|discard_block_engine}}
{{cpp/numeric/random/discard_block_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 | 1=
template&lt;
    class Engine, 
    size_t P, size_t R
&gt; class discard_block_engine;
}}
{{dcl end}}

{{tt|discard_block_engine}} is a pseudo-random number generator adapter that discards a certain amount of data produced by the base engine. From each block of size {{tt|P}} generated by the base engine, the adaptor keeps only {{tt|R}} numbers, discarding the rest.

===Template parameters===
{{par begin}}
{{par | Engine | the type of the wrapped engine }}
{{par | P | the size of a block. Must be greater than {{math|0}}. }}
{{par | R | the number of used numbers per block. Must be greater than {{math|0}} and not greater than {{tt|P}} }}
{{par hreq}}
{{par req concept | Engine | RandomNumberEngine}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|typename Engine::result_type}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc constructor |discard_block_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc seed |discard_block_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc base |discard_block_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator() |discard_block_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc discard |discard_block_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/adaptor/dsc min |discard_block_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc max |discard_block_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_cmp |discard_block_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_ltltgtgt |discard_block_engine}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} block_size | the size of the block, {{tt|P}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} used_size | the number of used numbers per block, {{tt|R}} }}
{{dsc end}}

[[de:cpp/numeric/random/discard block engine]]
[[es:cpp/numeric/random/discard block engine]]
[[fr:cpp/numeric/random/discard block engine]]
[[it:cpp/numeric/random/discard block engine]]
[[ja:cpp/numeric/random/discard block engine]]
[[pt:cpp/numeric/random/discard block engine]]
[[ru:cpp/numeric/random/discard block engine]]
[[zh:cpp/numeric/random/discard block engine]]</text>
      <sha1>dg7uqly8lfegb1janot9p29jzpv22ka</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/base</title>
    <ns>0</ns>
    <id>8787</id>
    <revision>
      <id>50915</id>
      <parentid>43936</parentid>
      <timestamp>2013-06-01T03:45:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="486">{{include page|cpp/numeric/random/adaptor/base|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/base]]
[[es:cpp/numeric/random/discard block engine/base]]
[[fr:cpp/numeric/random/discard block engine/base]]
[[it:cpp/numeric/random/discard block engine/base]]
[[ja:cpp/numeric/random/discard block engine/base]]
[[pt:cpp/numeric/random/discard block engine/base]]
[[ru:cpp/numeric/random/discard block engine/base]]
[[zh:cpp/numeric/random/discard block engine/base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/discard</title>
    <ns>0</ns>
    <id>8788</id>
    <revision>
      <id>50916</id>
      <parentid>43931</parentid>
      <timestamp>2013-06-01T03:45:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="513">{{include page|cpp/numeric/random/adaptor/discard|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/discard]]
[[es:cpp/numeric/random/discard block engine/discard]]
[[fr:cpp/numeric/random/discard block engine/discard]]
[[it:cpp/numeric/random/discard block engine/discard]]
[[ja:cpp/numeric/random/discard block engine/discard]]
[[pt:cpp/numeric/random/discard block engine/discard]]
[[ru:cpp/numeric/random/discard block engine/discard]]
[[zh:cpp/numeric/random/discard block engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/discard block engine</title>
    <ns>0</ns>
    <id>8784</id>
    <revision>
      <id>50917</id>
      <parentid>43926</parentid>
      <timestamp>2013-06-01T03:45:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="621">{{include page|cpp/numeric/random/adaptor/constructor|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/discard block engine]]
[[es:cpp/numeric/random/discard block engine/discard block engine]]
[[fr:cpp/numeric/random/discard block engine/discard block engine]]
[[it:cpp/numeric/random/discard block engine/discard block engine]]
[[ja:cpp/numeric/random/discard block engine/discard block engine]]
[[pt:cpp/numeric/random/discard block engine/discard block engine]]
[[ru:cpp/numeric/random/discard block engine/discard block engine]]
[[zh:cpp/numeric/random/discard block engine/discard block engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/max</title>
    <ns>0</ns>
    <id>8790</id>
    <revision>
      <id>50918</id>
      <parentid>43919</parentid>
      <timestamp>2013-06-01T03:45:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="477">{{include page|cpp/numeric/random/adaptor/max|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/max]]
[[es:cpp/numeric/random/discard block engine/max]]
[[fr:cpp/numeric/random/discard block engine/max]]
[[it:cpp/numeric/random/discard block engine/max]]
[[ja:cpp/numeric/random/discard block engine/max]]
[[pt:cpp/numeric/random/discard block engine/max]]
[[ru:cpp/numeric/random/discard block engine/max]]
[[zh:cpp/numeric/random/discard block engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/min</title>
    <ns>0</ns>
    <id>8789</id>
    <revision>
      <id>50919</id>
      <parentid>43913</parentid>
      <timestamp>2013-06-01T03:45:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="477">{{include page|cpp/numeric/random/adaptor/min|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/min]]
[[es:cpp/numeric/random/discard block engine/min]]
[[fr:cpp/numeric/random/discard block engine/min]]
[[it:cpp/numeric/random/discard block engine/min]]
[[ja:cpp/numeric/random/discard block engine/min]]
[[pt:cpp/numeric/random/discard block engine/min]]
[[ru:cpp/numeric/random/discard block engine/min]]
[[zh:cpp/numeric/random/discard block engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/operator()</title>
    <ns>0</ns>
    <id>8786</id>
    <revision>
      <id>43907</id>
      <parentid>37157</parentid>
      <timestamp>2012-11-03T04:14:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="527">{{cpp/numeric/random/adaptor/operator()|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/operator()]]
[[es:cpp/numeric/random/discard block engine/operator()]]
[[fr:cpp/numeric/random/discard block engine/operator()]]
[[it:cpp/numeric/random/discard block engine/operator()]]
[[ja:cpp/numeric/random/discard block engine/operator()]]
[[pt:cpp/numeric/random/discard block engine/operator()]]
[[ru:cpp/numeric/random/discard block engine/operator()]]
[[zh:cpp/numeric/random/discard block engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/operator cmp</title>
    <ns>0</ns>
    <id>8791</id>
    <revision>
      <id>50920</id>
      <parentid>43901</parentid>
      <timestamp>2013-06-01T03:45:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="558">{{include page|cpp/numeric/random/adaptor/operator cmp|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/operator cmp]]
[[es:cpp/numeric/random/discard block engine/operator cmp]]
[[fr:cpp/numeric/random/discard block engine/operator cmp]]
[[it:cpp/numeric/random/discard block engine/operator cmp]]
[[ja:cpp/numeric/random/discard block engine/operator cmp]]
[[pt:cpp/numeric/random/discard block engine/operator cmp]]
[[ru:cpp/numeric/random/discard block engine/operator cmp]]
[[zh:cpp/numeric/random/discard block engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>8792</id>
    <revision>
      <id>50921</id>
      <parentid>43895</parentid>
      <timestamp>2013-06-01T03:45:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="603">{{include page|cpp/numeric/random/adaptor/operator ltltgtgt|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[es:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[it:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/discard block engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/discard block engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discard block engine/seed</title>
    <ns>0</ns>
    <id>8785</id>
    <revision>
      <id>50922</id>
      <parentid>43890</parentid>
      <timestamp>2013-06-01T03:45:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="486">{{include page|cpp/numeric/random/adaptor/seed|discard_block_engine}}

[[de:cpp/numeric/random/discard block engine/seed]]
[[es:cpp/numeric/random/discard block engine/seed]]
[[fr:cpp/numeric/random/discard block engine/seed]]
[[it:cpp/numeric/random/discard block engine/seed]]
[[ja:cpp/numeric/random/discard block engine/seed]]
[[pt:cpp/numeric/random/discard block engine/seed]]
[[ru:cpp/numeric/random/discard block engine/seed]]
[[zh:cpp/numeric/random/discard block engine/seed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution</title>
    <ns>0</ns>
    <id>3926</id>
    <revision>
      <id>63374</id>
      <parentid>58684</parentid>
      <timestamp>2013-07-10T01:30:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2466">{{cpp/title|discrete_distribution}}
{{cpp/numeric/random/discrete_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class discrete_distribution;
}}

{{tt|std::discrete_distribution}} produces random integers on the interval {{tt|[0, n)}}, where the probability of each individual integer {{tt|i}} is defined as {{math|w{{su|b=i}}/S}}, that is the ''weight'' of the {{tt|i}}th integer divided by the sum of all {{tt|n}} weights. 

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | discrete_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | discrete_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | discrete_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/discrete_distribution/dsc probabilities}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | discrete_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | discrete_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | discrete_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | discrete_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | discrete_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::discrete_distribution&lt;&gt; d({40, 10, 10, 40});
    std::map&lt;int, int&gt; m;
    for(int n=0; n&lt;10000; ++n) {
        ++m[d(gen)];
    }
    for(auto p : m) {
        std::cout &lt;&lt; p.first &lt;&lt; &quot; generated &quot; &lt;&lt; p.second &lt;&lt; &quot; times\n&quot;;
    }
}
 | output=
0 generated 4028 times
1 generated 978 times
2 generated 1012 times
3 generated 3982 times
}}

[[de:cpp/numeric/random/discrete distribution]]
[[es:cpp/numeric/random/discrete distribution]]
[[fr:cpp/numeric/random/discrete distribution]]
[[it:cpp/numeric/random/discrete distribution]]
[[ja:cpp/numeric/random/discrete distribution]]
[[pt:cpp/numeric/random/discrete distribution]]
[[ru:cpp/numeric/random/discrete distribution]]
[[zh:cpp/numeric/random/discrete distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/discrete distribution</title>
    <ns>0</ns>
    <id>4964</id>
    <revision>
      <id>72256</id>
      <parentid>67568</parentid>
      <timestamp>2014-07-31T21:37:58Z</timestamp>
      <contributor>
        <ip>208.71.62.32</ip>
      </contributor>
      <comment>Fixed typo.</comment>
      <text xml:space="preserve" bytes="2715">{{cpp/numeric/random/discrete_distribution/title|discrete_distribution}}
{{cpp/numeric/random/discrete_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
discrete_distribution();
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class InputIt &gt;
discrete_distribution( InputIt first, InputIt last );
}}
{{dcl | num=3 | since=c++11 | 1=
discrete_distribution( std::initializer_list&lt;double&gt; weights );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class UnaryOperation &gt;
discrete_distribution( std::size_t count, double xmin, double xmax,
                       UnaryOperation unary_op );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit discrete_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. 

1) Default constructor. Constructs the distribution with weights {{math|p = {1} }}. This distribution will always generate {{c|0}}.

2) Constructs the distribution with weights in the range {{tt|[first, last)}}. If {{c|first {{==}} last}}, the effects are the same as of the default constructor.

3) Constructs the distribution with weights in {{tt|weights}}. Effectively calls {{c|discrete_distribution(weights.begin(), weights.end())}}.

4) Constructs the distribution with {{tt|count}} weights that are generated using function {{tt|unary_op}}. Each of the weights is equal to {{math|w{{su|b=i}} {{=}} unary_op(xmin + δ/2 + i · δ)}}, where {{math|δ {{=}} {{mfrac|(xmax − xmin)|count}}}} and {{math|i ∈ {0, ..., count−1} }}. {{tt|xmin}} and {{tt|xmax}} must be such that {{math|δ &gt; 0}}. If {{c|count {{==}} 0}} the effects are the same as of the default constructor.

5) Constructs the distribution with {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | first, last | the range of elements defining the numbers to use as weights. The type of the elements referred by {{tt|InputIterator}} must be convertible to {{c|double}}}}
{{par | weights | initializer list containing the weights}}
{{par op1 | unary_op | rp=double | p1=double}}
{{par | params | the distribution parameter set}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

[[de:cpp/numeric/random/discrete distribution/discrete distribution]]
[[es:cpp/numeric/random/discrete distribution/discrete distribution]]
[[fr:cpp/numeric/random/discrete distribution/discrete distribution]]
[[it:cpp/numeric/random/discrete distribution/discrete distribution]]
[[ja:cpp/numeric/random/discrete distribution/discrete distribution]]
[[pt:cpp/numeric/random/discrete distribution/discrete distribution]]
[[ru:cpp/numeric/random/discrete distribution/discrete distribution]]
[[zh:cpp/numeric/random/discrete distribution/discrete distribution]]</text>
      <sha1>q0l1hyd8wniquisjqzkbk9xlkvuspw7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/max</title>
    <ns>0</ns>
    <id>4016</id>
    <revision>
      <id>50923</id>
      <parentid>43874</parentid>
      <timestamp>2013-06-01T03:45:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/max|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/max]]
[[es:cpp/numeric/random/discrete distribution/max]]
[[fr:cpp/numeric/random/discrete distribution/max]]
[[it:cpp/numeric/random/discrete distribution/max]]
[[ja:cpp/numeric/random/discrete distribution/max]]
[[pt:cpp/numeric/random/discrete distribution/max]]
[[ru:cpp/numeric/random/discrete distribution/max]]
[[zh:cpp/numeric/random/discrete distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/min</title>
    <ns>0</ns>
    <id>3968</id>
    <revision>
      <id>50924</id>
      <parentid>43868</parentid>
      <timestamp>2013-06-01T03:45:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/min|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/min]]
[[es:cpp/numeric/random/discrete distribution/min]]
[[fr:cpp/numeric/random/discrete distribution/min]]
[[it:cpp/numeric/random/discrete distribution/min]]
[[ja:cpp/numeric/random/discrete distribution/min]]
[[pt:cpp/numeric/random/discrete distribution/min]]
[[ru:cpp/numeric/random/discrete distribution/min]]
[[zh:cpp/numeric/random/discrete distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/operator()</title>
    <ns>0</ns>
    <id>4115</id>
    <revision>
      <id>43860</id>
      <parentid>15064</parentid>
      <timestamp>2012-11-03T04:04:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="541">{{cpp/numeric/random/distribution/operator()|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/operator()]]
[[es:cpp/numeric/random/discrete distribution/operator()]]
[[fr:cpp/numeric/random/discrete distribution/operator()]]
[[it:cpp/numeric/random/discrete distribution/operator()]]
[[ja:cpp/numeric/random/discrete distribution/operator()]]
[[pt:cpp/numeric/random/discrete distribution/operator()]]
[[ru:cpp/numeric/random/discrete distribution/operator()]]
[[zh:cpp/numeric/random/discrete distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/operator cmp</title>
    <ns>0</ns>
    <id>4157</id>
    <revision>
      <id>50925</id>
      <parentid>43853</parentid>
      <timestamp>2013-06-01T03:45:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="572">{{include page|cpp/numeric/random/distribution/operator_cmp|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/operator cmp]]
[[es:cpp/numeric/random/discrete distribution/operator cmp]]
[[fr:cpp/numeric/random/discrete distribution/operator cmp]]
[[it:cpp/numeric/random/discrete distribution/operator cmp]]
[[ja:cpp/numeric/random/discrete distribution/operator cmp]]
[[pt:cpp/numeric/random/discrete distribution/operator cmp]]
[[ru:cpp/numeric/random/discrete distribution/operator cmp]]
[[zh:cpp/numeric/random/discrete distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4522</id>
    <revision>
      <id>50926</id>
      <parentid>43847</parentid>
      <timestamp>2013-06-01T03:45:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="617">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/discrete distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/discrete distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/param</title>
    <ns>0</ns>
    <id>4137</id>
    <revision>
      <id>50927</id>
      <parentid>43842</parentid>
      <timestamp>2013-06-01T03:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{include page|cpp/numeric/random/distribution/param|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/param]]
[[es:cpp/numeric/random/discrete distribution/param]]
[[fr:cpp/numeric/random/discrete distribution/param]]
[[it:cpp/numeric/random/discrete distribution/param]]
[[ja:cpp/numeric/random/discrete distribution/param]]
[[pt:cpp/numeric/random/discrete distribution/param]]
[[ru:cpp/numeric/random/discrete distribution/param]]
[[zh:cpp/numeric/random/discrete distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/probabilities</title>
    <ns>0</ns>
    <id>4967</id>
    <revision>
      <id>62893</id>
      <parentid>50349</parentid>
      <timestamp>2013-07-01T23:45:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1243">{{cpp/numeric/random/discrete_distribution/title | probabilities}}
{{cpp/numeric/random/discrete_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |1=
std::vector&lt;double&gt; probabilities() const;
}}
{{dcl end}}

Obtains a {{c|std::vector&lt;double&gt;}} containing the individual probabilities of each integer that is generated by this distribution.

===Parameters===
(none)

===Return value===
An object of type {{c|std::vector&lt;double&gt;}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;random&gt;
int main()
{
    std::discrete_distribution&lt;&gt; d({40, 10, 10, 40});
    std::vector&lt;double&gt; p = d.probabilities();
    for(auto n : p)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
0.4 0.1 0.1 0.4
}}

[[de:cpp/numeric/random/discrete distribution/probabilities]]
[[es:cpp/numeric/random/discrete distribution/probabilities]]
[[fr:cpp/numeric/random/discrete distribution/probabilities]]
[[it:cpp/numeric/random/discrete distribution/probabilities]]
[[ja:cpp/numeric/random/discrete distribution/probabilities]]
[[pt:cpp/numeric/random/discrete distribution/probabilities]]
[[ru:cpp/numeric/random/discrete distribution/probabilities]]
[[zh:cpp/numeric/random/discrete distribution/probabilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/discrete distribution/reset</title>
    <ns>0</ns>
    <id>4092</id>
    <revision>
      <id>50928</id>
      <parentid>43831</parentid>
      <timestamp>2013-06-01T03:45:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{include page|cpp/numeric/random/distribution/reset|discrete_distribution}}

[[de:cpp/numeric/random/discrete distribution/reset]]
[[es:cpp/numeric/random/discrete distribution/reset]]
[[fr:cpp/numeric/random/discrete distribution/reset]]
[[it:cpp/numeric/random/discrete distribution/reset]]
[[ja:cpp/numeric/random/discrete distribution/reset]]
[[pt:cpp/numeric/random/discrete distribution/reset]]
[[ru:cpp/numeric/random/discrete distribution/reset]]
[[zh:cpp/numeric/random/discrete distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/distribution/reset</title>
    <ns>0</ns>
    <id>3321</id>
    <revision>
      <id>50929</id>
      <parentid>43824</parentid>
      <timestamp>2013-06-01T03:45:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="440">{{include page|cpp/numeric/random/distribution/reset|uniform_int_distribution}}

[[de:cpp/numeric/random/distribution/reset]]
[[es:cpp/numeric/random/distribution/reset]]
[[fr:cpp/numeric/random/distribution/reset]]
[[it:cpp/numeric/random/distribution/reset]]
[[ja:cpp/numeric/random/distribution/reset]]
[[pt:cpp/numeric/random/distribution/reset]]
[[ru:cpp/numeric/random/distribution/reset]]
[[zh:cpp/numeric/random/distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution</title>
    <ns>0</ns>
    <id>3916</id>
    <revision>
      <id>67262</id>
      <parentid>65530</parentid>
      <timestamp>2014-01-31T09:07:12Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>possible output</comment>
      <text xml:space="preserve" bytes="3236">{{cpp/title|exponential_distribution}}
{{cpp/numeric/random/exponential_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class exponential_distribution;
}}

Produces random non-negative floating-point values {{math|x}}, distributed according to probability density function:

:{{math|P(x{{!}}λ) {{=}} λe{{su|p=-λx}}}}

The value obtained is the time/distance until the next random event if random events occur at constant rate {{math|λ}} per unit of time/distance. For example, this distribution describes the time between the clicks of a Geiger counter or the distance between point mutations in a DNA strand.

This is the continuous counterpart of {{lc|std::geometric_distribution}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | exponential_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | exponential_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | exponential_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/exponential_distribution/dsc lambda}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | exponential_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | exponential_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | exponential_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | exponential_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | exponential_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    // if particles decay once per second on average,
    // how much time, in seconds, until the next one?
    std::exponential_distribution&lt;&gt; d(1);
 
    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[2*d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(1) 
                  &lt;&lt; p.first/2.0 &lt;&lt; '-' &lt;&lt; (p.first+1)/2.0 &lt;&lt;
                ' ' &lt;&lt; std::string(p.second/200, '*') &lt;&lt; '\n';
    }
}
 | p=true
 | output=
0.0-0.5 *******************
0.5-1.0 ***********
1.0-1.5 *******
1.5-2.0 ****
2.0-2.5 **
2.5-3.0 *
3.0-3.5 
3.5-4.0 
}}

===External links===
[http://mathworld.wolfram.com/ExponentialDistribution.html Weisstein, Eric W. &quot;Exponential Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/exponential distribution]]
[[es:cpp/numeric/random/exponential distribution]]
[[fr:cpp/numeric/random/exponential distribution]]
[[it:cpp/numeric/random/exponential distribution]]
[[ja:cpp/numeric/random/exponential distribution]]
[[pt:cpp/numeric/random/exponential distribution]]
[[ru:cpp/numeric/random/exponential distribution]]
[[zh:cpp/numeric/random/exponential distribution]]</text>
      <sha1>d9klsxjg934malkzjwfv3o8yo0xk77r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/exponential distribution</title>
    <ns>0</ns>
    <id>4924</id>
    <revision>
      <id>62894</id>
      <parentid>50351</parentid>
      <timestamp>2013-07-01T23:45:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1355">{{cpp/numeric/random/exponential_distribution/title|exponential_distribution}}
{{cpp/numeric/random/exponential_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit exponential_distribution( RealType lambda = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit exponential_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|lambda}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | lambda | the ''λ'' distribution parameter (the rate parameter)}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|0 &lt; lambda}}.

[[de:cpp/numeric/random/exponential distribution/exponential distribution]]
[[es:cpp/numeric/random/exponential distribution/exponential distribution]]
[[fr:cpp/numeric/random/exponential distribution/exponential distribution]]
[[it:cpp/numeric/random/exponential distribution/exponential distribution]]
[[ja:cpp/numeric/random/exponential distribution/exponential distribution]]
[[pt:cpp/numeric/random/exponential distribution/exponential distribution]]
[[ru:cpp/numeric/random/exponential distribution/exponential distribution]]
[[zh:cpp/numeric/random/exponential distribution/exponential distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/lambda</title>
    <ns>0</ns>
    <id>5153</id>
    <revision>
      <id>63376</id>
      <parentid>61260</parentid>
      <timestamp>2013-07-10T01:30:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1036">{{cpp/numeric/random/exponential_distribution/title|lambda}}
{{cpp/numeric/random/exponential_distribution/navbar}}
{{ddcl | since=c++11 | 1=
RealType lambda() const;
}}

Returns the {{math|λ}} distribution parameter the distribution was constructed with. The parameter defines the rate of events, per unit. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
Floating point value identifying the rate of events per unit

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | exponential_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/exponential distribution/lambda]]
[[es:cpp/numeric/random/exponential distribution/lambda]]
[[fr:cpp/numeric/random/exponential distribution/lambda]]
[[it:cpp/numeric/random/exponential distribution/lambda]]
[[ja:cpp/numeric/random/exponential distribution/lambda]]
[[pt:cpp/numeric/random/exponential distribution/lambda]]
[[ru:cpp/numeric/random/exponential distribution/lambda]]
[[zh:cpp/numeric/random/exponential distribution/lambda]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/max</title>
    <ns>0</ns>
    <id>4007</id>
    <revision>
      <id>50930</id>
      <parentid>43799</parentid>
      <timestamp>2013-06-01T03:45:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/max|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/max]]
[[es:cpp/numeric/random/exponential distribution/max]]
[[fr:cpp/numeric/random/exponential distribution/max]]
[[it:cpp/numeric/random/exponential distribution/max]]
[[ja:cpp/numeric/random/exponential distribution/max]]
[[pt:cpp/numeric/random/exponential distribution/max]]
[[ru:cpp/numeric/random/exponential distribution/max]]
[[zh:cpp/numeric/random/exponential distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/min</title>
    <ns>0</ns>
    <id>3981</id>
    <revision>
      <id>50931</id>
      <parentid>43792</parentid>
      <timestamp>2013-06-01T03:45:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/min|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/min]]
[[es:cpp/numeric/random/exponential distribution/min]]
[[fr:cpp/numeric/random/exponential distribution/min]]
[[it:cpp/numeric/random/exponential distribution/min]]
[[ja:cpp/numeric/random/exponential distribution/min]]
[[pt:cpp/numeric/random/exponential distribution/min]]
[[ru:cpp/numeric/random/exponential distribution/min]]
[[zh:cpp/numeric/random/exponential distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/operator()</title>
    <ns>0</ns>
    <id>4105</id>
    <revision>
      <id>43787</id>
      <parentid>15054</parentid>
      <timestamp>2012-11-03T03:50:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="568">{{cpp/numeric/random/distribution/operator()|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/operator()]]
[[es:cpp/numeric/random/exponential distribution/operator()]]
[[fr:cpp/numeric/random/exponential distribution/operator()]]
[[it:cpp/numeric/random/exponential distribution/operator()]]
[[ja:cpp/numeric/random/exponential distribution/operator()]]
[[pt:cpp/numeric/random/exponential distribution/operator()]]
[[ru:cpp/numeric/random/exponential distribution/operator()]]
[[zh:cpp/numeric/random/exponential distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/operator cmp</title>
    <ns>0</ns>
    <id>4147</id>
    <revision>
      <id>50932</id>
      <parentid>43779</parentid>
      <timestamp>2013-06-01T03:45:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/operator_cmp|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/operator cmp]]
[[es:cpp/numeric/random/exponential distribution/operator cmp]]
[[fr:cpp/numeric/random/exponential distribution/operator cmp]]
[[it:cpp/numeric/random/exponential distribution/operator cmp]]
[[ja:cpp/numeric/random/exponential distribution/operator cmp]]
[[pt:cpp/numeric/random/exponential distribution/operator cmp]]
[[ru:cpp/numeric/random/exponential distribution/operator cmp]]
[[zh:cpp/numeric/random/exponential distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4532</id>
    <revision>
      <id>50933</id>
      <parentid>43773</parentid>
      <timestamp>2013-06-01T03:45:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="644">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/exponential distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/exponential distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/param</title>
    <ns>0</ns>
    <id>4127</id>
    <revision>
      <id>50934</id>
      <parentid>43768</parentid>
      <timestamp>2013-06-01T03:45:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/param|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/param]]
[[es:cpp/numeric/random/exponential distribution/param]]
[[fr:cpp/numeric/random/exponential distribution/param]]
[[it:cpp/numeric/random/exponential distribution/param]]
[[ja:cpp/numeric/random/exponential distribution/param]]
[[pt:cpp/numeric/random/exponential distribution/param]]
[[ru:cpp/numeric/random/exponential distribution/param]]
[[zh:cpp/numeric/random/exponential distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/exponential distribution/reset</title>
    <ns>0</ns>
    <id>4082</id>
    <revision>
      <id>50935</id>
      <parentid>43763</parentid>
      <timestamp>2013-06-01T03:45:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/reset|exponential_distribution}}

[[de:cpp/numeric/random/exponential distribution/reset]]
[[es:cpp/numeric/random/exponential distribution/reset]]
[[fr:cpp/numeric/random/exponential distribution/reset]]
[[it:cpp/numeric/random/exponential distribution/reset]]
[[ja:cpp/numeric/random/exponential distribution/reset]]
[[pt:cpp/numeric/random/exponential distribution/reset]]
[[ru:cpp/numeric/random/exponential distribution/reset]]
[[zh:cpp/numeric/random/exponential distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution</title>
    <ns>0</ns>
    <id>3919</id>
    <revision>
      <id>63377</id>
      <parentid>61136</parentid>
      <timestamp>2013-07-10T01:30:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2416">{{cpp/title|extreme_value_distribution}}
{{cpp/numeric/random/extreme_value_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class extreme_value_distribution;
}}

The {{tt|extreme_value_distribution}} class is a {{concept|RandomNumberDistribution}} that produces random numbers according to the [[enwiki:Generalized extreme value distribution|extreme value distribution]] (it is also known as Gumbel Type I, log-Weibull, Fisher-Tippett Type I):

:{{math|p(x;a,b) {{=}} {{mfrac||1|b}} exp{{mparen|(|)| {{mfrac||a-x|b}} - exp{{mparen|(|)| {{mfrac||a-x|b}} }} }} }}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | extreme_value_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | extreme_value_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | extreme_value_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | extreme_value_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | extreme_value_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | extreme_value_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | extreme_value_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | extreme_value_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | extreme_value_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
[http://mathworld.wolfram.com/ExtremeValueDistribution.html Weisstein, Eric W. &quot;Extreme Value Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/extreme value distribution]]
[[es:cpp/numeric/random/extreme value distribution]]
[[fr:cpp/numeric/random/extreme value distribution]]
[[it:cpp/numeric/random/extreme value distribution]]
[[ja:cpp/numeric/random/extreme value distribution]]
[[pt:cpp/numeric/random/extreme value distribution]]
[[ru:cpp/numeric/random/extreme value distribution]]
[[zh:cpp/numeric/random/extreme value distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/a</title>
    <ns>0</ns>
    <id>8903</id>
    <redirect title="cpp/numeric/random/extreme value distribution/params" />
    <revision>
      <id>61227</id>
      <parentid>58692</parentid>
      <timestamp>2013-06-05T12:31:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/extreme value distribution/params]]</comment>
      <text xml:space="preserve" bytes="66">#redirect [[cpp/numeric/random/extreme_value_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/b</title>
    <ns>0</ns>
    <id>8904</id>
    <redirect title="cpp/numeric/random/extreme value distribution/params" />
    <revision>
      <id>61229</id>
      <parentid>58693</parentid>
      <timestamp>2013-06-05T12:31:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/extreme value distribution/params]]</comment>
      <text xml:space="preserve" bytes="66">#redirect [[cpp/numeric/random/extreme_value_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/extreme value distribution</title>
    <ns>0</ns>
    <id>4927</id>
    <revision>
      <id>62895</id>
      <parentid>50356</parentid>
      <timestamp>2013-07-01T23:45:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1411">{{cpp/numeric/random/extreme_value_distribution/title|extreme_value_distribution}}
{{cpp/numeric/random/extreme_value_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit extreme_value_distribution( RealType a = 0.0, RealType b = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit extreme_value_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|a}} and {{tt|b}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | a | the ''a'' distribution parameter (location)}}
{{par | b | the ''b'' distribution parameter (scale)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[es:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[fr:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[it:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[ja:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[pt:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[ru:cpp/numeric/random/extreme value distribution/extreme value distribution]]
[[zh:cpp/numeric/random/extreme value distribution/extreme value distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/max</title>
    <ns>0</ns>
    <id>4010</id>
    <revision>
      <id>50936</id>
      <parentid>43730</parentid>
      <timestamp>2013-06-01T03:45:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/max|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/max]]
[[es:cpp/numeric/random/extreme value distribution/max]]
[[fr:cpp/numeric/random/extreme value distribution/max]]
[[it:cpp/numeric/random/extreme value distribution/max]]
[[ja:cpp/numeric/random/extreme value distribution/max]]
[[pt:cpp/numeric/random/extreme value distribution/max]]
[[ru:cpp/numeric/random/extreme value distribution/max]]
[[zh:cpp/numeric/random/extreme value distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/min</title>
    <ns>0</ns>
    <id>3975</id>
    <revision>
      <id>50937</id>
      <parentid>43724</parentid>
      <timestamp>2013-06-01T03:45:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/min|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/min]]
[[es:cpp/numeric/random/extreme value distribution/min]]
[[fr:cpp/numeric/random/extreme value distribution/min]]
[[it:cpp/numeric/random/extreme value distribution/min]]
[[ja:cpp/numeric/random/extreme value distribution/min]]
[[pt:cpp/numeric/random/extreme value distribution/min]]
[[ru:cpp/numeric/random/extreme value distribution/min]]
[[zh:cpp/numeric/random/extreme value distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/operator()</title>
    <ns>0</ns>
    <id>4108</id>
    <revision>
      <id>43718</id>
      <parentid>15057</parentid>
      <timestamp>2012-11-03T03:36:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="586">{{cpp/numeric/random/distribution/operator()|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/operator()]]
[[es:cpp/numeric/random/extreme value distribution/operator()]]
[[fr:cpp/numeric/random/extreme value distribution/operator()]]
[[it:cpp/numeric/random/extreme value distribution/operator()]]
[[ja:cpp/numeric/random/extreme value distribution/operator()]]
[[pt:cpp/numeric/random/extreme value distribution/operator()]]
[[ru:cpp/numeric/random/extreme value distribution/operator()]]
[[zh:cpp/numeric/random/extreme value distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/operator cmp</title>
    <ns>0</ns>
    <id>4150</id>
    <revision>
      <id>50938</id>
      <parentid>43712</parentid>
      <timestamp>2013-06-01T03:45:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="617">{{include page|cpp/numeric/random/distribution/operator_cmp|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/operator cmp]]
[[es:cpp/numeric/random/extreme value distribution/operator cmp]]
[[fr:cpp/numeric/random/extreme value distribution/operator cmp]]
[[it:cpp/numeric/random/extreme value distribution/operator cmp]]
[[ja:cpp/numeric/random/extreme value distribution/operator cmp]]
[[pt:cpp/numeric/random/extreme value distribution/operator cmp]]
[[ru:cpp/numeric/random/extreme value distribution/operator cmp]]
[[zh:cpp/numeric/random/extreme value distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4529</id>
    <revision>
      <id>50939</id>
      <parentid>43706</parentid>
      <timestamp>2013-06-01T03:45:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="662">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/extreme value distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/param</title>
    <ns>0</ns>
    <id>4129</id>
    <revision>
      <id>50940</id>
      <parentid>43700</parentid>
      <timestamp>2013-06-01T03:45:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="554">{{include page|cpp/numeric/random/distribution/param|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/param]]
[[es:cpp/numeric/random/extreme value distribution/param]]
[[fr:cpp/numeric/random/extreme value distribution/param]]
[[it:cpp/numeric/random/extreme value distribution/param]]
[[ja:cpp/numeric/random/extreme value distribution/param]]
[[pt:cpp/numeric/random/extreme value distribution/param]]
[[ru:cpp/numeric/random/extreme value distribution/param]]
[[zh:cpp/numeric/random/extreme value distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/params</title>
    <ns>0</ns>
    <id>12603</id>
    <revision>
      <id>61245</id>
      <timestamp>2013-06-05T12:49:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="774">{{cpp/numeric/random/extreme_value_distribution/title|a, b}}
{{cpp/numeric/random/extreme_value_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
RealType a() const;
}}
{{dcl | since=c++11 | num=2 |
RealType b() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the {{math|a}} distribution parameter (scale). The default value is {{c|1.0}}.

@2@ Returns the {{math|b}} distribution parameter (location). The default value is {{c|0.0}}.

===Parameters===
(none)

===Return value===
@1@ The {{math|a}} distribution parameter (scale).

@2@ The {{math|b}} distribution parameter (scale).

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | extreme_value_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/extreme value distribution/reset</title>
    <ns>0</ns>
    <id>4085</id>
    <revision>
      <id>50941</id>
      <parentid>43695</parentid>
      <timestamp>2013-06-01T03:45:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="554">{{include page|cpp/numeric/random/distribution/reset|extreme_value_distribution}}

[[de:cpp/numeric/random/extreme value distribution/reset]]
[[es:cpp/numeric/random/extreme value distribution/reset]]
[[fr:cpp/numeric/random/extreme value distribution/reset]]
[[it:cpp/numeric/random/extreme value distribution/reset]]
[[ja:cpp/numeric/random/extreme value distribution/reset]]
[[pt:cpp/numeric/random/extreme value distribution/reset]]
[[ru:cpp/numeric/random/extreme value distribution/reset]]
[[zh:cpp/numeric/random/extreme value distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution</title>
    <ns>0</ns>
    <id>3924</id>
    <revision>
      <id>63378</id>
      <parentid>61117</parentid>
      <timestamp>2013-07-10T01:30:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2302">{{cpp/title|fisher_f_distribution}}
{{cpp/numeric/random/fisher_f_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class fisher_f_distribution;
}}

The {{tt|fisher_f_distribution}} class is a {{concept|RandomNumberDistribution}} that produces random numbers according to the [[enwiki:F-distribution|f-distribution]]:

:{{math|p(x;m,n) {{=}} {{mfrac|| Γ((m+n)/2) | Γ(m/2) Γ(n/2) }} (m/n){{su|p=m/2}} x{{su|p=(m/2)-1}} (1+{{mfrac||mx|n}}){{su|p=-(m+n)/2}}}}

{{math|m}} and {{math|n}} are the [[enwiki:degrees of freedom (statistics)|degrees of freedom]].

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | fisher_f_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | fisher_f_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | fisher_f_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | fisher_f_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | fisher_f_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | fisher_f_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | fisher_f_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | fisher_f_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | fisher_f_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
[http://mathworld.wolfram.com/F-Distribution.html Weisstein, Eric W. &quot;F-Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/fisher f distribution]]
[[es:cpp/numeric/random/fisher f distribution]]
[[fr:cpp/numeric/random/fisher f distribution]]
[[it:cpp/numeric/random/fisher f distribution]]
[[ja:cpp/numeric/random/fisher f distribution]]
[[pt:cpp/numeric/random/fisher f distribution]]
[[ru:cpp/numeric/random/fisher f distribution]]
[[zh:cpp/numeric/random/fisher f distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/fisher f distribution</title>
    <ns>0</ns>
    <id>4963</id>
    <revision>
      <id>62896</id>
      <parentid>50358</parentid>
      <timestamp>2013-07-01T23:45:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1329">{{cpp/numeric/random/fisher_f_distribution/title|fisher_f_distribution}}
{{cpp/numeric/random/fisher_f_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit fisher_f_distribution( RealType m = 1.0, RealType n = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit fisher_f_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|m}} and {{tt|n}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | m | the ''m'' distribution parameter (degrees of freedom)}}
{{par | n | the ''n'' distribution parameter (degrees of freedom)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[es:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[fr:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[it:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[ja:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[pt:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[ru:cpp/numeric/random/fisher f distribution/fisher f distribution]]
[[zh:cpp/numeric/random/fisher f distribution/fisher f distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/m</title>
    <ns>0</ns>
    <id>12587</id>
    <redirect title="cpp/numeric/random/fisher f distribution/params" />
    <revision>
      <id>61121</id>
      <parentid>61093</parentid>
      <timestamp>2013-06-05T11:50:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/fisher f distribution/params]]</comment>
      <text xml:space="preserve" bytes="61">#redirect [[cpp/numeric/random/fisher_f_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/max</title>
    <ns>0</ns>
    <id>4015</id>
    <revision>
      <id>50942</id>
      <parentid>43679</parentid>
      <timestamp>2013-06-01T03:45:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/max|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/max]]
[[es:cpp/numeric/random/fisher f distribution/max]]
[[fr:cpp/numeric/random/fisher f distribution/max]]
[[it:cpp/numeric/random/fisher f distribution/max]]
[[ja:cpp/numeric/random/fisher f distribution/max]]
[[pt:cpp/numeric/random/fisher f distribution/max]]
[[ru:cpp/numeric/random/fisher f distribution/max]]
[[zh:cpp/numeric/random/fisher f distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/min</title>
    <ns>0</ns>
    <id>3970</id>
    <revision>
      <id>50943</id>
      <parentid>43673</parentid>
      <timestamp>2013-06-01T03:45:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/min|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/min]]
[[es:cpp/numeric/random/fisher f distribution/min]]
[[fr:cpp/numeric/random/fisher f distribution/min]]
[[it:cpp/numeric/random/fisher f distribution/min]]
[[ja:cpp/numeric/random/fisher f distribution/min]]
[[pt:cpp/numeric/random/fisher f distribution/min]]
[[ru:cpp/numeric/random/fisher f distribution/min]]
[[zh:cpp/numeric/random/fisher f distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/n</title>
    <ns>0</ns>
    <id>12586</id>
    <redirect title="cpp/numeric/random/fisher f distribution/params" />
    <revision>
      <id>61119</id>
      <parentid>61089</parentid>
      <timestamp>2013-06-05T11:48:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/fisher f distribution/params]]</comment>
      <text xml:space="preserve" bytes="61">#redirect [[cpp/numeric/random/fisher_f_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/operator()</title>
    <ns>0</ns>
    <id>4110</id>
    <revision>
      <id>43667</id>
      <parentid>15059</parentid>
      <timestamp>2012-11-03T03:27:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="541">{{cpp/numeric/random/distribution/operator()|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/operator()]]
[[es:cpp/numeric/random/fisher f distribution/operator()]]
[[fr:cpp/numeric/random/fisher f distribution/operator()]]
[[it:cpp/numeric/random/fisher f distribution/operator()]]
[[ja:cpp/numeric/random/fisher f distribution/operator()]]
[[pt:cpp/numeric/random/fisher f distribution/operator()]]
[[ru:cpp/numeric/random/fisher f distribution/operator()]]
[[zh:cpp/numeric/random/fisher f distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/operator cmp</title>
    <ns>0</ns>
    <id>4155</id>
    <revision>
      <id>50944</id>
      <parentid>43661</parentid>
      <timestamp>2013-06-01T03:45:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="572">{{include page|cpp/numeric/random/distribution/operator_cmp|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/operator cmp]]
[[es:cpp/numeric/random/fisher f distribution/operator cmp]]
[[fr:cpp/numeric/random/fisher f distribution/operator cmp]]
[[it:cpp/numeric/random/fisher f distribution/operator cmp]]
[[ja:cpp/numeric/random/fisher f distribution/operator cmp]]
[[pt:cpp/numeric/random/fisher f distribution/operator cmp]]
[[ru:cpp/numeric/random/fisher f distribution/operator cmp]]
[[zh:cpp/numeric/random/fisher f distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4524</id>
    <revision>
      <id>50945</id>
      <parentid>43655</parentid>
      <timestamp>2013-06-01T03:45:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="617">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/fisher f distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/param</title>
    <ns>0</ns>
    <id>4133</id>
    <revision>
      <id>50946</id>
      <parentid>43650</parentid>
      <timestamp>2013-06-01T03:46:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{include page|cpp/numeric/random/distribution/param|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/param]]
[[es:cpp/numeric/random/fisher f distribution/param]]
[[fr:cpp/numeric/random/fisher f distribution/param]]
[[it:cpp/numeric/random/fisher f distribution/param]]
[[ja:cpp/numeric/random/fisher f distribution/param]]
[[pt:cpp/numeric/random/fisher f distribution/param]]
[[ru:cpp/numeric/random/fisher f distribution/param]]
[[zh:cpp/numeric/random/fisher f distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/params</title>
    <ns>0</ns>
    <id>12596</id>
    <revision>
      <id>61253</id>
      <parentid>61120</parentid>
      <timestamp>2013-06-05T13:01:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce</comment>
      <text xml:space="preserve" bytes="877">{{cpp/numeric/random/fisher_f_distribution/title | m, n}}
{{cpp/numeric/random/fisher_f_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
RealType m() const;
}}
{{dcl | since=c++11 | num=2 |
RealType n() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the {{math|m}} (the first degree of freedom) distribution parameter. The default value is {{c|1.0}}.

@2@ Returns the {{math|n}} (the second degree of freedom) distribution parameter. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
@1@ The {{math|m}} (the first degree of freedom) distribution parameter.

@2@ The {{math|n}} (the second degree of freedom) distribution parameter. 

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | fisher_f_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/fisher f distribution/reset</title>
    <ns>0</ns>
    <id>4090</id>
    <revision>
      <id>50947</id>
      <parentid>43644</parentid>
      <timestamp>2013-06-01T03:46:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{include page|cpp/numeric/random/distribution/reset|fisher_f_distribution}}

[[de:cpp/numeric/random/fisher f distribution/reset]]
[[es:cpp/numeric/random/fisher f distribution/reset]]
[[fr:cpp/numeric/random/fisher f distribution/reset]]
[[it:cpp/numeric/random/fisher f distribution/reset]]
[[ja:cpp/numeric/random/fisher f distribution/reset]]
[[pt:cpp/numeric/random/fisher f distribution/reset]]
[[ru:cpp/numeric/random/fisher f distribution/reset]]
[[zh:cpp/numeric/random/fisher f distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution</title>
    <ns>0</ns>
    <id>3917</id>
    <revision>
      <id>64113</id>
      <parentid>63379</parentid>
      <timestamp>2013-08-13T06:23:58Z</timestamp>
      <contributor>
        <username>Faithandbrave</username>
        <id>1470</id>
      </contributor>
      <comment>integer values to floating-point values</comment>
      <text xml:space="preserve" bytes="2337">{{cpp/title|gamma_distribution}}
{{cpp/numeric/random/gamma_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class gamma_distribution;
}}

Produces random positive floating-point values {{math|x}}, distributed according to probability density function:

:{{math|P(x{{!}}α,β) {{=}} {{mfrac|e{{su|p=-x/β}}|β{{su|p=α}} · Γ(α)}} · x{{su|p=α-1}}}}

where {{math|α}} is known as the ''shape'' parameter and {{math|β}} is known as the ''scale'' parameter.

For floating-point {{math|α}}, the value obtained is the sum of {{math|α}} independent exponentially distributed random variables, each of which has a mean of {{math|β}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | gamma_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | gamma_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | gamma_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | gamma_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | gamma_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | gamma_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | gamma_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | gamma_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | gamma_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
[http://mathworld.wolfram.com/GammaDistribution.html Weisstein, Eric W. &quot;Gamma Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/gamma distribution]]
[[es:cpp/numeric/random/gamma distribution]]
[[fr:cpp/numeric/random/gamma distribution]]
[[it:cpp/numeric/random/gamma distribution]]
[[ja:cpp/numeric/random/gamma distribution]]
[[pt:cpp/numeric/random/gamma distribution]]
[[ru:cpp/numeric/random/gamma distribution]]
[[zh:cpp/numeric/random/gamma distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/alpha</title>
    <ns>0</ns>
    <id>5173</id>
    <redirect title="cpp/numeric/random/gamma distribution/params" />
    <revision>
      <id>61111</id>
      <parentid>61110</parentid>
      <timestamp>2013-06-05T11:42:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/gamma distribution/params]]</comment>
      <text xml:space="preserve" bytes="58">#redirect [[cpp/numeric/random/gamma_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/beta</title>
    <ns>0</ns>
    <id>5174</id>
    <redirect title="cpp/numeric/random/gamma distribution/params" />
    <revision>
      <id>61114</id>
      <parentid>58701</parentid>
      <timestamp>2013-06-05T11:42:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/gamma distribution/params]]</comment>
      <text xml:space="preserve" bytes="58">#redirect [[cpp/numeric/random/gamma_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/gamma distribution</title>
    <ns>0</ns>
    <id>4925</id>
    <revision>
      <id>69663</id>
      <parentid>62897</parentid>
      <timestamp>2014-04-17T22:48:21Z</timestamp>
      <contributor>
        <username>Jagerman</username>
        <id>2857</id>
      </contributor>
      <comment>&quot;scale&quot; and &quot;shape&quot; parenthetical text was reversed.  Fixed it, so that it now agrees with the class description.</comment>
      <text xml:space="preserve" bytes="1263">{{cpp/numeric/random/gamma_distribution/title|gamma_distribution}}
{{cpp/numeric/random/gamma_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit gamma_distribution( RealType alpha = 1.0, RealType beta = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit gamma_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|alpha}} and {{tt|beta}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | alpha | the ''α'' distribution parameter (shape)}}
{{par | beta | the ''β'' distribution parameter (scale)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/gamma distribution/gamma distribution]]
[[es:cpp/numeric/random/gamma distribution/gamma distribution]]
[[fr:cpp/numeric/random/gamma distribution/gamma distribution]]
[[it:cpp/numeric/random/gamma distribution/gamma distribution]]
[[ja:cpp/numeric/random/gamma distribution/gamma distribution]]
[[pt:cpp/numeric/random/gamma distribution/gamma distribution]]
[[ru:cpp/numeric/random/gamma distribution/gamma distribution]]
[[zh:cpp/numeric/random/gamma distribution/gamma distribution]]</text>
      <sha1>3juq28qcm1mk5n40defrw9vxlibpu1o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/max</title>
    <ns>0</ns>
    <id>4008</id>
    <revision>
      <id>50948</id>
      <parentid>43618</parentid>
      <timestamp>2013-06-01T03:46:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="464">{{include page|cpp/numeric/random/distribution/max|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/max]]
[[es:cpp/numeric/random/gamma distribution/max]]
[[fr:cpp/numeric/random/gamma distribution/max]]
[[it:cpp/numeric/random/gamma distribution/max]]
[[ja:cpp/numeric/random/gamma distribution/max]]
[[pt:cpp/numeric/random/gamma distribution/max]]
[[ru:cpp/numeric/random/gamma distribution/max]]
[[zh:cpp/numeric/random/gamma distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/min</title>
    <ns>0</ns>
    <id>3977</id>
    <revision>
      <id>50949</id>
      <parentid>43613</parentid>
      <timestamp>2013-06-01T03:46:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="464">{{include page|cpp/numeric/random/distribution/min|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/min]]
[[es:cpp/numeric/random/gamma distribution/min]]
[[fr:cpp/numeric/random/gamma distribution/min]]
[[it:cpp/numeric/random/gamma distribution/min]]
[[ja:cpp/numeric/random/gamma distribution/min]]
[[pt:cpp/numeric/random/gamma distribution/min]]
[[ru:cpp/numeric/random/gamma distribution/min]]
[[zh:cpp/numeric/random/gamma distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/operator()</title>
    <ns>0</ns>
    <id>4106</id>
    <revision>
      <id>43607</id>
      <parentid>15055</parentid>
      <timestamp>2012-11-03T03:16:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="514">{{cpp/numeric/random/distribution/operator()|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/operator()]]
[[es:cpp/numeric/random/gamma distribution/operator()]]
[[fr:cpp/numeric/random/gamma distribution/operator()]]
[[it:cpp/numeric/random/gamma distribution/operator()]]
[[ja:cpp/numeric/random/gamma distribution/operator()]]
[[pt:cpp/numeric/random/gamma distribution/operator()]]
[[ru:cpp/numeric/random/gamma distribution/operator()]]
[[zh:cpp/numeric/random/gamma distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/operator cmp</title>
    <ns>0</ns>
    <id>4148</id>
    <revision>
      <id>50950</id>
      <parentid>43601</parentid>
      <timestamp>2013-06-01T03:46:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="545">{{include page|cpp/numeric/random/distribution/operator_cmp|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/operator cmp]]
[[es:cpp/numeric/random/gamma distribution/operator cmp]]
[[fr:cpp/numeric/random/gamma distribution/operator cmp]]
[[it:cpp/numeric/random/gamma distribution/operator cmp]]
[[ja:cpp/numeric/random/gamma distribution/operator cmp]]
[[pt:cpp/numeric/random/gamma distribution/operator cmp]]
[[ru:cpp/numeric/random/gamma distribution/operator cmp]]
[[zh:cpp/numeric/random/gamma distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4531</id>
    <revision>
      <id>50951</id>
      <parentid>43595</parentid>
      <timestamp>2013-06-01T03:46:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="590">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/gamma distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/gamma distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/param</title>
    <ns>0</ns>
    <id>4128</id>
    <revision>
      <id>50952</id>
      <parentid>43589</parentid>
      <timestamp>2013-06-01T03:46:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/param|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/param]]
[[es:cpp/numeric/random/gamma distribution/param]]
[[fr:cpp/numeric/random/gamma distribution/param]]
[[it:cpp/numeric/random/gamma distribution/param]]
[[ja:cpp/numeric/random/gamma distribution/param]]
[[pt:cpp/numeric/random/gamma distribution/param]]
[[ru:cpp/numeric/random/gamma distribution/param]]
[[zh:cpp/numeric/random/gamma distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/params</title>
    <ns>0</ns>
    <id>12594</id>
    <revision>
      <id>61259</id>
      <parentid>61141</parentid>
      <timestamp>2013-06-05T13:07:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+default value</comment>
      <text xml:space="preserve" bytes="877">{{cpp/numeric/random/gamma_distribution/title|alpha, beta}}
{{cpp/numeric/random/gamma_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
RealType alpha() const;
}}
{{dcl | since=c++11 | num=2 | 1=
RealType beta() const;
}}
{{dcl end}}

Returns the distribution parameters the distribution has been constructed with.

@1@ Returns the {{math|α}} distribution parameter. It is also known as the shape parameter. The default value is {{c|1.0}}.

@2@ Returns the {{math|β}} distribution parameter. It is also known as the scale parameter. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
@1@ Floating point value identifying the {{math|α}} parameter

@2@ Floating point value identifying the {{math|β}} parameter

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | gamma_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/gamma distribution/reset</title>
    <ns>0</ns>
    <id>4083</id>
    <revision>
      <id>50953</id>
      <parentid>43583</parentid>
      <timestamp>2013-06-01T03:46:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/reset|gamma_distribution}}

[[de:cpp/numeric/random/gamma distribution/reset]]
[[es:cpp/numeric/random/gamma distribution/reset]]
[[fr:cpp/numeric/random/gamma distribution/reset]]
[[it:cpp/numeric/random/gamma distribution/reset]]
[[ja:cpp/numeric/random/gamma distribution/reset]]
[[pt:cpp/numeric/random/gamma distribution/reset]]
[[ru:cpp/numeric/random/gamma distribution/reset]]
[[zh:cpp/numeric/random/gamma distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/generate canonical</title>
    <ns>0</ns>
    <id>4748</id>
    <revision>
      <id>72067</id>
      <parentid>71393</parentid>
      <timestamp>2014-07-11T11:06:15Z</timestamp>
      <contributor>
        <ip>137.226.36.51</ip>
      </contributor>
      <comment>Fixed error regarding number of values produced</comment>
      <text xml:space="preserve" bytes="1645">{{cpp/title|generate_canonical}}
{{cpp/numeric/random/navbar}}
{{ddcl | since=c++11 | 
template&lt; class RealType, size_t bits, class Generator &gt;
RealType generate_canonical( Generator&amp; g );
}}

Generates a random floating point number in range {{math|[0; 1)}}. 

To generate enough entropy, calls {{c|g()}} exactly k times, where {{math|k {{=}} max(1, ⌈ b / log{{su|b=2}} R ⌉)}} and

* {{c|b {{=}} std::min&lt;std::size_t&gt;(bits, std::numeric_limits&lt;RealType&gt;::digits)}}
* {{c|R {{=}} g.max() - g.min() + 1}}.

===Parameters===
{{par begin}}
{{par | g | generator to use to acquire entropy}}
{{par end}}

===Return value===
Floating point value in range {{math|[0; 1)}}.

===Exceptions===
None except from those thrown by {{tt|g}}

===Example===
{{example
| produce random numbers with 10 bits of randomness: this may produce only k*R distinct values
| code=
#include &lt;random&gt;
#include &lt;iostream&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    for(int n=0; n&lt;10; ++n) {
        std::cout &lt;&lt; std::generate_canonical&lt;double, 10&gt;(gen) &lt;&lt; ' ';
    }
}
| output=
0.208143 0.824147 0.0278604 0.343183 0.0173263 0.864057 0.647037 0.539467 0.0583497 0.609219 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc uniform_real_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/generate canonical]]
[[es:cpp/numeric/random/generate canonical]]
[[fr:cpp/numeric/random/generate canonical]]
[[it:cpp/numeric/random/generate canonical]]
[[ja:cpp/numeric/random/generate canonical]]
[[pt:cpp/numeric/random/generate canonical]]
[[ru:cpp/numeric/random/generate canonical]]
[[zh:cpp/numeric/random/generate canonical]]</text>
      <sha1>62kupuhlnxch23a05cv1652sze2fgmh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution</title>
    <ns>0</ns>
    <id>3929</id>
    <revision>
      <id>63381</id>
      <parentid>58705</parentid>
      <timestamp>2013-07-10T01:30:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3136">{{cpp/title|geometric_distribution}}
{{cpp/numeric/random/geometric_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class geometric_distribution;
}}

Produces random non-negative integer values {{math|i}}, distributed according to discrete probability function:

:{{math|P(i{{!}}p) {{=}} p · (1 − p){{su|p=i}}}}

The value represents the number of yes/no trials (each succeeding with probability {{math|p}}) which are necessary to obtain a single success.

{{tt|std::geometric_distribution&lt;&gt;(p)}} is exactly equivalent to {{c|std::negative_binomial_distribution&lt;&gt;(1, p)}}. It is also the discrete counterpart of {{lc|std::exponential_distribution}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | geometric_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | geometric_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | geometric_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/geometric_distribution/dsc p}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | geometric_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | geometric_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | geometric_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | geometric_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | geometric_distribution}}
{{dsc end}}

===Example===
{{example
 | geometric_distribution&lt;&gt;(0.5) is the default and represents the number of coin tosses that are required to get heads
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    std::geometric_distribution&lt;&gt; d; // same as std::negative_binomial_distribution&lt;&gt; d(1, 0.5);

    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; p.first &lt;&lt;
                ' ' &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 *************************************************
1 *************************
2 ************
3 ******
4 **
5 *
6 
7 
8 
9 
10 
11 
}}

===External links===
[http://mathworld.wolfram.com/GeometricDistribution.html Weisstein, Eric W. &quot;Geometric Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/geometric distribution]]
[[es:cpp/numeric/random/geometric distribution]]
[[fr:cpp/numeric/random/geometric distribution]]
[[it:cpp/numeric/random/geometric distribution]]
[[ja:cpp/numeric/random/geometric distribution]]
[[pt:cpp/numeric/random/geometric distribution]]
[[ru:cpp/numeric/random/geometric distribution]]
[[zh:cpp/numeric/random/geometric distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/geometric distribution</title>
    <ns>0</ns>
    <id>4922</id>
    <revision>
      <id>62898</id>
      <parentid>50365</parentid>
      <timestamp>2013-07-01T23:45:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1317">{{cpp/numeric/random/geometric_distribution/title|geometric_distribution}}
{{cpp/numeric/random/geometric_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit geometric_distribution( double p = 0.5 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit geometric_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|p}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | p | the ''p'' distribution parameter (probability of a trial generating {{c|true}})}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|0 &lt; p &lt; 1}}

[[de:cpp/numeric/random/geometric distribution/geometric distribution]]
[[es:cpp/numeric/random/geometric distribution/geometric distribution]]
[[fr:cpp/numeric/random/geometric distribution/geometric distribution]]
[[it:cpp/numeric/random/geometric distribution/geometric distribution]]
[[ja:cpp/numeric/random/geometric distribution/geometric distribution]]
[[pt:cpp/numeric/random/geometric distribution/geometric distribution]]
[[ru:cpp/numeric/random/geometric distribution/geometric distribution]]
[[zh:cpp/numeric/random/geometric distribution/geometric distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/max</title>
    <ns>0</ns>
    <id>4005</id>
    <revision>
      <id>50954</id>
      <parentid>43557</parentid>
      <timestamp>2013-06-01T03:46:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/max|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/max]]
[[es:cpp/numeric/random/geometric distribution/max]]
[[fr:cpp/numeric/random/geometric distribution/max]]
[[it:cpp/numeric/random/geometric distribution/max]]
[[ja:cpp/numeric/random/geometric distribution/max]]
[[pt:cpp/numeric/random/geometric distribution/max]]
[[ru:cpp/numeric/random/geometric distribution/max]]
[[zh:cpp/numeric/random/geometric distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/min</title>
    <ns>0</ns>
    <id>3979</id>
    <revision>
      <id>50955</id>
      <parentid>43550</parentid>
      <timestamp>2013-06-01T03:46:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/min|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/min]]
[[es:cpp/numeric/random/geometric distribution/min]]
[[fr:cpp/numeric/random/geometric distribution/min]]
[[it:cpp/numeric/random/geometric distribution/min]]
[[ja:cpp/numeric/random/geometric distribution/min]]
[[pt:cpp/numeric/random/geometric distribution/min]]
[[ru:cpp/numeric/random/geometric distribution/min]]
[[zh:cpp/numeric/random/geometric distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/operator()</title>
    <ns>0</ns>
    <id>4103</id>
    <revision>
      <id>43544</id>
      <parentid>15052</parentid>
      <timestamp>2012-11-03T03:06:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="550">{{cpp/numeric/random/distribution/operator()|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/operator()]]
[[es:cpp/numeric/random/geometric distribution/operator()]]
[[fr:cpp/numeric/random/geometric distribution/operator()]]
[[it:cpp/numeric/random/geometric distribution/operator()]]
[[ja:cpp/numeric/random/geometric distribution/operator()]]
[[pt:cpp/numeric/random/geometric distribution/operator()]]
[[ru:cpp/numeric/random/geometric distribution/operator()]]
[[zh:cpp/numeric/random/geometric distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/operator cmp</title>
    <ns>0</ns>
    <id>4145</id>
    <revision>
      <id>50956</id>
      <parentid>43539</parentid>
      <timestamp>2013-06-01T03:46:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/operator_cmp|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/operator cmp]]
[[es:cpp/numeric/random/geometric distribution/operator cmp]]
[[fr:cpp/numeric/random/geometric distribution/operator cmp]]
[[it:cpp/numeric/random/geometric distribution/operator cmp]]
[[ja:cpp/numeric/random/geometric distribution/operator cmp]]
[[pt:cpp/numeric/random/geometric distribution/operator cmp]]
[[ru:cpp/numeric/random/geometric distribution/operator cmp]]
[[zh:cpp/numeric/random/geometric distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4534</id>
    <revision>
      <id>50957</id>
      <parentid>43533</parentid>
      <timestamp>2013-06-01T03:46:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="626">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/geometric distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/geometric distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/p</title>
    <ns>0</ns>
    <id>5147</id>
    <revision>
      <id>63382</id>
      <parentid>61262</parentid>
      <timestamp>2013-07-10T01:30:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="992">{{cpp/numeric/random/geometric_distribution/title|p}}
{{cpp/numeric/random/geometric_distribution/navbar}}
{{ddcl | since=c++11 | 1=
double p() const;
}}

Returns the {{math|p}} distribution parameter the distribution was constructed with. The parameter defines the probability of a trial generating {{c|true}}. The default value is {{c|0.5}}.

===Parameters===
(none)

===Return value===
Floating point value identifying the {{math|p}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | geometric_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/geometric distribution/p]]
[[es:cpp/numeric/random/geometric distribution/p]]
[[fr:cpp/numeric/random/geometric distribution/p]]
[[it:cpp/numeric/random/geometric distribution/p]]
[[ja:cpp/numeric/random/geometric distribution/p]]
[[pt:cpp/numeric/random/geometric distribution/p]]
[[ru:cpp/numeric/random/geometric distribution/p]]
[[zh:cpp/numeric/random/geometric distribution/p]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/param</title>
    <ns>0</ns>
    <id>4125</id>
    <revision>
      <id>50958</id>
      <parentid>43521</parentid>
      <timestamp>2013-06-01T03:46:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/param|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/param]]
[[es:cpp/numeric/random/geometric distribution/param]]
[[fr:cpp/numeric/random/geometric distribution/param]]
[[it:cpp/numeric/random/geometric distribution/param]]
[[ja:cpp/numeric/random/geometric distribution/param]]
[[pt:cpp/numeric/random/geometric distribution/param]]
[[ru:cpp/numeric/random/geometric distribution/param]]
[[zh:cpp/numeric/random/geometric distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/geometric distribution/reset</title>
    <ns>0</ns>
    <id>4080</id>
    <revision>
      <id>50959</id>
      <parentid>43514</parentid>
      <timestamp>2013-06-01T03:46:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/reset|geometric_distribution}}

[[de:cpp/numeric/random/geometric distribution/reset]]
[[es:cpp/numeric/random/geometric distribution/reset]]
[[fr:cpp/numeric/random/geometric distribution/reset]]
[[it:cpp/numeric/random/geometric distribution/reset]]
[[ja:cpp/numeric/random/geometric distribution/reset]]
[[pt:cpp/numeric/random/geometric distribution/reset]]
[[ru:cpp/numeric/random/geometric distribution/reset]]
[[zh:cpp/numeric/random/geometric distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine</title>
    <ns>0</ns>
    <id>3702</id>
    <revision>
      <id>62161</id>
      <parentid>62160</parentid>
      <timestamp>2013-06-25T11:24:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>param-&gt;par</comment>
      <text xml:space="preserve" bytes="2169">{{cpp/title|independent_bits_engine}}
{{cpp/numeric/random/independent_bits_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 |
template&lt;
    class Engine, 
    std::size_t W, 
    class UIntType
&gt; class independent_bits_engine;
}}
{{dcl end}}

{{tt|independent_bits_engine}} is a random number engine adaptor that produces random numbers with different number of bits than that of the wrapped engine.

===Template parameters===
{{par begin}}
{{par | Engine | the type of the wrapped engine }}
{{par | W | the number of bits the generated numbers should have }}
{{par | UIntType | the type of the generated random numbers. The type must be unsigned integral type. }}
{{par hreq}}
{{par req concept | Engine | RandomNumberEngine}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|UIntType}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc constructor |independent_bits_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc seed |independent_bits_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc base |independent_bits_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator() |independent_bits_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc discard |independent_bits_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/adaptor/dsc min |independent_bits_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc max |independent_bits_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_cmp |independent_bits_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_ltltgtgt |independent_bits_engine}}
{{dsc end}}

[[de:cpp/numeric/random/independent bits engine]]
[[es:cpp/numeric/random/independent bits engine]]
[[fr:cpp/numeric/random/independent bits engine]]
[[it:cpp/numeric/random/independent bits engine]]
[[ja:cpp/numeric/random/independent bits engine]]
[[pt:cpp/numeric/random/independent bits engine]]
[[ru:cpp/numeric/random/independent bits engine]]
[[zh:cpp/numeric/random/independent bits engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/base</title>
    <ns>0</ns>
    <id>8795</id>
    <revision>
      <id>50960</id>
      <parentid>43497</parentid>
      <timestamp>2013-06-01T03:46:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="513">{{include page|cpp/numeric/random/adaptor/base|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/base]]
[[es:cpp/numeric/random/independent bits engine/base]]
[[fr:cpp/numeric/random/independent bits engine/base]]
[[it:cpp/numeric/random/independent bits engine/base]]
[[ja:cpp/numeric/random/independent bits engine/base]]
[[pt:cpp/numeric/random/independent bits engine/base]]
[[ru:cpp/numeric/random/independent bits engine/base]]
[[zh:cpp/numeric/random/independent bits engine/base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/discard</title>
    <ns>0</ns>
    <id>8797</id>
    <revision>
      <id>50961</id>
      <parentid>43490</parentid>
      <timestamp>2013-06-01T03:46:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="540">{{include page|cpp/numeric/random/adaptor/discard|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/discard]]
[[es:cpp/numeric/random/independent bits engine/discard]]
[[fr:cpp/numeric/random/independent bits engine/discard]]
[[it:cpp/numeric/random/independent bits engine/discard]]
[[ja:cpp/numeric/random/independent bits engine/discard]]
[[pt:cpp/numeric/random/independent bits engine/discard]]
[[ru:cpp/numeric/random/independent bits engine/discard]]
[[zh:cpp/numeric/random/independent bits engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/independent bits engine</title>
    <ns>0</ns>
    <id>8793</id>
    <revision>
      <id>50962</id>
      <parentid>43484</parentid>
      <timestamp>2013-06-01T03:46:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="672">{{include page|cpp/numeric/random/adaptor/constructor|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/independent bits engine]]
[[es:cpp/numeric/random/independent bits engine/independent bits engine]]
[[fr:cpp/numeric/random/independent bits engine/independent bits engine]]
[[it:cpp/numeric/random/independent bits engine/independent bits engine]]
[[ja:cpp/numeric/random/independent bits engine/independent bits engine]]
[[pt:cpp/numeric/random/independent bits engine/independent bits engine]]
[[ru:cpp/numeric/random/independent bits engine/independent bits engine]]
[[zh:cpp/numeric/random/independent bits engine/independent bits engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/max</title>
    <ns>0</ns>
    <id>8799</id>
    <revision>
      <id>50963</id>
      <parentid>43478</parentid>
      <timestamp>2013-06-01T03:46:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="504">{{include page|cpp/numeric/random/adaptor/max|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/max]]
[[es:cpp/numeric/random/independent bits engine/max]]
[[fr:cpp/numeric/random/independent bits engine/max]]
[[it:cpp/numeric/random/independent bits engine/max]]
[[ja:cpp/numeric/random/independent bits engine/max]]
[[pt:cpp/numeric/random/independent bits engine/max]]
[[ru:cpp/numeric/random/independent bits engine/max]]
[[zh:cpp/numeric/random/independent bits engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/min</title>
    <ns>0</ns>
    <id>8798</id>
    <revision>
      <id>50964</id>
      <parentid>43470</parentid>
      <timestamp>2013-06-01T03:46:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="504">{{include page|cpp/numeric/random/adaptor/min|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/min]]
[[es:cpp/numeric/random/independent bits engine/min]]
[[fr:cpp/numeric/random/independent bits engine/min]]
[[it:cpp/numeric/random/independent bits engine/min]]
[[ja:cpp/numeric/random/independent bits engine/min]]
[[pt:cpp/numeric/random/independent bits engine/min]]
[[ru:cpp/numeric/random/independent bits engine/min]]
[[zh:cpp/numeric/random/independent bits engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/operator()</title>
    <ns>0</ns>
    <id>8796</id>
    <revision>
      <id>43463</id>
      <parentid>37167</parentid>
      <timestamp>2012-11-03T02:51:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="554">{{cpp/numeric/random/adaptor/operator()|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/operator()]]
[[es:cpp/numeric/random/independent bits engine/operator()]]
[[fr:cpp/numeric/random/independent bits engine/operator()]]
[[it:cpp/numeric/random/independent bits engine/operator()]]
[[ja:cpp/numeric/random/independent bits engine/operator()]]
[[pt:cpp/numeric/random/independent bits engine/operator()]]
[[ru:cpp/numeric/random/independent bits engine/operator()]]
[[zh:cpp/numeric/random/independent bits engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/operator cmp</title>
    <ns>0</ns>
    <id>8800</id>
    <revision>
      <id>50965</id>
      <parentid>43458</parentid>
      <timestamp>2013-06-01T03:46:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="585">{{include page|cpp/numeric/random/adaptor/operator cmp|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/operator cmp]]
[[es:cpp/numeric/random/independent bits engine/operator cmp]]
[[fr:cpp/numeric/random/independent bits engine/operator cmp]]
[[it:cpp/numeric/random/independent bits engine/operator cmp]]
[[ja:cpp/numeric/random/independent bits engine/operator cmp]]
[[pt:cpp/numeric/random/independent bits engine/operator cmp]]
[[ru:cpp/numeric/random/independent bits engine/operator cmp]]
[[zh:cpp/numeric/random/independent bits engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>8801</id>
    <revision>
      <id>50966</id>
      <parentid>43451</parentid>
      <timestamp>2013-06-01T03:46:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="630">{{include page|cpp/numeric/random/adaptor/operator ltltgtgt|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[es:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[it:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/independent bits engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/independent bits engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/independent bits engine/seed</title>
    <ns>0</ns>
    <id>8794</id>
    <revision>
      <id>50967</id>
      <parentid>43446</parentid>
      <timestamp>2013-06-01T03:46:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="513">{{include page|cpp/numeric/random/adaptor/seed|independent_bits_engine}}

[[de:cpp/numeric/random/independent bits engine/seed]]
[[es:cpp/numeric/random/independent bits engine/seed]]
[[fr:cpp/numeric/random/independent bits engine/seed]]
[[it:cpp/numeric/random/independent bits engine/seed]]
[[ja:cpp/numeric/random/independent bits engine/seed]]
[[pt:cpp/numeric/random/independent bits engine/seed]]
[[ru:cpp/numeric/random/independent bits engine/seed]]
[[zh:cpp/numeric/random/independent bits engine/seed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine</title>
    <ns>0</ns>
    <id>3115</id>
    <revision>
      <id>63195</id>
      <parentid>63191</parentid>
      <timestamp>2013-07-05T16:02:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="2840">{{cpp/title|linear_congruential_engine}}
{{cpp/numeric/random/linear_congruential_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 | 1=
template&lt;
    class UIntType, 
    UIntType a, 
    UIntType c, 
    UIntType m
&gt; class linear_congruential_engine;
}}
{{dcl end}}

{{tt|linear_congruential_engine}} is a random number engine based on [[enwiki:Linear congruential generator|Linear congruential generator (LCG)]]. A LCG has a state that consists of single integer.

The transition algorithm of the LCG function is {{math|x{{su|b=i+1}} ← (ax{{su|b=i}}+c) mod m}}.

The following typedefs define the random number engine with two commonly used parameter sets:
{{dsc begin}}
{{dsc header | random}}
{{dsc hitem | Type | Definition}}
{{dsc inc | cpp/numeric/random/dsc minstd_rand0}}
{{dsc inc | cpp/numeric/random/dsc minstd_rand}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | The integral type generated by the engine.  Results are undefined if this is not an unsigned integral type.}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h2 | Construction and Seeding}}
{{dsc inc | cpp/numeric/random/engine/dsc constructor |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc seed |linear_congruential_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc discard |linear_congruential_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/engine/dsc min |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc max |linear_congruential_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_cmp |linear_congruential_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt |linear_congruential_engine}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} multiplier | the multiplier term (a). }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} increment | the increment term (c). }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} modulus | the modulus term (m). }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} default_seed | the default seed ({{c|1}}). }}
{{dsc end}}

[[de:cpp/numeric/random/linear congruential engine]]
[[es:cpp/numeric/random/linear congruential engine]]
[[fr:cpp/numeric/random/linear congruential engine]]
[[it:cpp/numeric/random/linear congruential engine]]
[[ja:cpp/numeric/random/linear congruential engine]]
[[pt:cpp/numeric/random/linear congruential engine]]
[[ru:cpp/numeric/random/linear congruential engine]]
[[zh:cpp/numeric/random/linear congruential engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/discard</title>
    <ns>0</ns>
    <id>3719</id>
    <revision>
      <id>50968</id>
      <parentid>43436</parentid>
      <timestamp>2013-06-01T03:46:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="566">{{include page|cpp/numeric/random/engine/discard|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/discard]]
[[es:cpp/numeric/random/linear congruential engine/discard]]
[[fr:cpp/numeric/random/linear congruential engine/discard]]
[[it:cpp/numeric/random/linear congruential engine/discard]]
[[ja:cpp/numeric/random/linear congruential engine/discard]]
[[pt:cpp/numeric/random/linear congruential engine/discard]]
[[ru:cpp/numeric/random/linear congruential engine/discard]]
[[zh:cpp/numeric/random/linear congruential engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/linear congruential engine</title>
    <ns>0</ns>
    <id>3716</id>
    <revision>
      <id>50969</id>
      <parentid>43430</parentid>
      <timestamp>2013-06-01T03:46:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="722">{{include page|cpp/numeric/random/engine/constructor|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[es:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[fr:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[it:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[ja:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[pt:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[ru:cpp/numeric/random/linear congruential engine/linear congruential engine]]
[[zh:cpp/numeric/random/linear congruential engine/linear congruential engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/max</title>
    <ns>0</ns>
    <id>3721</id>
    <revision>
      <id>50970</id>
      <parentid>43423</parentid>
      <timestamp>2013-06-01T03:46:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="530">{{include page|cpp/numeric/random/engine/max|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/max]]
[[es:cpp/numeric/random/linear congruential engine/max]]
[[fr:cpp/numeric/random/linear congruential engine/max]]
[[it:cpp/numeric/random/linear congruential engine/max]]
[[ja:cpp/numeric/random/linear congruential engine/max]]
[[pt:cpp/numeric/random/linear congruential engine/max]]
[[ru:cpp/numeric/random/linear congruential engine/max]]
[[zh:cpp/numeric/random/linear congruential engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/min</title>
    <ns>0</ns>
    <id>3720</id>
    <revision>
      <id>50971</id>
      <parentid>43417</parentid>
      <timestamp>2013-06-01T03:46:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="530">{{include page|cpp/numeric/random/engine/min|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/min]]
[[es:cpp/numeric/random/linear congruential engine/min]]
[[fr:cpp/numeric/random/linear congruential engine/min]]
[[it:cpp/numeric/random/linear congruential engine/min]]
[[ja:cpp/numeric/random/linear congruential engine/min]]
[[pt:cpp/numeric/random/linear congruential engine/min]]
[[ru:cpp/numeric/random/linear congruential engine/min]]
[[zh:cpp/numeric/random/linear congruential engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/operator()</title>
    <ns>0</ns>
    <id>3718</id>
    <revision>
      <id>43409</id>
      <parentid>13901</parentid>
      <timestamp>2012-11-03T02:40:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="580">{{cpp/numeric/random/engine/operator()|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/operator()]]
[[es:cpp/numeric/random/linear congruential engine/operator()]]
[[fr:cpp/numeric/random/linear congruential engine/operator()]]
[[it:cpp/numeric/random/linear congruential engine/operator()]]
[[ja:cpp/numeric/random/linear congruential engine/operator()]]
[[pt:cpp/numeric/random/linear congruential engine/operator()]]
[[ru:cpp/numeric/random/linear congruential engine/operator()]]
[[zh:cpp/numeric/random/linear congruential engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/operator cmp</title>
    <ns>0</ns>
    <id>8821</id>
    <revision>
      <id>50972</id>
      <parentid>43402</parentid>
      <timestamp>2013-06-01T03:46:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="611">{{include page|cpp/numeric/random/engine/operator cmp|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/operator cmp]]
[[es:cpp/numeric/random/linear congruential engine/operator cmp]]
[[fr:cpp/numeric/random/linear congruential engine/operator cmp]]
[[it:cpp/numeric/random/linear congruential engine/operator cmp]]
[[ja:cpp/numeric/random/linear congruential engine/operator cmp]]
[[pt:cpp/numeric/random/linear congruential engine/operator cmp]]
[[ru:cpp/numeric/random/linear congruential engine/operator cmp]]
[[zh:cpp/numeric/random/linear congruential engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>3723</id>
    <revision>
      <id>50973</id>
      <parentid>43394</parentid>
      <timestamp>2013-06-01T03:46:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="656">{{include page|cpp/numeric/random/engine/operator_ltltgtgt|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[es:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[it:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/linear congruential engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/linear congruential engine/seed</title>
    <ns>0</ns>
    <id>3717</id>
    <revision>
      <id>50974</id>
      <parentid>43389</parentid>
      <timestamp>2013-06-01T03:46:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="539">{{include page|cpp/numeric/random/engine/seed|linear_congruential_engine}}

[[de:cpp/numeric/random/linear congruential engine/seed]]
[[es:cpp/numeric/random/linear congruential engine/seed]]
[[fr:cpp/numeric/random/linear congruential engine/seed]]
[[it:cpp/numeric/random/linear congruential engine/seed]]
[[ja:cpp/numeric/random/linear congruential engine/seed]]
[[pt:cpp/numeric/random/linear congruential engine/seed]]
[[ru:cpp/numeric/random/linear congruential engine/seed]]
[[zh:cpp/numeric/random/linear congruential engine/seed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution</title>
    <ns>0</ns>
    <id>3921</id>
    <revision>
      <id>63383</id>
      <parentid>61128</parentid>
      <timestamp>2013-07-10T01:30:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2982">{{cpp/title|lognormal_distribution}}
{{cpp/numeric/random/lognormal_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class lognormal_distribution;
}}

The lognormal_distribution random number distribution produces random numbers {{math|x &gt; 0}} according to a log-normal distribution:

:{{math|f(x; m,s) {{=}} {{mfrac||1|sx{{mrad|2 π}} }} exp{{mparen|(|)|- {{mfrac||(ln x - m){{su|p=2}}| 2s{{su|p=2}}}} }} }}

The parameter {{math|m}} is the mean and the parameter {{math|s}} the standard deviation.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | lognormal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | lognormal_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | lognormal_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | lognormal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | lognormal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | lognormal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | lognormal_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | lognormal_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | lognormal_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
#include &lt;cmath&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    std::lognormal_distribution&lt;&gt; d(1.6, 0.25);
 
    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[std::round(d(gen))];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(1) &lt;&lt; std::setw(2)
                  &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/200, '*') &lt;&lt; '\n';
    }
}
 | output=
 2 
 3 ***
 4 *************
 5 ***************
 6 *********
 7 ****
 8 *
 9 
10 
11 
12
}}

===External links===
* [http://mathworld.wolfram.com/LogNormalDistribution.html Weisstein, Eric W. &quot;Log Normal Distribution.&quot;] From MathWorld--A Wolfram Web Resource.
* [https://en.wikipedia.org/wiki/Log-normal_distribution Log-normal distribution.] From Wikipedia.

[[de:cpp/numeric/random/lognormal distribution]]
[[es:cpp/numeric/random/lognormal distribution]]
[[fr:cpp/numeric/random/lognormal distribution]]
[[it:cpp/numeric/random/lognormal distribution]]
[[ja:cpp/numeric/random/lognormal distribution]]
[[pt:cpp/numeric/random/lognormal distribution]]
[[ru:cpp/numeric/random/lognormal distribution]]
[[zh:cpp/numeric/random/lognormal distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/lognormal distribution</title>
    <ns>0</ns>
    <id>4929</id>
    <revision>
      <id>62899</id>
      <parentid>50370</parentid>
      <timestamp>2013-07-01T23:45:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1328">{{cpp/numeric/random/lognormal_distribution/title|lognormal_distribution}}
{{cpp/numeric/random/lognormal_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit lognormal_distribution( RealType m = 0.0, RealType s = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit lognormal_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|m}} and {{tt|s}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | m | the ''m'' distribution parameter (log-scale)}}
{{par | s | the ''s'' distribution parameter (shape)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[es:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[fr:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[it:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[ja:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[pt:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[ru:cpp/numeric/random/lognormal distribution/lognormal distribution]]
[[zh:cpp/numeric/random/lognormal distribution/lognormal distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/m</title>
    <ns>0</ns>
    <id>8889</id>
    <redirect title="cpp/numeric/random/lognormal distribution/params" />
    <revision>
      <id>61130</id>
      <parentid>58714</parentid>
      <timestamp>2013-06-05T12:13:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/lognormal distribution/params]]</comment>
      <text xml:space="preserve" bytes="62">#redirect [[cpp/numeric/random/lognormal_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/max</title>
    <ns>0</ns>
    <id>4011</id>
    <revision>
      <id>50975</id>
      <parentid>43359</parentid>
      <timestamp>2013-06-01T03:46:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/max|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/max]]
[[es:cpp/numeric/random/lognormal distribution/max]]
[[fr:cpp/numeric/random/lognormal distribution/max]]
[[it:cpp/numeric/random/lognormal distribution/max]]
[[ja:cpp/numeric/random/lognormal distribution/max]]
[[pt:cpp/numeric/random/lognormal distribution/max]]
[[ru:cpp/numeric/random/lognormal distribution/max]]
[[zh:cpp/numeric/random/lognormal distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/min</title>
    <ns>0</ns>
    <id>3973</id>
    <revision>
      <id>50976</id>
      <parentid>43353</parentid>
      <timestamp>2013-06-01T03:46:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/min|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/min]]
[[es:cpp/numeric/random/lognormal distribution/min]]
[[fr:cpp/numeric/random/lognormal distribution/min]]
[[it:cpp/numeric/random/lognormal distribution/min]]
[[ja:cpp/numeric/random/lognormal distribution/min]]
[[pt:cpp/numeric/random/lognormal distribution/min]]
[[ru:cpp/numeric/random/lognormal distribution/min]]
[[zh:cpp/numeric/random/lognormal distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/operator()</title>
    <ns>0</ns>
    <id>4111</id>
    <revision>
      <id>43347</id>
      <parentid>15060</parentid>
      <timestamp>2012-11-03T02:28:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="550">{{cpp/numeric/random/distribution/operator()|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/operator()]]
[[es:cpp/numeric/random/lognormal distribution/operator()]]
[[fr:cpp/numeric/random/lognormal distribution/operator()]]
[[it:cpp/numeric/random/lognormal distribution/operator()]]
[[ja:cpp/numeric/random/lognormal distribution/operator()]]
[[pt:cpp/numeric/random/lognormal distribution/operator()]]
[[ru:cpp/numeric/random/lognormal distribution/operator()]]
[[zh:cpp/numeric/random/lognormal distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/operator cmp</title>
    <ns>0</ns>
    <id>4152</id>
    <revision>
      <id>50977</id>
      <parentid>43340</parentid>
      <timestamp>2013-06-01T03:46:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/operator_cmp|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/operator cmp]]
[[es:cpp/numeric/random/lognormal distribution/operator cmp]]
[[fr:cpp/numeric/random/lognormal distribution/operator cmp]]
[[it:cpp/numeric/random/lognormal distribution/operator cmp]]
[[ja:cpp/numeric/random/lognormal distribution/operator cmp]]
[[pt:cpp/numeric/random/lognormal distribution/operator cmp]]
[[ru:cpp/numeric/random/lognormal distribution/operator cmp]]
[[zh:cpp/numeric/random/lognormal distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4527</id>
    <revision>
      <id>50978</id>
      <parentid>43333</parentid>
      <timestamp>2013-06-01T03:46:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="626">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/lognormal distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/param</title>
    <ns>0</ns>
    <id>4131</id>
    <revision>
      <id>50979</id>
      <parentid>43327</parentid>
      <timestamp>2013-06-01T03:47:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/param|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/param]]
[[es:cpp/numeric/random/lognormal distribution/param]]
[[fr:cpp/numeric/random/lognormal distribution/param]]
[[it:cpp/numeric/random/lognormal distribution/param]]
[[ja:cpp/numeric/random/lognormal distribution/param]]
[[pt:cpp/numeric/random/lognormal distribution/param]]
[[ru:cpp/numeric/random/lognormal distribution/param]]
[[zh:cpp/numeric/random/lognormal distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/params</title>
    <ns>0</ns>
    <id>12605</id>
    <revision>
      <id>61247</id>
      <timestamp>2013-06-05T12:53:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="795">{{cpp/numeric/random/lognormal_distribution/title|m, s}}
{{cpp/numeric/random/lognormal_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
RealType m() const;
}}
{{dcl | since=c++11 | num=2 |
RealType s() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the mean {{math|m}} distribution parameter. It defines the location of the peak. The default value is {{c|0.0}}.

@2@ Returns the deviation {{math|s}} distribution parameter. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
@1@ The mean {{math|m}} distribution parameter. 

@2@ The deviation {{math|s}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | lognormal_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/reset</title>
    <ns>0</ns>
    <id>4087</id>
    <revision>
      <id>50980</id>
      <parentid>43320</parentid>
      <timestamp>2013-06-01T03:47:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/reset|lognormal_distribution}}

[[de:cpp/numeric/random/lognormal distribution/reset]]
[[es:cpp/numeric/random/lognormal distribution/reset]]
[[fr:cpp/numeric/random/lognormal distribution/reset]]
[[it:cpp/numeric/random/lognormal distribution/reset]]
[[ja:cpp/numeric/random/lognormal distribution/reset]]
[[pt:cpp/numeric/random/lognormal distribution/reset]]
[[ru:cpp/numeric/random/lognormal distribution/reset]]
[[zh:cpp/numeric/random/lognormal distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/lognormal distribution/s</title>
    <ns>0</ns>
    <id>8890</id>
    <redirect title="cpp/numeric/random/lognormal distribution/params" />
    <revision>
      <id>61129</id>
      <parentid>58717</parentid>
      <timestamp>2013-06-05T12:13:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/lognormal distribution/params]]</comment>
      <text xml:space="preserve" bytes="62">#redirect [[cpp/numeric/random/lognormal_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine</title>
    <ns>0</ns>
    <id>3698</id>
    <revision>
      <id>63194</id>
      <parentid>63192</parentid>
      <timestamp>2013-07-05T16:02:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-}}</comment>
      <text xml:space="preserve" bytes="3618">{{cpp/title|mersenne_twister_engine}}
{{cpp/numeric/random/mersenne_twister_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 | 1=
template&lt;
    class UIntType, 
    size_t w, size_t n, size_t m, size_t r,
    UIntType a, size_t u, UIntType d, size_t s,
    UIntType b, size_t t,
    UIntType c, size_t l, UIntType f
&gt; class mersenne_twister_engine;
}}
{{dcl end}}

{{tt|mersenne_twister_engine}} is a random number engine based on [[enwiki:Mersenne_twister|Mersenne Twister]] algorithm. It produces high quality unsigned integer random numbers.

The following typedefs define the random number engine with two commonly used parameter sets:
{{dsc begin}}
{{dsc header | random}}
{{dsc hitem | Type | Definition}}
{{dsc inc | cpp/numeric/random/dsc mt19937}}
{{dsc inc | cpp/numeric/random/dsc mt19937_64}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | The integral type generated by the engine.  Results are undefined if this is not an unsigned integral type.}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h2 | Construction and Seeding}}
{{dsc inc | cpp/numeric/random/engine/dsc constructor |mersenne_twister_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc seed |mersenne_twister_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() |mersenne_twister_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc discard |mersenne_twister_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/engine/dsc min |mersenne_twister_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc max |mersenne_twister_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_cmp |mersenne_twister_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt |mersenne_twister_engine}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} word_size | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} state_size | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} shift_size | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} mask_bits | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} xor_mask | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} tempering_u | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} tempering_d | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} tempering_s | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} tempering_b | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} tempering_t | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} tempering_c | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} tempering_l | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} initialization_multiplier | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} default_seed | {{todo}} }}
{{dsc end}}

[[de:cpp/numeric/random/mersenne twister engine]]
[[es:cpp/numeric/random/mersenne twister engine]]
[[fr:cpp/numeric/random/mersenne twister engine]]
[[it:cpp/numeric/random/mersenne twister engine]]
[[ja:cpp/numeric/random/mersenne twister engine]]
[[pt:cpp/numeric/random/mersenne twister engine]]
[[ru:cpp/numeric/random/mersenne twister engine]]
[[zh:cpp/numeric/random/mersenne twister engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/discard</title>
    <ns>0</ns>
    <id>3728</id>
    <revision>
      <id>50981</id>
      <parentid>43299</parentid>
      <timestamp>2013-06-01T03:47:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="539">{{include page|cpp/numeric/random/engine/discard|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/discard]]
[[es:cpp/numeric/random/mersenne twister engine/discard]]
[[fr:cpp/numeric/random/mersenne twister engine/discard]]
[[it:cpp/numeric/random/mersenne twister engine/discard]]
[[ja:cpp/numeric/random/mersenne twister engine/discard]]
[[pt:cpp/numeric/random/mersenne twister engine/discard]]
[[ru:cpp/numeric/random/mersenne twister engine/discard]]
[[zh:cpp/numeric/random/mersenne twister engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/max</title>
    <ns>0</ns>
    <id>3726</id>
    <revision>
      <id>50982</id>
      <parentid>43294</parentid>
      <timestamp>2013-06-01T03:47:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="503">{{include page|cpp/numeric/random/engine/max|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/max]]
[[es:cpp/numeric/random/mersenne twister engine/max]]
[[fr:cpp/numeric/random/mersenne twister engine/max]]
[[it:cpp/numeric/random/mersenne twister engine/max]]
[[ja:cpp/numeric/random/mersenne twister engine/max]]
[[pt:cpp/numeric/random/mersenne twister engine/max]]
[[ru:cpp/numeric/random/mersenne twister engine/max]]
[[zh:cpp/numeric/random/mersenne twister engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/mersenne twister engine</title>
    <ns>0</ns>
    <id>3731</id>
    <revision>
      <id>50983</id>
      <parentid>43286</parentid>
      <timestamp>2013-06-01T03:47:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="671">{{include page|cpp/numeric/random/engine/constructor|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[es:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[fr:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[it:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[ja:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[pt:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[ru:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]
[[zh:cpp/numeric/random/mersenne twister engine/mersenne twister engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/min</title>
    <ns>0</ns>
    <id>3727</id>
    <revision>
      <id>50984</id>
      <parentid>43281</parentid>
      <timestamp>2013-06-01T03:47:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="503">{{include page|cpp/numeric/random/engine/min|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/min]]
[[es:cpp/numeric/random/mersenne twister engine/min]]
[[fr:cpp/numeric/random/mersenne twister engine/min]]
[[it:cpp/numeric/random/mersenne twister engine/min]]
[[ja:cpp/numeric/random/mersenne twister engine/min]]
[[pt:cpp/numeric/random/mersenne twister engine/min]]
[[ru:cpp/numeric/random/mersenne twister engine/min]]
[[zh:cpp/numeric/random/mersenne twister engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/operator()</title>
    <ns>0</ns>
    <id>3729</id>
    <revision>
      <id>43274</id>
      <parentid>13910</parentid>
      <timestamp>2012-11-03T02:15:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="553">{{cpp/numeric/random/engine/operator()|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/operator()]]
[[es:cpp/numeric/random/mersenne twister engine/operator()]]
[[fr:cpp/numeric/random/mersenne twister engine/operator()]]
[[it:cpp/numeric/random/mersenne twister engine/operator()]]
[[ja:cpp/numeric/random/mersenne twister engine/operator()]]
[[pt:cpp/numeric/random/mersenne twister engine/operator()]]
[[ru:cpp/numeric/random/mersenne twister engine/operator()]]
[[zh:cpp/numeric/random/mersenne twister engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/operator cmp</title>
    <ns>0</ns>
    <id>8820</id>
    <revision>
      <id>50985</id>
      <parentid>43264</parentid>
      <timestamp>2013-06-01T03:47:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="584">{{include page|cpp/numeric/random/engine/operator cmp|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[es:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[fr:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[it:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[ja:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[pt:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[ru:cpp/numeric/random/mersenne twister engine/operator cmp]]
[[zh:cpp/numeric/random/mersenne twister engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>3724</id>
    <revision>
      <id>50986</id>
      <parentid>43257</parentid>
      <timestamp>2013-06-01T03:47:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="629">{{include page|cpp/numeric/random/engine/operator_ltltgtgt|mersenne_twister_engine}}

[[de:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[es:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[it:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/mersenne twister engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/mersenne twister engine/seed</title>
    <ns>0</ns>
    <id>3730</id>
    <revision>
      <id>67887</id>
      <parentid>50987</parentid>
      <timestamp>2014-03-04T13:55:17Z</timestamp>
      <contributor>
        <username>Wanttoknow</username>
        <id>2904</id>
      </contributor>
      <text xml:space="preserve" bytes="979">{{include page|cpp/numeric/random/engine/seed|mersenne_twister_engine}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;random&gt;

int main()
{
    std::mt19937 gen;

    // Seed the engine with an unsigned int
    gen.seed(1);
    std::cout &lt;&lt; &quot;after seed by 1: &quot; &lt;&lt; gen() &lt;&lt; '\n';

    // Seed the engine with two unsigned ints
    std::seed_seq sseq{1, 2};
    gen.seed(sseq);
    std::cout &lt;&lt; &quot;after seed by {1,2}: &quot; &lt;&lt; gen() &lt;&lt; '\n';
}
 | output=
after seed by 1: 1791095845
after seed by {1,2}: 3127717181
}}

[[de:cpp/numeric/random/mersenne twister engine/seed]]
[[es:cpp/numeric/random/mersenne twister engine/seed]]
[[fr:cpp/numeric/random/mersenne twister engine/seed]]
[[it:cpp/numeric/random/mersenne twister engine/seed]]
[[ja:cpp/numeric/random/mersenne twister engine/seed]]
[[pt:cpp/numeric/random/mersenne twister engine/seed]]
[[ru:cpp/numeric/random/mersenne twister engine/seed]]
[[zh:cpp/numeric/random/mersenne twister engine/seed]]</text>
      <sha1>5qchp4kolll2lctxdwze862z4ozjlab</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution</title>
    <ns>0</ns>
    <id>3913</id>
    <revision>
      <id>63384</id>
      <parentid>61143</parentid>
      <timestamp>2013-07-10T01:30:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3217">{{cpp/title|negative_binomial_distribution}}
{{cpp/numeric/random/negative_binomial_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class negative_binomial_distribution;
}}

Produces random non-negative integer values {{math|i}}, distributed according to discrete probability function:

:{{math|P(i{{!}}k,p) {{=}}{{mparen|(|)|k + i − 1|i}} · p{{su|p=k}} · (1 − p){{su|p=i}}}}

The value represents the number of failures in a series of independent yes/no trials (each succeeds with probability {{math|p}}), before exactly {{math|k}} successes occur.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | negative_binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | negative_binomial_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | negative_binomial_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | negative_binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | negative_binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | negative_binomial_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | negative_binomial_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | negative_binomial_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | negative_binomial_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    // Pat goes door-to-door selling cookies
    // At each house, there's a 75% chance that she sells one box
    // how many times will she be turned away before selling 5 boxes?
    std::negative_binomial_distribution&lt;&gt; d(5, 0.75);
 
    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout  &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 ***********************
1 *****************************
2 **********************
3 *************
4 ******
5 ***
6 *
7 
8 
9 
10 
11 
}}

===External links===
[http://mathworld.wolfram.com/NegativeBinomialDistribution.html Weisstein, Eric W. &quot;Negative Binomial Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/negative binomial distribution]]
[[es:cpp/numeric/random/negative binomial distribution]]
[[fr:cpp/numeric/random/negative binomial distribution]]
[[it:cpp/numeric/random/negative binomial distribution]]
[[ja:cpp/numeric/random/negative binomial distribution]]
[[pt:cpp/numeric/random/negative binomial distribution]]
[[ru:cpp/numeric/random/negative binomial distribution]]
[[zh:cpp/numeric/random/negative binomial distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/k</title>
    <ns>0</ns>
    <id>5149</id>
    <redirect title="cpp/numeric/random/negative binomial distribution/params" />
    <revision>
      <id>61185</id>
      <parentid>58722</parentid>
      <timestamp>2013-06-05T12:26:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/negative binomial distribution/params]]</comment>
      <text xml:space="preserve" bytes="70">#redirect [[cpp/numeric/random/negative_binomial_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/max</title>
    <ns>0</ns>
    <id>4004</id>
    <revision>
      <id>50988</id>
      <parentid>43230</parentid>
      <timestamp>2013-06-01T03:47:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="572">{{include page|cpp/numeric/random/distribution/max|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/max]]
[[es:cpp/numeric/random/negative binomial distribution/max]]
[[fr:cpp/numeric/random/negative binomial distribution/max]]
[[it:cpp/numeric/random/negative binomial distribution/max]]
[[ja:cpp/numeric/random/negative binomial distribution/max]]
[[pt:cpp/numeric/random/negative binomial distribution/max]]
[[ru:cpp/numeric/random/negative binomial distribution/max]]
[[zh:cpp/numeric/random/negative binomial distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/min</title>
    <ns>0</ns>
    <id>3980</id>
    <revision>
      <id>50989</id>
      <parentid>43223</parentid>
      <timestamp>2013-06-01T03:47:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="572">{{include page|cpp/numeric/random/distribution/min|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/min]]
[[es:cpp/numeric/random/negative binomial distribution/min]]
[[fr:cpp/numeric/random/negative binomial distribution/min]]
[[it:cpp/numeric/random/negative binomial distribution/min]]
[[ja:cpp/numeric/random/negative binomial distribution/min]]
[[pt:cpp/numeric/random/negative binomial distribution/min]]
[[ru:cpp/numeric/random/negative binomial distribution/min]]
[[zh:cpp/numeric/random/negative binomial distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/negative binomial distribution</title>
    <ns>0</ns>
    <id>4921</id>
    <revision>
      <id>62900</id>
      <parentid>50376</parentid>
      <timestamp>2013-07-01T23:45:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1758">{{cpp/numeric/random/negative_binomial_distribution/title|negative_binomial_distribution}}
{{cpp/numeric/random/negative_binomial_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit negative_binomial_distribution( IntType k = 1, double p = 0.5 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit negative_binomial_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|k}} and {{tt|p}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | k | the ''k'' distribution parameter (number of trial failures)}}
{{par | p | the ''p'' distribution parameter (probability of a trial generating {{c|true}})}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|0 &lt; p ≤ 1}} and {{math|0 &lt; k}}.

The default-constructed {{tt|std::negative_binomial_distribution}} is equivalent to the default-constructed {{lc|std::geometric_distribution}}.

[[de:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[es:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[fr:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[it:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[ja:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[pt:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[ru:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]
[[zh:cpp/numeric/random/negative binomial distribution/negative binomial distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/operator()</title>
    <ns>0</ns>
    <id>4102</id>
    <revision>
      <id>43209</id>
      <parentid>15051</parentid>
      <timestamp>2012-11-03T02:01:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="622">{{cpp/numeric/random/distribution/operator()|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/operator()]]
[[es:cpp/numeric/random/negative binomial distribution/operator()]]
[[fr:cpp/numeric/random/negative binomial distribution/operator()]]
[[it:cpp/numeric/random/negative binomial distribution/operator()]]
[[ja:cpp/numeric/random/negative binomial distribution/operator()]]
[[pt:cpp/numeric/random/negative binomial distribution/operator()]]
[[ru:cpp/numeric/random/negative binomial distribution/operator()]]
[[zh:cpp/numeric/random/negative binomial distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/operator cmp</title>
    <ns>0</ns>
    <id>4144</id>
    <revision>
      <id>50990</id>
      <parentid>43201</parentid>
      <timestamp>2013-06-01T03:47:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="653">{{include page|cpp/numeric/random/distribution/operator_cmp|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[es:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[fr:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[it:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[ja:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[pt:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[ru:cpp/numeric/random/negative binomial distribution/operator cmp]]
[[zh:cpp/numeric/random/negative binomial distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4535</id>
    <revision>
      <id>50991</id>
      <parentid>43194</parentid>
      <timestamp>2013-06-01T03:47:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="698">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/negative binomial distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/p</title>
    <ns>0</ns>
    <id>5148</id>
    <redirect title="cpp/numeric/random/negative binomial distribution/params" />
    <revision>
      <id>61184</id>
      <parentid>58725</parentid>
      <timestamp>2013-06-05T12:26:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/negative binomial distribution/params]]</comment>
      <text xml:space="preserve" bytes="70">#redirect [[cpp/numeric/random/negative_binomial_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/param</title>
    <ns>0</ns>
    <id>4077</id>
    <revision>
      <id>50992</id>
      <parentid>43179</parentid>
      <timestamp>2013-06-01T03:47:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="590">{{include page|cpp/numeric/random/distribution/param|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/param]]
[[es:cpp/numeric/random/negative binomial distribution/param]]
[[fr:cpp/numeric/random/negative binomial distribution/param]]
[[it:cpp/numeric/random/negative binomial distribution/param]]
[[ja:cpp/numeric/random/negative binomial distribution/param]]
[[pt:cpp/numeric/random/negative binomial distribution/param]]
[[ru:cpp/numeric/random/negative binomial distribution/param]]
[[zh:cpp/numeric/random/negative binomial distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/params</title>
    <ns>0</ns>
    <id>12601</id>
    <revision>
      <id>61265</id>
      <parentid>61243</parentid>
      <timestamp>2013-06-05T13:13:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce, default value</comment>
      <text xml:space="preserve" bytes="850">{{cpp/numeric/random/negative_binomial_distribution/title|p, k}}
{{cpp/numeric/random/negative_binomial_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
double p() const;
}}
{{dcl | since=c++11 | num=2 |
IntType k() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the {{math|p}} distribution parameter. It defines the probability of a trial generating {{c|true}}. The default value is {{c|0.5}}.

@2@ Returns the {{math|k}} distribution parameter. It defines the number of desired outcomes. The default value is {{c|1}}.

===Parameters===
(none)

===Return value===
@1@ The {{math|p}} distribution parameter.

@2@ The {{math|k}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | negative_binomial_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/negative binomial distribution/reset</title>
    <ns>0</ns>
    <id>4079</id>
    <revision>
      <id>50993</id>
      <parentid>43172</parentid>
      <timestamp>2013-06-01T03:47:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="590">{{include page|cpp/numeric/random/distribution/reset|negative_binomial_distribution}}

[[de:cpp/numeric/random/negative binomial distribution/reset]]
[[es:cpp/numeric/random/negative binomial distribution/reset]]
[[fr:cpp/numeric/random/negative binomial distribution/reset]]
[[it:cpp/numeric/random/negative binomial distribution/reset]]
[[ja:cpp/numeric/random/negative binomial distribution/reset]]
[[pt:cpp/numeric/random/negative binomial distribution/reset]]
[[ru:cpp/numeric/random/negative binomial distribution/reset]]
[[zh:cpp/numeric/random/negative binomial distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution</title>
    <ns>0</ns>
    <id>3920</id>
    <revision>
      <id>63385</id>
      <parentid>63261</parentid>
      <timestamp>2013-07-10T01:30:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3085">{{cpp/title|normal_distribution}}
{{cpp/numeric/random/normal_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class normal_distribution;
}}

Generates random numbers according to the [[enwiki:Normal distribution|Normal (or Gaussian) random number distribution]]. It is defined as:

: {{math|f(x; μ,σ) {{=}} {{mfrac||1|σ{{mrad|2π}}}} exp{{mparen|(|)| -{{mfrac|1|2}} {{mparen|(|)|{{mfrac|x-μ|σ}} }}{{su|p=2}} }} }}

Here {{math|μ}} is the [[enwiki:Mean|mean]] and {{math|σ}} is the [[enwiki:Standard deviation|standard deviation]] (''stddev'').

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | normal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | normal_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | normal_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | normal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | normal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | normal_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | normal_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | normal_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | normal_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
#include &lt;cmath&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    // values near the mean are the most likely
    // standard deviation affects the dispersion of generated values from the mean
    std::normal_distribution&lt;&gt; d(5,2);

    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[std::round(d(gen))];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(1) &lt;&lt; std::setw(2)
                  &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/200, '*') &lt;&lt; '\n';
    }
}
 | output=
-2 
-1 
 0 
 1 *
 2 ***
 3 ******
 4 ********
 5 **********
 6 ********
 7 *****
 8 ***
 9 *
10 
11 
12 
}}

===External links===
* [http://mathworld.wolfram.com/NormalDistribution.html Weisstein, Eric W. &quot;Normal Distribution.&quot;] From MathWorld--A Wolfram Web Resource.
* [[enwiki:Normal_distribution|Normal Distribution.]] From Wikipedia.

[[de:cpp/numeric/random/normal distribution]]
[[es:cpp/numeric/random/normal distribution]]
[[fr:cpp/numeric/random/normal distribution]]
[[it:cpp/numeric/random/normal distribution]]
[[ja:cpp/numeric/random/normal distribution]]
[[pt:cpp/numeric/random/normal distribution]]
[[ru:cpp/numeric/random/normal distribution]]
[[zh:cpp/numeric/random/normal distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/max</title>
    <ns>0</ns>
    <id>4009</id>
    <revision>
      <id>50994</id>
      <parentid>43158</parentid>
      <timestamp>2013-06-01T03:47:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="473">{{include page|cpp/numeric/random/distribution/max|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/max]]
[[es:cpp/numeric/random/normal distribution/max]]
[[fr:cpp/numeric/random/normal distribution/max]]
[[it:cpp/numeric/random/normal distribution/max]]
[[ja:cpp/numeric/random/normal distribution/max]]
[[pt:cpp/numeric/random/normal distribution/max]]
[[ru:cpp/numeric/random/normal distribution/max]]
[[zh:cpp/numeric/random/normal distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/mean</title>
    <ns>0</ns>
    <id>8884</id>
    <redirect title="cpp/numeric/random/normal distribution/params" />
    <revision>
      <id>61133</id>
      <parentid>58729</parentid>
      <timestamp>2013-06-05T12:14:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/normal distribution/params]]</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/numeric/random/normal_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/min</title>
    <ns>0</ns>
    <id>3974</id>
    <revision>
      <id>50995</id>
      <parentid>43143</parentid>
      <timestamp>2013-06-01T03:47:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="473">{{include page|cpp/numeric/random/distribution/min|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/min]]
[[es:cpp/numeric/random/normal distribution/min]]
[[fr:cpp/numeric/random/normal distribution/min]]
[[it:cpp/numeric/random/normal distribution/min]]
[[ja:cpp/numeric/random/normal distribution/min]]
[[pt:cpp/numeric/random/normal distribution/min]]
[[ru:cpp/numeric/random/normal distribution/min]]
[[zh:cpp/numeric/random/normal distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/normal distribution</title>
    <ns>0</ns>
    <id>4928</id>
    <revision>
      <id>62901</id>
      <parentid>50380</parentid>
      <timestamp>2013-07-01T23:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1299">{{cpp/numeric/random/normal_distribution/title|normal_distribution}}
{{cpp/numeric/random/normal_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit normal_distribution( RealType mean = 0.0, RealType stddev = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit normal_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|mean}} and {{tt|stddev}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | mean | the ''μ'' distribution parameter (mean)}}
{{par | stddev | the ''σ'' distribution parameter (standard deviation)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/normal distribution/normal distribution]]
[[es:cpp/numeric/random/normal distribution/normal distribution]]
[[fr:cpp/numeric/random/normal distribution/normal distribution]]
[[it:cpp/numeric/random/normal distribution/normal distribution]]
[[ja:cpp/numeric/random/normal distribution/normal distribution]]
[[pt:cpp/numeric/random/normal distribution/normal distribution]]
[[ru:cpp/numeric/random/normal distribution/normal distribution]]
[[zh:cpp/numeric/random/normal distribution/normal distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/operator()</title>
    <ns>0</ns>
    <id>4109</id>
    <revision>
      <id>43129</id>
      <parentid>15058</parentid>
      <timestamp>2012-11-03T01:44:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="523">{{cpp/numeric/random/distribution/operator()|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/operator()]]
[[es:cpp/numeric/random/normal distribution/operator()]]
[[fr:cpp/numeric/random/normal distribution/operator()]]
[[it:cpp/numeric/random/normal distribution/operator()]]
[[ja:cpp/numeric/random/normal distribution/operator()]]
[[pt:cpp/numeric/random/normal distribution/operator()]]
[[ru:cpp/numeric/random/normal distribution/operator()]]
[[zh:cpp/numeric/random/normal distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/operator cmp</title>
    <ns>0</ns>
    <id>4151</id>
    <revision>
      <id>50996</id>
      <parentid>43122</parentid>
      <timestamp>2013-06-01T03:47:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="554">{{include page|cpp/numeric/random/distribution/operator_cmp|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/operator cmp]]
[[es:cpp/numeric/random/normal distribution/operator cmp]]
[[fr:cpp/numeric/random/normal distribution/operator cmp]]
[[it:cpp/numeric/random/normal distribution/operator cmp]]
[[ja:cpp/numeric/random/normal distribution/operator cmp]]
[[pt:cpp/numeric/random/normal distribution/operator cmp]]
[[ru:cpp/numeric/random/normal distribution/operator cmp]]
[[zh:cpp/numeric/random/normal distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4528</id>
    <revision>
      <id>50997</id>
      <parentid>43114</parentid>
      <timestamp>2013-06-01T03:47:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/normal distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/normal distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/param</title>
    <ns>0</ns>
    <id>4130</id>
    <revision>
      <id>50998</id>
      <parentid>43106</parentid>
      <timestamp>2013-06-01T03:47:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/param|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/param]]
[[es:cpp/numeric/random/normal distribution/param]]
[[fr:cpp/numeric/random/normal distribution/param]]
[[it:cpp/numeric/random/normal distribution/param]]
[[ja:cpp/numeric/random/normal distribution/param]]
[[pt:cpp/numeric/random/normal distribution/param]]
[[ru:cpp/numeric/random/normal distribution/param]]
[[zh:cpp/numeric/random/normal distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/params</title>
    <ns>0</ns>
    <id>12604</id>
    <revision>
      <id>61246</id>
      <timestamp>2013-06-05T12:51:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="813">{{cpp/numeric/random/normal_distribution/title|mean, stddev}}
{{cpp/numeric/random/normal_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
RealType mean() const;
}}
{{dcl | since=c++11 | num=2 |
RealType stddev() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the mean {{math|μ}} distribution parameter. The mean specifies the location of the peak. The default value is {{c|0.0}}.

@2@ Returns the deviation {{math|σ}} distribution parameter. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
@1@ The mean {{math|μ}} distribution parameter.

@2@ The deviation {{math|σ}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | normal_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/reset</title>
    <ns>0</ns>
    <id>4086</id>
    <revision>
      <id>50999</id>
      <parentid>43099</parentid>
      <timestamp>2013-06-01T03:47:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="491">{{include page|cpp/numeric/random/distribution/reset|normal_distribution}}

[[de:cpp/numeric/random/normal distribution/reset]]
[[es:cpp/numeric/random/normal distribution/reset]]
[[fr:cpp/numeric/random/normal distribution/reset]]
[[it:cpp/numeric/random/normal distribution/reset]]
[[ja:cpp/numeric/random/normal distribution/reset]]
[[pt:cpp/numeric/random/normal distribution/reset]]
[[ru:cpp/numeric/random/normal distribution/reset]]
[[zh:cpp/numeric/random/normal distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/normal distribution/stddev</title>
    <ns>0</ns>
    <id>8885</id>
    <redirect title="cpp/numeric/random/normal distribution/params" />
    <revision>
      <id>61134</id>
      <parentid>58730</parentid>
      <timestamp>2013-06-05T12:15:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/normal distribution/params]]</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/numeric/random/normal_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution</title>
    <ns>0</ns>
    <id>3927</id>
    <revision>
      <id>63386</id>
      <parentid>61096</parentid>
      <timestamp>2013-07-10T01:30:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3210">{{cpp/title|piecewise_constant_distribution}}
{{cpp/numeric/random/piecewise_constant_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class piecewise_constant_distribution;
}}

{{tt|std::piecewise_constant_distribution}} produces random floating-point numbers, which are uniformly distributed within each of the several subintervals {{math|[b{{su|b=i}}, b{{su|b=i+1}})}}, each with its own weight {{math|w{{su|b=i}}}}. The set of interval boundaries and the set of weights are the parameters of this distribution.

The probability density for any {{math|b{{su|b=i}}≤x&lt;b{{su|b=i+1}}}} is {{math|{{mfrac||w{{su|b=k}} | S (b{{su|b=i+1}} - b{{su|b=i}}) }} }}. where {{math|S}} is the sum of all weights.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | piecewise_constant_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | piecewise_constant_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | piecewise_constant_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/piecewise_constant_distribution/dsc params}}

{{dsc inc | cpp/numeric/random/distribution/dsc param | piecewise_constant_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | piecewise_constant_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | piecewise_constant_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | piecewise_constant_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | piecewise_constant_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    // 50% of the time, generate a random number between 0 and 1
    // 50% of the time, generate a random number between 10 and 15
    std::vector&lt;double&gt; i{0,  1, 10, 15};
    std::vector&lt;double&gt; w{  1,  0,  1};
    std::piecewise_constant_distribution&lt;&gt; d(i.begin(), i.end(), w.begin());

    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 **************************************************
10 **********
11 *********
12 *********
13 **********
14 *********
}}

[[de:cpp/numeric/random/piecewise constant distribution]]
[[es:cpp/numeric/random/piecewise constant distribution]]
[[fr:cpp/numeric/random/piecewise constant distribution]]
[[it:cpp/numeric/random/piecewise constant distribution]]
[[ja:cpp/numeric/random/piecewise constant distribution]]
[[pt:cpp/numeric/random/piecewise constant distribution]]
[[ru:cpp/numeric/random/piecewise constant distribution]]
[[zh:cpp/numeric/random/piecewise constant distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/densities</title>
    <ns>0</ns>
    <id>12589</id>
    <redirect title="cpp/numeric/random/piecewise constant distribution/params" />
    <revision>
      <id>61100</id>
      <timestamp>2013-06-05T11:20:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/piecewise constant distribution/params]]</comment>
      <text xml:space="preserve" bytes="71">#redirect [[cpp/numeric/random/piecewise_constant_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/intervals</title>
    <ns>0</ns>
    <id>12588</id>
    <redirect title="cpp/numeric/random/piecewise constant distribution/params" />
    <revision>
      <id>61099</id>
      <timestamp>2013-06-05T11:20:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/piecewise constant distribution/params]]</comment>
      <text xml:space="preserve" bytes="71">#redirect [[cpp/numeric/random/piecewise_constant_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/max</title>
    <ns>0</ns>
    <id>4013</id>
    <revision>
      <id>51000</id>
      <parentid>43079</parentid>
      <timestamp>2013-06-01T03:47:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/max|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/max]]
[[es:cpp/numeric/random/piecewise constant distribution/max]]
[[fr:cpp/numeric/random/piecewise constant distribution/max]]
[[it:cpp/numeric/random/piecewise constant distribution/max]]
[[ja:cpp/numeric/random/piecewise constant distribution/max]]
[[pt:cpp/numeric/random/piecewise constant distribution/max]]
[[ru:cpp/numeric/random/piecewise constant distribution/max]]
[[zh:cpp/numeric/random/piecewise constant distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/min</title>
    <ns>0</ns>
    <id>3967</id>
    <revision>
      <id>51001</id>
      <parentid>43073</parentid>
      <timestamp>2013-06-01T03:47:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/min|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/min]]
[[es:cpp/numeric/random/piecewise constant distribution/min]]
[[fr:cpp/numeric/random/piecewise constant distribution/min]]
[[it:cpp/numeric/random/piecewise constant distribution/min]]
[[ja:cpp/numeric/random/piecewise constant distribution/min]]
[[pt:cpp/numeric/random/piecewise constant distribution/min]]
[[ru:cpp/numeric/random/piecewise constant distribution/min]]
[[zh:cpp/numeric/random/piecewise constant distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/operator()</title>
    <ns>0</ns>
    <id>4114</id>
    <revision>
      <id>43068</id>
      <parentid>15063</parentid>
      <timestamp>2012-11-03T01:32:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="631">{{cpp/numeric/random/distribution/operator()|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/operator()]]
[[es:cpp/numeric/random/piecewise constant distribution/operator()]]
[[fr:cpp/numeric/random/piecewise constant distribution/operator()]]
[[it:cpp/numeric/random/piecewise constant distribution/operator()]]
[[ja:cpp/numeric/random/piecewise constant distribution/operator()]]
[[pt:cpp/numeric/random/piecewise constant distribution/operator()]]
[[ru:cpp/numeric/random/piecewise constant distribution/operator()]]
[[zh:cpp/numeric/random/piecewise constant distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/operator cmp</title>
    <ns>0</ns>
    <id>4158</id>
    <revision>
      <id>51002</id>
      <parentid>43061</parentid>
      <timestamp>2013-06-01T03:47:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="662">{{include page|cpp/numeric/random/distribution/operator_cmp|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[es:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[fr:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[it:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[ja:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[pt:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[ru:cpp/numeric/random/piecewise constant distribution/operator cmp]]
[[zh:cpp/numeric/random/piecewise constant distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4521</id>
    <revision>
      <id>51003</id>
      <parentid>43052</parentid>
      <timestamp>2013-06-01T03:47:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="707">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/piecewise constant distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/param</title>
    <ns>0</ns>
    <id>4138</id>
    <revision>
      <id>51004</id>
      <parentid>43047</parentid>
      <timestamp>2013-06-01T03:47:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/param|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/param]]
[[es:cpp/numeric/random/piecewise constant distribution/param]]
[[fr:cpp/numeric/random/piecewise constant distribution/param]]
[[it:cpp/numeric/random/piecewise constant distribution/param]]
[[ja:cpp/numeric/random/piecewise constant distribution/param]]
[[pt:cpp/numeric/random/piecewise constant distribution/param]]
[[ru:cpp/numeric/random/piecewise constant distribution/param]]
[[zh:cpp/numeric/random/piecewise constant distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/params</title>
    <ns>0</ns>
    <id>12590</id>
    <revision>
      <id>61102</id>
      <parentid>61101</parentid>
      <timestamp>2013-06-05T11:22:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplier title</comment>
      <text xml:space="preserve" bytes="681">{{cpp/numeric/random/piecewise_constant_distribution/title | intervals, densities}}
{{cpp/numeric/random/piecewise_constant_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
std::vector&lt;RealType&gt; intervals() const;
}}
{{dcl | since=c++11 | num=2 |
std::vector&lt;RealType&gt; densities() const;
}}
{{dcl end}}

Returns the distribution parameters.

@1@ Returns the list of boundaries of the intervals.

@2@ Returns the list of probability densities of the intervals.

===Parameters===
(none)

===Return value===
The distribution parameters:

@1@ The list of boundaries of the intervals.

@2@ The list of probability densities of the intervals.

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/piecewise constant distribution</title>
    <ns>0</ns>
    <id>9841</id>
    <revision>
      <id>70979</id>
      <parentid>70978</parentid>
      <timestamp>2014-06-04T18:06:15Z</timestamp>
      <contributor>
        <username>Mamos</username>
        <id>3136</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2377">{{cpp/numeric/random/piecewise_constant_distribution/title|piecewise_constant_distribution}}
{{cpp/numeric/random/piecewise_constant_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
piecewise_constant_distribution();
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class InputIt1, class InputIt2 &gt;
piecewise_constant_distribution( InputIt1 first_i, InputIt1 last_i,
                                 InputIt2 first_w );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class UnaryOperation &gt;
piecewise_constant_distribution( std::initializer_list&lt;RealType&gt; bl, 
                                 UnaryOperation fw );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class UnaryOperation &gt;
piecewise_constant_distribution( std::size_t nw, 
                                 RealType xmin, RealType xmax,
                                 UnaryOperation fw );
}}
{{dcl | num=5 | since=c++11 | 1=
explicit piecewise_constant_distribution( const param_type&amp; parm );
}}
{{dcl end}}

Constructs new piecewise constant distribution object.

@1@ Constructs a distribution object with {{math|1=n = 1}}, {{math|1=ρ0 = 1}}, {{math|1=b0 = 0}}, and {{math|1=b1 = 1}}.

@2@ Constructs a distribution object from iterators over the interval sequence {{tt|[first_i, last_i)}} and a matching weight sequence starting at {{tt|first_w}}.

@3@ Constructs a distribution object where the intervals are taken from the initializer list {{tt|bl}} and the weights generated by the function {{tt|fw}}.

@4@ Constructs a distribution object with the {{tt|nw}} intervals distributed uniformly over {{tt|[xmin, xmax]}} and the weights generated by the function {{tt|fw}}.

@5@ Constructs a distribution object initialized with the parameters {{tt|param}}.

===Parameters===
{{par begin}}
{{par | first_i | iterator initialized to the start of the interval sequence}}
{{par | last_i  | iterator initialized to one-past-the-end of the interval sequence}}
{{par | first_w | iterator initialized to the start of the density (weight) sequence}}
{{par | ilist_i | initializer_list yielding the interval sequnce}}
{{par | fw     | double(double) function yielding the densities}}
{{par | nw     | the number of densities}}
{{par | xmin   | the lower bound of the interval sequence}}
{{par | xmax   | the upper bound of the interval sequence}}
{{par | parm   | the distribution parameter set}}
{{par end}}</text>
      <sha1>rqxnqo0w55mpcpfocepk1qa5wbx5aka</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise constant distribution/reset</title>
    <ns>0</ns>
    <id>4093</id>
    <revision>
      <id>51005</id>
      <parentid>43040</parentid>
      <timestamp>2013-06-01T03:47:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/reset|piecewise_constant_distribution}}

[[de:cpp/numeric/random/piecewise constant distribution/reset]]
[[es:cpp/numeric/random/piecewise constant distribution/reset]]
[[fr:cpp/numeric/random/piecewise constant distribution/reset]]
[[it:cpp/numeric/random/piecewise constant distribution/reset]]
[[ja:cpp/numeric/random/piecewise constant distribution/reset]]
[[pt:cpp/numeric/random/piecewise constant distribution/reset]]
[[ru:cpp/numeric/random/piecewise constant distribution/reset]]
[[zh:cpp/numeric/random/piecewise constant distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution</title>
    <ns>0</ns>
    <id>3928</id>
    <revision>
      <id>67240</id>
      <parentid>63387</parentid>
      <timestamp>2014-01-29T05:19:55Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Example code corrected</comment>
      <text xml:space="preserve" bytes="3712">{{cpp/title|piecewise_linear_distribution}}
{{cpp/numeric/random/piecewise_linear_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class piecewise_linear_distribution;
}}

{{tt|std::piecewise_linear_distribution}} produces random floating-point numbers, which are distributed according to a linear probability density function within each of the several subintervals {{math|[b{{su|b=i}}, b{{su|b=i+1}})}}. The distribution is such that the probability density at each interval boundary is exactly the predefined value {{math|p{{su|b=i}}}}. 

The probability density for any {{math|b{{su|b=i}}≤x&lt;b{{su|b=i+1}}}} is {{math|{{mfrac|p{{su|b=i}}|b{{su|b=i+1}}-x|b{{su|b=i+1}}-b{{su|b=i}} }} + {{mfrac|p{{su|b=i+1}}|x-b{{su|b=i}}|b{{su|b=i+1}}-b{{su|b=i}} }} }}, where probability densities at interval boundaries {{math|p{{su|b=k}}}} are calculated as {{math|w{{su|b=k}}/S}} where {{math|S}} is the sum of all {{math|{{mfrac||1|2}}(w{{su|b=k}}+w{{su|b=k+1}})(b{{su|b=k+1}}−b{{su|b=k}})}}.

The set of interval boundaries {{math|b{{su|b=i}}}} and the set of weights at boundaries {{math|w{{su|b=i}}}} are the parameters of this distribution.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | piecewise_linear_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | piecewise_linear_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | piecewise_linear_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/piecewise_linear_distribution/dsc params}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | piecewise_linear_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | piecewise_linear_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | piecewise_linear_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | piecewise_linear_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | piecewise_linear_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    // increase the probability from 0 to 5
    // remain flat from 5 to 10
    // decrease from 10 to 15 at the same rate
    std::vector&lt;double&gt; i{0, 5, 10, 15};
    std::vector&lt;double&gt; w{0, 1,   1, 0};
    std::piecewise_linear_distribution&lt;&gt; d(i.begin(), i.end(), w.begin());

    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::setw(2) &lt;&lt; std::setfill('0') &lt;&lt; p.first &lt;&lt; ' '
            &lt;&lt; std::string(p.second/100,'*') &lt;&lt; '\n';
    }
}
 | p=true
 | output=
00 *
01 ***
02 ****
03 ******
04 *********
05 *********
06 *********
07 **********
08 *********
09 **********
10 *********
11 *******
12 ****
13 ***
14 *
}}

[[de:cpp/numeric/random/piecewise linear distribution]]
[[es:cpp/numeric/random/piecewise linear distribution]]
[[fr:cpp/numeric/random/piecewise linear distribution]]
[[it:cpp/numeric/random/piecewise linear distribution]]
[[ja:cpp/numeric/random/piecewise linear distribution]]
[[pt:cpp/numeric/random/piecewise linear distribution]]
[[ru:cpp/numeric/random/piecewise linear distribution]]
[[zh:cpp/numeric/random/piecewise linear distribution]]</text>
      <sha1>i2h219pmlg8uivj6u0mjh0kzex4rkew</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/densities</title>
    <ns>0</ns>
    <id>12593</id>
    <redirect title="cpp/numeric/random/piecewise linear distribution/params" />
    <revision>
      <id>61105</id>
      <timestamp>2013-06-05T11:26:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="69">#redirect [[cpp/numeric/random/piecewise_linear_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/intervals</title>
    <ns>0</ns>
    <id>12592</id>
    <redirect title="cpp/numeric/random/piecewise linear distribution/params" />
    <revision>
      <id>61104</id>
      <timestamp>2013-06-05T11:26:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/piecewise linear distribution/params]]</comment>
      <text xml:space="preserve" bytes="69">#redirect [[cpp/numeric/random/piecewise_linear_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/max</title>
    <ns>0</ns>
    <id>4018</id>
    <revision>
      <id>51006</id>
      <parentid>43027</parentid>
      <timestamp>2013-06-01T03:47:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="563">{{include page|cpp/numeric/random/distribution/max|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/max]]
[[es:cpp/numeric/random/piecewise linear distribution/max]]
[[fr:cpp/numeric/random/piecewise linear distribution/max]]
[[it:cpp/numeric/random/piecewise linear distribution/max]]
[[ja:cpp/numeric/random/piecewise linear distribution/max]]
[[pt:cpp/numeric/random/piecewise linear distribution/max]]
[[ru:cpp/numeric/random/piecewise linear distribution/max]]
[[zh:cpp/numeric/random/piecewise linear distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/min</title>
    <ns>0</ns>
    <id>3966</id>
    <revision>
      <id>51007</id>
      <parentid>43020</parentid>
      <timestamp>2013-06-01T03:47:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="563">{{include page|cpp/numeric/random/distribution/min|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/min]]
[[es:cpp/numeric/random/piecewise linear distribution/min]]
[[fr:cpp/numeric/random/piecewise linear distribution/min]]
[[it:cpp/numeric/random/piecewise linear distribution/min]]
[[ja:cpp/numeric/random/piecewise linear distribution/min]]
[[pt:cpp/numeric/random/piecewise linear distribution/min]]
[[ru:cpp/numeric/random/piecewise linear distribution/min]]
[[zh:cpp/numeric/random/piecewise linear distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/operator()</title>
    <ns>0</ns>
    <id>4117</id>
    <revision>
      <id>43013</id>
      <parentid>15066</parentid>
      <timestamp>2012-11-03T01:21:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="613">{{cpp/numeric/random/distribution/operator()|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/operator()]]
[[es:cpp/numeric/random/piecewise linear distribution/operator()]]
[[fr:cpp/numeric/random/piecewise linear distribution/operator()]]
[[it:cpp/numeric/random/piecewise linear distribution/operator()]]
[[ja:cpp/numeric/random/piecewise linear distribution/operator()]]
[[pt:cpp/numeric/random/piecewise linear distribution/operator()]]
[[ru:cpp/numeric/random/piecewise linear distribution/operator()]]
[[zh:cpp/numeric/random/piecewise linear distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/operator cmp</title>
    <ns>0</ns>
    <id>4159</id>
    <revision>
      <id>51008</id>
      <parentid>43006</parentid>
      <timestamp>2013-06-01T03:47:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="644">{{include page|cpp/numeric/random/distribution/operator_cmp|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[es:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[fr:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[it:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[ja:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[pt:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[ru:cpp/numeric/random/piecewise linear distribution/operator cmp]]
[[zh:cpp/numeric/random/piecewise linear distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4520</id>
    <revision>
      <id>51009</id>
      <parentid>43001</parentid>
      <timestamp>2013-06-01T03:47:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="689">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/piecewise linear distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/param</title>
    <ns>0</ns>
    <id>4134</id>
    <revision>
      <id>51010</id>
      <parentid>42992</parentid>
      <timestamp>2013-06-01T03:47:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/param|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/param]]
[[es:cpp/numeric/random/piecewise linear distribution/param]]
[[fr:cpp/numeric/random/piecewise linear distribution/param]]
[[it:cpp/numeric/random/piecewise linear distribution/param]]
[[ja:cpp/numeric/random/piecewise linear distribution/param]]
[[pt:cpp/numeric/random/piecewise linear distribution/param]]
[[ru:cpp/numeric/random/piecewise linear distribution/param]]
[[zh:cpp/numeric/random/piecewise linear distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/params</title>
    <ns>0</ns>
    <id>12591</id>
    <revision>
      <id>61103</id>
      <timestamp>2013-06-05T11:25:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="713">{{cpp/numeric/random/piecewise_linear_distribution/title | intervals, densities}}
{{cpp/numeric/random/piecewise_linear_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
std::vector&lt;RealType&gt; intervals() const;
}}
{{dcl | since=c++11 | num=2 |
std::vector&lt;RealType&gt; densities() const;
}}
{{dcl end}}

Returns the distribution parameters.

@1@ Returns the list of boundaries of the intervals.

@2@ Returns the list of probability densities at the boundaries of the intervals.

===Parameters===
(none)

===Return value===
The distribution parameters:

@1@ The list of boundaries of the intervals.

@2@ The list of probability densities at the boundaries of the intervals.

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/piecewise linear distribution</title>
    <ns>0</ns>
    <id>12775</id>
    <revision>
      <id>62903</id>
      <parentid>61767</parentid>
      <timestamp>2013-07-01T23:45:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2281">{{cpp/numeric/random/piecewise_linear_distribution/title|piecewise_linear_distribution}}
{{cpp/numeric/random/piecewise_linear_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
piecewise_linear_distribution();
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class InputIt1, class InputIt2 &gt;
piecewise_linear_distribution( InputIt1 first_i, InputIt1 last_i,
                               InputIt2 first_w );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class UnaryOperation &gt;
piecewise_linear_distribution( std::initializer_list&lt;RealType&gt; ilist, 
                               UnaryOperation fw );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class UnaryOperation &gt;
piecewise_linear_distribution( std::size_t nw, 
                               RealType xmin, RealType xmax,
                               UnaryOperation fw );
}}
{{dcl | num=5 | since=c++11 | 1=
explicit piecewise_linear_distribution( const param_type&amp; parm );
}}
{{dcl end}}

Constructs new piecewise linear distribution object.

@1@ Constructs a distribution object with ''n'' = 1, ''ρ0'' = 1, ''b0'' = 0, and ''b1'' = 1.

@2@ Constructs a distribution object from iterators over the and interval sequence {{tt|[first_i, last_i)}} and a matching weight sequence starting at {{tt|first_w}}.

@3@ Constructs a distribution object where the intervals are taken from the initializer list {{tt|ilist}} and the weights generated by the function {{tt|fw}}.

@4@ Constructs a distribution object with the {{tt|fw}} intervals distributed uniformly over {{tt|[xmin, xmax]}}

@5@ Constructs a distribution object initialized with the parameters {{tt|param}}.

===Parameters===
{{par begin}}
{{par | first_i | iterator initialized to the start of the interval sequence}}
{{par | last_i  | iterator initialized to one-past-the-end of the interval sequence}}
{{par | first_w | iterator initialized to the start of the density (weight) sequence}}
{{par | ilist_i | initializer_list yielding the interval sequence}}
{{par | fw     | double(double) function yielding the densities}}
{{par | nw     | the number of densities}}
{{par | xmin   | the lower bound of the interval sequence}}
{{par | xmax   | the upper bound of the interval sequence}}
{{par | parm   | the distribution parameter set}}
{{par end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/piecewise linear distribution/reset</title>
    <ns>0</ns>
    <id>4094</id>
    <revision>
      <id>51011</id>
      <parentid>42986</parentid>
      <timestamp>2013-06-01T03:47:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/reset|piecewise_linear_distribution}}

[[de:cpp/numeric/random/piecewise linear distribution/reset]]
[[es:cpp/numeric/random/piecewise linear distribution/reset]]
[[fr:cpp/numeric/random/piecewise linear distribution/reset]]
[[it:cpp/numeric/random/piecewise linear distribution/reset]]
[[ja:cpp/numeric/random/piecewise linear distribution/reset]]
[[pt:cpp/numeric/random/piecewise linear distribution/reset]]
[[ru:cpp/numeric/random/piecewise linear distribution/reset]]
[[zh:cpp/numeric/random/piecewise linear distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution</title>
    <ns>0</ns>
    <id>3915</id>
    <revision>
      <id>63388</id>
      <parentid>58737</parentid>
      <timestamp>2013-07-10T01:30:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2935">{{cpp/title|poisson_distribution}}
{{cpp/numeric/random/poisson_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class poisson_distribution;
}}

Produces random non-negative integer values {{math|i}}, distributed according to discrete probability function:

:{{math|P(i{{!}}μ) {{=}} {{mfrac|e{{su|p=-μ}}·μ{{su|p=i}}|i!}}}}

The value obtained is the probability of exactly {{math|i}} occurrences of a random event if the expected, ''mean'' number of its occurrence under the same conditions (on the same time/space interval) is {{math|μ}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | poisson_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | poisson_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | poisson_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/poisson_distribution/dsc mean}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | poisson_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | poisson_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | poisson_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | poisson_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | poisson_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());

    // if an event occurs 4 times a minute on average
    // how often is it that it occurs n times in one minute?
    std::poisson_distribution&lt;&gt; d(4);

    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[d(gen)];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; p.first &lt;&lt;
                ' ' &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 *
1 *******
2 **************
3 *******************
4 *******************
5 ***************
6 **********
7 *****
8 **
9 *
10 
11 
12 
13 
}}

===External links===
[http://mathworld.wolfram.com/PoissonDistribution.html Weisstein, Eric W. &quot;Poisson Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/poisson distribution]]
[[es:cpp/numeric/random/poisson distribution]]
[[fr:cpp/numeric/random/poisson distribution]]
[[it:cpp/numeric/random/poisson distribution]]
[[ja:cpp/numeric/random/poisson distribution]]
[[pt:cpp/numeric/random/poisson distribution]]
[[ru:cpp/numeric/random/poisson distribution]]
[[zh:cpp/numeric/random/poisson distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/max</title>
    <ns>0</ns>
    <id>4006</id>
    <revision>
      <id>51012</id>
      <parentid>42975</parentid>
      <timestamp>2013-06-01T03:47:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/max|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/max]]
[[es:cpp/numeric/random/poisson distribution/max]]
[[fr:cpp/numeric/random/poisson distribution/max]]
[[it:cpp/numeric/random/poisson distribution/max]]
[[ja:cpp/numeric/random/poisson distribution/max]]
[[pt:cpp/numeric/random/poisson distribution/max]]
[[ru:cpp/numeric/random/poisson distribution/max]]
[[zh:cpp/numeric/random/poisson distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/mean</title>
    <ns>0</ns>
    <id>5151</id>
    <revision>
      <id>63389</id>
      <parentid>61261</parentid>
      <timestamp>2013-07-10T01:30:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="980">{{cpp/numeric/random/poisson_distribution/title|mean}}
{{cpp/numeric/random/poisson_distribution/navbar}}
{{ddcl | since=c++11 | 1=
double mean() const;
}}

Returns the {{math|μ}} parameter the distribution was constructed with. The parameter defines mean number of occurrences of the event. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
Floating point value identifying the {{math|μ}} distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | poisson_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/poisson distribution/mean]]
[[es:cpp/numeric/random/poisson distribution/mean]]
[[fr:cpp/numeric/random/poisson distribution/mean]]
[[it:cpp/numeric/random/poisson distribution/mean]]
[[ja:cpp/numeric/random/poisson distribution/mean]]
[[pt:cpp/numeric/random/poisson distribution/mean]]
[[ru:cpp/numeric/random/poisson distribution/mean]]
[[zh:cpp/numeric/random/poisson distribution/mean]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/min</title>
    <ns>0</ns>
    <id>3978</id>
    <revision>
      <id>51013</id>
      <parentid>42960</parentid>
      <timestamp>2013-06-01T03:47:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/min|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/min]]
[[es:cpp/numeric/random/poisson distribution/min]]
[[fr:cpp/numeric/random/poisson distribution/min]]
[[it:cpp/numeric/random/poisson distribution/min]]
[[ja:cpp/numeric/random/poisson distribution/min]]
[[pt:cpp/numeric/random/poisson distribution/min]]
[[ru:cpp/numeric/random/poisson distribution/min]]
[[zh:cpp/numeric/random/poisson distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/operator()</title>
    <ns>0</ns>
    <id>4104</id>
    <revision>
      <id>42953</id>
      <parentid>15053</parentid>
      <timestamp>2012-11-03T01:08:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="532">{{cpp/numeric/random/distribution/operator()|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/operator()]]
[[es:cpp/numeric/random/poisson distribution/operator()]]
[[fr:cpp/numeric/random/poisson distribution/operator()]]
[[it:cpp/numeric/random/poisson distribution/operator()]]
[[ja:cpp/numeric/random/poisson distribution/operator()]]
[[pt:cpp/numeric/random/poisson distribution/operator()]]
[[ru:cpp/numeric/random/poisson distribution/operator()]]
[[zh:cpp/numeric/random/poisson distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/operator cmp</title>
    <ns>0</ns>
    <id>4146</id>
    <revision>
      <id>51014</id>
      <parentid>42945</parentid>
      <timestamp>2013-06-01T03:47:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="563">{{include page|cpp/numeric/random/distribution/operator_cmp|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/operator cmp]]
[[es:cpp/numeric/random/poisson distribution/operator cmp]]
[[fr:cpp/numeric/random/poisson distribution/operator cmp]]
[[it:cpp/numeric/random/poisson distribution/operator cmp]]
[[ja:cpp/numeric/random/poisson distribution/operator cmp]]
[[pt:cpp/numeric/random/poisson distribution/operator cmp]]
[[ru:cpp/numeric/random/poisson distribution/operator cmp]]
[[zh:cpp/numeric/random/poisson distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4533</id>
    <revision>
      <id>51015</id>
      <parentid>42941</parentid>
      <timestamp>2013-06-01T03:48:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="608">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/poisson distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/poisson distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/param</title>
    <ns>0</ns>
    <id>4126</id>
    <revision>
      <id>51016</id>
      <parentid>42933</parentid>
      <timestamp>2013-06-01T03:48:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/param|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/param]]
[[es:cpp/numeric/random/poisson distribution/param]]
[[fr:cpp/numeric/random/poisson distribution/param]]
[[it:cpp/numeric/random/poisson distribution/param]]
[[ja:cpp/numeric/random/poisson distribution/param]]
[[pt:cpp/numeric/random/poisson distribution/param]]
[[ru:cpp/numeric/random/poisson distribution/param]]
[[zh:cpp/numeric/random/poisson distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/poisson distribution</title>
    <ns>0</ns>
    <id>4923</id>
    <revision>
      <id>62904</id>
      <parentid>50387</parentid>
      <timestamp>2013-07-01T23:45:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1271">{{cpp/numeric/random/poisson_distribution/title|poisson_distribution}}
{{cpp/numeric/random/poisson_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit poisson_distribution( double mean = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit poisson_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|mean}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | mean | the ''μ'' distribution parameter (the mean of the distribution)}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|0 &lt; mean}}.

[[de:cpp/numeric/random/poisson distribution/poisson distribution]]
[[es:cpp/numeric/random/poisson distribution/poisson distribution]]
[[fr:cpp/numeric/random/poisson distribution/poisson distribution]]
[[it:cpp/numeric/random/poisson distribution/poisson distribution]]
[[ja:cpp/numeric/random/poisson distribution/poisson distribution]]
[[pt:cpp/numeric/random/poisson distribution/poisson distribution]]
[[ru:cpp/numeric/random/poisson distribution/poisson distribution]]
[[zh:cpp/numeric/random/poisson distribution/poisson distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/poisson distribution/reset</title>
    <ns>0</ns>
    <id>4081</id>
    <revision>
      <id>51017</id>
      <parentid>42920</parentid>
      <timestamp>2013-06-01T03:48:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/reset|poisson_distribution}}

[[de:cpp/numeric/random/poisson distribution/reset]]
[[es:cpp/numeric/random/poisson distribution/reset]]
[[fr:cpp/numeric/random/poisson distribution/reset]]
[[it:cpp/numeric/random/poisson distribution/reset]]
[[ja:cpp/numeric/random/poisson distribution/reset]]
[[pt:cpp/numeric/random/poisson distribution/reset]]
[[ru:cpp/numeric/random/poisson distribution/reset]]
[[zh:cpp/numeric/random/poisson distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/rand</title>
    <ns>0</ns>
    <id>2033</id>
    <revision>
      <id>71061</id>
      <parentid>69388</parentid>
      <timestamp>2014-06-05T01:36:50Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to RAND_MAX</comment>
      <text xml:space="preserve" bytes="2277">{{cpp/title|rand}}
{{cpp/numeric/random/navbar}}
{{ddcl | header=cstdlib | 
int rand();
}}

Returns a pseudo-random integral value between {{c|0}} and {{lc|RAND_MAX}} (0 and {{tt|RAND_MAX}} included).

{{lc|std::srand()}} seeds the pseudo-random number generator used by {{tt|rand()}}.
If {{tt|rand()}} is used before any calls to {{tt|srand()}}, {{tt|rand()}} behaves as if it was seeded with {{tt|srand(1)}}.

Each time {{tt|rand()}} is seeded with {{tt|srand()}}, it must produce the same sequence of values on successive calls. Other functions in the standard library may call {{tt|rand}}, it is implementation-defined which functions do so.

It is implementation-defined whether {{tt|rand()}} is thread-safe.

===Parameters===
(none)

===Return value===
Pseudo-random integral value between {{c|0}} and {{lc|RAND_MAX}}.

===Notes===
There are no guarantees as to the quality of the random sequence produced.
In the past, some implementations of {{tt|rand()}} have had serious shortcomings in the randomness, distribution and period of the sequence produced (in one well-known example, the low-order bit simply alternated between {{tt|1}} and {{tt|0}} between calls).

{{tt|rand()}} is not recommended for serious random-number generation needs, like cryptography.
{{rev inl|since=c++11|It is recommended to use C++11's [[cpp/numeric/random|random number generation]] facilities to replace rand().}}
===Example===
{{example
 | p=true
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
#include &lt;ctime&gt;

int main() 
{
    std::srand(std::time(0)); // use current time as seed for random generator
    int random_variable = std::rand();
    std::cout &lt;&lt; &quot;Random value on [0 &quot; &lt;&lt; RAND_MAX &lt;&lt; &quot;]: &quot; 
              &lt;&lt; random_variable &lt;&lt; '\n';
}
 | output=
Random value on [0 2147483647]: 1373858591
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/dsc srand}}
{{dsc inc | cpp/numeric/random/dsc RAND_MAX}}
{{dsc see c | c/numeric/random/rand}}
{{dsc end}}

[[de:cpp/numeric/random/rand]]
[[es:cpp/numeric/random/rand]]
[[fr:cpp/numeric/random/rand]]
[[it:cpp/numeric/random/rand]]
[[ja:cpp/numeric/random/rand]]
[[pt:cpp/numeric/random/rand]]
[[ru:cpp/numeric/random/rand]]
[[zh:cpp/numeric/random/rand]]</text>
      <sha1>ssj340xb89l67q48urjxnmcu93nbov9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device</title>
    <ns>0</ns>
    <id>4974</id>
    <revision>
      <id>67783</id>
      <parentid>67782</parentid>
      <timestamp>2014-02-27T16:08:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>I think I know what the editor was getting at...</comment>
      <text xml:space="preserve" bytes="2504">{{cpp/title|random_device}}
{{cpp/numeric/random/random_device/navbar}}
{{ddcl | header=random | since=c++11 | 1=
class random_device;
}}

{{tt|std::random_device}} is a uniformly-distributed integer random number generator that produces non-deterministic random numbers.

Note that {{tt|std::random_device}} may be implemented in terms of a pseudo-random number engine if a non-deterministic source (e.g. a hardware device) is not available to the implementation.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|unsigned int}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h2 | Construction}}
{{dsc inc | cpp/numeric/random/engine/dsc constructor |random_device}}
{{dsc mem fun | nolink=true | operator{{=}} | notes={{mark|deleted}} | the assignment operator is deleted}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() | random_device}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/random_device/dsc entropy}}
{{dsc inc | cpp/numeric/random/engine/dsc min |random_device}}
{{dsc inc | cpp/numeric/random/engine/dsc max |random_device}}
{{dsc end}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::map&lt;int, int&gt; hist;
    std::uniform_int_distribution&lt;int&gt; dist(0, 9);
    for (int n = 0; n &lt; 20000; ++n) {
        ++hist[dist(rd)]; // note: demo only: the performance of many 
                          // implementations of random_device degrades sharply
                          // once the entropy pool is exhausted. For practical use
                          // random_device is generally only used to seed 
                          // a PRNG such as mt19937
    }
    for (auto p : hist) {
        std::cout &lt;&lt; p.first &lt;&lt; &quot; : &quot; &lt;&lt; std::string(p.second/100, '*') &lt;&lt; '\n';
    }
}
 | output=
0 : ********************
1 : *******************
2 : ********************
3 : ********************
4 : ********************
5 : *******************
6 : ********************
7 : ********************
8 : *******************
9 : ********************
}}

[[de:cpp/numeric/random/random device]]
[[es:cpp/numeric/random/random device]]
[[fr:cpp/numeric/random/random device]]
[[it:cpp/numeric/random/random device]]
[[ja:cpp/numeric/random/random device]]
[[pt:cpp/numeric/random/random device]]
[[ru:cpp/numeric/random/random device]]
[[zh:cpp/numeric/random/random device]]</text>
      <sha1>1xff9fcmhgqk1gopjmqz0gitb5b0h5r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device/entropy</title>
    <ns>0</ns>
    <id>9613</id>
    <revision>
      <id>68015</id>
      <parentid>62905</parentid>
      <timestamp>2014-03-13T08:57:29Z</timestamp>
      <contributor>
        <ip>81.14.208.18</ip>
      </contributor>
      <text xml:space="preserve" bytes="1226">{{cpp/numeric/random/random_device/title|entropy}}
{{cpp/numeric/random/random_device/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
double entropy() const;
}}
{{dcl end}}

Obtains an estimate of the random number device entropy, which is a floating-point value between {{math|min()}} and {{math|log{{su|b=2}}(max()+1)}}. If the device has {{math|n}} states whose individual probabilities are {{math|P{{su|b=0}},...,P{{su|b=n-1}}}}, the device probability {{math|S}} is defined as

{{math|S {{=}} -Σ{{su|b=i{{=}}0|p=n-1}}P{{su|b=i}}log(P{{su|b=i}})}}

A deterministic random number generator (e.g. a pseudo-random engine) has entropy zero.

===Exceptions===
{{noexcept}}

===Return value===
The value of the device entropy, or zero if not applicable.

===Notes===
This function is not fully implemented in some standard libraries. For example, gcc and clang always return zero even though the device is non-deterministic. In comparison, Visual C++ always returns 32, and boost.random returns 10.

===Example===
{{example
 | Example output on one of the implementations
 | code=
#include &lt;iostream&gt;
#include &lt;random&gt;

int main()
{
    std::random_device rd;
    std::cout &lt;&lt; rd.entropy() &lt;&lt; '\n';
}
 | p=true
 | output=
32
}}</text>
      <sha1>pd47ukkumjvfbetsrckn89mj0z5sf0z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device/max</title>
    <ns>0</ns>
    <id>4980</id>
    <revision>
      <id>51018</id>
      <parentid>42898</parentid>
      <timestamp>2013-06-01T03:48:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="413">{{include page|cpp/numeric/random/engine/max|random_device}}

[[de:cpp/numeric/random/random device/max]]
[[es:cpp/numeric/random/random device/max]]
[[fr:cpp/numeric/random/random device/max]]
[[it:cpp/numeric/random/random device/max]]
[[ja:cpp/numeric/random/random device/max]]
[[pt:cpp/numeric/random/random device/max]]
[[ru:cpp/numeric/random/random device/max]]
[[zh:cpp/numeric/random/random device/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device/min</title>
    <ns>0</ns>
    <id>4978</id>
    <revision>
      <id>51019</id>
      <parentid>42891</parentid>
      <timestamp>2013-06-01T03:48:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="413">{{include page|cpp/numeric/random/engine/min|random_device}}

[[de:cpp/numeric/random/random device/min]]
[[es:cpp/numeric/random/random device/min]]
[[fr:cpp/numeric/random/random device/min]]
[[it:cpp/numeric/random/random device/min]]
[[ja:cpp/numeric/random/random device/min]]
[[pt:cpp/numeric/random/random device/min]]
[[ru:cpp/numeric/random/random device/min]]
[[zh:cpp/numeric/random/random device/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device/operator()</title>
    <ns>0</ns>
    <id>9879</id>
    <revision>
      <id>63391</id>
      <parentid>58745</parentid>
      <timestamp>2013-07-10T01:30:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="641">{{cpp/numeric/random/random_device/title|operator()}}
{{cpp/numeric/random/random_device/navbar}}
{{ddcl | since=c++11 | 1=
result_type operator()();
}}

Generates a non-deterministic uniformly-distributed random value. 

===Parameters===
(none)

===Return value===
A random number uniformly distributed in [{{c|min()}}, {{c|max()}}].

===Exceptions===
Throws an implementation-defined exception derived from {{lc|std::exception}} if a random number could not be generated.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc min |random_device}}
{{dsc inc | cpp/numeric/random/engine/dsc max |random_device}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/random device/random device</title>
    <ns>0</ns>
    <id>6321</id>
    <revision>
      <id>67759</id>
      <parentid>62906</parentid>
      <timestamp>2014-02-26T11:26:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>move implementation-defined behavior down to Notes and expand</comment>
      <text xml:space="preserve" bytes="2144">{{cpp/numeric/random/random_device/title|random_device}}
{{cpp/numeric/random/random_device/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit random_device(const std::string&amp; token = /*implementation-defined*/ );
}}
{{dcl | num=2 | since=c++11 | 1=
random_device(const random_device&amp; ) = delete;
}}
{{dcl end}}

@1@ Constructs a new {{lc|std::random_device}} object, making use of the argument {{tt|token}}, if provided, in implementation-defined manner. 
@2@ The copy constructor is deleted: {{tt|std::random_device}} is not copyable.

===Exceptions===
Throws an implementation-defined exceptions derived from {{lc|std::exception}} on failure.

===Notes===
The implementations in [http://llvm.org/svn/llvm-project/libcxx/trunk/src/random.cpp libc++] and [http://gcc.gnu.org/viewcvs/gcc/trunk/libstdc%2B%2B-v3/src/c%2B%2B11/random.cc?view=markup#l77 libstdc++] expect {{tt|token}} to be the name of a character device that produces random numbers when read from, with the default value {{c|&quot;/dev/urandom&quot;}}, although where the CPU command RDRND is available, libstdc++ uses that as the default.

===Example===
{{example
 | Demonstrates the two commonly available types of {{tt|std::random_device}} on Linux
 | code=
#include &lt;iostream&gt;
#include &lt;random&gt;

int main()
{

    std::uniform_int_distribution&lt;int&gt; d(0, 10);

    std::random_device rd1; // uses RDRND or /dev/urandom
    for(int n = 0; n &lt; 10; ++n)
        std::cout &lt;&lt; d(rd1) &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    std::random_device rd2(&quot;/dev/random&quot;); // much slower on Linux
    for(int n = 0; n &lt; 10; ++n)
        std::cout &lt;&lt; d(rd2) &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | p=true
 | output=
7 10 7 0 4 4 6 9 4 7 
2 4 10 6 3 2 0 6 3 7 
}}

[[de:cpp/numeric/random/random device/random device]]
[[es:cpp/numeric/random/random device/random device]]
[[fr:cpp/numeric/random/random device/random device]]
[[it:cpp/numeric/random/random device/random device]]
[[ja:cpp/numeric/random/random device/random device]]
[[pt:cpp/numeric/random/random device/random device]]
[[ru:cpp/numeric/random/random device/random device]]
[[zh:cpp/numeric/random/random device/random device]]</text>
      <sha1>5ykk72a2457euucpvgtte2nfsbaumkg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/seed seq</title>
    <ns>0</ns>
    <id>5144</id>
    <revision>
      <id>63782</id>
      <parentid>63762</parentid>
      <timestamp>2013-07-24T22:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Partial undo: we don't use tabs</comment>
      <text xml:space="preserve" bytes="2125">{{cpp/title|seed_seq}}
{{cpp/numeric/random/seed_seq/navbar}}
{{ddcl | header=random | since=c++11 | 1=
class seed_seq;
}}

{{tt|std::seed_seq}} consumes a sequence of integer-valued data and produces a requested number of unsigned integer values {{tt|i}}, {{math|0 ≤ i &lt; 2{{su|p=32}}}}, based on the consumed data. The produced values are distributed over the entire 32-bit range even if the consumed values are close.

It provides a way to seed a large number of random number engines or to seed a generator that requires a lot of entropy, given a small seed or a poorly distributed initial seed sequence.

{{tt|std::seed_seq}} meets the requirements of {{concept|SeedSequence}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{lc|std::uint_least32_t}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/numeric/random/seed_seq/seed_seq | constructs and seeds the std::seed_seq object}}
{{dsc mem fun | nolink=true | operator{{=}} | not copy-assignable | notes={{mark|deleted}}}}
{{dsc mem fun | cpp/numeric/random/seed_seq/generate | calculates the bias-eliminated, evenly distributed 32-bit values}}
{{dsc mem fun | cpp/numeric/random/seed_seq/size | obtains the number of 32-bit values stored in std::seed_seq }}
{{dsc mem fun | cpp/numeric/random/seed_seq/param | obtains the 32-bit values stored in std::seed_seq}}
{{dsc end}}

===Example===

{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;cstdint&gt;
#include &lt;iostream&gt;

int main()
{
    std::seed_seq seq{1,2,3,4,5};
    std::vector&lt;std::uint32_t&gt; seeds(10);
    seq.generate(seeds.begin(), seeds.end());
    for (std::uint32_t n : seeds) {
        std::cout &lt;&lt; n &lt;&lt; '\n';
    }
}
 | output=
4204997637
4246533866
1856049002
1129615051
690460811
1075771511
46783058
3904109078
1534123438
1495905678 
}}

[[de:cpp/numeric/random/seed seq]]
[[es:cpp/numeric/random/seed seq]]
[[fr:cpp/numeric/random/seed seq]]
[[it:cpp/numeric/random/seed seq]]
[[ja:cpp/numeric/random/seed seq]]
[[pt:cpp/numeric/random/seed seq]]
[[ru:cpp/numeric/random/seed seq]]
[[zh:cpp/numeric/random/seed seq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/seed seq/generate</title>
    <ns>0</ns>
    <id>8938</id>
    <revision>
      <id>66201</id>
      <parentid>62907</parentid>
      <timestamp>2013-11-09T22:17:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 (exceptions)</comment>
      <text xml:space="preserve" bytes="5079">{{cpp/numeric/random/seed_seq/title | generate}}
{{cpp/numeric/random/seed_seq/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class RandomIt &gt;
void generate( RandomIt begin, RandomIt end );
}}
{{dcl end}}

Fills the range {{c|[begin, end)}} with unsigned integer values {{tt|i}}, {{math|0 ≤ i &lt; 2{{su|p=32}}}}, based on the data originally provided in the constructor of this {{tt|seed_seq}}. The produced values are distributed over the entire 32-bit range even if the initial values were strongly biased.

The following algorithm is used (adapted from the initialization sequence of the Mersenne Twister generator by [http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html Makoto Matsumoto and Takuji Nishimura], incorporating the improvements made by [http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/SFMT/M062821.pdf Mutsuo Saito in 2007])

* If {{c|1=begin == end}}, do nothing. Otherwise,

* First, set each element of the output range to the value {{c|0x8b8b8b8b}}

* Transform the elements of the output range according to the following algorithm:

For {{c|1=k = 0,..., m-1}}&lt;br&gt;

where {{c|1=m=max(s+1, n)}}&lt;br&gt;
and {{c|1=n=end-begin}}&lt;br&gt;
and {{c|1=s=v.size()}}&lt;br&gt;
and {{c|v}} is the private container holding the values originally provided by the constructor of this {{tt|seed_seq}} object,
# {{c|1=begin[k+p] += r1}}
# {{c|1=begin[k+q] += r2}}
# {{c|1=begin[k] = r2}},
where {{c|1=p=(n-t)/2}}&lt;br&gt;
and {{c|1=q=p+t}}&lt;br&gt;
and {{c|1=t=(n &gt;= 623) ? 11 : (n &gt;= 68) ? 7 : (n &gt;= 39) ? 5 : (n &gt;= 7) ? 3 : (n - 1) / 2 }}&lt;br&gt;
and {{c|1=r1=1664525 * T(begin[k]^begin[k+p]^begin[k−1])}}&lt;br&gt;
and {{c|1=T(x) = x ^ (x &gt;&gt; 27)}}&lt;br&gt;
and {{c|1=r2=r1+s}} if {{c|1=k==0}}, {{c|1=r2=r1 + k%n + v[k-1]}} if {{c|1=0&lt;k&lt;=s}}, {{c|1=r2=r1 + k%n}} if {{c|1=k&gt;s}}.

For {{c|1=k = m,..., m+n-1}}, 
# {{c|1=begin[k+p] ^= r3}}
# {{c|1=begin[k+q] ^= r4}}
# {{c|1=begin[k]=r4}}
where {{c|1=r3 = 1566083941 * T(begin[k]+begin[k+p]+begin[k-1])}}&lt;br&gt;
and {{c|1=r4=r3 - k%n}}

where all calculations are performed {{math|modulo 2{{su|p=32}}}} and where the indexing of the output range ({{c|begin[x]}}) is taken {{math|modulo n}}.

===Parameters===
{{par begin}}
{{par | begin, end | mutable random-access iterators whose {{c|std::iterator_traits&lt;&gt;::value_type}} is an unsigned integer type suitable for storing 32-bit values}}
{{par hreq}}
{{par req concept | RandomIt | RandomAccessIterator}}
{{par end}}

===Return value===
none, the results are written to the {{c|[begin, end)}} range.

===Exceptions===
Only throws if the operations on {{tt|begin}} and {{tt|end}} throw.

===Example===

{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;

int main()
{
    std::seed_seq seq({1,2,3,4,5});
    std::vector&lt;std::uint32_t&gt; seeds(10);
    seq.generate(seeds.begin(), seeds.end());
// Step 1: fill with 0x8b8b8b8b
// seeds = {2341178251, 2341178251, 2341178251, 2341178251, 2341178251,
//          2341178251, 2341178251, 2341178251, 2341178251, 2341178251 }
//
// Step 2: 
// n = 10, s = 5, t = 3, p = 3, q = 6, m = 10
//
// First iteration, k = 0; r1 = 1371501266, r2 = 1371501271
//
// seeds = {1371501271, 2341178251, 2341178251, 3712679517, 2341178251,
//          2341178251, 3712679522, 2341178251, 2341178251, 2341178251 }
//
// Iterations from k = 1 to k = 5 (r2 = r1 + k%n + v[k-1])
//
// r1 = 2786190137, 3204727651, 4173325571, 1979226628, 401983366
// r2 = 2786190139, 3204727655, 4173325577, 1979226636, 401983376
//
// seeds = {3350727907, 3188173515, 3204727655, 4173325577, 1979226636,
//           401983376, 3591037797, 2811627722, 1652921976, 2219536532 } 
//
// Iterations from k = 6 to k = 9 (r2 = r1 + k%n)
//
// r1 = 2718637909, 1378394210, 2297813071, 1608643617
// r2 = 2718637915, 1378394217, 2297813079, 1608643626
//
// seeds = { 434154821, 1191019290, 3237041891, 1256752498, 4277039715,
//          2010627002, 2718637915, 1378394217, 2297813079, 1608643626 } 
//
// Step 3
// iterations from k = 10 to k = 19, using ^= to modify the output
//
// r1 = 1615303485, 3210438310, 893477041, 2884072672, 1918321961,
// r2 = 1615303485, 3210438309, 893477039, 2884072669, 1918321957
//
// seeds = { 303093272, 3210438309,  893477039, 2884072669, 1918321957,
//          1117182731, 1772877958, 2669970405, 3182737656, 4094066935 }
//
// r1 =  423054846, 46783064, 3904109085, 1534123446, 1495905687
// r2 =  423054841, 46783058, 3904109078, 1534123438, 1495905678
//
// seeds = { 4204997637, 4246533866, 1856049002, 1129615051, 690460811,
//           1075771511,   46783058, 3904109078, 1534123438, 1495905678 }

    for(std::uint32_t n : seeds)
        std::cout &lt;&lt; n &lt;&lt; '\n';
}
 | output=
4204997637
4246533866
1856049002
1129615051
690460811
1075771511
46783058
3904109078
1534123438
1495905678 
}}

[[de:cpp/numeric/random/seed seq/generate]]
[[es:cpp/numeric/random/seed seq/generate]]
[[fr:cpp/numeric/random/seed seq/generate]]
[[it:cpp/numeric/random/seed seq/generate]]
[[ja:cpp/numeric/random/seed seq/generate]]
[[pt:cpp/numeric/random/seed seq/generate]]
[[ru:cpp/numeric/random/seed seq/generate]]
[[zh:cpp/numeric/random/seed seq/generate]]</text>
      <sha1>nzxv2xcl2jcs0r9bd4qziwc3rw4x3aq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/seed seq/param</title>
    <ns>0</ns>
    <id>8941</id>
    <revision>
      <id>66203</id>
      <parentid>62908</parentid>
      <timestamp>2013-11-09T22:18:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 (exceptions)</comment>
      <text xml:space="preserve" bytes="1167">{{cpp/numeric/random/seed_seq/title | param}}
{{cpp/numeric/random/seed_seq/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class OutputIt &gt;
void param( OutputIt dest ) const;
}}
{{dcl end}}

Outputs the initial seed sequence that's stored in the {{tt|std::seed_seq}} object.

===Parameters===
{{par begin}}
{{par | dest | output iterator such that the expression {{c|1=*dest=rt}} is valid for a value {{tt|rt}} of {{tt|result_type}}}}
{{par hreq}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
(none)

===Exceptions===
Throws only if an operation on {{tt|dest}} throws.

===Example===
{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
int main()
{
    std::seed_seq s1 = {-1, 0, 1};
    s1.param(std::ostream_iterator&lt;int&gt;(std::cout, &quot; &quot;));
}
 | output=
-1 0 1
}}

[[de:cpp/numeric/random/seed seq/param]]
[[es:cpp/numeric/random/seed seq/param]]
[[fr:cpp/numeric/random/seed seq/param]]
[[it:cpp/numeric/random/seed seq/param]]
[[ja:cpp/numeric/random/seed seq/param]]
[[pt:cpp/numeric/random/seed seq/param]]
[[ru:cpp/numeric/random/seed seq/param]]
[[zh:cpp/numeric/random/seed seq/param]]</text>
      <sha1>g13y0moy8f8k7jumtymzif82vpd5n1x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/seed seq/seed seq</title>
    <ns>0</ns>
    <id>8940</id>
    <revision>
      <id>66200</id>
      <parentid>62909</parentid>
      <timestamp>2013-11-09T22:16:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 (exceptions)</comment>
      <text xml:space="preserve" bytes="2335">{{cpp/numeric/random/seed_seq/title | seed_seq}}
{{cpp/numeric/random/seed_seq/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
seed_seq();
}}
{{dcl | num=2 | since=c++11 | 1=
seed_seq( const seed_seq&amp; ) = delete;
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class InputIt &gt;
seed_seq( InputIt begin, InputIt end );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class T &gt;
seed_seq( std::initializer_list&lt;T&gt; il );
}}
{{dcl end}}

@1@ The default constructor creates a {{tt|std::seed_seq}} object with an initial seed sequence of length zero.
@2@ The copy constructor is deleted: {{tt|std::seed_seq}} is not copyable.
@3@ Constructs a {{tt|std::seed_seq}} with the initial seed sequence obtained by iterating over the range {{tt|[begin, end)}} and copying the values obtained by dereferencing the iterator, {{math|modulo 2{{su|p=32}}}} (that is, the lower 32 bits are copied)
@4@ Equivalent to {{c|seed_seq(il.begin(), il.end())}}. This constructor enables [[cpp/language/list_initialization|list-initialization]].

===Parameters===
{{par begin}}
{{par | begin, end | the initial seed sequence represented as a pair of input iterators whose {{c|std::iterator_traits&lt;&gt;::value_type}} is an integer type}}
{{par | il | {{lc|std::initializer_list}} of objects of integer type, providing the iniial seed sequence}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Exceptions===
@1@ Does not throw

===Example===
{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;sstream&gt;
#include &lt;iterator&gt;
int main()
{
    std::seed_seq s1; // default-constructible
    std::seed_seq s2{1, 2, 3}; // can use list-initialization
    std::seed_seq s3 = {-1, 0, 1}; // another form of list-initialization
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::seed_seq s4(a, a + 10); // can use iterators
    std::istringstream buf(&quot;1 2 3 4 5&quot;); 
    std::istream_iterator&lt;int&gt; beg(buf), end;
    std::seed_seq s5(beg, end); // even stream input iterators
}
 | output=
}}

[[de:cpp/numeric/random/seed seq/seed seq]]
[[es:cpp/numeric/random/seed seq/seed seq]]
[[fr:cpp/numeric/random/seed seq/seed seq]]
[[it:cpp/numeric/random/seed seq/seed seq]]
[[ja:cpp/numeric/random/seed seq/seed seq]]
[[pt:cpp/numeric/random/seed seq/seed seq]]
[[ru:cpp/numeric/random/seed seq/seed seq]]
[[zh:cpp/numeric/random/seed seq/seed seq]]</text>
      <sha1>nb4klruzuhgn2o4aljyp3p5wxlojvh7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/seed seq/size</title>
    <ns>0</ns>
    <id>8942</id>
    <revision>
      <id>66202</id>
      <parentid>62910</parentid>
      <timestamp>2013-11-09T22:17:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C++14 (exceptions)</comment>
      <text xml:space="preserve" bytes="901">{{cpp/numeric/random/seed_seq/title | size}}
{{cpp/numeric/random/seed_seq/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
std::size_t size() const
}}
{{dcl end}}

Returns the size of the stored initial seed sequence.

===Parameters===
(none)

===Return value===
The size of the private container that was populated at construction time.

===Complexity===
Constant time.

===Exeptions===
Does not throw

===Example===

{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;
int main()
{
    std::seed_seq s1 = {-1, 0, 1};
    std::cout &lt;&lt; s1.size() &lt;&lt; '\n';
}
 | output=
3
}}

[[de:cpp/numeric/random/seed seq/size]]
[[es:cpp/numeric/random/seed seq/size]]
[[fr:cpp/numeric/random/seed seq/size]]
[[it:cpp/numeric/random/seed seq/size]]
[[ja:cpp/numeric/random/seed seq/size]]
[[pt:cpp/numeric/random/seed seq/size]]
[[ru:cpp/numeric/random/seed seq/size]]
[[zh:cpp/numeric/random/seed seq/size]]</text>
      <sha1>13304mgj1b5ewxg4qkmm7vgrgdmd1nn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine</title>
    <ns>0</ns>
    <id>3703</id>
    <revision>
      <id>63198</id>
      <parentid>63197</parentid>
      <timestamp>2013-07-05T16:03:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>grammar</comment>
      <text xml:space="preserve" bytes="2542">{{cpp/title|shuffle_order_engine}}
{{cpp/numeric/random/shuffle_order_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 | 
template&lt;
    class Engine, 
    std::size_t K
&gt; class shuffle_order_engine;
}}
{{dcl end}}

{{tt|shuffle_order_engine}} is a random number engine adaptor that shuffles the random numbers generated by the base engine. It maintains a table of size {{tt|K}} and delivers a randomly selected number from that table when requested, replacing it with a number generated by the base engine.

The following typedef defines the random number engine with one commonly used parameter set:
{{dsc begin}}
{{dsc header | random}}
{{dsc hitem | Type | Definition}}
{{dsc inc | cpp/numeric/random/dsc knuth_b}}
{{dsc end}}

===Template parameters===
{{par begin}}
{{par | Engine | the type of the wrapped engine }}
{{par | K | the size of the internal table. Must be greater than {{math|0}} }}
{{par hreq}}
{{par req concept | Engine | RandomNumberEngine}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|typename Engine::result_type}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc constructor |shuffle_order_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc seed |shuffle_order_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc base |shuffle_order_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator() |shuffle_order_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc discard |shuffle_order_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/adaptor/dsc min |shuffle_order_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc max |shuffle_order_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_cmp |shuffle_order_engine}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator_ltltgtgt |shuffle_order_engine}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} table_size | the size of the internal table, {{tt|K}} }}
{{dsc end}}

[[de:cpp/numeric/random/shuffle order engine]]
[[es:cpp/numeric/random/shuffle order engine]]
[[fr:cpp/numeric/random/shuffle order engine]]
[[it:cpp/numeric/random/shuffle order engine]]
[[ja:cpp/numeric/random/shuffle order engine]]
[[pt:cpp/numeric/random/shuffle order engine]]
[[ru:cpp/numeric/random/shuffle order engine]]
[[zh:cpp/numeric/random/shuffle order engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/base</title>
    <ns>0</ns>
    <id>8804</id>
    <revision>
      <id>51020</id>
      <parentid>42832</parentid>
      <timestamp>2013-06-01T03:48:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="486">{{include page|cpp/numeric/random/adaptor/base|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/base]]
[[es:cpp/numeric/random/shuffle order engine/base]]
[[fr:cpp/numeric/random/shuffle order engine/base]]
[[it:cpp/numeric/random/shuffle order engine/base]]
[[ja:cpp/numeric/random/shuffle order engine/base]]
[[pt:cpp/numeric/random/shuffle order engine/base]]
[[ru:cpp/numeric/random/shuffle order engine/base]]
[[zh:cpp/numeric/random/shuffle order engine/base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/discard</title>
    <ns>0</ns>
    <id>8806</id>
    <revision>
      <id>51021</id>
      <parentid>42824</parentid>
      <timestamp>2013-06-01T03:48:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="513">{{include page|cpp/numeric/random/adaptor/discard|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/discard]]
[[es:cpp/numeric/random/shuffle order engine/discard]]
[[fr:cpp/numeric/random/shuffle order engine/discard]]
[[it:cpp/numeric/random/shuffle order engine/discard]]
[[ja:cpp/numeric/random/shuffle order engine/discard]]
[[pt:cpp/numeric/random/shuffle order engine/discard]]
[[ru:cpp/numeric/random/shuffle order engine/discard]]
[[zh:cpp/numeric/random/shuffle order engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/max</title>
    <ns>0</ns>
    <id>8808</id>
    <revision>
      <id>51022</id>
      <parentid>42818</parentid>
      <timestamp>2013-06-01T03:48:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="477">{{include page|cpp/numeric/random/adaptor/max|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/max]]
[[es:cpp/numeric/random/shuffle order engine/max]]
[[fr:cpp/numeric/random/shuffle order engine/max]]
[[it:cpp/numeric/random/shuffle order engine/max]]
[[ja:cpp/numeric/random/shuffle order engine/max]]
[[pt:cpp/numeric/random/shuffle order engine/max]]
[[ru:cpp/numeric/random/shuffle order engine/max]]
[[zh:cpp/numeric/random/shuffle order engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/min</title>
    <ns>0</ns>
    <id>8807</id>
    <revision>
      <id>51023</id>
      <parentid>42812</parentid>
      <timestamp>2013-06-01T03:48:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="477">{{include page|cpp/numeric/random/adaptor/min|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/min]]
[[es:cpp/numeric/random/shuffle order engine/min]]
[[fr:cpp/numeric/random/shuffle order engine/min]]
[[it:cpp/numeric/random/shuffle order engine/min]]
[[ja:cpp/numeric/random/shuffle order engine/min]]
[[pt:cpp/numeric/random/shuffle order engine/min]]
[[ru:cpp/numeric/random/shuffle order engine/min]]
[[zh:cpp/numeric/random/shuffle order engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/operator()</title>
    <ns>0</ns>
    <id>8805</id>
    <revision>
      <id>42804</id>
      <parentid>37176</parentid>
      <timestamp>2012-11-03T00:30:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="527">{{cpp/numeric/random/adaptor/operator()|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/operator()]]
[[es:cpp/numeric/random/shuffle order engine/operator()]]
[[fr:cpp/numeric/random/shuffle order engine/operator()]]
[[it:cpp/numeric/random/shuffle order engine/operator()]]
[[ja:cpp/numeric/random/shuffle order engine/operator()]]
[[pt:cpp/numeric/random/shuffle order engine/operator()]]
[[ru:cpp/numeric/random/shuffle order engine/operator()]]
[[zh:cpp/numeric/random/shuffle order engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/operator cmp</title>
    <ns>0</ns>
    <id>8809</id>
    <revision>
      <id>51024</id>
      <parentid>42796</parentid>
      <timestamp>2013-06-01T03:48:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="558">{{include page|cpp/numeric/random/adaptor/operator cmp|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/operator cmp]]
[[es:cpp/numeric/random/shuffle order engine/operator cmp]]
[[fr:cpp/numeric/random/shuffle order engine/operator cmp]]
[[it:cpp/numeric/random/shuffle order engine/operator cmp]]
[[ja:cpp/numeric/random/shuffle order engine/operator cmp]]
[[pt:cpp/numeric/random/shuffle order engine/operator cmp]]
[[ru:cpp/numeric/random/shuffle order engine/operator cmp]]
[[zh:cpp/numeric/random/shuffle order engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>8810</id>
    <revision>
      <id>51025</id>
      <parentid>42788</parentid>
      <timestamp>2013-06-01T03:48:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="603">{{include page|cpp/numeric/random/adaptor/operator ltltgtgt|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[es:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[it:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/shuffle order engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/seed</title>
    <ns>0</ns>
    <id>8803</id>
    <revision>
      <id>51026</id>
      <parentid>42780</parentid>
      <timestamp>2013-06-01T03:48:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="486">{{include page|cpp/numeric/random/adaptor/seed|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/seed]]
[[es:cpp/numeric/random/shuffle order engine/seed]]
[[fr:cpp/numeric/random/shuffle order engine/seed]]
[[it:cpp/numeric/random/shuffle order engine/seed]]
[[ja:cpp/numeric/random/shuffle order engine/seed]]
[[pt:cpp/numeric/random/shuffle order engine/seed]]
[[ru:cpp/numeric/random/shuffle order engine/seed]]
[[zh:cpp/numeric/random/shuffle order engine/seed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/shuffle order engine/shuffle order engine</title>
    <ns>0</ns>
    <id>8802</id>
    <revision>
      <id>51027</id>
      <parentid>42774</parentid>
      <timestamp>2013-06-01T03:48:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="621">{{include page|cpp/numeric/random/adaptor/constructor|shuffle_order_engine}}

[[de:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[es:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[fr:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[it:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[ja:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[pt:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[ru:cpp/numeric/random/shuffle order engine/shuffle order engine]]
[[zh:cpp/numeric/random/shuffle order engine/shuffle order engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/srand</title>
    <ns>0</ns>
    <id>2038</id>
    <revision>
      <id>71062</id>
      <parentid>64222</parentid>
      <timestamp>2014-06-05T01:37:37Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to RAND_MAX</comment>
      <text xml:space="preserve" bytes="2012">{{cpp/title|srand}}
{{cpp/numeric/random/navbar}}
{{ddcl | header=cstdlib | 
void srand( unsigned seed );
}}

Seeds the pseudo-random number generator used by {{lc|std::rand()}} with the value {{tt|seed}}.

If {{tt|rand()}} is used before any calls to {{tt|srand()}}, {{tt|rand()}} behaves as if it was seeded with {{tt|srand(1)}}.
Each time {{tt|rand()}} is seeded with {{tt|srand()}}, it must produce the same sequence of values.

{{tt|srand()}} is not guaranteed to be thread-safe.

===Parameters===
{{par begin}}
{{par | seed | the seed value}}
{{par end}}

===Return value===
(none)

===Notes===
Generally speaking, the pseudo-random number generator should only be seeded once, before any calls to {{tt|rand()}}, and the start of the program.
It should not be repeatedly seeded, or reseeded every time you wish to generate a new batch of pseudo-random numbers.

Standard practice is to use the result of a call to {{c|time(0)}} as the seed.
However, {{tt|time()}} returns a {{c|time_t}} value, and {{tt|time_t}} is not guaranteed to be an integral type.
In practice, though, every major implementation defines {{tt|time_t}} to be an integral type, and this is also what POSIX requires.

===Example===
{{example
 | p=true
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
#include &lt;ctime&gt;

int main() 
{
    std::srand(std::time(0)); //use current time as seed for random generator
    int random_variable = std::rand();
    std::cout &lt;&lt; &quot;Random value on [0 &quot; &lt;&lt; RAND_MAX &lt;&lt; &quot;]: &quot; 
              &lt;&lt; random_variable &lt;&lt; '\n';
}
 | output=
Random value on [0 2147483647]: 1373858591
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/numeric/random/dsc rand}}
{{dsc inc | cpp/numeric/random/dsc RAND_MAX}}
{{dsc see c | c/numeric/random/srand}}
{{dsc end}}

[[de:cpp/numeric/random/srand]]
[[es:cpp/numeric/random/srand]]
[[fr:cpp/numeric/random/srand]]
[[it:cpp/numeric/random/srand]]
[[ja:cpp/numeric/random/srand]]
[[pt:cpp/numeric/random/srand]]
[[ru:cpp/numeric/random/srand]]
[[zh:cpp/numeric/random/srand]]</text>
      <sha1>fy3okf5ak14zndcabxnla80dqfvdk4a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution</title>
    <ns>0</ns>
    <id>3925</id>
    <revision>
      <id>63393</id>
      <parentid>58752</parentid>
      <timestamp>2013-07-10T01:30:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2632">{{cpp/title|student_t_distribution}}
{{cpp/numeric/random/student_t_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class student_t_distribution;
}}

Produces random floating-point values {{math|x}}, distributed according to probability density function:

:{{math|P(x{{!}}n) {{=}} {{mfrac|1|{{mrad|n&amp;pi;}}}} · {{mfrac|Γ({{mfrac|n+1|2}})|Γ({{mfrac|n|2}})}} · {{mparen|(|)|1+{{mfrac|x{{su|p=2}}|n}}|rows=3}} {{su|p=-{{mfrac|n+1|2}}}}}}

where {{math|n}} is known as the number of ''degrees of freedom''. This distribution is used when estimating the ''mean'' of an unknown normally distributed value given {{math|n+1}} independent measurements, each with additive errors of unknown standard deviation, as in physical measurements. Or, alternatively, when estimating the unknown mean of a normal distribution with unknown standard deviation, given {{math|n+1}} samples.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | student_t_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | student_t_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | student_t_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/student_t_distribution/dsc n}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | student_t_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | student_t_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | student_t_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | student_t_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | student_t_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===External links===
[http://mathworld.wolfram.com/Studentst-Distribution.html Weisstein, Eric W. &quot;Student's t-Distribution.&quot;] From MathWorld--A Wolfram Web Resource.

[[de:cpp/numeric/random/student t distribution]]
[[es:cpp/numeric/random/student t distribution]]
[[fr:cpp/numeric/random/student t distribution]]
[[it:cpp/numeric/random/student t distribution]]
[[ja:cpp/numeric/random/student t distribution]]
[[pt:cpp/numeric/random/student t distribution]]
[[ru:cpp/numeric/random/student t distribution]]
[[zh:cpp/numeric/random/student t distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/max</title>
    <ns>0</ns>
    <id>4017</id>
    <revision>
      <id>51028</id>
      <parentid>42752</parentid>
      <timestamp>2013-06-01T03:48:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/max|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/max]]
[[es:cpp/numeric/random/student t distribution/max]]
[[fr:cpp/numeric/random/student t distribution/max]]
[[it:cpp/numeric/random/student t distribution/max]]
[[ja:cpp/numeric/random/student t distribution/max]]
[[pt:cpp/numeric/random/student t distribution/max]]
[[ru:cpp/numeric/random/student t distribution/max]]
[[zh:cpp/numeric/random/student t distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/min</title>
    <ns>0</ns>
    <id>3969</id>
    <revision>
      <id>51029</id>
      <parentid>42744</parentid>
      <timestamp>2013-06-01T03:48:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/min|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/min]]
[[es:cpp/numeric/random/student t distribution/min]]
[[fr:cpp/numeric/random/student t distribution/min]]
[[it:cpp/numeric/random/student t distribution/min]]
[[ja:cpp/numeric/random/student t distribution/min]]
[[pt:cpp/numeric/random/student t distribution/min]]
[[ru:cpp/numeric/random/student t distribution/min]]
[[zh:cpp/numeric/random/student t distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/n</title>
    <ns>0</ns>
    <id>5158</id>
    <revision>
      <id>63394</id>
      <parentid>61252</parentid>
      <timestamp>2013-07-10T01:30:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="961">{{cpp/numeric/random/student_t_distribution/title|n}}
{{cpp/numeric/random/student_t_distribution/navbar}}
{{ddcl | since=c++11 | 1=
RealType n() const;
}}

Returns the {{math|n}} distribution parameter (number of the degrees of freedom) the distribution was constructed with. The default value is {{c|1.0}}.

===Parameters===
(none)

===Return value===
Floating point value identifying the degrees of freedom of the distribution

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | student_t_distribution}}
{{dsc end}}

[[de:cpp/numeric/random/student t distribution/n]]
[[es:cpp/numeric/random/student t distribution/n]]
[[fr:cpp/numeric/random/student t distribution/n]]
[[it:cpp/numeric/random/student t distribution/n]]
[[ja:cpp/numeric/random/student t distribution/n]]
[[pt:cpp/numeric/random/student t distribution/n]]
[[ru:cpp/numeric/random/student t distribution/n]]
[[zh:cpp/numeric/random/student t distribution/n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/operator()</title>
    <ns>0</ns>
    <id>4113</id>
    <revision>
      <id>42730</id>
      <parentid>15062</parentid>
      <timestamp>2012-11-03T00:17:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="550">{{cpp/numeric/random/distribution/operator()|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/operator()]]
[[es:cpp/numeric/random/student t distribution/operator()]]
[[fr:cpp/numeric/random/student t distribution/operator()]]
[[it:cpp/numeric/random/student t distribution/operator()]]
[[ja:cpp/numeric/random/student t distribution/operator()]]
[[pt:cpp/numeric/random/student t distribution/operator()]]
[[ru:cpp/numeric/random/student t distribution/operator()]]
[[zh:cpp/numeric/random/student t distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/operator cmp</title>
    <ns>0</ns>
    <id>4156</id>
    <revision>
      <id>51030</id>
      <parentid>42725</parentid>
      <timestamp>2013-06-01T03:48:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/operator_cmp|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/operator cmp]]
[[es:cpp/numeric/random/student t distribution/operator cmp]]
[[fr:cpp/numeric/random/student t distribution/operator cmp]]
[[it:cpp/numeric/random/student t distribution/operator cmp]]
[[ja:cpp/numeric/random/student t distribution/operator cmp]]
[[pt:cpp/numeric/random/student t distribution/operator cmp]]
[[ru:cpp/numeric/random/student t distribution/operator cmp]]
[[zh:cpp/numeric/random/student t distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4523</id>
    <revision>
      <id>51031</id>
      <parentid>42718</parentid>
      <timestamp>2013-06-01T03:48:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="626">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/student t distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/student t distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/param</title>
    <ns>0</ns>
    <id>4135</id>
    <revision>
      <id>51032</id>
      <parentid>42709</parentid>
      <timestamp>2013-06-01T03:48:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/param|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/param]]
[[es:cpp/numeric/random/student t distribution/param]]
[[fr:cpp/numeric/random/student t distribution/param]]
[[it:cpp/numeric/random/student t distribution/param]]
[[ja:cpp/numeric/random/student t distribution/param]]
[[pt:cpp/numeric/random/student t distribution/param]]
[[ru:cpp/numeric/random/student t distribution/param]]
[[zh:cpp/numeric/random/student t distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/reset</title>
    <ns>0</ns>
    <id>4091</id>
    <revision>
      <id>51033</id>
      <parentid>42702</parentid>
      <timestamp>2013-06-01T03:48:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/reset|student_t_distribution}}

[[de:cpp/numeric/random/student t distribution/reset]]
[[es:cpp/numeric/random/student t distribution/reset]]
[[fr:cpp/numeric/random/student t distribution/reset]]
[[it:cpp/numeric/random/student t distribution/reset]]
[[ja:cpp/numeric/random/student t distribution/reset]]
[[pt:cpp/numeric/random/student t distribution/reset]]
[[ru:cpp/numeric/random/student t distribution/reset]]
[[zh:cpp/numeric/random/student t distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/student t distribution/student t distribution</title>
    <ns>0</ns>
    <id>4918</id>
    <revision>
      <id>62911</id>
      <parentid>50402</parentid>
      <timestamp>2013-07-01T23:45:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1245">{{cpp/numeric/random/student_t_distribution/title|student_t_distribution}}
{{cpp/numeric/random/student_t_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit student_t_distribution( RealType n = 1 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit student_t_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|n}} as the distribution parameter, the second version uses {{tt|params}} as the distribution parameter.

===Parameters===
{{par begin}}
{{par | n | the ''n'' distribution parameter (degrees of freedom)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/student t distribution/student t distribution]]
[[es:cpp/numeric/random/student t distribution/student t distribution]]
[[fr:cpp/numeric/random/student t distribution/student t distribution]]
[[it:cpp/numeric/random/student t distribution/student t distribution]]
[[ja:cpp/numeric/random/student t distribution/student t distribution]]
[[pt:cpp/numeric/random/student t distribution/student t distribution]]
[[ru:cpp/numeric/random/student t distribution/student t distribution]]
[[zh:cpp/numeric/random/student t distribution/student t distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine</title>
    <ns>0</ns>
    <id>3699</id>
    <revision>
      <id>63193</id>
      <parentid>62166</parentid>
      <timestamp>2013-07-05T16:02:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+typedefs</comment>
      <text xml:space="preserve" bytes="2600">{{cpp/title|subtract_with_carry_engine}}
{{cpp/numeric/random/subtract_with_carry_engine/navbar}}
{{dcl begin}}
{{dcl header | random}}
{{dcl | since=c++11 |
template&lt;
    class UIntType, 
    size_t w, size_t s, size_t r
&gt; class subtract_with_carry_engine;
}}
{{dcl end}}

{{tt|subtract_with_carry_engine}} is a random number engine that uses [[enwiki:subtract with carry|subtract with carry]] algorithm. 

{{todo}}

The following typedefs define the random number engine with two commonly used parameter sets:
{{dsc begin}}
{{dsc header | random}}
{{dsc hitem | Type | Definition}}
{{dsc inc | cpp/numeric/random/dsc ranlux24_base}}
{{dsc inc | cpp/numeric/random/dsc ranlux48_base}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | The integral type generated by the engine.  Results are undefined if this is not an unsigned integral type.}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc h2 | Construction and Seeding}}
{{dsc inc | cpp/numeric/random/engine/dsc constructor |subtract_with_carry_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc seed |subtract_with_carry_engine}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() |subtract_with_carry_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc discard |subtract_with_carry_engine}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/engine/dsc min |subtract_with_carry_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc max |subtract_with_carry_engine}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_cmp |subtract_with_carry_engine}}
{{dsc inc | cpp/numeric/random/engine/dsc operator_ltltgtgt |subtract_with_carry_engine}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} word_size | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} short_lag | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr size_t}} long_lag | {{todo}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr UIntType}} default_seed | {{todo}} }}
{{dsc end}}

[[de:cpp/numeric/random/subtract with carry engine]]
[[es:cpp/numeric/random/subtract with carry engine]]
[[fr:cpp/numeric/random/subtract with carry engine]]
[[it:cpp/numeric/random/subtract with carry engine]]
[[ja:cpp/numeric/random/subtract with carry engine]]
[[pt:cpp/numeric/random/subtract with carry engine]]
[[ru:cpp/numeric/random/subtract with carry engine]]
[[zh:cpp/numeric/random/subtract with carry engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/discard</title>
    <ns>0</ns>
    <id>3735</id>
    <revision>
      <id>51034</id>
      <parentid>42677</parentid>
      <timestamp>2013-06-01T03:48:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="566">{{include page|cpp/numeric/random/engine/discard|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/discard]]
[[es:cpp/numeric/random/subtract with carry engine/discard]]
[[fr:cpp/numeric/random/subtract with carry engine/discard]]
[[it:cpp/numeric/random/subtract with carry engine/discard]]
[[ja:cpp/numeric/random/subtract with carry engine/discard]]
[[pt:cpp/numeric/random/subtract with carry engine/discard]]
[[ru:cpp/numeric/random/subtract with carry engine/discard]]
[[zh:cpp/numeric/random/subtract with carry engine/discard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/max</title>
    <ns>0</ns>
    <id>3739</id>
    <revision>
      <id>51035</id>
      <parentid>42669</parentid>
      <timestamp>2013-06-01T03:48:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="530">{{include page|cpp/numeric/random/engine/max|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/max]]
[[es:cpp/numeric/random/subtract with carry engine/max]]
[[fr:cpp/numeric/random/subtract with carry engine/max]]
[[it:cpp/numeric/random/subtract with carry engine/max]]
[[ja:cpp/numeric/random/subtract with carry engine/max]]
[[pt:cpp/numeric/random/subtract with carry engine/max]]
[[ru:cpp/numeric/random/subtract with carry engine/max]]
[[zh:cpp/numeric/random/subtract with carry engine/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/min</title>
    <ns>0</ns>
    <id>3736</id>
    <revision>
      <id>51036</id>
      <parentid>42663</parentid>
      <timestamp>2013-06-01T03:48:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="530">{{include page|cpp/numeric/random/engine/min|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/min]]
[[es:cpp/numeric/random/subtract with carry engine/min]]
[[fr:cpp/numeric/random/subtract with carry engine/min]]
[[it:cpp/numeric/random/subtract with carry engine/min]]
[[ja:cpp/numeric/random/subtract with carry engine/min]]
[[pt:cpp/numeric/random/subtract with carry engine/min]]
[[ru:cpp/numeric/random/subtract with carry engine/min]]
[[zh:cpp/numeric/random/subtract with carry engine/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/operator()</title>
    <ns>0</ns>
    <id>3734</id>
    <revision>
      <id>42655</id>
      <parentid>13915</parentid>
      <timestamp>2012-11-03T00:03:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="580">{{cpp/numeric/random/engine/operator()|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/operator()]]
[[es:cpp/numeric/random/subtract with carry engine/operator()]]
[[fr:cpp/numeric/random/subtract with carry engine/operator()]]
[[it:cpp/numeric/random/subtract with carry engine/operator()]]
[[ja:cpp/numeric/random/subtract with carry engine/operator()]]
[[pt:cpp/numeric/random/subtract with carry engine/operator()]]
[[ru:cpp/numeric/random/subtract with carry engine/operator()]]
[[zh:cpp/numeric/random/subtract with carry engine/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/operator cmp</title>
    <ns>0</ns>
    <id>8819</id>
    <revision>
      <id>51037</id>
      <parentid>42647</parentid>
      <timestamp>2013-06-01T03:48:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="611">{{include page|cpp/numeric/random/engine/operator cmp|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[es:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[fr:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[it:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[ja:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[pt:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[ru:cpp/numeric/random/subtract with carry engine/operator cmp]]
[[zh:cpp/numeric/random/subtract with carry engine/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/operator ltltgtgt</title>
    <ns>0</ns>
    <id>3737</id>
    <revision>
      <id>51038</id>
      <parentid>42641</parentid>
      <timestamp>2013-06-01T03:48:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="656">{{include page|cpp/numeric/random/engine/operator_ltltgtgt|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[es:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[fr:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[it:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[ja:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[pt:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[ru:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]
[[zh:cpp/numeric/random/subtract with carry engine/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/seed</title>
    <ns>0</ns>
    <id>3733</id>
    <revision>
      <id>51039</id>
      <parentid>42634</parentid>
      <timestamp>2013-06-01T03:48:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="539">{{include page|cpp/numeric/random/engine/seed|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/seed]]
[[es:cpp/numeric/random/subtract with carry engine/seed]]
[[fr:cpp/numeric/random/subtract with carry engine/seed]]
[[it:cpp/numeric/random/subtract with carry engine/seed]]
[[ja:cpp/numeric/random/subtract with carry engine/seed]]
[[pt:cpp/numeric/random/subtract with carry engine/seed]]
[[ru:cpp/numeric/random/subtract with carry engine/seed]]
[[zh:cpp/numeric/random/subtract with carry engine/seed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/subtract with carry engine/subtract with carry engine</title>
    <ns>0</ns>
    <id>3732</id>
    <revision>
      <id>51040</id>
      <parentid>42627</parentid>
      <timestamp>2013-06-01T03:48:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="722">{{include page|cpp/numeric/random/engine/constructor|subtract_with_carry_engine}}

[[de:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[es:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[fr:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[it:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[ja:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[pt:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[ru:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]
[[zh:cpp/numeric/random/subtract with carry engine/subtract with carry engine]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution</title>
    <ns>0</ns>
    <id>2701</id>
    <revision>
      <id>72351</id>
      <parentid>63395</parentid>
      <timestamp>2014-08-14T01:26:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+todo</comment>
      <text xml:space="preserve" bytes="2441">{{cpp/title|uniform_int_distribution}}
{{cpp/numeric/random/uniform_int_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class IntType = int &gt;
class uniform_int_distribution;
}}

Produces random integer values {{math|i}}, uniformly distributed on the closed interval {{tt|[a, b]}}, that is, distributed according to the discrete probability function 

:{{math|P(i{{!}}a,b) {{=}} {{mfrac|1|b − a + 1}}}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|IntType}} {{todo|list of allowed types from 26.5.1.1, here and for every distribution}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | uniform_int_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | uniform_int_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | uniform_int_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | uniform_int_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | uniform_int_distribution | IntType }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | uniform_int_distribution}}
{{dsc end}}

===Example===

{{example
 | This program simulates throwing 6-sided dice.
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution&lt;&gt; dis(1, 6);

    for (int n=0; n&lt;10; ++n)
        std::cout &lt;&lt; dis(gen) &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | p=true
 | output=
1 1 6 5 2 2 5 5 6 2
}}

[[de:cpp/numeric/random/uniform int distribution]]
[[es:cpp/numeric/random/uniform int distribution]]
[[fr:cpp/numeric/random/uniform int distribution]]
[[it:cpp/numeric/random/uniform int distribution]]
[[ja:cpp/numeric/random/uniform int distribution]]
[[pt:cpp/numeric/random/uniform int distribution]]
[[ru:cpp/numeric/random/uniform int distribution]]
[[zh:cpp/numeric/random/uniform int distribution]]</text>
      <sha1>glqwlvxax2denigsp1lq1oqmxalrgli</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/a</title>
    <ns>0</ns>
    <id>4593</id>
    <redirect title="cpp/numeric/random/uniform int distribution/params" />
    <revision>
      <id>61201</id>
      <parentid>58760</parentid>
      <timestamp>2013-06-05T12:28:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/uniform int distribution/params]]</comment>
      <text xml:space="preserve" bytes="64">#redirect [[cpp/numeric/random/uniform_int_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/b</title>
    <ns>0</ns>
    <id>4594</id>
    <redirect title="cpp/numeric/random/uniform int distribution/params" />
    <revision>
      <id>61209</id>
      <parentid>58761</parentid>
      <timestamp>2013-06-05T12:29:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/uniform int distribution/params]]</comment>
      <text xml:space="preserve" bytes="64">#redirect [[cpp/numeric/random/uniform_int_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/max</title>
    <ns>0</ns>
    <id>3318</id>
    <revision>
      <id>51041</id>
      <parentid>42601</parentid>
      <timestamp>2013-06-01T03:48:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/max|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/max]]
[[es:cpp/numeric/random/uniform int distribution/max]]
[[fr:cpp/numeric/random/uniform int distribution/max]]
[[it:cpp/numeric/random/uniform int distribution/max]]
[[ja:cpp/numeric/random/uniform int distribution/max]]
[[pt:cpp/numeric/random/uniform int distribution/max]]
[[ru:cpp/numeric/random/uniform int distribution/max]]
[[zh:cpp/numeric/random/uniform int distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/min</title>
    <ns>0</ns>
    <id>3313</id>
    <revision>
      <id>51042</id>
      <parentid>42593</parentid>
      <timestamp>2013-06-01T03:48:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="518">{{include page|cpp/numeric/random/distribution/min|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/min]]
[[es:cpp/numeric/random/uniform int distribution/min]]
[[fr:cpp/numeric/random/uniform int distribution/min]]
[[it:cpp/numeric/random/uniform int distribution/min]]
[[ja:cpp/numeric/random/uniform int distribution/min]]
[[pt:cpp/numeric/random/uniform int distribution/min]]
[[ru:cpp/numeric/random/uniform int distribution/min]]
[[zh:cpp/numeric/random/uniform int distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/operator()</title>
    <ns>0</ns>
    <id>4097</id>
    <revision>
      <id>63156</id>
      <parentid>42585</parentid>
      <timestamp>2013-07-03T15:10:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+include page</comment>
      <text xml:space="preserve" bytes="581">{{include page|cpp/numeric/random/distribution/operator()|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/operator()]]
[[es:cpp/numeric/random/uniform int distribution/operator()]]
[[fr:cpp/numeric/random/uniform int distribution/operator()]]
[[it:cpp/numeric/random/uniform int distribution/operator()]]
[[ja:cpp/numeric/random/uniform int distribution/operator()]]
[[pt:cpp/numeric/random/uniform int distribution/operator()]]
[[ru:cpp/numeric/random/uniform int distribution/operator()]]
[[zh:cpp/numeric/random/uniform int distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/operator cmp</title>
    <ns>0</ns>
    <id>4141</id>
    <revision>
      <id>51043</id>
      <parentid>42578</parentid>
      <timestamp>2013-06-01T03:48:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="599">{{include page|cpp/numeric/random/distribution/operator_cmp|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/operator cmp]]
[[es:cpp/numeric/random/uniform int distribution/operator cmp]]
[[fr:cpp/numeric/random/uniform int distribution/operator cmp]]
[[it:cpp/numeric/random/uniform int distribution/operator cmp]]
[[ja:cpp/numeric/random/uniform int distribution/operator cmp]]
[[pt:cpp/numeric/random/uniform int distribution/operator cmp]]
[[ru:cpp/numeric/random/uniform int distribution/operator cmp]]
[[zh:cpp/numeric/random/uniform int distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4539</id>
    <revision>
      <id>51044</id>
      <parentid>42573</parentid>
      <timestamp>2013-06-01T03:48:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="644">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/uniform int distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/param</title>
    <ns>0</ns>
    <id>4119</id>
    <revision>
      <id>51045</id>
      <parentid>42565</parentid>
      <timestamp>2013-06-01T03:48:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="536">{{include page|cpp/numeric/random/distribution/param|uniform_int_distribution}}

[[de:cpp/numeric/random/uniform int distribution/param]]
[[es:cpp/numeric/random/uniform int distribution/param]]
[[fr:cpp/numeric/random/uniform int distribution/param]]
[[it:cpp/numeric/random/uniform int distribution/param]]
[[ja:cpp/numeric/random/uniform int distribution/param]]
[[pt:cpp/numeric/random/uniform int distribution/param]]
[[ru:cpp/numeric/random/uniform int distribution/param]]
[[zh:cpp/numeric/random/uniform int distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/params</title>
    <ns>0</ns>
    <id>12598</id>
    <revision>
      <id>65744</id>
      <parentid>61263</parentid>
      <timestamp>2013-10-03T20:50:51Z</timestamp>
      <contributor>
        <ip>5.28.71.244</ip>
      </contributor>
      <text xml:space="preserve" bytes="851">{{cpp/numeric/random/uniform_int_distribution/title|a, b}}
{{cpp/numeric/random/uniform_int_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
result_type a() const;
}}
{{dcl | since=c++11 | num=2 |
result_type b() const;
}}
{{dcl end}}

Returns the parameters the distribution has been constructed with.

@1@ Returns the ''a'' distribution parameter. It defines the minimum possibly generated value. The default value is {{c|0}}.

@2@ Returns the ''b'' distribution parameter. It defines the maximum possibly generated value. The default value is {{c|std::numeric_limits&lt;IntType&gt;::max()}}

===Parameters===
(none)

===Return value===
@1@ The ''a'' distribution parameter.

@2@ The ''b'' distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | uniform_int_distribution}}
{{dsc end}}</text>
      <sha1>d8jqt675nme24d4va3b8og15ghuq7k2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/reset</title>
    <ns>0</ns>
    <id>3342</id>
    <revision>
      <id>51046</id>
      <parentid>42551</parentid>
      <timestamp>2013-06-01T03:48:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="537">{{include page|cpp/numeric/random/distribution/reset|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform int distribution/reset]]
[[es:cpp/numeric/random/uniform int distribution/reset]]
[[fr:cpp/numeric/random/uniform int distribution/reset]]
[[it:cpp/numeric/random/uniform int distribution/reset]]
[[ja:cpp/numeric/random/uniform int distribution/reset]]
[[pt:cpp/numeric/random/uniform int distribution/reset]]
[[ru:cpp/numeric/random/uniform int distribution/reset]]
[[zh:cpp/numeric/random/uniform int distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform int distribution/uniform int distribution</title>
    <ns>0</ns>
    <id>4595</id>
    <revision>
      <id>63159</id>
      <parentid>62912</parentid>
      <timestamp>2013-07-03T16:15:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>this is part of the spec</comment>
      <text xml:space="preserve" bytes="1485">{{cpp/numeric/random/uniform_int_distribution/title|uniform_int_distribution}}
{{cpp/numeric/random/uniform_int_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit uniform_int_distribution( IntType a = 0, 
                                   IntType b = std::numeric_limits&lt;IntType&gt;::max() );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit uniform_int_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|a}} and {{tt|b}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

The behavior is undefined if {{c|a&gt;b}}.

===Parameters===
{{par begin}}
{{par | a | the ''a'' distribution parameter (minimum value)}}
{{par | b | the ''b'' distribution parameter (maximum value)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[es:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[fr:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[it:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[ja:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[pt:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[ru:cpp/numeric/random/uniform int distribution/uniform int distribution]]
[[zh:cpp/numeric/random/uniform int distribution/uniform int distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution</title>
    <ns>0</ns>
    <id>3327</id>
    <revision>
      <id>63396</id>
      <parentid>61149</parentid>
      <timestamp>2013-07-10T01:30:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2421">{{cpp/title|uniform_real_distribution}}
{{cpp/numeric/random/uniform_real_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class uniform_real_distribution;
}}

Produces random floating-point values {{math|i}}, uniformly distributed on the interval {{tt|[a, b)}}, that is, distributed according to the probability function:

:{{math|P(i{{!}}a,b) {{=}} {{mfrac|1|b − a}}}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | uniform_real_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | uniform_real_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | uniform_real_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | uniform_real_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | uniform_real_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | uniform_real_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | uniform_real_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | uniform_real_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | uniform_real_distribution}}
{{dsc end}}

===Example===

{{example
 | print 10 random numbers between 1 and 2
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution&lt;&gt; dis(1, 2);
    for (int n = 0; n &lt; 10; ++n) {
        std::cout &lt;&lt; dis(gen) &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
1.80829 1.15391 1.18483 1.38969 1.36094 1.0648 1.97798 1.27984 1.68261 1.57326 
}}

[[de:cpp/numeric/random/uniform real distribution]]
[[es:cpp/numeric/random/uniform real distribution]]
[[fr:cpp/numeric/random/uniform real distribution]]
[[it:cpp/numeric/random/uniform real distribution]]
[[ja:cpp/numeric/random/uniform real distribution]]
[[pt:cpp/numeric/random/uniform real distribution]]
[[ru:cpp/numeric/random/uniform real distribution]]
[[zh:cpp/numeric/random/uniform real distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/a</title>
    <ns>0</ns>
    <id>4591</id>
    <redirect title="cpp/numeric/random/uniform real distribution/params" />
    <revision>
      <id>61203</id>
      <parentid>58765</parentid>
      <timestamp>2013-06-05T12:29:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/uniform real distribution/params]]</comment>
      <text xml:space="preserve" bytes="65">#redirect [[cpp/numeric/random/uniform_real_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/b</title>
    <ns>0</ns>
    <id>4592</id>
    <redirect title="cpp/numeric/random/uniform real distribution/params" />
    <revision>
      <id>61212</id>
      <parentid>58766</parentid>
      <timestamp>2013-06-05T12:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/uniform real distribution/params]]</comment>
      <text xml:space="preserve" bytes="65">#redirect [[cpp/numeric/random/uniform_real_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/max</title>
    <ns>0</ns>
    <id>3341</id>
    <revision>
      <id>51047</id>
      <parentid>42517</parentid>
      <timestamp>2013-06-01T03:48:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="527">{{include page|cpp/numeric/random/distribution/max|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/max]]
[[es:cpp/numeric/random/uniform real distribution/max]]
[[fr:cpp/numeric/random/uniform real distribution/max]]
[[it:cpp/numeric/random/uniform real distribution/max]]
[[ja:cpp/numeric/random/uniform real distribution/max]]
[[pt:cpp/numeric/random/uniform real distribution/max]]
[[ru:cpp/numeric/random/uniform real distribution/max]]
[[zh:cpp/numeric/random/uniform real distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/min</title>
    <ns>0</ns>
    <id>3340</id>
    <revision>
      <id>51048</id>
      <parentid>42509</parentid>
      <timestamp>2013-06-01T03:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="527">{{include page|cpp/numeric/random/distribution/min|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/min]]
[[es:cpp/numeric/random/uniform real distribution/min]]
[[fr:cpp/numeric/random/uniform real distribution/min]]
[[it:cpp/numeric/random/uniform real distribution/min]]
[[ja:cpp/numeric/random/uniform real distribution/min]]
[[pt:cpp/numeric/random/uniform real distribution/min]]
[[ru:cpp/numeric/random/uniform real distribution/min]]
[[zh:cpp/numeric/random/uniform real distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/operator()</title>
    <ns>0</ns>
    <id>4098</id>
    <revision>
      <id>42500</id>
      <parentid>15045</parentid>
      <timestamp>2012-11-02T23:31:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="577">{{cpp/numeric/random/distribution/operator()|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/operator()]]
[[es:cpp/numeric/random/uniform real distribution/operator()]]
[[fr:cpp/numeric/random/uniform real distribution/operator()]]
[[it:cpp/numeric/random/uniform real distribution/operator()]]
[[ja:cpp/numeric/random/uniform real distribution/operator()]]
[[pt:cpp/numeric/random/uniform real distribution/operator()]]
[[ru:cpp/numeric/random/uniform real distribution/operator()]]
[[zh:cpp/numeric/random/uniform real distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/operator cmp</title>
    <ns>0</ns>
    <id>4160</id>
    <revision>
      <id>51049</id>
      <parentid>42492</parentid>
      <timestamp>2013-06-01T03:48:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="608">{{include page|cpp/numeric/random/distribution/operator_cmp|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/operator cmp]]
[[es:cpp/numeric/random/uniform real distribution/operator cmp]]
[[fr:cpp/numeric/random/uniform real distribution/operator cmp]]
[[it:cpp/numeric/random/uniform real distribution/operator cmp]]
[[ja:cpp/numeric/random/uniform real distribution/operator cmp]]
[[pt:cpp/numeric/random/uniform real distribution/operator cmp]]
[[ru:cpp/numeric/random/uniform real distribution/operator cmp]]
[[zh:cpp/numeric/random/uniform real distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4538</id>
    <revision>
      <id>51050</id>
      <parentid>42482</parentid>
      <timestamp>2013-06-01T03:48:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="653">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/uniform real distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/param</title>
    <ns>0</ns>
    <id>4120</id>
    <revision>
      <id>51051</id>
      <parentid>42472</parentid>
      <timestamp>2013-06-01T03:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="545">{{include page|cpp/numeric/random/distribution/param|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/param]]
[[es:cpp/numeric/random/uniform real distribution/param]]
[[fr:cpp/numeric/random/uniform real distribution/param]]
[[it:cpp/numeric/random/uniform real distribution/param]]
[[ja:cpp/numeric/random/uniform real distribution/param]]
[[pt:cpp/numeric/random/uniform real distribution/param]]
[[ru:cpp/numeric/random/uniform real distribution/param]]
[[zh:cpp/numeric/random/uniform real distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/params</title>
    <ns>0</ns>
    <id>12599</id>
    <revision>
      <id>65368</id>
      <parentid>61264</parentid>
      <timestamp>2013-09-10T17:41:26Z</timestamp>
      <contributor>
        <ip>50.136.177.227</ip>
      </contributor>
      <text xml:space="preserve" bytes="826">{{cpp/numeric/random/uniform_real_distribution/title|a, b}}
{{cpp/numeric/random/uniform_real_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 
result_type a() const;
}}
{{dcl | since=c++11 | num=2 | 
result_type b() const;
}}
{{dcl end}}

Returns the parameters the distribution has been constructed with.

@1@ Returns the ''a'' distribution parameter. It defines the minimum possibly generated value. The default value is {{c|0.0}}.

@2@ Returns the ''b'' distribution parameter. It defines the maximum possibly generated value. The default value is {{c|1.0}}

===Parameters===
(none)

===Return value===
@1@ The ''a'' distribution parameter.

@2@ The ''b'' distribution parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | uniform_real_distribution}}
{{dsc end}}</text>
      <sha1>i2s0r8eqpxtxhqv28jlhydcb804fbnt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/reset</title>
    <ns>0</ns>
    <id>3329</id>
    <revision>
      <id>51052</id>
      <parentid>42464</parentid>
      <timestamp>2013-06-01T03:49:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="545">{{include page|cpp/numeric/random/distribution/reset|uniform_real_distribution}}

[[de:cpp/numeric/random/uniform real distribution/reset]]
[[es:cpp/numeric/random/uniform real distribution/reset]]
[[fr:cpp/numeric/random/uniform real distribution/reset]]
[[it:cpp/numeric/random/uniform real distribution/reset]]
[[ja:cpp/numeric/random/uniform real distribution/reset]]
[[pt:cpp/numeric/random/uniform real distribution/reset]]
[[ru:cpp/numeric/random/uniform real distribution/reset]]
[[zh:cpp/numeric/random/uniform real distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/uniform real distribution/uniform real distribution</title>
    <ns>0</ns>
    <id>4596</id>
    <revision>
      <id>62913</id>
      <parentid>50411</parentid>
      <timestamp>2013-07-01T23:45:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1671">{{cpp/numeric/random/uniform_real_distribution/title|uniform_real_distribution}}
{{cpp/numeric/random/uniform_real_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit uniform_real_distribution( RealType a = 0.0, RealType b = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit uniform_real_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs new distribution object. The first version uses {{tt|a}} and {{tt|b}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | a | the ''a'' distribution parameter (minimum value)}}
{{par | b | the ''b'' distribution parameter (maximum value)}}
{{par | params | the distribution parameter set}}
{{par end}}

===Notes===
Requires that {{math|a ≤ b}} and {{math| b-a ≤ std::numeric_limits&lt;RealType&gt;::max() }}

To create a distribution over the closed interval {{math|[a,b]}}, {{c|std::nextafter(b, std::numeric_limits&lt;RealType&gt;::max())}} may be used as the second parameter.

[[de:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[es:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[fr:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[it:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[ja:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[pt:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[ru:cpp/numeric/random/uniform real distribution/uniform real distribution]]
[[zh:cpp/numeric/random/uniform real distribution/uniform real distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution</title>
    <ns>0</ns>
    <id>3918</id>
    <revision>
      <id>63397</id>
      <parentid>61138</parentid>
      <timestamp>2013-07-10T01:31:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3007">{{cpp/title|weibull_distribution}}
{{cpp/numeric/random/weibull_distribution/navbar}}
{{ddcl | header=random | since=c++11 | 1=
template&lt; class RealType = double &gt;
class weibull_distribution;
}}

The {{tt|weibull_distribution}} meets the requirements of a {{concept|RandomNumberDistribution}} and produces random numbers according to the [[enwiki:Weibull distribution|Weibull distribution]]:

:{{math|f(x;a,b) {{=}} {{mfrac||a|b}} {{mparen|(|)|{{mfrac||x|b}}}}{{su|p=a-1}} exp{{mparen|(|)|-{{mparen|(|)|{{mfrac||x|b}}}}{{su|p=a}} }} }}

{{math|a}} is the [[enwiki:shape parameter|shape parameter]] and {{math|b}} the [[enwiki:scale parameter|scale parameter]].

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|result_type}} | {{c|RealType}}}}
{{dsc | {{tt|param_type}} | the type of the parameter set, unspecified}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc constructor | weibull_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc reset | weibull_distribution}}

{{dsc h2 | Generation}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | weibull_distribution}}

{{dsc h2 | Characteristics}}
{{dsc inc | cpp/numeric/random/distribution/dsc params | weibull_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | weibull_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc min | weibull_distribution}}
{{dsc inc | cpp/numeric/random/distribution/dsc max | weibull_distribution}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_cmp | weibull_distribution }}
{{dsc inc | cpp/numeric/random/distribution/dsc operator_ltltgtgt | weibull_distribution}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;string&gt;
#include &lt;map&gt;
#include &lt;random&gt;
#include &lt;cmath&gt;
int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
 
    std::weibull_distribution&lt;&gt; d;
 
    std::map&lt;int, int&gt; hist;
    for(int n=0; n&lt;10000; ++n) {
        ++hist[std::round(d(gen))];
    }
    for(auto p : hist) {
        std::cout &lt;&lt; std::fixed &lt;&lt; std::setprecision(1) &lt;&lt; std::setw(2)
                  &lt;&lt; p.first &lt;&lt; ' ' &lt;&lt; std::string(p.second/200, '*') &lt;&lt; '\n';
    }
}
 | output=
 0 *******************
 1 *******************
 2 ******
 3 **
 4 
 5 
 6 
 7 
 8
}}

===External links===
* [http://mathworld.wolfram.com/WeibullDistribution.html Weisstein, Eric W. &quot;Weibull Distribution.&quot;] From MathWorld--A Wolfram Web Resource.
* [[enwiki:Weibull distribution|Weibull distribution.]] From Wikipedia.

[[de:cpp/numeric/random/weibull distribution]]
[[es:cpp/numeric/random/weibull distribution]]
[[fr:cpp/numeric/random/weibull distribution]]
[[it:cpp/numeric/random/weibull distribution]]
[[ja:cpp/numeric/random/weibull distribution]]
[[pt:cpp/numeric/random/weibull distribution]]
[[ru:cpp/numeric/random/weibull distribution]]
[[zh:cpp/numeric/random/weibull distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/a</title>
    <ns>0</ns>
    <id>12584</id>
    <redirect title="cpp/numeric/random/weibull distribution/params" />
    <revision>
      <id>61222</id>
      <parentid>61087</parentid>
      <timestamp>2013-06-05T12:31:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/weibull distribution/params]]</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/numeric/random/weibull_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/b</title>
    <ns>0</ns>
    <id>12585</id>
    <redirect title="cpp/numeric/random/weibull distribution/params" />
    <revision>
      <id>61225</id>
      <parentid>61086</parentid>
      <timestamp>2013-06-05T12:31:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/numeric/random/weibull distribution/params]]</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/numeric/random/weibull_distribution/params]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/max</title>
    <ns>0</ns>
    <id>4012</id>
    <revision>
      <id>51053</id>
      <parentid>42444</parentid>
      <timestamp>2013-06-01T03:49:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/max|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/max]]
[[es:cpp/numeric/random/weibull distribution/max]]
[[fr:cpp/numeric/random/weibull distribution/max]]
[[it:cpp/numeric/random/weibull distribution/max]]
[[ja:cpp/numeric/random/weibull distribution/max]]
[[pt:cpp/numeric/random/weibull distribution/max]]
[[ru:cpp/numeric/random/weibull distribution/max]]
[[zh:cpp/numeric/random/weibull distribution/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/min</title>
    <ns>0</ns>
    <id>3976</id>
    <revision>
      <id>51054</id>
      <parentid>42430</parentid>
      <timestamp>2013-06-01T03:49:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="482">{{include page|cpp/numeric/random/distribution/min|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/min]]
[[es:cpp/numeric/random/weibull distribution/min]]
[[fr:cpp/numeric/random/weibull distribution/min]]
[[it:cpp/numeric/random/weibull distribution/min]]
[[ja:cpp/numeric/random/weibull distribution/min]]
[[pt:cpp/numeric/random/weibull distribution/min]]
[[ru:cpp/numeric/random/weibull distribution/min]]
[[zh:cpp/numeric/random/weibull distribution/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/operator()</title>
    <ns>0</ns>
    <id>4107</id>
    <revision>
      <id>42420</id>
      <parentid>15056</parentid>
      <timestamp>2012-11-02T23:14:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="532">{{cpp/numeric/random/distribution/operator()|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/operator()]]
[[es:cpp/numeric/random/weibull distribution/operator()]]
[[fr:cpp/numeric/random/weibull distribution/operator()]]
[[it:cpp/numeric/random/weibull distribution/operator()]]
[[ja:cpp/numeric/random/weibull distribution/operator()]]
[[pt:cpp/numeric/random/weibull distribution/operator()]]
[[ru:cpp/numeric/random/weibull distribution/operator()]]
[[zh:cpp/numeric/random/weibull distribution/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/operator cmp</title>
    <ns>0</ns>
    <id>4149</id>
    <revision>
      <id>51055</id>
      <parentid>42411</parentid>
      <timestamp>2013-06-01T03:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="563">{{include page|cpp/numeric/random/distribution/operator_cmp|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/operator cmp]]
[[es:cpp/numeric/random/weibull distribution/operator cmp]]
[[fr:cpp/numeric/random/weibull distribution/operator cmp]]
[[it:cpp/numeric/random/weibull distribution/operator cmp]]
[[ja:cpp/numeric/random/weibull distribution/operator cmp]]
[[pt:cpp/numeric/random/weibull distribution/operator cmp]]
[[ru:cpp/numeric/random/weibull distribution/operator cmp]]
[[zh:cpp/numeric/random/weibull distribution/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/operator ltltgtgt</title>
    <ns>0</ns>
    <id>4530</id>
    <revision>
      <id>51056</id>
      <parentid>42403</parentid>
      <timestamp>2013-06-01T03:49:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="608">{{include page|cpp/numeric/random/distribution/operator_ltltgtgt|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[es:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[fr:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[it:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[ja:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[pt:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[ru:cpp/numeric/random/weibull distribution/operator ltltgtgt]]
[[zh:cpp/numeric/random/weibull distribution/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/param</title>
    <ns>0</ns>
    <id>4118</id>
    <revision>
      <id>51057</id>
      <parentid>42396</parentid>
      <timestamp>2013-06-01T03:49:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/param|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/param]]
[[es:cpp/numeric/random/weibull distribution/param]]
[[fr:cpp/numeric/random/weibull distribution/param]]
[[it:cpp/numeric/random/weibull distribution/param]]
[[ja:cpp/numeric/random/weibull distribution/param]]
[[pt:cpp/numeric/random/weibull distribution/param]]
[[ru:cpp/numeric/random/weibull distribution/param]]
[[zh:cpp/numeric/random/weibull distribution/param]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/params</title>
    <ns>0</ns>
    <id>12602</id>
    <revision>
      <id>61258</id>
      <parentid>61257</parentid>
      <timestamp>2013-06-05T13:06:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+default value</comment>
      <text xml:space="preserve" bytes="810">{{cpp/numeric/random/weibull_distribution/title | a, b}}
{{cpp/numeric/random/weibull_distribution/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 |
RealType a() const;
}}
{{dcl | since=c++11 | num=2 |
RealType b() const;
}}
{{dcl end}}

Returns the parameters the distribution was constructed with.

@1@ Returns the {{math|a}} parameter. It defines the shape of the distribution. The default value is {{c|1.0}}.

@2@ Returns the {{math|b}} parameter. It defines the scale of the distribution. The default value is {{c|1.0}}. 

===Parameters===
(none)

===Return value===
@1@ The value of the {{math|a}} parameter.

@2@ The value of the {{math|b}} parameter.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc param | weibull_distribution}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/reset</title>
    <ns>0</ns>
    <id>4084</id>
    <revision>
      <id>51058</id>
      <parentid>42387</parentid>
      <timestamp>2013-06-01T03:49:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="500">{{include page|cpp/numeric/random/distribution/reset|weibull_distribution}}

[[de:cpp/numeric/random/weibull distribution/reset]]
[[es:cpp/numeric/random/weibull distribution/reset]]
[[fr:cpp/numeric/random/weibull distribution/reset]]
[[it:cpp/numeric/random/weibull distribution/reset]]
[[ja:cpp/numeric/random/weibull distribution/reset]]
[[pt:cpp/numeric/random/weibull distribution/reset]]
[[ru:cpp/numeric/random/weibull distribution/reset]]
[[zh:cpp/numeric/random/weibull distribution/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/random/weibull distribution/weibull distribution</title>
    <ns>0</ns>
    <id>4926</id>
    <revision>
      <id>62914</id>
      <parentid>50413</parentid>
      <timestamp>2013-07-01T23:45:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1282">{{cpp/numeric/random/weibull_distribution/title|weibull_distribution}}
{{cpp/numeric/random/weibull_distribution/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit weibull_distribution( RealType a = 1.0, RealType b = 1.0 );
}}
{{dcl | num=2 | since=c++11 | 1=
explicit weibull_distribution( const param_type&amp; params );
}}
{{dcl end}}

Constructs a new distribution object. The first version uses {{tt|a}} and {{tt|b}} as the distribution parameters, the second version uses {{tt|params}} as the distribution parameters.

===Parameters===
{{par begin}}
{{par | a | the ''a'' distribution parameter (shape)}}
{{par | b | the ''b'' distribution parameter (scale)}}
{{par | params | the distribution parameter set}}
{{par end}}

[[de:cpp/numeric/random/weibull distribution/weibull distribution]]
[[es:cpp/numeric/random/weibull distribution/weibull distribution]]
[[fr:cpp/numeric/random/weibull distribution/weibull distribution]]
[[it:cpp/numeric/random/weibull distribution/weibull distribution]]
[[ja:cpp/numeric/random/weibull distribution/weibull distribution]]
[[pt:cpp/numeric/random/weibull distribution/weibull distribution]]
[[ru:cpp/numeric/random/weibull distribution/weibull distribution]]
[[zh:cpp/numeric/random/weibull distribution/weibull distribution]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio</title>
    <ns>0</ns>
    <id>2483</id>
    <revision>
      <id>58772</id>
      <parentid>50414</parentid>
      <timestamp>2013-06-01T06:21:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3120">{{title|Compile-time rational arithmetic}}
{{cpp/numeric/ratio/navbar}}

The class template {{tt|std::ratio}} and associated templates provide compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number.

===Compile-time fractions===
{{dsc begin}}
{{dsc header | ratio}}
{{dsc tclass | cpp/numeric/ratio/ratio | represents exact rational fraction}}
{{dsc end}}

Several convenience typedefs that correspond to the SI ratios are provided by the standard library:
{{dsc begin}}
{{dsc header | ratio}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|yocto}} | {{c|std::ratio&lt;1, 1000000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|zepto}} | {{c|std::ratio&lt;1, 1000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|atto}}  | {{c|std::ratio&lt;1, 1000000000000000000&gt;}}}}
{{dsc | {{tt|femto}} | {{c|std::ratio&lt;1, 1000000000000000&gt;}}}}
{{dsc | {{tt|pico}}  | {{c|std::ratio&lt;1, 1000000000000&gt;}}}}
{{dsc | {{tt|nano}}  | {{c|std::ratio&lt;1, 1000000000&gt;}}}}
{{dsc | {{tt|micro}} | {{c|std::ratio&lt;1, 1000000&gt;}}}}
{{dsc | {{tt|milli}} | {{c|std::ratio&lt;1, 1000&gt;}}}}
{{dsc | {{tt|centi}} | {{c|std::ratio&lt;1, 100&gt;}}}}
{{dsc | {{tt|deci}}  | {{c|std::ratio&lt;1, 10&gt;}}}}
{{dsc | {{tt|deca}}  | {{c|std::ratio&lt;10, 1&gt;}}}}
{{dsc | {{tt|hecto}} | {{c|std::ratio&lt;100, 1&gt;}}}}
{{dsc | {{tt|kilo}}  | {{c|std::ratio&lt;1000, 1&gt;}}}}
{{dsc | {{tt|mega}}  | {{c|std::ratio&lt;1000000, 1&gt;}}}}
{{dsc | {{tt|giga}}  | {{c|std::ratio&lt;1000000000, 1&gt;}}}}
{{dsc | {{tt|tera}}  | {{c|std::ratio&lt;1000000000000, 1&gt;}}}}
{{dsc | {{tt|peta}}  | {{c|std::ratio&lt;1000000000000000, 1&gt;}}}}
{{dsc | {{tt|exa}}   | {{c|std::ratio&lt;1000000000000000000, 1&gt;}}}}
{{dsc | {{tt|zetta}} | {{c|std::ratio&lt;1000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc | {{tt|yotta}} | {{c|std::ratio&lt;1000000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc end}}

===Compile-time rational arithmetic===

Several class templates, that perform arithmetic operations on {{tt|ratio}} objects at compile-time are provided.

{{dsc begin}}
{{dsc header | ratio}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_add}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_subtract}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_multiply}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_divide}}
{{dsc end}}

===Compile-time rational comparison===

Several class templates, that perform comparison operations on {{tt|ratio}} objects at compile-time are provided.

{{dsc begin}}
{{dsc header | ratio}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_not_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_less}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_less_equal}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_greater}}
{{dsc inc | cpp/numeric/ratio/dsc ratio_greater_equal}}
{{dsc end}}

[[de:cpp/numeric/ratio]]
[[es:cpp/numeric/ratio]]
[[fr:cpp/numeric/ratio]]
[[it:cpp/numeric/ratio]]
[[ja:cpp/numeric/ratio]]
[[pt:cpp/numeric/ratio]]
[[ru:cpp/numeric/ratio]]
[[zh:cpp/numeric/ratio]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio</title>
    <ns>0</ns>
    <id>2489</id>
    <revision>
      <id>68699</id>
      <parentid>68697</parentid>
      <timestamp>2014-03-19T15:57:42Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Undo revision 68697 by [[Special:Contributions/123.124.22.67|123.124.22.67]] ([[User talk:123.124.22.67|talk]]) renaming the template parameter is not necessary and introduces error</comment>
      <text xml:space="preserve" bytes="3033">{{cpp/title|ratio}}
{{cpp/numeric/ratio/navbar}}
{{ddcl | header=ratio | since=c++11 | 1=
template&lt; 
    std::intmax_t Num, 
    std::intmax_t Denom = 1 
&gt; class ratio;
}}

The class template {{tt|std::ratio}} provides compile-time rational arithmetic support. Each instantiation of this template exactly represents any finite rational number as long as its numerator {{tt|Num}} and denominator {{tt|Denom}} are representable as compile-time constants of type {{lc|std::intmax_t}}. In addition, {{tt|Denom}} may not be zero and may not be equal to the most negative value. Both numerator and denominator are automatically reduced to the lowest terms.

Several convenience typedefs that correspond to the SI ratios are provided by the standard library:
{{dsc begin}}
{{dsc header | ratio}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|yocto}} | {{c|std::ratio&lt;1, 1000000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|zepto}} | {{c|std::ratio&lt;1, 1000000000000000000000&gt;}}, if {{lc|std::intmax_t}} can represent the denominator}}
{{dsc | {{tt|atto}}  | {{c|std::ratio&lt;1, 1000000000000000000&gt;}}}}
{{dsc | {{tt|femto}} | {{c|std::ratio&lt;1, 1000000000000000&gt;}}}}
{{dsc | {{tt|pico}}  | {{c|std::ratio&lt;1, 1000000000000&gt;}}}}
{{dsc | {{tt|nano}}  | {{c|std::ratio&lt;1, 1000000000&gt;}}}}
{{dsc | {{tt|micro}} | {{c|std::ratio&lt;1, 1000000&gt;}}}}
{{dsc | {{tt|milli}} | {{c|std::ratio&lt;1, 1000&gt;}}}}
{{dsc | {{tt|centi}} | {{c|std::ratio&lt;1, 100&gt;}}}}
{{dsc | {{tt|deci}}  | {{c|std::ratio&lt;1, 10&gt;}}}}
{{dsc | {{tt|deca}}  | {{c|std::ratio&lt;10, 1&gt;}}}}
{{dsc | {{tt|hecto}} | {{c|std::ratio&lt;100, 1&gt;}}}}
{{dsc | {{tt|kilo}}  | {{c|std::ratio&lt;1000, 1&gt;}}}}
{{dsc | {{tt|mega}}  | {{c|std::ratio&lt;1000000, 1&gt;}}}}
{{dsc | {{tt|giga}}  | {{c|std::ratio&lt;1000000000, 1&gt;}}}}
{{dsc | {{tt|tera}}  | {{c|std::ratio&lt;1000000000000, 1&gt;}}}}
{{dsc | {{tt|peta}}  | {{c|std::ratio&lt;1000000000000000, 1&gt;}}}}
{{dsc | {{tt|exa}}   | {{c|std::ratio&lt;1000000000000000000, 1&gt;}}}}
{{dsc | {{tt|zetta}} | {{c|std::ratio&lt;1000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc | {{tt|yotta}} | {{c|std::ratio&lt;1000000000000000000000000, 1&gt;}}, if {{lc|std::intmax_t}} can represent the numerator}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{c|std::ratio&lt;num, den&gt;}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr intmax_t}} num | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom)}} }}
{{dsc mem sconst | nolink=true | {{dsc small|constexpr intmax_t}} den | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|abs(Denom) / gcd(Num, Denom)}} }}
{{dsc end}}

[[de:cpp/numeric/ratio/ratio]]
[[es:cpp/numeric/ratio/ratio]]
[[fr:cpp/numeric/ratio/ratio]]
[[it:cpp/numeric/ratio/ratio]]
[[ja:cpp/numeric/ratio/ratio]]
[[pt:cpp/numeric/ratio/ratio]]
[[ru:cpp/numeric/ratio/ratio]]
[[zh:cpp/numeric/ratio/ratio]]</text>
      <sha1>gq65pli3m1fylei4tfxwvxlvu0ou3p5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio add</title>
    <ns>0</ns>
    <id>4983</id>
    <revision>
      <id>50416</id>
      <parentid>42341</parentid>
      <timestamp>2013-06-01T03:24:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1622">{{cpp/title | ratio_add}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
using ratio_add = /* unspecified */;
}}
{{dcl end}}

The template alias {{tt|std::ratio_add}} denotes the result of adding two exact rational fractions represented by the {{lc|std::ratio}} instances {{tt|R1}} and {{tt|R2}}. The result a {{lc|std::ratio}} instance {{tt|std::ratio&lt;Num, Denom&gt;}} where {{c|1=Num == R1::num * R2::den + R2::num * R1::den}} and {{c|1=Denom == R1::den * R2::den}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{c|std::ratio&lt;num, den&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | num | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom)}} }}
{{dsc mem sconst | nolink=true | den | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|abs(Denom) / gcd(Num, Denom)}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    typedef std::ratio&lt;2, 3&gt; two_third;
    typedef std::ratio&lt;1, 6&gt; one_sixth;

    typedef std::ratio_add&lt;two_third, one_sixth&gt; sum;
    std::cout &lt;&lt; &quot;2/3 + 1/6 = &quot; &lt;&lt; sum::num &lt;&lt; '/' &lt;&lt; sum::den &lt;&lt; '\n';
}
 | output=
2/3 + 1/6 = 5/6
}}

[[de:cpp/numeric/ratio/ratio add]]
[[es:cpp/numeric/ratio/ratio add]]
[[fr:cpp/numeric/ratio/ratio add]]
[[it:cpp/numeric/ratio/ratio add]]
[[ja:cpp/numeric/ratio/ratio add]]
[[pt:cpp/numeric/ratio/ratio add]]
[[ru:cpp/numeric/ratio/ratio add]]
[[zh:cpp/numeric/ratio/ratio add]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio divide</title>
    <ns>0</ns>
    <id>4996</id>
    <revision>
      <id>50417</id>
      <parentid>42332</parentid>
      <timestamp>2013-06-01T03:24:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1633">{{cpp/title | ratio_divide}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
using ratio_divide = /* unspecified */;
}}
{{dcl end}}

The template alias {{tt|std::ratio_divide}} denotes the result of dividing two exact rational fractions represented by the {{lc|std::ratio}} instances {{tt|R1}} and {{tt|R2}}. The result a {{lc|std::ratio}} instance {{tt|std::ratio&lt;Num, Denom&gt;}} where {{c|1=Num == R1::num * R2::den}} and {{c|1=Denom == R1::den * R2::num}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{c|std::ratio&lt;num, den&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | num | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom)}} }}
{{dsc mem sconst | nolink=true | den | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|abs(Denom) / gcd(Num, Denom)}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    typedef std::ratio&lt;2, 3&gt; two_third;
    typedef std::ratio&lt;1, 6&gt; one_sixth;
    typedef std::ratio_divide&lt;two_third, one_sixth&gt; r;
    std::cout &lt;&lt; &quot;2/3 / 1/6 = &quot; &lt;&lt; r::num &lt;&lt; '/' &lt;&lt; r::den &lt;&lt; '\n';
}
 | output=
2/3 / 1/6 = 4/1
}}

[[de:cpp/numeric/ratio/ratio divide]]
[[es:cpp/numeric/ratio/ratio divide]]
[[fr:cpp/numeric/ratio/ratio divide]]
[[it:cpp/numeric/ratio/ratio divide]]
[[ja:cpp/numeric/ratio/ratio divide]]
[[pt:cpp/numeric/ratio/ratio divide]]
[[ru:cpp/numeric/ratio/ratio divide]]
[[zh:cpp/numeric/ratio/ratio divide]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio equal</title>
    <ns>0</ns>
    <id>4997</id>
    <revision>
      <id>50418</id>
      <parentid>42325</parentid>
      <timestamp>2013-06-01T03:24:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1277">{{cpp/title | ratio_equal}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_equal : std::integral_constant;
}}
{{dcl end}}

If the ratios R1 and R2 are equal, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num == R2::num &amp;&amp; R1::den == R2::den}} }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class R1, class R2 &gt;
struct ratio_equal : public std::integral_constant &lt;
                                 bool,
                                 R1::num == R2::num &amp;&amp; R1::den == R2::den
                            &gt; {};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    if(std::ratio_equal&lt;std::ratio&lt;2,3&gt;, std::ratio&lt;4,6&gt;&gt;::value) {
        std::cout &lt;&lt; &quot;2/3 == 4/6\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;2/3 != 4/6\n&quot;;
    }
}
 | output=
2/3 == 4/6
}}

[[de:cpp/numeric/ratio/ratio equal]]
[[es:cpp/numeric/ratio/ratio equal]]
[[fr:cpp/numeric/ratio/ratio equal]]
[[it:cpp/numeric/ratio/ratio equal]]
[[ja:cpp/numeric/ratio/ratio equal]]
[[pt:cpp/numeric/ratio/ratio equal]]
[[ru:cpp/numeric/ratio/ratio equal]]
[[zh:cpp/numeric/ratio/ratio equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio greater</title>
    <ns>0</ns>
    <id>5472</id>
    <revision>
      <id>50419</id>
      <parentid>42317</parentid>
      <timestamp>2013-06-01T03:24:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="865">{{cpp/title | ratio_greater}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_greater : std::integral_constant;
}}
{{dcl end}}

If the ratio {{tt|R1}} is greater than than the ratio {{tt|R2}}, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num * R2::den &gt; R2::num * R1::den}}, or equivalent expression that avoids overflow }}

===Example===
{{example |
 | code=
 | output=
}}

[[de:cpp/numeric/ratio/ratio greater]]
[[es:cpp/numeric/ratio/ratio greater]]
[[fr:cpp/numeric/ratio/ratio greater]]
[[it:cpp/numeric/ratio/ratio greater]]
[[ja:cpp/numeric/ratio/ratio greater]]
[[pt:cpp/numeric/ratio/ratio greater]]
[[ru:cpp/numeric/ratio/ratio greater]]
[[zh:cpp/numeric/ratio/ratio greater]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio greater equal</title>
    <ns>0</ns>
    <id>5474</id>
    <revision>
      <id>50420</id>
      <parentid>42308</parentid>
      <timestamp>2013-06-01T03:25:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="933">{{cpp/title | ratio_greater_equal}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_greater_equal : std::integral_constant;
}}
{{dcl end}}

If the ratio {{tt|R1}} is greater than or equal to the ratio {{tt|R2}}, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num * R2::den &gt;= R2::num * R1::den}}, or equivalent expression that avoids overflow }}

===Example===
{{example |
 | code=
 | output=
}}

[[de:cpp/numeric/ratio/ratio greater equal]]
[[es:cpp/numeric/ratio/ratio greater equal]]
[[fr:cpp/numeric/ratio/ratio greater equal]]
[[it:cpp/numeric/ratio/ratio greater equal]]
[[ja:cpp/numeric/ratio/ratio greater equal]]
[[pt:cpp/numeric/ratio/ratio greater equal]]
[[ru:cpp/numeric/ratio/ratio greater equal]]
[[zh:cpp/numeric/ratio/ratio greater equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio less</title>
    <ns>0</ns>
    <id>4999</id>
    <revision>
      <id>50421</id>
      <parentid>42301</parentid>
      <timestamp>2013-06-01T03:25:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="999">{{cpp/title | ratio_less}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_less : std::integral_constant;
}}
{{dcl end}}

If the ratio R1 is less than the ratio R2, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num * R2::den &lt; R2::num * R1::den}}, or equivalent expression that avoids overflow }}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    if (std::ratio_less&lt;std::ratio&lt;23,37&gt;, std::ratio&lt;57,90&gt;&gt;::value) {
        std::cout &lt;&lt; &quot;23/37 &lt; 57/90\n&quot;;
    }
}
 | output=
23/37 &lt; 57/90
}}

[[de:cpp/numeric/ratio/ratio less]]
[[es:cpp/numeric/ratio/ratio less]]
[[fr:cpp/numeric/ratio/ratio less]]
[[it:cpp/numeric/ratio/ratio less]]
[[ja:cpp/numeric/ratio/ratio less]]
[[pt:cpp/numeric/ratio/ratio less]]
[[ru:cpp/numeric/ratio/ratio less]]
[[zh:cpp/numeric/ratio/ratio less]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio less equal</title>
    <ns>0</ns>
    <id>5473</id>
    <revision>
      <id>50422</id>
      <parentid>42294</parentid>
      <timestamp>2013-06-01T03:25:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="900">{{cpp/title | ratio_less_equal}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_less_equal : std::integral_constant;
}}
{{dcl end}}

If the ratio {{tt|R1}} is less than or equal to the ratio {{tt|R2}}, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num * R2::den &lt;= R2::num * R1::den}}, or equivalent expression that avoids overflow }}

===Example===
{{example |
 | code=
 | output=
}}

[[de:cpp/numeric/ratio/ratio less equal]]
[[es:cpp/numeric/ratio/ratio less equal]]
[[fr:cpp/numeric/ratio/ratio less equal]]
[[it:cpp/numeric/ratio/ratio less equal]]
[[ja:cpp/numeric/ratio/ratio less equal]]
[[pt:cpp/numeric/ratio/ratio less equal]]
[[ru:cpp/numeric/ratio/ratio less equal]]
[[zh:cpp/numeric/ratio/ratio less equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio multiply</title>
    <ns>0</ns>
    <id>4995</id>
    <revision>
      <id>51059</id>
      <parentid>42286</parentid>
      <timestamp>2013-06-01T03:49:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1660">{{cpp/title | ratio_multiply}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
using ratio_multiply = /* unspecified */;
}}
{{dcl end}}

The template alias {{tt|std::ratio_multiply}} denotes the result of multiplying two exact rational fractions represented by the {{lc|std::ratio}} instances {{tt|R1}} and {{tt|R2}}. The result a {{lc|std::ratio}} instance {{tt|std::ratio&lt;Num, Denom&gt;}} where {{c|1=Num == R1::num * R2::num}} and {{c|1=Denom == R1::den * R2::den}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{c|std::ratio&lt;num, den&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | num | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom)}} }}
{{dsc mem sconst | nolink=true | den | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|abs(Denom) / gcd(Num, Denom)}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    typedef std::ratio&lt;2, 3&gt; two_third;
    typedef std::ratio&lt;1, 6&gt; one_sixth;
    typedef std::ratio_multiply&lt;two_third, one_sixth&gt; r;
    std::cout &lt;&lt; &quot;2/3 * 1/6 = &quot; &lt;&lt; r::num &lt;&lt; '/' &lt;&lt; r::den &lt;&lt; '\n';
}
 | output=
2/3 * 1/6 = 1/9
}}

[[de:cpp/numeric/ratio/ratio multiply]]
[[es:cpp/numeric/ratio/ratio multiply]]
[[fr:cpp/numeric/ratio/ratio multiply]]
[[it:cpp/numeric/ratio/ratio multiply]]
[[ja:cpp/numeric/ratio/ratio multiply]]
[[pt:cpp/numeric/ratio/ratio multiply]]
[[ru:cpp/numeric/ratio/ratio multiply]]
[[zh:cpp/numeric/ratio/ratio multiply]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio not equal</title>
    <ns>0</ns>
    <id>4998</id>
    <revision>
      <id>51060</id>
      <parentid>42277</parentid>
      <timestamp>2013-06-01T03:49:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1302">{{cpp/title | ratio_not_equal}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
struct ratio_not_equal : std::integral_constant;
}}
{{dcl end}}

If the ratios R1 and R2 are not equal, provides the member constant {{tt|value}} equal {{c|true}}. Otherwise, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{c|1=R1::num != R2::num {{!!}} R1::den != R2::den}} }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class R1, class R2 &gt;
struct ratio_not_equal : std::integral_constant &lt;
                              bool,
                              !std::ratio_equal&lt;R1, R2&gt;
                         &gt; {};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    if(std::ratio_not_equal&lt;std::ratio&lt;2,3&gt;, std::ratio&lt;1,3&gt;&gt;::value) {
        std::cout &lt;&lt; &quot;2/3 != 1/3\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;2/3 == 1/3\n&quot;;
    }
}
 | output=
2/3 != 1/3
}}

[[de:cpp/numeric/ratio/ratio not equal]]
[[es:cpp/numeric/ratio/ratio not equal]]
[[fr:cpp/numeric/ratio/ratio not equal]]
[[it:cpp/numeric/ratio/ratio not equal]]
[[ja:cpp/numeric/ratio/ratio not equal]]
[[pt:cpp/numeric/ratio/ratio not equal]]
[[ru:cpp/numeric/ratio/ratio not equal]]
[[zh:cpp/numeric/ratio/ratio not equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/ratio/ratio subtract</title>
    <ns>0</ns>
    <id>4994</id>
    <revision>
      <id>51061</id>
      <parentid>42267</parentid>
      <timestamp>2013-06-01T03:49:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1690">{{cpp/title | ratio_subtract}}
{{cpp/numeric/ratio/navbar}}
{{dcl begin}}
{{dcl header | ratio}}
{{dcl | 1=
template&lt; class R1, class R2 &gt;
using ratio_subtract = /* unspecified */;
}}
{{dcl end}}

The template alias {{tt|std::ratio_subtract}} denotes the result of subtracting two exact rational fractions represented by the {{lc|std::ratio}} instances {{tt|R1}} and {{tt|R2}}. The result a {{lc|std::ratio}} instance {{tt|std::ratio&lt;Num, Denom&gt;}} where {{c|1=Num == R1::num * R2::den - R2::num * R1::den}} and {{c|1=Denom == R1::den * R2::den}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{c|std::ratio&lt;num, den&gt;}}}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | nolink=true | num | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|sign(Num) * sign(Denom) * abs(Num) / gcd(Num, Denom)}} }}
{{dsc mem sconst | nolink=true | den | {{c|constexpr}} value of type {{lc|std::intmax_t}} equal to {{tt|abs(Denom) / gcd(Num, Denom)}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;ratio&gt;

int main()
{
    typedef std::ratio&lt;2, 3&gt; two_third;
    typedef std::ratio&lt;1, 6&gt; one_sixth;

    typedef std::ratio_subtract&lt;two_third, one_sixth&gt; diff;
    std::cout &lt;&lt; &quot;2/3 - 1/6 = &quot; &lt;&lt; diff::num &lt;&lt; '/' &lt;&lt; diff::den &lt;&lt; '\n';
}
 | output=
2/3 - 1/6 = 1/2
}}

[[de:cpp/numeric/ratio/ratio subtract]]
[[es:cpp/numeric/ratio/ratio subtract]]
[[fr:cpp/numeric/ratio/ratio subtract]]
[[it:cpp/numeric/ratio/ratio subtract]]
[[ja:cpp/numeric/ratio/ratio subtract]]
[[pt:cpp/numeric/ratio/ratio subtract]]
[[ru:cpp/numeric/ratio/ratio subtract]]
[[zh:cpp/numeric/ratio/ratio subtract]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray</title>
    <ns>0</ns>
    <id>2704</id>
    <revision>
      <id>72322</id>
      <parentid>65352</parentid>
      <timestamp>2014-08-08T14:37:32Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>use {{concept|NumericType}} instead of listing the requirements here</comment>
      <text xml:space="preserve" bytes="4255">{{cpp/title|valarray}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray |
template&lt; class T &gt;
class valarray;
}}

{{lc|std::valarray}} is the class for representing and manipulating arrays of values. It supports element-wise mathematical operations and various forms of generalized subscript operators, slicing and indirect access.

===Notes===
{{lc|std::valarray}} and helper classes are defined to be free of certain forms of aliasing, thus allowing operations on these classes to be optimized similar to the effect of the keyword {{tt|restrict}} in the C programming language. In addition, functions and operators that take {{tt|valarray}} arguments are allowed to return proxy objects to make it possible for the compiler to optimize an expression such as {{c|1=v1 = a*v2 + v3;}} as a single loop that executes {{c|1=v1[i] = a*v2[i] + v3[i];}} avoiding any temporaries or multiple passes. However, [[enwiki::Expression templates|expression templates]] make the same optimization technique available for any C++ container, and the majority of numeric libraries prefer expression templates to valarrays for flexibility. Some C++ standard library implementations use expression templates to implement efficient operations on {{tt|std::valarray}} (e.g. GNU libstdc++ and LLVM libc++). Only rarely are valarrays optimized any further, as in e.g. [http://software.intel.com/sites/products/documentation/doclib/iss/2013/compiler/cpp-lin/GUID-A2AEF527-422D-4B7C-A411-6B9CE4D0DBC7.htm Intel Parallel Studio].

===Template parameters===
{{par begin}}
{{par | T |  the type of the elements. The type must meet the {{concept|NumericType}} requirements}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc valarray}}
{{dsc inc | cpp/numeric/valarray/dsc ~valarray}}
{{dsc inc | cpp/numeric/valarray/dsc operator{{=}}}}
{{dsc inc | cpp/numeric/valarray/dsc operator_at}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith2}}
{{dsc inc | cpp/numeric/valarray/dsc swap}}
{{dsc inc | cpp/numeric/valarray/dsc size}}
{{dsc inc | cpp/numeric/valarray/dsc resize}}
{{dsc inc | cpp/numeric/valarray/dsc sum}}
{{dsc inc | cpp/numeric/valarray/dsc min}}
{{dsc inc | cpp/numeric/valarray/dsc max}}
{{dsc inc | cpp/numeric/valarray/dsc shift}}
{{dsc inc | cpp/numeric/valarray/dsc cshift}}
{{dsc inc | cpp/numeric/valarray/dsc apply}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc swap2}}
{{dsc inc | cpp/numeric/valarray/dsc begin2}}
{{dsc inc | cpp/numeric/valarray/dsc end2}}
{{dsc inc | cpp/numeric/valarray/dsc operator_arith3}}
{{dsc inc | cpp/numeric/valarray/dsc operator_cmp}}
{{dsc inc | cpp/numeric/valarray/dsc abs}}

{{dsc h2 | Exponential functions}}
{{dsc inc | cpp/numeric/valarray/dsc exp}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc inc | cpp/numeric/valarray/dsc log10}}

{{dsc h2 | Power functions}}
{{dsc inc | cpp/numeric/valarray/dsc pow}}
{{dsc inc | cpp/numeric/valarray/dsc sqrt}}

{{dsc h2 | Trigonometric functions}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}

{{dsc h2 | Hyperbolic functions}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc slice}}
{{dsc inc | cpp/numeric/valarray/dsc slice_array}}
{{dsc inc | cpp/numeric/valarray/dsc gslice}}
{{dsc inc | cpp/numeric/valarray/dsc gslice_array}}
{{dsc inc | cpp/numeric/valarray/dsc mask_array}}
{{dsc inc | cpp/numeric/valarray/dsc indirect_array}}
{{dsc end}}

[[de:cpp/numeric/valarray]]
[[es:cpp/numeric/valarray]]
[[fr:cpp/numeric/valarray]]
[[it:cpp/numeric/valarray]]
[[ja:cpp/numeric/valarray]]
[[pt:cpp/numeric/valarray]]
[[ru:cpp/numeric/valarray]]
[[zh:cpp/numeric/valarray]]</text>
      <sha1>hgdt50rfpg5vcngy384afsoz7gb8zj4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/abs</title>
    <ns>0</ns>
    <id>4316</id>
    <revision>
      <id>71268</id>
      <parentid>58776</parentid>
      <timestamp>2014-06-09T03:28:25Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>use templates</comment>
      <text xml:space="preserve" bytes="1462">{{cpp/title|abs{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; abs( const valarray&lt;T&gt;&amp; va );
}}

Computes absolute value of each element in the value array.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing absolute values of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|abs}}

{{cpp/numeric/valarray/notes ret|abs}}

===Possible implementation===
{{eq fun | 1=
template&lt; class T &gt;
valarray&lt;T&gt; abs( const valarray&lt;T&gt;&amp; va )
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = abs(i);
    }
    return other; // proxy object may be returned
}
}}

===Example===
{{example
|code=
#include &lt;valarray&gt;
#include &lt;iostream&gt;

int main()
{
    std::valarray&lt;int&gt; v{1, -2, 3, -4, 5, -6, 7, -8};
    std::valarray&lt;int&gt; v2 = std::abs(v);
    for(auto n : v2) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
|output=
1 2 3 4 5 6 7 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc abs}}
{{dsc inc | cpp/numeric/math/dsc fabs}}
{{dsc inc | cpp/numeric/complex/dsc abs}}
{{dsc end}}

[[de:cpp/numeric/valarray/abs]]
[[es:cpp/numeric/valarray/abs]]
[[fr:cpp/numeric/valarray/abs]]
[[it:cpp/numeric/valarray/abs]]
[[ja:cpp/numeric/valarray/abs]]
[[pt:cpp/numeric/valarray/abs]]
[[ru:cpp/numeric/valarray/abs]]
[[zh:cpp/numeric/valarray/abs]]</text>
      <sha1>22e8tjpji6apfy2r7evlpz85oo5ugwu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/acos</title>
    <ns>0</ns>
    <id>4327</id>
    <revision>
      <id>71091</id>
      <parentid>51064</parentid>
      <timestamp>2014-06-05T20:31:33Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1325">{{cpp/title|acos{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; acos( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes arc cosine of the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing arc cosines of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|acos}}

{{cpp/numeric/valarray/notes ret|acos}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; acos(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = acos(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc inc | cpp/numeric/math/dsc acos}}
{{dsc inc | cpp/numeric/complex/dsc acos}}
{{dsc end}}

[[de:cpp/numeric/valarray/acos]]
[[es:cpp/numeric/valarray/acos]]
[[fr:cpp/numeric/valarray/acos]]
[[it:cpp/numeric/valarray/acos]]
[[ja:cpp/numeric/valarray/acos]]
[[pt:cpp/numeric/valarray/acos]]
[[ru:cpp/numeric/valarray/acos]]
[[zh:cpp/numeric/valarray/acos]]</text>
      <sha1>5ng4cf7tx9e73ro7e5vvciw3sc7kzvt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/apply</title>
    <ns>0</ns>
    <id>4559</id>
    <revision>
      <id>58777</id>
      <parentid>51065</parentid>
      <timestamp>2013-06-01T06:21:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1394">{{cpp/numeric/valarray/title|apply}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | 
valarray&lt;T&gt; apply( T func(T) ) const;
}}
{{dcl |
valarray&lt;T&gt; apply( T func(const T&amp;) ) const;
}}
{{dcl end}}

Returns a new valarray of the same size with values which are acquired by applying function {{tt|func}} to the previous values of the elements.

===Parameters===
{{par begin}}
{{par | func | function to apply to the values}}
{{par end}}

===Return value===
The resulting valarray with values acquired by applying function {{tt|func}}.

===Notes===
{{cpp/numeric/valarray/notes_ret}}

===Example===
{{example| calculates and prints the first 10 factorials
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;
#include &lt;cmath&gt;

int main()
{
    std::valarray&lt;int&gt; v = {1,2,3,4,5,6,7,8,9,10};
    v = v.apply([](int n)-&gt;int {
                    return std::round(std::tgamma(n+1));
                });
    for(auto n : v) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
1 2 6 24 120 720 5040 40320 362880 3628800
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc for_each}}
{{dsc end}}

[[de:cpp/numeric/valarray/apply]]
[[es:cpp/numeric/valarray/apply]]
[[fr:cpp/numeric/valarray/apply]]
[[it:cpp/numeric/valarray/apply]]
[[ja:cpp/numeric/valarray/apply]]
[[pt:cpp/numeric/valarray/apply]]
[[ru:cpp/numeric/valarray/apply]]
[[zh:cpp/numeric/valarray/apply]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/asin</title>
    <ns>0</ns>
    <id>4325</id>
    <revision>
      <id>71097</id>
      <parentid>71090</parentid>
      <timestamp>2014-06-05T20:49:27Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>-</comment>
      <text xml:space="preserve" bytes="1322">{{cpp/title|asin{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; asin( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes arc sine of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing arc sines of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|asin}}

{{cpp/numeric/valarray/notes ret|asin}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; asin(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = asin(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc inc | cpp/numeric/math/dsc asin}}
{{dsc inc | cpp/numeric/complex/dsc asin}}
{{dsc end}}

[[de:cpp/numeric/valarray/asin]]
[[es:cpp/numeric/valarray/asin]]
[[fr:cpp/numeric/valarray/asin]]
[[it:cpp/numeric/valarray/asin]]
[[ja:cpp/numeric/valarray/asin]]
[[pt:cpp/numeric/valarray/asin]]
[[ru:cpp/numeric/valarray/asin]]
[[zh:cpp/numeric/valarray/asin]]</text>
      <sha1>0n8pn9hez1lx61m2v6x6o9j3z8k8mrv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/atan</title>
    <ns>0</ns>
    <id>4326</id>
    <revision>
      <id>71092</id>
      <parentid>51067</parentid>
      <timestamp>2014-06-05T20:34:05Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1328">{{cpp/title|atan{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; atan( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes arc tangent of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing arc tangents of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|atan}}

{{cpp/numeric/valarray/notes ret|atan}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; atan(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = atan(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc atan2}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc inc | cpp/numeric/math/dsc atan}}
{{dsc inc | cpp/numeric/complex/dsc atan}}
{{dsc end}}

[[de:cpp/numeric/valarray/atan]]
[[es:cpp/numeric/valarray/atan]]
[[fr:cpp/numeric/valarray/atan]]
[[it:cpp/numeric/valarray/atan]]
[[ja:cpp/numeric/valarray/atan]]
[[pt:cpp/numeric/valarray/atan]]
[[ru:cpp/numeric/valarray/atan]]
[[zh:cpp/numeric/valarray/atan]]</text>
      <sha1>gz3xoa6bpijf0en9pwyi1g2u2buytna</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/atan2</title>
    <ns>0</ns>
    <id>9037</id>
    <revision>
      <id>71266</id>
      <parentid>71093</parentid>
      <timestamp>2014-06-09T03:13:49Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+link to arg</comment>
      <text xml:space="preserve" bytes="1800">{{cpp/title|atan2{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl | num=1 |
template&lt; class T &gt; 
valarray&lt;T&gt; atan2( const valarray&lt;T&gt;&amp; y, const valarray&lt;T&gt;&amp; x );
}}
{{dcl | num=2 |
template&lt; class T &gt; 
valarray&lt;T&gt; atan2( const valarray&lt;T&gt;&amp; y, const T&amp; vx );
}}
{{dcl | num=3 |
template&lt; class T &gt; 
valarray&lt;T&gt; atan2( const T&amp; vy, const valarray&lt;T&gt;&amp; x );
}}
{{dcl end}}

Computes the inverse tangent of {{tt|y/x}} using the signs of arguments to correctly determine quadrant.

@1@ Computes the inverse tangent of each pair of corresponding values from {{tt|y}} and {{tt|x}}.

The behavior is undefined if {{c|1=x.size() != y.size()}}.
@2@ Computes the inverse tangent of {{tt|vx}} and each value in the numeric array {{tt|y}}.
@3@ Computes the inverse tangent of {{tt|vy}} and each value in the numeric array {{tt|x}}.

===Parameters===
{{par begin}}
{{par | x, y | numeric arrays to compute inverse tangent of}}
{{par | vy, vx | values to compute inverse tangent of}}
{{par end}}

===Return value===
A numeric array containing the results of computation of inverse tangent.

===Notes===
{{cpp/numeric/valarray/notes unq|atan2}}

{{cpp/numeric/valarray/notes ret|atan2}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc atan2}}
{{dsc inc | cpp/numeric/complex/dsc arg}}
{{dsc end}}

[[de:cpp/numeric/valarray/atan2]]
[[es:cpp/numeric/valarray/atan2]]
[[fr:cpp/numeric/valarray/atan2]]
[[it:cpp/numeric/valarray/atan2]]
[[ja:cpp/numeric/valarray/atan2]]
[[pt:cpp/numeric/valarray/atan2]]
[[ru:cpp/numeric/valarray/atan2]]
[[zh:cpp/numeric/valarray/atan2]]</text>
      <sha1>p3c55usvmzm9ktbdamh5hxnn6xyduem</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/begin2</title>
    <ns>0</ns>
    <id>9026</id>
    <revision>
      <id>71047</id>
      <parentid>64403</parentid>
      <timestamp>2014-06-05T01:12:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/specialization/overload</comment>
      <text xml:space="preserve" bytes="1910">{{cpp/title | begin&lt;small&gt;(std::valarray)&lt;/small&gt;}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; 
/*unspecified1*/ begin( valarray&lt;T&gt;&amp; v );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; 
/*unspecified2*/ begin( const valarray&lt;T&gt;&amp; v );
}}
{{dcl end}}

The overload of {{lc|std::begin}} for {{tt|valarray}} returns an iterator of unspecified type referring to the first element in the numeric array. 

@1@ The return type meets the requirements of mutable {{concept|RandomAccessIterator}}.
@2@ The return type meets the requirements of constant {{concept|RandomAccessIterator}}.

The iterator obtained from this function is invalidated when the member function {{lc|resize()}} is called on the array {{tt|v}} or when the lifetime of {{tt|v}} ends, whichever comes first.

===Parameters===
{{par begin}}
{{par | v | a numeric array}}
{{par end}} 

===Return value===
Iterator to the first value in the numeric array.

===Exceptions===
(none)

===Notes===
Unlike other functions that take {{tt|std::valarray}} arguments, {{tt|begin()}} cannot accept the replacement types (such as the types produced by expression templates) that may be returned from expressions involving valarrays: {{c|std::begin(v1 + v2)}} is not portable, {{c|std::begin(std::valarray&lt;T&gt;(v1 + v2))}} has to be used instead.

The intent of this function is to allow [[cpp/language/range-for|range for loops]] to work with valarrays, not to provide container semantics.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc end2}}
{{dsc end}}

[[de:cpp/numeric/valarray/begin2]]
[[es:cpp/numeric/valarray/begin2]]
[[fr:cpp/numeric/valarray/begin2]]
[[it:cpp/numeric/valarray/begin2]]
[[ja:cpp/numeric/valarray/begin2]]
[[pt:cpp/numeric/valarray/begin2]]
[[ru:cpp/numeric/valarray/begin2]]
[[zh:cpp/numeric/valarray/begin2]]</text>
      <sha1>kdzq7j3ge82doisnzu0170k1mso3733</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/cos</title>
    <ns>0</ns>
    <id>4323</id>
    <revision>
      <id>71088</id>
      <parentid>51070</parentid>
      <timestamp>2014-06-05T20:24:12Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1256">{{cpp/title|cos{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; cos( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes cosine of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing cosines of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|cos}}

{{cpp/numeric/valarray/notes ret|cos}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; cos(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = cos(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc acos}}
{{dsc inc | cpp/numeric/math/dsc cos}}
{{dsc inc | cpp/numeric/complex/dsc cos}}
{{dsc end}}

[[de:cpp/numeric/valarray/cos]]
[[es:cpp/numeric/valarray/cos]]
[[fr:cpp/numeric/valarray/cos]]
[[it:cpp/numeric/valarray/cos]]
[[ja:cpp/numeric/valarray/cos]]
[[pt:cpp/numeric/valarray/cos]]
[[ru:cpp/numeric/valarray/cos]]
[[zh:cpp/numeric/valarray/cos]]</text>
      <sha1>7g7gfap6omg2kixgqo0ovf9qfgv1oea</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/cosh</title>
    <ns>0</ns>
    <id>9039</id>
    <revision>
      <id>71095</id>
      <parentid>58782</parentid>
      <timestamp>2014-06-05T20:43:39Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1250">{{cpp/title|cosh{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; cosh( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes hyperbolic cosine of the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing hyperbolic cosine of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|cosh}}

{{cpp/numeric/valarray/notes ret|cosh}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; cosh(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = cosh(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc cosh}}
{{dsc inc | cpp/numeric/complex/dsc cosh}}
{{dsc end}}

[[de:cpp/numeric/valarray/cosh]]
[[es:cpp/numeric/valarray/cosh]]
[[fr:cpp/numeric/valarray/cosh]]
[[it:cpp/numeric/valarray/cosh]]
[[ja:cpp/numeric/valarray/cosh]]
[[pt:cpp/numeric/valarray/cosh]]
[[ru:cpp/numeric/valarray/cosh]]
[[zh:cpp/numeric/valarray/cosh]]</text>
      <sha1>mq89mi80h0q12l2c51mhqkg09xrszqk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/cshift</title>
    <ns>0</ns>
    <id>4558</id>
    <revision>
      <id>58783</id>
      <parentid>51072</parentid>
      <timestamp>2013-06-01T06:21:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1027">{{cpp/numeric/valarray/title|cshift}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
valarray&lt;T&gt; cshift( int count ) const;
}}

Returns a new valarray of the same size with elements whose positions are shifted circularly by {{tt|count}} elements. The new position of each element is {{math|(i−count) mod s}} where {{math|i}} is the previous position and {{math|s}} is {{c|size()}}.

===Parameters===
{{par begin}}
{{par | count | number of positions to shift the elements by}}
{{par end}}

===Return value===
The resulting valarray with circularly shifted elements.

===Notes===
{{cpp/numeric/valarray/notes_ret}}

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc shift}}
{{dsc end}}

[[de:cpp/numeric/valarray/cshift]]
[[es:cpp/numeric/valarray/cshift]]
[[fr:cpp/numeric/valarray/cshift]]
[[it:cpp/numeric/valarray/cshift]]
[[ja:cpp/numeric/valarray/cshift]]
[[pt:cpp/numeric/valarray/cshift]]
[[ru:cpp/numeric/valarray/cshift]]
[[zh:cpp/numeric/valarray/cshift]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/end2</title>
    <ns>0</ns>
    <id>9027</id>
    <revision>
      <id>71052</id>
      <parentid>64404</parentid>
      <timestamp>2014-06-05T01:16:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/specialization/overload</comment>
      <text xml:space="preserve" bytes="1913">{{cpp/title | end&lt;small&gt;(std::valarray)&lt;/small&gt;}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; 
/*unspecified1*/ end( valarray&lt;T&gt;&amp; v );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; 
/*unspecified2*/ end( const valarray&lt;T&gt;&amp; v );
}}
{{dcl end}}

The overload of {{lc|std::begin}} for {{tt|valarray}} returns an iterator of unspecified type referring to the one past the last element in the numeric array. 

@1@ The return type meets the requirements of mutable {{concept|RandomAccessIterator}}.
@2@ The return type meets the requirements of constant {{concept|RandomAccessIterator}}.

The iterator obtained from this function template is invalidated when the member function {{lc|resize()}} is called on the array {{tt|v}} or when the lifetime of {{tt|v}} ends, whichever comes first.

===Parameters===
{{par begin}}
{{par | v | a numeric array}}
{{par end}} 

===Return value===
Iterator to one past the last value in the numeric array.

===Exceptions===
(none)

===Notes===
Unlike other functions that take {{tt|std::valarray}} arguments, {{tt|end()}} cannot accept the replacement types (such as the types produced by expression templates) that may be returned from expressions involving valarrays: {{c|std::end(v1 + v2)}} is not portable, {{c|std::end(std::valarray&lt;T&gt;(v1 + v2))}} has to be used instead.

The intent of this function is to allow [[cpp/language/range-for|range for loops]] to work with valarrays, not to provide container semantics.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc begin2}}
{{dsc end}}

[[de:cpp/numeric/valarray/end2]]
[[es:cpp/numeric/valarray/end2]]
[[fr:cpp/numeric/valarray/end2]]
[[it:cpp/numeric/valarray/end2]]
[[ja:cpp/numeric/valarray/end2]]
[[pt:cpp/numeric/valarray/end2]]
[[ru:cpp/numeric/valarray/end2]]
[[zh:cpp/numeric/valarray/end2]]</text>
      <sha1>dk01neaxg4eom0gqred7vhm4c8jjna3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/exp</title>
    <ns>0</ns>
    <id>4317</id>
    <revision>
      <id>71103</id>
      <parentid>71102</parentid>
      <timestamp>2014-06-05T21:03:14Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>-</comment>
      <text xml:space="preserve" bytes="1823">{{cpp/title|exp{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; exp( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes ''e'' raised to the power equal to the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing ''e'' raised by the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|exp}}

{{cpp/numeric/valarray/notes ret|exp}}

===Possible implementation===
{{eq fun | 1=
template&lt; class T &gt;
valarray&lt;T&gt; exp( const valarray&lt;T&gt;&amp; va )
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = exp(i);
    }
    return other; // proxy object may be returned
}
}}

===Example===
{{example
| This example demonstrates the Euler's identity {{math|e{{su|p=i&amp;pi;}} {{=}} -1}} and the related exponents.
|code=
#include &lt;iostream&gt;
#include &lt;complex&gt;
#include &lt;valarray&gt;

int main()
{
    const double pi = std::acos(-1);
    std::valarray&lt;std::complex&lt;double&gt;&gt; v = {
        {0, 0}, {0, pi/2}, {0, pi}, {0, 3*pi/2}, {0, 2*pi}
    };
    std::valarray&lt;std::complex&lt;double&gt;&gt; v2 = std::exp(v);
    for(auto n : v2) {
        std::cout &lt;&lt; std::fixed &lt;&lt; n &lt;&lt; '\n';
    }
}
|output=
(1.000000,0.000000)
(0.000000,1.000000)
(-1.000000,0.000000)
(-0.000000,-1.000000)
(1.000000,-0.000000)
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc inc | cpp/numeric/math/dsc exp}}
{{dsc inc | cpp/numeric/complex/dsc exp}}
{{dsc end}}

[[de:cpp/numeric/valarray/exp]]
[[es:cpp/numeric/valarray/exp]]
[[fr:cpp/numeric/valarray/exp]]
[[it:cpp/numeric/valarray/exp]]
[[ja:cpp/numeric/valarray/exp]]
[[pt:cpp/numeric/valarray/exp]]
[[ru:cpp/numeric/valarray/exp]]
[[zh:cpp/numeric/valarray/exp]]</text>
      <sha1>kin5jypg8r3176e7vayq5lvd53diex5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice</title>
    <ns>0</ns>
    <id>5020</id>
    <revision>
      <id>61590</id>
      <parentid>61585</parentid>
      <timestamp>2013-06-06T06:25:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="5040">{{cpp/title|gslice}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray |
class gslice;
}}

{{tt|std::gslice}} is the selector class that identifies a subset of {{lc|std::valarray}} indices defined by a multi-level set of strides and sizes. Objects of type {{tt|std::gslice}} can be used as indices with valarray's {{tt|operator[]}} to select, for example, columns of a multidimensional array represented as a {{tt|valarray}}.

Given the starting value {{math|s}}, a list of strides {{math|i{{su|b=j}}}} and a list of sizes {{math|d{{su|b=j}}}}, a {{tt|std::gslice}} constructed from these values selects the set of indices {{math|k{{su|b=j}}{{=}}s+Σ{{su|b=j}}(i{{su|b=j}}d{{su|b=j}})}}.

For example, a gslice with starting index {{tt|3}}, strides {{tt|{19,4,1}}} and lengths {{tt|{2,4,3} }} generates the following set of indices:

{{cc|1=
3 + 0*19 + 0*4 + 0*1 = 3,
3 + 0*19 + 0*4 + 1*1 = 4,
3 + 0*19 + 0*4 + 2*1 = 5,
3 + 0*19 + 1*4 + 0*1 = 7,
3 + 0*19 + 1*4 + 1*1 = 8,
...
3 + 1*19 + 3*4 + 2*1 = 36}} 

It is possible to construct {{tt|std::gslice}} objects that select some indices more than once: if the above example used the strides {{tt|{1,1,1} }}, the indices would have been {{tt|{3, 4, 5, 4, 5, 6, ...} }}. Such gslices may only be used as arguments to the const version of {{tt|std::valarray::operator[]}}, otherwise the behavior is undefined.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/numeric/valarray/gslice | inlinemem=true | constructs a generic slice}}
{{dsc mem fun | cpp/numeric/valarray/gslice | title=start&lt;br/&gt;size&lt;br/&gt;stride | inlinemem=true | returns the parameters of the slice}}
{{dsc end}}

{{member | {{small|std::gslice::}}gslice |
{{dcl begin}}
{{dcl | 
gslice()
}}
{{dcl |
gslice( std::size_t start, const std::valarray&lt;std::size_t&gt;&amp; sizes,
                           const std::valarray&lt;std::size_t&gt;&amp; strides );
}}
{{dcl |
gslice( const gslice&amp; other );
}}
{{dcl end}}

Constructs a new generic slice.

@1@ Default constructor. Equivalent to {{c|gslice(0, std::valarray&lt;std::size_t&gt;(), std::valarray&lt;std::size_t&gt;())}}. This constructor exists only to allow construction of arrays of slices.

@2@ Constructs a new slice with parameters {{tt|start}}, {{tt|sizes}}, {{tt|strides}}.

@3@ Constructs a copy of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | start | the position of the first element}}
{{par | sizes | an array that defines the number of elements in each dimension}}
{{par | strides | an array that defines the number of positions between successive elements in each dimension}}
{{par | other | another slice to copy}}
{{par end}}
}}


{{member | {{small|std::slice::}}start, size, stride |
{{dcl begin}}
{{dcl | num=1 |
std::size_t start() const;
}}
{{dcl | num=2 |
std::valarray&lt;std::size_t&gt; size() const;
}}
{{dcl | num=3 |
std::valarray&lt;std::size_t&gt; stride() const;
}}
{{dcl end}}

Returns the parameters passed to the slice on construction - start, sizes and strides respectively.

===Parameters===
(none)

===Return value===
The parameters of the slice -- start, sizes and strides respectively.

===Complexity===
Constant.
}}

===Example===
{{example
 | demonstrates the use of gslices to address columns of a 3D array
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;
void test_print(std::valarray&lt;int&gt;&amp; v, int rows, int cols, int planes)
{
    for(int r=0; r&lt;rows; ++r) {
        for(int c=0; c&lt;cols; ++c) {
            for(int z=0; z&lt;planes; ++z)
                std::cout &lt;&lt; v[r*cols*planes + c*planes + z] &lt;&lt; ' ';
            std::cout &lt;&lt; '\n';
        }
        std::cout &lt;&lt; '\n';
    }
}
int main()
{
    std::valarray&lt;int&gt; v = // 3d array: 2 x 4 x 3 elements
    { 111,112,113 , 121,122,123 , 131,132,133 , 141,142,143,
      211,212,213 , 221,222,223 , 231,232,233 , 241,242,243};
    // int ar3d[2][4][3]
    std::cout &lt;&lt; &quot;Initial 2x4x3 array:\n&quot;;
    test_print(v, 2, 4, 3);

    // update every value in the first columns of both planes
    v[std::gslice(0, {2, 4}, {4*3, 3})] = 1; // two level one strides of 12 elements
                                             // then four level two strides of 3 elements

    // subtract the third column from the second column in the 1st plane
    v[std::gslice(1, {1, 4}, {4*3, 3})] -= v[std::gslice(2, {1, 4}, {4*3, 3})];

    std::cout &lt;&lt; &quot;After column operations: \n&quot;;
    test_print(v, 2, 4, 3);
}
 | output=
Initial 2x4x3 array:
111 112 113
121 122 123
131 132 133
141 142 143

211 212 213
221 222 223
231 232 233
241 242 243

After column operations:
1 -1 113
1 -1 123
1 -1 133
1 -1 143

1 212 213
1 222 223
1 232 233
1 242 243
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc operator_at}}
{{dsc inc | cpp/numeric/valarray/dsc slice}}
{{dsc inc | cpp/numeric/valarray/dsc gslice_array}}
{{dsc end}}

[[de:cpp/numeric/valarray/gslice]]
[[es:cpp/numeric/valarray/gslice]]
[[fr:cpp/numeric/valarray/gslice]]
[[it:cpp/numeric/valarray/gslice]]
[[ja:cpp/numeric/valarray/gslice]]
[[pt:cpp/numeric/valarray/gslice]]
[[ru:cpp/numeric/valarray/gslice]]
[[zh:cpp/numeric/valarray/gslice]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice array</title>
    <ns>0</ns>
    <id>12709</id>
    <revision>
      <id>61530</id>
      <parentid>61528</parentid>
      <timestamp>2013-06-06T03:12:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="966">{{cpp/title|gslice_array}}
{{cpp/numeric/valarray/gslice_array/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl |
template&lt; class T &gt; class gslice_array;
}}
{{dcl end}}

{{tt|std::gslice_array}} is a helper template used by {{c|std::gslice}} subscript operator. It has reference semantics to a subset of the array specified by the {{tt|std::gslice}} object.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/array/dsc constructor | gslice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc destructor | gslice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator{{=}} | gslice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator_arith | gslice_array}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc slice_array}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice array/gslice array</title>
    <ns>0</ns>
    <id>12731</id>
    <revision>
      <id>61553</id>
      <timestamp>2013-06-06T03:21:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="68">{{include page|cpp/numeric/valarray/array/constructor|gslice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice array/operator=</title>
    <ns>0</ns>
    <id>12733</id>
    <revision>
      <id>61555</id>
      <timestamp>2013-06-06T03:22:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="70">{{include page|cpp/numeric/valarray/array/operator{{=}}|gslice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice array/operator arith</title>
    <ns>0</ns>
    <id>12737</id>
    <revision>
      <id>61559</id>
      <timestamp>2013-06-06T03:22:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="71">{{include page|cpp/numeric/valarray/array/operator_arith|gslice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/gslice array/~gslice array</title>
    <ns>0</ns>
    <id>12732</id>
    <revision>
      <id>61554</id>
      <timestamp>2013-06-06T03:21:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="67">{{include page|cpp/numeric/valarray/array/destructor|gslice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/indirect array</title>
    <ns>0</ns>
    <id>12710</id>
    <revision>
      <id>64115</id>
      <parentid>61524</parentid>
      <timestamp>2013-08-13T13:28:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example</comment>
      <text xml:space="preserve" bytes="1528">{{cpp/title|indirect_array}}
{{cpp/numeric/valarray/indirect_array/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl |
template&lt; class T &gt; class indirect_array;
}}
{{dcl end}}

{{tt|std::gslice_array}} is a helper template used by {{c|std::indirect_array}} subscript operator. It has reference semantics to a subset of the array specified by an indirect array ({{c|std::valarray&lt;std::size_t&gt;}} object).

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/array/dsc constructor | indirect_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc destructor | indirect_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator{{=}} | indirect_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator_arith | indirect_array}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;

int main()
{
    std::valarray&lt;int&gt; data = {0,1,2,3,4,5,6,7,8,9};

    std::valarray&lt;std::size_t&gt; idx = {0,2,4,6,8};

    std::cout &lt;&lt; &quot;Original valarray: &quot;;
    for(int n: data) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    data[idx] += data[idx]; // double the values at indexes 'idx'

    // the type of data[idx] is std::indirect_array&lt;int&gt;

    std::cout &lt;&lt; &quot;After indirect modification: &quot;;
    for(int n: data) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
Original valarray: 0 1 2 3 4 5 6 7 8 9 
After indirect modification: 0 1 4 3 8 5 12 7 16 9 
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/indirect array/indirect array</title>
    <ns>0</ns>
    <id>12725</id>
    <revision>
      <id>61547</id>
      <timestamp>2013-06-06T03:20:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;{{include page|cpp/numeric/valarray/array/constructor|indirect_array}}&quot;</comment>
      <text xml:space="preserve" bytes="70">{{include page|cpp/numeric/valarray/array/constructor|indirect_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/indirect array/operator=</title>
    <ns>0</ns>
    <id>12734</id>
    <revision>
      <id>61556</id>
      <timestamp>2013-06-06T03:22:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="72">{{include page|cpp/numeric/valarray/array/operator{{=}}|indirect_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/indirect array/operator arith</title>
    <ns>0</ns>
    <id>12738</id>
    <revision>
      <id>61560</id>
      <timestamp>2013-06-06T03:22:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="73">{{include page|cpp/numeric/valarray/array/operator_arith|indirect_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/indirect array/~indirect array</title>
    <ns>0</ns>
    <id>12724</id>
    <revision>
      <id>61546</id>
      <timestamp>2013-06-06T03:20:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="69">{{include page|cpp/numeric/valarray/array/destructor|indirect_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/log</title>
    <ns>0</ns>
    <id>4318</id>
    <revision>
      <id>72130</id>
      <parentid>71104</parentid>
      <timestamp>2014-07-17T07:34:26Z</timestamp>
      <contributor>
        <ip>212.104.65.77</ip>
      </contributor>
      <comment>no return value provided</comment>
      <text xml:space="preserve" bytes="1247">{{cpp/title|log{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; log( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes natural logarithm of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array natural logarithms of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|log}}

{{cpp/numeric/valarray/notes ret|log}}

===Possible implementation===
{{eq fun | 1=
template&lt; class T &gt;
valarray&lt;T&gt; log( const valarray&lt;T&gt;&amp; va )
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = log(i);
    }
    return other;
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc log10}}
{{dsc inc | cpp/numeric/valarray/dsc exp}}
{{dsc inc | cpp/numeric/math/dsc log}}
{{dsc inc | cpp/numeric/complex/dsc log}}
{{dsc end}}

[[de:cpp/numeric/valarray/log]]
[[es:cpp/numeric/valarray/log]]
[[fr:cpp/numeric/valarray/log]]
[[it:cpp/numeric/valarray/log]]
[[ja:cpp/numeric/valarray/log]]
[[pt:cpp/numeric/valarray/log]]
[[ru:cpp/numeric/valarray/log]]
[[zh:cpp/numeric/valarray/log]]</text>
      <sha1>q0t5duzxh88kca6ynbfj9wpgt0s8c06</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/log10</title>
    <ns>0</ns>
    <id>4320</id>
    <revision>
      <id>71105</id>
      <parentid>51077</parentid>
      <timestamp>2014-06-05T21:10:11Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1224">{{cpp/title|log10{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; log10( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes common (base 10) logarithm of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array common logarithms of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|log10}}

{{cpp/numeric/valarray/notes ret|log10}}

===Possible implementation===
{{eq fun | 1=
template&lt; class T &gt;
valarray&lt;T&gt; log10( const valarray&lt;T&gt;&amp; va )
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = log10(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc log}}
{{dsc inc | cpp/numeric/math/dsc log10}}
{{dsc inc | cpp/numeric/complex/dsc log10}}
{{dsc end}}

[[de:cpp/numeric/valarray/log10]]
[[es:cpp/numeric/valarray/log10]]
[[fr:cpp/numeric/valarray/log10]]
[[it:cpp/numeric/valarray/log10]]
[[ja:cpp/numeric/valarray/log10]]
[[pt:cpp/numeric/valarray/log10]]
[[ru:cpp/numeric/valarray/log10]]
[[zh:cpp/numeric/valarray/log10]]</text>
      <sha1>pxxgbf5qn9veosmein58ld1ynthvh4t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/mask array</title>
    <ns>0</ns>
    <id>12711</id>
    <revision>
      <id>64116</id>
      <parentid>61525</parentid>
      <timestamp>2013-08-13T13:35:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+motivating example</comment>
      <text xml:space="preserve" bytes="1419">{{cpp/title|mask_array}}
{{cpp/numeric/valarray/mask_array/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl |
template&lt; class T &gt; class mask_array;
}}
{{dcl end}}

{{tt|std::gslice_array}} is a helper template used by {{c|std::mask_array}} subscript operator. It has reference semantics to a subset of the array specified by an mask array ({{c|std::valarray&lt;bool&gt;}} object).

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/array/dsc constructor | mask_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc destructor | mask_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator{{=}} | mask_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator_arith | mask_array}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;

int main() 
{
    std::valarray&lt;int&gt; data = {0,1,2,3,4,5,6,7,8,9};

    std::cout &lt;&lt; &quot;Initial valarray: &quot;;
    for(int n: data) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    data[data &gt; 5] = -1;
    // the type of data&gt;5 is std::valarray&lt;bool&gt;
    // the type of data[data&gt;5] is std::mask_array&lt;int&gt;

    std::cout &lt;&lt; &quot;After v[v&gt;5]=-1:  &quot;;
    for(int n: data) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
Initial valarray: 0 1 2 3 4 5 6 7 8 9 
After v[v&gt;5]=-1:  0 1 2 3 4 5 -1 -1 -1 -1 
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/mask array/mask array</title>
    <ns>0</ns>
    <id>12727</id>
    <revision>
      <id>61549</id>
      <timestamp>2013-06-06T03:21:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="66">{{include page|cpp/numeric/valarray/array/constructor|mask_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/mask array/operator=</title>
    <ns>0</ns>
    <id>12735</id>
    <revision>
      <id>61557</id>
      <timestamp>2013-06-06T03:22:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="68">{{include page|cpp/numeric/valarray/array/operator{{=}}|mask_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/mask array/operator arith</title>
    <ns>0</ns>
    <id>12739</id>
    <revision>
      <id>61561</id>
      <timestamp>2013-06-06T03:22:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="69">{{include page|cpp/numeric/valarray/array/operator_arith|mask_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/mask array/~mask array</title>
    <ns>0</ns>
    <id>12726</id>
    <revision>
      <id>61548</id>
      <timestamp>2013-06-06T03:21:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="65">{{include page|cpp/numeric/valarray/array/destructor|mask_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/max</title>
    <ns>0</ns>
    <id>4556</id>
    <revision>
      <id>58791</id>
      <parentid>51078</parentid>
      <timestamp>2013-06-01T06:21:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="740">{{cpp/numeric/valarray/title|max}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
T max() const;
}}

Computes the maximum value of the elements. 

If there are no elements, the behavior is undefined. 

The function can be used only if {{c|operator&lt;}} is defined for type {{tt|T}}.

===Parameters===
(none)

===Return value===
The maximum of the elements.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc min}}
{{dsc end}}

[[de:cpp/numeric/valarray/max]]
[[es:cpp/numeric/valarray/max]]
[[fr:cpp/numeric/valarray/max]]
[[it:cpp/numeric/valarray/max]]
[[ja:cpp/numeric/valarray/max]]
[[pt:cpp/numeric/valarray/max]]
[[ru:cpp/numeric/valarray/max]]
[[zh:cpp/numeric/valarray/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/min</title>
    <ns>0</ns>
    <id>4555</id>
    <revision>
      <id>58794</id>
      <parentid>51079</parentid>
      <timestamp>2013-06-01T06:21:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="740">{{cpp/numeric/valarray/title|min}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
T min() const;
}}

Computes the minimum value of the elements. 

If there are no elements, the behavior is undefined. 

The function can be used only if {{c|operator&lt;}} is defined for type {{tt|T}}.

===Parameters===
(none)

===Return value===
The minimum of the elements.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc max}}
{{dsc end}}

[[de:cpp/numeric/valarray/min]]
[[es:cpp/numeric/valarray/min]]
[[fr:cpp/numeric/valarray/min]]
[[it:cpp/numeric/valarray/min]]
[[ja:cpp/numeric/valarray/min]]
[[pt:cpp/numeric/valarray/min]]
[[ru:cpp/numeric/valarray/min]]
[[zh:cpp/numeric/valarray/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator=</title>
    <ns>0</ns>
    <id>9030</id>
    <revision>
      <id>68853</id>
      <parentid>68852</parentid>
      <timestamp>2014-03-22T19:00:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3696">{{cpp/numeric/valarray/title|operator{{=}}}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
valarray&lt;T&gt;&amp; operator=( const valarray&lt;T&gt;&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
valarray&lt;T&gt;&amp; operator=( valarray&lt;T&gt;&amp;&amp; other );
}}
{{dcl | num=3 | 1=
valarray&lt;T&gt;&amp; operator=( const T&amp; val );
}}
{{dcl | num=4 | 1=
valarray&lt;T&gt;&amp; operator=( const std::slice_array&amp; other);
}}
{{dcl | num=5 | 1=
valarray&lt;T&gt;&amp; operator=( const std::gslice_array&amp; other);
}}
{{dcl | num=6 | 1=
valarray&lt;T&gt;&amp; operator=( const std::mask_array&amp; other );
}}
{{dcl | num=7 | 1=
valarray&lt;T&gt;&amp; operator=( const std::indirect_array&amp; other );
}}
{{dcl | num=8 | since=c++11 | 1=
valarray&lt;T&gt;&amp; operator=( std::initializer_list&lt;T&gt; il );
}}
{{dcl end}}

Replaces the contents of the numeric array.

@1@ Copy assignment operator. If the length of {{tt|other}} does not equal the length of {{tt|*this}}, first resizes as if by {{c|resize(other.size())}}, then replaces each element of {{tt|*this}} with a copy of the corresponding element of {{tt|other}}
@2@ Move assignment operator. Replaces the contents of {{tt|*this}} with those of {{tt|other}}. The value of {{tt|other}} is unspecified after this operation. The complexity of this operation may be linear if T has non-trivial destructors, but is usually constant otherwise.
@3@ Replaces each value in {{tt|*this}} with a copy of {{tt|val}}.
@4-7@ Replaces the contents of {{tt|*this}} with the result of a generalized subscripting operation. The behavior is undefined if the length of the argument does not equal the length of {{tt|*this}} or if any value on the left depends on the value on the right (e.g {{c|v{{=}}v[v&gt;2]}}).
@8@ Assigns the contents of initializer list {{tt|il}}. Equivalent to {{c|1=*this = valarray(il)}}.

===Parameters===
{{par begin}}
{{par | other | another numeric array (or a mask) to assign}}
{{par | val | the value to initialize each element with}}
{{par | il | initializer list to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ (none)
@2@ {{noexcept}}
@3-8@ (none)

===Example===
{{example
|code=
#include &lt;valarray&gt;
#include &lt;iostream&gt;

int main()
{
    std::valarray&lt;int&gt; v1(3);
    v1 = -1; // from a scalar 
    std::cout &lt;&lt; &quot;assigned from scalar: &quot;;
    for(int n: v1) std::cout &lt;&lt; n &lt;&lt; ' '; std::cout &lt;&lt; '\n';

    v1 = {1, 2, 3, 4, 5, 6}; // from initializer list of different size
    std::cout &lt;&lt; &quot;assigned from initializer_list:      &quot;;
    for(int n: v1) std::cout &lt;&lt; n &lt;&lt; ' '; std::cout &lt;&lt; '\n';

    std::valarray&lt;int&gt; v2(3);
    v2 = v1[std::slice(0,3,2)]; // from slice array
    std::cout &lt;&lt; &quot;every 2nd element starting at pos 0: &quot;;
    for(int n: v2) std::cout &lt;&lt; n &lt;&lt; ' '; std::cout &lt;&lt; '\n';

    v2 = v1[v1 % 2 == 0]; // from mask array
    std::cout &lt;&lt; &quot;values that are even          :      &quot;;
    for(int n: v2) std::cout &lt;&lt; n &lt;&lt; ' '; std::cout &lt;&lt; '\n';

    std::valarray&lt;std::size_t&gt; idx = {0,1,2,4}; // index array
    v2.resize(4); // sizes must match when assigning from gen subscript
    v2 = v1[idx]; // from indirect array
    std::cout &lt;&lt; &quot;values at positions 0,1,2,4:         &quot;;
    for(int n: v2) std::cout &lt;&lt; n &lt;&lt; ' '; std::cout &lt;&lt; '\n';
}
|output=
assigned from scalar: -1 -1 -1 
assigned from initializer_list:      1 2 3 4 5 6 
every 2nd element starting at pos 0: 1 3 5 
values that are even          :      2 4 6 
values at positions 0,1,2,4:         1 2 3 5 
}}

[[de:cpp/numeric/valarray/operator=]]
[[es:cpp/numeric/valarray/operator=]]
[[fr:cpp/numeric/valarray/operator=]]
[[it:cpp/numeric/valarray/operator=]]
[[ja:cpp/numeric/valarray/operator=]]
[[pt:cpp/numeric/valarray/operator=]]
[[ru:cpp/numeric/valarray/operator=]]
[[zh:cpp/numeric/valarray/operator=]]</text>
      <sha1>cl5nxc7tbfvkesvhh7fogak106ffmky</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator arith</title>
    <ns>0</ns>
    <id>9033</id>
    <revision>
      <id>51081</id>
      <parentid>42084</parentid>
      <timestamp>2013-06-01T03:50:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1197">{{cpp/numeric/valarray/title|operator+,-,~,!}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 |
valarray&lt;T&gt; operator+() const;
}}
{{dcl | num=2 | 1=
valarray&lt;T&gt; operator-() const;
}}
{{dcl | num=3 | 1=
valarray&lt;T&gt; operator~() const;
}}
{{dcl | num=4 | 1=
valarray&lt;bool&gt; operator!() const;
}}
{{dcl end}}

Applies unary operators to each element in the numeric array.

===Parameters===
(none)

===Return value===
A numeric array containing elements with values obtained by applying corresponding operator to the values in {{c|*this}}.

===Exceptions===
(none)

===Notes===
Each of the operators can only be instantiated if the following requirements are met:
:* The indicated operator can be applied to type {{tt|T}}
:* The result value can be unambiguously converted to {{tt|T}} (1-3) or {{c|bool}} (4).

{{cpp/numeric/valarray/notes_ret}}

[[de:cpp/numeric/valarray/operator arith]]
[[es:cpp/numeric/valarray/operator arith]]
[[fr:cpp/numeric/valarray/operator arith]]
[[it:cpp/numeric/valarray/operator arith]]
[[ja:cpp/numeric/valarray/operator arith]]
[[pt:cpp/numeric/valarray/operator arith]]
[[ru:cpp/numeric/valarray/operator arith]]
[[zh:cpp/numeric/valarray/operator arith]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator arith2</title>
    <ns>0</ns>
    <id>9034</id>
    <revision>
      <id>51082</id>
      <parentid>42074</parentid>
      <timestamp>2013-06-01T03:50:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2569">{{cpp/numeric/valarray/title|1=operator+=,-=,*=,/=,%=,&amp;=,{{!}}=,&lt;&lt;=,&gt;&gt;=}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
valarray&lt;T&gt; operator+=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator-=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator*=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator/=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator%=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator&amp;=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator{{!}}=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator^=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator&lt;&lt;=( const valarray&lt;T&gt;&amp; v );
valarray&lt;T&gt; operator&gt;&gt;=( const valarray&lt;T&gt;&amp; v );
}}
{{dcl | num=2 | 1=
valarray&lt;T&gt; operator+=( const T&amp; val );
valarray&lt;T&gt; operator-=( const T&amp; val );
valarray&lt;T&gt; operator*=( const T&amp; val );
valarray&lt;T&gt; operator/=( const T&amp; val );
valarray&lt;T&gt; operator%=( const T&amp; val );
valarray&lt;T&gt; operator&amp;=( const T&amp; val );
valarray&lt;T&gt; operator{{!}}=( const T&amp; val );
valarray&lt;T&gt; operator^=( const T&amp; val );
valarray&lt;T&gt; operator&lt;&lt;=( const T&amp; val );
valarray&lt;T&gt; operator&gt;&gt;=( const T&amp; val );
}}
{{dcl end}}

Applies compound assignment operators to each element in the numeric array. 

@1@ Each element is assigned value obtained by applying the corresponding operator to the previous value of the element and corresponding element from {{tt|v}}.

The behavior is undefined if {{c|1=size() != v.size()}}

The behavior is undefined if any of the values in {{tt|v}} is computed during the assignment and depends on any of the values in {{c|*this}}, that is, the expression on the right side of the assignment refers to a variable in the left side of the assignment.

@2@ Each element is assigned value obtained by applying the corresponding operator to the previous value of the element and the value of {{tt|val}}.

===Parameters===
{{par begin}}
{{par | v | another numeric array}}
{{par | val | a value}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
(none)

===Notes===
Each of the operators can only be instantiated if the following requirements are met:
:* The indicated operator can be applied to type {{tt|T}}
:* The result value can be unambiguously converted to {{tt|T}} (1-3) or {{c|bool}} (4).

{{cpp/numeric/valarray/notes_ret}}

[[de:cpp/numeric/valarray/operator arith2]]
[[es:cpp/numeric/valarray/operator arith2]]
[[fr:cpp/numeric/valarray/operator arith2]]
[[it:cpp/numeric/valarray/operator arith2]]
[[ja:cpp/numeric/valarray/operator arith2]]
[[pt:cpp/numeric/valarray/operator arith2]]
[[ru:cpp/numeric/valarray/operator arith2]]
[[zh:cpp/numeric/valarray/operator arith2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator arith3</title>
    <ns>0</ns>
    <id>9646</id>
    <revision>
      <id>67447</id>
      <parentid>67446</parentid>
      <timestamp>2014-02-09T17:45:25Z</timestamp>
      <contributor>
        <username>Xan</username>
        <id>2811</id>
      </contributor>
      <minor/>
      <comment>change auto to std::valarray&lt;double&gt; (runtime error otherwise)</comment>
      <text xml:space="preserve" bytes="4931">{{title|1=operator+,-,*,/,%,&amp;,{{!}},&lt;&lt;,&gt;&gt;,^ {{small|std::valarray}}}}
{{cpp/numeric/valarray/navbar}}

{{dcl begin}}
{{dcl header | valarray }}
{{dcl | num=1 | 1=
template &lt;class T&gt; std::valarray&lt;T&gt; operator+ (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator- (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator* (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator/ (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator% (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&amp; (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator{{!}} (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator^ (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&lt;&lt; (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&gt;&gt; (const std::valarray&lt;T&gt;&amp; lhs, const std::valarray&lt;T&gt;&amp; rhs);
}}
{{dcl | num=2 | 1=
template &lt;class T&gt; std::valarray&lt;T&gt; operator+ (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator- (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator* (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator/ (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator% (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&amp; (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator{{!}} (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator^ (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&lt;&lt; (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&gt;&gt; (const T&amp; val, const std::valarray&lt;T&gt;&amp; rhs);
}}
{{dcl | num=3 | 1=
template &lt;class T&gt; std::valarray&lt;T&gt; operator+ (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; rhs);
template &lt;class T&gt; std::valarray&lt;T&gt; operator- (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator* (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator/ (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator% (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&amp; (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator{{!}} (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator^ (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&lt;&lt; (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
template &lt;class T&gt; std::valarray&lt;T&gt; operator&gt;&gt; (const std::valarray&lt;T&gt;&amp; lhs, const T&amp; val);
}}
{{dcl end}}

Apply binary operators to each element of two valarrays, or a valarray and a value.

@1@ The operators works on valarrays of the same size and returns avalarray with the same size as the parameters with the operation applied to every elements of the two arguments.

@2,3@ Applies the operator between each element of the valarray and the scalar.

===Parameters===
{{par begin}}
{{par | rhs | a numeric array}}
{{par | lhs | a numeric array}}
{{par | val | a value of type {{ttb|T}} }}
{{par end}}

===Return value===
A valarray with the same size as the parameter.

===Note===
The behaviour is undefined when the two arguments are valarrays with different sizes.

{{cpp/numeric/valarray/notes ret}}

===Example===
{{example
|Finds real roots of multiple quadratic equations.
|code=
#include &lt;valarray&gt;
#include &lt;iostream&gt;

int main()
{
    std::valarray&lt;double&gt; a(1, 8);
    std::valarray&lt;double&gt; b{1, 2, 3, 4, 5, 6, 7, 8};
    std::valarray&lt;double&gt; c = -b;
    // literals must also be of type T (double in this case)
    std::valarray&lt;double&gt; d = std::sqrt((b * b - 4.0 * a * c));
    std::valarray&lt;double&gt; x1 = (-b - d) / (2.0 * a);
    std::valarray&lt;double&gt; x2 = (-b + d) / (2.0 * a);
    std::cout &lt;&lt; &quot;quadratic equation    root 1,  root 2&quot; &lt;&lt; &quot;\n&quot;;
    for (size_t i = 0; i &lt; a.size(); ++i) {
        std::cout &lt;&lt; a[i] &lt;&lt; &quot;x\u00B2 + &quot; &lt;&lt; b[i] &lt;&lt; &quot;x + &quot; &lt;&lt; c[i] &lt;&lt; &quot; = 0   &quot;;
        std::cout &lt;&lt; x1[i] &lt;&lt; &quot;, &quot; &lt;&lt; x2[i] &lt;&lt; &quot;\n&quot;;
    }
}
|output=
quadratic equation    root 1,  root 2
1x² + 1x + -1 = 0   -1.61803, 0.618034
1x² + 2x + -2 = 0   -2.73205, 0.732051
1x² + 3x + -3 = 0   -3.79129, 0.791288
1x² + 4x + -4 = 0   -4.82843, 0.828427
1x² + 5x + -5 = 0   -5.8541, 0.854102
1x² + 6x + -6 = 0   -6.87298, 0.872983
1x² + 7x + -7 = 0   -7.88748, 0.887482
1x² + 8x + -8 = 0   -8.89898, 0.898979
}}</text>
      <sha1>562uid73kqlfebh2cwvk08idd27slyj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator at</title>
    <ns>0</ns>
    <id>9032</id>
    <revision>
      <id>51084</id>
      <parentid>47207</parentid>
      <timestamp>2013-06-01T03:50:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2432">{{cpp/numeric/valarray/title|operator[]}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
const T&amp;            operator[]( size_t pos ) const;
}}
{{dcl | num=2 | 1=
T&amp;                  operator[]( size_t pos );
}}
{{dcl | num=3 | 1=
valarray&lt;T&gt;         operator[]( slice slicearr ) const;
}}
{{dcl | num=4 | 1=
slice_array&lt;T&gt;      operator[]( slice slicearr );
}}
{{dcl | num=5 | 1=
valarray&lt;T&gt;         operator[]( const gslice&amp; gslicearr ) const;
}}
{{dcl | num=6 | 1=
gslice_array&lt;T&gt;     operator[]( const gslice&amp; gslicearr );
}}
{{dcl | num=7 | 1=
valarray&lt;T&gt;         operator[]( const valarray&lt;bool&gt;&amp; boolarr ) const;
}}
{{dcl | num=8 | 1=
mask_array&lt;T&gt;       operator[]( const valarray&lt;bool&gt;&amp; boolarr );
}}
{{dcl | num=9 | 1=
valarray&lt;T&gt;         operator[]( const valarray&lt;size_t&gt;&amp; indarr ) const;
}}
{{dcl | num=10 | 1=
indirect_array&lt;T&gt;   operator[]( const valarray&lt;size_t&gt;&amp; indarr );
}}
{{dcl end}}

Retrieve single elements or portions of the array.

The {{c|const}} overloads that return element sequences create a new {{lc|std::valarray}} object.
The non-{{c|const}} overloads return classes holding references to the array elements.

===Parameters===
{{todo}}

===Return value===
@1,2@ A reference to the corresponding element
@3,5,7,9@ A {{lc|std::valarray}} object containing copies of the selected items
@4,6,8,10@ The corresponding data structure containing references to the selected items 


===Exceptions===
(none)

===Precondition===
The selected elements must exist.

===Notes===
* For proper values of {{ttb|i}} and {{ttb|j}}, the following properties are true:
@1@ {{c|(a[i] {{=}} q, a[i]) {{==}} q}}
: For a non-const {{ttb|a}}.
@2@ {{c|&amp;a[i+j] {{==}} &amp;a[i] + j}} 
:This means that valarray elements are adjacent in memory.
@3@ {{c|&amp;a[i] !{{=}} &amp;b[j]}}
:This holds for every objects {{ttb|a}} and {{ttb|b}} that are not aliases of one another.
:This means that there are no aliases in the elements and this property can be used to perform some kinds of optimization.

* References become invalid on [[cpp/numeric/valarray/resize|resize]] or when the array is destructed.


[[de:cpp/numeric/valarray/operator at]]
[[es:cpp/numeric/valarray/operator at]]
[[fr:cpp/numeric/valarray/operator at]]
[[it:cpp/numeric/valarray/operator at]]
[[ja:cpp/numeric/valarray/operator at]]
[[pt:cpp/numeric/valarray/operator at]]
[[ru:cpp/numeric/valarray/operator at]]
[[zh:cpp/numeric/valarray/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/operator cmp</title>
    <ns>0</ns>
    <id>9035</id>
    <revision>
      <id>51085</id>
      <parentid>42052</parentid>
      <timestamp>2013-06-01T03:50:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="3426">{{title|1=operator==,!=,&lt;,&lt;=,&gt;,&gt;={{small|std::valarray}}}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class T &gt; 
valarray&lt;bool&gt; operator==( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator!=( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;=( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;=( const valarray&lt;T&gt;&amp; lhs, const valarray&lt;T&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class T &gt; 
valarray&lt;bool&gt; operator==( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator!=( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;=( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;=( const T&amp; lhsv, const valarray&lt;T&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; class T &gt; 
valarray&lt;bool&gt; operator==( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator!=( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&lt;=( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
template&lt; class T &gt; 
valarray&lt;bool&gt; operator&gt;=( const valarray&lt;T&gt;&amp; lhs, const T&amp; rhsv );
}}
{{dcl end}}

Compares each value within the numeric array with another value.

@1@ Returns a numeric array of {{c|bool}} containing elements each of which is obtained by applying the indicated comparison operator to the corresponding values of {{tt|lhs}} and {{tt|rhs}}

The behavior is undefined if {{c|1=size() != v.size()}}

@2@ Returns a numeric array of {{c|bool}} containing elements each of which is obtained by applying the indicated comparison operator to {{tt|lhsv}} and the corresponding value of {{tt|rhs}} .

@3@ Returns a numeric array of {{c|bool}} containing elements each of which is obtained by applying the indicated comparison operator to the corresponding value of {{tt|lhs}} and {{tt|rhsv}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | numeric arrays to compare}}
{{par | lhsv, rhsv | values to compare to each element within a numeric array}}
{{par end}}

===Return value===
A numeric array of {{c|bool}} containing comparison results of corresponding elements.

===Exceptions===
(none)

===Notes===
Each of the operators can only be instantiated if the following requirements are met:
:* The indicated operator can be applied to type {{tt|T}}
:* The result value can be unambiguously converted to {{tt|bool}}.

{{cpp/numeric/valarray/notes_ret}}

[[de:cpp/numeric/valarray/operator cmp]]
[[es:cpp/numeric/valarray/operator cmp]]
[[fr:cpp/numeric/valarray/operator cmp]]
[[it:cpp/numeric/valarray/operator cmp]]
[[ja:cpp/numeric/valarray/operator cmp]]
[[pt:cpp/numeric/valarray/operator cmp]]
[[ru:cpp/numeric/valarray/operator cmp]]
[[zh:cpp/numeric/valarray/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/pow</title>
    <ns>0</ns>
    <id>9036</id>
    <revision>
      <id>71099</id>
      <parentid>58795</parentid>
      <timestamp>2014-06-05T20:54:46Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1822">{{cpp/title|pow{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl | num=1 |
template&lt; class T &gt; 
valarray&lt;T&gt; pow( const valarray&lt;T&gt;&amp; base, const valarray&lt;T&gt;&amp; exp );
}}
{{dcl | num=2 |
template&lt; class T &gt; 
valarray&lt;T&gt; pow( const valarray&lt;T&gt;&amp; base, const T&amp; vexp );
}}
{{dcl | num=3 |
template&lt; class T &gt; 
valarray&lt;T&gt; pow( const T&amp; vbase, const valarray&lt;T&gt;&amp; exp );
}}
{{dcl end}}

Raises a value to a power.

@1@ Computes the values of each element in the numeric array {{tt|base}} raised to the power specified by the corresponding element from the numeric array {{tt|exp}}.

The behavior is undefined if {{c|1=base.size() != exp.size()}}.
@2@ Computes the values of each element in the numeric array {{tt|base}} raised to the power {{tt|vexp}}.
@3@ Computes the values of {{tt|vbase}} raised to the power defined by the elements in the numeric array {{tt|exp}}.

===Parameters===
{{par begin}}
{{par | base | numeric array containing the values of the base}}
{{par | exp | numeric array containing the values of the exponent}}
{{par | vbase | a value defining the base}}
{{par | vexp | a value defining the exponent}}
{{par end}}

===Return value===
A numeric array containing the results of exponentiation.

===Notes===
{{cpp/numeric/valarray/notes unq|pow}}

{{cpp/numeric/valarray/notes ret|pow}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc sqrt}}
{{dsc inc | cpp/numeric/math/dsc pow}}
{{dsc inc | cpp/numeric/complex/dsc pow}}
{{dsc end}}

[[de:cpp/numeric/valarray/pow]]
[[es:cpp/numeric/valarray/pow]]
[[fr:cpp/numeric/valarray/pow]]
[[it:cpp/numeric/valarray/pow]]
[[ja:cpp/numeric/valarray/pow]]
[[pt:cpp/numeric/valarray/pow]]
[[ru:cpp/numeric/valarray/pow]]
[[zh:cpp/numeric/valarray/pow]]</text>
      <sha1>ac6exfgb8b77u9fpumn609l0kbhxtc4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/resize</title>
    <ns>0</ns>
    <id>4553</id>
    <revision>
      <id>66620</id>
      <parentid>66617</parentid>
      <timestamp>2013-12-15T18:37:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>that deserves an example to reiterate the difference from other resizes</comment>
      <text xml:space="preserve" bytes="1099">{{cpp/numeric/valarray/title|resize}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 1=
void resize( std::size_t count, T value = T() );
}}

Resizes the valarray to contain {{tt|count}} elements and assigns {{tt|value}} to each element.

This functions invalidates all pointers and references to elements in the array.

===Parameters===
{{par begin}}
{{par | count | new size of the container}}
{{par | value | the value to initialize the new elements with }}
{{par end}}

===Return value===
(none)

===Example===
{{example|
 | code=
#include &lt;valarray&gt;
#include &lt;iostream&gt;
int main()
{
    std::valarray&lt;int&gt; v{1,2,3};
    v.resize(10);
    for(int n: v) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
0 0 0 0 0 0 0 0 0 0 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc size}}
{{dsc end}}

[[de:cpp/numeric/valarray/resize]]
[[es:cpp/numeric/valarray/resize]]
[[fr:cpp/numeric/valarray/resize]]
[[it:cpp/numeric/valarray/resize]]
[[ja:cpp/numeric/valarray/resize]]
[[pt:cpp/numeric/valarray/resize]]
[[ru:cpp/numeric/valarray/resize]]
[[zh:cpp/numeric/valarray/resize]]</text>
      <sha1>9sdogpyafrcufnzx4o4fg2q30kt5gj8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/shift</title>
    <ns>0</ns>
    <id>4557</id>
    <revision>
      <id>58799</id>
      <parentid>51088</parentid>
      <timestamp>2013-06-01T06:21:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1004">{{cpp/numeric/valarray/title|shift}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
valarray&lt;T&gt; shift( int count ) const;
}}

Returns a new valarray of the same size with elements whose positions are shifted by {{tt|count}} elements. The new position of each element is {{math|i−count}} where {{math|i}} is the previous position. The value of shifted in elements is {{c|T()}}.

===Parameters===
{{par begin}}
{{par | count | number of positions to shift the elements by}}
{{par end}}

===Return value===
The resulting valarray with shifted elements.

===Notes===
{{cpp/numeric/valarray/notes_ret}}

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc cshift}}
{{dsc end}}

[[de:cpp/numeric/valarray/shift]]
[[es:cpp/numeric/valarray/shift]]
[[fr:cpp/numeric/valarray/shift]]
[[it:cpp/numeric/valarray/shift]]
[[ja:cpp/numeric/valarray/shift]]
[[pt:cpp/numeric/valarray/shift]]
[[ru:cpp/numeric/valarray/shift]]
[[zh:cpp/numeric/valarray/shift]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/sin</title>
    <ns>0</ns>
    <id>4322</id>
    <revision>
      <id>71087</id>
      <parentid>51089</parentid>
      <timestamp>2014-06-05T20:22:28Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1600">{{cpp/title|sin{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; sin( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes sine of the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing sine of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|sin}}

{{cpp/numeric/valarray/notes ret|sin}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; sin(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = sin(i);
    }
}
}}

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;
#include &lt;cmath&gt;

const double pi = std::acos(-1);
int main()
{
    std::valarray&lt;double&gt; v1 = {0, 0.25, 0.5, 0.75, 1};
    std::valarray&lt;double&gt; v2 = std::sin(v1 * pi);

    for(double n : v2)
        std::cout &lt;&lt; std::fixed &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
|output=
0.000000 0.707107 1.000000 0.707107 0.000000 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc tan}}
{{dsc inc | cpp/numeric/valarray/dsc asin}}
{{dsc inc | cpp/numeric/math/dsc sin}}
{{dsc inc | cpp/numeric/complex/dsc sin}}
{{dsc end}}

[[de:cpp/numeric/valarray/sin]]
[[es:cpp/numeric/valarray/sin]]
[[fr:cpp/numeric/valarray/sin]]
[[it:cpp/numeric/valarray/sin]]
[[ja:cpp/numeric/valarray/sin]]
[[pt:cpp/numeric/valarray/sin]]
[[ru:cpp/numeric/valarray/sin]]
[[zh:cpp/numeric/valarray/sin]]</text>
      <sha1>sjn2t2sdpsejyxjdft6ltxzztkfd2vw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/sinh</title>
    <ns>0</ns>
    <id>9038</id>
    <revision>
      <id>71094</id>
      <parentid>58800</parentid>
      <timestamp>2014-06-05T20:42:12Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1246">{{cpp/title|sinh{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; sinh( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes hyperbolic sine of the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing hyperbolic sine of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|sinh}}

{{cpp/numeric/valarray/notes ret|sinh}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; sinh(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = sinh(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc inc | cpp/numeric/valarray/dsc tanh}}
{{dsc inc | cpp/numeric/math/dsc sinh}}
{{dsc inc | cpp/numeric/complex/dsc sinh}}
{{dsc end}}

[[de:cpp/numeric/valarray/sinh]]
[[es:cpp/numeric/valarray/sinh]]
[[fr:cpp/numeric/valarray/sinh]]
[[it:cpp/numeric/valarray/sinh]]
[[ja:cpp/numeric/valarray/sinh]]
[[pt:cpp/numeric/valarray/sinh]]
[[ru:cpp/numeric/valarray/sinh]]
[[zh:cpp/numeric/valarray/sinh]]</text>
      <sha1>cevllgiustfp7vxrc4m1cgylkxrkpcx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/size</title>
    <ns>0</ns>
    <id>4552</id>
    <revision>
      <id>58803</id>
      <parentid>51091</parentid>
      <timestamp>2013-06-01T06:21:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="638">{{cpp/numeric/valarray/title|size}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
std::size_t size() const;
}}

Returns the number of elements in the valarray.

===Parameters===
(none)

===Return value===
Number of elements in the valarray.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc resize}}
{{dsc end}}

[[de:cpp/numeric/valarray/size]]
[[es:cpp/numeric/valarray/size]]
[[fr:cpp/numeric/valarray/size]]
[[it:cpp/numeric/valarray/size]]
[[ja:cpp/numeric/valarray/size]]
[[pt:cpp/numeric/valarray/size]]
[[ru:cpp/numeric/valarray/size]]
[[zh:cpp/numeric/valarray/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice</title>
    <ns>0</ns>
    <id>5019</id>
    <revision>
      <id>61589</id>
      <parentid>61588</parentid>
      <timestamp>2013-06-06T06:19:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update navbar</comment>
      <text xml:space="preserve" bytes="3337">{{cpp/title|slice}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray |
class slice;
}}

{{tt|std::slice}} is the selector class that identifies a subset of {{lc|std::valarray}} similar to [[enwiki:BLAS|BLAS]] slice. An object of type {{tt|std::slice}} holds three values: the starting index, the stride, and the total number of values in the subset. Objects of type {{tt|std::slice}} can be used as indexes with valarray's {{tt|operator[]}}.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/numeric/valarray/slice | inlinemem=true | constructs a slice}}
{{dsc mem fun | cpp/numeric/valarray/slice | title=start&lt;br/&gt;size&lt;br/&gt;stride | inlinemem=true | returns the parameters of the slice}}
{{dsc end}}

{{member | {{small|std::slice::}}slice |
{{dcl begin}}
{{dcl | 
slice()
}}
{{dcl |
slice( std::size_t start, std::size_t size, std::size_t stride );
}}
{{dcl |
slice( const slice&amp; other );
}}
{{dcl end}}

Constructs a new slice.

@1@ Default constructor. Equivalent to {{c|slice(0, 0, 0)}}. This constructor exists only to allow construction of arrays of slices.

@2@ Constructs a new slice with parameters {{tt|start}}, {{tt|size}}, {{tt|stride}}. This slice will refer to {{tt|size}} number of elements, each with the position:

:@@ {{math|start + 0*stride}}
:@@ {{math|start + 1*stride}}
:@@ {{math|...}}
:@@ {{math|start + (size-1)*stride}}

@3@ Constructs a copy of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | start | the position of the first element}}
{{par | size | the number of elements in the slice}}
{{par | stride | the number of positions between successive elements in the slice}}
{{par | other | another slice to copy}}
{{par end}}
}}


{{member | {{small|std::slice::}}start, size, stride |
{{dcl begin}}
{{dcl | num=1 |
std::size_t start() const;
}}
{{dcl | num=2 |
std::size_t size() const;
}}
{{dcl | num=3 |
std::size_t stride() const;
}}
{{dcl end}}

Returns the parameters passed to the slice on construction - start, size and stride respectively.

===Parameters===
(none)

===Return value===
The parameters of the slice -- start, size and stride respectively.

===Complexity===
Constant.
}}

===Example===
{{example
 | Barebones valarray-backed Matrix class with a [[enwiki:Trace (linear algebra)|trace]] calculating function.
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;
class Matrix {
    std::valarray&lt;int&gt; data;
    int dim;
 public:
    Matrix(int r, int c) : data(r*c), dim(c) {}
    int&amp; operator()(int r, int c) {return data[r*dim + c];}
    int trace() const {
        return data[std::slice(0, dim, dim+1)].sum();
    }
};
int main()
{
    Matrix m(3,3);
    int n = 0;
    for(int r=0; r&lt;3; ++r)
       for(int c=0; c&lt;3; ++c)
           m(r, c) = ++n;
    std::cout &lt;&lt; &quot;Trace of the matrix (1,2,3) (4,5,6) (7,8,9) is &quot; &lt;&lt; m.trace() &lt;&lt; '\n';
}
 | output=
Trace of the matrix (1,2,3) (4,5,6) (7,8,9) is 15
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc operator_at}}
{{dsc inc | cpp/numeric/valarray/dsc gslice}}
{{dsc inc | cpp/numeric/valarray/dsc slice_array}}
{{dsc end}}

[[de:cpp/numeric/valarray/slice]]
[[es:cpp/numeric/valarray/slice]]
[[fr:cpp/numeric/valarray/slice]]
[[it:cpp/numeric/valarray/slice]]
[[ja:cpp/numeric/valarray/slice]]
[[pt:cpp/numeric/valarray/slice]]
[[ru:cpp/numeric/valarray/slice]]
[[zh:cpp/numeric/valarray/slice]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice array</title>
    <ns>0</ns>
    <id>12704</id>
    <revision>
      <id>61529</id>
      <parentid>61522</parentid>
      <timestamp>2013-06-06T03:12:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>separate navbar</comment>
      <text xml:space="preserve" bytes="958">{{cpp/title|slice_array}}
{{cpp/numeric/valarray/slice_array/navbar}}
{{dcl begin}}
{{dcl header | valarray}}
{{dcl | 
template&lt; class T &gt; class slice_array;
}}
{{dcl end}}

{{tt|std::slice_array}} is a helper template used by {{c|std::slice}} subscript operator. It has reference semantics to a subset of the array specified by the {{tt|std::slice}} object.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/array/dsc constructor | slice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc destructor | slice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator{{=}} | slice_array}}
{{dsc inc | cpp/numeric/valarray/array/dsc operator_arith | slice_array}}
{{dsc end}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc gslice_array}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice array/operator=</title>
    <ns>0</ns>
    <id>12730</id>
    <revision>
      <id>61552</id>
      <timestamp>2013-06-06T03:21:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="69">{{include page|cpp/numeric/valarray/array/operator{{=}}|slice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice array/operator arith</title>
    <ns>0</ns>
    <id>12736</id>
    <revision>
      <id>61558</id>
      <timestamp>2013-06-06T03:22:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="70">{{include page|cpp/numeric/valarray/array/operator_arith|slice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice array/slice array</title>
    <ns>0</ns>
    <id>12728</id>
    <revision>
      <id>61550</id>
      <timestamp>2013-06-06T03:21:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="67">{{include page|cpp/numeric/valarray/array/constructor|slice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/slice array/~slice array</title>
    <ns>0</ns>
    <id>12729</id>
    <revision>
      <id>61551</id>
      <timestamp>2013-06-06T03:21:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="66">{{include page|cpp/numeric/valarray/array/destructor|slice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/sqrt</title>
    <ns>0</ns>
    <id>4321</id>
    <revision>
      <id>71101</id>
      <parentid>67448</parentid>
      <timestamp>2014-06-05T20:57:18Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="2284">{{cpp/title|sqrt{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; sqrt( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes the square root of the value of the element.

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing square roots of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|sqrt}}

{{cpp/numeric/valarray/notes ret|sqrt}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; sqrt(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = sqrt(i);
    }
    return other;
}
}}

===Example===
{{example
|Finds real roots of multiple quadratic equations.
|code=
#include &lt;valarray&gt;
#include &lt;iostream&gt;

int main()
{
    std::valarray&lt;double&gt; a(1, 8);
    std::valarray&lt;double&gt; b{1, 2, 3, 4, 5, 6, 7, 8};
    std::valarray&lt;double&gt; c = -b;
    // literals must also be of type T (double in this case)
    std::valarray&lt;double&gt; d = std::sqrt((b * b - 4.0 * a * c));
    std::valarray&lt;double&gt; x1 = (-b - d) / (2.0 * a);
    std::valarray&lt;double&gt; x2 = (-b + d) / (2.0 * a);
    std::cout &lt;&lt; &quot;quadratic equation    root 1,  root 2&quot; &lt;&lt; &quot;\n&quot;;
    for (size_t i = 0; i &lt; a.size(); ++i) {
        std::cout &lt;&lt; a[i] &lt;&lt; &quot;x\u00B2 + &quot; &lt;&lt; b[i] &lt;&lt; &quot;x + &quot; &lt;&lt; c[i] &lt;&lt; &quot; = 0   &quot;;
        std::cout &lt;&lt; x1[i] &lt;&lt; &quot;, &quot; &lt;&lt; x2[i] &lt;&lt; &quot;\n&quot;;
    }
}
|output=
quadratic equation    root 1,  root 2
1x² + 1x + -1 = 0   -1.61803, 0.618034
1x² + 2x + -2 = 0   -2.73205, 0.732051
1x² + 3x + -3 = 0   -3.79129, 0.791288
1x² + 4x + -4 = 0   -4.82843, 0.828427
1x² + 5x + -5 = 0   -5.8541, 0.854102
1x² + 6x + -6 = 0   -6.87298, 0.872983
1x² + 7x + -7 = 0   -7.88748, 0.887482
1x² + 8x + -8 = 0   -8.89898, 0.898979
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc pow}}
{{dsc inc | cpp/numeric/math/dsc sqrt}}
{{dsc inc | cpp/numeric/complex/dsc sqrt}}
{{dsc end}}

[[de:cpp/numeric/valarray/sqrt]]
[[es:cpp/numeric/valarray/sqrt]]
[[fr:cpp/numeric/valarray/sqrt]]
[[it:cpp/numeric/valarray/sqrt]]
[[ja:cpp/numeric/valarray/sqrt]]
[[pt:cpp/numeric/valarray/sqrt]]
[[ru:cpp/numeric/valarray/sqrt]]
[[zh:cpp/numeric/valarray/sqrt]]</text>
      <sha1>s6vjd2uyihpoddkyje3nf1hfgt0jg2i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/sum</title>
    <ns>0</ns>
    <id>4554</id>
    <revision>
      <id>58807</id>
      <parentid>51094</parentid>
      <timestamp>2013-06-01T06:21:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1018">{{cpp/numeric/valarray/title|sum}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
T sum() const;
}}

Computes the sum of the elements. 

The function can be used only if {{c|operator+{{=}}}} is defined for type {{tt|T}}. If the {{tt|std::valarray}} is empty, the behavior is undefined. The order in which the elements are processed by this function is unspecified.

===Parameters===
(none)

===Return value===
The sum of the elements.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;valarray&gt;

int main()
{
    std::valarray&lt;int&gt; a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::cout &lt;&lt; a.sum() &lt;&lt; '\n';
}
 | output=
55
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc apply}}
{{dsc inc | cpp/algorithm/dsc accumulate}}
{{dsc end}}

[[de:cpp/numeric/valarray/sum]]
[[es:cpp/numeric/valarray/sum]]
[[fr:cpp/numeric/valarray/sum]]
[[it:cpp/numeric/valarray/sum]]
[[ja:cpp/numeric/valarray/sum]]
[[pt:cpp/numeric/valarray/sum]]
[[ru:cpp/numeric/valarray/sum]]
[[zh:cpp/numeric/valarray/sum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/swap</title>
    <ns>0</ns>
    <id>4550</id>
    <revision>
      <id>64843</id>
      <parentid>51095</parentid>
      <timestamp>2013-08-27T01:20:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcetp</comment>
      <text xml:space="preserve" bytes="667">{{cpp/numeric/valarray/title|swap}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
void swap( valarray&amp; other );
}}

Swaps the contents with those of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another valarray to swap the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/numeric/valarray/swap]]
[[es:cpp/numeric/valarray/swap]]
[[fr:cpp/numeric/valarray/swap]]
[[it:cpp/numeric/valarray/swap]]
[[ja:cpp/numeric/valarray/swap]]
[[pt:cpp/numeric/valarray/swap]]
[[ru:cpp/numeric/valarray/swap]]
[[zh:cpp/numeric/valarray/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/swap2</title>
    <ns>0</ns>
    <id>5487</id>
    <revision>
      <id>58808</id>
      <parentid>51096</parentid>
      <timestamp>2013-06-01T06:21:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="847">{{cpp/title | swap&lt;small&gt;(std::valarray)&lt;/small&gt;}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class T &gt;
void swap( valarray&lt;T&gt; &amp;lhs, valarray&lt;T&gt; &amp;rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::valarray}}. Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | valarrays whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc swap}}
{{dsc end}}

[[de:cpp/numeric/valarray/swap2]]
[[es:cpp/numeric/valarray/swap2]]
[[fr:cpp/numeric/valarray/swap2]]
[[it:cpp/numeric/valarray/swap2]]
[[ja:cpp/numeric/valarray/swap2]]
[[pt:cpp/numeric/valarray/swap2]]
[[ru:cpp/numeric/valarray/swap2]]
[[zh:cpp/numeric/valarray/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/tan</title>
    <ns>0</ns>
    <id>4324</id>
    <revision>
      <id>71089</id>
      <parentid>51097</parentid>
      <timestamp>2014-06-05T20:26:06Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1258">{{cpp/title|tan{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; tan( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes tangent of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing tangents of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|tan}}

{{cpp/numeric/valarray/notes ret|tan}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; tan(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = tan(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc sin}}
{{dsc inc | cpp/numeric/valarray/dsc cos}}
{{dsc inc | cpp/numeric/valarray/dsc atan}}
{{dsc inc | cpp/numeric/math/dsc tan}}
{{dsc inc | cpp/numeric/complex/dsc tan}}
{{dsc end}}

[[de:cpp/numeric/valarray/tan]]
[[es:cpp/numeric/valarray/tan]]
[[fr:cpp/numeric/valarray/tan]]
[[it:cpp/numeric/valarray/tan]]
[[ja:cpp/numeric/valarray/tan]]
[[pt:cpp/numeric/valarray/tan]]
[[ru:cpp/numeric/valarray/tan]]
[[zh:cpp/numeric/valarray/tan]]</text>
      <sha1>1txo6budh0a7bl5rf316523rbvq24u1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/tanh</title>
    <ns>0</ns>
    <id>9040</id>
    <revision>
      <id>71096</id>
      <parentid>58809</parentid>
      <timestamp>2014-06-05T20:47:36Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ links</comment>
      <text xml:space="preserve" bytes="1253">{{cpp/title|tanh{{small|(std::valarray)}}}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | header=valarray | 1=
template&lt; class T &gt;
valarray&lt;T&gt; tanh( const valarray&lt;T&gt;&amp; va );
}}

For each element in {{tt|va}} computes hyperbolic tangent of the value of the element. 

===Parameters===
{{par begin}}
{{par | va | value array to apply the operation to}}
{{par end}}

===Return value===
Value array containing hyperbolic tangent of the values in {{tt|va}}.

===Notes===
{{cpp/numeric/valarray/notes unq|tanh}}

{{cpp/numeric/valarray/notes ret|tanh}}

===Possible implementation===
{{eq fun | 1=
template&lt;class T&gt;
valarray&lt;T&gt; tanh(const valarray&lt;T&gt;&amp; va)
{
    valarray&lt;T&gt; other = va;
    for (T &amp;i : other) {
        i = tanh(i);
    }
}
}}

===Example===
{{example
|code=
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/valarray/dsc sinh}}
{{dsc inc | cpp/numeric/valarray/dsc cosh}}
{{dsc inc | cpp/numeric/math/dsc tanh}}
{{dsc inc | cpp/numeric/complex/dsc tanh}}
{{dsc end}}

[[de:cpp/numeric/valarray/tanh]]
[[es:cpp/numeric/valarray/tanh]]
[[fr:cpp/numeric/valarray/tanh]]
[[it:cpp/numeric/valarray/tanh]]
[[ja:cpp/numeric/valarray/tanh]]
[[pt:cpp/numeric/valarray/tanh]]
[[ru:cpp/numeric/valarray/tanh]]
[[zh:cpp/numeric/valarray/tanh]]</text>
      <sha1>186rhktw7y9hspfgm32dqr44s9aqze9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/valarray</title>
    <ns>0</ns>
    <id>9028</id>
    <revision>
      <id>65500</id>
      <parentid>64877</parentid>
      <timestamp>2013-09-16T23:16:18Z</timestamp>
      <contributor>
        <ip>178.214.35.69</ip>
      </contributor>
      <comment>default-initialized -&gt; value-initialized (ISO/IEC 14882:2011 26.6.2.2)</comment>
      <text xml:space="preserve" bytes="2281">{{cpp/numeric/valarray/title|valarray}}
{{cpp/numeric/valarray/navbar}}
{{dcl begin}}
{{dcl | num=1 | 
valarray();
}}
{{dcl | num=2 | 
explicit valarray( size_t count );
}}
{{dcl | num=3 | 
valarray( const T&amp; val, size_t count );
}}
{{dcl | num=4 | 
valarray( const T* vals, size_t count );
}}
{{dcl | num=5 | 
valarray( const valarray&amp; other );
}}
{{dcl | num=6 | since=c++11 | 
valarray( valarray&amp;&amp; other );
}}
{{dcl | num=7 | 
valarray( const std::slice_array&lt;T&gt;&amp; );
}}
{{dcl | num=8 | 
valarray( const std::gslice_array&lt;T&gt;&amp; );
}}
{{dcl | num=9 | 
valarray( const std::mask_array&lt;T&gt;&amp; );
}}
{{dcl | num=10 | 
valarray( const std::indirect_array&lt;T&gt;&amp; );
}}
{{dcl | num=11 | since=c++11 | 
valarray( std::initializer_list&lt;T&gt; il );
}}
{{dcl end}}

Constructs new numeric array from various sources.
@1@ Default constructor. Constructs an empty numeric array.
@2@ Constructs a numeric array with {{tt|count}} copies of value-initialized elements.
@3@ Constructs a numeric array with {{tt|count}} copies of {{tt|val}} or {{tt|*val}} respectively.
@4@ Constructs a numeric array with copies of {{tt|count}} values from an array pointed to by {{tt|vals}}. If this array contains less than {{tt|count}} values, the behavior is undefined.
@5@ Copy constructor. Constructs the numeric array with the copy of the contents of {{tt|other}}.
@6@ Move constructor. Constructs the container with the contents of {{tt|other}} using move semantics.
{{todo}}
@11@ Constructs the numeric array with the contents of the initializer list {{tt|il}}. 

===Parameters===
{{par begin}}
{{par | count | the number of elements to construct}}
{{par | val | the value to initialize the elements with}}
{{par | other | another numeric array to use as source to initialize the contents}}
{{todo}}
{{par | il | initializer list to initialize the elements with}}
{{par end}}

===Exceptions===
@1-5@ (none)
@6@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
@7-11@ (none)

[[de:cpp/numeric/valarray/valarray]]
[[es:cpp/numeric/valarray/valarray]]
[[fr:cpp/numeric/valarray/valarray]]
[[it:cpp/numeric/valarray/valarray]]
[[ja:cpp/numeric/valarray/valarray]]
[[pt:cpp/numeric/valarray/valarray]]
[[ru:cpp/numeric/valarray/valarray]]
[[zh:cpp/numeric/valarray/valarray]]</text>
      <sha1>ov5nlj8lzkz7che07uu80nk47qjuo4f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/numeric/valarray/~valarray</title>
    <ns>0</ns>
    <id>9029</id>
    <revision>
      <id>41935</id>
      <parentid>37938</parentid>
      <timestamp>2012-11-02T21:11:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="572">{{cpp/numeric/valarray/title|~valarray}}
{{cpp/numeric/valarray/navbar}}
{{ddcl | 
~valarray()
}}

Destructs the numeric array. The destructors of the elements are called and the used storage is deallocated. 

===Complexity===
Linear in the size of the numeric array.

[[de:cpp/numeric/valarray/~valarray]]
[[es:cpp/numeric/valarray/~valarray]]
[[fr:cpp/numeric/valarray/~valarray]]
[[it:cpp/numeric/valarray/~valarray]]
[[ja:cpp/numeric/valarray/~valarray]]
[[pt:cpp/numeric/valarray/~valarray]]
[[ru:cpp/numeric/valarray/~valarray]]
[[zh:cpp/numeric/valarray/~valarray]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor</title>
    <ns>0</ns>
    <id>1379</id>
    <revision>
      <id>72163</id>
      <parentid>71757</parentid>
      <timestamp>2014-07-19T14:36:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no #warning in C++</comment>
      <text xml:space="preserve" bytes="2498">{{title|Preprocessor}}
{{cpp/preprocessor/navbar}}
The preprocessor is executed at [[cpp/language/translation_phases|translation phase 4]], before the compilation. The result of preprocessing is a single file which is then passed to the actual compiler.

===Directives===

The preprocessing directives control the behavior of the preprocessor. Each directive occupies one line and has the following format:

* {{tt|#}} character
* preprocessing instruction (one of {{tt|define}}, {{tt|undef}}, {{tt|include}}, {{tt|if}}, {{tt|ifdef}}, {{tt|ifndef}}, {{tt|else}}, {{tt|elif}}, {{tt|endif}}, {{tt|line}}, {{tt|error}}, {{tt|pragma}}) &lt;ref&gt;These are the directives defined by the standard. The standard does not define behavior for other directives: they might be ignored, have some useful meaning, or  cause a compile-time error. Even if otherwise ignored, they are removed from the source code when the preprocessor is done. A common non-standard extension is the directive {{tt|#warning}} which emits a user-defined message during compilation.&lt;/ref&gt;
* arguments (depends on the instruction)
* line break

The null directive ({{tt|#}} followed by a line break) is allowed and has no effect.

===Capabilities===

The preprocessor has the source file translation capabilities:

* '''{{rl | conditional | conditionally}}''' compile of parts of source file (controlled by directive {{tt|#if}}, {{tt|#ifdef}}, {{tt|#ifndef}}, {{tt|#else}}, {{tt|#elif}} and {{tt|#endif}}).
* '''{{rl | replace}}''' text macros while possibly concatenating or quoting identifiers (controlled by directives {{tt|#define}} and {{tt|#undef}}, and operators {{tt|#}} and {{tt|##}})
* '''{{rl|include}}''' other files (controlled by directive {{tt|#include}})
* cause an '''{{rl|error}}''' (controlled by directive {{tt|#error}})

The following aspects of the preprocessor can be controlled:
* '''{{rl|impl | implementation defined}}''' behavior (controlled by directives {{tt|#pragma}})
* '''{{rl|line | file name and line information}}''' available to the preprocessor (controlled by directives {{tt|#line}})

===Footnotes===
&lt;references/&gt;

===See also===
{{dsc begin}}
{{dsc see c | c/preprocessor}}
{{dsc end}}

[[ar:cpp/preprocessor]]
[[cs:cpp/preprocessor]]
[[de:cpp/preprocessor]]
[[es:cpp/preprocessor]]
[[fr:cpp/preprocessor]]
[[it:cpp/preprocessor]]
[[ja:cpp/preprocessor]]
[[ko:cpp/preprocessor]]
[[pl:cpp/preprocessor]]
[[pt:cpp/preprocessor]]
[[ru:cpp/preprocessor]]
[[tr:cpp/preprocessor]]
[[zh:cpp/preprocessor]]</text>
      <sha1>sjxplxesu1tm30nrkrtdqlg7yj2g3b1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/conditional</title>
    <ns>0</ns>
    <id>1380</id>
    <revision>
      <id>67101</id>
      <parentid>64348</parentid>
      <timestamp>2014-01-22T13:54:23Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>bugs fixed</comment>
      <text xml:space="preserve" bytes="3933">{{title|Conditional inclusion}}
{{cpp/preprocessor/navbar}}
The preprocessor supports conditional compilation of parts of source file. This behavior is controlled by {{tt|#if}}, {{tt|#else}}, {{tt|#elif}}, {{tt|#ifdef}}, {{tt|#ifndef}} and {{tt|#endif}} directives.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#if}} {{spar|expression}} }}
{{sdsc | {{ttb|#ifdef}} {{spar|expression}} }}
{{sdsc | {{ttb|#ifndef}} {{spar|expression}} }}
{{sdsc | {{ttb|#elif}} {{spar|expression}} }}
{{sdsc | {{ttb|#else}} }}
{{sdsc | {{ttb|#endif}} }}
{{sdsc end}}

===Explanation===

The conditional preprocessing block starts with {{tt|#if}}, {{tt|#ifdef}} or {{tt|#ifndef}} directive, then optionally includes any number of {{tt|#elif}} directives, then optionally includes at most one {{tt|#else}} directive and is terminated with {{tt|#endif}} directive. Any inner conditional preprocessing blocks are processed separately.

Each of {{tt|#if}}, {{tt|#elif}}, {{tt|#else}}, {{tt|#ifdef}} and {{tt|#ifndef}} directives control code block until first {{tt|#elif}}, {{tt|#else}}, {{tt|#endif}} directive not belonging to any inner conditional preprocessing blocks. 

{{tt|#if}}, {{tt|#ifdef}} and {{tt|#ifndef}}  directives test the specified condition (see below) and if it evaluates to true, compiles the controlled code block. In that case subsequent {{tt|#else}} and {{tt|#elif}} directives are ignored. Otherwise, if the specified condition evaluates false, the controlled code block is skipped and the subsequent {{tt|#else}} or {{tt|#elif}} directive (if any) is processed. In the former case, the code block controlled by the {{tt|#else}} directive is unconditionally compiled. In the latter case, the {{tt|#elif}} directive acts as if it was {{tt|#if}} directive: checks for condition, compiles or skips the controlled code block based on the result, and in the latter case processes subsequent {{tt|#elif}} and {{tt|#else}} directives. The conditional preprocessing block is terminated by {{tt|#endif}} directive.

===Condition evaluation===

===={{tt|#if, #elif}}====

The {{spar|expression}} is a constant expression, using only [[cpp/language/expressions#Literals|literals]] and identifiers, defined using {{ltt|cpp/preprocessor/replace | #define}} directive. Any identifier, which is not literal, non defined using {{tt|#define}} directive, evaluates to ''0''. 

The expression may contain unary operators in form {{tt|defined}}&amp;nbsp;{{spar|identifier}} or  {{tt|defined (}}{{spar|identifier}}{{tt|)}} which return {{c|1}} if the {{spar|identifier}} was defined using {{ltt|cpp/preprocessor/replace | #define}} directive and ''0'' otherwise. If the {{spar|expression}} evaluates to nonzero value, the controlled code block is included and skipped otherwise. If any used identifier is not a constant, it is replaced with {{c|0}}.

===={{tt|#ifdef, #ifndef}}====

Checks if the identifier was defined using {{ltt|cpp/preprocessor/replace | #define}} directive. 

{{tt|#ifdef}}&amp;nbsp;{{spar|identifier}} is essentially equivalent to {{tt|#if defined(}}&amp;nbsp;{{spar|identifier}}{{tt|)}}.

{{tt|#ifndef}}&amp;nbsp;{{spar|identifier}} is essentially equivalent to {{tt|#if !defined(}}&amp;nbsp;{{spar|identifier}}{{tt|)}}.

===Example===
{{example|
|code=
#define ABCD 2
#include &lt;iostream&gt;

int main()
{

#ifdef ABCD
    std::cout &lt;&lt; &quot;1: yes\n&quot;;
#else
    std::cout &lt;&lt; &quot;1: no\n&quot;;
#endif

#ifndef ABCD
    std::cout &lt;&lt; &quot;2: no1\n&quot;;
#elif ABCD == 2
    std::cout &lt;&lt; &quot;2: yes\n&quot;;
#else
    std::cout &lt;&lt; &quot;2: no2\n&quot;;
#endif

#if !defined(DCBA) &amp;&amp; (ABCD &lt; 2*4-3)
    std::cout &lt;&lt; &quot;3: yes\n&quot;;
#endif
}
|output=
1: yes
2: yes
3: yes
}}

[[ar:cpp/preprocessor/conditional]]
[[de:cpp/preprocessor/conditional]]
[[es:cpp/preprocessor/conditional]]
[[fr:cpp/preprocessor/conditional]]
[[it:cpp/preprocessor/conditional]]
[[ja:cpp/preprocessor/conditional]]
[[pt:cpp/preprocessor/conditional]]
[[ru:cpp/preprocessor/conditional]]
[[zh:cpp/preprocessor/conditional]]</text>
      <sha1>e4eibw4y6d627mxb9jg6v94kzlsx30d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/error</title>
    <ns>0</ns>
    <id>1381</id>
    <revision>
      <id>72165</id>
      <parentid>51101</parentid>
      <timestamp>2014-07-19T14:38:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-warning</comment>
      <text xml:space="preserve" bytes="790">{{title|Error directive}}
{{cpp/preprocessor/navbar}}
Shows given message and renders program ill-formed.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#error}} {{spar|error_message}} }}
{{sdsc end}}

===Explanation===

After encountering {{tt|#error}} directive, diagnostic message {{spar|error_message}} is shown and the program is rendered ill-formed (the compilation is stopped). 

''error_message'' can consist of several words not necessarily in quotes. 

[[ar:cpp/preprocessor/error]]
[[cs:cpp/preprocessor/error]]
[[de:cpp/preprocessor/error]]
[[es:cpp/preprocessor/error]]
[[fr:cpp/preprocessor/error]]
[[it:cpp/preprocessor/error]]
[[ja:cpp/preprocessor/error]]
[[pl:cpp/preprocessor/error]]
[[pt:cpp/preprocessor/error]]
[[ru:cpp/preprocessor/error]]
[[zh:cpp/preprocessor/error]]</text>
      <sha1>tmjnmrv68yct9wowxs7cpnyygjwghk4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/impl</title>
    <ns>0</ns>
    <id>1382</id>
    <revision>
      <id>69255</id>
      <parentid>51102</parentid>
      <timestamp>2014-04-01T16:36:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>ub when not at the top of the block (thanks to Oracle compiler for warning me)</comment>
      <text xml:space="preserve" bytes="2958">{{title|Implementation defined behavior control}}
{{cpp/preprocessor/navbar}}
Implementation defined behavior is controlled by {{tt|#pragma}} directive.

===Syntax===

{{sdsc begin}}
{{sdsc | {{ttb|#pragma}} {{spar|pragma_params}} }}
{{sdsc end}}

===Explanation===

Pragma directive controls implementation-specific behavior of the compiler, such as disabling compiler warnings or changing alignment requirements. Any pragma that is not recognized is ignored.

===Standard pragmas===

The following three pragmas are defined by the language standard:

{{sdsc begin}}
{{sdsc | num = 1 | {{ttb|#pragma STDC FENV_ACCESS }}{{spar|arg}}}}
{{sdsc | num = 2 | {{ttb|#pragma STDC FP_CONTRACT }}{{spar|arg}}}}
{{sdsc | num = 3 | {{ttb|#pragma STDC CX_LIMITED_RANGE }}{{spar|arg}}}}
{{sdsc end}}

where {{spar|arg}} is either {{ttb|ON}} or {{ttb|OFF}} or {{ttb|DEFAULT}}. 

@1@ If set to {{ttb|ON}}, informs the compiler that the program will access or modify [[cpp/numeric/fenv|floating-point environment]], which means that optimizations that could subvert flag tests and mode changes (e.g., global common subexpression elimination, code motion, and constant folding) are prohibited. The default value is implementation-defined, usually {{ttb|OFF}}.
@2@ Allows ''contracting'' of floating-point expressions, that is optimizations that omit rounding errors and floating-point exceptions that would be observed if the expression was evaluated exactly as written. The default value is implementation-defined, usually {{ttb|ON}}.
@3@ Informs the compiler that multiplication, division, and absolute value of complex numbers may use simplified mathematical formulas, despite the possibility of intermediate overflow. The range of the values passed to those function is expected to be limited. The default value is {{ttb|OFF}}

The behavior of the program is undefined if any of the three pragmas above appear in any context other than outside all external declarations or preceding all explicit declarations and statements inside a compound statement.
===External links===

* [http://msdn.microsoft.com/en-us/library/d9x1s805(v=VS.100).aspx C++ pragmas in Visual Studio 2010]
* [http://gcc.gnu.org/onlinedocs/gcc-4.6.2/gcc/Pragmas.html#Pragmas Pragmas] accepted by GCC 4.6.2
* [http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/topic/com.ibm.vacpp7a.doc/compiler/ref/rupragen.htm General Purpose Pragmas] in IBM AIX XL C/C++ V7.0
* [http://download.oracle.com/docs/cd/E19422-01/819-3690/Pragmas_App.html#73499 Appendix B. Pragmas] in Sun Studio 11 C++ User's Guide
* [http://software.intel.com/sites/products/documentation/hpc/compilerpro/en-us/cpp/lin/compiler_c/cref_cls/common/cppref_pragma_ovrvw.htm Intel C++ compiler pragmas]

[[de:cpp/preprocessor/impl]]
[[es:cpp/preprocessor/impl]]
[[fr:cpp/preprocessor/impl]]
[[it:cpp/preprocessor/impl]]
[[ja:cpp/preprocessor/impl]]
[[pt:cpp/preprocessor/impl]]
[[ru:cpp/preprocessor/impl]]
[[zh:cpp/preprocessor/impl]]</text>
      <sha1>nxb4l008qh5983gr0w2vu1bufry8r0p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/include</title>
    <ns>0</ns>
    <id>1383</id>
    <revision>
      <id>71863</id>
      <parentid>67210</parentid>
      <timestamp>2014-06-29T13:08:33Z</timestamp>
      <contributor>
        <ip>61.164.214.37</ip>
      </contributor>
      <comment>reword, add an example and see also</comment>
      <text xml:space="preserve" bytes="1889">{{title|Source file inclusion}}
{{cpp/preprocessor/navbar}}
Includes other source file into current source file at the line immediately after the directive .

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#include &amp;lt;}}{{spar|filename}}{{ttb|&amp;gt;}} }}
{{sdsc | num=2 | {{ttb|#include &quot;}}{{spar|filename}}{{ttb|&quot;}} }}
{{sdsc end}}

===Explanation===

Includes source file, identified by {{spar|filename}} into the current source file at the line immediately after the directive. In the case the file is not found, program is ill-formed.

@1@ searches only standard include directories. The standard C++ library, as well as standard C library, is implicitly included in standard include directories. The standard include directories can be controlled by the user through compiler options. 

@2@ firstly searches the directory where the current file resides and, only if the file is not found, searches the standard include directories.

Any preprocessing tokens (macro constants or expressions) are permitted as arguments to {{tt|#include}} as long as they expand to a sequence of characters surrounded by {{ttb|&lt;}} {{ttb|&gt;}} or {{ttb|&quot;}} {{ttb|&quot;}}.

===Example===
{{example|code=
#ifndef TEXT
    #include &lt;iostream&gt;

    int main()
    {
    #define TEXT &quot;Hello, world!&quot;
    #include __FILE__
    #define TEXT &quot;Hello again!&quot;
    #include __FILE__

    }
#else
    std::cout &lt;&lt; TEXT &lt;&lt; '\n';
    #undef TEXT
#endif
|output=
Hello, world!
Hello again!
}}

===See also===
{{dsc begin}}
{{dsc|[[cpp/header]]|a list of C++ Standard Library header files}}
{{dsc end}}

[[ar:cpp/preprocessor/include]]
[[de:cpp/preprocessor/include]]
[[es:cpp/preprocessor/include]]
[[fr:cpp/preprocessor/include]]
[[it:cpp/preprocessor/include]]
[[ja:cpp/preprocessor/include]]
[[pl:cpp/preprocessor/include]]
[[pt:cpp/preprocessor/include]]
[[ru:cpp/preprocessor/include]]
[[zh:cpp/preprocessor/include]]</text>
      <sha1>rkfqgkimlg4e0b18h7emg0jlcc0i0dg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/line</title>
    <ns>0</ns>
    <id>1384</id>
    <revision>
      <id>65854</id>
      <parentid>61010</parentid>
      <timestamp>2013-10-10T15:13:04Z</timestamp>
      <contributor>
        <ip>71.95.191.2</ip>
      </contributor>
      <comment>there was no number before the list element...</comment>
      <text xml:space="preserve" bytes="1694">{{title|Filename and line information}}
{{cpp/preprocessor/navbar}}

Changes the current file name and number in the preprocessor.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#line}} {{spar|lineno}}}}
{{sdsc | num=2 |  {{ttb|#line}} {{spar|lineno}} {{ttb|&quot;}}{{spar|filename}}{{ttb|&quot;}} }}
{{sdsc end}}

===Explanation===

1) Changes the current preprocessor line number to {{spar|lineno}}. Expansions of the macro {{c|__LINE__}} beyond this point will expand to {{spar|lineno}} plus the number of actual source code lines encountered since.

2) Also changes the current preprocessor file name to {{spar|filename}}. Expansions of the macro {{c|__FILE__}} from this point will produce {{spar|filename}}.

Any preprocessing tokens (macro constants or expressions) are permitted as arguments to {{tt|#line}} as long as they expand to a valid decimal integer optionally following a valid character string.

===Notes===
This directive is used by some automatic code generation tools which produce C++ source files from a file written in another language. In that case, {{tt|#line}} directives may be inserted in the generated C++ file referencing line numbers and the file name of the original (human-editable) source file.

===Example===
{{example | code=
#include &lt;cassert&gt;
#define FNAME &quot;test.cc&quot;
int main()
{
#line 777 FNAME
        assert(2+2 == 5);
}
 | output=
test: test.cc:777: int main(): Assertion `2+2 == 5' failed.
}}

[[cs:cpp/preprocessor/line]]
[[de:cpp/preprocessor/line]]
[[es:cpp/preprocessor/line]]
[[fr:cpp/preprocessor/line]]
[[it:cpp/preprocessor/line]]
[[ja:cpp/preprocessor/line]]
[[pt:cpp/preprocessor/line]]
[[ru:cpp/preprocessor/line]]
[[zh:cpp/preprocessor/line]]</text>
      <sha1>18s03aour7w8olmxlewfy9zjkibs1eb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/preprocessor/replace</title>
    <ns>0</ns>
    <id>1385</id>
    <revision>
      <id>72001</id>
      <parentid>71851</parentid>
      <timestamp>2014-07-08T12:29:01Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="8105">{{title|Replacing text macros}}
{{cpp/preprocessor/navbar}}
The preprocessor supports text macro replacement. Function-like text macro replacement is also supported.

===Syntax===

{{sdsc begin}}
{{sdsc | num=1 | {{ttb|#define}} {{spar|identifier}} {{spar|replacement-list}} }}
{{sdsc | num=2 | {{ttb|#define}} {{spar|identifier}}{{ttb|(}} {{spar|parameters}} {{ttb|)}} {{spar|replacement-list}} }}
{{sdsc | num=3 | {{ttb|#define}} {{spar|identifier}}{{ttb|(}} {{spar|parameters}}{{ttb|, ... )}} {{spar|replacement-list}} | notes = {{mark since c++11}} }}
{{sdsc | num=4 | {{ttb|#define}} {{spar|identifier}}{{ttb|( ... )}} {{spar|replacement-list}} | notes = {{mark since c++11}} }}
{{sdsc | num=5 | {{ttb|#undef }} {{spar|identifier}} }}
{{sdsc end}}

===Explanation===

===={{tt|#define}} directives====

The {{tt|#define}} directives define the {{spar|identifier}} as macro, that is instruct the compiler to replace all successive occurrences of {{spar|identifier}} with {{spar|replacement-list}}, which can be optionally additionally processed. If the identifier is already defined as any type of macro , the program is ill-formed unless the definitions are identical. 

=====Object-like macros=====

Object-like macros replace every occurrence of defined {{spar|identifier}} with {{spar|replacement-list}}. Version (1) of the {{tt|#define}} directive behaves exactly like that.

=====Function-like macros=====

Function-like macros replace each occurrence of defined {{spar|identifier}} with {{spar|replacement-list}}, additionally taking a number of arguments, which then replace corresponding occurrences of any of the {{spar|parameters}} in the {{spar|replacement-list}}. The number of arguments must be the same as the number of arguments in macro definition ({{spar|parameters}}) or the program is ill-formed. If the identifier is not in functional-notation, i.e. does not have parentheses after itself, it is not replaced at all.

Version (2) of the {{tt|#define}} directive defines a simple function-like macro.

Version (3) of the {{tt|#define}} directive defines a function-like macro with variable number of arguments. The additional arguments can be accessed using {{tt|__VA_ARGS__}} identifier, which is then replaced with arguments, supplied with the identifier to be replaced.

Version (4) of the {{tt|#define}} directive defines a function-like macro with variable number of arguments, but no regular arguments. The arguments can be accessed only with {{tt|__VA_ARGS__}} identifier, which is then replaced with arguments, supplied with identifier to be replaced.

===={{tt|#}} and {{tt|##}} operators====

In function-like macros, a {{tt|#}} operator before an identifier in the {{spar|replacement-list}} runs the identifier through parameter replacement and encloses the result in quotes, effectively creating a string literal. In addition, the preprocessor adds backslashes to escape the quotes surrounding embedded string literals, if any, and doubles the backslashes within the string as necessary. All leading and trailing whitespace is removed, and any sequence of whitespace in the middle of the text (but not inside embedded string literals) is collapsed to a single space. This operation is called &quot;stringification&quot;. If the result of stringification is not a valid string literal, the behavior is undefined.

A {{tt|##}} operator between any two successive identifiers in the {{spar|replacement-list}} runs parameter replacement on the two identifiers (which are not macro-expanded first) and then concatenates the result. This operation is called &quot;concatenation&quot; or &quot;token pasting&quot;. Only tokens that form a valid token together may be pasted: identifiers that form a longer identifier, digits that form a number, or operators {{tt|+}} and {{tt|{{=}}}} that form a {{tt|+{{=}}}}. A comment cannot be created by pasting {{tt|/}} and {{tt|*}} because comments are removed from text before macro substitution is considered. If the result of concatenation is not a valid token, the behavior is undefined.

===={{tt|#undef}} directive====

The {{tt|#undef}} directive undefines the {{spar|identifier}}, that is cancels previous definition of the {{spar|identifier}} by {{tt|#define}} directive. If the identifier does not have associated macro, the directive is ignored.

===Predefined macros===
The following macro names are predefined in any translation unit.
{{dsc begin}}
{{dsc macro const | __cplusplus | nolink=true | denotes the version of C++ standard that is being used, expands to value 199711L{{mark until c++11}}, 201103L{{mark c++11}}, or 201402L{{mark c++14}}}}
{{dsc macro const | __STDC_HOSTED__ | nolink=true | expands to the integer constant {{c|1}} if the implementation is hosted (runs under an OS), {{c|0}} if freestanding (runs without an OS) | notes={{mark c++11}}}}
{{dsc macro const | __FILE__ | nolink=true | expands to the name of the current file, as a character string literal, can be changed by the {{rlp|line|#line}} directive}}
{{dsc macro const | __LINE__ | nolink=true | expands to the source file line number, an integer constant, can be changed by the {{rlp|line|#line}} directive}}
{{dsc macro const | __DATE__ | nolink=true | expands to the date of translation, a character string literal of the form &quot;Mmm dd yyyy&quot;. The name of the month is as if generated by {{c|std::asctime()}}}}
{{dsc macro const | __TIME__ | nolink=true | expands to the time of translation, a character string literal of the form &quot;hh:mm:ss&quot;}}
{{dsc end}}

The following additional macro names may be predefined by the implementations.
{{dsc begin}}
{{dsc macro const | __STDC__ | nolink=true | implementation-defined value, if present, typically used to indicate C conformance}}
{{dsc macro const | __STDC_VERSION__ | nolink=true | implementation-defined value, if present| notes={{mark c++11}}}}
{{dsc macro const | __STDC_ISO_10646__ | nolink=true | expands to an integer constant of the form {{tt|yyyymmL}}, if {{c|wchar_t}} uses Unicode, the date indicates the latest revision of Unicode supported| notes={{mark c++11}}}}
{{dsc macro const | __STDC_MB_MIGHT_NEQ_WC__ | nolink=true | expands to {{c|1}} if wide character encoding of the basic character set may not equal their narrow encoding| notes={{mark c++11}}}}
{{dsc macro const | __STDCPP_STRICT_POINTER_SAFETY__ | nolink=true | expands to {{c|1}} if the implementation has strict {{lc|std::pointer_safety}}| notes={{mark c++11}}}}
{{dsc macro const | __STDCPP_THREADS__ | nolink=true | expands to {{c|1}} if the program can have more than one thread of execution| notes={{mark c++11}}}}
{{dsc end}}

The values of these macros (except for {{tt|__FILE__}} and {{tt|__LINE__}}) remain constant throughout the translation unit. Attempts to redefine or undefine these macros result in undefined behavior.

Note: in the scope of every function body, there is a special function-local predefined variable named {{c|__func__}}{{mark since c++11}}, defined as a static character array holding the name of the function in implementation-defined format. It is not a preprocessor macro, but it is used together with {{tt|__FILE__}} and {{tt|__LINE__}}, e.g. by {{lc|assert}}.

===Example===
{{example | code=
#include &lt;iostream&gt;

//make function factory and use it
#define FUNCTION(name, a) int fun_##name() { return a;}

FUNCTION(abcd, 12);
FUNCTION(fff, 2);
FUNCTION(qqq, 23);

#undef FUNCTION
#define FUNCTION 34
#define OUTPUT(a) std::cout &lt;&lt; #a &lt;&lt; '\n'

int main()
{
    std::cout &lt;&lt; &quot;abcd: &quot; &lt;&lt; fun_abcd() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;fff: &quot; &lt;&lt; fun_fff() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;qqq: &quot; &lt;&lt; fun_qqq() &lt;&lt; '\n';
    std::cout &lt;&lt; FUNCTION &lt;&lt; '\n';
    OUTPUT(million);               //note the lack of quotes
}
| output=
abcd: 12
fff: 2
qqq: 23
34
million
}}

==See also==
{{dsc begin}}
{{dsc see c | c/preprocessor/replace | Replacing text macros}}
{{dsc end}}
[[de:cpp/preprocessor/replace]]
[[es:cpp/preprocessor/replace]]
[[fr:cpp/preprocessor/replace]]
[[it:cpp/preprocessor/replace]]
[[ja:cpp/preprocessor/replace]]
[[pt:cpp/preprocessor/replace]]
[[ru:cpp/preprocessor/replace]]
[[zh:cpp/preprocessor/replace]]</text>
      <sha1>srzpqqy8z5kbnloa3bem9voebbx6i0o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex</title>
    <ns>0</ns>
    <id>1387</id>
    <revision>
      <id>66983</id>
      <parentid>66954</parentid>
      <timestamp>2014-01-15T09:28:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="4552">{{title|Regular expressions library}}
{{cpp/regex/navbar}}

{{dsc begin}}
{{dsc header | regex }}
{{dsc end}}

The regular expressions library provides a class that represents [[enwiki:Regular expression|regular expressions]], which are a kind of mini-language used to perform pattern matching within strings. Almost all operations with regexes can be characterized by operating on several of the following objects:

* '''Target sequence'''. The character sequence that is searched for a pattern. This may be a range specified by two iterators, a null-terminated character string or {{lc|std::string}}.

* '''Pattern'''. This is the regular expression itself. It determines what constitutes a match. It is an object of type {{lc|std::basic_regex}}, constructed from a string with special syntax. See [[cpp/regex/syntax_option_type | syntax_option_type]] for the description of supported syntax variations.

* '''Matched array'''. The information about matches may be retrieved as an object of type {{lc|std::match_results}}.

* '''Replacement string'''. This is a string that determines how to replace the matches, see [[cpp/regex/match_flag_type | match_flag_type]] for the description of supported syntax variations. 

===Main classes===

These classes encapsulate a regular expression and the results of matching a regular expression within a target sequence of characters.

{{dsc begin}}
{{dsc inc | cpp/regex/dsc basic_regex }}
{{dsc inc | cpp/regex/dsc sub_match }}
{{dsc inc | cpp/regex/dsc match_results }}
{{dsc end}}

===Algorithms===

These functions are used to apply the regular expression encapsulated in a regex to a target sequence of characters.

{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_match }}
{{dsc inc | cpp/regex/dsc regex_search }}
{{dsc inc | cpp/regex/dsc regex_replace }}
{{dsc end}}

===Iterators===

The regex iterators are used to traverse the entire set of regular expression matches found within a sequence.

{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_iterator }}
{{dsc inc | cpp/regex/dsc regex_token_iterator }}
{{dsc end}}

===Exceptions===

This class defines the type of objects thrown as exceptions to report errors from the regular expressions library.

{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_error }}
{{dsc end}}

===Traits===

The regex traits class is used to encapsulate the localizable aspects of a regex.

{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_traits }}
{{dsc end}}

===Constants===

{{dsc begin}}
{{dsc namespace | std::regex_constants }}
{{dsc inc | cpp/regex/dsc syntax_option_type}}
{{dsc inc | cpp/regex/dsc match_flag_type}}
{{dsc inc | cpp/regex/dsc error_type}}
{{dsc end}}

===Example===
{{example | {{small|Note: only upcoming GCC 4.9 supports C++11 regexes. Please select clang 3.4 (C++11) at the moment}}
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    std::string s = &quot;Some people, when confronted with a problem, think &quot;
        &quot;\&quot;I know, I'll use regular expressions.\&quot; &quot;
        &quot;Now they have two problems.&quot;;

    std::regex self_regex(&quot;REGULAR EXPRESSIONS&quot;,
            std::regex_constants::ECMAScript {{!}} std::regex_constants::icase);
    if (std::regex_search(s, self_regex)) {
        std::cout &lt;&lt; &quot;Text contains the phrase 'regular expressions'\n&quot;;
    }

    std::regex word_regex(&quot;(\\S+)&quot;);
    auto words_begin = 
        std::sregex_iterator(s.begin(), s.end(), word_regex);
    auto words_end = std::sregex_iterator();

    std::cout &lt;&lt; &quot;Found &quot;
              &lt;&lt; std::distance(words_begin, words_end)
              &lt;&lt; &quot; words\n&quot;;

    const int N = 6;
    std::cout &lt;&lt; &quot;Words longer than &quot; &lt;&lt; N &lt;&lt; &quot; characters:\n&quot;;
    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
        std::smatch match = *i;
        std::string match_str = match.str();
        if (match_str.size() &gt; N) {
            std::cout &lt;&lt; &quot;  &quot; &lt;&lt; match_str &lt;&lt; '\n';
        }
    }

    std::regex long_word_regex(&quot;(\\w{7,})&quot;);
    std::string new_s = std::regex_replace(s, long_word_regex, &quot;[$&amp;]&quot;);
    std::cout &lt;&lt; new_s &lt;&lt; '\n';
}
 | output=
Text contains the phrase 'regular expressions'
Found 19 words
Words longer than 6 characters:
  people,
  confronted
  problem,
  regular
  expressions.&quot;
  problems.
Some people, when [confronted] with a [problem], think 
&quot;I know, I'll use [regular] [expressions].&quot; Now they have two [problems].
}}

[[ar:cpp/regex]]
[[de:cpp/regex]]
[[es:cpp/regex]]
[[fr:cpp/regex]]
[[it:cpp/regex]]
[[ja:cpp/regex]]
[[ko:cpp/regex]]
[[pt:cpp/regex]]
[[ru:cpp/regex]]
[[zh:cpp/regex]]</text>
      <sha1>31goir732f42zb3f69k07rhxv9vx33z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex</title>
    <ns>0</ns>
    <id>2279</id>
    <revision>
      <id>72320</id>
      <parentid>67151</parentid>
      <timestamp>2014-08-08T14:09:10Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2048">{{cpp/title|basic_regex}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
template &lt;
    class CharT,
    class Traits = std::regex_traits&lt;CharT&gt;
&gt; class basic_regex;
}}

The class template {{tt|basic_regex}} provides a general framework for holding regular expressions. 

Several specializations for common character types are provided:
{{dsc begin}}
{{dsc header | regex}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|regex}} | {{c|basic_regex&lt;char&gt;}}}}
{{dsc | {{tt|wregex}} | {{c|basic_regex&lt;wchar_t&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{c|CharT}}}}
{{dsc | {{tt|traits_type}} | {{c|Traits}}}}
{{dsc | {{tt|string_type}} | {{c|Traits::string_type}}}}
{{dsc | {{tt|locale_type}} | {{c|Traits::locale_type}}}}
{{dsc | {{tt|flag_type}} | {{lc|std::regex_constants::syntax_option_type}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc constructor}}
{{dsc inc | cpp/regex/basic_regex/dsc destructor}}
{{dsc inc | cpp/regex/basic_regex/dsc operator{{=}}}}
{{dsc inc | cpp/regex/basic_regex/dsc assign}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/regex/basic_regex/dsc mark_count}}
{{dsc inc | cpp/regex/basic_regex/dsc flags}}

{{dsc h2 | Locale}}
{{dsc inc | cpp/regex/basic_regex/dsc getloc}}
{{dsc inc | cpp/regex/basic_regex/dsc imbue}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/regex/basic_regex/dsc swap}}

{{dsc h1 | Constants}}
{{cpp/regex/syntax option type consts}}
{{dsc end}}
The member constants in {{tt|basic_regex}} are duplicates of the [[cpp/regex/syntax_option_type|syntax_option_type]] constants defined in the namespace {{tt|std::regex_constants}}.

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc swap2}}
{{dsc end}}

[[de:cpp/regex/basic regex]]
[[es:cpp/regex/basic regex]]
[[fr:cpp/regex/basic regex]]
[[it:cpp/regex/basic regex]]
[[ja:cpp/regex/basic regex]]
[[pt:cpp/regex/basic regex]]
[[ru:cpp/regex/basic regex]]
[[zh:cpp/regex/basic regex]]</text>
      <sha1>rnkch7oegbd973y8n3atfr6krtsa8em</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/assign</title>
    <ns>0</ns>
    <id>6394</id>
    <revision>
      <id>64286</id>
      <parentid>62919</parentid>
      <timestamp>2013-08-15T16:21:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="3134">{{cpp/regex/basic_regex/title|assign}}
{{cpp/regex/basic_regex/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
basic_regex&amp; assign( const basic_regex&amp; other );
}}
{{dcl | num=2 | since=c++11 |
basic_regex&amp; assign( basic_regex&amp;&amp; that );
}}
{{dcl | num=3 | since=c++11 | 1=
basic_regex&amp; assign( const CharT* s, 
                     flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=4 | since=c++11 | 1=
basic_regex&amp; assign( const charT* ptr, size_t count,
                     flag_type f = regex_constants::ECMAScript );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class ST, class SA &gt;
basic_regex&amp; assign( const std::basic_string&lt;CharT,ST,SA&gt;&amp; str,
                     flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class InputIt &gt;
basic_regex&amp; assign( InputIt first, InputIt last,
                     flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=7 | since=c++11 | 1=
basic_regex&amp; assign( std::initializer_list&lt;CharT&gt; ilist,
                     flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl end}}

Assigns the contents to the regular expression. 

@1@ Assigns the contents of {{tt|other}}. {{lc|flags()}} and {{lc|mark_count()}} are equivalent to the values of {{c|other.flags()}} and {{c|other.mark_count()}} after the call.

@2@ Assigns the contents of {{tt|other}} using move semantics. {{lc|flags()}} and {{lc|mark_count()}} are equivalent to the values of {{c|other.flags()}} and {{c|other.mark_count()}} before the assignment. After the call, {{tt|other}} is in a valid, but unspecified state.

@3-7@ Assigns a sequence of characters to the regular expression. The syntax flags are set to {{tt|f}}. {{lc|mark_count()}} returns the number of marked subexpressions within the resulting subexpression after the call.

:@3@ Assigns a null-terminated string pointed to by {{tt|s}}.
:@4@ Assigns a sequence of {{tt|count}} characters, pointed to by {{tt|s}}.
:@5@ Assigns the string {{tt|str}}.
:@6@ Assigns the characters in the range {{tt|[first, last)}}.
:@7@ Assigns the characters in the initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | other | another regular expression to assign}}
{{par | s | pointer to a character sequence to assign}}
{{par | str | string to assign}}
{{par | first, last | the range of characters to assign}}
{{par | ilist | initializer list containing characters to assign}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ (none)
@2@ {{noexcept}}
@3-7@ {{lc|std::regex_error}} if the supplied regular expression is not valid. The object is not modified in that case.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/regex/basic regex/assign]]
[[es:cpp/regex/basic regex/assign]]
[[fr:cpp/regex/basic regex/assign]]
[[it:cpp/regex/basic regex/assign]]
[[ja:cpp/regex/basic regex/assign]]
[[pt:cpp/regex/basic regex/assign]]
[[ru:cpp/regex/basic regex/assign]]
[[zh:cpp/regex/basic regex/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/basic regex</title>
    <ns>0</ns>
    <id>3098</id>
    <revision>
      <id>62920</id>
      <parentid>61657</parentid>
      <timestamp>2013-07-01T23:46:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="3109">{{cpp/regex/basic_regex/title | basic_regex}}
{{cpp/regex/basic_regex/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
basic_regex();
}}
{{dcl | num=2 | since=c++11 | 1= 
explicit basic_regex( const CharT* s, 
                      flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=3 | since=c++11 | 1= 
basic_regex( const CharT* s, std::size_t count,
             flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=4 | since=c++11 | 1= 
basic_regex( const basic_regex&amp; other );
}}
{{dcl | num=5 | since=c++11 | 1= 
basic_regex( basic_regex&amp;&amp; other );
}}
{{dcl | num=6 | since=c++11 | 1= 
template&lt; class ST, class SA &gt;
explicit basic_regex( const std::basic_string&lt;CharT,ST,SA&gt;&amp; str, 
                      flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=7 | since=c++11 | 1= 
template&lt; class ForwardIt &gt;
basic_regex( ForwardIt first, ForwardIt last, 
             flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl | num=8 | since=c++11 | 1= 
basic_regex( std::initializer_list&lt;CharT&gt; init, 
             flag_type f = std::regex_constants::ECMAScript );
}}
{{dcl end}}

Constructs a new regular expression from a sequence of characters interpreted according to the flags {{tt|f}}.

@1@ Default constructor.  Constructs an empty regular expression which will match nothing.

@2@ Constructs a regex from a null-terminated string {{tt|s}}.

@3@ Constructs a regex from a sequence of {{tt|count}} characters, pointed to by {{tt|s}}.

@4@ Copy constructor.  Constructs a regex by copying {{tt|other}}

@5@ Move constructor.  Constructs a regex by with the contents of {{tt|other}} using move semantics.

@6@ Constructs a regex from a string {{tt|str}}.

@7@ Range constructor.  Constructs the string  with the contents of the range {{tt|[first, last)}}.

@8@ Initializer list constructor.  Constructs the string with the contents of the initializer list {{tt|init}}.

===Parameters===
{{par begin}}
{{par | s | pointer to a null-terminated string}}
{{par | count | length of a character sequence used to initialize the regex}}
{{par | first, last | range of a character sequence used to initialize the regex}}
{{par | str | a basic_string used as a source used to initialize the regex}}
{{par | other | another regex to use as source to initialize the regex}}
{{par | init | initializer list used to initialize the regex}}
{{par | f | flags used to guide the interpretation of the character sequence as a regular expression }}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Exceptions===
@1@ (none)

@2-3@ {{lc|std::regex_error}} if the supplied regular expression is not valid.

@4@ (none)

@5@ {{noexcept}}

@5-8@ {{lc|std::regex_error}} if the supplied regular expression is not valid.

[[de:cpp/regex/basic regex/basic regex]]
[[es:cpp/regex/basic regex/basic regex]]
[[fr:cpp/regex/basic regex/basic regex]]
[[it:cpp/regex/basic regex/basic regex]]
[[ja:cpp/regex/basic regex/basic regex]]
[[pt:cpp/regex/basic regex/basic regex]]
[[ru:cpp/regex/basic regex/basic regex]]
[[zh:cpp/regex/basic regex/basic regex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/constants</title>
    <ns>0</ns>
    <id>8451</id>
    <revision>
      <id>58819</id>
      <parentid>51111</parentid>
      <timestamp>2013-06-01T06:21:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1748">{{cpp/title | basic_regex constants}}
{{cpp/regex/basic_regex/navbar}}

{{dcl begin}}
{{dcl header | regex}}
{{dcl | 1=
static constexpr std::regex_constants::syntax_option_type icase =
    std::regex_constants::icase;
static constexpr std::regex_constants::syntax_option_type nosubs =
    std::regex_constants::nosubs;
static constexpr std::regex_constants::syntax_option_type optimize =
    std::regex_constants::optimize;
static constexpr std::regex_constants::syntax_option_type collate =
    std::regex_constants::collate;
static constexpr std::regex_constants::syntax_option_type ECMAScript =
    std::regex_constants::ECMAScript;
static constexpr std::regex_constants::syntax_option_type basic =
    std::regex_constants::basic;
static constexpr std::regex_constants::syntax_option_type extended =
    std::regex_constants::extended;
static constexpr std::regex_constants::syntax_option_type awk =
    std::regex_constants::awk;
static constexpr std::regex_constants::syntax_option_type grep =
    std::regex_constants::grep;
static constexpr std::regex_constants::syntax_option_type egrep =
    std::regex_constants::egrep;
}}
{{dcl end}}

{{lc|std::basic_regex}} defines several constants that govern general regex matching syntax.

These constants are duplicated from {{c|std::regex_constants}}:

{{cpp/regex/syntax option type consts}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc syntax_option_type}}
{{dsc end}}

[[de:cpp/regex/basic regex/constants]]
[[es:cpp/regex/basic regex/constants]]
[[fr:cpp/regex/basic regex/constants]]
[[it:cpp/regex/basic regex/constants]]
[[ja:cpp/regex/basic regex/constants]]
[[pt:cpp/regex/basic regex/constants]]
[[ru:cpp/regex/basic regex/constants]]
[[zh:cpp/regex/basic regex/constants]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/flags</title>
    <ns>0</ns>
    <id>6372</id>
    <revision>
      <id>64287</id>
      <parentid>63400</parentid>
      <timestamp>2013-08-15T16:21:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="669">{{cpp/regex/basic_regex/title|flags}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
flag_type flags() const;
}}

Returns the regular expression syntax flags as set in the constructor or the last call to {{lc|assign()}}.

===Parameters===
(none)

===Return value===
Current regular expression syntax flags.

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/basic regex/flags]]
[[es:cpp/regex/basic regex/flags]]
[[fr:cpp/regex/basic regex/flags]]
[[it:cpp/regex/basic regex/flags]]
[[ja:cpp/regex/basic regex/flags]]
[[pt:cpp/regex/basic regex/flags]]
[[ru:cpp/regex/basic regex/flags]]
[[zh:cpp/regex/basic regex/flags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/getloc</title>
    <ns>0</ns>
    <id>6371</id>
    <revision>
      <id>63401</id>
      <parentid>58820</parentid>
      <timestamp>2013-07-10T01:31:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="918">{{cpp/regex/basic_regex/title|getloc}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
locale_type getloc() const;
}}

Returns the current locale associated with the regular expression.

Effectively calls {{c|traits_i.getloc()}} where {{tt|traits_i}} is a default initialized instance of the type {{tt|Traits}}, stored within the regular expression object.

===Parameters===
(none)

===Return value===
The current locale associated with the regular expression.

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc imbue}}
{{dsc end}}

[[de:cpp/regex/basic regex/getloc]]
[[es:cpp/regex/basic regex/getloc]]
[[fr:cpp/regex/basic regex/getloc]]
[[it:cpp/regex/basic regex/getloc]]
[[ja:cpp/regex/basic regex/getloc]]
[[pt:cpp/regex/basic regex/getloc]]
[[ru:cpp/regex/basic regex/getloc]]
[[zh:cpp/regex/basic regex/getloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/imbue</title>
    <ns>0</ns>
    <id>6370</id>
    <revision>
      <id>63402</id>
      <parentid>58821</parentid>
      <timestamp>2013-07-10T01:31:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1087">{{cpp/regex/basic_regex/title|imbue}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
locale_type imbue( locale_type loc );
}}

Replaces the current locale with {{tt|loc}}. The regular expression does not match any character sequence after the call.

Effectively calls {{c|traits_i.imbue(loc)}} where {{tt|traits_i}} is a default initialized instance of the type {{tt|Traits}} stored within the regular expression object.

===Parameters===
{{par begin}}
{{par | loc | new locale to use}}
{{par end}}

===Return value===
The locale before the call to this function. Effectively returns the result of expression {{c|traits_i.imbue(loc)}}.

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc getloc}}
{{dsc end}}

[[de:cpp/regex/basic regex/imbue]]
[[es:cpp/regex/basic regex/imbue]]
[[fr:cpp/regex/basic regex/imbue]]
[[it:cpp/regex/basic regex/imbue]]
[[ja:cpp/regex/basic regex/imbue]]
[[pt:cpp/regex/basic regex/imbue]]
[[ru:cpp/regex/basic regex/imbue]]
[[zh:cpp/regex/basic regex/imbue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/mark count</title>
    <ns>0</ns>
    <id>6373</id>
    <revision>
      <id>63403</id>
      <parentid>41886</parentid>
      <timestamp>2013-07-10T01:31:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="714">{{cpp/regex/basic_regex/title|mark_count}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
unsigned mark_count() const;
}}

Returns the number of marked sub-expressions within the regular expression.

===Parameters===
(none)

===Return value===
The number of marked sub-expressions within the regular expression.

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/basic regex/mark count]]
[[es:cpp/regex/basic regex/mark count]]
[[fr:cpp/regex/basic regex/mark count]]
[[it:cpp/regex/basic regex/mark count]]
[[ja:cpp/regex/basic regex/mark count]]
[[pt:cpp/regex/basic regex/mark count]]
[[ru:cpp/regex/basic regex/mark count]]
[[zh:cpp/regex/basic regex/mark count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/operator=</title>
    <ns>0</ns>
    <id>6330</id>
    <revision>
      <id>62921</id>
      <parentid>58824</parentid>
      <timestamp>2013-07-01T23:46:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1978">{{cpp/regex/basic_regex/title | operator{{=}}}}
{{cpp/regex/basic_regex/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
basic_regex&amp; operator=( const basic_regex&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
basic_regex&amp; operator=( basic_regex&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 | 1=
basic_regex&amp; operator=( const CharT* ptr );
}}
{{dcl | num=4 | since=c++11 | 1=
basic_regex&amp; operator=( std::initializer_list&lt;CharT&gt; il );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class ST, class SA &gt;
basic_regex&amp; operator=( const std::basic_string&lt;CharT,ST,SA&gt;&amp; p );
}}
{{dcl end}}

Assigns the contents.

@1@ Copy assignment operator. Assigns the contents of {{tt|other}}. Equivalent to {{c|assign(other);}}.

@2@ Move assignment operator. Assigns the contents of {{tt|other}} using move semantics. {{tt|other}} is in valid, but unspecified state after the operation. Equivalent to {{c|assign(other);}}.

@3@ Assigns a null-terminated character string pointed to by {{tt|ptr}}. Equivalent to {{c|assign(ptr);}}.

@4@ Assigns characters contained in initializer list {{tt|il}}. Equivalent to {{c|assign(il);}}.

@5@ Assigns the contents of the string {{tt|p}}. Equivalent to {{c|assign(p);}}.

===Parameters===
{{par begin}}
{{par | other | another regex object}}
{{par | ptr | pointer to a null-terminated character string}}
{{par | il | initializer list containing characters to assign}}
{{par | p | string containing characters to assign}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
@1@ (none)

@2@ {{noexcept}}

@3-5@ (none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc assign}}
{{dsc end}}

[[de:cpp/regex/basic regex/operator=]]
[[es:cpp/regex/basic regex/operator=]]
[[fr:cpp/regex/basic regex/operator=]]
[[it:cpp/regex/basic regex/operator=]]
[[ja:cpp/regex/basic regex/operator=]]
[[pt:cpp/regex/basic regex/operator=]]
[[ru:cpp/regex/basic regex/operator=]]
[[zh:cpp/regex/basic regex/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/swap</title>
    <ns>0</ns>
    <id>6367</id>
    <revision>
      <id>63404</id>
      <parentid>58825</parentid>
      <timestamp>2013-07-10T01:31:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="748">{{cpp/regex/basic_regex/title|swap}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
void swap( basic_regex&amp; other );
}}

Exchanges the contents of two regular expressions.

===Parameters===
{{par begin}}
{{par | other | the regular expression to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc swap2}}
{{dsc end}}

[[de:cpp/regex/basic regex/swap]]
[[es:cpp/regex/basic regex/swap]]
[[fr:cpp/regex/basic regex/swap]]
[[it:cpp/regex/basic regex/swap]]
[[ja:cpp/regex/basic regex/swap]]
[[pt:cpp/regex/basic regex/swap]]
[[ru:cpp/regex/basic regex/swap]]
[[zh:cpp/regex/basic regex/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/swap2</title>
    <ns>0</ns>
    <id>6369</id>
    <revision>
      <id>64854</id>
      <parentid>58828</parentid>
      <timestamp>2013-08-27T01:30:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=</comment>
      <text xml:space="preserve" bytes="988">{{cpp/title | swap&lt;small&gt;(std::basic_regex)&lt;/small&gt;}}
{{cpp/regex/basic_regex/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class CharT, class Traits &gt;
void swap( basic_regex&lt;CharT,Traits&gt; &amp;lhs, basic_regex&lt;CharT,Traits&gt; &amp;rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::basic_regex}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | regular expressions to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/basic_regex/dsc swap}}
{{dsc end}}

[[de:cpp/regex/basic regex/swap2]]
[[es:cpp/regex/basic regex/swap2]]
[[fr:cpp/regex/basic regex/swap2]]
[[it:cpp/regex/basic regex/swap2]]
[[ja:cpp/regex/basic regex/swap2]]
[[pt:cpp/regex/basic regex/swap2]]
[[ru:cpp/regex/basic regex/swap2]]
[[zh:cpp/regex/basic regex/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/basic regex/~basic regex</title>
    <ns>0</ns>
    <id>6374</id>
    <revision>
      <id>63405</id>
      <parentid>41874</parentid>
      <timestamp>2013-07-10T01:31:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="497">{{cpp/regex/basic_regex/title|~basic_regex}}
{{cpp/regex/basic_regex/navbar}}
{{ddcl | since=c++11 |
~basic_regex();
}}

Destroys the regular expression object.

[[de:cpp/regex/basic regex/~basic regex]]
[[es:cpp/regex/basic regex/~basic regex]]
[[fr:cpp/regex/basic regex/~basic regex]]
[[it:cpp/regex/basic regex/~basic regex]]
[[ja:cpp/regex/basic regex/~basic regex]]
[[pt:cpp/regex/basic regex/~basic regex]]
[[ru:cpp/regex/basic regex/~basic regex]]
[[zh:cpp/regex/basic regex/~basic regex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/ecmascript</title>
    <ns>0</ns>
    <id>13030</id>
    <revision>
      <id>67527</id>
      <parentid>67153</parentid>
      <timestamp>2014-02-10T23:05:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to LWG 2343 regrading $ and ^ vs line terminators</comment>
      <text xml:space="preserve" bytes="27251">{{title|Modified ECMAScript regular expression grammar}}
{{cpp/regex/basic_regex/navbar}}
This page describes the regular expression grammar that is used when {{lc|std::basic_regex}} is constructed with [[cpp/regex/syntax_option_type | syntax_option_type]] set to {{tt|ECMAScript}} (the default). See [[cpp/regex/syntax_option_type | syntax_option_type]] for the other supported regular expression grammars.

The {{tt|ECMAScript}} regular expression grammar in C++ is [http://ecma-international.org/ecma-262/5.1/#sec-15.10 ECMA-262 grammar] with modifications marked with {{mark|C++ only}} below.

===Alternatives===
A regular expression pattern is sequence of one or more ''Alternative''s, separated by the disjunction operator {{ttb|{{!}}}} (in other words, the disjunction operator has the lowest precedence)

''Pattern'' ::
:''Disjunction''

''Disjunction'' ::
:''Alternative''
:''Alternative'' {{ttb|{{!}}}} ''Disjunction''

The pattern first tries to skip the ''Disjunction'' and match the left ''Alternative'' followed by the rest of the regular expression (after the Disjunction).

If it fails, it tries to skip the left ''Alternative'' and match the right ''Disjunction'' (followed by the rest of the regular expression).

If the left ''Alternative'', the right ''Disjunction'', and the remainder of the regular expression all have choice points, all choices in the remainder of the expression are tried before moving on to the next choice in the left ''Alternative''. If choices in the left ''Alternative'' are exhausted, the right ''Disjunction'' is tried instead of the left ''Alternative''.

Any capturing parentheses inside a skipped ''Alternative'' produce empty submatches.

{{example|code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

void show_matches(const std::string&amp; in, const std::string&amp; re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if(m.empty()) {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: NO MATCH\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: &quot;;
        std::cout &lt;&lt; &quot;prefix=[&quot; &lt;&lt; m.prefix() &lt;&lt; &quot;] &quot;;
        for(std::size_t n = 0; n &lt; m.size(); ++n)
            std::cout &lt;&lt; &quot; m[&quot; &lt;&lt; n &lt;&lt; &quot;]=[&quot; &lt;&lt; m[n] &lt;&lt; &quot;] &quot;;
        std::cout &lt;&lt; &quot;suffix=[&quot; &lt;&lt; m.suffix() &lt;&lt; &quot;]\n&quot;;
    }
}
int main()
{
    show_matches(&quot;abcdef&quot;, &quot;abc{{!}}def&quot;);
    show_matches(&quot;abc&quot;, &quot;ab{{!}}abc&quot;); // left Alernative matched first

    // Match of the input against the left Alternative (a) followed
    // by the remained of the regex (c{{!}}bc) succeeds, which results
    // in m[1]=&quot;a&quot; and m[4]=&quot;bc&quot;.
    // The skipped Alternatives (ab) and (c) leave their submatches
    // m[3] and m[5] empty.
    show_matches(&quot;abc&quot;, &quot;((a){{!}}(ab))((c){{!}}(bc))&quot;);
}
| output=
input=[abcdef], regex=[abc{{!}}def]: prefix=[]  m[0]=[abc] suffix=[def]
input=[abc], regex=[ab{{!}}abc]: prefix=[]  m[0]=[ab] suffix=[c]
input=[abc], regex=[((a){{!}}(ab))((c){{!}}(bc))]: prefix=[]  m[0]=[abc]
m[1]=[a]  m[2]=[a]  m[3]=[] m[4]=[bc]  m[5]=[]  m[6]=[bc] suffix=[]
}}

===Terms===
Each ''Alternative'' is either empty or is a sequence of ''Term''s (with no separators between the ''Term''s)

''Alternative'' ::
: ''[empty]''
: ''Alternative'' ''Term''

Empty ''Alternative'' always matches and does not consume any input.

Consecutive ''Term''s try to simultaneously match consecutive portions of the input.

If the left ''Alternative'', the right ''Term'', and the remainder of the regular expression all have choice points, all choices in the remained of the expression are tried before moving on to the next choice in the right ''Term'', and all choices in the right ''Term'' are tried before moving on to the next choice in the left ''Alternative''.

{{example|code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

void show_matches(const std::string&amp; in, const std::string&amp; re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if(m.empty()) {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: NO MATCH\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: &quot;;
        std::cout &lt;&lt; &quot;prefix=[&quot; &lt;&lt; m.prefix() &lt;&lt; &quot;] &quot;;
        for(std::size_t n = 0; n &lt; m.size(); ++n)
            std::cout &lt;&lt; &quot; m[&quot; &lt;&lt; n &lt;&lt; &quot;]=[&quot; &lt;&lt; m[n] &lt;&lt; &quot;] &quot;;
        std::cout &lt;&lt; &quot;suffix=[&quot; &lt;&lt; m.suffix() &lt;&lt; &quot;]\n&quot;;
    }
}
int main()
{
    show_matches(&quot;abcdef&quot;, &quot;&quot;); // empty regex is a single empty Alternative
    show_matches(&quot;abc&quot;, &quot;abc{{!}}&quot;); // left Alernative matched first
    show_matches(&quot;abc&quot;, &quot;{{!}}abc&quot;); // left Alernative matched first, leaving abc unmatched
}
|output=
input=[abcdef], regex=[]: prefix=[]  m[0]=[] suffix=[abcdef]
input=[abc], regex=[abc{{!}}]: prefix=[]  m[0]=[abc] suffix=[]
input=[abc], regex=[{{!}}abc]: prefix=[]  m[0]=[] suffix=[abc]
}}

===Quantifiers===
* Each ''Term'' is either an ''Assertion'' (see below), or an ''Atom'' (see below), or an ''Atom'' immediately followed by a ''Quantifier''

''Term'' ::
: ''Assertion''
: ''Atom''
: ''Atom'' ''Quantifier''

Each ''Quantifier'' is either a ''greedy'' quantifier (which consists of just one ''QuantifierPrefix'' or a ''non-greedy'' quantifier (which consists of one ''QuantifierPrefix'' followed by the question mark {{ttb|?}}.

''Quantifier'' ::
: ''QuantifierPrefix''
: ''QuantifierPrefix'' {{ttb|?}}

Each ''QuantifierPrefix'' determines two numbers: the minimum number of repetitions and the maximum number of repetitions, as follows:
{|table class=wikitable
|-
!QuantifierPrefix||Minimum||Maximum
|-
| {{ttb|*}}
| zero
| infinity
|-
| {{ttb|+}}
| one
| infinity
|-
| {{ttb|?}}
| zero
| one
|-
| {{ttb|{ }} ''DecimalDigits'' {{ttb|} }}
| value of DecimalDigits
| value of DecimalDigits
|-
| {{ttb|{}} ''DecimalDigits'' {{ttb|,}} {{ttb|} }}
| value of DecimalDigits
| infinity
|-
| {{ttb|{}} ''DecimalDigits'' {{ttb|,}} ''DecimalDigits'' {{ttb|} }}
| value of DecimalDigits before the comma
| value of DecimalDigits after the comma
|}

The values of the individual ''DecimalDigits'' are obtained by calling {{lc|std::regex_traits::value}}{{mark|C++ only}} on each of the digits.

An ''Atom'' followed by a ''Quantifier'' is repeated the number of times specified by the ''Quantifier''. A ''Quantifier'' can be ''non-greedy'', in which case the ''Atom'' pattern is repeated as few times as possible while still matching the remainder of the regular expression, or it can be ''greedy'', in which case the ''Atom'' pattern is repeated as many times as possible while still matching the remainder of the regular expression.

The ''Atom'' pattern is what is repeated, not the input that it matches, so different repetitions of the ''Atom'' can match different input substrings.

If the ''Atom'' and the remainder of the regular expression all have choice points, the ''Atom'' is first matched as many (or as few, if ''non-greedy'') times as possible. All choices in the remainder of the regular expression are tried before moving on to the next choice in the last repetition of ''Atom''. All choices in the last (nth) repetition of ''Atom'' are tried before moving on to the next choice in the next-to-last (n–1)st repetition of ''Atom''; at which point it may turn out that more or fewer repetitions of ''Atom'' are now possible; these are exhausted (again, starting with either as few or as many as possible) before moving on to the next choice in the (n-1)st repetition of ''Atom'' and so on.

The ''Atom'''s captures are cleared each time it is repeated (see the {{c|&quot;(z)((a+)?(b+)?(c))*&quot;}} example below)

{{example|code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

void show_matches(const std::string&amp; in, const std::string&amp; re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if(m.empty()) {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: NO MATCH\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: &quot;;
        std::cout &lt;&lt; &quot;prefix=[&quot; &lt;&lt; m.prefix() &lt;&lt; &quot;] &quot;;
        for(std::size_t n = 0; n &lt; m.size(); ++n)
            std::cout &lt;&lt; &quot; m[&quot; &lt;&lt; n &lt;&lt; &quot;]=[&quot; &lt;&lt; m[n] &lt;&lt; &quot;] &quot;;
        std::cout &lt;&lt; &quot;suffix=[&quot; &lt;&lt; m.suffix() &lt;&lt; &quot;]\n&quot;;
    }
}
int main()
{
    // greedy match, repeats [a-z] 4 times
    show_matches(&quot;abcdefghi&quot;, &quot;a[a-z]{2,4}&quot;);
    // non-greedy match, repeats [a-z] 2 times
    show_matches(&quot;abcdefghi&quot;, &quot;a[a-z]{2,4}?&quot;);

    // Choice point ordering for quantifiers results in a match
    // with two repetitions, first matching the substring &quot;aa&quot;,
    // second matching the substring &quot;ba&quot;, leaving &quot;ac&quot; not matched
    // (&quot;ba&quot; appears in the capture clause m[1])
    show_matches(&quot;aabaac&quot;, &quot;(aa{{!}}aabaac{{!}}ba{{!}}b{{!}}c)*&quot;);

    // Choice point ordering for quantifiers makes this regex 
    // calculate the greatest common divisor between 10 and 15
    // (the answer is 5, and it populates m[1] with &quot;aaaaa&quot;)
    show_matches(&quot;aaaaaaaaaa,aaaaaaaaaaaaaaa&quot;, &quot;^(a+)\\1*,\\1+$&quot;);

    // the substring &quot;bbb&quot; does not appear in the capture clause m[4]
    // because it is cleared when the second repetition of the atom
    // (a+)?(b+)?(c) is matching the substring &quot;ac&quot;
    show_matches(&quot;zaacbbbcac&quot;, &quot;(z)((a+)?(b+)?(c))*&quot;);
}
|output=
input=[abcdefghi], regex=[a[a-z]{2,4}]: prefix=[]  m[0]=[abcde] suffix=[fghi]
input=[abcdefghi], regex=[a[a-z]{2,4}?]: prefix=[]  m[0]=[abc] suffix=[defghi]
input=[aabaac], regex=[(aa{{!}}aabaac{{!}}ba{{!}}b{{!}}c)*]:
 prefix=[]  m[0]=[aaba]  m[1]=[ba] suffix=[ac]
input=[aaaaaaaaaa,aaaaaaaaaaaaaaa], regex=[^(a+)\1*,\1+$]:
 prefix=[]  m[0]=[aaaaaaaaaa,aaaaaaaaaaaaaaa]  m[1]=[aaaaa] suffix=[]
input=[zaacbbbcac], regex=[(z)((a+)?(b+)?(c))*]:
prefix=[]  m[0]=[zaacbbbcac]  m[1]=[z]  m[2]=[ac]  m[3]=[a]  m[4]=[]  m[5]=[c] suffix=[]
}}

===Assertions===
''Assertion''s match conditions, rather than substrings of the input string. They never consume any characters from the input. Each ''Assertion'' is one of the following

''Assertion'' ::
: {{ttb|^}}
: {{ttb|$}}
: {{ttb|\}} {{ttb|b}}
: {{ttb|\}} {{ttb|B}}
: {{ttb|(}} {{ttb|?}} {{ttb|{{=}}}} ''Disjunction'' {{ttb|)}}
: {{ttb|(}} {{ttb|?}} {{ttb|!}} ''Disjunction'' {{ttb|)}}

The assertion {{ttb|^}} (beginning of line) matches 
@1@ The position that immediately follows a ''LineTerminator'' character. (if supported, see [http://cplusplus.github.io/LWG/lwg-active.html#2343 LWG issue 2343])
@2@ The beginning of the input (unless {{lc|std::regex_constants::match_not_bol}}{{mark|C++ only}} is enabled)

The assertion {{ttb|$}} (end of line) matches
@1@ The position of a ''LineTerminator'' character (if supported, see [http://cplusplus.github.io/LWG/lwg-active.html#2343 LWG issue 2343])
@2@ The end of the input (unless {{lc|std::regex_constants::match_not_eol}}){{mark|C++ only}} is enabled)

In the two assertions above and in the Atom {{ttb|.}} below, ''LineTerminator'' is one of the following four charactes: {{tt|U+000A}} ({{tt|\n}} or line feed), {{tt|U+000D}} ({{tt|\r}} or carriage return), {{tt|U+2028}} (line separator), or {{tt|U+2029}} (paragraph separator)

The assertion {{ttb|\b}} (word boundary) matches 
@1@ The beginning of a word (current character is a letter, digit, or underscore, and the previous character is not)
@2@ The end of a word (current character is not a letter, digit, or underscore, and the previous character is one of those)
@3@ The beginning of input if the first character is a letter, digit, or underscore (unless {{lc|std::regex_constants::match_not_bow}}{{mark|C++ only}} is enabled))
@4@ The end of input if the last character is a letter, digit, or underscore (unless {{lc|std::regex_constants::match_not_eow}}{{mark|C++ only}} is enabled))

The assertion {{ttb|\B}} (negative word boundary) matches everything EXCEPT the following
@1@ The beginning of a word (current character is a letter, digit, or underscore, and the previous character is not one of those or does not exist)
@2@ The end of a word (current character is not a letter, digit, or underscore (or the matcher is at the end of input), and the previous character is one of those)

The assertion {{ttb|(}} {{ttb|?}} {{ttb|{{=}}}} ''Disjunction'' {{ttb|)}} (zero-width positive lookahead) matches if ''Disjunction'' would match the input at the current position

The assertion {{ttb|(}} {{ttb|?}} {{ttb|!}} ''Disjunction'' {{ttb|)}} (zero-width negative lookahead) matches if ''Disjunction'' would NOT match the input at the current position.

For both Lookahead assertions, when matching the ''Disjunction'', the position is not advanced before matching the remainder of the regular expression. Also, if ''Disjunction'' can match at the current position in several ways, only the first one is tried.

ECMAScript forbids backtracking into the lookahead Disjunctions, which affects the behavior of backreferences into a positive lookahead from the remainder of the regular expression (see example below). Backreferences into the negative lookahead from the rest of the regular expression are always undefined (since the lookahead Disjunction must fail to proceed).

Note: Lookahead assertions may be used to create logical AND between multiple regular expressions (see example below)

{{example|code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

void show_matches(const std::string&amp; in, const std::string&amp; re)
{
    std::smatch m;
    std::regex_search(in, m, std::regex(re));
    if(m.empty()) {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: NO MATCH\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;input=[&quot; &lt;&lt; in &lt;&lt; &quot;], regex=[&quot; &lt;&lt; re &lt;&lt; &quot;]: &quot;;
        std::cout &lt;&lt; &quot;prefix=[&quot; &lt;&lt; m.prefix() &lt;&lt; &quot;] &quot;;
        for(std::size_t n = 0; n &lt; m.size(); ++n)
            std::cout &lt;&lt; &quot; m[&quot; &lt;&lt; n &lt;&lt; &quot;]=[&quot; &lt;&lt; m[n] &lt;&lt; &quot;] &quot;;
        std::cout &lt;&lt; &quot;suffix=[&quot; &lt;&lt; m.suffix() &lt;&lt; &quot;]\n&quot;;
    }
}
int main()
{
    // matches the a at the end of input
    show_matches(&quot;aaa&quot;, &quot;a$&quot;);

    // matches the o at the end of the first word
    show_matches(&quot;moo goo gai pan&quot;, &quot;o\\b&quot;);

    // the lookahead matches the empty string immediately after the first b
    // this populates m[1] with &quot;aaa&quot; although m[0] is empty
    show_matches(&quot;baaabac&quot;, &quot;(?=(a+))&quot;);

    // because backtracking into lookaheads is prohibited, 
    // this matches aba rather than aaaba
    show_matches(&quot;baaabac&quot;, &quot;(?=(a+))a*b\\1&quot;);

    // logical AND via lookahead: this password matches IF it contains
    // at least one lowercase letter
    // AND at least one uppercase letter
    // AND at least one punctuation character
    // AND be at least 6 characters long
    show_matches(&quot;abcdef&quot;, &quot;(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}&quot;);
    show_matches(&quot;aB,def&quot;, &quot;(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}&quot;);
}
| output=
input=[aaa], regex=[a$]: prefix=[aa]  m[0]=[a] suffix=[]
input=[moo goo gai pan], regex=[o\b]: prefix=[mo]  m[0]=[o] suffix=[ goo gai pan]
input=[baaabac], regex=[(?=(a+))]: prefix=[b]  m[0]=[]  m[1]=[aaa] suffix=[aaabac]
input=[baaabac], regex=[(?=(a+))a*b\1]: prefix=[baa]  m[0]=[aba]  m[1]=[a] suffix=[c]
input=[abcdef], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]:
 NO MATCH
input=[aB,def], regex=[(?=.*[[:lower:]])(?=.*[[:upper:]])(?=.*[[:punct:]]).{6,}]:
 prefix=[]  m[0]=[aB,def] suffix=[]
}}

===Atoms===
An ''Atom'' can be one of the following:

''Atom'' ::
: ''PatternCharacter''
: {{ttb|.}}
: {{ttb|\}} ''AtomEscape''
: ''CharacterClass''
: {{ttb|(}} ''Disjunction'' {{ttb|)}}
: {{ttb|(}} {{ttb|?}} {{ttb|:}} ''Disjunction'' {{ttb|)}}

where
''AtomEscape'' ::
: ''DecimalEscape''
: ''CharacterEscape''
: ''CharacterClassEscape''

Different kinds of atoms evaluate differently.

===Sub-expressions===
The ''Atom'' {{ttb|(}} ''Disjunction'' {{ttb|)}} is marked subexpression: it executes the ''Disjunction'' and stores the copy of the input substring that was consumed by ''Disjunctin'' in the submatch array at the index that corresponds to the number of times the left open parenthesis {{ttb|(}} of marked subexpressions has been encountered in the entire regular expression at this point.

Besides being returned in the {{lc|std::match_results}}, the captured submatches are accessible as back-references ({{tt|\1}}, {{tt|\2}}, ...) and can be referenced in {{lc|std::regex_replace}})

The ''Atom'' {{ttb|(}} {{ttb|?}} {{ttb|:}} ''Disjunction'' {{ttb|)}} (non-marking subexpression) simply evaluates the ''Disjunction'' and does not store its results in the submatch. This is a purely lexical grouping.

{{example}}

===Backreferences===
''DecimalEscape'' ::
: ''DecimalIntegerLiteral'' [''lookahead'' ∉ ''DecimalDigit'']

If {{ttb|\}} is followed by a decimal number {{tt|N}} whose first digit is not {{tt|0}}, then the escape sequence is considered to be a ''backreference''. The values {{tt|N}} is obtained by calling {{lc|std::regex_traits::value}}{{mark|C++ only}} on each of the digits and combining their results using base-10 arithmetic. It is an error if {{tt|N}} is greater than the total number of left capturing parentheses in the entire regular expression.

When a backreference {{tt|\N}} appears as an Atom, it matches the same substring as what is currently stored in the N'th element of the submatch array.

The decimal escape {{tt|\0}} is NOT a backreference: it is a character escape that represents the nul character. It cannot be followed by a decimal digit.

{{example}}

===Single character matches===
The ''Atom'' {{ttb|.}} matches and consumes any one character from the input string except for ''LineTerminator'' ({{tt|U+000D}}, {{tt|U+000A}}, {{tt|U+2029}}, or {{tt|U+2028}})

The ''Atom'' ''PatternCharacter'', where ''PatternCharacter'' is any ''SourceCharacter'' EXCEPT the chracters {{ttb|^ $ \ . * + ? ( ) [ ] { } {{!}}}}, matches and consumes one character from the input if it is equal to this ''PatternCharacter''.

The equality for this and all other single character matches is defined as follows:
@1@ If {{lc|std::regex_constants::icase}} is set, the characters are equal if the return values of {{lc|std::regex_traits::translate_nocase}} are equal.{{mark|C++ only}}
@2@ otherwise, if {{lc|std::regex_constants::collate}} is set, the characters are equal if the return values of {{lc|std::regex_traits::translate}} are equal.{{mark|C++ only}}
@3@ otherwise, the characters are equal if operator== returns true.

Each ''Atom'' that consists of the escape character {{ttb|\}} followed by ''CharacterEscape'' as well as the special DecimalEscape {{ttb|\0}}, matches and consumes one character from the input if it is equal to the character represented by the ''CharacterEscape''. The following character escape sequences are recognized:

''CharacterEscape'' ::
: ''ControlEscape''
: {{ttb|c}} ''ControlLetter''
: ''HexEscapeSequence''
: ''UnicodeEscapeSequence''
: ''IdentityEscape''

Here, ''ControlEscape'' is one of the following five characters: {{ttb|f n r t v}}

{|table class=wikitable
|-
!ControlEscape||Code Unit||Name
|-
| {{ttb|f}}
| U+000C
| form feed
|-
| {{ttb|n}}
| U+000A
| new line
|-
| {{ttb|r}}
| U+000D
| carriage return
|-
| {{ttb|t}}
| U+0009
| horizontal tab
|-
| {{ttb|v}}
| U+000B
| vertical tab
|}

''ControlLetter'' is any lowercase or uppercase ASCII letters and this character escape matches the character whose code unit equals the remainder of dividing the value of the code unit of ''ControlLetter'' by {{c|32}}, for example, {{ttb|\cD}} and {{ttb|\cd}} both match code unit {{tt|U+0004}} (EOT) because 'D' is {{tt|U+0044}}, and {{tt|0x44 % 32 {{==}} 4}} and 'd' is {{tt|U+0064}} and {{tt|0x64 % 32 {{==}} 4}}.

''HexEscapeSequence'' is the letter {{ttb|x}} followed by exactly two ''HexDigit''s (where ''HexDigit'' is one of {{ttb|0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F}}). This character escape matches the character whose code unit equals the numeric value of the two-digit hexadecimal number

''UnicodeEscapeSequence'' is the letter {{ttb|u}} followed by exactly four ''HexDigit''s. This character escape matches the character whose code unit equals the numeric value of this four-digit hexadecimal number. If the value does not fit in this {{lc|std::basic_regex}}'s CharT, {{lc|std::regex_error}} is thrown{{mark|C++ only}}.

''IdentityEscape'' can be any non-alphanumeric character: for example, another backslash. It matches the character as-is.

{{example}}

===Character classes===
An Atom can represent a character class, that is, it will match and consume one character if it belongs to one of the predefined groups of characters.

A character class can be introduced through a character class escape:

''Atom'' ::
: {{ttb|\}} ''CharacterClassEscape''

or directly

''Atom'' ::
: ''CharacterClass''

The character class escapes are shorthands for some of the common characters classes, as follows:

{|table class=wikitable
|-
!CharacterClassEscape||ClassName expression{{mark|C++ only}}||Meaning
|-
| {{ttb|d}}
| {{ttb|&lt;nowiki&gt;[[&lt;/nowiki&gt;:digit:]]}}
| digits
|-
| {{ttb|D}}
| {{ttb|[^[:digit:]]}}
| non-digits
|-
| {{ttb|s}}
| {{ttb|&lt;nowiki&gt;[[&lt;/nowiki&gt;:space:]]}}
| whitespace characters
|-
| {{ttb|S}}
| {{ttb|[^[:space:]]}}
| non-whitespace characters
|-
| {{ttb|w}}
| {{ttb|[_[:alnum:]]}}
| alphanumeric characters and the character {{ttb|_}}
|-
| {{ttb|W}}
| {{ttb|[^_[:alnum:]]}}
| characters other than alphanumeric or {{ttb|_}}
|}{{small|The exact meaning of each of these character class escapes in C++ is defined in terms of the locale-dependent named character classes, and not by explicitly listing the acceptable characters as in ECMAScript.}}

A ''CharacterClass'' is a bracket-enclosed sequence of ''ClassRanges'', optionally beginning with the negation operator {{ttb|^}}. If it begins with {{ttb|^}}, this ''Atom'' matches any character that is NOT in the set of characters represented by the union of all ''ClassRanges''. Otherwise, this ''Atom'' matches any character that IS in the set of the characters represented by the union of all ''ClassRanges''.

''CharacterClass'' ::
: {{ttb|[}} {{ttb|[}} ''lookahead ∉ {''{{ttb|^}}''}]'' ''ClassRanges'' {{ttb|]}}
: {{ttb|[}} {{ttb|^}} ''ClassRanges'' {{ttb|]}}

ClassRanges ::
: [empty]
: ''NonemptyClassRanges''

''NonemptyClassRanges'' ::
: ''ClassAtom''
: ''ClassAtom'' ''NonemptyClassRangesNoDash''
: ''ClassAtom'' - ''ClassAtom'' ''ClassRanges''

If non-empty class range has the form {{ttb|''ClassAtom'' - ''ClassAtom''}}, it matches any character from a range defined as follows: {{mark|C++ only}}

The first ''ClassAtom'' must match a single collating element {{tt|c1}} and the second ''ClassAtom'' must match a single collating element {{tt|c2}}. To test if the input character {{tt|c}} is matched by this range, the following steps are taken:
@1@ If {{lc|std::regex_constants::collate}} is not on, the character is matched by direct comparison of code points: {{tt|c}} is matched if {{tt|c1 &lt;{{=}} c &amp;&amp; c &lt;{{=}} c2}}
@1@ Otherwise (if {{lc|std::regex_constants::collate}} is enabled):
:@1@ If {{lc|std::regex_constants::icase}} is enabled, all three characters ({{tt|c}}, {{tt|c1}}, and {{tt|c2}} are passed {{lc|std::regex_traits::translate_nocase}}
:@2@ Otherwise (if {{lc|std::regex_constants::icase}} is not set), all three characters ({{tt|c}}, {{tt|c1}}, and {{tt|c2}} are passed {{lc|std::regex_traits::translate}}
@2@ The resulting strings are compared using {{lc|std::regex_traits::transform}} and the character {{tt|c}} is matched if {{tt|transformed c1 &lt;{{=}} transformed c &amp;&amp; transformed c &lt;{{=}} transformed c2}}

The character {{ttb|-}} is treated literally if it is
* the first or last character of ''ClassRanges''
* the beginning or end ClassAtom of a dash-separated range specification
* immediately follows a dash-separated range specification.
* escaped with a backslash as a ''CharacterEscape''

NonemptyClassRangesNoDash ::
: ''ClassAtom''
: ''ClassAtomNoDash'' ''NonemptyClassRangesNoDash''
: ''ClassAtomNoDash'' - ''ClassAtom'' ''ClassRanges''

''ClassAtom'' ::
: {{ttb|-}}
: ''ClassAtomNoDash''
: ''ClassAtomExClass''{{mark|C++ only}}
: ''ClassAtomCollatingElement''{{mark|C++ only}}
: ''ClassAtomEquivalence''{{mark|C++ only}}

ClassAtomNoDash ::
: ''SourceCharacter'' but not one of {{ttb|\ or ] or -}}
: {{ttb|\}} ''ClassEscape''

Each ''ClassAtomNoDash'' represents a single character -- either ''SourceCharacter'' as-is or escaped as follows:

ClassEscape ::
: ''DecimalEscape''
: {{ttb|b}}
: ''CharacterEscape''
: ''CharacterClassEscape''

The special ''ClassEscape'' {{ttb|\b}} produces a character set that matches the code unit U+0008 (backspace). Outside of ''CharacterClass'', it is the word-boundary ''Assertion''.

The use of {{ttb|\B}} and the use of any backreference (''DecimalEscape'' other than zero) inside a ''CharacterClass'' is an error.

The characters {{ttb|-}} and {{ttb|]}} may need to be escaped in some situations in order to be treated as atoms. Other characters that have special meaning outside of ''CharacterClass'', such as {{ttb|*}} or {{ttb|?}}, do not need to be escaped.

{{example}}

===POSIX-based character classes===
These character classes are an extension to the ECMAScript grammar, and are equivalent to character classes found in the the POSIX regular expressions.

ClassAtomExClass{{mark|C++ only}} ::
: {{ttb|[:}} ''ClassName'' {{ttb|:]}}

Represents all characters that are members of the named character class ''ClassName''. The name is valid only if {{lc|std::regex_traits::lookup_classname}} returns non-zero for this name. As described in {{lc|std::regex_traits::lookup_classname}}, the following names are guaranteed to be recognized: {{ttb|alnum, alpha, blank, cntrl, digit, graph, lower, print, punct, space, upper, xdigit, d, s, w}}. Additional names may be provided by system-supplied locales (such as {{ttb|jdigit}} or {{ttb|jkanji}} in Japanese) or implemented as a user-defined extension.

ClassAtomCollatingElement{{mark|C++ only}} ::
: {{ttb|[.}} ''ClassName'' {{ttb|.]}}

Represents the named collating element, which may represent a single character or a sequence of characters that collates as a single unit under the imbued locale, such as {{tt|[.tilde.]}} or {{tt|[.ch.]}} in Czech. The name is valid only if {{lc|std::regex_traits::lookup_collatename}} is not an empty string.

When using {{lc|std::regex_constants::collate}}, collating elements can always be used as ends points of a range (e.g. {{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;.dz.]-g]}} in Hungarian).

ClassAtomEquivalence{{mark|C++ only}} ::
: {{ttb|[{{=}}}} ''ClassName'' {{ttb|{{=}}]}}

Represents all characters that are members of the same equivalence class as the named collating element, that is, all characters whose whose primary collation key is the same as that for collating element ''ClassName''. The name is valid only if {{lc|std::regex_traits::lookup_collatename}} for that name is not an empty string and if the value returned by {{lc|std::regex_traits::transform_primary}} for the result of the call to {{lc|std::regex_traits::lookup_collatename}} is not an empty string.

A primary sort key is one that ignores case, accentation, or locale-specific tailorings; so for example {{tt|&lt;nowiki&gt;[[&lt;/nowiki&gt;{{=}}a{{=}}]]}} matches any of the characters: {{tt|a, À, Á, Â, Ã, Ä, Å, A, à, á, â, ã, ä and å. }}

ClassName{{mark|C++ only}} ::
: ClassNameCharacter
: ClassNameCharacter ClassName

ClassNameCharacter{{mark|C++ only}} ::
: ''SourceCharacter'' but not one of {{ttb|. {{=}} :}}

{{example}}</text>
      <sha1>fm2adsv7dygenj3kzog6qzf3fzekavy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/error type</title>
    <ns>0</ns>
    <id>2322</id>
    <revision>
      <id>64140</id>
      <parentid>62922</parentid>
      <timestamp>2013-08-15T03:43:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C++14</comment>
      <text xml:space="preserve" bytes="2835">{{cpp/title|n=regex_constants::|error_type}}
{{cpp/regex/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | since=c++11 | 1=
typedef /*implementation defined*/ error_type;
}}
{{dcl | since=c++11 | 1=
constexpr error_type error_collate = /*unspecified*/;
constexpr error_type error_ctype = /*unspecified*/;
constexpr error_type error_escape = /*unspecified*/;
constexpr error_type error_backref = /*unspecified*/;
constexpr error_type error_brack = /*unspecified*/;
constexpr error_type error_paren = /*unspecified*/;
constexpr error_type error_brace = /*unspecified*/;
constexpr error_type error_badbrace = /*unspecified*/;
constexpr error_type error_range = /*unspecified*/;
constexpr error_type error_space = /*unspecified*/;
constexpr error_type error_badrepeat = /*unspecified*/;
constexpr error_type error_complexity = /*unspecified*/;
constexpr error_type error_stack = /*unspecified*/;
}}
{{dcl end}}

The {{tt|error_type}} is a type that describes errors that may occur during regular expression parsing.

===Constants===

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|error_collate}} | the expression contains an invalid collating element name}}
{{dsc | {{tt|error_ctype}} | the expression contains an invalid character class name}}
{{dsc | {{tt|error_escape}} | the expression contains an invalid escaped character or a trailing escape}}
{{dsc | {{tt|error_backref}} | the expression contains an invalid back reference}}
{{dsc | {{tt|error_brack}} | the expression contains mismatched square brackets ('[' and ']')}}
{{dsc | {{tt|error_paren}} | the expression contains mismatched parentheses ('(' and ')')}}
{{dsc | {{tt|error_brace}} | the expression contains mismatched curly braces ('{' and '}')}}
{{dsc | {{tt|error_badbrace}} | the expression contains an invalid range in a {} expression}}
{{dsc | {{tt|error_range}} | the expression contains an invalid character range (e.g. [b-a])}}
{{dsc | {{tt|error_space}} | there was not enough memory to convert the expression into a finite state machine}}
{{dsc | {{tt|error_badrepeat}} | one of *?+{ was not preceded by a valid regular expression}}
{{dsc | {{tt|error_complexity}} | the complexity of an attempted match exceeded a predefined level}}
{{dsc | {{tt|error_stack}} | there was not enough memory to perform a match}}
{{dsc end}}

===Notes===
In C++11, these constants were specified with redundant keyword {{tt|static}}, which was removed by C++14 via [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2053 LWG issue 2053]

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_error }}
{{dsc end}}

[[de:cpp/regex/error type]]
[[es:cpp/regex/error type]]
[[fr:cpp/regex/error type]]
[[it:cpp/regex/error type]]
[[ja:cpp/regex/error type]]
[[pt:cpp/regex/error type]]
[[ru:cpp/regex/error type]]
[[zh:cpp/regex/error type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match flag type</title>
    <ns>0</ns>
    <id>2321</id>
    <revision>
      <id>68862</id>
      <parentid>64139</parentid>
      <timestamp>2014-03-22T19:58:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 1450</comment>
      <text xml:space="preserve" bytes="3477">{{cpp/title|n=regex_constants::|match_flag_type}}
{{cpp/regex/navbar}}
{{ddcl | header=regex | 1=
typedef /*unspecified*/ match_flag_type;
constexpr match_flag_type match_default = 0;
constexpr match_flag_type match_not_bol = /*unspecified*/;
constexpr match_flag_type match_not_eol = /*unspecified*/;
constexpr match_flag_type match_not_bow = /*unspecified*/;
constexpr match_flag_type match_not_eow = /*unspecified*/;
constexpr match_flag_type match_any = /*unspecified*/;
constexpr match_flag_type match_not_null = /*unspecified*/;
constexpr match_flag_type match_continuous = /*unspecified*/;
constexpr match_flag_type match_prev_avail = /*unspecified*/;
constexpr match_flag_type format_default = 0;
constexpr match_flag_type format_sed = /*unspecified*/;
constexpr match_flag_type format_no_copy = /*unspecified*/;
constexpr match_flag_type format_first_only = /*unspecified*/;
}}

{{tt|match_flag_type}} is a {{concept|BitmaskType}} that specifies additional regular expression matching options. 

===Constants===

Note: {{tt|[first, last)}} refers to the character sequence being matched.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|match_not_bol}} | The first character in ''[first,last)'' will be treated as if it is '''not''' at the beginning of a line (i.e. ''^'' will not match ''[first,first)''}}
{{dsc | {{tt|match_not_eol}} | The last character in ''[first,last)'' will be treated as if it is '''not''' at the end of a line (i.e. ''$'' will not match ''[last,last)}}
{{dsc | {{tt|match_not_bow}} | ''&quot;\b&quot;'' will not match ''[first,first)''}}
{{dsc | {{tt|match_not_eow}} | ''&quot;\b&quot;'' will not match ''[last,last)''}}
{{dsc | {{tt|match_any}} | If more than one match is possible, then any match is an acceptable result}}
{{dsc | {{tt|match_not_null}} | Do not match empty sequences}}
{{dsc | {{tt|match_continuous}} | Only match a sub-sequence that begins at ''first''}}
{{dsc | {{tt|match_prev_avail}} | ''--first'' is a valid iterator position.  When set, causes ''match_not_bol'' and ''match_not_bow'' to be ignored}}
{{dsc | {{tt|format_default}} | Use ECMAScript rules to construct strings in {{lc|std::regex_replace}} ([http://ecma-international.org/ecma-262/5.1/#sec-15.5.4.11 syntax documentation])}}
{{dsc | {{tt|format_sed}} | Use POSIX ''sed'' utility rules in {{lc|std::regex_replace}}. ([http://pubs.opengroup.org/onlinepubs/9699919799/utilities/sed.html#tag_20_116_13_03 syntax documentation])}}
{{dsc | {{tt|format_no_copy}} | Do not copy un-matched strings to the output in {{lc|std::regex_replace}}}}
{{dsc | {{tt|format_first_only}} | Only replace the first match in {{lc|std::regex_replace}}}}
{{dsc end}}

All constants, except for {{tt|match_default}} and {{tt|format_default}}, are bitmask elements. The {{tt|match_default}} and {{tt|format_default}} constants are empty bitmasks

===Notes===
In C++11, these constants were specified with redundant keyword {{tt|static}}, which was removed by C++14 via [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2053 LWG issue 2053]

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_match}}
{{dsc inc | cpp/regex/dsc syntax_option_type}}
{{dsc inc | cpp/regex/dsc error_type}}
{{dsc end}}

[[de:cpp/regex/match flag type]]
[[es:cpp/regex/match flag type]]
[[fr:cpp/regex/match flag type]]
[[it:cpp/regex/match flag type]]
[[ja:cpp/regex/match flag type]]
[[pt:cpp/regex/match flag type]]
[[ru:cpp/regex/match flag type]]
[[zh:cpp/regex/match flag type]]</text>
      <sha1>ehv98qwouujpfdatiev8ypq6l9wnd8e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results</title>
    <ns>0</ns>
    <id>2281</id>
    <revision>
      <id>68865</id>
      <parentid>66574</parentid>
      <timestamp>2014-03-22T20:04:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2306</comment>
      <text xml:space="preserve" bytes="4086">{{cpp/title|match_results}}
{{cpp/regex/match_results/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
template&lt;
    class BidirIt,
    class Alloc = std::allocator&lt;std::sub_match&lt;BidirIt&gt;&gt;
&gt; class match_results;
}}

The class template {{lc|std::match_results}} holds a collection of character sequences that represent the result of a regular expression match.

This is a specialized allocator-aware container.  It can only be default created, obtained from {{lc|std::regex_iterator}}, or modified by {{lc|std::regex_search}} or {{lc|std::regex_match}}. Because {{tt|std::match_results}} holds {{lc|std::sub_match}}es, each of which is a pair of iterators into the original character sequence that was matched, it's undefined behavior to examine {{tt|std::match_results}} if the original character sequence was destroyed or iterators to it were invalidated for other reasons.

The first sub_match (index 0) contained in a match_result always represents the full match within a target sequence made by a regex, and subsequent sub_matches represent sub-expression matches corresponding in sequence to the left parenthesis delimiting the sub-expression in the regex.

===Type requirements===
{{par begin}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | Alloc | Allocator}}
{{par end}}

===Specializations===
Several specializations for common character sequence types are provided: 

{{dsc begin}}
{{dsc header | regex}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|cmatch}} | {{c|match_results&lt;const char*&gt;}}}}
{{dsc | {{tt|wcmatch}} | {{c|match_results&lt;const wchar_t*&gt;}}}}
{{dsc | {{tt|smatch}} | {{c|match_results&lt;std::string::const_iterator&gt;}}}}
{{dsc | {{tt|wsmatch}} | {{c|match_results&lt;std::wstring::const_iterator&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|allocator_type}} | {{c|Allocator}}}}
{{dsc | {{tt|value_type}} | {{c|std::sub_match&lt;BidirIt&gt;}}}}
{{dsc | {{tt|const_reference}} | {{c|const value_type&amp;}}}}
{{dsc | {{tt|reference}} | {{c|value_type&amp;}}}}
{{dsc | {{tt|const_iterator}} | ''implementation defined'' (depends on the underlying container)}}
{{dsc | {{tt|iterator}} | {{c|const_iterator}}}}
{{dsc | {{tt|difference_type}} | {{c|std::iterator_traits&lt;BidirIt&gt;::difference_type}}}}
{{dsc | {{tt|size_type}} | {{c|std::allocator_traits&lt;Alloc&gt;::size_type}}}}
{{dsc | {{tt|char_type}} | {{c|std::iterator_traits&lt;BidirIt&gt;::value_type}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;char_type&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc constructor}}
{{dsc inc | cpp/regex/match_results/dsc destructor}}
{{dsc inc | cpp/regex/match_results/dsc operator{{=}}}}
{{dsc inc | cpp/regex/match_results/dsc get_allocator}}

{{dsc h2 | State}}
{{dsc mem fun | cpp/regex/match_results/ready | checks if the results are available}}

{{dsc h2 | Size}}
{{dsc inc | cpp/regex/match_results/dsc empty}}
{{dsc inc | cpp/regex/match_results/dsc size}}
{{dsc inc | cpp/regex/match_results/dsc max_size}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/regex/match_results/dsc length}}
{{dsc inc | cpp/regex/match_results/dsc position}}
{{dsc inc | cpp/regex/match_results/dsc str}}
{{dsc inc | cpp/regex/match_results/dsc operator_at}}
{{dsc inc | cpp/regex/match_results/dsc prefix}}
{{dsc inc | cpp/regex/match_results/dsc suffix}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/regex/match_results/dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc end}}

{{dsc h2 | Format}}
{{dsc inc | cpp/regex/match_results/dsc format}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/regex/match_results/dsc swap}}

{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc operator_cmp}}
{{dsc inc | cpp/regex/match_results/dsc swap2}}
{{dsc end}}

[[de:cpp/regex/match results]]
[[es:cpp/regex/match results]]
[[fr:cpp/regex/match results]]
[[it:cpp/regex/match results]]
[[ja:cpp/regex/match results]]
[[ko:cpp/regex/match results]]
[[pt:cpp/regex/match results]]
[[ru:cpp/regex/match results]]
[[zh:cpp/regex/match results]]</text>
      <sha1>t960ygkq1wug8evkkr2r8o8cogjsj9u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/begin</title>
    <ns>0</ns>
    <id>3121</id>
    <revision>
      <id>62923</id>
      <parentid>58836</parentid>
      <timestamp>2013-07-01T23:46:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="936">{{cpp/regex/match_results/title | begin | cbegin}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
iterator begin();
}}
{{dcl | since=c++11 |
const_iterator begin() const;
}}
{{dcl | since=c++11 |
const_iterator cbegin() const;
}}
{{dcl end}}

Returns an iterator to the beginning of the list of sub-matches. If match was successful, the iterator will point to the entire matched expression.

===Parameters===
(none)

===Return value===
Iterator to the first sub-match.

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc end}}
{{dsc end}}

[[de:cpp/regex/match results/begin]]
[[es:cpp/regex/match results/begin]]
[[fr:cpp/regex/match results/begin]]
[[it:cpp/regex/match results/begin]]
[[ja:cpp/regex/match results/begin]]
[[pt:cpp/regex/match results/begin]]
[[ru:cpp/regex/match results/begin]]
[[zh:cpp/regex/match results/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/empty</title>
    <ns>0</ns>
    <id>3118</id>
    <revision>
      <id>63407</id>
      <parentid>58837</parentid>
      <timestamp>2013-07-10T01:31:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="730">{{cpp/regex/match_results/title | empty}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
bool empty() const;
}}
Checks whether the match was successful.

===Parameters===
(none)

===Return value===
{{c|true}} if the match_results object contains no matches., {{c|false}} otherwise

===Exceptions===
(none)

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc size}}
{{dsc end}}

[[de:cpp/regex/match results/empty]]
[[es:cpp/regex/match results/empty]]
[[fr:cpp/regex/match results/empty]]
[[it:cpp/regex/match results/empty]]
[[ja:cpp/regex/match results/empty]]
[[pt:cpp/regex/match results/empty]]
[[ru:cpp/regex/match results/empty]]
[[zh:cpp/regex/match results/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/end</title>
    <ns>0</ns>
    <id>3123</id>
    <revision>
      <id>62924</id>
      <parentid>58838</parentid>
      <timestamp>2013-07-01T23:46:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="839">{{cpp/regex/match_results/title | end | cend}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
iterator end();
}}
{{dcl | since=c++11 |
const_iterator end() const;
}}
{{dcl | since=c++11 |
const_iterator cend() const;
}}
{{dcl end}}

Returns an iterator to the end of the list of sub-matches.

===Parameters===
(none)

===Return value===
Iterator to the element past the last sub-match.

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc begin}}
{{dsc end}}

[[de:cpp/regex/match results/end]]
[[es:cpp/regex/match results/end]]
[[fr:cpp/regex/match results/end]]
[[it:cpp/regex/match results/end]]
[[ja:cpp/regex/match results/end]]
[[pt:cpp/regex/match results/end]]
[[ru:cpp/regex/match results/end]]
[[zh:cpp/regex/match results/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/format</title>
    <ns>0</ns>
    <id>9046</id>
    <revision>
      <id>62925</id>
      <parentid>58841</parentid>
      <timestamp>2013-07-01T23:46:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="3823">{{cpp/regex/match_results/title|format}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class OutputIt &gt;
OutputIter format( OutputIt out,
                   const char_type* fmt_first, const char_type* fmt_last,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::format_default ) const;
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class OutputIt, class ST, class SA &gt;
OutputIter format( OutputIt out,
                   const basic_string&lt;char_type,ST,SA&gt;&amp; fmt,
                   std::regex_constants::match_flag_type flags =
                       std::regex_constants::format_default ) const;
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class ST, class SA &gt;
std::basic_string&lt;char_type,ST,SA&gt; 
    format( const std::basic_string&lt;char_type,ST,SA&gt;&amp; fmt,
            std::regex_constants::match_flag_type flags =
                std::regex_constants::format_default ) const;
}}
{{dcl | num=4 | since=c++11 | 1=
string_type format( const char_type* fmt_s,
                    std::regex_constants::match_flag_type flags =
                        std::regex_constants::format_default ) const;
}}
{{dcl end}}

{{tt|format}} outputs a format string, replacing any format specifiers or escape sequences in that string with match data from {{c|*this}}.

@1@ The format character sequence is defined by the range {{tt|[fmt_first, fmt_last)}}. The resulting character sequence is copied to {{tt|out}}.
@2@ The format character sequence is defined by the characters in {{tt|fmt}}. The resulting character sequence is copied to {{tt|out}}.
@3-4@ The format character sequence is defined by the characters in {{tt|fmt}} and {{tt|fmt_s}} respectively. The resulting character sequence is copied to a newly constructed {{lc|std::basic_string}}, which is returned.

The {{tt|flags}} bitmask determines which format specifiers and escape sequences are recognized.

The behavior of {{tt|format}} is undefined if {{c|1=ready() != true}}.

===Parameters===
{{par begin}}
{{par | fmt_begin, fmt_end | pointers to a range of characters defining the format character sequence}}
{{par | fmt | {{lc|std::basic_string}} defining the format character sequence}}
{{par | fmt_s | pointer to a null-terminated character string defining the format character sequence}}
{{par | out | iterator that the resulting character sequence is copied to}}
{{par | flags | {{lc|std::regex_constants::match_flag_type}} bitmask specifying which format specifiers and escape sequences are recognized}}
{{par hreq}}
{{par req concept | OutputIt | OutputIterator}}
{{par end}}

===Return value===
@1-2@ {{tt|out}}
@3-4@ The newly constructed string containing resulting character sequence.

===Exceptions===
(none)

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    std::string s = &quot;for a good time, call 867-5309&quot;;
    std::regex phone_regex(&quot;\\d{3}-\\d{4}&quot;);
    std::smatch phone_match;

    if (std::regex_search(s, phone_match, phone_regex)) {
        std::string fmt_s = phone_match.format(
            &quot;$`&quot;    // $` means characters before the match
            &quot;[$&amp;]&quot;  // $&amp; means the matched characters
            &quot;$'&quot;);  // $' means characters following the match
        std::cout &lt;&lt; fmt_s &lt;&lt; '\n';
    }   
}
 | output=
for a good time, call [867-5309]
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_replace }}
{{dsc inc | cpp/regex/dsc match_flag_type}}
{{dsc end}}

[[de:cpp/regex/match results/format]]
[[es:cpp/regex/match results/format]]
[[fr:cpp/regex/match results/format]]
[[it:cpp/regex/match results/format]]
[[ja:cpp/regex/match results/format]]
[[pt:cpp/regex/match results/format]]
[[ru:cpp/regex/match results/format]]
[[zh:cpp/regex/match results/format]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/get allocator</title>
    <ns>0</ns>
    <id>3117</id>
    <revision>
      <id>63408</id>
      <parentid>41849</parentid>
      <timestamp>2013-07-10T01:31:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="659">{{cpp/regex/match_results/title | get_allocator}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
allocator_type get_allocator() const;
}}

Returns the allocator associated with the object.

===Parameters===
(none)

===Return value===
The associated allocator.

===Complexity===
Constant.

[[de:cpp/regex/match results/get allocator]]
[[es:cpp/regex/match results/get allocator]]
[[fr:cpp/regex/match results/get allocator]]
[[it:cpp/regex/match results/get allocator]]
[[ja:cpp/regex/match results/get allocator]]
[[pt:cpp/regex/match results/get allocator]]
[[ru:cpp/regex/match results/get allocator]]
[[zh:cpp/regex/match results/get allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/length</title>
    <ns>0</ns>
    <id>3214</id>
    <revision>
      <id>63409</id>
      <parentid>58842</parentid>
      <timestamp>2013-07-10T01:31:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1103">{{cpp/regex/match_results/title | length}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
difference_type length( size_type n {{=}} 0 ) const;
}}

Returns the length of the specified sub-match.

If {{c|1=n == 0}}, the length of the entire matched expression is returned.

If {{c|n &gt; 0 &amp;&amp; n &lt; size()}}, the length of ''n''th sub-match is returned.

if {{c|1=n &gt;= size()}}, a length of the unmatched match is returned.

The call is equivalent to {{c|(*this)[n].length()}}.

===Parameters===
{{par begin}}
{{par | n | integral number specifying which match to examine}}
{{par end}}

===Return value===
The length of the specified match or sub-match.

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc operator_at}}
{{dsc inc | cpp/regex/sub_match/dsc length}}
{{dsc end}}

[[de:cpp/regex/match results/length]]
[[es:cpp/regex/match results/length]]
[[fr:cpp/regex/match results/length]]
[[it:cpp/regex/match results/length]]
[[ja:cpp/regex/match results/length]]
[[pt:cpp/regex/match results/length]]
[[ru:cpp/regex/match results/length]]
[[zh:cpp/regex/match results/length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/match results</title>
    <ns>0</ns>
    <id>3218</id>
    <revision>
      <id>62926</id>
      <parentid>51125</parentid>
      <timestamp>2013-07-01T23:46:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1334">{{cpp/regex/match_results/title | match_results}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
explicit match_results( const Allocator&amp; a = Allocator() );
}}
{{dcl | num=2 | since=c++11 | 1= 
match_results( const match_results&amp; rhs );
}}
{{dcl | num=3 | since=c++11 | 1= 
match_results( match_results&amp;&amp; rhs );
}}
{{dcl end}}

@1@ Default-constructor. Constructs a match result with no established result state ({{c|1=ready() != true}}).

@2@ Copy-constructor. Constructs a match result with a copy of {{tt|rhs}}.

@3@ Move-constructor. Constructs a match result with the contents of {{tt|rhs}} using move semantics. {{tt|rhs}} is in valid, but unspecified state after the call.

===Parameters===
{{par begin}}
{{par | a | allocator to use for all memory allocations of this container}}
{{par | rhs | another match_result to use as source to initialize the match_result with}}
{{par end}}

===Exceptions===
@1-2@ (none)
@3@ {{noexcept}}

[[de:cpp/regex/match results/match results]]
[[es:cpp/regex/match results/match results]]
[[fr:cpp/regex/match results/match results]]
[[it:cpp/regex/match results/match results]]
[[ja:cpp/regex/match results/match results]]
[[pt:cpp/regex/match results/match results]]
[[ru:cpp/regex/match results/match results]]
[[zh:cpp/regex/match results/match results]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/max size</title>
    <ns>0</ns>
    <id>3120</id>
    <revision>
      <id>63410</id>
      <parentid>41838</parentid>
      <timestamp>2013-07-10T01:31:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="807">{{cpp/regex/match_results/title | max_size}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
size_type max_size() const;
}}

Returns the maximum number of submatches the {{tt|match_results}} type is able to hold due to system or library implementation limitations, i.e. {{c|std::distance(begin(), end())}} for the largest number of submatches.

===Parameters===
(none)

===Return value===
Maximum number of submatches

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

[[de:cpp/regex/match results/max size]]
[[es:cpp/regex/match results/max size]]
[[fr:cpp/regex/match results/max size]]
[[it:cpp/regex/match results/max size]]
[[ja:cpp/regex/match results/max size]]
[[pt:cpp/regex/match results/max size]]
[[ru:cpp/regex/match results/max size]]
[[zh:cpp/regex/match results/max size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/operator=</title>
    <ns>0</ns>
    <id>9045</id>
    <revision>
      <id>62927</id>
      <parentid>51126</parentid>
      <timestamp>2013-07-01T23:46:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/regex/match_results/title | operator{{=}}}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
match_results&amp; operator=( const match_results&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
match_results&amp; operator=( match_results&amp;&amp; other );
}}
{{dcl end}}

Assigns the contents.

@1@ Copy assignment operator. Assigns the contents of {{tt|other}}. 

@2@ Move assignment operator. Assigns the contents of {{tt|other}} using move semantics. {{tt|other}} is in valid, but unspecified state after the operation. 

===Parameters===
{{par begin}}
{{par | other | another match results object}}
{{par end}}

===Return value===
{{c|*this}}.

===Exceptions===
@1@ (none)
@2@ {{noexcept}}

[[de:cpp/regex/match results/operator=]]
[[es:cpp/regex/match results/operator=]]
[[fr:cpp/regex/match results/operator=]]
[[it:cpp/regex/match results/operator=]]
[[ja:cpp/regex/match results/operator=]]
[[pt:cpp/regex/match results/operator=]]
[[ru:cpp/regex/match results/operator=]]
[[zh:cpp/regex/match results/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/operator at</title>
    <ns>0</ns>
    <id>3261</id>
    <revision>
      <id>66572</id>
      <parentid>66571</parentid>
      <timestamp>2013-12-08T16:47:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>more example tweaking</comment>
      <text xml:space="preserve" bytes="1611">{{cpp/regex/match_results/title | operator[]}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
const_reference operator[]( size_type n ) const;
}}

Returns an indicated sub-match.  

If {{c|1=n == 0}}, entire matched expression is returned.

If {{c|n &gt; 0 &amp;&amp; n &lt; size()}}, ''n''th sub-match is returned.

if {{c|1=n &gt;= size()}}, a sub-match representing the unmatched match is returned.

===Parameters===
{{par begin}}
{{par | n | integral number specifying which match to return}}
{{par end}}

===Return value===
Returns a sub-match representing the specified match or sub match.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
    std::string target(&quot;baaaby&quot;);
    std::smatch sm;

    std::regex re1(&quot;a(a)*b&quot;);
    std::regex_search(target, sm, re1);
    std::cout &lt;&lt; &quot;entire match: &quot; &lt;&lt; sm[0] &lt;&lt; '\n'
              &lt;&lt; &quot;submatch #1: &quot; &lt;&lt; sm[1] &lt;&lt; '\n';

    std::regex re2(&quot;a(a*)b&quot;);
    std::regex_search(target, sm, re2);
    std::cout &lt;&lt; &quot;entire match: &quot; &lt;&lt; sm[0] &lt;&lt; '\n'
              &lt;&lt; &quot;submatch #1: &quot; &lt;&lt; sm[1] &lt;&lt; '\n';

}
 | output=
entire match: aaab
submatch #1: a
entire match: aaab
submatch #1: aa
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc str}}
{{dsc end}}

[[de:cpp/regex/match results/operator at]]
[[es:cpp/regex/match results/operator at]]
[[fr:cpp/regex/match results/operator at]]
[[it:cpp/regex/match results/operator at]]
[[ja:cpp/regex/match results/operator at]]
[[pt:cpp/regex/match results/operator at]]
[[ru:cpp/regex/match results/operator at]]
[[zh:cpp/regex/match results/operator at]]</text>
      <sha1>hk7sihiaq6xxrsv22pbpl3o0329oq11</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/operator cmp</title>
    <ns>0</ns>
    <id>9044</id>
    <revision>
      <id>66568</id>
      <parentid>62928</parentid>
      <timestamp>2013-12-07T23:17:04Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1922">{{title | 1=operator==,!={{small|(std::match_results)}}}}
{{cpp/regex/match_results/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class BidirIt, class Alloc &gt;
bool operator==( match_results&lt;BidirIt,Alloc&gt;&amp; lhs,
                 match_results&lt;BidirIt,Alloc&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class BidirIt, class Alloc &gt;
bool operator!=( match_results&lt;BidirIt,Alloc&gt;&amp; lhs,
                 match_results&lt;BidirIt,Alloc&gt;&amp; rhs );
}}
{{dcl end}}

Compares two {{tt|match_results}} objects.

Two {{tt|match_results}} are equal if the following conditions are met:
* neither of the objects is ''ready'', ''or''
* both match results are ''ready'' and the following conditions are met: 
:* {{c|lhs.empty()}} and {{c|rhs.empty()}}, ''or''
:* {{c|!lhs.empty()}} and {{c|!rhs.empty()}} and the following conditions are met:
::* {{c|1=lhs.prefix() == rhs.prefix()}}
::* {{c|std::equal(lhs.begin(), lhs.end(), rhs.begin())}}
::* {{c|1=lhs.suffix() == rhs.suffix()}}

@1@ Checks if {{tt|lhs}} and {{c|rhs}} are equal.
@2@ Checks if {{tt|lhs}} and {{c|rhs}} are not equal.

===Parameters===
{{par begin}}
{{par | lhs, rhs | match results to compare}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | Alloc | Allocator}}
{{par end}}

===Return value===
@1@ {{c|true}} if {{tt|lhs}} and {{tt|rhs}} are equal, {{c|false}} otherwise.
@2@ {{c|true}} if {{tt|lhs}} and {{tt|rhs}} are not equal, {{c|false}} otherwise.

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/match results/operator cmp]]
[[es:cpp/regex/match results/operator cmp]]
[[fr:cpp/regex/match results/operator cmp]]
[[it:cpp/regex/match results/operator cmp]]
[[ja:cpp/regex/match results/operator cmp]]
[[pt:cpp/regex/match results/operator cmp]]
[[ru:cpp/regex/match results/operator cmp]]
[[zh:cpp/regex/match results/operator cmp]]</text>
      <sha1>17pxyr4mev1zpxir0bezxyxi06c5ohb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/position</title>
    <ns>0</ns>
    <id>3253</id>
    <revision>
      <id>63412</id>
      <parentid>58846</parentid>
      <timestamp>2013-07-10T01:31:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1429">{{cpp/regex/match_results/title | position}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
difference_type position( size_type sub {{=}} 0 ) const;
}}

Returns the position of the first character of the specified sub-match.

If {{c|1=n == 0}}, the position of the first character of entire matched expression is returned.

If {{c|n &gt; 0 &amp;&amp; n &lt; size()}}, the position of the first character of ''n''th sub-match is returned.

if {{c|1=n &gt;= size()}}, a position of the first character of the unmatched match is returned.

===Parameters===
{{par begin}}
{{par | n | integral number specifying which match to examine}}
{{par end}}

===Return value===
The position of the first character of the specified match or sub-match.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
    std::regex re(&quot;a(a)*b&quot;);
    std::string target(&quot;aaab&quot;);
    std::smatch sm;

    std::regex_match(target, sm, re);
    std::cout &lt;&lt; sm.position(1) &lt;&lt; '\n';
}
 | output=
1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc operator_at}}
{{dsc end}}

[[de:cpp/regex/match results/position]]
[[es:cpp/regex/match results/position]]
[[fr:cpp/regex/match results/position]]
[[it:cpp/regex/match results/position]]
[[ja:cpp/regex/match results/position]]
[[pt:cpp/regex/match results/position]]
[[ru:cpp/regex/match results/position]]
[[zh:cpp/regex/match results/position]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/prefix</title>
    <ns>0</ns>
    <id>3259</id>
    <revision>
      <id>63413</id>
      <parentid>41825</parentid>
      <timestamp>2013-07-10T01:31:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="921">{{cpp/regex/match_results/title | prefix}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
const_reference prefix() const;
}}

===Parameters===
(none)

===Return value===
Returns a sub_match representing the part of the target sequence between the beginning of the target sequence and the entire match of the regular expression.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
  std::regex re(&quot;a(a)*b&quot;);
  std::string target(&quot;baaaby&quot;);
  std::smatch sm;

  std::regex_search(target, sm, re);
  std::cout &lt;&lt; sm.prefix().str() &lt;&lt; '\n';
}
 | output=
b
}}

[[de:cpp/regex/match results/prefix]]
[[es:cpp/regex/match results/prefix]]
[[fr:cpp/regex/match results/prefix]]
[[it:cpp/regex/match results/prefix]]
[[ja:cpp/regex/match results/prefix]]
[[pt:cpp/regex/match results/prefix]]
[[ru:cpp/regex/match results/prefix]]
[[zh:cpp/regex/match results/prefix]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/ready</title>
    <ns>0</ns>
    <id>3217</id>
    <revision>
      <id>66576</id>
      <parentid>66575</parentid>
      <timestamp>2013-12-08T16:56:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1417">{{cpp/regex/match_results/title | ready}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
bool ready() const;
}}

Indicates if the match results are ready (valid) or not.

A default-constructed match result has no result state (is not ''ready''), and can only be made ready by one of the regex algorithms.  The ''ready'' state implies that all match results have been fully established.

The result of calling most member functions of the match_results object that is not ''ready'' is undefined.

===Return value===

{{c|true}} if the match results are ready, {{c|false}} otherwise.

===Example===
{{example|
code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
    std::string target(&quot;pattern&quot;);
    std::smatch sm;
    std::cout &lt;&lt; &quot;default constructed smatch is &quot;
              &lt;&lt; (sm.ready() ? &quot; ready\n&quot; : &quot; not ready\n&quot;);

    std::regex re1(&quot;tte&quot;);
    std::regex_search(target, sm, re1);

    std::cout &lt;&lt; &quot;after search, smatch is &quot;
              &lt;&lt; (sm.ready() ? &quot; ready\n&quot; : &quot; not ready\n&quot;);
}
|output=
default constructed smatch is  not ready
after search, smatch is  ready
}}


[[de:cpp/regex/match results/ready]]
[[es:cpp/regex/match results/ready]]
[[fr:cpp/regex/match results/ready]]
[[it:cpp/regex/match results/ready]]
[[ja:cpp/regex/match results/ready]]
[[pt:cpp/regex/match results/ready]]
[[ru:cpp/regex/match results/ready]]
[[zh:cpp/regex/match results/ready]]</text>
      <sha1>7kvvjduc4ednqayoc17lo1xp8ldxys1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/size</title>
    <ns>0</ns>
    <id>3119</id>
    <revision>
      <id>63415</id>
      <parentid>41819</parentid>
      <timestamp>2013-07-10T01:31:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="912">{{cpp/regex/match_results/title | size}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
size_type size() const;
}}

Returns the number of submatches, i.e. {{c|std::distance(begin(), end())}}.

===Parameters===
(none)

===Return value===
The number of submatches

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
    std::regex re(&quot;a(a)*b&quot;);
    std::string target(&quot;aaab&quot;);
    std::smatch sm;

    std::regex_match(target, sm, re);
    std::cout &lt;&lt; sm.size() &lt;&lt; '\n';
}
 | output=
2
}}

[[de:cpp/regex/match results/size]]
[[es:cpp/regex/match results/size]]
[[fr:cpp/regex/match results/size]]
[[it:cpp/regex/match results/size]]
[[ja:cpp/regex/match results/size]]
[[pt:cpp/regex/match results/size]]
[[ru:cpp/regex/match results/size]]
[[zh:cpp/regex/match results/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/str</title>
    <ns>0</ns>
    <id>3254</id>
    <revision>
      <id>66573</id>
      <parentid>66569</parentid>
      <timestamp>2013-12-08T16:48:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>same as operator[]</comment>
      <text xml:space="preserve" bytes="1681">{{cpp/regex/match_results/title | str}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 | 1=
string_type str( size_type n = 0 ) const;
}}

Returns a string representing the indicated sub-match.  

If {{c|1=n == 0}}, a string representing entire matched expression is returned.

If {{c|n &gt; 0 &amp;&amp; n &lt; size()}}, a string representing ''n''th sub-match is returned.

if {{c|1=n &gt;= size()}}, a string representing the unmatched match is returned.

The call is equivalent to {{c|string_type((*this)[n])}};

===Parameters===
{{par begin}}
{{par | n | integral number specifying which match to return}}
{{par end}}

===Return value===
Returns a string representing the specified match or sub match.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;
 
int main()
{
    std::string target(&quot;baaaby&quot;);
    std::smatch sm;
 
    std::regex re1(&quot;a(a)*b&quot;);
    std::regex_search(target, sm, re1);
    std::cout &lt;&lt; &quot;entire match: &quot; &lt;&lt; sm.str(0) &lt;&lt; '\n'
              &lt;&lt; &quot;submatch #1: &quot; &lt;&lt; sm.str(1) &lt;&lt; '\n';

    std::regex re2(&quot;a(a*)b&quot;);
    std::regex_search(target, sm, re2);
    std::cout &lt;&lt; &quot;entire match: &quot; &lt;&lt; sm.str(0) &lt;&lt; '\n'
              &lt;&lt; &quot;submatch #1: &quot; &lt;&lt; sm.str(1) &lt;&lt; '\n';

}
 | output=
entire match: aaab
submatch #1: a
entire match: aaab
submatch #1: aa
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc operator_at}}
{{dsc end}}

[[de:cpp/regex/match results/str]]
[[es:cpp/regex/match results/str]]
[[fr:cpp/regex/match results/str]]
[[it:cpp/regex/match results/str]]
[[ja:cpp/regex/match results/str]]
[[pt:cpp/regex/match results/str]]
[[ru:cpp/regex/match results/str]]
[[zh:cpp/regex/match results/str]]</text>
      <sha1>kcpmms5dywg73ks3km6tfxl438bq4cg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/suffix</title>
    <ns>0</ns>
    <id>3260</id>
    <revision>
      <id>63417</id>
      <parentid>41813</parentid>
      <timestamp>2013-07-10T01:31:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="947">{{cpp/regex/match_results/title | suffix}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
const_reference suffix() const;
}}

{{todo}}

===Parameters===
(none)

===Return value===

Returns a sub_match representing the part of the target sequence between the end of the entire match of the regular expression and the end of the target sequence.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
    std::regex re(&quot;a(a)*b&quot;);
    std::string target(&quot;baaaby&quot;);
    std::smatch sm;

    std::regex_search(target, sm, re);
    std::cout &lt;&lt; sm.suffix().str() &lt;&lt; '\n';
}
 | output=
y
}}

[[de:cpp/regex/match results/suffix]]
[[es:cpp/regex/match results/suffix]]
[[fr:cpp/regex/match results/suffix]]
[[it:cpp/regex/match results/suffix]]
[[ja:cpp/regex/match results/suffix]]
[[pt:cpp/regex/match results/suffix]]
[[ru:cpp/regex/match results/suffix]]
[[zh:cpp/regex/match results/suffix]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/swap</title>
    <ns>0</ns>
    <id>9042</id>
    <revision>
      <id>63418</id>
      <parentid>58850</parentid>
      <timestamp>2013-07-10T01:31:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="788">{{cpp/regex/match_results/title|swap}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
void swap( match_results&amp; other );
}}

Exchanges the shared states of two {{tt|match_results}} objects.

===Parameters===
{{par begin}}
{{par | other | the {{tt|match_results}} to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc swap2}}
{{dsc end}}

[[de:cpp/regex/match results/swap]]
[[es:cpp/regex/match results/swap]]
[[fr:cpp/regex/match results/swap]]
[[it:cpp/regex/match results/swap]]
[[ja:cpp/regex/match results/swap]]
[[pt:cpp/regex/match results/swap]]
[[ru:cpp/regex/match results/swap]]
[[zh:cpp/regex/match results/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/swap2</title>
    <ns>0</ns>
    <id>9043</id>
    <revision>
      <id>63419</id>
      <parentid>58851</parentid>
      <timestamp>2013-07-10T01:31:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1149">{{cpp/title | swap{{small|(std::match_results)}}}}
{{cpp/regex/match_results/navbar}}
{{ddcl | header=regex | since=c++11 |
template&lt; class BidirIt, class Alloc &gt;
void swap( match_results&lt;BidirIt,Alloc&gt;&amp; x1,
           match_results&lt;BidirIt,Alloc&gt;&amp; x2 );
}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::match_results}}. Exchanges the contents of {{tt|x1}} with those of {{tt|x2}}. Effectively calls {{c|x1.swap(x2)}}.

===Parameters===
{{par begin}}
{{par | x1, x2 | the match_results objects whose contents will be swapped}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | Alloc | Allocator}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/match_results/dsc swap}}
{{dsc end}}

[[de:cpp/regex/match results/swap2]]
[[es:cpp/regex/match results/swap2]]
[[fr:cpp/regex/match results/swap2]]
[[it:cpp/regex/match results/swap2]]
[[ja:cpp/regex/match results/swap2]]
[[pt:cpp/regex/match results/swap2]]
[[ru:cpp/regex/match results/swap2]]
[[zh:cpp/regex/match results/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/match results/~match results</title>
    <ns>0</ns>
    <id>3219</id>
    <revision>
      <id>63420</id>
      <parentid>41806</parentid>
      <timestamp>2013-07-10T01:31:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="628">{{cpp/regex/match_results/title | ~match_results}}
{{cpp/regex/match_results/navbar}}
{{ddcl | since=c++11 |
~match_results();
}}

Destructs the {{tt|match_results}} object and the associated sub-matches.

===Complexity===
Linear in the number of sub-matches.

[[de:cpp/regex/match results/~match results]]
[[es:cpp/regex/match results/~match results]]
[[fr:cpp/regex/match results/~match results]]
[[it:cpp/regex/match results/~match results]]
[[ja:cpp/regex/match results/~match results]]
[[pt:cpp/regex/match results/~match results]]
[[ru:cpp/regex/match results/~match results]]
[[zh:cpp/regex/match results/~match results]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex error</title>
    <ns>0</ns>
    <id>3109</id>
    <revision>
      <id>63421</id>
      <parentid>58854</parentid>
      <timestamp>2013-07-10T01:31:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1313">{{cpp/title|regex_error}}
{{cpp/regex/regex_error/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
class regex_error : public std::runtime_error {
  public:
    explicit regex_error(std::regex_constants::error_type ecode);
    std::regex_constants::error_type code() const;
};
}}

Defines the type of exception object thrown to report errors in the regular expressions library.

{{inheritance_diagram/std-regex_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_error/dsc regex_error}}
{{dsc inc | cpp/regex/regex_error/dsc code}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example|
  |code=
#include &lt;regex&gt;
#include &lt;iostream&gt;

int main()
{
    try {
        std::regex re(&quot;[a-b][a&quot;);
    } 

    catch (const std::regex_error&amp; e) {
        std::cout &lt;&lt; &quot;regex_error caught: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
        if (e.code() == std::regex_constants::error_brack) {
            std::cout &lt;&lt; &quot;The code was error_brack\n&quot;;
        }
    }
}
  |output=
regex_error caught: The expression contained mismatched [ and ].
The code was error_brack
}}

[[de:cpp/regex/regex error]]
[[es:cpp/regex/regex error]]
[[fr:cpp/regex/regex error]]
[[it:cpp/regex/regex error]]
[[ja:cpp/regex/regex error]]
[[pt:cpp/regex/regex error]]
[[ru:cpp/regex/regex error]]
[[zh:cpp/regex/regex error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex error/code</title>
    <ns>0</ns>
    <id>8444</id>
    <revision>
      <id>65358</id>
      <parentid>62929</parentid>
      <timestamp>2013-09-10T13:20:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="717">{{cpp/regex/regex_error/title | code}}
{{cpp/regex/regex_error/navbar}}

{{dcl begin}}
{{dcl header | regex }}
{{dcl | since=c++11 | 1=
std::regex_constants::error_type code() const;
}}
{{dcl end}}

Returns the {{lc|std::regex_constants::error_type}} that was passed to the {{lc|std::regex_error}} constructor.

===See Also===

{{dsc begin}}
{{dsc inc | cpp/regex/dsc error_type}}
{{dsc inc | cpp/regex/regex_error/dsc regex_error}}
{{dsc end}}

[[de:cpp/regex/regex error/code]]
[[es:cpp/regex/regex error/code]]
[[fr:cpp/regex/regex error/code]]
[[it:cpp/regex/regex error/code]]
[[ja:cpp/regex/regex error/code]]
[[pt:cpp/regex/regex error/code]]
[[ru:cpp/regex/regex error/code]]
[[zh:cpp/regex/regex error/code]]</text>
      <sha1>29zf3rzs9vjkqta3v24vsgwiobczpkk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex error/regex error</title>
    <ns>0</ns>
    <id>3107</id>
    <revision>
      <id>65357</id>
      <parentid>62930</parentid>
      <timestamp>2013-09-10T13:19:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="730">{{cpp/regex/regex_error/title | regex_error}}
{{cpp/regex/regex_error/navbar}}

{{dcl begin}}
{{dcl header | regex }}
{{dcl | since=c++11 | 1=
regex_error(std::regex_constants::error_type ecode);
}}
{{dcl end}}

Constructs a {{tt|regex_error}} with a given {{tt|ecode}} of type {{lc|std::regex_constants::error_type}} .

===See Also===

{{dsc begin}}
{{dsc inc | cpp/regex/dsc error_type}}
{{dsc end}}

[[de:cpp/regex/regex error/regex error]]
[[es:cpp/regex/regex error/regex error]]
[[fr:cpp/regex/regex error/regex error]]
[[it:cpp/regex/regex error/regex error]]
[[ja:cpp/regex/regex error/regex error]]
[[pt:cpp/regex/regex error/regex error]]
[[ru:cpp/regex/regex error/regex error]]
[[zh:cpp/regex/regex error/regex error]]</text>
      <sha1>3jqacdkc3kf6e1gwd60buyywlra6y5r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator</title>
    <ns>0</ns>
    <id>2289</id>
    <revision>
      <id>63422</id>
      <parentid>58859</parentid>
      <timestamp>2013-07-10T01:31:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="4652">{{cpp/title|regex_iterator}}
{{cpp/regex/regex_iterator/navbar}}
{{ddcl | since=c++11 | 1=
template&lt;
    class BidirIt,
    class CharT = typename std::iterator_traits&lt;BidirIt&gt;::value_type,
    class Traits = std::regex_traits&lt;CharT&gt;
&gt; class regex_iterator
}}

{{tt|std::regex_iterator}} is a read-only {{concept|ForwardIterator}} that accesses the individual matches of a regular expression within the underlying character sequence.

On construction, and on every increment, it calls {{lc|std::regex_search}} and remembers the result (that is, saves a copy of the value {{c|std::match_results&lt;BidirIt&gt;}}). The first object may be read when the iterator is constructed or when the first dereferencing is done. Otherwise, dereferencing only returns a copy of the most recently obtained regex match.

The default-constructed {{tt|std::regex_iterator}} is the end-of-sequence iterator. When a valid {{tt|std::regex_iterator}} is incremented after reaching the last match ({{lc|std::regex_search}} returns {{c|false}}), it becomes equal to the end-of-sequence iterator. Dereferencing or incrementing it further invokes undefined behavior.

A typical implementation of {{tt|std::regex_iterator}} holds the begin and the end iterators for the underlying sequence (two instances of BidirIt), a pointer to the regular expression ({{c|const regex_type*}}) and the match flags ({{lc|std::regex_constants::match_flag_type}}), and the current match ({{c|std::match_results&lt;BidirIt&gt;}}).

===Type requirements===
{{par begin}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Specializations===
Several specializations for common character sequence types are defined:

{{dsc begin}}
{{dsc header | regex}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|cregex_iterator}} | {{c|regex_iterator&lt;const char*&gt;}}}}
{{dsc | {{tt|wcregex_iterator}} | {{c|regex_iterator&lt;const wchar_t*&gt;}}}}
{{dsc | {{tt|sregex_iterator}} | {{c|regex_iterator&lt;std::string::const_iterator&gt;}}}}
{{dsc | {{tt|wsregex_iterator}} | {{c|regex_iterator&lt;std::wstring::const_iterator&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{c|std::match_results&lt;BidirIt&gt;}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc | {{tt|pointer}} | {{c|const value_type*}} }}
{{dsc | {{tt|reference}} | {{c|const value_type&amp;}} }}
{{dsc | {{tt|iterator_category}} | {{lc|std::forward_iterator_tag}} }}
{{dsc | {{tt|regex_type}} | {{c|basic_regex&lt;CharT, Traits&gt;}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_iterator/dsc constructor}}
{{dsc inc | cpp/regex/regex_iterator/dsc destructor}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator_cmp}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator*}}
{{dsc inc | cpp/regex/regex_iterator/dsc operator_arith}}
{{dsc end}}

===Notes===
It is the programmer's responsibility to ensure that the {{lc|std::basic_regex}} object passed to the iterator's constructor outlives the iterator. Because the iterator stores a pointer to the regex, incrementing the iterator after the regex was destroyed accesses a dangling pointer.

If the part of the regular expression that matched is just an assertion ({{tt|^}}, {{tt|$}}, {{tt|\b}}, {{tt|\B}}), the match stored in the iterator is a zero-length match, that is, {{c|1=match[0].first == match[0].second}}.

===Example===
{{example
 | 
 | code=
#include &lt;regex&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    const std::string s = &quot;Quick brown fox.&quot;;

    std::regex words_regex(&quot;[^\\s]+&quot;);
    auto words_begin = 
        std::sregex_iterator(s.begin(), s.end(), words_regex);
    auto words_end = std::sregex_iterator();

    std::cout &lt;&lt; &quot;Found &quot; 
              &lt;&lt; std::distance(words_begin, words_end) 
              &lt;&lt; &quot; words:\n&quot;;

    for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
        std::smatch match = *i;                                                 
        std::string match_str = match.str(); 
        std::cout &lt;&lt; match_str &lt;&lt; '\n';
    }   
}
| output=
Found 3 words:
Quick
brown
fox.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc match_results }}
{{dsc tfun | cpp/regex/regex_search | check if a regular expression occurs anywhere within a string | notes={{mark c++11}}}}
{{dsc begin}}

[[de:cpp/regex/regex iterator]]
[[es:cpp/regex/regex iterator]]
[[fr:cpp/regex/regex iterator]]
[[it:cpp/regex/regex iterator]]
[[ja:cpp/regex/regex iterator]]
[[pt:cpp/regex/regex iterator]]
[[ru:cpp/regex/regex iterator]]
[[zh:cpp/regex/regex iterator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/operator*</title>
    <ns>0</ns>
    <id>9819</id>
    <revision>
      <id>63947</id>
      <parentid>62931</parentid>
      <timestamp>2013-08-01T15:46:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="520">{{cpp/regex/regex_iterator/title | operator*,operator-&gt; }}
{{cpp/regex/regex_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
const value_type&amp; operator*() const;
}}
{{dcl | num=2 | since=c++11 | 1=
const value_type* operator-&gt;() const;
}}
{{dcl end}}

Extracts the current {{lc|std::regex_match}} from a {{tt|regex_iterator}}:

@1@ Returns a reference to the current {{lc|std::regex_match}}.

@2@ Returns a pointer to the current {{lc|std::regex_match}}.

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/operator=</title>
    <ns>0</ns>
    <id>12682</id>
    <revision>
      <id>61477</id>
      <timestamp>2013-06-06T02:11:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="357">{{cpp/regex/regex_iterator/title | operator{{=}}}}
{{cpp/regex/regex_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
regex_iterator&amp; operator=( const regex_iterator&amp; other );
}}
{{dcl end}}

Assigns the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | regex iterator to assign}}
{{par end}}

===Return value===
{{c|*this}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/operator arith</title>
    <ns>0</ns>
    <id>12683</id>
    <revision>
      <id>61480</id>
      <parentid>61479</parentid>
      <timestamp>2013-06-06T02:21:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="2334">{{cpp/regex/regex_iterator/title | operator++, operator++{{small|(int)}}}}
{{cpp/regex/regex_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
regex_iterator&amp; operator++();
}}
{{dcl | since=c++11 | 1=
regex_iterator operator++(int);
}}
{{dcl end}}

Advances the iterator on the next match.

{{todo|explain better}}

At first, a local variable of type {{tt|BidirIt}} is constructed with the value of {{c|match[0].second}}. 

If the iterator holds a zero-length match and {{c|start {{==}} end}}, {{c|*this}} is set to end-of-sequence iterator and the function returns.

Otherwise, if the iterator holds a zero-length match the operator invokes the following:

{{cc|regex_search(start, end, match, *pregex, 
                  flags {{!}} regex_constants::match_not_null {{!}} 
                          regex_constants::match_continuous);}} 

If the call returns {{c|true}}, the function returns.

Otherwise the operator increments {{tt|start}} and continues as if the most recent match was not a zero-length match.

If the most recent match was not a zero-length match, the operator sets {{tt|flags}} to {{c|flags {{!}} regex_constants::match_prev_avail}} and invokes the following: 

{{cc|regex_search(start, end, match, *pregex, flags);}}

If the call returns {{c|false}}, the iterator sets {{c|*this}} to the end-of-sequence iterator, the function returns.

In all cases in which the call to {{c|regex_search}} returns {{c|true}}, {{c|match.prefix().first}} will be equal to the previous value of {{c|match[0].second}} and for each index ''i'' in the range ''[0, ''{{cc|match.size()}}'')''
for which {{c|match[i].matched}} is {{c|true}}, {{c|match[i].position()}} will return {{c|distance(begin, match[i].first)}}.

This means that {{c|match[i].position()}} gives the offset from the beginning of the target sequence, which is often not the same as the offset from the sequence passed in the call to {{c|regex_search}}.

It is unspecified how the implementation makes these adjustments. This means that a compiler may call an implementation-specific search function, in which case a user-defined specialization of {{c|regex_search}} will not be called.

The behavior is undefined if the iterator is end-of-sequence iterator.

===Parameters===
(none)

===Return value===
@1@ {{c|*this}}

@2@ The previous value of the iterator.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/operator cmp</title>
    <ns>0</ns>
    <id>9818</id>
    <revision>
      <id>63946</id>
      <parentid>61019</parentid>
      <timestamp>2013-08-01T15:46:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Removing de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="1102">{{cpp/regex/regex_iterator/title | operator{{==}},operator!{{=}} }}
{{cpp/regex/regex_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
bool operator{{==}}(const regex_iterator&amp; rhs) const;
}}
{{dcl | num=2 | since=c++11 | 1=
bool operator!{{=}}(const regex_iterator&amp; rhs) const;
}}
{{dcl end}}

Compares two {{tt|regex_iterator}}s.

For the sake of exposition, assume that {{tt|regex_iterator}} contains the following members:
* {{tt|BidirIt begin}};
* {{tt|BidirIt end}};
* {{c|const regex_type *pregex;}}
* {{c|std::regex_constants::match_flag_type flags;}}
* {{c|std::match_results&lt;BidirIt&gt; match;}}

@1@ Returns {{c|true}} if {{c|*this}} and {{tt|rhs}} are both end-of-sequence iterators, or if all of the following conditions are true:
* {{c|begin {{==}} rhs.begin}}
* {{c|end {{==}} rhs.end}}
* {{c|pregex {{==}} rhs.pregex}}
* {{c|flags {{==}} rhs.flags}}
* {{c|match[0] {{==}} rhs.match[0]}}
 
@2@ Returns {{c|!(*this {{==}} rhs)}}

===Parameters===
{{par begin}}
{{par | rhs | a {{tt|regex_iterator}} to compare to}}
{{par end}}

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/operator comp</title>
    <ns>0</ns>
    <id>10135</id>
    <redirect title="cpp/regex/regex iterator/operator cmp" />
    <revision>
      <id>48362</id>
      <timestamp>2013-05-27T17:31:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/regex/regex iterator/operator comp]] to [[cpp/regex/regex iterator/operator cmp]]: move to the correct title</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[cpp/regex/regex iterator/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex iterator/regex iterator</title>
    <ns>0</ns>
    <id>9813</id>
    <revision>
      <id>68869</id>
      <parentid>63945</parentid>
      <timestamp>2014-03-22T20:17:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2332</comment>
      <text xml:space="preserve" bytes="1718">{{cpp/regex/regex_iterator/title | regex_iterator}}
{{cpp/regex/regex_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
regex_iterator();
}}
{{dcl | num=2 | since=c++11 | 1= 
regex_iterator(BidirIt a, BidirIt b,
               const regex_type&amp; re,
               std::regex_constants::match_flag_type m =
                   std::regex_constants::match_default);
}}
{{dcl | num=3 | since=c++11 | 1= 
regex_iterator(const regex_iterator&amp;);
}}
{{dcl | num=4 | since=c++14 | 1= 
regex_iterator(BidirIt, BidirIt,
               const regex_type&amp;&amp;,
               std::regex_constants::match_flag_type =
                   std::regex_constants::match_default) = delete;
}}
{{dcl end}}

Constructs a new {{tt|regex_iterator}}:

@1@ Default constructor.  Constructs an end-of-sequence iterator.

@2@ Constructs a {{tt|regex_iterator}} from the sequence of characters {{tt|[a, b)}}, the regular expression {{tt|re}}, and a flag {{tt|m}} that governs matching behavior.  This constructor performs an initial call to {{lc|std::regex_search}} with this data.  If the result of this initial call is {{c|false}}, {{c|*this}} is set to an end-of-sequence iterator.

@3@ Copies a {{tt|regex_iterator}}.

@4@ The overload 2 is not allowed to be called with a temporary regex, since the returned iterator would be immediately invalidated.

===Parameters===
{{par begin}}
{{par | a | {{tt|BidirIt}} to the beginning of the target character sequence}}
{{par | b | {{tt|BidirIt}} to the end of the targe character sequence}}
{{par | re | regular expression used to search the target character sequence}}
{{par | m | flags that govern the behavior of {{tt|re}} }}
{{par end}}

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1>9r58qjisq3axp8n678cajrmhcevwrfz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex match</title>
    <ns>0</ns>
    <id>2288</id>
    <revision>
      <id>68858</id>
      <parentid>62933</parentid>
      <timestamp>2014-03-22T19:40:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2329</comment>
      <text xml:space="preserve" bytes="8254">{{cpp/title|regex_match}}
{{cpp/regex/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class BidirIt, 
          class Alloc, class CharT, class Traits &gt;
bool regex_match( BidirIt first, BidirIt last,
                  std::match_results&lt;BidirIt,Alloc&gt;&amp; m,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class BidirIt, 
          class CharT, class Traits &gt;
bool regex_match( BidirIt first, BidirIt last,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class CharT, class Alloc, class Traits &gt;
bool regex_match( const CharT* str,
                  std::match_results&lt;const CharT*,Alloc&gt;&amp; m,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class STraits, class SAlloc, 
          class Alloc, class CharT, class Traits &gt;
bool regex_match( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; s,
                  std::match_results&lt;
                      typename std::basic_string&lt;CharT,STraits,SAlloc&gt;::const_iterator,
                      Alloc
                  &gt;&amp; m,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class CharT, class Traits &gt;
bool regex_match( const CharT* str,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class STraits, class SAlloc, 
          class CharT, class Traits &gt;
bool regex_match( const std::basic_string&lt;CharT, STraits, SAlloc&gt;&amp; s,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default );
}}
{{dcl | num=7 | since=c++14 | 1=
template&lt; class STraits, class SAlloc, 
          class Alloc, class CharT, class Traits &gt;
bool regex_match( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp;&amp;,
                  std::match_results&lt;
                      typename std::basic_string&lt;CharT,STraits,SAlloc&gt;::const_iterator,
                      Alloc
                  &gt;&amp;,
                  const std::basic_regex&lt;CharT,Traits&gt;&amp;,
                  std::regex_constants::match_flag_type flags = 
                      std::regex_constants::match_default ) = delete;
}}
{{dcl end}}

Determines if the regular expression {{tt|el}} matches the given target. 

@1@ Determines if there is a match between the regular expression {{tt|e}} and the entire target character sequence {{tt|[first,last)}}, taking into account the effect of {{tt|flags}}. Match results are returned in {{tt|m}}.

@2@ Behaves as (1) above, omitting the match results.

@3@ Returns {{c|std::regex_match(str, str + std::char_traits&lt;charT&gt;::length(str), m, e, flags)}}.

@4@ Returns {{c|std::regex_match(s.begin(), s.end(), m, e, flags)}}.

@5@ Returns {{c|std::regex_match(str, str + std::char_traits&lt;charT&gt;::length(str), e, flags)}}.

@6@ Returns {{c|std::regex_match(s.begin(), s.end(), e, flags)}}.

@7@ The overload 4 is prohibited from accepting temporary strings, otherwise this function populates match_results m with string iterators that become invalid immediately.

Note that {{tt|regex_match}} will only successfully match a regular expression to an ''entire'' character sequence, whereas {{lc|std::regex_search}} will successfully match subsequences.

===Parameters===
{{par begin}}
{{par | first, last | the target character range to apply the regex to, given as iterators}}
{{par | m | the match results}}
{{par | str | the target string, given as a null-terminated C-style string}}
{{par | s | the target string, given as a {{lc|std::basic_string}} }}
{{par | e | the regular expression}}
{{par | flags | flags used to determine how the match will be performed}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Return value===
Returns {{c|true}} if a match exists, {{c|false}} otherwise. In either case, the object {{tt|m}} is updated, as follows:

If the match does not exist:
{{dsc begin}}
{{dsc | {{c|1=m.ready() == true}} }}
{{dsc | {{c|1=m.empty() == true}} }}
{{dsc | {{c|1=m.size() == 0}} }}
{{dsc end}}

If the match exists:
{{dsc begin}}
{{dsc | {{c|m.ready()}} | {{c|true}} }}
{{dsc | {{c|m.empty()}} | {{c|false}} }}
{{dsc | {{c|m.size()}}  | number of subexpressions plus 1, that is, {{c|1+e.mark_count()}}}}
{{dsc | {{c|m.prefix().first}} | {{tt|first}} }}
{{dsc | {{c|m.prefix().second}} | {{tt|first}} }}
{{dsc | {{c|m.prefix().matched}} | {{c|false}} (the match prefix is empty) }}
{{dsc | {{c|m.suffix().first}} | {{tt|last}}}}
{{dsc | {{c|m.suffix().second}} | {{tt|last}}}}
{{dsc | {{c|m.suffix().matched}} | {{c|false}} (the match suffix is empty) }}
{{dsc | {{c|m[0].first}} | {{tt|first}} }}
{{dsc | {{c|m[0].second}} | {{tt|last}} }}
{{dsc | {{c|m[0].matched}} | {{c|true}} (the entire sequence is matched)}}
{{dsc | {{c|1=m[n].first}} | the start of the sequence that matched sub-expression n, or {{tt|last}} if the subexpression did not participate in the match}}
{{dsc | {{c|1=m[n].second}} | the end of the sequence that matched sub-expression n, or {{tt|last}} if the subexpression did not participate in the match}}
{{dsc | {{c|1=m[n].matched}} | {{c|true}} if sub-expression n participated in the match, {{c|false}} otherwise}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    // Simple regular expression matching
    std::string fnames[] = {&quot;foo.txt&quot;, &quot;bar.txt&quot;, &quot;baz.dat&quot;, &quot;zoidberg&quot;};
    std::regex txt_regex(&quot;[a-z]+\\.txt&quot;);

    for (const auto &amp;fname : fnames) {
        std::cout &lt;&lt; fname &lt;&lt; &quot;: &quot; &lt;&lt; std::regex_match(fname, txt_regex) &lt;&lt; '\n';
    }   

    // Extraction of a sub-match
    std::regex base_regex(&quot;([a-z]+)\\.txt&quot;);
    std::smatch base_match;

    for (const auto &amp;fname : fnames) {
        if (std::regex_match(fname, base_match, base_regex)) {
            // The first sub_match is the whole string; the next
            // sub_match is the first parenthesized expression.
            if (base_match.size() == 2) {
                std::ssub_match base_sub_match = base_match[1];
                std::string base = base_sub_match.str();
                std::cout &lt;&lt; fname &lt;&lt; &quot; has a base of &quot; &lt;&lt; base &lt;&lt; '\n';
            }
        }
    }

    // Extraction of several sub-matches
    std::regex pieces_regex(&quot;([a-z]+)\\.([a-z]+)&quot;);
    std::smatch pieces_match;

    for (const auto &amp;fname : fnames) {
        if (std::regex_match(fname, pieces_match, pieces_regex)) {
            std::cout &lt;&lt; fname &lt;&lt; '\n';
            for (size_t i = 0; i &lt; pieces_match.size(); ++i) {
                std::ssub_match sub_match = pieces_match[i];
                std::string piece = sub_match.str();
                std::cout &lt;&lt; &quot;  submatch &quot; &lt;&lt; i &lt;&lt; &quot;: &quot; &lt;&lt; piece &lt;&lt; '\n';
            }   
        }   
    }   
}
 | output=
foo.txt: 1
bar.txt: 1
baz.dat: 0
zoidberg: 0
foo.txt has a base of foo
bar.txt has a base of bar
foo.txt
  submatch 0: foo.txt
  submatch 1: foo
  submatch 2: txt
bar.txt
  submatch 0: bar.txt
  submatch 1: bar
  submatch 2: txt
baz.dat
  submatch 0: baz.dat
  submatch 1: baz
  submatch 2: dat
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc basic_regex}}
{{dsc inc | cpp/regex/dsc match_results}}
{{dsc inc | cpp/regex/dsc regex_search}}
{{dsc end}}

[[de:cpp/regex/regex match]]
[[es:cpp/regex/regex match]]
[[fr:cpp/regex/regex match]]
[[it:cpp/regex/regex match]]
[[ja:cpp/regex/regex match]]
[[pt:cpp/regex/regex match]]
[[ru:cpp/regex/regex match]]
[[zh:cpp/regex/regex match]]</text>
      <sha1>1d16wfj006mbazk8dz60jthfo755q0v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex replace</title>
    <ns>0</ns>
    <id>3270</id>
    <revision>
      <id>68868</id>
      <parentid>68867</parentid>
      <timestamp>2014-03-22T20:15:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>clarify ret val, too</comment>
      <text xml:space="preserve" bytes="6862">{{cpp/title|regex_replace}}
{{cpp/regex/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class OutputIt, class BidirIt,
          class Traits, class CharT,
          class STraits, class SAlloc &gt;
OutputIt regex_replace( OutputIt out, BidirIt first, BidirIt last,
                        const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                        const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; fmt,
                        std::regex_constants::match_flag_type flags {{=}} 
                            std::regex_constants::match_default );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class OutputIt, class BidirIt,
          class Traits, class CharT &gt;
OutputIt regex_replace( OutputIt out, BidirIt first, BidirIt last,
                        const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                        const CharT* fmt,
                        std::regex_constants::match_flag_type flags {{=}} 
                            std::regex_constants::match_default );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class Traits, class CharT,
          class STraits, class SAlloc,
          class FTraits, class FAlloc &gt;
std::basic_string&lt;CharT,STraits,SAlloc&gt; 
    regex_replace( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; s,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                   const std::basic_string&lt;CharT,FTraits,FAlloc&gt;&amp; fmt,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class Traits, class CharT,
          class STraits, class SAlloc &gt;
std::basic_string&lt;CharT,STraits,SAlloc&gt; 
    regex_replace( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; s,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                   const CharT* fmt,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class Traits, class CharT,
          class STraits, class SAlloc &gt;
std::basic_string&lt;CharT&gt; 
    regex_replace( const CharT* s,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                   const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; fmt,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class Traits, class CharT &gt;
std::basic_string&lt;CharT&gt; 
    regex_replace( const CharT* s,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; re,
                   const CharT* fmt,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl end}}

{{tt|regex_replace}} uses a regular expression to perform substitution on a sequence of characters:

@1@ Copies characters in the range {{tt|[first,last)}} to {{tt|out}}, replacing any sequences that match {{tt|re}} with characters formatted by {{tt|fmt}}.  In other words:

::* Constructs a {{lc|std::regex_iterator}} object {{tt|i}} as if by {{c|std::regex_iterator&lt;BidirIt, CharT, traits&gt; i(first, last, re, flags)}}, and uses it to step through every match of {{tt|re}} within the sequence {{tt|[first,last)}}. 
::* For each such match {{tt|m}}, copies the non-matched subsequence ([[cpp/regex/match_results/prefix|{{tt|m.prefix()}}]]) into {{tt|out}} as if by {{c|out {{=}} std::copy(m.prefix().first, m.prefix().second, out)}} and then replaces the matched subsequence with the formatted replacement string as if by calling [[cpp/regex/match_results/format|{{c|out {{=}} m.format(out, fmt, flags)}}]]. 
::* When no more matches are found, copies the remaining non-matched characters to {{tt|out}} as if by {{c|out {{=}} std::copy(last_m.suffix().first, last_m.suffix().second, out)}} where {{tt|last_m}} is a copy of the last match found. 
::* If there are no matches, copies the entire sequence into {{tt|out}} as-is, by {{c|out {{=}} std::copy(first, last, out)}}
::* If {{tt|flags}} contains {{lc|std::regex_constants::format_no_copy}}, the non-matched subsequences are not copied into {{tt|out}}.
::* If {{tt|flags}} contains {{lc|std::regex_constants::format_first_only}}, only the first match is replaced.

@2@ same as 1), but the formatted replacement is performed as if by calling [[cpp/regex/match_results/format|{{c|out {{=}} m.format(out, fmt, fmt + char_traits&lt;charT&gt;::length(fmt), flags)}}]]

@3-4@ Constructs an empty string {{tt|result}} of type {{c|std::basic_string&lt;CharT, ST, SA&gt;}} and calls {{c|std::regex_replace(std::back_inserter(result), s.begin(), s.end(), re, fmt, flags)}}.

@5-6@Constructs an empty string {{tt|result}} of type {{c|std::basic_string&lt;CharT&gt;}} and calls {{c|std::regex_replace(std::back_inserter(result), s, s + std::char_traits&lt;CharT&gt;::length(s), re, fmt, flags)}}.

===Parameters===
{{par begin}}
{{par | first, last | the input character sequence, represented as a pair of iterators}}
{{par | s | the input character sequence, represented as {{lc|std::basic_string}} or character array}}
{{par | re | the {{lc|std::basic_regex}} that will be matched against the input sequence}}
{{par | flags | the match flags of type {{lc|std::regex_constants::match_flag_type}} }}
{{par | fmt | the regex replacement format string, exact syntax depends on the value of {{tt|flags}} }}
{{par | out | output iterator to store the result of the replacement }}
{{par hreq}}
{{par req concept | OutputIt | OutputIterator}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Return value===
@1-2@ Returns a copy of the output iterator {{tt|out}} after all the insertions.
@3-6@ Returns the string {{tt|result}} which contains the output.

===Exceptions===
May throw {{lc|std::regex_error}} to indicate an [[cpp/regex/error_type|error condition]].

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;regex&gt;
#include &lt;string&gt;

int main()
{
   std::string text = &quot;Quick brown fox&quot;;
   std::regex vowel_re(&quot;a{{!}}e{{!}}i{{!}}o{{!}}u&quot;);

   // write the results to an output iterator
   std::regex_replace(std::ostreambuf_iterator&lt;char&gt;(std::cout),
                      text.begin(), text.end(), vowel_re, &quot;*&quot;);

   // construct a string holding the results
   std::cout &lt;&lt; '\n' &lt;&lt; std::regex_replace(text, vowel_re, &quot;[$&amp;]&quot;) &lt;&lt; '\n';
}
 | output=
Q**ck br*wn f*x
Q[u][i]ck br[o]wn f[o]x
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc regex_search }}
{{dsc inc | cpp/regex/dsc match_flag_type}}
{{dsc end}}

[[de:cpp/regex/regex replace]]
[[es:cpp/regex/regex replace]]
[[fr:cpp/regex/regex replace]]
[[it:cpp/regex/regex replace]]
[[ja:cpp/regex/regex replace]]
[[pt:cpp/regex/regex replace]]
[[ru:cpp/regex/regex replace]]
[[zh:cpp/regex/regex replace]]</text>
      <sha1>k56qze26wa9mrz1qk7somb9xsrjylo3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex search</title>
    <ns>0</ns>
    <id>3268</id>
    <revision>
      <id>72338</id>
      <parentid>68866</parentid>
      <timestamp>2014-08-13T06:02:49Z</timestamp>
      <contributor>
        <username>Jaredgrubb</username>
        <id>34</id>
      </contributor>
      <minor/>
      <comment>Typo (null-terminates -&gt; null-terminated)</comment>
      <text xml:space="preserve" bytes="7591">{{cpp/title|regex_search}}
{{cpp/regex/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class BidirIt, 
          class Alloc, class CharT, class Traits &gt;
bool regex_search( BidirIt first, BidirIt last,
                   std::match_results&lt;BidirIt,Alloc&gt;&amp; m,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags = 
                       std::regex_constants::match_default );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class Alloc, class CharT, class Traits &gt;
bool regex_search( const CharT* str,
                   std::match_results&lt;BidirIt,Alloc&gt;&amp; m,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class STraits, class SAlloc,
          class Alloc, class CharT, class Traits &gt;
bool regex_search( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; s,
                   std::match_results&lt;
                       typename std::basic_string&lt;CharT,STraits,SAlloc&gt;::const_iterator, 
                       Alloc
                   &gt;&amp; m,
                   const std::basic_regex&lt;CharT, Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags {{=}}
                       std::regex_constants::match_default );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class BidirIt,
          class CharT, class Traits &gt;
bool regex_search( BidirIt first, BidirIt last,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class CharT, class Traits &gt;
bool regex_search( const CharT* str,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags {{=}} 
                       std::regex_constants::match_default );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class STraits, class SAlloc,
          class CharT, class Traits &gt;
bool regex_search( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp; s,
                   const std::basic_regex&lt;CharT,Traits&gt;&amp; e,
                   std::regex_constants::match_flag_type flags = 
                       std::regex_constants::match_default );
}}
{{dcl | num=7 | since=c++14 | 1=
template&lt; class STraits, class SAlloc,
          class Alloc, class CharT, class Traits &gt;
bool regex_search( const std::basic_string&lt;CharT,STraits,SAlloc&gt;&amp;&amp;,
                   std::match_results&lt;
                       typename std::basic_string&lt;CharT,STraits,SAlloc&gt;::const_iterator, 
                       Alloc
                   &gt;&amp;,
                   const std::basic_regex&lt;CharT, Traits&gt;&amp;,
                   std::regex_constants::match_flag_type flags {{=}}
                       std::regex_constants::match_default ) = delete;
}}
{{dcl end}}

Determines if there is a match between the regular expression {{tt|e}} and some subsequence in the target character sequence.

@1@ Analyzes generic range {{tt|[first,last)}}. Match results are returned in {{tt|m}}.

@2@ Analyzes a null-terminated string pointed to by {{tt|str}}. Match results are returned in {{tt|m}}.

@3@ Analyzes a string {{tt|s}}. Match results are returned in {{tt|m}}.

@4-6@ Equivalent to (1-3), just omits the match results.

@7@ The overload 3 is prohibited from accepting temporary strings, otherwise this function populates match_results m with string iterators that become invalid immediately.

{{tt|regex_search}} will successfully match any subsequence of the given sequence, whereas {{lc|std::regex_match}} will only return {{c|true}} if the regular expression matches the ''entire'' sequence.

===Parameters===
{{par begin}}
{{par | first, last | a range identifying the target character sequence}}
{{par | str | a pointer to a null-terminated target character sequence}}
{{par | s | a string identifying target character sequence}}
{{par | e | the {{lc|std::regex}} that should be applied to the target character sequence}}
{{par | m | the match results}}
{{par | flags | {{lc|std::regex_constants::match_flag_type}} governing search behavior}}
{{par hreq}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par req concept | Alloc | Allocator}}
{{par end}}

===Return value===
Returns {{c|true}} if a match exists, {{c|false}} otherwise. In either case, the object {{tt|m}} is updated, as follows:

If the match does not exist:
{{dsc begin}}
{{dsc | {{c|1=m.ready() == true}} }}
{{dsc | {{c|1=m.empty() == true}} }}
{{dsc | {{c|1=m.size() == 0}} }}
{{dsc end}}

If the match exists:
{{dsc begin}}
{{dsc | {{c|m.ready()}} | {{c|true}} }}
{{dsc | {{c|m.empty()}} | {{c|false}} }}
{{dsc | {{c|m.size()}}  | number of subexpressions plus 1, that is, {{c|1+e.mark_count()}} }}
{{dsc | {{c|m.prefix().first}} | {{tt|first}} }}
{{dsc | {{c|m.prefix().second}} | {{c|m[0].first}} }}
{{dsc | {{c|m.prefix().matched}} | {{c|m.prefix().first !{{=}} m.prefix().second}} }}
{{dsc | {{c|m.suffix().first}} | {{c|m[0].second}}}}
{{dsc | {{c|m.suffix().second}} | {{tt|last}}}}
{{dsc | {{c|m.suffix().matched}} | {{c|m.suffix().first !{{=}} m.suffix().second}} }}
{{dsc | {{c|m[0].first}} | the start of the matching sequence }}
{{dsc | {{c|m[0].second}} | the end of the matching sequence }}
{{dsc | {{c|m[0].matched}} | {{c|true}}}}
{{dsc | {{c|1=m[n].first}} | the start of the sequence that matched sub-expression n, or {{tt|last}} if the subexpression did not participate in the match}}
{{dsc | {{c|1=m[n].second}} | the end of the sequence that matched sub-expression n, or {{tt|last}} if the subexpression did not participate in the match}}
{{dsc | {{c|1=m[n].matched}} | {{c|true}} if sub-expression n participated in the match, {{c|false}} otherwise}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    std::string lines[] = {&quot;Roses are #ff0000&quot;,
                           &quot;violets are #0000ff&quot;,
                           &quot;all of my base are belong to you&quot;};

    std::regex color_regex(&quot;#([a-f0-9]{2})&quot;
                            &quot;([a-f0-9]{2})&quot;
                            &quot;([a-f0-9]{2})&quot;);

    for (const auto &amp;line : lines) {
        std::cout &lt;&lt; line &lt;&lt; &quot;: &quot; 
                  &lt;&lt; std::regex_search(line, color_regex) &lt;&lt; '\n';
    }   
    
    std::smatch color_match;
    for (const auto &amp;line : lines) {
        std::regex_search(line, color_match, color_regex);
        std::cout &lt;&lt; &quot;matches for '&quot; &lt;&lt; line &lt;&lt; &quot;'\n&quot;;
        for (size_t i = 0; i &lt; color_match.size(); ++i) {
            std::ssub_match sub_match = color_match[i];
            std::string sub_match_str = sub_match.str();
            std::cout &lt;&lt; i &lt;&lt; &quot;: &quot; &lt;&lt; sub_match_str &lt;&lt; '\n';
        }   
    }   
}
 | output=
Roses are #ff0000: 1
violets are #0000ff: 1
all of my base are belong to you: 0
matches for 'Roses are #ff0000'
0: #ff0000
1: ff
2: 00
3: 00
matches for 'violets are #0000ff'
0: #0000ff
1: 00
2: 00
3: ff
matches for 'all of my base are belong to you'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc basic_regex}}
{{dsc inc | cpp/regex/dsc match_results}}
{{dsc inc | cpp/regex/dsc regex_match}}
{{dsc end}}

[[de:cpp/regex/regex search]]
[[es:cpp/regex/regex search]]
[[fr:cpp/regex/regex search]]
[[it:cpp/regex/regex search]]
[[ja:cpp/regex/regex search]]
[[pt:cpp/regex/regex search]]
[[ru:cpp/regex/regex search]]
[[zh:cpp/regex/regex search]]</text>
      <sha1>ro83hvi3kmqvuchlledansjs03hqrum</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator</title>
    <ns>0</ns>
    <id>2290</id>
    <revision>
      <id>66757</id>
      <parentid>63423</parentid>
      <timestamp>2013-12-28T21:23:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>member pointer is pointing to sub_match, not match_results</comment>
      <text xml:space="preserve" bytes="5319">{{cpp/title|regex_token_iterator}}
{{cpp/regex/regex_token_iterator/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
template&lt;
    class BidirIt,
    class CharT = typename std::iterator_traits&lt;BidirIt&gt;::value_type,
    class Traits = std::regex_traits&lt;CharT&gt;
&gt; class regex_token_iterator
}}

{{tt|std::regex_token_iterator}} is a read-only {{concept|ForwardIterator}} that accesses the individual sub-matches of every match of a regular expression within the underlying character sequence. It can also be used to access the parts of the sequence that were not matched by the given regular expression (e.g. as a tokenizer).

On construction, it constructs an {{lc|std::regex_iterator}} and on every increment it steps through the requested sub-matches from the current match_results, incrementing the underlying {{tt|regex_iterator}} when incrementing away from the last submatch.

The default-constructed {{tt|std::regex_token_iterator}} is the end-of-sequence iterator. When a valid {{tt|std::regex_token_iterator}} is incremented after reaching the last submatch of the last match, it becomes equal to the end-of-sequence iterator. Dereferencing or incrementing it further invokes undefined behavior.

Just before becoming the end-of-sequence iterator, a {{lc|std::regex_token_iterator}} may become a ''suffix iterator'', if the index {{c|-1}} (non-matched fragment) appears in the list of the requested submatch indexes. Such iterator, if dereferenced, returns a match_results corresponding to the sequence of characters between the last match and the end of sequence.

A typical implementation of {{tt|std::regex_token_iterator}} holds the underlying {{lc|std::regex_iterator}}, a container (e.g. {{c|std::vector&lt;int&gt;}}) of the requested submatch indexes, the internal counter equal to the index of the submatch, a pointer to {{lc|std::sub_match}}, pointing at the current submatch of the current match, and a {{lc|std::match_results}} object containing the last non-matched character sequence (used in tokenizer mode).

===Type requirements===
{{par begin}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Specializations===
Several specializations for common character sequence types are defined:

{{dsc begin}}
{{dsc header | regex}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|cregex_token_iterator}} | {{c|regex_token_iterator&lt;const char*&gt;}}}}
{{dsc | {{tt|wcregex_token_iterator}} | {{c|regex_token_iterator&lt;const wchar_t*&gt;}}}}
{{dsc | {{tt|sregex_token_iterator}} | {{c|regex_token_iterator&lt;std::string::const_iterator&gt;}}}}
{{dsc | {{tt|wsregex_token_iterator}} | {{c|regex_token_iterator&lt;std::wstring::const_iterator&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{c|std::sub_match&lt;BidirIt&gt;}} }}
{{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
{{dsc | {{tt|pointer}} | {{c|const value_type*}} }}
{{dsc | {{tt|reference}} | {{c|const value_type&amp;}} }}
{{dsc | {{tt|iterator_category}} | {{lc|std::forward_iterator_tag}} }}
{{dsc | {{tt|regex_type}} | {{c|basic_regex&lt;CharT, Traits&gt;}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc constructor}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc destructor}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator{{=}}}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator_cmp}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator*}}
{{dsc inc | cpp/regex/regex_token_iterator/dsc operator_arith}}
{{dsc end}}

===Notes===
It is the programmer's responsibility to ensure that the {{lc|std::basic_regex}} object passed to the iterator's constructor outlives the iterator. Because the iterator stores a {{lc|std::regex_iterator}} which stores a pointer to the regex, incrementing the iterator after the regex was destroyed results in undefined behavior.

===Example===
{{example
 | 
 | code=

#include &lt;fstream&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;regex&gt;

int main()
{
   std::string text = &quot;Quick brown fox.&quot;;
   // tokenization (non-matched fragments)
   // Note that regex is matched only two times: when the third value is obtained
   // the iterator is a suffix iterator.
   std::regex ws_re(&quot;\\s+&quot;); // whitespace
   std::copy( std::sregex_token_iterator(text.begin(), text.end(), ws_re, -1),
              std::sregex_token_iterator(),
              std::ostream_iterator&lt;std::string&gt;(std::cout, &quot;\n&quot;));

   // iterating the first submatches
   std::string html = &quot;&lt;p&gt;&lt;a href=\&quot;http://google.com\&quot;&gt;google&lt;/a&gt; &quot;
                      &quot;&lt; a HREF =\&quot;http://cppreference.com\&quot;&gt;cppreference&lt;/a&gt;\n&lt;/p&gt;&quot;;
   std::regex url_re(&quot;&lt;\\s*A\\s+[^&gt;]*href\\s*=\\s*\&quot;([^\&quot;]*)\&quot;&quot;, std::regex::icase);
   std::copy( std::sregex_token_iterator(html.begin(), html.end(), url_re, 1),
              std::sregex_token_iterator(),
              std::ostream_iterator&lt;std::string&gt;(std::cout, &quot;\n&quot;));
}
|output=
Quick
brown
fox.
http://google.com
http://cppreference.com
}}

[[de:cpp/regex/regex token iterator]]
[[es:cpp/regex/regex token iterator]]
[[fr:cpp/regex/regex token iterator]]
[[it:cpp/regex/regex token iterator]]
[[ja:cpp/regex/regex token iterator]]
[[pt:cpp/regex/regex token iterator]]
[[ru:cpp/regex/regex token iterator]]
[[zh:cpp/regex/regex token iterator]]</text>
      <sha1>8kgzb8uku7l9e2i2lzhufi9czhy5r3n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator/operator*</title>
    <ns>0</ns>
    <id>12678</id>
    <revision>
      <id>61471</id>
      <timestamp>2013-06-06T01:21:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="541">{{cpp/regex/regex_token_iterator/title | operator*, operator-&gt;}}
{{cpp/regex/regex_token_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
const value_type&amp; operator*() const;
}}
{{dcl | since=c++11 | 1=
const value_type* operator-&gt;() const;
}}
{{dcl end}}

Returns a pointer or reference to the current match.

The behavior is undefined if the iterator is end-of-sequence iterator.

===Parameters===
{{par begin}}
{{par | other | regex iterator to assign}}
{{par end}}

===Return value===
A pointer or reference to the current match.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator/operator=</title>
    <ns>0</ns>
    <id>12676</id>
    <revision>
      <id>61467</id>
      <parentid>61466</parentid>
      <timestamp>2013-06-06T01:12:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="381">{{cpp/regex/regex_token_iterator/title | operator{{=}}}}
{{cpp/regex/regex_token_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
regex_token_iterator&amp; operator=( const regex_token_iterator&amp; other );
}}
{{dcl end}}

Assigns the contents of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | regex iterator to assign}}
{{par end}}

===Return value===
{{c|*this}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator/operator arith</title>
    <ns>0</ns>
    <id>12679</id>
    <revision>
      <id>61472</id>
      <timestamp>2013-06-06T01:26:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1219">{{cpp/regex/regex_token_iterator/title | operator++, operator++{{small|(int)}}}}
{{cpp/regex/regex_token_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
regex_token_iterator&amp; operator++();
}}
{{dcl | since=c++11 | 1=
regex_token_iterator operator++(int);
}}
{{dcl end}}

Advances the iterator on the next sub match.

{{todo|explain better}}

If {{c|*this}} is a suffix iterator, sets {{c|*this}} to an end-of-sequence iterator.

Otherwise, if {{c|N + 1 &lt; subs.size()}}, increments N and sets result to the address of the current match.

Otherwise, sets {{tt|N}} to {{c|0}} and increments {{tt|position}}. If {{tt|position}} is not an end-of-sequence iterator the operator sets result to the address of the current match.

Otherwise, if any of the values stored in subs is equal to {{c|-1}} and {{cc|prev-&gt;suffix().length()}} is not {{c|0}} the operator sets {{tt|*this}} to a suffix iterator that points to the range [{{c|prev-&gt;suffix().first}}, {{c|prev-&gt;suffix().second}}).

Otherwise, sets {{c|*this}} to an end-of-sequence iterator.

The behavior is undefined if the iterator is end-of-sequence iterator.

===Parameters===
(none)

===Return value===
@1@ {{c|*this}}

@2@ The previous value of the iterator.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator/operator cmp</title>
    <ns>0</ns>
    <id>12677</id>
    <revision>
      <id>61470</id>
      <parentid>61469</parentid>
      <timestamp>2013-06-06T01:19:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>1=</comment>
      <text xml:space="preserve" bytes="1111">{{title | operator==, operator!={{small|(std::regex_token_iterator)}}}}
{{cpp/regex/regex_token_iterator/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
bool operator==( const regex_token_iterator&amp; other ) const;
}}
{{dcl | since=c++11 | 1=
bool operator!=( const regex_token_iterator&amp; other ) const;
}}
{{dcl end}}

Checks whether {{c|*this}} and {{tt|other}} are equivalent.

Two regex token iterators are equal if:

@a@ They are both end-of-sequence iterators

@b@ They are both suffix iterators and the suffixes are equal.

@c@ Neither of them is end-of-sequence or suffix iterator and:

::* {{c|1=position == other.position}}
::* {{c|1=N == other.N}}
::* {{c|1=subs == other.subs}}


@1@ Checks whether {{c|*this}} is ''equal to'' {{tt|other}}.

@2@ Checks whether {{c|*this}} is ''not equal to'' {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | another regex token iterator to compare to}}
{{par end}}

===Return value===
@1@ {{c|true}} if {{c|*this}} is ''equal to'' {{tt|other}}, {{c|false}} otherwise.

@2@ {{c|true}} if {{c|*this}} is ''not equal to'' {{tt|other}}, {{c|false}} otherwise.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex token iterator/regex token iterator</title>
    <ns>0</ns>
    <id>9814</id>
    <revision>
      <id>68870</id>
      <parentid>66760</parentid>
      <timestamp>2014-03-22T20:20:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2332</comment>
      <text xml:space="preserve" bytes="5668">{{cpp/regex/regex_token_iterator/title | regex_token_iterator}}
{{cpp/regex/regex_token_iterator/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1= 
regex_token_iterator();
}}
{{dcl | num=2 | since=c++11 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp; re,
                      int submatch = 0,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default );
}}
{{dcl | num=3 | since=c++11 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp; re,
                      const std::vector&lt;int&gt;&amp; submatches,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default );
}}
{{dcl | num=4 | since=c++11 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp; re,
                      std::initializer_list&lt;int&gt; submatches,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default );
}}
{{dcl | num=5 | since=c++11 | 1= 
template &lt;std::size_t N&gt;
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp; re,
                      const int (&amp;submatches)[N],
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default );
}}
{{dcl | num=6 | since=c++11 | 1= 
regex_token_iterator( const regex_token_iterator&amp; other );
}}
{{dcl | num=7 | since=c++14 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp;&amp; re,
                      int submatch = 0,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default ) = delete;
}}
{{dcl | num=8 | since=c++14 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp;&amp; re,
                      const std::vector&lt;int&gt;&amp; submatches,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default ) = delete;
}}
{{dcl | num=9 | since=c++14 | 1= 
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp;&amp; re,
                      std::initializer_list&lt;int&gt; submatches,
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default ) = delete;
}}
{{dcl | num=10 | since=c++14 | 1= 
template &lt;std::size_t N&gt;
regex_token_iterator( BidirectionalIterator a, BidirectionalIterator b,
                      const regex_type&amp;&amp; re,
                      const int (&amp;submatches)[N],
                      std::regex_constants::match_flag_type m =
                          std::regex_constants::match_default ) = delete;
}}
{{dcl end}}

Constructs a new {{tt|regex_token_iterator}}:

@1@ Default constructor. Constructs the end-of-sequence iterator.

@2-5@ First, copies the list of the requested submatch out of the {{tt|submatches}} or {{tt|submatch}} argument into the member list stored in the iterator and constructs the member {{lc|std::regex_iterator}} by passing {{tt|a}}, {{tt|b}}, {{tt|re}}, and {{tt|m}} to its four-argument constructor (that constructor performs the initial call to {{lc|std::regex_search}}) and sets the internal counter of submatches to zero.
* If, after construction, the member {{tt|regex_iterator}} is not an end-of-sequence iterator, sets the member pointer to the address of the current {{lc|std::sub_match}}.
* Otherwise (if the member {{tt|regex_iterator}} is an end-of-sequence iterator), but the value {{c|-1}} is one of the values in {{tt|submatches}}/{{tt|submatch}}, turns {{tt|*this}} into a ''suffix iterator'' pointing at the range {{tt|[a,b)}} (the entire string is the non-matched suffix)
* Otherwise (if -1 is not in the list of submatches), turns {{tt|*this}} into the end-of-sequence iterator.

The behavior is undefined if any value in {{tt|submatches}} is less than {{c|-1}}.

@6@ Copy constructor: performs member-wise copy (including making a copy of the member {{tt|regex_iterator}} and the member pointer to current {{lc|sub_match}}).

@7-10@ The overloads 2-5 are prohibited from being called with a temporary regex since otherwise the returned iterator would be immediately invalidated

===Parameters===
{{par begin}}
{{par | a | {{concept|BidirectionalIterator}} to the beginning of the target character sequence}}
{{par | b | {{concept|BidirectionalIterator}} to the end of the target character sequence}}
{{par | re | regular expression used to search the target character sequence}}
{{par | submatch | the index of the submatch that should be returned. &quot;0&quot; represents the entire match, and &quot;-1&quot; represents the parts that are not matched (e.g, the stuff between matches).}}
{{par | submatches | the sequence of submatch indices that should be iterated over within each match, may include the special value -1 for the non-matched fragments}}
{{par | m | flags that govern the behavior of {{tt|re}} }}
{{par end}}

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/basic regex/basic regex]]
[[es:cpp/regex/basic regex/basic regex]]
[[fr:cpp/regex/basic regex/basic regex]]
[[it:cpp/regex/basic regex/basic regex]]
[[ja:cpp/regex/basic regex/basic regex]]
[[pt:cpp/regex/basic regex/basic regex]]
[[ru:cpp/regex/basic regex/basic regex]]
[[zh:cpp/regex/basic regex/basic regex]]</text>
      <sha1>g67shwjr46b2jfa4zp8k5sslqckw4gy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits</title>
    <ns>0</ns>
    <id>3267</id>
    <revision>
      <id>63424</id>
      <parentid>61314</parentid>
      <timestamp>2013-07-10T01:31:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2496">{{cpp/title|regex_traits}}
{{cpp/regex/regex_traits/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
template&lt; class CharT &gt;
class regex_traits;
}}

The type trait template {{tt|regex_traits}} supplies {{lc|std::basic_regex}} with the set of types and functions necessary to operate on the type {{tt|CharT}}.

Since many of regex operations are locale-sensitive (when {{lc|std::regex_constants::collate}} flag is set), the regex_traits class typically holds an instance of a {{lc|std::locale}} as a private member.

===Standard specializations===
Two specializations of {{tt|std::regex_traits}} are defined by the standard library:
{{dsc begin}}
{{dsc | {{tt|std::regex_traits&lt;char&gt;}}}}
{{dsc | {{tt|std::regex_traits&lt;wchar_t&gt;}}}}
{{dsc end}}
These specializations make it possible to use {{c|std::basic_regex&lt;char&gt;}} (aka {{lc|std::regex}}) and {{c|std::basic_regex&lt;wchar_t&gt;}} (aka {{lc|std::wregex}}), but in order to use, for example, {{c|std::basic_regex&lt;char32_t&gt;}}, user-provided specializtion {{c|std::regex_traits&lt;char32_t&gt;}} needs to be defined.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;CharT&gt;}}}}
{{dsc | {{tt|locale_type}} | The locale used for localized behavior in the regular expression. Must be {{concept|CopyConstructible}}}}
{{dsc | {{tt|char_class_type}} | Represents a character classification and is capable of holding an implementation specific set returned by {{tt|lookup_classname}}. Must be a {{concept|BitmaskType}}.}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_traits/dsc constructor}}
{{dsc inc | cpp/regex/regex_traits/dsc length}}
{{dsc inc | cpp/regex/regex_traits/dsc translate}}
{{dsc inc | cpp/regex/regex_traits/dsc translate_nocase}}
{{dsc inc | cpp/regex/regex_traits/dsc transform}}
{{dsc inc | cpp/regex/regex_traits/dsc transform_primary}}
{{dsc inc | cpp/regex/regex_traits/dsc lookup_collatename}}
{{dsc inc | cpp/regex/regex_traits/dsc lookup_classname}}
{{dsc inc | cpp/regex/regex_traits/dsc isctype}}
{{dsc inc | cpp/regex/regex_traits/dsc value}}
{{dsc inc | cpp/regex/regex_traits/dsc imbue}}
{{dsc inc | cpp/regex/regex_traits/dsc getloc}}
{{dsc end}}

[[de:cpp/regex/regex traits]]
[[es:cpp/regex/regex traits]]
[[fr:cpp/regex/regex traits]]
[[it:cpp/regex/regex traits]]
[[ja:cpp/regex/regex traits]]
[[pt:cpp/regex/regex traits]]
[[ru:cpp/regex/regex traits]]
[[zh:cpp/regex/regex traits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/getloc</title>
    <ns>0</ns>
    <id>12623</id>
    <revision>
      <id>61327</id>
      <timestamp>2013-06-05T21:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="624">{{cpp/regex/regex_traits/title|getloc}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
locale_type getloc() const;
}}
{{dcl end}}

Returns the current locale of the traits object. 

If {{lc|imbue()}} has been never called for this object, then the global locale at the time of the call is returned. Otherwise, the locale passed to the last call to {{lc|imbue()}} is returned.

===Parameters===
(none)

===Return value===
The current locale of the traits object.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_traits/dsc imbue}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/imbue</title>
    <ns>0</ns>
    <id>12610</id>
    <revision>
      <id>61313</id>
      <parentid>61312</parentid>
      <timestamp>2013-06-05T21:29:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+since</comment>
      <text xml:space="preserve" bytes="824">{{cpp/regex/regex_traits/title|imbue}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
locale_type imbue( locale_type loc );
}}
{{dcl end}}

Replaces the current locale with a copy of {{tt|loc}}. If {{tt|loc}} is different than the current locale, then all cached data is invalidated.

After the call {{c|1=getloc() == loc}}.

===Parameters===
{{par begin}}
{{par | loc | the locale to imbue}}
{{par end}}

===Return value===
The current locale of the traits object.

If {{tt|imbue()}} has been never called for this object, then the global locale at the time of the call is returned. Otherwise, the locale passed to the last call to {{tt|imbue()}} is returned.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_traits/dsc getloc}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/isctype</title>
    <ns>0</ns>
    <id>8945</id>
    <revision>
      <id>67008</id>
      <parentid>66917</parentid>
      <timestamp>2014-01-16T05:26:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+custom traits example</comment>
      <text xml:space="preserve" bytes="2753">{{cpp/regex/regex_traits/title|isctype}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
bool isctype( CharT c, char_class_type f ) const;
}}
{{dcl end}}

Determines whether the character {{tt|c}} belongs to the character class identified by {{tt|f}}, which, in turn, is a value returned by {{lc|lookup_classname()}} or a bitwise OR of several such values.

The version of this function provided in the standard library specializations of {{lc|std::regex_traits}} does the following:

@1@ First converts {{tt|f}} to some temporary value {{tt|m}} of type {{lc|std::ctype_base::mask}} in implementation-defined manner

@2@ Then attempts to classify the character in the imbued locale by calling {{c|std::use_facet&lt;std::ctype&lt;CharT&gt;&gt;(getloc()).is(m, c)}}. If that returned {{c|true}}, {{c|true}} is returned by {{tt|isctype()}}.

@3@ Otherwise, checks whether {{tt|c}} equals {{tt|'_'}} and the bitmask {{tt|f}} includes  the result of calling {{lc|lookup_classname()}} for the character class {{tt|[:w:]}}, in which case {{c|true}} is returned.

@4@ Otherwise, {{tt|false}} is returned.

===Parameters===
{{par begin}}
{{par | c | the character to classify}}
{{par | f | the bitmask obtained from one or several calls to lookup_classname()}}
{{par end}}

===Return value===
{{c|true}} if {{tt|c}} is classified by {{tt|f}}, {{c|false}} otherwise.

===Notes===
The description above summarizes C++14; the C++11 phrasing required this function to return true for {{tt|'_'}} in all cases ([http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#2018 LWG issue 2018])

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    std::regex_traits&lt;char&gt; t;
    std::string str_alnum = &quot;alnum&quot;;
    auto a = t.lookup_classname(str_alnum.begin(), str_alnum.end());
    std::string str_w = &quot;w&quot;; // [:w:] is [:alnum:] plus '_'
    auto w = t.lookup_classname(str_w.begin(), str_w.end());
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; t.isctype('A', w) &lt;&lt; ' ' &lt;&lt; t.isctype('A', a) &lt;&lt; '\n'
              &lt;&lt; t.isctype('_', w) &lt;&lt; ' ' &lt;&lt; t.isctype('_', a) &lt;&lt; '\n'
              &lt;&lt; t.isctype(' ', w) &lt;&lt; ' ' &lt;&lt; t.isctype(' ', a) &lt;&lt; '\n';
}
 | output=
true true
true false
false false
}}

{{cpp/regex/isctype_example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/regex_traits/dsc lookup_classname}}
{{dsc inc | cpp/locale/ctype/dsc do_is}}
{{dsc inc | cpp/string/wide/dsc iswctype}}
{{dsc end}}

[[de:cpp/regex/regex traits/isctype]]
[[es:cpp/regex/regex traits/isctype]]
[[fr:cpp/regex/regex traits/isctype]]
[[it:cpp/regex/regex traits/isctype]]
[[ja:cpp/regex/regex traits/isctype]]
[[pt:cpp/regex/regex traits/isctype]]
[[ru:cpp/regex/regex traits/isctype]]
[[zh:cpp/regex/regex traits/isctype]]</text>
      <sha1>50ehcxltx73qk682bo84vzou9voamlr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/length</title>
    <ns>0</ns>
    <id>8856</id>
    <revision>
      <id>51147</id>
      <parentid>41769</parentid>
      <timestamp>2013-06-01T03:52:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1147">{{cpp/regex/regex_traits/title|length}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
static std::size_t length(const char_type* p);
}}
{{dcl end}}

Calculates the length of a null-terminated character sequence, that is, the smallest {{tt|i}} such that {{c|1=p[i]==0}}.

Standard library specializations of {{lc|std::regex_traits}} execute {{c|std::char_traits&lt;CharT&gt;::length(p);}}

===Parameters===
{{par begin}}
{{par | p | pointer to the first element of the null-terminated character sequence}}
{{par end}}

===Return value===
The length of the null-terminated character string.

===Example===
{{example
 | code=
#include &lt;regex&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout &lt;&lt; std::regex_traits&lt;char&gt;::length(u8&quot;Кошка&quot;) &lt;&lt; '\n'
              &lt;&lt; std::regex_traits&lt;wchar_t&gt;::length(L&quot;Кошка&quot;) &lt;&lt; '\n';
}
 | output=
10
5
}}

[[de:cpp/regex/regex traits/length]]
[[es:cpp/regex/regex traits/length]]
[[fr:cpp/regex/regex traits/length]]
[[it:cpp/regex/regex traits/length]]
[[ja:cpp/regex/regex traits/length]]
[[pt:cpp/regex/regex traits/length]]
[[ru:cpp/regex/regex traits/length]]
[[zh:cpp/regex/regex traits/length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/lookup classname</title>
    <ns>0</ns>
    <id>8944</id>
    <revision>
      <id>68864</id>
      <parentid>67007</parentid>
      <timestamp>2014-03-22T20:02:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2271</comment>
      <text xml:space="preserve" bytes="3726">{{cpp/regex/regex_traits/title|lookup_classname}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class ForwardIt &gt;
char_class_type lookup_classname( ForwardIt first,
                                  ForwardIt last,
                                  bool icase = false ) const;
}}
{{dcl end}}

If the character sequence {{tt|[first, last)}} represents the name of a valid character class in the currently imbued locale (that is, the string between {{tt|[:}} and {{tt|:]}} in regular expressions), returns the implementation-defined value representing this character class. Otherwise, returns zero.

If the parameter {{tt|icase}} is {{c|true}}, the character class ignores character case, e.g. the regex {{tt|[:lower:]}} with {{lc|std::regex_constants::icase}} generates a call to {{tt|regex_traits&lt;&gt;::lookup_classname()}} with {{tt|[first, last)}} indicating the string {{c|&quot;lower&quot;}} and {{c|1=icase == true}}. This call returns the same bitmask as the call generated by the regex {{tt|[:alpha:]}} with {{c|1=icase == false}}.

The following character classes are always recognized, in both narrow and wide character forms, and the classifications returned (with {{c|1=icase == false}}) correspond to the matching classifications obtained by the {{lc|std::ctype}} facet of the imbued locale, as follows:

{{dsc begin}}
{{dsc hitem | character class | {{lc|std::ctype}} classification }}
{{dsc | {{c|&quot;alnum&quot;}} | {{lc|std::ctype_base::alnum}} }}
{{dsc | {{c|&quot;alpha&quot;}} | {{lc|std::ctype_base::alpha}} }}
{{dsc | {{c|&quot;blank&quot;}} | {{lc|std::ctype_base::blank}} }}
{{dsc | {{c|&quot;cntrl&quot;}} | {{lc|std::ctype_base::cntrl}} }}
{{dsc | {{c|&quot;digit&quot;}} | {{lc|std::ctype_base::digit}} }}
{{dsc | {{c|&quot;graph&quot;}} | {{lc|std::ctype_base::graph}} }}
{{dsc | {{c|&quot;lower&quot;}} | {{lc|std::ctype_base::lower}} }}
{{dsc | {{c|&quot;print&quot;}} | {{lc|std::ctype_base::print}} }}
{{dsc | {{c|&quot;punct&quot;}} | {{lc|std::ctype_base::punct}} }}
{{dsc | {{c|&quot;space&quot;}} | {{lc|std::ctype_base::space}} }}
{{dsc | {{c|&quot;upper&quot;}} | {{lc|std::ctype_base::upper}} }}
{{dsc | {{c|&quot;xdigit&quot;}} | {{lc|std::ctype_base::xdigit}} }}
{{dsc | {{c|&quot;d&quot;}} | {{lc|std::ctype_base::digit}} }}
{{dsc | {{c|&quot;s&quot;}} | {{lc|std::ctype_base::space}} }}
{{dsc | {{c|&quot;w&quot;}} | {{lc|std::ctype_base::alnum}} with '_' optionally added }}
{{dsc end}}

The classification returned for the string {{c|&quot;w&quot;}} may be exactly the same as {{c|&quot;alnum&quot;}}, in which case {{lc|isctype()}} adds '_' explicitly.

Additional classifications such as {{lc|&quot;jdigit&quot;}} or {{lc|&quot;jkanji&quot;}} may be provided by system-supplied locales (in which case they are also accessible through {{lc|std::wctype}})

===Parameters===
{{par begin}}
{{par | first, last | a pair of iterators which determines the sequence of characters that represents a name of a character class}}
{{par | icase | if true, ignores the upper/lower case distinction in the character classification}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
The bitmask representing the character classification determined by the given character class, or {{tt|char_class_type()}} if the class is unknown.

===Example===
{{cpp/regex/isctype_example}}

===See also===
{{dsc begin}}
{{dsc mem fun | cpp/regex/regex_traits/isctype |indicates membership in a character class }}
{{dsc inc | cpp/string/wide/dsc wctype}}
{{dsc end}}

[[de:cpp/regex/regex traits/lookup classname]]
[[es:cpp/regex/regex traits/lookup classname]]
[[fr:cpp/regex/regex traits/lookup classname]]
[[it:cpp/regex/regex traits/lookup classname]]
[[ja:cpp/regex/regex traits/lookup classname]]
[[pt:cpp/regex/regex traits/lookup classname]]
[[ru:cpp/regex/regex traits/lookup classname]]
[[zh:cpp/regex/regex traits/lookup classname]]</text>
      <sha1>q3y82k5um7qh5hmjftj2ghivnoda4po</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/lookup collatename</title>
    <ns>0</ns>
    <id>8943</id>
    <revision>
      <id>51149</id>
      <parentid>41762</parentid>
      <timestamp>2013-06-01T03:52:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2422">{{cpp/regex/regex_traits/title|lookup_collatename}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class ForwardIt &gt;
string_type lookup_collatename( ForwardIt first, ForwardIt last ) const;
}}
{{dcl end}}

If the character sequence {{tt|[first, last)}} represents the name of a valid collating element in the currently imbued locale, returns the name of that collating element. Otherwise, returns an empty string.

Collating elements are the symbols found in POSIX regular expressions between {{tt|[.}} and {{tt|.]}}. For example, {{tt|[.a.]}} matches the character {{tt|a}} in the C locale. {{tt|[.tilde.]}} matches the character {{tt|~}} in the C locale as well. {{tt|[.ch.]}} matches the digraph {{tt|ch}} in Czech locale, but generates {{lc|std::regex_error}} with error code {{lc|std::regex_constants::error_collate}} in most other locales.

===Parameters===
{{par begin}}
{{par | first, last | a pair of iterators which determines the sequence of characters that represents a collating element name}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
The representation of the named collating element as a character string.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

struct noisy_traits : std::regex_traits&lt;char&gt; {

    template&lt; class Iter &gt;
    string_type lookup_collatename( Iter first, Iter last ) const {
        string_type result = regex_traits::lookup_collatename(first, last);
        std::cout &lt;&lt; &quot;regex_traits&lt;&gt;::lookup_collatename(\&quot;&quot;
                  &lt;&lt; string_type(first, last)
                  &lt;&lt; &quot;\&quot;) returns \&quot;&quot; &lt;&lt; result &lt;&lt; &quot;\&quot;\n&quot;;
        return result;
    }
};

int main()
{
    std::string str = &quot;z{{!}}}a&quot;; // C locale collation order: x,y,z,{,{{!}},},~
    std::basic_regex&lt;char, noisy_traits&gt; re(&quot;[x-[.tilde.]]*a&quot;, std::regex::basic);
    std::cout &lt;&lt; std::boolalpha &lt;&lt; std::regex_match(str, re) &lt;&lt; '\n';
}
 | output=
regex_traits&lt;&gt;::lookup_collatename(&quot;tilde&quot;) returns &quot;~&quot;
true
}}

[[de:cpp/regex/regex traits/lookup collatename]]
[[es:cpp/regex/regex traits/lookup collatename]]
[[fr:cpp/regex/regex traits/lookup collatename]]
[[it:cpp/regex/regex traits/lookup collatename]]
[[ja:cpp/regex/regex traits/lookup collatename]]
[[pt:cpp/regex/regex traits/lookup collatename]]
[[ru:cpp/regex/regex traits/lookup collatename]]
[[zh:cpp/regex/regex traits/lookup collatename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/regex traits</title>
    <ns>0</ns>
    <id>8859</id>
    <revision>
      <id>51150</id>
      <parentid>41760</parentid>
      <timestamp>2013-06-01T03:52:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1022">{{cpp/regex/regex_traits/title|regex_traits}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
regex_traits();
}}
{{dcl end}}

Default-constructs the {{lc|std::regex_traits}} object, including default-constructing the private {{lc|std::locale}} member or any other internal state as necessary.

===Parameters===
(none)

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

int main()
{
    std::locale::global(std::locale(&quot;en_US.utf8&quot;));
    std::regex_traits&lt;char&gt; r1;
    std::regex_traits&lt;wchar_t&gt; r2;
    std::cout &lt;&lt; &quot;The regex locale is &quot; &lt;&lt; r1.getloc().name() &lt;&lt; '\n';
}
 | output=
The regex locale is en_US.utf8
}}

[[de:cpp/regex/regex traits/regex traits]]
[[es:cpp/regex/regex traits/regex traits]]
[[fr:cpp/regex/regex traits/regex traits]]
[[it:cpp/regex/regex traits/regex traits]]
[[ja:cpp/regex/regex traits/regex traits]]
[[pt:cpp/regex/regex traits/regex traits]]
[[ru:cpp/regex/regex traits/regex traits]]
[[zh:cpp/regex/regex traits/regex traits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/transform</title>
    <ns>0</ns>
    <id>8861</id>
    <revision>
      <id>51151</id>
      <parentid>41758</parentid>
      <timestamp>2013-06-01T03:52:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1878">{{cpp/regex/regex_traits/title|transform}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class ForwardIt &gt;
string_type transform( ForwardIt first, ForwardIt last) const
}}
{{dcl end}}

Obtains the sort key for the character sequence {{tt|[first, last)}}, such that if a sort key compares less than another sort key with {{c|operator&lt;}}, then the character sequence that produced the first sort key comes before the character sequence that produced the second sort key, in the currently imbued locale's collation order.

For example when the regex flag {{lc|std::regex_constants::collate}} is set, then the sequence {{tt|[a-b]}} would match some character {{tt|c1}} if {{c|1=traits.transform(&quot;a&quot;) &lt;= traits.transform(c1) &lt;= traits.transform(&quot;b&quot;)}}. Note that this function takes a character sequence as the argument to accomodate to the ranges defined like {{c|[}}{{c|[.ae.]-d]}}.

Standard library specializations of {{lc|std::regex_traits}} return {{c|std::use_facet&lt;std::collate&lt;CharT&gt;&gt;(getloc()).transform(&amp;*str.begin(), &amp;*str.begin() + str.length())}} for some temporary string {{tt|str}} constructed as {{c|string_type str(first, last)}}.

===Parameters===
{{par begin}}
{{par | first, last | a pair of {{concept|ForwardIterator}}s which determines the sequence of characters to compare}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
The collation key for the character sequence {{tt|[first, last)}} in the currently imbued locale.

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/regex traits/transform]]
[[es:cpp/regex/regex traits/transform]]
[[fr:cpp/regex/regex traits/transform]]
[[it:cpp/regex/regex traits/transform]]
[[ja:cpp/regex/regex traits/transform]]
[[pt:cpp/regex/regex traits/transform]]
[[ru:cpp/regex/regex traits/transform]]
[[zh:cpp/regex/regex traits/transform]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/transform primary</title>
    <ns>0</ns>
    <id>8862</id>
    <revision>
      <id>62068</id>
      <parentid>62067</parentid>
      <timestamp>2013-06-20T17:13:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>misplaced parenthesis</comment>
      <text xml:space="preserve" bytes="3399">{{cpp/regex/regex_traits/title|transform_primary}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class ForwardIt &gt;
string_type transform_primary( ForwardIt first, ForwardIt last ) const
}}
{{dcl end}}

For the character sequence {{tt|[first, last)}}, obtains the primary sort key in the imbued locale's collating order, that is, the sort key that is based on the positions of the letters and collation units in the national alphabet, ignoring case, diacritics, variants, etc. If a primary sort key compares less than another primary sort key with {{c|operator&lt;}}, then the character sequence that produced the first sort key comes before the character sequence that produced the second sort key, in the currently imbued locale's primary collation order.

The regex library uses this trait to match characters against equivalence classes. For example, the regex {{c|1=[[=a=]]}} is equivalent to the character {{tt|c1}} if {{c|traits.transform_primary(c1)}} is equivalent to {{c|traits.transform_primary(&quot;a&quot;)}} (which is true for any {{tt|c1}} from {{c|&quot;AÀÁÂÃÄÅaàáâãäå&quot;}} in the U.S. English locale). Note that {{tt|transform_primary()}} takes a character sequence argument because equivalence classes may be multicharacter, such as {{c|1=[[=ch=]]}} in Czech or {{c|1=[[=dzs=]]}} in Hungarian.
 
There is no portable way to define primary sort key in terms of {{lc|std::locale}} since the conversion from the collation key returned by {{c|std::collate::transform()}} to the primary equivalence key is locale-specific, and if the user replaces the {{lc|std::collate}} facet, that conversion is no longer known to the standard library's {{lc|std::regex_traits}}. Standard library specializations of {{lc|std::regex_traits}} return an empty string unless the {{lc|std::collate}} facet of the currently-imbued locale was not replaced by the user, and still matches the system-supplied {{lc|std::collate}} facet), in which case {{c|std::collate_byname&lt;charT&gt;::transform(first, last)}} is executed and the sort key it produces is converted to the expected primary sort key using a locale-specific conversion.

===Parameters===
{{par begin}}
{{par | first, last | a pair of iterators which determines the sequence of characters to compare}}
{{par hreq}}
{{par req concept | ForwardIt | ForwardIterator}}
{{par end}}

===Return value===
The primary sort key for the character sequence {{tt|[first, last)}} in the currently imbued locale, ignoring case, variant, diacritics, etc. 

===Example===
{{example
 | Demonstrates the regex feature that works through transform_primary()
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;

int main()
{
    std::locale::global(std::locale(&quot;en_US.UTF-8&quot;));
    std::wstring str = L&quot;AÀÁÂÃÄÅaàáâãäå&quot;;
    std::wregex re(L&quot;[[=a=]]*&quot;, std::regex::basic);
    std::cout &lt;&lt; std::boolalpha &lt;&lt; std::regex_match(str, re) &lt;&lt; '\n';
}
 | output=
true
}}
{{todo|could use an example with user-defined regex_traits supplying user-defined transform_primary}}

[[de:cpp/regex/regex traits/transform primary]]
[[es:cpp/regex/regex traits/transform primary]]
[[fr:cpp/regex/regex traits/transform primary]]
[[it:cpp/regex/regex traits/transform primary]]
[[ja:cpp/regex/regex traits/transform primary]]
[[pt:cpp/regex/regex traits/transform primary]]
[[ru:cpp/regex/regex traits/transform primary]]
[[zh:cpp/regex/regex traits/transform primary]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/translate</title>
    <ns>0</ns>
    <id>8858</id>
    <revision>
      <id>51153</id>
      <parentid>41752</parentid>
      <timestamp>2013-06-01T03:52:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1191">{{cpp/regex/regex_traits/title|translate}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
CharT translate(CharT c) const;
}}
{{dcl end}}

Obtains the comparison key for the character {{tt|c}}, such that all characters that are equivalent to this character in the imbued locale produce the same key.

When the regex library needs to match two characters {{tt|c1}} and {{tt|c2}} and the flag  {{lc|std::regex_constants::collate}} is {{c|true}}, it executes {{c|1=regex_traits&lt;&gt;::translate(c1) == regex_traits&lt;&gt;::translate(c2)}}.

Standard library specializations of {{lc|std::regex_traits}} return {{tt|c}} unmodified.

===Parameters===
{{par begin}}
{{par | c | character that needs to be examined for equivalence}}
{{par end}}

===Return value===
The comparison key for {{tt|c}} in the currently imbued locale.

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/regex traits/translate]]
[[es:cpp/regex/regex traits/translate]]
[[fr:cpp/regex/regex traits/translate]]
[[it:cpp/regex/regex traits/translate]]
[[ja:cpp/regex/regex traits/translate]]
[[pt:cpp/regex/regex traits/translate]]
[[ru:cpp/regex/regex traits/translate]]
[[zh:cpp/regex/regex traits/translate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/translate nocase</title>
    <ns>0</ns>
    <id>8860</id>
    <revision>
      <id>51154</id>
      <parentid>41750</parentid>
      <timestamp>2013-06-01T03:52:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1461">{{cpp/regex/regex_traits/title|translate_nocase}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | 1=
CharT translate_nocase(CharT c) const;
}}
{{dcl end}}

Obtains the comparison key for the character {{tt|c}}, such that all characters that are equivalent to this character in the imbued locale, ignoring the case differences, if any, produce the same key.

When the regex library needs to match two characters {{tt|c1}} and {{tt|c2}} and the flag  {{lc|std::regex_constants::icase}} is {{c|true}}, it executes {{c|1=regex_traits&lt;&gt;::translate_nocase(c1) == regex_traits&lt;&gt;::translate_nocase(c2)}}.

Standard library specializations of {{lc|std::regex_traits}} return {{c|std::use_facet&lt;std::ctype&lt;CharT&gt;&gt;(getloc()).tolower(c)}}, that is, convert {{tt|c}} to lowercase, using the currently imbued locale.

===Parameters===
{{par begin}}
{{par | c | character that needs to be examined for equivalence, ignoring case}}
{{par end}}

===Return value===
The case-insensitive comparison key for {{tt|c}} in the currently imbued locale.

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/regex/regex traits/translate nocase]]
[[es:cpp/regex/regex traits/translate nocase]]
[[fr:cpp/regex/regex traits/translate nocase]]
[[it:cpp/regex/regex traits/translate nocase]]
[[ja:cpp/regex/regex traits/translate nocase]]
[[pt:cpp/regex/regex traits/translate nocase]]
[[ru:cpp/regex/regex traits/translate nocase]]
[[zh:cpp/regex/regex traits/translate nocase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/regex traits/value</title>
    <ns>0</ns>
    <id>8946</id>
    <revision>
      <id>67016</id>
      <parentid>67015</parentid>
      <timestamp>2014-01-17T00:27:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix copypasted comment</comment>
      <text xml:space="preserve" bytes="2600">{{cpp/regex/regex_traits/title|value}}
{{cpp/regex/regex_traits/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
int value( CharT ch, int radix ) const;
}}
{{dcl end}}

Determines the value represented by the digit {{tt|ch}} in the numeric base {{tt|radix}}, given the currently imbued locale. This function is called by {{lc|std::regex}} when processing [[cpp/regex/ecmascript#Quantifiers|Quantifiers]] such as {{tt|{1}}} or {{tt|{2,5}}}, [[cpp/regex/ecmascript#Backreferences|Backreferences]] such as {{tt|\1}}, and hexadecimal and Unicode character escapes.

===Parameters===
{{par begin}}
{{par | ch | the character that may represent a digit}}
{{par | radix | either 8, 10, or 16 }}
{{par end}}

===Return value===
The numeric value if {{tt|ch}} indeed represents a digit in the currently imbued locale that is valid for the numeric base {{tt|radix}}, or {{c|-1}} on error.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;regex&gt;
#include &lt;map&gt;

// This custom regex traits allows japanese numerals
struct jnum_traits : std::regex_traits&lt;wchar_t&gt;
{   
    static std::map&lt;wchar_t, int&gt; data;
    int value(wchar_t ch, int radix ) const {
        wchar_t up = std::toupper(ch, getloc());
        return data.count(up) ? data[up] : regex_traits::value(ch, radix);
    }
};
std::map&lt;wchar_t, int&gt; jnum_traits::data = {{L'〇',0}, {L'一',1}, {L'二',2},
                                            {L'三',3}, {L'四',4}, {L'五',5},
                                            {L'六',6}, {L'七',7}, {L'八',8},
                                            {L'九',9}, {L'Ａ',10}, {L'Ｂ',11},
                                            {L'Ｃ',12}, {L'Ｄ',13}, {L'Ｅ',14},
                                            {L'Ｆ',15}};
int main()
{   
    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    std::wcout.sync_with_stdio(false);
    std::wcout.imbue(std::locale());

    std::wstring in = L&quot;風&quot;;

    if(std::regex_match(in, std::wregex(L&quot;\\u98a8&quot;)))
        std::wcout &lt;&lt; &quot;\\u98a8 matched &quot; &lt;&lt; in &lt;&lt; '\n';

    if(std::regex_match(in, std::basic_regex&lt;wchar_t, jnum_traits&gt;(L&quot;\\u九八ａ八&quot;)))
        std::wcout &lt;&lt; L&quot;\\u九八ａ八 with custom traits matched &quot; &lt;&lt; in &lt;&lt; '\n';
}
 | output=
\u98a8 matched 風
\u九八ａ八 with custom traits matched 風
}}

[[de:cpp/regex/regex traits/value]]
[[es:cpp/regex/regex traits/value]]
[[fr:cpp/regex/regex traits/value]]
[[it:cpp/regex/regex traits/value]]
[[ja:cpp/regex/regex traits/value]]
[[pt:cpp/regex/regex traits/value]]
[[ru:cpp/regex/regex traits/value]]
[[zh:cpp/regex/regex traits/value]]</text>
      <sha1>d6dqatb7js2plv9rkljdoma4e30j4yg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match</title>
    <ns>0</ns>
    <id>2280</id>
    <revision>
      <id>63425</id>
      <parentid>61427</parentid>
      <timestamp>2013-07-10T01:31:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3071">{{cpp/title|sub_match}}
{{cpp/regex/sub_match/navbar}}
{{ddcl | header=regex | since=c++11 | 1=
template&lt;
    class BidirIt
&gt; class sub_match;
}}

The class template {{tt|sub_match}} is used by the regular expression engine to denote sequences of characters matched by marked sub-expressions.
A match is a {{tt|[begin, end)}} pair within the target range matched by the regular expression, but with additional observer functions to enhance code clarity.

Only the default constructor is publicly accessible.  Instances of {{tt|sub_match}} are normally constructed and populated as a part of a {{lc|std::match_results}} container during the processing of one of the regex algorithms.

The member functions return defined default values unless the {{c|matched}} member is {{tt|true}}.

{{tt|sub_match}} inherits from {{c|std::pair&lt;BidirIt, BidirIt&gt;}}, although it cannot be treated as a {{lc|std::pair}} object because member functions such as swap and assignment will not work as expected.

===Type requirements===
{{par begin}}
{{par req concept | BidirIt | BidirectionalIterator}}
{{par end}}

===Specializations===
Several specializations for common character sequence types are provided: 

{{dsc begin}}
{{dsc header | regex}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|csub_match}} | {{c|sub_match&lt;const char*&gt;}}}}
{{dsc | {{tt|wcsub_match}} | {{c|sub_match&lt;const wchar_t*&gt;}}}}
{{dsc | {{tt|ssub_match}} | {{c|sub_match&lt;std::string::const_iterator&gt;}}}}
{{dsc | {{tt|wssub_match}} | {{c|sub_match&lt;std::wstring::const_iterator&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|iterator}} | {{c|BidirIt}}}}
{{dsc | {{tt|value_type}} | {{c|std::iterator_traits&lt;BidirIt&gt;::value_type}}}}
{{dsc | {{tt|difference_type}} | {{c|std::iterator_traits&lt;BidirIt&gt;::difference_type}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;value_type&gt;}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc| {{tt|matched}} | Indicates if this match was successful.}}
{{dsc end}}
{{inherited | [[cpp/utility/pair | {{small|std::}}pair]] |
{{dsc begin}}
{{dsc| {{tt|first}} | Start of the match sequence.}}
{{dsc| {{tt|second}} | One-past-the-end of the match sequence.}}
{{dsc end}}
}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/sub_match/dsc constructor}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/regex/sub_match/dsc length}}
{{dsc inc | cpp/regex/sub_match/dsc str}}
{{dsc inc | cpp/regex/sub_match/dsc compare}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/regex/sub_match/dsc operator_cmp}}
{{dsc tfun | cpp/regex/sub_match/operator_ltlt | title=operator&lt;&lt; | outputs the matched character subsequence}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/regex/regex_token_iterator | iterates through regex submatches | notes={{mark c++11}}}}
{{dsc end}}

[[de:cpp/regex/sub match]]
[[es:cpp/regex/sub match]]
[[fr:cpp/regex/sub match]]
[[it:cpp/regex/sub match]]
[[ja:cpp/regex/sub match]]
[[pt:cpp/regex/sub match]]
[[ru:cpp/regex/sub match]]
[[zh:cpp/regex/sub match]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/compare</title>
    <ns>0</ns>
    <id>3132</id>
    <revision>
      <id>61475</id>
      <parentid>61473</parentid>
      <timestamp>2013-06-06T01:37:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>since=c++11</comment>
      <text xml:space="preserve" bytes="1818">{{cpp/regex/sub_match/title | compare}}
{{cpp/regex/sub_match/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
int compare( const sub_match&amp; m ) const;
}}
{{dcl | num=2 | since=c++11 |
int compare( const string_type&amp; s ) const;
}}
{{dcl | num=3 | since=c++11 |
int compare( const value_type* c ) const;
}}
{{dcl end}}

@1@ Compares two {{c|sub_match}} directly by comparing their underlying character sequences. Equivalent to {{c|str().compare(m.str())}}

@2@ Compares a {{c|sub_match}} with a {{lc|std::basic_string}}.  This function is implemented as follows. Equivalent to {{c|str().compare(s)}}

@3@ Compares a {{c|sub_match}} with a null-terminated sequence of the underlying character type pointed to by {{tt|s}}. Equivalent to {{c|str().compare(c)}}

This function is infrequently used directly by application code.  Instead, one of the non-member comparison operators are used.

===Parameters===
{{par begin}}
{{par | m | a pointer to another sub_match}}
{{par | s | a pointer to a string to compare to}}
{{par | c | a pointer to a null-terminated character sequence of the underlying {{c|value_type}} to compare to}}
{{par end}}

===Return value===
A value less than zero if this sub_match is ''less'' than the other character sequence, zero if the both underlyinging character sequences are equal, greater than zero if this sub_match is ''greater'' than the other character sequence.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc compare}}
{{dsc end}}

[[de:cpp/regex/sub match/compare]]
[[es:cpp/regex/sub match/compare]]
[[fr:cpp/regex/sub match/compare]]
[[it:cpp/regex/sub match/compare]]
[[ja:cpp/regex/sub match/compare]]
[[pt:cpp/regex/sub match/compare]]
[[ru:cpp/regex/sub match/compare]]
[[zh:cpp/regex/sub match/compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/length</title>
    <ns>0</ns>
    <id>3130</id>
    <revision>
      <id>41739</id>
      <parentid>34594</parentid>
      <timestamp>2012-11-02T19:21:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, pt, ru, zh</comment>
      <text xml:space="preserve" bytes="583">{{cpp/regex/sub_match/title | length}}
{{cpp/regex/sub_match/navbar}}
{{ddcl |
difference_type length() const;
}}

===Parameters===
(none)

===Return value===

Returns the number of characters in the match, i.e. {{c|std::distance(first, second)}} if the match is valid, 0 otherwise.

===Complexity===

Constant

[[de:cpp/regex/sub match/length]]
[[es:cpp/regex/sub match/length]]
[[fr:cpp/regex/sub match/length]]
[[it:cpp/regex/sub match/length]]
[[ja:cpp/regex/sub match/length]]
[[pt:cpp/regex/sub match/length]]
[[ru:cpp/regex/sub match/length]]
[[zh:cpp/regex/sub match/length]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/operator cmp</title>
    <ns>0</ns>
    <id>12681</id>
    <revision>
      <id>61476</id>
      <timestamp>2013-06-06T02:09:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+ 42 similar overloads, need some way to hide most of them</comment>
      <text xml:space="preserve" bytes="11698">{{cpp/regex/sub_match/title | compare}}
{{cpp/regex/sub_match/navbar}}
{{dcl begin}}
{{dcl header | regex}}
{{dcl h | Direct comparison}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator==( const sub_match&lt;BiIter&gt;&amp; lhs, 
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator!=( const sub_match&lt;BiIter&gt;&amp; lhs, 
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator&lt;( const sub_match&lt;BiIter&gt;&amp; lhs, 
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator&lt;=( const sub_match&lt;BiIter&gt;&amp; lhs, 
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator&gt;( const sub_match&lt;BiIter&gt;&amp; lhs, 
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class BidirIt &gt;
bool operator&gt;=( const sub_match&lt;BiIter&gt;&amp; lhs, 
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}

{{dcl h | {{tt|std::basic_string}} and {{tt|std::sub_match}} }}
{{dcl | num=7 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; lhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=8 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; lhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=9 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const std::basic_string&lt;
                    typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                    Traits,Alloc&gt;&amp; lhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=10 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const std::basic_string&lt;
                    typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                    Traits,Alloc&gt;&amp; lhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=11 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const std::basic_string&lt;
                    typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                    Traits,Alloc&gt;&amp; lhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=12 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; lhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}

{{dcl h | {{tt|std::sub_match}} and {{tt|std::basic_string}} }}
{{dcl | num=13 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=14 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=15 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const std::basic_string&lt;
                    typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                    Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=16 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=17 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const std::basic_string&lt;
                    typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                    Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=18 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const std::basic_string&lt;
                     typename std::iterator_traits&lt;BidirIt&gt;::value_type,
                     Traits,Alloc&gt;&amp; rhs );
}}

{{dcl h | {{tt|std::iterator_traits&lt;BiIter&gt;::value_type*}} and {{tt|std::sub_match}} }}
{{dcl | num=19 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=20 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=21 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=22 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=23 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=24 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}

{{dcl h | {{tt|std::sub_match}} and {{tt|std::iterator_traits&lt;BiIter&gt;::value_type*}} }}
{{dcl | num=25 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}
{{dcl | num=26 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}
{{dcl | num=27 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}
{{dcl | num=28 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}
{{dcl | num=29 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}
{{dcl | num=30 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type* rhs );
}}

{{dcl h | {{tt|std::iterator_traits&lt;BiIter&gt;::value_type&amp;}} and {{tt|std::sub_match}} }}
{{dcl | num=31 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=32 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=33 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=34 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=35 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                const sub_match&lt;BidirIt&gt;&amp; rhs );
}}
{{dcl | num=36 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs,
                 const sub_match&lt;BidirIt&gt;&amp; rhs );
}}

{{dcl h | {{tt|std::sub_match}} and {{tt|std::iterator_traits&lt;BiIter&gt;::value_type&amp;}} }}
{{dcl | num=37 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator==( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}
{{dcl | num=38 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator!=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}
{{dcl | num=39 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}
{{dcl | num=40 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&lt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}
{{dcl | num=41 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;( const sub_match&lt;BidirIt&gt;&amp; lhs,
                const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}
{{dcl | num=42 | since=c++11 | 1=
template&lt; class BidirIt, class Traits, class Alloc &gt;
bool operator&gt;=( const sub_match&lt;BidirIt&gt;&amp; lhs,
                 const typename std::iterator_traits&lt;BiIter&gt;::value_type&amp; rhs );
}}

{{dcl end}}

Compares a {{tt|sub_match}} to another {{tt|sub_match}}, a string, a null-terminated character sequence or a character.

@1-6@ Compares two {{c|sub_match}} directly by comparing their underlying character sequences. Implemented using {{c|lhs.str().compare(rhs.str())}}

@7-18@ Compares a {{c|sub_match}} with a {{lc|std::basic_string}}. Implemented using  {{c|sm.str().compare(st)}}, where {{tt|sm}} is a {{tt|sub_match}} and {{tt|st}} is a {{tt|basic_string}}.

@19-30@ Compares a {{c|sub_match}} with a null-terminated string. Implemented using {{c|sm.str().compare(s)}}, where {{tt|sm}} is a {{tt|sub_match}} and {{tt|s}} is a pointer to a null-terminated character string.

@31-42@ Compares a {{c|sub_match}} with a character. Implemented using the following:

{{cc|sm.str().compare(typename sub_match&lt;BidirIt&gt;::string_type(1, ch))}}, where {{tt|sm}} is a {{tt|sub_match}} and {{tt|ch}} is a character.

===Parameters===
{{par begin}}
{{par | lhs, rhs | a {{tt|sub_match}}, {{tt|basic_string}}, pointer to a null-terminated string or a character to compare}}
{{par end}}

===Return value===
{{c|true}} if the corresponding comparison holds as defined by {{lc|compare()}}, {{c|false}} otherwise.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/sub_match/dsc compare}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/operator ltlt</title>
    <ns>0</ns>
    <id>12680</id>
    <revision>
      <id>71240</id>
      <parentid>61474</parentid>
      <timestamp>2014-06-08T22:50:44Z</timestamp>
      <contributor>
        <username>Roysc</username>
        <id>2387</id>
      </contributor>
      <minor/>
      <comment>title</comment>
      <text xml:space="preserve" bytes="677">{{title | operator&lt;&lt;{{small|(std::sub_match)}} }}
{{cpp/regex/sub_match/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class CharT, class Traits, class BidirIt &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp;
    operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; os, 
                const sub_match&lt;BidirIt&gt;&amp; m );
}}
{{dcl end}}

Writes the representation of the matched subsequence {{tt|m}} to the output stream {{tt|os}}.

Equivalent to {{c|os &lt;&lt; m.str()}}.

===Parameters===
{{par begin}}
{{par | os | output stream to write the representation to}}
{{par | m | a sub-match object to output}}
{{par end}}

===Return value===
{{tt|os}}.

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1>m5r3x2gee215wzgc391dw84hdygygmg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/str</title>
    <ns>0</ns>
    <id>3133</id>
    <revision>
      <id>69166</id>
      <parentid>62375</parentid>
      <timestamp>2014-03-28T18:12:42Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1133">{{cpp/regex/sub_match/title | operator string_type | str}}
{{cpp/regex/sub_match/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
operator string_type() const;
}}
{{dcl | num=2 | 1=
string_type str() const;
}}
{{dcl end}}

Converts to an object of the underlying {{lc|std::basic_string}} type.

The first version is an implicit conversion, the second one is explicit.

===Parameters===
(none)

===Return value===
Returns the matched character sequence as an object of the underlying {{lc|std::basic_string}} type.  If the {{tt|matched}} member is ''false'' then the empty string is returned.

===Complexity===
Linear in the length of the underlying character sequence.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;regex&gt;
#include &lt;string&gt;
int main()
{
  std::ssub_match sm;
  std::string s = sm;  // implicit conversion
  std::cout &lt;&lt; s.length() &lt;&lt; '\n';
}
 | output=
0
}}

[[de:cpp/regex/sub match/str]]
[[es:cpp/regex/sub match/str]]
[[fr:cpp/regex/sub match/str]]
[[it:cpp/regex/sub match/str]]
[[ja:cpp/regex/sub match/str]]
[[pt:cpp/regex/sub match/str]]
[[ru:cpp/regex/sub match/str]]
[[zh:cpp/regex/sub match/str]]</text>
      <sha1>aahbatug92bb95hjmvmk55zkw4dsk0u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/sub match/sub match</title>
    <ns>0</ns>
    <id>3134</id>
    <revision>
      <id>51159</id>
      <parentid>47504</parentid>
      <timestamp>2013-06-01T03:53:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="653">{{cpp/regex/sub_match/title | sub_match}}
{{cpp/regex/sub_match/navbar}}
{{dcl begin}}
{{dcl| constexpr sub_match();}}
{{dcl end}}

Default constructs a {{lc|std::sub_match}}.  The {{c|1=matched}} member is set to ''false'' and the value of other members is undefined.

This is the only publicly accessible and defined constructor.

===Parameters===
(none)

[[de:cpp/regex/sub match/sub match]]
[[es:cpp/regex/sub match/sub match]]
[[fr:cpp/regex/sub match/sub match]]
[[it:cpp/regex/sub match/sub match]]
[[ja:cpp/regex/sub match/sub match]]
[[pt:cpp/regex/sub match/sub match]]
[[ru:cpp/regex/sub match/sub match]]
[[zh:cpp/regex/sub match/sub match]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/regex/syntax option type</title>
    <ns>0</ns>
    <id>2320</id>
    <revision>
      <id>64138</id>
      <parentid>58875</parentid>
      <timestamp>2013-08-15T03:42:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="3014">{{cpp/title|n=regex_constants::|syntax_option_type}}
{{cpp/regex/navbar}}

{{dcl begin}}
{{dcl header | regex}}
{{dcl | 1=
typedef /*unspecified*/ syntax_option_type;
constexpr syntax_option_type icase = /*unspecified*/;
constexpr syntax_option_type nosubs = /*unspecified*/;
constexpr syntax_option_type optimize = /*unspecified*/;
constexpr syntax_option_type collate = /*unspecified*/;
constexpr syntax_option_type ECMAScript = /*unspecified*/;
constexpr syntax_option_type basic = /*unspecified*/;
constexpr syntax_option_type extended = /*unspecified*/;
constexpr syntax_option_type awk = /*unspecified*/;
constexpr syntax_option_type grep = /*unspecified*/;
constexpr syntax_option_type egrep = /*unspecified*/;
}}
{{dcl end}}

The {{tt|syntax_option_type}} is a {{concept|BitmaskType}} that contains options that govern how regular expressions behave.

The possible values for this type ({{tt|icase}}, {{tt|optimize}}, etc.) are duplicated inside [[cpp/regex/basic_regex/constants|std::basic_regex]].

===Constants===

{{cpp/regex/syntax option type consts}}

===Notes===
Because POSIX uses &quot;leftmost longest&quot; matching rule (the longest matching subsequence is matched, and if there are several such subsequences, the first one is matched), it is not suitable, for example, for parsing markup languages: a POSIX regex such as {{c|&quot;&lt;tag[^&gt;]*&gt;.*&lt;/tag&gt;&quot;}} would match everything from the first {{c|&quot;&lt;tag&quot;}} to the last {{c|&quot;&lt;/tag&gt;&quot;}}, including every {{c|&quot;&lt;/tag&gt;&quot;}} and {{c|&quot;&lt;tag&gt;&quot;}} inbetween. On the other hand, ECMAScript supports non-greedy matches, and the ECMAScript regex {{c|&quot;&lt;tag[^&gt;]*&gt;.*?&lt;/tag&gt;&quot;}} would match only until the first closing tag.

In C++11, these constants were specified with redundant keyword {{tt|static}}, which was removed by C++14 via [http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2053 LWG issue 2053]

===Example===
{{example
 | Illustrates the difference in the matching algorithm between ECMAScript and POSIX regular expressions
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;regex&gt;

int main()
{
    std::string str = &quot;zzxayyzz&quot;;
    std::regex re1(&quot;.*(a{{!}}xayy)&quot;); // ECMA
    std::regex re2(&quot;.*(a{{!}}xayy)&quot;, std::regex::extended); // POSIX

    std::cout &lt;&lt; &quot;Searching for .*(a{{!}}xayy) in zzxayyzz:\n&quot;;
    std::smatch m;
    std::regex_search(str, m, re1);
    std::cout &lt;&lt; &quot; ECMA (depth first search) match: &quot; &lt;&lt; m[0] &lt;&lt; '\n';
    std::regex_search(str, m, re2);
    std::cout &lt;&lt; &quot; POSIX (leftmost longest)  match: &quot; &lt;&lt; m[0] &lt;&lt; '\n';
}
 | output=
Searching for .*(a{{!}}xayy) in zzxayyzz:
 ECMA (depth first search) match: zzxa
 POSIX (leftmost longest)  match: zzxayy
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/regex/dsc basic_regex}}
{{dsc end}}

[[de:cpp/regex/syntax option type]]
[[es:cpp/regex/syntax option type]]
[[fr:cpp/regex/syntax option type]]
[[it:cpp/regex/syntax option type]]
[[ja:cpp/regex/syntax option type]]
[[pt:cpp/regex/syntax option type]]
[[ru:cpp/regex/syntax option type]]
[[zh:cpp/regex/syntax option type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/resources</title>
    <ns>0</ns>
    <id>6601</id>
    <redirect title="cpp/links" />
    <revision>
      <id>25912</id>
      <timestamp>2012-04-28T19:36:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/resources]] to [[cpp/links]]: reflects the content better</comment>
      <text xml:space="preserve" bytes="23">#REDIRECT [[cpp/links]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string</title>
    <ns>0</ns>
    <id>1388</id>
    <revision>
      <id>70998</id>
      <parentid>70990</parentid>
      <timestamp>2014-06-04T18:41:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="2271">{{title|Strings library}}
{{cpp/string/navbar}}

The C++ strings library includes support for two general types of strings:

* {{lc|std::basic_string}} - a templated class designed to manipulate strings of any character type.
* Null-terminated strings - arrays of characters terminated by a special ''null'' character.

=== {{lc|std::basic_string}} ===

The templated class {{lc|std::basic_string}} generalizes how sequences of characters are manipulated and stored.  String creation, manipulation, and destruction are all handled by a convenient set of class methods and related functions.

Several specializations of {{lc|std::basic_string}} are provided for commonly-used types:

{{dsc begin}}
{{dsc header | string}}
{{dsc hitem | Type | Definition}}
{{dsc | {{lc|std::string}} | {{c|std::basic_string&lt;char&gt;}}}}
{{dsc | {{lc|std::wstring}} | {{c|std::basic_string&lt;wchar_t&gt;}}}}
{{dsc | {{lc|std::u16string}} | {{c|std::basic_string&lt;char16_t&gt;}} | notes={{mark since c++11}}}}
{{dsc | {{lc|std::u32string}} | {{c|std::basic_string&lt;char32_t&gt;}} | notes={{mark since c++11}}}}
{{dsc end}}

=== Null-terminated strings ===

Null-terminated strings are arrays of characters that are terminated by a special ''null'' character.  C++ provides functions to create, inspect, and modify null-terminated strings.

There are three types of null-terminated strings:

* {{rl | byte | null-terminated byte strings}}
* {{rl | multibyte | null-terminated multibyte strings}}
* {{rl | wide | null-terminated wide strings}}

=== Additional support ===

===={{lc|std::char_traits}}====

The string library also provides class template {{lc|std::char_traits}} that defines types and functions for {{lc|std::basic_string}}. The following specializations are defined:

{{dcl begin}}
{{dcl header | string}}
{{dcl | notes=&lt;br&gt;&lt;br&gt;{{mark since c++11}}&lt;br&gt;{{mark since c++11}} |
template&lt;&gt; class char_traits&lt;char&gt;;
template&lt;&gt; class char_traits&lt;wchar_t&gt;;
template&lt;&gt; class char_traits&lt;char16_t&gt;;
template&lt;&gt; class char_traits&lt;char32_t&gt;;
}}
{{dcl end}}

===See also===
{{dsc begin}}
{{dsc see c | c/string | Strings library}}
{{dsc end}}

[[ar:cpp/string]]
[[de:cpp/string]]
[[es:cpp/string]]
[[fr:cpp/string]]
[[it:cpp/string]]
[[ja:cpp/string]]
[[pt:cpp/string]]
[[ru:cpp/string]]
[[zh:cpp/string]]</text>
      <sha1>k317p31xsf5hqe6j01tr4docmtsfj2e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string</title>
    <ns>0</ns>
    <id>1389</id>
    <revision>
      <id>72362</id>
      <parentid>69821</parentid>
      <timestamp>2014-08-14T19:02:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention that it satisfies allocatorawarecontainer</comment>
      <text xml:space="preserve" bytes="6018">{{cpp/title|basic_string}}
{{cpp/string/basic_string/navbar}}
{{ddcl | header=string | 
template&lt; 
    class CharT, 
    class Traits {{=}} std::char_traits&lt;CharT&gt;, 
    class Allocator {{=}} std::allocator&lt;CharT&gt;
&gt; class basic_string;
}}

The class template {{tt|basic_string}} stores and manipulates sequences of {{c|char}}-like objects. The class is dependent neither on the character type nor on the nature of operations on that type. The definitions of the operations are supplied via the {{tt|Traits}} template parameter - a specialization of {{lc|std::char_traits}} or a compatible traits class. 

{{rev begin}}
{{rev | since=c++11 |
The elements of a {{tt|basic_string}} are stored contiguously, that is, for a basic_string {{tt|s}}, {{c|1=&amp;*(s.begin() + n) == &amp;*s.begin() + n}} for any n in {{tt|[0, s.size())}}, or, equivalently, a pointer to {{tt|s[0]}} can be passed to functions that expect a pointer to the first element of a {{tt|CharT[]}} array.
}}
{{rev end}}

{{tt|std::basic_string}} satisfies the requirements of {{concept|AllocatorAwareContainer}}.

Several typedefs for common character types are provided:
{{dsc begin}}
{{dsc header | string}}
{{dsc hitem | Type | Definition}}
{{dsc | {{lc|std::string}} | {{c|std::basic_string&lt;char&gt;}}}}
{{dsc | {{lc|std::wstring}} | {{c|std::basic_string&lt;wchar_t&gt;}}}}
{{dsc | {{lc|std::u16string}} {{mark c++11}}| {{c|std::basic_string&lt;char16_t&gt;}} }}
{{dsc | {{lc|std::u32string}} {{mark c++11}}| {{c|std::basic_string&lt;char32_t&gt;}} }}
{{dsc end}}

===Template parameters===
{{par begin}}
{{par | CharT | character type}}
{{par | Traits | traits class specifying the operations on the character type}}
{{par | Allocator | {{concept|Allocator}} type used to allocate internal storage}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|traits_type}} | {{tt|Traits}} }}
{{dsc | {{tt|value_type}} | {{tt|Traits::char_type}} }}
{{dsc inc | cpp/container/dsc allocator_type | basic_string}}
{{dsc inc | cpp/container/dsc size_type | basic_string}}
{{dsc inc | cpp/container/dsc difference_type | basic_string}}
{{dsc inc | cpp/container/dsc reference | basic_string}}
{{dsc inc | cpp/container/dsc const_reference | basic_string}}
{{dsc inc | cpp/container/dsc pointer | basic_string}}
{{dsc inc | cpp/container/dsc const_pointer | basic_string}}
{{dsc inc | cpp/container/dsc iterator | basic_string}}
{{dsc inc | cpp/container/dsc const_iterator | basic_string}}
{{dsc inc | cpp/container/dsc reverse_iterator | basic_string}}
{{dsc inc | cpp/container/dsc const_reverse_iterator | basic_string}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc constructor}}
{{dsc inc | cpp/string/basic_string/dsc operator{{=}}}}
{{dsc inc | cpp/string/basic_string/dsc assign}}
{{dsc inc | cpp/string/basic_string/dsc get_allocator}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/string/basic_string/dsc at}}
{{dsc inc | cpp/string/basic_string/dsc operator_at}}
{{dsc inc | cpp/string/basic_string/dsc front}}
{{dsc inc | cpp/string/basic_string/dsc back}}
{{dsc inc | cpp/string/basic_string/dsc data}}
{{dsc inc | cpp/string/basic_string/dsc c_str}}

{{dsc h2 | Iterators}}
{{dsc inc | cpp/string/basic_string/dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc end}}
{{dsc inc | cpp/string/basic_string/dsc rbegin}}
{{dsc inc | cpp/string/basic_string/dsc rend}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/string/basic_string/dsc empty}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc inc | cpp/string/basic_string/dsc max_size}}
{{dsc inc | cpp/string/basic_string/dsc reserve}}
{{dsc inc | cpp/string/basic_string/dsc capacity}}
{{dsc inc | cpp/string/basic_string/dsc shrink_to_fit}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/string/basic_string/dsc clear}}
{{dsc inc | cpp/string/basic_string/dsc insert}}
{{dsc inc | cpp/string/basic_string/dsc erase}}
{{dsc inc | cpp/string/basic_string/dsc push_back}}
{{dsc inc | cpp/string/basic_string/dsc pop_back}}
{{dsc inc | cpp/string/basic_string/dsc append}}
{{dsc inc | cpp/string/basic_string/dsc operator+{{=}}}}
{{dsc inc | cpp/string/basic_string/dsc compare}}
{{dsc inc | cpp/string/basic_string/dsc replace}}
{{dsc inc | cpp/string/basic_string/dsc substr}}
{{dsc inc | cpp/string/basic_string/dsc copy}}
{{dsc inc | cpp/string/basic_string/dsc resize}}
{{dsc inc | cpp/string/basic_string/dsc swap}}

{{dsc h2 | Search}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}

{{dsc h1 | Constants}}
{{dsc inc | cpp/string/basic_string/dsc npos}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator+}}
{{dsc inc | cpp/string/basic_string/dsc operator_cmp}}
{{dsc inc | cpp/string/basic_string/dsc swap2}}

{{dsc h2 | Input/output}}
{{dsc inc | cpp/string/basic_string/dsc operator_ltltgtgt}}
{{dsc inc | cpp/string/basic_string/dsc getline}}

{{dsc h2 | Numeric conversions}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/basic_string/dsc stoul}}
{{dsc inc | cpp/string/basic_string/dsc stof}}
{{dsc inc | cpp/string/basic_string/dsc to_string}}
{{dsc inc | cpp/string/basic_string/dsc to_wstring}}
{{dsc end}}

===Literals===
{{dsc begin}}
{{dsc namespace | std::literals::string_literals | inline=true }}
{{dsc inc | cpp/string/basic_string/dsc operator&quot;&quot;s}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc hash}}
{{dsc end}}

[[de:cpp/string/basic string]]
[[es:cpp/string/basic string]]
[[fr:cpp/string/basic string]]
[[it:cpp/string/basic string]]
[[ja:cpp/string/basic string]]
[[pl:cpp/string/basic string]]
[[pt:cpp/string/basic string]]
[[ru:cpp/string/basic string]]
[[tr:cpp/string/basic string]]
[[zh:cpp/string/basic string]]</text>
      <sha1>awwd7whqavcrq48ffvkpacna8vtfqiu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/append</title>
    <ns>0</ns>
    <id>1390</id>
    <revision>
      <id>69736</id>
      <parentid>68736</parentid>
      <timestamp>2014-04-21T21:10:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>23.2.3/14</comment>
      <text xml:space="preserve" bytes="4513">{{cpp/string/basic_string/title | append}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_string&amp; append( size_type count, CharT ch );
}}
{{dcl | num=2 | 
basic_string&amp; append( const basic_string&amp; str );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++14 | 
basic_string&amp; append( const basic_string&amp; str,
                      size_type pos,
                      size_type count );
}}
{{dcl | since=c++14 | 
basic_string&amp; append( const basic_string&amp; str,
                      size_type pos,
                      size_type count {{=}} npos);
}}
{{dcl rev end}}
{{dcl | num=4 |
basic_string&amp; append( const CharT* s,
                      size_type count );
}}
{{dcl | num=5 |
basic_string&amp; append( const CharT* s );
}}
{{dcl | num=6 | 1=
template&lt; class InputIt &gt;
basic_string&amp; append( InputIt first, InputIt last );
}}
{{dcl | num=7 | since=c++11 | 1=
basic_string&amp; append( std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Appends additional characters to the string.

1) Appends {{tt|count}} copies of character {{tt|ch}}

2) Appends string {{tt|str}}

3) Appends a substring {{tt|[pos, pos+count)}} of {{tt|str}}. If the requested substring lasts past the end of the string, or if {{c|1=count == npos}}, the appended substring is {{tt|[pos, size())}}.  If {{c|1=pos &gt;= str.size()}}, {{lc|std::out_of_range}} is thrown. 

4) Appends the first {{tt|count}} characters of character string pointed to by {{tt|s}}. {{tt|s}} can contain null characters.

5) Appends the null-terminated character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. 

6) Appends characters in the range {{tt|[first, last)}}. {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}

7) Appends characters in the initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | count | number of characters to append}}
{{par | ch | character value to append}}
{{par | first, last | range of characters to append}}
{{par | str | string to append}}
{{par | s | pointer to the character string to append}}
{{par | ilist | initializer list with the characters to append}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
{{c|*this}}

===Complexity===

1) linear in {{tt|count}}

2) linear in size of {{tt|str}}

3-4) linear in {{tt|count}}

5) linear in size of {{tt|s}}

6) linear in distance between {{tt|first}} and {{tt|last}}

7) linear in size of {{tt|ilist}}

===Exceptions===
{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

If the operation would result in {{tt|size() &gt; max_size()}}, throws {{lc|std::length_error}}.

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;

int main() {
    std::basic_string&lt;char&gt; str = &quot;string&quot;;
    const char* cptr = &quot;C-string&quot;;
    const char carr[] = &quot;Two and one&quot;;

    std::string output;

    // 1) Repeat a char
    output.append(3, '*');
    std::cout &lt;&lt; &quot;1) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;

    //  2) Append a whole string
    output.append(str);
    std::cout &lt;&lt; &quot;2) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;

    // 3) Append part of a string (last 3 letters, in this case)
    output.append(str, 3, 3);
    std::cout &lt;&lt; &quot;3) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;
    
    // 4) Append part of a C-string
    // Notice, because `append` returns *this, we can chain calls together
    output.append(1, ' ').append(carr, 4);
    std::cout &lt;&lt; &quot;4) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;

    // 5) Append a whole C-string
    output.append(cptr);
    std::cout &lt;&lt; &quot;5) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;

    // 6) Append range
    output.append(&amp;carr[3], std::end(carr));
    std::cout &lt;&lt; &quot;6) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;

    // 7) Append initializer list
    output.append({ ' ', 'l', 'i', 's', 't' });
    std::cout &lt;&lt; &quot;7) &quot; &lt;&lt; output &lt;&lt; &quot;\n&quot;;
}

 | output=
1) ***
2) ***string
3) ***stringing
4) ***stringing Two 
5) ***stringing Two C-string
6) ***stringing Two C-string and one
7) ***stringing Two C-string and one list
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator+{{=}}}}
{{dsc end}}

[[de:cpp/string/basic string/append]]
[[es:cpp/string/basic string/append]]
[[fr:cpp/string/basic string/append]]
[[it:cpp/string/basic string/append]]
[[ja:cpp/string/basic string/append]]
[[pl:cpp/string/basic string/append]]
[[pt:cpp/string/basic string/append]]
[[ru:cpp/string/basic string/append]]
[[zh:cpp/string/basic string/append]]</text>
      <sha1>szwdktn71p2xmc4usj44adfcap95qpc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/assign</title>
    <ns>0</ns>
    <id>1391</id>
    <revision>
      <id>72330</id>
      <parentid>72297</parentid>
      <timestamp>2014-08-10T22:13:52Z</timestamp>
      <contributor>
        <username>Dotslashzero</username>
        <id>3312</id>
      </contributor>
      <minor/>
      <comment>Fixed spelling typo.</comment>
      <text xml:space="preserve" bytes="5209">{{cpp/string/basic_string/title | assign}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_string&amp; assign( size_type count, CharT ch );
}}
{{dcl | num=2 | 
basic_string&amp; assign( const basic_string&amp; str );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++14 | 
basic_string&amp; assign( const basic_string&amp; str,
                      size_type pos,
                      size_type count );
}}
{{dcl | since=c++14 | 
basic_string&amp; assign( const basic_string&amp; str,
                      size_type pos,
                      size_type count {{=}} npos);
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 |
basic_string&amp; assign( basic_string&amp;&amp; str );
}}
{{dcl | num=5 |
basic_string&amp; assign( const CharT* s,
                      size_type count );
}}
{{dcl | num=6 |
basic_string&amp; assign( const CharT* s );
}}
{{dcl | num=7 | 1=
template&lt; class InputIt &gt;
basic_string&amp; assign( InputIt first, InputIt last );
}}
{{dcl | num=8 | since=c++11 | 1=
basic_string&amp; assign( std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Replaces the contents of the string.

@1@ Replaces the contents with {{tt|count}} copies of character {{tt|ch}}.

@2@ Replaces the contents with a copy of {{tt|str}}.

@3@ Replaces the contents with a substring {{tt|[pos, pos+count)}} of {{tt|str}}. If the requested substring lasts past the end of the string, or if {{c|1=count == npos}}, the resulting substring is {{tt|[pos, size())}}.  If {{c|1=pos &gt; str.size()}}, {{lc|std::out_of_range}} is thrown. 

@4@ Replaces the contents with those of {{tt|str}} using move semantics. {{tt|str}} is in undefined state after the operation.

@5@ Replaces the contents with the first {{tt|count}} characters of character string pointed to by {{tt|s}}. {{tt|s}} can contain null characters.

@6@ Replaces the contents with those of null-terminated character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. 

@7@ Replaces the contents with copies of the characters in the range {{tt|[first, last)}}. {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}

@8@ Replaces the contents with those of the initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | count | size of the resulting string}}
{{par | ch | value to initialize characters of the string with}}
{{par | first, last | range to copy the characters from}}
{{par | str | string to be used as source to initialize the characters with}}
{{par | s | pointer to a character string to use as source to initialize the string with}}
{{par | init | initializer list to initialize the characters of the string with}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
{{c|*this}}

===Complexity===

@1@ linear in {{tt|count}}

@2@ linear in size of {{tt|str}}

@3@ linear in {{tt|count}}

@4@ constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

@5@ linear in {{tt|count}}

@6@ linear in size of {{tt|s}}

@7@ linear in distance between {{tt|first}} and {{tt|last}}

@8@ linear in size of {{tt|init}}

===Exceptions===
{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

If the operation would result in {{tt|size() &gt; max_size()}}, throws {{lc|std::length_error}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
  std::string s;
  // assign(size_type count, CharT ch)
  s.assign(4, '=');
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;====&quot;
  
  std::string const c(&quot;Exemplary&quot;);
  // assign(basic_string const&amp; str)
  s.assign(c);
  std::cout &lt;&lt; c &lt;&lt; &quot;==&quot; &lt;&lt; s &lt;&lt;'\n'; // &quot;Exemplary == Exemplary&quot;

  // assign(basic_string const&amp; str, size_type pos, size_type count)
  s.assign(c, 0, c.length()-1);
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;Exemplar&quot;;

  // assign(basic_string&amp;&amp; str)
  s.assign(std::string(&quot;C++ by &quot;) + std::string(&quot;example&quot;));
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C++ by example&quot;

  // assign(charT const* s, size_type count)
  s.assign(&quot;C-style string&quot;, 7);
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;

  // assign(charT const* s)
  s.assign(&quot;C-style\0string&quot;);
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;

  char mutable_c_str[] = &quot;C-style string&quot;;
  // assign(InputIt first, InputIt last)
  s.assign(std::begin(mutable_c_str), std::end(mutable_c_str)-1);
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style string&quot;

  // assign(std::initializer_list&lt;charT&gt; ilist)
  s.assign({ 'C', '-', 's', 't', 'y', 'l', 'e' });
  std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;
}
 | output=
====
Exemplary==Exemplary
Exemplar
C++ by example
C-style
C-style
C-style string
C-style
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc constructor}}
{{dsc inc | cpp/string/basic_string/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/string/basic string/assign]]
[[es:cpp/string/basic string/assign]]
[[fr:cpp/string/basic string/assign]]
[[it:cpp/string/basic string/assign]]
[[ja:cpp/string/basic string/assign]]
[[pl:cpp/string/basic string/assign]]
[[pt:cpp/string/basic string/assign]]
[[ru:cpp/string/basic string/assign]]
[[zh:cpp/string/basic string/assign]]</text>
      <sha1>iymlcsm4k4c817skzkz2enr28j0r7mq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/at</title>
    <ns>0</ns>
    <id>1392</id>
    <revision>
      <id>70312</id>
      <parentid>69167</parentid>
      <timestamp>2014-05-18T20:12:24Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Catch exceptions by const reference</comment>
      <text xml:space="preserve" bytes="1649">{{cpp/string/basic_string/title | at}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
reference       at( size_type pos );
}}
{{dcl | 
const_reference at( size_type pos ) const;
}}
{{dcl end}}

Returns a reference to the character at specified location {{tt|pos}}. Bounds checking is performed, exception of type {{lc|std::out_of_range}} will be thrown on invalid access.

===Parameters===
{{par begin}}
{{par | pos | position of the character to return}}
{{par end}}

===Return value===
Reference to the requested character.

===Exceptions===
Throws {{lc|std::out_of_range}} if {{c|1=pos &gt;= size()}}.

===Complexity===
Constant.

===Example===
{{
example
| code=
#include &lt;stdexcept&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string s(&quot;message&quot;); // for capacity

    s = &quot;abc&quot;;
    s.at(2) = 'x'; // ok
    std::cout &lt;&lt; s &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;string size = &quot; &lt;&lt; s.size() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;string capacity = &quot; &lt;&lt; s.capacity() &lt;&lt; '\n';

    try {
        // throw, even if capacity allowed to access element
        s.at(3) = 'x';
    }
    catch (std::out_of_range const&amp; exc) {
        std::cout &lt;&lt; exc.what() &lt;&lt; '\n';
    }
}
| output=
abx
string size = 3
string capacity = 7
basic_string::at
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator_at }}
{{dsc end}}

[[de:cpp/string/basic string/at]]
[[es:cpp/string/basic string/at]]
[[fr:cpp/string/basic string/at]]
[[it:cpp/string/basic string/at]]
[[ja:cpp/string/basic string/at]]
[[pl:cpp/string/basic string/at]]
[[pt:cpp/string/basic string/at]]
[[ru:cpp/string/basic string/at]]
[[zh:cpp/string/basic string/at]]</text>
      <sha1>q1mcr0b7nrxi5r499nehvjzd39ijyux</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/back</title>
    <ns>0</ns>
    <id>1393</id>
    <revision>
      <id>70482</id>
      <parentid>70315</parentid>
      <timestamp>2014-05-24T02:19:16Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>print out the result</comment>
      <text xml:space="preserve" bytes="1230">{{cpp/string/basic_string/title | back}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
CharT&amp; back();
}}
{{dcl | since=c++11 |
const CharT&amp; back() const;
}}
{{dcl end}}

Returns reference to the last character in the string. 

===Parameters===
(none)

===Return value===
reference to the last character, equivalent to {{c|at(size() - 1)}}.

===Complexity===
Constant

===Notes===
{{tt|back}} requires that {{c|!empty() {{==}} true}}, otherwise the result is undefined.

===Example===
{{
example
| code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
  {
    std::string s(&quot;Exemplary&quot;);
    char&amp; back = s.back();
    back = 's';
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;Exemplars&quot;
  }

  {
    std::string const c(&quot;Exemplary&quot;);
    char const&amp; back = c.back();
    std::cout &lt;&lt; back &lt;&lt; '\n'; // 'y'
  }
}
| output=
Exemplars
y
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc front}}
{{dsc end}}

[[de:cpp/string/basic string/back]]
[[es:cpp/string/basic string/back]]
[[fr:cpp/string/basic string/back]]
[[it:cpp/string/basic string/back]]
[[ja:cpp/string/basic string/back]]
[[pt:cpp/string/basic string/back]]
[[ru:cpp/string/basic string/back]]
[[zh:cpp/string/basic string/back]]</text>
      <sha1>ptni6a00882zwta6bcj3tef93uoozcn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/basic string</title>
    <ns>0</ns>
    <id>1394</id>
    <revision>
      <id>70763</id>
      <parentid>70478</parentid>
      <timestamp>2014-05-29T23:23:33Z</timestamp>
      <contributor>
        <ip>173.252.71.189</ip>
      </contributor>
      <comment>noexcept movector</comment>
      <text xml:space="preserve" bytes="6489">{{cpp/string/basic_string/title | basic_string}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | until=c++14 | 1= 
explicit basic_string( const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1= 
basic_string() : basic_string( Allocator() ) {}
explicit basic_string( const Allocator&amp; alloc );
}}
{{dcl rev end}}
{{dcl | num=2 | 1=
basic_string( size_type count, 
              CharT ch, 
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=3 | 1=
basic_string( const basic_string&amp; other, 
              size_type pos, 
              size_type count = std::basic_string::npos,
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=4 | 1=
basic_string( const CharT* s,
              size_type count, 
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=5 | 1=
basic_string( const CharT* s,
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=6 | 1=
template&lt; class InputIt &gt;
basic_string( InputIt first, InputIt last, 
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=7 | 
basic_string( const basic_string&amp; other );                           
}}
{{dcl | num=7 | since=c++11 |
basic_string( const basic_string&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=8 | since=c++11 |
basic_string( basic_string&amp;&amp; other ) noexcept
}}
{{dcl | num=8 | since=c++11 |
basic_string( basic_string&amp;&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=9 | since=c++11 | 1=
basic_string( std::initializer_list&lt;CharT&gt; init, 
              const Allocator&amp; alloc = Allocator() );
}}
{{dcl end}}

Constructs new string from a variety of data sources and optionally using user supplied allocator {{tt|alloc}}.

@1@ Default constructor. Constructs empty string (zero size and unspecified capacity)
@2@ Constructs the string with {{tt|count}} copies of character {{tt|ch}}. The behavior is undefined if {{tt|count &gt;{{=}} npos}}
@3@ Constructs the string with a substring {{tt|[pos, pos+count)}} of {{tt|other}}. If the requested substring lasts past the end of the string, or if {{c|1=count == npos}}, the resulting substring is {{tt|[pos, size())}}.
@4@ Constructs the string with the first {{tt|count}} characters of character string pointed to by {{tt|s}}. {{tt|s}} can contain null characters. The behavior is undefined if {{tt|s}} does not point at an array of at least {{tt|count}} elements of {{tt|CharT}}.
@5@ Constructs the string with the contents initialized with a copy of the null-terminated character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. The behavior is undefined if {{tt|s}} does not point at an array of at least {{c|Traits::length(s)+1}} elements of {{tt|CharT}}.
@6@ Constructs the string  with the contents of the range {{tt|[first, last)}}. {{rev inl|since=c++11|This constructor does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}
@7@ Copy constructor. Constructs the string with the copy of the contents of {{tt|other}}.
@8@ Move constructor. Constructs the string with the contents of {{tt|other}} using move semantics. {{tt|other}} is left in valid, but unspecified state.
@9@ Constructs the string with the contents of the initializer list {{tt|init}}. 

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of this string}}
{{par | count | size of the resulting string}}
{{par | ch | value to initialize the string with}}
{{par | first, last | range to copy the characters from}}
{{par | s | pointer to a character string to use&lt;br&gt; as source to initialize the string with}}
{{par | other | another string to use as source to initialize the string with}}
{{par | init | initializer list to initialize the string with}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===

1) constant

2-4) linear in {{tt|count}}

5) linear in length of {{tt|s}}

6) linear in distance between {{tt|first}} and {{tt|last}}

7) linear in size of {{tt|other}}

8) constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

9) linear in size of {{tt|init}}

===Exceptions===
@3@ {{lc|std::out_of_range}} if {{c|pos &gt; other.size()}}
@8@ Throws nothing if {{c|alloc {{==}} str.get_allocator()}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cassert&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
  {
    // string::string()
    std::string s;
    assert(s.empty() &amp;&amp; (s.length() == 0) &amp;&amp; (s.size() == 0));
  }

  {
    // string::string(size_type count, charT ch)
    std::string s(4, '=');
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;====&quot;
  }

  {
    std::string const other(&quot;Exemplary&quot;);
    // string::string(string const&amp; other, size_type pos, size_type count)
    std::string s(other, 0, other.length()-1);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;Exemplar&quot;
  }

  {
    // string::string(charT const* s, size_type count)
    std::string s(&quot;C-style string&quot;, 7);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;
  }

  {
    // string::string(charT const* s)
    std::string s(&quot;C-style\0string&quot;);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;
  }

  {
    char mutable_c_str[] = &quot;another C-style string&quot;;
    // string::string(InputIt first, InputIt last)
    std::string s(std::begin(mutable_c_str)+8, std::end(mutable_c_str)-1);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style string&quot;
  }

  {
    std::string const other(&quot;Exemplar&quot;);
    std::string s(other);
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;Exemplar&quot;
  }

  {
    // string::string(string&amp;&amp; str)
    std::string s(std::string(&quot;C++ by &quot;) + std::string(&quot;example&quot;));
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C++ by example&quot;
  }

  {
    // string(std::initializer_list&lt;charT&gt; ilist)
    std::string s({ 'C', '-', 's', 't', 'y', 'l', 'e' });
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;C-style&quot;
  }
}
 | output=
====
Exemplar
C-style
C-style
C-style string
Exemplar
C++ by example
C-style
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc assign}}
{{dsc inc | cpp/string/basic_string/dsc operator{{=}} }}
{{dsc end}}

[[de:cpp/string/basic string/basic string]]
[[es:cpp/string/basic string/basic string]]
[[fr:cpp/string/basic string/basic string]]
[[it:cpp/string/basic string/basic string]]
[[ja:cpp/string/basic string/basic string]]
[[pl:cpp/string/basic string/basic string]]
[[pt:cpp/string/basic string/basic string]]
[[ru:cpp/string/basic string/basic string]]
[[zh:cpp/string/basic string/basic string]]</text>
      <sha1>obc2ghk8mktgz8jdjtfansq4irwny2v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/begin</title>
    <ns>0</ns>
    <id>1395</id>
    <revision>
      <id>70809</id>
      <parentid>70319</parentid>
      <timestamp>2014-05-30T15:59:58Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+{{image|range-begin-end.svg}}， +noexcept</comment>
      <text xml:space="preserve" bytes="1179">{{cpp/string/basic_string/title | begin | cbegin}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
iterator begin();
}}
{{dcl | 
const_iterator begin() const;
}}
{{dcl | since=c++11 |
const_iterator cbegin() const;
}}
{{dcl end}}

Returns an iterator to the first character of the string. 

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
iterator to the first character

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Complexity===
Constant

===Example===
{{example
|code=
#include &lt;cassert&gt;
#include &lt;string&gt;

int main()
{
  std::string s(&quot;Exemplar&quot;);
  *s.begin() = 'e';
  assert(&quot;exemplar&quot; == s);

  auto i = s.cbegin();
  assert(s[0] == *i);
}
|output=
}}
===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc end}}
{{dsc end}}

[[de:cpp/string/basic string/begin]]
[[es:cpp/string/basic string/begin]]
[[fr:cpp/string/basic string/begin]]
[[it:cpp/string/basic string/begin]]
[[ja:cpp/string/basic string/begin]]
[[pl:cpp/string/basic string/begin]]
[[pt:cpp/string/basic string/begin]]
[[ru:cpp/string/basic string/begin]]
[[zh:cpp/string/basic string/begin]]</text>
      <sha1>c6j4hrvrgoq28hfcx59lj36m8lv7rln</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/c str</title>
    <ns>0</ns>
    <id>1396</id>
    <revision>
      <id>70318</id>
      <parentid>64795</parentid>
      <timestamp>2014-05-19T00:04:35Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Add example</comment>
      <text xml:space="preserve" bytes="2536">{{cpp/string/basic_string/title | c_str}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
const CharT* c_str() const;
}}
{{dcl end}}

Returns a pointer to a null-terminated character array with data equivalent to those stored in the string. 

The pointer is such that the range {{tt|[c_str(); c_str() + size()]}} is valid and the values in it correspond to the values stored in the string with an additional null character after the last position.

The pointer obtained from {{tt|c_str()}} may be invalidated by:
* Passing a non-const reference to the string to any standard library function, or
* Calling non-const member functions on the string, excluding {{lc|operator[]}}, {{lc|at()}}, {{lc|front()}}, {{lc|back()}}, {{lc|begin()}}, {{lc|rbegin()}}, {{lc|end()}} and {{lc|rend()}}.

Writing to the character array accessed through {{tt|c_str()}} is undefined behavior.

{{rev begin}}
{{rev | since=c++11 | {{tt|c_str()}} and {{lc|data()}} perform the same function.}}
{{rev end}}

===Parameters===
(none)

===Return value===
Pointer to the underlying character storage.

{{rev begin}}
{{rev | until=c++11 | {{c|1=data()[i] == operator[](i)}} for every {{tt|i}} in {{tt|[0, size())}}. }}
{{rev | since=c++11 | {{c|1=data() + i == &amp;operator[](i)}} for every {{tt|i}} in {{tt|[0, size()]}}. }}
{{rev end}}

===Complexity===
Constant.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Notes===
The pointer obtained from {{tt|c_str()}} may only be treated as a pointer to a null-terminated character string if the string object does not contain other null characters.

===Example===
{{example
| code=
#include &lt;algorithm&gt;
#include &lt;cassert&gt;
#include &lt;cstring&gt;
#include &lt;string&gt;

int main()
{
  std::string const s(&quot;Emplary&quot;);
  assert(s.size() == std::strlen(s.c_str()));
  assert(std::equal(s.begin(), s.end(), s.c_str()));
  assert(std::equal(s.c_str(), s.c_str() + s.size(), s.begin()));
  assert(0 == *(s.c_str() + s.size()));
}
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc front}}
{{dsc inc | cpp/string/basic_string/dsc back}}
{{dsc inc | cpp/string/basic_string/dsc data}}
{{dsc end}}

[[de:cpp/string/basic string/c str]]
[[es:cpp/string/basic string/c str]]
[[fr:cpp/string/basic string/c str]]
[[it:cpp/string/basic string/c str]]
[[ja:cpp/string/basic string/c str]]
[[pl:cpp/string/basic string/c str]]
[[pt:cpp/string/basic string/c str]]
[[ru:cpp/string/basic string/c str]]
[[zh:cpp/string/basic string/c str]]</text>
      <sha1>2wwb1iv4icpzygj9tm4lnhvv1rgu3i9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/capacity</title>
    <ns>0</ns>
    <id>1397</id>
    <revision>
      <id>70483</id>
      <parentid>70339</parentid>
      <timestamp>2014-05-24T02:24:11Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>p=true</comment>
      <text xml:space="preserve" bytes="1375">{{cpp/string/basic_string/title | capacity}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
size_type capacity() const;
}}
{{dcl end}}

Returns the number of characters that the string has currently allocated space for. 

===Parameters===
(none)

===Return value===

capacity of the currently allocated storage

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

===Complexity===
Constant

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;string&gt;

void show_capacity(std::string const&amp; s)
{
    std::cout &lt;&lt; &quot;'&quot; &lt;&lt; s &lt;&lt; &quot;' has capacity &quot; &lt;&lt; s.capacity() &lt;&lt; &quot;.\n&quot;;
}

int main()
{
    std::string s{&quot;Exemplar&quot;};
    show_capacity(s);

    s += &quot; is an example string.&quot;;
    show_capacity(s);
}
|p=true
|output=
'Exemplar' has capacity 8.
'Exemplar is an example string.' has capacity 30.
}}
===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc inc | cpp/string/basic_string/dsc reserve}}
{{dsc end}}

[[de:cpp/string/basic string/capacity]]
[[es:cpp/string/basic string/capacity]]
[[fr:cpp/string/basic string/capacity]]
[[it:cpp/string/basic string/capacity]]
[[ja:cpp/string/basic string/capacity]]
[[pl:cpp/string/basic string/capacity]]
[[pt:cpp/string/basic string/capacity]]
[[ru:cpp/string/basic string/capacity]]
[[zh:cpp/string/basic string/capacity]]</text>
      <sha1>ic6wpwp8eukfhjk8u942o0lvrcxv0l0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/clear</title>
    <ns>0</ns>
    <id>1398</id>
    <revision>
      <id>70341</id>
      <parentid>70340</parentid>
      <timestamp>2014-05-20T03:20:20Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Make it clearer that s is empty, although capacity remains unchanged after clear().</comment>
      <text xml:space="preserve" bytes="1260">{{cpp/string/basic_string/title | clear}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
void clear();
}}
{{dcl end}}

Removes all characters from the string. The allocated memory will not be released, effectively leaving the {{lc|capacity}} of the string unchanged. The past-the-end iterators are not invalidated. 

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

===Complexity===
Linear in the size of the string.

===Example===
{{example
|code=
#include &lt;cassert&gt;
#include &lt;string&gt;

int main()
{
    std::string s{ &quot;Exemplar&quot; };
    std::string::size_type const capacity = s.capacity();

    s.clear();
    assert(capacity == s.capacity());
    assert(s.empty());
    assert(0 == s.size());
}
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc erase}}
{{dsc end}}

[[de:cpp/string/basic string/clear]]
[[es:cpp/string/basic string/clear]]
[[fr:cpp/string/basic string/clear]]
[[it:cpp/string/basic string/clear]]
[[ja:cpp/string/basic string/clear]]
[[pl:cpp/string/basic string/clear]]
[[pt:cpp/string/basic string/clear]]
[[ru:cpp/string/basic string/clear]]
[[zh:cpp/string/basic string/clear]]</text>
      <sha1>qcqsljezehgiy1eigvnf53jc8yo50p0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/compare</title>
    <ns>0</ns>
    <id>1399</id>
    <revision>
      <id>68738</id>
      <parentid>67997</parentid>
      <timestamp>2014-03-20T03:53:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="5614">{{cpp/string/basic_string/title | compare}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
int compare( const basic_string&amp; str ) const;
}}
{{dcl | num=2 |
int compare( size_type pos1, size_type count1,
             const basic_string&amp; str ) const;
}}
{{dcl rev begin|num=3}}
{{dcl | until=c++14 |
int compare( size_type pos1, size_type count1,
             const basic_string&amp; str,
             size_type pos2, size_type count2 ) const;
}}
{{dcl | since=c++14 |
int compare( size_type pos1, size_type count1,
             const basic_string&amp; str,
             size_type pos2, size_type count2 {{=}} npos ) const;
}}
{{dcl rev end}}
{{dcl | num=4 |
int compare( const CharT* s ) const;
}}
{{dcl | num=5 |
int compare( size_type pos1, size_type count1,
             const CharT* s ) const;
}}
{{dcl | num=6 |
int compare( size_type pos1, size_type count1,
             const CharT* s, size_type count2 ) const;
}}
{{dcl end}}

Compares two character sequences. 

@1@ Compares this string to ''str''. First, calculates the number of characters to compare, as if by {{c|1=size_type rlen = std::min(size(), str.size())}}. Then compares by calling {{c|Traits::compare(data(), str.data(), rlen)}}. For standard strings this function performs character-by-character lexicographical comparison. If the result is zero (the strings are equal so far), then their sizes are compared as follows:

{| class=&quot;wikitable&quot; style=&quot;text-align:center;&quot;
! colspan=2 | Condition
! Result
! Return value
|-
| colspan=2 style=&quot;text-align:left;&quot; | {{tt|Traits::compare({{spar|data}}, {{spar|arg}}, {{spar|rlen}}) &lt; 0}}
| {{spar|data}} is ''less'' than {{spar|arg}}
| {{c|&lt;0}}
|-
| rowspan=3 | {{tt|Traits::compare({{spar|data}}, {{spar|arg}}, {{spar|rlen}}) {{==}} 0}}
| {{tt|size({{spar|data}}) &lt; size({{spar|arg}})}}
| {{spar|data}} is ''less'' than {{spar|arg}}
| {{c|&lt;0}}
|-
&lt;!-- --&gt;
| {{tt|size({{spar|data}}) {{==}} size({{spar|arg}})}}
| {{spar|data}} is ''equal'' to {{spar|arg}}
| {{c|0}}
|-
&lt;!-- --&gt;
| {{tt|size({{spar|data}}) &gt; size({{spar|arg}})}}
| {{spar|data}} is ''greater'' than {{spar|arg}}
| {{c|&gt;0}}
|-
| colspan=2 style=&quot;text-align:left;&quot; | {{tt|Traits::compare({{spar|data}}, {{spar|arg}}, {{spar|rlen}}) &gt; 0}}
| {{spar|data}} is ''greater'' than {{spar|arg}}
| {{c|&gt;0}}
|}

@2@ Compares a {{tt|[pos1, pos1+count1)}} substring of this string to ''str'' as if by {{c|basic_string(*this, pos1, count1).compare(str)}}

@3@ Compares a {{tt|[pos1, pos1+count1)}} substring of this string to a substring {{tt|[pos2, pos2+count2)}} of ''str''  as if by {{c|basic_string(*this, pos1, count1).compare(basic_string(str, pos2, count2))}}

@4@ Compares this string to the null-terminated character sequence beginning at the character pointed to by ''s'', as if by {{c|compare(basic_string(s))}}

@5@ Compares a {{tt|[pos1, pos1+count1)}} substring of this string to the null-terminated character sequence beginning at the character pointed to by ''s'', as if by {{c|basic_string(*this, pos, count1).compare(basic_string(s))}}

@6@ Compares a {{tt|[pos1, pos1+count1)}} substring of this string to the first {{tt|count2}} characters of the character array whose first character is pointed to by ''s'', as if by {{c|basic_string(*this, pos, count1).compare(basic_string(s, count2)).}} (Note: the characters from {{tt|s}} to {{tt|s+count2}} may include null characters))

===Parameters===
{{par begin}}
{{par | str | other string to compare to}}
{{par | s | pointer to the character string to compare to}}
{{par | count1 | number of characters of this string to compare}}
{{par | pos1 | position of the first character in this string to compare}}
{{par | count2 | number of characters of the given string to compare}}
{{par | pos2 | position of the first character of the given string to compare}}
{{par end}} 

===Return value===
negative value if this string is ''less'' than the other character sequence, zero if the both character sequences are equal, positive value if this string is ''greater'' than the other character sequence.

===Exceptions===
@1@ {{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

@2-3@ May throw the exceptions thrown by the corresponding {{tt|basic_string}} constructors.

@4@ {{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

@5-6@ May throw the exceptions thrown by the corresponding {{tt|basic_string}} constructors.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class CharT, class Traits, class Alloc&gt;
int basic_string&lt;CharT, Traits, Alloc&gt;::compare(const std::basic_string&amp; str) const noexcept
{
    size_type lhs_sz = size();
    size_type rhs_sz = str.size();
    int result = traits_type::compare(data(), str.data(), std::min(lhs_sz, rhs_sz));
    if (result != 0)
        return result;
    if (lhs_sz &lt; rhs_sz)
        return -1;
    if (lhs_sz &gt; rhs_sz)
        return 1;
    return 0;
}
}}

===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator_cmp}}
{{dsc inc | cpp/string/basic_string/dsc substr}}
{{dsc inc | cpp/locale/dsc collate}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/algorithm/dsc lexicographical_compare}}
{{dsc end}}

[[de:cpp/string/basic string/compare]]
[[es:cpp/string/basic string/compare]]
[[fr:cpp/string/basic string/compare]]
[[it:cpp/string/basic string/compare]]
[[ja:cpp/string/basic string/compare]]
[[pl:cpp/string/basic string/compare]]
[[pt:cpp/string/basic string/compare]]
[[ru:cpp/string/basic string/compare]]
[[zh:cpp/string/basic string/compare]]</text>
      <sha1>azofj8a4a1t1tdtqn8s8dz9o4ll0xv3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/copy</title>
    <ns>0</ns>
    <id>1400</id>
    <revision>
      <id>72010</id>
      <parentid>71999</parentid>
      <timestamp>2014-07-08T13:06:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fmt example, missing #include, use the size param to match the size of the output</comment>
      <text xml:space="preserve" bytes="1549">{{cpp/string/basic_string/title | copy}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 1=
size_type copy( CharT* dest,
                size_type count,
                size_type pos = 0) const;
}}

Copies a substring {{tt|[pos, pos+count)}} to character string pointed to by {{tt|dest}}. If the requested substring lasts past the end of the string, or if {{c|1=count == npos}}, the copied substring is {{tt|[pos, size())}}.  The resulting character string is not null-terminated.

If {{c|1=pos &gt;= size()}}, {{lc|std::out_of_range}} is thrown. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the destination character string}}
{{par | pos | position of the first character to include}}
{{par | count | length of the substring}}
{{par end}} 

===Return value===
number of characters copied

===Exceptions===

{{lc|std::out_of_range}} if {{c|1=pos &gt;= size()}}.

===Complexity===
linear in {{tt|count}}

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;

int main()
{
  std::string foo(&quot;quuuux&quot;);
  char bar[7];
  foo.copy(bar, sizeof bar);
  bar[6] = '\0';
  std::cout &lt;&lt; bar &lt;&lt; '\n';
}
| output=
quuuux
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc substr}}
{{dsc end}}

[[de:cpp/string/basic string/copy]]
[[es:cpp/string/basic string/copy]]
[[fr:cpp/string/basic string/copy]]
[[it:cpp/string/basic string/copy]]
[[ja:cpp/string/basic string/copy]]
[[pl:cpp/string/basic string/copy]]
[[pt:cpp/string/basic string/copy]]
[[ru:cpp/string/basic string/copy]]
[[zh:cpp/string/basic string/copy]]</text>
      <sha1>ddnogez112h8qnnyjylr4r9xjfd9psv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/data</title>
    <ns>0</ns>
    <id>1401</id>
    <revision>
      <id>70317</id>
      <parentid>64797</parentid>
      <timestamp>2014-05-18T23:58:50Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Add example</comment>
      <text xml:space="preserve" bytes="2619">{{cpp/string/basic_string/title | data}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
const CharT* data() const;
}}
{{dcl end}}

Returns pointer to the underlying array serving as character storage. The pointer is such that the range {{tt|[data(); data() + size())}} is valid and the values in it correspond to the values stored in the string.  

{{rev begin}}
{{rev | until=c++11 |
The returned array is not required to be null-terminated.

If {{lc|empty()}} returns {{c|true}}, the pointer is a non-null pointer that should not be dereferenced. }}
{{rev | since=c++11 | 
The returned array is null-terminated, that is, {{tt|data()}} and {{lc|c_str()}} perform the same function.

If {{lc|empty()}} returns {{c|true}}, the pointer points to a single null character. | {{mark since c++11}} }}
{{rev end}}

The pointer obtained from {{tt|data()}} may be invalidated by:
* Passing a non-const reference to the string to any standard library function, or
* Calling non-const member functions on the string, excluding {{ltt|cpp/string/basic_string/operator_at|operator[]()}}, {{lc|at()}}, {{lc|front()}}, {{lc|back()}}, {{lc|begin()}}, {{lc|end()}}, {{lc|rbegin()}}, {{lc|rend()}}.

Modifying the character array accessed through {{tt|data}} is undefined behavior.

===Parameters===
(none)

===Return value===
A pointer to the underlying character storage.

{{rev begin}}
{{rev | until=c++11 | {{c|1=data()[i] == operator[](i)}} for every {{tt|i}} in {{tt|[0, size())}}. }}
{{rev | since=c++11 | {{c|1=data() + i == &amp;operator[](i)}} for every {{tt|i}} in {{tt|[0, size()]}}. }}
{{rev end}}

===Complexity===
Constant.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
| code=
#include &lt;algorithm&gt;
#include &lt;cassert&gt;
#include &lt;cstring&gt;
#include &lt;string&gt;

int main()
{
  std::string const s(&quot;Emplary&quot;);
  assert(s.size() == std::strlen(s.data()));
  assert(std::equal(s.begin(), s.end(), s.data()));
  assert(std::equal(s.data(), s.data() + s.size(), s.begin()));
  assert(0 == *(s.data() + s.size()));
}
| output=
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc front}}
{{dsc inc | cpp/string/basic_string/dsc back}}
{{dsc inc | cpp/string/basic_string/dsc c_str}}
{{dsc end}}

[[de:cpp/string/basic string/data]]
[[es:cpp/string/basic string/data]]
[[fr:cpp/string/basic string/data]]
[[it:cpp/string/basic string/data]]
[[ja:cpp/string/basic string/data]]
[[pl:cpp/string/basic string/data]]
[[pt:cpp/string/basic string/data]]
[[ru:cpp/string/basic string/data]]
[[zh:cpp/string/basic string/data]]</text>
      <sha1>5yg2i1mub9zox8g29ml95wzk486e6y8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/empty</title>
    <ns>0</ns>
    <id>1402</id>
    <revision>
      <id>70485</id>
      <parentid>70323</parentid>
      <timestamp>2014-05-24T02:40:53Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>print out the result</comment>
      <text xml:space="preserve" bytes="1348">{{cpp/string/basic_string/title | empty}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
bool empty() const;
}}
{{dcl end}}

Checks if the string has no characters, i.e. whether {{c|begin() {{==}} end()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the string is empty, {{c|false}} otherwise

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

===Complexity===
Constant.

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string s;
    std::boolalpha(std::cout);
    std::cout &lt;&lt; &quot;s.empty():&quot; &lt;&lt; s.empty() &lt;&lt; &quot;\t s:'&quot; &lt;&lt; s &lt;&lt; &quot;'\n&quot;;

    s = &quot;Exemplar&quot;;
    std::cout &lt;&lt; &quot;s.empty():&quot; &lt;&lt; s.empty() &lt;&lt; &quot;\t s:'&quot; &lt;&lt; s &lt;&lt; &quot;'\n&quot;;

    s = &quot;&quot;;
    std::cout &lt;&lt; &quot;s.empty():&quot; &lt;&lt; s.empty() &lt;&lt; &quot;\t s:'&quot; &lt;&lt; s &lt;&lt; &quot;'\n&quot;;
}
| output=
s.empty():true	 s:''
s.empty():false	 s:'Exemplar'
s.empty():true	 s:''
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc end}}

[[de:cpp/string/basic string/empty]]
[[es:cpp/string/basic string/empty]]
[[fr:cpp/string/basic string/empty]]
[[it:cpp/string/basic string/empty]]
[[ja:cpp/string/basic string/empty]]
[[pl:cpp/string/basic string/empty]]
[[pt:cpp/string/basic string/empty]]
[[ru:cpp/string/basic string/empty]]
[[zh:cpp/string/basic string/empty]]</text>
      <sha1>1rp0g9ihhg2a23ppwrtnsic53wknbdl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/end</title>
    <ns>0</ns>
    <id>1403</id>
    <revision>
      <id>70810</id>
      <parentid>70488</parentid>
      <timestamp>2014-05-30T16:02:14Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+{{image|range-begin-end.svg}}， +noexcept</comment>
      <text xml:space="preserve" bytes="1423">{{cpp/string/basic_string/title | end | cend}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
iterator end();
}}
{{dcl | 
const_iterator end() const;
}}
{{dcl | since=c++11 |
const_iterator cend() const;
}}
{{dcl end}}

Returns an iterator to the character following the last character of the string. This character acts as a placeholder, attempting to access it results in undefined behavior. 

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
iterator to the character following the last character

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Complexity===
Constant

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
    std::string s(&quot;Exemparl&quot;);
    std::next_permutation(s.begin(), s.end());

    std::string c;
    std::copy(s.cbegin(), s.cend(), std::back_inserter(c));
    std::cout &lt;&lt; c &lt;&lt;'\n'; // &quot;Exemplar&quot;
}
| output=
Exemplar
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc begin}}
{{dsc end}}

[[de:cpp/string/basic string/end]]
[[es:cpp/string/basic string/end]]
[[fr:cpp/string/basic string/end]]
[[it:cpp/string/basic string/end]]
[[ja:cpp/string/basic string/end]]
[[pl:cpp/string/basic string/end]]
[[pt:cpp/string/basic string/end]]
[[ru:cpp/string/basic string/end]]
[[zh:cpp/string/basic string/end]]</text>
      <sha1>iki0czrye0cvefk1wc57wn96c0vgt73</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/erase</title>
    <ns>0</ns>
    <id>1404</id>
    <revision>
      <id>66403</id>
      <parentid>63701</parentid>
      <timestamp>2013-11-19T19:57:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exception guarantees per 21.4.1[string.require]</comment>
      <text xml:space="preserve" bytes="2319">{{cpp/string/basic_string/title | erase}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_string&amp; erase( size_type index {{=}} 0, size_type count {{=}} npos );
}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
iterator erase( iterator position );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator position );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator erase( iterator first, iterator last );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator first, const_iterator last );
}}
{{dcl rev end}}
{{dcl end}}

Removes specified characters from the string. 

@1@ Removes ''min(''{{tt|count}}, {{lc|size()}}{{tt| - index}}'')'' characters starting at {{tt|index}}.

@2@ Removes the character at {{tt|position}}.

@3@ Removes the character in the range {{tt|[first; last)}}.

===Parameters===
{{par begin}}
{{par | index | first character to remove}}
{{par | count | number of characters to remove}}
{{par | position | iterator to the character to remove}}
{{par | first, last | range of the characters to remove}}
{{par end}} 

===Return value===
@1@ {{c|*this}}

@2-3@ iterator following the last removed character.

===Exceptions===
@1@ {{lc|std::out_of_range}} if {{c|index &gt; size()}}.
@2-3@ (none)

{{rev inl|since=c++11|
In any case, if an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

===Example===
{{example|
|code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;string&gt;
int main ()
{
    std::string s = &quot;This is an example&quot;;
    std::cout &lt;&lt; s &lt;&lt; '\n';

    s.erase(0, 5); // Erase &quot;This &quot;
    std::cout &lt;&lt; s &lt;&lt; '\n';

    s.erase(std::find(s.begin(), s.end(), ' ')); // Erase ' '
    std::cout &lt;&lt; s &lt;&lt; '\n';

    s.erase(s.find(' ')); // Trim from ' ' to the end of the string
    std::cout &lt;&lt; s &lt;&lt; '\n';
}
|output=
This is an example
is an example
isan example
isan
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc clear}}
{{dsc end}}

[[de:cpp/string/basic string/erase]]
[[es:cpp/string/basic string/erase]]
[[fr:cpp/string/basic string/erase]]
[[it:cpp/string/basic string/erase]]
[[ja:cpp/string/basic string/erase]]
[[pl:cpp/string/basic string/erase]]
[[pt:cpp/string/basic string/erase]]
[[ru:cpp/string/basic string/erase]]
[[zh:cpp/string/basic string/erase]]</text>
      <sha1>4sxyb2axzun16gqd034xju219k7wf11</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/find</title>
    <ns>0</ns>
    <id>1405</id>
    <revision>
      <id>64798</id>
      <parentid>64146</parentid>
      <timestamp>2013-08-27T00:55:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix rev</comment>
      <text xml:space="preserve" bytes="3409">{{cpp/string/basic_string/title | find}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type find( const basic_string&amp; str, size_type pos = 0 ) const;
}}
{{dcl | num=2 | 1=
size_type find( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type find( const CharT* s, size_type pos = 0 ) const;
}}
{{dcl | num=4 | 1=
size_type find( CharT ch, size_type pos = 0 ) const;
}}
{{dcl end}}

Finds the first substring equal to the given character sequence. Search begins at {{tt|pos}}, i.e. the found substring must not begin in a position preceding {{tt|pos}}.

@1@ Finds the first substring equal to {{tt|str}}. If {{tt|str.size()}} is zero, returns {{tt|pos}}.

@2@ Finds the first substring equal to the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters. If {{tt|count}} is zero, returns {{tt|pos}}.

@3@ Finds the first substring equal to the character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. If the length of {{tt|s}} is zero, returns {{tt|pos}}.

@4@ Finds the first character {{tt|ch}}.

If {{c|1=pos &gt;= size()}}, the function always returns {{lc|npos}}.

===Parameters===
{{par begin}}
{{par | str | string to search for}}
{{par | pos | position at which to start the search}}
{{par | count | length of substring to search for}}
{{par | s | pointer to a character string to seach for}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the first character of the found substring or {{lc|npos}} if no such substring is found.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2,3,4@ (none)
}}
{{rev end}}

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;

void print(std::string::size_type n, std::string const &amp;s)
{
    if (n == std::string::npos) {
        std::cout &lt;&lt; &quot;not found\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;found: &quot; &lt;&lt; s.substr(n) &lt;&lt; '\n';
    }
}

int main()
{
    std::string::size_type n;
    std::string const s = &quot;This is a string&quot;;

    // search from beginning of string
    n = s.find(&quot;is&quot;);
    print(n, s);

    // search from position 5
    n = s.find(&quot;is&quot;, 5);
    print(n, s);

    // find a single character
    n = s.find('a');
    print(n, s);

    // find a single character
    n = s.find('q');
    print(n, s);
}
 | output=
found: is is a string
found: is a string
found: a string
not found
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strstr}}
{{dsc inc | cpp/string/wide/dsc wcsstr}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}
{{dsc inc | cpp/algorithm/dsc search}}
{{dsc end}}

[[de:cpp/string/basic string/find]]
[[es:cpp/string/basic string/find]]
[[fr:cpp/string/basic string/find]]
[[it:cpp/string/basic string/find]]
[[ja:cpp/string/basic string/find]]
[[pt:cpp/string/basic string/find]]
[[ru:cpp/string/basic string/find]]
[[zh:cpp/string/basic string/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/find first not of</title>
    <ns>0</ns>
    <id>1406</id>
    <revision>
      <id>64804</id>
      <parentid>64145</parentid>
      <timestamp>2013-08-27T00:56:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix rev</comment>
      <text xml:space="preserve" bytes="2709">{{cpp/string/basic_string/title | find_first_not_of}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type find_first_not_of( const basic_string&amp; str, size_type pos = 0 ) const;
}}
{{dcl | num=2 | 1=
size_type find_first_not_of( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type find_first_not_of( const CharT* s, size_type pos = 0 ) const;
}}
{{dcl | num=4 | 1=
size_type find_first_not_of( CharT ch, size_type pos = 0 ) const;
}}
{{dcl end}}

Finds the first character equal to none of the characters in the given character sequence. Search begins at {{tt|pos}}, i.e. the found character must not be in position preceding {{tt|pos}}.

@1@ Finds the first character equal to none of characters in {{tt|str}}. 

@2@ Finds the first character equal to none of characters in the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters.

@3@ Finds the first character equal to none of characters in character string pointed to by {{tt|s}}. The length of the string is determined by the first null character.

@4@ Finds the first character not equal to {{tt|ch}}.

===Parameters===
{{par begin}}
{{par | str | string identifying characters to search for}}
{{par | pos | position for the seach to start from}}
{{par | count | length of character string identifying characters to search for}}
{{par | s | pointer to a character string identifying characters to search for}}
{{par | ch | character identifying characters to search for}}
{{par end}} 

===Return value===
Position of the found character or {{lc|npos}} if no such character is found.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2,3,4@ (none)
}}
{{rev end}}

===Notes===
These functions use {{c|traits::eq()}} to test the characters for equality.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}
{{dsc end}}

[[de:cpp/string/basic string/find first not of]]
[[es:cpp/string/basic string/find first not of]]
[[fr:cpp/string/basic string/find first not of]]
[[it:cpp/string/basic string/find first not of]]
[[ja:cpp/string/basic string/find first not of]]
[[pt:cpp/string/basic string/find first not of]]
[[ru:cpp/string/basic string/find first not of]]
[[zh:cpp/string/basic string/find first not of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/find first of</title>
    <ns>0</ns>
    <id>1407</id>
    <revision>
      <id>64803</id>
      <parentid>64144</parentid>
      <timestamp>2013-08-27T00:56:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix rev</comment>
      <text xml:space="preserve" bytes="3257">{{cpp/string/basic_string/title | find_first_of}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type find_first_of( const basic_string&amp; str, size_type pos = 0 ) const;
}}
{{dcl | num=2 | 1=
size_type find_first_of( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type find_first_of( const CharT* s, size_type pos = 0 ) const;
}}
{{dcl | num=4 | 1=
size_type find_first_of( CharT ch, size_type pos = 0 ) const;
}}
{{dcl end}}

Finds the first character equal to one of characters in the given character sequence. Search begins at {{tt|pos}}, i.e. the found character must not be in position preceding {{tt|pos}}.

@1@ Finds the first character equal to one of characters in {{tt|str}}. 

@2@ Finds the first character equal to one of characters in the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters.

@3@ Finds the first character equal to one of characters in character string pointed to by {{tt|s}}. The length of the string is determined by the first null character.

@4@ Finds the first character equal to {{tt|ch}}.

===Parameters===
{{par begin}}
{{par | str | string identifying characters to search for}}
{{par | pos | position at which to begin searching}}
{{par | count | length of character string identifying characters to search for}}
{{par | s | pointer to a character string identifying characters to search for}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the found character or {{lc|npos}} if no such character is found.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2-4@ (none)
}}
{{rev end}}

===Notes===
{{c|traits::eq()}} is used to perform the comparison.

===Example===
{{example
 | code= #include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    // the test string
    std::string str = std::string(&quot;Hello World!&quot;);

    // strings and chars to search for
    std::string search_str = std::string(&quot;o&quot;);
    const char* search_cstr = &quot;Good Bye!&quot;;

    std::cout &lt;&lt; str.find_first_of(search_str) &lt;&lt; '\n';
    std::cout &lt;&lt; str.find_first_of(search_str, 5) &lt;&lt; '\n';
    std::cout &lt;&lt; str.find_first_of(search_cstr) &lt;&lt; '\n';
    std::cout &lt;&lt; str.find_first_of(search_cstr, 0, 4) &lt;&lt; '\n';
    // 'x' is not in &quot;Hello World', thus it will return std::string::npos
    std::cout &lt;&lt; str.find_first_of('x') &lt;&lt; '\n';
}
 | p=true
 | output=4
7
1
4
18446744073709551615
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}
{{dsc end}}

[[de:cpp/string/basic string/find first of]]
[[es:cpp/string/basic string/find first of]]
[[fr:cpp/string/basic string/find first of]]
[[it:cpp/string/basic string/find first of]]
[[ja:cpp/string/basic string/find first of]]
[[pt:cpp/string/basic string/find first of]]
[[ru:cpp/string/basic string/find first of]]
[[zh:cpp/string/basic string/find first of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/find last not of</title>
    <ns>0</ns>
    <id>1408</id>
    <revision>
      <id>64802</id>
      <parentid>64149</parentid>
      <timestamp>2013-08-27T00:56:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix rev</comment>
      <text xml:space="preserve" bytes="2679">{{cpp/string/basic_string/title | find_last_not_of}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type find_last_not_of( const basic_string&amp; str, size_type pos = npos ) const;
}}
{{dcl | num=2 | 1=
size_type find_last_not_of( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type find_last_not_of( const CharT* s, size_type pos = npos ) const;
}}
{{dcl | num=4 | 1=
size_type find_last_not_of( CharT ch, size_type pos = npos ) const;
}}
{{dcl end}}

Finds the last character equal to none of the characters in the given character sequence. Search begins at {{tt|pos}}, i.e. only the substring {{tt|[0, pos]}} is considered in the search. If {{lc|npos}} is passed as {{tt|pos}} whole string will be searched.

@1@ Finds the last character equal to none of characters in {{tt|str}}. 

@2@ Finds the last character equal to none of characters in the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters.

@3@ Finds the last character equal to none of characters in character string pointed to by {{tt|s}}. The length of the string is determined by the first null character.

@4@ Finds the last character not equal to {{tt|ch}}.

===Parameters===
{{par begin}}
{{par | str | string identifying characters to search for}}
{{par | pos | position at which to begin searching}}
{{par | count | length of character string identifying characters to search for}}
{{par | s | pointer to a character string identifying characters to search fo}}
{{par | ch | character identifying characters to search for}}
{{par end}} 

===Return value===
Position of the found character or {{lc|npos}} if no such character is found.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2,3,4@ (none)
}}
{{rev end}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc end}}

[[de:cpp/string/basic string/find last not of]]
[[es:cpp/string/basic string/find last not of]]
[[fr:cpp/string/basic string/find last not of]]
[[it:cpp/string/basic string/find last not of]]
[[ja:cpp/string/basic string/find last not of]]
[[pt:cpp/string/basic string/find last not of]]
[[ru:cpp/string/basic string/find last not of]]
[[zh:cpp/string/basic string/find last not of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/find last of</title>
    <ns>0</ns>
    <id>1409</id>
    <revision>
      <id>68216</id>
      <parentid>66695</parentid>
      <timestamp>2014-03-18T10:00:15Z</timestamp>
      <contributor>
        <ip>80.145.31.246</ip>
      </contributor>
      <text xml:space="preserve" bytes="2602">{{cpp/string/basic_string/title | find_last_of}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type find_last_of( const basic_string&amp; str, size_type pos = npos ) const;
}}
{{dcl | num=2 | 1=
size_type find_last_of( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type find_last_of( const CharT* s, size_type pos = npos ) const;
}}
{{dcl | num=4 | 1=
size_type find_last_of( CharT ch, size_type pos = npos ) const;
}}
{{dcl end}}

Finds the last character equal to one of characters in the given character sequence. Search begins at {{tt|pos}}, i.e. only the substring {{tt|[0, pos]}} is considered in the search. If {{lc|npos}} is passed as {{tt|pos}} whole string will be searched.

@1@ Finds the last character equal to one of characters in {{tt|str}}. 

@2@ Finds the last character equal to one of characters in the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters.

@3@ Finds the last character equal to one of characters in character string pointed to by {{tt|s}}. The length of the string is determined by the first null character.

@4@ Finds the last character equal to {{tt|ch}}.

===Parameters===
{{par begin}}
{{par | str | string identifying characters to search for}}
{{par | pos | position at which the search is to finish}}
{{par | count | length of character string identifying characters to search for}}
{{par | s | pointer to a character string identifying characters to search fo}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the found character or {{lc|npos}} if no such character is found.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2,3,4@ (none)
}}
{{rev end}}


===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}
{{dsc end}}

[[de:cpp/string/basic string/find last of]]
[[es:cpp/string/basic string/find last of]]
[[fr:cpp/string/basic string/find last of]]
[[it:cpp/string/basic string/find last of]]
[[ja:cpp/string/basic string/find last of]]
[[pt:cpp/string/basic string/find last of]]
[[ru:cpp/string/basic string/find last of]]
[[zh:cpp/string/basic string/find last of]]</text>
      <sha1>5timkm9hwcaqxe2w4ymo3tjofrem7iz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/front</title>
    <ns>0</ns>
    <id>1410</id>
    <revision>
      <id>70481</id>
      <parentid>70314</parentid>
      <timestamp>2014-05-24T02:07:30Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>print out the result</comment>
      <text xml:space="preserve" bytes="1241">{{cpp/string/basic_string/title | front}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
CharT&amp; front();
}}
{{dcl | since=c++11 |
const CharT&amp; front() const;
}}
{{dcl end}}

Returns reference to the first character in the string.

===Parameters===
(none)

===Return value===
reference to the first character, equivalent to {{c|at(0)}}.

===Complexity===
Constant

===Notes===
{{tt|front}} requires that {{c|!empty() {{==}} true}}, otherwise the result is undefined.

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;string&gt;
 
int main()
{
  {
    std::string s(&quot;Exemplary&quot;);
    char&amp; f = s.front();
    f = 'e';
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;exemplary&quot;
  }
 
  {
    std::string const c(&quot;Exemplary&quot;);
    char const&amp; f = c.front();
    std::cout &lt;&lt; &amp;f &lt;&lt; '\n'; // &quot;Exemplary&quot;
  }
}
| output=
exemplary
Exemplary
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc back}}
{{dsc end}}

[[de:cpp/string/basic string/front]]
[[es:cpp/string/basic string/front]]
[[fr:cpp/string/basic string/front]]
[[it:cpp/string/basic string/front]]
[[ja:cpp/string/basic string/front]]
[[pt:cpp/string/basic string/front]]
[[ru:cpp/string/basic string/front]]
[[zh:cpp/string/basic string/front]]</text>
      <sha1>grxf12og6n1rh84zatpj50zhbrel0rp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/get allocator</title>
    <ns>0</ns>
    <id>1411</id>
    <revision>
      <id>70120</id>
      <parentid>41657</parentid>
      <timestamp>2014-05-10T12:29:13Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="815">{{cpp/string/basic_string/title | get_allocator}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 
allocator_type get_allocator() const;
}}

Returns the allocator associated with the string.

===Parameters===
(none)

===Return value===
the associated allocator

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc allocator}}
{{dsc inc | cpp/memory/dsc allocator_traits}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/string/basic string/get allocator]]
[[es:cpp/string/basic string/get allocator]]
[[fr:cpp/string/basic string/get allocator]]
[[it:cpp/string/basic string/get allocator]]
[[ja:cpp/string/basic string/get allocator]]
[[pt:cpp/string/basic string/get allocator]]
[[ru:cpp/string/basic string/get allocator]]
[[zh:cpp/string/basic string/get allocator]]</text>
      <sha1>m22rqpd8q4j12ih23j41ynbytc0mkt9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/getline</title>
    <ns>0</ns>
    <id>2134</id>
    <revision>
      <id>67643</id>
      <parentid>62944</parentid>
      <timestamp>2014-02-15T15:37:00Z</timestamp>
      <contributor>
        <ip>178.12.17.179</ip>
      </contributor>
      <comment>Removed misleading &quot;and returns&quot; which would imply that the execution of the function end here which would be wrong according to the standard.</comment>
      <text xml:space="preserve" bytes="4219">{{cpp/title|getline}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 |
template&lt; class CharT, class Traits, class Allocator &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; getline( std::basic_istream&lt;CharT,Traits&gt;&amp; input,
                                           std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; str,
                                           CharT delim );
}}
{{dcl | num=1 | since=c++11 |
template&lt; class CharT, class Traits, class Allocator &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; getline( std::basic_istream&lt;CharT,Traits&gt;&amp;&amp; input,
                                           std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; str,
                                           CharT delim );
}}
{{dcl | num=2 |
template&lt; class CharT, class Traits, class Allocator &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; getline( std::basic_istream&lt;CharT,Traits&gt;&amp; input,
                                           std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; str );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class CharT, class Traits, class Allocator &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; getline( std::basic_istream&lt;CharT,Traits&gt;&amp;&amp; input,
                                           std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; str );
}}
{{dcl end}}

{{tt|getline}} reads characters from an input stream and places them into a string:

@1@ Behaves as {{concept|UnformattedInputFunction}}, except that {{tt|input.gcount()}} is not affected. After constructing and checking the sentry object, performs the following:
:@1@ Calls {{c|str.erase()}}
:@2@ Extracts characters from {{tt|input}} and appends them to {{tt|str}} until one of the following occurs (checked in the order listed)
::@a@ end-of-file condition on {{tt|input}}, in which case, {{tt|getline}} sets {{ltt|cpp/io/ios_base/iostate|eofbit}}.
::@b@ the next available input character is {{tt|delim}}, as tested by {{c|Traits::eq(c, delim)}}, in which case the delimiter character is extracted from {{tt|input}}, but is not appended to {{tt|str}}.
::@c@ {{c|str.max_size()}} characters have been stored, in which case {{tt|getline}} sets {{ltt|cpp/io/ios_base/iostate|failbit}} and returns.
:@3@ If no characters were extracted for whatever reason (not even the discarded delimiter), {{tt|getline}} sets {{ltt|cpp/io/ios_base/iostate|failbit}} and returns.

@2@ Same as {{c|getline(input, str, input.widen(’\n’))}}, that is, the default delimiter is the endline character.

===Parameters===
{{par begin}}
{{par | input | the stream to get data from}}
{{par | str | the string to put the data into}}
{{par | delim | the delimiter character}}
{{par end}}

===Return value===
{{tt|input}}

===Notes===
When used immediately after whitespace-delimited input, e.g. after {{c|int n; std::cin &gt;&gt; n;}}, {{tt|getline}} consumes the endline character left on the input stream by [[cpp/io/basic_istream/operator_gtgt|operator&gt;&gt;]], and returns immediately. A common solution is to ignore all leftover characters on the line of input with {{c|cin.ignore(std::numeric_limits&lt;std::streamsize&gt;::max(), '\n');}} before switching to line-oriented input.

===Example===
{{example
 | p=true
 | The following example demonstrates how to use {{tt|getline}} function to read user's input and how to process file line by line.
 | code=#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;sstream&gt;
 
int main()
{
    // greet the user
    std::string name;
    std::cout &lt;&lt; &quot;What is your name? &quot;;
    std::getline(std::cin, name);
    std::cout &lt;&lt; &quot;Hello &quot; &lt;&lt; name &lt;&lt; &quot;, nice to meet you.\n&quot;;
 
    // read file line by line
    std::istringstream input;
    input.str(&quot;1\n2\n3\n4\n5\n6\n7\n&quot;);
    int sum = 0;
    for (std::string line; std::getline(input, line); ) {
        sum += std::stoi(line);
    }
    std::cout &lt;&lt; &quot;\nThe sum is: &quot; &lt;&lt; sum &lt;&lt; &quot;\n&quot;;
}
 | p=true | output=
What is your name? John Q. Public
Hello John Q. Public, nice to meet you.

The sum is 28
}}

[[de:cpp/string/basic string/getline]]
[[es:cpp/string/basic string/getline]]
[[fr:cpp/string/basic string/getline]]
[[it:cpp/string/basic string/getline]]
[[ja:cpp/string/basic string/getline]]
[[pt:cpp/string/basic string/getline]]
[[ru:cpp/string/basic string/getline]]
[[zh:cpp/string/basic string/getline]]</text>
      <sha1>hzm461ay1zi8556v6ltmt6yp5itbw2k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/hash</title>
    <ns>0</ns>
    <id>5521</id>
    <revision>
      <id>62945</id>
      <parentid>58922</parentid>
      <timestamp>2013-07-01T23:47:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1222">{{cpp/title|hash &lt;small&gt;(std::string, std::wstring, std::u16string, std::u32string)&lt;/small&gt;}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | since=c++11 | 1=
template&lt;&gt; struct hash&lt;std::string&gt;;
template&lt;&gt; struct hash&lt;std::wstring&gt;;
template&lt;&gt; struct hash&lt;std::u16string&gt;;
template&lt;&gt; struct hash&lt;std::u32string&gt;;
}}
{{dcl end}}

The template specializations of {{lc|std::hash}} for the various string classes allow users to obtain hashes of strings.

===Example===
{{example
 | The following code shows one possible output of a hash function used on a string:
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;functional&gt;
 
int main()
{
    std::string s = &quot;Stand back! I've got jimmies!&quot;;
    std::hash&lt;std::string&gt; hash_fn;

    size_t hash = hash_fn(s);

    std::cout &lt;&lt; hash &lt;&lt; '\n';
}
 | output=
325378910
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

[[de:cpp/string/basic string/hash]]
[[es:cpp/string/basic string/hash]]
[[fr:cpp/string/basic string/hash]]
[[it:cpp/string/basic string/hash]]
[[ja:cpp/string/basic string/hash]]
[[pt:cpp/string/basic string/hash]]
[[ru:cpp/string/basic string/hash]]
[[zh:cpp/string/basic string/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/insert</title>
    <ns>0</ns>
    <id>1412</id>
    <revision>
      <id>70342</id>
      <parentid>69735</parentid>
      <timestamp>2014-05-20T04:08:05Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Add example</comment>
      <text xml:space="preserve" bytes="7905">{{cpp/string/basic_string/title | insert}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_string&amp; insert( size_type index, size_type count, CharT ch );
}}
{{dcl | num=2 |
basic_string&amp; insert( size_type index, const CharT* s );
}}
{{dcl | num=3 |
basic_string&amp; insert( size_type index, const CharT* s, size_type count );
}}
{{dcl | num=4 |
basic_string&amp; insert( size_type index, const basic_string&amp; str );
}}
{{dcl rev begin | num=5 }}
{{dcl | until=c++14 |
basic_string&amp; insert( size_type index, const basic_string&amp; str,
                      size_type index_str, size_type count );
}}
{{dcl | since=c++14 |
basic_string&amp; insert( size_type index, const basic_string&amp; str,
                      size_type index_str, size_type count {{=}} npos);
}}
{{dcl rev end}}
{{dcl rev begin | num=6 }}
{{dcl | until=c++11 |
iterator insert( iterator pos, CharT ch );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator pos, CharT ch );
}}
{{dcl rev end}}
{{dcl rev begin | num=7 }}
{{dcl | until=c++11 |
void insert( iterator pos, size_type count, CharT ch );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator pos, size_type count, CharT ch );
}}
{{dcl rev end}}
{{dcl rev begin | num=8}}
{{dcl | until=c++11 |
template&lt; class InputIt &gt;
void insert( iterator pos, InputIt first, InputIt last );
}}
{{dcl | since=c++11 |
template&lt; class InputIt &gt;
iterator insert( const_iterator pos, InputIt first, InputIt last );
}}
{{dcl rev end}}
{{dcl | num=9 | since=c++11 |
iterator insert( const_iterator pos, std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Inserts characters into the string.

@1@ Inserts {{tt|count}} copies of character {{tt|ch}} at the position {{tt|index}}

@2@ Inserts null-terminated character string pointed to by {{tt|s}} at the position {{tt|index}}. The length of the string is determined by the first null character (effectively calls {{c|Traits::length(s)}}. 

@3@ Inserts the first {{tt|count}} characters from the character string pointed to by {{tt|s}} at the position {{tt|index}}. {{tt|s}} can contain null characters.

@4@ Inserts string {{tt|str}} at the position {{tt|index}}

@5@ Inserts a string, obtained by {{c|str.substr(index_str, count)}} at the position {{tt|index}}

@6@ Inserts character {{tt|ch}} before the character pointed by {{tt|pos}}

@7@ Inserts {{tt|count}} copies of character {{tt|ch}} before the element pointed by {{tt|pos}}

@8@ Inserts characters from the range {{tt|[first, last)}} before the element pointed by {{tt|pos}}. {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}

@9@ Inserts elements from initializer list {{tt|ilist}} before the element pointed by {{tt|pos}}

===Parameters===
{{par begin}}
{{par | index | position at which the content will be inserted}}
{{par | pos | iterator before which the characters will be inserted}}
{{par | ch | character to insert}}
{{par | count | number of characters to insert}}
{{par | s | pointer to the character string to insert}}
{{par | str | string to insert}}
{{par | first, last | range defining characters to insert}}
{{par | index_str | position of the first character in the string {{tt|str}} to insert}}
{{par | ilist | initializer list to insert the characters from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
@1-5@ {{c|*this}}

@6-9@ An iterator which refers to the copy of the first inserted character or {{tt|pos}} if no characters were inserted ({{tt|count{{==}}0}} or {{tt|first{{==}}last}} or {{tt|ilist.size(){{==}}0}})

===Exceptions===
@1@ {{lc|std::out_of_range}} if {{c|index &gt; size()}} and {{lc|std::length_error}} if {{c|size() + count &gt; max_size()}}.

@2@ {{lc|std::out_of_range}} if {{c|index &gt; size()}} and {{lc|std::length_error}} if {{c|size() + Traits::length(s) &gt; max_size()}}.

@3@ {{lc|std::out_of_range}} if {{c|index &gt; size()}} and {{lc|std::length_error}} if {{c|size() + count &gt; max_size()}}.

@4@ Throws exceptions on the following conditions:
:@a@ {{lc|std::out_of_range}} if {{c|index &gt; size()}}.
:@b@ {{lc|std::length_error}} if {{c|size() + str.size() &gt; max_size()}} where {{tt|ins_count}} is the number of characters that will be inserted.

@5@ Throws exceptions on the following conditions:
:@a@ {{lc|std::out_of_range}} if {{c|index &gt; size()}}.
:@b@ {{lc|std::out_of_range}} if {{c|index_str &gt; str.size()}}.
:@c@ {{lc|std::length_error}} if {{c|size() + ins_count &gt; max_size()}} where {{tt|ins_count}} is the number of characters that will be inserted.

@6-9@ (none)

{{rev inl|since=c++11|
In any case, if an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

===Example===
{{example
|Until C++
|code=
#include &lt;cassert&gt;
#include &lt;string&gt;

int main()
{
    std::string s(&quot;xmplr&quot;);

    // insert(size_type index, size_type count, char ch)
    s.insert(0, 1, 'E');
    assert(&quot;Exmplr&quot; == s);

    // insert(size_type index, char* s)
    s.insert(2, &quot;e&quot;);
    assert(&quot;Exemplr&quot; == s);

    // insert(size_type index, string const&amp; str)
    s.insert(6, std::string(&quot;a&quot;));
    assert(&quot;Exemplar&quot; == s);

    // insert(size_type index, string const&amp; str,
    //     size_type index_str, size_type count)
    s.insert(8, std::string(&quot; is an example string.&quot;), 0, 14);
    assert(&quot;Exemplar is an example&quot; == s);

    // insert(iterator pos, char ch)
    s.insert(s.begin() + s.find_first_of('n') + 1, ':');
    assert(&quot;Exemplar is an: example&quot; == s);

    // insert(iterator pos, size_type count, char ch)
    s.insert(s.begin() + s.find_first_of(':') + 1, 2, '=');
    assert(&quot;Exemplar is an:== example&quot; == s);

    // insert(iterator pos, InputIt first, InputIt last)
    {
        std::string const seq(&quot; suitable&quot;);
        s.insert(s.begin() + s.find_last_of('=') + 1,
            seq.begin(), seq.end());
        assert(&quot;Exemplar is an:== suitable example&quot; == s);
    }
}
|output=
}}
{{example
|C++11
|code=
#include &lt;cassert&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
    std::string s{ &quot;xmplr&quot; };

    // insert(size_type index, size_type count, char ch)
    s.insert(0, 1, 'E');
    assert(&quot;Exmplr&quot; == s);

    // insert(size_type index, char* s)
    s.insert(2, &quot;e&quot;);
    assert(&quot;Exemplr&quot; == s);

    // insert(size_type index, string const&amp; str)
    s.insert(6, std::string(&quot;a&quot;));
    assert(&quot;Exemplar&quot; == s);

    // insert(size_type index, string const&amp; str,
    //     size_type index_str, size_type count)
    s.insert(8, std::string(&quot; is an example string.&quot;), 0, 14);
    assert(&quot;Exemplar is an example&quot; == s);

    // insert(const_iterator pos, char ch)
    s.insert(s.cbegin() + s.find_first_of('n') + 1, ':');
    assert(&quot;Exemplar is an: example&quot; == s);

    // insert(const_iterator pos, size_type count, char ch)
    s.insert(s.cbegin() + s.find_first_of(':') + 1, 2, '=');
    assert(&quot;Exemplar is an:== example&quot; == s);

    // insert(const_iterator pos, InputIt first, InputIt last)
    {
        std::string const seq{ &quot; string&quot; };
        s.insert(s.begin() + s.find_last_of('e') + 1,
            std::begin(seq), std::end(seq));
        assert(&quot;Exemplar is an:== example string&quot; == s);
    }

    // insert(const_iterator pos, std::initializer_list&lt;char&gt;)
    {
        std::initializer_list&lt;char&gt; const period = { '.' };
        s.insert(s.cbegin() + s.find_first_of('g') + 1, period);
        assert(&quot;Exemplar is an:== example string.&quot; == s);
    }
}
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc append}}
{{dsc inc | cpp/string/basic_string/dsc push_back}}
{{dsc end}}

[[de:cpp/string/basic string/insert]]
[[es:cpp/string/basic string/insert]]
[[fr:cpp/string/basic string/insert]]
[[it:cpp/string/basic string/insert]]
[[ja:cpp/string/basic string/insert]]
[[pt:cpp/string/basic string/insert]]
[[ru:cpp/string/basic string/insert]]
[[zh:cpp/string/basic string/insert]]</text>
      <sha1>9iivwn6vilfkohnqwl3k9yhw8rudl34</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/length</title>
    <ns>0</ns>
    <id>1413</id>
    <redirect title="cpp/string/basic string/size" />
    <revision>
      <id>39665</id>
      <parentid>34633</parentid>
      <timestamp>2012-09-21T12:21:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/basic string/size]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/string/basic_string/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/max size</title>
    <ns>0</ns>
    <id>1414</id>
    <revision>
      <id>70484</id>
      <parentid>70326</parentid>
      <timestamp>2014-05-24T02:31:25Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>p=true</comment>
      <text xml:space="preserve" bytes="1199">{{cpp/string/basic_string/title | max_size}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
size_type max_size() const;
}}
{{dcl end}}

Returns the maximum number of elements the string is able to hold due to system or library implementation limitations, i.e. ​{{c|std::distance(begin(), end())}}​ for the largest string. 

===Parameters===
(none)

===Return value===
Maximum number of characters

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

===Complexity===
Constant.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string s;
    std::cout &lt;&lt; &quot;Maximum size of a string is &quot; &lt;&lt; s.max_size() &lt;&lt; &quot;\n&quot;;
}
|p=true
|output=Maximum size of a string is 4294967294
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc end}}

[[de:cpp/string/basic string/max size]]
[[es:cpp/string/basic string/max size]]
[[fr:cpp/string/basic string/max size]]
[[it:cpp/string/basic string/max size]]
[[ja:cpp/string/basic string/max size]]
[[pt:cpp/string/basic string/max size]]
[[ru:cpp/string/basic string/max size]]
[[zh:cpp/string/basic string/max size]]</text>
      <sha1>hsbdqxg31ux5ajtzkh7hihtcrona7ae</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/npos</title>
    <ns>0</ns>
    <id>1415</id>
    <revision>
      <id>41647</id>
      <parentid>36472</parentid>
      <timestamp>2012-11-02T18:29:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.3) (Robot: Adding de, es, fr, it, ja, zh</comment>
      <text xml:space="preserve" bytes="1321">{{cpp/string/basic_string/title | npos}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 1=
static const size_type npos = -1;
}}

This is a special value equal to the maximum value representable by the type {{tt|size_type}}. The exact meaning depends on context, but it is generally used either as end of string indicator by the functions that expect a string index or as the error indicator by the functions that return a string index.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;
#include &lt;string&gt;

int main()
{
    // string search functions return npos if nothing is found
    std::string s = &quot;test&quot;;
    if(s.find('a') == std::string::npos)
        std::cout &lt;&lt; &quot;no 'a' in 'test'\n&quot;;

    // functions that take string subsets as arguments 
    // use npos as the &quot;all the way to the end&quot; indicator
    std::string s2(s, 2, std::string::npos);
    std::cout &lt;&lt; s2 &lt;&lt; '\n';

    std::bitset&lt;5&gt; b(&quot;aaabb&quot;, std::string::npos, 'a', 'b');
    std::cout &lt;&lt; b &lt;&lt; '\n';
}
 | output =
no 'a' in 'test'
st
00011
}}

[[de:cpp/string/basic string/npos]]
[[es:cpp/string/basic string/npos]]
[[fr:cpp/string/basic string/npos]]
[[it:cpp/string/basic string/npos]]
[[ja:cpp/string/basic string/npos]]
[[pt:cpp/string/basic string/npos]]
[[ru:cpp/string/basic string/npos]]
[[zh:cpp/string/basic string/npos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator&quot;&quot;s</title>
    <ns>0</ns>
    <id>12914</id>
    <revision>
      <id>67696</id>
      <parentid>67630</parentid>
      <timestamp>2014-02-21T12:23:52Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2070">{{cpp/title|n=literals::string_literals::|operator&quot;&quot;s }}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++14 | 1=
string operator &quot;&quot; s(const char *str, std::size_t len);
}}
{{dcl | num=2 | since=c++14 | 1=
u16string operator &quot;&quot; s(const char16_t *str, std::size_t len);
}}
{{dcl | num=3 | since=c++14 | 1=
u32string operator &quot;&quot; s(const char32_t *str, std::size_t len);
}}
{{dcl | num=4 | since=c++14 | 1=
wstring operator &quot;&quot; s(const wchar_t *str, std::size_t len);
}}
{{dcl end}}

Forms a string literal of the desired type.

@1@ returns {{c|std::string{str, len} }}
@2@ returns {{c|std::u16string{str, len} }}
@3@ returns {{c|std::u32string{str, len} }}
@4@ returns {{c|std::wstring{str, len} }}

===Parameters===
{{par begin}}
{{par | str | pointer to the beginning of the raw character array literal}}
{{par | len | length of the raw character array literal}}
{{par end}}

===Return value===
The string literal.

===Notes===
These operators are declared in the namespace {{tt|std::literals::string_literals}}, where both {{tt|literals}} and {{tt|string_literals}} are inline namespaces.

{{lc|std::chrono::duration}} also defines {{tt|operator&quot;&quot;s}}, to represent literal seconds, but it is an integer literal: {{c|10s}} is ten seconds, but {{c|&quot;10&quot;s}} is a string.

===Example===
{{example
| code=
#include &lt;string&gt;

int main()
{
    //no need to write 'using namespace std::literals::string_literals'
    using namespace std::string_literals;

    std::string s2 = &quot;abc\0\0def&quot;; // forms the string &quot;abc&quot;
    std::string s1 = &quot;abc\0\0def&quot;s; // form the string &quot;abc\0\0def&quot;
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc constructor}}
{{dsc end}}

[[de:cpp/string/basic string/operator&quot;&quot;s]]
[[es:cpp/string/basic string/operator&quot;&quot;s]]
[[fr:cpp/string/basic string/operator&quot;&quot;s]]
[[it:cpp/string/basic string/operator&quot;&quot;s]]
[[ja:cpp/string/basic string/operator&quot;&quot;s]]
[[pt:cpp/string/basic string/operator&quot;&quot;s]]
[[ru:cpp/string/basic string/operator&quot;&quot;s]]
[[zh:cpp/string/basic string/operator&quot;&quot;s]]</text>
      <sha1>ryb7psga2mj9e8la1sph4mkpman64f2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator+</title>
    <ns>0</ns>
    <id>5077</id>
    <revision>
      <id>62946</id>
      <parentid>58927</parentid>
      <timestamp>2013-07-01T23:47:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="4512">{{cpp/title | operator+{{dsc small|(std::basic_string)}}}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs,
                   const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( const CharT* lhs,
                   const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( CharT lhs,
                   const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs,
                   const CharT* rhs );
}}
{{dcl | num=5 | 1=
template&lt;class CharT, class Traits, class Alloc&gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs,
                   CharT rhs );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; lhs,
                   const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=7 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs,
                   basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; rhs );
}}
{{dcl | num=8 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; lhs,
                   basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; rhs );
}}
{{dcl | num=9 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+(const CharT* lhs,
                  basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; rhs );
}}
{{dcl | num=10 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( CharT lhs,
                   basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; rhs );
}}
{{dcl | num=11 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; lhs,
                   const CharT* rhs );
}}
{{dcl | num=12 | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
    basic_string&lt;CharT,Traits,Alloc&gt;
        operator+( basic_string&lt;CharT,Traits,Alloc&gt;&amp;&amp; lhs,
                   CharT rhs );
}}
{{dcl end}}

Returns a string containing characters from {{tt|lhs}} followed by the characters from {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs | string, character, or pointer to the first character in a null-terminated array }}
{{par | rhs | string, character, or pointer to the first character in a null-terminated array }}
{{par end}} 

===Return value===

1) {{c|basic_string&lt;CharT,Traits,Alloc&gt;(lhs).append(rhs)}}

2) {{c|basic_string&lt;CharT,Traits,Alloc&gt;(lhs) + rhs}}

3) {{c|basic_string&lt;CharT,Traits,Alloc&gt;(1,lhs) + rhs}}

4) {{c|lhs + basic_string&lt;CharT,Traits,Alloc&gt;(rhs)}}

5) {{c|lhs + basic_string&lt;CharT,Traits,Alloc&gt;(1,rhs)}}

6) {{c|std::move(lhs.append(rhs))}}

7) {{c|std::move(rhs.insert(0, lhs))}}

8) {{c|std::move(lhs.append(rhs))}} or {{c|std::move(rhs.insert(0, lhs))}}

9) {{c|std::move(rhs.insert(0, lhs))}}

10) {{c|std::move(rhs.insert(0, 1, lhs))}}

11) {{c|std::move(lhs.append(rhs))}}

12) {{c|std::move(lhs.append(1, rhs))}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string s1 = &quot;Hello&quot;;
    std::string s2 = &quot;world&quot;;
    std::cout &lt;&lt; s1 + ' ' + s2 + &quot;!\n&quot;;
}
 | output=
Hello world!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc operator+{{=}}}}
{{dsc inc | cpp/string/basic_string/dsc append}}
{{dsc inc | cpp/string/basic_string/dsc insert}}
{{dsc end}}

[[de:cpp/string/basic string/operator+]]
[[es:cpp/string/basic string/operator+]]
[[fr:cpp/string/basic string/operator+]]
[[it:cpp/string/basic string/operator+]]
[[ja:cpp/string/basic string/operator+]]
[[pt:cpp/string/basic string/operator+]]
[[ru:cpp/string/basic string/operator+]]
[[zh:cpp/string/basic string/operator+]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator+=</title>
    <ns>0</ns>
    <id>1416</id>
    <revision>
      <id>67193</id>
      <parentid>66406</parentid>
      <timestamp>2014-01-26T07:33:48Z</timestamp>
      <contributor>
        <ip>221.237.157.116</ip>
      </contributor>
      <text xml:space="preserve" bytes="2259">{{cpp/string/basic_string/title | operator+{{=}}}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
basic_string&amp; operator+=( const basic_string&amp; str );
}}
{{dcl | num=2 | 1=
basic_string&amp; operator+=( CharT ch );
}}
{{dcl | num=3 | 1=
basic_string&amp; operator+=( const CharT* s );
}}
{{dcl | num=4 | since=c++11 | 1=
basic_string&amp; operator+=( std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Appends addinional characters to the string.

1) Appends string {{tt|str}}

2) Appends character {{tt|ch}}

3) Appends the null-terminated character string pointed to by {{tt|s}}. 

4) Appends characters in the initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | ch | character value to append}}
{{par | str | string to append}}
{{par | s | pointer to a null-terminated character string to append}}
{{par | init | initializer list with the characters to append}}
{{par end}} 

===Return value===
{{c|*this}}

===Complexity===

1) linear in size of {{tt|str}}

2) constant

3) linear in size of {{tt|s}}

4) linear in size of {{tt|init}}

===Exceptions===
{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

If the operation would result in {{tt|size() &gt; max_size()}}, throws {{lc|std::length_error}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
   std::string str;
   str.reserve(50); //reserves sufficient storage space to avoid memory reallocation
   std::cout &lt;&lt; str &lt;&lt; '\n'; //empty string

   str += &quot;This&quot;;
   std::cout &lt;&lt; str &lt;&lt; '\n';

   str += std::string(&quot; is &quot;);
   std::cout &lt;&lt; str &lt;&lt; '\n';

   str += 'a';
   std::cout &lt;&lt; str &lt;&lt; '\n';

   str += {' ','s','t','r','i','n','g','.'};
   std::cout &lt;&lt; str &lt;&lt; '\n';
}

 | output=

This
This is
This is a
This is a string.
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc assign}}
{{dsc end}}

[[de:cpp/string/basic string/operator+=]]
[[es:cpp/string/basic string/operator+=]]
[[fr:cpp/string/basic string/operator+=]]
[[it:cpp/string/basic string/operator+=]]
[[ja:cpp/string/basic string/operator+=]]
[[pt:cpp/string/basic string/operator+=]]
[[ru:cpp/string/basic string/operator+=]]
[[zh:cpp/string/basic string/operator+=]]</text>
      <sha1>luu9h6ht07ssnjoq66gu31hwkqk4f1c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator=</title>
    <ns>0</ns>
    <id>1417</id>
    <revision>
      <id>70762</id>
      <parentid>68742</parentid>
      <timestamp>2014-05-29T23:22:19Z</timestamp>
      <contributor>
        <ip>173.252.71.189</ip>
      </contributor>
      <comment>noexcept movector</comment>
      <text xml:space="preserve" bytes="2662">{{cpp/string/basic_string/title | operator{{=}}}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
basic_string&amp; operator=( const basic_string&amp; str );
}}
{{dcl | num=2 | since=c++11 | 1=
basic_string&amp; operator=( basic_string&amp;&amp; str ) noexcept;
}}
{{dcl | num=3 | 1=
basic_string&amp; operator=( const CharT* s );
}}
{{dcl | num=4 | 1=
basic_string&amp; operator=( CharT ch );
}}
{{dcl | num=5 | since=c++11 | 1=
basic_string&amp; operator=( std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Replaces the contents of the string.

@1@ Replaces the contents with a copy of {{tt|str}}. If {{tt|*this}} and {{tt|str}} are the same object, this function has no effect.
@2@ Replaces the contents with those of {{tt|str}} using move semantics. Leaves {{tt|str}} in valid, but inspecified state. The behavior is undefined if {{tt|*this}} and {{tt|str}} are the same object.
@3@ Replaces the contents with those of null-terminated character string pointed to by {{tt|s}} as if by {{c|*this {{=}} basic_string(s)}}, which involves a call to {{c|Traits::length(s)}}.
@4@ Replaces the contents with character {{tt|ch}} as if by {{c|*this {{=}} basic_string(1,c)}}
@5@ Replaces the contents with those of the initializer list {{tt|ilist}} as if by {{c|*this {{=}} basic_string(ilist)}}

===Parameters===
{{par begin}}
{{par | ch | value to initialize characters of the string with}}
{{par | str | string to be used as source to initialize the string with}}
{{par | s | pointer to a null-terminated character string &lt;br&gt;to use as source to initialize the string with}}
{{par | init | initializer list to initialize the string with}}
{{par end}} 

===Return value===
{{c|*this}}

===Complexity===

1) linear in size of {{tt|str}}

2) constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

3) linear in size of {{tt|s}}

4) constant.

5) linear in size of {{tt|init}}

===Exceptions===
{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

If the operation would result in {{tt|size() &gt; max_size()}}, throws {{lc|std::length_error}}.
 
===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc constructor}}
{{dsc inc | cpp/string/basic_string/dsc assign}}
{{dsc end}}

[[de:cpp/string/basic string/operator=]]
[[es:cpp/string/basic string/operator=]]
[[fr:cpp/string/basic string/operator=]]
[[it:cpp/string/basic string/operator=]]
[[ja:cpp/string/basic string/operator=]]
[[pt:cpp/string/basic string/operator=]]
[[ru:cpp/string/basic string/operator=]]
[[zh:cpp/string/basic string/operator=]]</text>
      <sha1>2k4xm06ow4cjacqwulkedb13sl59no9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator at</title>
    <ns>0</ns>
    <id>1418</id>
    <revision>
      <id>70490</id>
      <parentid>70480</parentid>
      <timestamp>2014-05-24T04:31:28Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>syntax</comment>
      <text xml:space="preserve" bytes="1739">{{cpp/string/basic_string/title | operator[]}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
reference       operator[]( size_type pos );
}}
{{dcl | 
const_reference operator[]( size_type pos ) const;
}}
{{dcl end}}

Returns a reference to the character at specified location {{tt|pos}}. No bounds checking is performed.

{{rev begin}}
{{rev | until=c++11 |
@1@ If {{c|1=pos == size()}}, the behavior is undefined.
@2@ If {{c|1=pos == size()}}, a reference to the character with value {{c|CharT()}} (the null character) is returned.
}}
{{rev | since=c++11 |
If {{c|1=pos == size()}}, a reference to the character with value {{c|CharT()}} (the null character) is returned. 

For the first (non-const) version, the behavior is undefined if this character is modified.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | pos | position of the character to return}}
{{par end}}

===Return value===
Reference to the requested character.

===Complexity===
Constant.

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;string&gt;
 
int main()
{
  {
    std::string const c(&quot;Exemplar&quot;);
    for (unsigned i = 7;i != 0; i/=2)
        std::cout &lt;&lt; c[i];
  }
    std::cout &lt;&lt; '\n';
  {
    std::string s(&quot;Exemplar &quot;);
    s[s.size()-1] = 'y';
    std::cout &lt;&lt; s;
  }
}
| output=
rmx
Exemplary
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc at}}
{{dsc end}}

[[de:cpp/string/basic string/operator at]]
[[es:cpp/string/basic string/operator at]]
[[fr:cpp/string/basic string/operator at]]
[[it:cpp/string/basic string/operator at]]
[[ja:cpp/string/basic string/operator at]]
[[pt:cpp/string/basic string/operator at]]
[[ru:cpp/string/basic string/operator at]]
[[zh:cpp/string/basic string/operator at]]</text>
      <sha1>nqbe0q00lj5akdxb65jz22bwpxfo8bl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator cmp</title>
    <ns>0</ns>
    <id>5485</id>
    <revision>
      <id>64835</id>
      <parentid>64143</parentid>
      <timestamp>2013-08-27T01:19:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="4802">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::basic_string)&lt;/small&gt;}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl h | Compare two {{tt|basic_string}} objects}}
{{dcl | num=1 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator==( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                 const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator!=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                 const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                 const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=5 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=6 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, 
                 const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl h | Compare a {{tt|basic_string}} object and null-terminated array of {{tt|T}}}}
{{dcl | num=7 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator==( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=7 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator==( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, const CharT* rhs );
}}
{{dcl | num=8 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator!=( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=8 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator!=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, const CharT* rhs );
}}
{{dcl | num=9 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=9 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs,  const CharT* rhs );
}}
{{dcl | num=10 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;=( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=10 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&lt;=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, const CharT* rhs );
}}
{{dcl | num=11 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=11 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, const CharT* lhs );
}}
{{dcl | num=12 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;=( const CharT* lhs, const basic_string&lt;CharT,Traits,Alloc&gt;&amp; rhs );
}}
{{dcl | num=12 | 1=
template&lt; class CharT, class traits, class Alloc &gt;
bool operator&gt;=( const basic_string&lt;CharT,Traits,Alloc&gt;&amp; lhs, const CharT* rhs );
}}
{{dcl end}}

Compares the contents of a string with another string or a null-terminated array of {{tt|CharT}}.

All comparisons are done via the {{lc|compare()}} member function (which itself is defined in terms of {{tt|Traits::compare()}}):

* Two strings are equal if both the size of {{tt|lhs}} and {{tt|rhs}} are equal and each character in {{tt|lhs}} has equivalent character in {{tt|rhs}} at the same position.

* The ordering comparisons are done lexicographically -- the comparison is performed by a function equivalent to {{lc|std::lexicographical_compare}}.

@1-6@ Compares two {{tt|basic_string}} objects.

@7-12@ Compares a {{tt|basic_string}} object and a null-terminated array of {{tt|CharT}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | strings whose contents to compare}}
{{par end}} 

===Return value===
{{c|true}} if the corresponding comparison holds, {{c|false}} otherwise.

===Exceptions===
@1-6@ {{rev begin}}
{{rev | until=c++14 | (none)}}
{{rev | since=c++14 | {{noexcept}}}}
{{rev end}}

@7-12@ (none)

===Complexity===
Linear in the size of the strings.

[[de:cpp/string/basic string/operator cmp]]
[[es:cpp/string/basic string/operator cmp]]
[[fr:cpp/string/basic string/operator cmp]]
[[it:cpp/string/basic string/operator cmp]]
[[ja:cpp/string/basic string/operator cmp]]
[[pl:cpp/string/basic string/operator cmp]]
[[pt:cpp/string/basic string/operator cmp]]
[[ru:cpp/string/basic string/operator cmp]]
[[zh:cpp/string/basic string/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/operator ltltgtgt</title>
    <ns>0</ns>
    <id>5523</id>
    <revision>
      <id>72359</id>
      <parentid>65250</parentid>
      <timestamp>2014-08-14T14:57:12Z</timestamp>
      <contributor>
        <ip>128.100.23.21</ip>
      </contributor>
      <comment>add operator&gt;&gt; to example</comment>
      <text xml:space="preserve" bytes="3658">{{title|operator&lt;&lt;,&gt;&gt;{{small|(std::basic_string)}}}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 |
template &lt;class CharT, class Traits, class Allocator&gt;
std::basic_ostream&lt;CharT, Traits&gt;&amp; 
    operator&lt;&lt;(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, 
               const std::basic_string&lt;CharT, Traits, Allocator&gt;&amp; str);
}}
{{dcl | num=2 |
template &lt;class CharT, class Traits, class Allocator&gt;
std::basic_istream&lt;CharT, Traits&gt;&amp; 
    operator&gt;&gt;(std::basic_istream&lt;CharT, Traits&gt;&amp; is, 
               std::basic_string&lt;CharT, Traits, Allocator&gt;&amp; str);
}}
{{dcl end}}

1) Behaves as an {{concept|FormattedOutputFunction}}. After constructing and checking the sentry object, determines the output format padding as follows:
:a) If {{tt|str.size()}} is not less than {{tt|os.width()}}, uses the range {{tt|[str.begin(), str.end())}} as-is
:b) Otherwise, if {{c|(os.flags() &amp; ios_base::adjustfield) {{==}} ios_base::left}}, places {{tt|os.width()-str.size()}} copies of the {{tt|os.fill()}} character after the character sequence
:c) Otherwise, places {{tt|os.width()-str.size()}} copies of the {{tt|os.fill()}} character before the character sequence

Then stores each character from the resulting sequence (the contents of {{tt|str}} plus padding) to the output stream {{tt|os}} as if by calling {{c|os.rdbuf()-&gt;sputn(seq, n)}}, where {{c|1=n=std::max(os.width(), str.size())}}

Finally, calls {{c|os.width(0)}} to cancel the effects of {{lc|std::setw}}, if any.

2) Behaves as an {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, first clears {{tt|str}} with {{c|str.erase()}}, then reads characters from {{tt|is}} and appends them to {{tt|str}} as if by {{c|str.append(1, c)}}, until one of the following conditions becomes true:

* {{tt|N}} characters are read, where {{tt|N}} is {{tt|is.width()}} if {{tt|is.width() &gt; 0}}, otherwise {{tt|N}} is {{tt|str.max_size()}}
* the end-of-file condition occurs in the stream {{tt|is}}
* {{c|std::isspace(c,is.getloc())}} is true for the next character {{tt|c}} in {{tt|is}} (this whitespace character remains in the input stream).

If no characters are extracted then {{c|std::ios::failbit}} is set on {{tt|is}}, which may throw {{lc|std::ios_base::failure}}.

Finally, calls {{c|os.width(0)}} to cancel the effects of {{lc|std::setw}}, if any. 

===Exceptions===
1) may throw {{lc|std::ios_base::failure}} if an exception is thrown during output.

2) may throw {{lc|std::ios_base::failure}} if no characters are extracted from {{tt|is}} (e.g the stream is at end of file, or consists of whitespace only), or if an exception is thrown during input.

===Parameters===
{{par begin}}
{{par | os | a character output stream}}
{{par | is | a character input stream}}
{{par | str | the string to be inserted or extracted}}
{{par end}}

===Return value===
1) {{tt|os}}

2) {{tt|is}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;sstream&gt;
 
int main()
{
    std::string greeting = &quot;Hello, whirled!&quot;;
    std::istringstream is(greeting);
    std::string hello_comma;
    is &gt;&gt; hello_comma;
    std::cout &lt;&lt; greeting &lt;&lt; '\n' &lt;&lt; hello_comma &lt;&lt; '\n';
}
 | output=
Hello, whirled!
Hello,
}}

[[de:cpp/string/basic string/operator ltltgtgt]]
[[es:cpp/string/basic string/operator ltltgtgt]]
[[fr:cpp/string/basic string/operator ltltgtgt]]
[[it:cpp/string/basic string/operator ltltgtgt]]
[[ja:cpp/string/basic string/operator ltltgtgt]]
[[pt:cpp/string/basic string/operator ltltgtgt]]
[[ru:cpp/string/basic string/operator ltltgtgt]]
[[zh:cpp/string/basic string/operator ltltgtgt]]</text>
      <sha1>qk2x0o6lyarifz8zfqolthswtidi3ka</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/pop back</title>
    <ns>0</ns>
    <id>1419</id>
    <revision>
      <id>68740</id>
      <parentid>63426</parentid>
      <timestamp>2014-03-20T04:01:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C++11: &quot;no erase() or pop_back() throws any exceptions&quot;, C++14: &quot;Throws: nothing&quot;</comment>
      <text xml:space="preserve" bytes="688">{{cpp/string/basic_string/title | pop_back}}
{{cpp/string/basic_string/navbar}}
{{ddcl | since=c++11 |
void pop_back();
}}

Removes the last character from the string.

===Parameters===
(none)

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
(none)

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc push_back}}
{{dsc end}}

[[de:cpp/string/basic string/pop back]]
[[es:cpp/string/basic string/pop back]]
[[fr:cpp/string/basic string/pop back]]
[[it:cpp/string/basic string/pop back]]
[[ja:cpp/string/basic string/pop back]]
[[pt:cpp/string/basic string/pop back]]
[[ru:cpp/string/basic string/pop back]]
[[zh:cpp/string/basic string/pop back]]</text>
      <sha1>216dl717voied1t0lpwwbdztsz7c8nt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/push back</title>
    <ns>0</ns>
    <id>1420</id>
    <revision>
      <id>66404</id>
      <parentid>58938</parentid>
      <timestamp>2013-11-19T19:57:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exception guarantees per 21.4.1[string.require]</comment>
      <text xml:space="preserve" bytes="995">{{cpp/string/basic_string/title | push_back}}
{{cpp/string/basic_string/navbar}}
{{ddcl |
void push_back( CharT ch );
}}

Appends the given character {{tt|ch}} to the end of the string.

===Parameters===
{{par begin}}
{{par | ch | the character to append}}
{{par end}} 

===Return value===
(none)

===Complexity===
Amortized constant.

===Exceptions===
{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

If the operation would result in {{tt|size() &gt; max_size()}}, throws {{lc|std::length_error}}.

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc pop_back}}
{{dsc end}}

[[de:cpp/string/basic string/push back]]
[[es:cpp/string/basic string/push back]]
[[fr:cpp/string/basic string/push back]]
[[it:cpp/string/basic string/push back]]
[[ja:cpp/string/basic string/push back]]
[[pt:cpp/string/basic string/push back]]
[[ru:cpp/string/basic string/push back]]
[[zh:cpp/string/basic string/push back]]</text>
      <sha1>jg6e8hguccfavfrcfzuu6x507cbh4n8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/rbegin</title>
    <ns>0</ns>
    <id>1421</id>
    <revision>
      <id>70808</id>
      <parentid>70487</parentid>
      <timestamp>2014-05-30T15:58:25Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+{{image|range-rbegin-rend.svg}}， +{{noexcept}}</comment>
      <text xml:space="preserve" bytes="1436">{{cpp/string/basic_string/title | rbegin | crbegin}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
reverse_iterator rbegin();
}}
{{dcl |
const_reverse_iterator rbegin() const;
}}
{{dcl | since=c++11 |
const_reverse_iterator crbegin() const;
}}
{{dcl end}}

Returns a reverse iterator to the first character of the reversed string. It corresponds to the last character of the non-reversed string. 

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
reverse iterator to the first character

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Complexity===
Constant

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
    std::string s(&quot;Exemplar!&quot;);
    *s.rbegin() = 'y';
    std::cout &lt;&lt; s &lt;&lt; '\n'; // &quot;Exemplary&quot;
 
    std::string c;
    std::copy(s.crbegin(), s.crend(), std::back_inserter(c));
    std::cout &lt;&lt; c &lt;&lt; '\n'; // &quot;yralpmexE&quot;
}
| output=
Exemplary
yralpmexE
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc rend}}
{{dsc end}}

[[de:cpp/string/basic string/rbegin]]
[[es:cpp/string/basic string/rbegin]]
[[fr:cpp/string/basic string/rbegin]]
[[it:cpp/string/basic string/rbegin]]
[[ja:cpp/string/basic string/rbegin]]
[[pt:cpp/string/basic string/rbegin]]
[[ru:cpp/string/basic string/rbegin]]
[[zh:cpp/string/basic string/rbegin]]</text>
      <sha1>7nen2yirbym8ydc0aot0x2dt6qqi9w3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/rend</title>
    <ns>0</ns>
    <id>1422</id>
    <revision>
      <id>70807</id>
      <parentid>70486</parentid>
      <timestamp>2014-05-30T15:54:40Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+{{image|range-rbegin-rend.svg}}， +{{noexcept}}</comment>
      <text xml:space="preserve" bytes="1749">{{cpp/string/basic_string/title | rend | crend}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | 
reverse_iterator rend();
}}
{{dcl |
const_reverse_iterator rend() const;
}}
{{dcl | since=c++11 |
const_reverse_iterator crend() const;
}}
{{dcl end}}

Returns a reverse iterator to the character following the last character of the reversed string. It corresponds to the character preceding the first character of the non-reversed string. This character acts as a placeholder, attempting to access it results in undefined behavior. 

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
reverse iterator to the character following the last character

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Complexity===
Constant

===Example===
{{example
| code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
  std::string s(&quot;A man, a plan, a canal: Panama&quot;);
  {
    std::string c;
    std::copy(s.rbegin(), s.rend(), std::back_inserter(c));
    std::cout &lt;&lt; c &lt;&lt;'\n'; // &quot;amanaP :lanac a ,nalp a ,nam A&quot;
  }

  {
    std::string c;
    std::copy(s.crbegin(), s.crend(), std::back_inserter(c));
    std::cout &lt;&lt; c &lt;&lt;'\n'; // &quot;amanaP :lanac a ,nalp a ,nam A&quot;
  }
}
| output=
amanaP :lanac a ,nalp a ,nam A
amanaP :lanac a ,nalp a ,nam A
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc rbegin}}
{{dsc end}}

[[de:cpp/string/basic string/rend]]
[[es:cpp/string/basic string/rend]]
[[fr:cpp/string/basic string/rend]]
[[it:cpp/string/basic string/rend]]
[[ja:cpp/string/basic string/rend]]
[[pt:cpp/string/basic string/rend]]
[[ru:cpp/string/basic string/rend]]
[[zh:cpp/string/basic string/rend]]</text>
      <sha1>poyyyvdoou6foqe318anhridpeztvw2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/replace</title>
    <ns>0</ns>
    <id>2713</id>
    <revision>
      <id>72205</id>
      <parentid>69737</parentid>
      <timestamp>2014-07-23T11:43:41Z</timestamp>
      <contributor>
        <ip>61.164.214.38</ip>
      </contributor>
      <comment>format</comment>
      <text xml:space="preserve" bytes="4412">{{cpp/string/basic_string/title|replace}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
basic_string&amp; replace( size_type pos, size_type count,
                       const basic_string&amp; str );
}}
{{dcl | num=1 |
basic_string&amp; replace( const_iterator first, const_iterator last,
                       const basic_string&amp; str );
}}
{{dcl rev begin|num=2}}
{{dcl | until=c++14 |
basic_string&amp; replace( size_type pos, size_type count,
                       const basic_string&amp; str,
                       size_type pos2, size_type count2 );
}}
{{dcl | since=c++14 |
basic_string&amp; replace( size_type pos, size_type count,
                       const basic_string&amp; str,
                       size_type pos2, size_type count2 {{=}} npos );
}}
{{dcl rev end}}
{{dcl | num=3 |
template&lt; class InputIt &gt;
basic_string&amp; replace( const_iterator first, const_iterator last,
                       InputIt first2, InputIt last2 );
}}
{{dcl | num=4 |
basic_string&amp; replace( size_type pos, size_type count,
                       const CharT* cstr, size_type count2 );
}}
{{dcl | num=4 |
basic_string&amp; replace( const_iterator first, const_iterator last,
                       const CharT* cstr, size_type count2 );
}}
{{dcl | num=5 |
basic_string&amp; replace( size_type pos, size_type count,
                       const CharT* cstr );
}}
{{dcl | num=5 |
basic_string&amp; replace( const_iterator first, const_iterator last,
                       const CharT* cstr );
}}
{{dcl | num=6 |
basic_string&amp; replace( size_type pos, size_type count,
                       size_type count2, CharT ch );
}}
{{dcl | num=6 |
basic_string&amp; replace( const_iterator first, const_iterator last,
                       size_type count2, CharT ch );
}}
{{dcl | num=7 | since=c++11 |
basic_string&amp; replace( const_iterator first, const_iterator last, 
                       std::initializer_list&lt;CharT&gt; ilist );
}}
{{dcl end}}

Replaces the part of the string indicated by either {{tt|[pos, pos + count)}} or {{tt|[first, last)}} with a new string.

The new string can be one of:

@1@ string {{tt|str}};

@2@ substring {{tt|[pos2, pos2 + count2)}} of {{tt|str}}

@3@ characters in the range {{tt|[first2, last2)}}; {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}

@4@ first {{tt|count2}} charcters of the character string pointed to by {{tt|cstr}};

@5@ null-terminated character string pointed to by {{tt|cstr}};

@6@ {{tt|count2}} copies of character {{tt|ch}};

@7@ characters in the initializer list {{tt|ilist}};

===Parameters===
{{par begin}}
{{par | pos | start of the substring that is going to be replaced}}
{{par | count | length of the substring that is going to be replaced}}
{{par | first, last | range of characters that is going to be replaced}}
{{par | str | string to use for replacement}}
{{par | pos2 | start of the substring to replace with}}
{{par | count2 | number of characters to replace with}}
{{par | cstr | pointer to the character string to use for replacement}}
{{par | ch | character value to use for replacement}}
{{par | first2, last2 | range of characters to use for replacement}}
{{par | ilist | initializer list with the characters to use for replacement}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{lc|std::out_of_range}} if {{tt|pos &gt; length()}} or {{tt|pos2 &gt; str.length()}}

{{lc|std::length_error}} if the resulting string will exceed maximum possible string length ({{tt|{{lc|std::string::npos}} - 1}})

{{rev inl|since=c++11|
In any case, if an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string str(&quot;The quick brown fox jumps over the lazy dog.&quot;);
    
    str.replace(10, 5, &quot;red&quot;); // (4)
    
    str.replace(str.begin(), str.begin() + 3, 1, 'A'); // (5)
    
    std::cout &lt;&lt; str &lt;&lt; '\n';
}
 | output=
A quick red fox jumps over the lazy dog.
}}

[[de:cpp/string/basic string/replace]]
[[es:cpp/string/basic string/replace]]
[[fr:cpp/string/basic string/replace]]
[[it:cpp/string/basic string/replace]]
[[ja:cpp/string/basic string/replace]]
[[pt:cpp/string/basic string/replace]]
[[ru:cpp/string/basic string/replace]]
[[zh:cpp/string/basic string/replace]]</text>
      <sha1>d47k2jb99u3j9ykxnk9oo4zwzgymkh5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/reserve</title>
    <ns>0</ns>
    <id>1423</id>
    <revision>
      <id>72361</id>
      <parentid>72358</parentid>
      <timestamp>2014-08-14T18:59:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+detail. this looked like it was written about vectors..</comment>
      <text xml:space="preserve" bytes="1910">{{cpp/string/basic_string/title | reserve}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 
void reserve( size_type new_cap {{=}} 0 );
}}

Informs a {{tt|std::basic_string}} object of a planned change in size, so that it can manage the storage allocation appropriately.

* If {{tt|new_cap}} is greater than the current {{lc|capacity()}}, new storage is allocated, and {{lc|capacity()}} is made equal or greater than {{tt|new_cap}}.

* If {{tt|new_cap}} is less than the current {{lc|capacity()}}, this is a non-binding shrink request.

* If {{tt|new_cap}} is less than the current {{lc|size()}}, this is a non-binding shrink-to-fit request {{rev inl|since=c++11|equivalent to {{lc|shrink_to_fit()}}}}.

If a capacity change takes place, all iterators and references, including the past-the-end iterator, are invalidated. 

===Parameters===
{{par begin}}
{{par | new_cap | new capacity of the string }}
{{par end}}

===Return value===
(none)

===Exceptions===
Throws {{lc|std::length_error}} if {{tt|new_cap}} is greater than {{lc|max_size()}}

May throw any exceptions thrown by {{c|std::allocator_traits&lt;Allocator&gt;::allocate()}}, such as {{lc|std::bad_alloc}}.

===Complexity===
At most linear in the {{lc|size()}} of the string

===Example===
{{example
|code=
#include &lt;cassert&gt;
#include &lt;string&gt;

int main()
{
    std::string s;
    std::string::size_type new_capacity{ 100u };
    assert(new_capacity &gt; s.capacity());

    s.reserve(new_capacity);
    assert(new_capacity &lt;= s.capacity());
}
|output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc capacity}}
{{dsc end}}

[[de:cpp/string/basic string/reserve]]
[[es:cpp/string/basic string/reserve]]
[[fr:cpp/string/basic string/reserve]]
[[it:cpp/string/basic string/reserve]]
[[ja:cpp/string/basic string/reserve]]
[[pt:cpp/string/basic string/reserve]]
[[ru:cpp/string/basic string/reserve]]
[[zh:cpp/string/basic string/reserve]]</text>
      <sha1>kafn52ysun4hpa3923tmji47mp90tl9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/resize</title>
    <ns>0</ns>
    <id>1424</id>
    <revision>
      <id>66408</id>
      <parentid>65390</parentid>
      <timestamp>2013-11-19T20:01:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exception guarantees per 21.4.1[string.require]</comment>
      <text xml:space="preserve" bytes="2220">{{cpp/string/basic_string/title | resize}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 |
void resize( size_type count );
}}
{{dcl | num=2 |
void resize( size_type count, CharT ch );
}}
{{dcl end}}

Resizes the string to contain {{tt|count}} characters.

If the current size is less than {{tt|count}}, additional characters are appended.

If the current size is greater than {{tt|count}}, the string is reduced to its first {{tt|count}} elements.

The first version initializes new characters to {{c|CharT()}}, the second version initializes new characters to {{tt|ch}}.

===Parameters===

{{par begin}}
{{par | count | new size of the string}}
{{par | ch | character to initialize the new characters with }}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::length_error}} if {{c|count &gt; max_size()}}.
Any exceptions thrown by corresponding {{tt|Allocator}}.

{{rev inl|since=c++11|
If an exception is thrown for any reason, this function has no effect (strong exception guarantee).}}

===Example===
{{example
| p=true
| code =
#include &lt;iostream&gt;
#include &lt;stdexcept&gt;

int main()
{
    std::string s;

    try {
        // size is OK, no length_error
        // (may throw bad_alloc)
        s.resize(s.max_size() - 1, 'x');
    } catch (std::bad_alloc&amp;) {
        std::cout &lt;&lt; &quot;1. bad alloc\n&quot;;
    }

    try {
        // size is OK, no length_error
        // (may throw bad_alloc)
        s.resize(s.max_size(), 'x');
    } catch (std::bad_alloc&amp; exc) {
        std::cout &lt;&lt; &quot;2. bad alloc\n&quot;;
    }

    try {
        // size is BAD, throw length_error
        s.resize(s.max_size() + 1, 'x');
    } catch (std::length_error&amp;) {
        std::cout &lt;&lt; &quot;3. length error\n&quot;;
    }
}
| output=
1. bad alloc
2. bad alloc
3. length error
}}

===Complexity===
Linear in the size of the string.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc end}}

[[de:cpp/string/basic string/resize]]
[[es:cpp/string/basic string/resize]]
[[fr:cpp/string/basic string/resize]]
[[it:cpp/string/basic string/resize]]
[[ja:cpp/string/basic string/resize]]
[[pt:cpp/string/basic string/resize]]
[[ru:cpp/string/basic string/resize]]
[[zh:cpp/string/basic string/resize]]</text>
      <sha1>grog1faejyu7mzp4p5lo80jcqopu65j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/rfind</title>
    <ns>0</ns>
    <id>1425</id>
    <revision>
      <id>72201</id>
      <parentid>72200</parentid>
      <timestamp>2014-07-23T10:55:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-endl</comment>
      <text xml:space="preserve" bytes="3571">{{cpp/string/basic_string/title | rfind}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
size_type rfind( const basic_string&amp; str, size_type pos = npos ) const;
}}
{{dcl | num=2 | 1=
size_type rfind( const CharT* s, size_type pos, size_type count ) const;
}}
{{dcl | num=3 | 1=
size_type rfind( const CharT* s, size_type pos = npos ) const;
}}
{{dcl | num=4 | 1=
size_type rfind( CharT ch, size_type pos = npos ) const;
}}
{{dcl end}}

Finds the last substring equal to the given character sequence. Search begins at {{tt|pos}}, i.e. the found substring must not begin in a position following {{tt|pos}}. If {{lc|npos}} or any value not smaller than {{lc|size()}} is passed as {{tt|pos}}, whole string will be searched.

@1@ Finds the last substring equal to {{tt|str}}. If {{c|str.size()}} is zero, returns {{tt|pos}} or {{c|size()-1}}, whichever is smaller.

@2@ Finds the last substring equal to the first {{tt|count}} characters of the character string pointed to by {{tt|s}}. {{tt|s}} can include null characters. If {{tt|count}} is zero, returns {{tt|pos}} or {{c|size()-1}}, whichever is smaller.

@3@ Finds the last substring equal to the character string pointed to by {{tt|s}}. The length of the string is determined by the first null character. If the length of {{tt|s}} is zero, returns {{tt|pos}} or {{c|size()-1}}, whichever is smaller.

@4@ Finds the last character {{tt|ch}}.

If {{lc|size()}} is zero, {{lc|npos}} is always returned.

===Parameters===
{{par begin}}
{{par | str | string to search for}}
{{par | pos | position at which to begin searching}}
{{par | count | length of substring to search for}}
{{par | s | pointer to a character string to seach for}}
{{par | ch | character to search for}}
{{par end}} 

===Return value===
Position of the first character of the found substring or {{lc|npos}} if no such substring is found. Note that this is an offset from the start of the string, not the end.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 |
@1-4@ (none)
}}
{{rev | since=c++11 | until=c++14 |
@1,4@ {{noexcept}}
@2,3@ (none)
}}
{{rev | since=c++14 |
@1@ {{noexcept}}
@2,3,4@ (none)
}}
{{rev end}}

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;

void print(std::string::size_type n, std::string const &amp;s)
{
    if (n == std::string::npos) {
        std::cout &lt;&lt; &quot;not found\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;found: \&quot;&quot; &lt;&lt; s.substr(n) &lt;&lt; &quot;\&quot; at &quot; &lt;&lt; n &lt;&lt; '\n';
    }
}

int main()
{
    std::string::size_type n;
    std::string const s = &quot;This is a string&quot;;

    // search backwards from end of string
    n = s.rfind(&quot;is&quot;);
    print(n, s);
    // search backwards from position 4
    n = s.rfind(&quot;is&quot;, 4);
    print(n, s);
    // find a single character
    n = s.rfind('s');
    print(n, s);
    // find a single character
    n = s.rfind('q');
    print(n, s);
}
 | output=
found: &quot;is a string&quot; at 5
found: &quot;is is a string&quot; at 2
found: &quot;string&quot; at 10
not found
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/basic_string/dsc find_first_of}}
{{dsc inc | cpp/string/basic_string/dsc find_first_not_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_of}}
{{dsc inc | cpp/string/basic_string/dsc find_last_not_of}}
{{dsc end}}

[[de:cpp/string/basic string/rfind]]
[[es:cpp/string/basic string/rfind]]
[[fr:cpp/string/basic string/rfind]]
[[it:cpp/string/basic string/rfind]]
[[ja:cpp/string/basic string/rfind]]
[[pt:cpp/string/basic string/rfind]]
[[ru:cpp/string/basic string/rfind]]
[[zh:cpp/string/basic string/rfind]]</text>
      <sha1>c1d04jtszc9kyy89xopwmqmw9lgr4zg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/shrink to fit</title>
    <ns>0</ns>
    <id>1426</id>
    <revision>
      <id>63427</id>
      <parentid>60972</parentid>
      <timestamp>2013-07-10T01:31:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1516">{{cpp/string/basic_string/title | shrink_to_fit}}
{{cpp/string/basic_string/navbar}}
{{ddcl | since=c++11 |
void shrink_to_fit();
}}
Requests the removal of unused capacity.

It is a non-binding request to reduce {{lc|capacity}} to {{lc|size}}. It depends on the implementation if the request is fulfilled. 

===Parameters===
(none)

===Return value===
(none)

===Complexity===
Constant

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;

int main()
{
    std::string s;
    std::cout &lt;&lt; &quot;Default-constructed capacity is &quot; &lt;&lt; s.capacity() &lt;&lt; '\n';
    s.resize(100);
    std::cout &lt;&lt; &quot;Capacity of a 100-element string is &quot; &lt;&lt; s.capacity() &lt;&lt; '\n';
    s.clear();
    std::cout &lt;&lt; &quot;Capacity after clear() is &quot; &lt;&lt; s.capacity() &lt;&lt; '\n';
    s.shrink_to_fit();
    std::cout &lt;&lt; &quot;Capacity after shrink_to_fit() is &quot; &lt;&lt; s.capacity() &lt;&lt; '\n';
}
| output=
Default-constructed capacity is 0
Capacity of a 100-element string is 100
Capacity after clear() is 100
Capacity after shrink_to_fit() is 0
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc inc | cpp/string/basic_string/dsc capacity}}
{{dsc end}}

[[de:cpp/string/basic string/shrink to fit]]
[[es:cpp/string/basic string/shrink to fit]]
[[fr:cpp/string/basic string/shrink to fit]]
[[it:cpp/string/basic string/shrink to fit]]
[[ja:cpp/string/basic string/shrink to fit]]
[[pt:cpp/string/basic string/shrink to fit]]
[[ru:cpp/string/basic string/shrink to fit]]
[[zh:cpp/string/basic string/shrink to fit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/size</title>
    <ns>0</ns>
    <id>1427</id>
    <revision>
      <id>70325</id>
      <parentid>70324</parentid>
      <timestamp>2014-05-19T00:55:08Z</timestamp>
      <contributor>
        <username>Legalize</username>
        <id>3097</id>
      </contributor>
      <minor/>
      <comment>Use &lt;iterator&gt; not &lt;algorithm&gt; for std::distance</comment>
      <text xml:space="preserve" bytes="1439">{{cpp/string/basic_string/title | size | length}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
size_type size() const;
}}
{{dcl |
size_type length() const;
}}
{{dcl end}}

Returns the number of {{tt|CharT}} elements in the string, i.e. {{c|std::distance(begin(), end())}}. 

===Parameters===
(none)

===Return value===
The number of {{tt|CharT}} elements in the string.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}} }}
{{rev end}}

===Complexity===
Constant

===Notes===
For {{lc|std::string}}, the elements are bytes (objects of type char), which are not the same as  characters if a multibyte encoding such as UTF-8 is used.

===Example===
{{example
| code=
#include &lt;cassert&gt;
#include &lt;iterator&gt;
#include &lt;string&gt;

int main()
{
    std::string s(&quot;Exemplar&quot;);
    assert(8 == s.size());
    assert(s.size() == s.length());
    assert(s.size() == static_cast&lt;std::string::size_type&gt;(
        std::distance(s.begin(), s.end())));
}
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc empty}}
{{dsc inc | cpp/string/basic_string/dsc max_size}}
{{dsc end}}

[[de:cpp/string/basic string/size]]
[[es:cpp/string/basic string/size]]
[[fr:cpp/string/basic string/size]]
[[it:cpp/string/basic string/size]]
[[ja:cpp/string/basic string/size]]
[[pt:cpp/string/basic string/size]]
[[ru:cpp/string/basic string/size]]
[[zh:cpp/string/basic string/size]]</text>
      <sha1>ezwptt1i4humiqefbbrfbbhqr26vab1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/stof</title>
    <ns>0</ns>
    <id>2149</id>
    <revision>
      <id>72434</id>
      <parentid>72429</parentid>
      <timestamp>2014-08-22T01:50:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72429 by [[Special:Contributions/Cubbi|Cubbi]] ([[User talk:Cubbi|talk]]) no, I'm wrong; they are all sensitive</comment>
      <text xml:space="preserve" bytes="2211">{{cpp/title| stof | stod | stold}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++11 | 1=
float       stof( const std::string&amp; str, std::size_t* pos = 0 );
float       stof( const std::wstring&amp; str, std::size_t* pos = 0 );
}}
{{dcl | num=2 | since=c++11 | 1=
double      stod( const std::string&amp; str, std::size_t* pos = 0 );
double      stod( const std::wstring&amp; str, std::size_t* pos = 0 );
}}
{{dcl | num=3 | since=c++11 | 1=
long double stold( const std::string&amp; str, std::size_t* pos = 0 );
long double stold( const std::wstring&amp; str, std::size_t* pos = 0 );
}}
{{dcl end}}

Interprets a floating point value in a string {{tt|str}}. 

@1@ calls {{c|std::strtod(str.c_str(), &amp;ptr)}} or {{c|std::wcstod(str.c_str(), &amp;ptr)}}
@2@ calls {{c|std::strtod(str.c_str(), &amp;ptr)}} or {{c|std::wcstod(str.c_str(), &amp;ptr)}}
@3@ calls {{c|std::strtold(str.c_str(), &amp;ptr)}} or {{c|std::wcstold(str.c_str(), &amp;ptr)}}

{{cpp/string/cvt str2float}}

If {{tt|pos}} is passed a value other than {{lc|0}} or {{lc|nullptr}}, then a pointer {{tt|ptr}}, internal to the conversion functions, will receive the address of the first unconverted character, and the index of that character will be calculated and stored in {{tt|*pos}}.

===Parameters===
{{par begin}}
{{par | str | the string to convert}}
{{par | pos | address of integer to store the index of the first unconverted character}}
{{par end}}

===Return value===
The string converted to the specified floating point type.

===Exceptions===
{{lc|std::invalid_argument}} if no conversion could be performed

{{lc|std::out_of_range}} if the converted value would fall out of the range of the result type or if the underlying function ({{tt|strtod}} or {{tt|strtold}}) sets {{c|errno}} to {{c|ERANGE}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/basic_string/dsc stoul}}
{{dsc end}}

[[de:cpp/string/basic string/stof]]
[[es:cpp/string/basic string/stof]]
[[fr:cpp/string/basic string/stof]]
[[it:cpp/string/basic string/stof]]
[[ja:cpp/string/basic string/stof]]
[[pt:cpp/string/basic string/stof]]
[[ru:cpp/string/basic string/stof]]
[[zh:cpp/string/basic string/stof]]</text>
      <sha1>oo267b95lk1ka3w4s9wpxyvuuug7t2i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/stol</title>
    <ns>0</ns>
    <id>2148</id>
    <revision>
      <id>72433</id>
      <parentid>72430</parentid>
      <timestamp>2014-08-22T01:49:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72430 by [[Special:Contributions/Cubbi|Cubbi]] ([[User talk:Cubbi|talk]]) no I'm wrong, they all are sensitive</comment>
      <text xml:space="preserve" bytes="3282">{{cpp/title| stoi | stol | stoll}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++11 | 1=
int       stoi( const std::string&amp; str, std::size_t* pos = 0, int base = 10 );
int       stoi( const std::wstring&amp; str, std::size_t* pos = 0, int base = 10 );
}}
{{dcl | num=2 | since=c++11 | 1=
long      stol( const std::string&amp; str, std::size_t* pos = 0, int base = 10 );
long      stol( const std::wstring&amp; str, std::size_t* pos = 0, int base = 10 );
}}
{{dcl | num=3 | since=c++11 | 1=
long long stoll( const std::string&amp; str, std::size_t* pos = 0, int base = 10 );
long long stoll( const std::wstring&amp; str, std::size_t* pos = 0, int base = 10 );
}}
{{dcl end}}

Interprets a signed integer value in the string {{tt|str}}.

@1@ calls {{c|std::strtol(str.c_str(), &amp;ptr, base)}} or {{c|std::wcstol(str.c_str(), &amp;ptr, base)}}
@2@ calls {{c|std::strtol(str.c_str(), &amp;ptr, base)}} or {{c|std::wcstol(str.c_str(), &amp;ptr, base)}}
@3@ calls {{c|std::strtoll(str.c_str(), &amp;ptr, base)}} or {{c|std::wcstoll(str.c_str(), &amp;ptr, base)}}

{{cpp/string/cvt str2int base | base=base}}

If {{tt|pos}} is passed a value other than {{lc|0}} or {{lc|nullptr}}, then a pointer {{tt|ptr}} - internal to the conversion functions - will receive the address of the first unconverted character, and the index of that character will be calculated and stored in {{tt|*pos}}.

===Parameters===
{{par begin}}
{{par | str | the string to convert}}
{{par | pos | address of an integer to store the index of the first unconverted character}}
{{par | base | the number base}}
{{par end}}

===Return value===
The string converted to the specified signed integer type.

===Exceptions===
* {{lc|std::invalid_argument}} if no conversion could be performed
* {{lc|std::out_of_range}} if the converted value would fall out of the range of the result type or if the underlying function (std::strtol or std::strtoll) sets {{c|errno}} to {{c|ERANGE}}.

===Example===
{{example|
 | code= 
#include &lt;iostream&gt;
#include &lt;string&gt;
 
int main()
{
    std::string str1 = &quot;45&quot;;
    std::string str2 = &quot;3.14159&quot;;
    std::string str3 = &quot;31337 with words&quot;;
    std::string str4 = &quot;words and 2&quot;;
    
    int myint1 = std::stoi(str1);
    int myint2 = std::stoi(str2);
    int myint3 = std::stoi(str3);
    // error: 'std::invalid_argument'
    // int myint4 = std::stoi(str4);
    
    std::cout &lt;&lt; &quot;std::stoi(\&quot;&quot; &lt;&lt; str1 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; myint1 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::stoi(\&quot;&quot; &lt;&lt; str2 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; myint2 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::stoi(\&quot;&quot; &lt;&lt; str3 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; myint3 &lt;&lt; '\n';
    //std::cout &lt;&lt; &quot;std::stoi(\&quot;&quot; &lt;&lt; str4 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; myint4 &lt;&lt; '\n';
}
 | output=
std::stoi(&quot;45&quot;) is 45
std::stoi(&quot;3.14159&quot;) is 3
std::stoi(&quot;31337 with words&quot;) is 31337
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc atoi}}
{{dsc inc | cpp/string/basic_string/dsc stoul}}
{{dsc inc | cpp/string/basic_string/dsc stof}}
{{dsc inc | cpp/string/basic_string/dsc to_string}}
{{dsc end}}

[[de:cpp/string/basic string/stol]]
[[es:cpp/string/basic string/stol]]
[[fr:cpp/string/basic string/stol]]
[[it:cpp/string/basic string/stol]]
[[ja:cpp/string/basic string/stol]]
[[pt:cpp/string/basic string/stol]]
[[ru:cpp/string/basic string/stol]]
[[zh:cpp/string/basic string/stol]]</text>
      <sha1>rfq3nsg881d7al2w9er46lv6zhekke6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/stoul</title>
    <ns>0</ns>
    <id>2468</id>
    <revision>
      <id>72432</id>
      <parentid>72431</parentid>
      <timestamp>2014-08-22T01:49:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72431 by [[Special:Contributions/Cubbi|Cubbi]] ([[User talk:Cubbi|talk]]) no, I'm wrong.. they all are</comment>
      <text xml:space="preserve" bytes="2145">{{cpp/title| stoul | stoull }}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++11 | 1=
unsigned long      stoul( const std::string&amp; str, std::size_t* pos = 0, int base = 10 );
unsigned long      stoul( const std::wstring&amp; str, std::size_t* pos = 0, int base = 10 );
}}
{{dcl | num=2 | since=c++11 | 1=
unsigned long long stoull( const std::string&amp; str, std::size_t* pos = 0, int base = 10 );
unsigned long long stoull( const std::wstring&amp; str, std::size_t* pos = 0, int base = 10 );
}}
{{dcl end}}

Interprets an unsigned integer value in the string {{tt|str}}.

@1@ calls {{c|std::strtoul(str.c_str(), &amp;ptr, base)}} or {{c|std::wcstoul(str.c_str(), &amp;ptr, base)}}
@2@ calls {{c|std::strtoull(str.c_str(), &amp;ptr, base)}} or {{c|std::wcstoull(str.c_str(), &amp;ptr, base)}}

{{cpp/string/cvt str2int base | base=base | u=true}}

If {{tt|pos}} is passed a value other than {{lc|0}} or {{lc|nullptr}}, then a pointer {{tt|ptr}}, internal to the conversion functions, will receive the address of the first unconverted character, and the index of that character will be calculated and stored in {{tt|*pos}}.

===Parameters===
{{par begin}}
{{par | str | the string to convert}}
{{par | pos | address of an integer to store the index of the first unconverted character}}
{{par | base | the number base}}
{{par end}}

===Return value===
The string converted to the specified unsigned integer type.

===Exceptions===
* {{lc|std::invalid_argument}} if no conversion could be performed
* {{lc|std::out_of_range}} if the converted value would fall out of the range of the result type or if the underlying function (std::strtoul or std::strtoull) sets {{c|errno}} to {{c|ERANGE}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/basic_string/dsc stof}}
{{dsc end}}

[[de:cpp/string/basic string/stoul]]
[[es:cpp/string/basic string/stoul]]
[[fr:cpp/string/basic string/stoul]]
[[it:cpp/string/basic string/stoul]]
[[ja:cpp/string/basic string/stoul]]
[[pt:cpp/string/basic string/stoul]]
[[ru:cpp/string/basic string/stoul]]
[[zh:cpp/string/basic string/stoul]]</text>
      <sha1>pdbk5wi6jv2my0g4uqo7tol0htnu6l2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/substr</title>
    <ns>0</ns>
    <id>1428</id>
    <revision>
      <id>72100</id>
      <parentid>66907</parentid>
      <timestamp>2014-07-15T10:18:32Z</timestamp>
      <contributor>
        <username>Feheren.fekete</username>
        <id>1642</id>
      </contributor>
      <text xml:space="preserve" bytes="1828">{{cpp/string/basic_string/title | substr}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 1=
basic_string substr( size_type pos = 0,
                     size_type count = npos ) const;
}}

Returns a substring {{tt|[pos, pos+count)}}. If the requested substring extends past the end of the string, or if {{c|1=count == npos}}, the returned substring is {{tt|[pos, }}[[cpp/string/basic_string/size|{{tt|size()}}]]{{tt|)}}. 

===Parameters===
{{par begin}}
{{par | pos | position of the first character to include}}
{{par | count | length of the substring}}
{{par end}} 

===Return value===
# An empty string if pos == [[cpp/string/basic_string/size|{{tt| size()}}]].
# String containing the substring {{tt|[pos, pos+count)}}.

===Exceptions===
{{lc|std::out_of_range}} if {{c|pos &gt;}}[[cpp/string/basic_string/size|{{tt| size()}}]]

===Complexity===
Linear in {{tt|count}}

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::string a = &quot;0123456789abcdefghij&quot;;
 
    std::string sub1 = a.substr(10);
    std::cout &lt;&lt; sub1 &lt;&lt; '\n';
 
    std::string sub2 = a.substr(5, 3);
    std::cout &lt;&lt; sub2 &lt;&lt; '\n';
 
    std::string sub3 = a.substr(12, 100);
    std::cout &lt;&lt; sub3 &lt;&lt; '\n';

    std::string sub4 = a.substr(a.size()-3, 50);
    std::cout &lt;&lt; sub4 &lt;&lt; '\n';
}
 | output=
abcdefghij
567
cdefghij
hij
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc copy}}
{{dsc inc | cpp/string/basic_string/dsc size}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc end}}

[[de:cpp/string/basic string/substr]]
[[es:cpp/string/basic string/substr]]
[[fr:cpp/string/basic string/substr]]
[[it:cpp/string/basic string/substr]]
[[ja:cpp/string/basic string/substr]]
[[pt:cpp/string/basic string/substr]]
[[ru:cpp/string/basic string/substr]]
[[zh:cpp/string/basic string/substr]]</text>
      <sha1>kve00ahflg3m338lsuit59vbo79az2m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/swap</title>
    <ns>0</ns>
    <id>1429</id>
    <revision>
      <id>69770</id>
      <parentid>65997</parentid>
      <timestamp>2014-04-23T19:44:12Z</timestamp>
      <contributor>
        <username>Langlaw</username>
        <id>3037</id>
      </contributor>
      <comment>swap invalidates iterators (see [string.require])</comment>
      <text xml:space="preserve" bytes="1134">{{cpp/string/basic_string/title | swap}}
{{cpp/string/basic_string/navbar}}
{{ddcl | 
void swap( basic_string&amp; other );
}}

Exchanges the contents of the string with those of {{tt|other}}. All iterators and references may be invalidated.

===Parameters===
{{par begin}}
{{par | other | string to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;

int main() 
{
    std::string a = &quot;AAA&quot;;
    std::string b = &quot;BBB&quot;;

    std::cout &lt;&lt; &quot;before swap&quot; &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;a: &quot; &lt;&lt; a &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b: &quot; &lt;&lt; b &lt;&lt; '\n';

    a.swap(b);

    std::cout &lt;&lt; &quot;after swap&quot; &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;a: &quot; &lt;&lt; a &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b: &quot; &lt;&lt; b &lt;&lt; '\n';
}

 | output=
before swap
a: AAA
b: BBB
after swap
a: BBB
b: AAA
}}

===Complexity===
Constant.

[[de:cpp/string/basic string/swap]]
[[es:cpp/string/basic string/swap]]
[[fr:cpp/string/basic string/swap]]
[[it:cpp/string/basic string/swap]]
[[ja:cpp/string/basic string/swap]]
[[pt:cpp/string/basic string/swap]]
[[ru:cpp/string/basic string/swap]]
[[zh:cpp/string/basic string/swap]]</text>
      <sha1>bt0h3l33ugu4spqfo15f40lpd5hf29s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/swap2</title>
    <ns>0</ns>
    <id>5486</id>
    <revision>
      <id>68739</id>
      <parentid>66964</parentid>
      <timestamp>2014-03-20T03:57:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>match C++14 wording tweak s/calls/equivalent/</comment>
      <text xml:space="preserve" bytes="956">{{cpp/title | swap&lt;small&gt;(std::basic_string)&lt;/small&gt;}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class T, class Traits, class Alloc &gt;
void swap( basic_string&lt;T, Traits, Alloc&gt; &amp;lhs, basic_string&lt;T, Traits, Alloc&gt; &amp;rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::basic_string}}. Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Equivalent to {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | strings whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc swap}}
{{dsc end}}

[[de:cpp/string/basic string/swap2]]
[[es:cpp/string/basic string/swap2]]
[[fr:cpp/string/basic string/swap2]]
[[it:cpp/string/basic string/swap2]]
[[ja:cpp/string/basic string/swap2]]
[[pt:cpp/string/basic string/swap2]]
[[ru:cpp/string/basic string/swap2]]
[[zh:cpp/string/basic string/swap2]]</text>
      <sha1>ewugi3v8c5xvl3mx37n8kbaycnltntk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/to string</title>
    <ns>0</ns>
    <id>2477</id>
    <revision>
      <id>71079</id>
      <parentid>63272</parentid>
      <timestamp>2014-06-05T15:00:05Z</timestamp>
      <contributor>
        <ip>129.16.147.118</ip>
      </contributor>
      <text xml:space="preserve" bytes="3104">{{cpp/title|to_string}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++11 |
std::string to_string( int value );
}}
{{dcl | num=2 | since=c++11 |
std::string to_string( long value );
}}
{{dcl | num=3 | since=c++11 |
std::string to_string( long long value );
}}
{{dcl | num=4 | since=c++11 |
std::string to_string( unsigned value );
}}
{{dcl | num=5 | since=c++11 |
std::string to_string( unsigned long value );
}}
{{dcl | num=6 | since=c++11 |
std::string to_string( unsigned long long value );
}}
{{dcl | num=7 | since=c++11 |
std::string to_string( float value );
}}
{{dcl | num=8 | since=c++11 |
std::string to_string( double value );
}}
{{dcl | num=9 | since=c++11 |
std::string to_string( long double value );
}}
{{dcl end}}

Converts a numeric value to {{lc|std::string}}.

@1@ Converts a signed decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%d&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@2@ Converts a signed decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%ld&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@3@ Converts a signed decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%lld&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@4@ Converts an unsigned decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%u&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@5@ Converts an unsigned decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%lu&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@6@ Converts an unsigned decimal integer to a string with the same content as what  {{c|std::sprintf(buf, &quot;%llu&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@7,8@ Converts a floating point value to a string with the same content as what  {{c|std::sprintf(buf, &quot;%f&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@9@ Converts a floating point value to a string with the same content as what  {{c|std::sprintf(buf, &quot;%Lf&quot;, value)}} would produce for sufficiently large {{tt|buf}}.

===Parameters===
{{par begin}}
{{par | value | a numeric value to convert}}
{{par end}}

===Return value===
a string holding the converted value

===Example===
{{example|
 | code= 
#include &lt;iostream&gt;
#include &lt;string&gt;
 
int main() 
{
    double f = 23.43;
    std::string f_str = std::to_string(f);
    std::cout &lt;&lt; f_str &lt;&lt; '\n';
}
 | output=
23.430000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc to_wstring}}
{{dsc inc | cpp/string/basic_string/dsc stoul}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/basic_string/dsc stof}}
{{dsc end}}

[[de:cpp/string/basic string/to string]]
[[es:cpp/string/basic string/to string]]
[[fr:cpp/string/basic string/to string]]
[[it:cpp/string/basic string/to string]]
[[ja:cpp/string/basic string/to string]]
[[pt:cpp/string/basic string/to string]]
[[ru:cpp/string/basic string/to string]]
[[zh:cpp/string/basic string/to string]]</text>
      <sha1>ojkqwg8tr6pwc5d76htae936icnwuag</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/basic string/to wstring</title>
    <ns>0</ns>
    <id>2476</id>
    <revision>
      <id>65857</id>
      <parentid>63273</parentid>
      <timestamp>2013-10-11T05:07:13Z</timestamp>
      <contributor>
        <username>Rapptz</username>
        <id>1465</id>
      </contributor>
      <text xml:space="preserve" bytes="3077">{{cpp/title|to_wstring}}
{{cpp/string/basic_string/navbar}}
{{dcl begin}}
{{dcl header | string}}
{{dcl | num=1 | since=c++11 |
std::wstring to_wstring( int value );
}}
{{dcl | num=2 | since=c++11 |
std::wstring to_wstring( long value );
}}
{{dcl | num=3 | since=c++11 |
std::wstring to_wstring( long long value );
}}
{{dcl | num=4 | since=c++11 |
std::wstring to_wstring( unsigned value );
}}
{{dcl | num=5 | since=c++11 |
std::wstring to_wstring( unsigned long value );
}}
{{dcl | num=6 | since=c++11 |
std::wstring to_wstring( unsigned long long value );
}}
{{dcl | num=7 | since=c++11 |
std::wstring to_wstring( float value );
}}
{{dcl | num=8 | since=c++11 |
std::wstring to_wstring( double value );
}}
{{dcl | num=9 | since=c++11 |
std::wstring to_wstring( long double value );
}}
{{dcl end}}

Converts a numeric value to {{lc|std::wstring}}.

@1@ Converts a signed decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%d&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@2@ Converts a signed decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%ld&quot;, value)}} would produce for sufficiently large {{tt|buf}}..
@3@ Converts a signed decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%lld&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@4@ Converts an unsigned decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%u&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@5@ Converts an unsigned decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%lu&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@6@ Converts an unsigned decimal integer to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%llu&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@7,8@ Converts a floating point value to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%f&quot;, value)}} would produce for sufficiently large {{tt|buf}}.
@9@ Converts a floating point value to a wide string with the same content as what  {{c|std::swprintf(buf, sz, L&quot;%Lf&quot;, value)}} would produce for sufficiently large {{tt|buf}}.

===Parameters===
{{par begin}}
{{par | value | a numeric value to convert}}
{{par end}}

===Return value===
a wide string holding the converted value

===Example===
{{example|
 | code= 
#include &lt;string&gt;
#include &lt;iostream&gt;

int main() {
    double f = 23.43;	
    std::wstring f_str = std::to_wstring(f);
    std::wcout &lt;&lt; f_str;
}
 | output= 23.430000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc to_string}}
{{dsc end}}

[[de:cpp/string/basic string/to wstring]]
[[es:cpp/string/basic string/to wstring]]
[[fr:cpp/string/basic string/to wstring]]
[[it:cpp/string/basic string/to wstring]]
[[ja:cpp/string/basic string/to wstring]]
[[pt:cpp/string/basic string/to wstring]]
[[ru:cpp/string/basic string/to wstring]]
[[zh:cpp/string/basic string/to wstring]]</text>
      <sha1>27yyizr1wel76f9ysqk801n5l828ckk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte</title>
    <ns>0</ns>
    <id>1430</id>
    <revision>
      <id>71107</id>
      <parentid>62419</parentid>
      <timestamp>2014-06-06T12:01:56Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="3025">{{title|Null-terminated byte strings}}
{{cpp/string/byte/navbar}}

A null-terminated byte string (NTBS) is a sequence of nonzero bytes followed by a byte with value zero (the terminating null character). Each byte in a byte string encodes one character of some character set. For example, the character array {{c|{'\x63', '\x61', '\x74', '\0'}}} is an NTBS holding the string {{c|&quot;cat&quot;}} in ASCII encoding.

===Functions===
{{dsc begin}}
{{dsc h2 | Character classification}}
{{dsc header | cctype}}
{{dsc inc | cpp/string/byte/dsc isalnum}}
{{dsc inc | cpp/string/byte/dsc isalpha}}
{{dsc inc | cpp/string/byte/dsc islower}}
{{dsc inc | cpp/string/byte/dsc isupper}}
{{dsc inc | cpp/string/byte/dsc isdigit}}
{{dsc inc | cpp/string/byte/dsc isxdigit}}
{{dsc inc | cpp/string/byte/dsc iscntrl}}
{{dsc inc | cpp/string/byte/dsc isgraph}}
{{dsc inc | cpp/string/byte/dsc isspace}}
{{dsc inc | cpp/string/byte/dsc isblank}}
{{dsc inc | cpp/string/byte/dsc isprint}}
{{dsc inc | cpp/string/byte/dsc ispunct}}

{{dsc h2 | Character manipulation}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc end}}
{{cpp/string/character classes}}
{{dsc begin}}

{{dsc h2 | Conversions to numeric formats}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/string/byte/dsc atof}}
{{dsc inc | cpp/string/byte/dsc atoi}}
{{dsc inc | cpp/string/byte/dsc strtol}}
{{dsc inc | cpp/string/byte/dsc strtoul}}
{{dsc inc | cpp/string/byte/dsc strtof}}
{{dsc header  | cinttypes}}
{{dsc inc | cpp/string/byte/dsc strtoimax}}

{{dsc h2 | String manipulation}}
{{dsc header | cstring}}
{{dsc inc | cpp/string/byte/dsc strcpy}}
{{dsc inc | cpp/string/byte/dsc strncpy}}
{{dsc inc | cpp/string/byte/dsc strcat}}
{{dsc inc | cpp/string/byte/dsc strncat}}
{{dsc inc | cpp/string/byte/dsc strxfrm}}

{{dsc h2 | String examination}}
{{dsc header | cstring}}
{{dsc inc | cpp/string/byte/dsc strlen}}
{{dsc inc | cpp/string/byte/dsc strcmp}}
{{dsc inc | cpp/string/byte/dsc strncmp}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/byte/dsc strrchr}}
{{dsc inc | cpp/string/byte/dsc strspn}}
{{dsc inc | cpp/string/byte/dsc strcspn}}
{{dsc inc | cpp/string/byte/dsc strpbrk}}
{{dsc inc | cpp/string/byte/dsc strstr}}
{{dsc inc | cpp/string/byte/dsc strtok}}

{{dsc h2 | Character array manipulation}}
{{dsc header | cstring}}
{{dsc inc | cpp/string/byte/dsc memchr}}
{{dsc inc | cpp/string/byte/dsc memcmp}}
{{dsc inc | cpp/string/byte/dsc memset}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc inc | cpp/string/byte/dsc memmove}}

{{dsc h2 | Miscellaneous}}
{{dsc header | cstring}}
{{dsc inc | cpp/string/byte/dsc strerror}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/byte | Null-terminated byte strings}}
{{dsc end}}

[[cs:cpp/string/byte]]
[[de:cpp/string/byte]]
[[es:cpp/string/byte]]
[[fr:cpp/string/byte]]
[[it:cpp/string/byte]]
[[ja:cpp/string/byte]]
[[pl:cpp/string/byte]]
[[pt:cpp/string/byte]]
[[ru:cpp/string/byte]]
[[zh:cpp/string/byte]]</text>
      <sha1>bfep31vd005mwvv12x5moxilk54g47r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/atof</title>
    <ns>0</ns>
    <id>1431</id>
    <revision>
      <id>58966</id>
      <parentid>51213</parentid>
      <timestamp>2013-06-01T06:24:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1345">{{cpp/title| atof}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstdlib |
double atof( const char *str );
}}

Interprets an floating point value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float}}

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par end}}

===Return value===
{{c|double}} value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of the return type, the return value is undefined. If no conversion can be performed, {{c|0.0}} is returned.

===Example===
{{example
 | 
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::cout &lt;&lt; std::atof(&quot;0.0000000123&quot;) &lt;&lt; &quot;\n&quot;
              &lt;&lt; std::atof(&quot;0.012&quot;) &lt;&lt; &quot;\n&quot;
              &lt;&lt; std::atof(&quot;15e16&quot;) &lt;&lt; &quot;\n&quot;
              &lt;&lt; std::atof(&quot;-0x1afp-2&quot;) &lt;&lt; &quot;\n&quot;
              &lt;&lt; std::atof(&quot;inF&quot;) &lt;&lt; &quot;\n&quot;
              &lt;&lt; std::atof(&quot;Nan&quot;) &lt;&lt; &quot;\n&quot;;
}
 | output=
1.23e-08
0.012
1.5e+17
-107.75
inf
nan
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strtof}}
{{dsc see c | c/string/byte/atof}}
{{dsc end}}

[[de:cpp/string/byte/atof]]
[[es:cpp/string/byte/atof]]
[[fr:cpp/string/byte/atof]]
[[it:cpp/string/byte/atof]]
[[ja:cpp/string/byte/atof]]
[[pt:cpp/string/byte/atof]]
[[ru:cpp/string/byte/atof]]
[[zh:cpp/string/byte/atof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/atoi</title>
    <ns>0</ns>
    <id>1432</id>
    <revision>
      <id>67818</id>
      <parentid>62957</parentid>
      <timestamp>2014-03-01T15:10:30Z</timestamp>
      <contributor>
        <ip>80.219.210.86</ip>
      </contributor>
      <comment>missed &quot;;&quot; sign</comment>
      <text xml:space="preserve" bytes="1968">{{cpp/title| atoi | atol | atoll}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl | 
int       atoi( const char *str );
}}
{{dcl |
long      atol( const char *str );
}}
{{dcl | since=c++11 |
long long atoll( const char *str );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int}}

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par end}}

===Return value===

Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, the return value is undefined. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

int main()
{
    const char *str1 = &quot;42&quot;;
    const char *str2 = &quot;3.14159&quot;;
    const char *str3 = &quot;31337 with words&quot;;
    const char *str4 = &quot;words and 2&quot;;

    int num1 = std::atoi(str1);
    int num2 = std::atoi(str2);
    int num3 = std::atoi(str3);
    int num4 = std::atoi(str4);

    std::cout &lt;&lt; &quot;std::atoi(\&quot;&quot; &lt;&lt; str1 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; num1 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::atoi(\&quot;&quot; &lt;&lt; str2 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; num2 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::atoi(\&quot;&quot; &lt;&lt; str3 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; num3 &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::atoi(\&quot;&quot; &lt;&lt; str4 &lt;&lt; &quot;\&quot;) is &quot; &lt;&lt; num4 &lt;&lt; '\n';
}
 | output=
std::atoi(&quot;42&quot;) is 42
std::atoi(&quot;3.14159&quot;) is 3
std::atoi(&quot;31337 with words&quot;) is 31337
std::atoi(&quot;words and 2&quot;) is 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc stol}}
{{dsc inc | cpp/string/byte/dsc strtol}}
{{dsc inc | cpp/string/byte/dsc strtoul}}
{{dsc see c | c/string/byte/atoi | atoi | atol | atoll}}
{{dsc end}}

[[de:cpp/string/byte/atoi]]
[[es:cpp/string/byte/atoi]]
[[fr:cpp/string/byte/atoi]]
[[it:cpp/string/byte/atoi]]
[[ja:cpp/string/byte/atoi]]
[[pt:cpp/string/byte/atoi]]
[[ru:cpp/string/byte/atoi]]
[[zh:cpp/string/byte/atoi]]</text>
      <sha1>qc4t3gyvsjv0v5x8x19hk52bs849a49</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/atol</title>
    <ns>0</ns>
    <id>3683</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>14488</id>
      <parentid>14288</parentid>
      <timestamp>2011-11-27T01:22:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/atoll</title>
    <ns>0</ns>
    <id>3684</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>14490</id>
      <parentid>14290</parentid>
      <timestamp>2011-11-27T01:24:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isalnum</title>
    <ns>0</ns>
    <id>1433</id>
    <revision>
      <id>69595</id>
      <parentid>66322</parentid>
      <timestamp>2014-04-15T13:20:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>non-zero value is not exactly {{c|true}}</comment>
      <text xml:space="preserve" bytes="1832">{{cpp/title|isalnum}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isalnum( int ch );
}}

Checks if the given character is an alphanumeric character as classified by the current C locale. In the default locale, the following characters are alphanumeric:

* digits ({{tt|0123456789}})
* uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}})
* lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}})

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value if the character is an alphanumeric character, {{tt|0}} otherwise.

===Example===
{{example
 | Demonstrates the use of isalnum() with different locales (OS-specific).
 | code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\xdf'; // German letter ß in ISO-8859-1

    std::cout &lt;&lt; &quot;isalnum(\'\\xdf\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isalnum(c) &lt;&lt; '\n';

    std::setlocale(LC_ALL, &quot;de_DE.iso88591&quot;);
    std::cout &lt;&lt; &quot;isalnum(\'\\xdf\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isalnum(c) &lt;&lt; '\n';

}
 | output=
isalnum('\xdf', default C locale) returned false
isalnum('\xdf', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isalnum}}
{{dsc inc | cpp/string/wide/dsc iswalnum}}
{{dsc see c | c/string/byte/isalnum}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isalnum]]
[[es:cpp/string/byte/isalnum]]
[[fr:cpp/string/byte/isalnum]]
[[it:cpp/string/byte/isalnum]]
[[ja:cpp/string/byte/isalnum]]
[[pt:cpp/string/byte/isalnum]]
[[ru:cpp/string/byte/isalnum]]
[[zh:cpp/string/byte/isalnum]]</text>
      <sha1>r5j7o21hla0yfc1ygk5kkpzr3acuu32</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isalpha</title>
    <ns>0</ns>
    <id>1434</id>
    <revision>
      <id>69600</id>
      <parentid>66321</parentid>
      <timestamp>2014-04-15T14:17:22Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>matches alnum (C++)</comment>
      <text xml:space="preserve" bytes="2244">{{cpp/title|isalpha}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isalpha( int ch );
}}

Checks if the given character is an alphabetic character as classified by the currently installed C locale. In the default locale, the following characters are alphanumeric:
* uppercase letters {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}
* lowercase letters {{tt|abcdefghijklmnopqrstuvwxyz}}

In locales other than {{c|&quot;C&quot;}}, an alphabetic character is a character for which {{lc|std::isupper()}} or {{lc|std::islower()}} returns {{c|true}} or any other character considered alphabetic by the locale. In any case, {{lc|std::iscntrl()}}, {{lc|std::isdigit()}}, {{lc|std::ispunct()}} and {{lc|std::isspace()}} will return {{c|false}} for this character.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an alphabetic character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
| Demonstrates the use of isalpha() with different locales (OS-specific).
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt; 
#include &lt;clocale&gt;
         
int main()
{        
    unsigned char c = '\xdf'; // German letter ß in ISO-8859-1
 
    std::cout &lt;&lt; &quot;isalpha(\'\\xdf\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isalpha(c) &lt;&lt; '\n';

    std::setlocale(LC_ALL, &quot;de_DE.iso88591&quot;);
    std::cout &lt;&lt; &quot;isalpha(\'\\xdf\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isalpha(c) &lt;&lt; '\n';
    
}
| output=
isalpha('\xdf', default C locale) returned false
isalpha('\xdf', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isalpha}}
{{dsc inc | cpp/string/wide/dsc iswalpha}}
{{dsc see c | c/string/byte/isalpha}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isalpha]]
[[es:cpp/string/byte/isalpha]]
[[fr:cpp/string/byte/isalpha]]
[[it:cpp/string/byte/isalpha]]
[[ja:cpp/string/byte/isalpha]]
[[pt:cpp/string/byte/isalpha]]
[[ru:cpp/string/byte/isalpha]]
[[tr:cpp/string/byte/isalpha]]
[[zh:cpp/string/byte/isalpha]]</text>
      <sha1>keesuoiml3re027wux732muy7na5v81</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isblank</title>
    <ns>0</ns>
    <id>2931</id>
    <revision>
      <id>66327</id>
      <parentid>66317</parentid>
      <timestamp>2013-11-10T04:19:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move ub note to the main text</comment>
      <text xml:space="preserve" bytes="1193">{{cpp/title|isblank}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype | since=c++11 |
int isblank( int ch );
}}

Checks if the given character is a blank character as classified by the currently installed C locale. Blank characters are whitespace characters used to separate words within a sentence. In the default C locale, only space ({{tt|0x20}}) and horizontal tab ({{tt|0x09}}) are classified as blank characters.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a blank character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isblank}}
{{dsc inc | cpp/string/wide/dsc iswblank}}
{{dsc see c | c/string/byte/isblank}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/byte/isblank]]
[[es:cpp/string/byte/isblank]]
[[fr:cpp/string/byte/isblank]]
[[it:cpp/string/byte/isblank]]
[[ja:cpp/string/byte/isblank]]
[[pt:cpp/string/byte/isblank]]
[[ru:cpp/string/byte/isblank]]
[[zh:cpp/string/byte/isblank]]</text>
      <sha1>5vxk7o0on0rttrg4hy2wanyx6nl16tv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/iscntrl</title>
    <ns>0</ns>
    <id>1435</id>
    <revision>
      <id>66323</id>
      <parentid>66320</parentid>
      <timestamp>2013-11-10T04:17:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1700">{{cpp/title|iscntrl}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int iscntrl( int ch );
}}

Checks if the given character is a control character as classified by the currently installed C locale. In the default, &quot;C&quot; locale, the control characters are the characters with the codes {{tt|0x00-0x1F}} and {{tt|0x7F}}.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a control character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\x94'; // the control code CCH in ISO-8859-1

    std::cout &lt;&lt; &quot;iscntrl(\'\\x94\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::iscntrl(c) &lt;&lt; '\n';

    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;iscntrl(\'\\x94\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::iscntrl(c) &lt;&lt; '\n';

}
| output=
iscntrl('\x94', default C locale) returned false
iscntrl('\x94', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc iscntrl}}
{{dsc inc | cpp/string/wide/dsc iswcntrl}}
{{dsc see c | c/string/byte/iscntrl}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/byte/iscntrl]]
[[es:cpp/string/byte/iscntrl]]
[[fr:cpp/string/byte/iscntrl]]
[[it:cpp/string/byte/iscntrl]]
[[ja:cpp/string/byte/iscntrl]]
[[pt:cpp/string/byte/iscntrl]]
[[ru:cpp/string/byte/iscntrl]]
[[zh:cpp/string/byte/iscntrl]]</text>
      <sha1>2t4ry4isaula6hbc66265u7m0bzy3dk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isdigit</title>
    <ns>0</ns>
    <id>1436</id>
    <revision>
      <id>66325</id>
      <parentid>66311</parentid>
      <timestamp>2013-11-10T04:18:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1329">{{cpp/title|isdigit}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isdigit( int ch );
}}

Checks if the given character is one of the 10 decimal digits: {{tt|0123456789}}.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|isdigit}} and {{tt|isxdigit}} are the only standard narrow character classification functions that are not affected by the currently installed C locale. although some implementations (e.g. Microsoft in 1252 codepage) may classify additional single-byte characters as digits. 
&lt;!-- ref: C standard, note 224 in $7.11.1.1 --&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isdigit}}
{{dsc inc | cpp/string/wide/dsc iswdigit}}
{{dsc see c | c/string/byte/isdigit}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isdigit]]
[[es:cpp/string/byte/isdigit]]
[[fr:cpp/string/byte/isdigit]]
[[it:cpp/string/byte/isdigit]]
[[ja:cpp/string/byte/isdigit]]
[[pl:cpp/string/byte/isdigit]]
[[pt:cpp/string/byte/isdigit]]
[[ru:cpp/string/byte/isdigit]]
[[zh:cpp/string/byte/isdigit]]</text>
      <sha1>hc87o3dw3xjb27n1k2iffl8c6rihdrf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isgraph</title>
    <ns>0</ns>
    <id>1437</id>
    <revision>
      <id>66328</id>
      <parentid>66316</parentid>
      <timestamp>2013-11-10T04:19:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move ub note to the main text</comment>
      <text xml:space="preserve" bytes="1928">{{cpp/title|isgraph}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isgraph( int ch );
}}

Checks if the given character is graphic (has a graphical representation) as classified by the currently installed C locale. In the default C locale, the following characters are graphic:

* digits ({{tt|0123456789}})
* uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}})
* lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}})
* punctuation characters ({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}})

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character has a graphical representation character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\xb6'; // the character ¶ in ISO-8859-1

    std::cout &lt;&lt; &quot;isgraph(\'\\xb6\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isgraph(c) &lt;&lt; '\n';

    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;isgraph(\'\\xb6\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isgraph(c) &lt;&lt; '\n';
}
| output=
isgraph('\xb6', default C locale) returned false
isgraph('\xb6', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isgraph}}
{{dsc inc | cpp/string/wide/dsc iswgraph}}
{{dsc see c | c/string/byte/isgraph}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isgraph]]
[[es:cpp/string/byte/isgraph]]
[[fr:cpp/string/byte/isgraph]]
[[it:cpp/string/byte/isgraph]]
[[ja:cpp/string/byte/isgraph]]
[[pt:cpp/string/byte/isgraph]]
[[ru:cpp/string/byte/isgraph]]
[[zh:cpp/string/byte/isgraph]]</text>
      <sha1>lk3eoq6jchhskcxsomgojl5uezoeu8q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/islower</title>
    <ns>0</ns>
    <id>1438</id>
    <revision>
      <id>66332</id>
      <parentid>66312</parentid>
      <timestamp>2013-11-10T05:07:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move ub note to the main text</comment>
      <text xml:space="preserve" bytes="1914">{{cpp/title|islower}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int islower( int ch );
}}

Checks if the given character is classified as a lowercase character according to the current C locale. In the default &quot;C&quot; locale, {{tt|islower}} returns true only for the lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}}).

If {{tt|islower}} returns {{c|true}}, it is guaranteed that {{c|iscntrl}}, {{c|isdigit}}, {{c|ispunct}}, and {{c|isspace}} return {{c|false}} for the same character in the same C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a lowercase letter, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;
 
int main()
{
    unsigned char c = '\xe5'; // letter å in ISO-8859-1
 
    std::cout &lt;&lt; &quot;islower(\'\\xe5\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::islower(c) &lt;&lt; '\n';
 
    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;islower(\'\\xe5\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::islower(c) &lt;&lt; '\n';

}
| output=
islower('\xe5', default C locale) returned false
islower('\xe5', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc islower}}
{{dsc inc | cpp/string/wide/dsc iswlower}}
{{dsc see c | c/string/byte/islower}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/byte/islower]]
[[es:cpp/string/byte/islower]]
[[fr:cpp/string/byte/islower]]
[[it:cpp/string/byte/islower]]
[[ja:cpp/string/byte/islower]]
[[pl:cpp/string/byte/islower]]
[[pt:cpp/string/byte/islower]]
[[ru:cpp/string/byte/islower]]
[[zh:cpp/string/byte/islower]]</text>
      <sha1>atn1m0x7936npsqpabpc6o1vurgwuhw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isprint</title>
    <ns>0</ns>
    <id>1439</id>
    <revision>
      <id>66330</id>
      <parentid>66319</parentid>
      <timestamp>2013-11-10T04:52:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1896">{{cpp/title|isprint}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isprint( int ch );
}}

Checks if is a printable character as classified by the currently installed C locale. In the default, &quot;C&quot; locale, the following characters are printable:

* digits ({{tt|0123456789}})
* uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}})
* lowercase letters ({{tt|abcdefghijklmnopqrstuvwxyz}})
* punctuation characters ({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}})
* space ({{tt| }})

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character can be printed, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;
 
int main()
{
    unsigned char c = '\xa0'; // the non-breaking space in ISO-8859-1
 
    std::cout &lt;&lt; &quot;isprint(\'\\xa0\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isprint(c) &lt;&lt; '\n';
 
    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;isprint(\'\\xa0\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isprint(c) &lt;&lt; '\n';
}
| output=
isprint('\xa0', default C locale) returned false
isprint('\xa0', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isprint}}
{{dsc inc | cpp/string/wide/dsc iswprint}}
{{dsc see c | c/string/byte/isprint}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isprint]]
[[es:cpp/string/byte/isprint]]
[[fr:cpp/string/byte/isprint]]
[[it:cpp/string/byte/isprint]]
[[ja:cpp/string/byte/isprint]]
[[pt:cpp/string/byte/isprint]]
[[ru:cpp/string/byte/isprint]]
[[zh:cpp/string/byte/isprint]]</text>
      <sha1>lkl8wb77nyklaflxjxv378szsuojbj0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/ispunct</title>
    <ns>0</ns>
    <id>1440</id>
    <revision>
      <id>66309</id>
      <parentid>66157</parentid>
      <timestamp>2013-11-10T04:13:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move ub note to the main text</comment>
      <text xml:space="preserve" bytes="1735">{{cpp/title|ispunct}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int ispunct( int ch );
}}

Checks if the given character is a punctuation character as classified by the current C locale. The default C locale classifies the characters {{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}} as punctuation.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a punctuation character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\xd7'; // the character × (multiplication sign) in ISO-8859-1

    std::cout &lt;&lt; &quot;ispunct(\'\\xd7\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::ispunct(c) &lt;&lt; '\n';

    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;ispunct(\'\\xd7\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::ispunct(c) &lt;&lt; '\n';
}
| output=
ispunct('\xd7', default C locale) returned false
ispunct('\xd7', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc ispunct}}
{{dsc inc | cpp/string/wide/dsc iswpunct}}
{{dsc see c | c/string/byte/ispunct}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/ispunct]]
[[es:cpp/string/byte/ispunct]]
[[fr:cpp/string/byte/ispunct]]
[[it:cpp/string/byte/ispunct]]
[[ja:cpp/string/byte/ispunct]]
[[pt:cpp/string/byte/ispunct]]
[[ru:cpp/string/byte/ispunct]]
[[zh:cpp/string/byte/ispunct]]</text>
      <sha1>73bldqq5cev2qnhnx6zu1kxjr2jiopj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isspace</title>
    <ns>0</ns>
    <id>1441</id>
    <revision>
      <id>66329</id>
      <parentid>66318</parentid>
      <timestamp>2013-11-10T04:51:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1290">{{cpp/title|isspace}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isspace( int ch );
}}

Checks if the given character is whitespace character as classified by the currently installed C locale. In the default locale, the whitespace characters are the following:

* space ({{tt|0x20}}, {{c|' '}})
* form feed ({{tt|0x0c}}, {{c|'\f'}})
* line feed ({{tt|0x0a}}, {{c|'\n'}})
* carriage return ({{tt|0x0d}}, {{c|'\r'}})
* horizontal tab ({{tt|0x09}}, {{c|'\t'}}) 
* vertical tab ({{tt|0x0b}}, {{c|'\v'}})

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is a whitespace character, {{tt|0}} ({{c|false}}) otherwise.

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isspace}}
{{dsc inc | cpp/string/wide/dsc iswspace}}
{{dsc see c | c/string/byte/isspace}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/byte/isspace]]
[[es:cpp/string/byte/isspace]]
[[fr:cpp/string/byte/isspace]]
[[it:cpp/string/byte/isspace]]
[[ja:cpp/string/byte/isspace]]
[[pt:cpp/string/byte/isspace]]
[[ru:cpp/string/byte/isspace]]
[[zh:cpp/string/byte/isspace]]</text>
      <sha1>ax545ws16jqqu5xkbuidgvinmb3ddm6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isupper</title>
    <ns>0</ns>
    <id>1442</id>
    <revision>
      <id>66326</id>
      <parentid>66313</parentid>
      <timestamp>2013-11-10T04:18:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1918">{{cpp/title|isupper}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isupper( int ch );
}}

Checks if the given character is an uppercase character as classified by the currently installed C locale. In the default &quot;C&quot; locale, {{tt|isupper}} returns true only for the uppercase letters ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}).

If {{tt|isupper}} returns {{c|true}}, it is guaranteed that {{c|iscntrl}}, {{c|isdigit}}, {{c|ispunct}}, and {{c|isspace}} return {{c|false}} for the same character in the same C locale.

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an uppercase letter, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;
 
int main()
{
    unsigned char c = '\xc6'; // letter Æ in ISO-8859-1
 
    std::cout &lt;&lt; &quot;isupper(\'\\xc6\', default C locale) returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isupper(c) &lt;&lt; '\n';
 
    std::setlocale(LC_ALL, &quot;en_GB.iso88591&quot;);
    std::cout &lt;&lt; &quot;isupper(\'\\xc6\', ISO-8859-1 locale) returned &quot;
              &lt;&lt; std::boolalpha &lt;&lt; (bool)std::isupper(c) &lt;&lt; '\n';

}
| output=
isupper('\xc6', default C locale) returned false
isupper('\xc6', ISO-8859-1 locale) returned true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isupper}}
{{dsc inc | cpp/string/wide/dsc iswupper}}
{{dsc see c | c/string/byte/isupper}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/byte/isupper]]
[[es:cpp/string/byte/isupper]]
[[fr:cpp/string/byte/isupper]]
[[it:cpp/string/byte/isupper]]
[[ja:cpp/string/byte/isupper]]
[[pl:cpp/string/byte/isupper]]
[[pt:cpp/string/byte/isupper]]
[[ru:cpp/string/byte/isupper]]
[[zh:cpp/string/byte/isupper]]</text>
      <sha1>ibunwjq1xi4tla763ok91caz7jrnxlp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/isxdigit</title>
    <ns>0</ns>
    <id>1443</id>
    <revision>
      <id>66324</id>
      <parentid>66310</parentid>
      <timestamp>2013-11-10T04:18:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1345">{{cpp/title|isxdigit}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int isxdigit( int ch );
}}

Checks if the given wide character is a hexadecimal numeric character ({{tt|0123456789abcdefABCDEF}}).

The behavior is undefined if the value of {{tt|ch}} is not representable as {{c|unsigned char}} and is not equal to {{c|EOF}}.

===Parameters===
{{par begin}}
{{par | ch | character to classify}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the character is an hexadecimal numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|isdigit}} and {{tt|isxdigit}} are the only standard narrow character classification functions that are not affected by the currently installed C locale. although some implementations (e.g. Microsoft in 1252 codepage) may classify additional single-byte characters as digits. 
&lt;!-- ref: C standard, note 224 in $7.11.1.1 --&gt;

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isxdigit}}
{{dsc inc | cpp/string/wide/dsc iswxdigit}}
{{dsc see c | c/string/byte/isxdigit}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/byte/isxdigit]]
[[es:cpp/string/byte/isxdigit]]
[[fr:cpp/string/byte/isxdigit]]
[[it:cpp/string/byte/isxdigit]]
[[ja:cpp/string/byte/isxdigit]]
[[pt:cpp/string/byte/isxdigit]]
[[ru:cpp/string/byte/isxdigit]]
[[zh:cpp/string/byte/isxdigit]]</text>
      <sha1>ak6tjdc3pou96bh7xtexw6fwecptlhg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/memchr</title>
    <ns>0</ns>
    <id>1444</id>
    <revision>
      <id>58988</id>
      <parentid>51227</parentid>
      <timestamp>2013-06-01T06:25:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1217">{{cpp/title| memchr}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
const void* memchr( const void* ptr, int ch, std::size_t count );
}}
{{dcl | 1=
      void* memchr(       void* ptr, int ch, std::size_t count );
}}
{{dcl end}}

Converts {{tt|ch}} to {{c|unsigned char}} and locates the first occurrence of that value in the initial {{tt|count}} characters (each interpreted as {{c|unsigned char}}) of the object pointed to by {{tt|ptr}}. 

===Parameters===
{{par begin}}
{{par | ptr | pointer to the object to be examined}}
{{par | ch | character to search for}}
{{par | count | number of characters to examine}}
{{par end}}

===Return value===
Pointer to the location of the character, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc see c | c/string/byte/memchr}}
{{dsc end}}

[[de:cpp/string/byte/memchr]]
[[es:cpp/string/byte/memchr]]
[[fr:cpp/string/byte/memchr]]
[[it:cpp/string/byte/memchr]]
[[ja:cpp/string/byte/memchr]]
[[pt:cpp/string/byte/memchr]]
[[ru:cpp/string/byte/memchr]]
[[zh:cpp/string/byte/memchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/memcmp</title>
    <ns>0</ns>
    <id>1445</id>
    <revision>
      <id>67215</id>
      <parentid>58991</parentid>
      <timestamp>2014-01-27T15:30:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link object representation</comment>
      <text xml:space="preserve" bytes="2022">{{cpp/title| memcmp}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
int memcmp( const void* lhs, const void* rhs, std::size_t count );
}}

Reinterprets the objects pointed to by {{tt|lhs}} and {{tt|rhs}} as arrays of {{c|unsigned char}} and compares the first {{tt|count}} characters of these arrays. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the memory buffers to compare}}
{{par | count | number of bytes to examine}}
{{par end}}

===Return value===
Negative value if the first differing byte (reinterpreted as {{c|unsigned char}}) in {{tt|lhs}} is less than the corresponding byte in {{tt|rhs}}.

{{c|0}} if all {{tt|count}} bytes of {{tt|lhs}} and {{tt|rhs}} are equal.

Positive value if the first differing byte in {{tt|lhs}} is greater than the corresponding byte in {{tt|rhs}}.

===Notes===
This function reads [[cpp/language/object|object representations]], not the object values, and is typically meaningful for trivially-copyable objects only. For example, {{tt|memcmp()}} between two objects of type {{lc|std::string}} or {{lc|std::vector}} will not compare their contents.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    char a1[] = {'a', 'b', 'c'};
    char a2[] = {'a', 'b', 'd'};

    std::cout &lt;&lt; &quot;'abc' vs 'abd': &quot; &lt;&lt; std::memcmp(a1, a2, sizeof a1) &lt;&lt; '\n'
              &lt;&lt; &quot;'abd' vs 'abc': &quot; &lt;&lt; std::memcmp(a2, a1, sizeof a1) &lt;&lt; '\n'
              &lt;&lt; &quot;'abc' vs 'abc': &quot; &lt;&lt; std::memcmp(a1, a1, sizeof a1) &lt;&lt; '\n';
}
 | output=
'abc' vs 'abd': -1
'abd' vs 'abc': 1
'abc' vs 'abc': 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcmp}}
{{dsc inc | cpp/string/byte/dsc strncmp}}
{{dsc see c | c/string/byte/memcmp}}
{{dsc end}}

[[de:cpp/string/byte/memcmp]]
[[es:cpp/string/byte/memcmp]]
[[fr:cpp/string/byte/memcmp]]
[[it:cpp/string/byte/memcmp]]
[[ja:cpp/string/byte/memcmp]]
[[pt:cpp/string/byte/memcmp]]
[[ru:cpp/string/byte/memcmp]]
[[zh:cpp/string/byte/memcmp]]</text>
      <sha1>n3fo0rf8z4ijvhfy03n9wkz2bxa6ust</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/memcpy</title>
    <ns>0</ns>
    <id>1446</id>
    <revision>
      <id>58992</id>
      <parentid>51229</parentid>
      <timestamp>2013-06-01T06:25:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1445">{{cpp/title|memcpy}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
void* memcpy( void* dest, const void* src, std::size_t count );
}}

Copies {{tt|count}} bytes from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. 

If the objects overlap, the behavior is undefined. If the objects are not trivially copyable (e.g. scalars, arrays, C-compatible structs), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    char source[] = &quot;once upon a midnight dreary...&quot;;
    char dest[4];

    std::memcpy(dest, source, sizeof dest);

    for (char c : dest) {
        std::cout &lt;&lt; c &lt;&lt; '\n';
    }
}
 | output=
o
n
c
e
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc memmove}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/byte/memcpy}}
{{dsc end}}

[[de:cpp/string/byte/memcpy]]
[[es:cpp/string/byte/memcpy]]
[[fr:cpp/string/byte/memcpy]]
[[it:cpp/string/byte/memcpy]]
[[ja:cpp/string/byte/memcpy]]
[[pt:cpp/string/byte/memcpy]]
[[ru:cpp/string/byte/memcpy]]
[[zh:cpp/string/byte/memcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/memmove</title>
    <ns>0</ns>
    <id>1447</id>
    <revision>
      <id>58995</id>
      <parentid>51230</parentid>
      <timestamp>2013-06-01T06:25:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1360">{{cpp/title| memmove}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
void* memmove( void* dest, const void* src, std::size_t count );
}}

Copies {{tt|count}} characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. The objects may overlap: copying takes place as if the characters were copied to a temporary character array and then the characters were copied from the array to {{tt|dest}}. If the objects are not trivially-copyable (scalars, arrays, C-style structs), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/byte/memmove}}
{{dsc end}}

[[de:cpp/string/byte/memmove]]
[[es:cpp/string/byte/memmove]]
[[fr:cpp/string/byte/memmove]]
[[it:cpp/string/byte/memmove]]
[[ja:cpp/string/byte/memmove]]
[[pl:cpp/string/byte/memmove]]
[[pt:cpp/string/byte/memmove]]
[[ru:cpp/string/byte/memmove]]
[[zh:cpp/string/byte/memmove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/memset</title>
    <ns>0</ns>
    <id>1448</id>
    <revision>
      <id>62143</id>
      <parentid>58996</parentid>
      <timestamp>2013-06-24T17:49:34Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1366">{{cpp/title| memset}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
void* memset( void* dest, int ch, std::size_t count );
}}

Converts the value {{tt|ch}} to {{c|unsigned char}} and copies it into each of the first {{tt|count}} characters of the object pointed to by {{tt|dest}}. If the object is not trivially-copyable (e.g., scalar, array, or a C-compatible struct), the behavior is undefined. If {{tt|count}} is greater than the size of the object pointed to by {{tt|dest}}, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the object to fill}}
{{par | ch | fill byte}}
{{par | count | number of bytes to fill}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    int a[20];
    std::memset(a, 0, sizeof(a));
    for (int ai : a) std::cout &lt;&lt; ai;
}
 | output=
00000000000000000000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/byte/memset}}
{{dsc end}}

[[de:cpp/string/byte/memset]]
[[es:cpp/string/byte/memset]]
[[fr:cpp/string/byte/memset]]
[[it:cpp/string/byte/memset]]
[[ja:cpp/string/byte/memset]]
[[pt:cpp/string/byte/memset]]
[[ru:cpp/string/byte/memset]]
[[zh:cpp/string/byte/memset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strcat</title>
    <ns>0</ns>
    <id>1449</id>
    <revision>
      <id>58997</id>
      <parentid>51232</parentid>
      <timestamp>2013-06-01T06:25:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1390">{{cpp/title| strcat}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
char *strcat( char *dest, const char *src );
}}

Appends a byte string pointed to by {{tt|src}} to a byte string pointed to by {{tt|dest}}. The resulting byte string is null-terminated. 

The destination byte string must have enough space for the contents of both {{tt|dest}} and {{tt|src}}, plus the terminating null character.

The behavior is undefined if the strings overlap.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to append to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;cstring&gt;
#include &lt;cstdio&gt;
 
int main() 
{
    char str[50] = &quot;Hello &quot;;
    char str2[50] = &quot;World!&quot;;
    std::strcat(str, str2);
    std::strcat(str, &quot; Goodbye World!&quot;);
    std::puts(str);
}
 | output=
Hello World! Goodbye World!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strncat}}
{{dsc inc | cpp/string/byte/dsc strcpy}}
{{dsc see c | c/string/byte/strcat}}
{{dsc end}}

[[de:cpp/string/byte/strcat]]
[[es:cpp/string/byte/strcat]]
[[fr:cpp/string/byte/strcat]]
[[it:cpp/string/byte/strcat]]
[[ja:cpp/string/byte/strcat]]
[[pt:cpp/string/byte/strcat]]
[[ru:cpp/string/byte/strcat]]
[[tr:cpp/string/byte/strcat]]
[[zh:cpp/string/byte/strcat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strchr</title>
    <ns>0</ns>
    <id>1450</id>
    <revision>
      <id>69846</id>
      <parentid>69845</parentid>
      <timestamp>2014-04-28T22:14:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix deprecated/invalid conversion in example</comment>
      <text xml:space="preserve" bytes="1786">{{cpp/title| strchr}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
const char* strchr( const char* str, int ch );
}}
{{dcl | 1=
      char* strchr(       char* str, int ch );
}}
{{dcl end}}

Finds the first occurrence of the character {{tt|ch}} in the byte string pointed to by {{tt|str}}. 

The terminating null character is considered to be a part of the string.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be analyzed}}
{{par | ch | character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.


===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
  const char *str = &quot;Try not. Do, or do not. There is no try.&quot;;
  char target = 'T';
  const char *result = str;

  while ((result = std::strchr(result, target)) != NULL) {
    std::cout &lt;&lt; &quot;Found '&quot; &lt;&lt; target
              &lt;&lt; &quot;' starting at '&quot; &lt;&lt; result &lt;&lt; &quot;'\n&quot;;

    // Increment result, otherwise we'll find target at the same location
    ++result;
  }
}
 | output=
Found 'T' starting at 'Try not. Do, or do not. There is no try.'
Found 'T' starting at 'There is no try.'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/byte/dsc strrchr}}
{{dsc inc | cpp/string/byte/dsc strpbrk}}
{{dsc see c | c/string/byte/strchr}}
{{dsc end}}

[[de:cpp/string/byte/strchr]]
[[es:cpp/string/byte/strchr]]
[[fr:cpp/string/byte/strchr]]
[[it:cpp/string/byte/strchr]]
[[ja:cpp/string/byte/strchr]]
[[pl:cpp/string/byte/strchr]]
[[pt:cpp/string/byte/strchr]]
[[ru:cpp/string/byte/strchr]]
[[tr:cpp/string/byte/strchr]]
[[zh:cpp/string/byte/strchr]]</text>
      <sha1>91j2pwiuv0himw54l0y3pnwyb2k5xbb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strcmp</title>
    <ns>0</ns>
    <id>1451</id>
    <revision>
      <id>59001</id>
      <parentid>51234</parentid>
      <timestamp>2013-06-01T06:25:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1513">{{cpp/title| strcmp}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
int strcmp( const char *lhs, const char *rhs );
}}

Compares two null-terminated byte strings. The comparison is done lexicographically.

Both {{tt|lhs}} and {{tt|rhs}} should point to valid strings.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
#include &lt;vector&gt;
#include &lt;cstring&gt;
#include &lt;algorithm&gt;
#include &lt;iostream&gt;

int main() 
{
    std::vector&lt;const char*&gt; cats {&quot;Heathcliff&quot;, &quot;Snagglepuss&quot;, &quot;Hobbes&quot;, &quot;Garfield&quot;};
    std::sort(cats.begin(), cats.end(), [](const char *strA, const char *strB) {
        return std::strcmp(strA, strB) &lt; 0;
    }); 

    for (const char *cat : cats) {
        std::cout &lt;&lt; cat &lt;&lt; '\n';
    }
}
 | output=
Garfield
Heathcliff
Hobbes
Snagglepuss
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strncmp}}
{{dsc inc | cpp/string/byte/dsc memcmp}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc see c | c/string/byte/strcmp}}
{{dsc end}}

[[de:cpp/string/byte/strcmp]]
[[es:cpp/string/byte/strcmp]]
[[fr:cpp/string/byte/strcmp]]
[[it:cpp/string/byte/strcmp]]
[[ja:cpp/string/byte/strcmp]]
[[pt:cpp/string/byte/strcmp]]
[[ru:cpp/string/byte/strcmp]]
[[zh:cpp/string/byte/strcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strcoll</title>
    <ns>0</ns>
    <id>4584</id>
    <revision>
      <id>59004</id>
      <parentid>51235</parentid>
      <timestamp>2013-06-01T06:25:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1820">{{cpp/title| strcoll}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
int strcoll( const char* lhs, const char* rhs );
}}

Compares two null-terminated byte strings according to the current locale as defined by the {{lc|LC_COLLATE}} category.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' (precedes) {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' (follows) {{tt|rhs}}.

===Notes===
{{cpp/locale/collate/collation_note}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;
#include &lt;clocale&gt;
 
int main()
{
    std::setlocale(LC_COLLATE, &quot;cs_CZ.iso88592&quot;);
    
    const char* s1 = &quot;hrnec&quot;;
    const char* s2 = &quot;chrt&quot;;
    
    std::cout &lt;&lt; &quot;In the Czech locale: &quot;;
    if(std::strcoll(s1, s2) &lt; 0)
         std::cout &lt;&lt; s1 &lt;&lt; &quot; before &quot; &lt;&lt; s2 &lt;&lt; '\n';
    else
         std::cout &lt;&lt; s2 &lt;&lt; &quot; before &quot; &lt;&lt; s1 &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;In lexicographical comparison: &quot;;
    if(std::strcmp(s1, s2) &lt; 0)
         std::cout &lt;&lt; s1 &lt;&lt; &quot; before &quot; &lt;&lt; s2 &lt;&lt; '\n';
    else
         std::cout &lt;&lt; s2 &lt;&lt; &quot; before &quot; &lt;&lt; s1 &lt;&lt; '\n';
}
 | output=
In the Czech locale: hrnec before chrt
In lexicographical comparison: chrt before hrnec
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc inc | cpp/locale/collate/dsc do_compare}}
{{dsc inc | cpp/string/byte/dsc strxfrm}}
{{dsc see c | c/string/byte/strcoll}}
{{dsc end}}

[[de:cpp/string/byte/strcoll]]
[[es:cpp/string/byte/strcoll]]
[[fr:cpp/string/byte/strcoll]]
[[it:cpp/string/byte/strcoll]]
[[ja:cpp/string/byte/strcoll]]
[[pt:cpp/string/byte/strcoll]]
[[ru:cpp/string/byte/strcoll]]
[[zh:cpp/string/byte/strcoll]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strcpy</title>
    <ns>0</ns>
    <id>1452</id>
    <revision>
      <id>63251</id>
      <parentid>59005</parentid>
      <timestamp>2013-07-07T14:28:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1132">{{cpp/title| strcpy}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
char* strcpy( char* dest, const char* src );
}}

Copies the byte string pointed to by {{tt|src}} to byte string, pointed to by {{tt|dest}}.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the byte string to copy to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;
 
int main()
{
    char *str = new char[100];
    std::strcpy(str, &quot;I am string!&quot;);
    std::cout &lt;&lt; str;
    delete[] str;
}

 | output= I am string!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strncpy}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc see c | c/string/byte/strcpy}}
{{dsc end}}

[[de:cpp/string/byte/strcpy]]
[[es:cpp/string/byte/strcpy]]
[[fr:cpp/string/byte/strcpy]]
[[it:cpp/string/byte/strcpy]]
[[ja:cpp/string/byte/strcpy]]
[[pt:cpp/string/byte/strcpy]]
[[ru:cpp/string/byte/strcpy]]
[[tr:cpp/string/byte/strcpy]]
[[zh:cpp/string/byte/strcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strcspn</title>
    <ns>0</ns>
    <id>1749</id>
    <revision>
      <id>59008</id>
      <parentid>51237</parentid>
      <timestamp>2013-06-01T06:25:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1150">{{cpp/title| strcspn}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
size_t strcspn( const char *dest, const char *src );
}}

Returns the length of the maximum initial segment of the byte string pointed to by {{tt|dest}}, that consists of only the characters ''not'' found in byte string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | src | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters not found in the byte string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strspn}}
{{dsc inc | cpp/string/byte/dsc strpbrk}}
{{dsc see c | c/string/byte/strcspn}}
{{dsc end}}

[[de:cpp/string/byte/strcspn]]
[[es:cpp/string/byte/strcspn]]
[[fr:cpp/string/byte/strcspn]]
[[it:cpp/string/byte/strcspn]]
[[ja:cpp/string/byte/strcspn]]
[[pt:cpp/string/byte/strcspn]]
[[ru:cpp/string/byte/strcspn]]
[[zh:cpp/string/byte/strcspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strerror</title>
    <ns>0</ns>
    <id>4586</id>
    <revision>
      <id>59009</id>
      <parentid>51238</parentid>
      <timestamp>2013-06-01T06:25:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1112">{{cpp/title| strerror}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
char* strerror( int errnum );
}}

Returns text version of the error code {{tt|errnum}}. {{tt|errnum}} is usually acquired from the {{tt|errno}} variable, however the function accepts any value of type {{c|int}}. The message is locale-specific.

The returned byte string must not be modified by the program, but may be overwritten by a subsequent call to the {{tt|strerror}} function. 

===Parameters===
{{par begin}}
{{par | errnum | integral value referring to a error code}}
{{par end}}

===Return value===
Pointer to a null-terminated byte string corresponding to the error code {{tt|errnum}}.

===Example===
{{example template|cpp/error/example_errno}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc errno_macros}}
{{dsc see c | c/string/byte/strerror}}
{{dsc end}}

[[de:cpp/string/byte/strerror]]
[[es:cpp/string/byte/strerror]]
[[fr:cpp/string/byte/strerror]]
[[it:cpp/string/byte/strerror]]
[[ja:cpp/string/byte/strerror]]
[[pt:cpp/string/byte/strerror]]
[[ru:cpp/string/byte/strerror]]
[[zh:cpp/string/byte/strerror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strlen</title>
    <ns>0</ns>
    <id>1750</id>
    <revision>
      <id>72217</id>
      <parentid>51239</parentid>
      <timestamp>2014-07-24T11:10:03Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>wording, example</comment>
      <text xml:space="preserve" bytes="1163">{{cpp/title| strlen}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
std::size_t strlen( const char* str );
}}

Returns the length of the given null-terminated byte string, that is, the number of characters that precede the terminating null character.

===Parameters===
{{par begin}}
{{par |str | pointer to the null-terminated byte string to be examined}}
{{par end}}

===Return value===
The length of the null-terminated string {{tt|str}}.

===Example===
{{example
 |
 | code=
#include &lt;cstring&gt;
#include &lt;iostream&gt;
 
int main()
{
   const char str[] = &quot;How many characters does this string contain?&quot;;
 
   std::cout &lt;&lt; &quot;without null character: &quot; &lt;&lt; std::strlen(str) &lt;&lt; '\n'
             &lt;&lt; &quot;with null character: &quot; &lt;&lt; sizeof(str) &lt;&lt; '\n';
}
 | output=
without null character: 45
with null character: 46
}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/byte/strlen}}
{{dsc end}}

[[de:cpp/string/byte/strlen]]
[[es:cpp/string/byte/strlen]]
[[fr:cpp/string/byte/strlen]]
[[it:cpp/string/byte/strlen]]
[[ja:cpp/string/byte/strlen]]
[[pl:cpp/string/byte/strlen]]
[[pt:cpp/string/byte/strlen]]
[[ru:cpp/string/byte/strlen]]
[[zh:cpp/string/byte/strlen]]</text>
      <sha1>ihv12ewxu60oqewy45pchrdd59h0hn3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strncat</title>
    <ns>0</ns>
    <id>1751</id>
    <revision>
      <id>59010</id>
      <parentid>51240</parentid>
      <timestamp>2013-06-01T06:25:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1542">{{cpp/title| strncat}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
char *strncat( char *dest, const char *src, std::size_t count );
}}

Appends a byte string pointed to by {{tt|src}} to a byte string pointed to by {{tt|dest}}. At most {{tt|count}} characters are copied. The resulting byte string is null-terminated. 

The destination byte string must have enough space for the contents of both {{tt|dest}} and {{tt|src}} plus the terminating null character, except that the size of {{tt|src}} is limited to {{tt|count}}.

The behavior is undefined if the strings overlap.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to append to}}
{{par | src | pointer to the null-terminated byte string to copy from}}
{{par | count | maximum number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;cstring&gt;
#include &lt;cstdio&gt;
 
int main() 
{
    char str[50] = &quot;Hello &quot;;
    char str2[50] = &quot;World!&quot;;
    std::strcat(str, str2);
    std::strncat(str, &quot; Goodbye World!&quot;, 3);
    std::puts(str);
}
 | output=
Hello World! Go
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcat}}
{{dsc inc | cpp/string/byte/dsc strcpy}}
{{dsc see c | c/string/byte/strncat}}
{{dsc end}}

[[de:cpp/string/byte/strncat]]
[[es:cpp/string/byte/strncat]]
[[fr:cpp/string/byte/strncat]]
[[it:cpp/string/byte/strncat]]
[[ja:cpp/string/byte/strncat]]
[[pt:cpp/string/byte/strncat]]
[[ru:cpp/string/byte/strncat]]
[[zh:cpp/string/byte/strncat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strncmp</title>
    <ns>0</ns>
    <id>1752</id>
    <revision>
      <id>71814</id>
      <parentid>65380</parentid>
      <timestamp>2014-06-25T07:59:25Z</timestamp>
      <contributor>
        <username>Marc van Leeuwen</username>
        <id>3164</id>
      </contributor>
      <comment>&quot;Hello, &quot; has 7 non-null characters, not 8; comment was misleading</comment>
      <text xml:space="preserve" bytes="2062">{{cpp/title| strncmp}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
int strncmp( const char* lhs, const char* rhs, size_t count );
}}

Compares at most {{tt|count}} characters of two null-terminated byte strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated byte strings to compare}}
{{par | count | maximum number of characters to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main() 
{
    const char world[] = &quot;Hello, world!&quot;;
    const char everybody[] = &quot;Hello, everybody!&quot;;
    const char somebody[] = &quot;Hello, somebody!&quot;;

    // Compares 13 characters of &quot;Hello, world!&quot; and &quot;Hello, everybody!&quot;
    std::cout &lt;&lt; std::strncmp(world, everybody, sizeof(world) - 1) &lt;&lt; '\n';

    // Compares 13 characters of &quot;Hello, everybody!&quot; and &quot;Hello, world!&quot;
    std::cout &lt;&lt; std::strncmp(everybody, world, sizeof(world) - 1) &lt;&lt; '\n';

    // Compares 7 characters of &quot;Hello, everybody!&quot; and &quot;Hello, world!&quot;
    std::cout &lt;&lt; std::strncmp(everybody, world, sizeof(&quot;Hello, &quot;) - 1) &lt;&lt; '\n';

    // Compares 5 characters of &quot;Hello, everybody!&quot; and &quot;Hello, somebody!&quot;
    //                                       ^                      ^
    std::cout &lt;&lt; std::strncmp(&amp;everybody[12], &amp;somebody[11], sizeof(&quot;body!&quot;) - 1) &lt;&lt; '\n';
}
 | output=
1
-1
0
0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcmp}}
{{dsc inc | cpp/string/byte/dsc memcmp}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc see c | c/string/byte/strncmp}}
{{dsc end}}

[[de:cpp/string/byte/strncmp]]
[[es:cpp/string/byte/strncmp]]
[[fr:cpp/string/byte/strncmp]]
[[it:cpp/string/byte/strncmp]]
[[ja:cpp/string/byte/strncmp]]
[[pl:cpp/string/byte/strncmp]]
[[pt:cpp/string/byte/strncmp]]
[[ru:cpp/string/byte/strncmp]]
[[zh:cpp/string/byte/strncmp]]</text>
      <sha1>jurw3e9z3cyt5aby4xmg8d7d0phtnxg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strncpy</title>
    <ns>0</ns>
    <id>1753</id>
    <revision>
      <id>59014</id>
      <parentid>51242</parentid>
      <timestamp>2013-06-01T06:25:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1849">{{cpp/title| strncpy}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
char *strncpy( char *dest, const char *src, std::size_t count );
}}

Copies at most {{tt|count}} characters of the byte string pointed to by {{tt|src}} (including the terminating null character) to character array pointed to by {{tt|dest}}. 

If {{tt|count}} is reached before the entire string {{tt|src}} was copied, the resulting character array is not null-terminated.

If, after copying the terminating null character from {{tt|src}}, {{tt|count}} is not reached, additional null characters are written to {{tt|dest}} until the total of {{tt|count}} characters have been written.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the character array to copy to}}
{{par | src | pointer to the byte string to copy from}}
{{par | count | maximum number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    const char* src = &quot;hi&quot;;
    char dest[6] = {'a', 'b', 'c', 'd', 'e', 'f'};;
    std::strncpy(dest, src, 5);

    std::cout &lt;&lt; &quot;The contents of dest are: &quot;;
    for (char c : dest) {
        if (c) {
            std::cout &lt;&lt; c &lt;&lt; ' ';
        } else {
            std::cout &lt;&lt; &quot;\\0&quot; &lt;&lt; ' ';
        }
    }
    std::cout &lt;&lt; '\n';
}
 | output=
The contents of dest are: h i \0 \0 \0 f 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcpy}}
{{dsc inc | cpp/string/byte/dsc memcpy}}
{{dsc see c | c/string/byte/strncpy}}
{{dsc end}}

[[de:cpp/string/byte/strncpy]]
[[es:cpp/string/byte/strncpy]]
[[fr:cpp/string/byte/strncpy]]
[[it:cpp/string/byte/strncpy]]
[[ja:cpp/string/byte/strncpy]]
[[pt:cpp/string/byte/strncpy]]
[[ru:cpp/string/byte/strncpy]]
[[zh:cpp/string/byte/strncpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strpbrk</title>
    <ns>0</ns>
    <id>1754</id>
    <revision>
      <id>59015</id>
      <parentid>51243</parentid>
      <timestamp>2013-06-01T06:25:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1541">{{cpp/title| strpbrk}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
const char* strpbrk( const char* dest, const char* str );
}}
{{dcl |
      char* strpbrk(       char* dest, const char* str );
}}
{{dcl end}}

Finds the first character in byte string pointed to by {{tt|dest}}, that is also in byte string pointed to by {{tt|str}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | str | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
Pointer to the first character in {{tt|dest}}, that is also in {{tt|str}}, or {{lc|NULL}} if no such character exists.

===Example===
{{example
 |
 | code=
#include &lt;cstdio&gt;
#include &lt;cstring&gt;

int main() 
{
    char* input = &quot;hello world friend of mine&quot;;
    char* space = &quot; &quot;;
    char* pos = input;
    int word_counter = 0;

    do {
        pos = std::strpbrk(pos, space);
        word_counter++;
        pos ? pos++ : pos;
        std::printf(&quot;%d\n&quot;, word_counter);
    } while (pos != NULL);
};
 | output=
1
2
3
4
5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcspn}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc see c | c/string/byte/strpbrk}}
{{dsc end}}

[[de:cpp/string/byte/strpbrk]]
[[es:cpp/string/byte/strpbrk]]
[[fr:cpp/string/byte/strpbrk]]
[[it:cpp/string/byte/strpbrk]]
[[ja:cpp/string/byte/strpbrk]]
[[pt:cpp/string/byte/strpbrk]]
[[ru:cpp/string/byte/strpbrk]]
[[zh:cpp/string/byte/strpbrk]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strrchr</title>
    <ns>0</ns>
    <id>1755</id>
    <revision>
      <id>59018</id>
      <parentid>51244</parentid>
      <timestamp>2013-06-01T06:25:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1442">{{cpp/title| strrchr}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
const char* strrchr( const char* str, int ch );
}}
{{dcl | 1=
      char* strrchr(       char* str, int ch );
}}
{{dcl end}}

Finds the last occurrence of {{tt|ch}} (after conversion to {{c|char}}) in the byte string pointed to by {{tt|str}}. The terminating null character is considered to be a part of the string and can be found if searching for {{c|'\0'}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be analyzed}}
{{par | ch | character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or null pointer if no such character is found.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    char input[] = &quot;/home/user/hello.c&quot;;
    char* output = std::strrchr(input, '/');
    if(output)
        std::cout &lt;&lt; output+1 &lt;&lt; '\n';
}
 | output=
hello.c
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/wide/dsc wcsrchr}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc see c | c/string/byte/strrchr}}
{{dsc end}}

[[de:cpp/string/byte/strrchr]]
[[es:cpp/string/byte/strrchr]]
[[fr:cpp/string/byte/strrchr]]
[[it:cpp/string/byte/strrchr]]
[[ja:cpp/string/byte/strrchr]]
[[pt:cpp/string/byte/strrchr]]
[[ru:cpp/string/byte/strrchr]]
[[zh:cpp/string/byte/strrchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strspn</title>
    <ns>0</ns>
    <id>1756</id>
    <revision>
      <id>59019</id>
      <parentid>51245</parentid>
      <timestamp>2013-06-01T06:25:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1120">{{cpp/title| strspn}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cstring |
size_t strspn( const char *dest, const char *src );
}}

Returns the length of the maximum initial segment of the byte string pointed to by {{tt|dest}}, that consists of only the characters found in byte string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated byte string to be analyzed}}
{{par | src | pointer to the null-terminated byte string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters from byte string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcspn}}
{{dsc inc | cpp/string/byte/dsc strpbrk}}
{{dsc see c | c/string/byte/strspn}}
{{dsc end}}

[[de:cpp/string/byte/strspn]]
[[es:cpp/string/byte/strspn]]
[[fr:cpp/string/byte/strspn]]
[[it:cpp/string/byte/strspn]]
[[ja:cpp/string/byte/strspn]]
[[pt:cpp/string/byte/strspn]]
[[ru:cpp/string/byte/strspn]]
[[zh:cpp/string/byte/strspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strstr</title>
    <ns>0</ns>
    <id>1757</id>
    <revision>
      <id>65944</id>
      <parentid>59022</parentid>
      <timestamp>2013-10-16T12:13:19Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="1927">{{cpp/title| strstr}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
const char* strstr( const char* str, const char* target );
}}
{{dcl | 1=
      char* strstr(       char* str, const char* target );
}}
{{dcl end}}

Finds the first occurrence of the byte string {{tt|target}} in the byte string pointed to by {{tt|str}}. The terminating null characters are not compared.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to examine}}
{{par | target | pointer to the null-terminated byte string to search for}}
{{par end}}

===Return value===
Pointer to the first character of the found substring in {{tt|str}}, or {{lc|NULL}} if no such character is found. If {{tt|target}} points to an empty string, {{tt|str}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstring&gt;

int main()
{
    const char *str = &quot;Try not. Do, or do not. There is no try.&quot;;
    const char *target = &quot;not&quot;;
    const char *result = str;

    while ((result = std::strstr(result, target)) != NULL) {
        std::cout &lt;&lt; &quot;Found '&quot; &lt;&lt; target 
                  &lt;&lt; &quot;' starting at '&quot; &lt;&lt; result &lt;&lt; &quot;'\n&quot;;

        // Increment result, otherwise we'll find target at the same location
        ++result;
    }   
}
 | output=
Found 'not' starting at 'not. Do, or do not. There is no try.'
Found 'not' starting at 'not. There is no try.'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/wide/dsc wcsstr}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/byte/dsc strrchr}}
{{dsc see c | c/string/byte/strstr}}
{{dsc end}}

[[de:cpp/string/byte/strstr]]
[[es:cpp/string/byte/strstr]]
[[fr:cpp/string/byte/strstr]]
[[it:cpp/string/byte/strstr]]
[[ja:cpp/string/byte/strstr]]
[[pt:cpp/string/byte/strstr]]
[[ru:cpp/string/byte/strstr]]
[[tr:cpp/string/byte/strstr]]
[[zh:cpp/string/byte/strstr]]</text>
      <sha1>j5mgw7bpptl1lahhmg0orxrsmf26we3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtod</title>
    <ns>0</ns>
    <id>2119</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>14531</id>
      <parentid>14352</parentid>
      <timestamp>2011-11-27T01:41:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtof</title>
    <ns>0</ns>
    <id>1758</id>
    <revision>
      <id>62958</id>
      <parentid>59023</parentid>
      <timestamp>2013-07-01T23:47:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2098">{{cpp/title| strtof | strtod | strtold}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl | since=c++11 |
float       strtof( const char* str, char** str_end );           
}}
{{dcl | 
double      strtod( const char* str, char** str_end );
}}
{{dcl | since=c++11 |
long double strtold( const char* str, char** str_end );
}}
{{dcl end}}

Interprets a floating point value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par end}}

===Return value===
Floating point value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|HUGE_VAL}}, {{lc|HUGE_VALF}} or {{lc|HUGE_VALL}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 | 
 | code=
#include &lt;cstdlib&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::cout &lt;&lt; std::strtod(&quot;0.0000000123&quot;, nullptr) &lt;&lt; &quot;\n&quot;;
 
    // the second arg of strto* is non-const. We must copy the string
    char src[] = &quot;0.012  15e16 -0x1afp-2 inF Nan&quot;;
    char* c = src;
    
    std::cout &lt;&lt; std::strtod(c, &amp;c) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; std::strtod(c, &amp;c) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; std::strtod(c, &amp;c) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; std::strtod(c, &amp;c) &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; std::strtod(c, &amp;c) &lt;&lt; &quot;\n&quot;;
}
 | output=
1.23e-08
0.012
1.5e+17
-107.75
inf
nan
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc atof}}
{{dsc see c | c/string/byte/strtof | strtof | strtod | strtold}}
{{dsc end}}

[[de:cpp/string/byte/strtof]]
[[es:cpp/string/byte/strtof]]
[[fr:cpp/string/byte/strtof]]
[[it:cpp/string/byte/strtof]]
[[ja:cpp/string/byte/strtof]]
[[pt:cpp/string/byte/strtof]]
[[ru:cpp/string/byte/strtof]]
[[zh:cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtoimax</title>
    <ns>0</ns>
    <id>9530</id>
    <revision>
      <id>66729</id>
      <parentid>62959</parentid>
      <timestamp>2013-12-28T14:10:44Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2588">{{cpp/title| strtoimax| strtoumax}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cinttypes}}
{{dcl | since=c++11 | 
std::intmax_t strtoimax( const char* nptr, char** endptr, int base );
}}
{{dcl | since=c++11 |
std::uintmax_t strtoumax( const char* nptr, char** endptr, int base );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|nptr}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|endptr}} to point to the character past the last character interpreted. If {{tt|endptr}} is {{lc|NULL}}, it is ignored.

If the {{tt|nptr}} is empty or does not have the expected form, no conversion is performed, and (if {{tt|enptr}} is not {{lc|NULL}}) the value of {{tt|nptr}} is stored in the object pointed to by {{tt|endptr}}.

===Parameters===
{{par begin}}
{{par | nptr | pointer to the null-terminated byte string to be interpreted}}
{{par | endptr | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===

* If successful, an integer value corresponding to the contents of {{tt|str}} is returned.
* If the converted value falls out of range of corresponding return type, a range error occurs (setting {{lc|errno}} to {{lc|ERANGE}}) and {{lc|INTMAX_MAX}}, {{lc|INTMAX_MIN}}, {{lc|UINTMAX_MAX}} or {{c|0}} is returned, as appropriate.
* If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;cinttypes&gt;

int main()
{
    std::string str = &quot;helloworld&quot;;
    std::intmax_t val = std::strtoimax(str.c_str(), nullptr, 36);
    std::cout &lt;&lt; str &lt;&lt; &quot; in base 36 is &quot; &lt;&lt; val &lt;&lt; &quot; in base 10\n&quot;;

    char* nptr;
    val = std::strtoimax(str.c_str(), &amp;nptr, 30);
    if(nptr != &amp;str[0] + str.size())
        std::cout &lt;&lt; str &lt;&lt; &quot; in base 30 is invalid.&quot;
                  &lt;&lt; &quot; The first invalid digit is &quot; &lt;&lt; *nptr &lt;&lt; '\n';
}
 | output=
helloworld in base 36 is 1767707668033969 in base 10
helloworld in base 30 is invalid. The first invalid digit is w
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcstoimax}}
{{dsc inc | cpp/string/byte/dsc strtol}}
{{dsc inc | cpp/string/byte/dsc strtoul}}
{{dsc see c | c/string/byte/strtoimax | strtoimax | strtoumax}}
{{dsc end}}

[[de:cpp/string/byte/strtoimax]]
[[es:cpp/string/byte/strtoimax]]
[[fr:cpp/string/byte/strtoimax]]
[[it:cpp/string/byte/strtoimax]]
[[ja:cpp/string/byte/strtoimax]]
[[pt:cpp/string/byte/strtoimax]]
[[ru:cpp/string/byte/strtoimax]]
[[zh:cpp/string/byte/strtoimax]]</text>
      <sha1>cmemb8t4x5gydyijb77l65ngzbnknuv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtok</title>
    <ns>0</ns>
    <id>5515</id>
    <revision>
      <id>51249</id>
      <parentid>46730</parentid>
      <timestamp>2013-06-01T03:56:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="3021">{{cpp/title| strtok}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl | 1=
char* strtok( char* str, const char* delim );
}}
{{dcl end}}

Finds the next token in a null-terminated byte string pointed to by {{tt|str}}. The separator characters are identified by null-terminated byte string pointed to by {{tt|delim}}.

This function is designed to be called multiples times to obtain successive tokens from the same string.

* If {{c|str !{{=}} NULL}}, the call is treated as the first call to {{tt|strtok}} for this particular string. The function searches for the first character which is ''not'' contained in {{tt|delim}}.
:* If no such character was found, there are no tokens in {{tt|str}} at all, and the function returns a null pointer. 
:* If such character was found, is it the ''beginning of the token''. The function then searches from that point on for the first character that ''is'' contained in {{tt|delim}}. 
::* If no such character was found, {{tt|str}} has only one token, and the future calls to {{tt|strtok}} will return a null pointer
::* If such character was found, it is ''replaced'' by the null character {{c|'\0'}} and the pointer to the following character is stored in a static location for subsequent invocations.
:* The function then returns the pointer to the beginning of the token
* If {{c|str {{==}} NULL}}, the call is treated as a subsequent calls to {{tt|strtok}}: the function continues from where it left in previous invocation. The behavior is the same as if the previously stored pointer is passed as {{c|str}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to tokenize}}
{{par | delim | pointer to the null-terminated byte string identifying delimiters}}
{{par end}}

===Return value===
Pointer to the beginning of the next token or {{lc|NULL}} if there are no more tokens.

===Notes===
This function is destructive: it writes the {{c|'\0'}} characters in the elements of the string {{tt|str}}. In particular, a [[cpp/language/string_literal|string literal]] cannot be used as the first argument of {{tt|strtok}}.

Each call to this function modifies a static variable: is not thread safe.

Unlike most other tokenizers, the delimiters in {{tt|strtok}} can be different for each subsequent token, and can even depend on the contents of the previous tokens.

===Example===
{{example
 |
 | code=
#include &lt;cstring&gt;
#include &lt;iostream&gt;

int main() 
{
    char input[100] = &quot;A bird came down the walk&quot;;
    char *token = std::strtok(input, &quot; &quot;);
    while (token != NULL) {
        std::cout &lt;&lt; token &lt;&lt; '\n';
        token = std::strtok(NULL, &quot; &quot;);
    }
}
 | output=
A
bird
came
down
the
walk
}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/byte/strtok}}
{{dsc end}}

[[de:cpp/string/byte/strtok]]
[[es:cpp/string/byte/strtok]]
[[fr:cpp/string/byte/strtok]]
[[it:cpp/string/byte/strtok]]
[[ja:cpp/string/byte/strtok]]
[[pt:cpp/string/byte/strtok]]
[[ru:cpp/string/byte/strtok]]
[[zh:cpp/string/byte/strtok]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtol</title>
    <ns>0</ns>
    <id>1759</id>
    <revision>
      <id>69302</id>
      <parentid>69295</parentid>
      <timestamp>2014-04-02T17:14:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix return type, -endl.. Good idea demonstarting the overflow behavior.</comment>
      <text xml:space="preserve" bytes="2337">{{cpp/title| strtol | strtoll}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl | 
long      strtol( const char *str, char **str_end, int base );
}}
{{dcl | since=c++11 |
long long strtoll( const char *str, char **str_end, int base );
}}
{{dcl end}}

Interprets an integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

If the {{tt|str}} is empty or does not have the expected form, no conversion is performed, and (if {{tt|str_end}} is not {{lc|NULL}}) the value of {{tt|str}} is stored in the object pointed to by {{tt|str_end}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===

* If successful, an integer value corresponding to the contents of {{tt|str}} is returned.
* If the converted value falls out of range of corresponding return type, a range error occurs (setting {{lc|errno}} to {{lc|ERANGE}}) and {{lc|LONG_MAX}}, {{lc|LONG_MIN}}, {{lc|LLONG_MAX}} or {{lc|LLONG_MIN}} is returned. 
* If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
 
int main()
{
    const char* begin = &quot;10 20000000000000000000000 30 40&quot;;
    char *end;
    for (long i = std::strtol(begin, &amp;end, 10);
         begin != end;
         i = std::strtol(begin, &amp;end, 10))
    {
        begin = end;
        if (errno == ERANGE){
            std::cout &lt;&lt; &quot;range error\n&quot;;
            errno = 0;
        }     
        std::cout &lt;&lt; i &lt;&lt; '\n';
    }
}
 | output=
10
range error
9223372036854775807
30
40
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc atoi}}
{{dsc inc | cpp/string/byte/dsc strtoul}}
{{dsc see c | c/string/byte/strtol | strtol | strtoll}}
{{dsc end}}

[[de:cpp/string/byte/strtol]]
[[es:cpp/string/byte/strtol]]
[[fr:cpp/string/byte/strtol]]
[[it:cpp/string/byte/strtol]]
[[ja:cpp/string/byte/strtol]]
[[pt:cpp/string/byte/strtol]]
[[ru:cpp/string/byte/strtol]]
[[zh:cpp/string/byte/strtol]]</text>
      <sha1>htx7rtwjkdgbikm9h4dim8rgmwhg40b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtold</title>
    <ns>0</ns>
    <id>3687</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>15838</id>
      <parentid>14534</parentid>
      <timestamp>2011-12-17T02:22:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix infinite redirect</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtoll</title>
    <ns>0</ns>
    <id>3685</id>
    <redirect title="cpp/string/byte/strtol" />
    <revision>
      <id>14535</id>
      <parentid>14360</parentid>
      <timestamp>2011-11-27T01:42:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtoul</title>
    <ns>0</ns>
    <id>1760</id>
    <revision>
      <id>69303</id>
      <parentid>69293</parentid>
      <timestamp>2014-04-02T17:15:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-endl</comment>
      <text xml:space="preserve" bytes="2090">{{cpp/title| strtoul | strtoull}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl | 
unsigned long      strtoul( const char *str, char **str_end, int base );
}}
{{dcl | since=c++11 |
unsigned long long strtoull( const char *str, char **str_end, int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a byte string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated byte string to be interpreted}}
{{par | str_end | pointer to a pointer to character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|ULONG_MAX}} or {{lc|ULLONG_MAX}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
 
int main()
{
    const char* begin = &quot;10 200000000000000000000000000000 30 40&quot;;
    char *end;
    for (unsigned long i = std::strtoul(begin, &amp;end, 10);
         begin != end;
         i = std::strtoul(begin, &amp;end, 10))
    {
        begin = end;
        if (errno == ERANGE){
            std::cout &lt;&lt; &quot;range error\n&quot;;
            errno = 0;
        }    
        std::cout &lt;&lt; i &lt;&lt; '\n';
    }
}
 | output=
10
range error
18446744073709551615
30
40
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc atoi}}
{{dsc inc | cpp/string/byte/dsc strtol}}
{{dsc see c | c/string/byte/strtoul | strtoul | strtoull}}
{{dsc end}}

[[de:cpp/string/byte/strtoul]]
[[es:cpp/string/byte/strtoul]]
[[fr:cpp/string/byte/strtoul]]
[[it:cpp/string/byte/strtoul]]
[[ja:cpp/string/byte/strtoul]]
[[pt:cpp/string/byte/strtoul]]
[[ru:cpp/string/byte/strtoul]]
[[zh:cpp/string/byte/strtoul]]</text>
      <sha1>h6qdbyi323tw5c8ixpf2665sca6u1f3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strtoull</title>
    <ns>0</ns>
    <id>3686</id>
    <redirect title="cpp/string/byte/strtoul" />
    <revision>
      <id>14537</id>
      <parentid>14364</parentid>
      <timestamp>2011-11-27T01:44:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strtoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/strxfrm</title>
    <ns>0</ns>
    <id>2124</id>
    <revision>
      <id>69168</id>
      <parentid>59031</parentid>
      <timestamp>2014-03-28T18:15:54Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2734">{{cpp/title|strxfrm}}
{{cpp/string/byte/navbar}}
{{dcl begin}}
{{dcl header | cstring}}
{{dcl |
std::size_t strxfrm( char* dest, const char* src, std::size_t count );
}}
{{dcl end}}

Transforms the null-terminated byte string pointed to by {{tt|src}} into the implementation-defined form such that comparing two transformed strings with {{lc|std::strcmp}} gives the same result as comparing the original strings with {{lc|std::strcoll}}, in the current C locale.

The first {{tt|count}} characters of the transformed string are written to destination, including the terminating null character, and the length of the full transformed string is returned, excluding the terminating null character.

If {{tt|count}} is {{c|0}}, then {{tt|dest}} is allowed to be a null pointer.

===Notes===
The correct length of the buffer that can receive the entire transformed string is {{c|1+std::strxfrm(NULL, src, 0)}}

===Parameters===
{{par begin}}
{{par| dest | pointer to the first element of the array where the transformed string will be written }}
{{par| src | pointer to the first character of a null-terminated byte string to transform}}
{{par| count | maximum number of characters to be written }}
{{par end}}

===Return value===
The length of the transformed string, not including the terminating null-character.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;cstring&gt;
#include &lt;string&gt;

int main()
{
    std::setlocale(LC_COLLATE, &quot;cs_CZ.iso88592&quot;);

    std::string in1 = &quot;hrnec&quot;;
    std::string out1(1+std::strxfrm(nullptr, in1.c_str(), 0), ' ');
    std::string in2 = &quot;chrt&quot;;
    std::string out2(1+std::strxfrm(nullptr, in2.c_str(), 0), ' ');

    std::strxfrm(&amp;out1[0], in1.c_str(), out1.size());
    std::strxfrm(&amp;out2[0], in2.c_str(), out2.size());

    std::cout &lt;&lt; &quot;In the Czech locale: &quot;;
    if(out1 &lt; out2)
         std::cout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::cout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;In lexicographical comparison: &quot;;
    if(in1 &lt; in2)
         std::cout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::cout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

}
 | output=
In the Czech locale: hrnec before chrt
In lexicographical comparison: chrt before hrnec
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcsxfrm}}
{{dsc inc | cpp/locale/collate/dsc do_transform}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc see c | c/string/byte/strxfrm}}
{{dsc end}}

[[de:cpp/string/byte/strxfrm]]
[[es:cpp/string/byte/strxfrm]]
[[fr:cpp/string/byte/strxfrm]]
[[it:cpp/string/byte/strxfrm]]
[[ja:cpp/string/byte/strxfrm]]
[[pt:cpp/string/byte/strxfrm]]
[[ru:cpp/string/byte/strxfrm]]
[[zh:cpp/string/byte/strxfrm]]</text>
      <sha1>7d72ofj3sx5hauhqfuwudmfilrbgh2p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/tolower</title>
    <ns>0</ns>
    <id>1761</id>
    <revision>
      <id>66158</id>
      <parentid>66149</parentid>
      <timestamp>2013-11-09T19:12:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1909">{{cpp/title|tolower}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int tolower( int ch );
}}

Converts the given character to lowercase according to the character conversion rules defined by the currently installed C locale.

In the default &quot;C&quot; locale, the following uppercase letters {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}} are replaced with respective lowercase letters {{tt|abcdefghijklmnopqrstuvwxyz}}.

===Parameters===
{{par begin}}
{{par | ch | character to be converted. If the value of {{tt|ch}} is not representable as {{c|unsigned char}} and does not equal {{c|EOF}}, the behavior is undefined}}
{{par end}}

===Return value===
Lowercase version of {{tt|ch}} or unmodified {{tt|ch}} if no lowercase version is listed in the current C locale.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\xb4'; // the character Ž in ISO-8859-15
                              // but ´ (acute accent) in ISO-8859-1 

    std::setlocale(LC_ALL, &quot;en_US.iso88591&quot;);
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    std::cout &lt;&lt; &quot;in iso8859-1, tolower('0xb4') gives &quot;
              &lt;&lt; std::tolower(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.iso885915&quot;);
    std::cout &lt;&lt; &quot;in iso8859-15, tolower('0xb4') gives &quot;
              &lt;&lt; std::tolower(c) &lt;&lt; '\n';
}
| output=
in iso8859-1, tolower('0xb4') gives 0xb4
in iso8859-15, tolower('0xb4') gives 0xb8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc inc | cpp/locale/dsc tolower}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc see c | c/string/byte/tolower}}
{{dsc end}}

[[de:cpp/string/byte/tolower]]
[[es:cpp/string/byte/tolower]]
[[fr:cpp/string/byte/tolower]]
[[it:cpp/string/byte/tolower]]
[[ja:cpp/string/byte/tolower]]
[[pl:cpp/string/byte/tolower]]
[[pt:cpp/string/byte/tolower]]
[[ru:cpp/string/byte/tolower]]
[[zh:cpp/string/byte/tolower]]</text>
      <sha1>p2pcu2mdaqhufzyrles8cyl61rjr57t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/byte/toupper</title>
    <ns>0</ns>
    <id>1762</id>
    <revision>
      <id>66943</id>
      <parentid>66159</parentid>
      <timestamp>2014-01-10T14:24:27Z</timestamp>
      <contributor>
        <ip>77.8.45.122</ip>
      </contributor>
      <comment>fixed lowercase &lt;-&gt; uppercase mixup</comment>
      <text xml:space="preserve" bytes="1887">{{cpp/title|toupper}}
{{cpp/string/byte/navbar}}
{{ddcl | header=cctype |
int toupper( int ch );
}}

Converts the given character to uppercase according to the character conversion rules defined by the currently installed C locale.

In the default &quot;C&quot; locale, the following lowercase letters {{tt|abcdefghijklmnopqrstuvwxyz}} are replaced with respective uppercase letters {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}.

===Parameters===
{{par begin}}
{{par | ch | character to be converted. If the value of {{tt|ch}} is not representable as {{c|unsigned char}} and does not equal {{c|EOF}}, the behavior is undefined.}}
{{par end}}

===Return value===
Converted character or {{tt|ch}} if no uppercase version is defined by the current C locale.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cctype&gt;
#include &lt;clocale&gt;

int main()
{
    unsigned char c = '\xb8'; // the character ž in ISO-8859-15
                              // but ¸ (cedilla) in ISO-8859-1 

    std::setlocale(LC_ALL, &quot;en_US.iso88591&quot;);
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    std::cout &lt;&lt; &quot;in iso8859-1, toupper('0xb8') gives &quot; &lt;&lt; std::toupper(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.iso885915&quot;);
    std::cout &lt;&lt; &quot;in iso8859-15, toupper('0xb8') gives &quot; &lt;&lt; std::toupper(c) &lt;&lt; '\n';
}
| output=
in iso8859-1, toupper('0xb8') gives 0xb8
in iso8859-15, toupper('0xb8') gives 0xb4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc inc | cpp/locale/dsc toupper}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc see c | c/string/byte/toupper}}
{{dsc end}}

[[de:cpp/string/byte/toupper]]
[[es:cpp/string/byte/toupper]]
[[fr:cpp/string/byte/toupper]]
[[it:cpp/string/byte/toupper]]
[[ja:cpp/string/byte/toupper]]
[[ko:cpp/string/byte/toupper]]
[[pl:cpp/string/byte/toupper]]
[[pt:cpp/string/byte/toupper]]
[[ru:cpp/string/byte/toupper]]
[[zh:cpp/string/byte/toupper]]</text>
      <sha1>fyoixi2frg617vccr64rq632dge6ckt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits</title>
    <ns>0</ns>
    <id>2238</id>
    <revision>
      <id>72075</id>
      <parentid>69962</parentid>
      <timestamp>2014-07-12T05:31:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>std::int_least16_t =&gt; std::uint_least16_t</comment>
      <text xml:space="preserve" bytes="4475">{{cpp/title|char_traits}}
{{cpp/string/char_traits/navbar}}
{{ddcl | header=string | 1=
template&lt;
    class CharT 
&gt; class char_traits;
}}

The {{tt|char_traits}} class is a traits class template that abstracts basic character and string operations for a given character type. The defined operation set is such that generic algorithms almost always can be implemented in terms of it. It is thus possible to use such algorithms with almost any possible character or string type, just by supplying customized {{tt|char_traits}} class.

The {{tt|char_traits}} class template serves as a basis for explicit instantiations. The user can provide a specialization for any custom character types. Several specializations are defined for the standard character types. The values of the member typedefs are as follows.

{| class=&quot;wikitable&quot;
|-
! Instantiation 
! {{tt|char_type}}
! {{tt|int_type}}
! {{tt|off_type}}
! {{tt|pos_type}}
! {{tt|state_type}}
|-
| {{c|char_traits&lt;char&gt;}} 
| {{c|char}}
| {{c|int}}
| {{lc|std::streamoff}}
| {{lc|std::streampos}}
| {{lc|std::mbstate_t}}
|-
| {{c|char_traits&lt;wchar_t&gt;}}
| {{c|wchar_t}}
| {{lc|std::wint_t}}
| {{lc|std::wstreamoff}}
| {{lc|std::wstreampos}}
| {{lc|std::mbstate_t}}
|-
| {{c|char_traits&lt;char16_t&gt;}} {{mark c++11}}
| {{c|char16_t}}
| {{lc|std::uint_least16_t}}
| {{lc|std::streamoff}} 
| {{lc|std::u16streampos}}
| {{lc|std::mbstate_t}}
|-
| {{c|char_traits&lt;char32_t&gt;}} {{mark c++11}}
| {{c|char32_t}}
| {{lc|std::uint_least32_t}}
| {{lc|std::streamoff}} 
| {{lc|std::u32streampos}}
| {{lc|std::mbstate_t}}
|}

The {{tt|char_traits}} class template fulfills all requirements of {{concept|Traits}} concept.

{{todo|reason=simplify the description, emphasize that char_traits can be user defined}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|int_type}} | an integer type that can hold all values of {{tt|char_type}} plus {{tt|EOF}}}}
{{dsc | {{tt|off_type}} | ''implementation-defined''}}
{{dsc | {{tt|pos_type}} | ''implementation-defined''}}
{{dsc | {{tt|state_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/string/char_traits/dsc assign}}
{{dsc inc | cpp/string/char_traits/dsc cmp}}
{{dsc inc | cpp/string/char_traits/dsc move}}
{{dsc inc | cpp/string/char_traits/dsc copy}}
{{dsc inc | cpp/string/char_traits/dsc compare}}
{{dsc inc | cpp/string/char_traits/dsc length}}
{{dsc inc | cpp/string/char_traits/dsc find}}
{{dsc inc | cpp/string/char_traits/dsc to_char_type}}
{{dsc inc | cpp/string/char_traits/dsc to_int_type}}
{{dsc inc | cpp/string/char_traits/dsc eq_int_type}}
{{dsc inc | cpp/string/char_traits/dsc eof}}
{{dsc inc | cpp/string/char_traits/dsc not_eof}}
{{dsc end}}

===Example===
{{example
 | User-defined character traits may be used to provide [http://www.gotw.ca/gotw/029.htm case-insensitive comparison]
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;cctype&gt;

struct ci_char_traits : public std::char_traits&lt;char&gt; {
    static bool eq(char c1, char c2) {
         return std::toupper(c1) == std::toupper(c2);
     }
    static bool lt(char c1, char c2) {
         return std::toupper(c1) &lt;  std::toupper(c2);
    }
    static int compare(const char* s1, const char* s2, size_t n) {
        while ( n-- != 0 ) {
            if ( std::toupper(*s1) &lt; std::toupper(*s2) ) return -1;
            if ( std::toupper(*s1) &gt; std::toupper(*s2) ) return 1;
            ++s1; ++s2;
        }
        return 0;
    }
    static const char* find(const char* s, int n, char a) {
        auto const ua (std::toupper(a));
        while ( n-- != 0 ) 
        {
            if (std::toupper(*s) == ua)
                return s;
            s++;
        }
        return nullptr;
    }
};

typedef std::basic_string&lt;char, ci_char_traits&gt; ci_string;

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const ci_string&amp; str) {
    return os.write(str.data(), str.size());
}

int main()
{
    ci_string s1 = &quot;Hello&quot;;
    ci_string s2 = &quot;heLLo&quot;;
    if (s1 == s2)
        std::cout &lt;&lt; s1 &lt;&lt; &quot; and &quot; &lt;&lt; s2 &lt;&lt; &quot; are equal\n&quot;;
}
| output=
Hello and heLLo are equal
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/dsc basic_string}}
{{dsc end}}

[[de:cpp/string/char traits]]
[[es:cpp/string/char traits]]
[[fr:cpp/string/char traits]]
[[it:cpp/string/char traits]]
[[ja:cpp/string/char traits]]
[[pt:cpp/string/char traits]]
[[ru:cpp/string/char traits]]
[[zh:cpp/string/char traits]]</text>
      <sha1>oke3ptmxqnozsiufhat3ovc9cyyw2oc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/assign</title>
    <ns>0</ns>
    <id>9105</id>
    <revision>
      <id>64879</id>
      <parentid>61900</parentid>
      <timestamp>2013-08-27T01:44:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1232">{{cpp/string/char_traits/title|assign}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | num=1 |
static void assign( char_type&amp; r, const char_type&amp; a );
}}
{{dcl | num=2 |
static char_type* assign( char_type* p, std::size_t count, char_type a );
}}
{{dcl end}}

Assigns a character.

@1@ Assigns character {{tt|a}} to character {{tt|r}}.
@2@ Assigns character {{tt|a}} to each character in {{tt|count}} characters in the character sequence pointed to by {{tt|p}}.

===Parameters===
{{par begin}}
{{par | a | character value to assign}}
{{par | r | character to assign to}}
{{par | p | pointer to a character sequence to assign to}}
{{par | count | the length of the character sequence}}
{{par end}}

===Return value===
@1@ (none)
@2@ {{tt|p}}

===Exceptions===
@1@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
@2@ (none)

===Complexity===
@1@ Constant.
@2@ Linear in {{tt|count}}

[[de:cpp/string/char traits/assign]]
[[es:cpp/string/char traits/assign]]
[[fr:cpp/string/char traits/assign]]
[[it:cpp/string/char traits/assign]]
[[ja:cpp/string/char traits/assign]]
[[pt:cpp/string/char traits/assign]]
[[ru:cpp/string/char traits/assign]]
[[zh:cpp/string/char traits/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/cmp</title>
    <ns>0</ns>
    <id>9106</id>
    <revision>
      <id>66135</id>
      <parentid>66134</parentid>
      <timestamp>2013-11-05T23:14:35Z</timestamp>
      <contributor>
        <username>IMneme</username>
        <id>2601</id>
      </contributor>
      <minor/>
      <comment>Move information slightly on page.</comment>
      <text xml:space="preserve" bytes="1552">{{cpp/string/char_traits/title|eq|lt}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
static bool eq( char_type a, char_type b );
}}
{{dcl | since=c++11 |
static constexpr bool eq( char_type a, char_type b );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
static bool lt( char_type a, char_type b );
}}
{{dcl | since=c++11 |
static constexpr bool lt( char_type a, char_type b );
}}
{{dcl rev end}}
{{dcl end}}

Compares two characters.

@1@ Compares {{tt|a}} and {{tt|b}} for equality.
@2@ Compares {{tt|a}} and {{tt|b}} in such a way that they are totally ordered.

{{rev begin}}
{{rev | since=c++11 |
For the {{tt|char}} specialization, {{tt|eq}} and {{tt|lt}} are defined identically to the built-in operators {{tt|{{==}}}} and {{tt|&amp;lt;}} for type {{tt|unsigned char}} (''not'' {{tt|char}}).
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | a, b | character values to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if {{tt|a}} and {{tt|b}} are equal, {{c|false}} otherwise.
@2@ {{c|true}} if {{tt|a}} is ''less'' than {{tt|b}}, {{c|false}} otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

[[de:cpp/string/char traits/cmp]]
[[es:cpp/string/char traits/cmp]]
[[fr:cpp/string/char traits/cmp]]
[[it:cpp/string/char traits/cmp]]
[[ja:cpp/string/char traits/cmp]]
[[pt:cpp/string/char traits/cmp]]
[[ru:cpp/string/char traits/cmp]]
[[zh:cpp/string/char traits/cmp]]</text>
      <sha1>0zq4xx2nsfxcidq7djqqrqdobown4lh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/compare</title>
    <ns>0</ns>
    <id>9117</id>
    <revision>
      <id>62046</id>
      <parentid>62045</parentid>
      <timestamp>2013-06-19T19:50:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>n -&gt; count</comment>
      <text xml:space="preserve" bytes="1129">{{cpp/string/char_traits/title|compare}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | 
static int compare( const char_type* s1, const char_type* s2, std::size_t count );
}}
{{dcl end}}

Compares the first {{tt|count}} characters of the character strings {{tt|s1}} and {{tt|s2}}. The comparison is done lexicographically.

If {{tt|count}} is zero, strings are considered equal.

===Parameters===
{{par begin}}
{{par | s1, s2 | pointers to character strings to compare}}
{{par | count | the number of characters to compare from each character string}}
{{par end}}

===Return value===
Negative value if {{tt|s1}} is ''less than'' {{tt|s2}}.

{{c|0}} if {{tt|s1}} is ''equal to'' {{tt|s2}}.

Positive value if {{tt|s1}} is ''greater than'' {{tt|s2}}.

===Exceptions===
(none)

===Complexity===
Linear in {{tt|count}}.

[[de:cpp/string/char traits/compare]]
[[es:cpp/string/char traits/compare]]
[[fr:cpp/string/char traits/compare]]
[[it:cpp/string/char traits/compare]]
[[ja:cpp/string/char traits/compare]]
[[pt:cpp/string/char traits/compare]]
[[ru:cpp/string/char traits/compare]]
[[zh:cpp/string/char traits/compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/copy</title>
    <ns>0</ns>
    <id>9116</id>
    <revision>
      <id>51259</id>
      <parentid>46297</parentid>
      <timestamp>2013-06-01T03:56:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1015">{{cpp/string/char_traits/title|copy}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | 
static char_type* copy( char_type* dest, const char_type* src, std::size_t count );
}}
{{dcl end}}

Copies {{tt|count}} character from character string pointed to by {{tt|src}} to character string pointed to by {{tt|dest}}.

The behavior is undefined if copied character ranges overlap, i.e. {{tt|src}} is in [{{tt|dest}}, {{tt|dest + count}}).

===Parameters===
{{par begin}}
{{par | dest | pointer to a character string to copy to}}
{{par | src | pointer to a character string to copy from}}
{{par | count | the number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Exceptions===
(none)

===Complexity===
Linear.

[[de:cpp/string/char traits/copy]]
[[es:cpp/string/char traits/copy]]
[[fr:cpp/string/char traits/copy]]
[[it:cpp/string/char traits/copy]]
[[ja:cpp/string/char traits/copy]]
[[pt:cpp/string/char traits/copy]]
[[ru:cpp/string/char traits/copy]]
[[zh:cpp/string/char traits/copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/eof</title>
    <ns>0</ns>
    <id>9107</id>
    <revision>
      <id>64881</id>
      <parentid>61908</parentid>
      <timestamp>2013-08-27T01:45:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="918">{{cpp/string/char_traits/title|eof}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
static int_type eof();
}}
{{dcl | since=c++11 |
static constexpr int_type eof();
}}
{{dcl rev end}}
{{dcl end}}

Returns a value not equivalent to any value of type {{tt|char_type}}.

===Parameters===
(none)

===Return value===
A value not equivalent to any value of type {{tt|char_type}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/char_traits/dsc not_eof}}
{{dsc end}}

[[de:cpp/string/char traits/eof]]
[[es:cpp/string/char traits/eof]]
[[fr:cpp/string/char traits/eof]]
[[it:cpp/string/char traits/eof]]
[[ja:cpp/string/char traits/eof]]
[[pt:cpp/string/char traits/eof]]
[[ru:cpp/string/char traits/eof]]
[[zh:cpp/string/char traits/eof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/eq int type</title>
    <ns>0</ns>
    <id>9109</id>
    <revision>
      <id>64883</id>
      <parentid>61906</parentid>
      <timestamp>2013-08-27T01:45:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1014">{{cpp/string/char_traits/title|eq_int_type}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
static bool eq_int_type( int_type c1, int_type c2 );
}}
{{dcl | since=c++11 |
static constexpr bool eq_int_type( int_type c1, int_type c2 );
}}
{{dcl rev end}}
{{dcl end}}

Checks whether two values of type {{tt|int_type}} are equal.

===Parameters===
{{par begin}}
{{par | c1, c2 | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{tt|c1}} is equal to {{tt|c2}}, {{c|false}} otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

[[de:cpp/string/char traits/eq int type]]
[[es:cpp/string/char traits/eq int type]]
[[fr:cpp/string/char traits/eq int type]]
[[it:cpp/string/char traits/eq int type]]
[[ja:cpp/string/char traits/eq int type]]
[[pt:cpp/string/char traits/eq int type]]
[[ru:cpp/string/char traits/eq int type]]
[[zh:cpp/string/char traits/eq int type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/find</title>
    <ns>0</ns>
    <id>9111</id>
    <revision>
      <id>62040</id>
      <parentid>51262</parentid>
      <timestamp>2013-06-19T18:50:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1023">{{cpp/string/char_traits/title|find}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | 
static const char_type* find( const char_type* p, std::size_t count, const char_type&amp; ch );
}}
{{dcl end}}

Searches for character {{tt|ch}} within the first {{tt|count}} characters of the sequence pointed to by {{tt|p}}.

===Parameters===
{{par begin}}
{{par | p | pointer to a character string to search}}
{{par | count | the number of characters to analyze}}
{{par | ch | the character to search for}}
{{par end}}

===Return value===
A pointer to the first character in the range specified by {{tt|[p, p + count)}} that compares equal to {{tt|ch}}, or {{lc|NULL}} if not found.

===Exceptions===
(none)

===Complexity===
Linear in {{tt|count}}.

[[de:cpp/string/char traits/find]]
[[es:cpp/string/char traits/find]]
[[fr:cpp/string/char traits/find]]
[[it:cpp/string/char traits/find]]
[[ja:cpp/string/char traits/find]]
[[pt:cpp/string/char traits/find]]
[[ru:cpp/string/char traits/find]]
[[zh:cpp/string/char traits/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/length</title>
    <ns>0</ns>
    <id>9110</id>
    <revision>
      <id>67294</id>
      <parentid>65314</parentid>
      <timestamp>2014-02-03T19:11:27Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <comment>Corrected the misspelling of the character type.</comment>
      <text xml:space="preserve" bytes="1182">{{cpp/string/char_traits/title|length}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | 
static std::size_t length( const char_type* s );
}}
{{dcl end}}

Returns the length of the character sequence pointed to by {{tt|s}}, that is, the position of the terminating null character ({{c|CharT()}}).

===Parameters===
{{par begin}}
{{par | s | pointer to a character sequence to return length of}}
{{par end}}

===Return value===
The length of character sequence pointed to by {{tt|s}}.

===Exceptions===
(none)

===Complexity===
Linear.

===Example===
{{
example
| code=
#include &lt;iostream&gt;

void print(const char* str)
{
  std::cout &lt;&lt; &quot;string '&quot; &lt;&lt; str &lt;&lt; &quot;' &quot;;
  std::cout &lt;&lt; &quot;length = &quot; &lt;&lt; std::char_traits&lt;char&gt;::length(str) &lt;&lt; '\n';
}

int main()
{
  print(&quot;foo&quot;);

  std::string s(&quot;booo&quot;);
  print(s.c_str());
}
| output=
string 'foo' length = 3
string 'booo' length = 4
}}

[[de:cpp/string/char traits/length]]
[[es:cpp/string/char traits/length]]
[[fr:cpp/string/char traits/length]]
[[it:cpp/string/char traits/length]]
[[ja:cpp/string/char traits/length]]
[[pt:cpp/string/char traits/length]]
[[ru:cpp/string/char traits/length]]
[[zh:cpp/string/char traits/length]]</text>
      <sha1>plmm0ucvfs7x8y0xdn8s7ggrpqszdwq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/move</title>
    <ns>0</ns>
    <id>9115</id>
    <revision>
      <id>51264</id>
      <parentid>46298</parentid>
      <timestamp>2013-06-01T03:57:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1017">{{cpp/string/char_traits/title|move}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl | 
static char_type* move( char_type* dest, const char_type* src, std::size_t count );
}}
{{dcl end}}

Copies {{tt|count}} character from character string pointed to by {{tt|src}} to character string pointed to by {{tt|dest}}.

Performs correctly even if the copied character ranges overlap, i.e. {{tt|src}} is in [{{tt|dest}}, {{tt|dest + count}}).

===Parameters===
{{par begin}}
{{par | dest | pointer to a character string to copy to}}
{{par | src | pointer to a character string to copy from}}
{{par | count | the number of characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Exceptions===
(none)

===Complexity===
Linear.

[[de:cpp/string/char traits/move]]
[[es:cpp/string/char traits/move]]
[[fr:cpp/string/char traits/move]]
[[it:cpp/string/char traits/move]]
[[ja:cpp/string/char traits/move]]
[[pt:cpp/string/char traits/move]]
[[ru:cpp/string/char traits/move]]
[[zh:cpp/string/char traits/move]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/not eof</title>
    <ns>0</ns>
    <id>9108</id>
    <revision>
      <id>64882</id>
      <parentid>61907</parentid>
      <timestamp>2013-08-27T01:45:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1047">{{cpp/string/char_traits/title|not_eof}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
static int_type not_eof( int_type e );
}}
{{dcl | since=c++11 |
static constexpr int_type not_eof( int_type e );
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|e}} is not equivalent to ''eof'' value.

===Parameters===
{{par begin}}
{{par | e | value to analyze}}
{{par end}}

===Return value===
{{tt|e}} if {{tt|e}} and ''eof'' value are not equivalent, some other value otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/char_traits/dsc eof}}
{{dsc end}}

[[de:cpp/string/char traits/not eof]]
[[es:cpp/string/char traits/not eof]]
[[fr:cpp/string/char traits/not eof]]
[[it:cpp/string/char traits/not eof]]
[[ja:cpp/string/char traits/not eof]]
[[pt:cpp/string/char traits/not eof]]
[[ru:cpp/string/char traits/not eof]]
[[zh:cpp/string/char traits/not eof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/to char type</title>
    <ns>0</ns>
    <id>9112</id>
    <revision>
      <id>64884</id>
      <parentid>61899</parentid>
      <timestamp>2013-08-27T01:45:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="1023">{{cpp/string/char_traits/title|to_char_type}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
static char_type to_char_type( int_type c );
}}
{{dcl | since=c++11 | 
static constexpr char_type to_char_type( int_type c );
}}
{{dcl rev end}}
{{dcl end}}

Converts a value of {{tt|int_type}} to {{tt|char_type}}. If there are no equivalent value, the results are unspecified.

===Parameters===
{{par begin}}
{{par | c | value to convert}}
{{par end}}

===Return value===
A value equivalent to {{tt|c}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

[[de:cpp/string/char traits/to char type]]
[[es:cpp/string/char traits/to char type]]
[[fr:cpp/string/char traits/to char type]]
[[it:cpp/string/char traits/to char type]]
[[ja:cpp/string/char traits/to char type]]
[[pt:cpp/string/char traits/to char type]]
[[ru:cpp/string/char traits/to char type]]
[[zh:cpp/string/char traits/to char type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/char traits/to int type</title>
    <ns>0</ns>
    <id>9113</id>
    <revision>
      <id>64885</id>
      <parentid>61898</parentid>
      <timestamp>2013-08-27T01:45:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="949">{{cpp/string/char_traits/title|to_int_type}}
{{cpp/string/char_traits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
static int_type to_int_type( char_type c );
}}
{{dcl | since=c++11 | 
static constexpr int_type to_int_type( char_type c );
}}
{{dcl rev end}}
{{dcl end}}

Converts a value of {{tt|char_type}} to {{tt|int_type}}.

===Parameters===
{{par begin}}
{{par | c | value to convert}}
{{par end}}

===Return value===
A value equivalent to {{tt|c}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Complexity===
Constant.

[[de:cpp/string/char traits/to int type]]
[[es:cpp/string/char traits/to int type]]
[[fr:cpp/string/char traits/to int type]]
[[it:cpp/string/char traits/to int type]]
[[ja:cpp/string/char traits/to int type]]
[[pt:cpp/string/char traits/to int type]]
[[ru:cpp/string/char traits/to int type]]
[[zh:cpp/string/char traits/to int type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/getline</title>
    <ns>0</ns>
    <id>2749</id>
    <redirect title="cpp/string/basic string/getline" />
    <revision>
      <id>10410</id>
      <timestamp>2011-09-12T18:41:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/getline]] to [[cpp/string/basic string/getline]]</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/string/basic string/getline]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte</title>
    <ns>0</ns>
    <id>3899</id>
    <revision>
      <id>71109</id>
      <parentid>59041</parentid>
      <timestamp>2014-06-06T12:06:50Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="3762">{{title|Null-terminated multibyte strings}}
{{cpp/string/multibyte/navbar}}

A null-terminated multibyte string (NTMBS), or &quot;multibyte string&quot;, is a sequence of nonzero bytes followed by a byte with value zero (the terminating null character).

Each character stored in the string may occupy more than one byte. The encoding used to represent characters in a multibyte character string is locale-specific: it may be UTF-8, GB18030, EUC-JP, Shift-JIS, etc. For example, the char array {{c|{'\xe4','\xbd','\xa0','\xe5','\xa5','\xbd','\0'}}} is an NTMBS holding the string {{c|&quot;你好&quot;}} in UTF-8 multibyte encoding: the first three bytes encode the character 你, the next three bytes encode the character 好. The same string encoded in GB18030 is the char array {{c|{'\xc4', '\xe3', '\xba', '\xc3', '\0'}}}, where each of the two characters is encoded as a two-byte sequence.

In some multibyte encodings, any given multibyte character sequence may represent different characters depending on the previous byte sequences, known as &quot;shift sequences&quot;. Such encodings are known as state-dependent: knowledge of the current shift state is required to interpret each character. An NTMBS is only valid if it begins and ends in the initial shift state: if a shift sequence was used, the corresponding unshift sequence has to be present before the terminating null character. Examples of such encodings are the 7-bit JIS, BOCU-1 and SCSU.

A multibyte character string is layout-compatible with null-terminated byte string (NTBS), that is, can be stored, copied, and examined using the same facilities, except for calculating the number of characters. If the correct locale is in effect, I/O functions also handle multibyte strings. Multibyte strings can be converted to and from wide strings using the {{lc|std::codecvt}} member functions, {{lc|std::wstring_convert}}, or the following locale-dependent conversion functions:

===Multibyte/wide character conversions===
{{dsc begin}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/string/multibyte/dsc mblen}}
{{dsc inc | cpp/string/multibyte/dsc mbtowc}}
{{dsc inc | cpp/string/multibyte/dsc wctomb}}
{{dsc inc | cpp/string/multibyte/dsc mbstowcs}}
{{dsc inc | cpp/string/multibyte/dsc wcstombs}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/multibyte/dsc mbsinit}}
{{dsc inc | cpp/string/multibyte/dsc btowc}}
{{dsc inc | cpp/string/multibyte/dsc wctob}}
{{dsc inc | cpp/string/multibyte/dsc mbrlen}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}
{{dsc header | cuchar}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc16}}
{{dsc inc | cpp/string/multibyte/dsc c16rtomb}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc32}}
{{dsc inc | cpp/string/multibyte/dsc c32rtomb}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/multibyte/dsc mbstate_t}}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc header | climits}}
{{dsc inc | cpp/string/multibyte/dsc MB_LEN_MAX}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/string/multibyte/dsc MB_CUR_MAX}}
{{dsc header | cuchar}}
{{dsc macro const | __STDC_UTF_16__ |  nolink=true | indicates that UTF-16 encoding is used by mbrtoc16 and c16rtomb}}
{{dsc macro const | __STDC_UTF_32__ |  nolink=true | indicates that UTF-32 encoding is used by mbrtoc32 and c32rtomb}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/multibyte | Null-terminated multibyte strings}}
{{dsc end}}

[[de:cpp/string/multibyte]]
[[es:cpp/string/multibyte]]
[[fr:cpp/string/multibyte]]
[[it:cpp/string/multibyte]]
[[ja:cpp/string/multibyte]]
[[pt:cpp/string/multibyte]]
[[ru:cpp/string/multibyte]]
[[zh:cpp/string/multibyte]]</text>
      <sha1>3uy9f0949riywbvypm70vumzi0jgp6s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/btowc</title>
    <ns>0</ns>
    <id>4632</id>
    <revision>
      <id>59044</id>
      <parentid>51269</parentid>
      <timestamp>2013-06-01T06:26:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2349">{{cpp/title|btowc}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::wint_t btowc( int c );
}}

Widens a single-byte character {{tt|c}} to its wide character equivalent.

Most multibyte character encodings use single-byte codes to represent the characters from the ASCII character set. This function may be used to convert such characters to {{c|wchar_t}}.

===Parameters===
{{par begin}}
{{par | c | single-byte character to widen}}
{{par end}}

===Return value===
{{c|WEOF}} if {{tt|c}} is {{lc|EOF}}. 

Wide character representation of {{tt|c}} if {{c|(unsigned char)c}} is a valid single-byte character in the initial shift state, {{c|WEOF}} otherwise.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;
#include &lt;clocale&gt;

void try_widen(char c)
{
    std::wint_t w = std::btowc(c);
    if(w != WEOF)
        std::cout &lt;&lt; &quot;The single-byte character &quot; &lt;&lt; +(unsigned char)c
                  &lt;&lt; &quot; widens to &quot; &lt;&lt; +w &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;The single-byte character &quot; &lt;&lt; +(unsigned char)c
                  &lt;&lt; &quot; failed to widen\n&quot;;
}

int main()
{
    std::setlocale(LC_ALL, &quot;lt_LT.iso88594&quot;);
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; &quot;In Lithuanian ISO-8859-4 locale:\n&quot;;
    try_widen('A');
    try_widen('\xdf'); // German letter ß (U+00df) in ISO-8859-4
    try_widen('\xf9'); // Lithuanian letter ų (U+0173) in ISO-8859-4

    std::setlocale(LC_ALL, &quot;lt_LT.utf8&quot;);
    std::cout &lt;&lt; &quot;In Lithuanian UTF-8 locale:\n&quot;;
    try_widen('A');
    try_widen('\xdf');
    try_widen('\xf9');
}
 | output=
In Lithuanian ISO-8859-4 locale:
The single-byte character 0x41 widens to 0x41
The single-byte character 0xdf widens to 0xdf
The single-byte character 0xf9 widens to 0x173
In Lithuanian UTF-8 locale:
The single-byte character 0x41 widens to 0x41
The single-byte character 0xdf failed to widen
The single-byte character 0xf9 failed to widen
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc wctob}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc see c | c/string/multibyte/btowc}}
{{dsc end}}

[[de:cpp/string/multibyte/btowc]]
[[es:cpp/string/multibyte/btowc]]
[[fr:cpp/string/multibyte/btowc]]
[[it:cpp/string/multibyte/btowc]]
[[ja:cpp/string/multibyte/btowc]]
[[pt:cpp/string/multibyte/btowc]]
[[ru:cpp/string/multibyte/btowc]]
[[zh:cpp/string/multibyte/btowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/c16rtomb</title>
    <ns>0</ns>
    <id>4222</id>
    <revision>
      <id>69451</id>
      <parentid>69446</parentid>
      <timestamp>2014-04-09T16:18:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>partial undo (last removal took out more than just 16-bit options)</comment>
      <text xml:space="preserve" bytes="2291">{{cpp/title|c16rtomb}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cuchar | since=c++11 |
std::size_t c16rtomb( char* s, char16_t c16, std::mbstate_t* ps );
}}

Converts a UTF-16 code point to narrow multibyte character.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|c16}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|std::c16rtomb(buf, u'\0', ps)}} for some internal buffer {{tt|buf}}.

If c16 is the null wide character {{c|u'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

The multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | c16 | the 16-bit character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. This value may be {{c|0}}, e.g. when processing the first {{c|char16_t}} in a surrogate pair.

On failure (if {{c|c16}} is not a valid 16-bit character), returns {{c|-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc16}}
{{dsc inc | cpp/locale/codecvt/dsc do_out | mem=std::codecvt&lt;char16_t, char, std::mbstate_t&gt;}}
{{dsc see c | c/string/multibyte/c16rtomb}}
{{dsc end}}

[[de:cpp/string/multibyte/c16rtomb]]
[[es:cpp/string/multibyte/c16rtomb]]
[[fr:cpp/string/multibyte/c16rtomb]]
[[it:cpp/string/multibyte/c16rtomb]]
[[ja:cpp/string/multibyte/c16rtomb]]
[[pt:cpp/string/multibyte/c16rtomb]]
[[ru:cpp/string/multibyte/c16rtomb]]
[[zh:cpp/string/multibyte/c16rtomb]]</text>
      <sha1>sektakuaa14502nviya5bgd6c2dzl02</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/c32rtomb</title>
    <ns>0</ns>
    <id>4638</id>
    <revision>
      <id>69453</id>
      <parentid>69447</parentid>
      <timestamp>2014-04-09T16:20:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>...in that case, this should say it's UTF-32</comment>
      <text xml:space="preserve" bytes="2349">{{cpp/title|c32rtomb}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cuchar | since=c++11 |
std::size_t c32rtomb( char* s, char32_t c32, std::mbstate_t* ps );
}}

Converts a UTF-32 character to its narrow multibyte representation.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|c32}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|std::c32rtomb(buf, U'\0', ps)}} for some internal buffer {{tt|buf}}.

If c32 is the null wide character {{c|U'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

The multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | c32 | the 32-bit character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. This value may be {{c|0}}, e.g. when processing the first {{c|char32_t}} in multi-{{c|char32_t}}-character sequence (does not occur in UTF-32).

On failure (if {{c|c32}} is not a valid 32-bit character), returns {{c|-1}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbrtoc32}}
{{dsc inc | cpp/locale/codecvt/dsc do_out | mem=std::codecvt&lt;char32_t, char, std::mbstate_t&gt;}}
{{dsc see c | c/string/multibyte/c32rtomb}}
{{dsc end}}

[[de:cpp/string/multibyte/c32rtomb]]
[[es:cpp/string/multibyte/c32rtomb]]
[[fr:cpp/string/multibyte/c32rtomb]]
[[it:cpp/string/multibyte/c32rtomb]]
[[ja:cpp/string/multibyte/c32rtomb]]
[[pt:cpp/string/multibyte/c32rtomb]]
[[ru:cpp/string/multibyte/c32rtomb]]
[[zh:cpp/string/multibyte/c32rtomb]]</text>
      <sha1>tegl1qbohvc49zq96btv0dy62c51d7n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mblen</title>
    <ns>0</ns>
    <id>4582</id>
    <revision>
      <id>63803</id>
      <parentid>59049</parentid>
      <timestamp>2013-07-26T06:30:11Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3296">{{cpp/title|mblen}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cstdlib |
int mblen( const char* s, std::size_t n );
}}

Determines the size, in bytes, of the multibyte character whose first byte is pointed to by {{tt|s}}. 

If {{tt|s}} is a null pointer, resets the global conversion state and determined whether shift sequences are used.

This function is equivalent to the call {{c|std::mbtowc((wchar_t*)0, s, n)}}, except that conversion state of {{lc|std::mbtowc}} is unaffected.

===Notes===
Each call to {{tt|mblen}} updates the internal global conversion state (a static object of type {{lc|std::mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, care must be taken to avoid backtracking or multiple scans. In any case, multiple threads should not call {{tt|mblen}} without synchronization: {{lc|std::mbrlen}} may be used instead.

===Parameters===
{{par begin}}
{{par | s | pointer to the multibyte character}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte character or {{c|-1}} if the first bytes pointed to by {{tt|s}} do not form a valid multibyte character or {{c|0}} if {{tt|s}} is pointing at the null charcter {{c|'\0'}}.

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Example===
{{example
 | 
 | code=
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;
#include &lt;stdexcept&gt;

// the number of characters in a multibyte string is the sum of mblen()'s
// note: the simpler approach is std::mbstowcs(NULL, s.c_str(), s.size())
std::size_t strlen_mb(const std::string&amp; s)
{
    std::size_t result = 0;
    const char* ptr = s.data();
    const char* end = ptr + s.size();
    std::mblen(NULL, 0); // reset the conversion state
    while (ptr &lt; end) {
        int next = std::mblen(ptr, end-ptr);
        if (next == -1) {
            throw std::runtime_error(&quot;strlen_mb(): conversion error&quot;);
        }
        ptr += next;
        ++result;
    }
    return result;
}

int main()
{
    // allow mblen() to work with UTF-8 multibyte encoding
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    std::string str = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                      // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    std::cout &lt;&lt; str &lt;&lt; &quot; is &quot; &lt;&lt; str.size() &lt;&lt; &quot; bytes, but only &quot;
              &lt;&lt; strlen_mb(str) &lt;&lt; &quot; characters\n&quot;;
}
 | output=
zß水𝄋 is 10 bytes, but only 4 characters
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbtowc}}
{{dsc inc | cpp/string/multibyte/dsc mbrlen}}
{{dsc see c | c/string/multibyte/mblen}}
{{dsc end}}

[[de:cpp/string/multibyte/mblen]]
[[es:cpp/string/multibyte/mblen]]
[[fr:cpp/string/multibyte/mblen]]
[[it:cpp/string/multibyte/mblen]]
[[ja:cpp/string/multibyte/mblen]]
[[pt:cpp/string/multibyte/mblen]]
[[ru:cpp/string/multibyte/mblen]]
[[zh:cpp/string/multibyte/mblen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbrlen</title>
    <ns>0</ns>
    <id>4583</id>
    <revision>
      <id>59052</id>
      <parentid>51273</parentid>
      <timestamp>2013-06-01T06:26:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2906">{{cpp/title|mbrlen}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::size_t mbrlen( const char* s, std::size_t n, std::mbstate_t* ps);
}}

Determines the size, in bytes, of the remainder of the multibyte character whose first byte is pointed to by {{tt|s}}, given the current conversion state {{tt|ps}}.

This function is equivalent to the call {{c|std::mbrtowc(nullptr, s, n, ps?ps:&amp;internal)}} for some hidden object {{tt|internal}} of type {{lc|std::mbstate_t}}, except that the expression {{tt|ps}} is evaluated only once.

===Parameters===
{{par begin}}
{{par | s | pointer to an element of a multibyte character string}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the variable holding the conversion state}}
{{par end}}

===Return value===
{{c|0}} if the next {{tt|n}} or fewer bytes complete the null character.

The number of bytes (between {{c|1}} and {{c|n}}) that complete a valid multibyte character

{{c|(size_t)-1}} if encoding error occurs

{{c|(size_t)-2}} if the next {{tt|n}} bytes are part of a possibly valid multibyte character, which is still incomplete after examining all {{tt|n}} bytes

===Example===
{{example
 | 
 | code=
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;cwchar&gt;

int main()
{
    // allow mbrlen() to work with UTF-8 multibyte encoding
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    std::string str = u8&quot;水&quot;; // or u8&quot;\u6c34&quot; or &quot;\xe6\xb0\xb4&quot;
    std::mbstate_t mb = std::mbstate_t();
    int len1 = std::mbrlen(&amp;str[0], 1, &amp;mb);
    if(len1 == -2) {
        std::cout &lt;&lt; &quot;The first 1 byte of &quot; &lt;&lt; str
                  &lt;&lt; &quot; is an incomplete multibyte char (mbrlen returns -2)\n&quot;;
    }
    int len2 = std::mbrlen(&amp;str[1], str.size()-1, &amp;mb);
    std::cout &lt;&lt; &quot;The remaining &quot; &lt;&lt; str.size()-1 &lt;&lt; &quot; bytes of &quot; &lt;&lt; str
              &lt;&lt; &quot; hold &quot; &lt;&lt; len2 &lt;&lt; &quot; bytes of the multibyte character\n&quot;;
    std::cout &lt;&lt; &quot;Attempting to call mbrlen() in the middle of &quot; &lt;&lt; str
              &lt;&lt; &quot; while in initial shift state returns &quot;
              &lt;&lt; (int)mbrlen(&amp;str[1], str.size(), &amp;mb) &lt;&lt; '\n';

}
 | output=
The first 1 byte of 水 is an incomplete multibyte char (mbrlen returns -2)
The remaining 2 bytes of 水 hold 2 bytes of the multibyte character
Attempting to call mbrlen() in the middle of 水 while in initial shift state returns -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/string/multibyte/dsc mblen}}
{{dsc inc | cpp/locale/codecvt/dsc do_length}}
{{dsc see c | c/string/multibyte/mbrlen}}
{{dsc end}}

[[de:cpp/string/multibyte/mbrlen]]
[[es:cpp/string/multibyte/mbrlen]]
[[fr:cpp/string/multibyte/mbrlen]]
[[it:cpp/string/multibyte/mbrlen]]
[[ja:cpp/string/multibyte/mbrlen]]
[[pt:cpp/string/multibyte/mbrlen]]
[[ru:cpp/string/multibyte/mbrlen]]
[[zh:cpp/string/multibyte/mbrlen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbrtoc16</title>
    <ns>0</ns>
    <id>4221</id>
    <revision>
      <id>69455</id>
      <parentid>69450</parentid>
      <timestamp>2014-04-09T16:21:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention current C locale here too</comment>
      <text xml:space="preserve" bytes="3141">{{cpp/title|mbrtoc16}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cuchar | since=c++11 |
std::size_t mbrtoc16( char16_t* pc16,
                      const char* s,
                      std::size_t n,
                      std::mbstate_t* ps );
}}

Converts a narrow multibyte character to UTF-16 character representation.

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding 16-bit character and stores it in {{c|*pc16}} (if {{tt|pc16}} is not null).

If the multibyte character in {{tt|*s}} corresponds to a multi-char16_t sequence (e.g. a surrogate pair in UTF-16), then after the first call to this function, {{tt|*ps}} is updated in such a way that the next call to {{tt|mbrtoc16}} will write out the additional char16_t, without considering {{tt|*s}}.

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pc16}} are ignored and the call is equivalent to {{c|std::mbrtoc16(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state {{c|*ps}} represents the initial shift state.

The multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | pc16 | pointer to the location where the resulting 16-bit character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===

The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|*pc16}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|-3}} if the next {{c|char16_t}} from a multi-{{c|char16_t}} character (e.g. a surrogate pair) has now been written to {{c|*pc16}}. No bytes are processed from the input in this case.
* {{c|-2}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pc16}}.
* {{c|-1}} if encoding error occurs. Nothing is written to {{tt|*pc16}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value if {{c|*ps}} is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc c16rtomb}}
{{dsc inc | cpp/locale/codecvt/dsc do_in | mem=std::codecvt&lt;char16_t, char, std::mbstate_t&gt;}}
{{dsc see c | c/string/multibyte/mbrtoc16}}
{{dsc end}}

[[de:cpp/string/multibyte/mbrtoc16]]
[[es:cpp/string/multibyte/mbrtoc16]]
[[fr:cpp/string/multibyte/mbrtoc16]]
[[it:cpp/string/multibyte/mbrtoc16]]
[[ja:cpp/string/multibyte/mbrtoc16]]
[[pt:cpp/string/multibyte/mbrtoc16]]
[[ru:cpp/string/multibyte/mbrtoc16]]
[[zh:cpp/string/multibyte/mbrtoc16]]</text>
      <sha1>1yprw22wgauk2prcidwbd26vibby0bm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbrtoc32</title>
    <ns>0</ns>
    <id>4637</id>
    <revision>
      <id>69454</id>
      <parentid>69452</parentid>
      <timestamp>2014-04-09T16:21:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention current C locale here too</comment>
      <text xml:space="preserve" bytes="3115">{{cpp/title|mbrtoc32}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cuchar | since=c++11 |
std::size_t mbrtoc32( char32_t* pc32,
                      const char* s,
                      std::size_t n,
                      std::mbstate_t* ps );
}}

Converts a narrow multibyte character to its UTF-32 character representation.

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding 32-bit character and stores it in {{c|*pc32}} (if {{tt|pc32}} is not null).

If the multibyte character in {{tt|*s}} corresponds to a multi-char32_t sequence (not possible with UTF-32), then after the first call to this function, {{tt|*ps}} is updated in such a way that the next calls to {{tt|mbrtoc32}} will write out the additional char32_t, without considering {{tt|*s}}.

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pc32}} are ignored and the call is equivalent to {{c|std::mbrtoc32(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state {{c|*ps}} represents the initial shift state.

The multibyte encoding used by this function is specified by the currently active C locale.

===Parameters===
{{par begin}}
{{par | pc32 | pointer to the location where the resulting 32-bit character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===

The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|*pc32}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|-3}} if the next {{c|char32_t}} from a multi-{{c|char32_t}} character has now been written to {{c|*pc32}}. No bytes are processed from the input in this case.
* {{c|-2}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pc32}}.
* {{c|-1}} if encoding error occurs. Nothing is written to {{tt|*pc32}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value if {{c|*ps}} is unspecified.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc c32rtomb}}
{{dsc inc | cpp/locale/codecvt/dsc do_in | mem=std::codecvt&lt;char32_t, char, std::mbstate_t&gt;}}
{{dsc see c | c/string/multibyte/mbrtoc32}}
{{dsc end}}

[[de:cpp/string/multibyte/mbrtoc32]]
[[es:cpp/string/multibyte/mbrtoc32]]
[[fr:cpp/string/multibyte/mbrtoc32]]
[[it:cpp/string/multibyte/mbrtoc32]]
[[ja:cpp/string/multibyte/mbrtoc32]]
[[pt:cpp/string/multibyte/mbrtoc32]]
[[ru:cpp/string/multibyte/mbrtoc32]]
[[zh:cpp/string/multibyte/mbrtoc32]]</text>
      <sha1>c67lllvb7lrma0m0s4wc3wb4neonolv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbrtowc</title>
    <ns>0</ns>
    <id>4636</id>
    <revision>
      <id>59057</id>
      <parentid>51276</parentid>
      <timestamp>2013-06-01T06:26:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3410">{{cpp/title|mbrtowc}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::size_t mbrtowc( wchar_t* pwc,
                     const char* s,
                     std::size_t n,
                     std::mbstate_t* ps );
}}

Converts a narrow multibyte character to a wide character.

If {{tt|s}} is not a null pointer, inspects at most {{tt|n}} bytes of the multibyte character string, beginning with the byte pointed to by {{tt|s}} to determine the number of bytes necessary to complete the next multibyte character (including any shift sequences). If the function determines that the next multibyte character in {{tt|s}} is complete and valid, converts it to the corresponding wide character and stores it in {{c|*pwc}} (if {{tt|pwc}} is not null).

If {{tt|s}} is a null pointer, the values of {{tt|n}} and {{tt|pwc}} are ignored and call is equivalent to {{c|std::mbrtowc(NULL, &quot;&quot;, 1, ps)}}.

If the wide character produced is the null character, the conversion state stored in {{c|*ps}} is the initial shift state.

===Parameters===
{{par begin}}
{{par | pwc | pointer to the location where the resulting wide character will be written}}
{{par | s | pointer to the multibyte character string used as input}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | ps | pointer to the conversion state used when interpreting the multibyte string }}
{{par end}}

===Return value===
The first of the following that applies:
* {{c|0}} if the character converted from {{tt|s}} (and stored in {{c|pwc}} if non-null) was the null character
* the number of bytes {{c|[1...n]}} of the multibyte character successfully converted from {{tt|s}}
* {{c|static_cast&lt;std::size_t&gt;(-2)}} if the next {{tt|n}} bytes constitute an incomplete, but so far valid, multibyte character. Nothing is written to {{c|*pwc}}.
* {{c|static_cast&lt;std::size_t&gt;(-1)}} if encoding error occurs. Nothing is written to {{tt|*pwc}}, the value {{lc|EILSEQ}} is stored in {{lc|errno}} and the value of {{c|*ps}} is left unspecified.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cstring&gt;
#include &lt;cwchar&gt;
 
void print_mb(const char* ptr)
{
    std::mbstate_t state = std::mbstate_t(); // initial state
    const char* end = ptr + std::strlen(ptr);
    int len;
    wchar_t wc;
    while((len = std::mbrtowc(&amp;wc, ptr, end-ptr, &amp;state)) &gt; 0) {
        std::wcout &lt;&lt; &quot;Next &quot; &lt;&lt; len &lt;&lt; &quot; bytes are the character &quot; &lt;&lt; wc &lt;&lt; '\n';
        ptr += len;
    }
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    const char* str = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                      // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    print_mb(str);
}
 | output=
Next 1 bytes are the character z
Next 2 bytes are the character ß
Next 3 bytes are the character 水
Next 4 bytes are the character 𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbtowc}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc see c | c/string/multibyte/mbrtowc}}
{{dsc end}}

[[de:cpp/string/multibyte/mbrtowc]]
[[es:cpp/string/multibyte/mbrtowc]]
[[fr:cpp/string/multibyte/mbrtowc]]
[[it:cpp/string/multibyte/mbrtowc]]
[[ja:cpp/string/multibyte/mbrtowc]]
[[pt:cpp/string/multibyte/mbrtowc]]
[[ru:cpp/string/multibyte/mbrtowc]]
[[zh:cpp/string/multibyte/mbrtowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbsinit</title>
    <ns>0</ns>
    <id>4623</id>
    <revision>
      <id>59060</id>
      <parentid>51277</parentid>
      <timestamp>2013-06-01T06:26:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2183">{{cpp/title|mbsinit}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
int mbsinit( const std::mbstate_t* ps);
}}

If {{tt|ps}} is not a null pointer, the {{tt|mbsinit}} function determines whether the pointed-to {{lc|std::mbstate_t}} object describes the initial conversion state. 

===Notes===
Although a zero-initialized {{lc|std::mbstate_t}} always represents the initial conversion state, there may be other values of {{lc|std::mbstate_t}} that also represent the initial conversion state.

===Parameters===
{{par begin}}
{{par | ps | pointer to the std::mbstate_t object to examine}}
{{par end}}

===Return value===
{{c|0}} if {{tt|ps}} is not a null pointer and does not reporesent the initial conversion state, nonzero value otherwise.

===Example===
{{example
 | 
 | code=
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;cwchar&gt;

int main()
{
    // allow mbrlen() to work with UTF-8 multibyte encoding
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    std::string str = u8&quot;水&quot;; // or u8&quot;\u6c34&quot; or &quot;\xe6\xb0\xb4&quot;
    std::mbstate_t mb = std::mbstate_t();
    (void)std::mbrlen(&amp;str[0], 1, &amp;mb);
    if (!std::mbsinit(&amp;mb)) {
        std::cout &lt;&lt; &quot;After processing the first 1 byte of &quot; &lt;&lt; str
                  &lt;&lt; &quot; the conversion state is not initial\n&quot;;
    }

    (void)std::mbrlen(&amp;str[1], str.size()-1, &amp;mb);
    if (std::mbsinit(&amp;mb)) {
        std::cout &lt;&lt; &quot;After processing the remaining 2 bytes of &quot; &lt;&lt; str
                  &lt;&lt; &quot;, the conversion state is initial conversion state\n&quot;;
    }
}
 | output=
After processing the first 1 byte of 水 the conversion state is not initial
After processing the remaining 2 bytes of 水, the conversion state is initial conversion state
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbstate_t}}
{{dsc see c | c/string/multibyte/mbsinit}}
{{dsc end}}

[[de:cpp/string/multibyte/mbsinit]]
[[es:cpp/string/multibyte/mbsinit]]
[[fr:cpp/string/multibyte/mbsinit]]
[[it:cpp/string/multibyte/mbsinit]]
[[ja:cpp/string/multibyte/mbsinit]]
[[pt:cpp/string/multibyte/mbsinit]]
[[ru:cpp/string/multibyte/mbsinit]]
[[zh:cpp/string/multibyte/mbsinit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbsrtowcs</title>
    <ns>0</ns>
    <id>4643</id>
    <revision>
      <id>59061</id>
      <parentid>51278</parentid>
      <timestamp>2013-06-01T06:26:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="3430">{{cpp/title|mbsrtowcs}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::size_t mbsrtowcs( wchar_t* dst,
                       const char** src,
                       std::size_t len,
                       std::mbstate_t* ps );
}}

Converts a null-terminated multibyte character sequence, which begins in the conversion state described by {{tt|*ps}}, from the array whose first element is pointed to by {{tt|*src}} to its wide character representation. If {{tt|dst}} is not null, converted characters are stored in the successive elements of the wchar_t array pointed to by {{tt|dst}}. No more than {{tt|len}} wide characters are written to the destination array.

Each multibyte character is converted as if by a call to {{lc|std::mbrtowc}}. The conversion stops if:

* The multibyte null character was converted and stored. {{tt|src}} is set to {{lc|NULL}} and {{tt|*ps}} represents the initial shift state.
* An invalid multibyte character (according to the current C locale) was encountered. {{tt|src}} is set to point at the beginning  of the first unconverted multibyte character.
* the next wide character to be stored would exceed {{tt|len}}. {{tt|src}} is set to point at the beginning of the first unconverted multibyte character. This condition is not checked if {{c|1=dst==NULL}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to wide character array where the results will be stored}}
{{par | src | pointer to pointer to the first element of a null-terminated multibyte string}}
{{par | len | number of wide characters available in the array pointed to by dst}}
{{par | ps | pointer to the conversion state object}}
{{par end}}

===Return value===
On success, returns the number of wide characters, excluding the terminating {{c|L'\0'}}, written to the character array.. If {{c|1=dst==NULL}}, returns the number of wide characters that would have been written given unlimited length.

On conversion error (if invalid multibyte character was encountered), returns {{c|static_cast&lt;std::size_t&gt;(-1)}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;clocale&gt;
#include &lt;cwchar&gt;

void print_as_wide(const char* mbstr)
{
    std::mbstate_t state = std::mbstate_t();
    int len = 1 + std::mbsrtowcs(NULL, &amp;mbstr, 0, &amp;state);
    std::vector&lt;wchar_t&gt; wstr(len);
    std::mbsrtowcs(&amp;wstr[0], &amp;mbstr, wstr.size(), &amp;state);
    std::wcout &lt;&lt; &quot;Wide string: &quot; &lt;&lt; &amp;wstr[0] &lt;&lt; '\n'
               &lt;&lt; &quot;The length, including '\\0': &quot; &lt;&lt; wstr.size() &lt;&lt; '\n';
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    const char* mbstr = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                        // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    print_as_wide(mbstr);
}
 | output=
Wide string: zß水𝄋
The length, including '\0': 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc see c | c/string/multibyte/mbsrtowcs}}
{{dsc end}}

[[de:cpp/string/multibyte/mbsrtowcs]]
[[es:cpp/string/multibyte/mbsrtowcs]]
[[fr:cpp/string/multibyte/mbsrtowcs]]
[[it:cpp/string/multibyte/mbsrtowcs]]
[[ja:cpp/string/multibyte/mbsrtowcs]]
[[pt:cpp/string/multibyte/mbsrtowcs]]
[[ru:cpp/string/multibyte/mbsrtowcs]]
[[zh:cpp/string/multibyte/mbsrtowcs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbstate t</title>
    <ns>0</ns>
    <id>4624</id>
    <revision>
      <id>59064</id>
      <parentid>51279</parentid>
      <timestamp>2013-06-01T06:26:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1460">{{cpp/title|mbstate_t}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
struct mbstate_t;
}}

The type mbstate_t is a trivial non-array type that can represent any of the conversion states that can occur in an implementation-defined set of supported multibyte character encoding rules. Zero-initialized value of {{tt|mbstate_t}} represents the initial conversion state, although other values of {{tt|mbstate_t}} may exist that also represent the initial conversion state.

Possible implementation of {{tt|mbstate_t}} is a struct type holding an array representing the incomplete multibyte character, an integer counter indicating the number of bytes in the array that have been processed, and a representation of the current shift state.

The following functions should not be called from multiple threads without synchronization with the {{c|std::mbstate_t*}} argument of {{tt|NULL}} due to possible data races: {{lc|std::mbrlen}}, {{lc|std::mbrtowc}}, {{c|std::mbsrtowc}}, {{lc|std::mbtowc}}, {{lc|std::wcrtomb}}, {{c|std::wcsrtomb}}, {{lc|std::wctomb}}. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbsinit}}
{{dsc end}}

[[de:cpp/string/multibyte/mbstate t]]
[[es:cpp/string/multibyte/mbstate t]]
[[fr:cpp/string/multibyte/mbstate t]]
[[it:cpp/string/multibyte/mbstate t]]
[[ja:cpp/string/multibyte/mbstate t]]
[[pt:cpp/string/multibyte/mbstate t]]
[[ru:cpp/string/multibyte/mbstate t]]
[[zh:cpp/string/multibyte/mbstate t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbstowcs</title>
    <ns>0</ns>
    <id>4642</id>
    <revision>
      <id>59065</id>
      <parentid>51280</parentid>
      <timestamp>2013-06-01T06:26:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2806">{{cpp/title|mbstowcs}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cstdlib |
std::size_t mbstowcs( wchar_t* dst, const char* src, std::size_t len)
}}

Converts a multibyte character string from the array whose first element is pointed to by {{tt|src}} to its wide character  representation. Converted characters are stored in the successive elements of the array pointed to by {{tt|dst}}. No more than {{tt|len}} wide characters are written to the destination array.

Each character is converted as if by a call to {{lc|std::mbtowc}}, except that the mbtowc conversion state is unaffected. The conversion stops if:

* The multibyte null character was converted and stored.
* An invalid (in the current C locale) multibyte character was encountered.
* The next wide character to be stored would exceed {{tt|len}}.

===Notes===
In most implementations, this function updates a global static object of type {{lc|std::mbstate_t}} as it processes through the string, and cannot be called simultaneously by two threads, {{lc|std::mbsrtowcs}} should be used in such cases.

POSIX specifies a common extension: if {{tt|dst}} is a null pointer, this function returns the number of wide characters that would be written to {{tt|dst}}, if converted. Similar behavior is standard for {{lc|std::mbsrtowcs}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to wide character array where the wide string will be stored}}
{{par | src | pointer to the first element of a null-terminated multibyte string to convert}}
{{par | len | number of wide characters available in the array pointed to by dst}}
{{par end}}

===Return value===
On success, returns the number of wide characters, excluding the terminating {{c|L'\0'}}, written to the destination array.

On conversion error (if invalid multibyte character was encountered), returns {{c|-1}}.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cstdlib&gt;
int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    const char* mbstr = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                        // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    wchar_t wstr[5];
    std::mbstowcs(wstr, mbstr, 5);
    std::wcout &lt;&lt; &quot;wide string: &quot; &lt;&lt; wstr &lt;&lt; '\n';
}
 | output=
wide string: zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/string/multibyte/dsc wcstombs}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc see c | c/string/multibyte/mbstowcs}}
{{dsc end}}

[[de:cpp/string/multibyte/mbstowcs]]
[[es:cpp/string/multibyte/mbstowcs]]
[[fr:cpp/string/multibyte/mbstowcs]]
[[it:cpp/string/multibyte/mbstowcs]]
[[ja:cpp/string/multibyte/mbstowcs]]
[[pt:cpp/string/multibyte/mbstowcs]]
[[ru:cpp/string/multibyte/mbstowcs]]
[[zh:cpp/string/multibyte/mbstowcs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/mbtowc</title>
    <ns>0</ns>
    <id>4634</id>
    <revision>
      <id>59068</id>
      <parentid>51281</parentid>
      <timestamp>2013-06-01T06:26:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2818">{{cpp/title|mbtowc}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cstdlib |
int mbtowc( wchar_t* pwc, const char* s, std::size_t n )
}}

Converts a multibyte character whose first byte is pointed to by {{tt|s}} to a wide character, written to {{tt|*pwc}} if {{tt|pwc}} is not null.

If {{tt|s}} is a null pointer, resets the global conversion state and determines whether shift sequences are used.

===Parameters===
{{par begin}}
{{par | s | pointer to the multibyte character}}
{{par | n | limit on the number of bytes in s that can be examined}}
{{par | pwc | pointer to the wide character for output }}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte character or {{c|-1}} if the first bytes pointed to by {{tt|s}} do not form a valid multibyte character or {{c|0}} if {{tt|s}} is pointing at the null charcter {{c|'\0'}}.

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Notes===
Each call to {{tt|mbtowc}} updates the internal global conversion state (a static object of type {{lc|std::mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, care must be taken to avoid backtracking or multiple scans. In any case, multiple threads should not call {{tt|mbtowc}} without synchronization: {{lc|std::mbrtowc}} may be used instead.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cstring&gt;
#include &lt;cstdlib&gt;

int print_mb(const char* ptr)
{
    std::mbtowc(NULL, 0, 0); // reset the conversion state
    const char* end = ptr + std::strlen(ptr);
    int ret;
    for (wchar_t wc; (ret = std::mbtowc(&amp;wc, ptr, end-ptr)) &gt; 0; ptr+=ret) {
        std::wcout &lt;&lt; wc;
    }
    std::wcout &lt;&lt; '\n';
    return ret;
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    const char* str = u8&quot;z\u00df\u6c34\U0001d10b&quot;; // or u8&quot;zß水𝄋&quot;
                      // or &quot;\x7a\xc3\x9f\xe6\xb0\xb4\xf0\x9d\x84\x8b&quot;;
    print_mb(str);
}
 | output=
zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/string/multibyte/dsc mblen}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc see c | c/string/multibyte/mbtowc}}
{{dsc end}}

[[de:cpp/string/multibyte/mbtowc]]
[[es:cpp/string/multibyte/mbtowc]]
[[fr:cpp/string/multibyte/mbtowc]]
[[it:cpp/string/multibyte/mbtowc]]
[[ja:cpp/string/multibyte/mbtowc]]
[[pt:cpp/string/multibyte/mbtowc]]
[[ru:cpp/string/multibyte/mbtowc]]
[[zh:cpp/string/multibyte/mbtowc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/wcrtomb</title>
    <ns>0</ns>
    <id>4639</id>
    <revision>
      <id>59069</id>
      <parentid>51282</parentid>
      <timestamp>2013-06-01T06:26:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2829">{{cpp/title|wcrtomb}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::size_t wcrtomb( char* s, wchar_t wc, std::mbstate_t* ps );
}}

Converts a wide character to its narrow multibyte representation.

If {{tt|s}} is not a null pointer, the function determines the number of bytes necessary to store the multibyte character representation of {{tt|wc}} (including any shift sequences), and stores the multibyte character representation in the character array whose first element is pointed to by {{tt|s}}. At most {{c|MB_CUR_MAX}} bytes can be written by this function.

If {{tt|s}} is a null pointer, the call is equivalent to {{c|std::wcrtomb(buf, L'\0', ps)}} for some internal buffer {{tt|buf}}.

If wc is the null wide character {{c|L'\0'}}, a null byte is stored, preceded by any shift sequence necessary to restore the initial shift state and the conversion state parameter {{c|*ps}} is updated to represent the initial shift state.

===Parameters===
{{par begin}}
{{par | s | pointer to narrow character array where the multibyte character will be stored}}
{{par | wc | the wide character to convert}}
{{par | ps | pointer to the conversion state object used when interpreting the multibyte string }}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences) written to the character array whose first element is pointed to by {{tt|s}}. 

On failure (if {{c|wc}} is not a valid wide character), returns {{c|static_cast&lt;std::size_t&gt;(-1)}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;cwchar&gt;

void print_wide(const std::wstring&amp; wstr)
{
    std::mbstate_t state = std::mbstate_t();
    for(wchar_t wc : wstr) {
        std::string mb(MB_CUR_MAX, '\0');
        int ret = std::wcrtomb(&amp;mb[0], wc, &amp;state);
        std::cout &lt;&lt; &quot;multibyte char &quot; &lt;&lt; mb &lt;&lt; &quot; is &quot; &lt;&lt; ret &lt;&lt; &quot; bytes\n&quot;;
    }
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    std::wstring wstr = L&quot;z\u00df\u6c34\U0001d10b&quot;; // or L&quot;zß水𝄋&quot;
    print_wide(wstr);
}
 | output=
multibyte char z is 1 bytes
multibyte char ß is 2 bytes
multibyte char 水 is 3 bytes
multibyte char 𝄋 is 4 bytes
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc wctomb}}
{{dsc inc | cpp/string/multibyte/dsc mbrtowc}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc see c | c/string/multibyte/wcrtomb}}
{{dsc end}}

[[de:cpp/string/multibyte/wcrtomb]]
[[es:cpp/string/multibyte/wcrtomb]]
[[fr:cpp/string/multibyte/wcrtomb]]
[[it:cpp/string/multibyte/wcrtomb]]
[[ja:cpp/string/multibyte/wcrtomb]]
[[pt:cpp/string/multibyte/wcrtomb]]
[[ru:cpp/string/multibyte/wcrtomb]]
[[zh:cpp/string/multibyte/wcrtomb]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/wcsrtombs</title>
    <ns>0</ns>
    <id>4640</id>
    <revision>
      <id>69005</id>
      <parentid>59072</parentid>
      <timestamp>2014-03-23T16:34:31Z</timestamp>
      <contributor>
        <username>Fun4jimmy</username>
        <id>2664</id>
      </contributor>
      <minor/>
      <comment>Change NULL to nullptr in example as it is c++11 best practice</comment>
      <text xml:space="preserve" bytes="3368">{{cpp/title|wcsrtombs}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
std::size_t wcsrtombs( char* dst,
                       const wchar_t** src,
                       std::size_t len,
                       std::mbstate_t* ps );
}}

Converts a sequence of wide characters from the array whose first element is pointed to by {{tt|*src}} to its narrow multibyte representation that begins in the conversion state described by {{tt|*ps}}. If {{tt|dst}} is not null, converted characters are stored in the successive elements of the char array pointed to by {{tt|dst}}. No more than {{tt|len}} bytes are written to the destination array.

Each character is converted as if by a call to {{lc|std::wcrtomb}}. The conversion stops if:

* The null character was converted and stored. {{tt|src}} is set to {{lc|NULL}} and {{tt|*ps}} represents the initial shift state.
* A {{c|wchar_t}} was found that does not correspond to a valid character in the current C locale. {{tt|src}} is set to point at the first unconverted wide character.
* the next multibyte character to be stored would exceed {{tt|len}}. {{tt|src}} is set to point at the first unconverted wide character. This condition is not checked if {{c|1=dst==NULL}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to narrow character array where the multibyte characters will be stored}}
{{par | src | pointer to pointer to the first element of a null-terminated wide string}}
{{par | len | number of bytes available in the array pointed to by dst}}
{{par | ps | pointer to the conversion state object}}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences, but excluding the terminating {{c|'\0'}}) written to the character array whose first element is pointed to by {{tt|dst}}. If {{c|1=dst==NULL}}, returns the number of bytes that would have been written.

On conversion error (if invalid wide character was encountered), returns {{c|static_cast&lt;std::size_t&gt;(-1)}}, stores {{lc|EILSEQ}} in {{lc|errno}}, and leaves {{c|*ps}} in unspecified state.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;cwchar&gt;

void print_wide(const wchar_t* wstr)
{
    std::mbstate_t state = std::mbstate_t();
    int len = 1 + std::wcsrtombs(nullptr, &amp;wstr, 0, &amp;state);
    std::vector&lt;char&gt; mbstr(len);
    std::wcsrtombs(&amp;mbstr[0], &amp;wstr, mbstr.size(), &amp;state);
    std::cout &lt;&lt; &quot;multibyte string: &quot; &lt;&lt; &amp;mbstr[0] &lt;&lt; '\n'
              &lt;&lt; &quot;Length, including '\\0': &quot; &lt;&lt; mbstr.size() &lt;&lt; '\n';
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    const wchar_t* wstr = L&quot;z\u00df\u6c34\U0001d10b&quot;; // or L&quot;zß水𝄋&quot;
    print_wide(wstr);
}
 | output=
multibyte string: zß水𝄋
Length, including '\0': 11
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/string/multibyte/dsc mbsrtowcs}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc see c | c/string/multibyte/wcsrtombs}}
{{dsc end}}

[[de:cpp/string/multibyte/wcsrtombs]]
[[es:cpp/string/multibyte/wcsrtombs]]
[[fr:cpp/string/multibyte/wcsrtombs]]
[[it:cpp/string/multibyte/wcsrtombs]]
[[ja:cpp/string/multibyte/wcsrtombs]]
[[pt:cpp/string/multibyte/wcsrtombs]]
[[ru:cpp/string/multibyte/wcsrtombs]]
[[zh:cpp/string/multibyte/wcsrtombs]]</text>
      <sha1>sih11syuxpnhs5fxrgfdir1zo8hv1ba</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/wcstombs</title>
    <ns>0</ns>
    <id>4641</id>
    <revision>
      <id>59073</id>
      <parentid>51284</parentid>
      <timestamp>2013-06-01T06:26:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2912">{{cpp/title|wcstombs}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cstdlib |
std::size_t wcstombs( char* dst, const wchar_t* src, std::size_t len)
}}

Converts a sequence of wide characters from the array whose first element is pointed to by {{tt|src}} to its narrow multibyte representation that begins in the initial shift state. Converted characters are stored in the successive elements of the char array pointed to by {{tt|dst}}. No more than {{tt|len}} bytes are written to the destination array.

Each character is converted as if by a call to {{lc|std::wctomb}}, except that the wctomb's conversion state is unaffected. The conversion stops if:

* The null character was converted and stored.
* A {{c|wchar_t}} was found that does not correspond to a valid character in the current C locale.
* The next multibyte character to be stored would exceed {{tt|len}}.

===Notes===
In most implementations, this function updates a global static object of type {{lc|std::mbstate_t}} as it processes through the string, and cannot be called simultaneously by two threads, {{c|std::wcsrtombs}} should be used in such cases.

POSIX specifies a common extension: if {{tt|dst}} is a null pointer, this function returns the number of bytes that would be written to {{tt|dst}}, if converted. Similar behavior is standard for {{c|std::wcsrtombs}}.

===Parameters===
{{par begin}}
{{par | dst | pointer to narrow character array where the multibyte character will be stored}}
{{par | src | pointer to the first element of a null-terminated wide string to convert}}
{{par | len | number of byte available in the array pointed to by dst}}
{{par end}}

===Return value===
On success, returns the number of bytes (including any shift sequences, but excluding the terminating {{c|'\0'}}) written to the character array whose first element is pointed to by {{tt|dst}}.

On conversion error (if invalid wide character was encountered), returns {{c|static_cast&lt;std::size_t&gt;(-1)}}.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cstdlib&gt;

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    const wchar_t* wstr = L&quot;z\u00df\u6c34\U0001d10b&quot;; // or L&quot;zß水𝄋&quot;
    char mbstr[11];
    std::wcstombs(mbstr, wstr, 11);
    std::cout &lt;&lt; &quot;multibyte string: &quot; &lt;&lt; mbstr &lt;&lt; '\n';
}
 | output=
multibyte string: zß水𝄋
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc wcsrtombs}}
{{dsc inc | cpp/string/multibyte/dsc mbstowcs}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc see c | c/string/multibyte/wcstombs}}
{{dsc end}}

[[de:cpp/string/multibyte/wcstombs]]
[[es:cpp/string/multibyte/wcstombs]]
[[fr:cpp/string/multibyte/wcstombs]]
[[it:cpp/string/multibyte/wcstombs]]
[[ja:cpp/string/multibyte/wcstombs]]
[[pt:cpp/string/multibyte/wcstombs]]
[[ru:cpp/string/multibyte/wcstombs]]
[[zh:cpp/string/multibyte/wcstombs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/wctob</title>
    <ns>0</ns>
    <id>4633</id>
    <revision>
      <id>59076</id>
      <parentid>51285</parentid>
      <timestamp>2013-06-01T06:26:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1996">{{cpp/title|wctob}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cwchar |
int wctob( std::wint_t c );
}}

Narrows a wide character {{tt|c}} if its multibyte character equivalent in the initial shift state is a single byte.

This is typically possible for the characters from the ASCII character set, since most multibyte encodings (such as UTF-8) use single bytes to encode those characters.

===Parameters===
{{par begin}}
{{par | c | wide character to narrow}}
{{par end}}

===Return value===
{{lc|EOF}} if {{tt|c}} does not represent a multibyte character with length {{c|1}} in initial shift state.

Otherwise, the single-byte representation of {{tt|c}} as {{c|unsigned char}} converted to {{c|int}}

===Example===
{{example
 | 
 | code=
#include &lt;clocale&gt;
#include &lt;cwchar&gt;
#include &lt;iostream&gt;

void try_narrowing(wchar_t c)
{
    int cn = std::wctob(c);
    if(cn != EOF)
        std::cout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' narrowed to &quot; &lt;&lt; +cn &lt;&lt; '\n';
    else
        std::cout &lt;&lt; '\'' &lt;&lt; c &lt;&lt; &quot;' could not be narrowed\n&quot;;
}
 
int main()
{
    std::setlocale(LC_ALL, &quot;th_TH.utf8&quot;);
    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; &quot;In Thai UTF-8 locale:\n&quot;;
    try_narrowing(L'a');
    try_narrowing(L'๛');

    std::setlocale(LC_ALL, &quot;th_TH.tis620&quot;);
    std::cout &lt;&lt; &quot;In Thai TIS-620 locale:\n&quot;;
    try_narrowing(L'a');
    try_narrowing(L'๛');
}
 | output=
In Thai UTF-8 locale:
'0x61' narrowed to 0x61
'0xe5b' could not be narrowed
In Thai TIS-620 locale:
'0x61' narrowed to 0x61
'0xe5b' narrowed to 0xfb
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc btowc}}
{{dsc inc | cpp/io/basic_ios/dsc narrow}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc see c | c/string/multibyte/wctob}}
{{dsc end}}

[[de:cpp/string/multibyte/wctob]]
[[es:cpp/string/multibyte/wctob]]
[[fr:cpp/string/multibyte/wctob]]
[[it:cpp/string/multibyte/wctob]]
[[ja:cpp/string/multibyte/wctob]]
[[pt:cpp/string/multibyte/wctob]]
[[ru:cpp/string/multibyte/wctob]]
[[zh:cpp/string/multibyte/wctob]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/multibyte/wctomb</title>
    <ns>0</ns>
    <id>4635</id>
    <revision>
      <id>59077</id>
      <parentid>51286</parentid>
      <timestamp>2013-06-01T06:26:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2984">{{cpp/title|wctomb}}
{{cpp/string/multibyte/navbar}}
{{ddcl | header=cstdlib |
int wctomb( char *s, wchar_t wc );
}}

Converts a wide character {{tt|wc}} to multibyte encoding and stores it (including any shift sequences) in the char array whose first element is pointed to by {{tt|s}}. No more than {{c|MB_CUR_MAX}} characters are stored.

If {{tt|wc}} is the null character, the null byte is written to {{tt|s}}, preceded by any shift sequences necessary to restore the initial shift state.

If {{tt|s}} is a null pointer, resets the global conversion state and determines whether shift sequences are used.

===Parameters===
{{par begin}}
{{par | s | pointer to the character array for output}}
{{par | wc | wide character to convert}}
{{par end}}

===Return value===
If {{tt|s}} is not a null pointer, returns the number of bytes that are contained in the multibyte representation of {{tt|wc}} or  {{c|-1}} if {{tt|wc}} is not a valid character. 

If {{tt|s}} is a null pointer, resets its internal conversion state to represent the initial shift state and returns {{c|0}} if the current multibyte encoding is not state-dependent (does not use shift sequences) or a non-zero value if the current multibyte encoding is state-dependent (uses shift sequences).

===Notes===
Each call to {{tt|wctomb}} updates the internal global conversion state (a static object of type {{lc|std::mbstate_t}}, only known to this function). If the multibyte encoding uses shift states, this function is not reentrant. In any case, multiple threads should not call {{tt|wctomb}} without synchronization: {{lc|std::wcrtomb}} may be used instead.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;string&gt;
#include &lt;cstdlib&gt;

void print_wide(const std::wstring&amp; wstr)
{
    bool shifts = std::wctomb(NULL, 0); // reset the conversion state
    std::cout &lt;&lt; &quot;shift sequences &quot; &lt;&lt; (shifts ? &quot;are&quot; : &quot;not&quot; ) &lt;&lt; &quot; used\n&quot;;
    for (wchar_t wc : wstr) {
        std::string mb(MB_CUR_MAX, '\0');
        int ret = std::wctomb(&amp;mb[0], wc);
        std::cout &lt;&lt; &quot;multibyte char &quot; &lt;&lt; mb &lt;&lt; &quot; is &quot; &lt;&lt; ret &lt;&lt; &quot; bytes\n&quot;;
    }
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    // UTF-8 narrow multibyte encoding
    std::wstring wstr = L&quot;z\u00df\u6c34\U0001d10b&quot;; // or L&quot;zß水𝄋&quot;
    print_wide(wstr);
}
 | output=
shift sequences not used
multibyte char z is 1 bytes
multibyte char ß is 2 bytes
multibyte char 水 is 3 bytes
multibyte char 𝄋 is 4 bytes
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/multibyte/dsc mbtowc}}
{{dsc inc | cpp/string/multibyte/dsc wcrtomb}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc see c | c/string/multibyte/wctomb}}
{{dsc end}}

[[de:cpp/string/multibyte/wctomb]]
[[es:cpp/string/multibyte/wctomb]]
[[fr:cpp/string/multibyte/wctomb]]
[[it:cpp/string/multibyte/wctomb]]
[[ja:cpp/string/multibyte/wctomb]]
[[pt:cpp/string/multibyte/wctomb]]
[[ru:cpp/string/multibyte/wctomb]]
[[zh:cpp/string/multibyte/wctomb]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow</title>
    <ns>0</ns>
    <id>3807</id>
    <redirect title="cpp/string/byte" />
    <revision>
      <id>14283</id>
      <timestamp>2011-11-27T01:11:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow]] to [[cpp/string/byte]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/string/byte]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/atof</title>
    <ns>0</ns>
    <id>3808</id>
    <redirect title="cpp/string/byte/atof" />
    <revision>
      <id>14285</id>
      <timestamp>2011-11-27T01:11:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/atof]] to [[cpp/string/byte/atof]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/atoi</title>
    <ns>0</ns>
    <id>3809</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>14287</id>
      <timestamp>2011-11-27T01:11:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/atoi]] to [[cpp/string/byte/atoi]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/atol</title>
    <ns>0</ns>
    <id>3810</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>15841</id>
      <parentid>14289</parentid>
      <timestamp>2011-12-17T02:23:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/atoll</title>
    <ns>0</ns>
    <id>3811</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>15840</id>
      <parentid>14291</parentid>
      <timestamp>2011-12-17T02:23:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isalnum</title>
    <ns>0</ns>
    <id>3812</id>
    <redirect title="cpp/string/byte/isalnum" />
    <revision>
      <id>14293</id>
      <timestamp>2011-11-27T01:11:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isalnum]] to [[cpp/string/byte/isalnum]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isalnum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isalpha</title>
    <ns>0</ns>
    <id>3813</id>
    <redirect title="cpp/string/byte/isalpha" />
    <revision>
      <id>14295</id>
      <timestamp>2011-11-27T01:11:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isalpha]] to [[cpp/string/byte/isalpha]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isblank</title>
    <ns>0</ns>
    <id>3814</id>
    <redirect title="cpp/string/byte/isblank" />
    <revision>
      <id>14297</id>
      <timestamp>2011-11-27T01:11:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isblank]] to [[cpp/string/byte/isblank]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isblank]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/iscntrl</title>
    <ns>0</ns>
    <id>3815</id>
    <redirect title="cpp/string/byte/iscntrl" />
    <revision>
      <id>14299</id>
      <timestamp>2011-11-27T01:11:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/iscntrl]] to [[cpp/string/byte/iscntrl]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/iscntrl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isdigit</title>
    <ns>0</ns>
    <id>3816</id>
    <redirect title="cpp/string/byte/isdigit" />
    <revision>
      <id>14301</id>
      <timestamp>2011-11-27T01:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isdigit]] to [[cpp/string/byte/isdigit]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isgraph</title>
    <ns>0</ns>
    <id>3817</id>
    <redirect title="cpp/string/byte/isgraph" />
    <revision>
      <id>14303</id>
      <timestamp>2011-11-27T01:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isgraph]] to [[cpp/string/byte/isgraph]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isgraph]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/islower</title>
    <ns>0</ns>
    <id>3818</id>
    <redirect title="cpp/string/byte/islower" />
    <revision>
      <id>14305</id>
      <timestamp>2011-11-27T01:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/islower]] to [[cpp/string/byte/islower]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/islower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isprint</title>
    <ns>0</ns>
    <id>3819</id>
    <redirect title="cpp/string/byte/isprint" />
    <revision>
      <id>14307</id>
      <timestamp>2011-11-27T01:11:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isprint]] to [[cpp/string/byte/isprint]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isprint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/ispunct</title>
    <ns>0</ns>
    <id>3820</id>
    <redirect title="cpp/string/byte/ispunct" />
    <revision>
      <id>14309</id>
      <timestamp>2011-11-27T01:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/ispunct]] to [[cpp/string/byte/ispunct]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/ispunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isspace</title>
    <ns>0</ns>
    <id>3821</id>
    <redirect title="cpp/string/byte/isspace" />
    <revision>
      <id>14311</id>
      <timestamp>2011-11-27T01:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isspace]] to [[cpp/string/byte/isspace]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isspace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isupper</title>
    <ns>0</ns>
    <id>3822</id>
    <redirect title="cpp/string/byte/isupper" />
    <revision>
      <id>14313</id>
      <timestamp>2011-11-27T01:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isupper]] to [[cpp/string/byte/isupper]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/isupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/isxdigit</title>
    <ns>0</ns>
    <id>3823</id>
    <redirect title="cpp/string/byte/isxdigit" />
    <revision>
      <id>14315</id>
      <timestamp>2011-11-27T01:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/isxdigit]] to [[cpp/string/byte/isxdigit]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/string/byte/isxdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/memchr</title>
    <ns>0</ns>
    <id>3824</id>
    <redirect title="cpp/string/byte/memchr" />
    <revision>
      <id>14317</id>
      <timestamp>2011-11-27T01:11:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/memchr]] to [[cpp/string/byte/memchr]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/memchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/memcmp</title>
    <ns>0</ns>
    <id>3825</id>
    <redirect title="cpp/string/byte/memcmp" />
    <revision>
      <id>14319</id>
      <timestamp>2011-11-27T01:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/memcmp]] to [[cpp/string/byte/memcmp]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/memcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/memcpy</title>
    <ns>0</ns>
    <id>3826</id>
    <redirect title="cpp/string/byte/memcpy" />
    <revision>
      <id>14321</id>
      <timestamp>2011-11-27T01:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/memcpy]] to [[cpp/string/byte/memcpy]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/memcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/memmove</title>
    <ns>0</ns>
    <id>3827</id>
    <redirect title="cpp/string/byte/memmove" />
    <revision>
      <id>14323</id>
      <timestamp>2011-11-27T01:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/memmove]] to [[cpp/string/byte/memmove]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/memmove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/memset</title>
    <ns>0</ns>
    <id>3828</id>
    <redirect title="cpp/string/byte/memset" />
    <revision>
      <id>14325</id>
      <timestamp>2011-11-27T01:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/memset]] to [[cpp/string/byte/memset]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/memset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strcat</title>
    <ns>0</ns>
    <id>3829</id>
    <redirect title="cpp/string/byte/strcat" />
    <revision>
      <id>14327</id>
      <timestamp>2011-11-27T01:11:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strcat]] to [[cpp/string/byte/strcat]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strcat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strchr</title>
    <ns>0</ns>
    <id>3830</id>
    <redirect title="cpp/string/byte/strchr" />
    <revision>
      <id>14329</id>
      <timestamp>2011-11-27T01:11:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strchr]] to [[cpp/string/byte/strchr]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strcmp</title>
    <ns>0</ns>
    <id>3831</id>
    <redirect title="cpp/string/byte/strcmp" />
    <revision>
      <id>14331</id>
      <timestamp>2011-11-27T01:11:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strcmp]] to [[cpp/string/byte/strcmp]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strcpy</title>
    <ns>0</ns>
    <id>3832</id>
    <redirect title="cpp/string/byte/strcpy" />
    <revision>
      <id>14333</id>
      <timestamp>2011-11-27T01:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strcpy]] to [[cpp/string/byte/strcpy]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strcspn</title>
    <ns>0</ns>
    <id>3833</id>
    <redirect title="cpp/string/byte/strcspn" />
    <revision>
      <id>14335</id>
      <timestamp>2011-11-27T01:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strcspn]] to [[cpp/string/byte/strcspn]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strcspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strlen</title>
    <ns>0</ns>
    <id>3834</id>
    <redirect title="cpp/string/byte/strlen" />
    <revision>
      <id>14337</id>
      <timestamp>2011-11-27T01:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strlen]] to [[cpp/string/byte/strlen]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strlen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strncat</title>
    <ns>0</ns>
    <id>3835</id>
    <redirect title="cpp/string/byte/strncat" />
    <revision>
      <id>14339</id>
      <timestamp>2011-11-27T01:11:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strncat]] to [[cpp/string/byte/strncat]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strncat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strncmp</title>
    <ns>0</ns>
    <id>3836</id>
    <redirect title="cpp/string/byte/strncmp" />
    <revision>
      <id>14341</id>
      <timestamp>2011-11-27T01:11:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strncmp]] to [[cpp/string/byte/strncmp]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strncmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strncpy</title>
    <ns>0</ns>
    <id>3837</id>
    <redirect title="cpp/string/byte/strncpy" />
    <revision>
      <id>14343</id>
      <timestamp>2011-11-27T01:11:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strncpy]] to [[cpp/string/byte/strncpy]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strncpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strpbrk</title>
    <ns>0</ns>
    <id>3838</id>
    <redirect title="cpp/string/byte/strpbrk" />
    <revision>
      <id>14345</id>
      <timestamp>2011-11-27T01:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strpbrk]] to [[cpp/string/byte/strpbrk]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strpbrk]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strrchr</title>
    <ns>0</ns>
    <id>3839</id>
    <redirect title="cpp/string/byte/strrchr" />
    <revision>
      <id>14347</id>
      <timestamp>2011-11-27T01:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strrchr]] to [[cpp/string/byte/strrchr]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strrchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strspn</title>
    <ns>0</ns>
    <id>3840</id>
    <redirect title="cpp/string/byte/strspn" />
    <revision>
      <id>14349</id>
      <timestamp>2011-11-27T01:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strspn]] to [[cpp/string/byte/strspn]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strstr</title>
    <ns>0</ns>
    <id>3841</id>
    <redirect title="cpp/string/byte/strstr" />
    <revision>
      <id>14351</id>
      <timestamp>2011-11-27T01:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strstr]] to [[cpp/string/byte/strstr]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strstr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtod</title>
    <ns>0</ns>
    <id>3842</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>15839</id>
      <parentid>14353</parentid>
      <timestamp>2011-12-17T02:22:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtof</title>
    <ns>0</ns>
    <id>3843</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>14355</id>
      <timestamp>2011-11-27T01:11:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strtof]] to [[cpp/string/byte/strtof]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtol</title>
    <ns>0</ns>
    <id>3844</id>
    <redirect title="cpp/string/byte/strtol" />
    <revision>
      <id>14357</id>
      <timestamp>2011-11-27T01:11:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strtol]] to [[cpp/string/byte/strtol]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtold</title>
    <ns>0</ns>
    <id>3845</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>15837</id>
      <parentid>14359</parentid>
      <timestamp>2011-12-17T02:22:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix infinite redirect</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtoll</title>
    <ns>0</ns>
    <id>3846</id>
    <redirect title="cpp/string/byte/strtol" />
    <revision>
      <id>15836</id>
      <parentid>14361</parentid>
      <timestamp>2011-12-17T02:21:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/string/byte/strtol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtoul</title>
    <ns>0</ns>
    <id>3847</id>
    <redirect title="cpp/string/byte/strtoul" />
    <revision>
      <id>14363</id>
      <timestamp>2011-11-27T01:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strtoul]] to [[cpp/string/byte/strtoul]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strtoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strtoull</title>
    <ns>0</ns>
    <id>3848</id>
    <redirect title="cpp/string/byte/strtoul" />
    <revision>
      <id>15835</id>
      <parentid>14365</parentid>
      <timestamp>2011-12-17T02:21:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strtoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/strxfrm</title>
    <ns>0</ns>
    <id>3849</id>
    <redirect title="cpp/string/byte/strxfrm" />
    <revision>
      <id>14367</id>
      <timestamp>2011-11-27T01:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/strxfrm]] to [[cpp/string/byte/strxfrm]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/strxfrm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/tolower</title>
    <ns>0</ns>
    <id>3850</id>
    <redirect title="cpp/string/byte/tolower" />
    <revision>
      <id>14369</id>
      <timestamp>2011-11-27T01:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/tolower]] to [[cpp/string/byte/tolower]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/tolower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/narrow/toupper</title>
    <ns>0</ns>
    <id>3851</id>
    <redirect title="cpp/string/byte/toupper" />
    <revision>
      <id>14371</id>
      <timestamp>2011-11-27T01:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/narrow/toupper]] to [[cpp/string/byte/toupper]]: narrow -&gt; byte</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/string/byte/toupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stof</title>
    <ns>0</ns>
    <id>2752</id>
    <redirect title="cpp/string/basic string/stof" />
    <revision>
      <id>10416</id>
      <timestamp>2011-09-12T18:42:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/stof]] to [[cpp/string/basic string/stof]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/string/basic string/stof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stoi</title>
    <ns>0</ns>
    <id>2467</id>
    <redirect title="cpp/string/basic string/stol" />
    <revision>
      <id>15834</id>
      <parentid>8767</parentid>
      <timestamp>2011-12-17T02:20:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/string/basic_string/stol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stol</title>
    <ns>0</ns>
    <id>2750</id>
    <redirect title="cpp/string/basic string/stol" />
    <revision>
      <id>10412</id>
      <timestamp>2011-09-12T18:41:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/stol]] to [[cpp/string/basic string/stol]]</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/string/basic string/stol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stoll</title>
    <ns>0</ns>
    <id>2471</id>
    <redirect title="cpp/string/basic string/stol" />
    <revision>
      <id>15833</id>
      <parentid>8790</parentid>
      <timestamp>2011-12-17T02:20:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[cpp/string/basic_string/stol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stoul</title>
    <ns>0</ns>
    <id>2751</id>
    <redirect title="cpp/string/basic string/stoul" />
    <revision>
      <id>10414</id>
      <timestamp>2011-09-12T18:42:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/stoul]] to [[cpp/string/basic string/stoul]]</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/string/basic string/stoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/stoull</title>
    <ns>0</ns>
    <id>2472</id>
    <redirect title="cpp/string/basic string/stoul" />
    <revision>
      <id>15832</id>
      <parentid>8791</parentid>
      <timestamp>2011-12-17T02:20:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix double redirect</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/string/basic_string/stoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/to string</title>
    <ns>0</ns>
    <id>2753</id>
    <redirect title="cpp/string/basic string/to string" />
    <revision>
      <id>10418</id>
      <timestamp>2011-09-12T18:42:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/to string]] to [[cpp/string/basic string/to string]]</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/string/basic string/to string]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/to wstring</title>
    <ns>0</ns>
    <id>2754</id>
    <redirect title="cpp/string/basic string/to wstring" />
    <revision>
      <id>10420</id>
      <timestamp>2011-09-12T18:42:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/string/to wstring]] to [[cpp/string/basic string/to wstring]]</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/string/basic string/to wstring]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide</title>
    <ns>0</ns>
    <id>2597</id>
    <revision>
      <id>71111</id>
      <parentid>59080</parentid>
      <timestamp>2014-06-06T12:12:03Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="3521">{{title|Null-terminated wide strings}}
{{cpp/string/wide/navbar}}

A null-terminated wide string is a sequence of valid wide characters, ending with a null character.

===Functions===
{{dsc begin}}
{{dsc h2 | Character classification}}
{{dsc header | cwctype}}
{{dsc inc | cpp/string/wide/dsc iswalnum}}
{{dsc inc | cpp/string/wide/dsc iswalpha}}
{{dsc inc | cpp/string/wide/dsc iswlower}}
{{dsc inc | cpp/string/wide/dsc iswupper}}
{{dsc inc | cpp/string/wide/dsc iswdigit}}
{{dsc inc | cpp/string/wide/dsc iswxdigit}}
{{dsc inc | cpp/string/wide/dsc iswcntrl}}
{{dsc inc | cpp/string/wide/dsc iswgraph}}
{{dsc inc | cpp/string/wide/dsc iswspace}}
{{dsc inc | cpp/string/wide/dsc iswblank}}
{{dsc inc | cpp/string/wide/dsc iswprint}}
{{dsc inc | cpp/string/wide/dsc iswpunct}}
{{dsc inc | cpp/string/wide/dsc iswctype}}
{{dsc inc | cpp/string/wide/dsc wctype}}
{{dsc h2 | Character manipulation}}
{{dsc header | cwctype}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc inc | cpp/string/wide/dsc towctrans}}
{{dsc inc | cpp/string/wide/dsc wctrans}}
{{dsc end}}
{{cpp/string/character classes}}
{{dsc begin}}
{{dsc h2 | Conversions to numeric formats}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/wide/dsc wcstol}}
{{dsc inc | cpp/string/wide/dsc wcstoul}}
{{dsc inc | cpp/string/wide/dsc wcstof}}
{{dsc header | cinttypes}}
{{dsc inc | cpp/string/wide/dsc wcstoimax}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | String manipulation}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/wide/dsc wcscpy}}
{{dsc inc | cpp/string/wide/dsc wcsncpy}}
{{dsc inc | cpp/string/wide/dsc wcscat}}
{{dsc inc | cpp/string/wide/dsc wcsncat}}
{{dsc inc | cpp/string/wide/dsc wcsxfrm}}

{{dsc h2 | String examination}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/wide/dsc wcslen}}
{{dsc inc | cpp/string/wide/dsc wcscmp}}
{{dsc inc | cpp/string/wide/dsc wcsncmp}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/wide/dsc wcsrchr}}
{{dsc inc | cpp/string/wide/dsc wcsspn}}
{{dsc inc | cpp/string/wide/dsc wcscspn}}
{{dsc inc | cpp/string/wide/dsc wcspbrk}}
{{dsc inc | cpp/string/wide/dsc wcsstr}}
{{dsc inc | cpp/string/wide/dsc wcstok}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Wide character array manipulation}}
{{dsc header | cwchar}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc inc | cpp/string/wide/dsc wmemmove}}
{{dsc inc | cpp/string/wide/dsc wmemcmp}}
{{dsc inc | cpp/string/wide/dsc wmemchr}}
{{dsc inc | cpp/string/wide/dsc wmemset}}
{{dsc end}}

===Types===
{{dsc begin}}
{{dsc header | cwctype}}
{{dsc | {{tt|wctrans_t}} | scalar type that holds locale-specific character mapping }}
{{dsc | {{tt|wctype_t}} | scalar type that holds locale-specific character classification }}
{{dsc | {{tt|wint_t}} | integer type that can hold any valid wide character and at least one more value }}
{{dsc end}}

===Macros===
{{dsc begin}}
{{dsc header | cwchar}}
{{dsc macro const | WEOF |  nolink=true | a non-character value of type wint_t used to indicate errors}}
{{dsc macro const | WCHAR_MIN |  nolink=true | the smallest valid value of wchar_t }}
{{dsc macro const | WCHAR_MAX |  nolink=true | the largest valid value of wchar_t }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/wide | Null-terminated wide strings}}
{{dsc end}}

[[de:cpp/string/wide]]
[[es:cpp/string/wide]]
[[fr:cpp/string/wide]]
[[it:cpp/string/wide]]
[[ja:cpp/string/wide]]
[[pt:cpp/string/wide]]
[[ru:cpp/string/wide]]
[[zh:cpp/string/wide]]</text>
      <sha1>l26w96frg0zf8n2nn3qxssljw6yg1cr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswalnum</title>
    <ns>0</ns>
    <id>1763</id>
    <revision>
      <id>59081</id>
      <parentid>51288</parentid>
      <timestamp>2013-06-01T06:26:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1682">{{cpp/title|iswalnum}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswalnum( std::wint_t ch );
}}

Checks if the given wide character is an alphanumeric character, i.e. either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}) or any alphanumeric character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a alphanumeric character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u13ad'; // the Cherokee letter HA ('Ꭽ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswalnum(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswalnum(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswalnum(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswalnum(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswalnum(0x13ad) = false
in Unicode locale, iswalnum(0x13ad) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isalnum}}
{{dsc inc | cpp/string/byte/dsc isalnum}}
{{dsc see c | c/string/wide/iswalnum}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswalnum]]
[[es:cpp/string/wide/iswalnum]]
[[fr:cpp/string/wide/iswalnum]]
[[it:cpp/string/wide/iswalnum]]
[[ja:cpp/string/wide/iswalnum]]
[[pt:cpp/string/wide/iswalnum]]
[[ru:cpp/string/wide/iswalnum]]
[[zh:cpp/string/wide/iswalnum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswalpha</title>
    <ns>0</ns>
    <id>1764</id>
    <revision>
      <id>59084</id>
      <parentid>51289</parentid>
      <timestamp>2013-06-01T06:26:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1614">{{cpp/title|iswalpha}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswalpha( std::wint_t ch );
}}

Checks if the given wide character is an alphabetic character, i.e. either an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}) or any alphabetic character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value if the wide character is a alphabetic character, {{tt|0}} otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u0b83'; // Tamil sign Visarga ('ஃ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswalpha(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswalpha(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswalpha(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswalpha(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswalpha(0xb83) = false
in Unicode locale, iswalpha(0xb83) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isalpha}}
{{dsc inc | cpp/string/byte/dsc isalpha}}
{{dsc see c | c/string/wide/iswalpha}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/wide/iswalpha]]
[[es:cpp/string/wide/iswalpha]]
[[fr:cpp/string/wide/iswalpha]]
[[it:cpp/string/wide/iswalpha]]
[[ja:cpp/string/wide/iswalpha]]
[[pt:cpp/string/wide/iswalpha]]
[[ru:cpp/string/wide/iswalpha]]
[[zh:cpp/string/wide/iswalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswblank</title>
    <ns>0</ns>
    <id>2932</id>
    <revision>
      <id>63433</id>
      <parentid>59085</parentid>
      <timestamp>2013-07-10T01:32:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1672">{{cpp/title|iswblank}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype | since=c++11 |
int iswblank( std::wint_t ch );
}}

Checks if the given wide character is classified as blank character (that is, a whitespace character used to separate words in a sentence) by the current C locale. In the default C locale, only space ({{tt|0x20}}) and horizontal tab ({{tt|0x09}}) are blank characters.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a blank character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u3000'; // Ideographic space ('　')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswblank(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswblank(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswblank(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswblank(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswblank(0x3000) = false
in Unicode locale, iswblank(0x3000) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isblank}}
{{dsc inc | cpp/string/byte/dsc isblank}}
{{dsc see c | c/string/wide/iswblank}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswblank]]
[[es:cpp/string/wide/iswblank]]
[[fr:cpp/string/wide/iswblank]]
[[it:cpp/string/wide/iswblank]]
[[ja:cpp/string/wide/iswblank]]
[[pt:cpp/string/wide/iswblank]]
[[ru:cpp/string/wide/iswblank]]
[[zh:cpp/string/wide/iswblank]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswcntrl</title>
    <ns>0</ns>
    <id>1765</id>
    <revision>
      <id>59086</id>
      <parentid>51291</parentid>
      <timestamp>2013-06-01T06:26:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1568">{{cpp/title|iswcntrl}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswcntrl( std::wint_t ch );
}}

Checks if the given wide character is a control character, i.e. codes {{tt|0x00-0x1F}} and {{tt|0x7F}} and any control characters specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a control character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u2028'; // the Unicode character &quot;line separator&quot; 

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswcntrl(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswcntrl(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswcntrl(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswcntrl(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswcntrl(0x2028) = false
in Unicode locale, iswcntrl(0x2028) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc iscntrl}}
{{dsc inc | cpp/string/byte/dsc iscntrl}}
{{dsc see c | c/string/wide/iswcntrl}}
{{dsc end}}

{{cpp/string/character classes}}

[[de:cpp/string/wide/iswcntrl]]
[[es:cpp/string/wide/iswcntrl]]
[[fr:cpp/string/wide/iswcntrl]]
[[it:cpp/string/wide/iswcntrl]]
[[ja:cpp/string/wide/iswcntrl]]
[[pt:cpp/string/wide/iswcntrl]]
[[ru:cpp/string/wide/iswcntrl]]
[[zh:cpp/string/wide/iswcntrl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswctype</title>
    <ns>0</ns>
    <id>2968</id>
    <revision>
      <id>59089</id>
      <parentid>51292</parentid>
      <timestamp>2013-06-01T06:26:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1471">{{cpp/title|iswctype}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswctype( std::wint_t ch, std::wctype_t desc );
}}

Classifies the wide character {{tt|wc}} using the current C locale's LC_CTYPE category identified by {{tt|desc}}.

===Parameters===
{{par begin}}
{{par | ch | the wide character to classify}}
{{par | desc | the LC_CTYPE category, obtained from a call to {{lc|std::wctype}}}}
{{par end}}

===Return value===

Non-zero if the character {{tt|ch}} has the property identified by {{tt|desc}} in LC_CTYPE facet of the current C locale.

===Example===
{{example
 |
 | code=
#include &lt;clocale&gt;
#include &lt;cwctype&gt;
#include &lt;iostream&gt;
bool classify(wchar_t ch, const std::string&amp; cat)
{
    return std::iswctype(ch, std::wctype(cat.c_str()));
}
int main()
{
    std::setlocale(LC_ALL, &quot;ja_JP.UTF-8&quot;);
    std::cout &lt;&lt; &quot;The character \u6c34 is...\n&quot;;
    for(std::string s : {&quot;digit&quot;, &quot;alpha&quot;, &quot;space&quot;, &quot;cntrl&quot;, &quot;jkanji&quot;})
        std::cout &lt;&lt; s &lt;&lt; &quot;? &quot; &lt;&lt; std::boolalpha &lt;&lt; classify(L'\u6c34', s) &lt;&lt; '\n';
}
 | output=
The character 水 is...
digit? false
alpha? true
space? false
cntrl? false
jkanji? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wctype}}
{{dsc end}}

[[de:cpp/string/wide/iswctype]]
[[es:cpp/string/wide/iswctype]]
[[fr:cpp/string/wide/iswctype]]
[[it:cpp/string/wide/iswctype]]
[[ja:cpp/string/wide/iswctype]]
[[pt:cpp/string/wide/iswctype]]
[[ru:cpp/string/wide/iswctype]]
[[zh:cpp/string/wide/iswctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswdigit</title>
    <ns>0</ns>
    <id>1766</id>
    <revision>
      <id>59090</id>
      <parentid>51293</parentid>
      <timestamp>2013-06-01T06:26:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2407">{{cpp/title|iswdigit}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswdigit( wint_t ch );
}}

Checks if the given wide character corresponds (if narrowed) to one of the ten decimal digit characters {{tt|0123456789}}.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|iswdigit}} and {{tt|iswxdigit}} are the only standard wide character classification functions that are not affected by the currently installed C locale.

===Example===
{{example | Some locales offer additional character classes that detect non-ASCII digits
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;
void test(wchar_t a3, wchar_t u3, wchar_t j3)
{
    std::wcout &lt;&lt; std::boolalpha
               &lt;&lt; &quot;          '&quot; &lt;&lt; a3 &lt;&lt; &quot;'   '&quot; &lt;&lt; u3 &lt;&lt; &quot;'  '&quot; &lt;&lt; j3  &lt;&lt; &quot;'\n&quot;
               &lt;&lt; &quot;iswdigit &quot;
               &lt;&lt; (bool)std::iswdigit(a3) &lt;&lt; &quot;  &quot;
               &lt;&lt; (bool)std::iswdigit(u3) &lt;&lt; &quot; &quot;
               &lt;&lt; (bool)std::iswdigit(j3) &lt;&lt; '\n'
               &lt;&lt; &quot;jdigit:  &quot;
               &lt;&lt; (bool)std::iswctype(a3, std::wctype(&quot;jdigit&quot;)) &lt;&lt; ' '
               &lt;&lt; (bool)std::iswctype(u3, std::wctype(&quot;jdigit&quot;)) &lt;&lt; ' '
               &lt;&lt; (bool)std::iswctype(j3, std::wctype(&quot;jdigit&quot;)) &lt;&lt; '\n';
}
int main()
{
    wchar_t a3 = L'3';  // the ASCII digit 3
    wchar_t u3 = L'三'; // the CJK numeral 3
    wchar_t j3 = L'３'; // the fullwidth digit 3

    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::wcout &lt;&lt; &quot;In american locale:\n&quot;;
    test(a3, u3, j3);

    std::wcout &lt;&lt; &quot;\nIn japanese locale:\n&quot;;
    std::setlocale(LC_ALL, &quot;ja_JP.utf8&quot;);
    test(a3, u3, j3);
}
| output=
In american locale:
          '3'   '三'  '３'
iswdigit true  false false
jdigit:  false false false

In japanese locale:
          '3'   '三'  '３'
iswdigit true  false false
jdigit:  false false true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isdigit}}
{{dsc inc | cpp/string/byte/dsc isdigit}}
{{dsc see c | c/string/wide/iswdigit}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswdigit]]
[[es:cpp/string/wide/iswdigit]]
[[fr:cpp/string/wide/iswdigit]]
[[it:cpp/string/wide/iswdigit]]
[[ja:cpp/string/wide/iswdigit]]
[[pt:cpp/string/wide/iswdigit]]
[[ru:cpp/string/wide/iswdigit]]
[[zh:cpp/string/wide/iswdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswgraph</title>
    <ns>0</ns>
    <id>1767</id>
    <revision>
      <id>62279</id>
      <parentid>59091</parentid>
      <timestamp>2013-06-26T03:55:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;i. e.&quot; to &quot;i.e.&quot;</comment>
      <text xml:space="preserve" bytes="1818">{{cpp/title|iswgraph}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswgraph( std::wint_t ch );
}}

Checks if the given wide character has a graphical representation, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}) or any graphical character specific to the current C locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character has a graphical representation character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u2602'; // the Unicode character Umbrella ('☂')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswgraph(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswgraph(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswgraph(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswgraph(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswgraph(0x2602) = false
in Unicode locale, iswgraph(0x2602) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isgraph}}
{{dsc inc | cpp/string/byte/dsc isgraph}}
{{dsc see c | c/string/wide/iswgraph}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswgraph]]
[[es:cpp/string/wide/iswgraph]]
[[fr:cpp/string/wide/iswgraph]]
[[it:cpp/string/wide/iswgraph]]
[[ja:cpp/string/wide/iswgraph]]
[[pt:cpp/string/wide/iswgraph]]
[[ru:cpp/string/wide/iswgraph]]
[[zh:cpp/string/wide/iswgraph]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswlower</title>
    <ns>0</ns>
    <id>1768</id>
    <revision>
      <id>59094</id>
      <parentid>51295</parentid>
      <timestamp>2013-06-01T06:26:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1555">{{cpp/title|iswlower}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswlower( std::wint_t ch );
}}

Checks if the given wide character is a lowercase letter, i.e. one of {{tt|abcdefghijklmnopqrstuvwxyz}} or any lowercase letter specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an lowercase letter, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u0444'; // Cyrillic small letter ef ('ф')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswlower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswlower(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswlower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswlower(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswlower(0x444) = false
in Unicode locale, iswlower(0x444) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc islower}}
{{dsc inc | cpp/string/byte/dsc islower}}
{{dsc see c | c/string/wide/iswlower}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswlower]]
[[es:cpp/string/wide/iswlower]]
[[fr:cpp/string/wide/iswlower]]
[[it:cpp/string/wide/iswlower]]
[[ja:cpp/string/wide/iswlower]]
[[pt:cpp/string/wide/iswlower]]
[[ru:cpp/string/wide/iswlower]]
[[zh:cpp/string/wide/iswlower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswprint</title>
    <ns>0</ns>
    <id>1769</id>
    <revision>
      <id>62284</id>
      <parentid>62280</parentid>
      <timestamp>2013-06-26T04:18:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example, std::</comment>
      <text xml:space="preserve" bytes="1741">{{cpp/title|iswprint}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswprint( std::wint_t ch );
}}

Checks if the given wide character can be printed, i.e. it is either a number ({{tt|0123456789}}), an uppercase letter ({{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}}), a lowercase letter ({{tt|abcdefghijklmnopqrstuvwxyz}}), a punctuation character({{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}}), space or any printable character specific to the current C locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character can be printed, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u2002'; // en-space
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; std::boolalpha &lt;&lt; std::hex &lt;&lt; std::showbase
              &lt;&lt; &quot;in Unicode locale,\n&quot;
              &lt;&lt; &quot;iswprint('&quot; &lt;&lt; c &lt;&lt; &quot;') = &quot;
              &lt;&lt; (bool)std::iswprint(c) &lt;&lt; '\n';

    c = L'\u0082'; // break permitted
    std::cout &lt;&lt; &quot;iswprint('&quot; &lt;&lt; c &lt;&lt; &quot;') = &quot;
              &lt;&lt; (bool)std::iswprint(c) &lt;&lt; '\n';
}
|output=
in Unicode locale,
iswprint('0x2002') = true
iswprint('0x82') = false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isprint}}
{{dsc inc | cpp/string/byte/dsc isprint}}
{{dsc see c | c/string/wide/iswprint}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswprint]]
[[es:cpp/string/wide/iswprint]]
[[fr:cpp/string/wide/iswprint]]
[[it:cpp/string/wide/iswprint]]
[[ja:cpp/string/wide/iswprint]]
[[pt:cpp/string/wide/iswprint]]
[[ru:cpp/string/wide/iswprint]]
[[zh:cpp/string/wide/iswprint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswpunct</title>
    <ns>0</ns>
    <id>1770</id>
    <revision>
      <id>59096</id>
      <parentid>51297</parentid>
      <timestamp>2013-06-01T06:27:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1615">{{cpp/title|iswpunct}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswpunct( std::wint_t ch );
}}

Checks if the given wide character is a punctuation character, i.e. it is one of {{tt|!&quot;#$%&amp;'()*+,-./:;&lt;{{=}}&gt;?@[\]^_`{&lt;nowiki&gt;&lt;/nowiki&gt;{{!}}&lt;nowiki&gt;&lt;/nowiki&gt;}~}} or any punctuation character specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a punctuation character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u2051'; // Two asterisks ('⁑')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswpunct(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswpunct(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswpunct(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswpunct(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswpunct(0x2051) = false
in Unicode locale, iswpunct(0x2051) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc ispunct}}
{{dsc inc | cpp/string/byte/dsc ispunct}}
{{dsc see c | c/string/wide/iswpunct}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswpunct]]
[[es:cpp/string/wide/iswpunct]]
[[fr:cpp/string/wide/iswpunct]]
[[it:cpp/string/wide/iswpunct]]
[[ja:cpp/string/wide/iswpunct]]
[[pt:cpp/string/wide/iswpunct]]
[[ru:cpp/string/wide/iswpunct]]
[[zh:cpp/string/wide/iswpunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswspace</title>
    <ns>0</ns>
    <id>1771</id>
    <revision>
      <id>63242</id>
      <parentid>59099</parentid>
      <timestamp>2013-07-06T23:07:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, ce</comment>
      <text xml:space="preserve" bytes="1819">{{cpp/title|iswspace}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswspace( wint_t ch );
}}

Checks if the given wide character is a wide whitespace character as classified by the currently installed C locale. In the default locale, the whitespace characters are the following:

* space ({{tt|0x20}}, {{c|' '}})
* form feed ({{tt|0x0c}}, {{c|'\f'}})
* line feed ({{tt|0x0a}}, {{c|'\n'}})
* carriage return ({{tt|0x0d}}, {{c|'\r'}})
* horizontal tab ({{tt|0x09}}, {{c|'\t'}}) 
* vertical tab ({{tt|0x0b}}, {{c|'\v'}})

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a whitespace character, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example
 | Demonstrates the use of {{c|iswspace()}} with different locales
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;
#include &lt;cwctype&gt;
void try_with(wchar_t c, const char* loc)
{
    std::setlocale(LC_ALL, loc);
    std::wcout &lt;&lt; &quot;isspace('&quot; &lt;&lt; c &lt;&lt; &quot;') in &quot; &lt;&lt; loc &lt;&lt; &quot; locale returned &quot;
               &lt;&lt; std::boolalpha &lt;&lt; (bool)std::iswspace(c) &lt;&lt; '\n';
}
int main()
{
    wchar_t EM_SPACE = L'\u2003'; // Unicode character 'EM SPACE'
    try_with(EM_SPACE, &quot;C&quot;);
    try_with(EM_SPACE, &quot;en_US.UTF8&quot;);
}
 | output=
isspace(' ') in C locale returned false
isspace(' ') in en_US.UTF8 locale returned true
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isspace}}
{{dsc inc | cpp/string/byte/dsc isspace}}
{{dsc see c | c/string/wide/iswspace}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswspace]]
[[es:cpp/string/wide/iswspace]]
[[fr:cpp/string/wide/iswspace]]
[[it:cpp/string/wide/iswspace]]
[[ja:cpp/string/wide/iswspace]]
[[pt:cpp/string/wide/iswspace]]
[[ru:cpp/string/wide/iswspace]]
[[zh:cpp/string/wide/iswspace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswupper</title>
    <ns>0</ns>
    <id>1772</id>
    <revision>
      <id>59100</id>
      <parentid>51299</parentid>
      <timestamp>2013-06-01T06:27:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1559">{{cpp/title|iswupper}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswupper( std::wint_t ch );
}}

Checks if the given wide character is an uppercase letter, i.e. one of {{tt|ABCDEFGHIJKLMNOPQRSTUVWXYZ}} or any uppercase letter specific to the current locale.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is an uppercase letter, {{tt|0}} ({{c|false}}) otherwise.

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u053d'; // Armenian capital letter xeh ('Խ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;in the default locale, iswupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswupper(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, iswupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; (bool)std::iswupper(c) &lt;&lt; '\n';
}
| output=
in the default locale, iswupper(0x53d) = false
in Unicode locale, iswupper(0x53d) = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isupper}}
{{dsc inc | cpp/string/byte/dsc isupper}}
{{dsc see c | c/string/wide/iswupper}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswupper]]
[[es:cpp/string/wide/iswupper]]
[[fr:cpp/string/wide/iswupper]]
[[it:cpp/string/wide/iswupper]]
[[ja:cpp/string/wide/iswupper]]
[[pt:cpp/string/wide/iswupper]]
[[ru:cpp/string/wide/iswupper]]
[[zh:cpp/string/wide/iswupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/iswxdigit</title>
    <ns>0</ns>
    <id>1773</id>
    <revision>
      <id>59103</id>
      <parentid>51300</parentid>
      <timestamp>2013-06-01T06:27:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1094">{{cpp/title|iswxdigit}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
int iswxdigit( wint_t ch );
}}

Checks if the given wide character corresponds (if narrowed) to a hexadecimal numeric character, i.e. one of {{tt|0123456789abcdefABCDEF}}.

===Parameters===
{{par begin}}
{{par | ch | wide character}}
{{par end}}

===Return value===
Non-zero value ({{c|true}}) if the wide character is a hexadecimal numeric character, {{tt|0}} ({{c|false}}) otherwise.

===Notes===
{{tt|iswdigit}} and {{tt|iswxdigit}} are the only standard wide character classification functions that are not affected by the currently installed C locale.

===See also===
{{dsc begin}}
{{dsc inc | cpp/locale/dsc isxdigit}}
{{dsc inc | cpp/string/byte/dsc isxdigit}}
{{dsc see c | c/string/wide/iswxdigit}}
{{dsc end}}
{{cpp/string/character classes}}

[[de:cpp/string/wide/iswxdigit]]
[[es:cpp/string/wide/iswxdigit]]
[[fr:cpp/string/wide/iswxdigit]]
[[it:cpp/string/wide/iswxdigit]]
[[ja:cpp/string/wide/iswxdigit]]
[[pt:cpp/string/wide/iswxdigit]]
[[ru:cpp/string/wide/iswxdigit]]
[[zh:cpp/string/wide/iswxdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/towctrans</title>
    <ns>0</ns>
    <id>2972</id>
    <revision>
      <id>59104</id>
      <parentid>51301</parentid>
      <timestamp>2013-06-01T06:27:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1629">{{cpp/title|towctrans}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
std::wint_t towctrans( std::wint_t wc, std::wctrans_t desc );
}}

Maps the wide character {{tt|wc}} using the current C locale's LC_CTYPE mapping category identified by {{tt|desc}}.

===Parameters===
{{par begin}}
{{par | ch | the wide character to map}}
{{par | desc | the LC_CTYPE mapping, obtained from a call to {{lc|std::wctrans}}}}
{{par end}}

===Return value===
The mapped value of {{tt|ch}} using the mapping identified by {{tt|desc}} in LC_CTYPE facet of the current C locale.

===Example===
{{example
 | The following example demonstrates katakana to hiragana character mapping
 | code=
#include &lt;clocale&gt;
#include &lt;cwctype&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;

std::wstring tohira(std::wstring str)
{
    std::transform(str.begin(), str.end(), str.begin(), [](wchar_t c) {
         return std::towctrans(c, std::wctrans(&quot;tojhira&quot;));
    });
    return str;
}

int main()
{
    std::setlocale(LC_ALL, &quot;ja_JP.UTF-8&quot;);
    std::wstring kana = L&quot;ヒラガナ&quot;;
    std::wcout &lt;&lt; &quot;katakana characters &quot; &lt;&lt; kana
               &lt;&lt; &quot; are &quot; &lt;&lt; tohira(kana) &lt;&lt; &quot; in hiragana\n&quot;;
}
 | output=
katakana characters ヒラガナ are ひらがな in hiragana
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wctrans}}
{{dsc see c | c/string/wide/towctrans}}
{{dsc end}}

[[de:cpp/string/wide/towctrans]]
[[es:cpp/string/wide/towctrans]]
[[fr:cpp/string/wide/towctrans]]
[[it:cpp/string/wide/towctrans]]
[[ja:cpp/string/wide/towctrans]]
[[pt:cpp/string/wide/towctrans]]
[[ru:cpp/string/wide/towctrans]]
[[zh:cpp/string/wide/towctrans]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/towlower</title>
    <ns>0</ns>
    <id>2961</id>
    <revision>
      <id>59107</id>
      <parentid>51302</parentid>
      <timestamp>2013-06-01T06:27:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1749">{{cpp/title|towlower}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
std::wint_t towlower( std::wint_t ch );
}}
Converts the given wide character to lowercase, if possible.

===Parameters===
{{par begin}}
{{par | ch | wide character to be converted}}
{{par end}}

===Return value===
Lowercase version of {{tt|ch}} or unmodified {{tt|ch}} if no lowercase version is listed in the current C locale.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the Greek uppercase letter 'Σ' has two lowercase forms, depending on the position in a word: 'σ' and 'ς'. A call to {{lc|std::towlower}} cannot be used to obtain the correct lowercase form in this case. 

===Example===
{{example |
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u0190'; // Latin capital open E ('Ɛ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    std::cout &lt;&lt; &quot;in the default locale, towlower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::towlower(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, towlower(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::towlower(c) &lt;&lt; '\n';
}
| output=
in the default locale, towlower(0x190) = 0x190
in Unicode locale, towlower(0x190) = 0x25b
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc towupper}}
{{dsc inc | cpp/locale/dsc tolower}}
{{dsc inc | cpp/string/byte/dsc tolower}}
{{dsc see c | c/string/wide/towlower}}
{{dsc end}}

[[de:cpp/string/wide/towlower]]
[[es:cpp/string/wide/towlower]]
[[fr:cpp/string/wide/towlower]]
[[it:cpp/string/wide/towlower]]
[[ja:cpp/string/wide/towlower]]
[[pt:cpp/string/wide/towlower]]
[[ru:cpp/string/wide/towlower]]
[[zh:cpp/string/wide/towlower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/towupper</title>
    <ns>0</ns>
    <id>2962</id>
    <revision>
      <id>59108</id>
      <parentid>51303</parentid>
      <timestamp>2013-06-01T06:27:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1779">{{cpp/title|towupper}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
std::wint_t towupper( std::wint_t ch );
}}
Converts the given wide character to uppercase, if possible.

===Parameters===
{{par begin}}
{{par | ch | wide character to be converted}}
{{par end}}

===Return value===
Uppercase version of {{tt|ch}} or unmodified {{tt|ch}} if no uppercase version is listed in the current C locale.

===Notes===
Only 1:1 character mapping can be performed by this function, e.g. the uppercase form of 'ß' is (with some exceptions) the two-character string &quot;SS&quot;, which cannot be obtained by {{lc|std::towupper}}.

===Example===
{{example | The latin [[enwiki:Long s|letter 'ſ' (U+017F)]] is the alternative lowercase form of 'S' (U+0053)
| code=
#include &lt;iostream&gt;
#include &lt;cwctype&gt;
#include &lt;clocale&gt;

int main()
{
    wchar_t c = L'\u017f'; // Latin small letter Long S ('ſ')

    std::cout &lt;&lt; std::hex &lt;&lt; std::showbase;
    std::cout &lt;&lt; &quot;in the default locale, towupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::towupper(c) &lt;&lt; '\n';
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::cout &lt;&lt; &quot;in Unicode locale, towupper(&quot; &lt;&lt; (std::wint_t)c &lt;&lt; &quot;) = &quot;
              &lt;&lt; std::towupper(c) &lt;&lt; '\n';
}
| output=
in the default locale, towupper(0x17f) = 0x17f
in Unicode locale, towupper(0x17f) = 0x53
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc towlower}}
{{dsc inc | cpp/locale/dsc toupper}}
{{dsc inc | cpp/string/byte/dsc toupper}}
{{dsc see c | c/string/wide/towupper}}
{{dsc end}}

[[de:cpp/string/wide/towupper]]
[[es:cpp/string/wide/towupper]]
[[fr:cpp/string/wide/towupper]]
[[it:cpp/string/wide/towupper]]
[[ja:cpp/string/wide/towupper]]
[[pt:cpp/string/wide/towupper]]
[[ru:cpp/string/wide/towupper]]
[[zh:cpp/string/wide/towupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcscat</title>
    <ns>0</ns>
    <id>3790</id>
    <revision>
      <id>59111</id>
      <parentid>51304</parentid>
      <timestamp>2013-06-01T06:27:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="995">{{cpp/title| wcscat}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t *wcscat( wchar_t *dest, const wchar_t *src );
}}

Appends a wide string pointed to by {{tt|src}} to a wide string pointed to by {{tt|dest}}. The resulting wide string is null-terminated. If the strings overlap, the behavior is undefined. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to append to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcsncat}}
{{dsc inc | cpp/string/wide/dsc wcscpy}}
{{dsc see c | c/string/wide/wcscat}}
{{dsc end}}

[[de:cpp/string/wide/wcscat]]
[[es:cpp/string/wide/wcscat]]
[[fr:cpp/string/wide/wcscat]]
[[it:cpp/string/wide/wcscat]]
[[ja:cpp/string/wide/wcscat]]
[[pt:cpp/string/wide/wcscat]]
[[ru:cpp/string/wide/wcscat]]
[[zh:cpp/string/wide/wcscat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcschr</title>
    <ns>0</ns>
    <id>3796</id>
    <revision>
      <id>59112</id>
      <parentid>51305</parentid>
      <timestamp>2013-06-01T06:27:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1811">{{cpp/title| wcschr}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
const wchar_t* wcschr( const wchar_t* str, wchar_t ch );
}}
{{dcl | 1=
      wchar_t* wcschr(       wchar_t* str, wchar_t ch );
}}
{{dcl end}}

Finds the first occurrence of the wide character {{tt|ch}} in the wide string pointed to by {{tt|str}}. 

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be analyzed}}
{{par | ch | wide character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;
#include &lt;locale&gt;

int main()
{
    wchar_t arr[] = L&quot;招き猫 кошка&quot;;
    const wchar_t* cat = std::wcschr(arr, L'猫');
    const wchar_t* dog = std::wcschr(arr, L'犬');

    std::cout.imbue(std::locale(&quot;en_US.utf8&quot;));

    if(cat)
        std::cout &lt;&lt; &quot;The character 猫 found at position &quot; &lt;&lt; cat - arr &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;The character 猫 not found\n&quot;;

    if(dog)
        std::cout &lt;&lt; &quot;The character 犬 found at position &quot; &lt;&lt; dog - arr &lt;&lt; '\n';
    else
        std::cout &lt;&lt; &quot;The character 犬 not found\n&quot;;
}
 | output=
The character 猫 found at position 2
The character 犬 not found
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/byte/dsc strchr}}
{{dsc inc | cpp/string/wide/dsc wcsrchr}}
{{dsc inc | cpp/string/wide/dsc wcspbrk}}
{{dsc see c | c/string/wide/wcschr}}
{{dsc end}}

[[de:cpp/string/wide/wcschr]]
[[es:cpp/string/wide/wcschr]]
[[fr:cpp/string/wide/wcschr]]
[[it:cpp/string/wide/wcschr]]
[[ja:cpp/string/wide/wcschr]]
[[pt:cpp/string/wide/wcschr]]
[[ru:cpp/string/wide/wcschr]]
[[zh:cpp/string/wide/wcschr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcscmp</title>
    <ns>0</ns>
    <id>3794</id>
    <revision>
      <id>59115</id>
      <parentid>51306</parentid>
      <timestamp>2013-06-01T06:27:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1025">{{cpp/title| wcscmp}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
int wcscmp( const wchar_t* lhs, const wchar_t* rhs );
}}

Compares two null-terminated wide strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcsncmp}}
{{dsc inc | cpp/string/wide/dsc wmemcmp}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc see c | c/string/wide/wcscmp}}
{{dsc end}}

[[de:cpp/string/wide/wcscmp]]
[[es:cpp/string/wide/wcscmp]]
[[fr:cpp/string/wide/wcscmp]]
[[it:cpp/string/wide/wcscmp]]
[[ja:cpp/string/wide/wcscmp]]
[[pt:cpp/string/wide/wcscmp]]
[[ru:cpp/string/wide/wcscmp]]
[[zh:cpp/string/wide/wcscmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcscoll</title>
    <ns>0</ns>
    <id>4585</id>
    <revision>
      <id>59116</id>
      <parentid>51307</parentid>
      <timestamp>2013-06-01T06:27:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2129">{{cpp/title| wcscoll}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
int wcscoll( const wchar_t* lhs, const wchar_t* rhs );
}}

Compares two null-terminated wide strings according to the locale most recently installed by {{lc|std::setlocale}}, as defined by the {{lc|LC_COLLATE}} category.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' (precedes) {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' (follows) {{tt|rhs}}.

===Notes===
{{cpp/locale/collate/collation_note}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;clocale&gt;

void try_compare(const wchar_t* p1, const wchar_t* p2)
{
    if(std::wcscoll(p1, p2) &lt; 0)
         std::wcout &lt;&lt; p1 &lt;&lt; &quot; before &quot; &lt;&lt; p2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; p2 &lt;&lt; &quot; before &quot; &lt;&lt; p1 &lt;&lt; '\n';
}

int main()
{
    std::setlocale(LC_ALL, &quot;en_US.utf8&quot;);
    std::wcout &lt;&lt; &quot;In the American locale: &quot;;
    try_compare(L&quot;hrnec&quot;, L&quot;chrt&quot;);

    std::setlocale(LC_COLLATE, &quot;cs_CZ.utf8&quot;);
    std::wcout &lt;&lt; &quot;In the Czech locale: &quot;;
    try_compare(L&quot;hrnec&quot;, L&quot;chrt&quot;);

    std::setlocale(LC_COLLATE, &quot;en_US.utf8&quot;);
    std::wcout &lt;&lt; &quot;In the American locale: &quot;;
    try_compare(L&quot;år&quot;, L&quot;ängel&quot;);

    std::setlocale(LC_COLLATE, &quot;sv_SE.utf8&quot;);
    std::wcout &lt;&lt; &quot;In the Swedish locale: &quot;;
    try_compare(L&quot;år&quot;, L&quot;ängel&quot;);
}
 | output=
In the American locale: chrt before hrnec
In the Czech locale: hrnec before chrt
In the American locale: ängel before år
In the Swedish locale: år before ängel
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strcoll}}
{{dsc inc | cpp/locale/collate/dsc do_compare}}
{{dsc inc | cpp/string/wide/dsc wcsxfrm}}
{{dsc see c | c/string/wide/wcscoll}}
{{dsc end}}

[[de:cpp/string/wide/wcscoll]]
[[es:cpp/string/wide/wcscoll]]
[[fr:cpp/string/wide/wcscoll]]
[[it:cpp/string/wide/wcscoll]]
[[ja:cpp/string/wide/wcscoll]]
[[pt:cpp/string/wide/wcscoll]]
[[ru:cpp/string/wide/wcscoll]]
[[zh:cpp/string/wide/wcscoll]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcscpy</title>
    <ns>0</ns>
    <id>3788</id>
    <revision>
      <id>59119</id>
      <parentid>51308</parentid>
      <timestamp>2013-06-01T06:27:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="997">{{cpp/title| wcscpy}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t *wcscpy( wchar_t *dest, const wchar_t *src );
}}

Copies the wide string pointed to by {{tt|src}} (including the terminating null wide character) to wide character array pointed to by {{tt|dest}}.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the wide character array to copy to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcsncpy}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc see c | c/string/wide/wcscpy}}
{{dsc end}}

[[de:cpp/string/wide/wcscpy]]
[[es:cpp/string/wide/wcscpy]]
[[fr:cpp/string/wide/wcscpy]]
[[it:cpp/string/wide/wcscpy]]
[[ja:cpp/string/wide/wcscpy]]
[[pt:cpp/string/wide/wcscpy]]
[[ru:cpp/string/wide/wcscpy]]
[[zh:cpp/string/wide/wcscpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcscspn</title>
    <ns>0</ns>
    <id>3799</id>
    <revision>
      <id>59120</id>
      <parentid>51309</parentid>
      <timestamp>2013-06-01T06:27:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1165">{{cpp/title| wcscspn}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
std::size_t wcscspn( const wchar_t* dest, const wchar_t* src );
}}

Returns the length of the maximum initial segment of the wide string pointed to by {{tt|dest}}, that consists of only the characters ''not'' found in wide string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters not found in the character string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcsspn}}
{{dsc inc | cpp/string/wide/dsc wcspbrk}}
{{dsc see c | c/string/wide/wcscspn}}
{{dsc end}}

[[de:cpp/string/wide/wcscspn]]
[[es:cpp/string/wide/wcscspn]]
[[fr:cpp/string/wide/wcscspn]]
[[it:cpp/string/wide/wcscspn]]
[[ja:cpp/string/wide/wcscspn]]
[[pt:cpp/string/wide/wcscspn]]
[[ru:cpp/string/wide/wcscspn]]
[[zh:cpp/string/wide/wcscspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcslen</title>
    <ns>0</ns>
    <id>3793</id>
    <revision>
      <id>51310</id>
      <parentid>42107</parentid>
      <timestamp>2013-06-01T03:58:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1037">{{cpp/title| wcslen}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
std::size_t wcslen( const wchar_t *str );
}}

Returns the length of a wide string, that is the number of non-null wide characters that precede the terminating null wide character.
===Parameters===
{{par begin}}
{{par |str | pointer to the null-terminated wide string to be examined}}
{{par end}}

===Return value===
The length of the null-terminated wide string {{tt|str}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;
int main()
{
    const wchar_t* str = L&quot;Hello, world!&quot;;
    std::wcout &lt;&lt; &quot;The length of L\&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot; is &quot; &lt;&lt; std::wcslen(str) &lt;&lt; '\n';
}
 | output=
The length of L&quot;Hello, world!&quot; is 13
}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/wide/wcslen}}
{{dsc end}}

[[de:cpp/string/wide/wcslen]]
[[es:cpp/string/wide/wcslen]]
[[fr:cpp/string/wide/wcslen]]
[[it:cpp/string/wide/wcslen]]
[[ja:cpp/string/wide/wcslen]]
[[pt:cpp/string/wide/wcslen]]
[[ru:cpp/string/wide/wcslen]]
[[zh:cpp/string/wide/wcslen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsncat</title>
    <ns>0</ns>
    <id>3791</id>
    <revision>
      <id>59121</id>
      <parentid>51311</parentid>
      <timestamp>2013-06-01T06:27:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1133">{{cpp/title| wcsncat}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t *wcsncat( wchar_t *dest, const wchar_t *src, std::size_t count );
}}

Appends a wide string pointed to by {{tt|src}} to a wide string pointed to by {{tt|dest}}. At most {{tt|count}} wide characters are copied. The resulting wide string is null-terminated. If the strings overlap, the behavior is undefined. 

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to append to}}
{{par | src | pointer to the null-terminated wide string to copy from}}
{{par | count | maximum number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscat}}
{{dsc inc | cpp/string/wide/dsc wcscpy}}
{{dsc see c | c/string/wide/wcsncat}}
{{dsc end}}

[[de:cpp/string/wide/wcsncat]]
[[es:cpp/string/wide/wcsncat]]
[[fr:cpp/string/wide/wcsncat]]
[[it:cpp/string/wide/wcsncat]]
[[ja:cpp/string/wide/wcsncat]]
[[pt:cpp/string/wide/wcsncat]]
[[ru:cpp/string/wide/wcsncat]]
[[zh:cpp/string/wide/wcsncat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsncmp</title>
    <ns>0</ns>
    <id>3795</id>
    <revision>
      <id>59124</id>
      <parentid>51312</parentid>
      <timestamp>2013-06-01T06:27:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1147">{{cpp/title| wcsncmp}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
int wcsncmp( const wchar_t* lhs, const wchar_t* rhs, size_t count );
}}

Compares at most {{tt|count}} wide characters of two null-terminated wide strings. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the null-terminated wide strings to compare}}
{{par | count | maximum number of characters to compare}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscmp}}
{{dsc inc | cpp/string/wide/dsc wmemcmp}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc see c | c/string/wide/wcsncmp}}
{{dsc end}}

[[de:cpp/string/wide/wcsncmp]]
[[es:cpp/string/wide/wcsncmp]]
[[fr:cpp/string/wide/wcsncmp]]
[[it:cpp/string/wide/wcsncmp]]
[[ja:cpp/string/wide/wcsncmp]]
[[pt:cpp/string/wide/wcsncmp]]
[[ru:cpp/string/wide/wcsncmp]]
[[zh:cpp/string/wide/wcsncmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsncpy</title>
    <ns>0</ns>
    <id>3789</id>
    <revision>
      <id>70355</id>
      <parentid>59125</parentid>
      <timestamp>2014-05-20T14:27:29Z</timestamp>
      <contributor>
        <ip>94.72.62.217</ip>
      </contributor>
      <comment>remove unneeded semicolon</comment>
      <text xml:space="preserve" bytes="2018">{{cpp/title| wcsncpy}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t *wcsncpy( wchar_t *dest, const wchar_t *src, std::size_t count );
}}

Copies at most {{tt|count}} characters of the wide string pointed to by {{tt|src}} (including the terminating null wide character) to wide character array pointed to by {{tt|dest}}. 

If {{tt|count}} is reached before the entire string {{tt|src}} was copied, the resulting wide character array is not null-terminated.

If, after copying the terminating null wide character from {{tt|src}}, {{tt|count}} is not reached, additional null wide characters are written to {{tt|dest}} until the total of {{tt|count}} characters have been written.

If the strings overlap, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the wide character array to copy to}}
{{par | src | pointer to the wide string to copy from}}
{{par | count | maximum number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Notes===
In typical usage, {{tt|count}} is the size of the destination array.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;

int main()
{
    wchar_t src[] = L&quot;hi&quot;;
    wchar_t dest[6] = {L'a', L'b', L'c', L'd', L'e', L'f'};

    std::wcsncpy(dest, src, 5); // this will copy hi and repeat \0 three times

    std::wcout &lt;&lt; &quot;The contents of dest are: &quot;;
    for(wchar_t c : dest) {
        if(c)
            std::wcout &lt;&lt; c &lt;&lt; ' ';
        else
            std::wcout &lt;&lt; &quot;\\0&quot; &lt;&lt; ' ';
    }
    std::wcout &lt;&lt; '\n';
}
 | output=
The contents of dest are: h i \0 \0 \0 f 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscpy}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc see c | c/string/wide/wcsncpy}}
{{dsc end}}

[[de:cpp/string/wide/wcsncpy]]
[[es:cpp/string/wide/wcsncpy]]
[[fr:cpp/string/wide/wcsncpy]]
[[it:cpp/string/wide/wcsncpy]]
[[ja:cpp/string/wide/wcsncpy]]
[[pt:cpp/string/wide/wcsncpy]]
[[ru:cpp/string/wide/wcsncpy]]
[[zh:cpp/string/wide/wcsncpy]]</text>
      <sha1>q0r0t536e54rwokijhr7amgdzvfsn86</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcspbrk</title>
    <ns>0</ns>
    <id>3800</id>
    <revision>
      <id>59126</id>
      <parentid>51314</parentid>
      <timestamp>2013-06-01T06:27:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1202">{{cpp/title| wcspbrk}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
const wchar_t* wcspbrk( const wchar_t* dest, const wchar_t* str );
}}
{{dcl |
      wchar_t* wcspbrk(       wchar_t* dest, const wchar_t* str );
}}
{{dcl end}}

Finds the first character in wide string pointed to by {{tt|dest}}, that is also in wide string pointed to by {{tt|str}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
Pointer to the first character in {{tt|dest}}, that is also in {{tt|str}}, or {{lc|NULL}} if no such character exists.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscspn}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc see c | c/string/wide/wcspbrk}}
{{dsc end}}

[[de:cpp/string/wide/wcspbrk]]
[[es:cpp/string/wide/wcspbrk]]
[[fr:cpp/string/wide/wcspbrk]]
[[it:cpp/string/wide/wcspbrk]]
[[ja:cpp/string/wide/wcspbrk]]
[[pt:cpp/string/wide/wcspbrk]]
[[ru:cpp/string/wide/wcspbrk]]
[[zh:cpp/string/wide/wcspbrk]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsrchr</title>
    <ns>0</ns>
    <id>3797</id>
    <revision>
      <id>59129</id>
      <parentid>51315</parentid>
      <timestamp>2013-06-01T06:27:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1131">{{cpp/title| wcsrchr}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
const wchar_t* wcsrchr( const wchar_t* str, wchar_t ch );
}}
{{dcl | 1=
      wchar_t* wcsrchr(       wchar_t* str, wchar_t ch );
}}
{{dcl end}}

Finds the last occurrence of the wide character {{tt|ch}} in the wide string pointed to by {{tt|str}}. 

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be analyzed}}
{{par | ch | wide character to search for}}
{{par end}}

===Return value===
Pointer to the found character in {{tt|str}}, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/byte/dsc strrchr}}
{{dsc inc | cpp/string/basic_string/dsc rfind}}
{{dsc see c | c/string/wide/wcsrchr}}
{{dsc end}}

[[de:cpp/string/wide/wcsrchr]]
[[es:cpp/string/wide/wcsrchr]]
[[fr:cpp/string/wide/wcsrchr]]
[[it:cpp/string/wide/wcsrchr]]
[[ja:cpp/string/wide/wcsrchr]]
[[pt:cpp/string/wide/wcsrchr]]
[[ru:cpp/string/wide/wcsrchr]]
[[zh:cpp/string/wide/wcsrchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsspn</title>
    <ns>0</ns>
    <id>3798</id>
    <revision>
      <id>59130</id>
      <parentid>51316</parentid>
      <timestamp>2013-06-01T06:27:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1125">{{cpp/title| wcsspn}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
size_t wcsspn( const wchar_t* dest, const wchar_t* src );
}}

Returns the length of the maximum initial segment of the wide string pointed to by {{tt|dest}}, that consists of only the characters found in wide string pointed to by {{tt|src}}.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to be analyzed}}
{{par | src | pointer to the null-terminated wide string that contains the characters to search for}}
{{par end}}

===Return value===
The length of the maximum initial segment that contains only characters from wide string pointed to by {{tt|src}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscspn}}
{{dsc inc | cpp/string/wide/dsc wcspbrk}}
{{dsc see c | c/string/wide/wcsspn}}
{{dsc end}}

[[de:cpp/string/wide/wcsspn]]
[[es:cpp/string/wide/wcsspn]]
[[fr:cpp/string/wide/wcsspn]]
[[it:cpp/string/wide/wcsspn]]
[[ja:cpp/string/wide/wcsspn]]
[[pt:cpp/string/wide/wcsspn]]
[[ru:cpp/string/wide/wcsspn]]
[[zh:cpp/string/wide/wcsspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsstr</title>
    <ns>0</ns>
    <id>3801</id>
    <revision>
      <id>65945</id>
      <parentid>59131</parentid>
      <timestamp>2013-10-16T12:13:38Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <text xml:space="preserve" bytes="1342">{{cpp/title| wcsstr}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
const wchar_t* wcsstr( const wchar_t* dest, const wchar_t* src );
}}
{{dcl | 1=
      wchar_t* wcsstr(       wchar_t* dest, const wchar_t* src );
}}
{{dcl end}}

Finds the first occurrence of the wide string {{tt|src}} in the wide string pointed to by {{tt|dest}}. The terminating null characters are not compared.

===Parameters===
{{par begin}}
{{par | dest | pointer to the null-terminated wide string to examine}}
{{par | src | pointer to the null-terminated wide string to search for}}
{{par end}}

===Return value===
Pointer to the first character of the found substring in {{tt|dest}}, or {{lc|NULL}} if no such substring is found. If {{tt|src}} points to an empty string, {{tt|dest}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc find}}
{{dsc inc | cpp/string/byte/dsc strstr}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/string/wide/dsc wcsrchr}}
{{dsc see c | c/string/wide/wcsstr}}
{{dsc end}}

[[de:cpp/string/wide/wcsstr]]
[[es:cpp/string/wide/wcsstr]]
[[fr:cpp/string/wide/wcsstr]]
[[it:cpp/string/wide/wcsstr]]
[[ja:cpp/string/wide/wcsstr]]
[[pt:cpp/string/wide/wcsstr]]
[[ru:cpp/string/wide/wcsstr]]
[[zh:cpp/string/wide/wcsstr]]</text>
      <sha1>bzos4lp0zldg69mjl5fk56vavzjdqa6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstod</title>
    <ns>0</ns>
    <id>4741</id>
    <redirect title="cpp/string/wide/wcstof" />
    <revision>
      <id>17214</id>
      <timestamp>2012-01-06T18:34:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/wide/wcstof]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstof</title>
    <ns>0</ns>
    <id>4740</id>
    <revision>
      <id>62962</id>
      <parentid>51318</parentid>
      <timestamp>2013-07-01T23:48:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1534">{{cpp/title| wcstof | wcstod | wcstold}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | since=c++11 |
float       wcstof( const wchar_t* str, wchar_t** str_end );           
}}
{{dcl | 
double      wcstod( const wchar_t* str, wchar_t** str_end );
}}
{{dcl | since=c++11 |
long double wcstold( const wchar_t* str, wchar_t** str_end );
}}
{{dcl end}}

Interprets a floating point value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2float|wide}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to a wide character.}}
{{par end}}

===Return value===
Floating point value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|HUGE_VAL}}, {{lc|HUGE_VALF}} or {{lc|HUGE_VALL}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/wide/wcstof}}
{{dsc end}}

[[de:cpp/string/wide/wcstof]]
[[es:cpp/string/wide/wcstof]]
[[fr:cpp/string/wide/wcstof]]
[[it:cpp/string/wide/wcstof]]
[[ja:cpp/string/wide/wcstof]]
[[pt:cpp/string/wide/wcstof]]
[[ru:cpp/string/wide/wcstof]]
[[zh:cpp/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstoimax</title>
    <ns>0</ns>
    <id>9531</id>
    <revision>
      <id>62963</id>
      <parentid>59134</parentid>
      <timestamp>2013-07-01T23:48:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2359">{{cpp/title| wcstoimax | wcstoumax}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cinttypes}}
{{dcl | since=c++11 | 
std::intmax_t wcstoimax( const wchar_t* nptr, wchar_t** endptr, int base );
}}
{{dcl | since=c++11 |
std::uintmax_t wcstoumax( const wchar_t* nptr, wchar_t** endptr, int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a wide string pointed to by {{tt|nptr}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|endptr}} to point to the wide character past the last character interpreted. If {{tt|endptr}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | nptr | pointer to the null-terminated wide string to be interpreted}}
{{par | endptr | pointer to a pointer to a wide character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|INTMAX_MAX}}, {{lc|INTMAX_MIN}}, {{lc|UINTMAX_MAX}}, or {{c|0}} is returned, as appropriate. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;cinttypes&gt;

int main()
{
    std::wstring str = L&quot;helloworld&quot;;
    std::intmax_t val = std::wcstoimax(str.c_str(), nullptr, 36);
    std::wcout &lt;&lt; str &lt;&lt; &quot; in base 36 is &quot; &lt;&lt; val &lt;&lt; &quot; in base 10\n&quot;;

    wchar_t* nptr;
    val = std::wcstoimax(str.c_str(), &amp;nptr, 30);
    if(nptr != &amp;str[0] + str.size())
        std::wcout &lt;&lt; str &lt;&lt; &quot; in base 30 is invalid.&quot;
                  &lt;&lt; &quot; The first invalid digit is &quot; &lt;&lt; *nptr &lt;&lt; '\n';
}
 | output=
helloworld in base 36 is 1767707668033969 in base 10
helloworld in base 30 is invalid. The first invalid digit is w
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strtoimax}}
{{dsc inc | cpp/string/wide/dsc wcstol}}
{{dsc inc | cpp/string/wide/dsc wcstoul}}
{{dsc see c | c/string/wide/wcstoimax | wcstoimax | wcstoumax}}
{{dsc end}}

[[de:cpp/string/wide/wcstoimax]]
[[es:cpp/string/wide/wcstoimax]]
[[fr:cpp/string/wide/wcstoimax]]
[[it:cpp/string/wide/wcstoimax]]
[[ja:cpp/string/wide/wcstoimax]]
[[pt:cpp/string/wide/wcstoimax]]
[[ru:cpp/string/wide/wcstoimax]]
[[zh:cpp/string/wide/wcstoimax]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstok</title>
    <ns>0</ns>
    <id>5516</id>
    <revision>
      <id>51320</id>
      <parentid>42023</parentid>
      <timestamp>2013-06-01T03:58:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1888">{{cpp/title| wcstok}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | 1=
wchar_t* wcstok( wchar_t* str, const wchar_t* delim );
}}
{{dcl end}}

Finds the next token in a null-terminated wide string pointed to by {{tt|str}}. The separator characters are identified by null-terminated wide string pointed to by {{tt|delim}}.

If {{c|str !{{=}} NULL}}, the function searches for the first wide character which is ''not'' separator. This character is the ''beginning of the token''. Then the function searches for the first separator character. This character is the ''end of the token''. Function terminates and returns {{lc|NULL}} if end of {{tt|str}} is encountered before ''end of the token'' is found. Otherwise, a pointer to ''end of the token'' is saved in a static location for subsequent invocations. This character is then replaced by a NULL-character and the function returns a pointer to the ''beginning of the token''.

If {{c|str {{==}} NULL}}, the function continues from where it left in previous invocation. The behavior is the same as if the previously stored pointer is passed as {{c|str}}.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to tokenize}}
{{par | delim | pointer to the null-terminated wide string identifying delimiters}}
{{par end}}

===Return value===
Pointer to the beginning of a token if the end of examined string has not been encountered. Otherwise returns {{lc|NULL}}&gt;

===Note===
The function is not thread safe.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see c | c/string/wide/wcstok}}
{{dsc end}}

[[de:cpp/string/wide/wcstok]]
[[es:cpp/string/wide/wcstok]]
[[fr:cpp/string/wide/wcstok]]
[[it:cpp/string/wide/wcstok]]
[[ja:cpp/string/wide/wcstok]]
[[pt:cpp/string/wide/wcstok]]
[[ru:cpp/string/wide/wcstok]]
[[zh:cpp/string/wide/wcstok]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstol</title>
    <ns>0</ns>
    <id>5128</id>
    <revision>
      <id>62964</id>
      <parentid>59135</parentid>
      <timestamp>2013-07-01T23:48:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1575">{{cpp/title| wcstol | wcstoll}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | 
long      wcstol( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl | since=c++11 |
long long wcstoll( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl end}}

Interprets an integer value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to wide character}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|LONG_MAX}}, {{lc|LONG_MIN}}, {{lc|LLONG_MAX}} or {{lc|LLONG_MIN}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcstoul}}
{{dsc see c | c/string/wide/wcstol | wcstol | wcstoll}}
{{dsc end}}

[[de:cpp/string/wide/wcstol]]
[[es:cpp/string/wide/wcstol]]
[[fr:cpp/string/wide/wcstol]]
[[it:cpp/string/wide/wcstol]]
[[ja:cpp/string/wide/wcstol]]
[[pt:cpp/string/wide/wcstol]]
[[ru:cpp/string/wide/wcstol]]
[[zh:cpp/string/wide/wcstol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstold</title>
    <ns>0</ns>
    <id>4742</id>
    <redirect title="cpp/string/wide/wcstof" />
    <revision>
      <id>17215</id>
      <timestamp>2012-01-06T18:34:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/wide/wcstof]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/wide/wcstof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcstoul</title>
    <ns>0</ns>
    <id>5129</id>
    <revision>
      <id>62965</id>
      <parentid>59138</parentid>
      <timestamp>2013-07-01T23:48:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1595">{{cpp/title| wcstoul | wcstoull}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl | 
unsigned long      wcstoul( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl | since=c++11 |
unsigned long long wcstoull( const wchar_t* str, wchar_t** str_end, int base );
}}
{{dcl end}}

Interprets an unsigned integer value in a wide string pointed to by {{tt|str}}.

{{cpp/string/cvt str2int base | base=base | u=true}}

The functions sets the pointer pointed to by {{tt|str_end}} to point to the wide character past the last character interpreted. If {{tt|str_end}} is {{lc|NULL}}, it is ignored.

===Parameters===
{{par begin}}
{{par | str | pointer to the null-terminated wide string to be interpreted}}
{{par | str_end | pointer to a pointer to a wide character.}}
{{par | base | ''base'' of the interpreted integer value}}
{{par end}}

===Return value===
Integer value corresponding to the contents of {{tt|str}} on success. If the converted value falls out of range of corresponding return type, range error occurs and {{lc|ULONG_MAX}} or {{lc|ULLONG_MAX}} is returned. If no conversion can be performed, {{c|0}} is returned.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcstol}}
{{dsc see c | c/string/wide/wcstoul | wcstoul | wcstoull}}
{{dsc end}}

[[de:cpp/string/wide/wcstoul]]
[[es:cpp/string/wide/wcstoul]]
[[fr:cpp/string/wide/wcstoul]]
[[it:cpp/string/wide/wcstoul]]
[[ja:cpp/string/wide/wcstoul]]
[[pt:cpp/string/wide/wcstoul]]
[[ru:cpp/string/wide/wcstoul]]
[[zh:cpp/string/wide/wcstoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wcsxfrm</title>
    <ns>0</ns>
    <id>3792</id>
    <revision>
      <id>59139</id>
      <parentid>51323</parentid>
      <timestamp>2013-06-01T06:27:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2716">{{cpp/title|wcsxfrm}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
std::size_t strxfrm( wchar_t* dest, const wchar_t* src, std::size_t count );
}}
{{dcl end}}

Transforms the null-terminated wide string pointed to by {{tt|src}} into the implementation-defined form such that comparing two transformed strings with {{lc|std::wcscmp}} gives the same result as comparing the original strings with {{lc|std::wcscoll}}, in the current C locale.

The first {{tt|count}} characters of the transformed string are written to destination, including the terminating null character, and the length of the full transformed string is returned, excluding the terminating null character.

If {{tt|count}} is {{c|0}}, then {{tt|dest}} is allowed to be a null pointer.

===Notes===
The correct length of the buffer that can receive the entire transformed string is {{c|1+std::wcsxfrm(NULL, src, 0)}}

===Parameters===
{{par begin}}
{{par| dest | pointer to the first element of a wide null-terminated string to write the transformed string to}}
{{par| src| pointer to the null-terminated wide character string to transform}}
{{par| count | maximum number of characters to output}}
{{par end}}

===Return value===
The length of the transformed wide string, not including the terminating null-character.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;

int main()
{
    std::setlocale(LC_ALL, &quot;sv_SE.utf8&quot;);

    std::wstring in1 = L&quot;\u00e5r&quot;;
    std::wstring out1(1+std::wcsxfrm(nullptr, in1.c_str(), 0), L' ');
    std::wstring in2 = L&quot;\u00e4ngel&quot;;
    std::wstring out2(1+std::wcsxfrm(nullptr, in2.c_str(), 0), L' ');

    std::wcsxfrm(&amp;out1[0], in1.c_str(), out1.size());
    std::wcsxfrm(&amp;out2[0], in2.c_str(), out2.size());

    std::wcout &lt;&lt; &quot;In the Swedish locale: &quot;;
    if(out1 &lt; out2)
         std::wcout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

    std::wcout &lt;&lt; &quot;In lexicographical comparison: &quot;;
    if(in1 &lt; in2)
         std::wcout &lt;&lt; in1 &lt;&lt; &quot; before &quot; &lt;&lt; in2 &lt;&lt; '\n';
    else
         std::wcout &lt;&lt; in2 &lt;&lt; &quot; before &quot; &lt;&lt; in1 &lt;&lt; '\n';

}
 | output=
In the Swedish locale: år before ängel
In lexicographical comparison: ängel before år
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/byte/dsc strxfrm}}
{{dsc inc | cpp/locale/collate/dsc do_transform}}
{{dsc inc | cpp/string/wide/dsc wcscoll}}
{{dsc see c | c/string/wide/wcsxfrm}}
{{dsc end}}

[[de:cpp/string/wide/wcsxfrm]]
[[es:cpp/string/wide/wcsxfrm]]
[[fr:cpp/string/wide/wcsxfrm]]
[[it:cpp/string/wide/wcsxfrm]]
[[ja:cpp/string/wide/wcsxfrm]]
[[pt:cpp/string/wide/wcsxfrm]]
[[ru:cpp/string/wide/wcsxfrm]]
[[zh:cpp/string/wide/wcsxfrm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wctrans</title>
    <ns>0</ns>
    <id>2971</id>
    <revision>
      <id>59142</id>
      <parentid>51324</parentid>
      <timestamp>2013-06-01T06:27:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1376">{{cpp/title|wctrans}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
std::wctrans_t wctrans( const char* str );
}}

Constructs a value of type {{c|std::wctrans_t}} that describes a LC_CTYPE category of wide character mapping. It may be one of the standard mappings, or a locale-specific mapping, such as {{tt|&quot;tojhira&quot;}} or {{tt|&quot;tojkana&quot;}}.

===Parameters===
{{par begin}}
{{par | str | C string holding the name of the desired mapping.
The following values of {{tt|str}} are supported in all C locales:
{{dsc begin}}
{{dsc hitem | Value of {{tt|str}}  | Effect  }}
{{dsc | {{tt|&quot;toupper&quot;}} | identifies the mapping used by {{c|towupper}} }}
{{dsc | {{tt|&quot;tolower&quot;}} | identifies the mapping used by {{c|towlower}} }}
{{dsc end}}
}}
{{dsc end}}

===Return value===

{{c|std::wctrans_t}} object suitable for use with {{lc|std::towctrans}} to map wide characters according to the named mapping of the current C locale or zero if {{tt|str}} does not name a mapping supported by the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc towctrans}}
{{dsc see c | c/string/wide/wctrans}}
{{dsc end}}

[[de:cpp/string/wide/wctrans]]
[[es:cpp/string/wide/wctrans]]
[[fr:cpp/string/wide/wctrans]]
[[it:cpp/string/wide/wctrans]]
[[ja:cpp/string/wide/wctrans]]
[[pt:cpp/string/wide/wctrans]]
[[ru:cpp/string/wide/wctrans]]
[[zh:cpp/string/wide/wctrans]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wctype</title>
    <ns>0</ns>
    <id>2967</id>
    <revision>
      <id>59143</id>
      <parentid>51325</parentid>
      <timestamp>2013-06-01T06:27:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2125">{{cpp/title|wctype}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwctype |
std::wctype_t wctype( const char* str );
}}

Constructs a value of type {{c|std::wctype_t}} that describes a LC_CTYPE category of wide character classification. It may be one of the standard classification categories, or a locale-specific category, such as {{tt|&quot;jkanji&quot;}}.

===Parameters===
{{par begin}}
{{par | str | C string holding the name of the desired category}}
{{par end}}

The following values of {{tt|str}} are supported in all C locales:
{{dsc begin}}
{{dsc hitem | value of {{tt|str}}  | effect  }}
{{dsc | {{tt|&quot;alnum&quot;}} | identifies the category used by {{lc|std::iswalnum}} }}
{{dsc | {{tt|&quot;alpha&quot;}} | identifies the category used by {{lc|std::iswalpha}} }}
{{dsc | {{tt|&quot;blank&quot;}} | identifies the category used by {{lc|std::iswblank}} {{mark c++11}}}}
{{dsc | {{tt|&quot;cntrl&quot;}} | identifies the category used by {{lc|std::iswcntrl}} }}
{{dsc | {{tt|&quot;digit&quot;}} | identifies the category used by {{lc|std::iswdigit}} }}
{{dsc | {{tt|&quot;graph&quot;}} | identifies the category used by {{lc|std::iswgraph}} }}
{{dsc | {{tt|&quot;lower&quot;}} | identifies the category used by {{lc|std::iswlower}} }}
{{dsc | {{tt|&quot;print&quot;}} | identifies the category used by {{lc|std::iswprint}} }}
{{dsc | {{tt|&quot;space&quot;}} | identifies the category used by {{lc|std::iswspace}} }}
{{dsc | {{tt|&quot;upper&quot;}} | identifies the category used by {{lc|std::iswupper}} }}
{{dsc | {{tt|&quot;xdigit&quot;}} | identifies the category used by {{lc|std::iswxdigit}} }}
{{dsc end}}

===Return value===
{{c|std::wctype_t}} object suitable for use with {{lc|std::iswctype}} to classify wide characters according to the named category of the current C locale or zero if {{tt|str}} does not name a category supported by the current C locale.

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc iswctype}}
{{dsc see c | c/string/wide/wctype}}
{{dsc end}}

[[de:cpp/string/wide/wctype]]
[[es:cpp/string/wide/wctype]]
[[fr:cpp/string/wide/wctype]]
[[it:cpp/string/wide/wctype]]
[[ja:cpp/string/wide/wctype]]
[[pt:cpp/string/wide/wctype]]
[[ru:cpp/string/wide/wctype]]
[[zh:cpp/string/wide/wctype]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wmemchr</title>
    <ns>0</ns>
    <id>3805</id>
    <revision>
      <id>59146</id>
      <parentid>51326</parentid>
      <timestamp>2013-06-01T06:27:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1183">{{cpp/title|wmemchr}}
{{cpp/string/wide/navbar}}
{{dcl begin}}
{{dcl header | cwchar}}
{{dcl |
const wchar_t* wmemchr( const wchar_t* ptr, wchar_t ch, std::size_t count );
}}
{{dcl | 1=
      wchar_t* wmemchr(       wchar_t* ptr, wchar_t ch, std::size_t count );
}}
{{dcl end}}

Locates the first occurrence of wide character {{tt|ch}} in the initial {{tt|count}} wide characters of the object pointed to by {{tt|ptr}}. 

===Parameters===
{{par begin}}
{{par | ptr | pointer to the object to be examined}}
{{par | ch | wide character to search for}}
{{par | count | number of characters to examine}}
{{par end}}

===Return value===
Pointer to the location of the character, or {{lc|NULL}} if no such character is found.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcschr}}
{{dsc inc | cpp/algorithm/dsc find}}
{{dsc see c | c/string/wide/wmemchr}}
{{dsc end}}

[[de:cpp/string/wide/wmemchr]]
[[es:cpp/string/wide/wmemchr]]
[[fr:cpp/string/wide/wmemchr]]
[[it:cpp/string/wide/wmemchr]]
[[ja:cpp/string/wide/wmemchr]]
[[pt:cpp/string/wide/wmemchr]]
[[ru:cpp/string/wide/wmemchr]]
[[zh:cpp/string/wide/wmemchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wmemcmp</title>
    <ns>0</ns>
    <id>3804</id>
    <revision>
      <id>59147</id>
      <parentid>51327</parentid>
      <timestamp>2013-06-01T06:27:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1103">{{cpp/title|wmemcmp}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
int wmemcmp( const wchar_t* lhs, const wchar_t* rhs, std::size_t count );
}}

Compares the first {{tt|count}} wide characters of the objects pointed to by {{tt|lhs}} and {{tt|rhs}}. The comparison is done lexicographically.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pointers to the memory buffers to compare}}
{{par | count | number of bytes to examine}}
{{par end}}

===Return value===
Negative value if {{tt|lhs}} is ''less than'' {{tt|rhs}}.

{{c|0}} if {{tt|lhs}} is ''equal to'' {{tt|rhs}}.

Positive value if {{tt|lhs}} is ''greater than'' {{tt|rhs}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wcscmp}}
{{dsc inc | cpp/string/wide/dsc wcsncmp}}
{{dsc see c | c/string/wide/wmemcmp}}
{{dsc end}}

[[de:cpp/string/wide/wmemcmp]]
[[es:cpp/string/wide/wmemcmp]]
[[fr:cpp/string/wide/wmemcmp]]
[[it:cpp/string/wide/wmemcmp]]
[[ja:cpp/string/wide/wmemcmp]]
[[pt:cpp/string/wide/wmemcmp]]
[[ru:cpp/string/wide/wmemcmp]]
[[zh:cpp/string/wide/wmemcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wmemcpy</title>
    <ns>0</ns>
    <id>3802</id>
    <revision>
      <id>59150</id>
      <parentid>51328</parentid>
      <timestamp>2013-06-01T06:27:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1233">{{cpp/title|wmemcpy}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t* wmemcpy( wchar_t* dest, const wchar_t* src, std::size_t count );
}}

Copies {{tt|count}} wide characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. If the objects overlap, the behavior is undefined. If the objects are not trivially copyable (scalars, arrays, C-compatible structs), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of wide characters to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wmemmove}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/wide/wmemcpy}}
{{dsc end}}

[[de:cpp/string/wide/wmemcpy]]
[[es:cpp/string/wide/wmemcpy]]
[[fr:cpp/string/wide/wmemcpy]]
[[it:cpp/string/wide/wmemcpy]]
[[ja:cpp/string/wide/wmemcpy]]
[[pt:cpp/string/wide/wmemcpy]]
[[ru:cpp/string/wide/wmemcpy]]
[[zh:cpp/string/wide/wmemcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wmemmove</title>
    <ns>0</ns>
    <id>3803</id>
    <revision>
      <id>59151</id>
      <parentid>51329</parentid>
      <timestamp>2013-06-01T06:27:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1353">{{cpp/title|wmemmove}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t* wmemmove( wchar_t* dest, const wchar_t* src, std::size_t count );
}}

Copies {{tt|count}} wide characters from the object pointed to by {{tt|src}} to the object pointed to by {{tt|dest}}. The objects may overlap: copying takes place as if the characters were copied to a temporary character array and then the characters were copied from the array to {{tt|dest}}. If the objects are not trivially-copyable (scalars, arrays, C-style structs), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the memory location to copy to}}
{{par | src | pointer to the memory location to copy from}}
{{par | count | number of bytes to copy}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc inc | cpp/algorithm/dsc copy}}
{{dsc inc | cpp/algorithm/dsc copy_backward}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/wide/wmemmove}}
{{dsc end}}

[[de:cpp/string/wide/wmemmove]]
[[es:cpp/string/wide/wmemmove]]
[[fr:cpp/string/wide/wmemmove]]
[[it:cpp/string/wide/wmemmove]]
[[ja:cpp/string/wide/wmemmove]]
[[pt:cpp/string/wide/wmemmove]]
[[ru:cpp/string/wide/wmemmove]]
[[zh:cpp/string/wide/wmemmove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/string/wide/wmemset</title>
    <ns>0</ns>
    <id>3806</id>
    <revision>
      <id>59154</id>
      <parentid>51330</parentid>
      <timestamp>2013-06-01T06:27:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1326">{{cpp/title|wmemset}}
{{cpp/string/wide/navbar}}
{{ddcl | header=cwchar |
wchar_t* wmemset( wchar_t* dest, wchar_t ch, std::size_t count );
}}

Copies wide character {{tt|ch}} into each of the first {{tt|count}} wide characters of the object pointed to by {{tt|dest}}. If the object is not trivially-copyable (e.g., scalar, array, or a C-compatible struct), the behavior is undefined. If {{c|dest+size+1}} points outside the object, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | dest | pointer to the object to fill}}
{{par | ch | fill byte}}
{{par | count | number of wide characters to fill}}
{{par end}}

===Return value===
{{tt|dest}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cwchar&gt;

int main()
{
    int a[20];
    std::memset(a, 0, sizeof(a));
    std::cout &lt;&lt; &quot;a[0] = &quot; &lt;&lt; a[0] &lt;&lt; '\n';
}
 | output=a[0] = 0 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/string/wide/dsc wmemcpy}}
{{dsc inc | cpp/algorithm/dsc fill_n}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc see c | c/string/wide/wmemset}}
{{dsc end}}

[[de:cpp/string/wide/wmemset]]
[[es:cpp/string/wide/wmemset]]
[[fr:cpp/string/wide/wmemset]]
[[it:cpp/string/wide/wmemset]]
[[ja:cpp/string/wide/wmemset]]
[[pt:cpp/string/wide/wmemset]]
[[ru:cpp/string/wide/wmemset]]
[[zh:cpp/string/wide/wmemset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread</title>
    <ns>0</ns>
    <id>1774</id>
    <revision>
      <id>71016</id>
      <parentid>71012</parentid>
      <timestamp>2014-06-04T18:59:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="3760">{{title|Thread support library}}
{{cpp/thread/navbar}}

C++ includes built-in support for threads, mutual exclusion, condition variables, and futures.

===Threads===

Threads enable programs to execute across several processor cores.

{{dsc begin}}
{{dsc header | thread}}
{{dsc inc | cpp/thread/dsc thread}}
{{dsc h2 | Functions managing the current thread}}
{{dsc namespace | this_thread}}
{{dsc inc | cpp/thread/dsc yield}}
{{dsc inc | cpp/thread/dsc get_id}}
{{dsc inc | cpp/thread/dsc sleep_for}}
{{dsc inc | cpp/thread/dsc sleep_until}}
{{dsc end}}

===Mutual exclusion===

Mutual exclusion algorithms prevent multiple threads from simultaneously accessing shared resources. This prevents data races and provides support for synchronization between threads.

{{dsc begin}}
{{dsc header | mutex}}
{{dsc inc | cpp/thread/dsc mutex}}
{{dsc inc | cpp/thread/dsc timed_mutex}}
{{dsc inc | cpp/thread/dsc recursive_mutex}}
{{dsc inc | cpp/thread/dsc recursive_timed_mutex}}
{{dsc header | shared_mutex}}
{{dsc inc | cpp/thread/dsc shared_timed_mutex}}

{{dsc h2 | Generic mutex management}}
{{dsc header | mutex}}
{{dsc inc | cpp/thread/dsc lock_guard}}
{{dsc inc | cpp/thread/dsc unique_lock}}
{{dsc inc | cpp/thread/dsc shared_lock}}
{{dsc inc | cpp/thread/dsc lock_tag_t}}
{{dsc inc | cpp/thread/dsc lock_tag}}

{{dsc h2 | Generic locking algorithms}}
{{dsc inc | cpp/thread/dsc try_lock}}
{{dsc inc | cpp/thread/dsc lock}}

{{dsc h2 | Call once}}
{{dsc inc | cpp/thread/dsc once_flag}}
{{dsc inc | cpp/thread/dsc call_once}}
{{dsc end}}

===Condition variables===

A condition variable is a synchronization primitive that allows multiple threads to communicate with each other.  It allows some number of threads to wait (possibly with a timeout) for notification from another thread that they may proceed. A condition variable is always associated with a mutex. 

{{dsc begin}}
{{dsc header | condition_variable}}
{{dsc class | cpp/thread/condition_variable | provides a condition variable associated with a {{lc|std::unique_lock}} | notes={{mark c++11}}}}
{{dsc class | cpp/thread/condition_variable_any | provides a condition variable associated with any lock type | notes={{mark c++11}}}}
{{dsc fun   | cpp/thread/notify_all_at_thread_exit | schedules a call to {{tt|notify_all}} to be invoked when this thread is completely finished | notes={{mark c++11}}}}
{{dsc enum | cpp/thread/cv_status | lists the possible results of timed waits on condition variables | notes={{mark c++11}}}}
{{dsc end}}

===Futures===

The standard library provides facilities to obtain values that are returned and to catch exceptions that are thrown by asynchronous tasks (i.e. functions launched in separate threads). These values are communicated in a ''shared state'', in which the asynchronous task may write its return value or store an exception, and which may be examined, waited for, and otherwise manipulated by other threads that hold instances of {{lc|std::future}} or {{lc|std::shared_future}} that reference that shared state.

{{dsc begin}}
{{dsc header | future}}
{{dsc inc | cpp/thread/dsc promise}}
{{dsc inc | cpp/thread/dsc packaged_task}}
{{dsc inc | cpp/thread/dsc future}}
{{dsc inc | cpp/thread/dsc shared_future}}
{{dsc inc | cpp/thread/dsc async}}
{{dsc inc | cpp/thread/dsc launch}}
{{dsc inc | cpp/thread/dsc future_status}}

{{dsc h2 | Future errors}}
{{dsc inc | cpp/thread/dsc future_error}}
{{dsc inc | cpp/thread/dsc future_category}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/thread | Thread support library}}
{{dsc end}}

[[ar:cpp/thread]]
[[de:cpp/thread]]
[[es:cpp/thread]]
[[fr:cpp/thread]]
[[it:cpp/thread]]
[[ja:cpp/thread]]
[[pt:cpp/thread]]
[[ru:cpp/thread]]
[[zh:cpp/thread]]</text>
      <sha1>8s65u5uroioah2dphg038qqh1spsxgn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/async</title>
    <ns>0</ns>
    <id>2516</id>
    <revision>
      <id>72132</id>
      <parentid>72129</parentid>
      <timestamp>2014-07-17T10:17:06Z</timestamp>
      <contributor>
        <username>NiXman</username>
        <id>122</id>
      </contributor>
      <comment>fix for previous changes</comment>
      <text xml:space="preserve" bytes="5490">{{cpp/title|async}}
{{cpp/thread/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | num=1 | since=c++11 |
template&lt; class Function, class... Args&gt;
std::future&lt;typename std::result_of&lt;Function(Args...)&gt;::type&gt;
    async( Function&amp;&amp; f, Args&amp;&amp;... args );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Function, class... Args &gt;
std::future&lt;typename std::result_of&lt;Function(Args...)&gt;::type&gt;
    async( std::launch policy, Function&amp;&amp; f, Args&amp;&amp;... args );
}}
{{dcl end}}

The template function {{tt|async}} runs the function {{tt|f}} asynchronously (potentially in a separate thread) and returns a {{lc|std::future}} that will eventually hold the result of that function call.

1) Behaves the same as {{c|async(std::launch::async {{!}} std::launch::deferred, f, args...)}}.  In other words, {{tt|f}} may be executed in another thread or it may be run synchronously when the resulting {{lc|std::future}} is queried for a value.

2) Calls a function {{tt|f}} with arguments {{tt|args}} according to a specific launch policy {{tt|policy}}: 

* If the ''async'' flag is set (i.e. {{c|1=policy &amp; std::launch::async != 0}}), then {{tt|async}} executes the function {{tt|f}} on a separate thread of execution as if spawned by {{c|std::thread(f, args...)}}, except that if the function {{tt|f}} returns a value or throws an exception, it is stored in the shared state accessible through the {{lc|std::future}} that {{tt|async}} returns to the caller.

* If the ''deferred'' flag is set (i.e. {{c|1=policy &amp; std::launch::deferred != 0}}), then {{tt|async}} converts {{tt|args...}} the same way as by {{lc|std::thread}} constructor, but does not spawn a new thread of execution. Instead, ''lazy evaluation'' is performed: the first call to a non-timed wait function on the {{lc|std::future}} that {{tt|async}} returned to the caller will cause {{tt|f(args...)}} to be executed in the current thread. The result or exception is placed in the shared state associated with the future and only then it is made ready. All further accesses to the same {{lc|std::future}} will return the result immediately.

* If both the {{lc|std::launch::async}} and {{lc|std::launch::deferred}} flags are set in {{tt|policy}}, it is up to the implementation whether to perform asynchronous execution or lazy evaluation.

* {{mark c++14}} If neither {{lc|std::launch::async}} nor {{lc|std::launch::deferred}}, nor any implementation-defined policy flag is set in {{tt|policy}}, the behavior is undefined.

In any case, the call to {{tt|std::async}} ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) the call to {{tt|f}}, and the completion of {{tt|f}} is ''sequenced-before'' making the shared state ready. If the {{tt|async}} policy is chosen, the associated thread completion ''synchronizes-with'' the successful return from the first function that is waiting on the shared state, or with the return of the last function that releases the shared state, whichever comes first.

===Parameters===
{{par begin}}
{{par | f | {{concept|Callable}} object to call}}
{{par | args... | parameters to pass to {{tt|f}}}}
{{par | policy | bitmask value, where individual bits control the allowed methods of execution
 {{dsc begin}}
 {{dsc hitem | Bit | Explanation}}
 {{dsc | {{lc|std::launch::async}} | enable asynchronous evaluation }}
 {{dsc | {{lc|std::launch::deferred}} | enable lazy evaluation }}
 {{dsc end}}
}}
{{par end}}

===Return value===
{{c|std::future&lt;std::result_of_t&lt;std::decay_t&lt;F&gt;(std::decay_t&lt;Args&gt;...)&gt;&gt;}} referring to the shared state created by this call to {{tt|std::async}}. 

===Exceptions===
Throws {{lc|std::system_error}} with error condition {{lc|std::errc::resource_unavailable_try_again}} if the launch policy equals {{lc|std::launch::async}} and the implementation is unable to start a new thread (if the policy is {{tt|async{{!}}deferred}} or has additional bits set, it will fall back to deferred or the implementation-defined policies in this case)

===Notes===
The implementation may extend the behavior of the first overload of {{lc|std::async}} by enabling additional (implementation-defined) bits in the default launch policy.

If the {{tt|std::future}} obtained from  {{tt|std::async}} has temporary object lifetime (not moved or bound to a variable), the destructor of the {{lc|std::future}} will block at the end of the full expression until the asynchronous operation completes, essentially code such as the following synchronous:
{{source|
std::async(std::launch::async, []{ f(); }); // temporary's dtor waits for f()
std::async(std::launch::async, []{ g(); }); // does not start until f() completes
}}

===Example===
{{example|
 | code= 
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;numeric&gt;
#include &lt;future&gt;

template &lt;typename RAIter&gt;
int parallel_sum(RAIter beg, RAIter end)
{
    auto len = std::distance(beg, end);
    if(len &lt; 1000)
        return std::accumulate(beg, end, 0);

    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum&lt;RAIter&gt;, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}

int main()
{
    std::vector&lt;int&gt; v(10000, 1);
    std::cout &lt;&lt; &quot;The sum is &quot; &lt;&lt; parallel_sum(v.begin(), v.end()) &lt;&lt; '\n';
}
 | output=
The sum is 10000
}}

[[de:cpp/thread/async]]
[[es:cpp/thread/async]]
[[fr:cpp/thread/async]]
[[it:cpp/thread/async]]
[[ja:cpp/thread/async]]
[[pt:cpp/thread/async]]
[[ru:cpp/thread/async]]
[[zh:cpp/thread/async]]</text>
      <sha1>n0pfyhcefzpq1rumpu76l5p1gcndtuc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/call once</title>
    <ns>0</ns>
    <id>2505</id>
    <revision>
      <id>70683</id>
      <parentid>70680</parentid>
      <timestamp>2014-05-28T13:19:02Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>seemed invoke data races.Undo revisions by [[Special:Contributions/汪育振|汪育振]] ([[User talk:汪育振|talk]])</comment>
      <text xml:space="preserve" bytes="3086">{{cpp/title|call_once}}
{{cpp/thread/navbar}}
{{ddcl | header=mutex | since=c++11 |
template&lt; class Callable, class... Args &gt;
void call_once( std::once_flag&amp; flag, Callable&amp;&amp; f, Args&amp;&amp;... args );
}}

Executes the {{concept|Callable}} object {{tt|f}} exactly once, even if called from several threads. 

Each group of {{tt|call_once}} invocations that receives the same {{lc|std::once_flag}} object will meet the following requirements:
 
* Exactly one execution of exactly one of the functions (passed as {{tt|f}} to the invocations in the group) is performed. It is undefined which function will be selected for execution. The selected function runs in the same thread as the {{tt|call_once}} invocation it was passed to.

* No invocation in the group returns before the abovementioned execution of the selected function is completed successfully, that is, doesn't exit via an exception.

* If the selected function exits via exception, it is propagated to the caller. Another function is then selected and executed.

===Parameters===
{{par begin}}
{{par | flag | an object, for which exactly one function gets executed }}
{{par | f | {{concept|Callable}} object to invoke}}
{{par | args... | arguments to pass to the function}}
{{par end}}

===Return value===
(none)

===Exceptions===
* {{lc|std::system_error}} if any condition prevents calls to {{tt|call_once}} from executing as specified
* any exception thrown by {{tt|f}}

===Example===
{{example|
 |code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;

std::once_flag flag;

void do_once()
{
    std::call_once(flag, [](){ std::cout &lt;&lt; &quot;Called once&quot; &lt;&lt; std::endl; });
}

int main()
{
    std::thread t1(do_once);
    std::thread t2(do_once);
    std::thread t3(do_once);
    std::thread t4(do_once);

    t1.join();
    t2.join();
    t3.join();
    t4.join();
}
 |output=
Called once
}}

===Example===
{{example|
 |p=true
 |code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;

std::once_flag flag;

inline void may_throw_function(bool do_throw)
{
  // only one instance of this function can be run simultaneously
  if (do_throw) {
    std::cout &lt;&lt; &quot;throw\n&quot;; // this message may be printed from 0 to 3 times
    // if function exits via exception, another function selected
    throw std::exception();
  }

  std::cout &lt;&lt; &quot;once\n&quot;; // printed exactly once, it's guaranteed that
      // there are no messages after it
}

inline void do_once(bool do_throw)
{
  try {
    std::call_once(flag, may_throw_function, do_throw);
  }
  catch (...) {
  }
}

int main()
{
    std::thread t1(do_once, true);
    std::thread t2(do_once, true);
    std::thread t3(do_once, false);
    std::thread t4(do_once, true);

    t1.join();
    t2.join();
    t3.join();
    t4.join();
}
 |p=true
 |output=
throw
throw
once
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc once_flag}}
{{dsc end}}

[[de:cpp/thread/call once]]
[[es:cpp/thread/call once]]
[[fr:cpp/thread/call once]]
[[it:cpp/thread/call once]]
[[ja:cpp/thread/call once]]
[[pt:cpp/thread/call once]]
[[ru:cpp/thread/call once]]
[[zh:cpp/thread/call once]]</text>
      <sha1>5cpz4891ogus2p07819jywc0yho68a0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable</title>
    <ns>0</ns>
    <id>2387</id>
    <revision>
      <id>72058</id>
      <parentid>72056</parentid>
      <timestamp>2014-07-10T20:31:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 72056 by [[Special:Contributions/Chenlailin|Chenlailin]] ([[User talk:Chenlailin|talk]]) don't pessimize</comment>
      <text xml:space="preserve" bytes="3990">{{cpp/title|condition_variable}}
{{cpp/thread/condition_variable/navbar}}
{{ddcl | header=condition_variable | since=c++11 | 1=
class condition_variable;
}}

The {{tt|condition_variable}} class is a synchronization primitive that can be used to block a thread, or multiple threads at the same time, until:

* a notification is received from another thread
* a timeout expires, or
* a [[enwiki:Spurious_wakeup|spurious wakeup]] occurs

Any thread that intends to wait on {{tt|std::condition_variable}} has to acquire a {{lc|std::unique_lock}} first. The wait operations atomically release the mutex and suspend the execution of the thread. When the condition variable is notified, the thread is awakened, and the mutex is reacquired.

Condition variables permit concurrent invocation of the {{lc|wait}}, {{lc|wait_for}}, {{lc|wait_until}}, {{lc|notify_one}} and {{lc|notify_all}} member functions.

The class {{tt|std::condition_variable}} is a {{concept|StandardLayoutType}}. It is not {{concept|CopyConstructible}}, {{concept|MoveConstructible}}, {{concept|CopyAssignable}}, {{concept|MoveAssignable}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc constructor | condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc destructor | condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc operator{{=}} | condition_variable}}

{{dsc h2 | Notification}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_one | condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_all | condition_variable}}

{{dsc h2 | Waiting}}
{{dsc inc | cpp/thread/condition_variable/dsc wait | condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for | condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until | condition_variable}}

{{dsc h2 | Native handle}}
{{dsc inc | cpp/thread/condition_variable/dsc native handle | condition_variable}}
{{dsc end}}

===Example===
{{example| {{tt|condition_variable}} is typically used in combination with a {{lc|std::mutex}} to facilitate inter-thread communication
|code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;
#include &lt;condition_variable&gt;

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;

void worker_thread()
{
    // Wait until main() sends data
    std::unique_lock&lt;std::mutex&gt; lk(m);
    cv.wait(lk, []{return ready;});

    //after the wait, we own the lock.
    std::cout &lt;&lt; &quot;Worker thread is processing data\n&quot;;
    data += &quot; after processing&quot;;

    // Send data back to main()
    processed = true;
    std::cout &lt;&lt; &quot;Worker thread signals data processing completed\n&quot;;
    
    // Manual unlocking is done before notifying, to avoid
    // that the waiting thread gets blocked again.
    lk.unlock();
    cv.notify_one();
}

int main()
{
    std::thread worker(worker_thread);

    data = &quot;Example data&quot;;
    // send data to the worker thread
    {
        std::lock_guard&lt;std::mutex&gt; lk(m);
        ready = true;
        std::cout &lt;&lt; &quot;main() signals data ready for processing\n&quot;;
    }
    cv.notify_one();

    // wait for the worker
    {
        std::unique_lock&lt;std::mutex&gt; lk(m);
        cv.wait(lk, []{return processed;});
    }
    std::cout &lt;&lt; &quot;Back in main(), data = &quot; &lt;&lt; data &lt;&lt; '\n';

    worker.join();
}
| output=
main() signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in main(), data = Example data after processing
}}

[[de:cpp/thread/condition variable]]
[[es:cpp/thread/condition variable]]
[[fr:cpp/thread/condition variable]]
[[it:cpp/thread/condition variable]]
[[ja:cpp/thread/condition variable]]
[[pt:cpp/thread/condition variable]]
[[ru:cpp/thread/condition variable]]
[[zh:cpp/thread/condition variable]]</text>
      <sha1>3x4wuqk07z203mk12s0wzns4l3bnle7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/condition variable</title>
    <ns>0</ns>
    <id>5024</id>
    <revision>
      <id>51335</id>
      <parentid>43989</parentid>
      <timestamp>2013-06-01T03:59:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="526">{{include page|cpp/thread/condition_variable/constructor|condition_variable}}

[[de:cpp/thread/condition variable/condition variable]]
[[es:cpp/thread/condition variable/condition variable]]
[[fr:cpp/thread/condition variable/condition variable]]
[[it:cpp/thread/condition variable/condition variable]]
[[ja:cpp/thread/condition variable/condition variable]]
[[pt:cpp/thread/condition variable/condition variable]]
[[ru:cpp/thread/condition variable/condition variable]]
[[zh:cpp/thread/condition variable/condition variable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/native handle</title>
    <ns>0</ns>
    <id>5030</id>
    <revision>
      <id>51336</id>
      <parentid>43982</parentid>
      <timestamp>2013-06-01T03:59:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="488">{{include page|cpp/thread/condition_variable/native_handle|condition_variable}}

[[de:cpp/thread/condition variable/native handle]]
[[es:cpp/thread/condition variable/native handle]]
[[fr:cpp/thread/condition variable/native handle]]
[[it:cpp/thread/condition variable/native handle]]
[[ja:cpp/thread/condition variable/native handle]]
[[pt:cpp/thread/condition variable/native handle]]
[[ru:cpp/thread/condition variable/native handle]]
[[zh:cpp/thread/condition variable/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/notify all</title>
    <ns>0</ns>
    <id>5027</id>
    <revision>
      <id>51337</id>
      <parentid>43976</parentid>
      <timestamp>2013-06-01T03:59:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="461">{{include page|cpp/thread/condition_variable/notify_all|condition_variable}}

[[de:cpp/thread/condition variable/notify all]]
[[es:cpp/thread/condition variable/notify all]]
[[fr:cpp/thread/condition variable/notify all]]
[[it:cpp/thread/condition variable/notify all]]
[[ja:cpp/thread/condition variable/notify all]]
[[pt:cpp/thread/condition variable/notify all]]
[[ru:cpp/thread/condition variable/notify all]]
[[zh:cpp/thread/condition variable/notify all]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/notify one</title>
    <ns>0</ns>
    <id>5026</id>
    <revision>
      <id>51338</id>
      <parentid>43971</parentid>
      <timestamp>2013-06-01T03:59:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="461">{{include page|cpp/thread/condition_variable/notify_one|condition_variable}}

[[de:cpp/thread/condition variable/notify one]]
[[es:cpp/thread/condition variable/notify one]]
[[fr:cpp/thread/condition variable/notify one]]
[[it:cpp/thread/condition variable/notify one]]
[[ja:cpp/thread/condition variable/notify one]]
[[pt:cpp/thread/condition variable/notify one]]
[[ru:cpp/thread/condition variable/notify one]]
[[zh:cpp/thread/condition variable/notify one]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/wait</title>
    <ns>0</ns>
    <id>5029</id>
    <revision>
      <id>51339</id>
      <parentid>43965</parentid>
      <timestamp>2013-06-01T03:59:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="407">{{include page|cpp/thread/condition_variable/wait|condition_variable}}

[[de:cpp/thread/condition variable/wait]]
[[es:cpp/thread/condition variable/wait]]
[[fr:cpp/thread/condition variable/wait]]
[[it:cpp/thread/condition variable/wait]]
[[ja:cpp/thread/condition variable/wait]]
[[pt:cpp/thread/condition variable/wait]]
[[ru:cpp/thread/condition variable/wait]]
[[zh:cpp/thread/condition variable/wait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/wait for</title>
    <ns>0</ns>
    <id>5062</id>
    <revision>
      <id>51340</id>
      <parentid>43959</parentid>
      <timestamp>2013-06-01T03:59:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="443">{{include page|cpp/thread/condition_variable/wait_for|condition_variable}}

[[de:cpp/thread/condition variable/wait for]]
[[es:cpp/thread/condition variable/wait for]]
[[fr:cpp/thread/condition variable/wait for]]
[[it:cpp/thread/condition variable/wait for]]
[[ja:cpp/thread/condition variable/wait for]]
[[pt:cpp/thread/condition variable/wait for]]
[[ru:cpp/thread/condition variable/wait for]]
[[zh:cpp/thread/condition variable/wait for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/wait until</title>
    <ns>0</ns>
    <id>5071</id>
    <revision>
      <id>51341</id>
      <parentid>43953</parentid>
      <timestamp>2013-06-01T03:59:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="461">{{include page|cpp/thread/condition_variable/wait_until|condition_variable}}

[[de:cpp/thread/condition variable/wait until]]
[[es:cpp/thread/condition variable/wait until]]
[[fr:cpp/thread/condition variable/wait until]]
[[it:cpp/thread/condition variable/wait until]]
[[ja:cpp/thread/condition variable/wait until]]
[[pt:cpp/thread/condition variable/wait until]]
[[ru:cpp/thread/condition variable/wait until]]
[[zh:cpp/thread/condition variable/wait until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable/~condition variable</title>
    <ns>0</ns>
    <id>5025</id>
    <revision>
      <id>51342</id>
      <parentid>43947</parentid>
      <timestamp>2013-06-01T03:59:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="533">{{include page|cpp/thread/condition_variable/destructor|condition_variable}}

[[de:cpp/thread/condition variable/~condition variable]]
[[es:cpp/thread/condition variable/~condition variable]]
[[fr:cpp/thread/condition variable/~condition variable]]
[[it:cpp/thread/condition variable/~condition variable]]
[[ja:cpp/thread/condition variable/~condition variable]]
[[pt:cpp/thread/condition variable/~condition variable]]
[[ru:cpp/thread/condition variable/~condition variable]]
[[zh:cpp/thread/condition variable/~condition variable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any</title>
    <ns>0</ns>
    <id>2388</id>
    <revision>
      <id>63436</id>
      <parentid>61930</parentid>
      <timestamp>2013-07-10T01:32:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3057">{{cpp/title|condition_variable_any}}
{{cpp/thread/condition_variable_any/navbar}}
{{ddcl | header=condition_variable | since=c++11 | 1=
class condition_variable_any;
}}

The {{tt|condition_variable_any}} class is a generalization of {{lc|std::condition_variable}}.  Whereas {{lc|std::condition_variable}} works only on {{c|std::unique_lock&lt;std::mutex&gt;}}, {{tt|condition_variable_any}} can operate on any user-defined lock that meets the {{concept|BasicLockable}} requirements.

{{tt|condition_variable_any}} provides similar functionality to {{lc|std::condition_variable}}. It is a synchronization primitive that can be used to block some number of threads until:

* a notification is received from another thread
* a timeout expires, or
* a [[enwiki:Spurious_wakeup|spurious wakeup]] occurs

Any thread that intends to wait on {{tt|std::condition_variable_any}} has to acquire a lock first. The wait operations atomically release the lock and suspend the execution of the thread. When the condition variable is notified, the thread is awakened, and the lock is reacquired.

The class {{tt|std::condition_variable_any}} is a standard-layout class. It is not copy-constructible, move-constructible, copy-assignable, or move-assignable.

If the lock is {{lc|std::unique_lock}}, {{lc|std::condition_variable}} may provide better performance.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc constructor | condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc destructor | condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc operator{{=}} | condition_variable_any}}

{{dsc h2 | Notification}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_one | condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_all | condition_variable_any}}

{{dsc h2 | Waiting}}
{{dsc inc | cpp/thread/condition_variable/dsc wait | condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for | condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until | condition_variable_any}}
{{dsc end}}

===Notes===
A possible use for {{tt|std::condition_variable_any}} with custom {{concept|Lockable}} types is to provide convenient interruptible waits: the custom lock operation would both lock the associated mutex as expected, and also perform the necessary setup to notify this condition variable when the interrupting signal is received.&lt;ref&gt;A. Williams (2012), &quot;C++ concurrency in action&quot; 9.2.4 Interupting a wait on std::condition_variable_any&lt;/ref&gt; &lt;!-- would be nice to come up with an example that's not as big as in the book, or maybe come up with some other plausible use case --&gt;

===References===
&lt;references/&gt;

[[de:cpp/thread/condition variable any]]
[[es:cpp/thread/condition variable any]]
[[fr:cpp/thread/condition variable any]]
[[it:cpp/thread/condition variable any]]
[[ja:cpp/thread/condition variable any]]
[[pt:cpp/thread/condition variable any]]
[[ru:cpp/thread/condition variable any]]
[[zh:cpp/thread/condition variable any]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/condition variable any</title>
    <ns>0</ns>
    <id>5110</id>
    <revision>
      <id>51344</id>
      <parentid>43933</parentid>
      <timestamp>2013-06-01T03:59:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="594">{{include page|cpp/thread/condition_variable/constructor|condition_variable_any}}

[[de:cpp/thread/condition variable any/condition variable any]]
[[es:cpp/thread/condition variable any/condition variable any]]
[[fr:cpp/thread/condition variable any/condition variable any]]
[[it:cpp/thread/condition variable any/condition variable any]]
[[ja:cpp/thread/condition variable any/condition variable any]]
[[pt:cpp/thread/condition variable any/condition variable any]]
[[ru:cpp/thread/condition variable any/condition variable any]]
[[zh:cpp/thread/condition variable any/condition variable any]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/native handle</title>
    <ns>0</ns>
    <id>5124</id>
    <revision>
      <id>51345</id>
      <parentid>43927</parentid>
      <timestamp>2013-06-01T03:59:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="524">{{include page|cpp/thread/condition_variable/native_handle|condition_variable_any}}

[[de:cpp/thread/condition variable any/native handle]]
[[es:cpp/thread/condition variable any/native handle]]
[[fr:cpp/thread/condition variable any/native handle]]
[[it:cpp/thread/condition variable any/native handle]]
[[ja:cpp/thread/condition variable any/native handle]]
[[pt:cpp/thread/condition variable any/native handle]]
[[ru:cpp/thread/condition variable any/native handle]]
[[zh:cpp/thread/condition variable any/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/notify all</title>
    <ns>0</ns>
    <id>5116</id>
    <revision>
      <id>51346</id>
      <parentid>43921</parentid>
      <timestamp>2013-06-01T03:59:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="497">{{include page|cpp/thread/condition_variable/notify_all|condition_variable_any}}

[[de:cpp/thread/condition variable any/notify all]]
[[es:cpp/thread/condition variable any/notify all]]
[[fr:cpp/thread/condition variable any/notify all]]
[[it:cpp/thread/condition variable any/notify all]]
[[ja:cpp/thread/condition variable any/notify all]]
[[pt:cpp/thread/condition variable any/notify all]]
[[ru:cpp/thread/condition variable any/notify all]]
[[zh:cpp/thread/condition variable any/notify all]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/notify one</title>
    <ns>0</ns>
    <id>5114</id>
    <revision>
      <id>51347</id>
      <parentid>43915</parentid>
      <timestamp>2013-06-01T03:59:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="497">{{include page|cpp/thread/condition_variable/notify_one|condition_variable_any}}

[[de:cpp/thread/condition variable any/notify one]]
[[es:cpp/thread/condition variable any/notify one]]
[[fr:cpp/thread/condition variable any/notify one]]
[[it:cpp/thread/condition variable any/notify one]]
[[ja:cpp/thread/condition variable any/notify one]]
[[pt:cpp/thread/condition variable any/notify one]]
[[ru:cpp/thread/condition variable any/notify one]]
[[zh:cpp/thread/condition variable any/notify one]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/wait</title>
    <ns>0</ns>
    <id>5118</id>
    <revision>
      <id>51348</id>
      <parentid>43908</parentid>
      <timestamp>2013-06-01T03:59:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="443">{{include page|cpp/thread/condition_variable/wait|condition_variable_any}}

[[de:cpp/thread/condition variable any/wait]]
[[es:cpp/thread/condition variable any/wait]]
[[fr:cpp/thread/condition variable any/wait]]
[[it:cpp/thread/condition variable any/wait]]
[[ja:cpp/thread/condition variable any/wait]]
[[pt:cpp/thread/condition variable any/wait]]
[[ru:cpp/thread/condition variable any/wait]]
[[zh:cpp/thread/condition variable any/wait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/wait for</title>
    <ns>0</ns>
    <id>5120</id>
    <revision>
      <id>51349</id>
      <parentid>43902</parentid>
      <timestamp>2013-06-01T04:00:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="479">{{include page|cpp/thread/condition_variable/wait_for|condition_variable_any}}

[[de:cpp/thread/condition variable any/wait for]]
[[es:cpp/thread/condition variable any/wait for]]
[[fr:cpp/thread/condition variable any/wait for]]
[[it:cpp/thread/condition variable any/wait for]]
[[ja:cpp/thread/condition variable any/wait for]]
[[pt:cpp/thread/condition variable any/wait for]]
[[ru:cpp/thread/condition variable any/wait for]]
[[zh:cpp/thread/condition variable any/wait for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/wait until</title>
    <ns>0</ns>
    <id>5122</id>
    <revision>
      <id>51350</id>
      <parentid>43896</parentid>
      <timestamp>2013-06-01T04:00:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="497">{{include page|cpp/thread/condition_variable/wait_until|condition_variable_any}}

[[de:cpp/thread/condition variable any/wait until]]
[[es:cpp/thread/condition variable any/wait until]]
[[fr:cpp/thread/condition variable any/wait until]]
[[it:cpp/thread/condition variable any/wait until]]
[[ja:cpp/thread/condition variable any/wait until]]
[[pt:cpp/thread/condition variable any/wait until]]
[[ru:cpp/thread/condition variable any/wait until]]
[[zh:cpp/thread/condition variable any/wait until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/condition variable any/~condition variable any</title>
    <ns>0</ns>
    <id>5112</id>
    <revision>
      <id>51351</id>
      <parentid>43891</parentid>
      <timestamp>2013-06-01T04:00:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="601">{{include page|cpp/thread/condition_variable/destructor|condition_variable_any}}

[[de:cpp/thread/condition variable any/~condition variable any]]
[[es:cpp/thread/condition variable any/~condition variable any]]
[[fr:cpp/thread/condition variable any/~condition variable any]]
[[it:cpp/thread/condition variable any/~condition variable any]]
[[ja:cpp/thread/condition variable any/~condition variable any]]
[[pt:cpp/thread/condition variable any/~condition variable any]]
[[ru:cpp/thread/condition variable any/~condition variable any]]
[[zh:cpp/thread/condition variable any/~condition variable any]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/cv status</title>
    <ns>0</ns>
    <id>5126</id>
    <revision>
      <id>62967</id>
      <parentid>59163</parentid>
      <timestamp>2013-07-01T23:48:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1310">{{cpp/title|cv_status}}
{{cpp/thread/navbar}}
{{dcl begin}}
{{dcl header | condition_variable}}
{{dcl | since=c++11 | 1=
enum class cv_status;
}}
{{dcl end}}

The scoped enumeration {{tt|std::cv_status}} describes whether a timed wait returned because of timeout or not.

{{tt|std::cv_status}} is used by the {{tt|wait_for}} and {{tt|wait_until}} methods of {{lc|std::condition_variable}} and {{lc|std::condition_variable_any}}.

===Member constants===
{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|no_timeout}} | the condition variable was awakened with {{tt|notify_all}}, {{tt|notify_one}}, or spuriously }}
{{dsc | {{tt|timeout}} | the condition variable was awakened by timeout expiration }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for|condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for|condition_variable_any}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until|condition_variable}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until|condition_variable_any}}
{{dsc end}}

[[de:cpp/thread/cv status]]
[[es:cpp/thread/cv status]]
[[fr:cpp/thread/cv status]]
[[it:cpp/thread/cv status]]
[[ja:cpp/thread/cv status]]
[[pt:cpp/thread/cv status]]
[[ru:cpp/thread/cv status]]
[[zh:cpp/thread/cv status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/cv status/no timeout</title>
    <ns>0</ns>
    <id>12874</id>
    <redirect title="cpp/thread/cv status" />
    <revision>
      <id>64064</id>
      <timestamp>2013-08-07T22:42:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>6 redlinks</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/thread/cv status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/cv status/timeout</title>
    <ns>0</ns>
    <id>12873</id>
    <redirect title="cpp/thread/cv status" />
    <revision>
      <id>64063</id>
      <timestamp>2013-08-07T22:42:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>6 redlinks</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/thread/cv status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future</title>
    <ns>0</ns>
    <id>2518</id>
    <revision>
      <id>66686</id>
      <parentid>66685</parentid>
      <timestamp>2013-12-25T03:46:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>undo removal of example output</comment>
      <text xml:space="preserve" bytes="3043">{{cpp/title|future}}
{{cpp/thread/future/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; class future;
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; class future&lt;T&amp;&gt;;
}}
{{dcl | num=3 | since=c++11 |
template&lt;&gt;          class future&lt;void&gt;;
}}
{{dcl end}}

The class template {{tt|std::future}} provides a mechanism to access the result of asynchronous operations:

* An asynchronous operation (created via {{lc|std::async}}, {{lc|std::packaged_task}}, or {{lc|std::promise}}) can provide a {{tt|std::future}} object to the creator of that asynchronous operation.

* The creator of the asynchronous operation can then use a variety of methods to query, wait for, or extract a value from the {{tt|std::future}}.  These methods may block if the asynchronous operation has not yet provided a value.

* When the asynchronous operation is ready to send a result to the creator, it can do so by modifying ''shared state'' (e.g. [[cpp/thread/promise/set_value|{{c|std::promise::set_value}}]]) that is linked to the creator's  {{tt|std::future}}.

Note that {{tt|std::future}} references shared state that is not shared with any other asynchronous return objects (as opposed to {{lc|std::shared_future}}). 

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc constructor}}
{{dsc inc | cpp/thread/future/dsc destructor}}
{{dsc inc | cpp/thread/future/dsc operator{{=}}}}
{{dsc inc | cpp/thread/future/dsc share}}

{{dsc h2 | Getting the result}}
{{dsc inc | cpp/thread/future/dsc get | future}}

{{dsc h2 | State}}
{{dsc inc | cpp/thread/future/dsc valid | future}}
{{dsc inc | cpp/thread/future/dsc wait | future}}
{{dsc inc | cpp/thread/future/dsc wait_for | future}}
{{dsc inc | cpp/thread/future/dsc wait_until | future}}
{{dsc end}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;future&gt;
#include &lt;thread&gt;

int main()
{
    // future from a packaged_task
    std::packaged_task&lt;int()&gt; task([](){ return 7; }); // wrap the function
    std::future&lt;int&gt; f1 = task.get_future();  // get a future
    std::thread(std::move(task)).detach(); // launch on a thread

    // future from an async()
    std::future&lt;int&gt; f2 = std::async(std::launch::async, [](){ return 8; });

    // future from a promise
    std::promise&lt;int&gt; p;
    std::future&lt;int&gt; f3 = p.get_future();
    std::thread( [](std::promise&lt;int&gt; p){ p.set_value_at_thread_exit(9); }, 
                 std::move(p) ).detach();

    std::cout &lt;&lt; &quot;Waiting...&quot; &lt;&lt; std::flush;
    f1.wait();
    f2.wait();
    f3.wait();
    std::cout &lt;&lt; &quot;Done!\nResults are: &quot;
              &lt;&lt; f1.get() &lt;&lt; ' ' &lt;&lt; f2.get() &lt;&lt; ' ' &lt;&lt; f3.get() &lt;&lt; '\n';
}
| output=
Waiting...Done!
Results are: 7 8 9
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc async}}
{{dsc inc | cpp/thread/dsc shared_future}}
{{dsc end}}

[[de:cpp/thread/future]]
[[es:cpp/thread/future]]
[[fr:cpp/thread/future]]
[[it:cpp/thread/future]]
[[ja:cpp/thread/future]]
[[pt:cpp/thread/future]]
[[ru:cpp/thread/future]]
[[zh:cpp/thread/future]]</text>
      <sha1>1nwcrbkkydjd8ksj8oue87kk2rrg4tx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/future</title>
    <ns>0</ns>
    <id>6452</id>
    <revision>
      <id>62969</id>
      <parentid>51354</parentid>
      <timestamp>2013-07-01T23:48:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1115">{{cpp/thread/future/title|future}}
{{cpp/thread/future/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
future();
}}
{{dcl | num=2 | since=c++11 |
future( future&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 |
future( const future&amp; other ) {{=}} delete;
}}
{{dcl end}}

Constructs a {{tt|std::future}} object.

@1@ Default constructor. Constructs a {{tt|std::future}} with no shared state.  After construction, [[cpp/thread/future/valid|{{c|valid()}}]] {{c|{{==}} false}}.

@2@ Move constructor. Constructs a {{tt|std::future}} with the shared state of {{tt|other}} using move semantics. After construction, {{c|other.valid() {{==}} false}}.

@3@ {{tt|std::future}} is not {{concept|CopyConstructible}}.

===Parameters===
{{par begin}}
{{par | other | another {{tt|std::future}} to acquire shared state from}}
{{par end}}

===Exceptions===
@1-2@ {{noexcept}}

[[de:cpp/thread/future/future]]
[[es:cpp/thread/future/future]]
[[fr:cpp/thread/future/future]]
[[it:cpp/thread/future/future]]
[[ja:cpp/thread/future/future]]
[[pt:cpp/thread/future/future]]
[[ru:cpp/thread/future/future]]
[[zh:cpp/thread/future/future]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/future category</title>
    <ns>0</ns>
    <id>8909</id>
    <revision>
      <id>63437</id>
      <parentid>59167</parentid>
      <timestamp>2013-07-10T01:32:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1145">{{cpp/title|future_category}}
{{cpp/thread/future/navbar}}
{{ddcl | header=future | since=c++11 |
const std::error_category&amp; future_category();
}}

Obtains a reference to the static error category object for future object errors. The object is required to override the virtual function {{c|error_category::name()}} to return a pointer to the string {{c|&quot;future&quot;}}. It is used to identify error codes provided in the exceptions of type {{lc|std::future_error}}.

===Parameters===
(none)

===Return value===
A reference to the static object of unspecified runtime type, derived from {{lc|std::error_category}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc future_error}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc end}}

[[de:cpp/thread/future/future category]]
[[es:cpp/thread/future/future category]]
[[fr:cpp/thread/future/future category]]
[[it:cpp/thread/future/future category]]
[[ja:cpp/thread/future/future category]]
[[pt:cpp/thread/future/future category]]
[[ru:cpp/thread/future/future category]]
[[zh:cpp/thread/future/future category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/get</title>
    <ns>0</ns>
    <id>5032</id>
    <revision>
      <id>51356</id>
      <parentid>43862</parentid>
      <timestamp>2013-06-01T04:00:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="278">{{include page|cpp/thread/future/get|future}}

[[de:cpp/thread/future/get]]
[[es:cpp/thread/future/get]]
[[fr:cpp/thread/future/get]]
[[it:cpp/thread/future/get]]
[[ja:cpp/thread/future/get]]
[[pt:cpp/thread/future/get]]
[[ru:cpp/thread/future/get]]
[[zh:cpp/thread/future/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/operator=</title>
    <ns>0</ns>
    <id>8680</id>
    <revision>
      <id>62970</id>
      <parentid>51357</parentid>
      <timestamp>2013-07-01T23:48:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1103">{{cpp/thread/future/title | operator{{=}}}}
{{cpp/thread/future/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
future&amp; operator=( future&amp;&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
future&amp; operator=( const future&amp; other ) = delete;
}}
{{dcl end}}

Assigns the contents of another future object.

1) Releases any shared state and move-assigns the contents of {{tt|other}} to {{c|*this}}. After the assignment, {{c|other.valid() {{==}} false}} and [[cpp/thread/future/valid|{{c|this-&gt;valid()}}]] will yield the same value as {{c|other.valid()}} before the assignment.

2) {{lc|std::future}} is not {{concept|CopyAssignable}}.

===Parameters===
{{par begin}}
{{par | other | a {{tt|std::future}} that will transfer state to {{c|*this}} }}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

[[de:cpp/thread/future/operator=]]
[[es:cpp/thread/future/operator=]]
[[fr:cpp/thread/future/operator=]]
[[it:cpp/thread/future/operator=]]
[[ja:cpp/thread/future/operator=]]
[[pt:cpp/thread/future/operator=]]
[[ru:cpp/thread/future/operator=]]
[[zh:cpp/thread/future/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/share</title>
    <ns>0</ns>
    <id>8681</id>
    <revision>
      <id>59170</id>
      <parentid>51358</parentid>
      <timestamp>2013-06-01T06:28:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1363">{{cpp/thread/future/title | share}}
{{cpp/thread/future/navbar}}
{{ddcl | note={{mark since c++11}} |
std::shared_future&lt;T&gt; share();
}}

Transfers the shared state of {{c|*this}} to a {{lc|std::shared_future}} object.  Multiple {{lc|std::shared_future}} objects may reference the same shared state, which is not possible with {{lc|std::future}}.

After calling {{tt|share}} on a {{lc|std::future}}, [[cpp/thread/future/valid|{{c|valid()}}]] {{c| {{==}} false}}.

The behavior is undefined if [[cpp/thread/future/valid|{{c|valid()}}]]{{c| {{==}} false}} before the call to this function.

===Parameters===
(none)

===Return value===
A {{lc|std::shared_future}} object containing the shared state previously held by {{c|*this}}

===Notes===
The implementations are encouraged to detect the case when {{c|valid {{==}} false}} before the call and throw a [[cpp/thread/future_error|{{c|future_error}}]] with an error condition of [[cpp/thread/future_errc|{{c|future_errc::no_state}}]].

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc shared_future}}
{{dsc end}}

[[de:cpp/thread/future/share]]
[[es:cpp/thread/future/share]]
[[fr:cpp/thread/future/share]]
[[it:cpp/thread/future/share]]
[[ja:cpp/thread/future/share]]
[[pt:cpp/thread/future/share]]
[[ru:cpp/thread/future/share]]
[[zh:cpp/thread/future/share]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/valid</title>
    <ns>0</ns>
    <id>5042</id>
    <revision>
      <id>51359</id>
      <parentid>43843</parentid>
      <timestamp>2013-06-01T04:00:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="296">{{include page|cpp/thread/future/valid|future}}

[[de:cpp/thread/future/valid]]
[[es:cpp/thread/future/valid]]
[[fr:cpp/thread/future/valid]]
[[it:cpp/thread/future/valid]]
[[ja:cpp/thread/future/valid]]
[[pt:cpp/thread/future/valid]]
[[ru:cpp/thread/future/valid]]
[[zh:cpp/thread/future/valid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/wait</title>
    <ns>0</ns>
    <id>5043</id>
    <revision>
      <id>51360</id>
      <parentid>43836</parentid>
      <timestamp>2013-06-01T04:00:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="287">{{include page|cpp/thread/future/wait|future}}

[[de:cpp/thread/future/wait]]
[[es:cpp/thread/future/wait]]
[[fr:cpp/thread/future/wait]]
[[it:cpp/thread/future/wait]]
[[ja:cpp/thread/future/wait]]
[[pt:cpp/thread/future/wait]]
[[ru:cpp/thread/future/wait]]
[[zh:cpp/thread/future/wait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/wait for</title>
    <ns>0</ns>
    <id>5046</id>
    <revision>
      <id>51361</id>
      <parentid>43830</parentid>
      <timestamp>2013-06-01T04:00:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="323">{{include page|cpp/thread/future/wait_for|future}}

[[de:cpp/thread/future/wait for]]
[[es:cpp/thread/future/wait for]]
[[fr:cpp/thread/future/wait for]]
[[it:cpp/thread/future/wait for]]
[[ja:cpp/thread/future/wait for]]
[[pt:cpp/thread/future/wait for]]
[[ru:cpp/thread/future/wait for]]
[[zh:cpp/thread/future/wait for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/wait until</title>
    <ns>0</ns>
    <id>5044</id>
    <revision>
      <id>51362</id>
      <parentid>43825</parentid>
      <timestamp>2013-06-01T04:00:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="341">{{include page|cpp/thread/future/wait_until|future}}

[[de:cpp/thread/future/wait until]]
[[es:cpp/thread/future/wait until]]
[[fr:cpp/thread/future/wait until]]
[[it:cpp/thread/future/wait until]]
[[ja:cpp/thread/future/wait until]]
[[pt:cpp/thread/future/wait until]]
[[ru:cpp/thread/future/wait until]]
[[zh:cpp/thread/future/wait until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future/~future</title>
    <ns>0</ns>
    <id>6453</id>
    <revision>
      <id>72333</id>
      <parentid>63438</parentid>
      <timestamp>2014-08-12T11:48:30Z</timestamp>
      <contributor>
        <username>Bear</username>
        <id>408</id>
      </contributor>
      <comment>From the standard.</comment>
      <text xml:space="preserve" bytes="873">{{cpp/thread/future/title | ~future}}
{{cpp/thread/future/navbar}}
{{ddcl | since=c++11 |
~future();
}}

Releases any shared state. This means
* if the return object or provider holds the last reference to its shared state, the shared state is destroyed; and
* the return object or provider gives up its reference to its shared state; and
* these actions will not block for the shared state to become ready, except that it may block if all of the following are true: the shared state was created by a call to std::async, the shared state is not yet ready, and this was the last reference to the shared state.

[[de:cpp/thread/future/~future]]
[[es:cpp/thread/future/~future]]
[[fr:cpp/thread/future/~future]]
[[it:cpp/thread/future/~future]]
[[ja:cpp/thread/future/~future]]
[[pt:cpp/thread/future/~future]]
[[ru:cpp/thread/future/~future]]
[[zh:cpp/thread/future/~future]]</text>
      <sha1>80o9szw1hp52r79g93spc6xujxwqoca</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future category</title>
    <ns>0</ns>
    <id>8546</id>
    <revision>
      <id>63439</id>
      <parentid>61336</parentid>
      <timestamp>2013-07-10T01:32:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1147">{{cpp/title|future_category}}
{{cpp/thread/navbar}}
{{ddcl | header=future | since=c++11 |
const std::error_category&amp; future_category();
}}

Obtains a reference to the static error category object for the errors related to futures and promises. The object is required to override the virtual function {{c|error_category::name()}} to return a pointer to the string {{c|&quot;future&quot;}}. It is used to identify error codes provided in the exceptions of type {{lc|std::future_error}}.

===Parameters===
(none)

===Return value===
A reference to the static object of unspecified runtime type, derived from {{lc|std::error_category}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc inc | cpp/thread/dsc future_error}}
{{dsc inc | cpp/error/dsc error_category}}
{{dsc end}}

[[de:cpp/thread/future category]]
[[es:cpp/thread/future category]]
[[fr:cpp/thread/future category]]
[[it:cpp/thread/future category]]
[[ja:cpp/thread/future category]]
[[pt:cpp/thread/future category]]
[[ru:cpp/thread/future category]]
[[zh:cpp/thread/future category]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future errc</title>
    <ns>0</ns>
    <id>8543</id>
    <revision>
      <id>68884</id>
      <parentid>65804</parentid>
      <timestamp>2014-03-22T21:34:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>distinct non-zero was a c++14 line</comment>
      <text xml:space="preserve" bytes="2362">{{cpp/title|future_errc}}
{{cpp/thread/future_errc/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | since=c++11 | 1=
enum class future_errc {
    broken_promise             = /* implementation-defined */,
    future_already_retrieved   = /* implementation-defined */,
    promise_already_satisfied  = /* implementation-defined */,
    no_state                   = /* implementation-defined */
};
}}
{{dcl end}}

The scoped enumeration {{tt|std::future_errc}} defines the error codes reported by {{lc|std::future}} and related classes in {{lc|std::future_error}} exception objects. Only four error codes are required, although the implementation may define additional error codes. Because the appropriate specialization of {{lc|std::is_error_code_enum}} is provided, values of type {{tt|std::future_errc}} are implicitly convertible to {{lc|std::error_code}}. 

{{rev begin}}
{{rev|since=c++14|
All error codes are distinct and non-zero.}}
{{rev end}}

===Member constants===
{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|broken_promise}} |  the asynchronous task abandoned its shared state }}
{{dsc | {{tt|future_already_retrieved}} | the contents of shared state were already accessed through {{lc|std::future}} }}
{{dsc | {{tt|promise_already_satisfied}} |  attempt to store a value in the shared state twice }}
{{dsc | {{tt|no_state}} | attempt to access {{lc|std::promise}} or {{lc|std::future}} without an associated shared state }}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/future_errc/dsc make_error_code}}
{{dsc inc | cpp/thread/future_errc/dsc make_error_condition}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/thread/future_errc/dsc is_error_code_enum}}
{{dsc end}}

===Notes===
In C++11, {{tt|broken_promise}} was specified to equal zero despite {{lc|std::error_code}}/{{lc|std::error_condition}} using zero to mean &quot;no error&quot;. This was fixed in C++14.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc end}}

[[de:cpp/thread/future errc]]
[[es:cpp/thread/future errc]]
[[fr:cpp/thread/future errc]]
[[it:cpp/thread/future errc]]
[[ja:cpp/thread/future errc]]
[[pt:cpp/thread/future errc]]
[[ru:cpp/thread/future errc]]
[[zh:cpp/thread/future errc]]</text>
      <sha1>i6ykqnwadz5mszp0gv0tcz4u6xqdbb1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future errc/is error code enum</title>
    <ns>0</ns>
    <id>12628</id>
    <revision>
      <id>61339</id>
      <parentid>61338</parentid>
      <timestamp>2013-06-05T21:59:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix header</comment>
      <text xml:space="preserve" bytes="513">{{cpp/title|is_error_condition_enum{{dsc small|&lt;std::future_errc&gt;}}}}
{{cpp/error/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | since=c++11 | 
template&lt;&gt;
struct is_error_condition_enum&lt;std::future_errc&gt; : std::true_type;
}}
{{dcl end}}

Specifies that {{lc|std::future_errc}} is an error condition enum. This enables {{lc|std::error_code}} and {{lc|std::error_condition}} automatic conversions.

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/error condition/dsc is_error_condition_enum}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future errc/make error code</title>
    <ns>0</ns>
    <id>12643</id>
    <revision>
      <id>61386</id>
      <parentid>61385</parentid>
      <timestamp>2013-06-05T22:37:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="922">{{cpp/title|make_error_code{{dsc small|(std::future_errc)}}}}
{{cpp/thread/future_errc/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | since=c++11 |
std::error_code make_error_code( std::future_errc e );
}}
{{dcl end}}

Constructs an {{lc|std::error_code}} object from a value of type {{lc|std::future_errc}} as if by: 

{{cc|std::error_code(static_cast&lt;int&gt;(e), std::future_category())}}. 

This function is called by the constructor of {{lc|std::error_code}} when given an {{lc|std::future_errc}} argument.

===Parameters===
{{par begin}}
{{par | e | error code number}}
{{par end}}

===Return value===
A value of type {{lc|std::error_code}} that holds the error code number from {{tt|e}} associated with the error category {{c|&quot;future&quot;}}.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_code}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future errc/make error condition</title>
    <ns>0</ns>
    <id>12644</id>
    <revision>
      <id>63636</id>
      <parentid>61388</parentid>
      <timestamp>2013-07-13T06:41:39Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <comment>fixed iostream_category -&gt; future_category</comment>
      <text xml:space="preserve" bytes="837">{{cpp/title|make_error_condition{{dsc small|(std::future_errc)}}}}
{{cpp/thread/future_errc/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | since=c++11 |
std::error_condition make_error_condition( std::future_errc e );
}}
{{dcl end}}

Constructs an {{lc|std::error_condition}} object from a value of type {{lc|std::future_errc}} as if by:

{{cc|std::error_condition(static_cast&lt;int&gt;(e), std::future_category())}}.

===Parameters===
{{par begin}}
{{par | e | error code number}}
{{par end}}

===Return value===
A value of type {{lc|std::error_condition}} that holds the error code number from {{tt|e}} associated with the error category {{c|&quot;future&quot;}}.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/error/dsc error_condition}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future error</title>
    <ns>0</ns>
    <id>8550</id>
    <revision>
      <id>62971</id>
      <parentid>59175</parentid>
      <timestamp>2013-07-01T23:48:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1610">{{cpp/title | future_error}}
{{cpp/thread/future_error/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | since=c++11 |
class future_error;
}}
{{dcl end}}

The class {{lc|std::future_error}} defines an exception object that is thrown on failure by the functions in the thread library that deal with asynchronous execution and shared states ({{lc|std::future}}, {{lc|std::promise}}, etc). Similar to {{lc|std::system_error}}, this exception carries an error code compatible with {{lc|std::error_code}}.

{{inheritance diagram/std-future_error}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/future_error/dsc constructor}}
{{dsc inc | cpp/thread/future_error/dsc code}}
{{dsc inc | cpp/thread/future_error/dsc what}}
{{dsc end}}

{{inherited | [[cpp/error/logic_error | {{small|std::}}logic_error]] }}
{{cpp/error/exception/inherit}}

===Example===
{{example
 | 
 | code=
#include &lt;future&gt;
#include &lt;iostream&gt;

int main()
{
    std::future&lt;int&gt; empty;
    try {
        int n = empty.get();
    } catch (const std::future_error&amp; e) {
        std::cout &lt;&lt; &quot;Caught a future_error with code \&quot;&quot; &lt;&lt; e.code()
                  &lt;&lt; &quot;\&quot;\nMessage: \&quot;&quot; &lt;&lt; e.what() &lt;&lt; &quot;\&quot;\n&quot;;
    }
}
 | output=
Caught a future_error with code &quot;future:3&quot;
Message: &quot;No associated state&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc future_errc}}
{{dsc end}}

[[de:cpp/thread/future error]]
[[es:cpp/thread/future error]]
[[fr:cpp/thread/future error]]
[[it:cpp/thread/future error]]
[[ja:cpp/thread/future error]]
[[pt:cpp/thread/future error]]
[[ru:cpp/thread/future error]]
[[zh:cpp/thread/future error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future error/code</title>
    <ns>0</ns>
    <id>8976</id>
    <revision>
      <id>63440</id>
      <parentid>59178</parentid>
      <timestamp>2013-07-10T01:32:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="645">{{cpp/thread/future_error/title|code}}
{{cpp/thread/future_error/navbar}}
{{ddcl | since=c++11 |
const std::error_code&amp; code() const;
}}

Returns the stored error code.

===Parameters===
(none)

===Return value===
The stored error code.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future_error/dsc what}}
{{dsc end}}

[[de:cpp/thread/future error/code]]
[[es:cpp/thread/future error/code]]
[[fr:cpp/thread/future error/code]]
[[it:cpp/thread/future error/code]]
[[ja:cpp/thread/future error/code]]
[[pt:cpp/thread/future error/code]]
[[ru:cpp/thread/future error/code]]
[[zh:cpp/thread/future error/code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future error/future error</title>
    <ns>0</ns>
    <id>8982</id>
    <revision>
      <id>63441</id>
      <parentid>51367</parentid>
      <timestamp>2013-07-10T01:32:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="637">{{cpp/thread/future_error/title|future_error}}
{{cpp/thread/future_error/navbar}}
{{ddcl | since=c++11 |
future_error( std::error_code ec );
}}

Constructs a new future error object containing error code {{tt|ec}}.

===Parameters===
{{par begin}}
{{par | ec | error code}}
{{par end}}

[[de:cpp/thread/future error/future error]]
[[es:cpp/thread/future error/future error]]
[[fr:cpp/thread/future error/future error]]
[[it:cpp/thread/future error/future error]]
[[ja:cpp/thread/future error/future error]]
[[pt:cpp/thread/future error/future error]]
[[ru:cpp/thread/future error/future error]]
[[zh:cpp/thread/future error/future error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future error/what</title>
    <ns>0</ns>
    <id>8975</id>
    <revision>
      <id>63442</id>
      <parentid>59179</parentid>
      <timestamp>2013-07-10T01:32:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="687">{{cpp/thread/future_error/title|what}}
{{cpp/thread/future_error/navbar}}
{{ddcl | since=c++11 |
virtual const char* what() const;
}}

Returns the explanatory string.

===Parameters===
(none)

===Return value===
Pointer to a null-terminated string with explanatory information. 

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future_error/dsc code}}
{{dsc end}}

[[de:cpp/thread/future error/what]]
[[es:cpp/thread/future error/what]]
[[fr:cpp/thread/future error/what]]
[[it:cpp/thread/future error/what]]
[[ja:cpp/thread/future error/what]]
[[pt:cpp/thread/future error/what]]
[[ru:cpp/thread/future error/what]]
[[zh:cpp/thread/future error/what]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/future status</title>
    <ns>0</ns>
    <id>8673</id>
    <revision>
      <id>63443</id>
      <parentid>59182</parentid>
      <timestamp>2013-07-10T01:32:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1195">{{cpp/title|future_status}}
{{cpp/thread/navbar}}
{{ddcl | header=future | since=c++11 | 1=
enum class future_status {
    ready,
    timeout,
    deferred
};
}}

Specifies state of a future as returned by {{tt|wait_for}} and {{tt|wait_until}} functions of {{lc|std::future}} and {{lc|std::shared_future}}.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|deferred}} | the shared state contains a deferred function, so the result will be computed only when explicitly requested}}
{{dsc | {{tt|ready}} | the shared state is ready}}
{{dsc | {{tt|timeout}} | the shared state did not become ready before specified timeout duration has passed}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc wait_for|future}}
{{dsc inc | cpp/thread/future/dsc wait_for|shared_future}}
{{dsc inc | cpp/thread/future/dsc wait_until|future}}
{{dsc inc | cpp/thread/future/dsc wait_until|shared_future}}
{{dsc end}}

[[de:cpp/thread/future status]]
[[es:cpp/thread/future status]]
[[fr:cpp/thread/future status]]
[[it:cpp/thread/future status]]
[[ja:cpp/thread/future status]]
[[pt:cpp/thread/future status]]
[[ru:cpp/thread/future status]]
[[zh:cpp/thread/future status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/get id</title>
    <ns>0</ns>
    <id>2298</id>
    <revision>
      <id>63444</id>
      <parentid>59183</parentid>
      <timestamp>2013-07-10T01:32:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1119">{{cpp/title|n=this_thread::|get_id}}
{{cpp/thread/navbar}}
{{ddcl | header=thread | since=c++11 | 1=
std::thread::id get_id();
}} 

Returns the ''id'' of the current thread.

===Parameters===
(none)

===Return value===
''id'' of the current thread

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;
#include &lt;mutex&gt;

std::mutex g_display_mutex;

void foo()
{
    std::thread::id this_id = std::this_thread::get_id();

    g_display_mutex.lock();
    std::cout &lt;&lt; &quot;thread &quot; &lt;&lt; this_id &lt;&lt; &quot; sleeping...\n&quot;;
    g_display_mutex.unlock();

    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(foo);

    t1.join();
    t2.join();
}
 | output=
thread 0x2384b312 sleeping...
thread 0x228a10fc sleeping...
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc get_id | mem=std::thread}}
{{dsc end}}

[[de:cpp/thread/get id]]
[[es:cpp/thread/get id]]
[[fr:cpp/thread/get id]]
[[it:cpp/thread/get id]]
[[ja:cpp/thread/get id]]
[[pt:cpp/thread/get id]]
[[ru:cpp/thread/get id]]
[[zh:cpp/thread/get id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/launch</title>
    <ns>0</ns>
    <id>8672</id>
    <revision>
      <id>64151</id>
      <parentid>63445</parentid>
      <timestamp>2013-08-15T04:08:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 (issue 2102)</comment>
      <text xml:space="preserve" bytes="1324">{{cpp/title|launch}}
{{cpp/thread/navbar}}
{{ddcl | header=future | since=c++11 | 1=
enum class launch : /* unspecified */ {
    async =    /* unspecified */,
    deferred = /* unspecified */,
    /* implementation-defined */
};
}}

Specifies the launch policy for a task executed by the {{lc|std::async}} function. {{tt|std::launch}} is an enumeration used as {{concept|BitmaskType}}.

The following constants denoting individual bits are defined by the standard library:

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|std::launch::async}} | a new thread is launched to execute the task asynchronously }}
{{dsc | {{tt|std::launch::deferred}} | the task is executed on the calling thread the first time its result is requested (lazy evaluation) }}
{{dsc end}}

In addition, implementations are allowed to:

* define additional bits and bitmasks to specify restrictions on task interactions applicable to a subset of launch policies, and
* enable those additional bitmasks for the first (default) overload of {{lc|std::async}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc async}}
{{dsc end}}

[[de:cpp/thread/launch]]
[[es:cpp/thread/launch]]
[[fr:cpp/thread/launch]]
[[it:cpp/thread/launch]]
[[ja:cpp/thread/launch]]
[[pt:cpp/thread/launch]]
[[ru:cpp/thread/launch]]
[[zh:cpp/thread/launch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock</title>
    <ns>0</ns>
    <id>2503</id>
    <revision>
      <id>66975</id>
      <parentid>63446</parentid>
      <timestamp>2014-01-14T04:38:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+boost extension in Notes</comment>
      <text xml:space="preserve" bytes="2791">{{cpp/title|lock}}
{{cpp/thread/navbar}}
{{ddcl | header=mutex | since=c++11 |
template&lt; class Lockable1, class Lockable2, class LockableN... &gt;
void lock( Lockable1&amp; lock1, Lockable2&amp; lock2, LockableN&amp; lockn... );
}}

Locks the given {{concept|Lockable}} objects {{tt|lock1}}, {{tt|lock2}}, {{tt|...}}, {{tt|lockn}} using a deadlock avoidance algorithm to avoid deadlock.

The objects are locked by an unspecified series of calls to {{tt|lock}}, {{tt|try_lock}}, {{tt|unlock}}.  If a call to {{tt|lock}} or {{tt|unlock}} results in an exception, {{tt|unlock}} is called for any locked objects before rethrowing.

===Parameters===
{{par begin}}
{{par | lock1, lock2, ... , lockn | the {{concept|Lockable}} objects to lock}}
{{par end}}

===Return value===
(none)

===Notes===
[http://www.boost.org/doc/libs/release/doc/html/thread/synchronization.html#thread.synchronization.lock_functions.lock_range Boost provides a version of this function] that takes a sequence of {{concept|Lockable}} objects defined by a pair of iterators.

===Example===
{{example|The following example uses {{tt|std::lock}} to lock pairs of mutexes without deadlock.
 | code=
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;functional&gt;
#include &lt;chrono&gt;

struct Employee {
    Employee(int id) : id(id) {}
    int id;
    std::vector&lt;int&gt; lunch_partners;
    std::mutex m;
};

void send_mail(Employee &amp;e1, Employee &amp;e2)
{
    // simulate a time-consuming messaging operation
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void assign_lunch_partner(Employee &amp;e1, Employee &amp;e2)
{
    // use std::lock to acquire two locks without worrying about 
    // other calls to assign_lunch_partner deadlocking us
    std::lock(e1.m, e2.m);

    e1.lunch_partners.push_back(e2.id);
    e2.lunch_partners.push_back(e1.id);

    e1.m.unlock();
    e2.m.unlock();

    send_mail(e1, e2);
    send_mail(e2, e1);
}

int main()
{
    Employee alice(0), bob(1), christina(2), dave(3);

    // assign in parallel threads because mailing users about lunch assignments
    // takes a long time
    std::vector&lt;std::thread&gt; threads;
    threads.emplace_back(assign_lunch_partner, std::ref(alice), std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(bob));
    threads.emplace_back(assign_lunch_partner, std::ref(christina), std::ref(alice));
    threads.emplace_back(assign_lunch_partner, std::ref(dave), std::ref(bob));

    for (auto &amp;thread : threads) thread.join();
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc try_lock}}
{{dsc end}}

[[de:cpp/thread/lock]]
[[es:cpp/thread/lock]]
[[fr:cpp/thread/lock]]
[[it:cpp/thread/lock]]
[[ja:cpp/thread/lock]]
[[pt:cpp/thread/lock]]
[[ru:cpp/thread/lock]]
[[zh:cpp/thread/lock]]</text>
      <sha1>qp833qbzey7fbiovtmv52cps247x87d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock guard</title>
    <ns>0</ns>
    <id>2615</id>
    <revision>
      <id>67020</id>
      <parentid>66931</parentid>
      <timestamp>2014-01-18T04:51:03Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <comment>Deleted copy assignment</comment>
      <text xml:space="preserve" bytes="2042">{{cpp/title|lock_guard}}
{{cpp/thread/lock_guard/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
template&lt; class Mutex &gt;
class lock_guard;
}}

The class {{tt|lock_guard}} is a mutex wrapper that provides a convenient [[enwiki:Resource_Acquisition_Is_Initialization|RAII-style]] mechanism for owning a mutex for the duration of a scoped block.  

When a {{tt|lock_guard}} object is created, it attempts to take ownership of the mutex it is given.  When control leaves the scope in which the {{tt|lock_guard}} object was created, the {{tt|lock_guard}} is destructed and the mutex is released.

The {{tt|lock_guard}} class is non-copyable.

===Template parameters===
{{par begin}}
{{par | Mutex | the type of the mutex to lock. The type must meet the {{concept|BasicLockable}} requirements}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|mutex_type}} | Mutex}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/lock_guard/dsc constructor}}
{{dsc inc | cpp/thread/lock_guard/dsc destructor}}
{{dsc inc | cpp/thread/lock_guard/dsc operator{{=}}}}
{{dsc end}}

===Example===
{{example|
 | code=
#include &lt;thread&gt;
#include &lt;mutex&gt;
#include &lt;iostream&gt;

int g_i = 0;
std::mutex g_i_mutex;  // protects g_i

void safe_increment()
{
    std::lock_guard&lt;std::mutex&gt; lock(g_i_mutex);
    ++g_i;

    std::cout &lt;&lt; std::this_thread::get_id() &lt;&lt; &quot;: &quot; &lt;&lt; g_i &lt;&lt; '\n';

    // g_i_mutex is automatically released when lock
    // goes out of scope
}

int main()
{
    std::cout &lt;&lt; __func__ &lt;&lt; &quot;: &quot; &lt;&lt; g_i &lt;&lt; '\n';

    std::thread t1(safe_increment);
    std::thread t2(safe_increment);

    t1.join();
    t2.join();

    std::cout &lt;&lt; __func__ &lt;&lt; &quot;: &quot; &lt;&lt; g_i &lt;&lt; '\n';
}
 | p=true
 | output=
main: 0
140641306900224: 1
140641298507520: 2
main: 2
}}

[[de:cpp/thread/lock guard]]
[[es:cpp/thread/lock guard]]
[[fr:cpp/thread/lock guard]]
[[it:cpp/thread/lock guard]]
[[ja:cpp/thread/lock guard]]
[[pt:cpp/thread/lock guard]]
[[ru:cpp/thread/lock guard]]
[[zh:cpp/thread/lock guard]]</text>
      <sha1>2i7u7d0yo0mh9z6s4b8t1jqy0oauj61</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock guard/lock guard</title>
    <ns>0</ns>
    <id>4451</id>
    <revision>
      <id>67022</id>
      <parentid>62972</parentid>
      <timestamp>2014-01-18T04:56:18Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <comment>Deleted copy constructor</comment>
      <text xml:space="preserve" bytes="1181">{{cpp/thread/lock_guard/title|lock_guard}}
{{cpp/thread/lock_guard/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
explicit lock_guard( mutex_type&amp; m );
}}
{{dcl | num=2 | since=c++11 |
lock_guard( mutex_type&amp; m, std::adopt_lock_t t );
}}
{{dcl | num=3 | since=c++11 |1=
lock_guard( const lock_guard&amp; ) = delete;
}}
{{dcl end}}

Acquires ownership of the given mutex {{tt|m}}.

1) If {{tt|m}} is not a recursive mutex, requires that the current thread does not own {{tt|m}}. Effectively calls {{c|m.lock()}}.

2) Requires that the current thread owns {{tt|m}}.

3) Copy constructor is deleted.

The behavior is undefined if {{tt|m}} is destroyed before the {{tt|lock_guard}} object is.

===Parameters===
{{par begin}}
{{par | m | mutex to acquire ownership of}}
{{par | t | tag parameter used to select non-locking version of the constructor}}
{{par end}}

[[de:cpp/thread/lock guard/lock guard]]
[[es:cpp/thread/lock guard/lock guard]]
[[fr:cpp/thread/lock guard/lock guard]]
[[it:cpp/thread/lock guard/lock guard]]
[[ja:cpp/thread/lock guard/lock guard]]
[[pt:cpp/thread/lock guard/lock guard]]
[[ru:cpp/thread/lock guard/lock guard]]
[[zh:cpp/thread/lock guard/lock guard]]</text>
      <sha1>btvudgzh1845yft1sjxqenxzwh5tx85</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock guard/~lock guard</title>
    <ns>0</ns>
    <id>4453</id>
    <revision>
      <id>63448</id>
      <parentid>43748</parentid>
      <timestamp>2013-07-10T01:32:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="600">{{cpp/thread/lock_guard/title|~lock_guard}}
{{cpp/thread/lock_guard/navbar}}
{{ddcl | since=c++11 |
~lock_guard();
}}

Releases the ownership of the owned mutex. Effectively calls {{c|m.unlock()}} where {{tt|m}} is the mutex passed to the {{tt|lock_guard}}'s constructor.

[[de:cpp/thread/lock guard/~lock guard]]
[[es:cpp/thread/lock guard/~lock guard]]
[[fr:cpp/thread/lock guard/~lock guard]]
[[it:cpp/thread/lock guard/~lock guard]]
[[ja:cpp/thread/lock guard/~lock guard]]
[[pt:cpp/thread/lock guard/~lock guard]]
[[ru:cpp/thread/lock guard/~lock guard]]
[[zh:cpp/thread/lock guard/~lock guard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock tag</title>
    <ns>0</ns>
    <id>4472</id>
    <revision>
      <id>62973</id>
      <parentid>59191</parentid>
      <timestamp>2013-07-01T23:48:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1172">{{cpp/title|defer_lock|try_to_lock|adopt_lock}}
{{cpp/thread/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
constexpr std::defer_lock_t defer_lock = std::defer_lock_t();
}}
{{dcl | since=c++11 | 1=
constexpr std::try_to_lock_t try_to_lock = std::try_to_lock_t();
}}
{{dcl | since=c++11 | 1=
constexpr std::adopt_lock_t adopt_lock = std::adopt_lock_t();
}}
{{dcl end}}

{{tt|std::defer_lock}}, {{tt|std::try_to_lock}} and {{tt|std::adopt_lock}} are instances of empty struct tag types {{lc|std::defer_lock_t}}, {{lc|std::try_to_lock_t}} and {{lc|std::adopt_lock_t}} respectively. 

They are used to specify locking strategies for {{lc|std::lock_guard}} and {{lc|std::unique_lock}}.

{{cpp/thread/lock_tag_types}}

===Example===
{{include| cpp/thread/example_lock_tag}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc lock_tag_t}}
{{dsc inc | cpp/thread/lock_guard/dsc constructor}}
{{dsc inc | cpp/thread/unique_lock/dsc constructor}}
{{dsc end}}

[[de:cpp/thread/lock tag]]
[[es:cpp/thread/lock tag]]
[[fr:cpp/thread/lock tag]]
[[it:cpp/thread/lock tag]]
[[ja:cpp/thread/lock tag]]
[[pt:cpp/thread/lock tag]]
[[ru:cpp/thread/lock tag]]
[[zh:cpp/thread/lock tag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/lock tag t</title>
    <ns>0</ns>
    <id>4471</id>
    <revision>
      <id>62974</id>
      <parentid>59192</parentid>
      <timestamp>2013-07-01T23:48:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="981">{{cpp/title|defer_lock_t|try_to_lock_t|adopt_lock_t}}
{{cpp/thread/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
struct defer_lock_t { };
}}
{{dcl | since=c++11 |
struct try_to_lock_t { };
}}
{{dcl | since=c++11 |
struct adopt_lock_t { };
}}
{{dcl end}}

{{tt|std::defer_lock_t}}, {{tt|std::try_to_lock_t}} and {{tt|std::adopt_lock_t}} are empty struct tag types used to specify locking strategy for {{lc|std::lock_guard}}, {{lc|std::unique_lock}} and {{lc|std::shared_lock}}.


{{cpp/thread/lock_tag_types}}

===Example===
{{include| cpp/thread/example_lock_tag}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc lock_tag}}
{{dsc inc | cpp/thread/lock_guard/dsc constructor}}
{{dsc inc | cpp/thread/unique_lock/dsc constructor}}
{{dsc end}}

[[de:cpp/thread/lock tag t]]
[[es:cpp/thread/lock tag t]]
[[fr:cpp/thread/lock tag t]]
[[it:cpp/thread/lock tag t]]
[[ja:cpp/thread/lock tag t]]
[[pt:cpp/thread/lock tag t]]
[[ru:cpp/thread/lock tag t]]
[[zh:cpp/thread/lock tag t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex</title>
    <ns>0</ns>
    <id>2291</id>
    <revision>
      <id>67025</id>
      <parentid>67024</parentid>
      <timestamp>2014-01-18T05:24:45Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3190">{{cpp/title|mutex}}
{{cpp/thread/mutex/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
class mutex;
}}

The {{tt|mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

{{tt|mutex}} offers exclusive, non-recursive ownership semantics:

* A calling thread ''owns'' a {{tt|mutex}} from the time that it successfully calls either [[cpp/thread/mutex/lock|{{tt|lock}}]] or [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]] until it calls [[cpp/thread/mutex/unlock|{{tt|unlock}}]].
* When a thread owns a {{tt|mutex}}, all other threads will block (for calls to [[cpp/thread/mutex/lock|{{tt|lock}}]]) or receive a {{c|false}} return value (for [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]]) if they attempt to claim ownership of the {{tt|mutex}}.
* A calling thread must not own the {{tt|mutex}} prior to calling [[cpp/thread/mutex/lock|{{tt|lock}}]] or [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]].

The behavior of a program is undefined if a {{tt|mutex}} is destroyed while still owned by some thread.  The {{tt|mutex}} class satisfies all requirements of {{concept|Mutex}} and {{concept|StandardLayoutType}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Locking}}
{{dsc inc | cpp/thread/mutex/dsc lock | mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | mutex}}

{{dsc h2 | Native handle}}
{{dsc inc | cpp/thread/mutex/dsc native_handle | mutex}}
{{dsc end}}

===Notes===
{{tt|std::mutex}} is usually not accessed directly: {{lc|std::unique_lock}} and {{lc|std::lock_guard}} are used to manage locking in exception-safe manner.

===Example===
{{example
 | This example shows how a {{tt|mutex}} can be used to protect a {{lc|std::map}} shared between two threads.
 | code=
#include &lt;iostream&gt;
#include &lt;map&gt;
#include &lt;string&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;

std::map&lt;std::string, std::string&gt; g_pages;
std::mutex g_pages_mutex;

void save_page(const std::string &amp;url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = &quot;fake content&quot;;

    g_pages_mutex.lock(); // or, to be exception-safe, use std::lock_guard
    g_pages[url] = result;
    g_pages_mutex.unlock();
}

int main() 
{
    std::thread t1(save_page, &quot;http://foo&quot;);
    std::thread t2(save_page, &quot;http://bar&quot;);
    t1.join();
    t2.join();

    // safe to access g_pages without lock now, as the threads are joined
    for (const auto &amp;pair : g_pages) {
        std::cout &lt;&lt; pair.first &lt;&lt; &quot; =&gt; &quot; &lt;&lt; pair.second &lt;&lt; '\n';
    }
}
 | output=
http://bar =&gt; fake content
http://foo =&gt; fake content
}}

[[de:cpp/thread/mutex]]
[[es:cpp/thread/mutex]]
[[fr:cpp/thread/mutex]]
[[it:cpp/thread/mutex]]
[[ja:cpp/thread/mutex]]
[[pt:cpp/thread/mutex]]
[[ru:cpp/thread/mutex]]
[[zh:cpp/thread/mutex]]</text>
      <sha1>izqvhw72u9pvvdtsm2l5i5rrkm58fnr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/lock</title>
    <ns>0</ns>
    <id>2329</id>
    <revision>
      <id>51378</id>
      <parentid>43727</parentid>
      <timestamp>2013-06-01T04:01:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="277">{{include page|cpp/thread/mutex/lock|mutex}}

[[de:cpp/thread/mutex/lock]]
[[es:cpp/thread/mutex/lock]]
[[fr:cpp/thread/mutex/lock]]
[[it:cpp/thread/mutex/lock]]
[[ja:cpp/thread/mutex/lock]]
[[pt:cpp/thread/mutex/lock]]
[[ru:cpp/thread/mutex/lock]]
[[zh:cpp/thread/mutex/lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/mutex</title>
    <ns>0</ns>
    <id>4488</id>
    <revision>
      <id>67033</id>
      <parentid>67032</parentid>
      <timestamp>2014-01-18T07:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cleanup</comment>
      <text xml:space="preserve" bytes="608">{{cpp/thread/mutex/title|mutex}}
{{cpp/thread/mutex/navbar}}
{{dcl begin}}
{{dcl | num=1 |since=c++11 |
constexpr mutex();
}}
{{dcl | num=2 |since=c++11 |1=
mutex( const mutex&amp; ) = delete;
}}
{{dcl end}}

@1@ Constructs the mutex. The mutex is in unlocked state after the call.

@2@ Copy constructor is deleted.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/thread/mutex/mutex]]
[[es:cpp/thread/mutex/mutex]]
[[fr:cpp/thread/mutex/mutex]]
[[it:cpp/thread/mutex/mutex]]
[[ja:cpp/thread/mutex/mutex]]
[[pt:cpp/thread/mutex/mutex]]
[[ru:cpp/thread/mutex/mutex]]
[[zh:cpp/thread/mutex/mutex]]</text>
      <sha1>icmj4epslmf5xqd8zmx0gi8arc68f6w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/native handle</title>
    <ns>0</ns>
    <id>2332</id>
    <revision>
      <id>51380</id>
      <parentid>43717</parentid>
      <timestamp>2013-06-01T04:01:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="358">{{include page|cpp/thread/mutex/native_handle|mutex}}

[[de:cpp/thread/mutex/native handle]]
[[es:cpp/thread/mutex/native handle]]
[[fr:cpp/thread/mutex/native handle]]
[[it:cpp/thread/mutex/native handle]]
[[ja:cpp/thread/mutex/native handle]]
[[pt:cpp/thread/mutex/native handle]]
[[ru:cpp/thread/mutex/native handle]]
[[zh:cpp/thread/mutex/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/try lock</title>
    <ns>0</ns>
    <id>2330</id>
    <revision>
      <id>51381</id>
      <parentid>43711</parentid>
      <timestamp>2013-06-01T04:01:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="313">{{include page|cpp/thread/mutex/try_lock|mutex}}

[[de:cpp/thread/mutex/try lock]]
[[es:cpp/thread/mutex/try lock]]
[[fr:cpp/thread/mutex/try lock]]
[[it:cpp/thread/mutex/try lock]]
[[ja:cpp/thread/mutex/try lock]]
[[pt:cpp/thread/mutex/try lock]]
[[ru:cpp/thread/mutex/try lock]]
[[zh:cpp/thread/mutex/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/unlock</title>
    <ns>0</ns>
    <id>2331</id>
    <revision>
      <id>51382</id>
      <parentid>43705</parentid>
      <timestamp>2013-06-01T04:01:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="295">{{include page|cpp/thread/mutex/unlock|mutex}}

[[de:cpp/thread/mutex/unlock]]
[[es:cpp/thread/mutex/unlock]]
[[fr:cpp/thread/mutex/unlock]]
[[it:cpp/thread/mutex/unlock]]
[[ja:cpp/thread/mutex/unlock]]
[[pt:cpp/thread/mutex/unlock]]
[[ru:cpp/thread/mutex/unlock]]
[[zh:cpp/thread/mutex/unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/mutex/~mutex</title>
    <ns>0</ns>
    <id>13124</id>
    <revision>
      <id>67048</id>
      <parentid>67029</parentid>
      <timestamp>2014-01-18T14:02:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fwd to template</comment>
      <text xml:space="preserve" bytes="50">{{include page|cpp/thread/mutex/destructor|mutex}}</text>
      <sha1>f5zpwhw39t7qcio1ly3qbw77m6jqgqk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/notify all at thread exit</title>
    <ns>0</ns>
    <id>5086</id>
    <revision>
      <id>68877</id>
      <parentid>66582</parentid>
      <timestamp>2014-03-22T21:08:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>lwg 2140 (sequenced-after)</comment>
      <text xml:space="preserve" bytes="3559">{{cpp/title|notify_all_at_thread_exit}}
{{cpp/thread/navbar}}
{{ddcl | header=condition_variable | since=c++11 |
void notify_all_at_thread_exit( std::condition_variable&amp; cond,
                                std::unique_lock&lt;std::mutex&gt; lk );
}}

{{tt|notify_all_at_thread_exit}} provides a mechanism to notify other threads that a given thread has completely finished, including destroying all [[cpp/keyword/thread_local|thread_local]] objects.  It operates as follows:

* Ownership of the previously acquired lock {{tt|lk}} is transferred to internal storage.

* The execution environment is modified such that when the current thread exits, the condition variable {{tt|cond}} is notified as if by:

{{c|
lk.unlock();
cond.notify_all();
}}

The implied {{tt|lk.unlock}} is ''sequenced after'' (as defined in {{lc|std::memory_order}})  the destruction of all objects with [[cpp/keyword/thread_local|thread local storage duration]] associated with the current thread.

An equivalent effect may be achieved with the facilities provided by {{lc|std::promise}} or {{lc|std::packaged_task}}.

===Notes===
Calling this function if {{tt|lock.mutex()}} is not locked by the current thread is undefined behavior.

Calling this function if {{tt|lock.mutex()}} is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.

The supplied lock {{tt|lk}} is held until the thread exits. Once this function has been called, no more threads may acquire the same lock in order to wait on {{tt|cond}}. If some thread is waiting on this condition variable, it should not attempt to release and reacquire the lock when it wakes up spuriously.

In typical use cases, this function is the last thing called by a detached thread.

===Parameters===
{{par begin}}
{{par | cond | the condition variable to notify at thread exit}}
{{par | lk | the lock associated with the condition variable {{tt|cond}} }}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | This partial code fragment illustrates how {{tt|notify_all_at_thread_exit}} can be used to avoid accessing data that depends on thread locals while those thread locals are in the process of being destructed:
 | code=
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;condtion_variable&gt;

std::mutex m;
std::condition_variable cv;

bool ready = false;
ComplexType result;  // some arbitrary type

void thread_func()
{
    std::unique_lock&lt;std::mutex&gt; lk(m);
    // assign a value to result using thread_local data
    result = function_that_uses_thread_locals();
    ready = true;
    std::notify_all_at_thread_exit(cv, std::move(lk));
} // 1. destroy thread_locals, 2. unlock mutex, 3. notify cv

int main()
{
    std::thread t(thread_func);
    t.detach();

    // do other work
    // ...

    // wait for the detached thread
    std::unique_lock&lt;std::mutex&gt; lk(m);
    while(!ready) {
        cv.wait(lk);
    }
    process(result); // result is ready and thread_local destructors have finished
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc set_value_at_thread_exit}}
{{dsc inc | cpp/thread/packaged_task/dsc make_ready_at_thread_exit}}
{{dsc end}}

[[de:cpp/thread/notify all at thread exit]]
[[es:cpp/thread/notify all at thread exit]]
[[fr:cpp/thread/notify all at thread exit]]
[[it:cpp/thread/notify all at thread exit]]
[[ja:cpp/thread/notify all at thread exit]]
[[pt:cpp/thread/notify all at thread exit]]
[[ru:cpp/thread/notify all at thread exit]]
[[zh:cpp/thread/notify all at thread exit]]</text>
      <sha1>tcrzk84jfo7q8q6viix80bsdvejsj23</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/once flag</title>
    <ns>0</ns>
    <id>2508</id>
    <revision>
      <id>63451</id>
      <parentid>59199</parentid>
      <timestamp>2013-07-10T01:32:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1016">{{cpp/title|once_flag}}
{{cpp/thread/navbar}}
{{ddcl | header=mutex | since=c++11 |
class once_flag;
}}

The class {{tt|std::once_flag}} is a helper structure for {{lc|std::call_once}}.

An object of type {{tt|std::once_flag}} that is passed to multiple calls to {{lc|std::call_once}} allows those calls to coordinate with each other such that only one of the calls will actually run to completion.

{{tt|std::once_flag}} is noncopyable.

===Member functions===
{{member | {{small|std::once_flag::}}once_flag |
{{ddcl |
once_flag();
}}

Constructs an {{tt|once_flag}} object. The internal state is set to indicate that no function has been called yet.

===Parameters===
(none)

===Exceptions===
{{noexcept}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc call_once}}
{{dsc end}}

[[de:cpp/thread/once flag]]
[[es:cpp/thread/once flag]]
[[fr:cpp/thread/once flag]]
[[it:cpp/thread/once flag]]
[[ja:cpp/thread/once flag]]
[[pt:cpp/thread/once flag]]
[[ru:cpp/thread/once flag]]
[[zh:cpp/thread/once flag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task</title>
    <ns>0</ns>
    <id>2560</id>
    <revision>
      <id>67883</id>
      <parentid>66580</parentid>
      <timestamp>2014-03-04T04:44:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link Callable</comment>
      <text xml:space="preserve" bytes="3035">{{cpp/title|packaged_task}}
{{cpp/thread/packaged_task/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | num=1 | since=c++11 |
template&lt; class &gt; class packaged_task; //not defined
}}
{{dcl | num=2 | since=c++11 |
template&lt; class R, class ...Args &gt; 
class packaged_task&lt;R(Args...)&gt;;
}}
{{dcl end}}

The class template {{tt|std::packaged_task}} wraps any {{concept|Callable}} target (function, lambda expression, bind expression, or another function object) so that it can be invoked asynchronously.  Its return value or exception thrown is stored in a shared state which can be accessed through {{lc|std::future}} objects.

Just like {{lc|std::function}}, {{tt|std::packaged_task}} is a polymorphic, allocator-aware container: the stored callable target may be allocated on heap or with a provided allocator.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc constructor}}
{{dsc inc | cpp/thread/packaged_task/dsc destructor}}
{{dsc inc | cpp/thread/packaged_task/dsc operator{{=}}}}
{{dsc inc | cpp/thread/packaged_task/dsc valid}}
{{dsc inc | cpp/thread/packaged_task/dsc swap}}

{{dsc h2 | Getting the result}}
{{dsc inc | cpp/thread/packaged_task/dsc get_future}}

{{dsc h2 | Execution}}
{{dsc inc | cpp/thread/packaged_task/dsc operator()}}
{{dsc inc | cpp/thread/packaged_task/dsc make_ready_at_thread_exit}}
{{dsc inc | cpp/thread/packaged_task/dsc reset}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc swap2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc uses_allocator}}
{{dsc end}}

===Example===
{{example
| code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;thread&gt;
#include &lt;future&gt;
#include &lt;functional&gt;

// unique function to avoid disambiguating the std::pow overload set
int f(int x, int y) { return std::pow(x,y); }

void task_lambda()
{
    std::packaged_task&lt;int(int,int)&gt; task([](int a, int b) {
        return std::pow(a, b); 
    });
    std::future&lt;int&gt; result = task.get_future();
	
    task(2, 9);

    std::cout &lt;&lt; &quot;task_lambda:\t&quot; &lt;&lt; result.get() &lt;&lt; '\n';
}

void task_bind()
{
    std::packaged_task&lt;int()&gt; task(std::bind(f, 2, 11));
    std::future&lt;int&gt; result = task.get_future();
	
    task();

    std::cout &lt;&lt; &quot;task_bind:\t&quot; &lt;&lt; result.get() &lt;&lt; '\n';
}

void task_thread()
{
    std::packaged_task&lt;int(int,int)&gt; task(f);
    std::future&lt;int&gt; result = task.get_future();
	
    std::thread task_td(std::move(task), 2, 10);
    task_td.join();

    std::cout &lt;&lt; &quot;task_thread:\t&quot; &lt;&lt; result.get() &lt;&lt; '\n';
}

int main()
{
    task_lambda();
    task_bind();
    task_thread();
}
| output=
task_lambda: 512
task_bind:   2048
task_thread: 1024
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc future}}
{{dsc end}}

[[de:cpp/thread/packaged task]]
[[es:cpp/thread/packaged task]]
[[fr:cpp/thread/packaged task]]
[[it:cpp/thread/packaged task]]
[[ja:cpp/thread/packaged task]]
[[pt:cpp/thread/packaged task]]
[[ru:cpp/thread/packaged task]]
[[zh:cpp/thread/packaged task]]</text>
      <sha1>49i4wt8zrhsucsspudaen95v7x8n59l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/get future</title>
    <ns>0</ns>
    <id>8676</id>
    <revision>
      <id>63452</id>
      <parentid>51386</parentid>
      <timestamp>2013-07-10T01:32:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1087">{{cpp/thread/packaged_task/title | get_future}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
std::future&lt;R&gt; get_future();
}}

Returns a {{tt|future}} which shares the same shared state as {{c|*this}}.

{{tt|get_future}} can be called only once for each {{tt|packaged_task}}.

===Parameters===
(none)

===Return value===
A future which shares the same shared state as {{c|*this}}.

===Exceptions===
{{lc|std::future_error}} on the following error conditions:

* The shared state has already been retrieved via a call to {{tt|get_future}}. The error category is set to {{ltt|cpp/thread/future_errc|future_already_retrieved}}.
* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

[[de:cpp/thread/packaged task/get future]]
[[es:cpp/thread/packaged task/get future]]
[[fr:cpp/thread/packaged task/get future]]
[[it:cpp/thread/packaged task/get future]]
[[ja:cpp/thread/packaged task/get future]]
[[pt:cpp/thread/packaged task/get future]]
[[ru:cpp/thread/packaged task/get future]]
[[zh:cpp/thread/packaged task/get future]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/make ready at thread exit</title>
    <ns>0</ns>
    <id>8679</id>
    <revision>
      <id>68025</id>
      <parentid>68018</parentid>
      <timestamp>2014-03-15T14:50:37Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>spacing</comment>
      <text xml:space="preserve" bytes="1550">{{cpp/thread/packaged_task/title|make_ready_at_thread_exit}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
void make_ready_at_thread_exit( ArgTypes... args );
}}

Calls the stored task with {{tt|args}} as the arguments. The return value of the task or any exceptions thrown are stored in the shared state. The shared state is not made ready until the current thread exits and all objects of ''thread local'' storage duration are destroyed. After and any threads waiting for this are unblocked.

===Parameters===
{{par begin}}
{{par | args | the parameters to pass on invocation of the stored task}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following error conditions:

* The stored task has already been invoked. The error category is set to {{tt|promise_already_satisfied}}.
* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc operator()}}
{{dsc end}}

[[de:cpp/thread/packaged task/make ready at thread exit]]
[[es:cpp/thread/packaged task/make ready at thread exit]]
[[fr:cpp/thread/packaged task/make ready at thread exit]]
[[it:cpp/thread/packaged task/make ready at thread exit]]
[[ja:cpp/thread/packaged task/make ready at thread exit]]
[[pt:cpp/thread/packaged task/make ready at thread exit]]
[[ru:cpp/thread/packaged task/make ready at thread exit]]
[[zh:cpp/thread/packaged task/make ready at thread exit]]</text>
      <sha1>s52m41l3y5zznlhn4kjf9bjo9h9ugvz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/operator()</title>
    <ns>0</ns>
    <id>8678</id>
    <revision>
      <id>68890</id>
      <parentid>63454</parentid>
      <timestamp>2014-03-22T22:19:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>lwg 2142</comment>
      <text xml:space="preserve" bytes="1697">{{cpp/thread/packaged_task/title | operator()}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
void operator()( ArgTypes... args );
}}

Calls the stored task with {{tt|args}} as the arguments. The return value of the task or any exceptions thrown are stored in the shared state. The shared state is made ready and any threads waiting for this are unblocked.

===Parameters===
{{par begin}}
{{par | args | the parameters to pass on invocation of the stored task}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following error conditions:

* The stored task has already been invoked. The error category is set to {{ltt|cpp/thread/future_errc|promise_already_satisfied}}.
* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

===Notes===
{{rev begin}}
{{rev|until=c++14|
A successful call to {{tt|operator()}} synchronizes with a call to any member function of a {{lc|std::future}} or {{lc|std::shared_future}} that share their shared state with {{c|*this}}.
}}
{{rev|since=c++14|
(no additional synchronization guarantees other than what's already provided by shared state.
}}
{{rev end}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc make_ready_at_thread_exit}}
{{dsc end}}

[[de:cpp/thread/packaged task/operator()]]
[[es:cpp/thread/packaged task/operator()]]
[[fr:cpp/thread/packaged task/operator()]]
[[it:cpp/thread/packaged task/operator()]]
[[ja:cpp/thread/packaged task/operator()]]
[[pt:cpp/thread/packaged task/operator()]]
[[ru:cpp/thread/packaged task/operator()]]
[[zh:cpp/thread/packaged task/operator()]]</text>
      <sha1>gdm7zqpmp5gki1orn15kpm8qvajktov</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/operator=</title>
    <ns>0</ns>
    <id>8586</id>
    <revision>
      <id>64857</id>
      <parentid>51389</parentid>
      <timestamp>2013-08-27T01:32:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=, fmt</comment>
      <text xml:space="preserve" bytes="1253">{{cpp/thread/packaged_task/title | operator{{=}}}}
{{cpp/thread/packaged_task/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
packaged_task&amp; operator=( const packaged_task&amp; ) = delete;
}}
{{dcl | num=2 | since=c++11 | 1=
packaged_task&amp; operator=( packaged_task&amp;&amp; rhs )
}}
{{dcl end}}

@1@ Copy assignment operator is deleted, {{tt|std::packaged_task}} is move-only.
Note: C++11 does not specify {{c|const}} here, this is the [http://lwg.github.com/issues/lwg-active.html#2067 defect 2067].
@2@ Releases the shared state, if any, destroys the previously-held task, and moves the shared state and the task owned by {{tt|rhs}} into {{c|*this}}. {{tt|rhs}} is left without a shared state and with a moved-from task.

===Parameters===
{{par begin}}
{{par | rhs | the {{tt|std::packaged_task}} to move from}}
{{par end}}

===Exceptions===
@1@ (none)

@2@ {{noexcept}}

===Example===
{{example
 | code=
| output=
}}

[[de:cpp/thread/packaged task/operator=]]
[[es:cpp/thread/packaged task/operator=]]
[[fr:cpp/thread/packaged task/operator=]]
[[it:cpp/thread/packaged task/operator=]]
[[ja:cpp/thread/packaged task/operator=]]
[[pt:cpp/thread/packaged task/operator=]]
[[ru:cpp/thread/packaged task/operator=]]
[[zh:cpp/thread/packaged task/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/packaged task</title>
    <ns>0</ns>
    <id>8585</id>
    <revision>
      <id>66197</id>
      <parentid>64858</parentid>
      <timestamp>2013-11-09T21:47:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="3290">{{cpp/thread/packaged_task/title | packaged_task}}
{{cpp/thread/packaged_task/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
packaged_task()
}}
{{dcl | num=2 | since=c++11 | 1=
template &lt;class F&gt;
explicit packaged_task( F&amp;&amp; f )
}}
{{dcl | num=3 | since=c++11 | 1=
template &lt;class F, class Allocator&gt;
explicit packaged_task( std::allocator_arg_t, const Allocator&amp; a, F&amp;&amp; f )
}}
{{dcl rev begin}}
{{dcl | num=4 | since=c++11 | until=c++14 | 1=
packaged_task( packaged_task&amp; ) = delete
}}
{{dcl | num=4 | since=c++14 | 1=
packaged_task( const packaged_task&amp; ) = delete
}}
{{dcl rev end}}
{{dcl | num=5 | since=c++11 | 1=
packaged_task( packaged_task&amp;&amp; rhs )
}}
{{dcl end}}

Constructs a new {{tt|std::packaged_task}} object.

@1@ Constructs a {{tt|std::packaged_task}} object with no task and no shared state.
@2@ Constructs a {{tt|std::packaged_task}} object with a shared state and a copy of the task, initialized with {{c|std::forward&lt;F&gt;(f)}}. This constructor does not participate in overload resolution if {{c|std::decay&lt;F&gt;::type}} is the same type as {{c|std::packaged_task&lt;R(ArgTypes...)&gt;}}.
@3@ Constructs a {{tt|std::packaged_task}} object with a shared state and a copy of the task, initialized with {{c|std::forward&lt;F&gt;(f)}}. Uses the provided allocator to allocate memory necessary to store the task. This constructor does not participate in overload resolution if {{c|std::decay&lt;F&gt;::type}} is the same type as {{c|std::packaged_task&lt;R(ArgTypes...)&gt;}}.
@4@ The copy constructor is deleted, {{tt|std::packaged_task}} is move-only.
@5@ Constructs a {{tt|std::packaged_task}} with the shared state and task formerly owned by {{tt|rhs}}, leaving {{tt|rhs}} with no shared state and a moved-from task.

===Parameters===
{{par begin}}
{{par | f | the callable target (function, member function, lambda-expression, functor) to execute}}
{{par | a | the allocator to use when storing the task}}
{{par | rhs | the {{tt|std::packaged_task}} to move from}}
{{par end}}

===Exceptions===
@1@ {{noexcept}}

@2-3@ Any exceptions thrown by copy/move constructor of {{tt|f}} and possiblly {{lc|std::bad_alloc}} if the allocation fails.

@4@ (none)

@5@ {{noexcept}}

===Example===
{{example
 | code=
#include &lt;future&gt;
#include &lt;iostream&gt;
#include &lt;thread&gt;

int fib(int n)
{
    if (n &lt; 3) return 1;
    else return fib(n-1) + fib(n-2);
}

int main()
{
    std::packaged_task&lt;int(int)&gt; fib_task(&amp;fib); 

    std::cout &lt;&lt; &quot;starting task\n&quot;;
    auto result = fib_task.get_future();
    std::thread t(std::move(fib_task), 40);

    std::cout &lt;&lt; &quot;waiting for task to finish...\n&quot;;
    std::cout &lt;&lt; result.get() &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;task complete\n&quot;;                                                                                                                                                                           
    t.join();
}
| output=
starting task
waiting for task to finish...
102334155
task complete
}}

[[de:cpp/thread/packaged task/packaged task]]
[[es:cpp/thread/packaged task/packaged task]]
[[fr:cpp/thread/packaged task/packaged task]]
[[it:cpp/thread/packaged task/packaged task]]
[[ja:cpp/thread/packaged task/packaged task]]
[[pt:cpp/thread/packaged task/packaged task]]
[[ru:cpp/thread/packaged task/packaged task]]
[[zh:cpp/thread/packaged task/packaged task]]</text>
      <sha1>6cq67ay95ain02u5g75l3zd49l2ntjs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/reset</title>
    <ns>0</ns>
    <id>8677</id>
    <revision>
      <id>69985</id>
      <parentid>63455</parentid>
      <timestamp>2014-05-04T22:17:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>example</comment>
      <text xml:space="preserve" bytes="1565">{{cpp/thread/packaged_task/title | reset}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
void reset();
}}

Resets the state abandoning the results of previous executions. New shared state is constructed.

Equivalent to {{c|1=*this = packaged_task(std::move(f))}}, where {{tt|f}} is the stored task.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
* {{lc|std::future_error}} if {{c|*this}} has no shared state. The error condition is set to {{ltt|cpp/thread/future_errc|no_state}}.
* {{lc|std::bad_alloc}} if there was not enough memory for a new shared state.
* any exception thrown by the [[cpp/thread/packaged_task/packaged_task | move constructor]] of the new {{tt|packaged_task}}

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;thread&gt;
#include &lt;future&gt;

int main()
{
    std::packaged_task&lt;int(int,int)&gt; task([](int a, int b) {
        return std::pow(a, b);
    });
    std::future&lt;int&gt; result = task.get_future();
    task(2, 9);
    std::cout &lt;&lt; &quot;2^9 = &quot; &lt;&lt; result.get() &lt;&lt; '\n';

    task.reset();
    result = task.get_future();
    std::thread task_td(std::move(task), 2, 10);
    task_td.join();
    std::cout &lt;&lt; &quot;2^10 = &quot; &lt;&lt; result.get() &lt;&lt; '\n';
}
|output=
2^9 = 512
2^10 = 1024
}}

[[de:cpp/thread/packaged task/reset]]
[[es:cpp/thread/packaged task/reset]]
[[fr:cpp/thread/packaged task/reset]]
[[it:cpp/thread/packaged task/reset]]
[[ja:cpp/thread/packaged task/reset]]
[[pt:cpp/thread/packaged task/reset]]
[[ru:cpp/thread/packaged task/reset]]
[[zh:cpp/thread/packaged task/reset]]</text>
      <sha1>pzpd9o6c3uxpcu6e4m6o6qyf7olie2e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/swap</title>
    <ns>0</ns>
    <id>8674</id>
    <revision>
      <id>63456</id>
      <parentid>59205</parentid>
      <timestamp>2013-07-10T01:32:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="764">{{cpp/thread/packaged_task/title | swap}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
void swap( packaged_task&amp; other );
}}

Exchanges the shared states and stored tasks of {{c|*this}} and {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | packaged task whose state to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/packaged task/swap]]
[[es:cpp/thread/packaged task/swap]]
[[fr:cpp/thread/packaged task/swap]]
[[it:cpp/thread/packaged task/swap]]
[[ja:cpp/thread/packaged task/swap]]
[[pt:cpp/thread/packaged task/swap]]
[[ru:cpp/thread/packaged task/swap]]
[[zh:cpp/thread/packaged task/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/swap2</title>
    <ns>0</ns>
    <id>5510</id>
    <revision>
      <id>64859</id>
      <parentid>59208</parentid>
      <timestamp>2013-08-27T01:33:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since=</comment>
      <text xml:space="preserve" bytes="1062">{{cpp/title | swap&lt;small&gt;(std::packaged_task)&lt;/small&gt;}}
{{cpp/thread/packaged_task/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class Function, class Args... &gt;
void swap( packaged_task&lt;Function(Args...)&gt; &amp;lhs, 
           packaged_task&lt;Function(Args...)&gt; &amp;rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::packaged_task}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | packaged tasks whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/packaged_task/dsc swap}}
{{dsc end}}

[[de:cpp/thread/packaged task/swap2]]
[[es:cpp/thread/packaged task/swap2]]
[[fr:cpp/thread/packaged task/swap2]]
[[it:cpp/thread/packaged task/swap2]]
[[ja:cpp/thread/packaged task/swap2]]
[[pt:cpp/thread/packaged task/swap2]]
[[ru:cpp/thread/packaged task/swap2]]
[[zh:cpp/thread/packaged task/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/uses allocator</title>
    <ns>0</ns>
    <id>6423</id>
    <revision>
      <id>63457</id>
      <parentid>61346</parentid>
      <timestamp>2013-07-10T01:32:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="847">{{cpp/title|uses_allocator{{small|&lt;std::packaged_task&gt;}}}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
template&lt; class R, class Alloc &gt;
struct uses_allocator&lt;std::packaged_task&lt;R&gt;, Alloc&gt; : true_type { };
}}

Provides a specialization of the {{lc|std::uses_allocator}} type trait for {{lc|std::packaged_task}}.

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses allocator}}
{{dsc end}}

[[de:cpp/thread/packaged task/uses allocator]]
[[es:cpp/thread/packaged task/uses allocator]]
[[fr:cpp/thread/packaged task/uses allocator]]
[[it:cpp/thread/packaged task/uses allocator]]
[[ja:cpp/thread/packaged task/uses allocator]]
[[pt:cpp/thread/packaged task/uses allocator]]
[[ru:cpp/thread/packaged task/uses allocator]]
[[zh:cpp/thread/packaged task/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/valid</title>
    <ns>0</ns>
    <id>8675</id>
    <revision>
      <id>63458</id>
      <parentid>43628</parentid>
      <timestamp>2013-07-10T01:32:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="622">{{cpp/thread/packaged_task/title | valid}}
{{cpp/thread/packaged_task/navbar}}
{{ddcl | since=c++11 |
bool valid() const;
}}

Checks whether {{c|*this}} has a shared state.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} has a shared state, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

[[de:cpp/thread/packaged task/valid]]
[[es:cpp/thread/packaged task/valid]]
[[fr:cpp/thread/packaged task/valid]]
[[it:cpp/thread/packaged task/valid]]
[[ja:cpp/thread/packaged task/valid]]
[[pt:cpp/thread/packaged task/valid]]
[[ru:cpp/thread/packaged task/valid]]
[[zh:cpp/thread/packaged task/valid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/packaged task/~packaged task</title>
    <ns>0</ns>
    <id>8587</id>
    <revision>
      <id>63835</id>
      <parentid>51395</parentid>
      <timestamp>2013-07-29T13:00:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to ~promise</comment>
      <text xml:space="preserve" bytes="865">{{cpp/thread/packaged_task/title | ~packaged_task}}
{{cpp/thread/packaged_task/navbar}}
{{dcl begin}}
{{dcl |1=
~packaged_task()
}}
{{dcl end}}

Abandons the shared state and destroys the stored task object.

As with {{lc|std::promise::~promise}}, if the shared state is abandoned before it was made ready, an {{lc|std::future_error}} exception is stored with the error code {{lc|std::future_errc::broken_promise}}).

===Parameters===
(none)

===Example===
{{example
 | code=
| output=
}}

[[de:cpp/thread/packaged task/~packaged task]]
[[es:cpp/thread/packaged task/~packaged task]]
[[fr:cpp/thread/packaged task/~packaged task]]
[[it:cpp/thread/packaged task/~packaged task]]
[[ja:cpp/thread/packaged task/~packaged task]]
[[pt:cpp/thread/packaged task/~packaged task]]
[[ru:cpp/thread/packaged task/~packaged task]]
[[zh:cpp/thread/packaged task/~packaged task]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise</title>
    <ns>0</ns>
    <id>2517</id>
    <revision>
      <id>72310</id>
      <parentid>72309</parentid>
      <timestamp>2014-08-07T14:23:18Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3058">{{cpp/title|promise}}
{{cpp/thread/promise/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; class promise;
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; class promise&lt;T&amp;&gt;;
}}
{{dcl | num=3 | since=c++11 |
template&lt;&gt;          class promise&lt;void&gt;;
}}
{{dcl end}}

@1@ base template
@2@ non-void specialization, used to communicate objects between threads
@3@ void specialization, used to communicate stateless events

The class template {{tt|std::promise}} provides a facility to store a value or an exception that is later acquired asynchronously via a {{lc|std::future}} object created by the {{tt|std::promise}} object.

Each promise is associated with a ''shared state'', which contains some state information and a ''result'' which may be not yet evaluated, evaluated to a value (possibly void) or evaluated to an exception. A promise may do three things with the shared state:
* ''make ready'': the promise stores the result or the exception in the shared state. marks the state ready and unblocks any thread waiting on a future associated with the shared state.
* ''release'': the promise gives up its reference to the shared state. If this was the last such reference, the shared state is destroyed. Unless this was a shared state created by {{c|std::async}} which is not yet ready, this operation does not block.
* ''abandon'': the promise stores the exception of type {{lc|std::future_error}} with error code {{lc|std::future_errc::broken_promise}}, makes the shared state ''ready'', and then ''releases'' it.

The promise is the &quot;push&quot; end of the promise-future communication channel: the operation that stores a value in the shared state ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) the successful return from any function that is waiting on the shared state (such as {{lc|std::future::get}}). Concurrent access to the same shared state may conflict otherwise: for example multiple callers of {{lc|std::shared_future::get}} must either all be read-only or provide external synchronization.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc constructor}}
{{dsc inc | cpp/thread/promise/dsc destructor}}
{{dsc inc | cpp/thread/promise/dsc operator{{=}}}}
{{dsc inc | cpp/thread/promise/dsc swap}}

{{dsc h2 | Getting the result}}
{{dsc inc | cpp/thread/promise/dsc get_future}}

{{dsc h2 | Setting the result}}
{{dsc inc | cpp/thread/promise/dsc set_value}}
{{dsc inc | cpp/thread/promise/dsc set_value_at_thread_exit}}
{{dsc inc | cpp/thread/promise/dsc set_exception}}
{{dsc inc | cpp/thread/promise/dsc set_exception_at_thread_exit}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc swap2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/thread/promise]]
[[es:cpp/thread/promise]]
[[fr:cpp/thread/promise]]
[[it:cpp/thread/promise]]
[[ja:cpp/thread/promise]]
[[pt:cpp/thread/promise]]
[[ru:cpp/thread/promise]]
[[zh:cpp/thread/promise]]</text>
      <sha1>ov24cik7d27xtg3c9s4n01yzdr3wks7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/get future</title>
    <ns>0</ns>
    <id>6447</id>
    <revision>
      <id>72311</id>
      <parentid>63459</parentid>
      <timestamp>2014-08-07T14:37:35Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1167">{{cpp/thread/promise/title | get_future}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
std::future&lt;R&gt; get_future();
}}

Returns a future object associated with the same shared state as {{c|*this}}. 

Exception is thrown if {{c|*this}} has no shared state or {{tt|get_future}} has already been called. To get multiple &quot;pop&quot; ends of the promise-future communication channel, use std::future::share.

===Parameters===
(none)

===Return value===
A future referring to the shared state of {{c|*this}}

===Exceptions===
{{lc|std::future_error}} on the following conditions:

* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

* {{tt|get_future()}} has already been called on a promise with the same shared state as {{c|*this}}. The error category is set to {{ltt|cpp/thread/future_errc|future_already_retrieved}}.

[[de:cpp/thread/promise/get future]]
[[es:cpp/thread/promise/get future]]
[[fr:cpp/thread/promise/get future]]
[[it:cpp/thread/promise/get future]]
[[ja:cpp/thread/promise/get future]]
[[pt:cpp/thread/promise/get future]]
[[ru:cpp/thread/promise/get future]]
[[zh:cpp/thread/promise/get future]]</text>
      <sha1>kb5i8kjculw2cjyor3lmywfe4omcjfe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/operator=</title>
    <ns>0</ns>
    <id>6427</id>
    <revision>
      <id>64294</id>
      <parentid>63834</parentid>
      <timestamp>2013-08-15T16:24:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1002">{{cpp/thread/promise/title | operator{{=}}}}
{{cpp/thread/promise/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
promise&amp; operator=( promise&amp;&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
promise&amp; operator=( const promise&amp; rhs ) = delete;
}}
{{dcl end}}

Assigns the contents.

@1@ Move assignment operator. First, abandons the shared state (as in {{lc|~promise()}}), then assigns the shared state of {{tt|other}} as if by executing {{c|std::promise(std::move(other)).swap(*this)}}.

@2@ {{tt|promise}} is not copy-assignable.

===Parameters===
{{par begin}}
{{par | other | another {{tt|promise}} to acquire the state from}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{noexcept}}

[[de:cpp/thread/promise/operator=]]
[[es:cpp/thread/promise/operator=]]
[[fr:cpp/thread/promise/operator=]]
[[it:cpp/thread/promise/operator=]]
[[ja:cpp/thread/promise/operator=]]
[[pt:cpp/thread/promise/operator=]]
[[ru:cpp/thread/promise/operator=]]
[[zh:cpp/thread/promise/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/promise</title>
    <ns>0</ns>
    <id>6425</id>
    <revision>
      <id>72284</id>
      <parentid>62978</parentid>
      <timestamp>2014-08-04T11:28:30Z</timestamp>
      <contributor>
        <username>K-ballo</username>
        <id>2143</id>
      </contributor>
      <text xml:space="preserve" bytes="1368">{{cpp/thread/promise/title | promise}}
{{cpp/thread/promise/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
promise();
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Alloc &gt;
promise( std::allocator_arg_t, const Alloc&amp; alloc );
}}
{{dcl | num=3 | since=c++11 |
promise( promise&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 | 1=
promise( const promise&amp; other ) = delete;
}}
{{dcl end}}

Constructs a {{tt|promise}} object.

@1@ Default constructor. Constructs the promise with an empty shared state.

@2@ Constructs the promise with an empty shared state. The shared state is allocated using {{tt|alloc}}. {{tt|Alloc}} must meet the requirements of {{concept|Allocator}}.

@3@ Move constructor. Constructs the promise with the shared state of {{tt|other}} using move semantics. After construction, {{tt|other}} has no shared state.

@4@ {{tt|promise}} is not copyable.

===Parameters===
{{par begin}}
{{par | alloc | allocator to use to allocate the shared state}}
{{par | other | another {{tt|promise}} to acquire the state from}}
{{par end}}

===Exceptions===
@1-2@ (none)
@3@ {{noexcept}}
`

[[de:cpp/thread/promise/promise]]
[[es:cpp/thread/promise/promise]]
[[fr:cpp/thread/promise/promise]]
[[it:cpp/thread/promise/promise]]
[[ja:cpp/thread/promise/promise]]
[[pt:cpp/thread/promise/promise]]
[[ru:cpp/thread/promise/promise]]
[[zh:cpp/thread/promise/promise]]</text>
      <sha1>1cxnwpy55o6vwfl03ir41fqmv1s3tsx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/set exception</title>
    <ns>0</ns>
    <id>6450</id>
    <revision>
      <id>63460</id>
      <parentid>62034</parentid>
      <timestamp>2013-07-10T01:32:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2128">{{cpp/thread/promise/title | set_exception}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
void set_exception( std::exception_ptr p );
}}

Stores the exception pointer {{tt|p}} into the shared state and makes the state ready. 

The operation is atomic, i.e. it behaves as though they acquire a single mutex associated with the promise object while updating the promise object.

An exception is thrown if there is no shared state or the shared state already stores a value or exception.

===Parameters===
{{par begin}}
{{par | p | exception pointer to store}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following conditions:

* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

* The shared state already stores a value or exception. The error category is set to {{ltt|cpp/thread/future_errc|promise_already_satisfied}}.

===Example===
{{example
 | code=
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;future&gt;

int main()
{
    std::promise&lt;int&gt; result;

    std::thread t([&amp;]{
            try {
                // code that may throw
                throw std::runtime_error(&quot;Example&quot;);
            } catch(...) {
                try {
                    // store anything thrown in the promise
                    result.set_exception(std::current_exception());
                } catch(...) {} // set_exception() may throw too
            }
    });

    try {
        std::cout &lt;&lt; result.get_future().get();
    } catch(const std::exception&amp; e) {
        std::cout &lt;&lt; &quot;Exception from the thread: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    }
    t.join();
}
 | output=
Exception from the thread: Example
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc set_exception_at_thread_exit}}
{{dsc end}}

[[de:cpp/thread/promise/set exception]]
[[es:cpp/thread/promise/set exception]]
[[fr:cpp/thread/promise/set exception]]
[[it:cpp/thread/promise/set exception]]
[[ja:cpp/thread/promise/set exception]]
[[pt:cpp/thread/promise/set exception]]
[[ru:cpp/thread/promise/set exception]]
[[zh:cpp/thread/promise/set exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/set exception at thread exit</title>
    <ns>0</ns>
    <id>6451</id>
    <revision>
      <id>63461</id>
      <parentid>59216</parentid>
      <timestamp>2013-07-10T01:32:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1687">{{cpp/thread/promise/title | set_exception_at_thread_exit}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
void set_exception_at_thread_exit( std::exception_ptr p );
}}

Stores the exception pointer {{tt|p}} into the shared state without making the state ready immediately. The state is made ready when the current thread exits, after all variables with thread-local storage duration have been destroyed.  

The operation is atomic, i.e. it behaves as though they acquire a single mutex associated with the promise object while updating the promise object.

An exception is thrown if there is no shared state or the shared state already stores a value or exception.

===Parameters===
{{par begin}}
{{par | p | exception pointer to store}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following conditions:

* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

* The shared state already stores a value or exception. The error category is set to {{ltt|cpp/thread/future_errc|promise_already_satisfied}}.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc set_exception}}
{{dsc end}}

[[de:cpp/thread/promise/set exception at thread exit]]
[[es:cpp/thread/promise/set exception at thread exit]]
[[fr:cpp/thread/promise/set exception at thread exit]]
[[it:cpp/thread/promise/set exception at thread exit]]
[[ja:cpp/thread/promise/set exception at thread exit]]
[[pt:cpp/thread/promise/set exception at thread exit]]
[[ru:cpp/thread/promise/set exception at thread exit]]
[[zh:cpp/thread/promise/set exception at thread exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/set value</title>
    <ns>0</ns>
    <id>6448</id>
    <revision>
      <id>67103</id>
      <parentid>59217</parentid>
      <timestamp>2014-01-22T18:27:08Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <comment>Added example</comment>
      <text xml:space="preserve" bytes="3941">{{cpp/thread/promise/title | set_value}}
{{cpp/thread/promise/navbar}}
{{dcl begin}}
{{dcl | num=1 | notes={{mark|member only of generic {{tt|promise}} template}}&lt;br&gt;{{mark since c++11}} |
void set_value( const R&amp; value );
}}
{{dcl | num=2 | notes={{mark|member only of generic {{tt|promise}} template}}&lt;br&gt;{{mark since c++11}} |
void set_value( R&amp;&amp; value );
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|promise&lt;R&amp;&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void set_value( R&amp; value );
}}
{{dcl | num=4 | notes={{mark|member only of {{tt|promise&lt;void&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void set_value()
}}
{{dcl end}}

Stores the {{tt|value}} into the shared state and makes the state ready. 

The operation is atomic, i.e. it behaves as though they acquire a single mutex associated with the promise object while updating the promise object.

An exception is thrown if there is no shared state or the shared state already stores a value or exception.

===Parameters===
{{par begin}}
{{par | value | value to store in the shared state}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following conditions:

* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

* The shared state already stores a value or exception. The error category is set to {{ltt|cpp/thread/future_errc|promise_already_satisfied}}.

Additionally:

@1-2@ Any exception thrown by the copy constructor of {{tt|value}}
@3@ Any exception thrown by the move constructor of {{tt|value}}

===Example===
{{example |
This example shows how {{tt|promise&lt;void&gt;}} can be used as signals between threads.
 | code=
#include &lt;thread&gt;
#include &lt;future&gt;
#include &lt;cctype&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;iterator&gt;
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::istringstream iss_numbers{&quot;3 4 1 42 23 -23 93 2 -289 93&quot;};
    std::istringstream iss_letters{&quot; a 23 b,e a2 k k?a;si,ksa c&quot;};

    std::vector&lt;int&gt; numbers;
    std::vector&lt;char&gt; letters;
    std::promise&lt;void&gt; numbers_promise, letters_promise;

    auto numbers_ready = numbers_promise.get_future();
    auto letter_ready = letters_promise.get_future();

    std::thread value_reader([&amp;]
    {
        // I/O operations.
        std::copy(std::istream_iterator&lt;int&gt;{iss_numbers},
                  std::istream_iterator&lt;int&gt;{},
                  std::back_inserter(numbers));

        //Notify for numbers.
        numbers_promise.set_value();

        std::copy_if(std::istreambuf_iterator&lt;char&gt;{iss_letters},
                     std::istreambuf_iterator&lt;char&gt;{},
                     std::back_inserter(letters),
                     ::isalpha);

        //Notify for letters.
        letters_promise.set_value();
    });


    numbers_ready.wait();

    std::sort(numbers.begin(), numbers.end());

    if (letter_ready.wait_for(std::chrono::seconds(1)) ==
            std::future_status::timeout)
    {
        //output the numbers while letters are being obtained.
        for (int num : numbers) std::cout &lt;&lt; num &lt;&lt; ' ';
        numbers.clear(); //Numbers were already printed.
    }

    letter_ready.wait();
    std::sort(letters.begin(), letters.end());

    //If numbers were already printed, it does nothing.
    for (int num : numbers) std::cout &lt;&lt; num &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    for (char let : letters) std::cout &lt;&lt; let &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    value_reader.join();
}
 | output=
-289 -23 1 2 3 4 23 42 93 93 
a a a a b c e i k k k s s 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc set_exception}}
{{dsc end}}

[[de:cpp/thread/promise/set value]]
[[es:cpp/thread/promise/set value]]
[[fr:cpp/thread/promise/set value]]
[[it:cpp/thread/promise/set value]]
[[ja:cpp/thread/promise/set value]]
[[pt:cpp/thread/promise/set value]]
[[ru:cpp/thread/promise/set value]]
[[zh:cpp/thread/promise/set value]]</text>
      <sha1>l6drcbbk8rimu0mhiz3muglv48fspjf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/set value at thread exit</title>
    <ns>0</ns>
    <id>6449</id>
    <revision>
      <id>59220</id>
      <parentid>51403</parentid>
      <timestamp>2013-06-01T06:28:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2358">{{cpp/thread/promise/title | set_value_at_thread_exit}}
{{cpp/thread/promise/navbar}}
{{dcl begin}}
{{dcl | num=1 | notes={{mark|member only of generic {{tt|promise}} template}}&lt;br&gt;{{mark since c++11}} |
void set_value_at_thread_exit( const R&amp; value );
}}
{{dcl | num=2 | notes={{mark|member only of generic {{tt|promise}} template}}&lt;br&gt;{{mark since c++11}} |
void set_value_at_thread_exit( R&amp;&amp; value );
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|promise&lt;R&amp;&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void set_value_at_thread_exit( R&amp; value );
}}
{{dcl | num=4 | notes={{mark|member only of {{tt|promise&lt;void&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void set_value_at_thread_exit()
}}
{{dcl end}}

Stores the {{tt|value}} into the shared state without making the state ready immediately. The state is made ready when the current thread exits, after all variables with thread-local storage duration have been destroyed.

The operation is atomic, i.e. it behaves as though they acquire a single mutex associated with the promise object while updating the promise object.

An exception is thrown if there is no shared state or the shared state already stores a value or exception.

===Parameters===
{{par begin}}
{{par | value | value to store in the shared state}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::future_error}} on the following conditions:

* {{c|*this}} has no shared state. The error category is set to {{ltt|cpp/thread/future_errc|no_state}}.

* The shared state already stores a value or exception. The error category is set to {{ltt|cpp/thread/future_errc|promise_already_satisfied}}.

Additionally:

@1-2@ Any exception thrown by the copy constructor of {{tt|value}}
@3@ Any exception thrown by the move constructor of {{tt|value}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc set_value}}
{{dsc end}}

[[de:cpp/thread/promise/set value at thread exit]]
[[es:cpp/thread/promise/set value at thread exit]]
[[fr:cpp/thread/promise/set value at thread exit]]
[[it:cpp/thread/promise/set value at thread exit]]
[[ja:cpp/thread/promise/set value at thread exit]]
[[pt:cpp/thread/promise/set value at thread exit]]
[[ru:cpp/thread/promise/set value at thread exit]]
[[zh:cpp/thread/promise/set value at thread exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/swap</title>
    <ns>0</ns>
    <id>6428</id>
    <revision>
      <id>63462</id>
      <parentid>59221</parentid>
      <timestamp>2013-07-10T01:33:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="701">{{cpp/thread/promise/title|swap}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
void swap( promise&amp; other );
}}

Exchanges the shared states of two promise objects.

===Parameters===
{{par begin}}
{{par | other | the promise to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/promise/swap]]
[[es:cpp/thread/promise/swap]]
[[fr:cpp/thread/promise/swap]]
[[it:cpp/thread/promise/swap]]
[[ja:cpp/thread/promise/swap]]
[[pt:cpp/thread/promise/swap]]
[[ru:cpp/thread/promise/swap]]
[[zh:cpp/thread/promise/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/swap2</title>
    <ns>0</ns>
    <id>5511</id>
    <revision>
      <id>63463</id>
      <parentid>59222</parentid>
      <timestamp>2013-07-10T01:33:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="904">{{cpp/title | swap&lt;small&gt;(std::promise)&lt;/small&gt;}}
{{cpp/thread/promise/navbar}}
{{ddcl | header=future | since=c++11 |
template&lt; class R &gt;
void swap( promise&lt;R&gt; &amp;lhs, promise&lt;R&gt; &amp;rhs );
}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::promise}}. Exchanges the shared state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | promises whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/promise/dsc swap}}
{{dsc end}}

[[de:cpp/thread/promise/swap2]]
[[es:cpp/thread/promise/swap2]]
[[fr:cpp/thread/promise/swap2]]
[[it:cpp/thread/promise/swap2]]
[[ja:cpp/thread/promise/swap2]]
[[pt:cpp/thread/promise/swap2]]
[[ru:cpp/thread/promise/swap2]]
[[zh:cpp/thread/promise/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/uses allocator</title>
    <ns>0</ns>
    <id>6424</id>
    <revision>
      <id>63464</id>
      <parentid>61348</parentid>
      <timestamp>2013-07-10T01:33:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="780">{{cpp/title|uses_allocator{{small|&lt;std::promise&gt;}}}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
template&lt; class R, class Alloc &gt;
struct uses_allocator&lt;std::promise&lt;R&gt;, Alloc&gt; : std::true_type { };
}}

Provides a specialization of the {{lc|std::uses_allocator}} type trait for {{lc|std::promise}}.

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses allocator}}
{{dsc end}}

[[de:cpp/thread/promise/uses allocator]]
[[es:cpp/thread/promise/uses allocator]]
[[fr:cpp/thread/promise/uses allocator]]
[[it:cpp/thread/promise/uses allocator]]
[[ja:cpp/thread/promise/uses allocator]]
[[pt:cpp/thread/promise/uses allocator]]
[[ru:cpp/thread/promise/uses allocator]]
[[zh:cpp/thread/promise/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/promise/~promise</title>
    <ns>0</ns>
    <id>6426</id>
    <revision>
      <id>63836</id>
      <parentid>63833</parentid>
      <timestamp>2013-07-29T13:02:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to broken_promise and fmt</comment>
      <text xml:space="preserve" bytes="669">{{cpp/thread/promise/title | ~promise}}
{{cpp/thread/promise/navbar}}
{{ddcl | since=c++11 |
~promise();
}}

Abandons the shared state:
* if the shared state is ready, releases it.
* if the shared state is not ready, stores an exception object of type {{lc|std::future_error}} with an error condition {{lc|std::future_errc::broken_promise}}, makes the shared state ready and releases it.


[[de:cpp/thread/promise/~promise]]
[[es:cpp/thread/promise/~promise]]
[[fr:cpp/thread/promise/~promise]]
[[it:cpp/thread/promise/~promise]]
[[ja:cpp/thread/promise/~promise]]
[[pt:cpp/thread/promise/~promise]]
[[ru:cpp/thread/promise/~promise]]
[[zh:cpp/thread/promise/~promise]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex</title>
    <ns>0</ns>
    <id>2301</id>
    <revision>
      <id>67038</id>
      <parentid>65479</parentid>
      <timestamp>2014-01-18T13:55:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+dtor and operator=</comment>
      <text xml:space="preserve" bytes="2681">{{cpp/title|recursive_mutex}}
{{cpp/thread/recursive_mutex/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
class recursive_mutex;
}}

The {{tt|recursive_mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

{{tt|recursive_mutex}} offers exclusive, recursive ownership semantics:

* A calling thread ''owns'' a {{tt|recursive_mutex}} for a period of time that starts when it successfully calls either [[cpp/thread/recursive_mutex/lock|{{tt|lock}}]] or [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]].  During this period, the thread may make additional calls to [[cpp/thread/recursive_mutex/lock|{{tt|lock}}]] or [[cpp/thread/recursive_mutex/try_lock|{{tt|try_lock}}]].  The period of ownership ends when the thread makes a matching number of calls to [[cpp/thread/recursive_mutex/unlock|{{tt|unlock}}]].
* When a thread owns a {{tt|recursive_mutex}}, all other threads will block (for calls to [[cpp/thread/recursive_mutex/lock|{{tt|lock}}]]) or receive a {{c|false}} return value (for [[cpp/thread/recursive_mutex/try_lock|{{tt|try_lock}}]]) if they attempt to claim ownership of the {{tt|recursive_mutex}}.
* The maximum number of times that a {{tt|recursive_mutex}} may be locked is unspecified, but after that number is reached, calls to [[cpp/thread/recursive_mutex/lock|{{tt|lock}}]] will throw {{lc|std::system_error}} and calls to [[cpp/thread/mutex/try_lock|{{tt|try_lock}}]] will return {{c|false}}.

The behavior of a program is undefined if a {{tt|recursive_mutex}} is destroyed while still owned by some thread.  The {{tt|recursive_mutex}} class satisfies all requiremenets of {{concept|Mutex}} and {{concept|StandardLayoutType}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | recursive_mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | recursive_mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Locking}}
{{dsc inc | cpp/thread/mutex/dsc lock | recursive_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | recursive_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | recursive_mutex}}

{{dsc h2 | Native handle}}
{{dsc inc | cpp/thread/mutex/dsc native_handle | recursive_mutex}}
{{dsc end}}

[[de:cpp/thread/recursive mutex]]
[[es:cpp/thread/recursive mutex]]
[[fr:cpp/thread/recursive mutex]]
[[it:cpp/thread/recursive mutex]]
[[ja:cpp/thread/recursive mutex]]
[[pt:cpp/thread/recursive mutex]]
[[ru:cpp/thread/recursive mutex]]
[[zh:cpp/thread/recursive mutex]]</text>
      <sha1>gqk6mkxg3dey3am99g0gkxhex12ltjq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/lock</title>
    <ns>0</ns>
    <id>2333</id>
    <revision>
      <id>51408</id>
      <parentid>43532</parentid>
      <timestamp>2013-06-01T04:01:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="367">{{include page|cpp/thread/mutex/lock|recursive_mutex}}

[[de:cpp/thread/recursive mutex/lock]]
[[es:cpp/thread/recursive mutex/lock]]
[[fr:cpp/thread/recursive mutex/lock]]
[[it:cpp/thread/recursive mutex/lock]]
[[ja:cpp/thread/recursive mutex/lock]]
[[pt:cpp/thread/recursive mutex/lock]]
[[ru:cpp/thread/recursive mutex/lock]]
[[zh:cpp/thread/recursive mutex/lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/native handle</title>
    <ns>0</ns>
    <id>2336</id>
    <revision>
      <id>51409</id>
      <parentid>43525</parentid>
      <timestamp>2013-06-01T04:01:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{include page|cpp/thread/mutex/native_handle|recursive_mutex}}

[[de:cpp/thread/recursive mutex/native handle]]
[[es:cpp/thread/recursive mutex/native handle]]
[[fr:cpp/thread/recursive mutex/native handle]]
[[it:cpp/thread/recursive mutex/native handle]]
[[ja:cpp/thread/recursive mutex/native handle]]
[[pt:cpp/thread/recursive mutex/native handle]]
[[ru:cpp/thread/recursive mutex/native handle]]
[[zh:cpp/thread/recursive mutex/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/recursive mutex</title>
    <ns>0</ns>
    <id>4490</id>
    <revision>
      <id>51410</id>
      <parentid>43519</parentid>
      <timestamp>2013-06-01T04:01:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="462">{{include page|cpp/thread/mutex/constructor|recursive_mutex}}

[[de:cpp/thread/recursive mutex/recursive mutex]]
[[es:cpp/thread/recursive mutex/recursive mutex]]
[[fr:cpp/thread/recursive mutex/recursive mutex]]
[[it:cpp/thread/recursive mutex/recursive mutex]]
[[ja:cpp/thread/recursive mutex/recursive mutex]]
[[pt:cpp/thread/recursive mutex/recursive mutex]]
[[ru:cpp/thread/recursive mutex/recursive mutex]]
[[zh:cpp/thread/recursive mutex/recursive mutex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/try lock</title>
    <ns>0</ns>
    <id>2334</id>
    <revision>
      <id>51411</id>
      <parentid>43512</parentid>
      <timestamp>2013-06-01T04:02:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/thread/mutex/try_lock|recursive_mutex}}

[[de:cpp/thread/recursive mutex/try lock]]
[[es:cpp/thread/recursive mutex/try lock]]
[[fr:cpp/thread/recursive mutex/try lock]]
[[it:cpp/thread/recursive mutex/try lock]]
[[ja:cpp/thread/recursive mutex/try lock]]
[[pt:cpp/thread/recursive mutex/try lock]]
[[ru:cpp/thread/recursive mutex/try lock]]
[[zh:cpp/thread/recursive mutex/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/unlock</title>
    <ns>0</ns>
    <id>2335</id>
    <revision>
      <id>51412</id>
      <parentid>43504</parentid>
      <timestamp>2013-06-01T04:02:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="385">{{include page|cpp/thread/mutex/unlock|recursive_mutex}}

[[de:cpp/thread/recursive mutex/unlock]]
[[es:cpp/thread/recursive mutex/unlock]]
[[fr:cpp/thread/recursive mutex/unlock]]
[[it:cpp/thread/recursive mutex/unlock]]
[[ja:cpp/thread/recursive mutex/unlock]]
[[pt:cpp/thread/recursive mutex/unlock]]
[[ru:cpp/thread/recursive mutex/unlock]]
[[zh:cpp/thread/recursive mutex/unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive mutex/~recursive mutex</title>
    <ns>0</ns>
    <id>13125</id>
    <revision>
      <id>67043</id>
      <timestamp>2014-01-18T14:00:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fwd to template</comment>
      <text xml:space="preserve" bytes="60">{{include page|cpp/thread/mutex/destructor|recursive_mutex}}</text>
      <sha1>9waigs7jrkaa5yskafgo27ep3eq7ifc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex</title>
    <ns>0</ns>
    <id>2303</id>
    <revision>
      <id>67041</id>
      <parentid>65483</parentid>
      <timestamp>2014-01-18T13:58:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+dtor/op=</comment>
      <text xml:space="preserve" bytes="2076">{{cpp/title|recursive_timed_mutex}}
{{cpp/thread/recursive_timed_mutex/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
class recursive_timed_mutex;
}}

The {{tt|recursive_timed_mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads.

In a manner similar to {{c|std::thread::recursive_mutex}}, {{tt|recursive_timed_mutex}} provides exclusive, recursive ownership semantics.  In addition, {{tt|recursive_timed_mutex}} provides the ability to attempt to claim ownership of a {{tt|recursive_timed_mutex}} with a timeout via the [[cpp/thread/recursive_timed_mutex/try_lock_for|{{tt|try_lock_for}}]] and [[cpp/thread/recursive_timed_mutex/try_lock_until|{{tt|try_lock_until}}]] methods.

The {{tt|recursive_timed_mutex}} class satisfies all requirements of {{concept|TimedMutex}} and {{concept|StandardLayoutType}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Locking}}
{{dsc inc | cpp/thread/mutex/dsc lock | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | recursive_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | recursive_timed_mutex}}

{{dsc h2 | Native handle}}
{{dsc inc | cpp/thread/mutex/dsc native_handle | recursive_timed_mutex}}
{{dsc end}}

[[de:cpp/thread/recursive timed mutex]]
[[es:cpp/thread/recursive timed mutex]]
[[fr:cpp/thread/recursive timed mutex]]
[[it:cpp/thread/recursive timed mutex]]
[[ja:cpp/thread/recursive timed mutex]]
[[pt:cpp/thread/recursive timed mutex]]
[[ru:cpp/thread/recursive timed mutex]]
[[zh:cpp/thread/recursive timed mutex]]</text>
      <sha1>jzs7xyd0m5vl77jm4txbmr8i0dfgv66</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/lock</title>
    <ns>0</ns>
    <id>2323</id>
    <revision>
      <id>51414</id>
      <parentid>43493</parentid>
      <timestamp>2013-06-01T04:02:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="421">{{include page|cpp/thread/mutex/lock|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/lock]]
[[es:cpp/thread/recursive timed mutex/lock]]
[[fr:cpp/thread/recursive timed mutex/lock]]
[[it:cpp/thread/recursive timed mutex/lock]]
[[ja:cpp/thread/recursive timed mutex/lock]]
[[pt:cpp/thread/recursive timed mutex/lock]]
[[ru:cpp/thread/recursive timed mutex/lock]]
[[zh:cpp/thread/recursive timed mutex/lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/native handle</title>
    <ns>0</ns>
    <id>2328</id>
    <revision>
      <id>51415</id>
      <parentid>43486</parentid>
      <timestamp>2013-06-01T04:02:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="502">{{include page|cpp/thread/mutex/native_handle|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/native handle]]
[[es:cpp/thread/recursive timed mutex/native handle]]
[[fr:cpp/thread/recursive timed mutex/native handle]]
[[it:cpp/thread/recursive timed mutex/native handle]]
[[ja:cpp/thread/recursive timed mutex/native handle]]
[[pt:cpp/thread/recursive timed mutex/native handle]]
[[ru:cpp/thread/recursive timed mutex/native handle]]
[[zh:cpp/thread/recursive timed mutex/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/recursive timed mutex</title>
    <ns>0</ns>
    <id>4491</id>
    <revision>
      <id>51416</id>
      <parentid>43479</parentid>
      <timestamp>2013-06-01T04:02:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="564">{{include page|cpp/thread/mutex/constructor|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[es:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[fr:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[it:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[ja:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[pt:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[ru:cpp/thread/recursive timed mutex/recursive timed mutex]]
[[zh:cpp/thread/recursive timed mutex/recursive timed mutex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/try lock</title>
    <ns>0</ns>
    <id>2324</id>
    <revision>
      <id>51417</id>
      <parentid>43472</parentid>
      <timestamp>2013-06-01T04:02:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="457">{{include page|cpp/thread/mutex/try_lock|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/try lock]]
[[es:cpp/thread/recursive timed mutex/try lock]]
[[fr:cpp/thread/recursive timed mutex/try lock]]
[[it:cpp/thread/recursive timed mutex/try lock]]
[[ja:cpp/thread/recursive timed mutex/try lock]]
[[pt:cpp/thread/recursive timed mutex/try lock]]
[[ru:cpp/thread/recursive timed mutex/try lock]]
[[zh:cpp/thread/recursive timed mutex/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/try lock for</title>
    <ns>0</ns>
    <id>2325</id>
    <revision>
      <id>51418</id>
      <parentid>43465</parentid>
      <timestamp>2013-06-01T04:02:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="493">{{include page|cpp/thread/mutex/try_lock_for|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/try lock for]]
[[es:cpp/thread/recursive timed mutex/try lock for]]
[[fr:cpp/thread/recursive timed mutex/try lock for]]
[[it:cpp/thread/recursive timed mutex/try lock for]]
[[ja:cpp/thread/recursive timed mutex/try lock for]]
[[pt:cpp/thread/recursive timed mutex/try lock for]]
[[ru:cpp/thread/recursive timed mutex/try lock for]]
[[zh:cpp/thread/recursive timed mutex/try lock for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/try lock until</title>
    <ns>0</ns>
    <id>2326</id>
    <revision>
      <id>51419</id>
      <parentid>43457</parentid>
      <timestamp>2013-06-01T04:02:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="511">{{include page|cpp/thread/mutex/try_lock_until|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/try lock until]]
[[es:cpp/thread/recursive timed mutex/try lock until]]
[[fr:cpp/thread/recursive timed mutex/try lock until]]
[[it:cpp/thread/recursive timed mutex/try lock until]]
[[ja:cpp/thread/recursive timed mutex/try lock until]]
[[pt:cpp/thread/recursive timed mutex/try lock until]]
[[ru:cpp/thread/recursive timed mutex/try lock until]]
[[zh:cpp/thread/recursive timed mutex/try lock until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/unlock</title>
    <ns>0</ns>
    <id>2327</id>
    <revision>
      <id>51420</id>
      <parentid>43450</parentid>
      <timestamp>2013-06-01T04:02:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="439">{{include page|cpp/thread/mutex/unlock|recursive_timed_mutex}}

[[de:cpp/thread/recursive timed mutex/unlock]]
[[es:cpp/thread/recursive timed mutex/unlock]]
[[fr:cpp/thread/recursive timed mutex/unlock]]
[[it:cpp/thread/recursive timed mutex/unlock]]
[[ja:cpp/thread/recursive timed mutex/unlock]]
[[pt:cpp/thread/recursive timed mutex/unlock]]
[[ru:cpp/thread/recursive timed mutex/unlock]]
[[zh:cpp/thread/recursive timed mutex/unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/recursive timed mutex/~recursive timed mutex</title>
    <ns>0</ns>
    <id>13127</id>
    <revision>
      <id>67045</id>
      <timestamp>2014-01-18T14:01:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fwd to template</comment>
      <text xml:space="preserve" bytes="66">{{include page|cpp/thread/mutex/destructor|recursive_timed_mutex}}</text>
      <sha1>lgn81npk2in5hq5f20iyvhks18fcoxj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future</title>
    <ns>0</ns>
    <id>2519</id>
    <revision>
      <id>62979</id>
      <parentid>61430</parentid>
      <timestamp>2013-07-01T23:48:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2983">{{cpp/title|shared_future}}
{{cpp/thread/shared_future/navbar}}
{{dcl begin}}
{{dcl header | future}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; class shared_future;
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; class shared_future&lt;T&amp;&gt;;
}}
{{dcl | num=3 | since=c++11 |
template&lt;&gt;          class shared_future&lt;void&gt;;
}}
{{dcl end}}

{{todo}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/thread/shared_future/shared_future | constructs the future object}}
{{dsc mem dtor | cpp/thread/shared_future/~shared_future | destructs the future object}}
{{dsc mem fun | cpp/thread/shared_future/operator{{=}} | assigns the contents}}

{{dsc h2 | Getting the result}}
{{dsc inc | cpp/thread/future/dsc get | shared_future}}

{{dsc h2 | State}}
{{dsc inc | cpp/thread/future/dsc valid | shared_future}}
{{dsc inc | cpp/thread/future/dsc wait | shared_future}}
{{dsc inc | cpp/thread/future/dsc wait_for | shared_future}}
{{dsc inc | cpp/thread/future/dsc wait_until | shared_future}}
{{dsc end}}

===Example===
{{example|A {{tt|shared_future}} may be used to signal multiple threads simultaneously, similar to {{lc|std::condition_variable::notify_all()}}
|code=
#include &lt;iostream&gt;
#include &lt;future&gt;
#include &lt;chrono&gt;

int main()
{   
    std::promise&lt;void&gt; ready_promise, t1_ready_promise, t2_ready_promise;
    std::shared_future&lt;void&gt; ready_future(ready_promise.get_future());

    std::chrono::time_point&lt;std::chrono::high_resolution_clock&gt; start;

    auto fun1 = [&amp;]() -&gt; std::chrono::duration&lt;double, std::milli&gt; 
    {
        t1_ready_promise.set_value();
        ready_future.wait(); // waits for the signal from main()
        return std::chrono::high_resolution_clock::now() - start;
    };


    auto fun2 = [&amp;]() -&gt; std::chrono::duration&lt;double, std::milli&gt; 
    {
        t2_ready_promise.set_value();
        ready_future.wait(); // waits for the signal from main()
        return std::chrono::high_resolution_clock::now() - start;
    };

    auto result1 = std::async(std::launch::async, fun1);
    auto result2 = std::async(std::launch::async, fun2);

    // wait for the threads to become ready
    t1_ready_promise.get_future().wait();
    t2_ready_promise.get_future().wait();

    // the threads are ready, start the clock
    start = std::chrono::high_resolution_clock::now();

    // signal the threads to go
    ready_promise.set_value();

    std::cout &lt;&lt; &quot;Thread 1 received the signal &quot;
              &lt;&lt; result1.get().count() &lt;&lt; &quot; ms after start\n&quot;
              &lt;&lt; &quot;Thread 2 received the signal &quot;
              &lt;&lt; result2.get().count() &lt;&lt; &quot; ms after start\n&quot;;
}
|p=true
|output=
Thread 1 received the signal 0.072 ms after start
Thread 2 received the signal 0.041 ms after start
}}

[[de:cpp/thread/shared future]]
[[es:cpp/thread/shared future]]
[[fr:cpp/thread/shared future]]
[[it:cpp/thread/shared future]]
[[ja:cpp/thread/shared future]]
[[pt:cpp/thread/shared future]]
[[ru:cpp/thread/shared future]]
[[zh:cpp/thread/shared future]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/get</title>
    <ns>0</ns>
    <id>6459</id>
    <revision>
      <id>51422</id>
      <parentid>43440</parentid>
      <timestamp>2013-06-01T04:02:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="341">{{include page|cpp/thread/future/get|shared_future}}

[[de:cpp/thread/shared future/get]]
[[es:cpp/thread/shared future/get]]
[[fr:cpp/thread/shared future/get]]
[[it:cpp/thread/shared future/get]]
[[ja:cpp/thread/shared future/get]]
[[pt:cpp/thread/shared future/get]]
[[ru:cpp/thread/shared future/get]]
[[zh:cpp/thread/shared future/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/operator=</title>
    <ns>0</ns>
    <id>8702</id>
    <revision>
      <id>64053</id>
      <parentid>62980</parentid>
      <timestamp>2013-08-07T16:19:07Z</timestamp>
      <contributor>
        <ip>82.150.248.29</ip>
      </contributor>
      <comment>The description was blindly copied from constructor and made no sense at all.</comment>
      <text xml:space="preserve" bytes="809">{{cpp/thread/shared_future/title | operator{{=}}}}
{{cpp/thread/shared_future/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
shared_future&amp; operator{{=}}(const shared_future&amp; rhs);
}}
{{dcl | num=2 | since=c++11 |
shared_future&amp; operator{{=}}(shared_future&amp;&amp; rhs) noexcept;
}}
{{dcl | num=3 | since=c++11 |
shared_future&amp; operator{{=}}(future&lt;R&gt;&amp;&amp; other);
}}
{{dcl | num=4 | since=c++11 |
shared_future&amp; operator{{=}}(shared_future&amp;&amp; other);
}}
{{dcl end}}

{{todo}}

[[de:cpp/thread/shared future/operator=]]
[[es:cpp/thread/shared future/operator=]]
[[fr:cpp/thread/shared future/operator=]]
[[it:cpp/thread/shared future/operator=]]
[[ja:cpp/thread/shared future/operator=]]
[[pt:cpp/thread/shared future/operator=]]
[[ru:cpp/thread/shared future/operator=]]
[[zh:cpp/thread/shared future/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/shared future</title>
    <ns>0</ns>
    <id>8698</id>
    <revision>
      <id>62981</id>
      <parentid>62010</parentid>
      <timestamp>2013-07-01T23:48:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1457">{{cpp/thread/shared_future/title | shared_future}}
{{cpp/thread/shared_future/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
shared_future();
}}
{{dcl | num=2 | since=c++11 |
shared_future( const shared_future&amp; other );
}}
{{dcl | num=3 | since=c++11 |
shared_future( future&lt;R&gt;&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 |
shared_future( shared_future&amp;&amp; other );
}}
{{dcl end}}

Constructs a new {{tt|shared_future}}.

@begin@
@1@ Default constructor. Constructs an empty shared future, that doesn't refer to a shared state, that is {{c|1=valid() == false}}.
@2@ Constructs a shared future that refers to the same shared state, as {{tt|other}}, if there's any.
@3-4@ Move constructor. Transfers the shared state held by {{tt|other}} to {{c|*this}}. After the construction, {{c|1=other-&gt;valid() == false}}, also {{c|valid()}} returns the same value as {{c|other.valid()}} would have returned before the construction.

===Parameters===
{{par begin}}
{{par | other | another future object to initialize with}}
{{par end}}

===Exceptions===
@1@ {{noexcept}}
@2@ (none)
@3-4@ {{noexcept}}

[[de:cpp/thread/shared future/shared future]]
[[es:cpp/thread/shared future/shared future]]
[[fr:cpp/thread/shared future/shared future]]
[[it:cpp/thread/shared future/shared future]]
[[ja:cpp/thread/shared future/shared future]]
[[pt:cpp/thread/shared future/shared future]]
[[ru:cpp/thread/shared future/shared future]]
[[zh:cpp/thread/shared future/shared future]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/valid</title>
    <ns>0</ns>
    <id>6460</id>
    <revision>
      <id>51425</id>
      <parentid>43422</parentid>
      <timestamp>2013-06-01T04:02:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="359">{{include page|cpp/thread/future/valid|shared_future}}

[[de:cpp/thread/shared future/valid]]
[[es:cpp/thread/shared future/valid]]
[[fr:cpp/thread/shared future/valid]]
[[it:cpp/thread/shared future/valid]]
[[ja:cpp/thread/shared future/valid]]
[[pt:cpp/thread/shared future/valid]]
[[ru:cpp/thread/shared future/valid]]
[[zh:cpp/thread/shared future/valid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/wait</title>
    <ns>0</ns>
    <id>6461</id>
    <revision>
      <id>51426</id>
      <parentid>43419</parentid>
      <timestamp>2013-06-01T04:02:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="350">{{include page|cpp/thread/future/wait|shared_future}}

[[de:cpp/thread/shared future/wait]]
[[es:cpp/thread/shared future/wait]]
[[fr:cpp/thread/shared future/wait]]
[[it:cpp/thread/shared future/wait]]
[[ja:cpp/thread/shared future/wait]]
[[pt:cpp/thread/shared future/wait]]
[[ru:cpp/thread/shared future/wait]]
[[zh:cpp/thread/shared future/wait]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/wait for</title>
    <ns>0</ns>
    <id>6462</id>
    <revision>
      <id>51427</id>
      <parentid>43412</parentid>
      <timestamp>2013-06-01T04:02:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="386">{{include page|cpp/thread/future/wait_for|shared_future}}

[[de:cpp/thread/shared future/wait for]]
[[es:cpp/thread/shared future/wait for]]
[[fr:cpp/thread/shared future/wait for]]
[[it:cpp/thread/shared future/wait for]]
[[ja:cpp/thread/shared future/wait for]]
[[pt:cpp/thread/shared future/wait for]]
[[ru:cpp/thread/shared future/wait for]]
[[zh:cpp/thread/shared future/wait for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/wait until</title>
    <ns>0</ns>
    <id>6463</id>
    <revision>
      <id>51428</id>
      <parentid>43404</parentid>
      <timestamp>2013-06-01T04:02:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="404">{{include page|cpp/thread/future/wait_until|shared_future}}

[[de:cpp/thread/shared future/wait until]]
[[es:cpp/thread/shared future/wait until]]
[[fr:cpp/thread/shared future/wait until]]
[[it:cpp/thread/shared future/wait until]]
[[ja:cpp/thread/shared future/wait until]]
[[pt:cpp/thread/shared future/wait until]]
[[ru:cpp/thread/shared future/wait until]]
[[zh:cpp/thread/shared future/wait until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared future/~shared future</title>
    <ns>0</ns>
    <id>8699</id>
    <revision>
      <id>63468</id>
      <parentid>43399</parentid>
      <timestamp>2013-07-10T01:33:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="625">{{cpp/thread/shared_future/title | ~shared_future}}
{{cpp/thread/shared_future/navbar}}
{{ddcl | since=c++11 |
~shared_future();
}}

If {{c|*this}} is the last object referring to the shared state, destroys the shared state. Otherwise does nothing.

[[de:cpp/thread/shared future/~shared future]]
[[es:cpp/thread/shared future/~shared future]]
[[fr:cpp/thread/shared future/~shared future]]
[[it:cpp/thread/shared future/~shared future]]
[[ja:cpp/thread/shared future/~shared future]]
[[pt:cpp/thread/shared future/~shared future]]
[[ru:cpp/thread/shared future/~shared future]]
[[zh:cpp/thread/shared future/~shared future]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock</title>
    <ns>0</ns>
    <id>10112</id>
    <revision>
      <id>65442</id>
      <parentid>63469</parentid>
      <timestamp>2013-09-15T15:12:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention that exclusive mode is handled by unique_lock</comment>
      <text xml:space="preserve" bytes="1852">{{cpp/title|shared_lock}}
{{cpp/thread/shared_lock/navbar}}
{{ddcl | header=mutex | since=c++14 | 1=
template&lt; class Mutex &gt;
class shared_lock;
}}

The class {{tt|shared_lock}} is a general-purpose shared mutex ownership wrapper allowing deferred locking, timed locking and transfer of lock ownership. Locking a {{tt|shared_lock}} locks the associated shared mutex in shared mode (to lock it in exclusive mode, {{lc|std::unique_lock}} can be used)

The {{tt|shared_lock}} class is movable, but not copyable -- it meets the requirements of {{concept|MoveConstructible}} and {{concept|MoveAssignable}} but not of {{concept|CopyConstructible}} or {{concept|CopyAssignable}}.

===Template parameters===
{{par begin}}
{{par | Mutex | the type of the shared mutex to lock. The type must meet the {{concept|SharedMutex}} requirements}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|mutex_type}} | {{c|Mutex}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc constructor}}
{{dsc inc | cpp/thread/shared_lock/dsc destructor}}
{{dsc inc | cpp/thread/shared_lock/dsc operator{{=}}}}

{{dsc h2 | Shared locking}}
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/thread/shared_lock/dsc swap}}
{{dsc inc | cpp/thread/shared_lock/dsc release}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/thread/shared_lock/dsc mutex}}
{{dsc inc | cpp/thread/shared_lock/dsc owns_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc operator bool}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc swap2}}
{{dsc end}}</text>
      <sha1>kv662mg66wtd1e8b6sz86n8ql1srux0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/lock</title>
    <ns>0</ns>
    <id>12980</id>
    <revision>
      <id>65436</id>
      <timestamp>2013-09-15T14:35:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1147">{{cpp/thread/shared_lock/title|lock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
void lock();
}}
{{dcl end}}

Locks the associated mutex. Effectively calls {{c|mutex()-&gt;lock_shared()}}.

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;lock_shared()}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/shared lock/lock]]
[[es:cpp/thread/shared lock/lock]]
[[fr:cpp/thread/shared lock/lock]]
[[it:cpp/thread/shared lock/lock]]
[[ja:cpp/thread/shared lock/lock]]
[[pt:cpp/thread/shared lock/lock]]
[[ru:cpp/thread/shared lock/lock]]
[[zh:cpp/thread/shared lock/lock]]</text>
      <sha1>5pj3wngcll1pr9fz7qz8s4v0yptr1e9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/mutex</title>
    <ns>0</ns>
    <id>12987</id>
    <revision>
      <id>65464</id>
      <timestamp>2013-09-15T15:44:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="743">{{cpp/thread/shared_lock/title|mutex}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
mutex_type* mutex() const;
}}
{{dcl end}}

Returns a pointer to the associated mutex, or a null pointer if there is no associated mutex.

===Parameters===
(none)

===Return value===
Pointer to the associated mutex or a null pointer if there is no associated mutex.

===Exceptions===
{{noexcept}}

===Example===
{{example|
 |code=
 |output=
}}

[[de:cpp/thread/shared lock/mutex]]
[[es:cpp/thread/shared lock/mutex]]
[[fr:cpp/thread/shared lock/mutex]]
[[it:cpp/thread/shared lock/mutex]]
[[ja:cpp/thread/shared lock/mutex]]
[[pt:cpp/thread/shared lock/mutex]]
[[ru:cpp/thread/shared lock/mutex]]
[[zh:cpp/thread/shared lock/mutex]]</text>
      <sha1>mo5sykud3qjh10e1s1bfed63gm7gfch</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/operator=</title>
    <ns>0</ns>
    <id>12978</id>
    <revision>
      <id>65420</id>
      <timestamp>2013-09-12T19:36:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1101">{{cpp/thread/shared_lock/title|operator{{=}}}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
shared_lock&amp; operator=( shared_lock&amp;&amp; other );
}}
{{dcl end}}

Move assignment operator. Replaces the contents with those of {{tt|other}} using move semantics. 

If, prior to this call, {{c|*this}} has an associated mutex (({{lc|mutex()}} returns a non-null pointer) and has acquired ownership of it ({{lc|owns()}} returns {{c|true}}), the mutex is unlocked by calling {{lc|std::shared_mutex::unlock_shared|unlock_shared()}}.

After this call, {{tt|other}} has no associated mutex.


===Parameters===
{{par begin}}
{{par | other | another {{tt|shared_lock}} to replace the state with}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

[[de:cpp/thread/shared lock/operator=]]
[[es:cpp/thread/shared lock/operator=]]
[[fr:cpp/thread/shared lock/operator=]]
[[it:cpp/thread/shared lock/operator=]]
[[ja:cpp/thread/shared lock/operator=]]
[[pt:cpp/thread/shared lock/operator=]]
[[ru:cpp/thread/shared lock/operator=]]
[[zh:cpp/thread/shared lock/operator=]]</text>
      <sha1>7en5ju8649p587g4hejlivugul8lse0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/operator bool</title>
    <ns>0</ns>
    <id>12989</id>
    <revision>
      <id>65466</id>
      <timestamp>2013-09-15T15:47:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="896">{{cpp/thread/shared_lock/title|operator bool}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
explicit operator bool() const;
}}
{{dcl end}}

Checks whether {{c|*this}} owns a locked mutex or not. Effectively calls {{lc|owns_lock()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} has an associated mutex and has acquired shared ownership of it, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc owns_lock}}
{{dsc end}}

[[de:cpp/thread/shared lock/operator bool]]
[[es:cpp/thread/shared lock/operator bool]]
[[fr:cpp/thread/shared lock/operator bool]]
[[it:cpp/thread/shared lock/operator bool]]
[[ja:cpp/thread/shared lock/operator bool]]
[[pt:cpp/thread/shared lock/operator bool]]
[[ru:cpp/thread/shared lock/operator bool]]
[[zh:cpp/thread/shared lock/operator bool]]</text>
      <sha1>3u9xwtg2wtf1xtlxsv3aq5tan6gwdkq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/owns lock</title>
    <ns>0</ns>
    <id>12988</id>
    <revision>
      <id>65465</id>
      <timestamp>2013-09-15T15:45:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="818">{{cpp/thread/shared_lock/title|owns_lock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
bool owns_lock() const;
}}
{{dcl end}}

Checks whether {{c|*this}} owns a locked mutex or not.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} has an associated mutex and has acquired shared ownership of it, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc operator_bool}}
{{dsc end}}

[[de:cpp/thread/shared lock/owns lock]]
[[es:cpp/thread/shared lock/owns lock]]
[[fr:cpp/thread/shared lock/owns lock]]
[[it:cpp/thread/shared lock/owns lock]]
[[ja:cpp/thread/shared lock/owns lock]]
[[pt:cpp/thread/shared lock/owns lock]]
[[ru:cpp/thread/shared lock/owns lock]]
[[zh:cpp/thread/shared lock/owns lock]]</text>
      <sha1>7ch2rqcwbmvtr2f6w87zmrin4k8q89o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/release</title>
    <ns>0</ns>
    <id>12986</id>
    <revision>
      <id>65455</id>
      <timestamp>2013-09-15T15:26:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1026">{{cpp/thread/shared_lock/title|release}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
mutex_type* release();
}}
{{dcl end}}

Breaks the association of the associated mutex, if any, and {{c|*this}}. 

No locks are unlocked. If the {{c|*this}} held ownership of the associated mutex prior to the call, the caller is now responsible to unlock the mutex.

===Parameters===
(none)

===Return value===
Pointer to the associated mutex or {{lc|NULL}} if there was no associated mutex.

===Exceptions===
{{noexcept}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
{{dsc inc | cpp/thread/unique_lock/dsc release}}
{{dsc end}}

[[de:cpp/thread/shared lock/release]]
[[es:cpp/thread/shared lock/release]]
[[fr:cpp/thread/shared lock/release]]
[[it:cpp/thread/shared lock/release]]
[[ja:cpp/thread/shared lock/release]]
[[pt:cpp/thread/shared lock/release]]
[[ru:cpp/thread/shared lock/release]]
[[zh:cpp/thread/shared lock/release]]</text>
      <sha1>7o7t8sbbjs54zj2df4aiqpkomuv8yns</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/shared lock</title>
    <ns>0</ns>
    <id>12975</id>
    <revision>
      <id>65370</id>
      <timestamp>2013-09-10T18:28:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>The only remaining cpp library redlinks are shared_mutex and shared_lock, I believe.</comment>
      <text xml:space="preserve" bytes="3298">{{cpp/thread/shared_lock/title|shared_lock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++14 | 1=
shared_lock();
}}
{{dcl | num=2 | since=c++14 | 1=
shared_lock( shared_lock&amp;&amp; other );
}}
{{dcl | num=3 | since=c++14 | 1=
explicit shared_lock( mutex_type&amp; m );
}}
{{dcl | num=4 | since=c++14 | 1=
shared_lock( mutex_type&amp; m, std::defer_lock_t t );
}}
{{dcl | num=5 | since=c++14 | 1=
shared_lock( mutex_type&amp; m, std::try_to_lock_t t );
}}
{{dcl | num=6 | since=c++14 | 1=
shared_lock( mutex_type&amp; m, std::adopt_lock_t t );
}}
{{dcl | num=7 | since=c++14 | 1=
template&lt; class Rep, class Period &gt;
shared_lock( mutex_type&amp; m, 
             const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl | num=8 | since=c++14 | 1=
template&lt; class Clock, class Duration &gt;
shared_lock( mutex_type&amp; m, 
             const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Constructs a {{tt|shared_lock}}, optionally locking the supplied mutex.

@1@ Constructs a {{tt|shared_lock}} with no associated mutex.
@2@ Move constructor. Initializes the {{tt|shared_lock}} with the contents of {{tt|other}}. Leaves {{tt|other}} with no associated mutex.
@3-8@ Constructs a {{tt|shared_lock}} with {{tt|m}} as the associated mutex. Additionally:
:@3@ Locks the associated mutex in shared mode by calling {{c|m.lock_shared()}}. The behavior is undefined if this thread already owns the mutex in any mode.
:@4@ Does not lock the associated mutex.
:@5@ Tries to lock the associated mutexin shared mode without blocking by calling {{c|m.try_lock_shared()}}. The behavior is undefined if this thread already owns the mutex in any mode.
:@5@ Assumes the calling thread already owns {{tt|m}} in shared mode.
@7@ Tries to lock the associated mutex in shared mode by calling {{c|m.try_lock_shared_until(timeout_duration)}}, which blocks until specified {{tt|timeout_duration}} has elapsed or the lock is acquired, whichever comes first. May block for longer than {{tt|timeout_duration}}. The behavior is undefined if this thread already owns the mutex in any mode.
@8@ Tries to lock the associated mutex in shared mode by calling {{c|m.try_lock_shared_for(timeout_time)}}, which blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. May block for longer than until {{tt|timeout_time}} has been reached. The behavior is undefined if this thread already owns the mutex in any mode.

===Parameters===
{{par begin}}
{{par | other | another {{tt|shared_lock}} to initialize the state with}}
{{par | m | mutex to associate with the lock and optionally acquire ownership of}}
{{par | t | tag parameter used to select constructors with different locking strategies}}
{{par | timeout_duration | maximum duration to block for}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Exceptions===
@1,2,4@ {{noexcept}}

===Example===
{{example|
 | code=
 | output=
}}

[[de:cpp/thread/shared lock/shared lock]]
[[es:cpp/thread/shared lock/shared lock]]
[[fr:cpp/thread/shared lock/shared lock]]
[[it:cpp/thread/shared lock/shared lock]]
[[ja:cpp/thread/shared lock/shared lock]]
[[pt:cpp/thread/shared lock/shared lock]]
[[ru:cpp/thread/shared lock/shared lock]]
[[zh:cpp/thread/shared lock/shared lock]]</text>
      <sha1>cwvb2lgq7nfsmuqnarodeiyp3epkt9k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/swap</title>
    <ns>0</ns>
    <id>12985</id>
    <revision>
      <id>65454</id>
      <timestamp>2013-09-15T15:24:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="786">{{cpp/thread/shared_lock/title|swap}}
{{cpp/thread/shared_lock/navbar}}
{{ddcl | since=c++14 |
template&lt; class Mutex &gt;
void swap( shared_lock&lt;Mutex&gt;&amp; other );
}}

Exchanges the internal states of the lock objects.

===Parameters===
{{par begin}}
{{par | other | the lock to swap the state with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/shared lock/swap]]
[[es:cpp/thread/shared lock/swap]]
[[fr:cpp/thread/shared lock/swap]]
[[it:cpp/thread/shared lock/swap]]
[[ja:cpp/thread/shared lock/swap]]
[[pt:cpp/thread/shared lock/swap]]
[[ru:cpp/thread/shared lock/swap]]
[[zh:cpp/thread/shared lock/swap]]</text>
      <sha1>48y2lmdbx9z2iygf6vt3zw8gpzklht2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/swap2</title>
    <ns>0</ns>
    <id>12803</id>
    <revision>
      <id>64870</id>
      <parentid>63151</parentid>
      <timestamp>2013-08-27T01:42:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+since=</comment>
      <text xml:space="preserve" bytes="702">{{cpp/title | swap&lt;small&gt;(std::shared_lock)&lt;/small&gt;}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |
template&lt; class Mutex &gt;
void swap( shared_lock&lt;Mutex&gt;&amp; lhs, 
           shared_lock&lt;Mutex&gt;&amp; rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::shared_lock}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | lock wrappers whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc swap}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/try lock</title>
    <ns>0</ns>
    <id>12981</id>
    <revision>
      <id>65453</id>
      <parentid>65443</parentid>
      <timestamp>2013-09-15T15:23:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1500">{{cpp/thread/shared_lock/title|try_lock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
bool try_lock();
}}
{{dcl end}}

Tries to lock the associated mutex in shared mode without blocking. Effectively calls {{c|mutex()-&gt;try_lock_shared()}}.

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
(none)

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock_shared()}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/shared lock/try lock]]
[[es:cpp/thread/shared lock/try lock]]
[[fr:cpp/thread/shared lock/try lock]]
[[it:cpp/thread/shared lock/try lock]]
[[ja:cpp/thread/shared lock/try lock]]
[[pt:cpp/thread/shared lock/try lock]]
[[ru:cpp/thread/shared lock/try lock]]
[[zh:cpp/thread/shared lock/try lock]]</text>
      <sha1>1n3pjfizagj9vkqs1fhwlq8f54wk1y5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/try lock for</title>
    <ns>0</ns>
    <id>12982</id>
    <revision>
      <id>65452</id>
      <parentid>65447</parentid>
      <timestamp>2013-09-15T15:22:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2088">{{cpp/thread/shared_lock/title|try_lock_for}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class Rep, class Period &gt;
bool try_lock_for( const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl end}}

Tries to lock the associated mutex in shared mode. Blocks until specified {{tt|timeout_duration}} has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. Effectively calls {{c|mutex()-&gt;try_lock_shared_for(timeout_duration)}}.

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
{{par begin}}
{{par | timeout_duration | maximum duration to block for}}
{{par end}}

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock_shared_for(timeout_duration)}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/shared lock/try lock for]]
[[es:cpp/thread/shared lock/try lock for]]
[[fr:cpp/thread/shared lock/try lock for]]
[[it:cpp/thread/shared lock/try lock for]]
[[ja:cpp/thread/shared lock/try lock for]]
[[pt:cpp/thread/shared lock/try lock for]]
[[ru:cpp/thread/shared lock/try lock for]]
[[zh:cpp/thread/shared lock/try lock for]]</text>
      <sha1>4i7b0o37p9g96xicge0n3oiomwav7ux</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/try lock until</title>
    <ns>0</ns>
    <id>12983</id>
    <revision>
      <id>65451</id>
      <parentid>65446</parentid>
      <timestamp>2013-09-15T15:22:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="2016">{{cpp/thread/shared_lock/title|try_lock_until}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class Clock, class Duration &gt;
bool try_lock_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Tries to lock the associated mutex in shared mode. Blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. May block for longer than until {{tt|timeout_time}} has been reached.

Effectively calls {{c|mutex()-&gt;try_lock_shared_until(timeout_time)}}

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
{{par begin}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock_shared_for(timeout_time)}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock}}
{{dsc inc | cpp/thread/shared_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/shared_lock/dsc unlock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_until}}
{{dsc end}}

[[de:cpp/thread/shared lock/try lock until]]
[[es:cpp/thread/shared lock/try lock until]]
[[fr:cpp/thread/shared lock/try lock until]]
[[it:cpp/thread/shared lock/try lock until]]
[[ja:cpp/thread/shared lock/try lock until]]
[[pt:cpp/thread/shared lock/try lock until]]
[[ru:cpp/thread/shared lock/try lock until]]
[[zh:cpp/thread/shared lock/try lock until]]</text>
      <sha1>dc1f8guk1h9tduwv9dy2pemjqrtt10a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/unlock</title>
    <ns>0</ns>
    <id>12984</id>
    <revision>
      <id>65450</id>
      <parentid>65449</parentid>
      <timestamp>2013-09-15T15:22:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1072">{{cpp/thread/shared_lock/title|unlock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
void unlock();
}}
{{dcl end}}

Unlocks the associated mutex from shared mode. Effectively calls {{c|mutex()-&gt;unlock_shared()}}

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is not locked.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;unlock_shared()}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/shared_lock/dsc lock}}
{{dsc inc | cpp/thread/shared_lock/dsc release}}
{{dsc end}}

[[de:cpp/thread/shared lock/unlock]]
[[es:cpp/thread/shared lock/unlock]]
[[fr:cpp/thread/shared lock/unlock]]
[[it:cpp/thread/shared lock/unlock]]
[[ja:cpp/thread/shared lock/unlock]]
[[pt:cpp/thread/shared lock/unlock]]
[[ru:cpp/thread/shared lock/unlock]]
[[zh:cpp/thread/shared lock/unlock]]</text>
      <sha1>3ajnkoywoxbp9x9d5qknei6lo6g13qo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared lock/~shared lock</title>
    <ns>0</ns>
    <id>12977</id>
    <revision>
      <id>65373</id>
      <timestamp>2013-09-10T19:04:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="758">{{cpp/thread/shared_lock/title|~shared_lock}}
{{cpp/thread/shared_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++14 | 1=
~shared_lock();
}}
{{dcl end}}

Destroys the lock.

If {{c|*this}} has an associated mutex (({{lc|mutex()}} returns a non-null pointer) and has acquired ownership of it ({{lc|owns()}} returns {{c|true}}), the mutex is unlocked by calling {{lc|std::shared_mutex::unlock_shared|unlock_shared()}}.

[[de:cpp/thread/shared lock/~shared lock]]
[[es:cpp/thread/shared lock/~shared lock]]
[[fr:cpp/thread/shared lock/~shared lock]]
[[it:cpp/thread/shared lock/~shared lock]]
[[ja:cpp/thread/shared lock/~shared lock]]
[[pt:cpp/thread/shared lock/~shared lock]]
[[ru:cpp/thread/shared lock/~shared lock]]
[[zh:cpp/thread/shared lock/~shared lock]]</text>
      <sha1>siot8ytmppg69ttpy1s3dxho4p4dlfg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex</title>
    <ns>0</ns>
    <id>13468</id>
    <redirect title="cpp/thread/shared timed mutex" />
    <revision>
      <id>68896</id>
      <timestamp>2014-03-22T22:24:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex]] to [[cpp/thread/shared timed mutex]]: renamed in C++14</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/thread/shared timed mutex]]</text>
      <sha1>6lbuttgb60b233avumo3fyvnfz5divr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/lock</title>
    <ns>0</ns>
    <id>13478</id>
    <redirect title="cpp/thread/shared timed mutex/lock" />
    <revision>
      <id>68933</id>
      <timestamp>2014-03-22T22:43:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/lock]] to [[cpp/thread/shared timed mutex/lock]]</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/thread/shared timed mutex/lock]]</text>
      <sha1>5de5bjy26zfj4p78se4czgd5g7rx8sa</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/lock shared</title>
    <ns>0</ns>
    <id>13482</id>
    <redirect title="cpp/thread/shared timed mutex/lock shared" />
    <revision>
      <id>68948</id>
      <timestamp>2014-03-22T22:49:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/lock shared]] to [[cpp/thread/shared timed mutex/lock shared]]</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[cpp/thread/shared timed mutex/lock shared]]</text>
      <sha1>qwuzqhx12zbi6jllsr3rtabzgw4lbeo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/shared mutex</title>
    <ns>0</ns>
    <id>13473</id>
    <redirect title="cpp/thread/shared timed mutex/shared mutex" />
    <revision>
      <id>68911</id>
      <timestamp>2014-03-22T22:33:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/shared mutex]] to [[cpp/thread/shared timed mutex/shared mutex]]</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[cpp/thread/shared timed mutex/shared mutex]]</text>
      <sha1>fyaoal32fzk0r5mv58bidizclo47aha</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock</title>
    <ns>0</ns>
    <id>13479</id>
    <redirect title="cpp/thread/shared timed mutex/try lock" />
    <revision>
      <id>68937</id>
      <timestamp>2014-03-22T22:44:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock]] to [[cpp/thread/shared timed mutex/try lock]]</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[cpp/thread/shared timed mutex/try lock]]</text>
      <sha1>7copd3kvfqzvr0cm189if6hg7r7a46b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock for</title>
    <ns>0</ns>
    <id>13470</id>
    <redirect title="cpp/thread/shared timed mutex/try lock for" />
    <revision>
      <id>68902</id>
      <timestamp>2014-03-22T22:30:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock for]] to [[cpp/thread/shared timed mutex/try lock for]]</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[cpp/thread/shared timed mutex/try lock for]]</text>
      <sha1>0iyg5u1bf67qxsmupjxzgy9xf61fq67</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock shared</title>
    <ns>0</ns>
    <id>13483</id>
    <redirect title="cpp/thread/shared timed mutex/try lock shared" />
    <revision>
      <id>68951</id>
      <timestamp>2014-03-22T22:50:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock shared]] to [[cpp/thread/shared timed mutex/try lock shared]]</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[cpp/thread/shared timed mutex/try lock shared]]</text>
      <sha1>rx9oaqt2mwvmiug2nhmnt5xfiakhkl5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock shared for</title>
    <ns>0</ns>
    <id>13484</id>
    <redirect title="cpp/thread/shared timed mutex/try lock shared for" />
    <revision>
      <id>68954</id>
      <timestamp>2014-03-22T22:51:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock shared for]] to [[cpp/thread/shared timed mutex/try lock shared for]]</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[cpp/thread/shared timed mutex/try lock shared for]]</text>
      <sha1>tbaspfignk2os46ea59rekpncxlohwf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock shared until</title>
    <ns>0</ns>
    <id>13485</id>
    <redirect title="cpp/thread/shared timed mutex/try lock shared until" />
    <revision>
      <id>68957</id>
      <timestamp>2014-03-22T22:52:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock shared until]] to [[cpp/thread/shared timed mutex/try lock shared until]]</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[cpp/thread/shared timed mutex/try lock shared until]]</text>
      <sha1>bguqkcdvn6m7253unua2p7uv62duirv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/try lock until</title>
    <ns>0</ns>
    <id>13477</id>
    <redirect title="cpp/thread/shared timed mutex/try lock until" />
    <revision>
      <id>68925</id>
      <timestamp>2014-03-22T22:39:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/try lock until]] to [[cpp/thread/shared timed mutex/try lock until]]</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[cpp/thread/shared timed mutex/try lock until]]</text>
      <sha1>h0nhp67d2lfygz8aachixyiqp8kho7r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/unlock</title>
    <ns>0</ns>
    <id>13481</id>
    <redirect title="cpp/thread/shared timed mutex/unlock" />
    <revision>
      <id>68944</id>
      <timestamp>2014-03-22T22:47:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/unlock]] to [[cpp/thread/shared timed mutex/unlock]]</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[cpp/thread/shared timed mutex/unlock]]</text>
      <sha1>jsi27q4p1xk0fr0xq5zv7m0kxvtcz9w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/unlock shared</title>
    <ns>0</ns>
    <id>13486</id>
    <redirect title="cpp/thread/shared timed mutex/unlock shared" />
    <revision>
      <id>68960</id>
      <timestamp>2014-03-22T22:53:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/unlock shared]] to [[cpp/thread/shared timed mutex/unlock shared]]</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[cpp/thread/shared timed mutex/unlock shared]]</text>
      <sha1>gv84pyp6xqfh6uy9uf56cef6twsfh5y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared mutex/~shared mutex</title>
    <ns>0</ns>
    <id>13480</id>
    <redirect title="cpp/thread/shared timed mutex/~shared timed mutex" />
    <revision>
      <id>68941</id>
      <timestamp>2014-03-22T22:47:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared mutex/~shared mutex]] to [[cpp/thread/shared timed mutex/~shared timed mutex]]</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[cpp/thread/shared timed mutex/~shared timed mutex]]</text>
      <sha1>3mslrn21su2nu61xagz796mhhqifclh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex</title>
    <ns>0</ns>
    <id>10109</id>
    <revision>
      <id>72293</id>
      <parentid>68898</parentid>
      <timestamp>2014-08-05T11:20:33Z</timestamp>
      <contributor>
        <username>Bear</username>
        <id>408</id>
      </contributor>
      <comment>In namespace std</comment>
      <text xml:space="preserve" bytes="2912">{{cpp/title|shared_timed_mutex}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{ddcl | header=shared_mutex | since=c++14 | 1=
class shared_timed_mutex;
}}

The {{tt|shared_timed_mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. In contrast to other mutex types which facilitate exclusive access, a shared_timed_mutex has two levels of access:

* ''shared'' - several threads can share ownership of the same mutex.

* ''exclusive'' - only one thread can own the mutex.

Shared mutexes are usually used in situations, when multiple readers can access the same resource at the same time without causing data races, but only one writer can do so.

In a manner similar to {{ltt|cpp/thread/timed_mutex}}, {{tt|shared_timed_mutex}} provides the ability to attempt to claim ownership of a {{tt|shared_timed_mutex}} with a timeout via the {{ltf|cpp/thread/shared_timed_mutex/try_lock_for}}, {{ltf|cpp/thread/shared_timed_mutex/try_lock_until}}, {{ltf|cpp/thread/shared_timed_mutex/try_lock_shared_for}}, {{ltf|cpp/thread/shared_timed_mutex/try_lock_shared_until}} methods.

The {{tt|shared_timed_mutex}} class satisfies all requirements of {{concept|SharedTimedMutex}} and {{concept|StandardLayoutType}}.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Exclusive locking}}
{{dsc inc | cpp/thread/mutex/dsc lock | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | shared_timed_mutex}}

{{dsc h2 | Shared locking}}
{{dsc inc | cpp/thread/mutex/dsc lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared_for | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared_until | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock_shared | shared_timed_mutex}}
{{dsc end}}


{{todo|build a motivating example}}
{{example|A copy assignment operator for a class that holds resources that can handle multiple readers, but only one writer
|code= class R
{
    mutable std::shared_timed_mutex m;
    /* data */
public:
    R&amp; operator=(const R&amp; other)
    {
        // requires exclusive ownership to write to *this
        std::unique_lock&lt;std::shared_timed_mutex&gt; lhs(mut, std::defer_lock);
        // requires shared ownership to read from other
        std::shared_lock&lt;std::shared_timed_mutex&gt; rhs(other.mut, std::defer_lock);
        std::lock(lhs, rhs);
        /* assign data */
        return *this;
    }
}
}}</text>
      <sha1>93c8eef4mihleazyrtfbz8tpdolziag</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/lock</title>
    <ns>0</ns>
    <id>12993</id>
    <revision>
      <id>68934</id>
      <parentid>68932</parentid>
      <timestamp>2014-03-22T22:43:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="394">{{include page|cpp/thread/mutex/lock|shared_timed_mutex}}

[[de:cpp/thread/shared timed mutex/lock]]
[[es:cpp/thread/shared timed mutex/lock]]
[[fr:cpp/thread/shared timed mutex/lock]]
[[it:cpp/thread/shared timed mutex/lock]]
[[ja:cpp/thread/shared timed mutex/lock]]
[[pt:cpp/thread/shared timed mutex/lock]]
[[ru:cpp/thread/shared timed mutex/lock]]
[[zh:cpp/thread/shared timed mutex/lock]]</text>
      <sha1>aez9wwiww88nzugtooqopl0gpvwi729</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/lock shared</title>
    <ns>0</ns>
    <id>12998</id>
    <revision>
      <id>68949</id>
      <parentid>68947</parentid>
      <timestamp>2014-03-22T22:50:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="2010">{{cpp/thread/shared_timed_mutex/title|lock_shared}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|shared_timed_mutex}} |
void lock_shared();
}}
{{dcl end}}

Acquires shared ownership of the mutex. If another thread is holding the mutex in exclusive ownership, a call to {{tt|lock_shared}} will block execution until shared ownership can be acquired.

If {{tt|lock_shared}} is called by a thread that already owns the {{tt|mutex}} in any mode (exclusive or shared), the behavior is undefined.

If more than the implementation-defined maximum number of shared owners already locked the mutex in shared mode, {{tt|lock_shared}} blocks execution until the number of shared owners is reduced. The maximum number of owners is guaranteed to be at least 10000.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
Throws {{lc|std::system_error}} when errors occur, including errors from the underlying operating system that would prevent {{tt|lock}} from meeting its specifications. The mutex is not locked in the case of any exception being thrown.

===Notes===
{{tt|lock_shared()}} is usually not called directly: {{lc|std::shared_lock}} is used to manage shared locking.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock_shared | shared_timed_mutex}}
{{dsc end}}

[[de:cpp/thread/shared timed mutex/lock_shared]]
[[es:cpp/thread/shared timed mutex/lock_shared]]
[[fr:cpp/thread/shared timed mutex/lock_shared]]
[[it:cpp/thread/shared timed mutex/lock_shared]]
[[ja:cpp/thread/shared timed mutex/lock_shared]]
[[pt:cpp/thread/shared timed mutex/lock_shared]]
[[ru:cpp/thread/shared timed mutex/lock_shared]]
[[zh:cpp/thread/shared timed mutex/lock_shared]]</text>
      <sha1>p6dfxbo50onwqjs70s05fcq5x58olje</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/shared mutex</title>
    <ns>0</ns>
    <id>13475</id>
    <redirect title="cpp/thread/shared timed mutex/shared timed mutex" />
    <revision>
      <id>68917</id>
      <timestamp>2014-03-22T22:35:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[cpp/thread/shared timed mutex/shared mutex]] to [[cpp/thread/shared timed mutex/shared timed mutex]]</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[cpp/thread/shared timed mutex/shared timed mutex]]</text>
      <sha1>mld8a7atehrfya4d0a5xr0627pihwdi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/shared timed mutex</title>
    <ns>0</ns>
    <id>12990</id>
    <revision>
      <id>68916</id>
      <parentid>68912</parentid>
      <timestamp>2014-03-22T22:35:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>Cubbi moved page [[cpp/thread/shared timed mutex/shared mutex]] to [[cpp/thread/shared timed mutex/shared timed mutex]]</comment>
      <text xml:space="preserve" bytes="457">{{include page|cpp/thread/mutex/constructor|shared_timed_mutex}}

[[de:cpp/thread/timed mutex/shared timed mutex]]
[[es:cpp/thread/timed mutex/shared timed mutex]]
[[fr:cpp/thread/timed mutex/shared timed mutex]]
[[it:cpp/thread/timed mutex/shared timed mutex]]
[[ja:cpp/thread/timed mutex/shared timed mutex]]
[[pt:cpp/thread/timed mutex/shared timed mutex]]
[[ru:cpp/thread/timed mutex/shared timed mutex]]
[[zh:cpp/thread/timed mutex/shared timed mutex]]</text>
      <sha1>namoapv1pv7znnttp7f32zkwdde0wpq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock</title>
    <ns>0</ns>
    <id>12994</id>
    <revision>
      <id>68938</id>
      <parentid>68936</parentid>
      <timestamp>2014-03-22T22:45:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="430">{{include page|cpp/thread/mutex/try_lock|shared_timed_mutex}}

[[de:cpp/thread/shared timed mutex/try lock]]
[[es:cpp/thread/shared timed mutex/try lock]]
[[fr:cpp/thread/shared timed mutex/try lock]]
[[it:cpp/thread/shared timed mutex/try lock]]
[[ja:cpp/thread/shared timed mutex/try lock]]
[[pt:cpp/thread/shared timed mutex/try lock]]
[[ru:cpp/thread/shared timed mutex/try lock]]
[[zh:cpp/thread/shared timed mutex/try lock]]</text>
      <sha1>rw4mjl4jmyovlri7agqr0jlrddjr9h8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock for</title>
    <ns>0</ns>
    <id>12995</id>
    <revision>
      <id>68927</id>
      <parentid>68901</parentid>
      <timestamp>2014-03-22T22:40:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="418">{{include page|cpp/thread/mutex/try_lock_for|shared_timed_mutex}}

[[de:cpp/thread/shared mutex/try lock for]]
[[es:cpp/thread/shared mutex/try lock for]]
[[fr:cpp/thread/shared mutex/try lock for]]
[[it:cpp/thread/shared mutex/try lock for]]
[[ja:cpp/thread/shared mutex/try lock for]]
[[pt:cpp/thread/shared mutex/try lock for]]
[[ru:cpp/thread/shared mutex/try lock for]]
[[zh:cpp/thread/shared mutex/try lock for]]</text>
      <sha1>77uvxhgg1ae93djceswnjvzj24q6fwy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock shared</title>
    <ns>0</ns>
    <id>13000</id>
    <revision>
      <id>68952</id>
      <parentid>68950</parentid>
      <timestamp>2014-03-22T22:51:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="1537">{{cpp/thread/shared_timed_mutex/title|try_lock_shared}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |
void try_lock_shared();
}}
{{dcl end}}

Tries to lock the mutex in shared mode. Returns immediately. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}.

This function is allowed to fail spuriously and return {{c|false}} even if the mutex is not currenly exclusively locked by any other thread.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}.

The behavior is undefined if the calling thread already owns the mutex in any mode.

===Parameters===
(none)

===Return value===
{{c|true}} if the lock was acquired successfully, otherwise {{c|false}}.

===Exceptions===
(none)

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock_shared | shared_timed_mutex}}
{{dsc end}}

[[de:cpp/thread/shared timed mutex/try_lock_shared]]
[[es:cpp/thread/shared timed mutex/try_lock_shared]]
[[fr:cpp/thread/shared timed mutex/try_lock_shared]]
[[it:cpp/thread/shared timed mutex/try_lock_shared]]
[[ja:cpp/thread/shared timed mutex/try_lock_shared]]
[[pt:cpp/thread/shared timed mutex/try_lock_shared]]
[[ru:cpp/thread/shared timed mutex/try_lock_shared]]
[[zh:cpp/thread/shared timed mutex/try_lock_shared]]</text>
      <sha1>75ujdes7297ypv4aqpkzaxvrmwype73</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock shared for</title>
    <ns>0</ns>
    <id>13001</id>
    <revision>
      <id>68955</id>
      <parentid>68953</parentid>
      <timestamp>2014-03-22T22:52:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="2422">{{cpp/thread/shared_timed_mutex/title|try_lock_shared_for}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |
template&lt; class Rep, class Period &gt;
bool try_lock_shared_for( const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl end}}

Tries to lock the mutex in shared mode. Blocks until specified {{tt|timeout_duration}} has elapsed or the shared lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. 

If {{tt|timeout_duration}} is less or equal {{tt|timeout_duration.zero()}}, the function behaves like {{lc|try_lock_shared()}}.

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

As with {{lc|try_lock_shared()}}, this function is allowed to fail spuriously and return {{c|false}} even if the mutex was not locked by any other thread at some point during {{tt|timeout_duration}}.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}.

If {{tt|try_lock_shared_for}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | timeout_duration | maximum duration to block for}}
{{par end}}

===Return value===
{{c|true}} if the lock was acquired successfully, otherwise {{c|false}}.

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared_until | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | shared_timed_mutex}}
{{dsc end}}


[[de:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[es:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[fr:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[it:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[ja:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[pt:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[ru:cpp/thread/shared timed mutex/try_lock_shared_for]]
[[zh:cpp/thread/shared mutex/try_lock_shared_for]]</text>
      <sha1>n6ic9w3hv3infzy2epqs60ncvof7exv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock shared until</title>
    <ns>0</ns>
    <id>13002</id>
    <revision>
      <id>68958</id>
      <parentid>68956</parentid>
      <timestamp>2014-03-22T22:53:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="2238">{{cpp/thread/shared_timed_mutex/title|try_lock_shared_until}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |
template&lt; class Clock, class Duration &gt;
bool try_lock_shared_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Tries to lock the mutex in shared mode. Blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}.

If {{tt|timeout_time}} has already passed, this function behaves like {{lc|try_lock_shared()}}.

The clock tied to {{tt|timeout_time}} is used, which means that adjustments of the clock are taken into account. Thus, the maximum duration of the block might, but might not, be less or more than  {{c|timeout_time - Clock::now()}} at the time of the call, depending on the direction of the adjustment. The function also may block for longer than until after {{tt|timeout_time}} has been reached due to scheduling or resource contention delays.

As with {{lc|try_lock_shared()}}, this function is allowed to fail spuriously and return {{c|false}} even if the mutex was not locked by any other thread at some point before {{tt|timeout_time}}.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}.

If {{tt|try_lock_shared_until}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.

===Parameters===
{{par begin}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Return value===
{{c|true}} if the shared lock ownership was acquired successfully, otherwise {{c|false}}.

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_shared_for | shared_timed_mutex}}
{{dsc end}}</text>
      <sha1>h5vms00t3vwznzirq9py05yxoqm9osu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/try lock until</title>
    <ns>0</ns>
    <id>12996</id>
    <revision>
      <id>68926</id>
      <parentid>68924</parentid>
      <timestamp>2014-03-22T22:40:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="436">{{include page|cpp/thread/mutex/try_lock_until|shared_timed_mutex}}

[[de:cpp/thread/shared mutex/try lock until]]
[[es:cpp/thread/shared mutex/try lock until]]
[[fr:cpp/thread/shared mutex/try lock until]]
[[it:cpp/thread/shared mutex/try lock until]]
[[ja:cpp/thread/shared mutex/try lock until]]
[[pt:cpp/thread/shared mutex/try lock until]]
[[ru:cpp/thread/shared mutex/try lock until]]
[[zh:cpp/thread/shared mutex/try lock until]]</text>
      <sha1>lx7fowbqy87p29aiztctfhxrwohf5ld</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/unlock</title>
    <ns>0</ns>
    <id>12997</id>
    <revision>
      <id>68945</id>
      <parentid>68943</parentid>
      <timestamp>2014-03-22T22:48:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="412">{{include page|cpp/thread/mutex/unlock|shared_timed_mutex}}

[[de:cpp/thread/shared timed mutex/unlock]]
[[es:cpp/thread/shared timed mutex/unlock]]
[[fr:cpp/thread/shared timed mutex/unlock]]
[[it:cpp/thread/shared timed mutex/unlock]]
[[ja:cpp/thread/shared timed mutex/unlock]]
[[pt:cpp/thread/shared timed mutex/unlock]]
[[ru:cpp/thread/shared timed mutex/unlock]]
[[zh:cpp/thread/shared timed mutex/unlock]]</text>
      <sha1>7yhtyer5izgy0d1oy5bn21d4qdyiuo0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/unlock shared</title>
    <ns>0</ns>
    <id>12999</id>
    <revision>
      <id>68961</id>
      <parentid>68959</parentid>
      <timestamp>2014-03-22T22:53:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="1323">{{cpp/thread/shared_timed_mutex/title|unlock_shared}}
{{cpp/thread/shared_timed_mutex/navbar}}
{{dcl begin}}
{{dcl | since=c++14 |
void unlock_shared();
}}
{{dcl end}}

Releases the mutex from shared ownership by the calling thread.
.
The mutex must be locked by the current thread of execution in shared mode, otherwise, the behavior is undefined.

This operation ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) any subsequent {{lc|lock()}} operation that obtains ownership of the same mutex.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
(none)

===Notes===
{{tt|unlock_shared()}} is usually not called directly: {{lc|std::shared_lock}} is used to manage exclusive locking.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock_shared | shared_timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | shared_timed_mutex}}
{{dsc end}}

[[de:cpp/thread/shared timed mutex/unlock_shared]]
[[es:cpp/thread/shared timed mutex/unlock_shared]]
[[fr:cpp/thread/shared timed mutex/unlock_shared]]
[[it:cpp/thread/shared timed mutex/unlock_shared]]
[[ja:cpp/thread/shared timed mutex/unlock_shared]]
[[pt:cpp/thread/shared timed mutex/unlock_shared]]
[[ru:cpp/thread/shared timed mutex/unlock_shared]]
[[zh:cpp/thread/shared timed mutex/unlock_shared]]</text>
      <sha1>j3sjjhxq5pdzz2j7536ggwx3dc8b6t2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/shared timed mutex/~shared timed mutex</title>
    <ns>0</ns>
    <id>13128</id>
    <revision>
      <id>68942</id>
      <parentid>68940</parentid>
      <timestamp>2014-03-22T22:47:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="63">{{include page|cpp/thread/mutex/destructor|shared_timed_mutex}}</text>
      <sha1>sxjcdjuei4ff2kppgul1l1sc7kccjhf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/sleep for</title>
    <ns>0</ns>
    <id>2299</id>
    <revision>
      <id>72044</id>
      <parentid>64406</parentid>
      <timestamp>2014-07-09T23:28:46Z</timestamp>
      <contributor>
        <ip>87.88.247.211</ip>
      </contributor>
      <comment>Improved consistency with argument name.</comment>
      <text xml:space="preserve" bytes="1400">{{cpp/title|n=this_thread::|sleep_for}}
{{cpp/thread/navbar}}
{{ddcl | header=thread | since=c++11 | 1=
template&lt; class Rep, class Period &gt;
void sleep_for( const std::chrono::duration&lt;Rep, Period&gt;&amp; sleep_duration );
}}

Blocks the execution of the current thread for ''at least'' the specified {{tt|sleep_duration}}. 

A steady clock is used to measure the duration. This function may block for longer than {{tt|sleep_duration}} due to scheduling or resource contention delays. 

===Parameters===
{{par begin}}
{{par | sleep_duration | time duration to sleep}}
{{par end}}

===Return value===
(none)

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;

int main()
{
    std::cout &lt;&lt; &quot;Hello waiter&quot; &lt;&lt; std::endl;
    std::chrono::milliseconds dura( 2000 );
    std::this_thread::sleep_for( dura );
    std::cout &lt;&lt; &quot;Waited 2000 ms\n&quot;;
}
 | output=
Hello waiter
Waited 2000 ms
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc sleep_until}}
{{dsc end}}

[[de:cpp/thread/sleep for]]
[[es:cpp/thread/sleep for]]
[[fr:cpp/thread/sleep for]]
[[it:cpp/thread/sleep for]]
[[ja:cpp/thread/sleep for]]
[[pt:cpp/thread/sleep for]]
[[ru:cpp/thread/sleep for]]
[[zh:cpp/thread/sleep for]]</text>
      <sha1>a38iu89jovhpxx9kdk23s0ilm5jomfz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/sleep until</title>
    <ns>0</ns>
    <id>2300</id>
    <revision>
      <id>64405</id>
      <parentid>63472</parentid>
      <timestamp>2013-08-16T03:12:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>this was never noexcept. Also, apply LWG issue 2093</comment>
      <text xml:space="preserve" bytes="1333">{{cpp/title|n=this_thread::|sleep_until}}
{{cpp/thread/navbar}}
{{ddcl | header=thread | since=c++11 | 1=
template&lt; class Clock, class Duration &gt;
void sleep_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; sleep_time );
}}

Blocks the execution of the current thread until specified {{tt|sleep_time}} has been reached. 

The clock tied to {{tt|sleep_time}} is used, which means that adjustments of the clock are taken into account. Thus, the duration of the block might, but might not, be less or more than  {{c|sleep_time - Clock::now()}} at the time of the call, depending on the direction of the adjustment. The function also may block for longer than until after {{tt|sleep_time}} has been reached due to scheduling or resource contention delays.

===Parameters===
{{par begin}}
{{par | sleep_time | time to block until}}
{{par end}}

===Return value===
(none)

===Exceptions===
Any exception thrown by {{tt|Clock}} or {{tt|Duration}} (clocks and durations provided by the standard library never throw)

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc sleep_for}}
{{dsc end}}

[[de:cpp/thread/sleep until]]
[[es:cpp/thread/sleep until]]
[[fr:cpp/thread/sleep until]]
[[it:cpp/thread/sleep until]]
[[ja:cpp/thread/sleep until]]
[[pt:cpp/thread/sleep until]]
[[ru:cpp/thread/sleep until]]
[[zh:cpp/thread/sleep until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread</title>
    <ns>0</ns>
    <id>2253</id>
    <revision>
      <id>63473</id>
      <parentid>59239</parentid>
      <timestamp>2013-07-10T01:33:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1382">{{cpp/title|thread}}
{{cpp/thread/thread/navbar}}
{{ddcl | header=thread | since=c++11 |
class thread;
}}

The class {{tt|thread}} represents [[enwiki:Thread_(computing)|a single thread of execution]].  Threads allow multiple pieces of code to run asynchronously and simultaneously.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc id}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc constructor}}
{{dsc inc | cpp/thread/thread/dsc destructor}}
{{dsc inc | cpp/thread/thread/dsc operator{{=}}}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/thread/thread/dsc joinable}}
{{dsc inc | cpp/thread/thread/dsc get_id}}
{{dsc inc | cpp/thread/thread/dsc native_handle}}
{{dsc inc | cpp/thread/thread/dsc hardware_concurrency}}

{{dsc h2 | Operations}}
{{dsc inc | cpp/thread/thread/dsc join}}
{{dsc inc | cpp/thread/thread/dsc detach}}
{{dsc inc | cpp/thread/thread/dsc swap}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/thread]]
[[es:cpp/thread/thread]]
[[fr:cpp/thread/thread]]
[[it:cpp/thread/thread]]
[[ja:cpp/thread/thread]]
[[pt:cpp/thread/thread]]
[[ru:cpp/thread/thread]]
[[zh:cpp/thread/thread]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/detach</title>
    <ns>0</ns>
    <id>2271</id>
    <revision>
      <id>66493</id>
      <parentid>66491</parentid>
      <timestamp>2013-11-26T07:03:28Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>Add preconditions and postconditions</comment>
      <text xml:space="preserve" bytes="1835">{{cpp/thread/thread/title|detach}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
void detach();
}}

Separates the thread of execution from the thread object, allowing execution to continue independently. Any allocated resources will be freed once the thread exits.

After calling {{tt|detach}} {{c|*this}} no longer owns any thread.

===Parameters===
(none)

===Return value===
(none)

===Preconditions===
{{lc|joinable}} is {{c|true}}

===Postconditions===
{{lc|joinable}} is {{c|false}}

===Exceptions===
{{lc|std::system_error}} if {{c|joinable() {{==}} false}} or an error occurs.

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;

void independentThread() 
{
    std::cout &lt;&lt; &quot;Starting concurrent thread.\n&quot;;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout &lt;&lt; &quot;Exiting concurrent thread.\n&quot;;
}

void threadCaller() 
{
    std::cout &lt;&lt; &quot;Starting thread caller.\n&quot;;
    std::thread t(independentThread);
    t.detach();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout &lt;&lt; &quot;Exiting thread caller.\n&quot;;
}

int main() 
{
    threadCaller();
    std::this_thread::sleep_for(std::chrono::seconds(5));
}
 | output=
Starting thread caller.
Starting concurrent thread.
Exiting thread caller.
Exiting concurrent thread.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc join}}
{{dsc inc | cpp/thread/thread/dsc joinable}}
{{dsc end}}

===References===
{{ref std c++11}}
{{ref std | section=30.3.1.5 | title=thread members | id=thread.thread.member}}
{{ref std end}}

[[de:cpp/thread/thread/detach]]
[[es:cpp/thread/thread/detach]]
[[fr:cpp/thread/thread/detach]]
[[it:cpp/thread/thread/detach]]
[[ja:cpp/thread/thread/detach]]
[[pt:cpp/thread/thread/detach]]
[[ru:cpp/thread/thread/detach]]
[[zh:cpp/thread/thread/detach]]</text>
      <sha1>l50hmqpcctzuvx1919cr1a3ow1kzxb2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/get id</title>
    <ns>0</ns>
    <id>2276</id>
    <revision>
      <id>64312</id>
      <parentid>63475</parentid>
      <timestamp>2013-08-15T16:33:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1359">{{cpp/thread/thread/title|get_id}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
std::thread::id get_id() const;
}}

Returns a value of {{lc|std::thread::id}} identifying the thread associated with {{c|*this}}.

===Parameters===
(none)

===Return value===
A value of type {{lc|std::thread::id}} identifying the thread associated with {{c|*this}}. If there is no thread associated, default constructed {{lc|std::thread::id}} is returned.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread::id t1_id = t1.get_id();

    std::thread t2(foo);
    std::thread::id t2_id = t2.get_id();

    std::cout &lt;&lt; &quot;t1's id: &quot; &lt;&lt; t1_id &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;t2's id: &quot; &lt;&lt; t2_id &lt;&lt; '\n';

    t1.join();
    t2.join();
}
 | output=
t1's id: 0x35a7210f
t2's id: 0x35a311c4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc id}}
{{dsc inc | cpp/thread/thread/dsc joinable}}
{{dsc end}}

[[de:cpp/thread/thread/get id]]
[[es:cpp/thread/thread/get id]]
[[fr:cpp/thread/thread/get id]]
[[it:cpp/thread/thread/get id]]
[[ja:cpp/thread/thread/get id]]
[[pt:cpp/thread/thread/get id]]
[[ru:cpp/thread/thread/get id]]
[[zh:cpp/thread/thread/get id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/hardware concurrency</title>
    <ns>0</ns>
    <id>2275</id>
    <revision>
      <id>63476</id>
      <parentid>45956</parentid>
      <timestamp>2013-07-10T01:33:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1080">{{cpp/thread/thread/title|hardware_concurrency}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
static unsigned hardware_concurrency();
}}

Returns number of concurrent threads supported by the implementation. The value should be considered only a hint.

===Parameters===
(none)

===Return value===
number of concurrent threads supported. If the value is not well defined or not computable, returns {{c|0}}.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;

int main() {
    unsigned int n = std::thread::hardware_concurrency();
    std::cout &lt;&lt; n &lt;&lt; &quot; concurrent threads are supported.\n&quot;;
}
 | output=
4 concurrent threads are supported.
}}

[[de:cpp/thread/thread/hardware concurrency]]
[[es:cpp/thread/thread/hardware concurrency]]
[[fr:cpp/thread/thread/hardware concurrency]]
[[it:cpp/thread/thread/hardware concurrency]]
[[ja:cpp/thread/thread/hardware concurrency]]
[[pt:cpp/thread/thread/hardware concurrency]]
[[ru:cpp/thread/thread/hardware concurrency]]
[[zh:cpp/thread/thread/hardware concurrency]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/id</title>
    <ns>0</ns>
    <id>5138</id>
    <revision>
      <id>63477</id>
      <parentid>61426</parentid>
      <timestamp>2013-07-10T01:33:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1340">{{cpp/thread/thread/title|id}}
{{cpp/thread/thread/id/navbar}}
{{ddcl | header=thread | since=c++11 |
class thread::id;
}}

The class {{tt|thread::id}} is a lightweight, trivially copyable class that serves as a unique identifier of {{lc|std::thread}} objects. 

Instances of this class may also hold the special distinct value that does not represent any thread. Once a thread has finished, the value of {{tt|std::thread::id}} may be reused by another thread.

This class is designed for use as key in associative containers, both ordered and unordered.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/thread/thread/id/id | constructs an id that does not represent a thread}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/id/dsc operator_cmp}}
{{dsc inc | cpp/thread/thread/id/dsc operator_ltlt}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc ptclass | cpp/thread/thread/id/hash | title=std::hash{{dsc small|&lt;std::thread::id&gt;}} | specializes {{lc|std::hash}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc get_id}}
{{dsc end}}

[[de:cpp/thread/thread/id]]
[[es:cpp/thread/thread/id]]
[[fr:cpp/thread/thread/id]]
[[it:cpp/thread/thread/id]]
[[ja:cpp/thread/thread/id]]
[[pt:cpp/thread/thread/id]]
[[ru:cpp/thread/thread/id]]
[[zh:cpp/thread/thread/id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/id/hash</title>
    <ns>0</ns>
    <id>8493</id>
    <revision>
      <id>62982</id>
      <parentid>59247</parentid>
      <timestamp>2013-07-01T23:48:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="735">{{cpp/title|hash{{small|&lt;std::thread::id&gt;}}}}
{{cpp/thread/thread/id/navbar}}
{{dcl begin}}
{{dcl header | thread}}
{{dcl | since=c++11 | 1=
template&lt;&gt; struct hash&lt;std::thread::id&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for the {{lc|std::thread::id}} class allows users to obtain hashes of the identifiers of threads.

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

[[de:cpp/thread/thread/id/hash]]
[[es:cpp/thread/thread/id/hash]]
[[fr:cpp/thread/thread/id/hash]]
[[it:cpp/thread/thread/id/hash]]
[[ja:cpp/thread/thread/id/hash]]
[[pt:cpp/thread/thread/id/hash]]
[[ru:cpp/thread/thread/id/hash]]
[[zh:cpp/thread/thread/id/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/id/id</title>
    <ns>0</ns>
    <id>9076</id>
    <revision>
      <id>62983</id>
      <parentid>51438</parentid>
      <timestamp>2013-07-01T23:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="519">{{cpp/thread/thread/id/title|id}}
{{cpp/thread/thread/id/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
id();
}}
{{dcl end}}

Default-constructs a new thread identifier. The identifier does not represent a thread.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/thread/thread/id/id]]
[[es:cpp/thread/thread/id/id]]
[[fr:cpp/thread/thread/id/id]]
[[it:cpp/thread/thread/id/id]]
[[ja:cpp/thread/thread/id/id]]
[[pt:cpp/thread/thread/id/id]]
[[ru:cpp/thread/thread/id/id]]
[[zh:cpp/thread/thread/id/id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/id/operator cmp</title>
    <ns>0</ns>
    <id>9075</id>
    <revision>
      <id>62984</id>
      <parentid>51439</parentid>
      <timestamp>2013-07-01T23:48:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1462">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;={{small|(std::thread::id)}}}}
{{cpp/thread/thread/id/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
bool operator==( thread::id lhs, thread::id rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
bool operator!=( thread::id lhs, thread::id rhs );
}}
{{dcl | num=3 | since=c++11 | 1=
bool operator&lt;( thread::id lhs, thread::id rhs );
}}
{{dcl | num=4 | since=c++11 | 1=
bool operator&lt;=( thread::id lhs, thread::id rhs );
}}
{{dcl | num=5 | since=c++11 | 1=
bool operator&gt;( thread::id lhs, thread::id rhs );
}}
{{dcl | num=6 | since=c++11 | 1=
bool operator&gt;=( thread::id lhs, thread::id rhs );
}}
{{dcl end}}

Compares two thread identifiers.

@1-2@ Checks whether {{tt|lhs}} and {{tt|rhs}} represent either the same thread, or no thread.

@3-6@ Compares {{tt|lhs}} and {{tt|rhs}} in such a way, that {{tt|lhs}} and {{tt|rhs}} are totally ordered.

===Parameters===
{{par begin}}
{{par | lhs, rhs | thread identifiers to compare}}
{{par end}} 

===Return value===
{{c|true}} whether the corresponding relation holds, {{tt|false}} otherwise.

===Exceptions===
{{noexcept}}

===Complexity===
Constant.

[[de:cpp/thread/thread/id/operator cmp]]
[[es:cpp/thread/thread/id/operator cmp]]
[[fr:cpp/thread/thread/id/operator cmp]]
[[it:cpp/thread/thread/id/operator cmp]]
[[ja:cpp/thread/thread/id/operator cmp]]
[[pt:cpp/thread/thread/id/operator cmp]]
[[ru:cpp/thread/thread/id/operator cmp]]
[[zh:cpp/thread/thread/id/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/id/operator ltlt</title>
    <ns>0</ns>
    <id>9078</id>
    <revision>
      <id>62985</id>
      <parentid>51440</parentid>
      <timestamp>2013-07-01T23:48:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1060">{{title | 1=operator&lt;&lt;{{small|(std::thread::id)}}}}
{{cpp/thread/thread/id/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class CharT, class Traits &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp;
    operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp;&amp; ost, thread::id id );
}}
{{dcl end}}

Writes a textual representation of a thread identifier {{tt|id}} to the output stream {{tt|ost}}. 

If two thread identifiers compare equal, they have identical textual representations; if they do not compare equal, their representations are distinct.

===Parameters===
{{par begin}}
{{par | ost | output stream to insert the data into}}
{{par | id | thread identifier}}
{{par end}} 

===Return value===
{{tt|ost}}

===Exceptions===
(none)

[[de:cpp/thread/thread/id/operator ltlt]]
[[es:cpp/thread/thread/id/operator ltlt]]
[[fr:cpp/thread/thread/id/operator ltlt]]
[[it:cpp/thread/thread/id/operator ltlt]]
[[ja:cpp/thread/thread/id/operator ltlt]]
[[pt:cpp/thread/thread/id/operator ltlt]]
[[ru:cpp/thread/thread/id/operator ltlt]]
[[zh:cpp/thread/thread/id/operator ltlt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/join</title>
    <ns>0</ns>
    <id>2272</id>
    <revision>
      <id>66494</id>
      <parentid>66490</parentid>
      <timestamp>2013-11-26T08:47:24Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>Add &quot;Error Conditions&quot;</comment>
      <text xml:space="preserve" bytes="1925">{{cpp/thread/thread/title|join}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
void join();
}}

Blocks the current thread until the thread identified by {{c|*this}} finishes its execution.

===Parameters===
(none)

===Return value===
(none)

===Preconditions===
{{lc|joinable}} is {{c|true}}

===Postconditions===
{{lc|joinable}} is {{c|false}}

===Exceptions===
{{lc|std::system_error}} if an error occurs.

===Error Conditions===
* {{lc|std::errc|resource_deadlock_would_occur}} if {{c|this-&gt;get_id() {{==}} std::this_thread::get_id()}} (deadlock detected)
* {{lc|std::errc|no_such_process}} if the thread is not valid
* {{lc|std::errc|invalid_argument}} if {{lc|joinable}} is {{c|false}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void foo()
{
    // simulate expensive operation
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    // simulate expensive operation
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::cout &lt;&lt; &quot;starting first helper...\n&quot;;
    std::thread helper1(foo);

    std::cout &lt;&lt; &quot;starting second helper...\n&quot;;
    std::thread helper2(bar);

    std::cout &lt;&lt; &quot;waiting for helpers to finish...&quot; &lt;&lt; std::endl;
    helper1.join();
    helper2.join();
 
    std::cout &lt;&lt; &quot;done!\n&quot;;
}
 | output=
starting first helper...
starting second helper...
waiting for helpers to finish...
done!
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc detach}}
{{dsc inc | cpp/thread/thread/dsc joinable}}
{{dsc end}}

===References===
{{ref std c++11}}
{{ref std | section=30.3.1.5 | title=thread members | id=thread.thread.member}}
{{ref std end}}

[[de:cpp/thread/thread/join]]
[[es:cpp/thread/thread/join]]
[[fr:cpp/thread/thread/join]]
[[it:cpp/thread/thread/join]]
[[ja:cpp/thread/thread/join]]
[[pt:cpp/thread/thread/join]]
[[ru:cpp/thread/thread/join]]
[[zh:cpp/thread/thread/join]]</text>
      <sha1>l8ikj44vxcseaqya79907v0zl6fpbo7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/joinable</title>
    <ns>0</ns>
    <id>2273</id>
    <revision>
      <id>66492</id>
      <parentid>66488</parentid>
      <timestamp>2013-11-26T06:52:03Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>Add const</comment>
      <text xml:space="preserve" bytes="1671">{{cpp/thread/thread/title|joinable}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
bool joinable() const;
}}

Checks if the thread object identifies an active thread of execution. Specifically, returns {{c|true}} if {{c|get_id() !{{=}} std::thread::id()}}. So a default constructed {{c|thread}} is not joinable. 

A thread that has finished executing code, but has not yet been joined is still considered an active thread of execution and is therefore joinable.

===Parameters===
(none)

===Return value===
{{c|true}} if the thread object identifies an active thread of execution, {{c|false}} otherwise

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t;
    std::cout &lt;&lt; &quot;before starting, joinable: &quot; &lt;&lt; t.joinable() &lt;&lt; '\n';

    t = std::thread(foo);
    std::cout &lt;&lt; &quot;after starting, joinable: &quot; &lt;&lt; t.joinable() &lt;&lt; '\n';

    t.join();
}
 | output=
before starting, joinable: 0
after starting, joinable: 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc get_id}}
{{dsc inc | cpp/thread/thread/dsc join}}
{{dsc inc | cpp/thread/thread/dsc detach}}
{{dsc end}}

===References===
{{ref std c++11}}
{{ref std | section=30.3.1.5 | title=thread members | id=thread.thread.member}}
{{ref std end}}

[[de:cpp/thread/thread/joinable]]
[[es:cpp/thread/thread/joinable]]
[[fr:cpp/thread/thread/joinable]]
[[it:cpp/thread/thread/joinable]]
[[ja:cpp/thread/thread/joinable]]
[[pt:cpp/thread/thread/joinable]]
[[ru:cpp/thread/thread/joinable]]
[[zh:cpp/thread/thread/joinable]]</text>
      <sha1>5hgzkretpliblfip9yldn4ml6w2iqcy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/native handle</title>
    <ns>0</ns>
    <id>2277</id>
    <revision>
      <id>66956</id>
      <parentid>63480</parentid>
      <timestamp>2014-01-11T22:57:42Z</timestamp>
      <contributor>
        <ip>95.68.110.50</ip>
      </contributor>
      <comment>Add missing &lt;mutex&gt; include</comment>
      <text xml:space="preserve" bytes="1670">{{cpp/thread/thread/title|native_handle}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
native_handle_type native_handle();
}}

Returns the implementation defined underlying thread handle. 

===Parameters===
(none)

===Return value===
implementation defined handle type representing the thread.

===Exceptions===
(none)

===Example===
{{example
 | Uses native_handle to enable realtime scheduling of C++ threads on a POSIX system
 | code=
#include &lt;thread&gt;
#include &lt;mutex&gt;
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;cstring&gt;
#include &lt;pthread.h&gt;

std::mutex iomutex;
void f(int num)
{
    std::this_thread::sleep_for(std::chrono::seconds(1));

   sched_param sch;
   int policy; 
   pthread_getschedparam(pthread_self(), &amp;policy, &amp;sch);
   std::lock_guard&lt;std::mutex&gt; lk(iomutex);
   std::cout &lt;&lt; &quot;Thread &quot; &lt;&lt; num &lt;&lt; &quot; is executing at priority &quot;
             &lt;&lt; sch.sched_priority &lt;&lt; '\n';
}

int main()
{
    std::thread t1(f, 1), t2(f, 2);

    sched_param sch;
    int policy; 
    pthread_getschedparam(t1.native_handle(), &amp;policy, &amp;sch);
    sch.sched_priority = 20;
    if(pthread_setschedparam(t1.native_handle(), SCHED_FIFO, &amp;sch)) {
        std::cout &lt;&lt; &quot;Failed to setschedparam: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    }

    t1.join(); t2.join();
}
 | output=
Thread 2 is executing at priority 0
Thread 1 is executing at priority 20
}}

[[de:cpp/thread/thread/native handle]]
[[es:cpp/thread/thread/native handle]]
[[fr:cpp/thread/thread/native handle]]
[[it:cpp/thread/thread/native handle]]
[[ja:cpp/thread/thread/native handle]]
[[pt:cpp/thread/thread/native handle]]
[[ru:cpp/thread/thread/native handle]]
[[zh:cpp/thread/thread/native handle]]</text>
      <sha1>jyfkzihttnxhc7yynte6xaoqu7cn7d7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/operator=</title>
    <ns>0</ns>
    <id>2466</id>
    <revision>
      <id>63481</id>
      <parentid>51443</parentid>
      <timestamp>2013-07-10T01:33:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="792">{{cpp/thread/thread/title|operator{{=}}}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 | 1=
thread&amp; operator=( thread&amp;&amp; other );
}}

Assigns the state of {{tt|other}} to {{c|*this}} using move semantics.

If {{c|*this}} still has an associated running thread (i.e. {{c|1=joinable() == true}}), {{c|std::terminate()}} is called.

===Parameters===
{{par begin}}
{{par | other | another thread object to assign to this thread object}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{noexcept}}

[[de:cpp/thread/thread/operator=]]
[[es:cpp/thread/thread/operator=]]
[[fr:cpp/thread/thread/operator=]]
[[it:cpp/thread/thread/operator=]]
[[ja:cpp/thread/thread/operator=]]
[[pt:cpp/thread/thread/operator=]]
[[ru:cpp/thread/thread/operator=]]
[[zh:cpp/thread/thread/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/swap</title>
    <ns>0</ns>
    <id>2268</id>
    <revision>
      <id>63482</id>
      <parentid>59252</parentid>
      <timestamp>2013-07-10T01:33:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1679">{{cpp/thread/thread/title|swap}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
void swap( thread&amp; other );
}}

Exchanges the underlying handles of two thread objects.

===Parameters===
{{par begin}}
{{par | other | the thread to swap with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar);

    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    std::swap(t1, t2);

    std::cout &lt;&lt; &quot;after std::swap(t1, t2):&quot; &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    t1.swap(t2);

    std::cout &lt;&lt; &quot;after t1.swap(t2):&quot; &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    t1.join();
    t2.join();
}
 | output=
thread 1 id: 1892
thread 2 id: 2584
after std::swap(t1, t2):
thread 1 id: 2584
thread 2 id: 1892
after t1.swap(t2):
thread 1 id: 1892
thread 2 id: 2584
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/thread/swap]]
[[es:cpp/thread/thread/swap]]
[[fr:cpp/thread/thread/swap]]
[[it:cpp/thread/thread/swap]]
[[ja:cpp/thread/thread/swap]]
[[pt:cpp/thread/thread/swap]]
[[ru:cpp/thread/thread/swap]]
[[zh:cpp/thread/thread/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/swap2</title>
    <ns>0</ns>
    <id>5499</id>
    <revision>
      <id>62986</id>
      <parentid>59253</parentid>
      <timestamp>2013-07-01T23:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1838">{{cpp/title | swap{{small|(std::thread)}}}}
{{cpp/thread/thread/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( thread &amp;lhs, thread &amp;rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::thread}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | threads whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar);

    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    std::swap(t1, t2);

    std::cout &lt;&lt; &quot;after std::swap(t1, t2):&quot; &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    t1.swap(t2);

    std::cout &lt;&lt; &quot;after t1.swap(t2):&quot; &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 1 id: &quot; &lt;&lt; t1.get_id() &lt;&lt; std::endl;
    std::cout &lt;&lt; &quot;thread 2 id: &quot; &lt;&lt; t2.get_id() &lt;&lt; std::endl;

    t1.join();
    t2.join();
}
 | output=
thread 1 id: 1892
thread 2 id: 2584
after std::swap(t1, t2):
thread 1 id: 2584
thread 2 id: 1892
after t1.swap(t2):
thread 1 id: 1892
thread 2 id: 2584
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc swap}}
{{dsc end}}

[[de:cpp/thread/thread/swap2]]
[[es:cpp/thread/thread/swap2]]
[[fr:cpp/thread/thread/swap2]]
[[it:cpp/thread/thread/swap2]]
[[ja:cpp/thread/thread/swap2]]
[[pt:cpp/thread/thread/swap2]]
[[ru:cpp/thread/thread/swap2]]
[[zh:cpp/thread/thread/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/thread</title>
    <ns>0</ns>
    <id>2464</id>
    <revision>
      <id>71956</id>
      <parentid>71954</parentid>
      <timestamp>2014-07-04T17:20:44Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <comment>Undo revision 71954 by [[Special:Contributions/Lingxi|Lingxi]] ([[User talk:Lingxi|talk]])</comment>
      <text xml:space="preserve" bytes="4492">{{cpp/thread/thread/title|thread}}
{{cpp/thread/thread/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
thread();
}}
{{dcl | num=2 | since=c++11 |
thread( thread&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 |
template&lt; class Function, class... Args &gt; 
explicit thread( Function&amp;&amp; f, Args&amp;&amp;... args );
}}
{{dcl | num=4 | since=c++11 |1=
thread(const thread&amp;) = delete;
}}
{{dcl end}}

Constructs new thread object.

@1@ Creates new thread object which does not represent a thread.

@2@ Move constructor. Constructs the thread object to represent the thread of execution that was represented by {{tt|other}}. After this call {{tt|other}} no longer represents a thread of execution.

@3@ Creates new {{tt|std::thread}} object and associates it with a thread of execution. First the constructor copies/moves all arguments {{tt|args...}} to thread-accessible storage as if by the function:
{{source|1=
template &lt;class T&gt;
typename decay&lt;T&gt;::type decay_copy(T&amp;&amp; v) {
    return std::forward&lt;T&gt;(v);
}
}}

@@ Any exceptions thrown during evaluation and copying/moving of the arguments are thrown in the current thread, not the new thread. 

@@ The code that will be run in the new thread is defined as follows. {{cpp/invoke|args=value_args | desc= and {{tt|value_args}} is the result of calling {{tt|decay_copy}} as defined above. The following code will be run in the new thread:}}

@@ {{mark c++14}} This constructor does not participate in overload resolution if {{c|std::decay&lt;Function&gt;::type}} is the same type as {{c|std::thread}}.

@4@ The copy constructor is deleted; threads are not copyable. No two {{tt|std::thread}} objects may represent the same thread of execution.

===Parameters===
{{par begin}}
{{par | other | another thread object to construct this thread object with}}
{{par | f | {{concept|Callable}} object to execute in the new thread}}
{{par | args... | arguments to pass to the new function}}
{{par end}}

===Postconditions===
@1@ {{lc|get_id()}} equal to {{lc|std::thread::id()}} (i.e. {{lc|joinable}} is {{c|false}})
@2@ {{c|other.get_id()}} equal to {{lc|std::thread::id()}} and {{lc|get_id()}} returns the value of {{c|other.get_id()}} prior to the start of construction
@3@ {{lc|get_id()}} not equal to {{lc|std::thread::id()}} (i.e. {{lc|joinable}} is {{c|true}})

===Exceptions===
@1-2@ {{noexcept}}

@3@ {{lc|std::system_error}} if the thread could not be started. The exception may represent the error condition {{tt|std::errc::resource_unavailable_try_again}} or another implementation-specific error condition.

===Notes===
The arguments to the thread function are copied by value. If a reference argument needs to be passed to the thread function, it has to be wrapped (e.g. with {{lc|std::ref}} or {{lc|std::cref}}).

Any return value from the function is ignored. If the function throws an exception, {{lc|std::terminate}} is called. In order to pass return values or exceptions back to the calling thread, {{lc|std::promise}} or {{lc|std::async}} may be used.

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;
#include &lt;functional&gt;
#include &lt;atomic&gt;

void f1(int n)
{
    for (int i = 0; i &lt; 5; ++i) {
        std::cout &lt;&lt; &quot;Thread 1 executing\n&quot;;
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

void f2(int&amp; n)
{
    for (int i = 0; i &lt; 5; ++i) {
        std::cout &lt;&lt; &quot;Thread 2 executing\n&quot;;
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main()
{
    int n = 0;
    std::thread t1; // t1 is not a thread
    std::thread t2(f1, n + 1); // pass by value
    std::thread t3(f2, std::ref(n)); // pass by reference
    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
    t2.join();
    t4.join();
    std::cout &lt;&lt; &quot;Final value of n is &quot; &lt;&lt; n &lt;&lt; '\n';
}
 |output=
Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 2 executing
Thread 1 executing
Final value of n is 5
}}

===References===
{{ref std c++11}}
{{ref std | section=30.3.1.2 | title=thread constructors | id=thread.thread.constr}}
{{ref std end}}

[[de:cpp/thread/thread/thread]]
[[es:cpp/thread/thread/thread]]
[[fr:cpp/thread/thread/thread]]
[[it:cpp/thread/thread/thread]]
[[ja:cpp/thread/thread/thread]]
[[pt:cpp/thread/thread/thread]]
[[ru:cpp/thread/thread/thread]]
[[zh:cpp/thread/thread/thread]]</text>
      <sha1>jfjtlrc3smp0c85t0x3ivyt7lcjfv57</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/thread/~thread</title>
    <ns>0</ns>
    <id>2465</id>
    <revision>
      <id>63483</id>
      <parentid>43268</parentid>
      <timestamp>2013-07-10T01:33:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="518">{{cpp/thread/thread/title|~thread}}
{{cpp/thread/thread/navbar}}
{{ddcl | since=c++11 |
~thread();
}}

Destroys the thread object. If {{c|*this}} still has an associated running thread (i.e. {{c|1=joinable() == true}}), {{c|std::terminate()}} is called.

[[de:cpp/thread/thread/~thread]]
[[es:cpp/thread/thread/~thread]]
[[fr:cpp/thread/thread/~thread]]
[[it:cpp/thread/thread/~thread]]
[[ja:cpp/thread/thread/~thread]]
[[pt:cpp/thread/thread/~thread]]
[[ru:cpp/thread/thread/~thread]]
[[zh:cpp/thread/thread/~thread]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex</title>
    <ns>0</ns>
    <id>2302</id>
    <revision>
      <id>67040</id>
      <parentid>65481</parentid>
      <timestamp>2014-01-18T13:58:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+dtor/op=</comment>
      <text xml:space="preserve" bytes="1775">{{cpp/title|timed_mutex}}
{{cpp/thread/timed_mutex/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
class timed_mutex;
}}

The {{tt|timed_mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. 

In a manner similar to {{ltt|cpp/thread/mutex}}, {{tt|timed_mutex}} offers exclusive, non-recursive ownership semantics.  In addition, {{tt|timed_mutex}} provides the ability to attempt to claim ownership of a {{tt|timed_mutex}} with a timeout via the {{ltf|cpp/thread/timed_mutex/try_lock_for}} and {{ltf|cpp/thread/timed_mutex/try_lock_until}} methods.

The {{tt|timed_mutex}} class satisfies all requirements of {{concept|TimedMutex}} and {{concept|StandardLayoutType}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|native_handle_type}} | ''implementation-defined''}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc constructor | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc destructor | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc operator{{=}}}}

{{dsc h2 | Locking}}
{{dsc inc | cpp/thread/mutex/dsc lock | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | timed_mutex}}
{{dsc inc | cpp/thread/mutex/dsc unlock | timed_mutex}}

{{dsc h2 | Native handle}}
{{dsc inc | cpp/thread/mutex/dsc native_handle | timed_mutex}}
{{dsc end}}

[[de:cpp/thread/timed mutex]]
[[es:cpp/thread/timed mutex]]
[[fr:cpp/thread/timed mutex]]
[[it:cpp/thread/timed mutex]]
[[ja:cpp/thread/timed mutex]]
[[pt:cpp/thread/timed mutex]]
[[ru:cpp/thread/timed mutex]]
[[zh:cpp/thread/timed mutex]]</text>
      <sha1>kgy4bqopodl9lx4duag7hs9g8x4fyc4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/lock</title>
    <ns>0</ns>
    <id>2337</id>
    <revision>
      <id>51448</id>
      <parentid>43255</parentid>
      <timestamp>2013-06-01T04:03:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="331">{{include page|cpp/thread/mutex/lock|timed_mutex}}

[[de:cpp/thread/timed mutex/lock]]
[[es:cpp/thread/timed mutex/lock]]
[[fr:cpp/thread/timed mutex/lock]]
[[it:cpp/thread/timed mutex/lock]]
[[ja:cpp/thread/timed mutex/lock]]
[[pt:cpp/thread/timed mutex/lock]]
[[ru:cpp/thread/timed mutex/lock]]
[[zh:cpp/thread/timed mutex/lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/native handle</title>
    <ns>0</ns>
    <id>2342</id>
    <revision>
      <id>51449</id>
      <parentid>43248</parentid>
      <timestamp>2013-06-01T04:03:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="412">{{include page|cpp/thread/mutex/native_handle|timed_mutex}}

[[de:cpp/thread/timed mutex/native handle]]
[[es:cpp/thread/timed mutex/native handle]]
[[fr:cpp/thread/timed mutex/native handle]]
[[it:cpp/thread/timed mutex/native handle]]
[[ja:cpp/thread/timed mutex/native handle]]
[[pt:cpp/thread/timed mutex/native handle]]
[[ru:cpp/thread/timed mutex/native handle]]
[[zh:cpp/thread/timed mutex/native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/timed mutex</title>
    <ns>0</ns>
    <id>4489</id>
    <revision>
      <id>51450</id>
      <parentid>43244</parentid>
      <timestamp>2013-06-01T04:03:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="394">{{include page|cpp/thread/mutex/constructor|timed_mutex}}

[[de:cpp/thread/timed mutex/timed mutex]]
[[es:cpp/thread/timed mutex/timed mutex]]
[[fr:cpp/thread/timed mutex/timed mutex]]
[[it:cpp/thread/timed mutex/timed mutex]]
[[ja:cpp/thread/timed mutex/timed mutex]]
[[pt:cpp/thread/timed mutex/timed mutex]]
[[ru:cpp/thread/timed mutex/timed mutex]]
[[zh:cpp/thread/timed mutex/timed mutex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/try lock</title>
    <ns>0</ns>
    <id>2338</id>
    <revision>
      <id>51451</id>
      <parentid>43235</parentid>
      <timestamp>2013-06-01T04:03:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="367">{{include page|cpp/thread/mutex/try_lock|timed_mutex}}

[[de:cpp/thread/timed mutex/try lock]]
[[es:cpp/thread/timed mutex/try lock]]
[[fr:cpp/thread/timed mutex/try lock]]
[[it:cpp/thread/timed mutex/try lock]]
[[ja:cpp/thread/timed mutex/try lock]]
[[pt:cpp/thread/timed mutex/try lock]]
[[ru:cpp/thread/timed mutex/try lock]]
[[zh:cpp/thread/timed mutex/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/try lock for</title>
    <ns>0</ns>
    <id>2339</id>
    <revision>
      <id>51452</id>
      <parentid>43227</parentid>
      <timestamp>2013-06-01T04:03:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="403">{{include page|cpp/thread/mutex/try_lock_for|timed_mutex}}

[[de:cpp/thread/timed mutex/try lock for]]
[[es:cpp/thread/timed mutex/try lock for]]
[[fr:cpp/thread/timed mutex/try lock for]]
[[it:cpp/thread/timed mutex/try lock for]]
[[ja:cpp/thread/timed mutex/try lock for]]
[[pt:cpp/thread/timed mutex/try lock for]]
[[ru:cpp/thread/timed mutex/try lock for]]
[[zh:cpp/thread/timed mutex/try lock for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/try lock until</title>
    <ns>0</ns>
    <id>2340</id>
    <revision>
      <id>51453</id>
      <parentid>43220</parentid>
      <timestamp>2013-06-01T04:03:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="421">{{include page|cpp/thread/mutex/try_lock_until|timed_mutex}}

[[de:cpp/thread/timed mutex/try lock until]]
[[es:cpp/thread/timed mutex/try lock until]]
[[fr:cpp/thread/timed mutex/try lock until]]
[[it:cpp/thread/timed mutex/try lock until]]
[[ja:cpp/thread/timed mutex/try lock until]]
[[pt:cpp/thread/timed mutex/try lock until]]
[[ru:cpp/thread/timed mutex/try lock until]]
[[zh:cpp/thread/timed mutex/try lock until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/unlock</title>
    <ns>0</ns>
    <id>2341</id>
    <revision>
      <id>51454</id>
      <parentid>43213</parentid>
      <timestamp>2013-06-01T04:03:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="349">{{include page|cpp/thread/mutex/unlock|timed_mutex}}

[[de:cpp/thread/timed mutex/unlock]]
[[es:cpp/thread/timed mutex/unlock]]
[[fr:cpp/thread/timed mutex/unlock]]
[[it:cpp/thread/timed mutex/unlock]]
[[ja:cpp/thread/timed mutex/unlock]]
[[pt:cpp/thread/timed mutex/unlock]]
[[ru:cpp/thread/timed mutex/unlock]]
[[zh:cpp/thread/timed mutex/unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/timed mutex/~timed mutex</title>
    <ns>0</ns>
    <id>13126</id>
    <revision>
      <id>67044</id>
      <timestamp>2014-01-18T14:00:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fwd to template</comment>
      <text xml:space="preserve" bytes="56">{{include page|cpp/thread/mutex/destructor|timed_mutex}}</text>
      <sha1>6i5p9j13mvssmrypi7icvzrqhaidbf2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/try lock</title>
    <ns>0</ns>
    <id>2504</id>
    <revision>
      <id>63485</id>
      <parentid>59259</parentid>
      <timestamp>2013-07-10T01:33:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3491">{{cpp/title|try_lock}}
{{cpp/thread/navbar}}
{{ddcl | header=mutex | since=c++11 |
template&lt; class Lockable1, class Lockable2, class LockableN... &gt;
int try_lock( Lockable1&amp; lock1, Lockable2&amp; lock2, LockableN&amp; lockn... );
}}

Tries to lock each of the given {{concept|Lockable}} objects {{tt|lock1}}, {{tt|lock2}}, {{tt|...}}, {{tt|lockn}} by calling {{tt|try_lock}} in order beginning with the first. 

If a call to {{tt|try_lock}} fails, {{tt|unlock}} is called for any locked objects and a {{tt|0}}-based index of the object that failed to lock is returned.

If a call to {{tt|try_lock}} results in an exception, {{tt|unlock}} is called for any locked objects before rethrowing.

===Parameters===
{{par begin}}
{{par | lock1, lock2, ... , lockn | the {{concept|Lockable}} objects to lock}}
{{par end}}

===Return value===
{{tt|-1}} on success, or {{tt|0}}-based index value of the object that failed to lock.

===Example===
{{example|The following example uses {{tt|std::try_lock}} to periodically tally and reset counters running in separate threads.
 | p=true
 | code=
#include &lt;mutex&gt;
#include &lt;vector&gt;
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;chrono&gt;

int main()
{
    int foo_count = 0;
    std::mutex foo_count_mutex;
    int bar_count = 0;
    std::mutex bar_count_mutex;
    int overall_count = 0;
    bool done = false;
    std::mutex done_mutex;

    auto increment = [](int &amp;counter, std::mutex &amp;m,  const char *desc) {
        for (int i = 0; i &lt; 10; ++i) {
            std::unique_lock&lt;std::mutex&gt; lock(m);
            ++counter;
            std::cout &lt;&lt; desc &lt;&lt; &quot;: &quot; &lt;&lt; counter &lt;&lt; '\n';
            lock.unlock();
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    };

    std::thread increment_foo(increment, std::ref(foo_count), 
        std::ref(foo_count_mutex), &quot;foo&quot;);
    std::thread increment_bar(increment, std::ref(bar_count), 
        std::ref(bar_count_mutex), &quot;bar&quot;);

    std::thread update_overall([&amp;]() {
        done_mutex.lock();
        while (!done) {
            done_mutex.unlock();
            int result = std::try_lock(foo_count_mutex, bar_count_mutex);
            if (result == -1) {
                overall_count += foo_count + bar_count;
                foo_count = 0;
                bar_count = 0;
                std::cout &lt;&lt; &quot;overall: &quot; &lt;&lt; overall_count &lt;&lt; '\n';
                foo_count_mutex.unlock();
                bar_count_mutex.unlock();
            }
            std::this_thread::sleep_for(std::chrono::seconds(2));
            done_mutex.lock();
        }
        done_mutex.unlock();
    });

    increment_foo.join();
    increment_bar.join();
    done_mutex.lock();
    done = true;
    done_mutex.unlock();
    update_overall.join();

    std::cout &lt;&lt; &quot;Done processing\n&quot;
              &lt;&lt; &quot;foo: &quot; &lt;&lt; foo_count &lt;&lt; '\n'
              &lt;&lt; &quot;bar: &quot; &lt;&lt; bar_count &lt;&lt; '\n'
              &lt;&lt; &quot;overall: &quot; &lt;&lt; overall_count &lt;&lt; '\n';
}
 | output=
bar: 1
foo: 1
foo: 2
bar: 2
foo: 3
overall: 5
bar: 1
foo: 1
bar: 2
foo: 2
bar: 3
overall: 10
bar: 1
foo: 1
bar: 2
foo: 2
overall: 14
bar: 1
foo: 1
bar: 2
overall: 17
foo: 1
bar: 1
foo: 2
overall: 20
Done processing
foo: 0
bar: 0
overall: 20
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/dsc lock}}
{{dsc end}}

[[de:cpp/thread/try lock]]
[[es:cpp/thread/try lock]]
[[fr:cpp/thread/try lock]]
[[it:cpp/thread/try lock]]
[[ja:cpp/thread/try lock]]
[[pt:cpp/thread/try lock]]
[[ru:cpp/thread/try lock]]
[[zh:cpp/thread/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock</title>
    <ns>0</ns>
    <id>2731</id>
    <revision>
      <id>67996</id>
      <parentid>67991</parentid>
      <timestamp>2014-03-12T01:40:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 67991 by [[Special:Contributions/Arbalest|Arbalest]] ([[User talk:Arbalest|talk]]) back to consistent content</comment>
      <text xml:space="preserve" bytes="3223">{{cpp/title|unique_lock}}
{{cpp/thread/unique_lock/navbar}}
{{ddcl | header=mutex | since=c++11 | 1=
template&lt; class Mutex &gt;
class unique_lock;
}}

The class {{c|unique_lock}} is a general-purpose mutex ownership wrapper allowing deferred locking, time-constrained attempts at locking, recursive locking, transfer of lock ownership, and use with condition variables. 

The class {{c|unique_lock}} is movable, but not copyable -- it meets the requirements of {{concept|MoveConstructible}} and {{concept|MoveAssignable}} but not of {{concept|CopyConstructible}} or {{concept|CopyAssignable}}.

The class {{c|unique_lock}} meets the {{concept|BasicLockable}} requirements. If '''Mutex''' meets the {{concept|Lockable}} requirements, {{c|unique_lock}} also meets the {{concept|Lockable}} requirements (ex.: can be used in {{lc|std::lock}}); if '''Mutex''' meets the {{concept|TimedLockable}} requirements, {{c|unique_lock}} also meets the {{concept|TimedLockable}} requirements.

===Template parameters===
{{par begin}}
{{par | Mutex | the type of the mutex to lock. The type must meet the {{concept|BasicLockable}} requirements}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|mutex_type}} | {{c|Mutex}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc constructor}}
{{dsc inc | cpp/thread/unique_lock/dsc destructor}}
{{dsc inc | cpp/thread/unique_lock/dsc operator{{=}}}}

{{dsc h2 | Locking}}
{{dsc inc | cpp/thread/unique_lock/dsc lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/thread/unique_lock/dsc swap}}
{{dsc inc | cpp/thread/unique_lock/dsc release}}

{{dsc h2 | Observers}}
{{dsc inc | cpp/thread/unique_lock/dsc mutex}}
{{dsc inc | cpp/thread/unique_lock/dsc owns_lock}}
{{dsc inc | cpp/thread/unique_lock/dsc operator bool}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc swap2}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

struct Box {
    explicit Box(int num) : num_things{num} {}

    int num_things;
    std::mutex m;
};

void transfer(Box &amp;from, Box &amp;to, int num)
{
    // don't actually take the locks yet
    std::unique_lock&lt;std::mutex&gt; lock1(from.m, std::defer_lock);
    std::unique_lock&lt;std::mutex&gt; lock2(to.m, std::defer_lock);

    // lock both unique_locks without deadlock
    std::lock(lock1, lock2);

    from.num_things -= num;
    to.num_things += num;

    // 'from.m' and 'to.m' mutexes unlocked in 'unique_lock' dtors
}

int main()
{
    Box acc1(100);
    Box acc2(50);

    std::thread t1(transfer, std::ref(acc1), std::ref(acc2), 10);
    std::thread t2(transfer, std::ref(acc2), std::ref(acc1), 5);

    t1.join();
    t2.join();
}
 | output=
}}

[[de:cpp/thread/unique lock]]
[[es:cpp/thread/unique lock]]
[[fr:cpp/thread/unique lock]]
[[it:cpp/thread/unique lock]]
[[ja:cpp/thread/unique lock]]
[[pt:cpp/thread/unique lock]]
[[ru:cpp/thread/unique lock]]
[[zh:cpp/thread/unique lock]]</text>
      <sha1>jcwngzfh0qakfdrhjexpflw9dfco42m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/lock</title>
    <ns>0</ns>
    <id>4483</id>
    <revision>
      <id>62988</id>
      <parentid>59263</parentid>
      <timestamp>2013-07-01T23:49:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2448">{{cpp/thread/unique_lock/title|lock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void lock();
}}
{{dcl end}}

Locks the associated mutex. Effectively calls {{c|mutex()-&gt;lock()}}.

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;lock()}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|The following example uses {{tt|lock}} to re-acquire a mutex that was unlocked.
 |p=true
 |code=
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;chrono&gt;

int main()
{
    int counter = 0;
    std::mutex counter_mutex;
    std::vector&lt;std::thread&gt; threads;
  
    auto worker_task = [&amp;](int id) {
        std::unique_lock&lt;std::mutex&gt; lock(counter_mutex);
        ++counter;
        std::cout &lt;&lt; id &lt;&lt; &quot;, initial counter: &quot; &lt;&lt; counter &lt;&lt; '\n';
        lock.unlock();

        // don't hold the lock while we simulate an expensive operation
        std::this_thread::sleep_for(std::chrono::seconds(1));

        lock.lock();
        ++counter;
        std::cout &lt;&lt; id &lt;&lt; &quot;, final counter: &quot; &lt;&lt; counter &lt;&lt; '\n';
    };

    for (int i = 0; i &lt; 10; ++i) threads.emplace_back(worker_task, i);

    for (auto &amp;thread : threads) thread.join();
}
 |output=
0, initial counter: 1
1, initial counter: 2
2, initial counter: 3
3, initial counter: 4
4, initial counter: 5
5, initial counter: 6
6, initial counter: 7
7, initial counter: 8
8, initial counter: 9
9, initial counter: 10
6, final counter: 11
3, final counter: 12
4, final counter: 13
2, final counter: 14
5, final counter: 15
0, final counter: 16
1, final counter: 17
7, final counter: 18
9, final counter: 19
8, final counter: 20
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/unique lock/lock]]
[[es:cpp/thread/unique lock/lock]]
[[fr:cpp/thread/unique lock/lock]]
[[it:cpp/thread/unique lock/lock]]
[[ja:cpp/thread/unique lock/lock]]
[[pt:cpp/thread/unique lock/lock]]
[[ru:cpp/thread/unique lock/lock]]
[[zh:cpp/thread/unique lock/lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/mutex</title>
    <ns>0</ns>
    <id>4480</id>
    <revision>
      <id>62989</id>
      <parentid>51458</parentid>
      <timestamp>2013-07-01T23:49:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="743">{{cpp/thread/unique_lock/title|mutex}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
mutex_type* mutex() const;
}}
{{dcl end}}

Returns a pointer to the associated mutex, or a null pointer if there is no associated mutex.

===Parameters===
(none)

===Return value===
Pointer to the associated mutex or a null pointer if there is no associated mutex.

===Exceptions===
{{noexcept}}

===Example===
{{example|
 |code=
 |output=
}}

[[de:cpp/thread/unique lock/mutex]]
[[es:cpp/thread/unique lock/mutex]]
[[fr:cpp/thread/unique lock/mutex]]
[[it:cpp/thread/unique lock/mutex]]
[[ja:cpp/thread/unique lock/mutex]]
[[pt:cpp/thread/unique lock/mutex]]
[[ru:cpp/thread/unique lock/mutex]]
[[zh:cpp/thread/unique lock/mutex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/operator=</title>
    <ns>0</ns>
    <id>4487</id>
    <revision>
      <id>68875</id>
      <parentid>62990</parentid>
      <timestamp>2014-03-22T21:02:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2104</comment>
      <text xml:space="preserve" bytes="976">{{cpp/thread/unique_lock/title|operator{{=}}}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
unique_lock&amp; operator=( unique_lock&amp;&amp; other );
}}
{{dcl end}}

Move assignment operator. Replaces the contents with those of {{tt|other}} using move semantics. 

If prior to the call {{c|*this}} has an associated mutex and has acquired ownership of it, the mutex is unlocked. 

===Parameters===
{{par begin}}
{{par | other | another {{tt|unique_lock}} to replace the state with}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev|until=c++14|{{noexcept}}}}
{{rev|since=c++14|Throws nothing}}
{{rev end}}

[[de:cpp/thread/unique lock/operator=]]
[[es:cpp/thread/unique lock/operator=]]
[[fr:cpp/thread/unique lock/operator=]]
[[it:cpp/thread/unique lock/operator=]]
[[ja:cpp/thread/unique lock/operator=]]
[[pt:cpp/thread/unique lock/operator=]]
[[ru:cpp/thread/unique lock/operator=]]
[[zh:cpp/thread/unique lock/operator=]]</text>
      <sha1>9u3ive8g6eeiknjpmc612u5hau40xl5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/operator bool</title>
    <ns>0</ns>
    <id>4478</id>
    <revision>
      <id>64227</id>
      <parentid>62991</parentid>
      <timestamp>2013-08-15T15:52:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="889">{{cpp/thread/unique_lock/title|operator bool}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
explicit operator bool() const;
}}
{{dcl end}}

Checks whether {{c|*this}} owns a locked mutex or not. Effectively calls {{lc|owns_lock()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} has an associated mutex and has acquired ownership of it, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc owns_lock}}
{{dsc end}}

[[de:cpp/thread/unique lock/operator bool]]
[[es:cpp/thread/unique lock/operator bool]]
[[fr:cpp/thread/unique lock/operator bool]]
[[it:cpp/thread/unique lock/operator bool]]
[[ja:cpp/thread/unique lock/operator bool]]
[[pt:cpp/thread/unique lock/operator bool]]
[[ru:cpp/thread/unique lock/operator bool]]
[[zh:cpp/thread/unique lock/operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/owns lock</title>
    <ns>0</ns>
    <id>4479</id>
    <revision>
      <id>62992</id>
      <parentid>59265</parentid>
      <timestamp>2013-07-01T23:49:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="811">{{cpp/thread/unique_lock/title|owns_lock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
bool owns_lock() const;
}}
{{dcl end}}

Checks whether {{c|*this}} owns a locked mutex or not.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} has an associated mutex and has acquired ownership of it, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc operator_bool}}
{{dsc end}}

[[de:cpp/thread/unique lock/owns lock]]
[[es:cpp/thread/unique lock/owns lock]]
[[fr:cpp/thread/unique lock/owns lock]]
[[it:cpp/thread/unique lock/owns lock]]
[[ja:cpp/thread/unique lock/owns lock]]
[[pt:cpp/thread/unique lock/owns lock]]
[[ru:cpp/thread/unique lock/owns lock]]
[[zh:cpp/thread/unique lock/owns lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/release</title>
    <ns>0</ns>
    <id>4481</id>
    <revision>
      <id>62993</id>
      <parentid>59268</parentid>
      <timestamp>2013-07-01T23:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="977">{{cpp/thread/unique_lock/title|release}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
mutex_type* release();
}}
{{dcl end}}

Breaks the association of the associated mutex, if any, and {{c|*this}}. 

No locks are unlocked. If the {{c|*this}} held ownership of the associated mutex prior to the call, the caller is now responsible to unlock the mutex.

===Parameters===
(none)

===Return value===
Pointer to the associated mutex or {{lc|NULL}} if there was no associated mutex.

===Exceptions===
{{noexcept}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/unique lock/release]]
[[es:cpp/thread/unique lock/release]]
[[fr:cpp/thread/unique lock/release]]
[[it:cpp/thread/unique lock/release]]
[[ja:cpp/thread/unique lock/release]]
[[pt:cpp/thread/unique lock/release]]
[[ru:cpp/thread/unique lock/release]]
[[zh:cpp/thread/unique lock/release]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/swap</title>
    <ns>0</ns>
    <id>5513</id>
    <revision>
      <id>63487</id>
      <parentid>59269</parentid>
      <timestamp>2013-07-10T01:33:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="786">{{cpp/thread/unique_lock/title|swap}}
{{cpp/thread/unique_lock/navbar}}
{{ddcl | since=c++11 |
template&lt; class Mutex &gt;
void swap( unique_lock&lt;Mutex&gt;&amp; other );
}}

Exchanges the internal states of the lock objects.

===Parameters===
{{par begin}}
{{par | other | the lock to swap the state with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc swap2}}
{{dsc end}}

[[de:cpp/thread/unique lock/swap]]
[[es:cpp/thread/unique lock/swap]]
[[fr:cpp/thread/unique lock/swap]]
[[it:cpp/thread/unique lock/swap]]
[[ja:cpp/thread/unique lock/swap]]
[[pt:cpp/thread/unique lock/swap]]
[[ru:cpp/thread/unique lock/swap]]
[[zh:cpp/thread/unique lock/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/swap2</title>
    <ns>0</ns>
    <id>5512</id>
    <revision>
      <id>64860</id>
      <parentid>63150</parentid>
      <timestamp>2013-08-27T01:33:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>missing since</comment>
      <text xml:space="preserve" bytes="991">{{cpp/title | swap&lt;small&gt;(std::unique_lock)&lt;/small&gt;}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class Mutex &gt;
void swap( unique_lock&lt;Mutex&gt;&amp; lhs, 
           unique_lock&lt;Mutex&gt;&amp; rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{lc|std::unique_lock}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | lock wrappers whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc swap}}
{{dsc end}}

[[de:cpp/thread/unique lock/swap2]]
[[es:cpp/thread/unique lock/swap2]]
[[fr:cpp/thread/unique lock/swap2]]
[[it:cpp/thread/unique lock/swap2]]
[[ja:cpp/thread/unique lock/swap2]]
[[pt:cpp/thread/unique lock/swap2]]
[[ru:cpp/thread/unique lock/swap2]]
[[zh:cpp/thread/unique lock/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/try lock</title>
    <ns>0</ns>
    <id>4484</id>
    <revision>
      <id>62994</id>
      <parentid>59273</parentid>
      <timestamp>2013-07-01T23:49:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1421">{{cpp/thread/unique_lock/title|try_lock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
bool try_lock();
}}
{{dcl end}}

Tries to lock the associated mutex without blocking. Effectively calls {{c|mutex()-&gt;try_lock()}}.

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
(none)

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock()}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/unique lock/try lock]]
[[es:cpp/thread/unique lock/try lock]]
[[fr:cpp/thread/unique lock/try lock]]
[[it:cpp/thread/unique lock/try lock]]
[[ja:cpp/thread/unique lock/try lock]]
[[pt:cpp/thread/unique lock/try lock]]
[[ru:cpp/thread/unique lock/try lock]]
[[zh:cpp/thread/unique lock/try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/try lock for</title>
    <ns>0</ns>
    <id>4485</id>
    <revision>
      <id>62995</id>
      <parentid>59274</parentid>
      <timestamp>2013-07-01T23:49:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2005">{{cpp/thread/unique_lock/title|try_lock_for}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class Rep, class Period &gt;
bool try_lock_for( const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl end}}

Tries to lock the associated mutex. Blocks until specified {{tt|timeout_duration}} has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. Effectively calls {{c|mutex()-&gt;try_lock_for(timeout_duration)}}.

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
{{par begin}}
{{par | timeout_duration | maximum duration to block for}}
{{par end}}

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock_for(timeout_duration)}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_until}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/unique lock/try lock for]]
[[es:cpp/thread/unique lock/try lock for]]
[[fr:cpp/thread/unique lock/try lock for]]
[[it:cpp/thread/unique lock/try lock for]]
[[ja:cpp/thread/unique lock/try lock for]]
[[pt:cpp/thread/unique lock/try lock for]]
[[ru:cpp/thread/unique lock/try lock for]]
[[zh:cpp/thread/unique lock/try lock for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/try lock until</title>
    <ns>0</ns>
    <id>4486</id>
    <revision>
      <id>62996</id>
      <parentid>59277</parentid>
      <timestamp>2013-07-01T23:49:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1931">{{cpp/thread/unique_lock/title|try_lock_until}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt; class Clock, class Duration &gt;
bool try_lock_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Tries to lock the associated mutex. Blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. May block for longer than until {{tt|timeout_time}} has been reached.

Effectively calls {{c|mutex()-&gt;try_lock_until(timeout_time)}}

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is already locked.

===Parameters===
{{par begin}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Return value===
{{c|true}} if the ownership of the mutex has been acquired successfully, {{c|false}} otherwise.

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;try_lock_for(timeout_time)}}

* If there is no associated mutex, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

* If the mutex is already locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::resource_deadlock_would_occur}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock}}
{{dsc inc | cpp/thread/unique_lock/dsc try_lock_for}}
{{dsc inc | cpp/thread/unique_lock/dsc unlock}}
{{dsc end}}

[[de:cpp/thread/unique lock/try lock until]]
[[es:cpp/thread/unique lock/try lock until]]
[[fr:cpp/thread/unique lock/try lock until]]
[[it:cpp/thread/unique lock/try lock until]]
[[ja:cpp/thread/unique lock/try lock until]]
[[pt:cpp/thread/unique lock/try lock until]]
[[ru:cpp/thread/unique lock/try lock until]]
[[zh:cpp/thread/unique lock/try lock until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/unique lock</title>
    <ns>0</ns>
    <id>4475</id>
    <revision>
      <id>65438</id>
      <parentid>65437</parentid>
      <timestamp>2013-09-15T14:46:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template bullets</comment>
      <text xml:space="preserve" bytes="5450">{{cpp/thread/unique_lock/title|unique_lock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
unique_lock();
}}
{{dcl | num=2 | since=c++11 | 1=
unique_lock( unique_lock&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 | 1=
explicit unique_lock( mutex_type&amp; m );
}}
{{dcl | num=4 | since=c++11 | 1=
unique_lock( mutex_type&amp; m, std::defer_lock_t t );
}}
{{dcl | num=5 | since=c++11 | 1=
unique_lock( mutex_type&amp; m, std::try_to_lock_t t );
}}
{{dcl | num=6 | since=c++11 | 1=
unique_lock( mutex_type&amp; m, std::adopt_lock_t t );
}}
{{dcl | num=7 | since=c++11 | 1=
template&lt; class Rep, class Period &gt;
unique_lock( mutex_type&amp; m, 
             const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl | num=8 | since=c++11 | 1=
template&lt; class Clock, class Duration &gt;
unique_lock( mutex_type&amp; m, 
             const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Constructs a {{tt|unique_lock}}, optionally locking the supplied mutex.

@1@ Constructs a {{tt|unique_lock}} with no associated mutex.
@2@ Move constructor. Initializes the {{tt|unique_lock}} with the contents of {{tt|other}}. Leaves {{tt|other}} with no associated mutex.
@3-8@ Constructs a {{tt|unique_lock}} with {{tt|m}} as the associated mutex. Additionally:
:@3@ Locks the associated mutex by calling {{c|m.lock()}}. The behavior is undefined if the current thread already owns the mutex except when the mutex is recursive.
:@4@ Does not lock the associated mutex.
:@5@ Tries to lock the associated mutex without blocking by calling {{c|m.try_lock()}}. The behavior is undefined if the current thread already owns the mutex except when the mutex is recursive.
:@6@ Assumes the calling thread already owns {{tt|m}}.
:@7@ Tries to lock the associated mutex by calling {{c|m.try_lock_for(timeout_duration)}}. Blocks until specified {{tt|timeout_duration}} has elapsed or the lock is acquired, whichever comes first. May block for longer than {{tt|timeout_duration}}.
:@8@ Tries to lock the associated mutex by calling {{c|m.try_lock_until(timeout_time)}}. Blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. May block for longer than until {{tt|timeout_time}} has been reached.

===Parameters===
{{par begin}}
{{par | other | another {{tt|unique_lock}} to initialize the state with}}
{{par | m | mutex to associate with the lock and optionally acquire ownership of}}
{{par | t | tag parameter used to select constructors with different locking strategies}}
{{par | timeout_duration | maximum duration to block for}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Exceptions===
1, 2, 4) {{noexcept}}

===Example===
{{example|
 | code=
#include &lt;cassert&gt;
#include &lt;iostream&gt; // std::cout
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;mutex&gt;

class Number;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; stream, const Number&amp; number);

class Number {
 public:
  Number() : v_(1) {}

  // thread-safe update of 'a' and 'b'
  static void update(Number&amp; a, Number&amp; b, bool order) {
    // do not lock 'mutex_' of 'a' and 'b' sequentially,
    // two sequential lock may lead to deadlock,
    // that's why 'std::lock' exists (see below)
    GuardLock lock_a(a.mutex_, std::defer_lock);
    GuardLock lock_b(b.mutex_, std::defer_lock);

    // mutexes is not locked
    assert(!lock_a.owns_lock());
    assert(!lock_b.owns_lock());

    // unspecified series of calls...
    std::lock(lock_a, lock_b);

    // Result: 'a.mutex_' and 'b.mutex_' is in locked state
    // 'a' and 'b' can be modified safety
    assert(lock_a.owns_lock());
    assert(lock_b.owns_lock());

    if (order) {
      a.v_ += b.v_;
      b.v_ += a.v_;

      std::cout &lt;&lt; a &lt;&lt; b;
    }
    else {
      b.v_ += a.v_;
      a.v_ += b.v_;

      std::cout &lt;&lt; b &lt;&lt; a;
    }

    // 'lock_a' and 'lock_b' will be destroyed,
    // unlocking 'a.mutex_' and 'b.mutex_'
  }

  // not thread-safe; used before thread creation or in thread-safe 'update'
  std::ostream&amp; print(std::ostream&amp; stream) const {
    stream &lt;&lt; v_ &lt;&lt; &quot; &quot;;
    return stream;
  }

 private:
  using Mutex = std::mutex;
  using GuardLock = std::unique_lock&lt;Mutex&gt;;

  Mutex mutex_;
  int v_;
};

// not thread-safe; see 'Number::print'
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; stream, const Number&amp; number) {
  return number.print(stream);
}

int main() {
  Number a, b;
  std::cout &lt;&lt; a &lt;&lt; b;

  std::vector&lt;std::thread&gt; threads;

  for (unsigned i = 0; i &lt; 4; ++i) {
    // without 'std::lock' deadlock may occur in this situation:
    //   thread #1 lock 'a.mutex_'
    //   thread #2 lock 'b.mutex_'
    //   thread #1 try to lock 'b.mutex_' and blocked (it's locked by #2)
    //   thread #2 try to lock 'a.mutex_' and blocked (it's locked by #1)
    //   ... deadlock
    threads.emplace_back(Number::update, std::ref(a), std::ref(b), true); // #1
    threads.emplace_back(Number::update, std::ref(b), std::ref(a), false); // #2
  }

  for (auto&amp; i: threads) {
    i.join();
  }

  std::cout &lt;&lt; '\n';
}

 | output=
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584  
}}

[[de:cpp/thread/unique lock/unique lock]]
[[es:cpp/thread/unique lock/unique lock]]
[[fr:cpp/thread/unique lock/unique lock]]
[[it:cpp/thread/unique lock/unique lock]]
[[ja:cpp/thread/unique lock/unique lock]]
[[pt:cpp/thread/unique lock/unique lock]]
[[ru:cpp/thread/unique lock/unique lock]]
[[zh:cpp/thread/unique lock/unique lock]]</text>
      <sha1>cuuf3uf271nbl9nm0r4hlskk9ec05go</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/unlock</title>
    <ns>0</ns>
    <id>4482</id>
    <revision>
      <id>66986</id>
      <parentid>65448</parentid>
      <timestamp>2014-01-15T12:52:43Z</timestamp>
      <contributor>
        <username>Zkostrzewa</username>
        <id>2791</id>
      </contributor>
      <text xml:space="preserve" bytes="1049">{{cpp/thread/unique_lock/title|unlock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void unlock();
}}
{{dcl end}}

Unlocks the associated mutex and releases ownership.

{{lc|std::system_error}} is thrown if there is no associated mutex or if the mutex is not locked.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
* Any exceptions thrown by {{c|mutex()-&gt;unlock()}}

* If there is no associated mutex or the mutex is not locked, {{lc|std::system_error}} with an error code of {{lc|std::errc::operation_not_permitted}}

===Example===
{{example|
 |code=
 |output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/unique_lock/dsc lock}}
{{dsc inc | cpp/thread/unique_lock/dsc release}}
{{dsc end}}

[[de:cpp/thread/unique lock/unlock]]
[[es:cpp/thread/unique lock/unlock]]
[[fr:cpp/thread/unique lock/unlock]]
[[it:cpp/thread/unique lock/unlock]]
[[ja:cpp/thread/unique lock/unlock]]
[[pt:cpp/thread/unique lock/unlock]]
[[ru:cpp/thread/unique lock/unlock]]
[[zh:cpp/thread/unique lock/unlock]]</text>
      <sha1>r1v7hkspms7s3js8bmz86mpuu69c6gj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/unique lock/~unique lock</title>
    <ns>0</ns>
    <id>4477</id>
    <revision>
      <id>62999</id>
      <parentid>51470</parentid>
      <timestamp>2013-07-01T23:49:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="610">{{cpp/thread/unique_lock/title|~unique_lock}}
{{cpp/thread/unique_lock/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
~unique_lock();
}}
{{dcl end}}

Destroys the lock. If {{c|*this}} has an associated mutex and has acquired ownership of it, the mutex is unlocked.

[[de:cpp/thread/unique lock/~unique lock]]
[[es:cpp/thread/unique lock/~unique lock]]
[[fr:cpp/thread/unique lock/~unique lock]]
[[it:cpp/thread/unique lock/~unique lock]]
[[ja:cpp/thread/unique lock/~unique lock]]
[[pt:cpp/thread/unique lock/~unique lock]]
[[ru:cpp/thread/unique lock/~unique lock]]
[[zh:cpp/thread/unique lock/~unique lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/thread/yield</title>
    <ns>0</ns>
    <id>2297</id>
    <revision>
      <id>66666</id>
      <parentid>63488</parentid>
      <timestamp>2013-12-21T00:39:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>behavioral notes</comment>
      <text xml:space="preserve" bytes="1758">{{cpp/title|n=this_thread::|yield}}
{{cpp/thread/navbar}}
{{ddcl | header=thread | since=c++11 | 1=
void yield();
}}

Provides a hint to the implementation to reschedule the execution of threads, allowing other threads to run. 

===Parameters===
(none)

===Return value===
(none)

===Notes===
The exact behavior of this function depends on the implementation, in particular on the mechanics of the OS scheduler in use and the state of the system. For example, a first-in-first-out realtime scheduler ({{tt|SCHED_FIFO}} in Linux) would suspend the current thread and put it on the back of the queue of the same-priority threads that are ready to run (and if there are no other threads at the same priority, {{tt|yield}} has no effect).

===Example===
{{example |
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;

// &quot;busy sleep&quot; while suggesting that other threads run 
// for a small amount of time
void little_sleep(std::chrono::microseconds us)
{
    auto start = std::chrono::high_resolution_clock::now();
    auto end = start + us;
    do {
        std::this_thread::yield();
    } while (std::chrono::high_resolution_clock::now() &lt; end);
}

int main()
{
    auto start = std::chrono::high_resolution_clock::now();

    little_sleep(std::chrono::microseconds(100));

    auto elapsed = std::chrono::high_resolution_clock::now() - start;
    std::cout &lt;&lt; &quot;waited for &quot;
              &lt;&lt; std::chrono::duration_cast&lt;std::chrono::microseconds&gt;(elapsed).count()
              &lt;&lt; &quot; microseconds\n&quot;;
}
 | output=
waited for 128 microseconds
}}

[[de:cpp/thread/yield]]
[[es:cpp/thread/yield]]
[[fr:cpp/thread/yield]]
[[it:cpp/thread/yield]]
[[ja:cpp/thread/yield]]
[[pt:cpp/thread/yield]]
[[ru:cpp/thread/yield]]
[[zh:cpp/thread/yield]]</text>
      <sha1>ffdw1xjlf8z7ldwmnu8tlr92j9gzkrx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types</title>
    <ns>0</ns>
    <id>1788</id>
    <revision>
      <id>72002</id>
      <parentid>71007</parentid>
      <timestamp>2014-07-08T12:35:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>language/types now includes void</comment>
      <text xml:space="preserve" bytes="5883">{{title|Type support (basic types, RTTI, type traits)}}
{{cpp/types/navbar}}

&lt;small&gt;(See also {{ltt|cpp/language/type}} for type system overview)&lt;/small&gt;
===Basic types===

====[[cpp/language/types | Fundamental types defined by the language]]====

====Additional basic types and macros====
{{dsc begin}}
{{dsc header | cstddef}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/types/dsc ptrdiff_t}}
{{dsc inc | cpp/types/dsc nullptr_t}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc inc | cpp/types/dsc max_align_t}}
{{dsc inc | cpp/types/dsc offsetof}}
{{dsc header | cstdbool}}
{{dsc macro const | __bool_true_false_are_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c++11}}}}
{{dsc header | cstdalign}}
{{dsc macro const | __alignas_is_defined | nolink=true | C compatibility macro constant, expands to integer constant {{c|1}}|notes={{mark c++11}}}}
{{dsc end}}

====[[cpp/types/integer | Fixed width integer types]] {{mark since c++11}}====

====numeric_limits====

{{dsc begin}}
{{dsc header | limits}}
{{dsc inc | cpp/types/dsc numeric_limits}}
{{dsc end}}

====[[cpp/types/climits|C numeric limits interface]]====

===Runtime type identification===

{{dsc begin}}
{{dsc inc | cpp/types/dsc type_info}}
{{dsc inc | cpp/types/dsc type_index}}
{{dsc inc | cpp/types/dsc bad_typeid}}
{{dsc inc | cpp/types/dsc bad_cast}}
{{dsc end}}

===Type traits {{mark since c++11}}===

Type traits defines an compile-time template-based interface to query or modify the properties of types.

====Type properties====

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc h2 | Primary type categories}}
{{dsc inc | cpp/types/dsc is_void}}
{{dsc inc | cpp/types/dsc is_null_pointer}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_enum}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_function}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_lvalue_reference}}
{{dsc inc | cpp/types/dsc is_rvalue_reference}}
{{dsc inc | cpp/types/dsc is_member_object_pointer}}
{{dsc inc | cpp/types/dsc is_member_function_pointer}}

{{dsc h2 | Composite type categories}}
{{dsc inc | cpp/types/dsc is_fundamental}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc inc | cpp/types/dsc is_compound}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc inc | cpp/types/dsc is_member_pointer}}

{{dsc h2 | Type properties}}
{{dsc inc | cpp/types/dsc is_const}}
{{dsc inc | cpp/types/dsc is_volatile}}
{{dsc inc | cpp/types/dsc is_trivial}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc inc | cpp/types/dsc is_standard_layout}}
{{dsc inc | cpp/types/dsc is_pod}}
{{dsc inc | cpp/types/dsc is_literal_type}}
{{dsc inc | cpp/types/dsc is_empty}}
{{dsc inc | cpp/types/dsc is_polymorphic}}
{{dsc inc | cpp/types/dsc is_final}}
{{dsc inc | cpp/types/dsc is_abstract}}
{{dsc inc | cpp/types/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_unsigned}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Supported operations}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc inc | cpp/types/dsc is_assignable}}
{{dsc inc | cpp/types/dsc is_copy_assignable}}
{{dsc inc | cpp/types/dsc is_move_assignable}}
{{dsc inc | cpp/types/dsc is_destructible}}
{{dsc inc | cpp/types/dsc has_virtual_destructor}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Property queries}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | Type relationships}}
{{dsc inc | cpp/types/dsc is_same}}
{{dsc inc | cpp/types/dsc is_base_of}}
{{dsc inc | cpp/types/dsc is_convertible}}
{{dsc end}}

====Type modifications====

Type modification templates create new type definitions by applying modifications on a template parameter. The resulting type can then be accessed through {{tt|type}} member typedef.

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc h2 | Const-volatility specifiers}}
{{dsc inc | cpp/types/dsc remove_cv}}
{{dsc inc | cpp/types/dsc add_cv}}

{{dsc h2 | References}}
{{dsc inc | cpp/types/dsc remove_reference}}
{{dsc inc | cpp/types/dsc add_reference}}

{{dsc h2 | Pointers}}
{{dsc inc | cpp/types/dsc remove_pointer}}
{{dsc inc | cpp/types/dsc add_pointer}}

{{dsc h2 | Sign modifiers}}
{{dsc inc | cpp/types/dsc make_signed}}
{{dsc inc | cpp/types/dsc make_unsigned}}

{{dsc h2 | Arrays}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}
{{dsc end}}

====Miscellaneous transformations====

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc inc | cpp/types/dsc aligned_storage}}
{{dsc inc | cpp/types/dsc aligned_union}}
{{dsc inc | cpp/types/dsc decay}}
{{dsc inc | cpp/types/dsc enable_if}}
{{dsc inc | cpp/types/dsc conditional}}
{{dsc inc | cpp/types/dsc common_type}}
{{dsc inc | cpp/types/dsc underlying_type}}
{{dsc inc | cpp/types/dsc result_of}}
{{dsc end}}

====Helper classes====

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc inc | cpp/types/dsc integral_constant}}
{{dsc end}}

Two specializations of {{lc|std::integral_constant}} for the type {{c|bool}} are provided: 

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|true_type}} | {{c|std::integral_constant&lt;bool, true&gt;}}}}
{{dsc | {{tt|false_type}} | {{c|std::integral_constant&lt;bool, false&gt;}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/types | Type support library}}
{{dsc end}}

[[de:cpp/types]]
[[es:cpp/types]]
[[fr:cpp/types]]
[[it:cpp/types]]
[[ja:cpp/types]]
[[pt:cpp/types]]
[[ru:cpp/types]]
[[zh:cpp/types]]</text>
      <sha1>d9kjvmlv9uszz3y65pedd7bn0whcaud</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/NULL</title>
    <ns>0</ns>
    <id>2772</id>
    <revision>
      <id>72174</id>
      <parentid>71841</parentid>
      <timestamp>2014-07-20T10:58:38Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>+ C++03 definition of null pointer constant</comment>
      <text xml:space="preserve" bytes="2047">{{title|NULL}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl header | cstring}}
{{dcl header | cwchar}}
{{dcl header | ctime}}
{{dcl header | cstdio|notes={{mark until c++11}}}}
{{dcl header | clocale|notes={{mark since c++11}}}}
{{dcl header | cstdlib|notes={{mark since c++11}}}}&lt;!--checked C++11 Table 149 --&gt;
{{dcl |
#define NULL /*implementation-defined*/
}}
{{dcl end}}

Defines the null pointer constant, which is
{{rev begin}}
{{rev|until=c++11|
an integral [[cpp/language/constant_expression|constant expression]] [[cpp/language/value_category|rvalue]] of integer type that evaluates to zero
}}
{{rev|since=c++11|until=c++14|
an integral [[cpp/language/constant_expression|constant expression]] [[cpp/language/value category|prvalue]] of integer type that evaluates to zero or a prvalue of type {{lc|std::nullptr_t}} 
}}
{{rev|since=c++14|
an [[cpp/language/integer literal|integer literal]] with value zero, or a prvalue of type {{lc|std::nullptr_t}}
}}
{{rev end}}
The null pointer constant may be [[cpp/language/implicit_cast|implicitly converted]] to any pointer type; such conversion results in the null pointer value of that type. If the null pointer constant has integer type, it may be converted to a prvalue of type {{lc|std::nullptr_t}}.

===Possible implementation===
{{eq fun
 | 1=
#define NULL 0
//since C++11
#define NULL nullptr
}}

===Notes===
In C, the macro {{tt|NULL}} may have the type {{tt|void*}}, but that is not allowed in C++.

===Example===
{{example
 |
 | code=
#include &lt;cstddef&gt;
class S;
int main()
{
    int* p = NULL;
    int* p2 = static_cast&lt;std::nullptr_t&gt;(NULL);
    void(*f)(int) = NULL;
    int S::*mp = NULL;
    void(S::*mfp)(int) = NULL;
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc nullptr}}
{{dsc inc | cpp/types/dsc nullptr_t}}
{{dsc see c | c/types/NULL}}
{{dsc end}}

[[de:cpp/types/NULL]]
[[es:cpp/types/NULL]]
[[fr:cpp/types/NULL]]
[[it:cpp/types/NULL]]
[[ja:cpp/types/NULL]]
[[pt:cpp/types/NULL]]
[[ru:cpp/types/NULL]]
[[zh:cpp/types/NULL]]</text>
      <sha1>2g7wavso7kctwvlt537w03fd7wahk1b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add const</title>
    <ns>0</ns>
    <id>4242</id>
    <redirect title="cpp/types/add cv" />
    <revision>
      <id>15341</id>
      <timestamp>2011-12-08T15:35:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/add cv]]</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/types/add_cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add cv</title>
    <ns>0</ns>
    <id>3281</id>
    <revision>
      <id>63000</id>
      <parentid>59285</parentid>
      <timestamp>2013-07-01T23:49:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2106">{{cpp/title|add_cv|add_const|add_volatile}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct add_cv;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct add_const;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct add_volatile;
}}
{{dcl end}}

Provides the member typedef {{tt|type}} which is the same as {{tt|T}}, except it has a cv-qualifier added (unless {{tt|T}} is a function, a reference, or already has this cv-qualifier)

1) adds both {{c|const}} and {{c|volatile}}

2) adds {{c|const}}

3) adds {{c|volatile}}

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type {{tt|T}} with the cv-qualifier }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_cv_t       = typename add_cv&lt;T&gt;::type;
}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_const_t    = typename add_const&lt;T&gt;::type;
}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_volatile_t = typename add_volatile&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct add_cv {
    typedef typename std::add_volatile&lt;typename std::add_const&lt;T&gt;::type&gt;::type type;
};

template&lt; class T&gt; struct add_const { typedef const T type; };

template&lt; class T&gt; struct add_volatile { typedef volatile T type; };
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct foo
{
    void m() { std::cout &lt;&lt; &quot;Non-cv\n&quot;; }
    void m() const { std::cout &lt;&lt; &quot;Const\n&quot;; }
};

template &lt;class T&gt;
void call_m()
{
    T().m();
}

int main()
{
    call_m&lt;foo&gt;();
    call_m&lt;std::add_const&lt;foo&gt;::type&gt;();
}

 | output=
Non-cv
Const
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_const}}
{{dsc inc | cpp/types/dsc is_volatile}}
{{dsc inc | cpp/types/dsc remove_cv}}
{{dsc end}}

[[de:cpp/types/add cv]]
[[es:cpp/types/add cv]]
[[fr:cpp/types/add cv]]
[[it:cpp/types/add cv]]
[[ja:cpp/types/add cv]]
[[pt:cpp/types/add cv]]
[[ru:cpp/types/add cv]]
[[zh:cpp/types/add cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add lvalue reference</title>
    <ns>0</ns>
    <id>4243</id>
    <redirect title="cpp/types/add reference" />
    <revision>
      <id>15342</id>
      <timestamp>2011-12-08T15:36:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/add reference]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/types/add_reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add pointer</title>
    <ns>0</ns>
    <id>3285</id>
    <revision>
      <id>72248</id>
      <parentid>63001</parentid>
      <timestamp>2014-07-29T13:23:32Z</timestamp>
      <contributor>
        <username>Curdeius</username>
        <id>401</id>
      </contributor>
      <comment>Added an example</comment>
      <text xml:space="preserve" bytes="2107">{{cpp/title|add_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct add_pointer;
}}
{{dcl end}}

Provides the member typedef {{tt|type}} which is the type {{tt|T*}}. If {{tt|T}} is a reference type, then {{tt|type}} is a pointer to the referred type.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | pointer to {{tt|T}} or to the type referenced by {{tt|T}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_pointer_t = typename add_pointer&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct add_pointer {
    typedef typename std::remove_reference&lt;T&gt;::type* type;
};
}}

===Example===
{{example
 |
 | lang=cpp
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main()
{
    int i = 123;
    int&amp; ri = i;
    typedef std::add_pointer&lt;decltype(i)&gt;::type IntPtr;
    typedef std::add_pointer&lt;decltype(ri)&gt;::type IntPtr2;
    IntPtr pi = &amp;i;
    std::cout &lt;&lt; &quot;i = &quot; &lt;&lt; i &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; &quot;*pi = &quot; &lt;&lt; *pi &lt;&lt; &quot;\n&quot;;
    
    static_assert(std::is_pointer&lt;IntPtr&gt;::value, &quot;IntPtr should be a pointer&quot;);
    static_assert(std::is_same&lt;IntPtr, int*&gt;::value, &quot;IntPtr should be a pointer to int&quot;);
    static_assert(std::is_same&lt;IntPtr2, IntPtr&gt;::value, &quot;IntPtr2 should be equal to IntPtr&quot;);
    
    typedef std::remove_pointer&lt;IntPtr&gt;::type IntAgain;
    IntAgain j = i;
    std::cout &lt;&lt; &quot;j = &quot; &lt;&lt; j &lt;&lt; &quot;\n&quot;;

    static_assert(!std::is_pointer&lt;IntAgain&gt;::value, &quot;IntAgain should not be a pointer&quot;);
    static_assert(std::is_same&lt;IntAgain, int&gt;::value, &quot;IntPtr should be equal to int&quot;);
}
 | output=
i = 123
*pi = 123
j = 123
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc remove_pointer}}
{{dsc end}}

[[de:cpp/types/add pointer]]
[[es:cpp/types/add pointer]]
[[fr:cpp/types/add pointer]]
[[it:cpp/types/add pointer]]
[[ja:cpp/types/add pointer]]
[[pt:cpp/types/add pointer]]
[[ru:cpp/types/add pointer]]
[[zh:cpp/types/add pointer]]</text>
      <sha1>2ppo9433snyc6htq1n5p7aj2d8z04ii</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add reference</title>
    <ns>0</ns>
    <id>3287</id>
    <revision>
      <id>63002</id>
      <parentid>62377</parentid>
      <timestamp>2013-07-01T23:49:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2299">{{cpp/title|add_lvalue_reference|add_rvalue_reference}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1| 1=
template&lt; class T &gt;
struct add_lvalue_reference;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct add_rvalue_reference;
}}
{{dcl end}}

Creates a lvalue or rvalue reference type of {{tt|T}}.

@1@ If {{tt|T}} is an object or function, provides a member typedef {{tt|type}} which is {{tt|T&amp;}}. If {{tt|T}} is an rvalue reference to some type {{tt|U}}, then {{tt|type}} is {{tt|U&amp;}}. Otherwise, {{tt|type}} is {{tt|T}}.

@2@ If {{tt|T}} is an object or function, provides a member typedef {{tt|type}} which is {{tt|T&amp;&amp;}}, otherwise {{tt|type}} is {{tt|T}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | reference to {{tt|T}}, or {{tt|T}} if not allowed}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_lvalue_reference_t = typename add_lvalue_reference&lt;T&gt;::type;
}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using add_rvalue_reference_t = typename add_rvalue_reference&lt;T&gt;::type;
}}
{{dcl end}}

===Notes===
These type transformations honor reference collapse rules:

{{c|1=
std::add_lvalue_reference&lt;T&amp;&gt;::type is T&amp;
std::add_lvalue_reference&lt;T&amp;&amp;&gt;::type is T&amp;
std::add_rvalue_reference&lt;T&amp;&gt;::type is T&amp;
std::add_rvalue_reference&lt;T&amp;&amp;&gt;::type is T&amp;&amp;
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
   using nonref = int;
   using lref = typename std::add_lvalue_reference&lt;nonref&gt;::type;
   using rref = typename std::add_rvalue_reference&lt;nonref&gt;::type;
      
   std::cout &lt;&lt; std::boolalpha;
   std::cout &lt;&lt; std::is_lvalue_reference&lt;nonref&gt;::value &lt;&lt; '\n';
   std::cout &lt;&lt; std::is_lvalue_reference&lt;lref&gt;::value &lt;&lt; '\n';
   std::cout &lt;&lt; std::is_rvalue_reference&lt;rref&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc inc | cpp/types/dsc remove_reference}}
{{dsc end}}

[[de:cpp/types/add reference]]
[[es:cpp/types/add reference]]
[[fr:cpp/types/add reference]]
[[it:cpp/types/add reference]]
[[ja:cpp/types/add reference]]
[[pt:cpp/types/add reference]]
[[ru:cpp/types/add reference]]
[[zh:cpp/types/add reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add rvalue reference</title>
    <ns>0</ns>
    <id>4244</id>
    <redirect title="cpp/types/add reference" />
    <revision>
      <id>15343</id>
      <timestamp>2011-12-08T15:36:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/add reference]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/types/add_reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/add volatile</title>
    <ns>0</ns>
    <id>4241</id>
    <redirect title="cpp/types/add cv" />
    <revision>
      <id>15340</id>
      <timestamp>2011-12-08T15:35:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/add cv]]</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/types/add_cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/aligned storage</title>
    <ns>0</ns>
    <id>3190</id>
    <revision>
      <id>72455</id>
      <parentid>71837</parentid>
      <timestamp>2014-08-22T15:08:30Z</timestamp>
      <contributor>
        <ip>109.80.191.2</ip>
      </contributor>
      <text xml:space="preserve" bytes="3520">{{cpp/title|aligned_storage}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; std::size_t Len, std::size_t Align = /*default-alignment*/ &gt;
struct aligned_storage;
}}
{{dcl end}}

Provides the member typedef {{tt|type}}, which is a {{concept|PODType}} suitable for use as uninitialized storage for any object whose size is at most {{tt|Len}} and whose [[cpp/language/object#Alignment|alignment requirement]] is a divisor of {{tt|Align}}. The default value of {{tt|Align}} is the most stringent (the largest) alignment requirement for any object whose size is at most {{tt|Len}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the POD type of at least size {{tt|Len}} with alignment requirement {{tt|Align}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; std::size_t Len, std::size_t Align = /*default-alignment*/ &gt;
using aligned_storage_t = typename aligned_storage&lt;Len, Align&gt;::type;
}}
{{dcl end}}

===Notes===
The type defined by {{tt|std::aligned_storage&lt;&gt;::type}} can be used to create uninitialized memory blocks suitable to hold the objects of given type, optionally aligned stricter than their natural alignment requirement, for example on a cache or page boundary.

As with any other uninitialized storage, the objects are created using [[cpp/language/new|placement new]] and destroyed with explicit destructor calls.

===Possible implementation===
Except for default argument, aligned_storage is expressible in terms of alignas:
{{eq fun
 | 1=
template&lt;std::size_t Len, std::size_t Align /* default alignment not implemented */&gt;
struct aligned_storage {
    struct type {
        alignas(Align) unsigned char data[Len];
    };
};
}}

===Example===
{{example
 | A primitive static vector class, demonstrating creation, access, and destruction of objects in aligned storage
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;string&gt;

template&lt;class T, std::size_t N&gt;
class static_vector
{
    // properly aligned uninitialized storage for N T's
    std::aligned_storage_t&lt;sizeof(T), alignof(T)&gt; data[N];
    std::size_t m_size = 0;
public:

    // Create an object in aligned storage
    template&lt;typename ...Args&gt; void emplace_back(Args&amp;&amp;... args) 
    {
        new(data+m_size) T(std::forward&lt;Args&gt;(args)...);
        if( m_size++ &gt;= N ) // possible error handling
            throw std::bad_alloc{};
    }

    // Access an object in aligned storage
    const T&amp; operator[](size_t pos) const 
    {
        return *static_cast&lt;const T*&gt;(static_cast&lt;const void*&gt;(&amp;data[pos]));
    }
    // Delete objects from aligned storage
    ~static_vector() 
    {
        for(std::size_t pos = 0; pos &lt; m_size; ++pos) {
            static_cast&lt;const T*&gt;(static_cast&lt;const void*&gt;(data+pos))-&gt;~T();
        }
    }
};

int main()
{
    static_vector&lt;std::string, 10&gt; v1;
    v1.emplace_back(5, '*');
    v1.emplace_back(10, '*');
    std::cout &lt;&lt; v1[0] &lt;&lt; '\n' &lt;&lt; v1[1] &lt;&lt; '\n';
}
 | output=
*****
**********
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc alignas}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc inc | cpp/types/dsc aligned_union}}
{{dsc inc | cpp/types/dsc max_align_t}}
{{dsc end}}

[[de:cpp/types/aligned storage]]
[[es:cpp/types/aligned storage]]
[[fr:cpp/types/aligned storage]]
[[it:cpp/types/aligned storage]]
[[ja:cpp/types/aligned storage]]
[[pt:cpp/types/aligned storage]]
[[ru:cpp/types/aligned storage]]
[[zh:cpp/types/aligned storage]]</text>
      <sha1>2eaahr13vfs8342tdbfmf7t6x1k57s6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/aligned union</title>
    <ns>0</ns>
    <id>3255</id>
    <revision>
      <id>67331</id>
      <parentid>63004</parentid>
      <timestamp>2014-02-05T05:08:19Z</timestamp>
      <contributor>
        <ip>98.164.7.43</ip>
      </contributor>
      <comment>Clarify that the object types contribute to the size of the POD, not only to the alignment. Old text was ambiguous.</comment>
      <text xml:space="preserve" bytes="1546">{{cpp/title|aligned_union}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; std::size_t Len, class... Types &gt;
struct aligned_union;
}}
{{dcl end}}

Provides the member typedef {{tt|type}}, which is a POD type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in {{tt|Types}}. The size of the storage is at least {{tt|Len}}. {{lc|std::aligned_union}} also determines the strictest (largest) alignment requirement among all {{tt|Types}} and makes it available as the constant {{tt|alignment_value}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the POD type suitable for storage of any type from {{tt|Types}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; std::size_t Len, class... Types &gt;
using aligned_union_t = typename aligned_union&lt;Len,Types...&gt;::type;
}}
{{dcl end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst | alignment_value | the strictest alignment requirement of all {{tt|Types}} | nolink=true}}
{{dsc end}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc inc | cpp/types/dsc aligned_storage}}
{{dsc end}}

[[de:cpp/types/aligned union]]
[[es:cpp/types/aligned union]]
[[fr:cpp/types/aligned union]]
[[it:cpp/types/aligned union]]
[[ja:cpp/types/aligned union]]
[[pt:cpp/types/aligned union]]
[[ru:cpp/types/aligned union]]
[[zh:cpp/types/aligned union]]</text>
      <sha1>c25v1e5vzjggelouyl4pjm7jd8jh6en</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/alignment of</title>
    <ns>0</ns>
    <id>3189</id>
    <revision>
      <id>71413</id>
      <parentid>69239</parentid>
      <timestamp>2014-06-11T01:08:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link alignment</comment>
      <text xml:space="preserve" bytes="1717">{{cpp/title|alignment_of}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct alignment_of;
}}
{{dcl end}}

Provides the member constant {{tt|value}} equal to the [[cpp/language/object#Alignment|alignment requirement]] of the type {{tt|T}}, as if obtained by an {{c|alignof}} expression. If {{tt|T}} is an array type, returns the alignment requirements of the element type. If {{tt|T}} is a reference type, returns the alignment requirements of the type referred to.

{{cpp/types/integral_constant/inherit2 |{{c|alignof(T)}}|std::size_t}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct alignment_of : std::integral_constant&lt;
                          std::size_t,
                          alignof(T)
                       &gt; {};
}}

===Notes===
This type trait predates the [[cpp/language/alignof|alignof keyword]], which can be used to obtain the same value with less verbosity.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
 
class A {};
 
int main() 
{
    std::cout &lt;&lt; std::alignment_of&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::alignment_of&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::alignment_of&lt;double&gt;::value &lt;&lt; '\n';
}
 | output=
1
4
8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc alignof}}
{{dsc inc | cpp/types/dsc aligned_storage}}
{{dsc inc | cpp/types/dsc aligned_union}}
{{dsc inc | cpp/types/dsc max_align_t}}
{{dsc end}}

[[de:cpp/types/alignment of]]
[[es:cpp/types/alignment of]]
[[fr:cpp/types/alignment of]]
[[it:cpp/types/alignment of]]
[[ja:cpp/types/alignment of]]
[[pt:cpp/types/alignment of]]
[[ru:cpp/types/alignment of]]
[[zh:cpp/types/alignment of]]</text>
      <sha1>qfxtncu8rw66yyp3g4n4fyx1nj01kx2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/bad cast</title>
    <ns>0</ns>
    <id>3277</id>
    <revision>
      <id>70257</id>
      <parentid>69642</parentid>
      <timestamp>2014-05-13T20:04:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>also thrown by use_facet</comment>
      <text xml:space="preserve" bytes="1158">{{cpp/title | bad_cast}}
{{cpp/types/bad_cast/navbar}}
{{ddcl | header=typeinfo |
class bad_cast : public std::exception;
}}

An exception of this type is thrown when a {{ltt|cpp/language/dynamic_cast}} to a reference type fails the run-time check (e.g. because the types are not related by inheritance), and also from {{lc|std::use_facet}} if the requested facet does not exist in the locale.

{{inheritance diagram/std-bad_cast}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/types/bad_cast/bad_cast | constructs a new bad_cast object}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;typeinfo&gt;

struct Foo { virtual ~Foo() {} };
struct Bar { virtual ~Bar() {} };

int main()
{
    Bar b;
    try {
        Foo&amp; f = dynamic_cast&lt;Foo&amp;&gt;(b);
    } catch(const std::bad_cast&amp; e)
    {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
} 
 | p=true
 | output=
Bad dynamic cast
}}

[[de:cpp/types/bad cast]]
[[es:cpp/types/bad cast]]
[[fr:cpp/types/bad cast]]
[[it:cpp/types/bad cast]]
[[ja:cpp/types/bad cast]]
[[pt:cpp/types/bad cast]]
[[ru:cpp/types/bad cast]]
[[zh:cpp/types/bad cast]]</text>
      <sha1>ayml1ij4cnd24n0ntwowe91cj4axo4w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/bad cast/bad cast</title>
    <ns>0</ns>
    <id>4751</id>
    <revision>
      <id>64841</id>
      <parentid>51480</parentid>
      <timestamp>2013-08-27T01:20:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcetp</comment>
      <text xml:space="preserve" bytes="660">{{cpp/types/bad_cast/title|bad_cast}}
{{cpp/types/bad_cast/navbar}}
{{ddcl | 
bad_cast();
}}

Constructs new {{lc|std::bad_cast}} object. The contents of the byte string returned by {{ltf|cpp/error/exception/what}} are implementation defined.

===Parameters===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/types/bad cast/bad cast]]
[[es:cpp/types/bad cast/bad cast]]
[[fr:cpp/types/bad cast/bad cast]]
[[it:cpp/types/bad cast/bad cast]]
[[ja:cpp/types/bad cast/bad cast]]
[[pt:cpp/types/bad cast/bad cast]]
[[ru:cpp/types/bad cast/bad cast]]
[[zh:cpp/types/bad cast/bad cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/bad typeid</title>
    <ns>0</ns>
    <id>3276</id>
    <revision>
      <id>66458</id>
      <parentid>51481</parentid>
      <timestamp>2013-11-23T01:17:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>typo per talk</comment>
      <text xml:space="preserve" bytes="1110">{{cpp/title | bad_typeid}}
{{cpp/types/bad_typeid/navbar}}
{{ddcl | header=typeinfo |
class bad_typeid : public std::exception;
}}

An exception of this type is thrown when a {{ltt|cpp/language/typeid|typeid}} operator is applied to a dereferenced null pointer value of a polymorphic type.

{{inheritance diagram/std-bad_typeid}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/types/bad_typeid/bad_typeid | constructs a new {{tt|bad_typeid}} object}}
{{dsc end}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;typeinfo&gt;

struct S { // The type has to be polymorphic
    virtual void f();
}; 

int main()
{
    S* p = nullptr;
    try {
        std::cout &lt;&lt; typeid(*p).name() &lt;&lt; '\n';
    } catch(const std::bad_typeid&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
Attempted a typeid of NULL pointer!
}}

[[de:cpp/types/bad typeid]]
[[es:cpp/types/bad typeid]]
[[fr:cpp/types/bad typeid]]
[[it:cpp/types/bad typeid]]
[[ja:cpp/types/bad typeid]]
[[pt:cpp/types/bad typeid]]
[[ru:cpp/types/bad typeid]]
[[zh:cpp/types/bad typeid]]</text>
      <sha1>91ocn0t2p0eliro39j4tx7aswsp0zud</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/bad typeid/bad typeid</title>
    <ns>0</ns>
    <id>4750</id>
    <revision>
      <id>64842</id>
      <parentid>51482</parentid>
      <timestamp>2013-08-27T01:20:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="702">{{cpp/types/bad_typeid/title|bad_typeid}}
{{cpp/types/bad_typeid/navbar}}
{{ddcl | 
bad_typeid();
}}

Constructs new {{lc|std::bad_typeid}} object. The contents of the byte string returned by {{ltf|cpp/error/exception/what}} are implementation defined.

===Parameters===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

[[de:cpp/types/bad typeid/bad typeid]]
[[es:cpp/types/bad typeid/bad typeid]]
[[fr:cpp/types/bad typeid/bad typeid]]
[[it:cpp/types/bad typeid/bad typeid]]
[[ja:cpp/types/bad typeid/bad typeid]]
[[pt:cpp/types/bad typeid/bad typeid]]
[[ru:cpp/types/bad typeid/bad typeid]]
[[zh:cpp/types/bad typeid/bad typeid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/climits</title>
    <ns>0</ns>
    <id>2027</id>
    <revision>
      <id>71129</id>
      <parentid>67796</parentid>
      <timestamp>2014-06-06T19:38:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>wrong language see-also</comment>
      <text xml:space="preserve" bytes="5557">{{title|C numeric limits interface}}
{{cpp/types/navbar}}

See also {{lc|std::numeric_limits}} interface.

{{dsc begin}}
{{dsc header | cstdint}}
{{dsc macro const | PTRDIFF_MIN | minimum value of object of {{lc|std::ptrdiff_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | PTRDIFF_MAX | maximum value of object of {{lc|std::ptrdiff_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | SIZE_MAX | maximum value of object of {{lc|std::size_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | SIG_ATOMIC_MIN | minimum value of object of {{lc|std::sig_atomic_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | SIG_ATOMIC_MAX | maximum value of object of {{lc|std::sig_atomic_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | WCHAR_MIN | minimum value of object of {{c|wchar_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | WCHAR_MAX | maximum value of object of {{c|wchar_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | WINT_MIN | minimum value of object of {{c|std::wint_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc macro const | WINT_MAX | maximum value of object of {{c|std::wint_t}} type | notes={{mark c++11}} | nolink=true}}
{{dsc end}}

===Limits of integer types===
{{dsc begin}}
{{dsc header | climits}}
{{dsc macro const | CHAR_BIT | number of bits in byte | nolink=true }}
{{dsc macro const | MB_LEN_MAX | maximum number of bytes in a multibyte character | nolink=true }}
{{dsc macro const | CHAR_MIN | minimum value of {{c|char}} | nolink=true }}
{{dsc macro const | CHAR_MAX | maximum value of {{c|char}} | nolink=true }}
{{dsc macro const | SCHAR_MIN&lt;br&gt;SHRT_MIN&lt;br&gt;INT_MIN&lt;br&gt;LONG_MIN&lt;br&gt;LLONG_MIN | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | minimum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | SCHAR_MAX&lt;br&gt;SHRT_MAX&lt;br&gt;INT_MAX&lt;br&gt;LONG_MAX&lt;br&gt;LLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | maximum value of {{c|signed char}}, {{c|short}}, {{c|int}}, {{c|long}} and {{c|long long}} respectively}}
{{dsc macro const | UCHAR_MAX&lt;br&gt;USHRT_MAX&lt;br&gt;UINT_MAX&lt;br&gt;ULONG_MAX&lt;br&gt;ULLONG_MAX | nolink=true | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}} | maximum value of {{c|unsigned char}}, {{c|unsigned short}}, {{c|unsigned int}},&lt;br&gt;{{c|unsigned long}} and {{c|unsigned long long}} respectively}}
{{dsc end}}

===Limits of floating point types===
{{dsc begin}}
{{dsc header | cfloat}}
{{dsc macro const | FLT_RADIX | the radix (integer base) used by the representation of all three floating-point types | nolink=true }}
{{dsc macro const | DECIMAL_DIG | number of decimal digits that can be converted to {{c|long double}} and back without losing precision | nolink=true | notes={{mark c++11}}}}
{{dsc macro const | FLT_MIN&lt;br&gt;DBL_MIN&lt;br&gt;LDBL_MIN | minimum value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX&lt;br&gt;DBL_MAX&lt;br&gt;LDBL_MAX | maximum value of {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_EPSILON&lt;br&gt;DBL_EPSILON&lt;br&gt;LDBL_EPSILON | difference between {{c|1.0}} and the next representable value for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_DIG&lt;br&gt;DBL_DIG&lt;br&gt;LDBL_DIG | number of decimal digits that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively (see {{lc|std::numeric_limits::digits10}} for explanation) | nolink=true }}
{{dsc macro const | FLT_MANT_DIG&lt;br&gt;DBL_MANT_DIG&lt;br&gt;LDBL_MANT_DIG | number of base {{tt|FLT_RADIX}} digits that can be represented without losing precision for {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_EXP&lt;br&gt;DBL_MIN_EXP&lt;br&gt;LDBL_MIN_EXP | minimum negative integer such that {{tt|FLT_RADIX}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MIN_10_EXP&lt;br&gt;DBL_MIN_10_EXP&lt;br&gt;LDBL_MIN_10_EXP | minimum negative integer such that {{c|10}} raised by power one less than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_EXP&lt;br&gt;DBL_MAX_EXP&lt;br&gt;LDBL_MAX_EXP | maximum positive integer such that {{tt|FLT_RADIX}} raised by power one more than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | FLT_MAX_10_EXP&lt;br&gt;DBL_MAX_10_EXP&lt;br&gt;LDBL_MAX_10_EXP | maximum positive integer such that {{c|10}} raised by power one more than that integer is a normalized {{c|float}}, {{c|double}} and {{c|long double}} respectively | nolink=true }}
{{dsc macro const | cpp/types/climits/FLT_ROUNDS | default rounding mode of floating-point arithmetics }}
{{dsc macro const | cpp/types/climits/FLT_EVAL_METHOD | specifies in what precision all arithmetic operations are done | notes={{mark c++11}} }}
{{dsc end}}

===See also===
* [[cpp/types/integer    | Fixed width integer types]]
* [[cpp/language/types | Arithmetic types]]
* [[cpp/language/type  | C++ type system overview]]
* [[cpp/types          | Type support (basic types, RTTI, type traits)]]

[[de:cpp/types/climits]]
[[es:cpp/types/climits]]
[[fr:cpp/types/climits]]
[[it:cpp/types/climits]]
[[ja:cpp/types/climits]]
[[pt:cpp/types/climits]]
[[ru:cpp/types/climits]]
[[zh:cpp/types/climits]]</text>
      <sha1>7wyk6bdm73is2hu5vfynqb7unu4uole</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/climits/FLT EVAL METHOD</title>
    <ns>0</ns>
    <id>8694</id>
    <revision>
      <id>63489</id>
      <parentid>51484</parentid>
      <timestamp>2013-07-10T01:33:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1443">{{title|FLT_EVAL_METHOD}}
{{cpp/types/climits/navbar}}
{{ddcl | header=cfloat | since=c++11 |
#define FLT_EVAL_METHOD /* implementation defined */
}}

Specifies the precision in which all floating-point arithmetic operations are done. 

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | negative values except {{tt|-1}} | implementation-defined behavior}}
{{dsc | {{tt|-1}} | the default precision is not known}}
{{dsc | {{tt|0}} | all operations and constants evaluate in the range and precision of the type used. Additionally, {{c|float_t}} and {{c|double_t}} are equivalent to {{c|float}} and {{c|double}} respectively}}
{{dsc | {{tt|1}} | all operations and constants evaluate in the range and precision of {{c|double}}. Additionally, both {{c|float_t}} and {{c|double_t}} are equivalent to {{c|double}}}}
{{dsc | {{tt|2}} | all operations and constants evaluate in the range and precision of {{c|long double}}. Additionally, both {{c|float_t}} and {{c|double_t}} are equivalent to {{c|long double}}}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/types/limits/FLT_EVAL_METHOD}}
{{dsc end}}

[[de:cpp/types/climits/FLT EVAL METHOD]]
[[es:cpp/types/climits/FLT EVAL METHOD]]
[[fr:cpp/types/climits/FLT EVAL METHOD]]
[[it:cpp/types/climits/FLT EVAL METHOD]]
[[ja:cpp/types/climits/FLT EVAL METHOD]]
[[pt:cpp/types/climits/FLT EVAL METHOD]]
[[ru:cpp/types/climits/FLT EVAL METHOD]]
[[zh:cpp/types/climits/FLT EVAL METHOD]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/climits/FLT ROUNDS</title>
    <ns>0</ns>
    <id>8696</id>
    <revision>
      <id>71778</id>
      <parentid>71772</parentid>
      <timestamp>2014-06-23T22:18:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move round_style down to note</comment>
      <text xml:space="preserve" bytes="1395">{{title|FLT_ROUNDS}}
{{cpp/types/climits/navbar}}
{{ddcl | header=cfloat | since=c++11 |
#define FLT_ROUNDS /* implementation defined */
}}

Specifies the current rounding direction of floating-point arithmetic operations.

{{dsc begin}}
{{dsc hitem | Value | Explanation}}
{{dsc | {{tt|-1}} | the default rounding direction is not known}}
{{dsc | {{tt|0}} | toward zero, {{lc|FE_TOWARDZERO}} }}
{{dsc | {{tt|1}} | to nearest, {{lc|FE_TONEAREST}} }}
{{dsc | {{tt|2}} | towards positive infinity, {{lc|FE_UPWARD}} }}
{{dsc | {{tt|3}} | towards negative infinity, {{lc|FE_DOWNWARD}} }}
{{dsc | other values | implementation-defined behavior}}
{{dsc end}}

===Notes===
The rounding mode can be changed with {{lc|std::fesetround}} and {{lc|FLT_ROUNDS}} reflects that change.

The possible values of FLT_ROUNDS match the possible values of {{lc|std::float_round_style}}, returned by {{lc|std::numeric_limits::round_style}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc float_round_style}}
{{dsc inc | cpp/numeric/fenv/dsc feround}}
{{dsc see c | c/types/limits/FLT_ROUNDS}}
{{dsc end}}

[[de:cpp/types/climits/FLT ROUNDS]]
[[es:cpp/types/climits/FLT ROUNDS]]
[[fr:cpp/types/climits/FLT ROUNDS]]
[[it:cpp/types/climits/FLT ROUNDS]]
[[ja:cpp/types/climits/FLT ROUNDS]]
[[pt:cpp/types/climits/FLT ROUNDS]]
[[ru:cpp/types/climits/FLT ROUNDS]]
[[zh:cpp/types/climits/FLT ROUNDS]]</text>
      <sha1>17f2nbqsymxkqs19cwgmbi32rb44ruu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/common type</title>
    <ns>0</ns>
    <id>3135</id>
    <revision>
      <id>72375</id>
      <parentid>72231</parentid>
      <timestamp>2014-08-17T02:29:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention that common_type is the only customizable thing in type_traits</comment>
      <text xml:space="preserve" bytes="3187">{{cpp/title|common_type}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class... T &gt;
struct common_type;
}}
{{dcl end}}

Determines the common type among all types {{tt|T...}}, that is the type all {{tt|T...}} can be implicitly converted to. 

* {{tt|std::common_type}} may be specialized for custom types, e.g. {{lc|std::chrono::time_point}}.
* For non-specialized {{tt|std::common_type}}, the rules for determining the common type between every pair {{tt|T1, T2}} are exactly the rules for determining the return type of the [[cpp/language/operator_other#Conditional operator|ternary conditional operator]] where {{tt|T1}} and {{tt|T2}} are the types of its second and the third operands. {{rev inl|since=c++14|The common type is the result of {{lc|std::decay}} applied to the type of the ternary conditional}}.
* For arithmetic types, the common type may also be viewed as the type of the (possibly mixed-mode) arithmetic expression such as {{c|T0() + T1() + ... + Tn()}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the common type for all {{tt|T...}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class... T &gt;
using common_type_t = typename common_type&lt;T...&gt;::type;
}}
{{dcl end}}

===Specializations===

Custom specializations of the type trait {{lc|std::common_type}} are allowed, as long as at least one parameter is a user-defined type (note that the behavior of a program that adds a specialization to any other class from {{tt|&lt;type_traits&gt;}} is undefined).

The following specializations are already provided by the standard library:

{{dsc begin}}
{{dsc inc | cpp/chrono/duration/dsc common_type}}
{{dsc inc | cpp/chrono/time_point/dsc common_type}}
{{dsc end}}

===Possible implementation===
{{eq fun
 | 1=
template &lt;class ...T&gt; struct common_type;

template &lt;class T&gt;
struct common_type&lt;T&gt; {
    typedef decay_t&lt;T&gt; type;
};

template &lt;class T, class U&gt;
struct common_type&lt;T, U&gt; {
    typedef decay_t&lt;decltype(true ? declval&lt;T&gt;() : declval&lt;U&gt;())&gt; type;
};

template &lt;class T, class U, class... V&gt;
struct common_type&lt;T, U, V...&gt; {
    typedef common_type_t&lt;common_type_t&lt;T, U&gt;, V...&gt; type;
};
}}

===Examples===
{{example
 | Demonstrates mixed-mode arithmetic on a user-defined class
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
 
template &lt;class T&gt;
struct Number { T n; };
 
template &lt;class T, class U&gt;
Number&lt;typename std::common_type&lt;T, U&gt;::type&gt; operator+(const Number&lt;T&gt;&amp; lhs,
                                                        const Number&lt;U&gt;&amp; rhs) 
{
    return {lhs.n + rhs.n};
}
 
int main()
{
    Number&lt;int&gt; i1 = {1}, i2 = {2};
    Number&lt;double&gt; d1 = {2.3}, d2 = {3.5};
    std::cout &lt;&lt; &quot;i1i2: &quot; &lt;&lt; (i1 + i2).n &lt;&lt; &quot;\ni1d2: &quot; &lt;&lt; (i1 + d2).n &lt;&lt; '\n'
              &lt;&lt; &quot;d1i2: &quot; &lt;&lt; (d1 + i2).n &lt;&lt; &quot;\nd1d2: &quot; &lt;&lt; (d1 + d2).n &lt;&lt; '\n';
}
 | output=
i1i2: 3
i1d2: 4.5
d1i2: 4.3
d1d2: 5.8
}}

[[de:cpp/types/common type]]
[[es:cpp/types/common type]]
[[fr:cpp/types/common type]]
[[it:cpp/types/common type]]
[[ja:cpp/types/common type]]
[[pt:cpp/types/common type]]
[[ru:cpp/types/common type]]
[[zh:cpp/types/common type]]</text>
      <sha1>rukwjbvu6ncier9f70o58pkmnnd7v8z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/conditional</title>
    <ns>0</ns>
    <id>3191</id>
    <revision>
      <id>63007</id>
      <parentid>59300</parentid>
      <timestamp>2013-07-01T23:50:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1686">{{cpp/title|conditional}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; bool B, class T, class F &gt;
struct conditional;
}}
{{dcl end}}

Provides member typedef {{tt|type}}, which is defined as {{tt|T}} if {{tt|B}} is {{c|true}} at compile time, or as {{tt|F}} if {{tt|B}} is {{c|false}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|type}} | {{tt|T}} if {{c|1=B == true}}, {{tt|F}} if {{c|1=B == false}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; bool B, class T, class F &gt;
using conditional_t = typename conditional&lt;B,T,F&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;bool B, class T, class F&gt;
struct conditional { typedef T type; };

template&lt;class T, class F&gt;
struct conditional&lt;false, T, F&gt; { typedef F type; };
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;typeinfo&gt;

int main() 
{
    typedef std::conditional&lt;true, int, double&gt;::type Type1;
    typedef std::conditional&lt;false, int, double&gt;::type Type2;
    typedef std::conditional&lt;sizeof(int) &gt;= sizeof(double), int, double&gt;::type Type3;
   
    std::cout &lt;&lt; typeid(Type1).name() &lt;&lt; '\n';
    std::cout &lt;&lt; typeid(Type2).name() &lt;&lt; '\n';
    std::cout &lt;&lt; typeid(Type3).name() &lt;&lt; '\n';
}
 | output=
i
d
d
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc enable_if}}
{{dsc end}}

[[de:cpp/types/conditional]]
[[es:cpp/types/conditional]]
[[fr:cpp/types/conditional]]
[[it:cpp/types/conditional]]
[[ja:cpp/types/conditional]]
[[pt:cpp/types/conditional]]
[[ru:cpp/types/conditional]]
[[zh:cpp/types/conditional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/decay</title>
    <ns>0</ns>
    <id>3251</id>
    <revision>
      <id>71795</id>
      <parentid>71637</parentid>
      <timestamp>2014-06-24T04:54:53Z</timestamp>
      <contributor>
        <ip>118.139.39.198</ip>
      </contributor>
      <comment>Reversed operand order in decay_equiv, for readability.</comment>
      <text xml:space="preserve" bytes="2215">{{cpp/title|decay}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct decay;
}}
{{dcl end}}

Applies lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type {{tt|T}}, removes cv-qualifiers, and defines the resulting type as the member typedef {{tt|type}}. This is the type conversion applied to all function arguments when passed by value.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the result of applying the decay type conversions to {{tt|T}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using decay_t = typename decay&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct decay {
    typedef typename std::remove_reference&lt;T&gt;::type U;
    typedef typename std::conditional&lt; 
        std::is_array&lt;U&gt;::value,
        typename std::remove_extent&lt;U&gt;::type*,
        typename std::conditional&lt; 
            std::is_function&lt;U&gt;::value,
            typename std::add_pointer&lt;U&gt;::type,
            typename std::remove_cv&lt;U&gt;::type
        &gt;::type
    &gt;::type type;
};
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

template &lt;typename T, typename U&gt;
struct decay_equiv : 
    std::is_same&lt;typename std::decay&lt;T&gt;::type, U&gt;::type 
{};

int main()
{
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; decay_equiv&lt;int, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; decay_equiv&lt;int&amp;, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; decay_equiv&lt;int&amp;&amp;, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; decay_equiv&lt;const int&amp;, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; decay_equiv&lt;int[2], int*&gt;::value &lt;&lt; '\n'
              &lt;&lt; decay_equiv&lt;int(int), int(*)(int)&gt;::value &lt;&lt; '\n';
} 
| output=
true
true
true
true
true
true
}}

===See also===
{{dsc begin}}
{{dsc | {{ltt|cpp/language/implicit_cast|implicit conversion}} | array-to-pointer, function-to-pointer, rvalue-to-lvalue conversions }}
{{dsc end}}

[[de:cpp/types/decay]]
[[es:cpp/types/decay]]
[[fr:cpp/types/decay]]
[[it:cpp/types/decay]]
[[ja:cpp/types/decay]]
[[pt:cpp/types/decay]]
[[ru:cpp/types/decay]]
[[zh:cpp/types/decay]]</text>
      <sha1>rwxxwqlvkcwqmfjiwccd4ppjw4jnzwd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/enable if</title>
    <ns>0</ns>
    <id>2716</id>
    <revision>
      <id>72035</id>
      <parentid>70292</parentid>
      <timestamp>2014-07-09T18:41:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note that static_assert works better for limiting specializations</comment>
      <text xml:space="preserve" bytes="3065">{{cpp/title|enable_if}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; bool B, class T = void &gt;
struct enable_if;
}}
{{dcl end}}

If {{tt|B}} is {{c|true}}, {{lc|std::enable_if}} has a public member typedef {{tt|type}}, equal to {{tt|T}}; otherwise, there is no member typedef. 

This metafunction is a convenient way to leverage [[cpp/language/sfinae|SFINAE]] to conditionally remove functions from [[cpp/language/overload_resolution|overload resolution]] based on type traits and to provide separate function overloads and specializations for different type traits. {{lc|std::enable_if}} can be used as an additional function argument (not applicable to operator overloads), as a return type (not applicable to constructors and destructors), or as a class template or function template parameter.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|type}} | either {{tt|T}} or no such member, depending on the value of {{tt|B}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; bool B, class T = void &gt;
using enable_if_t = typename enable_if&lt;B,T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;bool B, class T = void&gt;
struct enable_if {};

template&lt;class T&gt;
struct enable_if&lt;true, T&gt; { typedef T type; };
}}

===Example===
{{example
 |
 | code=
#include &lt;type_traits&gt;
#include &lt;iostream&gt;

// foo1 overloads are enabled via the return type
template&lt;class T&gt;
typename std::enable_if&lt;std::is_floating_point&lt;T&gt;::value, T&gt;::type 
    foo1(T t) 
{
    std::cout &lt;&lt; &quot;foo1: float\n&quot;;
    return t;
}

template&lt;class T&gt;
std::enable_if_t&lt;std::is_integral&lt;T&gt;::value, T&gt; //Using helper type
    foo1(T t) 
{
    std::cout &lt;&lt; &quot;foo1: int\n&quot;;
    return t;
}

// foo2 overload is enabled via a parameter
template&lt;class T&gt;
T foo2(T t, typename std::enable_if&lt;std::is_integral&lt;T&gt;::value &gt;::type* = 0) 
{
    return t;
}

// foo3 overload is enabled via a template parameter
template&lt;class T ,
         typename std::enable_if&lt;std::is_integral&lt;T&gt;::value&gt;::type* = nullptr &gt;
T foo3(T t) // note, function signature is unmodified
{
    return t;
}

// A is enabled via a template parameter
template&lt;class T, class Enable = void&gt;
class A; // undefined

template&lt;class T&gt;
class A&lt;T, typename std::enable_if&lt;std::is_floating_point&lt;T&gt;::value &gt;::type&gt; {
}; // note: for this use case, static_assert may be more appropriate

int main()
{
    foo1(1.2); // OK, calls the first version of foo1()
    foo1(10); // OK, calls the second version of foo1()

//  foo2(0.1); // compile-time error
    foo2(7); // OK

//  foo3(1.2); // compile-time error
    foo3(34); // OK

//  A&lt;int&gt; a1; // compile-time error
    A&lt;double&gt; a1; // OK
}
 | output=
foo1: float
foo1: int
}}

===See also===
* [[cpp/language/static_assert|static_assert]]


[[de:cpp/types/enable if]]
[[es:cpp/types/enable if]]
[[fr:cpp/types/enable if]]
[[it:cpp/types/enable if]]
[[ja:cpp/types/enable if]]
[[pt:cpp/types/enable if]]
[[ru:cpp/types/enable if]]
[[zh:cpp/types/enable if]]</text>
      <sha1>oa72ajhymy629pxjxnru60v33um0qfb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/extent</title>
    <ns>0</ns>
    <id>2719</id>
    <revision>
      <id>63010</id>
      <parentid>59301</parentid>
      <timestamp>2013-07-01T23:50:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2007">{{cpp/title|extent}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T, unsigned N = 0&gt;
struct extent;
}}
{{dcl end}}

If {{tt|T}} is an array type, provides the member constant {{tt|value}} equal to the number of elements along the {{tt|N}}th dimension of the array, if {{tt|N}} is in {{tt|[0, std::rank&lt;T&gt;::value)}}. For any other type, or if {{tt|T}} is array of unknown bound along its first dimension and {{tt|N}} is 0, {{tt|value}} is 0.

{{cpp/types/integral_constant/inherit2 | the number of elements along the {{tt|N}}th dimension of {{tt|T}}|std::size_t}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T, unsigned N = 0&gt;
struct extent : std::integral_constant&lt;std::size_t, 0&gt; {};

template&lt;class T&gt;
struct extent&lt;T[], 0&gt; : std::integral_constant&lt;std::size_t, 0&gt; {};

template&lt;class T, unsigned N&gt;
struct extent&lt;T[], N&gt; : std::integral_constant&lt;std::size_t, std::extent&lt;T, N-1&gt;::value&gt; {};

template&lt;class T, std::size_t N&gt;
struct extent&lt;T[N], 0&gt; : std::integral_constant&lt;std::size_t, N&gt; {};

template&lt;class T, std::size_t I, unsigned N&gt;
struct extent&lt;T[I], N&gt; : std::integral_constant&lt;std::size_t, std::extent&lt;T, N-1&gt;::value&gt; {};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main()
{
    std::cout &lt;&lt; std::extent&lt;int[3]&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::extent&lt;int[3][4]&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::extent&lt;int[3][4], 1&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::extent&lt;int[3][4], 2&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::extent&lt;int[]&gt;::value &lt;&lt; '\n';
}
 | output=
3
3
4
0
0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}
{{dsc end}}

[[de:cpp/types/extent]]
[[es:cpp/types/extent]]
[[fr:cpp/types/extent]]
[[it:cpp/types/extent]]
[[ja:cpp/types/extent]]
[[pt:cpp/types/extent]]
[[ru:cpp/types/extent]]
[[zh:cpp/types/extent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/has virtual destructor</title>
    <ns>0</ns>
    <id>3279</id>
    <revision>
      <id>63011</id>
      <parentid>59304</parentid>
      <timestamp>2013-07-01T23:50:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1643">{{cpp/title|has_virtual_destructor}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct has_virtual_destructor;
}}
{{dcl end}}

If {{tt|T}} is a type with a virtual destructor, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} has a virtual destructor }}

===Notes===
If a class has a public virtual destructor, it can be derived from, and the derived object can be safely deleted through a pointer to the base object ([http://www.parashift.com/c++-faq-lite/virtual-functions.html#faq-20.7  C++FAQ Lite 20.7])

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;string&gt;
#include &lt;stdexcept&gt;

int main()
{
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;std::string has a virtual destructor? &quot;
              &lt;&lt; std::has_virtual_destructor&lt;std::string&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;std::runtime_error has a virtual destructor? &quot;
              &lt;&lt; std::has_virtual_destructor&lt;std::runtime_error&gt;::value &lt;&lt; '\n';
}
 | output=
std::string has a virtual destructor? false
std::runtime_error has a virtual destructor? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_destructible}}
{{dsc end}}

[[de:cpp/types/has virtual destructor]]
[[es:cpp/types/has virtual destructor]]
[[fr:cpp/types/has virtual destructor]]
[[it:cpp/types/has virtual destructor]]
[[ja:cpp/types/has virtual destructor]]
[[pt:cpp/types/has virtual destructor]]
[[ru:cpp/types/has virtual destructor]]
[[zh:cpp/types/has virtual destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/integer</title>
    <ns>0</ns>
    <id>2031</id>
    <revision>
      <id>67911</id>
      <parentid>51492</parentid>
      <timestamp>2014-03-05T16:26:04Z</timestamp>
      <contributor>
        <ip>212.18.10.178</ip>
      </contributor>
      <comment>Convert section &quot;Format macro constants&quot; to table layout</comment>
      <text xml:space="preserve" bytes="7830">{{title | Fixed width integer types {{mark since c++11}}}}
{{cpp/types/navbar}}

===Types===

{{dsc begin}}
{{dsc header | cstdint}}
{{dsc | {{tt|int8_t}}&lt;br&gt;{{tt|int16_t}}&lt;br&gt;{{tt|int32_t}}&lt;br&gt;{{tt|int64_t}} | signed integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively&lt;br&gt;with no padding bits and using 2's complement for negative values&lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|int_fast8_t}}&lt;br&gt;{{tt|int_fast16_t}}&lt;br&gt;{{tt|int_fast32_t}}&lt;br&gt;{{tt|int_fast64_t}} | fastest signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|int_least8_t}}&lt;br&gt;{{tt|int_least16_t}}&lt;br&gt;{{tt|int_least32_t}}&lt;br&gt;{{tt|int_least64_t}} | smallest signed integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|intmax_t}} | maximum width integer type }}
{{dsc | {{tt|intptr_t}} | integer type capable of holding a pointer}}{{dsc | {{tt|uint8_t}}&lt;br&gt;{{tt|uint16_t}}&lt;br&gt;{{tt|uint32_t}}&lt;br&gt;{{tt|uint64_t}} | unsigned integer type with width of&lt;br&gt; exactly 8, 16, 32 and 64 bits respectively &lt;br&gt;(provided only if the implementation directly supports the type) }}
{{dsc | {{tt|uint_fast8_t}}&lt;br&gt;{{tt|uint_fast16_t}}&lt;br&gt;{{tt|uint_fast32_t}}&lt;br&gt;{{tt|uint_fast64_t}} | fastest unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uint_least8_t}}&lt;br&gt;{{tt|uint_least16_t}}&lt;br&gt;{{tt|uint_least32_t}}&lt;br&gt;{{tt|uint_least64_t}} | smallest unsigned integer type with width of&lt;br&gt; at least 8, 16, 32 and 64 bits respectively }}
{{dsc | {{tt|uintmax_t}} | maximum width unsigned integer type }}
{{dsc | {{tt|uintptr_t}} | unsigned integer type capable of holding a pointer}}
{{dsc end}}

===Macro constants===
{{dsc begin}}
{{dsc header | cstdint}}
{{dsc h2 | Signed integers : minimum value}}
{{dsc macro const | INT8_MIN&lt;br&gt;INT16_MIN&lt;br&gt;INT32_MIN&lt;br&gt;INT64_MIN |  minimum value of an object of type {{c|int8_t}}, {{c|int16_t}}, {{c|int32_t}}, {{c|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MIN&lt;br&gt;INT_FAST16_MIN&lt;br&gt;INT_FAST32_MIN&lt;br&gt;INT_FAST64_MIN |  minimum value of an object of type {{c|int_fast8_t}}, {{c|int_fast16_t}}, {{c|int_fast32_t}}, {{c|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MIN&lt;br&gt;INT_LEAST16_MIN&lt;br&gt;INT_LEAST32_MIN&lt;br&gt;INT_LEAST64_MIN |  minimum value of an object of type {{c|int_least8_t}}, {{c|int_least16_t}}, {{c|int_least32_t}}, {{c|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MIN | minimum value of an object of type {{c|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MIN | minimum value of an object of type {{c|intmax_t}} | nolink=true }}
{{dsc h2 | Signed integers : maximum value| nolink=true }}

{{dsc macro const | INT8_MAX&lt;br&gt;INT16_MAX&lt;br&gt;INT32_MAX&lt;br&gt;INT64_MAX |  maximum value of an object of type {{c|int8_t}}, {{c|int16_t}}, {{c|int32_t}}, {{c|int64_t}} | nolink=true }}
{{dsc macro const | INT_FAST8_MAX&lt;br&gt;INT_FAST16_MAX&lt;br&gt;INT_FAST32_MAX&lt;br&gt;INT_FAST64_MAX |  maximum value of an object of type {{c|int_fast8_t}}, {{c|int_fast16_t}}, {{c|int_fast32_t}}, {{c|int_fast64_t}} | nolink=true }}
{{dsc macro const | INT_LEAST8_MAX&lt;br&gt;INT_LEAST16_MAX&lt;br&gt;INT_LEAST32_MAX&lt;br&gt;INT_LEAST64_MAX |  maximum value of an object of type {{c|int_least8_t}}, {{c|int_least16_t}}, {{c|int_least32_t}}, {{c|int_least64_t}} | nolink=true }}
{{dsc macro const | INTPTR_MAX | maximum value of an object of type {{c|intptr_t}} | nolink=true }}
{{dsc macro const | INTMAX_MAX | maximum value of an object of type {{c|intmax_t}} | nolink=true }}
{{dsc h2 | Unsigned integers : maximum value| nolink=true }}{{dsc macro const | UINT8_MAX&lt;br&gt;UINT16_MAX&lt;br&gt;UINT32_MAX&lt;br&gt;UINT64_MAX |  maximum value of an object of type {{c|uint8_t}}, {{c|uint16_t}}, {{c|uint32_t}}, {{c|uint64_t}} | nolink=true }}
{{dsc macro const | UINT_FAST8_MAX&lt;br&gt;UINT_FAST16_MAX&lt;br&gt;UINT_FAST32_MAX&lt;br&gt;UINT_FAST64_MAX |  maximum value of an object of type {{c|uint_fast8_t}}, {{c|uint_fast16_t}}, {{c|uint_fast32_t}}, {{c|uint_fast64_t}} | nolink=true }}
{{dsc macro const | UINT_LEAST8_MAX&lt;br&gt;UINT_LEAST16_MAX&lt;br&gt;UINT_LEAST32_MAX&lt;br&gt;UINT_LEAST64_MAX |  maximum value of an object of type {{c|uint_least8_t}}, {{c|uint_least16_t}}, {{c|uint_least32_t}}, {{c|uint_least64_t}} | nolink=true }}
{{dsc macro const | UINTPTR_MAX | maximum value of an object of type {{c|uintptr_t}} | nolink=true }}
{{dsc macro const | UINTMAX_MAX | maximum value of an object of type {{c|uintmax_t}} | nolink=true }}
{{dsc end}}

===Format macro constants===
{{dsc begin}}
{{dsc header | cinttypes}}
{{dsc end}}
====Format constants for the {{lc|std::fprintf}} family of functions====
{| class=&quot;wikitable&quot; style=&quot;text-align:center; font-size:85%; max-width:90em;&quot;
|-
! rowspan=3 | Equivalent&lt;br&gt;for {{c|int}} or&lt;br&gt;{{c|unsigned int}}
! rowspan=3 | Description
! colspan=5 | Macros for data types
|-
| &lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{vertical|{{lc|std::int}}'''x'''{{lc|_t}}}}&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;
| {{vertical|{{lc|std::int_least}}'''x'''{{lc|_t}}}}
| {{vertical|{{lc|std::int_fast}}'''x'''{{lc|_t}}}}
| rowspan=2 | {{vertical|{{lc|std::intmax_t}}}}
| rowspan=2 | {{vertical|{{lc|std::intptr_t}}}}
|-
| colspan=3 | '''x''' = 8, 16, 32 or 64
|-
! {{tt|%d}}
| rowspan=2 style=&quot;text-align:left;&quot; | output of a signed decimal integer value
| PRId'''x'''
| PRIdLEAST'''x'''
| PRIdFAST'''x'''
| PRIdMAX
| PRIdPTR
|-
! {{tt|%i}}
| PRIi'''x'''
| PRIiLEAST'''x'''
| PRIiFAST'''x'''
| PRIiMAX
| PRIiPTR
|-
! {{tt|%u}}
| style=&quot;text-align:left;&quot; | output of an unsigned decimal integer value
| PRIu'''x'''
| PRIuLEAST'''x'''
| PRIuFAST'''x'''
| PRIuMAX
| PRIuPTR
|-
! {{tt|%o}}
| style=&quot;text-align:left;&quot; | output of an unsigned octal integer value
| PRIo'''x'''
| PRIoLEAST'''x'''
| PRIoFAST'''x'''
| PRIoMAX
| PRIoPTR
|-
! {{tt|%x}}
| style=&quot;text-align:left;&quot; | output of an unsigned lowercase hexadecimal integer value
| PRIx'''x'''
| PRIxLEAST'''x'''
| PRIxFAST'''x'''
| PRIxMAX
| PRIxPTR
|-
! {{tt|%X}}
| style=&quot;text-align:left;&quot; | output of an unsigned uppercase hexadecimal integer value
| PRIX'''x'''
| PRIXLEAST'''x'''
| PRIXFAST'''x'''
| PRIXMAX
| PRIXPTR
|}
====Format constants for the {{lc|std::fscanf}} family of functions====
{| class=&quot;wikitable&quot; style=&quot;text-align:center; font-size:85%; max-width:90em;&quot;
|-
! rowspan=3 | Equivalent&lt;br&gt;for {{c|int}} or&lt;br&gt;{{c|unsigned int}}
! rowspan=3 | Description
! colspan=5 | Macros for data types
|-
| &lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;{{vertical|{{lc|std::int}}'''x'''{{lc|_t}}}}&lt;br&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;
| {{vertical|{{lc|std::int_least}}'''x'''{{lc|_t}}}}
| {{vertical|{{lc|std::int_fast}}'''x'''{{lc|_t}}}}
| rowspan=2 | {{vertical|{{lc|std::intmax_t}}}}
| rowspan=2 | {{vertical|{{lc|std::intptr_t}}}}
|-
| colspan=3 | '''x''' = 8, 16, 32 or 64
|-
! {{tt|%d}}
| rowspan=2 style=&quot;text-align:left;&quot; | input of a signed decimal integer value
| SCNd'''x'''
| SCNdLEAST'''x'''
| SCNdFAST'''x'''
| SCNdMAX
| SCNdPTR
|-
! {{tt|%i}}
| SCNi'''x'''
| SCNiLEAST'''x'''
| SCNiFAST'''x'''
| SCNiMAX
| SCNiPTR
|-
! {{tt|%u}}
| style=&quot;text-align:left;&quot; | input of an unsigned decimal integer value
| SCNu'''x'''
| SCNuLEAST'''x'''
| SCNuFAST'''x'''
| SCNuMAX
| SCNuPTR
|-
! {{tt|%o}}
| style=&quot;text-align:left;&quot; | input of an unsigned octal integer value
| SCNo'''x'''
| SCNoLEAST'''x'''
| SCNoFAST'''x'''
| SCNoMAX
| SCNoPTR
|-
! {{tt|%x}}
| style=&quot;text-align:left;&quot; | input of an unsigned lowercase hexadecimal integer value
| SCNx'''x'''
| SCNxLEAST'''x'''
| SCNxFAST'''x'''
| SCNxMAX
| SCNxPTR
|-
! {{tt|%X}}
| style=&quot;text-align:left;&quot; | input of an unsigned uppercase hexadecimal integer value
| SCNX'''x'''
| SCNXLEAST'''x'''
| SCNXFAST'''x'''
| SCNXMAX
| SCNXPTR
|}


[[de:cpp/types/integer]]
[[es:cpp/types/integer]]
[[fr:cpp/types/integer]]
[[it:cpp/types/integer]]
[[ja:cpp/types/integer]]
[[pt:cpp/types/integer]]
[[ru:cpp/types/integer]]
[[zh:cpp/types/integer]]</text>
      <sha1>n03e4fo7rdna9b2oaujhk8188031fgb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/integral constant</title>
    <ns>0</ns>
    <id>2760</id>
    <revision>
      <id>71721</id>
      <parentid>68211</parentid>
      <timestamp>2014-06-22T06:21:15Z</timestamp>
      <contributor>
        <ip>50.193.51.210</ip>
      </contributor>
      <comment>Fixed static assertion error description</comment>
      <text xml:space="preserve" bytes="2639">{{cpp/title|integral_constant}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T, T v &gt;
struct integral_constant;
}}
{{dcl end}}

{{lc|std::integral_constant}} wraps a static constant of specified type. It is the base class for the C++ type traits. 

Two specializations for the type {{c|bool}} are provided: 

{{dsc begin}}
{{dsc header | type_traits}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|true_type}} | {{c|std::integral_constant&lt;bool, true&gt;}}}}
{{dsc | {{tt|false_type}} | {{c|std::integral_constant&lt;bool, false&gt;}}}}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc | {{tt|type}} | {{c|std::integral_constant&lt;T,v&gt;}} }}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc hitem | Name | Value }}
{{dsc | {{tt|value}} | static constant expression of type {{tt|T}} with value {{tt|v}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/types/integral_constant/dsc operator value_type}}
{{dsc inc | cpp/types/integral_constant/dsc operator()}}
{{dsc end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T, T v&gt;
struct integral_constant {
    static constexpr T value = v;
    typedef T value_type;
    typedef integral_constant type;
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() 
{
    typedef std::integral_constant&lt;int, 2&gt; two_t;
    typedef std::integral_constant&lt;int, 4&gt; four_t;

//  static_assert(std::is_same&lt;two_t, four_t&gt;::value,
//                &quot;two_t and four_t are not equal!&quot;); 
//  error: static assertion failed: &quot;two_t and four_t are not equal!&quot;

    static_assert(two_t::value*2 == four_t::value,
       &quot;2*2 != 4&quot;
    );

    enum class my_e {
       e1,
       e2
    };
    typedef std::integral_constant&lt;my_e, my_e::e1&gt; my_e_e1;
    typedef std::integral_constant&lt;my_e, my_e::e2&gt; my_e_e2;

//  static_assert(my_e_e1::value == my_e::e2,
//               &quot;my_e_e1::value != my_e::e2&quot;);
//  error: static assertion failed: &quot;my_e_e1::value != my_e::e2&quot;

    static_assert(std::is_same&lt;my_e_e2, my_e_e2&gt;::value,
                  &quot;my_e_e2 != my_e_e2&quot;);
}
 | output=
}}

[[de:cpp/types/integral constant]]
[[es:cpp/types/integral constant]]
[[fr:cpp/types/integral constant]]
[[it:cpp/types/integral constant]]
[[ja:cpp/types/integral constant]]
[[pt:cpp/types/integral constant]]
[[ru:cpp/types/integral constant]]
[[zh:cpp/types/integral constant]]</text>
      <sha1>l188x4mds8dgqs9sbb1ll5nskf8a7jl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is abstract</title>
    <ns>0</ns>
    <id>3181</id>
    <revision>
      <id>68722</id>
      <parentid>63013</parentid>
      <timestamp>2014-03-20T02:55:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to the fuller explanation in cpp/language</comment>
      <text xml:space="preserve" bytes="1405">{{cpp/title|is_abstract}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_abstract;
}}
{{dcl end}}

If {{tt|T}} is an [[cpp/language/abstract_class|abstract class]] (that is, a non-union class that declares or inherits at least one pure virtual function), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an [[cpp/language/abstract_class|abstract class]] type }}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    virtual void foo();
};

struct C {
    virtual void foo() = 0;
};

struct D : C {};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_abstract&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_abstract&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_abstract&lt;C&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_abstract&lt;D&gt;::value &lt;&lt; '\n';
}
 | output=
false
false
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_polymorphic}}
{{dsc end}}

[[de:cpp/types/is abstract]]
[[es:cpp/types/is abstract]]
[[fr:cpp/types/is abstract]]
[[it:cpp/types/is abstract]]
[[ja:cpp/types/is abstract]]
[[pt:cpp/types/is abstract]]
[[ru:cpp/types/is abstract]]
[[zh:cpp/types/is abstract]]</text>
      <sha1>alg5ltvaqj42b0vryyitekkr32l5iht</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is arithmetic</title>
    <ns>0</ns>
    <id>3173</id>
    <revision>
      <id>63014</id>
      <parentid>59309</parentid>
      <timestamp>2013-07-01T23:50:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2009">{{cpp/title|is_arithmetic}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_arithmetic;
}}
{{dcl end}}

If {{tt|T}} is an arithmetic type (that is, an integral type or a floating-point type), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an arithmetic type }}

===Notes===
Arithmetic types are the types for which the built-in [[cpp/language/operator_arithmetic|arithmetic operators]] (+, -, *, /) are defined (possibly in combination with the usual arithmetic conversions)

Specializations of {{lc|std::numeric_limits}} are provided for all arithmetic types.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_arithmetic : std::integral_constant&lt;bool,
                                              std::is_integral&lt;T&gt;::value {{!!}}
                                              std::is_floating_point&lt;T&gt;::value&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_arithmetic&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;int*&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;float&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_arithmetic&lt;float*&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc end}}

[[de:cpp/types/is arithmetic]]
[[es:cpp/types/is arithmetic]]
[[fr:cpp/types/is arithmetic]]
[[it:cpp/types/is arithmetic]]
[[ja:cpp/types/is arithmetic]]
[[pt:cpp/types/is arithmetic]]
[[ru:cpp/types/is arithmetic]]
[[zh:cpp/types/is arithmetic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is array</title>
    <ns>0</ns>
    <id>2718</id>
    <revision>
      <id>63015</id>
      <parentid>59310</parentid>
      <timestamp>2013-07-01T23:50:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1608">{{cpp/title|is_array}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_array;
}}
{{dcl end}}

Checks whether {{tt|T}} is an array type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is an array type . Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is an array type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct is_array : std::false_type {};

template&lt;class T&gt;
struct is_array&lt;T[]&gt; : std::true_type {};

template&lt;class T, std::size_t N&gt;
struct is_array&lt;T[N]&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_array&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_array&lt;A[3]&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_array&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_array&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_array&lt;int[3]&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}
{{dsc end}}

[[de:cpp/types/is array]]
[[es:cpp/types/is array]]
[[fr:cpp/types/is array]]
[[it:cpp/types/is array]]
[[ja:cpp/types/is array]]
[[pt:cpp/types/is array]]
[[ru:cpp/types/is array]]
[[zh:cpp/types/is array]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is assignable</title>
    <ns>0</ns>
    <id>3262</id>
    <revision>
      <id>65862</id>
      <parentid>63016</parentid>
      <timestamp>2013-10-11T09:46:11Z</timestamp>
      <contributor>
        <ip>129.132.102.145</ip>
      </contributor>
      <text xml:space="preserve" bytes="2547">{{cpp/title|is_assignable|is_trivially_assignable|is_nothrow_assignable}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T, class U &gt;
struct is_assignable;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T, class U &gt;
struct is_trivially_assignable;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T, class U &gt;
struct is_nothrow_assignable;
}}
{{dcl end}}

@1@ If the expression {{c|1=std::declval&lt;T&gt;() = std::declval&lt;U&gt;()}} is well-formed in unevaluated context, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

@2@ same as (1), but evaluation of the assignment expression will not call any operation that is not trivial.

@3@ same as (1), but the evaluation of the assignment expression will not call any operation that is not noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is assignable from {{tt|U}} }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;type_traits&gt;
struct Ex1 { int n; };
int main() {
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;int is assignable from int? &quot;
              &lt;&lt; std::is_assignable&lt;int, int&gt;::value &lt;&lt; '\n' // 1 = 1; wouldn't compile
              &lt;&lt; &quot;int&amp; is assignable from int? &quot;
              &lt;&lt; std::is_assignable&lt;int&amp;, int&gt;::value &lt;&lt; '\n' // int a; a = 1; works
              &lt;&lt; &quot;int is assignable from double? &quot;
              &lt;&lt; std::is_assignable&lt;int, double&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;int&amp; is nothrow assignable from double? &quot;
              &lt;&lt; std::is_nothrow_assignable&lt;int&amp;, double&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;string is assignable from double? &quot;
              &lt;&lt; std::is_assignable&lt;std::string, double&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex1&amp; is trivially assignable from const Ex1&amp;? &quot;
              &lt;&lt; std::is_trivially_assignable&lt;Ex1&amp;, const Ex1&amp;&gt;::value &lt;&lt; '\n';
}
 | output=
int is assignable from int? false
int&amp; is assignable from int? true
int is assignable from double? false
int&amp; is nothrow assignable from double? true
string is assignable from double? true
Ex1&amp; is trivially assignable from const Ex1&amp;? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_copy_assignable}}
{{dsc inc | cpp/types/dsc is_move_assignable}}
{{dsc end}}

[[de:cpp/types/is assignable]]
[[es:cpp/types/is assignable]]
[[fr:cpp/types/is assignable]]
[[it:cpp/types/is assignable]]
[[ja:cpp/types/is assignable]]
[[pt:cpp/types/is assignable]]
[[ru:cpp/types/is assignable]]
[[zh:cpp/types/is assignable]]</text>
      <sha1>ln2j0bqmvhiyu700w00jv3at9y4igft</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is base of</title>
    <ns>0</ns>
    <id>3187</id>
    <revision>
      <id>66102</id>
      <parentid>63017</parentid>
      <timestamp>2013-10-29T15:29:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention requirement for complete type</comment>
      <text xml:space="preserve" bytes="1285">{{cpp/title|is_base_of}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class Base, class Derived &gt;
struct is_base_of;
}}
{{dcl end}}

If {{tt|Derived}} is derived from {{tt|Base}} or if both are the same non-union class, provides the member constant {{tt|value}} equal to {{c|true}}. Otherwise {{tt|value}} is {{c|false}}.

Requires that {{tt|Derived}} is a [[cpp/language/incomplete type|complete type]] if it is not the same type as {{tt|Base}} and if both {{tt|Base}} and {{tt|Derived}} are class types.

{{cpp/types/integral_constant/inherit | {{tt|Derived}} is derived from {{tt|Base}} }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

class B : A {};

class C {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;a2b: &quot; &lt;&lt; std::is_base_of&lt;A, B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b2a: &quot; &lt;&lt; std::is_base_of&lt;B, A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;c2b: &quot; &lt;&lt; std::is_base_of&lt;C, B&gt;::value &lt;&lt; '\n';
}
 | output=
a2b: true
b2a: false
c2b: false
}}

[[de:cpp/types/is base of]]
[[es:cpp/types/is base of]]
[[fr:cpp/types/is base of]]
[[it:cpp/types/is base of]]
[[ja:cpp/types/is base of]]
[[pt:cpp/types/is base of]]
[[ru:cpp/types/is base of]]
[[zh:cpp/types/is base of]]</text>
      <sha1>3n6i33gr9xc7706jz5we0t8ovjsldw5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is class</title>
    <ns>0</ns>
    <id>3140</id>
    <revision>
      <id>69434</id>
      <parentid>63018</parentid>
      <timestamp>2014-04-08T18:09:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>possible impl (based on libc++)</comment>
      <text xml:space="preserve" bytes="1605">{{cpp/title|is_class}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_class;
}}
{{dcl end}}

Checks whether {{tt|T}} is an class or struct type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is an class or struct type (but not union). Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a class or struct }}

===Possible implementation===
{{eq fun
 | 1=
namespace detail {
    template &lt;class T&gt; char test(int T::*);
    struct two { char c[2]; };
    template &lt;class T&gt; two test(...);
}

template &lt;class T&gt;
struct is_class : std::integral_constant&lt;bool, sizeof(detail::test&lt;T&gt;(0))==1
                                            &amp;&amp; !std::is_union&lt;T&gt;::value&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {};

class B {};

enum class C {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_class&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_class&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_class&lt;C&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_class&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
true
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc end}}

[[de:cpp/types/is class]]
[[es:cpp/types/is class]]
[[fr:cpp/types/is class]]
[[it:cpp/types/is class]]
[[ja:cpp/types/is class]]
[[pt:cpp/types/is class]]
[[ru:cpp/types/is class]]
[[zh:cpp/types/is class]]</text>
      <sha1>puzsz4er5l8v118dlm4zwoq17lyof2g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is compound</title>
    <ns>0</ns>
    <id>3144</id>
    <revision>
      <id>63019</id>
      <parentid>59315</parentid>
      <timestamp>2013-07-01T23:50:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1733">{{cpp/title|is_compound}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_compound;
}}
{{dcl end}}

If {{tt|T}} is a compound type (that is, array, function, object pointer, function pointer, member object pointer, member function pointer, reference, class, union, or enumeration, including any cv-qualified variants), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a compound type }}

===Notes===
Compound types are the types that are constructed from fundamental types. Any C++ type is either fundamental or compound.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_compound : std::integral_constant&lt;bool, !std::is_fundamental&lt;T&gt;::value&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    class cls {};
    std::cout &lt;&lt; (std::is_compound&lt;cls&gt;::value
                     ? &quot;T is compound&quot;
                     : &quot;T is not a compound&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; (std::is_compound&lt;int&gt;::value
                     ? &quot;T is compound&quot;
                     : &quot;T is not a compound&quot;) &lt;&lt; '\n';
}

 | output=
T is compound
T is not a compound
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_fundamental}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc end}}

[[de:cpp/types/is compound]]
[[es:cpp/types/is compound]]
[[fr:cpp/types/is compound]]
[[it:cpp/types/is compound]]
[[ja:cpp/types/is compound]]
[[pt:cpp/types/is compound]]
[[ru:cpp/types/is compound]]
[[zh:cpp/types/is compound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is const</title>
    <ns>0</ns>
    <id>3176</id>
    <revision>
      <id>63020</id>
      <parentid>59318</parentid>
      <timestamp>2013-07-01T23:50:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1172">{{cpp/title|is_const}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_const;
}}
{{dcl end}}

If {{tt|T}} is a const-qualified type (that is, {{c|const}}, or {{c|const volatile}}), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a const-qualified type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; struct is_const          : std::false_type {};
template&lt;class T&gt; struct is_const&lt;const T&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_const&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_const&lt;const int&gt;::value  &lt;&lt; '\n';
}

 | output=
false
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_volatile}}
{{dsc end}}

[[de:cpp/types/is const]]
[[es:cpp/types/is const]]
[[fr:cpp/types/is const]]
[[it:cpp/types/is const]]
[[ja:cpp/types/is const]]
[[pt:cpp/types/is const]]
[[ru:cpp/types/is const]]
[[zh:cpp/types/is const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is constructible</title>
    <ns>0</ns>
    <id>3249</id>
    <revision>
      <id>70573</id>
      <parentid>63021</parentid>
      <timestamp>2014-05-25T12:18:39Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2704">{{cpp/title|is_constructible|is_trivially_constructible|is_nothrow_constructible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T, class... Args &gt;
struct is_constructible;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T, class... Args &gt;
struct is_trivially_constructible;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T, class... Args &gt;
struct is_nothrow_constructible;
}}
{{dcl end}}

1) If the expression {{c|T obj(arg1, arg2, ... argN);}} is well-formed, given {{c|declval&lt;Args&gt;()...}} as arguments, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

2) same as 1), but the constructor expression does not call any operation that is not trivial.

3) same as 1), but the constructor expression is noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is constructible from {{tt|Args...}} }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class Foo {
    int v1;
    double v2;
 public:
    Foo(int n) : v1(n), v2() {}
    Foo(int n, double f) noexcept : v1(n), v2(f) {}
};

int main() {
    std::cout &lt;&lt; &quot;Foo is ...\n&quot; &lt;&lt; std::boolalpha
              &lt;&lt; &quot;\tTrivially-constructible from const Foo&amp;? &quot;
              &lt;&lt; std::is_trivially_constructible&lt;Foo, const Foo&amp;&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;\tTrivially-constructible from int? &quot;
              &lt;&lt; std::is_trivially_constructible&lt;Foo, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;\tConstructible from int? &quot;
              &lt;&lt; std::is_constructible&lt;Foo, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;\tNothrow-constructible from int? &quot;
              &lt;&lt; std::is_nothrow_constructible&lt;Foo, int&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;\tNothrow-constructible from int and double? &quot;
              &lt;&lt; std::is_nothrow_constructible&lt;Foo, int, double&gt;::value &lt;&lt; '\n';
}
 | output=
Foo is ...
        Trivially-constructible from const Foo&amp;? true
        Trivially-constructible from int? false
        Constructible from int? true
        Nothrow-constructible from int? false
        Nothrow-constructible from int and double? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc inc | cpp/memory/dsc uses_allocator}} &lt;!-- example of practical use of is_constructible --&gt;
{{dsc end}}

[[de:cpp/types/is constructible]]
[[es:cpp/types/is constructible]]
[[fr:cpp/types/is constructible]]
[[it:cpp/types/is constructible]]
[[ja:cpp/types/is constructible]]
[[pt:cpp/types/is constructible]]
[[ru:cpp/types/is constructible]]
[[zh:cpp/types/is constructible]]</text>
      <sha1>m1qpkx2taiw2q5b2rjyfx0n50s1s4o7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is convertible</title>
    <ns>0</ns>
    <id>3188</id>
    <revision>
      <id>63022</id>
      <parentid>51503</parentid>
      <timestamp>2013-07-01T23:50:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1428">{{cpp/title|is_convertible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class From, class To &gt;
struct is_convertible;
}}
{{dcl end}}

If an imaginary rvalue of type {{tt|From}} can be used in the return statement of a function returning {{tt|To}}, that is, if it can be converted to {{tt|To}} using {{ltt|cpp/language/implicit_cast|implicit conversion}}, provides the member constant {{tt|value}} equal to {{c|true}}. Otherwise {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|From}} is convertible to {{tt|To}} }}

===Notes===
Gives well-defined results for reference types, void types, array types, and function types.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() 
{
    class A {};
    class B : public A {};
    class C {};
    
    bool b2a = std::is_convertible&lt;B*, A*&gt;::value;
    bool a2b = std::is_convertible&lt;A*, B*&gt;::value;
    bool b2c = std::is_convertible&lt;B*, C*&gt;::value;
   
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; b2a &lt;&lt; '\n';
    std::cout &lt;&lt; a2b &lt;&lt; '\n';
    std::cout &lt;&lt; b2c &lt;&lt; '\n';
}
 | output=
true
false
false
}}

[[de:cpp/types/is convertible]]
[[es:cpp/types/is convertible]]
[[fr:cpp/types/is convertible]]
[[it:cpp/types/is convertible]]
[[ja:cpp/types/is convertible]]
[[pt:cpp/types/is convertible]]
[[ru:cpp/types/is convertible]]
[[zh:cpp/types/is convertible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is copy assignable</title>
    <ns>0</ns>
    <id>3272</id>
    <revision>
      <id>63023</id>
      <parentid>59322</parentid>
      <timestamp>2013-07-01T23:50:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2750">{{cpp/title|is_copy_assignable|is_trivially_copy_assignable|is_nothrow_copy_assignable}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_copy_assignable;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_copy_assignable;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_copy_assignable;
}}
{{dcl end}}

1) Checks whether a type is {{concept|CopyAssignable}}, i.e. has an accessible explicit or implicit copy assignment operator. If the requirement is met, a member constant {{tt|value}} equal {{c|true}} is provided, otherwise {{tt|value}} is {{c|false}}.

2) Same as 1), but evaluation of the copy-assignment expression will not call any operation that is not trivial.

3) Same as 1), but the evaluation of the copy-assignment expression will not call any operation that is not noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is copy-assignable}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T&gt;
struct is_copy_assignable
    : std::is_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                          typename std::add_lvalue_reference&lt;const T&gt;::type&gt; {};

template&lt; class T&gt;
struct is_trivially_copy_assignable
    : std::is_trivially_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                                    typename std::add_lvalue_reference&lt;const T&gt;::type&gt; {};

template&lt; class T&gt;
struct is_nothrow_copy_assignable
    : std::is_nothrow_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                                  typename std::add_lvalue_reference&lt;const T&gt;::type&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;type_traits&gt;
struct Foo { int n; };
int main() {
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;Foo is trivally copy-assignable? &quot;
              &lt;&lt; std::is_trivially_copy_assignable&lt;Foo&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;int[2] is copy-assignable? &quot;
              &lt;&lt; std::is_copy_assignable&lt;int[2]&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;int is nothrow copy-assignable? &quot;
              &lt;&lt; std::is_nothrow_copy_assignable&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
Foo is trivally copy-assignable? true
int[2] is copy-assignable? false
int is nothrow copy-assignable? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_assignable}}
{{dsc inc | cpp/types/dsc is_move_assignable}}
{{dsc end}}

[[de:cpp/types/is copy assignable]]
[[es:cpp/types/is copy assignable]]
[[fr:cpp/types/is copy assignable]]
[[it:cpp/types/is copy assignable]]
[[ja:cpp/types/is copy assignable]]
[[pt:cpp/types/is copy assignable]]
[[ru:cpp/types/is copy assignable]]
[[zh:cpp/types/is copy assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is copy constructible</title>
    <ns>0</ns>
    <id>3257</id>
    <revision>
      <id>66734</id>
      <parentid>66529</parentid>
      <timestamp>2013-12-28T19:21:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>similar wording change (after all, std now defines it simply as is_constructible&lt;T, const T&amp;&gt;</comment>
      <text xml:space="preserve" bytes="2870">{{cpp/title|is_copy_constructible|is_trivially_copy_constructible|is_nothrow_copy_constructible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_copy_constructible;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_copy_constructible;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_copy_constructible;
}}
{{dcl end}}

1) Checks whether a type is {{concept|CopyConstructible}}, i.e. can be constructed from a {{tt|const T&amp;}} argument. If the requirement is met, a member constant {{tt|value}} equal {{c|true}} is provided, otherwise {{tt|value}} is {{c|false}}.

2) Same as (1), but the copy constructor expression does not call any operation that is not trivial.

3) Same as (1), but the copy constructor expression is noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is copy-constructible }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct is_copy_constructible :
    std::is_constructible&lt;T, const typename std::add_lvalue_reference&lt;T&gt;::type&gt; {};

template&lt;class T&gt;
struct is_trivially_copy_constructible :
    std::is_trivially_constructible&lt;T, const typename std::add_lvalue_reference&lt;T&gt;::type&gt; {};

template&lt;class T&gt;
struct is_nothrow_copy_constructible :
    std::is_nothrow_constructible&lt;T, const typename std::add_lvalue_reference&lt;T&gt;::type&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct Ex1 {
    std::string str; // member has a non-trivial copy ctor
};
struct Ex2 {
    int n;
    Ex2(const Ex2&amp;) = default; // trivial and non-throwing
};

int main() {
    std::cout &lt;&lt; std::boolalpha &lt;&lt; &quot;Ex1 is copy-constructible? &quot;
              &lt;&lt; std::is_copy_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex1 is trivially copy-constructible? &quot;
              &lt;&lt; std::is_trivially_copy_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is trivially copy-constructible? &quot;
              &lt;&lt; std::is_trivially_copy_constructible&lt;Ex2&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is nothrow copy-constructible? &quot;
              &lt;&lt; std::is_nothrow_copy_constructible&lt;Ex2&gt;::value &lt;&lt; '\n';
}
 | output=
Ex1 is copy-constructible? true
Ex1 is trivially copy-constructible? false
Ex2 is trivially copy-constructible? true
Ex2 is nothrow copy-constructible? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc end}}

[[de:cpp/types/is copy constructible]]
[[es:cpp/types/is copy constructible]]
[[fr:cpp/types/is copy constructible]]
[[it:cpp/types/is copy constructible]]
[[ja:cpp/types/is copy constructible]]
[[pt:cpp/types/is copy constructible]]
[[ru:cpp/types/is copy constructible]]
[[zh:cpp/types/is copy constructible]]</text>
      <sha1>5orz2cg751587cywq25c1h1pkw40nll</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is default constructible</title>
    <ns>0</ns>
    <id>3256</id>
    <revision>
      <id>65313</id>
      <parentid>63025</parentid>
      <timestamp>2013-09-08T08:18:23Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <minor/>
      <comment>compile fix</comment>
      <text xml:space="preserve" bytes="2787">{{cpp/title|is_default_constructible|is_trivially_default_constructible|is_nothrow_default_constructible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_default_constructible;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_default_constructible;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_default_constructible;
}}
{{dcl end}}

1) Checks whether a type is {{concept|DefaultConstructible}}, i.e. has an accessible explicit or implicit default constructor. If the requirement is met, a member constant {{tt|value}} equal {{c|true}} is provided, otherwise {{tt|value}} is {{c|false}}.

2) Same as 1), but the constructor expression does not call any operation that is not trivial.

3) Same as 1), but the constructor expression is noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is default-constructible }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T&gt;
struct is_default_constructible : std::is_constructible&lt;T&gt; {};

template&lt; class T&gt;
struct is_trivially_default_constructible : std::is_trivially_constructible&lt;T&gt; {};

template&lt; class T&gt;
struct is_nothrow_default_constructible : std::is_nothrow_constructible&lt;T&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct Ex1 {
    std::string str; // member has a non-trivial default ctor
};
struct Ex2 {
    int n;
    Ex2() = default; // trivial and non-throwing
};

int main() {
    std::cout &lt;&lt; std::boolalpha &lt;&lt; &quot;Ex1 is default-constructible? &quot;
              &lt;&lt; std::is_default_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex1 is trivially default-constructible? &quot;
              &lt;&lt; std::is_trivially_default_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is trivially default-constructible? &quot;
              &lt;&lt; std::is_trivially_default_constructible&lt;Ex2&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is nothrow default-constructible? &quot;
              &lt;&lt; std::is_nothrow_default_constructible&lt;Ex2&gt;::value &lt;&lt; '\n';
}
 | output=
Ex1 is default-constructible? true
Ex1 is trivially default-constructible? false
Ex2 is trivially default-constructible? true
Ex2 is nothrow default-constructible? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc inc | cpp/types/dsc is_move_constructible}}
{{dsc end}}

[[de:cpp/types/is default constructible]]
[[es:cpp/types/is default constructible]]
[[fr:cpp/types/is default constructible]]
[[it:cpp/types/is default constructible]]
[[ja:cpp/types/is default constructible]]
[[pt:cpp/types/is default constructible]]
[[ru:cpp/types/is default constructible]]
[[zh:cpp/types/is default constructible]]</text>
      <sha1>1wagway926k3tlslmd9jcffbpog8sbe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is destructible</title>
    <ns>0</ns>
    <id>3274</id>
    <revision>
      <id>67159</id>
      <parentid>67113</parentid>
      <timestamp>2014-01-24T10:51:31Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2907">{{cpp/title|is_destructible|is_trivially_destructible|is_nothrow_destructible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_destructible;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_destructible;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_destructible;
}}
{{dcl end}}

{{rev begin}}
{{rev | until=c++14|
1) If an imaginary struct containing a member object of type {{tt|T}} has a non-deleted destructor, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}. }}
{{rev | since=c++14|
1) If {{tt|T}} is a reference type, provides the member constant {{tt|value}} equal {{c|true}}

If {{tt|T}} is an incomplete type (including void) or a function type, {{tt|value}} equals {{c|false}}.

If {{tt|T}} is an object type, then, for the type {{tt|U}} equal {{c|std::remove_all_extents&lt;T&gt;::type}}, if the expression {{c|std::declval&lt;U&amp;&gt;().~U()}} is well-formed in unevaluated context, {{tt|value}} equals {{c|true}}. Otherwise, {{tt|value}} equals {{c|false}}.
}}
{{rev end}}

2) same as 1), but the destructor does not call any operation that is not trivial.

3) same as 1), but the destructor is noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is destructible}}

===Notes===
Because the C++ program terminates if a destructor throws an exception during stack unwinding (which usually cannot be predicted), all practical destructors are non-throwing even if they are not declared noexcept. All destructors found in the C++ standard library are non-throwing.

Storage occupied by trivially destructible objects [[cpp/language/lifetime#Storage_reuse|may be reused]] without calling the destructor.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;type_traits&gt;
struct Foo {
   std::string str;
   ~Foo() noexcept {};
};
struct Bar {
    ~Bar() = default;
};
int main() {
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;std::string is destructible? &quot;
              &lt;&lt; std::is_destructible&lt;std::string&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Foo is nothrow destructible? &quot;
              &lt;&lt; std::is_nothrow_destructible&lt;Foo&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Bar is trivally destructible? &quot;
              &lt;&lt; std::is_trivially_destructible&lt;Bar&gt;::value &lt;&lt; '\n';
}
 | output=
std::string is destructible? true
Foo is nothrow destructible? true
Bar is trivally destructible? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc has_virtual_destructor}}
{{dsc end}}

[[de:cpp/types/is destructible]]
[[es:cpp/types/is destructible]]
[[fr:cpp/types/is destructible]]
[[it:cpp/types/is destructible]]
[[ja:cpp/types/is destructible]]
[[pt:cpp/types/is destructible]]
[[ru:cpp/types/is destructible]]
[[zh:cpp/types/is destructible]]</text>
      <sha1>9u8ltry91qosyp5mkckwik1l4ty4goz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is empty</title>
    <ns>0</ns>
    <id>3179</id>
    <revision>
      <id>67267</id>
      <parentid>67266</parentid>
      <timestamp>2014-01-31T17:53:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link empty base optimization</comment>
      <text xml:space="preserve" bytes="1502">{{cpp/title|is_empty}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_empty;
}}
{{dcl end}}

If {{tt|T}} is an empty type (that is, a non-union class type with no non-static data members other than bit-fields of size 0, no virtual functions, no virtual base classes, and no non-empty base classes), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an empty class type }}

===Notes===
{{c|sizeof(T)}} always returns 1 if {{tt|T}} is empty, but inheriting from empty base classes usually does not increase the size of a class due to [[cpp/language/ebo|empty base optimization]].

{{c|std::is_empty&lt;T&gt;}} and all other type traits are empty classes.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {};

struct B {
    int m;
};

struct C {
    virtual ~C();
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_empty&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_empty&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_empty&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc end}}

[[de:cpp/types/is empty]]
[[es:cpp/types/is empty]]
[[fr:cpp/types/is empty]]
[[it:cpp/types/is empty]]
[[ja:cpp/types/is empty]]
[[pt:cpp/types/is empty]]
[[ru:cpp/types/is empty]]
[[zh:cpp/types/is empty]]</text>
      <sha1>ef477omuroy2aulzw8fd8tlbpbydys8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is enum</title>
    <ns>0</ns>
    <id>3138</id>
    <revision>
      <id>63028</id>
      <parentid>59333</parentid>
      <timestamp>2013-07-01T23:51:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1299">{{cpp/title|is_enum}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_enum;
}}
{{dcl end}}

Checks whether {{tt|T}} is an enumeration type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is an enumeration type . Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is an enumeration type }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

enum E {};

enum class Ec : int {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_enum&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_enum&lt;E&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_enum&lt;Ec&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_enum&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_void}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc end}}

[[de:cpp/types/is enum]]
[[es:cpp/types/is enum]]
[[fr:cpp/types/is enum]]
[[it:cpp/types/is enum]]
[[ja:cpp/types/is enum]]
[[pt:cpp/types/is enum]]
[[ru:cpp/types/is enum]]
[[zh:cpp/types/is enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is final</title>
    <ns>0</ns>
    <id>13174</id>
    <revision>
      <id>67912</id>
      <timestamp>2014-03-05T17:25:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1031">{{cpp/title|is_final}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
struct is_final;
}}
{{dcl end}}

If {{tt|T}} is a final class (that is, a class declared with the [[cpp/language/final|final specifier]]), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a final class type }}

===Notes===
Final classes cannot be used as base classes.

A [[cpp/language/union|union]] can be marked {{tt|final}} (and {{tt|std::is_final}} will detect that), even though unions cannot be used as bases in any case.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_polymorphic}}
{{dsc end}}

[[de:cpp/types/is final]]
[[es:cpp/types/is final]]
[[fr:cpp/types/is final]]
[[it:cpp/types/is final]]
[[ja:cpp/types/is final]]
[[pt:cpp/types/is final]]
[[ru:cpp/types/is final]]
[[zh:cpp/types/is final]]</text>
      <sha1>mqvrm0xcbbq8fwq8nkumoyu3gig51zj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is floating point</title>
    <ns>0</ns>
    <id>3166</id>
    <revision>
      <id>68218</id>
      <parentid>63029</parentid>
      <timestamp>2014-03-18T17:49:25Z</timestamp>
      <contributor>
        <ip>134.130.191.100</ip>
      </contributor>
      <text xml:space="preserve" bytes="1922">{{cpp/title|is_floating_point}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_floating_point;
}}
{{dcl end}}

Checks whether {{tt|T}} is a floating-point type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is the type {{c|float}}, {{c|double}}, {{c|long double}}, including any cv-qualified variants. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a floating-point type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_floating_point : std::integral_constant&lt;
                               bool,
                               std::is_same&lt;float, typename std::remove_cv&lt;T&gt;::type&gt;::value  {{!!}}
                               std::is_same&lt;double, typename std::remove_cv&lt;T&gt;::type&gt;::value  {{!!}}
                               std::is_same&lt;long double, typename std::remove_cv&lt;T&gt;::type&gt;::value
                           &gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_floating_point&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_floating_point&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_floating_point&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_iec559}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc end}}

[[de:cpp/types/is floating point]]
[[es:cpp/types/is floating point]]
[[fr:cpp/types/is floating point]]
[[it:cpp/types/is floating point]]
[[ja:cpp/types/is floating point]]
[[pt:cpp/types/is floating point]]
[[ru:cpp/types/is floating point]]
[[zh:cpp/types/is floating point]]</text>
      <sha1>ov3fje4d7usrlwz2uqbk64ofuxj49qx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is function</title>
    <ns>0</ns>
    <id>3141</id>
    <revision>
      <id>72461</id>
      <parentid>65699</parentid>
      <timestamp>2014-08-23T11:31:32Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Possible implementation */ + function types with cv-qualifiers and ref-qualifiers</comment>
      <text xml:space="preserve" bytes="4063">{{cpp/title|is_function}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_function;
}}
{{dcl end}}

Checks whether {{tt|T}} is a function type (not {{lc|std::function}}). Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a function type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a function type }}

===Possible implementation===
{{eq fun
 | 1=
// primary template
template&lt;class&gt;
struct is_function : std::false_type { };

// specialization for regular functions
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)&gt; : std::true_type {};

// specialization for variadic functions such as std::printf
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)&gt; : std::true_type {};

// specialization for function types that have cv-qualifiers
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)volatile&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const volatile&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)volatile&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const volatile&gt; : std::true_type {};

// specialization for function types that have ref-qualifiers
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...) &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)volatile &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const volatile &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......) &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)volatile &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const volatile &amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...) &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)volatile &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args...)const volatile &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......) &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)volatile &amp;&amp;&gt; : std::true_type {};
template&lt;class Ret, class... Args&gt;
struct is_function&lt;Ret(Args......)const volatile &amp;&amp;&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {};

int f()
{
    return 1;
}

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_function&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_function&lt;int(int)&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_function&lt;decltype(f)&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_function&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc end}}

[[de:cpp/types/is function]]
[[es:cpp/types/is function]]
[[fr:cpp/types/is function]]
[[it:cpp/types/is function]]
[[ja:cpp/types/is function]]
[[pt:cpp/types/is function]]
[[ru:cpp/types/is function]]
[[zh:cpp/types/is function]]</text>
      <sha1>tcjo3moldrp9mt93hyv0wik67f6s4d3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is fundamental</title>
    <ns>0</ns>
    <id>3174</id>
    <revision>
      <id>63031</id>
      <parentid>59338</parentid>
      <timestamp>2013-07-01T23:51:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1778">{{cpp/title|is_fundamental}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_fundamental;
}}
{{dcl end}}

If {{tt|T}} is a fundamental type (that is, arithmetic type, {{c|void}}, or {{c|nullptr_t}}), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a fundamental type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T&gt;
struct is_fundamental
  : std::integral_constant&lt;
        bool,
        std::is_arithmetic&lt;T&gt;::value {{!!}}
        std::is_void&lt;T&gt;::value  {{!!}}
        std::is_same&lt;std::nullptr_t, typename std::remove_cv&lt;T&gt;::type&gt;::value
&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_fundamental&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;int*&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;float&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_fundamental&lt;float*&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_compound}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc inc | cpp/types/dsc is_void}}
{{dsc end}}

[[de:cpp/types/is fundamental]]
[[es:cpp/types/is fundamental]]
[[fr:cpp/types/is fundamental]]
[[it:cpp/types/is fundamental]]
[[ja:cpp/types/is fundamental]]
[[pt:cpp/types/is fundamental]]
[[ru:cpp/types/is fundamental]]
[[zh:cpp/types/is fundamental]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is integral</title>
    <ns>0</ns>
    <id>3165</id>
    <revision>
      <id>65568</id>
      <parentid>63032</parentid>
      <timestamp>2013-09-20T15:44:35Z</timestamp>
      <contributor>
        <ip>87.149.190.171</ip>
      </contributor>
      <comment>There can be more integral types that the standard ones.</comment>
      <text xml:space="preserve" bytes="1506">{{cpp/title|is_integral}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_integral;
}}
{{dcl end}}

Checks whether {{tt|T}} is an integral type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is the type {{c|bool}}, {{c|char}}, {{c|char16_t}}, {{c|char32_t}}, {{c|wchar_t}}, {{c|short}}, {{c|int}}, {{c|long}}, {{c|long long}}, or any implementation-defined extended integer types, including any signed, unsigned, and cv-qualified variants. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is an integral type }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_integral&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_integral&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_integral&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
false
false
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc end}}

[[de:cpp/types/is integral]]
[[es:cpp/types/is integral]]
[[fr:cpp/types/is integral]]
[[it:cpp/types/is integral]]
[[ja:cpp/types/is integral]]
[[pt:cpp/types/is integral]]
[[ru:cpp/types/is integral]]
[[zh:cpp/types/is integral]]</text>
      <sha1>rfk0e3b025dom98yrlv534k0slbcgw3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is literal type</title>
    <ns>0</ns>
    <id>3184</id>
    <revision>
      <id>71474</id>
      <parentid>71472</parentid>
      <timestamp>2014-06-11T14:45:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>actually, this is a worse-quality duplicate of what's in cpp/concepts, so just link to that</comment>
      <text xml:space="preserve" bytes="1200">{{cpp/title|is_literal_type}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_literal_type;
}}
{{dcl end}}

If {{tt|T}} satisfies all requirements of {{concept|LiteralType}}, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit |{{tt|T}} is a literal type}}

===Notes===
Only literal types may be used as parameters to or returned from [[cpp/language/constexpr|constexpr functions]]. Only literal classes may have constexpr member functions.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    virtual ~B();
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_literal_type&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_literal_type&lt;B&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
}}

[[de:cpp/types/is literal type]]
[[es:cpp/types/is literal type]]
[[fr:cpp/types/is literal type]]
[[it:cpp/types/is literal type]]
[[ja:cpp/types/is literal type]]
[[pt:cpp/types/is literal type]]
[[ru:cpp/types/is literal type]]
[[zh:cpp/types/is literal type]]</text>
      <sha1>p6kt0lnylp2bzt9bw50ab14kj64hh7d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is lvalue reference</title>
    <ns>0</ns>
    <id>3168</id>
    <revision>
      <id>63034</id>
      <parentid>59342</parentid>
      <timestamp>2013-07-01T23:51:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1747">{{cpp/title|is_lvalue_reference}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_lvalue_reference;
}}
{{dcl end}}

Checks whether {{tt|T}} is a lvalue reference type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a lvalue reference type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is an lvalue reference type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; struct is_lvalue_reference     : std::false_type {};
template&lt;class T&gt; struct is_lvalue_reference&lt;T&amp;&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_lvalue_reference&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_lvalue_reference&lt;A&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_lvalue_reference&lt;A&amp;&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_lvalue_reference&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_lvalue_reference&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_lvalue_reference&lt;int&amp;&amp;&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc inc | cpp/types/dsc is_rvalue_reference}}
{{dsc end}}

[[de:cpp/types/is lvalue reference]]
[[es:cpp/types/is lvalue reference]]
[[fr:cpp/types/is lvalue reference]]
[[it:cpp/types/is lvalue reference]]
[[ja:cpp/types/is lvalue reference]]
[[pt:cpp/types/is lvalue reference]]
[[ru:cpp/types/is lvalue reference]]
[[zh:cpp/types/is lvalue reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is member function pointer</title>
    <ns>0</ns>
    <id>3172</id>
    <revision>
      <id>72324</id>
      <parentid>63035</parentid>
      <timestamp>2014-08-08T22:23:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix example: that static assert could never fire for the reason stated in the comment</comment>
      <text xml:space="preserve" bytes="1919">{{cpp/title|is_member_function_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_member_function_pointer;
}}
{{dcl end}}

Checks whether {{tt|T}} is a non-static member function pointer. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a non-static member function pointer type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a member function pointer type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_member_function_pointer_helper : std::false_type {};

template&lt; class T, class U&gt;
struct is_member_function_pointer_helper&lt;T U::*&gt; : std::is_function&lt;T&gt; {};

template&lt; class T &gt;
struct is_member_function_pointer : is_member_function_pointer_helper&lt;
                                        typename std::remove_cv&lt;T&gt;::type
                                    &gt; {};
}}

===Example===
{{example
 | code=
#include &lt;type_traits&gt;

class A {
    void member() { }
};

int main()
{
    // fails at compile time if A::member is a data member and not a function
    static_assert(std::is_member_function_pointer&lt;decltype(&amp;A::member)&gt;::value,
                  &quot;A::member is not a member function.&quot;); 
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_member_object_pointer}}
{{dsc inc | cpp/types/dsc is_member_pointer}}
{{dsc end}}

[[de:cpp/types/is member function pointer]]
[[es:cpp/types/is member function pointer]]
[[fr:cpp/types/is member function pointer]]
[[it:cpp/types/is member function pointer]]
[[ja:cpp/types/is member function pointer]]
[[pt:cpp/types/is member function pointer]]
[[ru:cpp/types/is member function pointer]]
[[zh:cpp/types/is member function pointer]]</text>
      <sha1>fthligk3y9mklpmy4lqaqro7on7pe7h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is member object pointer</title>
    <ns>0</ns>
    <id>3171</id>
    <revision>
      <id>63036</id>
      <parentid>59346</parentid>
      <timestamp>2013-07-01T23:51:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2051">{{cpp/title|is_member_object_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_member_object_pointer;
}}
{{dcl end}}

Checks whether {{tt|T}} is a non-static member object. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a non-static member object type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a pointer to member object }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct is_member_object_pointer : std::integral_constant&lt;
                                      bool,
                                      std::is_member_pointer&lt;T&gt;::value &amp;&amp;
                                      !std::is_member_function_pointer&lt;T&gt;::value
                                  &gt; {};
}}

===Example===
{{todo|simplify}}
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    class cls {};
    std::cout &lt;&lt; (std::is_member_object_pointer&lt;int(cls::*)&gt;::value
                     ? &quot;T is member object pointer&quot;
                     : &quot;T is not a member object pointer&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; (std::is_member_object_pointer&lt;int(cls::*)()&gt;::value
                     ? &quot;T is member object pointer&quot;
                     : &quot;T is not a member object pointer&quot;) &lt;&lt; '\n';
}

 | output=
T is member object pointer
T is not a member object pointer
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_member_pointer}}
{{dsc inc | cpp/types/dsc is_member_function_pointer}}
{{dsc end}}

[[de:cpp/types/is member object pointer]]
[[es:cpp/types/is member object pointer]]
[[fr:cpp/types/is member object pointer]]
[[it:cpp/types/is member object pointer]]
[[ja:cpp/types/is member object pointer]]
[[pt:cpp/types/is member object pointer]]
[[ru:cpp/types/is member object pointer]]
[[zh:cpp/types/is member object pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is member pointer</title>
    <ns>0</ns>
    <id>3170</id>
    <revision>
      <id>63037</id>
      <parentid>59349</parentid>
      <timestamp>2013-07-01T23:51:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1787">{{cpp/title|is_member_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_member_pointer;
}}
{{dcl end}}

If {{tt|T}} is pointer to non-static member object or a pointer to non-static member function, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a member pointer type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_member_pointer_helper         : std::false_type {};

template&lt; class T, class U &gt;
struct is_member_pointer_helper&lt;T U::*&gt; : std::true_type {};

template&lt; class T &gt;
struct is_member_pointer : 
    is_member_pointer_helper&lt;typename std::remove_cv&lt;T&gt;::type&gt; {};
}}

===Example===
{{todo|simplify}}
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    class cls {};
    std::cout &lt;&lt; (std::is_member_pointer&lt;int(cls::*)&gt;::value
                     ? &quot;T is member pointer&quot;
                     : &quot;T is not a member pointer&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; (std::is_member_pointer&lt;int&gt;::value
                     ? &quot;T is member pointer&quot;
                     : &quot;T is not a member pointer&quot;) &lt;&lt; '\n';
}
 | output=
T is member pointer
T is not a member pointer
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_member_object_pointer}}
{{dsc inc | cpp/types/dsc is_member_function_pointer}}
{{dsc end}}

[[de:cpp/types/is member pointer]]
[[es:cpp/types/is member pointer]]
[[fr:cpp/types/is member pointer]]
[[it:cpp/types/is member pointer]]
[[ja:cpp/types/is member pointer]]
[[pt:cpp/types/is member pointer]]
[[ru:cpp/types/is member pointer]]
[[zh:cpp/types/is member pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is move assignable</title>
    <ns>0</ns>
    <id>3273</id>
    <revision>
      <id>63038</id>
      <parentid>59350</parentid>
      <timestamp>2013-07-01T23:51:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2756">{{cpp/title|is_move_assignable|is_trivially_move_assignable|is_nothrow_move_assignable}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_move_assignable;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_move_assignable;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_move_assignable;
}}
{{dcl end}}

1) Checks whether a type is {{concept|MoveAssignable}}, i.e. has an accessible explicit or implicit move assignment operator. If the requirement is met, a member constant {{tt|value}} equal {{c|true}} is provided, otherwise {{tt|value}} is {{c|false}}.

2) same as 1), but evaluation of the move-assignment expression will not call any operation that is not trivial.

3) same as 1), but the evaluation of the move-assignment expression will not call any operation that is not noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is move-assignable}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T&gt;
struct is_move_assignable
    : std::is_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                          typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};

template&lt; class T&gt;
struct is_trivially_move_assignable
    : std::is_trivially_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                                    typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};

template&lt; class T&gt;
struct is_nothrow_move_assignable
    : std::is_nothrow_assignable&lt; typename std::add_lvalue_reference&lt;T&gt;::type,
                                  typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;type_traits&gt;
struct Foo { int n; };
int main() {
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;std::string is nothrow move-assignable? &quot;
              &lt;&lt; std::is_nothrow_move_assignable&lt;std::string&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;int[2] is move-assignable? &quot;
              &lt;&lt; std::is_move_assignable&lt;int[2]&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Foo is trivally move-assignable? &quot;
              &lt;&lt; std::is_trivially_move_assignable&lt;Foo&gt;::value &lt;&lt; '\n';
}
 | output=
std::string is nothrow move-assignable? true
int[2] is move-assignable? false
Foo is trivially move-assignable? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_assignable}}
{{dsc inc | cpp/types/dsc is_copy_assignable}}
{{dsc end}}

[[de:cpp/types/is move assignable]]
[[es:cpp/types/is move assignable]]
[[fr:cpp/types/is move assignable]]
[[it:cpp/types/is move assignable]]
[[ja:cpp/types/is move assignable]]
[[pt:cpp/types/is move assignable]]
[[ru:cpp/types/is move assignable]]
[[zh:cpp/types/is move assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is move constructible</title>
    <ns>0</ns>
    <id>3258</id>
    <revision>
      <id>66738</id>
      <parentid>66736</parentid>
      <timestamp>2013-12-28T19:34:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/xvalue/rvalue</comment>
      <text xml:space="preserve" bytes="3399">{{cpp/title|is_move_constructible|is_trivially_move_constructible|is_nothrow_move_constructible}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct is_move_constructible;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct is_trivially_move_constructible;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct is_nothrow_move_constructible;
}}
{{dcl end}}

1) Checks whether a type is {{concept|MoveConstructible}}, that is, can be constructed from [[cpp/language/value_category|rvalue]] argument. If the requirement is met, a member constant {{tt|value}} equal to {{c|true}} is provided; otherwise the {{tt|value}} is {{c|false}}.

2) Same as 1), but the move constructor expression does not call any operation that is not trivial.

3) Same as 1), but the move constructor expression is noexcept.

{{cpp/types/integral_constant/inherit | {{tt|T}} is move-constructible }}

===Notes===
Types without a move constructor, but with a copy constructor that accepts {{tt|const T&amp;}} arguments, satisfy {{tt|std::is_move_constructible}}.

Move constructors are usually noexcept, since otherwise they are unusable in any code that provides strong exception guarantee.

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct is_move_constructible :
      std::is_constructible&lt;T, typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};

template&lt;class T&gt;
struct is_trivially_move_constructible :
     std::is_trivially_constructible&lt;T, typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};

template&lt;class T&gt;
struct is_nothrow_move_constructible :
     std::is_nothrow_constructible&lt;T, typename std::add_rvalue_reference&lt;T&gt;::type&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct Ex1 {
    std::string str; // member has a non-trivial but non-throwing move ctor
};
struct Ex2 {
    int n;
    Ex2(Ex2&amp;&amp;) = default; // trivial and non-throwing
};

int main() {
    std::cout &lt;&lt; std::boolalpha &lt;&lt; &quot;Ex1 is move-constructible? &quot;
              &lt;&lt; std::is_move_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex1 is trivially move-constructible? &quot;
              &lt;&lt; std::is_trivially_move_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex1 is nothrow move-constructible? &quot;
              &lt;&lt; std::is_nothrow_move_constructible&lt;Ex1&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is trivially move-constructible? &quot;
              &lt;&lt; std::is_trivially_move_constructible&lt;Ex2&gt;::value &lt;&lt; '\n'
              &lt;&lt; &quot;Ex2 is nothrow move-constructible? &quot;
              &lt;&lt; std::is_nothrow_move_constructible&lt;Ex2&gt;::value &lt;&lt; '\n';
}
 | output=
Ex1 is move-constructible? true
Ex1 is trivially move-constructible? false
Ex1 is nothrow move-constructible? true
Ex2 is trivially move-constructible? true
Ex2 is nothrow move-constructible? true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_constructible}}
{{dsc inc | cpp/types/dsc is_default_constructible}}
{{dsc inc | cpp/types/dsc is_copy_constructible}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc end}}

[[de:cpp/types/is move constructible]]
[[es:cpp/types/is move constructible]]
[[fr:cpp/types/is move constructible]]
[[it:cpp/types/is move constructible]]
[[ja:cpp/types/is move constructible]]
[[pt:cpp/types/is move constructible]]
[[ru:cpp/types/is move constructible]]
[[zh:cpp/types/is move constructible]]</text>
      <sha1>1n8dwbmvzhdw31iw3a7w7gh0oba10ky</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow assignable</title>
    <ns>0</ns>
    <id>4236</id>
    <redirect title="cpp/types/is assignable" />
    <revision>
      <id>15335</id>
      <timestamp>2011-12-08T15:29:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is assignable]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/types/is_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow constructible</title>
    <ns>0</ns>
    <id>4224</id>
    <redirect title="cpp/types/is constructible" />
    <revision>
      <id>15323</id>
      <timestamp>2011-12-08T15:26:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is constructible]]</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/types/is_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow copy assignable</title>
    <ns>0</ns>
    <id>4233</id>
    <redirect title="cpp/types/is copy assignable" />
    <revision>
      <id>15332</id>
      <timestamp>2011-12-08T15:29:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is copy assignable]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/types/is_copy_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow copy constructible</title>
    <ns>0</ns>
    <id>4228</id>
    <redirect title="cpp/types/is copy constructible" />
    <revision>
      <id>15327</id>
      <timestamp>2011-12-08T15:28:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is copy constructible]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/types/is_copy_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow default constructible</title>
    <ns>0</ns>
    <id>4226</id>
    <redirect title="cpp/types/is default constructible" />
    <revision>
      <id>15325</id>
      <timestamp>2011-12-08T15:27:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is default constructible]]</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/types/is_default_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow destructible</title>
    <ns>0</ns>
    <id>4238</id>
    <redirect title="cpp/types/is destructible" />
    <revision>
      <id>15337</id>
      <timestamp>2011-12-08T15:31:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is destructible]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/types/is_destructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow move assignable</title>
    <ns>0</ns>
    <id>4232</id>
    <redirect title="cpp/types/is move assignable" />
    <revision>
      <id>15331</id>
      <timestamp>2011-12-08T15:28:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is move assignable]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/types/is_move_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is nothrow move constructible</title>
    <ns>0</ns>
    <id>4229</id>
    <redirect title="cpp/types/is move constructible" />
    <revision>
      <id>15328</id>
      <timestamp>2011-12-08T15:28:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is move constructible]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/types/is_move_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is null pointer</title>
    <ns>0</ns>
    <id>13044</id>
    <revision>
      <id>66209</id>
      <timestamp>2013-11-09T22:57:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1842">{{cpp/title|is_null_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
struct is_null_pointer;
}}
{{dcl end}}

Checks whether {{tt|T}} is the type {{lc|std::nullptr_t}}.

Provides the member constant {{tt|value}} that is equal to {{c|true}}, if {{tt|T}} is the type {{c|std::nullptr_t}}, {{c|const std::nullptr_t}}, {{c|volatile std::nullptr_t}}, or {{c|const volatile std::nullptr_t}}.

Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is the type {{lc|std::nullptr_t}} (possibly cv-qualified) }}

===Notes===
{{lc|std::is_pointer}} is {{c|false}} for {{lc|std::nullptr_t}} because it is not a built-in pointer type.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main()
{
    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; std::is_null_pointer&lt; decltype(nullptr) &gt;::value &lt;&lt; ' '
              &lt;&lt; std::is_null_pointer&lt; int* &gt;::value &lt;&lt; '\n'
              &lt;&lt; std::is_pointer&lt; decltype(nullptr) &gt;::value &lt;&lt; ' '
              &lt;&lt; std::is_pointer&lt;int*&gt;::value &lt;&lt; '\n';
}
| output=
true false
false true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_void}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_enum}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_function}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc end}}

[[de:cpp/types/is null pointer]]
[[es:cpp/types/is null pointer]]
[[fr:cpp/types/is null pointer]]
[[it:cpp/types/is null pointer]]
[[ja:cpp/types/is null pointer]]
[[pt:cpp/types/is null pointer]]
[[ru:cpp/types/is null pointer]]
[[zh:cpp/types/is null pointer]]</text>
      <sha1>8qevx0ab4avpouspveznc05rlthqby6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is object</title>
    <ns>0</ns>
    <id>3142</id>
    <revision>
      <id>63040</id>
      <parentid>59354</parentid>
      <timestamp>2013-07-01T23:51:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1546">{{cpp/title|is_object}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_object;
}}
{{dcl end}}

If {{tt|T}} is an object type (that is, scalar, array, class, or union), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an object type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T&gt;
struct is_object : std::integral_constant&lt;bool,
                     std::is_scalar&lt;T&gt;::value {{!!}}
                     std::is_array&lt;T&gt;::value  {{!!}}
                     std::is_union&lt;T&gt;::value  {{!!}}
                     std::is_class&lt;T&gt;::value&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    class cls {};
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_object&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_object&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_object&lt;cls&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_object&lt;cls&amp;&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc end}}

[[de:cpp/types/is object]]
[[es:cpp/types/is object]]
[[fr:cpp/types/is object]]
[[it:cpp/types/is object]]
[[ja:cpp/types/is object]]
[[pt:cpp/types/is object]]
[[ru:cpp/types/is object]]
[[zh:cpp/types/is object]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is pod</title>
    <ns>0</ns>
    <id>3178</id>
    <revision>
      <id>63041</id>
      <parentid>59357</parentid>
      <timestamp>2013-07-01T23:51:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1268">{{cpp/title|is_pod}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_pod;
}}
{{dcl end}}

If {{tt|T}} is a {{concept|PODType}} (&quot;plain old data type&quot;), that is, both trivial and standard-layout, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a POD type }}

===Notes===
Objects of POD types are fully compatible with the C programming language.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    int m1;
private:
    int m2;
};

struct C {
    virtual void foo();
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_pod&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pod&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pod&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_standard_layout}}
{{dsc inc | cpp/types/dsc is_trivial}}
{{dsc end}}

[[de:cpp/types/is pod]]
[[es:cpp/types/is pod]]
[[fr:cpp/types/is pod]]
[[it:cpp/types/is pod]]
[[ja:cpp/types/is pod]]
[[pt:cpp/types/is pod]]
[[ru:cpp/types/is pod]]
[[zh:cpp/types/is pod]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is pointer</title>
    <ns>0</ns>
    <id>3137</id>
    <revision>
      <id>72261</id>
      <parentid>66718</parentid>
      <timestamp>2014-08-01T12:36:27Z</timestamp>
      <contributor>
        <username>Kwi</username>
        <id>3285</id>
      </contributor>
      <comment>This is a teaching moment: References are not pointers. Arrays are not pointers. ;)</comment>
      <text xml:space="preserve" bytes="1947">{{cpp/title|is_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_pointer;
}}
{{dcl end}}

Checks whether {{tt|T}} is a pointer to object or a pointer to function (not a pointer to a non-static member object or to a data member). Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a object pointer type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a pointer type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt; struct is_pointer_helper     : std::false_type {};
template&lt; class T &gt; struct is_pointer_helper&lt;T*&gt; : std::true_type {};
template&lt; class T &gt; struct is_pointer : is_pointer_helper&lt;typename std::remove_cv&lt;T&gt;::type&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::is_pointer&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;A *&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;A &amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;int *&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;int **&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_pointer&lt;int[10]&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
true
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_member_pointer}}
{{dsc inc | cpp/types/dsc is_member_object_pointer}}
{{dsc inc | cpp/types/dsc is_member_function_pointer}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc end}}

[[de:cpp/types/is pointer]]
[[es:cpp/types/is pointer]]
[[fr:cpp/types/is pointer]]
[[it:cpp/types/is pointer]]
[[ja:cpp/types/is pointer]]
[[pt:cpp/types/is pointer]]
[[ru:cpp/types/is pointer]]
[[zh:cpp/types/is pointer]]</text>
      <sha1>p2zffp6r41rwa7wt23iu7xe2edw6bkt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is polymorphic</title>
    <ns>0</ns>
    <id>3180</id>
    <revision>
      <id>68723</id>
      <parentid>63043</parentid>
      <timestamp>2014-03-20T02:56:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to fuller explanation in cpp/language</comment>
      <text xml:space="preserve" bytes="1362">{{cpp/title|is_polymorphic}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_polymorphic;
}}
{{dcl end}}

If {{tt|T}} is a [[cpp/language/object#Polymorphic objects|polymorphic class]] (that is, a non-union class that declares or inherits at least one virtual function), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a [[cpp/language/object#Polymorphic objects|polymorphic]] class type }}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    virtual void foo();
};

struct C : B {};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_polymorphic&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_polymorphic&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_polymorphic&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_abstract}}
{{dsc end}}

[[de:cpp/types/is polymorphic]]
[[es:cpp/types/is polymorphic]]
[[fr:cpp/types/is polymorphic]]
[[it:cpp/types/is polymorphic]]
[[ja:cpp/types/is polymorphic]]
[[pt:cpp/types/is polymorphic]]
[[ru:cpp/types/is polymorphic]]
[[zh:cpp/types/is polymorphic]]</text>
      <sha1>inlb1atm3klh2nrbvqxumovy4y6g6uy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is reference</title>
    <ns>0</ns>
    <id>3167</id>
    <revision>
      <id>63044</id>
      <parentid>59362</parentid>
      <timestamp>2013-07-01T23:52:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1572">{{cpp/title|is_reference}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_reference;
}}
{{dcl end}}

If {{tt|T}} is a reference type (lvalue reference or rvalue reference), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a reference type }}

===Possible implementation===
{{eq fun
 | 1=
template &lt;class T&gt; struct is_reference      : std::false_type {};
template &lt;class T&gt; struct is_reference&lt;T&amp;&gt;  : std::true_type {};
template &lt;class T&gt; struct is_reference&lt;T&amp;&amp;&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_reference&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_reference&lt;A&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_reference&lt;A&amp;&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_reference&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_reference&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_reference&lt;int&amp;&amp;&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
false
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_lvalue_reference}}
{{dsc inc | cpp/types/dsc is_rvalue_reference}}
{{dsc end}}

[[de:cpp/types/is reference]]
[[es:cpp/types/is reference]]
[[fr:cpp/types/is reference]]
[[it:cpp/types/is reference]]
[[ja:cpp/types/is reference]]
[[pt:cpp/types/is reference]]
[[ru:cpp/types/is reference]]
[[zh:cpp/types/is reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is rvalue reference</title>
    <ns>0</ns>
    <id>3169</id>
    <revision>
      <id>63045</id>
      <parentid>59365</parentid>
      <timestamp>2013-07-01T23:52:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1751">{{cpp/title|is_rvalue_reference}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_rvalue_reference;
}}
{{dcl end}}

Checks whether {{tt|T}} is a rvalue reference type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is a rvalue reference type. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is an rvalue reference type }}

===Possible implementation===
{{eq fun
 | 1=
template &lt;class T&gt; struct is_rvalue_reference      : std::false_type {};
template &lt;class T&gt; struct is_rvalue_reference&lt;T&amp;&amp;&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_rvalue_reference&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_rvalue_reference&lt;A&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_rvalue_reference&lt;A&amp;&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_rvalue_reference&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_rvalue_reference&lt;int&amp;&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_rvalue_reference&lt;int&amp;&amp;&gt;::value &lt;&lt; '\n';
}
 | output=
false
false
true
false
false
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_lvalue_reference}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc end}}

[[de:cpp/types/is rvalue reference]]
[[es:cpp/types/is rvalue reference]]
[[fr:cpp/types/is rvalue reference]]
[[it:cpp/types/is rvalue reference]]
[[ja:cpp/types/is rvalue reference]]
[[pt:cpp/types/is rvalue reference]]
[[ru:cpp/types/is rvalue reference]]
[[zh:cpp/types/is rvalue reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is same</title>
    <ns>0</ns>
    <id>2729</id>
    <revision>
      <id>64908</id>
      <parentid>64907</parentid>
      <timestamp>2013-08-27T06:44:13Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <comment>+ refs</comment>
      <text xml:space="preserve" bytes="2045">{{cpp/title|is_same}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T, class U &gt;
struct is_same;
}}
{{dcl end}}

If {{tt|T}} and {{tt|U}} name the same type with the same const-volatile qualifications, provides the member constant {{tt|value}} equal to {{c|true}}. Otherwise {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} and {{tt|U}} is the same type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T, class U&gt;
struct is_same : std::false_type {};

template&lt;class T&gt;
struct is_same&lt;T, T&gt; : std::true_type {};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;cstdint&gt;

void print_separator()
{
    std::cout &lt;&lt; &quot;-----\n&quot;;
}

int main()
{
    std::cout &lt;&lt; std::boolalpha;

    std::cout &lt;&lt; std::is_same&lt;int, int32_t&gt;::value &lt;&lt; '\n';   // true
    std::cout &lt;&lt; std::is_same&lt;int, int64_t&gt;::value &lt;&lt; '\n';   // false
    std::cout &lt;&lt; std::is_same&lt;float, int32_t&gt;::value &lt;&lt; '\n'; // false

    print_separator();

    std::cout &lt;&lt; std::is_same&lt;int, int&gt;::value &lt;&lt; &quot;\n&quot;;          // true
    std::cout &lt;&lt; std::is_same&lt;int, unsigned int&gt;::value &lt;&lt; &quot;\n&quot;; // false
    std::cout &lt;&lt; std::is_same&lt;int, signed int&gt;::value &lt;&lt; &quot;\n&quot;;   // true

    print_separator();

    // unlike other types 'char' is not 'unsigned' and not 'signed'
    std::cout &lt;&lt; std::is_same&lt;char, char&gt;::value &lt;&lt; &quot;\n&quot;;          // true
    std::cout &lt;&lt; std::is_same&lt;char, unsigned char&gt;::value &lt;&lt; &quot;\n&quot;; // false
    std::cout &lt;&lt; std::is_same&lt;char, signed char&gt;::value &lt;&lt; &quot;\n&quot;;   // false
}
 | output=
true
false
false
-----
true
false
true
-----
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_integral }}
{{dsc inc | cpp/types/dsc make_signed }}
{{dsc inc | cpp/types/dsc make_unsigned }}
{{dsc end}}

[[de:cpp/types/is same]]
[[es:cpp/types/is same]]
[[fr:cpp/types/is same]]
[[it:cpp/types/is same]]
[[ja:cpp/types/is same]]
[[pt:cpp/types/is same]]
[[ru:cpp/types/is same]]
[[zh:cpp/types/is same]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is scalar</title>
    <ns>0</ns>
    <id>3143</id>
    <revision>
      <id>63047</id>
      <parentid>59366</parentid>
      <timestamp>2013-07-01T23:52:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2218">{{cpp/title|is_scalar}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_scalar;
}}
{{dcl end}}

If {{tt|T}} is a scalar type (that is, arithmetic type, enumeration type, pointer, pointer to member, or {{lc|std::nullptr_t}}, including any cv-qualified variants), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a scalar type }}

===Notes===
Each individual memory location in the C++ memory model, including the hidden memory locations used by language features (e.g virtual table pointer), has scalar type (or is a sequence of adjacent bit-fields of non-zero length). Sequencing of side-effects in expression evaluation, interthread synchronization, and dependency ordering are all defined in terms of individual scalar objects.

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_scalar : std::integral_constant&lt;bool,
                     std::is_arithmetic&lt;T&gt;::value     {{!!}}
                     std::is_enum&lt;T&gt;::value           {{!!}}
                     std::is_pointer&lt;T&gt;::value        {{!!}}
                     std::is_member_pointer&lt;T&gt;::value {{!!}}
                     std::is_same&lt;std::nullptr_t, typename std::remove_cv&lt;T&gt;::type&gt;::value&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    class cls {};
    std::cout &lt;&lt; (std::is_scalar&lt;int&gt;::value
                     ? &quot;T is scalar&quot;
                     : &quot;T is not a scalar&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; (std::is_scalar&lt;cls&gt;::value
                     ? &quot;T is scalar&quot;
                     : &quot;T is not a scalar&quot;) &lt;&lt; '\n';
}

 | output=
T is scalar
T is not a scalar
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_arithmetic}}
{{dsc inc | cpp/types/dsc is_enum}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_member_pointer}}
{{dsc end}}

[[de:cpp/types/is scalar]]
[[es:cpp/types/is scalar]]
[[fr:cpp/types/is scalar]]
[[it:cpp/types/is scalar]]
[[ja:cpp/types/is scalar]]
[[pt:cpp/types/is scalar]]
[[ru:cpp/types/is scalar]]
[[zh:cpp/types/is scalar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is signed</title>
    <ns>0</ns>
    <id>3185</id>
    <revision>
      <id>63048</id>
      <parentid>59369</parentid>
      <timestamp>2013-07-01T23:52:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1475">{{cpp/title|is_signed}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_signed;
}}
{{dcl end}}

If {{tt|T}} is a signed arithmetic type, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a signed arithmetic type }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};
enum B : int {};
enum class C : int {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_signed&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_signed&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_signed&lt;signed int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_signed&lt;unsigned int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_signed&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_signed&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
true
false
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_unsigned}}
{{dsc inc | cpp/types/numeric_limits/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc make_signed}}
{{dsc inc | cpp/types/dsc make_unsigned}}
{{dsc end}}

[[de:cpp/types/is signed]]
[[es:cpp/types/is signed]]
[[fr:cpp/types/is signed]]
[[it:cpp/types/is signed]]
[[ja:cpp/types/is signed]]
[[pt:cpp/types/is signed]]
[[ru:cpp/types/is signed]]
[[zh:cpp/types/is signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is standard layout</title>
    <ns>0</ns>
    <id>3183</id>
    <revision>
      <id>71669</id>
      <parentid>63049</parentid>
      <timestamp>2014-06-19T02:32:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to concept</comment>
      <text xml:space="preserve" bytes="2364">{{cpp/title|is_standard_layout}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_standard_layout;
}}
{{dcl end}}

If {{tt|T}} is a standard layout type (that is, a scalar type, a standard-layout class, or an array of such type/class, possibly cv-qualified), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

A [[cpp/language/data_members|standard-layout class]] is a class that satisfies {{concept|StandardLayoutType}}, that is

1. has no non-static data members that aren't standard-layout

2. has no virtual functions and no virtual base classes

3. has the same access control for all non-static data members

4. has no base classes that aren't standard-layout

5. either has no base class with non-static data members or has no non-static data members in the most derived class and only one base with them

6. has no base classes of the same type as the first non-static data member

{{cpp/types/integral_constant/inherit | {{tt|T}} is a standard-layout type }}

===Notes===
A pointer to a standard-layout class may be converted (with reinterpret_cast) to a pointer to its first non-static data member and vice versa.

If a standard-layout union holds two or more standard-layout structs, it is permitted to inspect the common initial part of them.

The macro {{lc|offsetof}} can only be used with standard-layout classes.

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    int m1;
private:
    int m2;
};

struct C {
    virtual void foo();
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_standard_layout&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_standard_layout&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_standard_layout&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc inc | cpp/types/dsc is_pod}}
{{dsc inc | cpp/types/dsc offsetof}}
{{dsc end}}

[[de:cpp/types/is standard layout]]
[[es:cpp/types/is standard layout]]
[[fr:cpp/types/is standard layout]]
[[it:cpp/types/is standard layout]]
[[ja:cpp/types/is standard layout]]
[[pt:cpp/types/is standard layout]]
[[ru:cpp/types/is standard layout]]
[[zh:cpp/types/is standard layout]]</text>
      <sha1>ndr2xhtbqk3hsymvkkrwhijesnqhrih</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivial</title>
    <ns>0</ns>
    <id>3182</id>
    <revision>
      <id>72382</id>
      <parentid>72283</parentid>
      <timestamp>2014-08-18T14:09:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link trival type and trivial default ctor</comment>
      <text xml:space="preserve" bytes="1447">{{cpp/title|is_trivial}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_trivial;
}}
{{dcl end}}

If {{tt|T}} is {{concept|TrivialType}} (that is, a scalar type, a trivially copyable class with a [[cpp/language/default_constructor#Trivial_default_constructor|trivial default constructor]], or array of such type/class, possibly cv-qualified), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a trivial type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_trivial : std::integral_constant&lt; 
    bool,
    std::is_trivially_copyable&lt;T&gt;::value &amp;&amp;
    std::is_trivially_default_constructible&lt;T&gt;::value 
&gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    B() {}
};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_trivial&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_trivial&lt;B&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_trivially_copyable}}
{{dsc end}}

[[de:cpp/types/is trivial]]
[[es:cpp/types/is trivial]]
[[fr:cpp/types/is trivial]]
[[it:cpp/types/is trivial]]
[[ja:cpp/types/is trivial]]
[[pt:cpp/types/is trivial]]
[[ru:cpp/types/is trivial]]
[[zh:cpp/types/is trivial]]</text>
      <sha1>b05a4q9ibcd0x3gsrjtlg9b524ajr68</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially assignable</title>
    <ns>0</ns>
    <id>4235</id>
    <redirect title="cpp/types/is assignable" />
    <revision>
      <id>15334</id>
      <timestamp>2011-12-08T15:29:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is assignable]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/types/is_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially constructible</title>
    <ns>0</ns>
    <id>4223</id>
    <redirect title="cpp/types/is constructible" />
    <revision>
      <id>15322</id>
      <timestamp>2011-12-08T15:26:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is constructible]]</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/types/is_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially copy assignable</title>
    <ns>0</ns>
    <id>4234</id>
    <redirect title="cpp/types/is copy assignable" />
    <revision>
      <id>15333</id>
      <timestamp>2011-12-08T15:29:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is copy assignable]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/types/is_copy_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially copy constructible</title>
    <ns>0</ns>
    <id>4227</id>
    <redirect title="cpp/types/is copy constructible" />
    <revision>
      <id>15326</id>
      <timestamp>2011-12-08T15:27:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is copy constructible]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/types/is_copy_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially copyable</title>
    <ns>0</ns>
    <id>3175</id>
    <revision>
      <id>71433</id>
      <parentid>63051</parentid>
      <timestamp>2014-06-11T03:12:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>cwg 496 (volatiles aren't trivial), also link to concept.</comment>
      <text xml:space="preserve" bytes="2198">{{cpp/title|is_trivially_copyable}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_trivially_copyable;
}}
{{dcl end}}

If {{tt|T}} is a {{concept|TriviallyCopyable}} type, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

The only trivially copyable types are scalar types, trivially copyable classes, and arrays of such types/classes (possibly const-qualified, but not volatile-qualified).

A trivially copyable class is a class that

1. Has no non-trivial copy constructors (this also requires no virtual functions or virtual bases)

2. Has no non-trivial move constructors

3. Has no non-trivial copy assignment operators

4. Has no non-trivial move assignment operators

5. Has a trivial destructor

{{cpp/types/integral_constant/inherit | {{tt|T}} is a trivially copyable type }}

===Notes===
Objects of trivially-copyable types are the only C++ objects that may be safely copied with {{lc|std::memcpy}} or serialized to/from binary files with {{l2tt|cpp/io/basic_ostream/write|write()|std::ofstream}}/{{l2tt|cpp/io/basic_istream/read|read()|std::ifstream}}. In general, a trivially copyable type is any type for which the underlying bytes can be copied to an array of char or unsigned char and into a new object of the same type, and the resulting object would have the same value as the original. 

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {
    int m;
};

struct B {
    B(const B&amp;) {}
};

struct C {
    virtual void foo();
};

int main()
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_trivially_copyable&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_trivially_copyable&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_trivially_copyable&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
true
false
false
}}

[[de:cpp/types/is trivially copyable]]
[[es:cpp/types/is trivially copyable]]
[[fr:cpp/types/is trivially copyable]]
[[it:cpp/types/is trivially copyable]]
[[ja:cpp/types/is trivially copyable]]
[[pt:cpp/types/is trivially copyable]]
[[ru:cpp/types/is trivially copyable]]
[[zh:cpp/types/is trivially copyable]]</text>
      <sha1>bezukblxtj8bbtvs9epxiis2t80p8hg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially default constructible</title>
    <ns>0</ns>
    <id>4225</id>
    <redirect title="cpp/types/is default constructible" />
    <revision>
      <id>15324</id>
      <timestamp>2011-12-08T15:27:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is default constructible]]</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/types/is_default_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially destructible</title>
    <ns>0</ns>
    <id>4237</id>
    <redirect title="cpp/types/is destructible" />
    <revision>
      <id>15336</id>
      <timestamp>2011-12-08T15:31:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is destructible]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/types/is_destructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially move assignable</title>
    <ns>0</ns>
    <id>4231</id>
    <redirect title="cpp/types/is move assignable" />
    <revision>
      <id>15330</id>
      <timestamp>2011-12-08T15:28:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is move assignable]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/types/is_move_assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is trivially move constructible</title>
    <ns>0</ns>
    <id>4230</id>
    <redirect title="cpp/types/is move constructible" />
    <revision>
      <id>15329</id>
      <timestamp>2011-12-08T15:28:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/is move constructible]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/types/is_move_constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is union</title>
    <ns>0</ns>
    <id>3139</id>
    <revision>
      <id>63052</id>
      <parentid>59374</parentid>
      <timestamp>2013-07-01T23:52:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1248">{{cpp/title|is_union}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_union;
}}
{{dcl end}}

Checks whether {{tt|T}} is an union type. Provides the member constant {{tt|value}} which is equal to {{c|true}}, if {{tt|T}} is an union type . Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is a union type }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

struct A {};

typedef union {
    int a;
    float b;
} B;

struct C {
    B d;
};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_union&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_union&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_union&lt;C&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_union&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
false
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc end}}

[[de:cpp/types/is union]]
[[es:cpp/types/is union]]
[[fr:cpp/types/is union]]
[[it:cpp/types/is union]]
[[ja:cpp/types/is union]]
[[pt:cpp/types/is union]]
[[ru:cpp/types/is union]]
[[zh:cpp/types/is union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is unsigned</title>
    <ns>0</ns>
    <id>3186</id>
    <revision>
      <id>63053</id>
      <parentid>59375</parentid>
      <timestamp>2013-07-01T23:52:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1469">{{cpp/title|is_unsigned}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_unsigned;
}}
{{dcl end}}

If {{tt|T}} is an unsigned arithmetic type, provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is an unsigned arithmetic type }}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

class A {};
enum B : unsigned {};
enum class C : unsigned {};

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_unsigned&lt;A&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_unsigned&lt;float&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_unsigned&lt;signed int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_unsigned&lt;unsigned int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_unsigned&lt;B&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_unsigned&lt;C&gt;::value &lt;&lt; '\n';
}
 | output=
false
false
false
true
false
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_floating_point}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/dsc make_signed}}
{{dsc inc | cpp/types/dsc make_unsigned}}
{{dsc end}}

[[de:cpp/types/is unsigned]]
[[es:cpp/types/is unsigned]]
[[fr:cpp/types/is unsigned]]
[[it:cpp/types/is unsigned]]
[[ja:cpp/types/is unsigned]]
[[pt:cpp/types/is unsigned]]
[[ru:cpp/types/is unsigned]]
[[zh:cpp/types/is unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is void</title>
    <ns>0</ns>
    <id>3136</id>
    <revision>
      <id>63054</id>
      <parentid>59378</parentid>
      <timestamp>2013-07-01T23:52:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1613">{{cpp/title|is_void}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_void;
}}
{{dcl end}}

Checks whether {{tt|T}} is a void type. Provides the member constant {{tt|value}} that is equal to {{c|true}}, if {{tt|T}} is the type {{c|void}}, {{c|const void}}, {{c|volatile void}}, or {{c|const volatile void}}. Otherwise, {{tt|value}} is equal to {{c|false}}.

===Template parameters===
{{par begin}}
{{par | T | a type to check}}
{{par end}}

{{cpp/types/integral_constant/inherit | {{tt|T}} is the type {{c|void}} (possibly cv-qualified) }}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct is_void : std::integral_constant&lt;
                     bool,
                     std::is_same&lt;void, typename std::remove_cv&lt;T&gt;::type&gt;::value
                  &gt; {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_void&lt;void&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_void&lt;int&gt;::value &lt;&lt; '\n';
} | output=
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc is_enum}}
{{dsc inc | cpp/types/dsc is_union}}
{{dsc inc | cpp/types/dsc is_class}}
{{dsc inc | cpp/types/dsc is_function}}
{{dsc inc | cpp/types/dsc is_object}}
{{dsc end}}

[[de:cpp/types/is void]]
[[es:cpp/types/is void]]
[[fr:cpp/types/is void]]
[[it:cpp/types/is void]]
[[ja:cpp/types/is void]]
[[pt:cpp/types/is void]]
[[ru:cpp/types/is void]]
[[zh:cpp/types/is void]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/is volatile</title>
    <ns>0</ns>
    <id>3177</id>
    <revision>
      <id>69170</id>
      <parentid>63055</parentid>
      <timestamp>2014-03-28T18:21:36Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1229">{{cpp/title|is_volatile}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_volatile;
}}
{{dcl end}}

If {{tt|T}} is a volatile-qualified type (that is, {{c|volatile}}, or {{c|const volatile}}), provides the member constant {{tt|value}} equal {{c|true}}. For any other type, {{tt|value}} is {{c|false}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a volatile-qualified type }}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt; struct is_volatile             : std::false_type {};
template&lt;class T&gt; struct is_volatile&lt;volatile T&gt; : std::true_type {};
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() 
{
    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; std::is_volatile&lt;int&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::is_volatile&lt;volatile int&gt;::value  &lt;&lt; '\n';
}

 | output=
false
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_const}}
{{dsc end}}

[[de:cpp/types/is volatile]]
[[es:cpp/types/is volatile]]
[[fr:cpp/types/is volatile]]
[[it:cpp/types/is volatile]]
[[ja:cpp/types/is volatile]]
[[pt:cpp/types/is volatile]]
[[ru:cpp/types/is volatile]]
[[zh:cpp/types/is volatile]]</text>
      <sha1>a77moqgosrs4cjc55cbayoyhnvsxk2j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/make signed</title>
    <ns>0</ns>
    <id>3282</id>
    <revision>
      <id>63056</id>
      <parentid>59380</parentid>
      <timestamp>2013-07-01T23:52:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1876">{{cpp/title|make_signed}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct make_signed;
}}
{{dcl end}}

Given an integral (except bool) or enumeration type {{tt|T}}, provides the member typedef {{tt|type}} which is the signed integer type corresponding to {{tt|T}}, with the same cv-qualifiers.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the signed integer type corresponding to {{tt|T}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using make_signed_t = typename make_signed&lt;T&gt;::type;
}}
{{dcl end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    typedef std::make_signed&lt;char&gt;::type char_type;
    typedef std::make_signed&lt;int&gt;::type int_type;
    typedef std::make_signed&lt;volatile long&gt;::type long_type;

    bool ok1 = std::is_same&lt;char_type, signed char&gt;::value;
    bool ok2 = std::is_same&lt;int_type, signed int&gt;::value;
    bool ok3 = std::is_same&lt;long_type, volatile signed long&gt;::value;

    std::cout &lt;&lt; std::boolalpha
    &lt;&lt; &quot;char_type is 'signed char'?          : &quot; &lt;&lt; ok1 &lt;&lt; '\n'
    &lt;&lt; &quot;int_type  is 'signed int'?           : &quot; &lt;&lt; ok2 &lt;&lt; '\n'
    &lt;&lt; &quot;long_type is 'volatile signed long'? : &quot; &lt;&lt; ok3 &lt;&lt; '\n';
}
 | output=
char_type is 'signed char'?          : true
int_type  is 'signed int'?           : true
long_type is 'volatile signed long'? : true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_unsigned}}
{{dsc inc | cpp/types/dsc make_unsigned}}
{{dsc end}}

[[de:cpp/types/make signed]]
[[es:cpp/types/make signed]]
[[fr:cpp/types/make signed]]
[[it:cpp/types/make signed]]
[[ja:cpp/types/make signed]]
[[pt:cpp/types/make signed]]
[[ru:cpp/types/make signed]]
[[zh:cpp/types/make signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/make unsigned</title>
    <ns>0</ns>
    <id>3283</id>
    <revision>
      <id>63057</id>
      <parentid>59383</parentid>
      <timestamp>2013-07-01T23:52:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1931">{{cpp/title|make_unsigned}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct make_unsigned;
}}
{{dcl end}}

Given an integral (except bool) or enumeration type {{tt|T}}, provides the member typedef {{tt|type}} which is the unsigned integer type corresponding to {{tt|T}}, with the same cv-qualifiers.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the unsigned integer type corresponding to {{tt|T}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using make_unsigned_t = typename make_unsigned&lt;T&gt;::type;
}}
{{dcl end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main() {
    typedef std::make_unsigned&lt;char&gt;::type char_type;
    typedef std::make_unsigned&lt;int&gt;::type int_type;
    typedef std::make_unsigned&lt;volatile long&gt;::type long_type;

    bool ok1 = std::is_same&lt;char_type, unsigned char&gt;::value; 
    bool ok2 = std::is_same&lt;int_type, unsigned int&gt;::value;
    bool ok3 = std::is_same&lt;long_type, volatile unsigned long&gt;::value;
    
    std::cout &lt;&lt; std::boolalpha
    &lt;&lt; &quot;char_type is 'unsigned char'?          : &quot; &lt;&lt; ok1 &lt;&lt; '\n'
    &lt;&lt; &quot;int_type  is 'unsigned int'?           : &quot; &lt;&lt; ok2 &lt;&lt; '\n'
    &lt;&lt; &quot;long_type is 'volatile unsigned long'? : &quot; &lt;&lt; ok3 &lt;&lt; '\n';
}
 | output=
char_type is 'unsigned char'?          : true
int_type  is 'unsigned int'?           : true
long_type is 'volatile unsigned long'? : true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_signed}}
{{dsc inc | cpp/types/dsc is_unsigned}}
{{dsc inc | cpp/types/dsc make_signed}}
{{dsc end}}

[[de:cpp/types/make unsigned]]
[[es:cpp/types/make unsigned]]
[[fr:cpp/types/make unsigned]]
[[it:cpp/types/make unsigned]]
[[ja:cpp/types/make unsigned]]
[[pt:cpp/types/make unsigned]]
[[ru:cpp/types/make unsigned]]
[[zh:cpp/types/make unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/max align t</title>
    <ns>0</ns>
    <id>3269</id>
    <revision>
      <id>71412</id>
      <parentid>63058</parentid>
      <timestamp>2014-06-11T01:07:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to alignment</comment>
      <text xml:space="preserve" bytes="1330">{{cpp/title|max_align_t}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl | since=c++11 |
typedef /*implementation-defined*/ max_align_t;
}}
{{dcl end}}

{{lc|std::max_align_t}} is a POD type whose [[cpp/language/object#Alignment|alignment requirement]] is at least as strict (as large) as that of every scalar type.

===Notes===
Pointers returned by allocation functions such as {{lc|std::malloc}} are suitably aligned for any object, which means they are aligned at least as strict as {{lc|std::max_align_t}}.

{{lc|std::max_align_t}} is usually synonymous with the largest scalar type, which is {{c|long double}} on most platforms, and its alignment requirement is either 8 or 16.

===Example===
{{example
 | &lt;!-- todo: smarter example, perhaps use as aligned storage? --&gt;
 | code=
#include &lt;iostream&gt;
#include &lt;cstddef&gt;
int main()
{
    std::cout &lt;&lt; alignof(std::max_align_t) &lt;&lt; '\n';
}
 | output=
16
 | p = true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc alignof}}
{{dsc inc | cpp/types/dsc alignment_of}}
{{dsc inc | cpp/types/dsc is_scalar}}
{{dsc end}}

[[de:cpp/types/max align t]]
[[es:cpp/types/max align t]]
[[fr:cpp/types/max align t]]
[[it:cpp/types/max align t]]
[[ja:cpp/types/max align t]]
[[pt:cpp/types/max align t]]
[[ru:cpp/types/max align t]]
[[zh:cpp/types/max align t]]</text>
      <sha1>ntlf8rcfh35lwpg0jfzrxgomntwilfn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/nullptr t</title>
    <ns>0</ns>
    <id>2874</id>
    <revision>
      <id>63059</id>
      <parentid>59387</parentid>
      <timestamp>2013-07-01T23:52:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1301">{{cpp/title|nullptr_t}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl | since=c++11 |
typedef decltype(nullptr) nullptr_t;
}}
{{dcl end}}

{{lc|std::nullptr_t}} is the type of the null pointer literal, {{c|nullptr}}. 

===Example===
{{example
 | If two or more overloads accept different pointer types, an overload for {{lc|std::nullptr_t}} is necessary to accept a null pointer argument.
 | code=
#include &lt;cstddef&gt;
#include &lt;iostream&gt;

void f(int* pi)
{
   std::cout &lt;&lt; &quot;Pointer to integer overload\n&quot;;
}

void f(double* pd)
{
   std::cout &lt;&lt; &quot;Pointer to double overload\n&quot;;
}

void f(std::nullptr_t nullp)
{
   std::cout &lt;&lt; &quot;null pointer overload\n&quot;;
}

int main()
{
    int* pi; double* pd;

    f(pi);
    f(pd);
    f(nullptr);  // would be ambiguous without void f(nullptr_t)
    // f(NULL);  // ambiguous overload: all three functions are candidates
}
 | output=
Pointer to integer overload
Pointer to double overload
null pointer overload
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc nullptr}}
{{dsc inc | cpp/types/dsc NULL}}
{{dsc end}}

[[de:cpp/types/nullptr t]]
[[es:cpp/types/nullptr t]]
[[fr:cpp/types/nullptr t]]
[[it:cpp/types/nullptr t]]
[[ja:cpp/types/nullptr t]]
[[pt:cpp/types/nullptr t]]
[[ru:cpp/types/nullptr t]]
[[zh:cpp/types/nullptr t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits</title>
    <ns>0</ns>
    <id>2032</id>
    <revision>
      <id>67795</id>
      <parentid>59390</parentid>
      <timestamp>2014-02-28T14:24:03Z</timestamp>
      <contributor>
        <username>Oli</username>
        <id>1232</id>
      </contributor>
      <comment>/* See also */ new section to link to [[cpp/language/types | Arithmetic types]]</comment>
      <text xml:space="preserve" bytes="9789">{{cpp/title|numeric_limits}}
{{cpp/types/numeric_limits/navbar}}

{{ddcl | header=limits | 
template&lt; class T &gt; class numeric_limits;
}}

The {{tt|numeric_limits}} class template provides a standardized way to query various properties of fundamental types (e.g. the largest possible value for type {{c|int}} is {{c|std::numeric_limits&lt;int&gt;::max()}}). 

This information is provided via specializations of the {{tt|numeric_limits}} template. The standard library makes available specializations for all fundamental types:

{{dcl begin}}
{{dcl header | limits}}
{{dcl |
template&lt;&gt; class numeric_limits&lt;bool&gt;;
template&lt;&gt; class numeric_limits&lt;char&gt;;
template&lt;&gt; class numeric_limits&lt;signed char&gt;;
template&lt;&gt; class numeric_limits&lt;unsigned char&gt;;
template&lt;&gt; class numeric_limits&lt;wchar_t&gt;;
template&lt;&gt; class numeric_limits&lt;char16_t&gt;;   // C++11 feature
template&lt;&gt; class numeric_limits&lt;char32_t&gt;;   // C++11 feature
template&lt;&gt; class numeric_limits&lt;short&gt;;
template&lt;&gt; class numeric_limits&lt;unsigned short&gt;;
template&lt;&gt; class numeric_limits&lt;int&gt;;
template&lt;&gt; class numeric_limits&lt;unsigned int&gt;;
template&lt;&gt; class numeric_limits&lt;long&gt;;
template&lt;&gt; class numeric_limits&lt;unsigned long&gt;;
template&lt;&gt; class numeric_limits&lt;long long&gt;;
template&lt;&gt; class numeric_limits&lt;unsigned long long&gt;;
template&lt;&gt; class numeric_limits&lt;float&gt;;
template&lt;&gt; class numeric_limits&lt;double&gt;;
template&lt;&gt; class numeric_limits&lt;long double&gt;;
}}
{{dcl end}}

Additionally, a specialization exists for every cv-qualified version of each fundamental type, identical to the unqualified specialization, e.g. {{tt|std::numeric_limits&lt;const int&gt;}}, {{tt|std::numeric_limits&lt;volatile int&gt;}}, and {{tt|std::numeric_limits&lt;const volatile int&gt;}} are provided and are equivalent to {{tt|std::numeric_limits&lt;int&gt;}}.

The standard library types that are aliases of fundamental types (such as {{lc|std::size_t}} or {{lc|std::streamsize}} may also be examined with the {{lc|std::numeric_limits}} type traits.

Implementations may provide specializations of {{lc|std::numeric_limits}} for implementation-specific types: e.g. GCC provides {{c|std::numeric_limits&lt;__int128&gt;}}. Libraries may add specializations for library-provided types, e.g. [http://openexr.com/ OpenEXR] provides {{c|std::numeric_limits&lt;half&gt;}} for a 16-bit floating-point type.

===Template parameters===
{{par begin}}
{{par | T | a type to retrieve numeric properties for}}
{{par end}}

===Member constants===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_specialized}}
{{dsc inc | cpp/types/numeric_limits/dsc is_signed}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm_loss}}
{{dsc inc | cpp/types/numeric_limits/dsc round_style}}
{{dsc inc | cpp/types/numeric_limits/dsc is_iec559}}
{{dsc inc | cpp/types/numeric_limits/dsc is_bounded}}
{{dsc inc | cpp/types/numeric_limits/dsc is_modulo}}
{{dsc inc | cpp/types/numeric_limits/dsc digits}}
{{dsc inc | cpp/types/numeric_limits/dsc digits10}}
{{dsc inc | cpp/types/numeric_limits/dsc max_digits10}}
{{dsc inc | cpp/types/numeric_limits/dsc radix}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent10}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent10}}
{{dsc inc | cpp/types/numeric_limits/dsc traps}}
{{dsc inc | cpp/types/numeric_limits/dsc tinyness_before}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min}}
{{dsc inc | cpp/types/numeric_limits/dsc lowest}}
{{dsc inc | cpp/types/numeric_limits/dsc max}}
{{dsc inc | cpp/types/numeric_limits/dsc epsilon}}
{{dsc inc | cpp/types/numeric_limits/dsc round_error}}
{{dsc inc | cpp/types/numeric_limits/dsc infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc signaling_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc denorm_min}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc float_round_style}}
{{dsc inc | cpp/types/numeric_limits/dsc float_denorm_style}}
{{dsc end}}

===Relationship with C library macro constants===

{| class=&quot;wikitable&quot; style=&quot;font-size:85%; white-space: nowrap;&quot;
|-
! rowspan=2 | Specialization 
! colspan=11 | Members
|-
&lt;!-- --&gt;
! {{tt|min()}}
! {{tt|lowest()}}&lt;br&gt;{{mark c++11}}
! {{tt|max()}}
! {{tt|epsilon()}}
! {{tt|digits}}
! {{tt|digits10}}
! {{tt|min_exponent}}
! {{tt|min_exponent10}}
! {{tt|max_exponent}}
! {{tt|max_exponent10}}
! {{tt|radix}}
|-
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|bool}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
|
|
|
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|char}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|CHAR_MIN}}
| {{lc|CHAR_MIN}}
| {{lc|CHAR_MAX}} 
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|signed char}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|SCHAR_MIN}}
| {{lc|SCHAR_MIN}}
| {{lc|SCHAR_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|unsigned char}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|UCHAR_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|wchar_t}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|WCHAR_MIN}}
| {{lc|WCHAR_MIN}}
| {{lc|WCHAR_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|char16_t}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|UINT_LEAST16_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|char32_t}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|UINT_LEAST32_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|short}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| rowspan=2 | {{lc|SHRT_MIN}}
| rowspan=2 | {{lc|SHRT_MIN}}
| rowspan=2 | {{lc|SHRT_MAX}}
|
|
|
|
|
|
|
| rowspan=2 | {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|signed short}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|
|
|
|
|
|
|
&lt;!-- --&gt;
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|unsigned short}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|USHRT_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|int}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| rowspan=2 | {{lc|INT_MIN}}
| rowspan=2 | {{lc|INT_MIN}}
| rowspan=2 | {{lc|INT_MAX}}
|
|
|
|
|
|
|
| rowspan=2 | {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|signed int}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|
|
|
|
|
|
|
&lt;!-- --&gt;
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|unsigned int}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|UINT_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| rowspan=2 | {{lc|LONG_MIN}}
| rowspan=2 | {{lc|LONG_MIN}}
| rowspan=2 | {{lc|LONG_MAX}}
|
|
|
|
|
|
|
| rowspan=2 | {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|signed long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|
|
|
|
|
|
&lt;!-- --&gt;
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|unsigned long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|ULONG_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|long long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| rowspan=2 | {{lc|LLONG_MIN}}
| rowspan=2 | {{lc|LLONG_MIN}}
| rowspan=2 | {{lc|LLONG_MAX}}
|
|
|
|
|
|
|
| rowspan=2 | {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|signed long long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|
|
|
|
|
|
|
&lt;!-- --&gt;
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|unsigned long long}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{c|0}}
| {{c|0}}
| {{lc|ULLONG_MAX}}
|
|
|
|
|
|
|
| {{c|2}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|float}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|FLT_MIN}}
| {{c|-FLT_MAX}}
| {{lc|FLT_MAX}}
| {{lc|FLT_EPSILON}}
| {{lc|FLT_MANT_DIG}}
| {{lc|FLT_DIG}}
| {{lc|FLT_MIN_EXP}}
| {{lc|FLT_MIN_10_EXP}}
| {{lc|FLT_MAX_EXP}}
| {{lc|FLT_MAX_10_EXP}}
| {{lc|FLT_RADIX}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|double}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|DBL_MIN}}
| {{c|-DBL_MAX}}
| {{lc|DBL_MAX}}
| {{lc|DBL_EPSILON}}
| {{lc|DBL_MANT_DIG}}
| {{lc|DBL_DIG}}
| {{lc|DBL_MIN_EXP}}
| {{lc|DBL_MIN_10_EXP}}
| {{lc|DBL_MAX_EXP}}
| {{lc|DBL_MAX_10_EXP}}
| {{lc|FLT_RADIX}}
|-
| {{tt|&lt;sub&gt;numeric_limits&lt; &lt;/sub&gt;}}{{c|long double}}{{tt|&lt;sub&gt; &gt;&lt;/sub&gt;}}
| {{lc|LDBL_MIN}}
| {{c|-LDBL_MAX}}
| {{lc|LDBL_MAX}}
| {{lc|LDBL_EPSILON}}
| {{lc|LDBL_MANT_DIG}}
| {{lc|LDBL_DIG}}
| {{lc|LDBL_MIN_EXP}}
| {{lc|LDBL_MIN_10_EXP}}
| {{lc|LDBL_MAX_EXP}}
| {{lc|LDBL_MAX_10_EXP}}
| {{lc|FLT_RADIX}}
|}

===Example===
{{example
 | p=true
 | code=
#include &lt;limits&gt;
#include &lt;iostream&gt;

int main() 
{
    std::cout &lt;&lt; &quot;type\tlowest\thighest\n&quot;;
    std::cout &lt;&lt; &quot;int\t&quot;
              &lt;&lt; std::numeric_limits&lt;int&gt;::lowest() &lt;&lt; '\t'
              &lt;&lt; std::numeric_limits&lt;int&gt;::max() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;float\t&quot;
              &lt;&lt; std::numeric_limits&lt;float&gt;::lowest() &lt;&lt; '\t'
              &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;double\t&quot;
              &lt;&lt; std::numeric_limits&lt;double&gt;::lowest() &lt;&lt; '\t'
              &lt;&lt; std::numeric_limits&lt;double&gt;::max() &lt;&lt; '\n';
}
 | output=
type    lowest         highest
int     -2147483648    2147483647
float   -3.40282e+38   3.40282e+38
double  -1.79769e+308  1.79769e+308
}}

===See also===
* [[c/types/integer    | Fixed width integer types]]
* [[cpp/language/types | Arithmetic types]]
* [[cpp/language/type  | C++ type system overview]]
* [[cpp/types          | Type support (basic types, RTTI, type traits)]]

[[de:cpp/types/numeric limits]]
[[es:cpp/types/numeric limits]]
[[fr:cpp/types/numeric limits]]
[[it:cpp/types/numeric limits]]
[[ja:cpp/types/numeric limits]]
[[pt:cpp/types/numeric limits]]
[[ru:cpp/types/numeric limits]]
[[zh:cpp/types/numeric limits]]</text>
      <sha1>l5o43b7j4vri4x7gye0x2ki3eb1ou5p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/denorm min</title>
    <ns>0</ns>
    <id>3030</id>
    <revision>
      <id>64824</id>
      <parentid>61876</parentid>
      <timestamp>2013-08-27T01:13:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="2797">{{cpp/types/numeric_limits/title | denorm_min}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T denorm_min();
}}
{{dcl | since=c++11 |1=
static constexpr T denorm_min();
}}
{{dcl rev end}}
{{dcl end}}

Returns the minimum positive [[enwiki:Denormal number|subnormal value]] of the type {{tt|T}}, if {{c|1=std::numeric_limits&lt;T&gt;::has_denorm != std::denorm_absent}}, otherwise returns {{c|std::numeric_limits&lt;T&gt;::min()}}. Only meaningful for floating-point types.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::denorm_min()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{math|2{{su|p=-149}}}} if {{c|1=std::numeric_limits&lt;float&gt;::is_iec559 == true}} }}
{{dsc | {{c|double}}            | {{math|2{{su|p=-1074}}}} if {{c|1=std::numeric_limits&lt;double&gt;::is_iec559 == true}} }}
{{dsc | {{c|long double}}       | /* implementation-defined */ }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | Demonstates the underlying bit structure of the denorm_min()
 | code=
#include &lt;cstdint&gt;
#include &lt;limits&gt;
#include &lt;cassert&gt;
int main()
{
    // the smallest subnormal value has sign bit = 0, exponent = 0
    // and only the least significant bit of the fraction is 1
    uint32_t denorm_bits = 0x0001;
    float denorm_float = reinterpret_cast&lt;float&amp;&gt;(denorm_bits);
    assert(denorm_float == std::numeric_limits&lt;float&gt;::denorm_min());
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm}}
{{dsc inc | cpp/types/numeric_limits/dsc lowest}}
{{dsc end}}

[[de:cpp/types/numeric limits/denorm min]]
[[es:cpp/types/numeric limits/denorm min]]
[[fr:cpp/types/numeric limits/denorm min]]
[[it:cpp/types/numeric limits/denorm min]]
[[ja:cpp/types/numeric limits/denorm min]]
[[pt:cpp/types/numeric limits/denorm min]]
[[ru:cpp/types/numeric limits/denorm min]]
[[zh:cpp/types/numeric limits/denorm min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/digits</title>
    <ns>0</ns>
    <id>3074</id>
    <revision>
      <id>61864</id>
      <parentid>59392</parentid>
      <timestamp>2013-06-09T16:07:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2450">{{cpp/types/numeric_limits/title | digits}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int digits;
}}
{{dcl | since=c++11 |1=
static constexpr int digits;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::digits}} is the number of digits in base-{{rlp|radix}} that can be represented by the type {{tt|T}} without change. For integer types, this is the number of bits not counting the sign bit. For floating-point types, this is the number of digits in the mantissa.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::digits}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|1}} }}
{{dsc | {{c|char}}              | {{c|1=CHAR_BIT - std::numeric_limits&lt;char&gt;::is_signed}} }}
{{dsc | {{c|signed char}}       | {{c|CHAR_BIT-1}} }}
{{dsc | {{c|unsigned char}}     | {{lc|CHAR_BIT}} }}
{{dsc | {{c|wchar_t}}           | {{c|1=CHAR_BIT*sizeof(wchar_t) - std::numeric_limits&lt;wchar_t&gt;::is_signed}} }}
{{dsc | {{c|char16_t}}          | {{c|CHAR_BIT*sizeof(char16_t)}} }}
{{dsc | {{c|char32_t}}          | {{c|CHAR_BIT*sizeof(char32_t)}} }}
{{dsc | {{c|short}}             | {{c|CHAR_BIT*sizeof(short)-1}} }}
{{dsc | {{c|unsigned short}}    | {{c|CHAR_BIT*sizeof(short)}} }}
{{dsc | {{c|int}}               | {{c|CHAR_BIT*sizeof(int)-1}} }}
{{dsc | {{c|unsigned int}}      | {{c|CHAR_BIT*sizeof(int)}} }}
{{dsc | {{c|long}}              | {{c|CHAR_BIT*sizeof(long)-1}} }}
{{dsc | {{c|unsigned long}}     | {{c|CHAR_BIT*sizeof(long)}} }}
{{dsc | {{c|long long}}         | {{c|CHAR_BIT*sizeof(long long)-1}} }}
{{dsc | {{c|unsigned long long}}| {{c|CHAR_BIT*sizeof(long long)}} }}
{{dsc | {{c|float}}             | {{lc|FLT_MANT_DIG}} }}
{{dsc | {{c|double}}            | {{lc|DBL_MANT_DIG}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MANT_DIG}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc radix}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc end}}

[[de:cpp/types/numeric limits/digits]]
[[es:cpp/types/numeric limits/digits]]
[[fr:cpp/types/numeric limits/digits]]
[[it:cpp/types/numeric limits/digits]]
[[ja:cpp/types/numeric limits/digits]]
[[pt:cpp/types/numeric limits/digits]]
[[ru:cpp/types/numeric limits/digits]]
[[zh:cpp/types/numeric limits/digits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/digits10</title>
    <ns>0</ns>
    <id>3075</id>
    <revision>
      <id>61863</id>
      <parentid>59395</parentid>
      <timestamp>2013-06-09T16:07:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="3950">{{cpp/types/numeric_limits/title | digits10}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int digits10;
}}
{{dcl | since=c++11 |1=
static constexpr int digits10
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::digits10}} is the number of base-10 digits that can be represented by the type {{tt|T}} without change, that is, any number with this many decimal digits can be converted to a value of type {{tt|T}} and back to decimal form, without change due to rounding or overflow. For base-{{rlp|radix}} types, it is the value of {{rlp|digits}} ({{c|digits-1}} for floating-point types) multiplied by {{math|log{{su|b=10}}(radix)}} and rounded down.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::digits10}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|std::numeric_limits&lt;char&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|signed char}}       | {{c|std::numeric_limits&lt;signed char&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|unsigned char}}     | {{c|std::numeric_limits&lt;unsigned char&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|wchar_t}}           | {{c|std::numeric_limits&lt;wchar_t&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|char16_t}}          | {{c|std::numeric_limits&lt;char16_t&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|char32_t}}          | {{c|std::numeric_limits&lt;char32_t&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|short}}             | {{c|std::numeric_limits&lt;short&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|unsigned short}}    | {{c|std::numeric_limits&lt;signed short&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|int}}               | {{c|std::numeric_limits&lt;int&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|unsigned int}}      | {{c|std::numeric_limits&lt;signed int&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|long}}              | {{c|std::numeric_limits&lt;long&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|unsigned long}}     | {{c|std::numeric_limits&lt;unsigned long&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|long long}}         | {{c|std::numeric_limits&lt;long long&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|unsigned long long}}| {{c|std::numeric_limits&lt;unsigned long long&gt;::digits * std::log10(2)}} }}
{{dsc | {{c|float}}             | {{lc|FLT_DIG}} }}
{{dsc | {{c|double}}            | {{lc|DBL_DIG}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_DIG}} }}
{{dsc end}}

===Example===
An 8-bit binary type can represent any two-digit decimal number exactly, but 3-digit decimal numbers 256..999 cannot be represented. The value of {{tt|digits10}} for an 8-bit type is 2 ({{c|1=8 * std::log10(2)}} is 2.41)

The standard 32-bit IEEE 754 floating-point type has a 24 bit fractional part (23 bits written, one implied), which may suggest that it can represent 7 digit decimals ({{c|1=24 * std::log10(2)}} is 7.22), but relative rounding errors are non-uniform and some floating-point values with 7 decimal digits do not survive conversion to 32-bit float and back: the smallest positive example is {{c|8.589973e9}}, which becomes {{c|8.589974e9}} after the roundtrip. These rounding errors cannot exceed one bit in the representation, and {{tt|digits10}} is calculated as {{c|1=(24-1)*std::log10(2)}}, which is 6.92. Rounding down results in the value 6.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc radix}}
{{dsc inc | cpp/types/numeric_limits/dsc digits}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc end}}

[[de:cpp/types/numeric limits/digits10]]
[[es:cpp/types/numeric limits/digits10]]
[[fr:cpp/types/numeric limits/digits10]]
[[it:cpp/types/numeric limits/digits10]]
[[ja:cpp/types/numeric limits/digits10]]
[[pt:cpp/types/numeric limits/digits10]]
[[ru:cpp/types/numeric limits/digits10]]
[[zh:cpp/types/numeric limits/digits10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/epsilon</title>
    <ns>0</ns>
    <id>3027</id>
    <revision>
      <id>71237</id>
      <parentid>69171</parentid>
      <timestamp>2014-06-08T22:22:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mention why this is 'simplictic' and scale to the sign-sensitive sum, not to the max abs (http://stackoverflow.com/questions/10334688)</comment>
      <text xml:space="preserve" bytes="3097">{{cpp/types/numeric_limits/title | epsilon}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T epsilon();
}}
{{dcl | since=c++11 |1=
static constexpr T epsilon();
}}
{{dcl rev end}}
{{dcl end}}

Returns the machine epsilon, that is, the difference between {{c|1.0}} and the next value representable by the floating-point type {{tt|T}}. It is only meaningful if {{c|1=std::numeric_limits&lt;T&gt;::is_integer == false}}.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::epsilon()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}       }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|FLT_EPSILON}}   }}
{{dsc | {{c|double}}            | {{lc|DBL_EPSILON}}   }}
{{dsc | {{c|long double}}       | {{lc|LDBL_EPSILON}}  }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | Demonstrates the simplistic use of machine epsilon to compare floating-point values (this approach doesn't work for the subnormal values, for which the epsilon is meaningless)
 | code=
#include &lt;cmath&gt;
#include &lt;limits&gt;
#include &lt;iomanip&gt;
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;algorithm&gt;

template&lt;class T&gt;
typename std::enable_if&lt;!std::numeric_limits&lt;T&gt;::is_integer, bool&gt;::type
    almost_equal(T x, T y, int ulp)
{
    // the machine epsilon has to be scaled to the magnitude of the larger value
    // and multiplied by the desired precision in ULPs (units in the last place)
    return std::abs(x-y) &lt;= std::numeric_limits&lt;T&gt;::epsilon() * std::abs(x+y) * ulp;
}
int main()
{
    double d1 = 0.2;
    double d2 = 1 / std::sqrt(5) / std::sqrt(5);

    if(d1 == d2)
            std::cout &lt;&lt; &quot;d1 == d2\n&quot;;
    else
            std::cout &lt;&lt; &quot;d1 != d2\n&quot;;

    if(almost_equal(d1, d2, 2))
            std::cout &lt;&lt; &quot;d1 almost equals d2\n&quot;;
    else
            std::cout &lt;&lt; &quot;d1 does not almost equal d2\n&quot;;
}
 | output=
d1 != d2
d1 almost equals d2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/math/dsc nextafter}}
{{dsc end}}

[[de:cpp/types/numeric limits/epsilon]]
[[es:cpp/types/numeric limits/epsilon]]
[[fr:cpp/types/numeric limits/epsilon]]
[[it:cpp/types/numeric limits/epsilon]]
[[ja:cpp/types/numeric limits/epsilon]]
[[pt:cpp/types/numeric limits/epsilon]]
[[ru:cpp/types/numeric limits/epsilon]]
[[zh:cpp/types/numeric limits/epsilon]]</text>
      <sha1>d3g53gtvdodc1ex8sn9uilfezvrwroq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/float denorm style</title>
    <ns>0</ns>
    <id>3093</id>
    <revision>
      <id>59399</id>
      <parentid>51546</parentid>
      <timestamp>2013-06-01T06:33:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1233">{{cpp/title | float_denorm_style}}
{{cpp/types/numeric_limits/navbar}}

{{dcl begin}}
{{dcl header | limits}}
{{dcl | 1=
enum float_denorm_style {
    denorm_indeterminate = -1,
    denorm_absent        = 0,
    denorm_present       = 1
};
}}
{{dcl end}}

Enumeration constants of type {{lc|std::float_denorm_style}} indicate support of subnormal values by floating-point types.

===Enumeration constants===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{lc|std::denorm_indeterminate}} | Support of subnormal values cannot be determined }}
{{dsc | {{lc|std::denorm_absent}}        | The type does not support subnormal values}}
{{dsc | {{lc|std::denorm_present}}       | The type allows subnormal values}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm}}
{{dsc end}}

[[de:cpp/types/numeric limits/float denorm style]]
[[es:cpp/types/numeric limits/float denorm style]]
[[fr:cpp/types/numeric limits/float denorm style]]
[[it:cpp/types/numeric limits/float denorm style]]
[[ja:cpp/types/numeric limits/float denorm style]]
[[pt:cpp/types/numeric limits/float denorm style]]
[[ru:cpp/types/numeric limits/float denorm style]]
[[zh:cpp/types/numeric limits/float denorm style]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/float round style</title>
    <ns>0</ns>
    <id>3092</id>
    <revision>
      <id>59402</id>
      <parentid>51547</parentid>
      <timestamp>2013-06-01T06:33:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1599">{{cpp/title | float_round_style}}
{{cpp/types/numeric_limits/navbar}}

{{dcl begin}}
{{dcl header | limits}}
{{dcl | 1=
enum float_round_style {
    round_indeterminate       = -1,
    round_toward_zero         = 0,
    round_to_nearest          = 1, 
    round_toward_infinity     = 2,
    round_toward_neg_infinity = 3
};
}}
{{dcl end}}

Enumeration constants of type {{lc|std::float_round_style}} indicate the rounding style used by floating-point arithmetics whenever a result of an expression is stored in an object of a floating-point type. The values are:

===Enumeration constants===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{lc|std::round_indeterminate}} | Rounding style cannot be determined }}
{{dsc | {{lc|std::round_toward_zero}}   | Rounding toward zero}}
{{dsc | {{lc|std::round_to_nearest}}    | Rounding toward nearest representable value}}
{{dsc | {{lc|std::round_toward_infinity}}    | Rounding toward positive infinity }}
{{dsc | {{lc|std::round_toward_neg_infinity}}    | Rounding toward negative infinity }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc round_style}}
{{dsc inc | cpp/numeric/fenv/dsc FE_round}}
{{dsc end}}

[[de:cpp/types/numeric limits/float round style]]
[[es:cpp/types/numeric limits/float round style]]
[[fr:cpp/types/numeric limits/float round style]]
[[it:cpp/types/numeric limits/float round style]]
[[ja:cpp/types/numeric limits/float round style]]
[[pt:cpp/types/numeric limits/float round style]]
[[ru:cpp/types/numeric limits/float round style]]
[[zh:cpp/types/numeric limits/float round style]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/has denorm</title>
    <ns>0</ns>
    <id>3094</id>
    <revision>
      <id>61852</id>
      <parentid>59403</parentid>
      <timestamp>2013-06-09T16:05:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2311">{{cpp/types/numeric_limits/title | has_denorm}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const std::float_denorm_style has_denorm
}}
{{dcl | since=c++11 |1=
static constexpr std::float_denorm_style has_denorm
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::has_denorm}} identifies the floating-point types that support [[enwiki:Denormal number|subnormal values]].

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::has_denorm}} }}
{{dsc | /* non-specialized */     | {{lc|std::denorm_absent}} }}
{{dsc | {{c|bool}}              | {{lc|std::denorm_absent}} }}
{{dsc | {{c|char}}              | {{lc|std::denorm_absent}} }}
{{dsc | {{c|signed char}}       | {{lc|std::denorm_absent}} }}
{{dsc | {{c|unsigned char}}     | {{lc|std::denorm_absent}} }}
{{dsc | {{c|wchar_t}}           | {{lc|std::denorm_absent}} }}
{{dsc | {{c|char16_t}}          | {{lc|std::denorm_absent}} }}
{{dsc | {{c|char32_t}}          | {{lc|std::denorm_absent}} }}
{{dsc | {{c|short}}             | {{lc|std::denorm_absent}} }}
{{dsc | {{c|unsigned short}}    | {{lc|std::denorm_absent}} }}
{{dsc | {{c|int}}               | {{lc|std::denorm_absent}} }}
{{dsc | {{c|unsigned int}}      | {{lc|std::denorm_absent}} }}
{{dsc | {{c|long}}              | {{lc|std::denorm_absent}} }}
{{dsc | {{c|unsigned long}}     | {{lc|std::denorm_absent}} }}
{{dsc | {{c|long long}}         | {{lc|std::denorm_absent}} }}
{{dsc | {{c|unsigned long long}}| {{lc|std::denorm_absent}} }}
{{dsc | {{c|float}}             | usually {{lc|std::denorm_present}} }}
{{dsc | {{c|double}}            | usually {{lc|std::denorm_present}} }}
{{dsc | {{c|long double}}       | usually {{lc|std::denorm_present}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc denorm_min}}
{{dsc inc | cpp/types/numeric_limits/dsc float_denorm_style}}
{{dsc end}}

[[de:cpp/types/numeric limits/has denorm]]
[[es:cpp/types/numeric limits/has denorm]]
[[fr:cpp/types/numeric limits/has denorm]]
[[it:cpp/types/numeric limits/has denorm]]
[[ja:cpp/types/numeric limits/has denorm]]
[[pt:cpp/types/numeric limits/has denorm]]
[[ru:cpp/types/numeric limits/has denorm]]
[[zh:cpp/types/numeric limits/has denorm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/has denorm loss</title>
    <ns>0</ns>
    <id>3080</id>
    <revision>
      <id>61859</id>
      <parentid>59406</parentid>
      <timestamp>2013-06-09T16:06:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2788">{{cpp/types/numeric_limits/title | has_denorm_loss}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool has_denorm_loss;
}}
{{dcl | since=c++11 |1=
static constexpr bool has_denorm_loss;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::has_denorm_loss}} is {{c|true}} for all floating-point types {{tt|T}} capable of distinguishing loss of precision due to denormalization from other causes of inexact result.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::has_denorm_loss}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | implementation-defined }}
{{dsc | {{c|double}}            | implementation-defined }}
{{dsc | {{c|long double}}       | implementation-defined }}
{{dsc end}}

===Notes===
Standard-compliant IEEE 754 floating-point implementations may detect the floating-point underflow at three predefined moments:

1) after computation of a result with absolute value smaller than {{c|std::numeric_limits&lt;T&gt;::min()}}, such implementation detects tinyness before rounding.

2) after rounding of the result to {{c|std::numeric_limits&lt;T&gt;::digits}} bits, if the result is tiny, such implementation detects tinyness after rounding.

3) if the conversion of the rounded tiny result to subnormal form resulted in the loss of precision, such implementation detects denorm loss.

===Example===
{{example
 | 
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc tinyness_before}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm}}
{{dsc end}}

[[de:cpp/types/numeric limits/has denorm loss]]
[[es:cpp/types/numeric limits/has denorm loss]]
[[fr:cpp/types/numeric limits/has denorm loss]]
[[it:cpp/types/numeric limits/has denorm loss]]
[[ja:cpp/types/numeric limits/has denorm loss]]
[[pt:cpp/types/numeric limits/has denorm loss]]
[[ru:cpp/types/numeric limits/has denorm loss]]
[[zh:cpp/types/numeric limits/has denorm loss]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/has infinity</title>
    <ns>0</ns>
    <id>3077</id>
    <revision>
      <id>61862</id>
      <parentid>59407</parentid>
      <timestamp>2013-06-09T16:07:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2247">{{cpp/types/numeric_limits/title | has_infinity}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool has_infinity;
}}
{{dcl | since=c++11 |1=
static constexpr bool has_infinity;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::has_infinity}} is {{c|true}} for all types {{tt|T}} capable of representing the positive infinity as a distinct special value. This constant is meaningful for all floating-point types and is guaranteed to be {{c|true}} if {{c|1=std::numeric_limits&lt;T&gt;::is_iec559 == true}}.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::has_infinity}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | usually {{c|true}} }}
{{dsc | {{c|double}}            | usually {{c|true}} }}
{{dsc | {{c|long double}}       | usually {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/has infinity]]
[[es:cpp/types/numeric limits/has infinity]]
[[fr:cpp/types/numeric limits/has infinity]]
[[it:cpp/types/numeric limits/has infinity]]
[[ja:cpp/types/numeric limits/has infinity]]
[[pt:cpp/types/numeric limits/has infinity]]
[[ru:cpp/types/numeric limits/has infinity]]
[[zh:cpp/types/numeric limits/has infinity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/has quiet NaN</title>
    <ns>0</ns>
    <id>3078</id>
    <revision>
      <id>61861</id>
      <parentid>59410</parentid>
      <timestamp>2013-06-09T16:07:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2264">{{cpp/types/numeric_limits/title | has_quiet_NaN}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool has_quiet_NaN;
}}
{{dcl | since=c++11 |1=
static constexpr bool has_quiet_NaN;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::has_quiet_NaN}} is {{c|true}} for all types {{tt|T}} capable of representing the special value &quot;Quiet [[enwiki:NaN|Not-A-Number]]&quot;. This constant is meaningful for all floating-point types and is guaranteed to be {{c|true}} if {{c|1=std::numeric_limits&lt;T&gt;::is_iec559 == true}}.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::has_quiet_NaN}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | usually {{c|true}} }}
{{dsc | {{c|double}}            | usually {{c|true}} }}
{{dsc | {{c|long double}}       | usually {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/has quiet NaN]]
[[es:cpp/types/numeric limits/has quiet NaN]]
[[fr:cpp/types/numeric limits/has quiet NaN]]
[[it:cpp/types/numeric limits/has quiet NaN]]
[[ja:cpp/types/numeric limits/has quiet NaN]]
[[pt:cpp/types/numeric limits/has quiet NaN]]
[[ru:cpp/types/numeric limits/has quiet NaN]]
[[zh:cpp/types/numeric limits/has quiet NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/has signaling NaN</title>
    <ns>0</ns>
    <id>3079</id>
    <revision>
      <id>61860</id>
      <parentid>59411</parentid>
      <timestamp>2013-06-09T16:06:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2316">{{cpp/types/numeric_limits/title | has_signaling_NaN}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool has_signaling_NaN;
}}
{{dcl | since=c++11 |1=
static constexpr bool has_signaling_NaN;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::has_signaling_NaN}} is {{c|true}} for all types {{tt|T}} capable of representing the special value &quot;Signaling [[enwiki:NaN|Not-A-Number]]&quot;. This constant is meaningful for all floating-point types and is guaranteed to be {{c|true}} if {{c|1=std::numeric_limits&lt;T&gt;::is_iec559 == true}}.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::has_signaling_NaN}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | usually {{c|true}} }}
{{dsc | {{c|double}}            | usually {{c|true}} }}
{{dsc | {{c|long double}}       | usually {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/has signaling NaN]]
[[es:cpp/types/numeric limits/has signaling NaN]]
[[fr:cpp/types/numeric limits/has signaling NaN]]
[[it:cpp/types/numeric limits/has signaling NaN]]
[[ja:cpp/types/numeric limits/has signaling NaN]]
[[pt:cpp/types/numeric limits/has signaling NaN]]
[[ru:cpp/types/numeric limits/has signaling NaN]]
[[zh:cpp/types/numeric limits/has signaling NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/infinity</title>
    <ns>0</ns>
    <id>3032</id>
    <revision>
      <id>64825</id>
      <parentid>61875</parentid>
      <timestamp>2013-08-27T01:13:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="2483">{{cpp/types/numeric_limits/title | infinity}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T infinity();
}}
{{dcl | since=c++11 |1=
static constexpr T infinity();
}}
{{dcl rev end}}
{{dcl end}}

Returns the special value &quot;positive infinity&quot;, as represented by the floating-point type {{tt|T}}. Only meaningful if {{c|1=std::numeric_limits&lt;T&gt;::has_infinity == true}}. In IEEE 754, the most common binary representation of floating-point numbers, the positive infinity is the value with all bits of the exponent set and all bits of the fraction cleared.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::infinity()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|HUGE_VALF}} }}
{{dsc | {{c|double}}            | {{lc|HUGE_VAL}} }}
{{dsc | {{c|long double}}       | {{lc|HUGE_VALL}} }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
int main()
{
    double max = std::numeric_limits&lt;double&gt;::max();
    double inf = std::numeric_limits&lt;double&gt;::infinity();

    if(inf &gt; max)
        std::cout &lt;&lt; inf &lt;&lt; &quot; is greater than &quot; &lt;&lt; max &lt;&lt; '\n';
}
 | output=
inf is greater than 1.79769e+308
}}


===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc end}}

[[de:cpp/types/numeric limits/infinity]]
[[es:cpp/types/numeric limits/infinity]]
[[fr:cpp/types/numeric limits/infinity]]
[[it:cpp/types/numeric limits/infinity]]
[[ja:cpp/types/numeric limits/infinity]]
[[pt:cpp/types/numeric limits/infinity]]
[[ru:cpp/types/numeric limits/infinity]]
[[zh:cpp/types/numeric limits/infinity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is bounded</title>
    <ns>0</ns>
    <id>3064</id>
    <revision>
      <id>61868</id>
      <parentid>59415</parentid>
      <timestamp>2013-06-09T16:08:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2182">{{cpp/types/numeric_limits/title | is_bounded}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_bounded;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_bounded;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_bounded}} is {{c|true}} for all arithmetic types {{tt|T}} that represent a finite set of values. While all fundamental types are bounded, this constant would be {{c|false}} in a specialization of {{lc|std::numeric_limits}} for a library-provided arbitrary precision arithmetic type 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_bounded}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|true}} }}
{{dsc | {{c|char}}              | {{c|true}} }}
{{dsc | {{c|signed char}}       | {{c|true}} }}
{{dsc | {{c|unsigned char}}     | {{c|true}} }}
{{dsc | {{c|wchar_t}}           | {{c|true}} }}
{{dsc | {{c|char16_t}}          | {{c|true}} }}
{{dsc | {{c|char32_t}}          | {{c|true}} }}
{{dsc | {{c|short}}             | {{c|true}} }}
{{dsc | {{c|unsigned short}}    | {{c|true}} }}
{{dsc | {{c|int}}               | {{c|true}} }}
{{dsc | {{c|unsigned int}}      | {{c|true}} }}
{{dsc | {{c|long}}              | {{c|true}} }}
{{dsc | {{c|unsigned long}}     | {{c|true}} }}
{{dsc | {{c|long long}}         | {{c|true}} }}
{{dsc | {{c|unsigned long long}}| {{c|true}} }}
{{dsc | {{c|float}}             | {{c|true}} }}
{{dsc | {{c|double}}            | {{c|true}} }}
{{dsc | {{c|long double}}       | {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_signed}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc end}}

[[de:cpp/types/numeric limits/is bounded]]
[[es:cpp/types/numeric limits/is bounded]]
[[fr:cpp/types/numeric limits/is bounded]]
[[it:cpp/types/numeric limits/is bounded]]
[[ja:cpp/types/numeric limits/is bounded]]
[[pt:cpp/types/numeric limits/is bounded]]
[[ru:cpp/types/numeric limits/is bounded]]
[[zh:cpp/types/numeric limits/is bounded]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is exact</title>
    <ns>0</ns>
    <id>3063</id>
    <revision>
      <id>61869</id>
      <parentid>59418</parentid>
      <timestamp>2013-06-09T16:08:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2206">{{cpp/types/numeric_limits/title | is_exact}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_exact;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_exact;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_exact}} is {{c|true}} for all arithmetic types {{tt|T}} that use exact representation. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_exact}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|true}} }}
{{dsc | {{c|char}}              | {{c|true}} }}
{{dsc | {{c|signed char}}       | {{c|true}} }}
{{dsc | {{c|unsigned char}}     | {{c|true}} }}
{{dsc | {{c|wchar_t}}           | {{c|true}} }}
{{dsc | {{c|char16_t}}          | {{c|true}} }}
{{dsc | {{c|char32_t}}          | {{c|true}} }}
{{dsc | {{c|short}}             | {{c|true}} }}
{{dsc | {{c|unsigned short}}    | {{c|true}} }}
{{dsc | {{c|int}}               | {{c|true}} }}
{{dsc | {{c|unsigned int}}      | {{c|true}} }}
{{dsc | {{c|long}}              | {{c|true}} }}
{{dsc | {{c|unsigned long}}     | {{c|true}} }}
{{dsc | {{c|long long}}         | {{c|true}} }}
{{dsc | {{c|unsigned long long}}| {{c|true}} }}
{{dsc | {{c|float}}             | {{c|false}} }}
{{dsc | {{c|double}}            | {{c|false}} }}
{{dsc | {{c|long double}}       | {{c|false}} }}
{{dsc end}}

===Notes===
While all fundamental types {{tt|T}} for which {{c|1=std::numeric_limits&lt;T&gt;::is_exact==true}} are integer types, a library may define exact types that aren't integers, e.g. a rational arithmetics type representing fractions.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_signed}}
{{dsc inc | cpp/types/numeric_limits/dsc is_bounded}}
{{dsc end}}

[[de:cpp/types/numeric limits/is exact]]
[[es:cpp/types/numeric limits/is exact]]
[[fr:cpp/types/numeric limits/is exact]]
[[it:cpp/types/numeric limits/is exact]]
[[ja:cpp/types/numeric limits/is exact]]
[[pt:cpp/types/numeric limits/is exact]]
[[ru:cpp/types/numeric limits/is exact]]
[[zh:cpp/types/numeric limits/is exact]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is iec559</title>
    <ns>0</ns>
    <id>3086</id>
    <revision>
      <id>61857</id>
      <parentid>59419</parentid>
      <timestamp>2013-06-09T16:06:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2319">{{cpp/types/numeric_limits/title | is_iec559}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_iec559;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_iec559;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_iec559}} is {{c|true}} for all floating-point types {{tt|T}} which fulfill the requirements of IEC 559 ([[enwiki:IEEE 754-2008|IEEE 754]]) standard. If {{c|std::numeric_limits&lt;T&gt;::is_iec559}} is {{c|true}}, then {{c|std::numeric_limits&lt;T&gt;::has_infinity}}, {{c|std::numeric_limits&lt;T&gt;::has_quiet_NaN}}, and {{c|std::numeric_limits&lt;T&gt;::has_signaling_NaN}} are also {{c|true}}.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_iec559}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | usually {{c|true}} }}
{{dsc | {{c|double}}            | usually {{c|true}} }}
{{dsc | {{c|long double}}       | usually {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_infinity}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/is iec559]]
[[es:cpp/types/numeric limits/is iec559]]
[[fr:cpp/types/numeric limits/is iec559]]
[[it:cpp/types/numeric limits/is iec559]]
[[ja:cpp/types/numeric limits/is iec559]]
[[pt:cpp/types/numeric limits/is iec559]]
[[ru:cpp/types/numeric limits/is iec559]]
[[zh:cpp/types/numeric limits/is iec559]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is integer</title>
    <ns>0</ns>
    <id>3062</id>
    <revision>
      <id>61870</id>
      <parentid>59420</parentid>
      <timestamp>2013-06-09T16:08:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2088">{{cpp/types/numeric_limits/title | is_integer}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_integer;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_integer;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_integer}} is {{c|true}} for all integer arithmetic types {{tt|T}} and {{c|false}} otherwise. This constant is meaningful for all specializations.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_integer}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|true}} }}
{{dsc | {{c|char}}              | {{c|true}} }}
{{dsc | {{c|signed char}}       | {{c|true}} }}
{{dsc | {{c|unsigned char}}     | {{c|true}} }}
{{dsc | {{c|wchar_t}}           | {{c|true}} }}
{{dsc | {{c|char16_t}}          | {{c|true}} }}
{{dsc | {{c|char32_t}}          | {{c|true}} }}
{{dsc | {{c|short}}             | {{c|true}} }}
{{dsc | {{c|unsigned short}}    | {{c|true}} }}
{{dsc | {{c|int}}               | {{c|true}} }}
{{dsc | {{c|unsigned int}}      | {{c|true}} }}
{{dsc | {{c|long}}              | {{c|true}} }}
{{dsc | {{c|unsigned long}}     | {{c|true}} }}
{{dsc | {{c|long long}}         | {{c|true}} }}
{{dsc | {{c|unsigned long long}}| {{c|true}} }}
{{dsc | {{c|float}}             | {{c|false}} }}
{{dsc | {{c|double}}            | {{c|false}} }}
{{dsc | {{c|long double}}       | {{c|false}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_integral}}
{{dsc inc | cpp/types/numeric_limits/dsc is_signed}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc inc | cpp/types/numeric_limits/dsc is_bounded}}
{{dsc end}}

[[de:cpp/types/numeric limits/is integer]]
[[es:cpp/types/numeric limits/is integer]]
[[fr:cpp/types/numeric limits/is integer]]
[[it:cpp/types/numeric limits/is integer]]
[[ja:cpp/types/numeric limits/is integer]]
[[pt:cpp/types/numeric limits/is integer]]
[[ru:cpp/types/numeric limits/is integer]]
[[zh:cpp/types/numeric limits/is integer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is modulo</title>
    <ns>0</ns>
    <id>3067</id>
    <revision>
      <id>61867</id>
      <parentid>59423</parentid>
      <timestamp>2013-06-09T16:08:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="3785">{{cpp/types/numeric_limits/title | is_modulo}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_modulo;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_modulo;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_modulo}} is {{c|true}} for all arithmetic types {{tt|T}} that handle overflows with modulo arithmetic, that is, if the result of addition, subtraction, multiplication, or division of this type would fall outside the range {{c|[min(), max()]}}, the value returned by such operation differs from the expected value by a multiple of {{c|max()-min()+1}}. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_modulo}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | implementation-defined }}
{{dsc | {{c|signed char}}       | implementation-defined }}
{{dsc | {{c|unsigned char}}     | {{c|true}} }}
{{dsc | {{c|wchar_t}}           | implementation-defined }}
{{dsc | {{c|char16_t}}          | implementation-defined }}
{{dsc | {{c|char32_t}}          | implementation-defined }}
{{dsc | {{c|short}}             | implementation-defined }}
{{dsc | {{c|unsigned short}}    | {{c|true}} }}
{{dsc | {{c|int}}               | implementation-defined }}
{{dsc | {{c|unsigned int}}      | {{c|true}} }}
{{dsc | {{c|long}}              | implementation-defined }}
{{dsc | {{c|unsigned long}}     | {{c|true}} }}
{{dsc | {{c|long long}}         | implementation-defined }}
{{dsc | {{c|unsigned long long}}| {{c|true}} }}
{{dsc | {{c|float}}             | {{c|false}} }}
{{dsc | {{c|double}}            | {{c|false}} }}
{{dsc | {{c|long double}}       | {{c|false}} }}
{{dsc end}}

===Notes===
Although the C++11 standard still says &quot;On most machines, this is true for signed integers.&quot;, the exact wording changed from C++03 to C++11 in such a way that the {{c|true}} value is no longer compatible with [[cpp/language/operator_arithmetic#Overflows|undefined behavior on signed integer overflow]] (it changed from &quot;possible&quot; to a strict requirement). Because of that, the implementations that rely on signed overflow being undefined (for optimization opportunities) now set {{tt|is_modulo}} to {{tt|false}} for signed integers. See for example [http://gcc.gnu.org/bugzilla/show_bug.cgi?id=22200 GCC PR 22200].

===Example===
{{example
 | Demonstrates the behavior of modulo types
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;limits&gt;

template&lt;class T&gt;
typename std::enable_if&lt;std::numeric_limits&lt;T&gt;::is_modulo&gt;::type
    check_overflow()
{
    std::cout &lt;&lt; &quot;\nmax value is &quot; &lt;&lt; std::numeric_limits&lt;T&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;min value is &quot; &lt;&lt; std::numeric_limits&lt;T&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;max value + 1 is &quot; &lt;&lt; std::numeric_limits&lt;T&gt;::max()+1 &lt;&lt; '\n';
}

int main()
{
    check_overflow&lt;int&gt;();
    check_overflow&lt;unsigned long&gt;();
    // check_overflow&lt;float&gt;(); // compile-time error, not a modulo type
}
 | p = true
 | output=
max value is 2147483647
min value is -2147483648
max value + 1 is -2147483648

max value is 18446744073709551615
min value is 0
max value + 1 is 0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_iec559}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc end}}

[[de:cpp/types/numeric limits/is modulo]]
[[es:cpp/types/numeric limits/is modulo]]
[[fr:cpp/types/numeric limits/is modulo]]
[[it:cpp/types/numeric limits/is modulo]]
[[ja:cpp/types/numeric limits/is modulo]]
[[pt:cpp/types/numeric limits/is modulo]]
[[ru:cpp/types/numeric limits/is modulo]]
[[zh:cpp/types/numeric limits/is modulo]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is signed</title>
    <ns>0</ns>
    <id>3061</id>
    <revision>
      <id>61871</id>
      <parentid>59426</parentid>
      <timestamp>2013-06-09T16:09:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2179">{{cpp/types/numeric_limits/title | is_signed}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_signed;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_signed;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_signed}} is {{c|true}} for all signed arithmetic types {{tt|T}} and {{c|false}} for the unsigned types. This constant is meaningful for all specializations.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_signed}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | implementation-defined }}
{{dsc | {{c|signed char}}       | {{c|true}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | implementation-defined }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|true}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|true}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|true}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|true}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | {{c|true}} }}
{{dsc | {{c|double}}            | {{c|true}} }}
{{dsc | {{c|long double}}       | {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc tclass | cpp/types/is_signed | checks if a type is signed integer type | notes={{mark c++11}}}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc inc | cpp/types/numeric_limits/dsc is_bounded}}
{{dsc end}}

[[de:cpp/types/numeric limits/is signed]]
[[es:cpp/types/numeric limits/is signed]]
[[fr:cpp/types/numeric limits/is signed]]
[[it:cpp/types/numeric limits/is signed]]
[[ja:cpp/types/numeric limits/is signed]]
[[pt:cpp/types/numeric limits/is signed]]
[[ru:cpp/types/numeric limits/is signed]]
[[zh:cpp/types/numeric limits/is signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/is specialized</title>
    <ns>0</ns>
    <id>3059</id>
    <revision>
      <id>61872</id>
      <parentid>59427</parentid>
      <timestamp>2013-06-09T16:09:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2117">{{cpp/types/numeric_limits/title | is_specialized}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool is_specialized;
}}
{{dcl | since=c++11 |1=
static constexpr bool is_specialized;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::is_specialized}} is {{c|true}} for all {{tt|T}} for which there exists a specialization of {{lc|std::numeric_limits}}.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::is_specialized}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|true}} }}
{{dsc | {{c|char}}              | {{c|true}} }}
{{dsc | {{c|signed char}}       | {{c|true}} }}
{{dsc | {{c|unsigned char}}     | {{c|true}} }}
{{dsc | {{c|wchar_t}}           | {{c|true}} }}
{{dsc | {{c|char16_t}}          | {{c|true}} }}
{{dsc | {{c|char32_t}}          | {{c|true}} }}
{{dsc | {{c|short}}             | {{c|true}} }}
{{dsc | {{c|unsigned short}}    | {{c|true}} }}
{{dsc | {{c|int}}               | {{c|true}} }}
{{dsc | {{c|unsigned int}}      | {{c|true}} }}
{{dsc | {{c|long}}              | {{c|true}} }}
{{dsc | {{c|unsigned long}}     | {{c|true}} }}
{{dsc | {{c|long long}}         | {{c|true}} }}
{{dsc | {{c|unsigned long long}}| {{c|true}} }}
{{dsc | {{c|float}}             | {{c|true}} }}
{{dsc | {{c|double}}            | {{c|true}} }}
{{dsc | {{c|long double}}       | {{c|true}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc is_integer}}
{{dsc inc | cpp/types/numeric_limits/dsc is_iec559}}
{{dsc inc | cpp/types/numeric_limits/dsc is_exact}}
{{dsc inc | cpp/types/numeric_limits/dsc is_bounded}}
{{dsc end}}

[[de:cpp/types/numeric limits/is specialized]]
[[es:cpp/types/numeric limits/is specialized]]
[[fr:cpp/types/numeric limits/is specialized]]
[[it:cpp/types/numeric limits/is specialized]]
[[ja:cpp/types/numeric limits/is specialized]]
[[pt:cpp/types/numeric limits/is specialized]]
[[ru:cpp/types/numeric limits/is specialized]]
[[zh:cpp/types/numeric limits/is specialized]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/lowest</title>
    <ns>0</ns>
    <id>3012</id>
    <revision>
      <id>64820</id>
      <parentid>63060</parentid>
      <timestamp>2013-08-27T01:13:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="4152">{{cpp/types/numeric_limits/title | lowest}}
{{cpp/types/numeric_limits/navbar}}

{{dcl begin}}
{{dcl | since=c++11 |1=
static constexpr T lowest() 
}}
{{dcl end}}

Returns the lowest finite value representable by the numeric type {{tt|T}}, that is, a finite value {{tt|x}} such that there is no other finite value {{tt|y}} where {{tt|y &lt; x}}. This is different from {{c|std::numeric_limits&lt;T&gt;::min()}} for floating-point types. Only meaningful for bounded types.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::lowest()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{lc|CHAR_MIN}}  }}
{{dsc | {{c|signed char}}       | {{lc|SCHAR_MIN}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}}         }}
{{dsc | {{c|wchar_t}}           | {{lc|WCHAR_MIN}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{lc|SHRT_MIN}}  }}
{{dsc | {{c|unsigned short}}    | {{c|0}}         }}
{{dsc | {{c|int}}               | {{lc|INT_MIN}}   }}
{{dsc | {{c|unsigned int}}      | {{c|0}}         }}
{{dsc | {{c|long}}              | {{lc|LONG_MIN}}  }}
{{dsc | {{c|unsigned long}}     | {{c|0}}         }}
{{dsc | {{c|long long}}         | {{lc|LLONG_MIN}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}}         }}
{{dsc | {{c|float}}             | {{c|-FLT_MAX}}   }}
{{dsc | {{c|double}}            | {{c|-DBL_MAX}}   }}
{{dsc | {{c|long double}}       | {{c|-LDBL_MAX}}  }}
{{dsc end}}

===Notes===
While it's not true for fundamental C++ floating-poing types, a third-party floating-point type {{tt|T}} may exist such that {{c|1=std::numeric_limits&lt;T&gt;::lowest() != -std::numeric_limits&lt;T&gt;::max()}}.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | Demonstrates min, max, and lowest for floating-point types
 | code=
#include &lt;limits&gt;
#include &lt;iostream&gt;
int main()
{
    
    std::cout &lt;&lt; &quot;std::numeric_limits&lt;T&gt;::min():\n&quot;
              &lt;&lt; &quot;\tfloat: &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;\tdouble: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;double&gt;::min()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;double&gt;::min() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::numeric_limits&lt;T&gt;::lowest():\n&quot;
              &lt;&lt; &quot;\tfloat: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;float&gt;::lowest()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;float&gt;::lowest() &lt;&lt; '\n'
              &lt;&lt; &quot;\tdouble: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;double&gt;::lowest()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;double&gt;::lowest() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;std::numeric_limits&lt;T&gt;::max():\n&quot;
              &lt;&lt; &quot;\tfloat: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;float&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;\tdouble: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;double&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;double&gt;::max() &lt;&lt; '\n';
}
 | output=
std::numeric_limits&lt;T&gt;::min():
        float: 1.17549e-38 or 0x1p-126
        double: 2.22507e-308 or 0x1p-1022
std::numeric_limits&lt;T&gt;::lowest():
        float: -3.40282e+38 or -0x1.fffffep+127
        double: -1.79769e+308 or -0x1.fffffffffffffp+1023
std::numeric_limits&lt;T&gt;::max():
        float: 3.40282e+38 or 0x1.fffffep+127
        double: 1.79769e+308 or 0x1.fffffffffffffp+1023
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min}}
{{dsc inc | cpp/types/numeric_limits/dsc denorm_min}}
{{dsc inc | cpp/types/numeric_limits/dsc max}}
{{dsc end}}

[[de:cpp/types/numeric limits/lowest]]
[[es:cpp/types/numeric limits/lowest]]
[[fr:cpp/types/numeric limits/lowest]]
[[it:cpp/types/numeric limits/lowest]]
[[ja:cpp/types/numeric limits/lowest]]
[[pt:cpp/types/numeric limits/lowest]]
[[ru:cpp/types/numeric limits/lowest]]
[[zh:cpp/types/numeric limits/lowest]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/max</title>
    <ns>0</ns>
    <id>3026</id>
    <revision>
      <id>64821</id>
      <parentid>61879</parentid>
      <timestamp>2013-08-27T01:13:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="3531">{{cpp/types/numeric_limits/title | max}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T max();
}}
{{dcl | since=c++11 |1=
static constexpr T max();
}}
{{dcl rev end}}
{{dcl end}}

Returns the maximum finite value representable by the numeric type {{tt|T}}. Meaningful for all bounded types.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::max()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|true}}     }}
{{dsc | {{c|char}}              | {{lc|CHAR_MAX}}  }}
{{dsc | {{c|signed char}}       | {{lc|SCHAR_MAX}} }}
{{dsc | {{c|unsigned char}}     | {{lc|UCHAR_MAX}} }}
{{dsc | {{c|wchar_t}}           | {{lc|WCHAR_MAX}} }}
{{dsc | {{c|char16_t}}          | {{lc|UINT_LEAST16_MAX}} }}
{{dsc | {{c|char32_t}}          | {{lc|UINT_LEAST32_MAX}} }}
{{dsc | {{c|short}}             | {{lc|SHRT_MAX}}  }}
{{dsc | {{c|unsigned short}}    | {{lc|USHRT_MAX}} }}
{{dsc | {{c|int}}               | {{lc|INT_MAX}}   }}
{{dsc | {{c|unsigned int}}      | {{lc|UINT_MAX}}  }}
{{dsc | {{c|long}}              | {{lc|LONG_MAX}}  }}
{{dsc | {{c|unsigned long}}     | {{lc|ULONG_MAX}} }}
{{dsc | {{c|long long}}         | {{lc|LLONG_MAX}} }}
{{dsc | {{c|unsigned long long}}| {{lc|ULLONG_MAX}}}}
{{dsc | {{c|float}}             | {{lc|FLT_MAX}}   }}
{{dsc | {{c|double}}            | {{lc|DBL_MAX}}   }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MAX}}  }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | Demonstrates the use of max() with some fundamental types and some standard library typedefs (the output is system-specific)
 | code=
#include &lt;limits&gt;
#include &lt;cstddef&gt;
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;short: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;short&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::showbase &lt;&lt; std::numeric_limits&lt;short&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;int: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;int&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::numeric_limits&lt;int&gt;::max() &lt;&lt; '\n' &lt;&lt; std::dec
              &lt;&lt; &quot;streamsize: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;std::streamsize&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::numeric_limits&lt;std::streamsize&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;size_t: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;std::size_t&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::numeric_limits&lt;std::size_t&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;float: &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;double: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;double&gt;::max()
              &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;double&gt;::max() &lt;&lt; '\n';
}
 | output=
short: 32767 or 0x7fff
int: 2147483647 or 0x7fffffff
size_t: 18446744073709551615 or 0xffffffffffffffff
streamsize: 9223372036854775807 or 0x7fffffffffffffff
float: 3.40282e+38 or 0x1.fffffep+127
double: 1.79769e+308 or 0x1.fffffffffffffp+1023
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc lowest}}
{{dsc inc | cpp/types/numeric_limits/dsc min}}
{{dsc end}}

[[de:cpp/types/numeric limits/max]]
[[es:cpp/types/numeric limits/max]]
[[fr:cpp/types/numeric limits/max]]
[[it:cpp/types/numeric limits/max]]
[[ja:cpp/types/numeric limits/max]]
[[pt:cpp/types/numeric limits/max]]
[[ru:cpp/types/numeric limits/max]]
[[zh:cpp/types/numeric limits/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/max digits10</title>
    <ns>0</ns>
    <id>3076</id>
    <revision>
      <id>63061</id>
      <parentid>59434</parentid>
      <timestamp>2013-07-01T23:53:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2786">{{cpp/types/numeric_limits/title | max_digits10}}
{{cpp/types/numeric_limits/navbar}}

{{dcl begin}}
{{dcl | since=c++11 |1=
static constexpr int max_digits10
}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::max_digits10}} is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type {{tt|T}}, such as necessary for serialization/deserialization to text. This constant is meaningful for all floating-point types. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::max_digits10}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{c|std::floor(std::numeric_limits&lt;float&gt;::digits * std::log10(2) + 2}}) }}
{{dsc | {{c|double}}            | {{c|std::floor(std::numeric_limits&lt;double&gt;::digits * std::log10(2) + 2}}) }}
{{dsc | {{c|long double}}       | {{c|std::floor(std::numeric_limits&lt;long double&gt;::digits * std::log10(2) + 2}}) }}
{{dsc end}}

===Notes===
Unlike most mathematical operations, the conversion of a floating-point value to text and back is ''exact'' as long as at least {{tt|max_digits10}} were used ({{c|9}} for {{c|float}}, {{c|17}} for {{c|double}}): it is guaranteed to produce the same floating-point value, even though the intermediate text representation is not exact. It may take over a hundred decimal digits to represent the precise value of a {{c|float}} in decimal notation.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc radix}}
{{dsc inc | cpp/types/numeric_limits/dsc digits}}
{{dsc inc | cpp/types/numeric_limits/dsc digits10}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc end}}

[[de:cpp/types/numeric limits/max digits10]]
[[es:cpp/types/numeric limits/max digits10]]
[[fr:cpp/types/numeric limits/max digits10]]
[[it:cpp/types/numeric limits/max digits10]]
[[ja:cpp/types/numeric limits/max digits10]]
[[pt:cpp/types/numeric limits/max digits10]]
[[ru:cpp/types/numeric limits/max digits10]]
[[zh:cpp/types/numeric limits/max digits10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/max exponent</title>
    <ns>0</ns>
    <id>3091</id>
    <revision>
      <id>67851</id>
      <parentid>67850</parentid>
      <timestamp>2014-03-03T06:00:52Z</timestamp>
      <contributor>
        <ip>177.9.13.218</ip>
      </contributor>
      <text xml:space="preserve" bytes="2707">{{cpp/types/numeric_limits/title | max_exponent}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int max_exponent;
}}
{{dcl | since=c++11 |1=
static constexpr int max_exponent;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::max_exponent}} is the largest positive number {{tt|n}} such that {{math|2{{su|p=n-1}}}} is a representable finite value of the floating-point type {{tt|T}}. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::max_exponent}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|FLT_MAX_EXP}} }}
{{dsc | {{c|double}}            | {{lc|DBL_MAX_EXP}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MAX_EXP}} }}
{{dsc end}}

===Example===
{{example
 | Demonstrates the relationships of max_exponent, max_exponent10, and max() for the type float:
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
int main()
{
    std::cout &lt;&lt; &quot;max() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;max_exponent10 = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max_exponent10 &lt;&lt; '\n'
              &lt;&lt; std::hexfloat
              &lt;&lt; &quot;max() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;max_exponent = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max_exponent &lt;&lt; '\n';
}

 | output=
max() = 3.40282e+38
max_exponent10 = 38
max() = 0x1.fffffep+127
max_exponent = 128
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent10}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent10}}
{{dsc end}}

[[de:cpp/types/numeric limits/max exponent]]
[[es:cpp/types/numeric limits/max exponent]]
[[fr:cpp/types/numeric limits/max exponent]]
[[it:cpp/types/numeric limits/max exponent]]
[[ja:cpp/types/numeric limits/max exponent]]
[[pt:cpp/types/numeric limits/max exponent]]
[[ru:cpp/types/numeric limits/max exponent]]
[[zh:cpp/types/numeric limits/max exponent]]</text>
      <sha1>9w0yurbyo0bgqtwqn65uhoms2kk0zcq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/max exponent10</title>
    <ns>0</ns>
    <id>3089</id>
    <revision>
      <id>61855</id>
      <parentid>59440</parentid>
      <timestamp>2013-06-09T16:05:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2723">{{cpp/types/numeric_limits/title | max_exponent10}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int max_exponent10;
}}
{{dcl | since=c++11 |1=
static constexpr int max_exponent10;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::max_exponent10}} is the largest positive number {{tt|n}} such that {{math|10{{su|p=n}}}} is a representable finite value of the floating-point type {{tt|T}}. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::max_exponent10}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|FLT_MAX_10_EXP}} }}
{{dsc | {{c|double}}            | {{lc|DBL_MAX_10_EXP}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MAX_10_EXP}} }}
{{dsc end}}

===Example===
{{example
 | Demonstrates the relationships of max_exponent, max_exponent10, and max() for the type float:
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;max() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;max_exponent10 = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max_exponent10 &lt;&lt; '\n'
              &lt;&lt; std::hexfloat
              &lt;&lt; &quot;max() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max() &lt;&lt; '\n'
              &lt;&lt; &quot;max_exponent = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::max_exponent &lt;&lt; '\n';
}

 | output=
max() = 3.40282e+38
max_exponent10 = 38
max() = 0x1.fffffep+127
max_exponent = 128
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent10}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent10}}
{{dsc end}}

[[de:cpp/types/numeric limits/max exponent10]]
[[es:cpp/types/numeric limits/max exponent10]]
[[fr:cpp/types/numeric limits/max exponent10]]
[[it:cpp/types/numeric limits/max exponent10]]
[[ja:cpp/types/numeric limits/max exponent10]]
[[pt:cpp/types/numeric limits/max exponent10]]
[[ru:cpp/types/numeric limits/max exponent10]]
[[zh:cpp/types/numeric limits/max exponent10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/min</title>
    <ns>0</ns>
    <id>3011</id>
    <revision>
      <id>63270</id>
      <parentid>61880</parentid>
      <timestamp>2013-07-08T15:49:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use rev in noexcept</comment>
      <text xml:space="preserve" bytes="3782">{{cpp/types/numeric_limits/title | min}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T min();
}}
{{dcl | since=c++11 |1=
static constexpr T min(); 
}}
{{dcl rev end}}
{{dcl end}}

Returns the minimum finite value representable by the numeric type {{tt|T}}.  

For floating-point types with denormalization, {{tt|min}} returns the minimum positive normalized value.  ''Note that this behavior may be unexpected'', especially when compared to the behavior of {{tt|min}} for integral types. To find the value that has no values less than it, use {{l2tt|cpp/types/numeric_limits/lowest}}.

{{tt|min}} is only meaningful for bounded types and for unbounded unsigned types, that is, types that represent an infinite set of negative values have no meaningful minimum.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::min()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{lc|CHAR_MIN}}  }}
{{dsc | {{c|signed char}}       | {{lc|SCHAR_MIN}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}}         }}
{{dsc | {{c|wchar_t}}           | {{lc|WCHAR_MIN}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{lc|SHRT_MIN}}  }}
{{dsc | {{c|unsigned short}}    | {{c|0}}         }}
{{dsc | {{c|int}}               | {{lc|INT_MIN}}   }}
{{dsc | {{c|unsigned int}}      | {{c|0}}         }}
{{dsc | {{c|long}}              | {{lc|LONG_MIN}}  }}
{{dsc | {{c|unsigned long}}     | {{c|0}}         }}
{{dsc | {{c|long long}}         | {{lc|LLONG_MIN}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}}         }}
{{dsc | {{c|float}}             | {{lc|FLT_MIN}}   }}
{{dsc | {{c|double}}            | {{lc|DBL_MIN}}   }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MIN}}  }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none) }}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | p=true
 | Demonstrates the use with typedef types, and the difference in the sign of the result between integer and floating-point types
 | code=
#include &lt;limits&gt;
#include &lt;cstddef&gt;
#include &lt;iostream&gt;

int main()
{
    std::cout 
        &lt;&lt; &quot;short: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;short&gt;::min()
        &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::showbase 
        &lt;&lt; std::numeric_limits&lt;short&gt;::min() &lt;&lt; '\n'

        &lt;&lt; &quot;int: &quot; &lt;&lt; std::dec &lt;&lt; std::numeric_limits&lt;int&gt;::min() &lt;&lt; std::showbase
        &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::numeric_limits&lt;int&gt;::min() &lt;&lt; '\n' &lt;&lt; std::dec 

        &lt;&lt; &quot;ptrdiff_t: &quot; &lt;&lt; std::numeric_limits&lt;std::ptrdiff_t&gt;::min() &lt;&lt; std::showbase
        &lt;&lt; &quot; or &quot; &lt;&lt; std::hex &lt;&lt; std::numeric_limits&lt;std::ptrdiff_t&gt;::min() &lt;&lt; '\n'

        &lt;&lt; &quot;float: &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min()
        &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'

        &lt;&lt; &quot;double: &quot; &lt;&lt; std::defaultfloat &lt;&lt; std::numeric_limits&lt;double&gt;::min()
        &lt;&lt; &quot; or &quot; &lt;&lt; std::hexfloat &lt;&lt; std::numeric_limits&lt;double&gt;::min() &lt;&lt; '\n';
}
 | output=
short: -32768 or 0x8000
int: -2147483648 or 0x80000000
ptrdiff_t: -9223372036854775808 or 0x8000000000000000
float: 1.17549e-38 or 0x1p-126
double: 2.22507e-308 or 0x1p-1022
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc lowest}}
{{dsc inc | cpp/types/numeric_limits/dsc denorm_min}}
{{dsc inc | cpp/types/numeric_limits/dsc max}}
{{dsc end}}

[[de:cpp/types/numeric limits/min]]
[[es:cpp/types/numeric limits/min]]
[[fr:cpp/types/numeric limits/min]]
[[it:cpp/types/numeric limits/min]]
[[ja:cpp/types/numeric limits/min]]
[[pt:cpp/types/numeric limits/min]]
[[ru:cpp/types/numeric limits/min]]
[[zh:cpp/types/numeric limits/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/min exponent</title>
    <ns>0</ns>
    <id>3090</id>
    <revision>
      <id>66137</id>
      <parentid>61854</parentid>
      <timestamp>2013-11-07T01:08:30Z</timestamp>
      <contributor>
        <ip>152.2.130.155</ip>
      </contributor>
      <comment>Fixed typo erroneously referring to min_exponent10.</comment>
      <text xml:space="preserve" bytes="2787">{{cpp/types/numeric_limits/title | min_exponent}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int min_exponent;
}}
{{dcl | since=c++11 |1=
static constexpr int min_exponent;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::min_exponent}} is the lowest negative number {{tt|n}} such that {{math|r{{su|p=n-1}}}}, where {{tt|r}} is {{c|std::numeric_limits&lt;T&gt;::radix}} is a valid normalized value of the floating-point type {{tt|T}}. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::min_exponent}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|FLT_MIN_EXP}} }}
{{dsc | {{c|double}}            | {{lc|DBL_MIN_EXP}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MIN_EXP}} }}
{{dsc end}}

===Example===
{{example
 | Demonstrates the relationships of min_exponent, min_exponent10, min, and radix for the type float:
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;min() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;min_exponent10 = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min_exponent10 &lt;&lt; '\n'
              &lt;&lt; std::hexfloat
              &lt;&lt; &quot;min() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;min_exponent = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min_exponent &lt;&lt; '\n';
}
 | output=
min() = 1.17549e-38
min_exponent10 = -37
min() = 0x1p-126
min_exponent = -125
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc radix}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent10}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent10}}
{{dsc end}}

[[de:cpp/types/numeric limits/min exponent]]
[[es:cpp/types/numeric limits/min exponent]]
[[fr:cpp/types/numeric limits/min exponent]]
[[it:cpp/types/numeric limits/min exponent]]
[[ja:cpp/types/numeric limits/min exponent]]
[[pt:cpp/types/numeric limits/min exponent]]
[[ru:cpp/types/numeric limits/min exponent]]
[[zh:cpp/types/numeric limits/min exponent]]</text>
      <sha1>2oe5ggdjht2s2jvishlyhl0mctaq58v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/min exponent10</title>
    <ns>0</ns>
    <id>3088</id>
    <revision>
      <id>61856</id>
      <parentid>59447</parentid>
      <timestamp>2013-06-09T16:06:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2715">{{cpp/types/numeric_limits/title | min_exponent10}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int min_exponent10;
}}
{{dcl | since=c++11 |1=
static constexpr int min_exponent10;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::min_exponent10}} is the lowest negative number {{tt|n}} such that {{math|10{{su|p=n}}}} is a valid normalized value of the floating-point type {{tt|T}}. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::min_exponent10}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|0}} }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|FLT_MIN_10_EXP}} }}
{{dsc | {{c|double}}            | {{lc|DBL_MIN_10_EXP}} }}
{{dsc | {{c|long double}}       | {{lc|LDBL_MIN_10_EXP}} }}
{{dsc end}}

===Example===
{{example
 | Demonstrates the relationships of min_exponent, min_exponent10, min, and radix for the type float:
 | code=
#include &lt;iostream&gt;
int main()
{
    std::cout &lt;&lt; &quot;min() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;min_exponent10 = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min_exponent10 &lt;&lt; '\n'
              &lt;&lt; std::hexfloat
              &lt;&lt; &quot;min() = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min() &lt;&lt; '\n'
              &lt;&lt; &quot;min_exponent = &quot; &lt;&lt; std::numeric_limits&lt;float&gt;::min_exponent &lt;&lt; '\n';
}
 | output=
min() = 1.17549e-38
min_exponent10 = -37
min() = 0x1p-126
min_exponent = -125
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent10}}
{{dsc end}}

[[de:cpp/types/numeric limits/min exponent10]]
[[es:cpp/types/numeric limits/min exponent10]]
[[fr:cpp/types/numeric limits/min exponent10]]
[[it:cpp/types/numeric limits/min exponent10]]
[[ja:cpp/types/numeric limits/min exponent10]]
[[pt:cpp/types/numeric limits/min exponent10]]
[[ru:cpp/types/numeric limits/min exponent10]]
[[zh:cpp/types/numeric limits/min exponent10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/quiet NaN</title>
    <ns>0</ns>
    <id>3057</id>
    <revision>
      <id>67235</id>
      <parentid>64826</parentid>
      <timestamp>2014-01-28T17:55:15Z</timestamp>
      <contributor>
        <ip>195.70.114.118</ip>
      </contributor>
      <comment>type, signaling</comment>
      <text xml:space="preserve" bytes="3264">{{cpp/types/numeric_limits/title | quiet_NaN}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T quiet_NaN();
}}
{{dcl | since=c++11 |1=
static constexpr T quiet_NaN();
}}
{{dcl rev end}}
{{dcl end}}

Returns the special value &quot;quiet [[enwiki:NaN|not-a-number]]&quot;, as represented by the floating-point type {{tt|T}}. Only meaningful if {{c|1=std::numeric_limits&lt;T&gt;::has_quiet_NaN == true}}. In IEEE 754, the most common binary representation of floating-point numbers, any value with all bits of the exponent set and at least one bit of the fraction set represents a NaN. It is implementation-defined which values of the fraction represent quiet or signaling NaNs, and whether the sign bit is meaningful.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::quiet_NaN()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{lc|NAN}} or another implementation-defined NaN }}
{{dsc | {{c|double}}            | implementation-defined }}
{{dsc | {{c|long double}}       | implementation-defined }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Notes===
A NaN never compares equal to itself. Copying a NaN may not preserve its bit representation.

===Example===
{{example
 | Several ways to generate a NaN (the output string is compiler-specific)
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
#include &lt;cmath&gt;

int main()
{
    std::cout &lt;&lt; std::numeric_limits&lt;double&gt;::quiet_NaN() &lt;&lt; ' '
              &lt;&lt; std::numeric_limits&lt;double&gt;::signaling_NaN() &lt;&lt; ' '
              &lt;&lt; std::acos(2) &lt;&lt; ' '
              &lt;&lt; std::tgamma(-1) &lt;&lt; ' '
              &lt;&lt; std::log(-1) &lt;&lt; ' '
              &lt;&lt; std::sqrt(-1) &lt;&lt; ' '
              &lt;&lt; 0 / 0.0 &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;NaN == NaN? &quot; &lt;&lt; std::boolalpha
              &lt;&lt; ( std::numeric_limits&lt;double&gt;::quiet_NaN()
                   == std::numeric_limits&lt;double&gt;::quiet_NaN() ) &lt;&lt; '\n';
}
 | output=
nan nan nan nan nan -nan -nan
NaN == NaN? false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_quiet_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc signaling_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/quiet NaN]]
[[es:cpp/types/numeric limits/quiet NaN]]
[[fr:cpp/types/numeric limits/quiet NaN]]
[[it:cpp/types/numeric limits/quiet NaN]]
[[ja:cpp/types/numeric limits/quiet NaN]]
[[pt:cpp/types/numeric limits/quiet NaN]]
[[ru:cpp/types/numeric limits/quiet NaN]]
[[zh:cpp/types/numeric limits/quiet NaN]]</text>
      <sha1>0eb4smrap4zbc9wrr4qrpnef0kexmgj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/radix</title>
    <ns>0</ns>
    <id>3073</id>
    <revision>
      <id>61865</id>
      <parentid>59451</parentid>
      <timestamp>2013-06-09T16:07:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="2180">{{cpp/types/numeric_limits/title | radix}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const int radix;
}}
{{dcl | since=c++11 |1=
static constexpr int radix;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::radix}} is the base of the number system used in the representation of the type. It is 2 for all binary numeric types, but it may be, for example, 10 for IEEE 754 [[enwiki:Decimal64 floating-point format|decimal floating-point types]] or for third-party [[enwiki:Binary-coded decimal|binary-coded decimal]] integers. This constant is meaningful for all specializations.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::radix}} }}
{{dsc | /* non-specialized */     | {{c|0}} }}
{{dsc | {{c|bool}}              | {{c|2}} }}
{{dsc | {{c|char}}              | {{c|2}} }}
{{dsc | {{c|signed char}}       | {{c|2}} }}
{{dsc | {{c|unsigned char}}     | {{c|2}} }}
{{dsc | {{c|wchar_t}}           | {{c|2}} }}
{{dsc | {{c|char16_t}}          | {{c|2}} }}
{{dsc | {{c|char32_t}}          | {{c|2}} }}
{{dsc | {{c|short}}             | {{c|2}} }}
{{dsc | {{c|unsigned short}}    | {{c|2}} }}
{{dsc | {{c|int}}               | {{c|2}} }}
{{dsc | {{c|unsigned int}}      | {{c|2}} }}
{{dsc | {{c|long}}              | {{c|2}} }}
{{dsc | {{c|unsigned long}}     | {{c|2}} }}
{{dsc | {{c|long long}}         | {{c|2}} }}
{{dsc | {{c|unsigned long long}}| {{c|2}} }}
{{dsc | {{c|float}}             | {{lc|FLT_RADIX}} }}
{{dsc | {{c|double}}            | {{lc|FLT_RADIX}} }}
{{dsc | {{c|long double}}       | {{lc|FLT_RADIX}} }}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc digits}}
{{dsc inc | cpp/types/numeric_limits/dsc min_exponent}}
{{dsc inc | cpp/types/numeric_limits/dsc max_exponent}}
{{dsc end}}

[[de:cpp/types/numeric limits/radix]]
[[es:cpp/types/numeric limits/radix]]
[[fr:cpp/types/numeric limits/radix]]
[[it:cpp/types/numeric limits/radix]]
[[ja:cpp/types/numeric limits/radix]]
[[pt:cpp/types/numeric limits/radix]]
[[ru:cpp/types/numeric limits/radix]]
[[zh:cpp/types/numeric limits/radix]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/round error</title>
    <ns>0</ns>
    <id>3028</id>
    <revision>
      <id>64823</id>
      <parentid>61877</parentid>
      <timestamp>2013-08-27T01:13:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="2096">{{cpp/types/numeric_limits/title | round_error}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T round_error();
}}
{{dcl | since=c++11 |1=
static constexpr T round_error();
}}
{{dcl rev end}}
{{dcl end}}

Returns the largest possible rounding error in ULPs (units in the last place) as defined by ISO 10967, which can vary from 0.5 (rounding to the nearest digit) to 1.0 (rounding to zero or to infinity). It is only meaningful if {{c|1=std::numeric_limits&lt;T&gt;::is_integer == false}}.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::round_error()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}       }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | {{c|0.5F}}   }}
{{dsc | {{c|double}}            | {{c|0.5}}   }}
{{dsc | {{c|long double}}       | {{c|0.5L}}  }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc round_style}}
{{dsc end}}

[[de:cpp/types/numeric limits/round error]]
[[es:cpp/types/numeric limits/round error]]
[[fr:cpp/types/numeric limits/round error]]
[[it:cpp/types/numeric limits/round error]]
[[ja:cpp/types/numeric limits/round error]]
[[pt:cpp/types/numeric limits/round error]]
[[ru:cpp/types/numeric limits/round error]]
[[zh:cpp/types/numeric limits/round error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/round style</title>
    <ns>0</ns>
    <id>3095</id>
    <revision>
      <id>71779</id>
      <parentid>61849</parentid>
      <timestamp>2014-06-23T22:19:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention that these are constants and do not reflect FLT_ROUNDS</comment>
      <text xml:space="preserve" bytes="3718">{{cpp/types/numeric_limits/title | round_style}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const std::float_round_style round_style
}}
{{dcl | since=c++11 |1=
static constexpr std::float_round_style round_style
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::round_stylem}} identifies the rounding style used by the floating-point type {{tt|T}} whenever a value that is not one of the exactly repesentable values of {{tt|T}} is stored in an object of that type.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::round_style}} }}
{{dsc | /* non-specialized */     | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|bool}}              | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|char}}              | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|signed char}}       | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|unsigned char}}     | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|wchar_t}}           | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|char16_t}}          | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|char32_t}}          | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|short}}             | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|unsigned short}}    | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|int}}               | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|unsigned int}}      | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|long}}              | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|unsigned long}}     | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|long long}}         | {{lc|std::round_toward_zero}} }}
{{dsc | {{c|unsigned long long}}| {{lc|std::round_toward_zero}} }}
{{dsc | {{c|float}}             | usually {{lc|std::round_to_nearest}} }}
{{dsc | {{c|double}}            | usually {{lc|std::round_to_nearest}} }}
{{dsc | {{c|long double}}       | usually {{lc|std::round_to_nearest}} }}
{{dsc end}}

===Notes===
These values are constants, and do not reflect the changes to the rounding made by {{lc|std::fesetround}}. The changed values may be obtained from {{lc|FLT_ROUNDS}} or {{lc|std::fegetround}}.

===Example===
The decimal value {{c|0.1}} cannot be represented by a binary floating-point type. When stored in an IEEE-745 {{c|double}}, it falls between {{math|0x1.9999999999999*2{{su|p=-4}}}} and {{math|0x1.999999999999a*2{{su|p=-4}}}}. Rounding to nearest representable value results in {{math|0x1.999999999999a*2{{su|p=-4}}}}. 

Similarly, the decimal value 0.3, which is between {{math|0x1.3333333333333*2{{su|p=-2}}}} and {{math|0x1.3333333333334*2{{su|p=-2}}}} is rounded to nearest and is stored as {{math|0x1.3333333333333*2{{su|p=-2}}}}.

{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
int main()
{
    std::cout &lt;&lt; std::hexfloat &lt;&lt; &quot;The decimal 0.1 is stored in a double as &quot;
              &lt;&lt; 0.1 &lt;&lt; '\n'
              &lt;&lt; &quot;The decimal 0.3 is stored in a double as &quot;
              &lt;&lt; 0.3 &lt;&lt; '\n'
              &lt;&lt; &quot;The rounding style is &quot; &lt;&lt; std::numeric_limits&lt;double&gt;::round_style &lt;&lt; '\n';
}
 | output=
The decimal 0.1 is stored in a double as 0x1.999999999999ap-4
The decimal 0.3 is stored in a double as 0x1.3333333333333p-2
The rounding style is 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc float_round_style}}
{{dsc end}}

[[de:cpp/types/numeric limits/round style]]
[[es:cpp/types/numeric limits/round style]]
[[fr:cpp/types/numeric limits/round style]]
[[it:cpp/types/numeric limits/round style]]
[[ja:cpp/types/numeric limits/round style]]
[[pt:cpp/types/numeric limits/round style]]
[[ru:cpp/types/numeric limits/round style]]
[[zh:cpp/types/numeric limits/round style]]</text>
      <sha1>4dwp2uarn7ip3bszitqos02ku5y1b50</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/signaling NaN</title>
    <ns>0</ns>
    <id>3058</id>
    <revision>
      <id>64827</id>
      <parentid>61873</parentid>
      <timestamp>2013-08-27T01:14:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="3812">{{cpp/types/numeric_limits/title | signaling_NaN}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static T signaling_NaN();
}}
{{dcl | since=c++11 |1=
static constexpr T signaling_NaN();
}}
{{dcl rev end}}
{{dcl end}}

Returns the special value &quot;signaling [[enwiki:NaN|not-a-number]]&quot;, as represented by the floating-point type {{tt|T}}. Only meaningful if {{c|1=std::numeric_limits&lt;T&gt;::has_signaling_NaN == true}}. In IEEE 754, the most common binary representation of floating-point numbers, any value with all bits of the exponent set and at least one bit of the fraction set represents a NaN. It is implementation-defined which values of the fraction represent quiet or signaling NaNs, and whether the sign bit is meaningful.

===Return value===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | {{c|std::numeric_limits&lt;T&gt;::quiet_NaN()}} }}
{{dsc | /* non-specialized */ | {{tt|T();}} }}
{{dsc | {{c|bool}}              | {{c|false}}     }}
{{dsc | {{c|char}}              | {{c|0}} }}
{{dsc | {{c|signed char}}       | {{c|0}} }}
{{dsc | {{c|unsigned char}}     | {{c|0}} }}
{{dsc | {{c|wchar_t}}           | {{c|0}} }}
{{dsc | {{c|char16_t}}          | {{c|0}} }}
{{dsc | {{c|char32_t}}          | {{c|0}} }}
{{dsc | {{c|short}}             | {{c|0}} }}
{{dsc | {{c|unsigned short}}    | {{c|0}} }}
{{dsc | {{c|int}}               | {{c|0}} }}
{{dsc | {{c|unsigned int}}      | {{c|0}} }}
{{dsc | {{c|long}}              | {{c|0}} }}
{{dsc | {{c|unsigned long}}     | {{c|0}} }}
{{dsc | {{c|long long}}         | {{c|0}} }}
{{dsc | {{c|unsigned long long}}| {{c|0}} }}
{{dsc | {{c|float}}             | implementation-defined }}
{{dsc | {{c|double}}            | implementation-defined }}
{{dsc | {{c|long double}}       | implementation-defined }}
{{dsc end}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Notes===
A NaN never compares equal to itself. Copying a NaN may not preserve its bit representation.

When a signaling NaN is used as an argument to an arithmetic expression, the appropriate floating-point exception may be raised and the NaN is &quot;quieted&quot;, that is, the expression returns a quiet NaN.

===Example===
{{example
 | Demonstrates the use of a signaling NaN to raise a floating-point exception
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
#include &lt;cfenv&gt;
#pragma STDC_FENV_ACCESS on
void show_fe_exceptions()
{
    int n = std::fetestexcept(FE_ALL_EXCEPT);
    if(n &amp; FE_INVALID) std::cout &lt;&lt; &quot;FE_INVALID is raised\n&quot;;
    else if(n == 0)    std::cout &lt;&lt; &quot;no exceptions are raised\n&quot;;
    std::feclearexcept(FE_ALL_EXCEPT);
}
int main()
{
    double snan = std::numeric_limits&lt;double&gt;::signaling_NaN();
    std::cout &lt;&lt; &quot;After sNaN was obtained &quot;;
    show_fe_exceptions();
    double qnan = snan * 2.0;
    std::cout &lt;&lt; &quot;After sNaN was multiplied by 2 &quot;;
    show_fe_exceptions();
    double qnan2 = qnan * 2.0;
    std::cout &lt;&lt; &quot;After the quieted NaN was multiplied by 2 &quot;;
    show_fe_exceptions();
    std::cout &lt;&lt; &quot;The result is &quot; &lt;&lt; qnan2 &lt;&lt; '\n';
}
 | output=
After sNaN was obtained no exceptions are raised
After sNaN was multiplied by 2 FE_INVALID is raised
After the quieted NaN was multiplied by 2 no exceptions are raised
The result is nan
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_signaling_NaN}}
{{dsc inc | cpp/types/numeric_limits/dsc quiet_NaN}}
{{dsc end}}

[[de:cpp/types/numeric limits/signaling NaN]]
[[es:cpp/types/numeric limits/signaling NaN]]
[[fr:cpp/types/numeric limits/signaling NaN]]
[[it:cpp/types/numeric limits/signaling NaN]]
[[ja:cpp/types/numeric limits/signaling NaN]]
[[pt:cpp/types/numeric limits/signaling NaN]]
[[ru:cpp/types/numeric limits/signaling NaN]]
[[zh:cpp/types/numeric limits/signaling NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/tinyness before</title>
    <ns>0</ns>
    <id>3081</id>
    <revision>
      <id>64090</id>
      <parentid>61858</parentid>
      <timestamp>2013-08-08T13:36:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>found a platform where this works</comment>
      <text xml:space="preserve" bytes="3974">{{cpp/types/numeric_limits/title | tinyness_before}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool tinyness_before;
}}
{{dcl | since=c++11 |1=
static constexpr bool tinyness_before;
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::tinyness_before}} is {{c|true}} for all floating-point types {{tt|T}} that test results of floating-point expressions for underflow before rounding.

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::tinyness_before}} }}
{{dsc | /* non-specialized */     | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | {{c|false}} }}
{{dsc | {{c|signed char}}       | {{c|false}} }}
{{dsc | {{c|unsigned char}}     | {{c|false}} }}
{{dsc | {{c|wchar_t}}           | {{c|false}} }}
{{dsc | {{c|char16_t}}          | {{c|false}} }}
{{dsc | {{c|char32_t}}          | {{c|false}} }}
{{dsc | {{c|short}}             | {{c|false}} }}
{{dsc | {{c|unsigned short}}    | {{c|false}} }}
{{dsc | {{c|int}}               | {{c|false}} }}
{{dsc | {{c|unsigned int}}      | {{c|false}} }}
{{dsc | {{c|long}}              | {{c|false}} }}
{{dsc | {{c|unsigned long}}     | {{c|false}} }}
{{dsc | {{c|long long}}         | {{c|false}} }}
{{dsc | {{c|unsigned long long}}| {{c|false}} }}
{{dsc | {{c|float}}             | implementation-defined }}
{{dsc | {{c|double}}            | implementation-defined }}
{{dsc | {{c|long double}}       | implementation-defined }}
{{dsc end}}

===Notes===
Standard-compliant IEEE 754 floating-point implementations may detect the floating-point underflow at three predefined moments:

1) after computation of a result with absolute value smaller than {{c|std::numeric_limits&lt;T&gt;::min()}}, such implementation detects tinyness before rounding (e.g. UltraSparc)

2) after rounding of the result to {{c|std::numeric_limits&lt;T&gt;::digits}} bits, if the result is tiny, such implementation detects tinyness after rounding (e.g. SuperSparc)

3) if the conversion of the rounded tiny result to subnormal form resulted in the loss of precision, such implementation detects denorm loss.

===Example===
{{example
 | Multiplication of the largest subnormal number by the number one machine epsilon greater than 1.0 gives the tiny value 0x0.fffffffffffff8p-1022 before rounding, but normal value 1p-1022 after rounding. The implementation used to execute this test (IBM Power7) detects tinyness before rounding.
 | code=
#include &lt;iostream&gt;
#include &lt;limits&gt;
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
int main()
{
    std::cout &lt;&lt; &quot;Tinyness before: &quot; &lt;&lt; std::boolalpha
              &lt;&lt; std::numeric_limits&lt;double&gt;::tinyness_before &lt;&lt; '\n';

    double denorm_max = std::nextafter(std::numeric_limits&lt;double&gt;::min(), 0);
    double multiplier = 1 + std::numeric_limits&lt;double&gt;::epsilon();

    std::feclearexcept(FE_ALL_EXCEPT);

    double result = denorm_max*multiplier; // Underflow only if tinyness_before

    if(std::fetestexcept(FE_UNDERFLOW))
        std::cout &lt;&lt; &quot;Underflow detected\n&quot;;
    else if (std::fetestexcept(FE_INEXACT))
        std::cout &lt;&lt; &quot;Inexact result detected\n&quot;;

    std::cout &lt;&lt; std::hexfloat &lt;&lt; denorm_max &lt;&lt; &quot; x &quot; &lt;&lt; multiplier  &lt;&lt;  &quot; = &quot;
              &lt;&lt; result &lt;&lt; '\n';
}
 | p=true
 | output=
Tinyness before: true
Underflow detected
0xf.ffffffffffffp-1030 x 0x1.0000000000001p+0 = 0x1p-1022
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm_loss}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm}}
{{dsc end}}

[[de:cpp/types/numeric limits/tinyness before]]
[[es:cpp/types/numeric limits/tinyness before]]
[[fr:cpp/types/numeric limits/tinyness before]]
[[it:cpp/types/numeric limits/tinyness before]]
[[ja:cpp/types/numeric limits/tinyness before]]
[[pt:cpp/types/numeric limits/tinyness before]]
[[ru:cpp/types/numeric limits/tinyness before]]
[[zh:cpp/types/numeric limits/tinyness before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/numeric limits/traps</title>
    <ns>0</ns>
    <id>3068</id>
    <revision>
      <id>61866</id>
      <parentid>59462</parentid>
      <timestamp>2013-06-09T16:08:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="3051">{{cpp/types/numeric_limits/title | traps}}
{{cpp/types/numeric_limits/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |1=
static const bool traps
}}
{{dcl | since=c++11 |1=
static constexpr bool traps
}}
{{dcl rev end}}
{{dcl end}}

The value of {{c|std::numeric_limits&lt;T&gt;::traps}} is {{c|true}} for all arithmetic types {{tt|T}} that have at least one value that, if used as an argument to an arithmetic operation, will generate a [[enwiki:Trap (computing)|trap]]. 

===Standard specializations===
{{dsc begin}}
{{dsc hitem | {{tt|T}} | value of {{c|std::numeric_limits&lt;T&gt;::traps}} }}
{{dsc | /* non-specialized */ | {{c|false}} }}
{{dsc | {{c|bool}}              | {{c|false}} }}
{{dsc | {{c|char}}              | usually {{c|true}} }}
{{dsc | {{c|signed char}}       | usually {{c|true}} }}
{{dsc | {{c|unsigned char}}     | usually {{c|true}} }}
{{dsc | {{c|wchar_t}}           | usually {{c|true}} }}
{{dsc | {{c|char16_t}}          | usually {{c|true}} }}
{{dsc | {{c|char32_t}}          | usually {{c|true}} }}
{{dsc | {{c|short}}             | usually {{c|true}} }}
{{dsc | {{c|unsigned short}}    | usually {{c|true}} }}
{{dsc | {{c|int}}               | usually {{c|true}} }}
{{dsc | {{c|unsigned int}}      | usually {{c|true}} }}
{{dsc | {{c|long}}              | usually {{c|true}} }}
{{dsc | {{c|unsigned long}}     | usually {{c|true}} }}
{{dsc | {{c|long long}}         | usually {{c|true}} }}
{{dsc | {{c|unsigned long long}}| usually {{c|true}} }}
{{dsc | {{c|float}}             | usually {{c|false}} }}
{{dsc | {{c|double}}            | usually {{c|false}} }}
{{dsc | {{c|long double}}       | usually {{c|false}} }}
{{dsc end}}

===Notes===
On most platforms integer division by zero always traps, and {{c|std::numeric_limits&lt;T&gt;::traps}} is {{c|true}} for all integer types that support the value 0. The exception is the type {{c|bool}}: even though division by {{c|false}} traps due to integral promotion from {{c|bool}} to {{c|int}}, it is the zero-valued {{c|int}} that traps. Zero is not a value of type {{c|bool}}.

On most platforms, floating-point exceptions may be turned on and off at run time (e.g. {{c|feenableexcept()}} on Linux or {{c|_controlfp}} on Windows), in which case the value of {{c|std::numeric_limits&lt;T&gt;::traps}} for floating-point types reflects the state of floating-point trapping facility at the time of program startup, which is {{c|false}} on most modern systems. An exception would be a DEC Alpha program, where it is {{c|true}} if compiled without {{tt|-ieee}}.


===See also===
{{dsc begin}}
{{dsc | [[cpp/numeric/fenv|Floating-point environment]]}}
{{dsc inc | cpp/types/numeric_limits/dsc tinyness_before}}
{{dsc inc | cpp/types/numeric_limits/dsc has_denorm_loss}}
{{dsc end}}

[[de:cpp/types/numeric limits/traps]]
[[es:cpp/types/numeric limits/traps]]
[[fr:cpp/types/numeric limits/traps]]
[[it:cpp/types/numeric limits/traps]]
[[ja:cpp/types/numeric limits/traps]]
[[pt:cpp/types/numeric limits/traps]]
[[ru:cpp/types/numeric limits/traps]]
[[zh:cpp/types/numeric limits/traps]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/offsetof</title>
    <ns>0</ns>
    <id>3266</id>
    <revision>
      <id>70955</id>
      <parentid>70457</parentid>
      <timestamp>2014-06-04T12:45:42Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1624">{{title|offsetof}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl |
#define offsetof(type, member) /*implementation-defined*/
}}
{{dcl end}}

The macro {{lc|offsetof}} expands to a constant of type {{lc|std::size_t}}, the value of which is the offset, in bytes, from the beginning of an object of specified type to its specified member, including padding if any.

If {{tt|type}} is not a [[cpp/language/data_members#Standard layout|standard layout type]], the behavior is undefined.

If {{tt|member}} is a [[cpp/language/static|static member]] or a [[cpp/language/member_functions|member function]], the behavior is undefined.

The offset of the first member of a standard-layout type is always zero ([[cpp/language/ebo|empty-base optimization]] is mandatory)

===Possible implementation===
{{eq fun
 | 1=
#define offsetof(type,member) ((std::size_t) &amp;(((type*)0)-&gt;member))
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cstddef&gt;
struct S {
    char c;
    double d;
};
int main()
{
    std::cout &lt;&lt; &quot;the first element is at offset &quot; &lt;&lt; offsetof(S, c) &lt;&lt; '\n'
              &lt;&lt; &quot;the double is at offset &quot; &lt;&lt; offsetof(S, d) &lt;&lt; '\n';
}
 | p=true
 | output=
the first element is at offset 0
the double is at offset 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/types/dsc is_standard_layout}}
{{dsc see c | c/types/offsetof}}
{{dsc end}}

[[de:cpp/types/offsetof]]
[[es:cpp/types/offsetof]]
[[fr:cpp/types/offsetof]]
[[it:cpp/types/offsetof]]
[[ja:cpp/types/offsetof]]
[[pt:cpp/types/offsetof]]
[[ru:cpp/types/offsetof]]
[[zh:cpp/types/offsetof]]</text>
      <sha1>c4w0gfsje89n4q5zurnq4zvtlsnvpfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/ptrdiff t</title>
    <ns>0</ns>
    <id>3265</id>
    <revision>
      <id>70952</id>
      <parentid>59466</parentid>
      <timestamp>2014-06-04T12:36:15Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1972">{{cpp/title|ptrdiff_t}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl |
typedef /*implementation-defined*/ ptrdiff_t;
}}
{{dcl end}}

{{lc|std::ptrdiff_t}} is the signed integer type of the result of subtracting two pointers.

===Notes===
{{lc|std::ptrdiff_t}} is used for pointer arithmetic and array indexing, if negative values are possible. Programs that use other types, such as {{c|int}}, may fail on, e.g. 64-bit systems when the index exceeds {{lc|INT_MAX}} or if it relies on 32-bit modular arithmetic.

When working with the C++ container library, the proper type for the difference between iterators is the member typedef {{c|difference_type}}, which is often synonymous with {{lc|std::ptrdiff_t}}.

Only pointers to elements of the same array (including the pointer one past the end of the array) may be subtracted from each other. 

If an array is so large (greater than {{lc|PTRDIFF_MAX}} elements, but less than {{lc|SIZE_MAX}} bytes), that the difference between two pointers may not be representable as {{lc|std::ptrdiff_t}}, the result of subtracting two such pointers is undefined.

For char arrays shorter than {{lc|PTRDIFF_MAX}}, {{lc|std::ptrdiff_t}} acts as the signed counterpart of {{lc|std::size_t}}: it can store the size of the array of any type and is, on most platforms, synonymous with {{lc|std::intptr_t}}).

===Example===
{{example
 | 
 | code=
#include &lt;cstddef&gt;

int main()
{
    const std::size_t N = 100;
    int* a = new int[N];
    int* end = a + N;
    for (std::ptrdiff_t i = N; i &gt; 0; --i)
        *(end - i) = i;
    delete[] a;
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc size_t}}
{{dsc inc | cpp/types/dsc offsetof}}
{{dsc see c | c/types/ptrdiff_t}}
{{dsc end}}

[[de:cpp/types/ptrdiff t]]
[[es:cpp/types/ptrdiff t]]
[[fr:cpp/types/ptrdiff t]]
[[it:cpp/types/ptrdiff t]]
[[ja:cpp/types/ptrdiff t]]
[[pt:cpp/types/ptrdiff t]]
[[ru:cpp/types/ptrdiff t]]
[[zh:cpp/types/ptrdiff t]]</text>
      <sha1>kk44v2sntqk25kvh7oav8t6fzvgmyq2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/rank</title>
    <ns>0</ns>
    <id>2717</id>
    <revision>
      <id>70296</id>
      <parentid>63062</parentid>
      <timestamp>2014-05-17T17:58:09Z</timestamp>
      <contributor>
        <ip>118.236.225.79</ip>
      </contributor>
      <comment>Fix Possible implementation</comment>
      <text xml:space="preserve" bytes="1432">{{cpp/title|rank}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct rank;
}}
{{dcl end}}

If {{tt|T}} is an array type, provides the member constant {{tt|value}} equal to the number of dimensions of the array. For any other type, {{tt|value}} is 0.

{{cpp/types/integral_constant/inherit2 |the number of dimensions of {{tt|T}} or zero|std::size_t}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct rank : public std::integral_constant&lt;std::size_t, 0&gt; {};

template&lt;class T&gt;
struct rank&lt;T[]&gt; : public std::integral_constant&lt;std::size_t, rank&lt;T&gt;::value + 1&gt; {};

template&lt;class T, std::size_t N&gt;
struct rank&lt;T[N]&gt; : public std::integral_constant&lt;std::size_t, rank&lt;T&gt;::value + 1&gt; {};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

int main()
{
    std::cout &lt;&lt; std::rank&lt;int[1][2][3]&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::rank&lt;int[][2][3][4]&gt;::value &lt;&lt; '\n';
    std::cout &lt;&lt; std::rank&lt;int&gt;::value &lt;&lt; '\n';
}
 | output=
3
4
0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}
{{dsc end}}

[[de:cpp/types/rank]]
[[es:cpp/types/rank]]
[[fr:cpp/types/rank]]
[[it:cpp/types/rank]]
[[ja:cpp/types/rank]]
[[pt:cpp/types/rank]]
[[ru:cpp/types/rank]]
[[zh:cpp/types/rank]]</text>
      <sha1>8pe338iefo8hmnhn23vmh5nt6fxhwyl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove all extents</title>
    <ns>0</ns>
    <id>2720</id>
    <revision>
      <id>63063</id>
      <parentid>59470</parentid>
      <timestamp>2013-07-01T23:53:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1993">{{cpp/title|remove_all_extents}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct remove_all_extents;
}}
{{dcl end}}

If {{tt|T}} is a multidimensional array of some type {{tt|X}}, provides the member typedef {{tt|type}} equal to {{tt|X}}, otherwise {{tt|type}} is {{tt|T}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type of the element of {{tt|T}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_all_extents_t = typename remove_all_extents&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct remove_all_extents { typedef T type;};

template&lt;class T&gt;
struct remove_all_extents&lt;T[]&gt; {
    typedef typename remove_all_extents&lt;T&gt;::type type;
};

template&lt;class Tp, std::size_t N&gt;
struct remove_all_extents&lt;T[N]&gt; {
    typedef typename remove_all_extents&lt;T&gt;::type type;
};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;typeinfo&gt;

template&lt;class A&gt;
void foo(const A&amp;)
{
    typedef typename std::remove_all_extents&lt;A&gt;::type Type;
    std::cout &lt;&lt; &quot;underlying type: &quot; &lt;&lt; typeid(Type).name() &lt;&lt; '\n';
}

int main()
{
    float a1[1][2][3];
    int a2[3][2];
    float a3[1][1][1][1][2];
    double a4[2][3];
 
    foo(a1);
    foo(a2);
    foo(a3);
    foo(a4);
}
 | output=
underlying type: f
underlying type: i
underlying type: f
underlying type: d
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc inc | cpp/types/dsc remove_extent}}
{{dsc end}}

[[de:cpp/types/remove all extents]]
[[es:cpp/types/remove all extents]]
[[fr:cpp/types/remove all extents]]
[[it:cpp/types/remove all extents]]
[[ja:cpp/types/remove all extents]]
[[pt:cpp/types/remove all extents]]
[[ru:cpp/types/remove all extents]]
[[zh:cpp/types/remove all extents]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove const</title>
    <ns>0</ns>
    <id>4239</id>
    <redirect title="cpp/types/remove cv" />
    <revision>
      <id>15338</id>
      <timestamp>2011-12-08T15:35:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/remove cv]]</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/types/remove_cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove cv</title>
    <ns>0</ns>
    <id>3280</id>
    <revision>
      <id>63064</id>
      <parentid>59471</parentid>
      <timestamp>2013-07-01T23:53:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="3096">{{cpp/title|remove_cv|remove_const|remove_volatile}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class T &gt;
struct remove_cv;
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class T &gt;
struct remove_const;
}}
{{dcl | since=c++11 | num=3 | 1=
template&lt; class T &gt;
struct remove_volatile;
}}
{{dcl end}}

Provides the member typedef {{tt|type}} which is the same as {{tt|T}}, except that its topmost cv-qualifiers are removed.

1) removes the topmost {{c|const}}, the topmost {{c|volatile}}, or both, if present.

2) removes the topmost {{c|const}}

3) removes the topmost {{c|volatile}}

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type {{tt|T}} without cv-qualifier }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_cv_t       = typename remove_cv&lt;T&gt;::type;
}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_const_t    = typename remove_const&lt;T&gt;::type;
}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_volatile_t = typename remove_volatile&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt;
struct remove_cv {
    typedef typename std::remove_volatile&lt;typename std::remove_const&lt;T&gt;::type&gt;::type type;
};

template&lt; class T &gt; struct remove_const          { typedef T type; };
template&lt; class T &gt; struct remove_const&lt;const T&gt; { typedef T type; };

template&lt; class T &gt; struct remove_volatile             { typedef T type; };
template&lt; class T &gt; struct remove_volatile&lt;volatile T&gt; { typedef T type; };
}}

===Example===
{{example
 | Removing const/volatile from {{c|const volatile int *}} does not modify the type, because the pointer itself is neither const nor volatile.
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
 
int main() {
    typedef std::remove_cv&lt;const int&gt;::type type1;
    typedef std::remove_cv&lt;volatile int&gt;::type type2;
    typedef std::remove_cv&lt;const volatile int&gt;::type type3;
    typedef std::remove_cv&lt;const volatile int*&gt;::type type4;
    typedef std::remove_cv&lt;int * const volatile&gt;::type type5;
 
    std::cout &lt;&lt; &quot;test1 &quot; &lt;&lt; (std::is_same&lt;int, type1&gt;::value
        ? &quot;passed&quot; : &quot;failed&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;test2 &quot; &lt;&lt; (std::is_same&lt;int, type2&gt;::value
        ? &quot;passed&quot; : &quot;failed&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;test3 &quot; &lt;&lt; (std::is_same&lt;int, type3&gt;::value
        ? &quot;passed&quot; : &quot;failed&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;test4 &quot; &lt;&lt; (std::is_same&lt;const volatile int*, type4&gt;::value
        ? &quot;passed&quot; : &quot;failed&quot;) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;test5 &quot; &lt;&lt; (std::is_same&lt;int*, type5&gt;::value
        ? &quot;passed&quot; : &quot;failed&quot;) &lt;&lt; '\n';
}
 | output=
test1 passed
test2 passed
test3 passed
test4 passed
test5 passed
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_const}}
{{dsc inc | cpp/types/dsc is_volatile}}
{{dsc end}}

[[de:cpp/types/remove cv]]
[[es:cpp/types/remove cv]]
[[fr:cpp/types/remove cv]]
[[it:cpp/types/remove cv]]
[[ja:cpp/types/remove cv]]
[[pt:cpp/types/remove cv]]
[[ru:cpp/types/remove cv]]
[[zh:cpp/types/remove cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove extent</title>
    <ns>0</ns>
    <id>2721</id>
    <revision>
      <id>63065</id>
      <parentid>59474</parentid>
      <timestamp>2013-07-01T23:53:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1888">{{cpp/title|remove_extent}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct remove_extent;
}}
{{dcl end}}

If {{tt|T}} is an array of some type {{tt|X}}, provides the member typedef {{tt|type}} equal to {{tt|X}}, otherwise {{tt|type}} is {{tt|T}}. Note that if T is a multidimensional array, only the first dimension is removed.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type of the element of {{tt|T}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_extent_t = typename remove_extent&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;class T&gt;
struct remove_extent { typedef T type; };

template&lt;class T&gt;
struct remove_extent&lt;T[]&gt; { typedef T type; };

template&lt;class T, std::size_t N&gt;
struct remove_extent&lt;T[N]&gt; { typedef T type;};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;type_traits&gt;

template&lt;class A&gt;
typename std::enable_if&lt; std::rank&lt;A&gt;::value == 1 &gt;::type
print_1d(const A&amp; a)
{
    copy(a, a+std::extent&lt;A&gt;::value,
         std::ostream_iterator&lt;typename std::remove_extent&lt;A&gt;::type&gt;(std::cout, &quot; &quot;));
    std::cout &lt;&lt; '\n';
}

int main()
{
    int a[][3] = {{1,2,3},{4,5,6}};
//  print_1d(a); // compile-time error
    print_1d(a[1]);
}
 | output=
4 5 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_array}}
{{dsc inc | cpp/types/dsc rank}}
{{dsc inc | cpp/types/dsc extent}}
{{dsc inc | cpp/types/dsc remove_all_extents}}
{{dsc end}}

[[de:cpp/types/remove extent]]
[[es:cpp/types/remove extent]]
[[fr:cpp/types/remove extent]]
[[it:cpp/types/remove extent]]
[[ja:cpp/types/remove extent]]
[[pt:cpp/types/remove extent]]
[[ru:cpp/types/remove extent]]
[[zh:cpp/types/remove extent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove pointer</title>
    <ns>0</ns>
    <id>3284</id>
    <revision>
      <id>65058</id>
      <parentid>64905</parentid>
      <timestamp>2013-08-30T14:58:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>spacing, reduce clutter a bit</comment>
      <text xml:space="preserve" bytes="2477">{{cpp/title|remove_pointer}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct remove_pointer;
}}
{{dcl end}}

Provides the member typedef {{tt|type}} which is the type pointed to by {{tt|T}}, or, if {{tt|T}} is not a pointer, then {{tt|type}} is the same as {{tt|T}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type pointed to by {{tt|T}} or {{tt|T}} if it's not a pointer}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_pointer_t = typename remove_pointer&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt; struct remove_pointer                    {typedef T type;};
template&lt; class T &gt; struct remove_pointer&lt;T*&gt;                {typedef T type;};
template&lt; class T &gt; struct remove_pointer&lt;T* const&gt;          {typedef T type;};
template&lt; class T &gt; struct remove_pointer&lt;T* volatile&gt;       {typedef T type;};
template&lt; class T &gt; struct remove_pointer&lt;T* const volatile&gt; {typedef T type;};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

template&lt;class T1, class T2&gt;
void print_is_same() 
{
    std::cout &lt;&lt; std::is_same&lt;T1, T2&gt;() &lt;&lt; '\n';
}

void print_separator() 
{
    std::cout &lt;&lt; &quot;-----\n&quot;;
}

int main() 
{
    std::cout &lt;&lt; std::boolalpha;

    print_is_same&lt;int, int&gt;();   // true
    print_is_same&lt;int, int*&gt;();  // false
    print_is_same&lt;int, int**&gt;(); // false

    print_separator();

    print_is_same&lt;int, std::remove_pointer&lt;int&gt;::type&gt;();   // true
    print_is_same&lt;int, std::remove_pointer&lt;int*&gt;::type&gt;();  // true
    print_is_same&lt;int, std::remove_pointer&lt;int**&gt;::type&gt;(); // false

    print_separator();

    print_is_same&lt;int, std::remove_pointer&lt;int* const&gt;::type&gt;();          // true
    print_is_same&lt;int, std::remove_pointer&lt;int* volatile&gt;::type&gt;();       // true
    print_is_same&lt;int, std::remove_pointer&lt;int* const volatile&gt;::type&gt;(); // true
}
 | output=
true
false
false
-----
true
true
false
-----
true
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_pointer}}
{{dsc inc | cpp/types/dsc add_pointer}}
{{dsc end}}

[[de:cpp/types/remove pointer]]
[[es:cpp/types/remove pointer]]
[[fr:cpp/types/remove pointer]]
[[it:cpp/types/remove pointer]]
[[ja:cpp/types/remove pointer]]
[[pt:cpp/types/remove pointer]]
[[ru:cpp/types/remove pointer]]
[[zh:cpp/types/remove pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove reference</title>
    <ns>0</ns>
    <id>3286</id>
    <revision>
      <id>63625</id>
      <parentid>63620</parentid>
      <timestamp>2013-07-11T14:18:53Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>minor formatting</comment>
      <text xml:space="preserve" bytes="1953">{{cpp/title|remove_reference}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct remove_reference;
}}
{{dcl end}}
If the type {{tt|T}} is a reference type, provides the member typedef {{tt|type}} which is the type referred to by {{tt|T}}. Otherwise {{tt|type}} is {{tt|T}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the type referred by {{tt|T}} or {{tt|T}} if it is not a reference}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using remove_reference_t = typename remove_reference&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; class T &gt; struct remove_reference      {typedef T type;};
template&lt; class T &gt; struct remove_reference&lt;T&amp;&gt;  {typedef T type;};
template&lt; class T &gt; struct remove_reference&lt;T&amp;&amp;&gt; {typedef T type;};
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt; // std::cout
#include &lt;type_traits&gt; // std::is_same

template&lt;class T1, class T2&gt;
void print_is_same() {
  std::cout &lt;&lt; std::is_same&lt;T1, T2&gt;() &lt;&lt; '\n';
}

int main() {
  std::cout &lt;&lt; std::boolalpha;

  print_is_same&lt;int, int&gt;();    // true
  print_is_same&lt;int, int &amp;&gt;();  // false
  print_is_same&lt;int, int &amp;&amp;&gt;(); // false

  print_is_same&lt;int, std::remove_reference&lt;int&gt;::type&gt;();    // true
  print_is_same&lt;int, std::remove_reference&lt;int &amp;&gt;::type&gt;();  // true
  print_is_same&lt;int, std::remove_reference&lt;int &amp;&amp;&gt;::type&gt;(); // true
}
 | output=
true
false
false
true
true
true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc is_reference}}
{{dsc inc | cpp/types/dsc add_reference}}
{{dsc end}}

[[de:cpp/types/remove reference]]
[[es:cpp/types/remove reference]]
[[fr:cpp/types/remove reference]]
[[it:cpp/types/remove reference]]
[[ja:cpp/types/remove reference]]
[[pt:cpp/types/remove reference]]
[[ru:cpp/types/remove reference]]
[[zh:cpp/types/remove reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/remove volatile</title>
    <ns>0</ns>
    <id>4240</id>
    <redirect title="cpp/types/remove cv" />
    <revision>
      <id>15339</id>
      <timestamp>2011-12-08T15:35:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/types/remove cv]]</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/types/remove_cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/result of</title>
    <ns>0</ns>
    <id>2670</id>
    <revision>
      <id>72239</id>
      <parentid>72189</parentid>
      <timestamp>2014-07-27T17:11:20Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Possible implementation */ fix a bug when ObjectRef has an overloaded indirect operator that return itself</comment>
      <text xml:space="preserve" bytes="5708">{{cpp/title|result_of}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | num=1 | since=c++11 |
template&lt; class &gt;
class result_of; //not defined
}}
{{dcl | num=2 | since=c++11 |
template&lt; class F, class... ArgTypes &gt;
class result_of&lt;F(ArgTypes...)&gt;;
}}
{{dcl end}}

Deduces the return type of a function call expression at compile time.

{{rev begin}}
{{rev |since=c++11|
{{tt|F}} must be a callable type, reference to function, or reference to callable type. Invoking {{tt|F}} with {{tt|ArgTypes...}} must be a well-formed expression }}
{{rev |since=c++14|
{{tt|F}} and all types in {{tt|ArgTypes}} can be any complete type, array of unknown bound, or (cv-qualified) void }}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | &lt;code&gt;type&lt;/code&gt; | the return type of the {{concept|Callable}} type &lt;code&gt;F&lt;/code&gt; if invoked with the arguments &lt;code&gt;ArgTypes...&lt;/code&gt;. {{rev inl|since=c++14|Only defined if F can be called with the arguments ArgTypes... in unevaluated context.}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using result_of_t = typename result_of&lt;T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{source|1=
template &lt;class&gt; struct result_of;

namespace detail {
template &lt;class F, class... Args&gt;
inline auto INVOKE(F&amp;&amp; f, Args&amp;&amp;... args) -&gt;
    decltype(forward&lt;F&gt;(f)(forward&lt;Args&gt;(args)...)) {
      return forward&lt;F&gt;(f)(forward&lt;Args&gt;(args)...);
}

template &lt;class Base, class T, class Derived&gt;
inline auto INVOKE(T Base::*&amp;&amp; pmd, Derived&amp;&amp; ref) -&gt;
    decltype(forward&lt;Derived&gt;(ref).*forward&lt;T Base::*&gt;(pmd)) {
      return forward&lt;Derived&gt;(ref).*forward&lt;T Base::*&gt;(pmd);
}

template &lt;class PMD, class Pointer&gt;
inline auto INVOKE(PMD&amp;&amp; pmd, Pointer&amp;&amp; ptr) -&gt;
    decltype((*forward&lt;Pointer&gt;(ptr)).*forward&lt;PMD&gt;(pmd)) {
      return (*forward&lt;Pointer&gt;(ptr)).*forward&lt;PMD&gt;(pmd);
}

template &lt;class Base, class T, class Derived, class... Args&gt;
inline auto INVOKE(T Base::*&amp;&amp; pmf, Derived&amp;&amp; ref, Args&amp;&amp;... args) -&gt;
    decltype((forward&lt;Derived&gt;(ref).*forward&lt;T Base::*&gt;(pmf))(forward&lt;Args&gt;(args)...)) {
      return (forward&lt;Derived&gt;(ref).*forward&lt;T Base::*&gt;(pmf))(forward&lt;Args&gt;(args)...);
}

template &lt;class PMF, class Pointer, class... Args&gt;
inline auto INVOKE(PMF&amp;&amp; pmf, Pointer&amp;&amp; ptr, Args&amp;&amp;... args) -&gt;
    decltype(((*forward&lt;Pointer&gt;(ptr)).*forward&lt;PMF&gt;(pmf))(forward&lt;Args&gt;(args)...)) {
      return ((*forward&lt;Pointer&gt;(ptr)).*forward&lt;PMF&gt;(pmf))(forward&lt;Args&gt;(args)...);
}
} // namespace detail

// C++11 implementation:
template &lt;class F, class... ArgTypes&gt;
struct result_of&lt;F(ArgTypes...)&gt; {
    using type = decltype(detail::INVOKE(
        declval&lt;F&gt;(), declval&lt;ArgTypes&gt;()...
    ));
};

// C++14 implementation:
namespace detail {
template &lt;class F, class... ArgTypes&gt;
struct invokeable {
    template &lt;typename U = F&gt;
    static auto test(int) -&gt; decltype(INVOKE(
        declval&lt;U&gt;(), declval&lt;ArgTypes&gt;()...
    ), void(), true_type());

    static auto test(...) -&gt; false_type;

    static constexpr bool value = decltype(test(0))::value;
};

template &lt;bool B, class F, class... ArgTypes&gt;
struct _result_of {
    using type = decltype(INVOKE(
        declval&lt;F&gt;(), declval&lt;ArgTypes&gt;()...
    ));
};

template &lt;class F, class... ArgTypes&gt;
struct _result_of&lt;false, F, ArgTypes...&gt; { };
} // namespace detail

template &lt;class F, class... ArgTypes&gt;
struct result_of&lt;F(ArgTypes...)&gt; :
    detail::_result_of&lt;detail::invokeable&lt;F, ArgTypes...&gt;::value, F, ArgTypes...&gt; { };
}}

===Notes===
As formulated in C++11, {{tt|std::result_of}} would fail to compile when F(ArgTypes...) is ill-formed (e.g. when F is not a callable type at all). C++14 changes that to a [[cpp/language/sfinae|SFINAE]] (when F is not callable, {{tt|std::result_of&lt;F(Args...)&gt;}} simply doesn't have the {{tt|type}} member).

===Examples===
{{example
 | {{tt|std::result_of}} can be used to determine the result of invoking a functor, in particular if the result type is different for different sets of arguments:
 | code=
#include &lt;type_traits&gt;

struct S {
    double operator()(char, int&amp;);
    float operator()(int);
};

struct C {
    double Func(char, int&amp;);
};

int main()
{
    // the result of invoking S with char and int&amp; arguments is double
    std::result_of&lt;S(char, int&amp;)&gt;::type f = 3.14; // f has type double
    static_assert(std::is_same&lt;decltype(f), double&gt;::value, &quot;&quot;);

    // the result of invoking S with int argument is float
    std::result_of&lt;S(int)&gt;::type d = 3.14; // f has type float
    static_assert(std::is_same&lt;decltype(d), float&gt;::value, &quot;&quot;);

    // result_of can be used with a pointer to member function as follows
    std::result_of&lt;decltype(&amp;C::Func)(C, char, int&amp;)&gt;::type g = 3.14;
    static_assert(std::is_same&lt;decltype(g), double&gt;::value, &quot;&quot;);
}
 | output=
}}

{{example
 | This program takes advantage of the C++14 changes to overload two functions on the &quot;callability&quot; of a template parameter:
 | code=
#include &lt;type_traits&gt;
#include &lt;iostream&gt;

template&lt;class T&gt;
typename std::result_of&lt;T(int)&gt;::type
f(T&amp; t)
{
    std::cout &lt;&lt; &quot;overload of f for callable T\n&quot;;
    return t(0);
}

template&lt;class T, class U&gt;
int f(U u)
{
    std::cout &lt;&lt; &quot;overload of f for non-callable T\n&quot;;
    return u;
}

struct S {};

int main() {
  f&lt;S&gt;(1); // fails to compile in C++11, calls the non-callable overload in C++14
}
|output=
overload of f for non-callable T
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc declval}}
{{dsc end}}

[[de:cpp/types/result of]]
[[es:cpp/types/result of]]
[[fr:cpp/types/result of]]
[[it:cpp/types/result of]]
[[ja:cpp/types/result of]]
[[pt:cpp/types/result of]]
[[ru:cpp/types/result of]]
[[zh:cpp/types/result of]]</text>
      <sha1>2q8dckkshves9l50f1zmrvl45t59rgw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/size t</title>
    <ns>0</ns>
    <id>3264</id>
    <revision>
      <id>71842</id>
      <parentid>71833</parentid>
      <timestamp>2014-06-27T11:40:17Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>header</comment>
      <text xml:space="preserve" bytes="1922">{{cpp/title|size_t}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | cstddef}}
{{dcl header | cstdio}}
{{dcl header | cstring}}
{{dcl header | ctime}}
{{dcl header | cstdlib|notes={{mark since c++11}}}}&lt;!-- C++11 Table 151 --&gt;
{{dcl |
typedef /*implementation-defined*/ size_t;
}}
{{dcl end}}

{{lc|std::size_t}} is the unsigned integer type of the result of the {{ltt|cpp/language/sizeof}} operator {{rev inl|since=c++11|as well as the {{ltt|cpp/language/sizeof...}} operator and the {{ltt|cpp/language/alignof}} operator}}. 

===Notes===
{{lc|std::size_t}} can store the maximum size of a theoretically possible object of any type (including array). On many platforms (an exception are systems with segmented addressing)  {{lc|std::size_t}} can safely store the value of any non-member pointer, in which case it is synonymous with {{lc|std::uintptr_t}}.

{{lc|std::size_t}} is commonly used for array indexing and loop counting. Programs that use other types, such as {{c|unsigned int}}, for array indexing may fail on, e.g. 64-bit systems when the index exceeds {{lc|UINT_MAX}} or if it relies on 32-bit modular arithmetic.

When indexing C++ containers, such as {{lc|std::string}}, {{lc|std::vector}}, etc, the appropriate type is the member typedef {{c|size_type}} provided by such containers. It is usually defined as a synonym for {{lc|std::size_t}}.

===Example===
{{example
 | 
 | code=
#include &lt;cstddef&gt;
 
int main()
{
    const std::size_t N = 100;
    int* a = new int[N];
 
    for (std::size_t n = 0; n &lt; N; ++n)
        a[n] = n;
 
    delete[] a;
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc ptrdiff_t}}
{{dsc inc | cpp/types/dsc offsetof}}
{{dsc see c | c/types/size_t}}
{{dsc end}}

[[de:cpp/types/size t]]
[[es:cpp/types/size t]]
[[fr:cpp/types/size t]]
[[it:cpp/types/size t]]
[[ja:cpp/types/size t]]
[[pt:cpp/types/size t]]
[[ru:cpp/types/size t]]
[[zh:cpp/types/size t]]</text>
      <sha1>gm34yjznjg20yuju5zr9arjb615lsmr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index</title>
    <ns>0</ns>
    <id>1786</id>
    <revision>
      <id>63069</id>
      <parentid>59483</parentid>
      <timestamp>2013-07-01T23:53:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2370">{{cpp/title|type_index}}
{{cpp/types/type_index/navbar}}

{{dcl begin}}
{{dcl header | typeindex}}
{{dcl | since=c++11 |
class type_index;
}}
{{dcl end}}

The {{tt|type_index}} class is a wrapper class around a {{lc|std::type_info}} object, that can be used as index in associative and unordered associative containers. The relationship with {{tt|type_info}} object is maintained through a pointer, therefore {{tt|type_index}} is {{concept|CopyConstructible}} and {{concept|CopyAssignable}}.

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/types/type_index/dsc constructor}}
{{dsc inc | cpp/types/type_index/dsc operator_cmp}}
{{dsc inc | cpp/types/type_index/dsc hash_code}}
{{dsc inc | cpp/types/type_index/dsc name}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/types/type_index/dsc hash}}
{{dsc end}}

===Example===
{{example | The following program is an example of an efficient type-value mapping.
 | code=
#include &lt;iostream&gt;
#include &lt;typeinfo&gt;
#include &lt;typeindex&gt;
#include &lt;unordered_map&gt;
#include &lt;string&gt;
#include &lt;memory&gt;

struct A {
    virtual ~A() {}
};

struct B : A {};
struct C : A {};

int main()
{
    std::unordered_map&lt;std::type_index, std::string&gt; type_names;

    type_names[std::type_index(typeid(int))] = &quot;int&quot;;
    type_names[std::type_index(typeid(double))] = &quot;double&quot;;
    type_names[std::type_index(typeid(A))] = &quot;A&quot;;
    type_names[std::type_index(typeid(B))] = &quot;B&quot;;
    type_names[std::type_index(typeid(C))] = &quot;C&quot;;

    int i;
    double d;
    A a;

    // note that we're storing pointer to type A
    std::unique_ptr&lt;A&gt; b(new B);
    std::unique_ptr&lt;A&gt; c(new C);

    std::cout &lt;&lt; &quot;i is &quot; &lt;&lt; type_names[std::type_index(typeid(i))] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;d is &quot; &lt;&lt; type_names[std::type_index(typeid(d))] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;a is &quot; &lt;&lt; type_names[std::type_index(typeid(a))] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b is &quot; &lt;&lt; type_names[std::type_index(typeid(*b))] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;c is &quot; &lt;&lt; type_names[std::type_index(typeid(*c))] &lt;&lt; '\n';
}
 | output=
i is int
d is double
a is A
b is B
c is C
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc type_info}}
{{dsc end}}

[[de:cpp/types/type index]]
[[es:cpp/types/type index]]
[[fr:cpp/types/type index]]
[[it:cpp/types/type index]]
[[ja:cpp/types/type index]]
[[pt:cpp/types/type index]]
[[ru:cpp/types/type index]]
[[zh:cpp/types/type index]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index/hash</title>
    <ns>0</ns>
    <id>5545</id>
    <revision>
      <id>72078</id>
      <parentid>64262</parentid>
      <timestamp>2014-07-12T11:38:16Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="755">{{cpp/title | hash{{small|&lt;std::type_index&gt;}}}}
{{cpp/types/type_index/navbar}}
{{ddcl | header=typeindex | since=c++11 | 1=
template&lt;&gt; struct hash&lt;type_index&gt;;
}}

The template specialization of {{lc|std::hash}} for {{lc|std::type_index}} allows users to obtain hashes of objects of type {{lc|std::type_index}}.

The member {{c|operator()}} effectively returns the same value as {{lc|hash_code()}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_index/dsc hash_code}}
{{dsc end}}

[[de:cpp/types/type index/hash]]
[[es:cpp/types/type index/hash]]
[[fr:cpp/types/type index/hash]]
[[it:cpp/types/type index/hash]]
[[ja:cpp/types/type index/hash]]
[[pt:cpp/types/type index/hash]]
[[ru:cpp/types/type index/hash]]
[[zh:cpp/types/type index/hash]]</text>
      <sha1>rr0rdd3lgob2rbunxa6v5za724es0ih</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index/hash code</title>
    <ns>0</ns>
    <id>2386</id>
    <revision>
      <id>64812</id>
      <parentid>64460</parentid>
      <timestamp>2013-08-27T01:01:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, fix noexcept</comment>
      <text xml:space="preserve" bytes="919">{{cpp/types/type_index/title|hash_code}}
{{cpp/types/type_index/navbar}}
{{ddcl | since=c++11 | 1=
size_t hash_code() const;
}}

Returns the hash code of the associated {{lc|std::type_info}} object. Equivalent to calling {{l2tt|cpp/types/type_info/hash_code}} directly.

===Parameters===
(none)

===Return value===
The hash code of the associated {{c|type_info}} object.

===Exceptions===
{{rev begin}}
{{rev | until=c++14 | (none)}}
{{rev | since=c++14 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
| code=
| output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_index/dsc hash}}
{{dsc end}}

[[de:cpp/types/type index/hash code]]
[[es:cpp/types/type index/hash code]]
[[fr:cpp/types/type index/hash code]]
[[it:cpp/types/type index/hash code]]
[[ja:cpp/types/type index/hash code]]
[[pt:cpp/types/type index/hash code]]
[[ru:cpp/types/type index/hash code]]
[[zh:cpp/types/type index/hash code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index/name</title>
    <ns>0</ns>
    <id>2385</id>
    <revision>
      <id>64811</id>
      <parentid>64461</parentid>
      <timestamp>2013-08-27T01:00:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, noexcept</comment>
      <text xml:space="preserve" bytes="769">{{cpp/types/type_index/title|name}}
{{cpp/types/type_index/navbar}}
{{ddcl | since=c++11 | 1=
const char* name() const;
}}

Returns the name of the associated {{lc|std::type_info}} object. Equivalent to calling {{lc|std::type_info::name()}} directly.

===Parameters===
(none)

===Return value===
The name of the associated {{c|type_info}} object.

===Exceptions===
{{rev begin}}
{{rev | until=c++14 | (none)}}
{{rev | since=c++14 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
| code=
| output=
}}

[[de:cpp/types/type index/name]]
[[es:cpp/types/type index/name]]
[[fr:cpp/types/type index/name]]
[[it:cpp/types/type index/name]]
[[ja:cpp/types/type index/name]]
[[pt:cpp/types/type index/name]]
[[ru:cpp/types/type index/name]]
[[zh:cpp/types/type index/name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index/operator cmp</title>
    <ns>0</ns>
    <id>5575</id>
    <revision>
      <id>63070</id>
      <parentid>51590</parentid>
      <timestamp>2013-07-01T23:53:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1742">{{cpp/types/type_index/title|1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=}}
{{cpp/types/type_index/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
bool operator==( const type_index&amp; rhs ) const;
}}
{{dcl | since=c++11 | 1=
bool operator!=( const type_index&amp; rhs ) const;
}}
{{dcl | since=c++11 | 1=
bool operator&lt;( const type_index&amp; rhs ) const;
}}
{{dcl | since=c++11 | 1=
bool operator&lt;=( const type_index&amp; rhs ) const;
}}
{{dcl | since=c++11 | 1=
bool operator&gt;( const type_index&amp; rhs ) const;
}}
{{dcl | since=c++11 | 1=
bool operator&gt;=( const type_index&amp; rhs ) const;
}}
{{dcl end}}

Compares the underlying {{lc|std::type_info}} objects.

1-2) Checks whether the underlying {{lc|std::type_info}} objects refer to the same type.

3-6) Compares the underlying {{lc|std::type_info}} objects as defined by an implementation-defined ordering. The comparison is done by {{l2tt|cpp/types/type_info/before}}.

===Parameters===
{{par begin}}
{{par | rhs | another {{tt|type_index}} object to compare to}}
{{par end}} 

===Return value===
1) {{c|true}} if the underlying {{lc|std::type_info}} objects refer to the same type, {{c|false}} otherwise

2) {{c|true}} if the underlying {{lc|std::type_info}} objects refer not to the same type, {{c|false}} otherwise

3-6) {{c|true}} if the types referred by the underlying {{lc|std::type_info}} objects are ordered by corresponding order, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

[[de:cpp/types/type index/operator cmp]]
[[es:cpp/types/type index/operator cmp]]
[[fr:cpp/types/type index/operator cmp]]
[[it:cpp/types/type index/operator cmp]]
[[ja:cpp/types/type index/operator cmp]]
[[pt:cpp/types/type index/operator cmp]]
[[ru:cpp/types/type index/operator cmp]]
[[zh:cpp/types/type index/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type index/type index</title>
    <ns>0</ns>
    <id>2383</id>
    <revision>
      <id>63494</id>
      <parentid>51591</parentid>
      <timestamp>2013-07-10T01:33:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="650">{{cpp/types/type_index/title|type_index}}
{{cpp/types/type_index/navbar}}
{{ddcl | since=c++11 | 1=
type_index( const std::type_info&amp; info );
}}

Constructs the type index from {{lc|std::type_info}} object.

===Parameters===
{{par begin}}
{{par | info | type information object}}
{{par end}}

===Example===
{{example
| code=
| output=
}}

[[de:cpp/types/type index/type index]]
[[es:cpp/types/type index/type index]]
[[fr:cpp/types/type index/type index]]
[[it:cpp/types/type index/type index]]
[[ja:cpp/types/type index/type index]]
[[pt:cpp/types/type index/type index]]
[[ru:cpp/types/type index/type index]]
[[zh:cpp/types/type index/type index]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info</title>
    <ns>0</ns>
    <id>1787</id>
    <revision>
      <id>59488</id>
      <parentid>51592</parentid>
      <timestamp>2013-06-01T06:36:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1343">{{cpp/title|type_info}}
{{cpp/types/type_info/navbar}}
{{dcl begin}}
{{dcl header | typeinfo}}
{{dcl |
class type_info;
}}
{{dcl end}}

The class {{tt|type_info}} holds implementation-specific information about a type, including the name of the type and means to compare two types for equality or collating order. This is the class returned by the {{ltt|cpp/language/typeid|typeid}} operator. 

The {{tt|type_info}} class is neither {{concept|CopyConstructible}} nor {{concept|CopyAssignable}}. 

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | notes={{cmark deleted}} | has neither default nor copy constructors}}
{{dsc mem vdtor | cpp/types/type_info/~type_info | derived objects are safe to delete through pointer-to-base }}
{{dsc mem fun | nolink=true | operator{{=}} | notes={{cmark deleted}} | can not be copy-assigned}}
{{dsc inc | cpp/types/type_info/dsc operator_cmp}}
{{dsc inc | cpp/types/type_info/dsc before}}
{{dsc inc | cpp/types/type_info/dsc hash_code}}
{{dsc inc | cpp/types/type_info/dsc name}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/dsc type_index}}
{{dsc end}}

[[de:cpp/types/type info]]
[[es:cpp/types/type info]]
[[fr:cpp/types/type info]]
[[it:cpp/types/type info]]
[[ja:cpp/types/type info]]
[[pt:cpp/types/type info]]
[[ru:cpp/types/type info]]
[[zh:cpp/types/type info]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/before</title>
    <ns>0</ns>
    <id>2225</id>
    <revision>
      <id>59489</id>
      <parentid>51593</parentid>
      <timestamp>2013-06-01T06:36:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1014">{{cpp/types/type_info/title | before}}
{{cpp/types/type_info/navbar}}
{{ddcl | 1=
bool before( const type_info&amp; rhs );
}}

Returns {{c|true}} if the referred type precedes type, referred to by {{tt|rhs}} in the implementation's collation order. No guarantees are given, in particular, the collation order can change between the invocations of the same program.

===Parameters===
{{par begin}}
{{par | rhs | another type information object to compare to}}
{{par end}} 

===Return value===
{{c|true}} if the referred type precedes type, referred to by {{c|rhs}} in the implementation's collation order.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_info/dsc operator_cmp}}
{{dsc end}}

[[de:cpp/types/type info/before]]
[[es:cpp/types/type info/before]]
[[fr:cpp/types/type info/before]]
[[it:cpp/types/type info/before]]
[[ja:cpp/types/type info/before]]
[[pt:cpp/types/type info/before]]
[[ru:cpp/types/type info/before]]
[[zh:cpp/types/type info/before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/hash code</title>
    <ns>0</ns>
    <id>2226</id>
    <revision>
      <id>67531</id>
      <parentid>67528</parentid>
      <timestamp>2014-02-11T02:41:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>partial undo - they are all the same type (std::type_info), it's about what type they are referring to.</comment>
      <text xml:space="preserve" bytes="2368">{{cpp/types/type_info/title | hash_code}}
{{cpp/types/type_info/navbar}}
{{ddcl | since=c++11 | 1=
size_t hash_code() const;
}}

Returns an unspecified value, which is identical for the {{tt|type_info}} objects referring to the same type. No other guarantees are given. For example, the same value may be returned for different types. The value can also change between invocations of the same program.

===Parameters===
(none)

===Return value===
Some value, which is identical for the same types.

===Example===
{{example | The following program is an example of an efficient type-value mapping without using {{lc|std::type_index}}.
 | code=
#include &lt;iostream&gt;
#include &lt;typeinfo&gt;
#include &lt;unordered_map&gt;
#include &lt;string&gt;
#include &lt;functional&gt;
#include &lt;memory&gt;

struct A {
    virtual ~A() {}
};

struct B : A {};
struct C : A {};

using TypeInfoRef = std::reference_wrapper&lt;const std::type_info&gt;;

struct Hasher {
    std::size_t operator()(TypeInfoRef code) const
    {
        return code.get().hash_code();
    }
};

struct EqualTo {
    bool operator()(TypeInfoRef lhs, TypeInfoRef rhs) const
    {
        return lhs.get() == rhs.get();
    }
};

int main()
{
    std::unordered_map&lt;TypeInfoRef, std::string, Hasher, EqualTo&gt; type_names;

    type_names[typeid(int)] = &quot;int&quot;;
    type_names[typeid(double)] = &quot;double&quot;;
    type_names[typeid(A)] = &quot;A&quot;;
    type_names[typeid(B)] = &quot;B&quot;;
    type_names[typeid(C)] = &quot;C&quot;;

    int i;
    double d;
    A a;

    // note that we're storing pointer to type A
    std::unique_ptr&lt;A&gt; b(new B);
    std::unique_ptr&lt;A&gt; c(new C);

    std::cout &lt;&lt; &quot;i is &quot; &lt;&lt; type_names[typeid(i)] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;d is &quot; &lt;&lt; type_names[typeid(d)] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;a is &quot; &lt;&lt; type_names[typeid(a)] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b is &quot; &lt;&lt; type_names[typeid(*b)] &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;c is &quot; &lt;&lt; type_names[typeid(*c)] &lt;&lt; '\n';
}
 | output=
i is int
d is double
a is A
b is B
c is C
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_info/dsc operator_cmp}}
{{dsc inc | cpp/types/type_info/dsc name}}
{{dsc end}}

[[de:cpp/types/type info/hash code]]
[[es:cpp/types/type info/hash code]]
[[fr:cpp/types/type info/hash code]]
[[it:cpp/types/type info/hash code]]
[[ja:cpp/types/type info/hash code]]
[[pt:cpp/types/type info/hash code]]
[[ru:cpp/types/type info/hash code]]
[[zh:cpp/types/type info/hash code]]</text>
      <sha1>3i2xmqu5yyqxm5gvupk8wcomdmthykn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/name</title>
    <ns>0</ns>
    <id>2227</id>
    <revision>
      <id>59493</id>
      <parentid>51595</parentid>
      <timestamp>2013-06-01T06:36:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1012">{{cpp/types/type_info/title | name}}
{{cpp/types/type_info/navbar}}
{{ddcl | 1=
const char* name() const;
}}

Returns an implementation defined null-terminated character string containing the name of the type. No guarantees are given, in particular, the returned string can be identical for several types and change between invocations of the same program.

===Parameters===
(none)

===Return value===
null-terminated character string containing the name of the type.

===Notes===
With compilers such as gcc and clang, the returned string can be piped through {{tt|c++filt -t}} to be converted to human-readable form.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_info/dsc hash_code}}
{{dsc end}}

[[de:cpp/types/type info/name]]
[[es:cpp/types/type info/name]]
[[fr:cpp/types/type info/name]]
[[it:cpp/types/type info/name]]
[[ja:cpp/types/type info/name]]
[[pt:cpp/types/type info/name]]
[[ru:cpp/types/type info/name]]
[[zh:cpp/types/type info/name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/operator cmp</title>
    <ns>0</ns>
    <id>2223</id>
    <revision>
      <id>59494</id>
      <parentid>51596</parentid>
      <timestamp>2013-06-01T06:36:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1830">{{cpp/types/type_info/title | operator{{==}} | operator!{{=}}}}
{{cpp/types/type_info/navbar}}
{{dcl begin}}
{{dcl | 1=
bool operator==( const type_info&amp; rhs ) const;
}}
{{dcl | 1=
bool operator!=( const type_info&amp; rhs ) const;
}}
{{dcl end}}

Checks if the objects refer to the same types.

===Parameters===
{{par begin}}
{{par | rhs | another type information object to compare to}}
{{par end}} 

===Return value===
{{c|true}} if the comparison operation holds true, {{c|false}} otherwise

===Example===
{{example
 | code=

#include &lt;iostream&gt;
#include &lt;typeinfo&gt;
#include &lt;string&gt;
#include &lt;utility&gt;

class person
{
  public:

   person(std::string&amp;&amp; n) : _name(n) {}
   virtual const std::string&amp; name() const{ return _name; }

  private:

    std::string _name;
};

class employee : public person
{
   public:

     employee(std::string&amp;&amp; n, std::string&amp;&amp; p) :
         person(std::move(n)), _profession(std::move(p)) {}

     const std::string&amp; profession() const { return _profession; }

   private:

     std::string _profession;
};

void somefunc(const person&amp; p)
{
   if(typeid(employee) == typeid(p))
   {
      std::cout &lt;&lt; p.name() &lt;&lt; &quot; is an employee &quot;;
      auto&amp; emp = dynamic_cast&lt;const employee&amp;&gt;(p);
      std::cout &lt;&lt; &quot;who works in &quot; &lt;&lt; emp.profession() &lt;&lt; '\n';
   }
}

int main()
{
   employee paul(&quot;Paul&quot;,&quot;Economics&quot;);
   somefunc(paul);
}
 | output= Paul is an employee who works in Economics


}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/types/type_info/dsc before}}
{{dsc end}}

[[de:cpp/types/type info/operator cmp]]
[[es:cpp/types/type info/operator cmp]]
[[fr:cpp/types/type info/operator cmp]]
[[it:cpp/types/type info/operator cmp]]
[[ja:cpp/types/type info/operator cmp]]
[[pt:cpp/types/type info/operator cmp]]
[[ru:cpp/types/type info/operator cmp]]
[[zh:cpp/types/type info/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/operator comp</title>
    <ns>0</ns>
    <id>4216</id>
    <redirect title="cpp/types/type info/operator cmp" />
    <revision>
      <id>15273</id>
      <timestamp>2011-12-08T01:21:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/types/type info/operator comp]] to [[cpp/types/type info/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[cpp/types/type info/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/type info/~type info</title>
    <ns>0</ns>
    <id>3278</id>
    <revision>
      <id>51597</id>
      <parentid>41972</parentid>
      <timestamp>2013-06-01T04:12:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="643">{{cpp/types/type_info/title|~type_info}}
{{cpp/types/type_info/navbar}}
{{dcl begin}}
{{dcl | 1=
virtual ˜type_info();
}}
{{dcl end}}

Destructs an object of type {{lc|std::type_info}}. This destructor is public virtual, allowing objects of classes, derived from {{lc|std::type_info}} to be safely deleted through pointers to base class.

[[de:cpp/types/type info/~type info]]
[[es:cpp/types/type info/~type info]]
[[fr:cpp/types/type info/~type info]]
[[it:cpp/types/type info/~type info]]
[[ja:cpp/types/type info/~type info]]
[[pt:cpp/types/type info/~type info]]
[[ru:cpp/types/type info/~type info]]
[[zh:cpp/types/type info/~type info]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/types/underlying type</title>
    <ns>0</ns>
    <id>3252</id>
    <revision>
      <id>63071</id>
      <parentid>51598</parentid>
      <timestamp>2013-07-01T23:53:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1778">{{cpp/title|underlying_type}}
{{cpp/types/navbar}}
{{dcl begin}}
{{dcl header | type_traits}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct underlying_type;
}}
{{dcl end}}

Defines a member typedef {{tt|type}} of type that is the underlying type for the enumeration {{tt|T}}. 

===Member types===
{{dsc begin}}
{{dsc hitem | Name | Definition}}
{{dsc | {{tt|type}} | the underlying type for {{tt|T}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template&lt; class T &gt;
using underlying_type_t = typename underlying_type&lt;T&gt;::type;
}}
{{dcl end}}

===Notes===
Each enumeration type has an underlying type, which can be

1. Specified explicitly (both scoped and unscoped enumerations)

2. Omitted, in which case it is {{c|int}} for scoped enumerations or an implementation-defined integral type capable of representing all values of the enum (for unscoped enumerations)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;

enum e1 {};
enum class e2: int {};

int main() {
    bool e1_type = std::is_same&lt;
        unsigned
       ,typename std::underlying_type&lt;e1&gt;::type
    &gt;::value; 

    bool e2_type = std::is_same&lt;
        int
       ,typename std::underlying_type&lt;e2&gt;::type
    &gt;::value;
   
    std::cout
    &lt;&lt; &quot;underlying type for 'e1' is &quot; &lt;&lt; (e1_type?&quot;unsigned&quot;:&quot;non-unsigned&quot;) &lt;&lt; '\n'
    &lt;&lt; &quot;underlying type for 'e2' is &quot; &lt;&lt; (e2_type?&quot;int&quot;:&quot;non-int&quot;) &lt;&lt; '\n';
}

 | output=
underlying type for 'e1' is unsigned
underlying type for 'e2' is int
}}

[[de:cpp/types/underlying type]]
[[es:cpp/types/underlying type]]
[[fr:cpp/types/underlying type]]
[[it:cpp/types/underlying type]]
[[ja:cpp/types/underlying type]]
[[pt:cpp/types/underlying type]]
[[ru:cpp/types/underlying type]]
[[zh:cpp/types/underlying type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility</title>
    <ns>0</ns>
    <id>1775</id>
    <revision>
      <id>72368</id>
      <parentid>65913</parentid>
      <timestamp>2014-08-15T18:11:30Z</timestamp>
      <contributor>
        <ip>54.240.196.186</ip>
      </contributor>
      <comment>atdd link to placeholders and mem_fn</comment>
      <text xml:space="preserve" bytes="3535">{{title|Utility library}}
{{cpp/utility/navbar}}

C++ includes a variety of utility libraries that provide functionality ranging from [[cpp/utility/bitset|bit-counting]] to [[cpp/utility/functional/bind|partial function application]]. These libraries can be broadly divided into two groups: 

* language support libraries, and
* general-purpose libraries.

==Language support==

Language support libraries provide classes and functions that interact closely with language features and support common language idioms.

===[[cpp/types|Type support]]===

Basic types (e.g. {{lc|std::size_t}}, {{lc|std::nullptr_t}}), RTTI (e.g. {{lc|std::type_info}}), type traits (e.g. {{lc|std::is_integral}}, {{lc|std::rank}})

===[[cpp/memory|Dynamic memory management]]===

Smart pointers (e.g. {{lc|std::shared_ptr}}), allocators (e.g. {{lc|std::allocator}}), C-style memory management (e.g. {{lc|std::malloc}})

===[[cpp/error|Error handling]]===

Exceptions (e.g. {{lc|std::exception}}, {{lc|std::logic_error}}), assertions (e.g. {{lc|assert}})

===Initializer lists===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc initializer_list}}
{{dsc end}}

===[[cpp/utility/variadic|Variadic functions]]===

Support for functions that take an arbitrary number of parameters (via e.g. {{lc|va_start}}, {{lc|va_arg}}, {{lc|va_end}})


==General-purpose utilities==

===[[cpp/utility/program | Program utilities]]===

Termination (e.g. {{lc|std::abort}}, {{lc|std::atexit}}), environment (e.g. {{lc|std::system}}), signals (e.g. {{lc|std::raise}})

===[[cpp/chrono|Date and time]]===

Time tracking (e.g. {{lc|std::chrono::time_point}}, {{lc|std::chrono::duration}}), C-style date and time (e.g. {{lc|std::time}}, {{lc|std::clock}})

===Bitset===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc bitset}}
{{dsc end}}

===[[cpp/utility/functional|Function objects]]===

Partial function application (e.g. {{lc|std::bind}}) and related utilities: utilities for binding such as {{lc|std::ref}}  and {{lc|std::placeholders}}, polymorphic function wrappers: {{lc|std::function}}, predefined functors (e.g. {{lc|std::plus}}, {{lc|std::equal_to}}), method to function converters {{lc|std::mem_fn}}. 

===Pairs and tuples===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc pair}}
{{dsc inc | cpp/utility/dsc tuple}}
{{dsc inc | cpp/utility/dsc piecewise_construct_t}}
{{dsc inc | cpp/utility/dsc piecewise_construct}}
{{dsc inc | cpp/utility/dsc integer_sequence}}
{{dsc end}}

===Swap, forward and move===

{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/utility/dsc exchange}}
{{dsc inc | cpp/utility/dsc forward}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc inc | cpp/utility/dsc declval}}
{{dsc end}}

===Relational operators===

{{dsc begin}}
{{dsc namespace | std::rel_ops }}
{{dsc inc | cpp/utility/rel_ops/dsc operator_cmp}}
{{dsc end}}

===Hash support===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

&lt;!-- perhaps keep hidden until 2017?
===Optional types===

{{dsc begin}}
{{dsc header | optional}}
{{dsc inc | cpp/utility/dsc optional}}
{{dsc inc | cpp/utility/dsc in_place_t}}
{{dsc inc | cpp/utility/dsc in_place}}
{{dsc inc | cpp/utility/dsc nullopt_t}}
{{dsc inc | cpp/utility/dsc nullopt}}
{{dsc inc | cpp/utility/dsc bad_optional_access}}
{{dsc end}}
--&gt;

[[ar:cpp/utility]]
[[cs:cpp/utility]]
[[de:cpp/utility]]
[[es:cpp/utility]]
[[fr:cpp/utility]]
[[it:cpp/utility]]
[[ja:cpp/utility]]
[[ko:cpp/utility]]
[[pl:cpp/utility]]
[[pt:cpp/utility]]
[[ru:cpp/utility]]
[[zh:cpp/utility]]</text>
      <sha1>t44cp4b7eosnegv0lujlsx5jymy5tad</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bad optional access</title>
    <ns>0</ns>
    <id>10106</id>
    <revision>
      <id>68176</id>
      <parentid>63496</parentid>
      <timestamp>2014-03-17T01:39:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="1018">{{cpp/title | bad_optional_access}}
{{cpp/error/domain_error/navbar}}
{{ddcl | header=optional | since=libfund_ts |
class bad_optional_access;
}}

Defines a type of object to be thrown as exception when accessing a {{lc|std::experimental::optional}} object with uninitialized state.

{{inheritance diagram/std-bad_optional_access}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/bad_optional_access/dsc constructor}}
{{dsc end}}

{{member | {{small|std::bad_optional_access::}}bad_optional_access | 2=
{{dcl begin}}
{{dcl | num=1 | since=libfund_ts |
explicit bad_optional_access( const std::string&amp; what_arg );
}}
{{dcl | num=2 | since=libfund_ts |
explicit bad_optional_access( const char* what_arg );
}}
{{dcl end}}

Constructs the exception object with {{tt|what_arg}} as explanatory string that can be accessed through {{ltf|cpp/error/exception/what}}.

===Parameters===
{{par begin}}
{{par | what_arg | explanatory string}}
{{par end}}

===Exceptions===
(none)
}}


{{cpp/error/exception/inherit}}</text>
      <sha1>gl7q0zjjn8a0wwe72zjumb3vaizjgtv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset</title>
    <ns>0</ns>
    <id>1776</id>
    <revision>
      <id>59501</id>
      <parentid>51601</parentid>
      <timestamp>2013-06-01T06:36:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2206">{{cpp/title|bitset}}
{{cpp/utility/bitset/navbar}}
{{ddcl | header=bitset |
template&lt; std::size_t N &gt;
class bitset;
}}

The class template {{tt|bitset}} represents a fixed-size sequence of {{tt|N}} bits. Bitsets can be manipulated by standard logic operators and converted to and from strings and integers.

{{tt|bitset}} meets the requirements of {{concept|CopyConstructible}} and {{concept|CopyAssignable}}.

===Template parameters===
{{par begin}}
{{par | N | the number of bits to allocate storage for}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc class | cpp/utility/bitset/reference | proxy class representing a reference to a bit}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc constructor}}
{{dsc inc | cpp/utility/bitset/dsc operator_cmp}}

{{dsc h2 | Element access}}
{{dsc inc | cpp/utility/bitset/dsc operator_at}}
{{dsc inc | cpp/utility/bitset/dsc test}}
{{dsc inc | cpp/utility/bitset/dsc all_any_none}}
{{dsc inc | cpp/utility/bitset/dsc count}}

{{dsc h2 | Capacity}}
{{dsc inc | cpp/utility/bitset/dsc size}}

{{dsc h2 | Modifiers}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt}}
{{dsc inc | cpp/utility/bitset/dsc set}}
{{dsc inc | cpp/utility/bitset/dsc reset}}
{{dsc inc | cpp/utility/bitset/dsc flip}}

{{dsc h2 | Conversions}}
{{dsc inc | cpp/utility/bitset/dsc to_string}}
{{dsc inc | cpp/utility/bitset/dsc to_ulong}}
{{dsc inc | cpp/utility/bitset/dsc to_ullong}}

{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic2}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc hash}}
{{dsc end}}

===Notes===
If the size of the bitset is not known at compile time, [[cpp/container/vector_bool|std::vector&lt;bool&gt;]] or [http://www.boost.org/doc/libs/release/libs/dynamic_bitset/dynamic_bitset.html boost::dynamic_bitset] may be used.

[[de:cpp/utility/bitset]]
[[es:cpp/utility/bitset]]
[[fr:cpp/utility/bitset]]
[[it:cpp/utility/bitset]]
[[ja:cpp/utility/bitset]]
[[pt:cpp/utility/bitset]]
[[ru:cpp/utility/bitset]]
[[zh:cpp/utility/bitset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/all</title>
    <ns>0</ns>
    <id>1777</id>
    <redirect title="cpp/utility/bitset/all any none" />
    <revision>
      <id>5387</id>
      <parentid>3554</parentid>
      <timestamp>2011-07-27T10:19:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>redirect</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/utility/bitset/all_any_none]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/all any none</title>
    <ns>0</ns>
    <id>2372</id>
    <revision>
      <id>72327</id>
      <parentid>63073</parentid>
      <timestamp>2014-08-09T09:32:29Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <text xml:space="preserve" bytes="1767">{{cpp/utility/bitset/title | all|any|none}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
bool all() const;
}}
{{dcl | num=2 |
bool any() const;
}}
{{dcl | num=3 |
bool none() const;
}}
{{dcl end}}

Checks if all, any or none of the bits are set to {{c|true}}.

@1@ Checks if all bits are set to {{c|true}}

@2@ Checks if any bits are set to {{c|true}}

@3@ Checks if none of the bits are set to {{c|true}}

===Parameters===
(none)

===Return value===
@1@ {{c|true}} if all bits are set to {{c|true}}, otherwise {{c|false}}

@2@ {{c|true}} if any of the bits are set to {{c|true}}, otherwise {{c|false}}

@3@ {{c|true}} if none of the bits are set to {{c|true}}, otherwise {{c|false}}

===Exceptions===
{{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;4&gt; b1(&quot;0000&quot;);
    std::bitset&lt;4&gt; b2(&quot;0101&quot;);
    std::bitset&lt;4&gt; b3(&quot;1111&quot;);

    std::cout &lt;&lt; &quot;bitset\t&quot; &lt;&lt; &quot;all\t&quot; &lt;&lt; &quot;any\t&quot; &lt;&lt; &quot;none\n&quot;;
    std::cout &lt;&lt; b1 &lt;&lt; '\t' &lt;&lt; b1.all() &lt;&lt; '\t' &lt;&lt; b1.any() &lt;&lt; '\t' &lt;&lt; b1.none() &lt;&lt; '\n';
    std::cout &lt;&lt; b2 &lt;&lt; '\t' &lt;&lt; b2.all() &lt;&lt; '\t' &lt;&lt; b2.any() &lt;&lt; '\t' &lt;&lt; b2.none() &lt;&lt; '\n';
    std::cout &lt;&lt; b3 &lt;&lt; '\t' &lt;&lt; b3.all() &lt;&lt; '\t' &lt;&lt; b3.any() &lt;&lt; '\t' &lt;&lt; b3.none() &lt;&lt; '\n';
}
 | output=
bitset  all     any     none
0000    0       0       1
0101    0       1       0
1111    1       1       0
}}

[[de:cpp/utility/bitset/all any none]]
[[es:cpp/utility/bitset/all any none]]
[[fr:cpp/utility/bitset/all any none]]
[[it:cpp/utility/bitset/all any none]]
[[ja:cpp/utility/bitset/all any none]]
[[pt:cpp/utility/bitset/all any none]]
[[ru:cpp/utility/bitset/all any none]]
[[zh:cpp/utility/bitset/all any none]]</text>
      <sha1>blwo783mqm9k13ns5o9kp1z3oraj1gc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/any</title>
    <ns>0</ns>
    <id>1778</id>
    <redirect title="cpp/utility/bitset/all any none" />
    <revision>
      <id>5385</id>
      <parentid>3556</parentid>
      <timestamp>2011-07-27T10:18:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/utility/bitset/all any none]]</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/utility/bitset/all_any_none]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/bitset</title>
    <ns>0</ns>
    <id>5451</id>
    <revision>
      <id>70396</id>
      <parentid>69804</parentid>
      <timestamp>2014-05-21T19:09:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>equivalent effect for #4, mention traits::eq for #3, mention invalid_argument in Exceptions section</comment>
      <text xml:space="preserve" bytes="5217">{{cpp/utility/bitset/title | bitset}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 |
constexpr bitset() noexcept;
}}
{{dcl | num=2 |
constexpr bitset( unsigned long long val ) noexcept;
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
explicit bitset( const std::basic_string&lt;CharT,Traits,Alloc&gt;&amp; str,
                 typename std::basic_string&lt;CharT,Traits,Alloc&gt;::size_type pos = 0,
                 typename std::basic_string&lt;CharT,Traits,Alloc&gt;::size_type n =
                     std::basic_string&lt;CharT,Traits,Alloc&gt;::npos);
}}
{{dcl | since=c++11 | 1=
template&lt; class CharT, class Traits, class Alloc &gt;
explicit bitset( const std::basic_string&lt;CharT,Traits,Alloc&gt;&amp; str,
                 typename std::basic_string&lt;CharT,Traits,Alloc&gt;::size_type pos = 0,
                 typename std::basic_string&lt;CharT,Traits,Alloc&gt;::size_type n =
                     std::basic_string&lt;CharT,Traits,Alloc&gt;::npos,
                 CharT zero = CharT(’0’), 
                 CharT one = CharT(’1’));
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class CharT &gt;
explicit bitset( const CharT* str,
                 typename std::basic_string&lt;CharT&gt;::size_type n =
                     std::basic_string&lt;CharT&gt;::npos,
                 CharT zero = CharT(’0’), 
                 CharT one = CharT(’1’));
}}
{{dcl end}}

Constructs a new bitset from one of several optional data sources:

@1@ Default constructor.  Constructs a bitset with all bits set to zero.

@2@ Constructs a bitset, initializing the first (rightmost, least significant) {{tt|M}} bit positions to the corresponding bit values of {{tt|val}}, where {{tt|M}} is the smaller of the number of bits in an {{tt|unsigned long long}} and the number of bits {{tt|N}} in the bitset being constructed. If M is less than N (the bitset is longer than 64 bits, for typical implementations of unsigned long long), the remaining bit positions are initialized to zeroes. 

@3@ Constructs a bitset using the characters in the {{lc|std::basic_string}} {{tt|str}}.  An optional starting position {{tt|pos}} and length {{tt|n}} can be provided, as well as characters denoting alternate values for set ({{tt|one}}) and unset ({{tt|zero}}) bits. {{tt|Traits::eq()}} is used to compare the character values. 

@@The effective length of the initializing string is min({{tt|n}}, {{tt|str.size() - pos}}).

@@If {{tt|pos &gt; str.size()}}, this constructor throws {{lc|std::out_of_range}}.  If any characters examined in {{tt|str}} are not {{tt|zero}} or {{tt|one}}, it throws {{lc|std::invalid_argument}}.

@4@ Similar to (3), but uses a {{tt|CharT*}} instead of a {{lc|std::basic_string}}. Equivalent to {{c|1=bitset(n == basic_string&lt;charT&gt;::npos ? basic_string&lt;charT&gt;(str) : basic_string&lt;charT&gt;(str, n), 0, n, zero, one)}}

===Parameters===
{{par begin}}
{{par | val  | number used to initialize the bitset}}
{{par | str  | string used to initialize the bitset}}
{{par | pos  | a starting offset into {{tt|str}}}}
{{par | n    | number of characters to use from {{tt|str}}}}
{{par | one  | alternate character for set bits in {{tt|str}}}}
{{par | zero | alternate character for unset bits in {{tt|str}}}}
{{par end}}

===Exceptions===
1. none

2. none

3. {{lc|std::out_of_range}} if {{c|pos &gt; str.size()}}, {{lc|std::invalid_argument}} if any character is not one or zero

4. {{lc|std::invalid_argument}} if any character is not one or zero


===Example===
{{example
 | code=
#include &lt;bitset&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;climits&gt;

int main() 
{
    // empty constructor
    std::bitset&lt;8&gt; b1; // [0,0,0,0,0,0,0,0]
    
    // unsigned long long constructor
    std::bitset&lt;8&gt; b2(42);          // [0,0,1,0,1,0,1,0]
    std::bitset&lt;70&gt; bl(ULLONG_MAX); // [0,0,0,0,0,0,1,1,1,...,1,1,1]
    std::bitset&lt;8&gt; bs(0xfff0);      // [1,1,1,1,0,0,0,0]
    
    // string constructor
    std::string bit_string = &quot;110010&quot;;
    std::bitset&lt;8&gt; b3(bit_string);       // [0,0,1,1,0,0,1,0]
    std::bitset&lt;8&gt; b4(bit_string, 2);    // [0,0,0,0,0,0,1,0]
    std::bitset&lt;8&gt; b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]

    // string constructor using custom zero/one digits
    std::string alpha_bit_string = &quot;aBaaBBaB&quot;;
    std::bitset&lt;8&gt; b6(alpha_bit_string, 0, alpha_bit_string.size(),
                      'a', 'B');         // [0,1,0,0,1,1,0,1]

    // char* constructor using custom digits
    std::bitset&lt;8&gt; b7(&quot;XXXXYYYY&quot;, 8, 'X', 'Y'); // [0,0,0,0,1,1,1,1]

    std::cout &lt;&lt; b1 &lt;&lt; '\n' &lt;&lt; b2 &lt;&lt; '\n' &lt;&lt; bl &lt;&lt; '\n' &lt;&lt; bs &lt;&lt; '\n'
              &lt;&lt; b3 &lt;&lt; '\n' &lt;&lt; b4 &lt;&lt; '\n' &lt;&lt; b5 &lt;&lt; '\n' &lt;&lt; b6 &lt;&lt; '\n'
              &lt;&lt; b7 &lt;&lt; '\n';
}
 | output=
00000000
00101010
0000001111111111111111111111111111111111111111111111111111111111111111
11110000
00110010
00000010
00000001
01001101
00001111
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc set}}
{{dsc inc | cpp/utility/bitset/dsc reset}}
{{dsc end}}

[[de:cpp/utility/bitset/bitset]]
[[es:cpp/utility/bitset/bitset]]
[[fr:cpp/utility/bitset/bitset]]
[[it:cpp/utility/bitset/bitset]]
[[ja:cpp/utility/bitset/bitset]]
[[pt:cpp/utility/bitset/bitset]]
[[ru:cpp/utility/bitset/bitset]]
[[zh:cpp/utility/bitset/bitset]]</text>
      <sha1>5bx7bhddxt8um7wxtmdhk8ozqk4mzxh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/count</title>
    <ns>0</ns>
    <id>1779</id>
    <revision>
      <id>59505</id>
      <parentid>51604</parentid>
      <timestamp>2013-06-01T06:36:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1233">{{cpp/utility/bitset/title | count}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl |
size_t count() const;
}}
{{dcl end}}

Returns the number of bits that are set to {{c|true}}.

===Parameters===
(none)

===Return value===
number of bits that are set to {{c|true}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;8&gt; b(&quot;00010010&quot;);
    std::cout &lt;&lt; &quot;initial value: &quot; &lt;&lt; b &lt;&lt; '\n';

    // find the first unset bit
    size_t idx = 0;
    while (idx &lt; b.size() &amp;&amp; b.test(idx)) ++idx;

    // continue setting bits until half the bitset is filled
    while (idx &lt; b.size() &amp;&amp; b.count() &lt; b.size()/2) {
        b.set(idx);
        std::cout &lt;&lt; &quot;setting bit &quot; &lt;&lt; idx &lt;&lt; &quot;: &quot; &lt;&lt; b &lt;&lt; '\n';
        while (idx &lt; b.size() &amp;&amp; b.test(idx)) ++idx;
    }

}
 | output=
initial value: 00010010
setting bit 0: 00010011
setting bit 2: 00010111
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc size}}
{{dsc end}}

[[de:cpp/utility/bitset/count]]
[[es:cpp/utility/bitset/count]]
[[fr:cpp/utility/bitset/count]]
[[it:cpp/utility/bitset/count]]
[[ja:cpp/utility/bitset/count]]
[[pt:cpp/utility/bitset/count]]
[[ru:cpp/utility/bitset/count]]
[[zh:cpp/utility/bitset/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/flip</title>
    <ns>0</ns>
    <id>2368</id>
    <revision>
      <id>67190</id>
      <parentid>64813</parentid>
      <timestamp>2014-01-26T01:07:39Z</timestamp>
      <contributor>
        <username>Xan</username>
        <id>2811</id>
      </contributor>
      <comment>add example</comment>
      <text xml:space="preserve" bytes="1503">{{cpp/utility/bitset/title|flip}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 |
bitset&lt;N&gt;&amp; flip();
}}
{{dcl | num=2 |
bitset&lt;N&gt;&amp; flip( size_t pos );
}}
{{dcl end}}

Flips bits, i.e. changes {{c|true}} values to {{c|false}} and {{c|false}} values to {{c|true}}.   Equivalent to a logical NOT operation on part or all of the bitset.

@1@ Flips all bits (equivalent to {{lc|operator~}})

@2@ Flips the bit at the position {{tt|pos}}.

===Parameters===
{{par begin}}
{{par | pos | the position of the bit to flip}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

@2@ throws {{lc|std::out_of_range}} if {{tt|pos}} does not correspond to a valid position within the bitset.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;4&gt; b;

    std::cout &lt;&lt; b &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; b.flip(0) &lt;&lt; '\n';
    std::cout &lt;&lt; b.flip(2) &lt;&lt; '\n';
    std::cout &lt;&lt; b.flip() &lt;&lt; '\n';
}
 | output=
0000
0001
0101
1010
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc set}}
{{dsc inc | cpp/utility/bitset/dsc reset}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic}}
{{dsc end}}

[[de:cpp/utility/bitset/flip]]
[[es:cpp/utility/bitset/flip]]
[[fr:cpp/utility/bitset/flip]]
[[it:cpp/utility/bitset/flip]]
[[ja:cpp/utility/bitset/flip]]
[[pt:cpp/utility/bitset/flip]]
[[ru:cpp/utility/bitset/flip]]
[[zh:cpp/utility/bitset/flip]]</text>
      <sha1>dwuu7t12u7dyy1lcpnnkuaow1hnd650</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/hash</title>
    <ns>0</ns>
    <id>5518</id>
    <revision>
      <id>63075</id>
      <parentid>59509</parentid>
      <timestamp>2013-07-01T23:53:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1189">{{cpp/title | hash &lt;small&gt;(std::bitset)&lt;/small&gt;}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
template&lt;size_t N&gt; struct hash&lt;bitset&lt;N&gt;&gt;;
}}
{{dcl end}}

The template specialization of {{lc|std::hash}} for {{c|std::bitset&lt;N&gt;}} allows users to obtain hashes of objects of type {{c|std::bitset&lt;N&gt;}}.

===Example===
{{example
 | The following code shows one possible output of a hash function used on several bitsets:
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;
#include &lt;functional&gt;
 
int main()
{
    std::bitset&lt;4&gt; b1(1);
    std::bitset&lt;4&gt; b2(2);
    std::bitset&lt;4&gt; b3(b2);

    std::hash&lt;std::bitset&lt;4&gt;&gt; hash_fn;

    size_t h1 = hash_fn(b1);
    size_t h2 = hash_fn(b2);
    size_t h3 = hash_fn(b3);

    std::cout &lt;&lt; h1 &lt;&lt; '\n';
    std::cout &lt;&lt; h2 &lt;&lt; '\n';
    std::cout &lt;&lt; h3 &lt;&lt; '\n';
}
 | output=
67918732
118251589
118251589
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/dsc hash}}
{{dsc end}}

[[de:cpp/utility/bitset/hash]]
[[es:cpp/utility/bitset/hash]]
[[fr:cpp/utility/bitset/hash]]
[[it:cpp/utility/bitset/hash]]
[[ja:cpp/utility/bitset/hash]]
[[pt:cpp/utility/bitset/hash]]
[[ru:cpp/utility/bitset/hash]]
[[zh:cpp/utility/bitset/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/none</title>
    <ns>0</ns>
    <id>1780</id>
    <redirect title="cpp/utility/bitset/all any none" />
    <revision>
      <id>5386</id>
      <parentid>3560</parentid>
      <timestamp>2011-07-27T10:18:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>redirect</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/utility/bitset/all_any_none]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator at</title>
    <ns>0</ns>
    <id>1781</id>
    <revision>
      <id>64232</id>
      <parentid>61886</parentid>
      <timestamp>2013-08-15T15:54:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1811">{{cpp/utility/bitset/title | operator[]}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
bool operator[]( std::size_t pos ) const;
}}
{{dcl | since=c++11 |
constexpr bool operator[]( std::size_t pos ) const;
}}
{{dcl rev end}}
{{dcl | num=2 |
reference operator[]( std::size_t pos );
}}
{{dcl end}}

Accesses the bit at position {{tt|pos}}. The first version returns the value of the bit, the second version returns an object of type {{lc|std::bitset::reference}} that allows modification of the value.

Unlike {{lc|test()}}, does not throw exceptions: the behavior is undefined if {{tt|pos}} is out of bounds.

===Parameters===
{{par begin}}
{{par | pos | position of the bit to return}}
{{par end}}

===Return value===
1) the value of the requested bit

2) an object of type {{lc|std::bitset::reference}}, which allows writing to the requested bit.

===Exceptions===
None

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;8&gt; b1(42);
    for (std::size_t i = 0; i &lt; b1.size(); ++i) {
        std::cout &lt;&lt; &quot;b1[&quot; &lt;&lt; i &lt;&lt; &quot;]: &quot; &lt;&lt; b1[i] &lt;&lt; '\n';
    }
    b1[0] = true; // modifies the first bit through bitset::refence
    std::cout &lt;&lt; &quot;After setting bit 0, the bitset holds &quot; &lt;&lt; b1 &lt;&lt; '\n';
}
 | output=
b1[0]: 0
b1[1]: 1
b1[2]: 0
b1[3]: 1
b1[4]: 0
b1[5]: 1
b1[6]: 0
b1[7]: 0
After setting bit 0, the bitset holds 00101011
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc test}}
{{dsc end}}

[[de:cpp/utility/bitset/operator at]]
[[es:cpp/utility/bitset/operator at]]
[[fr:cpp/utility/bitset/operator at]]
[[it:cpp/utility/bitset/operator at]]
[[ja:cpp/utility/bitset/operator at]]
[[pt:cpp/utility/bitset/operator at]]
[[ru:cpp/utility/bitset/operator at]]
[[zh:cpp/utility/bitset/operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator cmp</title>
    <ns>0</ns>
    <id>5452</id>
    <revision>
      <id>67939</id>
      <parentid>67929</parentid>
      <timestamp>2014-03-07T10:49:32Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>escape '=='</comment>
      <text xml:space="preserve" bytes="1487">{{title | 1=operator==,!=&lt;small&gt;(std::bitset&lt;/small&gt;)}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
bool operator==( const bitset&lt;N&gt;&amp; rhs ) const;
}}
{{dcl | num=2 | 1=
bool operator!=( const bitset&lt;N&gt;&amp; rhs ) const;
}}
{{dcl end}}

1) Returns true if all of the bits in {{tt|*this}} and {{tt|rhs}} are equal.

2) Returns true if any of the bits in {{tt|*this}} and {{tt|rhs}} are not equal.

===Parameters===
{{par begin}}
{{par | rhs | bitset to compare }}
{{par end}} 

===Return value===

1) {{c|true}} if the value of each bit in {{tt|*this}} equals the value of the corresponding bit in {{tt|rhs}}, otherwise {{c|false}}

2) {{c|true}} if {{tt|!(*this {{==}} rhs)}}, otherwise {{c|false}}

===Example===
{{example
 | Compare two bitsets to determine if they are identical:
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;4&gt; b1(3); // [0,0,1,1]
    std::bitset&lt;4&gt; b2(b1);
    std::bitset&lt;4&gt; b3(4); // [0,1,0,0]

    std::cout &lt;&lt; &quot;b1 == b2: &quot; &lt;&lt; (b1 == b2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b1 == b3: &quot; &lt;&lt; (b1 == b3) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b1 != b3: &quot; &lt;&lt; (b1 != b3) &lt;&lt; '\n';
}
 | output=
b1 == b2: 1
b1 == b3: 0
b1 != b3: 1
}}

[[de:cpp/utility/bitset/operator cmp]]
[[es:cpp/utility/bitset/operator cmp]]
[[fr:cpp/utility/bitset/operator cmp]]
[[it:cpp/utility/bitset/operator cmp]]
[[ja:cpp/utility/bitset/operator cmp]]
[[pt:cpp/utility/bitset/operator cmp]]
[[ru:cpp/utility/bitset/operator cmp]]
[[zh:cpp/utility/bitset/operator cmp]]</text>
      <sha1>b4zg6967ctv3ezwloahfjzn0qogrktv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator gtgtltlt</title>
    <ns>0</ns>
    <id>3487</id>
    <redirect title="cpp/utility/bitset/operator ltltgtgt" />
    <revision>
      <id>13141</id>
      <timestamp>2011-11-03T19:48:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/bitset/operator gtgtltlt]] to [[cpp/utility/bitset/operator ltltgtgt]]: consistency</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[cpp/utility/bitset/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator logic</title>
    <ns>0</ns>
    <id>2365</id>
    <revision>
      <id>59513</id>
      <parentid>51609</parentid>
      <timestamp>2013-06-01T06:37:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1927">{{cpp/utility/bitset/title|operator&amp;{{=}},{{!=}},^{{=}},~}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
bitset&lt;N&gt;&amp; operator&amp;=( const bitset&lt;N&gt;&amp; other );
}}
{{dcl | num=2 | 1=
bitset&lt;N&gt;&amp; operator{{!}}=( const bitset&lt;N&gt;&amp; other );
}}
{{dcl | num=3 | 1=
bitset&lt;N&gt;&amp; operator^=( const bitset&lt;N&gt;&amp; other );
}}
{{dcl | num=4 | 1=
bitset&lt;N&gt; operator~() const;
}}
{{dcl end}}

Performs binary AND, OR, XOR and NOT.

1) Sets the bits to the result of binary AND on corresponding pairs of bits of {{c|*this}} and {{tt|other}}.

2) Sets the bits to the result of binary OR on corresponding pairs of bits of {{c|*this}} and {{tt|other}}.

3) Sets the bits to the result of binary XOR on corresponding pairs of bits of {{c|*this}} and {{tt|other}}.

4) Returns a temporary copy of {{c|*this}} with all bits flipped (binary NOT).

Note that &amp;=, |=, and ^= are only defined for bitsets of the same size {{tt|N}}.

===Parameters===
{{par begin}}
{{par | other | another bitset}}
{{par end}}

===Return value===
1-3) {{c|*this}}

4) a bitset&lt;N&gt; temporary with all bits flipped
===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;16&gt; dest;
    std::string pattern_str = &quot;1001&quot;;
    std::bitset&lt;16&gt; pattern(pattern_str);
    
    for (size_t i = 0, ie = dest.size()/pattern_str.size(); i != ie; ++i) {
        dest &lt;&lt;= pattern_str.size();
        dest {{!}}= pattern;
    }
    std::cout &lt;&lt; dest &lt;&lt; '\n';
}
 | output=
1001100110011001
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt}}
{{dsc end}}

[[de:cpp/utility/bitset/operator logic]]
[[es:cpp/utility/bitset/operator logic]]
[[fr:cpp/utility/bitset/operator logic]]
[[it:cpp/utility/bitset/operator logic]]
[[ja:cpp/utility/bitset/operator logic]]
[[pt:cpp/utility/bitset/operator logic]]
[[ru:cpp/utility/bitset/operator logic]]
[[zh:cpp/utility/bitset/operator logic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator logic2</title>
    <ns>0</ns>
    <id>5453</id>
    <revision>
      <id>64836</id>
      <parentid>59514</parentid>
      <timestamp>2013-08-27T01:19:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, noexcept</comment>
      <text xml:space="preserve" bytes="2065">{{title | 1=operator&amp;,{{!}},^&lt;small&gt;(std::bitset&lt;/small&gt;)}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
bitset&lt;N&gt; operator&amp;( const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
bitset&lt;N&gt; operator{{!}}( const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
bitset&lt;N&gt; operator^( const bitset&lt;N&gt;&amp; lhs, const bitset&lt;N&gt;&amp; rhs );
}}
{{dcl end}}

Performs binary AND, OR, and XOR between two bitsets, {{tt|lhs}} and {{tt|rhs}}.

@1@ Returns a {{tt|bitset&lt;N&gt;}} containing the result of binary AND on corresponding pairs of bits of {{tt|lhs}} and {{tt|rhs}}.

@2@ Returns a {{tt|bitset&lt;N&gt;}} containing the result of binary OR on corresponding pairs of bits of {{tt|lhs}} and {{tt|rhs}}.

@3@ Returns a {{tt|bitset&lt;N&gt;}} containing the result of binary XOR on corresponding pairs of bits of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs | the bitset on the left-hand side of the operator}}
{{par | rhs | the bitset on the right-hand side of the operator}}
{{par end}}

===Return value===
@1@ {{c|bitset&lt;N&gt;(lhs) &amp;= rhs}}

@2@ {{c|bitset&lt;N&gt;(lhs) {{!}}= rhs}}

@3@ {{c|bitset&lt;N&gt;(lhs) ^= rhs}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 | code=
#include &lt;bitset&gt;
#include &lt;iostream&gt;

int main()
{
    std::bitset&lt;4&gt; b1(&quot;0110&quot;);
    std::bitset&lt;4&gt; b2(&quot;0011&quot;);
    std::cout &lt;&lt; &quot;b1 &amp; b2: &quot; &lt;&lt; (b1 &amp; b2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b1 {{!}} b2: &quot; &lt;&lt; (b1 {{!}} b2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;b1 ^ b2: &quot; &lt;&lt; (b1 ^ b2) &lt;&lt; '\n';
}
 | output=
b1 &amp; b2: 0010
b1 {{!}} b2: 0111
b1 ^ b2: 0101
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic}}
{{dsc end}}

[[de:cpp/utility/bitset/operator logic2]]
[[es:cpp/utility/bitset/operator logic2]]
[[fr:cpp/utility/bitset/operator logic2]]
[[it:cpp/utility/bitset/operator logic2]]
[[ja:cpp/utility/bitset/operator logic2]]
[[pt:cpp/utility/bitset/operator logic2]]
[[ru:cpp/utility/bitset/operator logic2]]
[[zh:cpp/utility/bitset/operator logic2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator ltltgtgt</title>
    <ns>0</ns>
    <id>2364</id>
    <revision>
      <id>59517</id>
      <parentid>51611</parentid>
      <timestamp>2013-06-01T06:37:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1705">{{cpp/utility/bitset/title|operator&amp;lt;&amp;lt;,&amp;lt;&amp;lt;{{=}},&amp;gt;&amp;gt;,&amp;gt;&amp;gt;{{=}}}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
bitset&lt;N&gt; operator&lt;&lt;( size_t pos ) const;
}}
{{dcl | num=2 | 1=
bitset&lt;N&gt;&amp; operator&lt;&lt;=( size_t pos );
}}
{{dcl | num=3 | 1=
bitset&lt;N&gt; operator&gt;&gt;( size_t pos ) const;
}}
{{dcl | num=4 | 1=
bitset&lt;N&gt;&amp; operator&gt;&gt;=( size_t pos );
}}
{{dcl end}}

Performs binary shift left and binary shift right. Zeroes are shifted in.

1-2) Performs binary shift left. The (2) version is destructive, i.e. performs the shift to the current object.

3-4) Performs binary shift right. The (4) version is destructive, i.e. performs the shift to the current object.

===Parameters===
{{par begin}}
{{par | pos | number of positions to shift the bits}}
{{par end}}

===Return value===
1,3) new bitset object containing the shifted bits

2,4) {{c|*this}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;8&gt; b(&quot;01110010&quot;);
    std::cout &lt;&lt; &quot;initial value: &quot; &lt;&lt; b &lt;&lt; '\n';

    while (b.any()) {
        while (!b.test(0)) {
            b &gt;&gt;= 1;
        }
        std::cout &lt;&lt; b &lt;&lt; '\n';
        b &gt;&gt;= 1;
    }
}
 | output=
initial value: 01110010
00111001
00000111
00000011
00000001
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_logic}}
{{dsc end}}

[[de:cpp/utility/bitset/operator ltltgtgt]]
[[es:cpp/utility/bitset/operator ltltgtgt]]
[[fr:cpp/utility/bitset/operator ltltgtgt]]
[[it:cpp/utility/bitset/operator ltltgtgt]]
[[ja:cpp/utility/bitset/operator ltltgtgt]]
[[pt:cpp/utility/bitset/operator ltltgtgt]]
[[ru:cpp/utility/bitset/operator ltltgtgt]]
[[zh:cpp/utility/bitset/operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator ltltgtgt2</title>
    <ns>0</ns>
    <id>5454</id>
    <revision>
      <id>64269</id>
      <parentid>59518</parentid>
      <timestamp>2013-08-15T16:12:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="2855">{{title | 1=operator&lt;&lt;,&gt;&gt;&lt;small&gt;(std::bitset)&lt;/small&gt;}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template &lt;class CharT, class Traits, size_t N&gt;
std::basic_ostream&lt;CharT, Traits&gt;&amp; operator&lt;&lt;(std::basic_ostream&lt;CharT, Traits&gt;&amp; os, 
                                              const bitset&lt;N&gt;&amp; x);
}}
{{dcl | num=2 | 1=
template &lt;class CharT, class Traits, size_t N&gt;
std::basic_istream&lt;CharT, Traits&gt;&amp; operator&gt;&gt;(std::basic_istream&lt;CharT, Traits&gt;&amp; is, 
                                              bitset&lt;N&gt;&amp; x);
}}
{{dcl end}}

Inserts or extracts a bitset from a character stream.

@1@ Writes the bitset {{tt|x}} to the character stream {{tt|os}} as if by first converting it to a {{tt|basic_string&lt;CharT,Traits&gt;}} using {{lc|to_string()}}, and then writing it into {{tt|os}} using the {{ltt|cpp/string/basic_string/operator_ltltgtgt|operator&lt;&lt;}} (which is a {{concept|FormattedOutputFunction}} for strings). The characters to use for ones and zeroes are obtained from the currently-imbued locale by calling {{c|std::use_facet&lt;std::ctype&lt;CharT&gt;(os.getloc()).widen()}} with {{c|'1'}} and {{c|'0'}} as arguments.

@2@ Behaves as a {{concept|FormattedInputFunction}}. After constructing and checking the sentry object, which may skip leading whitespace, extracts up to {{tt|N}} characters from {{tt|is}} and stores the characters in the bitset {{tt|x}}.

Characters are extracted until either

* {{tt|N}} characters have been read,
* end-of-file occurs in {{tt|is}}, or
* the next character is neither {{tt|is.widen('0')}} nor {{tt|is.widen('1')}}.

If no characters are extracted, {{tt|is.setstate(ios_base::failbit)}} is called.

===Parameters===
{{par begin}}
{{par | os | the character stream to write to}}
{{par | is | the character stream to read from}}
{{par | x | the bitset to be read or written}}
{{par end}}

===Return value===

The character stream that was operated on, e.g. {{tt|os}} or {{tt|is}}.

===Example===
{{example
 | code=
#include &lt;bitset&gt;
#include &lt;iostream&gt;
#include &lt;sstream&gt;

int main()
{
    std::string bit_string = &quot;001101&quot;;
    std::istringstream bit_stream(bit_string);

    std::bitset&lt;3&gt; b1;
    bit_stream &gt;&gt; b1; // reads &quot;001&quot;, stream still holds &quot;101&quot;
    std::cout &lt;&lt; b1 &lt;&lt; '\n';

    std::bitset&lt;8&gt; b2;
    bit_stream &gt;&gt; b2; // reads &quot;101&quot;, populates the 8-bit set as &quot;00000101&quot;
    std::cout &lt;&lt; b2 &lt;&lt; '\n';
}
 | output=
001
00000101
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_ltltgtgt}}
{{dsc end}}

[[de:cpp/utility/bitset/operator ltltgtgt2]]
[[es:cpp/utility/bitset/operator ltltgtgt2]]
[[fr:cpp/utility/bitset/operator ltltgtgt2]]
[[it:cpp/utility/bitset/operator ltltgtgt2]]
[[ja:cpp/utility/bitset/operator ltltgtgt2]]
[[pt:cpp/utility/bitset/operator ltltgtgt2]]
[[ru:cpp/utility/bitset/operator ltltgtgt2]]
[[zh:cpp/utility/bitset/operator ltltgtgt2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/operator mod</title>
    <ns>0</ns>
    <id>5587</id>
    <redirect title="cpp/utility/bitset/operator logic" />
    <revision>
      <id>20590</id>
      <timestamp>2012-03-28T16:28:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/bitset/operator mod]] to [[cpp/utility/bitset/operator logic]]: better title</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/utility/bitset/operator logic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/reference</title>
    <ns>0</ns>
    <id>5068</id>
    <revision>
      <id>64840</id>
      <parentid>59519</parentid>
      <timestamp>2013-08-27T01:20:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>noexcept</comment>
      <text xml:space="preserve" bytes="3151">{{cpp/utility/bitset/title | reference}}
{{cpp/utility/bitset/navbar}}
{{ddcl| 1=
class reference;
}}

The {{lc|std::bitset}} class includes {{lc|std::bitset::reference}} as a publicly-accessible nested class.  This class is used as a proxy object to allow users to interact with individual bits of a bitset, since standard C++ types (like references and pointers) are not built with enough precision to specify individual bits.

The primary use of {{lc|std::bitset::reference}} is to provide an l-value that can be returned from {{ltt|cpp/utility/bitset/operator_at|operator[]}}.

Any reads or writes to a bitset that happen via a {{lc|std::bitset::reference}} potentially read or write to the entire underlying bitset.

===Member functions===
{{dsc begin}}
{{dsc priv mem ctor | nolink=true | constructs the reference. Accessible only to {{lc|std::bitset}} itself}}
{{dsc mem dtor | ~reference | nolink=true | destroys the reference}}
{{dsc mem fun | operator{{=}} | nolink=true | assigns a {{c|bool}} to the referenced bit}}
{{dsc inc | cpp/utility/bitset/reference/dsc operator bool}}
{{dsc mem fun | operator ~ | nolink=true | returns inverted referenced bit}}
{{dsc mem fun | flip | nolink=true | flips the referenced bit}}
{{dsc end}}

{{member | {{small|std::bitset&lt;N&gt;::reference::}}~reference | 2=
{{ddcl | 1=
~reference()
}}

Destroys the reference.
}}

{{member | {{small|std::bitset&lt;N&gt;::reference::}}operator{{=}} | 2=
{{ddcl | 1=
reference&amp; operator=( bool x );
reference&amp; operator=( const reference&amp; x );
}}

Assigns a value to the referenced bit.

===Parameters===
{{par begin}}
{{par | x | value to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::bitset&lt;N&gt;::reference::}}operator bool | 2=
{{ddcl | 1=        
operator bool() const;
}}

Returns the value of the referenced bit.

===Parameters===
(none)

===Return value===
The referenced bit.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::bitset&lt;N&gt;::reference::}}operator~ | 2=
{{ddcl | 1=        
bool operator~() const;
}}

Returns the inverse of the referenced bit.

===Parameters===
(none)

===Return value===
The inverse of the referenced bit.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

{{member | {{small|std::bitset&lt;N&gt;::reference::}}flip | 2=
{{ddcl | 1=        
reference&amp; flip();
}}

Inverts the referenced bit.

===Parameters===
(none)

===Return value===
{{c|*this}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_at}}
{{dsc end}}

[[de:cpp/utility/bitset/reference]]
[[es:cpp/utility/bitset/reference]]
[[fr:cpp/utility/bitset/reference]]
[[it:cpp/utility/bitset/reference]]
[[ja:cpp/utility/bitset/reference]]
[[pt:cpp/utility/bitset/reference]]
[[ru:cpp/utility/bitset/reference]]
[[zh:cpp/utility/bitset/reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/reset</title>
    <ns>0</ns>
    <id>2367</id>
    <revision>
      <id>64814</id>
      <parentid>59522</parentid>
      <timestamp>2013-08-27T01:02:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix noexcept</comment>
      <text xml:space="preserve" bytes="1424">{{cpp/utility/bitset/title|reset}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 |
bitset&lt;N&gt;&amp; reset();
}}
{{dcl | num=2 |
bitset&lt;N&gt;&amp; reset( size_t pos );
}}
{{dcl end}}

Sets bits to {{c|false}}.

@1@ Sets all bits to {{c|false}}

@2@ Sets the bit at position {{tt|pos}} to {{c|false}}.

===Parameters===
{{par begin}}
{{par | pos | the position of the bit to set}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

@2@ Throws {{lc|std::out_of_range}} if {{tt|pos}} does not correspond to a valid position within the bitset

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;8&gt; b(42);
    std::cout &lt;&lt; &quot;Bitset is         &quot; &lt;&lt; b &lt;&lt; '\n';
    b.reset(1);
    std::cout &lt;&lt; &quot;After b.reset(1): &quot; &lt;&lt; b &lt;&lt; '\n';
    b.reset();
    std::cout &lt;&lt; &quot;After b.reset():  &quot; &lt;&lt; b &lt;&lt; '\n';
}
 | output=
Bitset is         00101010
After b.reset(1): 00101000
After b.reset():  00000000
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc set}}
{{dsc inc | cpp/utility/bitset/dsc flip}}
{{dsc end}}

[[de:cpp/utility/bitset/reset]]
[[es:cpp/utility/bitset/reset]]
[[fr:cpp/utility/bitset/reset]]
[[it:cpp/utility/bitset/reset]]
[[ja:cpp/utility/bitset/reset]]
[[pt:cpp/utility/bitset/reset]]
[[ru:cpp/utility/bitset/reset]]
[[zh:cpp/utility/bitset/reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/set</title>
    <ns>0</ns>
    <id>2366</id>
    <revision>
      <id>64815</id>
      <parentid>59523</parentid>
      <timestamp>2013-08-27T01:02:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, noexcept</comment>
      <text xml:space="preserve" bytes="1345">{{cpp/utility/bitset/title|set}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl | num=1 |
bitset&lt;N&gt;&amp; set();
}}
{{dcl | num=2 | 1=
bitset&lt;N&gt;&amp; set( size_t pos, bool value = true );
}}
{{dcl end}}

Sets all bits to {{c|true}} or to specified value.

@1@ Sets all bits to {{c|true}}.

@2@ Sets the bit at position {{tt|pos}} to the value {{tt|value}}.

===Parameters===
{{par begin}}
{{par | pos | the position of the bit to set}}
{{par | value | the value to set the bit to}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1@ {{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

@2@ Throws {{lc|std::out_of_range}} if {{tt|pos}} does not correspond to a valid position within the bitset.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    std::bitset&lt;8&gt; b;
    for (size_t i = 1; i &lt; b.size(); i += 2) {
        b.set(i);
    }
    std::cout &lt;&lt; b &lt;&lt; '\n';
}
 | output=
10101010
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc reset}}
{{dsc inc | cpp/utility/bitset/dsc flip}}
{{dsc end}}

[[de:cpp/utility/bitset/set]]
[[es:cpp/utility/bitset/set]]
[[fr:cpp/utility/bitset/set]]
[[it:cpp/utility/bitset/set]]
[[ja:cpp/utility/bitset/set]]
[[pt:cpp/utility/bitset/set]]
[[ru:cpp/utility/bitset/set]]
[[zh:cpp/utility/bitset/set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/size</title>
    <ns>0</ns>
    <id>1782</id>
    <revision>
      <id>64799</id>
      <parentid>64675</parentid>
      <timestamp>2013-08-27T00:55:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+rev noexcept</comment>
      <text xml:space="preserve" bytes="929">{{cpp/utility/bitset/title | size}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
std::size_t size() const;
}}
{{dcl | since=c++11 | until=c++14 |
constexpr std::size_t size();
}}
{{dcl | since=c++14 |
constexpr std::size_t size() const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the number of bits that the bitset can hold.

===Parameters===
(none)

===Return value===
number of bits that the bitset can hold, i.e. the template parameter {{tt|N}}

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc count}}
{{dsc end}}

[[de:cpp/utility/bitset/size]]
[[es:cpp/utility/bitset/size]]
[[fr:cpp/utility/bitset/size]]
[[it:cpp/utility/bitset/size]]
[[ja:cpp/utility/bitset/size]]
[[pt:cpp/utility/bitset/size]]
[[ru:cpp/utility/bitset/size]]
[[zh:cpp/utility/bitset/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/test</title>
    <ns>0</ns>
    <id>1783</id>
    <revision>
      <id>64205</id>
      <parentid>59527</parentid>
      <timestamp>2013-08-15T15:29:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="1378">{{cpp/utility/bitset/title | test}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl |
bool test( size_t pos ) const;
}}
{{dcl end}}

Returns the value of the bit at the position {{tt|pos}}.

Unlike {{lc|operator[]}}, performs a bounds check and throws {{lc|std::out_of_range}} if {{tt|pos}} does not correspond to a valid position in the bitset.

===Parameters===
{{par begin}}
{{par | pos | position of the bit to return}}
{{par end}}

===Return value===
{{c|true}} if the requested bit is set, {{c|false}} otherwise.
===Exceptions===
{{lc|std::out_of_range}} if {{tt|pos}} does not correspond to a valid position within the bitset.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main() 
{
    std::bitset&lt;10&gt; b1(&quot;1111010000&quot;);

    size_t idx = 0;
    while (idx &lt; b1.size() &amp;&amp; !b1.test(idx)) {
      ++idx;
    }

    if (idx &lt; b1.size()) {
        std::cout &lt;&lt; &quot;lowest set bit at index &quot; &lt;&lt; idx &lt;&lt; '\n';
    } else {
        std::cout &lt;&lt; &quot;no set bits\n&quot;;
    }
}
 | output=
first set bit at index 4
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc operator_at}}
{{dsc end}}

[[de:cpp/utility/bitset/test]]
[[es:cpp/utility/bitset/test]]
[[fr:cpp/utility/bitset/test]]
[[it:cpp/utility/bitset/test]]
[[ja:cpp/utility/bitset/test]]
[[pt:cpp/utility/bitset/test]]
[[ru:cpp/utility/bitset/test]]
[[zh:cpp/utility/bitset/test]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/to string</title>
    <ns>0</ns>
    <id>2369</id>
    <revision>
      <id>61890</id>
      <parentid>61882</parentid>
      <timestamp>2013-06-09T16:24:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>1=</comment>
      <text xml:space="preserve" bytes="1805">{{cpp/utility/bitset/title|to_string}}
{{cpp/utility/bitset/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt;
    class CharT,
    class Traits,
    class Alloc 
&gt; std::basic_string&lt;CharT,Traits,Allocator&gt; to_string() const;
}}
{{dcl | since=c++11 | 1=
template&lt;
    class CharT = char,
    class Traits = std::char_traits&lt;CharT&gt;,
    class Allocator = std::allocator&lt;CharT&gt; 
&gt; std::basic_string&lt;CharT,Traits,Allocator&gt;
    to_string(CharT zero = CharT(’0’), CharT one = CharT(’1’)) const;
}}
{{dcl rev end}}
{{dcl end}}

Converts the contents of the bitset to a string. Uses {{tt|zero}} to represent bits with value of {{c|false}} and {{tt|one}} to represent bits with value of {{c|true}}.

The resulting string contains {{tt|N}} characters with the first character corresponds to the last ({{tt|N-1}}th) bit and the last character corresponding to the first bit.

===Parameters===
{{par begin}}
{{par | zero | character to use to represent {{c|false}} }}
{{par | one | character to use to represent {{c|true}} }}
{{par end}}

===Return value===
the converted string

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;
int main()
{
    std::bitset&lt;8&gt; b(42);
    std::cout &lt;&lt; b.to_string() &lt;&lt; '\n'
              &lt;&lt; b.to_string('*') &lt;&lt; '\n'
              &lt;&lt; b.to_string('O', 'X') &lt;&lt; '\n';
}
 | output=
00101010
**1*1*1*
OOXOXOXO
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc to_ulong}}
{{dsc inc | cpp/utility/bitset/dsc to_ullong}}
{{dsc end}}

[[de:cpp/utility/bitset/to string]]
[[es:cpp/utility/bitset/to string]]
[[fr:cpp/utility/bitset/to string]]
[[it:cpp/utility/bitset/to string]]
[[ja:cpp/utility/bitset/to string]]
[[pt:cpp/utility/bitset/to string]]
[[ru:cpp/utility/bitset/to string]]
[[zh:cpp/utility/bitset/to string]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/to ullong</title>
    <ns>0</ns>
    <id>2371</id>
    <revision>
      <id>67192</id>
      <parentid>67191</parentid>
      <timestamp>2014-01-26T02:31:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fmt long line in the example, and add std::hex to make the output as shown</comment>
      <text xml:space="preserve" bytes="1484">{{cpp/utility/bitset/title|to_ullong}}
{{cpp/utility/bitset/navbar}}
{{ddcl | since=c++11 | 1=
unsigned long long to_ullong() const
}}

Converts the contents of the bitset to an {{c|unsigned long long}} integer. 

The first bit of the bitset corresponds to the least significant digit of the number and the last bit corresponds to the most significant digit.

===Parameters===
(none)

===Return value===
the converted integer

===Exceptions===
{{lc|std::overflow_error}} if the value can not be represented in {{c|unsigned long long}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;
#include &lt;limits&gt;

int main()
{
    std::bitset&lt;std::numeric_limits&lt;unsigned long long&gt;::digits&gt; b(
        0x123456789abcdef0LL
    );

    std::cout &lt;&lt; b &lt;&lt; &quot;  &quot; &lt;&lt; std::hex &lt;&lt; b.to_ullong() &lt;&lt; '\n';
    b.flip();
    std::cout &lt;&lt; b &lt;&lt; &quot;  &quot; &lt;&lt; b.to_ullong() &lt;&lt; '\n';
}
 | output=
0001001000110100010101100111100010011010101111001101111011110000  123456789abcdef0
1110110111001011101010011000011101100101010000110010000100001111  edcba9876543210f
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc to_string}}
{{dsc inc | cpp/utility/bitset/dsc to_ulong}}
{{dsc end}}

[[de:cpp/utility/bitset/to ullong]]
[[es:cpp/utility/bitset/to ullong]]
[[fr:cpp/utility/bitset/to ullong]]
[[it:cpp/utility/bitset/to ullong]]
[[ja:cpp/utility/bitset/to ullong]]
[[pt:cpp/utility/bitset/to ullong]]
[[ru:cpp/utility/bitset/to ullong]]
[[zh:cpp/utility/bitset/to ullong]]</text>
      <sha1>cnlxliwn1lqjjemxgaan2rxikm0gr0n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/bitset/to ulong</title>
    <ns>0</ns>
    <id>2370</id>
    <revision>
      <id>59532</id>
      <parentid>51620</parentid>
      <timestamp>2013-06-01T06:37:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1478">{{cpp/utility/bitset/title|to_ulong}}
{{cpp/utility/bitset/navbar}}
{{ddcl | 1=
unsigned long to_ulong() const
}}

Converts the contents of the bitset to an {{c|unsigned long}} integer. 

The first bit of the bitset corresponds to the least significant digit of the number and the last bit corresponds to the most significant digit.

===Parameters===
(none)

===Return value===
the converted integer

===Exceptions===
throws {{lc|std::overflow_error}} if the value can not be represented in {{c|unsigned long}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;bitset&gt;

int main()
{
    for (unsigned long i = 0; i &lt; 10; ++i) {
        std::bitset&lt;5&gt; b(i);
        std::bitset&lt;5&gt; b_inverted = ~b;
        std::cout &lt;&lt; i &lt;&lt; '\t';
        std::cout &lt;&lt; b &lt;&lt; '\t';
        std::cout &lt;&lt; b_inverted &lt;&lt; '\t';
        std::cout &lt;&lt; b_inverted.to_ulong() &lt;&lt; '\n'; 
    }
}
 | output=
0	00000	11111	31
1	00001	11110	30
2	00010	11101	29
3	00011	11100	28
4	00100	11011	27
5	00101	11010	26
6	00110	11001	25
7	00111	11000	24
8	01000	10111	23
9	01001	10110	22
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/bitset/dsc to_string}}
{{dsc inc | cpp/utility/bitset/dsc to_ullong}}
{{dsc end}}

[[de:cpp/utility/bitset/to ulong]]
[[es:cpp/utility/bitset/to ulong]]
[[fr:cpp/utility/bitset/to ulong]]
[[it:cpp/utility/bitset/to ulong]]
[[ja:cpp/utility/bitset/to ulong]]
[[pt:cpp/utility/bitset/to ulong]]
[[ru:cpp/utility/bitset/to ulong]]
[[zh:cpp/utility/bitset/to ulong]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/declval</title>
    <ns>0</ns>
    <id>2669</id>
    <revision>
      <id>71955</id>
      <parentid>71174</parentid>
      <timestamp>2014-07-04T17:07:01Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1874">{{cpp/title|declval}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl | since=c++11 |
template&lt; class T &gt;
typename std::add_rvalue_reference&lt;T&gt;::type declval();
}}
{{dcl end}}

Converts any type {{tt|T}} to a reference type, making it possible to use member functions in {{c|decltype}} expressions without the need to go through constructors. 

{{tt|declval}} is commonly used in templates where acceptable template parameters may have no constructor in common, but have the same member function whose return type is needed. Note that because no definition exists for {{tt|declval}}, it can only be used in unevaluated contexts; it is an error to evaluate an expression that contains this function. 

===Parameters===
(none)

===Return value===
Cannot be called and thus never returns a value. The return type is {{tt|T&amp;&amp;}} unless {{tt|T}} is (possibly cv-qualified) {{tt|void}}, in which case the return type is {{tt|T}}.&lt;!--Note that reference collapsing may take place when determine what T&amp;&amp; refers to.--&gt;

===Exceptions===
{{noexcept}}  

===Example===
{{example
 |
 | code=
#include &lt;utility&gt;
#include &lt;iostream&gt;

struct Default {
    int foo() const {return 1;}
};

struct NonDefault {
    NonDefault(const NonDefault&amp;) {}
    int foo() const {return 1;}
};

int main()
{
    decltype(Default().foo()) n1 = 1; // int n1
//  decltype(NonDefault().foo()) n2 = n1; // will not compile
    decltype(std::declval&lt;NonDefault&gt;().foo()) n2 = n1; // int n2
    std::cout &lt;&lt; &quot;n2 = &quot; &lt;&lt; n2 &lt;&lt; '\n';
}
 | output=
n2 = 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/language/dsc decltype}}
{{dsc inc | cpp/types/dsc result_of}}
{{dsc end}}

[[de:cpp/utility/declval]]
[[es:cpp/utility/declval]]
[[fr:cpp/utility/declval]]
[[it:cpp/utility/declval]]
[[ja:cpp/utility/declval]]
[[pt:cpp/utility/declval]]
[[ru:cpp/utility/declval]]
[[zh:cpp/utility/declval]]</text>
      <sha1>2gaaasoidsjt0xatnxem0rni9hq3h1e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/exchange</title>
    <ns>0</ns>
    <id>10005</id>
    <revision>
      <id>63498</id>
      <parentid>61944</parentid>
      <timestamp>2013-07-10T01:34:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2239">{{cpp/title|exchange}}
{{cpp/utility/navbar}}
{{ddcl | header=utility | since=c++14 | 1=
template&lt; class T, class U = T &gt;
T exchange( T&amp; obj, U&amp;&amp; new_value );
}}

Replaces the value of {{tt|obj}} with {{tt|new_value}} and returns the old value of {{tt|obj}}.

===Parameters===
{{par begin}}
{{par | obj | object whose value to replace}}
{{par | new_value | the value to assign to {{tt|obj}} }}
{{par hreq}}
{{par req concept | T | MoveAssignable | notes=Also, it must be possible to move-assign objects of type {{tt|U}} to objects of type {{tt|T}} }}
{{par end}}

===Return value===
The old value of {{tt|obj}}

===Exceptions===
(none)

===Possible implementation===
{{eq fun| 1=
template&lt;class T, class U = T&gt;
T exchange(T&amp; obj, U&amp;&amp; new_value)
{
    T old_value = std::move(obj);
    obj = std::forward&lt;U&gt;(new_value);
    return old_value;
}
}}

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;
#include &lt;iterator&gt;

class stream
{
  public:

   using flags_type = int;

  public:

    flags_type flags() const
    { return flags_; }

    ///Replaces flags_ by newf, and returns the old value.
    flags_type flags(flags_type newf)
    { return std::exchange(flags_, newf); }

  private:

    flags_type flags_ = 0;
};

void f() { std::cout &lt;&lt; &quot;f()&quot;; }

int main()
{
   stream s;

   std::cout &lt;&lt; s.flags() &lt;&lt; '\n';
   std::cout &lt;&lt; s.flags(12) &lt;&lt; '\n';
   std::cout &lt;&lt; s.flags() &lt;&lt; &quot;\n\n&quot;;

   std::vector&lt;int&gt; v;

   //Since the second template parameter has a default value, it is possible
   //to use a braced-init-list as second argument. The expression below
   //is equivalent to std::exchange(v, std::vector&lt;int&gt;{1,2,3,4});

   std::exchange(v, {1,2,3,4});

   std::copy(begin(v),end(v), std::ostream_iterator&lt;int&gt;(std::cout,&quot;, &quot;));

   std::cout &lt;&lt; &quot;\n\n&quot;;

   void (*fun)();

   //the default value of template parameter also makes possible to use a
   //normal function as second argument. The expression below is equivalent to
   //std::exchange(fun, std::static_cast&lt;void(*)()&gt;(f))
   std::exchange(fun,f);
   fun();
}
 | output=
0
0
12

1, 2, 3, 4, 

f()
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc swap}}
{{dsc inc | cpp/atomic/dsc atomic_exchange}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/forward</title>
    <ns>0</ns>
    <id>2666</id>
    <revision>
      <id>72294</id>
      <parentid>70125</parentid>
      <timestamp>2014-08-05T12:58:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use {{v</comment>
      <text xml:space="preserve" bytes="3894">{{cpp/title|forward}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | num=1 |
template&lt; class T &gt;
T&amp;&amp; forward( typename std::remove_reference&lt;T&gt;::type&amp; t );
}}
{{dcl | since=c++14 | num=1 |
template&lt; class T &gt;
constexpr T&amp;&amp; forward( typename std::remove_reference&lt;T&gt;::type&amp; t );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | num=2 |
template&lt; class T &gt;
T&amp;&amp; forward( typename std::remove_reference&lt;T&gt;::type&amp;&amp; t );
}}
{{dcl | since=c++14 | num=2 |
template&lt; class T &gt;
constexpr T&amp;&amp; forward( typename std::remove_reference&lt;T&gt;::type&amp;&amp; t );
}}
{{dcl rev end}}
{{dcl end}}

When used according to the following recipe in a function template, forwards the argument to another function with the [[cpp/language/value_category|value category]] it had when passed to the calling function.

For example, if used in wrapper such as the following, the template behaves as described below:

{{cc|1=
template&lt;class T&gt;
void wrapper(T&amp;&amp; arg) 
{
    foo(std::forward&lt;T&gt;(arg)); // Forward a single argument.
}
}}

* If a call to {{tt|wrapper()}} passes an rvalue {{tt|std::string}}, then {{tt|T}} is deduced to {{tt|std::string}} (not {{tt|std::string&amp;}}, {{tt|const std::string&amp;}}, or {{tt|std::string&amp;&amp;}}), and {{tt|std::forward}} ensures that an rvalue reference is passed to {{tt|foo}}.
* If a call to {{tt|wrapper()}} passes a const lvalue {{tt|std::string}}, then {{tt|T}} is deduced to {{tt|const std::string&amp;}}, and {{tt|std::forward}} ensures that a const lvalue reference is passed to {{tt|foo}}.
* If a call to {{tt|wrapper()}} passes a non-const lvalue {{tt|std::string}}, then {{tt|T}} is deduced to {{tt|std::string&amp;}}, and {{tt|std::forward}} ensures that a non-const lvalue reference is passed to {{tt|foo}}.

===Notes===
Attempting to forward an rvalue as an lvalue, such as by instantiating the form {{v|2}} with lvalue reference type T, is a compile-time error.

See [[cpp/language/template_argument_deduction|template argument deduction]] for the special rules behind {{tt|T&amp;&amp;}} used as a function parameter.

===Parameters===
{{par begin}}
{{par | t | the object to be forwarded}}
{{par end}}

===Return value===
{{c|static_cast&lt;T&amp;&amp;&gt;(t)}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 | This example demonstrates perfect forwarding of the parameter(s) to the argument of the constructor of class {{tt|T}}. Also, perfect forwarding of parameter packs is demonstrated.
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;utility&gt;
#include &lt;array&gt;

struct A {
    A(int&amp;&amp; n) { std::cout &lt;&lt; &quot;rvalue overload, n=&quot; &lt;&lt; n &lt;&lt; &quot;\n&quot;; }
    A(int&amp; n)  { std::cout &lt;&lt; &quot;lvalue overload, n=&quot; &lt;&lt; n &lt;&lt; &quot;\n&quot;; }
};

class B {
public:
    template&lt;class T1, class T2, class T3&gt;
    B(T1&amp;&amp; t1, T2&amp;&amp; t2, T3&amp;&amp; t3) :
        a1_{std::forward&lt;T1&gt;(t1)},
        a2_{std::forward&lt;T2&gt;(t2)},
        a3_{std::forward&lt;T3&gt;(t3)}
    {
    }

private:
    A a1_, a2_, a3_;
};

template&lt;class T, class U&gt;
std::unique_ptr&lt;T&gt; make_unique1(U&amp;&amp; u)
{
    return std::unique_ptr&lt;T&gt;(new T(std::forward&lt;U&gt;(u)));
}

template&lt;class T, class... U&gt;
std::unique_ptr&lt;T&gt; make_unique(U&amp;&amp;... u)
{
    return std::unique_ptr&lt;T&gt;(new T(std::forward&lt;U&gt;(u)...));
}

int main()
{   
    auto p1 = make_unique1&lt;A&gt;(2); // rvalue
    int i = 1;
    auto p2 = make_unique1&lt;A&gt;(i); // lvalue

    std::cout &lt;&lt; &quot;B\n&quot;;
    auto t = make_unique&lt;B&gt;(2, i, 3);
}
 | output=
rvalue overload, n=2
lvalue overload, n=1
B
rvalue overload, n=2
lvalue overload, n=1
rvalue overload, n=3
}}

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc end}}

[[de:cpp/utility/forward]]
[[es:cpp/utility/forward]]
[[fr:cpp/utility/forward]]
[[it:cpp/utility/forward]]
[[ja:cpp/utility/forward]]
[[pt:cpp/utility/forward]]
[[ru:cpp/utility/forward]]
[[zh:cpp/utility/forward]]</text>
      <sha1>lixzh5z53nks0mr9qtt3y1vimc29x5o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional</title>
    <ns>0</ns>
    <id>2065</id>
    <revision>
      <id>64478</id>
      <parentid>59540</parentid>
      <timestamp>2013-08-18T02:56:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+bit_not</comment>
      <text xml:space="preserve" bytes="3772">{{title|Function objects}}
{{cpp/utility/functional/navbar}}

A ''function object'' is any object for which the function call operator is defined.  C++ provides many built-in function objects as well as support for creation and manipulation of new function objects.

===Polymorphic function wrappers===

{{lc|std::function}} provides support for storing arbitrary function objects.

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc mem_fn}}
{{dsc inc | cpp/utility/functional/dsc bad_function_call}}
{{dsc end}}

===Bind===

{{lc|std::bind}} provides support for [[enwiki:Partial_application|partial function application]], i.e. binding arguments to functions to produce new functions. 

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc inc | cpp/utility/functional/dsc is_bind_expression}}
{{dsc inc | cpp/utility/functional/dsc is_placeholder}}
{{dsc namespace | std::placeholders }}
{{dsc inc | cpp/utility/functional/dsc placeholders}}
{{dsc end}}

===Reference wrappers===

Reference wrappers allow reference arguments to be stored in copyable function objects:

{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc reference_wrapper}}
{{dsc inc | cpp/utility/functional/dsc ref}}
{{dsc end}}

===Function objects===

C++ defines several function objects that represent common arithmetic and logical operations:

{{dsc begin}}
{{dsc h2 | Arithmetic operations}}
{{dsc inc | cpp/utility/functional/dsc plus}}
{{dsc inc | cpp/utility/functional/dsc minus}}
{{dsc inc | cpp/utility/functional/dsc multiplies}}
{{dsc inc | cpp/utility/functional/dsc divides}}
{{dsc inc | cpp/utility/functional/dsc modulus}}
{{dsc inc | cpp/utility/functional/dsc negate}}

{{dsc h2 | Comparisons }}
{{dsc inc | cpp/utility/functional/dsc equal_to}}
{{dsc inc | cpp/utility/functional/dsc not_equal_to}}
{{dsc inc | cpp/utility/functional/dsc greater}}
{{dsc inc | cpp/utility/functional/dsc less}}
{{dsc inc | cpp/utility/functional/dsc greater_equal}}
{{dsc inc | cpp/utility/functional/dsc less_equal}}

{{dsc h2 | Logical operations }}
{{dsc inc | cpp/utility/functional/dsc logical_and}}
{{dsc inc | cpp/utility/functional/dsc logical_or}}
{{dsc inc | cpp/utility/functional/dsc logical_not}}

{{dsc h2 | Bitwise operations }}
{{dsc inc | cpp/utility/functional/dsc bit_and}}
{{dsc inc | cpp/utility/functional/dsc bit_or}}
{{dsc inc | cpp/utility/functional/dsc bit_xor}}
{{dsc inc | cpp/utility/functional/dsc bit_not}}

{{dsc h2 | Negators }}
{{dsc inc | cpp/utility/functional/dsc unary_negate}}
{{dsc inc | cpp/utility/functional/dsc binary_negate}}
{{dsc inc | cpp/utility/functional/dsc not1}}
{{dsc inc | cpp/utility/functional/dsc not2}}
{{dsc end}}

===Deprecated in C++11===

Several utilities that provided early functional support are deprecated in C++11:

{{dsc begin}}
{{dsc h2 | Base}}
{{dsc inc | cpp/utility/functional/dsc unary_function}}
{{dsc inc | cpp/utility/functional/dsc binary_function}}

{{dsc h2 | Binders}}
{{dsc inc | cpp/utility/functional/dsc binder12}}
{{dsc inc | cpp/utility/functional/dsc bind12}}

{{dsc h2 | Function adaptors}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_unary_function}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_binary_function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_t}}
{{dsc inc | cpp/utility/functional/dsc mem_fun}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref_t}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref}}
{{dsc end}}

[[de:cpp/utility/functional]]
[[es:cpp/utility/functional]]
[[fr:cpp/utility/functional]]
[[it:cpp/utility/functional]]
[[ja:cpp/utility/functional]]
[[pt:cpp/utility/functional]]
[[ru:cpp/utility/functional]]
[[zh:cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bad function call</title>
    <ns>0</ns>
    <id>3451</id>
    <revision>
      <id>63078</id>
      <parentid>59543</parentid>
      <timestamp>2013-07-01T23:53:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1572">{{cpp/title|bad_function_call}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl | since=c++11 | 1=
class bad_function_call;
}}
{{dcl end}}

{{tt|std::bad_function_call}} is the type of the exception thrown by [[cpp/utility/functional/function/operator()| {{tt|std::function::operator()}} ]] if the function wrapper has no target.

{{inheritance diagram/std-bad_function_call}}
===Member functions===
{{dsc begin}}
{{dsc mem ctor | bad_function_call() | nolink=true | constructs the bad_function_call object}}
{{dsc end}}

{{member | {{small|std::bad_function_call::}}bad_function_call() | 2=
{{ddcl | 1=
bad_function_call();
}}

Constructs a new instance of {{tt|std::bad_function_call}}.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

}}

{{cpp/error/exception/inherit}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;

int main()
{
    std::function&lt;int()&gt; f = nullptr;
    try {
        f();
    } catch(const std::bad_function_call&amp; e) {
        std::cout &lt;&lt; e.what() &lt;&lt; '\n';
    }
}
 | output=
bad function call
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc end}}

[[de:cpp/utility/functional/bad function call]]
[[es:cpp/utility/functional/bad function call]]
[[fr:cpp/utility/functional/bad function call]]
[[it:cpp/utility/functional/bad function call]]
[[ja:cpp/utility/functional/bad function call]]
[[pt:cpp/utility/functional/bad function call]]
[[ru:cpp/utility/functional/bad function call]]
[[zh:cpp/utility/functional/bad function call]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/binary function</title>
    <ns>0</ns>
    <id>5156</id>
    <revision>
      <id>67555</id>
      <parentid>59544</parentid>
      <timestamp>2014-02-11T18:24:03Z</timestamp>
      <contributor>
        <username>Fanael</username>
        <id>1958</id>
      </contributor>
      <comment>nope</comment>
      <text xml:space="preserve" bytes="2715">{{cpp/title|binary_function}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | notes={{mark deprecated}} | 1=
template&lt;
    class Arg1,
    class Arg2, 
    class Result
&gt; struct binary_function;
}}
{{dcl end}}

{{tt|binary_function}} is a base class for creating function objects with two arguments.

{{tt|binary_function}} does not define {{c|operator()}}; it is expected that derived classes will define this. {{tt|binary_function}} provides only three types - {{tt|first_argument_type}}, {{tt|second_argument_type}} and {{tt|result_type}} - defined by the template parameters.

Some standard library function object adaptors, such as {{lc|std::not2}}, require the function objects they adapt to have certain types defined; {{lc|std::not2}} requires the function object being adapted to have two types named {{tt|first_argument_type}} and {{tt|second_argument_type}}. Deriving function objects that take two arguments from {{tt|binary_function}} is an easy way to make them compatible with those adaptors.

{{tt|binary_function}} is deprecated in C++11.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|first_argument_type}} | {{tt|Arg1}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|Arg2}} }}
{{dsc | {{tt|result_type}} | {{tt|Result}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

struct same : std::binary_function&lt;int, int, bool&gt;
{
    bool operator()(int a, int b) const { return a == b; }
};

int main()
{
    std::vector&lt;int&gt; v1{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector&lt;int&gt; v2{10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
    std::vector&lt;bool&gt; v3(v1.size());
    
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), std::not2(same()));
    
    std::cout &lt;&lt; std::boolalpha;
    for (std::size_t i = 0; i &lt; v1.size(); ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';
}
 | output=
0 10 true
1 9 true
2 8 true
3 7 true
4 6 true
5 5 false
6 4 true
7 3 true
8 2 true
9 1 true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_binary_function}}
{{dsc inc | cpp/utility/functional/dsc unary_function}}
{{dsc end}}

[[de:cpp/utility/functional/binary function]]
[[es:cpp/utility/functional/binary function]]
[[fr:cpp/utility/functional/binary function]]
[[it:cpp/utility/functional/binary function]]
[[ja:cpp/utility/functional/binary function]]
[[pt:cpp/utility/functional/binary function]]
[[ru:cpp/utility/functional/binary function]]
[[zh:cpp/utility/functional/binary function]]</text>
      <sha1>fifrx6j0msmjehrwwhypx97fv4ciblz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/binary negate</title>
    <ns>0</ns>
    <id>5162</id>
    <revision>
      <id>66308</id>
      <parentid>61841</parentid>
      <timestamp>2013-11-10T02:29:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr. Finally done with n3789</comment>
      <text xml:space="preserve" bytes="5002">{{cpp/title|binary_negate}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class Predicate &gt;
struct binary_negate :
    public std::binary_function&lt;
        Predicate::first_argument_type,
        Predicate::second_argument_type,
        bool
    &gt;;
}}
{{dcl | since=c++11 |
template&lt; class Predicate &gt;
struct binary_negate;
}}
{{dcl rev end}}
{{dcl end}}

{{tt|binary_negate}} is a wrapper function object returning the complement of the binary predicate it holds.

The binary predicate type must define two member types, {{tt|first_argument_type}} and {{tt|second_argument_type}}, that are convertible to the predicate's parameter types. The function objects obtained from {{lc|std::owner_less}}, {{lc|std::ref}}, {{lc|std::cref}}, {{lc|std::plus}}, {{lc|std::minus}}, {{lc|std::multiplies}}, {{lc|std::divides}}, {{lc|std::modulus}}, {{lc|std::equal_to}}, {{lc|std::not_equal_to}}, {{lc|std::greater}}, {{lc|std::less}}, {{lc|std::greater_equal}}, {{lc|std::less_equal}}, {{lc|std::logical_not}}, {{lc|std::logical_or}}, {{lc|std::bit_and}}, {{lc|std::bit_or}}, {{lc|std::bit_xor}}, {{lc|std::mem_fn}}, {{lc|std::map::value_comp}}, {{lc|std::multimap::value_comp}}, {{lc|std::function}}, or from a call to {{lc|std::not2}} have these types defined, as are function objects derived from the deprecated {{lc|std::binary_function}}. 

{{tt|binary_negate}} objects are easily constructed with helper function {{lc|std::not2}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|first_argument_type}} | {{c|Predicate::first_argument_type}} }}
{{dsc | {{tt|second_argument_type}} | {{c|Predicate::second_argument_type}} }}
{{dsc | {{tt|result_type}} | {{c|bool}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | constructs a new binary_negate object with the supplied predicate}}
{{dsc mem fun | operator() | nolink=true | returns the logical complement of the result of a call to the stored predicate}}
{{dsc end}}

{{member | {{small|std::binary_negate::}}binary_negate | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
explicit binary_negate( Predicate const&amp; pred );
}}
{{dcl |since=c++14|
explicit constexpr binary_negate( Predicate const&amp; pred );
}}
{{dcl rev end}}
{{dcl end}}

Constructs a {{tt|binary_negate}} function object with the stored predicate {{tt|pred}}.

===Parameters===
{{par begin}}
{{par | pred | predicate function object}}
{{par end}}
}}

{{member | {{small|std::binary_negate::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( first_argument_type const&amp; x,
                 second_argument_type const&amp; y ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( first_argument_type const&amp; x,
                           second_argument_type const&amp; y ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the logical complement of the result of calling  {{c|pred(x, y)}}.

===Parameters===
{{par begin}}
{{par | x | first argument to pass through to predicate}}
{{par | y | second argument to pass through to predicate}}
{{par end}}

===Return value===
The logical complement of the result of calling {{c|pred(x, y)}}.

}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

struct same : std::binary_function&lt;int, int, bool&gt;
{
    bool operator()(int a, int b) const { return a == b; }
};

int main()
{
    std::vector&lt;int&gt; v1;
    std::vector&lt;int&gt; v2;
    for (int i = 0; i &lt; 10; ++i) v1.push_back(i);
    for (int i = 0; i &lt; 10; ++i) v2.push_back(10 - i);
    
    std::vector&lt;bool&gt; v3(v1.size());
    
    std::binary_negate&lt;same&gt; not_same((same()));
    
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), not_same);
    
    /* C++11 solution:
        // Use std::function&lt;bool (int, int)&gt;
        std::function&lt;bool (int, int)&gt; not_same =
            [](int x, int y)-&gt;bool{ return !same()(x, y); };
        
        std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), not_same);
    */
    
    std::cout.setf(std::ios_base::boolalpha);
    for (int i = 0; i &lt; 10; ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';
}
 | output=
0 10 true
1 9 true
2 8 true
3 7 true
4 6 true
5 5 false
6 4 true
7 3 true
8 2 true
9 1 true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc binary_function}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc not2}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc unary_negate}}
{{dsc end}}

[[de:cpp/utility/functional/binary negate]]
[[es:cpp/utility/functional/binary negate]]
[[fr:cpp/utility/functional/binary negate]]
[[it:cpp/utility/functional/binary negate]]
[[ja:cpp/utility/functional/binary negate]]
[[pt:cpp/utility/functional/binary negate]]
[[ru:cpp/utility/functional/binary negate]]
[[zh:cpp/utility/functional/binary negate]]</text>
      <sha1>osv8z1gaitmc6ge19bsbmcmdxw3jsl2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bind</title>
    <ns>0</ns>
    <id>4161</id>
    <revision>
      <id>72012</id>
      <parentid>71949</parentid>
      <timestamp>2014-07-08T13:28:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>rephrase move/copy-constructible requirements, move data members inside the block about the return type</comment>
      <text xml:space="preserve" bytes="6808">{{cpp/title|bind}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 | num=1|
template&lt; class F, class... Args &gt;
/*unspecified*/ bind( F&amp;&amp; f, Args&amp;&amp;... args );
}}
{{dcl | since=c++11 | num=2|
template&lt; class R, class F, class... Args &gt;
/*unspecified*/ bind( F&amp;&amp; f, Args&amp;&amp;... args );
}}
{{dcl end}}

The function template {{tt|bind}} generates a forwarding call wrapper for {{tt|f}}. Calling this wrapper is equivalent to invoking {{tt|f}} with some of its arguments bound to {{tt|args}}. 

===Parameters===
{{par begin}}
{{par | f | {{concept|Callable}} object (function object, pointer to function, reference to function, pointer to member function, or pointer to data member) that will be bound to some arguments}}
{{par | args | list of arguments to bind, with the unbound arguments replaced by the placeholders {{tt|_1, _2, _3...}} of namespace {{tt|std::placeholders}} }}
{{par end}}

===Return value===
A function object of unspecified type {{tt|T}}, for which {{c|1=std::is_bind_expression&lt;T&gt;::value == true}}, and which can be stored in {{lc|std::function}}. It has the following members:

{{member | {{small|std::bind}} ''return type'' | 2=

====Member objects====
The return type of {{tt|std::bind}} holds a member object of type {{c|std::decay&lt;F&gt;::type}} constructed from {{c|std::forward&lt;F&gt;(f)}}, and one object per each of {{tt|args...}}, of type {{c|std::decay&lt;Arg_i&gt;::type}}, similarly constructed from {{c|std::forward&lt;Arg_i&gt;(arg_i)}}.

====Constructors====
The return type of {{tt|std::bind}} is {{concept|CopyConstructible}} if all of its member objects (specified above) are CopyConstructible, and is {{concept|MoveConstructible}} otherwise. The type defines the following members:

====Member type {{tt|result_type}}====

1) If {{tt|F}} is a pointer to function or a pointer to member function, {{tt|result_type}} is the return type of {{tt|F}}. If {{tt|F}} is a class type with nested typedef {{tt|result_type}}, then {{tt|result_type}} is {{tt|F::result_type}}.  Otherwise no {{tt|result_type}} is defined.

2) {{tt|result_type}} is exactly {{tt|R}}.

====Member function {{tt|operator()}}====

Given an object {{tt|g}} obtained from an earlier call to {{tt|bind}}, when it is invoked in a function call expression {{c|g(u1, u2, ... uM)}}, an invocation of the stored object of type {{c|std::decay&lt;F&gt;::type}} takes place, with arguments defined as follows:

* If the argument is of type {{tt|std::reference_wrapper&lt;T&gt;}} (for example, {{lc|std::ref}} or {{lc|std::cref}} was used in the initial call to {{tt|bind}}), then the reference {{tt|T&amp;}} stored in the bound argument is passed to the invocable object.
* If {{c|1=std::is_bind_expression&lt;T&gt;::value == true}} (i.e. another {{tt|bind}} subexpression was used as an argument in the initial call to {{tt|bind}}), then that bind subexpression is invoked immediately and its result is passed to the invocable object. If the bind subexpression has any placeholder arguments, they are picked from {{tt|u1, u2, ...}}.
* If {{c|1=std::is_placeholder&lt;T&gt;::value != 0}} (i.e., {{tt|std::placeholders::_1, _2, _3, ...}} was used as the argument to the initial call to {{tt|bind}}), then the argument indicated by the placeholder ({{tt|u1}} for {{tt|_1}}, {{tt|u2}} for {{tt|_2}}, etc) is passed to the invocable object as {{c|std::forward&lt;Uj&gt;(uj)}}.
* Otherwise, the stored argument is passed to the invocable object as-is.

If some of the arguments that are supplied in the call to {{tt|g()}} are not matched by any placeholders stored in {{tt|g}}, the unused arguments are evaluated and discarded.

}}

===Exceptions===
Only throws if construction of {{c|std::decay&lt;F&gt;::type}} from {{c|std::forward&lt;F&gt;(f)}} throws, or any of the constructors for {{c|std::decay&lt;Arg_i&gt;::type}} from the corresponding {{c|std::forward&lt;Arg_i&gt;(arg_i)}} throws where {{tt|Arg_i}} is the ith type and {{tt|arg_i}} is the ith argument in {{tt|Args... args}}.

===Notes===
As described in {{concept|Callable}}, when invoking a pointer to non-static member function or pointer to non-static data member, the first argument has to be a reference or pointer (including, possibly, smart pointer such as {{lc|std::shared_ptr}} and {{lc|std::unique_ptr}}) to an object whose member will be accessed.

The arguments to bind are copied or moved, and are never passed by reference unless wrapped in {{lc|std::ref}} or {{lc|std::cref}}.

Duplicate placeholders in the same bind expression (multiple {{tt|_1}}'s for example) are allowed, but the results are only well defined if the corresponding argument ({{tt|u1}}) is an lvalue or non-movable rvalue.

===Example===
{{example
 |
 | code=
#include &lt;random&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;functional&gt;

void f(int n1, int n2, int n3, const int&amp; n4, int n5)
{
    std::cout &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; ' ' &lt;&lt; n4 &lt;&lt; ' ' &lt;&lt; n5 &lt;&lt; '\n';
}

int g(int n1)
{
    return n1;
}

struct Foo {
    void print_sum(int n1, int n2)
    {
        std::cout &lt;&lt; n1+n2 &lt;&lt; '\n';
    }
    int data = 10;
};

int main()
{
    using namespace std::placeholders;  // for _1, _2, _3...

    // demonstrates argument reordering and pass-by-reference
    int n = 7;
    // (_1 and _2 are from std::placeholders, and represent future
    // arguments that will be passed to f1)
    auto f1 = std::bind(f, _2, _1, 42, std::cref(n), n);
    n = 10;
    f1(1, 2, 1001); // 1 is bound by _1, 2 is bound by _2, 1001 is unused

    // nested bind subexpressions share the placeholders
    auto f2 = std::bind(f, _3, std::bind(g, _3), _3, 4, 5);
    f2(10, 11, 12);

    // common use case: binding a RNG with a distribution
    std::default_random_engine e;
    std::uniform_int_distribution&lt;&gt; d(0, 10);
    std::function&lt;int()&gt; rnd = std::bind(d, e); // a copy of e is stored in rnd
    for(int n=0; n&lt;10; ++n)
        std::cout &lt;&lt; rnd() &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
 
    // bind to a member function
    Foo foo;
    auto f3 = std::bind(&amp;Foo::print_sum, &amp;foo, 95, _1);
    f3(5);

    // bind to member data
    auto f4 = std::bind(&amp;Foo::data, _1);
    std::cout &lt;&lt; f4(foo) &lt;&lt; '\n';

    // smart pointers can be used to call members of the referenced objects, too
    std::cout &lt;&lt; f4(std::make_shared&lt;Foo&gt;(foo)) &lt;&lt; '\n'
              &lt;&lt; f4(std::unique_ptr&lt;Foo&gt;(new Foo(foo))) &lt;&lt; '\n';}
 | output=
2 1 42 10 7
12 12 12 4 5
1 5 0 2 0 8 2 2 10 8
100
10
10
10
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc placeholders}}
{{dsc inc | cpp/utility/functional/dsc mem_fn}}
{{dsc end}}

[[de:cpp/utility/functional/bind]]
[[es:cpp/utility/functional/bind]]
[[fr:cpp/utility/functional/bind]]
[[it:cpp/utility/functional/bind]]
[[ja:cpp/utility/functional/bind]]
[[pt:cpp/utility/functional/bind]]
[[ru:cpp/utility/functional/bind]]
[[zh:cpp/utility/functional/bind]]</text>
      <sha1>9kquk08vli0x54fyrihqi07qpjymz32</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bind12</title>
    <ns>0</ns>
    <id>5480</id>
    <revision>
      <id>59551</id>
      <parentid>51629</parentid>
      <timestamp>2013-06-01T06:37:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1504">{{cpp/title | bind1st | bind2nd}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class F, class T &gt;
std::binder1st&lt;F&gt; bind1st( const F&amp; f, const T&amp; x );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class F, class T &gt;
std::binder2nd&lt;F&gt; bind2nd( const F&amp; f, const T&amp; x );
}}
{{dcl end}}

Binds a given argument {{tt|x}} to a first or second parameter of the given binary function object {{tt|f}}. That is, stores {{tt|x}} within the resulting wrapper, which, if called, passes {{tt|x}} as the first or the second parameter of {{tt|f}}.

1) Binds the first argument of {{tt|f}} to {{tt|x}}. Effectively calls {{c|std::binder1st&lt;F&gt;(f, typename F::first_argument_type(x))}}.

2) Binds the second argument of {{tt|f}} to {{tt|x}}. Effectively calls {{c|std::binder2nd&lt;F&gt;(f, typename F::second_argument_type(x))}}.

===Parameters===
{{par begin}}
{{par | f | pointer to a function to bind an argument to}}
{{par | x | argument to bind to {{tt|f}}}}
{{par end}}

===Return value===
A function object wrapping {{tt|f}} and {{tt|x}}.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc binder12}}
{{dsc end}}

[[de:cpp/utility/functional/bind12]]
[[es:cpp/utility/functional/bind12]]
[[fr:cpp/utility/functional/bind12]]
[[it:cpp/utility/functional/bind12]]
[[ja:cpp/utility/functional/bind12]]
[[pt:cpp/utility/functional/bind12]]
[[ru:cpp/utility/functional/bind12]]
[[zh:cpp/utility/functional/bind12]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/binder12</title>
    <ns>0</ns>
    <id>10176</id>
    <revision>
      <id>59552</id>
      <parentid>51630</parentid>
      <timestamp>2013-06-01T06:37:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1957">{{cpp/title | binder1st | binder2nd}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 | 
template&lt; class Fn &gt;
class binder1st : public std::unary_function&lt;typename Fn::second_argument_type, 
                                             typename Fn::result_type&gt; {
protected:
    
    Fn op;
    typename Fn::first_argument_type value;

public:

    binder1st(const Fn&amp; fn, 
              const typename Fn::first_argument_type&amp; value);

    typename Fn::result_type 
        operator()(const typename Fn::second_argument_type&amp; x) const;

    typename Fn::result_type 
        operator()(typename Fn::second_argument_type&amp; x) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Fn &gt;
class binder2nd : public unary_function&lt;typename Fn::first_argument_type,
                                        typename Fn::result_type&gt; {
protected:
    Fn op;
    typename Fn::second_argument_type value;
public:
    binder2nd(const Fn&amp; fn, 
              const typename Fn::second_argument_type&amp; value);

    typename Fn::result_type 
        operator()(const typename Fn::first_argument_type&amp; x) const;

    typename Fn::result_type 
        operator()(typename Fn::first_argument_type&amp; x) const;
};
}}
{{dcl end}}

A function object that binds an argument to a binary function.

The value of the parameter is passed to the object at the construction time and stored within the object. Whenever the function object is invoked though {{c|operator()}}, the stored value is passed as one of the arguments, the other argument is passed as an argument of {{c|operator()}}. The resulting function object is an unary function.

@1@ Binds the first parameter to the value {{tt|value}} given at the construction of the object.

@2@ Binds the second parameter to the value {{tt|value}} given at the construction of the object.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind12}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit and</title>
    <ns>0</ns>
    <id>4767</id>
    <revision>
      <id>66293</id>
      <parentid>51631</parentid>
      <timestamp>2013-11-10T02:04:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2007">{{cpp/title|bit_and}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct bit_and;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct bit_and;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing bitwise AND. Effectively calls {{c|operator&amp;}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::bit_and}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bit_and_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the result of bitwise AND of two arguments}}
{{dsc end}}

{{member | {{small|std::bit_and::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the result of bitwise AND of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise AND of}}
{{par end}}

===Return value===
The result of {{c|lhs &amp; rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &amp; rhs;
}
}}
}}

[[de:cpp/utility/functional/bit and]]
[[es:cpp/utility/functional/bit and]]
[[fr:cpp/utility/functional/bit and]]
[[it:cpp/utility/functional/bit and]]
[[ja:cpp/utility/functional/bit and]]
[[pt:cpp/utility/functional/bit and]]
[[ru:cpp/utility/functional/bit and]]
[[zh:cpp/utility/functional/bit and]]</text>
      <sha1>nts0saasqfcvviip60r5twoa9dfuzaa</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit and void</title>
    <ns>0</ns>
    <id>13080</id>
    <revision>
      <id>66304</id>
      <timestamp>2013-11-10T02:23:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1055">{{cpp/title|bit_and&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class bit_and&lt;void&gt;;
}}

{{c|std::bit_and&lt;&gt;}} is a specialization of {{lc|std::bit_and}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/bit_and_void | title=operator() | inlinemem=true | applies {{tt|operator&amp;}} to lhs and rhs}}
{{dsc end}}

{{member | {{small|std::bit_and&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &amp; std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs &amp; rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise AND for}}
{{par end}}

===Return value===
The result of {{c|lhs &amp; rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>1glharrgyyzf7ejjwl8s6pfltdjfygz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit not</title>
    <ns>0</ns>
    <id>13078</id>
    <revision>
      <id>66303</id>
      <parentid>66300</parentid>
      <timestamp>2013-11-10T02:21:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1676">{{cpp/title|bit_not}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct bit_not;
}}
{{dcl end}}

Function object for performing bitwise NOT. Effectively calls {{c|operator~}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::bit_not}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bit_not_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the result of bitwise NOT of its argument}}
{{dsc end}}

{{member | {{small|std::bit_not::}}operator() | 2=
{{dcl begin}}
{{dcl|
constexpr T operator()( const T&amp; arg ) const;
}}
{{dcl end}}

Returns the result of bitwise NOT of {{tt|arg}}.

===Parameters===
{{par begin}}
{{par | arg | value to compute bitwise NOT of}}
{{par end}}

===Return value===
The result of {{c|~arg}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T&amp; arg) const 
{
    return ~arg;
}
}}
}}

[[de:cpp/utility/functional/bit not]]
[[es:cpp/utility/functional/bit not]]
[[fr:cpp/utility/functional/bit not]]
[[it:cpp/utility/functional/bit not]]
[[ja:cpp/utility/functional/bit not]]
[[pt:cpp/utility/functional/bit not]]
[[ru:cpp/utility/functional/bit not]]
[[zh:cpp/utility/functional/bit not]]</text>
      <sha1>j9asdkvhlkdwxcw67nzq4gsoed8cxoc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit not void</title>
    <ns>0</ns>
    <id>13079</id>
    <revision>
      <id>66302</id>
      <parentid>66301</parentid>
      <timestamp>2013-11-10T02:21:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stray parentheses</comment>
      <text xml:space="preserve" bytes="998">{{cpp/title|bit_not&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class bit_not&lt;void&gt;;
}}

{{c|std::bit_not&lt;&gt;}} is a specialization of {{lc|std::bit_not}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/bit_not_void | title=operator() | inlinemem=true | applies {{tt|operator~}} to its argument}}
{{dsc end}}

{{member | {{small|std::bit_not&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T &gt;
constexpr auto operator()( T&amp;&amp; arg ) const
  -&gt; decltype(~std::forward&lt;T&gt;(lhs));
}}

Returns the result of {{tt|~arg}}.

===Parameters===
{{par begin}}
{{par | arg | value to apply bitwise NOT to}}
{{par end}}

===Return value===
The result of {{c|~arg}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>c2gff4vghfre58ms2bc463ibn2ssaf8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit or</title>
    <ns>0</ns>
    <id>4768</id>
    <revision>
      <id>66296</id>
      <parentid>51632</parentid>
      <timestamp>2013-11-10T02:06:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2001">{{cpp/title|bit_or}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct bit_or;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct bit_or;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing bitwise OR. Effectively calls {{c|operator{{!}}}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::bit_or}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bit_or_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the result of bitwise OR of two arguments}}
{{dsc end}}

{{member | {{small|std::bit_or::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the result of bitwise OR of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise OR of}}
{{par end}}

===Return value===
The result of {{c|lhs {{!}} rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs {{!}} rhs;
}
}}
}}

[[de:cpp/utility/functional/bit or]]
[[es:cpp/utility/functional/bit or]]
[[fr:cpp/utility/functional/bit or]]
[[it:cpp/utility/functional/bit or]]
[[ja:cpp/utility/functional/bit or]]
[[pt:cpp/utility/functional/bit or]]
[[ru:cpp/utility/functional/bit or]]
[[zh:cpp/utility/functional/bit or]]</text>
      <sha1>fp8y4sdvo1dwdhtalggqne7sbrkjgr6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit or void</title>
    <ns>0</ns>
    <id>13081</id>
    <revision>
      <id>66305</id>
      <timestamp>2013-11-10T02:24:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/title|bit_or&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class bit_or&lt;void&gt;;
}}

{{c|std::bit_or&lt;&gt;}} is a specialization of {{lc|std::bit_or}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/bit_or_void | title=operator() | inlinemem=true | applies {{tt|operator{{!}}}} to lhs and rhs}}
{{dsc end}}

{{member | {{small|std::bit_or&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) {{!}} std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs {{!}} rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise OR for}}
{{par end}}

===Return value===
The result of {{c|lhs {{!}} rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>9a6hl19qer1uvx8dpt9rvmy676o147e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit xor</title>
    <ns>0</ns>
    <id>4769</id>
    <revision>
      <id>66298</id>
      <parentid>51633</parentid>
      <timestamp>2013-11-10T02:08:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2007">{{cpp/title|bit_xor}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct bit_xor;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct bit_xor;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing bitwise XOR. Effectively calls {{c|operator^}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::bit_xor}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bit_xor_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the result of bitwise XOR of two arguments}}
{{dsc end}}

{{member | {{small|std::bit_xor::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the result of bitwise XOR of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise XOR of}}
{{par end}}

===Return value===
The result of {{c|lhs ^ rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs ^ rhs;
}
}}
}}

[[de:cpp/utility/functional/bit xor]]
[[es:cpp/utility/functional/bit xor]]
[[fr:cpp/utility/functional/bit xor]]
[[it:cpp/utility/functional/bit xor]]
[[ja:cpp/utility/functional/bit xor]]
[[pt:cpp/utility/functional/bit xor]]
[[ru:cpp/utility/functional/bit xor]]
[[zh:cpp/utility/functional/bit xor]]</text>
      <sha1>ng90i4qznemn9qdyl20g3rzscdchb1q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/bit xor void</title>
    <ns>0</ns>
    <id>13082</id>
    <revision>
      <id>66306</id>
      <timestamp>2013-11-10T02:25:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1055">{{cpp/title|bit_xor&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class bit_xor&lt;void&gt;;
}}

{{c|std::bit_xor&lt;&gt;}} is a specialization of {{lc|std::bit_xor}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/bit_xor_void | title=operator() | inlinemem=true | applies {{tt|operator^}} to lhs and rhs}}
{{dsc end}}

{{member | {{small|std::bit_xor&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) ^ std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs ^ rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute bitwise XOR for}}
{{par end}}

===Return value===
The result of {{c|lhs ^ rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>2kwzu2lwgmpzxd6onzux49nhrs7ozr0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/cref</title>
    <ns>0</ns>
    <id>8372</id>
    <redirect title="cpp/utility/functional/ref" />
    <revision>
      <id>29854</id>
      <timestamp>2012-05-03T09:53:43Z</timestamp>
      <contributor>
        <ip>62.159.77.164</ip>
      </contributor>
      <comment>Redirected page to [[cpp/utility/functional/ref]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/utility/functional/ref]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/divides</title>
    <ns>0</ns>
    <id>4053</id>
    <revision>
      <id>66245</id>
      <parentid>66227</parentid>
      <timestamp>2013-11-10T00:50:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>forgot c++14 in the declaration</comment>
      <text xml:space="preserve" bytes="2044">{{cpp/title|divides}}
{{cpp/utility/functional/navbar}}

{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct divides;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct divides;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing division. Effectively calls {{c|operator/}} on two instances of type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::divides}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc divides_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the result of the division of the first argument by the second argument}}
{{dsc end}}

{{member | {{small|std::divides::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the result of division of {{tt|lhs}} by {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to divide one by other}}
{{par end}}

===Return value===
The result of {{c|lhs / rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs / rhs;
}
}}
}}

[[de:cpp/utility/functional/divides]]
[[es:cpp/utility/functional/divides]]
[[fr:cpp/utility/functional/divides]]
[[it:cpp/utility/functional/divides]]
[[ja:cpp/utility/functional/divides]]
[[pt:cpp/utility/functional/divides]]
[[ru:cpp/utility/functional/divides]]
[[zh:cpp/utility/functional/divides]]</text>
      <sha1>mf9pbd97jw7cdwygi8ftcn81ofoxs5s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/divides void</title>
    <ns>0</ns>
    <id>13052</id>
    <revision>
      <id>66275</id>
      <parentid>66236</parentid>
      <timestamp>2013-11-10T01:34:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1103">{{cpp/title|divides&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class divides&lt;void&gt;;
}}

{{c|std::divides&lt;&gt;}} is a specialization of {{lc|std::divides}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/divides_void | title=operator() | inlinemem=true | returns the quotient of two arguments}}
{{dsc end}}

{{member | {{small|std::divides&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) / std::forward&lt;U&gt;(rhs));
}}

Returns the result of dividing {{tt|lhs}} by {{tt|rhs}} (or whatever {{tt|operator/}} is overloaded to do)

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to divide}}
{{par end}}

===Return value===
The result of {{c|lhs / rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>29t4sbfzki7a4t2ffx26oq89s1cgiwk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/equal to</title>
    <ns>0</ns>
    <id>4058</id>
    <revision>
      <id>66248</id>
      <parentid>66247</parentid>
      <timestamp>2013-11-10T00:52:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stray line</comment>
      <text xml:space="preserve" bytes="2037">{{cpp/title|equal_to}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct equal_to;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct equal_to;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialised, invokes {{c|operator{{==}}}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::equal_to}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc equal_to_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the arguments are ''equal''}}
{{dsc end}}

{{member | {{small|std::equal_to::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|lhs}} is ''equal'' to {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs == rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs == rhs;
}
}}
}}

[[de:cpp/utility/functional/equal to]]
[[es:cpp/utility/functional/equal to]]
[[fr:cpp/utility/functional/equal to]]
[[it:cpp/utility/functional/equal to]]
[[ja:cpp/utility/functional/equal to]]
[[pt:cpp/utility/functional/equal to]]
[[ru:cpp/utility/functional/equal to]]
[[zh:cpp/utility/functional/equal to]]</text>
      <sha1>aiafe7zrb8kl7c4pakneyolsa4q2cnt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/equal to void</title>
    <ns>0</ns>
    <id>13061</id>
    <revision>
      <id>66273</id>
      <parentid>66262</parentid>
      <timestamp>2013-11-10T01:34:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1089">{{cpp/title|equal_to&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class equal_to&lt;void&gt;;
}}

{{c|std::equal_to&lt;&gt;}} is a specialization of {{lc|std::equal_to}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/equal_to_void | title=operator() | inlinemem=true | tests if the two arguments compare equal}}
{{dsc end}}

{{member | {{small|std::equal_to&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) == std::forward&lt;U&gt;(rhs));
}}

Returns the result of equality comparison between {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|lhs {{==}} rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>nhvkymobisbltw2vlopgubuh8zymjef</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function</title>
    <ns>0</ns>
    <id>2698</id>
    <revision>
      <id>72135</id>
      <parentid>71464</parentid>
      <timestamp>2014-07-17T16:07:33Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>mention pointer to members are also allowed</comment>
      <text xml:space="preserve" bytes="4406">{{cpp/title|function}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 |
template&lt; class &gt;
class function; /* undefined */
}}
{{dcl | since=c++11 |
template&lt; class R, class... Args &gt;
class function&lt;R(Args...)&gt;
}}
{{dcl end}}

Class template {{tt|std::function}} is a general-purpose polymorphic function wrapper. Instances of {{tt|std::function}} can store, copy, and invoke any {{concept|Callable}} ''target'' -- functions, [[cpp/language/lambda|lambda expressions]], [[cpp/utility/functional/bind|bind expressions]], or other function objects, as well as pointers to member functions and pointers to data members.

The stored callable object is called the ''target'' of {{tt|std::function}}. If a {{tt|std::function}} contains no target, it is called ''empty''. Invoking the ''target'' of an ''empty'' {{tt|std::function}} results in {{lc|std::bad_function_call}} exception being thrown.

{{tt|std::function}} satisfies the requirements of {{concept|CopyConstructible}} and {{concept|CopyAssignable}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|R}}}}
{{dsc | {{tt|argument_type}} | {{tt|T}} if {{c|1=sizeof...(Args)==1}} and {{tt|T}} is the first and only type in {{tt|Args...}} }}
{{dsc | {{tt|first_argument_type}} | {{tt|T1}} if {{c|1=sizeof...(Args)==2}} and {{tt|T1}} is the first of the two types in {{tt|Args...}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T2}} if {{c|1=sizeof...(Args)==2}} and {{tt|T2}} is the second of the two types in {{tt|Args...}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc constructor}}
{{dsc inc | cpp/utility/functional/function/dsc destructor}}
{{dsc inc | cpp/utility/functional/function/dsc operator{{=}}}}
{{dsc inc | cpp/utility/functional/function/dsc swap}}
{{dsc inc | cpp/utility/functional/function/dsc assign}}
{{dsc inc | cpp/utility/functional/function/dsc operator_bool}}
{{dsc inc | cpp/utility/functional/function/dsc operator()}}

{{dsc h2 | Target access}}
{{dsc inc | cpp/utility/functional/function/dsc target_type}}
{{dsc inc | cpp/utility/functional/function/dsc target}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc swap2}}
{{dsc inc | cpp/utility/functional/function/dsc operator_cmp}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc uses_allocator}}
{{dsc end}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout &lt;&lt; num_+i &lt;&lt; '\n'; }
    int num_;
};
 
void print_num(int i)
{
    std::cout &lt;&lt; i &lt;&lt; '\n';
}

struct PrintNum {
    void operator()(int i) const
    {
        std::cout &lt;&lt; i &lt;&lt; '\n';
    }
};
 
int main()
{
    // store a free function
    std::function&lt;void(int)&gt; f_display = print_num;
    f_display(-9);
 
    // store a lambda
    std::function&lt;void()&gt; f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // store the result of a call to std::bind
    std::function&lt;void()&gt; f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // store a call to a member function
    std::function&lt;void(const Foo&amp;, int)&gt; f_add_display = &amp;Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    
    // store a call to a member function and object
    using std::placeholders::_1;
    std::function&lt;void(int)&gt; f_add_display2= std::bind( &amp;Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // store a call to a member function and object ptr
    std::function&lt;void(int)&gt; f_add_display3= std::bind( &amp;Foo::print_add, &amp;foo, _1 );
    f_add_display3(3);

    // store a call to a function object
    std::function&lt;void(int)&gt; f_display_obj = PrintNum();
    f_display_obj(18);
}
 | output=
-9
42
31337
314160
314161
314162
18
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bad_function_call}}
{{dsc inc | cpp/utility/functional/dsc mem_fn}}
{{dsc end}}

[[de:cpp/utility/functional/function]]
[[es:cpp/utility/functional/function]]
[[fr:cpp/utility/functional/function]]
[[it:cpp/utility/functional/function]]
[[ja:cpp/utility/functional/function]]
[[pt:cpp/utility/functional/function]]
[[ru:cpp/utility/functional/function]]
[[zh:cpp/utility/functional/function]]</text>
      <sha1>gdna7o1cnbbu3bghchu7b9is22shxcg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/assign</title>
    <ns>0</ns>
    <id>5069</id>
    <revision>
      <id>61958</id>
      <parentid>51637</parentid>
      <timestamp>2013-06-11T11:59:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+desc</comment>
      <text xml:space="preserve" bytes="1180">{{cpp/utility/functional/function/title | assign}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class F, class Alloc &gt;
void assign( F&amp;&amp; f, const Alloc&amp; alloc );
}}
{{dcl end}}

Initializes the ''target'' with {{tt|f}}. {{tt|alloc}} is used to allocate memory for any internal data structures that the {{tt|function}} might use.

Equivalent to {{cc|function(allocator_arg, alloc, std::forward&lt;F&gt;(f)).swap(*this)}}

===Parameters===
{{par begin}}
{{par | f | callable function to initialize the ''target'' with}}
{{par | alloc | allocator to use to allocate memory for the internal data structures}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc operator{{=}}}}
{{dsc end}}

[[de:cpp/utility/functional/function/assign]]
[[es:cpp/utility/functional/function/assign]]
[[fr:cpp/utility/functional/function/assign]]
[[it:cpp/utility/functional/function/assign]]
[[ja:cpp/utility/functional/function/assign]]
[[pt:cpp/utility/functional/function/assign]]
[[ru:cpp/utility/functional/function/assign]]
[[zh:cpp/utility/functional/function/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/function</title>
    <ns>0</ns>
    <id>5229</id>
    <revision>
      <id>72141</id>
      <parentid>72139</parentid>
      <timestamp>2014-07-18T13:13:27Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>explain small object optimization</comment>
      <text xml:space="preserve" bytes="3570">{{cpp/utility/functional/function/title | function}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
function();
}}
{{dcl | num=2 | since=c++11 |
function( std::nullptr_t );
}}
{{dcl | num=3 | since=c++11 |
function( const function&amp; other );
}}
{{dcl | num=4 | since=c++11 |
function( function&amp;&amp; other );
}}
{{dcl | num=5 | since=c++11 |
template&lt; class F &gt; 
function( F f );
}}
{{dcl | num=6 | since=c++11 |
template&lt; class Alloc &gt; 
function( std::allocator_arg_t, const Alloc&amp; alloc );
}}
{{dcl | num=7 | since=c++11 |
template&lt; class Alloc &gt; 
function( std::allocator_arg_t, const Alloc&amp; alloc, 
          std::nullptr_t );
}}
{{dcl | num=8 | since=c++11 |
template&lt; class Alloc &gt; 
function( std::allocator_arg_t, const Alloc&amp; alloc, 
          const function&amp; other );
}}
{{dcl | num=9 | since=c++11 |
template&lt; class Alloc &gt; 
function( std::allocator_arg_t, const Alloc&amp; alloc, 
          function&amp;&amp; other );
}}
{{dcl | num=10 | since=c++11 |
template&lt; class F, class Alloc &gt; 
function( std::allocator_arg_t, const Alloc&amp; alloc, F f );
}}
{{dcl end}}

Constructs a {{tt|std::function}} from a variety of sources.

@1-2@ Creates an ''empty'' function.

@3-4@ Copies {{v|3}} or moves {{v|4}} the ''target'' of {{tt|other}} to the ''target'' of {{c|*this}}. If {{tt|other}} is ''empty'', {{c|*this}} will be ''empty'' after the call too.

@5@ Initializes the ''target'' with a copy of {{tt|f}}. If {{tt|f}} is a null pointer to function or null pointer to member, {{c|*this}} will be ''empty'' after the call. {{rev inl|since=c++14|This constructor does not participate in overload resolution unless f is {{concept|Callable}} for argument types {{tt|Args...}} and return type {{tt|R}}.}}

@6-10@ Same as {{v|1-5}} just that {{tt|alloc}} is used to allocate memory for any internal data structures that the {{tt|function}} might use.

When the ''target'' is a function pointer or a {{lc|std::reference_wrapper}}, small object optimization is guaranteed, that is, these targets are always directly stored inside the {{lc|std::function}} object, no dynamic allocation takes place. Other large objects may be constructed in dynamic allocated storage and accessed by the {{lc|std::function}} object through a pointer.
===Parameters===
{{par begin}}
{{par | other | the function object used to initialize {{c|*this}} }}
{{par | f | a callable used to initialize {{c|*this}} }}
{{par | alloc | an {{concept|Allocator}} used for internal memory allocation }}
{{par hreq}}
{{par req concept | F | CopyConstructible | Callable }}
{{par req concept | Alloc | Allocator}}
{{par end}}

===Exceptions===
@1-2@ {{noexcept}}

@3,8@ does not throw if {{tt|other}}'s ''target'' is a function pointer or a {{lc|std::reference_wrapper}}, otherwise may throw {{lc|std::bad_alloc}} or any exception thrown by the copy constructor of the stored callable object.

@4@ (none)

@5,10@ does not throw if {{tt|f}} is a function pointer or a {{lc|std::reference_wrapper}}, otherwise may throw {{lc|std::bad_alloc}} or any exception thrown by the copy constructor of the stored callable object.

@6-7@ {{noexcept}}

@9@ (none)

===Example===
{{example
 | code=
 | output=
}}

[[de:cpp/utility/functional/function/function]]
[[es:cpp/utility/functional/function/function]]
[[fr:cpp/utility/functional/function/function]]
[[it:cpp/utility/functional/function/function]]
[[ja:cpp/utility/functional/function/function]]
[[pt:cpp/utility/functional/function/function]]
[[ru:cpp/utility/functional/function/function]]
[[zh:cpp/utility/functional/function/function]]</text>
      <sha1>7xkzu2ldkxdgv7fzgflizz9vfse8yxp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/operator()</title>
    <ns>0</ns>
    <id>5231</id>
    <revision>
      <id>63499</id>
      <parentid>51639</parentid>
      <timestamp>2013-07-10T01:34:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1599">{{cpp/utility/functional/function/title | operator()}}
{{cpp/utility/functional/function/navbar}}
{{ddcl | since=c++11 |
R operator()( ArgTypes... args ) const;
}}

Calls the stored callable function target with the parameters {{tt|args}}.

===Parameters===
{{par begin}}
{{par | args | parameters to pass to the stored callable function target}}
{{par end}}

===Return value===
None if {{tt|R}} is {{c|void}}. Otherwise the return value of the invocation of the stored callable object.

===Exceptions===
* {{lc|std::bad_function_call}} if {{c|*this}} does not store a callable function target,  {{c|!*this {{==}} true}}.

===Example===
{{example
 | The following example shows how {{lc|std::function}} can passed to other functions by value. Also, it shown how {{lc|std::function}} can store lambdas.
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;

void call(std::function&lt;int()&gt; f)  // can be passed by value
{ 
    std::cout &lt;&lt; f() &lt;&lt; '\n';
}

int normal_function() 
{
    return 42;
}

int main()
{
    int n = 1;
    std::function&lt;int()&gt; f = [&amp;n](){ return n; };
    call(f);

    n = 2;
    call(f); 

    f = normal_function; 
    call(f);
}
 | output=
1
2
42
}}

===See also===
{{todo}}

[[de:cpp/utility/functional/function/operator()]]
[[es:cpp/utility/functional/function/operator()]]
[[fr:cpp/utility/functional/function/operator()]]
[[it:cpp/utility/functional/function/operator()]]
[[ja:cpp/utility/functional/function/operator()]]
[[pt:cpp/utility/functional/function/operator()]]
[[ru:cpp/utility/functional/function/operator()]]
[[zh:cpp/utility/functional/function/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/operator=</title>
    <ns>0</ns>
    <id>5235</id>
    <revision>
      <id>68210</id>
      <parentid>66971</parentid>
      <timestamp>2014-03-18T04:08:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2132</comment>
      <text xml:space="preserve" bytes="2108">{{cpp/utility/functional/function/title | operator{{=}}}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
function&amp; operator=( const function&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
function&amp; operator=( function&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 | 1=
function&amp; operator=( std::nullptr_t );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class F &gt; 
function&amp; operator=( F&amp;&amp; f );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class F &gt; 
function&amp; operator=( std::reference_wrapper&lt;F&gt; f );
}}
{{dcl end}}

Assigns a new ''target'' to {{tt|std::function}}.

@1@ Assigns a copy of ''target'' of {{tt|other}}, as if by executing {{c|function(other).swap(*this);}}

@2@ Moves the ''target'' of {{tt|other}} to {{c|*this}}. {{tt|other}} is in a valid state with an unspecified value.

@3@ Drops the current ''target''. {{c|*this}} is ''empty'' after the call.

@4@ Moves the callable {{tt|f}} to the ''target'' of {{c|*this}}, as if by executing {{c|function(std::forward&lt;F&gt;(f)).swap(*this);}}. {{rev inl|since=c++14|This operator does not participate in overload resolution unless {{tt|f}} is {{concept|Callable}} for argument types {{tt|Args...}} and return type {{tt|R}}.}}

@5@ Assigns a copy of {{tt|f}}, as if by executing {{c|function(f).swap(*this);}}

===Parameters===
{{par begin}}
{{par | other | another {{tt|std::function}} object to copy the target of}}
{{par | f | a callable to initialize the ''target'' with}}
{{par hreq}}
{{par req concept | F | Callable}}
{{par end}}

===Return value===
{{c|*this}}

===Exceptions===
@1-4@ (none)

@5@ {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc assign}}
{{dsc begin}}

[[de:cpp/utility/functional/function/operator=]]
[[es:cpp/utility/functional/function/operator=]]
[[fr:cpp/utility/functional/function/operator=]]
[[it:cpp/utility/functional/function/operator=]]
[[ja:cpp/utility/functional/function/operator=]]
[[pt:cpp/utility/functional/function/operator=]]
[[ru:cpp/utility/functional/function/operator=]]
[[zh:cpp/utility/functional/function/operator=]]</text>
      <sha1>dnm0ll95gz79if5t6qnrhy9ofeuiuw5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/operator bool</title>
    <ns>0</ns>
    <id>5232</id>
    <revision>
      <id>66639</id>
      <parentid>63500</parentid>
      <timestamp>2013-12-18T14:49:18Z</timestamp>
      <contributor>
        <username>Seishun</username>
        <id>2538</id>
      </contributor>
      <comment>No need to make a copy</comment>
      <text xml:space="preserve" bytes="1437">{{cpp/utility/functional/function/title | operator bool}}
{{cpp/utility/functional/function/navbar}}
{{ddcl | since=c++11 |
explicit operator bool() const;
}}

Checks whether {{c|*this}} stores a callable function target, i.e. is not empty.

===Parameters===
(none)

===Return value===
{{c|true}} if {{c|*this}} stores a callable function target, {{c|false}} otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

typedef std::function&lt;void(int)&gt; SomeVoidFunc;

class C {
  public:
    C(SomeVoidFunc void_func = nullptr)
        : void_func_(std::move(void_func))
    {
        if (!void_func_) {
            void_func_ = std::bind(&amp;C::default_func, this, std::placeholders::_1);
        }
        void_func_(7);
    }

    void default_func(int i) { std::cout &lt;&lt; i &lt;&lt; '\n'; };

  private:
    SomeVoidFunc void_func_;
};

void user_func(int i)
{
    std::cout &lt;&lt; (i + 1) &lt;&lt; '\n';
}

int main()
{
    C c1;
    C c2(user_func);
}
 | output=
7
8
}}

[[de:cpp/utility/functional/function/operator bool]]
[[es:cpp/utility/functional/function/operator bool]]
[[fr:cpp/utility/functional/function/operator bool]]
[[it:cpp/utility/functional/function/operator bool]]
[[ja:cpp/utility/functional/function/operator bool]]
[[pt:cpp/utility/functional/function/operator bool]]
[[ru:cpp/utility/functional/function/operator bool]]
[[zh:cpp/utility/functional/function/operator bool]]</text>
      <sha1>95a0zbckjdfbv4ava2rd5wxn0adeng1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/operator cmp</title>
    <ns>0</ns>
    <id>8707</id>
    <revision>
      <id>61953</id>
      <parentid>51641</parentid>
      <timestamp>2013-06-11T11:19:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt example</comment>
      <text xml:space="preserve" bytes="2037">{{title | operator{{==}},!{{=}}&lt;small&gt;(std::function)&lt;/small&gt;}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | num=1 |
template&lt; class R, class... ArgTypes &gt;
bool operator{{==}}( const function&lt;R(ArgTypes...)&gt;&amp; f, std::nullptr_t );
}}
{{dcl | num=2 |
template&lt; class R, class... ArgTypes &gt;
bool operator{{==}}( std::nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp; f );
}}
{{dcl | num=3 |
template&lt; class R, class... ArgTypes &gt;
bool operator!{{=}}( const function&lt;R(ArgTypes...)&gt;&amp; f, std::nullptr_t );
}}
{{dcl | num=4 |
template&lt; class R, class... ArgTypes &gt;
bool operator!{{=}}( std::nullptr_t, const function&lt;R(ArgTypes...)&gt;&amp; f );
}}
{{dcl end}}

Compares a {{tt|std::function}} with a null pointer. Empty functions (that is, functions without a callable target) compare equal, non-empty functions compare non-equal.

===Parameters===
{{par begin}}
{{par | f | {{tt|std::function}} to compare}}
{{par end}}

===Return value===
1-2) {{c|!f}}

3-4) {{c|(bool) f}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

using SomeVoidFunc = std::function&lt;void(int)&gt;;

class C {
public:
    C(SomeVoidFunc void_func = nullptr) : 
        void_func_(void_func)
    {
        if (void_func_ == nullptr) { // specialized compare with nullptr
            void_func_ = std::bind(&amp;C::default_func, this, std::placeholders::_1);
        }
        void_func_(7);
    }

    void default_func(int i) { std::cout &lt;&lt; i &lt;&lt; '\n'; };

private:
    SomeVoidFunc void_func_;
};

void user_func(int i)
{
    std::cout &lt;&lt; (i + 1) &lt;&lt; '\n';
}

int main()
{
    C c1;
    C c2(user_func);
}
 | output=
7
8
}}

[[de:cpp/utility/functional/function/operator cmp]]
[[es:cpp/utility/functional/function/operator cmp]]
[[fr:cpp/utility/functional/function/operator cmp]]
[[it:cpp/utility/functional/function/operator cmp]]
[[ja:cpp/utility/functional/function/operator cmp]]
[[pt:cpp/utility/functional/function/operator cmp]]
[[ru:cpp/utility/functional/function/operator cmp]]
[[zh:cpp/utility/functional/function/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/swap</title>
    <ns>0</ns>
    <id>5234</id>
    <revision>
      <id>63501</id>
      <parentid>51642</parentid>
      <timestamp>2013-07-10T01:34:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="753">{{cpp/utility/functional/function/title | swap}}
{{cpp/utility/functional/function/navbar}}
{{ddcl | since=c++11 |
void swap( function&amp; other );
}}

Exchanges the stored callable objects of {{c|*this}} and {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | function wrapper to exchange the stored callable object with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

[[de:cpp/utility/functional/function/swap]]
[[es:cpp/utility/functional/function/swap]]
[[fr:cpp/utility/functional/function/swap]]
[[it:cpp/utility/functional/function/swap]]
[[ja:cpp/utility/functional/function/swap]]
[[pt:cpp/utility/functional/function/swap]]
[[ru:cpp/utility/functional/function/swap]]
[[zh:cpp/utility/functional/function/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/swap2</title>
    <ns>0</ns>
    <id>5500</id>
    <revision>
      <id>59557</id>
      <parentid>51643</parentid>
      <timestamp>2013-06-01T06:37:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1072">{{cpp/title | swap&lt;small&gt;(std::function)&lt;/small&gt;}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class R, class Args... &gt;
void swap( function&lt;R(Args...)&gt; &amp;lhs, function&lt;R(Args...)&gt; &amp;rhs );
}}
{{dcl end}}

Overloads the {{lc|std::swap}} algorithm for {{lc|std::function}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | polymorphic function wrappers whose states to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc swap}}
{{dsc end}}

[[de:cpp/utility/functional/function/swap2]]
[[es:cpp/utility/functional/function/swap2]]
[[fr:cpp/utility/functional/function/swap2]]
[[it:cpp/utility/functional/function/swap2]]
[[ja:cpp/utility/functional/function/swap2]]
[[pt:cpp/utility/functional/function/swap2]]
[[ru:cpp/utility/functional/function/swap2]]
[[zh:cpp/utility/functional/function/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/target</title>
    <ns>0</ns>
    <id>8705</id>
    <revision>
      <id>69228</id>
      <parentid>63083</parentid>
      <timestamp>2014-03-31T10:25:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>more realistic example from SO</comment>
      <text xml:space="preserve" bytes="1980">{{cpp/utility/functional/function/title | target}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
template&lt; class T &gt; 
T* target(); 
}}
{{dcl | num=2 | since=c++11 |
template&lt; class T &gt; 
const T* target() const;
}}
{{dcl end}}

Returns a pointer to the stored callable function target.

===Parameters===
(none)

===Return value===
A pointer to the stored function if [[cpp/utility/functional/function/target_type|{{tt|target_type}}]]{{c|() {{==}} typeid(T)}}, otherwise a null pointer.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

int f(int, int) { return 1; }
int g(int, int) { return 2; }
void test(std::function&lt;int(int, int)&gt; const&amp; arg)
{
    std::cout &lt;&lt; &quot;test function: &quot;;
    if (arg.target&lt;std::plus&lt;int&gt;&gt;())
        std::cout &lt;&lt; &quot;it is plus\n&quot;;
    if (arg.target&lt;std::minus&lt;int&gt;&gt;())
        std::cout &lt;&lt; &quot;it is minus\n&quot;;

    int (*const* ptr)(int, int) = arg.target&lt;int(*)(int, int)&gt;();
    if (ptr &amp;&amp; *ptr == f)
        std::cout &lt;&lt; &quot;it is the function f\n&quot;;
    if (ptr &amp;&amp; *ptr == g)
        std::cout &lt;&lt; &quot;it is the function g\n&quot;;
}

int main()
{
    test(std::function&lt;int(int, int)&gt;(std::plus&lt;int&gt;()));
    test(std::function&lt;int(int, int)&gt;(std::minus&lt;int&gt;()));
    test(std::function&lt;int(int, int)&gt;(f));
    test(std::function&lt;int(int, int)&gt;(g));
}
 | output=
test function: it is plus
test function: it is minus
test function: it is the function f
test function: it is the function g
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc target_type}}
{{dsc end}}

[[de:cpp/utility/functional/function/target]]
[[es:cpp/utility/functional/function/target]]
[[fr:cpp/utility/functional/function/target]]
[[it:cpp/utility/functional/function/target]]
[[ja:cpp/utility/functional/function/target]]
[[pt:cpp/utility/functional/function/target]]
[[ru:cpp/utility/functional/function/target]]
[[zh:cpp/utility/functional/function/target]]</text>
      <sha1>kwsba9lufb7rh4kxu19k77ukppbvnm4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/target type</title>
    <ns>0</ns>
    <id>8706</id>
    <revision>
      <id>69946</id>
      <parentid>63084</parentid>
      <timestamp>2014-05-02T18:48:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>mini-example</comment>
      <text xml:space="preserve" bytes="1329">{{cpp/utility/functional/function/title | target_type}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
const std::type_info&amp; target_type() const;
}}
{{dcl end}}

Returns the type of the stored function.

===Parameters===
(none)

===Return value===
{{c|typeid(T)}} if the stored function has type {{tt|T}}, otherwise {{c|typeid(void)}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

int f(int a) { return -a; }
int main()
{
    // fn1 and fn2 have the same type, but their targets do not
    std::function&lt;int(int)&gt; fn1(f),
                            fn2([](int a) {return -a;});
    std::cout &lt;&lt; fn1.target_type().name() &lt;&lt; '\n'
              &lt;&lt; fn2.target_type().name() &lt;&lt; '\n';
}
 |p=true
 | output=
int (*)(int)
main::$_0
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/function/dsc target}}
{{dsc end}}

[[de:cpp/utility/functional/function/target type]]
[[es:cpp/utility/functional/function/target type]]
[[fr:cpp/utility/functional/function/target type]]
[[it:cpp/utility/functional/function/target type]]
[[ja:cpp/utility/functional/function/target type]]
[[pt:cpp/utility/functional/function/target type]]
[[ru:cpp/utility/functional/function/target type]]
[[zh:cpp/utility/functional/function/target type]]</text>
      <sha1>ql7ttvyo6qnrsfx9t9712qau05x1pm0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/uses allocator</title>
    <ns>0</ns>
    <id>3405</id>
    <revision>
      <id>63085</id>
      <parentid>59562</parentid>
      <timestamp>2013-07-01T23:54:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1125">{{cpp/title|uses_allocator&lt;small&gt;&lt;std::function&gt;&lt;/small&gt;}}
{{cpp/utility/functional/function/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl | since=c++11 |
template&lt; class R, class... ArgTypes, class Alloc &gt;
struct uses_allocator&lt;std::function&lt;R(ArgTypes...)&gt;, Alloc&gt; : std::true_type { };
}}
{{dcl end}}

This specialization of {{lc|std::uses_allocator}} informs other library components that all objects of type {{lc|std::function}} support ''uses-allocator construction'', even though they do not have a nested {{tt|allocator_type}}. 

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/utility/functional/function/uses allocator]]
[[es:cpp/utility/functional/function/uses allocator]]
[[fr:cpp/utility/functional/function/uses allocator]]
[[it:cpp/utility/functional/function/uses allocator]]
[[ja:cpp/utility/functional/function/uses allocator]]
[[pt:cpp/utility/functional/function/uses allocator]]
[[ru:cpp/utility/functional/function/uses allocator]]
[[zh:cpp/utility/functional/function/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/function/~function</title>
    <ns>0</ns>
    <id>5233</id>
    <revision>
      <id>63502</id>
      <parentid>51647</parentid>
      <timestamp>2013-07-10T01:34:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="659">{{cpp/utility/functional/function/title | ~function}}
{{cpp/utility/functional/function/navbar}}
{{ddcl | since=c++11 |
~function();
}}

Destroys the {{lc|std::function}} instance. If the stored callable is valid, it is destroyed also.

===Exceptions===
{{noexcept}}

[[de:cpp/utility/functional/function/~function]]
[[es:cpp/utility/functional/function/~function]]
[[fr:cpp/utility/functional/function/~function]]
[[it:cpp/utility/functional/function/~function]]
[[ja:cpp/utility/functional/function/~function]]
[[pt:cpp/utility/functional/function/~function]]
[[ru:cpp/utility/functional/function/~function]]
[[zh:cpp/utility/functional/function/~function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/greater</title>
    <ns>0</ns>
    <id>4762</id>
    <revision>
      <id>66253</id>
      <parentid>66252</parentid>
      <timestamp>2013-11-10T01:00:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stray line</comment>
      <text xml:space="preserve" bytes="2108">{{cpp/title|greater}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct greater;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct greater;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialized, invokes {{c|operator&gt;}} on type {{tt|T}}.

===Specializations===
{{cpp/utility/functional/pointer_order|operator&gt;|std::greater}}

{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::greater}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc greater_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the first argument is ''greater'' than the second}}
{{dsc end}}


{{member | {{small|std::greater::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|lhs}} is ''greater'' than {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs &gt; rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &gt; rhs;
}
}}
}}

[[de:cpp/utility/functional/greater]]
[[es:cpp/utility/functional/greater]]
[[fr:cpp/utility/functional/greater]]
[[it:cpp/utility/functional/greater]]
[[ja:cpp/utility/functional/greater]]
[[pt:cpp/utility/functional/greater]]
[[ru:cpp/utility/functional/greater]]
[[zh:cpp/utility/functional/greater]]</text>
      <sha1>bkwodjfnbzep92jm8xhf81mfr81jruk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/greater equal</title>
    <ns>0</ns>
    <id>4764</id>
    <revision>
      <id>66258</id>
      <parentid>51649</parentid>
      <timestamp>2013-11-10T01:04:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2241">{{cpp/title|greater_equal}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct greater_equal;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct greater_equal;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialized, invokes {{c|operator&gt;{{=}}}} on type {{tt|T}}.

===Specializations===
{{cpp/utility/functional/pointer_order|operator&lt;{{=}}|std::greater_equal}}

{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::greater_equal}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc greater_equal_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the first argument is ''greater'' than or ''equal'' to the second}}
{{dsc end}}

{{member | {{small|std::greater_equal::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|lhs}} is ''greater'' than or ''equal'' to {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs &gt;= rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &gt;= rhs;
}
}}
}}

[[de:cpp/utility/functional/greater equal]]
[[es:cpp/utility/functional/greater equal]]
[[fr:cpp/utility/functional/greater equal]]
[[it:cpp/utility/functional/greater equal]]
[[ja:cpp/utility/functional/greater equal]]
[[pt:cpp/utility/functional/greater equal]]
[[ru:cpp/utility/functional/greater equal]]
[[zh:cpp/utility/functional/greater equal]]</text>
      <sha1>4z9st0ay9u5wsevaq3cdft3l6ma1pn4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/greater equal void</title>
    <ns>0</ns>
    <id>13066</id>
    <revision>
      <id>66470</id>
      <parentid>66280</parentid>
      <timestamp>2013-11-24T11:34:01Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1096">{{cpp/title|greater_equal&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class greater_equal&lt;void&gt;;
}}

{{c|std::greater_equal&lt;&gt;}} is a specialization of {{lc|std::greater_equal}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/greater_equal_void | title=operator() | inlinemem=true | tests if the lhs compares greater or equal than rhs}}
{{dsc end}}

{{member | {{small|std::greater_equal&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &gt;= std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|1= lhs &gt;= rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|1= lhs &gt;= rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>ol9t6r7h020pmd1jim692apwzlkkgth</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/greater void</title>
    <ns>0</ns>
    <id>13063</id>
    <revision>
      <id>66271</id>
      <parentid>66267</parentid>
      <timestamp>2013-11-10T01:33:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template for is_transparent note</comment>
      <text xml:space="preserve" bytes="1042">{{cpp/title|greater&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class greater&lt;void&gt;;
}}

{{c|std::greater&lt;&gt;}} is a specialization of {{lc|std::greater}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/greater_void | title=operator() | inlinemem=true | tests if the lhs compares greater than rhs}}
{{dsc end}}

{{member | {{small|std::greater&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &gt; std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs &gt; rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|lhs &gt; rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>s5i2wy0ew3fvq4z7n0qcfolt69fqio2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/is bind expression</title>
    <ns>0</ns>
    <id>4220</id>
    <revision>
      <id>68208</id>
      <parentid>63086</parentid>
      <timestamp>2014-03-18T04:01:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to concept, following lwg 2010</comment>
      <text xml:space="preserve" bytes="2041">{{cpp/title|is_bind_expression}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_bind_expression;
}}
{{dcl end}}

If {{tt|T}} is the type produced by a call to {{lc|std::bind}}, this template is derived from {{lc|std::true_type}}.  For any other type, this template is derived from {{lc|std::false_type}}.

{{cpp/types/integral_constant/inherit | {{tt|T}} is a function object generated by {{lc|std::bind}}}}


This template may be specialized for a user-defined type {{tt|T}} to implement {{concept|UnaryTypeTrait}} with ''BaseCharacteristic'' of {{lc|std::true_type}} to indicate that {{tt|T}} should be treated by {{lc|std::bind}} as if it were the type of a bind subexpression: when a bind-generated function object is invoked, a bound argument of this type will be invoked as a function object and will be given all the unbound arguments passed to the bind-generated object.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;functional&gt;

struct MyBind {
    typedef int result_type;
    int operator()(int a, int b) const { return a + b; }
};

namespace std {
    template&lt;&gt;
    struct is_bind_expression&lt;MyBind&gt; : public true_type {};
}

int f(int n1, int n2)
{
    return n1+n2;
}

int main()
{
    // as if bind(f, bind(MyBind::operator(), _1, _2), 2)
    auto b = std::bind(f, MyBind(), 2); 

    std::cout &lt;&lt; &quot;Adding 2 to the sum of 10 and 11 gives &quot; &lt;&lt; b(10, 11) &lt;&lt; '\n';
}
 | output=
Adding 2 to the sum of 10 and 11 gives 23
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc end}}

[[de:cpp/utility/functional/is bind expression]]
[[es:cpp/utility/functional/is bind expression]]
[[fr:cpp/utility/functional/is bind expression]]
[[it:cpp/utility/functional/is bind expression]]
[[ja:cpp/utility/functional/is bind expression]]
[[pt:cpp/utility/functional/is bind expression]]
[[ru:cpp/utility/functional/is bind expression]]
[[zh:cpp/utility/functional/is bind expression]]</text>
      <sha1>3jozbdmog13rw0vo3b3t55eyuhwei28</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/is placeholder</title>
    <ns>0</ns>
    <id>4219</id>
    <revision>
      <id>68207</id>
      <parentid>63087</parentid>
      <timestamp>2014-03-18T03:56:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to concept, slightly reword to match lwg 2010 better</comment>
      <text xml:space="preserve" bytes="2260">{{cpp/title|is_placeholder}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl | since=c++11 | 1=
template&lt; class T &gt;
struct is_placeholder;
}}
{{dcl end}}

If {{tt|T}} is the type of a standard placeholder (_1, _2, _3, ...), then this template is derived from {{c|std::integral_constant&lt;int,1&gt;}}, {{c|std::integral_constant&lt;int,2&gt;}}, {{c|std::integral_constant&lt;int,3&gt;}}, respectively.

If {{tt|T}} is not a standard placeholder type, this template is derived from {{c|std::integral_constant&lt;int,0&gt;}}

{{cpp/types/integral_constant/inherit2|placeholder value or 0 for non-placeholder types|int}}

The template may be specialized for any user-defined {{tt|T}} type: the specialization must satisfy {{concept|UnaryTypeTrait}} with ''BaseCharacteristic'' of {{c|std::integral_constant&lt;int, N&gt;}} with {{c|N &gt; 0}} to indicate that {{tt|T}} should be treated as N'th placeholder type.

{{lc|std::bind}} uses {{tt|std::is_placeholder}} to detect placeholders for unbound arguments. 

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;type_traits&gt;
#include &lt;functional&gt;

struct My_2 {
} my_2;

namespace std {
    template&lt;&gt;
    struct is_placeholder&lt;My_2&gt; : public integral_constant&lt;int, 2&gt; {};
}

int f(int n1, int n2)
{
    return n1+n2;
}

int main()
{
    std::cout &lt;&lt; &quot;Standard placeholder _5 is for the argument number &quot;
              &lt;&lt; std::is_placeholder&lt;decltype(std::placeholders::_5)&gt;::value
              &lt;&lt; '\n';

    auto b = std::bind(f, my_2, 2);
    std::cout &lt;&lt; &quot;Adding 2 to 11 selected with a custom placeholder gives &quot; 
              &lt;&lt; b(10, 11) 
              &lt;&lt; '\n';
}
 | output=
Standard placeholder _5 is for the argument number 5
Adding 2 to 11 selected with a custom placeholder gives 13
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc inc | cpp/utility/functional/dsc placeholders}}
{{dsc end}}

[[de:cpp/utility/functional/is placeholder]]
[[es:cpp/utility/functional/is placeholder]]
[[fr:cpp/utility/functional/is placeholder]]
[[it:cpp/utility/functional/is placeholder]]
[[ja:cpp/utility/functional/is placeholder]]
[[pt:cpp/utility/functional/is placeholder]]
[[ru:cpp/utility/functional/is placeholder]]
[[zh:cpp/utility/functional/is placeholder]]</text>
      <sha1>9kf2s5u2iai0b5tn0iwbdavgbw21t55</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/less</title>
    <ns>0</ns>
    <id>4763</id>
    <revision>
      <id>66255</id>
      <parentid>59569</parentid>
      <timestamp>2013-11-10T01:02:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2480">{{cpp/title|less}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct less;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct less;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialized, invokes {{c|operator&lt;}} on type {{tt|T}}.

===Specializations===
{{cpp/utility/functional/pointer_order|operator&lt;|std::less}}

{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::less}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc less_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the first argument is ''less'' than the second}}
{{dsc end}}

{{member | {{small|std::less::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|lhs}} is ''less'' than {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs &lt; rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &lt; rhs;
}
}}
}}

===Example===
{{example
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

template &lt;typename A, typename B, typename U = std::less&lt;int&gt;&gt;
bool f(A a, B b, U u = U())
{
    return u(a, b);
}

int main() 
{
    std::cout &lt;&lt; std::boolalpha;   
    std::cout &lt;&lt; f(5, 20) &lt;&lt; '\n';
    std::cout &lt;&lt; f(100, 10) &lt;&lt; '\n';
}
 | output=
true
false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc owner_less}}
{{dsc end}}

[[de:cpp/utility/functional/less]]
[[es:cpp/utility/functional/less]]
[[fr:cpp/utility/functional/less]]
[[it:cpp/utility/functional/less]]
[[ja:cpp/utility/functional/less]]
[[pt:cpp/utility/functional/less]]
[[ru:cpp/utility/functional/less]]
[[zh:cpp/utility/functional/less]]</text>
      <sha1>h2sm6vhymb9v8vx5leuxsksd7akxwgy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/less equal</title>
    <ns>0</ns>
    <id>4765</id>
    <revision>
      <id>66261</id>
      <parentid>51653</parentid>
      <timestamp>2013-11-10T01:09:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2185">{{cpp/title|less_equal}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct less_equal;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct less_equal;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialized, invokes {{c|operator&lt;{{=}}}} on type {{tt|T}}.

===Specializations===
{{cpp/utility/functional/pointer_order|operator&lt;{{=}}|std::less_equal}}

{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::less_equal}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc less_equal_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the first argument is ''less'' than or ''equal'' to the second}}
{{dsc end}}

{{member | {{small|std::less_equal::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks if {{tt|lhs}} is ''less'' than or ''equal'' to {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs &lt;= rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &lt;= rhs;
}
}}
}}

[[de:cpp/utility/functional/less equal]]
[[es:cpp/utility/functional/less equal]]
[[fr:cpp/utility/functional/less equal]]
[[it:cpp/utility/functional/less equal]]
[[ja:cpp/utility/functional/less equal]]
[[pt:cpp/utility/functional/less equal]]
[[ru:cpp/utility/functional/less equal]]
[[zh:cpp/utility/functional/less equal]]</text>
      <sha1>hh4uavzc86c0c0vwcbu3wkjbfwdd9g4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/less equal void</title>
    <ns>0</ns>
    <id>13067</id>
    <revision>
      <id>66471</id>
      <parentid>66281</parentid>
      <timestamp>2013-11-24T11:36:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="1075">{{cpp/title|less_equal&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class less_equal&lt;void&gt;;
}}

{{c|std::less_equal&lt;&gt;}} is a specialization of {{lc|std::less_equal}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/less_equal_void | title=operator() | inlinemem=true | tests if the lhs compares less or equal than rhs}}
{{dsc end}}

{{member | {{small|std::less_equal&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &lt;= std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|1= lhs &lt;= rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|1= lhs &lt;= rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>6ou7tg9g756ezp1oc33lb785to0ipac</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/less void</title>
    <ns>0</ns>
    <id>13064</id>
    <revision>
      <id>66270</id>
      <parentid>66268</parentid>
      <timestamp>2013-11-10T01:33:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1021">{{cpp/title|less&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class less&lt;void&gt;;
}}

{{c|std::less&lt;&gt;}} is a specialization of {{lc|std::less}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/less_void | title=operator() | inlinemem=true | tests if the lhs compares less than rhs}}
{{dsc end}}

{{member | {{small|std::less&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &lt; std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs &lt; rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|lhs &lt; rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>rxbk5m8kcl13xre5wnl80yn0yxyw395</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical and</title>
    <ns>0</ns>
    <id>4055</id>
    <revision>
      <id>66284</id>
      <parentid>51654</parentid>
      <timestamp>2013-11-10T01:50:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2084">{{cpp/title|logical_and}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct logical_and;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct logical_and;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing logical AND (logical conjunction). Effectively calls {{c|operator&amp;&amp;}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::logical_and}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc logical_and_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the logical AND of the two arguments}}
{{dsc end}}

{{member | {{small|std::logical_and::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the logical AND of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute logical AND of}}
{{par end}}

===Return value===
The result of {{c|lhs &amp;&amp; rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs &amp;&amp; rhs;
}
}}
}}

[[de:cpp/utility/functional/logical and]]
[[es:cpp/utility/functional/logical and]]
[[fr:cpp/utility/functional/logical and]]
[[it:cpp/utility/functional/logical and]]
[[ja:cpp/utility/functional/logical and]]
[[pt:cpp/utility/functional/logical and]]
[[ru:cpp/utility/functional/logical and]]
[[zh:cpp/utility/functional/logical and]]</text>
      <sha1>d8867mgf71a28645zazi3g0rg0g0ez2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical and void</title>
    <ns>0</ns>
    <id>13071</id>
    <revision>
      <id>66289</id>
      <timestamp>2013-11-10T01:58:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1063">{{cpp/title|logical_and&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class logical_and&lt;void&gt;;
}}

{{c|std::logical_and&lt;&gt;}} is a specialization of {{lc|std::logical_and}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/logical_and_void | title=operator() | inlinemem=true | applies {{tt|operator&amp;&amp;}} to lhs and rhs}}
{{dsc end}}

{{member | {{small|std::logical_and&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) &amp;&amp; std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs &amp;&amp; rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to AND}}
{{par end}}

===Return value===
The result of {{c|lhs &amp;&amp; rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>9ce43mtcxkak54m9f51dwpqdg1veonq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical not</title>
    <ns>0</ns>
    <id>4057</id>
    <revision>
      <id>66288</id>
      <parentid>51655</parentid>
      <timestamp>2013-11-10T01:55:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="1941">{{cpp/title|logical_not}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct logical_not;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct logical_not;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing logical NOT (logical negation). Effectively calls {{c|operator!}} for type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::logical_not}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc logical_not_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the logical NOT of the argument}}
{{dsc end}}

{{member | {{small|std::logical_not::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; arg ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; arg ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the logical NOT of {{tt|arg}}.

===Parameters===
{{par begin}}
{{par | arg | value to compute logical NOT of}}
{{par end}}

===Return value===
The result of {{c|!arg}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
const bool operator()(const T &amp;arg) const 
{
    return !arg;
}
}}
}}

[[de:cpp/utility/functional/logical not]]
[[es:cpp/utility/functional/logical not]]
[[fr:cpp/utility/functional/logical not]]
[[it:cpp/utility/functional/logical not]]
[[ja:cpp/utility/functional/logical not]]
[[pt:cpp/utility/functional/logical not]]
[[ru:cpp/utility/functional/logical not]]
[[zh:cpp/utility/functional/logical not]]</text>
      <sha1>7wc8je7w7iquq74jeyakdkashzn8op6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical not void</title>
    <ns>0</ns>
    <id>13073</id>
    <revision>
      <id>66291</id>
      <timestamp>2013-11-10T02:01:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1026">{{cpp/title|logical_not&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class logical_not&lt;void&gt;;
}}

{{c|std::logical_not&lt;&gt;}} is a specialization of {{lc|std::logical_not}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/logical_not_void | title=operator() | inlinemem=true | applies {{tt|operator{{!}}}} to its argument}}
{{dsc end}}

{{member | {{small|std::logical_not&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T &gt;
constexpr auto operator()( T&amp;&amp; arg ) const
  -&gt; decltype(!std::forward&lt;T&gt;(lhs));
}}

Returns the result of {{tt|!arg}}.

===Parameters===
{{par begin}}
{{par | arg | value to apply logical NOT to}}
{{par end}}

===Return value===
The result of {{c|!arg}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>lkfh5x5wgzjl6wi0o8xzk0mjk2buz9z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical or</title>
    <ns>0</ns>
    <id>4056</id>
    <revision>
      <id>66286</id>
      <parentid>51656</parentid>
      <timestamp>2013-11-10T01:52:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2078">{{cpp/title|logical_or}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct logical_or;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct logical_or;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing logical OR (logical disjunction). Effectively calls {{c|operator{{!!}}}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::logical_or}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc logical_or_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the logical OR of the two arguments}}
{{dsc end}}

{{member | {{small|std::logical_or::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the logical OR of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compute logical OR of}}
{{par end}}

===Return value===
The result of {{c|lhs {{!!}} rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs {{!!}} rhs;
}
}}
}}

[[de:cpp/utility/functional/logical or]]
[[es:cpp/utility/functional/logical or]]
[[fr:cpp/utility/functional/logical or]]
[[it:cpp/utility/functional/logical or]]
[[ja:cpp/utility/functional/logical or]]
[[pt:cpp/utility/functional/logical or]]
[[ru:cpp/utility/functional/logical or]]
[[zh:cpp/utility/functional/logical or]]</text>
      <sha1>071jlv3z4wer3yvsmlyiucq1cmz4uax</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/logical or void</title>
    <ns>0</ns>
    <id>13072</id>
    <revision>
      <id>66290</id>
      <timestamp>2013-11-10T01:59:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1072">{{cpp/title|logical_or&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class logical_or&lt;void&gt;;
}}

{{c|std::logical_or&lt;&gt;}} is a specialization of {{lc|std::logical_or}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/logical_or_void | title=operator() | inlinemem=true | applies {{tt|operator{{!!}}}} to lhs and rhs}}
{{dsc end}}

{{member | {{small|std::logical_or&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) {{!!}} std::forward&lt;U&gt;(rhs));
}}

Returns the result of {{tt|lhs {{!!}} rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to OR}}
{{par end}}

===Return value===
The result of {{c|lhs {{!!}} rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>ff0zl47t570nb4zq0ut8wyocgy22x7g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/mem fn</title>
    <ns>0</ns>
    <id>3486</id>
    <revision>
      <id>71937</id>
      <parentid>64052</parentid>
      <timestamp>2014-07-02T13:25:10Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>use since= and until=</comment>
      <text xml:space="preserve" bytes="5989">{{cpp/title|mem_fn}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 | num=1 |
template&lt; class R, class T &gt;
/*unspecified*/ mem_fn(R T::* pm);
}}
{{dcl | since=c++11 | until=c++14 | num=2 |
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...));
template&lt; class R, class T, class... Args &gt;
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) &amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const &amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) &amp;&amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const &amp;&amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) volatile &amp;&amp;);
template&lt; class R, class T, class... Args &gt; 
/*unspecified*/ mem_fn(R (T::* pm)(Args...) const volatile &amp;&amp;);
}}
{{dcl end}}

Function template {{tt|std::mem_fn}} generates wrapper objects for pointers to members, which can store, copy, and invoke a pointer to member. Both references and pointers (including smart pointers) to an object can be used when invoking a {{tt|std::mem_fn}}.

The overloads (2) were introduced in C++11 but removed in C++14 as [http://cplusplus.github.io/LWG/lwg-defects.html#2048 defect #2048]

===Parameters===
{{par begin}}
{{par | pm | pointer to member that will be wrapped}}
{{par end}}

===Return value===
{{tt|std::mem_fn}} returns a call wrapper of unspecified type that has the following members:

{{member | {{small|std::mem_fn}} Return type | 2=

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | the return type of {{c|pm}} if {{c|pm}} is a pointer to member function, not defined for pointer to member object }}
{{dsc | {{tt|argument_type}} | {{tt|T*}}, possibly cv-qualified, if {{c|pm}} is a pointer to member function taking no arguments}}
{{dsc | {{tt|first_argument_type}} | {{tt|T*}} if {{c|pm}} is a pointer to member function taking one argument}}
{{dsc | {{tt|second_argument_type}} | {{tt|T1}} if {{c|pm}} is a pointer to member function taking one argument of type {{tt|T1}} }}
{{dsc end}}

===Member function===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | invokes the target on a specified object, with optional parameters }} &lt;!-- todo: use the INVOKE template? --&gt;
{{dsc end}}

}}

===Exceptions===
None.

===Example 1===
{{example
 | Use {{tt|mem_fn}} to store and execute a member function and a member object:
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

struct Foo {
    void display_greeting() {
        std::cout &lt;&lt; &quot;Hello, world.\n&quot;;
    }
    void display_number(int i) {
        std::cout &lt;&lt; &quot;number: &quot; &lt;&lt; i &lt;&lt; '\n';
    }
    int data = 7;
};

int main() {
    Foo f;

    auto greet = std::mem_fn(&amp;Foo::display_greeting);
    greet(f);

    auto print_num = std::mem_fn(&amp;Foo::display_number);
    print_num(f, 42);

    auto access_data = std::mem_fn(&amp;Foo::data);
    std::cout &lt;&lt; &quot;data: &quot; &lt;&lt; access_data(f) &lt;&lt; '\n';
}
 | output=
Hello, world.
number: 42
data: 7
}}

===Example 2===
{{example
 | Pass a member function to {{lc|std::transform}} to create a sequence of numbers: 
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;iterator&gt;
#include &lt;memory&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;

int main()
{
    std::vector&lt;std::string&gt; words = {&quot;This&quot;, &quot;is&quot;, &quot;a&quot;, &quot;test&quot;};
    std::vector&lt;std::unique_ptr&lt;std::string&gt;&gt; words2;
    words2.emplace_back(new std::string(&quot;another&quot;));
    words2.emplace_back(new std::string(&quot;test&quot;));

    std::vector&lt;std::size_t&gt; lengths;
    std::transform(words.begin(),
                   words.end(),
                   std::back_inserter(lengths),
                   std::mem_fn(&amp;std::string::size)); // uses references to strings
    std::transform(words2.begin(),
                   words2.end(),
                   std::back_inserter(lengths),
                   std::mem_fn(&amp;std::string::size)); // uses unique_ptr to strings

    std::cout &lt;&lt; &quot;The string lengths are &quot;;
    for(auto n : lengths) std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
The string lengths are 4 2 1 4 7 4
}}

===Example 3===
{{example
 | Demonstrates the effect of the C++14 changes to the specification of std::mem_fn
 | code=

#include &lt;iostream&gt;
#include &lt;functional&gt;
 
struct X {
    int x;
    
    int&amp;       easy()      {return x;}
    int&amp;       get()       {return x;}
    const int&amp; get() const {return x;}
};
 
 
int main(void)
{
    auto a = std::mem_fn        (&amp;X::easy); // no problem at all
//  auto b = std::mem_fn&lt;int&amp;  &gt;(&amp;X::get ); // no longer works in C++14
    auto c = std::mem_fn&lt;int&amp;()&gt;(&amp;X::get ); // works with both C++11 and C++14
    auto d = [] (X&amp; x) {return x.get();};   // another approach to overload resolution
    
    X x = {33};
    std::cout &lt;&lt; &quot;a() = &quot; &lt;&lt; a(x) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;c() = &quot; &lt;&lt; c(x) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;d() = &quot; &lt;&lt; d(x) &lt;&lt; '\n';
}
 | output=
a() = 33
c() = 33
d() = 33
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc end}}

[[de:cpp/utility/functional/mem fn]]
[[es:cpp/utility/functional/mem fn]]
[[fr:cpp/utility/functional/mem fn]]
[[it:cpp/utility/functional/mem fn]]
[[ja:cpp/utility/functional/mem fn]]
[[pt:cpp/utility/functional/mem fn]]
[[ru:cpp/utility/functional/mem fn]]
[[zh:cpp/utility/functional/mem fn]]</text>
      <sha1>93zymaw4j91jquh6zqg4hdmxrobtzxq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/mem fun</title>
    <ns>0</ns>
    <id>10172</id>
    <revision>
      <id>63952</id>
      <parentid>59573</parentid>
      <timestamp>2013-08-01T15:47:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>r2.7.4) (Robot: Adding [[es:cpp/utility/functional/mem fun]]</comment>
      <text xml:space="preserve" bytes="1866">{{cpp/title|mem_fun}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Res, class T &gt; 
std::mem_fun_t&lt;Res,T&gt; mem_fun( Res (T::*f)() );
}}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Res, class T &gt; 
std::const_mem_fun_t&lt;Res,T&gt; mem_fun( Res (T::*f)() );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Res, class T, class Arg &gt; 
std::mem_fun1_t&lt;Res,T,Arg&gt; mem_fun( Res (T::*f)(Arg) );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Res, class T, class Arg &gt; 
std::const_mem_fun1_t&lt;Res,T,Arg&gt; mem_fun( S (T::*f)(Arg) );
}}
{{dcl end}}

Creates a member function wrapper object, deducing the target type from the template arguments. The wrapper object expects a pointer to an object of type {{tt|T}} as the first parameter to its {{c|operator()}}.

@1@ Effectively calls {{c|std::mem_fun_t&lt;S,T&gt;(f)}} or {{c|std::const_mem_fun_t&lt;S,T&gt;(f)}}.

@2@ Effectively calls {{c|std::mem_fun1_t&lt;S,T&gt;(f)}} or {{c|std::const_mem_fun1_t&lt;S,T&gt;(f)}}.

This function and the related types are deprecated as of C++11 in favor of the more general {{lc|std::function}} and {{lc|std::bind}}, both of which create callable adapter-compatible function objects from plain functions.

===Parameters===
{{par begin}}
{{par | f | pointer to a member function to create a wrapper for}}
{{par end}}

===Return value===
A function object wrapping {{tt|f}}.

===Exceptions===
(none)

===Notes===
The difference between {{c|std::mem_fun}} and {{c|std::mem_fun_ref}} is that the former produces an function wrapper that expects a pointer to an object, whereas the latter -- a reference.

===Example===
{{example
 | 
 | code=
 | output=
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref}}
{{dsc end}}

[[es:cpp/utility/functional/mem fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/mem fun ref</title>
    <ns>0</ns>
    <id>10173</id>
    <revision>
      <id>68696</id>
      <parentid>63951</parentid>
      <timestamp>2014-03-19T10:34:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+example</comment>
      <text xml:space="preserve" bytes="2361">{{cpp/title|mem_fun_ref}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Res, class T &gt; 
std::mem_fun_ref_t&lt;Res,T&gt; mem_fun_ref( Res (T::*f)() );
}}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Res, class T &gt; 
std::const_mem_fun_ref_t&lt;Res,T&gt; mem_fun_ref( Res (T::*f)() );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Res, class T, class Arg &gt; 
std::mem_fun1_ref_t&lt;Res,T,Arg&gt; mem_fun_ref( Res (T::*f)(Arg) );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Res, class T, class Arg &gt; 
std::const_mem_fun1_ref_t&lt;Res,T,Arg&gt; mem_fun_ref( S (T::*f)(Arg) );
}}
{{dcl end}}

Creates a member function wrapper object, deducing the target type from the template arguments. The wrapper object expects a reference to an object of type {{tt|T}} as the first parameter to its {{c|operator()}}.

1) Effectively calls {{c|std::mem_fun_ref_t&lt;S,T&gt;(f)}} or {{c|std::const_mem_fun_ref_t&lt;S,T&gt;(f)}}.

2) Effectively calls {{c|std::mem_fun1_ref_t&lt;S,T&gt;(f)}} or {{c|std::const_mem_fun1_ref_t&lt;S,T&gt;(f)}}.

This function and the related types are deprecated as of C++11 in favor of the more general {{lc|std::function}} and {{lc|std::bind}}, both of which create callable adapter-compatible function objects from plain functions.

===Parameters===
{{par begin}}
{{par | f | pointer to a member function to create a wrapper for}}
{{par end}}

===Return value===
A function object wrapping {{tt|f}}.

===Exceptions===
(none)

===Notes===
The difference between {{c|std::mem_fun}} and {{c|std::mem_fun_ref}} is that the former produces an function wrapper that expects a pointer to an object, whereas the latter -- a reference.

===Example===
{{example
 | uses std::mem_fun_ref to bind std::string's member function .size()
 | code=
#include &lt;functional&gt;
#include &lt;vector&gt;
#include &lt;string&gt;
#include &lt;iterator&gt;
#include &lt;algorithm&gt;
#include &lt;iostream&gt;

int main()
{
    std::vector&lt;std::string&gt; v = {&quot;once&quot;, &quot;upon&quot;, &quot;a&quot;, &quot;time&quot;};
    std::transform(v.begin(), v.end(),
                   std::ostream_iterator&lt;std::size_t&gt;(std::cout, &quot; &quot;),
                   std::mem_fun_ref(&amp;std::string::size));
}
 | output=
4 4 1 4
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc mem_fun}}
{{dsc end}}

[[es:cpp/utility/functional/mem fun ref]]</text>
      <sha1>pa8ynaskfki6zroeshe2f33hde13qbl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/mem fun ref t</title>
    <ns>0</ns>
    <id>5482</id>
    <revision>
      <id>59575</id>
      <parentid>51660</parentid>
      <timestamp>2013-06-01T06:38:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1961">{{cpp/title | mem_fun_ref_t | mem_fun1_ref_t | const_mem_fun_ref_t | const_mem_fun1_ref_t}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 | 
template&lt; class S, class T &gt; 
class mem_fun_ref_t : public unary_function&lt;T,S&gt; {
public:
    explicit mem_fun_ref_t(S (T::*p)());
    S operator()(T&amp; p) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class S, class T &gt; 
class const_mem_fun_ref_t : public unary_function&lt;T,S&gt; {
public:
    explicit const_mem_fun_ref_t(S (T::*p)() const);
    S operator()(const T&amp; p) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=3 | 
template&lt; class S, class T, class A &gt; 
class mem_fun1_ref_t : public binary_function&lt;T,A,S&gt; {
public:
    explicit mem_fun1_ref_t(S (T::*p)(A));
    S operator()(T&amp; p, A x) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=4 |
template&lt; class S, class T, class A &gt; 
class const_mem_fun1_ref_t : public binary_function&lt;T,A,S&gt; {
public:
    explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
    S operator()(const T&amp; p, A x) const;
};
}}
{{dcl end}}

Wrapper around a member function pointer. The class instance whose member function to call is passed as a reference to the {{tt|operator()}}.

@1@ Wraps a non-const member function with no parameters.

@2@ Wraps a const member function with no parameters.

@3@ Wraps a non-const member function with a single parameter.

@4@ Wraps a const member function with a single parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_t}}
{{dsc end}}

[[de:cpp/utility/functional/mem fun ref t]]
[[es:cpp/utility/functional/mem fun ref t]]
[[fr:cpp/utility/functional/mem fun ref t]]
[[it:cpp/utility/functional/mem fun ref t]]
[[ja:cpp/utility/functional/mem fun ref t]]
[[pt:cpp/utility/functional/mem fun ref t]]
[[ru:cpp/utility/functional/mem fun ref t]]
[[zh:cpp/utility/functional/mem fun ref t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/mem fun t</title>
    <ns>0</ns>
    <id>5481</id>
    <revision>
      <id>59578</id>
      <parentid>51661</parentid>
      <timestamp>2013-06-01T06:38:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1896">{{cpp/title | mem_fun_t | mem_fun1_t | const_mem_fun_t | const_mem_fun1_t}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl | notes={{mark deprecated}} | num=1 | 
template&lt; class S, class T &gt; 
class mem_fun_t : public unary_function&lt;T*,S&gt; {
public:
    explicit mem_fun_t(S (T::*p)());
    S operator()(T* p) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class S, class T &gt; 
class const_mem_fun_t : public unary_function&lt;const T*,S&gt; {
public:
    explicit const_mem_fun_t(S (T::*p)() const);
    S operator()(const T* p) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class S, class T, class Arg &gt; 
class mem_fun1_t : public binary_function&lt;T*,A,S&gt; {
public:
    explicit mem_fun1_t(S (T::*p)(A));
    S operator()(T* p, A x) const;
};
}}
{{dcl | notes={{mark deprecated}} | num=4 |
template&lt; class S, class T, class A &gt; 
class const_mem_fun1_t : public binary_function&lt;const T*,A,S&gt; {
public:
    explicit const_mem_fun1_t(S (T::*p)(A) const);
    S operator()(const T* p, A x) const;
};
}}
{{dcl end}}

Wrapper around a member function pointer. The class instance whose member function to call is passed as a pointer to the {{tt|operator()}}.

@1@ Wraps a non-const member function with no parameters.

@2@ Wraps a const member function with no parameters.

@3@ Wraps a non-const member function with a single parameter.

@4@ Wraps a const member function with a single parameter.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc mem_fun}}
{{dsc inc | cpp/utility/functional/dsc mem_fun_ref_t}}
{{dsc end}}

[[de:cpp/utility/functional/mem fun t]]
[[es:cpp/utility/functional/mem fun t]]
[[fr:cpp/utility/functional/mem fun t]]
[[it:cpp/utility/functional/mem fun t]]
[[ja:cpp/utility/functional/mem fun t]]
[[pt:cpp/utility/functional/mem fun t]]
[[ru:cpp/utility/functional/mem fun t]]
[[zh:cpp/utility/functional/mem fun t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/minus</title>
    <ns>0</ns>
    <id>4050</id>
    <revision>
      <id>66242</id>
      <parentid>66241</parentid>
      <timestamp>2013-11-10T00:48:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>lost header</comment>
      <text xml:space="preserve" bytes="1987">{{cpp/title|minus}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct minus;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct minus;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing subtraction. Effectively calls {{c|operator-}} on two instances of type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::minus}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc minus_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the difference between two arguments}}
{{dsc end}}

{{member | {{small|std::minus::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the difference between {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to subtract from one another}}
{{par end}}

===Return value===
The result of {{c|lhs - rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs - rhs;
}
}}
}}

[[de:cpp/utility/functional/minus]]
[[es:cpp/utility/functional/minus]]
[[fr:cpp/utility/functional/minus]]
[[it:cpp/utility/functional/minus]]
[[ja:cpp/utility/functional/minus]]
[[pt:cpp/utility/functional/minus]]
[[ru:cpp/utility/functional/minus]]
[[zh:cpp/utility/functional/minus]]</text>
      <sha1>bo6arb0dymtwft0a70ig199dqah7ib7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/minus void</title>
    <ns>0</ns>
    <id>13050</id>
    <revision>
      <id>66278</id>
      <parentid>66234</parentid>
      <timestamp>2013-11-10T01:35:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1100">{{cpp/title|minus&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class minus&lt;void&gt;;
}}

{{c|std::minus&lt;&gt;}} is a specialization of {{lc|std::minus}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/minus_void | title=operator() | inlinemem=true | returns the difference of two arguments}}
{{dsc end}}

{{member | {{small|std::minus&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) - std::forward&lt;U&gt;(rhs));
}}

Returns the result of subtracting {{tt|rhs}} from {{tt|lhs}} (or whatever {{tt|operator-}} if overloaded to do)

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to subtract}}
{{par end}}

===Return value===
The result of {{c|lhs - rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>5jm9qyc5qjpzlsk0umgju4hp73gvfkb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/modulus</title>
    <ns>0</ns>
    <id>4054</id>
    <revision>
      <id>66246</id>
      <parentid>66229</parentid>
      <timestamp>2013-11-10T00:51:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>forgot c++14 in the declaration</comment>
      <text xml:space="preserve" bytes="2049">{{cpp/title|modulus}}
{{cpp/utility/functional/navbar}}

{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct modulus;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct modulus;
}}
{{dcl rev end}}
{{dcl end}}

Function object for computing remainders of divisions. Implements {{c|operator%}} for type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::modulus}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc modulus_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the remainder from the division of the first argument by the second argument}}
{{dsc end}}

{{member | {{small|std::modulus::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the remainder of the division of {{tt|lhs}} by {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to divide one by another}}
{{par end}}

===Return value===
The result of {{c|lhs % rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs % rhs;
}
}}
}}

[[de:cpp/utility/functional/modulus]]
[[es:cpp/utility/functional/modulus]]
[[fr:cpp/utility/functional/modulus]]
[[it:cpp/utility/functional/modulus]]
[[ja:cpp/utility/functional/modulus]]
[[pt:cpp/utility/functional/modulus]]
[[ru:cpp/utility/functional/modulus]]
[[zh:cpp/utility/functional/modulus]]</text>
      <sha1>9op4o0gii7grswnopjc5qnx4b9h4tby</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/modulus void</title>
    <ns>0</ns>
    <id>13053</id>
    <revision>
      <id>66274</id>
      <parentid>66237</parentid>
      <timestamp>2013-11-10T01:34:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1112">{{cpp/title|modulus&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class modulus&lt;void&gt;;
}}

{{c|std::modulus&lt;&gt;}} is a specialization of {{lc|std::modulus}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/modulus_void | title=operator() | inlinemem=true | returns the modulus of two arguments}}
{{dsc end}}

{{member | {{small|std::modulus&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) % std::forward&lt;U&gt;(rhs));
}}

Returns the remainder of the division of {{tt|lhs}} by {{tt|rhs}} (or whatever {{tt|operator%}} is overloaded to do)

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to divide}}
{{par end}}

===Return value===
The result of {{c|lhs % rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>6zaqmsrdf6roxbm2eas75pi4ck7lv8y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/multiplies</title>
    <ns>0</ns>
    <id>4052</id>
    <revision>
      <id>66244</id>
      <parentid>66225</parentid>
      <timestamp>2013-11-10T00:49:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>forgot c++14 in the declaration</comment>
      <text xml:space="preserve" bytes="2027">{{cpp/title|multiplies}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct multiplies;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct multiplies;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing multiplication. Effectively calls {{c|operator*}} on two instances of type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::multiplies}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc multiplies_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the product of two arguments}}
{{dsc end}}

{{member | {{small|std::multiplies::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the product of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to multiply}}
{{par end}}

===Return value===
The result of {{c|lhs * rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs * rhs;
}
}}
}}

[[de:cpp/utility/functional/multiplies]]
[[es:cpp/utility/functional/multiplies]]
[[fr:cpp/utility/functional/multiplies]]
[[it:cpp/utility/functional/multiplies]]
[[ja:cpp/utility/functional/multiplies]]
[[pt:cpp/utility/functional/multiplies]]
[[ru:cpp/utility/functional/multiplies]]
[[zh:cpp/utility/functional/multiplies]]</text>
      <sha1>7g0mfg66eq2mmyxbw1i8go9st8eyisp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/multiplies void</title>
    <ns>0</ns>
    <id>13051</id>
    <revision>
      <id>66276</id>
      <parentid>66235</parentid>
      <timestamp>2013-11-10T01:35:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1125">{{cpp/title|multiplies&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class multiplies&lt;void&gt;;
}}

{{c|std::multiplies&lt;&gt;}} is a specialization of {{lc|std::multiplies}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/multiplies_void | title=operator() | inlinemem=true | returns the product of two arguments}}
{{dsc end}}

{{member | {{small|std::multiplies&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) * std::forward&lt;U&gt;(rhs));
}}

Returns the result of multiplying {{tt|lhs}} by {{tt|rhs}} (or whatever {{tt|operator*}} is overloaded to do)

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to multiply}}
{{par end}}

===Return value===
The result of {{c|lhs * rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>2hsl1mpakpawngqyxgvk0tjrzqpar7c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/negate</title>
    <ns>0</ns>
    <id>4051</id>
    <revision>
      <id>66243</id>
      <parentid>66230</parentid>
      <timestamp>2013-11-10T00:48:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>forgot c++14 in the declaration</comment>
      <text xml:space="preserve" bytes="1846">{{cpp/title|negate}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct negate;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct negate;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing negation. Effectively calls {{c|operator-}} on an instance of type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::negate}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc negate_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | returns the negation of the argument}}
{{dsc end}}

{{member | {{small|std::negate::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; arg ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; arg ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the negation of {{tt|arg}}.

===Parameters===
{{par begin}}
{{par | arg | value to compute negation of}}
{{par end}}

===Return value===
The result of {{c|-arg}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;arg) const 
{
    return -arg;
}
}}
}}

[[de:cpp/utility/functional/negate]]
[[es:cpp/utility/functional/negate]]
[[fr:cpp/utility/functional/negate]]
[[it:cpp/utility/functional/negate]]
[[ja:cpp/utility/functional/negate]]
[[pt:cpp/utility/functional/negate]]
[[ru:cpp/utility/functional/negate]]
[[zh:cpp/utility/functional/negate]]</text>
      <sha1>r5milusynwhzd2i6bhpv953jfh2yd1r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/negate void</title>
    <ns>0</ns>
    <id>13054</id>
    <revision>
      <id>66277</id>
      <parentid>66238</parentid>
      <timestamp>2013-11-10T01:35:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note</comment>
      <text xml:space="preserve" bytes="1034">{{cpp/title|negate&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class negate&lt;void&gt;;
}}

{{c|std::negate&lt;&gt;}} is a specialization of {{lc|std::negate}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/negate_void | title=operator() | inlinemem=true | returns its negated argument}}
{{dsc end}}

{{member | {{small|std::negate&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T &gt;
constexpr auto operator()( T&amp;&amp; arg ) const
  -&gt; decltype(-std::forward&lt;T&gt;(arg));
}}

Returns the result of negating {{tt|arg}} (or whatever the unary {{tt|operator-}} is overloaded to do)

===Parameters===
{{par begin}}
{{par | arg | value to negate}}
{{par end}}

===Return value===
The result of {{c|-arg}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>riclxiba0mbhmol9bxv1hvizwqy0dki</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/not1</title>
    <ns>0</ns>
    <id>5254</id>
    <revision>
      <id>70299</id>
      <parentid>66218</parentid>
      <timestamp>2014-05-18T12:25:12Z</timestamp>
      <contributor>
        <ip>81.166.238.144</ip>
      </contributor>
      <comment>Example program output was incorrect.</comment>
      <text xml:space="preserve" bytes="2487">{{cpp/title|not1}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14| 
template&lt; class Predicate &gt;
std::unary_negate&lt;Predicate&gt; not1(const Predicate&amp; pred);
}}
{{dcl | since=c++14| 
template&lt; class Predicate &gt;
constexpr std::unary_negate&lt;Predicate&gt; not1(const Predicate&amp; pred);
}}
{{dcl rev end}}
{{dcl end}}

{{tt|not1}} is a helper function to create a function object that returns the complement of the unary predicate function passed. The function object created is of type {{c|std::unary_negate&lt;Predicate&gt;}}.

The unary predicate type must define a member type, {{tt|argument_type}}, that is convertible to the predicate's parameter type. The unary function objects obtained from {{lc|std::ref}}, {{lc|std::cref}}, {{lc|std::negate}}, {{lc|std::logical_not}}, {{lc|std::mem_fn}}, {{lc|std::function}}, {{lc|std::hash}}, or from another call to {{lc|std::not1}} have this type defined, as are function objects derived from the deprecated {{lc|std::unary_function}}. 

===Parameters===
{{par begin}}
{{par | pred | unary predicate}}
{{par end}}

===Return value===
{{tt|std::not1}} returns an object of type {{c|std::unary_negate&lt;Predicate&gt;}}, constructed with {{tt|pred}}.

===Exceptions===
None.

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

struct LessThan7 : std::unary_function&lt;int, bool&gt;
{
    bool operator()(int i) const { return i &lt; 7; }
};

int main()
{
    std::vector&lt;int&gt; v;
    for (int i = 0; i &lt; 10; ++i) {
        v.push_back(i);
    }
    
    std::cout &lt;&lt; std::count_if(v.begin(), v.end(), std::not1(LessThan7())) &lt;&lt; &quot;\n&quot;;
    
    //same as above, but use a lambda function
    std::function&lt;int(int)&gt; less_than_9 = [](int x){ return x &lt; 9; };
    std::cout &lt;&lt; std::count_if(v.begin(), v.end(), std::not1(less_than_9)) &lt;&lt; &quot;\n&quot;;
}

 | output=
3
1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc unary_negate}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc not2}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc unary_function}}
{{dsc end}}

[[de:cpp/utility/functional/not1]]
[[es:cpp/utility/functional/not1]]
[[fr:cpp/utility/functional/not1]]
[[it:cpp/utility/functional/not1]]
[[ja:cpp/utility/functional/not1]]
[[pt:cpp/utility/functional/not1]]
[[ru:cpp/utility/functional/not1]]
[[zh:cpp/utility/functional/not1]]</text>
      <sha1>m31j70l1vc9lbhiujp9eefatwzaoy97</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/not2</title>
    <ns>0</ns>
    <id>5255</id>
    <revision>
      <id>66219</id>
      <parentid>59582</parentid>
      <timestamp>2013-11-10T00:01:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="4201">{{cpp/title|not2}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl |until=c++14| 
template&lt; class Predicate &gt;
std::binary_negate&lt;Predicate&gt; not2(const Predicate&amp; pred);
}}
{{dcl |since=c++14| 
template&lt; class Predicate &gt;
constexpr std::binary_negate&lt;Predicate&gt; not2(const Predicate&amp; pred);
}}
{{dcl rev end}}
{{dcl end}}

{{tt|not2}} is a helper function to create a function object that returns the complement of the binary predicate function passed. The function object created is of type {{c|std::binary_negate&lt;Predicate&gt;}}.

The binary predicate type must define  two member types, {{tt|first_argument_type}} and {{tt|second_argument_type}}, that are convertible to the predicate's parameter types. The function objects obtained from {{lc|std::owner_less}}, {{lc|std::ref}}, {{lc|std::cref}}, {{lc|std::plus}}, {{lc|std::minus}}, {{lc|std::multiplies}}, {{lc|std::divides}}, {{lc|std::modulus}}, {{lc|std::equal_to}}, {{lc|std::not_equal_to}}, {{lc|std::greater}}, {{lc|std::less}}, {{lc|std::greater_equal}}, {{lc|std::less_equal}}, {{lc|std::logical_not}}, {{lc|std::logical_or}}, {{lc|std::bit_and}}, {{lc|std::bit_or}}, {{c|std::bit_xor}}, {{lc|std::mem_fn}}, {{c|std::map::value_comp}}, {{c|std::multimap::value_comp}}, {{lc|std::function}}, or from another call to {{lc|std::not2}} have these types defined, as are function objects derived from the deprecated {{lc|std::binary_function}}. 

===Parameters===
{{par begin}}
{{par | pred | binary predicate}}
{{par end}}

===Return value===
{{tt|std::not2}} returns an object of type {{c|std::binary_negate&lt;Predicate&gt;}}, constructed with {{tt|pred}}.

===Exceptions===
None.

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
 
struct old_same : std::binary_function&lt;int, int, bool&gt;
{
    bool operator()(int a, int b) const { return a == b; }
};
 
struct new_same
{
    bool operator()(int a, int b) const { return a == b; }
};

bool same_fn(int a, int b)
{
    return a == b;
}

 
int main()
{
    std::vector&lt;int&gt; v1{0, 1, 2};
    std::vector&lt;int&gt; v2{2, 1, 0};
    std::vector&lt;bool&gt; v3(v1.size());
 
    std::cout &lt;&lt; &quot;negating a binary_function:\n&quot;;
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
                   std::not2(old_same()));
 
    std::cout &lt;&lt; std::boolalpha;
    for (std::size_t i = 0; i &lt; v1.size(); ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';
 
    std::cout &lt;&lt; &quot;negating a standard functor:\n&quot;;
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
                   std::not2(std::equal_to&lt;int&gt;()));
 
    for (std::size_t i = 0; i &lt; v1.size(); ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';
 
    std::cout &lt;&lt; &quot;negating a std::function:\n&quot;;
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
                   std::not2(std::function&lt;bool(int,int)&gt;(new_same())));
 
    for (std::size_t i = 0; i &lt; v1.size(); ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;negating a std::reference_wrapper:\n&quot;;
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(),
                   std::not2(std::ref(same_fn)));
 
    for (std::size_t i = 0; i &lt; v1.size(); ++i)
        std::cout &lt;&lt; v1[i] &lt;&lt; ' ' &lt;&lt; v2[i] &lt;&lt; ' ' &lt;&lt; v3[i] &lt;&lt; '\n';

}
 | output=
negating a binary_function:
0 2 true
1 1 false
2 0 true
negating a standard functor:
0 2 true
1 1 false
2 0 true
negating a std::function:
0 2 true
1 1 false
2 0 true
negating a std::reference_wrapper:
0 2 true
1 1 false
2 0 true
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc binary_negate}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc not1}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc binary_function}}
{{dsc end}}

[[de:cpp/utility/functional/not2]]
[[es:cpp/utility/functional/not2]]
[[fr:cpp/utility/functional/not2]]
[[it:cpp/utility/functional/not2]]
[[ja:cpp/utility/functional/not2]]
[[pt:cpp/utility/functional/not2]]
[[ru:cpp/utility/functional/not2]]
[[zh:cpp/utility/functional/not2]]</text>
      <sha1>1tpxherobp5hmuy8dc7ks3gu7px23a2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/not equal to</title>
    <ns>0</ns>
    <id>4059</id>
    <revision>
      <id>66250</id>
      <parentid>51668</parentid>
      <timestamp>2013-11-10T00:56:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14</comment>
      <text xml:space="preserve" bytes="2101">{{cpp/title|not_equal_to}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct not_equal_to;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct not_equal_to;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing comparisons. Unless specialised, invokes {{c|operator!{{=}}}} on type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::not_equal_to}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc not_equal_to_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|result_type}} | {{tt|bool}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator() | nolink=true | checks if the arguments are ''not equal''}}
{{dsc end}}

{{member | {{small|std::not_equal_to::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Checks whether {{tt|lhs}} is ''not equal'' to {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|true}} if {{c|1=lhs != rhs}}, {{c|false}} otherwise.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr bool operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs != rhs;
}
}}
}}

[[de:cpp/utility/functional/not equal to]]
[[es:cpp/utility/functional/not equal to]]
[[fr:cpp/utility/functional/not equal to]]
[[it:cpp/utility/functional/not equal to]]
[[ja:cpp/utility/functional/not equal to]]
[[pt:cpp/utility/functional/not equal to]]
[[ru:cpp/utility/functional/not equal to]]
[[zh:cpp/utility/functional/not equal to]]</text>
      <sha1>7rsaw11ylyhkw4euvu7ip524bnlcyd2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/not equal to void</title>
    <ns>0</ns>
    <id>13062</id>
    <revision>
      <id>66272</id>
      <parentid>66263</parentid>
      <timestamp>2013-11-10T01:33:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template for is_transparent note</comment>
      <text xml:space="preserve" bytes="1124">{{cpp/title|not_equal_to&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class not_equal_to&lt;void&gt;;
}}

{{c|std::not_equal_to&lt;&gt;}} is a specialization of {{lc|std::not_equal_to}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | cpp/utility/functional/not_equal_to_void | title=operator() | inlinemem=true | tests if the two arguments do not compare equal}}
{{dsc end}}

{{member | {{small|std::not_equal_to&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) != std::forward&lt;U&gt;(rhs));
}}

Returns the result of non-equality comparison between {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
The result of {{c|lhs !{{=}} rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example}}</text>
      <sha1>0bov50oflzm4k7p54tebkssgdb6ifxw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/placeholders</title>
    <ns>0</ns>
    <id>2474</id>
    <revision>
      <id>59583</id>
      <parentid>51669</parentid>
      <timestamp>2013-06-01T06:38:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2354">{{cpp/title|n=placeholders::|_1|_2, ...|_N}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl |
extern /*unspecified*/ _1;
extern /*unspecified*/ _2;
.
.
extern /*unspecified*/ _N;
}}
{{dcl end}}

The {{lc|std::placeholders}} namespace contains the placeholder objects {{tt|[_1, . . . _N]}} where {{tt|N}} is an implementation defined maximum number.

When used as an argument in a {{lc|std::bind}} expression, the placeholder objects are stored in the generated function object, and when that function object is invoked with unbound arguments, each placeholder {{tt|_N}} is replaced by the corresponding Nth unbound argument.

The types of the placeholder objects are {{concept|DefaultConstructible}} and {{concept|CopyConstructible}}, their default copy/move constructors do not throw exceptions, and for any placeholder {{tt|_N}}, the type {{c|std::is_placeholder&lt;decltype(_N)&gt;}} is defined and is derived from {{c|std::integral_constant&lt;int, N&gt;}}.

===Example===
{{example
 | The following code shows the creation of function objects with a placeholder argument.
 | code=
#include &lt;functional&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

void goodbye(const std::string&amp; s)
{
    std::cout &lt;&lt; &quot;Goodbye &quot; &lt;&lt; s &lt;&lt; '\n';
}

class Object {
public:
    void hello(const std::string&amp; s)
    {
        std::cout &lt;&lt; &quot;Hello &quot; &lt;&lt; s &lt;&lt; '\n';
    }
};

int main(int argc, char* argv[])
{
    typedef std::function&lt;void(const std::string&amp;)&gt; ExampleFunction;
    Object instance;
    std::string str(&quot;World&quot;);
    ExampleFunction f = std::bind(&amp;Object::hello, &amp;instance, 
                                  std::placeholders::_1);
    
    // equivalent to instance.hello(str)
    f(str);
    f = std::bind(&amp;goodbye, std::placeholders::_1);
   
    // equivalent to goodbye(str)
    f(str);    
    return 0;
}
| output=
Hello World
Goodbye World
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc inc | cpp/utility/functional/dsc is_placeholder}}
{{dsc end}}

[[de:cpp/utility/functional/placeholders]]
[[es:cpp/utility/functional/placeholders]]
[[fr:cpp/utility/functional/placeholders]]
[[it:cpp/utility/functional/placeholders]]
[[ja:cpp/utility/functional/placeholders]]
[[pt:cpp/utility/functional/placeholders]]
[[ru:cpp/utility/functional/placeholders]]
[[zh:cpp/utility/functional/placeholders]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/plus</title>
    <ns>0</ns>
    <id>4049</id>
    <revision>
      <id>66221</id>
      <parentid>66220</parentid>
      <timestamp>2013-11-10T00:06:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>constexpr the possible implementation too</comment>
      <text xml:space="preserve" bytes="1903">{{cpp/title|plus}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++14 |
template&lt; class T &gt;
struct plus;
}}
{{dcl | since=c++14 |
template&lt; class T {{=}} void &gt;
struct plus;
}}
{{dcl rev end}}
{{dcl end}}

Function object for performing addition. Effectively calls {{c|operator+}} on two instances of type {{tt|T}}.

===Specializations===
{{rev begin}}
{{rev | since=c++14 |
The standard library provides a specialization of {{tt|std::plus}} when {{tt|T}} is not specified, which leaves the parameter types and return type to be deduced.
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc plus_void}}
{{dsc end}}
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|result_type}} | {{tt|T}}}}
{{dsc | {{tt|first_argument_type}} | {{tt|T}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/plus/dsc operator()}}
{{dsc end}}

{{member | {{small|std::plus::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl |since=c++14|
constexpr T operator()( const T&amp; lhs, const T&amp; rhs ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the sum of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to sum}}
{{par end}}

===Return value===
The result of {{c|lhs + rhs}}.

===Exceptions===
(none)

===Possible implementation===
{{eq fun | 1=
constexpr T operator()(const T &amp;lhs, const T &amp;rhs) const 
{
    return lhs + rhs;
}
}}
}}

[[de:cpp/utility/functional/plus]]
[[es:cpp/utility/functional/plus]]
[[fr:cpp/utility/functional/plus]]
[[it:cpp/utility/functional/plus]]
[[ja:cpp/utility/functional/plus]]
[[pt:cpp/utility/functional/plus]]
[[ru:cpp/utility/functional/plus]]
[[zh:cpp/utility/functional/plus]]</text>
      <sha1>nq4aezeup8pm29ka2vkxuwv9caq1y1p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/plus void</title>
    <ns>0</ns>
    <id>12865</id>
    <revision>
      <id>66279</id>
      <parentid>66232</parentid>
      <timestamp>2013-11-10T01:36:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>template is_transparent note, show heterogeneity in the example</comment>
      <text xml:space="preserve" bytes="1148">{{cpp/title|plus&lt;void&gt;}}
{{cpp/utility/functional/navbar}}
{{ddcl | header=functional | since=c++14 |
template&lt;&gt;
class plus&lt;void&gt;;
}}

{{c|std::plus&lt;&gt;}} is a specialization of {{lc|std::plus}} with parameter and return type deduced.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|is_transparent}} | /* unspecified */}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/plus_void/dsc operator()}}
{{dsc end}}

{{member | {{small|std::plus&lt;&gt;::}}operator() | 2=
{{ddcl | 1=
template&lt; class T, class U&gt;
constexpr auto operator()( T&amp;&amp; lhs, U&amp;&amp; rhs ) const
  -&gt; decltype(std::forward&lt;T&gt;(lhs) + std::forward&lt;U&gt;(rhs));
}}

Returns the sum of {{tt|lhs}} and {{tt|rhs}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to sum}}
{{par end}}

===Return value===
The result of {{c|lhs + rhs}}.
}}

===Notes===
{{cpp/utility/functional/is_transparent_note}}

===Example===
{{example
|code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

int main()
{
    std::string a = &quot;Hello &quot;;
    const char* b = &quot;world&quot;;
    std::cout &lt;&lt; std::plus&lt;&gt;{}(a, b) &lt;&lt; '\n';
}
|output=
Hello world
}}</text>
      <sha1>etfbfpzdxa22iuwmcopkcni7c2xf5u5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/pointer to binary function</title>
    <ns>0</ns>
    <id>5476</id>
    <revision>
      <id>59587</id>
      <parentid>51671</parentid>
      <timestamp>2013-06-01T06:38:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1906">{{cpp/title|pointer_to_binary_function}}
{{cpp/utility/functional/navbar}}
{{ddcl | notes={{mark deprecated}} |
template&lt; 
    class Arg1, 
    class Arg2,
    class Result 
&gt; class pointer_to_binary_function : public std::binary_function&lt;Arg1, Arg2, Result&gt;;
}}

{{tt|std::pointer_to_binary_function}} is a function object that acts as a wrapper around a binary function.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | constructs a new {{tt|pointer_to_binary_function}} object with the supplied function}}
{{dsc mem fun | operator() | nolink=true | calls the stored function}}
{{dsc end}}

{{member | {{small|std::pointer_to_binary_function::}}pointer_to_binary_function | 2=
{{ddcl | 1=
explicit pointer_to_binary_function( Result (*f)(Arg1,Arg2) );
}}

Constructs a {{tt|pointer_to_binary_function}} function object with the stored function {{tt|f}}.

===Parameters===
{{par begin}}
{{par | f | pointer to a function to store}}
{{par end}}

}}

{{member | {{small|std::pointer_to_binary_function::}}operator() | 2=
{{ddcl | 1=
Result operator()( Arg1 x1, Arg2 x2 ) const;
}}

Calls the stored function.

===Parameters===
{{par begin}}
{{par | x1, x2 | arguments to pass to the function}}
{{par end}}

===Return value===
The value returned by the called function.

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_unary_function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc end}}

[[de:cpp/utility/functional/pointer to binary function]]
[[es:cpp/utility/functional/pointer to binary function]]
[[fr:cpp/utility/functional/pointer to binary function]]
[[it:cpp/utility/functional/pointer to binary function]]
[[ja:cpp/utility/functional/pointer to binary function]]
[[pt:cpp/utility/functional/pointer to binary function]]
[[ru:cpp/utility/functional/pointer to binary function]]
[[zh:cpp/utility/functional/pointer to binary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/pointer to unary function</title>
    <ns>0</ns>
    <id>5475</id>
    <revision>
      <id>59590</id>
      <parentid>51672</parentid>
      <timestamp>2013-06-01T06:38:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1841">{{cpp/title|pointer_to_unary_function}}
{{cpp/utility/functional/navbar}}
{{ddcl | notes={{mark deprecated}} |
template&lt; 
    class Arg, 
    class Result 
&gt; class pointer_to_unary_function : public std::unary_function&lt;Arg, Result&gt;;
}}

{{tt|std::pointer_to_unary_function}} is a function object that acts as a wrapper around a unary function.

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | constructs a new {{tt|pointer_to_unary_function}} object with the supplied function}}
{{dsc mem fun | operator() | nolink=true | calls the stored function}}
{{dsc end}}

{{member | {{small|std::pointer_to_unary_function::}}pointer_to_unary_function | 2=
{{ddcl | 1=
explicit pointer_to_unary_function( Result (*f)(Arg) );
}}

Constructs a {{tt|pointer_to_unary_function}} function object with the stored function {{tt|f}}.

===Parameters===
{{par begin}}
{{par | f | pointer to a function to store}}
{{par end}}

}}

{{member | {{small|std::pointer_to_unary_function::}}operator() | 2=
{{ddcl | 1=
Result operator()( Arg x ) const;
}}

Calls the stored function.

===Parameters===
{{par begin}}
{{par | x | argument to pass to the function}}
{{par end}}

===Return value===
The value returned by the called function.

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_binary_function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc end}}

[[de:cpp/utility/functional/pointer to unary function]]
[[es:cpp/utility/functional/pointer to unary function]]
[[fr:cpp/utility/functional/pointer to unary function]]
[[it:cpp/utility/functional/pointer to unary function]]
[[ja:cpp/utility/functional/pointer to unary function]]
[[pt:cpp/utility/functional/pointer to unary function]]
[[ru:cpp/utility/functional/pointer to unary function]]
[[zh:cpp/utility/functional/pointer to unary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/ptr fun</title>
    <ns>0</ns>
    <id>5477</id>
    <revision>
      <id>51673</id>
      <parentid>46433</parentid>
      <timestamp>2013-06-01T04:15:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2063">{{cpp/title|ptr_fun}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | notes={{mark deprecated}} | num=1 |
template&lt; class Arg, class Result &gt;
std::pointer_to_unary_function&lt;Arg,Result&gt;
    ptr_fun( Result (*f)(Arg) );
}}
{{dcl | notes={{mark deprecated}} | num=2 |
template&lt; class Arg1, class Arg2, class Result &gt;
std::pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;
    ptr_fun( Result (*f)(Arg1, Arg2) );
}}
{{dcl end}}

Creates a function wrapper object (either {{c|std::pointer_to_unary_function}} or {{c|std::pointer_to_binary_function}}), deducing the target type from the template arguments.

1) Effectively calls {{c|std::pointer_to_unary_function&lt;Arg,Result&gt;(f)}}.

2) Effectively calls {{c|std::pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;(f)}}.

This function and the related types are deprecated as of C++11 in favor of the more general {{lc|std::function}} and {{lc|std::ref}}, both of which create callable adapter-compatible function objects from plain functions.

===Parameters===
{{par begin}}
{{par | f | pointer to a function to create a wrapper for}}
{{par end}}

===Return value===
A function object wrapping {{tt|f}}.

===Exceptions===
(none)

===Example===
{{example
 | 
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;algorithm&gt;
#include &lt;functional&gt;

bool isvowel(char c)
{
    return std::string(&quot;aeoiuAEIOU&quot;).find(c) != std::string::npos;
}

int main()
{
    std::string s = &quot;Hello, world!&quot;;
    std::copy_if(s.begin(), s.end(), std::ostreambuf_iterator&lt;char&gt;(std::cout),
                 std::not1(std::ptr_fun(isvowel)));
// C++11 alternatives: 
//               std::not1(std::ref(isvowel)));
//               std::not1(std::function&lt;bool(char)&gt;(isvowel)));

}
 | output=
Hll, wrld!
}}

[[de:cpp/utility/functional/ptr fun]]
[[es:cpp/utility/functional/ptr fun]]
[[fr:cpp/utility/functional/ptr fun]]
[[it:cpp/utility/functional/ptr fun]]
[[ja:cpp/utility/functional/ptr fun]]
[[pt:cpp/utility/functional/ptr fun]]
[[ru:cpp/utility/functional/ptr fun]]
[[zh:cpp/utility/functional/ptr fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/ref</title>
    <ns>0</ns>
    <id>5225</id>
    <revision>
      <id>69961</id>
      <parentid>63089</parentid>
      <timestamp>2014-05-03T21:00:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link</comment>
      <text xml:space="preserve" bytes="2445">{{cpp/title|ref|cref}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 | num=1|
template&lt; class T &gt;
std::reference_wrapper&lt;T&gt; ref(T&amp; t);
}}
{{dcl | since=c++11 | num=2|
template&lt; class T &gt;
std::reference_wrapper&lt;T&gt; ref( std::reference_wrapper&lt;T&gt; t );
}}
{{dcl | since=c++11 | num=3|
template &lt;class T&gt;
void ref(const T&amp;&amp;) {{=}} delete;
}}
{{dcl | since=c++11 | num=4|
template&lt; class T &gt;
std::reference_wrapper&lt;const T&gt; cref( const T&amp; t );
}}
{{dcl | since=c++11 | num=5|
template&lt; class T &gt;
std::reference_wrapper&lt;const T&gt; cref( std::reference_wrapper&lt;T&gt; t )
}}
{{dcl | since=c++11 | num=6|
template &lt;class T&gt;
void cref(const T&amp;&amp;) {{=}} delete;
}}
{{dcl end}}

Function templates {{tt|ref}} and {{tt|cref}} are helper functions that generate an object of type {{lc|std::reference_wrapper}}, using [[cpp/language/template_argument_deduction|template argument deduction]] to determine the template argument of the result.

===Parameters===
{{par begin}}
{{par | t | lvalue reference to object that needs to be wrapped or an instance of {{lc|std::reference_wrapper}}}}
{{par end}}

===Return value===
@1@ {{c|std::reference_wrapper&lt;T&gt;(t)}}
@2@ {{c|ref(t.get())}}
@4@ {{c|std::reference_wrapper&lt;const T&gt;(t)}}
@5@ {{c|cref(t.get())}}

===Exeptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
#include &lt;functional&gt;
#include &lt;iostream&gt;

void f(int&amp; n1, int&amp; n2, const int&amp; n3)
{
    std::cout &lt;&lt; &quot;In function: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';
    ++n1; // increments the copy of n1 stored in the function object
    ++n2; // increments the main()'s n2
    // ++n3; // compile error
}

int main()
{
    int n1 = 1, n2 = 2, n3 = 3;
    std::function&lt;void()&gt; bound_f = std::bind(f, n1, std::ref(n2), std::cref(n3));
    n1 = 10;
    n2 = 11;
    n3 = 12;
    std::cout &lt;&lt; &quot;Before function: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';
    bound_f();
    std::cout &lt;&lt; &quot;After function: &quot; &lt;&lt; n1 &lt;&lt; ' ' &lt;&lt; n2 &lt;&lt; ' ' &lt;&lt; n3 &lt;&lt; '\n';
}
 | output=
Before function: 10 11 12
In function: 1 11 12
After function: 10 12 12
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc reference_wrapper}}
{{dsc end}}

[[de:cpp/utility/functional/ref]]
[[es:cpp/utility/functional/ref]]
[[fr:cpp/utility/functional/ref]]
[[it:cpp/utility/functional/ref]]
[[ja:cpp/utility/functional/ref]]
[[pt:cpp/utility/functional/ref]]
[[ru:cpp/utility/functional/ref]]
[[zh:cpp/utility/functional/ref]]</text>
      <sha1>10knoeqwqk6qk97g5ffdxpklfv35jbh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/reference wrapper</title>
    <ns>0</ns>
    <id>5219</id>
    <revision>
      <id>70230</id>
      <parentid>70217</parentid>
      <timestamp>2014-05-12T15:12:39Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>minor format spacing</comment>
      <text xml:space="preserve" bytes="4938">{{cpp/title|reference_wrapper}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | since=c++11 |
template&lt; class T &gt;
class reference_wrapper;
}}
{{dcl end}}

{{tt|std::reference_wrapper}} is a class template that wraps a reference in a copyable, assignable object.  It is frequently used as a mechanism to store references inside standard containers (like {{lc|std::vector}} or {{lc|std::pair}}) which can not normally hold references.

Specifically, {{tt|std::reference_wrapper}} is a {{concept|CopyConstructible}} and {{concept|CopyAssignable}} wrapper around a reference to object or reference to function of type {{tt|T}}. Instances of {{tt|std::reference_wrapper}} are objects (they can be copied or stored in containers) but they are implicitly convertible to {{c|T&amp;}}, so that they can be used as arguments with the functions that take the underlying type by reference.

Helper functions {{lc|std::ref}} and {{lc|std::cref}} are often used to generate {{tt|std::reference_wrapper}} objects. 

{{tt|std::reference_wrapper}} is also used to pass objects to {{lc|std::bind}} or to the constructor of {{lc|std::thread}} by reference.

===Member types===
{{dsc begin}}
{{dsc hitem | type | definition }}
{{dsc | {{tt|type}} | {{tt|T}}}}
{{dsc | {{tt|result_type}} | The return type of {{tt|T}} if {{tt|T}} is a function. Otherwise, not defined }}
{{dsc | {{tt|argument_type}} | 1) if {{tt|T}} is a function or pointer to function that takes one argument of type {{tt|A1}},  then {{tt|argument_type}} is {{tt|A1}}.&lt;br&gt;
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes no arguments, then {{tt|argument_type}} is {{tt|T0*}}, possibly cv-qualified&lt;br&gt;
3) if {{tt|T}} is a class type with a member type {{tt|T::argument_type}}, then {{tt|argument_type}} is an alias of that}}
{{dsc | {{tt|first_argument_type}} | 1) if {{tt|T}} is a function or pointer to function that takes two arguments of type s {{tt|A1}} and {{tt|A2}}, then {{tt|first_argument_type}} is {{tt|A1}}.&lt;br&gt;
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes one argument, then {{tt|first_argument_type}} is {{tt|T0*}}, possibly cv-qualified&lt;br&gt;
3) if {{tt|T}} is a class type with a member type {{tt|T::first_argument_type}}, then {{tt|first_argument_type}} is an alias of that
}}
{{dsc | {{tt|second_argument_type}} |1) if {{tt|T}} is a function or pointer to function that takes two arguments of type s {{tt|A1}} and {{tt|A2}}, then {{tt|second_argument_type}} is {{tt|A2}}.&lt;br&gt;
2) if {{tt|T}} is a pointer to member function of class {{tt|T0}} that takes one argument {{tt|A1}}, then {{tt|second_argument_type}} is {{tt|A1}}, possibly cv-qualified&lt;br&gt;
3) if {{tt|T}} is a class type with a member type {{tt|T::second_argument_type}}, then {{tt|second_argument_type}} is an alias of that}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc constructor}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator{{=}} }}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc get}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator()}}
{{dsc end}}

===Example===
{{example
 | Demonstrates the use of reference_wrapper as a container of references, which makes it possible to access the same container using multiple indexes
 | code=
#include &lt;algorithm&gt;
#include &lt;list&gt;
#include &lt;vector&gt;
#include &lt;iostream&gt;
#include &lt;functional&gt;

int main()
{
    std::list&lt;int&gt; l = {-4, -3, -2, -1, 0, 1, 2, 3, 4};
 
    std::vector&lt;std::reference_wrapper&lt;int&gt;&gt; v(l.begin(), l.end());
    std::random_shuffle(v.begin(), v.end());

    std::cout &lt;&lt; &quot;Contents of the list: &quot;;
    for (int n : l) {
        std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;Contents of the list, shuffled: &quot;;
    for (int i : v) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;Doubling the values in the initial list...\n&quot;;
    for (int &amp;i : l) {
        i *= 2;
    }

    std::cout &lt;&lt; &quot;Shuffled vector actually contains references: &quot;;
    for (int i : v) {
        std::cout &lt;&lt; i &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';
}
 | output=
Contents of the list: -4 -3 -2 -1 0 1 2 3 4 
Contents of the list, shuffled: 0 -1 3 4 -4 1 -2 -3 2 
Doubling the values in the initial list...
Shuffled vector actually contains references: 0 -2 6 8 -8 2 -4 -6 4 
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc ref}}
{{dsc inc | cpp/utility/functional/dsc bind}}
{{dsc end}}

[[de:cpp/utility/functional/reference wrapper]]
[[es:cpp/utility/functional/reference wrapper]]
[[fr:cpp/utility/functional/reference wrapper]]
[[it:cpp/utility/functional/reference wrapper]]
[[ja:cpp/utility/functional/reference wrapper]]
[[pt:cpp/utility/functional/reference wrapper]]
[[ru:cpp/utility/functional/reference wrapper]]
[[zh:cpp/utility/functional/reference wrapper]]</text>
      <sha1>egr9nch1sqn7ty2h3rsk0ud9wlvuy5p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/reference wrapper/get</title>
    <ns>0</ns>
    <id>5460</id>
    <revision>
      <id>63091</id>
      <parentid>59597</parentid>
      <timestamp>2013-07-01T23:54:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="896">{{cpp/utility/functional/reference_wrapper/title|get|operator T&amp;}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 
operator T&amp; () const;
}}
{{dcl | since=c++11 |
T&amp; get() const;
}}
{{dcl end}}

Returns the stored reference.

===Parameters===
(none)

===Return value===
The stored reference.

===Exceptions===
1-2) {{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator()}}
{{dsc end}}

[[de:cpp/utility/functional/reference wrapper/get]]
[[es:cpp/utility/functional/reference wrapper/get]]
[[fr:cpp/utility/functional/reference wrapper/get]]
[[it:cpp/utility/functional/reference wrapper/get]]
[[ja:cpp/utility/functional/reference wrapper/get]]
[[pt:cpp/utility/functional/reference wrapper/get]]
[[ru:cpp/utility/functional/reference wrapper/get]]
[[zh:cpp/utility/functional/reference wrapper/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/reference wrapper/operator()</title>
    <ns>0</ns>
    <id>5461</id>
    <revision>
      <id>67884</id>
      <parentid>63503</parentid>
      <timestamp>2014-03-04T04:45:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link callable</comment>
      <text xml:space="preserve" bytes="1826">{{cpp/utility/functional/reference_wrapper/title|operator()}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{ddcl | since=c++11 | 
template&lt; class... ArgTypes &gt;
typename std::result_of&lt;T&amp;(ArgTypes&amp;&amp;...)&gt;::type
    operator() ( ArgTypes&amp;&amp;... args ) const;
}}

Calls the {{concept|Callable}} object, reference to which is stored. This function is available only if the stored reference points to a {{concept|Callable}} object.

===Parameters===
{{par begin}}
{{par | args | arguments to pass to the called function}}
{{par end}}

===Return value===
The return value of the called function.

===Exceptions===
(none)

===Example===
{{example |
|code=
#include &lt;iostream&gt;
#include &lt;functional&gt;

void f1()
{
    std::cout &lt;&lt; &quot;reference to function called\n&quot;;
}
void f2(int n)
{
    std::cout &lt;&lt; &quot;bind expression called with &quot; &lt;&lt; n &lt;&lt; &quot; as the argument\n&quot;;
}

int main()
{
    std::reference_wrapper&lt;void()&gt; ref1 = std::ref(f1);
    ref1();

    auto b = std::bind(f2, std::placeholders::_1);
    auto ref2 = std::ref(b);
    ref2(7);

    auto c = []{std::cout &lt;&lt; &quot;lambda function called\n&quot;; };
    auto ref3 = std::ref(c);
    ref3();
}
|output=
reference to function called
bind expression called with 7 as the argument
lambda function called
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/reference_wrapper/dsc get}}
{{dsc end}}

[[de:cpp/utility/functional/reference wrapper/operator()]]
[[es:cpp/utility/functional/reference wrapper/operator()]]
[[fr:cpp/utility/functional/reference wrapper/operator()]]
[[it:cpp/utility/functional/reference wrapper/operator()]]
[[ja:cpp/utility/functional/reference wrapper/operator()]]
[[pt:cpp/utility/functional/reference wrapper/operator()]]
[[ru:cpp/utility/functional/reference wrapper/operator()]]
[[zh:cpp/utility/functional/reference wrapper/operator()]]</text>
      <sha1>lkuf7tig2kf85fd94ilnoih4uxdda2x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/reference wrapper/operator=</title>
    <ns>0</ns>
    <id>5459</id>
    <revision>
      <id>63504</id>
      <parentid>51678</parentid>
      <timestamp>2013-07-10T01:34:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="930">{{cpp/utility/functional/reference_wrapper/title|operator{{=}}}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{ddcl | since=c++11 | 1=
reference_wrapper&amp; operator=( const reference_wrapper&lt;T&gt;&amp; other );
}}

Copy assignment operator. Drops the current reference and stores a reference to {{c|other.get()}}.

===Parameters===
{{par begin}}
{{par | other | reference wrapper to copy}}
{{par end}}

===Return values===
{{c|*this}}

===Exceptions=== 
{{noexcept}}

[[de:cpp/utility/functional/reference wrapper/operator=]]
[[es:cpp/utility/functional/reference wrapper/operator=]]
[[fr:cpp/utility/functional/reference wrapper/operator=]]
[[it:cpp/utility/functional/reference wrapper/operator=]]
[[ja:cpp/utility/functional/reference wrapper/operator=]]
[[pt:cpp/utility/functional/reference wrapper/operator=]]
[[ru:cpp/utility/functional/reference wrapper/operator=]]
[[zh:cpp/utility/functional/reference wrapper/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/reference wrapper/reference wrapper</title>
    <ns>0</ns>
    <id>5458</id>
    <revision>
      <id>63967</id>
      <parentid>63092</parentid>
      <timestamp>2013-08-02T21:13:25Z</timestamp>
      <contributor>
        <ip>216.16.254.41</ip>
      </contributor>
      <text xml:space="preserve" bytes="1224">{{cpp/utility/functional/reference_wrapper/title|reference_wrapper}}
{{cpp/utility/functional/reference_wrapper/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
reference_wrapper( T&amp; x );
}}
{{dcl | since=c++11 | 1=
reference_wrapper( T&amp;&amp; x ) = delete;
}}
{{dcl | since=c++11 | 1=
reference_wrapper( const reference_wrapper&lt;T&gt;&amp; other );
}}
{{dcl end}}

Constructs a new reference wrapper.

1) Stores a reference to {{tt|x}}.

2) Construction from a temporary object is not allowed.

3) Copy constructor. Stores a reference to {{tt|other.get()}}.

===Parameters===
{{par begin}}
{{par | x | an object to wrap}}
{{par | other | another reference wrapper}}
{{par end}}

===Exceptions===
{{noexcept}}

[[de:cpp/utility/functional/reference wrapper/reference wrapper]]
[[es:cpp/utility/functional/reference wrapper/reference wrapper]]
[[fr:cpp/utility/functional/reference wrapper/reference wrapper]]
[[it:cpp/utility/functional/reference wrapper/reference wrapper]]
[[ja:cpp/utility/functional/reference wrapper/reference wrapper]]
[[pt:cpp/utility/functional/reference wrapper/reference wrapper]]
[[ru:cpp/utility/functional/reference wrapper/reference wrapper]]
[[zh:cpp/utility/functional/reference wrapper/reference wrapper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/unary function</title>
    <ns>0</ns>
    <id>5155</id>
    <revision>
      <id>67554</id>
      <parentid>59599</parentid>
      <timestamp>2014-02-11T18:23:44Z</timestamp>
      <contributor>
        <username>Fanael</username>
        <id>1958</id>
      </contributor>
      <comment>nope</comment>
      <text xml:space="preserve" bytes="2475">{{cpp/title|unary_function}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl | notes={{mark deprecated}} | 1=
template &lt;typename ArgumentType, typename ResultType&gt;
struct unary_function;
}}
{{dcl end}}

{{tt|unary_function}} is a base class for creating function objects with one argument.

{{tt|unary_function}} does not define {{c|operator()}}; it is expected that derived classes will define this. {{tt|unary_function}} provides only two types - {{tt|argument_type}} and {{tt|result_type}} - defined by the template parameters.

Some standard library function object adaptors, such as {{lc|std::not1}}, require the function objects they adapt to have certain types defined; {{lc|std::not1}} requires the function object being adapted to have a type named {{tt|argument_type}}. Deriving function objects that take one argument from {{tt|unary_function}} is an easy way to make them compatible with those adaptors.

{{tt|unary_function}} is deprecated in C++11.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|argument_type}} | {{tt|ArgumentType}} }}
{{dsc | {{tt|result_type}} | {{tt|ResultType}} }}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

struct less_than_7 : std::unary_function&lt;int, bool&gt;
{
    bool operator()(int i) const { return i &lt; 7; }
};

int main()
{
    std::vector&lt;int&gt; v;
    for (int i = 0; i &lt; 10; ++i) v.push_back(i);
    
    std::cout &lt;&lt; std::count_if(v.begin(), v.end(), std::not1(less_than_7()));
    
    /* C++11 solution:
        // Cast to std::function&lt;bool (int)&gt; somehow - even with a lambda
        std::cout &lt;&lt; std::count_if(v.begin(), v.end(),
            std::not1(std::function&lt;bool (int)&gt;([](int i){ return i &lt; 7; }))
        );
    */
}
 | output=
3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc pointer_to_unary_function}}
{{dsc inc | cpp/utility/functional/dsc binary_function}}
{{dsc end}}

[[de:cpp/utility/functional/unary function]]
[[es:cpp/utility/functional/unary function]]
[[fr:cpp/utility/functional/unary function]]
[[it:cpp/utility/functional/unary function]]
[[ja:cpp/utility/functional/unary function]]
[[pt:cpp/utility/functional/unary function]]
[[ru:cpp/utility/functional/unary function]]
[[zh:cpp/utility/functional/unary function]]</text>
      <sha1>lw42q5xsue0ws9tw31qp666twwj9da4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/functional/unary negate</title>
    <ns>0</ns>
    <id>5161</id>
    <revision>
      <id>66307</id>
      <parentid>61843</parentid>
      <timestamp>2013-11-10T02:27:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="3845">{{cpp/title|unary_negate}}
{{cpp/utility/functional/navbar}}
{{dcl begin}}
{{dcl header | functional }}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class Predicate &gt;
struct unary_negate : public std::unary_function&lt;Predicate::argument_type, bool&gt;;
}}
{{dcl | since=c++11 | 
template&lt; class Predicate &gt;
struct unary_negate;
}}
{{dcl rev end}}
{{dcl end}}

{{tt|unary_negate}} is a wrapper function object returning the complement of the unary predicate it holds.

The unary predicate type must define a member type, {{tt|argument_type}}, that is convertible to the predicate's parameter type. The unary function objects obtained from {{lc|std::ref}}, {{lc|std::cref}}, {{lc|std::negate}}, {{lc|std::logical_not}}, {{lc|std::mem_fn}}, {{lc|std::function}}, {{lc|std::hash}}, or from another call to {{lc|std::not1}} have this type defined, as are function objects derived from the deprecated {{lc|std::unary_function}}. 

{{tt|unary_negate}} objects are easily constructed with helper function {{lc|std::not1}}.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition }}
{{dsc | {{tt|argument_type}} | {{c|Predicate::argument_type}} }}
{{dsc | {{tt|result_type}} | {{c|bool}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | nolink=true | constructs a new unary_negate object with the supplied predicate}}
{{dsc mem fun | operator() | nolink=true | returns the logical complement of the result of a call to the stored predicate}}
{{dsc end}}

{{member | {{small|std::unary_negate::}}unary_negate | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
explicit unary_negate( Predicate const&amp; pred );
}}
{{dcl |since=c++14|
explicit constexpr unary_negate( Predicate const&amp; pred );
}}
{{dcl rev end}}
{{dcl end}}

Constructs a {{tt|unary_negate}} function object with the stored predicate {{tt|pred}}.

===Parameters===
{{par begin}}
{{par | pred | predicate function object}}
{{par end}}

}}

{{member | {{small|std::unary_negate::}}operator() | 2=
{{dcl begin}}
{{dcl rev begin}}
{{dcl |until=c++14|
bool operator()( argument_type const&amp; x ) const;
}}
{{dcl |since=c++14|
constexpr bool operator()( argument_type const&amp; x ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns the logical complement of the result of calling  {{c|pred(x)}}.

===Parameters===
{{par begin}}
{{par | x | argument to pass through to predicate}}
{{par end}}

===Return value===
The logical complement of the result of calling {{c|pred(x)}}.

}}

===Example===
{{example
 |
 | code=
#include &lt;algorithm&gt;
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;

struct less_than_7 : std::unary_function&lt;int, bool&gt;
{
    bool operator()(int i) const { return i &lt; 7; }
};

int main()
{
    std::vector&lt;int&gt; v;
    for (int i = 0; i &lt; 10; ++i) v.push_back(i);
    
    std::unary_negate&lt;less_than_7&gt; not_less_than_7((less_than_7()));
    
    std::cout &lt;&lt; std::count_if(v.begin(), v.end(), not_less_than_7);
    
    /* C++11 solution:
        // Use std::function&lt;bool (int)&gt;
        std::function&lt;bool (int)&gt; not_less_than_7 =
            [](int x)-&gt;bool{ return !less_than_7()(x); };
        
        std::cout &lt;&lt; std::count_if(v.begin(), v.end(), not_less_than_7);
    */
}
 | output=
3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/functional/dsc binary_negate}}
{{dsc inc | cpp/utility/functional/dsc function}}
{{dsc inc | cpp/utility/functional/dsc not1}}
{{dsc inc | cpp/utility/functional/dsc ptr_fun}}
{{dsc inc | cpp/utility/functional/dsc unary_function}}
{{dsc end}}

[[de:cpp/utility/functional/unary negate]]
[[es:cpp/utility/functional/unary negate]]
[[fr:cpp/utility/functional/unary negate]]
[[it:cpp/utility/functional/unary negate]]
[[ja:cpp/utility/functional/unary negate]]
[[pt:cpp/utility/functional/unary negate]]
[[ru:cpp/utility/functional/unary negate]]
[[zh:cpp/utility/functional/unary negate]]</text>
      <sha1>i2z9vipm5vb5lk32t8n5kvzctz0ajsd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/hash</title>
    <ns>0</ns>
    <id>2990</id>
    <revision>
      <id>72249</id>
      <parentid>68721</parentid>
      <timestamp>2014-07-29T17:32:07Z</timestamp>
      <contributor>
        <ip>84.201.173.97</ip>
      </contributor>
      <text xml:space="preserve" bytes="6720">{{cpp/title | hash}}
{{cpp/utility/hash/navbar}}
{{dcl begin}}
{{dcl header | functional}}
{{dcl | since=c++11 | 1=
template&lt; class Key &gt;
struct hash; // not defined
}}
{{dcl end}}

The hash template defines a function object that implements a [[enwiki:Hash function|hash function]].  Instances of this function object satisfy {{concept|Hash}}. In particular, they define an {{c|operator()}} that:

1. Accepts a single parameter of type {{tt|Key}}.

2. Returns a value of type {{c|size_t}} that represents the hash value of the parameter.

3. Does not throw exceptions when called.

4. For two parameters {{tt|k1}} and {{tt|k2}} that are equal, {{c|1=std::hash&lt;Key&gt;()(k1) == std::hash&lt;Key&gt;()(k2)}}.

5. For two different parameters {{tt|k1}} and {{tt|k2}} that are not equal, the probability that {{c|1=std::hash&lt;Key&gt;()(k1) == std::hash&lt;Key&gt;()(k2)}} should be very small, approaching {{c|1=1.0/std::numeric_limits&lt;size_t&gt;::max()}}.

The hash template is both {{concept|CopyConstructible}} and {{concept|Destructible}}.

The unordered associative containers {{lc|std::unordered_set}}, {{lc|std::unordered_multiset}}, {{lc|std::unordered_map}}, {{lc|std::unordered_multimap}} use specializations of the template {{lc|std::hash}} as the default hash function.

===Notes===
The actual hash functions are implementation-dependent and are not required to fulfill any other quality criteria except those specified above. Notably, some implementations use trivial (identity) hash functions which map an integer to itself. In other words, these hash functions are designed to work with unordered associative containers, but not as cryptographic hashes, for example.

{{rev begin}}
{{rev|since=c++14|Hash functions are only required to produce the same result for the same input within a single execution of a program; this allows salted hashes that prevent collision DoS attacks.}}
{{rev end}}

There is no specialization for C strings. {{c|std::hash&lt;const char*&gt;}} produces a hash of the value of the pointer (the memory address), it does not examine the contents of any character array.

===Member types===
{{dsc begin}}
{{dsc| {{tt|argument_type}} | {{tt|Key}} }}
{{dsc| {{tt|result_type}} | {{lc|std::size_t}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/utility/hash/hash | constructs a hash function object }}
{{dsc mem fun | cpp/utility/hash/operator() | calculate the hash of the argument }}
{{dsc end}}

===Standard specializations for basic types===
{{dcl begin}}
{{dcl header | functional}}
{{dcl|
template&lt;&gt; struct hash&lt;bool&gt;;
template&lt;&gt; struct hash&lt;char&gt;;
template&lt;&gt; struct hash&lt;signed char&gt;;
template&lt;&gt; struct hash&lt;unsigned char&gt;;
template&lt;&gt; struct hash&lt;char16_t&gt;;
template&lt;&gt; struct hash&lt;char32_t&gt;;
template&lt;&gt; struct hash&lt;wchar_t&gt;;
template&lt;&gt; struct hash&lt;short&gt;;
template&lt;&gt; struct hash&lt;unsigned short&gt;;
template&lt;&gt; struct hash&lt;int&gt;;
template&lt;&gt; struct hash&lt;unsigned int&gt;;
template&lt;&gt; struct hash&lt;long&gt;;
template&lt;&gt; struct hash&lt;long long&gt;;
template&lt;&gt; struct hash&lt;unsigned long&gt;;
template&lt;&gt; struct hash&lt;unsigned long long&gt;;
template&lt;&gt; struct hash&lt;float&gt;;
template&lt;&gt; struct hash&lt;double&gt;;
template&lt;&gt; struct hash&lt;long double&gt;;
template&lt; class T &gt; struct hash&lt;T*&gt;;}}
{{dcl end}}
{{rev begin}}
{{rev|since=c++14|
In addition to the above, standard library provides specializations for all (scoped and unscoped) enumeration types (which are not required, but usually are implemented as {{c|std::hash&lt;std::underlying_type&lt;Enum&gt;::type&gt;}})
}}
{{rev end}}

===Standard specializations for library types===
{{dsc begin}}
{{dsc inc | cpp/string/basic_string/dsc hash}}
{{dsc inc | cpp/error/error_code/dsc hash}}
{{dsc inc | cpp/utility/bitset/dsc hash}}
{{dsc inc | cpp/memory/unique_ptr/dsc hash}}
{{dsc inc | cpp/memory/shared_ptr/dsc hash}}
{{dsc inc | cpp/types/type_index/dsc hash}}
{{dsc ptclass | cpp/container/vector bool/hash | title=std::hash{{dsc small|&lt;std::vector&lt;bool&gt;&gt;}} | hash support for {{c|std::vector&lt;bool&gt;}} | notes={{mark c++11}} }}
{{dsc ptclass | cpp/thread/thread/id/hash | title=std::hash{{dsc small|&lt;std::thread::id&gt;}} | hash support for {{lc|std::thread::id}} | notes={{mark c++11}} }}
{{dsc end}}

===Examples===
{{example |
Demonstrates the computation of a hash for {{lc|std::string}}, a type that already has a hash specialization.
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;string&gt;

int main()
{
    std::string str = &quot;Meet the new boss...&quot;;
    std::hash&lt;std::string&gt; hash_fn;
    std::size_t str_hash = hash_fn(str);

    std::cout &lt;&lt; str_hash &lt;&lt; '\n';
}
 | output=
391070135
|p=true
}}
{{example |
Demonstrates creation of a hash function for a user defined type. Using this as a template parameter for {{lc|std::unordered_map}}, {{lc|std::unordered_set}}, etc. also requires specialization of {{lc|std::equal_to}}.
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;string&gt;

struct S
{
    std::string first_name;
    std::string last_name;
};

template &lt;class T&gt;
class MyHash;

template&lt;&gt;
class MyHash&lt;S&gt;
{
public:
    std::size_t operator()(S const&amp; s) const 
    {
        std::size_t h1 = std::hash&lt;std::string&gt;()(s.first_name);
        std::size_t h2 = std::hash&lt;std::string&gt;()(s.last_name);
        return h1 ^ (h2 &lt;&lt; 1);
    }
};

int main()
{
    std::string s1 = &quot;Hubert&quot;;
    std::string s2 = &quot;Farnsworth&quot;;
    std::hash&lt;std::string&gt; h1;

    S n1;
    n1.first_name = s1;
    n1.last_name =  s2;

    std::cout &lt;&lt; &quot;hash(s1) = &quot; &lt;&lt; h1(s1) &lt;&lt; &quot;\n&quot;
              &lt;&lt; &quot;hash(s2) = &quot; &lt;&lt; std::hash&lt;std::string&gt;()(s2) &lt;&lt; &quot;\n&quot;
	      &lt;&lt; &quot;hash(n1) = &quot; &lt;&lt; MyHash&lt;S&gt;()(n1) &lt;&lt; &quot;\n&quot;;
  
}
 | output=
hash(s1) = 6119893563398376542
hash(s2) = 14988020022735710972
hash(n1) = 17649170831080298918
|p=true
}}
{{example |
Demonstrates how to specialize {{lc|std::hash}} for a user defined type.
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;string&gt;

struct S
{
    std::string first_name;
    std::string last_name;
};

namespace std
{
    template&lt;&gt;
    struct hash&lt;S&gt;
    {
        typedef S argument_type;
        typedef std::size_t result_type;

        result_type operator()(argument_type const&amp; s) const
        {
            result_type const h1 ( std::hash&lt;std::string&gt;()(s.first_name) );
            result_type const h2 ( std::hash&lt;std::string&gt;()(s.last_name) );
            return h1 ^ (h2 &lt;&lt; 1);
        }
    };
}

int main()
{
    S s;
    s.first_name = &quot;Bender&quot;;
    s.last_name =  &quot;Rodriguez&quot;;
    std::hash&lt;S&gt; hash_fn;

    std::cout &lt;&lt; &quot;hash(s) = &quot; &lt;&lt; hash_fn(s) &lt;&lt; &quot;\n&quot;;
}
 | output=
hash(s) = 32902390710
|p=true
}}

[[de:cpp/utility/hash]]
[[es:cpp/utility/hash]]
[[fr:cpp/utility/hash]]
[[it:cpp/utility/hash]]
[[ja:cpp/utility/hash]]
[[pt:cpp/utility/hash]]
[[ru:cpp/utility/hash]]
[[zh:cpp/utility/hash]]</text>
      <sha1>jta096nepeays5suiz3on3e2grcdyrc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/hash/hash</title>
    <ns>0</ns>
    <id>5532</id>
    <revision>
      <id>51683</id>
      <parentid>41864</parentid>
      <timestamp>2013-06-01T04:16:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="420">{{cpp/title | hash::hash}}
{{cpp/utility/hash/navbar}}

The {{lc|std::hash}} class should be {{concept|DefaultConstructible}}, {{concept|CopyConstructible}}, and {{concept|Destructible}}.

[[de:cpp/utility/hash/hash]]
[[es:cpp/utility/hash/hash]]
[[fr:cpp/utility/hash/hash]]
[[it:cpp/utility/hash/hash]]
[[ja:cpp/utility/hash/hash]]
[[pt:cpp/utility/hash/hash]]
[[ru:cpp/utility/hash/hash]]
[[zh:cpp/utility/hash/hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/hash/operator()</title>
    <ns>0</ns>
    <id>5524</id>
    <revision>
      <id>51684</id>
      <parentid>41861</parentid>
      <timestamp>2013-06-01T04:16:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1991">{{cpp/title | hash&lt;Key&gt;::operator()}}
{{cpp/utility/hash/navbar}}

Specializations of {{lc|std::hash}} should define an {{tt|operator()}} that:

* Takes a single argument {{tt|key}} of type {{tt|Key}}. 
* Returns a value of type {{c|size_t}} that represents the hash value of {{tt|key}}.
* For two parameters {{tt|k1}} and {{tt|k2}} that are equal, {{c|1=std::hash&lt;Key&gt;()(k1) == std::hash&lt;Key&gt;()(k2)}}.
* For two different parameters {{tt|k1}} and {{tt|k2}} that are not equal, the probability that {{c|1=std::hash&lt;Key&gt;()(k1) == std::hash&lt;Key&gt;()(k2)}} should be very small, approaching {{c|1.0/std::numeric_limits&lt;size_t&gt;::max()}}.

===Parameters===
{{par begin}}
{{par | key | the object to be hashed}}
{{par end}}

===Return value===
a {{c|size_t}} representing the hash value

===Exceptions===
Hash functions should not throw exceptions.

===Example===
{{example 
| The following code shows how to specialize the {{lc|std::hash}} template for a custom class.
| code=
#include &lt;functional&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

struct Employee {
  std::string name;
  unsigned int ID;
};

namespace std {
template &lt;&gt;
class hash&lt;Employee&gt; {
 public:
  size_t operator()(const Employee &amp;employee) const
  {
    // computes the hash of an employee using a variant 
    // of the Fowler-Noll-Vo hash function
    size_t result = 2166136261;

    for (size_t i = 0, ie = employee.name.size(); i != ie; ++i) {
      result = (result * 16777619) ^ employee.name[i];
    }

    return result ^ (employee.ID &lt;&lt; 1);
  }
};
}

int main()
{
  Employee employee;
  employee.name = &quot;Zaphod Beeblebrox&quot;;
  employee.ID = 42;

  std::hash&lt;Employee&gt; hash_fn;
  std::cout &lt;&lt; hash_fn(employee) &lt;&lt; '\n';
}
| output=
177237019
}}

[[de:cpp/utility/hash/operator()]]
[[es:cpp/utility/hash/operator()]]
[[fr:cpp/utility/hash/operator()]]
[[it:cpp/utility/hash/operator()]]
[[ja:cpp/utility/hash/operator()]]
[[pt:cpp/utility/hash/operator()]]
[[ru:cpp/utility/hash/operator()]]
[[zh:cpp/utility/hash/operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/in place</title>
    <ns>0</ns>
    <id>10104</id>
    <revision>
      <id>64416</id>
      <parentid>63094</parentid>
      <timestamp>2013-08-16T14:44:50Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added std::optional see also</comment>
      <text xml:space="preserve" bytes="517">{{cpp/title|in_place}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | optional}}
{{dcl | since=c++14 |1=
constexpr in_place_t in_place{};
}}
{{dcl end}}

{{tt|std::in_place}} is a constant of type {{c|std::in_place_t}} that is used to disambiguate the overloads of constructors and member functions of that take arguments (possibly a parameter pack) for in-place construction of some value.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc in_place_t}}
{{dsc inc | cpp/utility/dsc optional}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/in place t</title>
    <ns>0</ns>
    <id>10101</id>
    <revision>
      <id>64415</id>
      <parentid>63095</parentid>
      <timestamp>2013-08-16T14:44:16Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added std::optional see also</comment>
      <text xml:space="preserve" bytes="479">{{cpp/title|in_place_t}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | optional}}
{{dcl | since=c++14 |1=
struct in_place_t {};
}}
{{dcl end}}

{{tt|std::in_place_t}} is an empty class type used to disambiguate the overloads of constructors and member functions of that take arguments (possibly a parameter pack) for in-place construction of some value.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc in_place}}
{{dsc inc | cpp/utility/dsc optional}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list</title>
    <ns>0</ns>
    <id>2361</id>
    <revision>
      <id>71656</id>
      <parentid>71655</parentid>
      <timestamp>2014-06-18T03:13:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+it's still possible to be in .rodata in C++14</comment>
      <text xml:space="preserve" bytes="4931">{{cpp/title|initializer_list}}
{{cpp/utility/initializer_list/navbar}}
(not to be confused with [[cpp/language/initializer list|member initializer list]])
{{ddcl | header = initializer_list | since=c++11 |
template&lt; class T &gt;
class initializer_list;
}}

An object of type {{tt|std::initializer_list&lt;T&gt;}} is a lightweight proxy object that provides access to an array of objects of type {{tt|const T}}.  

A {{tt|std::initializer_list}} object is automatically constructed when:
* a ''braced-init-list'' is used in [[cpp/language/list_initialization |list-initialization]], including function-call list initialization and assignment expressions 
* a ''braced-init-list'' is bound to {{c|auto}}, including in a [[cpp/language/range-for | ranged for loop]]

Initializer lists may be implemented as a pair of pointers or pointer and length. Copying a {{tt|std::initializer_list}} does not copy the underlying objects.

{{rev begin}}
{{rev|until=c++14|The underlying array is not guaranteed to exist after the lifetime of the original initializer list object has ended.  The storage for {{tt|std::initializer_list}} is unspecified (i.e. it could be automatic, temporary, or static read-only memory, depending on the situation).}}
{{rev|since=c++14|The underlying array is a temporary array, in which each element is copy-initialized (except that narrowing conversions are invalid) from the corresponding element of the original initializer list. The lifetime of the underlying array is the same as any other [[cpp/language/lifetime#Temporary_object_lifetime|temporary object]], except that initializing an initializer_list object from the array extends the lifetime of the array exactly like [[cpp/language/reference_initialization#Lifetime_of_a_temporary|binding a reference to a temporary]] (with the same exceptions, such as for initializing a non-static class member). The underlying array may be allocated in read-only memory.
}}
{{rev end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{c|T}}}}
{{dsc | {{tt|reference}} | {{c|const T&amp;}}}}
{{dsc | {{tt|const_reference}} | {{c|const T&amp;}}}}
{{dsc | {{tt|size_type}} | {{c|std::size_t}}}}
{{dsc | {{tt|iterator}} | {{c|const T*}}}}
{{dsc | {{tt|const_iterator}} | {{c|const T*}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc constructor}}
{{dsc h2 | Capacity}}
{{dsc inc | cpp/utility/initializer_list/dsc size}}
{{dsc h2 | Iterators}}
{{dsc inc | cpp/utility/initializer_list/dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc end}}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc begin2}}
{{dsc inc | cpp/utility/initializer_list/dsc end2}}
{{dsc header|iterator}}
{{dsc inc | cpp/utility/initializer_list/dsc rbegin2}}
{{dsc inc | cpp/utility/initializer_list/dsc rend2}}
{{dsc end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;initializer_list&gt;

template &lt;class T&gt;
struct S {
    std::vector&lt;T&gt; v;
    S(std::initializer_list&lt;T&gt; l) : v(l) {
         std::cout &lt;&lt; &quot;constructed with a &quot; &lt;&lt; l.size() &lt;&lt; &quot;-element list\n&quot;;
    }
    void append(std::initializer_list&lt;T&gt; l) {
        v.insert(v.end(), l.begin(), l.end());
    }
    std::pair&lt;const T*, std::size_t&gt; c_arr() const {
        return {&amp;v[0], v.size()};  // list-initialization in return statement
                                   // this is NOT a use of std::initializer_list
    }
};

template &lt;typename T&gt;
void templated_fn(T) {}

int main()
{
    S&lt;int&gt; s = {1, 2, 3, 4, 5}; // direct list-initialization
    s.append({6, 7, 8});      // list-initialization in function call

    std::cout &lt;&lt; &quot;The vector size is now &quot; &lt;&lt; s.c_arr().second &lt;&lt; &quot; ints:\n&quot;;

    for (auto n : s.v) std::cout &lt;&lt; ' ' &lt;&lt; n;

    std::cout &lt;&lt; '\n';

    std::cout &lt;&lt; &quot;range-for over brace-init-list: \n&quot;;

    for (int x : {-1, -2, -3}) // the rule for auto makes this ranged for work
        std::cout &lt;&lt; x &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    auto al = {10, 11, 12};   // special rule for auto

    std::cout &lt;&lt; &quot;The list bound to auto has size() = &quot; &lt;&lt; al.size() &lt;&lt; '\n';

//    templated_fn({1, 2, 3}); // compiler error! &quot;{1, 2, 3}&quot; is not an expression,
                             // it has no type, and so T cannot be deduced
    templated_fn&lt;std::initializer_list&lt;int&gt;&gt;({1, 2, 3}); // OK
    templated_fn&lt;std::vector&lt;int&gt;&gt;({1, 2, 3});           // also OK
}
 | output=
constructed with a 5-element list
The vector size is now 8 ints:
 1 2 3 4 5 6 7 8
range-for over brace-init-list: 
-1 -2 -3 
The list bound to auto has size() = 3
}}

[[de:cpp/utility/initializer list]]
[[es:cpp/utility/initializer list]]
[[fr:cpp/utility/initializer list]]
[[it:cpp/utility/initializer list]]
[[ja:cpp/utility/initializer list]]
[[pt:cpp/utility/initializer list]]
[[ru:cpp/utility/initializer list]]
[[zh:cpp/utility/initializer list]]</text>
      <sha1>gxrwsxgr44o73h1ibezpvp1k3qm5sm5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/begin</title>
    <ns>0</ns>
    <id>8510</id>
    <revision>
      <id>64493</id>
      <parentid>63506</parentid>
      <timestamp>2013-08-18T14:34:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="1076">{{cpp/utility/initializer_list/title | begin}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | const T* begin() const;}}
{{dcl | since=c++14 | constexpr const T* begin() const;}}
{{dcl rev end}}
{{dcl end}}

Returns a pointer to the first element in the initializer list.

If the initializer list is empty, the values of {{c|begin()}} and [[cpp/utility/initializer_list/end|{{c|end()}}]] are unspecified, but will be identical.

===Parameters===
(none)

===Return value===
a pointer to the first element in the initializer list

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc end}}
{{dsc end}}

[[de:cpp/utility/initializer list/begin]]
[[es:cpp/utility/initializer list/begin]]
[[fr:cpp/utility/initializer list/begin]]
[[it:cpp/utility/initializer list/begin]]
[[ja:cpp/utility/initializer list/begin]]
[[pt:cpp/utility/initializer list/begin]]
[[ru:cpp/utility/initializer list/begin]]
[[zh:cpp/utility/initializer list/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/begin2</title>
    <ns>0</ns>
    <id>8851</id>
    <revision>
      <id>71048</id>
      <parentid>64495</parentid>
      <timestamp>2014-06-05T01:12:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/specialization/overload</comment>
      <text xml:space="preserve" bytes="1367">{{cpp/title | begin&lt;small&gt;(std::initializer_list)&lt;/small&gt;}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class E &gt; 
const E* begin( initializer_list&lt;E&gt; il );
}}
{{dcl | since=c++14 |
template&lt; class E &gt; 
constexpr const E* begin( initializer_list&lt;E&gt; il );
}}
{{dcl rev end}}
{{dcl end}}

The overload of {{lc|std::begin}} for {{tt|initializer_list}} returns a pointer to the first element of {{tt|il}}.

===Parameters===
{{par begin}}
{{par | il | an {{tt|initializer_list}} }}
{{par end}} 

===Return value===
{{c|il.begin()}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;

int main() 
{
    // range-based for uses std::begin and std::end to iterate
    // over a given range; in this case, it's an initializer list
    for (int i : {3, 1, 4, 1}) {
        std::cout &lt;&lt; i &lt;&lt; '\n';
    }
}
 | output=
3
1
4
1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc begin}}
{{dsc end}}

[[de:cpp/utility/initializer list/begin2]]
[[es:cpp/utility/initializer list/begin2]]
[[fr:cpp/utility/initializer list/begin2]]
[[it:cpp/utility/initializer list/begin2]]
[[ja:cpp/utility/initializer list/begin2]]
[[pt:cpp/utility/initializer list/begin2]]
[[ru:cpp/utility/initializer list/begin2]]
[[zh:cpp/utility/initializer list/begin2]]</text>
      <sha1>4tj5yhsckt1iza9glj1im3lyhh61meo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/end</title>
    <ns>0</ns>
    <id>8511</id>
    <revision>
      <id>64494</id>
      <parentid>63507</parentid>
      <timestamp>2013-08-18T14:35:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="1103">{{cpp/utility/initializer_list/title | end}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | const T* end() const;}}
{{dcl | since=c++14 | constexpr const T* end() const;}}
{{dcl rev end}}
{{dcl end}}

Returns a pointer to one past the last element in the initializer list, i.e. {{c|begin() + size()}}.

If the initializer list is empty, the values of [[cpp/utility/initializer_list/begin|{{c|begin()}}]] and {{c|end()}} are unspecified, but will be identical.

===Parameters===
(none)

===Return value===
a pointer to one past the last element in the initializer list

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc begin}}
{{dsc end}}

[[de:cpp/utility/initializer list/end]]
[[es:cpp/utility/initializer list/end]]
[[fr:cpp/utility/initializer list/end]]
[[it:cpp/utility/initializer list/end]]
[[ja:cpp/utility/initializer list/end]]
[[pt:cpp/utility/initializer list/end]]
[[ru:cpp/utility/initializer list/end]]
[[zh:cpp/utility/initializer list/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/end2</title>
    <ns>0</ns>
    <id>8852</id>
    <revision>
      <id>71051</id>
      <parentid>64496</parentid>
      <timestamp>2014-06-05T01:16:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/specialization/overload</comment>
      <text xml:space="preserve" bytes="1348">{{cpp/title | end&lt;small&gt;(std::initializer_list)&lt;/small&gt;}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 |
template&lt; class E &gt; 
const E* end( initializer_list&lt;E&gt; il );
}}
{{dcl | since=c++11 | until=c++14 | 
template&lt; class E &gt; 
constexpr const E* end( initializer_list&lt;E&gt; il );
}}
{{dcl rev end}}
{{dcl end}}

The overload of {{lc|std::end}} for {{tt|initializer_list}} returns a pointer to one past the last element of {{tt|il}}.

===Parameters===
{{par begin}}
{{par | il | an {{tt|initializer_list}} }}
{{par end}} 

===Return value===
{{c|il.end()}}

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;

int main() 
{
    // range-based for uses std::begin and std::end to iterate
    // over a given range; in this case, it's an initializer list
    for (int i : {3, 1, 4, 1}) {
        std::cout &lt;&lt; i &lt;&lt; '\n';
    }
}
 | output=
3
1
4
1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/initializer_list/dsc end}}
{{dsc end}}

[[de:cpp/utility/initializer list/end2]]
[[es:cpp/utility/initializer list/end2]]
[[fr:cpp/utility/initializer list/end2]]
[[it:cpp/utility/initializer list/end2]]
[[ja:cpp/utility/initializer list/end2]]
[[pt:cpp/utility/initializer list/end2]]
[[ru:cpp/utility/initializer list/end2]]
[[zh:cpp/utility/initializer list/end2]]</text>
      <sha1>8w240n648vevq4fuom65wj3t9jq3jp4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/initializer list</title>
    <ns>0</ns>
    <id>8505</id>
    <revision>
      <id>64489</id>
      <parentid>63508</parentid>
      <timestamp>2013-08-18T04:08:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="2025">{{cpp/utility/initializer_list/title | initializer_list}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | initializer_list();}}
{{dcl | since=c++14 | constexpr initializer_list();}}
{{dcl rev end}}
{{dcl end}}

Constructs an empty initializer list.

===Parameters===
(none)

===Exceptions===
{{noexcept}}

===Complexity===
Constant

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;initializer_list&gt;

int main() 
{
    std::initializer_list&lt;int&gt; empty_list;
    std::cout &lt;&lt; &quot;empty_list.size(): &quot; &lt;&lt; empty_list.size() &lt;&lt; '\n';

    // create initializer lists using list-initialization
    std::initializer_list&lt;int&gt; digits {1, 2, 3, 4, 5};
    std::cout &lt;&lt; &quot;digits.size(): &quot; &lt;&lt; digits.size() &lt;&lt; '\n';

    // special rule for auto means 'fractions' has the
    // type std::initializer_list&lt;double&gt;
    auto fractions = {3.14159, 2.71828};
    std::cout &lt;&lt; &quot;fractions.size(): &quot; &lt;&lt; fractions.size() &lt;&lt; '\n';
}
 | output=
empty_list.size(): 0
digits.size(): 5
fractions.size(): 2
}}

===Notes===
Despite a lack of constructors, it is possible to create non-empty initializer lists.  Instances of {{tt|std::initializer_list}} are implicitly constructed when:
* a ''braced-init-list'' is used in [[cpp/language/list_initialization |list-initialization]], including function-call list initialization and assignment expressions (not to be confused with [[cpp/language/initializer_list | constructor initializer lists]])
* a ''braced-init-list'' is bound to {{c|auto}}, including in a [[cpp/language/range-for | ranged for loop]]

[[de:cpp/utility/initializer list/initializer list]]
[[es:cpp/utility/initializer list/initializer list]]
[[fr:cpp/utility/initializer list/initializer list]]
[[it:cpp/utility/initializer list/initializer list]]
[[ja:cpp/utility/initializer list/initializer list]]
[[pt:cpp/utility/initializer list/initializer list]]
[[ru:cpp/utility/initializer list/initializer list]]
[[zh:cpp/utility/initializer list/initializer list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/rbegin2</title>
    <ns>0</ns>
    <id>12972</id>
    <revision>
      <id>65346</id>
      <parentid>65345</parentid>
      <timestamp>2013-09-09T20:10:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note on crbegin</comment>
      <text xml:space="preserve" bytes="1340">{{cpp/title | rbegin&lt;small&gt;(std::initializer_list)&lt;/small&gt;}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl header|iterator}}
{{dcl | since=c++14|
template &lt;class E&gt;
std::reverse_iterator&lt;const E*&gt; rbegin( std::initializer_list&lt;E&gt; il );
}}
{{dcl end}}

The overload of {{lc|std::rbegin}} for {{tt|initializer_list}} returns an {{c|std::reverse_iterator}} pointing at the last element of {{tt|il}}.

===Parameters===
{{par begin}}
{{par | il | an {{tt|initializer_list}} }}
{{par end}} 

===Return value===
{{c|std::reverse_iterator&lt;const E*&gt;(il.end())}}.

===Exceptions===
(none)

===Notes===
This overload is necessary because {{lc|std::initializer_list}} does not have a member function {{tt|rbegin}}. No overload is needed for {{lc|std::crbegin}} because it is implemented in terms of {{lc|std::rbegin}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc rend}}
{{dsc end}}

[[de:cpp/utility/initializer list/rbegin2]]
[[es:cpp/utility/initializer list/rbegin2]]
[[fr:cpp/utility/initializer list/rbegin2]]
[[it:cpp/utility/initializer list/rbegin2]]
[[ja:cpp/utility/initializer list/rbegin2]]
[[pt:cpp/utility/initializer list/rbegin2]]
[[ru:cpp/utility/initializer list/rbegin2]]
[[zh:cpp/utility/initializer list/rbegin2]]</text>
      <sha1>nu2apvpg5eelprvvn0n21tcpj57kfxf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/rend2</title>
    <ns>0</ns>
    <id>12973</id>
    <revision>
      <id>65347</id>
      <timestamp>2013-09-09T20:13:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1315">{{cpp/title | rend&lt;small&gt;(std::initializer_list)&lt;/small&gt;}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl header|iterator}}
{{dcl | since=c++14|
template &lt;class E&gt;
std::reverse_iterator&lt;const E*&gt; rend( std::initializer_list&lt;E&gt; il );
}}
{{dcl end}}

The overload of {{lc|std::rend}} for {{tt|initializer_list}} returns an {{c|std::reverse_iterator}} pointing at the first element of {{tt|il}}.

===Parameters===
{{par begin}}
{{par | il | an {{tt|initializer_list}} }}
{{par end}} 

===Return value===
{{c|std::reverse_iterator&lt;const E*&gt;(il.begin())}}.

===Exceptions===
(none)

===Notes===
This overload is necessary because {{lc|std::initializer_list}} does not have a member function {{tt|rend}}. No overload is needed for {{lc|std::crend}} because it is implemented in terms of {{lc|std::rend}}.

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/dsc rbegin}}
{{dsc inc | cpp/iterator/dsc rend}}
{{dsc end}}

[[de:cpp/utility/initializer list/rend2]]
[[es:cpp/utility/initializer list/rend2]]
[[fr:cpp/utility/initializer list/rend2]]
[[it:cpp/utility/initializer list/rend2]]
[[ja:cpp/utility/initializer list/rend2]]
[[pt:cpp/utility/initializer list/rend2]]
[[ru:cpp/utility/initializer list/rend2]]
[[zh:cpp/utility/initializer list/rend2]]</text>
      <sha1>kgtt4ho3wumht17tz0bu5suzch2wn01</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/initializer list/size</title>
    <ns>0</ns>
    <id>5294</id>
    <revision>
      <id>64492</id>
      <parentid>63509</parentid>
      <timestamp>2013-08-18T14:33:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="841">{{cpp/utility/initializer_list/title|size}}
{{cpp/utility/initializer_list/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | size_type size() const;}}
{{dcl | since=c++14 | constexpr size_type size() const;}}
{{dcl rev end}}
{{dcl end}}

Returns the number of elements in the initializer list, i.e. {{c|std::distance(begin(), end())}}.

===Parameters===
(none)

===Return value===
the number of elements in the initializer list

===Exceptions===
{{noexcept}}

===Complexity===
Constant

[[de:cpp/utility/initializer list/size]]
[[es:cpp/utility/initializer list/size]]
[[fr:cpp/utility/initializer list/size]]
[[it:cpp/utility/initializer list/size]]
[[ja:cpp/utility/initializer list/size]]
[[pt:cpp/utility/initializer list/size]]
[[ru:cpp/utility/initializer list/size]]
[[zh:cpp/utility/initializer list/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/integer sequence</title>
    <ns>0</ns>
    <id>10004</id>
    <revision>
      <id>72036</id>
      <parentid>69458</parentid>
      <timestamp>2014-07-09T18:52:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/tt/ttb to make the helper templates stand out</comment>
      <text xml:space="preserve" bytes="3881">{{cpp/title|integer_sequence}}
{{cpp/utility/navbar}}
{{ddcl | since=c++14 | header=utility | 1=
template&lt; class T, T... Ints &gt;
class integer_sequence;
}}

The class template {{tt|std::integer_sequence}} represents a compile-time sequence of integers. When used as an argument to a [[cpp/language/function template|function template]], the [[cpp/language/parameter pack|parameter pack]] {{tt|Ints}} can be deduced and used in pack expansion.

===Template parameters===
{{par begin}}
{{par | T | an integer type to use for the elements of the sequence}}
{{par | ...Ints | a non-type parameter pack representing the sequence}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|T}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem sfun | cpp/utility/integer_sequence | inlinemem=true | title=size | returns the number of elements in {{tt|Ints}}}}
{{dsc end}}

{{member | {{small|std::integer_sequence::}}size | 2=
{{ddcl | 1=
static constexpr std::size_t size();
}}

Returns the number of elements in {{tt|Ints}}. Equivalent to {{c|sizeof...(Ints)}}

===Parameters===
(none)

===Return value===
The number of elements in {{tt|Ints}}.

===Exceptions===
{{noexcept}}
}}

===Helper templates===

A helper alias template {{ttb|std::index_sequence}} is defined for the common case where {{tt|T}} is {{lc|std::size_t}}.

{{ddcl | 1=
template&lt;std::size_t... Ints&gt;
using index_sequence = std::integer_sequence&lt;std::size_t, Ints...&gt;;
}}

A helper alias template {{ttb|std::make_integer_sequence}} is defined to simplify creation of {{tt|std::integer_sequence}} and {{tt|std::index_sequence}} types with 0, 1, 2, ..., {{tt|N-1}} as {{tt|Ints}}:

{{dcl begin}}
{{dcl | 1=
template&lt;class T, T N&gt;
using make_integer_sequence = std::integer_sequence&lt;T, /* a sequence 0, 1, 2, ..., N-1 */ &gt;;
}}
{{dcl | 1=
template&lt;std::size_t N&gt;
using make_index_sequence = make_integer_sequence&lt;std::size_t, N&gt;;
}}
{{dcl end}}

The behavior is undefined if {{tt|N}} is negative. If {{tt|N}} is zero, the indicated type is {{tt|integer_sequence&lt;T&gt;}}.

A helper alias template {{ttb|std::index_sequence_for}} is defined to convert any type parameter pack into an index sequence of the same length

{{dcl begin}}
{{dcl | 1=
template&lt;class... T&gt;
using index_sequence_for = std::make_index_sequence&lt;sizeof...(T)&gt;;
}}
{{dcl end}}

===Example===
{{example|
code=
#include &lt;tuple&gt;
#include &lt;iostream&gt;
#include &lt;array&gt;
#include &lt;utility&gt;

// Convert array into to tuple
template&lt;typename Array, std::size_t... I&gt;
auto a2t_impl(const Array&amp; a, std::index_sequence&lt;I...&gt;)
    -&gt; decltype(std::make_tuple(a[I]...))
{
    return std::make_tuple(a[I]...);
}

template&lt;typename T, std::size_t N, typename Indices = std::make_index_sequence&lt;N&gt;&gt;
auto a2t(const std::array&lt;T, N&gt;&amp; a)
    -&gt; decltype(a2t_impl(a, Indices()))
{
    return a2t_impl(a, Indices());
}

// pretty-print a tuple (from http://stackoverflow.com/a/6245777/273767 )

template&lt;class Ch, class Tr, class Tuple, std::size_t... Is&gt;
void print_tuple_impl(std::basic_ostream&lt;Ch,Tr&gt;&amp; os,
                      const Tuple &amp; t,
                      std::index_sequence&lt;Is...&gt;)
{
    using swallow = int[];
    (void)swallow{0, (void(os &lt;&lt; (Is == 0? &quot;&quot; : &quot;, &quot;) &lt;&lt; std::get&lt;Is&gt;(t)), 0)...};
}

template&lt;class Ch, class Tr, class... Args&gt;
auto operator&lt;&lt;(std::basic_ostream&lt;Ch, Tr&gt;&amp; os, const std::tuple&lt;Args...&gt;&amp; t)
   -&gt; std::basic_ostream&lt;Ch, Tr&gt;&amp;
{
    os &lt;&lt; &quot;(&quot;;
    print_tuple_impl(os, t, std::index_sequence_for&lt;Args...&gt;{});
    return os &lt;&lt; &quot;)&quot;;
}

int main()
{
    std::array&lt;int, 4&gt; array = {1,2,3,4};

    // convert an array into a tuple
    auto tuple = a2t(array);
    static_assert(std::is_same&lt;decltype(tuple),
                               std::tuple&lt;int, int, int, int&gt;&gt;::value, &quot;&quot;);

    // print it to cout
    std::cout &lt;&lt; tuple &lt;&lt; '\n';
}
|output=
(1, 2, 3, 4)
}}</text>
      <sha1>7h5o9u57d5vzmxbelqiewi5aqb54wcm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/make pair</title>
    <ns>0</ns>
    <id>2564</id>
    <redirect title="cpp/utility/pair/make pair" />
    <revision>
      <id>9377</id>
      <timestamp>2011-08-22T23:27:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/make pair]] to [[cpp/utility/pair/make pair]]: move to the class page</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/utility/pair/make pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/move</title>
    <ns>0</ns>
    <id>2664</id>
    <revision>
      <id>67937</id>
      <parentid>66922</parentid>
      <timestamp>2014-03-06T20:16:35Z</timestamp>
      <contributor>
        <ip>93.6.88.12</ip>
      </contributor>
      <comment>NULL =&gt; nullptr</comment>
      <text xml:space="preserve" bytes="5452">{{cpp/title|move}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T &gt;
typename std::remove_reference&lt;T&gt;::type&amp;&amp; move( T&amp;&amp; t );
}}
{{dcl | since=c++14 |
template&lt; class T &gt;
constexpr typename std::remove_reference&lt;T&gt;::type&amp;&amp; move( T&amp;&amp; t );
}}
{{dcl rev end}}
{{dcl end}}

{{tt|std::move}} obtains an rvalue reference to its argument and converts it to an [[cpp/language/value_category|xvalue]].

Code that receives such an [[cpp/language/value_category|xvalue]] has the opportunity to optimize away unnecessary overhead by ''moving'' data out of the argument, leaving it in a valid but unspecified state.
===Parameters===
{{par begin}}
{{par | t | the object to be moved}}
{{par end}}

===Return value===

{{c|static_cast&lt;typename std::remove_reference&lt;T&gt;::type&amp;&amp;&gt;(t)}}

===Exceptions===
{{noexcept}}


===Notes===
The functions that accept rvalue reference parameters (including [[cpp/language/move_constructor|move constructors]], [[cpp/language/move_operator|move assignment operators]], and regular member functions such as {{lc|std::vector::push_back}}) are selected, by [[cpp/language/overload_resolution|overload resolution]], when called with [[cpp/language/value_category|rvalue]] arguments (either  [[cpp/language/value_category|prvalues]] such as a temporary objects or  [[cpp/language/value_category|xvalue]]s such as the one produced by {{tt|std::move}}). If the argument identifies a resource-owning object, these overloads have the option, but aren't required, to ''move'' any resources held by the argument. For example, a move constructor of a linked list might copy the pointer to the head of the list and store {{c|nullptr}} in the argument instead of allocating and copying individual nodes.

Names of [[cpp/language/reference|rvalue reference]] variables are [[cpp/language/value_category|lvalues]] and have to be converted to [[cpp/language/value_category|xvalues]] to be bound to the function overloads that accept rvalue reference parameters, which is why [[cpp/language/move_constructor|move constructors]] and [[cpp/language/move_operator|move assignment operators]] typically use {{c|std::move}}:
{{source|1=
// Simple move constructor
Foo(A&amp;&amp; arg) : member(std::move(arg)) // the expression &quot;arg&quot; is lvalue
{} 
// Simple move assignment operator
A&amp; operator=(A&amp;&amp; other) {
     member = std::move(other.member);
     return *this;
}
}}
One exception is when the type of the function parameter is rvalue reference to type template parameter (&quot;universal reference&quot;), in which case {{lc|std::forward}} is used instead.

Unless otherwise specified, all standard library functions that accept rvalue reference parameters (such as {{lc|std::vector::push_back}}) are guaranteed to leave the moved-from argument in valid but unspecified state (that is, only the functions without preconditions, such as the assignment operator, may be used on the object after it was moved into a standard library container:
{{source|1=
std::vector&lt;std::string&gt; v;
std::string str = &quot;example&quot;;
v.push_back(std::move(str)); // str is now valid but unspecified
str[0]; // undefined behavior: operator[](size_t n) has a precondition size() &gt; n
str.clear(); // OK, clear() has no preconditions
}}

Also, the standard library functions called with xvalue arguments may assume the argument is the only reference to the object; if it was constructed from an lvalue with {{tt|std::move}}, no aliasing checks are made. In particular, this means that standard library move assignment operators do not have to perform self-assignment checks:
{{source|1=
std::string s = &quot;example&quot;;
s = std::move(s); // undefined behavior
}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;
#include &lt;string&gt;

int main()
{
    std::string str = &quot;Hello&quot;;
    std::vector&lt;std::string&gt; v;

    // uses the push_back(const T&amp;) overload, which means 
    // we'll incur the cost of copying str
    v.push_back(str);
    std::cout &lt;&lt; &quot;After copy, str is \&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot;\n&quot;;

    // uses the rvalue reference push_back(T&amp;&amp;) overload, 
    // which means no strings will be copied; instead, the contents
    // of str will be moved into the vector.  This is less
    // expensive, but also means str might now be empty.
    v.push_back(std::move(str));
    std::cout &lt;&lt; &quot;After move, str is \&quot;&quot; &lt;&lt; str &lt;&lt; &quot;\&quot;\n&quot;;

    std::cout &lt;&lt; &quot;The contents of the vector are \&quot;&quot; &lt;&lt; v[0]
                                         &lt;&lt; &quot;\&quot;, \&quot;&quot; &lt;&lt; v[1] &lt;&lt; &quot;\&quot;\n&quot;;

    // string move assignment operator is often implemented as swap,
    // in this case, the moved-from object is NOT empty
    std::string str2 = &quot;Good-bye&quot;;
    std::cout &lt;&lt; &quot;Before move from str2, str2 = '&quot; &lt;&lt; str2 &lt;&lt; &quot;'\n&quot;;
    v[0] = std::move(str2);
    std::cout &lt;&lt; &quot;After move from str2, str2 = '&quot; &lt;&lt; str2 &lt;&lt; &quot;'\n&quot;;
}
 | p=true
 | output=
After copy, str is &quot;Hello&quot;
After move, str is &quot;&quot;
The contents of the vector are &quot;Hello&quot;, &quot;Hello&quot;
Before move from str2, str2 = 'Good-bye'
After move from str2, str2 = 'Hello'
}}

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc forward}}
{{dsc inc | cpp/utility/dsc move_if_noexcept}}
{{dsc inc | cpp/algorithm/dsc move}}
{{dsc end}}

[[de:cpp/utility/move]]
[[es:cpp/utility/move]]
[[fr:cpp/utility/move]]
[[it:cpp/utility/move]]
[[ja:cpp/utility/move]]
[[pt:cpp/utility/move]]
[[ru:cpp/utility/move]]
[[zh:cpp/utility/move]]</text>
      <sha1>ahdtq5rdpzv4b5w1rw4xschyn9ofzpe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/move if noexcept</title>
    <ns>0</ns>
    <id>2668</id>
    <revision>
      <id>64499</id>
      <parentid>63099</parentid>
      <timestamp>2013-08-18T14:48:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr, move vector::resize to notes and mention its fallback</comment>
      <text xml:space="preserve" bytes="2851">{{cpp/title|move_if_noexcept}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T &gt;
typename std::conditional&lt;  
    !std::is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; std::is_copy_constructible&lt;T&gt;::value,
    const T&amp;,
    T&amp;&amp; 
&gt;::type move_if_noexcept(T&amp; x);
}}
{{dcl | since=c++14 |
template&lt; class T &gt;
constexpr typename std::conditional&lt;  
    !std::is_nothrow_move_constructible&lt;T&gt;::value &amp;&amp; std::is_copy_constructible&lt;T&gt;::value,
    const T&amp;,
    T&amp;&amp; 
&gt;::type move_if_noexcept(T&amp; x);
}}
{{dcl rev end}}
{{dcl end}}

{{tt|move_if_noexcept}} obtains an rvalue reference to its argument if its move constructor does not throw exceptions, otherwise obtains an lvalue reference to its argument. It is typically used to combine move semantics with strong exception guarantee.

===Parameters===
{{par begin}}
{{par | x | the object to be moved or copied}}
{{par end}}

===Return value===

{{c|std::move(x)}} or {{c|x}}, depending on exception guarantees.

===Exceptions===
{{noexcept}}

===Notes===
This is used, for example, by {{c|std::vector::resize}}, which may have to allocate new storage and then move or copy elements from old storage to new storage. If an exception occurs during this operation, {{c|std::vector::resize}} undoes everything it did to this point, which is only possible if {{tt|std::move_if_noexcept}} was used to decide whether to use move construction or copy construction. (unless copy constructor is not available, in which case move constructor is used either way and the strong exception guarantee may be  waived)

===Example===
{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;

struct Bad
{
    Bad() {}
    Bad(Bad&amp;&amp;)  // may throw
    {
        std::cout &lt;&lt; &quot;Throwing move constructor called\n&quot;;
    }
    Bad(const Bad&amp;) // may throw as well
    {
        std::cout &lt;&lt; &quot;Throwing copy constructor called\n&quot;;
    }
};

struct Good
{
    Good() {}
    Good(Good&amp;&amp;) noexcept // will NOT throw
    {
        std::cout &lt;&lt; &quot;Non-throwing move constructor called\n&quot;;
    }
    Good(const Good&amp;) noexcept // will NOT throw
    {
        std::cout &lt;&lt; &quot;Non-throwing copy constructor called\n&quot;;
    }
};

int main()
{
    Good g;
    Bad b;
    Good g2 = std::move_if_noexcept(g);
    Bad b2 = std::move_if_noexcept(b);
}
 | output=
Non-throwing move constructor called
Throwing copy constructor called
}}

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc forward}}
{{dsc inc | cpp/utility/dsc move}}
{{dsc end}}

[[de:cpp/utility/move if noexcept]]
[[es:cpp/utility/move if noexcept]]
[[fr:cpp/utility/move if noexcept]]
[[it:cpp/utility/move if noexcept]]
[[ja:cpp/utility/move if noexcept]]
[[pt:cpp/utility/move if noexcept]]
[[ru:cpp/utility/move if noexcept]]
[[zh:cpp/utility/move if noexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/nullopt</title>
    <ns>0</ns>
    <id>10103</id>
    <revision>
      <id>63100</id>
      <parentid>61959</parentid>
      <timestamp>2013-07-01T23:54:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="389">{{cpp/title|nullopt}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | optional}}
{{dcl | since=c++14 |1=
constexpr nullopt_t nullopt{/*unspecified*/};
}}
{{dcl end}}

{{tt|std::nullopt}} is a constant of type {{lc|std::nullopt_t}} that is used to indicate {{tt|optional}} type with uninitialized state. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc nullopt_t}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/nullopt t</title>
    <ns>0</ns>
    <id>10102</id>
    <revision>
      <id>63101</id>
      <parentid>59626</parentid>
      <timestamp>2013-07-01T23:54:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="337">{{cpp/title|nullopt_t}}
{{cpp/utility/navbar}}
{{dcl begin}}
{{dcl header | optional}}
{{dcl | since=c++14 |1=
struct nullopt_t {};
}}
{{dcl end}}

{{tt|std::nullopt_t}} is an empty class type used to indicate {{tt|optional}} type with uninitialized state. 

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc nullopt}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional</title>
    <ns>0</ns>
    <id>13184</id>
    <redirect title="cpp/experimental/optional" />
    <revision>
      <id>68037</id>
      <timestamp>2014-03-16T20:18:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional]] to [[cpp/experimental/optional]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/experimental/optional]]</text>
      <sha1>hzddk0gpkzso4mqet26rm5aka8i7ojs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/emplace</title>
    <ns>0</ns>
    <id>13185</id>
    <redirect title="cpp/experimental/optional/emplace" />
    <revision>
      <id>68039</id>
      <timestamp>2014-03-16T20:18:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/emplace]] to [[cpp/experimental/optional/emplace]]</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[cpp/experimental/optional/emplace]]</text>
      <sha1>0ue4hv6tmfaj1xl3po5okh0vkm1r336</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/hash</title>
    <ns>0</ns>
    <id>13186</id>
    <redirect title="cpp/experimental/optional/hash" />
    <revision>
      <id>68041</id>
      <timestamp>2014-03-16T20:18:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/hash]] to [[cpp/experimental/optional/hash]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/experimental/optional/hash]]</text>
      <sha1>4zq8laud0b5rqdy9yei5to8l1wza15k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/make optional</title>
    <ns>0</ns>
    <id>13187</id>
    <redirect title="cpp/experimental/optional/make optional" />
    <revision>
      <id>68043</id>
      <timestamp>2014-03-16T20:18:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/make optional]] to [[cpp/experimental/optional/make optional]]</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[cpp/experimental/optional/make optional]]</text>
      <sha1>0ybp6qqwo4rcqsr9ls2zsj41hpp8xob</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/operator*</title>
    <ns>0</ns>
    <id>13188</id>
    <redirect title="cpp/experimental/optional/operator*" />
    <revision>
      <id>68045</id>
      <timestamp>2014-03-16T20:18:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/operator*]] to [[cpp/experimental/optional/operator*]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/experimental/optional/operator*]]</text>
      <sha1>33zvddyle2a5m86dcd1aaxkzjysanb5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/operator=</title>
    <ns>0</ns>
    <id>13189</id>
    <redirect title="cpp/experimental/optional/operator=" />
    <revision>
      <id>68047</id>
      <timestamp>2014-03-16T20:18:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/operator=]] to [[cpp/experimental/optional/operator=]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/experimental/optional/operator=]]</text>
      <sha1>7r0b0rxhk9902dlajsdueakaifv0wbd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/operator bool</title>
    <ns>0</ns>
    <id>13190</id>
    <redirect title="cpp/experimental/optional/operator bool" />
    <revision>
      <id>68049</id>
      <timestamp>2014-03-16T20:18:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/operator bool]] to [[cpp/experimental/optional/operator bool]]</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[cpp/experimental/optional/operator bool]]</text>
      <sha1>03qq1eightf1ptuibo8vgkc4hvyd0na</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/operator cmp</title>
    <ns>0</ns>
    <id>13191</id>
    <redirect title="cpp/experimental/optional/operator cmp" />
    <revision>
      <id>68051</id>
      <timestamp>2014-03-16T20:18:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/operator cmp]] to [[cpp/experimental/optional/operator cmp]]</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[cpp/experimental/optional/operator cmp]]</text>
      <sha1>9x8f4xb2fbyhurtg1h3xmgkeqd43pxu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/optional</title>
    <ns>0</ns>
    <id>13192</id>
    <redirect title="cpp/experimental/optional/optional" />
    <revision>
      <id>68053</id>
      <timestamp>2014-03-16T20:18:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/optional]] to [[cpp/experimental/optional/optional]]</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/experimental/optional/optional]]</text>
      <sha1>9229z9d05eb4gt3x75flswgj2rjfzrw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/swap</title>
    <ns>0</ns>
    <id>13193</id>
    <redirect title="cpp/experimental/optional/swap" />
    <revision>
      <id>68055</id>
      <timestamp>2014-03-16T20:18:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/swap]] to [[cpp/experimental/optional/swap]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/experimental/optional/swap]]</text>
      <sha1>k4wgykbo3n7yj1ujznbbs8sypjmwbjk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/swap2</title>
    <ns>0</ns>
    <id>13194</id>
    <redirect title="cpp/experimental/optional/swap2" />
    <revision>
      <id>68057</id>
      <timestamp>2014-03-16T20:18:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/swap2]] to [[cpp/experimental/optional/swap2]]</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/experimental/optional/swap2]]</text>
      <sha1>ivfgp65gjtnd0x6wqu9wwrx4rbsmszf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/value</title>
    <ns>0</ns>
    <id>13195</id>
    <redirect title="cpp/experimental/optional/value" />
    <revision>
      <id>68059</id>
      <timestamp>2014-03-16T20:18:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/value]] to [[cpp/experimental/optional/value]]</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[cpp/experimental/optional/value]]</text>
      <sha1>dockl9xkuto3v8rphovw1ugwusyroj6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/value or</title>
    <ns>0</ns>
    <id>13196</id>
    <redirect title="cpp/experimental/optional/value or" />
    <revision>
      <id>68061</id>
      <timestamp>2014-03-16T20:18:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/value or]] to [[cpp/experimental/optional/value or]]</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[cpp/experimental/optional/value or]]</text>
      <sha1>exq9tcgxhminuh5xnnjr9kdcimof39l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/optional/~optional</title>
    <ns>0</ns>
    <id>13197</id>
    <redirect title="cpp/experimental/optional/~optional" />
    <revision>
      <id>68063</id>
      <timestamp>2014-03-16T20:18:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[cpp/utility/optional/~optional]] to [[cpp/experimental/optional/~optional]]</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[cpp/experimental/optional/~optional]]</text>
      <sha1>la6ncioeisia7k9tlwc2hfc45yse162</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair</title>
    <ns>0</ns>
    <id>2121</id>
    <revision>
      <id>59645</id>
      <parentid>51710</parentid>
      <timestamp>2013-06-01T06:39:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1687">{{cpp/title|pair}}
{{cpp/utility/pair/navbar}}
{{ddcl | header=utility |
template&lt;
    class T1,
    class T2
&gt; struct pair;
}}

{{tt|std::pair}} is a struct template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a {{lc|std::tuple}} with two elements.

===Template parameters===
{{par begin}}
{{par | T1, T2 | the types of the elements that the pair stores.}}
{{par end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|first_type}} | {{tt|T1}} }}
{{dsc | {{tt|second_type}} | {{tt|T2}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|first}} | {{tt|T1}} }}
{{dsc | {{tt|second}} | {{tt|T2}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/utility/pair/pair | constructs new pair}}
{{dsc mem fun | cpp/utility/pair/operator{{=}} | assigns the contents}}
{{dsc mem fun | cpp/utility/pair/swap | swaps the contents | notes={{mark c++11}} }}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/pair/dsc make_pair}}
{{dsc inc | cpp/utility/pair/dsc operator_cmp}}
{{dsc inc | cpp/utility/pair/dsc swap2}}
{{dsc inc | cpp/utility/pair/dsc get}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/utility/pair/dsc tuple_size}}
{{dsc inc | cpp/utility/pair/dsc tuple_element}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc tuple}}
{{dsc end}}

[[cs:cpp/utility/pair]]
[[de:cpp/utility/pair]]
[[es:cpp/utility/pair]]
[[fr:cpp/utility/pair]]
[[it:cpp/utility/pair]]
[[ja:cpp/utility/pair]]
[[pt:cpp/utility/pair]]
[[ru:cpp/utility/pair]]
[[zh:cpp/utility/pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/get</title>
    <ns>0</ns>
    <id>2601</id>
    <revision>
      <id>72474</id>
      <parentid>64897</parentid>
      <timestamp>2014-08-25T11:15:38Z</timestamp>
      <contributor>
        <ip>91.150.26.226</ip>
      </contributor>
      <comment>typo: a element -&gt; an element</comment>
      <text xml:space="preserve" bytes="3178">{{cpp/title | get&lt;small&gt;(std::pair)&lt;/small&gt;}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | num=1 | since=c++11 | until=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;
    get( pair&lt;T1, T2&gt;&amp; p );
}}
{{dcl | num=1 | since=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
constexpr typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;
    get( pair&lt;T1, T2&gt;&amp; p );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | num=2 | since=c++11 | until=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
const typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;
    get( const pair&lt;T1,T2&gt;&amp; p );
}}
{{dcl | num=2 | since=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
constexpr const typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;
    get( const pair&lt;T1,T2&gt;&amp; p );
}}
{{dcl rev end}}
{{dcl rev begin | num=3}}
{{dcl | num=3 | since=c++11 | until=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;&amp;
    get( std::pair&lt;T1,T2&gt;&amp;&amp; p );
}}
{{dcl | num=3 | since=c++14 | 
template&lt; size_t N, class T1, class T2 &gt;
constexpr typename std::tuple_element&lt;I, std::pair&lt;T1,T2&gt; &gt;::type&amp;&amp;
    get( std::pair&lt;T1,T2&gt;&amp;&amp; p );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++14 | 
template &lt;class T, class U&gt;
constexpr T&amp; get(std::pair&lt;T, U&gt;&amp; p);

template &lt;class T, class U&gt;
constexpr const T&amp; get(const std::pair&lt;T, U&gt;&amp; p);
}}
{{dcl | num=5 | since=c++14 | 
template &lt;class T, class U&gt;
constexpr T&amp;&amp; get(std::pair&lt;T, U&gt;&amp;&amp; p);
}}
{{dcl | num=6 | since=c++14 | 
template &lt;class T, class U&gt;
constexpr T&amp; get(std::pair&lt;U, T&gt;&amp; p);

template &lt;class T, class U&gt;
constexpr const T&amp; get(const std::pair&lt;U, T&gt;&amp; p);
}}
{{dcl | num=7 | since=c++14 | 
template &lt;class T, class U&gt;
constexpr T&amp;&amp; get(std::pair&lt;U, T&gt;&amp;&amp; p);
}}
{{dcl end}}

Extracts an element from the pair using tuple-like interface.

Type-based overloads 4-7 fail to compile if the types {{tt|T}} and {{tt|U}} are the same.

===Parameters===
{{par begin}}
{{par | p | pair whose contents to extract}}
{{par end}} 

===Return value===

@1,2@ Returns {{tt|p.first}} if {{tt|1=N==0}} and {{tt|p.second}} if {{tt|1=N==1}}.
@3@ Returns {{c|std::forward&lt;T1&amp;&amp;&gt;(p.first)}} if {{tt|1=N==0}} and {{c|std::forward&lt;T2&amp;&amp;&gt;(p.second)}} if {{tt|1=N==1}}
@4@ Returns {{c|std::get&lt;0&gt;(p)}}
@5@ Returns {{c|std::get&lt;0&gt;(std::move(p))}}
@6@ Returns {{c|std::get&lt;1&gt;(p)}}
@7@ Returns {{c|std::get&lt;1&gt;(std::move(p))}}

===Exceptions===

{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;

int main()
{
    auto p = std::make_pair(1, 3.14);
    std::cout &lt;&lt; '(' &lt;&lt; std::get&lt;0&gt;(p) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(p) &lt;&lt; &quot;)\n&quot;;
    std::cout &lt;&lt; '(' &lt;&lt; std::get&lt;int&gt;(p) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;double&gt;(p) &lt;&lt; &quot;)\n&quot;;
}
 | output=
(1, 3.14)
(1, 3.14)
}}


===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc get}}
{{dsc inc | cpp/container/array/dsc get}}
{{dsc end}}

[[de:cpp/utility/pair/get]]
[[es:cpp/utility/pair/get]]
[[fr:cpp/utility/pair/get]]
[[it:cpp/utility/pair/get]]
[[ja:cpp/utility/pair/get]]
[[pt:cpp/utility/pair/get]]
[[ru:cpp/utility/pair/get]]
[[zh:cpp/utility/pair/get]]</text>
      <sha1>00zdh45nszcgr93eem28md1aiu0dvn9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/make pair</title>
    <ns>0</ns>
    <id>2360</id>
    <revision>
      <id>64501</id>
      <parentid>61891</parentid>
      <timestamp>2013-08-18T14:53:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C++14 constexpr</comment>
      <text xml:space="preserve" bytes="2040">{{cpp/title|make_pair}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class T1, class T2 &gt;
std::pair&lt;T1,T2&gt; make_pair( T1 t, T2 u );
}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T1, class T2 &gt;
std::pair&lt;V1,V2&gt; make_pair( T1&amp;&amp; t, T2&amp;&amp; u );
}}
{{dcl | since=c++14 |
template&lt; class T1, class T2 &gt;
constexpr std::pair&lt;V1,V2&gt; make_pair( T1&amp;&amp; t, T2&amp;&amp; u );
}}
{{dcl rev end}}
{{dcl end}}

Creates a {{lc|std::pair}} object, deducing the target type from the types of arguments.

{{rev begin}}
{{rev | since=c++11 |
The deduced types {{tt|V1}} and {{tt|V2}} are {{c|std::decay&lt;T1&gt;::type}} and {{c|std::decay&lt;T2&gt;::type}} (the usual type transformations applied to arguments of functions passed by value) unless application of {{lc|std::decay}} results in {{c|std::reference_wrapper&lt;X&gt;}} for some type {{tt|X}}, in which case the deduced type is {{tt|X&amp;}}.
}}
{{rev end}}

===Parameters===
{{par begin}}
{{par | t, u | the values to construct the pair from}}
{{par end}}

===Return value===
An {{lc|std::pair}} object containing the given values.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;functional&gt;

int main()
{
    int n = 1;
    int a[5] = {1, 2, 3, 4, 5};

    // build a pair from two ints
    auto p1 = std::make_pair(n, a[1]);
    std::cout &lt;&lt; &quot;The value of p1 is &quot;
              &lt;&lt; &quot;(&quot; &lt;&lt; p1.first &lt;&lt; &quot;, &quot; &lt;&lt; p1.second &lt;&lt; &quot;)\n&quot;;

    // build a pair from a reference to int and an array (decayed to pointer)
    auto p2 = std::make_pair(std::ref(n), a);
    n = 7;
    std::cout &lt;&lt; &quot;The value of p2 is &quot;
              &lt;&lt; &quot;(&quot; &lt;&lt; p2.first &lt;&lt; &quot;, &quot; &lt;&lt; *(p2.second + 1) &lt;&lt; &quot;)\n&quot;;
}
 | output=
The value of p1 is (1, 2)
The value of p2 is (7, 2)
}}

[[de:cpp/utility/pair/make pair]]
[[es:cpp/utility/pair/make pair]]
[[fr:cpp/utility/pair/make pair]]
[[it:cpp/utility/pair/make pair]]
[[ja:cpp/utility/pair/make pair]]
[[pt:cpp/utility/pair/make pair]]
[[ru:cpp/utility/pair/make pair]]
[[zh:cpp/utility/pair/make pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/operator=</title>
    <ns>0</ns>
    <id>2596</id>
    <revision>
      <id>72101</id>
      <parentid>64816</parentid>
      <timestamp>2014-07-15T11:53:52Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>/* Exceptions */ The move assignment operator is new in C++11, -revbox</comment>
      <text xml:space="preserve" bytes="1527">{{cpp/utility/pair/title | operator{{=}}}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
pair&amp; operator=( const pair&amp; other );
}}
{{dcl | num=2 | 1=
template&lt; class U1, class U2 &gt;
pair&amp; operator=( const pair&lt;U1,U2&gt;&amp; other );
}}
{{dcl | num=3 | since=c++11 | 1=
pair&amp; operator=( pair&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class U1, class U2 &gt;
pair&amp; operator=( pair&lt;U1,U2&gt;&amp;&amp; other );
}}
{{dcl end}}

Replaces the contents of the pair.

@1@ Copy assignment operator. Replaces the contents with a copy of the contents of other.
 
@2@ Assigns {{tt|other.first}} to {{tt|first}} and {{tt|other.second}} to {{tt|second}}

@3@ Move assignment operator. Replaces the contents with those of {{tt|other}} using move semantics. 

@4@ Assigns {{c|std::forward&lt;U1&gt;(p.first)}} to {{tt|first}} and {{c|std::forward&lt;U2&gt;(p.second)}} to {{tt|second}}. 

===Parameters===
{{par begin}}
{{par | other | pair of values to replace the contents of this pair }}
{{par end}} 

===Return value===
{{c|*this}}

===Exceptions===
@1-2@ (none)

@3@{{noexcept|
    is_nothrow_move_assignable&lt;T1&gt;::value &amp;&amp;
    is_nothrow_move_assignable&lt;T2&gt;::value
}}

@4@ (none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc end}}

[[de:cpp/utility/pair/operator=]]
[[es:cpp/utility/pair/operator=]]
[[fr:cpp/utility/pair/operator=]]
[[it:cpp/utility/pair/operator=]]
[[ja:cpp/utility/pair/operator=]]
[[pt:cpp/utility/pair/operator=]]
[[ru:cpp/utility/pair/operator=]]
[[zh:cpp/utility/pair/operator=]]</text>
      <sha1>mgz1b91wznf0xgkuelhbv1x2qobtmrv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/operator cmp</title>
    <ns>0</ns>
    <id>2599</id>
    <revision>
      <id>69172</id>
      <parentid>64500</parentid>
      <timestamp>2014-03-28T18:29:04Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="3826">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::pair&lt;/small&gt;)}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl rev begin}}
{{dcl | num=1 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator==( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=1 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator==( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator!=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator!=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator&lt;( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=3 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator&lt;( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=4 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator&lt;=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator&lt;=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=5 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator&gt;( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=5 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator&gt;( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=6 | until=c++14 | 1=
template&lt; class T1, class T2 &gt;
bool operator&gt;=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl | num=6 | since=c++14 | 1=
template&lt; class T1, class T2 &gt;
constexpr bool operator&gt;=( const pair&lt;T1,T2&gt;&amp; lhs, const pair&lt;T1,T2&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl end}}

@1-2@ Tests if both elements of lhs and rhs are equal, that is, compares {{tt|lhs.first}} with {{tt|rhs.first}} and {{tt|lhs.second}} with {{tt|rhs.second}}
@3-6@ Compares {{tt|lhs}} and {{tt|rhs}} lexicographically, that is, compares the first elements and only if they are equivalent, compares the second elements.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pairs to compare }}
{{par end}} 

===Return value===

1) {{c|true}} if both {{tt|1=lhs.first == rhs.first}} and {{tt|1=lhs.second == rhs.second}}, otherwise {{c|false}}

2) {{c|true}} if either {{tt|1=lhs.first != rhs.first}} or {{tt|1=lhs.second != rhs.second}}, otherwise {{c|false}}

3) If {{tt|lhs.first&lt;rhs.first}}, returns {{c|true}}. Otherwise, if {{tt|rhs.first&lt;lhs.first}}, returns {{c|false}}. Otherwise, if {{tt|lhs.second&lt;rhs.second}}, returns {{c|true}}. Otherwise, returns {{c|false}}.

4) {{tt|!(rhs &lt; lhs)}}

5) {{tt|rhs &lt; lhs}}

6) {{tt|!(lhs &lt; rhs)}}

===Example===
{{example
 | Because operator&lt; is defined for pairs, containers of pairs can be sorted.
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
#include &lt;string&gt;

int main()
{
    std::vector&lt;std::pair&lt;int, std::string&gt;&gt; v = { {2, &quot;baz&quot;},
                                                   {2, &quot;bar&quot;},
                                                   {1, &quot;foo&quot;} };
    std::sort(v.begin(), v.end());

    for(auto p: v) {
        std::cout &lt;&lt; &quot;(&quot; &lt;&lt; p.first &lt;&lt; &quot;,&quot; &lt;&lt; p.second &lt;&lt; &quot;)\n&quot;;
    }
}
 | output=
(1,foo)
(2,bar)
(2,baz)
}}

[[de:cpp/utility/pair/operator cmp]]
[[es:cpp/utility/pair/operator cmp]]
[[fr:cpp/utility/pair/operator cmp]]
[[it:cpp/utility/pair/operator cmp]]
[[ja:cpp/utility/pair/operator cmp]]
[[pt:cpp/utility/pair/operator cmp]]
[[ru:cpp/utility/pair/operator cmp]]
[[zh:cpp/utility/pair/operator cmp]]</text>
      <sha1>gqs8rlknp5p6fhnp9ht9v0l9khmdkd8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/operator comp</title>
    <ns>0</ns>
    <id>4217</id>
    <redirect title="cpp/utility/pair/operator cmp" />
    <revision>
      <id>15278</id>
      <timestamp>2011-12-08T01:22:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/pair/operator comp]] to [[cpp/utility/pair/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/utility/pair/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/pair</title>
    <ns>0</ns>
    <id>2594</id>
    <revision>
      <id>64504</id>
      <parentid>64503</parentid>
      <timestamp>2013-08-18T16:31:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C++14 constexpr, exceptions note</comment>
      <text xml:space="preserve" bytes="4404">{{cpp/utility/pair/title | pair}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
pair();
}}
{{dcl | since=c++11 |
constexpr pair();
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | until=c++14 | 1=
pair( const T1&amp; x, const T2&amp; y );
}}
{{dcl | num=2 | since=c++14 | 1=
constexpr pair( const T1&amp; x, const T2&amp; y );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | since=c++11 | until=c++14 | 1=
template&lt; class U1, class U2 &gt;
pair( U1&amp;&amp; x, U2&amp;&amp; y );
}}
{{dcl | num=3 | since=c++14 | 1=
template&lt; class U1, class U2 &gt;
constexpr pair( U1&amp;&amp; x, U2&amp;&amp; y );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=4 | until=c++14 | 1=
template&lt; class U1, class U2 &gt;
pair( const pair&lt;U1, U2&gt;&amp; p );
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class U1, class U2 &gt;
constexpr pair( const pair&lt;U1, U2&gt;&amp; p );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=5 | since=c++11 | until=c++14 | 1=
template&lt; class U1, class U2 &gt;
pair( pair&lt;U1, U2&gt;&amp;&amp; p );
}}
{{dcl | num=5 | since=c++14 | 1=
template&lt; class U1, class U2 &gt;
constexpr pair( pair&lt;U1, U2&gt;&amp;&amp; p );
}}
{{dcl rev end}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class... Args1, class... Args2 &gt;
pair( std::piecewise_construct_t,
      std::tuple&lt;Args1...&gt; first_args,
      std::tuple&lt;Args2...&gt; second_args );
}}
{{dcl | num=7 | 1= 
pair( const pair&amp; p ) = default;
}}
{{dcl | num=8 | since=c++11 | 1= 
pair( pair&amp;&amp; p ) = default;
}}
{{dcl end}}


Constructs a new pair.

1) Default constructor. Value-initializes both elements of the pair, {{tt|first}} and {{tt|second}}.

2) Initializes {{tt|first}} with {{tt|x}} and {{tt|second}} with {{tt|y}}.

3) Initializes {{tt|first}} with {{c|std::forward&lt;U1&gt;(x)}} and {{tt|second}} with {{c|std::forward&lt;U2&gt;(y)}}.

4) Initializes {{tt|first}} with {{tt|p.first}} and {{tt|second}} with {{tt|p.second}}. 

5) Initializes {{tt|first}} with {{c|std::move&lt;U1&gt;(p.first)}} and {{tt|second}} with {{c|std::move&lt;U2&gt;(p.second)}}.

6) Forwards the elements of {{tt|first_args}} to the constructor of {{tt|first}} and forwards the elements of {{tt|second_args}} to the constructor of {{tt|second}}. This is the only non-default constructor that can be used to create a pair of non-copyable non-movable types.

7) Copy constructor is defaulted, and is {{c|constexpr}} if copying of both elements satisfies the requirements on constexpr functions.

8) Move constructor is defaulted, and is {{c|constexpr}} if moving of both elements satisfies the requirements on constexpr functions.

===Parameters===

{{par begin}}
{{par | x | value to initialize the first element of this pair }}
{{par | y | value to initialize the second element of this pair }}
{{par | p | pair of values used to initialize both elements of this pair}}
{{par | first_args | tuple of constructor arguments to initialize the first element of this pair}}
{{par | second_args | tuple of constructor arguments to initialize the second element of this pair}}
{{par end}} 

===Exceptions===
Does not throw exceptions unless one of the specified operations (e.g. constructor of an element) throws.

===Example===
{{example
 | code=
#include &lt;utility&gt;
#include &lt;string&gt;
#include &lt;complex&gt;
#include &lt;tuple&gt;
#include &lt;iostream&gt;

int main()
{
    std::pair&lt;int, float&gt; p1;
    std::cout &lt;&lt; &quot;Value-initialized: &quot;
              &lt;&lt; p1.first &lt;&lt; &quot;, &quot; &lt;&lt; p1.second &lt;&lt; '\n';

    std::pair&lt;int, double&gt; p2(42, 0.123);
    std::cout &lt;&lt; &quot;Initialized with two values: &quot;
              &lt;&lt; p2.first &lt;&lt; &quot;, &quot; &lt;&lt; p2.second &lt;&lt; '\n';

    std::pair&lt;char, int&gt; p4(p2);
    std::cout &lt;&lt; &quot;Implicitly converted: &quot;
              &lt;&lt; p4.first &lt;&lt; &quot;, &quot; &lt;&lt; p4.second &lt;&lt; '\n';

    std::pair&lt;std::complex&lt;double&gt;, std::string&gt; p6(
                    std::piecewise_construct, 
                    std::forward_as_tuple(0.123, 7.7),
                    std::forward_as_tuple(10, 'a'));
    std::cout &lt;&lt; &quot;Piecewise constructed: &quot;
              &lt;&lt; p6.first &lt;&lt; &quot;, &quot; &lt;&lt; p6.second &lt;&lt; '\n';
}
 | output=
Value-initialized: 0, 0
Initialized with two values: 42, 0.123
Implicitly converted: *, 0
Piecewise constructed: (0.123,7.7), aaaaaaaaaa
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/pair/dsc make_pair}}
{{dsc end}}

[[de:cpp/utility/pair/pair]]
[[es:cpp/utility/pair/pair]]
[[fr:cpp/utility/pair/pair]]
[[it:cpp/utility/pair/pair]]
[[ja:cpp/utility/pair/pair]]
[[pt:cpp/utility/pair/pair]]
[[ru:cpp/utility/pair/pair]]
[[zh:cpp/utility/pair/pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/std swap</title>
    <ns>0</ns>
    <id>3455</id>
    <redirect title="cpp/utility/pair/swap2" />
    <revision>
      <id>12996</id>
      <timestamp>2011-11-03T18:33:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/pair/std swap]] to [[cpp/utility/pair/swap2]]: std_ prefix was not consistent, since there are a lot of different overloads in the std:: namespace, but we use std_ only for std::swap.</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/utility/pair/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/swap</title>
    <ns>0</ns>
    <id>2598</id>
    <revision>
      <id>72094</id>
      <parentid>72085</parentid>
      <timestamp>2014-07-14T12:18:21Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>This member is also new in C++11</comment>
      <text xml:space="preserve" bytes="1068">{{cpp/utility/pair/title | swap}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void swap(pair&amp; other);
}}
{{dcl end}}

Swaps {{tt|first}} with {{tt|other.first}} and {{tt|second}} with {{tt|other.second}}.

===Parameters===
{{par begin}}
{{par | other | pair of values to swap }}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept|
     noexcept(std::swap(first, other.first)) &amp;&amp;
     noexcept(std::swap(second, other.second))
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;string&gt;
int main()
{
    std::pair&lt;int, std::string&gt; p1, p2;
    p1 = std::make_pair(10, &quot;test&quot;);
    p2.swap(p1);
    std::cout &lt;&lt; &quot;(&quot; &lt;&lt; p2.first &lt;&lt; &quot;, &quot; &lt;&lt; p2.second &lt;&lt; &quot;)\n&quot;;
}
 | output=
(10, test)
}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/algorithm/dsc swap}}
{{dsc end}}

[[de:cpp/utility/pair/swap]]
[[es:cpp/utility/pair/swap]]
[[fr:cpp/utility/pair/swap]]
[[it:cpp/utility/pair/swap]]
[[ja:cpp/utility/pair/swap]]
[[pt:cpp/utility/pair/swap]]
[[ru:cpp/utility/pair/swap]]
[[zh:cpp/utility/pair/swap]]</text>
      <sha1>d6k0s4navsidv2u7ffmcnlcyvg8yqcr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/swap2</title>
    <ns>0</ns>
    <id>2600</id>
    <revision>
      <id>72093</id>
      <parentid>72083</parentid>
      <timestamp>2014-07-14T12:16:27Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Um, I'm quite sure it is new in C++11</comment>
      <text xml:space="preserve" bytes="777">{{cpp/title | swap&lt;small&gt;(std::pair)&lt;/small&gt;}}
{{cpp/utility/pair/navbar}}
{{ddcl | header=utility | since=c++11 |
template&lt; class T1, class T2 &gt;
void swap( pair&lt;T1,T2&gt;&amp; lhs, pair&lt;T1,T2&gt;&amp; rhs );
}}

Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Equivalent to {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | pairs whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept|noexcept(lhs.swap(rhs))}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/algorithm/dsc swap}}
{{dsc end}}

[[de:cpp/utility/pair/swap2]]
[[es:cpp/utility/pair/swap2]]
[[fr:cpp/utility/pair/swap2]]
[[it:cpp/utility/pair/swap2]]
[[ja:cpp/utility/pair/swap2]]
[[pt:cpp/utility/pair/swap2]]
[[ru:cpp/utility/pair/swap2]]
[[zh:cpp/utility/pair/swap2]]</text>
      <sha1>apx8rsftfjlq8740k44f2vivm7f29q3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/tuple element</title>
    <ns>0</ns>
    <id>2622</id>
    <revision>
      <id>63113</id>
      <parentid>61774</parentid>
      <timestamp>2013-07-01T23:55:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2062">{{cpp/title|tuple_element&lt;small&gt;&lt;std::pair&gt;&lt;/small&gt;}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl header | utility}}
{{dcl | since=c++11 | num = 1 |
template&lt; class T1, class T2 &gt;
struct tuple_element&lt;0, std::pair&lt;T1,T2&gt; &gt;;
}}
{{dcl | since=c++11 | num = 2 |
template&lt; class T1, class T2 &gt;
struct tuple_element&lt;1, std::pair&lt;T1,T2&gt; &gt;;
}}
{{dcl end}}

The partial specializations of {{c|std::tuple_element}} for pairs provide compile-time access to the types of the pair's elements, using tuple-like syntax.

===Member types===
{{dsc begin}}
{{dsc h2 | First version}}
{{dsc hitem | Member type | Definition}}
{{dsc | &lt;code&gt;type&lt;/code&gt; | &lt;code&gt;T1&lt;/code&gt;}}
{{dsc h2 | Second version}}
{{dsc hitem | Member type | Definition}}
{{dsc | &lt;code&gt;type&lt;/code&gt; | &lt;code&gt;T2&lt;/code&gt;}}
{{dsc end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt;std::size_t I, typename T&gt;
  struct tuple_element;

template&lt;typename T1, typename T2&gt;
  struct tuple_element&lt;0, std::pair&lt;T1,T2&gt; &gt;
  {
     using type = T1;
  };

template&lt;typename T1, typename T2&gt;
  struct tuple_element&lt;1, std::pair&lt;T1,T2&gt; &gt;
  {
     using type = T2;
  };

}}

===Example===
{{example |
 | code=
#include &lt;tuple&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;

template &lt;int N, typename T, typename U&gt;
static auto constexpr get(std::pair&lt;T, U&gt; const&amp; pair)
    -&gt; typename std::tuple_element&lt;N, decltype(pair)&gt;::type
{
    return N == 0 ? pair.first : pair.second;
}

int main()
{
    auto var = std::make_pair(1, std::string{&quot;one&quot;});
    
    std::cout &lt;&lt; get&lt;0&gt;(var) &lt;&lt; &quot; = &quot; &lt;&lt; get&lt;1&gt;(var);
}
 | output= 1 = one
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tuple_element}}
{{dsc inc | cpp/container/array/dsc tuple_element}}
{{dsc inc | cpp/utility/pair/dsc tuple_size}}
{{dsc end}}

[[de:cpp/utility/pair/tuple element]]
[[es:cpp/utility/pair/tuple element]]
[[fr:cpp/utility/pair/tuple element]]
[[it:cpp/utility/pair/tuple element]]
[[ja:cpp/utility/pair/tuple element]]
[[pt:cpp/utility/pair/tuple element]]
[[ru:cpp/utility/pair/tuple element]]
[[zh:cpp/utility/pair/tuple element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/pair/tuple size</title>
    <ns>0</ns>
    <id>2621</id>
    <revision>
      <id>68201</id>
      <parentid>68200</parentid>
      <timestamp>2014-03-18T03:13:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+inherit template to reflect (almost) current standing</comment>
      <text xml:space="preserve" bytes="1512">{{cpp/title|tuple_size&lt;small&gt;&lt;std::pair&gt;&lt;/small&gt;}}
{{cpp/utility/pair/navbar}}
{{dcl begin}}
{{dcl header|utility}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class T1, class T2 &gt;
struct tuple_size&lt;std::pair&lt;T1, T2&gt;&gt;; 
}}
{{dcl | since=c++14 |
template &lt;class T1, class T2&gt;
struct tuple_size&lt;std::pair&lt;T1, T2&gt;&gt;
  : std::integral_constant&lt;std::size_t, 2&gt; { };
}}
{{dcl rev end}}
{{dcl end}}


The partial specialization of {{c|std::tuple_size}} for pairs provides a compile-time way to obtain the number of elements in a pair, which is always 2, using tuple-like syntax.

{{cpp/types/integral_constant/inherit2 |the constant value 2 |std::size_t}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;tuple&gt;

template&lt;class T&gt;
void test(T t)
{
    int a[std::tuple_size&lt;T&gt;::value]; // can be used at compile time
    std::cout &lt;&lt; std::tuple_size&lt;T&gt;::value &lt;&lt; '\n'; // or at run time
}

int main()
{
    test(std::make_tuple(1, 2, 3.14));
    test(std::make_pair(1, 3.14));
}
 | output=
3
2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tuple_size}}
{{dsc inc | cpp/container/array/dsc tuple_size}}
{{dsc inc | cpp/utility/pair/dsc tuple_element}}
{{dsc end}}

[[de:cpp/utility/pair/tuple size]]
[[es:cpp/utility/pair/tuple size]]
[[fr:cpp/utility/pair/tuple size]]
[[it:cpp/utility/pair/tuple size]]
[[ja:cpp/utility/pair/tuple size]]
[[pt:cpp/utility/pair/tuple size]]
[[ru:cpp/utility/pair/tuple size]]
[[zh:cpp/utility/pair/tuple size]]</text>
      <sha1>ausft101d1ii1z9tisj3bn3b6vv3j2q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/piecewise construct</title>
    <ns>0</ns>
    <id>2623</id>
    <revision>
      <id>63515</id>
      <parentid>59654</parentid>
      <timestamp>2013-07-10T01:34:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="836">{{cpp/title|piecewise_construct}}
{{cpp/utility/pair/navbar}}
{{ddcl | since=c++11 | 1=
constexpr piecewise_construct_t piecewise_construct = std::piecewise_construct_t();
}}

The constant {{lc|std::piecewise_construct}} is an instance of an empty struct tag type {{lc|std::piecewise_construct_t}}.

===Example===
{{include| cpp/utility/example_piecewise_construct}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc piecewise_construct_t}}
{{dsc mem ctor | cpp/utility/pair/pair | constructs new pair}}
{{dsc end}}

[[de:cpp/utility/piecewise construct]]
[[es:cpp/utility/piecewise construct]]
[[fr:cpp/utility/piecewise construct]]
[[it:cpp/utility/piecewise construct]]
[[ja:cpp/utility/piecewise construct]]
[[pt:cpp/utility/piecewise construct]]
[[ru:cpp/utility/piecewise construct]]
[[zh:cpp/utility/piecewise construct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/piecewise construct t</title>
    <ns>0</ns>
    <id>2654</id>
    <revision>
      <id>63516</id>
      <parentid>59657</parentid>
      <timestamp>2013-07-10T01:34:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1160">{{cpp/title|piecewise_construct_t}}
{{cpp/utility/pair/navbar}}
{{ddcl | header=utility | since=c++11 |
struct piecewise_construct_t { };
}}

{{lc|std::piecewise_construct_t}} is an empty struct tag type used to disambiguate between different functions that take two tuple arguments.

The overloads that do not use {{lc|std::piecewise_construct_t}} assume that each tuple argument becomes the element of a pair. The overloads that use {{lc|std::piecewise_construct_t}} assume that each tuple argument is used to construct, piecewise, a new object of specified type, which will become the element of the pair.

===Example===
{{include| cpp/utility/example_piecewise_construct}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/dsc piecewise_construct}}
{{dsc mem ctor | cpp/utility/pair/pair | constructs new pair}}
{{dsc end}}

[[de:cpp/utility/piecewise construct t]]
[[es:cpp/utility/piecewise construct t]]
[[fr:cpp/utility/piecewise construct t]]
[[it:cpp/utility/piecewise construct t]]
[[ja:cpp/utility/piecewise construct t]]
[[pt:cpp/utility/piecewise construct t]]
[[ru:cpp/utility/piecewise construct t]]
[[zh:cpp/utility/piecewise construct t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program</title>
    <ns>0</ns>
    <id>1784</id>
    <revision>
      <id>71000</id>
      <parentid>70984</parentid>
      <timestamp>2014-06-04T18:42:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>name the new see-also</comment>
      <text xml:space="preserve" bytes="1801">{{title|Program support utilities}}
{{cpp/utility/program/navbar}}
===Program termination===

The following functions manage program termination and resource cleanup.

{{dsc begin}}
{{dsc header | cstdlib}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc inc | cpp/utility/program/dsc exit}}
{{dsc inc | cpp/utility/program/dsc quick_exit}}
{{dsc inc | cpp/utility/program/dsc _Exit}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc inc | cpp/utility/program/dsc at_quick_exit}}
{{dsc inc | cpp/utility/program/dsc EXIT_status}}
{{dsc end}}

===Communicating with the environment===

{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc system}}
{{dsc inc | cpp/utility/program/dsc getenv}}
{{dsc end}}

===Signals===

Several functions and macro constants for signal management are provided.

{{dsc begin}}
{{dsc header | csignal}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc inc | cpp/utility/program/dsc raise}}
{{dsc typedef | cpp/utility/program/sig_atomic_t | the integer type that can be accessed as an atomic entity from an asynchronous signal handler}}
{{dsc inc | cpp/utility/program/dsc SIG_strategies}}
{{dsc inc | cpp/utility/program/dsc SIG_ERR}}

{{dsc h2 | Signal types}}
{{dsc inc | cpp/utility/program/dsc SIG_types}}
{{dsc end}}

===Non-local jumps===

{{dsc begin}}
{{dsc header | csetjmp}}
{{dsc inc | cpp/utility/program/dsc setjmp}}
{{dsc inc | cpp/utility/program/dsc longjmp}}

{{dsc h2 | Types}}
{{dsc inc | cpp/utility/program/dsc jmp_buf}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/program | Program support utilities}}
{{dsc end}}

[[de:cpp/utility/program]]
[[es:cpp/utility/program]]
[[fr:cpp/utility/program]]
[[it:cpp/utility/program]]
[[ja:cpp/utility/program]]
[[pt:cpp/utility/program]]
[[ru:cpp/utility/program]]
[[zh:cpp/utility/program]]</text>
      <sha1>n3z0fdfavmsxv8tibw70w45skig2ewp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/EXIT FAILURE</title>
    <ns>0</ns>
    <id>1969</id>
    <redirect title="cpp/utility/program/EXIT status" />
    <revision>
      <id>16055</id>
      <parentid>8202</parentid>
      <timestamp>2011-12-19T14:25:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge similar constants</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/utility/program/EXIT_status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/EXIT SUCCESS</title>
    <ns>0</ns>
    <id>1968</id>
    <redirect title="cpp/utility/program/EXIT status" />
    <revision>
      <id>16056</id>
      <parentid>8203</parentid>
      <timestamp>2011-12-19T14:25:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge similar constants</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/utility/program/EXIT_status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/EXIT status</title>
    <ns>0</ns>
    <id>4549</id>
    <revision>
      <id>69742</id>
      <parentid>51723</parentid>
      <timestamp>2014-04-22T01:23:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>more desc</comment>
      <text xml:space="preserve" bytes="1147">{{title|EXIT_SUCCESS, EXIT_FAILURE}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl |
#define EXIT_SUCCESS /*implementation defined*/
}}
{{dcl |
#define EXIT_FAILURE /*implementation defined*/
}}
{{dcl end}}

The {{tt|EXIT_SUCCESS}} and {{tt|EXIT_FAILURE}} macros expand into integral expressions that can be used as arguments to the {{lc|std::exit}} function (and, therefore, as the values to return from the [[cpp/language/main_function|main function]]), and indicate program execution status.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|EXIT_SUCCESS}} | successful execution of a program}}
{{dsc | {{tt|EXIT_FAILURE}} | unsuccessful execution of a program}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/program/EXIT_status | EXIT_SUCCESS | EXIT_FAILURE}}
{{dsc end}}

[[de:cpp/utility/program/EXIT status]]
[[es:cpp/utility/program/EXIT status]]
[[fr:cpp/utility/program/EXIT status]]
[[it:cpp/utility/program/EXIT status]]
[[ja:cpp/utility/program/EXIT status]]
[[pt:cpp/utility/program/EXIT status]]
[[ru:cpp/utility/program/EXIT status]]
[[zh:cpp/utility/program/EXIT status]]</text>
      <sha1>edg485jisqwu40yuc8gcz6sp6q4mus2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGABRT</title>
    <ns>0</ns>
    <id>1976</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22417</id>
      <parentid>8204</parentid>
      <timestamp>2012-04-19T19:59:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge signal pages</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/utility/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGFPE</title>
    <ns>0</ns>
    <id>1977</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22416</id>
      <parentid>7671</parentid>
      <timestamp>2012-04-19T19:59:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge signal pages</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/utility/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGILL</title>
    <ns>0</ns>
    <id>1978</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22415</id>
      <parentid>8205</parentid>
      <timestamp>2012-04-19T19:59:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge signal pages</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/utility/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGINT</title>
    <ns>0</ns>
    <id>1979</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22414</id>
      <parentid>8206</parentid>
      <timestamp>2012-04-19T19:59:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge signal pages</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/utility/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGSEGV</title>
    <ns>0</ns>
    <id>1981</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22412</id>
      <parentid>7069</parentid>
      <timestamp>2012-04-19T19:56:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge signal pages</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/utility/program/SIG_types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIGTERM</title>
    <ns>0</ns>
    <id>6333</id>
    <redirect title="cpp/utility/program/SIG types" />
    <revision>
      <id>22411</id>
      <timestamp>2012-04-19T19:55:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/program/SIGTERM]] to [[cpp/utility/program/SIG types]]: merge signals</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[cpp/utility/program/SIG types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIG DFL</title>
    <ns>0</ns>
    <id>4546</id>
    <redirect title="cpp/utility/program/SIG strategies" />
    <revision>
      <id>16049</id>
      <timestamp>2011-12-19T14:17:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/utility/program/SIG_strategies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIG ERR</title>
    <ns>0</ns>
    <id>8690</id>
    <revision>
      <id>59661</id>
      <parentid>51724</parentid>
      <timestamp>2013-06-01T06:39:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="638">{{title|SIG_ERR}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csignal |
#define SIG_ERR /* implementation defined */
}}

A value of type {{tt|void (*)(int)}}. When returned by {{lc|std::signal}}, indicates that an error has occurred.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc see c | c/program/SIG_ERR}}
{{dsc end}}

[[de:cpp/utility/program/SIG ERR]]
[[es:cpp/utility/program/SIG ERR]]
[[fr:cpp/utility/program/SIG ERR]]
[[it:cpp/utility/program/SIG ERR]]
[[ja:cpp/utility/program/SIG ERR]]
[[pt:cpp/utility/program/SIG ERR]]
[[ru:cpp/utility/program/SIG ERR]]
[[zh:cpp/utility/program/SIG ERR]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIG IGN</title>
    <ns>0</ns>
    <id>4547</id>
    <redirect title="cpp/utility/program/SIG strategies" />
    <revision>
      <id>16050</id>
      <timestamp>2011-12-19T14:17:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/utility/program/SIG_strategies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIG strategies</title>
    <ns>0</ns>
    <id>4545</id>
    <revision>
      <id>65692</id>
      <parentid>51725</parentid>
      <timestamp>2013-09-27T04:20:09Z</timestamp>
      <contributor>
        <username>Gcweb</username>
        <id>2481</id>
      </contributor>
      <minor/>
      <comment>Fix the typo &quot;SIF_IGN&quot; -&gt; &quot;SIG_IGN&quot;</comment>
      <text xml:space="preserve" bytes="1026">{{title|SIG_DFL, SIG_IGN}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | csignal}}
{{dcl |
#define SIG_DFL /*implementation defined*/
}}
{{dcl |
#define SIG_IGN /*implementation defined*/
}}
{{dcl end}}

The {{lc|SIG_DFL}} and {{lc|SIG_IGN}} macros expand into integral expressions that are not equal to an address of any function. The macros define signal handling strategies for {{c|std::signal()}} function.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|SIG_DFL}} | default signal handling}}
{{dsc | {{tt|SIG_IGN}} | signal is ignored}}
{{dsc end}}

===See also===
{{dsc begin}}
{{dsc see c | c/program/SIG_strategies | SIG_DFL | SIG_IGN}}
{{dsc end}}

[[de:cpp/utility/program/SIG strategies]]
[[es:cpp/utility/program/SIG strategies]]
[[fr:cpp/utility/program/SIG strategies]]
[[it:cpp/utility/program/SIG strategies]]
[[ja:cpp/utility/program/SIG strategies]]
[[pt:cpp/utility/program/SIG strategies]]
[[ru:cpp/utility/program/SIG strategies]]
[[zh:cpp/utility/program/SIG strategies]]</text>
      <sha1>lcbtzwc71f48rccgrib4q4ux4c8y4q8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/SIG types</title>
    <ns>0</ns>
    <id>1980</id>
    <revision>
      <id>64229</id>
      <parentid>64210</parentid>
      <timestamp>2013-08-15T15:53:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+std::</comment>
      <text xml:space="preserve" bytes="1780">{{title|SIGTERM, SIGSEGV, SIGINT, SIGILL, SIGABRT, SIGFPE}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | csignal}}
{{dcl |
#define SIGTERM /*implementation defined*/
}}
{{dcl |
#define SIGSEGV /*implementation defined*/
}}
{{dcl |
#define SIGINT /*implementation defined*/
}}
{{dcl |
#define SIGILL /*implementation defined*/
}}
{{dcl |
#define SIGABRT /*implementation defined*/
}}
{{dcl |
#define SIGFPE /*implementation defined*/
}}
{{dcl end}}

Each of the above macro constants to an integer constant expression with distinct values, which represent different signals sent to the program.

{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{tt|SIGTERM}}  | termination request, sent to the program}}
{{dsc | {{tt|SIGSEGV}}  | invalid memory access (segmentation fault)}}
{{dsc | {{tt|SIGINT}}  | external interrupt, usually initiated by the user}}
{{dsc | {{tt|SIGILL}}  | invalid program image, such as invalid instruction}}
{{dsc | {{tt|SIGABRT}}  | abnormal termination condition, as is e.g. initiated by {{lc|std::abort()}}}}
{{dsc | {{tt|SIGFPE}}  | erroneous arithmetic operation such as divide by zero}}
{{dsc end}}

===Notes===
Additional signal names [http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html are specified by POSIX]

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc inc | cpp/utility/program/dsc raise}}
{{dsc see c | c/program/SIG_types | signal types | nomono=true}}
{{dsc end}}

[[de:cpp/utility/program/SIG types]]
[[es:cpp/utility/program/SIG types]]
[[fr:cpp/utility/program/SIG types]]
[[it:cpp/utility/program/SIG types]]
[[ja:cpp/utility/program/SIG types]]
[[pt:cpp/utility/program/SIG types]]
[[ru:cpp/utility/program/SIG types]]
[[zh:cpp/utility/program/SIG types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/ Exit</title>
    <ns>0</ns>
    <id>1967</id>
    <revision>
      <id>71936</id>
      <parentid>65383</parentid>
      <timestamp>2014-07-02T12:28:26Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>-noexcept rev (this function itself is since c++11)</comment>
      <text xml:space="preserve" bytes="2097">{{cpp/title| _Exit}}
{{cpp/utility/program/navbar}}
{{ddcl | header=cstdlib | since=c++11 |
[[noreturn]] void _Exit( int exit_code );
}}

Causes normal program termination to occur without completely cleaning the resources.

Destructors of variables with automatic, thread local and static storage durations are not called. Functions passed to {{lc|std::at_quick_exit()}} or {{lc|std::atexit()}} are not called. Whether open resources such as files are closed is implementation defined. If {{tt|exit_code}} is {{lc|EXIT_FAILURE}}, an implementation-defined status, indicating ''unsuccessful'' termination, is returned. In other cases implementation-defined status value is returned. 

===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;

class Static {
public:
    ~Static() 
    {
        std::cout &lt;&lt; &quot;Static dtor\n&quot;;
    }
};

class Local {
public:
    ~Local() 
    {
        std::cout &lt;&lt; &quot;Local dtor\n&quot;;
    }
};

Static static_variable; // dtor of this object will *not* be called

void atexit_handler()
{
    std::cout &lt;&lt; &quot;atexit handler\n&quot;;
}

int main()
{
    Local local_variable; // dtor of this object will *not* be called
    
    // handler will *not* be called
    const int result = std::atexit(atexit_handler);

    if (result != 0) {
        std::cerr &lt;&lt; &quot;atexit registration failed\n&quot;;
        return EXIT_FAILURE;
    }

    std::cout &lt;&lt; &quot;test&quot; &lt;&lt; std::endl; // flush from std::endl
        // needs to be here, otherwise nothing will be printed
    std::_Exit(EXIT_FAILURE);
}
 | output=
test
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc inc | cpp/utility/program/dsc exit}}
{{dsc see c | c/program/_Exit}}
{{dsc end}}

[[de:cpp/utility/program/ Exit]]
[[es:cpp/utility/program/ Exit]]
[[fr:cpp/utility/program/ Exit]]
[[it:cpp/utility/program/ Exit]]
[[ja:cpp/utility/program/ Exit]]
[[pt:cpp/utility/program/ Exit]]
[[ru:cpp/utility/program/ Exit]]
[[zh:cpp/utility/program/ Exit]]</text>
      <sha1>1u4rag3e4nb6y4619g1al3q6ybza2sb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/abort</title>
    <ns>0</ns>
    <id>1964</id>
    <revision>
      <id>71573</id>
      <parentid>67181</parentid>
      <timestamp>2014-06-13T16:43:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>actually call abort()</comment>
      <text xml:space="preserve" bytes="2372">{{cpp/title| abort}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl rev begin}}
{{dcl | until=c++11 |
             void abort();
}}
{{dcl | since=c++11 |
[[noreturn]] void abort();
}}
{{dcl rev end}}
{{dcl end}}

Causes abnormal program termination unless {{lc|SIGABRT}} is being caught by a signal handler passed to signal and the handler does not return.

Destructors of variables with automatic, thread local and static [[cpp/language/storage duration | storage durations]] are not called. Functions passed to {{lc|std::atexit()}} are also not called. Whether open resources such as files are closed is implementation defined. Implementation defined status is returned to the host environment that indicates unsuccessful execution. 

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;csignal&gt;
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

class Tester {
 public:
  Tester() {
    std::cout &lt;&lt; &quot;Tester ctor\n&quot;;
  }

  ~Tester() {
    std::cout &lt;&lt; &quot;Tester dtor\n&quot;;
  }
};

Tester static_tester; // Destructor not called

void signal_handler(int signal) {
  if (signal == SIGABRT) {
    std::cerr &lt;&lt; &quot;SIGABRT received\n&quot;;
  }
  else {
    std::cerr &lt;&lt; &quot;Unexpected signal &quot; &lt;&lt; signal &lt;&lt; &quot; received\n&quot;;
  }
  std::_Exit(EXIT_FAILURE);
}

int main()
{
  Tester automatic_tester; // Destructor not called

  // Setup handler
  auto previous_handler = std::signal(SIGABRT, signal_handler);
  if (previous_handler == SIG_ERR) {
    std::cerr &lt;&lt; &quot;Setup failed\n&quot;;
    return EXIT_FAILURE;
  }

  std::abort();  // Raise SIGABRT
  std::cout &lt;&lt; &quot;This code is unreachable\n&quot;;
}
 | output=
Tester ctor
Tester ctor
SIGABRT received
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc exit}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc inc | cpp/utility/program/dsc quick_exit}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc see c | c/program/abort}}
{{dsc end}}

[[de:cpp/utility/program/abort]]
[[es:cpp/utility/program/abort]]
[[fr:cpp/utility/program/abort]]
[[it:cpp/utility/program/abort]]
[[ja:cpp/utility/program/abort]]
[[pt:cpp/utility/program/abort]]
[[ru:cpp/utility/program/abort]]
[[tr:cpp/utility/program/abort]]
[[zh:cpp/utility/program/abort]]</text>
      <sha1>k3z8qsuu3qizl6837102b5d4uoajnrb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/at quick exit</title>
    <ns>0</ns>
    <id>1971</id>
    <revision>
      <id>71934</id>
      <parentid>64806</parentid>
      <timestamp>2014-07-02T12:08:17Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>correction, mention the registered functions won't be called on std::exit()</comment>
      <text xml:space="preserve" bytes="1390">{{cpp/title| at_quick_exit}}
{{cpp/utility/program/navbar}}
{{ddcl | header=cstdlib |since=c++11|
extern &quot;C&quot;   int at_quick_exit( void (*func)() );
extern &quot;C++&quot; int at_quick_exit( void (*func)() );
}}

Registers the function pointed to by {{tt|func}} to be called on quick program termination (via {{lc|std::quick_exit}}).

Calling the function from several threads does not induce a data race. The implementation shall support the registration of at least {{c|32}} functions.

The registered functions will not be called on {{rlp|exit|normal program termination}}. If a function need to be called in that case, {{lc|std::atexit}} must be used.

===Parameters===
{{par begin}}
{{par | func | pointer to a function to be called on quick program termination}}
{{par end}}

===Return value===
{{c|0}} if the registration succeeds, nonzero value otherwise.

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc see c | c/program/at_quick_exit}}
{{dsc end}}

[[de:cpp/utility/program/at quick exit]]
[[es:cpp/utility/program/at quick exit]]
[[fr:cpp/utility/program/at quick exit]]
[[it:cpp/utility/program/at quick exit]]
[[ja:cpp/utility/program/at quick exit]]
[[pt:cpp/utility/program/at quick exit]]
[[ru:cpp/utility/program/at quick exit]]
[[zh:cpp/utility/program/at quick exit]]</text>
      <sha1>1zv317hyzqu9zcsp5sb70hz3djvm61x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/atexit</title>
    <ns>0</ns>
    <id>1970</id>
    <revision>
      <id>65754</id>
      <parentid>65703</parentid>
      <timestamp>2013-10-06T15:11:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++11</comment>
      <text xml:space="preserve" bytes="2835">{{cpp/title| atexit}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl rev begin}}
{{dcl |
extern &quot;C&quot;   int atexit( void (*func)() );
}}
{{dcl |
extern &quot;C++&quot; int atexit( void (*func)() );
}}
{{dcl rev end}}
{{dcl end}}

Registers the function pointed to by {{tt|func}} to be called on normal program termination (via {{lc|std::exit()}} or returning from the [[cpp/language/main function]])
{{rev begin}}
{{rev |until=c++11|The functions will be called during the destruction of the static objects, in reverse order: if A was registered before B, then the call to B is made before the call to A. Same applies to the ordering between static object constructors and the calls to {{tt|atexit}}: see {{lc|std::exit}} }}
{{rev |since=c++11|The functions may be called concurrently with the destruction of the objects with static storage duration and with each other, maintaining the guarantee that if registration of A was sequenced-before the registration of B, then the call to B is sequenced-before the call to A, same applies to the sequencing between static object constructors and calls to {{tt|atexit}}: see {{lc|std::exit}} }}
{{rev end}}

The same function may be registered more than once.

If a function exits via an exception, {{c|std::terminate}} is called.

{{tt|atexit}} is thread-safe: calling the function from several threads does not induce a data race. 

The implementation is guaranteed to support the registration of at least {{c|32}} functions. The exact limit is implementation-defined.

===Parameters===
{{par begin}}
{{par | func | pointer to a function to be called on normal program termination}}
{{par end}}

===Return value===
{{c|0}} if the registration succeeds, nonzero value otherwise.

===Exceptions===
{{rev begin}}
{{rev | until=c++11 | (none)}}
{{rev | since=c++11 | {{noexcept}}}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

void atexit_handler_1() 
{
    std::cout &lt;&lt; &quot;at exit #1\n&quot;;
}

void atexit_handler_2() 
{
    std::cout &lt;&lt; &quot;at exit #2\n&quot;;
}

int main() 
{
    const int result_1 = std::atexit(atexit_handler_1);
    const int result_2 = std::atexit(atexit_handler_2);

    if ((result_1 != 0) or (result_2 != 0)) {
        std::cerr &lt;&lt; &quot;Registration failed\n&quot;;
        return EXIT_FAILURE;
    }

    std::cout &lt;&lt; &quot;returning from main\n&quot;;
    return EXIT_SUCCESS;
}
 | output=
returning from main
at exit #2
at exit #1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc at_quick_exit}}
{{dsc see c | c/program/atexit}}
{{dsc end}}

[[de:cpp/utility/program/atexit]]
[[es:cpp/utility/program/atexit]]
[[fr:cpp/utility/program/atexit]]
[[it:cpp/utility/program/atexit]]
[[ja:cpp/utility/program/atexit]]
[[pt:cpp/utility/program/atexit]]
[[ru:cpp/utility/program/atexit]]
[[zh:cpp/utility/program/atexit]]</text>
      <sha1>adjdyjwoadusw2rv4sy2gxr7l1bruai</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/exit</title>
    <ns>0</ns>
    <id>1965</id>
    <revision>
      <id>66142</id>
      <parentid>66139</parentid>
      <timestamp>2013-11-08T16:17:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stray parentheses</comment>
      <text xml:space="preserve" bytes="5843">{{cpp/title| exit}}
{{cpp/utility/program/navbar}}
{{dcl begin}}
{{dcl header | cstdlib}}
{{dcl rev begin}}
{{dcl | until=c++11 |
             void exit( int exit_code );
}}
{{dcl | since=c++11 |
[[noreturn]] void exit( int exit_code );
}}
{{dcl rev end}}
{{dcl end}}

Causes normal program termination to occur.

Several cleanup steps are performed:

{{rev begin}}
{{rev|until=c++11|
@1@ destructors of objects with static storage duration are called in reverse order of completion of their constructors or the completion of their dynamic initialization, and the functions passed to {{lc|std::atexit}} are called in reverse order they are registered (last one first).
:@a@ any static objects whose initialization was completed before the call to {{lc|std::atexit}} for some function F will be destroyed after the call to F during program termination.
:@b@ any static objects whose construction began after the call to {{lc|std::atexit}} for some function F will be destroyed before the call to F during program termination (this includes the case where {{lc|std::atexit}} was called from the constructor of the static object)
}}
{{rev|since=c++11|
@1@The destructors of objects with thread local [[cpp/language/storage duration|storage duration]], the destructors of objects with static storage duration, and the functions registered with {{lc|std::atexit}} are executed concurrently, while maintaining the following guarantees:
:@a@ The last destructor for thread-local objects is sequenced-before the first destructor for a static object
:@b@ If the completion of the constructor or dynamic initialization for thread-local or static object A was sequenced-before thread-local or static object B, the completion of the destruction of B is sequenced-before the start of the destruction of A
:@c@ If the completion of the initialization of a static object A was sequenced-before the call to {{lc|std::atexit}} for some function F, the call to F during termination is sequenced-before the start of the destruction of A
:@d@ If the call to {{lc|std::atexit}} for some function F was sequenced-before the completion of initialization of a static object A, the start of the destruction of A is sequenced-before the call to F during termination.
:@e@ If a call to {{lc|std::atexit}} for some function F1 was sequenced-before the call to {{lc|std::atexit}} for some function F2, then the call to F2 during termination is sequenced-before the call to F1}}
{{rev end}}
:* In the above,
::* if any function registered with {{tt|atexit}} or any destructor of static/thread-local object throws an exception, {{lc|std::terminate}} is called
::* if the compiler opted to lift dynamic initialization of an object to the static initialization phase of [[cpp/language/initialization|non-local initialization]], the sequencing of destruction honors its would-be dynamic initialization.
::* If a function-local (block-scope) static object was destroyed and then that function is called from the destructor of another static object and the control flow passes through the definition of that object (or if it is used indirectly, via pointer or reference), the behavior is undefined.
::* if a function-local (block-scope) static object was initialized during construction of a subobject of a class or array, it is only destroyed after all subobjects of that class or all elements of that array were destroyed.
@2@ all C streams are flushed and closed
@3@ files created by {{lc|std::tmpfile}} are removed
@4@ control is returned to the host environment. If {{tt|exit_code}} is {{lc|0}} or {{lc|EXIT_SUCCESS}}, an implementation-defined status indicating successful termination is returned. If {{tt|exit_code}} is {{lc|EXIT_FAILURE}}, an implementation-defined status indicating unsuccessful termination is returned. In other cases implementation-defined status value is returned.

Stack is not unwound: destructors of variables with automatic [[cpp/language/storage duration | storage durations]] are not called.

===Relationship with the main function===
Returning from the [[cpp/language/main function|the main function]], either by a {{tt|return}} statement or by reaching the end of the function performs the normal function termination (calls the destructors of the variables with automatic [[cpp/language/storage duration | storage durations]]) and then executes {{lc|std::exit}}, passing the argument of the return statement (or {{c|0}} if implicit return was used) as {{tt|exit_code}}.

===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

class Static {
public:
   
    ~Static() 
    {
        std::cout &lt;&lt; &quot;Static dtor\n&quot;;
    }
};

class Local {
public:
    ~Local() 
    {
        std::cout &lt;&lt; &quot;Local dtor\n&quot;;
    }
};

Static static_variable; // dtor of this object *will* be called

void atexit_handler()
{
    std::cout &lt;&lt; &quot;atexit handler\n&quot;;
}

int main()
{
    Local local_variable; // dtor of this object will *not* be called
    const int result = std::atexit(atexit_handler); // handler will be called
  
    if (result != 0) {
        std::cerr &lt;&lt; &quot;atexit registration failed\n&quot;;
        return EXIT_FAILURE;
    }

    std::cout &lt;&lt; &quot;test\n&quot;;
    std::exit(EXIT_FAILURE);
}
 | output=
test
atexit handler
Static dtor
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc inc | cpp/utility/program/dsc quick_exit}}
{{dsc see c | c/program/exit}}
{{dsc end}}

[[de:cpp/utility/program/exit]]
[[es:cpp/utility/program/exit]]
[[fr:cpp/utility/program/exit]]
[[it:cpp/utility/program/exit]]
[[ja:cpp/utility/program/exit]]
[[pt:cpp/utility/program/exit]]
[[ru:cpp/utility/program/exit]]
[[zh:cpp/utility/program/exit]]</text>
      <sha1>6vynaov147saz7yhl5x1pls0tcuwyix</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/getenv</title>
    <ns>0</ns>
    <id>1973</id>
    <revision>
      <id>65812</id>
      <parentid>65810</parentid>
      <timestamp>2013-10-08T14:59:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>stress that envp is optional</comment>
      <text xml:space="preserve" bytes="2843">{{cpp/title| getenv}}
{{cpp/utility/program/navbar}}
{{ddcl | header=cstdlib |
const char* getenv( const char* env_var );
}}

Searches the ''environment list'' provided by the host environment (the OS), for a string that matches the C string pointed to by {{tt|env_var}} and returns a pointer to the C string that is associated with the matched environment list member.

{{rev begin}}
{{rev|until=c++11|
This function is not required to be thread-safe. Another call to getenv, as well as a call to the POSIX functions [http://pubs.opengroup.org/onlinepubs/9699919799/functions/setenv.html setenv()], [http://pubs.opengroup.org/onlinepubs/9699919799/functions/unsetenv.html unsetenv()], and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/putenv.html putenv()] may invalidate the pointer returned by a previous call or modify the string obtained from a previous call.
}}
{{rev|since=c++11|
This function is thread-safe (calling it from multiple threads does not introduce a data race) as long as no other function modifies the host environment. In particular, the POSIX functions [http://pubs.opengroup.org/onlinepubs/9699919799/functions/setenv.html setenv()], [http://pubs.opengroup.org/onlinepubs/9699919799/functions/unsetenv.html unsetenv()], and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/putenv.html putenv()] would introduce a data race if called without synchronization.
}}
{{rev end}}

Modifying the string returned by {{tt|getenv}} (e.g. after casting away constness) invokes undefined behavior.

===Parameters===
{{par begin}}
{{par | env_var | null-terminated character string identifying the name of the environmental variable to look for }}
{{par end}}

===Return value===
Character string identifying the value of the environmental variable or null pointer if such variable is not found.

===Notes===
On POSIX systems, the [http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08 environment variables] are also accessible through the global variable {{tt|environ}}, declared as {{c|extern char **environ;}} in {{tt|&lt;unistd.h&gt;}}, and through the optional third argument, {{tt|envp}}, of [[cpp/language/main function|the main function]].

===Example===
{{example
 |
 | p=true | code=
#include &lt;iostream&gt;
#include &lt;cstdlib&gt;

int main(int argc, char *argv[])
{
    std::cout &lt;&lt; &quot;Your PATH is: &quot; &lt;&lt; std::getenv(&quot;PATH&quot;) &lt;&lt; std::endl;
}
 | output=
Your PATH is: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games
}}

===See also===
{{dsc begin}}
{{dsc see c | c/program/getenv}}
{{dsc end}}

[[de:cpp/utility/program/getenv]]
[[es:cpp/utility/program/getenv]]
[[fr:cpp/utility/program/getenv]]
[[it:cpp/utility/program/getenv]]
[[ja:cpp/utility/program/getenv]]
[[pt:cpp/utility/program/getenv]]
[[ru:cpp/utility/program/getenv]]
[[zh:cpp/utility/program/getenv]]</text>
      <sha1>ozhe2mrazu48dozj2wzi9m2yri41v2u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/jmp buf</title>
    <ns>0</ns>
    <id>8688</id>
    <revision>
      <id>59672</id>
      <parentid>51733</parentid>
      <timestamp>2013-06-01T06:39:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="929">{{cpp/title|jmp_buf}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csetjmp | 
typedef /* unspecified */ jmp_buf;
}}

The {{tt|std::jmp_buf}} type is an array type suitable for storing information to restore a calling environment. The stored information is sufficient to restore execution at the correct block of the program and invocation of that block. The state of floating-point status flags, or open files, or any other data is not stored in an object of type {{tt|jmp_buf}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc setjmp}}
{{dsc inc | cpp/utility/program/dsc longjmp}}
{{dsc see c | c/program/jmp_buf}}
{{dsc end}}

[[de:cpp/utility/program/jmp buf]]
[[es:cpp/utility/program/jmp buf]]
[[fr:cpp/utility/program/jmp buf]]
[[it:cpp/utility/program/jmp buf]]
[[ja:cpp/utility/program/jmp buf]]
[[pt:cpp/utility/program/jmp buf]]
[[ru:cpp/utility/program/jmp buf]]
[[zh:cpp/utility/program/jmp buf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/longjmp</title>
    <ns>0</ns>
    <id>1983</id>
    <revision>
      <id>59675</id>
      <parentid>51734</parentid>
      <timestamp>2013-06-01T06:39:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2011">{{cpp/title| longjmp}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csetjmp |
void longjmp( std::jmp_buf env, int status );
}}

Loads the execution context {{tt|env}} saved by a previous call to {{lc|setjmp}}. This function does not return. Control is transferred to the call site of the macro {{lc|setjmp}} that set up {{tt|env}}. That {{lc|setjmp}} then returns the value, passed as the {{tt|status}}.

If the function that called {{lc|setjmp}} has exited, the behavior is undefined (in other words, only long jumps up the call stack are allowed)

No destructors for automatic objects are called. If replacing of {{tt|std::longjmp}} with {{c|throw}} and {{lc|setjmp}} with {{c|catch}} would execute a non-trivial destructor for any automatic object, the behavior of such {{lc|std::longjmp}} is undefined.

===Parameters===
{{par begin}}
{{par | env | variable referring to the execution state of the program saved by {{c|std::setjmp}}}}
{{par | status | the value to return from {{lc|setjmp}}. If it is equal to {{c|0}}, {{c|1}} is used instead}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;csetjmp&gt;

std::jmp_buf jump_buffer;

[[noreturn]] void a(int count) 
{
    std::cout &lt;&lt; &quot;a(&quot; &lt;&lt; count &lt;&lt; &quot;) called\n&quot;;
    std::longjmp(jump_buffer, count+1);  // setjump() will return count+1
}

int main()
{
    int count = setjmp(jump_buffer);
    if (count != 9) {
        a(count);  // This will cause setjmp() to exit
    }
}
 | output=
a(0) called
a(1) called
a(2) called
a(3) called
a(4) called
a(5) called
a(6) called
a(7) called
a(8) called
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc setjmp}}
{{dsc see c | c/program/longjmp}}
{{dsc end}}

[[de:cpp/utility/program/longjmp]]
[[es:cpp/utility/program/longjmp]]
[[fr:cpp/utility/program/longjmp]]
[[it:cpp/utility/program/longjmp]]
[[ja:cpp/utility/program/longjmp]]
[[pt:cpp/utility/program/longjmp]]
[[ru:cpp/utility/program/longjmp]]
[[zh:cpp/utility/program/longjmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/quick exit</title>
    <ns>0</ns>
    <id>1966</id>
    <revision>
      <id>71935</id>
      <parentid>64809</parentid>
      <timestamp>2014-07-02T12:20:57Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>needn't use noexcept rev (this function is since c++11), mention atexit</comment>
      <text xml:space="preserve" bytes="1284">{{cpp/title| quick_exit}}
{{cpp/utility/program/navbar}}
{{ddcl | header=cstdlib | since=c++11 |
[[noreturn]] void quick_exit( int exit_code );
}}

Causes normal program termination to occur without completely cleaning the resources.

Functions passed to {{lc|std::at_quick_exit}} are called in reverse order of their registration. If an exception tries to propagate out of any of the functions, {{lc|std::terminate}} is called. After calling the registered functions, calls {{c|std::_Exit(exit_code)}}

Functions passed to {{lc|std::atexit}} are not called.
===Parameters===
{{par begin}}
{{par | exit_code | exit status of the program}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Example===
{{example
 |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc abort}}
{{dsc inc | cpp/utility/program/dsc atexit}}
{{dsc inc | cpp/utility/program/dsc at_quick_exit}}
{{dsc see c | c/program/quick_exit}}
{{dsc end}}

[[de:cpp/utility/program/quick exit]]
[[es:cpp/utility/program/quick exit]]
[[fr:cpp/utility/program/quick exit]]
[[it:cpp/utility/program/quick exit]]
[[ja:cpp/utility/program/quick exit]]
[[pt:cpp/utility/program/quick exit]]
[[ru:cpp/utility/program/quick exit]]
[[zh:cpp/utility/program/quick exit]]</text>
      <sha1>h3ii9xeu98aepfu8d3960jggw3p11po</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/raise</title>
    <ns>0</ns>
    <id>1975</id>
    <revision>
      <id>64230</id>
      <parentid>64209</parentid>
      <timestamp>2013-08-15T15:53:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+std::</comment>
      <text xml:space="preserve" bytes="1494">{{cpp/title| raise}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csignal |
int raise( int sig );
}}

Sends signal sig to the program. The signal handler (specified using the {{lc|std::signal()}} function) is invoked.

If the user-defined signal handling strategy is not set using {{lc|std::signal()}} yet, it is implementation-defined whether the signal will be ignored or default handler will be invoked. 

===Parameters===
{{par begin}}
{{par | sig | the signal to be sent. It can be an implementation-defined value or one of the following values:
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc SIG_types}}
{{dsc end}}
}}
{{par end}}

===Return value===
{{c|0}} upon success, non-zero value on failure.

===Example===
{{example
 |
 | p=true
 | code=
#include &lt;csignal&gt;
#include &lt;iostream&gt;

void signal_handler(int signal)
{
    std::cout &lt;&lt; &quot;Received signal &quot; &lt;&lt; signal &lt;&lt; '\n';
}

int main()
{
    // Install a signal handler
    std::signal(SIGTERM, signal_handler);

    std::cout &lt;&lt; &quot;Sending signal &quot; &lt;&lt; SIGTERM &lt;&lt; '\n';
    std::raise(SIGTERM);
}
 | output=
Sending signal 15
Received signal 15
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc see c | c/program/raise}}
{{dsc end}}

[[de:cpp/utility/program/raise]]
[[es:cpp/utility/program/raise]]
[[fr:cpp/utility/program/raise]]
[[it:cpp/utility/program/raise]]
[[ja:cpp/utility/program/raise]]
[[pt:cpp/utility/program/raise]]
[[ru:cpp/utility/program/raise]]
[[zh:cpp/utility/program/raise]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/setjmp</title>
    <ns>0</ns>
    <id>1982</id>
    <revision>
      <id>65597</id>
      <parentid>59680</parentid>
      <timestamp>2013-09-23T16:58:23Z</timestamp>
      <contributor>
        <username>Radix</username>
        <id>584</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1870">{{title| setjmp}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csetjmp | 
#define setjmp(env) /* implementation-defined */
}}

Saves the current execution context into a variable {{tt|env}} of type {{lc|std::jmp_buf}}. This variable can later be used to restore the current execution context by {{lc|std::longjmp}} function. That is, when a call to {{lc|std::longjmp}} function is made, the execution continues at the particular call site that constructed the {{lc|std::jmp_buf}} variable passed to {{lc|std::longjmp}}. In that case {{lc|setjmp}} returns the value passed to {{lc|std::longjmp}}.

===Parameters===
{{par begin}}
{{par | env | variable to save the execution state of the program to.}}
{{par end}}

===Return value===
{{c|0}} if the macro was called by the original code and the execution context was saved to {{tt|env}}.

Non-zero value if a non-local jump was just performed. The return value is the same as passed to {{lc|std::longjmp}}.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;csetjmp&gt;

std::jmp_buf jump_buffer;

[[noreturn]] void a(int count) 
{
    std::cout &lt;&lt; &quot;a(&quot; &lt;&lt; count &lt;&lt; &quot;) called\n&quot;;
    std::longjmp(jump_buffer, count+1);  // setjump() will return count+1
}

int main()
{
    int count = setjmp(jump_buffer);
    if (count != 9) {
        a(count);  // This will cause setjmp() to exit
    }
}
 | output=
a(0) called
a(1) called
a(2) called
a(3) called
a(4) called
a(5) called
a(6) called
a(7) called
a(8) called
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc longjmp}}
{{dsc see c | c/program/setjmp}}
{{dsc end}}

[[de:cpp/utility/program/setjmp]]
[[es:cpp/utility/program/setjmp]]
[[fr:cpp/utility/program/setjmp]]
[[it:cpp/utility/program/setjmp]]
[[ja:cpp/utility/program/setjmp]]
[[pt:cpp/utility/program/setjmp]]
[[ru:cpp/utility/program/setjmp]]
[[zh:cpp/utility/program/setjmp]]</text>
      <sha1>m1ap557xc3pomhzyf36a31899h2wn79</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/sig atomic t</title>
    <ns>0</ns>
    <id>8692</id>
    <revision>
      <id>66030</id>
      <parentid>59681</parentid>
      <timestamp>2013-10-21T16:49:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>use in signal handlers as described in C Rationale 5.2.3 Signals and interrupts</comment>
      <text xml:space="preserve" bytes="1022">{{cpp/title|sig_atomic_t}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csignal |
typedef /* unspecified */ sig_atomic_t;
}}

An integer type which can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals.

===Notes===
Until C++11, which introduced {{lc|std::atomic}} and {{lc|std::atomic_signal_fence}}, about the only thing a strictly conforming program could do in a signal handler was to assign a value to a {{c|volatile static std::sig_atomic_t}} variable and promptly return.

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc signal}}
{{dsc see c | c/program/sig_atomic_t}}
{{dsc inc | cpp/atomic/dsc atomic_signal_fence}}
{{dsc end}}

[[de:cpp/utility/program/sig atomic t]]
[[es:cpp/utility/program/sig atomic t]]
[[fr:cpp/utility/program/sig atomic t]]
[[it:cpp/utility/program/sig atomic t]]
[[ja:cpp/utility/program/sig atomic t]]
[[pt:cpp/utility/program/sig atomic t]]
[[ru:cpp/utility/program/sig atomic t]]
[[zh:cpp/utility/program/sig atomic t]]</text>
      <sha1>92nf03nso86kb6827i4dsu8zmv8lpct</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/signal</title>
    <ns>0</ns>
    <id>1974</id>
    <revision>
      <id>72262</id>
      <parentid>67803</parentid>
      <timestamp>2014-08-01T13:44:46Z</timestamp>
      <contributor>
        <username>Kerinor</username>
        <id>2068</id>
      </contributor>
      <text xml:space="preserve" bytes="4879">{{cpp/title| signal}}
{{cpp/utility/program/navbar}}
{{ddcl | header=csignal |
void (*signal( int sig, void (*handler) (int))) (int);
}}

Sets the error handler for signal {{tt|sig}}. The signal handler can be set so that default handling will occur, signal is ignored, or a user-defined function is called.

When signal handler is set to a function and a signal occurs, it is implementation defined whether {{c|std::signal(sig, SIG_DFL)}} will be executed immediately before the start of signal handler. Also, the implementation can prevent some implementation-defined set of signals from occurring while the signal handler runs.

For some of the signals, the implementation may call {{c|std::signal(sig, SIG_IGN)}} at the startup of the program. For the rest, the implementation must call {{c|std::signal(sig, SIG_DFL)}}.

===Parameters===
{{par begin}}
{{par | sig | the signal to set the signal handler to. It can be an implementation-defined value or one of the following values: 
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc SIG_types}}
{{dsc end}}
}}
{{par | handler | the signal handler. This must be one of the following: 
*{{lc|SIG_DFL}} macro. The signal handler is set to default signal handler.
*{{lc|SIG_IGN}} macro. The signal is ignored.
*pointer to a function. The signature of the function must be equivalent to the following:
{{ddcl | 
void fun(int sig);}}}}
{{par end}}

===Return value===
Previous signal handler on success or {{lc|SIG_ERR}} on failure (setting a signal handler can be disabled on some implementations).

===Signal handler===
The following limitations are imposed on the user-defined function that is installed as a signal handler.

If the user defined function returns when handling {{lc|SIGFPE}}, {{lc|SIGILL}}, {{lc|SIGSEGV}} or any other implementation-defined signal specifying a computational exception, the behavior is undefined.

If the signal handler is called as a result of {{lc|std::abort}} or {{lc|std::raise}}, the behavior is undefined if the signal handler calls {{lc|std::raise}}.

If the signal handler is called NOT as a result of {{lc|std::abort}} or {{lc|std::raise}}, the behavior is undefined if
* the signal handler calls any function within the standard library, except {{lc|std::abort}}, {{lc|std::_Exit}}, {{lc|std::quick_exit}}, or {{c|std::signal}} with the first argument not being the number of the signal currently handled. 
* the signal handler refers to any object with static or thread-local{{mark since c++11}} storage duration that is not {{lc|std::atomic}}{{mark since c++11}} or {{c|volatile std::sig_atomic_t}}.

On entry to the signal handler, the state of the [[cpp/numeric/fenv|floating-point environment]] and the values of all objects is unspecified, except for
* objects of type {{c|volatile std::sig_atomic_t}}
* objects of {{lc|std::atomic}} types {{mark since c++11}}
* side effects made visible through {{lc|std::atomic_signal_fence}} {{mark since c++11}}

On return from a signal handler, the value of any object modified by the signal handler that is not {{c|volatile std::sig_atomic_t}} or {{lc|std::atomic}} is undefined.

The behavior is undefined if {{tt|std::signal}} is used in a multithreaded program. It is not required to be thread-safe.&lt;!-- said explicitly in C11's 7.14.1.1/7, C++11's signal refers to C99 which doesn't know about threads --&gt;

===Notes===
POSIX requires that {{tt|signal}} is thread-safe, and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04 specifies a list of async-signal-safe library functions] that may be called from any signal handler.

Signal handlers are expected to have [[cpp/language/language_linkage|C linkage]] and, in general, only use the features from the common subset of C and C++. It is implementation-defined if a function with C++ linkage can be used as a signal handler. &lt;!-- per C++11 $18.10[support.runtime]/9 --&gt;

===Example===
{{example
 |
 | p=true
 | code=
#include &lt;csignal&gt;
#include &lt;iostream&gt;

namespace
{
  volatile sig_atomic_t gSignalStatus = 0;
}

void signal_handler(int signal)
{
  gSignalStatus = signal;
}

int main()
{
  // Install a signal handler
  std::signal(SIGINT, signal_handler);

  std::cout &lt;&lt; &quot;SignalValue: &quot; &lt;&lt; gSignalStatus &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;Sending signal &quot; &lt;&lt; SIGINT &lt;&lt; '\n';
  std::raise(SIGINT);
  std::cout &lt;&lt; &quot;SignalValue: &quot; &lt;&lt; gSignalStatus &lt;&lt; '\n';
}
 | output=
SignalValue: 0
Sending signal 2
SignalValue: 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/program/dsc raise}}
{{dsc see c | c/program/signal}}
{{dsc inc | cpp/atomic/dsc atomic_signal_fence}}
{{dsc end}}

[[de:cpp/utility/program/signal]]
[[es:cpp/utility/program/signal]]
[[fr:cpp/utility/program/signal]]
[[it:cpp/utility/program/signal]]
[[ja:cpp/utility/program/signal]]
[[pt:cpp/utility/program/signal]]
[[ru:cpp/utility/program/signal]]
[[zh:cpp/utility/program/signal]]</text>
      <sha1>0gze0zcwqdlj8653sa8fguxcsvyd766</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/program/system</title>
    <ns>0</ns>
    <id>1972</id>
    <revision>
      <id>65432</id>
      <parentid>62270</parentid>
      <timestamp>2013-09-14T16:00:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+popen in notes</comment>
      <text xml:space="preserve" bytes="1518">{{cpp/title| system}}
{{cpp/utility/program/navbar}}
{{ddcl | header=cstdlib |
int system( const char *command );
}}

Calls the host environment's command processor with command parameter. Returns implementation-defined value (usually the value that the invoked program returns).

If command is the {{lc|NULL}} pointer, checks if host environment has a command processor and returns nonzero value only if the command processor exists.

===Parameters===
{{par begin}}
{{par | command | character string identifying the command to be run in the command processor. If NULL pointer is given, command processor is checked for existence}}
{{par end}}

===Return value===
Implementation-defined value. If {{tt|command}} is {{lc|NULL}} returns nonzero value only if command processor exists.

===Notes===
Related POSIX function [http://pubs.opengroup.org/onlinepubs/9699919799/functions/popen.html popen] makes the output generated by {{tt|command}} available to the caller.

===Example===
In this example there is a system call of the unix command '''ls -l &gt;test.txt''':
{{example
 |
 | code=
#include &lt;cstdlib&gt;

int main()
{
    std::system(&quot;ls -l &gt;test.txt&quot;);
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc see c | c/program/system}}
{{dsc end}}

[[de:cpp/utility/program/system]]
[[es:cpp/utility/program/system]]
[[fr:cpp/utility/program/system]]
[[it:cpp/utility/program/system]]
[[ja:cpp/utility/program/system]]
[[pt:cpp/utility/program/system]]
[[ru:cpp/utility/program/system]]
[[zh:cpp/utility/program/system]]</text>
      <sha1>bbh7w6jj8n5jmtsrtf2mnf90f5nvqh7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/ratio</title>
    <ns>0</ns>
    <id>3513</id>
    <redirect title="cpp/numeric/ratio" />
    <revision>
      <id>13318</id>
      <timestamp>2011-11-07T13:32:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/ratio]] to [[cpp/numeric/ratio]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/numeric/ratio]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/ratio/ratio</title>
    <ns>0</ns>
    <id>3515</id>
    <redirect title="cpp/numeric/ratio/ratio" />
    <revision>
      <id>13322</id>
      <timestamp>2011-11-07T13:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/ratio/ratio]] to [[cpp/numeric/ratio/ratio]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/numeric/ratio/ratio]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rel ops/operator cmp</title>
    <ns>0</ns>
    <id>4255</id>
    <revision>
      <id>67967</id>
      <parentid>67966</parentid>
      <timestamp>2014-03-10T12:47:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 67966 by [[Special:Contributions/140.93.3.229|140.93.3.229]] ([[User talk:140.93.3.229|talk]])</comment>
      <text xml:space="preserve" bytes="3149">{{cpp/utility/rel_ops/title | operator!{{=}},&gt;,&lt;{{=}},&gt;{{=}}}}
{{cpp/utility/navbar}}

{{dcl begin}}
{{dcl header | utility}}
{{dcl | num=1 | 1=
template&lt; class T &gt;
bool operator!=( const T&amp; lhs, const T&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class T &gt;
bool operator&gt;( const T&amp; lhs, const T&amp; rhs );
}}

{{dcl | num=3 | 1=
template&lt; class T &gt;
bool operator&lt;=( const T&amp; lhs, const T&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; class T &gt;
bool operator&gt;=( const T&amp; lhs, const T&amp; rhs );
}}
{{dcl end}}

Given a user-defined {{c|1=operator==}} and {{c|1=operator&lt;}} for objects of type {{tt|T}}, implements the usual semantics of other comparison operators.

1) Implements {{c|1=operator!=}} in terms of {{c|1=operator==}}.

2) Implements {{c|1=operator&gt;}} in terms of {{c|1=operator&lt;}}.

3) Implements {{c|1=operator&lt;=}} in terms of {{c|1=operator&lt;}}.

4) Implements {{c|1=operator&gt;=}} in terms of {{c|1=operator&lt;}}.

===Parameters===
{{par begin}}
{{par | lhs | left-hand argument}}
{{par | rhs | right-hand argument}}
{{par end}}

===Return value===

1) Returns {{c|true}} if {{tt|lhs}} is ''not equal'' to {{tt|rhs}}.

2) Returns {{c|true}} if {{tt|lhs}} is ''greater'' than {{tt|rhs}}.

3) Returns {{c|true}} if {{tt|lhs}} is ''less or equal'' to {{tt|rhs}}.

4) Returns {{c|true}} if {{tt|lhs}} is ''greater or equal'' to {{tt|rhs}}.

===Possible implementation===
{{eq fun
 | 1=
namespace rel_ops {
    template&lt; class T &gt;
    bool operator!=( const T&amp; lhs, const T&amp; rhs ) 
    {
        return !(lhs == rhs);
    }
}
 | 2=
namespace rel_ops {
    template&lt; class T &gt;
    bool operator&gt;( const T&amp; lhs, const T&amp; rhs ) 
    {
        return rhs &lt; lhs;
    }
}
 | 3=
namespace rel_ops {
    template&lt; class T &gt;
    bool operator&lt;=( const T&amp; lhs, const T&amp; rhs ) 
    {
        return !(rhs &lt; lhs);
    }
}
 | 4=
namespace rel_ops {
    template&lt; class T &gt;
    bool operator&gt;=( const T&amp; lhs, const T&amp; rhs ) 
    {
        return !(lhs &lt; rhs);
    }
}
}}

===Notes===
[http://www.boost.org/doc/libs/release/libs/utility/operators.htm Boost.operators] provides a more versatile alternative to {{tt|std::rel_ops}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;

struct Foo {
    int n;
};

bool operator==(const Foo&amp; lhs, const Foo&amp; rhs)
{
    return lhs.n == rhs.n;
}

bool operator&lt;(const Foo&amp; lhs, const Foo&amp; rhs)
{
    return lhs.n &lt; rhs.n;
}

int main()
{
    Foo f1 = {1};
    Foo f2 = {2};
    using namespace std::rel_ops;

    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;not equal?     : &quot; &lt;&lt; (f1 != f2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;greater?       : &quot; &lt;&lt; (f1 &gt; f2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;less equal?    : &quot; &lt;&lt; (f1 &lt;= f2) &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;greater equal? : &quot; &lt;&lt; (f1 &gt;= f2) &lt;&lt; '\n';
}
 | output=
not equal?     : true
greater?       : false
less equal?    : true
greater equal? : false
}}

[[de:cpp/utility/rel ops/operator cmp]]
[[es:cpp/utility/rel ops/operator cmp]]
[[fr:cpp/utility/rel ops/operator cmp]]
[[it:cpp/utility/rel ops/operator cmp]]
[[ja:cpp/utility/rel ops/operator cmp]]
[[pt:cpp/utility/rel ops/operator cmp]]
[[ru:cpp/utility/rel ops/operator cmp]]
[[zh:cpp/utility/rel ops/operator cmp]]</text>
      <sha1>kog0che3lckdxbnkmxtqupa5ogr3l3p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rel ops/operator ge</title>
    <ns>0</ns>
    <id>2998</id>
    <redirect title="cpp/utility/rel ops/operator cmp" />
    <revision>
      <id>15431</id>
      <parentid>11306</parentid>
      <timestamp>2011-12-09T14:57:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/utility/rel ops/operator cmp]]</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/utility/rel_ops/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rel ops/operator gt</title>
    <ns>0</ns>
    <id>2996</id>
    <redirect title="cpp/utility/rel ops/operator cmp" />
    <revision>
      <id>15429</id>
      <parentid>11305</parentid>
      <timestamp>2011-12-09T14:57:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/utility/rel ops/operator cmp]]</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/utility/rel_ops/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rel ops/operator le</title>
    <ns>0</ns>
    <id>2997</id>
    <redirect title="cpp/utility/rel ops/operator cmp" />
    <revision>
      <id>15430</id>
      <parentid>11303</parentid>
      <timestamp>2011-12-09T14:57:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/utility/rel ops/operator cmp]]</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/utility/rel_ops/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rel ops/operator not eq</title>
    <ns>0</ns>
    <id>2994</id>
    <redirect title="cpp/utility/rel ops/operator cmp" />
    <revision>
      <id>15428</id>
      <parentid>11304</parentid>
      <timestamp>2011-12-09T14:57:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/utility/rel ops/operator cmp]]</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/utility/rel_ops/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rtti</title>
    <ns>0</ns>
    <id>1785</id>
    <redirect title="cpp/types" />
    <revision>
      <id>4894</id>
      <parentid>4893</parentid>
      <timestamp>2011-07-07T12:42:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="23">#REDIRECT [[cpp/types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rtti/type index</title>
    <ns>0</ns>
    <id>2169</id>
    <redirect title="cpp/types/type index" />
    <revision>
      <id>4888</id>
      <timestamp>2011-07-07T12:37:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/rtti/type index]] to [[cpp/types/type index]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/types/type index]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/rtti/type info</title>
    <ns>0</ns>
    <id>2170</id>
    <redirect title="cpp/types/type info" />
    <revision>
      <id>4891</id>
      <timestamp>2011-07-07T12:38:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/rtti/type info]] to [[cpp/types/type info]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[cpp/types/type info]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/swap</title>
    <ns>0</ns>
    <id>13086</id>
    <redirect title="cpp/algorithm/swap" />
    <revision>
      <id>66380</id>
      <timestamp>2013-11-15T17:43:17Z</timestamp>
      <contributor>
        <ip>208.180.238.130</ip>
      </contributor>
      <comment>C++ swap is defined in utility, not algorithm, but create a redirect back to the algorithm/swap page.</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[cpp/algorithm/swap]]</text>
      <sha1>nn81ger25bkl2f3nk56x3pndxz4zk4z</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple</title>
    <ns>0</ns>
    <id>2379</id>
    <revision>
      <id>66005</id>
      <parentid>64134</parentid>
      <timestamp>2013-10-20T07:57:53Z</timestamp>
      <contributor>
        <username>Ruslo</username>
        <id>2177</id>
      </contributor>
      <text xml:space="preserve" bytes="2757">{{cpp/title|tuple}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | since=c++11 | 1=
template&lt; class... Types &gt;
class tuple;
}}
{{dcl end}}

Class template {{tt|std::tuple}} is a fixed-size collection of heterogeneous values. It is a generalization of {{lc|std::pair}}.

===Template parameters===
{{par begin}}
{{par | Types... | the types of the elements that the tuple stores. Empty list is supported. }}
{{par end}}

===Member functions===
{{dsc begin}}
{{dsc mem ctor | cpp/utility/tuple/tuple | constructs a new {{tt|tuple}} }}
{{dsc mem fun | cpp/utility/tuple/operator{{=}} | assigns the contents of one {{tt|tuple}} to another}}
{{dsc mem fun | cpp/utility/tuple/swap | swaps the contents of two {{tt|tuple}}s }}
{{dsc end}}

===Non-member functions===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tuple_cat}}
{{dsc inc | cpp/utility/tuple/dsc get}}
{{dsc inc | cpp/utility/tuple/dsc operator_cmp}}
{{dsc inc | cpp/utility/tuple/dsc swap2}}
{{dsc end}}

===Helper classes===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tuple_size}}
{{dsc inc | cpp/utility/tuple/dsc tuple_element}}
{{dsc inc | cpp/utility/tuple/dsc uses_allocator}}
{{dsc inc | cpp/utility/tuple/dsc ignore}}
{{dsc end}}

===Example===
{{example |
 | code=
#include &lt;tuple&gt;
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;stdexcept&gt;

std::tuple&lt;double, char, std::string&gt; get_student(int id)
{
    if (id == 0) return std::make_tuple(3.8, 'A', &quot;Lisa Simpson&quot;);
    if (id == 1) return std::make_tuple(2.9, 'C', &quot;Milhouse Van Houten&quot;);
    if (id == 2) return std::make_tuple(1.7, 'D', &quot;Ralph Wiggum&quot;);
    throw std::invalid_argument(&quot;id&quot;);
}

int main()
{
    auto student0 = get_student(0);
    std::cout &lt;&lt; &quot;ID: 0, &quot;
              &lt;&lt; &quot;GPA: &quot; &lt;&lt; std::get&lt;0&gt;(student0) &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;grade: &quot; &lt;&lt; std::get&lt;1&gt;(student0) &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;name: &quot; &lt;&lt; std::get&lt;2&gt;(student0) &lt;&lt; '\n';

    double gpa1;
    char grade1;
    std::string name1;
    std::tie(gpa1, grade1, name1) = get_student(1);
    std::cout &lt;&lt; &quot;ID: 1, &quot;
              &lt;&lt; &quot;GPA: &quot; &lt;&lt; gpa1 &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;grade: &quot; &lt;&lt; grade1 &lt;&lt; &quot;, &quot;
              &lt;&lt; &quot;name: &quot; &lt;&lt; name1 &lt;&lt; '\n';
} | output=
ID: 0, GPA: 3.8, grade: A, name: Lisa Simpson
ID: 1, GPA: 2.9, grade: C, name: Milhouse Van Houten
}}

===References===
{{ref std c++11}}
{{ref std | section=20.4 | title=Tuples | id=tuple}}
{{ref std end}}

[[de:cpp/utility/tuple]]
[[es:cpp/utility/tuple]]
[[fr:cpp/utility/tuple]]
[[it:cpp/utility/tuple]]
[[ja:cpp/utility/tuple]]
[[ko:cpp/utility/tuple]]
[[pt:cpp/utility/tuple]]
[[ru:cpp/utility/tuple]]
[[zh:cpp/utility/tuple]]</text>
      <sha1>t2w87npns57pdf3i3li502d2jgkjlf6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/forward as tuple</title>
    <ns>0</ns>
    <id>2681</id>
    <revision>
      <id>66794</id>
      <parentid>66193</parentid>
      <timestamp>2013-12-30T19:00:16Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2114">{{cpp/title|forward_as_tuple}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class... Types &gt;
tuple&lt;Types&amp;&amp;...&gt; forward_as_tuple( Types&amp;&amp;... args );
}}
{{dcl | since=c++14 | 1=
template&lt; class... Types &gt;
constexpr tuple&lt;Types&amp;&amp;...&gt; forward_as_tuple( Types&amp;&amp;... args );
}}
{{dcl rev end}}
{{dcl end}}

Constructs a tuple of references to the arguments in {{tt|args}} suitable for forwarding as an argument to a function. The tuple has rvalue reference data members when rvalues are used as arguments, and otherwise has lvalue reference data members. If rvalues are used, the result of this function must be consumed before the next sequence point.

===Parameters===
{{par begin}}
{{par | args | zero or more arguments to construct the tuple from}}
{{par end}}

===Return value===
A {{lc|std::tuple}} object created as if by {{c|std::tuple&lt;Types&amp;&amp;...&gt;(std::forward&lt;Types&gt;(args)...)}}

===Exceptions===
{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;map&gt;
#include &lt;tuple&gt;
#include &lt;string&gt;

int main()
{
    std::map&lt;int, std::string&gt; m;

    m.emplace(std::piecewise_construct,
              std::forward_as_tuple(10),
              std::forward_as_tuple(20, 'a'));
    std::cout &lt;&lt; &quot;m[10] = &quot; &lt;&lt; m[10] &lt;&lt; '\n';

    // The following is an error: it produces a
    // std::tuple&lt;int&amp;&amp;, char&amp;&amp;&gt; holding two dangling references.
    //
    // auto t = std::forward_as_tuple(20, 'a');
    // m.emplace(std::piecewise_construct, std::forward_as_tuple(10), t);
}
 | output=
m[10] = aaaaaaaaaaaaaaaaaaaa
}}

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc tuple_cat}}
{{dsc end}}

[[de:cpp/utility/tuple/forward as tuple]]
[[es:cpp/utility/tuple/forward as tuple]]
[[fr:cpp/utility/tuple/forward as tuple]]
[[it:cpp/utility/tuple/forward as tuple]]
[[ja:cpp/utility/tuple/forward as tuple]]
[[pt:cpp/utility/tuple/forward as tuple]]
[[ru:cpp/utility/tuple/forward as tuple]]
[[zh:cpp/utility/tuple/forward as tuple]]</text>
      <sha1>fp8cxbxj6uzv2tixctexcd5i4eirfxd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/get</title>
    <ns>0</ns>
    <id>2692</id>
    <revision>
      <id>71864</id>
      <parentid>64640</parentid>
      <timestamp>2014-06-29T15:57:16Z</timestamp>
      <contributor>
        <username>Lingxi</username>
        <id>3179</id>
      </contributor>
      <minor/>
      <comment>Deleted a duplicate &quot;element&quot;.</comment>
      <text xml:space="preserve" bytes="3132">{{cpp/title | get&lt;small&gt;(std::tuple)&lt;/small&gt;}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | num=1 | since=c++11 | until=c++14 |
template&lt; std::size_t I, class... Types &gt;
typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;
    get( tuple&lt;Types...&gt;&amp; t );
}}
{{dcl | num=1 | since=c++14 |
template&lt; std::size_t I, class... Types &gt;
constexpr typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;
    get( tuple&lt;Types...&gt;&amp; t );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | since=c++11 | until=c++14 |
template&lt; std::size_t I, class... Types &gt;
typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;&amp;
    get( tuple&lt;Types...&gt;&amp;&amp; t );
}}
{{dcl | num=2 | since=c++14 |
template&lt; std::size_t I, class... Types &gt;
constexpr typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type&amp;&amp;
    get( tuple&lt;Types...&gt;&amp;&amp; t );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | since=c++11 | until=c++14 |
template&lt; std::size_t I, class... Types &gt;
typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp;
    get( const tuple&lt;Types...&gt;&amp; t );
}}
{{dcl | num=3 | since=c++14 |
template&lt; std::size_t I, class... Types &gt;
constexpr typename std::tuple_element&lt;I, tuple&lt;Types...&gt; &gt;::type const&amp;
    get( const tuple&lt;Types...&gt;&amp; t );
}}
{{dcl rev end}}
{{dcl | num=4 | since=c++14 |
template&lt; class T, class... Types &gt;
constexpr T&amp; get(tuple&lt;Types...&gt;&amp; t);
}}
{{dcl | num=5 | since=c++14 |
template&lt; class T, class... Types &gt;
constexpr T&amp;&amp; get(tuple&lt;Types...&gt;&amp;&amp; t);
}}
{{dcl | num=6 | since=c++14 |
template&lt; class T, class... Types &gt;
constexpr const T&amp; get(const tuple&lt;Types...&gt;&amp; t);
}}
{{dcl end}}

@1-3@ Extracts the {{tt|Ith}} element from the tuple. {{tt|I}} is an integer value in {{tt|[0, sizeof...(Types))}}.
@4-6@ Extracts the element of the tuple {{tt|t}} whose type is {{tt|T}}. Fails to compile if the tuple has more than one element of that type.

===Parameters===
{{par begin}}
{{par | t | tuple whose contents to extract}}
{{par end}} 

===Return value===

@1,4@ Reference to the selected element of {{tt|t}}.

@2,5@ Rvalue reference to the selected element of {{tt|t}}, unless the element is of lvalue reference type, in which case lvalue reference is returned.

@3,6@ Const reference to the selected element of {{tt|t}}.

===Exceptions===

{{noexcept}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;tuple&gt;

int main()
{
    auto t = std::make_tuple(1, &quot;Foo&quot;, 3.14);
    // index-based access
    std::cout &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;0&gt;(t) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(t)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;2&gt;(t) &lt;&lt; &quot;)\n&quot;;
    // type-based access
    std::cout &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;int&gt;(t) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;const char*&gt;(t)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;double&gt;(t) &lt;&lt; &quot;)\n&quot;;
}
 | output=
(1, Foo, 3.14)
(1, Foo, 3.14)
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/array/dsc get}}
{{dsc inc | cpp/utility/pair/dsc get}}
{{dsc end}}

[[de:cpp/utility/tuple/get]]
[[es:cpp/utility/tuple/get]]
[[fr:cpp/utility/tuple/get]]
[[it:cpp/utility/tuple/get]]
[[ja:cpp/utility/tuple/get]]
[[pt:cpp/utility/tuple/get]]
[[ru:cpp/utility/tuple/get]]
[[zh:cpp/utility/tuple/get]]</text>
      <sha1>l1sstp3z5mhlhv3xp3ytr8brqaxy7mf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/ignore</title>
    <ns>0</ns>
    <id>2689</id>
    <revision>
      <id>63117</id>
      <parentid>59692</parentid>
      <timestamp>2013-07-01T23:55:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1137">{{cpp/title|ignore}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | since=c++11 | 1=
const /*unspecified*/ ignore;
}}
{{dcl end}}

An object of unspecified type such that any value can be assigned to it with no effect. Intended for use with {{lc|std::tie}} when unpacking a {{lc|std::tuple}}, as a placeholder for the arguments that are not used.

===Example===
{{example
 | unpack a pair returned by set.insert(), but only save the boolean.
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;set&gt;
#include &lt;tuple&gt;

int main()
{
    std::set&lt;std::string&gt; set_of_str;
    bool inserted;
    std::tie(std::ignore, inserted) = set_of_str.insert(&quot;Test&quot;);
    if (inserted) {
        std::cout &lt;&lt; &quot;Value was inserted sucessfully\n&quot;;
    }
}
 | output=
Value was inserted sucessfully
}}

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc end}}

[[de:cpp/utility/tuple/ignore]]
[[es:cpp/utility/tuple/ignore]]
[[fr:cpp/utility/tuple/ignore]]
[[it:cpp/utility/tuple/ignore]]
[[ja:cpp/utility/tuple/ignore]]
[[pt:cpp/utility/tuple/ignore]]
[[ru:cpp/utility/tuple/ignore]]
[[zh:cpp/utility/tuple/ignore]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/make tuple</title>
    <ns>0</ns>
    <id>2678</id>
    <revision>
      <id>67070</id>
      <parentid>66615</parentid>
      <timestamp>2014-01-21T01:25:33Z</timestamp>
      <contributor>
        <username>SuperBoi45</username>
        <id>1156</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2475">{{cpp/title|make_tuple}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 | 1=
template&lt; class... Types &gt;
tuple&lt;VTypes...&gt; make_tuple( Types&amp;&amp;... args );
}}
{{dcl | since=c++14 | 1=
template&lt; class... Types &gt;
constexpr tuple&lt;VTypes...&gt; make_tuple( Types&amp;&amp;... args );
}}
{{dcl rev end}}
{{dcl end}}

Creates a tuple object, deducing the target type from the types of arguments.

For each {{tt|Ti}} in {{tt|Types...}}, the corresponding type {{tt|Vi}} in {{tt|Vtypes...}} is {{c|std::decay&lt;Ti&gt;::type}} unless application of {{lc|std::decay}} results in {{c|std::reference_wrapper&lt;X&gt;}} for some type {{tt|X}}, in which case the deduced type is {{tt|X&amp;}}. 

===Parameters===
{{par begin}}
{{par | args | zero or more arguments to construct the tuple from}}
{{par end}}

===Return value===
A {{lc|std::tuple}} object containing the given values, created as if by {{c|std::tuple&lt;VTypes...&gt;(std::forward&lt;Types&gt;(t)...).}}

===Possible implementation===
{{eq fun | 1=
template &lt;class T&gt;
struct special_decay
{
    using type = typename std::decay&lt;T&gt;::type;
};

template &lt;class T&gt;
struct special_decay&lt;std::reference_wrapper&lt;T&gt;&gt;
{
    using type = T&amp;;
};

template &lt;class T&gt;
using special_decay_t = typename special_decay&lt;T&gt;::type;

template &lt;class... Types&gt;
auto make_tuple(Types&amp;&amp;... args)
{
    return std::tuple&lt;special_decay_t&lt;Types&gt;...&gt;(std::forward&lt;Types&gt;(args)...);
}
}}

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;tuple&gt;
#include &lt;functional&gt;

int main()
{
    auto t1 = std::make_tuple(10, &quot;Test&quot;, 3.14);
    std::cout &lt;&lt; &quot;The value of t1 is &quot;
              &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;0&gt;(t1) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(t1)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;2&gt;(t1) &lt;&lt; &quot;)\n&quot;;

    int n = 1;
    auto t2 = std::make_tuple(std::ref(n), n);
    n = 7;
    std::cout &lt;&lt; &quot;The value of t2 is &quot;
              &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;0&gt;(t2) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(t2) &lt;&lt; &quot;)\n&quot;;
}
 | output=
The value of t1 is (10, Test, 3.14)
The value of t2 is (7, 1)
}}

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tuple_cat}}
{{dsc end}}

[[de:cpp/utility/tuple/make tuple]]
[[es:cpp/utility/tuple/make tuple]]
[[fr:cpp/utility/tuple/make tuple]]
[[it:cpp/utility/tuple/make tuple]]
[[ja:cpp/utility/tuple/make tuple]]
[[pt:cpp/utility/tuple/make tuple]]
[[ru:cpp/utility/tuple/make tuple]]
[[zh:cpp/utility/tuple/make tuple]]</text>
      <sha1>h0ar3e56twsdz9a0pj9pgz51vmd3qlr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/operator=</title>
    <ns>0</ns>
    <id>2676</id>
    <revision>
      <id>63119</id>
      <parentid>51747</parentid>
      <timestamp>2013-07-01T23:55:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="2251">{{cpp/utility/tuple/title | operator{{=}}}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
tuple&amp; operator=( const tuple&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
tuple&amp; operator=( tuple&amp;&amp; other );
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; class... UTypes &gt;
tuple&amp; operator=( const tuple&lt;UTypes...&gt;&amp; other );
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; class... UTypes &gt;
tuple&amp; operator=( tuple&lt;UTypes...&gt;&amp;&amp; other );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class U1, class U2 &gt;
tuple&amp; operator=( const pair&lt;U1,U2&gt;&amp; p );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class U1, class U2 &gt;
tuple&amp; operator=( pair&lt;U1,U2&gt;&amp;&amp; p );
}}
{{dcl end}}

Replaces the contents of the tuple with the contents of another tuple or a pair.

1) Copy assignment operator. Replaces each element with a copy of the corresponding element of {{tt|other}}.
 
2) Move assignment operator. Replaces each element with the corresponding element of {{tt|other}} using move semantics. 

3) For all {{tt|i}}, assigns {{c|std::get&lt;i&gt;(other)}} to {{c|std::get&lt;i&gt;(*this)}}.

4) For all {{tt|i}}, assigns {{c|std::forward&lt;Ui&gt;(std::get&lt;i&gt;(other))}} to {{c|std::get&lt;i&gt;(*this)}}. 

5) Assigns {{c|p.first}} to the first element of {{c|*this}} and {{c|p.second}} to the second element of {{c|*this}}.

6) Assigns {{c|std::forward&lt;U1&gt;(p.first)}} to the first element of {{c|*this}} and {{c|std::forward&lt;U2&gt;(p.second)}} to the second element of {{c|*this}}.

===Parameters===
{{par begin}}
{{par | other | tuple to replace the contents of this tuple }}
{{par | p | pair to replace the contents of this 2-tuple }}
{{par end}} 

===Return value===
{{c|*this}}

===Exceptions===
1) (none)

2) {{noexcept|
    is_nothrow_move_assignable&lt;T0&gt;::value &amp;&amp;
    is_nothrow_move_assignable&lt;T1&gt;::value &amp;&amp;
    is_nothrow_move_assignable&lt;T2&gt;::value &amp;&amp;
    ...
}}

3-5) (none)

6) {{noexcept}}

===Example===
{{example
 | code=
 | output=
}}

===See also===

{{dsc begin}}
{{dsc end}}

[[de:cpp/utility/tuple/operator=]]
[[es:cpp/utility/tuple/operator=]]
[[fr:cpp/utility/tuple/operator=]]
[[it:cpp/utility/tuple/operator=]]
[[ja:cpp/utility/tuple/operator=]]
[[pt:cpp/utility/tuple/operator=]]
[[ru:cpp/utility/tuple/operator=]]
[[zh:cpp/utility/tuple/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/operator cmp</title>
    <ns>0</ns>
    <id>2690</id>
    <revision>
      <id>65302</id>
      <parentid>64638</parentid>
      <timestamp>2013-09-07T16:42:49Z</timestamp>
      <contributor>
        <username>K-ballo</username>
        <id>2143</id>
      </contributor>
      <comment>Fixed return values 4 and 6</comment>
      <text xml:space="preserve" bytes="4735">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;=&lt;small&gt;(std::tuple&lt;/small&gt;)}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl rev begin}}
{{dcl | num=1 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator==( const tuple&lt;TTypes...&gt;&amp; lhs, 
                 const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=1 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator==( const tuple&lt;TTypes...&gt;&amp; lhs, 
                           const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=2 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator!=( const tuple&lt;TTypes...&gt;&amp; lhs,
                 const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator!=( const tuple&lt;TTypes...&gt;&amp; lhs,
                           const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator&lt;( const tuple&lt;TTypes...&gt;&amp; lhs,
                const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=3 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator&lt;( const tuple&lt;TTypes...&gt;&amp; lhs,
                          const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=4 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator&lt;=( const tuple&lt;TTypes...&gt;&amp; lhs,
                 const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator&lt;=( const tuple&lt;TTypes...&gt;&amp; lhs,
                           const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=5 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator&gt;( const tuple&lt;TTypes...&gt;&amp; lhs,
                const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=5 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator&gt;( const tuple&lt;TTypes...&gt;&amp; lhs,
                          const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=6 | since=c++11 | until=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
bool operator&gt;=( const tuple&lt;TTypes...&gt;&amp; lhs, 
                 const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl | num=6 | since=c++14 | 1=
template&lt; class... TTypes, class... UTypes &gt;
constexpr bool operator&gt;=( const tuple&lt;TTypes...&gt;&amp; lhs, 
                           const tuple&lt;UTypes...&gt;&amp; rhs );
}}
{{dcl rev end}}
{{dcl end}}

1-2) Compares every element of the tuple {{tt|lhs}} with the corresponding element of the tuple {{tt|rhs}}.

3-6) Compares {{tt|lhs}} and {{tt|rhs}} lexicographically, that is, compares the first elements, if they are equivalent, compares the second elements, if those are equivalent, compares the third elements, and so on.

All comparison operators are short-circuited; they do not access tuple elements beyond what is necessary to determine the result of the comparison.

===Parameters===
{{par begin}}
{{par | lhs, rhs | tuples to compare }}
{{par end}} 

===Return value===

1) {{c|true}} if {{c|1=std::get&lt;i&gt;(lhs) == std::get&lt;i&gt;(rhs)}} for all i in {{tt|[0, sizeof...(Types))}}, otherwise {{c|false}}. For two empty tuples returns {{c|true}}.

2) {{c|1=!(lhs == rhs)}}

3) {{c|1=(bool)(std::get&lt;0&gt;(lhs) &lt; std::get&lt;0&gt;(rhs)) {{!!}} (!(bool)(std::get&lt;0&gt;(rhs) &lt; std::get&lt;0&gt;(lhs)) &amp;&amp; lhstail &lt; rhstail)}}, where {{tt|lhstail}} is lhs without its first element, and {{tt|rhstail}} is rhs without its first element. For two empty tuples, returns {{c|false}}.

4) {{c|!(rhs &lt; lhs)}}

5) {{c|rhs &lt; lhs}}

6) {{c|!(lhs &lt; rhs)}}

===Example===
{{example
 | Because operator&lt; is defined for tuples, containers of tuples can be sorted.
 | code=
#include &lt;iostream&gt;
#include &lt;tuple&gt;
#include &lt;vector&gt;
#include &lt;algorithm&gt;
int main()
{
    std::vector&lt;std::tuple&lt;int, std::string, float&gt;&gt; v;
    v.emplace_back(2, &quot;baz&quot;, -0.1);
    v.emplace_back(2, &quot;bar&quot;, 3.14);
    v.emplace_back(1, &quot;foo&quot;, 100.1);
    std::sort(v.begin(), v.end());

    for(auto p: v) {
        std::cout &lt;&lt; &quot;(&quot; &lt;&lt; std::get&lt;0&gt;(p) &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(p)
                  &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;2&gt;(p) &lt;&lt; &quot;)\n&quot;;
    }
}
 | output=
(1, foo, 100.1)
(2, bar, 3.14)
(2, baz, -0.1)
}}

===See also===

{{dsc begin}}
{{dsc end}}

[[de:cpp/utility/tuple/operator cmp]]
[[es:cpp/utility/tuple/operator cmp]]
[[fr:cpp/utility/tuple/operator cmp]]
[[it:cpp/utility/tuple/operator cmp]]
[[ja:cpp/utility/tuple/operator cmp]]
[[pt:cpp/utility/tuple/operator cmp]]
[[ru:cpp/utility/tuple/operator cmp]]
[[zh:cpp/utility/tuple/operator cmp]]</text>
      <sha1>4ipj3untg3bhygfmjbh6akx1mn19azv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/operator comp</title>
    <ns>0</ns>
    <id>4218</id>
    <redirect title="cpp/utility/tuple/operator cmp" />
    <revision>
      <id>15281</id>
      <timestamp>2011-12-08T01:22:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/tuple/operator comp]] to [[cpp/utility/tuple/operator cmp]]: comp-&gt;cmp</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[cpp/utility/tuple/operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/std swap</title>
    <ns>0</ns>
    <id>3473</id>
    <redirect title="cpp/utility/tuple/swap2" />
    <revision>
      <id>13035</id>
      <timestamp>2011-11-03T18:42:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/tuple/std swap]] to [[cpp/utility/tuple/swap2]]: consistency</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/utility/tuple/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/swap</title>
    <ns>0</ns>
    <id>2677</id>
    <revision>
      <id>63121</id>
      <parentid>51749</parentid>
      <timestamp>2013-07-01T23:55:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1283">{{cpp/utility/tuple/title | swap}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | since=c++11 | 1=
void swap( tuple&amp; other );
}}
{{dcl end}}

Calls {{lc|std::swap}} for each element in {{c|*this}} and its corresponding element in {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | tuple of values to swap }}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept|
    noexcept(swap(std::declval&lt;T0&amp;&gt;&gt;(), std::declval&lt;T0&amp;&gt;())) &amp;&amp;
    noexcept(swap(std::declval&lt;T1&amp;&gt;&gt;(), std::declval&lt;T1&amp;&gt;())) &amp;&amp;
    noexcept(swap(std::declval&lt;T2&amp;&gt;&gt;(), std::declval&lt;T2&amp;&gt;())) &amp;&amp;
    ...
}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;tuple&gt;
#include &lt;string&gt;

int main()
{
    std::tuple&lt;int, std::string, float&gt; p1, p2;
    p1 = std::make_tuple(10, &quot;test&quot;, 3.14);
    p2.swap(p1);
    std::cout &lt;&lt; &quot;(&quot;  &lt;&lt; std::get&lt;0&gt;(p2)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;1&gt;(p2)
              &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;2&gt;(p2) &lt;&lt; &quot;)\n&quot;;
}
 | output=
(10, test, 3.14)
}}

===See also===

{{dsc begin}}
{{dsc end}}

[[de:cpp/utility/tuple/swap]]
[[es:cpp/utility/tuple/swap]]
[[fr:cpp/utility/tuple/swap]]
[[it:cpp/utility/tuple/swap]]
[[ja:cpp/utility/tuple/swap]]
[[pt:cpp/utility/tuple/swap]]
[[ru:cpp/utility/tuple/swap]]
[[zh:cpp/utility/tuple/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/swap2</title>
    <ns>0</ns>
    <id>2691</id>
    <revision>
      <id>63122</id>
      <parentid>51750</parentid>
      <timestamp>2013-07-01T23:55:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="766">{{cpp/title | swap&lt;small&gt;(std::tuple)&lt;/small&gt;}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class... Types &gt;
void swap( tuple&lt;Types...&gt;&amp; lhs, tuple&lt;Types...&gt;&amp; rhs );
}}
{{dcl end}}

Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Equivalent to {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | tuples whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Exceptions===
{{noexcept|noexcept(lhs.swap(rhs))}}

===See also===

{{dsc begin}}
{{dsc end}}

[[de:cpp/utility/tuple/swap2]]
[[es:cpp/utility/tuple/swap2]]
[[fr:cpp/utility/tuple/swap2]]
[[it:cpp/utility/tuple/swap2]]
[[ja:cpp/utility/tuple/swap2]]
[[pt:cpp/utility/tuple/swap2]]
[[ru:cpp/utility/tuple/swap2]]
[[zh:cpp/utility/tuple/swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/tie</title>
    <ns>0</ns>
    <id>2679</id>
    <revision>
      <id>68199</id>
      <parentid>63123</parentid>
      <timestamp>2014-03-18T03:07:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>constexpr in c++14 (lwg 2301)</comment>
      <text xml:space="preserve" bytes="1975">{{cpp/title|tie}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |1=
template&lt; class... Types &gt;
tuple&lt;Types&amp;...&gt; tie( Types&amp;... args );
}}
{{dcl | since=c++14 |1=
template&lt; class... Types &gt;
constexpr tuple&lt;Types&amp;...&gt; tie( Types&amp;... args );
}}
{{dcl rev end}}
{{dcl end}}

Creates a tuple of lvalue references to its arguments or instances of {{lc|std::ignore}}.

===Parameters===
{{par begin}}
{{par | args | zero or more lvalue arguments to construct the tuple from}}
{{par end}}

===Return value===
A {{lc|std::tuple}} object containing lvalue references.

===Exceptions===
{{noexcept}}

===Example===
{{example
 | {{lc|std::tie}} can be used to introduce lexicographical comparison to a struct or to unpack a tuple:
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;set&gt;
#include &lt;tuple&gt;

struct S {
    int n;
    std::string s;
    float d;
    bool operator&lt;(const S&amp; rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) &lt; std::tie(rhs.n, rhs.s, rhs.d);
    }
};

int main()
{
    std::set&lt;S&gt; set_of_s; // S is LessThanComparable

    S value{42, &quot;Test&quot;, 3.14};
    std::set&lt;S&gt;::iterator iter;
    bool inserted;

    // unpacks the return value of insert into iter and inserted
    std::tie(iter, inserted) = set_of_s.insert(value);

    if (inserted)
        std::cout &lt;&lt; &quot;Value was inserted successfully\n&quot;;
}
 | output=
Value was inserted successfully
}}

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tuple_cat}}
{{dsc inc | cpp/utility/tuple/dsc ignore}}
{{dsc end}}

[[de:cpp/utility/tuple/tie]]
[[es:cpp/utility/tuple/tie]]
[[fr:cpp/utility/tuple/tie]]
[[it:cpp/utility/tuple/tie]]
[[ja:cpp/utility/tuple/tie]]
[[pt:cpp/utility/tuple/tie]]
[[ru:cpp/utility/tuple/tie]]
[[zh:cpp/utility/tuple/tie]]</text>
      <sha1>m787767pv8kf17t2gh6sribz3hoeadf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/tuple</title>
    <ns>0</ns>
    <id>2675</id>
    <revision>
      <id>64639</id>
      <parentid>63124</parentid>
      <timestamp>2013-08-24T13:10:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++14 constexpr</comment>
      <text xml:space="preserve" bytes="7202">{{cpp/utility/tuple/title | tuple}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple }}
{{dcl | num=1 | since=c++11 | 1=
constexpr tuple();
}}
{{dcl rev begin}}
{{dcl | num=2 | since=c++11 | until=c++14 | 1=
explicit tuple( const Types&amp;... args );
}}
{{dcl | num=2 | since=c++14 | 1=
explicit constexpr tuple( const Types&amp;... args );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=3 | since=c++11 | until=c++14 | 1=
template&lt; class... UTypes &gt;
explicit tuple( UTypes&amp;&amp;... args );
}}
{{dcl | num=3 | since=c++14 | 1=
template&lt; class... UTypes &gt;
explicit constexpr tuple( UTypes&amp;&amp;... args );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=4 | since=c++11 | until=c++14 | 1=
template&lt; class... UTypes &gt;
tuple( const tuple&lt;UTypes...&gt;&amp; other );
}}
{{dcl | num=4 | since=c++14 | 1=
template&lt; class... UTypes &gt;
constexpr tuple( const tuple&lt;UTypes...&gt;&amp; other );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=5 | since=c++11 | until=c++14 | 1=
template &lt;class... UTypes&gt;
tuple( tuple&lt;UTypes...&gt;&amp;&amp; other );
}}
{{dcl | num=5 | since=c++14 | 1=
template &lt;class... UTypes&gt;
constexpr tuple( tuple&lt;UTypes...&gt;&amp;&amp; other );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=6 | since=c++11 | until=c++14 | 1=
template&lt; class U1, class U2 &gt;
tuple( const pair&lt;U1,U2&gt;&amp; p );
}}
{{dcl | num=6 | since=c++14 | 1=
template&lt; class U1, class U2 &gt;
constexpr tuple( const pair&lt;U1,U2&gt;&amp; p );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | num=7 | since=c++11 | until=c++14 | 1=
template&lt; class U1, class U2 &gt;
tuple( pair&lt;U1,U2&gt;&amp;&amp; p );
}}
{{dcl | num=7 | since=c++14 | 1=
template&lt; class U1, class U2 &gt;
constexpr tuple( pair&lt;U1,U2&gt;&amp;&amp; p );
}}
{{dcl rev end}}
{{dcl | num=8 | since=c++11 | 1=
tuple( const tuple&amp; other ) = default;
}}
{{dcl | num=9 | since=c++11 | 1=
tuple( tuple&amp;&amp; other ) = default;
}}
{{dcl | num=10 | since=c++11 | 1=
template&lt; class Alloc &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a );
}}
{{dcl | num=11 | since=c++11 | 1=
template&lt; class Alloc &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, const Types&amp;... args );
}}
{{dcl | num=12 | since=c++11 | 1=
template&lt; class Alloc, class... UTypes &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, UTypes&amp;&amp;... args );
}}
{{dcl | num=13 | since=c++11 | 1=
template &lt;class Alloc, class... UTypes&gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, const tuple&lt;UTypes...&gt;&amp; other );
}}
{{dcl | num=14 | since=c++11 | 1=
template&lt; class Alloc, class... UTypes &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, tuple&lt;UTypes...&gt;&amp;&amp; other );
}}
{{dcl | num=15 | since=c++11 | 1=
template&lt; class Alloc, class U1, class U2 &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, const pair&lt;U1, U2&gt;&amp; p );
}}
{{dcl | num=16 | since=c++11 | 1=
template&lt; class Alloc, class U1, class U2 &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, pair&lt;U1, U2&gt;&amp;&amp; p );
}}
{{dcl | num=17 | since=c++11 | 1=
template&lt; class Alloc &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, const tuple&amp; other );
}}
{{dcl | num=18 | since=c++11 | 1=
template&lt; class Alloc &gt;
tuple( std::allocator_arg_t, const Alloc&amp; a, tuple&amp;&amp; other );
}}
{{dcl end}}

Constructs a new tuple. 

1) Default constructor. Value-initializes all elements.

2) Initializes each element of the tuple with the corresponding parameter.

3) Initializes each element of the tuple with the corresponding value in {{c|std::forward&lt;Utypes&gt;(args)}}.

4) For all {{tt|i}} in {{c|sizeof...(UTypes)}}, initializes ith element of the tuple with {{c|std::get&lt;i&gt;(other)}}.

5) For all {{tt|i}} in {{c|sizeof...(UTypes)}}, initializes ith element of the tuple with {{c|std::forward&lt;Ui&gt;(std::get&lt;i&gt;(other))}}.

6) Constructs a 2-element tuple with the first element constructed from {{tt|p.first}} and the second element from {{tt|p.second}}

7) Constructs a 2-element tuple with the first element constructed from {{c|std::forward&lt;U1&gt;(p.first)}} and the second element from {{c|std::forward&lt;U2&gt;(p.second)}}

8) Compiler-generated copy constructor. Initializes each element of the tuple with the corresponding element of {{tt|other}}. This constructor is {{c|constexpr}} if every operation it performs is {{c|constexpr}}. For the empty tuple {{c|std::tuple&lt;&gt;}}, it is {{c|constexpr}}.

9) Compiler-generated move constructor. Initializes each ith element of the tuple with {{c|std::forward&lt;Ui&gt;(std::get&lt;i&gt;(other))}}. This constructor is {{c|constexpr}} if every operation it performs is {{c|constexpr}}. For the empty tuple {{c|std::tuple&lt;&gt;}}, it is {{c|constexpr}}.

10 - 18) Identical to 1-9 except each element is created by ''uses-allocator construction'', that is, the Allocator object {{tt|a}} is passed as an additional argument to the constructor of each element for which {{c|std::uses_allocator&lt;Ui, Alloc&gt;::value}} is {{c|true}}.

===Parameters===

{{par begin}}
{{par | args | values used to initialize each element of the tuple }}
{{par | other | a tuple of values used to initialize each element of the tupe }}
{{par | p | pair of values used to initialize both elements of this 2-tuple }}
{{par | a | allocator to use in uses-allocator construction }}
{{par end}} 

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;vector&gt;
#include &lt;tuple&gt;
#include &lt;memory&gt;

// helper function to print a tuple of any size
template&lt;class Tuple, std::size_t N&gt;
struct TuplePrinter {
    static void print(const Tuple&amp; t) 
    {
        TuplePrinter&lt;Tuple, N-1&gt;::print(t);
        std::cout &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;N-1&gt;(t);
    }
};

template&lt;class Tuple&gt;
struct TuplePrinter&lt;Tuple, 1&gt;{
    static void print(const Tuple&amp; t) 
    {
        std::cout &lt;&lt; std::get&lt;0&gt;(t);
    }
};

template&lt;class... Args&gt;
void print(const std::tuple&lt;Args...&gt;&amp; t) 
{
    std::cout &lt;&lt; &quot;(&quot;;
    TuplePrinter&lt;decltype(t), sizeof...(Args)&gt;::print(t);
    std::cout &lt;&lt; &quot;)\n&quot;;
}
// end helper function

int main()
{
    std::tuple&lt;int, std::string, double&gt; t1;
    std::cout &lt;&lt; &quot;Value-initialized: &quot;; print(t1);
    std::tuple&lt;int, std::string, double&gt; t2(42, &quot;Test&quot;, -3.14);
    std::cout &lt;&lt; &quot;Initialized with values: &quot;; print(t2);
    std::tuple&lt;char, std::string, int&gt; t3(t2);
    std::cout &lt;&lt; &quot;Implicitly converted: &quot;; print(t3);
    std::tuple&lt;int, double&gt; t4(std::make_pair(42, 3.14));
    std::cout &lt;&lt; &quot;Constructed from a pair&quot;; print(t4);

    // given Allocator my_alloc with a single-argument constructor my_alloc(int)
    // use my_alloc(1) to allocate 10 ints in a vector
    std::vector&lt;int, my_alloc&gt; v(10, 1, my_alloc(1));
    // use my_alloc(2) to allocate 10 ints in a vector in a tuple
    std::tuple&lt;int, std::vector&lt;int, my_alloc&gt;, double&gt; t5(std::allocator_arg,
                                                           my_alloc(2), 42, v,  -3.14);
}
 | output=
Value-initialized: (0, , 0)
Initialized with values: (42, Test, -3.14)
Implicitly converted: (*, Test, -3)
Constructed from a pair(42, 3.14)
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc end}}

[[de:cpp/utility/tuple/tuple]]
[[es:cpp/utility/tuple/tuple]]
[[fr:cpp/utility/tuple/tuple]]
[[it:cpp/utility/tuple/tuple]]
[[ja:cpp/utility/tuple/tuple]]
[[pt:cpp/utility/tuple/tuple]]
[[ru:cpp/utility/tuple/tuple]]
[[zh:cpp/utility/tuple/tuple]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/tuple cat</title>
    <ns>0</ns>
    <id>2682</id>
    <revision>
      <id>72415</id>
      <parentid>64637</parentid>
      <timestamp>2014-08-20T14:58:05Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2133">{{cpp/title|tuple_cat}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
template&lt; class... Tuples &gt;
std::tuple&lt;CTypes...&gt; tuple_cat(Tuples&amp;&amp;... args);
}}
{{dcl | since=c++14 |
template&lt; class... Tuples &gt;
constexpr std::tuple&lt;CTypes...&gt; tuple_cat(Tuples&amp;&amp;... args);
}}
{{dcl rev end}}
{{dcl end}}

Constructs a tuple that is a concatenation of all tuples in {{tt|args}}.

===Parameters===
{{par begin}}
{{par | args | zero or more tuples to concatenate}}
{{par end}}

===Return value===
A {{lc|std::tuple}} object composed of all elements of all argument tuples constructed from {{c|std::get&lt;i&gt;(std::forward&lt;Ti&gt;(arg))}} for each individual element.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;tuple&gt;
#include &lt;string&gt;

// helper function to print a tuple of any size
template&lt;class Tuple, std::size_t N&gt;
struct TuplePrinter {
    static void print(const Tuple&amp; t) 
    {
        TuplePrinter&lt;Tuple, N-1&gt;::print(t);
        std::cout &lt;&lt; &quot;, &quot; &lt;&lt; std::get&lt;N-1&gt;(t);
    }
};

template&lt;class Tuple&gt;
struct TuplePrinter&lt;Tuple, 1&gt; {
    static void print(const Tuple&amp; t) 
    {
        std::cout &lt;&lt; std::get&lt;0&gt;(t);
    }
};

template&lt;class... Args&gt;
void print(const std::tuple&lt;Args...&gt;&amp; t) 
{
    std::cout &lt;&lt; &quot;(&quot;;
    TuplePrinter&lt;decltype(t), sizeof...(Args)&gt;::print(t);
    std::cout &lt;&lt; &quot;)\n&quot;;
}
// end helper function

int main()
{
    std::tuple&lt;int, std::string, float&gt; t1(10, &quot;Test&quot;, 3.14);
    int n = 7;
    auto t2 = std::tuple_cat(t1, std::make_pair(&quot;Foo&quot;, &quot;bar&quot;), t1, std::tie(n));
    n = 10;
    print(t2);
}
 | output=
(10, Test, 3.14, Foo, bar, 10, Test, 3.14, 10)
}}
=== See also ===
{{dsc begin}}
{{dsc inc | cpp/utility/tuple/dsc make_tuple}}
{{dsc inc | cpp/utility/tuple/dsc tie}}
{{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}}
{{dsc end}}

[[de:cpp/utility/tuple/tuple cat]]
[[es:cpp/utility/tuple/tuple cat]]
[[fr:cpp/utility/tuple/tuple cat]]
[[it:cpp/utility/tuple/tuple cat]]
[[ja:cpp/utility/tuple/tuple cat]]
[[pt:cpp/utility/tuple/tuple cat]]
[[ru:cpp/utility/tuple/tuple cat]]
[[zh:cpp/utility/tuple/tuple cat]]</text>
      <sha1>b7u4wywcqch5l6ti7z3kxk6fjiep2y8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/tuple element</title>
    <ns>0</ns>
    <id>2700</id>
    <revision>
      <id>72390</id>
      <parentid>69485</parentid>
      <timestamp>2014-08-19T12:56:07Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>n3887 added tuple_element_t</comment>
      <text xml:space="preserve" bytes="2580">{{cpp/title|tuple_element{{small|&lt;std::tuple&gt;}}}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; std::size_t I, class T &gt;
class tuple_element; /* undefined */
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; std::size_t I, class... Types &gt;
class tuple_element&lt; I, tuple&lt;Types...&gt; &gt;;
}}
{{dcl | num=3 | since=c++11 | 1=
template&lt; std::size_t I, class T &gt;
class tuple_element&lt; I, const T &gt; {
  typedef typename
      std::add_const&lt;typename std::tuple_element&lt;I, T&gt;::type&gt;::type type;
};
}}
{{dcl | num=4 | since=c++11 | 1=
template&lt; std::size_t I, class T &gt;
class tuple_element&lt; I, volatile T &gt; {
  typedef typename
      std::add_volatile&lt;typename std::tuple_element&lt;I, T&gt;::type&gt;::type type;
};
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; std::size_t I, class T &gt;
class tuple_element&lt; I, const volatile T &gt; {
  typedef typename
      std::add_cv&lt;typename std::tuple_element&lt;I, T&gt;::type&gt;::type type;
};
}}
{{dcl end}}

Provides compile-type indexed access to the types of the elements of the tuple.

===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | type | the type of {{tt|I}}th element of the tuple, where {{tt|I}} is in {{tt|[0, sizeof...(Types))}} }}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl | since=c++14 | 1=
template &lt;std::size_t I, class T&gt;
using tuple_element_t = typename tuple_element&lt;I, T&gt;::type;
}}
{{dcl end}}

===Possible implementation===
{{eq fun
 | 1=
template&lt; std::size_t I, class T &gt;
struct tuple_element;

// recursive case
template&lt; std::size_t I, class Head, class... Tail &gt;
struct tuple_element&lt;I, std::tuple&lt;Head, Tail...&gt;&gt;
    : std::tuple_element&lt;I-1, std::tuple&lt;Tail...&gt;&gt; { };

// base case
template&lt; class Head, class... Tail &gt;
struct tuple_element&lt;0, std::tuple&lt;Head, Tail...&gt;&gt; {
   typedef Head type;
};
}}

===Example===
{{example |
 | code=
#include &lt;tuple&gt;

template &lt;class... Args&gt;
struct type_list
{
   template &lt;std::size_t N&gt;
   using type = typename std::tuple_element&lt;N, std::tuple&lt;Args...&gt;&gt;::type;
};

int main()
{
   type_list&lt;int, char, bool&gt;::type&lt;2&gt; x = true;
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/array/dsc tuple_element}}
{{dsc inc | cpp/utility/pair/dsc tuple_element}}
{{dsc end}}

[[de:cpp/utility/tuple/tuple element]]
[[es:cpp/utility/tuple/tuple element]]
[[fr:cpp/utility/tuple/tuple element]]
[[it:cpp/utility/tuple/tuple element]]
[[ja:cpp/utility/tuple/tuple element]]
[[pt:cpp/utility/tuple/tuple element]]
[[ru:cpp/utility/tuple/tuple element]]
[[zh:cpp/utility/tuple/tuple element]]</text>
      <sha1>so418q7qx9yjh0hit17tbstxstnfys4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/tuple size</title>
    <ns>0</ns>
    <id>2699</id>
    <revision>
      <id>68202</id>
      <parentid>65403</parentid>
      <timestamp>2014-03-18T03:21:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>apply LWG 2313</comment>
      <text xml:space="preserve" bytes="2067">{{cpp/title|tuple_size&lt;small&gt;&lt;std::tuple&gt;&lt;/small&gt;}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | num=1 | since=c++11 |1=
template&lt; class T &gt;
class tuple_size; /*undefined*/
}}
{{dcl | num=2 | since=c++11 |1=
template&lt; class... Types &gt;
class tuple_size&lt; std::tuple&lt;Types...&gt; &gt;
 : public std::integral_constant&lt;std::size_t, sizeof...(Types)&gt; { };
}}
{{dcl | num=3 | since=c++11 |1=
template&lt; class T &gt;
class tuple_size&lt;const T&gt;
 : public std::integral_constant&lt;std::size_t, tuple_size&lt;T&gt;::value&gt; { };
}}
{{dcl | num=4 | since=c++11 |1=
template&lt; class T &gt;
class tuple_size&lt; volatile T &gt;
 : public std::integral_constant&lt;std::size_t, tuple_size&lt;T&gt;::value&gt; { };
}}
{{dcl | num=5 | since=c++11 |1=
template&lt; class T &gt;
class tuple_size&lt; const volatile T &gt;
 : public std::integral_constant&lt;std::size_t, tuple_size&lt;T&gt;::value&gt; { };
}}
{{dcl end}}

Provides access to the number of elements in a tuple as a compile-time constant expression. 

{{cpp/types/integral_constant/inherit2 | {{tt|sizeof...(Types)}}|std::size_t}}

===Notes===
All specializations of {{tt|std::tuple_size}} satisfy {{concept|UnaryTypeTrait}} with  ''BaseCharacteristic'' {{tt|std::integral_constant&lt;std::size_t, N&gt;}} for some {{tt|N}}.

===Example===
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;tuple&gt;

template &lt;class T&gt;
void test(T t)
{
    int a[std::tuple_size&lt;T&gt;::value]; // can be used at compile time

    std::cout &lt;&lt; std::tuple_size&lt;T&gt;::value &lt;&lt; '\n'; // or at run time
}

int main()
{
    test(std::make_tuple(1, 2, 3.14));
}
 | output=
3
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/array/dsc tuple_size}}
{{dsc inc | cpp/utility/pair/dsc tuple_size}}
{{dsc inc | cpp/utility/tuple/dsc get}}
{{dsc inc | cpp/utility/tuple/dsc tuple_element}}
{{dsc end}}

[[de:cpp/utility/tuple/tuple size]]
[[es:cpp/utility/tuple/tuple size]]
[[fr:cpp/utility/tuple/tuple size]]
[[it:cpp/utility/tuple/tuple size]]
[[ja:cpp/utility/tuple/tuple size]]
[[pt:cpp/utility/tuple/tuple size]]
[[ru:cpp/utility/tuple/tuple size]]
[[zh:cpp/utility/tuple/tuple size]]</text>
      <sha1>ice05sxi8leiss18b1kl9l8cp18vzg7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/tuple/uses allocator</title>
    <ns>0</ns>
    <id>2696</id>
    <revision>
      <id>63128</id>
      <parentid>59705</parentid>
      <timestamp>2013-07-01T23:55:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{dcl}} template.</comment>
      <text xml:space="preserve" bytes="1504">{{cpp/title|uses_allocator&lt;small&gt;&lt;std::tuple&gt;&lt;/small&gt;}}
{{cpp/utility/tuple/navbar}}
{{dcl begin}}
{{dcl header | tuple}}
{{dcl | since=c++11 |
template&lt; class... Types, class Alloc &gt;
struct uses_allocator&lt; std::tuple&lt;Types...&gt;, Alloc &gt; : std::true_type { };
}}
{{dcl end}}

This specialization of {{lc|std::uses_allocator}} informs other library components that tuples support ''uses-allocator construction'', even though they do not have a nested {{tt|allocator_type}}.

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===Example===
{{example
 | 
 | code=
// myalloc is a stateful Allocator with a single-argument constructor
// that takes an int. It has no default constructor.

    typedef std::vector&lt;int, myalloc&lt;int&gt;&gt; innervector_t;
    typedef std::tuple&lt;int, innervector_t&gt; elem_t;
    typedef std::scoped_allocator_adaptor&lt; myalloc&lt;elem_t&gt;, myalloc&lt;int&gt;&gt; Alloc;
    Alloc a(1,2);
    std::vector&lt;elem_t, Alloc&gt; v(a);
    v.resize(1);                  // uses allocator #1 for elements of v
    std::get&lt;1&gt;(v[0]).resize(10); // uses allocator #2 for innervector_t
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}

[[de:cpp/utility/tuple/uses allocator]]
[[es:cpp/utility/tuple/uses allocator]]
[[fr:cpp/utility/tuple/uses allocator]]
[[it:cpp/utility/tuple/uses allocator]]
[[ja:cpp/utility/tuple/uses allocator]]
[[pt:cpp/utility/tuple/uses allocator]]
[[ru:cpp/utility/tuple/uses allocator]]
[[zh:cpp/utility/tuple/uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/types</title>
    <ns>0</ns>
    <id>2164</id>
    <redirect title="cpp/types" />
    <revision>
      <id>4876</id>
      <timestamp>2011-07-07T12:16:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/types]] to [[cpp/types]]: Merge basic types, RTTI and type traits into one page</comment>
      <text xml:space="preserve" bytes="23">#REDIRECT [[cpp/types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/types/climits</title>
    <ns>0</ns>
    <id>2165</id>
    <redirect title="cpp/types/climits" />
    <revision>
      <id>4878</id>
      <timestamp>2011-07-07T12:16:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/types/climits]] to [[cpp/types/climits]]: Merge basic types, RTTI and type traits into one page</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/types/climits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/types/integer</title>
    <ns>0</ns>
    <id>2166</id>
    <redirect title="cpp/types/integer" />
    <revision>
      <id>4880</id>
      <timestamp>2011-07-07T12:16:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/types/integer]] to [[cpp/types/integer]]: Merge basic types, RTTI and type traits into one page</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[cpp/types/integer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/types/numeric limits</title>
    <ns>0</ns>
    <id>2167</id>
    <redirect title="cpp/types/numeric limits" />
    <revision>
      <id>4882</id>
      <timestamp>2011-07-07T12:16:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[cpp/utility/types/numeric limits]] to [[cpp/types/numeric limits]]: Merge basic types, RTTI and type traits into one page</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/types/numeric limits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic</title>
    <ns>0</ns>
    <id>3440</id>
    <revision>
      <id>71748</id>
      <parentid>67770</parentid>
      <timestamp>2014-06-22T19:39:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1918">{{title|Variadic functions}}
{{cpp/utility/variadic/navbar}}

Variadic functions are functions (e.g. {{lc|std::printf}}) which take a [[cpp/language/variadic_arguments|variable number of arguments]].

To declare a variadic function, an ellipsis is used as the last parameter, e.g. {{c|int printf(const char* format, ...);}}. See [[cpp/language/variadic_arguments|Variadic arguments]] for additional detail on the syntax, automatic argument conversions and the alternatives.

To access the variadic arguments from the function body, the following library facilities are provided:

{{dsc begin}}
{{dsc header | cstdarg}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc inc | cpp/utility/variadic/dsc va_list}}
{{dsc end}}

===Example===

{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdarg&gt;

void simple_printf(const char* fmt...)
{
    va_list args;
    va_start(args, fmt);

    while (*fmt != '\0') {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            std::cout &lt;&lt; i &lt;&lt; '\n';
        } else if (*fmt == 'c') {
            // note automatic conversion to integral type
            int c = va_arg(args, int);
            std::cout &lt;&lt; static_cast&lt;char&gt;(c) &lt;&lt; '\n';
        } else if (*fmt == 'f') {
            double d = va_arg(args, double);
            std::cout &lt;&lt; d &lt;&lt; '\n';
        }
        ++fmt;
    }

    va_end(args);
}

int main()
{
    simple_printf(&quot;dcff&quot;, 3, 'a', 1.999, 42.5); 
}
 | output=
3
a
1.999
42.5
}}

===See also===
{{dsc begin}}
{{dsc see c | c/variadic | Variadic functions}}
{{dsc end}}

[[de:cpp/utility/variadic]]
[[es:cpp/utility/variadic]]
[[fr:cpp/utility/variadic]]
[[it:cpp/utility/variadic]]
[[ja:cpp/utility/variadic]]
[[pt:cpp/utility/variadic]]
[[ru:cpp/utility/variadic]]
[[zh:cpp/utility/variadic]]</text>
      <sha1>sqlny7mlpggo52bjx6shabx8lefka1m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic/va arg</title>
    <ns>0</ns>
    <id>8535</id>
    <revision>
      <id>71819</id>
      <parentid>65489</parentid>
      <timestamp>2014-06-25T15:07:39Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="2257">{{ctitle | n={{trim|va_arg}} }}
{{cpp/utility/variadic/navbar}}
{{dcl begin}}
{{dcl header | cstdarg}}
{{dcl | 
T va_arg( va_list ap, T );
}}
{{dcl end}}

The {{tt|va_arg}} macro expands to an expression of type {{tt|T}} that corresponds to the next parameter from the {{lc|va_list}} {{tt|ap}}.

Prior to calling {{tt|va_arg}}, {{tt|ap}} must be initialized by a call to either {{lc|va_start}} or {{lc|va_copy}}, with no intervening call to {{lc|va_end}}.  Each invocation of the {{tt|va_arg}} macro modifies {{tt|ap}} to point to the next variable argument.

If {{tt|va_arg}} is called when there are no more arguments in {{tt|ap}}, or if the type of the next argument in {{tt|ap}} (after promotions) is not compatible with {{tt|T}}, the behavior is undefined, unless:

* one type is a signed integer type, the other type is the corresponding unsigned integer type, and the value is representable in both types; or
* one type is pointer to {{c|void}} and the other is a pointer to a character type.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type}}
{{par | T | the type of the next parameter in {{tt|ap}} }}
{{par end}}

===Expanded value===
the next variable parameter in {{tt|ap}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdarg&gt;
#include &lt;cmath&gt;

double stddev(int count, ...) 
{
    double sum = 0;
    double sum_sq = 0;
    va_list args;
    va_start(args, count);
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args, double);
        sum += num;
        sum_sq += num*num;
    }
    va_end(args);
    return std::sqrt(sum_sq/count - (sum/count)*(sum/count));
}

int main() 
{
    std::cout &lt;&lt; stddev(4, 25.0, 27.3, 26.9, 25.7) &lt;&lt; '\n';
}
 | output=
0.920258
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc see c | c/variadic/va_arg | va_arg}}
{{dsc end}}

[[de:cpp/utility/variadic/va arg]]
[[es:cpp/utility/variadic/va arg]]
[[fr:cpp/utility/variadic/va arg]]
[[it:cpp/utility/variadic/va arg]]
[[ja:cpp/utility/variadic/va arg]]
[[pt:cpp/utility/variadic/va arg]]
[[ru:cpp/utility/variadic/va arg]]
[[zh:cpp/utility/variadic/va arg]]</text>
      <sha1>nregvvvofmueosyn6wkcvnkgtlha1pz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic/va copy</title>
    <ns>0</ns>
    <id>8538</id>
    <revision>
      <id>71820</id>
      <parentid>63129</parentid>
      <timestamp>2014-06-25T15:10:01Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1907">{{ctitle | n={{trim|va_copy}} }}
{{cpp/utility/variadic/navbar}}
{{dcl begin}}
{{dcl header | cstdarg}}
{{dcl | since=c++11 | 
void va_copy( va_list dest, va_list src );
}}
{{dcl end}}

The {{tt|va_copy}} macro copies {{tt|src}} to {{tt|dest}}.

{{lc|va_end}} should be called on {{tt|dest}} before the function returns or any subsequent re-initialization of {{tt|dest}} (via calls to {{lc|va_start}} or {{lc|va_copy}}).

===Parameters===
{{par begin}}
{{par | dest | an instance of the {{lc|va_list}} type to initialize}}
{{par | src | the source {{lc|va_list}} that will be used to initialize {{tt|dest}} }}
{{par end}}

===Expanded value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdarg&gt;
#include &lt;cmath&gt;

double sample_stddev(int count, ...) 
{
    double sum = 0;
    va_list args1;
    va_start(args1, count);
    va_list args2;
    va_copy(args2, args1);
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args1, double);
        sum += num;
    }
    va_end(args1);
    double mean = sum / count;

    double sum_sq_diff = 0;
    for (int i = 0; i &lt; count; ++i) {
        double num = va_arg(args2, double);
        sum_sq_diff += (num-mean) * (num-mean);
    }
    va_end(args2);
    return std::sqrt(sum_sq_diff / count);
}

int main() 
{
    std::cout &lt;&lt; sample_stddev(4, 25.0, 27.3, 26.9, 25.7) &lt;&lt; '\n';
}
 | output=
0.920258
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc see c | c/variadic/va_copy | va_copy}}
{{dsc end}}

[[de:cpp/utility/variadic/va copy]]
[[es:cpp/utility/variadic/va copy]]
[[fr:cpp/utility/variadic/va copy]]
[[it:cpp/utility/variadic/va copy]]
[[ja:cpp/utility/variadic/va copy]]
[[pt:cpp/utility/variadic/va copy]]
[[ru:cpp/utility/variadic/va copy]]
[[zh:cpp/utility/variadic/va copy]]</text>
      <sha1>g4hhg39tprx75un0z8bzdfvnbrs60b9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic/va end</title>
    <ns>0</ns>
    <id>8536</id>
    <revision>
      <id>71821</id>
      <parentid>59713</parentid>
      <timestamp>2014-06-25T15:11:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1200">{{ctitle | n={{trim|va_end}} }}
{{cpp/utility/variadic/navbar}}
{{dcl begin}}
{{dcl header | cstdarg}}
{{dcl | 
void va_end( va_list ap );
}}
{{dcl end}}

The {{tt|va_end}} macro performs cleanup for an {{tt|ap}} object initialized by a call to {{lc|va_start}} or {{lc|va_copy}}.  {{tt|va_end}} may modify {{tt|ap}} so that it is no longer usable.

If there is no corresponding call to {{lc|va_start}} or {{lc|va_copy}}, or if {{tt|va_end}} is not called before a function that calls {{lc|va_start}} or {{lc|va_copy}} returns, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type to clean up}}
{{par end}}

===Expanded value===
(none)

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc see c | c/variadic/va_end | va_end}}
{{dsc end}}

[[de:cpp/utility/variadic/va end]]
[[es:cpp/utility/variadic/va end]]
[[fr:cpp/utility/variadic/va end]]
[[it:cpp/utility/variadic/va end]]
[[ja:cpp/utility/variadic/va end]]
[[pt:cpp/utility/variadic/va end]]
[[ru:cpp/utility/variadic/va end]]
[[zh:cpp/utility/variadic/va end]]</text>
      <sha1>om9ax557dmpcc7yh84v25r6qijk1bvg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic/va list</title>
    <ns>0</ns>
    <id>8537</id>
    <revision>
      <id>71822</id>
      <parentid>59714</parentid>
      <timestamp>2014-06-25T15:12:48Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1174">{{ctitle | n={{trim|va_list}} }}
{{cpp/utility/variadic/navbar}}
{{ddcl | /* unspecified */ va_list;}}

{{tt|va_list}} is a complete object type suitable for holding the information needed by the macros {{lc|va_start}}, {{lc|va_copy}}, {{lc|va_arg}}, and {{lc|va_end}}.

If a {{tt|va_list}} instance is created, passed to another function, and used via {{lc|va_arg}} in that function, then any subsequent use in the calling function should be preceded by a call to {{lc|va_end}}.

It is legal to pass a pointer to a {{tt|va_list}} object to another function and then use that object after the function returns.

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/variadic/dsc va_start}}
{{dsc inc | cpp/utility/variadic/dsc va_copy}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc see c | c/variadic/va_list | va_list}}
{{dsc end}}

[[de:cpp/utility/variadic/va list]]
[[es:cpp/utility/variadic/va list]]
[[fr:cpp/utility/variadic/va list]]
[[it:cpp/utility/variadic/va list]]
[[ja:cpp/utility/variadic/va list]]
[[pt:cpp/utility/variadic/va list]]
[[ru:cpp/utility/variadic/va list]]
[[zh:cpp/utility/variadic/va list]]</text>
      <sha1>ojiflsbu2pkoolq3nb6bsqbflbp3i5b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>cpp/utility/variadic/va start</title>
    <ns>0</ns>
    <id>8534</id>
    <revision>
      <id>71818</id>
      <parentid>68196</parentid>
      <timestamp>2014-06-25T15:05:34Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>see also C</comment>
      <text xml:space="preserve" bytes="1691">{{ctitle | n={{trim|va_start}} }}
{{cpp/utility/variadic/navbar}}
{{dcl begin}}
{{dcl header | cstdarg}}
{{dcl | 
void va_start( va_list ap, parm_n );
}}
{{dcl end}}

The {{tt|va_start}} macro enables access to the variable arguments following the named argument {{tt|parm_n}}.  

{{tt|va_start}} should be invoked with an instance to a valid {{lc|va_list}} object {{tt|ap}} before any calls to {{lc|va_arg}}.

If {{tt|parm_n}} is declared with reference type, with {{tt|register}} storage class specifier, or with a type not compatible with the type that results from default argument promotions, the behavior is undefined.

===Parameters===
{{par begin}}
{{par | ap | an instance of the {{lc|va_list}} type}}
{{par | parm_n | the named parameter preceding the first variable parameter}}
{{par end}}

===Expanded value===
(none)

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;cstdarg&gt;

int add_nums(int count, ...) 
{
    int result = 0;
    va_list args;
    va_start(args, count);
    for (int i = 0; i &lt; count; ++i) {
        result += va_arg(args, int);
    }
    va_end(args);
    return result;
}

int main() 
{
    std::cout &lt;&lt; add_nums(4, 25, 25, 50, 50) &lt;&lt; '\n';
}
 | output=
150
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/utility/variadic/dsc va_arg}}
{{dsc inc | cpp/utility/variadic/dsc va_end}}
{{dsc see c | c/variadic/va_start | va_start}}
{{dsc end}}

[[de:cpp/utility/variadic/va start]]
[[es:cpp/utility/variadic/va start]]
[[fr:cpp/utility/variadic/va start]]
[[it:cpp/utility/variadic/va start]]
[[ja:cpp/utility/variadic/va start]]
[[pt:cpp/utility/variadic/va start]]
[[ru:cpp/utility/variadic/va start]]
[[zh:cpp/utility/variadic/va start]]</text>
      <sha1>shd7y2pzu0uu8w9a7rjxy0fx53r56de</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/</title>
    <ns>0</ns>
    <id>13014</id>
    <redirect title="Main Page" />
    <revision>
      <id>65673</id>
      <parentid>65672</parentid>
      <timestamp>2013-09-25T12:38:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Main Page]]</comment>
      <text xml:space="preserve" bytes="23">#redirect [[Main_Page]]</text>
      <sha1>4r564vwcqllkcrydpbribe3bxeejddh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/about/</title>
    <ns>0</ns>
    <id>7643</id>
    <redirect title="Cppreference:FAQ" />
    <revision>
      <id>28265</id>
      <parentid>28264</parentid>
      <timestamp>2012-05-01T17:28:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[Cppreference:FAQ]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/about/faq</title>
    <ns>0</ns>
    <id>7644</id>
    <redirect title="Cppreference:FAQ" />
    <revision>
      <id>28267</id>
      <parentid>28266</parentid>
      <timestamp>2012-05-01T17:28:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[Cppreference:FAQ]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/</title>
    <ns>0</ns>
    <id>7714</id>
    <redirect title="cpp/algorithm" />
    <revision>
      <id>28407</id>
      <parentid>28406</parentid>
      <timestamp>2012-05-01T17:30:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/algorithm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/accumulate</title>
    <ns>0</ns>
    <id>7645</id>
    <redirect title="cpp/algorithm/accumulate" />
    <revision>
      <id>28269</id>
      <parentid>28268</parentid>
      <timestamp>2012-05-01T17:30:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/algorithm/accumulate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/adjacent difference</title>
    <ns>0</ns>
    <id>7646</id>
    <redirect title="cpp/algorithm/adjacent difference" />
    <revision>
      <id>28271</id>
      <parentid>28270</parentid>
      <timestamp>2012-05-01T17:30:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/algorithm/adjacent_difference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/adjacent find</title>
    <ns>0</ns>
    <id>7647</id>
    <redirect title="cpp/algorithm/adjacent find" />
    <revision>
      <id>28273</id>
      <parentid>28272</parentid>
      <timestamp>2012-05-01T17:30:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/adjacent_find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/binary search</title>
    <ns>0</ns>
    <id>7648</id>
    <redirect title="cpp/algorithm/binary search" />
    <revision>
      <id>28275</id>
      <parentid>28274</parentid>
      <timestamp>2012-05-01T17:30:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/binary_search]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/bsearch</title>
    <ns>0</ns>
    <id>7649</id>
    <redirect title="cpp/algorithm/bsearch" />
    <revision>
      <id>28277</id>
      <parentid>28276</parentid>
      <timestamp>2012-05-01T17:30:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/bsearch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/copy</title>
    <ns>0</ns>
    <id>7650</id>
    <redirect title="cpp/algorithm/copy" />
    <revision>
      <id>28279</id>
      <parentid>28278</parentid>
      <timestamp>2012-05-01T17:30:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/copy backward</title>
    <ns>0</ns>
    <id>7651</id>
    <redirect title="cpp/algorithm/copy backward" />
    <revision>
      <id>28281</id>
      <parentid>28280</parentid>
      <timestamp>2012-05-01T17:30:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/copy_backward]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/count</title>
    <ns>0</ns>
    <id>7652</id>
    <redirect title="cpp/algorithm/count" />
    <revision>
      <id>28283</id>
      <parentid>28282</parentid>
      <timestamp>2012-05-01T17:30:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/count if</title>
    <ns>0</ns>
    <id>7653</id>
    <redirect title="cpp/algorithm/count" />
    <revision>
      <id>28285</id>
      <parentid>28284</parentid>
      <timestamp>2012-05-01T17:30:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/equal</title>
    <ns>0</ns>
    <id>7654</id>
    <redirect title="cpp/algorithm/equal" />
    <revision>
      <id>28287</id>
      <parentid>28286</parentid>
      <timestamp>2012-05-01T17:30:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/equal range</title>
    <ns>0</ns>
    <id>7655</id>
    <redirect title="cpp/algorithm/equal range" />
    <revision>
      <id>28289</id>
      <parentid>28288</parentid>
      <timestamp>2012-05-01T17:30:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/equal_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/fill</title>
    <ns>0</ns>
    <id>7656</id>
    <redirect title="cpp/algorithm/fill" />
    <revision>
      <id>28291</id>
      <parentid>28290</parentid>
      <timestamp>2012-05-01T17:30:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/fill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/fill n</title>
    <ns>0</ns>
    <id>7657</id>
    <redirect title="cpp/algorithm/fill n" />
    <revision>
      <id>28293</id>
      <parentid>28292</parentid>
      <timestamp>2012-05-01T17:30:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/fill_n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/find</title>
    <ns>0</ns>
    <id>7658</id>
    <redirect title="cpp/algorithm/find" />
    <revision>
      <id>28295</id>
      <parentid>28294</parentid>
      <timestamp>2012-05-01T17:30:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/find end</title>
    <ns>0</ns>
    <id>7659</id>
    <redirect title="cpp/algorithm/find end" />
    <revision>
      <id>28297</id>
      <parentid>28296</parentid>
      <timestamp>2012-05-01T17:30:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/find_end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/find first of</title>
    <ns>0</ns>
    <id>7660</id>
    <redirect title="cpp/algorithm/find first of" />
    <revision>
      <id>28299</id>
      <parentid>28298</parentid>
      <timestamp>2012-05-01T17:30:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/find_first_of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/find if</title>
    <ns>0</ns>
    <id>7661</id>
    <redirect title="cpp/algorithm/find" />
    <revision>
      <id>28301</id>
      <parentid>28300</parentid>
      <timestamp>2012-05-01T17:30:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/for each</title>
    <ns>0</ns>
    <id>7662</id>
    <redirect title="cpp/algorithm/for each" />
    <revision>
      <id>28303</id>
      <parentid>28302</parentid>
      <timestamp>2012-05-01T17:30:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/for_each]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/generate</title>
    <ns>0</ns>
    <id>7663</id>
    <redirect title="cpp/algorithm/generate" />
    <revision>
      <id>28305</id>
      <parentid>28304</parentid>
      <timestamp>2012-05-01T17:30:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/generate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/generate n</title>
    <ns>0</ns>
    <id>7664</id>
    <redirect title="cpp/algorithm/generate n" />
    <revision>
      <id>28307</id>
      <parentid>28306</parentid>
      <timestamp>2012-05-01T17:30:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/algorithm/generate_n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/includes</title>
    <ns>0</ns>
    <id>7665</id>
    <redirect title="cpp/algorithm/includes" />
    <revision>
      <id>28309</id>
      <parentid>28308</parentid>
      <timestamp>2012-05-01T17:30:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/includes]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/inner product</title>
    <ns>0</ns>
    <id>7666</id>
    <redirect title="cpp/algorithm/inner product" />
    <revision>
      <id>28311</id>
      <parentid>28310</parentid>
      <timestamp>2012-05-01T17:30:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/inner_product]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/inplace merge</title>
    <ns>0</ns>
    <id>7667</id>
    <redirect title="cpp/algorithm/inplace merge" />
    <revision>
      <id>28313</id>
      <parentid>28312</parentid>
      <timestamp>2012-05-01T17:30:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/algorithm/inplace_merge]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/is heap</title>
    <ns>0</ns>
    <id>7668</id>
    <redirect title="cpp/algorithm/is heap" />
    <revision>
      <id>28315</id>
      <parentid>28314</parentid>
      <timestamp>2012-05-01T17:30:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/is_heap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/iter swap</title>
    <ns>0</ns>
    <id>7669</id>
    <redirect title="cpp/algorithm/iter swap" />
    <revision>
      <id>28317</id>
      <parentid>28316</parentid>
      <timestamp>2012-05-01T17:30:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/iter_swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/lexicographical compare</title>
    <ns>0</ns>
    <id>7670</id>
    <redirect title="cpp/algorithm/lexicographical compare" />
    <revision>
      <id>28319</id>
      <parentid>28318</parentid>
      <timestamp>2012-05-01T17:30:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/algorithm/lexicographical_compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/lexicographical compare 3way</title>
    <ns>0</ns>
    <id>7671</id>
    <redirect title="cpp/algorithm/lexicographical compare" />
    <revision>
      <id>28321</id>
      <parentid>28320</parentid>
      <timestamp>2012-05-01T17:30:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/algorithm/lexicographical_compare]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/lower bound</title>
    <ns>0</ns>
    <id>7672</id>
    <redirect title="cpp/algorithm/lower bound" />
    <revision>
      <id>28323</id>
      <parentid>28322</parentid>
      <timestamp>2012-05-01T17:30:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/lower_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/make heap</title>
    <ns>0</ns>
    <id>7673</id>
    <redirect title="cpp/algorithm/make heap" />
    <revision>
      <id>28325</id>
      <parentid>28324</parentid>
      <timestamp>2012-05-01T17:30:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/make_heap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/max</title>
    <ns>0</ns>
    <id>7674</id>
    <redirect title="cpp/algorithm/max" />
    <revision>
      <id>28327</id>
      <parentid>28326</parentid>
      <timestamp>2012-05-01T17:30:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/algorithm/max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/max element</title>
    <ns>0</ns>
    <id>7675</id>
    <redirect title="cpp/algorithm/max element" />
    <revision>
      <id>28329</id>
      <parentid>28328</parentid>
      <timestamp>2012-05-01T17:30:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/max_element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/merge</title>
    <ns>0</ns>
    <id>7676</id>
    <redirect title="cpp/algorithm/merge" />
    <revision>
      <id>28331</id>
      <parentid>28330</parentid>
      <timestamp>2012-05-01T17:30:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/merge]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/min</title>
    <ns>0</ns>
    <id>7677</id>
    <redirect title="cpp/algorithm/min" />
    <revision>
      <id>28333</id>
      <parentid>28332</parentid>
      <timestamp>2012-05-01T17:30:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/algorithm/min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/min element</title>
    <ns>0</ns>
    <id>7678</id>
    <redirect title="cpp/algorithm/min element" />
    <revision>
      <id>28335</id>
      <parentid>28334</parentid>
      <timestamp>2012-05-01T17:30:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/min_element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/mismatch</title>
    <ns>0</ns>
    <id>7679</id>
    <redirect title="cpp/algorithm/mismatch" />
    <revision>
      <id>28337</id>
      <parentid>28336</parentid>
      <timestamp>2012-05-01T17:30:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/mismatch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/next permutation</title>
    <ns>0</ns>
    <id>7680</id>
    <redirect title="cpp/algorithm/next permutation" />
    <revision>
      <id>28339</id>
      <parentid>28338</parentid>
      <timestamp>2012-05-01T17:30:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/algorithm/next_permutation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/nth element</title>
    <ns>0</ns>
    <id>7681</id>
    <redirect title="cpp/algorithm/nth element" />
    <revision>
      <id>28341</id>
      <parentid>28340</parentid>
      <timestamp>2012-05-01T17:30:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/nth_element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/partial sort</title>
    <ns>0</ns>
    <id>7682</id>
    <redirect title="cpp/algorithm/partial sort" />
    <revision>
      <id>28343</id>
      <parentid>28342</parentid>
      <timestamp>2012-05-01T17:30:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/algorithm/partial_sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/partial sort copy</title>
    <ns>0</ns>
    <id>7683</id>
    <redirect title="cpp/algorithm/partial sort copy" />
    <revision>
      <id>28345</id>
      <parentid>28344</parentid>
      <timestamp>2012-05-01T17:30:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/algorithm/partial_sort_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/partial sum</title>
    <ns>0</ns>
    <id>7684</id>
    <redirect title="cpp/algorithm/partial sum" />
    <revision>
      <id>28347</id>
      <parentid>28346</parentid>
      <timestamp>2012-05-01T17:30:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/partial_sum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/partition</title>
    <ns>0</ns>
    <id>7685</id>
    <redirect title="cpp/algorithm/partition" />
    <revision>
      <id>28349</id>
      <parentid>28348</parentid>
      <timestamp>2012-05-01T17:30:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/partition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/pop heap</title>
    <ns>0</ns>
    <id>7686</id>
    <redirect title="cpp/algorithm/pop heap" />
    <revision>
      <id>28351</id>
      <parentid>28350</parentid>
      <timestamp>2012-05-01T17:30:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/pop_heap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/prev permutation</title>
    <ns>0</ns>
    <id>7687</id>
    <redirect title="cpp/algorithm/prev permutation" />
    <revision>
      <id>28353</id>
      <parentid>28352</parentid>
      <timestamp>2012-05-01T17:30:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/algorithm/prev_permutation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/push heap</title>
    <ns>0</ns>
    <id>7688</id>
    <redirect title="cpp/algorithm/push heap" />
    <revision>
      <id>28355</id>
      <parentid>28354</parentid>
      <timestamp>2012-05-01T17:30:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/push_heap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/qsort</title>
    <ns>0</ns>
    <id>7689</id>
    <redirect title="cpp/algorithm/qsort" />
    <revision>
      <id>28357</id>
      <parentid>28356</parentid>
      <timestamp>2012-05-01T17:30:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/qsort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/random shuffle</title>
    <ns>0</ns>
    <id>7690</id>
    <redirect title="cpp/algorithm/random shuffle" />
    <revision>
      <id>28359</id>
      <parentid>28358</parentid>
      <timestamp>2012-05-01T17:30:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/algorithm/random_shuffle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/remove</title>
    <ns>0</ns>
    <id>7691</id>
    <redirect title="cpp/algorithm/remove" />
    <revision>
      <id>28361</id>
      <parentid>28360</parentid>
      <timestamp>2012-05-01T17:30:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/remove copy</title>
    <ns>0</ns>
    <id>7692</id>
    <redirect title="cpp/algorithm/remove copy" />
    <revision>
      <id>28363</id>
      <parentid>28362</parentid>
      <timestamp>2012-05-01T17:30:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/remove_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/remove copy if</title>
    <ns>0</ns>
    <id>7693</id>
    <redirect title="cpp/algorithm/remove copy" />
    <revision>
      <id>28365</id>
      <parentid>28364</parentid>
      <timestamp>2012-05-01T17:30:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/remove_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/remove if</title>
    <ns>0</ns>
    <id>7694</id>
    <redirect title="cpp/algorithm/remove" />
    <revision>
      <id>28367</id>
      <parentid>28366</parentid>
      <timestamp>2012-05-01T17:30:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/replace</title>
    <ns>0</ns>
    <id>7695</id>
    <redirect title="cpp/algorithm/replace" />
    <revision>
      <id>28369</id>
      <parentid>28368</parentid>
      <timestamp>2012-05-01T17:30:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/replace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/replace copy</title>
    <ns>0</ns>
    <id>7696</id>
    <redirect title="cpp/algorithm/replace copy" />
    <revision>
      <id>28371</id>
      <parentid>28370</parentid>
      <timestamp>2012-05-01T17:30:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/algorithm/replace_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/replace copy if</title>
    <ns>0</ns>
    <id>7697</id>
    <redirect title="cpp/algorithm/replace copy" />
    <revision>
      <id>28373</id>
      <parentid>28372</parentid>
      <timestamp>2012-05-01T17:30:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/algorithm/replace_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/replace if</title>
    <ns>0</ns>
    <id>7698</id>
    <redirect title="cpp/algorithm/replace" />
    <revision>
      <id>28375</id>
      <parentid>28374</parentid>
      <timestamp>2012-05-01T17:30:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/replace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/reverse</title>
    <ns>0</ns>
    <id>7699</id>
    <redirect title="cpp/algorithm/reverse" />
    <revision>
      <id>28377</id>
      <parentid>28376</parentid>
      <timestamp>2012-05-01T17:30:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/reverse]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/reverse copy</title>
    <ns>0</ns>
    <id>7700</id>
    <redirect title="cpp/algorithm/reverse copy" />
    <revision>
      <id>28379</id>
      <parentid>28378</parentid>
      <timestamp>2012-05-01T17:30:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/algorithm/reverse_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/rotate</title>
    <ns>0</ns>
    <id>7701</id>
    <redirect title="cpp/algorithm/rotate" />
    <revision>
      <id>28381</id>
      <parentid>28380</parentid>
      <timestamp>2012-05-01T17:30:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/rotate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/rotate copy</title>
    <ns>0</ns>
    <id>7702</id>
    <redirect title="cpp/algorithm/rotate copy" />
    <revision>
      <id>28383</id>
      <parentid>28382</parentid>
      <timestamp>2012-05-01T17:30:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/rotate_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/search</title>
    <ns>0</ns>
    <id>7703</id>
    <redirect title="cpp/algorithm/search" />
    <revision>
      <id>28385</id>
      <parentid>28384</parentid>
      <timestamp>2012-05-01T17:30:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/search]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/search n</title>
    <ns>0</ns>
    <id>7704</id>
    <redirect title="cpp/algorithm/search n" />
    <revision>
      <id>28387</id>
      <parentid>28386</parentid>
      <timestamp>2012-05-01T17:30:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/algorithm/search_n]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/set difference</title>
    <ns>0</ns>
    <id>7705</id>
    <redirect title="cpp/algorithm/set difference" />
    <revision>
      <id>28389</id>
      <parentid>28388</parentid>
      <timestamp>2012-05-01T17:30:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/algorithm/set_difference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/set intersection</title>
    <ns>0</ns>
    <id>7706</id>
    <redirect title="cpp/algorithm/set intersection" />
    <revision>
      <id>28391</id>
      <parentid>28390</parentid>
      <timestamp>2012-05-01T17:30:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/algorithm/set_intersection]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/set symmetric difference</title>
    <ns>0</ns>
    <id>7707</id>
    <redirect title="cpp/algorithm/set symmetric difference" />
    <revision>
      <id>28393</id>
      <parentid>28392</parentid>
      <timestamp>2012-05-01T17:30:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/algorithm/set_symmetric_difference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/set union</title>
    <ns>0</ns>
    <id>7708</id>
    <redirect title="cpp/algorithm/set union" />
    <revision>
      <id>28395</id>
      <parentid>28394</parentid>
      <timestamp>2012-05-01T17:30:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/set_union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/sort</title>
    <ns>0</ns>
    <id>7709</id>
    <redirect title="cpp/algorithm/sort" />
    <revision>
      <id>28397</id>
      <parentid>28396</parentid>
      <timestamp>2012-05-01T17:30:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/sort heap</title>
    <ns>0</ns>
    <id>7710</id>
    <redirect title="cpp/algorithm/sort heap" />
    <revision>
      <id>28399</id>
      <parentid>28398</parentid>
      <timestamp>2012-05-01T17:30:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/sort_heap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/stable partition</title>
    <ns>0</ns>
    <id>7711</id>
    <redirect title="cpp/algorithm/stable partition" />
    <revision>
      <id>28401</id>
      <parentid>28400</parentid>
      <timestamp>2012-05-01T17:30:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/algorithm/stable_partition]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/stable sort</title>
    <ns>0</ns>
    <id>7712</id>
    <redirect title="cpp/algorithm/stable sort" />
    <revision>
      <id>28403</id>
      <parentid>28402</parentid>
      <timestamp>2012-05-01T17:30:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/stable_sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/start</title>
    <ns>0</ns>
    <id>7713</id>
    <redirect title="cpp/algorithm" />
    <revision>
      <id>28405</id>
      <parentid>28404</parentid>
      <timestamp>2012-05-01T17:30:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/algorithm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/swap</title>
    <ns>0</ns>
    <id>7715</id>
    <redirect title="cpp/algorithm/swap" />
    <revision>
      <id>28409</id>
      <parentid>28408</parentid>
      <timestamp>2012-05-01T17:30:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/algorithm/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/swap ranges</title>
    <ns>0</ns>
    <id>7716</id>
    <redirect title="cpp/algorithm/swap ranges" />
    <revision>
      <id>28411</id>
      <parentid>28410</parentid>
      <timestamp>2012-05-01T17:30:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/swap_ranges]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/transform</title>
    <ns>0</ns>
    <id>7717</id>
    <redirect title="cpp/algorithm/transform" />
    <revision>
      <id>28413</id>
      <parentid>28412</parentid>
      <timestamp>2012-05-01T17:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/algorithm/transform]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/unique</title>
    <ns>0</ns>
    <id>7718</id>
    <redirect title="cpp/algorithm/unique" />
    <revision>
      <id>28415</id>
      <parentid>28414</parentid>
      <timestamp>2012-05-01T17:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/algorithm/unique]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/unique copy</title>
    <ns>0</ns>
    <id>7719</id>
    <redirect title="cpp/algorithm/unique copy" />
    <revision>
      <id>28417</id>
      <parentid>28416</parentid>
      <timestamp>2012-05-01T17:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/unique_copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/algorithm/upper bound</title>
    <ns>0</ns>
    <id>7720</id>
    <redirect title="cpp/algorithm/upper bound" />
    <revision>
      <id>28419</id>
      <parentid>28418</parentid>
      <timestamp>2012-05-01T17:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/algorithm/upper_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/ascii</title>
    <ns>0</ns>
    <id>7635</id>
    <redirect title="cpp/language/ascii" />
    <revision>
      <id>28249</id>
      <parentid>28248</parentid>
      <timestamp>2012-05-01T17:28:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/language/ascii]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/atomic/</title>
    <ns>0</ns>
    <id>7722</id>
    <redirect title="cpp/atomic" />
    <revision>
      <id>28423</id>
      <parentid>28422</parentid>
      <timestamp>2012-05-01T17:30:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="24">#redirect [[cpp/atomic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/atomic/start</title>
    <ns>0</ns>
    <id>7721</id>
    <redirect title="cpp/atomic" />
    <revision>
      <id>28421</id>
      <parentid>28420</parentid>
      <timestamp>2012-05-01T17:30:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="24">#redirect [[cpp/atomic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/</title>
    <ns>0</ns>
    <id>7875</id>
    <redirect title="cpp" />
    <revision>
      <id>28729</id>
      <parentid>28728</parentid>
      <timestamp>2012-05-01T17:31:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/</title>
    <ns>0</ns>
    <id>7732</id>
    <redirect title="cpp/chrono/c" />
    <revision>
      <id>28443</id>
      <parentid>28442</parentid>
      <timestamp>2012-05-01T17:30:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/chrono/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/asctime</title>
    <ns>0</ns>
    <id>7723</id>
    <redirect title="cpp/chrono/c/asctime" />
    <revision>
      <id>28425</id>
      <parentid>28424</parentid>
      <timestamp>2012-05-01T17:30:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/chrono/c/asctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/clock</title>
    <ns>0</ns>
    <id>7724</id>
    <redirect title="cpp/chrono/c/clock" />
    <revision>
      <id>28427</id>
      <parentid>28426</parentid>
      <timestamp>2012-05-01T17:30:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/chrono/c/clock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/ctime</title>
    <ns>0</ns>
    <id>7725</id>
    <redirect title="cpp/chrono/c/ctime" />
    <revision>
      <id>28429</id>
      <parentid>28428</parentid>
      <timestamp>2012-05-01T17:30:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/chrono/c/ctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/difftime</title>
    <ns>0</ns>
    <id>7726</id>
    <redirect title="cpp/chrono/c/difftime" />
    <revision>
      <id>28431</id>
      <parentid>28430</parentid>
      <timestamp>2012-05-01T17:30:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/chrono/c/difftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/gmtime</title>
    <ns>0</ns>
    <id>7727</id>
    <redirect title="cpp/chrono/c/gmtime" />
    <revision>
      <id>28433</id>
      <parentid>28432</parentid>
      <timestamp>2012-05-01T17:30:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/chrono/c/gmtime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/localtime</title>
    <ns>0</ns>
    <id>7728</id>
    <redirect title="cpp/chrono/c/localtime" />
    <revision>
      <id>28435</id>
      <parentid>28434</parentid>
      <timestamp>2012-05-01T17:30:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/chrono/c/localtime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/mktime</title>
    <ns>0</ns>
    <id>7729</id>
    <redirect title="cpp/chrono/c/mktime" />
    <revision>
      <id>28437</id>
      <parentid>28436</parentid>
      <timestamp>2012-05-01T17:30:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/chrono/c/mktime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/setlocale</title>
    <ns>0</ns>
    <id>7730</id>
    <redirect title="cpp/locale/setlocale" />
    <revision>
      <id>28439</id>
      <parentid>28438</parentid>
      <timestamp>2012-05-01T17:30:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/locale/setlocale]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/start</title>
    <ns>0</ns>
    <id>7731</id>
    <redirect title="cpp/chrono/c" />
    <revision>
      <id>28441</id>
      <parentid>28440</parentid>
      <timestamp>2012-05-01T17:30:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/chrono/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/strftime</title>
    <ns>0</ns>
    <id>7733</id>
    <redirect title="cpp/chrono/c/strftime" />
    <revision>
      <id>28445</id>
      <parentid>28444</parentid>
      <timestamp>2012-05-01T17:30:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/chrono/c/strftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/time</title>
    <ns>0</ns>
    <id>7734</id>
    <redirect title="cpp/chrono/c/time" />
    <revision>
      <id>28447</id>
      <parentid>28446</parentid>
      <timestamp>2012-05-01T17:30:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/chrono/c/time]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/date/tm</title>
    <ns>0</ns>
    <id>7735</id>
    <redirect title="cpp/chrono/c/tm" />
    <revision>
      <id>28449</id>
      <parentid>28448</parentid>
      <timestamp>2012-05-01T17:30:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/chrono/c/tm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/</title>
    <ns>0</ns>
    <id>7773</id>
    <redirect title="cpp/io/c" />
    <revision>
      <id>28525</id>
      <parentid>28524</parentid>
      <timestamp>2012-05-01T17:30:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="22">#redirect [[cpp/io/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/clearerr</title>
    <ns>0</ns>
    <id>7736</id>
    <redirect title="cpp/io/c/clearerr" />
    <revision>
      <id>28451</id>
      <parentid>28450</parentid>
      <timestamp>2012-05-01T17:30:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/clearerr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fclose</title>
    <ns>0</ns>
    <id>7737</id>
    <redirect title="cpp/io/c/fclose" />
    <revision>
      <id>28453</id>
      <parentid>28452</parentid>
      <timestamp>2012-05-01T17:30:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fclose]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/feof</title>
    <ns>0</ns>
    <id>7738</id>
    <redirect title="cpp/io/c/feof" />
    <revision>
      <id>28455</id>
      <parentid>28454</parentid>
      <timestamp>2012-05-01T17:30:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/feof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/ferror</title>
    <ns>0</ns>
    <id>7739</id>
    <redirect title="cpp/io/c/ferror" />
    <revision>
      <id>28457</id>
      <parentid>28456</parentid>
      <timestamp>2012-05-01T17:30:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/ferror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fflush</title>
    <ns>0</ns>
    <id>7740</id>
    <redirect title="cpp/io/c/fflush" />
    <revision>
      <id>28459</id>
      <parentid>28458</parentid>
      <timestamp>2012-05-01T17:30:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fflush]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fgetc</title>
    <ns>0</ns>
    <id>7741</id>
    <redirect title="cpp/io/c/fgetc" />
    <revision>
      <id>28461</id>
      <parentid>28460</parentid>
      <timestamp>2012-05-01T17:30:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fgetpos</title>
    <ns>0</ns>
    <id>7742</id>
    <redirect title="cpp/io/c/fgetpos" />
    <revision>
      <id>28463</id>
      <parentid>28462</parentid>
      <timestamp>2012-05-01T17:30:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fgetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fgets</title>
    <ns>0</ns>
    <id>7743</id>
    <redirect title="cpp/io/c/fgets" />
    <revision>
      <id>28465</id>
      <parentid>28464</parentid>
      <timestamp>2012-05-01T17:30:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fgets]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fopen</title>
    <ns>0</ns>
    <id>7744</id>
    <redirect title="cpp/io/c/fopen" />
    <revision>
      <id>28467</id>
      <parentid>28466</parentid>
      <timestamp>2012-05-01T17:30:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fopen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fprintf</title>
    <ns>0</ns>
    <id>7745</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>28469</id>
      <parentid>28468</parentid>
      <timestamp>2012-05-01T17:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fputc</title>
    <ns>0</ns>
    <id>7746</id>
    <redirect title="cpp/io/c/fputc" />
    <revision>
      <id>28471</id>
      <parentid>28470</parentid>
      <timestamp>2012-05-01T17:30:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fputs</title>
    <ns>0</ns>
    <id>7747</id>
    <redirect title="cpp/io/c/fputs" />
    <revision>
      <id>28473</id>
      <parentid>28472</parentid>
      <timestamp>2012-05-01T17:30:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fputs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fread</title>
    <ns>0</ns>
    <id>7748</id>
    <redirect title="cpp/io/c/fread" />
    <revision>
      <id>28475</id>
      <parentid>28474</parentid>
      <timestamp>2012-05-01T17:30:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fread]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/freopen</title>
    <ns>0</ns>
    <id>7749</id>
    <redirect title="cpp/io/c/freopen" />
    <revision>
      <id>28477</id>
      <parentid>28476</parentid>
      <timestamp>2012-05-01T17:30:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/freopen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fscanf</title>
    <ns>0</ns>
    <id>7750</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>28479</id>
      <parentid>28478</parentid>
      <timestamp>2012-05-01T17:30:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fseek</title>
    <ns>0</ns>
    <id>7751</id>
    <redirect title="cpp/io/c/fseek" />
    <revision>
      <id>28481</id>
      <parentid>28480</parentid>
      <timestamp>2012-05-01T17:30:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fseek]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fsetpos</title>
    <ns>0</ns>
    <id>7752</id>
    <redirect title="cpp/io/c/fsetpos" />
    <revision>
      <id>28483</id>
      <parentid>28482</parentid>
      <timestamp>2012-05-01T17:30:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fsetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/ftell</title>
    <ns>0</ns>
    <id>7753</id>
    <redirect title="cpp/io/c/ftell" />
    <revision>
      <id>28485</id>
      <parentid>28484</parentid>
      <timestamp>2012-05-01T17:30:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/ftell]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/fwrite</title>
    <ns>0</ns>
    <id>7754</id>
    <redirect title="cpp/io/c/fwrite" />
    <revision>
      <id>28487</id>
      <parentid>28486</parentid>
      <timestamp>2012-05-01T17:30:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fwrite]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/getc</title>
    <ns>0</ns>
    <id>7755</id>
    <redirect title="cpp/io/c/fgetc" />
    <revision>
      <id>28489</id>
      <parentid>28488</parentid>
      <timestamp>2012-05-01T17:30:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/getchar</title>
    <ns>0</ns>
    <id>7756</id>
    <redirect title="cpp/io/c/getchar" />
    <revision>
      <id>28491</id>
      <parentid>28490</parentid>
      <timestamp>2012-05-01T17:30:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/getchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/gets</title>
    <ns>0</ns>
    <id>7757</id>
    <redirect title="cpp/io/c/gets" />
    <revision>
      <id>28493</id>
      <parentid>28492</parentid>
      <timestamp>2012-05-01T17:30:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/gets]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/perror</title>
    <ns>0</ns>
    <id>7758</id>
    <redirect title="cpp/io/c/perror" />
    <revision>
      <id>28495</id>
      <parentid>28494</parentid>
      <timestamp>2012-05-01T17:30:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/perror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/printf</title>
    <ns>0</ns>
    <id>7759</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>28497</id>
      <parentid>28496</parentid>
      <timestamp>2012-05-01T17:30:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/putc</title>
    <ns>0</ns>
    <id>7760</id>
    <redirect title="cpp/io/c/fputc" />
    <revision>
      <id>28499</id>
      <parentid>28498</parentid>
      <timestamp>2012-05-01T17:30:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/putchar</title>
    <ns>0</ns>
    <id>7761</id>
    <redirect title="cpp/io/c/putchar" />
    <revision>
      <id>28501</id>
      <parentid>28500</parentid>
      <timestamp>2012-05-01T17:30:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/putchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/puts</title>
    <ns>0</ns>
    <id>7762</id>
    <redirect title="cpp/io/c/puts" />
    <revision>
      <id>28503</id>
      <parentid>28502</parentid>
      <timestamp>2012-05-01T17:30:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/puts]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/remove</title>
    <ns>0</ns>
    <id>7763</id>
    <redirect title="cpp/io/c/remove" />
    <revision>
      <id>28505</id>
      <parentid>28504</parentid>
      <timestamp>2012-05-01T17:30:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/rename</title>
    <ns>0</ns>
    <id>7764</id>
    <redirect title="cpp/io/c/rename" />
    <revision>
      <id>28507</id>
      <parentid>28506</parentid>
      <timestamp>2012-05-01T17:30:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/rename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/rewind</title>
    <ns>0</ns>
    <id>7765</id>
    <redirect title="cpp/io/c/rewind" />
    <revision>
      <id>28509</id>
      <parentid>28508</parentid>
      <timestamp>2012-05-01T17:30:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/rewind]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/scanf</title>
    <ns>0</ns>
    <id>7766</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>28511</id>
      <parentid>28510</parentid>
      <timestamp>2012-05-01T17:30:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/setbuf</title>
    <ns>0</ns>
    <id>7767</id>
    <redirect title="cpp/io/c/setbuf" />
    <revision>
      <id>28513</id>
      <parentid>28512</parentid>
      <timestamp>2012-05-01T17:30:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/setbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/setvbuf</title>
    <ns>0</ns>
    <id>7768</id>
    <redirect title="cpp/io/c/setvbuf" />
    <revision>
      <id>28515</id>
      <parentid>28514</parentid>
      <timestamp>2012-05-01T17:30:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/setvbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/snprintf</title>
    <ns>0</ns>
    <id>7769</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>28517</id>
      <parentid>28516</parentid>
      <timestamp>2012-05-01T17:30:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/sprintf</title>
    <ns>0</ns>
    <id>7770</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>28519</id>
      <parentid>28518</parentid>
      <timestamp>2012-05-01T17:30:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/sscanf</title>
    <ns>0</ns>
    <id>7771</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>28521</id>
      <parentid>28520</parentid>
      <timestamp>2012-05-01T17:30:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/start</title>
    <ns>0</ns>
    <id>7772</id>
    <redirect title="cpp/io/c" />
    <revision>
      <id>28523</id>
      <parentid>28522</parentid>
      <timestamp>2012-05-01T17:30:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="22">#redirect [[cpp/io/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/tmpfile</title>
    <ns>0</ns>
    <id>7774</id>
    <redirect title="cpp/io/c/tmpfile" />
    <revision>
      <id>28527</id>
      <parentid>28526</parentid>
      <timestamp>2012-05-01T17:30:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/tmpfile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/tmpnam</title>
    <ns>0</ns>
    <id>7775</id>
    <redirect title="cpp/io/c/tmpnam" />
    <revision>
      <id>28529</id>
      <parentid>28528</parentid>
      <timestamp>2012-05-01T17:30:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/tmpnam]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/ungetc</title>
    <ns>0</ns>
    <id>7776</id>
    <redirect title="cpp/io/c/ungetc" />
    <revision>
      <id>28531</id>
      <parentid>28530</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/ungetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/vprintf vfprintf vsprintf</title>
    <ns>0</ns>
    <id>7777</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>28533</id>
      <parentid>28532</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/io/vscanf vfscanf vsscanf</title>
    <ns>0</ns>
    <id>7778</id>
    <redirect title="cpp/io/c/vfscanf" />
    <revision>
      <id>28535</id>
      <parentid>28534</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/</title>
    <ns>0</ns>
    <id>7804</id>
    <redirect title="cpp/numeric/math" />
    <revision>
      <id>28587</id>
      <parentid>28586</parentid>
      <timestamp>2012-05-01T17:30:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/numeric/math]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/abs</title>
    <ns>0</ns>
    <id>7779</id>
    <redirect title="cpp/numeric/math/abs" />
    <revision>
      <id>28537</id>
      <parentid>28536</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/acos</title>
    <ns>0</ns>
    <id>7780</id>
    <redirect title="cpp/numeric/math/acos" />
    <revision>
      <id>28539</id>
      <parentid>28538</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/acos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/asin</title>
    <ns>0</ns>
    <id>7781</id>
    <redirect title="cpp/numeric/math/asin" />
    <revision>
      <id>28541</id>
      <parentid>28540</parentid>
      <timestamp>2012-05-01T17:30:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/asin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/atan</title>
    <ns>0</ns>
    <id>7782</id>
    <redirect title="cpp/numeric/math/atan" />
    <revision>
      <id>28543</id>
      <parentid>28542</parentid>
      <timestamp>2012-05-01T17:30:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/atan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/atan2</title>
    <ns>0</ns>
    <id>7783</id>
    <redirect title="cpp/numeric/math/atan2" />
    <revision>
      <id>28545</id>
      <parentid>28544</parentid>
      <timestamp>2012-05-01T17:30:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/atan2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/ceil</title>
    <ns>0</ns>
    <id>7784</id>
    <redirect title="cpp/numeric/math/ceil" />
    <revision>
      <id>28547</id>
      <parentid>28546</parentid>
      <timestamp>2012-05-01T17:30:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/ceil]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/cos</title>
    <ns>0</ns>
    <id>7785</id>
    <redirect title="cpp/numeric/math/cos" />
    <revision>
      <id>28549</id>
      <parentid>28548</parentid>
      <timestamp>2012-05-01T17:30:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/cos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/cosh</title>
    <ns>0</ns>
    <id>7786</id>
    <redirect title="cpp/numeric/math/cosh" />
    <revision>
      <id>28551</id>
      <parentid>28550</parentid>
      <timestamp>2012-05-01T17:30:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/cosh]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/div</title>
    <ns>0</ns>
    <id>7787</id>
    <redirect title="cpp/numeric/math/div" />
    <revision>
      <id>28553</id>
      <parentid>28552</parentid>
      <timestamp>2012-05-01T17:30:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/exp</title>
    <ns>0</ns>
    <id>7788</id>
    <redirect title="cpp/numeric/math/exp" />
    <revision>
      <id>28555</id>
      <parentid>28554</parentid>
      <timestamp>2012-05-01T17:30:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/exp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/fabs</title>
    <ns>0</ns>
    <id>7789</id>
    <redirect title="cpp/numeric/math/fabs" />
    <revision>
      <id>28557</id>
      <parentid>28556</parentid>
      <timestamp>2012-05-01T17:30:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/fabs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/floor</title>
    <ns>0</ns>
    <id>7790</id>
    <redirect title="cpp/numeric/math/floor" />
    <revision>
      <id>28559</id>
      <parentid>28558</parentid>
      <timestamp>2012-05-01T17:30:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/floor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/fmod</title>
    <ns>0</ns>
    <id>7791</id>
    <redirect title="cpp/numeric/math/fmod" />
    <revision>
      <id>28561</id>
      <parentid>28560</parentid>
      <timestamp>2012-05-01T17:30:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/fmod]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/frexp</title>
    <ns>0</ns>
    <id>7792</id>
    <redirect title="cpp/numeric/math/frexp" />
    <revision>
      <id>28563</id>
      <parentid>28562</parentid>
      <timestamp>2012-05-01T17:30:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/frexp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/labs</title>
    <ns>0</ns>
    <id>7793</id>
    <redirect title="cpp/numeric/math/abs" />
    <revision>
      <id>46086</id>
      <parentid>28565</parentid>
      <timestamp>2013-02-15T21:49:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/numeric/math/abs]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/ldexp</title>
    <ns>0</ns>
    <id>7794</id>
    <redirect title="cpp/numeric/math/ldexp" />
    <revision>
      <id>28567</id>
      <parentid>28566</parentid>
      <timestamp>2012-05-01T17:30:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/ldexp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/ldiv</title>
    <ns>0</ns>
    <id>7795</id>
    <redirect title="cpp/numeric/math/div" />
    <revision>
      <id>46087</id>
      <parentid>28569</parentid>
      <timestamp>2013-02-15T21:49:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/numeric/math/div]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[cpp/numeric/math/div]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/log</title>
    <ns>0</ns>
    <id>7796</id>
    <redirect title="cpp/numeric/math/log" />
    <revision>
      <id>28571</id>
      <parentid>28570</parentid>
      <timestamp>2012-05-01T17:30:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/log]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/log10</title>
    <ns>0</ns>
    <id>7797</id>
    <redirect title="cpp/numeric/math/log10" />
    <revision>
      <id>28573</id>
      <parentid>28572</parentid>
      <timestamp>2012-05-01T17:30:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/log10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/modf</title>
    <ns>0</ns>
    <id>7798</id>
    <redirect title="cpp/numeric/math/modf" />
    <revision>
      <id>28575</id>
      <parentid>28574</parentid>
      <timestamp>2012-05-01T17:30:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/modf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/pow</title>
    <ns>0</ns>
    <id>7799</id>
    <redirect title="cpp/numeric/math/pow" />
    <revision>
      <id>28577</id>
      <parentid>28576</parentid>
      <timestamp>2012-05-01T17:30:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/pow]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/sin</title>
    <ns>0</ns>
    <id>7800</id>
    <redirect title="cpp/numeric/math/sin" />
    <revision>
      <id>28579</id>
      <parentid>28578</parentid>
      <timestamp>2012-05-01T17:30:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/sin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/sinh</title>
    <ns>0</ns>
    <id>7801</id>
    <redirect title="cpp/numeric/math/sinh" />
    <revision>
      <id>28581</id>
      <parentid>28580</parentid>
      <timestamp>2012-05-01T17:30:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/sinh]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/sqrt</title>
    <ns>0</ns>
    <id>7802</id>
    <redirect title="cpp/numeric/math/sqrt" />
    <revision>
      <id>28583</id>
      <parentid>28582</parentid>
      <timestamp>2012-05-01T17:30:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/sqrt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/start</title>
    <ns>0</ns>
    <id>7803</id>
    <redirect title="cpp/numeric/math" />
    <revision>
      <id>28585</id>
      <parentid>28584</parentid>
      <timestamp>2012-05-01T17:30:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/numeric/math]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/tan</title>
    <ns>0</ns>
    <id>7805</id>
    <redirect title="cpp/numeric/math/tan" />
    <revision>
      <id>28589</id>
      <parentid>28588</parentid>
      <timestamp>2012-05-01T17:30:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/numeric/math/tan]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/tanh</title>
    <ns>0</ns>
    <id>7806</id>
    <redirect title="cpp/numeric/math/tanh" />
    <revision>
      <id>28591</id>
      <parentid>28590</parentid>
      <timestamp>2012-05-01T17:30:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/numeric/math/tanh]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/math/trunc</title>
    <ns>0</ns>
    <id>7807</id>
    <redirect title="cpp/numeric/math/trunc" />
    <revision>
      <id>28593</id>
      <parentid>28592</parentid>
      <timestamp>2012-05-01T17:30:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/numeric/math/trunc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/</title>
    <ns>0</ns>
    <id>7813</id>
    <redirect title="cpp/memory/c" />
    <revision>
      <id>28605</id>
      <parentid>28604</parentid>
      <timestamp>2012-05-01T17:30:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/memory/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/calloc</title>
    <ns>0</ns>
    <id>7808</id>
    <redirect title="cpp/memory/c/calloc" />
    <revision>
      <id>28595</id>
      <parentid>28594</parentid>
      <timestamp>2012-05-01T17:30:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/memory/c/calloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/free</title>
    <ns>0</ns>
    <id>7809</id>
    <redirect title="cpp/memory/c/free" />
    <revision>
      <id>28597</id>
      <parentid>28596</parentid>
      <timestamp>2012-05-01T17:30:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/memory/c/free]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/malloc</title>
    <ns>0</ns>
    <id>7810</id>
    <redirect title="cpp/memory/c/malloc" />
    <revision>
      <id>28599</id>
      <parentid>28598</parentid>
      <timestamp>2012-05-01T17:30:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/memory/c/malloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/realloc</title>
    <ns>0</ns>
    <id>7811</id>
    <redirect title="cpp/memory/c/realloc" />
    <revision>
      <id>28601</id>
      <parentid>28600</parentid>
      <timestamp>2012-05-01T17:30:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/memory/c/realloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/mem/start</title>
    <ns>0</ns>
    <id>7812</id>
    <redirect title="cpp/memory/c" />
    <revision>
      <id>28603</id>
      <parentid>28602</parentid>
      <timestamp>2012-05-01T17:30:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/memory/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/</title>
    <ns>0</ns>
    <id>7828</id>
    <redirect title="cpp" />
    <revision>
      <id>28635</id>
      <parentid>28634</parentid>
      <timestamp>2012-05-01T17:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/abort</title>
    <ns>0</ns>
    <id>7814</id>
    <redirect title="cpp/utility/program/abort" />
    <revision>
      <id>28607</id>
      <parentid>28606</parentid>
      <timestamp>2012-05-01T17:30:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/utility/program/abort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/assert</title>
    <ns>0</ns>
    <id>7815</id>
    <redirect title="cpp/error/assert" />
    <revision>
      <id>28609</id>
      <parentid>28608</parentid>
      <timestamp>2012-05-01T17:30:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/error/assert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/atexit</title>
    <ns>0</ns>
    <id>7816</id>
    <redirect title="cpp/utility/program/atexit" />
    <revision>
      <id>28611</id>
      <parentid>28610</parentid>
      <timestamp>2012-05-01T17:30:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/utility/program/atexit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/bsearch</title>
    <ns>0</ns>
    <id>7817</id>
    <redirect title="cpp/algorithm/bsearch" />
    <revision>
      <id>28613</id>
      <parentid>28612</parentid>
      <timestamp>2012-05-01T17:31:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/algorithm/bsearch]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/exit</title>
    <ns>0</ns>
    <id>7818</id>
    <redirect title="cpp/utility/program/exit" />
    <revision>
      <id>28615</id>
      <parentid>28614</parentid>
      <timestamp>2012-05-01T17:31:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/utility/program/exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/getenv</title>
    <ns>0</ns>
    <id>7819</id>
    <redirect title="cpp/utility/program/getenv" />
    <revision>
      <id>28617</id>
      <parentid>28616</parentid>
      <timestamp>2012-05-01T17:31:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/utility/program/getenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/longjmp</title>
    <ns>0</ns>
    <id>7820</id>
    <redirect title="cpp/utility/program/longjmp" />
    <revision>
      <id>28619</id>
      <parentid>28618</parentid>
      <timestamp>2012-05-01T17:31:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/utility/program/longjmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/qsort</title>
    <ns>0</ns>
    <id>7821</id>
    <redirect title="cpp/algorithm/qsort" />
    <revision>
      <id>28621</id>
      <parentid>28620</parentid>
      <timestamp>2012-05-01T17:31:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/algorithm/qsort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/raise</title>
    <ns>0</ns>
    <id>7822</id>
    <redirect title="cpp/utility/program/raise" />
    <revision>
      <id>28623</id>
      <parentid>28622</parentid>
      <timestamp>2012-05-01T17:31:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/utility/program/raise]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/rand</title>
    <ns>0</ns>
    <id>7823</id>
    <redirect title="cpp/numeric/random/rand" />
    <revision>
      <id>28625</id>
      <parentid>28624</parentid>
      <timestamp>2012-05-01T17:31:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/numeric/random/rand]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/setjmp</title>
    <ns>0</ns>
    <id>7824</id>
    <redirect title="cpp/utility/program/setjmp" />
    <revision>
      <id>28627</id>
      <parentid>28626</parentid>
      <timestamp>2012-05-01T17:31:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/utility/program/setjmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/signal</title>
    <ns>0</ns>
    <id>7825</id>
    <redirect title="cpp/utility/program/signal" />
    <revision>
      <id>28629</id>
      <parentid>28628</parentid>
      <timestamp>2012-05-01T17:31:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/utility/program/signal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/srand</title>
    <ns>0</ns>
    <id>7826</id>
    <redirect title="cpp/numeric/random/srand" />
    <revision>
      <id>28631</id>
      <parentid>28630</parentid>
      <timestamp>2012-05-01T17:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/random/srand]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/start</title>
    <ns>0</ns>
    <id>7827</id>
    <redirect title="cpp" />
    <revision>
      <id>28633</id>
      <parentid>28632</parentid>
      <timestamp>2012-05-01T17:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/system</title>
    <ns>0</ns>
    <id>7829</id>
    <redirect title="cpp/utility/program/system" />
    <revision>
      <id>28637</id>
      <parentid>28636</parentid>
      <timestamp>2012-05-01T17:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/utility/program/system]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/other/va arg</title>
    <ns>0</ns>
    <id>7830</id>
    <redirect title="cpp" />
    <revision>
      <id>28639</id>
      <parentid>28638</parentid>
      <timestamp>2012-05-01T17:31:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/start</title>
    <ns>0</ns>
    <id>7874</id>
    <redirect title="cpp" />
    <revision>
      <id>28727</id>
      <parentid>28726</parentid>
      <timestamp>2012-05-01T17:31:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/</title>
    <ns>0</ns>
    <id>7851</id>
    <redirect title="cpp/string/byte" />
    <revision>
      <id>46094</id>
      <parentid>28681</parentid>
      <timestamp>2013-02-15T21:50:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/string/byte]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/string/byte]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/atof</title>
    <ns>0</ns>
    <id>7831</id>
    <redirect title="cpp/string/byte/atof" />
    <revision>
      <id>36251</id>
      <parentid>28641</parentid>
      <timestamp>2012-06-17T12:55:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/string/byte/atof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/atoi</title>
    <ns>0</ns>
    <id>7832</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>36252</id>
      <parentid>28643</parentid>
      <timestamp>2012-06-17T12:56:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/atol</title>
    <ns>0</ns>
    <id>7833</id>
    <redirect title="cpp/string/byte/atoi" />
    <revision>
      <id>36253</id>
      <parentid>28645</parentid>
      <timestamp>2012-06-17T12:56:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/string/byte/atoi]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isalnum</title>
    <ns>0</ns>
    <id>7834</id>
    <redirect title="cpp/string/byte/isalnum" />
    <revision>
      <id>36254</id>
      <parentid>28647</parentid>
      <timestamp>2012-06-17T12:56:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isalnum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isalpha</title>
    <ns>0</ns>
    <id>7835</id>
    <redirect title="cpp/string/byte/isalpha" />
    <revision>
      <id>36256</id>
      <parentid>28649</parentid>
      <timestamp>2012-06-17T12:56:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isalpha]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/iscntrl</title>
    <ns>0</ns>
    <id>7836</id>
    <redirect title="cpp/string/byte/iscntrl" />
    <revision>
      <id>36257</id>
      <parentid>28651</parentid>
      <timestamp>2012-06-17T12:57:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/iscntrl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isdigit</title>
    <ns>0</ns>
    <id>7837</id>
    <redirect title="cpp/string/byte/isdigit" />
    <revision>
      <id>36258</id>
      <parentid>28653</parentid>
      <timestamp>2012-06-17T12:57:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isgraph</title>
    <ns>0</ns>
    <id>7838</id>
    <redirect title="cpp/string/byte/isgraph" />
    <revision>
      <id>36259</id>
      <parentid>28655</parentid>
      <timestamp>2012-06-17T12:58:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isgraph]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/islower</title>
    <ns>0</ns>
    <id>7839</id>
    <redirect title="cpp/string/byte/islower" />
    <revision>
      <id>36260</id>
      <parentid>28657</parentid>
      <timestamp>2012-06-17T12:58:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/islower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isprint</title>
    <ns>0</ns>
    <id>7840</id>
    <redirect title="cpp/string/byte/isprint" />
    <revision>
      <id>36261</id>
      <parentid>28659</parentid>
      <timestamp>2012-06-17T12:59:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isprint]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/ispunct</title>
    <ns>0</ns>
    <id>7841</id>
    <redirect title="cpp/string/byte/ispunct" />
    <revision>
      <id>36262</id>
      <parentid>28661</parentid>
      <timestamp>2012-06-17T12:59:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/ispunct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isspace</title>
    <ns>0</ns>
    <id>7842</id>
    <redirect title="cpp/string/byte/isspace" />
    <revision>
      <id>36263</id>
      <parentid>28663</parentid>
      <timestamp>2012-06-17T12:59:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isspace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isupper</title>
    <ns>0</ns>
    <id>7843</id>
    <redirect title="cpp/string/byte/isupper" />
    <revision>
      <id>36264</id>
      <parentid>28665</parentid>
      <timestamp>2012-06-17T13:00:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/isupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/isxdigit</title>
    <ns>0</ns>
    <id>7844</id>
    <redirect title="cpp/string/byte/isxdigit" />
    <revision>
      <id>36265</id>
      <parentid>28667</parentid>
      <timestamp>2012-06-17T13:01:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/string/byte/isxdigit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/memchr</title>
    <ns>0</ns>
    <id>7845</id>
    <redirect title="cpp/string/byte/memchr" />
    <revision>
      <id>36266</id>
      <parentid>28669</parentid>
      <timestamp>2012-06-17T13:01:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/memchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/memcmp</title>
    <ns>0</ns>
    <id>7846</id>
    <redirect title="cpp/string/byte/memcmp" />
    <revision>
      <id>36267</id>
      <parentid>28671</parentid>
      <timestamp>2012-06-17T13:02:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/memcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/memcpy</title>
    <ns>0</ns>
    <id>7847</id>
    <redirect title="cpp/string/byte/memcpy" />
    <revision>
      <id>36268</id>
      <parentid>28673</parentid>
      <timestamp>2012-06-17T13:02:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/memcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/memmove</title>
    <ns>0</ns>
    <id>7848</id>
    <redirect title="cpp/string/byte/memmove" />
    <revision>
      <id>36269</id>
      <parentid>28675</parentid>
      <timestamp>2012-06-17T13:02:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/memmove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/memset</title>
    <ns>0</ns>
    <id>7849</id>
    <redirect title="cpp/string/byte/memset" />
    <revision>
      <id>36270</id>
      <parentid>28677</parentid>
      <timestamp>2012-06-17T13:03:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/memset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/start</title>
    <ns>0</ns>
    <id>7850</id>
    <redirect title="cpp/string/byte" />
    <revision>
      <id>46093</id>
      <parentid>28679</parentid>
      <timestamp>2013-02-15T21:49:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/string/byte]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[cpp/string/byte]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strcat</title>
    <ns>0</ns>
    <id>7852</id>
    <redirect title="cpp/string/byte/strcat" />
    <revision>
      <id>36255</id>
      <parentid>28683</parentid>
      <timestamp>2012-06-17T12:56:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strcat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strchr</title>
    <ns>0</ns>
    <id>7853</id>
    <redirect title="cpp/string/byte/strchr" />
    <revision>
      <id>36271</id>
      <parentid>28685</parentid>
      <timestamp>2012-06-17T13:03:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strcmp</title>
    <ns>0</ns>
    <id>7854</id>
    <redirect title="cpp/string/byte/strcmp" />
    <revision>
      <id>36272</id>
      <parentid>28687</parentid>
      <timestamp>2012-06-17T13:04:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strcmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strcoll</title>
    <ns>0</ns>
    <id>7855</id>
    <redirect title="cpp/string/byte/strcoll" />
    <revision>
      <id>29750</id>
      <parentid>28689</parentid>
      <timestamp>2012-05-01T18:09:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/byte/strcoll]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strcoll]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strcpy</title>
    <ns>0</ns>
    <id>7856</id>
    <redirect title="cpp/string/byte/strcpy" />
    <revision>
      <id>36273</id>
      <parentid>28691</parentid>
      <timestamp>2012-06-17T13:04:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strcpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strcspn</title>
    <ns>0</ns>
    <id>7857</id>
    <redirect title="cpp/string/byte/strcspn" />
    <revision>
      <id>36274</id>
      <parentid>28693</parentid>
      <timestamp>2012-06-17T13:05:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strcspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strerror</title>
    <ns>0</ns>
    <id>7858</id>
    <redirect title="cpp/string/byte/strerror" />
    <revision>
      <id>29748</id>
      <parentid>28695</parentid>
      <timestamp>2012-05-01T18:09:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/byte/strerror]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/string/byte/strerror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strlen</title>
    <ns>0</ns>
    <id>7859</id>
    <redirect title="cpp/string/byte/strlen" />
    <revision>
      <id>36275</id>
      <parentid>28697</parentid>
      <timestamp>2012-06-17T13:06:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strlen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strncat</title>
    <ns>0</ns>
    <id>7860</id>
    <redirect title="cpp/string/byte/strncat" />
    <revision>
      <id>36276</id>
      <parentid>28699</parentid>
      <timestamp>2012-06-17T13:06:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strncat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strncmp</title>
    <ns>0</ns>
    <id>7861</id>
    <redirect title="cpp/string/byte/strncmp" />
    <revision>
      <id>36277</id>
      <parentid>28701</parentid>
      <timestamp>2012-06-17T13:06:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strncmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strncpy</title>
    <ns>0</ns>
    <id>7862</id>
    <redirect title="cpp/string/byte/strncpy" />
    <revision>
      <id>36278</id>
      <parentid>28703</parentid>
      <timestamp>2012-06-17T13:06:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strncpy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strpbrk</title>
    <ns>0</ns>
    <id>7863</id>
    <redirect title="cpp/string/byte/strpbrk" />
    <revision>
      <id>36279</id>
      <parentid>28705</parentid>
      <timestamp>2012-06-17T13:06:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strpbrk]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strrchr</title>
    <ns>0</ns>
    <id>7864</id>
    <redirect title="cpp/string/byte/strrchr" />
    <revision>
      <id>36280</id>
      <parentid>28707</parentid>
      <timestamp>2012-06-17T13:06:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strrchr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strspn</title>
    <ns>0</ns>
    <id>7865</id>
    <redirect title="cpp/string/byte/strspn" />
    <revision>
      <id>36281</id>
      <parentid>28709</parentid>
      <timestamp>2012-06-17T13:06:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strspn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strstr</title>
    <ns>0</ns>
    <id>7866</id>
    <redirect title="cpp/string/byte/strstr" />
    <revision>
      <id>36282</id>
      <parentid>28711</parentid>
      <timestamp>2012-06-17T13:06:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strstr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strtod</title>
    <ns>0</ns>
    <id>7867</id>
    <redirect title="cpp/string/byte/strtof" />
    <revision>
      <id>36283</id>
      <parentid>28713</parentid>
      <timestamp>2012-06-17T13:07:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strtof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strtok</title>
    <ns>0</ns>
    <id>7868</id>
    <redirect title="cpp/string/byte/strtok" />
    <revision>
      <id>29746</id>
      <parentid>28715</parentid>
      <timestamp>2012-05-01T18:08:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/string/byte/strtok]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strtok]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strtol</title>
    <ns>0</ns>
    <id>7869</id>
    <redirect title="cpp/string/byte/strtol" />
    <revision>
      <id>36284</id>
      <parentid>28717</parentid>
      <timestamp>2012-06-17T13:08:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/string/byte/strtol]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strtoul</title>
    <ns>0</ns>
    <id>7870</id>
    <redirect title="cpp/string/byte/strtoul" />
    <revision>
      <id>36285</id>
      <parentid>28719</parentid>
      <timestamp>2012-06-17T13:08:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strtoul]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/strxfrm</title>
    <ns>0</ns>
    <id>7871</id>
    <redirect title="cpp/string/byte/strxfrm" />
    <revision>
      <id>36286</id>
      <parentid>28721</parentid>
      <timestamp>2012-06-17T13:08:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/strxfrm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/tolower</title>
    <ns>0</ns>
    <id>7872</id>
    <redirect title="cpp/string/byte/tolower" />
    <revision>
      <id>36287</id>
      <parentid>28723</parentid>
      <timestamp>2012-06-17T13:09:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/tolower]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c/string/toupper</title>
    <ns>0</ns>
    <id>7873</id>
    <redirect title="cpp/string/byte/toupper" />
    <revision>
      <id>36288</id>
      <parentid>28725</parentid>
      <timestamp>2012-06-17T13:10:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/string/narrow/&quot; to &quot;/string/byte/&quot;</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/string/byte/toupper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/c 0x</title>
    <ns>0</ns>
    <id>7641</id>
    <redirect title="cpp" />
    <revision>
      <id>37571</id>
      <parentid>30557</parentid>
      <timestamp>2012-07-15T21:00:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp]]</comment>
      <text xml:space="preserve" bytes="17">#redirect [[cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/</title>
    <ns>0</ns>
    <id>7890</id>
    <redirect title="cpp/chrono" />
    <revision>
      <id>28759</id>
      <parentid>28758</parentid>
      <timestamp>2012-05-01T17:31:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="24">#redirect [[cpp/chrono]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/</title>
    <ns>0</ns>
    <id>7885</id>
    <redirect title="cpp/chrono/c" />
    <revision>
      <id>28749</id>
      <parentid>28748</parentid>
      <timestamp>2012-05-01T17:31:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/chrono/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/asctime</title>
    <ns>0</ns>
    <id>7876</id>
    <redirect title="cpp/chrono/c/asctime" />
    <revision>
      <id>28731</id>
      <parentid>28730</parentid>
      <timestamp>2012-05-01T17:31:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/chrono/c/asctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/clock</title>
    <ns>0</ns>
    <id>7877</id>
    <redirect title="cpp/chrono/c/clock" />
    <revision>
      <id>28733</id>
      <parentid>28732</parentid>
      <timestamp>2012-05-01T17:31:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/chrono/c/clock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/clocks per sec</title>
    <ns>0</ns>
    <id>7878</id>
    <redirect title="cpp/chrono/c/CLOCKS PER SEC" />
    <revision>
      <id>28735</id>
      <parentid>28734</parentid>
      <timestamp>2012-05-01T17:31:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/chrono/c/CLOCKS_PER_SEC]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/ctime</title>
    <ns>0</ns>
    <id>7879</id>
    <redirect title="cpp/chrono/c/ctime" />
    <revision>
      <id>28737</id>
      <parentid>28736</parentid>
      <timestamp>2012-05-01T17:31:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/chrono/c/ctime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/difftime</title>
    <ns>0</ns>
    <id>7880</id>
    <redirect title="cpp/chrono/c/difftime" />
    <revision>
      <id>28739</id>
      <parentid>28738</parentid>
      <timestamp>2012-05-01T17:31:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/chrono/c/difftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/gmtime</title>
    <ns>0</ns>
    <id>7881</id>
    <redirect title="cpp/chrono/c/gmtime" />
    <revision>
      <id>28741</id>
      <parentid>28740</parentid>
      <timestamp>2012-05-01T17:31:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/chrono/c/gmtime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/localtime</title>
    <ns>0</ns>
    <id>7882</id>
    <redirect title="cpp/chrono/c/localtime" />
    <revision>
      <id>28743</id>
      <parentid>28742</parentid>
      <timestamp>2012-05-01T17:31:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/chrono/c/localtime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/mktime</title>
    <ns>0</ns>
    <id>7883</id>
    <redirect title="cpp/chrono/c/mktime" />
    <revision>
      <id>28745</id>
      <parentid>28744</parentid>
      <timestamp>2012-05-01T17:31:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/chrono/c/mktime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/start</title>
    <ns>0</ns>
    <id>7884</id>
    <redirect title="cpp/chrono/c" />
    <revision>
      <id>28747</id>
      <parentid>28746</parentid>
      <timestamp>2012-05-01T17:31:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="26">#redirect [[cpp/chrono/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/strftime</title>
    <ns>0</ns>
    <id>7886</id>
    <redirect title="cpp/chrono/c/strftime" />
    <revision>
      <id>28751</id>
      <parentid>28750</parentid>
      <timestamp>2012-05-01T17:31:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/chrono/c/strftime]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/time</title>
    <ns>0</ns>
    <id>7887</id>
    <redirect title="cpp/chrono/c/time" />
    <revision>
      <id>28753</id>
      <parentid>28752</parentid>
      <timestamp>2012-05-01T17:31:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/chrono/c/time]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/c/tm</title>
    <ns>0</ns>
    <id>7888</id>
    <redirect title="cpp/chrono/c/tm" />
    <revision>
      <id>28755</id>
      <parentid>28754</parentid>
      <timestamp>2012-05-01T17:31:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/chrono/c/tm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/chrono/start</title>
    <ns>0</ns>
    <id>7889</id>
    <redirect title="cpp/chrono" />
    <revision>
      <id>28757</id>
      <parentid>28756</parentid>
      <timestamp>2012-05-01T17:31:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="24">#redirect [[cpp/chrono]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/</title>
    <ns>0</ns>
    <id>7900</id>
    <redirect title="cpp/numeric/complex" />
    <revision>
      <id>28779</id>
      <parentid>28778</parentid>
      <timestamp>2012-05-01T17:31:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/numeric/complex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/abs</title>
    <ns>0</ns>
    <id>7891</id>
    <redirect title="cpp/numeric/complex/abs" />
    <revision>
      <id>28761</id>
      <parentid>28760</parentid>
      <timestamp>2012-05-01T17:31:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/numeric/complex/abs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/arg</title>
    <ns>0</ns>
    <id>7892</id>
    <redirect title="cpp/numeric/complex/arg" />
    <revision>
      <id>28763</id>
      <parentid>28762</parentid>
      <timestamp>2012-05-01T17:31:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/numeric/complex/arg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/complex constructors</title>
    <ns>0</ns>
    <id>7893</id>
    <redirect title="cpp/numeric/complex/complex" />
    <revision>
      <id>28765</id>
      <parentid>28764</parentid>
      <timestamp>2012-05-01T17:31:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/numeric/complex/complex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/conj</title>
    <ns>0</ns>
    <id>7894</id>
    <redirect title="cpp/numeric/complex/conj" />
    <revision>
      <id>28767</id>
      <parentid>28766</parentid>
      <timestamp>2012-05-01T17:31:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/complex/conj]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/imag</title>
    <ns>0</ns>
    <id>7895</id>
    <redirect title="cpp/numeric/complex/imag" />
    <revision>
      <id>28769</id>
      <parentid>28768</parentid>
      <timestamp>2012-05-01T17:31:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/complex/imag]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/norm</title>
    <ns>0</ns>
    <id>7896</id>
    <redirect title="cpp/numeric/complex/norm" />
    <revision>
      <id>28771</id>
      <parentid>28770</parentid>
      <timestamp>2012-05-01T17:31:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/complex/norm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/polar</title>
    <ns>0</ns>
    <id>7897</id>
    <redirect title="cpp/numeric/complex/polar" />
    <revision>
      <id>28773</id>
      <parentid>28772</parentid>
      <timestamp>2012-05-01T17:31:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/numeric/complex/polar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/real</title>
    <ns>0</ns>
    <id>7898</id>
    <redirect title="cpp/numeric/complex/real" />
    <revision>
      <id>28775</id>
      <parentid>28774</parentid>
      <timestamp>2012-05-01T17:31:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/numeric/complex/real]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complex/start</title>
    <ns>0</ns>
    <id>7899</id>
    <redirect title="cpp/numeric/complex" />
    <revision>
      <id>28777</id>
      <parentid>28776</parentid>
      <timestamp>2012-05-01T17:31:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/numeric/complex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/complexity</title>
    <ns>0</ns>
    <id>7642</id>
    <redirect title="cpp" />
    <revision>
      <id>37572</id>
      <parentid>30558</parentid>
      <timestamp>2012-07-15T21:00:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp]]</comment>
      <text xml:space="preserve" bytes="150">#redirect [[cpp]]

[[es:cpp/complexity]]
[[fr:cpp/complexity]]
[[it:cpp/complexity]]
[[ja:cpp/complexity]]
[[pl:cpp/complexity]]
[[zh:cpp/complexity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/</title>
    <ns>0</ns>
    <id>8199</id>
    <redirect title="cpp/container" />
    <revision>
      <id>29377</id>
      <parentid>29376</parentid>
      <timestamp>2012-05-01T17:33:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/container]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/</title>
    <ns>0</ns>
    <id>7914</id>
    <redirect title="cpp/container/array" />
    <revision>
      <id>28807</id>
      <parentid>28806</parentid>
      <timestamp>2012-05-01T17:31:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/array]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/at</title>
    <ns>0</ns>
    <id>7901</id>
    <redirect title="cpp/container/array/at" />
    <revision>
      <id>28781</id>
      <parentid>28780</parentid>
      <timestamp>2012-05-01T17:31:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/array/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/back</title>
    <ns>0</ns>
    <id>7902</id>
    <redirect title="cpp/container/array/back" />
    <revision>
      <id>28783</id>
      <parentid>28782</parentid>
      <timestamp>2012-05-01T17:31:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/array/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/begin</title>
    <ns>0</ns>
    <id>7903</id>
    <redirect title="cpp/container/array/begin" />
    <revision>
      <id>28785</id>
      <parentid>28784</parentid>
      <timestamp>2012-05-01T17:31:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/array/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/data</title>
    <ns>0</ns>
    <id>7904</id>
    <redirect title="cpp/container/array/data" />
    <revision>
      <id>28787</id>
      <parentid>28786</parentid>
      <timestamp>2012-05-01T17:31:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/array/data]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/empty</title>
    <ns>0</ns>
    <id>7905</id>
    <redirect title="cpp/container/array/empty" />
    <revision>
      <id>28789</id>
      <parentid>28788</parentid>
      <timestamp>2012-05-01T17:31:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/array/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/end</title>
    <ns>0</ns>
    <id>7906</id>
    <redirect title="cpp/container/array/end" />
    <revision>
      <id>28791</id>
      <parentid>28790</parentid>
      <timestamp>2012-05-01T17:31:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/array/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/front</title>
    <ns>0</ns>
    <id>7907</id>
    <redirect title="cpp/container/array/front" />
    <revision>
      <id>28793</id>
      <parentid>28792</parentid>
      <timestamp>2012-05-01T17:31:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/array/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/max size</title>
    <ns>0</ns>
    <id>7908</id>
    <redirect title="cpp/container/array/max size" />
    <revision>
      <id>28795</id>
      <parentid>28794</parentid>
      <timestamp>2012-05-01T17:31:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/array/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/operator at</title>
    <ns>0</ns>
    <id>7909</id>
    <redirect title="cpp/container/array/operator at" />
    <revision>
      <id>28797</id>
      <parentid>28796</parentid>
      <timestamp>2012-05-01T17:31:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/array/operator_at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/rbegin</title>
    <ns>0</ns>
    <id>7910</id>
    <redirect title="cpp/container/array/rbegin" />
    <revision>
      <id>28799</id>
      <parentid>28798</parentid>
      <timestamp>2012-05-01T17:31:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/array/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/rend</title>
    <ns>0</ns>
    <id>7911</id>
    <redirect title="cpp/container/array/rend" />
    <revision>
      <id>28801</id>
      <parentid>28800</parentid>
      <timestamp>2012-05-01T17:31:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/array/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/size</title>
    <ns>0</ns>
    <id>7912</id>
    <redirect title="cpp/container/array/size" />
    <revision>
      <id>28803</id>
      <parentid>28802</parentid>
      <timestamp>2012-05-01T17:31:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/array/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/start</title>
    <ns>0</ns>
    <id>7913</id>
    <redirect title="cpp/container/array" />
    <revision>
      <id>28805</id>
      <parentid>28804</parentid>
      <timestamp>2012-05-01T17:31:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/array]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/array/swap</title>
    <ns>0</ns>
    <id>7915</id>
    <redirect title="cpp/container/array/swap" />
    <revision>
      <id>28809</id>
      <parentid>28808</parentid>
      <timestamp>2012-05-01T17:31:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/array/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/</title>
    <ns>0</ns>
    <id>7942</id>
    <redirect title="cpp/container/deque" />
    <revision>
      <id>28863</id>
      <parentid>28862</parentid>
      <timestamp>2012-05-01T17:31:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/deque]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/assign</title>
    <ns>0</ns>
    <id>7916</id>
    <redirect title="cpp/container/deque/assign" />
    <revision>
      <id>28811</id>
      <parentid>28810</parentid>
      <timestamp>2012-05-01T17:31:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/deque/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/at</title>
    <ns>0</ns>
    <id>7917</id>
    <redirect title="cpp/container/deque/at" />
    <revision>
      <id>28813</id>
      <parentid>28812</parentid>
      <timestamp>2012-05-01T17:31:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/deque/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/back</title>
    <ns>0</ns>
    <id>7918</id>
    <redirect title="cpp/container/deque/back" />
    <revision>
      <id>28815</id>
      <parentid>28814</parentid>
      <timestamp>2012-05-01T17:31:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/deque/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/begin</title>
    <ns>0</ns>
    <id>7919</id>
    <redirect title="cpp/container/deque/begin" />
    <revision>
      <id>28817</id>
      <parentid>28816</parentid>
      <timestamp>2012-05-01T17:31:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/clear</title>
    <ns>0</ns>
    <id>7920</id>
    <redirect title="cpp/container/deque/clear" />
    <revision>
      <id>28819</id>
      <parentid>28818</parentid>
      <timestamp>2012-05-01T17:31:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/constructor</title>
    <ns>0</ns>
    <id>7921</id>
    <redirect title="cpp/container/deque/deque" />
    <revision>
      <id>28821</id>
      <parentid>28820</parentid>
      <timestamp>2012-05-01T17:31:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/deque]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/deque operators</title>
    <ns>0</ns>
    <id>7922</id>
    <redirect title="cpp/container/deque/operator cmp" />
    <revision>
      <id>36223</id>
      <parentid>28823</parentid>
      <timestamp>2012-06-17T12:43:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/deque/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/empty</title>
    <ns>0</ns>
    <id>7923</id>
    <redirect title="cpp/container/deque/empty" />
    <revision>
      <id>28825</id>
      <parentid>28824</parentid>
      <timestamp>2012-05-01T17:31:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/end</title>
    <ns>0</ns>
    <id>7924</id>
    <redirect title="cpp/container/deque/end" />
    <revision>
      <id>28827</id>
      <parentid>28826</parentid>
      <timestamp>2012-05-01T17:31:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/deque/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/erase</title>
    <ns>0</ns>
    <id>7925</id>
    <redirect title="cpp/container/deque/erase" />
    <revision>
      <id>28829</id>
      <parentid>28828</parentid>
      <timestamp>2012-05-01T17:31:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/front</title>
    <ns>0</ns>
    <id>7926</id>
    <redirect title="cpp/container/deque/front" />
    <revision>
      <id>28831</id>
      <parentid>28830</parentid>
      <timestamp>2012-05-01T17:31:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/deque/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/get allocator</title>
    <ns>0</ns>
    <id>7927</id>
    <redirect title="cpp/container/deque/get allocator" />
    <revision>
      <id>28833</id>
      <parentid>28832</parentid>
      <timestamp>2012-05-01T17:31:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/deque/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/insert</title>
    <ns>0</ns>
    <id>7928</id>
    <redirect title="cpp/container/deque/insert" />
    <revision>
      <id>28835</id>
      <parentid>28834</parentid>
      <timestamp>2012-05-01T17:31:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/deque/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/max size</title>
    <ns>0</ns>
    <id>7929</id>
    <redirect title="cpp/container/deque/max size" />
    <revision>
      <id>28837</id>
      <parentid>28836</parentid>
      <timestamp>2012-05-01T17:31:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/deque/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/operator at</title>
    <ns>0</ns>
    <id>7930</id>
    <redirect title="cpp/container/deque/operator at" />
    <revision>
      <id>28839</id>
      <parentid>28838</parentid>
      <timestamp>2012-05-01T17:31:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/deque/operator_at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/operator comp</title>
    <ns>0</ns>
    <id>7931</id>
    <redirect title="cpp/container/deque/operator cmp" />
    <revision>
      <id>36224</id>
      <parentid>28841</parentid>
      <timestamp>2012-06-17T12:45:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/deque/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/pop back</title>
    <ns>0</ns>
    <id>7932</id>
    <redirect title="cpp/container/deque/pop back" />
    <revision>
      <id>28843</id>
      <parentid>28842</parentid>
      <timestamp>2012-05-01T17:31:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/deque/pop_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/pop front</title>
    <ns>0</ns>
    <id>7933</id>
    <redirect title="cpp/container/deque/pop front" />
    <revision>
      <id>28845</id>
      <parentid>28844</parentid>
      <timestamp>2012-05-01T17:31:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/deque/pop_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/push back</title>
    <ns>0</ns>
    <id>7934</id>
    <redirect title="cpp/container/deque/push back" />
    <revision>
      <id>28847</id>
      <parentid>28846</parentid>
      <timestamp>2012-05-01T17:31:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/deque/push_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/push front</title>
    <ns>0</ns>
    <id>7935</id>
    <redirect title="cpp/container/deque/push front" />
    <revision>
      <id>28849</id>
      <parentid>28848</parentid>
      <timestamp>2012-05-01T17:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/deque/push_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/rbegin</title>
    <ns>0</ns>
    <id>7936</id>
    <redirect title="cpp/container/deque/rbegin" />
    <revision>
      <id>28851</id>
      <parentid>28850</parentid>
      <timestamp>2012-05-01T17:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/deque/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/rend</title>
    <ns>0</ns>
    <id>7937</id>
    <redirect title="cpp/container/deque/rend" />
    <revision>
      <id>28853</id>
      <parentid>28852</parentid>
      <timestamp>2012-05-01T17:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/deque/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/resize</title>
    <ns>0</ns>
    <id>7938</id>
    <redirect title="cpp/container/deque/resize" />
    <revision>
      <id>28855</id>
      <parentid>28854</parentid>
      <timestamp>2012-05-01T17:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/deque/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/shrink to fit</title>
    <ns>0</ns>
    <id>7939</id>
    <redirect title="cpp/container/deque/shrink to fit" />
    <revision>
      <id>28857</id>
      <parentid>28856</parentid>
      <timestamp>2012-05-01T17:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/deque/shrink_to_fit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/size</title>
    <ns>0</ns>
    <id>7940</id>
    <redirect title="cpp/container/deque/size" />
    <revision>
      <id>28859</id>
      <parentid>28858</parentid>
      <timestamp>2012-05-01T17:31:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/deque/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/start</title>
    <ns>0</ns>
    <id>7941</id>
    <redirect title="cpp/container/deque" />
    <revision>
      <id>28861</id>
      <parentid>28860</parentid>
      <timestamp>2012-05-01T17:31:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/deque]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/deque/swap</title>
    <ns>0</ns>
    <id>7943</id>
    <redirect title="cpp/container/deque/swap" />
    <revision>
      <id>28865</id>
      <parentid>28864</parentid>
      <timestamp>2012-05-01T17:31:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/deque/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/</title>
    <ns>0</ns>
    <id>7961</id>
    <redirect title="cpp/container/forward list" />
    <revision>
      <id>28901</id>
      <parentid>28900</parentid>
      <timestamp>2012-05-01T17:31:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/forward_list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/assign</title>
    <ns>0</ns>
    <id>7944</id>
    <redirect title="cpp/container/forward list/assign" />
    <revision>
      <id>28867</id>
      <parentid>28866</parentid>
      <timestamp>2012-05-01T17:31:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/forward_list/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/before begin</title>
    <ns>0</ns>
    <id>7945</id>
    <redirect title="cpp/container/forward list/before begin" />
    <revision>
      <id>28869</id>
      <parentid>28868</parentid>
      <timestamp>2012-05-01T17:31:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="53">#redirect [[cpp/container/forward_list/before_begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/begin</title>
    <ns>0</ns>
    <id>7946</id>
    <redirect title="cpp/container/forward list/begin" />
    <revision>
      <id>28871</id>
      <parentid>28870</parentid>
      <timestamp>2012-05-01T17:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/forward_list/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/clear</title>
    <ns>0</ns>
    <id>7947</id>
    <redirect title="cpp/container/forward list/clear" />
    <revision>
      <id>28873</id>
      <parentid>28872</parentid>
      <timestamp>2012-05-01T17:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/forward_list/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/constructor</title>
    <ns>0</ns>
    <id>7948</id>
    <redirect title="cpp/container/forward list/forward list" />
    <revision>
      <id>28875</id>
      <parentid>28874</parentid>
      <timestamp>2012-05-01T17:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="53">#redirect [[cpp/container/forward_list/forward_list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/empty</title>
    <ns>0</ns>
    <id>7949</id>
    <redirect title="cpp/container/forward list/empty" />
    <revision>
      <id>28877</id>
      <parentid>28876</parentid>
      <timestamp>2012-05-01T17:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/forward_list/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/end</title>
    <ns>0</ns>
    <id>7950</id>
    <redirect title="cpp/container/forward list/end" />
    <revision>
      <id>28879</id>
      <parentid>28878</parentid>
      <timestamp>2012-05-01T17:31:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/forward_list/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/erase after</title>
    <ns>0</ns>
    <id>7951</id>
    <redirect title="cpp/container/forward list/erase after" />
    <revision>
      <id>28881</id>
      <parentid>28880</parentid>
      <timestamp>2012-05-01T17:31:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/forward_list/erase_after]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/front</title>
    <ns>0</ns>
    <id>7952</id>
    <redirect title="cpp/container/forward list/front" />
    <revision>
      <id>28883</id>
      <parentid>28882</parentid>
      <timestamp>2012-05-01T17:31:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/forward_list/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/get allocator</title>
    <ns>0</ns>
    <id>7953</id>
    <redirect title="cpp/container/forward list/get allocator" />
    <revision>
      <id>28885</id>
      <parentid>28884</parentid>
      <timestamp>2012-05-01T17:31:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="54">#redirect [[cpp/container/forward_list/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/insert after</title>
    <ns>0</ns>
    <id>7954</id>
    <redirect title="cpp/container/forward list/insert after" />
    <revision>
      <id>28887</id>
      <parentid>28886</parentid>
      <timestamp>2012-05-01T17:31:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="53">#redirect [[cpp/container/forward_list/insert_after]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/max size</title>
    <ns>0</ns>
    <id>7955</id>
    <redirect title="cpp/container/forward list/max size" />
    <revision>
      <id>28889</id>
      <parentid>28888</parentid>
      <timestamp>2012-05-01T17:31:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/container/forward_list/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/operator comp</title>
    <ns>0</ns>
    <id>7956</id>
    <redirect title="cpp/container/forward list/operator cmp" />
    <revision>
      <id>36225</id>
      <parentid>28891</parentid>
      <timestamp>2012-06-17T12:45:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="53">#redirect [[cpp/container/forward_list/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/pop front</title>
    <ns>0</ns>
    <id>7957</id>
    <redirect title="cpp/container/forward list/pop front" />
    <revision>
      <id>28893</id>
      <parentid>28892</parentid>
      <timestamp>2012-05-01T17:31:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/forward_list/pop_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/push front</title>
    <ns>0</ns>
    <id>7958</id>
    <redirect title="cpp/container/forward list/push front" />
    <revision>
      <id>28895</id>
      <parentid>28894</parentid>
      <timestamp>2012-05-01T17:31:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/container/forward_list/push_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/size</title>
    <ns>0</ns>
    <id>7959</id>
    <redirect title="cpp/container/list/size" />
    <revision>
      <id>29721</id>
      <parentid>28897</parentid>
      <timestamp>2012-05-01T18:04:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/container/list/size]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/start</title>
    <ns>0</ns>
    <id>7960</id>
    <redirect title="cpp/container/forward list" />
    <revision>
      <id>28899</id>
      <parentid>28898</parentid>
      <timestamp>2012-05-01T17:31:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/forward_list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/forward list/swap</title>
    <ns>0</ns>
    <id>7962</id>
    <redirect title="cpp/container/forward list/swap" />
    <revision>
      <id>28903</id>
      <parentid>28902</parentid>
      <timestamp>2012-05-01T17:31:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/forward_list/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/</title>
    <ns>0</ns>
    <id>7992</id>
    <redirect title="cpp/container/list" />
    <revision>
      <id>28963</id>
      <parentid>28962</parentid>
      <timestamp>2012-05-01T17:32:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/container/list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/assign</title>
    <ns>0</ns>
    <id>7963</id>
    <redirect title="cpp/container/list/assign" />
    <revision>
      <id>28905</id>
      <parentid>28904</parentid>
      <timestamp>2012-05-01T17:31:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/back</title>
    <ns>0</ns>
    <id>7964</id>
    <redirect title="cpp/container/list/back" />
    <revision>
      <id>28907</id>
      <parentid>28906</parentid>
      <timestamp>2012-05-01T17:31:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/begin</title>
    <ns>0</ns>
    <id>7965</id>
    <redirect title="cpp/container/list/begin" />
    <revision>
      <id>28909</id>
      <parentid>28908</parentid>
      <timestamp>2012-05-01T17:31:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/clear</title>
    <ns>0</ns>
    <id>7966</id>
    <redirect title="cpp/container/list/clear" />
    <revision>
      <id>28911</id>
      <parentid>28910</parentid>
      <timestamp>2012-05-01T17:31:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/constructor</title>
    <ns>0</ns>
    <id>7967</id>
    <redirect title="cpp/container/list/list" />
    <revision>
      <id>28913</id>
      <parentid>28912</parentid>
      <timestamp>2012-05-01T17:31:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/empty</title>
    <ns>0</ns>
    <id>7968</id>
    <redirect title="cpp/container/list/empty" />
    <revision>
      <id>28915</id>
      <parentid>28914</parentid>
      <timestamp>2012-05-01T17:31:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/end</title>
    <ns>0</ns>
    <id>7969</id>
    <redirect title="cpp/container/list/end" />
    <revision>
      <id>28917</id>
      <parentid>28916</parentid>
      <timestamp>2012-05-01T17:32:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/list/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/erase</title>
    <ns>0</ns>
    <id>7970</id>
    <redirect title="cpp/container/list/erase" />
    <revision>
      <id>28919</id>
      <parentid>28918</parentid>
      <timestamp>2012-05-01T17:32:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/front</title>
    <ns>0</ns>
    <id>7971</id>
    <redirect title="cpp/container/list/front" />
    <revision>
      <id>28921</id>
      <parentid>28920</parentid>
      <timestamp>2012-05-01T17:32:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/get allocator</title>
    <ns>0</ns>
    <id>7972</id>
    <redirect title="cpp/container/list/get allocator" />
    <revision>
      <id>28923</id>
      <parentid>28922</parentid>
      <timestamp>2012-05-01T17:32:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/list/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/insert</title>
    <ns>0</ns>
    <id>7973</id>
    <redirect title="cpp/container/list/insert" />
    <revision>
      <id>28925</id>
      <parentid>28924</parentid>
      <timestamp>2012-05-01T17:32:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/list operators</title>
    <ns>0</ns>
    <id>7974</id>
    <redirect title="cpp/container/list/operator cmp" />
    <revision>
      <id>36226</id>
      <parentid>28927</parentid>
      <timestamp>2012-06-17T12:45:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/list/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/max size</title>
    <ns>0</ns>
    <id>7975</id>
    <redirect title="cpp/container/list/max size" />
    <revision>
      <id>28929</id>
      <parentid>28928</parentid>
      <timestamp>2012-05-01T17:32:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/list/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/merge</title>
    <ns>0</ns>
    <id>7976</id>
    <redirect title="cpp/container/list/merge" />
    <revision>
      <id>28931</id>
      <parentid>28930</parentid>
      <timestamp>2012-05-01T17:32:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/list/merge]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/operator comp</title>
    <ns>0</ns>
    <id>7977</id>
    <redirect title="cpp/container/list/operator cmp" />
    <revision>
      <id>36227</id>
      <parentid>28933</parentid>
      <timestamp>2012-06-17T12:45:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/list/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/pop back</title>
    <ns>0</ns>
    <id>7978</id>
    <redirect title="cpp/container/list/pop back" />
    <revision>
      <id>28935</id>
      <parentid>28934</parentid>
      <timestamp>2012-05-01T17:32:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/list/pop_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/pop front</title>
    <ns>0</ns>
    <id>7979</id>
    <redirect title="cpp/container/list/pop front" />
    <revision>
      <id>28937</id>
      <parentid>28936</parentid>
      <timestamp>2012-05-01T17:32:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/list/pop_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/push back</title>
    <ns>0</ns>
    <id>7980</id>
    <redirect title="cpp/container/list/push back" />
    <revision>
      <id>28939</id>
      <parentid>28938</parentid>
      <timestamp>2012-05-01T17:32:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/list/push_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/push front</title>
    <ns>0</ns>
    <id>7981</id>
    <redirect title="cpp/container/list/push front" />
    <revision>
      <id>28941</id>
      <parentid>28940</parentid>
      <timestamp>2012-05-01T17:32:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/list/push_front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/rbegin</title>
    <ns>0</ns>
    <id>7982</id>
    <redirect title="cpp/container/list/rbegin" />
    <revision>
      <id>28943</id>
      <parentid>28942</parentid>
      <timestamp>2012-05-01T17:32:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/remove</title>
    <ns>0</ns>
    <id>7983</id>
    <redirect title="cpp/container/list/remove" />
    <revision>
      <id>28945</id>
      <parentid>28944</parentid>
      <timestamp>2012-05-01T17:32:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/remove if</title>
    <ns>0</ns>
    <id>7984</id>
    <redirect title="cpp/container/list/remove" />
    <revision>
      <id>45612</id>
      <parentid>28947</parentid>
      <timestamp>2013-01-08T04:49:58Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/container/list/remove]]</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/rend</title>
    <ns>0</ns>
    <id>7985</id>
    <redirect title="cpp/container/list/rend" />
    <revision>
      <id>28949</id>
      <parentid>28948</parentid>
      <timestamp>2012-05-01T17:32:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/resize</title>
    <ns>0</ns>
    <id>7986</id>
    <redirect title="cpp/container/list/resize" />
    <revision>
      <id>28951</id>
      <parentid>28950</parentid>
      <timestamp>2012-05-01T17:32:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/reverse</title>
    <ns>0</ns>
    <id>7987</id>
    <redirect title="cpp/container/list/reverse" />
    <revision>
      <id>28953</id>
      <parentid>28952</parentid>
      <timestamp>2012-05-01T17:32:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/list/reverse]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/size</title>
    <ns>0</ns>
    <id>7988</id>
    <redirect title="cpp/container/list/size" />
    <revision>
      <id>28955</id>
      <parentid>28954</parentid>
      <timestamp>2012-05-01T17:32:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/sort</title>
    <ns>0</ns>
    <id>7989</id>
    <redirect title="cpp/container/list/sort" />
    <revision>
      <id>28957</id>
      <parentid>28956</parentid>
      <timestamp>2012-05-01T17:32:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/sort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/splice</title>
    <ns>0</ns>
    <id>7990</id>
    <redirect title="cpp/container/list/splice" />
    <revision>
      <id>28959</id>
      <parentid>28958</parentid>
      <timestamp>2012-05-01T17:32:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/splice]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/start</title>
    <ns>0</ns>
    <id>7991</id>
    <redirect title="cpp/container/list" />
    <revision>
      <id>28961</id>
      <parentid>28960</parentid>
      <timestamp>2012-05-01T17:32:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/container/list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/swap</title>
    <ns>0</ns>
    <id>7993</id>
    <redirect title="cpp/container/list/swap" />
    <revision>
      <id>28965</id>
      <parentid>28964</parentid>
      <timestamp>2012-05-01T17:32:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/list/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/list/unique</title>
    <ns>0</ns>
    <id>7994</id>
    <redirect title="cpp/container/list/unique" />
    <revision>
      <id>28967</id>
      <parentid>28966</parentid>
      <timestamp>2012-05-01T17:32:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/list/unique]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/</title>
    <ns>0</ns>
    <id>8019</id>
    <redirect title="cpp/container/map" />
    <revision>
      <id>29017</id>
      <parentid>29016</parentid>
      <timestamp>2012-05-01T17:32:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/container/map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/begin</title>
    <ns>0</ns>
    <id>7995</id>
    <redirect title="cpp/container/map/begin" />
    <revision>
      <id>28969</id>
      <parentid>28968</parentid>
      <timestamp>2012-05-01T17:32:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/map/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/clear</title>
    <ns>0</ns>
    <id>7996</id>
    <redirect title="cpp/container/map/clear" />
    <revision>
      <id>28971</id>
      <parentid>28970</parentid>
      <timestamp>2012-05-01T17:32:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/map/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/constructor</title>
    <ns>0</ns>
    <id>7997</id>
    <redirect title="cpp/container/map/map" />
    <revision>
      <id>28973</id>
      <parentid>28972</parentid>
      <timestamp>2012-05-01T17:32:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/container/map/map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/count</title>
    <ns>0</ns>
    <id>7998</id>
    <redirect title="cpp/container/map/count" />
    <revision>
      <id>29720</id>
      <parentid>28975</parentid>
      <timestamp>2012-05-01T18:04:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/container/map/count]]</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/map/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/empty</title>
    <ns>0</ns>
    <id>7999</id>
    <redirect title="cpp/container/map/empty" />
    <revision>
      <id>28977</id>
      <parentid>28976</parentid>
      <timestamp>2012-05-01T17:32:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/map/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/end</title>
    <ns>0</ns>
    <id>8000</id>
    <redirect title="cpp/container/map/end" />
    <revision>
      <id>28979</id>
      <parentid>28978</parentid>
      <timestamp>2012-05-01T17:32:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/container/map/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/equal range</title>
    <ns>0</ns>
    <id>8001</id>
    <redirect title="cpp/container/map/equal range" />
    <revision>
      <id>28981</id>
      <parentid>28980</parentid>
      <timestamp>2012-05-01T17:32:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/map/equal_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/erase</title>
    <ns>0</ns>
    <id>8002</id>
    <redirect title="cpp/container/map/erase" />
    <revision>
      <id>28983</id>
      <parentid>28982</parentid>
      <timestamp>2012-05-01T17:32:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/map/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/find</title>
    <ns>0</ns>
    <id>8003</id>
    <redirect title="cpp/container/map/find" />
    <revision>
      <id>28985</id>
      <parentid>28984</parentid>
      <timestamp>2012-05-01T17:32:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/map/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/get allocator</title>
    <ns>0</ns>
    <id>8004</id>
    <redirect title="cpp/container/map/get allocator" />
    <revision>
      <id>28987</id>
      <parentid>28986</parentid>
      <timestamp>2012-05-01T17:32:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/map/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/insert</title>
    <ns>0</ns>
    <id>8005</id>
    <redirect title="cpp/container/map/insert" />
    <revision>
      <id>28989</id>
      <parentid>28988</parentid>
      <timestamp>2012-05-01T17:32:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/map/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/key comp</title>
    <ns>0</ns>
    <id>8006</id>
    <redirect title="cpp/container/map/key comp" />
    <revision>
      <id>28991</id>
      <parentid>28990</parentid>
      <timestamp>2012-05-01T17:32:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/map/key_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/lower bound</title>
    <ns>0</ns>
    <id>8007</id>
    <redirect title="cpp/container/map/lower bound" />
    <revision>
      <id>28993</id>
      <parentid>28992</parentid>
      <timestamp>2012-05-01T17:32:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/map/lower_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/map operators</title>
    <ns>0</ns>
    <id>8008</id>
    <redirect title="cpp/container/map/operator cmp" />
    <revision>
      <id>36228</id>
      <parentid>28995</parentid>
      <timestamp>2012-06-17T12:45:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/map/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/max size</title>
    <ns>0</ns>
    <id>8009</id>
    <redirect title="cpp/container/map/max size" />
    <revision>
      <id>28997</id>
      <parentid>28996</parentid>
      <timestamp>2012-05-01T17:32:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/map/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/operator at</title>
    <ns>0</ns>
    <id>8010</id>
    <redirect title="cpp/container/map/operator at" />
    <revision>
      <id>28999</id>
      <parentid>28998</parentid>
      <timestamp>2012-05-01T17:32:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/map/operator_at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/operator comp</title>
    <ns>0</ns>
    <id>8011</id>
    <redirect title="cpp/container/map/operator cmp" />
    <revision>
      <id>36229</id>
      <parentid>29001</parentid>
      <timestamp>2012-06-17T12:45:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/map/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/rbegin</title>
    <ns>0</ns>
    <id>8012</id>
    <redirect title="cpp/container/map/rbegin" />
    <revision>
      <id>29003</id>
      <parentid>29002</parentid>
      <timestamp>2012-05-01T17:32:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/map/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/rend</title>
    <ns>0</ns>
    <id>8013</id>
    <redirect title="cpp/container/map/rend" />
    <revision>
      <id>29005</id>
      <parentid>29004</parentid>
      <timestamp>2012-05-01T17:32:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/map/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/size</title>
    <ns>0</ns>
    <id>8014</id>
    <redirect title="cpp/container/map/size" />
    <revision>
      <id>29007</id>
      <parentid>29006</parentid>
      <timestamp>2012-05-01T17:32:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/map/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/start</title>
    <ns>0</ns>
    <id>8018</id>
    <redirect title="cpp/container/map" />
    <revision>
      <id>29015</id>
      <parentid>29014</parentid>
      <timestamp>2012-05-01T17:32:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/container/map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/swap</title>
    <ns>0</ns>
    <id>8015</id>
    <redirect title="cpp/container/map/swap" />
    <revision>
      <id>29009</id>
      <parentid>29008</parentid>
      <timestamp>2012-05-01T17:32:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/map/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/upper bound</title>
    <ns>0</ns>
    <id>8016</id>
    <redirect title="cpp/container/map/upper bound" />
    <revision>
      <id>29011</id>
      <parentid>29010</parentid>
      <timestamp>2012-05-01T17:32:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/map/upper_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/map/value comp</title>
    <ns>0</ns>
    <id>8017</id>
    <redirect title="cpp/container/map/value comp" />
    <revision>
      <id>29013</id>
      <parentid>29012</parentid>
      <timestamp>2012-05-01T17:32:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/map/value_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/</title>
    <ns>0</ns>
    <id>8040</id>
    <redirect title="cpp/container/multimap" />
    <revision>
      <id>29059</id>
      <parentid>29058</parentid>
      <timestamp>2012-05-01T17:32:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/begin</title>
    <ns>0</ns>
    <id>8020</id>
    <redirect title="cpp/container/multimap/begin" />
    <revision>
      <id>29019</id>
      <parentid>29018</parentid>
      <timestamp>2012-05-01T17:32:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multimap/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/clear</title>
    <ns>0</ns>
    <id>8021</id>
    <redirect title="cpp/container/multimap/clear" />
    <revision>
      <id>29021</id>
      <parentid>29020</parentid>
      <timestamp>2012-05-01T17:32:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multimap/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/constructor</title>
    <ns>0</ns>
    <id>8022</id>
    <redirect title="cpp/container/multimap/multimap" />
    <revision>
      <id>29023</id>
      <parentid>29022</parentid>
      <timestamp>2012-05-01T17:32:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multimap/multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/count</title>
    <ns>0</ns>
    <id>8023</id>
    <redirect title="cpp/container/multimap/count" />
    <revision>
      <id>29025</id>
      <parentid>29024</parentid>
      <timestamp>2012-05-01T17:32:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multimap/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/empty</title>
    <ns>0</ns>
    <id>8024</id>
    <redirect title="cpp/container/multimap/empty" />
    <revision>
      <id>29027</id>
      <parentid>29026</parentid>
      <timestamp>2012-05-01T17:32:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multimap/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/end</title>
    <ns>0</ns>
    <id>8025</id>
    <redirect title="cpp/container/multimap/end" />
    <revision>
      <id>29029</id>
      <parentid>29028</parentid>
      <timestamp>2012-05-01T17:32:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/multimap/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/equal range</title>
    <ns>0</ns>
    <id>8026</id>
    <redirect title="cpp/container/multimap/equal range" />
    <revision>
      <id>29031</id>
      <parentid>29030</parentid>
      <timestamp>2012-05-01T17:32:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multimap/equal_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/erase</title>
    <ns>0</ns>
    <id>8027</id>
    <redirect title="cpp/container/multimap/erase" />
    <revision>
      <id>29033</id>
      <parentid>29032</parentid>
      <timestamp>2012-05-01T17:32:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multimap/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/find</title>
    <ns>0</ns>
    <id>8028</id>
    <redirect title="cpp/container/multimap/find" />
    <revision>
      <id>29035</id>
      <parentid>29034</parentid>
      <timestamp>2012-05-01T17:32:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multimap/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/get allocator</title>
    <ns>0</ns>
    <id>8029</id>
    <redirect title="cpp/container/multimap/get allocator" />
    <revision>
      <id>29037</id>
      <parentid>29036</parentid>
      <timestamp>2012-05-01T17:32:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/multimap/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/insert</title>
    <ns>0</ns>
    <id>8030</id>
    <redirect title="cpp/container/multimap/insert" />
    <revision>
      <id>29039</id>
      <parentid>29038</parentid>
      <timestamp>2012-05-01T17:32:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/multimap/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/key comp</title>
    <ns>0</ns>
    <id>8031</id>
    <redirect title="cpp/container/multimap/key comp" />
    <revision>
      <id>29041</id>
      <parentid>29040</parentid>
      <timestamp>2012-05-01T17:32:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multimap/key_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/lower bound</title>
    <ns>0</ns>
    <id>8032</id>
    <redirect title="cpp/container/multimap/lower bound" />
    <revision>
      <id>29043</id>
      <parentid>29042</parentid>
      <timestamp>2012-05-01T17:32:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multimap/lower_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/max size</title>
    <ns>0</ns>
    <id>8033</id>
    <redirect title="cpp/container/multimap/max size" />
    <revision>
      <id>29045</id>
      <parentid>29044</parentid>
      <timestamp>2012-05-01T17:32:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multimap/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/multimap operators</title>
    <ns>0</ns>
    <id>8034</id>
    <redirect title="cpp/container/multimap/operator cmp" />
    <revision>
      <id>36230</id>
      <parentid>29047</parentid>
      <timestamp>2012-06-17T12:46:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/container/multimap/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/operator comp</title>
    <ns>0</ns>
    <id>8035</id>
    <redirect title="cpp/container/multimap/operator cmp" />
    <revision>
      <id>36231</id>
      <parentid>29049</parentid>
      <timestamp>2012-06-17T12:46:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/container/multimap/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/rbegin</title>
    <ns>0</ns>
    <id>8036</id>
    <redirect title="cpp/container/multimap/rbegin" />
    <revision>
      <id>29051</id>
      <parentid>29050</parentid>
      <timestamp>2012-05-01T17:32:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/multimap/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/rend</title>
    <ns>0</ns>
    <id>8037</id>
    <redirect title="cpp/container/multimap/rend" />
    <revision>
      <id>29053</id>
      <parentid>29052</parentid>
      <timestamp>2012-05-01T17:32:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multimap/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/size</title>
    <ns>0</ns>
    <id>8038</id>
    <redirect title="cpp/container/multimap/size" />
    <revision>
      <id>29055</id>
      <parentid>29054</parentid>
      <timestamp>2012-05-01T17:32:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multimap/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/start</title>
    <ns>0</ns>
    <id>8039</id>
    <redirect title="cpp/container/multimap" />
    <revision>
      <id>29057</id>
      <parentid>29056</parentid>
      <timestamp>2012-05-01T17:32:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/swap</title>
    <ns>0</ns>
    <id>8041</id>
    <redirect title="cpp/container/multimap/swap" />
    <revision>
      <id>29061</id>
      <parentid>29060</parentid>
      <timestamp>2012-05-01T17:32:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multimap/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/upper bound</title>
    <ns>0</ns>
    <id>8042</id>
    <redirect title="cpp/container/multimap/upper bound" />
    <revision>
      <id>29063</id>
      <parentid>29062</parentid>
      <timestamp>2012-05-01T17:32:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multimap/upper_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multimap/value comp</title>
    <ns>0</ns>
    <id>8043</id>
    <redirect title="cpp/container/multimap/value comp" />
    <revision>
      <id>29065</id>
      <parentid>29064</parentid>
      <timestamp>2012-05-01T17:32:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/multimap/value_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/</title>
    <ns>0</ns>
    <id>8064</id>
    <redirect title="cpp/container/multiset" />
    <revision>
      <id>29107</id>
      <parentid>29106</parentid>
      <timestamp>2012-05-01T17:32:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/begin</title>
    <ns>0</ns>
    <id>8044</id>
    <redirect title="cpp/container/multiset/begin" />
    <revision>
      <id>29067</id>
      <parentid>29066</parentid>
      <timestamp>2012-05-01T17:32:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multiset/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/clear</title>
    <ns>0</ns>
    <id>8045</id>
    <redirect title="cpp/container/multiset/clear" />
    <revision>
      <id>29069</id>
      <parentid>29068</parentid>
      <timestamp>2012-05-01T17:32:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multiset/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/constructor</title>
    <ns>0</ns>
    <id>8046</id>
    <redirect title="cpp/container/multiset/multiset" />
    <revision>
      <id>29071</id>
      <parentid>29070</parentid>
      <timestamp>2012-05-01T17:32:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multiset/multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/count</title>
    <ns>0</ns>
    <id>8047</id>
    <redirect title="cpp/container/multiset/count" />
    <revision>
      <id>29073</id>
      <parentid>29072</parentid>
      <timestamp>2012-05-01T17:32:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multiset/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/empty</title>
    <ns>0</ns>
    <id>8048</id>
    <redirect title="cpp/container/multiset/empty" />
    <revision>
      <id>29075</id>
      <parentid>29074</parentid>
      <timestamp>2012-05-01T17:32:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multiset/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/end</title>
    <ns>0</ns>
    <id>8049</id>
    <redirect title="cpp/container/multiset/end" />
    <revision>
      <id>29077</id>
      <parentid>29076</parentid>
      <timestamp>2012-05-01T17:32:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/multiset/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/equal range</title>
    <ns>0</ns>
    <id>8050</id>
    <redirect title="cpp/container/multiset/equal range" />
    <revision>
      <id>29079</id>
      <parentid>29078</parentid>
      <timestamp>2012-05-01T17:32:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multiset/equal_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/erase</title>
    <ns>0</ns>
    <id>8051</id>
    <redirect title="cpp/container/multiset/erase" />
    <revision>
      <id>29081</id>
      <parentid>29080</parentid>
      <timestamp>2012-05-01T17:32:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/multiset/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/find</title>
    <ns>0</ns>
    <id>8052</id>
    <redirect title="cpp/container/multiset/find" />
    <revision>
      <id>29083</id>
      <parentid>29082</parentid>
      <timestamp>2012-05-01T17:32:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multiset/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/get allocator</title>
    <ns>0</ns>
    <id>8053</id>
    <redirect title="cpp/container/multiset/get allocator" />
    <revision>
      <id>29085</id>
      <parentid>29084</parentid>
      <timestamp>2012-05-01T17:32:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/multiset/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/insert</title>
    <ns>0</ns>
    <id>8054</id>
    <redirect title="cpp/container/multiset/insert" />
    <revision>
      <id>29087</id>
      <parentid>29086</parentid>
      <timestamp>2012-05-01T17:32:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/multiset/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/key comp</title>
    <ns>0</ns>
    <id>8055</id>
    <redirect title="cpp/container/multiset/key comp" />
    <revision>
      <id>29089</id>
      <parentid>29088</parentid>
      <timestamp>2012-05-01T17:32:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multiset/key_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/lower bound</title>
    <ns>0</ns>
    <id>8056</id>
    <redirect title="cpp/container/multiset/lower bound" />
    <revision>
      <id>29091</id>
      <parentid>29090</parentid>
      <timestamp>2012-05-01T17:32:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multiset/lower_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/max size</title>
    <ns>0</ns>
    <id>8057</id>
    <redirect title="cpp/container/multiset/max size" />
    <revision>
      <id>29093</id>
      <parentid>29092</parentid>
      <timestamp>2012-05-01T17:32:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/multiset/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/multiset operators</title>
    <ns>0</ns>
    <id>8058</id>
    <redirect title="cpp/container/multiset/operator cmp" />
    <revision>
      <id>36232</id>
      <parentid>29095</parentid>
      <timestamp>2012-06-17T12:46:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/container/multiset/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/operator comp</title>
    <ns>0</ns>
    <id>8059</id>
    <redirect title="cpp/container/multiset/operator cmp" />
    <revision>
      <id>36233</id>
      <parentid>29097</parentid>
      <timestamp>2012-06-17T12:46:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/container/multiset/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/rbegin</title>
    <ns>0</ns>
    <id>8060</id>
    <redirect title="cpp/container/multiset/rbegin" />
    <revision>
      <id>29099</id>
      <parentid>29098</parentid>
      <timestamp>2012-05-01T17:32:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/multiset/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/rend</title>
    <ns>0</ns>
    <id>8061</id>
    <redirect title="cpp/container/multiset/rend" />
    <revision>
      <id>29101</id>
      <parentid>29100</parentid>
      <timestamp>2012-05-01T17:32:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multiset/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/size</title>
    <ns>0</ns>
    <id>8062</id>
    <redirect title="cpp/container/multiset/size" />
    <revision>
      <id>29103</id>
      <parentid>29102</parentid>
      <timestamp>2012-05-01T17:32:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multiset/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/start</title>
    <ns>0</ns>
    <id>8063</id>
    <redirect title="cpp/container/multiset" />
    <revision>
      <id>29105</id>
      <parentid>29104</parentid>
      <timestamp>2012-05-01T17:32:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/swap</title>
    <ns>0</ns>
    <id>8065</id>
    <redirect title="cpp/container/multiset/swap" />
    <revision>
      <id>29109</id>
      <parentid>29108</parentid>
      <timestamp>2012-05-01T17:32:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/multiset/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/upper bound</title>
    <ns>0</ns>
    <id>8066</id>
    <redirect title="cpp/container/multiset/upper bound" />
    <revision>
      <id>29111</id>
      <parentid>29110</parentid>
      <timestamp>2012-05-01T17:32:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/multiset/upper_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/multiset/value comp</title>
    <ns>0</ns>
    <id>8067</id>
    <redirect title="cpp/container/multiset/value comp" />
    <revision>
      <id>29113</id>
      <parentid>29112</parentid>
      <timestamp>2012-05-01T17:32:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/multiset/value_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/</title>
    <ns>0</ns>
    <id>8074</id>
    <redirect title="cpp/container/priority queue" />
    <revision>
      <id>29127</id>
      <parentid>29126</parentid>
      <timestamp>2012-05-01T17:32:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/priority_queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/constructor</title>
    <ns>0</ns>
    <id>8068</id>
    <redirect title="cpp/container/priority queue/priority queue" />
    <revision>
      <id>29115</id>
      <parentid>29114</parentid>
      <timestamp>2012-05-01T17:32:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="57">#redirect [[cpp/container/priority_queue/priority_queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/empty</title>
    <ns>0</ns>
    <id>8069</id>
    <redirect title="cpp/container/priority queue/empty" />
    <revision>
      <id>29117</id>
      <parentid>29116</parentid>
      <timestamp>2012-05-01T17:32:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/priority_queue/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/pop</title>
    <ns>0</ns>
    <id>8070</id>
    <redirect title="cpp/container/priority queue/pop" />
    <revision>
      <id>29119</id>
      <parentid>29118</parentid>
      <timestamp>2012-05-01T17:32:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/priority_queue/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/push</title>
    <ns>0</ns>
    <id>8071</id>
    <redirect title="cpp/container/priority queue/push" />
    <revision>
      <id>29121</id>
      <parentid>29120</parentid>
      <timestamp>2012-05-01T17:32:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/priority_queue/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/size</title>
    <ns>0</ns>
    <id>8072</id>
    <redirect title="cpp/container/priority queue/size" />
    <revision>
      <id>29123</id>
      <parentid>29122</parentid>
      <timestamp>2012-05-01T17:32:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/priority_queue/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/start</title>
    <ns>0</ns>
    <id>8073</id>
    <redirect title="cpp/container/priority queue" />
    <revision>
      <id>29125</id>
      <parentid>29124</parentid>
      <timestamp>2012-05-01T17:32:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/priority_queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/swap</title>
    <ns>0</ns>
    <id>8075</id>
    <redirect title="cpp/container/priority queue/swap" />
    <revision>
      <id>29129</id>
      <parentid>29128</parentid>
      <timestamp>2012-05-01T17:32:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/priority_queue/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/priority queue/top</title>
    <ns>0</ns>
    <id>8076</id>
    <redirect title="cpp/container/priority queue/top" />
    <revision>
      <id>29131</id>
      <parentid>29130</parentid>
      <timestamp>2012-05-01T17:32:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/priority_queue/top]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/</title>
    <ns>0</ns>
    <id>8085</id>
    <redirect title="cpp/container/queue" />
    <revision>
      <id>29149</id>
      <parentid>29148</parentid>
      <timestamp>2012-05-01T17:32:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/back</title>
    <ns>0</ns>
    <id>8077</id>
    <redirect title="cpp/container/queue/back" />
    <revision>
      <id>29133</id>
      <parentid>29132</parentid>
      <timestamp>2012-05-01T17:32:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/queue/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/constructor</title>
    <ns>0</ns>
    <id>8078</id>
    <redirect title="cpp/container/queue/queue" />
    <revision>
      <id>29135</id>
      <parentid>29134</parentid>
      <timestamp>2012-05-01T17:32:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/queue/queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/empty</title>
    <ns>0</ns>
    <id>8079</id>
    <redirect title="cpp/container/queue/empty" />
    <revision>
      <id>29137</id>
      <parentid>29136</parentid>
      <timestamp>2012-05-01T17:32:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/queue/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/front</title>
    <ns>0</ns>
    <id>8080</id>
    <redirect title="cpp/container/queue/front" />
    <revision>
      <id>29139</id>
      <parentid>29138</parentid>
      <timestamp>2012-05-01T17:32:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/queue/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/pop</title>
    <ns>0</ns>
    <id>8081</id>
    <redirect title="cpp/container/queue/pop" />
    <revision>
      <id>29141</id>
      <parentid>29140</parentid>
      <timestamp>2012-05-01T17:32:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/queue/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/push</title>
    <ns>0</ns>
    <id>8082</id>
    <redirect title="cpp/container/queue/push" />
    <revision>
      <id>29143</id>
      <parentid>29142</parentid>
      <timestamp>2012-05-01T17:32:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/queue/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/size</title>
    <ns>0</ns>
    <id>8083</id>
    <redirect title="cpp/container/queue/size" />
    <revision>
      <id>29145</id>
      <parentid>29144</parentid>
      <timestamp>2012-05-01T17:32:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/queue/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/start</title>
    <ns>0</ns>
    <id>8084</id>
    <redirect title="cpp/container/queue" />
    <revision>
      <id>29147</id>
      <parentid>29146</parentid>
      <timestamp>2012-05-01T17:32:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/queue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/queue/swap</title>
    <ns>0</ns>
    <id>8086</id>
    <redirect title="cpp/container/queue/swap" />
    <revision>
      <id>29151</id>
      <parentid>29150</parentid>
      <timestamp>2012-05-01T17:32:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/queue/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/</title>
    <ns>0</ns>
    <id>8107</id>
    <redirect title="cpp/container/set" />
    <revision>
      <id>29193</id>
      <parentid>29192</parentid>
      <timestamp>2012-05-01T17:32:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/container/set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/begin</title>
    <ns>0</ns>
    <id>8087</id>
    <redirect title="cpp/container/set/begin" />
    <revision>
      <id>29153</id>
      <parentid>29152</parentid>
      <timestamp>2012-05-01T17:32:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/set/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/clear</title>
    <ns>0</ns>
    <id>8088</id>
    <redirect title="cpp/container/set/clear" />
    <revision>
      <id>29155</id>
      <parentid>29154</parentid>
      <timestamp>2012-05-01T17:32:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/set/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/constructor</title>
    <ns>0</ns>
    <id>8089</id>
    <redirect title="cpp/container/set/set" />
    <revision>
      <id>29157</id>
      <parentid>29156</parentid>
      <timestamp>2012-05-01T17:32:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/container/set/set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/count</title>
    <ns>0</ns>
    <id>8090</id>
    <redirect title="cpp/container/set/count" />
    <revision>
      <id>29159</id>
      <parentid>29158</parentid>
      <timestamp>2012-05-01T17:32:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/set/count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/empty</title>
    <ns>0</ns>
    <id>8091</id>
    <redirect title="cpp/container/set/empty" />
    <revision>
      <id>29161</id>
      <parentid>29160</parentid>
      <timestamp>2012-05-01T17:32:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/set/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/end</title>
    <ns>0</ns>
    <id>8092</id>
    <redirect title="cpp/container/set/end" />
    <revision>
      <id>29163</id>
      <parentid>29162</parentid>
      <timestamp>2012-05-01T17:32:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/container/set/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/equal range</title>
    <ns>0</ns>
    <id>8093</id>
    <redirect title="cpp/container/set/equal range" />
    <revision>
      <id>29165</id>
      <parentid>29164</parentid>
      <timestamp>2012-05-01T17:32:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/set/equal_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/erase</title>
    <ns>0</ns>
    <id>8094</id>
    <redirect title="cpp/container/set/erase" />
    <revision>
      <id>29167</id>
      <parentid>29166</parentid>
      <timestamp>2012-05-01T17:32:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/set/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/find</title>
    <ns>0</ns>
    <id>8095</id>
    <redirect title="cpp/container/set/find" />
    <revision>
      <id>29169</id>
      <parentid>29168</parentid>
      <timestamp>2012-05-01T17:32:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/set/find]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/get allocator</title>
    <ns>0</ns>
    <id>8096</id>
    <redirect title="cpp/container/set/get allocator" />
    <revision>
      <id>29171</id>
      <parentid>29170</parentid>
      <timestamp>2012-05-01T17:32:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/set/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/insert</title>
    <ns>0</ns>
    <id>8097</id>
    <redirect title="cpp/container/set/insert" />
    <revision>
      <id>29173</id>
      <parentid>29172</parentid>
      <timestamp>2012-05-01T17:32:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/set/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/key comp</title>
    <ns>0</ns>
    <id>8098</id>
    <redirect title="cpp/container/set/key comp" />
    <revision>
      <id>29175</id>
      <parentid>29174</parentid>
      <timestamp>2012-05-01T17:32:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/set/key_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/lower bound</title>
    <ns>0</ns>
    <id>8099</id>
    <redirect title="cpp/container/set/lower bound" />
    <revision>
      <id>29177</id>
      <parentid>29176</parentid>
      <timestamp>2012-05-01T17:32:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/set/lower_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/max size</title>
    <ns>0</ns>
    <id>8100</id>
    <redirect title="cpp/container/set/max size" />
    <revision>
      <id>29179</id>
      <parentid>29178</parentid>
      <timestamp>2012-05-01T17:32:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/set/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/operator comp</title>
    <ns>0</ns>
    <id>8101</id>
    <redirect title="cpp/container/set/operator cmp" />
    <revision>
      <id>36234</id>
      <parentid>29181</parentid>
      <timestamp>2012-06-17T12:46:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/set/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/rbegin</title>
    <ns>0</ns>
    <id>8102</id>
    <redirect title="cpp/container/set/rbegin" />
    <revision>
      <id>29183</id>
      <parentid>29182</parentid>
      <timestamp>2012-05-01T17:32:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/set/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/rend</title>
    <ns>0</ns>
    <id>8103</id>
    <redirect title="cpp/container/set/rend" />
    <revision>
      <id>29185</id>
      <parentid>29184</parentid>
      <timestamp>2012-05-01T17:32:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/set/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/set operators</title>
    <ns>0</ns>
    <id>8104</id>
    <redirect title="cpp/container/set/operator cmp" />
    <revision>
      <id>36235</id>
      <parentid>29187</parentid>
      <timestamp>2012-06-17T12:46:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/set/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/size</title>
    <ns>0</ns>
    <id>8105</id>
    <redirect title="cpp/container/set/size" />
    <revision>
      <id>29189</id>
      <parentid>29188</parentid>
      <timestamp>2012-05-01T17:32:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/set/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/start</title>
    <ns>0</ns>
    <id>8106</id>
    <redirect title="cpp/container/set" />
    <revision>
      <id>29191</id>
      <parentid>29190</parentid>
      <timestamp>2012-05-01T17:32:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/container/set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/swap</title>
    <ns>0</ns>
    <id>8108</id>
    <redirect title="cpp/container/set/swap" />
    <revision>
      <id>29195</id>
      <parentid>29194</parentid>
      <timestamp>2012-05-01T17:32:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/container/set/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/upper bound</title>
    <ns>0</ns>
    <id>8109</id>
    <redirect title="cpp/container/set/upper bound" />
    <revision>
      <id>29197</id>
      <parentid>29196</parentid>
      <timestamp>2012-05-01T17:32:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/set/upper_bound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/set/value comp</title>
    <ns>0</ns>
    <id>8110</id>
    <redirect title="cpp/container/set/value comp" />
    <revision>
      <id>29199</id>
      <parentid>29198</parentid>
      <timestamp>2012-05-01T17:32:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/set/value_comp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/</title>
    <ns>0</ns>
    <id>8117</id>
    <redirect title="cpp/container/stack" />
    <revision>
      <id>29213</id>
      <parentid>29212</parentid>
      <timestamp>2012-05-01T17:32:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/constructor</title>
    <ns>0</ns>
    <id>8111</id>
    <redirect title="cpp/container/stack/stack" />
    <revision>
      <id>29201</id>
      <parentid>29200</parentid>
      <timestamp>2012-05-01T17:32:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/stack/stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/empty</title>
    <ns>0</ns>
    <id>8112</id>
    <redirect title="cpp/container/stack/empty" />
    <revision>
      <id>29203</id>
      <parentid>29202</parentid>
      <timestamp>2012-05-01T17:32:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/stack/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/pop</title>
    <ns>0</ns>
    <id>8113</id>
    <redirect title="cpp/container/stack/pop" />
    <revision>
      <id>29205</id>
      <parentid>29204</parentid>
      <timestamp>2012-05-01T17:32:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/stack/pop]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/push</title>
    <ns>0</ns>
    <id>8114</id>
    <redirect title="cpp/container/stack/push" />
    <revision>
      <id>29207</id>
      <parentid>29206</parentid>
      <timestamp>2012-05-01T17:32:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/stack/push]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/size</title>
    <ns>0</ns>
    <id>8115</id>
    <redirect title="cpp/container/stack/size" />
    <revision>
      <id>29209</id>
      <parentid>29208</parentid>
      <timestamp>2012-05-01T17:32:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/stack/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/start</title>
    <ns>0</ns>
    <id>8116</id>
    <redirect title="cpp/container/stack" />
    <revision>
      <id>29211</id>
      <parentid>29210</parentid>
      <timestamp>2012-05-01T17:32:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/container/stack]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/swap</title>
    <ns>0</ns>
    <id>8118</id>
    <redirect title="cpp/container/stack/swap" />
    <revision>
      <id>29215</id>
      <parentid>29214</parentid>
      <timestamp>2012-05-01T17:32:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/stack/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/stack/top</title>
    <ns>0</ns>
    <id>8119</id>
    <redirect title="cpp/container/stack/top" />
    <revision>
      <id>29217</id>
      <parentid>29216</parentid>
      <timestamp>2012-05-01T17:32:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/stack/top]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/start</title>
    <ns>0</ns>
    <id>8198</id>
    <redirect title="cpp/container" />
    <revision>
      <id>29375</id>
      <parentid>29374</parentid>
      <timestamp>2012-05-01T17:33:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/container]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/</title>
    <ns>0</ns>
    <id>8131</id>
    <redirect title="cpp/container/unordered map" />
    <revision>
      <id>29241</id>
      <parentid>29240</parentid>
      <timestamp>2012-05-01T17:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/unordered_map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/begin</title>
    <ns>0</ns>
    <id>8120</id>
    <redirect title="cpp/container/unordered map/begin" />
    <revision>
      <id>29219</id>
      <parentid>29218</parentid>
      <timestamp>2012-05-01T17:32:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_map/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/clear</title>
    <ns>0</ns>
    <id>8121</id>
    <redirect title="cpp/container/unordered map/clear" />
    <revision>
      <id>29221</id>
      <parentid>29220</parentid>
      <timestamp>2012-05-01T17:32:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_map/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/constructor</title>
    <ns>0</ns>
    <id>8122</id>
    <redirect title="cpp/container/unordered map/unordered map" />
    <revision>
      <id>29223</id>
      <parentid>29222</parentid>
      <timestamp>2012-05-01T17:32:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_map/unordered_map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/empty</title>
    <ns>0</ns>
    <id>8123</id>
    <redirect title="cpp/container/unordered map/empty" />
    <revision>
      <id>29225</id>
      <parentid>29224</parentid>
      <timestamp>2012-05-01T17:32:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_map/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/end</title>
    <ns>0</ns>
    <id>8124</id>
    <redirect title="cpp/container/unordered map/end" />
    <revision>
      <id>29227</id>
      <parentid>29226</parentid>
      <timestamp>2012-05-01T17:32:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/unordered_map/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/get allocator</title>
    <ns>0</ns>
    <id>8125</id>
    <redirect title="cpp/container/unordered map/get allocator" />
    <revision>
      <id>29229</id>
      <parentid>29228</parentid>
      <timestamp>2012-05-01T17:33:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_map/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/max size</title>
    <ns>0</ns>
    <id>8126</id>
    <redirect title="cpp/container/unordered map/max size" />
    <revision>
      <id>29231</id>
      <parentid>29230</parentid>
      <timestamp>2012-05-01T17:33:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/unordered_map/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/operator comp</title>
    <ns>0</ns>
    <id>8127</id>
    <redirect title="cpp/container/unordered map/operator cmp" />
    <revision>
      <id>36236</id>
      <parentid>29233</parentid>
      <timestamp>2012-06-17T12:46:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="54">#redirect [[cpp/container/unordered_map/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/size</title>
    <ns>0</ns>
    <id>8128</id>
    <redirect title="cpp/container/unordered map/size" />
    <revision>
      <id>29235</id>
      <parentid>29234</parentid>
      <timestamp>2012-05-01T17:33:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_map/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/start</title>
    <ns>0</ns>
    <id>8130</id>
    <redirect title="cpp/container/unordered map" />
    <revision>
      <id>29239</id>
      <parentid>29238</parentid>
      <timestamp>2012-05-01T17:33:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/unordered_map]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered map/swap</title>
    <ns>0</ns>
    <id>8129</id>
    <redirect title="cpp/container/unordered map/swap" />
    <revision>
      <id>29237</id>
      <parentid>29236</parentid>
      <timestamp>2012-05-01T17:33:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_map/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/</title>
    <ns>0</ns>
    <id>8142</id>
    <redirect title="cpp/container/unordered multimap" />
    <revision>
      <id>29263</id>
      <parentid>29262</parentid>
      <timestamp>2012-05-01T17:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/begin</title>
    <ns>0</ns>
    <id>8132</id>
    <redirect title="cpp/container/unordered multimap/begin" />
    <revision>
      <id>29243</id>
      <parentid>29242</parentid>
      <timestamp>2012-05-01T17:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multimap/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/clear</title>
    <ns>0</ns>
    <id>8133</id>
    <redirect title="cpp/container/unordered multimap/clear" />
    <revision>
      <id>29245</id>
      <parentid>29244</parentid>
      <timestamp>2012-05-01T17:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multimap/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/constructor</title>
    <ns>0</ns>
    <id>8134</id>
    <redirect title="cpp/container/unordered multimap/unordered multimap" />
    <revision>
      <id>29247</id>
      <parentid>29246</parentid>
      <timestamp>2012-05-01T17:33:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="65">#redirect [[cpp/container/unordered_multimap/unordered_multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/empty</title>
    <ns>0</ns>
    <id>8135</id>
    <redirect title="cpp/container/unordered multimap/empty" />
    <revision>
      <id>29249</id>
      <parentid>29248</parentid>
      <timestamp>2012-05-01T17:33:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multimap/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/end</title>
    <ns>0</ns>
    <id>8136</id>
    <redirect title="cpp/container/unordered multimap/end" />
    <revision>
      <id>29251</id>
      <parentid>29250</parentid>
      <timestamp>2012-05-01T17:33:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/unordered_multimap/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/get allocator</title>
    <ns>0</ns>
    <id>8137</id>
    <redirect title="cpp/container/unordered multimap/get allocator" />
    <revision>
      <id>29253</id>
      <parentid>29252</parentid>
      <timestamp>2012-05-01T17:33:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/container/unordered_multimap/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/max size</title>
    <ns>0</ns>
    <id>8138</id>
    <redirect title="cpp/container/unordered multimap/max size" />
    <revision>
      <id>29255</id>
      <parentid>29254</parentid>
      <timestamp>2012-05-01T17:33:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_multimap/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/operator comp</title>
    <ns>0</ns>
    <id>8139</id>
    <redirect title="cpp/container/unordered multimap/operator cmp" />
    <revision>
      <id>36237</id>
      <parentid>29257</parentid>
      <timestamp>2012-06-17T12:47:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/container/unordered_multimap/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/size</title>
    <ns>0</ns>
    <id>8140</id>
    <redirect title="cpp/container/unordered multimap/size" />
    <revision>
      <id>29722</id>
      <parentid>29259</parentid>
      <timestamp>2012-05-01T18:04:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/container/unordered multimap/size]]</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/container/unordered_multimap/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/start</title>
    <ns>0</ns>
    <id>8141</id>
    <redirect title="cpp/container/unordered multimap" />
    <revision>
      <id>29261</id>
      <parentid>29260</parentid>
      <timestamp>2012-05-01T17:33:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_multimap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multimap/swap</title>
    <ns>0</ns>
    <id>8143</id>
    <redirect title="cpp/container/unordered multimap/swap" />
    <revision>
      <id>29265</id>
      <parentid>29264</parentid>
      <timestamp>2012-05-01T17:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/container/unordered_multimap/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/</title>
    <ns>0</ns>
    <id>8154</id>
    <redirect title="cpp/container/unordered multiset" />
    <revision>
      <id>29287</id>
      <parentid>29286</parentid>
      <timestamp>2012-05-01T17:33:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/begin</title>
    <ns>0</ns>
    <id>8144</id>
    <redirect title="cpp/container/unordered multiset/begin" />
    <revision>
      <id>29267</id>
      <parentid>29266</parentid>
      <timestamp>2012-05-01T17:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multiset/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/clear</title>
    <ns>0</ns>
    <id>8145</id>
    <redirect title="cpp/container/unordered multiset/clear" />
    <revision>
      <id>29269</id>
      <parentid>29268</parentid>
      <timestamp>2012-05-01T17:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multiset/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/constructor</title>
    <ns>0</ns>
    <id>8146</id>
    <redirect title="cpp/container/unordered multiset/unordered multiset" />
    <revision>
      <id>29271</id>
      <parentid>29270</parentid>
      <timestamp>2012-05-01T17:33:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="65">#redirect [[cpp/container/unordered_multiset/unordered_multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/empty</title>
    <ns>0</ns>
    <id>8147</id>
    <redirect title="cpp/container/unordered multiset/empty" />
    <revision>
      <id>29273</id>
      <parentid>29272</parentid>
      <timestamp>2012-05-01T17:33:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="52">#redirect [[cpp/container/unordered_multiset/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/end</title>
    <ns>0</ns>
    <id>8148</id>
    <redirect title="cpp/container/unordered multiset/end" />
    <revision>
      <id>29275</id>
      <parentid>29274</parentid>
      <timestamp>2012-05-01T17:33:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/unordered_multiset/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/get allocator</title>
    <ns>0</ns>
    <id>8149</id>
    <redirect title="cpp/container/unordered multiset/get allocator" />
    <revision>
      <id>29277</id>
      <parentid>29276</parentid>
      <timestamp>2012-05-01T17:33:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/container/unordered_multiset/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/max size</title>
    <ns>0</ns>
    <id>8150</id>
    <redirect title="cpp/container/unordered multiset/max size" />
    <revision>
      <id>29723</id>
      <parentid>29279</parentid>
      <timestamp>2012-05-01T18:04:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/container/unordered multiset/max size]]</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_multiset/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/operator comp</title>
    <ns>0</ns>
    <id>8151</id>
    <redirect title="cpp/container/unordered multiset/operator cmp" />
    <revision>
      <id>36238</id>
      <parentid>29281</parentid>
      <timestamp>2012-06-17T12:48:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="59">#redirect [[cpp/container/unordered_multiset/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/size</title>
    <ns>0</ns>
    <id>8152</id>
    <redirect title="cpp/container/unordered multiset/size" />
    <revision>
      <id>29283</id>
      <parentid>29282</parentid>
      <timestamp>2012-05-01T17:33:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/container/unordered_multiset/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/start</title>
    <ns>0</ns>
    <id>8153</id>
    <redirect title="cpp/container/unordered multiset" />
    <revision>
      <id>29285</id>
      <parentid>29284</parentid>
      <timestamp>2012-05-01T17:33:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_multiset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered multiset/swap</title>
    <ns>0</ns>
    <id>8155</id>
    <redirect title="cpp/container/unordered multiset/swap" />
    <revision>
      <id>29289</id>
      <parentid>29288</parentid>
      <timestamp>2012-05-01T17:33:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="51">#redirect [[cpp/container/unordered_multiset/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/</title>
    <ns>0</ns>
    <id>8167</id>
    <redirect title="cpp/container/unordered set" />
    <revision>
      <id>29313</id>
      <parentid>29312</parentid>
      <timestamp>2012-05-01T17:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/unordered_set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/begin</title>
    <ns>0</ns>
    <id>8156</id>
    <redirect title="cpp/container/unordered set/begin" />
    <revision>
      <id>29291</id>
      <parentid>29290</parentid>
      <timestamp>2012-05-01T17:33:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_set/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/clear</title>
    <ns>0</ns>
    <id>8157</id>
    <redirect title="cpp/container/unordered set/clear" />
    <revision>
      <id>29293</id>
      <parentid>29292</parentid>
      <timestamp>2012-05-01T17:33:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_set/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/constructor</title>
    <ns>0</ns>
    <id>8158</id>
    <redirect title="cpp/container/unordered set/unordered set" />
    <revision>
      <id>29295</id>
      <parentid>29294</parentid>
      <timestamp>2012-05-01T17:33:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_set/unordered_set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/empty</title>
    <ns>0</ns>
    <id>8159</id>
    <redirect title="cpp/container/unordered set/empty" />
    <revision>
      <id>29297</id>
      <parentid>29296</parentid>
      <timestamp>2012-05-01T17:33:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/unordered_set/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/end</title>
    <ns>0</ns>
    <id>8160</id>
    <redirect title="cpp/container/unordered set/end" />
    <revision>
      <id>29299</id>
      <parentid>29298</parentid>
      <timestamp>2012-05-01T17:33:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/container/unordered_set/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/get allocator</title>
    <ns>0</ns>
    <id>8161</id>
    <redirect title="cpp/container/unordered set/get allocator" />
    <revision>
      <id>29301</id>
      <parentid>29300</parentid>
      <timestamp>2012-05-01T17:33:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="55">#redirect [[cpp/container/unordered_set/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/max size</title>
    <ns>0</ns>
    <id>8162</id>
    <redirect title="cpp/container/unordered set/max size" />
    <revision>
      <id>29303</id>
      <parentid>29302</parentid>
      <timestamp>2012-05-01T17:33:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/container/unordered_set/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/operator comp</title>
    <ns>0</ns>
    <id>8163</id>
    <redirect title="cpp/container/unordered set/operator cmp" />
    <revision>
      <id>36239</id>
      <parentid>29305</parentid>
      <timestamp>2012-06-17T12:48:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="54">#redirect [[cpp/container/unordered_set/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/size</title>
    <ns>0</ns>
    <id>8164</id>
    <redirect title="cpp/container/unordered set/size" />
    <revision>
      <id>29307</id>
      <parentid>29306</parentid>
      <timestamp>2012-05-01T17:33:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_set/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/start</title>
    <ns>0</ns>
    <id>8166</id>
    <redirect title="cpp/container/unordered set" />
    <revision>
      <id>29311</id>
      <parentid>29310</parentid>
      <timestamp>2012-05-01T17:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/unordered_set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/unordered set/swap</title>
    <ns>0</ns>
    <id>8165</id>
    <redirect title="cpp/container/unordered set/swap" />
    <revision>
      <id>29309</id>
      <parentid>29308</parentid>
      <timestamp>2012-05-01T17:33:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/unordered_set/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/</title>
    <ns>0</ns>
    <id>8197</id>
    <redirect title="cpp/container/vector" />
    <revision>
      <id>29373</id>
      <parentid>29372</parentid>
      <timestamp>2012-05-01T17:33:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/container/vector]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/assign</title>
    <ns>0</ns>
    <id>8168</id>
    <redirect title="cpp/container/vector/assign" />
    <revision>
      <id>29315</id>
      <parentid>29314</parentid>
      <timestamp>2012-05-01T17:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/vector/assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/at</title>
    <ns>0</ns>
    <id>8169</id>
    <redirect title="cpp/container/vector/at" />
    <revision>
      <id>29317</id>
      <parentid>29316</parentid>
      <timestamp>2012-05-01T17:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/container/vector/at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/back</title>
    <ns>0</ns>
    <id>8170</id>
    <redirect title="cpp/container/vector/back" />
    <revision>
      <id>29319</id>
      <parentid>29318</parentid>
      <timestamp>2012-05-01T17:33:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/vector/back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/begin</title>
    <ns>0</ns>
    <id>8171</id>
    <redirect title="cpp/container/vector/begin" />
    <revision>
      <id>29321</id>
      <parentid>29320</parentid>
      <timestamp>2012-05-01T17:33:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/vector/begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/capacity</title>
    <ns>0</ns>
    <id>8172</id>
    <redirect title="cpp/container/vector/capacity" />
    <revision>
      <id>29323</id>
      <parentid>29322</parentid>
      <timestamp>2012-05-01T17:33:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/vector/capacity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/clear</title>
    <ns>0</ns>
    <id>8173</id>
    <redirect title="cpp/container/vector/clear" />
    <revision>
      <id>29325</id>
      <parentid>29324</parentid>
      <timestamp>2012-05-01T17:33:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/vector/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/constructor</title>
    <ns>0</ns>
    <id>8174</id>
    <redirect title="cpp/container/vector/vector" />
    <revision>
      <id>29327</id>
      <parentid>29326</parentid>
      <timestamp>2012-05-01T17:33:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/vector/vector]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/data</title>
    <ns>0</ns>
    <id>8175</id>
    <redirect title="cpp/container/vector/data" />
    <revision>
      <id>29329</id>
      <parentid>29328</parentid>
      <timestamp>2012-05-01T17:33:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/vector/data]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/empty</title>
    <ns>0</ns>
    <id>8176</id>
    <redirect title="cpp/container/vector/empty" />
    <revision>
      <id>29331</id>
      <parentid>29330</parentid>
      <timestamp>2012-05-01T17:33:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/vector/empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/end</title>
    <ns>0</ns>
    <id>8177</id>
    <redirect title="cpp/container/vector/end" />
    <revision>
      <id>29333</id>
      <parentid>29332</parentid>
      <timestamp>2012-05-01T17:33:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/container/vector/end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/erase</title>
    <ns>0</ns>
    <id>8178</id>
    <redirect title="cpp/container/vector/erase" />
    <revision>
      <id>29335</id>
      <parentid>29334</parentid>
      <timestamp>2012-05-01T17:33:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/vector/erase]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/front</title>
    <ns>0</ns>
    <id>8179</id>
    <redirect title="cpp/container/vector/front" />
    <revision>
      <id>29337</id>
      <parentid>29336</parentid>
      <timestamp>2012-05-01T17:33:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/container/vector/front]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/get allocator</title>
    <ns>0</ns>
    <id>8180</id>
    <redirect title="cpp/container/vector/get allocator" />
    <revision>
      <id>29339</id>
      <parentid>29338</parentid>
      <timestamp>2012-05-01T17:33:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/vector/get_allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/insert</title>
    <ns>0</ns>
    <id>8181</id>
    <redirect title="cpp/container/vector/insert" />
    <revision>
      <id>29341</id>
      <parentid>29340</parentid>
      <timestamp>2012-05-01T17:33:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/vector/insert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/max size</title>
    <ns>0</ns>
    <id>8182</id>
    <redirect title="cpp/container/vector/max size" />
    <revision>
      <id>29343</id>
      <parentid>29342</parentid>
      <timestamp>2012-05-01T17:33:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/vector/max_size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/operator as</title>
    <ns>0</ns>
    <id>8183</id>
    <redirect title="cpp/container/vector/operator=" />
    <revision>
      <id>29345</id>
      <parentid>29344</parentid>
      <timestamp>2012-05-01T17:33:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/vector/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/operator at</title>
    <ns>0</ns>
    <id>8184</id>
    <redirect title="cpp/container/vector/operator at" />
    <revision>
      <id>29347</id>
      <parentid>29346</parentid>
      <timestamp>2012-05-01T17:33:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/container/vector/operator_at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/operator comp</title>
    <ns>0</ns>
    <id>8185</id>
    <redirect title="cpp/container/vector/operator cmp" />
    <revision>
      <id>36240</id>
      <parentid>29349</parentid>
      <timestamp>2012-06-17T12:49:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/vector/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/pop back</title>
    <ns>0</ns>
    <id>8186</id>
    <redirect title="cpp/container/vector/pop back" />
    <revision>
      <id>29351</id>
      <parentid>29350</parentid>
      <timestamp>2012-05-01T17:33:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/container/vector/pop_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/push back</title>
    <ns>0</ns>
    <id>8187</id>
    <redirect title="cpp/container/vector/push back" />
    <revision>
      <id>29353</id>
      <parentid>29352</parentid>
      <timestamp>2012-05-01T17:33:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/container/vector/push_back]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/rbegin</title>
    <ns>0</ns>
    <id>8188</id>
    <redirect title="cpp/container/vector/rbegin" />
    <revision>
      <id>29355</id>
      <parentid>29354</parentid>
      <timestamp>2012-05-01T17:33:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/vector/rbegin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/rend</title>
    <ns>0</ns>
    <id>8189</id>
    <redirect title="cpp/container/vector/rend" />
    <revision>
      <id>29357</id>
      <parentid>29356</parentid>
      <timestamp>2012-05-01T17:33:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/vector/rend]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/reserve</title>
    <ns>0</ns>
    <id>8190</id>
    <redirect title="cpp/container/vector/reserve" />
    <revision>
      <id>29359</id>
      <parentid>29358</parentid>
      <timestamp>2012-05-01T17:33:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/container/vector/reserve]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/resize</title>
    <ns>0</ns>
    <id>8191</id>
    <redirect title="cpp/container/vector/resize" />
    <revision>
      <id>29361</id>
      <parentid>29360</parentid>
      <timestamp>2012-05-01T17:33:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/container/vector/resize]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/shrink to fit</title>
    <ns>0</ns>
    <id>8192</id>
    <redirect title="cpp/container/vector/shrink to fit" />
    <revision>
      <id>29363</id>
      <parentid>29362</parentid>
      <timestamp>2012-05-01T17:33:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/container/vector/shrink_to_fit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/size</title>
    <ns>0</ns>
    <id>8193</id>
    <redirect title="cpp/container/vector/size" />
    <revision>
      <id>29365</id>
      <parentid>29364</parentid>
      <timestamp>2012-05-01T17:33:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/vector/size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/start</title>
    <ns>0</ns>
    <id>8196</id>
    <redirect title="cpp/container/vector" />
    <revision>
      <id>29371</id>
      <parentid>29370</parentid>
      <timestamp>2012-05-01T17:33:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/container/vector]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/swap</title>
    <ns>0</ns>
    <id>8194</id>
    <redirect title="cpp/container/vector/swap" />
    <revision>
      <id>29367</id>
      <parentid>29366</parentid>
      <timestamp>2012-05-01T17:33:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/container/vector/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/container/vector/vector operators</title>
    <ns>0</ns>
    <id>8195</id>
    <redirect title="cpp/container/vector/operator cmp" />
    <revision>
      <id>36241</id>
      <parentid>29369</parentid>
      <timestamp>2012-06-17T12:49:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;/operator_comp&quot; to &quot;/operator_cmp&quot;</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/container/vector/operator_cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/data types</title>
    <ns>0</ns>
    <id>7636</id>
    <redirect title="cpp/language/types" />
    <revision>
      <id>28251</id>
      <parentid>28250</parentid>
      <timestamp>2012-05-01T17:28:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="32">#redirect [[cpp/language/types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/</title>
    <ns>0</ns>
    <id>8236</id>
    <redirect title="cpp/error" />
    <revision>
      <id>29451</id>
      <parentid>29450</parentid>
      <timestamp>2012-05-01T17:33:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="23">#redirect [[cpp/error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/assert</title>
    <ns>0</ns>
    <id>8234</id>
    <redirect title="cpp/error/assert" />
    <revision>
      <id>29447</id>
      <parentid>29446</parentid>
      <timestamp>2012-05-01T17:33:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/error/assert]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/</title>
    <ns>0</ns>
    <id>8231</id>
    <redirect title="cpp/error/exception" />
    <revision>
      <id>29441</id>
      <parentid>29440</parentid>
      <timestamp>2012-05-01T17:33:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/error/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/domain error/</title>
    <ns>0</ns>
    <id>8202</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>45614</id>
      <parentid>29383</parentid>
      <timestamp>2013-01-08T04:50:53Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/domain_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/domain error/constructor</title>
    <ns>0</ns>
    <id>8200</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>61270</id>
      <parentid>45615</parentid>
      <timestamp>2013-06-05T14:10:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/domain error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/domain error/start</title>
    <ns>0</ns>
    <id>8201</id>
    <redirect title="cpp/error/domain error" />
    <revision>
      <id>45613</id>
      <parentid>29381</parentid>
      <timestamp>2013-01-08T04:50:28Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <minor/>
      <comment>Redirected page to [[cpp/error/domain error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/domain_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/exception/</title>
    <ns>0</ns>
    <id>8204</id>
    <redirect title="cpp/error/exception/exception" />
    <revision>
      <id>29387</id>
      <parentid>29386</parentid>
      <timestamp>2012-05-01T17:33:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/error/exception/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/exception/start</title>
    <ns>0</ns>
    <id>8203</id>
    <redirect title="cpp/error/exception/exception" />
    <revision>
      <id>29385</id>
      <parentid>29384</parentid>
      <timestamp>2012-05-01T17:33:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/error/exception/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/exception/what</title>
    <ns>0</ns>
    <id>8205</id>
    <redirect title="cpp/error/exception/what" />
    <revision>
      <id>45616</id>
      <parentid>29389</parentid>
      <timestamp>2013-01-08T04:52:45Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/exception/what]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/error/exception/what]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/invalid argument/</title>
    <ns>0</ns>
    <id>8208</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>45618</id>
      <parentid>29395</parentid>
      <timestamp>2013-01-08T04:53:25Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/error/invalid_argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/invalid argument/constructor</title>
    <ns>0</ns>
    <id>8206</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>61272</id>
      <parentid>45619</parentid>
      <timestamp>2013-06-05T14:10:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[cpp/error/invalid argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/invalid argument/start</title>
    <ns>0</ns>
    <id>8207</id>
    <redirect title="cpp/error/invalid argument" />
    <revision>
      <id>45617</id>
      <parentid>29393</parentid>
      <timestamp>2013-01-08T04:53:20Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/invalid argument]]</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/error/invalid_argument]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/length error/</title>
    <ns>0</ns>
    <id>8211</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>45621</id>
      <parentid>29401</parentid>
      <timestamp>2013-01-08T04:53:44Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/length_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/length error/constructor</title>
    <ns>0</ns>
    <id>8209</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>61274</id>
      <parentid>45622</parentid>
      <timestamp>2013-06-05T14:10:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/length error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/length error/start</title>
    <ns>0</ns>
    <id>8210</id>
    <redirect title="cpp/error/length error" />
    <revision>
      <id>45620</id>
      <parentid>29399</parentid>
      <timestamp>2013-01-08T04:53:39Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/length error]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/length_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/logic error/</title>
    <ns>0</ns>
    <id>8214</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>45623</id>
      <parentid>29407</parentid>
      <timestamp>2013-01-08T04:54:27Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/error/logic_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/logic error/constructor</title>
    <ns>0</ns>
    <id>8212</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>61276</id>
      <parentid>45624</parentid>
      <timestamp>2013-06-05T14:10:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/logic error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/logic error/start</title>
    <ns>0</ns>
    <id>8213</id>
    <redirect title="cpp/error/logic error" />
    <revision>
      <id>45630</id>
      <parentid>29405</parentid>
      <timestamp>2013-01-08T04:55:13Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/logic error]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/error/logic_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/out of range/</title>
    <ns>0</ns>
    <id>8217</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>45626</id>
      <parentid>29413</parentid>
      <timestamp>2013-01-08T04:54:49Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/out_of_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/out of range/constructor</title>
    <ns>0</ns>
    <id>8215</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>61278</id>
      <parentid>45627</parentid>
      <timestamp>2013-06-05T14:10:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[cpp/error/out of range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/out of range/start</title>
    <ns>0</ns>
    <id>8216</id>
    <redirect title="cpp/error/out of range" />
    <revision>
      <id>45625</id>
      <parentid>29411</parentid>
      <timestamp>2013-01-08T04:54:42Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/out of range]]</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/error/out_of_range]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/overflow error/</title>
    <ns>0</ns>
    <id>8220</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>45629</id>
      <parentid>29419</parentid>
      <timestamp>2013-01-08T04:55:05Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/error/overflow_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/overflow error/constructor</title>
    <ns>0</ns>
    <id>8218</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>61280</id>
      <parentid>46070</parentid>
      <timestamp>2013-06-05T14:11:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[cpp/error/overflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/overflow error/start</title>
    <ns>0</ns>
    <id>8219</id>
    <redirect title="cpp/error/overflow error" />
    <revision>
      <id>45628</id>
      <parentid>29417</parentid>
      <timestamp>2013-01-08T04:55:00Z</timestamp>
      <contributor>
        <username>Theemathas</username>
        <id>1439</id>
      </contributor>
      <comment>Redirected page to [[cpp/error/overflow error]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/error/overflow_error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/range error/</title>
    <ns>0</ns>
    <id>8223</id>
    <redirect title="cpp/error/range error" />
    <revision>
      <id>46072</id>
      <parentid>29425</parentid>
      <timestamp>2013-02-15T21:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/range error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/range error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/range error/constructor</title>
    <ns>0</ns>
    <id>8221</id>
    <redirect title="cpp/error/range error" />
    <revision>
      <id>61281</id>
      <parentid>29724</parentid>
      <timestamp>2013-06-05T14:11:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/range error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/range error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/range error/start</title>
    <ns>0</ns>
    <id>8222</id>
    <redirect title="cpp/error/range error" />
    <revision>
      <id>46071</id>
      <parentid>29423</parentid>
      <timestamp>2013-02-15T21:48:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/range error]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[cpp/error/range error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/runtime error/</title>
    <ns>0</ns>
    <id>8226</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>46074</id>
      <parentid>29431</parentid>
      <timestamp>2013-02-15T21:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/runtime error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/runtime error/constructor</title>
    <ns>0</ns>
    <id>8224</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>61283</id>
      <parentid>46075</parentid>
      <timestamp>2013-06-05T14:11:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/runtime error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/runtime error/start</title>
    <ns>0</ns>
    <id>8225</id>
    <redirect title="cpp/error/runtime error" />
    <revision>
      <id>46073</id>
      <parentid>29429</parentid>
      <timestamp>2013-02-15T21:48:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/runtime error]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[cpp/error/runtime error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/start</title>
    <ns>0</ns>
    <id>8230</id>
    <redirect title="cpp/error/exception" />
    <revision>
      <id>29439</id>
      <parentid>29438</parentid>
      <timestamp>2012-05-01T17:33:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/error/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/terminate</title>
    <ns>0</ns>
    <id>8232</id>
    <redirect title="cpp/error/terminate" />
    <revision>
      <id>29443</id>
      <parentid>29442</parentid>
      <timestamp>2012-05-01T17:33:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/error/terminate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/underflow error/</title>
    <ns>0</ns>
    <id>8229</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>46077</id>
      <parentid>29437</parentid>
      <timestamp>2013-02-15T21:49:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/underflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/underflow error/constructor</title>
    <ns>0</ns>
    <id>8227</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>61285</id>
      <parentid>46078</parentid>
      <timestamp>2013-06-05T14:11:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/underflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/underflow error/start</title>
    <ns>0</ns>
    <id>8228</id>
    <redirect title="cpp/error/underflow error" />
    <revision>
      <id>46076</id>
      <parentid>29435</parentid>
      <timestamp>2013-02-15T21:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/error/underflow error]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[cpp/error/underflow error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/exception/unexpected</title>
    <ns>0</ns>
    <id>8233</id>
    <redirect title="cpp/error/unexpected" />
    <revision>
      <id>29445</id>
      <parentid>29444</parentid>
      <timestamp>2012-05-01T17:33:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/error/unexpected]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/error/start</title>
    <ns>0</ns>
    <id>8235</id>
    <redirect title="cpp/error" />
    <revision>
      <id>29449</id>
      <parentid>29448</parentid>
      <timestamp>2012-05-01T17:33:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="23">#redirect [[cpp/error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/escape sequences</title>
    <ns>0</ns>
    <id>7637</id>
    <redirect title="cpp/language/escape" />
    <revision>
      <id>28253</id>
      <parentid>28252</parentid>
      <timestamp>2012-05-01T17:28:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/language/escape]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/exception/</title>
    <ns>0</ns>
    <id>8238</id>
    <redirect title="cpp/error/exception" />
    <revision>
      <id>29455</id>
      <parentid>29454</parentid>
      <timestamp>2012-05-01T17:33:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/error/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/exception/start</title>
    <ns>0</ns>
    <id>8237</id>
    <redirect title="cpp/error/exception" />
    <revision>
      <id>29453</id>
      <parentid>29452</parentid>
      <timestamp>2012-05-01T17:33:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="33">#redirect [[cpp/error/exception]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/</title>
    <ns>0</ns>
    <id>8254</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29487</id>
      <parentid>29486</parentid>
      <timestamp>2012-05-01T17:33:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/binary function</title>
    <ns>0</ns>
    <id>8239</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29457</id>
      <parentid>29456</parentid>
      <timestamp>2012-05-01T17:33:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/binary negate</title>
    <ns>0</ns>
    <id>8240</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29459</id>
      <parentid>29458</parentid>
      <timestamp>2012-05-01T17:33:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/bind1st</title>
    <ns>0</ns>
    <id>8241</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29461</id>
      <parentid>29460</parentid>
      <timestamp>2012-05-01T17:33:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/bind2nd</title>
    <ns>0</ns>
    <id>8242</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29463</id>
      <parentid>29462</parentid>
      <timestamp>2012-05-01T17:33:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/binder1st</title>
    <ns>0</ns>
    <id>8243</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29465</id>
      <parentid>29464</parentid>
      <timestamp>2012-05-01T17:33:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/binder2nd</title>
    <ns>0</ns>
    <id>8244</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29467</id>
      <parentid>29466</parentid>
      <timestamp>2012-05-01T17:33:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/const mem fun1 ref t</title>
    <ns>0</ns>
    <id>8245</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29469</id>
      <parentid>29468</parentid>
      <timestamp>2012-05-01T17:33:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/const mem fun1 t</title>
    <ns>0</ns>
    <id>8246</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29471</id>
      <parentid>29470</parentid>
      <timestamp>2012-05-01T17:33:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/const mem fun ref t</title>
    <ns>0</ns>
    <id>8247</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29473</id>
      <parentid>29472</parentid>
      <timestamp>2012-05-01T17:33:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/const mem fun t</title>
    <ns>0</ns>
    <id>8248</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29475</id>
      <parentid>29474</parentid>
      <timestamp>2012-05-01T17:33:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/divides</title>
    <ns>0</ns>
    <id>8249</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29477</id>
      <parentid>29476</parentid>
      <timestamp>2012-05-01T17:33:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/greater</title>
    <ns>0</ns>
    <id>8250</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29479</id>
      <parentid>29478</parentid>
      <timestamp>2012-05-01T17:33:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/logical and</title>
    <ns>0</ns>
    <id>8251</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29481</id>
      <parentid>29480</parentid>
      <timestamp>2012-05-01T17:33:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/not2</title>
    <ns>0</ns>
    <id>8252</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29483</id>
      <parentid>29482</parentid>
      <timestamp>2012-05-01T17:33:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/functional/start</title>
    <ns>0</ns>
    <id>8253</id>
    <redirect title="cpp/utility/functional" />
    <revision>
      <id>29485</id>
      <parentid>29484</parentid>
      <timestamp>2012-05-01T17:33:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/utility/functional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/header files</title>
    <ns>0</ns>
    <id>7638</id>
    <redirect title="cpp/header" />
    <revision>
      <id>46079</id>
      <parentid>28255</parentid>
      <timestamp>2013-02-15T21:49:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/header]]</comment>
      <text xml:space="preserve" bytes="24">#REDIRECT [[cpp/header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/headers/</title>
    <ns>0</ns>
    <id>8256</id>
    <redirect title="cpp/header" />
    <revision>
      <id>46081</id>
      <parentid>29491</parentid>
      <timestamp>2013-02-15T21:49:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/header]]</comment>
      <text xml:space="preserve" bytes="24">#REDIRECT [[cpp/header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/headers/start</title>
    <ns>0</ns>
    <id>8255</id>
    <redirect title="cpp/header" />
    <revision>
      <id>46080</id>
      <parentid>29489</parentid>
      <timestamp>2013-02-15T21:49:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Robot: Fixing double redirect to [[cpp/header]]</comment>
      <text xml:space="preserve" bytes="24">#REDIRECT [[cpp/header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/</title>
    <ns>0</ns>
    <id>6824</id>
    <redirect title="cpp/io" />
    <revision>
      <id>26627</id>
      <parentid>26626</parentid>
      <timestamp>2012-05-01T17:20:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="20">#redirect [[cpp/io]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/bad</title>
    <ns>0</ns>
    <id>6795</id>
    <redirect title="cpp/io/basic ios/bad" />
    <revision>
      <id>26569</id>
      <parentid>26568</parentid>
      <timestamp>2012-05-01T17:20:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ios/bad]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic filebuf/</title>
    <ns>0</ns>
    <id>8258</id>
    <redirect title="cpp/io/basic filebuf" />
    <revision>
      <id>29495</id>
      <parentid>29494</parentid>
      <timestamp>2012-05-01T17:33:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_filebuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic filebuf/start</title>
    <ns>0</ns>
    <id>8257</id>
    <redirect title="cpp/io/basic filebuf" />
    <revision>
      <id>29493</id>
      <parentid>29492</parentid>
      <timestamp>2012-05-01T17:33:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_filebuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/</title>
    <ns>0</ns>
    <id>8266</id>
    <redirect title="cpp/io/basic fstream" />
    <revision>
      <id>29511</id>
      <parentid>29510</parentid>
      <timestamp>2012-05-01T17:33:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_fstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/close</title>
    <ns>0</ns>
    <id>8259</id>
    <redirect title="cpp/io/basic fstream/close" />
    <revision>
      <id>29497</id>
      <parentid>29496</parentid>
      <timestamp>2012-05-01T17:33:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_fstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/constructor</title>
    <ns>0</ns>
    <id>8260</id>
    <redirect title="cpp/io/basic fstream/basic fstream" />
    <revision>
      <id>29499</id>
      <parentid>29498</parentid>
      <timestamp>2012-05-01T17:33:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/io/basic_fstream/basic_fstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/is open</title>
    <ns>0</ns>
    <id>8261</id>
    <redirect title="cpp/io/basic fstream/is open" />
    <revision>
      <id>29501</id>
      <parentid>29500</parentid>
      <timestamp>2012-05-01T17:33:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_fstream/is_open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/open</title>
    <ns>0</ns>
    <id>8262</id>
    <redirect title="cpp/io/basic fstream/open" />
    <revision>
      <id>29503</id>
      <parentid>29502</parentid>
      <timestamp>2012-05-01T17:33:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_fstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/operator as</title>
    <ns>0</ns>
    <id>8263</id>
    <redirect title="cpp/io/basic fstream/operator=" />
    <revision>
      <id>29725</id>
      <parentid>29505</parentid>
      <timestamp>2012-05-01T18:05:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic fstream/operator=]]</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/io/basic_fstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/rdbuf</title>
    <ns>0</ns>
    <id>8264</id>
    <redirect title="cpp/io/basic fstream/rdbuf" />
    <revision>
      <id>29507</id>
      <parentid>29506</parentid>
      <timestamp>2012-05-01T17:33:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_fstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/start</title>
    <ns>0</ns>
    <id>8265</id>
    <redirect title="cpp/io/basic fstream" />
    <revision>
      <id>29509</id>
      <parentid>29508</parentid>
      <timestamp>2012-05-01T17:33:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_fstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic fstream/swap</title>
    <ns>0</ns>
    <id>8267</id>
    <redirect title="cpp/io/basic fstream/swap" />
    <revision>
      <id>29513</id>
      <parentid>29512</parentid>
      <timestamp>2012-05-01T17:33:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_fstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/</title>
    <ns>0</ns>
    <id>8275</id>
    <redirect title="cpp/io/basic ifstream" />
    <revision>
      <id>29529</id>
      <parentid>29528</parentid>
      <timestamp>2012-05-01T17:33:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ifstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/close</title>
    <ns>0</ns>
    <id>8268</id>
    <redirect title="cpp/io/basic ifstream/close" />
    <revision>
      <id>29515</id>
      <parentid>29514</parentid>
      <timestamp>2012-05-01T17:33:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_ifstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/constructor</title>
    <ns>0</ns>
    <id>8269</id>
    <redirect title="cpp/io/basic ifstream/basic ifstream" />
    <revision>
      <id>29517</id>
      <parentid>29516</parentid>
      <timestamp>2012-05-01T17:33:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/io/basic_ifstream/basic_ifstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/is open</title>
    <ns>0</ns>
    <id>8270</id>
    <redirect title="cpp/io/basic ifstream/is open" />
    <revision>
      <id>29519</id>
      <parentid>29518</parentid>
      <timestamp>2012-05-01T17:33:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/io/basic_ifstream/is_open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/open</title>
    <ns>0</ns>
    <id>8271</id>
    <redirect title="cpp/io/basic ifstream/open" />
    <revision>
      <id>29521</id>
      <parentid>29520</parentid>
      <timestamp>2012-05-01T17:33:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ifstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/operator as</title>
    <ns>0</ns>
    <id>8272</id>
    <redirect title="cpp/io/basic ifstream/operator=" />
    <revision>
      <id>29726</id>
      <parentid>29523</parentid>
      <timestamp>2012-05-01T18:05:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic ifstream/operator=]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/basic_ifstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/rdbuf</title>
    <ns>0</ns>
    <id>8273</id>
    <redirect title="cpp/io/basic ifstream/rdbuf" />
    <revision>
      <id>29525</id>
      <parentid>29524</parentid>
      <timestamp>2012-05-01T17:33:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_ifstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/start</title>
    <ns>0</ns>
    <id>8274</id>
    <redirect title="cpp/io/basic ifstream" />
    <revision>
      <id>29527</id>
      <parentid>29526</parentid>
      <timestamp>2012-05-01T17:33:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ifstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ifstream/swap</title>
    <ns>0</ns>
    <id>8276</id>
    <redirect title="cpp/io/basic ifstream/swap" />
    <revision>
      <id>29531</id>
      <parentid>29530</parentid>
      <timestamp>2012-05-01T17:33:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ifstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/</title>
    <ns>0</ns>
    <id>8287</id>
    <redirect title="cpp/io/basic ios" />
    <revision>
      <id>29553</id>
      <parentid>29552</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/basic_ios]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/bad</title>
    <ns>0</ns>
    <id>8277</id>
    <redirect title="cpp/io/basic ios/bad" />
    <revision>
      <id>29533</id>
      <parentid>29532</parentid>
      <timestamp>2012-05-01T17:33:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ios/bad]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/clear</title>
    <ns>0</ns>
    <id>8278</id>
    <redirect title="cpp/io/basic ios/clear" />
    <revision>
      <id>29535</id>
      <parentid>29534</parentid>
      <timestamp>2012-05-01T17:33:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_ios/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/copyfmt</title>
    <ns>0</ns>
    <id>8279</id>
    <redirect title="cpp/io/basic ios/copyfmt" />
    <revision>
      <id>29537</id>
      <parentid>29536</parentid>
      <timestamp>2012-05-01T17:33:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/basic_ios/copyfmt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/eof</title>
    <ns>0</ns>
    <id>8280</id>
    <redirect title="cpp/io/basic ios/eof" />
    <revision>
      <id>29539</id>
      <parentid>29538</parentid>
      <timestamp>2012-05-01T17:33:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ios/eof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/fail</title>
    <ns>0</ns>
    <id>8281</id>
    <redirect title="cpp/io/basic ios/fail" />
    <revision>
      <id>29541</id>
      <parentid>29540</parentid>
      <timestamp>2012-05-01T17:33:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/fail]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/fill</title>
    <ns>0</ns>
    <id>8282</id>
    <redirect title="cpp/io/basic ios/fill" />
    <revision>
      <id>29543</id>
      <parentid>29542</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/fill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/good</title>
    <ns>0</ns>
    <id>8283</id>
    <redirect title="cpp/io/basic ios/good" />
    <revision>
      <id>29545</id>
      <parentid>29544</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/good]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/operator bool</title>
    <ns>0</ns>
    <id>8284</id>
    <redirect title="cpp/io/basic ios/operator bool" />
    <revision>
      <id>29547</id>
      <parentid>29546</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/io/basic_ios/operator_bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/operator neg</title>
    <ns>0</ns>
    <id>8285</id>
    <redirect title="cpp/io/basic ios/operator!" />
    <revision>
      <id>29549</id>
      <parentid>29548</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ios/operator!]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ios/start</title>
    <ns>0</ns>
    <id>8286</id>
    <redirect title="cpp/io/basic ios" />
    <revision>
      <id>29551</id>
      <parentid>29550</parentid>
      <timestamp>2012-05-01T17:33:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/basic_ios]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic iostream/</title>
    <ns>0</ns>
    <id>8289</id>
    <redirect title="cpp/io/basic iostream" />
    <revision>
      <id>29557</id>
      <parentid>29556</parentid>
      <timestamp>2012-05-01T17:33:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_iostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic iostream/start</title>
    <ns>0</ns>
    <id>8288</id>
    <redirect title="cpp/io/basic iostream" />
    <revision>
      <id>29555</id>
      <parentid>29554</parentid>
      <timestamp>2012-05-01T17:33:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_iostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/</title>
    <ns>0</ns>
    <id>8301</id>
    <redirect title="cpp/io/basic istream" />
    <revision>
      <id>29581</id>
      <parentid>29580</parentid>
      <timestamp>2012-05-01T17:34:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_istream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/gcount</title>
    <ns>0</ns>
    <id>8290</id>
    <redirect title="cpp/io/basic istream/gcount" />
    <revision>
      <id>29559</id>
      <parentid>29558</parentid>
      <timestamp>2012-05-01T17:33:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_istream/gcount]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/get</title>
    <ns>0</ns>
    <id>8291</id>
    <redirect title="cpp/io/basic istream/get" />
    <revision>
      <id>29561</id>
      <parentid>29560</parentid>
      <timestamp>2012-05-01T17:33:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/basic_istream/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/getline</title>
    <ns>0</ns>
    <id>8292</id>
    <redirect title="cpp/io/basic istream/getline" />
    <revision>
      <id>29563</id>
      <parentid>29562</parentid>
      <timestamp>2012-05-01T17:34:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_istream/getline]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/ignore</title>
    <ns>0</ns>
    <id>8293</id>
    <redirect title="cpp/io/basic istream/ignore" />
    <revision>
      <id>29565</id>
      <parentid>29564</parentid>
      <timestamp>2012-05-01T17:34:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_istream/ignore]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/operator gt gt</title>
    <ns>0</ns>
    <id>8294</id>
    <redirect title="cpp/io/basic istream/operator gtgt" />
    <revision>
      <id>29567</id>
      <parentid>29566</parentid>
      <timestamp>2012-05-01T17:34:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="48">#redirect [[cpp/io/basic_istream/operator_gtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/peek</title>
    <ns>0</ns>
    <id>8295</id>
    <redirect title="cpp/io/basic istream/peek" />
    <revision>
      <id>29569</id>
      <parentid>29568</parentid>
      <timestamp>2012-05-01T17:34:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_istream/peek]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/putback</title>
    <ns>0</ns>
    <id>8296</id>
    <redirect title="cpp/io/basic istream/putback" />
    <revision>
      <id>29571</id>
      <parentid>29570</parentid>
      <timestamp>2012-05-01T17:34:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_istream/putback]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/read</title>
    <ns>0</ns>
    <id>8297</id>
    <redirect title="cpp/io/basic istream/read" />
    <revision>
      <id>29573</id>
      <parentid>29572</parentid>
      <timestamp>2012-05-01T17:34:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_istream/read]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/readsome</title>
    <ns>0</ns>
    <id>8298</id>
    <redirect title="cpp/io/basic istream/readsome" />
    <revision>
      <id>29575</id>
      <parentid>29574</parentid>
      <timestamp>2012-05-01T17:34:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/io/basic_istream/readsome]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/seekg</title>
    <ns>0</ns>
    <id>8299</id>
    <redirect title="cpp/io/basic istream/seekg" />
    <revision>
      <id>29577</id>
      <parentid>29576</parentid>
      <timestamp>2012-05-01T17:34:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_istream/seekg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/start</title>
    <ns>0</ns>
    <id>8300</id>
    <redirect title="cpp/io/basic istream" />
    <revision>
      <id>29579</id>
      <parentid>29578</parentid>
      <timestamp>2012-05-01T17:34:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_istream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/sync</title>
    <ns>0</ns>
    <id>8302</id>
    <redirect title="cpp/io/basic istream/sync" />
    <revision>
      <id>29583</id>
      <parentid>29582</parentid>
      <timestamp>2012-05-01T17:34:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_istream/sync]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/tellg</title>
    <ns>0</ns>
    <id>8303</id>
    <redirect title="cpp/io/basic istream/tellg" />
    <revision>
      <id>29585</id>
      <parentid>29584</parentid>
      <timestamp>2012-05-01T17:34:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_istream/tellg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istream/unget</title>
    <ns>0</ns>
    <id>8304</id>
    <redirect title="cpp/io/basic istream/unget" />
    <revision>
      <id>29587</id>
      <parentid>29586</parentid>
      <timestamp>2012-05-01T17:34:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_istream/unget]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/</title>
    <ns>0</ns>
    <id>8309</id>
    <redirect title="cpp/io/basic istringstream" />
    <revision>
      <id>29597</id>
      <parentid>29596</parentid>
      <timestamp>2012-05-01T17:34:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_istringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/constructor</title>
    <ns>0</ns>
    <id>8305</id>
    <redirect title="cpp/io/basic istringstream/basic istringstream" />
    <revision>
      <id>29589</id>
      <parentid>29588</parentid>
      <timestamp>2012-05-01T17:34:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/io/basic_istringstream/basic_istringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/operator as</title>
    <ns>0</ns>
    <id>8306</id>
    <redirect title="cpp/io/basic istringstream/operator=" />
    <revision>
      <id>29731</id>
      <parentid>29727</parentid>
      <timestamp>2012-05-01T18:05:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic istringstream/operator=]]</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/io/basic_istringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/rdbuf</title>
    <ns>0</ns>
    <id>8307</id>
    <redirect title="cpp/io/basic istringstream/rdbuf" />
    <revision>
      <id>29593</id>
      <parentid>29592</parentid>
      <timestamp>2012-05-01T17:34:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/io/basic_istringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/start</title>
    <ns>0</ns>
    <id>8308</id>
    <redirect title="cpp/io/basic istringstream" />
    <revision>
      <id>29595</id>
      <parentid>29594</parentid>
      <timestamp>2012-05-01T17:34:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_istringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic istringstream/swap</title>
    <ns>0</ns>
    <id>8310</id>
    <redirect title="cpp/io/basic istringstream/swap" />
    <revision>
      <id>29599</id>
      <parentid>29598</parentid>
      <timestamp>2012-05-01T17:34:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/basic_istringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/</title>
    <ns>0</ns>
    <id>8318</id>
    <redirect title="cpp/io/basic ofstream" />
    <revision>
      <id>29615</id>
      <parentid>29614</parentid>
      <timestamp>2012-05-01T17:34:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/close</title>
    <ns>0</ns>
    <id>8311</id>
    <redirect title="cpp/io/basic ofstream/close" />
    <revision>
      <id>29601</id>
      <parentid>29600</parentid>
      <timestamp>2012-05-01T17:34:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_ofstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/constructor</title>
    <ns>0</ns>
    <id>8312</id>
    <redirect title="cpp/io/basic ofstream/basic ofstream" />
    <revision>
      <id>29603</id>
      <parentid>29602</parentid>
      <timestamp>2012-05-01T17:34:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/io/basic_ofstream/basic_ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/is open</title>
    <ns>0</ns>
    <id>8313</id>
    <redirect title="cpp/io/basic ofstream/is open" />
    <revision>
      <id>29605</id>
      <parentid>29604</parentid>
      <timestamp>2012-05-01T17:34:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="43">#redirect [[cpp/io/basic_ofstream/is_open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/open</title>
    <ns>0</ns>
    <id>8314</id>
    <redirect title="cpp/io/basic ofstream/open" />
    <revision>
      <id>29607</id>
      <parentid>29606</parentid>
      <timestamp>2012-05-01T17:34:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ofstream/open]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/operator as</title>
    <ns>0</ns>
    <id>8315</id>
    <redirect title="cpp/io/basic ofstream/operator=" />
    <revision>
      <id>29734</id>
      <parentid>29728</parentid>
      <timestamp>2012-05-01T18:06:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic ofstream/operator=]]</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/basic_ofstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/rdbuf</title>
    <ns>0</ns>
    <id>8316</id>
    <redirect title="cpp/io/basic ofstream/rdbuf" />
    <revision>
      <id>29611</id>
      <parentid>29610</parentid>
      <timestamp>2012-05-01T17:34:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_ofstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/start</title>
    <ns>0</ns>
    <id>8317</id>
    <redirect title="cpp/io/basic ofstream" />
    <revision>
      <id>29613</id>
      <parentid>29612</parentid>
      <timestamp>2012-05-01T17:34:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ofstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ofstream/swap</title>
    <ns>0</ns>
    <id>8319</id>
    <redirect title="cpp/io/basic ofstream/swap" />
    <revision>
      <id>29617</id>
      <parentid>29616</parentid>
      <timestamp>2012-05-01T17:34:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ofstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/</title>
    <ns>0</ns>
    <id>8324</id>
    <redirect title="cpp/io/basic ostream" />
    <revision>
      <id>29627</id>
      <parentid>29626</parentid>
      <timestamp>2012-05-01T17:34:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/flush</title>
    <ns>0</ns>
    <id>8320</id>
    <redirect title="cpp/io/basic ostream/flush" />
    <revision>
      <id>29619</id>
      <parentid>29618</parentid>
      <timestamp>2012-05-01T17:34:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostream/flush]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/put</title>
    <ns>0</ns>
    <id>8321</id>
    <redirect title="cpp/io/basic ostream/put" />
    <revision>
      <id>29621</id>
      <parentid>29620</parentid>
      <timestamp>2012-05-01T17:34:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/basic_ostream/put]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/seekp</title>
    <ns>0</ns>
    <id>8322</id>
    <redirect title="cpp/io/basic ostream/seekp" />
    <revision>
      <id>29623</id>
      <parentid>29622</parentid>
      <timestamp>2012-05-01T17:34:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostream/seekp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/start</title>
    <ns>0</ns>
    <id>8323</id>
    <redirect title="cpp/io/basic ostream" />
    <revision>
      <id>29625</id>
      <parentid>29624</parentid>
      <timestamp>2012-05-01T17:34:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ostream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/tellp</title>
    <ns>0</ns>
    <id>8325</id>
    <redirect title="cpp/io/basic ostream/tellp" />
    <revision>
      <id>29629</id>
      <parentid>29628</parentid>
      <timestamp>2012-05-01T17:34:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostream/tellp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostream/write</title>
    <ns>0</ns>
    <id>8326</id>
    <redirect title="cpp/io/basic ostream/write" />
    <revision>
      <id>29631</id>
      <parentid>29630</parentid>
      <timestamp>2012-05-01T17:34:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostream/write]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/</title>
    <ns>0</ns>
    <id>8331</id>
    <redirect title="cpp/io/basic ostringstream" />
    <revision>
      <id>29641</id>
      <parentid>29640</parentid>
      <timestamp>2012-05-01T17:34:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/constructor</title>
    <ns>0</ns>
    <id>8327</id>
    <redirect title="cpp/io/basic ostringstream/basic ostringstream" />
    <revision>
      <id>29633</id>
      <parentid>29632</parentid>
      <timestamp>2012-05-01T17:34:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="60">#redirect [[cpp/io/basic_ostringstream/basic_ostringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/operator as</title>
    <ns>0</ns>
    <id>8328</id>
    <redirect title="cpp/io/basic ostringstream/operator=" />
    <revision>
      <id>29732</id>
      <parentid>29729</parentid>
      <timestamp>2012-05-01T18:05:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic ostringstream/operator=]]</comment>
      <text xml:space="preserve" bytes="50">#redirect [[cpp/io/basic_ostringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/rdbuf</title>
    <ns>0</ns>
    <id>8329</id>
    <redirect title="cpp/io/basic ostringstream/rdbuf" />
    <revision>
      <id>29637</id>
      <parentid>29636</parentid>
      <timestamp>2012-05-01T17:34:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="46">#redirect [[cpp/io/basic_ostringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/start</title>
    <ns>0</ns>
    <id>8330</id>
    <redirect title="cpp/io/basic ostringstream" />
    <revision>
      <id>29639</id>
      <parentid>29638</parentid>
      <timestamp>2012-05-01T17:34:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic ostringstream/swap</title>
    <ns>0</ns>
    <id>8332</id>
    <redirect title="cpp/io/basic ostringstream/swap" />
    <revision>
      <id>29643</id>
      <parentid>29642</parentid>
      <timestamp>2012-05-01T17:34:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/basic_ostringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic streambuf/</title>
    <ns>0</ns>
    <id>8334</id>
    <redirect title="cpp/io/basic streambuf" />
    <revision>
      <id>29647</id>
      <parentid>29646</parentid>
      <timestamp>2012-05-01T17:34:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_streambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic streambuf/start</title>
    <ns>0</ns>
    <id>8333</id>
    <redirect title="cpp/io/basic streambuf" />
    <revision>
      <id>29645</id>
      <parentid>29644</parentid>
      <timestamp>2012-05-01T17:34:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_streambuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringbuf/</title>
    <ns>0</ns>
    <id>8336</id>
    <redirect title="cpp/io/basic stringbuf" />
    <revision>
      <id>29651</id>
      <parentid>29650</parentid>
      <timestamp>2012-05-01T17:34:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_stringbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringbuf/start</title>
    <ns>0</ns>
    <id>8335</id>
    <redirect title="cpp/io/basic stringbuf" />
    <revision>
      <id>29649</id>
      <parentid>29648</parentid>
      <timestamp>2012-05-01T17:34:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_stringbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/</title>
    <ns>0</ns>
    <id>8341</id>
    <redirect title="cpp/io/basic stringstream" />
    <revision>
      <id>29661</id>
      <parentid>29660</parentid>
      <timestamp>2012-05-01T17:34:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_stringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/constructor</title>
    <ns>0</ns>
    <id>8337</id>
    <redirect title="cpp/io/basic stringstream/basic stringstream" />
    <revision>
      <id>29653</id>
      <parentid>29652</parentid>
      <timestamp>2012-05-01T17:34:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="58">#redirect [[cpp/io/basic_stringstream/basic_stringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/operator as</title>
    <ns>0</ns>
    <id>8338</id>
    <redirect title="cpp/io/basic stringstream/operator=" />
    <revision>
      <id>29733</id>
      <parentid>29730</parentid>
      <timestamp>2012-05-01T18:05:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/basic stringstream/operator=]]</comment>
      <text xml:space="preserve" bytes="49">#redirect [[cpp/io/basic_stringstream/operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/rdbuf</title>
    <ns>0</ns>
    <id>8339</id>
    <redirect title="cpp/io/basic stringstream/rdbuf" />
    <revision>
      <id>29657</id>
      <parentid>29656</parentid>
      <timestamp>2012-05-01T17:34:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/basic_stringstream/rdbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/start</title>
    <ns>0</ns>
    <id>8340</id>
    <redirect title="cpp/io/basic stringstream" />
    <revision>
      <id>29659</id>
      <parentid>29658</parentid>
      <timestamp>2012-05-01T17:34:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/basic_stringstream]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/basic stringstream/swap</title>
    <ns>0</ns>
    <id>8342</id>
    <redirect title="cpp/io/basic stringstream/swap" />
    <revision>
      <id>29663</id>
      <parentid>29662</parentid>
      <timestamp>2012-05-01T17:34:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/io/basic_stringstream/swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/</title>
    <ns>0</ns>
    <id>6745</id>
    <redirect title="cpp/io/c" />
    <revision>
      <id>26469</id>
      <parentid>26468</parentid>
      <timestamp>2012-05-01T17:20:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="22">#redirect [[cpp/io/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/clearerr</title>
    <ns>0</ns>
    <id>8343</id>
    <redirect title="cpp/io/c/clearerr" />
    <revision>
      <id>29665</id>
      <parentid>29664</parentid>
      <timestamp>2012-05-01T17:34:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/clearerr]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fclose</title>
    <ns>0</ns>
    <id>8344</id>
    <redirect title="cpp/io/c/fclose" />
    <revision>
      <id>29667</id>
      <parentid>29666</parentid>
      <timestamp>2012-05-01T17:34:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fclose]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/feof</title>
    <ns>0</ns>
    <id>8345</id>
    <redirect title="cpp/io/c/feof" />
    <revision>
      <id>29669</id>
      <parentid>29668</parentid>
      <timestamp>2012-05-01T17:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/feof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/ferror</title>
    <ns>0</ns>
    <id>8346</id>
    <redirect title="cpp/io/c/ferror" />
    <revision>
      <id>29671</id>
      <parentid>29670</parentid>
      <timestamp>2012-05-01T17:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/ferror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fflush</title>
    <ns>0</ns>
    <id>8347</id>
    <redirect title="cpp/io/c/fflush" />
    <revision>
      <id>29673</id>
      <parentid>29672</parentid>
      <timestamp>2012-05-01T17:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fflush]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fgetc</title>
    <ns>0</ns>
    <id>8348</id>
    <redirect title="cpp/io/c/fgetc" />
    <revision>
      <id>29675</id>
      <parentid>29674</parentid>
      <timestamp>2012-05-01T17:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fgetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fgetpos</title>
    <ns>0</ns>
    <id>8349</id>
    <redirect title="cpp/io/c/fgetpos" />
    <revision>
      <id>29677</id>
      <parentid>29676</parentid>
      <timestamp>2012-05-01T17:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fgetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fgets</title>
    <ns>0</ns>
    <id>8350</id>
    <redirect title="cpp/io/c/fgets" />
    <revision>
      <id>29679</id>
      <parentid>29678</parentid>
      <timestamp>2012-05-01T17:34:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fgets]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fopen</title>
    <ns>0</ns>
    <id>8351</id>
    <redirect title="cpp/io/c/fopen" />
    <revision>
      <id>29681</id>
      <parentid>29680</parentid>
      <timestamp>2012-05-01T17:34:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fopen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fprintf</title>
    <ns>0</ns>
    <id>8352</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>29683</id>
      <parentid>29682</parentid>
      <timestamp>2012-05-01T17:34:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fputc</title>
    <ns>0</ns>
    <id>8353</id>
    <redirect title="cpp/io/c/fputc" />
    <revision>
      <id>29685</id>
      <parentid>29684</parentid>
      <timestamp>2012-05-01T17:34:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fputc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fputs</title>
    <ns>0</ns>
    <id>8354</id>
    <redirect title="cpp/io/c/fputs" />
    <revision>
      <id>29687</id>
      <parentid>29686</parentid>
      <timestamp>2012-05-01T17:34:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fputs]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fread</title>
    <ns>0</ns>
    <id>8355</id>
    <redirect title="cpp/io/c/fread" />
    <revision>
      <id>29689</id>
      <parentid>29688</parentid>
      <timestamp>2012-05-01T17:34:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fread]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/freopen</title>
    <ns>0</ns>
    <id>8356</id>
    <redirect title="cpp/io/c/freopen" />
    <revision>
      <id>29691</id>
      <parentid>29690</parentid>
      <timestamp>2012-05-01T17:34:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/freopen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fscanf</title>
    <ns>0</ns>
    <id>8357</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>29693</id>
      <parentid>29692</parentid>
      <timestamp>2012-05-01T17:34:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fseek</title>
    <ns>0</ns>
    <id>8358</id>
    <redirect title="cpp/io/c/fseek" />
    <revision>
      <id>29695</id>
      <parentid>29694</parentid>
      <timestamp>2012-05-01T17:34:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/fseek]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fsetpos</title>
    <ns>0</ns>
    <id>8359</id>
    <redirect title="cpp/io/c/fsetpos" />
    <revision>
      <id>29697</id>
      <parentid>29696</parentid>
      <timestamp>2012-05-01T17:34:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fsetpos]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/ftell</title>
    <ns>0</ns>
    <id>8360</id>
    <redirect title="cpp/io/c/ftell" />
    <revision>
      <id>29699</id>
      <parentid>29698</parentid>
      <timestamp>2012-05-01T17:34:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="28">#redirect [[cpp/io/c/ftell]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/fwrite</title>
    <ns>0</ns>
    <id>8361</id>
    <redirect title="cpp/io/c/fwrite" />
    <revision>
      <id>29701</id>
      <parentid>29700</parentid>
      <timestamp>2012-05-01T17:34:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fwrite]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/getchar</title>
    <ns>0</ns>
    <id>8362</id>
    <redirect title="cpp/io/c/getchar" />
    <revision>
      <id>29703</id>
      <parentid>29702</parentid>
      <timestamp>2012-05-01T17:34:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/getchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/gets</title>
    <ns>0</ns>
    <id>8363</id>
    <redirect title="cpp/io/c/gets" />
    <revision>
      <id>29705</id>
      <parentid>29704</parentid>
      <timestamp>2012-05-01T17:34:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/gets]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/perror</title>
    <ns>0</ns>
    <id>8364</id>
    <redirect title="cpp/io/c/perror" />
    <revision>
      <id>29707</id>
      <parentid>29706</parentid>
      <timestamp>2012-05-01T17:34:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/perror]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/printf</title>
    <ns>0</ns>
    <id>8365</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>29709</id>
      <parentid>29708</parentid>
      <timestamp>2012-05-01T17:34:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/printf format</title>
    <ns>0</ns>
    <id>8366</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>29711</id>
      <parentid>29710</parentid>
      <timestamp>2012-05-01T17:34:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/putchar</title>
    <ns>0</ns>
    <id>8367</id>
    <redirect title="cpp/io/c/putchar" />
    <revision>
      <id>29713</id>
      <parentid>29712</parentid>
      <timestamp>2012-05-01T17:34:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/putchar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/puts</title>
    <ns>0</ns>
    <id>8368</id>
    <redirect title="cpp/io/c/puts" />
    <revision>
      <id>29715</id>
      <parentid>29714</parentid>
      <timestamp>2012-05-01T17:34:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="27">#redirect [[cpp/io/c/puts]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/remove</title>
    <ns>0</ns>
    <id>8369</id>
    <redirect title="cpp/io/c/remove" />
    <revision>
      <id>29717</id>
      <parentid>29716</parentid>
      <timestamp>2012-05-01T17:34:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/remove]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/rename</title>
    <ns>0</ns>
    <id>8370</id>
    <redirect title="cpp/io/c/rename" />
    <revision>
      <id>29719</id>
      <parentid>29718</parentid>
      <timestamp>2012-05-01T17:34:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/rename]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/rewind</title>
    <ns>0</ns>
    <id>6736</id>
    <redirect title="cpp/io/c/rewind" />
    <revision>
      <id>26451</id>
      <parentid>26450</parentid>
      <timestamp>2012-05-01T17:19:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/rewind]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/scanf</title>
    <ns>0</ns>
    <id>6737</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>26453</id>
      <parentid>26452</parentid>
      <timestamp>2012-05-01T17:19:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/scanf format</title>
    <ns>0</ns>
    <id>6738</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>26455</id>
      <parentid>26454</parentid>
      <timestamp>2012-05-01T17:19:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/setbuf</title>
    <ns>0</ns>
    <id>6739</id>
    <redirect title="cpp/io/c/setbuf" />
    <revision>
      <id>26457</id>
      <parentid>26456</parentid>
      <timestamp>2012-05-01T17:19:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/setbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/setvbuf</title>
    <ns>0</ns>
    <id>6740</id>
    <redirect title="cpp/io/c/setvbuf" />
    <revision>
      <id>26459</id>
      <parentid>26458</parentid>
      <timestamp>2012-05-01T17:19:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/setvbuf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/snprintf</title>
    <ns>0</ns>
    <id>6741</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>26461</id>
      <parentid>26460</parentid>
      <timestamp>2012-05-01T17:19:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/sprintf</title>
    <ns>0</ns>
    <id>6742</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>26463</id>
      <parentid>26462</parentid>
      <timestamp>2012-05-01T17:19:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/sscanf</title>
    <ns>0</ns>
    <id>6743</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>26465</id>
      <parentid>26464</parentid>
      <timestamp>2012-05-01T17:20:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/start</title>
    <ns>0</ns>
    <id>6744</id>
    <redirect title="cpp/io/c" />
    <revision>
      <id>26467</id>
      <parentid>26466</parentid>
      <timestamp>2012-05-01T17:20:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="22">#redirect [[cpp/io/c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/tmpfile</title>
    <ns>0</ns>
    <id>6746</id>
    <redirect title="cpp/io/c/tmpfile" />
    <revision>
      <id>26471</id>
      <parentid>26470</parentid>
      <timestamp>2012-05-01T17:20:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/tmpfile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/tmpnam</title>
    <ns>0</ns>
    <id>6747</id>
    <redirect title="cpp/io/c/tmpnam" />
    <revision>
      <id>26473</id>
      <parentid>26472</parentid>
      <timestamp>2012-05-01T17:20:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/tmpnam]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/ungetc</title>
    <ns>0</ns>
    <id>6748</id>
    <redirect title="cpp/io/c/ungetc" />
    <revision>
      <id>26475</id>
      <parentid>26474</parentid>
      <timestamp>2012-05-01T17:20:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/ungetc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vfprintf</title>
    <ns>0</ns>
    <id>6749</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>26477</id>
      <parentid>26476</parentid>
      <timestamp>2012-05-01T17:20:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vfscanf</title>
    <ns>0</ns>
    <id>6750</id>
    <redirect title="cpp/io/c/fscanf" />
    <revision>
      <id>26479</id>
      <parentid>26478</parentid>
      <timestamp>2012-05-01T17:20:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/c/fscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vprintf</title>
    <ns>0</ns>
    <id>6751</id>
    <redirect title="cpp/io/c/fprintf" />
    <revision>
      <id>26481</id>
      <parentid>26480</parentid>
      <timestamp>2012-05-01T17:20:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/fprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vprintf vfprintf vsprintf</title>
    <ns>0</ns>
    <id>6752</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>26483</id>
      <parentid>26482</parentid>
      <timestamp>2012-05-01T17:20:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vscanf</title>
    <ns>0</ns>
    <id>6753</id>
    <redirect title="cpp/io/c/vfscanf" />
    <revision>
      <id>26485</id>
      <parentid>26484</parentid>
      <timestamp>2012-05-01T17:20:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vsnprintf</title>
    <ns>0</ns>
    <id>6754</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>26487</id>
      <parentid>26486</parentid>
      <timestamp>2012-05-01T17:20:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vsprintf</title>
    <ns>0</ns>
    <id>6755</id>
    <redirect title="cpp/io/c/vfprintf" />
    <revision>
      <id>26489</id>
      <parentid>26488</parentid>
      <timestamp>2012-05-01T17:20:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="31">#redirect [[cpp/io/c/vfprintf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/c/vsscanf</title>
    <ns>0</ns>
    <id>6756</id>
    <redirect title="cpp/io/c/vfscanf" />
    <revision>
      <id>26491</id>
      <parentid>26490</parentid>
      <timestamp>2012-05-01T17:20:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="30">#redirect [[cpp/io/c/vfscanf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/clear</title>
    <ns>0</ns>
    <id>6796</id>
    <redirect title="cpp/io/basic ios/clear" />
    <revision>
      <id>26571</id>
      <parentid>26570</parentid>
      <timestamp>2012-05-01T17:20:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/basic_ios/clear]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/close</title>
    <ns>0</ns>
    <id>6797</id>
    <redirect title="cpp/io/basic fstream/close" />
    <revision>
      <id>26573</id>
      <parentid>26572</parentid>
      <timestamp>2012-05-01T17:20:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_fstream/close]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/constructors</title>
    <ns>0</ns>
    <id>6798</id>
    <redirect title="cpp/io" />
    <revision>
      <id>26575</id>
      <parentid>26574</parentid>
      <timestamp>2012-05-01T17:20:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="20">#redirect [[cpp/io]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/eof</title>
    <ns>0</ns>
    <id>6799</id>
    <redirect title="cpp/io/basic ios/eof" />
    <revision>
      <id>26577</id>
      <parentid>26576</parentid>
      <timestamp>2012-05-01T17:20:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/basic_ios/eof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/exceptions</title>
    <ns>0</ns>
    <id>6800</id>
    <redirect title="cpp/io/basic ios/exceptions" />
    <revision>
      <id>26579</id>
      <parentid>26578</parentid>
      <timestamp>2012-05-01T17:20:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_ios/exceptions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/fail</title>
    <ns>0</ns>
    <id>6801</id>
    <redirect title="cpp/io/basic ios/fail" />
    <revision>
      <id>26581</id>
      <parentid>26580</parentid>
      <timestamp>2012-05-01T17:20:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/fail]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/fill</title>
    <ns>0</ns>
    <id>6802</id>
    <redirect title="cpp/io/basic ios/fill" />
    <revision>
      <id>26583</id>
      <parentid>26582</parentid>
      <timestamp>2012-05-01T17:20:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/fill]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/flags</title>
    <ns>0</ns>
    <id>6803</id>
    <redirect title="cpp/io/ios base/flags" />
    <revision>
      <id>26585</id>
      <parentid>26584</parentid>
      <timestamp>2012-05-01T17:20:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/flags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/flush</title>
    <ns>0</ns>
    <id>6804</id>
    <redirect title="cpp/io/basic ostream/flush" />
    <revision>
      <id>26587</id>
      <parentid>26586</parentid>
      <timestamp>2012-05-01T17:20:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="40">#redirect [[cpp/io/basic_ostream/flush]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/gcount</title>
    <ns>0</ns>
    <id>6805</id>
    <redirect title="cpp/io/basic istream/gcount" />
    <revision>
      <id>26589</id>
      <parentid>26588</parentid>
      <timestamp>2012-05-01T17:20:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_istream/gcount]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/get</title>
    <ns>0</ns>
    <id>6806</id>
    <redirect title="cpp/io/basic istream/get" />
    <revision>
      <id>26591</id>
      <parentid>26590</parentid>
      <timestamp>2012-05-01T17:20:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/basic_istream/get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/getline</title>
    <ns>0</ns>
    <id>6807</id>
    <redirect title="cpp/io/basic istream/getline" />
    <revision>
      <id>26593</id>
      <parentid>26592</parentid>
      <timestamp>2012-05-01T17:20:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="42">#redirect [[cpp/io/basic_istream/getline]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/good</title>
    <ns>0</ns>
    <id>6808</id>
    <redirect title="cpp/io/basic ios/good" />
    <revision>
      <id>26595</id>
      <parentid>26594</parentid>
      <timestamp>2012-05-01T17:20:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/basic_ios/good]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ignore</title>
    <ns>0</ns>
    <id>6809</id>
    <redirect title="cpp/io/basic istream/ignore" />
    <revision>
      <id>26597</id>
      <parentid>26596</parentid>
      <timestamp>2012-05-01T17:20:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="41">#redirect [[cpp/io/basic_istream/ignore]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/io flags</title>
    <ns>0</ns>
    <id>6810</id>
    <redirect title="cpp/io/ios base/flags" />
    <revision>
      <id>29737</id>
      <parentid>26599</parentid>
      <timestamp>2012-05-01T18:07:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/ios base/flags]]</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/flags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/</title>
    <ns>0</ns>
    <id>6783</id>
    <redirect title="cpp/io/ios base" />
    <revision>
      <id>26545</id>
      <parentid>26544</parentid>
      <timestamp>2012-05-01T17:20:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/ios_base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/app</title>
    <ns>0</ns>
    <id>6757</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26493</id>
      <parentid>26492</parentid>
      <timestamp>2012-05-01T17:20:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/ate</title>
    <ns>0</ns>
    <id>6758</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26495</id>
      <parentid>26494</parentid>
      <timestamp>2012-05-01T17:20:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/beg</title>
    <ns>0</ns>
    <id>6759</id>
    <redirect title="cpp/io/ios base/seekdir" />
    <revision>
      <id>26497</id>
      <parentid>26496</parentid>
      <timestamp>2012-05-01T17:20:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/seekdir]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/binary</title>
    <ns>0</ns>
    <id>6760</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26499</id>
      <parentid>26498</parentid>
      <timestamp>2012-05-01T17:20:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/cur</title>
    <ns>0</ns>
    <id>6761</id>
    <redirect title="cpp/io/ios base/seekdir" />
    <revision>
      <id>26501</id>
      <parentid>26500</parentid>
      <timestamp>2012-05-01T17:20:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/seekdir]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/d ios base</title>
    <ns>0</ns>
    <id>6762</id>
    <redirect title="cpp/io/ios base/~ios base" />
    <revision>
      <id>26503</id>
      <parentid>26502</parentid>
      <timestamp>2012-05-01T17:20:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/ios_base/~ios_base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/end</title>
    <ns>0</ns>
    <id>6763</id>
    <redirect title="cpp/io/ios base/seekdir" />
    <revision>
      <id>26505</id>
      <parentid>26504</parentid>
      <timestamp>2012-05-01T17:20:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/seekdir]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/event</title>
    <ns>0</ns>
    <id>6764</id>
    <redirect title="cpp/io/ios base/event" />
    <revision>
      <id>26507</id>
      <parentid>26506</parentid>
      <timestamp>2012-05-01T17:20:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/event]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/event callback</title>
    <ns>0</ns>
    <id>6765</id>
    <redirect title="cpp/io/ios base/event callback" />
    <revision>
      <id>26509</id>
      <parentid>26508</parentid>
      <timestamp>2012-05-01T17:20:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="44">#redirect [[cpp/io/ios_base/event_callback]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/flags</title>
    <ns>0</ns>
    <id>6766</id>
    <redirect title="cpp/io/ios base/flags" />
    <revision>
      <id>26511</id>
      <parentid>26510</parentid>
      <timestamp>2012-05-01T17:20:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/flags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/fmtflags</title>
    <ns>0</ns>
    <id>6767</id>
    <redirect title="cpp/io/ios base/fmtflags" />
    <revision>
      <id>26513</id>
      <parentid>26512</parentid>
      <timestamp>2012-05-01T17:20:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/fmtflags]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/getloc</title>
    <ns>0</ns>
    <id>6768</id>
    <redirect title="cpp/io/ios base/getloc" />
    <revision>
      <id>26515</id>
      <parentid>26514</parentid>
      <timestamp>2012-05-01T17:20:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/ios_base/getloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/imbue</title>
    <ns>0</ns>
    <id>6769</id>
    <redirect title="cpp/io/ios base/imbue" />
    <revision>
      <id>26517</id>
      <parentid>26516</parentid>
      <timestamp>2012-05-01T17:20:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/imbue]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/in</title>
    <ns>0</ns>
    <id>6770</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26519</id>
      <parentid>26518</parentid>
      <timestamp>2012-05-01T17:20:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/init</title>
    <ns>0</ns>
    <id>6771</id>
    <redirect title="cpp/io/ios base/Init" />
    <revision>
      <id>26521</id>
      <parentid>26520</parentid>
      <timestamp>2012-05-01T17:20:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/ios_base/Init]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/ios base</title>
    <ns>0</ns>
    <id>6772</id>
    <redirect title="cpp/io/ios base/ios base" />
    <revision>
      <id>26523</id>
      <parentid>26522</parentid>
      <timestamp>2012-05-01T17:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/ios_base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/iostate</title>
    <ns>0</ns>
    <id>6773</id>
    <redirect title="cpp/io/ios base/iostate" />
    <revision>
      <id>26525</id>
      <parentid>26524</parentid>
      <timestamp>2012-05-01T17:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/iostate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/iword</title>
    <ns>0</ns>
    <id>6774</id>
    <redirect title="cpp/io/ios base/iword" />
    <revision>
      <id>26527</id>
      <parentid>26526</parentid>
      <timestamp>2012-05-01T17:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/iword]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/openmode</title>
    <ns>0</ns>
    <id>6775</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26529</id>
      <parentid>26528</parentid>
      <timestamp>2012-05-01T17:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/out</title>
    <ns>0</ns>
    <id>6776</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>26531</id>
      <parentid>26530</parentid>
      <timestamp>2012-05-01T17:20:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/precision</title>
    <ns>0</ns>
    <id>6777</id>
    <redirect title="cpp/io/ios base/precision" />
    <revision>
      <id>26533</id>
      <parentid>26532</parentid>
      <timestamp>2012-05-01T17:20:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="39">#redirect [[cpp/io/ios_base/precision]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/pword</title>
    <ns>0</ns>
    <id>6778</id>
    <redirect title="cpp/io/ios base/pword" />
    <revision>
      <id>26535</id>
      <parentid>26534</parentid>
      <timestamp>2012-05-01T17:20:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/pword]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/register callback</title>
    <ns>0</ns>
    <id>6779</id>
    <redirect title="cpp/io/ios base/register callback" />
    <revision>
      <id>26537</id>
      <parentid>26536</parentid>
      <timestamp>2012-05-01T17:20:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="47">#redirect [[cpp/io/ios_base/register_callback]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/seekdir</title>
    <ns>0</ns>
    <id>6780</id>
    <redirect title="cpp/io/ios base/seekdir" />
    <revision>
      <id>26539</id>
      <parentid>26538</parentid>
      <timestamp>2012-05-01T17:20:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="37">#redirect [[cpp/io/ios_base/seekdir]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/setf</title>
    <ns>0</ns>
    <id>6781</id>
    <redirect title="cpp/io/ios base/setf" />
    <revision>
      <id>26541</id>
      <parentid>26540</parentid>
      <timestamp>2012-05-01T17:20:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="34">#redirect [[cpp/io/ios_base/setf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/start</title>
    <ns>0</ns>
    <id>6782</id>
    <redirect title="cpp/io/ios base" />
    <revision>
      <id>26543</id>
      <parentid>26542</parentid>
      <timestamp>2012-05-01T17:20:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="29">#redirect [[cpp/io/ios_base]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/sync with stdio</title>
    <ns>0</ns>
    <id>6784</id>
    <redirect title="cpp/io/ios base/sync with stdio" />
    <revision>
      <id>26547</id>
      <parentid>26546</parentid>
      <timestamp>2012-05-01T17:20:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="45">#redirect [[cpp/io/ios_base/sync_with_stdio]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/trunc</title>
    <ns>0</ns>
    <id>6785</id>
    <redirect title="cpp/io/ios base/openmode" />
    <revision>
      <id>29736</id>
      <parentid>26549</parentid>
      <timestamp>2012-05-01T18:06:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[cpp/io/ios base/openmode]]</comment>
      <text xml:space="preserve" bytes="38">#redirect [[cpp/io/ios_base/openmode]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/unsetf</title>
    <ns>0</ns>
    <id>6786</id>
    <redirect title="cpp/io/ios base/unsetf" />
    <revision>
      <id>26551</id>
      <parentid>26550</parentid>
      <timestamp>2012-05-01T17:20:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/ios_base/unsetf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/width</title>
    <ns>0</ns>
    <id>6787</id>
    <redirect title="cpp/io/ios base/width" />
    <revision>
      <id>26553</id>
      <parentid>26552</parentid>
      <timestamp>2012-05-01T17:20:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="35">#redirect [[cpp/io/ios_base/width]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>old/wiki/io/ios base/xalloc</title>
    <ns>0</ns>
    <id>6788</id>
    <redirect title="cpp/io/ios base/xalloc" />
    <revision>
      <id>26555</id>
      <parentid>26554</parentid>
      <timestamp>2012-05-01T17:20:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Add redirects from dokuwiki</comment>
      <text xml:space="preserve" bytes="36">#redirect [[cpp/io/ios_base/xalloc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!</title>
    <ns>10</ns>
    <id>1793</id>
    <revision>
      <id>13545</id>
      <parentid>13543</parentid>
      <timestamp>2011-11-09T12:08:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 13543 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="60">|&lt;noinclude&gt;
{{documentation | Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!!</title>
    <ns>10</ns>
    <id>1794</id>
    <revision>
      <id>13939</id>
      <parentid>13546</parentid>
      <timestamp>2011-11-15T21:57:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>undo again: breaks syntax highlighting</comment>
      <text xml:space="preserve" bytes="61">||&lt;noinclude&gt;
{{documentation | Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!)</title>
    <ns>10</ns>
    <id>10100</id>
    <revision>
      <id>48131</id>
      <timestamp>2013-05-18T18:38:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">&lt;includeonly&gt;|}&lt;/includeonly&gt;&lt;noinclude&gt;&lt;nowiki&gt;|}&lt;/nowiki&gt;{{documentation | Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!-</title>
    <ns>10</ns>
    <id>1795</id>
    <revision>
      <id>3590</id>
      <parentid>3589</parentid>
      <timestamp>2011-06-06T23:01:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="2">|-</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!/doc</title>
    <ns>10</ns>
    <id>1796</id>
    <revision>
      <id>48132</id>
      <parentid>4623</parentid>
      <timestamp>2013-05-18T18:39:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="297">This is one of the templates used to output special symbols:

{{tl|!}} - outputs &lt;tt&gt;|&lt;/tt&gt;

{{tl|!!}} - outputs &lt;tt&gt;||&lt;/tt&gt;

{{tl|1==}} - outputs &lt;tt&gt;=&lt;/tt&gt;

{{tl|1===}} - outputs &lt;tt&gt;==&lt;/tt&gt;

{{tl|1=!=}} - outputs &lt;tt&gt;|=&lt;/tt&gt;

{{tl|1=(!}} - outputs &lt;tt&gt;{|&lt;/tt&gt;

{{tl|1=!)}} - outputs &lt;tt&gt;|}&lt;/tt&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:!=</title>
    <ns>10</ns>
    <id>1797</id>
    <revision>
      <id>3594</id>
      <parentid>3593</parentid>
      <timestamp>2011-06-06T23:01:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="61">|=&lt;noinclude&gt;
{{documentation | Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:(!</title>
    <ns>10</ns>
    <id>10099</id>
    <revision>
      <id>48130</id>
      <timestamp>2013-05-18T18:38:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">&lt;includeonly&gt;{|&lt;/includeonly&gt;&lt;noinclude&gt;&lt;nowiki&gt;{|&lt;/nowiki&gt;{{documentation | Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:=</title>
    <ns>10</ns>
    <id>1798</id>
    <revision>
      <id>3596</id>
      <parentid>3595</parentid>
      <timestamp>2011-06-06T23:01:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="58">=&lt;noinclude&gt;
{{documentation|Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:==</title>
    <ns>10</ns>
    <id>1799</id>
    <revision>
      <id>3598</id>
      <parentid>3597</parentid>
      <timestamp>2011-06-06T23:01:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="59">==&lt;noinclude&gt;
{{documentation|Template:!/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:Talk archive navigation</title>
    <ns>10</ns>
    <id>10095</id>
    <revision>
      <id>48014</id>
      <parentid>48012</parentid>
      <timestamp>2013-05-18T17:13:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>background</comment>
      <text xml:space="preserve" bytes="26908">{{fmbox
| style = background: none repeat scroll 0 0 #F8EABA; {{{style|}}}
| textstyle = {{{textstyle|}}}
| image = [[File:{{{icon|Replacement filing cabinet.svg}}}|40x40px|alt=|link=]]
| text  = 
This is an archive of past discussions{{#if:{{{period|}}}|&amp;#32;for the period '''{{{period}}}'''}}. '''Do not edit the contents of this page.''' If you wish to start a new discussion or revive an old one, please do so on the [[{{NAMESPACE}}:{{BASEPAGENAME}}|current page]].
}}
{| style=&quot;width: 32em; background: transparent; margin: 0 auto 0.5em; text-align: center&quot;
| {{#switch:{{SUBPAGENAME}}|
Archive 2={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 1|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 1|&amp;larr; Archive 1]]}}|
Archive 3={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 2|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 2|&amp;larr; Archive 2]]}}|
Archive 4={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 3|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 3|&amp;larr; Archive 3]]}}|
Archive 5={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 4|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 4|&amp;larr; Archive 4]]}}|
Archive 6={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 5|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 5|&amp;larr; Archive 5]]}}|
Archive 7={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 6|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 6|&amp;larr; Archive 6]]}}|
Archive 8={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 7|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 7|&amp;larr; Archive 7]]}}|
Archive 9={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 8|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 8|&amp;larr; Archive 8]]}}|
Archive 10={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 9|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 9|&amp;larr; Archive 9]]}}|
Archive 11={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 10|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 10|&amp;larr; Archive 10]]}}|
Archive 12={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 11|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 11|&amp;larr; Archive 11]]}}|
Archive 13={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 12|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 12|&amp;larr; Archive 12]]}}|
Archive 14={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 13|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 13|&amp;larr; Archive 13]]}}|
Archive 15={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 14|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 14|&amp;larr; Archive 14]]}}|
Archive 16={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 15|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 15|&amp;larr; Archive 15]]}}|
Archive 17={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 16|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 16|&amp;larr; Archive 16]]}}|
Archive 18={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 17|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 17|&amp;larr; Archive 17]]}}|
Archive 19={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 18|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 18|&amp;larr; Archive 18]]}}|
Archive 20={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 19|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 19|&amp;larr; Archive 19]]}}|
Archive 21={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 20|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 20|&amp;larr; Archive 20]]}}|
Archive 22={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 21|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 21|&amp;larr; Archive 21]]}}|
Archive 23={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 22|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 22|&amp;larr; Archive 22]]}}|
Archive 24={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 23|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 23|&amp;larr; Archive 23]]}}|
Archive 25={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 24|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 24|&amp;larr; Archive 24]]}}|
Archive 26={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 25|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 25|&amp;larr; Archive 25]]}}|
Archive 27={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 26|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 26|&amp;larr; Archive 26]]}}|
Archive 28={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 27|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 27|&amp;larr; Archive 27]]}}|
Archive 29={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 28|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 28|&amp;larr; Archive 28]]}}|
Archive 30={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 29|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 29|&amp;larr; Archive 29]]}}|
Archive 31={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 30|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 30|&amp;larr; Archive 30]]}}|
Archive 32={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 31|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 31|&amp;larr; Archive 31]]}}|
Archive 33={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 32|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 32|&amp;larr; Archive 32]]}}|
Archive 34={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 33|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 33|&amp;larr; Archive 33]]}}|
Archive 35={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 34|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 34|&amp;larr; Archive 34]]}}|
Archive 36={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 35|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 35|&amp;larr; Archive 35]]}}|
Archive 37={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 36|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 36|&amp;larr; Archive 36]]}}|
Archive 38={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 37|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 37|&amp;larr; Archive 37]]}}|
Archive 39={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 38|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 38|&amp;larr; Archive 38]]}}|
Archive 40={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 39|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 39|&amp;larr; Archive 39]]}}|
Archive 41={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 40|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 40|&amp;larr; Archive 40]]}}|
Archive 42={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 41|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 41|&amp;larr; Archive 41]]}}|
Archive 43={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 42|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 42|&amp;larr; Archive 42]]}}|
Archive 44={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 43|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 43|&amp;larr; Archive 43]]}}|
Archive 45={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 44|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 44|&amp;larr; Archive 44]]}}|
Archive 46={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 45|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 45|&amp;larr; Archive 45]]}}|
Archive 47={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 46|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 46|&amp;larr; Archive 46]]}}|
Archive 48={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 47|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 47|&amp;larr; Archive 47]]}}|
Archive 49={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 48|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 48|&amp;larr; Archive 48]]}}|
Archive 50={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 49|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 49|&amp;larr; Archive 49]]}}|
Archive 51={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 50|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 50|&amp;larr; Archive 50]]}}|
Archive 52={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 51|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 51|&amp;larr; Archive 51]]}}|
Archive 53={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 52|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 52|&amp;larr; Archive 52]]}}|
Archive 54={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 53|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 53|&amp;larr; Archive 53]]}}|
Archive 55={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 54|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 54|&amp;larr; Archive 54]]}}|
Archive 56={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 55|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 55|&amp;larr; Archive 55]]}}|
Archive 57={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 56|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 56|&amp;larr; Archive 56]]}}|
Archive 58={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 57|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 57|&amp;larr; Archive 57]]}}|
Archive 59={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 58|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 58|&amp;larr; Archive 58]]}}|
Archive 60={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 59|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 59|&amp;larr; Archive 59]]}}|
Archive 61={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 60|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 60|&amp;larr; Archive 60]]}}|
Archive 62={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 61|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 61|&amp;larr; Archive 61]]}}|
Archive 63={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 62|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 62|&amp;larr; Archive 62]]}}|
Archive 64={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 63|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 63|&amp;larr; Archive 63]]}}|
Archive 65={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 64|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 64|&amp;larr; Archive 64]]}}|
Archive 66={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 65|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 65|&amp;larr; Archive 65]]}}|
Archive 67={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 66|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 66|&amp;larr; Archive 66]]}}|
Archive 68={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 67|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 67|&amp;larr; Archive 67]]}}|
Archive 69={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 68|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 68|&amp;larr; Archive 68]]}}|
Archive 70={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 69|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 69|&amp;larr; Archive 69]]}}}}
| '''{{SUBPAGENAME}}'''
| {{#switch:{{SUBPAGENAME}}|
Archive 1={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 2|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 2|Archive 2 &amp;rarr;]]}}|
Archive 2={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 3|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 3|Archive 3 &amp;rarr;]]}}|
Archive 3={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 4|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 4|Archive 4 &amp;rarr;]]}}|
Archive 4={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 5|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 5|Archive 5 &amp;rarr;]]}}|
Archive 5={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 6|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 6|Archive 6 &amp;rarr;]]}}|
Archive 6={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 7|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 7|Archive 7 &amp;rarr;]]}}|
Archive 7={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 8|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 8|Archive 8 &amp;rarr;]]}}|
Archive 8={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 9|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 9|Archive 9 &amp;rarr;]]}}|
Archive 9={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 10|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 10|Archive 10 &amp;rarr;]]}}|
Archive 10={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 11|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 11|Archive 11 &amp;rarr;]]}}|
Archive 11={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 12|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 12|Archive 12 &amp;rarr;]]}}|
Archive 12={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 13|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 13|Archive 13 &amp;rarr;]]}}|
Archive 13={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 14|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 14|Archive 14 &amp;rarr;]]}}|
Archive 14={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 15|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 15|Archive 15 &amp;rarr;]]}}|
Archive 15={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 16|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 16|Archive 16 &amp;rarr;]]}}|
Archive 16={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 17|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 17|Archive 17 &amp;rarr;]]}}|
Archive 17={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 18|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 18|Archive 18 &amp;rarr;]]}}|
Archive 18={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 19|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 19|Archive 19 &amp;rarr;]]}}|
Archive 19={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 20|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 20|Archive 20 &amp;rarr;]]}}|
Archive 20={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 21|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 21|Archive 21 &amp;rarr;]]}}|
Archive 21={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 22|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 22|Archive 22 &amp;rarr;]]}}|
Archive 22={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 23|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 23|Archive 23 &amp;rarr;]]}}|
Archive 23={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 24|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 24|Archive 24 &amp;rarr;]]}}|
Archive 24={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 25|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 25|Archive 25 &amp;rarr;]]}}|
Archive 25={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 26|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 26|Archive 26 &amp;rarr;]]}}|
Archive 26={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 27|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 27|Archive 27 &amp;rarr;]]}}|
Archive 27={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 28|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 28|Archive 28 &amp;rarr;]]}}|
Archive 28={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 29|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 29|Archive 29 &amp;rarr;]]}}|
Archive 29={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 30|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 30|Archive 30 &amp;rarr;]]}}|
Archive 30={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 31|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 31|Archive 31 &amp;rarr;]]}}|
Archive 31={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 32|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 32|Archive 32 &amp;rarr;]]}}|
Archive 32={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 33|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 33|Archive 33 &amp;rarr;]]}}|
Archive 33={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 34|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 34|Archive 34 &amp;rarr;]]}}|
Archive 34={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 35|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 35|Archive 35 &amp;rarr;]]}}|
Archive 35={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 36|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 36|Archive 36 &amp;rarr;]]}}|
Archive 36={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 37|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 37|Archive 37 &amp;rarr;]]}}|
Archive 37={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 38|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 38|Archive 38 &amp;rarr;]]}}|
Archive 38={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 39|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 39|Archive 39 &amp;rarr;]]}}|
Archive 39={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 40|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 40|Archive 40 &amp;rarr;]]}}|
Archive 40={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 41|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 41|Archive 41 &amp;rarr;]]}}|
Archive 41={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 42|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 42|Archive 42 &amp;rarr;]]}}|
Archive 42={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 43|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 43|Archive 43 &amp;rarr;]]}}|
Archive 43={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 44|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 44|Archive 44 &amp;rarr;]]}}|
Archive 44={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 45|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 45|Archive 45 &amp;rarr;]]}}|
Archive 45={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 46|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 46|Archive 46 &amp;rarr;]]}}|
Archive 46={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 47|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 47|Archive 47 &amp;rarr;]]}}|
Archive 47={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 48|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 48|Archive 48 &amp;rarr;]]}}|
Archive 48={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 49|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 49|Archive 49 &amp;rarr;]]}}|
Archive 49={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 50|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 50|Archive 50 &amp;rarr;]]}}|
Archive 50={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 51|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 51|Archive 51 &amp;rarr;]]}}|
Archive 51={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 52|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 52|Archive 52 &amp;rarr;]]}}|
Archive 52={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 53|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 53|Archive 53 &amp;rarr;]]}}|
Archive 53={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 548|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 54|Archive 54 &amp;rarr;]]}}|
Archive 54={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 559|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 55|Archive 55 &amp;rarr;]]}}|
Archive 55={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 56|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 56|Archive 56 &amp;rarr;]]}}|
Archive 56={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 57|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 57|Archive 57 &amp;rarr;]]}}|
Archive 57={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 58|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 58|Archive 58 &amp;rarr;]]}}|
Archive 58={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 59|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 59|Archive 59 &amp;rarr;]]}}|
Archive 59={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 60|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 60|Archive 60 &amp;rarr;]]}}|
Archive 60={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 61|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 61|Archive 61 &amp;rarr;]]}}|
Archive 61={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 62|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 62|Archive 62 &amp;rarr;]]}}|
Archive 62={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 63|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 63|Archive 63 &amp;rarr;]]}}|
Archive 63={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 64|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 64|Archive 64 &amp;rarr;]]}}|
Archive 64={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 65|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 65|Archive 65 &amp;rarr;]]}}|
Archive 65={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 66|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 66|Archive 66 &amp;rarr;]]}}|
Archive 66={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 67|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 67|Archive 67 &amp;rarr;]]}}|
Archive 67={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 68|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 68|Archive 68 &amp;rarr;]]}}|
Archive 68={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 69|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 69|Archive 69 &amp;rarr;]]}}|
Archive 69={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 70|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 70|Archive 70 &amp;rarr;]]}}|
Archive 70={{#ifexpr:({{#ifeq:{{{noredlinks|}}}|y|1|0}} and {{#ifexist:{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 71|0|1}})||[[{{NAMESPACE}}:{{BASEPAGENAME}}/Archive 71|Archive 71 &amp;rarr;]]}}}}
|}&lt;includeonly&gt;{{{category|__NOEDITSECTION__}}}__NONEWSECTIONLINK__&lt;/includeonly&gt;&lt;noinclude&gt;

{{documentation}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ambox</title>
    <ns>10</ns>
    <id>1801</id>
    <revision>
      <id>15475</id>
      <parentid>4144</parentid>
      <timestamp>2011-12-10T15:33:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc link</comment>
      <text xml:space="preserve" bytes="1288">{{#ifeq:{{{subst}}}|SUBST
 |{{#if:{{{name|}}}
  |{{error|Template {{tlx|{{{name}}}}} has been incorrectly substituted.}}
 }}
}}{{#ifeq:{{{small}}}|left
 |{{ambox/core
  |small      = left
  |type       = {{{type|}}}
  |image      = {{#if:{{{smallimage|}}}
   |{{{smallimage}}}
   |{{{image|}}}
  }}
  |imageright = {{#if:{{{smallimageright|}}}
   |{{{smallimageright}}}
   |{{{imageright|}}}
  }}
  |style      = {{{style|}}}
  |textstyle  = {{{textstyle|}}}
  |text       = {{#if:{{{smalltext|}}}
   |{{{smalltext}}} 
   |{{{text}}} 
  }}
 }}
 |{{ambox/core
  |type       = {{{type|}}}
  |image      = {{{image|}}}
  |imageright = {{{imageright|}}}
  |style      = {{{style|}}}
  |textstyle  = {{{textstyle|}}}
  |text       = {{{text}}}
  |date       = {{#ifeq:{{FULLROOTPAGENAME}}|Template:{{PAGENAME:{{{name}}}}}
   |{{#ifeq:{{{date|¬}}}|¬||{{CURRENTMONTHNAME}} {{CURRENTYEAR}}}}
   |{{{date|}}}
  }}
 }}
}}{{cat handler
 |main={{ambox/category
  |cat={{{cat|}}}
  |date={{{date|}}}
  |all={{{all|}}}
 }}
 |template={{#ifeq:{{BASEPAGENAME}}|{{SUBPAGENAME}}|}}
}}{{#ifeq:{{FULLPAGENAME}}|Template:{{PAGENAME:{{{name}}}}}
 |{{#ifeq:{{{doc}}}|no|
  |{{documentation}}&lt;!-- Transclude documentation on template page --&gt;
 }}
}}&lt;noinclude&gt;

{{documentation|Template:mbox/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ambox/category</title>
    <ns>10</ns>
    <id>1802</id>
    <revision>
      <id>3604</id>
      <parentid>3603</parentid>
      <timestamp>2011-06-06T23:01:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="308">{{#if:{{{cat|}}}
 |{{#if:{{{date|}}}
  |[[Category:{{{cat}}} {{{preposition|from}}} {{{date}}}]]{{#ifexist:Category:{{{cat}}} {{{preposition|from}}} {{{date}}}|
   |[[Category:Articles with invalid date parameter in template]]
  }}
  |[[Category:{{{cat}}}]]
 }}
}}{{#if:{{{all|}}}
 |[[Category:{{{all}}}]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ambox/core</title>
    <ns>10</ns>
    <id>1803</id>
    <revision>
      <id>20008</id>
      <parentid>10525</parentid>
      <timestamp>2012-03-19T18:26:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="2900">&lt;table class=&quot;metadata plainlinks ambox {{#switch:{{{small|}}}
| left = mbox-small-left
}} {{#switch:{{{type|}}}
| speedy     = ambox-speedy
| delete     = ambox-delete
| content    = ambox-content
| style      = ambox-style
| move       = ambox-move
| protection = ambox-protection
| notice     &lt;!-- notice = default --&gt;
| #default   = ambox-notice
}}&quot; style=&quot;{{{style|}}}&quot;&gt;&lt;!--
--&gt;&lt;tr&gt;&lt;!--
  --&gt;{{#switch:{{{image|}}}
     | blank    &lt;!-- Fall back to &quot;none&quot;, since deprecated. --&gt;
     | none = &lt;td class=&quot;mbox-empty-cell&quot;&gt;&lt;/td&gt;   &lt;!-- No image. Cell with some width or padding necessary for text cell to have 100% width. --&gt;
     | #default = &lt;!--
  --&gt;&lt;td class=&quot;mbox-image&quot;&gt;&lt;!--
    --&gt;{{#switch:{{{small|}}}
       | left = &lt;!-- Don't use the DIV --&gt; 
       | #default = &lt;div style=&quot;width: 52px;&quot;&gt; 
       }}&lt;!--
    --&gt;{{#if:{{{image|}}}
       | {{{image}}}
       | [[File:&lt;!--
      --&gt;{{#switch:{{{type|}}}
         | speedy     = Ambox speedy deletion.png
         | delete     = Ambox deletion.png
         | content    = Ambox content.png
         | style      = Edit-clear.svg
         | move       = Ambox move.png
         | protection = Ambox protection.png
         | notice          &lt;!-- notice = default --&gt;
         | #default   = Ambox notice.png
         }} | &lt;!--
      --&gt;{{#switch:{{{small|}}} 
         | left = 20x20px 
         | #default = 40x40px 
         }} | link= |alt= &lt;!--
      --&gt;]]&lt;!--
    --&gt;}}&lt;!--
    --&gt;{{#switch:{{{small|}}}
       | left = &lt;!-- Don't use the /DIV --&gt;
       | #default = &lt;/div&gt; 
       }}&lt;!--
  --&gt;&lt;/td&gt;&lt;!--
  --&gt;}}&lt;!--
  --&gt;&lt;td class=&quot;mbox-text&quot; style=&quot;{{{textstyle|}}}&quot;&gt;&lt;!--
   --&gt;{{{text}}} {{#if:{{{date|}}}|&lt;small&gt;''({{{date}}})''&lt;/small&gt;}}&lt;!--
  --&gt;&lt;/td&gt;&lt;!--
  --&gt;{{#if:{{{imageright|}}}
     | {{#ifeq:{{{imageright|}}}|none
       | &lt;!-- No image.--&gt;
       | &lt;td class=&quot;mbox-imageright&quot;&gt;&lt;!--
        --&gt;{{#switch:{{{small|}}}
           | left = {{{imageright}}}
           | #default = &lt;div style=&quot;width: 52px;&quot;&gt; {{{imageright}}} &lt;/div&gt;
           }}&lt;!--
      --&gt;&lt;/td&gt;&lt;!--
    --&gt;}}&lt;!--
  --&gt;}}&lt;!--
--&gt;&lt;/tr&gt;&lt;/table&gt;&lt;!-- 
Detect and report usage with faulty &quot;type&quot; parameter:
--&gt;{{#switch:{{{type|}}}
|   &lt;!-- No type fed, is also valid input --&gt;
| speedy
| delete
| content
| style
| move
| protection
| notice     = &lt;!-- Do nothing, valid &quot;type&quot; --&gt;
| #default   = &lt;div style=&quot;text-align: center;&quot;&gt;This message box is using an invalid &quot;type={{{type|}}}&quot; parameter and needs fixing.&lt;/div&gt;[[Category:Wikipedia message box parameter needs fixing|{{main other|Main:}}{{FULLPAGENAME}}]]&lt;!-- Sort on namespace --&gt;
}}&lt;!-- 
Detect and report usage of deprecated &quot;image=blank&quot;:
--&gt;{{#switch:{{{image|}}}
| blank = [[Category:Wikipedia message box parameter needs fixing|{{main other|Main:}}{{FULLPAGENAME}}]]&lt;!-- Sort on namespace --&gt;
}}&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:anchor</title>
    <ns>10</ns>
    <id>12964</id>
    <revision>
      <id>65279</id>
      <timestamp>2013-09-06T22:09:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="675">{{#if:{{{1|}}}|&lt;span id=&quot;{{{1|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{2|}}}|&lt;span id=&quot;{{{2|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{3|}}}|&lt;span id=&quot;{{{3|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{4|}}}|&lt;span id=&quot;{{{4|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{5|}}}|&lt;span id=&quot;{{{5|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{6|}}}|&lt;span id=&quot;{{{6|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{7|}}}|&lt;span id=&quot;{{{7|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{8|}}}|&lt;span id=&quot;{{{8|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{9|}}}|&lt;span id=&quot;{{{9|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{10|}}}|&lt;span id=&quot;{{{10|}}}&quot;&gt;&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{11|}}}|&lt;span class=&quot;error&quot;&gt;[[Template:Anchor]] (or Anchors): too many anchors, maximum is 10.&lt;/span&gt;}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1>c2yyfcwzozsbbn693ucl9hyjhetli94</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:archive list long</title>
    <ns>10</ns>
    <id>10097</id>
    <revision>
      <id>48129</id>
      <parentid>48128</parentid>
      <timestamp>2013-05-18T18:35:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="946">{{#if: {{{num|}}} | {{(!}} cellpadding=&quot;0&quot; width=&quot;100%&quot; style=&quot;text-align: center; background-color: transparent;&quot;
{{#ifexpr: 1 &lt;= {{{num|0}}} |
{{!}} [[{{#rel2abs:./Archive 1|{{{root|}}}}}|Archive 1]]
{{!}} {{#ifexpr: 2 &lt;= {{{num|0}}} | [[{{#rel2abs:./Archive 2|{{{root|}}}}}|Archive 2]]}}
{{!}} {{#ifexpr: 3 &lt;= {{{num|0}}} | [[{{#rel2abs:./Archive 3|{{{root|}}}}}|Archive 3]]}}
{{!}}-
}}
{{#ifexpr: 4 &lt;= {{{num|0}}} |
{{!}} [[{{#rel2abs:./Archive 4|{{{root|}}}}}|Archive 4]]
{{!}} {{#ifexpr: 5 &lt;= {{{num|0}}} | [[{{#rel2abs:./Archive 5|{{{root|}}}}}|Archive 5]]}}
{{!}} {{#ifexpr: 6 &lt;= {{{num|0}}} |[[{{#rel2abs:./Archive 6|{{{root|}}}}}|Archive 6]]}}
{{!}}-
}}
{{#ifexpr: 7 &lt;= {{{num|0}}} |
{{!}} [[{{#rel2abs:./Archive 7|{{{root|}}}}}|Archive 7]]
{{!}} {{#ifexpr: 8 &lt;= {{{num|0}}} |[[{{#rel2abs:./Archive 8|{{{root|}}}}}|Archive 8]]}}
{{!}} {{#ifexpr: 9 &lt;= {{{num|0}}} |[[{{#rel2abs:./Archive 9|{{{root|}}}}}|Archive 9]]}}
{{!}}-
}}
{{!)}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:archives</title>
    <ns>10</ns>
    <id>10096</id>
    <revision>
      <id>48126</id>
      <parentid>48021</parentid>
      <timestamp>2013-05-18T18:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+num param</comment>
      <text xml:space="preserve" bytes="371">&lt;table class=&quot;tmbox&quot; style=&quot;text-align: center; {{#if:{{{box-width|}}}|width:{{{box-width}}};}} {{{style|}}}&quot;&gt;
&lt;tr&gt;&lt;th style=&quot;padding: 0.5em;&quot;&gt;[[Image:Replacement filing cabinet.svg|40px]]
{{{title|Archives}}}
&lt;/th&gt;&lt;td style=&quot;text-align:left; padding: 0.5em; min-width: 100px;&quot;&gt;{{archive list long|num={{{num|}}}|{{#if:{{{root|}}}|root}}={{{root}}} }}
&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c</title>
    <ns>10</ns>
    <id>6244</id>
    <revision>
      <id>64029</id>
      <parentid>64012</parentid>
      <timestamp>2013-08-06T23:08:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:c]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="185">&lt;onlyinclude&gt;&lt;span class=&quot;t-c&quot;&gt;{{#tag:source|{{{code|{{trim|{{{1}}}}}}}}|lang={{{lang|{{{2|{{get_lang}}}}}}}}|enclose=none}}&lt;/span&gt;&lt;/onlyinclude&gt;
{{documentation | Template:source/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/algorithm/dsc bsearch</title>
    <ns>10</ns>
    <id>5967</id>
    <revision>
      <id>53054</id>
      <parentid>51763</parentid>
      <timestamp>2013-06-01T04:58:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/algorithm/dcl list bsearch]] to [[Template:c/algorithm/dsc bsearch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/algorithm/bsearch | searches an array for an element of unspecified type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/algorithm/dsc qsort</title>
    <ns>10</ns>
    <id>5968</id>
    <revision>
      <id>53057</id>
      <parentid>51764</parentid>
      <timestamp>2013-06-01T04:58:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/algorithm/dcl list qsort]] to [[Template:c/algorithm/dsc qsort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | c/algorithm/qsort | sorts a range of elements with unspecified type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/algorithm/navbar</title>
    <ns>10</ns>
    <id>6117</id>
    <revision>
      <id>39835</id>
      <parentid>35717</parentid>
      <timestamp>2012-09-28T19:55:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="148">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/algorithm/navbar heading
|content2 = c/algorithm/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/algorithm/navbar content</title>
    <ns>10</ns>
    <id>6119</id>
    <revision>
      <id>51765</id>
      <parentid>35469</parentid>
      <timestamp>2013-06-01T04:34:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="85">{{nv begin}}
{{nv ln | c/algorithm/qsort}}
{{nv ln | c/algorithm/bsearch}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/algorithm/navbar heading</title>
    <ns>10</ns>
    <id>6118</id>
    <revision>
      <id>35470</id>
      <parentid>21442</parentid>
      <timestamp>2012-06-15T22:26:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/algorithm/sidebar heading]] to [[Template:c/algorithm/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="28">[[c/algorithm | Algorithms]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/align/dsc alignas</title>
    <ns>10</ns>
    <id>13706</id>
    <revision>
      <id>71922</id>
      <parentid>71917</parentid>
      <timestamp>2014-07-01T21:03:02Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="111">{{dsc macro fun | c/align/alignas | set the alignment requirement of a type or an object | notes={{mark c11}}}}</text>
      <sha1>c7px9aptlpej3nhcwr3cjsgqtnatni4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/align/dsc alignas is defined</title>
    <ns>10</ns>
    <id>13708</id>
    <revision>
      <id>71919</id>
      <timestamp>2014-07-01T20:43:19Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>new template for alignas_is_defined</comment>
      <text xml:space="preserve" bytes="105">{{dsc macro const | c/align/alignas_is_defined | expands to the integer constant 1 | notes={{mark c11}}}}</text>
      <sha1>6hfboy5fwyrbjdvhq60b0kp38s8sstq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/align/dsc alignof</title>
    <ns>10</ns>
    <id>13707</id>
    <revision>
      <id>72009</id>
      <parentid>71923</parentid>
      <timestamp>2014-07-08T13:02:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>&quot;query&quot; replaced with &quot;get&quot;</comment>
      <text xml:space="preserve" bytes="111">{{dsc macro fun | c/align/alignof | get the alignment requirement of a type or an object | notes={{mark c11}}}}</text>
      <sha1>5zt4d36t3lw8glogkxdx91n6g3mp4nl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/align/dsc alignof is defined</title>
    <ns>10</ns>
    <id>13709</id>
    <revision>
      <id>71920</id>
      <timestamp>2014-07-01T20:47:20Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>new template for alignof_is_defined</comment>
      <text xml:space="preserve" bytes="105">{{dsc macro const | c/align/alignof_is_defined | expands to the integer constant 1 | notes={{mark c11}}}}</text>
      <sha1>jmijj4eijjc9zff031h7qwlxd5qx74l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc ATOMIC FLAG INIT</title>
    <ns>10</ns>
    <id>9293</id>
    <revision>
      <id>53060</id>
      <parentid>51766</parentid>
      <timestamp>2013-06-01T04:58:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list ATOMIC FLAG INIT]] to [[Template:c/atomic/dsc ATOMIC FLAG INIT]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc macro const | c/atomic/ATOMIC_FLAG_INIT | initializes a new {{c|atomic_flag}} | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc ATOMIC LOCK FREE consts</title>
    <ns>10</ns>
    <id>9292</id>
    <revision>
      <id>53064</id>
      <parentid>51767</parentid>
      <timestamp>2013-06-01T04:58:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list ATOMIC LOCK FREE consts]] to [[Template:c/atomic/dsc ATOMIC LOCK FREE consts]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="397">{{dsc macro const | c/atomic/ATOMIC_LOCK_FREE_consts | title=ATOMIC_BOOL_LOCK_FREE&lt;br&gt;ATOMIC_CHAR_LOCK_FREE&lt;br&gt;ATOMIC_CHAR16_T_LOCK_FREE&lt;br&gt;ATOMIC_CHAR32_T_LOCK_FREE&lt;br&gt;ATOMIC_WCHAR_T_LOCK_FREE&lt;br&gt;ATOMIC_SHORT_LOCK_FREE&lt;br&gt;ATOMIC_INT_LOCK_FREE&lt;br&gt;ATOMIC_LONG_LOCK_FREE&lt;br&gt;ATOMIC_LLONG_LOCK_FREE&lt;br&gt;ATOMIC_POINTER_LOCK_FREE | indicates that the given atomic type is lock-free | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc ATOMIC VAR INIT</title>
    <ns>10</ns>
    <id>9294</id>
    <revision>
      <id>53067</id>
      <parentid>51768</parentid>
      <timestamp>2013-06-01T04:58:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list ATOMIC VAR INIT]] to [[Template:c/atomic/dsc ATOMIC VAR INIT]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc macro fun | c/atomic/ATOMIC_VAR_INIT | initializes a new atomic object | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic compare exchange</title>
    <ns>10</ns>
    <id>9284</id>
    <revision>
      <id>53070</id>
      <parentid>51769</parentid>
      <timestamp>2013-06-01T04:58:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic compare exchange]] to [[Template:c/atomic/dsc atomic compare exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="332">{{dsc fun | c/atomic/atomic_compare_exchange | title=atomic_compare_exchange_strong&lt;br&gt;atomic_compare_exchange_strong_explicit&lt;br&gt;atomic_compare_exchange_weak&lt;br&gt;atomic_compare_exchange_weak_explicit| swaps a value with the an atomic object if the old value is what is expected, otherwise reads the old value | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic exchange</title>
    <ns>10</ns>
    <id>9283</id>
    <revision>
      <id>53074</id>
      <parentid>51770</parentid>
      <timestamp>2013-06-01T04:58:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic exchange]] to [[Template:c/atomic/dsc atomic exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc fun | c/atomic/atomic_exchange | title=atomic_exchange&lt;br&gt;atomic_exchange_explicit| swaps a value with the value of an atomic object | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic fetch add</title>
    <ns>10</ns>
    <id>9285</id>
    <revision>
      <id>53077</id>
      <parentid>51771</parentid>
      <timestamp>2013-06-01T04:58:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic fetch add]] to [[Template:c/atomic/dsc atomic fetch add]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | c/atomic/atomic_fetch_add | title=atomic_fetch_add&lt;br&gt;atomic_fetch_add_explicit| atomic addition | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic fetch and</title>
    <ns>10</ns>
    <id>9289</id>
    <revision>
      <id>53080</id>
      <parentid>51772</parentid>
      <timestamp>2013-06-01T04:58:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic fetch and]] to [[Template:c/atomic/dsc atomic fetch and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | c/atomic/atomic_fetch_and | title=atomic_fetch_and&lt;br&gt;atomic_fetch_and_explicit| atomic logical AND | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic fetch or</title>
    <ns>10</ns>
    <id>9287</id>
    <revision>
      <id>53084</id>
      <parentid>51773</parentid>
      <timestamp>2013-06-01T04:58:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic fetch or]] to [[Template:c/atomic/dsc atomic fetch or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc fun | c/atomic/atomic_fetch_or | title=atomic_fetch_or&lt;br&gt;atomic_fetch_or_explicit| atomic logical OR | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic fetch sub</title>
    <ns>10</ns>
    <id>9286</id>
    <revision>
      <id>53087</id>
      <parentid>51774</parentid>
      <timestamp>2013-06-01T04:58:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic fetch sub]] to [[Template:c/atomic/dsc atomic fetch sub]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | c/atomic/atomic_fetch_sub | title=atomic_fetch_sub&lt;br&gt;atomic_fetch_sub_explicit| atomic subtraction | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic fetch xor</title>
    <ns>10</ns>
    <id>9288</id>
    <revision>
      <id>53091</id>
      <parentid>51775</parentid>
      <timestamp>2013-06-01T04:58:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic fetch xor]] to [[Template:c/atomic/dsc atomic fetch xor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | c/atomic/atomic_fetch_xor | title=atomic_fetch_xor&lt;br&gt;atomic_fetch_xor_explicit| atomic logical exclusive OR | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic flag</title>
    <ns>10</ns>
    <id>9297</id>
    <revision>
      <id>53094</id>
      <parentid>39141</parentid>
      <timestamp>2013-06-01T04:58:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic flag]] to [[Template:c/atomic/dsc atomic flag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dcl list struct | c/atomic/atomic_flag | lock-free atomic boolean flag | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic flag clear</title>
    <ns>10</ns>
    <id>9278</id>
    <revision>
      <id>53097</id>
      <parentid>51776</parentid>
      <timestamp>2013-06-01T04:58:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic flag clear]] to [[Template:c/atomic/dsc atomic flag clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc fun | c/atomic/atomic_flag_clear | title=atomic_flag_clear&lt;br&gt;atomic_flag_clear_explicit | sets an atomic_flag to false | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic flag test and set</title>
    <ns>10</ns>
    <id>9277</id>
    <revision>
      <id>53100</id>
      <parentid>51777</parentid>
      <timestamp>2013-06-01T04:58:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic flag test and set]] to [[Template:c/atomic/dsc atomic flag test and set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="195">{{dsc fun | c/atomic/atomic_flag_test_and_set | title=atomic_flag_test_and_set&lt;br&gt;atomic_flag_test_and_set_explicit | sets an atomic_flag to true and returns the old value | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic init</title>
    <ns>10</ns>
    <id>9279</id>
    <revision>
      <id>53104</id>
      <parentid>51778</parentid>
      <timestamp>2013-06-01T04:58:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic init]] to [[Template:c/atomic/dsc atomic init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | c/atomic/atomic_init | initializes an existing atomic object | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic is lock free</title>
    <ns>10</ns>
    <id>9280</id>
    <revision>
      <id>53107</id>
      <parentid>51779</parentid>
      <timestamp>2013-06-01T04:59:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic is lock free]] to [[Template:c/atomic/dsc atomic is lock free]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc fun | c/atomic/atomic_is_lock_free | indicates whether the atomic object is lock-free | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic load</title>
    <ns>10</ns>
    <id>9282</id>
    <revision>
      <id>53110</id>
      <parentid>51780</parentid>
      <timestamp>2013-06-01T04:59:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic load]] to [[Template:c/atomic/dsc atomic load]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc fun | c/atomic/atomic_load | title=atomic_load&lt;br&gt;atomic_load_explicit| reads a value from an atomic object | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic signal fence</title>
    <ns>10</ns>
    <id>9291</id>
    <revision>
      <id>53114</id>
      <parentid>51781</parentid>
      <timestamp>2013-06-01T04:59:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic signal fence]] to [[Template:c/atomic/dsc atomic signal fence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc fun | c/atomic/atomic_signal_fence | fence between a thread and a signal handler executed in the same thread | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic store</title>
    <ns>10</ns>
    <id>9281</id>
    <revision>
      <id>53117</id>
      <parentid>51782</parentid>
      <timestamp>2013-06-01T04:59:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic store]] to [[Template:c/atomic/dsc atomic store]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc fun | c/atomic/atomic_store | title=atomic_store&lt;br&gt;atomic_store_explicit| stores a value in an atomic object | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc atomic thread fence</title>
    <ns>10</ns>
    <id>9290</id>
    <revision>
      <id>53120</id>
      <parentid>51783</parentid>
      <timestamp>2013-06-01T04:59:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list atomic thread fence]] to [[Template:c/atomic/dsc atomic thread fence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc fun | c/atomic/atomic_thread_fence | generic memory order-dependent fence synchronization primitive  | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc kill dependency</title>
    <ns>10</ns>
    <id>9295</id>
    <revision>
      <id>53123</id>
      <parentid>51784</parentid>
      <timestamp>2013-06-01T04:59:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list kill dependency]] to [[Template:c/atomic/dsc kill dependency]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc macro fun | c/atomic/kill_dependency | breaks a dependency chain for {{c|memory_order_consume}} | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/dsc memory order</title>
    <ns>10</ns>
    <id>9296</id>
    <revision>
      <id>53127</id>
      <parentid>51785</parentid>
      <timestamp>2013-06-01T04:59:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/atomic/dcl list memory order]] to [[Template:c/atomic/dsc memory order]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc enum | c/atomic/memory_order | defines memory ordering constraints | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/navbar</title>
    <ns>10</ns>
    <id>6535</id>
    <revision>
      <id>39836</id>
      <parentid>35471</parentid>
      <timestamp>2012-09-28T19:55:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="143">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/atomic/navbar heading
|content2 = c/atomic/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/navbar content</title>
    <ns>10</ns>
    <id>9382</id>
    <revision>
      <id>51786</id>
      <parentid>39551</parentid>
      <timestamp>2013-06-01T04:34:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="913">{{nv begin}}
{{nv h2 | Types }}
{{nv ln | c/atomic/memory_order}}
{{nv ln | c/atomic/atomic_flag}}

{{nv h2 | Macros }}
{{nv ln | c/atomic/ATOMIC_LOCK_FREE_consts | ATOMIC_***_LOCK_FREE}}
{{nv ln | c/atomic/ATOMIC_FLAG_INIT}}
{{nv ln | c/atomic/ATOMIC_VAR_INIT}}
{{nv ln | c/atomic/kill_dependency}}

{{nv h2 | Functions }}
{{nv ln | c/atomic/atomic_flag_test_and_set}}
{{nv ln | c/atomic/atomic_flag_clear}}
{{nv ln | c/atomic/atomic_init}}
{{nv ln | c/atomic/atomic_is_lock_free}}
{{nv ln | c/atomic/atomic_store}}
{{nv ln | c/atomic/atomic_load}}
{{nv ln | c/atomic/atomic_exchange}}
{{nv ln | c/atomic/atomic_compare_exchange}}
{{nv ln | c/atomic/atomic_fetch_add}}
{{nv ln | c/atomic/atomic_fetch_sub}}
{{nv ln | c/atomic/atomic_fetch_or}}
{{nv ln | c/atomic/atomic_fetch_xor}}
{{nv ln | c/atomic/atomic_fetch_and}}
{{nv ln | c/atomic/atomic_thread_fence}}
{{nv ln | c/atomic/atomic_signal_fence}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/atomic/navbar heading</title>
    <ns>10</ns>
    <id>6536</id>
    <revision>
      <id>39081</id>
      <parentid>35472</parentid>
      <timestamp>2012-08-28T14:24:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="40">[[c/atomic | Atomic operations library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc CLOCKS PER SEC</title>
    <ns>10</ns>
    <id>5955</id>
    <revision>
      <id>53130</id>
      <parentid>51787</parentid>
      <timestamp>2013-06-01T04:59:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list CLOCKS PER SEC]] to [[Template:c/chrono/dsc CLOCKS PER SEC]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc macro const | c/chrono/CLOCKS_PER_SEC | number of processor clock ticks per second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc asctime</title>
    <ns>10</ns>
    <id>5962</id>
    <revision>
      <id>71359</id>
      <parentid>53133</parentid>
      <timestamp>2014-06-09T11:33:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected type of parameter</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/chrono/asctime | converts a {{tt|tm}} object to a textual representation}}</text>
      <sha1>scgr69inb6hwv2d8x9p5422fwea0zhv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc clock</title>
    <ns>10</ns>
    <id>5963</id>
    <revision>
      <id>53137</id>
      <parentid>51789</parentid>
      <timestamp>2013-06-01T04:59:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list clock]] to [[Template:c/chrono/dsc clock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/chrono/clock | returns raw processor clock time since the program is started}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc clock t</title>
    <ns>10</ns>
    <id>6161</id>
    <revision>
      <id>53140</id>
      <parentid>51790</parentid>
      <timestamp>2013-06-01T04:59:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list clock t]] to [[Template:c/chrono/dsc clock t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc typedef | c/chrono/clock_t | process running time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc ctime</title>
    <ns>10</ns>
    <id>5961</id>
    <revision>
      <id>63786</id>
      <parentid>53144</parentid>
      <timestamp>2013-07-25T08:48:21Z</timestamp>
      <contributor>
        <ip>89.146.25.74</ip>
      </contributor>
      <comment>Corrected the input typen of ctime</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | c/chrono/ctime | converts a {{tt|time_t}} object to a textual representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc difftime</title>
    <ns>10</ns>
    <id>5965</id>
    <revision>
      <id>53147</id>
      <parentid>51792</parentid>
      <timestamp>2013-06-01T04:59:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list difftime]] to [[Template:c/chrono/dsc difftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | c/chrono/difftime | computes the difference between times}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc gmtime</title>
    <ns>10</ns>
    <id>5958</id>
    <revision>
      <id>71521</id>
      <parentid>53150</parentid>
      <timestamp>2014-06-12T10:52:07Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>corrected name</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | c/chrono/gmtime | converts time since epoch to calendar time expressed as Coordinated Universal Time (UTC)}}</text>
      <sha1>6ix90rueoiikt9czyh95m2s941pt1ln</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc localtime</title>
    <ns>10</ns>
    <id>5957</id>
    <revision>
      <id>53154</id>
      <parentid>51794</parentid>
      <timestamp>2013-06-01T04:59:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list localtime]] to [[Template:c/chrono/dsc localtime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | c/chrono/localtime | converts time since epoch to calendar time expressed as local time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc mktime</title>
    <ns>10</ns>
    <id>5956</id>
    <revision>
      <id>53157</id>
      <parentid>51795</parentid>
      <timestamp>2013-06-01T04:59:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list mktime]] to [[Template:c/chrono/dsc mktime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | c/chrono/mktime | converts calendar time to time since epoch}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc strftime</title>
    <ns>10</ns>
    <id>5960</id>
    <revision>
      <id>53160</id>
      <parentid>51796</parentid>
      <timestamp>2013-06-01T04:59:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list strftime]] to [[Template:c/chrono/dsc strftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | c/chrono/strftime | converts a {{tt|tm}} object to custom textual representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc time</title>
    <ns>10</ns>
    <id>5964</id>
    <revision>
      <id>71566</id>
      <parentid>53164</parentid>
      <timestamp>2014-06-13T13:44:45Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted &quot;calendar&quot;</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | c/chrono/time | returns the current calendar time of the system as time since epoch}}</text>
      <sha1>540i5rcm6skrpqo0bh40ubxka5ptyod</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc time t</title>
    <ns>10</ns>
    <id>6160</id>
    <revision>
      <id>71567</id>
      <parentid>53167</parentid>
      <timestamp>2014-06-13T13:53:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted &quot;calendar&quot;</comment>
      <text xml:space="preserve" bytes="66">{{dsc typedef | c/chrono/time_t | calendar time since epoch type}}</text>
      <sha1>i3q72wwfkuxprpdbc6nuvmxtfg13anm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc timespec</title>
    <ns>10</ns>
    <id>13680</id>
    <revision>
      <id>71563</id>
      <parentid>71555</parentid>
      <timestamp>2014-06-13T13:03:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>align desc with C</comment>
      <text xml:space="preserve" bytes="95">{{dsc class | c/chrono/timespec | time in seconds and nanoseconds | notes={{mark since c11}} }}</text>
      <sha1>cylxiq2rw1l6ji3kjvp4yvfmkk866ti</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc timespec get</title>
    <ns>10</ns>
    <id>13681</id>
    <revision>
      <id>71556</id>
      <timestamp>2014-06-13T12:41:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/chrono/timespec_get | returns the calendar time based on a given time base | notes={{mark since c11}} }}</text>
      <sha1>l8xkqry1s64hdnvs267qb810aio27c5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc tm</title>
    <ns>10</ns>
    <id>6159</id>
    <revision>
      <id>53170</id>
      <parentid>51799</parentid>
      <timestamp>2013-06-01T04:59:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list tm]] to [[Template:c/chrono/dsc tm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">{{dsc class | c/chrono/tm | calendar time type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/dsc wcsftime</title>
    <ns>10</ns>
    <id>5959</id>
    <revision>
      <id>53173</id>
      <parentid>51800</parentid>
      <timestamp>2013-06-01T04:59:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/dcl list wcsftime]] to [[Template:c/chrono/dsc wcsftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/chrono/wcsftime | converts a tm object to custom wide string textual representation }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/navbar</title>
    <ns>10</ns>
    <id>6032</id>
    <revision>
      <id>39837</id>
      <parentid>35473</parentid>
      <timestamp>2012-09-28T19:55:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="142">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/chrono/navbar heading
|content2 = c/chrono/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/navbar content</title>
    <ns>10</ns>
    <id>6472</id>
    <revision>
      <id>71562</id>
      <parentid>51801</parentid>
      <timestamp>2014-06-13T13:01:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+timespec</comment>
      <text xml:space="preserve" bytes="658">{{nv begin}}
{{nv h1 | Functions}}
{{nv h2 | Time manipulation}}
{{nv ln | c/chrono/difftime}}
{{nv ln | c/chrono/time}}
{{nv ln | c/chrono/clock}}
{{nv ln | c/chrono/timespec_get | notes={{mark c11}}}}

{{nv h2 | Format conversions}}
{{nv ln | c/chrono/asctime}}
{{nv ln | c/chrono/ctime}}
{{nv ln | c/chrono/strftime}}
{{nv ln | c/chrono/wcsftime}}
{{nv ln | c/chrono/gmtime}}
{{nv ln | c/chrono/localtime}}
{{nv ln | c/chrono/mktime}}

{{nv h1 | Constants}}
{{nv ln | c/chrono/CLOCKS_PER_SEC}}

{{nv h1 | Types}}
{{nv ln | c/chrono/tm}}
{{nv ln | c/chrono/time_t}}
{{nv ln | c/chrono/clock_t}}
{{nv ln | c/chrono/timespec | notes={{mark c11}}}}
{{nv end}}</text>
      <sha1>n9m99vk5at9z0frkb6zin5u0wctomxm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/chrono/navbar heading</title>
    <ns>10</ns>
    <id>6035</id>
    <revision>
      <id>35338</id>
      <parentid>21351</parentid>
      <timestamp>2012-06-15T22:23:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/chrono/sidebar heading]] to [[Template:c/chrono/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="38">[[c/chrono | Date and time utilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/core</title>
    <ns>10</ns>
    <id>12774</id>
    <revision>
      <id>61673</id>
      <timestamp>2013-06-08T04:49:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="151">&lt;onlyinclude&gt;{{#tag:source|{{{code|{{{1}}}}}}|lang={{{lang|{{{2|{{get_lang}}}}}}}}|enclose=none}}&lt;/onlyinclude&gt;
{{documentation | Template:source/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/dsc assert</title>
    <ns>10</ns>
    <id>6400</id>
    <revision>
      <id>53177</id>
      <parentid>51802</parentid>
      <timestamp>2013-06-01T04:59:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/error/dcl list assert]] to [[Template:c/error/dsc assert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc macro fun | c/error/assert | aborts the program if the user-specified condition is not {{c|true}}. May be disabled for release builds}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/dsc errno</title>
    <ns>10</ns>
    <id>6402</id>
    <revision>
      <id>53180</id>
      <parentid>51803</parentid>
      <timestamp>2013-06-01T04:59:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/error/dcl list errno]] to [[Template:c/error/dsc errno]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc | {{dsc member | c/error/errno | errno }} | macro which expands to POSIX-compatible thread-local error number variable&lt;br/&gt;{{mark|macro variable}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/dsc errno macros</title>
    <ns>10</ns>
    <id>6401</id>
    <revision>
      <id>53183</id>
      <parentid>51804</parentid>
      <timestamp>2013-06-01T04:59:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/error/dcl list errno macros]] to [[Template:c/error/dsc errno macros]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc macro const | c/error/errno_macros | title=E2BIG, EACCES, ..., EXDEV | macros for standard POSIX-compatible error conditions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/navbar</title>
    <ns>10</ns>
    <id>6406</id>
    <revision>
      <id>39838</id>
      <parentid>35475</parentid>
      <timestamp>2012-09-28T19:55:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="140">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/error/navbar heading
|content2 = c/error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/navbar content</title>
    <ns>10</ns>
    <id>6408</id>
    <revision>
      <id>70418</id>
      <parentid>51805</parentid>
      <timestamp>2014-05-22T13:40:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+static_assert</comment>
      <text xml:space="preserve" bytes="226">{{nv begin}}
{{nv h2 | Error codes}}
{{nv | [[c/error/errno_macros | Error codes]] }}
{{nv ln | c/error/errno}}

{{nv h2 | Assertions}}
{{nv ln | c/error/assert}}
{{nv ln | c/error/static_assert|notes={{mark c11}}}}
{{nv end}}</text>
      <sha1>cu91jigtsx95upfzqq90heta0wfxhlt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/error/navbar heading</title>
    <ns>10</ns>
    <id>6407</id>
    <revision>
      <id>34620</id>
      <parentid>25464</parentid>
      <timestamp>2012-06-15T22:06:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/error/sidebar heading]] to [[Template:c/error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="28">[[c/error | Error handling]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc clearerr</title>
    <ns>10</ns>
    <id>5875</id>
    <revision>
      <id>53187</id>
      <parentid>51806</parentid>
      <timestamp>2013-06-01T04:59:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list clearerr]] to [[Template:c/io/dsc clearerr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">{{dsc fun | c/io/clearerr | clears errors}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fclose</title>
    <ns>10</ns>
    <id>5911</id>
    <revision>
      <id>53190</id>
      <parentid>51807</parentid>
      <timestamp>2013-06-01T04:59:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fclose]] to [[Template:c/io/dsc fclose]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="42">{{dsc fun | c/io/fclose | closes a file }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc feof</title>
    <ns>10</ns>
    <id>5874</id>
    <revision>
      <id>53194</id>
      <parentid>51808</parentid>
      <timestamp>2013-06-01T04:59:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list feof]] to [[Template:c/io/dsc feof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">{{dsc fun | c/io/feof | checks for the end-of-file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc ferror</title>
    <ns>10</ns>
    <id>5873</id>
    <revision>
      <id>53197</id>
      <parentid>51809</parentid>
      <timestamp>2013-06-01T04:59:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list ferror]] to [[Template:c/io/dsc ferror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">{{dsc fun |c/io/ferror | checks for a file error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fflush</title>
    <ns>10</ns>
    <id>5910</id>
    <revision>
      <id>53201</id>
      <parentid>51810</parentid>
      <timestamp>2013-06-01T04:59:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fflush]] to [[Template:c/io/dsc fflush]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | c/io/fflush | synchronizes an output stream with the actual file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fgetc</title>
    <ns>10</ns>
    <id>5904</id>
    <revision>
      <id>53204</id>
      <parentid>51811</parentid>
      <timestamp>2013-06-01T04:59:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fgetc]] to [[Template:c/io/dsc fgetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | c/io/fgetc | title=fgetc&lt;br&gt;getc | gets a character from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fgetpos</title>
    <ns>10</ns>
    <id>5879</id>
    <revision>
      <id>53207</id>
      <parentid>51812</parentid>
      <timestamp>2013-06-01T04:59:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fgetpos]] to [[Template:c/io/dsc fgetpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc fun | c/io/fgetpos | gets the file position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fgets</title>
    <ns>10</ns>
    <id>5903</id>
    <revision>
      <id>53210</id>
      <parentid>51813</parentid>
      <timestamp>2013-06-01T04:59:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fgets]] to [[Template:c/io/dsc fgets]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | c/io/fgets | gets a character string from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fgetwc</title>
    <ns>10</ns>
    <id>5895</id>
    <revision>
      <id>53214</id>
      <parentid>51814</parentid>
      <timestamp>2013-06-01T04:59:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fgetwc]] to [[Template:c/io/dsc fgetwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/io/fgetwc | title=fgetwc&lt;br&gt;getwc | gets a wide character from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fgetws</title>
    <ns>10</ns>
    <id>5894</id>
    <revision>
      <id>53217</id>
      <parentid>51815</parentid>
      <timestamp>2013-06-01T04:59:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fgetws]] to [[Template:c/io/dsc fgetws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/io/fgetws | gets a wide string from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fopen</title>
    <ns>10</ns>
    <id>5913</id>
    <revision>
      <id>53221</id>
      <parentid>51816</parentid>
      <timestamp>2013-06-01T04:59:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fopen]] to [[Template:c/io/dsc fopen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="40">{{dsc fun | c/io/fopen | opens a file }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fprintf</title>
    <ns>10</ns>
    <id>5886</id>
    <revision>
      <id>53224</id>
      <parentid>51817</parentid>
      <timestamp>2013-06-01T04:59:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fprintf]] to [[Template:c/io/dsc fprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="178">{{dsc fun | c/io/fprintf | title=printf&lt;br&gt;fprintf&lt;br&gt;sprintf&lt;br&gt;snprintf | prints formatted output to {{lc|stdout}}, a file stream or a buffer | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fputc</title>
    <ns>10</ns>
    <id>5902</id>
    <revision>
      <id>53228</id>
      <parentid>51818</parentid>
      <timestamp>2013-06-01T04:59:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fputc]] to [[Template:c/io/dsc fputc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | c/io/fputc | title=fputc&lt;br&gt;putc | writes a character to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fputs</title>
    <ns>10</ns>
    <id>5901</id>
    <revision>
      <id>53231</id>
      <parentid>51819</parentid>
      <timestamp>2013-06-01T04:59:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fputs]] to [[Template:c/io/dsc fputs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | c/io/fputs | writes a character string to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fputwc</title>
    <ns>10</ns>
    <id>5893</id>
    <revision>
      <id>53234</id>
      <parentid>51820</parentid>
      <timestamp>2013-06-01T04:59:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fputwc]] to [[Template:c/io/dsc fputwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/io/fputwc | title=fputwc&lt;br&gt;putwc | writes a wide character to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fputws</title>
    <ns>10</ns>
    <id>5892</id>
    <revision>
      <id>53238</id>
      <parentid>51821</parentid>
      <timestamp>2013-06-01T04:59:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fputws]] to [[Template:c/io/dsc fputws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/io/fputws | writes a wide string to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fread</title>
    <ns>10</ns>
    <id>5906</id>
    <revision>
      <id>53241</id>
      <parentid>51822</parentid>
      <timestamp>2013-06-01T04:59:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fread]] to [[Template:c/io/dsc fread]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">{{dsc fun | c/io/fread | reads from a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc freopen</title>
    <ns>10</ns>
    <id>5912</id>
    <revision>
      <id>53244</id>
      <parentid>51823</parentid>
      <timestamp>2013-06-01T04:59:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list freopen]] to [[Template:c/io/dsc freopen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | c/io/freopen | open an existing stream with a different name}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fscanf</title>
    <ns>10</ns>
    <id>5888</id>
    <revision>
      <id>53247</id>
      <parentid>51824</parentid>
      <timestamp>2013-06-01T05:00:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fscanf]] to [[Template:c/io/dsc fscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc fun | c/io/fscanf | title=scanf&lt;br&gt;fscanf&lt;br&gt;sscanf | reads formatted input from {{lc|stdin}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fseek</title>
    <ns>10</ns>
    <id>5878</id>
    <revision>
      <id>53251</id>
      <parentid>51825</parentid>
      <timestamp>2013-06-01T05:00:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fseek]] to [[Template:c/io/dsc fseek]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc fun | c/io/fseek | moves the file position indicator to a specific location in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fsetpos</title>
    <ns>10</ns>
    <id>5877</id>
    <revision>
      <id>53254</id>
      <parentid>51826</parentid>
      <timestamp>2013-06-01T05:00:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fsetpos]] to [[Template:c/io/dsc fsetpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc fun | c/io/fsetpos | moves the file position indicator to a specific location in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc ftell</title>
    <ns>10</ns>
    <id>5880</id>
    <revision>
      <id>53258</id>
      <parentid>51827</parentid>
      <timestamp>2013-06-01T05:00:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list ftell]] to [[Template:c/io/dsc ftell]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | c/io/ftell | returns the current file position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fwide</title>
    <ns>10</ns>
    <id>5909</id>
    <revision>
      <id>53261</id>
      <parentid>51828</parentid>
      <timestamp>2013-06-01T05:00:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fwide]] to [[Template:c/io/dsc fwide]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | c/io/fwide | switches a file stream between wide character I/O and narrow character I/O}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fwprintf</title>
    <ns>10</ns>
    <id>5882</id>
    <revision>
      <id>53264</id>
      <parentid>51829</parentid>
      <timestamp>2013-06-01T05:00:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fwprintf]] to [[Template:c/io/dsc fwprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc fun | c/io/fwprintf | title=wprintf&lt;br&gt;fwprintf&lt;br&gt;swprintf | prints formatted wide character output to {{lc|stdout}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fwrite</title>
    <ns>10</ns>
    <id>5905</id>
    <revision>
      <id>53268</id>
      <parentid>51830</parentid>
      <timestamp>2013-06-01T05:00:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fwrite]] to [[Template:c/io/dsc fwrite]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">{{dsc fun | c/io/fwrite | writes to a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc fwscanf</title>
    <ns>10</ns>
    <id>5884</id>
    <revision>
      <id>53271</id>
      <parentid>51831</parentid>
      <timestamp>2013-06-01T05:00:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list fwscanf]] to [[Template:c/io/dsc fwscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc fun | c/io/fwscanf | title=wscanf&lt;br&gt;fwscanf&lt;br&gt;swscanf | reads formatted wide character input from {{lc|stdin}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc getchar</title>
    <ns>10</ns>
    <id>5900</id>
    <revision>
      <id>53274</id>
      <parentid>51832</parentid>
      <timestamp>2013-06-01T05:00:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list getchar]] to [[Template:c/io/dsc getchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc fun | c/io/getchar | reads a character from {{lc|stdin}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc gets</title>
    <ns>10</ns>
    <id>5899</id>
    <revision>
      <id>71871</id>
      <parentid>53277</parentid>
      <timestamp>2014-06-30T12:47:23Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>mark until c11</comment>
      <text xml:space="preserve" bytes="93">{{dsc fun | c/io/gets | reads a character string from {{tt|stdin}}|notes={{mark until c11}}}}</text>
      <sha1>m9ttw1p79qgoi8u1ztsva4wjgwb4nt4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc getwchar</title>
    <ns>10</ns>
    <id>5891</id>
    <revision>
      <id>53281</id>
      <parentid>51834</parentid>
      <timestamp>2013-06-01T05:00:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list getwchar]] to [[Template:c/io/dsc getwchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | c/io/getwchar | reads a wide character from {{tt|stdin}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc perror</title>
    <ns>10</ns>
    <id>5872</id>
    <revision>
      <id>53284</id>
      <parentid>51835</parentid>
      <timestamp>2013-06-01T05:00:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list perror]] to [[Template:c/io/dsc perror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | c/io/perror | displays a character string corresponding of the current error to {{lc|stderr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc putchar</title>
    <ns>10</ns>
    <id>5898</id>
    <revision>
      <id>53287</id>
      <parentid>51836</parentid>
      <timestamp>2013-06-01T05:00:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list putchar]] to [[Template:c/io/dsc putchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/io/putchar |  writes a character to {{tt|stdout}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc puts</title>
    <ns>10</ns>
    <id>5897</id>
    <revision>
      <id>53291</id>
      <parentid>51837</parentid>
      <timestamp>2013-06-01T05:00:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list puts]] to [[Template:c/io/dsc puts]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | c/io/puts | writes a character string to {{lc|stdout}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc putwchar</title>
    <ns>10</ns>
    <id>5890</id>
    <revision>
      <id>53294</id>
      <parentid>51838</parentid>
      <timestamp>2013-06-01T05:00:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list putwchar]] to [[Template:c/io/dsc putwchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | c/io/putwchar | writes a wide character to {{lc|stdout}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc remove</title>
    <ns>10</ns>
    <id>5871</id>
    <revision>
      <id>53297</id>
      <parentid>51839</parentid>
      <timestamp>2013-06-01T05:00:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list remove]] to [[Template:c/io/dsc remove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="41">{{dsc fun | c/io/remove | erases a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc rename</title>
    <ns>10</ns>
    <id>5870</id>
    <revision>
      <id>53301</id>
      <parentid>51840</parentid>
      <timestamp>2013-06-01T05:00:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list rename]] to [[Template:c/io/dsc rename]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="42">{{dsc fun | c/io/rename | renames a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc rewind</title>
    <ns>10</ns>
    <id>5876</id>
    <revision>
      <id>53304</id>
      <parentid>51841</parentid>
      <timestamp>2013-06-01T05:00:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list rewind]] to [[Template:c/io/dsc rewind]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/io/rewind | moves the file position indicator to the beginning in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc setbuf</title>
    <ns>10</ns>
    <id>5908</id>
    <revision>
      <id>53307</id>
      <parentid>51842</parentid>
      <timestamp>2013-06-01T05:00:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list setbuf]] to [[Template:c/io/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc fun | c/io/setbuf | sets the buffer for a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc setvbuf</title>
    <ns>10</ns>
    <id>5907</id>
    <revision>
      <id>53310</id>
      <parentid>51843</parentid>
      <timestamp>2013-06-01T05:00:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list setvbuf]] to [[Template:c/io/dsc setvbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/io/setvbuf | sets the buffer and its size for a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc tmpfile</title>
    <ns>10</ns>
    <id>5869</id>
    <revision>
      <id>53314</id>
      <parentid>51844</parentid>
      <timestamp>2013-06-01T05:00:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list tmpfile]] to [[Template:c/io/dsc tmpfile]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc fun | c/io/tmpfile | returns a pointer to a temporary file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc tmpnam</title>
    <ns>10</ns>
    <id>5868</id>
    <revision>
      <id>53317</id>
      <parentid>51845</parentid>
      <timestamp>2013-06-01T05:00:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list tmpnam]] to [[Template:c/io/dsc tmpnam]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">{{dsc fun | c/io/tmpnam | returns a unique filename}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc ungetc</title>
    <ns>10</ns>
    <id>5896</id>
    <revision>
      <id>53320</id>
      <parentid>51846</parentid>
      <timestamp>2013-06-01T05:00:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list ungetc]] to [[Template:c/io/dsc ungetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | c/io/ungetc | puts a character back into a file stream }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc ungetwc</title>
    <ns>10</ns>
    <id>5889</id>
    <revision>
      <id>53324</id>
      <parentid>51847</parentid>
      <timestamp>2013-06-01T05:00:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list ungetwc]] to [[Template:c/io/dsc ungetwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/io/ungetwc | puts a wide character back into a file stream }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc vfprintf</title>
    <ns>10</ns>
    <id>5885</id>
    <revision>
      <id>53327</id>
      <parentid>51848</parentid>
      <timestamp>2013-06-01T05:00:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list vfprintf]] to [[Template:c/io/dsc vfprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="216">{{dsc fun | c/io/vfprintf | title=vprintf&lt;br&gt;vfprintf&lt;br&gt;vsprintf&lt;br&gt;vsnprintf | prints formatted output to {{lc|stdout}}, a file stream or a buffer&lt;br&gt; using variable argument list | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc vfscanf</title>
    <ns>10</ns>
    <id>5887</id>
    <revision>
      <id>53330</id>
      <parentid>51849</parentid>
      <timestamp>2013-06-01T05:00:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list vfscanf]] to [[Template:c/io/dsc vfscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="218">{{dsc fun | c/io/vfscanf | title=vscanf&lt;br&gt;vfscanf&lt;br&gt;vsscanf | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} | reads formatted input from {{lc|stdin}}, a file stream or a buffer&lt;br&gt; using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc vfwprintf</title>
    <ns>10</ns>
    <id>5881</id>
    <revision>
      <id>53334</id>
      <parentid>51850</parentid>
      <timestamp>2013-06-01T05:00:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list vfwprintf]] to [[Template:c/io/dsc vfwprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="189">{{dsc fun | c/io/vfwprintf | title=vwprintf&lt;br&gt;vfwprintf&lt;br&gt;vswprintf | prints formatted wide character output to {{lc|stdout}}, a file stream&lt;br&gt; or a buffer using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/dsc vfwscanf</title>
    <ns>10</ns>
    <id>5883</id>
    <revision>
      <id>53337</id>
      <parentid>51851</parentid>
      <timestamp>2013-06-01T05:00:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/dcl list vfwscanf]] to [[Template:c/io/dsc vfwscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="237">{{dsc fun | c/io/vfwscanf | title=vwscanf&lt;br&gt;vfwscanf&lt;br&gt;vswscanf | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} | reads formatted wide character input from {{lc|stdin}}, a file stream&lt;br&gt; or a buffer using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/file access flags</title>
    <ns>10</ns>
    <id>9893</id>
    <revision>
      <id>46543</id>
      <timestamp>2013-03-23T03:21:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>=</comment>
      <text xml:space="preserve" bytes="1177">{| class=&quot;wikitable&quot;
|-
! File access &lt;br&gt;mode string
! Meaning
! Explanation
! Action if file &lt;br&gt; already exists
! Action if file &lt;br&gt; does not exist
|-
| {{tt|&quot;r&quot;}}
| read
| Open a file for reading
| read from start
| failure to open
|-
| {{tt|&quot;w&quot;}}
| write
| Create a file for writing
| destroy contents
| create new
|-
| {{tt|&quot;a&quot;}}
| append
| Append to a file
| write to end
| create new
|-
| {{tt|&quot;r+&quot;}}
| read extended
| Open a file for read/write
| read from start
| error
|-
| {{tt|&quot;w+&quot;}}
| write extended
| Create a file for read/write
| destroy contents
| create new
|-
| {{tt|&quot;a+&quot;}}
| append extended
| Open a file for read/write
| write to end
| create new
|-
| colspan=&quot;5&quot; | File access mode flag {{tt|&quot;b&quot;}} can optionally be specified to open a file in binary mode. This flag has effect only on Windows systems. &lt;br&gt; On the append file access modes, data is written to the end of the file regardless of the current position of the file position indicator.
|-
| colspan=&quot;5&quot; | File access mode flag {{tt|&quot;x&quot;}} can optionally be appended to &quot;w&quot; or &quot;w+&quot; specifiers. This flag forces the function to fail if the file exists, instead of overwriting it. {{mark c11}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/navbar</title>
    <ns>10</ns>
    <id>5914</id>
    <revision>
      <id>39839</id>
      <parentid>36002</parentid>
      <timestamp>2012-09-28T19:55:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="134">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/io/navbar heading
|content2 = c/io/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/navbar content</title>
    <ns>10</ns>
    <id>6196</id>
    <revision>
      <id>51852</id>
      <parentid>35478</parentid>
      <timestamp>2013-06-01T04:35:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1967">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | File access}}
{{nv col begin}}
{{nv ln | c/io/fopen}}
{{nv ln | c/io/freopen}}
{{nv ln | c/io/fclose}}
{{nv ln | c/io/fflush}}
{{nv col next}}
{{nv ln | c/io/fwide}}
{{nv ln | c/io/setbuf}}
{{nv ln | c/io/setvbuf}}
{{nv col end}}

{{nv h2 | Direct input/output}}
{{nv ln | c/io/fread}}
{{nv ln | c/io/fwrite}}

{{nv h2 | Unformatted input/output}}
{{nv col begin}}
{{nv ln | c/io/fgetc}}
{{nv ln | c/io/fgets}}
{{nv ln | c/io/fputc}}
{{nv ln | c/io/fputs}}
{{nv ln | c/io/getchar}}
{{nv ln | c/io/gets}}
{{nv ln | c/io/putchar}}
{{nv ln | c/io/puts}}
{{nv ln | c/io/ungetc}}
{{nv col next}}
{{nv ln | c/io/fgetwc}}
{{nv ln | c/io/fgetws}}
{{nv ln | c/io/fputwc}}
{{nv ln | c/io/fputws}}
{{nv ln | c/io/getwchar}}
{{nv ln | c/io/putwchar}}
{{nv ln | c/io/ungetwc}}
{{nv col end}}

{{nv h2 | Formatted input/output}}
{{nv col begin}}
{{nv ln | c/io/fscanf | scanf | fscanf | sscanf}}
{{nv ln | c/io/vfscanf | vscanf | vfscanf | vsscanf | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}}}
{{nv ln | c/io/fprintf | printf | fprintf | sprintf | snprintf | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}
{{nv ln | c/io/vfprintf | vprintf | vfprintf | vsprintf | vsnprintf  | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}
{{nv col next}}
{{nv ln | c/io/fwscanf | wscanf | fwscanf | swscanf}}
{{nv ln | c/io/vfwscanf | vwscanf | vfwscanf | vswscanf | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}}}
{{nv ln | c/io/fwprintf | wprintf | fwprintf | swprintf}}
{{nv ln | c/io/vfwprintf | vwprintf | vfwprintf | vswprintf}}
{{nv col end}}

{{nv h2 | File positioning}}
{{nv ln | c/io/ftell}}
{{nv ln | c/io/fgetpos}}
{{nv ln | c/io/fseek}}
{{nv ln | c/io/fsetpos}}
{{nv ln | c/io/rewind}}

{{nv h2 | Error handling}}
{{nv ln | c/io/clearerr}}
{{nv ln | c/io/feof}}
{{nv ln | c/io/ferror}}
{{nv ln | c/io/perror}}

{{nv h2 | Operations on files}}
{{nv ln | c/io/remove}}
{{nv ln | c/io/rename}}
{{nv ln | c/io/tmpfile}}
{{nv ln | c/io/tmpnam}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/io/navbar heading</title>
    <ns>10</ns>
    <id>6153</id>
    <revision>
      <id>35480</id>
      <parentid>21480</parentid>
      <timestamp>2012-06-15T22:26:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/io/sidebar heading]] to [[Template:c/io/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="28">[[c/io | File input/output]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/keyword/navbar</title>
    <ns>10</ns>
    <id>6193</id>
    <revision>
      <id>39840</id>
      <parentid>35481</parentid>
      <timestamp>2012-09-28T19:55:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="144">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/keyword/navbar heading
|content2 = c/keyword/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/keyword/navbar content</title>
    <ns>10</ns>
    <id>6195</id>
    <revision>
      <id>51853</id>
      <parentid>41318</parentid>
      <timestamp>2013-06-01T04:35:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1385">{{nv begin}}
{{nv col begin}}
{{nv ln | c/keyword/auto}}
{{nv ln | c/keyword/break}}
{{nv ln | c/keyword/case}}
{{nv ln | c/keyword/char}}
{{nv ln | c/keyword/const}}
{{nv ln | c/keyword/continue}}
{{nv ln | c/keyword/default}}
{{nv ln | c/keyword/do}}
{{nv ln | c/keyword/double}}
{{nv ln | c/keyword/else}}
{{nv ln | c/keyword/enum}}
{{nv ln | c/keyword/extern}}
{{nv col next}}
{{nv ln | c/keyword/float}}
{{nv ln | c/keyword/for}}
{{nv ln | c/keyword/goto}}
{{nv ln | c/keyword/if}}
{{nv ln | c/keyword/inline}}
{{nv ln | c/keyword/int}}
{{nv ln | c/keyword/long}}
{{nv ln | c/keyword/register}}
{{nv ln | c/keyword/restrict}}
{{nv ln | c/keyword/return}}
{{nv ln | c/keyword/short}}
{{nv col next}}
{{nv ln | c/keyword/signed}}
{{nv ln | c/keyword/sizeof}}
{{nv ln | c/keyword/static}}
{{nv ln | c/keyword/struct}}
{{nv ln | c/keyword/switch}}
{{nv ln | c/keyword/typedef}}
{{nv ln | c/keyword/union}}
{{nv ln | c/keyword/unsigned}}
{{nv ln | c/keyword/void}}
{{nv ln | c/keyword/volatile}}
{{nv ln | c/keyword/while}}
{{nv col next}}
{{nv ln | c/keyword/_Alignas}}
{{nv ln | c/keyword/_Alignof}}
{{nv ln | c/keyword/_Atomic}}
{{nv ln | c/keyword/_Bool}}
{{nv ln | c/keyword/_Complex}}
{{nv ln | c/keyword/_Generic}}
{{nv ln | c/keyword/_Imaginary}}
{{nv ln | c/keyword/_Noreturn}}
{{nv ln | c/keyword/_Static_assert}}
{{nv ln | c/keyword/_Thread_local}}
{{nv col end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/keyword/navbar heading</title>
    <ns>10</ns>
    <id>6194</id>
    <revision>
      <id>35483</id>
      <parentid>21530</parentid>
      <timestamp>2012-06-15T22:26:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/keyword/sidebar heading]] to [[Template:c/keyword/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="26">[[c/keyword | C keywords]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/keyword/title</title>
    <ns>10</ns>
    <id>8588</id>
    <revision>
      <id>31762</id>
      <timestamp>2012-06-08T14:07:57Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="68">&lt;onlyinclude&gt;{{title | {{small|C keywords:}} {{{1}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/language/navbar</title>
    <ns>10</ns>
    <id>6318</id>
    <revision>
      <id>39841</id>
      <parentid>35484</parentid>
      <timestamp>2012-09-28T19:55:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="146">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/language/navbar heading
|content2 = c/language/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/language/navbar content</title>
    <ns>10</ns>
    <id>6550</id>
    <revision>
      <id>67831</id>
      <parentid>51854</parentid>
      <timestamp>2014-03-02T16:44:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-ascii</comment>
      <text xml:space="preserve" bytes="2702">{{nv begin}}
{{nv h1 | General topics}}
{{nv | [[c/preprocessor | Preprocessor]]}}
{{nv | [[c/comments | Comments]]}}
{{nv | [[c/keyword | Keywords]]}}
{{nv | [[c/language/escape | Escape sequences]]}}
{{nv | [[c/language/history | History of C]]}}

{{nv h1 | Flow control}}
{{nv h2 | Conditional execution statements}}
{{nv col begin}}
{{nv | [[c/language/if | {{tt|if}} statement]]}}
{{nv col next}}
{{nv | [[c/language/switch | {{tt|switch}} statement]]}}
{{nv col end}}

{{nv h2 | Iteration statements}}
{{nv col begin}}
{{nv | [[c/language/for | {{tt|for}} loop]]}}
{{nv col next}}
{{nv | [[c/language/while | {{tt|while}} loop]]}}
{{nv | [[c/language/do | {{tt|do-while}} loop]]}}
{{nv col end}}

{{nv h2 | Jump statements }}
{{nv col begin}}
{{nv | [[c/language/continue | {{tt|continue}} statement]]}}
{{nv | [[c/language/break | {{tt|break}} statement]]}}
{{nv col next}}
{{nv | [[c/language/goto | {{tt|goto}} statement]]}}
{{nv | [[c/language/return | {{tt|return}} statement]]}}
{{nv col end}}

{{nv h1 | Functions}}
{{nv | [[c/language/function | function declaration]]}}
{{nv | [[c/language/inline | inline specifier]]}}

{{nv h1 | Types}}
{{nv col begin}}
{{nv | [[c/language/types | fundamental types]]}}
{{nv | [[c/language/pointer | pointer types]]}}
{{nv | [[c/language/struct | compound types]]}}
{{nv | [[c/language/enum | enumeration types]]}}
{{nv col next}}
{{nv | [[c/language/union | union types]]}}
{{nv | [[c/language/function | function types]]}}
{{nv col end}}

{{nv h2 | Specifiers}}
{{nv | [[c/language/cv | cv specifiers]]}}
{{nv | [[c/language/storage_class_specifiers | storage-class specifiers]]}}
{{nv | [[c/language/alignas | alignas specifier]] {{mark c99}}}}
{{nv | [[c/language/function_specifiers | function specifiers]] {{mark c99}}}}

{{nv h2 | Literals}}
{{nv col begin}}
{{nv | [[c/language/integer_literal | integer literals]]}}
{{nv | [[c/language/character_literal | character literals]]}} 
{{nv | [[c/language/floating_literal | floating-point literals]]}}  
{{nv col next}}
{{nv | [[c/language/string_literal | string literals]]}}
{{nv | [[c/language/bool_literal| boolean literals]]{{mark c99}}}}
{{nv col end}}

{{nv h1 | Expressions}}
{{nv | [[c/language/eval_order | order of evaluation]]}}
{{nv | [[c/language/operators | operators]]}}
{{nv | [[c/language/operator_precedence | operator precedence]]}}
{{nv | [[c/language/operator_alternative | alternative operators]]}}

{{nv h1 | Utilities}}
{{nv | [[c/language/typedef | {{tt|typedef}} declaration]]}}
{{nv | [[c/language/attributes | attributes]] {{mark c99}}}}
{{nv | [[c/language/implicit_cast | casts]]}}

{{nv h1 | Miscellaneous }}
{{nv | [[c/language/asm | Inline assembly]]}}
{{nv end}}</text>
      <sha1>8epy6e6jzk3093v8h8sreldw9p5hvp4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/language/navbar heading</title>
    <ns>10</ns>
    <id>6319</id>
    <revision>
      <id>35254</id>
      <parentid>22199</parentid>
      <timestamp>2012-06-15T22:21:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/language/sidebar heading]] to [[Template:c/language/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="27">[[c/language | C language]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/language/operators</title>
    <ns>10</ns>
    <id>8465</id>
    <revision>
      <id>41451</id>
      <parentid>41450</parentid>
      <timestamp>2012-10-26T15:57:06Z</timestamp>
      <contributor>
        <username>OrangeBuzzard</username>
        <id>1124</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="894">{| class=&quot;wikitable&quot;
|- style=&quot;text-align:center&quot;
! colspan=&quot;7&quot; | Common operators 
|- style=&quot;text-align:center&quot;
| [[c/language/operator assignment | assignment]]
| [[c/language/operator incdec | increment&lt;br&gt;decrement]]
| [[c/language/operator arithmetic | arithmetic]]
| [[c/language/operator logical | logical]]
| [[c/language/operator comparison | comparison]]
| [[c/language/operator member access | member&lt;br&gt;access]]
| [[c/language/operator other | other]]
|- style=&quot;text-align:center&quot;
| 
{{c|1=a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &amp;= b
a {{!}}= b
a ^= b
a &lt;&lt;= b
a &gt;&gt;= b}}
| 
{{c|1=++a
--a
a++
a--
}}
| 
{{c|1=+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a &amp; b
a {{!}} b
a ^ b
a &lt;&lt; b
a &gt;&gt; b
}}
| 
{{c|1=!a
a &amp;&amp; b
a {{!!}} b
}}
| 
{{c|1=a == b
a != b
a &lt; b
a &gt; b
a &lt;= b
a &gt;= b
}}
| 
{{c|1=a[b]
*a
&amp;a
a-&gt;b
a.b
}}
| 
{{c|1=a(...)
a, b
(type) a
? :
sizeof
_Alignof}} {{mark since c11}}
|-
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/dsc LC categories</title>
    <ns>10</ns>
    <id>5928</id>
    <revision>
      <id>53340</id>
      <parentid>51855</parentid>
      <timestamp>2013-06-01T05:00:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/locale/dcl list LC categories]] to [[Template:c/locale/dsc LC categories]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc macro const | c/locale/LC_categories | title=LC_ALL&lt;br&gt;LC_COLLATE&lt;br&gt;LC_CTYPE&lt;br&gt;LC_MONETARY&lt;br&gt;LC_NUMERIC&lt;br&gt;LC_TIME | locale categories for {{c|setlocale}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/dsc lconv</title>
    <ns>10</ns>
    <id>5926</id>
    <revision>
      <id>53343</id>
      <parentid>51856</parentid>
      <timestamp>2013-06-01T05:00:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/locale/dcl list lconv]] to [[Template:c/locale/dsc lconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc class | c/locale/lconv | formatting details, returned by {{c|localeconv}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/dsc localeconv</title>
    <ns>10</ns>
    <id>5927</id>
    <revision>
      <id>53347</id>
      <parentid>51857</parentid>
      <timestamp>2013-06-01T05:00:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/locale/dcl list localeconv]] to [[Template:c/locale/dsc localeconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/locale/localeconv | queries numeric and monetary formatting details of the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/dsc setlocale</title>
    <ns>10</ns>
    <id>5925</id>
    <revision>
      <id>53350</id>
      <parentid>51858</parentid>
      <timestamp>2013-06-01T05:00:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/locale/dcl list setlocale]] to [[Template:c/locale/dsc setlocale]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | c/locale/setlocale | gets and sets the current C locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/navbar</title>
    <ns>10</ns>
    <id>5929</id>
    <revision>
      <id>39842</id>
      <parentid>35486</parentid>
      <timestamp>2012-09-28T19:55:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="142">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/locale/navbar heading
|content2 = c/locale/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/navbar content</title>
    <ns>10</ns>
    <id>6479</id>
    <revision>
      <id>51859</id>
      <parentid>33775</parentid>
      <timestamp>2013-06-01T04:35:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="248">{{nv begin}}
{{nv ln | c/locale/setlocale}}
{{nv ln | c/locale/localeconv}}
{{nv ln | c/locale/lconv}}
{{nv h2 | Locale categories}}
{{nv ln | c/locale/LC_categories | LC_ALL | LC_COLLATE | LC_CTYPE | LC_MONETARY | LC_NUMERIC | LC_TIME}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/locale/navbar heading</title>
    <ns>10</ns>
    <id>5930</id>
    <revision>
      <id>35487</id>
      <parentid>21240</parentid>
      <timestamp>2012-06-15T22:26:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/locale/sidebar heading]] to [[Template:c/locale/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="35">[[c/locale | Localization support]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/memory/navbar</title>
    <ns>10</ns>
    <id>5744</id>
    <revision>
      <id>39843</id>
      <parentid>36001</parentid>
      <timestamp>2012-09-28T19:55:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="142">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/memory/navbar heading
|content2 = c/memory/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/memory/navbar content</title>
    <ns>10</ns>
    <id>5747</id>
    <revision>
      <id>66070</id>
      <parentid>51860</parentid>
      <timestamp>2013-10-24T13:39:30Z</timestamp>
      <contributor>
        <username>Ruediger</username>
        <id>752</id>
      </contributor>
      <comment>aligned_alloc</comment>
      <text xml:space="preserve" bytes="189">{{nv begin}}
{{nv ln | c/memory/malloc}}
{{nv ln | c/memory/calloc}}
{{nv ln | c/memory/realloc}}
{{nv ln | c/memory/free}}
{{nv ln | c/memory/aligned_alloc |notes={{mark c11}}}}
{{nv end}}</text>
      <sha1>lfn59ofo40s10fynw07m5nxh9myaft6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/memory/navbar heading</title>
    <ns>10</ns>
    <id>5746</id>
    <revision>
      <id>35204</id>
      <parentid>21041</parentid>
      <timestamp>2012-06-15T22:19:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/memory/sidebar heading]] to [[Template:c/memory/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="40">[[c/memory | Dynamic memory management]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/navbar</title>
    <ns>10</ns>
    <id>6312</id>
    <revision>
      <id>39844</id>
      <parentid>35510</parentid>
      <timestamp>2012-09-28T19:55:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="69">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/navbar content</title>
    <ns>10</ns>
    <id>5753</id>
    <revision>
      <id>51861</id>
      <parentid>44741</parentid>
      <timestamp>2013-06-01T04:35:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="659">{{nv begin| style=line-height:1.1em;}}
{{nv | [[c/language | Language]] }}
{{nv | [[c/header | Standard Library]] }}
{{nv | [[c/types | Type support]] }}
{{nv | [[c/memory | Dynamic memory management]] }}
{{nv | [[c/error | Error handling]] }}
{{nv | [[c/program | Program utilities]] }}
{{nv | [[c/chrono | Date and time utilities]] }}
{{nv | [[c/string | Strings library]] }}
{{nv | [[c/algorithm | Algorithms]] }}
{{nv | [[c/numeric | Numerics]] }}
{{nv | [[c/io | Input/output support]] }}
{{nv | [[c/locale | Localization support]] }}
{{nv | [[c/thread | Thread support]] {{mark c11}} }}
{{nv | [[c/atomic | Atomic operations]] {{mark c11}} }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/navbar heading</title>
    <ns>10</ns>
    <id>5745</id>
    <revision>
      <id>35512</id>
      <parentid>32824</parentid>
      <timestamp>2012-06-15T22:27:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/sidebar heading]] to [[Template:c/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="9">[[c | C]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc CMPLX</title>
    <ns>10</ns>
    <id>9331</id>
    <revision>
      <id>53353</id>
      <parentid>51862</parentid>
      <timestamp>2013-06-01T05:00:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list CMPLX]] to [[Template:c/numeric/complex/dsc CMPLX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="190">{{dsc macro fun | c/numeric/complex/CMPLX | title=CMPLX&lt;br&gt;CMPLXF&lt;br&gt;CMPLXL | constructs a complex number from real and imaginary parts | notes={{mark c11}}&lt;br&gt;{{mark c11}}&lt;br&gt;{{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc Complex I</title>
    <ns>10</ns>
    <id>9327</id>
    <revision>
      <id>53357</id>
      <parentid>51863</parentid>
      <timestamp>2013-06-01T05:00:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list Complex I]] to [[Template:c/numeric/complex/dsc Complex I]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc macro const | c/numeric/complex/Complex_I | the complex unit constant i| notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc I</title>
    <ns>10</ns>
    <id>9330</id>
    <revision>
      <id>53360</id>
      <parentid>51864</parentid>
      <timestamp>2013-06-01T05:00:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list I]] to [[Template:c/numeric/complex/dsc I]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc macro const | c/numeric/complex/I  | the complex or imaginary unit constant i| notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc Imaginary I</title>
    <ns>10</ns>
    <id>9329</id>
    <revision>
      <id>53364</id>
      <parentid>51865</parentid>
      <timestamp>2013-06-01T05:00:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list Imaginary I]] to [[Template:c/numeric/complex/dsc Imaginary I]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc macro const | c/numeric/complex/Imaginary_I | the imaginary unit constant i| notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cabs</title>
    <ns>10</ns>
    <id>9346</id>
    <revision>
      <id>53367</id>
      <parentid>51866</parentid>
      <timestamp>2013-06-01T05:00:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cabs]] to [[Template:c/numeric/complex/dsc cabs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc fun | c/numeric/complex/cabs |title=cabs&lt;br&gt;cabsf&lt;br&gt;cabsl | computes the magnitude of a complex number | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cacos</title>
    <ns>10</ns>
    <id>9332</id>
    <revision>
      <id>53370</id>
      <parentid>51867</parentid>
      <timestamp>2013-06-01T05:00:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cacos]] to [[Template:c/numeric/complex/dsc cacos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc fun | c/numeric/complex/cacos |title=cacos&lt;br&gt;cacosf&lt;br&gt;cacosl | computes the complex arc cosine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cacosh</title>
    <ns>10</ns>
    <id>9338</id>
    <revision>
      <id>53372</id>
      <parentid>51868</parentid>
      <timestamp>2013-06-01T05:00:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cacosh]] to [[Template:c/numeric/complex/dsc cacosh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="172">{{dsc fun | c/numeric/complex/cacosh |title=cacosh&lt;br&gt;cacoshf&lt;br&gt;cacoshl | computes the complex arc hyperbolic cosine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc carg</title>
    <ns>10</ns>
    <id>9351</id>
    <revision>
      <id>53375</id>
      <parentid>51869</parentid>
      <timestamp>2013-06-01T05:00:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list carg]] to [[Template:c/numeric/complex/dsc carg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="169">{{dsc fun | c/numeric/complex/carg |title=carg&lt;br&gt;cargf&lt;br&gt;cargl | computes the phase angle of a complex number | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc casin</title>
    <ns>10</ns>
    <id>9333</id>
    <revision>
      <id>53378</id>
      <parentid>51870</parentid>
      <timestamp>2013-06-01T05:00:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list casin]] to [[Template:c/numeric/complex/dsc casin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc fun | c/numeric/complex/casin |title=casin&lt;br&gt;casinf&lt;br&gt;casinl | computes the complex arc sine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc casinh</title>
    <ns>10</ns>
    <id>9339</id>
    <revision>
      <id>53381</id>
      <parentid>51871</parentid>
      <timestamp>2013-06-01T05:01:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list casinh]] to [[Template:c/numeric/complex/dsc casinh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc fun | c/numeric/complex/casinh |title=casinh&lt;br&gt;casinhf&lt;br&gt;casinhl | computes the complex arc hyperbolic sine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc catan</title>
    <ns>10</ns>
    <id>9334</id>
    <revision>
      <id>53386</id>
      <parentid>51872</parentid>
      <timestamp>2013-06-01T05:01:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list catan]] to [[Template:c/numeric/complex/dsc catan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | c/numeric/complex/catan |title=catan&lt;br&gt;catanf&lt;br&gt;catanl | computes the complex arc tangent| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc catanh</title>
    <ns>10</ns>
    <id>9340</id>
    <revision>
      <id>53388</id>
      <parentid>51873</parentid>
      <timestamp>2013-06-01T05:01:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list catanh]] to [[Template:c/numeric/complex/dsc catanh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="173">{{dsc fun | c/numeric/complex/catanh |title=catanh&lt;br&gt;catanhf&lt;br&gt;catanhl | computes the complex arc hyperbolic tangent| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc ccos</title>
    <ns>10</ns>
    <id>9335</id>
    <revision>
      <id>53487</id>
      <parentid>51874</parentid>
      <timestamp>2013-06-01T05:02:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list ccos]] to [[Template:c/numeric/complex/dsc ccos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc fun | c/numeric/complex/ccos |title=ccos&lt;br&gt;ccosf&lt;br&gt;ccosl | computes the complex cosine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc ccosh</title>
    <ns>10</ns>
    <id>9341</id>
    <revision>
      <id>53490</id>
      <parentid>51875</parentid>
      <timestamp>2013-06-01T05:02:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list ccosh]] to [[Template:c/numeric/complex/dsc ccosh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc fun | c/numeric/complex/ccosh |title=ccosh&lt;br&gt;ccoshf&lt;br&gt;ccoshl | computes the complex hyperbolic cosine| notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cexp</title>
    <ns>10</ns>
    <id>9344</id>
    <revision>
      <id>53493</id>
      <parentid>51876</parentid>
      <timestamp>2013-06-01T05:02:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cexp]] to [[Template:c/numeric/complex/dsc cexp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc fun | c/numeric/complex/cexp |title=cexp&lt;br&gt;cexpf&lt;br&gt;cexpl | computes the complex base-e exponential| notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cimag</title>
    <ns>10</ns>
    <id>9349</id>
    <revision>
      <id>53497</id>
      <parentid>51877</parentid>
      <timestamp>2013-06-01T05:02:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cimag]] to [[Template:c/numeric/complex/dsc cimag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="173">{{dsc fun | c/numeric/complex/cimag |title=cimag&lt;br&gt;cimagf&lt;br&gt;cimagl | computes the imaginary part a complex number | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc clog</title>
    <ns>10</ns>
    <id>9345</id>
    <revision>
      <id>53500</id>
      <parentid>51878</parentid>
      <timestamp>2013-06-01T05:02:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list clog]] to [[Template:c/numeric/complex/dsc clog]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc fun | c/numeric/complex/clog |title=clog&lt;br&gt;clogf&lt;br&gt;clogl | computes the complex natural logarithm| notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc complex</title>
    <ns>10</ns>
    <id>9326</id>
    <revision>
      <id>53503</id>
      <parentid>51879</parentid>
      <timestamp>2013-06-01T05:02:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list complex]] to [[Template:c/numeric/complex/dsc complex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc macro const | c/numeric/complex/complex | complex type macro | notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc conj</title>
    <ns>10</ns>
    <id>9352</id>
    <revision>
      <id>53507</id>
      <parentid>51880</parentid>
      <timestamp>2013-06-01T05:02:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list conj]] to [[Template:c/numeric/complex/dsc conj]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc fun | c/numeric/complex/conj |title=conj&lt;br&gt;conjf&lt;br&gt;conjl | computes the complex conjugate | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cpow</title>
    <ns>10</ns>
    <id>9347</id>
    <revision>
      <id>53510</id>
      <parentid>51881</parentid>
      <timestamp>2013-06-01T05:03:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cpow]] to [[Template:c/numeric/complex/dsc cpow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc fun | c/numeric/complex/cpow |title=cpow&lt;br&gt;cpowf&lt;br&gt;cpowl | computes the complex power function | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc cproj</title>
    <ns>10</ns>
    <id>9353</id>
    <revision>
      <id>53513</id>
      <parentid>51882</parentid>
      <timestamp>2013-06-01T05:03:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list cproj]] to [[Template:c/numeric/complex/dsc cproj]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="168">{{dsc fun | c/numeric/complex/cproj |title=cproj&lt;br&gt;cprojf&lt;br&gt;cprojl | computes the projection on Riemann sphere | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc creal</title>
    <ns>10</ns>
    <id>9350</id>
    <revision>
      <id>53516</id>
      <parentid>51883</parentid>
      <timestamp>2013-06-01T05:03:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list creal]] to [[Template:c/numeric/complex/dsc creal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="171">{{dsc fun | c/numeric/complex/creal |title=creal&lt;br&gt;crealf&lt;br&gt;creall | computes the real part of a complex number | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc csin</title>
    <ns>10</ns>
    <id>9336</id>
    <revision>
      <id>53518</id>
      <parentid>51884</parentid>
      <timestamp>2013-06-01T05:03:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list csin]] to [[Template:c/numeric/complex/dsc csin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc fun | c/numeric/complex/csin |title=csin&lt;br&gt;csinf&lt;br&gt;csinl | computes the complex sine| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc csinh</title>
    <ns>10</ns>
    <id>9342</id>
    <revision>
      <id>53520</id>
      <parentid>51885</parentid>
      <timestamp>2013-06-01T05:03:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list csinh]] to [[Template:c/numeric/complex/dsc csinh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc fun | c/numeric/complex/csinh |title=csinh&lt;br&gt;csinhf&lt;br&gt;csinhl | computes the complex hyperbolic sine| notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc csqrt</title>
    <ns>10</ns>
    <id>9348</id>
    <revision>
      <id>53522</id>
      <parentid>51886</parentid>
      <timestamp>2013-06-01T05:03:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list csqrt]] to [[Template:c/numeric/complex/dsc csqrt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | c/numeric/complex/csqrt |title=csqrt&lt;br&gt;csqrtf&lt;br&gt;csqrtl | computes the complex square root | notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc ctan</title>
    <ns>10</ns>
    <id>9337</id>
    <revision>
      <id>53524</id>
      <parentid>51887</parentid>
      <timestamp>2013-06-01T05:03:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list ctan]] to [[Template:c/numeric/complex/dsc ctan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc fun | c/numeric/complex/ctan |title=ctan&lt;br&gt;ctanf&lt;br&gt;ctanl | computes the complex tangent| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc ctanh</title>
    <ns>10</ns>
    <id>9343</id>
    <revision>
      <id>53526</id>
      <parentid>51888</parentid>
      <timestamp>2013-06-01T05:03:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list ctanh]] to [[Template:c/numeric/complex/dsc ctanh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc fun | c/numeric/complex/ctanh |title=ctanh&lt;br&gt;ctanhf&lt;br&gt;ctanhl | computes the complex hyperbolic tangent| notes={{mark c99}}&lt;br/&gt;{{mark c99}}&lt;br/&gt;{{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/dsc imaginary</title>
    <ns>10</ns>
    <id>9328</id>
    <revision>
      <id>53528</id>
      <parentid>51889</parentid>
      <timestamp>2013-06-01T05:03:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/dcl list imaginary]] to [[Template:c/numeric/complex/dsc imaginary]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc macro const | c/numeric/complex/imaginary | imaginary type macro  | notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/navbar</title>
    <ns>10</ns>
    <id>6519</id>
    <revision>
      <id>39846</id>
      <parentid>35489</parentid>
      <timestamp>2012-09-28T19:56:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="235">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/numeric/navbar heading
|content2 = c/numeric/navbar content

|heading3 = c/numeric/complex/navbar heading
|content3 = c/numeric/complex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/navbar content</title>
    <ns>10</ns>
    <id>8492</id>
    <revision>
      <id>51890</id>
      <parentid>39549</parentid>
      <timestamp>2013-06-01T04:36:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1431">{{nv begin}}

{{nv h2 | Types and the imaginary constant}}
{{nv col begin}}
{{nv ln | c/numeric/complex/complex}}
{{nv ln | c/numeric/complex/Complex_I}}
{{nv ln | c/numeric/complex/CMPLX}}
{{nv col next}}
{{nv ln | c/numeric/complex/imaginary}}
{{nv ln | c/numeric/complex/Imaginary_I}}
{{nv ln | c/numeric/complex/I}}
{{nv col end}}

{{nv h2 | Manipulation}}
{{nv col begin}}
{{nv ln | c/numeric/complex/cimag}}
{{nv ln | c/numeric/complex/creal}}
{{nv ln | c/numeric/complex/carg}}
{{nv col next}}
{{nv ln | c/numeric/complex/conj}}
{{nv ln | c/numeric/complex/cproj}}
{{nv col end}}

{{nv h2 | Power and exponential functions}}
{{nv col begin}}
{{nv ln | c/numeric/complex/cexp}}
{{nv ln | c/numeric/complex/clog}}
{{nv col next}}
{{nv ln | c/numeric/complex/cpow}}
{{nv ln | c/numeric/complex/csqrt}}
{{nv col end}}

{{nv h2 | Trigonometric functions}}
{{nv col begin}}
{{nv ln | c/numeric/complex/ccos}}
{{nv ln | c/numeric/complex/csin}}
{{nv ln | c/numeric/complex/ctan}}
{{nv col next}}
{{nv ln | c/numeric/complex/cacos}}
{{nv ln | c/numeric/complex/casin}}
{{nv ln | c/numeric/complex/catan}}
{{nv col end}}

{{nv h2 | Hyperbolic functions}}
{{nv col begin}}
{{nv ln | c/numeric/complex/ccosh}}
{{nv ln | c/numeric/complex/csinh}}
{{nv ln | c/numeric/complex/ctanh}}
{{nv col next}}
{{nv ln | c/numeric/complex/cacosh}}
{{nv ln | c/numeric/complex/casinh}}
{{nv ln | c/numeric/complex/catanh}}
{{nv col end}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/complex/navbar heading</title>
    <ns>10</ns>
    <id>6520</id>
    <revision>
      <id>35314</id>
      <parentid>25696</parentid>
      <timestamp>2012-06-15T22:22:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/complex/sidebar heading]] to [[Template:c/numeric/complex/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="49">[[c/numeric/complex | Complex number arithmetic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc FE DFL ENV</title>
    <ns>10</ns>
    <id>8609</id>
    <revision>
      <id>53531</id>
      <parentid>51891</parentid>
      <timestamp>2013-06-01T05:03:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list FE DFL ENV]] to [[Template:c/numeric/fenv/dsc FE DFL ENV]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc macro const | c/numeric/fenv/FE_DFL_ENV | default floating-point environment|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc FE exceptions</title>
    <ns>10</ns>
    <id>8607</id>
    <revision>
      <id>53534</id>
      <parentid>51892</parentid>
      <timestamp>2013-06-01T05:03:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list FE exceptions]] to [[Template:c/numeric/fenv/dsc FE exceptions]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="196">{{dsc macro const | c/numeric/fenv/FE_exceptions | title=FE_ALL_EXCEPT&lt;br&gt;FE_DIVBYZERO&lt;br&gt;FE_INEXACT&lt;br&gt;FE_INVALID&lt;br&gt;FE_OVERFLOW&lt;br&gt;FE_UNDERFLOW | floating-point exceptions | notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc FE round</title>
    <ns>10</ns>
    <id>8608</id>
    <revision>
      <id>53538</id>
      <parentid>51893</parentid>
      <timestamp>2013-06-01T05:03:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list FE round]] to [[Template:c/numeric/fenv/dsc FE round]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc macro const | c/numeric/fenv/FE_round | title=FE_DOWNWARD&lt;br&gt;FE_TONEAREST&lt;br&gt;FE_TOWARDZERO&lt;br&gt;FE_UPWARD | floating-point rounding direction|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feclearexcept</title>
    <ns>10</ns>
    <id>8599</id>
    <revision>
      <id>53541</id>
      <parentid>51894</parentid>
      <timestamp>2013-06-01T05:03:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feclearexcept]] to [[Template:c/numeric/fenv/dsc feclearexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | c/numeric/fenv/feclearexcept | clears the specified floating-point status flags|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feenv</title>
    <ns>10</ns>
    <id>8604</id>
    <revision>
      <id>53544</id>
      <parentid>51895</parentid>
      <timestamp>2013-06-01T05:03:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feenv]] to [[Template:c/numeric/fenv/dsc feenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc fun | c/numeric/fenv/feenv | title=fegetenv&lt;br&gt;fesetenv |  saves or restores the current floating point environment|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feexceptflag</title>
    <ns>10</ns>
    <id>8602</id>
    <revision>
      <id>53547</id>
      <parentid>51896</parentid>
      <timestamp>2013-06-01T05:03:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feexceptflag]] to [[Template:c/numeric/fenv/dsc feexceptflag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="223">{{dsc fun | c/numeric/fenv/feexceptflag | title=fegetexceptflag&lt;br&gt;fesetexceptflag|copies the state of the specified floating-point status flags from or to the floating-point environment|notes={{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feholdexcept</title>
    <ns>10</ns>
    <id>8605</id>
    <revision>
      <id>53551</id>
      <parentid>51897</parentid>
      <timestamp>2013-06-01T05:03:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feholdexcept]] to [[Template:c/numeric/fenv/dsc feholdexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc fun | c/numeric/fenv/feholdexcept | saves the environment, clears all status flags and ignores all future errors|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feraiseexcept</title>
    <ns>10</ns>
    <id>8601</id>
    <revision>
      <id>53607</id>
      <parentid>51898</parentid>
      <timestamp>2013-06-01T05:04:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feraiseexcept]] to [[Template:c/numeric/fenv/dsc feraiseexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | c/numeric/fenv/feraiseexcept | raises the specified floating-point exceptions|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feround</title>
    <ns>10</ns>
    <id>8603</id>
    <revision>
      <id>53610</id>
      <parentid>51899</parentid>
      <timestamp>2013-06-01T05:04:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feround]] to [[Template:c/numeric/fenv/dsc feround]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc fun | c/numeric/fenv/feround | title=fegetround&lt;br&gt;fesetround | gets or sets rounding  direction | notes={{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc fetestexcept</title>
    <ns>10</ns>
    <id>8600</id>
    <revision>
      <id>53614</id>
      <parentid>51900</parentid>
      <timestamp>2013-06-01T05:04:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list fetestexcept]] to [[Template:c/numeric/fenv/dsc fetestexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | c/numeric/fenv/fetestexcept | determines which of the specified floating-point status flags are set|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/dsc feupdateenv</title>
    <ns>10</ns>
    <id>8606</id>
    <revision>
      <id>53617</id>
      <parentid>51901</parentid>
      <timestamp>2013-06-01T05:04:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/dcl list feupdateenv]] to [[Template:c/numeric/fenv/dsc feupdateenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | c/numeric/fenv/feupdateenv | restores the floating-point environment and raises the previously raise exceptions|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/navbar</title>
    <ns>10</ns>
    <id>6521</id>
    <revision>
      <id>39847</id>
      <parentid>35491</parentid>
      <timestamp>2012-09-28T19:56:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/numeric/navbar heading
|content2 = c/numeric/navbar content

|heading3 = c/numeric/fenv/navbar heading
|content3 = c/numeric/fenv/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/navbar content</title>
    <ns>10</ns>
    <id>8682</id>
    <revision>
      <id>51902</id>
      <parentid>36559</parentid>
      <timestamp>2013-06-01T04:36:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="987">{{nv begin}}
{{nv h1 | Functions}}
{{nv ln | c/numeric/fenv/feclearexcept | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/fetestexcept | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/feraiseexcept | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/feexceptflag | fegetexceptflag | fesetexceptflag | notes={{mark c99}}&lt;br&gt;{{mark c99}}}}
{{nv ln | c/numeric/fenv/feround | fegetround | fesetround | notes={{mark c99}}&lt;br&gt;{{mark c99}}}}
{{nv ln | c/numeric/fenv/feenv | fegetenv | fesetenv | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/feholdexcept | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/feupdateenv | notes={{mark c99}}}}

{{nv h1 | Macro constants}}
{{nv ln | c/numeric/fenv/FE_exceptions | FE_ALL_EXCEPT| FE_DIVBYZERO | FE_INEXACT | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/FE_round | FE_DOWNWARD | FE_TONEAREST | FE_TOWARDZERO | FE_UPWARD | notes={{mark c99}}}}
{{nv ln | c/numeric/fenv/FE_DFL_ENV | notes={{mark c99}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/fenv/navbar heading</title>
    <ns>10</ns>
    <id>6522</id>
    <revision>
      <id>35492</id>
      <parentid>25700</parentid>
      <timestamp>2012-06-15T22:26:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/fenv/sidebar heading]] to [[Template:c/numeric/fenv/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="47">[[c/numeric/fenv | Floating point environment]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc FP categories</title>
    <ns>10</ns>
    <id>6029</id>
    <revision>
      <id>71606</id>
      <parentid>53620</parentid>
      <timestamp>2014-06-15T02:14:06Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>FP_INFINITY ==&gt; FP_INFINITE</comment>
      <text xml:space="preserve" bytes="243">{{dsc macro const | c/numeric/math/FP_categories | title=FP_NORMAL&lt;br&gt;FP_SUBNORMAL&lt;br&gt;FP_ZERO&lt;br&gt;FP_INFINITE&lt;br&gt;FP_NAN | indicates a floating-point category | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1>io31nyb5es8ingbjwic2lqgozc304al</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc HUGE VAL</title>
    <ns>10</ns>
    <id>6030</id>
    <revision>
      <id>53624</id>
      <parentid>51904</parentid>
      <timestamp>2013-06-01T05:04:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list HUGE VAL]] to [[Template:c/numeric/math/dsc HUGE VAL]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="251">{{dsc macro const | c/numeric/math/HUGE_VAL | title=HUGE_VALF&lt;br&gt;HUGE_VAL&lt;br&gt;HUGE_VALL | indicates value too big to be representable (infinity) by {{c|float}}, {{c|double}} and {{c|long double}} respectively  | notes={{mark c99}}&lt;br&gt;&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc INFINITY</title>
    <ns>10</ns>
    <id>13549</id>
    <revision>
      <id>70463</id>
      <timestamp>2014-05-23T22:14:41Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>+ INFINITY (C99) template</comment>
      <text xml:space="preserve" bytes="149">{{dsc macro const | c/numeric/math/INFINITY | evaluates to positive infinity or the value guaranteed to overflow a {{c|float}}| notes={{mark c99}} }}</text>
      <sha1>5hzvv54c6b13b7kurtua1mj9plinee5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc NAN</title>
    <ns>10</ns>
    <id>13550</id>
    <revision>
      <id>70464</id>
      <timestamp>2014-05-23T22:16:22Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>+ NAN (C99) template</comment>
      <text xml:space="preserve" bytes="109">{{dsc macro const | c/numeric/math/NAN | evaluates to a quiet NaN of type {{c|float}} | notes={{mark c99}} }}</text>
      <sha1>plt9p6mibvgrr5turj29n88d2xv7k74</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc abs</title>
    <ns>10</ns>
    <id>6001</id>
    <revision>
      <id>71914</id>
      <parentid>71912</parentid>
      <timestamp>2014-07-01T19:32:02Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>mark c99 for llabs</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | c/numeric/math/abs | title=abs&lt;br&gt;labs&lt;br&gt;llabs | computes absolute value of an integral value ({{math|{{!}}x{{!}}}}) | notes=&lt;br&gt;&lt;br&gt;{{mark c99}} }}</text>
      <sha1>n5jnv2co7gjlve7f72o7i9rqoxbr61w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc acos</title>
    <ns>10</ns>
    <id>5975</id>
    <revision>
      <id>70726</id>
      <parentid>53630</parentid>
      <timestamp>2014-05-29T13:37:03Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="149">{{dsc fun | c/numeric/math/acos | title=acos&lt;br&gt;acosf&lt;br&gt;acosl | computes arc cosine ({{math|arccos(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>bn9e4bmo4ix05dt8m5jg9htbck3uds0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc acosh</title>
    <ns>10</ns>
    <id>6026</id>
    <revision>
      <id>70733</id>
      <parentid>70599</parentid>
      <timestamp>2014-05-29T15:00:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>inserted C99</comment>
      <text xml:space="preserve" bytes="180">{{dsc fun | c/numeric/math/acosh | title=acosh&lt;br&gt;acoshf&lt;br&gt;acoshl | computes inverse hyperbolic cosine ({{math|arcosh(x)}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>6q2ghvf48ggmv6f22gsnmwvq7g0nkvq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc asin</title>
    <ns>10</ns>
    <id>5976</id>
    <revision>
      <id>70725</id>
      <parentid>53637</parentid>
      <timestamp>2014-05-29T13:35:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="147">{{dsc fun | c/numeric/math/asin | title=asin&lt;br&gt;asinf&lt;br&gt;asinl | computes arc sine ({{math|arcsin(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>rbtv4n9q20gnc7wsgao6rh0av1numje</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc asinh</title>
    <ns>10</ns>
    <id>6028</id>
    <revision>
      <id>70734</id>
      <parentid>70732</parentid>
      <timestamp>2014-05-29T15:01:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>deleted &quot;the&quot;</comment>
      <text xml:space="preserve" bytes="175">{{dsc fun | c/numeric/math/asinh |title=asinh&lt;br&gt;asinhf&lt;br&gt;asinhl |computes inverse hyperbolic sine ({{math|arsinh(x)}})| notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>cff6d9q14ip7tibtflbbh1xxc3mcgbf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc atan</title>
    <ns>10</ns>
    <id>5974</id>
    <revision>
      <id>70727</id>
      <parentid>53644</parentid>
      <timestamp>2014-05-29T13:38:58Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="149">{{dsc fun | c/numeric/math/atan | title=atan&lt;br&gt;atanf&lt;br&gt;atanl |computes arc tangent ({{math|arctan(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>qzfxk609n8wll1496bqbytqb39zhayh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc atan2</title>
    <ns>10</ns>
    <id>5973</id>
    <revision>
      <id>70728</id>
      <parentid>53647</parentid>
      <timestamp>2014-05-29T13:42:24Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="169">{{dsc fun | c/numeric/math/atan2 | title=atan2&lt;br&gt;atan2f&lt;br&gt;atan2l | computes arc tangent, using signs to determine quadrants | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>qkyqu83fbn0jnagqadanaw3ha8yz85b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc atanh</title>
    <ns>10</ns>
    <id>6025</id>
    <revision>
      <id>70735</id>
      <parentid>70600</parentid>
      <timestamp>2014-05-29T15:03:46Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted C99</comment>
      <text xml:space="preserve" bytes="181">{{dsc fun | c/numeric/math/atanh | title=atanh&lt;br&gt;atanhf&lt;br&gt;atanhl | computes inverse hyperbolic tangent ({{math|artanh(x)}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>p528d04deu5jgb2aa9fmlkkkez5avp4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc cbrt</title>
    <ns>10</ns>
    <id>5983</id>
    <revision>
      <id>70720</id>
      <parentid>53654</parentid>
      <timestamp>2014-05-29T13:17:42Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="165">{{dsc fun | c/numeric/math/cbrt | title=cbrt&lt;br&gt;cbrtf&lt;br&gt;cbrtl | computes cubic root  ({{math|{{mrad|x|3}}}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>5oz69m1l1qwlcmrzpvjzahivqne3con</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc ceil</title>
    <ns>10</ns>
    <id>6020</id>
    <revision>
      <id>70748</id>
      <parentid>53657</parentid>
      <timestamp>2014-05-29T20:18:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb; corrected explanation</comment>
      <text xml:space="preserve" bytes="164">{{dsc fun | c/numeric/math/ceil | title=ceil&lt;br&gt;ceilf&lt;br&gt;ceill | computes smallest integer not less than the given value | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>94i0g8ljdh0jqln0cnhn5ysvufzb9fl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc copysign</title>
    <ns>10</ns>
    <id>6008</id>
    <revision>
      <id>70761</id>
      <parentid>53660</parentid>
      <timestamp>2014-05-29T21:17:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; used clause found in 7.12.11.1 of n1570</comment>
      <text xml:space="preserve" bytes="225">{{dsc fun | c/numeric/math/copysign | title=copysign&lt;br&gt;copysignf&lt;br&gt;copysignl | produces a value with the magnitude of a given value and the sign of another given value | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>a3osy7unyvw65ipdhsvn0f6vga68b0i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc cos</title>
    <ns>10</ns>
    <id>5979</id>
    <revision>
      <id>70723</id>
      <parentid>53664</parentid>
      <timestamp>2014-05-29T13:30:07Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="138">{{dsc fun | c/numeric/math/cos | title=cos&lt;br&gt;cosf&lt;br&gt;cosl | computes cosine ({{math|cos(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>ssim214pftultbra5ljacli7u5opko3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc cosh</title>
    <ns>10</ns>
    <id>5971</id>
    <revision>
      <id>70730</id>
      <parentid>53667</parentid>
      <timestamp>2014-05-29T14:47:22Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="152">{{dsc fun | c/numeric/math/cosh | title=cosh&lt;br&gt;coshf&lt;br&gt;coshl | computes hyperbolic cosine ({{math|ch(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>agw07gkpp9yuzfrq216d0p5tvc3cm0p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc div</title>
    <ns>10</ns>
    <id>5999</id>
    <revision>
      <id>71915</id>
      <parentid>71913</parentid>
      <timestamp>2014-07-01T19:33:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>mark c99 for lldiv</comment>
      <text xml:space="preserve" bytes="145">{{dsc fun | c/numeric/math/div | title=div&lt;br&gt;ldiv&lt;br&gt;lldiv | computes quotient and remainder of integer division | notes=&lt;br&gt;&lt;br&gt;{{mark c99}} }}</text>
      <sha1>7g3p1d0f4k78d547whccvr26w2j8gdo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc div t</title>
    <ns>10</ns>
    <id>13637</id>
    <revision>
      <id>71478</id>
      <parentid>71364</parentid>
      <timestamp>2014-06-11T20:08:22Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link to div</comment>
      <text xml:space="preserve" bytes="101">{{dsc typedef | c/numeric/math/div | title=div_t | structure type, return of the {{c|div}} function}}</text>
      <sha1>8mb81d6s29r0z33ejwcwxjvh2p3b3g7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc double t</title>
    <ns>10</ns>
    <id>13634</id>
    <revision>
      <id>71484</id>
      <parentid>71360</parentid>
      <timestamp>2014-06-11T20:15:50Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>nolink</comment>
      <text xml:space="preserve" bytes="132">{{dsc typedef | nolink=true | double_t | most efficient floating-point type at least as wide as {{c|double}} | notes={{mark c99}} }}</text>
      <sha1>3bjf8m6j6idxyde7s4l1vuw4cencomw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc erf</title>
    <ns>10</ns>
    <id>6024</id>
    <revision>
      <id>70737</id>
      <parentid>53674</parentid>
      <timestamp>2014-05-29T19:41:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb</comment>
      <text xml:space="preserve" bytes="139">{{dsc fun |c/numeric/math/erf | title=erf&lt;br&gt;erff&lt;br&gt;erfl | computes error function | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>0rsj3qrr81g9rq0o9cdyn2ro57etpue</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc erfc</title>
    <ns>10</ns>
    <id>6023</id>
    <revision>
      <id>70738</id>
      <parentid>53677</parentid>
      <timestamp>2014-05-29T19:44:30Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | c/numeric/math/erfc | title=erfc&lt;br&gt;erfcf&lt;br&gt;erfcl | computes complementary error function | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>q1elx6rckly2zeiozfhvb3lgdddhkfs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc exp</title>
    <ns>10</ns>
    <id>5991</id>
    <revision>
      <id>70707</id>
      <parentid>53680</parentid>
      <timestamp>2014-05-29T12:01:44Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="170">{{dsc fun | c/numeric/math/exp | title=exp&lt;br&gt;expf&lt;br&gt;expl | computes ''e'' raised to the given power ({{math|e&lt;sup&gt;x&lt;/sup&gt;}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>6uodpz1hswes6l13rvleeepx2vl3xig</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc exp2</title>
    <ns>10</ns>
    <id>5990</id>
    <revision>
      <id>70708</id>
      <parentid>53684</parentid>
      <timestamp>2014-05-29T12:07:54Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="186">{{dsc fun | c/numeric/math/exp2 | title=exp2&lt;br&gt;exp2f&lt;br&gt;exp2l | computes ''2'' raised to the given power ({{math|2&lt;sup&gt;x&lt;/sup&gt;}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>ezh77td6k877fgqacb22j3zr0yytkrf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc expm1</title>
    <ns>10</ns>
    <id>5989</id>
    <revision>
      <id>70709</id>
      <parentid>53687</parentid>
      <timestamp>2014-05-29T12:12:05Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="203">{{dsc fun | c/numeric/math/expm1 | title=expm1&lt;br&gt;expm1f&lt;br&gt;expm1l | computes ''e'' raised to the given power, minus one ({{math|e&lt;sup&gt;x&lt;/sup&gt;-1}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>4xd6g0oqle4l6igvutfvtzlpiuwqvtm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fabs</title>
    <ns>10</ns>
    <id>6000</id>
    <revision>
      <id>70789</id>
      <parentid>70675</parentid>
      <timestamp>2014-05-30T10:59:23Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="179">{{dsc fun | c/numeric/math/fabs | title=fabs&lt;br&gt;fabsf&lt;br&gt;fabsl | computes absolute value of a floating-point value ({{math|{{!}}x{{!}}}})|notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>gtqop1duplycuot336zmhgcror2burl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fdim</title>
    <ns>10</ns>
    <id>5993</id>
    <revision>
      <id>70794</id>
      <parentid>70706</parentid>
      <timestamp>2014-05-30T11:05:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="203">{{dsc fun | c/numeric/math/fdim | title=fdim&lt;br&gt;fdimf&lt;br&gt;fdiml | determines positive difference of two floating-point values ({{math|max(0, x-y)}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>hd6qs9vtqmgzuor7zg3h8f66n98bdjj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc float t</title>
    <ns>10</ns>
    <id>13580</id>
    <revision>
      <id>71483</id>
      <parentid>71482</parentid>
      <timestamp>2014-06-11T20:15:17Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="130">{{dsc typedef | nolink=true | float_t | most efficient floating-point type at least as wide as {{c|float}} | notes={{mark c99}} }}</text>
      <sha1>q5cii0387wuqma6xdz97s9u5qsmr9az</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc floor</title>
    <ns>10</ns>
    <id>6027</id>
    <revision>
      <id>70750</id>
      <parentid>53697</parentid>
      <timestamp>2014-05-29T20:21:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb; corrected explanation</comment>
      <text xml:space="preserve" bytes="170">{{dsc fun | c/numeric/math/floor | title=floor&lt;br&gt;floorf&lt;br&gt;floorl | computes largest integer not greater than the given value | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>cajvm2nlq8v6zilvw6oo97a0byq8r6h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fma</title>
    <ns>10</ns>
    <id>5995</id>
    <revision>
      <id>70699</id>
      <parentid>53701</parentid>
      <timestamp>2014-05-29T01:22:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="154">{{dsc fun | c/numeric/math/fma | title=fma&lt;br&gt;fmaf&lt;br&gt;fmal | computes fused multiply-add operation | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>1x7qcos7ux99uxdodjvyjhvg2lyrdrl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fmax</title>
    <ns>10</ns>
    <id>5994</id>
    <revision>
      <id>70792</id>
      <parentid>70704</parentid>
      <timestamp>2014-05-30T11:02:19Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="167">{{dsc fun | c/numeric/math/fmax | title=fmax&lt;br&gt;fmaxf&lt;br&gt;fmaxl | determines larger of two floating-point values | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>ry501hev3aeqy7wi29okvg1tsk24q66</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fmin</title>
    <ns>10</ns>
    <id>5970</id>
    <revision>
      <id>70793</id>
      <parentid>70705</parentid>
      <timestamp>2014-05-30T11:03:45Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="168">{{dsc fun | c/numeric/math/fmin | title=fmin&lt;br&gt;fminf&lt;br&gt;fminl | determines smaller of two floating-point values | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>nwozu3bkj8mt5a3f5q0qo747yz5q9vi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fmod</title>
    <ns>10</ns>
    <id>5998</id>
    <revision>
      <id>70790</id>
      <parentid>70695</parentid>
      <timestamp>2014-05-30T11:00:26Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="166">{{dsc fun | c/numeric/math/fmod | title=fmod&lt;br&gt;fmodf&lt;br&gt;fmodl| computes remainder of the floating-point division operation |notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>brpxc1qzhxeifgl3yf5j4ygixlps7sd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fnan</title>
    <ns>10</ns>
    <id>5992</id>
    <revision>
      <id>70858</id>
      <parentid>53714</parentid>
      <timestamp>2014-05-31T11:16:38Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted verb</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | c/numeric/math/nan | title=nan&lt;br&gt;nanf&lt;br&gt;nanl | returns a NaN (not-a-number) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1>r6qpbc74pbhyqpmgnhy2ihxnykgt6ju</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc fpclassify</title>
    <ns>10</ns>
    <id>6007</id>
    <revision>
      <id>70796</id>
      <parentid>53718</parentid>
      <timestamp>2014-05-30T11:12:33Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen; entry now uses the same verb that appears in 7.12.3.1 of n1570</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/numeric/math/fpclassify | classifies the given floating-point value | notes={{mark c99}} }}</text>
      <sha1>gfxv7v9yd833iksd31rb78knd8sj8k9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc frexp</title>
    <ns>10</ns>
    <id>6015</id>
    <revision>
      <id>70751</id>
      <parentid>53721</parentid>
      <timestamp>2014-05-29T20:28:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; used verb found in 7.12.6.4 of n1570</comment>
      <text xml:space="preserve" bytes="168">{{dsc fun | c/numeric/math/frexp | title=frexp&lt;br&gt;frexpf&lt;br&gt;frexpl | breaks a number into significand and a power of {{c|2}} | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>c0bmy4ct1dv99rkl2j48o8knu26oeju</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc hypot</title>
    <ns>10</ns>
    <id>5982</id>
    <revision>
      <id>70721</id>
      <parentid>53724</parentid>
      <timestamp>2014-05-29T13:20:43Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="236">{{dsc fun | c/numeric/math/hypot | title=hypot&lt;br&gt;hypotf&lt;br&gt;hypotl | computes square root of the sum of the squares of two given numbers ({{math|{{mrad|x{{su|p=2}}+y{{su|p=2}}}}}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>27bdcnddn5cdb4ma6drtjwkiu14desd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc ilogb</title>
    <ns>10</ns>
    <id>6011</id>
    <revision>
      <id>70755</id>
      <parentid>53727</parentid>
      <timestamp>2014-05-29T20:53:21Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function</comment>
      <text xml:space="preserve" bytes="162">{{dsc fun | c/numeric/math/ilogb | title=ilogb&lt;br&gt;ilogbf&lt;br&gt;ilogbl | extracts exponent of the given number | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>ghabn3i5cs32jjvc6v624sxatftwdl4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc imaxabs</title>
    <ns>10</ns>
    <id>13704</id>
    <revision>
      <id>71909</id>
      <timestamp>2014-07-01T19:22:24Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>New template to separate abs and imaxabs, like in C++ templates</comment>
      <text xml:space="preserve" bytes="140">{{dsc fun | c/numeric/math/abs | title=imaxabs | computes absolute value of an integral value ({{math|{{!}}x{{!}}}}) | notes={{mark c99}} }}</text>
      <sha1>n0rgi8l3eqa8x9ymosja3xh6t6g8g56</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc imaxdiv</title>
    <ns>10</ns>
    <id>13705</id>
    <revision>
      <id>71910</id>
      <timestamp>2014-07-01T19:24:28Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>New template to separate div and imaxdiv, like in C++ templates</comment>
      <text xml:space="preserve" bytes="124">{{dsc fun | c/numeric/math/div | title=imaxdiv | computes quotient and remainder of integer division | notes={{mark c99}} }}</text>
      <sha1>1o9r29hpzri6p3at3zl2vh1lqvy5426</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc imaxdiv t</title>
    <ns>10</ns>
    <id>13636</id>
    <revision>
      <id>71481</id>
      <parentid>71362</parentid>
      <timestamp>2014-06-11T20:10:54Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link to div</comment>
      <text xml:space="preserve" bytes="131">{{dsc typedef | c/numeric/math/div | title=imaxdiv_t | structure type, return of the {{c|imaxdiv}} function | notes={{mark c99}} }}</text>
      <sha1>equqmciwh3dkgtzi8m861qh86isgdia</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isfinite</title>
    <ns>10</ns>
    <id>6006</id>
    <revision>
      <id>53731</id>
      <parentid>51936</parentid>
      <timestamp>2013-06-01T05:05:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list isfinite]] to [[Template:c/numeric/math/dsc isfinite]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/numeric/math/isfinite | checks if the given number has finite value | notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isgreater</title>
    <ns>10</ns>
    <id>13533</id>
    <revision>
      <id>70403</id>
      <timestamp>2014-05-21T22:19:29Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing isgreater (C99) like isgreater (c++11)</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | c/numeric/math/isgreater | checks if the first floating-point argument is greater than the second| notes={{mark c99}} }}</text>
      <sha1>dc6mzeybg2qbc2h7xu7paaj60txqlto</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isgreaterequal</title>
    <ns>10</ns>
    <id>13534</id>
    <revision>
      <id>70404</id>
      <timestamp>2014-05-21T22:22:58Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing isgreaterequal (C99) like isgreaterequal (C++11)</comment>
      <text xml:space="preserve" bytes="146">{{dsc fun | c/numeric/math/isgreaterequal | checks if the first floating-point argument is greater or equal than the second| notes={{mark c99}} }}</text>
      <sha1>79nkfxf5yj85fwcxuclumynnkp65s2r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isinf</title>
    <ns>10</ns>
    <id>6005</id>
    <revision>
      <id>53734</id>
      <parentid>51937</parentid>
      <timestamp>2013-06-01T05:05:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list isinf]] to [[Template:c/numeric/math/dsc isinf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | c/numeric/math/isinf | checks if the given number is infinite | notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isless</title>
    <ns>10</ns>
    <id>13535</id>
    <revision>
      <id>70405</id>
      <timestamp>2014-05-21T22:26:04Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing isless (C99) like isless (C++11)</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | c/numeric/math/isless | checks if the first floating-point argument is less than the second| notes={{mark c99}} }}</text>
      <sha1>5hjj45q6hh9t7ttcx7euuislb9drm1r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc islessequal</title>
    <ns>10</ns>
    <id>13536</id>
    <revision>
      <id>70406</id>
      <timestamp>2014-05-21T22:27:56Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing islessequal (C99) like islessequal (C++11)</comment>
      <text xml:space="preserve" bytes="140">{{dsc fun | c/numeric/math/islessequal | checks if the first floating-point argument is less or equal than the second| notes={{mark c99}} }}</text>
      <sha1>g58k6qm6c8ltankx4qttnhvadn0srs3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc islessgreater</title>
    <ns>10</ns>
    <id>13537</id>
    <revision>
      <id>70407</id>
      <timestamp>2014-05-21T22:30:40Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing islessgreater (C99) like islessgreater (C++11)</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | c/numeric/math/islessgreater | checks if the first floating-point argument is less or greater than the second| notes={{mark c99}} }}</text>
      <sha1>o3ez0fioote8lwn3yonkmfugjzixvdj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isnan</title>
    <ns>10</ns>
    <id>6004</id>
    <revision>
      <id>53737</id>
      <parentid>51938</parentid>
      <timestamp>2013-06-01T05:05:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list isnan]] to [[Template:c/numeric/math/dsc isnan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | c/numeric/math/isnan | checks if the given number is NaN| notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isnormal</title>
    <ns>10</ns>
    <id>6003</id>
    <revision>
      <id>53741</id>
      <parentid>51939</parentid>
      <timestamp>2013-06-01T05:05:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list isnormal]] to [[Template:c/numeric/math/dsc isnormal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | c/numeric/math/isnormal | checks if the given number is normal | notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc isunordered</title>
    <ns>10</ns>
    <id>13538</id>
    <revision>
      <id>70408</id>
      <timestamp>2014-05-21T22:33:05Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>Add missing isunordered (C99) like isunordered (C++11)</comment>
      <text xml:space="preserve" bytes="113">{{dsc fun | c/numeric/math/isunordered | checks if two floating-point values are unordered| notes={{mark c99}} }}</text>
      <sha1>mrgy9ej30vxweelpntho4y650ncpy6b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc ldexp</title>
    <ns>10</ns>
    <id>6014</id>
    <revision>
      <id>70752</id>
      <parentid>53744</parentid>
      <timestamp>2014-05-29T20:32:37Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | c/numeric/math/ldexp | title=ldexp&lt;br&gt;ldexpf&lt;br&gt;ldexpl | multiplies a number by {{c|2}} raised to a power | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>kidw0ls29j54e58a2z57naqktrloj8o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc ldiv t</title>
    <ns>10</ns>
    <id>13638</id>
    <revision>
      <id>71479</id>
      <parentid>71365</parentid>
      <timestamp>2014-06-11T20:09:11Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link to div</comment>
      <text xml:space="preserve" bytes="103">{{dsc typedef | c/numeric/math/div | title=ldiv_t | structure type, return of the {{c|ldiv}} function}}</text>
      <sha1>lsa98jak47ab0nlfj35tx884uqv3v9m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc lgamma</title>
    <ns>10</ns>
    <id>6022</id>
    <revision>
      <id>70739</id>
      <parentid>53750</parentid>
      <timestamp>2014-05-29T19:47:55Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb</comment>
      <text xml:space="preserve" bytes="190">{{dsc fun | c/numeric/math/lgamma | title=lgamma&lt;br&gt;lgammaf&lt;br&gt;lgammal | computes natural (base-''e'') logarithm of the gamma function | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>oh4fal8rg0zie864ey5stw46fpz8jcl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc lldiv t</title>
    <ns>10</ns>
    <id>13635</id>
    <revision>
      <id>71480</id>
      <parentid>71361</parentid>
      <timestamp>2014-06-11T20:10:08Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>link to div</comment>
      <text xml:space="preserve" bytes="127">{{dsc typedef | c/numeric/math/div | title=lldiv_t | structure type, return of the {{c|lldiv}} function | notes={{mark c99}} }}</text>
      <sha1>b1kdl9ta2xogvv175ctjsz6hz89ua53</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc log</title>
    <ns>10</ns>
    <id>5988</id>
    <revision>
      <id>70714</id>
      <parentid>70710</parentid>
      <timestamp>2014-05-29T12:38:32Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | c/numeric/math/log | title=log&lt;br&gt;logf&lt;br&gt;logl | computes natural (base-''e'') logarithm ({{math|ln(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>t3a7zr8ymw9ss074xrqipi6junb7eyf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc log10</title>
    <ns>10</ns>
    <id>5987</id>
    <revision>
      <id>70715</id>
      <parentid>70711</parentid>
      <timestamp>2014-05-29T12:39:19Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="183">{{dsc fun | c/numeric/math/log10 | title=log10&lt;br&gt;log10f&lt;br&gt;log10l | computes common (base-''10'') logarithm ({{math|log&lt;sub&gt;10&lt;/sub&gt;(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>spyc8ib1fhd8iaalcc6ecy6afmk7gko</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc log1p</title>
    <ns>10</ns>
    <id>5986</id>
    <revision>
      <id>70716</id>
      <parentid>70713</parentid>
      <timestamp>2014-05-29T12:40:33Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="210">{{dsc fun | c/numeric/math/log1p | title=log1p&lt;br&gt;log1pf&lt;br&gt;log1pl | computes natural (base-''e'') logarithm of 1 plus the given number ({{math|ln(1+x)}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>18505dud9izzq7zy2h8oasfml40jt9k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc log2</title>
    <ns>10</ns>
    <id>5985</id>
    <revision>
      <id>70712</id>
      <parentid>70591</parentid>
      <timestamp>2014-05-29T12:28:36Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names; inserted verb; deleted superfluous prepositional phrase</comment>
      <text xml:space="preserve" bytes="177">{{dsc fun | c/numeric/math/log2 | title=log2&lt;br&gt;log2f&lt;br&gt;log2l  | computes base-2 logarithm ({{math|log&lt;sub&gt;2&lt;/sub&gt;(x)}}) | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>av8tzx2glykoqoflg5flz99t438kdsy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc logb</title>
    <ns>10</ns>
    <id>6010</id>
    <revision>
      <id>70757</id>
      <parentid>53766</parentid>
      <timestamp>2014-05-29T20:56:50Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | c/numeric/math/logb | title=logb&lt;br&gt;logbf&lt;br&gt;logbl | extracts exponent of the given number | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>my5vz1hzf3tv3bx90do7yygim64uvem</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc math errhandling</title>
    <ns>10</ns>
    <id>13523</id>
    <revision>
      <id>70183</id>
      <timestamp>2014-05-11T16:00:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="244">{{dsc macro const | c/numeric/math/math_errhandling |title=math_errhandling&lt;br&gt;MATH_ERRNO&lt;br&gt;MATH_ERREXCEPT | defines the error handling mechanism used by the common mathematical functions | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>prti65erh25oue1z8gelcopetsujwiq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc modf</title>
    <ns>10</ns>
    <id>6013</id>
    <revision>
      <id>70753</id>
      <parentid>53768</parentid>
      <timestamp>2014-05-29T20:37:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; used verb found in 7.12.6.12 of n1570</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | c/numeric/math/modf | title=modf&lt;br&gt;modff&lt;br&gt;modfl | breaks a number into integer and fractional parts | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>8fflhq8nn3cvf49e2oo9l7e6hyq7tlr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc nearbyint</title>
    <ns>10</ns>
    <id>6017</id>
    <revision>
      <id>70743</id>
      <parentid>53772</parentid>
      <timestamp>2014-05-29T20:04:11Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb; correct explanation</comment>
      <text xml:space="preserve" bytes="189">{{dsc fun | c/numeric/math/nearbyint | title=nearbyint&lt;br&gt;nearbyintf&lt;br&gt;nearbyintl | rounds to an integer using current rounding mode | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>e79bbzdjl8euv4t6s6eg8yo0kaa7o52</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc nextafter</title>
    <ns>10</ns>
    <id>6009</id>
    <revision>
      <id>70795</id>
      <parentid>70759</parentid>
      <timestamp>2014-05-30T11:07:06Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="307">{{dsc fun | c/numeric/math/nextafter | title=nextafter&lt;br&gt;nextafterf&lt;br&gt;nextafterl&lt;br&gt;nexttoward&lt;br&gt;nexttowardf&lt;br&gt;nexttowardl | determines next representable floating-point value towards the given value | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>oqttn84v0n010lh6fnos8e7j9xol8et</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc pow</title>
    <ns>10</ns>
    <id>5981</id>
    <revision>
      <id>70717</id>
      <parentid>53781</parentid>
      <timestamp>2014-05-29T12:48:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="173">{{dsc fun | c/numeric/math/pow | title=pow&lt;br&gt;powf&lt;br&gt;powl | computes a number raised to the given power ({{math|x&lt;sup&gt;y&lt;/sup&gt;}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>dbcajzqneswc1zzuwto0bgsp0yb75qs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc remainder</title>
    <ns>10</ns>
    <id>5997</id>
    <revision>
      <id>70791</id>
      <parentid>70696</parentid>
      <timestamp>2014-05-30T11:01:17Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted hyphen</comment>
      <text xml:space="preserve" bytes="207">{{dsc fun | c/numeric/math/remainder | title=remainder&lt;br&gt;remainderf&lt;br&gt;remainderl | computes signed remainder of the floating-point division operation | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>nhtootw4lbwoujo4nob0wc9kotvn9k2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc remquo</title>
    <ns>10</ns>
    <id>5996</id>
    <revision>
      <id>70698</id>
      <parentid>53786</parentid>
      <timestamp>2014-05-29T01:13:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double function names; inserted verb</comment>
      <text xml:space="preserve" bytes="211">{{dsc fun | c/numeric/math/remquo | title=remquo&lt;br&gt;remquof&lt;br&gt;remquol | computes signed remainder as well as the three last bits of the division operation | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>itf3utfwqe2ulayi95855508j667f2a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc rint</title>
    <ns>10</ns>
    <id>6016</id>
    <revision>
      <id>70745</id>
      <parentid>53792</parentid>
      <timestamp>2014-05-29T20:11:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb; correct explanation</comment>
      <text xml:space="preserve" bytes="368">{{dsc fun | c/numeric/math/rint | title=rint&lt;br&gt;rintf&lt;br&gt;rintl&lt;br&gt;lrint&lt;br&gt;lrintf&lt;br&gt;lrintl&lt;br&gt;llrint&lt;br&gt;llrintf&lt;br&gt;llrintl | rounds to an integer using current rounding mode with &lt;br&gt; exception if the result differs | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>8y59tiit498zi6v5528ddiw47a8zyf4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc round</title>
    <ns>10</ns>
    <id>6018</id>
    <revision>
      <id>70742</id>
      <parentid>53796</parentid>
      <timestamp>2014-05-29T19:59:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted verb</comment>
      <text xml:space="preserve" bytes="193">{{dsc fun | c/numeric/math/round | title=round&lt;br&gt;lround&lt;br&gt;llround | rounds to nearest integer, rounding away from zero in halfway cases | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>m9h5jiq3qu75abmgnplg9st3zifgaab</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc scalbn</title>
    <ns>10</ns>
    <id>6012</id>
    <revision>
      <id>70754</id>
      <parentid>53801</parentid>
      <timestamp>2014-05-29T20:45:12Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; used verb found in 7.12.6.13 of n1570</comment>
      <text xml:space="preserve" bytes="282">{{dsc fun | c/numeric/math/scalbn | title=scalbn&lt;br&gt;scalbnf&lt;br&gt;scalbnl&lt;br&gt;scalbln&lt;br&gt;scalblnf&lt;br&gt;scalblnl | computes efficiently a number times {{lc|FLT_RADIX}} raised to a power | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>22d7h3ip8c5cbuq2ptv6w7ryqtup5q5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc signbit</title>
    <ns>10</ns>
    <id>6002</id>
    <revision>
      <id>53805</id>
      <parentid>51956</parentid>
      <timestamp>2013-06-01T05:05:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/dcl list signbit]] to [[Template:c/numeric/math/dsc signbit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | c/numeric/math/signbit | checks if the given number is negative | notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc sin</title>
    <ns>10</ns>
    <id>5980</id>
    <revision>
      <id>70722</id>
      <parentid>53811</parentid>
      <timestamp>2014-05-29T13:26:53Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="137">{{dsc fun | c/numeric/math/sin | title=sin&lt;br&gt;sinf&lt;br&gt;sinl  | computes sine ({{math|sin(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>r5kaupqynxyxi3nyrl6lsgvl59gmq9r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc sinh</title>
    <ns>10</ns>
    <id>5972</id>
    <revision>
      <id>70729</id>
      <parentid>53814</parentid>
      <timestamp>2014-05-29T14:44:33Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="150">{{dsc fun | c/numeric/math/sinh | title=sinh&lt;br&gt;sinhf&lt;br&gt;sinhl | computes hyperbolic sine ({{math|sh(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>5fg57wnhz7uqn5xshjze5sushru1rh7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc sqrt</title>
    <ns>10</ns>
    <id>5984</id>
    <revision>
      <id>70718</id>
      <parentid>53816</parentid>
      <timestamp>2014-05-29T12:51:52Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="152">{{dsc fun | c/numeric/math/sqrt | title=sqrt&lt;br&gt;sqrtf&lt;br&gt;sqrtl | computes square root ({{math|{{mrad|x}}}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}  }}</text>
      <sha1>a8jswl94sin24sepeqxn05wk1udydqj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc tan</title>
    <ns>10</ns>
    <id>5977</id>
    <revision>
      <id>70724</id>
      <parentid>53819</parentid>
      <timestamp>2014-05-29T13:32:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="139">{{dsc fun | c/numeric/math/tan | title=tan&lt;br&gt;tanf&lt;br&gt;tanl | computes tangent ({{math|tan(x)}}) | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>tjyps4p6vin0ax9uk8omz3uyp3pxpgn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc tanh</title>
    <ns>10</ns>
    <id>5978</id>
    <revision>
      <id>70731</id>
      <parentid>53821</parentid>
      <timestamp>2014-05-29T14:52:04Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>inserted the float and long double function names</comment>
      <text xml:space="preserve" bytes="136">{{dsc fun | c/numeric/math/tanh | title=tanh&lt;br&gt;tanhf&lt;br&gt;tanhl | computes hyperbolic tangent | notes=&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>59wtvi4p9uarcfdg3syzy5b9rpio450</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc tgamma</title>
    <ns>10</ns>
    <id>6021</id>
    <revision>
      <id>70740</id>
      <parentid>53824</parentid>
      <timestamp>2014-05-29T19:50:41Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb</comment>
      <text xml:space="preserve" bytes="152">{{dsc fun | c/numeric/math/tgamma | title=tgamma&lt;br&gt;tgammaf&lt;br&gt;tgammal | computes gamma function | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>pmh94ra7mzihxh6vmovo3m7ywmxotfk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/dsc trunc</title>
    <ns>10</ns>
    <id>6019</id>
    <revision>
      <id>70741</id>
      <parentid>53828</parentid>
      <timestamp>2014-05-29T19:55:57Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>inserted float and long double names of the function; inserted verb</comment>
      <text xml:space="preserve" bytes="196">{{dsc fun | c/numeric/math/trunc | title=trunc&lt;br&gt;truncf&lt;br&gt;truncl | rounds to nearest integer not greater in magnitude than the given value | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}</text>
      <sha1>3krx8ypb4291eb3fvzxjvam6kup276w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/navbar</title>
    <ns>10</ns>
    <id>6033</id>
    <revision>
      <id>39848</id>
      <parentid>35494</parentid>
      <timestamp>2012-09-28T19:56:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/numeric/navbar heading
|content2 = c/numeric/navbar content

|heading3 = c/numeric/math/navbar heading
|content3 = c/numeric/math/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/navbar content</title>
    <ns>10</ns>
    <id>6409</id>
    <revision>
      <id>51964</id>
      <parentid>35497</parentid>
      <timestamp>2013-06-01T04:37:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="4146">{{nv begin}}
{{nv h1 | Functions}}
{{nv h2 | Basic operations}}
{{nv col begin}}
{{nv ln | c/numeric/math/abs | abs | labs | llabs |imaxabs|notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}
{{nv ln | c/numeric/math/fabs}}
{{nv ln | c/numeric/math/div | div | ldiv | lldiv| imaxdiv|notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c99}}}}
{{nv ln | c/numeric/math/fmod}}
{{nv col next}}
{{nv ln | c/numeric/math/remainder | notes={{mark c99}} }}
{{nv ln | c/numeric/math/remquo | notes={{mark c99}} }}
{{nv ln | c/numeric/math/fma | notes={{mark c99}} }}
{{nv ln | c/numeric/math/fmax | notes={{mark c99}} }}
{{nv ln | c/numeric/math/fmin | notes={{mark c99}} }}
{{nv ln | c/numeric/math/fdim | notes={{mark c99}} }}
{{nv ln | c/numeric/math/nan | nan | nanf | nanl | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}
{{nv col end}}

{{nv h2 | Exponential functions}}
{{nv col begin}}
{{nv ln | c/numeric/math/exp}}
{{nv ln | c/numeric/math/exp2 | notes={{mark c99}} }}
{{nv ln | c/numeric/math/expm1 | notes={{mark c99}} }}
{{nv col next}}
{{nv ln | c/numeric/math/log}}
{{nv ln | c/numeric/math/log10}}
{{nv ln | c/numeric/math/log1p | notes={{mark c99}} }}
{{nv ln | c/numeric/math/log2| notes={{mark c99}} }}
{{nv col end}}

{{nv h2 | Power functions}}
{{nv col begin}}
{{nv ln | c/numeric/math/sqrt}}
{{nv ln | c/numeric/math/cbrt | notes={{mark c99}} }}
{{nv col next}}
{{nv ln | c/numeric/math/hypot | notes={{mark c99}} }}
{{nv ln | c/numeric/math/pow}}
{{nv col end}}

{{nv h2 | Trigonometric and hyperbolic functions}}
{{nv col begin}}
{{nv ln | c/numeric/math/sin}}
{{nv ln | c/numeric/math/cos}}
{{nv ln | c/numeric/math/tan}}
{{nv ln | c/numeric/math/asin}}
{{nv ln | c/numeric/math/acos}}
{{nv ln | c/numeric/math/atan}}
{{nv ln | c/numeric/math/atan2}}
{{nv col next}}
{{nv ln | c/numeric/math/sinh}}
{{nv ln | c/numeric/math/cosh}}
{{nv ln | c/numeric/math/tanh}}
{{nv ln | c/numeric/math/asinh | notes={{mark c99}} }}
{{nv ln | c/numeric/math/acosh | notes={{mark c99}} }}
{{nv ln | c/numeric/math/atanh | notes={{mark c99}} }}
{{nv col end}}

{{nv h2 | Error and gamma functions}}
{{nv col begin}}
{{nv ln | c/numeric/math/erf | notes={{mark c99}} }}
{{nv ln | c/numeric/math/erfc | notes={{mark c99}} }}
{{nv col next}}
{{nv ln | c/numeric/math/lgamma | notes={{mark c99}} }}
{{nv ln | c/numeric/math/tgamma | notes={{mark c99}} }}
{{nv col end}}

{{nv h2 | Nearest integer floating point operations}}
{{nv col begin}}
{{nv ln | c/numeric/math/ceil}}
{{nv ln | c/numeric/math/floor}}
{{nv ln | c/numeric/math/round | round | lround | llround  | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}}}
{{nv col next}}
{{nv ln | c/numeric/math/trunc | notes={{mark c99}} }}
{{nv ln | c/numeric/math/nearbyint | notes={{mark c99}} }}
{{nv ln | c/numeric/math/rint | rint | lrint | llrint | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}
{{nv col end}}

{{nv h2 | Floating point manipulation functions}}
{{nv col begin}}
{{nv ln | c/numeric/math/ldexp}}
{{nv ln | c/numeric/math/scalbn | scalbn | scalbln | notes={{mark c99}}&lt;br&gt;{{mark c99}} }}
{{nv ln | c/numeric/math/ilogb | notes={{mark c99}} }}
{{nv ln | c/numeric/math/logb | notes={{mark c99}} }}
{{nv col next}}
{{nv ln | c/numeric/math/frexp}}
{{nv ln | c/numeric/math/modf}}
{{nv ln | c/numeric/math/nextafter | nextafter | nexttoward | notes={{mark c99}}&lt;br&gt;{{mark c99}} }}
{{nv ln | c/numeric/math/copysign | notes={{mark c99}} }}
{{nv col end}}

{{nv h2 | Classification}}
{{nv ln | c/numeric/math/fpclassify | notes={{mark c99}} }}
{{nv ln | c/numeric/math/isfinite | notes={{mark c99}} }}
{{nv ln | c/numeric/math/isinf | notes={{mark c99}} }}
{{nv ln | c/numeric/math/isnan | notes={{mark c99}} }}
{{nv ln | c/numeric/math/isnormal | notes={{mark c99}} }}
{{nv ln | c/numeric/math/signbit | notes={{mark c99}} }}

{{nv h1 | Macro constants}}
{{nv col begin}}
{{nv ln | c/numeric/math/HUGE_VAL | HUGE_VALF | HUGE_VAL | HUGE_VALL | notes={{mark c99}}&lt;br&gt;&lt;br&gt;{{mark c99}}}}
{{nv col next}}
{{nv ln | c/numeric/math/FP_categories | FP_NORMAL | FP_SUBNORMAL | FP_ZERO | FP_INFINITE | FP_NAN | notes={{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}}&lt;br&gt;{{mark c99}} }}
{{nv col end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/math/navbar heading</title>
    <ns>10</ns>
    <id>6034</id>
    <revision>
      <id>35498</id>
      <parentid>25272</parentid>
      <timestamp>2012-06-15T22:26:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/math/sidebar heading]] to [[Template:c/numeric/math/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="50">[[c/numeric/math | Common mathematical functions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/navbar</title>
    <ns>10</ns>
    <id>6358</id>
    <revision>
      <id>39849</id>
      <parentid>35503</parentid>
      <timestamp>2012-09-28T19:56:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="144">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/numeric/navbar heading
|content2 = c/numeric/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/navbar content</title>
    <ns>10</ns>
    <id>6360</id>
    <revision>
      <id>51965</id>
      <parentid>34982</parentid>
      <timestamp>2013-06-01T04:37:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="302">{{nv begin}}
{{nv | [[c/numeric/math|Common mathematical functions]] }}
{{nv | [[c/numeric/fenv|Floating-point environment]] }}
{{nv | [[c/numeric/complex|Complex number arithmetics]] }}
{{nv | [[c/numeric/random|Random number generation]] }}
{{nv | [[c/numeric/tgmath|Type-generic math]] }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/navbar heading</title>
    <ns>10</ns>
    <id>6359</id>
    <revision>
      <id>35454</id>
      <parentid>25050</parentid>
      <timestamp>2012-06-15T22:25:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/sidebar heading]] to [[Template:c/numeric/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="24">[[c/numeric | Numerics]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/dsc RAND MAX</title>
    <ns>10</ns>
    <id>6412</id>
    <revision>
      <id>53830</id>
      <parentid>51966</parentid>
      <timestamp>2013-06-01T05:06:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/random/dcl list RAND MAX]] to [[Template:c/numeric/random/dsc RAND MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc macro const | c/numeric/random/RAND_MAX | maximum possible value generated by {{c|rand()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/dsc rand</title>
    <ns>10</ns>
    <id>6413</id>
    <revision>
      <id>53832</id>
      <parentid>51967</parentid>
      <timestamp>2013-06-01T05:06:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/random/dcl list rand]] to [[Template:c/numeric/random/dsc rand]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | c/numeric/random/rand | generates a pseudo-random number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/dsc srand</title>
    <ns>10</ns>
    <id>6414</id>
    <revision>
      <id>53834</id>
      <parentid>51968</parentid>
      <timestamp>2013-06-01T05:06:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/random/dcl list srand]] to [[Template:c/numeric/random/dsc srand]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/numeric/random/srand | seeds pseudo-random number generator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/navbar</title>
    <ns>10</ns>
    <id>6418</id>
    <revision>
      <id>39850</id>
      <parentid>35500</parentid>
      <timestamp>2012-09-28T19:56:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="233">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/numeric/navbar heading
|content2 = c/numeric/navbar content

|heading3 = c/numeric/random/navbar heading
|content3 = c/numeric/random/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/navbar content</title>
    <ns>10</ns>
    <id>6420</id>
    <revision>
      <id>51969</id>
      <parentid>35501</parentid>
      <timestamp>2013-06-01T04:37:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="139">{{nv begin}}
{{nv ln | cpp/numeric/random/rand }}
{{nv ln | cpp/numeric/random/srand }}
{{nv ln | cpp/numeric/random/RAND_MAX }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/numeric/random/navbar heading</title>
    <ns>10</ns>
    <id>6419</id>
    <revision>
      <id>35502</id>
      <parentid>25487</parentid>
      <timestamp>2012-06-15T22:26:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/numeric/random/sidebar heading]] to [[Template:c/numeric/random/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="54">[[c/numeric/random | Pseudo-random number generation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/preprocessor/navbar</title>
    <ns>10</ns>
    <id>12668</id>
    <revision>
      <id>61446</id>
      <timestamp>2013-06-06T00:37:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="231">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/language/navbar heading
|content2 = c/language/navbar content

|heading3 = c/preprocessor/navbar heading
|content3 = c/preprocessor/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/preprocessor/navbar content</title>
    <ns>10</ns>
    <id>12670</id>
    <revision>
      <id>72160</id>
      <parentid>61449</parentid>
      <timestamp>2014-07-19T14:28:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no #warning in C</comment>
      <text xml:space="preserve" bytes="413">{{nv begin}}
{{nv ln | c/preprocessor/conditional | &amp;#35;if | &amp;#35;ifdef | &amp;#35;ifndef | &amp;#35;else | &amp;#35;elif | &amp;#35;endif}}
{{nv ln | c/preprocessor/replace | &amp;#35;define | &amp;#35;undef | &amp;#35;,&amp;#35;&amp;#35; operators}}
{{nv ln | c/preprocessor/include | &amp;#35;include}}
{{nv ln | c/preprocessor/error | &amp;#35;error}}
{{nv ln | c/preprocessor/impl | &amp;#35;pragma}}
{{nv ln | c/preprocessor/line | &amp;#35;line}}
{{nv end}}</text>
      <sha1>ggz6at849rnkfzazqcyp0ik6y895byc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/preprocessor/navbar heading</title>
    <ns>10</ns>
    <id>12669</id>
    <revision>
      <id>61448</id>
      <parentid>61447</parentid>
      <timestamp>2013-06-06T00:38:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="33">[[c/preprocessor | Preprocessor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc EXIT status</title>
    <ns>10</ns>
    <id>5948</id>
    <revision>
      <id>53838</id>
      <parentid>51970</parentid>
      <timestamp>2013-06-01T05:06:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list EXIT status]] to [[Template:c/program/dsc EXIT status]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc macro const | c/program/EXIT_status | title=EXIT_SUCCESS&lt;br&gt;EXIT_FAILURE | indicates program execution execution status}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc Exit</title>
    <ns>10</ns>
    <id>5951</id>
    <revision>
      <id>53840</id>
      <parentid>51971</parentid>
      <timestamp>2013-06-01T05:06:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list Exit]] to [[Template:c/program/dsc Exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc fun | c/program/_Exit | causes normal program termination without cleaning up |notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc SIG ERR</title>
    <ns>10</ns>
    <id>5942</id>
    <revision>
      <id>53842</id>
      <parentid>51972</parentid>
      <timestamp>2013-06-01T05:06:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list SIG ERR]] to [[Template:c/program/dsc SIG ERR]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc macro const | c/program/SIG_ERR | error was encountered }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc SIG strategies</title>
    <ns>10</ns>
    <id>5943</id>
    <revision>
      <id>53844</id>
      <parentid>51973</parentid>
      <timestamp>2013-06-01T05:06:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list SIG strategies]] to [[Template:c/program/dsc SIG strategies]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc macro const | c/program/SIG_strategies | title=SIG_DFL&lt;br&gt;SIG_IGN | defines signal handling strategies }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc SIG types</title>
    <ns>10</ns>
    <id>6336</id>
    <revision>
      <id>53846</id>
      <parentid>51974</parentid>
      <timestamp>2013-06-01T05:06:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list SIG types]] to [[Template:c/program/dsc SIG types]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc macro const | c/program/SIG_types | title=SIGABRT&lt;br&gt;SIGFPE&lt;br&gt;SIGILL&lt;br&gt;SIGINT&lt;br&gt;SIGSEGV&lt;br&gt;SIGTERM | defines signal types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc abort</title>
    <ns>10</ns>
    <id>5954</id>
    <revision>
      <id>53848</id>
      <parentid>51975</parentid>
      <timestamp>2013-06-01T05:06:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list abort]] to [[Template:c/program/dsc abort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | c/program/abort | causes abnormal program termination (without cleaning up)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc at quick exit</title>
    <ns>10</ns>
    <id>5949</id>
    <revision>
      <id>53850</id>
      <parentid>51976</parentid>
      <timestamp>2013-06-01T05:06:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list at quick exit]] to [[Template:c/program/dsc at quick exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc fun | c/program/at_quick_exit | registers a function to be called on {{ltt|c/program/quick_exit}} invocation |notes={{mark c99}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc atexit</title>
    <ns>10</ns>
    <id>5950</id>
    <revision>
      <id>64382</id>
      <parentid>53852</parentid>
      <timestamp>2013-08-15T18:49:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | c/program/atexit | registers a function to be called on {{lc|exit()}} invocation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc exit</title>
    <ns>10</ns>
    <id>5953</id>
    <revision>
      <id>53854</id>
      <parentid>51978</parentid>
      <timestamp>2013-06-01T05:06:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list exit]] to [[Template:c/program/dsc exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | c/program/exit | causes normal program termination with cleaning up}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc getenv</title>
    <ns>10</ns>
    <id>5946</id>
    <revision>
      <id>53856</id>
      <parentid>51979</parentid>
      <timestamp>2013-06-01T05:06:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list getenv]] to [[Template:c/program/dsc getenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | c/program/getenv | access to the list of environment variables }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc jmp buf</title>
    <ns>10</ns>
    <id>5934</id>
    <revision>
      <id>53858</id>
      <parentid>51980</parentid>
      <timestamp>2013-06-01T05:06:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list jmp buf]] to [[Template:c/program/dsc jmp buf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc fun | c/program/jmp_buf | execution context type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc longjmp</title>
    <ns>10</ns>
    <id>5935</id>
    <revision>
      <id>53860</id>
      <parentid>51981</parentid>
      <timestamp>2013-06-01T05:06:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list longjmp]] to [[Template:c/program/dsc longjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc fun | c/program/longjmp | jumps to specified location }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc quick exit</title>
    <ns>10</ns>
    <id>5952</id>
    <revision>
      <id>53862</id>
      <parentid>51982</parentid>
      <timestamp>2013-06-01T05:06:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list quick exit]] to [[Template:c/program/dsc quick exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | c/program/quick_exit | causes normal program termination without completely cleaning up |notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc raise</title>
    <ns>10</ns>
    <id>5944</id>
    <revision>
      <id>53864</id>
      <parentid>51983</parentid>
      <timestamp>2013-06-01T05:06:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list raise]] to [[Template:c/program/dsc raise]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | c/program/raise | runs the signal handler for particular signal }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc setjmp</title>
    <ns>10</ns>
    <id>5936</id>
    <revision>
      <id>53866</id>
      <parentid>51984</parentid>
      <timestamp>2013-06-01T05:06:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list setjmp]] to [[Template:c/program/dsc setjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc macro fun | c/program/setjmp | saves the context }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc signal</title>
    <ns>10</ns>
    <id>5945</id>
    <revision>
      <id>53868</id>
      <parentid>51985</parentid>
      <timestamp>2013-06-01T05:06:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list signal]] to [[Template:c/program/dsc signal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | c/program/signal | sets a signal handler for particular signal }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/dsc system</title>
    <ns>10</ns>
    <id>5947</id>
    <revision>
      <id>53870</id>
      <parentid>51986</parentid>
      <timestamp>2013-06-01T05:06:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/dcl list system]] to [[Template:c/program/dsc system]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | c/program/system | calls the host environment's command processor }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/navbar</title>
    <ns>10</ns>
    <id>6031</id>
    <revision>
      <id>39851</id>
      <parentid>35505</parentid>
      <timestamp>2012-09-28T19:56:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="144">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/program/navbar heading
|content2 = c/program/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/navbar content</title>
    <ns>10</ns>
    <id>6471</id>
    <revision>
      <id>51987</id>
      <parentid>36580</parentid>
      <timestamp>2013-06-01T04:38:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1071">{{nv begin}}
{{nv h1 | Program termination}}
{{nv col begin}}
{{nv ln | c/program/abort}}
{{nv ln | c/program/exit}}
{{nv ln | c/program/quick_exit | notes={{mark c++11}}}}
{{nv ln | c/program/_Exit | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | c/program/atexit}}
{{nv ln | c/program/at_quick_exit | notes={{mark c++11}}}}
{{nv ln | c/program/EXIT_status | EXIT_SUCCESS | EXIT_FAILURE}}
{{nv col end}}

{{nv h1 | Communicating with the environment}}
{{nv col begin}}
{{nv ln | c/program/system}}
{{nv col next}}
{{nv ln | c/program/getenv}}
{{nv col end}}

{{nv h1 | Signals}}
{{nv col begin}}
{{nv ln | c/program/signal}}
{{nv ln | c/program/raise}}
{{nv ln | c/program/sig_atomic_t}}
{{nv col next}}
{{nv ln | c/program/SIG_strategies | SIG_DFL | SIG_IGN}}
{{nv ln | c/program/SIG_ERR}}
{{nv col end}}

{{nv h2 | Signal types}}
{{nv ln | c/program/SIG_types | SIGABRT | SIGFPE | SIGILL | SIGINT | SIGSEGV | SIGTERM}}

{{nv h1 | Non-local jumps}}
{{nv ln | c/program/setjmp}}
{{nv ln | c/program/longjmp}}

{{nv h2 | Types}}
{{nv ln | c/program/jmp_buf}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/program/navbar heading</title>
    <ns>10</ns>
    <id>6036</id>
    <revision>
      <id>35509</id>
      <parentid>21352</parentid>
      <timestamp>2012-06-15T22:27:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/program/sidebar heading]] to [[Template:c/program/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="41">[[c/program | Program support utilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc atof</title>
    <ns>10</ns>
    <id>5865</id>
    <revision>
      <id>53873</id>
      <parentid>51988</parentid>
      <timestamp>2013-06-01T05:06:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list atof]] to [[Template:c/string/byte/dsc atof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | c/string/byte/atof | converts a byte string to a floating point value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc atoi</title>
    <ns>10</ns>
    <id>5864</id>
    <revision>
      <id>53877</id>
      <parentid>51989</parentid>
      <timestamp>2013-06-01T05:06:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list atoi]] to [[Template:c/string/byte/dsc atoi]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc fun | c/string/byte/atoi | title=atoi&lt;br&gt;atol&lt;br&gt;atoll | converts a byte string to an integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isalnum</title>
    <ns>10</ns>
    <id>5838</id>
    <revision>
      <id>53881</id>
      <parentid>51990</parentid>
      <timestamp>2013-06-01T05:06:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isalnum]] to [[Template:c/string/byte/dsc isalnum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/string/byte/isalnum | checks if a character is alphanumeric}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isalpha</title>
    <ns>10</ns>
    <id>5837</id>
    <revision>
      <id>53883</id>
      <parentid>51991</parentid>
      <timestamp>2013-06-01T05:06:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isalpha]] to [[Template:c/string/byte/dsc isalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | c/string/byte/isalpha | checks if a character is alphabetic}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isblank</title>
    <ns>10</ns>
    <id>5829</id>
    <revision>
      <id>53886</id>
      <parentid>51992</parentid>
      <timestamp>2013-06-01T05:06:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isblank]] to [[Template:c/string/byte/dsc isblank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | c/string/byte/isblank | checks if a character is a blank character | notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc iscntrl</title>
    <ns>10</ns>
    <id>5832</id>
    <revision>
      <id>53888</id>
      <parentid>51993</parentid>
      <timestamp>2013-06-01T05:06:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list iscntrl]] to [[Template:c/string/byte/dsc iscntrl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | c/string/byte/iscntrl | checks if a character is a control character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isdigit</title>
    <ns>10</ns>
    <id>5834</id>
    <revision>
      <id>53890</id>
      <parentid>51994</parentid>
      <timestamp>2013-06-01T05:06:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isdigit]] to [[Template:c/string/byte/dsc isdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | c/string/byte/isdigit | checks if a character is a digit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isgraph</title>
    <ns>10</ns>
    <id>5831</id>
    <revision>
      <id>53893</id>
      <parentid>51995</parentid>
      <timestamp>2013-06-01T05:06:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isgraph]] to [[Template:c/string/byte/dsc isgraph]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | c/string/byte/isgraph | checks if a character is a graphical character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc islower</title>
    <ns>10</ns>
    <id>5836</id>
    <revision>
      <id>53895</id>
      <parentid>51996</parentid>
      <timestamp>2013-06-01T05:07:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list islower]] to [[Template:c/string/byte/dsc islower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | c/string/byte/islower | checks if a character is lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isprint</title>
    <ns>10</ns>
    <id>5828</id>
    <revision>
      <id>53898</id>
      <parentid>51997</parentid>
      <timestamp>2013-06-01T05:07:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isprint]] to [[Template:c/string/byte/dsc isprint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc fun | c/string/byte/isprint | checks if a character is a printing character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc ispunct</title>
    <ns>10</ns>
    <id>5827</id>
    <revision>
      <id>53900</id>
      <parentid>51998</parentid>
      <timestamp>2013-06-01T05:07:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list ispunct]] to [[Template:c/string/byte/dsc ispunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | c/string/byte/ispunct | checks if a character is a punctuation character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isspace</title>
    <ns>10</ns>
    <id>5830</id>
    <revision>
      <id>53905</id>
      <parentid>51999</parentid>
      <timestamp>2013-06-01T05:07:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isspace]] to [[Template:c/string/byte/dsc isspace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | c/string/byte/isspace | checks if a character is a space character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isupper</title>
    <ns>10</ns>
    <id>5835</id>
    <revision>
      <id>53909</id>
      <parentid>52000</parentid>
      <timestamp>2013-06-01T05:07:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isupper]] to [[Template:c/string/byte/dsc isupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc fun | c/string/byte/isupper | checks if a character is an uppercase character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc isxdigit</title>
    <ns>10</ns>
    <id>5833</id>
    <revision>
      <id>53914</id>
      <parentid>52001</parentid>
      <timestamp>2013-06-01T05:07:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list isxdigit]] to [[Template:c/string/byte/dsc isxdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | c/string/byte/isxdigit | checks if a character is a hexadecimal character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc memchr</title>
    <ns>10</ns>
    <id>5843</id>
    <revision>
      <id>53918</id>
      <parentid>52002</parentid>
      <timestamp>2013-06-01T05:07:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list memchr]] to [[Template:c/string/byte/dsc memchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | c/string/byte/memchr | searches an array for the first occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc memcmp</title>
    <ns>10</ns>
    <id>5866</id>
    <revision>
      <id>53924</id>
      <parentid>52003</parentid>
      <timestamp>2013-06-01T05:07:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list memcmp]] to [[Template:c/string/byte/dsc memcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc fun | c/string/byte/memcmp | compares two buffers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc memcpy</title>
    <ns>10</ns>
    <id>5841</id>
    <revision>
      <id>53927</id>
      <parentid>52004</parentid>
      <timestamp>2013-06-01T05:07:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list memcpy]] to [[Template:c/string/byte/dsc memcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/string/byte/memcpy | copies one buffer to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc memmove</title>
    <ns>10</ns>
    <id>5840</id>
    <revision>
      <id>53931</id>
      <parentid>52005</parentid>
      <timestamp>2013-06-01T05:07:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list memmove]] to [[Template:c/string/byte/dsc memmove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/string/byte/memmove | moves one buffer to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc memset</title>
    <ns>10</ns>
    <id>5842</id>
    <revision>
      <id>53934</id>
      <parentid>52006</parentid>
      <timestamp>2013-06-01T05:07:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list memset]] to [[Template:c/string/byte/dsc memset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc fun | c/string/byte/memset | fills a buffer with a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strcat</title>
    <ns>10</ns>
    <id>5857</id>
    <revision>
      <id>53937</id>
      <parentid>52007</parentid>
      <timestamp>2013-06-01T05:07:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strcat]] to [[Template:c/string/byte/dsc strcat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc fun | c/string/byte/strcat | concatenates two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strchr</title>
    <ns>10</ns>
    <id>5850</id>
    <revision>
      <id>53941</id>
      <parentid>52008</parentid>
      <timestamp>2013-06-01T05:07:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strchr]] to [[Template:c/string/byte/dsc strchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | c/string/byte/strchr | finds the first occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strcmp</title>
    <ns>10</ns>
    <id>5853</id>
    <revision>
      <id>53943</id>
      <parentid>52009</parentid>
      <timestamp>2013-06-01T05:07:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strcmp]] to [[Template:c/string/byte/dsc strcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc fun | c/string/byte/strcmp | compares two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strcoll</title>
    <ns>10</ns>
    <id>5851</id>
    <revision>
      <id>53945</id>
      <parentid>52010</parentid>
      <timestamp>2013-06-01T05:07:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strcoll]] to [[Template:c/string/byte/dsc strcoll]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | c/string/byte/strcoll | compares two strings in accordance to the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strcpy</title>
    <ns>10</ns>
    <id>5859</id>
    <revision>
      <id>53948</id>
      <parentid>52011</parentid>
      <timestamp>2013-06-01T05:07:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strcpy]] to [[Template:c/string/byte/dsc strcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | c/string/byte/strcpy | copies one string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strcspn</title>
    <ns>10</ns>
    <id>5847</id>
    <revision>
      <id>53953</id>
      <parentid>52012</parentid>
      <timestamp>2013-06-01T05:07:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strcspn]] to [[Template:c/string/byte/dsc strcspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc fun | c/string/byte/strcspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the characters not found in another byte string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strerror</title>
    <ns>10</ns>
    <id>5839</id>
    <revision>
      <id>53959</id>
      <parentid>52013</parentid>
      <timestamp>2013-06-01T05:07:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strerror]] to [[Template:c/string/byte/dsc strerror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc fun | c/string/byte/strerror | returns a text version of a given error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strlen</title>
    <ns>10</ns>
    <id>5854</id>
    <revision>
      <id>53963</id>
      <parentid>52014</parentid>
      <timestamp>2013-06-01T05:07:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strlen]] to [[Template:c/string/byte/dsc strlen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | c/string/byte/strlen | returns the length of a given string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strncat</title>
    <ns>10</ns>
    <id>5856</id>
    <revision>
      <id>53969</id>
      <parentid>52015</parentid>
      <timestamp>2013-06-01T05:07:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strncat]] to [[Template:c/string/byte/dsc strncat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | c/string/byte/strncat | concatenates a certain amount of characters of two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strncmp</title>
    <ns>10</ns>
    <id>5852</id>
    <revision>
      <id>53973</id>
      <parentid>52016</parentid>
      <timestamp>2013-06-01T05:07:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strncmp]] to [[Template:c/string/byte/dsc strncmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/string/byte/strncmp | compares a certain amount of characters of two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strncpy</title>
    <ns>10</ns>
    <id>5858</id>
    <revision>
      <id>53979</id>
      <parentid>52017</parentid>
      <timestamp>2013-06-01T05:07:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strncpy]] to [[Template:c/string/byte/dsc strncpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | c/string/byte/strncpy | copies a certain amount of characters from one string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strpbrk</title>
    <ns>10</ns>
    <id>5846</id>
    <revision>
      <id>53982</id>
      <parentid>52018</parentid>
      <timestamp>2013-06-01T05:07:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strpbrk]] to [[Template:c/string/byte/dsc strpbrk]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | c/string/byte/strpbrk | finds the first location of any character in one string, in another string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strrchr</title>
    <ns>10</ns>
    <id>5849</id>
    <revision>
      <id>53986</id>
      <parentid>52019</parentid>
      <timestamp>2013-06-01T05:07:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strrchr]] to [[Template:c/string/byte/dsc strrchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | c/string/byte/strrchr | finds the last occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strspn</title>
    <ns>10</ns>
    <id>5848</id>
    <revision>
      <id>53989</id>
      <parentid>52020</parentid>
      <timestamp>2013-06-01T05:08:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strspn]] to [[Template:c/string/byte/dsc strspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | c/string/byte/strspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the characters found in another byte string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strstr</title>
    <ns>10</ns>
    <id>5845</id>
    <revision>
      <id>53995</id>
      <parentid>52021</parentid>
      <timestamp>2013-06-01T05:08:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strstr]] to [[Template:c/string/byte/dsc strstr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/string/byte/strstr | finds the first occurrence of a substring of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strtof</title>
    <ns>10</ns>
    <id>5861</id>
    <revision>
      <id>54005</id>
      <parentid>52022</parentid>
      <timestamp>2013-06-01T05:08:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strtof]] to [[Template:c/string/byte/dsc strtof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc fun | c/string/byte/strtof | title=strtof&lt;br&gt;strtod&lt;br&gt;strtold | converts a byte string to a floating point value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strtoimax</title>
    <ns>10</ns>
    <id>5860</id>
    <revision>
      <id>54011</id>
      <parentid>52023</parentid>
      <timestamp>2013-06-01T05:08:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strtoimax]] to [[Template:c/string/byte/dsc strtoimax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc fun | c/string/byte/strtoimax| title=strtoimax&lt;br&gt;strtoumax | converts a byte string to {{c|intmax_t}} or {{c|uintmax_t}} | notes={{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strtok</title>
    <ns>10</ns>
    <id>5844</id>
    <revision>
      <id>54015</id>
      <parentid>52024</parentid>
      <timestamp>2013-06-01T05:08:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strtok]] to [[Template:c/string/byte/dsc strtok]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | c/string/byte/strtok | finds the next token in a byte string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strtol</title>
    <ns>10</ns>
    <id>5863</id>
    <revision>
      <id>54025</id>
      <parentid>52025</parentid>
      <timestamp>2013-06-01T05:08:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strtol]] to [[Template:c/string/byte/dsc strtol]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc fun | c/string/byte/strtol | title=strtol&lt;br&gt;strtoll | converts a byte string to an integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strtoul</title>
    <ns>10</ns>
    <id>5862</id>
    <revision>
      <id>54029</id>
      <parentid>52026</parentid>
      <timestamp>2013-06-01T05:08:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strtoul]] to [[Template:c/string/byte/dsc strtoul]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/string/byte/strtoul| title=strtoul&lt;br&gt; strtoull | converts a byte string to an unsigned integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc strxfrm</title>
    <ns>10</ns>
    <id>5855</id>
    <revision>
      <id>54031</id>
      <parentid>52027</parentid>
      <timestamp>2013-06-01T05:08:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list strxfrm]] to [[Template:c/string/byte/dsc strxfrm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | c/string/byte/strxfrm | converts a substring so that it can be used by string comparison functions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc tolower</title>
    <ns>10</ns>
    <id>5826</id>
    <revision>
      <id>54034</id>
      <parentid>52028</parentid>
      <timestamp>2013-06-01T05:08:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list tolower]] to [[Template:c/string/byte/dsc tolower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | c/string/byte/tolower | converts a character to lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/dsc toupper</title>
    <ns>10</ns>
    <id>5825</id>
    <revision>
      <id>54039</id>
      <parentid>52029</parentid>
      <timestamp>2013-06-01T05:08:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/dcl list toupper]] to [[Template:c/string/byte/dsc toupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | c/string/byte/toupper | converts a character to uppercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/navbar</title>
    <ns>10</ns>
    <id>5916</id>
    <revision>
      <id>39852</id>
      <parentid>35514</parentid>
      <timestamp>2012-09-28T19:56:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="225">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/string/navbar heading
|content2 = c/string/navbar content

|heading3 = c/string/byte/navbar heading
|content3 = c/string/byte/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/navbar content</title>
    <ns>10</ns>
    <id>6361</id>
    <revision>
      <id>66191</id>
      <parentid>52030</parentid>
      <timestamp>2013-11-09T19:32:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>s/c++11/c99</comment>
      <text xml:space="preserve" bytes="1859">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | Character manipulation}}
{{nv col begin}}
{{nv ln | c/string/byte/isalnum}}
{{nv ln | c/string/byte/isalpha}}
{{nv ln | c/string/byte/islower}}
{{nv ln | c/string/byte/isupper}}
{{nv ln | c/string/byte/isdigit}}
{{nv ln | c/string/byte/isxdigit}}
{{nv ln | c/string/byte/isblank|notes={{mark c99}}}}
{{nv col next}}
{{nv ln | c/string/byte/iscntrl}}
{{nv ln | c/string/byte/isgraph}}
{{nv ln | c/string/byte/isspace}}
{{nv ln | c/string/byte/isprint}}
{{nv ln | c/string/byte/ispunct}}
{{nv ln | c/string/byte/tolower}}
{{nv ln | c/string/byte/toupper}}
{{nv col end}}

{{nv h2 | Conversions to numeric formats}}
{{nv col begin}}
{{nv ln | c/string/byte/atof}}
{{nv ln | c/string/byte/atoi|atoi|atol|atoll}}
{{nv ln | c/string/byte/strtol|strtol|strtoll}}
{{nv col next}}
{{nv ln | c/string/byte/strtoul|strtoul|strtoull}}
{{nv ln | c/string/byte/strtof|strtof|strtod|strtold}}
{{nv col end}}

{{nv h2 | String manipulation}}
{{nv ln | c/string/byte/strcpy}}
{{nv ln | c/string/byte/strncpy}}
{{nv ln | c/string/byte/strcat}}
{{nv ln | c/string/byte/strncat}}
{{nv ln | c/string/byte/strxfrm}}

{{nv h2 | String examination}}
{{nv col begin}}
{{nv ln | c/string/byte/strlen}}
{{nv ln | c/string/byte/strcmp}}
{{nv ln | c/string/byte/strncmp}}
{{nv ln | c/string/byte/strcoll}}
{{nv ln | c/string/byte/strchr}}
{{nv ln | c/string/byte/strrchr}}
{{nv col next}}
{{nv ln | c/string/byte/strspn}}
{{nv ln | c/string/byte/strcspn}}
{{nv ln | c/string/byte/strpbrk}}
{{nv ln | c/string/byte/strstr}}
{{nv ln | c/string/byte/strtok}}
{{nv col end}}

{{nv h2 | Memory manipulation}}
{{nv ln | c/string/byte/memchr}}
{{nv ln | c/string/byte/memcmp}}
{{nv ln | c/string/byte/memset}}
{{nv ln | c/string/byte/memcpy}}
{{nv ln | c/string/byte/memmove}}

{{nv h2 | Miscellaneous}}
{{nv ln | c/string/byte/strerror}}
{{nv end}}</text>
      <sha1>gpq061aniw4gfkc793rdj4r63xaclh7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/byte/navbar heading</title>
    <ns>10</ns>
    <id>5921</id>
    <revision>
      <id>35516</id>
      <parentid>21231</parentid>
      <timestamp>2012-06-15T22:27:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/byte/sidebar heading]] to [[Template:c/string/byte/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">[[c/string/byte | Null-terminated byte strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/character classes</title>
    <ns>10</ns>
    <id>5760</id>
    <revision>
      <id>21061</id>
      <timestamp>2012-04-13T00:37:53Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <comment>Created page with &quot;{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:center;&quot; |- ! colspan=&quot;2&quot; | ASCII values &lt;br&gt; (hex) ! characters ! style=&quot;font-size:85%;&quot; | {{ltt|c/string/byte/iscntrl | is...&quot;</comment>
      <text xml:space="preserve" bytes="9241">{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:center;&quot;
|-
! colspan=&quot;2&quot; | ASCII values &lt;br&gt; (hex)
! characters
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/iscntrl | iscntrl}} &lt;br&gt;
{{ltt|c/string/wide/iswcntrl | iswcntrl}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isprint | isprint}} &lt;br&gt;
{{ltt|c/string/wide/iswprint | iswprint}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isspace | isspace}} &lt;br&gt;
{{ltt|c/string/wide/iswspace | iswspace}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isblank | isblank}} &lt;br&gt;
{{ltt|c/string/wide/iswblank | iswblank}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isgraph | isgraph}} &lt;br&gt;
{{ltt|c/string/wide/iswgraph | iswgraph}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/ispunct | ispunct}} &lt;br&gt;
{{ltt|c/string/wide/iswpunct | iswpunct}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isalnum | isalnum}} &lt;br&gt;
{{ltt|c/string/wide/iswalnum | iswalnum}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isalpha | isalpha}} &lt;br&gt;
{{ltt|c/string/wide/iswalpha | iswalpha}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isupper | isupper}} &lt;br&gt;
{{ltt|c/string/wide/iswupper | iswupper}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/islower | islower}} &lt;br&gt;
{{ltt|c/string/wide/iswlower | iswlower}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isdigit | isdigit}} &lt;br&gt;
{{ltt|c/string/wide/iswdigit | iswdigit}}
! style=&quot;font-size:85%;&quot; |
{{ltt|c/string/byte/isxdigit | isxdigit}} &lt;br&gt;
{{ltt|c/string/wide/iswxdigit | iswxdigit}}
|-
| 0  - 8 
| {{tt|0x00-0x08}}
| control codes ({{tt|NUL}}, etc.)
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 9 
| {{tt|0x09}}
| tab ({{tt|\t}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 10  - 13 
| {{tt|0x0A-0x0D}}
| whitespaces ({{tt|\n}},{{tt|\v}},{{tt|\f}},{{tt|\r}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 14 - 31 
| {{tt|0x0E-0x1F}}
| control codes
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 32 
| {{tt|0x20}}
| space
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 33 - 47 
| {{tt|0x21-0x2F}}
| {{tt|!&quot;#$%&amp;'()*+,-./}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 48 - 57 
| {{tt|0x30-0x39}}
| {{tt|0123456789}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}} 
|-
| 58 - 64 
| {{tt|0x3a-0x40}}
| {{tt|:;&lt;{{=}}&gt;?@}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 65 - 70 
| {{tt|0x41-0x46}}
| {{tt|ABCDEF}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}} 
|-
| 71 - 90 
| {{tt|0x47-0x5A}}
| {{tt|GHIJKLMNOPQRSTUVWXYZ}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 91 - 96 
| {{tt|0x5B-0x60}}
| {{tt|[\]&lt;nowiki&gt;^&lt;/nowiki&gt;_`}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 97 -102 
| {{tt|0x61-0x66}}
| {{tt|abcdef}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}} 
|-
| 103-122 
| {{tt|0x67-0x7A}}
| {{tt|ghijklmnopqrstuvwxyz}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 123-126 
| {{tt|0x7B-0x7E}}
| {{tt|{&lt;nowiki&gt;|&lt;/nowiki&gt;}~}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 127 
| {{tt|0x7F}}
| backspace character ({{tt|DEL}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc MB CUR MAX</title>
    <ns>10</ns>
    <id>5805</id>
    <revision>
      <id>54045</id>
      <parentid>52031</parentid>
      <timestamp>2013-06-01T05:08:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list MB CUR MAX]] to [[Template:c/string/multibyte/dsc MB CUR MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc | {{dsc member | nolink=true | MB_CUR_MAX }} | maximum number of bytes in a multibyte character in the current C locale&lt;br/&gt;{{mark|macro variable}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc MB LEN MAX</title>
    <ns>10</ns>
    <id>5806</id>
    <revision>
      <id>54050</id>
      <parentid>52032</parentid>
      <timestamp>2013-06-01T05:08:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list MB LEN MAX]] to [[Template:c/string/multibyte/dsc MB LEN MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc macro const | MB_LEN_MAX | nolink=true | maximum number of bytes in a multibyte character }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc btowc</title>
    <ns>10</ns>
    <id>5807</id>
    <revision>
      <id>54054</id>
      <parentid>52033</parentid>
      <timestamp>2013-06-01T05:08:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list btowc]] to [[Template:c/string/multibyte/dsc btowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | c/string/multibyte/btowc | widens a single-byte narrow character to wide character, if possible}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc c16rtomb</title>
    <ns>10</ns>
    <id>5811</id>
    <revision>
      <id>54059</id>
      <parentid>52034</parentid>
      <timestamp>2013-06-01T05:08:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list c16rtomb]] to [[Template:c/string/multibyte/dsc c16rtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc fun | c/string/multibyte/c16rtomb | convert a 16-bit wide character to narrow multibyte string| notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc c32rtomb</title>
    <ns>10</ns>
    <id>5808</id>
    <revision>
      <id>54065</id>
      <parentid>52035</parentid>
      <timestamp>2013-06-01T05:08:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list c32rtomb]] to [[Template:c/string/multibyte/dsc c32rtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc fun | c/string/multibyte/c32rtomb | convert a 32-bit wide character to narrow multibyte string| notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc char16 t</title>
    <ns>10</ns>
    <id>6524</id>
    <revision>
      <id>54069</id>
      <parentid>52036</parentid>
      <timestamp>2013-06-01T05:08:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list char16 t]] to [[Template:c/string/multibyte/dsc char16 t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc typedef | c/string/multibyte/char16_t | 16-bit character type | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc char32 t</title>
    <ns>10</ns>
    <id>6525</id>
    <revision>
      <id>54074</id>
      <parentid>52037</parentid>
      <timestamp>2013-06-01T05:08:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list char32 t]] to [[Template:c/string/multibyte/dsc char32 t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc typedef | c/string/multibyte/char32_t | 32-bit character type | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mblen</title>
    <ns>10</ns>
    <id>5824</id>
    <revision>
      <id>54080</id>
      <parentid>52038</parentid>
      <timestamp>2013-06-01T05:09:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mblen]] to [[Template:c/string/multibyte/dsc mblen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | c/string/multibyte/mblen  | returns the number of bytes in the next multibyte character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbrlen</title>
    <ns>10</ns>
    <id>5817</id>
    <revision>
      <id>54084</id>
      <parentid>52039</parentid>
      <timestamp>2013-06-01T05:09:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbrlen]] to [[Template:c/string/multibyte/dsc mbrlen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | c/string/multibyte/mbrlen | returns the number of bytes in the next multibyte character, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbrtoc16</title>
    <ns>10</ns>
    <id>5812</id>
    <revision>
      <id>54089</id>
      <parentid>52040</parentid>
      <timestamp>2013-06-01T05:09:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbrtoc16]] to [[Template:c/string/multibyte/dsc mbrtoc16]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc fun | c/string/multibyte/mbrtoc16 | generate the next 16-bit wide character from a narrow multibyte string | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbrtoc32</title>
    <ns>10</ns>
    <id>5810</id>
    <revision>
      <id>54092</id>
      <parentid>52041</parentid>
      <timestamp>2013-06-01T05:09:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbrtoc32]] to [[Template:c/string/multibyte/dsc mbrtoc32]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | c/string/multibyte/mbrtoc32 | generate the next 32-bit wide character from a narrow multibyte string| notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbrtowc</title>
    <ns>10</ns>
    <id>5816</id>
    <revision>
      <id>54096</id>
      <parentid>52042</parentid>
      <timestamp>2013-06-01T05:09:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbrtowc]] to [[Template:c/string/multibyte/dsc mbrtowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | c/string/multibyte/mbrtowc  | converts the next multibyte character to wide character, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbsinit</title>
    <ns>10</ns>
    <id>5819</id>
    <revision>
      <id>54099</id>
      <parentid>52043</parentid>
      <timestamp>2013-06-01T05:09:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbsinit]] to [[Template:c/string/multibyte/dsc mbsinit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/string/multibyte/mbsinit  | checks if the mbstate_t object represents initial shift state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbsrtowcs</title>
    <ns>10</ns>
    <id>5814</id>
    <revision>
      <id>54105</id>
      <parentid>52044</parentid>
      <timestamp>2013-06-01T05:09:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbsrtowcs]] to [[Template:c/string/multibyte/dsc mbsrtowcs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/string/multibyte/mbsrtowcs  | converts a narrow multibyte character string to wide string, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbstate t</title>
    <ns>10</ns>
    <id>5809</id>
    <revision>
      <id>54108</id>
      <parentid>52045</parentid>
      <timestamp>2013-06-01T05:09:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbstate t]] to [[Template:c/string/multibyte/dsc mbstate t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc class | c/string/multibyte/mbstate_t | conversion state information necessary to iterate multibyte character strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbstowcs</title>
    <ns>10</ns>
    <id>5821</id>
    <revision>
      <id>54111</id>
      <parentid>52046</parentid>
      <timestamp>2013-06-01T05:09:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbstowcs]] to [[Template:c/string/multibyte/dsc mbstowcs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | c/string/multibyte/mbstowcs  | converts a narrow multibyte character string to wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc mbtowc</title>
    <ns>10</ns>
    <id>5823</id>
    <revision>
      <id>54115</id>
      <parentid>52047</parentid>
      <timestamp>2013-06-01T05:09:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list mbtowc]] to [[Template:c/string/multibyte/dsc mbtowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | c/string/multibyte/mbtowc  | converts the next multibyte character to wide character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc wcrtomb</title>
    <ns>10</ns>
    <id>5815</id>
    <revision>
      <id>54117</id>
      <parentid>52048</parentid>
      <timestamp>2013-06-01T05:09:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list wcrtomb]] to [[Template:c/string/multibyte/dsc wcrtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | c/string/multibyte/wcrtomb  | converts a wide character to its multibyte representation, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc wcsrtombs</title>
    <ns>10</ns>
    <id>5813</id>
    <revision>
      <id>54119</id>
      <parentid>52049</parentid>
      <timestamp>2013-06-01T05:09:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list wcsrtombs]] to [[Template:c/string/multibyte/dsc wcsrtombs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/string/multibyte/wcsrtombs  | converts a wide string to narrow multibyte character string, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc wcstombs</title>
    <ns>10</ns>
    <id>5820</id>
    <revision>
      <id>54124</id>
      <parentid>52050</parentid>
      <timestamp>2013-06-01T05:09:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list wcstombs]] to [[Template:c/string/multibyte/dsc wcstombs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | c/string/multibyte/wcstombs  | converts a wide string to narrow multibyte character string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc wctob</title>
    <ns>10</ns>
    <id>5818</id>
    <revision>
      <id>54129</id>
      <parentid>52051</parentid>
      <timestamp>2013-06-01T05:09:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list wctob]] to [[Template:c/string/multibyte/dsc wctob]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | c/string/multibyte/wctob | narrows a wide character to a single-byte narrow character, if possible}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/dsc wctomb</title>
    <ns>10</ns>
    <id>5822</id>
    <revision>
      <id>54134</id>
      <parentid>52052</parentid>
      <timestamp>2013-06-01T05:09:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/dcl list wctomb]] to [[Template:c/string/multibyte/dsc wctomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/string/multibyte/wctomb  | converts a wide character to its multibyte representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/navbar</title>
    <ns>10</ns>
    <id>5917</id>
    <revision>
      <id>39853</id>
      <parentid>35517</parentid>
      <timestamp>2012-09-28T19:56:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="235">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/string/navbar heading
|content2 = c/string/navbar content

|heading3 = c/string/multibyte/navbar heading
|content3 = c/string/multibyte/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/navbar content</title>
    <ns>10</ns>
    <id>6363</id>
    <revision>
      <id>52053</id>
      <parentid>39591</parentid>
      <timestamp>2013-06-01T04:39:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="833">{{nv begin}}
{{nv h2 | Wide/multibyte conversions}}
{{nv ln | c/string/multibyte/mbsinit}}
{{nv col begin}}
{{nv ln | c/string/multibyte/mbtowc}}
{{nv ln | c/string/multibyte/mbstowcs}}
{{nv ln | c/string/multibyte/btowc}}
{{nv ln | c/string/multibyte/mbrtowc}}
{{nv ln | c/string/multibyte/mbsrtowcs}}
{{nv ln | c/string/multibyte/mblen}}
{{nv ln | c/string/multibyte/mbrtoc16}}
{{nv ln | c/string/multibyte/c16rtomb}}
{{nv col next}}
{{nv ln | c/string/multibyte/wctomb}}
{{nv ln | c/string/multibyte/wcstombs}}
{{nv ln | c/string/multibyte/wctob}}
{{nv ln | c/string/multibyte/wcrtomb}}
{{nv ln | c/string/multibyte/wcsrtombs}}
{{nv ln | c/string/multibyte/mbrlen}}
{{nv ln | c/string/multibyte/mbrtoc32}}
{{nv ln | c/string/multibyte/c32rtomb}}
{{nv col end}}
{{nv h2 | Types}}
{{nv ln | c/string/multibyte/mbstate_t}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/multibyte/navbar heading</title>
    <ns>10</ns>
    <id>5922</id>
    <revision>
      <id>35518</id>
      <parentid>21232</parentid>
      <timestamp>2012-06-15T22:27:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/multibyte/sidebar heading]] to [[Template:c/string/multibyte/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="58">[[c/string/multibyte | Null-terminated multibyte strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/navbar</title>
    <ns>10</ns>
    <id>5915</id>
    <revision>
      <id>39854</id>
      <parentid>35519</parentid>
      <timestamp>2012-09-28T19:56:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="142">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/string/navbar heading
|content2 = c/string/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/navbar content</title>
    <ns>10</ns>
    <id>5920</id>
    <revision>
      <id>52054</id>
      <parentid>35520</parentid>
      <timestamp>2013-06-01T04:39:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="162">{{nv begin}}
{{nv | [[c/string/byte | Byte strings]] }}
{{nv | [[c/string/multibyte | Multibyte strings]] }}
{{nv | [[c/string/wide | Wide strings]] }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/navbar heading</title>
    <ns>10</ns>
    <id>5919</id>
    <revision>
      <id>35521</id>
      <parentid>21228</parentid>
      <timestamp>2012-06-15T22:27:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/sidebar heading]] to [[Template:c/string/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="30">[[c/string | Strings library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswalnum</title>
    <ns>10</ns>
    <id>5799</id>
    <revision>
      <id>54138</id>
      <parentid>52055</parentid>
      <timestamp>2013-06-01T05:09:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswalnum]] to [[Template:c/string/wide/dsc iswalnum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | c/string/wide/iswalnum | checks if a wide character is alphanumeric}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswalpha</title>
    <ns>10</ns>
    <id>5798</id>
    <revision>
      <id>54141</id>
      <parentid>52056</parentid>
      <timestamp>2013-06-01T05:09:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswalpha]] to [[Template:c/string/wide/dsc iswalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | c/string/wide/iswalpha | checks if a wide character is alphabetic}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswblank</title>
    <ns>10</ns>
    <id>5790</id>
    <revision>
      <id>54145</id>
      <parentid>52057</parentid>
      <timestamp>2013-06-01T05:09:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswblank]] to [[Template:c/string/wide/dsc iswblank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/string/wide/iswblank | checks if a wide character is a blank character|notes={{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswcntrl</title>
    <ns>10</ns>
    <id>5793</id>
    <revision>
      <id>54148</id>
      <parentid>52058</parentid>
      <timestamp>2013-06-01T05:09:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswcntrl]] to [[Template:c/string/wide/dsc iswcntrl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/string/wide/iswcntrl | checks if a wide character is a control character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswctype</title>
    <ns>10</ns>
    <id>5787</id>
    <revision>
      <id>54152</id>
      <parentid>52059</parentid>
      <timestamp>2013-06-01T05:09:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswctype]] to [[Template:c/string/wide/dsc iswctype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc fun | c/string/wide/iswctype | classifies a wide character according to the specified LC_CTYPE category  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswdigit</title>
    <ns>10</ns>
    <id>5795</id>
    <revision>
      <id>54155</id>
      <parentid>52060</parentid>
      <timestamp>2013-06-01T05:09:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswdigit]] to [[Template:c/string/wide/dsc iswdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc fun | c/string/wide/iswdigit | checks if a wide character is a digit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswgraph</title>
    <ns>10</ns>
    <id>5792</id>
    <revision>
      <id>54158</id>
      <parentid>52061</parentid>
      <timestamp>2013-06-01T05:09:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswgraph]] to [[Template:c/string/wide/dsc iswgraph]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | c/string/wide/iswgraph | checks if a wide character is a graphical character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswlower</title>
    <ns>10</ns>
    <id>5797</id>
    <revision>
      <id>54161</id>
      <parentid>52062</parentid>
      <timestamp>2013-06-01T05:09:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswlower]] to [[Template:c/string/wide/dsc iswlower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | c/string/wide/iswlower | checks if a wide character is an lowercase character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswprint</title>
    <ns>10</ns>
    <id>5789</id>
    <revision>
      <id>54167</id>
      <parentid>52063</parentid>
      <timestamp>2013-06-01T05:10:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswprint]] to [[Template:c/string/wide/dsc iswprint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | c/string/wide/iswprint | checks if a wide character is a printing character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswpunct</title>
    <ns>10</ns>
    <id>5788</id>
    <revision>
      <id>54171</id>
      <parentid>52064</parentid>
      <timestamp>2013-06-01T05:10:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswpunct]] to [[Template:c/string/wide/dsc iswpunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | c/string/wide/iswpunct | checks if a wide character is a punctuation character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswspace</title>
    <ns>10</ns>
    <id>5791</id>
    <revision>
      <id>54175</id>
      <parentid>52065</parentid>
      <timestamp>2013-06-01T05:10:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswspace]] to [[Template:c/string/wide/dsc iswspace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | c/string/wide/iswspace | checks if a wide character is a space character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswupper</title>
    <ns>10</ns>
    <id>5796</id>
    <revision>
      <id>54186</id>
      <parentid>52066</parentid>
      <timestamp>2013-06-01T05:10:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswupper]] to [[Template:c/string/wide/dsc iswupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | c/string/wide/iswupper | checks if a wide character is an uppercase character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc iswxdigit</title>
    <ns>10</ns>
    <id>5794</id>
    <revision>
      <id>54190</id>
      <parentid>52067</parentid>
      <timestamp>2013-06-01T05:10:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list iswxdigit]] to [[Template:c/string/wide/dsc iswxdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/string/wide/iswxdigit | checks if a character is a hexadecimal character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc towctrans</title>
    <ns>10</ns>
    <id>5783</id>
    <revision>
      <id>54193</id>
      <parentid>52068</parentid>
      <timestamp>2013-06-01T05:10:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list towctrans]] to [[Template:c/string/wide/dsc towctrans]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | c/string/wide/towctrans | performs character mapping according to the specified LC_CTYPE mapping category }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc towlower</title>
    <ns>10</ns>
    <id>5785</id>
    <revision>
      <id>54198</id>
      <parentid>52069</parentid>
      <timestamp>2013-06-01T05:10:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list towlower]] to [[Template:c/string/wide/dsc towlower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | c/string/wide/towlower | converts a wide character to lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc towupper</title>
    <ns>10</ns>
    <id>5784</id>
    <revision>
      <id>54201</id>
      <parentid>52070</parentid>
      <timestamp>2013-06-01T05:10:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list towupper]] to [[Template:c/string/wide/dsc towupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | c/string/wide/towupper | converts a wide character to uppercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcscat</title>
    <ns>10</ns>
    <id>5774</id>
    <revision>
      <id>54205</id>
      <parentid>52071</parentid>
      <timestamp>2013-06-01T05:10:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcscat]] to [[Template:c/string/wide/dsc wcscat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | c/string/wide/wcscat | appends a copy of one wide string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcschr</title>
    <ns>10</ns>
    <id>5767</id>
    <revision>
      <id>54208</id>
      <parentid>52072</parentid>
      <timestamp>2013-06-01T05:10:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcschr]] to [[Template:c/string/wide/dsc wcschr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/string/wide/wcschr | finds the first occurrence of a wide character in a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcscmp</title>
    <ns>10</ns>
    <id>5770</id>
    <revision>
      <id>54212</id>
      <parentid>52073</parentid>
      <timestamp>2013-06-01T05:10:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcscmp]] to [[Template:c/string/wide/dsc wcscmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc fun | c/string/wide/wcscmp | compares two wide strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcscoll</title>
    <ns>10</ns>
    <id>5768</id>
    <revision>
      <id>54216</id>
      <parentid>52074</parentid>
      <timestamp>2013-06-01T05:10:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcscoll]] to [[Template:c/string/wide/dsc wcscoll]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | c/string/wide/wcscoll | compares two wide strings in accordance to the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcscpy</title>
    <ns>10</ns>
    <id>5776</id>
    <revision>
      <id>54221</id>
      <parentid>52075</parentid>
      <timestamp>2013-06-01T05:10:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcscpy]] to [[Template:c/string/wide/dsc wcscpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | c/string/wide/wcscpy | copies one wide string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcscspn</title>
    <ns>10</ns>
    <id>5764</id>
    <revision>
      <id>54226</id>
      <parentid>52076</parentid>
      <timestamp>2013-06-01T05:10:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcscspn]] to [[Template:c/string/wide/dsc wcscspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | c/string/wide/wcscspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the wide ''not'' found in another wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcslen</title>
    <ns>10</ns>
    <id>5771</id>
    <revision>
      <id>54230</id>
      <parentid>52077</parentid>
      <timestamp>2013-06-01T05:10:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcslen]] to [[Template:c/string/wide/dsc wcslen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | c/string/wide/wcslen | returns the length of a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsncat</title>
    <ns>10</ns>
    <id>5773</id>
    <revision>
      <id>54234</id>
      <parentid>52078</parentid>
      <timestamp>2013-06-01T05:10:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsncat]] to [[Template:c/string/wide/dsc wcsncat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | c/string/wide/wcsncat | appends a certain amount of wide characters from one wide string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsncmp</title>
    <ns>10</ns>
    <id>5769</id>
    <revision>
      <id>54237</id>
      <parentid>52079</parentid>
      <timestamp>2013-06-01T05:10:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsncmp]] to [[Template:c/string/wide/dsc wcsncmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | c/string/wide/wcsncmp | compares a certain amount of characters from two wide strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsncpy</title>
    <ns>10</ns>
    <id>5775</id>
    <revision>
      <id>54241</id>
      <parentid>52080</parentid>
      <timestamp>2013-06-01T05:10:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsncpy]] to [[Template:c/string/wide/dsc wcsncpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc fun | c/string/wide/wcsncpy | copies a certain amount of wide characters from one string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcspbrk</title>
    <ns>10</ns>
    <id>5763</id>
    <revision>
      <id>54244</id>
      <parentid>52081</parentid>
      <timestamp>2013-06-01T05:10:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcspbrk]] to [[Template:c/string/wide/dsc wcspbrk]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | c/string/wide/wcspbrk | finds the first location of any wide character in one wide string, in another wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsrchr</title>
    <ns>10</ns>
    <id>5766</id>
    <revision>
      <id>54248</id>
      <parentid>52082</parentid>
      <timestamp>2013-06-01T05:10:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsrchr]] to [[Template:c/string/wide/dsc wcsrchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/string/wide/wcsrchr | finds the last occurrence of a wide character in a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsspn</title>
    <ns>10</ns>
    <id>5765</id>
    <revision>
      <id>54251</id>
      <parentid>52083</parentid>
      <timestamp>2013-06-01T05:10:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsspn]] to [[Template:c/string/wide/dsc wcsspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc fun | c/string/wide/wcsspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the wide characters found in another wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsstr</title>
    <ns>10</ns>
    <id>5762</id>
    <revision>
      <id>54254</id>
      <parentid>52084</parentid>
      <timestamp>2013-06-01T05:10:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsstr]] to [[Template:c/string/wide/dsc wcsstr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | c/string/wide/wcsstr | finds the first occurrence of a wide string within another wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcstof</title>
    <ns>10</ns>
    <id>5779</id>
    <revision>
      <id>54259</id>
      <parentid>52085</parentid>
      <timestamp>2013-06-01T05:11:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcstof]] to [[Template:c/string/wide/dsc wcstof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | c/string/wide/wcstof | title=wcstof&lt;br&gt;wcstod&lt;br&gt;wcstold | converts a wide string to a floating point value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcstoimax</title>
    <ns>10</ns>
    <id>5777</id>
    <revision>
      <id>54263</id>
      <parentid>52086</parentid>
      <timestamp>2013-06-01T05:11:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcstoimax]] to [[Template:c/string/wide/dsc wcstoimax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc fun | c/string/wide/wcstoimax | title=wcstoimax&lt;br&gt;wcstoumax | converts a wide string to {{c|intmax_t}} or {{c|uintmax_t}} | notes={{mark c99}}&lt;br&gt;{{mark c99}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcstok</title>
    <ns>10</ns>
    <id>5761</id>
    <revision>
      <id>54269</id>
      <parentid>52087</parentid>
      <timestamp>2013-06-01T05:11:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcstok]] to [[Template:c/string/wide/dsc wcstok]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/string/wide/wcstok | finds the next token in a wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcstol</title>
    <ns>10</ns>
    <id>5781</id>
    <revision>
      <id>54273</id>
      <parentid>52088</parentid>
      <timestamp>2013-06-01T05:11:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcstol]] to [[Template:c/string/wide/dsc wcstol]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/string/wide/wcstol | title=wcstol&lt;br&gt;wcstoll | converts a wide string to an integer value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcstoul</title>
    <ns>10</ns>
    <id>5780</id>
    <revision>
      <id>54277</id>
      <parentid>52089</parentid>
      <timestamp>2013-06-01T05:11:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcstoul]] to [[Template:c/string/wide/dsc wcstoul]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc fun | c/string/wide/wcstoul | title=wcstoul&lt;br&gt;wcstoull | converts a wide string to an unsigned integer value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wcsxfrm</title>
    <ns>10</ns>
    <id>5772</id>
    <revision>
      <id>54282</id>
      <parentid>52090</parentid>
      <timestamp>2013-06-01T05:11:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wcsxfrm]] to [[Template:c/string/wide/dsc wcsxfrm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/string/wide/wcsxfrm | transform a wide string so that wcscmp would produce the same result as wcscoll }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wctrans</title>
    <ns>10</ns>
    <id>5782</id>
    <revision>
      <id>54286</id>
      <parentid>52091</parentid>
      <timestamp>2013-06-01T05:11:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wctrans]] to [[Template:c/string/wide/dsc wctrans]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/string/wide/wctrans | looks up a character mapping category in the current C locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wctype</title>
    <ns>10</ns>
    <id>5786</id>
    <revision>
      <id>54292</id>
      <parentid>52092</parentid>
      <timestamp>2013-06-01T05:11:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wctype]] to [[Template:c/string/wide/dsc wctype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | c/string/wide/wctype | looks up a character classification category in the current C locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wmemchr</title>
    <ns>10</ns>
    <id>5801</id>
    <revision>
      <id>54294</id>
      <parentid>52093</parentid>
      <timestamp>2013-06-01T05:11:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wmemchr]] to [[Template:c/string/wide/dsc wmemchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | c/string/wide/wmemchr | finds the first occurrence of a wide character in a wide character array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wmemcmp</title>
    <ns>10</ns>
    <id>5802</id>
    <revision>
      <id>54296</id>
      <parentid>52094</parentid>
      <timestamp>2013-06-01T05:11:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wmemcmp]] to [[Template:c/string/wide/dsc wmemcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | c/string/wide/wmemcmp | compares a certain amount of wide characters from two arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wmemcpy</title>
    <ns>10</ns>
    <id>5804</id>
    <revision>
      <id>54300</id>
      <parentid>52095</parentid>
      <timestamp>2013-06-01T05:11:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wmemcpy]] to [[Template:c/string/wide/dsc wmemcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | c/string/wide/wmemcpy | copies a certain amount of wide characters between two non-overlapping arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wmemmove</title>
    <ns>10</ns>
    <id>5803</id>
    <revision>
      <id>54304</id>
      <parentid>52096</parentid>
      <timestamp>2013-06-01T05:11:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wmemmove]] to [[Template:c/string/wide/dsc wmemmove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc fun | c/string/wide/wmemmove | copies a certain amount of wide characters between two, possibly overlapping, arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/dsc wmemset</title>
    <ns>10</ns>
    <id>5800</id>
    <revision>
      <id>54308</id>
      <parentid>52097</parentid>
      <timestamp>2013-06-01T05:11:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/dcl list wmemset]] to [[Template:c/string/wide/dsc wmemset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | c/string/wide/wmemset | copies the given wide character to every position in a wide character array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/navbar</title>
    <ns>10</ns>
    <id>5918</id>
    <revision>
      <id>39855</id>
      <parentid>35522</parentid>
      <timestamp>2012-09-28T19:56:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="225">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/string/navbar heading
|content2 = c/string/navbar content

|heading3 = c/string/wide/navbar heading
|content3 = c/string/wide/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/navbar content</title>
    <ns>10</ns>
    <id>6362</id>
    <revision>
      <id>52098</id>
      <parentid>35523</parentid>
      <timestamp>2013-06-01T04:40:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1846">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | Character manipulation}}
{{nv col begin}}
{{nv ln | c/string/wide/iswalnum}}
{{nv ln | c/string/wide/iswalpha}}
{{nv ln | c/string/wide/iswlower}}
{{nv ln | c/string/wide/iswupper}}
{{nv ln | c/string/wide/iswdigit}}
{{nv ln | c/string/wide/iswxdigit}}
{{nv ln | c/string/wide/iswblank|notes={{mark c++11}}}}
{{nv ln | c/string/wide/wctype}}
{{nv ln | c/string/wide/iswctype}}
{{nv col next}}
{{nv ln | c/string/wide/iswcntrl}}
{{nv ln | c/string/wide/iswgraph}}
{{nv ln | c/string/wide/iswspace}}
{{nv ln | c/string/wide/iswprint}}
{{nv ln | c/string/wide/iswpunct}}
{{nv ln | c/string/wide/towlower}}
{{nv ln | c/string/wide/towupper}}
{{nv ln | c/string/wide/wctrans}}
{{nv ln | c/string/wide/towctrans}}
{{nv col end}}

{{nv h2 | Conversions to numeric formats}}
{{nv col begin}}
{{nv ln | c/string/wide/wcstol|wcstol|wcstoll}}
{{nv ln | c/string/wide/wcstoul|wcstoul|wcstoull}}
{{nv col next}}
{{nv ln | c/string/wide/wcstof|wcstof|wcstod|wcstold}}
{{nv col end}}

{{nv h2 | String manipulation}}
{{nv col begin}}
{{nv ln | c/string/wide/wcslen}}
{{nv ln | c/string/wide/wcscpy}}
{{nv ln | c/string/wide/wcsncpy}}
{{nv ln | c/string/wide/wcscat}}
{{nv ln | c/string/wide/wcsncat}}
{{nv ln | c/string/wide/wcscmp}}
{{nv ln | c/string/wide/wcscoll}}
{{nv ln | c/string/wide/wcsncmp}}
{{nv col next}}
{{nv ln | c/string/wide/wcsxfrm}}
{{nv ln | c/string/wide/wcschr}}
{{nv ln | c/string/wide/wcsrchr}}
{{nv ln | c/string/wide/wcspbrk}}
{{nv ln | c/string/wide/wcsspn}}
{{nv ln | c/string/wide/wcscspn}}
{{nv ln | c/string/wide/wcsstr}}
{{nv ln | c/string/wide/wcstok}}
{{nv col end}}

{{nv h2 | Array manipulation}}
{{nv ln | c/string/wide/wmemcpy}}
{{nv ln | c/string/wide/wmemmove}}
{{nv ln | c/string/wide/wmemcmp}}
{{nv ln | c/string/wide/wmemchr}}
{{nv ln | c/string/wide/wmemset}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/string/wide/navbar heading</title>
    <ns>10</ns>
    <id>5923</id>
    <revision>
      <id>35524</id>
      <parentid>21233</parentid>
      <timestamp>2012-06-15T22:27:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/string/wide/sidebar heading]] to [[Template:c/string/wide/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">[[c/string/wide | Null-terminated wide strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc ONCE FLAG INIT</title>
    <ns>10</ns>
    <id>9174</id>
    <revision>
      <id>54320</id>
      <parentid>52099</parentid>
      <timestamp>2013-06-01T05:11:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list ONCE FLAG INIT]] to [[Template:c/thread/dsc ONCE FLAG INIT]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc macro const | c/thread/ONCE_FLAG_INIT | initializes a once_flag | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc TSS DTOR ITERATIONS</title>
    <ns>10</ns>
    <id>9189</id>
    <revision>
      <id>54325</id>
      <parentid>52100</parentid>
      <timestamp>2013-06-01T05:11:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list TSS DTOR ITERATIONS]] to [[Template:c/thread/dsc TSS DTOR ITERATIONS]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc macro const | c/thread/TSS_DTOR_ITERATIONS | maximum number of times destructors are called | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc call once</title>
    <ns>10</ns>
    <id>9175</id>
    <revision>
      <id>54327</id>
      <parentid>52101</parentid>
      <timestamp>2013-06-01T05:11:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list call once]] to [[Template:c/thread/dsc call once]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc fun | c/thread/call_once| calls a function exactly once | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd broadcast</title>
    <ns>10</ns>
    <id>9178</id>
    <revision>
      <id>54329</id>
      <parentid>52102</parentid>
      <timestamp>2013-06-01T05:11:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd broadcast]] to [[Template:c/thread/dsc cnd broadcast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc fun | c/thread/cnd_broadcast | unblocks all threads blocked on a condition variable | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd destroy</title>
    <ns>10</ns>
    <id>9181</id>
    <revision>
      <id>54332</id>
      <parentid>52103</parentid>
      <timestamp>2013-06-01T05:11:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd destroy]] to [[Template:c/thread/dsc cnd destroy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | c/thread/cnd_destroy | destroys a condition variable | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd init</title>
    <ns>10</ns>
    <id>9176</id>
    <revision>
      <id>54336</id>
      <parentid>52104</parentid>
      <timestamp>2013-06-01T05:11:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd init]] to [[Template:c/thread/dsc cnd init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | c/thread/cnd_init | creates a condition variable | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd signal</title>
    <ns>10</ns>
    <id>9177</id>
    <revision>
      <id>54338</id>
      <parentid>52105</parentid>
      <timestamp>2013-06-01T05:11:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd signal]] to [[Template:c/thread/dsc cnd signal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | c/thread/cnd_signal | unblocks one thread blocked on a condition variable | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd timedwait</title>
    <ns>10</ns>
    <id>9180</id>
    <revision>
      <id>54341</id>
      <parentid>52106</parentid>
      <timestamp>2013-06-01T05:11:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd timedwait]] to [[Template:c/thread/dsc cnd timedwait]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | c/thread/cnd_timedwait | blocks on a condition variable, with a timeout | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc cnd wait</title>
    <ns>10</ns>
    <id>9179</id>
    <revision>
      <id>54343</id>
      <parentid>52107</parentid>
      <timestamp>2013-06-01T05:11:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list cnd wait]] to [[Template:c/thread/dsc cnd wait]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | c/thread/cnd_wait | blocks on a condition variable | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx destroy</title>
    <ns>10</ns>
    <id>9171</id>
    <revision>
      <id>54346</id>
      <parentid>52108</parentid>
      <timestamp>2013-06-01T05:12:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx destroy]] to [[Template:c/thread/dsc mtx destroy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/thread/mtx_destroy | destroys a mutex | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx init</title>
    <ns>10</ns>
    <id>9166</id>
    <revision>
      <id>54348</id>
      <parentid>52109</parentid>
      <timestamp>2013-06-01T05:12:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx init]] to [[Template:c/thread/dsc mtx init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | c/thread/mtx_init | creates a mutex | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx lock</title>
    <ns>10</ns>
    <id>9167</id>
    <revision>
      <id>54350</id>
      <parentid>52110</parentid>
      <timestamp>2013-06-01T05:12:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx lock]] to [[Template:c/thread/dsc mtx lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | c/thread/mtx_lock | blocks until locks a mutex | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx t</title>
    <ns>10</ns>
    <id>9165</id>
    <revision>
      <id>54353</id>
      <parentid>52111</parentid>
      <timestamp>2013-06-01T05:12:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx t]] to [[Template:c/thread/dsc mtx t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc | {{ttb|mtx_t}} | mutex identifier | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx timedlock</title>
    <ns>10</ns>
    <id>9168</id>
    <revision>
      <id>54355</id>
      <parentid>52112</parentid>
      <timestamp>2013-06-01T05:12:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx timedlock]] to [[Template:c/thread/dsc mtx timedlock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | c/thread/mtx_timedlock | blocks until locks a mutex or times out | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx trylock</title>
    <ns>10</ns>
    <id>9169</id>
    <revision>
      <id>54357</id>
      <parentid>52113</parentid>
      <timestamp>2013-06-01T05:12:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx trylock]] to [[Template:c/thread/dsc mtx trylock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | c/thread/mtx_trylock | locks a mutex or returns without blocking if already locked | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx types</title>
    <ns>10</ns>
    <id>9172</id>
    <revision>
      <id>67311</id>
      <parentid>54359</parentid>
      <timestamp>2014-02-04T15:17:50Z</timestamp>
      <contributor>
        <ip>130.75.117.49</ip>
      </contributor>
      <comment>It's C11, not C++11</comment>
      <text xml:space="preserve" bytes="164">{{dsc enum | c/thread/mtx_types | title=mtx_plain&lt;br&gt;mtx_recursive&lt;br&gt;mtx_timed | defines the type of a mutex | notes={{mark c11}}&lt;br&gt;{{mark c11}}&lt;br&gt;{{mark c11}}}}</text>
      <sha1>45mt3eryotegx4q788hx0a2oehaxmux</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc mtx unlock</title>
    <ns>10</ns>
    <id>9170</id>
    <revision>
      <id>54361</id>
      <parentid>52115</parentid>
      <timestamp>2013-06-01T05:12:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list mtx unlock]] to [[Template:c/thread/dsc mtx unlock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | c/thread/mtx_unlock | unlocks a mutex | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc once flag</title>
    <ns>10</ns>
    <id>9173</id>
    <revision>
      <id>54363</id>
      <parentid>52116</parentid>
      <timestamp>2013-06-01T05:12:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list once flag]] to [[Template:c/thread/dsc once flag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc | {{ttb|once_flag}} | the type of the flag used by call_once | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd create</title>
    <ns>10</ns>
    <id>9153</id>
    <revision>
      <id>54365</id>
      <parentid>52117</parentid>
      <timestamp>2013-06-01T05:12:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd create]] to [[Template:c/thread/dsc thrd create]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | c/thread/thrd_create | creates a thread | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd current</title>
    <ns>10</ns>
    <id>9155</id>
    <revision>
      <id>54367</id>
      <parentid>52118</parentid>
      <timestamp>2013-06-01T05:12:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd current]] to [[Template:c/thread/dsc thrd current]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | c/thread/thrd_current | obtains the current thread identifier | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd detach</title>
    <ns>10</ns>
    <id>9154</id>
    <revision>
      <id>54369</id>
      <parentid>52119</parentid>
      <timestamp>2013-06-01T05:12:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd detach]] to [[Template:c/thread/dsc thrd detach]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc fun | c/thread/thrd_detach | detaches a thread | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd equal</title>
    <ns>10</ns>
    <id>9156</id>
    <revision>
      <id>54371</id>
      <parentid>52120</parentid>
      <timestamp>2013-06-01T05:12:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd equal]] to [[Template:c/thread/dsc thrd equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc fun | c/thread/thrd_equal | checks if two identifiers refer to the same thread | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd errors</title>
    <ns>10</ns>
    <id>9161</id>
    <revision>
      <id>54375</id>
      <parentid>52121</parentid>
      <timestamp>2013-06-01T05:12:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd errors]] to [[Template:c/thread/dsc thrd errors]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc const | c/thread/thrd_errors | title=thrd_success&lt;br&gt;thrd_timedout&lt;br&gt;thrd_busy&lt;br&gt;thrd_nomem&lt;br&gt;thrd_error | indicates a thread error status | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd exit</title>
    <ns>10</ns>
    <id>9157</id>
    <revision>
      <id>54379</id>
      <parentid>52122</parentid>
      <timestamp>2013-06-01T05:12:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd exit]] to [[Template:c/thread/dsc thrd exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | c/thread/thrd_exit | terminates the calling thread | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd join</title>
    <ns>10</ns>
    <id>9158</id>
    <revision>
      <id>54385</id>
      <parentid>52123</parentid>
      <timestamp>2013-06-01T05:12:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd join]] to [[Template:c/thread/dsc thrd join]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | c/thread/thrd_join | blocks until a thread terminates | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd sleep</title>
    <ns>10</ns>
    <id>9159</id>
    <revision>
      <id>54390</id>
      <parentid>52124</parentid>
      <timestamp>2013-06-01T05:12:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd sleep]] to [[Template:c/thread/dsc thrd sleep]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | c/thread/thrd_sleep | suspends execution of the calling thread for the given period of time | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd start t</title>
    <ns>10</ns>
    <id>9164</id>
    <revision>
      <id>54394</id>
      <parentid>52125</parentid>
      <timestamp>2013-06-01T05:12:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd start t]] to [[Template:c/thread/dsc thrd start t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc typedef | nolink=true | thrd_start_t | function pointer type passed to {{c|thrd_create}} | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd t</title>
    <ns>10</ns>
    <id>9163</id>
    <revision>
      <id>54400</id>
      <parentid>52126</parentid>
      <timestamp>2013-06-01T05:12:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd t]] to [[Template:c/thread/dsc thrd t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc | {{ttb|thrd_t}} | a type identifying a thread | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thrd yield</title>
    <ns>10</ns>
    <id>9160</id>
    <revision>
      <id>54404</id>
      <parentid>52127</parentid>
      <timestamp>2013-06-01T05:12:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thrd yield]] to [[Template:c/thread/dsc thrd yield]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | c/thread/thrd_yield | yields the current time slice | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc thread local</title>
    <ns>10</ns>
    <id>9182</id>
    <revision>
      <id>54408</id>
      <parentid>52128</parentid>
      <timestamp>2013-06-01T05:12:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list thread local]] to [[Template:c/thread/dsc thread local]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc macro const | c/thread/thread_local | thread local type macro | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss create</title>
    <ns>10</ns>
    <id>9185</id>
    <revision>
      <id>54412</id>
      <parentid>52129</parentid>
      <timestamp>2013-06-01T05:12:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss create]] to [[Template:c/thread/dsc tss create]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | c/thread/tss_create | creates thread-specific storage pointer with a given destructor | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss delete</title>
    <ns>10</ns>
    <id>9188</id>
    <revision>
      <id>54414</id>
      <parentid>52130</parentid>
      <timestamp>2013-06-01T05:12:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss delete]] to [[Template:c/thread/dsc tss delete]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | c/thread/tss_delete | releases the resources held by a given thread-specific pointer  | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss dtor t</title>
    <ns>10</ns>
    <id>9184</id>
    <revision>
      <id>54417</id>
      <parentid>52131</parentid>
      <timestamp>2013-06-01T05:12:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss dtor t]] to [[Template:c/thread/dsc tss dtor t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc | {{ttb|tss_dtor_t}} | function pointer type used for TSS destructor | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss get</title>
    <ns>10</ns>
    <id>9186</id>
    <revision>
      <id>54421</id>
      <parentid>52132</parentid>
      <timestamp>2013-06-01T05:12:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss get]] to [[Template:c/thread/dsc tss get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | c/thread/tss_get | reads from thread-specific storage | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss set</title>
    <ns>10</ns>
    <id>9187</id>
    <revision>
      <id>54423</id>
      <parentid>52133</parentid>
      <timestamp>2013-06-01T05:12:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss set]] to [[Template:c/thread/dsc tss set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | c/thread/tss_set | write to thread-specific storage | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/dsc tss t</title>
    <ns>10</ns>
    <id>9183</id>
    <revision>
      <id>54426</id>
      <parentid>52134</parentid>
      <timestamp>2013-06-01T05:12:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/dcl list tss t]] to [[Template:c/thread/dsc tss t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc | {{ttb|tss_t}} | thread-specific storage pointer | notes={{mark c11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/navbar</title>
    <ns>10</ns>
    <id>6527</id>
    <revision>
      <id>39856</id>
      <parentid>35525</parentid>
      <timestamp>2012-09-28T19:56:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="143">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/thread/navbar heading
|content2 = c/thread/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/navbar content</title>
    <ns>10</ns>
    <id>9207</id>
    <revision>
      <id>52135</id>
      <parentid>38731</parentid>
      <timestamp>2013-06-01T04:40:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1444">{{nv begin}}
{{nv h1 | Threads}}
{{nv col begin}}
{{nv ln | c/thread/thrd_create}}
{{nv ln | c/thread/thrd_equal}}
{{nv ln | c/thread/thrd_current}}
{{nv ln | c/thread/thrd_sleep}}
{{nv ln | c/thread/thrd_yield}}
{{nv ln | c/thread/thrd_exit}}
{{nv col next}}
{{nv ln | c/thread/thrd_detach}}
{{nv ln | c/thread/thrd_join}}
{{nv ln | c/thread/thrd_errors | thrd_success | thrd_timedout thrd_busy | thrd_nomem | thrd_error}}
{{nv col end}}

{{nv h1 | Mutual exclusion}}
{{nv col begin}}
{{nv ln | c/thread/mtx_init}}
{{nv ln | c/thread/mtx_lock}}
{{nv ln | c/thread/mtx_timedlock}}
{{nv ln | c/thread/mtx_trylock}}
{{nv col next}}
{{nv ln | c/thread/mtx_unlock}}
{{nv ln | c/thread/mtx_destroy}}
{{nv ln | c/thread/mtx_types}}
{{nv col end}}

{{nv h2 | Call once}}
{{nv col begin}}
{{nv ln | c/thread/ONCE_FLAG_INIT}}
{{nv col next}}
{{nv ln | c/thread/call_once}}
{{nv col end}}

{{nv h1 | Condition variables}}
{{nv col begin}}
{{nv ln | c/thread/cnd_init}}
{{nv ln | c/thread/cnd_signal}}
{{nv ln | c/thread/cnd_broadcast}}
{{nv col next}}
{{nv ln | c/thread/cnd_wait}}
{{nv ln | c/thread/cnd_timedwait}}
{{nv ln | c/thread/cnd_destroy}}
{{nv col end}}

{{nv h1 | Thread-local storage}}
{{nv col begin}}
{{nv ln | c/thread/thread_local}}
{{nv ln | c/thread/TSS_DTOR_ITERATIONS}}
{{nv ln | c/thread/tss_create}}
{{nv col next}}
{{nv ln | c/thread/tss_get}}
{{nv ln | c/thread/tss_set}}
{{nv ln | c/thread/tss_delete}}
{{nv col end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/thread/navbar heading</title>
    <ns>10</ns>
    <id>6528</id>
    <revision>
      <id>35526</id>
      <parentid>25714</parentid>
      <timestamp>2012-06-15T22:27:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/thread/sidebar heading]] to [[Template:c/thread/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="37">[[c/thread | Thread support library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/title</title>
    <ns>10</ns>
    <id>5752</id>
    <revision>
      <id>21051</id>
      <timestamp>2012-04-13T00:24:32Z</timestamp>
      <contributor>
        <username>Eendy</username>
        <id>539</id>
      </contributor>
      <comment>copy paste from c++ version</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{ctitle | {{{1|}}} | {{{2|}}} | {{{3|}}} | {{{4|}}} | {{{5|}}} | {{{6|}}} }}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/dsc NULL</title>
    <ns>10</ns>
    <id>6542</id>
    <revision>
      <id>54432</id>
      <parentid>52136</parentid>
      <timestamp>2013-06-01T05:12:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/types/dcl list NULL]] to [[Template:c/types/dsc NULL]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc macro const | c/types/NULL | implementation-defined null pointer constant}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/dsc max align t</title>
    <ns>10</ns>
    <id>9385</id>
    <revision>
      <id>54434</id>
      <parentid>52137</parentid>
      <timestamp>2013-06-01T05:12:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/types/dcl list max align t]] to [[Template:c/types/dsc max align t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc typedef | c/types/max_align_t | a type with alignment requirement as great as any other scalar type | notes={{mark c11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/dsc offsetof</title>
    <ns>10</ns>
    <id>6543</id>
    <revision>
      <id>54441</id>
      <parentid>52138</parentid>
      <timestamp>2013-06-01T05:13:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/types/dcl list offsetof]] to [[Template:c/types/dsc offsetof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc macro fun | c/types/offsetof | byte offset from the beginning of a struct type to specified member}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/dsc ptrdiff t</title>
    <ns>10</ns>
    <id>6544</id>
    <revision>
      <id>54445</id>
      <parentid>52139</parentid>
      <timestamp>2013-06-01T05:13:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/types/dcl list ptrdiff t]] to [[Template:c/types/dsc ptrdiff t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc typedef | c/types/ptrdiff_t | signed integer type returned when subtracting two pointers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/dsc size t</title>
    <ns>10</ns>
    <id>6545</id>
    <revision>
      <id>54451</id>
      <parentid>52140</parentid>
      <timestamp>2013-06-01T05:13:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:c/types/dcl list size t]] to [[Template:c/types/dsc size t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc typedef | c/types/size_t | unsigned integer type returned by the {{ltt|c/language/sizeof | sizeof}} operator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/limits/navbar</title>
    <ns>10</ns>
    <id>9520</id>
    <revision>
      <id>40424</id>
      <parentid>40418</parentid>
      <timestamp>2012-10-13T08:40:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="225">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/types/navbar heading
|content2 = c/types/navbar content

|heading3 = c/types/limits/navbar heading
|content3 = c/types/limits/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/limits/navbar content</title>
    <ns>10</ns>
    <id>9524</id>
    <revision>
      <id>52141</id>
      <parentid>40425</parentid>
      <timestamp>2013-06-01T04:40:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="104">{{nv begin}}
{{nv ln | c/types/limits/FLT_ROUNDS}}
{{nv ln | c/types/limits/FLT_EVAL_METHOD}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/limits/navbar heading</title>
    <ns>10</ns>
    <id>9525</id>
    <revision>
      <id>40426</id>
      <timestamp>2012-10-13T08:41:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="35">[[c/types/limits | Numeric limits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/navbar</title>
    <ns>10</ns>
    <id>9309</id>
    <revision>
      <id>39857</id>
      <parentid>39240</parentid>
      <timestamp>2012-09-28T19:56:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="140">{{navbar
|heading1 = c/navbar heading
|content1 = c/navbar content

|heading2 = c/types/navbar heading
|content2 = c/types/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/navbar content</title>
    <ns>10</ns>
    <id>9526</id>
    <revision>
      <id>52142</id>
      <parentid>40428</parentid>
      <timestamp>2013-06-01T04:40:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="238">{{nv begin}}
{{nv ln | c/types/size_t}}
{{nv ln | c/types/ptrdiff_t}}
{{nv ln | c/types/NULL}}
{{nv ln | c/types/max_align_t | notes={{mark since c11}}}}
{{nv ln | c/types/offsetof}}
{{nv | [[c/types/limits | Numeric limits]]}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/types/navbar heading</title>
    <ns>10</ns>
    <id>9310</id>
    <revision>
      <id>39241</id>
      <timestamp>2012-08-29T22:07:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="26">[[c/types | Type support]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/variadic/dsc va arg</title>
    <ns>10</ns>
    <id>13687</id>
    <revision>
      <id>71739</id>
      <timestamp>2014-06-22T13:13:50Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>new template for va_arg</comment>
      <text xml:space="preserve" bytes="84">{{dsc macro fun | c/variadic/va_arg | accesses the next variadic function argument}}</text>
      <sha1>3ez97toc3h2yr42osp3soxweihy8gte</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/variadic/dsc va copy</title>
    <ns>10</ns>
    <id>13688</id>
    <revision>
      <id>71770</id>
      <parentid>71769</parentid>
      <timestamp>2014-06-23T20:20:47Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>deleted extra '/'</comment>
      <text xml:space="preserve" bytes="109">{{dsc macro fun | c/variadic/va_copy | makes a copy of the variadic function arguments | notes={{mark c99}}}}</text>
      <sha1>mau1huw0dnu7t0fwdtrqrpth7k3xo52</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/variadic/dsc va end</title>
    <ns>10</ns>
    <id>13689</id>
    <revision>
      <id>71743</id>
      <timestamp>2014-06-22T17:35:45Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>new template for va_end</comment>
      <text xml:space="preserve" bytes="89">{{dsc macro fun | c/variadic/va_end | ends traversal of the variadic function arguments}}</text>
      <sha1>oot4sz3jo2o9uh2wdqbtv4cl20tpqzz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/variadic/dsc va list</title>
    <ns>10</ns>
    <id>13685</id>
    <revision>
      <id>71744</id>
      <parentid>71735</parentid>
      <timestamp>2014-06-22T18:47:08Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <minor/>
      <comment>replaced class with typedef</comment>
      <text xml:space="preserve" bytes="108">{{dsc typedef | c/variadic/va_list | holds the information needed by va_start, va_arg, va_end, and va_copy}}</text>
      <sha1>c9ay0p94bprh3jpwdij8zjp8eds3ti4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:c/variadic/dsc va start</title>
    <ns>10</ns>
    <id>13686</id>
    <revision>
      <id>71738</id>
      <timestamp>2014-06-22T12:59:31Z</timestamp>
      <contributor>
        <username>Newatthis</username>
        <id>2723</id>
      </contributor>
      <comment>new template for va_start</comment>
      <text xml:space="preserve" bytes="87">{{dsc macro fun | c/variadic/va_start | enables access to variadic function arguments}}</text>
      <sha1>i6be6or37y7lx5zsiimlwe2z1t7z638</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cast req1</title>
    <ns>10</ns>
    <id>1806</id>
    <revision>
      <id>24607</id>
      <parentid>3612</parentid>
      <timestamp>2012-04-20T05:59:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{cpp|&quot; to &quot;{{c|&quot;</comment>
      <text xml:space="preserve" bytes="456">{{#if: {{{p1|}}}
 | The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{p1}}}}} can be dereferenced and then implicitly converted to {{c|{{{1}}}}}.&lt;!--
--&gt;| {{#if: {{{t1|}}}&lt;!--
   --&gt;| The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{t1}}}}} can be implicitly converted to {{c|{{{1}}}}}.&lt;!--
   --&gt;| {{error|requirement not defined}}&lt;!--
   --&gt;}}&lt;!--
--&gt;}}&lt;noinclude&gt;{{documentation | content={{cast rreq/doc}}}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cast req2</title>
    <ns>10</ns>
    <id>1807</id>
    <revision>
      <id>24608</id>
      <parentid>3614</parentid>
      <timestamp>2012-04-20T05:59:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{cpp|&quot; to &quot;{{c|&quot;</comment>
      <text xml:space="preserve" bytes="1741">{{#if:{{{t2|}}}
 |{{#if:{{{t1|}}} 
   | &lt;!--t1t2--&gt; The types {{c|{{{1}}}}} and {{c|{{{2}}}}} must be such that objects of types {{c|{{{t1}}}}} and {{c|{{{t2}}}}} can be implicitly converted to {{c|{{{1}}}}} and {{c|{{{2}}}}} respectively.
   |{{#if:{{{p1|}}}
     | &lt;!--p1t2--&gt; The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{p1}}}}} can be dereferenced and then implicitly converted to {{c|{{{1}}}}}. The type {{c|{{{2}}}}} must be such that an object of type {{c|{{{t2}}}}} can be implicitly converted to {{c|{{{2}}}}}.
     | {{error|requirement not defined}}
    }}
  }}
 |{{#if:{{{p2|}}}
   |{{#if:{{{t1|}}} 
     | &lt;!--t1p2--&gt; The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{t1}}}}} can be implicitly converted to {{c|{{{1}}}}}. The type {{c|{{{2}}}}} must be such that an object of type {{c|{{{p2}}}}} can be dereferenced and then implicitly converted to {{c|{{{2}}}}}.
     |{{#if:{{{p1|}}}
       | &lt;!--p1p2--&gt; The types {{c|{{{1}}}}} and {{c|{{{2}}}}} must be such that objects of types {{c|{{{p1}}}}} and {{c|{{{p2}}}}} can be dereferenced and then implicitly converted to {{c|{{{1}}}}} and {{c|{{{2}}}}} respectively.
       | {{error|requirement not defined}}
      }}
    }}
   |{{#if:{{{t1|}}} 
     | &lt;!--t1t1--&gt; The types {{c|{{{1}}}}} and {{c|{{{2}}}}} must be such that an object of type {{c|{{{t1}}}}} can be implicitly converted to both of them.
     |{{#if:{{{p1|}}}
       | &lt;!--p1p1--&gt; The types {{c|{{{1}}}}} and {{c|{{{2}}}}} must be such that an object of type {{c|{{{p1}}}}} can be dereferenced and then implicitly converted to both of them.
       | {{error|requirement not defined}}
      }}
    }}
  }}
}}&lt;noinclude&gt;{{documentation | content={{cast rreq/doc}}}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cast rreq</title>
    <ns>10</ns>
    <id>1808</id>
    <revision>
      <id>24609</id>
      <parentid>3945</parentid>
      <timestamp>2012-04-20T05:59:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{cpp|&quot; to &quot;{{c|&quot;</comment>
      <text xml:space="preserve" bytes="393">{{#if: {{{rp|}}}
 | The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{rp}}}}} can be dereferenced and assigned a value of type {{c|{{{1}}}}}.
 | {{#if: {{{rt|}}}
    | The type {{c|{{{1}}}}} must be such that an object of type {{c|{{{rt}}}}} can be assigned a value of type {{c|{{{1}}}}}.
    | {{error|requirement not defined}}
   }}
}}&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cast rreq/doc</title>
    <ns>10</ns>
    <id>1809</id>
    <revision>
      <id>23852</id>
      <parentid>3618</parentid>
      <timestamp>2012-04-20T03:37:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{cpp|&quot; to &quot;{{c|&quot;</comment>
      <text xml:space="preserve" bytes="1229">This is one of the templates used to specify that some type must be convertible to another. All these templates can emit either of the requirements that it must be possible to convert an object of particular type to another type or it must be possible to dereference an object of particular type and then convert it to another type. This behavior depends an the supplied parameters ({{tt|t}} means plain type, {{tt|p}} - type that must be dereferenced first).

{{tl|cast rreq | ''base_type'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type''}} - ''base_type'' must be convertible to {{c|rt}} or {{c|*rp}}.

{{tl|cast req1 | ''base_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type''}} - {{tt|t1}} or {{tt|*p1}} must be convertible to ''base_type''.

{{tl|cast req2 | ''base_type1'' | ''base_type2'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{small|(optional)}}}} - {{tt|t1}} or {{tt|*p1}} must be convertible to ''base_type1'' or {{tt|t2}} or {{tt|*p2}} must be convertible to ''base_type2''. If neither {{tt|t2}} nor {{tt|p2}} is supplied, it is assumed that {{tt|t1}} or {{tt|*p1}} must be convertible to both ''base_type1'' or ''base_type2''.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cat handler</title>
    <ns>10</ns>
    <id>1810</id>
    <revision>
      <id>20018</id>
      <parentid>3620</parentid>
      <timestamp>2012-03-19T18:30:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="3223">{{#if:
  {{#ifeq: {{lc: {{{nocat|}}} }} | true
  | dontcat    &lt;!--&quot;nocat=true&quot;, don't categorize--&gt;
  }}{{#ifeq: {{lc: {{{categories|}}} }} | no
  | dontcat
  }}{{#switch: {{lc: {{{category2|¬}}} }}
  | yes
  | ¬   =   &lt;!--Not defined--&gt;
  | #default = dontcat   &lt;!--&quot;category2 = no/'defined but empty'/'anything'&quot;--&gt;
  }}{{#switch: {{lc: {{{subpage|}}} }}
  | no = 
    {{basepage subpage
    | 
    | dontcat    &lt;!--&quot;subpage=no&quot; and on a subpage--&gt;
    | page = {{{page|}}}   &lt;!--For testing--&gt;
    }}
  | only = 
    {{basepage subpage
    | dontcat    &lt;!--&quot;subpage=only&quot; and not on a subpage--&gt;
    | page = {{{page|}}}   &lt;!--For testing--&gt;
    }}
  }}

|   &lt;!--Don't categorise (result was &quot;dontcat&quot; or &quot;dontcatdontcat&quot; and so on)--&gt;
| &lt;!--Check blacklist--&gt;
  {{#switch:
    {{#ifeq: {{lc: {{{nocat|}}} }} | false
    |   &lt;!--&quot;nocat=false&quot;, skip blacklist check--&gt;
    | {{#ifeq: {{lc: {{{categories|}}} }} | yes
      |   &lt;!--Skip blacklist check--&gt;
      | {{#ifeq: {{lc: {{{category2|}}} }} | yes
        |   &lt;!--Skip blacklist check--&gt;
        | {{cat handler/blacklist| page = {{{page|}}} }}   &lt;!--Check blacklist--&gt;
        }}
      }}
    }}
  | hide = &lt;!--Blacklist returned &quot;hide&quot;, don't categorize--&gt;
  | #default  = 
    &lt;!--Check if any namespace parameter is defined--&gt;
    {{#ifeq: h0#384!5nea+w9 | {{{all| {{{main| {{{talk| {{{user| {{{wikipedia| {{{file| {{{mediawiki| {{{template| {{{help| {{{category| {{{portal| {{{book| {{{other| h0#384!5nea+w9 }}} }}} }}} }}} }}} }}} }}} }}} }}} }}} }}} }}} }}}
    | &lt;!--No namespace parameters fed, basic usage--&gt;
      {{namespace detect
      | main = {{{1|}}}
      | file = {{{1|}}}
      | help = {{{1|}}}
      | category = {{{1|}}}
      | portal = {{{1|}}}
      | book = {{{1|}}}
      | page = {{{page|}}}   &lt;!--For testing and demonstration--&gt;
      }}
    | &lt;!--Namespace parameters fed, advanced usage.
          If &quot;data&quot; is a number, return the corresponding 
          numbered parameter, else return &quot;data&quot;.  --&gt;
      {{{all|}}}{{cat handler/numbered
      | 1 = {{{1|}}}
      | 2 = {{{2|}}}
      | 3 = {{{3|}}}
      | 4 = {{{4|}}}
      | 5 = {{{5|}}}
      | 6 = {{{6|}}}
      | 7 = {{{7|}}}
      | 8 = {{{8|}}}
      | 9 = {{{9|}}}
      | 10 = {{{10|}}}
      | data = 
        &lt;!--Check what namespace, and return the data for it.
            Respecting empty parameters on purpose.  --&gt;
        {{namespace detect
        | main = {{{main| {{{other|}}} }}}
        | talk = {{{talk| {{{other|}}} }}}
        | user = {{{user| {{{other|}}} }}}
        | wikipedia = {{{wikipedia| {{{project| {{{other|}}} }}} }}}
        | file = {{{file| {{{image| {{{other|}}} }}} }}}
        | mediawiki = {{{mediawiki| {{{other|}}} }}}
        | template = {{{template| {{{other|}}} }}}
        | help = {{{help| {{{other|}}} }}}
        | category = {{{category| {{{other|}}} }}}
        | portal = {{{portal| {{{other|}}} }}}
        | book = {{{book| {{{other|}}} }}}
        | other = {{{other|}}}  &lt;!--Namespace special or a new namespace--&gt;
        | page = {{{page|}}}   &lt;!--For testing and demonstration--&gt;
        }}
      }}
    }}
  }}
}}&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cat handler/blacklist</title>
    <ns>10</ns>
    <id>1811</id>
    <revision>
      <id>3622</id>
      <parentid>3621</parentid>
      <timestamp>2011-06-06T23:01:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cat handler/numbered</title>
    <ns>10</ns>
    <id>1812</id>
    <revision>
      <id>20016</id>
      <parentid>3624</parentid>
      <timestamp>2012-03-19T18:30:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="278">{{#iferror: {{#expr: 1 + {{{data|}}} }} 
| {{{data|}}}   &lt;!--Not a number, return &quot;data&quot; as is--&gt; 
| {{{ {{{data|}}} |}}}   &lt;!--&quot;data&quot; is a number, return that numbered parameter--&gt;
}}&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cc</title>
    <ns>10</ns>
    <id>10091</id>
    <revision>
      <id>48003</id>
      <parentid>47984</parentid>
      <timestamp>2013-05-18T16:42:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>force inline</comment>
      <text xml:space="preserve" bytes="177">&lt;onlyinclude&gt;&lt;span class=&quot;t-cc&quot;&gt;{{#tag:source|{{{code|{{{1}}}}}}|lang={{{lang|{{{2|{{get_lang}}}}}}}}|enclose=none}}&lt;/span&gt;&lt;/onlyinclude&gt;
{{documentation | Template:source/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:center</title>
    <ns>10</ns>
    <id>1813</id>
    <revision>
      <id>3626</id>
      <parentid>3625</parentid>
      <timestamp>2011-06-06T23:01:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="159">&lt;includeonly&gt;&lt;div class=&quot;center&quot; style=&quot;width:auto; margin-left:auto; margin-right:auto;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:center/doc</title>
    <ns>10</ns>
    <id>2747</id>
    <revision>
      <id>10400</id>
      <timestamp>2011-09-10T20:11:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="224">Aligns a snippet of text passed as the first unnamed parameter

{{tl|left|''text''}} - aligns ''text'' to the left

{{tl|center|''text''}} - aligns ''text'' to the center

{{tl|right|''text''}} - aligns ''text'' to the right</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cmark</title>
    <ns>10</ns>
    <id>1814</id>
    <revision>
      <id>17981</id>
      <parentid>13150</parentid>
      <timestamp>2012-01-19T23:34:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorter css class name (we ship at least 1.5MB just for that word)</comment>
      <text xml:space="preserve" bytes="90">&lt;span class=&quot;t-cmark&quot; &gt;[{{trim|{{{1}}}}}]&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cmark/doc</title>
    <ns>10</ns>
    <id>1815</id>
    <revision>
      <id>3630</id>
      <parentid>3629</parentid>
      <timestamp>2011-06-06T23:01:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="230">Creates an annotation for a function. Several annotations are already defined: 

{{tl|cmark virtual}} results in {{cmark virtual}}

{{tl|cmark static}} results in {{cmark static}}

{{tl|cmark deleted}} results in {{cmark deleted}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cmark deleted</title>
    <ns>10</ns>
    <id>1816</id>
    <revision>
      <id>3940</id>
      <parentid>3632</parentid>
      <timestamp>2011-06-10T19:57:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:cmark deleted]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="80">{{cmark|deleted}}&lt;noinclude&gt;
{{documentation | Template:cmark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cmark static</title>
    <ns>10</ns>
    <id>1817</id>
    <revision>
      <id>3937</id>
      <parentid>3634</parentid>
      <timestamp>2011-06-10T19:56:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:cmark static]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="79">{{cmark|static}}&lt;noinclude&gt;
{{documentation | Template:cmark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cmark virtual</title>
    <ns>10</ns>
    <id>1818</id>
    <revision>
      <id>3939</id>
      <parentid>3636</parentid>
      <timestamp>2011-06-10T19:57:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:cmark virtual]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="80">{{cmark|virtual}}&lt;noinclude&gt;
{{documentation | Template:cmark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:concept</title>
    <ns>10</ns>
    <id>5429</id>
    <revision>
      <id>39826</id>
      <parentid>38365</parentid>
      <timestamp>2012-09-28T17:47:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt -&gt; code</comment>
      <text xml:space="preserve" bytes="136">{{#if: {{{1|}}} |[[cpp/concept/{{trim|{{{1|}}}}}|&lt;code&gt;{{trim|{{{1|}}}}}&lt;/code&gt;]]| {{error|no concept given}} }}&lt;noinclude&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp//title</title>
    <ns>10</ns>
    <id>1827</id>
    <revision>
      <id>3654</id>
      <parentid>3653</parentid>
      <timestamp>2011-06-06T23:01:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="134">&lt;onlyinclude&gt;{{cpp/title | n=&amp;#123;&amp;#123;&amp;#123;1&amp;#125;&amp;#125;&amp;#125;::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc accumulate</title>
    <ns>10</ns>
    <id>1828</id>
    <revision>
      <id>54453</id>
      <parentid>52143</parentid>
      <timestamp>2013-06-01T05:13:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list accumulate]] to [[Template:cpp/algorithm/dsc accumulate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc tfun | cpp/algorithm/accumulate | sums up a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc adjacent difference</title>
    <ns>10</ns>
    <id>1829</id>
    <revision>
      <id>54455</id>
      <parentid>52144</parentid>
      <timestamp>2013-06-01T05:13:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list adjacent difference]] to [[Template:cpp/algorithm/dsc adjacent difference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tfun | cpp/algorithm/adjacent_difference | computes the differences between adjacent elements in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc adjacent find</title>
    <ns>10</ns>
    <id>1830</id>
    <revision>
      <id>71756</id>
      <parentid>54458</parentid>
      <timestamp>2014-06-23T05:21:18Z</timestamp>
      <contributor>
        <username>Jeremy murphy</username>
        <id>3174</id>
      </contributor>
      <comment>Change wording to use &quot;equality&quot; not &quot;identity&quot;; specify that it is the _first_ two adjacent items; use more technical terminology.</comment>
      <text xml:space="preserve" bytes="126">{{dsc tfun | cpp/algorithm/adjacent_find | finds the first two adjacent items that are equal (or satisfy a given predicate) }}</text>
      <sha1>6cnqoin1vk19txa657136s755z1imu9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc all any none of</title>
    <ns>10</ns>
    <id>1831</id>
    <revision>
      <id>54460</id>
      <parentid>52146</parentid>
      <timestamp>2013-06-01T05:13:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list all any none of]] to [[Template:cpp/algorithm/dsc all any none of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="225">{{dsc tfun | cpp/algorithm/all_any_none_of | title=all_of&lt;br&gt;any_of&lt;br&gt;none_of | checks if a predicate is {{c|true}} for all, any or none of the elements in a range |notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc binary search</title>
    <ns>10</ns>
    <id>1832</id>
    <revision>
      <id>54465</id>
      <parentid>52147</parentid>
      <timestamp>2013-06-01T05:13:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list binary search]] to [[Template:cpp/algorithm/dsc binary search]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc tfun | cpp/algorithm/binary_search | determines if an element exists in a certain range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc bsearch</title>
    <ns>10</ns>
    <id>1833</id>
    <revision>
      <id>54469</id>
      <parentid>52148</parentid>
      <timestamp>2013-06-01T05:13:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list bsearch]] to [[Template:cpp/algorithm/dsc bsearch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/algorithm/bsearch | searches an array for an element of unspecified type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc copy</title>
    <ns>10</ns>
    <id>1834</id>
    <revision>
      <id>54473</id>
      <parentid>52149</parentid>
      <timestamp>2013-06-01T05:13:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list copy]] to [[Template:cpp/algorithm/dsc copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tfun | cpp/algorithm/copy | copies a range of elements to a new location | title=copy&lt;br&gt;copy_if | notes=&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc copy backward</title>
    <ns>10</ns>
    <id>1835</id>
    <revision>
      <id>54476</id>
      <parentid>52150</parentid>
      <timestamp>2013-06-01T05:13:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list copy backward]] to [[Template:cpp/algorithm/dsc copy backward]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tfun | cpp/algorithm/copy_backward | copies a range of elements in backwards order }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc copy n</title>
    <ns>10</ns>
    <id>2437</id>
    <revision>
      <id>54478</id>
      <parentid>52151</parentid>
      <timestamp>2013-06-01T05:13:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list copy n]] to [[Template:cpp/algorithm/dsc copy n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tfun | cpp/algorithm/copy_n | copies a number of elements to a new location | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc count</title>
    <ns>10</ns>
    <id>1836</id>
    <revision>
      <id>54481</id>
      <parentid>52152</parentid>
      <timestamp>2013-06-01T05:13:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list count]] to [[Template:cpp/algorithm/dsc count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/algorithm/count | title=count&lt;br&gt;count_if | returns the number of elements satisfying specific criteria }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc equal</title>
    <ns>10</ns>
    <id>1837</id>
    <revision>
      <id>54485</id>
      <parentid>52153</parentid>
      <timestamp>2013-06-01T05:13:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list equal]] to [[Template:cpp/algorithm/dsc equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc tfun | cpp/algorithm/equal | determines if two sets of elements are the same }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc equal range</title>
    <ns>10</ns>
    <id>1838</id>
    <revision>
      <id>54489</id>
      <parentid>52154</parentid>
      <timestamp>2013-06-01T05:13:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list equal range]] to [[Template:cpp/algorithm/dsc equal range]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tfun | cpp/algorithm/equal_range | returns range of elements matching a specific key}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc fill</title>
    <ns>10</ns>
    <id>1839</id>
    <revision>
      <id>54491</id>
      <parentid>52155</parentid>
      <timestamp>2013-06-01T05:13:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list fill]] to [[Template:cpp/algorithm/dsc fill]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc tfun | cpp/algorithm/fill | assigns a range of elements a certain value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc fill n</title>
    <ns>10</ns>
    <id>1840</id>
    <revision>
      <id>54494</id>
      <parentid>52156</parentid>
      <timestamp>2013-06-01T05:13:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list fill n]] to [[Template:cpp/algorithm/dsc fill n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc tfun | cpp/algorithm/fill_n | assigns a value to a number of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc find</title>
    <ns>10</ns>
    <id>1841</id>
    <revision>
      <id>54498</id>
      <parentid>52157</parentid>
      <timestamp>2013-06-01T05:13:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list find]] to [[Template:cpp/algorithm/dsc find]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc tfun | cpp/algorithm/find | title=find&lt;br&gt;find_if&lt;br&gt;find_if_not | finds the first element satisfying specific criteria | notes=&lt;br&gt;&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc find end</title>
    <ns>10</ns>
    <id>1842</id>
    <revision>
      <id>54500</id>
      <parentid>52158</parentid>
      <timestamp>2013-06-01T05:13:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list find end]] to [[Template:cpp/algorithm/dsc find end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tfun | cpp/algorithm/find_end | finds the last sequence of elements in a certain range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc find first of</title>
    <ns>10</ns>
    <id>1843</id>
    <revision>
      <id>54503</id>
      <parentid>52159</parentid>
      <timestamp>2013-06-01T05:13:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list find first of]] to [[Template:cpp/algorithm/dsc find first of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tfun | cpp/algorithm/find_first_of | searches for any one of a set of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc for each</title>
    <ns>10</ns>
    <id>1844</id>
    <revision>
      <id>54509</id>
      <parentid>52160</parentid>
      <timestamp>2013-06-01T05:13:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list for each]] to [[Template:cpp/algorithm/dsc for each]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc tfun | cpp/algorithm/for_each | applies a function to a range of elements}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc generate</title>
    <ns>10</ns>
    <id>1845</id>
    <revision>
      <id>54513</id>
      <parentid>52161</parentid>
      <timestamp>2013-06-01T05:13:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list generate]] to [[Template:cpp/algorithm/dsc generate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc tfun | cpp/algorithm/generate | saves the result of a function in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc generate n</title>
    <ns>10</ns>
    <id>1846</id>
    <revision>
      <id>54517</id>
      <parentid>52162</parentid>
      <timestamp>2013-06-01T05:13:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list generate n]] to [[Template:cpp/algorithm/dsc generate n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tfun | cpp/algorithm/generate_n | saves the result of N applications of a function }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc includes</title>
    <ns>10</ns>
    <id>1847</id>
    <revision>
      <id>54520</id>
      <parentid>52163</parentid>
      <timestamp>2013-06-01T05:13:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list includes]] to [[Template:cpp/algorithm/dsc includes]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tfun | cpp/algorithm/includes | returns true if one set is a subset of another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc inner product</title>
    <ns>10</ns>
    <id>1848</id>
    <revision>
      <id>54526</id>
      <parentid>52164</parentid>
      <timestamp>2013-06-01T05:13:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list inner product]] to [[Template:cpp/algorithm/dsc inner product]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc tfun | cpp/algorithm/inner_product | computes the inner product of two ranges of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc inplace merge</title>
    <ns>10</ns>
    <id>1849</id>
    <revision>
      <id>54529</id>
      <parentid>52165</parentid>
      <timestamp>2013-06-01T05:13:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list inplace merge]] to [[Template:cpp/algorithm/dsc inplace merge]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc tfun | cpp/algorithm/inplace_merge | merges two ordered ranges in-place }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc iota</title>
    <ns>10</ns>
    <id>2436</id>
    <revision>
      <id>54531</id>
      <parentid>52166</parentid>
      <timestamp>2013-06-01T05:14:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list iota]] to [[Template:cpp/algorithm/dsc iota]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc tfun | cpp/algorithm/iota | fills a range with successive increments of the starting value | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is heap</title>
    <ns>10</ns>
    <id>1850</id>
    <revision>
      <id>66011</id>
      <parentid>63741</parentid>
      <timestamp>2013-10-21T05:21:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c++11</comment>
      <text xml:space="preserve" bytes="101">{{dsc tfun | cpp/algorithm/is_heap | checks if the given range is a max heap| notes={{mark c++11}} }}</text>
      <sha1>0521c5c3rk6gs6ptjfm1r7mqp7v2w0n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is heap until</title>
    <ns>10</ns>
    <id>1851</id>
    <revision>
      <id>63742</id>
      <parentid>54536</parentid>
      <timestamp>2013-07-23T19:55:23Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;, cf. talk:cpp/algorithm/notes heap</comment>
      <text xml:space="preserve" bytes="113">{{dsc tfun | cpp/algorithm/is_heap_until | finds the largest subrange that is a max heap | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is partitioned</title>
    <ns>10</ns>
    <id>2434</id>
    <revision>
      <id>54538</id>
      <parentid>52169</parentid>
      <timestamp>2013-06-01T05:14:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list is partitioned]] to [[Template:cpp/algorithm/dsc is partitioned]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/algorithm/is_partitioned | determines if the range is partitioned by the given predicate | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is permutation</title>
    <ns>10</ns>
    <id>2431</id>
    <revision>
      <id>54540</id>
      <parentid>52170</parentid>
      <timestamp>2013-06-01T05:14:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list is permutation]] to [[Template:cpp/algorithm/dsc is permutation]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/algorithm/is_permutation | determines if a sequence is a permutation of another sequence | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is sorted</title>
    <ns>10</ns>
    <id>1852</id>
    <revision>
      <id>54542</id>
      <parentid>52171</parentid>
      <timestamp>2013-06-01T05:14:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list is sorted]] to [[Template:cpp/algorithm/dsc is sorted]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc tfun | cpp/algorithm/is_sorted | checks whether a range is sorted into ascending order | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc is sorted until</title>
    <ns>10</ns>
    <id>1853</id>
    <revision>
      <id>54544</id>
      <parentid>52172</parentid>
      <timestamp>2013-06-01T05:14:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list is sorted until]] to [[Template:cpp/algorithm/dsc is sorted until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc tfun | cpp/algorithm/is_sorted_until | finds the largest sorted subrange | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc iter swap</title>
    <ns>10</ns>
    <id>1854</id>
    <revision>
      <id>54546</id>
      <parentid>52173</parentid>
      <timestamp>2013-06-01T05:14:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list iter swap]] to [[Template:cpp/algorithm/dsc iter swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc tfun | cpp/algorithm/iter_swap | swaps the elements pointed to by two iterators }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc lexicographical compare</title>
    <ns>10</ns>
    <id>1855</id>
    <revision>
      <id>54548</id>
      <parentid>52174</parentid>
      <timestamp>2013-06-01T05:14:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list lexicographical compare]] to [[Template:cpp/algorithm/dsc lexicographical compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc tfun | cpp/algorithm/lexicographical_compare | returns true if one range is lexicographically less than another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc lower bound</title>
    <ns>10</ns>
    <id>1856</id>
    <revision>
      <id>54550</id>
      <parentid>52175</parentid>
      <timestamp>2013-06-01T05:14:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list lower bound]] to [[Template:cpp/algorithm/dsc lower bound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc tfun | cpp/algorithm/lower_bound | returns an iterator to the first element ''not less'' than the given value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc make heap</title>
    <ns>10</ns>
    <id>1857</id>
    <revision>
      <id>63743</id>
      <parentid>54552</parentid>
      <timestamp>2013-07-23T19:55:30Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;, cf. talk:cpp/algorithm/notes heap</comment>
      <text xml:space="preserve" bytes="87">{{dsc tfun | cpp/algorithm/make_heap | creates a max heap out of a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc max</title>
    <ns>10</ns>
    <id>1858</id>
    <revision>
      <id>54554</id>
      <parentid>52177</parentid>
      <timestamp>2013-06-01T05:14:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list max]] to [[Template:cpp/algorithm/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc tfun | cpp/algorithm/max | returns the larger of two elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc max element</title>
    <ns>10</ns>
    <id>1859</id>
    <revision>
      <id>54558</id>
      <parentid>52178</parentid>
      <timestamp>2013-06-01T05:14:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list max element]] to [[Template:cpp/algorithm/dsc max element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc tfun | cpp/algorithm/max_element | returns the largest element in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc merge</title>
    <ns>10</ns>
    <id>1860</id>
    <revision>
      <id>54564</id>
      <parentid>52179</parentid>
      <timestamp>2013-06-01T05:14:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list merge]] to [[Template:cpp/algorithm/dsc merge]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc tfun | cpp/algorithm/merge | merges two sorted ranges }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc min</title>
    <ns>10</ns>
    <id>1861</id>
    <revision>
      <id>54568</id>
      <parentid>52180</parentid>
      <timestamp>2013-06-01T05:14:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list min]] to [[Template:cpp/algorithm/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc tfun | cpp/algorithm/min | returns the smaller of two elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc min element</title>
    <ns>10</ns>
    <id>1862</id>
    <revision>
      <id>54571</id>
      <parentid>52181</parentid>
      <timestamp>2013-06-01T05:14:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list min element]] to [[Template:cpp/algorithm/dsc min element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc tfun | cpp/algorithm/min_element | returns the smallest element in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc minmax</title>
    <ns>10</ns>
    <id>2429</id>
    <revision>
      <id>54574</id>
      <parentid>52182</parentid>
      <timestamp>2013-06-01T05:14:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list minmax]] to [[Template:cpp/algorithm/dsc minmax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tfun | cpp/algorithm/minmax | returns the larger and the smaller of two elements | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc minmax element</title>
    <ns>10</ns>
    <id>2430</id>
    <revision>
      <id>54576</id>
      <parentid>52183</parentid>
      <timestamp>2013-06-01T05:14:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list minmax element]] to [[Template:cpp/algorithm/dsc minmax element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/algorithm/minmax_element | returns the smallest and the largest element in a range |notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc mismatch</title>
    <ns>10</ns>
    <id>1863</id>
    <revision>
      <id>54579</id>
      <parentid>52184</parentid>
      <timestamp>2013-06-01T05:14:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list mismatch]] to [[Template:cpp/algorithm/dsc mismatch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc tfun | cpp/algorithm/mismatch | finds the first position where two ranges differ }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc move</title>
    <ns>10</ns>
    <id>2432</id>
    <revision>
      <id>54585</id>
      <parentid>52185</parentid>
      <timestamp>2013-06-01T05:14:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list move]] to [[Template:cpp/algorithm/dsc move]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc tfun | cpp/algorithm/move | moves a range of elements to a new location | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc move backward</title>
    <ns>10</ns>
    <id>2433</id>
    <revision>
      <id>54590</id>
      <parentid>52186</parentid>
      <timestamp>2013-06-01T05:14:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list move backward]] to [[Template:cpp/algorithm/dsc move backward]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/algorithm/move_backward | moves a range of elements to a new location in backwards order | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc next permutation</title>
    <ns>10</ns>
    <id>1864</id>
    <revision>
      <id>54594</id>
      <parentid>52187</parentid>
      <timestamp>2013-06-01T05:14:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list next permutation]] to [[Template:cpp/algorithm/dsc next permutation]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/algorithm/next_permutation | generates the next greater lexicographic permutation of a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc nth element</title>
    <ns>10</ns>
    <id>1865</id>
    <revision>
      <id>54600</id>
      <parentid>52188</parentid>
      <timestamp>2013-06-01T05:14:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list nth element]] to [[Template:cpp/algorithm/dsc nth element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/algorithm/nth_element | partially sorts the given range making sure that it is partitioned by the given element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partial sort</title>
    <ns>10</ns>
    <id>1866</id>
    <revision>
      <id>54603</id>
      <parentid>52189</parentid>
      <timestamp>2013-06-01T05:14:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partial sort]] to [[Template:cpp/algorithm/dsc partial sort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc tfun | cpp/algorithm/partial_sort | sorts the first N elements of a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partial sort copy</title>
    <ns>10</ns>
    <id>1867</id>
    <revision>
      <id>54607</id>
      <parentid>52190</parentid>
      <timestamp>2013-06-01T05:14:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partial sort copy]] to [[Template:cpp/algorithm/dsc partial sort copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc tfun | cpp/algorithm/partial_sort_copy | copies and partially sorts a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partial sum</title>
    <ns>10</ns>
    <id>1868</id>
    <revision>
      <id>54609</id>
      <parentid>52191</parentid>
      <timestamp>2013-06-01T05:14:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partial sum]] to [[Template:cpp/algorithm/dsc partial sum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tfun | cpp/algorithm/partial_sum | computes the partial sum of a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partition</title>
    <ns>10</ns>
    <id>1869</id>
    <revision>
      <id>54612</id>
      <parentid>52192</parentid>
      <timestamp>2013-06-01T05:14:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partition]] to [[Template:cpp/algorithm/dsc partition]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc tfun | cpp/algorithm/partition | divides a range of elements into two groups }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partition copy</title>
    <ns>10</ns>
    <id>2514</id>
    <revision>
      <id>54618</id>
      <parentid>52193</parentid>
      <timestamp>2013-06-01T05:14:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partition copy]] to [[Template:cpp/algorithm/dsc partition copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc tfun | cpp/algorithm/partition_copy | copies a range dividing the elements into two groups | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc partition point</title>
    <ns>10</ns>
    <id>2435</id>
    <revision>
      <id>54621</id>
      <parentid>52194</parentid>
      <timestamp>2013-06-01T05:14:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list partition point]] to [[Template:cpp/algorithm/dsc partition point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tfun | cpp/algorithm/partition_point | locates the partition point of a partitioned range | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc pop heap</title>
    <ns>10</ns>
    <id>1870</id>
    <revision>
      <id>63744</id>
      <parentid>54626</parentid>
      <timestamp>2013-07-23T19:55:46Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;, cf. talk:cpp/algorithm/notes heap</comment>
      <text xml:space="preserve" bytes="84">{{dsc tfun | cpp/algorithm/pop_heap | removes the largest element from a max heap }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc prev permutation</title>
    <ns>10</ns>
    <id>1871</id>
    <revision>
      <id>54629</id>
      <parentid>52196</parentid>
      <timestamp>2013-06-01T05:15:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list prev permutation]] to [[Template:cpp/algorithm/dsc prev permutation]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/algorithm/prev_permutation | generates the next smaller lexicographic permutation of a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc push heap</title>
    <ns>10</ns>
    <id>1872</id>
    <revision>
      <id>63745</id>
      <parentid>54633</parentid>
      <timestamp>2013-07-23T19:55:57Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;, cf. talk:cpp/algorithm/notes heap</comment>
      <text xml:space="preserve" bytes="71">{{dsc tfun | cpp/algorithm/push_heap | adds an element to a max heap }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc qsort</title>
    <ns>10</ns>
    <id>1873</id>
    <revision>
      <id>54637</id>
      <parentid>52198</parentid>
      <timestamp>2013-06-01T05:15:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list qsort]] to [[Template:cpp/algorithm/dsc qsort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc fun | cpp/algorithm/qsort | sorts a range of elements with unspecified type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc random shuffle</title>
    <ns>10</ns>
    <id>1874</id>
    <revision>
      <id>54643</id>
      <parentid>52199</parentid>
      <timestamp>2013-06-01T05:15:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list random shuffle]] to [[Template:cpp/algorithm/dsc random shuffle]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/algorithm/random_shuffle | randomly re-orders elements in a range | title=random_shuffle&lt;br&gt;shuffle | notes=&amp;nbsp;&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc remove</title>
    <ns>10</ns>
    <id>1875</id>
    <revision>
      <id>54646</id>
      <parentid>52200</parentid>
      <timestamp>2013-06-01T05:15:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list remove]] to [[Template:cpp/algorithm/dsc remove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tfun | cpp/algorithm/remove | title=remove&lt;br&gt;remove_if | removes elements satisfying specific criteria }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc remove copy</title>
    <ns>10</ns>
    <id>1876</id>
    <revision>
      <id>54651</id>
      <parentid>52201</parentid>
      <timestamp>2013-06-01T05:15:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list remove copy]] to [[Template:cpp/algorithm/dsc remove copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc tfun | cpp/algorithm/remove_copy | title=remove_copy&lt;br&gt;remove_copy_if | copies a range of elements omitting those that satisfy specific criteria }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc replace</title>
    <ns>10</ns>
    <id>1877</id>
    <revision>
      <id>54655</id>
      <parentid>52202</parentid>
      <timestamp>2013-06-01T05:15:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list replace]] to [[Template:cpp/algorithm/dsc replace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tfun | cpp/algorithm/replace | title=replace&lt;br&gt;replace_if| replaces all values satisfying specific criteria with another value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc replace copy</title>
    <ns>10</ns>
    <id>1878</id>
    <revision>
      <id>54659</id>
      <parentid>52203</parentid>
      <timestamp>2013-06-01T05:15:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list replace copy]] to [[Template:cpp/algorithm/dsc replace copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc tfun | cpp/algorithm/replace_copy | title=replace_copy&lt;br&gt;replace_copy_if | copies a range, replacing elements satisfying specific criteria with another value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc reverse</title>
    <ns>10</ns>
    <id>1879</id>
    <revision>
      <id>54665</id>
      <parentid>52204</parentid>
      <timestamp>2013-06-01T05:15:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list reverse]] to [[Template:cpp/algorithm/dsc reverse]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc tfun | cpp/algorithm/reverse | reverses the order elements in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc reverse copy</title>
    <ns>10</ns>
    <id>1880</id>
    <revision>
      <id>54668</id>
      <parentid>52205</parentid>
      <timestamp>2013-06-01T05:15:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list reverse copy]] to [[Template:cpp/algorithm/dsc reverse copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tfun | cpp/algorithm/reverse_copy | creates a copy of a range that is reversed }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc rotate</title>
    <ns>10</ns>
    <id>1881</id>
    <revision>
      <id>54674</id>
      <parentid>52206</parentid>
      <timestamp>2013-06-01T05:15:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list rotate]] to [[Template:cpp/algorithm/dsc rotate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc tfun | cpp/algorithm/rotate | rotates the order of elements in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc rotate copy</title>
    <ns>10</ns>
    <id>1882</id>
    <revision>
      <id>54676</id>
      <parentid>52207</parentid>
      <timestamp>2013-06-01T05:15:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list rotate copy]] to [[Template:cpp/algorithm/dsc rotate copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc tfun | cpp/algorithm/rotate_copy | copies and rotate a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc search</title>
    <ns>10</ns>
    <id>1883</id>
    <revision>
      <id>54683</id>
      <parentid>52208</parentid>
      <timestamp>2013-06-01T05:15:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list search]] to [[Template:cpp/algorithm/dsc search]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc tfun | cpp/algorithm/search | searches for a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc search n</title>
    <ns>10</ns>
    <id>1884</id>
    <revision>
      <id>54686</id>
      <parentid>52209</parentid>
      <timestamp>2013-06-01T05:15:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list search n]] to [[Template:cpp/algorithm/dsc search n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc tfun | cpp/algorithm/search_n | searches for a number consecutive copies of an element in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc set difference</title>
    <ns>10</ns>
    <id>1885</id>
    <revision>
      <id>54691</id>
      <parentid>52210</parentid>
      <timestamp>2013-06-01T05:15:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list set difference]] to [[Template:cpp/algorithm/dsc set difference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tfun | cpp/algorithm/set_difference | computes the difference between two sets }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc set intersection</title>
    <ns>10</ns>
    <id>1886</id>
    <revision>
      <id>54693</id>
      <parentid>52211</parentid>
      <timestamp>2013-06-01T05:15:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list set intersection]] to [[Template:cpp/algorithm/dsc set intersection]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc tfun | cpp/algorithm/set_intersection | computes the intersection of two sets }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc set symmetric difference</title>
    <ns>10</ns>
    <id>1887</id>
    <revision>
      <id>54695</id>
      <parentid>52212</parentid>
      <timestamp>2013-06-01T05:15:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list set symmetric difference]] to [[Template:cpp/algorithm/dsc set symmetric difference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tfun | cpp/algorithm/set_symmetric_difference | computes the symmetric difference between two sets }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc set union</title>
    <ns>10</ns>
    <id>1888</id>
    <revision>
      <id>54698</id>
      <parentid>52213</parentid>
      <timestamp>2013-06-01T05:15:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list set union]] to [[Template:cpp/algorithm/dsc set union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc tfun | cpp/algorithm/set_union | computes the union of two sets }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc sort</title>
    <ns>10</ns>
    <id>1889</id>
    <revision>
      <id>54700</id>
      <parentid>52214</parentid>
      <timestamp>2013-06-01T05:15:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list sort]] to [[Template:cpp/algorithm/dsc sort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc tfun | cpp/algorithm/sort | sorts a range into ascending order }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc sort heap</title>
    <ns>10</ns>
    <id>1890</id>
    <revision>
      <id>63748</id>
      <parentid>54705</parentid>
      <timestamp>2013-07-23T19:57:47Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;, cf. talk:cpp/algorithm/notes heap</comment>
      <text xml:space="preserve" bytes="109">{{dsc tfun | cpp/algorithm/sort_heap | turns a max heap into a range of elements sorted in ascending order }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc stable partition</title>
    <ns>10</ns>
    <id>1891</id>
    <revision>
      <id>54709</id>
      <parentid>52216</parentid>
      <timestamp>2013-06-01T05:15:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list stable partition]] to [[Template:cpp/algorithm/dsc stable partition]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tfun | cpp/algorithm/stable_partition | divides elements into two groups while preserving their relative order }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc stable sort</title>
    <ns>10</ns>
    <id>1892</id>
    <revision>
      <id>54714</id>
      <parentid>52217</parentid>
      <timestamp>2013-06-01T05:15:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list stable sort]] to [[Template:cpp/algorithm/dsc stable sort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc tfun | cpp/algorithm/stable_sort | sorts a range of elements while preserving order between equal elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc swap</title>
    <ns>10</ns>
    <id>1893</id>
    <revision>
      <id>54720</id>
      <parentid>52218</parentid>
      <timestamp>2013-06-01T05:16:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list swap]] to [[Template:cpp/algorithm/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc tfun | cpp/algorithm/swap | swaps the values of two objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc swap ranges</title>
    <ns>10</ns>
    <id>1894</id>
    <revision>
      <id>54724</id>
      <parentid>52219</parentid>
      <timestamp>2013-06-01T05:16:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list swap ranges]] to [[Template:cpp/algorithm/dsc swap ranges]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc tfun | cpp/algorithm/swap_ranges | swaps two ranges of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc transform</title>
    <ns>10</ns>
    <id>1895</id>
    <revision>
      <id>54729</id>
      <parentid>52220</parentid>
      <timestamp>2013-06-01T05:16:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list transform]] to [[Template:cpp/algorithm/dsc transform]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc tfun | cpp/algorithm/transform | applies a function to a range of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc unique</title>
    <ns>10</ns>
    <id>1896</id>
    <revision>
      <id>54735</id>
      <parentid>52221</parentid>
      <timestamp>2013-06-01T05:16:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list unique]] to [[Template:cpp/algorithm/dsc unique]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc tfun | cpp/algorithm/unique | removes consecutive duplicate elements in a range }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc unique copy</title>
    <ns>10</ns>
    <id>1897</id>
    <revision>
      <id>54739</id>
      <parentid>52222</parentid>
      <timestamp>2013-06-01T05:16:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list unique copy]] to [[Template:cpp/algorithm/dsc unique copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/algorithm/unique_copy | creates a copy of some range of elements that contains no consecutive duplicates }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/dsc upper bound</title>
    <ns>10</ns>
    <id>1898</id>
    <revision>
      <id>54742</id>
      <parentid>52223</parentid>
      <timestamp>2013-06-01T05:16:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/dcl list upper bound]] to [[Template:cpp/algorithm/dsc upper bound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tfun | cpp/algorithm/upper_bound | returns an iterator to the first element ''greater'' than a certain value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/navbar</title>
    <ns>10</ns>
    <id>1900</id>
    <revision>
      <id>39858</id>
      <parentid>35527</parentid>
      <timestamp>2012-09-28T19:56:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="158">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/algorithm/navbar heading
|content2 = cpp/algorithm/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/navbar content</title>
    <ns>10</ns>
    <id>1901</id>
    <revision>
      <id>66012</id>
      <parentid>52224</parentid>
      <timestamp>2013-10-21T05:21:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>is_heap c++11</comment>
      <text xml:space="preserve" bytes="4708">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | Non-modifying sequence operations }}
{{nv col begin}}
{{nv ln | cpp/algorithm/all_any_none_of | all_of | any_of | none_of | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/algorithm/for_each }}
{{nv ln | cpp/algorithm/count | count | count_if}}
{{nv ln | cpp/algorithm/mismatch }}
{{nv ln | cpp/algorithm/equal }}
{{nv col next}}
{{nv ln | cpp/algorithm/find | find | find_if | find_if_not | notes=&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/algorithm/find_end }}
{{nv ln | cpp/algorithm/find_first_of }}
{{nv ln | cpp/algorithm/adjacent_find }}
{{nv ln | cpp/algorithm/search }}
{{nv ln | cpp/algorithm/search_n }}
{{nv col end}}

{{nv h2 | Modifying sequence operations }}
{{nv col begin}}
{{nv ln | cpp/algorithm/copy | copy | copy_if | notes=&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/algorithm/copy_n | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/copy_backward }}
{{nv ln | cpp/algorithm/move | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/move_backward | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/fill }}
{{nv ln | cpp/algorithm/fill_n }}
{{nv ln | cpp/algorithm/transform }}
{{nv ln | cpp/algorithm/generate }}
{{nv ln | cpp/algorithm/generate_n }}
{{nv ln | cpp/algorithm/remove | remove | remove_if}}
{{nv ln | cpp/algorithm/remove_copy | remove_copy | remove_copy_if}}
{{nv col next}}
{{nv ln | cpp/algorithm/replace | replace | replace_if}}
{{nv ln | cpp/algorithm/replace_copy | replace_copy | replace_copy_if}}
{{nv ln | cpp/algorithm/swap }}
{{nv ln | cpp/algorithm/swap_ranges }}
{{nv ln | cpp/algorithm/iter_swap }}
{{nv ln | cpp/algorithm/reverse }}
{{nv ln | cpp/algorithm/reverse_copy }}
{{nv ln | cpp/algorithm/rotate }}
{{nv ln | cpp/algorithm/rotate_copy }}
{{nv ln | cpp/algorithm/random_shuffle | random_shuffle | shuffle | notes=&amp;nbsp;&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/algorithm/unique }}
{{nv ln | cpp/algorithm/unique_copy }}
{{nv col end}}

{{nv h2 | Partitioning operations}}
{{nv col begin}}
{{nv ln | cpp/algorithm/is_partitioned | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/partition}}
{{nv ln | cpp/algorithm/partition_copy | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/algorithm/stable_partition }}
{{nv ln | cpp/algorithm/partition_point | notes={{mark c++11}} }}
{{nv col end}}

{{nv h2 | Sorting operations (on sorted ranges) }}
{{nv col begin}}
{{nv ln | cpp/algorithm/is_sorted | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/is_sorted_until | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/sort }}
{{nv col next}}
{{nv ln | cpp/algorithm/partial_sort }}
{{nv ln | cpp/algorithm/partial_sort_copy }}
{{nv ln | cpp/algorithm/stable_sort }}
{{nv ln | cpp/algorithm/nth_element }}
{{nv col end}}

{{nv h2 | Binary search operations (on sorted ranges) }}
{{nv col begin}}
{{nv ln | cpp/algorithm/lower_bound }}
{{nv ln | cpp/algorithm/upper_bound }}
{{nv col next}}
{{nv ln | cpp/algorithm/binary_search }}
{{nv ln | cpp/algorithm/equal_range }}
{{nv col end}}

{{nv h2 | Set operations (on sorted ranges) }}
{{nv col begin}}
{{nv ln | cpp/algorithm/merge }}
{{nv ln | cpp/algorithm/inplace_merge }}
{{nv ln | cpp/algorithm/includes }}
{{nv col next}}
{{nv ln | cpp/algorithm/set_difference }}
{{nv ln | cpp/algorithm/set_intersection }}
{{nv ln | cpp/algorithm/set_symmetric_difference }}
{{nv ln | cpp/algorithm/set_union }}
{{nv col end}}

{{nv h2 | Heap operations }}
{{nv col begin}}
{{nv ln | cpp/algorithm/is_heap | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/is_heap_until | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/make_heap }}
{{nv col next}}
{{nv ln | cpp/algorithm/push_heap }}
{{nv ln | cpp/algorithm/pop_heap }}
{{nv ln | cpp/algorithm/sort_heap }}
{{nv col end}}

{{nv h2 | Minimum/maximum operations }}
{{nv col begin}}
{{nv ln | cpp/algorithm/max }}
{{nv ln | cpp/algorithm/max_element }}
{{nv ln | cpp/algorithm/min }}
{{nv ln | cpp/algorithm/min_element }}
{{nv ln | cpp/algorithm/minmax | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/minmax_element | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/algorithm/lexicographical_compare }}
{{nv ln | cpp/algorithm/is_permutation | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/next_permutation }}
{{nv ln | cpp/algorithm/prev_permutation }}
{{nv col end}}

{{nv h2 | Numeric operations }}
{{nv col begin}}
{{nv ln | cpp/algorithm/iota | notes={{mark c++11}}}}
{{nv ln | cpp/algorithm/accumulate }}
{{nv ln | cpp/algorithm/inner_product }}
{{nv col next}}
{{nv ln | cpp/algorithm/adjacent_difference }}
{{nv ln | cpp/algorithm/partial_sum }}
{{nv col end}}

{{nv h2 | C library }}
{{nv col begin}}
{{nv ln | cpp/algorithm/qsort }}
{{nv col next}}
{{nv ln | cpp/algorithm/bsearch }}
{{nv col end}}
{{nv end}}</text>
      <sha1>pmpbkv6ysq79e96dfe6sqifs04iiebd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/navbar heading</title>
    <ns>10</ns>
    <id>1902</id>
    <revision>
      <id>35479</id>
      <parentid>3803</parentid>
      <timestamp>2012-06-15T22:26:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/algorithm/sidebar heading]] to [[Template:cpp/algorithm/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="37">[[cpp/algorithm | Algorithm library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/algorithm/notes heap</title>
    <ns>10</ns>
    <id>1899</id>
    <revision>
      <id>63733</id>
      <parentid>24611</parentid>
      <timestamp>2013-07-23T19:34:30Z</timestamp>
      <contributor>
        <username>Extensive</username>
        <id>1328</id>
      </contributor>
      <comment>&quot;heap&quot; --&gt; &quot;max heap&quot;</comment>
      <text xml:space="preserve" bytes="323">A ''max heap'' is a range of elements {{tt|[f,l)}} that has the following properties:
:* {{c|*f}} is the largest element in the range
:* a new element can be added using {{c|std::push_heap()}}
:* the first element can be removed using {{c|std::pop_heap()}}

The actual arrangement of the elements is implementation defined.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc compare exchange</title>
    <ns>10</ns>
    <id>6323</id>
    <revision>
      <id>54747</id>
      <parentid>52225</parentid>
      <timestamp>2013-06-01T05:16:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list compare exchange]] to [[Template:cpp/atomic/atomic/dsc compare exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="249">{{dsc mem fun  | cpp/atomic/atomic/compare_exchange | title=compare_exchange_weak&lt;br&gt;compare_exchange_strong | atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc constructor</title>
    <ns>10</ns>
    <id>6731</id>
    <revision>
      <id>54749</id>
      <parentid>52226</parentid>
      <timestamp>2013-06-01T05:16:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list constructor]] to [[Template:cpp/atomic/atomic/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem ctor | cpp/atomic/atomic/atomic | constructs an atomic object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc exchange</title>
    <ns>10</ns>
    <id>4722</id>
    <revision>
      <id>65897</id>
      <parentid>54751</parentid>
      <timestamp>2013-10-14T02:14:25Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>replaced -&gt; replaces</comment>
      <text xml:space="preserve" bytes="176">{{dsc mem fun | cpp/atomic/atomic/exchange | mem={{{mem|}}} | atomically replaces the value of the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1>ccbszonvvty5tvvk66ur8d758r04xe1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc fetch add</title>
    <ns>10</ns>
    <id>4724</id>
    <revision>
      <id>54756</id>
      <parentid>52228</parentid>
      <timestamp>2013-06-01T05:16:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list fetch add]] to [[Template:cpp/atomic/atomic/dsc fetch add]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="196">{{dsc mem fun | cpp/atomic/atomic/fetch_add | mem={{{mem|}}} | atomically adds the argument to the value stored in the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc fetch and</title>
    <ns>10</ns>
    <id>4728</id>
    <revision>
      <id>54760</id>
      <parentid>52229</parentid>
      <timestamp>2013-06-01T05:16:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list fetch and]] to [[Template:cpp/atomic/atomic/dsc fetch and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="214">{{dsc mem fun | cpp/atomic/atomic/fetch_and | mem={{{mem|}}} | atomically performs bitwise AND between the argument and the value of the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc fetch or</title>
    <ns>10</ns>
    <id>4730</id>
    <revision>
      <id>54764</id>
      <parentid>52230</parentid>
      <timestamp>2013-06-01T05:16:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list fetch or]] to [[Template:cpp/atomic/atomic/dsc fetch or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="212">{{dsc mem fun | cpp/atomic/atomic/fetch_or | mem={{{mem|}}} | atomically performs bitwise OR between the argument and the value of the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc fetch sub</title>
    <ns>10</ns>
    <id>4726</id>
    <revision>
      <id>54768</id>
      <parentid>52231</parentid>
      <timestamp>2013-06-01T05:16:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list fetch sub]] to [[Template:cpp/atomic/atomic/dsc fetch sub]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="203">{{dsc mem fun | cpp/atomic/atomic/fetch_sub | mem={{{mem|}}} | atomically subtracts the argument from the value stored in the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc fetch xor</title>
    <ns>10</ns>
    <id>4732</id>
    <revision>
      <id>54773</id>
      <parentid>52232</parentid>
      <timestamp>2013-06-01T05:16:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list fetch xor]] to [[Template:cpp/atomic/atomic/dsc fetch xor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="214">{{dsc mem fun | cpp/atomic/atomic/fetch_xor | mem={{{mem|}}} | atomically performs bitwise XOR between the argument and the value of the atomic object and obtains the value held previously | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc is lock free</title>
    <ns>10</ns>
    <id>6730</id>
    <revision>
      <id>54777</id>
      <parentid>52233</parentid>
      <timestamp>2013-06-01T05:16:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list is lock free]] to [[Template:cpp/atomic/atomic/dsc is lock free]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun  | cpp/atomic/atomic/is_lock_free | checks if the atomic object is lock-free}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc load</title>
    <ns>10</ns>
    <id>4721</id>
    <revision>
      <id>54783</id>
      <parentid>52234</parentid>
      <timestamp>2013-06-01T05:16:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list load]] to [[Template:cpp/atomic/atomic/dsc load]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc mem fun | cpp/atomic/atomic/load | mem={{{mem|}}} | atomically obtains the value of the atomic object | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc operator=</title>
    <ns>10</ns>
    <id>6733</id>
    <revision>
      <id>54786</id>
      <parentid>52235</parentid>
      <timestamp>2013-06-01T05:16:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list operator=]] to [[Template:cpp/atomic/atomic/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun  | cpp/atomic/atomic/operator{{=}} | stores a value into an atomic object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc operator T</title>
    <ns>10</ns>
    <id>6732</id>
    <revision>
      <id>54788</id>
      <parentid>52236</parentid>
      <timestamp>2013-06-01T05:16:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list operator T]] to [[Template:cpp/atomic/atomic/dsc operator T]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun  | cpp/atomic/atomic/operator T | loads a value from an atomic object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc operator arith</title>
    <ns>10</ns>
    <id>6734</id>
    <revision>
      <id>54791</id>
      <parentid>52237</parentid>
      <timestamp>2013-06-01T05:16:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list operator arith]] to [[Template:cpp/atomic/atomic/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="201">{{dsc mem fun | cpp/atomic/atomic/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}}&lt;br&gt;operator--&lt;br&gt;operator--{{dsc small|(int)}} | increments or decrements the atomic value by one }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc operator arith2</title>
    <ns>10</ns>
    <id>6735</id>
    <revision>
      <id>54793</id>
      <parentid>52238</parentid>
      <timestamp>2013-06-01T05:16:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list operator arith2]] to [[Template:cpp/atomic/atomic/dsc operator arith2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="204">{{dsc mem fun | cpp/atomic/atomic/operator_arith2 | title=operator+=&lt;br&gt;operator-=&lt;br&gt;operator&amp;=&lt;br&gt;operator{{!}}=&lt;br&gt;operator^= | adds, subtracts, or performs bitwise AND, OR, XOR with the atomic value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/dsc store</title>
    <ns>10</ns>
    <id>4719</id>
    <revision>
      <id>54796</id>
      <parentid>52239</parentid>
      <timestamp>2013-06-01T05:16:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic/dcl list store]] to [[Template:cpp/atomic/atomic/dsc store]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc mem fun | cpp/atomic/atomic/store | mem={{{mem|}}} | atomically replaces the value of the atomic object with a non-atomic argument | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/navbar</title>
    <ns>10</ns>
    <id>4735</id>
    <revision>
      <id>39859</id>
      <parentid>35528</parentid>
      <timestamp>2012-09-28T19:56:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/atomic/navbar heading
|content2 = cpp/atomic/navbar content

|heading3 = cpp/atomic/atomic/navbar heading
|content3 = cpp/atomic/atomic/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/navbar content</title>
    <ns>10</ns>
    <id>9231</id>
    <revision>
      <id>52240</id>
      <parentid>38851</parentid>
      <timestamp>2013-06-01T04:42:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="913">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/atomic/atomic/atomic}}
{{nv mem ln | cpp/atomic/atomic/operator{{=}}}}
{{nv mem ln | cpp/atomic/atomic/is_lock_free}}
{{nv mem ln | cpp/atomic/atomic/store}}
{{nv mem ln | cpp/atomic/atomic/load}}
{{nv mem ln | cpp/atomic/atomic/operator T}}
{{nv mem ln | cpp/atomic/atomic/exchange}}
{{nv mem ln | cpp/atomic/atomic/compare_exchange}}

{{nv h1 | Specialized member functions}}
{{nv mem ln | cpp/atomic/atomic/fetch_add}}
{{nv mem ln | cpp/atomic/atomic/fetch_sub}}
{{nv mem ln | cpp/atomic/atomic/fetch_and}}
{{nv mem ln | cpp/atomic/atomic/fetch_or}}
{{nv mem ln | cpp/atomic/atomic/fetch_xor}}
{{nv mem ln | cpp/atomic/atomic/operator_arith | operator++ | operator++(int) | operator-- | operator--(int)}}
{{nv mem ln | cpp/atomic/atomic/operator_arith2 | operator+{{=}} | operator-{{=}} | operator&amp;{{=}} | operator{{!=}} | operator^{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/navbar heading</title>
    <ns>10</ns>
    <id>4736</id>
    <revision>
      <id>48080</id>
      <parentid>35529</parentid>
      <timestamp>2013-05-18T18:06:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="37">{{ltt|cpp/atomic/atomic|std::atomic}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic/title</title>
    <ns>10</ns>
    <id>5000</id>
    <revision>
      <id>18053</id>
      <timestamp>2012-01-20T14:45:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=atomic::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic fetch cond example</title>
    <ns>10</ns>
    <id>10127</id>
    <revision>
      <id>48266</id>
      <parentid>48257</parentid>
      <timestamp>2013-05-21T21:58:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rm heading</comment>
      <text xml:space="preserve" bytes="2005">{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;atomic&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;
#include &lt;functional&gt;

// Binary semaphore for demonstrative purposes only
// This is a simple yet meaningful example: atomic operations
// are unnecessary without threads. 
class Semaphore {
    std::atomic_char m_signaled;
  public:
    Semaphore(bool initial = false)
    {
        m_signaled = initial;
    }
    // Block until semaphore is signaled
    void take() 
    {
        while (!std::atomic_fetch_and(&amp;m_signaled, false)) {
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
    }

    void put() 
    {
        std::atomic_fetch_or(&amp;m_signaled, true);
    }
};

class ThreadedCounter {
    static const int N = 100;
    static const int REPORT_INTERVAL = 10;
    int m_count;
    bool m_done;
    Semaphore m_count_sem;
    Semaphore m_print_sem;

    void count_up() 
    {
        for (m_count = 1; m_count &lt;= N; m_count++) {
            if (m_count % REPORT_INTERVAL == 0) {
                if (m_count == N) m_done = true;
                m_print_sem.put(); // signal printing to occur
                m_count_sem.take(); // wait until printing is complete proceeding
            }
        }
        std::cout &lt;&lt; &quot;count_up() done\n&quot;;
        m_done = true;
        m_print_sem.put();
    }

    void print_count() 
    {
        do {
            m_print_sem.take();
            std::cout &lt;&lt; m_count &lt;&lt; '\n';
            m_count_sem.put();
        } while (!m_done);
        std::cout &lt;&lt; &quot;print_count() done\n&quot;;
    }

  public:
    ThreadedCounter() : m_done(false) {}
    void run() 
    {
        auto print_thread = std::thread(&amp;ThreadedCounter::print_count, this);
        auto count_thread = std::thread(&amp;ThreadedCounter::count_up, this);
        print_thread.join();
        count_thread.join();
    }
};

int main() 
{
    ThreadedCounter m_counter;
    m_counter.run();
}
 | output=
10
20
30
40
50
60
70
80
90
100
print_count() done
count_up() done
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/dsc clear</title>
    <ns>10</ns>
    <id>2828</id>
    <revision>
      <id>54799</id>
      <parentid>52241</parentid>
      <timestamp>2013-06-01T05:16:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic flag/dcl list clear]] to [[Template:cpp/atomic/atomic flag/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun  | cpp/atomic/atomic_flag/clear | atomically sets flag to {{c|false}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/dsc test and set</title>
    <ns>10</ns>
    <id>2829</id>
    <revision>
      <id>54805</id>
      <parentid>52242</parentid>
      <timestamp>2013-06-01T05:16:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/atomic flag/dcl list test and set]] to [[Template:cpp/atomic/atomic flag/dsc test and set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun  | cpp/atomic/atomic_flag/test_and_set | atomically sets the flag to {{c|true}} and obtains its previous value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/navbar</title>
    <ns>10</ns>
    <id>2836</id>
    <revision>
      <id>39860</id>
      <parentid>35530</parentid>
      <timestamp>2012-09-28T19:56:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/atomic/navbar heading
|content2 = cpp/atomic/navbar content

|heading3 = cpp/atomic/atomic_flag/navbar heading
|content3 = cpp/atomic/atomic_flag/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/navbar content</title>
    <ns>10</ns>
    <id>2838</id>
    <revision>
      <id>52243</id>
      <parentid>35531</parentid>
      <timestamp>2013-06-01T04:42:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="253">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/atomic/atomic_flag/atomic_flag}}
{{nv mem ln | cpp/atomic/atomic_flag/operator{{=}}}}
{{nv mem ln | cpp/atomic/atomic_flag/clear}}
{{nv mem ln | cpp/atomic/atomic_flag/test_and_set}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/navbar heading</title>
    <ns>10</ns>
    <id>2837</id>
    <revision>
      <id>48029</id>
      <parentid>35532</parentid>
      <timestamp>2013-05-18T17:58:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/atomic/atomic_flag|std::atomic_flag}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/atomic flag/title</title>
    <ns>10</ns>
    <id>2814</id>
    <revision>
      <id>10685</id>
      <timestamp>2011-09-20T13:53:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=atomic_flag::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=atomic_flag::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc ATOMIC FLAG INIT</title>
    <ns>10</ns>
    <id>2815</id>
    <revision>
      <id>54808</id>
      <parentid>52244</parentid>
      <timestamp>2013-06-01T05:16:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list ATOMIC FLAG INIT]] to [[Template:cpp/atomic/dsc ATOMIC FLAG INIT]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc macro const | cpp/atomic/ATOMIC_FLAG_INIT | initializes an {{lc|std::atomic_flag}} to {{c|false}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc ATOMIC VAR INIT</title>
    <ns>10</ns>
    <id>2827</id>
    <revision>
      <id>54814</id>
      <parentid>52245</parentid>
      <timestamp>2013-06-01T05:17:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list ATOMIC VAR INIT]] to [[Template:cpp/atomic/dsc ATOMIC VAR INIT]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc macro fun | cpp/atomic/ATOMIC_VAR_INIT | constant initialization of an atomic variable of static storage duration | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic</title>
    <ns>10</ns>
    <id>4710</id>
    <revision>
      <id>54816</id>
      <parentid>52246</parentid>
      <timestamp>2013-06-01T05:17:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic]] to [[Template:cpp/atomic/dsc atomic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tclass | cpp/atomic/atomic | atomic class template and specializations for bool, integral, and pointer types | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic compare exchange</title>
    <ns>10</ns>
    <id>4713</id>
    <revision>
      <id>54818</id>
      <parentid>52247</parentid>
      <timestamp>2013-06-01T05:17:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic compare exchange]] to [[Template:cpp/atomic/dsc atomic compare exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="419">{{dsc tfun | cpp/atomic/atomic_compare_exchange | title=atomic_compare_exchange_weak&lt;br&gt;atomic_compare_exchange_weak_explicit&lt;br&gt;atomic_compare_exchange_strong&lt;br&gt;atomic_compare_exchange_strong_explicit | atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic exchange</title>
    <ns>10</ns>
    <id>4712</id>
    <revision>
      <id>54821</id>
      <parentid>52248</parentid>
      <timestamp>2013-06-01T05:17:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic exchange]] to [[Template:cpp/atomic/dsc atomic exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="252">{{dsc tfun | cpp/atomic/atomic_exchange | title=atomic_exchange&lt;br&gt;atomic_exchange_explicit | atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic fetch add</title>
    <ns>10</ns>
    <id>4714</id>
    <revision>
      <id>54823</id>
      <parentid>52249</parentid>
      <timestamp>2013-06-01T05:17:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic fetch add]] to [[Template:cpp/atomic/dsc atomic fetch add]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="228">{{dsc tfun | cpp/atomic/atomic_fetch_add | title=atomic_fetch_add&lt;br&gt;atomic_fetch_add_explicit | adds a non-atomic value to an atomic object and obtains the previous value of the atomic | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic fetch and</title>
    <ns>10</ns>
    <id>4716</id>
    <revision>
      <id>54826</id>
      <parentid>52250</parentid>
      <timestamp>2013-06-01T05:17:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic fetch and]] to [[Template:cpp/atomic/dsc atomic fetch and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="269">{{dsc tfun | cpp/atomic/atomic_fetch_and | title=atomic_fetch_and&lt;br&gt;atomic_fetch_and_explicit | replaces the atomic object with the result of logical AND with a non-atomic argument and obtains the previous value of the atomic | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic fetch or</title>
    <ns>10</ns>
    <id>4717</id>
    <revision>
      <id>54828</id>
      <parentid>52251</parentid>
      <timestamp>2013-06-01T05:17:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic fetch or]] to [[Template:cpp/atomic/dsc atomic fetch or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="265">{{dsc tfun | cpp/atomic/atomic_fetch_or | title=atomic_fetch_or&lt;br&gt;atomic_fetch_or_explicit | replaces the atomic object with the result of logical OR with a non-atomic argument and obtains the previous value of the atomic | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic fetch sub</title>
    <ns>10</ns>
    <id>4715</id>
    <revision>
      <id>54833</id>
      <parentid>52252</parentid>
      <timestamp>2013-06-01T05:17:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic fetch sub]] to [[Template:cpp/atomic/dsc atomic fetch sub]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="235">{{dsc tfun | cpp/atomic/atomic_fetch_sub | title=atomic_fetch_sub&lt;br&gt;atomic_fetch_sub_explicit | subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic fetch xor</title>
    <ns>10</ns>
    <id>4718</id>
    <revision>
      <id>54837</id>
      <parentid>52253</parentid>
      <timestamp>2013-06-01T05:17:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic fetch xor]] to [[Template:cpp/atomic/dsc atomic fetch xor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="270">{{dsc tfun | cpp/atomic/atomic_fetch_xor | title=atomic_fetch_xor&lt;br&gt;atomic_fetch_xor_explicit | replaces the atomic object with the result of logical XOR with a non-atomic argument and obtains the previous value of the atomic  | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic flag</title>
    <ns>10</ns>
    <id>2817</id>
    <revision>
      <id>54842</id>
      <parentid>52254</parentid>
      <timestamp>2013-06-01T05:17:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic flag]] to [[Template:cpp/atomic/dsc atomic flag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc class | cpp/atomic/atomic_flag | the lock-free boolean atomic type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic flag clear</title>
    <ns>10</ns>
    <id>2825</id>
    <revision>
      <id>54846</id>
      <parentid>52255</parentid>
      <timestamp>2013-06-01T05:17:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic flag clear]] to [[Template:cpp/atomic/dsc atomic flag clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="195">{{dsc fun | cpp/atomic/atomic_flag_clear | title=atomic_flag_clear&lt;br&gt;atomic_flag_clear_explicit | atomically sets the value of the flag to {{c|false}} | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic flag test and set</title>
    <ns>10</ns>
    <id>2824</id>
    <revision>
      <id>54849</id>
      <parentid>52256</parentid>
      <timestamp>2013-06-01T05:17:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic flag test and set]] to [[Template:cpp/atomic/dsc atomic flag test and set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="232">{{dsc fun | cpp/atomic/atomic_flag_test_and_set | title=atomic_flag_test_and_set&lt;br&gt;atomic_flag_test_and_set_explicit | atomically sets the flag to {{c|true}} and returns its previous value | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic init</title>
    <ns>10</ns>
    <id>2826</id>
    <revision>
      <id>54852</id>
      <parentid>52257</parentid>
      <timestamp>2013-06-01T05:17:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic init]] to [[Template:cpp/atomic/dsc atomic init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc tfun | cpp/atomic/atomic_init | non-atomic initialization of a default-constructed atomic object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic is lock free</title>
    <ns>10</ns>
    <id>4711</id>
    <revision>
      <id>54856</id>
      <parentid>52258</parentid>
      <timestamp>2013-06-01T05:17:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic is lock free]] to [[Template:cpp/atomic/dsc atomic is lock free]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/atomic/atomic_is_lock_free | checks if the atomic type's operations are lock-free | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic load</title>
    <ns>10</ns>
    <id>4708</id>
    <revision>
      <id>54859</id>
      <parentid>52259</parentid>
      <timestamp>2013-06-01T05:17:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic load]] to [[Template:cpp/atomic/dsc atomic load]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="180">{{dsc tfun | cpp/atomic/atomic_load | title=atomic_load&lt;br&gt;atomic_load_explicit | atomically obtains the value stored in an atomic object | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic signal fence</title>
    <ns>10</ns>
    <id>2823</id>
    <revision>
      <id>54863</id>
      <parentid>52260</parentid>
      <timestamp>2013-06-01T05:17:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic signal fence]] to [[Template:cpp/atomic/dsc atomic signal fence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc fun | cpp/atomic/atomic_signal_fence | fence between a thread and a signal handler executed in the same thread | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic store</title>
    <ns>10</ns>
    <id>4709</id>
    <revision>
      <id>54868</id>
      <parentid>52261</parentid>
      <timestamp>2013-06-01T05:17:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic store]] to [[Template:cpp/atomic/dsc atomic store]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="205">{{dsc tfun | cpp/atomic/atomic_store | title=atomic_store&lt;br&gt;atomic_store_explicit | atomically replaces the value of the atomic object with a non-atomic argument | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc atomic thread fence</title>
    <ns>10</ns>
    <id>2822</id>
    <revision>
      <id>54872</id>
      <parentid>52262</parentid>
      <timestamp>2013-06-01T05:17:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list atomic thread fence]] to [[Template:cpp/atomic/dsc atomic thread fence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc fun | cpp/atomic/atomic_thread_fence | generic memory order-dependent fence synchronization primitive | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc kill dependency</title>
    <ns>10</ns>
    <id>2821</id>
    <revision>
      <id>54878</id>
      <parentid>52263</parentid>
      <timestamp>2013-06-01T05:17:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list kill dependency]] to [[Template:cpp/atomic/dsc kill dependency]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="153">{{dsc tfun | cpp/atomic/kill_dependency | removes the specified object from the {{lc|std::memory_order_consume}} dependency tree | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/dsc memory order</title>
    <ns>10</ns>
    <id>2820</id>
    <revision>
      <id>54881</id>
      <parentid>52264</parentid>
      <timestamp>2013-06-01T05:17:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/dcl list memory order]] to [[Template:cpp/atomic/dsc memory order]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc typedef | cpp/atomic/memory_order | defines memory ordering constraints for the given atomic operation | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/navbar</title>
    <ns>10</ns>
    <id>1903</id>
    <revision>
      <id>39861</id>
      <parentid>35533</parentid>
      <timestamp>2012-09-28T19:56:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="152">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/atomic/navbar heading
|content2 = cpp/atomic/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/navbar content</title>
    <ns>10</ns>
    <id>2813</id>
    <revision>
      <id>52265</id>
      <parentid>35534</parentid>
      <timestamp>2013-06-01T04:43:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2305">{{nv begin}}
{{nv h1 | Types}}
{{nv ln | cpp/atomic/atomic | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_is_lock_free | notes={{mark c++11}}}}

{{nv h1 | Functions}}
{{nv ln | cpp/atomic/atomic_store | atomic_store | atomic_store_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_load | atomic_load | atomic_load_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_exchange | atomic_exchange | atomic_exchange_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_compare_exchange | atomic_compare_exchange_weak | atomic_compare_exchange_weak_explicit | atomic_compare_exchange_strong | atomic_compare_exchange_strong_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_fetch_add | atomic_fetch_add | atomic_fetch_add_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_fetch_sub | atomic_fetch_sub | atomic_fetch_sub_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_fetch_and | atomic_fetch_and | atomic_fetch_and_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_fetch_or | atomic_fetch_or | atomic_fetch_or_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_fetch_xor | atomic_fetch_xor | atomic_fetch_xor_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}

{{nv h1 | Atomic flags}}
{{nv ln | cpp/atomic/atomic_flag | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_flag_test_and_set | atomic_flag_test_and_set | atomic_flag_test_and_set_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_flag_clear | atomic_flag_clear | atomic_flag_clear_explicit | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}

{{nv h1 | Initialization}}
{{nv ln | cpp/atomic/atomic_init | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/ATOMIC_VAR_INIT | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/ATOMIC_FLAG_INIT | notes={{mark c++11}}}}

{{nv h1 | Memory ordering}}
{{nv ln | cpp/atomic/memory_order | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/kill_dependency | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_thread_fence | notes={{mark c++11}}}}
{{nv ln | cpp/atomic/atomic_signal_fence | notes={{mark c++11}}}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/navbar heading</title>
    <ns>10</ns>
    <id>1904</id>
    <revision>
      <id>35535</id>
      <parentid>3807</parentid>
      <timestamp>2012-06-15T22:28:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/atomic/sidebar heading]] to [[Template:cpp/atomic/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="42">[[cpp/atomic | Atomic operations library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/atomic/title</title>
    <ns>10</ns>
    <id>6324</id>
    <revision>
      <id>22225</id>
      <timestamp>2012-04-18T15:31:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=atomic::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono//navbar</title>
    <ns>10</ns>
    <id>5284</id>
    <revision>
      <id>35537</id>
      <parentid>19211</parentid>
      <timestamp>2012-06-15T22:28:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono//sidebar]] to [[Template:cpp/chrono//navbar]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono//title</title>
    <ns>10</ns>
    <id>5283</id>
    <revision>
      <id>19210</id>
      <timestamp>2012-02-29T16:42:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc CLOCKS PER SEC</title>
    <ns>10</ns>
    <id>2050</id>
    <revision>
      <id>54885</id>
      <parentid>52266</parentid>
      <timestamp>2013-06-01T05:17:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list CLOCKS PER SEC]] to [[Template:cpp/chrono/c/dsc CLOCKS PER SEC]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc macro const | cpp/chrono/c/CLOCKS_PER_SEC | number of processor clock ticks per second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc asctime</title>
    <ns>10</ns>
    <id>2041</id>
    <revision>
      <id>54891</id>
      <parentid>52267</parentid>
      <timestamp>2013-06-01T05:17:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list asctime]] to [[Template:cpp/chrono/c/dsc asctime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/chrono/c/asctime | converts a {{tt|tm}} object to a textual representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc clock</title>
    <ns>10</ns>
    <id>2042</id>
    <revision>
      <id>54894</id>
      <parentid>52268</parentid>
      <timestamp>2013-06-01T05:17:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list clock]] to [[Template:cpp/chrono/c/dsc clock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/chrono/c/clock | returns raw processor clock time since the program is started}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc clock t</title>
    <ns>10</ns>
    <id>8473</id>
    <revision>
      <id>54900</id>
      <parentid>52269</parentid>
      <timestamp>2013-06-01T05:17:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list clock t]] to [[Template:cpp/chrono/c/dsc clock t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc typedef | cpp/chrono/c/clock_t | process running time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc ctime</title>
    <ns>10</ns>
    <id>2043</id>
    <revision>
      <id>54903</id>
      <parentid>52270</parentid>
      <timestamp>2013-06-01T05:17:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list ctime]] to [[Template:cpp/chrono/c/dsc ctime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/chrono/c/ctime | converts a {{tt|time_t}} object to a textual representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc difftime</title>
    <ns>10</ns>
    <id>2044</id>
    <revision>
      <id>54905</id>
      <parentid>52271</parentid>
      <timestamp>2013-06-01T05:17:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list difftime]] to [[Template:cpp/chrono/c/dsc difftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | cpp/chrono/c/difftime | computes the difference between times}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc gmtime</title>
    <ns>10</ns>
    <id>2045</id>
    <revision>
      <id>54909</id>
      <parentid>52272</parentid>
      <timestamp>2013-06-01T05:18:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list gmtime]] to [[Template:cpp/chrono/c/dsc gmtime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | cpp/chrono/c/gmtime | converts time since epoch to calendar time expressed as Universal Coordinated Time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc localtime</title>
    <ns>10</ns>
    <id>2048</id>
    <revision>
      <id>54915</id>
      <parentid>52273</parentid>
      <timestamp>2013-06-01T05:18:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list localtime]] to [[Template:cpp/chrono/c/dsc localtime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | cpp/chrono/c/localtime | converts time since epoch to calendar time expressed as local time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc mktime</title>
    <ns>10</ns>
    <id>2046</id>
    <revision>
      <id>54918</id>
      <parentid>52274</parentid>
      <timestamp>2013-06-01T05:18:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list mktime]] to [[Template:cpp/chrono/c/dsc mktime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/chrono/c/mktime | converts calendar time to time since epoch}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc strftime</title>
    <ns>10</ns>
    <id>2047</id>
    <revision>
      <id>54920</id>
      <parentid>52275</parentid>
      <timestamp>2013-06-01T05:18:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list strftime]] to [[Template:cpp/chrono/c/dsc strftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | cpp/chrono/c/strftime | converts a {{tt|tm}} object to custom textual representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc time</title>
    <ns>10</ns>
    <id>2049</id>
    <revision>
      <id>54922</id>
      <parentid>52276</parentid>
      <timestamp>2013-06-01T05:18:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list time]] to [[Template:cpp/chrono/c/dsc time]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/chrono/c/time | returns the current time of the system as time since epoch}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc time t</title>
    <ns>10</ns>
    <id>8472</id>
    <revision>
      <id>54927</id>
      <parentid>52277</parentid>
      <timestamp>2013-06-01T05:18:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list time t]] to [[Template:cpp/chrono/c/dsc time t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc typedef | cpp/chrono/c/time_t | time since epoch type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc tm</title>
    <ns>10</ns>
    <id>8471</id>
    <revision>
      <id>54931</id>
      <parentid>52278</parentid>
      <timestamp>2013-06-01T05:18:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list tm]] to [[Template:cpp/chrono/c/dsc tm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">{{dsc class | cpp/chrono/c/tm | calendar time type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/dsc wcsftime</title>
    <ns>10</ns>
    <id>4648</id>
    <revision>
      <id>54937</id>
      <parentid>52279</parentid>
      <timestamp>2013-06-01T05:18:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/dcl list wcsftime]] to [[Template:cpp/chrono/c/dsc wcsftime]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/chrono/c/wcsftime | converts a tm object to custom wide string textual representation }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/navbar</title>
    <ns>10</ns>
    <id>2052</id>
    <revision>
      <id>39862</id>
      <parentid>36012</parentid>
      <timestamp>2012-09-28T19:57:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="311">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/c/navbar heading
|content4 = cpp/chrono/c/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/navbar content</title>
    <ns>10</ns>
    <id>2593</id>
    <revision>
      <id>52280</id>
      <parentid>35539</parentid>
      <timestamp>2013-06-01T04:43:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="608">{{nv begin}}
{{nv h1 | Functions}}
{{nv h2 | Time manipulation}}
{{nv ln | cpp/chrono/c/difftime}}
{{nv ln | cpp/chrono/c/time}}
{{nv ln | cpp/chrono/c/clock}}

{{nv h2 | Format conversions}}
{{nv ln | cpp/chrono/c/asctime}}
{{nv ln | cpp/chrono/c/ctime}}
{{nv ln | cpp/chrono/c/strftime}}
{{nv ln | cpp/chrono/c/wcsftime}}
{{nv ln | cpp/chrono/c/gmtime}}
{{nv ln | cpp/chrono/c/localtime}}
{{nv ln | cpp/chrono/c/mktime}}

{{nv h1 | Constants}}
{{nv ln | cpp/chrono/c/CLOCKS_PER_SEC}}

{{nv h1 | Types}}
{{nv ln | cpp/chrono/c/tm}}
{{nv ln | cpp/chrono/c/time_t}}
{{nv ln | cpp/chrono/c/clock_t}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/navbar heading</title>
    <ns>10</ns>
    <id>2592</id>
    <revision>
      <id>35540</id>
      <parentid>9782</parentid>
      <timestamp>2012-06-15T22:28:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/c/sidebar heading]] to [[Template:cpp/chrono/c/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">[[cpp/chrono/c|C-style date and time utilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/c/strftime format</title>
    <ns>10</ns>
    <id>2062</id>
    <revision>
      <id>65905</id>
      <parentid>65903</parentid>
      <timestamp>2013-10-14T17:39:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>c99'izing</comment>
      <text xml:space="preserve" bytes="10362">The format string consists of zero or more conversion specifiers and ordinary characters (except {{tt|%}}). All ordinary characters, including the terminating null character, are copied to the output string without modification. Each conversion specification begins with {{tt|%}} character, optionally followed by {{tt|E}} or {{tt|O}} modifier (ignored if unsupported by the locale), followed by the character that determines the behavior of the specifier. The following format specifiers are available:

{| class=&quot;wikitable&quot; style=&quot;font-size:85%; max-width:90em;&quot;
|-
! Conversion&lt;br&gt; specifier
! Explanation
! Used fields
|-
! {{tt|%}} 
| writes literal {{tt|%}}. The full conversion specification must be {{tt|%%}}.
|
|-
! {{tt|n}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes newline character
|
|-
! {{tt|t}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes horizontal tab character
|
|-
! colspan=3 | Year
|-
! {{tt|Y}}
| writes '''year''' as a 4 digit decimal number
| {{ttb|tm_year}}
|-
! {{tt|EY}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''year''' in the alternative representation, e.g.平成23年 (year Heisei 23) instead of 2011年 (year 2011) in ja_JP locale
| {{ttb|tm_year}}
|-
! {{tt|y}}
| writes last 2 digits of '''year''' as a decimal number (range {{tt|[00,99]}})
| {{ttb|tm_year}}
|-
! {{tt|Oy}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes last 2 digits of '''year''' using the alternative numeric system, e.g. 十一 instead of 11 in ja_JP locale
| {{ttb|tm_year}}
|-
! {{tt|Ey}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''year''' as offset from locale's alternative calendar period {{tt|%EC}} (locale-dependent)
| {{ttb|tm_year}}
|-
! {{tt|C}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes first 2 digits of '''year''' as a decimal number (range {{tt|[00,99]}})
| {{ttb|tm_year}}
|-
! {{tt|EC}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes name of the '''base year (period)''' in the locale's alternative representation, e.g. 平成 (Heisei era) in ja_JP
| {{ttb|tm_year}}
|-
! {{tt|G}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''ISO 8601 week-based year''', i.e. the year that contains the specified week.
In IS0 8601 weeks begin with Monday and the first week of the year must satisfy the following requirements:
* Includes January 4
* Includes first Thursday of the year
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|g}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes last 2 digits of '''ISO 8601 week-based year''', i.e. the year that contains the specified week (range {{tt|[00,99]}}).
In IS0 8601 weeks begin with Monday and the first week of the year must satisfy the following requirements:
* Includes January 4
* Includes first Thursday of the year 
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! colspan=3 | Month
|-
! {{tt|b}}
| writes '''abbreviated month''' name, e.g. {{tt|Oct}} (locale dependent)
| {{ttb|tm_mon}}
|-
! {{tt|h}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| synonym of {{tt|b}}
| {{ttb|tm_mon}}
|-
! {{tt|B}}
| writes '''full month''' name, e.g. {{tt|October}} (locale dependent)
| {{ttb|tm_mon}}
|-
! {{tt|m}}
| writes '''month''' as a decimal number (range {{tt|[01,12]}})
| {{ttb|tm_mon}}
|-
! {{tt|Om}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''month''' using the alternative numeric system, e.g. 十二 instead of 12 in ja_JP locale
| {{ttb|tm_mon}}
|-
! colspan=3 | Week
|-
! {{tt|U}}
| writes '''week of the year''' as a decimal number (Sunday is the first day of the week) (range {{tt|[00,53]}})
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|OU}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''week of the year''', as by {{tt|%U}}, using the alternative numeric system, e.g. 五十二 instead of 52 in ja_JP locale
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|W}}
| writes '''week of the year''' as a decimal number (Monday is the first day of the week) (range {{tt|[00,53]}})
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|OW}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''week of the year''', as by {{tt|%W}}, using the alternative numeric system, e.g. 五十二 instead of 52 in ja_JP locale
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|V}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''ISO 8601 week of the year''' (range {{tt|[01,53]}}).
In IS0 8601 weeks begin with Monday and the first week of the year must satisfy the following requirements:
* Includes January 4
* Includes first Thursday of the year 
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|OV}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''week of the year''', as by {{tt|%V}}, using the alternative numeric system, e.g. 五十二 instead of 52 in ja_JP locale
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! colspan=3 | Day of the year/month
|-
! {{tt|j}}
| writes '''day of the year''' as a decimal number (range {{tt|[001,366]}})
| {{ttb|tm_yday}}
|-
! {{tt|d}}
| writes '''day of the month''' as a decimal number (range {{tt|[01,31]}})
| {{ttb|tm_mday}}
|-
! {{tt|Od}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes zero-based '''day of the month''' using the alternative numeric system, e.g 二十七 instead of 23 in ja_JP locale
Single character is preceded by a space.
| {{ttb|tm_mday}}
|-
! {{tt|e}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''day of the month''' as a decimal number (range {{tt|[1,31]}}).
Single digit is preceded by a space.
| {{ttb|tm_mday}}
|-
! {{tt|Oe}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes one-based '''day of the month''' using the alternative numeric system, e.g. 二十七 instead of 27 in ja_JP locale
Single character is preceded by a space.
| {{ttb|tm_mday}}
|-
! colspan=3 | Day of the week
|-
! {{tt|a}}
| writes '''abbreviated weekday''' name, e.g. {{tt|Fri}} (locale dependent)
| {{ttb|tm_wday}}
|-
! {{tt|A}}
| writes '''full weekday''' name, e.g. {{tt|Friday}} (locale dependent)
| {{ttb|tm_wday}}
|-
! {{tt|w}}
| writes '''weekday''' as a decimal number, where Sunday is {{tt|0}} (range {{tt|[0-6]}})
| {{ttb|tm_wday}}
|-
! {{tt|Ow}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''weekday''', where Sunday is {{tt|0}}, using the alternative numeric system, e.g. 二 instead of 2 in ja_JP locale
| {{ttb|tm_wday}}
|-
! {{tt|u}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''weekday''' as a decimal number, where Monday is {{tt|1}} (ISO 8601 format) (range {{tt|[1-7]}})
| {{ttb|tm_wday}}
|-
! {{tt|Ou}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''weekday''', where Monday is {{tt|1}}, using the alternative numeric system, e.g. 二 instead of 2 in ja_JP locale
| {{ttb|tm_wday}}
|-
! colspan=3 | Hour, minute, second
|-
! {{tt|H}}
| writes '''hour''' as a decimal number, 24 hour clock (range {{tt|[00-23]}})
| {{ttb|tm_hour}}
|-
! {{tt|OH}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''hour''' from 24-hour clock using the alternative numeric system, e.g. 十八 instead of 18 in ja_JP locale
| {{ttb|tm_hour}}
|-
! {{tt|I}}
| writes '''hour''' as a decimal number, 12 hour clock (range {{tt|[01,12]}})
| {{ttb|tm_hour}}
|-
! {{tt|OI}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''hour''' from 12-hour clock using the alternative numeric system, e.g. 六 instead of 06 in ja_JP locale
| {{ttb|tm_hour}}
|-
! {{tt|M}}
| writes '''minute''' as a decimal number (range {{tt|[00,59]}})
| {{ttb|tm_min}}
|-
! {{tt|OM}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''minute''' using the alternative numeric system, e.g. 二十五 instead of 25 in ja_JP locale
| {{ttb|tm_min}}
|-
! {{tt|S}}
| writes '''second''' as a decimal number (range {{tt|[00,60]}})
| {{ttb|tm_sec}}
|-
! {{tt|OS}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''second''' using the alternative numeric system, e.g. 二十四 instead of 24 in ja_JP locale
| {{ttb|tm_sec}}
|-
! colspan=3 | Other
|-
! {{tt|c}}
| writes '''standard date and time string''', e.g. {{tt|Sun Oct 17 04:41:13 2010}} (locale dependent)
| all
|-
! {{tt|Ec}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''alternative date and time string''', e.g. using 平成23年 (year Heisei 23) instead of 2011年 (year 2011) in ja_JP locale
| all
|-
! {{tt|x}}
| writes localized '''date representation''' (locale dependent)
| all
|-
! {{tt|Ex}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''alternative date representation''', e.g. using 平成23年 (year Heisei 23) instead of 2011年 (year 2011) in ja_JP locale
| all
|-
! {{tt|X}}
| writes localized '''time representation''' (locale dependent)
| all
|-
! {{tt|EX}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''alternative time representation''' (locale dependent)
| all
|-
! {{tt|D}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| equivalent to '''&quot;%m/%d/%y&quot;'''
| {{ttb|tm_mon}}, {{ttb|tm_mday}}, {{ttb|tm_year}}
|-
! {{tt|F}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| equivalent to '''&quot;%Y-%m-%d&quot;''' (the ISO 8601 date format)
| {{ttb|tm_mon}}, {{ttb|tm_mday}}, {{ttb|tm_year}}
|-
! {{tt|r}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes localized '''12-hour clock''' time (locale dependent)
| {{ttb|tm_hour}}, {{ttb|tm_min}}, {{ttb|tm_sec}}
|-
! {{tt|R}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| equivalent to '''&quot;%H:%M&quot;'''
| {{ttb|tm_hour}}, {{ttb|tm_min}}
|-
! {{tt|T}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| equivalent to '''&quot;%H:%M:%S&quot;''' (the ISO 8601 time format)
| {{ttb|tm_hour}}, {{ttb|tm_min}}, {{ttb|tm_sec}}
|-
! {{tt|p}}
| writes localized '''a.m. or p.m.''' (locale dependent)
| {{ttb|tm_hour}}
|-
! {{tt|z}}&lt;br/&gt;{{#ifeq:{{{1|}}}|c|{{mark c99}}|{{mark c++11}}}}
| writes '''offset from UTC''' in the ISO 8601 format (e.g. {{tt|-0430}}), or no characters if the time zone information is not available
| {{ttb|tm_isdst}}
|-
! {{tt|Z}}
| writes '''time zone name or abbreviation''', or no characters if the time zone information is not available (locale dependent)
| {{ttb|tm_isdst}}
|}</text>
      <sha1>1o4xuozrc63hzukazvm5boxa5d558kd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/chrono literals namespace</title>
    <ns>10</ns>
    <id>13464</id>
    <revision>
      <id>68731</id>
      <parentid>68724</parentid>
      <timestamp>2014-03-20T03:41:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>semicolons</comment>
      <text xml:space="preserve" bytes="614">These operators are declared in the namespace {{tt|std::literals::chrono_literals}}, where both {{tt|literals}} and {{tt|chrono_literals}} are inline namespaces. Access to these operators can be gained with {{c|using namespace std::literals}} and {{c|using namespace std::literals::chrono_literals}}.

In addition, within the namespace {{tt|std::chrono}}, the directive {{c|using namespace literals::chrono_literals;}} is provided by the standard library, so that if a programmer uses {{c|using namespace std::chrono;}} to gain access to the duration classes, the duration literal operators become visible as well.</text>
      <sha1>8r1hwekcup54v5t6jn48591verpzinv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/clock/now</title>
    <ns>10</ns>
    <id>5278</id>
    <revision>
      <id>69716</id>
      <parentid>62239</parentid>
      <timestamp>2014-04-20T22:19:09Z</timestamp>
      <contributor>
        <username>Arbalest</username>
        <id>437</id>
      </contributor>
      <comment>Added comments</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/chrono/{{{1|}}}/title | now }}
{{cpp/chrono/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
static std::chrono::time_point&lt;std::chrono::{{{1}}}&gt; now();
}}
{{dcl end}}

Returns a time point representing with the current point in time.

===Parameters===
(none)

===Return value===
A time point representing the current time.

===Exceptions===
{{noexcept}}

===Example===
{{example |
|p=true
|code=
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;chrono&gt;

int main()
{
    for (unsigned long long size = 1; size &lt; 10000000; size *= 10) {

        auto start = std::chrono::{{{1}}}::now();   // a &quot;timepoint&quot; representing now

        std::vector&lt;int&gt; v(size, 42);               // something that takes some time to do

        auto end = std::chrono::{{{1}}}::now();     // the new current &quot;timepoint&quot;

        auto elapsed = end - start;                 // difference is a &quot;duration&quot;

        std::cout &lt;&lt; size &lt;&lt; &quot;: &quot; &lt;&lt; elapsed.count() &lt;&lt; '\n';  // clock ticks (seconds)
    }
}
|output=
1: 1
10: 2
100: 3
1000: 6
10000: 47
100000: 507
1000000: 4822
}}</text>
      <sha1>fcibp7wmcf2p9cxtqxyyl3gzy66h1zg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc duration</title>
    <ns>10</ns>
    <id>8466</id>
    <revision>
      <id>54940</id>
      <parentid>52281</parentid>
      <timestamp>2013-06-01T05:18:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/dcl list duration]] to [[Template:cpp/chrono/dsc duration]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc tclass | cpp/chrono/duration | a time interval | notes={{mark c++11}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc high resolution clock</title>
    <ns>10</ns>
    <id>8470</id>
    <revision>
      <id>54946</id>
      <parentid>52282</parentid>
      <timestamp>2013-06-01T05:18:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/dcl list high resolution clock]] to [[Template:cpp/chrono/dsc high resolution clock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc class | cpp/chrono/high_resolution_clock | the clock with the shortest tick period available | notes={{mark c++11}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;h</title>
    <ns>10</ns>
    <id>12886</id>
    <revision>
      <id>64323</id>
      <timestamp>2013-08-15T17:45:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">{{dsc fun | cpp/chrono/operator&quot;&quot;h | A {{lc|std::chrono::duration}} literal representing hours | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;min</title>
    <ns>10</ns>
    <id>12887</id>
    <revision>
      <id>64329</id>
      <parentid>64324</parentid>
      <timestamp>2013-08-15T17:47:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="123">{{dsc fun | cpp/chrono/operator&quot;&quot;min | A {{lc|std::chrono::duration}} literal representing minutes | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;ms</title>
    <ns>10</ns>
    <id>12889</id>
    <revision>
      <id>64331</id>
      <parentid>64326</parentid>
      <timestamp>2013-08-15T17:47:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/chrono/operator&quot;&quot;ms | A {{lc|std::chrono::duration}} literal representing milliseconds | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;ns</title>
    <ns>10</ns>
    <id>12891</id>
    <revision>
      <id>64333</id>
      <parentid>64328</parentid>
      <timestamp>2013-08-15T17:48:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/chrono/operator&quot;&quot;ns | A {{lc|std::chrono::duration}} literal representing nanoseconds | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;s</title>
    <ns>10</ns>
    <id>12888</id>
    <revision>
      <id>64330</id>
      <parentid>64325</parentid>
      <timestamp>2013-08-15T17:47:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | cpp/chrono/operator&quot;&quot;s | A {{lc|std::chrono::duration}} literal representing seconds | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc operator&quot;&quot;us</title>
    <ns>10</ns>
    <id>12890</id>
    <revision>
      <id>64332</id>
      <parentid>64327</parentid>
      <timestamp>2013-08-15T17:47:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste typo</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/chrono/operator&quot;&quot;us | A {{lc|std::chrono::duration}} literal representing microseconds | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc steady clock</title>
    <ns>10</ns>
    <id>8469</id>
    <revision>
      <id>54949</id>
      <parentid>52283</parentid>
      <timestamp>2013-06-01T05:18:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/dcl list steady clock]] to [[Template:cpp/chrono/dsc steady clock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc class | cpp/chrono/steady_clock | monotonic clock that will never be adjusted | notes={{mark c++11}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc system clock</title>
    <ns>10</ns>
    <id>8468</id>
    <revision>
      <id>54951</id>
      <parentid>52284</parentid>
      <timestamp>2013-06-01T05:18:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/dcl list system clock]] to [[Template:cpp/chrono/dsc system clock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc class | cpp/chrono/system_clock | wall clock time from the system-wide realtime clock  | notes={{mark c++11}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/dsc time point</title>
    <ns>10</ns>
    <id>8467</id>
    <revision>
      <id>54954</id>
      <parentid>52285</parentid>
      <timestamp>2013-06-01T05:18:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/dcl list time point]] to [[Template:cpp/chrono/dsc time point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc tclass | cpp/chrono/time_point | a point in time | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc common type</title>
    <ns>10</ns>
    <id>3410</id>
    <revision>
      <id>54956</id>
      <parentid>52286</parentid>
      <timestamp>2013-06-01T05:18:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list common type]] to [[Template:cpp/chrono/duration/dsc common type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc ptclass | cpp/chrono/duration/common_type | title=std::common_type{{dsc small|&lt;std::chrono::duration&gt;}} | specializes the {{lc|std::common_type}} trait}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc constructor</title>
    <ns>10</ns>
    <id>8621</id>
    <revision>
      <id>54959</id>
      <parentid>52287</parentid>
      <timestamp>2013-06-01T05:18:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list constructor]] to [[Template:cpp/chrono/duration/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem ctor | cpp/chrono/duration/duration | constructs new duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc count</title>
    <ns>10</ns>
    <id>8623</id>
    <revision>
      <id>54963</id>
      <parentid>52288</parentid>
      <timestamp>2013-06-01T05:18:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list count]] to [[Template:cpp/chrono/duration/dsc count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/chrono/duration/count | returns the count of ticks}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc duration cast</title>
    <ns>10</ns>
    <id>8633</id>
    <revision>
      <id>54966</id>
      <parentid>52289</parentid>
      <timestamp>2013-06-01T05:18:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list duration cast]] to [[Template:cpp/chrono/duration/dsc duration cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tfun | cpp/chrono/duration/duration_cast | converts a duration to another, with a different tick interval}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc max</title>
    <ns>10</ns>
    <id>8626</id>
    <revision>
      <id>54969</id>
      <parentid>52290</parentid>
      <timestamp>2013-06-01T05:18:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list max]] to [[Template:cpp/chrono/duration/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem sfun | cpp/chrono/duration/max | returns the special duration value max}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc min</title>
    <ns>10</ns>
    <id>8625</id>
    <revision>
      <id>54975</id>
      <parentid>52291</parentid>
      <timestamp>2013-06-01T05:18:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list min]] to [[Template:cpp/chrono/duration/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem sfun | cpp/chrono/duration/min | returns the special duration value min}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator=</title>
    <ns>10</ns>
    <id>8622</id>
    <revision>
      <id>54978</id>
      <parentid>52292</parentid>
      <timestamp>2013-06-01T05:18:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator=]] to [[Template:cpp/chrono/duration/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/chrono/duration/operator{{=}} | assigns the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator arith</title>
    <ns>10</ns>
    <id>8627</id>
    <revision>
      <id>54980</id>
      <parentid>52293</parentid>
      <timestamp>2013-06-01T05:18:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator arith]] to [[Template:cpp/chrono/duration/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/chrono/duration/operator_arith | title=operator+&lt;br&gt;operator-| implements unary + and unary -}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator arith2</title>
    <ns>10</ns>
    <id>8628</id>
    <revision>
      <id>54983</id>
      <parentid>52294</parentid>
      <timestamp>2013-06-01T05:18:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator arith2]] to [[Template:cpp/chrono/duration/dsc operator arith2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="193">{{dsc mem fun | cpp/chrono/duration/operator_arith2 | title=operator++&lt;br&gt;operator++{{dsc small|(int)}}&lt;br&gt;operator--&lt;br&gt;operator--{{dsc small|(int)}}| increments or decrements the tick count}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator arith3</title>
    <ns>10</ns>
    <id>8629</id>
    <revision>
      <id>54985</id>
      <parentid>52295</parentid>
      <timestamp>2013-06-01T05:18:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator arith3]] to [[Template:cpp/chrono/duration/dsc operator arith3]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="182">{{dsc mem fun | cpp/chrono/duration/operator_arith3 | title=operator+=&lt;br&gt;operator-=&lt;br&gt;operator*=&lt;br&gt;operator/=&lt;br&gt;operator%=| implements compound assignment between two durations}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator arith4</title>
    <ns>10</ns>
    <id>9402</id>
    <revision>
      <id>54990</id>
      <parentid>52296</parentid>
      <timestamp>2013-06-01T05:18:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator arith4]] to [[Template:cpp/chrono/duration/dsc operator arith4]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="183">{{dsc tfun | cpp/chrono/duration/operator_arith4 | title=operator+&lt;br&gt;operator-&lt;br&gt;operator*&lt;br&gt;operator/&lt;br&gt;operator% | implements arithmetic operations with durations as arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc operator cmp</title>
    <ns>10</ns>
    <id>9403</id>
    <revision>
      <id>54994</id>
      <parentid>52297</parentid>
      <timestamp>2013-06-01T05:18:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list operator cmp]] to [[Template:cpp/chrono/duration/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/chrono/duration/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares two durations}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/dsc zero</title>
    <ns>10</ns>
    <id>8624</id>
    <revision>
      <id>54999</id>
      <parentid>52298</parentid>
      <timestamp>2013-06-01T05:18:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/dcl list zero]] to [[Template:cpp/chrono/duration/dsc zero]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem sfun | cpp/chrono/duration/zero | returns the special duration value zero}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/navbar</title>
    <ns>10</ns>
    <id>5054</id>
    <revision>
      <id>39863</id>
      <parentid>36014</parentid>
      <timestamp>2012-09-28T19:57:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="324">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/duration/navbar heading
|content4 = cpp/chrono/duration/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/navbar content</title>
    <ns>10</ns>
    <id>8630</id>
    <revision>
      <id>66475</id>
      <parentid>62334</parentid>
      <timestamp>2013-11-24T14:32:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+literals</comment>
      <text xml:space="preserve" bytes="1477">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/duration/duration}}
{{nv mem ln | cpp/chrono/duration/operator{{=}} }}
{{nv mem ln | cpp/chrono/duration/count}}
{{nv mem ln | cpp/chrono/duration/zero}}
{{nv mem ln | cpp/chrono/duration/min}}
{{nv mem ln | cpp/chrono/duration/max}}
{{nv mem ln | cpp/chrono/duration/operator_arith | operator+ | operator-}}
{{nv mem ln | cpp/chrono/duration/operator_arith2 | operator++ | operator--}}
{{nv mem ln | cpp/chrono/duration/operator_arith3 | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} | operator%{{=}} }}
{{nv h1 | Non-member functions}}
{{nv col begin}}
{{nv ln | cpp/chrono/duration/operator_arith4 | operator+ | operator- | operator* | operator/ | operator% }}
{{nv ln | cpp/chrono/duration/operator_cmp | operator{{==}} | operator!{{=}} | operator&lt; | operator&lt;{{=}} | operator&gt; | operator&gt;{{=}} }}
{{nv col next}}
{{nv ln | cpp/chrono/duration/common_type }}
{{nv ln | cpp/chrono/duration/duration_cast }}
{{nv ln | cpp/chrono/operator&quot;&quot;h|notes={{mark c++14}}}}
{{nv ln | cpp/chrono/operator&quot;&quot;min|notes={{mark c++14}}}}
{{nv ln | cpp/chrono/operator&quot;&quot;s|notes={{mark c++14}}}}
{{nv ln | cpp/chrono/operator&quot;&quot;ms|notes={{mark c++14}}}}
{{nv ln | cpp/chrono/operator&quot;&quot;us|notes={{mark c++14}}}}
{{nv ln | cpp/chrono/operator&quot;&quot;ns|notes={{mark c++14}}}}
{{nv col end}}
{{nv h1 | Helper classes}}
{{nv ln | cpp/chrono/treat_as_floating_point }}
{{nv ln | cpp/chrono/duration_values}}
{{nv end}}</text>
      <sha1>05jqxybp4mv5pxw5xhakt5mbylhgrog</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/navbar heading</title>
    <ns>10</ns>
    <id>5056</id>
    <revision>
      <id>35542</id>
      <parentid>18303</parentid>
      <timestamp>2012-06-15T22:28:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration/sidebar heading]] to [[Template:cpp/chrono/duration/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="49">{{ltt|cpp/chrono/duration|std::chrono::duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration/title</title>
    <ns>10</ns>
    <id>8475</id>
    <revision>
      <id>31219</id>
      <timestamp>2012-05-16T05:03:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=chrono::duration::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/dsc max</title>
    <ns>10</ns>
    <id>8638</id>
    <revision>
      <id>55003</id>
      <parentid>52300</parentid>
      <timestamp>2013-06-01T05:19:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration values/dcl list max]] to [[Template:cpp/chrono/duration values/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem sfun | cpp/chrono/duration_values/max | returns the largest possible representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/dsc min</title>
    <ns>10</ns>
    <id>8637</id>
    <revision>
      <id>55009</id>
      <parentid>52301</parentid>
      <timestamp>2013-06-01T05:19:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration values/dcl list min]] to [[Template:cpp/chrono/duration values/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem sfun | cpp/chrono/duration_values/min | returns the smallest possible representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/dsc zero</title>
    <ns>10</ns>
    <id>8639</id>
    <revision>
      <id>55012</id>
      <parentid>52302</parentid>
      <timestamp>2013-06-01T05:19:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/duration values/dcl list zero]] to [[Template:cpp/chrono/duration values/dsc zero]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem sfun | cpp/chrono/duration_values/zero | returns a zero-length representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/navbar</title>
    <ns>10</ns>
    <id>8647</id>
    <revision>
      <id>39864</id>
      <parentid>36374</parentid>
      <timestamp>2012-09-28T19:57:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="433">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/duration/navbar heading
|content4 = cpp/chrono/duration/navbar content

|heading5 = cpp/chrono/duration_values/navbar heading
|content5 = cpp/chrono/duration_values/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/navbar content</title>
    <ns>10</ns>
    <id>8645</id>
    <revision>
      <id>52303</id>
      <parentid>36372</parentid>
      <timestamp>2013-06-01T04:43:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="194">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/duration_values/zero}}
{{nv mem ln | cpp/chrono/duration_values/min}}
{{nv mem ln | cpp/chrono/duration_values/max}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/navbar heading</title>
    <ns>10</ns>
    <id>8646</id>
    <revision>
      <id>36373</id>
      <timestamp>2012-06-18T15:08:06Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="63">{{ltt|cpp/chrono/duration_values|std::chrono::duration_values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/duration values/title</title>
    <ns>10</ns>
    <id>8644</id>
    <revision>
      <id>36369</id>
      <timestamp>2012-06-18T13:56:45Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/title | n=chrono::duration_values::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/high resolution clock/navbar</title>
    <ns>10</ns>
    <id>5264</id>
    <revision>
      <id>39865</id>
      <parentid>36016</parentid>
      <timestamp>2012-09-28T19:57:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="350">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/high_resolution_clock/navbar heading
|content4 = cpp/chrono/high_resolution_clock/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/high resolution clock/navbar content</title>
    <ns>10</ns>
    <id>5276</id>
    <revision>
      <id>52304</id>
      <parentid>35544</parentid>
      <timestamp>2013-06-01T04:43:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="105">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/high_resolution_clock/now}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/high resolution clock/navbar heading</title>
    <ns>10</ns>
    <id>5268</id>
    <revision>
      <id>35536</id>
      <parentid>19190</parentid>
      <timestamp>2012-06-15T22:28:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/high resolution clock/sidebar heading]] to [[Template:cpp/chrono/high resolution clock/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="75">{{ltt|cpp/chrono/high_resolution_clock|std::chrono::high_resolution_clock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/high resolution clock/title</title>
    <ns>10</ns>
    <id>5281</id>
    <revision>
      <id>19208</id>
      <timestamp>2012-02-29T16:41:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="126">&lt;onlyinclude&gt;{{cpp/title | n=chrono::high_resolution_clock::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/navbar</title>
    <ns>10</ns>
    <id>2039</id>
    <revision>
      <id>39866</id>
      <parentid>36017</parentid>
      <timestamp>2012-09-28T19:57:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/navbar content</title>
    <ns>10</ns>
    <id>2715</id>
    <revision>
      <id>52305</id>
      <parentid>36470</parentid>
      <timestamp>2013-06-01T04:43:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="371">{{nv begin}}
{{nv ln | cpp/chrono/time_point | notes={{mark c++11}}}}
{{nv ln | cpp/chrono/duration | notes={{mark c++11}}}}
{{nv ln | cpp/chrono/system_clock | notes={{mark c++11}}}}
{{nv ln | cpp/chrono/steady_clock | notes={{mark c++11}}}}
{{nv ln | cpp/chrono/high_resolution_clock | notes={{mark c++11}}}}
{{nv | [[cpp/chrono/c | C-style date and time]]}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/navbar heading</title>
    <ns>10</ns>
    <id>2040</id>
    <revision>
      <id>35546</id>
      <parentid>4345</parentid>
      <timestamp>2012-06-15T22:28:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/sidebar heading]] to [[Template:cpp/chrono/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="38">[[cpp/chrono|Date and time utilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/steady clock/navbar</title>
    <ns>10</ns>
    <id>5263</id>
    <revision>
      <id>39867</id>
      <parentid>36018</parentid>
      <timestamp>2012-09-28T19:57:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="332">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/steady_clock/navbar heading
|content4 = cpp/chrono/steady_clock/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/steady clock/navbar content</title>
    <ns>10</ns>
    <id>5275</id>
    <revision>
      <id>52306</id>
      <parentid>35548</parentid>
      <timestamp>2013-06-01T04:43:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="96">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/steady_clock/now}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/steady clock/navbar heading</title>
    <ns>10</ns>
    <id>5265</id>
    <revision>
      <id>35549</id>
      <parentid>19185</parentid>
      <timestamp>2012-06-15T22:28:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/steady clock/sidebar heading]] to [[Template:cpp/chrono/steady clock/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="57">{{ltt|cpp/chrono/steady_clock|std::chrono::steady_clock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/steady clock/title</title>
    <ns>10</ns>
    <id>5282</id>
    <revision>
      <id>19209</id>
      <timestamp>2012-02-29T16:41:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=chrono::steady_clock::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/dsc from time t</title>
    <ns>10</ns>
    <id>5273</id>
    <revision>
      <id>55016</id>
      <parentid>52307</parentid>
      <timestamp>2013-06-01T05:19:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/system clock/dcl list from time t]] to [[Template:cpp/chrono/system clock/dsc from time t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem sfun | cpp/chrono/system_clock/from_time_t | converts {{lc|std::time_t}} to a system clock time point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/dsc now</title>
    <ns>10</ns>
    <id>5271</id>
    <revision>
      <id>55020</id>
      <parentid>52308</parentid>
      <timestamp>2013-06-01T05:19:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/system clock/dcl list now]] to [[Template:cpp/chrono/system clock/dsc now]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc mem sfun | cpp/chrono/system_clock/now  | returns a {{lc|std::chrono::time_point}} representing the current point in time}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/dsc to time t</title>
    <ns>10</ns>
    <id>5272</id>
    <revision>
      <id>55023</id>
      <parentid>52309</parentid>
      <timestamp>2013-06-01T05:19:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/system clock/dcl list to time t]] to [[Template:cpp/chrono/system clock/dsc to time t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem sfun | cpp/chrono/system_clock/to_time_t | converts a system clock time point to {{lc|std::time_t}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/navbar</title>
    <ns>10</ns>
    <id>5262</id>
    <revision>
      <id>39868</id>
      <parentid>36000</parentid>
      <timestamp>2012-09-28T19:57:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="333">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/system_clock/navbar heading
|content4 = cpp/chrono/system_clock/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/navbar content</title>
    <ns>10</ns>
    <id>5274</id>
    <revision>
      <id>52310</id>
      <parentid>34003</parentid>
      <timestamp>2013-06-01T04:43:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="198">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/system_clock/now}}
{{nv mem ln | cpp/chrono/system_clock/to_time_t}}
{{nv mem ln | cpp/chrono/system_clock/from_time_t}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/navbar heading</title>
    <ns>10</ns>
    <id>5267</id>
    <revision>
      <id>35550</id>
      <parentid>19187</parentid>
      <timestamp>2012-06-15T22:28:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/system clock/sidebar heading]] to [[Template:cpp/chrono/system clock/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="57">{{ltt|cpp/chrono/system_clock|std::chrono::system_clock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/system clock/title</title>
    <ns>10</ns>
    <id>5270</id>
    <revision>
      <id>19192</id>
      <timestamp>2012-02-29T16:30:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=chrono::system_clock::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time poind/dsc time since epoch</title>
    <ns>10</ns>
    <id>9534</id>
    <revision>
      <id>55027</id>
      <parentid>52311</parentid>
      <timestamp>2013-06-01T05:19:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time poind/dcl list time since epoch]] to [[Template:cpp/chrono/time poind/dsc time since epoch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/chrono/time_point/time_since_epoch | returns the time point as duration since the start of its clock }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc common type</title>
    <ns>10</ns>
    <id>3411</id>
    <revision>
      <id>55030</id>
      <parentid>52312</parentid>
      <timestamp>2013-06-01T05:19:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list common type]] to [[Template:cpp/chrono/time point/dsc common type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc ptclass | cpp/chrono/time_point/common_type | title=std::common_type{{dsc small|&lt;std::chrono::time_point&gt;}} | specializes the {{lc|std::common_type}} trait}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc constructor</title>
    <ns>10</ns>
    <id>9533</id>
    <revision>
      <id>55035</id>
      <parentid>52313</parentid>
      <timestamp>2013-06-01T05:19:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list constructor]] to [[Template:cpp/chrono/time point/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem ctor | cpp/chrono/time_point/time_point | constructs a new time point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc max</title>
    <ns>10</ns>
    <id>8655</id>
    <revision>
      <id>55038</id>
      <parentid>52314</parentid>
      <timestamp>2013-06-01T05:19:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list max]] to [[Template:cpp/chrono/time point/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem sfun | cpp/chrono/time_point/max | returns the time point corresponding to the largest duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc min</title>
    <ns>10</ns>
    <id>8654</id>
    <revision>
      <id>55044</id>
      <parentid>52315</parentid>
      <timestamp>2013-06-01T05:19:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list min]] to [[Template:cpp/chrono/time point/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem sfun | cpp/chrono/time_point/min | returns the time point corresponding to the smallest duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc operator arith</title>
    <ns>10</ns>
    <id>9535</id>
    <revision>
      <id>61304</id>
      <parentid>55046</parentid>
      <timestamp>2013-06-05T21:15:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem fun | cpp/chrono/time_point/operator_arith | title=operator+=&lt;br&gt;operator-= | modifies the time point by the given duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc operator arith2</title>
    <ns>10</ns>
    <id>9536</id>
    <revision>
      <id>61292</id>
      <parentid>55051</parentid>
      <timestamp>2013-06-05T14:24:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/chrono/time_point/operator_arith2 | title=operator+&lt;br&gt;operator- | modifies the time point by the given duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc operator cmp</title>
    <ns>10</ns>
    <id>9537</id>
    <revision>
      <id>55055</id>
      <parentid>52318</parentid>
      <timestamp>2013-06-01T05:19:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list operator cmp]] to [[Template:cpp/chrono/time point/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc tfun | cpp/chrono/time_point/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares two time points}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/dsc time point cast</title>
    <ns>10</ns>
    <id>9538</id>
    <revision>
      <id>55059</id>
      <parentid>52319</parentid>
      <timestamp>2013-06-01T05:19:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/dcl list time point cast]] to [[Template:cpp/chrono/time point/dsc time point cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc tfun | cpp/chrono/time_point/time_point_cast | converts a time point to another time point on the same clock, with a different duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/navbar</title>
    <ns>10</ns>
    <id>5055</id>
    <revision>
      <id>39869</id>
      <parentid>36019</parentid>
      <timestamp>2012-09-28T19:57:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/chrono/navbar heading
|content3 = cpp/chrono/navbar content

|heading4 = cpp/chrono/time_point/navbar heading
|content4 = cpp/chrono/time_point/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/navbar content</title>
    <ns>10</ns>
    <id>8652</id>
    <revision>
      <id>52320</id>
      <parentid>36415</parentid>
      <timestamp>2013-06-01T04:44:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="662">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/chrono/time_point/time_point}}
{{nv mem ln | cpp/chrono/time_point/time_since_epoch}}
{{nv mem ln | cpp/chrono/time_point/operator_arith | operator+ | operator-}}
{{nv mem ln | cpp/chrono/time_point/min}}
{{nv mem ln | cpp/chrono/time_point/max}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/chrono/time_point/common_type }}
{{nv ln | cpp/chrono/time_point/operator_arith2 | operator+ | operator-}}
{{nv ln | cpp/chrono/time_point/operator_cmp | operator{{==}} | operator!{{=}} | operator&lt; | operator&lt;{{=}} | operator&gt; | operator&gt;{{=}} }}
{{nv ln | cpp/chrono/time_point/time_point_cast }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/navbar heading</title>
    <ns>10</ns>
    <id>5057</id>
    <revision>
      <id>35552</id>
      <parentid>18304</parentid>
      <timestamp>2012-06-15T22:28:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/chrono/time point/sidebar heading]] to [[Template:cpp/chrono/time point/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="53">{{ltt|cpp/chrono/time_point|std::chrono::time_point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/time point/title</title>
    <ns>10</ns>
    <id>8650</id>
    <revision>
      <id>36413</id>
      <timestamp>2012-06-19T15:32:50Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=chrono::time_point::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/chrono/title</title>
    <ns>10</ns>
    <id>5052</id>
    <revision>
      <id>18297</id>
      <timestamp>2012-01-29T16:02:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=chrono::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/codecvt/title</title>
    <ns>10</ns>
    <id>4436</id>
    <revision>
      <id>15808</id>
      <timestamp>2011-12-15T18:43:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=codecvt::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/concept/concept note</title>
    <ns>10</ns>
    <id>5544</id>
    <revision>
      <id>20409</id>
      <timestamp>2012-03-25T14:25:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="192">Note, that the standard doesn't define a named requirement or concept with this name. This is a type category defined by the core language. It is included here as concept only for consistency.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/concept/navbar</title>
    <ns>10</ns>
    <id>5423</id>
    <revision>
      <id>39870</id>
      <parentid>35553</parentid>
      <timestamp>2012-09-28T19:57:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="154">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/concept/navbar heading
|content2 = cpp/concept/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/concept/navbar content</title>
    <ns>10</ns>
    <id>5425</id>
    <revision>
      <id>65469</id>
      <parentid>65462</parentid>
      <timestamp>2013-09-15T15:53:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>sharedmutex</comment>
      <text xml:space="preserve" bytes="3455">{{nv begin}}

{{nv h1 | Basic}}
{{nv col begin}}
{{nv ln | cpp/concept/DefaultConstructible}}
{{nv ln | cpp/concept/CopyAssignable}}
{{nv ln | cpp/concept/CopyConstructible}}
{{nv col next}}
{{nv ln | cpp/concept/MoveAssignable | notes={{mark c++11}}}}
{{nv ln | cpp/concept/MoveConstructible | notes={{mark c++11}}}}
{{nv ln | cpp/concept/Destructible}}
{{nv col end}}

{{nv h1 | Library-Wide}}
{{nv col begin}}
{{nv ln | cpp/concept/EqualityComparable}}
{{nv ln | cpp/concept/LessThanComparable}}
{{nv ln | cpp/concept/Swappable | notes={{mark c++11}} }}
{{nv ln | cpp/concept/ValueSwappable | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/concept/NullablePointer | notes={{mark c++11}} }}
{{nv ln | cpp/concept/Hash | notes={{mark c++11}} }}
{{nv ln | cpp/concept/Allocator}}
{{nv col end}}

{{nv h1 | Container}}
{{nv col begin}}
{{nv ln | cpp/concept/Container}}
{{nv ln | cpp/concept/SequenceContainer}}
{{nv ln | cpp/concept/ReversibleContainer}}
{{nv col next}}
{{nv ln | cpp/concept/AssociativeContainer}}
{{nv ln | cpp/concept/AllocatorAwareContainer}}
{{nv ln | cpp/concept/UnorderedAssociativeContainer | notes={{mark c++11}} }}
{{nv col end}}
{{nv h2 | Container Elements}}
{{nv col begin}}
{{nv ln | cpp/concept/CopyInsertable | notes={{mark c++11}} }}
{{nv ln | cpp/concept/MoveInsertable | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/concept/EmplaceConstructible | notes={{mark c++11}} }}
{{nv col end}}

{{nv h1 | Iterator}}
{{nv col begin}}
{{nv ln | cpp/concept/Iterator}}
{{nv ln | cpp/concept/OutputIterator}}
{{nv ln | cpp/concept/InputIterator}}
{{nv col next}}
{{nv ln | cpp/concept/ForwardIterator}}
{{nv ln | cpp/concept/BidirectionalIterator}}
{{nv ln | cpp/concept/RandomAccessIterator}}
{{nv col end}}

{{nv h1 | Stream I/O}}
{{nv col begin}}
{{nv ln | cpp/concept/FormattedInputFunction}}
{{nv ln | cpp/concept/UnformattedInputFunction}}
{{nv col next}}
{{nv ln | cpp/concept/FormattedOutputFunction}}
{{nv ln | cpp/concept/UnformattedOutputFunction}}
{{nv col end}}

{{nv h1 | Random Numbers}}
{{nv col begin}}
{{nv ln | cpp/concept/SeedSequence | notes={{mark c++11}} }}
{{nv ln | cpp/concept/RandomNumberEngine|notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/concept/RandomNumberDistribution | notes={{mark c++11}} }}
{{nv ln | cpp/concept/UniformRandomNumberGenerator | notes={{mark c++11}} }}
{{nv ln | cpp/concept/RandomNumberEngineAdaptor | notes={{mark c++11}} }}
{{nv col end}}

{{nv h1 | Concurrency}}
{{nv col begin}}
{{nv ln | cpp/concept/BasicLockable | notes={{mark c++11}} }}
{{nv ln | cpp/concept/Lockable | notes={{mark c++11}} }}
{{nv ln | cpp/concept/TimedLockable | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/concept/Mutex | notes={{mark c++11}} }}
{{nv ln | cpp/concept/TimedMutex | notes={{mark c++11}} }}
{{nv ln | cpp/concept/SharedMutex | notes={{mark c++14}} }}
{{nv col end}}

{{nv h1 | Other}}
{{nv col begin}}
{{nv ln | cpp/concept/CharTraits }}
{{nv ln | cpp/concept/pos_type }}
{{nv ln | cpp/concept/off_type}}
{{nv ln | cpp/concept/Clock | notes={{mark c++11}} }}
{{nv ln | cpp/concept/BitmaskType }}
{{nv col next}}
{{nv ln | cpp/concept/UnaryTypeTrait | notes={{mark c++11}} }}
{{nv ln | cpp/concept/BinaryTypeTrait | notes={{mark c++11}} }}
{{nv ln | cpp/concept/TransformationTrait | notes={{mark c++11}} }}
{{nv ln | cpp/concept/TrivialClock | notes={{mark c++11}} }}
{{nv ln | cpp/concept/LiteralType |notes={{mark c++11}} }}
{{nv col end}}

{{nv end}}</text>
      <sha1>g7zzjh0turdx57fatukv4hflji57p2u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/concept/navbar heading</title>
    <ns>10</ns>
    <id>5424</id>
    <revision>
      <id>35555</id>
      <parentid>19661</parentid>
      <timestamp>2012-06-15T22:28:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/concept/sidebar heading]] to [[Template:cpp/concept/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="30">[[cpp/concept | C++ concepts]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/concept/title</title>
    <ns>10</ns>
    <id>5421</id>
    <revision>
      <id>19637</id>
      <timestamp>2012-03-11T12:41:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="70">&lt;onlyinclude&gt;{{title | {{small|C++ concepts:}} {{{1}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container//navbar</title>
    <ns>10</ns>
    <id>1905</id>
    <redirect title="Template:cpp/container/navbar" />
    <revision>
      <id>36847</id>
      <parentid>35556</parentid>
      <timestamp>2012-07-02T17:52:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:cpp/container/navbar]]</comment>
      <text xml:space="preserve" bytes="43">#redirect [[Template:cpp/container/navbar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container//title</title>
    <ns>10</ns>
    <id>1906</id>
    <revision>
      <id>3811</id>
      <parentid>3810</parentid>
      <timestamp>2011-06-06T23:02:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container//value compare/title</title>
    <ns>10</ns>
    <id>9935</id>
    <revision>
      <id>47093</id>
      <timestamp>2013-04-23T16:35:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;!-- --&gt;&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/dsc get</title>
    <ns>10</ns>
    <id>4579</id>
    <revision>
      <id>55062</id>
      <parentid>52322</parentid>
      <timestamp>2013-06-01T05:19:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/array/dcl list get]] to [[Template:cpp/container/array/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/container/array/get | title=std::get{{dsc small|(std::array)}} | accesses an element of an {{tt|array}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/dsc tuple element</title>
    <ns>10</ns>
    <id>4581</id>
    <revision>
      <id>55066</id>
      <parentid>52323</parentid>
      <timestamp>2013-06-01T05:19:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/array/dcl list tuple element]] to [[Template:cpp/container/array/dsc tuple element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc ptclass | cpp/container/array/tuple_element | title=std::tuple_element{{dsc small|&lt;std::array&gt;}}|obtains the type of the elements of {{tt|array}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/dsc tuple size</title>
    <ns>10</ns>
    <id>4580</id>
    <revision>
      <id>55069</id>
      <parentid>52324</parentid>
      <timestamp>2013-06-01T05:19:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/array/dcl list tuple size]] to [[Template:cpp/container/array/dsc tuple size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc ptclass | cpp/container/array/tuple_size | title=std::tuple_size{{dsc small|&lt;std::array&gt;}} |obtains the size of an {{tt|array}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/example empty</title>
    <ns>10</ns>
    <id>10032</id>
    <revision>
      <id>52325</id>
      <parentid>47711</parentid>
      <timestamp>2013-06-01T04:44:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="439">{{example
 | The following code uses {{tt|empty}} to check if a {{lc|std::array}} contains any elements:
 | code=
#include &lt;array&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::array&lt;int, 4&gt; numbers {3, 1, 4, 1};
    std::array&lt;int, 0&gt; no_numbers;

    std::cout &lt;&lt; &quot;numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;no_numbers.empty(): &quot; &lt;&lt; no_numbers.empty() &lt;&lt; '\n';
}
 | output=
numbers.empty(): 0
no_numbers.empty(): 1
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/example size</title>
    <ns>10</ns>
    <id>10043</id>
    <revision>
      <id>52326</id>
      <parentid>47732</parentid>
      <timestamp>2013-06-01T04:44:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="322">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::array}}:
 | code=
#include &lt;array&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::array&lt;int, 4&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/navbar</title>
    <ns>10</ns>
    <id>1907</id>
    <revision>
      <id>39871</id>
      <parentid>35557</parentid>
      <timestamp>2012-09-28T19:57:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/array/navbar heading
|content3 = cpp/container/array/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/navbar content</title>
    <ns>10</ns>
    <id>1908</id>
    <revision>
      <id>52327</id>
      <parentid>35558</parentid>
      <timestamp>2013-06-01T04:44:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1041">{{nv begin}}
{{nv h1 | Member functions}}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/array/at }}
{{nv mem ln | cpp/container/array/operator_at | operator[] }}
{{nv mem ln | cpp/container/array/front }}
{{nv mem ln | cpp/container/array/back }}
{{nv mem ln | cpp/container/array/data }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/array/begin | begin | cbegin}}
{{nv mem ln | cpp/container/array/end | end | cend}}
{{nv mem ln | cpp/container/array/rbegin | rbegin | crbegin}}
{{nv mem ln | cpp/container/array/rend | rend | crend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/array/empty}}
{{nv mem ln | cpp/container/array/size}}
{{nv mem ln | cpp/container/array/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/array/fill}}
{{nv mem ln | cpp/container/array/swap}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/container/array/get}}
{{nv ln | cpp/container/array/swap2|swap}}
{{nv h1 | Helper classes}}
{{nv ln | cpp/container/array/tuple_size}}
{{nv ln | cpp/container/array/tuple_element}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/navbar heading</title>
    <ns>10</ns>
    <id>1909</id>
    <revision>
      <id>35559</id>
      <parentid>3817</parentid>
      <timestamp>2012-06-15T22:28:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/array/sidebar heading]] to [[Template:cpp/container/array/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="40">{{ltt|cpp/container/array | std::array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/array/title</title>
    <ns>10</ns>
    <id>1910</id>
    <revision>
      <id>3819</id>
      <parentid>3818</parentid>
      <timestamp>2011-06-06T23:02:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=array::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/assign</title>
    <ns>10</ns>
    <id>1911</id>
    <revision>
      <id>69731</id>
      <parentid>69730</parentid>
      <timestamp>2014-04-21T21:04:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1772">{{cpp/container/{{{1|}}}/title | assign}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} | 
void assign( size_type count, const T&amp; value );
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
template&lt; class InputIt &gt;
void assign( InputIt first, InputIt last );
}}
{{dcl | num=3 | since=c++11 |
void assign( std::initializer_list&lt;T&gt; ilist );
}}
{{dcl end}}

Replaces the contents of the container.

@1@ Replaces the contents with {{tt|count}} copies of value {{tt|value}}

@2@ Replaces the contents with copies of those in the range {{tt|[first, last)}}. {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}}

@3@ Replaces the contents with the elements from the initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | count | the new size of the container}}
{{par | value | the value to initialize elements of the container with}}
{{par | first, last | the range to copy the elements from}}
{{par | ilist | initializer list to copy the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===

@1@ Linear in {{tt|count}}

@2@ Linear in distance between {{tt|first}} and {{tt|last}}

@3@ Linear in {{c|ilist.size()}}

===Example===
{{example
 | The following code uses {{tt|assign}} to add several characters to a {{c|std::{{{1}}}&lt;char&gt;}}:
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::{{{1}}}&lt;char&gt; characters;
 
    characters.assign(5, 'a');

    for (char c : characters) {
        std::cout &lt;&lt; c &lt;&lt; '\n';
    } 

    return 0;
}
 | output=
a
a
a
a
a
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>422qrhmxeew98tx1pmvyi0wrl016sce</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/assoc note</title>
    <ns>10</ns>
    <id>9952</id>
    <revision>
      <id>47247</id>
      <timestamp>2013-05-02T14:49:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+note on equivalence of iterator and const_iterator and how to avoid ODR violations</comment>
      <text xml:space="preserve" bytes="267">The member types {{tt|iterator}} and {{tt|const_iterator}} may be aliases to the same type. Since {{tt|iterator}} is convertible to {{tt|const_iterator}}, {{tt|const_iterator}} should be used in function parameter lists to avoid violations of the One Definition Rule.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/at</title>
    <ns>10</ns>
    <id>1912</id>
    <revision>
      <id>67659</id>
      <parentid>67658</parentid>
      <timestamp>2014-02-18T16:03:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix template</comment>
      <text xml:space="preserve" bytes="1013">{{cpp/container/{{{1|}}}/title | at}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
reference       at( size_type pos );
}}
{{#ifeq:{{{1}}}|array|
{{dcl rev begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 |
const_reference at( size_type pos ) const;
}}
{{dcl | since=c++14 |
constexpr const_reference at( size_type pos ) const;
}}
{{dcl rev end}}
|
{{dcl | 
const_reference at( size_type pos ) const;
}}
}}
{{dcl end}}

Returns a reference to the element at specified location {{tt|pos}}, with bounds checking. 

If {{tt|pos}} not within the range of the container, an exception of type {{lc|std::out_of_range}} is thrown.

===Parameters===
{{par begin}}
{{par | pos | position of the element to return}}
{{par end}}

===Return value===
Reference to the requested element.

===Exceptions===
{{lc|std::out_of_range}} if {{c|!(pos &lt; size())}}.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_at |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>7dcp4ar9k8nhysmf9g06bsorqvabfnj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/at assoc</title>
    <ns>10</ns>
    <id>1913</id>
    <revision>
      <id>63568</id>
      <parentid>55700</parentid>
      <timestamp>2013-07-10T01:44:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="971">{{cpp/container/{{{1|}}}/title | at}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
T&amp; at( const Key&amp; key );
}}
{{dcl | num=2 | since=c++11 |
const T &amp; at( const Key&amp; key ) const;
}}
{{dcl end}}

Returns a reference to the mapped value of the element with key equivalent to {{tt|key}}. If no such element exists, an exception of type {{lc|std::out_of_range}} is thrown.

===Parameters===
{{par begin}}
{{par | key | the key of the element to find}}
{{par end}}

===Return value===
Reference to the mapped value of the requested element

&lt;!-- ======== --&gt; 
===Exceptions===
{{lc|std::out_of_range}} if the container does not have an element with the specified {{tt|key}}

===Complexity===
{{#switch: {{{1|}}} 
| map = Logarithmic in the size of the container.
| unordered_map = Average case: constant, worst case: linear in size.
| {{todo}} }}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc operator_at |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/back</title>
    <ns>10</ns>
    <id>1914</id>
    <revision>
      <id>68754</id>
      <parentid>68752</parentid>
      <timestamp>2014-03-21T00:42:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>constexpr is for arrays only</comment>
      <text xml:space="preserve" bytes="1383">{{cpp/container/{{{1|}}}/title | back}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
reference back();
}}
{{#ifeq:{{{1}}}|array|
{{dcl rev begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 |
const_reference back() const;
}}
{{dcl | since=c++14 |
constexpr const_reference back() const;
}}
{{dcl rev end}}
|{{dcl | since={{cpp/std|{{{1|}}}}}|
const_reference back() const;
}}
}}
{{dcl end}}

Returns reference to the last element in the container. 

Calling {{tt|back}} on an empty container is undefined.

===Parameters===
(none)

===Return value===
Reference to the last element.

===Complexity===
Constant.

===Notes===
For a container {{tt|c}}, the expression {{c|return c.back();}} is equivalent to {{c|{ auto tmp {{=}} c.end(); --tmp; return *tmp; } }}

===Example===
{{example
 | The following code uses {{tt|back}} to display the last element of a {{c|std::{{{1}}}&lt;char&gt;}}:
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
 
int main()
{
    {{#ifeq:{{{1|}}}|array
|std::{{{1}}}&lt;char, 6&gt; letters {'o', 'm', 'g', 'w', 't', 'f'};
|std::{{{1}}}&lt;char&gt; letters {'o', 'm', 'g', 'w', 't', 'f'};
}}
    if (!letters.empty()) {
        std::cout &lt;&lt; &quot;The last character is: &quot; &lt;&lt; letters.back() &lt;&lt; '\n';
    }  
}
 | output=
The last character is f
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc front |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>bw83os3ntaxart2jfvuhvr2bypn9hdh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/begin</title>
    <ns>10</ns>
    <id>1915</id>
    <revision>
      <id>64869</id>
      <parentid>64770</parentid>
      <timestamp>2013-08-27T01:41:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix since=</comment>
      <text xml:space="preserve" bytes="732">{{cpp/container/{{{1|}}}/title | begin | cbegin}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
iterator begin();
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
const_iterator begin() const;
}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
const_iterator cbegin() const;
}}
{{dcl end}}

Returns an iterator to the first element of the container. 

If the container is empty, the returned iterator will be equal to {{lc|end()}}.

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
Iterator to the first element

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc end |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/begin(int)</title>
    <ns>10</ns>
    <id>9085</id>
    <redirect title="Template:cpp/container/begin2" />
    <revision>
      <id>38139</id>
      <timestamp>2012-07-24T13:29:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/container/begin(int)]] to [[Template:cpp/container/begin2]]: Text replace - &quot;/begin(int)&quot; to &quot;/begin2&quot;</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/container/begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/begin2</title>
    <ns>10</ns>
    <id>1916</id>
    <revision>
      <id>63849</id>
      <parentid>63569</parentid>
      <timestamp>2013-07-29T15:18:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt, use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="724">{{cpp/container/{{{1|}}}/title | begin{{small|(int)}} | cbegin{{small|(int)}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
local_iterator begin( size_type n );
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
const_local_iterator begin( size_type n ) const;
}}
{{dcl | since=c++11 |
const_local_iterator cbegin( size_type n ) const;
}}
{{dcl end}}

Returns an iterator to the first element of the bucket with index {{tt|pos}}. 

===Parameters===
{{par begin}}
{{par | n | the index of the bucket to access}}
{{par end}}

===Return value===
Iterator to the first element.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc end(int) |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/bucket</title>
    <ns>10</ns>
    <id>1917</id>
    <revision>
      <id>62476</id>
      <parentid>62402</parentid>
      <timestamp>2013-07-01T17:16:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorten the summary sentence, expand</comment>
      <text xml:space="preserve" bytes="776">{{cpp/container/{{{1|}}}/title | bucket}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type bucket( const Key&amp; key ) const;
}}
{{dcl end}}

Returns the index of the bucket for key {{tt|key}}. Elements (if any) with keys equivalent to {{tt|key}} are always found in this bucket. The returned value is valid only for instances of the container for which {{lc|bucket_count()}} returns the same value.

The behavior is undefined if {{lc|bucket_count()}} is zero.

===Parameters===
{{par begin}}
{{par | key | the value of the key to examine}}
{{par end}}

===Return value===
Bucket index for the key {{tt|key}}.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc bucket_size |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/bucket count</title>
    <ns>10</ns>
    <id>1918</id>
    <revision>
      <id>62207</id>
      <parentid>55714</parentid>
      <timestamp>2013-06-25T12:09:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="496">{{cpp/container/{{{1|}}}/title | bucket_count}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type bucket_count() const;
}}
{{dcl end}}

Returns the number of buckets in the container.

===Parameters===
(none)

===Return value===
The number of buckets in the container.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc bucket_size |{{{1|}}}}}
{{dsc inc | cpp/container/dsc max_bucket_count |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/bucket size</title>
    <ns>10</ns>
    <id>1919</id>
    <revision>
      <id>62206</id>
      <parentid>55715</parentid>
      <timestamp>2013-06-25T12:09:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="542">{{cpp/container/{{{1|}}}/title | bucket_size}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type bucket_size( size_type n ) const;
}}
{{dcl end}}

Returns the number of elements in the bucket with index {{tt|n}}.

===Parameters===
{{par begin}}
{{par | n | the index of the bucket to examine}}
{{par end}}

===Return value===
The number of elements in the bucket {{tt|n}}.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc bucket_count |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/capacity</title>
    <ns>10</ns>
    <id>1920</id>
    <revision>
      <id>64769</id>
      <parentid>62205</parentid>
      <timestamp>2013-08-26T23:50:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix std markers</comment>
      <text xml:space="preserve" bytes="569">{{cpp/container/{{{1|}}}/title | capacity}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type capacity() const;
}}
{{dcl end}}

Returns the number of elements that the container has currently allocated space for. 

===Parameters===
(none)

===Return value===
Capacity of the currently allocated storage.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc size |{{{1|}}}}}
{{dsc inc | cpp/container/dsc reserve |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/clear</title>
    <ns>10</ns>
    <id>1921</id>
    <revision>
      <id>72032</id>
      <parentid>64916</parentid>
      <timestamp>2014-07-09T17:43:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+until c++14 for the c++11 branch</comment>
      <text xml:space="preserve" bytes="1099">{{cpp/container/{{{1|}}}/title | clear}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void clear();
}}
{{dcl end}}

Removes all elements from the container. 

Invalidates any references, pointers, or iterators referring to contained elements. May invalidate any past-the-end iterators.
{{#ifeq: {{{1|}}} | vector | &amp;nbsp;

Leaves the {{lc|capacity()}} of the vector unchanged.
}}
===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Linear in the size of the container. &lt;!--
--&gt;{{cpp/container/if seq|{{{1|}}}|
{{rev begin}}
{{rev | until=c++11 | {{tt|clear}} is defined in terms of {{tt|erase}}, which has linear complexity.}}
{{rev | since=c++11 | until=c++14 | complexity of {{tt|clear}} is omitted }}
{{rev | since=c++14 | {{tt|clear}} has linear complexity for sequence containers.}}
{{rev end}} }}

===See also===
{{dsc begin}}
{{#ifeq: {{{1|}}} | forward_list
 | {{dsc inc | cpp/container/dsc erase_after |{{{1|}}}}}
 | {{dsc inc | cpp/container/dsc erase |{{{1|}}}}}
}}
{{dsc end}}</text>
      <sha1>j8gbeaub8sg49647ptc85xlid9lqlxm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/constructor</title>
    <ns>10</ns>
    <id>1922</id>
    <revision>
      <id>69728</id>
      <parentid>69727</parentid>
      <timestamp>2014-04-21T20:59:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>...mention why 4 is disabled</comment>
      <text xml:space="preserve" bytes="5613">{{cpp/container/{{{1|}}}/title | {{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 | 1=
explicit {{{1}}}( const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | | 1=
{{{1}}}() : {{{1}}}( Allocator() ) {}
explicit {{{1}}}( const Allocator&amp; alloc );
}}
{{dcl rev end}}
{{#ifeq:{{{1}}}|forward_list
|{{dcl | num=2 | since=c++11 | 1=
{{{1}}}( size_type count, 
{{space as|{{{1}}}}}  const T&amp; value,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator());
}}
|{{dcl rev begin | num=2}}
{{dcl | until=c++11 | 1=
explicit {{{1}}}( size_type count, 
         {{space as|{{{1}}}}}  const T&amp; value = T(),
         {{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator());
}}
{{dcl | since=c++11 | 1=
         {{{1}}}( size_type count, 
         {{space as|{{{1}}}}}  const T&amp; value,
         {{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator());
}}
{{dcl rev end}}
}}
{{dcl rev begin | num=3}}
{{dcl | since=c++11 | until=c++14 |
explicit {{{1}}}( size_type count );
}}
{{dcl | since=c++14 | 1=
explicit {{{1}}}( size_type count, const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl | num=4 | since={{cpp/std|{{{1|}}}}} | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last, 
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=5 | since={{cpp/std|{{{1|}}}}} |
{{{1}}}( const {{{1}}}&amp; other );                           
}}
{{dcl | num=5 | since=c++11 |
{{{1}}}( const {{{1}}}&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=6 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other )
}}
{{dcl | num=6 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=7 | since=c++11 | 1=
{{{1}}}( std::initializer_list&lt;T&gt; init, 
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl end}}

Constructs new container from a variety of data sources and optionally using user supplied allocator {{tt|alloc}}.

@1@ Default constructor. Constructs empty container.

@2@ Constructs the container with {{tt|count}} copies of elements with value {{tt|value}}.

@3@ Constructs the container with {{tt|count}} value-initialized (default constructed, for classes) instances of {{tt|T}}. No copies are made.

@4@ Constructs the container with the contents of the range {{tt|[first, last)}}. {{rev inl|since=c++11|This constructor does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}, to avoid ambiguity with the overload 2}}

@5@ Copy constructor. Constructs the container with the copy of the contents of {{tt|other}}. If {{tt|alloc}} is not provided, allocator is obtained by calling {{c|std::allocator_traits&lt;allocator_type&gt;::select_on_container_copy_construction(other)}}.

@6@ Move constructor. Constructs the container with the contents of {{tt|other}} using move semantics. If {{tt|alloc}} is not provided, allocator is obtained by move-construction from the allocator belonging to {{tt|other}}.
@7@ Constructs the container with the contents of the initializer list {{tt|init}}. 

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of this container}}
{{par | count | the size of the container}}
{{par | value | the value to initialize elements of the container with}}
{{par | first, last | the range to copy the elements from}}
{{par | other | another container to be used as source to initialize the elements of the container with}}
{{par | init | initializer list to initialize the elements of the container with}}
{{par hreq}}
{{par req concept | Allocator | Allocator}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===
@1@ Constant

@2-3@ Linear in {{tt|count}}

@4@ Linear in distance between {{tt|first}} and {{tt|last}}

@5@ Linear in size of {{tt|other}}

@6@ Constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

@7@ Linear in size of {{tt|init}}
{{#ifeq:{{{1}}}|vector|

===Notes===
The overload (3) zeroes out elements of non-class types such as {{c|int}}, which is different from the behavior of [[cpp/language/new|new[] ]], which leaves them uninitialized. To match the behavior of new[], a [http://stackoverflow.com/a/21028912/273767 custom Allocator::constuct] can be provided which leaves such elements uninitialized.

}}
===Example===
{{example
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;

template&lt;typename T&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; s, const std::{{{1}}}&lt;T&gt;&amp; v) {
    s.put('[');
    char comma[3] = {'\0', ' ', '\0'};
    for (const auto&amp; e : v) {
        s &lt;&lt; comma &lt;&lt; e;
        comma[0] = ',';
    }
    return s &lt;&lt; ']';
}

int main() 
{
    // c++11 initializer list syntax:
    std::{{{1}}}&lt;std::string&gt; words1 {&quot;the&quot;, &quot;frogurt&quot;, &quot;is&quot;, &quot;also&quot;, &quot;cursed&quot;};
    std::cout &lt;&lt; &quot;words1: &quot; &lt;&lt; words1 &lt;&lt; '\n';

    // words2 == words1
    std::{{{1}}}&lt;std::string&gt; words2(words1.begin(), words1.end());
    std::cout &lt;&lt; &quot;words2: &quot; &lt;&lt; words2 &lt;&lt; '\n';

    // words3 == words1
    std::{{{1}}}&lt;std::string&gt; words3(words1);
    std::cout &lt;&lt; &quot;words3: &quot; &lt;&lt; words3 &lt;&lt; '\n';

    // words4 is {&quot;Mo&quot;, &quot;Mo&quot;, &quot;Mo&quot;, &quot;Mo&quot;, &quot;Mo&quot;}
    std::{{{1}}}&lt;std::string&gt; words4(5, &quot;Mo&quot;);
    std::cout &lt;&lt; &quot;words4: &quot; &lt;&lt; words4 &lt;&lt; '\n';
}
 | output=
words1: [the, frogurt, is, also, cursed]
words2: [the, frogurt, is, also, cursed]
words3: [the, frogurt, is, also, cursed]
words4: [Mo, Mo, Mo, Mo, Mo]
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc assign |{{{1|}}}}}
{{dsc inc | cpp/container/dsc operator{{=}} |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>e9x2tii4zihms6gqjcuzuwiluxgyf67</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/constructor ad</title>
    <ns>10</ns>
    <id>1923</id>
    <revision>
      <id>63571</id>
      <parentid>63257</parentid>
      <timestamp>2013-07-10T01:44:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3902">{{cpp/container/{{{1|}}}/title | {{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 | 1=
explicit {{{1}}}( const Container&amp; cont = Container() );
}}
{{dcl | since=c++11 | 
explicit {{{1}}}( const Container&amp; cont );
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 |1=
explicit {{{1}}}( Container&amp;&amp; cont = Container() );
}}
{{dcl | num=3 |1=
{{{1}}}( const {{{1}}}&amp; other );
}}
{{dcl | num=4 | since=c++11 | 1=
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=5 | since=c++11 | 1=
template&lt; class Alloc &gt; 
explicit {{{1}}}( const Alloc&amp; alloc );
}}
{{dcl | num=6 | since=c++11 | 1=
template&lt; class Alloc &gt; 
{{{1}}}( const Container&amp; cont, const Alloc&amp; alloc );
}}
{{dcl | num=7 | since=c++11 | 1=
template&lt; class Alloc &gt; 
{{{1}}}( Container&amp;&amp; cont, const Alloc&amp; alloc );
}}
{{dcl | num=8 | since=c++11 | 1=
template&lt; class Alloc &gt; 
{{{1}}}( const {{{1}}}&amp; other, const Alloc&amp; alloc );
}}
{{dcl | num=9 | since=c++11 | 1=
template&lt; class Alloc &gt; 
{{{1}}}( {{{1}}}&amp;&amp; other, const Alloc&amp; alloc );
}}
{{dcl end}}

Constructs new underlying container of the container adaptor from a variety of data sources.

@1@ Copy-constructs the underlying container {{tt|c}} with the contents of {{tt|cont}}. {{rev inl|This is also the default constructor|until=c++11}}

@2@ Move-constructs the underlying container {{tt|c}} with {{c|std::move(cont)}}. {{rev inl|This is also the default constructor|since=c++11}}

@3@ Copy constructor. The adaptor is copy-constructed with the contents of {{c|other.c}}. {{mark implicit}}

@4@ Move constructor. The adaptor is constructed with {{c|std::move(other.c)}}. {{mark implicit}}

@5-9@ The following constructors are only defined if {{c|1=std::uses_allocator&lt;container_type, Alloc&gt;::value == true}}, that is, if the underlying container is an allocator-aware container (true for all standard library containers).

:@5@ Constructs the underlying container using {{tt|alloc}} as allocator. Effectively calls {{c|c(alloc)}}.

:@6@ Constructs the underlying container with the contents of {{tt|cont}} and using {{tt|alloc}} as allocator. Effectively calls {{c|c(cont, alloc)}}.

:@7@ Constructs the underlying container with the contents of {{tt|cont}} using move semantics while utilising {{tt|alloc}} as allocator. Effectively calls {{c|c(std::move(cont), alloc)}}.

:@8@ Constructs the adaptor with the contents of {{tt|other.c}} and using {{tt|alloc}} as allocator. Effectively calls {{c|c(athor.c, alloc)}}.

:@9@ Constructs the adaptor with the contents of {{tt|other}} using move semantics while utilising {{tt|alloc}} as allocator. Effectively calls {{c|c(std::move(other.c), alloc)}}.

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of the underlying container}}
{{par | other | another container adaptor to be used as source to initialize the underlying container}}
{{par | cont | container to be used as source to initialize the underlying container}}
{{par | first, last | range of elements to initialize with}}
{{par hreq}}
{{par req concept | Alloc | Allocator}}
{{par req concept | Container | Container | notes=The constructors (5-10) are only defined if {{tt|Container}} meets the requirements of {{concept|AllocatorAwareContainer}}}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===
1, 3, 5, 6, 8: linear in {{tt|cont}} or {{tt|other}}

2, 4, 7, 9: constant
{{todo}}

===Example===
{{example
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;deque&gt;
#include &lt;iostream&gt;

int main()
{
    std::{{{1}}}&lt;int&gt; c1;
    c1.push(5);
    std::cout &lt;&lt; c1.size() &lt;&lt; '\n';

    std::{{{1}}}&lt;int&gt; c2(c1);
    std::cout &lt;&lt; c2.size() &lt;&lt; '\n';
 
    std::deque&lt;int&gt; deq {3, 1, 4, 1, 5};
    std::{{{1}}}&lt;int&gt; c3(deq);
    std::cout &lt;&lt; c3.size() &lt;&lt; '\n';
}
 | output=
1
1
5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc operator{{=}} | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/constructor ord</title>
    <ns>10</ns>
    <id>1924</id>
    <revision>
      <id>72254</id>
      <parentid>69411</parentid>
      <timestamp>2014-07-31T15:29:14Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>- wrong default arguments</comment>
      <text xml:space="preserve" bytes="6630">{{cpp/container/{{{1|}}}/title | {{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 | 1=
explicit {{{1}}}( const Compare&amp; comp = Compare(), 
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
{{{1}}}() : {{{1}}}( Compare() ) {}
explicit {{{1}}}( const Compare&amp; comp, 
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl | num=1 | since=c++11 | 1=
explicit {{{1}}}( const Allocator&amp; alloc );
}}
{{dcl rev begin | num=2}}
{{dcl | since={{cpp/std|{{{1|}}}}} | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  const Compare&amp; comp = Compare(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  const Allocator&amp; alloc );
}}
{{dcl rev end}}
{{dcl | num=3 | since={{cpp/std|{{{1|}}}}} | 1=
{{{1}}}( const {{{1}}}&amp; other );
}}
{{dcl | num=3 | since=c++11 |
{{{1}}}( const {{{1}}}&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other, const Allocator&amp; alloc );
}}
{{dcl rev begin | num=5}}
{{dcl | since=c++11 | 1=
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  const Compare&amp; comp = Compare(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  const Allocator&amp; );
}}
{{dcl rev end}}
{{dcl end}}

Constructs new container from a variety of data sources and optionally using user supplied allocator {{tt|alloc}} or comparison function object {{tt|comp}}.

@1@ Default constructor. Constructs empty container.

@2@ Constructs the container with the contents of the range {{tt|[first, last)}}.

@3@ Copy constructor. Constructs the container with the copy of the contents of {{tt|other}}. If {{tt|alloc}} is not provided, allocator is obtained by calling {{c|std::allocator_traits&lt;allocator_type&gt;::select_on_copy_construction(other)}}.

@4@ Move constructor. Constructs the container with the contents of {{tt|other}} using move semantics. If {{tt|alloc}} is not provided, allocator is obtained by move-construction from the allocator belonging to {{tt|other}}.

@5@ Constructs the container with the contents of the initializer list {{tt|init}}. 

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of this container}}
{{par | comp | comparison function object to use for all comparisons of keys}}
{{par | first, last | the range to copy the elements from}}
{{par | other | another container to be used as source to initialize the elements of the container with}}
{{par | init | initializer list to initialize the elements of the container with}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | Compare | Compare}}
{{par req concept | Allocator | Allocator}}
{{par end}} 

===Complexity===
@1@ Constant

@2@ {{math|N log(N)}} where {{c|N {{=}} std::distance(first, last)}} in general, linear in {{tt|N}} if the range is already sorted by {{tt|value_comp()}}.

@3@ Linear in size of {{tt|other}}

@4@ Constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

@5@ {{math|N log(N)}} where {{c|N {{=}} init.size())}} in general, linear in {{tt|N}} if {{tt|init}} is already sorted by {{tt|value_comp()}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;iomanip&gt;
#include &lt;map&gt;
 
// helper function templates for printing each element
template&lt;typename CharT, typename Traits, typename T&gt;
void print_item(std::basic_ostream&lt;CharT, Traits&gt;&amp; stream, const T&amp; item)
{
  stream &lt;&lt; item;
}
 
template&lt;typename CharT, typename Traits, typename Alloc&gt;
void print_item(std::basic_ostream&lt;CharT, Traits&gt;&amp; stream,
    const std::basic_string&lt;CharT, Traits, Alloc&gt;&amp; item)
{
  stream &lt;&lt; std::quoted(item);
}
 
// A printer for unordered maps
template&lt;typename Key, typename T, typename Compare, typename Allocator&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; stream,
    const std::map&lt;Key, T, Compare, Allocator&gt;&amp; map)
{
  stream &lt;&lt; '{';
  char comma[3] = {'\0', ' ', '\0'};
  for (const auto&amp; pair : map) {
    stream &lt;&lt; comma;
    print_item(stream, pair.first);
    stream &lt;&lt; ':';
    print_item(stream, pair.second);
    comma[0] = ',';
  }
  stream &lt;&lt; '}';
  return stream;
}

int main()
{
  // (1) Default constructor
  std::map&lt;std::string, int&gt; map1;
  map1[&quot;something&quot;] = 69;
  map1[&quot;anything&quot;] = 199;
  map1[&quot;that thing&quot;] = 50;
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;map1 = &quot; &lt;&lt; map1 &lt;&lt; '\n';
 
  // (2) Iterator constructor
  std::map&lt;std::string, int&gt; iter(map1.find(&quot;anything&quot;), map1.end());
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;iter = &quot; &lt;&lt; iter &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;map1 = &quot; &lt;&lt; map1 &lt;&lt; '\n';
 
  // (3) Copy constructor
  std::map&lt;std::string, int&gt; copied(map1);
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;copied = &quot; &lt;&lt; copied &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;map1 = &quot; &lt;&lt; map1 &lt;&lt; '\n';
 
  // (4) Move constructor
  std::map&lt;std::string, int&gt; moved(std::move(map1));
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;moved = &quot; &lt;&lt; moved &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;map1 = &quot; &lt;&lt; map1 &lt;&lt; '\n';
 
  // (5) Initializer list constructor
  const std::map&lt;std::string, int&gt; init {
    {&quot;this&quot;, 100},
    {&quot;can&quot;, 100},
    {&quot;be&quot;, 100},
    {&quot;const&quot;, 100},
  };
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; '\n';
  std::cout &lt;&lt; &quot;init = &quot; &lt;&lt; init &lt;&lt; '\n';
}
 | output=
--------------------------------------------------------------------------------
map1 = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
--------------------------------------------------------------------------------
iter = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
map1 = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
--------------------------------------------------------------------------------
copied = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
map1 = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
--------------------------------------------------------------------------------
moved = {&quot;anything&quot;:199, &quot;something&quot;:69, &quot;that thing&quot;:50}
map1 = {}
--------------------------------------------------------------------------------
init = {&quot;be&quot;:100, &quot;can&quot;:100, &quot;const&quot;:100, &quot;this&quot;:100}
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc operator{{=}} |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>q1bnmq7g42rc733q8qvpdcbm83xu05s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/constructor ordset</title>
    <ns>10</ns>
    <id>13684</id>
    <revision>
      <id>71801</id>
      <parentid>71800</parentid>
      <timestamp>2014-06-24T14:48:41Z</timestamp>
      <contributor>
        <username>DizzySkin</username>
        <id>3171</id>
      </contributor>
      <comment>Fixed insert and find statements.</comment>
      <text xml:space="preserve" bytes="7234">{{cpp/container/{{{1|}}}/title | {{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 | 1=
explicit {{{1}}}( const Compare&amp; comp = Compare(), 
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
{{{1}}}() : {{{1}}}( Compare() ) {}
explicit {{{1}}}( const Compare&amp; comp, 
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl | num=1 | since=c++11 | 1=
explicit {{{1}}}( const Allocator&amp; alloc );
}}
{{dcl rev begin | num=2}}
{{dcl | since={{cpp/std|{{{1|}}}}} | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  const Compare&amp; comp = Compare(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl | num=3 | since={{cpp/std|{{{1|}}}}} | 1=
{{{1}}}( const {{{1}}}&amp; other );
}}
{{dcl | num=3 | since=c++11 |
{{{1}}}( const {{{1}}}&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other, const Allocator&amp; alloc );
}}
{{dcl rev begin | num=5}}
{{dcl | since=c++11 | 1=
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  const Compare&amp; comp = Compare(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14 | 1=
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl end}}

Constructs new container from a variety of data sources and optionally using user supplied allocator {{tt|alloc}} or comparison function object {{tt|comp}}.

1) Default constructor. Constructs empty container.

2) Constructs the container with the contents of the range {{tt|[first, last)}}.

3) Copy constructor. Constructs the container with the copy of the contents of {{tt|other}}. If {{tt|alloc}} is not provided, allocator is obtained by calling {{c|std::allocator_traits&lt;allocator_type&gt;::select_on_copy_construction(other)}}.

4) Move constructor. Constructs the container with the contents of {{tt|other}} using move semantics. If {{tt|alloc}} is not provided, allocator is obtained by move-construction from the allocator belonging to {{tt|other}}.

5) Constructs the container with the contents of the initializer list {{tt|init}}. 

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of this container}}
{{par | comp | comparison function object to use for all comparisons of keys}}
{{par | first, last | the range to copy the elements from}}
{{par | other | another container to be used as source to initialize the elements of the container with}}
{{par | init | initializer list to initialize the elements of the container with}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par req concept | Compare | Compare}}
{{par req concept | Allocator | Allocator}}
{{par end}} 

===Complexity===
1) Constant

2) {{math|N log(N)}} where {{c|N {{=}} std::distance(first, last)}} in general, linear in {{tt|N}} if the range is already sorted by {{tt|value_comp()}}.

3) Linear in size of {{tt|other}}

4) Constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.

5) {{math|N log(N)}} where {{c|N {{=}} init.size())}} in general, linear in {{tt|N}} if {{tt|init}} is already sorted by {{tt|value_comp()}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
{{cpp/container/correct include assoc| {{{1|set}}}}}
 
// Helper function for printing pairs.
template&lt;class Ch, class Tr, class A, class B&gt; inline
std::basic_ostream&lt;Ch, Tr&gt;&amp; operator&lt;&lt;(std::basic_ostream&lt;Ch, Tr&gt;&amp; stream, std::pair&lt;A,B&gt; p)
{
  return stream &lt;&lt; '(' &lt;&lt; p.first &lt;&lt; &quot;, &quot; &lt;&lt; p.second &lt;&lt; ')';
}

// Helper function for printing containers.
template&lt;class Ch, class Tr, class Co&gt;
std::basic_ostream&lt;Ch, Tr&gt;&amp; operator&lt;&lt;(std::basic_ostream&lt;Ch, Tr&gt;&amp; stream, Co&amp; c)
{
  stream &lt;&lt; '{' &lt;&lt; *c.begin();
 
  for(auto it = ++(c.begin()); it != c.end(); ++it)
    stream &lt;&lt; &quot;, &quot; &lt;&lt; *it;
  
  stream &lt;&lt; '}' &lt;&lt; std::endl;
  return stream;
}
 
int main()
{
  // (1) Default constructor
  std::{{{1|set}}}&lt;{{cpp/container/if map| {{{1|set}}}| int, | }}std::string&gt; a;
  a.insert({{cpp/container/if map| {{{1|set}}}| {1, &quot;something&quot;}| &quot;something&quot;}});
  a.insert({{cpp/container/if map| {{{1|set}}}| {3, &quot;anything&quot;}| &quot;anything&quot;}});
  a.insert({{cpp/container/if map| {{{1|set}}}| {5, &quot;that thing&quot;}| &quot;that thing&quot;}});
  std::cout &lt;&lt; &quot;a = &quot; &lt;&lt; a;
 
  // (2) Iterator constructor
  std::{{{1|set}}}&lt;{{cpp/container/if map| {{{1|set}}}| int, | }}std::string&gt; b(a.find({{cpp/container/if map| {{{1|set}}}| 3| &quot;anything&quot;}}), a.end());
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; std::endl;
  std::cout &lt;&lt; &quot;b = &quot; &lt;&lt; b;
 
  // (3) Copy constructor
  std::{{{1|set}}}&lt;{{cpp/container/if map| {{{1|set}}}| int, | }}std::string&gt; c(a);
  c.insert({{cpp/container/if map| {{{1|set}}}| {7, &quot;another thing&quot;}| &quot;another thing&quot;}});
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; std::endl;
  std::cout &lt;&lt; &quot;a = &quot; &lt;&lt; a;
  std::cout &lt;&lt; &quot;c = &quot; &lt;&lt; c;
 
  // (4) Move constructor
  std::{{{1|set}}}&lt;{{cpp/container/if map| {{{1|set}}}| int, | }}std::string&gt; d(std::move(a));
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; std::endl;
  std::cout &lt;&lt; &quot;a = nullptr&quot; &lt;&lt; std::endl;
  std::cout &lt;&lt; &quot;d = &quot; &lt;&lt; d;
 
  // (5) Initializer list constructor
  std::{{{1|set}}}&lt;{{cpp/container/if map| {{{1|set}}}| int, | }}std::string&gt; e{
    {{cpp/container/if map| {{{1|set}}}| {1, &quot;one&quot;}, {2, &quot;two&quot;}, {3, &quot;three&quot;}, {5, &quot;five&quot;}, {8, &quot;eight&quot;}| &quot;one&quot;, &quot;two&quot;, &quot;three&quot;, &quot;five&quot;, &quot;eight&quot;}}
  };
  std::cout &lt;&lt; std::string(80, '-') &lt;&lt; std::endl;
  std::cout &lt;&lt; &quot;e = &quot; &lt;&lt; e;
}
 | output=
{{cpp/container/if map| {{{1|set}}}| 
a {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
b {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
a {{=}} {anything, something, that thing}
c {{=}} {another thing, anything, something, that thing}
--------------------------------------------------------------------------------
a {{=}} nullptr
d {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
e {{=}} {eight, five, one, three, two}| 
a {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
b {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
a {{=}} {anything, something, that thing}
c {{=}} {another thing, anything, something, that thing}
--------------------------------------------------------------------------------
a {{=}} nullptr
d {{=}} {anything, something, that thing}
--------------------------------------------------------------------------------
e {{=}} {eight, five, one, three, two}
}}
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc operator{{=}} |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>0q2owz372ynlzear2um0deu70j4hi9d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/constructor unord</title>
    <ns>10</ns>
    <id>1925</id>
    <revision>
      <id>69409</id>
      <parentid>68764</parentid>
      <timestamp>2014-04-07T12:30:17Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6639">{{cpp/container/{{{1|}}}/title | {{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin|num=1}}
{{dcl | since=c++11 | until=c++14| 1=
explicit {{{1}}}( size_type bucket_count = /*implementation-defined*/,
{{space as|explicit {{{1}}}}}  const Hash&amp; hash = Hash(),
{{space as|explicit {{{1}}}}}  const KeyEqual&amp; equal = KeyEqual(),
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | since=c++14| 1=
{{{1}}}() : {{{1}}}( size_type(/*implementation-defined*/) {}
explicit {{{1}}}( size_type bucket_count,
{{space as|explicit {{{1}}}}}  const Hash&amp; hash = Hash(),
{{space as|explicit {{{1}}}}}  const KeyEqual&amp; equal = KeyEqual(),
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl rev end}}
{{dcl | num=1 | since=c++14 | 1=
{{{1}}}( size_type bucket_count,
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
{{{1}}}( size_type bucket_count,
{{space as|explicit {{{1}}}}}  const Hash&amp; hash,
{{space as|explicit {{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=1 | since=c++11 | 1=
explicit {{{1}}}( const Allocator&amp; alloc );
}}
{{dcl | num=2 | notes={{mark since c++11}}&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark since c++14}} | 1=
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  size_type bucket_count = /*implementation-defined*/,
{{space as|{{{1}}}}}  const Hash&amp; hash = Hash(),
{{space as|{{{1}}}}}  const KeyEqual&amp; equal = KeyEqual(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  size_type bucket_count,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
template&lt; class InputIt &gt;
{{{1}}}( InputIt first, InputIt last,
{{space as|{{{1}}}}}  size_type bucket_count,
{{space as|{{{1}}}}}  const Hash&amp; hash,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl | num=3 | since=c++11 | 1=
{{{1}}}( const {{{1}}}&amp; other );
}}
{{dcl | num=3 | since=c++11 |
{{{1}}}( const {{{1}}}&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other, const Allocator&amp; alloc );
}}
{{dcl | num=5 | notes={{mark since c++11}}&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark since c++14}} | 1=
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  size_type bucket_count = /*implementation-defined*/,
{{space as|{{{1}}}}}  const Hash&amp; hash = Hash(),
{{space as|{{{1}}}}}  const KeyEqual&amp; equal = KeyEqual(),
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  size_type bucket_count,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
{{{1}}}( std::initializer_list&lt;value_type&gt; init,
{{space as|{{{1}}}}}  size_type bucket_count,
{{space as|{{{1}}}}}  const Hash&amp; hash,
{{space as|{{{1}}}}}  const Allocator&amp; alloc = Allocator() );
}}
{{dcl end}}

Constructs new container from a variety of data sources. Optionally uses user supplied {{tt|bucket_count}} as a minimal number of buckets to create, {{tt|hash}} as the hash function, {{tt|equal}} as the function to compare keys and {{tt|alloc}} as the allocator. 

@1@ Constructs empty container. Sets {{tt|max_load_factor()}} to 1.0. For the default constructor, the number of buckets is implementation-defined.
@2@ constructs the container with the contents of the range {{tt|[first, last)}}. Sets {{tt|max_load_factor()}} to 1.0.
@3@ copy constructor. Constructs the container with the copy of the contents of {{tt|other}}, copies the load factor, the predicate, and the hash function as well. If {{tt|alloc}} is not provided, allocator is obtained by calling {{c|std::allocator_traits&lt;allocator_type&gt;::select_on_copy_construction(other)}}.
@4@ move constructor. Constructs the container with the contents of {{tt|other}} using move semantics. If {{tt|alloc}} is not provided, allocator is obtained by move-construction from the allocator belonging to {{tt|other}}.
@5@ constructs the container with the contents of the initializer list {{tt|init}}, same as {{{1}}}(init.begin(), init.end()).

===Parameters===
{{par begin}}
{{par | alloc | allocator to use for all memory allocations of this container}}
{{par | bucket_count | minimal number of buckets to use on initialization. If it is not specified, implementation-defined default value is used}}
{{par | hash | hash function to use}}
{{par | equal | comparison function to use for all key comparisons of this container}}
{{par | first, last | the range to copy the elements from}}
{{par | other | another container to be used as source to initialize the elements of the container with}}
{{par | init | initializer list to initialize the elements of the container with}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Complexity===
@1@ constant
@2@ average case linear worst case quadratic in distance between {{tt|first}} and {{tt|last}}
@3@ linear in size of {{tt|other}}
@4@ constant. If {{tt|alloc}} is given and {{c|alloc !{{=}} other.get_allocator()}}, then linear.
@5@ average case linear worst case quadratic in size of {{tt|init}}

===Example===
{{example
 | code=
{{#switch:{{{1|}}} |unordered_map=
#include &lt;unordered_map&gt;
#include &lt;vector&gt;
#include &lt;bitset&gt;
#include &lt;string&gt;
#include &lt;utility&gt;

struct Key {
    std::string first;
    std::string second;
};

struct KeyHash {
 std::size_t operator()(const Key&amp; k) const
 {
     return std::hash&lt;std::string&gt;()(k.first) ^
            (std::hash&lt;std::string&gt;()(k.second) &lt;&lt; 1);
 }
};

struct KeyEqual {
 bool operator()(const Key&amp; lhs, const Key&amp; rhs) const
 {
    return lhs.first == rhs.first &amp;&amp; lhs.second == rhs.second;
 }
};

int main()
{
    // default constructor: empty map
    std::unordered_map&lt;std::string, std::string&gt; m1;

    // list constructor
    std::unordered_map&lt;int, std::string&gt; m2 =
    {
        {1, &quot;foo&quot;},
        {3, &quot;bar&quot;},
        {2, &quot;baz&quot;},
    };

    // copy constructor
    std::unordered_map&lt;int, std::string&gt; m3 = m2;

    // move constructor
    std::unordered_map&lt;int, std::string&gt; m4 = std::move(m2);

    // range constructor
    std::vector&lt;std::pair&lt;std::bitset&lt;8&gt;, int&gt;&gt; v = { {0x12, 1}, {0x01,-1} };
    std::unordered_map&lt;std::bitset&lt;8&gt;, double&gt; m5(v.begin(), v.end());

    // constructor for a custom type
    std::unordered_map&lt;Key, std::string, KeyHash, KeyEqual&gt; m6 = {
            { {&quot;John&quot;, &quot;Doe&quot;}, &quot;example&quot;},
            { {&quot;Mary&quot;, &quot;Sue&quot;}, &quot;another&quot;}
    };
}
|}}
 | output=
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc operator{{=}} |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>sw2tvrafgikb0tmxx6eci7mygdemkn7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/correct include assoc</title>
    <ns>10</ns>
    <id>13697</id>
    <revision>
      <id>71797</id>
      <timestamp>2014-06-24T14:14:54Z</timestamp>
      <contributor>
        <username>DizzySkin</username>
        <id>3171</id>
      </contributor>
      <comment>Includes the correct std lib for associative containers. Defaults to &quot;set&quot;.</comment>
      <text xml:space="preserve" bytes="156">#include &lt;{{cpp/container/if ord| {{{1|set}}}| {{cpp/container/if map| {{{1|set}}}| map| set}}| unordered_{{cpp/container/if map| {{{1|set}}}| map| set}}}}&gt;</text>
      <sha1>by1ye91arxkriuuqd3vgt2wdcqy71c8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/count ord</title>
    <ns>10</ns>
    <id>1926</id>
    <revision>
      <id>67165</id>
      <parentid>65123</parentid>
      <timestamp>2014-01-24T20:40:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>explicit about count() only ever returning 1 or 0 for set/map</comment>
      <text xml:space="preserve" bytes="1329">{{cpp/container/{{{1|}}}/title | count}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
size_type count( const Key&amp; key ) const;
}}
{{dcl | num=2 | since=c++14 |
template&lt; class K &gt; 
size_type count( const K&amp; x ) const;
}}
{{dcl end}}

@1@ Returns the number of elements with key {{tt|key}}{{cpp/container/if uniq|{{{1|}}}|, which is either 1 or 0 since this container does not allow duplicates|.}}

@2@ Returns the number of elements with key that compares ''equivalent'' to the value {{tt|x}}. These templates only participate in overload resolution if the type {{c|Compare::is_transparent}} exists. They allow calling this function without constructing an instance of {{tt|Key}}.

===Parameters===
{{par begin}}
{{par | key | key value of the elements to count}}
{{par | x | alternative value to compare to the keys}}
{{par end}} 

===Return value===
Number of elements with key {{tt|key}}{{cpp/container/if uniq|{{{1|}}}|, that is either 1 or 0|.}}

===Complexity===
{{cpp/container/if uniq|{{{1|}}}|
Logarithmic in the size of the container.
|Logarithmic in the size of the container plus linear in the number of the elements found.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc find |{{{1|}}}}}
{{dsc inc | cpp/container/dsc equal_range |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>i3kcvae9vj09v1phlem8gwxbt5smflm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/count unord</title>
    <ns>10</ns>
    <id>12947</id>
    <revision>
      <id>68777</id>
      <parentid>66802</parentid>
      <timestamp>2014-03-21T02:33:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>LWG 2304</comment>
      <text xml:space="preserve" bytes="779">{{cpp/container/{{{1|}}}/title | count}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
size_type count( const Key&amp; key ) const;
}}
{{dcl end}}

Returns the number of elements with key {{tt|key}}.

===Parameters===
{{par begin}}
{{par | key | key value of the elements to count}}
{{par end}} 

===Return value===
Number of elements with key {{tt|key}}.

===Complexity===
{{cpp/container/if uniq| {{{1|}}}|
Constant on average, worst case linear in the size of the container.
|linear in the number of elements with key {{tt|key}} on average, worst case linear in the size of the container.}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc find |{{{1|}}}}}
{{dsc inc | cpp/container/dsc equal_range |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>61t2xo9x2bua8wgedoqktz7sqm5if35</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/data</title>
    <ns>10</ns>
    <id>1927</id>
    <revision>
      <id>72204</id>
      <parentid>64768</parentid>
      <timestamp>2014-07-23T11:19:04Z</timestamp>
      <contributor>
        <ip>61.164.214.38</ip>
      </contributor>
      <comment>This function is new in C++11</comment>
      <text xml:space="preserve" bytes="748">{{cpp/container/{{{1|}}}/title | data}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
T* data();
}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
const T* data() const;
}}
{{dcl end}}

Returns pointer to the underlying array serving as element storage. The pointer is such that range {{tt|[data(); data() + size())}} is always a valid range, even if the container is empty.

===Parameters===
(none)

===Return value===
Pointer to the underlying element storage. For non-empty containers, returns {{c|&amp;front()}}

===Complexity===
Constant.

===Exceptions===
{{noexcept}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc front |{{{1|}}}}}
{{dsc inc | cpp/container/dsc back |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>38d850olcj8lamw8s3cid035tyfsb9d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/example empty</title>
    <ns>10</ns>
    <id>10033</id>
    <revision>
      <id>47712</id>
      <timestamp>2013-05-16T19:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="509">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::deque&lt;int&gt;}} contains any elements:
 | code=
#include &lt;deque&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::deque&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.push_back(42);
    numbers.push_back(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/example operator=</title>
    <ns>10</ns>
    <id>12826</id>
    <revision>
      <id>63233</id>
      <timestamp>2013-07-06T11:58:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1138">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::deque}} to another:
 | code=
#include &lt;deque&gt;
#include &lt;iostream&gt;

void display_sizes(const std::deque&lt;int&gt;&amp; nums1,
                   const std::deque&lt;int&gt;&amp; nums2,
                   const std::deque&lt;int&gt;&amp; nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::deque&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::deque&lt;int&gt; nums2; 
    std::deque&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/example shrink to fit</title>
    <ns>10</ns>
    <id>9954</id>
    <revision>
      <id>65257</id>
      <parentid>47813</parentid>
      <timestamp>2013-09-06T13:52:10Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>deque doesn't have capacity</comment>
      <text xml:space="preserve" bytes="335">{{example
 |
 | code=
#include &lt;deque&gt;

int main() {
    std::deque&lt;int&gt; nums(1000, 42);
    nums.push_front(1);
    nums.pop_front();

    nums.clear();

    // nums now contains no items, but it may still be holding allocated memory. 
    // Calling shrink_to_fit will free any unused memory.
    nums.shrink_to_fit();
}
| output=
}}</text>
      <sha1>a4mkwrh7arru3quq1b2mfa3v75g1q2w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/example size</title>
    <ns>10</ns>
    <id>10044</id>
    <revision>
      <id>52456</id>
      <parentid>47733</parentid>
      <timestamp>2013-06-01T04:47:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="319">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::deque}}:
 | code=
#include &lt;deque&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::deque&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/navbar</title>
    <ns>10</ns>
    <id>1064</id>
    <revision>
      <id>39872</id>
      <parentid>35560</parentid>
      <timestamp>2012-09-28T19:57:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/deque/navbar heading
|content3 = cpp/container/deque/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/navbar content</title>
    <ns>10</ns>
    <id>1065</id>
    <revision>
      <id>52457</id>
      <parentid>35561</parentid>
      <timestamp>2013-06-01T04:47:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1517">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/deque/deque }}
{{nv mem ln | cpp/container/deque/~deque }}
{{nv mem ln | cpp/container/deque/operator{{=}} }}
{{nv mem ln | cpp/container/deque/assign }}
{{nv mem ln | cpp/container/deque/get_allocator }}

{{nv h2 | Element access}}
{{nv mem ln | cpp/container/deque/front }}
{{nv mem ln | cpp/container/deque/back }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/deque/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/deque/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/deque/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/deque/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/deque/empty}}
{{nv mem ln | cpp/container/deque/size}}
{{nv mem ln | cpp/container/deque/max_size}}
{{nv mem ln | cpp/container/deque/shrink_to_fit}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/deque/clear}}
{{nv mem ln | cpp/container/deque/insert}}
{{nv mem ln | cpp/container/deque/emplace}}
{{nv mem ln | cpp/container/deque/erase}}
{{nv mem ln | cpp/container/deque/push_front}}
{{nv mem ln | cpp/container/deque/emplace_front}}
{{nv mem ln | cpp/container/deque/pop_front}}
{{nv mem ln | cpp/container/deque/push_back}}
{{nv mem ln | cpp/container/deque/emplace_back}}
{{nv mem ln | cpp/container/deque/pop_back}}
{{nv mem ln | cpp/container/deque/resize}}
{{nv mem ln | cpp/container/deque/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/navbar heading</title>
    <ns>10</ns>
    <id>1066</id>
    <revision>
      <id>47252</id>
      <parentid>35562</parentid>
      <timestamp>2013-05-02T15:02:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="40">{{ltt|cpp/container/deque | std::deque}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/deque/title</title>
    <ns>10</ns>
    <id>1067</id>
    <revision>
      <id>2135</id>
      <parentid>2134</parentid>
      <timestamp>2011-06-06T22:52:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=deque::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/destructor</title>
    <ns>10</ns>
    <id>1068</id>
    <revision>
      <id>62193</id>
      <parentid>62192</parentid>
      <timestamp>2013-06-25T12:02:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <text xml:space="preserve" bytes="684">{{cpp/container/{{{1|}}}/title | ~{{{1}}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
~{{{1}}}();
}}
{{dcl end}}

{{cpp/container/if ad|{{{1|}}}
|Destructs the container adaptor.
|Destructs the container.
}} The destructors of the elements are called and the used storage is deallocated. Note, that if the elements are pointers, the pointed-to objects are not destroyed.
{{#ifeq:{{{1|}}}|dynarray
| The global {{c|operator delete}} is called only if the {{c|operator new}} was called during construction
}}
===Complexity===
{{cpp/container/if ad|{{{1|}}}
|Linear in the size of the container adaptor.
|Linear in the size of the container.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc allocator type</title>
    <ns>10</ns>
    <id>1186</id>
    <revision>
      <id>55072</id>
      <parentid>52345</parentid>
      <timestamp>2013-06-01T05:19:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list allocator type]] to [[Template:cpp/container/dsc allocator type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">{{dsc | {{tt|allocator_type}} | {{tt|Allocator}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc array</title>
    <ns>10</ns>
    <id>5089</id>
    <revision>
      <id>55076</id>
      <parentid>52346</parentid>
      <timestamp>2013-06-01T05:19:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list array]] to [[Template:cpp/container/dsc array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/container/array | static contiguous array | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc assign</title>
    <ns>10</ns>
    <id>1928</id>
    <revision>
      <id>55079</id>
      <parentid>52347</parentid>
      <timestamp>2013-06-01T05:19:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list assign]] to [[Template:cpp/container/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/container/{{{1|}}}/assign | assigns values to the container }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc at</title>
    <ns>10</ns>
    <id>1929</id>
    <revision>
      <id>55083</id>
      <parentid>52348</parentid>
      <timestamp>2013-06-01T05:19:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list at]] to [[Template:cpp/container/dsc at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc mem fun | cpp/container/{{{1|}}}/at | access specified element with bounds checking | notes={{#ifeq: {{{1|}}} | map | {{mark c++11}}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc back</title>
    <ns>10</ns>
    <id>1930</id>
    <revision>
      <id>55086</id>
      <parentid>52349</parentid>
      <timestamp>2013-06-01T05:19:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list back]] to [[Template:cpp/container/dsc back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/container/{{{1|}}}/back | access the last element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc before begin</title>
    <ns>10</ns>
    <id>1931</id>
    <revision>
      <id>55090</id>
      <parentid>52350</parentid>
      <timestamp>2013-06-01T05:19:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list before begin]] to [[Template:cpp/container/dsc before begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc mem fun | cpp/container/{{{1|}}}/before_begin | title=before_begin&lt;br&gt; cbefore_begin | returns an iterator to the element before beginning }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc begin</title>
    <ns>10</ns>
    <id>1932</id>
    <revision>
      <id>55092</id>
      <parentid>52351</parentid>
      <timestamp>2013-06-01T05:19:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list begin]] to [[Template:cpp/container/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc mem fun | cpp/container/{{{1|}}}/begin | title=begin&lt;br&gt; cbegin | returns an iterator to the beginning | notes=&lt;br&gt;{{cpp/container/mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc begin(int)</title>
    <ns>10</ns>
    <id>1933</id>
    <revision>
      <id>55095</id>
      <parentid>52352</parentid>
      <timestamp>2013-06-01T05:19:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list begin(int)]] to [[Template:cpp/container/dsc begin(int)]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="174">{{dsc mem fun | cpp/container/{{{1|}}}/begin2 | title=begin{{dsc small|(int)}}&lt;br&gt; cbegin{{dsc small|(int)}} | returns an iterator to the beginning of the specified bucket }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc bucket</title>
    <ns>10</ns>
    <id>1934</id>
    <revision>
      <id>55101</id>
      <parentid>52353</parentid>
      <timestamp>2013-06-01T05:20:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list bucket]] to [[Template:cpp/container/dsc bucket]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/container/{{{1|}}}/bucket | returns the bucket for specific key}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc bucket count</title>
    <ns>10</ns>
    <id>1935</id>
    <revision>
      <id>55105</id>
      <parentid>52354</parentid>
      <timestamp>2013-06-01T05:20:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list bucket count]] to [[Template:cpp/container/dsc bucket count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/container/{{{1|}}}/bucket_count | returns the number of buckets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc bucket size</title>
    <ns>10</ns>
    <id>1936</id>
    <revision>
      <id>55110</id>
      <parentid>52355</parentid>
      <timestamp>2013-06-01T05:20:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list bucket size]] to [[Template:cpp/container/dsc bucket size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/container/{{{1|}}}/bucket_size | returns the number of elements in specific bucket}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc c</title>
    <ns>10</ns>
    <id>2199</id>
    <revision>
      <id>55116</id>
      <parentid>52356</parentid>
      <timestamp>2013-06-01T05:20:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list c]] to [[Template:cpp/container/dsc c]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc prot mem obj | nolink=true | {{dsc small|Container}} c | the underlying container}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc capacity</title>
    <ns>10</ns>
    <id>1937</id>
    <revision>
      <id>55120</id>
      <parentid>52357</parentid>
      <timestamp>2013-06-01T05:20:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list capacity]] to [[Template:cpp/container/dsc capacity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc mem fun | cpp/container/{{{1|}}}/capacity | returns the number of elements that can be held in currently allocated storage }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc clear</title>
    <ns>10</ns>
    <id>1938</id>
    <revision>
      <id>55125</id>
      <parentid>52358</parentid>
      <timestamp>2013-06-01T05:20:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list clear]] to [[Template:cpp/container/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/container/{{{1|}}}/clear | clears the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc const iterator</title>
    <ns>10</ns>
    <id>1187</id>
    <revision>
      <id>55131</id>
      <parentid>52359</parentid>
      <timestamp>2013-06-01T05:20:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list const iterator]] to [[Template:cpp/container/dsc const iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="541">{{#switch:{{{1|}}}
| array
| dynarray
| vector
| deque
| basic_string = {{dsc | {{tt|const_iterator}} | Constant random access iterator }}
| forward_list = {{dsc | {{tt|const_iterator}} | Constant forward iterator }}
| list 
| set
| multiset
| map
| multimap = {{dsc | {{tt|const_iterator}} | Constant bidirectional iterator }}
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{dsc | {{tt|const_iterator}} | Constant forward iterator }}
| vector_bool = {{dsc | {{tt|const_iterator}} | implementation-defined }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc const local iterator</title>
    <ns>10</ns>
    <id>1188</id>
    <revision>
      <id>55134</id>
      <parentid>52360</parentid>
      <timestamp>2013-06-01T05:20:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list const local iterator]] to [[Template:cpp/container/dsc const local iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="250">{{dsc | {{tt|const_local_iterator}} | An iterator type whose category, value, difference, pointer and&lt;br&gt; reference types are the same as {{tt|const_iterator}}. This iterator&lt;br&gt; can be used to iterate through a single bucket but not across buckets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc const pointer</title>
    <ns>10</ns>
    <id>1189</id>
    <revision>
      <id>71981</id>
      <parentid>71973</parentid>
      <timestamp>2014-07-04T19:12:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use normal rev table</comment>
      <text xml:space="preserve" bytes="624">{{#switch:{{{1|}}}
| vector
| deque 
| list
| set
| multiset
| map
| multimap
| basic_string = {{dsc | {{tt|const_pointer}} | {{rev begin|noborder=true}}{{rev|until=c++11|{{tt|Allocator::const_pointer}}}}{{rev|since=c++11|{{c|std::allocator_traits&lt;Allocator&gt;::const_pointer}}}}{{rev end}} }}
| array
| dynarray = {{dsc | {{tt|const_pointer}} | {{tt|const value_type*}}}}
| forward_list
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{dsc | {{tt|const_pointer}} | {{c|std::allocator_traits&lt;Allocator&gt;::const_pointer}} }}
| vector_bool = {{dsc | {{tt|const_pointer}} | implementation-defined}}
}}</text>
      <sha1>a377q1d4tfkn68t12dybj3y8veem153</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc const reference</title>
    <ns>10</ns>
    <id>1190</id>
    <revision>
      <id>71982</id>
      <parentid>71979</parentid>
      <timestamp>2014-07-04T19:14:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fi</comment>
      <text xml:space="preserve" bytes="608">{{#switch:{{{1|}}}
| vector
| deque 
| list
| set
| multiset
| map
| multimap
| basic_string = {{dsc | {{tt|const_reference}} | {{rev begin|noborder=true}}{{rev|until=c++11|{{tt|Allocator::const_reference}}}}{{rev|since=c++11|{{tt|const value_type&amp;}}}}{{rev end}} }}
| vector_bool = {{dsc | {{tt|const_reference}} | {{c|bool}} }}
| array
| dynarray
| forward_list
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{dsc | {{tt|const_reference}} | {{tt|const value_type&amp;}} }}
| stack
| queue
| priority_queue = {{dsc | {{tt|const_reference}} | {{tt|Container::const_reference}} }}
}}</text>
      <sha1>kq2918pbhlfnla0rcy7bxahky9mqo5h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc const reverse iterator</title>
    <ns>10</ns>
    <id>1191</id>
    <revision>
      <id>55146</id>
      <parentid>52363</parentid>
      <timestamp>2013-06-01T05:20:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list const reverse iterator]] to [[Template:cpp/container/dsc const reverse iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc | &lt;code&gt;const_reverse_iterator&lt;/code&gt; | {{c|std::reverse_iterator&lt;const_iterator&gt;}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc constructor</title>
    <ns>10</ns>
    <id>1939</id>
    <revision>
      <id>55150</id>
      <parentid>52364</parentid>
      <timestamp>2013-06-01T05:20:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list constructor]] to [[Template:cpp/container/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem ctor | cpp/container/{{{1|}}}/{{{1|constructor}}} | constructs the {{tt|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc container type</title>
    <ns>10</ns>
    <id>1192</id>
    <revision>
      <id>55153</id>
      <parentid>52365</parentid>
      <timestamp>2013-06-01T05:20:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list container type]] to [[Template:cpp/container/dsc container type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">{{dsc | {{tt|container_type}} | {{tt|Container}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc count</title>
    <ns>10</ns>
    <id>1940</id>
    <revision>
      <id>55157</id>
      <parentid>52366</parentid>
      <timestamp>2013-06-01T05:20:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list count]] to [[Template:cpp/container/dsc count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem fun | cpp/container/{{{1|}}}/count | returns the number of elements matching specific key }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc data</title>
    <ns>10</ns>
    <id>1941</id>
    <revision>
      <id>55160</id>
      <parentid>52367</parentid>
      <timestamp>2013-06-01T05:20:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list data]] to [[Template:cpp/container/dsc data]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc mem fun | cpp/container/{{{1|}}}/data | direct access to the underlying array | notes={{cpp/container/mark c++11|{{{1|}}}}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc deque</title>
    <ns>10</ns>
    <id>5093</id>
    <revision>
      <id>55162</id>
      <parentid>52368</parentid>
      <timestamp>2013-06-01T05:20:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list deque]] to [[Template:cpp/container/dsc deque]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc tclass | cpp/container/deque | double-ended queue}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc destructor</title>
    <ns>10</ns>
    <id>1942</id>
    <revision>
      <id>55164</id>
      <parentid>52369</parentid>
      <timestamp>2013-06-01T05:20:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list destructor]] to [[Template:cpp/container/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem dtor | cpp/container/{{{1|}}}/~{{{1|}}} | destructs the {{tt|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc difference type</title>
    <ns>10</ns>
    <id>1193</id>
    <revision>
      <id>63263</id>
      <parentid>55166</parentid>
      <timestamp>2013-07-07T22:04:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="427">{{#switch:{{{1|}}}
| array
| dynarray = {{dsc | {{tt|difference_type}} | {{lc|std::ptrdiff_t}} }}
| vector
| deque 
| forward_list
| list
| set
| multiset
| unordered_set
| unordered_multiset
| map
| multimap
| unordered_map
| unordered_multimap
| basic_string = {{dsc | {{tt|difference_type}} | Signed integer type (usually {{lc|std::ptrdiff_t}}) }}
| vector_bool = {{dsc | {{tt|difference_type}} | implementation-defined}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc dynarray</title>
    <ns>10</ns>
    <id>9990</id>
    <revision>
      <id>55168</id>
      <parentid>52371</parentid>
      <timestamp>2013-06-01T05:20:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list dynarray]] to [[Template:cpp/container/dsc dynarray]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc tclass | cpp/container/dynarray | fixed-size contiguous array | notes={{mark since c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc emplace</title>
    <ns>10</ns>
    <id>1943</id>
    <revision>
      <id>55170</id>
      <parentid>52372</parentid>
      <timestamp>2013-06-01T05:20:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list emplace]] to [[Template:cpp/container/dsc emplace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="554">{{#switch:{{{1|}}}
| stack
= {{dsc mem fun | cpp/container/{{{1|}}}/emplace | constructs element in-place at the top | notes={{mark c++11}} }}
| queue
= {{dsc mem fun | cpp/container/{{{1|}}}/emplace | constructs element in-place at the end | notes={{mark c++11}} }}
| priority_queue
= {{dsc mem fun | cpp/container/{{{1|}}}/emplace | constructs element in-place and sorts the underlying container | notes={{mark c++11}} }}
| {{dsc mem fun | cpp/container/{{{1|}}}/emplace | constructs element in-place | notes={{cpp/container/mark c++11|{{{1|}}}}} }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc emplace after</title>
    <ns>10</ns>
    <id>1944</id>
    <revision>
      <id>55172</id>
      <parentid>52373</parentid>
      <timestamp>2013-06-01T05:20:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list emplace after]] to [[Template:cpp/container/dsc emplace after]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/container/{{{1|}}}/emplace_after | constructs elements in-place after an element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc emplace back</title>
    <ns>10</ns>
    <id>1945</id>
    <revision>
      <id>55176</id>
      <parentid>52374</parentid>
      <timestamp>2013-06-01T05:20:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list emplace back]] to [[Template:cpp/container/dsc emplace back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc mem fun | cpp/container/{{{1|}}}/emplace_back | constructs elements in-place at the end | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc emplace front</title>
    <ns>10</ns>
    <id>1946</id>
    <revision>
      <id>55179</id>
      <parentid>52375</parentid>
      <timestamp>2013-06-01T05:20:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list emplace front]] to [[Template:cpp/container/dsc emplace front]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc mem fun | cpp/container/{{{1|}}}/emplace_front | constructs elements in-place at the beginning | notes={{cpp/container/mark c++11|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc emplace hint</title>
    <ns>10</ns>
    <id>1947</id>
    <revision>
      <id>55182</id>
      <parentid>52376</parentid>
      <timestamp>2013-06-01T05:20:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list emplace hint]] to [[Template:cpp/container/dsc emplace hint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc mem fun | cpp/container/{{{1|}}}/emplace_hint | constructs elements in-place using a hint | notes={{cpp/container/mark c++11|{{{1|}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc empty</title>
    <ns>10</ns>
    <id>1948</id>
    <revision>
      <id>55187</id>
      <parentid>52377</parentid>
      <timestamp>2013-06-01T05:20:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list empty]] to [[Template:cpp/container/dsc empty]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="243">{{#switch:{{{1|}}}
| stack | queue | priority_queue
={{dsc mem fun | cpp/container/{{{1|}}}/empty | checks whether the underlying container is empty }}
|{{dsc mem fun | cpp/container/{{{1|}}}/empty | checks whether the container is empty }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc end</title>
    <ns>10</ns>
    <id>1949</id>
    <revision>
      <id>55191</id>
      <parentid>52378</parentid>
      <timestamp>2013-06-01T05:21:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list end]] to [[Template:cpp/container/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/container/{{{1|}}}/end | title=end &lt;br&gt;cend | returns an iterator to the end | notes=&lt;br&gt;{{cpp/container/mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc end(int)</title>
    <ns>10</ns>
    <id>1950</id>
    <revision>
      <id>55197</id>
      <parentid>52379</parentid>
      <timestamp>2013-06-01T05:21:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list end(int)]] to [[Template:cpp/container/dsc end(int)]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc mem fun | cpp/container/{{{1|}}}/end2 | title=end{{dsc small|(int)}}&lt;br&gt; cend{{dsc small|(int)}} | returns an iterator to the end of the specified bucket }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc equal range</title>
    <ns>10</ns>
    <id>1951</id>
    <revision>
      <id>55200</id>
      <parentid>52380</parentid>
      <timestamp>2013-06-01T05:21:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list equal range]] to [[Template:cpp/container/dsc equal range]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/container/{{{1|}}}/equal_range | returns range of elements matching a specific key}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc erase</title>
    <ns>10</ns>
    <id>1952</id>
    <revision>
      <id>55206</id>
      <parentid>52381</parentid>
      <timestamp>2013-06-01T05:21:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list erase]] to [[Template:cpp/container/dsc erase]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc mem fun | cpp/container/{{{1|}}}/erase | erases elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc erase after</title>
    <ns>10</ns>
    <id>1953</id>
    <revision>
      <id>55208</id>
      <parentid>52382</parentid>
      <timestamp>2013-06-01T05:21:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list erase after]] to [[Template:cpp/container/dsc erase after]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/container/{{{1|}}}/erase_after | erases an element after an element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc fill</title>
    <ns>10</ns>
    <id>1954</id>
    <revision>
      <id>55210</id>
      <parentid>52383</parentid>
      <timestamp>2013-06-01T05:21:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list fill]] to [[Template:cpp/container/dsc fill]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/container/{{{1|}}}/fill | fill the container with specified value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc find</title>
    <ns>10</ns>
    <id>1955</id>
    <revision>
      <id>55213</id>
      <parentid>52384</parentid>
      <timestamp>2013-06-01T05:21:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list find]] to [[Template:cpp/container/dsc find]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/container/{{{1|}}}/find | finds element with specific key}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc forward list</title>
    <ns>10</ns>
    <id>5091</id>
    <revision>
      <id>55215</id>
      <parentid>52385</parentid>
      <timestamp>2013-06-01T05:21:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list forward list]] to [[Template:cpp/container/dsc forward list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc tclass | cpp/container/forward_list | singly-linked list | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc front</title>
    <ns>10</ns>
    <id>1956</id>
    <revision>
      <id>55218</id>
      <parentid>52386</parentid>
      <timestamp>2013-06-01T05:21:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list front]] to [[Template:cpp/container/dsc front]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/container/{{{1|}}}/front | access the first element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc get allocator</title>
    <ns>10</ns>
    <id>1957</id>
    <revision>
      <id>55220</id>
      <parentid>52387</parentid>
      <timestamp>2013-06-01T05:21:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list get allocator]] to [[Template:cpp/container/dsc get allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/container/{{{1|}}}/get_allocator | returns the associated allocator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc hash function</title>
    <ns>10</ns>
    <id>1958</id>
    <revision>
      <id>55224</id>
      <parentid>52388</parentid>
      <timestamp>2013-06-01T05:21:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list hash function]] to [[Template:cpp/container/dsc hash function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/container/{{{1|}}}/hash_function | returns function used to hash the keys }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc hasher</title>
    <ns>10</ns>
    <id>1194</id>
    <revision>
      <id>55227</id>
      <parentid>52389</parentid>
      <timestamp>2013-06-01T05:21:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list hasher]] to [[Template:cpp/container/dsc hasher]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="38">{{dsc | {{tt|hasher}} | {{tt|Hash}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc insert</title>
    <ns>10</ns>
    <id>1959</id>
    <revision>
      <id>55229</id>
      <parentid>52390</parentid>
      <timestamp>2013-06-01T05:21:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list insert]] to [[Template:cpp/container/dsc insert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/container/{{{1|}}}/insert | inserts elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc insert after</title>
    <ns>10</ns>
    <id>1960</id>
    <revision>
      <id>55232</id>
      <parentid>52391</parentid>
      <timestamp>2013-06-01T05:21:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list insert after]] to [[Template:cpp/container/dsc insert after]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/container/{{{1|}}}/insert_after | inserts elements after an element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc iterator</title>
    <ns>10</ns>
    <id>1195</id>
    <revision>
      <id>55235</id>
      <parentid>52392</parentid>
      <timestamp>2013-06-01T05:21:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list iterator]] to [[Template:cpp/container/dsc iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="601">{{#switch:{{{1|}}}
| array
| dynarray
| vector
| deque
| basic_string = {{dsc | {{tt|iterator}} | {{concept|RandomAccessIterator}} }}
| vector_bool = {{dsc | {{tt|iterator}} | implementation-defined }}
| set
| multiset = {{dsc | {{tt|iterator}} | {{concept|BidirectionalIterator}} {{mark until c++11}}&lt;br&gt;Constant bidirectional iterator {{mark since c++11}} }}
| list 
| map
| multimap = {{dsc | {{tt|iterator}} | {{concept|BidirectionalIterator}} }}
| unordered_set
| unordered_multiset
| unordered_map
| forward_list
| unordered_multimap = {{dsc | {{tt|iterator}} | {{concept|ForwardIterator}} }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc iterator semantics</title>
    <ns>10</ns>
    <id>13501</id>
    <revision>
      <id>69299</id>
      <parentid>69298</parentid>
      <timestamp>2014-04-02T16:19:51Z</timestamp>
      <contributor>
        <username>Shachar</username>
        <id>2974</id>
      </contributor>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/container/{{{1|}}}/iterator semantics | Invalidation rules for the iterators. }}</text>
      <sha1>alk1hysd8n4bt5y16rtsq6s5h6sn8uf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc key comp</title>
    <ns>10</ns>
    <id>1961</id>
    <revision>
      <id>55239</id>
      <parentid>52393</parentid>
      <timestamp>2013-06-01T05:21:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list key comp]] to [[Template:cpp/container/dsc key comp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/container/{{{1|}}}/key_comp | returns the function that compares keys}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc key compare</title>
    <ns>10</ns>
    <id>1196</id>
    <revision>
      <id>55243</id>
      <parentid>52394</parentid>
      <timestamp>2013-06-01T05:21:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list key compare]] to [[Template:cpp/container/dsc key compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">{{dsc | {{tt|key_compare}} | {{tt|Compare}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc key eq</title>
    <ns>10</ns>
    <id>1962</id>
    <revision>
      <id>55249</id>
      <parentid>52395</parentid>
      <timestamp>2013-06-01T05:21:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list key eq]] to [[Template:cpp/container/dsc key eq]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/container/{{{1|}}}/key_eq | returns the function used to compare keys for equality }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc key equal</title>
    <ns>10</ns>
    <id>1197</id>
    <revision>
      <id>55253</id>
      <parentid>52396</parentid>
      <timestamp>2013-06-01T05:21:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list key equal]] to [[Template:cpp/container/dsc key equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">{{dsc | {{tt|key_equal}} | {{tt|KeyEqual}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc key type</title>
    <ns>10</ns>
    <id>1198</id>
    <revision>
      <id>55255</id>
      <parentid>52397</parentid>
      <timestamp>2013-06-01T05:21:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list key type]] to [[Template:cpp/container/dsc key type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="39">{{dsc | {{tt|key_type}} | {{tt|Key}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc list</title>
    <ns>10</ns>
    <id>5092</id>
    <revision>
      <id>55258</id>
      <parentid>52398</parentid>
      <timestamp>2013-06-01T05:21:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list list]] to [[Template:cpp/container/dsc list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">{{dsc tclass | cpp/container/list | doubly-linked list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc load factor</title>
    <ns>10</ns>
    <id>1963</id>
    <revision>
      <id>55260</id>
      <parentid>52399</parentid>
      <timestamp>2013-06-01T05:21:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list load factor]] to [[Template:cpp/container/dsc load factor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/container/{{{1|}}}/load_factor | returns average number of elements per bucket}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc local iterator</title>
    <ns>10</ns>
    <id>1199</id>
    <revision>
      <id>55263</id>
      <parentid>52400</parentid>
      <timestamp>2013-06-01T05:21:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list local iterator]] to [[Template:cpp/container/dsc local iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="238">{{dsc | {{tt|local_iterator}} | An iterator type whose category, value, difference, pointer and&lt;br&gt; reference types are the same as {{tt|iterator}}. This iterator&lt;br&gt; can be used to iterate through a single bucket but not across buckets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc lower bound</title>
    <ns>10</ns>
    <id>1034</id>
    <revision>
      <id>55267</id>
      <parentid>52401</parentid>
      <timestamp>2013-06-01T05:21:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list lower bound]] to [[Template:cpp/container/dsc lower bound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc mem fun | cpp/container/{{{1|}}}/lower_bound | returns an iterator to the first element ''not less'' than the given value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc map</title>
    <ns>10</ns>
    <id>5095</id>
    <revision>
      <id>55273</id>
      <parentid>52402</parentid>
      <timestamp>2013-06-01T05:21:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list map]] to [[Template:cpp/container/dsc map]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tclass | cpp/container/map | collection of key-value pairs, sorted by keys, keys are unique}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc mapped type</title>
    <ns>10</ns>
    <id>1200</id>
    <revision>
      <id>55277</id>
      <parentid>52403</parentid>
      <timestamp>2013-06-01T05:21:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list mapped type]] to [[Template:cpp/container/dsc mapped type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="40">{{dsc | {{tt|mapped_type}} | {{tt|T}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc max bucket count</title>
    <ns>10</ns>
    <id>1035</id>
    <revision>
      <id>55281</id>
      <parentid>52404</parentid>
      <timestamp>2013-06-01T05:21:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list max bucket count]] to [[Template:cpp/container/dsc max bucket count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/container/{{{1|}}}/max_bucket_count | returns the maximum number of buckets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc max load factor</title>
    <ns>10</ns>
    <id>1036</id>
    <revision>
      <id>55287</id>
      <parentid>52405</parentid>
      <timestamp>2013-06-01T05:22:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list max load factor]] to [[Template:cpp/container/dsc max load factor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/container/{{{1|}}}/max_load_factor | manages maximum average number of elements per bucket}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc max size</title>
    <ns>10</ns>
    <id>1037</id>
    <revision>
      <id>55291</id>
      <parentid>52406</parentid>
      <timestamp>2013-06-01T05:22:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list max size]] to [[Template:cpp/container/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/container/{{{1|}}}/max_size | returns the maximum possible number of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc merge</title>
    <ns>10</ns>
    <id>1038</id>
    <revision>
      <id>55294</id>
      <parentid>52407</parentid>
      <timestamp>2013-06-01T05:22:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list merge]] to [[Template:cpp/container/dsc merge]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/container/{{{1|}}}/merge | merges two sorted lists}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc multimap</title>
    <ns>10</ns>
    <id>5097</id>
    <revision>
      <id>55297</id>
      <parentid>52408</parentid>
      <timestamp>2013-06-01T05:22:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list multimap]] to [[Template:cpp/container/dsc multimap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tclass | cpp/container/multimap | collection of key-value pairs, sorted by keys}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc multiset</title>
    <ns>10</ns>
    <id>5096</id>
    <revision>
      <id>55301</id>
      <parentid>52409</parentid>
      <timestamp>2013-06-01T05:22:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list multiset]] to [[Template:cpp/container/dsc multiset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc tclass | cpp/container/multiset | collection of keys, sorted by keys}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc operator=</title>
    <ns>10</ns>
    <id>1039</id>
    <revision>
      <id>55304</id>
      <parentid>52410</parentid>
      <timestamp>2013-06-01T05:22:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list operator=]] to [[Template:cpp/container/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="381">{{#switch:{{{1|}}}
| stack | queue | priority_queue
={{dsc mem fun | cpp/container/{{{1|}}}/operator{{=}} | assigns values to the container adaptor}}
| dynarray
={{dsc mem fun | operator{{=}} | nolink=true | notes={{cmark deleted}} | the container is neither copy-, nor move-assignable}}
|{{dsc mem fun | cpp/container/{{{1|}}}/operator{{=}} | assigns values to the container }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc operator at</title>
    <ns>10</ns>
    <id>1040</id>
    <revision>
      <id>55310</id>
      <parentid>52411</parentid>
      <timestamp>2013-06-01T05:22:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list operator at]] to [[Template:cpp/container/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/container/{{{1|}}}/operator_at | title=operator[] | access specified element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc operator cmp</title>
    <ns>10</ns>
    <id>1986</id>
    <revision>
      <id>55315</id>
      <parentid>52412</parentid>
      <timestamp>2013-06-01T05:22:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list operator cmp]] to [[Template:cpp/container/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc tfun | cpp/container/{{{1|}}}/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | lexicographically compares the values in the {{{1|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc operator cmp unord</title>
    <ns>10</ns>
    <id>2007</id>
    <revision>
      <id>55319</id>
      <parentid>52413</parentid>
      <timestamp>2013-06-01T05:22:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list operator cmp unord]] to [[Template:cpp/container/dsc operator cmp unord]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc tfun | cpp/container/{{{1|}}}/operator_cmp | title=operator==&lt;br&gt;operator!= | compares the values in the {{{1|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc pointer</title>
    <ns>10</ns>
    <id>1201</id>
    <revision>
      <id>71980</id>
      <parentid>71972</parentid>
      <timestamp>2014-07-04T19:11:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use normal rev table</comment>
      <text xml:space="preserve" bytes="576">{{#switch:{{{1|}}}
| vector
| deque 
| list
| set
| multiset
| map
| multimap
| basic_string = {{dsc | {{tt|pointer}} | {{rev begin|noborder=true}}{{rev|until=c++11|{{tt|Allocator::pointer}}}}{{rev|since=c++11|{{c|std::allocator_traits&lt;Allocator&gt;::pointer}}}}{{rev end}} }}
| array
| dynarray = {{dsc | {{tt|pointer}} | {{tt|value_type*}}}}
| vector_bool = {{dsc | {{tt|pointer}} | implementation-defined}}
| forward_list
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{dsc | {{tt|pointer}} | {{c|std::allocator_traits&lt;Allocator&gt;::pointer}} }}
}}</text>
      <sha1>g6jgursgozkp7wqj6bl8fctu4pthlqs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc pop</title>
    <ns>10</ns>
    <id>1041</id>
    <revision>
      <id>67278</id>
      <parentid>55327</parentid>
      <timestamp>2014-02-02T21:02:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix the description of priority_queue::pop</comment>
      <text xml:space="preserve" bytes="193">{{#switch:{{{1|}}}
|stack|priority_queue
= {{dsc mem fun | cpp/container/{{{1|}}}/pop | removes the top element }}
| {{dsc mem fun | cpp/container/{{{1|}}}/pop | removes the first element }}
}}</text>
      <sha1>ngzm5akgi8lufrkynsu8ftminvsfpf1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc pop back</title>
    <ns>10</ns>
    <id>1042</id>
    <revision>
      <id>55329</id>
      <parentid>52416</parentid>
      <timestamp>2013-06-01T05:22:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list pop back]] to [[Template:cpp/container/dsc pop back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/container/{{{1|}}}/pop_back | removes the last element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc pop front</title>
    <ns>10</ns>
    <id>1043</id>
    <revision>
      <id>55332</id>
      <parentid>52417</parentid>
      <timestamp>2013-06-01T05:22:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list pop front]] to [[Template:cpp/container/dsc pop front]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/container/{{{1|}}}/pop_front | removes the first element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc priority queue</title>
    <ns>10</ns>
    <id>5102</id>
    <revision>
      <id>55334</id>
      <parentid>52418</parentid>
      <timestamp>2013-06-01T05:22:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list priority queue]] to [[Template:cpp/container/dsc priority queue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tclass | cpp/container/priority_queue | adapts a container to provide priority queue}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc push</title>
    <ns>10</ns>
    <id>1044</id>
    <revision>
      <id>55337</id>
      <parentid>52419</parentid>
      <timestamp>2013-06-01T05:22:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list push]] to [[Template:cpp/container/dsc push]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="308">{{#switch:{{{1|}}}
|stack
= {{dsc mem fun | cpp/container/{{{1|}}}/push | inserts element at the top }}
|queue
= {{dsc mem fun | cpp/container/{{{1|}}}/push | inserts element at the end}}
|priority_queue|
= {{dsc mem fun | cpp/container/{{{1|}}}/push | inserts element and sorts the underlying container}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc push back</title>
    <ns>10</ns>
    <id>1045</id>
    <revision>
      <id>55339</id>
      <parentid>52420</parentid>
      <timestamp>2013-06-01T05:22:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list push back]] to [[Template:cpp/container/dsc push back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/container/{{{1|}}}/push_back | adds elements to the end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc push front</title>
    <ns>10</ns>
    <id>1046</id>
    <revision>
      <id>55343</id>
      <parentid>52421</parentid>
      <timestamp>2013-06-01T05:22:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list push front]] to [[Template:cpp/container/dsc push front]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/container/{{{1|}}}/push_front | inserts elements to the beginning}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc queue</title>
    <ns>10</ns>
    <id>5103</id>
    <revision>
      <id>55346</id>
      <parentid>52422</parentid>
      <timestamp>2013-06-01T05:22:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list queue]] to [[Template:cpp/container/dsc queue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/container/queue | adapts a container to provide queue (FIFO data structure) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc rbegin</title>
    <ns>10</ns>
    <id>1047</id>
    <revision>
      <id>55349</id>
      <parentid>52423</parentid>
      <timestamp>2013-06-01T05:22:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list rbegin]] to [[Template:cpp/container/dsc rbegin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem fun | cpp/container/{{{1|}}}/rbegin | title=rbegin&lt;br&gt; crbegin | returns a reverse iterator to the beginning | notes=&lt;br&gt;{{cpp/container/mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc reference</title>
    <ns>10</ns>
    <id>1202</id>
    <revision>
      <id>71978</id>
      <parentid>71967</parentid>
      <timestamp>2014-07-04T19:10:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use normal rev table</comment>
      <text xml:space="preserve" bytes="503">{{#switch:{{{1|}}}
| vector
| deque 
| list
| set
| multiset
| map
| multimap
| basic_string = {{dsc | {{tt|reference}} | {{rev begin|noborder=true}}{{rev|until=c++11|{{tt|Allocator::reference}}}}{{rev|since=c++11|{{tt|value_type&amp;}}}}{{rev end}} }}
| array
| dynarray
| forward_list
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{dsc | {{tt|reference}} | {{tt|value_type&amp;}} }}
| stack
| queue
| priority_queue = {{dsc | {{tt|reference}} | {{tt|Container::reference}} }}
}}</text>
      <sha1>dabqq15h1jlbgxdvpewunzbosad1ips</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc rehash</title>
    <ns>10</ns>
    <id>1048</id>
    <revision>
      <id>55358</id>
      <parentid>52425</parentid>
      <timestamp>2013-06-01T05:22:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list rehash]] to [[Template:cpp/container/dsc rehash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem fun | cpp/container/{{{1|}}}/rehash | reserves at least the specified number of buckets.&lt;br&gt;This regenerates the hash table.}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc remove</title>
    <ns>10</ns>
    <id>1049</id>
    <revision>
      <id>55360</id>
      <parentid>52426</parentid>
      <timestamp>2013-06-01T05:22:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list remove]] to [[Template:cpp/container/dsc remove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/container/{{{1|}}}/remove | title=remove&lt;br&gt;remove_if | removes elements satisfying specific criteria}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc rend</title>
    <ns>10</ns>
    <id>1051</id>
    <revision>
      <id>55363</id>
      <parentid>52427</parentid>
      <timestamp>2013-06-01T05:22:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list rend]] to [[Template:cpp/container/dsc rend]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc mem fun | cpp/container/{{{1|}}}/rend | title=rend&lt;br&gt; crend | returns a reverse iterator to the end | notes=&lt;br&gt;{{cpp/container/mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc reserve</title>
    <ns>10</ns>
    <id>1052</id>
    <revision>
      <id>55365</id>
      <parentid>52428</parentid>
      <timestamp>2013-06-01T05:22:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list reserve]] to [[Template:cpp/container/dsc reserve]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="254">{{cpp/container/if unord|{{{1}}}
|{{dsc mem fun | cpp/container/{{{1|}}}/reserve | reserves space for at least the specified number of elements.&lt;br&gt;This regenerates the hash table.}}
|{{dsc mem fun | cpp/container/{{{1|}}}/reserve | reserves storage}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc resize</title>
    <ns>10</ns>
    <id>1053</id>
    <revision>
      <id>55367</id>
      <parentid>52429</parentid>
      <timestamp>2013-06-01T05:22:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list resize]] to [[Template:cpp/container/dsc resize]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/container/{{{1|}}}/resize | changes the number of elements stored }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc reverse</title>
    <ns>10</ns>
    <id>1054</id>
    <revision>
      <id>55369</id>
      <parentid>52430</parentid>
      <timestamp>2013-06-01T05:22:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list reverse]] to [[Template:cpp/container/dsc reverse]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/container/{{{1|}}}/reverse | reverses the order of the elements}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc reverse iterator</title>
    <ns>10</ns>
    <id>1203</id>
    <revision>
      <id>55371</id>
      <parentid>52431</parentid>
      <timestamp>2013-06-01T05:22:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list reverse iterator]] to [[Template:cpp/container/dsc reverse iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc | &lt;code&gt;reverse_iterator&lt;/code&gt; | {{c|std::reverse_iterator&lt;iterator&gt;}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc set</title>
    <ns>10</ns>
    <id>5094</id>
    <revision>
      <id>55375</id>
      <parentid>52432</parentid>
      <timestamp>2013-06-01T05:23:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list set]] to [[Template:cpp/container/dsc set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc tclass | cpp/container/set | collection of unique keys, sorted by keys}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc shrink to fit</title>
    <ns>10</ns>
    <id>1055</id>
    <revision>
      <id>55381</id>
      <parentid>52433</parentid>
      <timestamp>2013-06-01T05:23:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list shrink to fit]] to [[Template:cpp/container/dsc shrink to fit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/container/{{{1|}}}/shrink_to_fit | reduces memory usage by freeing unused memory | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc size</title>
    <ns>10</ns>
    <id>1056</id>
    <revision>
      <id>55385</id>
      <parentid>52434</parentid>
      <timestamp>2013-06-01T05:23:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list size]] to [[Template:cpp/container/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/container/{{{1|}}}/size | returns the number of elements }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc size type</title>
    <ns>10</ns>
    <id>1204</id>
    <revision>
      <id>63262</id>
      <parentid>55389</parentid>
      <timestamp>2013-07-07T22:04:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="500">{{#switch:{{{1|}}}
| dynarray
| array = {{dsc | {{tt|size_type}} | {{lc|std::size_t}} }}
| vector
| deque 
| forward_list
| list
| set
| multiset
| unordered_set
| unordered_multiset
| map
| multimap
| unordered_map
| unordered_multimap
| basic_string = {{dsc | {{tt|size_type}} | Unsigned integral type (usually {{lc|std::size_t}}) }}
| vector_bool = {{dsc | {{tt|size_type}} | implementation-defined }}
| stack
| queue
| priority_queue = {{dsc | {{tt|size_type}} | {{tt|Container::size_type}} }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc sort</title>
    <ns>10</ns>
    <id>1057</id>
    <revision>
      <id>55395</id>
      <parentid>52436</parentid>
      <timestamp>2013-06-01T05:23:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list sort]] to [[Template:cpp/container/dsc sort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/container/{{{1|}}}/sort | sorts the elements}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc splice</title>
    <ns>10</ns>
    <id>1058</id>
    <revision>
      <id>55399</id>
      <parentid>52437</parentid>
      <timestamp>2013-06-01T05:23:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list splice]] to [[Template:cpp/container/dsc splice]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | cpp/container/{{{1|}}}/splice | moves elements from another {{tt|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc splice after</title>
    <ns>10</ns>
    <id>2447</id>
    <revision>
      <id>55402</id>
      <parentid>52438</parentid>
      <timestamp>2013-06-01T05:23:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list splice after]] to [[Template:cpp/container/dsc splice after]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/container/{{{1|}}}/splice_after | moves elements from another {{tt|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc stack</title>
    <ns>10</ns>
    <id>5104</id>
    <revision>
      <id>55407</id>
      <parentid>52439</parentid>
      <timestamp>2013-06-01T05:23:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list stack]] to [[Template:cpp/container/dsc stack]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/container/stack | adapts a container to provide stack (LIFO data structure) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc swap</title>
    <ns>10</ns>
    <id>1059</id>
    <revision>
      <id>55411</id>
      <parentid>52440</parentid>
      <timestamp>2013-06-01T05:23:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list swap]] to [[Template:cpp/container/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/container/{{{1|}}}/swap | swaps the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc swap2</title>
    <ns>10</ns>
    <id>1987</id>
    <revision>
      <id>72238</id>
      <parentid>72237</parentid>
      <timestamp>2014-07-26T07:16:45Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="224">{{dsc tfun | cpp/container/{{{1|}}}/swap2 | title=std::swap{{dsc small|(std::{{{1|}}})}} | specializes the {{lc|std::swap}} algorithm | notes={{#ifeq:{{cpp/std|{{{1}}}}}|c++98|&lt;!--empty--&gt;|{{mark {{cpp/std|{{{1}}} }} }}}} }}</text>
      <sha1>mvmg2p73vcv4irta6rdbip9rrkd7fid</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc top</title>
    <ns>10</ns>
    <id>1060</id>
    <revision>
      <id>67279</id>
      <parentid>55416</parentid>
      <timestamp>2014-02-02T21:03:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>consistency</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/container/{{{1|}}}/top | accesses the top element }}</text>
      <sha1>evmpmi59z7htoipsmo4l5eex4se07gr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc unique</title>
    <ns>10</ns>
    <id>1061</id>
    <revision>
      <id>55418</id>
      <parentid>52443</parentid>
      <timestamp>2013-06-01T05:23:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list unique]] to [[Template:cpp/container/dsc unique]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/container/{{{1|}}}/unique | removes consecutive duplicate elements}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc unordered map</title>
    <ns>10</ns>
    <id>5098</id>
    <revision>
      <id>55421</id>
      <parentid>52444</parentid>
      <timestamp>2013-06-01T05:23:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list unordered map]] to [[Template:cpp/container/dsc unordered map]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc tclass | cpp/container/unordered_map | collection of key-value pairs, hashed by keys, keys are unique | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc unordered multimap</title>
    <ns>10</ns>
    <id>5101</id>
    <revision>
      <id>55423</id>
      <parentid>52445</parentid>
      <timestamp>2013-06-01T05:23:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list unordered multimap]] to [[Template:cpp/container/dsc unordered multimap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc tclass | cpp/container/unordered_multimap | collection of key-value pairs, hashed by keys | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc unordered multiset</title>
    <ns>10</ns>
    <id>5100</id>
    <revision>
      <id>55425</id>
      <parentid>52446</parentid>
      <timestamp>2013-06-01T05:23:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list unordered multiset]] to [[Template:cpp/container/dsc unordered multiset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc tclass | cpp/container/unordered_multiset | collection of keys, hashed by keys | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc unordered set</title>
    <ns>10</ns>
    <id>5099</id>
    <revision>
      <id>55430</id>
      <parentid>52447</parentid>
      <timestamp>2013-06-01T05:23:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list unordered set]] to [[Template:cpp/container/dsc unordered set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc tclass | cpp/container/unordered_set | collection of unique keys, hashed by keys | notes={{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc upper bound</title>
    <ns>10</ns>
    <id>1062</id>
    <revision>
      <id>55436</id>
      <parentid>52448</parentid>
      <timestamp>2013-06-01T05:23:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list upper bound]] to [[Template:cpp/container/dsc upper bound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem fun | cpp/container/{{{1|}}}/upper_bound | returns an iterator to the first element ''greater'' than a certain value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc uses allocator</title>
    <ns>10</ns>
    <id>3386</id>
    <revision>
      <id>55439</id>
      <parentid>52449</parentid>
      <timestamp>2013-06-01T05:23:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list uses allocator]] to [[Template:cpp/container/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="189">{{dsc tfun | cpp/container/{{{1|}}}/uses_allocator | title=std::uses_allocator{{dsc small|&lt;std::{{{1|}}}&gt;}} | specializes the {{lc|std::uses_allocator}} type trait | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc value comp</title>
    <ns>10</ns>
    <id>1063</id>
    <revision>
      <id>55445</id>
      <parentid>52450</parentid>
      <timestamp>2013-06-01T05:23:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list value comp]] to [[Template:cpp/container/dsc value comp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/container/{{{1|}}}/value_comp | returns the function that compares keys in objects of type value_type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc value compare</title>
    <ns>10</ns>
    <id>3615</id>
    <revision>
      <id>55449</id>
      <parentid>52451</parentid>
      <timestamp>2013-06-01T05:23:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list value compare]] to [[Template:cpp/container/dsc value compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc class | cpp/container/{{{1|}}}/value_compare | compares objects of type {{tt|value_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc value compare2</title>
    <ns>10</ns>
    <id>1205</id>
    <revision>
      <id>55452</id>
      <parentid>52452</parentid>
      <timestamp>2013-06-01T05:23:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list value compare2]] to [[Template:cpp/container/dsc value compare2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">{{dsc | {{tt|value_compare}} | {{tt|Compare}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc value type</title>
    <ns>10</ns>
    <id>1206</id>
    <revision>
      <id>55455</id>
      <parentid>52453</parentid>
      <timestamp>2013-06-01T05:23:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list value type]] to [[Template:cpp/container/dsc value type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="490">{{#switch:{{{1|}}}
| array
| dynarray
| vector
| deque 
| forward_list
| list = {{dsc | {{tt|value_type}} | {{tt|T}} }}
| vector_bool = {{dsc | {{tt|value_type}} | {{c|bool}} }}
| set
| multiset
| unordered_set
| unordered_multiset = {{dsc | {{tt|value_type}} | {{tt|Key}} }}
| map
| multimap
| unordered_map
| unordered_multimap = {{dsc | {{tt|value_type}} | {{c|std::pair&lt;const Key, T&gt;}} }}
| stack
| queue
| priority_queue = {{dsc | {{tt|value_type}} | {{tt|Container::value_type}} }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc vector</title>
    <ns>10</ns>
    <id>5090</id>
    <revision>
      <id>55460</id>
      <parentid>52454</parentid>
      <timestamp>2013-06-01T05:23:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/dcl list vector]] to [[Template:cpp/container/dsc vector]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc tclass | cpp/container/vector | dynamic contiguous array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dsc vector bool</title>
    <ns>10</ns>
    <id>8649</id>
    <revision>
      <id>64075</id>
      <parentid>64074</parentid>
      <timestamp>2013-08-08T12:44:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 64074 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="111">{{dsc ptclass | cpp/container/vector_bool | title=vector{{dsc small|&lt;bool&gt;}} | space-efficient dynamic bitset}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dynarray/navbar</title>
    <ns>10</ns>
    <id>10053</id>
    <revision>
      <id>47747</id>
      <timestamp>2013-05-16T20:19:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="257">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/dynarray/navbar heading
|content3 = cpp/container/dynarray/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dynarray/navbar content</title>
    <ns>10</ns>
    <id>10055</id>
    <revision>
      <id>52458</id>
      <parentid>47786</parentid>
      <timestamp>2013-06-01T04:47:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="909">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/dynarray/dynarray }}
{{nv mem ln | cpp/container/dynarray/~dynarray }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/dynarray/at }}
{{nv mem ln | cpp/container/dynarray/operator_at | operator[] }}
{{nv mem ln | cpp/container/dynarray/front }}
{{nv mem ln | cpp/container/dynarray/back }}
{{nv mem ln | cpp/container/dynarray/data}}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/dynarray/begin | begin | cbegin}}
{{nv mem ln | cpp/container/dynarray/end | end | cend}}
{{nv mem ln | cpp/container/dynarray/rbegin | rbegin | crbegin}}
{{nv mem ln | cpp/container/dynarray/rend | rend | crend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/dynarray/empty}}
{{nv mem ln | cpp/container/dynarray/size}}
{{nv mem ln | cpp/container/dynarray/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/dynarray/fill}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dynarray/navbar heading</title>
    <ns>10</ns>
    <id>10054</id>
    <revision>
      <id>47748</id>
      <timestamp>2013-05-16T20:20:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="44">{{ltt|cpp/container/dynarray|std::dynarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/dynarray/title</title>
    <ns>10</ns>
    <id>10010</id>
    <revision>
      <id>47678</id>
      <timestamp>2013-05-16T18:40:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=dynarray::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace</title>
    <ns>10</ns>
    <id>1069</id>
    <revision>
      <id>68718</id>
      <parentid>62194</parentid>
      <timestamp>2014-03-20T02:32:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note on bool</comment>
      <text xml:space="preserve" bytes="1611">{{cpp/container/{{{1|}}}/title | emplace}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class... Args &gt; 
iterator emplace( const_iterator pos, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element into the container directly before {{tt|pos}}. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with the arguments {{c|std::forward&lt;Args&gt;(args)...}}. The element type must be {{concept|EmplaceConstructible}}{{#switch:{{{1|}}}|list=|vector|deque=, {{concept|MoveInsertable}} and {{concept|MoveAssignable}}}}.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|emplace}}

===Parameters===
{{par begin}}
{{par | pos | iterator before which the new element will be constructed}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Iterator pointing to the emplaced element. 

===Complexity===
{{#switch:{{{1|}}}
|list=
Constant.
|deque=
Linear in the lesser of the distances between {{tt|pos}} and either of the ends of the container.
|vector=
Linear in the distance between {{tt|pos}} and end of the container.
| {{included}}
}}

===Exceptions===
If an exception is thrown (e.g. by the constructor), the container is left unmodified, as if this function was never called (strong exception guarantee).
{{#ifeq:{{{1|}}}|vector|

===Notes===
The specialization [[cpp/container/vector_bool|std::vector&lt;bool&gt;]] did not have {{tt|emplace()}} member until C++14.

}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc insert |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>h3j98rgwvcic9qakgqrapkyyh23ojrz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace ad</title>
    <ns>10</ns>
    <id>1070</id>
    <revision>
      <id>67096</id>
      <parentid>67095</parentid>
      <timestamp>2014-01-22T03:37:24Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>only log+emplace_back for priority queue</comment>
      <text xml:space="preserve" bytes="1687">{{cpp/container/{{{1|}}}/title | emplace}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class... Args &gt;
void emplace( Args&amp;&amp;... args );
}}
{{dcl end}}

{{#switch:{{{1|}}}
| stack = Pushes new element on top of the stack. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function.

Effectively calls {{c|c.emplace_back(std::forward&lt;Args&gt;(args)...)}}

| queue = Pushes new element to the end of the queue. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function.

Effectively calls {{c|c.emplace_back(std::forward&lt;Args&gt;(args)...)}}

| priority_queue | Pushes new element to the priority queue. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments as supplied to the function.

Effectively calls {{c|c.emplace_back(std::forward&lt;Args&gt;(args)...); std::push_heap(c.begin(), c.end(), comp);}}
}}

===Parameters===
{{par begin}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
(none)

===Complexity===
{{#switch:{{{1|}}}
| priority_queue = Logarithmic number of comparisons plus the complexity of {{c|Container::emplace_back}}.
| #default = Identical to the complexity of {{c|Container::emplace_back}}.
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc push | {{{1|}}}}}
{{dsc inc | cpp/container/dsc pop | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>c1zqh1sk4as0vewmukgxusmorgcd03m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace assoc</title>
    <ns>10</ns>
    <id>1071</id>
    <revision>
      <id>69581</id>
      <parentid>69148</parentid>
      <timestamp>2014-04-14T14:55:25Z</timestamp>
      <contributor>
        <username>Dribeas</username>
        <id>2132</id>
      </contributor>
      <text xml:space="preserve" bytes="3019">{{cpp/container/{{{1|}}}/title | emplace}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
{{cpp/container/if uniq | {{{1|}}}
 |template&lt; class... Args &gt;
std::pair&lt;iterator,bool&gt; emplace( Args&amp;&amp;... args );
 |template&lt; class... Args &gt;
iterator emplace( Args&amp;&amp;... args );
}}
}}
{{dcl end}}

Inserts a new element into the container by constructing it in-place with the given {{tt|args}}  {{cpp/container/if uniq |{{{1|}}} |  if there is no element with the key in the container | }}.

Careful use of {{tt|emplace}} allows the new element to be constructed while avoiding unnecessary copy or move operations.
{{cpp/container/if set | {{{1|}}} | The constructor of the new element is called with exactly the same arguments as supplied to {{tt|emplace}}, forwarded via {{c|std::forward&lt;Args&gt;(args)...}}. | The constructor of the new element (i.e. {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to {{tt|emplace}}, forwarded via {{c|std::forward&lt;Args&gt;(args)...}}.}}

{{cpp/container/note_iterator_invalidation|{{{1|}}}|emplace}}

===Parameters===
{{par begin}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
{{cpp/container/if uniq | {{{1|}}}
 |Returns a pair consisting of a {{c|bool}} denoting whether the insertion took place and an iterator to the inserted element, or the already-existing element if no insertion happened.
 |Returns an iterator to the inserted element.
}}

===Exceptions===
If an exception is thrown by any operation, this function has no effect.

===Complexity===
{{cpp/container/if ord | {{{1|}}}
 | Logarithmic in the size of the container.
 | Amortized constant on average, worst case linear in the size of the container.
}}

===Example===
{{example |
| code =
{{#switch: {{{1|}}} | map | multimap | unordered_map | unordered_multimap =
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;string&gt;
{{cpp/container/if ord | {{{1|}}}
| #include &lt;map&gt;
| #include &lt;unordered_map&gt;
}}
int main()
{
    std::{{{1|}}}&lt;std::string, std::string&gt; m;

    // uses pair's move constructor (overload 8)
    m.emplace(std::make_pair(std::string(&quot;a&quot;), std::string(&quot;a&quot;)));

    // uses pair's converting move constructor (overload 5)
    m.emplace(std::make_pair(&quot;b&quot;, &quot;abcd&quot;));

    // uses pair's template constructor (overload 3)
    m.emplace(&quot;d&quot;, &quot;ddd&quot;);

    // uses pair's piecewise constructor (overload 6)
    m.emplace(std::piecewise_construct,
              std::forward_as_tuple(&quot;c&quot;),
              std::forward_as_tuple(10, 'c'));

    for (const auto &amp;p : m) {
        std::cout &lt;&lt; p.first &lt;&lt; &quot; =&gt; &quot; &lt;&lt; p.second &lt;&lt; '\n';
    }
}
|}}
| p={{#switch: {{{1|}}} | unordered_map | unordered_multimap =
true|false}}
| output =
{{#switch: {{{1|}}} | map | multimap | unordered_map | unordered_multimap =
a =&gt; a
b =&gt; abcd
c =&gt; cccccccccc
d =&gt; ddd
|}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace_hint |{{{1|}}}}}
{{dsc inc | cpp/container/dsc insert |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>oaoh8q2z6lh601yj69nmdjmbsmypuel</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace back</title>
    <ns>10</ns>
    <id>1072</id>
    <revision>
      <id>68840</id>
      <parentid>68719</parentid>
      <timestamp>2014-03-22T16:53:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use copyinsertable in phrasing</comment>
      <text xml:space="preserve" bytes="3274">{{cpp/container/{{{1|}}}/title | emplace_back}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class... Args &gt;
void emplace_back( Args&amp;&amp;... args );
}}
{{dcl end}}

Appends a new element to the end of the container. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments that are supplied to the function.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|emplace_back}}

===Parameters===
{{par begin}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
If an exception is thrown, this function has no effect (strong exception guarantee).
{{#ifeq: {{{1|}}} | vector |
If {{tt|T}}'s move constructor is not {{c|noexcept}} and is not {{concept|CopyInsertable}} into {{tt|*this}}, vector will use the throwing move constructor. If it throws, the guarantee is waived and the effects are unspecified.
}}
{{#ifeq:{{{1|}}}|vector|

===Notes===
The specialization [[cpp/container/vector_bool|std::vector&lt;bool&gt;]] did not have {{tt|emplace_back()}} member until C++14.

}}
===Example===
{{example
 | The following code uses {{tt|emplace_back}} to append an object of type {{tt|President}} to a {{c|std::{{{1}}}}}. It demonstrates how {{tt|emplace_back}} forwards parameters to the {{tt|President}} constructor and shows how using {{tt|emplace_back}} avoids the extra copy or move operation required when using {{tt|push_back}}.
 | code =
#include &lt;{{{1}}}&gt;
#include &lt;string&gt;
#include &lt;iostream&gt;
 
struct President
{
    std::string name;
    std::string country;
    int year;
  
    President(std::string p_name, std::string p_country, int p_year)
        : name(std::move(p_name)), country(std::move(p_country)), year(p_year)
    {
        std::cout &lt;&lt; &quot;I am being constructed.\n&quot;;
    }
    President(President&amp;&amp; other)
        : name(std::move(other.name)), country(std::move(other.country)), year(other.year)
    {
        std::cout &lt;&lt; &quot;I am being moved.\n&quot;;
    }
    President&amp; operator=(const President&amp; other) = default;
};

int main()
{
    std::{{{1}}}&lt;President&gt; elections;
    std::cout &lt;&lt; &quot;emplace_back:\n&quot;;
    elections.emplace_back(&quot;Nelson Mandela&quot;, &quot;South Africa&quot;, 1994);

    std::{{{1}}}&lt;President&gt; reElections;
    std::cout &lt;&lt; &quot;\npush_back:\n&quot;;
    reElections.push_back(President(&quot;Franklin Delano Roosevelt&quot;, &quot;the USA&quot;, 1936));
 
    std::cout &lt;&lt; &quot;\nContents:\n&quot;;
    for (President const&amp; president: elections) {
        std::cout &lt;&lt; president.name &lt;&lt; &quot; was elected president of &quot;
                  &lt;&lt; president.country &lt;&lt; &quot; in &quot; &lt;&lt; president.year &lt;&lt; &quot;.\n&quot;;
    }
    for (President const&amp; president: reElections) {
        std::cout &lt;&lt; president.name &lt;&lt; &quot; was re-elected president of &quot;
                  &lt;&lt; president.country &lt;&lt; &quot; in &quot; &lt;&lt; president.year &lt;&lt; &quot;.\n&quot;;
    }
}
 | output=
emplace_back:
I am being constructed.

push_back:
I am being constructed.
I am being moved.

Contents:
Nelson Mandela was elected president of South Africa in 1994.
Franklin Delano Roosevelt was re-elected president of the USA in 1936.
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc push_back |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>eydhinvld6qysrdqdoaxvl4wfadr225</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace front</title>
    <ns>10</ns>
    <id>1073</id>
    <revision>
      <id>68836</id>
      <parentid>62188</parentid>
      <timestamp>2014-03-22T16:44:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>strong exception guarantee (lwg 2252)</comment>
      <text xml:space="preserve" bytes="882">{{cpp/container/{{{1|}}}/title | emplace_front}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class... Args &gt;
void emplace_front( Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the beginning of the container. The element is constructed in-place, i.e. no copy or move operations are performed. The constructor of the element is called with exactly the same arguments, as supplied to the function.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|emplace_front}}

===Parameters===
{{par begin}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
If an exception is thrown, this function has no effect (strong exception guarantee).

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc push_front |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>s8kl6hupfnxliiy1e8hlfzrb5i1ckt6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/emplace hint</title>
    <ns>10</ns>
    <id>1074</id>
    <revision>
      <id>62189</id>
      <parentid>55758</parentid>
      <timestamp>2013-06-25T11:59:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="1750">{{cpp/container/{{{1|}}}/title | emplace_hint}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template &lt;class... Args&gt;
iterator emplace_hint( const_iterator hint, Args&amp;&amp;... args );
}}
{{dcl end}}

Inserts a new element to the container, using {{tt|hint}} as a suggestion where the element should go. The element is constructed in-place, i.e. no copy or move operations are performed. {{cpp/container/if set | {{{1|}}} | The constructor of the element is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}. | The constructor of the element type ({{tt|value_type}}, that is, {{c|std::pair&lt;const Key, T&gt;}}) is called with exactly the same arguments as supplied to the function, forwarded with {{c|std::forward&lt;Args&gt;(args)...}}.}}

{{cpp/container/note_iterator_invalidation|{{{1|}}}|emplace_hint}}

===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the new element}}
{{par | args | arguments to forward to the constructor of the element}}
{{par end}} 

===Return value===
Returns an iterator to the newly inserted element.
{{cpp/container/if uniq | {{{1|}}}
 | 
If the insertion failed because the element already exists, returns an iterator to the already existing element with the equivalent key.|}}

===Complexity===
{{cpp/container/if ord | {{{1|}}}
 | Logarithmic in the size of the container in general, but amortized constant if the new element is inserted just before {{tt|hint}}.
 | Amortized constant on average, worst case linear in the size of the container.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |{{{1|}}}}}
{{dsc inc | cpp/container/dsc insert |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/empty</title>
    <ns>10</ns>
    <id>1075</id>
    <revision>
      <id>64774</id>
      <parentid>64687</parentid>
      <timestamp>2013-08-26T23:52:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix noexcept</comment>
      <text xml:space="preserve" bytes="805">{{cpp/container/{{{1|}}}/title | empty}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{#ifeq:{{{1|}}}|array
|
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
constexpr bool empty();
}}
{{dcl | since=c++14 |
constexpr bool empty() const;
}}
{{dcl rev end}}
|
{{dcl | since={{cpp/std|{{{1|}}}}} |
bool empty() const;
}}
}}
{{dcl end}}

Checks if the container has no elements, i.e. whether {{c|begin() {{==}} end()}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the container is empty, {{c|false}} otherwise

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===Example===
{{include | cpp/container/{{{1|}}}/example_empty}}

{{#ifeq: {{{1|}}} | forward_list||
===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc size |{{{1|}}}}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/empty ad</title>
    <ns>10</ns>
    <id>1076</id>
    <revision>
      <id>62191</id>
      <parentid>55762</parentid>
      <timestamp>2013-06-25T12:00:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="478">{{cpp/container/{{{1|}}}/title | empty}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
bool empty() const;
}}
{{dcl end}}

Checks if the underlying container has no elements, i.e. whether {{c|c.empty()}}.

===Parameters===
(none)

===Return value===

{{c|true}} if the underlying container is empty, {{c|false}} otherwise

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc size | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/end</title>
    <ns>10</ns>
    <id>1077</id>
    <revision>
      <id>64868</id>
      <parentid>64773</parentid>
      <timestamp>2013-08-27T01:41:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix since=</comment>
      <text xml:space="preserve" bytes="779">{{cpp/container/{{{1|}}}/title | end | cend}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
iterator end();
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
const_iterator end() const;
}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
const_iterator cend() const;
}}
{{dcl end}}

Returns an iterator to the element following the last element of the container. 

This element acts as a placeholder; attempting to access it results in undefined behavior. 

{{image|range-begin-end.svg}}

===Parameters===
(none)

===Return value===
Iterator to the element following the last element.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc begin |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/end(int)</title>
    <ns>10</ns>
    <id>9091</id>
    <redirect title="Template:cpp/container/end2" />
    <revision>
      <id>38160</id>
      <timestamp>2012-07-24T13:44:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/container/end(int)]] to [[Template:cpp/container/end2]]: Text replace - &quot;/end(int)&quot; to &quot;/end2&quot;</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[Template:cpp/container/end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/end2</title>
    <ns>10</ns>
    <id>1078</id>
    <revision>
      <id>63575</id>
      <parentid>55768</parentid>
      <timestamp>2013-07-10T01:44:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="820">{{cpp/container/{{{1|}}}/title | end{{small|(int)}} | cend{{small|(int)}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
local_iterator end( size_type n );
}}
{{dcl | since=c++11 |
const_local_iterator end( size_type n ) const;
}}
{{dcl | since=c++11 |
const_local_iterator cend( size_type n ) const;
}}
{{dcl end}}

Returns an iterator to the element following the last element of the bucket with index {{tt|n}}. 
. This element acts as a placeholder, attempting to access it results in undefined behavior. 

===Parameters===
{{par begin}}
{{par | n | the index of the bucket to access}}
{{par end}}

===Return value===

iterator to the element following the last element

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc begin(int) |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/equal range ord</title>
    <ns>10</ns>
    <id>1079</id>
    <revision>
      <id>67231</id>
      <parentid>67226</parentid>
      <timestamp>2014-01-28T08:23:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>seems to work..</comment>
      <text xml:space="preserve" bytes="2364">{{cpp/container/{{{1|}}}/title | equal_range}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 |
std::pair&lt;iterator,iterator&gt; equal_range( const Key&amp; key );
}}
{{dcl | num=2 |
std::pair&lt;const_iterator,const_iterator&gt; equal_range( const Key&amp; key ) const;
}}
{{dcl | num=3 | since=c++14 |
template&lt; class K &gt;
std::pair&lt;iterator,iterator&gt; equal_range( const K&amp; x );
}}
{{dcl | num=4 | since=c++14 |
template&lt; class K &gt;
std::pair&lt;const_iterator,const_iterator&gt; equal_range( const K&amp; x ) const;
}}
{{dcl end}}

Returns a range containing all elements with the given key in the container. The range is defined by two iterators, one pointing to the first element that is ''not less'' than {{tt|key}} and another pointing to the first element ''greater'' than {{tt|key}}. The first iterator may be alternatively obtained with {{lc|lower_bound()}}, the second - with {{lc|upper_bound()}}.

@1-2@ Compares the keys to {{tt|key}}.

@3,4@ Compares the keys to the value {{tt|x}}. These templates only participate in overload resolution if the type {{c|Compare::is_transparent}} exists. They allow calling this function without constructing an instance of {{tt|Key}}. {{todo|explain better}}

===Parameters===
{{par begin}}
{{par | key | key value to compare the elements to}}
{{par | x | alternative value that can be compared to {{tt|Key}} }}
{{par end}} 

===Return value===
{{lc|std::pair}} containing a pair of iterators defining the wanted range: the first pointing to the first element that is not ''less'' than {{tt|key}} and the second pointing to the first element ''greater'' than {{tt|key}}. 

If there are no elements ''not less'' than {{tt|key}}, past-the-end (see {{lc|end()}}) iterator is returned as the first element. Similarly if there are no elements ''greater'' than {{tt|key}}, past-the-end iterator is returned as the second element.

{{cpp/container/if uniq|{{{1|}}}||
{{rev begin}}
{{rev|since=c++11 | Since {{rlp|insert}} always inserts at the upper bound, the order of equivalent elements is the equal range is the order of insertion.
}}
{{rev end}}
}}

===Complexity===
Logarithmic in the size of the container.

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc find |{{{1|}}}}}
{{dsc inc | cpp/container/dsc upper_bound |{{{1|}}}}}
{{dsc inc | cpp/container/dsc lower_bound |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>sopv07f99x1hz1c62jq6ir1kqlnqguu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/equal range unord</title>
    <ns>10</ns>
    <id>12946</id>
    <revision>
      <id>70011</id>
      <parentid>70010</parentid>
      <timestamp>2014-05-06T16:17:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>diff output between multimap and uniq</comment>
      <text xml:space="preserve" bytes="1477">{{cpp/container/{{{1|}}}/title | equal_range}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
std::pair&lt;iterator,iterator&gt; equal_range( const Key&amp; key );
}}
{{dcl | since=c++11 |
std::pair&lt;const_iterator,const_iterator&gt; equal_range( const Key&amp; key ) const;
}}
{{dcl end}}

Returns a range containing all elements with key {{tt|key}} in the container. The range is defined by two iterators, the first pointing to the first element of the wanted range and the second pointing past the last element of the range.

===Parameters===
{{par begin}}
{{par | key | key value to compare the elements to}}
{{par end}} 

===Return value===
{{lc|std::pair}} containing a pair of iterators defining the wanted range. If there are no such elements, past-the-end (see {{lc|end()}}) iterators are returned as both elements of the pair.

===Complexity===
Average case constant, worst case linear in the size of the container.

===Example===
{{cpp/container/if map| {{{1|}}} |
{{example|code=
#include &lt;iostream&gt;
#include &lt;unordered_map&gt;
 
int main()
{  
    std::{{{1}}}&lt;int,char&gt; map = {{1,'a'},{1,'b'},{1,'d'},{2,'b'}};
    auto range = map.equal_range(1);
    for (auto it = range.first; it != range.second; ++it) {
        std::cout &lt;&lt; it-&gt;first &lt;&lt; ' ' &lt;&lt; it-&gt;second &lt;&lt; '\n';
    }
}
|output=
1 a
{{cpp/container/if uniq|{{{1}}}||
1 b
1 d
}}
}}
| 
{{example
|code=
|output=
}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc find |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>3ucp2zdz10akvph1tnaigno3r9jvtlk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/erase</title>
    <ns>10</ns>
    <id>1080</id>
    <revision>
      <id>72281</id>
      <parentid>72246</parentid>
      <timestamp>2014-08-03T23:46:11Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>swap complexity guarantees</comment>
      <text xml:space="preserve" bytes="2533">{{cpp/container/{{{1|}}}/title | erase}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
iterator erase( iterator pos );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator pos );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
iterator erase( iterator first, iterator last );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator first, const_iterator last );
}}
{{dcl rev end}}
{{dcl end}}

Removes specified elements from the container. 

@1@ Removes the element at {{tt|pos}}.

@2@ Removes the elements in the range {{tt|[first; last)}}.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|erase}}

The iterator {{tt|pos}} must be valid and dereferenceable. Thus the {{lc|end()}} iterator (which is valid, but is not dereferencable) cannot be used as a value for {{tt|pos}}.

The iterator {{tt|first}} does not need to be dereferenceable if {{tt|first{{==}}last}}: erasing an empty range is a no-op.

===Parameters===
{{par begin}}
{{par | pos | iterator to the element to remove}}
{{par | first, last | range of elements to remove}}
{{par end}} 

===Return value===
Iterator following the last removed element. If the iterator {{tt|pos}} refers to the last element, the {{lc|end()}} iterator is returned.

===Exceptions===
(none)

===Complexity===
{{#switch:{{{1|}}} | list=
@1@ Constant.

@2@ Linear in the distance between {{tt|first}} and {{tt|last}}.
|
@1@ Linear in distance between {{tt|position}} and the end of the container.

@2@ Linear in the distance between {{tt|position}} and {{tt|last}}.
}}

===Example===
{{example
 |code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
{{#switch:{{{1}}}
| vector
| deque = 
|
#include &lt;iterator&gt;
}}

int main( )
{
    std::{{{1}}}&lt;int&gt; c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    for (auto &amp;i : c) {
        std::cout &lt;&lt; i &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';

    c.erase(c.begin());

    for (auto &amp;i : c) {
        std::cout &lt;&lt; i &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';

    {{#switch:{{{1}}}
| vector
| deque = 
    c.erase(c.begin()+2, c.begin()+5);
|
    std::{{{1}}}&lt;int&gt;::iterator range_begin {{=}} c.begin();
    std::{{{1}}}&lt;int&gt;::iterator range_end {{=}} c.begin();
    std::advance(range_begin,2);
    std::advance(range_end,5);

    c.erase(range_begin, range_end);
}}

    for (auto &amp;i : c) {
        std::cout &lt;&lt; i &lt;&lt; &quot; &quot;;
    }
    std::cout &lt;&lt; '\n';
}
| output=
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 6 7 8 9
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc clear |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>j37qczz0p58r7vethc0fdmmf45app4w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/erase assoc</title>
    <ns>10</ns>
    <id>1081</id>
    <revision>
      <id>68779</id>
      <parentid>68778</parentid>
      <timestamp>2014-03-21T02:37:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="2421">{{cpp/container/{{{1|}}}/title | erase}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{cpp/container/if ord | {{{1|}}} |
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
void erase( iterator pos );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator pos );
}}
{{dcl rev end}}
{{dcl rev begin | num=2}}
{{dcl | until=c++11 |
void erase( iterator first, iterator last );
}}
{{dcl | since=c++11 |
iterator erase( const_iterator first, const_iterator last );
}}
{{dcl rev end}}
{{dcl | num=3 |
size_type erase( const key_type&amp; key );
}}
|{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
iterator erase( const_iterator pos );
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
iterator erase( const_iterator first, const_iterator last );
}}
{{dcl | num=3 | since={{cpp/std|{{{1|}}}}} |
size_type erase( const key_type&amp; key );
}}
}}
{{dcl end}}

Removes specified elements from the container. 

@1@ Removes the element at {{tt|pos}}.
@2@ Removes the elements in the range {{tt|[first; last)}}.
@3@ Removes all elements with the key value {{tt|key}}.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|erase}}

The iterator {{tt|pos}} must be valid and dereferenceable. Thus the {{lc|end()}} iterator (which is valid, but is not dereferencable) cannot be used as a value for {{tt|pos}}.

{{cpp/container/if unord | {{{1|}}} |
{{rev begin}}
{{rev|since=c++14|
The order of the elements that are not erased is preserved (this makes it possible to erase individual elements while iterating through the container)
}}
{{rev end}}
}}
===Parameters===
{{par begin}}
{{par | pos | iterator to the element to remove}}
{{par | first, last | range of elements to remove}}
{{par | key | key value of the elements to remove}}
{{par end}} 

===Return value===
@1-2@ Iterator following the last removed element.
@3@ Number of elements removed.

===Exceptions===
@1,2@ (none)
@3@ Any exceptions thrown by the {{tt|Compare}} object.

===Complexity===
Given an instance {{tt|c}} of {{tt|{{{1}}}}}:
{{cpp/container/if ord | {{{1|}}} |
@1@ Amortized constant

@2@ {{c|log(c.size()) + std::distance(first, last)}}

@3@ {{c|log(c.size()) + c.count(k)}}
|
@1@ Average case: constant, worst case: {{c|c.size()}}

@2@ Average case: {{c|std::distance(first, last)}}, worst case: {{c|c.size()}}

@3@ Average case: {{c|c.count(key)}}, worst case: {{c|c.size()}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc clear |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>hj49bl6s2g1pb8vs19u9nyqgny0i3xo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/fill</title>
    <ns>10</ns>
    <id>10052</id>
    <revision>
      <id>63853</id>
      <parentid>52472</parentid>
      <timestamp>2013-07-29T15:20:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="419">{{cpp/container/{{{1|}}}/title | fill}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void fill( const T&amp; value );
}}
{{dcl end}}

Assigns the given value {{tt|value}} to all elements in the container.

===Parameters===
{{par begin}}
{{par | value | the value to assign to the elements}}
{{par end}}

===Return value===
(none)

===Complexity===
Linear in the size of the container</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/find</title>
    <ns>10</ns>
    <id>1082</id>
    <revision>
      <id>71798</id>
      <parentid>71742</parentid>
      <timestamp>2014-06-24T14:18:16Z</timestamp>
      <contributor>
        <username>DizzySkin</username>
        <id>3171</id>
      </contributor>
      <minor/>
      <comment>Using new template for including associative containers.</comment>
      <text xml:space="preserve" bytes="2235">{{cpp/container/{{{1|}}}/title | find}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num = 1 |
iterator find( const Key&amp; key );
}}
{{dcl | num = 2 |
const_iterator find( const Key&amp; key ) const;
}}
{{cpp/container/if ord | {{{1|}}}
|{{dcl | num=3 | since=c++14 |
template&lt; class K &gt; iterator find( const K&amp; x );
}}
{{dcl | num=4 | since=c++14 |
template&lt; class K &gt; const_iterator find( const K&amp; x ) const;
}}
}}
{{dcl end}}

@1,2@ Finds an element with key equivalent to {{tt|key}}. {{#ifeq:{{{1|}}}|multimap|If there are several elements with {{tt|key}} in the container, any of them may be returned.}} 

{{cpp/container/if ord | {{{1|}}}
|@3,4@ Finds an element with key that compares ''equivalent'' to the value {{tt|x}}. These templates only participate in overload resolution if the type {{c|Compare::is_transparent}} exists. They allow calling this function without constructing an instance of {{tt|Key}}
}}
===Parameters===
{{par begin}}
{{par | key | key value of the element to search for}}
{{cpp/container/if ord | {{{1|}}} |
{{par | x | a value of any type that can be transparently compared with a key}}
}}
{{par end}} 

===Return value===
Iterator to an element with key equivalent to {{tt|key}}. If no such element is found, past-the-end (see {{lc|end()}}) iterator is returned.

===Complexity===
{{cpp/container/if ord | {{{1|}}}
 | Logarithmic in the size of the container.
 | Constant on average, worst case linear in the size of the container.
}}

===Example===
{{example|code=
#include &lt;iostream&gt;
{{cpp/container/correct include assoc| {{{1|set}}}}}
 
int main()
{  
    std::{{{1|set}}}{{cpp/container/if map| {{{1|set}}}| &lt;int,char&gt;| &lt;int&gt;}} example = {{cpp/container/if map| {{{1|set}}}| {{1,'a'},{2,'b'}}| {1, 2, 3, 4} }};
    
    auto search = example.find(2);
    if(search != example.end()) {
        std::cout &lt;&lt; &quot;Found &quot; &lt;&lt; {{cpp/container/if map| {{{1|set}}}| search-&gt;first &lt;&lt; &quot; &quot; &lt;&lt; search-&gt;second| (*search)}} &lt;&lt; '\n';
    }
    else {
        std::cout &lt;&lt; &quot;Not found\n&quot;;
    }
}
|output=
{{cpp/container/if map| {{{1|set}}}| Found 2 b| Found 2}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc count |{{{1|}}}}}
{{dsc inc | cpp/container/dsc equal_range |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>izlh19a5usmik83p6u2any94x5hv28p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/example empty</title>
    <ns>10</ns>
    <id>10034</id>
    <revision>
      <id>65139</id>
      <parentid>47713</parentid>
      <timestamp>2013-08-30T21:57:07Z</timestamp>
      <contributor>
        <ip>98.159.213.242</ip>
      </contributor>
      <comment>forward list doesn't have push_back</comment>
      <text xml:space="preserve" bytes="532">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::forward_list&lt;int&gt;}} contains any elements:
 | code=
#include &lt;forward_list&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::forward_list&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.push_front(42);
    numbers.push_front(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/example operator=</title>
    <ns>10</ns>
    <id>12823</id>
    <revision>
      <id>63230</id>
      <timestamp>2013-07-06T11:57:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1281">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::forward_list}} to another:
 | code=
#include &lt;forward_list&gt;
#include &lt;iostream&gt;

void display_sizes(const std::forward_list&lt;int&gt; &amp;nums1,
                   const std::forward_list&lt;int&gt; &amp;nums2,
                   const std::forward_list&lt;int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; std::distance(nums1.begin(), nums1.end()) 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; std::distance(nums2.begin(), nums2.end())
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; std::distance(nums3.begin(), nums3.end()) &lt;&lt; '\n';
}

int main()
{
    std::forward_list&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::forward_list&lt;int&gt; nums2; 
    std::forward_list&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/navbar</title>
    <ns>10</ns>
    <id>1083</id>
    <revision>
      <id>39873</id>
      <parentid>35563</parentid>
      <timestamp>2012-09-28T19:57:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="267">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/forward_list/navbar heading
|content3 = cpp/container/forward_list/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/navbar content</title>
    <ns>10</ns>
    <id>1084</id>
    <revision>
      <id>52474</id>
      <parentid>35564</parentid>
      <timestamp>2013-06-01T04:47:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1617">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/forward_list/forward_list }}
{{nv mem ln | cpp/container/forward_list/~forward_list }}
{{nv mem ln | cpp/container/forward_list/operator{{=}} }}
{{nv mem ln | cpp/container/forward_list/assign }}
{{nv mem ln | cpp/container/forward_list/get_allocator }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/forward_list/front }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/forward_list/before_begin | before_begin | cbefore_begin}}
{{nv mem ln | cpp/container/forward_list/begin | begin | cbegin}}
{{nv mem ln | cpp/container/forward_list/end | end | cend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/forward_list/empty}}
{{nv mem ln | cpp/container/forward_list/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/forward_list/clear}}
{{nv mem ln | cpp/container/forward_list/insert_after}}
{{nv mem ln | cpp/container/forward_list/emplace_after}}
{{nv mem ln | cpp/container/forward_list/erase_after}}
{{nv mem ln | cpp/container/forward_list/push_front}}
{{nv mem ln | cpp/container/forward_list/emplace_front}}
{{nv mem ln | cpp/container/forward_list/pop_front}}
{{nv mem ln | cpp/container/forward_list/resize}}
{{nv mem ln | cpp/container/forward_list/swap}}
{{nv h2 | Operations}}
{{nv mem ln | cpp/container/forward_list/merge}}
{{nv mem ln | cpp/container/forward_list/splice_after}}
{{nv mem ln | cpp/container/forward_list/remove | remove | remove_if}}
{{nv mem ln | cpp/container/forward_list/reverse}}
{{nv mem ln | cpp/container/forward_list/unique}}
{{nv mem ln | cpp/container/forward_list/sort}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/navbar heading</title>
    <ns>10</ns>
    <id>1085</id>
    <revision>
      <id>34972</id>
      <parentid>2171</parentid>
      <timestamp>2012-06-15T22:15:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/forward list/sidebar heading]] to [[Template:cpp/container/forward list/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="54">{{ltt|cpp/container/forward_list | std::forward_list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/forward list/title</title>
    <ns>10</ns>
    <id>1086</id>
    <revision>
      <id>2173</id>
      <parentid>2172</parentid>
      <timestamp>2011-06-06T22:52:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=forward_list::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/front</title>
    <ns>10</ns>
    <id>1087</id>
    <revision>
      <id>68720</id>
      <parentid>68708</parentid>
      <timestamp>2014-03-20T02:40:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>this is only constexpr for arrays.</comment>
      <text xml:space="preserve" bytes="1303">{{cpp/container/{{{1|}}}/title | front}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
reference front();
}}
{{#ifeq:{{{1}}}|array|
{{dcl rev begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 |
const_reference front() const;
}}
{{dcl | since=c++14 |
constexpr const_reference front() const;
}}
{{dcl rev end}}
|{{dcl | since={{cpp/std|{{{1|}}}}}|
const_reference front() const;
}}
}}
{{dcl end}}

Returns a reference to the first element in the container. 

Calling {{tt|front}} on an empty container is undefined.

===Parameters===
(none)

===Return value===
reference to the first element

===Complexity===
Constant

===Notes===
For a container {{tt|c}}, the expression {{c|c.front()}} is equivalent to {{c|*c.begin()}}.

===Example===
{{example
 | The following code uses {{tt|front}} to display the first element of a {{c|std::{{{1}}}&lt;char&gt;}}:
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::{{{1}}}&lt;char&gt; letters {'o', 'm', 'g', 'w', 't', 'f'};
 
    if (!letters.empty()) {
        std::cout &lt;&lt; &quot;The first character is: &quot; &lt;&lt; letters.front() &lt;&lt; '\n';
    }  
}
 | output=
The first character is o
}}

{{#ifeq: {{{1|}}} | forward_list ||
===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc back |{{{1|}}}}}
{{dsc end}}
}}</text>
      <sha1>9y4puf7tjxdnhpd5gxhq80p1pesg44e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/get allocator</title>
    <ns>10</ns>
    <id>1088</id>
    <revision>
      <id>62195</id>
      <parentid>35207</parentid>
      <timestamp>2013-06-25T12:03:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="339">{{cpp/container/{{{1|}}}/title | get_allocator}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
allocator_type get_allocator() const;
}}
{{dcl end}}

Returns the allocator associated with the container.

===Parameters===
(none)

===Return value===
The associated allocator.

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/get types</title>
    <ns>10</ns>
    <id>8824</id>
    <revision>
      <id>47743</id>
      <parentid>37226</parentid>
      <timestamp>2013-05-16T20:16:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dynarray</comment>
      <text xml:space="preserve" bytes="978">{{#vardefine:types|{{#switch:{{{1|}}}
 |array=class T, std::size_t N
 |dynarray=class T
 |vector|deque|list|forward_list=class T, class Alloc
 |set|multiset=class Key, class Compare, class Alloc
 |map|multimap=class Key, class T, class Compare, class Alloc
 |unordered_set|unordered_multiset=class Key, class Hash, class KeyEqual, class Alloc
 |unordered_map|unordered_multimap=class Key, class T, class Hash, class KeyEqual, class Alloc
 |stack|queue=class T, class Container
 |priority_queue=class T, class Container, class Compare
 |...
}}}}{{#vardefine:types_short|{{#switch:{{{1|}}}
 |array=T,N
 |dynarray=T
 |vector|deque|list|forward_list=T,Alloc
 |set|multiset=Key,Compare,Alloc
 |map|multimap=Key,T,Compare,Alloc
 |unordered_set|unordered_multiset=Key,Hash,KeyEqual,Alloc
 |unordered_map|unordered_multimap=Key,T,Hash,KeyEqual,Alloc
 |stack|queue=T,Container
 |priority_queue=T,Container,Compare
 |...
}}}}&lt;noinclude&gt;{{documentation|Template:get_types/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/hash function</title>
    <ns>10</ns>
    <id>1089</id>
    <revision>
      <id>62196</id>
      <parentid>60822</parentid>
      <timestamp>2013-06-25T12:04:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="390">{{cpp/container/{{{1|}}}/title | hash_function}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
hasher hash_function() const;
}}
{{dcl end}}

Returns the function that hashes the keys.

===Parameters===
(none)

===Return value===
The hash function.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc key_eq |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if ad</title>
    <ns>10</ns>
    <id>1090</id>
    <revision>
      <id>10956</id>
      <parentid>2181</parentid>
      <timestamp>2011-09-24T10:57:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>include the content correctly</comment>
      <text xml:space="preserve" bytes="160">{{#switch: {{{1|}}}
 | stack | queue | priority_queue = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc }}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if assoc</title>
    <ns>10</ns>
    <id>1091</id>
    <revision>
      <id>2183</id>
      <parentid>2182</parentid>
      <timestamp>2011-06-06T22:52:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="196">{{#switch: {{{1|}}}
 | set | multiset | map | multimap | unordered_set | unordered_multiset | unordered_map | unordered_multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if assoc/doc</title>
    <ns>10</ns>
    <id>1092</id>
    <revision>
      <id>64763</id>
      <parentid>2185</parentid>
      <timestamp>2013-08-26T23:40:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+if c++11</comment>
      <text xml:space="preserve" bytes="2699">This is one of the group of the templates used to categorize containers. 

{{tl|cpp/container/if seq| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|array}}, {{tt|vector}}, {{tt|deque}}, {{tt|list}}, {{tt|forward_list}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if assoc| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|set}}, {{tt|multiset}}, {{tt|map}}, {{tt|multimap}}, {{tt|unordered_set}}, {{tt|unordered_multiset}}, {{tt|unordered_map}} and {{tt|unordered_multimap}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if ord| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|set}}, {{tt|multiset}}, {{tt|map}} and {{tt|multimap}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if unord| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|unordered_set}}, {{tt|unordered_multiset}}, {{tt|unordered_map}} and {{tt|unordered_multimap}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if uniq| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|set}}, {{tt|map}}, {{tt|unordered_set}} and {{tt|unordered_map}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if eq| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|multiset}}, {{tt|multimap}}, {{tt|unordered_multiset}} and {{tt|unordered_multimap}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if set| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|set}}, {{tt|multiset}}, {{tt|unordered_set}} and {{tt|unordered_multiset}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if map| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|map}}, {{tt|multimap}}, {{tt|unordered_map}} and {{tt|unordered_multimap}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if ad| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|stack}}, {{tt|queue}} and {{tt|priority_queue}}. ''if_false'' is returned otherwise, if present.

{{tl|cpp/container/if c++11| ''container'' | ''if_true'' | ''it_false''}} - results in ''if_true'' if ''container'' is one of {{tt|array}}, {{tt|unordered_set}}, {{tt|unordered_multiset}}, {{tt|unordered_map}} and {{tt|unordered_multimap}}. ''if_false'' is returned otherwise, if present.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if c++11</title>
    <ns>10</ns>
    <id>12918</id>
    <revision>
      <id>64762</id>
      <timestamp>2013-08-26T23:39:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="208">{{#switch: {{{1|}}}
 | array | unordered_set | unordered_multiset | unordered_map | unordered_multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if eq</title>
    <ns>10</ns>
    <id>1093</id>
    <revision>
      <id>2187</id>
      <parentid>2186</parentid>
      <timestamp>2011-06-06T22:52:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="190">{{#switch: {{{1|}}}
 | multiset | multimap | unordered_multiset | unordered_multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if map</title>
    <ns>10</ns>
    <id>1094</id>
    <revision>
      <id>2189</id>
      <parentid>2188</parentid>
      <timestamp>2011-06-06T22:52:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="180">{{#switch: {{{1|}}}
 | map | multimap | unordered_map | unordered_multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if ord</title>
    <ns>10</ns>
    <id>1095</id>
    <revision>
      <id>2191</id>
      <parentid>2190</parentid>
      <timestamp>2011-06-06T22:52:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="160">{{#switch: {{{1|}}}
 | set | multiset | map | multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if seq</title>
    <ns>10</ns>
    <id>1096</id>
    <revision>
      <id>2193</id>
      <parentid>2192</parentid>
      <timestamp>2011-06-06T22:52:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="173">{{#switch: {{{1|}}}
 | array | vector | deque | forward_list | list = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if set</title>
    <ns>10</ns>
    <id>1097</id>
    <revision>
      <id>2195</id>
      <parentid>2194</parentid>
      <timestamp>2011-06-06T22:52:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="180">{{#switch: {{{1|}}}
 | set | multiset | unordered_set | unordered_multiset = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if uniq</title>
    <ns>10</ns>
    <id>1098</id>
    <revision>
      <id>2197</id>
      <parentid>2196</parentid>
      <timestamp>2011-06-06T22:52:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="171">{{#switch: {{{1|}}}
 | set | map | unordered_set | unordered_map = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}} 
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/if unord</title>
    <ns>10</ns>
    <id>1099</id>
    <revision>
      <id>2199</id>
      <parentid>2198</parentid>
      <timestamp>2011-06-06T22:52:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="200">{{#switch: {{{1|}}}
 | unordered_set | unordered_multiset | unordered_map | unordered_multimap = {{{2|}}}
 | {{{3|}}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/if assoc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/insert</title>
    <ns>10</ns>
    <id>1100</id>
    <revision>
      <id>69732</id>
      <parentid>69729</parentid>
      <timestamp>2014-04-21T21:05:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="5277">{{cpp/container/{{{1|}}}/title | insert}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin | num=1}}
{{dcl | until=c++11 |
iterator insert( iterator pos, const T&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator pos, const T&amp; value );
}}
{{dcl rev end}}
{{dcl | num=2 | since=c++11 |
iterator insert( const_iterator pos, T&amp;&amp; value );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
void insert( iterator pos, size_type count, const T&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator pos, size_type count, const T&amp; value );
}}
{{dcl rev end}}
{{dcl rev begin | num=4}}
{{dcl | until=c++11 |
template&lt; class InputIt &gt;
void insert( iterator pos, InputIt first, InputIt last);
}}
{{dcl | since=c++11 |
template&lt; class InputIt &gt;
iterator insert( const_iterator pos, InputIt first, InputIt last );
}}
{{dcl rev end}}
{{dcl | num=5 | since=c++11 |
iterator insert( const_iterator pos, std::initializer_list&lt;T&gt; ilist );
}}
{{dcl end}}

Inserts elements at specified location in the container.

@1-2@ inserts {{tt|value}} before the location pointed to by {{tt|pos}}

@3@ inserts {{tt|count}} copies of the {{tt|value}} before the location pointed to by {{tt|pos}}

@4@ inserts elements from range {{tt|[first, last)}} before the location pointed to by {{tt|pos}}. {{rev inl|since=c++11|This overload does not participate in overload resolution if {{tt|InputIt}} does not satisfy {{concept|InputIterator}}.}} The behavior is undefined if {{tt|first}} and {{tt|last}} are iterators into {{c|*this}}. 

@5@ inserts elements from initializer list {{tt|ilist}}.

{{#ifeq:{{{1|}}}|vector|Causes reallocation if the new {{lc|size()}} is greater than the old {{lc|capacity()}}.&amp;#32;

}}{{cpp/container/note_iterator_invalidation|{{{1|}}}|insert}}

===Parameters===
{{par begin}}
{{par | pos | iterator to the location before which the content will be inserted. {{tt|pos}} may be the {{lc|end()}} iterator}}
{{par | value | element value to insert}}
{{par | first, last | the range of elements to insert, can't be iterators into container for which insert is called}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
@1-2@ Iterator pointing to the inserted {{tt|value}}

@3@ Iterator pointing to the first element inserted, or {{tt|pos}} if {{c|1=count==0}}.

@4@ Iterator pointing to the first element inserted, or {{tt|pos}} if {{c|1=first==last}}.

@5@ Iterator pointing to the first element inserted, or {{tt|pos}} if {{tt|ilist}} is empty.

===Complexity===
{{#switch:{{{1|}}}
|list=
@1-2@ Constant.

@3@ Linear in {{c|count}}

@4@ Linear in {{c|std::distance(first, last)}}

@5@ Linear in {{c|ilist.size()}}
|deque=
@1-2@ Constant plus linear in the lesser of the distances between {{tt|pos}} and either of the ends of the container.

@3@ Linear in {{c|count}}  plus linear in the lesser of the distances between {{tt|pos}} and either of the ends of the container.

@4@ Linear in {{c|std::distance(first, last)}} plus linear in the lesser of the distances between {{tt|pos}} and either of the ends of the container.

@5@ Linear in {{c|ilist.size()}} plus linear in the lesser of the distances between {{tt|pos}} and either of the ends of the container.
|vector=
@1-2@ Constant plus linear in the distance between {{tt|pos}} and end of the container.

@3@ Linear in {{c|count}} plus linear in the distance between {{tt|pos}} and end of the container.

@4@ Linear in {{c|std::distance(first, last)}} plus linear in the distance between {{tt|pos}} and end of the container.

@5@ Linear in {{c|ilist.size()}} plus linear in the distance between {{tt|pos}} and end of the container.
| {{included}}
}}
{{#switch:{{{1|}}}
|deque=
===Exceptions===
If an exception is thrown when inserting a single element at either end, this function has no effect (strong exception guarantee).
|vector=
===Exceptions===
If an exception is thrown when inserting a single element at the end, and T is {{concept|CopyInsertable}} or {{lc|std::is_nothrow_move_constructible&lt;T&gt;::value}} is {{lc|true}}, there are no effects (strong exception guarantee).
}}
{{#switch:{{{1|}}}
|vector=
===Example===
{{example
|code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

void print_vec(const std::vector&lt;int&gt;&amp; vec)
{
    for (auto x: vec) {
         std::cout &lt;&lt; ' ' &lt;&lt; x;
    }
    std::cout &lt;&lt; '\n';
}

int main ()
{
    std::vector&lt;int&gt; vec(3,100);
    print_vec(vec);

    auto it = vec.begin();
    it = vec.insert(it, 200);
    print_vec(vec);

    vec.insert(it,2,300);
    print_vec(vec);

    // &quot;it&quot; no longer valid, get a new one:
    it = vec.begin();

    std::vector&lt;int&gt; vec2(2,400);
    vec.insert(it+2, vec2.begin(), vec2.end());
    print_vec(vec);

    int arr[] = { 501,502,503 };
    vec.insert(vec.begin(), arr, arr+3);
    print_vec(vec);
}
|output=
100 100 100
200 100 100 100
300 300 200 100 100 100
300 300 400 400 200 100 100 100
501 502 503 300 300 400 400 200 100 100 100
}}
}}
===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |{{{1|}}}}}
{{#ifeq: {{{1|}}} | vector | | {{dsc inc | cpp/container/dsc push_front |{{{1|}}}}} }}
{{#ifeq: {{{1|}}} | forward_list | | {{dsc inc | cpp/container/dsc push_back |{{{1|}}}}} }}
{{dsc end}}</text>
      <sha1>k37wnxiy2z5fy47evtt8t5fniy63kv8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/insert assoc</title>
    <ns>10</ns>
    <id>1101</id>
    <revision>
      <id>64574</id>
      <parentid>64397</parentid>
      <timestamp>2013-08-20T21:17:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="4623">{{cpp/container/{{{1|}}}/title | insert}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
{{cpp/container/if uniq | {{{1|}}}
 |std::pair&lt;iterator,bool&gt; insert( const value_type&amp; value );
 |iterator insert( const value_type&amp; value );
}}
}}
{{dcl | num=2 | since=c++11 |
{{#switch: {{{1|}}}
 | set | unordered_set =
std::pair&lt;iterator,bool&gt; insert( value_type&amp;&amp; value );
 | multiset | unordered_multiset =
iterator insert( value_type&amp;&amp; value );
 | map | unordered_map =
template&lt; class P &gt;
std::pair&lt;iterator,bool&gt; insert( P&amp;&amp; value );
 | multimap | unordered_multimap=
template&lt; class P &gt;
iterator insert( P&amp;&amp; value );
}}
}}
{{cpp/container/if unord | {{{1|}}} |
{{dcl | num=3 | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
|
{{dcl rev begin | num=3}}
{{dcl | until=c++11 |
iterator insert( iterator hint, const value_type&amp; value );
}}
{{dcl | since=c++11 |
iterator insert( const_iterator hint, const value_type&amp; value );
}}
{{dcl rev end}}
}}
{{dcl | num=4 | since=c++11 |
{{#switch: {{{1|}}}
 | set | unordered_set | multiset | unordered_multiset =
iterator insert( const_iterator hint, value_type&amp;&amp; value );
 | map | unordered_map | multimap | unordered_multimap =
template&lt; class P &gt;
iterator insert( const_iterator hint, P&amp;&amp; value );
}}
}}
{{dcl | num=5 | since={{cpp/std|{{{1|}}}}} |
template&lt; class InputIt &gt;
void insert( InputIt first, InputIt last );
}}
{{dcl | num=6 | since=c++11 |
void insert( std::initializer_list&lt;value_type&gt; ilist );
}}
{{dcl end}}

{{cpp/container/if uniq | {{{1|}}}
 |Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.
 |Inserts element(s) into the container.
}}

@1-2@ inserts {{tt|value}}. {{cpp/container/if uniq | {{{1|}}} | | {{cpp/container/if ord | {{{1|}}} | If the container has elements with equivalent key, inserts at the upper bound of that range.{{mark since c++11}} }} }} {{cpp/container/if map | {{{1|}}} | The overload 2) is equivalent to {{c|emplace(std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.
}}

{{cpp/container/if ord | {{{1|}}}
| @3-4@ inserts {{tt|value}} in the position as close as possible, just prior{{mark since c++11}}, to {{tt|hint}}. 
| @3-4@ inserts {{tt|value}}, using {{tt|hint}} as a non-binding suggestion to where the search should start.
}} {{cpp/container/if map | {{{1|}}} | The overload 4) is equivalent to {{c|emplace_hint(hint, std::forward&lt;P&gt;(value))}} and only participates in overload resolution if {{c|std::is_constructible&lt;value_type, P&amp;&amp;&gt;::value {{==}} true}}.
}}

@5@ inserts elements from range {{tt|[first, last)}}.

@6@ inserts elements from initializer list {{tt|ilist}}.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|insert}}
===Parameters===
{{par begin}}
{{par | hint | iterator, used as a suggestion as to where to insert the content}}
{{par | value | element value to insert}}
{{par | first, last | range of elements to insert}}
{{par | ilist | initializer list to insert the values from}}
{{par hreq}}
{{par req concept | InputIt | InputIterator}}
{{par end}} 

===Return value===
{{cpp/container/if uniq | {{{1|}}}
 |@1-2@ Returns a pair consisting of an iterator to the inserted element (or to the element that prevented the insertion) and a {{c|bool}} denoting whether the insertion took place.

@3-4@ Returns an iterator to the inserted element, or to the element that prevented the insertion.
 |@1-4@ Returns an iterator to the inserted element.
}}

@5-6@ (none)

===Exceptions===
@1-4@ If an exception is thrown by any operation, the insertion has no effect.

{{todo|cases 5-6}}

===Complexity===

{{cpp/container/if unord | {{{1|}}}
| @1-4@ Average case: {{tt|O(1)}}, worst case {{tt|O(size())}}

@5-6@ Average case: {{tt|O(N)}}, where N is the number of elements to insert. Worse case: {{tt|O(N*size()+N)}}
| @1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}.

{{rev begin}}
{{rev | until=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''after'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev | since=c++11 |
@3-4@ Amortized constant if the insertion happens in the position just ''before'' the hint, logarithmic in the size of the container otherwise.
}}
{{rev end}}

@5-6@ {{tt|O(N*log(size() + N))}}, where N is the number of elements to insert.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace |{{{1|}}}}}
{{dsc inc | cpp/container/dsc emplace_hint |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/key comp</title>
    <ns>10</ns>
    <id>1102</id>
    <revision>
      <id>67371</id>
      <parentid>67370</parentid>
      <timestamp>2014-02-06T15:22:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix link to ctor</comment>
      <text xml:space="preserve" bytes="772">{{cpp/container/{{{1|}}}/title | key_comp}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
key_compare key_comp() const;
}}
{{dcl end}}

{{cpp/container/if map | {{{1|}}}
 |Returns the function object that compares the keys, which is a copy of this container's [[cpp/container/{{{1|}}}/{{{1|}}}|constructor]] argument {{tt|comp}}.
 |Returns the function object that compares the keys, which is a copy of this container's [[cpp/container/{{{1|}}}/{{{1|}}}|constructor]] argument {{tt|comp}}. It is the same as {{lc|value_comp}}.
}}

===Parameters===
(none)

===Return value===
The key comparison function object.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc value_comp |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>0zw14j8ujbdc5yqf7ag6wg8pizxell4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/key eq</title>
    <ns>10</ns>
    <id>1103</id>
    <revision>
      <id>62198</id>
      <parentid>60826</parentid>
      <timestamp>2013-06-25T12:05:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="422">{{cpp/container/{{{1|}}}/title | key_eq}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
key_equal key_eq() const;
}}
{{dcl end}}

Returns the function that compares keys for equality.

===Parameters===
(none)

===Return value===
The key comparison function.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc hash_function |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/example empty</title>
    <ns>10</ns>
    <id>10035</id>
    <revision>
      <id>47714</id>
      <timestamp>2013-05-16T19:20:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="506">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::list&lt;int&gt;}} contains any elements:
 | code=
#include &lt;list&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::list&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.push_back(42);
    numbers.push_back(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/example operator=</title>
    <ns>10</ns>
    <id>12825</id>
    <revision>
      <id>63232</id>
      <timestamp>2013-07-06T11:58:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1130">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::list}} to another:
 | code=
#include &lt;list&gt;
#include &lt;iostream&gt;

void display_sizes(const std::list&lt;int&gt;&amp; nums1,
                   const std::list&lt;int&gt;&amp; nums2,
                   const std::list&lt;int&gt;&amp; nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::list&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::list&lt;int&gt; nums2; 
    std::list&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/example size</title>
    <ns>10</ns>
    <id>10045</id>
    <revision>
      <id>52481</id>
      <parentid>47734</parentid>
      <timestamp>2013-06-01T04:47:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="316">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::list}}:
 | code=
#include &lt;list&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::list&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/navbar</title>
    <ns>10</ns>
    <id>1104</id>
    <revision>
      <id>39874</id>
      <parentid>35565</parentid>
      <timestamp>2012-09-28T19:57:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/list/navbar heading
|content3 = cpp/container/list/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/navbar content</title>
    <ns>10</ns>
    <id>1105</id>
    <revision>
      <id>52482</id>
      <parentid>34652</parentid>
      <timestamp>2013-06-01T04:47:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1801">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/list/list }}
{{nv mem ln | cpp/container/list/~list }}
{{nv mem ln | cpp/container/list/operator{{=}} }}
{{nv mem ln | cpp/container/list/assign }}
{{nv mem ln | cpp/container/list/get_allocator }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/list/front }}
{{nv mem ln | cpp/container/list/back }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/list/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/list/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/list/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/list/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/list/empty}}
{{nv mem ln | cpp/container/list/size}}
{{nv mem ln | cpp/container/list/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/list/clear}}
{{nv mem ln | cpp/container/list/insert}}
{{nv mem ln | cpp/container/list/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/list/erase}}
{{nv mem ln | cpp/container/list/push_front}}
{{nv mem ln | cpp/container/list/emplace_front | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/list/pop_front}}
{{nv mem ln | cpp/container/list/push_back}}
{{nv mem ln | cpp/container/list/emplace_back | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/list/pop_back}}
{{nv mem ln | cpp/container/list/resize}}
{{nv mem ln | cpp/container/list/swap}}
{{nv h2 | Operations}}
{{nv mem ln | cpp/container/list/merge}}
{{nv mem ln | cpp/container/list/splice}}
{{nv mem ln | cpp/container/list/remove | remove | remove_if}}
{{nv mem ln | cpp/container/list/reverse}}
{{nv mem ln | cpp/container/list/unique}}
{{nv mem ln | cpp/container/list/sort}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/navbar heading</title>
    <ns>10</ns>
    <id>1106</id>
    <revision>
      <id>35566</id>
      <parentid>2213</parentid>
      <timestamp>2012-06-15T22:28:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/list/sidebar heading]] to [[Template:cpp/container/list/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="38">{{ltt|cpp/container/list | std::list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/list/title</title>
    <ns>10</ns>
    <id>1107</id>
    <revision>
      <id>2215</id>
      <parentid>2214</parentid>
      <timestamp>2011-06-06T22:52:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="101">&lt;onlyinclude&gt;{{cpp/title | n=list::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/load factor</title>
    <ns>10</ns>
    <id>1108</id>
    <revision>
      <id>62199</id>
      <parentid>60827</parentid>
      <timestamp>2013-06-25T12:06:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="437">{{cpp/container/{{{1|}}}/title | load_factor}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
float load_factor() const;
}}
{{dcl end}}

Returns the average number of elements per bucket.

===Parameters===
(none)

===Return value===
Average number of elements per bucket.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc max_load_factor |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/lower bound</title>
    <ns>10</ns>
    <id>1109</id>
    <revision>
      <id>65132</id>
      <parentid>65100</parentid>
      <timestamp>2013-08-30T16:37:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1363">{{cpp/container/{{{1|}}}/title | lower_bound}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |num=1|
iterator lower_bound( const Key&amp; key );
}}
{{dcl |num=1|
const_iterator lower_bound( const Key&amp; key ) const;
}}
{{dcl | num=2 | since=c++14 |
template&lt; class K &gt; 
iterator lower_bound(const K&amp; x);
}}
{{dcl | num=2 | since=c++14 |
template&lt; class K &gt; 
const_iterator lower_bound(const K&amp; x) const;
}}
{{dcl end}}

@1@ Returns an iterator pointing to the first element that is ''not less'' than {{tt|key}}.

@2@ Returns an iterator pointing to the first element that compares ''not less'' to the value {{tt|x}}. These templates only participate in overload resolution if the type {{c|Compare::is_transparent}} exists. They allow calling this function without constructing an instance of {{tt|Key}}.

===Parameters===
{{par begin}}
{{par | key | key value to compare the elements to}}
{{par | x | alternative value that can be compared to {{tt|Key}} }}
{{par end}} 

===Return value===
Iterator pointing to the first element that is not ''less'' than {{tt|key}}. If no such element is found, a past-the-end iterator (see {{lc|end()}}) is returned.

===Complexity===
Logarithmic in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc equal_range |{{{1|}}}}}
{{dsc inc | cpp/container/dsc upper_bound |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/example empty</title>
    <ns>10</ns>
    <id>10036</id>
    <revision>
      <id>69149</id>
      <parentid>47718</parentid>
      <timestamp>2014-03-28T16:55:10Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="551">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::map&lt;int, int&gt;}} contains any elements:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;
 
int main()
{
    std::map&lt;int,int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.emplace(42, 13);
    numbers.insert(std::make_pair(13317, 123)); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1>1o6y4rch3auf8473k5rtk15l4j41r02</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/example operator=</title>
    <ns>10</ns>
    <id>12820</id>
    <revision>
      <id>63227</id>
      <parentid>63226</parentid>
      <timestamp>2013-07-06T11:54:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sp</comment>
      <text xml:space="preserve" bytes="1213">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::map}} to another:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;

void display_sizes(const std::map&lt;int, int&gt; &amp;nums1,
                   const std::map&lt;int, int&gt; &amp;nums2,
                   const std::map&lt;int, int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::map&lt;int, int&gt; nums1 {{3, 1}, {4, 1}, {5, 9}, 
                              {6, 1}, {7, 1}, {8, 9}};
    std::map&lt;int, int&gt; nums2; 
    std::map&lt;int, int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/example size</title>
    <ns>10</ns>
    <id>10048</id>
    <revision>
      <id>52485</id>
      <parentid>47739</parentid>
      <timestamp>2013-06-01T04:47:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="346">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::map}}:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::map&lt;int,char&gt; nums {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/navbar</title>
    <ns>10</ns>
    <id>1110</id>
    <revision>
      <id>39875</id>
      <parentid>35567</parentid>
      <timestamp>2012-09-28T19:57:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/map/navbar heading
|content3 = cpp/container/map/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/navbar content</title>
    <ns>10</ns>
    <id>1111</id>
    <revision>
      <id>52486</id>
      <parentid>35569</parentid>
      <timestamp>2013-06-01T04:47:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1510">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/map/map }}
{{nv mem ln | cpp/container/map/~map }}
{{nv mem ln | cpp/container/map/operator{{=}} }}
{{nv mem ln | cpp/container/map/get_allocator }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/map/at}}
{{nv mem ln | cpp/container/map/operator_at | operator[]}}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/map/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/map/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/map/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/map/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/map/empty}}
{{nv mem ln | cpp/container/map/size}}
{{nv mem ln | cpp/container/map/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/map/clear}}
{{nv mem ln | cpp/container/map/insert}}
{{nv mem ln | cpp/container/map/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/map/emplace_hint | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/map/erase}}
{{nv mem ln | cpp/container/map/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/map/count}}
{{nv mem ln | cpp/container/map/find}}
{{nv mem ln | cpp/container/map/equal_range}}
{{nv mem ln | cpp/container/map/lower_bound}}
{{nv mem ln | cpp/container/map/upper_bound}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/map/key_comp}}
{{nv mem ln | cpp/container/map/value_comp}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/navbar heading</title>
    <ns>10</ns>
    <id>1112</id>
    <revision>
      <id>35570</id>
      <parentid>2225</parentid>
      <timestamp>2012-06-15T22:28:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/map/sidebar heading]] to [[Template:cpp/container/map/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="39">{{tt|[[cpp/container/map | std::map]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/title</title>
    <ns>10</ns>
    <id>1113</id>
    <revision>
      <id>2227</id>
      <parentid>2226</parentid>
      <timestamp>2011-06-06T22:52:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="100">&lt;onlyinclude&gt;{{cpp/title | n=map::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/map/value compare/title</title>
    <ns>10</ns>
    <id>8565</id>
    <revision>
      <id>31726</id>
      <timestamp>2012-06-06T20:44:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="124">&lt;onlyinclude&gt;{{cpp/container/map/title | n=value_compare::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/mark c++11</title>
    <ns>10</ns>
    <id>1114</id>
    <revision>
      <id>5599</id>
      <parentid>5598</parentid>
      <timestamp>2011-08-02T01:34:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/mark c++0x]] to [[Template:cpp/container/mark c++11]]: c++0x -&gt; c++11</comment>
      <text xml:space="preserve" bytes="314">{{#switch:{{{1|}}}
| array =
| vector
| deque
| list = {{mark c++11}}
| forward_list = 
| set
| multiset
| map
| multimap = {{mark c++11}}
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = 
| stack
| queue
| priority_queue = {{mark c++11}}
|  
}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/mark c++11/doc</title>
    <ns>10</ns>
    <id>1115</id>
    <revision>
      <id>18974</id>
      <parentid>18957</parentid>
      <timestamp>2012-02-20T10:38:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;mark c++11 feature&quot; to &quot;mark since c++11&quot;</comment>
      <text xml:space="preserve" bytes="679">This is one of the templates that are used to mark since c++11s according to the container.

{{tl|cpp/container/mark c++11|''container''}} - outputs {{mark c++11}} if the container is ''not'' new in C++11. This is used to omit redundant C++11 mark in containers that are C++11 features themselves.

{{tl|cpp/container/mark since c++11 |''container''}} - outputs {{mark since c++11}} if the container is new in C++11.

===Example===

  
  &lt;nowiki&gt; array: {{cpp/container/mark since c++11 | array}}&lt;br&gt;
  vector: {{cpp/container/mark since c++11 | vector}}&lt;/nowiki&gt;

Output

array: {{cpp/container/mark since c++11 | array}} &lt;br&gt;
vector: {{cpp/container/mark since c++11 | vector}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/mark since c++11</title>
    <ns>10</ns>
    <id>1116</id>
    <revision>
      <id>47679</id>
      <parentid>18944</parentid>
      <timestamp>2013-05-16T18:42:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dynarray</comment>
      <text xml:space="preserve" bytes="444">{{#switch:{{{1|}}}
| array = {{mark since c++11}}
| dynarray = {{mark since c++14}}
| vector
| deque
| list =
| forward_list = {{mark since c++11}}
| set
| multiset
| map
| multimap = 
| unordered_set
| unordered_multiset
| unordered_map
| unordered_multimap = {{mark since c++11}}
| stack
| queue
| priority_queue =
| {{small|(no container - C++11 feature)}}
}}&lt;noinclude&gt;
{{documentation | Template:cpp/container/mark c++11/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/max bucket count</title>
    <ns>10</ns>
    <id>1117</id>
    <revision>
      <id>62203</id>
      <parentid>60829</parentid>
      <timestamp>2013-06-25T12:07:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="506">{{cpp/container/{{{1|}}}/title | max_bucket_count}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type max_bucket_count() const;
}}
{{dcl end}}

Returns the maximum number of buckets the container is able to hold due to system or library implementation limitations.

===Parameters===
(none)

===Return value===
Maximum number of buckets.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc bucket_count |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/max load factor</title>
    <ns>10</ns>
    <id>1118</id>
    <revision>
      <id>63577</id>
      <parentid>60830</parentid>
      <timestamp>2013-07-10T01:44:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="776">{{cpp/container/{{{1|}}}/title | max_load_factor}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
float max_load_factor() const;
}}
{{dcl | num=2 | since=c++11 |
void max_load_factor( float ml );
}}
{{dcl end}}

Manages the maximum load factor (number of elements per bucket). The container automatically increases the number of buckets if the load factor exceeds this threshold.

1) Returns current maximum load factor.

2) Sets the maximum load factor to {{tt|ml}}.

===Parameters===
{{par begin}}
{{par | ml | new maximum load factor setting}}
{{par end}}

===Return value===

1) current maximum load factor.

2) none.

===Complexity===
Constant

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc load_factor |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/max size</title>
    <ns>10</ns>
    <id>1119</id>
    <revision>
      <id>64780</id>
      <parentid>64686</parentid>
      <timestamp>2013-08-27T00:09:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix noexcept</comment>
      <text xml:space="preserve" bytes="1209">{{cpp/container/{{{1|}}}/title | max_size}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{#ifeq:{{{1|}}}|array
|
{{dcl rev begin}}
{{dcl | since=c++11 | until=c++14 |
constexpr size_type max_size();
}}
{{dcl | since=c++14 |
constexpr size_type max_size() const;
}}
{{dcl rev end}}
|
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type max_size() const;
}}
}}
{{dcl end}}

Returns the maximum number of elements the container is able to hold due to system or library implementation limitations, i.e. {{c|std::distance(begin(), end())}} for the largest container.

===Parameters===
(none)

===Return value===
Maximum number of elements.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===Notes===
This value is typically equal to {{c|std::numeric_limits&lt;size_type&gt;::max()}}, and reflects the theoretical limit on the size of the container. At runtime, the size of the container may be limited to a value smaller than {{tt|max_size()}} by the amount of RAM available.

{{#ifeq: {{{1|}}} | forward_list||
===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc size |{{{1|}}} }}
{{#ifeq: {{{1|}}} | vector | {{dsc inc | cpp/container/dsc capacity |{{{1|}}}}} }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/merge</title>
    <ns>10</ns>
    <id>1120</id>
    <revision>
      <id>68833</id>
      <parentid>67360</parentid>
      <timestamp>2014-03-22T16:35:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>forward_list.merge() has strong exception guarantee</comment>
      <text xml:space="preserve" bytes="2554">{{cpp/container/{{{1|}}}/title | merge}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
void merge( {{{1}}}&amp; other );
}}
{{dcl | num=1 | since=c++11 |
void merge( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
template &lt;class Compare&gt; 
void merge( {{{1}}}&amp; other, Compare comp );
}}
{{dcl | num=2 | since=c++11 |
template &lt;class Compare&gt; 
void merge( {{{1}}}&amp;&amp; other, Compare comp );
}}
{{dcl end}}

Merges two sorted lists into one. The lists should be sorted into ascending order. 

No elements are copied. The container {{tt|other}} becomes empty after the operation. The function does nothing if {{c|this {{==}} &amp;other}}. If {{c|get_allocator() !{{=}} other.get_allocator()}}, the behavior is undefined. No iterators or references become invalidated, except that the iterators of moved elements now refer into {{c|*this}}, not into {{tt|other}}. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

This operation is stable: for equivalent elements in the two lists, the elements from {{tt|*this}} shall always precede the elements from {{tt|other}}, and the order of equivalent elements of {{tt|*this}} and {{tt|other}} does not change.

===Parameters===
{{par begin}}
{{par | other | another container to merge}}
{{par cmp ord | comp | p1={{{1}}}&lt;T,Allocator&gt;::const_iterator }} 
{{par end}} 

===Return value===
(none)
{{#ifeq: {{{1|}}} | forward_list |

===Exceptions===
If an exception is thrown, this function has no effect (strong exception guarantee), except if the exception comes from the comparison function.

}}
===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;{{{1}}}&gt;
 
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; ostr, const std::{{{1}}}&lt;int&gt;&amp; list)
{
    for (auto &amp;i : list) {
        ostr &lt;&lt; &quot; &quot; &lt;&lt; i;
    }
    return ostr;
}
 
int main()
{
    std::{{{1}}}&lt;int&gt; list1 = { 5,9,0,1,3 };
    std::{{{1}}}&lt;int&gt; list2 = { 8,7,2,6,4 };
 
    list1.sort();
    list2.sort();
    std::cout &lt;&lt; &quot;list1:  &quot; &lt;&lt; list1 &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; &quot;list2:  &quot; &lt;&lt; list2 &lt;&lt; &quot;\n&quot;;
    list1.merge(list2);
    std::cout &lt;&lt; &quot;merged: &quot; &lt;&lt; list1 &lt;&lt; &quot;\n&quot;;
}
 | output=
list1:   0 1 3 5 9
list2:   2 4 6 7 8
merged:  0 1 2 3 4 5 6 7 8 9
}}

===Complexity===
at most {{c|size() + other.size() - 1}} comparisons.

===See also===
{{dsc begin}}
{{#switch: {{{1|}}}
 | list={{dsc inc | cpp/container/dsc splice |{{{1|}}}}}
 | forward_list={{dsc inc | cpp/container/dsc splice_after |{{{1|}}}}}
}}
{{dsc end}}</text>
      <sha1>f12y7pk5emlqsuqrxkx5hjnzr9u67hi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/example empty</title>
    <ns>10</ns>
    <id>10037</id>
    <revision>
      <id>69151</id>
      <parentid>47719</parentid>
      <timestamp>2014-03-28T17:02:49Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <text xml:space="preserve" bytes="563">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::multimap&lt;int, int&gt;}} contains any elements:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;
 
int main()
{
    std::multimap&lt;int, int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.emplace(42, 13);
    numbers.insert(std::make_pair(13317, 123));  
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1>rn0sdvolrsx168fl5scdsqp2e1bejuq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/example operator=</title>
    <ns>10</ns>
    <id>12819</id>
    <revision>
      <id>63225</id>
      <timestamp>2013-07-06T11:54:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1253">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::multimap}} to another:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;

void display_sizes(const std::multimap&lt;int, int&gt; &amp;nums1,
                   const std::multimap&lt;int, int&gt; &amp;nums2,
                   const std::multimap&lt;int, int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::multimap&lt;int, int&gt; nums1 {{3, 1}, {4, 1}, {5, 9}, 
                                   {6, 1}, {7, 1}, {8, 9}};
    std::multimap&lt;int, int&gt; nums2; 
    std::multimap&lt;int, int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/example size</title>
    <ns>10</ns>
    <id>10047</id>
    <revision>
      <id>52491</id>
      <parentid>47738</parentid>
      <timestamp>2013-06-01T04:47:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="356">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::multimap}}:
 | code=
#include &lt;map&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::multimap&lt;int,char&gt; nums {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/navbar</title>
    <ns>10</ns>
    <id>1121</id>
    <revision>
      <id>39876</id>
      <parentid>35572</parentid>
      <timestamp>2012-09-28T19:57:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="259">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/multimap/navbar heading
|content3 = cpp/container/multimap/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/navbar content</title>
    <ns>10</ns>
    <id>1122</id>
    <revision>
      <id>52492</id>
      <parentid>35573</parentid>
      <timestamp>2013-06-01T04:47:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1517">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/multimap/multimap }}
{{nv mem ln | cpp/container/multimap/~multimap }}
{{nv mem ln | cpp/container/multimap/operator{{=}} }}
{{nv mem ln | cpp/container/multimap/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/multimap/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multimap/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multimap/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multimap/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/multimap/erase}}
{{nv mem ln | cpp/container/multimap/size}}
{{nv mem ln | cpp/container/multimap/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/multimap/clear}}
{{nv mem ln | cpp/container/multimap/insert}}
{{nv mem ln | cpp/container/multimap/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/multimap/emplace_hint | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/multimap/erase}}
{{nv mem ln | cpp/container/multimap/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/multimap/count}}
{{nv mem ln | cpp/container/multimap/find}}
{{nv mem ln | cpp/container/multimap/equal_range}}
{{nv mem ln | cpp/container/multimap/lower_bound}}
{{nv mem ln | cpp/container/multimap/upper_bound}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/multimap/key_comp}}
{{nv mem ln | cpp/container/multimap/value_comp}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/navbar heading</title>
    <ns>10</ns>
    <id>1123</id>
    <revision>
      <id>35574</id>
      <parentid>2247</parentid>
      <timestamp>2012-06-15T22:28:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/multimap/sidebar heading]] to [[Template:cpp/container/multimap/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/container/multimap | std::multimap}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/title</title>
    <ns>10</ns>
    <id>1124</id>
    <revision>
      <id>2249</id>
      <parentid>2248</parentid>
      <timestamp>2011-06-06T22:52:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=multimap::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multimap/value compare/title</title>
    <ns>10</ns>
    <id>8562</id>
    <revision>
      <id>31723</id>
      <timestamp>2012-06-06T20:44:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="129">&lt;onlyinclude&gt;{{cpp/container/multimap/title | n=value_compare::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/example empty</title>
    <ns>10</ns>
    <id>10038</id>
    <revision>
      <id>47717</id>
      <timestamp>2013-05-16T19:20:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="507">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::multiset&lt;int&gt;}} contains any elements:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::multiset&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.insert(42);
    numbers.insert(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/example operator=</title>
    <ns>10</ns>
    <id>12818</id>
    <revision>
      <id>63224</id>
      <timestamp>2013-07-06T11:52:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1157">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::multiset}} to another:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;

void display_sizes(const std::multiset&lt;int&gt; &amp;nums1,
                   const std::multiset&lt;int&gt; &amp;nums2,
                   const std::multiset&lt;int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::multiset&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::multiset&lt;int&gt; nums2; 
    std::multiset&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/example size</title>
    <ns>10</ns>
    <id>10046</id>
    <revision>
      <id>52493</id>
      <parentid>47737</parentid>
      <timestamp>2013-06-01T04:47:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="323">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::multiset}}:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::multiset&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/navbar</title>
    <ns>10</ns>
    <id>1125</id>
    <revision>
      <id>39877</id>
      <parentid>35575</parentid>
      <timestamp>2012-09-28T19:57:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="259">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/multiset/navbar heading
|content3 = cpp/container/multiset/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/navbar content</title>
    <ns>10</ns>
    <id>1126</id>
    <revision>
      <id>52494</id>
      <parentid>33308</parentid>
      <timestamp>2013-06-01T04:47:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1517">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/multiset/multiset }}
{{nv mem ln | cpp/container/multiset/~multiset }}
{{nv mem ln | cpp/container/multiset/operator{{=}} }}
{{nv mem ln | cpp/container/multiset/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/multiset/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multiset/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multiset/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/multiset/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/multiset/empty}}
{{nv mem ln | cpp/container/multiset/size}}
{{nv mem ln | cpp/container/multiset/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/multiset/clear}}
{{nv mem ln | cpp/container/multiset/insert}}
{{nv mem ln | cpp/container/multiset/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/multiset/emplace_hint | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/multiset/erase}}
{{nv mem ln | cpp/container/multiset/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/multiset/count}}
{{nv mem ln | cpp/container/multiset/find}}
{{nv mem ln | cpp/container/multiset/equal_range}}
{{nv mem ln | cpp/container/multiset/lower_bound}}
{{nv mem ln | cpp/container/multiset/upper_bound}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/multiset/key_comp}}
{{nv mem ln | cpp/container/multiset/value_comp}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/navbar heading</title>
    <ns>10</ns>
    <id>1127</id>
    <revision>
      <id>35576</id>
      <parentid>2255</parentid>
      <timestamp>2012-06-15T22:28:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/multiset/sidebar heading]] to [[Template:cpp/container/multiset/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/container/multiset | std::multiset}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/multiset/title</title>
    <ns>10</ns>
    <id>1128</id>
    <revision>
      <id>2257</id>
      <parentid>2256</parentid>
      <timestamp>2011-06-06T22:52:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=multiset::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/navbar</title>
    <ns>10</ns>
    <id>1161</id>
    <revision>
      <id>61572</id>
      <parentid>39878</parentid>
      <timestamp>2013-06-06T04:31:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="156">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/navbar content</title>
    <ns>10</ns>
    <id>1162</id>
    <revision>
      <id>65911</id>
      <parentid>52495</parentid>
      <timestamp>2013-10-15T04:19:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no dynarray in n3797</comment>
      <text xml:space="preserve" bytes="739">{{nv begin}}
{{nv ln | cpp/container/array | notes={{mark c++11}} }}
{{nv ln | cpp/container/vector}}
{{nv ln | cpp/container/deque}}
{{nv ln | cpp/container/forward_list | notes={{mark c++11}} }}
{{nv ln | cpp/container/list}}
{{nv ln | cpp/container/set}}
{{nv ln | cpp/container/multiset}}
{{nv ln | cpp/container/map}}
{{nv ln | cpp/container/multimap}}
{{nv ln | cpp/container/unordered_set | notes={{mark c++11}} }}
{{nv ln | cpp/container/unordered_multiset | notes={{mark c++11}} }}
{{nv ln | cpp/container/unordered_map | notes={{mark c++11}} }}
{{nv ln | cpp/container/unordered_multimap | notes={{mark c++11}} }}
{{nv ln | cpp/container/stack}}
{{nv ln | cpp/container/queue}}
{{nv ln | cpp/container/priority_queue}}
{{nv end}}</text>
      <sha1>enbhe7puc11s9f1djxhmgmd3386zwd1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/navbar heading</title>
    <ns>10</ns>
    <id>1163</id>
    <revision>
      <id>35584</id>
      <parentid>2327</parentid>
      <timestamp>2012-06-15T22:28:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/sidebar heading]] to [[Template:cpp/container/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="38">[[cpp/container | Containers library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/noexcept</title>
    <ns>10</ns>
    <id>12919</id>
    <revision>
      <id>64766</id>
      <parentid>64764</parentid>
      <timestamp>2013-08-26T23:47:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="215">{{#switch:{{{1|}}}
| vector | list | deque | set | map | multiset | multimap | stack | queue | priority_queue = {{rev begin}}
{{rev|until=c++11|(none)}}
{{rev|since=c++11|{{noexcept}}}}
{{rev end}}
| {{noexcept}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/note iterator invalidation</title>
    <ns>10</ns>
    <id>5107</id>
    <revision>
      <id>69109</id>
      <parentid>69107</parentid>
      <timestamp>2014-03-27T15:51:22Z</timestamp>
      <contributor>
        <username>Dribeas</username>
        <id>2132</id>
      </contributor>
      <text xml:space="preserve" bytes="5327">{{#switch:{{{1|}}}
|vector={{#switch:{{{2|}}}
  |insert|emplace=If the new {{lc|size()}} is greater than {{lc|capacity()}}, all iterators and references are invalidated. Otherwise, only the iterators and references before the insertion point remain valid. The past-the-end iterator is also invalidated.
  |erase=Invalidates iterators and references at or after the point of the erase, including the {{lc|end()}} iterator.
  |push_back|emplace_back=If the new {{lc|size()}} is greater than {{lc|capacity()}} then all iterators and references (including the past-the-end iterator) are invalidated. Otherwise only the past-the-end iterator is invalidated.
  |pop_back=No iterators or references except for {{lc|back()}} and {{lc|end()}} are invalidated.
  |reserve=If {{tt|new_cap}} is greater than {{lc|capacity()}}, all iterators and references, including the past-the-end iterator, are invalidated. Otherwise, no iterators or references are invalidated.
  |shrink_to_fit=All iterators, including the past the end iterator, are potentially invalidated.
  |swap=All iterators and references remain valid. The past-the-end iterator is invalidated.
}}
|deque={{#switch:{{{2|}}}
  |insert|emplace=All iterators, including the past-the-end iterator, are invalidated. References are invalidated too, unless {{c|pos {{==}} begin()}} or {{c|pos {{==}} end()}}, in which case they are not invalidated.
  |erase=
All iterators and references are invalidated, unless the erased elements are at the end or the beginning of the container, in which case only the iterators and references to the erased elements are invalidated.
{{rev begin}}
{{rev | until=c++11 | It is unspecified when the past-the-end iterator is invalidated. }}
{{rev | since=c++11 | The past-the-end iterator is also invalidated unless the erased elements are at the beginning of the container and the last element is not erased.
}}
{{rev end}}
  |push_back|emplace_back|push_front|push_back=All iterators, including the past-the-end iterator, are invalidated. No references are invalidated.
  |pop_back=
{{rev begin}}
{{rev | until=c++11 | Iterators and references to the erased element are invalidated. It is unspecified whether the past-the-end iterator is invalidated. Other references and iterators are not affected.
}}
{{rev | since=c++11 | Iterators and references to the erased element are invalidated. The past-the-end iterator is also invalidated. Other references and iterators are not affected.
}}
{{rev end}}
  |pop_front=
{{rev begin}}
{{rev | since=c++11 | Iterators and references to the erased element are invalidated. It is unspecified whether the past-the-end iterator is invalidated if the element is the last element in the container. Other references and iterators are not affected.
}}
{{rev | until=c++11 | Iterators and references to the erased element are invalidated. If the element is the last element in the container, the past-the-end iterator is also invalidated. Other references and iterators are not affected.
}}
{{rev end}}
  |shrink_to_fit=All iterators and references are potentially invalidated. Past-the-end iterator is also potentially invalidated.
  |swap=All iterators and references remain valid. The past-the-end iterator is invalidated.
}}
|forward_list|list={{#switch:{{{2|}}}
  |insert|insert_after|emplace|emplace_after|push_back|emplace_back|push_front|emplace_front=No iterators or references are invalidated.
  |erase=References and iterators to the erased elements are invalidated. Other references and iterators are not affected.
  |pop_front|pop_back=References and iterators to the erased element are invalidated.
  |swap=All iterators and references remain valid. It is unspecified whether an iterator holding the past-the-end value in this container will refer to the this or the other container after the operation.
}}
|set|multiset|map|multimap={{#switch:{{{2|}}}
  |insert|emplace|emplace_hint|at|operator_at=No iterators or references are invalidated.
  |erase=References and iterators to the erased elements are invalidated. Other references and iterators are not affected.
  |swap=All iterators and references remain valid. The past-the-end iterator is invalidated.
}}
|unordered_set|unordered_map|unordered_multimap|unordered_multiset={{#switch:{{{2|}}}
  |insert|emplace|emplace_hint=If rehashing occurs due to the insertion, all iterators are invalidated. Otherwise iterators are not affected. References are not invalidated. Rehashing occurs only if the new number of elements is equal to or greater than {{c|max_load_factor()*bucket_count()}}.
  |at|operator_at=If an insertion occurs and results in a rehashing of the container, all iterators are invalidated. Otherwise iterators are not affected. References are not invalidated. Rehashing occurs only if the new number of elements is equal to or greater than {{c|max_load_factor()*bucket_count()}}.
  |erase=References and iterators to the erased elements are invalidated. Other iterators and references are not invalidated.
  |swap=All iterators and references remain valid. The past-the-end iterator is invalidated.
}}
|&lt;!-- default --&gt;&lt;span style{{=}}&quot;border:1px solid #CCC; padding: 2px&quot;&gt;Information on iterator invalidation is copied from [[Template:cpp/container/note_iterator_invalidation|here]]&lt;/span&gt;
}}&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1>gq97cgx3tkkb9wz7wsywx4534zqj9s4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/note iterator invalidation/doc</title>
    <ns>10</ns>
    <id>5108</id>
    <revision>
      <id>18432</id>
      <timestamp>2012-02-02T17:05:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="185">This template contains the information about iterator invalidation of all containers. 

===Usage===

{{tl|cpp/container/note iterator invalidation|''container_name''|''function_name''}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator=</title>
    <ns>10</ns>
    <id>1129</id>
    <revision>
      <id>72257</id>
      <parentid>68019</parentid>
      <timestamp>2014-07-31T22:30:59Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>taget -&gt; target</comment>
      <text xml:space="preserve" bytes="2528">{{cpp/container/{{{1|}}}/title | operator{{=}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} | 1=
{{{1}}}&amp; operator=( const {{{1}}}&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
{{{1}}}&amp; operator=( {{{1}}}&amp;&amp; other );
}}
{{cpp/container/if assoc|{{{1|}}}|
{{dcl | num=3 | since=c++11 | 1=
{{{1}}}&amp; operator=( std::initializer_list&lt;value_type&gt; ilist );
}}
|{{dcl | num=3 | since=c++11 | 1=
{{{1}}}&amp; operator=( std::initializer_list&lt;T&gt; ilist );
}}
}}
{{dcl end}}

Replaces the contents of the container.

@1@ Copy assignment operator. Replaces the contents with a copy of the contents of {{tt|other}}.{{rev inl|since=c++11|If {{lc|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_copy_assignment()}} is {{c|true}}, the target allocator is replaced by a copy of the source allocator. If the target and the source allocators do not compare equal, the target ({{c|*this}}) allocator is used to deallocate the memory, then {{tt|other}}'s allocator is used to allocate it before copying the elements.}}

@2@ Move assignment operator. Replaces the contents with those of {{tt|other}} using move semantics (i.e. the data in {{tt|other}} is moved from {{tt|other}} into this container). {{tt|other}} is in a valid but unspecified state afterwards. If {{lc|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment()}} is {{c|true}}, the target allocator is replaced by a copy of the source allocator. If it is {{c|false}} and the source and the target allocators do not compare equal, the target cannot take ownership of the source memory and must move-assign each element individually, allocating additional memory using its own allocator as needed.

@3@ Replaces the contents with those identified by initializer list {{tt|ilist}}.

===Parameters===
{{par begin}}
{{par | other | another container to use as data source}}
{{par | ilist | initializer list to use as data source}}
{{par end}}

===Return value===
{{c|*this}}

===Complexity===
@1@ Linear in the size of the {{tt|other}}.

@2@ Constant unless {{lc|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_move_assignment()}} is false and the allocators do not compare equal (in which case linear).

@3@ Linear in the size of {{tt|ilist}}.

===Example===
{{include|cpp/container/{{{1|}}}/example operator{{=}}}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor |{{{1|}}}}}
{{cpp/container/if seq|{{{1|}}}|{{dsc inc | cpp/container/dsc assign |{{{1|}}}}}}}
{{dsc end}}</text>
      <sha1>lcdltd367xxxorg77mt55a3hh73d5ir</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator= ad</title>
    <ns>10</ns>
    <id>1130</id>
    <revision>
      <id>63579</id>
      <parentid>63203</parentid>
      <timestamp>2013-07-10T01:44:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1036">{{cpp/container/{{{1|}}}/title | operator{{=}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
{{{1}}}&lt;T, Container&gt;&amp; 
operator=( const {{{1}}}&lt;T,Container&gt;&amp; other );
}}
{{dcl | num=2 | since=c++11 | 1=
{{{1}}}&lt;T, Container&gt;&amp; 
operator=( {{{1}}}&lt;T,Container&gt;&amp;&amp; other );
}}
{{dcl end}}

Replaces the contents of the container adaptor with those of {{tt|other}}.

@1@ Copy assignment operator. Replaces the contents with a copy of the contents of {{tt|other}}. Effectively calls {{c|c {{=}} other.c;}}. {{mark implicit}}

@2@ Move assignment operator. Replaces the contents with those of {{tt|other}} using move semantics. Effectively calls {{c|c {{=}} std::move(other.c);}} {{mark implicit}}

===Parameters===
{{par begin}}
{{par | other | another container adaptor to be used as source}}
{{par end}}

===Return value===
{{c|*this}}

===Complexity===
Equivalent to that of {{c|1=operator=}} of the underlying container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc constructor | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator at</title>
    <ns>10</ns>
    <id>1131</id>
    <revision>
      <id>67656</id>
      <parentid>67655</parentid>
      <timestamp>2014-02-18T15:57:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>try with a more correct syntax</comment>
      <text xml:space="preserve" bytes="1295">{{cpp/container/{{{1|}}}/title | operator[]}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
reference       operator[]( size_type pos );
}}
{{dcl rev begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} | until=c++14 |
const_reference operator[]( size_type pos ) const;
}}
{{dcl | since=c++14 |
constexpr const_reference operator[]( size_type pos ) const;
}}
{{dcl rev end}}
{{dcl end}}

Returns a reference to the element at specified location {{tt|pos}}. No bounds checking is performed.

===Parameters===
{{par begin}}
{{par | pos | position of the element to return}}
{{par end}}

===Return value===
Reference to the requested element.

===Complexity===
Constant.

===Example===
{{example
 | The following code uses {{tt|operator[]}} read from and write to a {{c|std::{{{1}}}&lt;int&gt;}}:
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::{{{1}}}&lt;int{{#ifeq:{{{1}}}|array|,4}}&gt; numbers {2, 4, 6, 8};

    std::cout &lt;&lt; &quot;Second element: &quot; &lt;&lt; numbers[1] &lt;&lt; '\n';

    numbers[0] = 5;

    std::cout &lt;&lt; &quot;All numbers:&quot;;
    for (auto i : numbers) {
        std::cout &lt;&lt; ' ' &lt;&lt; i;
    }
    std::cout &lt;&lt; '\n';
}
 | output=
Second element: 4
All numbers: 5 4 6 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc at |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>l8zgtabp76t93s0c4h1t30oyxl5li83</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator at assoc</title>
    <ns>10</ns>
    <id>1132</id>
    <revision>
      <id>66129</id>
      <parentid>64917</parentid>
      <timestamp>2013-11-04T19:34:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>spell out what T() does (not just default-construction)</comment>
      <text xml:space="preserve" bytes="3557">{{cpp/container/{{{1|}}}/title | operator[]}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
T&amp; operator[]( const Key&amp; key );
}}
{{dcl | num=2 | since=c++11 |
T&amp; operator[]( Key&amp;&amp; key );
}}
{{dcl end}}

Returns a reference to the value that is mapped to a key equivalent to {{tt|key}}, performing an insertion if such key does not already exist. 

If an insertion is performed, the mapped value is [[cpp/language/value initialization|value-initialized]] (default-constructed for class types, zero-initialized otherwise) and a reference to it is returned.

@1@ Inserts {{c|value_type(key, T())}} 
{{par begin}}
{{par req concept | key_type | CopyConstructible }}
{{par req concept | mapped_type | DefaultConstructible | notes={{mark since c++11}} }}
{{par end}}
@2@ Inserts {{c|value_type(std::move(key), T())}}
{{par begin}}
{{par req concept | key_type | MoveConstructible | notes={{mark since c++11}} }}
{{par req concept | mapped_type | DefaultConstructible | notes={{mark since c++11}} }}
{{par end}}

{{cpp/container/note_iterator_invalidation|{{{1|}}}|operator_at}}

===Parameters===
{{par begin}}
{{par | key | the key of the element to find}}
{{par end}}

===Return value===
Reference to the mapped value of the new element if no element with key {{tt|key}} existed. Otherwise a reference to the mapped value of the existing element whose key is equivalent to {{tt|key}}.

===Exceptions===
If an exception is thrown by any operation, the insertion has no effect

===Complexity===
{{#switch: {{{1|}}} 
| map = Logarithmic in the size of the container.
| unordered_map=Average case: constant, worst case: linear in size.
| {{included}}}}

{{#ifeq: {{{1|}}} | map |
===Notes===
Until C++11, the overload (1) was specified to be equivalent to {{c|(insert(std::make_pair(key, T())).first)-&gt;second }}, which required T to be CopyConstructible.
}}

===Example===
{{example
 | This example demonstrates how to modify existing values and insert new values using {{tt|operator[]}}:
 | code=
#include &lt;iostream&gt;
#include &lt;{{{1|}}}&gt;

int main()
{
    std::{{{1|}}}&lt;char, int&gt; letter_counts {{'a', 27}, {'b', 3}, {'c', 1}};

    std::cout &lt;&lt; &quot;initially:\n&quot;;
    for (const auto &amp;pair : letter_counts) {
        std::cout &lt;&lt; pair.first &lt;&lt; &quot;: &quot; &lt;&lt; pair.second &lt;&lt; '\n';
    }

    letter_counts['b'] = 42;  // update an existing value
  
    letter_counts['x'] = 9;  // insert a new value

    std::cout &lt;&lt; &quot;after modifications:\n&quot;;
    for (const auto &amp;pair : letter_counts) {
        std::cout &lt;&lt; pair.first &lt;&lt; &quot;: &quot; &lt;&lt; pair.second &lt;&lt; '\n';
    }
}  
 | output=
initially:
a: 27
b: 3
c: 1
after modifications:
a: 27
b: 42
c: 1
x: 9
}}

{{example 
 | The following example counts the occurrences of each word in a vector of strings:
 | code=
#include &lt;string&gt;
#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;{{{1|}}}&gt;

int main()
{
    std::vector&lt;std::string&gt; words = { 
        &quot;this&quot;, &quot;sentence&quot;, &quot;is&quot;, &quot;not&quot;, &quot;a&quot;, &quot;sentence&quot;,
	&quot;this&quot;, &quot;sentence&quot;, &quot;is&quot;, &quot;a&quot;, &quot;hoax&quot; 
    };

    std::{{{1|}}}&lt;std::string, size_t&gt;  word_map;
    for (const auto &amp;w : words) {
        ++word_map[w];
    }

    for (const auto &amp;pair : word_map) {
        std::cout &lt;&lt; pair.second
	          &lt;&lt; &quot; occurrences of word '&quot;
	          &lt;&lt; pair.first &lt;&lt; &quot;'\n&quot;;
    }
}
 | output=
1 occurrences of word 'hoax'
2 occurrences of word 'this'
2 occurrences of word 'a'
2 occurrences of word 'is'
1 occurrences of word 'not'
3 occurrences of word 'sentence'
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc at |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>ph6jess2gtvnsh6h6wtuf8sddd9h6mk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator cmp</title>
    <ns>10</ns>
    <id>2012</id>
    <revision>
      <id>65833</id>
      <parentid>61004</parentid>
      <timestamp>2013-10-09T19:52:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>fix terminology: == means 'equal', not 'equivalent' (not less and not greater is 'equivalent'')</comment>
      <text xml:space="preserve" bytes="3294">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;={{small|(std::{{{1}}})}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{cpp/container/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; {{#var:types}} &gt;
bool operator!=( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; {{#var:types}} &gt;
bool operator&lt;( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; {{#var:types}} &gt;
bool operator&lt;=( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=5 | 1=
template&lt; {{#var:types}} &gt;
bool operator&gt;( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=6 | 1=
template&lt; {{#var:types}} &gt;
bool operator&gt;=( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl end}}

Compares the contents of two containers.

@1-2@ {{#ifeq:{{{1|}}}|array|
Checks if the contents of {{tt|lhs}} and {{tt|rhs}} are equal, that is, whether each element in {{tt|lhs}} compares equal with the element in {{tt|rhs}} at the same position.
|
Checks if the contents of {{tt|lhs}} and {{tt|rhs}} are equal, that is, whether {{c|1=lhs.size() == rhs.size()}} and each element in {{tt|lhs}} compares equal with the element in {{tt|rhs}} at the same position.
}}

@3-6@ Compares the contents of {{tt|lhs}} and {{tt|rhs}} lexicographically. The comparison is performed by a function equivalent to {{lc|std::lexicographical_compare}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | containers whose contents to compare}} {{#switch:{{{1|}}} 
| array | vector | deque | list | forward_list | dynarray =
{{par req concept | T | EqualityComparable | overloads=1-2}}
{{par req concept | T | LessThanComparable | overloads=3-6 | notes=The ordering relation must establish total order. }}
| set | multiset =
{{par req concept | Key | EqualityComparable | overloads=1-2}}
| map | multimap =
{{par req concept | T, Key | EqualityComparable | overloads=1-2}}
{{par req concept | Key | LessThanComparable | overloads=3-6 | notes=The ordering relation must establish total order. }}
| {{included}} 
}}
{{par end}} 

===Return value===
@1@ {{c|true}} if the contents of the containers are equal, {{c|false}} otherwise

@2@ {{c|true}} if the contents of the containers are not equal, {{c|false}} otherwise

@3@ {{c|true}} if the contents of the {{tt|lhs}} are lexicographically ''less'' than the contents of {{tt|rhs}}, {{c|false}} otherwise

@4@ {{c|true}} if the contents of the {{tt|lhs}} are lexicographically ''less'' than or ''equal'' the contents of {{tt|rhs}}, {{c|false}} otherwise

@5@ {{c|true}} if the contents of the {{tt|lhs}} are lexicographically ''greater'' than the contents of {{tt|rhs}}, {{c|false}} otherwise

@6@ {{c|true}} if the contents of the {{tt|lhs}} are lexicographically ''greater'' than or ''equal'' the contents of {{tt|rhs}}, {{c|false}} otherwise

===Complexity===
Linear in the size of the container</text>
      <sha1>mxmdqjr6gs0qbbxc18g6ddrb1z2sezt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/operator cmp unord</title>
    <ns>10</ns>
    <id>2006</id>
    <revision>
      <id>66544</id>
      <parentid>65835</parentid>
      <timestamp>2013-12-04T21:47:13Z</timestamp>
      <contributor>
        <username>Mpark</username>
        <id>2656</id>
      </contributor>
      <minor/>
      <comment>Fix 'operator==' incorrectly titled 'operator='</comment>
      <text xml:space="preserve" bytes="3123">{{title | operator{{==}},!{{=}}&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}} &lt;!-- switch to apprepriate declarations --&gt;
{{#switch: {{{1}}}
|unordered_set|unordered_multiset=
{{dcl | num=1 | 1=
template&lt; class Key, class Hash, class KeyEqual, class Allocator &gt;
void operator==( {{{1}}}&lt;Key,Hash,KeyEqual,Allocator&gt; &amp;lhs, 
                {{{1}}}&lt;Key,Hash,KeyEqual,Allocator&gt; &amp;rhs);
}}
{{dcl | num=2 | 1=
template&lt; class Key, class Hash, class KeyEqual, class Allocator &gt;
void operator!=( {{{1}}}&lt;Key,Hash,KeyEqual,Allocator&gt; &amp;lhs, 
                 {{{1}}}&lt;Key,Hash,KeyEqual,Allocator&gt; &amp;rhs);
}}
|unordered_map|unordered_multimap=
{{dcl | num=1 | 1=
template&lt; class Key, class T, class Hash, class KeyEqual, class Allocator &gt;
void operator==( {{{1}}}&lt;Key,T,Hash,KeyEqual,Allocator&gt; &amp;lhs, 
                {{{1}}}&lt;Key,T,Hash,KeyEqual,Allocator&gt; &amp;rhs);
}}
{{dcl | num=2 | 1=
template&lt; class Key, class T, class Hash, class KeyEqual, class Allocator &gt;
void operator!=( {{{1}}}&lt;Key,T,Hash,KeyEqual,Allocator&gt; &amp;lhs, 
                 {{{1}}}&lt;Key,T,Hash,KeyEqual,Allocator&gt; &amp;rhs);
}}
|{{included}}
}}
{{dcl end}}

Compares the contents of two unordered containers. 

The contents of two unordered containers {{tt|lhs}} and {{tt|rhs}} are equal if the following conditions hold:
* {{c|1=lhs.size() == rhs.size()}}
* each group of equivalent keys {{tt|[lhs_eq1, lhs_eq2)}} obtained from {{c|lhs.equal_range(lhs_eq1)}} has a corresponding group of equivalent keys in the other container {{tt|[rhs_eq1, rhs_eq2)}} obtained from {{c|rhs.equal_range(rhs_eq1)}}, that has the following properties:
:* {{c|1=std::distance(lhs_eq1, lhs_eq2) == std::distance(rhs_eq1, rhs_eq2)}}.
:* {{c|1=std::is_permutation(lhs_eq1, lhs_eq2, rhs_eq1) == true}}.

{{#switch:{{{1|}}}
|unordered_set|unordered_multiset=The behavior is undefined if {{tt|Key}} is not {{concept|EqualityComparable}}.
|unordered_map|unordered_multimap=The behavior is undefined if {{tt|Key}} or {{tt|T}} are not {{concept|EqualityComparable}}.
|{{included}}
}}

The behavior is also undefined if Hash and KeyEqual do not have the same behavior on lhs and rhs or if the equality comparison operator for Key is not a refinement of the partition into equivalent-key groups introduced by KeyEqual (that is, if two keys that compare equal fall into different partitions)

===Parameters===
{{par begin}}
{{par | lhs, rhs | unordered containers to compare}}
{{par end}} 

===Return value===
@1@ {{c|true}} if the contents of the containers are equal, {{c|false}} otherwise

@2@ {{c|true}} if the contents of the containers are not equal, {{c|false}} otherwise

===Complexity===
{{#switch: {{{1}}}
|unordered_set | unordered_map |1=
''N'' comparisons of the keys in the average case, ''N&lt;sup&gt;2&lt;/sup&gt;'' in the worst case, where ''N'' is the size of the container.
|unordered_multiset | unordered_multimap |1=
''ΣS&lt;sub&gt;i&lt;/sub&gt;&lt;sup&gt;2&lt;/sup&gt;'' comparisons of the keys in the average case, where ''S'' is the size of the ''i''th equivalent key group. ''N&lt;sup&gt;2&lt;/sup&gt;'' comparisons of the keys in the worst case, where ''N'' is the size of the container.
}}</text>
      <sha1>63erqhxp0lxusagl185upc5vpshx70e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/param list Allocator</title>
    <ns>10</ns>
    <id>9969</id>
    <revision>
      <id>52502</id>
      <parentid>47473</parentid>
      <timestamp>2013-06-01T04:48:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="151">{{par | Allocator | An allocator that is used to acquire memory to store the elements. The type must meet the requirements of {{concept|Allocator}}. }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/param list T</title>
    <ns>10</ns>
    <id>9968</id>
    <revision>
      <id>70686</id>
      <parentid>52503</parentid>
      <timestamp>2014-05-28T13:37:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>T must be complete per 17.6.4.8/2</comment>
      <text xml:space="preserve" bytes="588">{{par | T | The type of the elements. 
{{rev begin}} 
{{rev | until=c++11 | {{tt|T}} must meet the requirements of {{concept|CopyAssignable}} and {{concept|CopyConstructible}}. }}
{{rev | since=c++11 | The requirements that are imposed on the elements depend on the actual operations performed on the container. Generally, it is required that element type is a complete type&lt;!--17.6.4.8[res.on.functions]/2, last bullet--&gt; and meets the requirements of {{concept|MoveConstructible}} and {{concept|MoveAssignable}}, but many member functions impose stricter requirements. }}
{{rev end}}
}}</text>
      <sha1>7jyr1yg7qiejdpwe81ytt6r70tme3qj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/pop</title>
    <ns>10</ns>
    <id>1133</id>
    <revision>
      <id>62202</id>
      <parentid>60837</parentid>
      <timestamp>2013-06-25T12:07:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="964">{{cpp/container/{{{1|}}}/title | pop}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void pop();
}}
{{dcl end}}

{{#switch:{{{1|}}}
| stack = Removes the top element from the stack. Effectively calls {{c|c.pop_back()}}
| queue = Removes an element from the front of the queue. Effectively calls {{c|c.pop_front()}}
| priority_queue | Removes the top element from the priority queue. Effectively calls {{c|std::pop_heap(c.begin(), c.end(), comp); c.pop_back();}}
}}

===Parameters===
(none)

===Return value===
(none)

===Complexity===
{{#switch:{{{1|}}}
| stack = Equal to the complexity of {{c|Container::pop_back}}.
| queue = Equal to the complexity of {{c|Container::pop_front}}.
| priority_queue = Logarithmic number of comparisons plus the complexity of {{c|Container::pop_back}}.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace|{{{1|}}}}}
{{dsc inc | cpp/container/dsc push|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/pop back</title>
    <ns>10</ns>
    <id>1134</id>
    <revision>
      <id>72252</id>
      <parentid>70356</parentid>
      <timestamp>2014-07-31T12:04:19Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>Calling pop_back on an empty container is undefined.</comment>
      <text xml:space="preserve" bytes="613">{{cpp/container/{{{1|}}}/title | pop_back}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void pop_back();
}}
{{dcl end}}

Removes the last element of the container. 

Calling {{tt|pop_back}} on an empty container is undefined.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|pop_back}}

===Parameters===
(none)

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{#ifeq: {{{1|}}} | vector ||{{dsc inc | cpp/container/dsc pop_front |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc push_back |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>9ou9a6vfhiru23ej9v1g1hz3jfyjfub</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/pop front</title>
    <ns>10</ns>
    <id>1135</id>
    <revision>
      <id>70358</id>
      <parentid>62219</parentid>
      <timestamp>2014-05-20T17:15:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>also nothrow guarantee</comment>
      <text xml:space="preserve" bytes="570">{{cpp/container/{{{1|}}}/title | pop_front}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void pop_front();
}}
{{dcl end}}

Removes the first element of the container.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|pop_front}}

===Parameters===
(none)

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
Does not throw.

===See also===
{{dsc begin}}
{{#ifeq: {{{1|}}} | forward_list ||{{dsc inc | cpp/container/dsc pop_back |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc push_front |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>meoqlka9mtbhru8pu96mkckeq3w9dvr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/priority queue/navbar</title>
    <ns>10</ns>
    <id>1136</id>
    <revision>
      <id>39879</id>
      <parentid>35577</parentid>
      <timestamp>2012-09-28T19:57:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="271">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/priority_queue/navbar heading
|content3 = cpp/container/priority_queue/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/priority queue/navbar content</title>
    <ns>10</ns>
    <id>1137</id>
    <revision>
      <id>52507</id>
      <parentid>35578</parentid>
      <timestamp>2013-06-01T04:48:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="658">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/priority_queue/priority_queue }}
{{nv mem ln | cpp/container/priority_queue/~priority_queue }}
{{nv mem ln | cpp/container/priority_queue/operator{{=}} }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/priority_queue/top }}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/priority_queue/empty}}
{{nv mem ln | cpp/container/priority_queue/size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/priority_queue/push}}
{{nv mem ln | cpp/container/priority_queue/emplace}}
{{nv mem ln | cpp/container/priority_queue/pop}}
{{nv mem ln | cpp/container/priority_queue/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/priority queue/navbar heading</title>
    <ns>10</ns>
    <id>1138</id>
    <revision>
      <id>35579</id>
      <parentid>2277</parentid>
      <timestamp>2012-06-15T22:28:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/priority queue/sidebar heading]] to [[Template:cpp/container/priority queue/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="61">{{tt|[[cpp/container/priority_queue | std::priority_queue]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/priority queue/title</title>
    <ns>10</ns>
    <id>1139</id>
    <revision>
      <id>2279</id>
      <parentid>2278</parentid>
      <timestamp>2011-06-06T22:52:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=priority_queue::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/push</title>
    <ns>10</ns>
    <id>1140</id>
    <revision>
      <id>63862</id>
      <parentid>63581</parentid>
      <timestamp>2013-07-29T15:21:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}, fmt</comment>
      <text xml:space="preserve" bytes="1412">{{cpp/container/{{{1|}}}/title | push}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void push( const T&amp; value );
}}
{{dcl | since=c++11 |
void push( T&amp;&amp; value );
}}
{{dcl end}}

{{#switch:{{{1|}}}
| stack = Pushes the given element {{tt|value}} to the top of the stack. 

@1@ Effectively calls {{c|c.push_back(value)}}

@2@ Effectively calls {{c|c.push_back(std::move(value))}}
| queue = Pushes the given element {{tt|value}} to the end of the queue.

@1@ Effectively calls {{c|c.push_back(value)}}

@2@ Effectively calls {{c|c.push_back(std::move(value))}}
| priority_queue | Pushes the given element {{tt|value}} to the priority queue.

@1@ Effectively calls {{c|c.push_back(value); std::push_heap(c.begin(), c.end(), comp);}}

@2@ Effectively calls {{c|c.push_back(std::move(value)); std::push_heap(c.begin(), c.end(), comp);}}
}}

===Parameters===
{{par begin}}
{{par | value | the value of the element to push}}
{{par end}} 

===Return value===
(none)

===Complexity===
{{#switch:{{{1|}}}
| stack = Equal to the complexity of {{c|Container::push_back}}.
| queue = Equal to the complexity of {{c|Container::push_back}}.
| priority_queue = Logarithmic number of comparisons plus the complexity of {{c|Container::push_back}}.
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace | {{{1|}}}}}
{{dsc inc | cpp/container/dsc pop | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/push back</title>
    <ns>10</ns>
    <id>1141</id>
    <revision>
      <id>68839</id>
      <parentid>66110</parentid>
      <timestamp>2014-03-22T16:52:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use copyinsertable in exception guarantee phrasing</comment>
      <text xml:space="preserve" bytes="1922">{{cpp/container/{{{1|}}}/title | push_back}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
void push_back( const T&amp; value );
}}
{{dcl | num=2 | since=c++11 |
void push_back( T&amp;&amp; value );
}}
{{dcl end}}

Appends the given element {{tt|value}} to the end of the container.

@1@ The new element is initialized as a copy of {{tt|value}}.

@2@ {{tt|value}} is moved into the new element.

{{cpp/container/note_iterator_invalidation|{{{1|}}}|push_back}}

===Parameters===
{{par begin}}
{{par | value | the value of the element to append}}
{{par hreq}}
{{par req concept | T | CopyInsertable | overload=1}}
{{par req concept | T | MoveInsertable | overload=2}}
{{par end}} 

===Return value===
(none)

===Complexity===
{{#switch:{{{1|}}}
 | vector = Amortized constant.
 | deque | list = Constant.
 | {{included}}
}}

===Exceptions===
If an exception is thrown, this function has no effect (strong exception guarantee).
{{#ifeq: {{{1|}}} | vector |
{{rev begin}}
{{rev | since=c++11 |
If {{tt|T}}'s move constructor is not {{c|noexcept}} and T is not {{concept|CopyInsertable}} into {{tt|*this}}, vector will use the throwing move constructor. If it throws, the guarantee is waived and the effects are unspecified.}}
{{rev end}}
}}

===Example===
{{example
 | The following code uses {{tt|push_back}} to add several integers to a {{c|std::{{{1}}}&lt;int&gt;}}:
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::{{{1}}}&lt;int&gt; numbers;
 
    numbers.push_back(42);
    numbers.push_back(314159); 

    for (int i : numbers) { // c++11 range-based for loop
        std::cout &lt;&lt; i &lt;&lt; '\n';
    } 

    return 0;
}
 | output=
42
314159
}}

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace_back |{{{1|}}}}}
{{#ifeq: {{{1|}}} | vector ||{{dsc inc | cpp/container/dsc push_front |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc pop_back |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>rof4lf7x7b0folswoj0qtkaoal0guoc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/push front</title>
    <ns>10</ns>
    <id>1142</id>
    <revision>
      <id>64084</id>
      <parentid>63860</parentid>
      <timestamp>2013-08-08T12:51:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exception guarantees</comment>
      <text xml:space="preserve" bytes="876">{{cpp/container/{{{1|}}}/title | push_front}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void push_front( const T&amp; value );
}}
{{dcl | since=c++11 |
void push_front( T&amp;&amp; value );
}}
{{dcl end}}

Prepends the given element {{tt|value}} to the beginning of the container. 

{{cpp/container/note_iterator_invalidation|{{{1|}}}|push_front}}

===Parameters===
{{par begin}}
{{par | value | the value of the element to prepend}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===Exceptions===
If an exception is thrown, this function has no effect (strong exception guarantee).

===See also===

{{dsc begin}}
{{dsc inc | cpp/container/dsc emplace_front |{{{1|}}}}}
{{#ifeq: {{{1|}}} | forward_list ||{{dsc inc | cpp/container/dsc push_back |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc pop_front |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/queue/navbar</title>
    <ns>10</ns>
    <id>1143</id>
    <revision>
      <id>39880</id>
      <parentid>35999</parentid>
      <timestamp>2012-09-28T19:57:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="252">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/queue/navbar heading
|content3 = cpp/container/queue/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/queue/navbar content</title>
    <ns>10</ns>
    <id>1144</id>
    <revision>
      <id>52511</id>
      <parentid>35580</parentid>
      <timestamp>2013-06-01T04:48:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="594">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/queue/queue }}
{{nv mem ln | cpp/container/queue/~queue }}
{{nv mem ln | cpp/container/queue/operator{{=}} }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/queue/front }}
{{nv mem ln | cpp/container/queue/back }}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/queue/empty}}
{{nv mem ln | cpp/container/queue/size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/queue/push}}
{{nv mem ln | cpp/container/queue/emplace}}
{{nv mem ln | cpp/container/queue/pop}}
{{nv mem ln | cpp/container/queue/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/queue/navbar heading</title>
    <ns>10</ns>
    <id>1145</id>
    <revision>
      <id>35581</id>
      <parentid>2291</parentid>
      <timestamp>2012-06-15T22:28:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/queue/sidebar heading]] to [[Template:cpp/container/queue/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="43">{{tt|[[cpp/container/queue | std::queue]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/queue/title</title>
    <ns>10</ns>
    <id>1146</id>
    <revision>
      <id>2293</id>
      <parentid>2292</parentid>
      <timestamp>2011-06-06T22:52:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=queue::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/rbegin</title>
    <ns>10</ns>
    <id>1147</id>
    <revision>
      <id>64781</id>
      <parentid>63859</parentid>
      <timestamp>2013-08-27T00:09:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix std</comment>
      <text xml:space="preserve" bytes="774">{{cpp/container/{{{1|}}}/title | rbegin | crbegin}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
reverse_iterator rbegin();
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
const_reverse_iterator rbegin() const;
}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
const_reverse_iterator crbegin() const;
}}
{{dcl end}}

Returns a reverse iterator to the first element of the reversed container. It corresponds to the last element of the non-reversed container. 

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
Reverse iterator to the first element.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc rend |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/rehash</title>
    <ns>10</ns>
    <id>1148</id>
    <revision>
      <id>62216</id>
      <parentid>60844</parentid>
      <timestamp>2013-06-25T12:13:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="997">{{cpp/container/{{{1|}}}/title | rehash}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void rehash( size_type count );
}}
{{dcl end}}

Sets the number of buckets to {{tt|count}} and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. If the new number of buckets makes load factor more than maximum load factor ({{c|count &lt; size() / max_load_factor()}}), then the new number of buckets is at least {{c|size() / max_load_factor()}}. 

===Parameters===
{{par begin}}
{{par | count | new number of buckets}}
{{par end}}

===Return value===
(none)

===Complexity===
Average case linear in the size of the container, worst case quadratic.

===Notes===
{{tt|rehash(0)}} may be used to force an unconditional rehash, such as after suspension of automatic rehashing by temporary increasing {{c|max_load_factor()}}.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc reserve |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/remove</title>
    <ns>10</ns>
    <id>1149</id>
    <revision>
      <id>63858</id>
      <parentid>62117</parentid>
      <timestamp>2013-07-29T15:21:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="1247">{{cpp/container/{{{1|}}}/title | remove, remove_if}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void remove( const T&amp; value );
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
template&lt; class UnaryPredicate &gt;
void remove_if( UnaryPredicate p );
}}
{{dcl end}}

Removes all elements satisfying specific criteria. The first version removes all elements that are equal to {{tt|value}}, the second version removes all elements for which predicate {{tt|p}} returns {{c|true}}. 

===Parameters===
{{par begin}}
{{par | value | value of the elements to remove}}
{{par pred1 | p | if the element should be removed | p1={{{1}}}&lt;T,Allocator&gt;::const_iterator}}
{{par end}} 

===Return value===
(none)

===Complexity===
Linear in the size of the container

===Example===
{{example
 | code=
#include &lt;{{{1}}}&gt;
#include &lt;iostream&gt;

int main()
{
    std::{{{1}}}&lt;int&gt; l = { 1,100,2,3,10,1,11,-1,12 };

    l.remove(1); // remove both elements equal to 1
    l.remove_if([](int n){ return n &gt; 10; }); // remove all elements greater than 10

    for (int n : l) {
        std::cout &lt;&lt; n &lt;&lt; ' '; 
    }
    std::cout &lt;&lt; '\n';
}
 | output=
2 3 10 -1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc remove}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/rend</title>
    <ns>10</ns>
    <id>1151</id>
    <revision>
      <id>64782</id>
      <parentid>63857</parentid>
      <timestamp>2013-08-27T00:10:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix std</comment>
      <text xml:space="preserve" bytes="921">{{cpp/container/{{{1|}}}/title | rend | crend}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |since={{cpp/std|{{{1|}}}}} |
reverse_iterator rend();
}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
const_reverse_iterator rend() const;
}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
const_reverse_iterator crend() const;
}}
{{dcl end}}

Returns a reverse iterator to the element following the last element of the reversed container. It corresponds to the element preceding the first element of the non-reversed container. This element acts as a placeholder, attempting to access it results in undefined behavior. 

{{image|range-rbegin-rend.svg}}

===Parameters===
(none)

===Return value===
Reverse iterator to the element following the last element.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc rbegin |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/reserve</title>
    <ns>10</ns>
    <id>1152</id>
    <revision>
      <id>68982</id>
      <parentid>68981</parentid>
      <timestamp>2014-03-23T15:49:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>rebind's optional too</comment>
      <text xml:space="preserve" bytes="2766">{{cpp/container/{{{1|}}}/title | reserve}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void reserve( size_type new_cap );
}}
{{dcl end}}

Increase the capacity of the container to a value that's greater or equal to {{tt|new_cap}}. If {{tt|new_cap}} is greater than the current {{lc|capacity()}}, new storage is allocated, otherwise the method does nothing.

{{cpp/container/note iterator invalidation|{{{1|}}}|reserve}}

===Parameters===
{{par begin}}
{{par | new_cap | new capacity of the container }}
{{#ifeq:{{{1|}}}|vector|
{{par hreq}}
{{par req concept | T | MoveInsertable}}
}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{lc|std::length_error}} if {{c|new_cap &gt; max_size()}}.

===Complexity===
At most linear in the {{lc|size()}} of the container.

===Notes===
{{lc|reserve()}} cannot be used to reduce the capacity of the container, to that end {{lc|shrink_to_fit()}} is provided.

===Example===
{{#ifeq:{{{1}}}|vector|
{{example
|code=
#include &lt;vector&gt;
#include &lt;iostream&gt;

// minimal C++11 allocator with debug output
template &lt;class Tp&gt;
struct NAlloc {
    typedef Tp value_type;
    NAlloc() = default;
    template &lt;class T&gt; NAlloc(const NAlloc&lt;T&gt;&amp;) {}
    Tp* allocate(std::size_t n) {
        n *= sizeof(Tp);
        std::cout &lt;&lt; &quot;allocating &quot; &lt;&lt; n &lt;&lt; &quot; bytes\n&quot;;
        return static_cast&lt;Tp*&gt;(::operator new(n));
    }
    void deallocate(Tp* p, std::size_t n) {
        std::cout &lt;&lt; &quot;deallocating &quot; &lt;&lt; n*sizeof*p &lt;&lt; &quot; bytes\n&quot;;
        ::operator delete(p);
    }
};
template &lt;class T, class U&gt;
bool operator==(const NAlloc&lt;T&gt;&amp;, const NAlloc&lt;U&gt;&amp;) { return true; }
template &lt;class T, class U&gt;
bool operator!=(const NAlloc&lt;T&gt;&amp;, const NAlloc&lt;U&gt;&amp;) { return false; }

int main()
{
    int sz = 100;
    std::cout &lt;&lt; &quot;using reserve: \n&quot;;
    {
        std::vector&lt;int, NAlloc&lt;int&gt;&gt; v1;
        v1.reserve(sz);
        for(int n = 0; n &lt; sz; ++n)
            v1.push_back(n);
    }
    std::cout &lt;&lt; &quot;not using reserve: \n&quot;;
    {
        std::vector&lt;int, NAlloc&lt;int&gt;&gt; v1;
        for(int n = 0; n &lt; sz; ++n)
            v1.push_back(n);
    }
}
|p=true
|output=
using reserve: 
allocating 400 bytes
deallocating 400 bytes
not using reserve: 
allocating 4 bytes
allocating 8 bytes
deallocating 4 bytes
allocating 16 bytes
deallocating 8 bytes
allocating 32 bytes
deallocating 16 bytes
allocating 64 bytes
deallocating 32 bytes
allocating 128 bytes
deallocating 64 bytes
allocating 256 bytes
deallocating 128 bytes
allocating 512 bytes
deallocating 256 bytes
deallocating 512 bytes
}}
|{{example}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc capacity |{{{1|}}}}}
{{dsc inc | cpp/container/dsc resize |{{{1|}}}}}
{{dsc inc | cpp/container/dsc shrink_to_fit |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>dvy1ssn88yrokkd26q2ydm83rwtqk8f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/reserve unord</title>
    <ns>10</ns>
    <id>1153</id>
    <revision>
      <id>62214</id>
      <parentid>60848</parentid>
      <timestamp>2013-06-25T12:12:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="792">{{cpp/container/{{{1|}}}/title | reserve}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void reserve( size_type count );
}}
{{dcl end}}

Sets the number of buckets to the number needed to accomodate at least {{tt|count}} elements without exceeding maximum load factor and rehashes the container, i.e. puts the elements into appropriate buckets considering that total number of buckets has changed. Effectively calls {{c|rehash(std::ceil(count / max_load_factor()))}}.

===Parameters===
{{par begin}}
{{par | count | new capacity of the container}}
{{par end}}

===Return value===
(none)

===Complexity===
Average case linear in the size of the container, worst case quadratic.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc rehash |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/resize</title>
    <ns>10</ns>
    <id>1154</id>
    <revision>
      <id>72323</id>
      <parentid>72203</parentid>
      <timestamp>2014-08-08T16:59:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention that resize never shrinks vector capacity</comment>
      <text xml:space="preserve" bytes="2391">{{cpp/container/{{{1|}}}/title | resize}}
{{cpp/container/{{{1|}}}/navbar}}
{{#ifeq: {{{1|}}} | forward_list |
{{dcl begin}}
{{dcl | num=1|
void resize( size_type count );
}}
{{dcl | num=2|
void resize( size_type count, const value_type&amp; value);
}}
{{dcl end}}
|
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
void resize( size_type count, T value {{=}} T() );
}}
{{dcl | since=c++11 | num=1|
void resize( size_type count );
}}
{{dcl | since=c++11 | num=2|
void resize( size_type count, const value_type&amp; value );
}}
{{dcl rev end}}
{{dcl end}}
}}

Resizes the container to contain {{tt|count}} elements.

If the current size is greater than {{tt|count}}, the container is reduced to its first {{tt|count}} elements as if by repeatedly calling {{tt|pop_back()}}.

{{#ifeq: {{{1|}}} | forward_list |
If the current size is less than {{tt|count}},
@1@ additional value-initialized elements are appended
@2@ additional copies of {{tt|value}} are appended
|
{{rev begin}}
{{rev|until=c++11|
If the current size is less than {{tt|count}}, additional elements are appended and initialized with copies of {{tt|value}}.
}}
{{rev|since=c++11|
If the current size is less than {{tt|count}},
@1@ additional value-initialized elements are appended
@2@ additional copies of {{tt|value}} are appended
}}
{{rev end}}
}}
===Parameters===
{{par begin}}
{{par | count | new size of the container}}
{{par | value | the value to initialize the new elements with }}
{{par hreq}}
{{par req concept | T | MoveInsertable | DefaultConstructible | overload=1 }}
{{par req concept | T | CopyInsertable | overload=2 }}
{{par end}}

===Return value===
(none)

===Complexity===
Linear in the size of the container
{{#ifeq:{{{1}}}|vector|

===Notes===
If value-initialization is undesirable, for example, if the elements are of non-class type and zeroing out is not needed, it can be avoided by providing a [http://stackoverflow.com/a/21028912/273767 custom Allocator::constuct].

Vector capacity is never reduced when resizing to smaller size because that would invalidate all iterators, rather than only the ones that would be invalidated by the equivalent sequence of pop_back() calls.
}}

===See also===
{{dsc begin}}
{{#ifeq:{{{1|}}} | forward_list || {{dsc inc | cpp/container/dsc size |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc insert |{{{1|}}}}}
{{dsc inc | cpp/container/dsc erase |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>krcmdfza06ezsc9yi5jxdvjwfxu8ok4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/reverse</title>
    <ns>10</ns>
    <id>1155</id>
    <revision>
      <id>63856</id>
      <parentid>60850</parentid>
      <timestamp>2013-07-29T15:20:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="1052">{{cpp/container/{{{1|}}}/title | reverse}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void reverse();
}}
{{dcl end}}

Reverses the order of the elements in the container. No references or iterators become invalidated.

===Parameters===
(none)

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;{{{1}}}&gt;

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; ostr, const std::{{{1}}}&lt;int&gt;&amp; list)
{
    for (auto &amp;i : list) {
        ostr &lt;&lt; &quot; &quot; &lt;&lt; i;
    }
    return ostr;
}

int main()
{
    std::{{{1}}}&lt;int&gt; list = { 8,7,5,9,0,1,3,2,6,4 };

    std::cout &lt;&lt; &quot;before:     &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
    list.sort();
    std::cout &lt;&lt; &quot;ascending:  &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
    list.reverse();
    std::cout &lt;&lt; &quot;descending: &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
}
 | output=
before:      8 7 5 9 0 1 3 2 6 4
ascending:   0 1 2 3 4 5 6 7 8 9
descending:  9 8 7 6 5 4 3 2 1 0
}}

===Complexity===
Linear in the size of the container

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc sort |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/example empty</title>
    <ns>10</ns>
    <id>10026</id>
    <revision>
      <id>47705</id>
      <parentid>47704</parentid>
      <timestamp>2013-05-16T19:16:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="497">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::set&lt;int&gt;}} contains any elements:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::set&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.insert(42);
    numbers.insert(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/example operator=</title>
    <ns>10</ns>
    <id>12815</id>
    <revision>
      <id>63219</id>
      <timestamp>2013-07-06T11:49:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1122">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::set}} to another:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;

void display_sizes(const std::set&lt;int&gt; &amp;nums1,
                   const std::set&lt;int&gt; &amp;nums2,
                   const std::set&lt;int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::set&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::set&lt;int&gt; nums2; 
    std::set&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/example size</title>
    <ns>10</ns>
    <id>10039</id>
    <revision>
      <id>47728</id>
      <timestamp>2013-05-16T20:08:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="317">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{c|std::set&lt;int&gt;}}:
 | code=
#include &lt;set&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::set&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/navbar</title>
    <ns>10</ns>
    <id>1156</id>
    <revision>
      <id>39881</id>
      <parentid>35582</parentid>
      <timestamp>2012-09-28T19:57:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/set/navbar heading
|content3 = cpp/container/set/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/navbar content</title>
    <ns>10</ns>
    <id>1157</id>
    <revision>
      <id>52520</id>
      <parentid>34626</parentid>
      <timestamp>2013-06-01T04:48:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1387">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/set/set }}
{{nv mem ln | cpp/container/set/~set }}
{{nv mem ln | cpp/container/set/operator{{=}} }}
{{nv mem ln | cpp/container/set/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/set/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/set/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/set/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/set/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/set/empty}}
{{nv mem ln | cpp/container/set/size}}
{{nv mem ln | cpp/container/set/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/set/clear}}
{{nv mem ln | cpp/container/set/insert}}
{{nv mem ln | cpp/container/set/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/set/emplace_hint | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/set/erase}}
{{nv mem ln | cpp/container/set/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/set/count}}
{{nv mem ln | cpp/container/set/find}}
{{nv mem ln | cpp/container/set/equal_range}}
{{nv mem ln | cpp/container/set/lower_bound}}
{{nv mem ln | cpp/container/set/upper_bound}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/set/key_comp}}
{{nv mem ln | cpp/container/set/value_comp}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/navbar heading</title>
    <ns>10</ns>
    <id>1158</id>
    <revision>
      <id>35021</id>
      <parentid>2317</parentid>
      <timestamp>2012-06-15T22:16:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/set/sidebar heading]] to [[Template:cpp/container/set/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="36">{{ltt|cpp/container/set | std::set}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/set/title</title>
    <ns>10</ns>
    <id>1159</id>
    <revision>
      <id>2319</id>
      <parentid>2318</parentid>
      <timestamp>2011-06-06T22:52:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="100">&lt;onlyinclude&gt;{{cpp/title | n=set::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/shrink to fit</title>
    <ns>10</ns>
    <id>1160</id>
    <revision>
      <id>68835</id>
      <parentid>64351</parentid>
      <timestamp>2014-03-22T16:40:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>&quot;at most&quot; linear is the wording</comment>
      <text xml:space="preserve" bytes="1005">{{cpp/container/{{{1|}}}/title | shrink_to_fit}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void shrink_to_fit();
}}
{{dcl end}}

Requests the removal of unused capacity.

It is a non-binding request to reduce {{#ifeq:{{{1|}}}|vector|{{lc|capacity()}}|{{tt|capacity}}}} to {{lc|size()}}. It depends on the implementation if the request is fulfilled. 

{{cpp/container/note iterator invalidation|{{{1|}}}|shrink_to_fit}}

===Parameters===
(none)

{{par begin}}
{{par hreq}}
{{par req concept | T | MoveInsertable}}
{{par end}}

===Return value===
(none)

===Complexity===
At most linear in the size of the container.
{{#ifeq:{{{1|}}}|vector|

===Notes===
If an exception is thrown other than by T's move constructor, there are no effects.
}}
===Example===
{{include|cpp/container/{{{1|}}}/example_shrink_to_fit}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc size |{{{1|}}}}}
{{#ifeq: {{{1|}}}|vector|{{dsc inc | cpp/container/dsc capacity |{{{1|}}}}}}}
{{dsc end}}</text>
      <sha1>niza6ao8sjbiy12i1dxa28kigt1h9lq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/size</title>
    <ns>10</ns>
    <id>1164</id>
    <revision>
      <id>64981</id>
      <parentid>64977</parentid>
      <timestamp>2013-08-28T22:22:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>no more list</comment>
      <text xml:space="preserve" bytes="822">{{cpp/container/{{{1|}}}/title | size}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type size() const;
}}
{{dcl end}}

Returns the number of elements in the container, i.e. {{c|std::distance(begin(), end())}}.

===Parameters===
(none)

===Return value===
The number of elements in the container.

===Exceptions===
{{cpp/container/noexcept|{{{1|}}}}}

===Complexity===
Constant.

===Example===
{{include | cpp/container/{{{1|}}}/example_size}}

===See also===
{{dsc begin}}
{{#ifeq: {{{1|}}} | vector | {{dsc inc | cpp/container/dsc capacity |{{{1|}}}}} }}
{{dsc inc | cpp/container/dsc empty |{{{1|}}}}}
{{dsc inc | cpp/container/dsc max_size |{{{1|}}}}}
{{#switch:{{{1|}}} | vector | deque | list | forward_list={{dsc inc | cpp/container/dsc resize |{{{1|}}}}} }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/size ad</title>
    <ns>10</ns>
    <id>1165</id>
    <revision>
      <id>62271</id>
      <parentid>62211</parentid>
      <timestamp>2013-06-26T03:43:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce</comment>
      <text xml:space="preserve" bytes="454">{{cpp/container/{{{1|}}}/title | size}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
size_type size() const;
}}
{{dcl end}}

Returns the number of elements in the underlying container, that is, {{c|c.size()}}.

===Parameters===
(none)

===Return value===
The number of elements in the container.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc empty | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/sort</title>
    <ns>10</ns>
    <id>1166</id>
    <revision>
      <id>67359</id>
      <parentid>63855</parentid>
      <timestamp>2014-02-05T20:34:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>cmp ord</comment>
      <text xml:space="preserve" bytes="1347">{{cpp/container/{{{1|}}}/title | sort}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
void sort();
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
template&lt; class Compare &gt; 
void sort( Compare comp );
}}
{{dcl end}}

Sorts the elements in ascending order. The order of equal elements is preserved. The first version uses {{c|operator&lt;}} to compare the elements, the second version uses the given comparison function {{tt|comp}}.

===Parameters===
{{par begin}}
{{par cmp ord | comp | p1={{{1}}}&lt;T,Allocator&gt;::const_iterator }} 
{{par end}} 

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;functional&gt;
#include &lt;{{{1}}}&gt;

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; ostr, const std::{{{1}}}&lt;int&gt;&amp; list)
{
    for (auto &amp;i : list) {
        ostr &lt;&lt; &quot; &quot; &lt;&lt; i;
    }
    return ostr;
}

int main()
{
    std::{{{1}}}&lt;int&gt; list = { 8,7,5,9,0,1,3,2,6,4 };

    std::cout &lt;&lt; &quot;before:     &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
    list.sort();
    std::cout &lt;&lt; &quot;ascending:  &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
    list.sort(std::greater&lt;int&gt;());
    std::cout &lt;&lt; &quot;descending: &quot; &lt;&lt; list &lt;&lt; &quot;\n&quot;;
}
 | output=
before:      8 7 5 9 0 1 3 2 6 4
ascending:   0 1 2 3 4 5 6 7 8 9
descending:  9 8 7 6 5 4 3 2 1 0
}}

===Complexity===
{{math|N · log(N)}} comparisons, where {{tt|N}} is the size of the container.</text>
      <sha1>fawy8tzc16wzvez8shptfe0tjdf84tf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/splice</title>
    <ns>10</ns>
    <id>1167</id>
    <revision>
      <id>71184</id>
      <parentid>63846</parentid>
      <timestamp>2014-06-07T22:01:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>since this doesn't call move constructors, reword from 'moves' to 'transfers'</comment>
      <text xml:space="preserve" bytes="3234">{{cpp/container/{{{1|}}}/title | splice}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
void splice( const_iterator pos, {{{1}}}&amp; other );
}}
{{dcl | num=1 | since=c++11 |
void splice( const_iterator pos, {{{1}}}&amp;&amp; other );
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
void splice( const_iterator pos, {{{1}}}&amp; other, const_iterator it );
}}
{{dcl | num=2 | since=c++11 |
void splice( const_iterator pos, {{{1}}}&amp;&amp; other, const_iterator it );
}}
{{dcl | num=3 |since={{cpp/std|{{{1|}}}}} |
void splice( const_iterator pos, {{{1}}}&amp; other, 
             const_iterator first, const_iterator last);
}}
{{dcl | num=3 | since=c++11 |
void splice( const_iterator pos, {{{1}}}&amp;&amp; other, 
             const_iterator first, const_iterator last );
}}
{{dcl end}}

Transfers elements from one list to another.

No elements are copied or moved, only the internal pointers of the list nodes are re-pointed. The behavior is undefined if: {{c|get_allocator() !{{=}} other.get_allocator()}}. No iterators or references become invalidated, the iterators to moved elements remain valid, but now refer into {{c|*this}}, not into {{tt|other}}.

@1@ Transfers all elements from {{tt|other}} into {{c|*this}}. The elements are inserted before the element pointed to by {{tt|pos}}. The container {{tt|other}} becomes empty after the operation. The behavior is undefined if {{c|this {{==}} &amp;other}}.

@2@ Transfers the element pointed to by {{tt|it}} from {{tt|other}} into {{c|*this}}. The element is inserted before the element pointed to by {{tt|pos}}.

@3@ Transfers the elements in the range {{tt|[first, last)}} from {{tt|other}} into {{c|*this}}. The elements are inserted before the element pointed to by {{tt|pos}}. The behavior is undefined if {{tt|pos}} is an iterator in the range {{tt|[first,last)}}.

===Parameters===
{{par begin}}
{{par | pos | element before which the content will be inserted }}
{{par | other | another container to transfer the content from}}
{{par | it | the element to transfer from {{tt|other}} to {{c|*this}}}}
{{par | first, last | the range of elements to transfer from {{tt|other}} to {{c|*this}}}}
{{par end}} 

===Return value===
(none)

===Complexity===
1-2) Constant.

3) Constant if {{c|this {{==}} &amp;other}}, otherwise linear in {{c|std::distance(first, last)}}.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;list&gt;

std::ostream&amp; operator&lt;&lt;(std::ostream&amp; ostr, const std::list&lt;int&gt;&amp; list)
{
    for (auto &amp;i : list) {
        ostr &lt;&lt; &quot; &quot; &lt;&lt; i;
    }
    return ostr;
}

int main ()
{
    std::list&lt;int&gt; list1 = { 1, 2, 3, 4, 5 };
    std::list&lt;int&gt; list2 = { 10, 20, 30, 40, 50 };

    auto it = list1.begin();
    std::advance(it, 2);

    list1.splice(it, list2);

    std::cout &lt;&lt; &quot;list1: &quot; &lt;&lt; list1 &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; &quot;list2: &quot; &lt;&lt; list2 &lt;&lt; &quot;\n&quot;;

    list2.splice(list2.begin(), list1, it, list1.end());

    std::cout &lt;&lt; &quot;list1: &quot; &lt;&lt; list1 &lt;&lt; &quot;\n&quot;;
    std::cout &lt;&lt; &quot;list2: &quot; &lt;&lt; list2 &lt;&lt; &quot;\n&quot;;
}
 | output=
list1:  1 2 10 20 30 40 50 3 4 5
list2: 
list1:  1 2 10 20 30 40 50
list2:  3 4 5
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc merge |{{{1|}}}}}
{{dsc inc | cpp/container/dsc remove |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>sk43s8rnop8futggbsm496ckebzuokv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/splice after</title>
    <ns>10</ns>
    <id>2449</id>
    <revision>
      <id>63587</id>
      <parentid>60855</parentid>
      <timestamp>2013-07-10T01:44:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3186">{{cpp/container/{{{1|}}}/title | splice_after}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp; other );
}}
{{dcl | num=1 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp;&amp; other );
}}
{{dcl | num=2 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp; other, const_iterator it );
}}
{{dcl | num=2 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp;&amp; other, const_iterator it );
}}
{{dcl | num=3 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp; other, 
                   const_iterator first, const_iterator last );
}}
{{dcl | num=3 | since=c++11 |
void splice_after( const_iterator pos, {{{1}}}&amp;&amp; other, 
                   const_iterator first, const_iterator last );
}}
{{dcl end}}

Moves elements from another {{tt|{{{1}}}}} to {{c|*this}}.

No elements are copied. {{tt|pos}} is a valid iterator in {{c|*this}} or is the {{c|before_begin()}} iterator. The behavior is undefined if {{c|get_allocator() !{{=}} other.get_allocator()}}. No iterators or references become invalidated, the iterators to moved elements now refer into {{c|*this}}, not into {{tt|other}}.

1) Moves all elements from {{tt|other}} into {{c|*this}}. The elements are inserted after the element pointed to by {{tt|pos}}. The container {{tt|other}} becomes empty after the operation. The behavior is undefined if {{c|this {{==}} &amp;other}}

2) Moves the element pointed to by the iterator following {{tt|it}} from {{tt|other}} into {{c|*this}}. The element is inserted after the element pointed to by {{tt|pos}}.

3) Moves the elements in the range {{tt|(first, last)}} from {{tt|other}} into {{c|*this}}. The elements are inserted after the element pointed to by {{tt|pos}}. The element pointed-to by {{tt|first}} is not moved. The behavior is undefined if {{tt|pos}} is an iterator in the range {{tt|(first,last)}}.

===Parameters===
{{par begin}}
{{par | pos | element after which the content will be inserted }}
{{par | other | another container to move the content from}}
{{par | it | iterator preceding the iterator to the element to move from {{tt|other}} to {{c|*this}}}}
{{par | first, last | the range of elements to move from {{tt|other}} to {{c|*this}}}}
{{par end}} 

===Return value===
(none)

===Complexity===
1) Linear in the size of {{tt|other}}

2) Constant

3) Linear in {{c|std::distance(first, last)}}

===Example===
{{example
 | Demonstrates the meaning of open interval (first, last) in the third form of splice_after(): the first element of l1 is not moved.
 | code =
#include &lt;iostream&gt;
#include &lt;forward_list&gt;
int main()
{
    std::forward_list&lt;int&gt; l1 = {1,2,3,4,5};
    std::forward_list&lt;int&gt; l2 = {10,11,12};

    l2.splice_after(l2.cbegin(), l1, l1.cbegin(), l1.cend());
    // not equivalent to l2.splice_after(l2.cbegin(), l1);

    for(int n : l1)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';

    for(int n : l2)
        std::cout &lt;&lt; n &lt;&lt; ' ';
    std::cout &lt;&lt; '\n';
}
 | output=
1
10 2 3 4 5 11 12
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc merge |{{{1|}}}}}
{{dsc inc | cpp/container/dsc remove |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/stack/navbar</title>
    <ns>10</ns>
    <id>1168</id>
    <revision>
      <id>39883</id>
      <parentid>35390</parentid>
      <timestamp>2012-09-28T19:57:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/stack/navbar heading
|content3 = cpp/container/stack/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/stack/navbar content</title>
    <ns>10</ns>
    <id>1169</id>
    <revision>
      <id>52527</id>
      <parentid>35057</parentid>
      <timestamp>2013-06-01T04:48:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="550">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/stack/stack }}
{{nv mem ln | cpp/container/stack/~stack }}
{{nv mem ln | cpp/container/stack/operator{{=}} }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/stack/top }}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/stack/empty}}
{{nv mem ln | cpp/container/stack/size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/stack/push}}
{{nv mem ln | cpp/container/stack/emplace}}
{{nv mem ln | cpp/container/stack/pop}}
{{nv mem ln | cpp/container/stack/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/stack/navbar heading</title>
    <ns>10</ns>
    <id>1170</id>
    <revision>
      <id>35585</id>
      <parentid>2341</parentid>
      <timestamp>2012-06-15T22:28:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/stack/sidebar heading]] to [[Template:cpp/container/stack/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="43">{{tt|[[cpp/container/stack | std::stack]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/stack/title</title>
    <ns>10</ns>
    <id>1171</id>
    <revision>
      <id>2343</id>
      <parentid>2342</parentid>
      <timestamp>2011-06-06T22:53:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=stack::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/swap</title>
    <ns>10</ns>
    <id>1172</id>
    <revision>
      <id>65573</id>
      <parentid>62125</parentid>
      <timestamp>2013-09-20T17:01:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>revbox the POCS rules</comment>
      <text xml:space="preserve" bytes="1636">{{cpp/container/{{{1|}}}/title | swap}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void swap( {{{1}}}&amp; other );
}}
{{dcl end}}

Exchanges the contents of the container with those of {{tt|other}}. Does not invoke any move, copy, or swap operations on individual elements.

{{cpp/container/note iterator invalidation|{{{1|}}}|swap}}

{{#switch:{{{1|}}}
|map | set | multimap | multiset=The {{tt|Pred}} objects must be {{concept|Swappable}}, and they are exchanged using unqualified call to non-member {{tt|swap}}.
|unordered_map | unordered_set | unordered_multimap| unordered_multiset=The {{tt|Hash}} and {{tt|KeyEqual}} objects must be {{concept|Swappable}}, and they are exchanged using unqualified calls to non-member {{tt|swap}}.
}}
{{rev inl|since=c++11|
If {{c|std::allocator_traits&lt;allocator_type&gt;::propagate_on_container_swap::value}} is true, then the allocators are exchanged using an unqualified call to non-member {{tt|swap}}. Otherwise, they are not swapped (and if {{c|1=get_allocator() != other.get_allocator()}}, the behavior is undefined).}}

===Parameters===
{{par begin}}
{{par | other | container to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{#switch:{{{1|}}}
|map | set | multimap | multiset=Any exception thrown by the swap of the {{tt|Compare}} objects.
|unordered_map | unordered_set | unordered_multimap| unordered_multiset=Any exception thrown by the swap {{tt|Hash}} or {{tt|KeyEqual}} objects.
|(none)
}}

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap2 |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>squx37xroa7vj8eb34i9tk0sunrgvdg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/swap2</title>
    <ns>10</ns>
    <id>1997</id>
    <revision>
      <id>63851</id>
      <parentid>60857</parentid>
      <timestamp>2013-07-29T15:19:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="834">{{cpp/title | swap&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/container/{{{1|}}}/navbar}}
{{cpp/container/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
template&lt; {{#var:types}} &gt;
void swap( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs, 
           {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{c|std::{{{1}}}}}. Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | containers whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Complexity===
{{#switch: {{{1}}}
|array=
Linear in size of the container.
|stack|queue|priority_queue=
Same as swapping the underlying container.
|Constant.
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/swap ad</title>
    <ns>10</ns>
    <id>1173</id>
    <revision>
      <id>72419</id>
      <parentid>64761</parentid>
      <timestamp>2014-08-21T11:39:13Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>it's new in C++11</comment>
      <text xml:space="preserve" bytes="998">{{cpp/container/{{{1|}}}/title | swap}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}|c++11}} |
void swap( {{{1}}}&amp; other );
}}
{{dcl end}}

Exchanges the contents of the container adaptor with those of {{tt|other}}. {{#switch:{{{1|}}}
 | stack|queue=Effectively calls {{c|using std::swap; swap(c, other.c);}}
 | priority_queue|=Effectively calls {{c|using std::swap; swap(c, other.c); swap(comp, other.comp);}}
}}

===Parameters===
{{par begin}}
{{par | other | container adaptor to exchange the contents with}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{#switch:{{{1|}}}
| stack|queue={{noexcept|noexcept(std::swap(c, other.c))}}
| priority_queue|={{noexcept|noexcept(std::swap(c, other.c)) &amp;&amp; noexcept(std::swap(comp, other.comp))}}
}}


===Complexity===
Same as underlying container (linear if {{tt|Container}} is {{lc|std::array}}, constant otherwise).

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap2 |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>oy0tgppq6r1zj7leeqowavceb3xq00a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell</title>
    <ns>10</ns>
    <id>1174</id>
    <revision>
      <id>19159</id>
      <parentid>19143</parentid>
      <timestamp>2012-02-27T14:31:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>specify center on the table element</comment>
      <text xml:space="preserve" bytes="62">&lt;span style=&quot;font-size:0.9em; color: #505050;&quot;&gt;{{{1|}}}&lt;/span&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell hn</title>
    <ns>10</ns>
    <id>1175</id>
    <revision>
      <id>2351</id>
      <parentid>2350</parentid>
      <timestamp>2011-06-06T22:53:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="362">style = &quot;padding: 0;  background: #b0d0b0;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; border: none; vertical-align: middle; text-align: center; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #b0d0b0;&quot;
| style=&quot;border: none;&quot; | &lt;tt&gt;&lt;b&gt;{{{2|{{ltt/core|{{{1|&amp;nbsp;}}}}}}}}&lt;/b&gt;&lt;/tt&gt;
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell ho</title>
    <ns>10</ns>
    <id>1176</id>
    <revision>
      <id>2353</id>
      <parentid>2352</parentid>
      <timestamp>2011-06-06T22:53:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="362">style = &quot;padding: 0;  background: #b0b0d0;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; border: none; vertical-align: middle; text-align: center; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #b0b0d0;&quot;
| style=&quot;border: none;&quot; | &lt;tt&gt;&lt;b&gt;{{{2|{{ltt/core|{{{1|&amp;nbsp;}}}}}}}}&lt;/b&gt;&lt;/tt&gt;
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell ln</title>
    <ns>10</ns>
    <id>1177</id>
    <revision>
      <id>2355</id>
      <parentid>2354</parentid>
      <timestamp>2011-06-06T22:53:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="315">style = &quot;padding: 0;  background: #b0d0b0;&quot; | &lt;div style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; border: none; vertical-align: middle; text-align: center; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #b0d0b0;&quot;
| style=&quot;border: none;&quot; | &lt;tt&gt;{{{1|&amp;nbsp;}}}&lt;/tt&gt;
|}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell lnn</title>
    <ns>10</ns>
    <id>1178</id>
    <revision>
      <id>2357</id>
      <parentid>2356</parentid>
      <timestamp>2011-06-06T22:53:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="386">style = &quot;padding: 0 0 0 0;&quot; | &lt;div style=&quot;padding: 0 0 0 0;&quot; &gt;
{| width=&quot;100%&quot; height=&quot;100%&quot; style=&quot;border-spacing: 0px; vertical-align: middle; text-align: center; padding: 0 0 0 0;&quot;
|- style=&quot;background: #b0b0d0;&quot;
| style=&quot;border: 0; border-bottom: 1px solid #AAAAAA;&quot; | &lt;tt&gt;{{{1|&amp;nbsp;}}}&lt;/tt&gt;
|-  style=&quot;background: #b0b0d0;&quot;
| style=&quot;border: 0;&quot; | &lt;tt&gt;{{{2|&amp;nbsp;}}}&lt;/tt&gt;
|}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell lo</title>
    <ns>10</ns>
    <id>1179</id>
    <revision>
      <id>2359</id>
      <parentid>2358</parentid>
      <timestamp>2011-06-06T22:53:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="315">style = &quot;padding: 0;  background: #b0b0d0;&quot; | &lt;div style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; border: none; vertical-align: middle; text-align: center; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #b0b0d0;&quot;
| style=&quot;border: none;&quot; | &lt;tt&gt;{{{1|&amp;nbsp;}}}&lt;/tt&gt;
|}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell lon</title>
    <ns>10</ns>
    <id>1180</id>
    <revision>
      <id>2361</id>
      <parentid>2360</parentid>
      <timestamp>2011-06-06T22:53:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="346">style = &quot;padding: 0 0 0 0;&quot; |
{| width=&quot;100%&quot; height=&quot;100%&quot; style=&quot;border-spacing: 0px; vertical-align: middle; text-align: center; padding: 0 0 0 0;&quot;
|- style=&quot;background: #b0b0d0;&quot;
| style=&quot;border: 0; border-bottom: 1px solid #AAAAAA;&quot; | &lt;tt&gt;{{{1|&amp;nbsp;}}}&lt;/tt&gt;
|-  style=&quot;background: #b0d0b0;&quot;
| style=&quot;border: 0;&quot; | &lt;tt&gt;{{{2|&amp;nbsp;}}}&lt;/tt&gt;
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell n</title>
    <ns>10</ns>
    <id>1181</id>
    <revision>
      <id>19160</id>
      <parentid>2363</parentid>
      <timestamp>2012-02-27T14:33:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move to the main table</comment>
      <text xml:space="preserve" bytes="350">style = &quot;padding: 0; background: #bcffbc;&quot; | [[ {{{1|cpp}}} | &lt;div  style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; vertical-align: middle; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #bcffbc;&quot;
| style=&quot;border: none;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{2|{{ltt/core|{{{1|&amp;nbsp;}}}}}}}}&lt;/tt&gt;}}
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell nn</title>
    <ns>10</ns>
    <id>1182</id>
    <revision>
      <id>19161</id>
      <parentid>2365</parentid>
      <timestamp>2012-02-27T14:34:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move to the main table</comment>
      <text xml:space="preserve" bytes="443">style = &quot;padding: 0 0 0 0;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0 0 0 0;&quot; &gt;
{| width=&quot;100%&quot; height=&quot;100%&quot; style=&quot;border-spacing: 0px; vertical-align: middle; padding: 0 0 0 0;&quot;
|- style=&quot;background: #bcffbc;&quot;
| style=&quot;border: 0; border-bottom: 1px solid #AAAAAA;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{2|&amp;nbsp;}}}&lt;/tt&gt;}}
|-  style=&quot;background: #bcffbc;&quot;
| style=&quot;border: 0;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{3|&amp;nbsp;}}}&lt;/tt&gt;}}
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell o</title>
    <ns>10</ns>
    <id>1183</id>
    <revision>
      <id>19162</id>
      <parentid>2367</parentid>
      <timestamp>2012-02-27T14:34:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move to the main table</comment>
      <text xml:space="preserve" bytes="364">style = &quot;padding: 0;  background: #bcbcff;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0; margin: 0;&quot; &gt;
{| style=&quot;border-spacing: 0px; border: none; vertical-align: middle; padding: 0; margin: 0; width: 100%; height: 100%;&quot;
|- style=&quot;background: #bcbcff;&quot;
| style=&quot;border: none;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{2|{{ltt/core|{{{1|&amp;nbsp;}}}}}}}}&lt;/tt&gt;}}
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell on</title>
    <ns>10</ns>
    <id>1184</id>
    <revision>
      <id>19163</id>
      <parentid>2369</parentid>
      <timestamp>2012-02-27T14:34:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move to the main table</comment>
      <text xml:space="preserve" bytes="443">style = &quot;padding: 0 0 0 0;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0 0 0 0;&quot; &gt;
{| width=&quot;100%&quot; height=&quot;100%&quot; style=&quot;border-spacing: 0px; vertical-align: middle; padding: 0 0 0 0;&quot;
|- style=&quot;background: #bcbcff;&quot;
| style=&quot;border: 0; border-bottom: 1px solid #AAAAAA;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{2|&amp;nbsp;}}}&lt;/tt&gt;}}
|-  style=&quot;background: #bcffbc;&quot;
| style=&quot;border: 0;&quot; | {{cpp/container/table cell|&lt;tt&gt;{{{3|&amp;nbsp;}}}&lt;/tt&gt;}}
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/table cell oo</title>
    <ns>10</ns>
    <id>1185</id>
    <revision>
      <id>2371</id>
      <parentid>2370</parentid>
      <timestamp>2011-06-06T22:53:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="387">style = &quot;padding: 0 0 0 0;&quot; | [[ {{{1|cpp}}} | &lt;div style=&quot;padding: 0 0 0 0;&quot; &gt;
{| width=&quot;100%&quot; height=&quot;100%&quot; style=&quot;border-spacing: 0px; vertical-align: middle; text-align: center; padding: 0 0 0 0;&quot;
|- style=&quot;background: #bcbcff;&quot;
| style=&quot;border: 0; border-bottom: 1px solid #AAAAAA;&quot; | {{{2|&amp;nbsp;}}}
|-  style=&quot;background: #bcbcff;&quot;
| style=&quot;border: 0;&quot; | {{{3|&amp;nbsp;}}}
|}
&lt;/div&gt;]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unique</title>
    <ns>10</ns>
    <id>1207</id>
    <revision>
      <id>63854</id>
      <parentid>60859</parentid>
      <timestamp>2013-07-29T15:20:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{cpp/std}}</comment>
      <text xml:space="preserve" bytes="1285">{{cpp/container/{{{1|}}}/title | unique}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since={{cpp/std|{{{1|}}}}} |
void unique();
}}
{{dcl | num=2 | since={{cpp/std|{{{1|}}}}} |
template&lt; class BinaryPredicate &gt;
void unique( BinaryPredicate p );

}}
{{dcl end}}

Removes all ''consecutive'' duplicate elements from the container. Only the first element in each group of equal elements is left. The first version uses {{tt|operator{{==}}}} to compare the elements, the second version uses the given binary predicate {{tt|p}}.

===Parameters===
{{par begin}}
{{par pred2 eq | p | p1={{{1}}}&lt;T,Allocator&gt;::const_iterator}}
{{par end}}

===Return value===
(none)

===Complexity===
Linear in the size of the container

===Example===
{{example|code=
#include &lt;iostream&gt;
#include &lt;{{{1}}}&gt;

int main()
{
  std::{{{1}}}&lt;int&gt; x = {1, 2, 2, 3, 3, 2, 1, 1, 2};

  std::cout &lt;&lt; &quot;contents before:&quot;;
  for (auto val : x)
    std::cout &lt;&lt; ' ' &lt;&lt; val;
  std::cout &lt;&lt; '\n';

  x.unique();
  std::cout &lt;&lt; &quot;contents after unique():&quot;;
  for (auto val : x)
    std::cout &lt;&lt; ' ' &lt;&lt; val;
  std::cout &lt;&lt; '\n';

  return 0;
}
|output=
contents before: 1 2 2 3 3 2 1 1 2
contents after unique(): 1 2 3 2 1 2
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/algorithm/dsc unique}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/example empty</title>
    <ns>10</ns>
    <id>10027</id>
    <revision>
      <id>69152</id>
      <parentid>47721</parentid>
      <timestamp>2014-03-28T17:06:30Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="582">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::unordered_map&lt;int,int&gt;}} contains any elements:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;
 
int main()
{
    std::unordered_map&lt;int, int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.emplace(42, 13);
    numbers.insert(std::make_pair(13317, 123));  
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1>d9vqo4xbpajsvo4s5xacedh55vzs7lv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/example operator=</title>
    <ns>10</ns>
    <id>12822</id>
    <revision>
      <id>63229</id>
      <timestamp>2013-07-06T11:55:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1303">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::unordered_map}} to another:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;

void display_sizes(const std::unordered_map&lt;int, int&gt; &amp;nums1,
                   const std::unordered_map&lt;int, int&gt; &amp;nums2,
                   const std::unordered_map&lt;int, int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::unordered_map&lt;int, int&gt; nums1 {{3, 1}, {4, 1}, {5, 9}, 
                                        {6, 1}, {7, 1}, {8, 9}};
    std::unordered_map&lt;int, int&gt; nums2; 
    std::unordered_map&lt;int, int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/example size</title>
    <ns>10</ns>
    <id>10050</id>
    <revision>
      <id>52532</id>
      <parentid>47741</parentid>
      <timestamp>2013-06-01T04:48:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="376">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::unordered_map}}:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::unordered_map&lt;int,char&gt; nums {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/navbar</title>
    <ns>10</ns>
    <id>1208</id>
    <revision>
      <id>39884</id>
      <parentid>35586</parentid>
      <timestamp>2012-09-28T19:58:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="269">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/unordered_map/navbar heading
|content3 = cpp/container/unordered_map/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/navbar content</title>
    <ns>10</ns>
    <id>1209</id>
    <revision>
      <id>52533</id>
      <parentid>38146</parentid>
      <timestamp>2013-06-01T04:48:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1847">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/unordered_map/unordered_map }}
{{nv mem ln | cpp/container/unordered_map/~unordered_map }}
{{nv mem ln | cpp/container/unordered_map/operator{{=}} }}
{{nv mem ln | cpp/container/unordered_map/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/unordered_map/begin | begin | cbegin}}
{{nv mem ln | cpp/container/unordered_map/end | end | cend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/unordered_map/erase}}
{{nv mem ln | cpp/container/unordered_map/size}}
{{nv mem ln | cpp/container/unordered_map/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/unordered_map/clear}}
{{nv mem ln | cpp/container/unordered_map/insert}}
{{nv mem ln | cpp/container/unordered_map/emplace}}
{{nv mem ln | cpp/container/unordered_map/emplace_hint}}
{{nv mem ln | cpp/container/unordered_map/erase}}
{{nv mem ln | cpp/container/unordered_map/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/unordered_map/count}}
{{nv mem ln | cpp/container/unordered_map/find}}
{{nv mem ln | cpp/container/unordered_map/equal_range}}
{{nv h2 | Bucket interface}}
{{nv mem ln | cpp/container/unordered_map/begin2 }}
{{nv mem ln | cpp/container/unordered_map/end2 }}
{{nv mem ln | cpp/container/unordered_map/bucket_count}}
{{nv mem ln | cpp/container/unordered_map/max_bucket_count}}
{{nv mem ln | cpp/container/unordered_map/bucket_size}}
{{nv mem ln | cpp/container/unordered_map/bucket}}
{{nv h2 | Hash policy}}
{{nv mem ln | cpp/container/unordered_map/load_factor}}
{{nv mem ln | cpp/container/unordered_map/max_load_factor}}
{{nv mem ln | cpp/container/unordered_map/rehash}}
{{nv mem ln | cpp/container/unordered_map/reserve}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/unordered_map/hash_function}}
{{nv mem ln | cpp/container/unordered_map/key_eq}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/navbar heading</title>
    <ns>10</ns>
    <id>1210</id>
    <revision>
      <id>35588</id>
      <parentid>2421</parentid>
      <timestamp>2012-06-15T22:28:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/unordered map/sidebar heading]] to [[Template:cpp/container/unordered map/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="56">{{ltt|cpp/container/unordered_map | std::unordered_map}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered map/title</title>
    <ns>10</ns>
    <id>1211</id>
    <revision>
      <id>2423</id>
      <parentid>2422</parentid>
      <timestamp>2011-06-06T22:53:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=unordered_map::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/example empty</title>
    <ns>10</ns>
    <id>10028</id>
    <revision>
      <id>69153</id>
      <parentid>47720</parentid>
      <timestamp>2014-03-28T17:07:17Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <text xml:space="preserve" bytes="590">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::unordered_multimap&lt;int,int&gt;}} contains any elements:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;
#include &lt;utility&gt;

int main()
{
    std::unordered_multimap&lt;int, int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.emplace(42, 13);
    numbers.insert(std::make_pair(13317, 123)); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1>3vnz3z7sthcf2eyil4zhcz1fmlhe244</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/example operator=</title>
    <ns>10</ns>
    <id>12821</id>
    <revision>
      <id>63228</id>
      <timestamp>2013-07-06T11:55:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1333">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::unordered_multimap}} to another:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;

void display_sizes(const std::unordered_multimap&lt;int, int&gt; &amp;nums1,
                   const std::unordered_multimap&lt;int, int&gt; &amp;nums2,
                   const std::unordered_multimap&lt;int, int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::unordered_multimap&lt;int, int&gt; nums1 {{3, 1}, {4, 1}, {5, 9}, 
                                   {6, 1}, {7, 1}, {8, 9}};
    std::unordered_multimap&lt;int, int&gt; nums2; 
    std::unordered_multimap&lt;int, int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/example size</title>
    <ns>10</ns>
    <id>10049</id>
    <revision>
      <id>52534</id>
      <parentid>47740</parentid>
      <timestamp>2013-06-01T04:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="386">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{lc|std::unordered_multimap}}:
 | code=
#include &lt;unordered_map&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::unordered_multimap&lt;int,char&gt; nums {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/navbar</title>
    <ns>10</ns>
    <id>1212</id>
    <revision>
      <id>39885</id>
      <parentid>35589</parentid>
      <timestamp>2012-09-28T19:58:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="279">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/unordered_multimap/navbar heading
|content3 = cpp/container/unordered_multimap/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/navbar content</title>
    <ns>10</ns>
    <id>1213</id>
    <revision>
      <id>52535</id>
      <parentid>38147</parentid>
      <timestamp>2013-06-01T04:48:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2007">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/unordered_multimap/unordered_multimap }}
{{nv mem ln | cpp/container/unordered_multimap/~unordered_multimap }}
{{nv mem ln | cpp/container/unordered_multimap/operator{{=}} }}
{{nv mem ln | cpp/container/unordered_multimap/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/unordered_multimap/begin | begin | cbegin}}
{{nv mem ln | cpp/container/unordered_multimap/end | end | cend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/unordered_multimap/erase}}
{{nv mem ln | cpp/container/unordered_multimap/size}}
{{nv mem ln | cpp/container/unordered_multimap/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/unordered_multimap/clear}}
{{nv mem ln | cpp/container/unordered_multimap/insert}}
{{nv mem ln | cpp/container/unordered_multimap/emplace}}
{{nv mem ln | cpp/container/unordered_multimap/emplace_hint}}
{{nv mem ln | cpp/container/unordered_multimap/erase}}
{{nv mem ln | cpp/container/unordered_multimap/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/unordered_multimap/count}}
{{nv mem ln | cpp/container/unordered_multimap/find}}
{{nv mem ln | cpp/container/unordered_multimap/equal_range}}
{{nv h2 | Bucket interface}}
{{nv mem ln | cpp/container/unordered_multimap/begin2 }}
{{nv mem ln | cpp/container/unordered_multimap/end2 }}
{{nv mem ln | cpp/container/unordered_multimap/bucket_count}}
{{nv mem ln | cpp/container/unordered_multimap/max_bucket_count}}
{{nv mem ln | cpp/container/unordered_multimap/bucket_size}}
{{nv mem ln | cpp/container/unordered_multimap/bucket}}
{{nv h2 | Hash policy}}
{{nv mem ln | cpp/container/unordered_multimap/load_factor}}
{{nv mem ln | cpp/container/unordered_multimap/max_load_factor}}
{{nv mem ln | cpp/container/unordered_multimap/rehash}}
{{nv mem ln | cpp/container/unordered_multimap/reserve}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/unordered_multimap/hash_function}}
{{nv mem ln | cpp/container/unordered_multimap/key_eq}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/navbar heading</title>
    <ns>10</ns>
    <id>1214</id>
    <revision>
      <id>35591</id>
      <parentid>2429</parentid>
      <timestamp>2012-06-15T22:28:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/unordered multimap/sidebar heading]] to [[Template:cpp/container/unordered multimap/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="69">{{tt|[[cpp/container/unordered_multimap | std::unordered_multimap]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multimap/title</title>
    <ns>10</ns>
    <id>1215</id>
    <revision>
      <id>2431</id>
      <parentid>2430</parentid>
      <timestamp>2011-06-06T22:53:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=unordered_multimap::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/example empty</title>
    <ns>10</ns>
    <id>10029</id>
    <revision>
      <id>47708</id>
      <timestamp>2013-05-16T19:18:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="537">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::unordered_multiset&lt;int&gt;}} contains any elements:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::unordered_multiset&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.insert(42);
    numbers.insert(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/example operator=</title>
    <ns>10</ns>
    <id>12816</id>
    <revision>
      <id>69154</id>
      <parentid>63223</parentid>
      <timestamp>2014-03-28T17:13:28Z</timestamp>
      <contributor>
        <username>Pchriste</username>
        <id>2961</id>
      </contributor>
      <text xml:space="preserve" bytes="1237">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::unordered_multiset}} to another:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;

void display_sizes(const std::unordered_multiset&lt;int&gt; &amp;nums1,
                   const std::unordered_multiset&lt;int&gt; &amp;nums2,
                   const std::unordered_multiset&lt;int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::unordered_multiset&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::unordered_multiset&lt;int&gt; nums2; 
    std::unordered_multiset&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1>hq4x38h6ltqqs1ppteyyn4bwp6562la</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/example size</title>
    <ns>10</ns>
    <id>10040</id>
    <revision>
      <id>47729</id>
      <timestamp>2013-05-16T20:09:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="357">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{c|std::unordered_multiset&lt;int&gt;}}:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::unordered_multiset&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/navbar</title>
    <ns>10</ns>
    <id>1216</id>
    <revision>
      <id>39886</id>
      <parentid>35592</parentid>
      <timestamp>2012-09-28T19:58:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="279">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/unordered_multiset/navbar heading
|content3 = cpp/container/unordered_multiset/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/navbar content</title>
    <ns>10</ns>
    <id>1217</id>
    <revision>
      <id>52536</id>
      <parentid>38148</parentid>
      <timestamp>2013-06-01T04:48:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2007">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/unordered_multiset/unordered_multiset }}
{{nv mem ln | cpp/container/unordered_multiset/~unordered_multiset }}
{{nv mem ln | cpp/container/unordered_multiset/operator{{=}} }}
{{nv mem ln | cpp/container/unordered_multiset/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/unordered_multiset/begin | begin | cbegin}}
{{nv mem ln | cpp/container/unordered_multiset/end | end | cend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/unordered_multiset/erase}}
{{nv mem ln | cpp/container/unordered_multiset/size}}
{{nv mem ln | cpp/container/unordered_multiset/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/unordered_multiset/clear}}
{{nv mem ln | cpp/container/unordered_multiset/insert}}
{{nv mem ln | cpp/container/unordered_multiset/emplace}}
{{nv mem ln | cpp/container/unordered_multiset/emplace_hint}}
{{nv mem ln | cpp/container/unordered_multiset/erase}}
{{nv mem ln | cpp/container/unordered_multiset/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/unordered_multiset/count}}
{{nv mem ln | cpp/container/unordered_multiset/find}}
{{nv mem ln | cpp/container/unordered_multiset/equal_range}}
{{nv h2 | Bucket interface}}
{{nv mem ln | cpp/container/unordered_multiset/begin2 }}
{{nv mem ln | cpp/container/unordered_multiset/end2 }}
{{nv mem ln | cpp/container/unordered_multiset/bucket_count}}
{{nv mem ln | cpp/container/unordered_multiset/max_bucket_count}}
{{nv mem ln | cpp/container/unordered_multiset/bucket_size}}
{{nv mem ln | cpp/container/unordered_multiset/bucket}}
{{nv h2 | Hash policy}}
{{nv mem ln | cpp/container/unordered_multiset/load_factor}}
{{nv mem ln | cpp/container/unordered_multiset/max_load_factor}}
{{nv mem ln | cpp/container/unordered_multiset/rehash}}
{{nv mem ln | cpp/container/unordered_multiset/reserve}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/unordered_multiset/hash_function}}
{{nv mem ln | cpp/container/unordered_multiset/key_eq}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/navbar heading</title>
    <ns>10</ns>
    <id>1218</id>
    <revision>
      <id>35594</id>
      <parentid>2437</parentid>
      <timestamp>2012-06-15T22:29:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/unordered multiset/sidebar heading]] to [[Template:cpp/container/unordered multiset/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="69">{{tt|[[cpp/container/unordered_multiset | std::unordered_multiset]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered multiset/title</title>
    <ns>10</ns>
    <id>1219</id>
    <revision>
      <id>2439</id>
      <parentid>2438</parentid>
      <timestamp>2011-06-06T22:53:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=unordered_multiset::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/example empty</title>
    <ns>10</ns>
    <id>10030</id>
    <revision>
      <id>47709</id>
      <timestamp>2013-05-16T19:18:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="527">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::unordered_set&lt;int&gt;}} contains any elements:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::unordered_set&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.insert(42);
    numbers.insert(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/example operator=</title>
    <ns>10</ns>
    <id>12817</id>
    <revision>
      <id>63222</id>
      <timestamp>2013-07-06T11:50:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;{{example  | The following code uses {{tt|operator=}} to assign one {{c|std::unordered_set}} to another:  | code= #include &lt;unordered_set&gt; #include &lt;iostream&gt;  void display_si...&quot;</comment>
      <text xml:space="preserve" bytes="1202">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::unordered_set}} to another:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;

void display_sizes(const std::unordered_set&lt;int&gt; &amp;nums1,
                   const std::unordered_set&lt;int&gt; &amp;nums2,
                   const std::unordered_set&lt;int&gt; &amp;nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::unordered_set&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::unordered_set&lt;int&gt; nums2; 
    std::unordered_set&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/example size</title>
    <ns>10</ns>
    <id>10041</id>
    <revision>
      <id>47730</id>
      <timestamp>2013-05-16T20:09:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="347">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{c|std::unordered_set&lt;int&gt;}}:
 | code=
#include &lt;unordered_set&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::unordered_set&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/navbar</title>
    <ns>10</ns>
    <id>1220</id>
    <revision>
      <id>39887</id>
      <parentid>35541</parentid>
      <timestamp>2012-09-28T19:58:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="269">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/unordered_set/navbar heading
|content3 = cpp/container/unordered_set/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/navbar content</title>
    <ns>10</ns>
    <id>1221</id>
    <revision>
      <id>52537</id>
      <parentid>38149</parentid>
      <timestamp>2013-06-01T04:49:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1847">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/unordered_set/unordered_set }}
{{nv mem ln | cpp/container/unordered_set/~unordered_set }}
{{nv mem ln | cpp/container/unordered_set/operator{{=}} }}
{{nv mem ln | cpp/container/unordered_set/get_allocator }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/unordered_set/begin | begin | cbegin}}
{{nv mem ln | cpp/container/unordered_set/end | end | cend}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/unordered_set/erase}}
{{nv mem ln | cpp/container/unordered_set/size}}
{{nv mem ln | cpp/container/unordered_set/max_size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/unordered_set/clear}}
{{nv mem ln | cpp/container/unordered_set/insert}}
{{nv mem ln | cpp/container/unordered_set/emplace}}
{{nv mem ln | cpp/container/unordered_set/emplace_hint}}
{{nv mem ln | cpp/container/unordered_set/erase}}
{{nv mem ln | cpp/container/unordered_set/swap}}
{{nv h2 | Lookup}}
{{nv mem ln | cpp/container/unordered_set/count}}
{{nv mem ln | cpp/container/unordered_set/find}}
{{nv mem ln | cpp/container/unordered_set/equal_range}}
{{nv h2 | Bucket interface}}
{{nv mem ln | cpp/container/unordered_set/begin2 }}
{{nv mem ln | cpp/container/unordered_set/end2 }}
{{nv mem ln | cpp/container/unordered_set/bucket_count}}
{{nv mem ln | cpp/container/unordered_set/max_bucket_count}}
{{nv mem ln | cpp/container/unordered_set/bucket_size}}
{{nv mem ln | cpp/container/unordered_set/bucket}}
{{nv h2 | Hash policy}}
{{nv mem ln | cpp/container/unordered_set/load_factor}}
{{nv mem ln | cpp/container/unordered_set/max_load_factor}}
{{nv mem ln | cpp/container/unordered_set/rehash}}
{{nv mem ln | cpp/container/unordered_set/reserve}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/container/unordered_set/hash_function}}
{{nv mem ln | cpp/container/unordered_set/key_eq}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/navbar heading</title>
    <ns>10</ns>
    <id>1222</id>
    <revision>
      <id>35244</id>
      <parentid>2445</parentid>
      <timestamp>2012-06-15T22:20:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/unordered set/sidebar heading]] to [[Template:cpp/container/unordered set/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="59">{{tt|[[cpp/container/unordered_set | std::unordered_set]]}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/unordered set/title</title>
    <ns>10</ns>
    <id>1223</id>
    <revision>
      <id>2447</id>
      <parentid>2446</parentid>
      <timestamp>2011-06-06T22:53:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=unordered_set::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/upper bound</title>
    <ns>10</ns>
    <id>1224</id>
    <revision>
      <id>65134</id>
      <parentid>65133</parentid>
      <timestamp>2013-08-30T16:38:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1362">{{cpp/container/{{{1|}}}/title | upper_bound}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |num=1|
iterator upper_bound( const Key&amp; key );
}}
{{dcl |num=1|
const_iterator upper_bound( const Key&amp; key ) const;
}}
{{dcl | num=2 | since=c++14 |
template&lt; class K &gt; 
iterator upper_bound( const K&amp; x );
}}
{{dcl | num=2 | since=c++14 |
template&lt; class K &gt; 
const_iterator upper_bound( const K&amp; x ) const;
}}
{{dcl end}}

@1@ Returns an iterator pointing to the first element that is ''greater'' than {{tt|key}}.

@2@ Returns an iterator pointing to the first element that compares ''greater'' to the value {{tt|x}}. These templates only participate in overload resolution if the type {{c|Compare::is_transparent}} exists. They allow calling this function without constructing an instance of {{tt|Key}}.

===Parameters===
{{par begin}}
{{par | key | key value to compare the elements to}}
{{par | x | alternative value that can be compared to {{tt|Key}} }}
{{par end}} 

===Return value===
Iterator pointing to the first element that is ''greater'' than {{tt|key}}. If no such element is found, past-the-end (see {{lc|end()}}) iterator is returned.

===Complexity===
Logarithmic in the size of the container.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc equal_range |{{{1|}}}}}
{{dsc inc | cpp/container/dsc lower_bound |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/uses allocator</title>
    <ns>10</ns>
    <id>3404</id>
    <revision>
      <id>63588</id>
      <parentid>61344</parentid>
      <timestamp>2013-07-10T01:44:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="729">{{cpp/title | uses_allocator&lt;small&gt;&lt;std::{{{1}}}&gt;&lt;/small&gt;}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |1=
template&lt; class T, class Container, {{#ifeq:{{{1|}}}|priority_queue|class Compare,}}class Alloc &gt;
struct uses_allocator&lt;{{{1}}}&lt;T,{{#ifeq:{{{1|}}}|priority_queue|Compare,}}Container&gt;,Alloc&gt; : 
    std::uses_allocator&lt;Container, Alloc&gt;::type { };
}}
{{dcl end}}

Provides a transparent specialization of the {{lc|std::uses_allocator}} type trait for {{c|std::{{{1}}}}}: the container adaptor uses allocator if and only if the underlying container does. 

{{cpp/types/integral_constant/inherit2 |{{c|true}}|bool}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc uses_allocator}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/value comp</title>
    <ns>10</ns>
    <id>1225</id>
    <revision>
      <id>67369</id>
      <parentid>64350</parentid>
      <timestamp>2014-02-06T15:17:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention that key_comp is used to do the key comparison in map's value_comp</comment>
      <text xml:space="preserve" bytes="707">{{cpp/container/{{{1|}}}/title | value_comp}}
{{cpp/container/{{trim|{{{1|}}}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
std::{{{1}}}::value_compare value_comp() const;
}}
{{dcl end}}

{{cpp/container/if map | {{{1|}}}
 |Returns a function object that compares objects of type std::{{{1}}}::value_type (key-value pairs) by using {{lc|key_comp}} to compare the first components of the pairs.
 |Returns the function object that compares the values. It is the same as {{lc|key_comp}}.
}}

===Parameters===
(none)

===Return value===
The value comparison function object.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc key_comp |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>iep4x5k3421k3mb578qb58bvhvxu13u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/value compare</title>
    <ns>10</ns>
    <id>3616</id>
    <revision>
      <id>62253</id>
      <parentid>62252</parentid>
      <timestamp>2013-06-25T12:40:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="1675">{{cpp/container/{{{1|}}}/title | value_compare}}
{{cpp/container/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
class value_compare;
}}
{{dcl end}}

{{tt|std::{{{1}}}::value_compare}} is a function object that compares objects of type {{tt|std::{{{1}}}::value_type}} (key-value pairs) by comparing of the first components of the pairs.

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|result_type}} | {{c|bool}} }}
{{dsc | {{tt|first_argument_type}} | {{tt|value_type}} }}
{{dsc | {{tt|second_argument_type}} | {{tt|value_type}} }}
{{dsc end}}

===Protected member objects===
{{dsc begin}}
{{dsc hitem | Name | Type}}
{{dsc | {{tt|comp}} | {{tt|Compare}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/container/value_compare/dsc constructor | {{{1|}}} }}
{{dsc inc | cpp/container/value_compare/dsc operator() | {{{1|}}} }}
{{dsc end}}

{{member | {{small|std::{{{1|}}}&lt;Key,T,Compare,Alloc&gt;::value_compare::}}value_compare | 2=
{{dcl begin}}
{{dcl |
protected:
value_compare( Compare c );
}}
{{dcl end}}

Initializes the internal instance of the comparator to {{tt|c}}.

===Parameters===
{{par begin}}
{{par | c | comparator to assign}}
{{par end}}
}}

{{member | {{small|std::{{{1|}}}&lt;Key,T,Compare,Alloc&gt;::value_compare::}}operator() | 2=
{{dcl begin}}
{{dcl | 1=
bool operator()( const value_type&amp; lhs, const value_type&amp; rhs ) const;
}}
{{dcl end}}

Compares {{tt|lhs.first}} and {{tt|rhs.first}} by calling the stored comparator.

===Parameters===
{{par begin}}
{{par | lhs, rhs | values to compare}}
{{par end}}

===Return value===
{{c|comp(lhs.first, rhs.first)}}.

===Exceptions===
(none)
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/value compare/dsc constructor</title>
    <ns>10</ns>
    <id>6395</id>
    <revision>
      <id>55465</id>
      <parentid>52542</parentid>
      <timestamp>2013-06-01T05:23:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/value compare/dcl list constructor]] to [[Template:cpp/container/value compare/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc prot mem ctor | cpp/container/{{{1|}}}/value_compare | inlinemem=true | constructs a new {{tt|value_compare}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/value compare/dsc operator()</title>
    <ns>10</ns>
    <id>5001</id>
    <revision>
      <id>55468</id>
      <parentid>52543</parentid>
      <timestamp>2013-06-01T05:23:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/value compare/dcl list operator()]] to [[Template:cpp/container/value compare/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc mem fun | cpp/container/{{{1|}}}/value_compare | title=operator() | inlinemem=true | compares two values of type {{tt|value_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/example empty</title>
    <ns>10</ns>
    <id>10031</id>
    <revision>
      <id>47710</id>
      <timestamp>2013-05-16T19:18:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="512">{{example
 | The following code uses {{tt|empty}} to check if a {{c|std::vector&lt;int&gt;}} contains any elements:
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
 
int main()
{
    std::vector&lt;int&gt; numbers;
    std::cout &lt;&lt; &quot;Initially, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';

    numbers.push_back(42);
    numbers.push_back(13317); 
    std::cout &lt;&lt; &quot;After adding elements, numbers.empty(): &quot; &lt;&lt; numbers.empty() &lt;&lt; '\n';
}
 | output=
Initially, numbers.empty(): 1
After adding elements, numbers.empty(): 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/example operator=</title>
    <ns>10</ns>
    <id>12824</id>
    <revision>
      <id>63231</id>
      <timestamp>2013-07-06T11:58:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1146">{{example
 | The following code uses {{tt|operator=}} to assign one {{c|std::vector}} to another:
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;

void display_sizes(const std::vector&lt;int&gt;&amp; nums1,
                   const std::vector&lt;int&gt;&amp; nums2,
                   const std::vector&lt;int&gt;&amp; nums3)
{
    std::cout &lt;&lt; &quot;nums1: &quot; &lt;&lt; nums1.size() 
              &lt;&lt; &quot; nums2: &quot; &lt;&lt; nums2.size()
              &lt;&lt; &quot; nums3: &quot; &lt;&lt; nums3.size() &lt;&lt; '\n';
}

int main()
{
    std::vector&lt;int&gt; nums1 {3, 1, 4, 6, 5, 9};
    std::vector&lt;int&gt; nums2; 
    std::vector&lt;int&gt; nums3;

    std::cout &lt;&lt; &quot;Initially:\n&quot;;
    display_sizes(nums1, nums2, nums3);

    // copy assignment copies data from nums1 to nums2
    nums2 = nums1;

    std::cout &lt;&lt; &quot;After assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
 
    // move assignment moves data from nums1 to nums3,
    // modifying both nums1 and nums3
    nums3 = std::move(nums1);

    std::cout &lt;&lt; &quot;After move assigment:\n&quot;; 
    display_sizes(nums1, nums2, nums3);
}
 | output=
Initially:
nums1: 6 nums2: 0 nums3: 0
After assigment:
nums1: 6 nums2: 6 nums3: 0
After move assigment:
nums1: 0 nums2: 6 nums3: 6
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/example shrink to fit</title>
    <ns>10</ns>
    <id>9953</id>
    <revision>
      <id>47814</id>
      <parentid>47257</parentid>
      <timestamp>2013-05-16T22:06:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/vector/shrink to fit example]] to [[Template:cpp/container/vector/example shrink to fit]]</comment>
      <text xml:space="preserve" bytes="627">{{example
 |
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;vector&gt;

int main()
{
    std::vector&lt;int&gt; v;
    std::cout &lt;&lt; &quot;Default-constructed capacity is &quot; &lt;&lt; v.capacity() &lt;&lt; '\n';
    v.resize(100);
    std::cout &lt;&lt; &quot;Capacity of a 100-element vector is &quot; &lt;&lt; v.capacity() &lt;&lt; '\n';
    v.clear();
    std::cout &lt;&lt; &quot;Capacity after clear() is &quot; &lt;&lt; v.capacity() &lt;&lt; '\n';
    v.shrink_to_fit();
    std::cout &lt;&lt; &quot;Capacity after shrink_to_fit() is &quot; &lt;&lt; v.capacity() &lt;&lt; '\n';
}
| output=
Default-constructed capacity is 0
Capacity of a 100-element vector is 100
Capacity after clear() is 100
Capacity after shrink_to_fit() is 0
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/example size</title>
    <ns>10</ns>
    <id>10042</id>
    <revision>
      <id>47731</id>
      <timestamp>2013-05-16T20:10:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="326">{{example
 | The following code uses {{tt|size}} to display the number of elements in a {{c|std::vector&lt;int&gt;}}:
 | code=
#include &lt;vector&gt;
#include &lt;iostream&gt;
 
int main()
{ 
    std::vector&lt;int&gt; nums {1, 3, 5, 7};
 
    std::cout &lt;&lt; &quot;nums contains &quot; &lt;&lt; nums.size() &lt;&lt; &quot; elements.\n&quot;;
}
 | output=
nums contains 4 elements.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/navbar</title>
    <ns>10</ns>
    <id>1226</id>
    <revision>
      <id>47781</id>
      <parentid>39888</parentid>
      <timestamp>2013-05-16T20:26:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/vector/navbar heading
|content3 = cpp/container/vector/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/navbar content</title>
    <ns>10</ns>
    <id>1227</id>
    <revision>
      <id>52544</id>
      <parentid>45463</parentid>
      <timestamp>2013-06-01T04:49:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1726">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/vector/vector }}
{{nv mem ln | cpp/container/vector/~vector }}
{{nv mem ln | cpp/container/vector/operator{{=}} }}
{{nv mem ln | cpp/container/vector/assign }}
{{nv mem ln | cpp/container/vector/get_allocator }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/vector/at }}
{{nv mem ln | cpp/container/vector/operator_at | operator[] }}
{{nv mem ln | cpp/container/vector/front }}
{{nv mem ln | cpp/container/vector/back }}
{{nv mem ln | cpp/container/vector/data|notes={{mark c++11}}}}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/vector/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/vector/empty}}
{{nv mem ln | cpp/container/vector/size}}
{{nv mem ln | cpp/container/vector/max_size}}
{{nv mem ln | cpp/container/vector/reserve}}
{{nv mem ln | cpp/container/vector/capacity}}
{{nv mem ln | cpp/container/vector/shrink_to_fit | notes={{mark c++11}}}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/vector/clear}}
{{nv mem ln | cpp/container/vector/insert}}
{{nv mem ln | cpp/container/vector/emplace | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/vector/erase}}
{{nv mem ln | cpp/container/vector/push_back}}
{{nv mem ln | cpp/container/vector/emplace_back | notes={{mark c++11}}}}
{{nv mem ln | cpp/container/vector/pop_back}}
{{nv mem ln | cpp/container/vector/resize}}
{{nv mem ln | cpp/container/vector/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/navbar heading</title>
    <ns>10</ns>
    <id>1228</id>
    <revision>
      <id>47756</id>
      <parentid>35598</parentid>
      <timestamp>2013-05-16T20:22:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="40">{{ltt|cpp/container/vector|std::vector}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector/title</title>
    <ns>10</ns>
    <id>1229</id>
    <revision>
      <id>2459</id>
      <parentid>2458</parentid>
      <timestamp>2011-06-06T22:53:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=vector::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc emplace</title>
    <ns>10</ns>
    <id>13462</id>
    <revision>
      <id>68715</id>
      <timestamp>2014-03-20T02:27:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/container/vector/emplace | constructs element in-place | notes={{mark since c++14}} }}</text>
      <sha1>jp01ldw9t3m9dk2js5iaj6lhwobrht2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc emplace back</title>
    <ns>10</ns>
    <id>13463</id>
    <revision>
      <id>68716</id>
      <timestamp>2014-03-20T02:27:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">{{dsc mem fun | cpp/container/vector/emplace_back | constructs elements in-place at the end | notes={{mark c++14}} }}</text>
      <sha1>938wu5yqe4nrljkelrrxmv3482yg9j0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc flip</title>
    <ns>10</ns>
    <id>5552</id>
    <revision>
      <id>55470</id>
      <parentid>52545</parentid>
      <timestamp>2013-06-01T05:24:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/vector bool/dcl list flip]] to [[Template:cpp/container/vector bool/dsc flip]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/container/vector_bool/flip | title=flip | flips all the bits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc hash</title>
    <ns>10</ns>
    <id>9782</id>
    <revision>
      <id>55473</id>
      <parentid>52546</parentid>
      <timestamp>2013-06-01T05:24:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/vector bool/dcl list hash]] to [[Template:cpp/container/vector bool/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc ptclass | cpp/container/vector_bool/hash | title=std::hash{{dsc small|&lt;std::vector&lt;bool&gt;&gt;}} | hash support for {{c|std::vector&lt;bool&gt;}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc swap</title>
    <ns>10</ns>
    <id>5563</id>
    <revision>
      <id>55479</id>
      <parentid>52547</parentid>
      <timestamp>2013-06-01T05:24:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/vector bool/dcl list swap]] to [[Template:cpp/container/vector bool/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem sfun | cpp/container/vector_bool/swap | title=swap | swaps two {{tt|std::vector&lt;bool&gt;::reference}}s}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/dsc swap2</title>
    <ns>10</ns>
    <id>5560</id>
    <revision>
      <id>63852</id>
      <parentid>60864</parentid>
      <timestamp>2013-07-29T15:19:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="608">{{cpp/title | swap&lt;small&gt;(std::vector&lt;bool&gt;)&lt;/small&gt;}}
{{cpp/container/vector_bool/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class T, class Alloc &gt;
void swap( {{{1}}}&lt;T,Alloc&gt; &amp;lhs, {{{1}}}&lt;T,Alloc&gt; &amp;rhs );
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{c|std::vector&lt;bool&gt;}}. Swaps the contents of {{tt|lhs}} and {{tt|rhs}}. Calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | containers whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/container/dsc swap |vector}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/navbar</title>
    <ns>10</ns>
    <id>5549</id>
    <revision>
      <id>39889</id>
      <parentid>35599</parentid>
      <timestamp>2012-09-28T19:58:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="265">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/container/navbar heading
|content2 = cpp/container/navbar content

|heading3 = cpp/container/vector_bool/navbar heading
|content3 = cpp/container/vector_bool/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/navbar content</title>
    <ns>10</ns>
    <id>5550</id>
    <revision>
      <id>52549</id>
      <parentid>45465</parentid>
      <timestamp>2013-06-01T04:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1730">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/container/vector/vector }}
{{nv mem ln | cpp/container/vector/~vector }}
{{nv mem ln | cpp/container/vector/operator{{=}} }}
{{nv mem ln | cpp/container/vector/assign }}
{{nv mem ln | cpp/container/vector/get_allocator }}
{{nv h2 | Element access}}
{{nv mem ln | cpp/container/vector/at }}
{{nv mem ln | cpp/container/vector/operator_at | operator[] }}
{{nv mem ln | cpp/container/vector/front }}
{{nv mem ln | cpp/container/vector/back }}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/container/vector/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/container/vector/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/container/vector/empty}}
{{nv mem ln | cpp/container/vector/size}}
{{nv mem ln | cpp/container/vector/max_size}}
{{nv mem ln | cpp/container/vector/reserve}}
{{nv mem ln | cpp/container/vector/capacity}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/container/vector/clear}}
{{nv mem ln | cpp/container/vector/insert}}
{{nv mem ln | cpp/container/vector/erase}}
{{nv mem ln | cpp/container/vector/push_back}}
{{nv mem ln | cpp/container/vector/pop_back}}
{{nv mem ln | cpp/container/vector/resize}}
{{nv mem ln | cpp/container/vector/swap}}
{{nv h2 | Helper classes}}
{{nv ln | cpp/container/vector_bool/hash | std::hash | notes={{mark c++11}}}}
{{nv h2 | std::vector&lt;bool&gt; specific}}
{{nv | {{ltt|cpp/container/vector_bool/flip | vector&lt;bool&gt;::flip}}}}
{{nv | {{ltt|cpp/container/vector_bool/swap | vector&lt;bool&gt;::swap}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/navbar heading</title>
    <ns>10</ns>
    <id>5551</id>
    <revision>
      <id>48103</id>
      <parentid>35601</parentid>
      <timestamp>2013-05-18T18:12:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/container/vector|std::vector&lt;bool&gt;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/reference/dsc operator bool</title>
    <ns>10</ns>
    <id>9932</id>
    <revision>
      <id>55487</id>
      <parentid>52550</parentid>
      <timestamp>2013-06-01T05:24:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/container/vector bool/reference/dcl list operator bool]] to [[Template:cpp/container/vector bool/reference/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/container/vector_bool/reference | title=operator bool | inlinemem=true | returns the referenced bit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/reference/title</title>
    <ns>10</ns>
    <id>8555</id>
    <revision>
      <id>31715</id>
      <parentid>31714</parentid>
      <timestamp>2012-06-06T20:41:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>vector-&gt;vector bool</comment>
      <text xml:space="preserve" bytes="128">&lt;onlyinclude&gt;{{cpp/container/vector bool/title | n=reference::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container/vector bool/title</title>
    <ns>10</ns>
    <id>5568</id>
    <revision>
      <id>20509</id>
      <timestamp>2012-03-27T23:43:46Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added title</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=vector&lt;bool&gt;::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/container adaptor/operator cmp</title>
    <ns>10</ns>
    <id>9090</id>
    <revision>
      <id>52551</id>
      <parentid>47050</parentid>
      <timestamp>2013-06-01T04:49:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1582">{{title | 1=operator==,!=,&lt;,&lt;=,&gt;,&gt;={{small|(std::{{{1}}})}}}}
{{cpp/container/{{{1|}}}/navbar}}
{{cpp/container/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; {{#var:types}} &gt;
bool operator!=( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; {{#var:types}} &gt;
bool operator&lt;( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; {{#var:types}} &gt;
bool operator&lt;=( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=5 | 1=
template&lt; {{#var:types}} &gt;
bool operator&gt;( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=6 | 1=
template&lt; {{#var:types}} &gt;
bool operator&gt;=( {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl end}}

Compares the contents of the underlying containers of two container adaptors. The comparison is done by applying the corresponding operator to the underlying containers.

===Parameters===
{{par begin}}
{{par | lhs, rhs | container adaptors whose contents to compare}}
{{par req concept | T | EqualityComparable}}
{{par end}} 

===Return value===
{{c|true}} if the corresponding comparison yields {{c|true}}, {{c|false}} otherwise.

===Complexity===
Linear in the size of the container</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/bad exception/navbar</title>
    <ns>10</ns>
    <id>8990</id>
    <revision>
      <id>39890</id>
      <parentid>37797</parentid>
      <timestamp>2012-09-28T19:58:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="330">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/bad_exception/navbar heading
|content4 = cpp/error/bad_exception/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/bad exception/navbar content</title>
    <ns>10</ns>
    <id>8992</id>
    <revision>
      <id>52552</id>
      <parentid>37799</parentid>
      <timestamp>2013-06-01T04:49:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="205">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/bad_exception/bad_exception}}
{{nv mem ln | cpp/error/bad_exception/operator{{=}}}}
{{nv mem ln | cpp/error/bad_exception/what}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/bad exception/navbar heading</title>
    <ns>10</ns>
    <id>8991</id>
    <revision>
      <id>60987</id>
      <parentid>37798</parentid>
      <timestamp>2013-06-03T11:42:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="50">{{ltt|cpp/error/bad_exception|std::bad_exception}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/bad exception/title</title>
    <ns>10</ns>
    <id>8993</id>
    <revision>
      <id>37800</id>
      <timestamp>2012-07-18T23:52:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=bad_exception::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/domain error/navbar</title>
    <ns>10</ns>
    <id>2093</id>
    <revision>
      <id>39891</id>
      <parentid>35992</parentid>
      <timestamp>2012-09-28T19:58:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/domain_error/navbar heading
|content4 = cpp/error/domain_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/domain error/navbar content</title>
    <ns>10</ns>
    <id>2552</id>
    <revision>
      <id>52585</id>
      <parentid>35233</parentid>
      <timestamp>2013-06-01T04:50:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="154">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/domain_error/domain_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/domain error/navbar heading</title>
    <ns>10</ns>
    <id>2107</id>
    <revision>
      <id>34865</id>
      <parentid>26312</parentid>
      <timestamp>2012-06-15T22:12:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/domain error/sidebar heading]] to [[Template:cpp/error/domain error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">{{ltt|cpp/error/domain_error|std::domain_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc assert</title>
    <ns>10</ns>
    <id>6399</id>
    <revision>
      <id>55492</id>
      <parentid>52553</parentid>
      <timestamp>2013-06-01T05:24:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list assert]] to [[Template:cpp/error/dsc assert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc macro fun | cpp/error/assert | aborts the program if the user-specified condition is not {{c|true}}. May be disabled for release builds}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc bad exception</title>
    <ns>10</ns>
    <id>3508</id>
    <revision>
      <id>55494</id>
      <parentid>52554</parentid>
      <timestamp>2013-06-01T05:24:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list bad exception]] to [[Template:cpp/error/dsc bad exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc class | cpp/error/bad_exception | exception thrown when dynamic exception specification is violated, if possible}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc current exception</title>
    <ns>10</ns>
    <id>3498</id>
    <revision>
      <id>55496</id>
      <parentid>52555</parentid>
      <timestamp>2013-06-01T05:24:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list current exception]] to [[Template:cpp/error/dsc current exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/error/current_exception | captures the current exception in a {{lc|std::exception_ptr}}| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc errc</title>
    <ns>10</ns>
    <id>4783</id>
    <revision>
      <id>55499</id>
      <parentid>52556</parentid>
      <timestamp>2013-06-01T05:24:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list errc]] to [[Template:cpp/error/dsc errc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc class  | cpp/error/errc | the {{lc|std::error_condition}} enumeration listing all standard {{header|cerrno}} macro constants| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc errno</title>
    <ns>10</ns>
    <id>5445</id>
    <revision>
      <id>55501</id>
      <parentid>52557</parentid>
      <timestamp>2013-06-01T05:24:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list errno]] to [[Template:cpp/error/dsc errno]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc | {{dsc member | cpp/error/errno | errno }} | macro which expands to POSIX-compatible thread-local error number variable&lt;br/&gt;{{mark|macro variable}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc errno macros</title>
    <ns>10</ns>
    <id>5446</id>
    <revision>
      <id>55504</id>
      <parentid>52558</parentid>
      <timestamp>2013-06-01T05:24:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list errno macros]] to [[Template:cpp/error/dsc errno macros]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc macro const | cpp/error/errno_macros | title=E2BIG, EACCES, ..., EXDEV | macros for standard POSIX-compatible error conditions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc error category</title>
    <ns>10</ns>
    <id>4773</id>
    <revision>
      <id>55506</id>
      <parentid>52559</parentid>
      <timestamp>2013-06-01T05:24:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list error category]] to [[Template:cpp/error/dsc error category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc class  | cpp/error/error_category | base class for error categories | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc error code</title>
    <ns>10</ns>
    <id>4784</id>
    <revision>
      <id>55510</id>
      <parentid>52560</parentid>
      <timestamp>2013-06-01T05:24:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list error code]] to [[Template:cpp/error/dsc error code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc class  | cpp/error/error_code | holds a platform-dependent error code | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc error condition</title>
    <ns>10</ns>
    <id>4780</id>
    <revision>
      <id>55516</id>
      <parentid>52561</parentid>
      <timestamp>2013-06-01T05:24:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list error condition]] to [[Template:cpp/error/dsc error condition]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc class  | cpp/error/error_condition | holds a portable error code| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc exception</title>
    <ns>10</ns>
    <id>3494</id>
    <revision>
      <id>55520</id>
      <parentid>52562</parentid>
      <timestamp>2013-06-01T05:24:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list exception]] to [[Template:cpp/error/dsc exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc class | cpp/error/exception | base class for exceptions thrown by the standard library components}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc exception ptr</title>
    <ns>10</ns>
    <id>3496</id>
    <revision>
      <id>55522</id>
      <parentid>52563</parentid>
      <timestamp>2013-06-01T05:24:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list exception ptr]] to [[Template:cpp/error/dsc exception ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc typedef | cpp/error/exception_ptr | shared pointer type for handling exception objects | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc generic category</title>
    <ns>10</ns>
    <id>4778</id>
    <revision>
      <id>55525</id>
      <parentid>52564</parentid>
      <timestamp>2013-06-01T05:24:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list generic category]] to [[Template:cpp/error/dsc generic category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/error/generic_category | identifies the generic error category | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc get terminate</title>
    <ns>10</ns>
    <id>3505</id>
    <revision>
      <id>55527</id>
      <parentid>52565</parentid>
      <timestamp>2013-06-01T05:24:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list get terminate]] to [[Template:cpp/error/dsc get terminate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/error/get_terminate | obtains the current terminate_handler | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc get unexpected</title>
    <ns>10</ns>
    <id>3510</id>
    <revision>
      <id>55530</id>
      <parentid>52566</parentid>
      <timestamp>2013-06-01T05:24:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list get unexpected]] to [[Template:cpp/error/dsc get unexpected]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | cpp/error/get_unexpected | notes={{mark c++11}}{{mark deprecated}} | obtains the current unexpected_handler}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc make exception ptr</title>
    <ns>10</ns>
    <id>3497</id>
    <revision>
      <id>55553</id>
      <parentid>52571</parentid>
      <timestamp>2013-06-01T05:24:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list make exception ptr]] to [[Template:cpp/error/dsc make exception ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc tfun | cpp/error/make_exception_ptr | creates an {{lc|std::exception_ptr}} from an exception object| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc nested exception</title>
    <ns>10</ns>
    <id>3500</id>
    <revision>
      <id>55557</id>
      <parentid>52572</parentid>
      <timestamp>2013-06-01T05:24:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list nested exception]] to [[Template:cpp/error/dsc nested exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc class | cpp/error/nested_exception | a mixin type to capture and store current exceptions| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc rethrow exception</title>
    <ns>10</ns>
    <id>3499</id>
    <revision>
      <id>55560</id>
      <parentid>52573</parentid>
      <timestamp>2013-06-01T05:24:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list rethrow exception]] to [[Template:cpp/error/dsc rethrow exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | cpp/error/rethrow_exception | throws the exception from an {{lc|std::exception_ptr}}| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc rethrow if nested</title>
    <ns>10</ns>
    <id>3502</id>
    <revision>
      <id>55563</id>
      <parentid>52574</parentid>
      <timestamp>2013-06-01T05:25:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list rethrow if nested]] to [[Template:cpp/error/dsc rethrow if nested]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/error/rethrow_if_nested | throws the exception from a {{lc|std::nested_exception}}| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc set terminate</title>
    <ns>10</ns>
    <id>3506</id>
    <revision>
      <id>55567</id>
      <parentid>52575</parentid>
      <timestamp>2013-06-01T05:25:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list set terminate]] to [[Template:cpp/error/dsc set terminate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | cpp/error/set_terminate | changes the function to be called by {{lc|std::terminate}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc set unexpected</title>
    <ns>10</ns>
    <id>3511</id>
    <revision>
      <id>55570</id>
      <parentid>52576</parentid>
      <timestamp>2013-06-01T05:25:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list set unexpected]] to [[Template:cpp/error/dsc set unexpected]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc fun | cpp/error/set_unexpected | notes={{mark deprecated}} | changes the function to be called by {{lc|std::unexpected}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc system category</title>
    <ns>10</ns>
    <id>4779</id>
    <revision>
      <id>55576</id>
      <parentid>52577</parentid>
      <timestamp>2013-06-01T05:25:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list system category]] to [[Template:cpp/error/dsc system category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | cpp/error/system_category | identifies the operating system error category | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc system error</title>
    <ns>10</ns>
    <id>4787</id>
    <revision>
      <id>55579</id>
      <parentid>52578</parentid>
      <timestamp>2013-06-01T05:25:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list system error]] to [[Template:cpp/error/dsc system error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc class  | cpp/error/system_error | exception class used to report conditions that have an error_code| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc terminate</title>
    <ns>10</ns>
    <id>3503</id>
    <revision>
      <id>55581</id>
      <parentid>52579</parentid>
      <timestamp>2013-06-01T05:25:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list terminate]] to [[Template:cpp/error/dsc terminate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | cpp/error/terminate | function called when exception handling fails}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc terminate handler</title>
    <ns>10</ns>
    <id>3504</id>
    <revision>
      <id>55583</id>
      <parentid>52580</parentid>
      <timestamp>2013-06-01T05:25:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list terminate handler]] to [[Template:cpp/error/dsc terminate handler]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc typedef | cpp/error/terminate_handler | the type of the function called by {{lc|std::terminate}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc throw with nested</title>
    <ns>10</ns>
    <id>3501</id>
    <revision>
      <id>55586</id>
      <parentid>52581</parentid>
      <timestamp>2013-06-01T05:25:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list throw with nested]] to [[Template:cpp/error/dsc throw with nested]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc tfun | cpp/error/throw_with_nested | throws its argument with {{lc|std::nested_exception}} mixed in| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc uncaught exception</title>
    <ns>10</ns>
    <id>3495</id>
    <revision>
      <id>55589</id>
      <parentid>52582</parentid>
      <timestamp>2013-06-01T05:25:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list uncaught exception]] to [[Template:cpp/error/dsc uncaught exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | cpp/error/uncaught_exception | checks if exception handling is currently in progress}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc unexpected</title>
    <ns>10</ns>
    <id>3507</id>
    <revision>
      <id>55593</id>
      <parentid>52583</parentid>
      <timestamp>2013-06-01T05:25:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list unexpected]] to [[Template:cpp/error/dsc unexpected]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc fun | cpp/error/unexpected | notes={{mark deprecated}} | function called when dynamic exception specification is violated}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/dsc unexpected handler</title>
    <ns>10</ns>
    <id>3509</id>
    <revision>
      <id>55599</id>
      <parentid>52584</parentid>
      <timestamp>2013-06-01T05:25:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/dcl list unexpected handler]] to [[Template:cpp/error/dsc unexpected handler]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc typedef | cpp/error/unexpected_handler | notes={{mark deprecated}} |  the type of the function called by {{lc|std::unexpected}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/dsc is error condition enum</title>
    <ns>10</ns>
    <id>12624</id>
    <revision>
      <id>61329</id>
      <timestamp>2013-06-05T21:38:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="258">{{dsc tfun | cpp/error/errc/is_error_condition_enum  | title=is_error_condition_enum{{dsc small|&lt;std::errc&gt;}}| notes={{mark c++11}} | extends the type trait {{lc|std::is_error_condition_enum}} to identify the the {{lc|std::errc}} values as error conditions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/dsc make error code</title>
    <ns>10</ns>
    <id>12633</id>
    <revision>
      <id>61330</id>
      <timestamp>2013-06-05T21:38:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="160">{{dsc fun | cpp/error/errc/make_error_code | title=make_error_code{{dsc small|(std::errc)}} | notes={{mark c++11}} | constructs an {{lc|std::errc}} error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/dsc make error condition</title>
    <ns>10</ns>
    <id>12632</id>
    <revision>
      <id>61331</id>
      <timestamp>2013-06-05T21:38:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="176">{{dsc fun | cpp/error/errc/make_error_condition  | title=make_error_condition{{dsc small|(std::errc)}} | notes={{mark c++11}} | constructs an {{lc|std::errc}} error condition}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/navbar</title>
    <ns>10</ns>
    <id>12634</id>
    <revision>
      <id>61366</id>
      <timestamp>2013-06-05T22:23:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="312">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading3 = cpp/error/errc/navbar heading
|content3 = cpp/error/errc/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/navbar content</title>
    <ns>10</ns>
    <id>12636</id>
    <revision>
      <id>61370</id>
      <parentid>61369</parentid>
      <timestamp>2013-06-05T22:25:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sb -&gt; nv</comment>
      <text xml:space="preserve" bytes="226">{{nv begin}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/error/errc/make_error_code}}
{{nv ln | cpp/error/errc/make_error_condition}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/error/errc/is_error_condition_enum}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/errc/navbar heading</title>
    <ns>10</ns>
    <id>12635</id>
    <revision>
      <id>61367</id>
      <timestamp>2013-06-05T22:23:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="34">{{ltt|cpp/error/errc | std::errc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc constructor</title>
    <ns>10</ns>
    <id>8910</id>
    <revision>
      <id>55601</id>
      <parentid>52586</parentid>
      <timestamp>2013-06-01T05:25:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list constructor]] to [[Template:cpp/error/error category/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem ctor | cpp/error/error_category/error_category | constructs an {{tt|error_category}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc default error condition</title>
    <ns>10</ns>
    <id>8912</id>
    <revision>
      <id>55608</id>
      <parentid>52587</parentid>
      <timestamp>2013-06-01T05:25:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list default error condition]] to [[Template:cpp/error/error category/dsc default error condition]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem vfun | cpp/error/error_category/default_error_condition | maps {{tt|error_code}} to {{tt|error_condition}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc destructor</title>
    <ns>10</ns>
    <id>8916</id>
    <revision>
      <id>55610</id>
      <parentid>52588</parentid>
      <timestamp>2013-06-01T05:25:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list destructor]] to [[Template:cpp/error/error category/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem vdtor | cpp/error/error_category/~error_category | destructs an {{tt|error_category}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc equivalent</title>
    <ns>10</ns>
    <id>8913</id>
    <revision>
      <id>55612</id>
      <parentid>52589</parentid>
      <timestamp>2013-06-01T05:25:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list equivalent]] to [[Template:cpp/error/error category/dsc equivalent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem vfun | cpp/error/error_category/equivalent | compares {{tt|error_code}} and {{tt|error_condition}} for equivalence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc message</title>
    <ns>10</ns>
    <id>8914</id>
    <revision>
      <id>55615</id>
      <parentid>52590</parentid>
      <timestamp>2013-06-01T05:25:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list message]] to [[Template:cpp/error/error category/dsc message]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem vfun | cpp/error/error_category/message | obtains the explanatory string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc name</title>
    <ns>10</ns>
    <id>8911</id>
    <revision>
      <id>55617</id>
      <parentid>52591</parentid>
      <timestamp>2013-06-01T05:25:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list name]] to [[Template:cpp/error/error category/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem vfun | cpp/error/error_category/name | obtains the name of the category}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc operator=</title>
    <ns>10</ns>
    <id>8917</id>
    <revision>
      <id>55621</id>
      <parentid>52592</parentid>
      <timestamp>2013-06-01T05:25:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list operator=]] to [[Template:cpp/error/error category/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | operator{{=}} | nolink=true | notes={{cmark deleted}} | not copy assignable}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/dsc operator cmp</title>
    <ns>10</ns>
    <id>8915</id>
    <revision>
      <id>55624</id>
      <parentid>52593</parentid>
      <timestamp>2013-06-01T05:25:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error category/dcl list operator cmp]] to [[Template:cpp/error/error category/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc fun | cpp/error/error_category/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt; | compares two error categories}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/navbar</title>
    <ns>10</ns>
    <id>4829</id>
    <revision>
      <id>39892</id>
      <parentid>36015</parentid>
      <timestamp>2012-09-28T19:58:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="332">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/error_category/navbar heading
|content4 = cpp/error/error_category/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/navbar content</title>
    <ns>10</ns>
    <id>4831</id>
    <revision>
      <id>52594</id>
      <parentid>37607</parentid>
      <timestamp>2013-06-01T04:50:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="471">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/error/error_category/error_category}}
{{nv mem ln | cpp/error/error_category/~error_category}}
{{nv mem ln | cpp/error/error_category/name}}
{{nv mem ln | cpp/error/error_category/default_error_condition}}
{{nv mem ln | cpp/error/error_category/equivalent}}
{{nv mem ln | cpp/error/error_category/message}}
{{nv mem ln | cpp/error/error_category/operator_cmp|operator{{==}}|operator!{{=}}|operator&lt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/navbar heading</title>
    <ns>10</ns>
    <id>4830</id>
    <revision>
      <id>60993</id>
      <parentid>35604</parentid>
      <timestamp>2013-06-03T11:45:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="52">{{ltt|cpp/error/error_category|std::error_category}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error category/title</title>
    <ns>10</ns>
    <id>8920</id>
    <revision>
      <id>37598</id>
      <timestamp>2012-07-15T21:35:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=error_category::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc assign</title>
    <ns>10</ns>
    <id>9005</id>
    <revision>
      <id>55629</id>
      <parentid>52595</parentid>
      <timestamp>2013-06-01T05:25:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list assign]] to [[Template:cpp/error/error code/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/error/error_code/assign | assigns another error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc category</title>
    <ns>10</ns>
    <id>9008</id>
    <revision>
      <id>55633</id>
      <parentid>52596</parentid>
      <timestamp>2013-06-01T05:25:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list category]] to [[Template:cpp/error/error code/dsc category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/error/error_code/category | obtains the error_category for this error_code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc clear</title>
    <ns>10</ns>
    <id>9006</id>
    <revision>
      <id>55638</id>
      <parentid>52597</parentid>
      <timestamp>2013-06-01T05:25:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list clear]] to [[Template:cpp/error/error code/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/error/error_code/clear | sets the error_code to value 0 in generic_category }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc constructor</title>
    <ns>10</ns>
    <id>9003</id>
    <revision>
      <id>55643</id>
      <parentid>52598</parentid>
      <timestamp>2013-06-01T05:25:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list constructor]] to [[Template:cpp/error/error code/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem ctor | cpp/error/error_code/error_code | constructs an error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc default error condition</title>
    <ns>10</ns>
    <id>9009</id>
    <revision>
      <id>55646</id>
      <parentid>52599</parentid>
      <timestamp>2013-06-01T05:25:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list default error condition]] to [[Template:cpp/error/error code/dsc default error condition]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/error/error_code/default_error_condition | obtains the error_condition for this error_code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc hash</title>
    <ns>10</ns>
    <id>4816</id>
    <revision>
      <id>55652</id>
      <parentid>52600</parentid>
      <timestamp>2013-06-01T05:25:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list hash]] to [[Template:cpp/error/error code/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc ptclass | cpp/error/error_code/hash | title=std::hash{{dsc small|&lt;std::error_code&gt;}} | hash support for {{lc|std::error_code}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc is error code enum</title>
    <ns>10</ns>
    <id>4812</id>
    <revision>
      <id>55656</id>
      <parentid>52601</parentid>
      <timestamp>2013-06-01T05:25:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list is error code enum]] to [[Template:cpp/error/error code/dsc is error code enum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc tclass  | cpp/error/error_code/is_error_code_enum | identifies a class as an error_code enumeration| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc message</title>
    <ns>10</ns>
    <id>9010</id>
    <revision>
      <id>55665</id>
      <parentid>52603</parentid>
      <timestamp>2013-06-01T05:26:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list message]] to [[Template:cpp/error/error code/dsc message]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/error/error_code/message | obtains the explanatory string for this error_code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc operator=</title>
    <ns>10</ns>
    <id>9004</id>
    <revision>
      <id>55671</id>
      <parentid>52604</parentid>
      <timestamp>2013-06-01T05:26:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list operator=]] to [[Template:cpp/error/error code/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/error/error_code/operator{{=}} | assigns another error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc operator bool</title>
    <ns>10</ns>
    <id>9011</id>
    <revision>
      <id>55675</id>
      <parentid>52605</parentid>
      <timestamp>2013-06-01T05:26:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list operator bool]] to [[Template:cpp/error/error code/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/error/error_code/operator bool | checks if the value is non-zero }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc operator cmp</title>
    <ns>10</ns>
    <id>9012</id>
    <revision>
      <id>55680</id>
      <parentid>52606</parentid>
      <timestamp>2013-06-01T05:26:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list operator cmp]] to [[Template:cpp/error/error code/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/error/error_code/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt; | compares two {{tt|error_code}}s}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc operator ltlt</title>
    <ns>10</ns>
    <id>9013</id>
    <revision>
      <id>55683</id>
      <parentid>52607</parentid>
      <timestamp>2013-06-01T05:26:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list operator ltlt]] to [[Template:cpp/error/error code/dsc operator ltlt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc fun | cpp/error/error_code/operator_ltlt | title=operator&lt;&lt; | outputs the value and the message to an output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/dsc value</title>
    <ns>10</ns>
    <id>9007</id>
    <revision>
      <id>55685</id>
      <parentid>52608</parentid>
      <timestamp>2013-06-01T05:26:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error code/dcl list value]] to [[Template:cpp/error/error code/dsc value]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/error/error_code/value | obtains the value of the error_code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/navbar</title>
    <ns>10</ns>
    <id>4817</id>
    <revision>
      <id>39893</id>
      <parentid>35975</parentid>
      <timestamp>2012-09-28T19:59:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="325">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/error_code/navbar heading
|content4 = cpp/error/error_code/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/navbar content</title>
    <ns>10</ns>
    <id>4819</id>
    <revision>
      <id>61357</id>
      <parentid>52609</parentid>
      <timestamp>2013-06-05T22:14:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move make_error_code</comment>
      <text xml:space="preserve" bytes="864">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/error_code/error_code}}
{{nv mem ln | cpp/error/error_code/operator{{=}}}}
{{nv mem ln | cpp/error/error_code/assign}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/error/error_code/clear}}
{{nv h2 | Observers}}
{{nv mem ln | cpp/error/error_code/value}}
{{nv mem ln | cpp/error/error_code/category}}
{{nv mem ln | cpp/error/error_code/default_error_condition}}
{{nv mem ln | cpp/error/error_code/message}}
{{nv mem ln | cpp/error/error_code/operator bool}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/error/error_code/operator_cmp|operator&lt;&lt;br&gt;operator{{==}}&lt;br&gt;operator!{{=}}}}
{{nv ln | cpp/error/error_code/operator_ltlt|operator&lt;&lt;}}
{{nv h1 | Helper classes}}
{{nv ln | cpp/error/error_code/is_error_code_enum}}
{{nv ln | cpp/error/error_code/hash|hash{{dsc small|&lt;std::error_code&gt;}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/navbar heading</title>
    <ns>10</ns>
    <id>4818</id>
    <revision>
      <id>48084</id>
      <parentid>35606</parentid>
      <timestamp>2013-05-18T18:06:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="44">{{ltt|cpp/error/error_code|std::error_code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error code/title</title>
    <ns>10</ns>
    <id>8558</id>
    <revision>
      <id>31718</id>
      <timestamp>2012-06-06T20:42:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=error_code::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc assign</title>
    <ns>10</ns>
    <id>9621</id>
    <revision>
      <id>55688</id>
      <parentid>52610</parentid>
      <timestamp>2013-06-01T05:26:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list assign]] to [[Template:cpp/error/error condition/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/error/error_condition/assign | replaces the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc category</title>
    <ns>10</ns>
    <id>9624</id>
    <revision>
      <id>55696</id>
      <parentid>52611</parentid>
      <timestamp>2013-06-01T05:26:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list category]] to [[Template:cpp/error/error condition/dsc category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/error/error_condition/category | obtains the {{tt|error_category}} for this {{tt|error_condition}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc clear</title>
    <ns>10</ns>
    <id>9622</id>
    <revision>
      <id>55705</id>
      <parentid>52612</parentid>
      <timestamp>2013-06-01T05:26:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list clear]] to [[Template:cpp/error/error condition/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/error/error_condition/clear | sets the error_condition to value 0 in generic_category }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc constructor</title>
    <ns>10</ns>
    <id>9619</id>
    <revision>
      <id>55712</id>
      <parentid>52613</parentid>
      <timestamp>2013-06-01T05:26:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list constructor]] to [[Template:cpp/error/error condition/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem ctor | cpp/error/error_condition/error_condition | constructs an {{tt|error_condition}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc is error condition enum</title>
    <ns>10</ns>
    <id>4810</id>
    <revision>
      <id>55719</id>
      <parentid>52614</parentid>
      <timestamp>2013-06-01T05:26:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list is error condition enum]] to [[Template:cpp/error/error condition/dsc is error condition enum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc tclass  | cpp/error/error_condition/is_error_condition_enum | identifies an enumeration as an {{lc|std::error_condition}}| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc message</title>
    <ns>10</ns>
    <id>9625</id>
    <revision>
      <id>55731</id>
      <parentid>52616</parentid>
      <timestamp>2013-06-01T05:26:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list message]] to [[Template:cpp/error/error condition/dsc message]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/error/error_condition/message | obtains the explanatory string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc operator=</title>
    <ns>10</ns>
    <id>9620</id>
    <revision>
      <id>55737</id>
      <parentid>52617</parentid>
      <timestamp>2013-06-01T05:26:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list operator=]] to [[Template:cpp/error/error condition/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/error/error_condition/operator{{=}} | replaces the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc operator bool</title>
    <ns>10</ns>
    <id>9626</id>
    <revision>
      <id>55744</id>
      <parentid>52618</parentid>
      <timestamp>2013-06-01T05:26:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list operator bool]] to [[Template:cpp/error/error condition/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/error/error_condition/operator bool | checks if the value is non-zero }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc operator cmp</title>
    <ns>10</ns>
    <id>9627</id>
    <revision>
      <id>55750</id>
      <parentid>52619</parentid>
      <timestamp>2013-06-01T05:27:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list operator cmp]] to [[Template:cpp/error/error condition/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc fun | cpp/error/error_condition/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt; | compares error_conditions and error_codes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/dsc value</title>
    <ns>10</ns>
    <id>9623</id>
    <revision>
      <id>55756</id>
      <parentid>52620</parentid>
      <timestamp>2013-06-01T05:27:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/error condition/dcl list value]] to [[Template:cpp/error/error condition/dsc value]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/error/error_condition/value | obtains the value of the error_condition}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/navbar</title>
    <ns>10</ns>
    <id>4807</id>
    <revision>
      <id>39894</id>
      <parentid>36020</parentid>
      <timestamp>2012-09-28T19:59:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="334">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/error_condition/navbar heading
|content4 = cpp/error/error_condition/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/navbar content</title>
    <ns>10</ns>
    <id>4814</id>
    <revision>
      <id>61354</id>
      <parentid>52621</parentid>
      <timestamp>2013-06-05T22:13:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>move make_error_condition</comment>
      <text xml:space="preserve" bytes="681">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/error/error_condition/error_condition}}
{{nv mem ln | cpp/error/error_condition/operator{{=}}}}
{{nv mem ln | cpp/error/error_condition/assign}}
{{nv mem ln | cpp/error/error_condition/clear}}
{{nv mem ln | cpp/error/error_condition/value}}
{{nv mem ln | cpp/error/error_condition/category}}
{{nv mem ln | cpp/error/error_condition/message}}
{{nv mem ln | cpp/error/error_condition/operator bool}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/error/error_condition/operator_cmp|operator{{==}}|operator!{{=}}|operator&lt;}}
{{nv h2 | Helper classes}}
{{nv ln | cpp/error/error_condition/is_error_condition_enum}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/navbar heading</title>
    <ns>10</ns>
    <id>4813</id>
    <revision>
      <id>48083</id>
      <parentid>34199</parentid>
      <timestamp>2013-05-18T18:06:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="54">{{ltt|cpp/error/error_condition|std::error_condition}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/error condition/title</title>
    <ns>10</ns>
    <id>8581</id>
    <revision>
      <id>31742</id>
      <timestamp>2012-06-06T20:46:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=error_condition::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/example errno</title>
    <ns>10</ns>
    <id>5562</id>
    <revision>
      <id>66379</id>
      <parentid>66378</parentid>
      <timestamp>2013-11-15T14:57:31Z</timestamp>
      <contributor>
        <ip>91.82.97.158</ip>
      </contributor>
      <comment>Well, actually it isn't, because it's a macro</comment>
      <text xml:space="preserve" bytes="321">{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cmath&gt;
#include &lt;cerrno&gt;
#include &lt;cstring&gt;

int main()
{
    double not_a_number = std::log(-1.0);
    if (errno == EDOM) {
        std::cout &lt;&lt; &quot;log(-1) failed: &quot; &lt;&lt; std::strerror(errno) &lt;&lt; '\n';
    }
}
 | output=
log(-1) failed: Numerical argument out of domain
}}</text>
      <sha1>koayk0o55ekyht0y22pb273z460v6nr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/example exception ptr</title>
    <ns>10</ns>
    <id>5607</id>
    <revision>
      <id>69691</id>
      <parentid>26077</parentid>
      <timestamp>2014-04-20T03:16:07Z</timestamp>
      <contributor>
        <ip>84.52.101.196</ip>
      </contributor>
      <comment>converts to bool</comment>
      <text xml:space="preserve" bytes="718">{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;string&gt;
#include &lt;exception&gt;
#include &lt;stdexcept&gt;

void handle_eptr(std::exception_ptr eptr) // passing by value is ok
{
    try {
        if (eptr) {
            std::rethrow_exception(eptr);
        }
    } catch(const std::exception&amp; e) {
        std::cout &lt;&lt; &quot;Caught exception \&quot;&quot; &lt;&lt; e.what() &lt;&lt; &quot;\&quot;\n&quot;;
    }
}

int main()
{
    std::exception_ptr eptr;
    try {
        std::string().at(1); // this generates an std::out_of_range
    } catch(...) {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed
 | output=
Caught exception &quot;basic_string::at&quot;
}}</text>
      <sha1>r4dvzigp7hwq663blpktw3artpuyma7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/example nested exception</title>
    <ns>10</ns>
    <id>5553</id>
    <revision>
      <id>26079</id>
      <parentid>23438</parentid>
      <timestamp>2012-04-29T08:29:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/example nested exception]] to [[Template:cpp/error/example nested exception]]: merge cpp/error/exception path to cpp/error</comment>
      <text xml:space="preserve" bytes="1466">{{example
 | Demonstrates construction and recursion through a nested exception object
 | code=
#include &lt;iostream&gt;
#include &lt;stdexcept&gt;
#include &lt;exception&gt;
#include &lt;string&gt;
#include &lt;fstream&gt;

// prints the explanatory string of an exception. If the exception is nested,
// recurses to print the explanatory of the exception it holds
void print_exception(const std::exception&amp; e, int level =  0)
{
    std::cerr &lt;&lt; std::string(level, ' ') &lt;&lt; &quot;exception: &quot; &lt;&lt; e.what() &lt;&lt; '\n';
    try {
        std::rethrow_if_nested(e);
    } catch(const std::exception&amp; e) {
        print_exception(e, level+1);
    } catch(...) {}
}

// sample function that catches an exception and wraps it in a nested exception
void open_file(const std::string&amp; s)
{
    try {
        std::ifstream file(s);
        file.exceptions(std::ios_base::failbit);
    } catch(...) {
        std::throw_with_nested( std::runtime_error(&quot;Couldn't open &quot; + s) );
    }
}

// sample function that catches an exception and wraps it in a nested exception
void run()
{
    try {
        open_file(&quot;nonexistent.file&quot;);
    } catch(...) {
        std::throw_with_nested( std::runtime_error(&quot;run() failed&quot;) );
    }
}

// runs the sample function above and prints the caught exception
int main()
{
    try {
        run();
    } catch(const std::exception&amp; e) {
        print_exception(e);
    }
}
 | output=
exception: run() failed
 exception: Couldn't open nonexistent.file
  exception: basic_ios::clear
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/constructor</title>
    <ns>10</ns>
    <id>4496</id>
    <revision>
      <id>64379</id>
      <parentid>63589</parentid>
      <timestamp>2013-08-15T18:48:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="448">{{member | {{small|std::{{{1}}}::}}{{{1}}} | 2=
{{dcl begin}}
{{dcl | num=1 |
explicit {{{1}}}( const std::string&amp; what_arg );
}}
{{dcl | num=2 | since=c++11 |
explicit {{{1}}}( const char* what_arg );
}}
{{dcl end}}

Constructs the exception object with {{tt|what_arg}} as explanatory string that can be accessed through {{lc|what()}}.

===Parameters===
{{par begin}}
{{par | what_arg | explanatory string}}
{{par end}}

===Exceptions===
(none)
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/dsc constructor</title>
    <ns>10</ns>
    <id>2116</id>
    <revision>
      <id>55763</id>
      <parentid>52623</parentid>
      <timestamp>2013-06-01T05:27:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/dcl list constructor]] to [[Template:cpp/error/exception/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem ctor | cpp/error/{{{1|/}}} | inlinemem=true | constructs the exception object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/dsc destructor</title>
    <ns>10</ns>
    <id>2074</id>
    <revision>
      <id>55770</id>
      <parentid>52624</parentid>
      <timestamp>2013-06-01T05:27:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/dcl list destructor]] to [[Template:cpp/error/exception/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem vdtor | cpp/error/exception/~exception | destructs the exception object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/dsc operator=</title>
    <ns>10</ns>
    <id>4518</id>
    <revision>
      <id>55774</id>
      <parentid>52625</parentid>
      <timestamp>2013-06-01T05:27:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/dcl list operator=]] to [[Template:cpp/error/exception/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/error/exception/operator{{=}} | copies exception object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/dsc what</title>
    <ns>10</ns>
    <id>2075</id>
    <revision>
      <id>55777</id>
      <parentid>52626</parentid>
      <timestamp>2013-06-01T05:27:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/dcl list what]] to [[Template:cpp/error/exception/dsc what]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem vfun | cpp/error/exception/what | returns an explanatory string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/inherit</title>
    <ns>10</ns>
    <id>2076</id>
    <revision>
      <id>60865</id>
      <parentid>52628</parentid>
      <timestamp>2013-06-01T11:59:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="210">{{inherited | [[cpp/error/exception | {{small|std::}}exception]] |
===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/exception/dsc destructor}}
{{dsc inc | cpp/error/exception/dsc what}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/inherit sidebar</title>
    <ns>10</ns>
    <id>4760</id>
    <revision>
      <id>52629</id>
      <parentid>48095</parentid>
      <timestamp>2013-06-01T04:50:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="157">{{nv h2 | Inherited from {{ltt|cpp/error/exception|std::exception}}}}
{{nv mem ln | cpp/error/exception/~exception}}
{{nv mem ln | cpp/error/exception/what}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/navbar</title>
    <ns>10</ns>
    <id>2078</id>
    <revision>
      <id>39895</id>
      <parentid>36021</parentid>
      <timestamp>2012-09-28T19:59:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="322">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/exception/navbar heading
|content4 = cpp/error/exception/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/navbar content</title>
    <ns>10</ns>
    <id>2559</id>
    <revision>
      <id>52630</id>
      <parentid>35610</parentid>
      <timestamp>2013-06-01T04:50:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="236">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/exception/exception}}
{{nv mem ln | cpp/error/exception/~exception}}
{{nv mem ln | cpp/error/exception/operator{{=}}}}
{{nv mem ln | cpp/error/exception/what}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/navbar heading</title>
    <ns>10</ns>
    <id>2079</id>
    <revision>
      <id>35611</id>
      <parentid>26321</parentid>
      <timestamp>2012-06-15T22:29:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/sidebar heading]] to [[Template:cpp/error/exception/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="45">{{ltt| cpp/error/exception | std::exception}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/exception/title</title>
    <ns>10</ns>
    <id>4515</id>
    <revision>
      <id>26097</id>
      <parentid>15998</parentid>
      <timestamp>2012-04-29T08:29:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/exception/exception/title]] to [[Template:cpp/error/exception/title]]: merge cpp/error/exception path to cpp/error</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=exception::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/invalid argument/navbar</title>
    <ns>10</ns>
    <id>2092</id>
    <revision>
      <id>39896</id>
      <parentid>36022</parentid>
      <timestamp>2012-09-28T20:01:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="336">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/invalid_argument/navbar heading
|content4 = cpp/error/invalid_argument/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/invalid argument/navbar content</title>
    <ns>10</ns>
    <id>2551</id>
    <revision>
      <id>52631</id>
      <parentid>35615</parentid>
      <timestamp>2013-06-01T04:50:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="162">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/invalid_argument/invalid_argument}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/invalid argument/navbar heading</title>
    <ns>10</ns>
    <id>2100</id>
    <revision>
      <id>35617</id>
      <parentid>26316</parentid>
      <timestamp>2012-06-15T22:29:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/invalid argument/sidebar heading]] to [[Template:cpp/error/invalid argument/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="56">{{ltt|cpp/error/invalid_argument|std::invalid_argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/length error/navbar</title>
    <ns>10</ns>
    <id>2098</id>
    <revision>
      <id>39898</id>
      <parentid>36023</parentid>
      <timestamp>2012-09-28T20:09:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="329">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content 

|heading4 = cpp/error/length_error/navbar heading
|content4 = cpp/error/length_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/length error/navbar content</title>
    <ns>10</ns>
    <id>2553</id>
    <revision>
      <id>52632</id>
      <parentid>35618</parentid>
      <timestamp>2013-06-01T04:50:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="154">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/length_error/length_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/length error/navbar heading</title>
    <ns>10</ns>
    <id>2106</id>
    <revision>
      <id>35619</id>
      <parentid>26326</parentid>
      <timestamp>2012-06-15T22:29:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/length error/sidebar heading]] to [[Template:cpp/error/length error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">{{ltt|cpp/error/length_error|std::length_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/logic error/navbar</title>
    <ns>10</ns>
    <id>2090</id>
    <revision>
      <id>39899</id>
      <parentid>36011</parentid>
      <timestamp>2012-09-28T20:09:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="326">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/logic_error/navbar heading
|content4 = cpp/error/logic_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/logic error/navbar content</title>
    <ns>10</ns>
    <id>2550</id>
    <revision>
      <id>52633</id>
      <parentid>35621</parentid>
      <timestamp>2013-06-01T04:50:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="152">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/logic_error/logic_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/logic error/navbar heading</title>
    <ns>10</ns>
    <id>2099</id>
    <revision>
      <id>35622</id>
      <parentid>26329</parentid>
      <timestamp>2012-06-15T22:29:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/logic error/sidebar heading]] to [[Template:cpp/error/logic error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/error/logic_error|std::logic_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/navbar</title>
    <ns>10</ns>
    <id>2072</id>
    <revision>
      <id>61365</id>
      <parentid>39900</parentid>
      <timestamp>2013-06-05T22:23:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="227">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/navbar content</title>
    <ns>10</ns>
    <id>3493</id>
    <revision>
      <id>52634</id>
      <parentid>35499</parentid>
      <timestamp>2013-06-01T04:50:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2025">{{nv begin}}
{{nv h2 | Exception handling}}
{{nv ln | cpp/error/exception }}
{{nv ln | cpp/error/uncaught_exception}}
{{nv ln | cpp/error/exception_ptr |notes={{mark c++11}}}}
{{nv ln | cpp/error/make_exception_ptr |notes={{mark c++11}}}}
{{nv ln | cpp/error/current_exception |notes={{mark c++11}}}}
{{nv ln | cpp/error/rethrow_exception |notes={{mark c++11}}}}
{{nv ln | cpp/error/nested_exception |notes={{mark c++11}}}}
{{nv ln | cpp/error/throw_with_nested |notes={{mark c++11}}}}
{{nv ln | cpp/error/rethrow_if_nested |notes={{mark c++11}}}}

{{nv h2 | Exception handling failures}}
{{nv ln | cpp/error/terminate}}
{{nv ln | cpp/error/terminate_handler}}
{{nv ln | cpp/error/get_terminate | notes={{mark c++11}}}}
{{nv ln | cpp/error/set_terminate}}
{{nv ln | cpp/error/unexpected|notes={{mark deprecated}}}}
{{nv ln | cpp/error/bad_exception}}
{{nv ln | cpp/error/unexpected_handler|notes={{mark deprecated}}}}
{{nv ln | cpp/error/get_unexpected|notes={{mark c++11}}{{mark deprecated}}}}
{{nv ln | cpp/error/set_unexpected|notes={{mark deprecated}}}}

{{nv h2 | Exception categories}}
{{nv ln | cpp/error/logic_error}}
{{nv ln | cpp/error/invalid_argument}}
{{nv ln | cpp/error/domain_error}}
{{nv ln | cpp/error/length_error}}
{{nv ln | cpp/error/out_of_range}}
{{nv ln | cpp/error/runtime_error}}
{{nv ln | cpp/error/range_error}}
{{nv ln | cpp/error/overflow_error}}
{{nv ln | cpp/error/underflow_error}}

{{nv h2 | Error codes}}
{{nv | [[cpp/error/errno_macros | Error codes]] }}
{{nv ln | cpp/error/errno}}

{{nv h2 | Assertions}}
{{nv ln | cpp/error/assert}}

{{nv h2 | system_error facility}}
{{nv ln | cpp/error/error_category | notes={{mark c++11}}}}
{{nv ln | cpp/error/generic_category | notes={{mark c++11}}}}
{{nv ln | cpp/error/system_category | notes={{mark c++11}}}}
{{nv ln | cpp/error/error_condition | notes={{mark c++11}}}}
{{nv ln | cpp/error/errc | notes={{mark c++11}}}}
{{nv ln | cpp/error/error_code | notes={{mark c++11}}}}
{{nv ln | cpp/error/system_error | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/navbar heading</title>
    <ns>10</ns>
    <id>2073</id>
    <revision>
      <id>35633</id>
      <parentid>4439</parentid>
      <timestamp>2012-06-15T22:29:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/sidebar heading]] to [[Template:cpp/error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="30">[[cpp/error | Error handling]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/nested exception/navbar</title>
    <ns>10</ns>
    <id>9890</id>
    <revision>
      <id>46530</id>
      <timestamp>2013-03-23T00:22:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="336">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/nested_exception/navbar heading
|content4 = cpp/error/nested_exception/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/nested exception/navbar content</title>
    <ns>10</ns>
    <id>9892</id>
    <revision>
      <id>61286</id>
      <parentid>52635</parentid>
      <timestamp>2013-06-05T14:18:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="342">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/nested_exception/nested_exception}}
{{nv mem ln | cpp/error/nested_exception/~nested_exception}}
{{nv mem ln | cpp/error/nested_exception/operator{{=}}}}
{{nv mem ln | cpp/error/nested_exception/rethrow_nested}}
{{nv mem ln | cpp/error/nested_exception/nested_ptr}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/nested exception/navbar heading</title>
    <ns>10</ns>
    <id>9891</id>
    <revision>
      <id>46531</id>
      <timestamp>2013-03-23T00:23:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="59">{{ltt| cpp/error/nested_exception | std::nested_exception}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/nested exception/title</title>
    <ns>10</ns>
    <id>9889</id>
    <revision>
      <id>46529</id>
      <timestamp>2013-03-23T00:22:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=nested_exception::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/out of range/navbar</title>
    <ns>10</ns>
    <id>2094</id>
    <revision>
      <id>39901</id>
      <parentid>36009</parentid>
      <timestamp>2012-09-28T20:09:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/out_of_range/navbar heading
|content4 = cpp/error/out_of_range/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/out of range/navbar content</title>
    <ns>10</ns>
    <id>2554</id>
    <revision>
      <id>52636</id>
      <parentid>35625</parentid>
      <timestamp>2013-06-01T04:50:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="154">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/out_of_range/out_of_range}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/out of range/navbar heading</title>
    <ns>10</ns>
    <id>2105</id>
    <revision>
      <id>35626</id>
      <parentid>26332</parentid>
      <timestamp>2012-06-15T22:29:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/out of range/sidebar heading]] to [[Template:cpp/error/out of range/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">{{ltt|cpp/error/out_of_range|std::out_of_range}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/overflow error/navbar</title>
    <ns>10</ns>
    <id>2096</id>
    <revision>
      <id>39902</id>
      <parentid>36008</parentid>
      <timestamp>2012-09-28T20:09:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="332">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/overflow_error/navbar heading
|content4 = cpp/error/overflow_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/overflow error/navbar content</title>
    <ns>10</ns>
    <id>2557</id>
    <revision>
      <id>52637</id>
      <parentid>34831</parentid>
      <timestamp>2013-06-01T04:50:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="158">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/overflow_error/overflow_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/overflow error/navbar heading</title>
    <ns>10</ns>
    <id>2102</id>
    <revision>
      <id>33481</id>
      <parentid>26335</parentid>
      <timestamp>2012-06-15T20:19:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/overflow error/sidebar heading]] to [[Template:cpp/error/overflow error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="52">{{ltt|cpp/error/overflow_error|std::overflow_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/range error/navbar</title>
    <ns>10</ns>
    <id>2095</id>
    <revision>
      <id>39903</id>
      <parentid>35949</parentid>
      <timestamp>2012-09-28T20:09:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="326">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/range_error/navbar heading
|content4 = cpp/error/range_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/range error/navbar content</title>
    <ns>10</ns>
    <id>2556</id>
    <revision>
      <id>52638</id>
      <parentid>34954</parentid>
      <timestamp>2013-06-01T04:51:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="152">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/range_error/range_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/range error/navbar heading</title>
    <ns>10</ns>
    <id>2103</id>
    <revision>
      <id>35628</id>
      <parentid>26338</parentid>
      <timestamp>2012-06-15T22:29:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/range error/sidebar heading]] to [[Template:cpp/error/range error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/error/range_error|std::range_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/runtime error/inherit</title>
    <ns>10</ns>
    <id>12786</id>
    <revision>
      <id>62099</id>
      <timestamp>2013-06-22T02:04:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="148">{{inherited | [[cpp/error/runtime_error | {{small|std::}}runtime_error]] |
&lt;!-- nothing special, it's only here to show the inheritance chain --&gt;
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/runtime error/navbar</title>
    <ns>10</ns>
    <id>2091</id>
    <revision>
      <id>39904</id>
      <parentid>36007</parentid>
      <timestamp>2012-09-28T20:09:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="330">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/runtime_error/navbar heading
|content4 = cpp/error/runtime_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/runtime error/navbar content</title>
    <ns>10</ns>
    <id>2555</id>
    <revision>
      <id>52639</id>
      <parentid>35630</parentid>
      <timestamp>2013-06-01T04:51:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="156">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/runtime_error/runtime_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/runtime error/navbar heading</title>
    <ns>10</ns>
    <id>2104</id>
    <revision>
      <id>35631</id>
      <parentid>26341</parentid>
      <timestamp>2012-06-15T22:29:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/runtime error/sidebar heading]] to [[Template:cpp/error/runtime error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="50">{{ltt|cpp/error/runtime_error|std::runtime_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/dsc code</title>
    <ns>10</ns>
    <id>4776</id>
    <revision>
      <id>55784</id>
      <parentid>52640</parentid>
      <timestamp>2013-06-01T05:27:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/system error/dcl list code]] to [[Template:cpp/error/system error/dsc code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/error/system_error/code | returns error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/dsc constructor</title>
    <ns>10</ns>
    <id>8973</id>
    <revision>
      <id>55790</id>
      <parentid>52641</parentid>
      <timestamp>2013-06-01T05:27:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/system error/dcl list constructor]] to [[Template:cpp/error/system error/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem ctor | cpp/error/system_error/system_error | constructs the {{tt|system_error}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/dsc what</title>
    <ns>10</ns>
    <id>4775</id>
    <revision>
      <id>55794</id>
      <parentid>52642</parentid>
      <timestamp>2013-06-01T05:27:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/system error/dcl list what]] to [[Template:cpp/error/system error/dsc what]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem vfun | cpp/error/system_error/what | returns explanatory string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/inherit</title>
    <ns>10</ns>
    <id>4777</id>
    <revision>
      <id>62098</id>
      <parentid>60866</parentid>
      <timestamp>2013-06-22T02:04:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>consistency</comment>
      <text xml:space="preserve" bytes="216">{{inherited | [[cpp/error/system_error | {{small|std::}}system_error]] |
===Member functions===
{{dsc begin}}
{{dsc inc | cpp/error/system_error/dsc code}}
{{dsc inc | cpp/error/system_error/dsc what}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/navbar</title>
    <ns>10</ns>
    <id>5448</id>
    <revision>
      <id>39905</id>
      <parentid>36006</parentid>
      <timestamp>2012-09-28T20:09:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/system_error/navbar heading
|content4 = cpp/error/system_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/navbar content</title>
    <ns>10</ns>
    <id>5450</id>
    <revision>
      <id>52644</id>
      <parentid>35635</parentid>
      <timestamp>2013-06-01T04:51:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="192">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/error/system_error/system_error}}
{{nv mem ln | cpp/error/system_error/code}}
{{nv mem ln | cpp/error/system_error/what}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/navbar heading</title>
    <ns>10</ns>
    <id>5449</id>
    <revision>
      <id>48102</id>
      <parentid>35636</parentid>
      <timestamp>2013-05-18T18:12:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="48">{{ltt|cpp/error/system_error|std::system_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/system error/title</title>
    <ns>10</ns>
    <id>5003</id>
    <revision>
      <id>26202</id>
      <parentid>18074</parentid>
      <timestamp>2012-04-29T08:36:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/system error/system error/title]] to [[Template:cpp/error/system error/title]]: Merge cpp/error/system_error path to cpp/error</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=system_error::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/underflow error/navbar</title>
    <ns>10</ns>
    <id>2097</id>
    <revision>
      <id>39906</id>
      <parentid>36005</parentid>
      <timestamp>2012-09-28T20:09:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="334">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/error/navbar heading
|content3 = cpp/error/navbar content

|heading4 = cpp/error/underflow_error/navbar heading
|content4 = cpp/error/underflow_error/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/underflow error/navbar content</title>
    <ns>10</ns>
    <id>2558</id>
    <revision>
      <id>52645</id>
      <parentid>35638</parentid>
      <timestamp>2013-06-01T04:51:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="160">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/error/underflow_error/underflow_error}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/error/underflow error/navbar heading</title>
    <ns>10</ns>
    <id>2101</id>
    <revision>
      <id>35347</id>
      <parentid>26346</parentid>
      <timestamp>2012-06-15T22:23:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/error/underflow error/sidebar heading]] to [[Template:cpp/error/underflow error/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="54">{{ltt|cpp/error/underflow_error|std::underflow_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc any cast</title>
    <ns>10</ns>
    <id>13648</id>
    <revision>
      <id>71488</id>
      <parentid>71457</parentid>
      <timestamp>2014-06-12T00:22:30Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Update description to match draft doc.</comment>
      <text xml:space="preserve" bytes="88">{{dsc tfun | cpp/experimental/any/any_cast | type-safe access to the contained object }}</text>
      <sha1>4qkfqk15pq6d5grlh4rwkxkztcfreuw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc clear</title>
    <ns>10</ns>
    <id>13668</id>
    <revision>
      <id>71494</id>
      <timestamp>2014-06-12T00:46:26Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/experimental/any/clear | destroys contained object}}</text>
      <sha1>2gf4dpow2wvv4118lfuttpyw7yw92w4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc constructor</title>
    <ns>10</ns>
    <id>13650</id>
    <revision>
      <id>71417</id>
      <timestamp>2014-06-11T01:26:18Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem ctor | cpp/experimental/any/any | constructs an {{tt|any}} object}}</text>
      <sha1>03krhfh78yeca1uahqqg1ueua0uiz2j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc empty</title>
    <ns>10</ns>
    <id>13652</id>
    <revision>
      <id>71419</id>
      <timestamp>2014-06-11T01:28:24Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/experimental/any/empty | checks if object holds a value }}</text>
      <sha1>ihbomfakak4fje026o7tpw57vfd2fgl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc operator=</title>
    <ns>10</ns>
    <id>13651</id>
    <revision>
      <id>71418</id>
      <timestamp>2014-06-11T01:27:16Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/experimental/any/operator{{=}} | assigns an {{tt|any}} object }}</text>
      <sha1>eejfoiwn5cd0iznc3juibqtsnv4ovyo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc swap</title>
    <ns>10</ns>
    <id>13647</id>
    <revision>
      <id>71415</id>
      <parentid>71410</parentid>
      <timestamp>2014-06-11T01:22:03Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix description.</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/experimental/any/swap | swaps two {{tt|any}} objects}}</text>
      <sha1>on8ck1hb8zobpz4bb634h2dk1652z6x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc swap2</title>
    <ns>10</ns>
    <id>13649</id>
    <revision>
      <id>71520</id>
      <parentid>71414</parentid>
      <timestamp>2014-06-12T08:27:15Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Fix namespace &amp; function declaration.</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | cpp/experimental/any/swap2 | title=swap | swaps two {{tt|any}} instances }}</text>
      <sha1>d6ra4cky7uozb2z9tw5xeu02bjj0kpu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/dsc type</title>
    <ns>10</ns>
    <id>13653</id>
    <revision>
      <id>71420</id>
      <timestamp>2014-06-11T01:29:10Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/experimental/any/type | returns the {{tt|typeid}} of the contained value }}</text>
      <sha1>473s1n3omvyh3pdl5p8ei7mb13nmryt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/navbar</title>
    <ns>10</ns>
    <id>13654</id>
    <revision>
      <id>71421</id>
      <timestamp>2014-06-11T01:31:20Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="259">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/navbar heading
|content2 = cpp/experimental/navbar content

|heading3 = cpp/experimental/any/navbar heading
|content3 = cpp/experimental/any/navbar content
}}</text>
      <sha1>ixz0aabld8ax06qejb8932qghr4q5ia</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/navbar content</title>
    <ns>10</ns>
    <id>13655</id>
    <revision>
      <id>71497</id>
      <parentid>71422</parentid>
      <timestamp>2014-06-12T00:49:10Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add clear function.</comment>
      <text xml:space="preserve" bytes="521">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/experimental/any/any}}
{{nv mem ln | cpp/experimental/any/operator{{=}}}}

{{nv h2 | Modifers}}
{{nv mem ln | cpp/experimental/any/clear}}
{{nv mem ln | cpp/experimental/any/swap}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/experimental/any/empty}}
{{nv mem ln | cpp/experimental/any/type}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/experimental/any/swap2 | swap{{dsc small|(std::experimental::any)}} }}
{{nv ln | cpp/experimental/any/any_cast }}
{{nv end}}</text>
      <sha1>ifj1vp8bm8fqskaacabdtoidu8spebk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/navbar heading</title>
    <ns>10</ns>
    <id>13656</id>
    <revision>
      <id>71423</id>
      <timestamp>2014-06-11T01:36:22Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/experimental/any|std::experimental::any}}</text>
      <sha1>og67p143q7v0l3hs3oqw2cmcl3wmq0m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/any/title</title>
    <ns>10</ns>
    <id>13658</id>
    <revision>
      <id>71449</id>
      <timestamp>2014-06-11T05:31:19Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="114">&lt;onlyinclude&gt;{{cpp/title | n=experimental::any::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>hfhrb57ytknr82iogc7pxp08ym7a9h8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/basic string view</title>
    <ns>10</ns>
    <id>13587</id>
    <revision>
      <id>71280</id>
      <timestamp>2014-06-09T03:54:20Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem ctor | cpp/experimental/basic_string_view/basic_string_view | constructs a {{tt| basic_string_view}} }}</text>
      <sha1>arc5jvk2n4nq11klcvu0nc0aco5ryfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc at</title>
    <ns>10</ns>
    <id>13594</id>
    <revision>
      <id>71293</id>
      <timestamp>2014-06-09T04:25:33Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/experimental/basic string view/at | access specified character with bounds checking }}</text>
      <sha1>4d1wq3abartko1hco4sx44wmrkg8xbf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc back</title>
    <ns>10</ns>
    <id>13595</id>
    <revision>
      <id>71295</id>
      <parentid>71294</parentid>
      <timestamp>2014-06-09T04:27:15Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix function typo</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/experimental/basic string view/back | accesses the last character }}</text>
      <sha1>68b82i5ij4jszvu7m4e8wvw8wedxsxo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc begin</title>
    <ns>10</ns>
    <id>13589</id>
    <revision>
      <id>71283</id>
      <timestamp>2014-06-09T03:58:41Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/experimental/basic string view/begin | title=begin&lt;br&gt;cbegin | returns an iterator to the beginning }}</text>
      <sha1>se8m1guti72ace6nz47rb4j7sgdun83</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc clear</title>
    <ns>10</ns>
    <id>13602</id>
    <revision>
      <id>71304</id>
      <timestamp>2014-06-09T04:36:18Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/experimental/basic string view/clear | Clears the view }}</text>
      <sha1>mpv87oka0hf32dz07kc6zt5evt5jjem</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc compare</title>
    <ns>10</ns>
    <id>13629</id>
    <revision>
      <id>71349</id>
      <timestamp>2014-06-09T10:19:29Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/experimental/basic string view/compare | compares two views }}</text>
      <sha1>bsolh4sh5ofx7srglbbi6zq7hsx0pn8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc constructor</title>
    <ns>10</ns>
    <id>13588</id>
    <revision>
      <id>71282</id>
      <timestamp>2014-06-09T03:56:19Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem ctor | cpp/experimental/basic_string_view/basic_string_view | constructs a {{tt| basic_string_view}} }}</text>
      <sha1>arc5jvk2n4nq11klcvu0nc0aco5ryfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc copy</title>
    <ns>10</ns>
    <id>13607</id>
    <revision>
      <id>71313</id>
      <timestamp>2014-06-09T06:43:38Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/experimental/basic string view/copy | copies characters }}</text>
      <sha1>0jmn51hrqyv7aika1kkvts3vv5a4ixd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc data</title>
    <ns>10</ns>
    <id>13626</id>
    <revision>
      <id>71346</id>
      <timestamp>2014-06-09T10:17:06Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/experimental/basic string view/data | returns a pointer to the first character of a view }}</text>
      <sha1>kkp2orbn01wrscn4ccn5nlz4l9ooenh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc empty</title>
    <ns>10</ns>
    <id>13597</id>
    <revision>
      <id>71297</id>
      <timestamp>2014-06-09T04:31:26Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/experimental/basic string view/empty | checks whether the view is empty  }}</text>
      <sha1>te4u0qsjml4x2io8kcu7h0a5ehjnd0v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc end</title>
    <ns>10</ns>
    <id>13590</id>
    <revision>
      <id>71284</id>
      <timestamp>2014-06-09T03:59:33Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem fun | cpp/experimental/basic string view/end | title=end&lt;br&gt;cend | returns an iterator to the end }}</text>
      <sha1>rfs0ispzsbzqbfgcy2jr6o3yw7q6b66</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc find</title>
    <ns>10</ns>
    <id>13608</id>
    <revision>
      <id>71314</id>
      <timestamp>2014-06-09T06:44:05Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/experimental/basic string view/find | find characters in the view }}</text>
      <sha1>18muzezkc35szatzpaev1rded6rnhuw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc find first not of</title>
    <ns>10</ns>
    <id>13615</id>
    <revision>
      <id>71325</id>
      <timestamp>2014-06-09T09:05:15Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/experimental/basic_string_view/find_first_not_of | find first absence of characters }}</text>
      <sha1>fvltbwccc7swye1kdy7e3vdee8zvj8n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc find first of</title>
    <ns>10</ns>
    <id>13613</id>
    <revision>
      <id>71323</id>
      <timestamp>2014-06-09T09:03:37Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/experimental/basic_string_view/find_first_of | find first occurrence of characters }}</text>
      <sha1>atot08qa4r7g1k85vefgvx487614ds3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc find last not of</title>
    <ns>10</ns>
    <id>13616</id>
    <revision>
      <id>71326</id>
      <timestamp>2014-06-09T09:05:39Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/experimental/basic_string_view/find_last_not_of | find last absence of characters }}</text>
      <sha1>12lao19dbef57insa9bgke974jqdlwf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc find last of</title>
    <ns>10</ns>
    <id>13614</id>
    <revision>
      <id>71324</id>
      <timestamp>2014-06-09T09:03:55Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/experimental/basic_string_view/find_last_of | find last occurrence of characters }}</text>
      <sha1>nbfn535ei5i5yk2jz5ar51er5t6qwsi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc front</title>
    <ns>10</ns>
    <id>13596</id>
    <revision>
      <id>71296</id>
      <timestamp>2014-06-09T04:27:56Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/experimental/basic string view/front | accesses the first character }}</text>
      <sha1>s5g017t2r27vopu35g9raaneg7n7km6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc hash</title>
    <ns>10</ns>
    <id>13632</id>
    <revision>
      <id>71352</id>
      <timestamp>2014-06-09T10:23:37Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="331">{{dsc ptclass | cpp/experimental/basic_string_view/hash | title=std::hash{{dsc small|&lt;std::experimental::string_view&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::experimental::wstring_view&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::experimental::u16string_view&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::experimental::u32string_view&gt;}} | hash support for views }}</text>
      <sha1>5fd6s35yw56lleudtxyfb1j2xrkq5g5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc max size</title>
    <ns>10</ns>
    <id>13598</id>
    <revision>
      <id>71298</id>
      <timestamp>2014-06-09T04:31:56Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/experimental/basic string view/max_size | returns the maximum number of characters }}</text>
      <sha1>rub1nizvsqdl99dclv3joxpktshnn53</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc npos</title>
    <ns>10</ns>
    <id>13630</id>
    <revision>
      <id>71350</id>
      <timestamp>2014-06-09T10:20:18Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem sconst | cpp/experimental/basic string view/npos | special value. The exact meaning depends on the context}}</text>
      <sha1>2zq87wypifaqihlnkwpuf770jrptw7g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc operator=</title>
    <ns>10</ns>
    <id>13586</id>
    <revision>
      <id>71276</id>
      <parentid>71275</parentid>
      <timestamp>2014-06-09T03:45:47Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix class typo</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/experimental/basic_string_view/operator{{=}} | assigns a view }}</text>
      <sha1>2rm8miqd9my5sch8agt33pxw9cd6rhj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc operator at</title>
    <ns>10</ns>
    <id>13593</id>
    <revision>
      <id>71292</id>
      <timestamp>2014-06-09T04:24:25Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/experimental/basic string view/operator_at|title=operator[] | access specified character }}</text>
      <sha1>6k3a4ya9izeu6wbcuaaeef9io4r9r0h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc operator cmp</title>
    <ns>10</ns>
    <id>13610</id>
    <revision>
      <id>71317</id>
      <timestamp>2014-06-09T07:05:52Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="189">{{dsc tfun | cpp/experimental/basic string view/operator cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&gt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;= | lexicographically compares two views }}</text>
      <sha1>lpnjaz56tyyh4hcuir24dyz4qc526dl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc operator ltlt</title>
    <ns>10</ns>
    <id>13631</id>
    <revision>
      <id>71351</id>
      <timestamp>2014-06-09T10:22:31Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="117">{{dsc tfun | cpp/experimental/basic_string_view/operator_ltlt | title=operator&lt;&lt; | performs stream output on views }}</text>
      <sha1>bco0p5wqinq5sn0fe07e6oeqw8dhqhk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc rbegin</title>
    <ns>10</ns>
    <id>13592</id>
    <revision>
      <id>71287</id>
      <timestamp>2014-06-09T04:12:48Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem fun | cpp/experimental/basic string view/rbegin | title=rbegin&lt;br&gt;crbegin | returns a reverse iterator to the beginning }}</text>
      <sha1>0zv8od5eb55psl5rj1lthgw757hzayz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc remove prefix</title>
    <ns>10</ns>
    <id>13600</id>
    <revision>
      <id>71301</id>
      <timestamp>2014-06-09T04:34:43Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/experimental/basic string view/remove_prefix | Removes characters from the start of the view }}</text>
      <sha1>c8rinfox2jkmn5f30xeh3d1coi2edct</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc remove suffix</title>
    <ns>10</ns>
    <id>13601</id>
    <revision>
      <id>71302</id>
      <timestamp>2014-06-09T04:35:00Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/experimental/basic string view/remove_suffix | Removes characters from the end of the view }}</text>
      <sha1>njqszdb1v055noyqwlxf44bswvwgg3y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc rend</title>
    <ns>10</ns>
    <id>13591</id>
    <revision>
      <id>71285</id>
      <timestamp>2014-06-09T04:06:12Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/experimental/basic string view/rend | title=rend&lt;br&gt;crend | returns a reverse iterator to the end }}</text>
      <sha1>kp8usk90621iuiuz9ttqaojvh9c4e1g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc rfind</title>
    <ns>10</ns>
    <id>13612</id>
    <revision>
      <id>71322</id>
      <timestamp>2014-06-09T09:02:38Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/experimental/basic_string_view/rfind | find the last occurrence of a substring }}</text>
      <sha1>s2j9i537dt0zk900kurr52x9xrzuqfq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc size</title>
    <ns>10</ns>
    <id>13599</id>
    <revision>
      <id>71299</id>
      <timestamp>2014-06-09T04:33:07Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="117">{{dsc mem fun | cpp/experimental/basic string view/size | title=size&lt;br/&gt;length | returns the number of characters }}</text>
      <sha1>4slu4hor3dvolzgzjxalc7tncz8vfv4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc substr</title>
    <ns>10</ns>
    <id>13605</id>
    <revision>
      <id>71309</id>
      <timestamp>2014-06-09T06:15:40Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/experimental/basic_string_view/substr | returns a substring}}</text>
      <sha1>a43yrq48w0zjayickkvy49slwz5amx4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc swap</title>
    <ns>10</ns>
    <id>13627</id>
    <revision>
      <id>71347</id>
      <timestamp>2014-06-09T10:17:31Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/experimental/basic string view/swap | swaps the contents }}</text>
      <sha1>fyzctcvgbh2fujg0rv5xj94e94bw0eh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/dsc to string</title>
    <ns>10</ns>
    <id>13628</id>
    <revision>
      <id>71348</id>
      <timestamp>2014-06-09T10:19:02Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/experimental/basic string view/to_string | title=to_string&lt;br/&gt;operator basic_string | creates a string from the view}}</text>
      <sha1>rrezuiztj38qxb08ypmz77ep6md8t98</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/navbar</title>
    <ns>10</ns>
    <id>13559</id>
    <revision>
      <id>71114</id>
      <timestamp>2014-06-06T14:43:45Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Created page with &quot;{{navbar |heading1 = cpp/navbar heading |content1 = cpp/navbar content  |heading2 = cpp/experimental/navbar heading |content2 = cpp/experimental/navbar content  |heading3 = cp...&quot;</comment>
      <text xml:space="preserve" bytes="287">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/navbar heading
|content2 = cpp/experimental/navbar content

|heading3 = cpp/experimental/basic_string_view/navbar heading
|content3 = cpp/experimental/basic_string_view/navbar content
}}</text>
      <sha1>hrqy0yajrcqyar6c6zmx2fises57prk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/navbar content</title>
    <ns>10</ns>
    <id>13561</id>
    <revision>
      <id>71118</id>
      <parentid>71117</parentid>
      <timestamp>2014-06-06T15:13:43Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2612">{{nv begin}}
{{nv col begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/experimental/basic_string_view/basic_string_view}}
{{nv mem ln | cpp/experimental/basic_string_view/operator{{=}}}}

{{nv h2 | Iterators}}
{{nv mem ln | cpp/experimental/basic_string_view/begin | begin | cbegin}}
{{nv mem ln | cpp/experimental/basic_string_view/end | end | cend }}
{{nv mem ln | cpp/experimental/basic_string_view/rbegin | rbegin | crbegin }}
{{nv mem ln | cpp/experimental/basic_string_view/rend | rend | crend }}

{{nv h2 | Element access}}
{{nv mem ln | cpp/experimental/basic_string_view/at}}
{{nv mem ln | cpp/experimental/basic_string_view/operator_at | operator[]}}
{{nv mem ln | cpp/experimental/basic_string_view/front}}
{{nv mem ln | cpp/experimental/basic_string_view/back}}
{{nv mem ln | cpp/experimental/basic_string_view/data}}

{{nv h2 | Capacity}}
{{nv mem ln | cpp/experimental/basic_string_view/size | size | length}}
{{nv mem ln | cpp/experimental/basic_string_view/max_size}}
{{nv mem ln | cpp/experimental/basic_string_view/empty}}

{{nv h2 | Modifers}}
{{nv mem ln | cpp/experimental/basic_string_view/clear}}
{{nv mem ln | cpp/experimental/basic_string_view/remove_prefix}}
{{nv mem ln | cpp/experimental/basic_string_view/remove_suffix}}
{{nv mem ln | cpp/experimental/basic_string_view/swap}}

{{nv col next}}

{{nv h2 | Operations}}
{{nv mem ln | cpp/experimental/basic_string_view/to_string | to_string | operator basic_string}}
{{nv mem ln | cpp/experimental/basic_string_view/copy}}
{{nv mem ln | cpp/experimental/basic_string_view/substr}}
{{nv mem ln | cpp/experimental/basic_string_view/compare}}
{{nv mem ln | cpp/experimental/basic_string_view/find}}
{{nv mem ln | cpp/experimental/basic_string_view/rfind}}
{{nv mem ln | cpp/experimental/basic_string_view/find_first_of}}
{{nv mem ln | cpp/experimental/basic_string_view/find_last_of}}
{{nv mem ln | cpp/experimental/basic_string_view/find_first_not_of}}
{{nv mem ln | cpp/experimental/basic_string_view/find_last_not_of}}

{{nv h1 | Constants}}
{{nv mem ln | cpp/experimental/basic_string_view/npos}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/experimental/basic_string_view/operator_cmp | operator{{==}} | operator!{{=}} | operator&lt; | operator&gt; | operator&lt;{{=}} | operator&gt;{{=}} }}
{{nv ln | cpp/experimental/basic_string_view/operator_ltlt | operator&lt;&lt;}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/experimental/basic_string_view/hash | hash{{dsc small|&lt;std::string_view&gt;}} |  hash{{dsc small|&lt;std::wstring_view&gt;}} | hash{{dsc small|&lt;std::u16string_view&gt;}} | hash{{dsc small|&lt;std::u32string_view&gt;}} }}
{{nv col end}}
{{nv end}}</text>
      <sha1>esuofsu5gzp72wf8wakooayz58wququ</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/navbar heading</title>
    <ns>10</ns>
    <id>13560</id>
    <revision>
      <id>71115</id>
      <timestamp>2014-06-06T14:44:54Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Created page with &quot;{{ltt|cpp/experimental/basic_string_view|std::experimental::basic_string_view}}&quot;</comment>
      <text xml:space="preserve" bytes="79">{{ltt|cpp/experimental/basic_string_view|std::experimental::basic_string_view}}</text>
      <sha1>dwqocf758l5dfs09vt704taso2csbuh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/basic string view/title</title>
    <ns>10</ns>
    <id>13558</id>
    <revision>
      <id>71254</id>
      <parentid>71113</parentid>
      <timestamp>2014-06-09T01:35:56Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Fix template params.</comment>
      <text xml:space="preserve" bytes="128">&lt;onlyinclude&gt;{{cpp/title | n=experimental::basic_string_view::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>gkv1tvufzmny8l6gpvxtzhe13a6xrjf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc assign</title>
    <ns>10</ns>
    <id>13234</id>
    <revision>
      <id>68223</id>
      <parentid>68222</parentid>
      <timestamp>2014-03-19T00:36:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/experimental/fs/directory_entry/assign | assigns contents}}</text>
      <sha1>c44eixgwds6iibhes9hgc103k8p4rkj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc constructor</title>
    <ns>10</ns>
    <id>13235</id>
    <revision>
      <id>68225</id>
      <parentid>68224</parentid>
      <timestamp>2014-03-19T00:36:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem ctor | cpp/experimental/fs/directory_entry/directory_entry | constructs a directory entry}}</text>
      <sha1>1t2jc41vfsv8gbwpouq45hsf4e4pxsy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc destructor</title>
    <ns>10</ns>
    <id>13236</id>
    <revision>
      <id>68227</id>
      <parentid>68226</parentid>
      <timestamp>2014-03-19T00:36:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="50">{{dsc mem dtor | nolink=true |default destructor}}</text>
      <sha1>i01ji52k8tx9kvhkfyft88iuv6guyyc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc operator=</title>
    <ns>10</ns>
    <id>13237</id>
    <revision>
      <id>68229</id>
      <parentid>68228</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/experimental/fs/directory_entry/operator{{=}} | assigns contents}}</text>
      <sha1>64f29tni7ac58dwzeqayd8mlp2tgess</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc operator cmp</title>
    <ns>10</ns>
    <id>13238</id>
    <revision>
      <id>68231</id>
      <parentid>68230</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="219">{{dsc mem fun | cpp/experimental/fs/directory_entry/operator_cmp | title=operator{{==}}&lt;br/&gt;opretaro{{!=}}&lt;br/&gt;opetator&amp;lt;&lt;br/&gt;operator&amp;lt;{{=}}&lt;br/&gt;operator&amp;gt;&lt;br/&gt;operator&amp;gt;{{=}} | compares two directory entries}}</text>
      <sha1>53b4ic6gj4s8ce2trse43c9vlwba124</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc path</title>
    <ns>10</ns>
    <id>13239</id>
    <revision>
      <id>68233</id>
      <parentid>68232</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/experimental/fs/directory_entry/path | returns the path the entry refers to}}</text>
      <sha1>lnsas1yj7josr3r9sizj5dn1uge68tp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc replace filename</title>
    <ns>10</ns>
    <id>13240</id>
    <revision>
      <id>68235</id>
      <parentid>68234</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/experimental/fs/directory_entry/replace_filename | sets the filename }}</text>
      <sha1>22mh5arepkdz5qfq5qxdunltzl1rgec</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc status</title>
    <ns>10</ns>
    <id>13241</id>
    <revision>
      <id>68237</id>
      <parentid>68236</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem fun | cpp/experimental/fs/directory_entry/status | returns the status of the file entry refers to}}</text>
      <sha1>eexeo6xgo47erwfibb5oukhn6779vbv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/dsc symlink status</title>
    <ns>10</ns>
    <id>13242</id>
    <revision>
      <id>68239</id>
      <parentid>68238</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/experimental/fs/directory_entry/symbolic_status | returns the status of the target of the symbolic link}}</text>
      <sha1>flcmh3my8ki2o4np7e189d8wnj8ewsr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/navbar</title>
    <ns>10</ns>
    <id>13243</id>
    <revision>
      <id>68241</id>
      <parentid>68240</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="295">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/directory_entry/navbar heading
|content3 = cpp/experimental/fs/directory_entry/navbar content
}}</text>
      <sha1>tt3nhlw5bi65pwk3wgpghz5wzbexaxc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/navbar heading</title>
    <ns>10</ns>
    <id>13244</id>
    <revision>
      <id>68674</id>
      <parentid>68243</parentid>
      <timestamp>2014-03-19T00:39:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="63">{{ltt | cpp/experimental/fs/directory_entry | directory_entry}}</text>
      <sha1>oyx6fcyg7i8ub6ib9pkxxqhjki9gvpi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory entry/title</title>
    <ns>10</ns>
    <id>13245</id>
    <revision>
      <id>68685</id>
      <parentid>68245</parentid>
      <timestamp>2014-03-19T00:47:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="138">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::directory_entry::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>4dvxeh10fin0987f3v3f9fjidpkfsde</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/dsc constructor</title>
    <ns>10</ns>
    <id>13246</id>
    <revision>
      <id>68247</id>
      <parentid>68246</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem ctor | cpp/experimental/fs/directory_iterator/directory_iterator | constructs a directory iterator}}</text>
      <sha1>3q7rldqxa1shwoztv6c94rcn7uyz9qd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/dsc destructor</title>
    <ns>10</ns>
    <id>13247</id>
    <revision>
      <id>68249</id>
      <parentid>68248</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="51">{{dsc mem dtor | nolink=true | default destructor}}</text>
      <sha1>pht56euirfx3859r0v6ael8a57qtkx3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/dsc increment</title>
    <ns>10</ns>
    <id>13248</id>
    <revision>
      <id>68251</id>
      <parentid>68250</parentid>
      <timestamp>2014-03-19T00:36:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem fun | cpp/experimental/fs/directory_iterator/increment | title=increment&lt;br/&gt;operator++ | advances to the next entry}}</text>
      <sha1>7ts1ez9vcw0j07vjfbs4pojf9wn6gv5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/dsc operator*</title>
    <ns>10</ns>
    <id>13249</id>
    <revision>
      <id>68253</id>
      <parentid>68252</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="131">{{dsc mem fun | cpp/experimental/fs/directory_iterator/operator* | title=operator*&lt;br/&gt;operator-&gt; | accesses the pointed-to entry}}</text>
      <sha1>9lwqw5sjuo28k57pkku6ixhfahr1a6v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/dsc operator=</title>
    <ns>10</ns>
    <id>13250</id>
    <revision>
      <id>68255</id>
      <parentid>68254</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/experimental/fs/directory_iterator/operator{{=}} | assigns contents}}</text>
      <sha1>12mgodp9519zoh7qs0owjw0x230dixn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/navbar</title>
    <ns>10</ns>
    <id>13251</id>
    <revision>
      <id>68257</id>
      <parentid>68256</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="301">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/directory_iterator/navbar heading
|content3 = cpp/experimental/fs/directory_iterator/navbar content
}}</text>
      <sha1>3hcye2xypztsqfkrkxr0jjgfmubl8x8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/navbar heading</title>
    <ns>10</ns>
    <id>13252</id>
    <revision>
      <id>68675</id>
      <parentid>68259</parentid>
      <timestamp>2014-03-19T00:39:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="69">{{ltt | cpp/experimental/fs/directory_iterator | directory_iterator}}</text>
      <sha1>pywv5fg520syu1qtsnupj4b4bhbuvjy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/directory iterator/title</title>
    <ns>10</ns>
    <id>13253</id>
    <revision>
      <id>68686</id>
      <parentid>68261</parentid>
      <timestamp>2014-03-19T00:47:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="141">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::directory_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>nceec0nj0b5vk92oq8ffq9jw8izrukt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc absolute</title>
    <ns>10</ns>
    <id>13254</id>
    <revision>
      <id>68263</id>
      <parentid>68262</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | cpp/experimental/fs/absolute | composes an absolute path}}</text>
      <sha1>q7fkjxogr4rdg4o3g4rxj74ebj7g9o7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc canonical</title>
    <ns>10</ns>
    <id>13255</id>
    <revision>
      <id>68265</id>
      <parentid>68264</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | cpp/experimental/fs/canonical | composes a canonical path}}</text>
      <sha1>m2daqjfthi2a46o6iyl2dbw4ag3f8uv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc copy</title>
    <ns>10</ns>
    <id>13256</id>
    <revision>
      <id>68267</id>
      <parentid>68266</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="68">{{dsc fun | cpp/experimental/fs/copy | copies files or directories}}</text>
      <sha1>s7kzu0o91rn6ej9axb60r3a8erj4a9y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc copy file</title>
    <ns>10</ns>
    <id>13257</id>
    <revision>
      <id>68269</id>
      <parentid>68268</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="66">{{dsc fun | cpp/experimental/fs/copy_file | copies file contents}}</text>
      <sha1>il3x53g39f3omcqentd4hfidvs0c3mt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc copy options</title>
    <ns>10</ns>
    <id>13258</id>
    <revision>
      <id>68271</id>
      <parentid>68270</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="88">{{dsc enum | cpp/experimental/fs/copy_options | specifies semantics of copy operations}}</text>
      <sha1>gy3vcbd87sncfpjqjwq6jrr1tsljwdi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc copy symlink</title>
    <ns>10</ns>
    <id>13259</id>
    <revision>
      <id>68273</id>
      <parentid>68272</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | cpp/experimental/fs/copy_symlink | copies a symbolic link}}</text>
      <sha1>hwjznbk7ju5yjwp14u7je3z67yg7hao</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc create directory</title>
    <ns>10</ns>
    <id>13260</id>
    <revision>
      <id>68275</id>
      <parentid>68274</parentid>
      <timestamp>2014-03-19T00:36:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="122">{{dsc fun | cpp/experimental/fs/create_directory | title=create_directory&lt;br/&gt;create_directories | creates new directory}}</text>
      <sha1>k3for7u74sipsnhox9ldidxybr9my16</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc create hard link</title>
    <ns>10</ns>
    <id>13261</id>
    <revision>
      <id>68277</id>
      <parentid>68276</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | cpp/experimental/fs/create_hard_link | creates a hard link}}</text>
      <sha1>m09qrbglsggkvp5hcdnw62mhnka0vsd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc create symlink</title>
    <ns>10</ns>
    <id>13262</id>
    <revision>
      <id>68279</id>
      <parentid>68278</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/experimental/fs/create_symlink | title=create_symlink&lt;br/&gt;create_directory_symlink | creates a symbolic link}}</text>
      <sha1>o2wub8qszd1g01era4o2bm89hjrrnpr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc current path</title>
    <ns>10</ns>
    <id>13263</id>
    <revision>
      <id>68281</id>
      <parentid>68280</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | cpp/experimental/fs/current_path | return current working directory}}</text>
      <sha1>6cubudg98ozcvhnxw6qcawz47wa5e81</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc directory entry</title>
    <ns>10</ns>
    <id>13264</id>
    <revision>
      <id>68283</id>
      <parentid>68282</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="71">{{dsc class | cpp/experimental/fs/directory_entry | a directory entry}}</text>
      <sha1>lg4nry74n2phnsxk95i17yql3ivy7bm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc directory iterator</title>
    <ns>10</ns>
    <id>13265</id>
    <revision>
      <id>68285</id>
      <parentid>68284</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="101">{{dsc class | cpp/experimental/fs/directory_iterator | an iterator to the contents of the directory}}</text>
      <sha1>nv7tx6v9mlh8hbageb7ws3hfh3b7ne7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc directory options</title>
    <ns>10</ns>
    <id>13266</id>
    <revision>
      <id>68287</id>
      <parentid>68286</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="95">{{dsc enum | cpp/experimental/fs/directory_options | options for iterating directory contents}}</text>
      <sha1>r1jjkde3esbxcvj69fg8gt7yhfakt5i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc equivalent</title>
    <ns>10</ns>
    <id>13267</id>
    <revision>
      <id>68289</id>
      <parentid>68288</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="108">{{dsc fun | cpp/experimental/fs/equivalent | checks whether two paths refer to the same file system object}}</text>
      <sha1>lonpiufl3dhqc7hvy6syuhd7r9153f8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc exists</title>
    <ns>10</ns>
    <id>13268</id>
    <revision>
      <id>68291</id>
      <parentid>68290</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/experimental/fs/exists | checks whether path refers to existing file system object }}</text>
      <sha1>7monmoyq77kwblqas5nrs1eldppzs3n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc file size</title>
    <ns>10</ns>
    <id>13269</id>
    <revision>
      <id>68293</id>
      <parentid>68292</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | cpp/experimental/fs/file_size | returns the size of a file}}</text>
      <sha1>3joayy4af0vi0s3thg7v70e8p4t8skr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc file status</title>
    <ns>10</ns>
    <id>13270</id>
    <revision>
      <id>68295</id>
      <parentid>68294</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="86">{{dsc class | cpp/experimental/fs/file_status | represents file type and permissions}}</text>
      <sha1>ry70oxc52c3nr4xn00oytbld14cygj4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc file time type</title>
    <ns>10</ns>
    <id>13271</id>
    <revision>
      <id>68297</id>
      <parentid>68296</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="82">{{dsc typedef | cpp/experimental/fs/file_time_type | represents file time values}}</text>
      <sha1>139f2zmxq7y6b7epptvwy69j7tdam2x</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc file type</title>
    <ns>10</ns>
    <id>13272</id>
    <revision>
      <id>68299</id>
      <parentid>68298</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="65">{{dsc enum | cpp/experimental/fs/file_type | the type of a file}}</text>
      <sha1>680kyx3ijxvtrh20j22ij8t5nobw4f4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc filesystem error</title>
    <ns>10</ns>
    <id>13273</id>
    <revision>
      <id>68301</id>
      <parentid>68300</parentid>
      <timestamp>2014-03-19T00:36:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="96">{{dsc class | cpp/experimental/fs/filesystem_error | an exception thrown on file system errors}}</text>
      <sha1>1g91ipf4tx0p7fg1fyxk34cs2pbrm69</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc hard link count</title>
    <ns>10</ns>
    <id>13274</id>
    <revision>
      <id>68303</id>
      <parentid>68302</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="115">{{dsc fun | cpp/experimental/fs/hard_link_count | returns the number of hard links referring to the specific file}}</text>
      <sha1>cr0v6nhhym9o5tcksgbugkehwil4ljb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is block file</title>
    <ns>10</ns>
    <id>13275</id>
    <revision>
      <id>68305</id>
      <parentid>68304</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/experimental/fs/is_block_file | checks whether the given path refers to block file}}</text>
      <sha1>6clnpx7utkdfcce3jobsst1h2p9ukue</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is character file</title>
    <ns>10</ns>
    <id>13276</id>
    <revision>
      <id>68307</id>
      <parentid>68306</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/experimental/fs/is_character_file | checks whether the given path refers to a character file}}</text>
      <sha1>80jr06pvczjnbazpssn26igbi9n9r30</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is directory</title>
    <ns>10</ns>
    <id>13277</id>
    <revision>
      <id>68309</id>
      <parentid>68308</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/experimental/fs/is_directory | checks whether the given path refers to a directory}}</text>
      <sha1>dmodnix9mmnqduf54an4eb6jm7c9tzx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is empty</title>
    <ns>10</ns>
    <id>13278</id>
    <revision>
      <id>68311</id>
      <parentid>68310</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | cpp/experimental/fs/is_empty | checks whether the given path refers to an empty file or directory}}</text>
      <sha1>20flqh3n7o7b0i25z1ht9audqnafajq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is fifo</title>
    <ns>10</ns>
    <id>13279</id>
    <revision>
      <id>68313</id>
      <parentid>68312</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/experimental/fs/is_fifo | checks whether the given path refers to a FIFO}}</text>
      <sha1>n8zq6hl86g5kckstvbscoruv9ovttgs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is other</title>
    <ns>10</ns>
    <id>13280</id>
    <revision>
      <id>68315</id>
      <parentid>68314</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/experimental/fs/is_other | checks whether the argument refers to an ''other'' file}}</text>
      <sha1>3umzcfmificywhnigufm9rrunwn5c9u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is regular file</title>
    <ns>10</ns>
    <id>13281</id>
    <revision>
      <id>68317</id>
      <parentid>68316</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/experimental/fs/is_regular_file | checks whether the argument refers to a regular file}}</text>
      <sha1>gxl5sowl4n69ty7uasncyxc125b8819</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is socket</title>
    <ns>10</ns>
    <id>13282</id>
    <revision>
      <id>68319</id>
      <parentid>68318</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/experimental/fs/is_socket | checks whether the argument refers to a socket}}</text>
      <sha1>qt3k22c7qep6b8jymtji9q7hx031y0g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is symlink</title>
    <ns>10</ns>
    <id>13283</id>
    <revision>
      <id>68321</id>
      <parentid>68320</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/experimental/fs/is_symlink | checks whether the argument refers to a symbolic link}}</text>
      <sha1>r8d3ueoivanwbzwsvqxndfhzg2il07m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc is type</title>
    <ns>10</ns>
    <id>13284</id>
    <revision>
      <id>68323</id>
      <parentid>68322</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="262">{{dsc fun | cpp/experimental/fs/is_type | title=is_block_file&lt;br/&gt;is_character_file&lt;br/&gt;is_directory&lt;br/&gt;is_empty&lt;br/&gt;is_fifo&lt;br/&gt;is_other&lt;br/&gt;is_regular_file&lt;br/&gt;is_socket&lt;br/&gt;is_symlink | checks checks whether the given path refers to a file of specific type}}</text>
      <sha1>bykl8xfnhsvnimicrznnriiuzmkxuj5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc path</title>
    <ns>10</ns>
    <id>13285</id>
    <revision>
      <id>68325</id>
      <parentid>68324</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="74">{{dsc class | cpp/experimental/fs/path | represents a path | since=fs_ts}}</text>
      <sha1>r5rxb1dka5ow2ej2mlq94g9p984h65w</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc perms</title>
    <ns>10</ns>
    <id>13286</id>
    <revision>
      <id>68327</id>
      <parentid>68326</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="77">{{dsc enum | cpp/experimental/fs/perms | identifies file system permissions}}</text>
      <sha1>r0zujezib4g44ymd7imow8719kcropz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc recursive directory iterator</title>
    <ns>10</ns>
    <id>13287</id>
    <revision>
      <id>68329</id>
      <parentid>68328</parentid>
      <timestamp>2014-03-19T00:36:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="132">{{dsc class | cpp/experimental/fs/recursive_directory_iterator | an iterator to the contents of a directory and its subdirectories}}</text>
      <sha1>pn4kiqpr9xbzsk04qj09q6u4f3m0nul</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc space info</title>
    <ns>10</ns>
    <id>13288</id>
    <revision>
      <id>68331</id>
      <parentid>68330</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="109">{{dsc class | cpp/experimental/fs/space_info | information about free and available space on the filesystem}}</text>
      <sha1>hbqfeu0yakzmtjvnkd7ciqd7vppy2p4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/dsc temp directory path</title>
    <ns>10</ns>
    <id>13289</id>
    <revision>
      <id>68333</id>
      <parentid>68332</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/experimental/fs/temp_directory_path | returns a directory suitable for temporary files}}</text>
      <sha1>nokupvel84j5ek7u66zpfnvbddhkq9l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/dsc constructor</title>
    <ns>10</ns>
    <id>13290</id>
    <revision>
      <id>68335</id>
      <parentid>68334</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem ctor | cpp/experimental/fs/file_status/file_status | constructs a {{tt|file_status}} object}}</text>
      <sha1>3fvrqs8x4cs1qj1vjutpiafhn6u3mg1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/dsc destructor</title>
    <ns>10</ns>
    <id>13291</id>
    <revision>
      <id>68337</id>
      <parentid>68336</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="52">{{dsc mem dtor | nolink=true | implicit destructor}}</text>
      <sha1>bqy69mkfl93bt5tnxpbi6657yobcrft</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/dsc operator=</title>
    <ns>10</ns>
    <id>13292</id>
    <revision>
      <id>68339</id>
      <parentid>68338</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/experimental/fs/file_status/operator{{=}} | assigns contents}}</text>
      <sha1>0d7yfe2ysydenkbw7hjw86dmhbci7n6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/dsc permissions</title>
    <ns>10</ns>
    <id>13293</id>
    <revision>
      <id>68341</id>
      <parentid>68340</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/experimental/fs/file_status/permissions | gets or sets the permissions of the file}}</text>
      <sha1>oavt0lid3u7xmojot76obygqdpw79qp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/dsc type</title>
    <ns>10</ns>
    <id>13294</id>
    <revision>
      <id>68343</id>
      <parentid>68342</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/experimental/fs/file_status/type | gets or sets the type of the file}}</text>
      <sha1>g3e6ul62jt0ziby31xkfw1jekiuao3e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/navbar</title>
    <ns>10</ns>
    <id>13295</id>
    <revision>
      <id>68345</id>
      <parentid>68344</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="287">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/file_status/navbar heading
|content3 = cpp/experimental/fs/file_status/navbar content
}}</text>
      <sha1>topwua6nt21el7kr6i2yg15zl1xjozq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/navbar heading</title>
    <ns>10</ns>
    <id>13296</id>
    <revision>
      <id>68676</id>
      <parentid>68347</parentid>
      <timestamp>2014-03-19T00:39:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="55">{{ltt | cpp/experimental/fs/file_status | file_status}}</text>
      <sha1>kpgkdbt8424hl49kb8r6ew8ts5wmchf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/file status/title</title>
    <ns>10</ns>
    <id>13297</id>
    <revision>
      <id>68687</id>
      <parentid>68349</parentid>
      <timestamp>2014-03-19T00:47:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="134">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::file_status::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>f76y8q6hspznd8la0lp0zg264nfcvub</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/dsc constructor</title>
    <ns>10</ns>
    <id>13298</id>
    <revision>
      <id>68351</id>
      <parentid>68350</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem ctor | cpp/experimental/fs/filesystem_error/filesystem_error | constructs the error object}}</text>
      <sha1>l2wmt7ljae3g95w5whsi8lug3s8dpq3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/dsc path</title>
    <ns>10</ns>
    <id>13299</id>
    <revision>
      <id>68353</id>
      <parentid>68352</parentid>
      <timestamp>2014-03-19T00:36:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem fun | cpp/experimental/fs/filesystem_error/path | title=path1&lt;br/&gt;path2 | returns the paths that were involved in the operation that caused the error}}</text>
      <sha1>i2euy6157p70jvaiyclc635b0bseucu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/dsc what</title>
    <ns>10</ns>
    <id>13300</id>
    <revision>
      <id>68355</id>
      <parentid>68354</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/experimental/fs/filesystem_error/what | returns the explanatory string}}</text>
      <sha1>otb8ju5crq2m3uco2az6uyezsa56yj5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/navbar</title>
    <ns>10</ns>
    <id>13301</id>
    <revision>
      <id>68357</id>
      <parentid>68356</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="297">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/filesystem_error/navbar heading
|content3 = cpp/experimental/fs/filesystem_error/navbar content
}}</text>
      <sha1>q7csbek2u8mrbnz4ncpa03vg8jwndqh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/navbar heading</title>
    <ns>10</ns>
    <id>13302</id>
    <revision>
      <id>68677</id>
      <parentid>68359</parentid>
      <timestamp>2014-03-19T00:39:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="65">{{ltt | cpp/experimental/fs/filesystem_error | filesystem_error}}</text>
      <sha1>rp8i9lhpd2zwcyqgzd08dvuan11ufnc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/filesystem error/title</title>
    <ns>10</ns>
    <id>13303</id>
    <revision>
      <id>68688</id>
      <parentid>68361</parentid>
      <timestamp>2014-03-19T00:47:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="139">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::filesystem_error::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>qzkh3o13i8mjzc66q8wpxbe53rnngoe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/navbar</title>
    <ns>10</ns>
    <id>13304</id>
    <revision>
      <id>68363</id>
      <parentid>68362</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="168">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content
}}</text>
      <sha1>ogtgbjpjtkd4djg0z6o4npzvlw3hvem</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/navbar heading</title>
    <ns>10</ns>
    <id>13305</id>
    <revision>
      <id>68683</id>
      <parentid>68365</parentid>
      <timestamp>2014-03-19T00:45:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="44">[[cpp/experimental/fs | Filesystem library]]</text>
      <sha1>jxd0nq57djl5yxphu93r7nmh0ayhwin</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc append</title>
    <ns>10</ns>
    <id>13306</id>
    <revision>
      <id>68367</id>
      <parentid>68366</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem fun | cpp/experimental/fs/path/append | title=append&lt;br/&gt;operator/{{=}} | appends elements to the path}}</text>
      <sha1>kxr1nmjq7dy8vrahiuusbu6hw8jtjao</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc assign</title>
    <ns>10</ns>
    <id>13307</id>
    <revision>
      <id>68369</id>
      <parentid>68368</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="68">{{dsc mem fun | cpp/experimental/fs/path/assign | assigns contents}}</text>
      <sha1>qz8gnuxc74j3w1fljavr03sa1tbalf7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc begin</title>
    <ns>10</ns>
    <id>13308</id>
    <revision>
      <id>68371</id>
      <parentid>68370</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/experimental/fs/path/begin | returns an iterator to the beginning of element list}}</text>
      <sha1>rnys85bjtexp8vb40hyiroffnb16734</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc c str</title>
    <ns>10</ns>
    <id>13309</id>
    <revision>
      <id>68373</id>
      <parentid>68372</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/experimental/fs/path/c_str | returns the native version of the path }}</text>
      <sha1>5os0ge8p87yt45gn1i1s470r48hrppy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc clear</title>
    <ns>10</ns>
    <id>13310</id>
    <revision>
      <id>68375</id>
      <parentid>68374</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/experimental/fs/path/clear | erases the contents }}</text>
      <sha1>byiy9gfvv6025rd1rzd8ir7jtsh0h5l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc compare</title>
    <ns>10</ns>
    <id>13311</id>
    <revision>
      <id>68377</id>
      <parentid>68376</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/experimental/fs/path/compare | compares the lexical representations of two paths lexicographically}}</text>
      <sha1>bdibplq25x0bsnsrqsnr42pgzodqcdx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc concat</title>
    <ns>10</ns>
    <id>13312</id>
    <revision>
      <id>68379</id>
      <parentid>68378</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/experimental/fs/path/concat | title=concat&lt;br/&gt;operator+{{=}} | concatenates two paths}}</text>
      <sha1>2rz8a8er192bvcx6evsaymfhmjerle9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc constructor</title>
    <ns>10</ns>
    <id>13313</id>
    <revision>
      <id>68381</id>
      <parentid>68380</parentid>
      <timestamp>2014-03-19T00:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem ctor | cpp/experimental/fs/path/path | constructs a {{tt|path}}}}</text>
      <sha1>69anpce93u80wqmpsdp2likox9nmjlt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc destructor</title>
    <ns>10</ns>
    <id>13314</id>
    <revision>
      <id>68383</id>
      <parentid>68382</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem dtor | cpp/experimental/fs/path/~path | destroys a {{tt|path}} object}}</text>
      <sha1>exruayy7cripzvh8plibj9krh6jritz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc empty</title>
    <ns>10</ns>
    <id>13315</id>
    <revision>
      <id>68385</id>
      <parentid>68384</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/experimental/fs/path/empty | checks if the path is empty}}</text>
      <sha1>rza32dlwu0mex3bzvvs0l60jdf9nqrw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc end</title>
    <ns>10</ns>
    <id>13316</id>
    <revision>
      <id>68387</id>
      <parentid>68386</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/experimental/fs/path/end | returns an iterator to the end of element list}}</text>
      <sha1>g2rinzg93iq4h35hflloa5a2p35l0ig</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc extension</title>
    <ns>10</ns>
    <id>13317</id>
    <revision>
      <id>68389</id>
      <parentid>68388</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/experimental/fs/path/extension | returns the file extension path component}}</text>
      <sha1>kykzys0qgb995e095rs5sbqow0xs96f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc filename</title>
    <ns>10</ns>
    <id>13318</id>
    <revision>
      <id>68391</id>
      <parentid>68390</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/experimental/fs/path/filename | returns the filename path component}}</text>
      <sha1>irw0d6xpsd13258vvy1pio0mw2xdk9p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc generic string</title>
    <ns>10</ns>
    <id>13319</id>
    <revision>
      <id>68393</id>
      <parentid>68392</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="233">{{dsc mem fun | cpp/experimental/fs/path/generic_string | title=generic_string&lt;br/&gt;generic_wstring&lt;br/&gt;generic_u8string&lt;br/&gt;generic_u16string&lt;br/&gt;generic_u32string | returns the path in generic pathname format converted to a string}}</text>
      <sha1>khh2mxriyqrc4a7erntcc2dghwx36v8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc has path</title>
    <ns>10</ns>
    <id>13320</id>
    <revision>
      <id>68395</id>
      <parentid>68394</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="260">{{dsc mem fun | cpp/experimental/fs/path/has_path | title=has_root_path&lt;br/&gt;has_root_name&lt;br/&gt;has_root_directory&lt;br/&gt;has_relative_path&lt;br/&gt;has_parent_path&lt;br/&gt;has_filename&lt;br/&gt;has_stem&lt;br/&gt;has_extension | checks if the corresponding path element is not empty}}</text>
      <sha1>5mqx0lmv1d8pvnry40o8rxmddi6o98m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc is absrel</title>
    <ns>10</ns>
    <id>13321</id>
    <revision>
      <id>68397</id>
      <parentid>68396</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="160">{{dsc mem fun | cpp/experimental/fs/path/is_absrel | title=is_absolute&lt;br/&gt;is_relative | checks if {{lc|root_path()}} uniquely identifies file system location}}</text>
      <sha1>ipd3o9y18dmmv8gkbxyg0galc8w1ppj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc make preferred</title>
    <ns>10</ns>
    <id>13322</id>
    <revision>
      <id>68399</id>
      <parentid>68398</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/experimental/fs/path/make_preferred | converts directory separators to preferred directory separator}}</text>
      <sha1>mwv72ou6dhw6uwepdvyl2xz4mo6ev5e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc native</title>
    <ns>10</ns>
    <id>13323</id>
    <revision>
      <id>68401</id>
      <parentid>68400</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="131">{{dsc mem fun | cpp/experimental/fs/path/native | title=native&lt;br/&gt;operator string_type | returns the native version of the path }}</text>
      <sha1>31jutfpmi20iur9dk89iqktha6z21rl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator/</title>
    <ns>10</ns>
    <id>13324</id>
    <revision>
      <id>68403</id>
      <parentid>68402</parentid>
      <timestamp>2014-03-19T00:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/experimental/fs/path/operator_slash | title=operator/ | concatenates two paths}}</text>
      <sha1>efuw2rhkiqjd9x90hdn0kcdgp59b78m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator=</title>
    <ns>10</ns>
    <id>13325</id>
    <revision>
      <id>68405</id>
      <parentid>68404</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/experimental/fs/path/operator{{=}} | assigns another path}}</text>
      <sha1>rqy0a4slnmspg1g4u53x31ego33fu20</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator +=</title>
    <ns>10</ns>
    <id>13326</id>
    <revision>
      <id>68407</id>
      <parentid>68406</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/experimental/fs/path/operator+{{=}} | appends elements to the path}}</text>
      <sha1>fqn65f5jaxig5cy5yp6hbgdb5c4b5qs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator cmp</title>
    <ns>10</ns>
    <id>13327</id>
    <revision>
      <id>68409</id>
      <parentid>68408</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="210">{{dsc fun | cpp/experimental/fs/path/operator_cmp | title=operator{{==}}&lt;br/&gt;operator!{{=}}&lt;br/&gt;operator&amp;lt;&lt;br/&gt;operator&amp;lt;{{=}}&lt;br/&gt;operator&amp;gt;&lt;br/&gt;operator&amp;gt;{{=}} | lexicographically compares two paths}}</text>
      <sha1>fabrtt6qdmkli8duw3h5xgnzm3q2ru6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>13328</id>
    <revision>
      <id>68411</id>
      <parentid>68410</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="147">{{dsc fun | cpp/experimental/fs/path/operator_ltltgtgt | title=operator&amp;lt;&amp;lt;&lt;br/&gt;operator&amp;gt;&amp;gt; | performs stream input and output on a path}}</text>
      <sha1>0lqa4n0i8j0b187f1usjrptwvapzqcr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator slash</title>
    <ns>10</ns>
    <id>13329</id>
    <revision>
      <id>68413</id>
      <parentid>68412</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/experimental/fs/path/operator_slash | title=operator/ | concatenates two paths}}</text>
      <sha1>efuw2rhkiqjd9x90hdn0kcdgp59b78m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc operator slash=</title>
    <ns>10</ns>
    <id>13330</id>
    <revision>
      <id>68415</id>
      <parentid>68414</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="116">{{dsc mem fun | cpp/experimental/fs/path/operator_slash{{=}} | title=operator/{{=}} | appends elements to the path}}</text>
      <sha1>7k0m7a4oj9t90j0s43fhadzfl6ydt5f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc parent path</title>
    <ns>10</ns>
    <id>13331</id>
    <revision>
      <id>68417</id>
      <parentid>68416</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/experimental/fs/path/parent_path | returns the path of the parent path}}</text>
      <sha1>5rdyyyzxmnu4i7el0nc2eetoot2ckhf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc relative path</title>
    <ns>10</ns>
    <id>13332</id>
    <revision>
      <id>68419</id>
      <parentid>68418</parentid>
      <timestamp>2014-03-19T00:36:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/experimental/fs/path/relative_path | returns path relative to the root path}}</text>
      <sha1>e5w5gwwqalofcpi0j7os7bab1glskwo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc remove filename</title>
    <ns>10</ns>
    <id>13333</id>
    <revision>
      <id>68421</id>
      <parentid>68420</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/experimental/fs/path/remove_filename | removes filename path component}}</text>
      <sha1>tga4jwfl8mzrw6anj6eecmg2205cqv8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc replace extension</title>
    <ns>10</ns>
    <id>13334</id>
    <revision>
      <id>68423</id>
      <parentid>68422</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/experimental/fs/path/replace_extension | replaces the extension}}</text>
      <sha1>l9t96vf6g4k91d45wwsurcavs1xjhgi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc replace filename</title>
    <ns>10</ns>
    <id>13335</id>
    <revision>
      <id>68698</id>
      <parentid>68425</parentid>
      <timestamp>2014-03-19T13:49:43Z</timestamp>
      <contributor>
        <ip>159.178.227.1</ip>
      </contributor>
      <comment>fix typo</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/experimental/fs/path/replace_filename | replaces the last path component with another path}}</text>
      <sha1>tj2w14v9o076z3wr09fcn7s10wy9fsm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc root directory</title>
    <ns>10</ns>
    <id>13336</id>
    <revision>
      <id>68427</id>
      <parentid>68426</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem fun | cpp/experimental/fs/path/root_directory | returns the root directory of the path, if present}}</text>
      <sha1>bzkusw9w9oo3dqpk591w0336qdr2laf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc root name</title>
    <ns>10</ns>
    <id>13337</id>
    <revision>
      <id>68429</id>
      <parentid>68428</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/experimental/fs/path/root_name | returns the root-name of the path, if present}}</text>
      <sha1>0pcznf1vwsb8a4nfbxpx461wqzvtiv2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc root path</title>
    <ns>10</ns>
    <id>13338</id>
    <revision>
      <id>68431</id>
      <parentid>68430</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/experimental/fs/path/root_path | returns the root path of the path, if present}}</text>
      <sha1>pq5g9whrf61ky2by50kypfbryd8230y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc stem</title>
    <ns>10</ns>
    <id>13339</id>
    <revision>
      <id>68433</id>
      <parentid>68432</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/experimental/fs/path/stem | returns the stem path component}}</text>
      <sha1>qmeb9ajpxlxjr43bnq9lpmye4h0qza9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc string</title>
    <ns>10</ns>
    <id>13340</id>
    <revision>
      <id>68435</id>
      <parentid>68434</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="184">{{dsc mem fun | cpp/experimental/fs/path/string | title=string&lt;br/&gt;wstring&lt;br/&gt;u8string&lt;br/&gt;u16string&lt;br/&gt;u32string | returns the path in native pathname format converted to a string}}</text>
      <sha1>s3t53j597elk83n221hzzm8xzga9h6s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc swap</title>
    <ns>10</ns>
    <id>13341</id>
    <revision>
      <id>68437</id>
      <parentid>68436</parentid>
      <timestamp>2014-03-19T00:36:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="65">{{dsc mem fun | cpp/experimental/fs/path/swap | swaps two paths}}</text>
      <sha1>pn2w8fjw1ecrcqoj20i2gcxgx5ush58</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc swap2</title>
    <ns>10</ns>
    <id>13342</id>
    <revision>
      <id>68439</id>
      <parentid>68438</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/experimental/fs/path/swap2 | title=swap{{dsc small|(std::fs::path)}} | swaps two paths}}</text>
      <sha1>bjl5986g808qorhsqilvpctyz91mnw1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/dsc u8path</title>
    <ns>10</ns>
    <id>13343</id>
    <revision>
      <id>68441</id>
      <parentid>68440</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | cpp/experimental/fs/path/u8path | creates a {{tt|path}} from a UTF-8 encoded source}}</text>
      <sha1>ompx12553b85cxsiner53l65dlaiuf7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/navbar</title>
    <ns>10</ns>
    <id>13344</id>
    <revision>
      <id>68443</id>
      <parentid>68442</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="273">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/path/navbar heading
|content3 = cpp/experimental/fs/path/navbar content
}}</text>
      <sha1>k1hz62jv47t2eskdk3n1cl1c8hz8s6b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/navbar heading</title>
    <ns>10</ns>
    <id>13345</id>
    <revision>
      <id>68678</id>
      <parentid>68445</parentid>
      <timestamp>2014-03-19T00:39:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/experimental/fs/path | path}}</text>
      <sha1>hbzn2vcm7rpsbxob0f82zddp4ujg0d6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/path/title</title>
    <ns>10</ns>
    <id>13346</id>
    <revision>
      <id>68684</id>
      <parentid>68447</parentid>
      <timestamp>2014-03-19T00:47:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="127">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::path::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>ar2fat2kpzwxv9kfvfcp28kgsq7miyv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc constructor</title>
    <ns>10</ns>
    <id>13347</id>
    <revision>
      <id>68449</id>
      <parentid>68448</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="140">{{dsc mem ctor | cpp/experimental/fs/recursive_directory_iterator/recursive_directory_iterator | constructs a recursive directory iterator}}</text>
      <sha1>jlskpc317uqsrnqp35gj2llvgprl2rs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc depth</title>
    <ns>10</ns>
    <id>13348</id>
    <revision>
      <id>68451</id>
      <parentid>68450</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/depth | returns the current recursion depth}}</text>
      <sha1>53pj4sb35mclh6jc3g168xo4z02pxfq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc destructor</title>
    <ns>10</ns>
    <id>13349</id>
    <revision>
      <id>68453</id>
      <parentid>68452</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="51">{{dsc mem dtor | nolink=true | default destructor}}</text>
      <sha1>pht56euirfx3859r0v6ael8a57qtkx3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc disable recursion pending</title>
    <ns>10</ns>
    <id>13350</id>
    <revision>
      <id>68455</id>
      <parentid>68454</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="138">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/disable_recursion_pending | disables recursion until the next increment}}</text>
      <sha1>penerct343tr8as1pzyxkub6jqt4lt0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc increment</title>
    <ns>10</ns>
    <id>13351</id>
    <revision>
      <id>68457</id>
      <parentid>68456</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="138">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/increment | title=increment&lt;br/&gt;operator++ | advances to the next entry}}</text>
      <sha1>c58ijtww4d25gdj1b5hv3kz94lkz495</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc operator*</title>
    <ns>10</ns>
    <id>13352</id>
    <revision>
      <id>68459</id>
      <parentid>68458</parentid>
      <timestamp>2014-03-19T00:36:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="141">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/operator* | title=operator*&lt;br/&gt;operator-&gt; | accesses the pointed-to entry}}</text>
      <sha1>lj9chjisp2jqpufgttrwj3tlzj4d0df</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc operator=</title>
    <ns>10</ns>
    <id>13353</id>
    <revision>
      <id>68461</id>
      <parentid>68460</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/operator{{=}} | assigns contents}}</text>
      <sha1>fqqo4ivtux6c326b5kb2qmof8qk701m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc options</title>
    <ns>10</ns>
    <id>13354</id>
    <revision>
      <id>68463</id>
      <parentid>68462</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/options | returns the currently active options that affect the iteration}}</text>
      <sha1>a83htxodzz8yq8qpc6zr0vxk0x1ntl1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc pop</title>
    <ns>10</ns>
    <id>13355</id>
    <revision>
      <id>68465</id>
      <parentid>68464</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="131">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/pop | moves the iterator one level up in the directory hierarchy}}</text>
      <sha1>otjykq8y10a800jkp6xgqdt9we8cds7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/dsc recursion pending</title>
    <ns>10</ns>
    <id>13356</id>
    <revision>
      <id>68467</id>
      <parentid>68466</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="153">{{dsc mem fun | cpp/experimental/fs/recursive_directory_iterator/recursion_pending | checks whether the recursion is disabled for the current directory}}</text>
      <sha1>kwbrp0ikyssuns53x0heq7tq7rwyysf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/navbar</title>
    <ns>10</ns>
    <id>13357</id>
    <revision>
      <id>68469</id>
      <parentid>68468</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="321">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/fs/navbar heading
|content2 = cpp/experimental/fs/navbar content

|heading3 = cpp/experimental/fs/recursive_directory_iterator/navbar heading
|content3 = cpp/experimental/fs/recursive_directory_iterator/navbar content
}}</text>
      <sha1>18ss8j1yn20bva5o07fked45nvxv7ul</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/navbar heading</title>
    <ns>10</ns>
    <id>13358</id>
    <revision>
      <id>68679</id>
      <parentid>68471</parentid>
      <timestamp>2014-03-19T00:40:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ns is evident from the title</comment>
      <text xml:space="preserve" bytes="89">{{ltt | cpp/experimental/fs/recursive_directory_iterator | recursive_directory_iterator}}</text>
      <sha1>t3a9y85tevh6zf9n6om179p5mij7c1p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/recursive directory iterator/title</title>
    <ns>10</ns>
    <id>13359</id>
    <revision>
      <id>68689</id>
      <parentid>68473</parentid>
      <timestamp>2014-03-19T00:48:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="151">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::recursive_directory_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>rmhc3ob1qfu8t9tqrmxgs45pnp16rvs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/fs/title</title>
    <ns>10</ns>
    <id>13360</id>
    <revision>
      <id>68475</id>
      <parentid>68474</parentid>
      <timestamp>2014-03-19T00:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: Import from a private wiki</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/title | n=experimental::filesystem::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>cn40gsjoxscq80wy5ilato0tfgig3l7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/memory/navbar</title>
    <ns>10</ns>
    <id>13675</id>
    <revision>
      <id>71543</id>
      <timestamp>2014-06-13T05:54:58Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="265">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/navbar heading
|content2 = cpp/experimental/navbar content

|heading3 = cpp/experimental/memory/navbar heading
|content3 = cpp/experimental/memory/navbar content
}}</text>
      <sha1>doprsxtpkporo05k8k2gxud35dfhwnr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/memory/navbar content</title>
    <ns>10</ns>
    <id>13677</id>
    <revision>
      <id>71546</id>
      <timestamp>2014-06-13T06:06:23Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="310">{{nv begin}}
{{nv h1 | Classes}}
{{nv ln | cpp/experimental/pmr/memory_resource }}
{{nv ln | cpp/experimental/pmr/polymorphic_allocator }}
{{nv ln | cpp/experimental/pmr/resource_adaptor }}
{{nv ln | cpp/string/synchronized_pool_resource | synchronized_pool_resource | unsynchronized_pool_resource}}
{{nv end}}</text>
      <sha1>s929einpemr4g6tmbqjwhvylrf3ck90</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/memory/navbar heading</title>
    <ns>10</ns>
    <id>13676</id>
    <revision>
      <id>71545</id>
      <timestamp>2014-06-13T06:02:09Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="59">[[cpp/experimental/memory | Polymorphic allocator library]]</text>
      <sha1>dluxsrk783etviwchwf8opwd39seisj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/navbar content</title>
    <ns>10</ns>
    <id>13585</id>
    <revision>
      <id>71549</id>
      <parentid>71544</parentid>
      <timestamp>2014-06-13T06:15:39Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Update link formatting (targets aren't classes).</comment>
      <text xml:space="preserve" bytes="463">{{nv begin}}
{{nv h1 | Experimental standard libraries }}
{{nv ln | cpp/experimental/optional | notes={{mark since libfund ts}} }}
{{nv ln | cpp/experimental/any | notes={{mark since libfund ts}} }}
{{nv ln | cpp/experimental/basic_string_view | notes={{mark since libfund ts}} }}
{{nv | [[cpp/experimental/memory | Polymorphic allocator library]] {{mark since libfund ts}}}}
{{nv | [[cpp/experimental/fs  | Filesystem library]] {{mark since fs ts}} }}
{{nv end}}</text>
      <sha1>fdm6x4s1k7yhuk85phoyg09zrs5kekt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/navbar heading</title>
    <ns>10</ns>
    <id>13233</id>
    <revision>
      <id>68184</id>
      <timestamp>2014-03-17T01:52:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="45">[[cpp/experimental | Experimental libraries]]</text>
      <sha1>edfzvqynylafw1lidaqrl30aizknwt5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list constructor</title>
    <ns>10</ns>
    <id>12523</id>
    <redirect title="Template:cpp/utility/optional/dsc constructor" />
    <revision>
      <id>68069</id>
      <parentid>60711</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list constructor]] to [[Template:cpp/experimental/optional/dcl list constructor]]</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/utility/optional/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list destructor</title>
    <ns>10</ns>
    <id>12524</id>
    <redirect title="Template:cpp/utility/optional/dsc destructor" />
    <revision>
      <id>68071</id>
      <parentid>60713</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list destructor]] to [[Template:cpp/experimental/optional/dcl list destructor]]</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/optional/dsc destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list emplace</title>
    <ns>10</ns>
    <id>12525</id>
    <redirect title="Template:cpp/utility/optional/dsc emplace" />
    <revision>
      <id>68073</id>
      <parentid>60715</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list emplace]] to [[Template:cpp/experimental/optional/dcl list emplace]]</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/optional/dsc emplace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list hash</title>
    <ns>10</ns>
    <id>12526</id>
    <redirect title="Template:cpp/utility/optional/dsc hash" />
    <revision>
      <id>68075</id>
      <parentid>60717</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list hash]] to [[Template:cpp/experimental/optional/dcl list hash]]</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/utility/optional/dsc hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list make optional</title>
    <ns>10</ns>
    <id>12527</id>
    <redirect title="Template:cpp/utility/optional/dsc make optional" />
    <revision>
      <id>68077</id>
      <parentid>60719</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list make optional]] to [[Template:cpp/experimental/optional/dcl list make optional]]</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/optional/dsc make optional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list operator*</title>
    <ns>10</ns>
    <id>12528</id>
    <redirect title="Template:cpp/utility/optional/dsc operator*" />
    <revision>
      <id>68079</id>
      <parentid>60721</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list operator*]] to [[Template:cpp/experimental/optional/dcl list operator*]]</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/optional/dsc operator*]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list operator=</title>
    <ns>10</ns>
    <id>12529</id>
    <redirect title="Template:cpp/utility/optional/dsc operator=" />
    <revision>
      <id>68081</id>
      <parentid>60723</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list operator=]] to [[Template:cpp/experimental/optional/dcl list operator=]]</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/optional/dsc operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list operator bool</title>
    <ns>10</ns>
    <id>12530</id>
    <redirect title="Template:cpp/utility/optional/dsc operator bool" />
    <revision>
      <id>68083</id>
      <parentid>60725</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list operator bool]] to [[Template:cpp/experimental/optional/dcl list operator bool]]</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/optional/dsc operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12531</id>
    <redirect title="Template:cpp/utility/optional/dsc operator cmp" />
    <revision>
      <id>68085</id>
      <parentid>60727</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list operator cmp]] to [[Template:cpp/experimental/optional/dcl list operator cmp]]</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/optional/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list swap</title>
    <ns>10</ns>
    <id>12532</id>
    <redirect title="Template:cpp/utility/optional/dsc swap" />
    <revision>
      <id>68087</id>
      <parentid>60729</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list swap]] to [[Template:cpp/experimental/optional/dcl list swap]]</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/utility/optional/dsc swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list swap2</title>
    <ns>10</ns>
    <id>12533</id>
    <redirect title="Template:cpp/utility/optional/dsc swap2" />
    <revision>
      <id>68089</id>
      <parentid>60731</parentid>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list swap2]] to [[Template:cpp/experimental/optional/dcl list swap2]]</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/optional/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list value</title>
    <ns>10</ns>
    <id>12534</id>
    <redirect title="Template:cpp/utility/optional/dsc value" />
    <revision>
      <id>68091</id>
      <parentid>60733</parentid>
      <timestamp>2014-03-16T20:19:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list value]] to [[Template:cpp/experimental/optional/dcl list value]]</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/optional/dsc value]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dcl list value or</title>
    <ns>10</ns>
    <id>12535</id>
    <redirect title="Template:cpp/utility/optional/dsc value or" />
    <revision>
      <id>68093</id>
      <parentid>60735</parentid>
      <timestamp>2014-03-16T20:19:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>P12 moved page [[Template:cpp/utility/optional/dcl list value or]] to [[Template:cpp/experimental/optional/dcl list value or]]</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/optional/dsc value or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc constructor</title>
    <ns>10</ns>
    <id>10062</id>
    <revision>
      <id>68131</id>
      <parentid>68095</parentid>
      <timestamp>2014-03-16T20:27:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem ctor | cpp/experimental/optional/optional | constructs the optional object}}</text>
      <sha1>ngtuygnr7q1cgqrzwz7d53ikwwg2rud</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc destructor</title>
    <ns>10</ns>
    <id>10063</id>
    <revision>
      <id>68132</id>
      <parentid>68097</parentid>
      <timestamp>2014-03-16T20:27:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem dtor | cpp/experimental/optional/~optional | if ''engaged'', destroys the contained value}}</text>
      <sha1>j0zehzgu65y7rirjuc2mrjq450yc7bq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc emplace</title>
    <ns>10</ns>
    <id>10074</id>
    <revision>
      <id>68139</id>
      <parentid>68099</parentid>
      <timestamp>2014-03-16T20:27:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | cpp/experimental/optional/emplace | constructs the contained value in-place}}</text>
      <sha1>6u6o0efvnhz984adylq0o8a9rzhdbmz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc hash</title>
    <ns>10</ns>
    <id>10073</id>
    <revision>
      <id>68180</id>
      <parentid>68101</parentid>
      <timestamp>2014-03-17T01:40:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="155">{{dsc ptclass | cpp/experimental/optional/hash | title=std::hash{{dsc small|&lt;std::experimental::optional&gt;}} | specializes the {{lc|std::hash}} algorithm }}</text>
      <sha1>afmdo3m45t6axpgtav4ompcilu742uv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc make optional</title>
    <ns>10</ns>
    <id>10071</id>
    <revision>
      <id>68178</id>
      <parentid>68103</parentid>
      <timestamp>2014-03-17T01:40:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="91">{{dsc tfun | cpp/experimental/optional/make_optional | creates an {{tt|optional}} object }}</text>
      <sha1>cpep8w4u1od1py1q43g9o4kzfomsb6k</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc operator*</title>
    <ns>10</ns>
    <id>10065</id>
    <revision>
      <id>68134</id>
      <parentid>68105</parentid>
      <timestamp>2014-03-16T20:27:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/experimental/optional/operator* | title=operator-&amp;gt;&lt;br/&gt;operator* | accesses the contained value}}</text>
      <sha1>d23mixdslyzsy49qnmscxlqy39e4jg5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc operator=</title>
    <ns>10</ns>
    <id>10064</id>
    <revision>
      <id>68133</id>
      <parentid>68107</parentid>
      <timestamp>2014-03-16T20:27:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/experimental/optional/operator{{=}} | assigns contents}}</text>
      <sha1>g78rv70kvmjbe61g1qtlyomltrx1md1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc operator bool</title>
    <ns>10</ns>
    <id>10066</id>
    <revision>
      <id>68135</id>
      <parentid>68109</parentid>
      <timestamp>2014-03-16T20:27:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem fun | cpp/experimental/optional/operator bool | checks whether the object is in ''engaged'' state}}</text>
      <sha1>g64h81p40axclweny3lmol95y77jbv5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc operator cmp</title>
    <ns>10</ns>
    <id>10070</id>
    <revision>
      <id>68177</id>
      <parentid>68111</parentid>
      <timestamp>2014-03-17T01:40:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="125">{{dsc tfun | cpp/experimental/optional/operator_cmp | title=operator{{==}}&lt;br/&gt;operator&lt;| compares {{tt|optional}} objects }}</text>
      <sha1>3zneg4005x4r0rblizsd3drkxuq4li2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc swap</title>
    <ns>10</ns>
    <id>10069</id>
    <revision>
      <id>68138</id>
      <parentid>68113</parentid>
      <timestamp>2014-03-16T20:27:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/experimental/optional/swap| exchanges the contents}}</text>
      <sha1>ki9mih3qaon9161r9ty1kmlg7lxtwhx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc swap2</title>
    <ns>10</ns>
    <id>10072</id>
    <revision>
      <id>68179</id>
      <parentid>68115</parentid>
      <timestamp>2014-03-17T01:40:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="152">{{dsc fun | cpp/experimental/optional/swap2 | title=std::swap{{dsc small|(std::experimental::optional)}} | specializes the {{lc|std::swap}} algorithm }}</text>
      <sha1>mkp3gejldjp10tyog2wfzk3c1g57c5l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc value</title>
    <ns>10</ns>
    <id>10067</id>
    <revision>
      <id>68136</id>
      <parentid>68117</parentid>
      <timestamp>2014-03-16T20:27:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/experimental/optional/value| returns the contained value}}</text>
      <sha1>jhxero14wzgfcded415yj1v8w3bggnd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/dsc value or</title>
    <ns>10</ns>
    <id>10068</id>
    <revision>
      <id>68137</id>
      <parentid>68119</parentid>
      <timestamp>2014-03-16T20:27:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update location</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/experimental/optional/value_or | returns the contained value if ''engaged'', another value otherwise }}</text>
      <sha1>ss6klncn9f8g4upo403h3z56dqpkoby</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/navbar</title>
    <ns>10</ns>
    <id>10075</id>
    <revision>
      <id>68183</id>
      <parentid>68141</parentid>
      <timestamp>2014-03-17T01:51:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="269">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/experimental/navbar heading
|content2 = cpp/experimental/navbar content

|heading3 = cpp/experimental/optional/navbar heading
|content3 = cpp/experimental/optional/navbar content
}}</text>
      <sha1>jgpe9f52dt0z7klrl9w8k03pg9dj2so</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/navbar content</title>
    <ns>10</ns>
    <id>10077</id>
    <revision>
      <id>68143</id>
      <parentid>68123</parentid>
      <timestamp>2014-03-16T20:33:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix page location</comment>
      <text xml:space="preserve" bytes="881">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/experimental/optional/optional}}
{{nv mem ln | cpp/experimental/optional/~optional}}
{{nv mem ln | cpp/experimental/optional/operator{{=}}}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/experimental/optional/operator* | operator-&gt; | operator*}}
{{nv mem ln | cpp/experimental/optional/operator bool}}
{{nv mem ln | cpp/experimental/optional/value}}
{{nv mem ln | cpp/experimental/optional/value_or}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/experimental/optional/emplace}}
{{nv mem ln | cpp/experimental/optional/swap}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/experimental/optional/operator_cmp | operator{{==}} | operator&lt;}}
{{nv ln | cpp/experimental/optional/make_optional}}
{{nv ln | cpp/experimental/optional/swap2 | swap}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/experimental/optional/hash | hash}}
{{nv end}}</text>
      <sha1>558r7domp7tg1pamjgzw6b9ccwonzop</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/navbar heading</title>
    <ns>10</ns>
    <id>10076</id>
    <revision>
      <id>68142</id>
      <parentid>68125</parentid>
      <timestamp>2014-03-16T20:33:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="61">{{ltt|cpp/experimental/optional|std::experimental::optional}}</text>
      <sha1>ohswhcpeohpk29bzi4waoamua941srx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/optional/title</title>
    <ns>10</ns>
    <id>10080</id>
    <revision>
      <id>68182</id>
      <parentid>68127</parentid>
      <timestamp>2014-03-17T01:50:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix title</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=experimental::optional::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>t2aln1e9n6ii7sfki6joohdqhn3hxea</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/pmr/dsc new delete resource</title>
    <ns>10</ns>
    <id>13671</id>
    <revision>
      <id>71534</id>
      <parentid>71530</parentid>
      <timestamp>2014-06-13T04:03:04Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Clarifiaction.</comment>
      <text xml:space="preserve" bytes="112">{{dsc fun | cpp/experimental/pmr/new_delete_resource | returns the static program-wide {{tt|memory_resource}} }}</text>
      <sha1>7iyrdrq6o25zvvitv50c3rqsiqvit8t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/pmr/dsc null memory resource</title>
    <ns>10</ns>
    <id>13672</id>
    <revision>
      <id>71535</id>
      <parentid>71531</parentid>
      <timestamp>2014-06-13T04:03:26Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <minor/>
      <comment>Clarification.</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/experimental/pmr/null_memory_resource | returns a static {{tt|memory_resource}} that performs no allocation }}</text>
      <sha1>k3a9y09gs63hn4z93xp2j736xg68orv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/pmr/dsc set default resource</title>
    <ns>10</ns>
    <id>13673</id>
    <revision>
      <id>71532</id>
      <timestamp>2014-06-13T04:01:06Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | cpp/experimental/pmr/set_default_resource | title=set_default_resource&lt;br/&gt;get_default_resource | sets and gets the default {{tt|memory_resource}} }}</text>
      <sha1>opr6sdh71xdn4fvbqte87yxpkl7l5zl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/pmr/memory resource/dsc operator cmp</title>
    <ns>10</ns>
    <id>13669</id>
    <revision>
      <id>71529</id>
      <parentid>71527</parentid>
      <timestamp>2014-06-13T03:54:41Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <text xml:space="preserve" bytes="122">{{dsc fun | cpp/experimental/pmr/memory_resource/operator cmp | title=operator==&lt;br&gt;operator!= | compares two resources }}</text>
      <sha1>p1bhby1yf7t931wy29ul0lpmsp6fmi6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/experimental/pmr/polymorphic allocator/dsc operator cmp</title>
    <ns>10</ns>
    <id>13670</id>
    <revision>
      <id>71528</id>
      <timestamp>2014-06-13T03:54:25Z</timestamp>
      <contributor>
        <username>Luksy</username>
        <id>3138</id>
      </contributor>
      <comment>Add template.</comment>
      <text xml:space="preserve" bytes="130">{{dsc tfun | cpp/experimental/pmr/polymorphic_allocator/operator cmp | title=operator==&lt;br&gt;operator!= | compares two allocators }}</text>
      <sha1>kjecfdrplys7j4dyol2svd2yxmtt2i6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/header/c</title>
    <ns>10</ns>
    <id>9757</id>
    <revision>
      <id>65252</id>
      <parentid>45302</parentid>
      <timestamp>2013-09-05T18:11:47Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <minor/>
      <comment>escape &lt;&gt;</comment>
      <text xml:space="preserve" bytes="101">This header was originally in the C standard library as {{ttb|&amp;lt;{{#sub:{{SUBPAGENAME}}|1}}.h&amp;gt;}}.</text>
      <sha1>feo8bs16vqb23fi9d8ay0pl2o21e2lo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/header/navbar</title>
    <ns>10</ns>
    <id>9656</id>
    <revision>
      <id>44980</id>
      <timestamp>2012-12-06T19:00:48Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="152">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/header/navbar heading
|content2 = cpp/header/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/header/navbar content</title>
    <ns>10</ns>
    <id>9659</id>
    <revision>
      <id>67560</id>
      <parentid>65921</parentid>
      <timestamp>2014-02-12T06:17:57Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>remove newlines</comment>
      <text xml:space="preserve" bytes="3346">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h1 | Language Support}}
{{nv col begin}}
{{nv | {{header|cstddef}}}}
{{nv | {{header|limits}}}}
{{nv | {{header|climits}}}}
{{nv | {{header|cfloat}}}}
{{nv | {{header|cstdint}}}}
{{nv | {{header|new}}}}
{{nv | {{header|typeinfo}}}}
{{nv | {{header|exception}}}}
{{nv | {{header|ciso646}}}}
{{nv col next}}
{{nv | {{header|initializer_list}}}}
{{nv | {{header|csignal}}}}
{{nv | {{header|csetjmp}}}}
{{nv | {{header|cstdalign}}}}
{{nv | {{header|cstdarg}}}}
{{nv | {{header|cstdbool}}}}
{{nv | {{header|cstdlib}}}}
{{nv | {{header|ctime}}}}
{{nv col end}}

{{nv h1 | Diagnostics}}
{{nv col begin}}
{{nv | {{header|stdexcept}}}}
{{nv | {{header|cassert}}}}
{{nv col next}}
{{nv | {{header|cerrno}}}}
{{nv | {{header|system_error}}}}
{{nv col end}}

{{nv h1 | General utilities}}
{{nv col begin}}
{{nv | {{header|utility}}}}
{{nv | {{header|tuple}}}}
{{nv | {{header|bitset}}}}
{{nv | {{header|memory}}}}
{{nv | {{header|cstdlib}}}}
{{nv | {{header|cstring}}}}
{{nv | {{header|functional}}}}
{{nv col next}}
{{nv | {{header|type_traits}}}}
{{nv | {{header|ratio}}}}
{{nv | {{header|chrono}}}}
{{nv | {{header|ctime}}}}
{{nv | {{header|scoped_allocator}}}}
{{nv | {{header|typeindex}}}}
{{nv col end}}

{{nv h1 | Strings}}
{{nv col begin}}
{{nv | {{header|string}}}}
{{nv | {{header|cctype}}}}
{{nv | {{header|cwctype}}}}
{{nv | {{header|cstring}}}}
{{nv col next}}
{{nv | {{header|cwchar}}}}
{{nv | {{header|cstdlib}}}}
{{nv | {{header|cuchar}}}}
{{nv col end}}

{{nv h1 | Localization}}
{{nv col begin}}
{{nv | {{header|locale}}}}
{{nv | {{header|codectv}}}}
{{nv | {{header|clocale}}}}
{{nv col end}}

{{nv end}}
&lt;/div&gt;
&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}

{{nv h1 | Containers}}
{{nv col begin}}
{{nv | {{header|array}}}}
{{nv | {{header|deque}}}}
{{nv | {{header|forward_list}}}}
{{nv | {{header|list}}}}
{{nv | {{header|vector}}}}
{{nv col next}}
{{nv | {{header|map}}}}
{{nv | {{header|set}}}}
{{nv | {{header|unordered_map}}}}
{{nv | {{header|unordered_set}}}}
{{nv | {{header|queue}}}}
{{nv | {{header|stack}}}}
{{nv col end}}

{{nv h1 | Iterators}}
{{nv col begin}}
{{nv | {{header|iterator}}}}
{{nv col end}}

{{nv h1 | Algorithms}}
{{nv col begin}}
{{nv | {{header|algorithm}}}}
{{nv col next}}
{{nv | {{header|cstdlib}}}}
{{nv col end}}

{{nv h1 | Numerics}}
{{nv col begin}}
{{nv | {{header|cfenv}}}}
{{nv | {{header|complex}}}}
{{nv | {{header|random}}}}
{{nv | {{header|valarray}}}}
{{nv col next}}
{{nv | {{header|numeric}}}}
{{nv | {{header|cmath}}}}
{{nv | {{header|ctgmath}}}}
{{nv | {{header|cstdlib}}}}
{{nv col end}}

{{nv h1 | Input/Output}}
{{nv col begin}}
{{nv | {{header|iosfwd}}}}
{{nv | {{header|iostream}}}}
{{nv | {{header|ios}}}}
{{nv | {{header|streambuf}}}}
{{nv | {{header|istream}}}}
{{nv | {{header|ostream}}}}
{{nv col next}}
{{nv | {{header|iomanip}}}}
{{nv | {{header|sstream}}}}
{{nv | {{header|fstream}}}}
{{nv | {{header|cstdio}}}}
{{nv | {{header|cinttypes}}}}
{{nv col end}}

{{nv h1 | Regular expressions}}
{{nv col begin}}
{{nv | {{header|regex}}}}
{{nv col end}}

{{nv h1 | Thread support}}
{{nv col begin}}
{{nv | {{header|thread}}}}
{{nv | {{header|mutex}}}}
{{nv | {{header|atomic}}}}
{{nv col next}}
{{nv | {{header|shared_mutex}}}}
{{nv | {{header|condition_variable}}}}
{{nv | {{header|future}}}}
{{nv col end}}

{{nv end}}
&lt;/div&gt;</text>
      <sha1>qg9kmss3ktoihdfs5plxkgc7n60xc94</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/header/navbar heading</title>
    <ns>10</ns>
    <id>9657</id>
    <revision>
      <id>44981</id>
      <timestamp>2012-12-06T19:02:33Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="47">[[cpp/header | Standard Library header files ]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/header/title</title>
    <ns>10</ns>
    <id>9655</id>
    <revision>
      <id>44979</id>
      <timestamp>2012-12-06T18:58:38Z</timestamp>
      <contributor>
        <username>Bazzy</username>
        <id>405</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="55">{{title | {{small|Standard library header}} &lt;{{{1}}}&gt;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/invoke</title>
    <ns>10</ns>
    <id>9409</id>
    <revision>
      <id>39771</id>
      <parentid>39770</parentid>
      <timestamp>2012-09-28T12:34:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1072">Let's refer to {{#ifeq:{{{fun|f}}}|f||{{tt|{{{fun|}}}}} as {{tt|f}} and to }}{{tt|{{{args|{{error|args}}}}}}} as {{tt|t1}}, {{tt|t2}}, ..., {{tt|tN}}, where {{tt|N}} is {{c|sizeof...({{{args|args}}})}}{{{desc|.}}}&lt;div&gt;

* If {{tt|f}} is pointer to a member function of class {{tt|T}}, then it is called. The return value is ignored. Effectively, the following code is executed:
:* {{c|(t1.*f)(t2, ..., tN)}} if the type of {{tt|t1}} is either {{tt|T}}, reference to {{tt|T}} or reference to type derived from {{tt|T}}.
:* {{c|((*t1).*f)(t2, ..., tN)}} otherwise.

* If {{c|1=N == 1}} and {{tt|f}} is pointer to a member data object of a class, then it is accessed. The value of the object is ignored. Effectively, the following code is executed:
:* {{c|t1.*f}} if  and the type of {{tt|t1}} is either {{tt|T}}, reference to {{tt|T}} or reference to type derived from {{tt|T}}.
:* {{c|(*t1).*f}} otherwise.

* {{tt|f}} is called as a pointer to a non-member function in all other cases. The return value is ignored. Effectively, {{c|f(t1, t2, ..., tN)}} is executed.
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/invoke r</title>
    <ns>10</ns>
    <id>9410</id>
    <revision>
      <id>39772</id>
      <parentid>39769</parentid>
      <timestamp>2012-09-28T12:34:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1069">Let's refer to {{#ifeq:{{{fun|f}}}|f||{{tt|{{{fun|}}}}} as {{tt|f}} and to }}{{tt|{{{args|{{error|args}}}}}}} as {{tt|t1}}, {{tt|t2}}, ..., {{tt|tN}}, where {{tt|N}} is {{c|sizeof...({{{args|args}}})}}{{{desc|.}}}&lt;div&gt;

* If {{tt|f}} is pointer to a member function of class {{tt|T}}, then it is called. The return value of {{tt|f}} is returned. Effectively, the following code is executed:
:* {{c|(t1.*f)(t2, ..., tN)}} if the type of {{tt|t1}} is either {{tt|T}}, reference to {{tt|T}} or reference to type derived from {{tt|T}}.
:* {{c|((*t1).*f)(t2, ..., tN)}} otherwise.

* If {{c|1=N == 1}} and {{tt|f}} is pointer to a member data object of a class, then its value is returned. Effectively, the following code is executed:
:* {{c|t1.*f}} if  and the type of {{tt|t1}} is either {{tt|T}}, reference to {{tt|T}} or reference to type derived from {{tt|T}}.
:* {{c|(*t1).*f}} otherwise.

* {{tt|f}} is called as a pointer to a non-member function in all other cases. The return value of {{tt|f}} is returned. Effectively, {{c|f(t1, t2, ..., tN)}} is executed.
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io//navbar</title>
    <ns>10</ns>
    <id>1230</id>
    <revision>
      <id>35639</id>
      <parentid>2461</parentid>
      <timestamp>2012-06-15T22:29:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io//sidebar]] to [[Template:cpp/io//navbar]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io//title</title>
    <ns>10</ns>
    <id>1231</id>
    <revision>
      <id>2463</id>
      <parentid>2462</parentid>
      <timestamp>2011-06-06T22:53:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc basic filebuf</title>
    <ns>10</ns>
    <id>5630</id>
    <revision>
      <id>55797</id>
      <parentid>52647</parentid>
      <timestamp>2013-06-01T05:27:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list basic filebuf]] to [[Template:cpp/io/basic filebuf/dsc basic filebuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem ctor | cpp/io/basic_filebuf/basic_filebuf | constructs a basic_filebuf object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc close</title>
    <ns>10</ns>
    <id>5636</id>
    <revision>
      <id>55801</id>
      <parentid>52648</parentid>
      <timestamp>2013-06-01T05:27:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list close]] to [[Template:cpp/io/basic filebuf/dsc close]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/io/basic_filebuf/close | flushes the put area buffer and closes the associated file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc imbue</title>
    <ns>10</ns>
    <id>5645</id>
    <revision>
      <id>55804</id>
      <parentid>52649</parentid>
      <timestamp>2013-06-01T05:27:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list imbue]] to [[Template:cpp/io/basic filebuf/dsc imbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc prot mem vfun | cpp/io/basic_filebuf/imbue | changes the associated locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc is open</title>
    <ns>10</ns>
    <id>5634</id>
    <revision>
      <id>55810</id>
      <parentid>52650</parentid>
      <timestamp>2013-06-01T05:27:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list is open]] to [[Template:cpp/io/basic filebuf/dsc is open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/io/basic_filebuf/is_open | checks if the associated file is open}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc open</title>
    <ns>10</ns>
    <id>5635</id>
    <revision>
      <id>55814</id>
      <parentid>52651</parentid>
      <timestamp>2013-06-01T05:27:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list open]] to [[Template:cpp/io/basic filebuf/dsc open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/io/basic_filebuf/open | opens a file and configures it as the associated character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc operator=</title>
    <ns>10</ns>
    <id>5631</id>
    <revision>
      <id>55819</id>
      <parentid>52652</parentid>
      <timestamp>2013-06-01T05:27:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list operator=]] to [[Template:cpp/io/basic filebuf/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/io/basic_filebuf/operator{{=}} | assigns a basic_filebuf object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc overflow</title>
    <ns>10</ns>
    <id>5641</id>
    <revision>
      <id>55825</id>
      <parentid>52653</parentid>
      <timestamp>2013-06-01T05:27:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list overflow]] to [[Template:cpp/io/basic filebuf/dsc overflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc prot mem vfun | cpp/io/basic_filebuf/overflow | writes characters to the associated file from the put area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc pbackfail</title>
    <ns>10</ns>
    <id>5640</id>
    <revision>
      <id>55829</id>
      <parentid>52654</parentid>
      <timestamp>2013-06-01T05:27:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list pbackfail]] to [[Template:cpp/io/basic filebuf/dsc pbackfail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc prot mem vfun | cpp/io/basic_filebuf/pbackfail | backs out the input sequence to unget a character, not affecting the associated file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc seekoff</title>
    <ns>10</ns>
    <id>5642</id>
    <revision>
      <id>55835</id>
      <parentid>52655</parentid>
      <timestamp>2013-06-01T05:27:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list seekoff]] to [[Template:cpp/io/basic filebuf/dsc seekoff]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc prot mem vfun | cpp/io/basic_filebuf/seekoff | repositions the file position, using relative addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc seekpos</title>
    <ns>10</ns>
    <id>5643</id>
    <revision>
      <id>55839</id>
      <parentid>52656</parentid>
      <timestamp>2013-06-01T05:27:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list seekpos]] to [[Template:cpp/io/basic filebuf/dsc seekpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc prot mem vfun | cpp/io/basic_filebuf/seekpos | repositions the file position, using absolute addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc setbuf</title>
    <ns>10</ns>
    <id>4569</id>
    <revision>
      <id>55844</id>
      <parentid>52657</parentid>
      <timestamp>2013-06-01T05:27:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list setbuf]] to [[Template:cpp/io/basic filebuf/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc prot mem vfun | cpp/io/basic_filebuf/setbuf | mem={{{mem|}}}| provides user-supplied buffer or turns this filebuf unbuffered}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc showmanyc</title>
    <ns>10</ns>
    <id>5637</id>
    <revision>
      <id>55848</id>
      <parentid>52658</parentid>
      <timestamp>2013-06-01T05:27:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list showmanyc]] to [[Template:cpp/io/basic filebuf/dsc showmanyc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc prot mem vfun | cpp/io/basic_filebuf/showmanyc | optionally provides the number of characters available for input from the file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc swap</title>
    <ns>10</ns>
    <id>5632</id>
    <revision>
      <id>55852</id>
      <parentid>52659</parentid>
      <timestamp>2013-06-01T05:27:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list swap]] to [[Template:cpp/io/basic filebuf/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/io/basic_filebuf/swap | swaps two basic_filebuf objects | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc swap2</title>
    <ns>10</ns>
    <id>5646</id>
    <revision>
      <id>55855</id>
      <parentid>52660</parentid>
      <timestamp>2013-06-01T05:28:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list swap2]] to [[Template:cpp/io/basic filebuf/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc tfun | cpp/io/basic_filebuf/swap2 | title=std::swap{{dsc small|(std::basic_filebuf)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc sync</title>
    <ns>10</ns>
    <id>5644</id>
    <revision>
      <id>55859</id>
      <parentid>52661</parentid>
      <timestamp>2013-06-01T05:28:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list sync]] to [[Template:cpp/io/basic filebuf/dsc sync]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc prot mem vfun | cpp/io/basic_filebuf/sync | writes characters to the associated file from the put area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc uflow</title>
    <ns>10</ns>
    <id>5639</id>
    <revision>
      <id>55864</id>
      <parentid>52662</parentid>
      <timestamp>2013-06-01T05:28:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list uflow]] to [[Template:cpp/io/basic filebuf/dsc uflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc prot mem vfun | cpp/io/basic_filebuf/uflow | reads from the associated file and advances the next pointer in the get area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc underflow</title>
    <ns>10</ns>
    <id>5638</id>
    <revision>
      <id>55868</id>
      <parentid>52663</parentid>
      <timestamp>2013-06-01T05:28:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list underflow]] to [[Template:cpp/io/basic filebuf/dsc underflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc prot mem vfun | cpp/io/basic_filebuf/underflow | reads from the associated file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/dsc ~basic filebuf</title>
    <ns>10</ns>
    <id>5633</id>
    <revision>
      <id>55874</id>
      <parentid>52664</parentid>
      <timestamp>2013-06-01T05:28:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic filebuf/dcl list ~basic filebuf]] to [[Template:cpp/io/basic filebuf/dsc ~basic filebuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem vdtor | cpp/io/basic_filebuf/~basic_filebuf | destructs a basic_filebuf object and closes the file if it is open}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/navbar</title>
    <ns>10</ns>
    <id>1232</id>
    <revision>
      <id>47780</id>
      <parentid>39907</parentid>
      <timestamp>2013-05-16T20:26:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="239">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_filebuf/navbar heading
|content3 = cpp/io/basic_filebuf/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/navbar content</title>
    <ns>10</ns>
    <id>4372</id>
    <revision>
      <id>52665</id>
      <parentid>33610</parentid>
      <timestamp>2013-06-01T04:51:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1050">{{nv begin}}
{{nv h1 | Public member functions}}
{{nv mem ln | cpp/io/basic_filebuf/basic_filebuf}}
{{nv mem ln | cpp/io/basic_filebuf/~basic_filebuf}}
{{nv mem ln | cpp/io/basic_filebuf/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_filebuf/swap|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_filebuf/is_open}}
{{nv mem ln | cpp/io/basic_filebuf/open}}
{{nv mem ln | cpp/io/basic_filebuf/close}}

{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/io/basic_filebuf/showmanyc}}
{{nv mem ln | cpp/io/basic_filebuf/underflow}}
{{nv mem ln | cpp/io/basic_filebuf/uflow}}
{{nv mem ln | cpp/io/basic_filebuf/pbackfail}}
{{nv mem ln | cpp/io/basic_filebuf/overflow}}
{{nv mem ln | cpp/io/basic_filebuf/setbuf}}
{{nv mem ln | cpp/io/basic_filebuf/seekoff}}
{{nv mem ln | cpp/io/basic_filebuf/seekpos}}
{{nv mem ln | cpp/io/basic_filebuf/sync}}
{{nv mem ln | cpp/io/basic_filebuf/imbue}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/io/basic_filebuf/swap2|swap{{dsc small|(std::basic_filebuf)}}|notes={{mark c++11}}}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/navbar heading</title>
    <ns>10</ns>
    <id>2452</id>
    <revision>
      <id>48093</id>
      <parentid>35641</parentid>
      <timestamp>2013-05-18T18:09:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/io/basic_filebuf|std::basic_filebuf}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic filebuf/title</title>
    <ns>10</ns>
    <id>4566</id>
    <revision>
      <id>16109</id>
      <timestamp>2011-12-21T06:24:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=basic_filebuf::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/close</title>
    <ns>10</ns>
    <id>1233</id>
    <revision>
      <id>62251</id>
      <parentid>60867</parentid>
      <timestamp>2013-06-25T12:38:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="1156">{{cpp/io/{{{1|}}}/title | close}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
void close();
}}
{{dcl end}}

Closes the associated file.

Effectively calls {{c|rdbuf()-&gt;close()}}. If an error occurs during operation, {{c|setstate(failbit)}} is called. 

===Parameters===
(none)

===Return value===
(none)

===Example===
{{example
 | code=
{{#switch: {{{1|}}}
| basic_fstream= 

#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::fstream f1(&quot;example1&quot;, std::ios::out),
                 f2(&quot;example2&quot;, std::ios::out),
                 f3(&quot;example3&quot;, std::ios::out);

    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; f1.is_open() &lt;&lt; '\n'
              &lt;&lt; f2.is_open() &lt;&lt; '\n'
              &lt;&lt; f3.is_open() &lt;&lt; '\n';

    f1.close();
    f2.close();

    std::cout &lt;&lt; f1.is_open() &lt;&lt; '\n'
              &lt;&lt; f2.is_open() &lt;&lt; '\n'
              &lt;&lt; f3.is_open() &lt;&lt; '\n';
}
}}
 | p = true
 | output=

{{#switch: {{{1|}}}

| basic_fstream= 
 
true
true
true
false
false
true

}}

}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc is_open |{{{1|}}}}}
{{dsc inc | cpp/io/basic_fstream/dsc open |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/constructor</title>
    <ns>10</ns>
    <id>1234</id>
    <revision>
      <id>63590</id>
      <parentid>60868</parentid>
      <timestamp>2013-07-10T01:45:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="3368">{{cpp/io/{{{1|}}}/title | {{{1|}}}}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 |
{{{1}}}();
}}
{{dcl | num=2 | 1=
explicit {{{1}}}( const char* filename,
{{space as|{{{1}}}}}  ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_ifstream=ios_base::in );
 | basic_ofstream=ios_base::out );
 | basic_fstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl | num=3 | since=c++11 | 1=
explicit {{{1}}}( const string&amp; filename,                                  
{{space as|{{{1}}}}}  ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_ifstream=ios_base::in );
 | basic_ofstream=ios_base::out );
 | basic_fstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl | num=4 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl | num=5 | since=c++11 |1=
{{{1}}}( const {{{1}}}&amp; rhs) = delete;
}}
{{dcl end}}

Constructs new file stream.

@1@ Default constructor: constructs a stream that is not associated with a file: default-constructs the {{lc|std::basic_filebuf}} and constructs the base with the pointer to this default-constructed {{lc|std::basic_filebuf}} member.
@2@ First, performs the same steps as the default constructor, then asssociates the stream with a file by calling {{#switch: {{{1|}}}
 | basic_ifstream={{c|rdbuf()-&gt;open(filename, mode {{!}} std::ios_base::in)}}.
 | basic_ofstream={{c|rdbuf()-&gt;open(filename, mode {{!}} std::ios_base::out)}}.
 | basic_fstream={{c|rdbuf()-&gt;open(filename, mode)}}.
}}. If the open() call returns a null pointer, sets {{c|setstate(failbit)}}.
@3@ Same as {{c|{{{1|}}}(filename.c_str(), mode)}}. 
@4@ Move constructor. First, move-constructs the base class from {{tt|other}} (which does not affect the {{tt|rdbuf()}} pointer), then move-constructs the {{lc|std::basic_filebuf}} member, then calls {{c|this-&gt;set_rdbuf()}} to install the new {{tt|basic_filebuf}} as the {{c|rdbuf()}} pointer in the base class.
@5@ The copy-constructor is deleted: this class is not copyable.

===Parameters===
{{par begin}}
{{par | filename | the name of the file to be opened}}
{{par | mode | specifies stream open mode. It is bitmask type, the following constants are defined: 
{{cpp/io/ios_base/openmode consts}} }}
{{par | other | another file stream to use as source}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;fstream&gt;
#include &lt;utility&gt;
#include &lt;string&gt;
int main()
{
{{#switch: {{{1|}}}
 | basic_ifstream=    std::ifstream f0;
    std::ifstream f1(&quot;test.bin&quot;, std::ios::binary);
    std::string name = &quot;example.txt&quot;;
    std::ifstream f2(name);
    std::ifstream f3(std::move(f1));
 | basic_ofstream=    std::{{{1|}}} f0;
    std::ofstream f1(&quot;test.bin&quot;, std::ios::binary);
    std::string name = &quot;example.txt&quot;;
    std::ofstream f2(name);
    std::ofstream f3(std::move(f1));
 | basic_fstream=    std::fstream f0;
    std::fstream f1(&quot;test.bin&quot;, std::ios::binary);
    std::string name = &quot;example.txt&quot;;
    std::fstream f2(name);
    std::fstream f3(std::move(f1));
}}
}
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc open |{{{1|}}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc open}}
{{dsc inc | cpp/io/basic_ios/dsc set_rdbuf}}
{{#switch: {{{1|}}}
 | basic_ifstream={{dsc inc | cpp/io/basic_istream/dsc constructor}}
 | basic_ofstream={{dsc inc | cpp/io/basic_ostream/dsc constructor}}
 | basic_fstream={{dsc inc | cpp/io/basic_iostream/dsc constructor}}
}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc close</title>
    <ns>10</ns>
    <id>1235</id>
    <revision>
      <id>55878</id>
      <parentid>52668</parentid>
      <timestamp>2013-06-01T05:28:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list close]] to [[Template:cpp/io/basic fstream/dsc close]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc mem fun | cpp/io/{{{1|}}}/close | closes the associated file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc constructor</title>
    <ns>10</ns>
    <id>1236</id>
    <revision>
      <id>55883</id>
      <parentid>52669</parentid>
      <timestamp>2013-06-01T05:28:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list constructor]] to [[Template:cpp/io/basic fstream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem ctor | cpp/io/{{{1|}}}/{{{1|}}} | constructs the file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc destructor</title>
    <ns>10</ns>
    <id>4378</id>
    <revision>
      <id>55887</id>
      <parentid>52670</parentid>
      <timestamp>2013-06-01T05:28:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list destructor]] to [[Template:cpp/io/basic fstream/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem vdtor | nolink=true | notes={{mark implicit}} | destructs the {{{1}}} and the associated buffer, closes the file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc is open</title>
    <ns>10</ns>
    <id>1237</id>
    <revision>
      <id>55889</id>
      <parentid>52671</parentid>
      <timestamp>2013-06-01T05:28:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list is open]] to [[Template:cpp/io/basic fstream/dsc is open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/io/{{{1|}}}/is_open | checks if the stream has an associated file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc open</title>
    <ns>10</ns>
    <id>1238</id>
    <revision>
      <id>55892</id>
      <parentid>52672</parentid>
      <timestamp>2013-06-01T05:28:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list open]] to [[Template:cpp/io/basic fstream/dsc open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/io/{{{1|}}}/open | opens a file and associates it with the stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc operator=</title>
    <ns>10</ns>
    <id>1239</id>
    <revision>
      <id>55894</id>
      <parentid>52673</parentid>
      <timestamp>2013-06-01T05:28:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list operator=]] to [[Template:cpp/io/basic fstream/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/io/{{{1|}}}/operator{{=}} | moves the file stream | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc rdbuf</title>
    <ns>10</ns>
    <id>1240</id>
    <revision>
      <id>55896</id>
      <parentid>52674</parentid>
      <timestamp>2013-06-01T05:28:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list rdbuf]] to [[Template:cpp/io/basic fstream/dsc rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/io/{{{1|}}}/rdbuf | returns the underlying raw file device object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc swap</title>
    <ns>10</ns>
    <id>1241</id>
    <revision>
      <id>55901</id>
      <parentid>52675</parentid>
      <timestamp>2013-06-01T05:28:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list swap]] to [[Template:cpp/io/basic fstream/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/io/{{{1|}}}/swap | swaps two file streams | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/dsc swap2</title>
    <ns>10</ns>
    <id>4379</id>
    <revision>
      <id>55903</id>
      <parentid>52676</parentid>
      <timestamp>2013-06-01T05:28:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/dcl list swap2]] to [[Template:cpp/io/basic fstream/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc tfun | cpp/io/{{{1}}}/swap2 | title=std::swap{{dsc small|(std::{{{1}}})}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/is open</title>
    <ns>10</ns>
    <id>1242</id>
    <revision>
      <id>61927</id>
      <parentid>61910</parentid>
      <timestamp>2013-06-09T17:04:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="1598">{{cpp/io/{{{1|}}}/title | is_open}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
bool is_open();
}}
{{dcl | since=c++11 |
bool is_open() const;
}}
{{dcl rev end}}
{{dcl end}}

Checks if the file stream has an associated file.

Effectively calls {{ltt|cpp/io/basic_filebuf/is_open|rdbuf()-&gt;is_open()}}. 

===Parameters===
(none)

===Return value===
{{c|true}} if the file stream has an associated file, {{c|false}} otherwise

===Example===
{{example
 | code=
  {{#switch: {{{1|}}}

 | basic_fstream= 
#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::string filename = &quot;some_file&quot;;

    std::fstream fs(filename, std::ios::in);

    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;fs.is_open() = &quot; &lt;&lt; fs.is_open() &lt;&lt; '\n';

    if(!fs.is_open())
    {
       fs.clear();
       fs.open(filename, std::ios::out);
       std::cout &lt;&lt; &quot;fs.is_open() = &quot; &lt;&lt; fs.is_open() &lt;&lt; '\n';
    }
}
  
| basic_ifstream=
#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;
//this file is called main.cpp

bool file_exists(const std::string&amp; str)
{
   std::ifstream fs(str);
   return fs.is_open();
}

int main()
{
  std::boolalpha(std::cout);
  std::cout &lt;&lt; file_exists(&quot;main.cpp&quot;)  &lt;&lt; '\n'
            &lt;&lt; file_exists(&quot;strange_file&quot;) &lt;&lt; '\n';
} 

  }}


 | p = true
 | output= 
{{#switch: {{{1|}}}

| basic_fstream=
fs.is_open() = false
fs.is_open() = true


 | basic_ifstream=
true
false

}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc open |{{{1|}}}}}
{{dsc inc | cpp/io/basic_fstream/dsc close |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/navbar</title>
    <ns>10</ns>
    <id>1246</id>
    <revision>
      <id>39908</id>
      <parentid>35642</parentid>
      <timestamp>2012-09-28T20:09:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_fstream/navbar heading
|content3 = cpp/io/basic_fstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/navbar content</title>
    <ns>10</ns>
    <id>1247</id>
    <revision>
      <id>52678</id>
      <parentid>35643</parentid>
      <timestamp>2013-06-01T04:51:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="579">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_fstream/basic_fstream}}
{{nv mem ln | cpp/io/basic_fstream/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_fstream/swap|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_fstream/rdbuf}}

{{nv h2 | File operations }}
{{nv mem ln | cpp/io/basic_fstream/is_open}}
{{nv mem ln | cpp/io/basic_fstream/open}}
{{nv mem ln | cpp/io/basic_fstream/close}}

{{nv h2 | Non-member functions }}
{{nv mem ln | cpp/io/basic_fstream/swap2|swap{{dsc small|(std::basic_fstream)}}|notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/navbar heading</title>
    <ns>10</ns>
    <id>1248</id>
    <revision>
      <id>35644</id>
      <parentid>2497</parentid>
      <timestamp>2012-06-15T22:29:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic fstream/sidebar heading]] to [[Template:cpp/io/basic fstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="51">{{ltt | cpp/io/basic_fstream | std::basic_fstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/open</title>
    <ns>10</ns>
    <id>1243</id>
    <revision>
      <id>66391</id>
      <parentid>63591</parentid>
      <timestamp>2013-11-18T18:11:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>seealso to filebuf::open</comment>
      <text xml:space="preserve" bytes="2252">{{cpp/io/{{{1|}}}/title | open}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1=
void open( const char *filename,
           ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_ifstream=ios_base::in );
 | basic_ofstream=ios_base::out );
 | basic_fstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl | since=c++11 | 1=
void open( const std::string &amp;filename,                                  
           ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_ifstream=ios_base::in );
 | basic_ofstream=ios_base::out );
 | basic_fstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl end}}

Opens and associates the file with name {{tt|filename}} with the file stream.

Calls {{c|setstate(failbit)}} on failure.
{{rev begin}}
{{rev|since=c++11|Calls {{c|clear()}} on success.}}
{{rev end}}

The first version effectively calls {{#switch: {{{1|}}}
 | basic_ifstream={{c|rdbuf()-&gt;open(filename, mode {{!}} ios_base::in)}}.
 | basic_ofstream={{c|rdbuf()-&gt;open(filename, mode {{!}} ios_base::out)}}.
 | basic_fstream={{c|rdbuf()-&gt;open(filename, mode)}}.
}}

The second version effectively calls {{c|open(filename.c_str(), mode)}}. 

===Parameters===
{{par begin}}
{{par | filename | the name of the file to be opened}}
{{par | mode | specifies stream open mode. It is bitmask type, the following constants are defined: 
{{cpp/io/ios_base/openmode consts}} }}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
{{#switch: {{{1|}}}

| basic_fstream=

#include &lt;string&gt;
#include &lt;fstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::string filename = &quot;example.123&quot;;

    std::fstream fs;

    fs.open(filename);

    if(!fs.is_open())
    {
       fs.clear();
       fs.open(filename, std::ios::out); //Create file.
       fs.close();
       fs.open(filename);
    }

    std::cout &lt;&lt; std::boolalpha;
    std::cout &lt;&lt; &quot;fs.is_open() = &quot; &lt;&lt; fs.is_open() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;fs.good() = &quot; &lt;&lt; fs.good() &lt;&lt; '\n';
}

}}

 | p = true
 | output=
{{#switch: {{{1|}}}

basic_fstream=

fs.is_open() = true
fs.good() = true

}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc is_open |{{{1|}}}}}
{{dsc inc | cpp/io/basic_fstream/dsc close |{{{1|}}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc open}}
{{dsc end}}</text>
      <sha1>86il2r8i40ix4zhp3pb4pnly8kxlhl1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/operator=</title>
    <ns>10</ns>
    <id>1244</id>
    <revision>
      <id>67189</id>
      <parentid>67182</parentid>
      <timestamp>2014-01-25T20:57:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>return value is a template parameter</comment>
      <text xml:space="preserve" bytes="573">{{cpp/io/{{{1|}}}/title | operator{{=}}}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
{{{1}}}&amp; operator{{=}}( {{{1}}}&amp;&amp; other );
}}
{{dcl end}}

Moves the file stream. The source stream becomes of invalid state after the operation. 

===Parameters===
{{par begin}}
{{par | other | file stream to move. {{tt|other}} becomes of invalid state after the operation. }}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc swap |{{{1|}}}}}
{{dsc end}}</text>
      <sha1>j69p0ry86et871im1zi8by74gdvq1g8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/rdbuf</title>
    <ns>10</ns>
    <id>1245</id>
    <revision>
      <id>62258</id>
      <parentid>35281</parentid>
      <timestamp>2013-06-25T12:42:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="352">{{cpp/io/{{{1|}}}/title | rdbuf}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
basic_filebuf&lt;CharT, Traits&gt;* rdbuf() const;
}}
{{dcl end}}

Returns pointer to the underlying raw file device object. 

===Parameters===
(none)

===Return value===
Pointer to the underlying raw file device.

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/swap</title>
    <ns>10</ns>
    <id>1249</id>
    <revision>
      <id>67199</id>
      <parentid>67188</parentid>
      <timestamp>2014-01-26T16:17:01Z</timestamp>
      <contributor>
        <ip>59.151.95.131</ip>
      </contributor>
      <comment>correcting</comment>
      <text xml:space="preserve" bytes="808">{{cpp/io/{{{1|}}}/title | swap}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( {{{1}}}&amp; other );
}}
{{dcl end}}

Exchanges the state of the stream with those of {{tt|other}}. 

This is done by calling {{#switch: {{{1|}}} | basic_ifstream={{c|basic_istream&lt;CharT, Traits&gt;::swap(other)}} | basic_ofstream={{c|basic_ostream&lt;CharT, Traits&gt;::swap(other)}} | basic_fstream={{c|basic_iostream&lt;CharT, Traits&gt;::swap(other)}}
}} and {{c|rdbuf()-&gt;swap(other.rdbuf())}}.  

===Parameters===
{{par begin}}
{{par | other | stream to exchange the state with}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc operator{{=}} |{{{1|}}}}}
{{dsc inc | cpp/io/basic_filebuf/dsc swap}}
{{dsc end}}</text>
      <sha1>gpr4udt2bhjuibbjibxkygeezu3qldr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/swap2</title>
    <ns>10</ns>
    <id>5491</id>
    <revision>
      <id>60873</id>
      <parentid>52682</parentid>
      <timestamp>2013-06-01T11:59:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="636">{{cpp/title | swap&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class T &gt;
void swap( {{{1}}}&lt;T&gt; &amp;lhs, {{{1}}}&lt;T&gt; &amp;rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{c|std::{{{1}}}}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | streams whose state to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_fstream/dsc swap | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic fstream/title</title>
    <ns>10</ns>
    <id>1250</id>
    <revision>
      <id>2501</id>
      <parentid>2500</parentid>
      <timestamp>2011-06-06T22:53:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=basic_fstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ifstream/navbar</title>
    <ns>10</ns>
    <id>1251</id>
    <revision>
      <id>39909</id>
      <parentid>35645</parentid>
      <timestamp>2012-09-28T20:09:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_ifstream/navbar heading
|content3 = cpp/io/basic_ifstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ifstream/navbar content</title>
    <ns>10</ns>
    <id>1252</id>
    <revision>
      <id>52683</id>
      <parentid>35646</parentid>
      <timestamp>2013-06-01T04:51:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="589">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_ifstream/basic_ifstream}}
{{nv mem ln | cpp/io/basic_ifstream/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_ifstream/swap|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_ifstream/rdbuf}}

{{nv h2 | File operations }}
{{nv mem ln | cpp/io/basic_ifstream/is_open}}
{{nv mem ln | cpp/io/basic_ifstream/open}}
{{nv mem ln | cpp/io/basic_ifstream/close}}

{{nv h2 | Non-member functions }}
{{nv mem ln | cpp/io/basic_ifstream/swap2|swap{{dsc small|(std::basic_ifstream)}}|notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ifstream/navbar heading</title>
    <ns>10</ns>
    <id>1253</id>
    <revision>
      <id>35647</id>
      <parentid>2507</parentid>
      <timestamp>2012-06-15T22:29:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ifstream/sidebar heading]] to [[Template:cpp/io/basic ifstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="53">{{ltt | cpp/io/basic_ifstream | std::basic_ifstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ifstream/title</title>
    <ns>10</ns>
    <id>1254</id>
    <revision>
      <id>2509</id>
      <parentid>2508</parentid>
      <timestamp>2011-06-06T22:53:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=basic_ifstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc bad</title>
    <ns>10</ns>
    <id>1255</id>
    <revision>
      <id>55907</id>
      <parentid>52684</parentid>
      <timestamp>2013-06-01T05:28:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list bad]] to [[Template:cpp/io/basic ios/dsc bad]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/io/basic_ios/bad | checks if a non-recoverable error has occurred}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc clear</title>
    <ns>10</ns>
    <id>1256</id>
    <revision>
      <id>55910</id>
      <parentid>52685</parentid>
      <timestamp>2013-06-01T05:28:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list clear]] to [[Template:cpp/io/basic ios/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/io/basic_ios/clear | clears error and eof flags}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc constructor</title>
    <ns>10</ns>
    <id>1257</id>
    <revision>
      <id>55914</id>
      <parentid>52686</parentid>
      <timestamp>2013-06-01T05:28:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list constructor]] to [[Template:cpp/io/basic ios/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem ctor | cpp/io/basic_ios/basic_ios | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc copyfmt</title>
    <ns>10</ns>
    <id>1258</id>
    <revision>
      <id>55920</id>
      <parentid>52687</parentid>
      <timestamp>2013-06-01T05:28:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list copyfmt]] to [[Template:cpp/io/basic ios/dsc copyfmt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/io/basic_ios/copyfmt | copies formatting information}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc destructor</title>
    <ns>10</ns>
    <id>1259</id>
    <revision>
      <id>55922</id>
      <parentid>52688</parentid>
      <timestamp>2013-06-01T05:28:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list destructor]] to [[Template:cpp/io/basic ios/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem vdtor | cpp/io/basic_ios/~basic_ios | destructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc eof</title>
    <ns>10</ns>
    <id>1260</id>
    <revision>
      <id>55924</id>
      <parentid>52689</parentid>
      <timestamp>2013-06-01T05:28:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list eof]] to [[Template:cpp/io/basic ios/dsc eof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/io/basic_ios/eof | checks if end-of-file has been reached}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc exceptions</title>
    <ns>10</ns>
    <id>1261</id>
    <revision>
      <id>55927</id>
      <parentid>52690</parentid>
      <timestamp>2013-06-01T05:28:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list exceptions]] to [[Template:cpp/io/basic ios/dsc exceptions]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/io/basic_ios/exceptions | manages exception mask}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc fail</title>
    <ns>10</ns>
    <id>1262</id>
    <revision>
      <id>55929</id>
      <parentid>52691</parentid>
      <timestamp>2013-06-01T05:28:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list fail]] to [[Template:cpp/io/basic ios/dsc fail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/io/basic_ios/fail | checks if a recoverable error has occurred}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc fill</title>
    <ns>10</ns>
    <id>1263</id>
    <revision>
      <id>55934</id>
      <parentid>52692</parentid>
      <timestamp>2013-06-01T05:28:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list fill]] to [[Template:cpp/io/basic ios/dsc fill]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/io/basic_ios/fill | mem={{{mem|}}} | manages the fill character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc good</title>
    <ns>10</ns>
    <id>1264</id>
    <revision>
      <id>55938</id>
      <parentid>52693</parentid>
      <timestamp>2013-06-01T05:28:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list good]] to [[Template:cpp/io/basic ios/dsc good]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem fun | cpp/io/basic_ios/good | checks if no error has occurred i.e. I/O operations are available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc imbue</title>
    <ns>10</ns>
    <id>1265</id>
    <revision>
      <id>55942</id>
      <parentid>52694</parentid>
      <timestamp>2013-06-01T05:28:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list imbue]] to [[Template:cpp/io/basic ios/dsc imbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">{{dsc mem fun | cpp/io/basic_ios/imbue | sets the locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc init</title>
    <ns>10</ns>
    <id>8764</id>
    <revision>
      <id>55947</id>
      <parentid>52695</parentid>
      <timestamp>2013-06-01T05:28:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list init]] to [[Template:cpp/io/basic ios/dsc init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc prot mem fun | cpp/io/basic_ios/init | initializes a default-constructed {{lc|std::basic_ios}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc move</title>
    <ns>10</ns>
    <id>8765</id>
    <revision>
      <id>69917</id>
      <parentid>55951</parentid>
      <timestamp>2014-05-01T14:23:01Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>mark c++11</comment>
      <text xml:space="preserve" bytes="134">{{dsc prot mem fun | cpp/io/basic_ios/move | moves from another {{lc|std::basic_ios}} except for {{tt|rdbuf}} |notes={{mark c++11}} }}</text>
      <sha1>39wy98s7npbvvlszta2rzhkq6v5wswt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc narrow</title>
    <ns>10</ns>
    <id>1266</id>
    <revision>
      <id>55955</id>
      <parentid>52697</parentid>
      <timestamp>2013-06-01T05:29:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list narrow]] to [[Template:cpp/io/basic ios/dsc narrow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc mem fun | cpp/io/basic_ios/narrow | narrows characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc operator!</title>
    <ns>10</ns>
    <id>1267</id>
    <revision>
      <id>69918</id>
      <parentid>64378</parentid>
      <timestamp>2014-05-01T14:25:54Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>missing ')'</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/io/basic_ios/operator! | checks if an error has occurred (synonym of {{lc|std::basic_ios::fail|fail()}}) }}</text>
      <sha1>3dq18r93zoj8jgwgbik8e59ogfr78sx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc operator bool</title>
    <ns>10</ns>
    <id>1268</id>
    <revision>
      <id>61909</id>
      <parentid>61847</parentid>
      <timestamp>2013-06-09T16:44:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 61847 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="198">{{dsc mem fun | cpp/io/basic_ios/operator bool | title=operator void*&lt;br&gt;operator bool|checks if no error has occurred (synonym of {{c|!fail()}})|notes={{mark until c++11}}&lt;br&gt;{{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc rdbuf</title>
    <ns>10</ns>
    <id>1269</id>
    <revision>
      <id>55962</id>
      <parentid>52700</parentid>
      <timestamp>2013-06-01T05:29:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list rdbuf]] to [[Template:cpp/io/basic ios/dsc rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/io/basic_ios/rdbuf | manages associated stream buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc rdstate</title>
    <ns>10</ns>
    <id>1270</id>
    <revision>
      <id>55965</id>
      <parentid>52701</parentid>
      <timestamp>2013-06-01T05:29:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list rdstate]] to [[Template:cpp/io/basic ios/dsc rdstate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc mem fun | cpp/io/basic_ios/rdstate | returns state flags}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc set rdbuf</title>
    <ns>10</ns>
    <id>5530</id>
    <revision>
      <id>55967</id>
      <parentid>52702</parentid>
      <timestamp>2013-06-01T05:29:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list set rdbuf]] to [[Template:cpp/io/basic ios/dsc set rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc prot mem fun | cpp/io/basic_ios/set_rdbuf | replaces the {{tt|rdbuf}} without clearing its error state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc setstate</title>
    <ns>10</ns>
    <id>1271</id>
    <revision>
      <id>55970</id>
      <parentid>52703</parentid>
      <timestamp>2013-06-01T05:29:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list setstate]] to [[Template:cpp/io/basic ios/dsc setstate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc mem fun | cpp/io/basic_ios/setstate | sets state flags}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc swap</title>
    <ns>10</ns>
    <id>8766</id>
    <revision>
      <id>69916</id>
      <parentid>55972</parentid>
      <timestamp>2014-05-01T14:20:38Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>mark c++11</comment>
      <text xml:space="preserve" bytes="134">{{dsc prot mem fun | cpp/io/basic_ios/swap | swaps with another {{lc|std::basic_ios}} except for {{tt|rdbuf}} |notes={{mark c++11}} }}</text>
      <sha1>ihpoflfdm2hupqsiowf2wyi5e2qca99</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc tie</title>
    <ns>10</ns>
    <id>1272</id>
    <revision>
      <id>55974</id>
      <parentid>52705</parentid>
      <timestamp>2013-06-01T05:29:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list tie]] to [[Template:cpp/io/basic ios/dsc tie]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">{{dsc mem fun | cpp/io/basic_ios/tie | manages tied stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/dsc widen</title>
    <ns>10</ns>
    <id>1273</id>
    <revision>
      <id>55976</id>
      <parentid>52706</parentid>
      <timestamp>2013-06-01T05:29:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/dcl list widen]] to [[Template:cpp/io/basic ios/dsc widen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">{{dsc mem fun | cpp/io/basic_ios/widen | widens characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/example1</title>
    <ns>10</ns>
    <id>9449</id>
    <revision>
      <id>40432</id>
      <parentid>40164</parentid>
      <timestamp>2012-10-14T09:49:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:template cpp/io/basic ios/example1]] to [[Template:cpp/io/basic ios/example1]]</comment>
      <text xml:space="preserve" bytes="741">{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;cstdlib&gt;
int main()
{
    std::ifstream file(&quot;test.txt&quot;);
    if(!file)  // operator! is used here
    {  
        std::cout &lt;&lt; &quot;File opening failed\n&quot;;
        return EXIT_FAILURE;
    }

    // typical C++ I/O loop uses the return value of the I/O function
    // as the loop controlling condition, operator bool() is used here
    for(int n; file &gt;&gt; n; ) {
       std::cout &lt;&lt; n &lt;&lt; ' ';
    }
    std::cout &lt;&lt; '\n';

    if (file.bad())
        std::cout &lt;&lt; &quot;I/O error while reading\n&quot;;
    else if (file.eof())
        std::cout &lt;&lt; &quot;End of file reached successfully\n&quot;;
    else if (file.fail())
        std::cout &lt;&lt; &quot;Non-integer data encountered\n&quot;;
}
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/inherit</title>
    <ns>10</ns>
    <id>1274</id>
    <revision>
      <id>60874</id>
      <parentid>52707</parentid>
      <timestamp>2013-06-01T11:59:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1212">{{inherited | [[cpp/io/basic_ios | {{small|std::}}basic_ios]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{c|CharT}}}}
{{dsc | {{tt|traits_type}} | {{c|Traits}}}}
{{dsc | {{tt|int_type}} | {{c|Traits::int_type}}}}
{{dsc | {{tt|pos_type}} | {{c|Traits::pos_type}}}}
{{dsc | {{tt|off_type}} | {{c|Traits::off_type}}}}
{{dsc end}}

{{dsc begin}}
{{dsc h2 | State functions}}
{{dsc inc | cpp/io/basic_ios/dsc good}}
{{dsc inc | cpp/io/basic_ios/dsc eof}}
{{dsc inc | cpp/io/basic_ios/dsc fail}}
{{dsc inc | cpp/io/basic_ios/dsc bad}}
{{dsc inc | cpp/io/basic_ios/dsc operator!}}
{{dsc inc | cpp/io/basic_ios/dsc operator bool}}
{{dsc inc | cpp/io/basic_ios/dsc rdstate}}
{{dsc inc | cpp/io/basic_ios/dsc setstate}}
{{dsc inc | cpp/io/basic_ios/dsc clear}}

{{dsc h2 | Formatting}}
{{dsc inc | cpp/io/basic_ios/dsc copyfmt}}
{{dsc inc | cpp/io/basic_ios/dsc fill}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/basic_ios/dsc exceptions}}
{{dsc inc | cpp/io/basic_ios/dsc imbue}}
{{dsc inc | cpp/io/basic_ios/dsc rdbuf}}
{{dsc inc | cpp/io/basic_ios/dsc tie}}
{{dsc inc | cpp/io/basic_ios/dsc narrow}}
{{dsc inc | cpp/io/basic_ios/dsc widen}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/iostate accessors</title>
    <ns>10</ns>
    <id>9452</id>
    <revision>
      <id>65166</id>
      <parentid>64383</parentid>
      <timestamp>2013-09-03T19:50:35Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added an explanatory sentence</comment>
      <text xml:space="preserve" bytes="1821">The following table shows the value of {{tt|basic_ios}} accessors ({{ltt|cpp/io/basic_ios/good|good()}}, {{ltt|cpp/io/basic_ios/fail|fail()}}, etc.) for all possible combinations of {{ltt|cpp/io/ios_base/iostate|ios_base::iostate}} flags:

{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:center;&quot;
|-
| colspan=&quot;3&quot; | {{ltt|cpp/io/ios_base/iostate|ios_base::iostate}} flags
| colspan=&quot;6&quot; | {{tt|basic_ios}} accessors
|-
| eofbit
| failbit
| badbit

| {{ltt|cpp/io/basic_ios/good|good()}}
| {{ltt|cpp/io/basic_ios/fail|fail()}}
| {{ltt|cpp/io/basic_ios/bad|bad()}}
| {{ltt|cpp/io/basic_ios/eof|eof()}}
| {{ltt|cpp/io/basic_ios/operator bool|operator bool}}
| {{ltt|cpp/io/basic_ios/operator!|operator!}}
|-
| {{no|false}}
| {{no|false}}
| {{no|false}}

| {{yes|true}}
| {{no|false}}
| {{no|false}}
| {{no|false}}
| {{yes|true}}
| {{no|false}}
|-
| {{no|false}}
| {{no|false}}
| {{yes|true}}

| {{no|false}}
| {{yes|true}}
| {{yes|true}}
| {{no|false}}
| {{no|false}}
| {{yes|true}}
|-
| {{no|false}}
| {{yes|true}}
| {{no|false}}

| {{no|false}}
| {{yes|true}}
| {{no|false}}
| {{no|false}}
| {{no|false}}
| {{yes|true}}
|-
| {{no|false}}
| {{yes|true}}
| {{yes|true}}

| {{no|false}}
| {{yes|true}}
| {{yes|true}}
| {{no|false}}
| {{no|false}}
| {{yes|true}}
|-
| {{yes|true}}
| {{no|false}}
| {{no|false}}

| {{no|false}}
| {{no|false}}
| {{no|false}}
| {{yes|true}}
| {{yes|true}}
| {{no|false}}
|-
| {{yes|true}}
| {{no|false}}
| {{yes|true}}

| {{no|false}}
| {{yes|true}}
| {{yes|true}}
| {{yes|true}}
| {{no|false}}
| {{yes|true}}
|-
| {{yes|true}}
| {{yes|true}}
| {{no|false}}

| {{no|false}}
| {{yes|true}}
| {{no|false}}
| {{yes|true}}
| {{no|false}}
| {{yes|true}}
|-
| {{yes|true}}
| {{yes|true}}
| {{yes|true}}

| {{no|false}}
| {{yes|true}}
| {{yes|true}}
| {{yes|true}}
| {{no|false}}
| {{yes|true}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/navbar</title>
    <ns>10</ns>
    <id>1275</id>
    <revision>
      <id>39910</id>
      <parentid>35936</parentid>
      <timestamp>2012-09-28T20:09:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="231">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_ios/navbar heading
|content3 = cpp/io/basic_ios/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/navbar content</title>
    <ns>10</ns>
    <id>1276</id>
    <revision>
      <id>52708</id>
      <parentid>35648</parentid>
      <timestamp>2013-06-01T04:52:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1095">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_ios/basic_ios}}
{{nv mem ln | cpp/io/basic_ios/~basic_ios}}

{{nv h2 | State functions}}
{{nv mem ln | cpp/io/basic_ios/good}}
{{nv mem ln | cpp/io/basic_ios/eof}}
{{nv mem ln | cpp/io/basic_ios/fail}}
{{nv mem ln | cpp/io/basic_ios/bad}}
{{nv mem ln | cpp/io/basic_ios/operator!}}
{{nv mem ln | cpp/io/basic_ios/operator bool}}
{{nv mem ln | cpp/io/basic_ios/rdstate}}
{{nv mem ln | cpp/io/basic_ios/setstate}}
{{nv mem ln | cpp/io/basic_ios/clear}}

{{nv h2 | Formatting}}
{{nv mem ln | cpp/io/basic_ios/copyfmt}}
{{nv mem ln | cpp/io/basic_ios/fill}}

{{nv h2 | Miscellaneous}}
{{nv mem ln | cpp/io/basic_ios/exceptions}}
{{nv mem ln | cpp/io/basic_ios/imbue}}
{{nv mem ln | cpp/io/basic_ios/rdbuf}}
{{nv mem ln | cpp/io/basic_ios/tie}}
{{nv mem ln | cpp/io/basic_ios/narrow}}
{{nv mem ln | cpp/io/basic_ios/widen}}

{{nv h2 | Protected member functions}}
{{nv mem ln | cpp/io/basic_ios/init}}
{{nv mem ln | cpp/io/basic_ios/move}}
{{nv mem ln | cpp/io/basic_ios/swap}}
{{nv mem ln | cpp/io/basic_ios/set_rdbuf}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/navbar heading</title>
    <ns>10</ns>
    <id>1277</id>
    <revision>
      <id>35649</id>
      <parentid>2555</parentid>
      <timestamp>2012-06-15T22:29:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ios/sidebar heading]] to [[Template:cpp/io/basic ios/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="43">{{ltt | cpp/io/basic_ios | std::basic_ios}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ios/title</title>
    <ns>10</ns>
    <id>1278</id>
    <revision>
      <id>2557</id>
      <parentid>2556</parentid>
      <timestamp>2011-06-06T22:53:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=basic_ios::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/dsc constructor</title>
    <ns>10</ns>
    <id>2547</id>
    <revision>
      <id>55978</id>
      <parentid>52709</parentid>
      <timestamp>2013-06-01T05:29:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic iostream/dcl list constructor]] to [[Template:cpp/io/basic iostream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem ctor | cpp/io/basic_iostream/basic_iostream | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/dsc destructor</title>
    <ns>10</ns>
    <id>2548</id>
    <revision>
      <id>55981</id>
      <parentid>52710</parentid>
      <timestamp>2013-06-01T05:29:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic iostream/dcl list destructor]] to [[Template:cpp/io/basic iostream/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem vdtor | cpp/io/basic_iostream/~basic_iostream | destructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/dsc operator=</title>
    <ns>10</ns>
    <id>8770</id>
    <revision>
      <id>55986</id>
      <parentid>52711</parentid>
      <timestamp>2013-06-01T05:29:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic iostream/dcl list operator=]] to [[Template:cpp/io/basic iostream/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/io/basic_iostream/operator{{=}} | move-assigns another {{tt|basic_iostream}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/dsc swap</title>
    <ns>10</ns>
    <id>8771</id>
    <revision>
      <id>55988</id>
      <parentid>52712</parentid>
      <timestamp>2013-06-01T05:29:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic iostream/dcl list swap]] to [[Template:cpp/io/basic iostream/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/io/basic_iostream/swap | exchanges the state with another {{tt|basic_iostream}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/navbar</title>
    <ns>10</ns>
    <id>1279</id>
    <revision>
      <id>39911</id>
      <parentid>35650</parentid>
      <timestamp>2012-09-28T20:09:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_iostream/navbar heading
|content3 = cpp/io/basic_iostream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/navbar content</title>
    <ns>10</ns>
    <id>2549</id>
    <revision>
      <id>52713</id>
      <parentid>37059</parentid>
      <timestamp>2013-06-01T04:52:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="294">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_iostream/basic_iostream}}
{{nv mem ln | cpp/io/basic_iostream/~basic_iostream}}

{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/io/basic_iostream/operator{{=}}}}
{{nv mem ln | cpp/io/basic_iostream/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/navbar heading</title>
    <ns>10</ns>
    <id>1280</id>
    <revision>
      <id>35652</id>
      <parentid>2561</parentid>
      <timestamp>2012-06-15T22:29:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic iostream/sidebar heading]] to [[Template:cpp/io/basic iostream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="53">{{ltt | cpp/io/basic_iostream | std::basic_iostream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic iostream/title</title>
    <ns>10</ns>
    <id>8769</id>
    <revision>
      <id>37014</id>
      <timestamp>2012-07-03T12:31:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=basic_iostream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc constructor</title>
    <ns>10</ns>
    <id>2399</id>
    <revision>
      <id>55990</id>
      <parentid>52714</parentid>
      <timestamp>2013-06-01T05:29:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list constructor]] to [[Template:cpp/io/basic istream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem ctor | cpp/io/basic_istream/basic_istream | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc destructor</title>
    <ns>10</ns>
    <id>2398</id>
    <revision>
      <id>55993</id>
      <parentid>52715</parentid>
      <timestamp>2013-06-01T05:29:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list destructor]] to [[Template:cpp/io/basic istream/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem vdtor | cpp/io/basic_istream/~basic_istream | destructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc gcount</title>
    <ns>10</ns>
    <id>1282</id>
    <revision>
      <id>55995</id>
      <parentid>52716</parentid>
      <timestamp>2013-06-01T05:29:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list gcount]] to [[Template:cpp/io/basic istream/dsc gcount]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/io/basic_istream/gcount | returns number of characters extracted by last unformatted input operation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc get</title>
    <ns>10</ns>
    <id>1283</id>
    <revision>
      <id>56000</id>
      <parentid>52717</parentid>
      <timestamp>2013-06-01T05:29:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list get]] to [[Template:cpp/io/basic istream/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc mem fun |cpp/io/basic_istream/get | extracts characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc getline</title>
    <ns>10</ns>
    <id>1284</id>
    <revision>
      <id>56004</id>
      <parentid>52718</parentid>
      <timestamp>2013-06-01T05:29:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list getline]] to [[Template:cpp/io/basic istream/dsc getline]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/io/basic_istream/getline | extracts characters until the given character is found}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc ignore</title>
    <ns>10</ns>
    <id>1285</id>
    <revision>
      <id>56010</id>
      <parentid>52719</parentid>
      <timestamp>2013-06-01T05:29:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list ignore]] to [[Template:cpp/io/basic istream/dsc ignore]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem fun | cpp/io/basic_istream/ignore | mem={{{mem|}}} | extracts and discards characters until the given character is found}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc operator=</title>
    <ns>10</ns>
    <id>4027</id>
    <revision>
      <id>56014</id>
      <parentid>52720</parentid>
      <timestamp>2013-06-01T05:29:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list operator=]] to [[Template:cpp/io/basic istream/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc prot mem fun | cpp/io/basic_istream/operator{{=}} | replaces the buffer object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc operator gtgt</title>
    <ns>10</ns>
    <id>1286</id>
    <revision>
      <id>56017</id>
      <parentid>52721</parentid>
      <timestamp>2013-06-01T05:29:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list operator gtgt]] to [[Template:cpp/io/basic istream/dsc operator gtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/io/basic_istream/operator_gtgt | title=operator&gt;&gt; | extracts formatted data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc operator gtgt2</title>
    <ns>10</ns>
    <id>3763</id>
    <revision>
      <id>56022</id>
      <parentid>52722</parentid>
      <timestamp>2013-06-01T05:29:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list operator gtgt2]] to [[Template:cpp/io/basic istream/dsc operator gtgt2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc tfun | cpp/io/basic_istream/operator_gtgt2 | title=operator&gt;&gt;{{dsc small|(std::basic_istream)}} | extracts characters and character arrays}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc peek</title>
    <ns>10</ns>
    <id>1287</id>
    <revision>
      <id>56024</id>
      <parentid>52723</parentid>
      <timestamp>2013-06-01T05:29:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list peek]] to [[Template:cpp/io/basic istream/dsc peek]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/io/basic_istream/peek | reads the next character without extracting it}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc putback</title>
    <ns>10</ns>
    <id>1288</id>
    <revision>
      <id>56026</id>
      <parentid>52724</parentid>
      <timestamp>2013-06-01T05:29:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list putback]] to [[Template:cpp/io/basic istream/dsc putback]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/io/basic_istream/putback | puts character into input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc read</title>
    <ns>10</ns>
    <id>1289</id>
    <revision>
      <id>56029</id>
      <parentid>52725</parentid>
      <timestamp>2013-06-01T05:29:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list read]] to [[Template:cpp/io/basic istream/dsc read]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/io/basic_istream/read | extracts blocks of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc readsome</title>
    <ns>10</ns>
    <id>1290</id>
    <revision>
      <id>56031</id>
      <parentid>52726</parentid>
      <timestamp>2013-06-01T05:29:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list readsome]] to [[Template:cpp/io/basic istream/dsc readsome]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/io/basic_istream/readsome | extracts already available blocks of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc seekg</title>
    <ns>10</ns>
    <id>1291</id>
    <revision>
      <id>56034</id>
      <parentid>52727</parentid>
      <timestamp>2013-06-01T05:29:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list seekg]] to [[Template:cpp/io/basic istream/dsc seekg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/io/basic_istream/seekg | sets the input position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc sentry</title>
    <ns>10</ns>
    <id>1292</id>
    <revision>
      <id>56036</id>
      <parentid>52728</parentid>
      <timestamp>2013-06-01T05:29:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list sentry]] to [[Template:cpp/io/basic istream/dsc sentry]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem class | cpp/io/basic_istream/sentry | implements basic logic for preparation of the stream for input operations}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc swap</title>
    <ns>10</ns>
    <id>4026</id>
    <revision>
      <id>56041</id>
      <parentid>52729</parentid>
      <timestamp>2013-06-01T05:30:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list swap]] to [[Template:cpp/io/basic istream/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc prot mem fun | cpp/io/basic_istream/swap | swaps stream objects, except for the associated buffer|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc sync</title>
    <ns>10</ns>
    <id>1293</id>
    <revision>
      <id>56045</id>
      <parentid>52730</parentid>
      <timestamp>2013-06-01T05:30:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list sync]] to [[Template:cpp/io/basic istream/dsc sync]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem fun | cpp/io/basic_istream/sync | mem={{{mem|}}} | synchronizes with the underlying storage device}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc tellg</title>
    <ns>10</ns>
    <id>1294</id>
    <revision>
      <id>56050</id>
      <parentid>52731</parentid>
      <timestamp>2013-06-01T05:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list tellg]] to [[Template:cpp/io/basic istream/dsc tellg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem fun | cpp/io/basic_istream/tellg | returns the input position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/dsc unget</title>
    <ns>10</ns>
    <id>1295</id>
    <revision>
      <id>56056</id>
      <parentid>52732</parentid>
      <timestamp>2013-06-01T05:30:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/dcl list unget]] to [[Template:cpp/io/basic istream/dsc unget]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/io/basic_istream/unget | unextracts a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/inherit</title>
    <ns>10</ns>
    <id>1297</id>
    <revision>
      <id>60875</id>
      <parentid>52733</parentid>
      <timestamp>2013-06-01T11:59:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="930">{{inherited | [[cpp/io/basic_istream | {{small|std::}}basic_istream]] |
===Member functions===
{{dsc begin}}
{{dsc h2 | Formatted input}}
{{dsc inc | cpp/io/basic_istream/dsc operator_gtgt}}

{{dsc h2 | Unformatted input}}
{{dsc inc | cpp/io/basic_istream/dsc get}}
{{dsc inc | cpp/io/basic_istream/dsc peek}}
{{dsc inc | cpp/io/basic_istream/dsc unget}}
{{dsc inc | cpp/io/basic_istream/dsc putback}}
{{dsc inc | cpp/io/basic_istream/dsc getline}}
{{dsc inc | cpp/io/basic_istream/dsc ignore}}
{{dsc inc | cpp/io/basic_istream/dsc read}}
{{dsc inc | cpp/io/basic_istream/dsc readsome}}
{{dsc inc | cpp/io/basic_istream/dsc gcount}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_istream/dsc tellg}}
{{dsc inc | cpp/io/basic_istream/dsc seekg}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/basic_istream/dsc sync}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/io/basic_istream/dsc sentry}}
{{dsc end}}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/navbar</title>
    <ns>10</ns>
    <id>1303</id>
    <revision>
      <id>39912</id>
      <parentid>35656</parentid>
      <timestamp>2012-09-28T20:09:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_istream/navbar heading
|content3 = cpp/io/basic_istream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/navbar content</title>
    <ns>10</ns>
    <id>1304</id>
    <revision>
      <id>52734</id>
      <parentid>35659</parentid>
      <timestamp>2013-06-01T04:52:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1251">{{nv begin}}
{{nv h1 | Global objects}}
{{nv ln | cpp/io/cin| cin | wcin}}

{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_istream/basic_istream}}
{{nv mem ln | cpp/io/basic_istream/~basic_istream}}
{{nv mem ln | cpp/io/basic_istream/operator{{=}}|notes={{mark c++11}}}}

{{nv h2 | Formatted input}}
{{nv mem ln | cpp/io/basic_istream/operator_gtgt | operator&gt;&gt;}}

{{nv h2 | Unformatted input}}
{{nv mem ln | cpp/io/basic_istream/get}}
{{nv mem ln | cpp/io/basic_istream/peek}}
{{nv mem ln | cpp/io/basic_istream/unget}}
{{nv mem ln | cpp/io/basic_istream/putback}}
{{nv mem ln | cpp/io/basic_istream/getline}}
{{nv mem ln | cpp/io/basic_istream/ignore}}
{{nv mem ln | cpp/io/basic_istream/read}}
{{nv mem ln | cpp/io/basic_istream/readsome}}
{{nv mem ln | cpp/io/basic_istream/gcount}}

{{nv h2 | Positioning}}
{{nv mem ln | cpp/io/basic_istream/tellg}}
{{nv mem ln | cpp/io/basic_istream/seekg}}

{{nv h2 | Miscellaneous}}
{{nv mem ln | cpp/io/basic_istream/sync}}
{{nv mem ln | cpp/io/basic_istream/swap|notes={{mark c++11}}}}

{{nv h1 | Member classes}}
{{nv mem ln | cpp/io/basic_istream/sentry}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/io/basic_istream/operator_gtgt2 | operator&gt;&gt;{{dsc small|(std::basic_istream)}}}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/navbar heading</title>
    <ns>10</ns>
    <id>1305</id>
    <revision>
      <id>35662</id>
      <parentid>2611</parentid>
      <timestamp>2012-06-15T22:30:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/sidebar heading]] to [[Template:cpp/io/basic istream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="51">{{ltt | cpp/io/basic_istream | std::basic_istream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/sentry/dsc constructor</title>
    <ns>10</ns>
    <id>1298</id>
    <revision>
      <id>56060</id>
      <parentid>52735</parentid>
      <timestamp>2013-06-01T05:30:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/sentry/dcl list constructor]] to [[Template:cpp/io/basic istream/sentry/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem ctor | cpp/io/basic_istream/sentry | inlinemem=true | constructs the sentry object. All the preparation tasks are done here }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/sentry/dsc destructor</title>
    <ns>10</ns>
    <id>10138</id>
    <revision>
      <id>56065</id>
      <parentid>52736</parentid>
      <timestamp>2013-06-01T05:30:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/sentry/dcl list destructor]] to [[Template:cpp/io/basic istream/sentry/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc mem dtor | cpp/io/basic_istream/sentry | inlinemem=true | finalizes the stream object after formatted input or after exception, if necessary}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/sentry/dsc operator bool</title>
    <ns>10</ns>
    <id>1299</id>
    <revision>
      <id>56070</id>
      <parentid>52737</parentid>
      <timestamp>2013-06-01T05:30:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istream/sentry/dcl list operator bool]] to [[Template:cpp/io/basic istream/sentry/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc mem fun | cpp/io/basic_istream/sentry | title=operator bool| inlinemem=true | checks if the preparation of the stream object was successful}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/sentry/title</title>
    <ns>10</ns>
    <id>10139</id>
    <revision>
      <id>48407</id>
      <timestamp>2013-05-29T15:21:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/io/basic_istream/title | n=sentry::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istream/title</title>
    <ns>10</ns>
    <id>1306</id>
    <revision>
      <id>2613</id>
      <parentid>2612</parentid>
      <timestamp>2011-06-06T22:53:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=basic_istream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istringstream/navbar</title>
    <ns>10</ns>
    <id>1307</id>
    <revision>
      <id>39914</id>
      <parentid>35663</parentid>
      <timestamp>2012-09-28T20:09:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_istringstream/navbar heading
|content3 = cpp/io/basic_istringstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istringstream/navbar content</title>
    <ns>10</ns>
    <id>1308</id>
    <revision>
      <id>52739</id>
      <parentid>35664</parentid>
      <timestamp>2013-06-01T04:52:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="348">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_istringstream/basic_istringstream}}
{{nv mem ln | cpp/io/basic_istringstream/operator{{=}}}}
{{nv mem ln | cpp/io/basic_istringstream/swap}}
{{nv mem ln | cpp/io/basic_istringstream/rdbuf}}

{{nv h2 | String operations }}
{{nv mem ln | cpp/io/basic_istringstream/str}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istringstream/navbar heading</title>
    <ns>10</ns>
    <id>1309</id>
    <revision>
      <id>35665</id>
      <parentid>2619</parentid>
      <timestamp>2012-06-15T22:30:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic istringstream/sidebar heading]] to [[Template:cpp/io/basic istringstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="63">{{ltt | cpp/io/basic_istringstream | std::basic_istringstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic istringstream/title</title>
    <ns>10</ns>
    <id>1310</id>
    <revision>
      <id>2621</id>
      <parentid>2620</parentid>
      <timestamp>2011-06-06T22:53:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=basic_istringstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ofstream/navbar</title>
    <ns>10</ns>
    <id>1311</id>
    <revision>
      <id>39915</id>
      <parentid>35666</parentid>
      <timestamp>2012-09-28T20:09:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_ofstream/navbar heading
|content3 = cpp/io/basic_ofstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ofstream/navbar content</title>
    <ns>10</ns>
    <id>1312</id>
    <revision>
      <id>52740</id>
      <parentid>35667</parentid>
      <timestamp>2013-06-01T04:52:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="589">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_ofstream/basic_ofstream}}
{{nv mem ln | cpp/io/basic_ofstream/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_ofstream/swap|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_ofstream/rdbuf}}

{{nv h2 | File operations }}
{{nv mem ln | cpp/io/basic_ofstream/is_open}}
{{nv mem ln | cpp/io/basic_ofstream/open}}
{{nv mem ln | cpp/io/basic_ofstream/close}}

{{nv h2 | Non-member functions }}
{{nv mem ln | cpp/io/basic_ofstream/swap2|swap{{dsc small|(std::basic_ofstream)}}|notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ofstream/navbar heading</title>
    <ns>10</ns>
    <id>1313</id>
    <revision>
      <id>35668</id>
      <parentid>2627</parentid>
      <timestamp>2012-06-15T22:30:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ofstream/sidebar heading]] to [[Template:cpp/io/basic ofstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="53">{{ltt | cpp/io/basic_ofstream | std::basic_ofstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ofstream/title</title>
    <ns>10</ns>
    <id>1314</id>
    <revision>
      <id>2629</id>
      <parentid>2628</parentid>
      <timestamp>2011-06-06T22:53:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=basic_ofstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc constructor</title>
    <ns>10</ns>
    <id>2400</id>
    <revision>
      <id>56073</id>
      <parentid>52741</parentid>
      <timestamp>2013-06-01T05:30:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list constructor]] to [[Template:cpp/io/basic ostream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem ctor | cpp/io/basic_ostream/basic_ostream | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc destructor</title>
    <ns>10</ns>
    <id>2401</id>
    <revision>
      <id>56076</id>
      <parentid>52742</parentid>
      <timestamp>2013-06-01T05:30:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list destructor]] to [[Template:cpp/io/basic ostream/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem vdtor | cpp/io/basic_ostream/~basic_ostream | destructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc flush</title>
    <ns>10</ns>
    <id>1316</id>
    <revision>
      <id>56079</id>
      <parentid>52743</parentid>
      <timestamp>2013-06-01T05:30:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list flush]] to [[Template:cpp/io/basic ostream/dsc flush]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/io/basic_ostream/flush | mem={{{mem|}}} | synchronizes with the underlying storage device}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc operator=</title>
    <ns>10</ns>
    <id>4030</id>
    <revision>
      <id>56081</id>
      <parentid>52744</parentid>
      <timestamp>2013-06-01T05:30:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list operator=]] to [[Template:cpp/io/basic ostream/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc prot mem fun | cpp/io/basic_ostream/operator{{=}} | replaces the buffer object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc operator ltlt</title>
    <ns>10</ns>
    <id>1317</id>
    <revision>
      <id>56084</id>
      <parentid>52745</parentid>
      <timestamp>2013-06-01T05:30:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list operator ltlt]] to [[Template:cpp/io/basic ostream/dsc operator ltlt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/io/basic_ostream/operator_ltlt | title=operator&lt;&lt; | inserts formatted data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc operator ltlt2</title>
    <ns>10</ns>
    <id>3764</id>
    <revision>
      <id>56086</id>
      <parentid>52746</parentid>
      <timestamp>2013-06-01T05:30:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list operator ltlt2]] to [[Template:cpp/io/basic ostream/dsc operator ltlt2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/io/basic_ostream/operator_ltlt2 | title=operator&lt;&lt;{{dsc small|(std::basic_ostream)}} | inserts character data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc put</title>
    <ns>10</ns>
    <id>1318</id>
    <revision>
      <id>56089</id>
      <parentid>52747</parentid>
      <timestamp>2013-06-01T05:30:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list put]] to [[Template:cpp/io/basic ostream/dsc put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc mem fun | cpp/io/basic_ostream/put | inserts a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc seekp</title>
    <ns>10</ns>
    <id>1319</id>
    <revision>
      <id>56091</id>
      <parentid>52748</parentid>
      <timestamp>2013-06-01T05:30:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list seekp]] to [[Template:cpp/io/basic ostream/dsc seekp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/io/basic_ostream/seekp | mem={{{mem|}}} | sets the output position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc sentry</title>
    <ns>10</ns>
    <id>1320</id>
    <revision>
      <id>56094</id>
      <parentid>52749</parentid>
      <timestamp>2013-06-01T05:30:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list sentry]] to [[Template:cpp/io/basic ostream/dsc sentry]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem class | cpp/io/basic_ostream/sentry | implements basic logic for preparation of the stream for output operations}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc swap</title>
    <ns>10</ns>
    <id>4031</id>
    <revision>
      <id>56097</id>
      <parentid>52750</parentid>
      <timestamp>2013-06-01T05:30:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list swap]] to [[Template:cpp/io/basic ostream/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc prot mem fun | cpp/io/basic_ostream/swap | swaps stream objects, except for the associated buffer|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc tellp</title>
    <ns>10</ns>
    <id>1321</id>
    <revision>
      <id>56099</id>
      <parentid>52751</parentid>
      <timestamp>2013-06-01T05:30:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list tellp]] to [[Template:cpp/io/basic ostream/dsc tellp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/io/basic_ostream/tellp | mem={{{mem|}}} | returns the output position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/dsc write</title>
    <ns>10</ns>
    <id>1322</id>
    <revision>
      <id>56101</id>
      <parentid>52752</parentid>
      <timestamp>2013-06-01T05:30:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/dcl list write]] to [[Template:cpp/io/basic ostream/dsc write]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/io/basic_ostream/write | inserts blocks of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/inherit</title>
    <ns>10</ns>
    <id>1324</id>
    <revision>
      <id>60876</id>
      <parentid>52753</parentid>
      <timestamp>2013-06-01T11:59:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="612">{{inherited | [[cpp/io/basic_ostream | {{small|std::}}basic_ostream]] |
===Member functions===
{{dsc begin}}
{{dsc h2 | Formatted input }}
{{dsc inc | cpp/io/basic_ostream/dsc operator_ltlt}}

{{dsc h2 | Unformatted input }}
{{dsc inc | cpp/io/basic_ostream/dsc put}}
{{dsc inc | cpp/io/basic_ostream/dsc write}}

{{dsc h2 | Positioning }}
{{dsc inc | cpp/io/basic_ostream/dsc tellp}}
{{dsc inc | cpp/io/basic_ostream/dsc seekp}}

{{dsc h2 | Miscellaneous }}
{{dsc inc | cpp/io/basic_ostream/dsc flush}}
{{dsc end}}

===Member classes===
{{dsc begin}}
{{dsc inc | cpp/io/basic_ostream/dsc sentry}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/navbar</title>
    <ns>10</ns>
    <id>1455</id>
    <revision>
      <id>39916</id>
      <parentid>35672</parentid>
      <timestamp>2012-09-28T20:10:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_ostream/navbar heading
|content3 = cpp/io/basic_ostream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/navbar content</title>
    <ns>10</ns>
    <id>1456</id>
    <revision>
      <id>67813</id>
      <parentid>67812</parentid>
      <timestamp>2014-03-01T08:06:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix typo</comment>
      <text xml:space="preserve" bytes="1092">{{nv begin}}
{{nv h1 | Global objects}}
{{nv col begin}}
{{nv ln | cpp/io/cout| cout | wcout}}
{{nv col next}}
{{nv ln | cpp/io/cerr| cerr | wcerr}}
{{nv col next}}
{{nv ln | cpp/io/clog| clog | wclog}}
{{nv col end}}

{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_ostream/basic_ostream}}
{{nv mem ln | cpp/io/basic_ostream/~basic_ostream}}
{{nv mem ln | cpp/io/basic_ostream/operator{{=}}|notes={{mark c++11}}}}

{{nv h2 | Formatted output }}
{{nv mem ln | cpp/io/basic_ostream/operator_ltlt | operator&lt;&lt;}}

{{nv h2 | Unformatted output }}
{{nv mem ln | cpp/io/basic_ostream/put}}
{{nv mem ln | cpp/io/basic_ostream/write}}

{{nv h2 | Positioning }}
{{nv mem ln | cpp/io/basic_ostream/tellp}}
{{nv mem ln | cpp/io/basic_ostream/seekp}}

{{nv h2 | Miscellaneous }}
{{nv mem ln | cpp/io/basic_ostream/flush}}
{{nv mem ln | cpp/io/basic_ostream/swap|notes={{mark c++11}}}}

{{nv h1 | Member classes}}
{{nv mem ln | cpp/io/basic_ostream/sentry}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/io/basic_ostream/operator_ltlt2 | operator&lt;&lt;{{dsc small|(std::basic_ostream)}}}}
{{nv end}}</text>
      <sha1>klcp40ap5g5kz9ys6rcl9vdnj95aic9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/navbar heading</title>
    <ns>10</ns>
    <id>1457</id>
    <revision>
      <id>33605</id>
      <parentid>2914</parentid>
      <timestamp>2012-06-15T20:29:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/sidebar heading]] to [[Template:cpp/io/basic ostream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="51">{{ltt | cpp/io/basic_ostream | std::basic_ostream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/sentry/dsc constructor</title>
    <ns>10</ns>
    <id>1325</id>
    <revision>
      <id>56103</id>
      <parentid>52755</parentid>
      <timestamp>2013-06-01T05:30:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/sentry/dcl list constructor]] to [[Template:cpp/io/basic ostream/sentry/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem ctor | cpp/io/basic_ostream/sentry | inlinemem=true | constructs the sentry object. All the preparation tasks are done here }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/sentry/dsc operator bool</title>
    <ns>10</ns>
    <id>1326</id>
    <revision>
      <id>56105</id>
      <parentid>52756</parentid>
      <timestamp>2013-06-01T05:30:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostream/sentry/dcl list operator bool]] to [[Template:cpp/io/basic ostream/sentry/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc mem fun | cpp/io/basic_ostream/sentry | title=operator bool | inlinemem=true | checks if the preparation of the stream object was successful}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/sentry/title</title>
    <ns>10</ns>
    <id>10140</id>
    <revision>
      <id>48409</id>
      <parentid>48408</parentid>
      <timestamp>2013-05-29T15:21:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/io/basic_ostream/title | n=sentry::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostream/title</title>
    <ns>10</ns>
    <id>1458</id>
    <revision>
      <id>2916</id>
      <parentid>2915</parentid>
      <timestamp>2011-06-06T22:56:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=basic_ostream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostringstream/navbar</title>
    <ns>10</ns>
    <id>1459</id>
    <revision>
      <id>39918</id>
      <parentid>35929</parentid>
      <timestamp>2012-09-28T20:10:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="252">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_ostringstream/navbar heading
|content3 = cpp/io/basic_ostringstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostringstream/navbar content</title>
    <ns>10</ns>
    <id>1460</id>
    <revision>
      <id>52758</id>
      <parentid>35146</parentid>
      <timestamp>2013-06-01T04:53:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="348">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_ostringstream/basic_ostringstream}}
{{nv mem ln | cpp/io/basic_ostringstream/operator{{=}}}}
{{nv mem ln | cpp/io/basic_ostringstream/swap}}
{{nv mem ln | cpp/io/basic_ostringstream/rdbuf}}

{{nv h2 | String operations }}
{{nv mem ln | cpp/io/basic_ostringstream/str}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostringstream/navbar heading</title>
    <ns>10</ns>
    <id>1461</id>
    <revision>
      <id>34985</id>
      <parentid>2922</parentid>
      <timestamp>2012-06-15T22:15:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic ostringstream/sidebar heading]] to [[Template:cpp/io/basic ostringstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="63">{{ltt | cpp/io/basic_ostringstream | std::basic_ostringstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic ostringstream/title</title>
    <ns>10</ns>
    <id>1462</id>
    <revision>
      <id>2924</id>
      <parentid>2923</parentid>
      <timestamp>2011-06-06T22:56:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=basic_ostringstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc basic streambuf</title>
    <ns>10</ns>
    <id>4352</id>
    <revision>
      <id>56107</id>
      <parentid>52759</parentid>
      <timestamp>2013-06-01T05:30:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list basic streambuf]] to [[Template:cpp/io/basic streambuf/dsc basic streambuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc prot mem ctor | cpp/io/basic_streambuf/basic_streambuf | constructs a basic_streambuf object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc gbump</title>
    <ns>10</ns>
    <id>4358</id>
    <revision>
      <id>56109</id>
      <parentid>52760</parentid>
      <timestamp>2013-06-01T05:30:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list gbump]] to [[Template:cpp/io/basic streambuf/dsc gbump]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc prot mem fun | cpp/io/basic_streambuf/gbump | advances the next pointer in the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc getloc</title>
    <ns>10</ns>
    <id>4330</id>
    <revision>
      <id>56111</id>
      <parentid>52761</parentid>
      <timestamp>2013-06-01T05:30:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list getloc]] to [[Template:cpp/io/basic streambuf/dsc getloc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/io/basic_streambuf/getloc | obtains a copy of the associated locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc gptr</title>
    <ns>10</ns>
    <id>4356</id>
    <revision>
      <id>56113</id>
      <parentid>52762</parentid>
      <timestamp>2013-06-01T05:31:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list gptr]] to [[Template:cpp/io/basic streambuf/dsc gptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc prot mem fun | cpp/io/basic_streambuf/gptr | title=eback&lt;br&gt;gptr&lt;br&gt;egptr | returns a pointer to the beginning, current character and the end of the get area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc imbue</title>
    <ns>10</ns>
    <id>4332</id>
    <revision>
      <id>56115</id>
      <parentid>52763</parentid>
      <timestamp>2013-06-01T05:31:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list imbue]] to [[Template:cpp/io/basic streambuf/dsc imbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc prot mem vfun | cpp/io/basic_streambuf/pubimbue | title=imbue | changes the associated locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc in avail</title>
    <ns>10</ns>
    <id>4341</id>
    <revision>
      <id>56117</id>
      <parentid>52764</parentid>
      <timestamp>2013-06-01T05:31:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list in avail]] to [[Template:cpp/io/basic streambuf/dsc in avail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/io/basic_streambuf/in_avail | obtains the number of characters immediately available in the get area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc operator=</title>
    <ns>10</ns>
    <id>4353</id>
    <revision>
      <id>56119</id>
      <parentid>52765</parentid>
      <timestamp>2013-06-01T05:31:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list operator=]] to [[Template:cpp/io/basic streambuf/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc prot mem fun | cpp/io/basic_streambuf/operator{{=}} | replaces a basic_streambuf object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc overflow</title>
    <ns>10</ns>
    <id>4368</id>
    <revision>
      <id>56121</id>
      <parentid>52766</parentid>
      <timestamp>2013-06-01T05:31:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list overflow]] to [[Template:cpp/io/basic streambuf/dsc overflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc prot mem vfun | cpp/io/basic_streambuf/overflow | writes characters to the associated output sequence from the put area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pbackfail</title>
    <ns>10</ns>
    <id>4369</id>
    <revision>
      <id>56123</id>
      <parentid>52767</parentid>
      <timestamp>2013-06-01T05:31:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pbackfail]] to [[Template:cpp/io/basic streambuf/dsc pbackfail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc prot mem vfun | cpp/io/basic_streambuf/pbackfail | puts a character back into the input sequence, possibly modifying the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pbump</title>
    <ns>10</ns>
    <id>4361</id>
    <revision>
      <id>56125</id>
      <parentid>52768</parentid>
      <timestamp>2013-06-01T05:31:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pbump]] to [[Template:cpp/io/basic streambuf/dsc pbump]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc prot mem fun | cpp/io/basic_streambuf/pbump | advances the next pointer of the output sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pptr</title>
    <ns>10</ns>
    <id>4363</id>
    <revision>
      <id>56127</id>
      <parentid>52769</parentid>
      <timestamp>2013-06-01T05:31:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pptr]] to [[Template:cpp/io/basic streambuf/dsc pptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc prot mem fun | cpp/io/basic_streambuf/pptr | title=pbase&lt;br&gt;pptr&lt;br&gt;epptr | returns a pointer to the beginning, current character and the end of the put area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pubimbue</title>
    <ns>10</ns>
    <id>4331</id>
    <revision>
      <id>56129</id>
      <parentid>52770</parentid>
      <timestamp>2013-06-01T05:31:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pubimbue]] to [[Template:cpp/io/basic streambuf/dsc pubimbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/io/basic_streambuf/pubimbue | invokes {{c|imbue()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pubseekoff</title>
    <ns>10</ns>
    <id>4335</id>
    <revision>
      <id>56132</id>
      <parentid>52771</parentid>
      <timestamp>2013-06-01T05:31:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pubseekoff]] to [[Template:cpp/io/basic streambuf/dsc pubseekoff]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/io/basic_streambuf/pubseekoff | invokes {{c|seekoff()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pubseekpos</title>
    <ns>10</ns>
    <id>4337</id>
    <revision>
      <id>56134</id>
      <parentid>52772</parentid>
      <timestamp>2013-06-01T05:31:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pubseekpos]] to [[Template:cpp/io/basic streambuf/dsc pubseekpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/io/basic_streambuf/pubseekpos | invokes {{c|seekpos()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pubsetbuf</title>
    <ns>10</ns>
    <id>4333</id>
    <revision>
      <id>56136</id>
      <parentid>52773</parentid>
      <timestamp>2013-06-01T05:31:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pubsetbuf]] to [[Template:cpp/io/basic streambuf/dsc pubsetbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/io/basic_streambuf/pubsetbuf | mem={{{mem|}}} | invokes {{c|setbuf()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc pubsync</title>
    <ns>10</ns>
    <id>4339</id>
    <revision>
      <id>56138</id>
      <parentid>52774</parentid>
      <timestamp>2013-06-01T05:31:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list pubsync]] to [[Template:cpp/io/basic streambuf/dsc pubsync]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/io/basic_streambuf/pubsync | invokes {{c|sync()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sbumpc</title>
    <ns>10</ns>
    <id>4343</id>
    <revision>
      <id>56140</id>
      <parentid>52775</parentid>
      <timestamp>2013-06-01T05:31:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sbumpc]] to [[Template:cpp/io/basic streambuf/dsc sbumpc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc mem fun | cpp/io/basic_streambuf/sbumpc | reads one character from the input sequence and advances the sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc seekoff</title>
    <ns>10</ns>
    <id>4336</id>
    <revision>
      <id>56142</id>
      <parentid>52776</parentid>
      <timestamp>2013-06-01T05:31:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list seekoff]] to [[Template:cpp/io/basic streambuf/dsc seekoff]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="179">{{dsc prot mem vfun | cpp/io/basic_streambuf/pubseekoff | title=seekoff | repositions the next pointer in the input sequence, output sequence, or both, using relative addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc seekpos</title>
    <ns>10</ns>
    <id>4338</id>
    <revision>
      <id>56144</id>
      <parentid>52777</parentid>
      <timestamp>2013-06-01T05:31:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list seekpos]] to [[Template:cpp/io/basic streambuf/dsc seekpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="178">{{dsc prot mem vfun | cpp/io/basic_streambuf/pubseekpos | title=seekpos | repositions the next pointer in the input sequence, output sequence, or both using absolute addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc setbuf</title>
    <ns>10</ns>
    <id>4334</id>
    <revision>
      <id>56146</id>
      <parentid>52778</parentid>
      <timestamp>2013-06-01T05:31:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list setbuf]] to [[Template:cpp/io/basic streambuf/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc prot mem vfun | cpp/io/basic_streambuf/pubsetbuf | title=setbuf | replaces the buffer with user-defined array, if permitted}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc setg</title>
    <ns>10</ns>
    <id>4359</id>
    <revision>
      <id>56148</id>
      <parentid>52779</parentid>
      <timestamp>2013-06-01T05:31:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list setg]] to [[Template:cpp/io/basic streambuf/dsc setg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc prot mem fun | cpp/io/basic_streambuf/setg | repositions the beginning, next, and end pointers of the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc setp</title>
    <ns>10</ns>
    <id>4360</id>
    <revision>
      <id>56150</id>
      <parentid>52780</parentid>
      <timestamp>2013-06-01T05:31:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list setp]] to [[Template:cpp/io/basic streambuf/dsc setp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc prot mem fun | cpp/io/basic_streambuf/setp | repositions the beginning, next, and end pointers of the output sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sgetc</title>
    <ns>10</ns>
    <id>4342</id>
    <revision>
      <id>56152</id>
      <parentid>52781</parentid>
      <timestamp>2013-06-01T05:31:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sgetc]] to [[Template:cpp/io/basic streambuf/dsc sgetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/io/basic_streambuf/sgetc | reads one character from the input sequence without advancing the sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sgetn</title>
    <ns>10</ns>
    <id>4345</id>
    <revision>
      <id>56154</id>
      <parentid>52782</parentid>
      <timestamp>2013-06-01T05:31:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sgetn]] to [[Template:cpp/io/basic streambuf/dsc sgetn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/io/basic_streambuf/sgetn | invokes {{c|xsgetn()}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc showmanyc</title>
    <ns>10</ns>
    <id>4365</id>
    <revision>
      <id>56156</id>
      <parentid>52783</parentid>
      <timestamp>2013-06-01T05:31:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list showmanyc]] to [[Template:cpp/io/basic streambuf/dsc showmanyc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc prot mem vfun | cpp/io/basic_streambuf/showmanyc | obtains the number of characters available for input in the associated input sequence, if known }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc snextc</title>
    <ns>10</ns>
    <id>4344</id>
    <revision>
      <id>56158</id>
      <parentid>52784</parentid>
      <timestamp>2013-06-01T05:31:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list snextc]] to [[Template:cpp/io/basic streambuf/dsc snextc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/io/basic_streambuf/snextc | advances the input sequence, then reads one character without advancing again}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sputbackc</title>
    <ns>10</ns>
    <id>4347</id>
    <revision>
      <id>56160</id>
      <parentid>52785</parentid>
      <timestamp>2013-06-01T05:31:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sputbackc]] to [[Template:cpp/io/basic streambuf/dsc sputbackc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/io/basic_streambuf/sputbackc | puts one character back in the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sputc</title>
    <ns>10</ns>
    <id>4349</id>
    <revision>
      <id>56162</id>
      <parentid>52786</parentid>
      <timestamp>2013-06-01T05:32:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sputc]] to [[Template:cpp/io/basic streambuf/dsc sputc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/io/basic_streambuf/sputc | writes one character to the put area and advances the next pointer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sputn</title>
    <ns>10</ns>
    <id>4350</id>
    <revision>
      <id>56164</id>
      <parentid>52787</parentid>
      <timestamp>2013-06-01T05:32:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sputn]] to [[Template:cpp/io/basic streambuf/dsc sputn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/io/basic_streambuf/sputn | invokes {{c|xsputn()}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc stossc</title>
    <ns>10</ns>
    <id>4798</id>
    <revision>
      <id>64381</id>
      <parentid>64380</parentid>
      <timestamp>2013-08-15T18:49:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="184">{{dsc mem fun | stossc | nolink=true | notes={{mark deprecated}} | advances the input sequence as if by calling {{lc|std::basic_streambuf::sbumpc|sbumpc()}} and discarding the result}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sungetc</title>
    <ns>10</ns>
    <id>4348</id>
    <revision>
      <id>56168</id>
      <parentid>52789</parentid>
      <timestamp>2013-06-01T05:32:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sungetc]] to [[Template:cpp/io/basic streambuf/dsc sungetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem fun | cpp/io/basic_streambuf/sungetc | moves the next pointer in the input sequence back by one}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc swap</title>
    <ns>10</ns>
    <id>4354</id>
    <revision>
      <id>56170</id>
      <parentid>52790</parentid>
      <timestamp>2013-06-01T05:32:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list swap]] to [[Template:cpp/io/basic streambuf/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc prot mem fun | cpp/io/basic_streambuf/swap | swaps two basic_streambuf objects | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc sync</title>
    <ns>10</ns>
    <id>4340</id>
    <revision>
      <id>56173</id>
      <parentid>52791</parentid>
      <timestamp>2013-06-01T05:32:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list sync]] to [[Template:cpp/io/basic streambuf/dsc sync]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc prot mem vfun | cpp/io/basic_streambuf/pubsync | title=sync | synchronizes the buffers with the associated character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc uflow</title>
    <ns>10</ns>
    <id>4367</id>
    <revision>
      <id>56175</id>
      <parentid>52792</parentid>
      <timestamp>2013-06-01T05:32:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list uflow]] to [[Template:cpp/io/basic streambuf/dsc uflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc prot mem vfun | cpp/io/basic_streambuf/uflow | reads characters from the associated input sequence to the get area and advances the next pointer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc underflow</title>
    <ns>10</ns>
    <id>4366</id>
    <revision>
      <id>56177</id>
      <parentid>52793</parentid>
      <timestamp>2013-06-01T05:32:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list underflow]] to [[Template:cpp/io/basic streambuf/dsc underflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc prot mem vfun | cpp/io/basic_streambuf/underflow | reads characters from the associated input sequence to the get area}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc xsgetn</title>
    <ns>10</ns>
    <id>4346</id>
    <revision>
      <id>56179</id>
      <parentid>52794</parentid>
      <timestamp>2013-06-01T05:32:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list xsgetn]] to [[Template:cpp/io/basic streambuf/dsc xsgetn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc prot mem vfun | cpp/io/basic_streambuf/sgetn | title=xsgetn | reads multiple characters from the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc xsputn</title>
    <ns>10</ns>
    <id>4351</id>
    <revision>
      <id>56181</id>
      <parentid>52795</parentid>
      <timestamp>2013-06-01T05:32:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list xsputn]] to [[Template:cpp/io/basic streambuf/dsc xsputn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc prot mem vfun | cpp/io/basic_streambuf/sputn | title=xsputn | writes multiple characters to the output sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/dsc ~basic streambuf</title>
    <ns>10</ns>
    <id>4329</id>
    <revision>
      <id>56183</id>
      <parentid>52796</parentid>
      <timestamp>2013-06-01T05:32:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic streambuf/dcl list ~basic streambuf]] to [[Template:cpp/io/basic streambuf/dsc ~basic streambuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem vdtor | cpp/io/basic_streambuf/~basic_streambuf | destructs the basic_streambuf object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/example1</title>
    <ns>10</ns>
    <id>4917</id>
    <revision>
      <id>23446</id>
      <parentid>18611</parentid>
      <timestamp>2012-04-20T02:25:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="899">{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;

class null_filter_buf : public std::streambuf {
    std::streambuf* src;
    char ch; // single-byte buffer
protected:
    int underflow() {
        while( (ch= src-&gt;sbumpc()) == '\0') ; // skip zeroes
        setg(&amp;ch, &amp;ch, &amp;ch+1); // make one read position available
        return ch; // may return EOF
    }
public:
    null_filter_buf(std::streambuf* buf) : src(buf) {
        setg(&amp;ch, &amp;ch+1, &amp;ch+1); // buffer is initially full
    }
};

void filtered_read(std::istream&amp; in)
{
    std::streambuf* orig = in.rdbuf();
    null_filter_buf buf(orig);
    in.rdbuf(&amp;buf);
    for(char c; in.get(c); )
            std::cout &lt;&lt; c;
    in.rdbuf(orig);
}

int main()
{
    char a[] = &quot;This i\0s \0an e\0\0\0xample&quot;;
    std::istringstream in(std::string(std::begin(a), std::end(a)));
    filtered_read(in);
}
 | output=
This is an example
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/inherit</title>
    <ns>10</ns>
    <id>4374</id>
    <revision>
      <id>60877</id>
      <parentid>52797</parentid>
      <timestamp>2013-06-01T11:59:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="2543">{{inherited | [[cpp/io/basic_streambuf | {{small|std::}}basic_streambuf]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc inc | cpp/io/dsc char_type}}
{{dsc inc | cpp/io/dsc traits_type}}
{{dsc inc | cpp/io/dsc int_type}}
{{dsc inc | cpp/io/dsc pos_type}}
{{dsc inc | cpp/io/dsc off_type}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc ~basic_streambuf}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubimbue}}
{{dsc inc | cpp/io/basic_streambuf/dsc getloc}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsetbuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekoff}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubseekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc pubsync}}

{{dsc h2 | Get area}}
{{dsc inc | cpp/io/basic_streambuf/dsc in_avail}}
{{dsc inc | cpp/io/basic_streambuf/dsc snextc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sbumpc}}
{{dsc inc | cpp/io/basic_streambuf/dsc stossc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sgetn}}

{{dsc h2 | Put area}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputn}}

{{dsc h2 | Putback}}
{{dsc inc | cpp/io/basic_streambuf/dsc sputbackc}}
{{dsc inc | cpp/io/basic_streambuf/dsc sungetc}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/io/basic_streambuf/dsc basic_streambuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc operator{{=}}}}
{{dsc inc | cpp/io/basic_streambuf/dsc swap}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/basic_streambuf/dsc imbue}}

{{dsc h2 | Positioning}}
{{dsc inc | cpp/io/basic_streambuf/dsc setbuf}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekoff}}
{{dsc inc | cpp/io/basic_streambuf/dsc seekpos}}
{{dsc inc | cpp/io/basic_streambuf/dsc sync}}

{{dsc h2 | Get area}}
{{dsc inc | cpp/io/basic_streambuf/dsc showmanyc}}
{{dsc inc | cpp/io/basic_streambuf/dsc underflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc uflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc xsgetn}}
{{dsc inc | cpp/io/basic_streambuf/dsc gptr}}
{{dsc inc | cpp/io/basic_streambuf/dsc gbump}}
{{dsc inc | cpp/io/basic_streambuf/dsc setg}}

{{dsc h2 | Put area}}
{{dsc inc | cpp/io/basic_streambuf/dsc xsputn}}
{{dsc inc | cpp/io/basic_streambuf/dsc overflow}}
{{dsc inc | cpp/io/basic_streambuf/dsc pptr}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbump}}
{{dsc inc | cpp/io/basic_streambuf/dsc setp}}

{{dsc h2 | Putback}}
{{dsc inc | cpp/io/basic_streambuf/dsc pbackfail}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/navbar</title>
    <ns>10</ns>
    <id>1463</id>
    <revision>
      <id>47779</id>
      <parentid>39919</parentid>
      <timestamp>2013-05-16T20:26:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_streambuf/navbar heading
|content3 = cpp/io/basic_streambuf/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/navbar content</title>
    <ns>10</ns>
    <id>4370</id>
    <revision>
      <id>52798</id>
      <parentid>33410</parentid>
      <timestamp>2013-06-01T04:53:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2226">{{nv begin}}
{{nv h1 | Public member functions}}
{{nv mem ln | cpp/io/basic_streambuf/~basic_streambuf}}

{{nv h2 | Locales }}
{{nv mem ln | cpp/io/basic_streambuf/pubimbue}}
{{nv mem ln | cpp/io/basic_streambuf/getloc}}

{{nv h2 | Positioning }}
{{nv mem ln | cpp/io/basic_streambuf/pubsetbuf}}
{{nv mem ln | cpp/io/basic_streambuf/pubseekoff}}
{{nv mem ln | cpp/io/basic_streambuf/pubseekpos}}
{{nv mem ln | cpp/io/basic_streambuf/pubsync}}

{{nv h2 | Get area }}
{{nv mem ln | cpp/io/basic_streambuf/in_avail}}
{{nv mem ln | cpp/io/basic_streambuf/snextc}}
{{nv mem ln | cpp/io/basic_streambuf/sbumpc}}
{{nv mem ln | cpp/io/basic_streambuf/sgetc}}
{{nv mem ln | cpp/io/basic_streambuf/sgetn}}

{{nv h2 | Put area }}
{{nv mem ln | cpp/io/basic_streambuf/sputc}}
{{nv mem ln | cpp/io/basic_streambuf/sputn}}

{{nv h2 | Putback }}
{{nv mem ln | cpp/io/basic_streambuf/sputbackc}}
{{nv mem ln | cpp/io/basic_streambuf/sungetc}}

{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/io/basic_streambuf/basic_streambuf}}
{{nv mem ln | cpp/io/basic_streambuf/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_streambuf/swap|notes={{mark c++11}}}}

{{nv h2 | Locales }}
{{nv mem ln | cpp/io/basic_streambuf/pubimbue|imbue}}

{{nv h2 | Positioning }}
{{nv mem ln | cpp/io/basic_streambuf/pubsetbuf|setbuf}}
{{nv mem ln | cpp/io/basic_streambuf/pubseekoff|seekoff}}
{{nv mem ln | cpp/io/basic_streambuf/pubseekpos|seekpos}}
{{nv mem ln | cpp/io/basic_streambuf/pubsync|sync}}

{{nv h2 | Get area }}
{{nv mem ln | cpp/io/basic_streambuf/showmanyc}}
{{nv mem ln | cpp/io/basic_streambuf/underflow}}
{{nv mem ln | cpp/io/basic_streambuf/uflow}}
{{nv mem ln | cpp/io/basic_streambuf/sgetn | xsgetn}}
{{nv mem ln | cpp/io/basic_streambuf/gptr | eback | gptr | egptr}}
{{nv mem ln | cpp/io/basic_streambuf/gbump}}
{{nv mem ln | cpp/io/basic_streambuf/setg}}

{{nv h2 | Put area }}
{{nv mem ln | cpp/io/basic_streambuf/sputn | xsputn}}
{{nv mem ln | cpp/io/basic_streambuf/overflow}}
{{nv mem ln | cpp/io/basic_streambuf/pptr | pbase | pptr | epptr}}
{{nv mem ln | cpp/io/basic_streambuf/pbump}}
{{nv mem ln | cpp/io/basic_streambuf/setp}}

{{nv h2 | Putback }}
{{nv mem ln | cpp/io/basic_streambuf/pbackfail}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/navbar heading</title>
    <ns>10</ns>
    <id>2451</id>
    <revision>
      <id>48092</id>
      <parentid>35674</parentid>
      <timestamp>2013-05-18T18:09:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/io/basic_streambuf|std::basic_streambuf}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic streambuf/title</title>
    <ns>10</ns>
    <id>4567</id>
    <revision>
      <id>16114</id>
      <timestamp>2011-12-21T17:00:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=basic_streambuf::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc constructor</title>
    <ns>10</ns>
    <id>9047</id>
    <revision>
      <id>56185</id>
      <parentid>52799</parentid>
      <timestamp>2013-06-01T05:32:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list constructor]] to [[Template:cpp/io/basic stringbuf/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem ctor | cpp/io/basic_stringbuf/basic_stringbuf | constructs a basic_stringbuf object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc destructor</title>
    <ns>10</ns>
    <id>9050</id>
    <revision>
      <id>56189</id>
      <parentid>52800</parentid>
      <timestamp>2013-06-01T05:32:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list destructor]] to [[Template:cpp/io/basic stringbuf/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc mem vdtor | nolink=true | destructs a basic_stringbuf object and the string it holds| notes={{mark implicit}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc operator=</title>
    <ns>10</ns>
    <id>9048</id>
    <revision>
      <id>56191</id>
      <parentid>52801</parentid>
      <timestamp>2013-06-01T05:32:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list operator=]] to [[Template:cpp/io/basic stringbuf/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/io/basic_stringbuf/operator{{=}} | assigns a basic_stringbuf object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc overflow</title>
    <ns>10</ns>
    <id>6343</id>
    <revision>
      <id>56194</id>
      <parentid>52802</parentid>
      <timestamp>2013-06-01T05:32:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list overflow]] to [[Template:cpp/io/basic stringbuf/dsc overflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc prot mem vfun | cpp/io/basic_stringbuf/overflow | appends a character to the output sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc pbackfail</title>
    <ns>10</ns>
    <id>9053</id>
    <revision>
      <id>56196</id>
      <parentid>52803</parentid>
      <timestamp>2013-06-01T05:32:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list pbackfail]] to [[Template:cpp/io/basic stringbuf/dsc pbackfail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc prot mem vfun | cpp/io/basic_stringbuf/pbackfail | puts a character back into the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc seekoff</title>
    <ns>10</ns>
    <id>9055</id>
    <revision>
      <id>56198</id>
      <parentid>52804</parentid>
      <timestamp>2013-06-01T05:32:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list seekoff]] to [[Template:cpp/io/basic stringbuf/dsc seekoff]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc prot mem vfun | cpp/io/basic_stringbuf/seekoff | repositions the next pointer in the input sequence, output sequence, or both, using relative addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc seekpos</title>
    <ns>10</ns>
    <id>9054</id>
    <revision>
      <id>56200</id>
      <parentid>52805</parentid>
      <timestamp>2013-06-01T05:32:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list seekpos]] to [[Template:cpp/io/basic stringbuf/dsc seekpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc prot mem vfun | cpp/io/basic_stringbuf/seekpos | repositions the next pointer in the input sequence, output sequence, or both using absolute addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc setbuf</title>
    <ns>10</ns>
    <id>4695</id>
    <revision>
      <id>56204</id>
      <parentid>52806</parentid>
      <timestamp>2013-06-01T05:32:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list setbuf]] to [[Template:cpp/io/basic stringbuf/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc prot mem vfun | cpp/io/basic_stringbuf/setbuf | mem={{{1|}}}| attempts to replace the controlled character sequence with an array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc str</title>
    <ns>10</ns>
    <id>9051</id>
    <revision>
      <id>56206</id>
      <parentid>52807</parentid>
      <timestamp>2013-06-01T05:32:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list str]] to [[Template:cpp/io/basic stringbuf/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/io/basic_stringbuf/str | replaces or obtains a copy of the associated character string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc swap</title>
    <ns>10</ns>
    <id>9049</id>
    <revision>
      <id>56208</id>
      <parentid>52808</parentid>
      <timestamp>2013-06-01T05:32:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list swap]] to [[Template:cpp/io/basic stringbuf/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/io/basic_stringbuf/swap | swaps two basic_stringbuf objects | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc swap2</title>
    <ns>10</ns>
    <id>9056</id>
    <revision>
      <id>56210</id>
      <parentid>52809</parentid>
      <timestamp>2013-06-01T05:32:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list swap2]] to [[Template:cpp/io/basic stringbuf/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc tfun | cpp/io/basic_stringbuf/swap2 | title=std::swap{{dsc small|(std::basic_stringbuf)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/dsc underflow</title>
    <ns>10</ns>
    <id>9052</id>
    <revision>
      <id>56212</id>
      <parentid>52810</parentid>
      <timestamp>2013-06-01T05:32:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringbuf/dcl list underflow]] to [[Template:cpp/io/basic stringbuf/dsc underflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc prot mem vfun | cpp/io/basic_stringbuf/underflow | returns the next character available in the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/navbar</title>
    <ns>10</ns>
    <id>1464</id>
    <revision>
      <id>47778</id>
      <parentid>39920</parentid>
      <timestamp>2013-05-16T20:26:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_stringbuf/navbar heading
|content3 = cpp/io/basic_stringbuf/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/navbar content</title>
    <ns>10</ns>
    <id>4371</id>
    <revision>
      <id>52811</id>
      <parentid>38021</parentid>
      <timestamp>2013-06-01T04:54:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="760">{{nv begin}}
{{nv h1 | Public member functions}}
{{nv mem ln | cpp/io/basic_stringbuf/basic_stringbuf}}
{{nv mem ln | cpp/io/basic_stringbuf/operator{{=}}|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_stringbuf/swap|notes={{mark c++11}}}}
{{nv mem ln | cpp/io/basic_stringbuf/str}}

{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/io/basic_stringbuf/underflow}}
{{nv mem ln | cpp/io/basic_stringbuf/pbackfail}}
{{nv mem ln | cpp/io/basic_stringbuf/overflow}}
{{nv mem ln | cpp/io/basic_stringbuf/setbuf}}
{{nv mem ln | cpp/io/basic_stringbuf/seekoff}}
{{nv mem ln | cpp/io/basic_stringbuf/seekpos}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/io/basic_stringbuf/swap2|swap{{dsc small|(std::basic_stringbuf)}}|notes={{mark c++11}}}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/navbar heading</title>
    <ns>10</ns>
    <id>2453</id>
    <revision>
      <id>48094</id>
      <parentid>35676</parentid>
      <timestamp>2013-05-18T18:09:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/io/basic_stringbuf|std::basic_stringbuf}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringbuf/title</title>
    <ns>10</ns>
    <id>4577</id>
    <revision>
      <id>16132</id>
      <timestamp>2011-12-22T05:44:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=basic_stringbuf::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/constructor</title>
    <ns>10</ns>
    <id>1465</id>
    <revision>
      <id>65977</id>
      <parentid>63592</parentid>
      <timestamp>2013-10-16T18:00:50Z</timestamp>
      <contributor>
        <username>Seishun</username>
        <id>2538</id>
      </contributor>
      <comment>These constructors are explicit (why isn't this template shared with stringbuf?)</comment>
      <text xml:space="preserve" bytes="2712">{{cpp/io/{{{1|}}}/title | {{{1|}}}}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
explicit {{{1}}}( ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_istringstream=ios_base::in );
 | basic_ostringstream=ios_base::out );
 | basic_stringstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl | num=2  | 1=
explicit {{{1}}}( const std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; str,
{{space as|{{{1}}}}}  ios_base::openmode mode {{=}} {{#switch: {{{1|}}}
 | basic_istringstream=ios_base::in );
 | basic_ostringstream=ios_base::out );
 | basic_stringstream= ios_base::in{{!}}ios_base::out );
}}
}}
{{dcl | num=3 | since=c++11 |
{{{1}}}( {{{1}}}&amp;&amp; other );
}}
{{dcl end}}

Constructs new string stream.

1) Constructs new underlying string device. The underlying {{tt|basic_stringbuf}} object is constructed as {{#switch: {{{1|}}}
 | basic_istringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(mode {{!}} ios_base::in)}}.
 | basic_ostringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(mode {{!}} ios_base::out)}}.
 | basic_stringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(mode)}}.
}}

2) Uses a copy of {{tt|str}} as initial contents of the underlying string device. The underlying {{tt|basic_stringbuf}} object is constructed as {{#switch: {{{1|}}}
 | basic_istringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(str, mode {{!}} ios_base::in)}}.
 | basic_ostringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(str, mode {{!}} ios_base::out)}}.
 | basic_stringstream={{c|basic_stringbuf&lt;Char,Traits,Allocator&gt;(str, mode)}}.
}}

3) Move constructor. Constructs the file stream with the state of {{tt|other}} using move semantics. 

===Parameters===
{{par begin}}
{{par | str | string to use as initial contents of the string stream}}
{{par | mode | specifies stream open mode. It is bitmask type, the following constants are defined: 
{{cpp/io/ios_base/openmode consts}} }}
{{par | other | another string stream to use as source}}
{{par end}}

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;sstream&gt;
int main()
{
    // default constructor (input/output stream)
    std::stringstream buf1;
    buf1 &lt;&lt; 7;
    int n = 0;
    buf1 &gt;&gt; n;
    std::cout &lt;&lt; &quot;buf1 = &quot; &lt;&lt; buf1.str() &lt;&lt; &quot; n = &quot; &lt;&lt; n &lt;&lt; '\n';

    // input stream
    std::istringstream inbuf(&quot;-10&quot;);
    inbuf &gt;&gt; n;
    std::cout &lt;&lt; &quot;n = &quot; &lt;&lt; n &lt;&lt; '\n';

    // output stream in append mode (C++11)
    std::ostringstream buf2(&quot;test&quot;, std::ios_base::ate);
    buf2 &lt;&lt; '1';
    std::cout &lt;&lt; buf2.str() &lt;&lt; '\n';
}
 | output=
buf1 = 7 n = 7
n = -10
test1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc str |{{{1|}}}}}
{{dsc inc | cpp/io/basic_stringbuf/dsc constructor}}
{{dsc end}}</text>
      <sha1>pxrbvfqaclq6da1kfe8no71l6aeu7jl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc constructor</title>
    <ns>10</ns>
    <id>1466</id>
    <revision>
      <id>56214</id>
      <parentid>52813</parentid>
      <timestamp>2013-06-01T05:32:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/dcl list constructor]] to [[Template:cpp/io/basic stringstream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem ctor | cpp/io/{{{1|}}}/{{{1|}}} | constructs the string stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc operator=</title>
    <ns>10</ns>
    <id>1467</id>
    <revision>
      <id>56216</id>
      <parentid>52814</parentid>
      <timestamp>2013-06-01T05:32:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/dcl list operator=]] to [[Template:cpp/io/basic stringstream/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/io/{{{1|}}}/operator{{=}} | moves the string stream | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc rdbuf</title>
    <ns>10</ns>
    <id>1468</id>
    <revision>
      <id>56218</id>
      <parentid>52815</parentid>
      <timestamp>2013-06-01T05:33:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/dcl list rdbuf]] to [[Template:cpp/io/basic stringstream/dsc rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/io/{{{1|}}}/rdbuf | returns the underlying raw string device object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc str</title>
    <ns>10</ns>
    <id>1469</id>
    <revision>
      <id>56220</id>
      <parentid>52816</parentid>
      <timestamp>2013-06-01T05:33:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/dcl list str]] to [[Template:cpp/io/basic stringstream/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/io/{{{1|}}}/str | gets or sets the contents of underlying string device object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc swap</title>
    <ns>10</ns>
    <id>1470</id>
    <revision>
      <id>56222</id>
      <parentid>52817</parentid>
      <timestamp>2013-06-01T05:33:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/dcl list swap]] to [[Template:cpp/io/basic stringstream/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/io/{{{1|}}}/swap | swaps two string streams | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/dsc swap2</title>
    <ns>10</ns>
    <id>12581</id>
    <revision>
      <id>61068</id>
      <timestamp>2013-06-05T03:10:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="148">{{dsc tfun | cpp/io/{{{1}}}/swap2 | title=std::swap{{dsc small|(std::{{{1}}})}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/navbar</title>
    <ns>10</ns>
    <id>1473</id>
    <revision>
      <id>39921</id>
      <parentid>35677</parentid>
      <timestamp>2012-09-28T20:10:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/basic_stringstream/navbar heading
|content3 = cpp/io/basic_stringstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/navbar content</title>
    <ns>10</ns>
    <id>1474</id>
    <revision>
      <id>52818</id>
      <parentid>35679</parentid>
      <timestamp>2013-06-01T04:54:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="342">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/basic_stringstream/basic_stringstream}}
{{nv mem ln | cpp/io/basic_stringstream/operator{{=}}}}
{{nv mem ln | cpp/io/basic_stringstream/swap}}
{{nv mem ln | cpp/io/basic_stringstream/rdbuf}}

{{nv h2 | String operations }}
{{nv mem ln | cpp/io/basic_stringstream/str}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/navbar heading</title>
    <ns>10</ns>
    <id>1475</id>
    <revision>
      <id>35681</id>
      <parentid>2950</parentid>
      <timestamp>2012-06-15T22:30:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/basic stringstream/sidebar heading]] to [[Template:cpp/io/basic stringstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="61">{{ltt | cpp/io/basic_stringstream | std::basic_stringstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/operator=</title>
    <ns>10</ns>
    <id>1471</id>
    <revision>
      <id>62260</id>
      <parentid>62256</parentid>
      <timestamp>2013-06-25T12:42:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <text xml:space="preserve" bytes="621">{{cpp/title | n={{trim|{{{1|}}}}}:: | operator{{=}}}}
{{cpp/io/{{trim|{{{1|}}}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
{{trim|{{{1}}}}}&amp; operator{{=}}( {{trim|{{{1}}}}}&amp;&amp; other );
}}
{{dcl end}}

Moves the string stream. The source stream becomes of invalid state after the operation. 

===Parameters===
{{par begin}}
{{par | other | string stream to move. {{tt|other}} becomes of invalid state after the operation. }}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/rdbuf</title>
    <ns>10</ns>
    <id>1472</id>
    <revision>
      <id>62255</id>
      <parentid>44673</parentid>
      <timestamp>2013-06-25T12:41:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="381">{{cpp/title | n={{trim|{{{1|}}}}}:: | rdbuf}}
{{cpp/io/{{trim|{{{1|}}}}}/navbar}}
{{dcl begin}}
{{dcl |
std::basic_stringbuf&lt;CharT, Traits, Allocator&gt;* rdbuf() const;
}}
{{dcl end}}

Returns pointer to the underlying raw string device object. 

===Parameters===
(none)

===Return value===
Pointer to the underlying raw string device.

===Example===
{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/str</title>
    <ns>10</ns>
    <id>1476</id>
    <revision>
      <id>64102</id>
      <parentid>64091</parentid>
      <timestamp>2013-08-09T00:42:12Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>not sure if this is entirely appropriate here, but cleaning it up a bit regardless</comment>
      <text xml:space="preserve" bytes="1985">{{cpp/io/{{{1|}}}/title | str}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
std::basic_string&lt;CharT,Traits,Allocator&gt; str() const;
}}
{{dcl | num=2 | 1=
void str(const std::basic_string&lt;CharT,Traits,Allocator&gt;&amp; new_str);
}}
{{dcl end}}

Manages the contents of the underlying string object. 

1) Returns a copy of the underlying string as if by calling {{c|rdbuf()-&gt;str()}}.

2) Replaces the contents of the underlying string as if by calling {{c|rdbuf()-&gt;str(new_str)}}.

===Parameters===
{{par begin}}
{{par | new_str | new contents of the underlying string}}
{{par end}}

===Return value===

1) a copy of the underlying string object.

2) (none)

===Notes===
The copy of the underlying string returned by {{tt|str}} is a temporary object that will be destructed at the end of the expression, so directly calling [[cpp/string/basic_string/c_str|{{c|c_str()}}]] on the result of {{c|str()}} (for example in {{c|1=auto *ptr = out.str().c_str();}}) results in a dangling pointer.

===Example===
{{example
 | code=
#include &lt;sstream&gt;
#include &lt;iostream&gt;
int main()
{
    int n;

    std::istringstream in;  // could also use in(&quot;1 2&quot;)
    in.str(&quot;1 2&quot;);
    in &gt;&gt; n;
    std::cout &lt;&lt; &quot;after reading the first int from \&quot;1 2\&quot;, the int is &quot;
              &lt;&lt; n &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; in.str() &lt;&lt; &quot;\&quot;\n&quot;;

    std::ostringstream out(&quot;1 2&quot;);
    out &lt;&lt; 3;
    std::cout &lt;&lt; &quot;after writing the int '3' to output stream \&quot;1 2\&quot;&quot;
              &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; out.str() &lt;&lt; &quot;\&quot;\n&quot;;

    std::ostringstream ate(&quot;1 2&quot;, std::ios_base::ate);
    ate &lt;&lt; 3;
    std::cout &lt;&lt; &quot;after writing the int '3' to append stream \&quot;1 2\&quot;&quot;
              &lt;&lt; &quot;, str() = \&quot;&quot; &lt;&lt; ate.str() &lt;&lt; &quot;\&quot;\n&quot;;
}
 | output=
after reading the first int from &quot;1 2&quot;, the int is 1, str() = &quot;1 2&quot;
after writing the int '3' to output stream &quot;1 2&quot;, str() = &quot;3 2&quot;
after writing the int '3' to append stream &quot;1 2&quot;, str() = &quot;1 23&quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringbuf/dsc str}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/swap</title>
    <ns>10</ns>
    <id>1477</id>
    <revision>
      <id>72207</id>
      <parentid>62254</parentid>
      <timestamp>2014-07-23T15:26:30Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>correction</comment>
      <text xml:space="preserve" bytes="851">{{cpp/title | n={{trim|{{{1|}}}}}:: | swap}}
{{cpp/io/{{trim|{{{1|}}}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void swap( {{{1|}}}&amp; other );
}}
{{dcl end}}

Exchanges the state of the stream with those of {{tt|other}}. 

This is done by calling{{#switch: {{{1|}}} | basic_istringstream={{c|basic_istream&lt;CharT, Traits&gt;::swap(other)}} | basic_ostringstream={{c|basic_ostream&lt;CharT, Traits&gt;::swap(other)}} | basic_stringstream={{c|basic_iostream&lt;CharT, Traits&gt;::swap(other)}}}} and {{c|rdbuf()-&gt;swap(*other.rdbuf())}}.  

===Parameters===
{{par begin}}
{{par | other | stream to exchange the state with}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc operator{{=}} |{{{1|}}}}}
{{dsc inc | cpp/io/basic_stringbuf/dsc swap}}
{{dsc end}}</text>
      <sha1>tcju3npw0at94qypft8b46xk5wu9xf1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/swap2</title>
    <ns>10</ns>
    <id>5495</id>
    <revision>
      <id>72206</id>
      <parentid>61070</parentid>
      <timestamp>2014-07-23T15:22:24Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>correct the template parameters</comment>
      <text xml:space="preserve" bytes="739">{{cpp/title | swap&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class CharT, class Traits, class Allocator &gt;
void swap( std::{{{1}}}&lt;CharT,Traits,Allocator&gt;&amp; lhs,
           std::{{{1}}}&lt;CharT,Traits,Allocator&gt;&amp; rhs );
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{c|std::{{{1}}}}}. Exchanges the state of {{tt|lhs}} with that of {{tt|rhs}}. Effectively calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | streams whose state to swap}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/basic_stringstream/dsc swap | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>13p7dw3j32m5ga87h0c58labl1d3dcn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/basic stringstream/title</title>
    <ns>10</ns>
    <id>1478</id>
    <revision>
      <id>2956</id>
      <parentid>2955</parentid>
      <timestamp>2011-06-06T22:56:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=basic_stringstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/buffering modes</title>
    <ns>10</ns>
    <id>1479</id>
    <revision>
      <id>2958</id>
      <parentid>2957</parentid>
      <timestamp>2011-06-06T22:56:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="129">{| class=&quot;wikitable&quot;
|-
| {{tt|_IOFBF}}
| full buffering
|-
| {{tt|_IOLBF}}
| line buffering
|-
| {{tt|_IONBF}}
| no buffering
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc clearerr</title>
    <ns>10</ns>
    <id>1480</id>
    <revision>
      <id>56224</id>
      <parentid>52823</parentid>
      <timestamp>2013-06-01T05:33:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list clearerr]] to [[Template:cpp/io/c/dsc clearerr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">{{dsc fun | cpp/io/c/clearerr | clears errors}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fclose</title>
    <ns>10</ns>
    <id>1481</id>
    <revision>
      <id>56226</id>
      <parentid>52824</parentid>
      <timestamp>2013-06-01T05:33:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fclose]] to [[Template:cpp/io/c/dsc fclose]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">{{dsc fun | cpp/io/c/fclose | closes a file }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc feof</title>
    <ns>10</ns>
    <id>1482</id>
    <revision>
      <id>56228</id>
      <parentid>52825</parentid>
      <timestamp>2013-06-01T05:33:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list feof]] to [[Template:cpp/io/c/dsc feof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">{{dsc fun | cpp/io/c/feof | checks for the end-of-file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc ferror</title>
    <ns>10</ns>
    <id>1483</id>
    <revision>
      <id>56230</id>
      <parentid>52826</parentid>
      <timestamp>2013-06-01T05:33:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list ferror]] to [[Template:cpp/io/c/dsc ferror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">{{dsc fun |cpp/io/c/ferror | checks for a file error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fflush</title>
    <ns>10</ns>
    <id>1484</id>
    <revision>
      <id>56232</id>
      <parentid>52827</parentid>
      <timestamp>2013-06-01T05:33:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fflush]] to [[Template:cpp/io/c/dsc fflush]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | cpp/io/c/fflush | synchronizes an output stream with the actual file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fgetc</title>
    <ns>10</ns>
    <id>1485</id>
    <revision>
      <id>56234</id>
      <parentid>52828</parentid>
      <timestamp>2013-06-01T05:33:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fgetc]] to [[Template:cpp/io/c/dsc fgetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/io/c/fgetc | title=fgetc&lt;br&gt;getc | gets a character from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fgetpos</title>
    <ns>10</ns>
    <id>1486</id>
    <revision>
      <id>56236</id>
      <parentid>52829</parentid>
      <timestamp>2013-06-01T05:33:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fgetpos]] to [[Template:cpp/io/c/dsc fgetpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | cpp/io/c/fgetpos | gets the file position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fgets</title>
    <ns>10</ns>
    <id>1487</id>
    <revision>
      <id>56239</id>
      <parentid>52830</parentid>
      <timestamp>2013-06-01T05:33:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fgets]] to [[Template:cpp/io/c/dsc fgets]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/io/c/fgets | gets a character string from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fgetwc</title>
    <ns>10</ns>
    <id>1488</id>
    <revision>
      <id>56241</id>
      <parentid>52831</parentid>
      <timestamp>2013-06-01T05:33:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fgetwc]] to [[Template:cpp/io/c/dsc fgetwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/io/c/fgetwc | title=fgetwc&lt;br&gt;getwc | gets a wide character from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fgetws</title>
    <ns>10</ns>
    <id>1489</id>
    <revision>
      <id>56243</id>
      <parentid>52832</parentid>
      <timestamp>2013-06-01T05:33:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fgetws]] to [[Template:cpp/io/c/dsc fgetws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | cpp/io/c/fgetws | gets a wide string from a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fopen</title>
    <ns>10</ns>
    <id>1490</id>
    <revision>
      <id>56245</id>
      <parentid>52833</parentid>
      <timestamp>2013-06-01T05:33:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fopen]] to [[Template:cpp/io/c/dsc fopen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">{{dsc fun | cpp/io/c/fopen | opens a file }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fprintf</title>
    <ns>10</ns>
    <id>1491</id>
    <revision>
      <id>56247</id>
      <parentid>52834</parentid>
      <timestamp>2013-06-01T05:33:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fprintf]] to [[Template:cpp/io/c/dsc fprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="184">{{dsc fun | cpp/io/c/fprintf | title=printf&lt;br&gt;fprintf&lt;br&gt;sprintf&lt;br&gt;snprintf | prints formatted output to {{lc|stdout}}, a file stream or a buffer | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fputc</title>
    <ns>10</ns>
    <id>1492</id>
    <revision>
      <id>56249</id>
      <parentid>52835</parentid>
      <timestamp>2013-06-01T05:33:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fputc]] to [[Template:cpp/io/c/dsc fputc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/io/c/fputc | title=fputc&lt;br&gt;putc | writes a character to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fputs</title>
    <ns>10</ns>
    <id>1493</id>
    <revision>
      <id>56251</id>
      <parentid>52836</parentid>
      <timestamp>2013-06-01T05:33:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fputs]] to [[Template:cpp/io/c/dsc fputs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/io/c/fputs | writes a character string to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fputwc</title>
    <ns>10</ns>
    <id>1494</id>
    <revision>
      <id>56254</id>
      <parentid>52837</parentid>
      <timestamp>2013-06-01T05:33:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fputwc]] to [[Template:cpp/io/c/dsc fputwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/io/c/fputwc | title=fputwc&lt;br&gt;putwc | writes a wide character to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fputws</title>
    <ns>10</ns>
    <id>1495</id>
    <revision>
      <id>56256</id>
      <parentid>52838</parentid>
      <timestamp>2013-06-01T05:33:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fputws]] to [[Template:cpp/io/c/dsc fputws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | cpp/io/c/fputws | writes a wide string to a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fread</title>
    <ns>10</ns>
    <id>1496</id>
    <revision>
      <id>56258</id>
      <parentid>52839</parentid>
      <timestamp>2013-06-01T05:33:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fread]] to [[Template:cpp/io/c/dsc fread]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">{{dsc fun | cpp/io/c/fread | reads from a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc freopen</title>
    <ns>10</ns>
    <id>1497</id>
    <revision>
      <id>56260</id>
      <parentid>52840</parentid>
      <timestamp>2013-06-01T05:33:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list freopen]] to [[Template:cpp/io/c/dsc freopen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/io/c/freopen | open an existing stream with a different name}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fscanf</title>
    <ns>10</ns>
    <id>1498</id>
    <revision>
      <id>56262</id>
      <parentid>52841</parentid>
      <timestamp>2013-06-01T05:33:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fscanf]] to [[Template:cpp/io/c/dsc fscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | cpp/io/c/fscanf | title=scanf&lt;br&gt;fscanf&lt;br&gt;sscanf | reads formatted input from {{lc|stdin}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fseek</title>
    <ns>10</ns>
    <id>1499</id>
    <revision>
      <id>56264</id>
      <parentid>52842</parentid>
      <timestamp>2013-06-01T05:33:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fseek]] to [[Template:cpp/io/c/dsc fseek]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | cpp/io/c/fseek | moves the file position indicator to a specific location in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fsetpos</title>
    <ns>10</ns>
    <id>1500</id>
    <revision>
      <id>56266</id>
      <parentid>52843</parentid>
      <timestamp>2013-06-01T05:33:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fsetpos]] to [[Template:cpp/io/c/dsc fsetpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | cpp/io/c/fsetpos | moves the file position indicator to a specific location in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc ftell</title>
    <ns>10</ns>
    <id>1501</id>
    <revision>
      <id>56268</id>
      <parentid>52844</parentid>
      <timestamp>2013-06-01T05:33:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list ftell]] to [[Template:cpp/io/c/dsc ftell]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/c/ftell | returns the current file position indicator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fwide</title>
    <ns>10</ns>
    <id>2935</id>
    <revision>
      <id>56270</id>
      <parentid>52845</parentid>
      <timestamp>2013-06-01T05:33:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fwide]] to [[Template:cpp/io/c/dsc fwide]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | cpp/io/c/fwide | switches a file stream between wide character I/O and narrow character I/O}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fwprintf</title>
    <ns>10</ns>
    <id>1502</id>
    <revision>
      <id>56272</id>
      <parentid>52846</parentid>
      <timestamp>2013-06-01T05:34:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fwprintf]] to [[Template:cpp/io/c/dsc fwprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc fun | cpp/io/c/fwprintf | title=wprintf&lt;br&gt;fwprintf&lt;br&gt;swprintf | prints formatted wide character output to {{lc|stdout}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fwrite</title>
    <ns>10</ns>
    <id>1503</id>
    <revision>
      <id>56274</id>
      <parentid>52847</parentid>
      <timestamp>2013-06-01T05:34:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fwrite]] to [[Template:cpp/io/c/dsc fwrite]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">{{dsc fun | cpp/io/c/fwrite | writes to a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc fwscanf</title>
    <ns>10</ns>
    <id>1504</id>
    <revision>
      <id>56276</id>
      <parentid>52848</parentid>
      <timestamp>2013-06-01T05:34:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list fwscanf]] to [[Template:cpp/io/c/dsc fwscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc fun | cpp/io/c/fwscanf | title=wscanf&lt;br&gt;fwscanf&lt;br&gt;swscanf | reads formatted wide character input from {{lc|stdin}}, a file stream or a buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc getchar</title>
    <ns>10</ns>
    <id>1505</id>
    <revision>
      <id>56278</id>
      <parentid>52849</parentid>
      <timestamp>2013-06-01T05:34:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list getchar]] to [[Template:cpp/io/c/dsc getchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc fun | cpp/io/c/getchar | reads a character from {{lc|stdin}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc gets</title>
    <ns>10</ns>
    <id>1506</id>
    <revision>
      <id>68828</id>
      <parentid>56280</parentid>
      <timestamp>2014-03-22T11:42:16Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ {{mark until c++14}}</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/io/c/gets | reads a character string from {{lc|stdin}}{{mark until c++14}}}}</text>
      <sha1>1b7idcajg3m172dg0nvjb4darl553az</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc getwchar</title>
    <ns>10</ns>
    <id>1507</id>
    <revision>
      <id>56282</id>
      <parentid>52851</parentid>
      <timestamp>2013-06-01T05:34:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list getwchar]] to [[Template:cpp/io/c/dsc getwchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/c/getwchar | reads a wide character from {{lc|stdin}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc perror</title>
    <ns>10</ns>
    <id>1508</id>
    <revision>
      <id>56284</id>
      <parentid>52852</parentid>
      <timestamp>2013-06-01T05:34:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list perror]] to [[Template:cpp/io/c/dsc perror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | cpp/io/c/perror | displays a character string corresponding of the current error to {{lc|stderr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc putchar</title>
    <ns>10</ns>
    <id>1509</id>
    <revision>
      <id>56287</id>
      <parentid>52853</parentid>
      <timestamp>2013-06-01T05:34:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list putchar]] to [[Template:cpp/io/c/dsc putchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | cpp/io/c/putchar |  writes a character to {{lc|stdout}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc puts</title>
    <ns>10</ns>
    <id>1510</id>
    <revision>
      <id>56289</id>
      <parentid>52854</parentid>
      <timestamp>2013-06-01T05:34:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list puts]] to [[Template:cpp/io/c/dsc puts]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/io/c/puts | writes a character string to {{lc|stdout}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc putwchar</title>
    <ns>10</ns>
    <id>1511</id>
    <revision>
      <id>56291</id>
      <parentid>52855</parentid>
      <timestamp>2013-06-01T05:34:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list putwchar]] to [[Template:cpp/io/c/dsc putwchar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/c/putwchar | writes a wide character to {{lc|stdout}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc remove</title>
    <ns>10</ns>
    <id>1512</id>
    <revision>
      <id>56293</id>
      <parentid>52856</parentid>
      <timestamp>2013-06-01T05:34:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list remove]] to [[Template:cpp/io/c/dsc remove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">{{dsc fun | cpp/io/c/remove | erases a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc rename</title>
    <ns>10</ns>
    <id>1513</id>
    <revision>
      <id>56295</id>
      <parentid>52857</parentid>
      <timestamp>2013-06-01T05:34:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list rename]] to [[Template:cpp/io/c/dsc rename]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">{{dsc fun | cpp/io/c/rename | renames a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc rewind</title>
    <ns>10</ns>
    <id>1514</id>
    <revision>
      <id>56297</id>
      <parentid>52858</parentid>
      <timestamp>2013-06-01T05:34:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list rewind]] to [[Template:cpp/io/c/dsc rewind]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/io/c/rewind | moves the file position indicator to the beginning in a file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc setbuf</title>
    <ns>10</ns>
    <id>1515</id>
    <revision>
      <id>56299</id>
      <parentid>52859</parentid>
      <timestamp>2013-06-01T05:34:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list setbuf]] to [[Template:cpp/io/c/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc fun | cpp/io/c/setbuf | sets the buffer for a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc setvbuf</title>
    <ns>10</ns>
    <id>1516</id>
    <revision>
      <id>56301</id>
      <parentid>52860</parentid>
      <timestamp>2013-06-01T05:34:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list setvbuf]] to [[Template:cpp/io/c/dsc setvbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | cpp/io/c/setvbuf | sets the buffer and its size for a file stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc tmpfile</title>
    <ns>10</ns>
    <id>1517</id>
    <revision>
      <id>56303</id>
      <parentid>52861</parentid>
      <timestamp>2013-06-01T05:34:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list tmpfile]] to [[Template:cpp/io/c/dsc tmpfile]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | cpp/io/c/tmpfile | creates and opens a temporary, auto-removing file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc tmpnam</title>
    <ns>10</ns>
    <id>1518</id>
    <revision>
      <id>56305</id>
      <parentid>52862</parentid>
      <timestamp>2013-06-01T05:34:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list tmpnam]] to [[Template:cpp/io/c/dsc tmpnam]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">{{dsc fun | cpp/io/c/tmpnam | returns a unique filename}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc ungetc</title>
    <ns>10</ns>
    <id>1519</id>
    <revision>
      <id>56307</id>
      <parentid>52863</parentid>
      <timestamp>2013-06-01T05:34:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list ungetc]] to [[Template:cpp/io/c/dsc ungetc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/io/c/ungetc | puts a character back into a file stream }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc ungetwc</title>
    <ns>10</ns>
    <id>1520</id>
    <revision>
      <id>56309</id>
      <parentid>52864</parentid>
      <timestamp>2013-06-01T05:34:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list ungetwc]] to [[Template:cpp/io/c/dsc ungetwc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | cpp/io/c/ungetwc | puts a wide character back into a file stream }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc vfprintf</title>
    <ns>10</ns>
    <id>1521</id>
    <revision>
      <id>56311</id>
      <parentid>52865</parentid>
      <timestamp>2013-06-01T05:34:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list vfprintf]] to [[Template:cpp/io/c/dsc vfprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="222">{{dsc fun | cpp/io/c/vfprintf | title=vprintf&lt;br&gt;vfprintf&lt;br&gt;vsprintf&lt;br&gt;vsnprintf | prints formatted output to {{lc|stdout}}, a file stream or a buffer&lt;br&gt; using variable argument list | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc vfscanf</title>
    <ns>10</ns>
    <id>1522</id>
    <revision>
      <id>56313</id>
      <parentid>52866</parentid>
      <timestamp>2013-06-01T05:34:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list vfscanf]] to [[Template:cpp/io/c/dsc vfscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="228">{{dsc fun | cpp/io/c/vfscanf | title=vscanf&lt;br&gt;vfscanf&lt;br&gt;vsscanf | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} | reads formatted input from {{lc|stdin}}, a file stream or a buffer&lt;br&gt; using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc vfwprintf</title>
    <ns>10</ns>
    <id>1523</id>
    <revision>
      <id>56315</id>
      <parentid>52867</parentid>
      <timestamp>2013-06-01T05:34:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list vfwprintf]] to [[Template:cpp/io/c/dsc vfwprintf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="193">{{dsc fun | cpp/io/c/vfwprintf | title=vwprintf&lt;br&gt;vfwprintf&lt;br&gt;vswprintf | prints formatted wide character output to {{lc|stdout}}, a file stream&lt;br&gt; or a buffer using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/dsc vfwscanf</title>
    <ns>10</ns>
    <id>1524</id>
    <revision>
      <id>56317</id>
      <parentid>52868</parentid>
      <timestamp>2013-06-01T05:34:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/c/dcl list vfwscanf]] to [[Template:cpp/io/c/dsc vfwscanf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="247">{{dsc fun | cpp/io/c/vfwscanf | title=vwscanf&lt;br&gt;vfwscanf&lt;br&gt;vswscanf | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} | reads formatted wide character input from {{lc|stdin}}, a file stream&lt;br&gt; or a buffer using variable argument list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/example1</title>
    <ns>10</ns>
    <id>9450</id>
    <revision>
      <id>40438</id>
      <parentid>40172</parentid>
      <timestamp>2012-10-14T09:52:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:template cpp/io/c/example1]] to [[Template:cpp/io/c/example1]]</comment>
      <text xml:space="preserve" bytes="547">{{example
 | 
 | code=
#include &lt;cstdio&gt;
#include &lt;cstdlib&gt;

int main()
{
    FILE* fp = std::fopen(&quot;test.txt&quot;, &quot;r&quot;);
    if(!fp) {
        std::perror(&quot;File opening failed&quot;);
        return EXIT_FAILURE;
    }

    int c; // note: int, not char, required to handle EOF
    while ((c = std::fgetc(fp)) != EOF) { // standard C I/O file reading loop
       std::putchar(c);
    }

    if (std::ferror(fp))
        std::puts(&quot;I/O error when reading&quot;);
    else if (std::feof(fp))
        std::puts(&quot;End of file reached successfully&quot;);
}
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/file access flags</title>
    <ns>10</ns>
    <id>1526</id>
    <revision>
      <id>72340</id>
      <parentid>46540</parentid>
      <timestamp>2014-08-13T14:00:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>slightly more correct about binary mode (not &quot;only&quot; on Windows, it's only an example)</comment>
      <text xml:space="preserve" bytes="1059">{| class=&quot;wikitable&quot;
|-
! File access &lt;br&gt;mode string
! Meaning
! Explanation
! Action if file &lt;br&gt; already exists
! Action if file &lt;br&gt; does not exist
|-
| {{tt|&quot;r&quot;}}
| read
| Open a file for reading
| read from start
| failure to open
|-
| {{tt|&quot;w&quot;}}
| write
| Create a file for writing
| destroy contents
| create new
|-
| {{tt|&quot;a&quot;}}
| append
| Append to a file
| write to end
| create new
|-
| {{tt|&quot;r+&quot;}}
| read extended
| Open a file for read/write
| read from start
| error
|-
| {{tt|&quot;w+&quot;}}
| write extended
| Create a file for read/write
| destroy contents
| create new
|-
| {{tt|&quot;a+&quot;}}
| append extended
| Open a file for read/write
| write to end
| create new
|-
| colspan=&quot;5&quot; | File access mode flag {{tt|&quot;b&quot;}} can optionally be specified to open a file in binary mode. This flag has no effect on POSIX systems, but on Windows, for example, it disables special handling of {{c|'\n'}} and {{c|'\x1A'}}. &lt;br&gt; On the append file access modes, data is written to the end of the file regardless of the current position of the file position indicator.
|}</text>
      <sha1>15ux0thpucf3b20sa5dkoop65g19sat</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/navbar</title>
    <ns>10</ns>
    <id>1529</id>
    <revision>
      <id>39922</id>
      <parentid>35683</parentid>
      <timestamp>2012-09-28T20:10:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="217">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/c/navbar heading
|content3 = cpp/io/c/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/navbar content</title>
    <ns>10</ns>
    <id>1530</id>
    <revision>
      <id>52869</id>
      <parentid>35684</parentid>
      <timestamp>2013-06-01T04:55:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2167">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | File access}}
{{nv col begin}}
{{nv ln | cpp/io/c/fopen}}
{{nv ln | cpp/io/c/freopen}}
{{nv ln | cpp/io/c/fclose}}
{{nv ln | cpp/io/c/fflush}}
{{nv col next}}
{{nv ln | cpp/io/c/fwide}}
{{nv ln | cpp/io/c/setbuf}}
{{nv ln | cpp/io/c/setvbuf}}
{{nv col end}}

{{nv h2 | Direct input/output}}
{{nv ln | cpp/io/c/fread}}
{{nv ln | cpp/io/c/fwrite}}

{{nv h2 | Unformatted input/output}}
{{nv col begin}}
{{nv ln | cpp/io/c/fgetc}}
{{nv ln | cpp/io/c/fgets}}
{{nv ln | cpp/io/c/fputc}}
{{nv ln | cpp/io/c/fputs}}
{{nv ln | cpp/io/c/getchar}}
{{nv ln | cpp/io/c/gets}}
{{nv ln | cpp/io/c/putchar}}
{{nv ln | cpp/io/c/puts}}
{{nv ln | cpp/io/c/ungetc}}
{{nv col next}}
{{nv ln | cpp/io/c/fgetwc}}
{{nv ln | cpp/io/c/fgetws}}
{{nv ln | cpp/io/c/fputwc}}
{{nv ln | cpp/io/c/fputws}}
{{nv ln | cpp/io/c/getwchar}}
{{nv ln | cpp/io/c/putwchar}}
{{nv ln | cpp/io/c/ungetwc}}
{{nv col end}}

{{nv h2 | Formatted input/output}}
{{nv col begin}}
{{nv ln | cpp/io/c/fscanf | scanf | fscanf | sscanf}}
{{nv ln | cpp/io/c/vfscanf | vscanf | vfscanf | vsscanf | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/io/c/fprintf | printf | fprintf | sprintf | snprintf | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/io/c/vfprintf | vprintf | vfprintf | vsprintf | vsnprintf  | notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/io/c/fwscanf | wscanf | fwscanf | swscanf}}
{{nv ln | cpp/io/c/vfwscanf | vwscanf | vfwscanf | vswscanf | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/io/c/fwprintf | wprintf | fwprintf | swprintf}}
{{nv ln | cpp/io/c/vfwprintf | vwprintf | vfwprintf | vswprintf}}
{{nv col end}}

{{nv h2 | File positioning}}
{{nv ln | cpp/io/c/ftell}}
{{nv ln | cpp/io/c/fgetpos}}
{{nv ln | cpp/io/c/fseek}}
{{nv ln | cpp/io/c/fsetpos}}
{{nv ln | cpp/io/c/rewind}}

{{nv h2 | Error handling}}
{{nv ln | cpp/io/c/clearerr}}
{{nv ln | cpp/io/c/feof}}
{{nv ln | cpp/io/c/ferror}}
{{nv ln | cpp/io/c/perror}}

{{nv h2 | Operations on files}}
{{nv ln | cpp/io/c/remove}}
{{nv ln | cpp/io/c/rename}}
{{nv ln | cpp/io/c/tmpfile}}
{{nv ln | cpp/io/c/tmpnam}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/navbar heading</title>
    <ns>10</ns>
    <id>1531</id>
    <revision>
      <id>40058</id>
      <parentid>35685</parentid>
      <timestamp>2012-09-28T20:52:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="27">[[ cpp/io/c | C-style I/O]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/printf format</title>
    <ns>10</ns>
    <id>1527</id>
    <revision>
      <id>72466</id>
      <parentid>72464</parentid>
      <timestamp>2014-08-23T16:59:29Z</timestamp>
      <contributor>
        <ip>77.35.56.56</ip>
      </contributor>
      <comment>For floating point types 'l' length specifier has no effect  and effect of 'll' is unspecified.</comment>
      <text xml:space="preserve" bytes="11445">The format string consists of ordinary characters (except {{ttb|%}}), which are copied unchanged into the output stream, and conversion specifications. Each conversion specification has the following format:

:* introductory {{ttb|%}} character

:* {{mark optional}} one or more flags that modify the behavior of the conversion:
::* {{ttb|-}}: the result of the conversion is left-justified within the field (by default it is right-justified)
::* {{ttb|+}}: the sign of signed conversions is always prepended to the result of the conversion (by default the result is preceded by minus only when it is negative)
::* ''space'': if the result of a signed conversion does not start with a sign character, or is empty, space is prepended to the result. It is ignored if {{tt|+}} flag is present.
::* {{ttb|#}} : ''alternative form'' of the conversion is performed. See the table below for exact effects.
::* {{ttb|0}} : for integer and floating point number conversions, leading zeros are used to pad the field instead of ''space'' characters. For floating point numbers it is ignored if the precision is explicitly specified. For other conversions using this flag results in undefined behavior. It is ignored if {{tt|-}} flag is present.

:* {{mark optional}} integer value or {{tt|*}} that specifies minimum field width. The result is padded with ''space'' characters (by default), if required, on the left when right-justified, or on the right if left-justified. In the case when {{tt|*}} is used, the width is specified by an additional argument of type {{c|int}}. If the value of the argument is negative, it results with the {{tt|-}} flag specified and positive field width.

:* {{mark optional}} {{ttb|.}} followed by integer number or {{ttb|*}} that specifies ''precision'' of the conversion. In the case when {{tt|*}} is used, the ''precision'' is specified by an additional argument of type {{c|int}}. If the value of this argument is negative, it is ignored. See the table below for exact effects of ''precision''.

:* {{mark optional}} ''length modifier'' that specifies the size of the argument

:* conversion format specifier

The following format specifiers are available:

{| class=&quot;wikitable&quot; style=&quot;text-align:center; font-size:85%; max-width:90em;&quot;
|-
! rowspan=1 | Conversion&lt;br&gt; specifier
! rowspan=1 | Explanation
! colspan=9 | Argument type
|-
! colspan=2 style=&quot;text-align:right; font-weight:normal;&quot; | length modifier
&lt;!-- --&gt;
! {{tt|hh}}
! {{tt|h}}
! style=&quot;font-weight:normal;&quot; | (none)
! {{ttb|l}}
! {{ttb|ll}}
! {{ttb|j}}
! {{ttb|z}}
! {{ttb|t}}
! {{ttb|L}}
|-
! {{tt|%}}
| style=&quot;text-align:left;&quot; | writes literal {{ttb|%}}. The full conversion specification must be {{ttb|%%}}.
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|-
! {{tt|c}}
| style=&quot;text-align:left;&quot; |
: writes a '''single character'''.
The argument is first converted to {{c|unsigned char}}.
If the '''l''' modifier is used, the argument is first converted to a character string as if by '''%ls''' with a {{c|wchar_t[2]}} argument.
| {{n/a}}
| {{n/a}}
| {{vertical|{{c|int}}}}
| {{vertical|{{c|wint_t}}}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|-
! {{tt|s}}
| style=&quot;text-align:left;&quot; | 
: writes a '''character string'''
The argument must be a pointer to the initial element of an array of characters. 
''Precision'' specifies the maximum number of bytes to be written. If ''Presition'' is not specified, writes every byte up to and not including the first null terminator.
If the '''l''' specifier is used, the argument must be a pointer to the initial element of an array of {{c|wchar_t}}, which is converted to char array as if by a call to {{lc|std::wcrtomb}} with zero-initialized conversion state.
| {{n/a}}
| {{n/a}}
| {{vertical|{{c|char*}}}}
| {{vertical|{{c|wchar_t*}}}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|-
! {{tt|d}}&lt;br&gt; {{tt|i}}
| style=&quot;text-align:left;&quot; | 
:converts a '''signed integer''' into decimal representation ''[-]dddd''.

''Precision'' specifies the minimum number of digits to appear. The default precision is {{c|1}}.&lt;br&gt; 
If both the converted value and the precision are {{c|0}} the conversion results in no characters.
| rowspan=1 | {{vertical|{{c|signed char}}}}
| rowspan=1 | {{vertical|{{c|short}}}}
| rowspan=1 | {{vertical|{{c|int}}}}
| rowspan=1 | {{vertical|{{c|long}}}}
| rowspan=1 | {{vertical|{{c|long long}}}}
| rowspan=1 | {{vertical|{{c|intmax_t}}}}
| rowspan=1 | {{vertical|signed {{c|size_t}}}}
| rowspan=1 | {{vertical|{{c|ptrdiff_t}}}}
| {{n/a}}
|-
! {{tt|o}}
| style=&quot;text-align:left;&quot; | 
:converts a '''unsigned integer''' into octal representation ''oooo''.

''Precision'' specifies the minimum number of digits to appear. The default precision is {{c|1}}. 
If both the converted value and the precision are {{c|0}} the conversion results in no characters.
In the ''alternative implementation'' precision is increased if necessary, to write one leading zero.
In that case if both the converted value and the precision are {{c|0}}, single {{c|0}} is written.
| rowspan=3 | {{vertical|{{c|unsigned char}}}}
| rowspan=3 | {{vertical|{{c|unsigned short}}}}
| rowspan=3 | {{vertical|{{c|unsigned int}}}}
| rowspan=3 | {{vertical|{{c|unsigned long}}}}
| rowspan=3 | {{vertical|{{c|unsigned long long}}}}
| rowspan=3 | {{vertical|{{c|uintmax_t}}}}
| rowspan=3 | {{vertical|{{c|size_t}}}}
| rowspan=3 | {{vertical|unsigned version of {{c|ptrdiff_t}}}}
| {{n/a}}
|-
! {{tt|x}}&lt;br&gt; {{tt|X}}
| style=&quot;text-align:left;&quot; | 
:converts an '''unsigned integer''' into hexadecimal representation ''hhhh''.

For the {{ttb|x}} conversion letters {{tt|abcdef}} are used.&lt;br&gt;
For the {{ttb|X}} conversion letters {{tt|ABCDEF}} are used.&lt;br&gt;
''Precision'' specifies the minimum number of digits to appear. The default precision is {{c|1}}.
If both the converted value and the precision are {{c|0}} the conversion results in no characters.
In the ''alternative implementation'' {{ttb|0x}} or {{ttb|0X}} is prefixed to results if the converted value is nonzero.
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
| {{n/a}}
|-
! {{tt|u}}
| style=&quot;text-align:left;&quot; | 
:converts an '''unsigned integer''' into decimal representation ''dddd''.

''Precision'' specifies the minimum number of digits to appear. 
The default precision is {{c|1}}. 
If both the converted value and the precision are {{c|0}} the conversion results in no characters.
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
| {{n/a}}
|-
! {{tt|f}}&lt;br&gt; {{tt|F}}
| style=&quot;text-align:left;&quot; | 
:converts '''floating-point number''' to the decimal notation in the style ''[-]ddd.ddd''.

''Precision'' specifies the minimum number of digits to appear after the decimal point character. 
The default precision is {{c|6}}.
In the ''alternative implementation'' decimal point character is written even if no digits follow it.
For infinity and not-a-number conversion style see notes.
| {{n/a}}
| {{n/a}}
| rowspan=4 | {{vertical|{{c|double}}}}
| rowspan=4 | {{vertical|no effect}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| rowspan=4 | {{vertical|{{c|long double}}}}
|-
! {{tt|e}} &lt;br&gt; {{tt|E}}
| style=&quot;text-align:left;&quot; | 
:converts '''floating-point number''' to the decimal exponent notation.

For the {{ttb|e}} conversion style ''[-]d.ddd''{{ttb|e}}''±dd'' is used.&lt;br&gt;
For the {{ttb|E}} conversion style ''[-]d.ddd''{{ttb|E}}''±dd'' is used.&lt;br&gt;
The exponent contains at least two digits, more digits are used only if necessary. 
If the value is {{c|0}}, the exponent is also {{c|0}}.
''Precision'' specifies the minimum number of digits to appear after the decimal point character.
The default precision is {{c|6}}.
In the ''alternative implementation'' decimal point character is written even if no digits follow it.
For infinity and not-a-number conversion style see notes.
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
&lt;!-- --&gt;
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
|-
! {{tt|a}} &lt;br&gt; {{tt|A}}
| style=&quot;text-align:left;&quot; | 
:converts '''floating-point number''' to the hexadecimal exponent notation.

For the {{ttb|a}} conversion style ''[-]''{{ttb|0x}}''h.hhh''{{ttb|p}}''±d'' is used.&lt;br&gt;
For the {{ttb|A}} conversion style ''[-]''{{ttb|0X}}''h.hhh''{{ttb|P}}''±d'' is used.&lt;br&gt;
The first hexadecimal digit is {{tt|0}} if the argument is not a normalized floating point value.
If the value is {{c|0}}, the exponent is also {{c|0}}.
''Precision'' specifies the minimum number of digits to appear after the decimal point character.
The default precision is sufficient for exact representation of the value.
In the ''alternative implementation'' decimal point character is written even if no digits follow it.
For infinity and not-a-number conversion style see notes.
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
&lt;!-- --&gt;
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
|-
! {{tt|g}} &lt;br&gt; {{tt|G}}
| style=&quot;text-align:left;&quot; | 
:converts '''floating-point number''' to decimal or decimal exponent notation depending on the value and the ''precision''.

For the {{ttb|g}} conversion style conversion with style {{ttb|e}} or {{ttb|f}} will be performed.&lt;br&gt;
For the {{ttb|G}} conversion style conversion with style {{ttb|E}} or {{ttb|F}} will be performed.&lt;br&gt;
Let {{tt|P}} equal the precision if nonzero, {{c|6}} if the precision is not specified, or {{c|1}} if the precision is {{c|0}}. Then, if a conversion with style {{tt|E}} would have an exponent of {{tt|X}}:

* if ''P &gt; X ≥ −4'', the conversion is with style {{ttb|f}} or {{ttb|F}} and precision ''P − 1 − X''.
* otherwise, the conversion is with style {{ttb|e}} or {{ttb|E}} and precision ''P − 1''.

Unless ''alternative representation'' is requested the trailing zeros are removed, also the decimal point character is removed if no fractional part is left.
For infinity and not-a-number conversion style see notes.
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
&lt;!-- --&gt;
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
&lt;!-- --&gt;
|-
! {{tt|n}}
| style=&quot;text-align:left;&quot; | 
:returns the '''number of characters written''' so far by this call to the function.

The result is ''written'' to the value pointed to by the argument. 
The complete specification must be {{ttb|%n}}.
| {{vertical|{{c|signed char*}}}}
| {{vertical|{{c|short*}}}}
| {{vertical|{{c|int*}}}}
| {{vertical|{{c|long*}}}}
| {{vertical|{{c|long long*}}}}
| {{vertical|{{c|intmax_t*}}}}
| {{vertical|signed {{c|size_t*}}}}
| {{vertical|{{c|ptrdiff_t*}}}}
| {{n/a}}

|-
! {{tt|p}}
| style=&quot;text-align:left;&quot; | writes an implementation defined character sequence defining a '''pointer'''. 
| {{n/a}}
| {{n/a}}
| {{c|void*}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|-
| colspan=11 style=&quot;text-align:left;&quot; |
:'''Notes''':

The floating point conversion functions convert infinity to {{tt|inf}} or {{tt|infinity}}. Which one is used is implementation defined.&lt;br&gt;
Not-a-number is converted to {{tt|nan}} or {{tt|nan(''char_sequence'')}}. Which one is used is implementation defined.&lt;br&gt;
The conversions {{ttb|F}}, {{ttb|E}}, {{ttb|G}}, {{ttb|A}} output {{tt|INF}}, {{tt|INFINITY}}, {{tt|NAN}} instead.&lt;br&gt;
Even though {{tt|%c}} expects {{tt|int}} argument, it is safe to pass a {{tt|char}} because of the integer promotion that takes place when a variadic function is called&lt;br&gt;
The correct conversion specifiers for the fixed-width character types ({{lc|std::int8_t}}, etc) are defined in the header [[cpp/types/integer|&lt;cinttypes&gt;]]
|}</text>
      <sha1>nqwyfp9omta6qjr1qhemo1e6clbvrmm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/c/scanf format</title>
    <ns>10</ns>
    <id>1528</id>
    <revision>
      <id>70461</id>
      <parentid>66818</parentid>
      <timestamp>2014-05-23T11:47:33Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="6638">The format string consists of whitespace characters (any single whitespace character in the format string consumes all available consecutive whitespace characters from the input), non-whitespace characters except {{ttb|%}} (each such character in the format string consumes exactly one identical character from the input) and conversion specifications. Each conversion specification has the following format:

:* introductory {{ttb|%}} character

:* {{mark optional}} assignment-suppressing character {{ttb|*}}. If this option is present, the function does not assign the result of the conversion to any receiving argument.

:* {{mark optional}} integer number (greater than zero) that specifies ''maximum field width'', that is, the maximum number of characters that the function is allowed to consume when doing the conversion specified by the current conversion specification. Note that %s and %[ may lead to buffer overflow if the width is not provided.

:* {{mark optional}} ''length modifier'' that specifies the size of the receiving argument, that is, the actual destination type. This affects the conversion accuracy and overflow rules. The default destination type is different for each conversion type (see table below).

:* conversion format specifier

The following format specifiers are available:

{| class=&quot;wikitable&quot; style=&quot;text-align:center; font-size:85%; max-width:90em;&quot;
|-
! rowspan=1 | Conversion&lt;br&gt; specifier
! rowspan=1 | Explanation
! colspan=9 | Argument type
|-
! colspan=2 style=&quot;text-align:right; font-weight:normal;&quot; | length modifier
&lt;!-- --&gt;
! {{tt|hh}}
! {{tt|h}}
! style=&quot;font-weight:normal;&quot; | (none)
! {{ttb|l}}
! {{ttb|ll}}
! {{ttb|j}}
! {{ttb|z}}
! {{ttb|t}}
! {{ttb|L}}
|-
! {{tt|%}}
| style=&quot;text-align:left;&quot; | matches literal {{ttb|%}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|-
! {{tt|c}}
| style=&quot;text-align:left;&quot; | matches a '''single character'''
| rowspan=3 {{n/a}}
| rowspan=3 {{n/a}}
| rowspan=3 | {{vertical|{{c|char*}}}}
| rowspan=3 | {{vertical|{{c|wchar_t*}}}}
| rowspan=3 {{n/a}}
| rowspan=3 {{n/a}}
| rowspan=3 {{n/a}}
| rowspan=3 {{n/a}}
| rowspan=3 {{n/a}}
|-
! {{tt|s}}
| style=&quot;text-align:left;&quot; | matches a '''character string''' (a sequence of non-whitespace characters)
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|[}}{{spar|set}}{{tt|]}}
| style=&quot;text-align:left;&quot; | 
:matches a non-empty sequence of character from {{spar|set}} of characters.

If the first character of the set is {{tt|^}}, then all characters not in the set are matched. If the set begins with {{tt|]}} or {{tt|^]}} then the {{tt|]}} character is also included into the set.
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|d}}  
| style=&quot;text-align:left;&quot; |
:matches a '''decimal integer'''.

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtol}} with the value {{c|10}} for the {{tt|base}} argument
| rowspan=6 | {{vertical|{{c|signed char*}} or {{c|unsigned char*}}}}
| rowspan=6 | {{vertical|{{c|signed short*}} or {{c|unsigned short*}}}}
| rowspan=6 | {{vertical|{{c|signed int*}} or {{c|unsigned int*}}}}
| rowspan=6 | {{vertical|{{c|signed long*}} or {{c|unsigned long*}}}}
| rowspan=6 | {{vertical|{{c|signed long long*}} or {{c|unsigned long long*}}}}
| rowspan=6 | {{vertical|{{c|intmax_t*}} or {{c|uintmax_t*}}}}
| rowspan=6 | {{vertical|{{c|size_t*}}}}
| rowspan=6 | {{vertical|{{c|ptrdiff_t*}}}}
| rowspan=6 {{n/a}}
|-
! {{tt|i}}
| style=&quot;text-align:left;&quot; |
:matches a '''decimal integer'''.

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtol}} with the value {{c|0}} for the {{tt|base}} argument 
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|u}}
| style=&quot;text-align:left;&quot; |
:matches a '''unsigned decimal integer'''. 

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtoul}} with the value {{c|0}} for the {{tt|base}} argument
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|o}}
| style=&quot;text-align:left;&quot; | 
:matches an '''octal integer'''.

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtol}} with the value {{c|8}} for the {{tt|base}} argument
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|x}}
| style=&quot;text-align:left;&quot; | 
:matches an '''hexadecimal integer'''.

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtol}} with the value {{c|16}} for the {{tt|base}} argument
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|n}}
| style=&quot;text-align:left;&quot; |
:returns the '''number of characters read so far'''.

No input is consumed. Does not increment the assignment count. If the specifier has assignment-suppressing operator defined, the behavior is undefined
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
&lt;!-- --&gt;
|-
! {{tt|a}}, {{tt|A}}&lt;br&gt; {{tt|e}}, {{tt|E}}&lt;br&gt; {{tt|f}}, {{tt|F}}&lt;br&gt; {{tt|g}}, {{tt|G}}
| style=&quot;text-align:left;&quot; | 
:matches a '''floating-point number'''.

The format of the number is the same as expected by {{ltf|cpp/string/byte/strtof}}
| {{n/a}}
| {{n/a}}
| {{vertical|{{c|float*}}}}
| {{vertical|{{c|double*}}}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{vertical|{{c|long double*}}}}
|-
! {{tt|p}}
| style=&quot;text-align:left;&quot; | 
:matches implementation defined character sequence defining a '''pointer'''.

{{tt|printf}} family of functions should produce the same sequence using {{ttb|%p}} format specifier
| {{n/a}}
| {{n/a}}
| {{vertical|{{c|void**}}}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
| {{n/a}}
|}
All conversion specifiers other than {{tt|[}}, {{tt|c}}, and {{tt|n}} consume and discard all leading whitespace characters before attempting to parse the input. These consumed characters do not count towards the specified maximum field width.

The conversion specifiers {{tt|lc}}, {{tt|ls}}, and {{tt|l[}} perform multibyte-to-wide character conversion as if by calling {{lc|mbrtowc}} with an {{lc|mbstate_t}} object initialized to zero before the first character is converted.

The conversion specifiers {{tt|s}} and {{tt|[}} always store the null terminator in addition to the matched characters. The size of the destination array must be at least one greater than the specified field width.

The correct conversion specifications for the fixed-width character types ({{lc|int8_t}}, etc) are defined in the header [[cpp/types/integer|&lt;cinttypes&gt;]].</text>
      <sha1>lefq4tg03z75ng4v6hfi1rpzc35dl5o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc allocator type</title>
    <ns>10</ns>
    <id>1572</id>
    <revision>
      <id>56319</id>
      <parentid>52871</parentid>
      <timestamp>2013-06-01T05:34:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list allocator type]] to [[Template:cpp/io/dsc allocator type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc | {{tt|allocator_type}} | {{c|Allocator}} {{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc cerr</title>
    <ns>10</ns>
    <id>4281</id>
    <revision>
      <id>56321</id>
      <parentid>52872</parentid>
      <timestamp>2013-06-01T05:34:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list cerr]] to [[Template:cpp/io/dsc cerr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc | {{dsc member | cpp/io/cerr | cerr&lt;br&gt;wcerr }} | writes to the standard C error stream {{lc|stderr}}, unbuffered&lt;br&gt;{{mark|global object}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc char type</title>
    <ns>10</ns>
    <id>1573</id>
    <revision>
      <id>56323</id>
      <parentid>52873</parentid>
      <timestamp>2013-06-01T05:34:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list char type]] to [[Template:cpp/io/dsc char type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="40">{{dsc | {{tt|char_type}} | {{c|CharT}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc cin</title>
    <ns>10</ns>
    <id>4279</id>
    <revision>
      <id>56325</id>
      <parentid>52874</parentid>
      <timestamp>2013-06-01T05:34:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list cin]] to [[Template:cpp/io/dsc cin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc | {{dsc member | cpp/io/cin | cin&lt;br&gt;wcin }} | reads from the standard C input stream {{lc|stdin}} &lt;br&gt;{{mark|global object}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc clog</title>
    <ns>10</ns>
    <id>4282</id>
    <revision>
      <id>56327</id>
      <parentid>52875</parentid>
      <timestamp>2013-06-01T05:34:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list clog]] to [[Template:cpp/io/dsc clog]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc | {{dsc member | cpp/io/clog | clog&lt;br&gt;wclog }} | writes to the standard C error stream {{lc|stderr}}&lt;br&gt;{{mark|global object}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc cout</title>
    <ns>10</ns>
    <id>4280</id>
    <revision>
      <id>56329</id>
      <parentid>52876</parentid>
      <timestamp>2013-06-01T05:34:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list cout]] to [[Template:cpp/io/dsc cout]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc | {{dsc member | cpp/io/cout | cout&lt;br&gt;wcout }} | writes to the standard C output stream {{lc|stdout}}&lt;br&gt;{{mark|global object}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc int type</title>
    <ns>10</ns>
    <id>1574</id>
    <revision>
      <id>56331</id>
      <parentid>52877</parentid>
      <timestamp>2013-06-01T05:34:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list int type]] to [[Template:cpp/io/dsc int type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">{{dsc | {{tt|int_type}} | {{c|Traits::int_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc io errc</title>
    <ns>10</ns>
    <id>4771</id>
    <revision>
      <id>56333</id>
      <parentid>52878</parentid>
      <timestamp>2013-06-01T05:34:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list io errc]] to [[Template:cpp/io/dsc io errc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc enum | cpp/io/io_errc  | notes={{mark c++11}} | the IO stream error codes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc iostream category</title>
    <ns>10</ns>
    <id>4772</id>
    <revision>
      <id>56335</id>
      <parentid>52879</parentid>
      <timestamp>2013-06-01T05:34:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list iostream category]] to [[Template:cpp/io/dsc iostream category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/io/iostream_category  | notes={{mark c++11}} | identifies the iostream error category}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc off type</title>
    <ns>10</ns>
    <id>1575</id>
    <revision>
      <id>56337</id>
      <parentid>52880</parentid>
      <timestamp>2013-06-01T05:35:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list off type]] to [[Template:cpp/io/dsc off type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">{{dsc | {{tt|off_type}} | {{c|Traits::off_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc pos type</title>
    <ns>10</ns>
    <id>1576</id>
    <revision>
      <id>56341</id>
      <parentid>52881</parentid>
      <timestamp>2013-06-01T05:35:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list pos type]] to [[Template:cpp/io/dsc pos type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">{{dsc | {{tt|pos_type}} | {{c|Traits::pos_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/dsc traits type</title>
    <ns>10</ns>
    <id>1577</id>
    <revision>
      <id>56345</id>
      <parentid>52882</parentid>
      <timestamp>2013-06-01T05:35:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/dcl list traits type]] to [[Template:cpp/io/dsc traits type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">{{dsc | {{tt|traits_type}} | {{c|Traits}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/fpos/navbar</title>
    <ns>10</ns>
    <id>9648</id>
    <revision>
      <id>44949</id>
      <timestamp>2012-12-05T15:43:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="223">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/fpos/navbar heading
|content3 = cpp/io/fpos/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/fpos/navbar content</title>
    <ns>10</ns>
    <id>9650</id>
    <revision>
      <id>52883</id>
      <parentid>44951</parentid>
      <timestamp>2013-06-01T04:55:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="86">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/fpos/state}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/fpos/navbar heading</title>
    <ns>10</ns>
    <id>9649</id>
    <revision>
      <id>44950</id>
      <timestamp>2012-12-05T15:44:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="33">{{ltt | cpp/io/fpos | std::fpos}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/fpos/title</title>
    <ns>10</ns>
    <id>9647</id>
    <revision>
      <id>44948</id>
      <timestamp>2012-12-05T15:42:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="101">&lt;onlyinclude&gt;{{cpp/title | n=fpos::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/dsc is error code enum</title>
    <ns>10</ns>
    <id>12642</id>
    <revision>
      <id>61380</id>
      <timestamp>2013-06-05T22:30:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="217">{{dsc tclass | cpp/io/io_errc/is_error_code_enum  | title=is_error_code_enum{{dsc small|&lt;std::io_errc&gt;}}| notes={{mark c++11}} | extends the type trait {{lc|std::is_error_code_enum}} to identify iostream error codes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/dsc make error code</title>
    <ns>10</ns>
    <id>12640</id>
    <revision>
      <id>61378</id>
      <timestamp>2013-06-05T22:30:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="155">{{dsc fun | cpp/io/io_errc/make_error_code | title=make_error_code{{dsc small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/dsc make error condition</title>
    <ns>10</ns>
    <id>12641</id>
    <revision>
      <id>61379</id>
      <timestamp>2013-06-05T22:30:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="171">{{dsc fun | cpp/io/io_errc/make_error_condition  | title=make_error_condition{{dsc small|(std::io_errc)}} | notes={{mark c++11}} | constructs an iostream error_condition}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/navbar</title>
    <ns>10</ns>
    <id>4789</id>
    <revision>
      <id>39923</id>
      <parentid>35686</parentid>
      <timestamp>2012-09-28T20:10:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/io_errc/navbar heading
|content3 = cpp/io/io_errc/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/navbar content</title>
    <ns>10</ns>
    <id>4791</id>
    <revision>
      <id>61382</id>
      <parentid>52884</parentid>
      <timestamp>2013-06-05T22:31:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>reorder</comment>
      <text xml:space="preserve" bytes="370">{{nv begin}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/io/io_errc/make_error_code | make_error_code{{dsc small|(std::io_errc)}} }}
{{nv ln | cpp/io/io_errc/make_error_condition | make_error_condition{{dsc small|(std::io_errc)}} }}

{{nv h1 | Helper classes}}
{{nv ln | cpp/io/io_errc/is_error_code_enum | is_error_code_enum{{dsc small|&lt;std::io_errc&gt;}} }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/io errc/navbar heading</title>
    <ns>10</ns>
    <id>4790</id>
    <revision>
      <id>35006</id>
      <parentid>17387</parentid>
      <timestamp>2012-06-15T22:16:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/io errc/sidebar heading]] to [[Template:cpp/io/io errc/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="39">{{ltt | cpp/io/io_errc | std::io_errc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc Init</title>
    <ns>10</ns>
    <id>1532</id>
    <revision>
      <id>56349</id>
      <parentid>52885</parentid>
      <timestamp>2013-06-01T05:35:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list Init]] to [[Template:cpp/io/ios base/dsc Init]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem class | cpp/io/ios_base/Init | initializes standard stream objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc constructor</title>
    <ns>10</ns>
    <id>1533</id>
    <revision>
      <id>56353</id>
      <parentid>52886</parentid>
      <timestamp>2013-06-01T05:35:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list constructor]] to [[Template:cpp/io/ios base/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc prot mem ctor | cpp/io/ios_base/ios_base | constructs the object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc destructor</title>
    <ns>10</ns>
    <id>1534</id>
    <revision>
      <id>56358</id>
      <parentid>52887</parentid>
      <timestamp>2013-06-01T05:35:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list destructor]] to [[Template:cpp/io/ios base/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem vdtor | cpp/io/ios_base/~ios_base | destructs the object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc event</title>
    <ns>10</ns>
    <id>1562</id>
    <revision>
      <id>56363</id>
      <parentid>52888</parentid>
      <timestamp>2013-06-01T05:35:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list event]] to [[Template:cpp/io/ios base/dsc event]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">{{dsc enum | cpp/io/ios_base/event | specifies event type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc event callback</title>
    <ns>10</ns>
    <id>1563</id>
    <revision>
      <id>56367</id>
      <parentid>52889</parentid>
      <timestamp>2013-06-01T05:35:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list event callback]] to [[Template:cpp/io/ios base/dsc event callback]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc typedef | cpp/io/ios_base/event_callback | callback function type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc failure</title>
    <ns>10</ns>
    <id>1535</id>
    <revision>
      <id>56371</id>
      <parentid>52890</parentid>
      <timestamp>2013-06-01T05:35:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list failure]] to [[Template:cpp/io/ios base/dsc failure]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc mem class | cpp/io/ios_base/failure | stream exception }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc flags</title>
    <ns>10</ns>
    <id>1536</id>
    <revision>
      <id>56375</id>
      <parentid>52891</parentid>
      <timestamp>2013-06-01T05:35:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list flags]] to [[Template:cpp/io/ios base/dsc flags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc mem fun | cpp/io/ios_base/flags | manages format flags }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc fmtflags</title>
    <ns>10</ns>
    <id>1564</id>
    <revision>
      <id>56379</id>
      <parentid>52892</parentid>
      <timestamp>2013-06-01T05:35:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list fmtflags]] to [[Template:cpp/io/ios base/dsc fmtflags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc typedef | cpp/io/ios_base/fmtflags | formatting flags type

The following constants are also defined:
{{cpp/io/ios_base/fmtflags consts}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc getloc</title>
    <ns>10</ns>
    <id>1537</id>
    <revision>
      <id>56383</id>
      <parentid>52893</parentid>
      <timestamp>2013-06-01T05:35:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list getloc]] to [[Template:cpp/io/ios base/dsc getloc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/io/ios_base/getloc | returns current locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc imbue</title>
    <ns>10</ns>
    <id>1538</id>
    <revision>
      <id>56387</id>
      <parentid>52894</parentid>
      <timestamp>2013-06-01T05:35:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list imbue]] to [[Template:cpp/io/ios base/dsc imbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">{{dsc mem fun | cpp/io/ios_base/imbue | sets locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc iostate</title>
    <ns>10</ns>
    <id>1565</id>
    <revision>
      <id>56391</id>
      <parentid>52895</parentid>
      <timestamp>2013-06-01T05:35:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list iostate]] to [[Template:cpp/io/ios base/dsc iostate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc typedef | cpp/io/ios_base/iostate | state of the stream type

The following constants are also defined:
{{cpp/io/ios_base/iostate consts}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc iword</title>
    <ns>10</ns>
    <id>1539</id>
    <revision>
      <id>56396</id>
      <parentid>52896</parentid>
      <timestamp>2013-06-01T05:35:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list iword]] to [[Template:cpp/io/ios base/dsc iword]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc mem fun | cpp/io/ios_base/iword | resizes the private storage if necessary and access to the {{c|long}} element at the given index}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc openmode</title>
    <ns>10</ns>
    <id>1566</id>
    <revision>
      <id>56400</id>
      <parentid>52897</parentid>
      <timestamp>2013-06-01T05:35:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list openmode]] to [[Template:cpp/io/ios base/dsc openmode]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc typedef | cpp/io/ios_base/openmode | stream open mode type

The following constants are also defined:
{{cpp/io/ios_base/openmode consts}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc precision</title>
    <ns>10</ns>
    <id>1540</id>
    <revision>
      <id>56405</id>
      <parentid>52898</parentid>
      <timestamp>2013-06-01T05:35:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list precision]] to [[Template:cpp/io/ios base/dsc precision]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/io/ios_base/precision | manages decimal precision of floating point operations }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc pword</title>
    <ns>10</ns>
    <id>1541</id>
    <revision>
      <id>56409</id>
      <parentid>52899</parentid>
      <timestamp>2013-06-01T05:35:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list pword]] to [[Template:cpp/io/ios base/dsc pword]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/io/ios_base/pword | resizes the private storage if necessary and access to the {{c|void*}} element at the given index}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc register callback</title>
    <ns>10</ns>
    <id>1542</id>
    <revision>
      <id>56413</id>
      <parentid>52900</parentid>
      <timestamp>2013-06-01T05:35:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list register callback]] to [[Template:cpp/io/ios base/dsc register callback]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/io/ios_base/register_callback | registers event callback function }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc seekdir</title>
    <ns>10</ns>
    <id>1567</id>
    <revision>
      <id>56417</id>
      <parentid>52901</parentid>
      <timestamp>2013-06-01T05:35:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list seekdir]] to [[Template:cpp/io/ios base/dsc seekdir]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc typedef | cpp/io/ios_base/seekdir | seeking direction type

The following constants are also defined:
{{cpp/io/ios_base/seekdir consts}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc setf</title>
    <ns>10</ns>
    <id>1543</id>
    <revision>
      <id>56422</id>
      <parentid>52902</parentid>
      <timestamp>2013-06-01T05:35:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list setf]] to [[Template:cpp/io/ios base/dsc setf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/io/ios_base/setf | mem={{{mem|}}} | sets specific format flag }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc sync with stdio</title>
    <ns>10</ns>
    <id>1544</id>
    <revision>
      <id>56427</id>
      <parentid>52903</parentid>
      <timestamp>2013-06-01T05:36:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list sync with stdio]] to [[Template:cpp/io/ios base/dsc sync with stdio]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem sfun | cpp/io/ios_base/sync_with_stdio | sets whether C++ and C IO libraries are interoperable }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc unsetf</title>
    <ns>10</ns>
    <id>1545</id>
    <revision>
      <id>56432</id>
      <parentid>52904</parentid>
      <timestamp>2013-06-01T05:36:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list unsetf]] to [[Template:cpp/io/ios base/dsc unsetf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/io/ios_base/unsetf | clears specific format flag }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc width</title>
    <ns>10</ns>
    <id>1546</id>
    <revision>
      <id>56436</id>
      <parentid>52905</parentid>
      <timestamp>2013-06-01T05:36:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list width]] to [[Template:cpp/io/ios base/dsc width]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/io/ios_base/width | manages field width|mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/dsc xalloc</title>
    <ns>10</ns>
    <id>1547</id>
    <revision>
      <id>56441</id>
      <parentid>52906</parentid>
      <timestamp>2013-06-01T05:36:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/dcl list xalloc]] to [[Template:cpp/io/ios base/dsc xalloc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc mem sfun | cpp/io/ios_base/xalloc | returns a program-wide unique integer that is safe to use as index to pword() and iword() }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/failure/dsc constructor</title>
    <ns>10</ns>
    <id>1548</id>
    <revision>
      <id>62097</id>
      <parentid>56445</parentid>
      <timestamp>2013-06-22T02:02:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>inlinemem=true</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem ctor | cpp/io/ios_base/failure | inlinemem=true | constructs the exception object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/failure/navbar</title>
    <ns>10</ns>
    <id>1551</id>
    <revision>
      <id>39924</id>
      <parentid>35688</parentid>
      <timestamp>2012-09-28T20:10:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/ios_base/failure/navbar heading
|content3 = cpp/io/ios_base/failure/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/failure/navbar content</title>
    <ns>10</ns>
    <id>1552</id>
    <revision>
      <id>52908</id>
      <parentid>35689</parentid>
      <timestamp>2013-06-01T04:55:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="100">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/ios_base/failure/failure}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/failure/navbar heading</title>
    <ns>10</ns>
    <id>1553</id>
    <revision>
      <id>37262</id>
      <parentid>35690</parentid>
      <timestamp>2012-07-03T17:35:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="49">{{ltt|cpp/io/ios_base/failure|ios_base::failure}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/failure/title</title>
    <ns>10</ns>
    <id>2788</id>
    <revision>
      <id>10608</id>
      <parentid>10607</parentid>
      <timestamp>2011-09-18T22:45:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/io/ios_base/title | n=failure::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/fmtflags consts</title>
    <ns>10</ns>
    <id>1554</id>
    <revision>
      <id>70864</id>
      <parentid>70863</parentid>
      <timestamp>2014-05-31T12:25:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>manipulator pages have more info: linking each manipulator page from fmtflag line</comment>
      <text xml:space="preserve" bytes="2616">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|dec}} | use decimal base for integer I/O: see {{lc|std::dec}}}}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|oct}} | use octal base for integer I/O: see {{lc|std::oct}}}}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|hex}} | use hexadecimal base for integer I/O: see {{lc|std::hex}}}}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|basefield}} | {{c|dec{{!}}oct{{!}}hex{{!}}0}}. Useful for masking operations}}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|left}} |  left adjustment (adds fill characters to the right): see {{lc|std::left}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|right}} | right adjustment (adds fill characters to the left): see {{lc|std::right}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|internal}} | internal adjustment (adds fill characters to the internal designated point): see {{lc|std::internal}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|adjustfield}} | {{c|left{{!}}right{{!}}internal}}. Useful for masking operations }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|scientific}} |  generate floating point types using scientific notation, or hex notation if combined with fixed: see {{lc|std::scientific}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|fixed}} | generate floating point types using fixed notation, or hex notation if combined with scientific: see {{lc|std::fixed}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|floatfield}} | {{c|scientific{{!}}fixed{{!}}(scientific{{!}}fixed){{!}}0}}. Useful for masking operations }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|boolalpha}} |  insert and extract {{c|bool}} type in alphanumeric format: see {{lc|std::boolalpha}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|showbase}} | generate a prefix indicating the numeric base for integer output, require the currency indicator in monetary I/O: see {{lc|std::showbase}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|showpoint}} | generate a decimal-point character unconditionally for floating-point number output: see {{lc|std::showpoint}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|showpos}} | generate a {{c|+}} character for non-negative numeric output: see {{lc|std::showpos}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|skipws}} | skip leading whitespace before certain input operations: see {{lc|std::skipws}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|unitbuf}} | flush the output after each output operation: see {{lc|std::unitbuf}} }}
{{dsc | {{ltt|cpp/io/ios_base/fmtflags|uppercase}} | replace certain lowercase letters with their uppercase&lt;br&gt;equivalents in certain output output operations: see {{lc|std::uppercase}} }}
{{dsc end}}</text>
      <sha1>opx1u3wzja6bxlfsxw7majhqpjzs88s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/inherit</title>
    <ns>10</ns>
    <id>1555</id>
    <revision>
      <id>60883</id>
      <parentid>52910</parentid>
      <timestamp>2013-06-01T11:59:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1207">{{inherited | [[cpp/io/ios_base | {{small|std::}}ios_base]] |
===Member functions===
{{dsc begin}}

{{dsc h2 | Formatting}}
{{dsc inc | cpp/io/ios_base/dsc flags}}
{{dsc inc | cpp/io/ios_base/dsc setf}}
{{dsc inc | cpp/io/ios_base/dsc unsetf}}
{{dsc inc | cpp/io/ios_base/dsc precision}}
{{dsc inc | cpp/io/ios_base/dsc width}}

{{dsc h2 | Locales}}
{{dsc inc | cpp/io/ios_base/dsc imbue}}
{{dsc inc | cpp/io/ios_base/dsc getloc}}

{{dsc h2 | Internal extensible array}}
{{dsc inc | cpp/io/ios_base/dsc xalloc}}
{{dsc inc | cpp/io/ios_base/dsc iword}}
{{dsc inc | cpp/io/ios_base/dsc pword}}

{{dsc h2 | Miscellaneous}}
{{dsc inc | cpp/io/ios_base/dsc register_callback}}
{{dsc inc | cpp/io/ios_base/dsc sync_with_stdio}}

{{dsc h2 | Member classes}}
{{dsc inc | cpp/io/ios_base/dsc failure}}
{{dsc inc | cpp/io/ios_base/dsc Init}}
{{dsc end}}

{{dsc begin}}
{{dsc h1 | Member types and constants}}
{{dsc hitem | Type | Explanation}}
{{dsc inc | cpp/io/ios_base/dsc openmode}}
{{dsc inc | cpp/io/ios_base/dsc fmtflags}}
{{dsc inc | cpp/io/ios_base/dsc iostate}}
{{dsc inc | cpp/io/ios_base/dsc seekdir}}
{{dsc inc | cpp/io/ios_base/dsc event}}
{{dsc inc | cpp/io/ios_base/dsc event_callback}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/iostate consts</title>
    <ns>10</ns>
    <id>1556</id>
    <revision>
      <id>52911</id>
      <parentid>36510</parentid>
      <timestamp>2013-06-01T04:56:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="423">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{ltt|cpp/io/ios_base/iostate|goodbit}} | no error }}
{{dsc | {{ltt|cpp/io/ios_base/iostate|badbit}} | irrecoverable stream error }}
{{dsc | {{ltt|cpp/io/ios_base/iostate|failbit}} | input/output operation failed (formatting or extraction error) }}
{{dsc | {{ltt|cpp/io/ios_base/iostate|eofbit}} | associated input sequence has reached end-of-file }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/navbar</title>
    <ns>10</ns>
    <id>1559</id>
    <revision>
      <id>39925</id>
      <parentid>35692</parentid>
      <timestamp>2012-09-28T20:10:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="231">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/ios_base/navbar heading
|content3 = cpp/io/ios_base/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/navbar content</title>
    <ns>10</ns>
    <id>1560</id>
    <revision>
      <id>52912</id>
      <parentid>35693</parentid>
      <timestamp>2013-06-01T04:56:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1108">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/ios_base/ios_base}}
{{nv mem ln | cpp/io/ios_base/~ios_base}}

{{nv h2 | Formatting}}
{{nv mem ln | cpp/io/ios_base/flags}}
{{nv mem ln | cpp/io/ios_base/setf}}
{{nv mem ln | cpp/io/ios_base/unsetf}}
{{nv mem ln | cpp/io/ios_base/precision}}
{{nv mem ln | cpp/io/ios_base/width}}

{{nv h2 | Locales}}
{{nv mem ln | cpp/io/ios_base/imbue}}
{{nv mem ln | cpp/io/ios_base/getloc}}

{{nv h2 | Internal extensible array}}
{{nv mem ln | cpp/io/ios_base/xalloc}}
{{nv mem ln | cpp/io/ios_base/iword}}
{{nv mem ln | cpp/io/ios_base/pword}}

{{nv h2 | Miscellaneous}}
{{nv mem ln | cpp/io/ios_base/register_callback}}
{{nv mem ln | cpp/io/ios_base/sync_with_stdio}}

{{nv h1 | Member classes}}
{{nv mem ln | cpp/io/ios_base/failure}}
{{nv mem ln | cpp/io/ios_base/Init}}

{{nv h1 | Member types}}
{{nv mem ln | cpp/io/ios_base/openmode}}
{{nv mem ln | cpp/io/ios_base/fmtflags}}
{{nv mem ln | cpp/io/ios_base/iostate}}
{{nv mem ln | cpp/io/ios_base/seekdir}}
{{nv mem ln | cpp/io/ios_base/event}}
{{nv mem ln | cpp/io/ios_base/event_callback}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/navbar heading</title>
    <ns>10</ns>
    <id>1561</id>
    <revision>
      <id>35695</id>
      <parentid>3122</parentid>
      <timestamp>2012-06-15T22:30:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ios base/sidebar heading]] to [[Template:cpp/io/ios base/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="41">{{ltt | cpp/io/ios_base | std::ios_base}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/openmode consts</title>
    <ns>10</ns>
    <id>1557</id>
    <revision>
      <id>52913</id>
      <parentid>32713</parentid>
      <timestamp>2013-06-01T04:56:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="557">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|app}} | seek to the end of stream before each write}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|binary}} | open in binary mode}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|in}} | open for reading}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|out}} | open for writing}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|trunc}} | discard the contents of the stream when opening}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|ate}} | seek to the end of stream immediately after open}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/openmode streambuf consts</title>
    <ns>10</ns>
    <id>4874</id>
    <revision>
      <id>52914</id>
      <parentid>32714</parentid>
      <timestamp>2013-06-01T04:56:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="214">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|in}} | affect the input sequence}}
{{dsc | {{ltt|cpp/io/ios_base/openmode|out}} | affect the output sequence}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/seekdir consts</title>
    <ns>10</ns>
    <id>1558</id>
    <revision>
      <id>52915</id>
      <parentid>32715</parentid>
      <timestamp>2013-06-01T04:56:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="310">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc | {{ltt|cpp/io/ios_base/seekdir|beg}} | the beginning of a stream }}
{{dsc | {{ltt|cpp/io/ios_base/seekdir|end}} | the ending of a stream }}
{{dsc | {{ltt|cpp/io/ios_base/seekdir|cur}} | the current position of stream position indicator }}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/title</title>
    <ns>10</ns>
    <id>1568</id>
    <revision>
      <id>3136</id>
      <parentid>3135</parentid>
      <timestamp>2011-06-06T22:57:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=ios_base::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ios base/xalloc example</title>
    <ns>10</ns>
    <id>6539</id>
    <revision>
      <id>25785</id>
      <parentid>25783</parentid>
      <timestamp>2012-04-25T14:14:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+desc</comment>
      <text xml:space="preserve" bytes="1636">{{example
 | Uses base class pword storage for runtime type identification of derived stream objects.
 | code=
#include &lt;iostream&gt;

template&lt;class charT, class traits = std::char_traits&lt;charT&gt; &gt;
class mystream : public std::basic_ostream&lt;charT, traits&gt;
{
 public:
    static const int xindex;
    mystream(std::basic_ostream&lt;charT, traits&gt;&amp; ostr) :
        std::basic_ostream&lt;charT, traits&gt;(ostr.rdbuf())
    {
         this-&gt;pword(xindex) = this;
    }
 
    void myfn()
    {
        *this &lt;&lt; &quot;[special handling for mystream]&quot;;
    }
};

// each specialization of mystream obtains a unique index from xalloc()
template&lt;class charT, class traits&gt;
const int mystream&lt;charT, traits&gt;::xindex = std::ios_base::xalloc();

// This I/O manipulator will be able to recognize ostreams that are mystreams
// by looking up the pointer stored in pword
template&lt;class charT, class traits&gt;
std::basic_ostream&lt;charT,traits&gt;&amp; mymanip(std::basic_ostream&lt;charT,traits&gt;&amp; os)
{
 if (os.pword(mystream&lt;charT,traits&gt;::xindex) == &amp;os) 
    static_cast&lt;mystream&lt;charT,traits&gt;&amp;&gt;(os).myfn();
 return os;
}

int main()
{
    std::cout &lt;&lt; &quot;cout, narrow-character test &quot; &lt;&lt; mymanip &lt;&lt; '\n';

    mystream&lt;char&gt; myout(std::cout);
    myout &lt;&lt; &quot;myout, narrow-character test &quot; &lt;&lt; mymanip &lt;&lt; '\n';

    std::wcout &lt;&lt; &quot;wcout, wide-character test &quot; &lt;&lt; mymanip &lt;&lt; '\n';

    mystream&lt;wchar_t&gt; mywout(std::wcout);
    mywout &lt;&lt; &quot;mywout, wide-character test &quot; &lt;&lt; mymanip &lt;&lt; '\n';
}
 | output=
cout, narrow-character test 
myout, narrow-character test [special handling for mystream]
wcout, wide-character test 
mywout, wide-character test [special handling for mystream]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/istrstream/navbar</title>
    <ns>10</ns>
    <id>4697</id>
    <revision>
      <id>39926</id>
      <parentid>35696</parentid>
      <timestamp>2012-09-28T20:10:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="235">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/istrstream/navbar heading
|content3 = cpp/io/istrstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/istrstream/navbar content</title>
    <ns>10</ns>
    <id>4699</id>
    <revision>
      <id>52916</id>
      <parentid>35697</parentid>
      <timestamp>2013-06-01T04:56:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="221">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/istrstream/istrstream}}
{{nv mem ln | cpp/io/istrstream/~istrstream}}
{{nv mem ln | cpp/io/istrstream/rdbuf}}
{{nv mem ln | cpp/io/istrstream/str}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/istrstream/navbar heading</title>
    <ns>10</ns>
    <id>4698</id>
    <revision>
      <id>35504</id>
      <parentid>17075</parentid>
      <timestamp>2012-06-15T22:26:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/istrstream/sidebar heading]] to [[Template:cpp/io/istrstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="45">{{ltt | cpp/io/istrstream | std::istrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/istrstream/title</title>
    <ns>10</ns>
    <id>12790</id>
    <revision>
      <id>62231</id>
      <timestamp>2013-06-25T12:28:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=istrstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc boolalpha</title>
    <ns>10</ns>
    <id>4650</id>
    <revision>
      <id>56450</id>
      <parentid>52917</parentid>
      <timestamp>2013-06-01T05:36:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list boolalpha]] to [[Template:cpp/io/manip/dsc boolalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | cpp/io/manip/boolalpha | title=boolalpha&lt;br&gt;noboolalpha | switches between textual and numeric representation of booleans}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc endl</title>
    <ns>10</ns>
    <id>4663</id>
    <revision>
      <id>56455</id>
      <parentid>52918</parentid>
      <timestamp>2013-06-01T05:36:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list endl]] to [[Template:cpp/io/manip/dsc endl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc tfun | cpp/io/manip/endl | outputs {{c|'\n'}} and flushes the output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc ends</title>
    <ns>10</ns>
    <id>4661</id>
    <revision>
      <id>56460</id>
      <parentid>52919</parentid>
      <timestamp>2013-06-01T05:36:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list ends]] to [[Template:cpp/io/manip/dsc ends]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">{{dsc tfun | cpp/io/manip/ends | outputs {{c|'\0'}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc fixed</title>
    <ns>10</ns>
    <id>4659</id>
    <revision>
      <id>56465</id>
      <parentid>52920</parentid>
      <timestamp>2013-06-01T05:36:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list fixed]] to [[Template:cpp/io/manip/dsc fixed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="186">{{dsc fun | cpp/io/manip/fixed | title=fixed&lt;br&gt;scientific&lt;br&gt;hexfloat&lt;br&gt;defaultfloat | notes=&lt;br&gt;&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} | changes formatting used for floating-point I/O}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc flush</title>
    <ns>10</ns>
    <id>4662</id>
    <revision>
      <id>56470</id>
      <parentid>52921</parentid>
      <timestamp>2013-06-01T05:36:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list flush]] to [[Template:cpp/io/manip/dsc flush]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">{{dsc tfun | cpp/io/manip/flush | flushes the output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc get money</title>
    <ns>10</ns>
    <id>4670</id>
    <revision>
      <id>56475</id>
      <parentid>52922</parentid>
      <timestamp>2013-06-01T05:36:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list get money]] to [[Template:cpp/io/manip/dsc get money]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc tfun | cpp/io/manip/get_money | parses a monetary value | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc get time</title>
    <ns>10</ns>
    <id>4645</id>
    <revision>
      <id>56480</id>
      <parentid>52923</parentid>
      <timestamp>2013-06-01T05:36:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list get time]] to [[Template:cpp/io/manip/dsc get time]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc tfun | cpp/io/manip/get_time | parses a date/time value of specified format| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc hex</title>
    <ns>10</ns>
    <id>4658</id>
    <revision>
      <id>56485</id>
      <parentid>52924</parentid>
      <timestamp>2013-06-01T05:37:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list hex]] to [[Template:cpp/io/manip/dsc hex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/io/manip/hex | title=dec&lt;br&gt;hex&lt;br&gt;oct | changes the base used for integer I/O}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc left</title>
    <ns>10</ns>
    <id>4657</id>
    <revision>
      <id>56490</id>
      <parentid>52925</parentid>
      <timestamp>2013-06-01T05:37:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list left]] to [[Template:cpp/io/manip/dsc left]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/io/manip/left | title=internal&lt;br&gt;left&lt;br&gt;right | sets the placement of fill characters  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc put money</title>
    <ns>10</ns>
    <id>4671</id>
    <revision>
      <id>56494</id>
      <parentid>52926</parentid>
      <timestamp>2013-06-01T05:37:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list put money]] to [[Template:cpp/io/manip/dsc put money]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc tfun | cpp/io/manip/put_money | formats and outputs a monetary value| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc put time</title>
    <ns>10</ns>
    <id>4646</id>
    <revision>
      <id>56497</id>
      <parentid>52927</parentid>
      <timestamp>2013-06-01T05:37:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list put time]] to [[Template:cpp/io/manip/dsc put time]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tfun | cpp/io/manip/put_time | formats and outputs a date/time value according to the specified format| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc quoted</title>
    <ns>10</ns>
    <id>9991</id>
    <revision>
      <id>56501</id>
      <parentid>52928</parentid>
      <timestamp>2013-06-01T05:37:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list quoted]] to [[Template:cpp/io/manip/dsc quoted]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tfun | cpp/io/manip/quoted | inserts and extracts quoted strings with embedded spaces | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc resetiosflags</title>
    <ns>10</ns>
    <id>4664</id>
    <revision>
      <id>56505</id>
      <parentid>52929</parentid>
      <timestamp>2013-06-01T05:37:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list resetiosflags]] to [[Template:cpp/io/manip/dsc resetiosflags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/io/manip/resetiosflags | clears the specified ios_base flags}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc setbase</title>
    <ns>10</ns>
    <id>4666</id>
    <revision>
      <id>56509</id>
      <parentid>52930</parentid>
      <timestamp>2013-06-01T05:37:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list setbase]] to [[Template:cpp/io/manip/dsc setbase]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/manip/setbase | changes the base used for integer I/O}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc setfill</title>
    <ns>10</ns>
    <id>4667</id>
    <revision>
      <id>56514</id>
      <parentid>52931</parentid>
      <timestamp>2013-06-01T05:37:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list setfill]] to [[Template:cpp/io/manip/dsc setfill]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc tfun | cpp/io/manip/setfill | changes the fill character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc setiosflags</title>
    <ns>10</ns>
    <id>4665</id>
    <revision>
      <id>56518</id>
      <parentid>52932</parentid>
      <timestamp>2013-06-01T05:37:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list setiosflags]] to [[Template:cpp/io/manip/dsc setiosflags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/manip/setiosflags | sets the specified ios_base flags}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc setprecision</title>
    <ns>10</ns>
    <id>4668</id>
    <revision>
      <id>56523</id>
      <parentid>52933</parentid>
      <timestamp>2013-06-01T05:37:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list setprecision]] to [[Template:cpp/io/manip/dsc setprecision]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/io/manip/setprecision | changes floating-point precision}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc setw</title>
    <ns>10</ns>
    <id>4669</id>
    <revision>
      <id>56528</id>
      <parentid>52934</parentid>
      <timestamp>2013-06-01T05:37:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list setw]] to [[Template:cpp/io/manip/dsc setw]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | cpp/io/manip/setw | changes the width of the next input/output field}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc showbase</title>
    <ns>10</ns>
    <id>4651</id>
    <revision>
      <id>56533</id>
      <parentid>52935</parentid>
      <timestamp>2013-06-01T05:37:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list showbase]] to [[Template:cpp/io/manip/dsc showbase]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/io/manip/showbase | title=showbase&lt;br&gt;noshowbase | controls whether prefix is used to indicate numeric base }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc showpoint</title>
    <ns>10</ns>
    <id>4652</id>
    <revision>
      <id>56538</id>
      <parentid>52936</parentid>
      <timestamp>2013-06-01T05:37:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list showpoint]] to [[Template:cpp/io/manip/dsc showpoint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc fun | cpp/io/manip/showpoint | title=showpoint&lt;br&gt;noshowpoint | controls whether decimal point is always included in floating-point representation }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc showpos</title>
    <ns>10</ns>
    <id>4653</id>
    <revision>
      <id>56543</id>
      <parentid>52937</parentid>
      <timestamp>2013-06-01T05:37:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list showpos]] to [[Template:cpp/io/manip/dsc showpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc fun | cpp/io/manip/showpos | title=showpos&lt;br&gt;noshowpos| controls whether the {{tt|+}} sign used with non-negative numbers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc skipws</title>
    <ns>10</ns>
    <id>4654</id>
    <revision>
      <id>56547</id>
      <parentid>52938</parentid>
      <timestamp>2013-06-01T05:37:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list skipws]] to [[Template:cpp/io/manip/dsc skipws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc fun | cpp/io/manip/skipws | title=skipws&lt;br&gt;noskipws| controls whether leading whitespace is skipped on input}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc unitbuf</title>
    <ns>10</ns>
    <id>4656</id>
    <revision>
      <id>56552</id>
      <parentid>52939</parentid>
      <timestamp>2013-06-01T05:37:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list unitbuf]] to [[Template:cpp/io/manip/dsc unitbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | cpp/io/manip/unitbuf | title=unitbuf&lt;br&gt;nounitbuf | controls whether output is flushed after each operation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc uppercase</title>
    <ns>10</ns>
    <id>4655</id>
    <revision>
      <id>56557</id>
      <parentid>52940</parentid>
      <timestamp>2013-06-01T05:37:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list uppercase]] to [[Template:cpp/io/manip/dsc uppercase]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | cpp/io/manip/uppercase | title=uppercase&lt;br&gt;nouppercase | controls whether uppercase characters are used with some output formats }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/dsc ws</title>
    <ns>10</ns>
    <id>4660</id>
    <revision>
      <id>56561</id>
      <parentid>52941</parentid>
      <timestamp>2013-06-01T05:38:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/dcl list ws]] to [[Template:cpp/io/manip/dsc ws]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">{{dsc tfun | cpp/io/manip/ws | consumes whitespace}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/navbar</title>
    <ns>10</ns>
    <id>2974</id>
    <revision>
      <id>39927</id>
      <parentid>36038</parentid>
      <timestamp>2012-09-28T20:10:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="223">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/manip/navbar heading
|content3 = cpp/io/manip/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/navbar content</title>
    <ns>10</ns>
    <id>4672</id>
    <revision>
      <id>52942</id>
      <parentid>35699</parentid>
      <timestamp>2013-06-01T04:56:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1851">{{nv begin}}

{{nv h2 | Floating-point formatting}}
{{nv col begin}}
{{nv ln | cpp/io/manip/showpoint|showpoint|noshowpoint}}
{{nv ln | cpp/io/manip/setprecision}}
{{nv col next}}
{{nv ln | cpp/io/manip/fixed|fixed|scientific|hexfloat|defaultfloat|notes=&lt;br&gt;&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv col end}}

{{nv h2 | Integer formatting}}
{{nv col begin}}
{{nv ln | cpp/io/manip/setbase}}
{{nv ln | cpp/io/manip/showbase|showbase|noshowbase}}
{{nv col next}}
{{nv ln | cpp/io/manip/hex|dec|hex|oct}}
{{nv col end}}

{{nv h2 | Boolean formatting}}
{{nv ln | cpp/io/manip/boolalpha|boolalpha|noboolalpha}}

{{nv h2 | Field width and fill control}}
{{nv col begin}}
{{nv ln | cpp/io/manip/setfill}}
{{nv ln | cpp/io/manip/setw}}
{{nv col next}}
{{nv ln | cpp/io/manip/left|internal|left|right}}
{{nv col end}}

{{nv h2 | Other formatting}}
{{nv col begin}}
{{nv ln | cpp/io/manip/showpos|showpos|noshowpos}}
{{nv col next}}
{{nv ln | cpp/io/manip/uppercase|uppercase|nouppercase}}
{{nv col end}}

{{nv h2 | Whitespace processing}}
{{nv col begin}}
{{nv ln | cpp/io/manip/ws}}
{{nv ln | cpp/io/manip/ends}}
{{nv col next}}
{{nv ln | cpp/io/manip/skipws|skipws|noskipws}}
{{nv col end}}

{{nv h2 | Output flushing}}
{{nv col begin}}
{{nv ln | cpp/io/manip/flush}}
{{nv ln | cpp/io/manip/endl}}
{{nv col next}}
{{nv ln | cpp/io/manip/unitbuf|unitbuf|nounitbuf}}
{{nv col end}}

{{nv h2 | Status flags manipulation}}
{{nv col begin}}
{{nv ln | cpp/io/manip/resetiosflags}}
{{nv col next}}
{{nv ln | cpp/io/manip/setiosflags}}
{{nv col end}}

{{nv h2 | Time and money I/O}}
{{nv col begin}}
{{nv ln | cpp/io/manip/get_money|notes={{mark c++11}}}}
{{nv ln | cpp/io/manip/get_time|notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/io/manip/put_money|notes={{mark c++11}}}}
{{nv ln | cpp/io/manip/put_time|notes={{mark c++11}}}}
{{nv col end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/manip/navbar heading</title>
    <ns>10</ns>
    <id>2975</id>
    <revision>
      <id>35700</id>
      <parentid>11235</parentid>
      <timestamp>2012-06-15T22:30:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/manip/sidebar heading]] to [[Template:cpp/io/manip/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="42">[[cpp/io/manip|Input/output manipulators]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/navbar</title>
    <ns>10</ns>
    <id>1569</id>
    <revision>
      <id>39928</id>
      <parentid>35704</parentid>
      <timestamp>2012-09-28T20:10:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="144">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/navbar content</title>
    <ns>10</ns>
    <id>1570</id>
    <revision>
      <id>52943</id>
      <parentid>35705</parentid>
      <timestamp>2013-06-01T04:56:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1196">{{nv begin}}
{{nv | [[cpp/io/manip | I/O manipulators]]}}
{{nv | [[cpp/io/c | C-style I/O]]}}
{{nv h1 | Buffers }}
{{nv ln | cpp/io/basic_streambuf}}
{{nv ln | cpp/io/basic_filebuf}}
{{nv ln | cpp/io/basic_stringbuf}}
{{nv ln | cpp/io/strstreambuf|notes={{mark deprecated}}}}
{{nv h1 | Streams }}
{{nv h2 | Abstractions }}
{{nv ln | cpp/io/ios_base}}
{{nv ln | cpp/io/basic_ios}}
{{nv ln | cpp/io/basic_istream}}
{{nv ln | cpp/io/basic_ostream}}
{{nv ln | cpp/io/basic_iostream}}
{{nv h2 | File I/O }}
{{nv ln | cpp/io/basic_ifstream}}
{{nv ln | cpp/io/basic_ofstream}}
{{nv ln | cpp/io/basic_fstream}}
{{nv h2 | String I/O }}
{{nv ln | cpp/io/basic_istringstream}}
{{nv ln | cpp/io/basic_ostringstream}}
{{nv ln | cpp/io/basic_stringstream}}
{{nv h2 | Array I/O }}
{{nv ln | cpp/io/istrstream | notes={{mark deprecated}}}}
{{nv ln | cpp/io/ostrstream | notes={{mark deprecated}}}}
{{nv ln | cpp/io/strstream | notes={{mark deprecated}}}}
{{nv h1 | Types }}
{{nv ln | cpp/io/streamoff}}
{{nv ln | cpp/io/streamsize}}
{{nv ln | cpp/io/fpos}}
{{nv h1 | Error category interface }}
{{nv ln | cpp/io/iostream_category |notes={{mark c++11}}}}
{{nv ln | cpp/io/io_errc|notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/navbar heading</title>
    <ns>10</ns>
    <id>1571</id>
    <revision>
      <id>35706</id>
      <parentid>3142</parentid>
      <timestamp>2012-06-15T22:30:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/sidebar heading]] to [[Template:cpp/io/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="33">[[cpp/io | Input/output library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ostrstream/navbar</title>
    <ns>10</ns>
    <id>4701</id>
    <revision>
      <id>39929</id>
      <parentid>35701</parentid>
      <timestamp>2012-09-28T20:10:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="234">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/ostrstream/navbar heading
|content3 = cpp/io/ostrstream/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ostrstream/navbar content</title>
    <ns>10</ns>
    <id>4703</id>
    <revision>
      <id>52944</id>
      <parentid>35702</parentid>
      <timestamp>2013-06-01T04:56:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="303">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/ostrstream/ostrstream}}
{{nv mem ln | cpp/io/ostrstream/~ostrstream}}
{{nv mem ln | cpp/io/ostrstream/rdbuf}}
{{nv mem ln | cpp/io/ostrstream/str}}
{{nv mem ln | cpp/io/ostrstream/freeze}}
{{nv mem ln | cpp/io/ostrstream/pcount}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ostrstream/navbar heading</title>
    <ns>10</ns>
    <id>4702</id>
    <revision>
      <id>35703</id>
      <parentid>17080</parentid>
      <timestamp>2012-06-15T22:30:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/ostrstream/sidebar heading]] to [[Template:cpp/io/ostrstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="45">{{ltt | cpp/io/ostrstream | std::ostrstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/ostrstream/title</title>
    <ns>10</ns>
    <id>12789</id>
    <revision>
      <id>62230</id>
      <timestamp>2013-06-25T12:28:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=ostrstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/stream exceptions</title>
    <ns>10</ns>
    <id>12782</id>
    <revision>
      <id>61987</id>
      <parentid>61986</parentid>
      <timestamp>2013-06-14T13:01:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="298">{{lc|failure}} if an error occurred (the error state flag is not {{lc|goodbit}}) and {{lc|exceptions()}} is set to throw for that state.

If an internal operation throws an exception, it is caught and {{lc|badbit}} is set. If {{lc|exceptions()}} is set for {{tt|badbit}}, the exception is rethrown.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc constructor</title>
    <ns>10</ns>
    <id>9708</id>
    <revision>
      <id>56586</id>
      <parentid>52945</parentid>
      <timestamp>2013-06-01T05:38:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list constructor]] to [[Template:cpp/io/strstream/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem ctor | cpp/io/{{{1|}}}/{{{1|}}} | constructs an strstream, optionally allocating the buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc destructor</title>
    <ns>10</ns>
    <id>9709</id>
    <revision>
      <id>56590</id>
      <parentid>52946</parentid>
      <timestamp>2013-06-01T05:38:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list destructor]] to [[Template:cpp/io/strstream/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem vdtor | cpp/io/{{{1|}}}/~{{{1|}}} | destructs a strstream, optionally deallocating the buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc freeze</title>
    <ns>10</ns>
    <id>9712</id>
    <revision>
      <id>56595</id>
      <parentid>52947</parentid>
      <timestamp>2013-06-01T05:38:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list freeze]] to [[Template:cpp/io/strstream/dsc freeze]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/io/{{{1|}}}/freeze | disables/enables automatic reallocation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc pcount</title>
    <ns>10</ns>
    <id>9713</id>
    <revision>
      <id>56600</id>
      <parentid>52948</parentid>
      <timestamp>2013-06-01T05:38:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list pcount]] to [[Template:cpp/io/strstream/dsc pcount]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem fun | cpp/io/{{{1|}}}/pcount | obtains the number of characters written}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc rdbuf</title>
    <ns>10</ns>
    <id>9710</id>
    <revision>
      <id>56604</id>
      <parentid>52949</parentid>
      <timestamp>2013-06-01T05:38:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list rdbuf]] to [[Template:cpp/io/strstream/dsc rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/io/{{{1|}}}/rdbuf | obtains a pointer to the associated strstreambuf}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/dsc str</title>
    <ns>10</ns>
    <id>9711</id>
    <revision>
      <id>56609</id>
      <parentid>52950</parentid>
      <timestamp>2013-06-01T05:38:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/dcl list str]] to [[Template:cpp/io/strstream/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/io/{{{1|}}}/str | accesses the output buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/freeze</title>
    <ns>10</ns>
    <id>9725</id>
    <revision>
      <id>64271</id>
      <parentid>62229</parentid>
      <timestamp>2013-08-15T16:13:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1545">{{cpp/io/{{{1|}}}/title | freeze}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 
void freeze(bool flag {{=}} true);
}}
{{dcl end}}

If the stream is using a dynamically-allocated array for output, disables ({{c|flag {{==}} true}}) or enables ({{c|flag {{==}} false}}) automatic allocation/deallocation of the buffer. Effectively calls {{c|rdbuf()-&gt;pcount()}}

===Notes===
After a call to {{lc|str()}}, dynamic streams become frozen automatically. A call to {{c|freeze(false)}} is required before exiting the scope in which this {{c|{{{1|}}} }} object was created. otherwise the destructor will leak memory. Also, additional output to a frozen stream may be truncated once it reaches the end of the allocated buffer.

===Parameters===
{{par begin}}
{{par | flag | desired status}}
{{par end}}

===Return value===
(none)

===Example===
{{example
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::{{{1|}}} dyn; // dynamically-allocated output buffer
    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::cout &lt;&lt; &quot;The output stream contains \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;

    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::cout &lt;&lt; &quot;The output stream contains \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    // the stream is now frozen due to str()
    dyn &lt;&lt; &quot; More text&quot;;
    std::cout &lt;&lt; &quot;The output stream contains \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    dyn.freeze(false);
}
 | p = true
 | output=
The output stream contains &quot;Test: 1.23&quot;
The output stream contains &quot;Test: 1.23 More &quot;
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc freeze}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/navbar</title>
    <ns>10</ns>
    <id>4794</id>
    <revision>
      <id>39930</id>
      <parentid>35707</parentid>
      <timestamp>2012-09-28T20:10:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="233">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/strstream/navbar heading
|content3 = cpp/io/strstream/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/navbar content</title>
    <ns>10</ns>
    <id>4797</id>
    <revision>
      <id>52952</id>
      <parentid>35708</parentid>
      <timestamp>2013-06-01T04:56:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="295">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/io/strstream/strstream}}
{{nv mem ln | cpp/io/strstream/~strstream}}
{{nv mem ln | cpp/io/strstream/rdbuf}}
{{nv mem ln | cpp/io/strstream/str}}
{{nv mem ln | cpp/io/strstream/pcount}}
{{nv mem ln | cpp/io/strstream/freeze}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/navbar heading</title>
    <ns>10</ns>
    <id>4796</id>
    <revision>
      <id>35709</id>
      <parentid>17402</parentid>
      <timestamp>2012-06-15T22:30:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstream/sidebar heading]] to [[Template:cpp/io/strstream/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="43">{{ltt | cpp/io/strstream | std::strstream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/pcount</title>
    <ns>10</ns>
    <id>9722</id>
    <revision>
      <id>62232</id>
      <parentid>60885</parentid>
      <timestamp>2013-06-25T12:29:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>title, don't use ddcl</comment>
      <text xml:space="preserve" bytes="1064">{{cpp/io/{{{1|}}}/title | pcount}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 
int pcount() const;
}}
{{dcl end}}

Returns the number of characters that were output in the put area of the associated {{c|std::strstreambuf}}. Effectively calls {{c|rdbuf()-&gt;pcount()}}

===Parameters===
(none)

===Return value===
The number of characters in the put area, or zero if nothing was output.

===Example===
{{example
 | code=
#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::{{{1|}}} dyn; // dynamically-allocated output buffer
    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::cout &lt;&lt; &quot;The size of the output is &quot; &lt;&lt; dyn.pcount()
              &lt;&lt; &quot; and it holds \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    dyn.freeze(false);

    char buf[10];
    std::{{{1|}}} user(buf, 10); // user-provided output buffer
    user &lt;&lt; 1.23; // note: no std::ends
    std::cout.write(buf, user.pcount());
    std::cout &lt;&lt; '\n';
}
 | output=
The size of the output is 10 and it holds &quot;Test: 1.23&quot;
1.23
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc pcount}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/rdbuf</title>
    <ns>10</ns>
    <id>9733</id>
    <revision>
      <id>62227</id>
      <parentid>45149</parentid>
      <timestamp>2013-06-25T12:26:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>title, don't use ddcl</comment>
      <text xml:space="preserve" bytes="617">{{cpp/io/{{{1|}}}/title | rdbuf}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |  
strstreambuf* rdbuf() const;
}}
{{dcl end}}

Returns a pointer to the associated {{c|std::strstreambuf}}, casting away its constness (despite the const qualifier on the member function)

===Parameters===
(none)

===Return value===
Pointer to the associated {{c|std::strsteambuf}}, with constness cast away.

===Example===
{{example
 | code=
#include &lt;strstream&gt;
int main()
{
{{#ifeq:{{{1|}}}|istrstream|    const std::{{{1|}}} buf(&quot;example&quot;);
|    const std::{{{1|}}} buf;}}
    std::strstreambuf* ptr = buf.rdbuf();
}
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/str</title>
    <ns>10</ns>
    <id>9729</id>
    <revision>
      <id>64270</id>
      <parentid>62228</parentid>
      <timestamp>2013-08-15T16:13:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="1545">{{cpp/io/{{{1|}}}/title | str}}
{{cpp/io/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
char* str();
}}
{{dcl end}}

Returns the pointer to the beginning of the buffer, after freezing it. Effectively calls {{c|rdbuf()-&gt;str()}}

{{#ifeq:{{{1|}}}|istrstream||===Notes===
After a call to {{lc|str()}}, dynamic streams become frozen. A call to {{c|freeze(false)}} is required before exiting the scope in which this {{c|{{{1|}}} }} object was created. otherwise the destructor will leak memory. Also, additional output to a frozen stream may be truncated once it reaches the end of the allocated buffer.
}}
===Parameters===
(none)

===Return value===
Pointer to the beginning of the buffer in the associated {{c|std::strsteambuf}} or {{lc|NULL}} if no buffer is available.

===Example===
{{example
 | code=
{{#ifeq:{{{1|}}}|istrstream||#include &lt;strstream&gt;
#include &lt;iostream&gt;

int main()
{
    std::{{{1|}}} dyn; // dynamically-allocated output buffer
    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::cout &lt;&lt; &quot;The output stream holds \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;

    dyn &lt;&lt; &quot;Test: &quot; &lt;&lt; 1.23;
    std::cout &lt;&lt; &quot;The output stream holds \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    // the stream is now frozen due to str()
    dyn &lt;&lt; &quot; More text&quot;;
    std::cout &lt;&lt; &quot;The output stream holds \&quot;&quot; &lt;&lt; dyn.str() &lt;&lt; &quot;\&quot;\n&quot;;
    dyn.freeze(false);
}
}} | p = true
 | output=
{{#ifeq:{{{1|}}}|istrstream||The stream holds &quot;Test: 1.23&quot;
The stream holds &quot;Test: 1.23 More &quot;
}}}}

{{#ifeq:{{{1|}}}|istrstream||===See also===
{{dsc begin}}
{{dsc inc | cpp/io/strstreambuf/dsc str}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstream/title</title>
    <ns>10</ns>
    <id>9448</id>
    <revision>
      <id>40154</id>
      <timestamp>2012-10-03T14:21:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=strstream::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc freeze</title>
    <ns>10</ns>
    <id>9701</id>
    <revision>
      <id>56614</id>
      <parentid>52955</parentid>
      <timestamp>2013-06-01T05:38:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list freeze]] to [[Template:cpp/io/strstreambuf/dsc freeze]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/io/strstreambuf/freeze | sets/clears the frozen state of the buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc overflow</title>
    <ns>10</ns>
    <id>6344</id>
    <revision>
      <id>56618</id>
      <parentid>52956</parentid>
      <timestamp>2013-06-01T05:38:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list overflow]] to [[Template:cpp/io/strstreambuf/dsc overflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="172">{{dsc prot mem vfun | cpp/io/strstreambuf/overflow | appends a character to the output sequence, may reallocate or initially allocate the buffer if dynamic and not frozen}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc pbackfail</title>
    <ns>10</ns>
    <id>9692</id>
    <revision>
      <id>56622</id>
      <parentid>52957</parentid>
      <timestamp>2013-06-01T05:38:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list pbackfail]] to [[Template:cpp/io/strstreambuf/dsc pbackfail]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc prot mem vfun | cpp/io/strstreambuf/pbackfail | backs out the input sequence to unget a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc pcount</title>
    <ns>10</ns>
    <id>9703</id>
    <revision>
      <id>56625</id>
      <parentid>52958</parentid>
      <timestamp>2013-06-01T05:38:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list pcount]] to [[Template:cpp/io/strstreambuf/dsc pcount]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc mem fun | cpp/io/strstreambuf/pcount | returns the next pointer minus the beginning pointer in the output sequence: the number of characters written }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc seekoff</title>
    <ns>10</ns>
    <id>9706</id>
    <revision>
      <id>56630</id>
      <parentid>52959</parentid>
      <timestamp>2013-06-01T05:38:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list seekoff]] to [[Template:cpp/io/strstreambuf/dsc seekoff]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc prot mem vfun | cpp/io/strstreambuf/seekoff | repositions the next pointer in the input sequence, output sequence, or both, using relative addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc seekpos</title>
    <ns>10</ns>
    <id>9707</id>
    <revision>
      <id>56634</id>
      <parentid>52960</parentid>
      <timestamp>2013-06-01T05:39:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list seekpos]] to [[Template:cpp/io/strstreambuf/dsc seekpos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc prot mem vfun | cpp/io/strstreambuf/seekpos | repositions the next pointer in the input sequence, output sequence, or both using absolute addressing}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc setbuf</title>
    <ns>10</ns>
    <id>9705</id>
    <revision>
      <id>56639</id>
      <parentid>52961</parentid>
      <timestamp>2013-06-01T05:39:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list setbuf]] to [[Template:cpp/io/strstreambuf/dsc setbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc prot mem vfun | cpp/io/strstreambuf/setbuf | attempts to replace the controlled character sequence with an array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc str</title>
    <ns>10</ns>
    <id>9702</id>
    <revision>
      <id>56644</id>
      <parentid>52962</parentid>
      <timestamp>2013-06-01T05:39:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list str]] to [[Template:cpp/io/strstreambuf/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/io/strstreambuf/str | marks the buffer frozen and returns the beginning pointer of the input sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc strstreambuf</title>
    <ns>10</ns>
    <id>9698</id>
    <revision>
      <id>56649</id>
      <parentid>52963</parentid>
      <timestamp>2013-06-01T05:39:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list strstreambuf]] to [[Template:cpp/io/strstreambuf/dsc strstreambuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem ctor | cpp/io/strstreambuf/strstreambuf | constructs a strstreambuf object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc underflow</title>
    <ns>10</ns>
    <id>9704</id>
    <revision>
      <id>56653</id>
      <parentid>52964</parentid>
      <timestamp>2013-06-01T05:39:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list underflow]] to [[Template:cpp/io/strstreambuf/dsc underflow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc prot mem vfun | cpp/io/strstreambuf/underflow | reads a character from the input sequence without advancing the next pointer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/dsc ~strstreambuf</title>
    <ns>10</ns>
    <id>9700</id>
    <revision>
      <id>56658</id>
      <parentid>52965</parentid>
      <timestamp>2013-06-01T05:39:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/io/strstreambuf/dcl list ~strstreambuf]] to [[Template:cpp/io/strstreambuf/dsc ~strstreambuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem vdtor | cpp/io/strstreambuf/~strstreambuf | destructs a strstreambuf object, optionally deallocating the character array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/navbar</title>
    <ns>10</ns>
    <id>4375</id>
    <revision>
      <id>39931</id>
      <parentid>35710</parentid>
      <timestamp>2012-09-28T20:10:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="239">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/io/navbar heading
|content2 = cpp/io/navbar content

|heading3 = cpp/io/strstreambuf/navbar heading
|content3 = cpp/io/strstreambuf/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/navbar content</title>
    <ns>10</ns>
    <id>4377</id>
    <revision>
      <id>52966</id>
      <parentid>33570</parentid>
      <timestamp>2013-06-01T04:57:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="592">{{nv begin}}
{{nv h1 | Public member functions}}
{{nv mem ln | cpp/io/strstreambuf/strstreambuf}}
{{nv mem ln | cpp/io/strstreambuf/~strstreambuf}}
{{nv mem ln | cpp/io/strstreambuf/freeze}}
{{nv mem ln | cpp/io/strstreambuf/str}}
{{nv mem ln | cpp/io/strstreambuf/pcount}}

{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/io/strstreambuf/underflow}}
{{nv mem ln | cpp/io/strstreambuf/pbackfail}}
{{nv mem ln | cpp/io/strstreambuf/overflow}}
{{nv mem ln | cpp/io/strstreambuf/setbuf}}
{{nv mem ln | cpp/io/strstreambuf/seekoff}}
{{nv mem ln | cpp/io/strstreambuf/seekpos}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/navbar heading</title>
    <ns>10</ns>
    <id>4376</id>
    <revision>
      <id>48071</id>
      <parentid>35711</parentid>
      <timestamp>2013-05-18T18:05:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="45">{{ltt|cpp/io/strstreambuf|std::strstreambuf}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/io/strstreambuf/title</title>
    <ns>10</ns>
    <id>6345</id>
    <revision>
      <id>24009</id>
      <timestamp>2012-04-20T03:59:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=strstreambuf::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator//navbar</title>
    <ns>10</ns>
    <id>8724</id>
    <redirect title="Template:cpp/iterator/navbar" />
    <revision>
      <id>36848</id>
      <timestamp>2012-07-02T17:53:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:cpp/iterator/navbar]]</comment>
      <text xml:space="preserve" bytes="42">#redirect [[Template:cpp/iterator/navbar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator//title</title>
    <ns>10</ns>
    <id>8723</id>
    <revision>
      <id>36846</id>
      <timestamp>2012-07-02T17:50:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/base</title>
    <ns>10</ns>
    <id>8725</id>
    <revision>
      <id>60887</id>
      <parentid>52967</parentid>
      <timestamp>2013-06-01T11:59:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="415">{{cpp/iterator/{{{1|}}}/title| base}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 
Iterator base() const;
}}
{{dcl end}}

Returns the underlying base iterator.

===Parameters===
(none)

===Return value===
The underlying iterator.

===Exceptions===
(none)

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator*|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/constructor</title>
    <ns>10</ns>
    <id>8717</id>
    <revision>
      <id>60888</id>
      <parentid>52968</parentid>
      <timestamp>2013-06-01T11:59:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="841">{{cpp/iterator/{{{1|}}}/title | {{{1}}}}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 
{{{1}}}();
}}
{{dcl | num=2 |
explicit {{{1}}}( Iterator x ); 
}}
{{dcl | num=3 |
template&lt; class U &gt; 
{{{1}}}( const {{{1}}}&lt;U&gt;&amp; other );
}}
{{dcl end}}

Constructs a new iterator adaptor.

@1@ Default constructor. {{tt|current}} is value-initialized. This makes sense only if operations on an value-initialized {{tt|Iterator}} make also sense.

@2@ {{tt|current}} is initialized with {{tt|x}}.

@3@ Copy constructor. The underlying iterator is initialized with that of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | x | iterator to adapt}}
{{par | other | iterator adaptor to copy}}
{{par end}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator{{=}}| {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc base</title>
    <ns>10</ns>
    <id>8712</id>
    <revision>
      <id>56662</id>
      <parentid>52969</parentid>
      <timestamp>2013-06-01T05:39:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list base]] to [[Template:cpp/iterator/adaptor/dsc base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/iterator/{{{1|}}}/base | accesses the underlying iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc constructor</title>
    <ns>10</ns>
    <id>8710</id>
    <revision>
      <id>56667</id>
      <parentid>52970</parentid>
      <timestamp>2013-06-01T05:39:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list constructor]] to [[Template:cpp/iterator/adaptor/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem ctor | cpp/iterator/{{{1|}}}/{{{1|}}} | constructs a new iterator adaptor }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator*</title>
    <ns>10</ns>
    <id>8713</id>
    <revision>
      <id>56671</id>
      <parentid>52971</parentid>
      <timestamp>2013-06-01T05:39:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator*]] to [[Template:cpp/iterator/adaptor/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator* | title=operator*&lt;br&gt;operator-&gt; | accesses the pointed-to element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator+</title>
    <ns>10</ns>
    <id>8738</id>
    <revision>
      <id>56676</id>
      <parentid>52972</parentid>
      <timestamp>2013-06-01T05:39:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator+]] to [[Template:cpp/iterator/adaptor/dsc operator+]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc tfun | cpp/iterator/{{{1|}}}/operator+ | advances the iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator-</title>
    <ns>10</ns>
    <id>8739</id>
    <revision>
      <id>56680</id>
      <parentid>52973</parentid>
      <timestamp>2013-06-01T05:39:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator-]] to [[Template:cpp/iterator/adaptor/dsc operator-]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tfun | cpp/iterator/{{{1|}}}/operator- | computes the distance between two iterator adaptors}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator=</title>
    <ns>10</ns>
    <id>8711</id>
    <revision>
      <id>56684</id>
      <parentid>52974</parentid>
      <timestamp>2013-06-01T05:39:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator=]] to [[Template:cpp/iterator/adaptor/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator{{=}} | assigns another iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator arith</title>
    <ns>10</ns>
    <id>8715</id>
    <revision>
      <id>56687</id>
      <parentid>52975</parentid>
      <timestamp>2013-06-01T05:39:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator arith]] to [[Template:cpp/iterator/adaptor/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="246">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}}&lt;br&gt;operator+=&lt;br&gt;operator+&lt;br&gt;operator--&lt;br&gt;operator--{{dsc small|(int)}}&lt;br&gt;operator-=&lt;br&gt;operator- | advances or decrements the iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator at</title>
    <ns>10</ns>
    <id>8714</id>
    <revision>
      <id>71933</id>
      <parentid>71903</parentid>
      <timestamp>2014-07-02T11:16:47Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="102">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator_at | title=operator[] |  accesses an element by index}}</text>
      <sha1>m3rkcxhe4plq33nb7kolhayczc95rvk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/dsc operator cmp</title>
    <ns>10</ns>
    <id>8720</id>
    <revision>
      <id>56697</id>
      <parentid>52977</parentid>
      <timestamp>2013-06-01T05:39:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/adaptor/dcl list operator cmp]] to [[Template:cpp/iterator/adaptor/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="173">{{dsc tfun | cpp/iterator/{{{1|}}}/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares the underlying iterators }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator*</title>
    <ns>10</ns>
    <id>8727</id>
    <revision>
      <id>60889</id>
      <parentid>52978</parentid>
      <timestamp>2013-06-01T11:59:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="852">{{cpp/iterator/{{{1|}}}/title | operator*,-&gt; }}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 |
reference operator* () const;
}}
{{dcl | num=2 | 
pointer   operator-&gt;() const;
}}
{{dcl end}}

Returns a reference or pointer to the element previous to {{tt|current}}.

@1@ Equivalent to {{c|1=d_tmp = current; --d_tmp; return *d_tmp;}};
@2@ Equivalent to {{c|&amp;(operator*())}}.

===Parameters===
(none)

===Return value===
Reference or pointer to the element previous to {{tt|current}}.

===Notes===
The iterator object contains an auxiliary member variable {{tt|d_tmp}}, not a temporary variable, to avoid returning a reference that persists beyond the lifetime of its associated iterator.

===Example===
{{example
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_at|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator+</title>
    <ns>10</ns>
    <id>5620</id>
    <revision>
      <id>60890</id>
      <parentid>52979</parentid>
      <timestamp>2013-06-01T11:59:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="819">{{title | 1=operator+&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
template&lt; class Iterator &gt; 
reverse_iterator&lt;Iterator&gt; 
    operator+( typename {{{1}}}&lt;Iterator&gt;::difference_type n,
               const {{{1}}}&lt;Iterator&gt;&amp; it );
}}
{{dcl end}}

Returns the iterator {{tt|it}} incremented by {{tt|n}}.

===Parameters===
{{par begin}}
{{par | n | the number of positions to increment the iterator}}
{{par | it | the iterator adaptor to increment}}
{{par end}}

===Return value===
The incremented iterator, that is {{#switch:{{{1|}}}
|move_iterator={{c|{{{1}}}&lt;Iterator&gt;(x.current + n)}}
|reverse_iterator|{{c|{{{1}}}&lt;Iterator&gt;(x.current - n)}}
}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator_arith|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator-</title>
    <ns>10</ns>
    <id>5621</id>
    <revision>
      <id>61903</id>
      <parentid>52980</parentid>
      <timestamp>2013-06-09T16:41:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+dcl rev</comment>
      <text xml:space="preserve" bytes="951">{{title | 1=operator-&lt;small&gt;({{{1}}})&lt;/small&gt;}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl rev begin}}
{{dcl | until=c++11 |
template&lt; class Iterator &gt;
typename reverse_iterator&lt;Iterator&gt;::difference_type 
    operator-( const {{{1|}}}&lt;Iterator&gt;&amp; lhs,
               const {{{1|}}}&lt;Iterator&gt;&amp; rhs );
}}
{{dcl | until=c++11 |
template&lt; class Iterator1, class Iterator2 &gt;
auto operator-( const {{{1|}}}&lt;Iterator1&gt;&amp; lhs,
                const {{{1|}}}&lt;Iterator2&gt;&amp; rhs ) -&gt; decltype({{#switch:{{{1|}}}
|move_iterator=lhs.base() - rhs.base()
|reverse_iterator|rhs.base() - lhs.base()
}});
}}
{{dcl rev end}}
{{dcl end}}

Returns the distance between two iterator adaptors.

===Parameters===
{{par begin}}
{{par | lhs, rhs | iterator adaptors to compute the difference of}}
{{par end}}

===Return value===
{{#switch:{{{1|}}}
|move_iterator={{c|lhs.base() - rhs.base()}}
|reverse_iterator|{{c|rhs.base() - lhs.base()}}
}}

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator=</title>
    <ns>10</ns>
    <id>8721</id>
    <revision>
      <id>62245</id>
      <parentid>60891</parentid>
      <timestamp>2013-06-25T12:35:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="607">{{cpp/iterator/{{{1|}}}/title | operator{{=}} }}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1=
template&lt; class U &gt; 
{{{1|}}}&amp; operator=( const {{{1|}}}&lt;U&gt;&amp; other );
}}
{{dcl end}}

Copy assignment operator. The underlying iterator is assigned the value of the underlying iterator of {{tt|other}}, i.e. {{tt|other.base()}}.

===Parameters===
{{par begin}}
{{par | other | iterator adaptor to assign}}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{example |
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc constructor|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator arith</title>
    <ns>10</ns>
    <id>8734</id>
    <revision>
      <id>63658</id>
      <parentid>60892</parentid>
      <timestamp>2013-07-16T18:09:51Z</timestamp>
      <contributor>
        <username>Dtruby</username>
        <id>2202</id>
      </contributor>
      <comment>operator++ returns the iterator, not a reference to the pointed-to element. See 24.5.1.1 [reverse.iterator]</comment>
      <text xml:space="preserve" bytes="1453">{{cpp/iterator/{{{1|}}}/title | 1=operator++,+,+=,--,-,-= }}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 
{{{1}}}&amp; operator++();
}}
{{dcl | num=2 | 
{{{1}}}&amp; operator--();
}}
{{dcl | num=3 | 
{{{1}}} operator++( int );
}}
{{dcl | num=4 | 
{{{1}}} operator--( int );
}}
{{dcl | num=5 | 
{{{1}}} operator+( difference_type n ) const;
}}
{{dcl | num=6 | 
{{{1}}} operator-( difference_type n ) const;
}}
{{dcl | num=7 | 1=
{{{1}}}&amp; operator+=( difference_type n ) const;
}}
{{dcl | num=8 | 1=
{{{1}}}&amp; operator-=( difference_type n ) const;
}}
{{dcl end}}

Increments or decrements the iterator. {{#ifeq:{{{1|}}}|reverse_iterator|Inverse operations are applied to the underlying operator because of the reverse order.}}
@1-2@ Pre-increments or pre-decrements by one respectively.
@3-4@ Post-increments or post-decrements by one respectively.
@5-6@ Returns an iterator which is advanced by {{tt|n}} or {{tt|-n}} positions respectively.
@7-8@ Advances the iterator by {{tt|n}} or {{tt|-n}} positions respectively.

===Return value===
@1@ {{c|*this}}
@2@ a copy of {{c|*this}} that was made before the change
@3@ {{#switch:{{{1|}}}
|reverse_iterator={{c|{{{1}}}(base()-n)}} or {{c|{{{1}}}(base()+n)}} respectively.
|move_iterator|{{c|{{{1}}}(base()+n)}} or {{c|{{{1}}}(base()-n)}} respectively.
}}
@4@ {{c|*this}}

===Example===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator+|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator at</title>
    <ns>10</ns>
    <id>8729</id>
    <revision>
      <id>71904</id>
      <parentid>62246</parentid>
      <timestamp>2014-07-01T13:24:36Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="745">{{cpp/iterator/{{{1|}}}/title|operator[]}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} | 1=
/*unspecified*/ operator[]( difference_type n ) const; 
}}
{{dcl end}}

Returns a reference to the element at specified relative location.

===Parameters===
{{par begin}}
{{par | n | position relative to current location.}}
{{par end}}

===Return value===
{{#switch:{{{1|}}}
 |reverse_iterator=A reference to the element at relative location, that is, {{c| current[-n-1]}}
 |move_iterator=An rvalue reference to the element at relative location, that is, {{c|std::move(current[n])}}
}}.

===Examples===
{{example}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/iterator/adaptor/dsc operator*|{{{1|}}}}}`
{{dsc end}}</text>
      <sha1>jwj0uh1q4wwdqr9v49ukxsny7601iez</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/adaptor/operator cmp</title>
    <ns>10</ns>
    <id>8732</id>
    <revision>
      <id>52984</id>
      <parentid>39317</parentid>
      <timestamp>2013-06-01T04:57:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1859">{{title | 1=operator&lt;,&lt;{{=}},&gt;,&gt;{{=}}&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator==( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                 const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl | num=2 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator!=( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                 const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl | num=3 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator&lt;( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl | num=4 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator&lt;=( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                 const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl | num=5 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator&gt;( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl | num=6 | 1=
template&lt; class Iterator1, class Iterator2 &gt;
bool operator&gt;=( const {{{1}}}&lt;Iterator1&gt;&amp; lhs,
                 const {{{1}}}&lt;Iterator2&gt;&amp; rhs );
}}
{{dcl end}}

Compares the underlying iterators. {{#ifeq:{{{1|}}}|reverse_iterator| Inverse comparisons are applied in order to take into account that the iterator order is reversed.}}

===Parameters===
{{par begin}}
{{par | lhs, rhs | iterator adaptors to compare}}
{{par end}}

===Return Value===
@1@ {{c|1= lhs.base() == rhs.base()}}
@2@ {{c|1= lhs.base() != rhs.base()}}
{{#switch:{{{1|}}}
|move_iterator=
@3@ {{c|1= lhs.base() &lt; rhs.base()}}
@4@ {{c|1= lhs.base() &lt;= rhs.base()}}
@5@ {{c|1= lhs.base() &gt; rhs.base()}}
@6@ {{c|1= lhs.base() &gt;= rhs.base()}}
|reverse_iterator|
@3@ {{c|1= lhs.base() &gt; rhs.base()}}
@4@ {{c|1= lhs.base() &gt;= rhs.base()}}
@5@ {{c|1= lhs.base() &lt; rhs.base()}}
@6@ {{c|1= lhs.base() &lt;= rhs.base()}}
}}

===Example===
{{example}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/back insert iterator/navbar</title>
    <ns>10</ns>
    <id>4950</id>
    <revision>
      <id>39932</id>
      <parentid>35712</parentid>
      <timestamp>2012-09-28T20:10:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="278">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/back_insert_iterator/navbar heading
|content3 = cpp/iterator/back_insert_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/back insert iterator/navbar content</title>
    <ns>10</ns>
    <id>4952</id>
    <revision>
      <id>52985</id>
      <parentid>35446</parentid>
      <timestamp>2013-06-01T04:57:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="335">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/back_insert_iterator/back_insert_iterator}}
{{nv mem ln | cpp/iterator/back_insert_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/back_insert_iterator/operator*}}
{{nv mem ln | cpp/iterator/back_insert_iterator/operator++|operator++|operator++(int)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/back insert iterator/navbar heading</title>
    <ns>10</ns>
    <id>4951</id>
    <revision>
      <id>48098</id>
      <parentid>35713</parentid>
      <timestamp>2013-05-18T18:12:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="67">{{ltt|cpp/iterator/back_insert_iterator|std::back_insert_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/back insert iterator/title</title>
    <ns>10</ns>
    <id>8479</id>
    <revision>
      <id>31262</id>
      <timestamp>2012-05-17T03:03:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=back_insert_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc advance</title>
    <ns>10</ns>
    <id>2694</id>
    <revision>
      <id>56701</id>
      <parentid>52986</parentid>
      <timestamp>2013-06-01T05:40:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list advance]] to [[Template:cpp/iterator/dsc advance]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc fun | cpp/iterator/advance | advances an iterator by given distance }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc back insert iterator</title>
    <ns>10</ns>
    <id>4840</id>
    <revision>
      <id>56705</id>
      <parentid>52987</parentid>
      <timestamp>2013-06-01T05:40:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list back insert iterator]] to [[Template:cpp/iterator/dsc back insert iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tclass | cpp/iterator/back_insert_iterator | iterator adaptor for insertion at the end of a container }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc back inserter</title>
    <ns>10</ns>
    <id>4841</id>
    <revision>
      <id>56710</id>
      <parentid>52988</parentid>
      <timestamp>2013-06-01T05:40:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list back inserter]] to [[Template:cpp/iterator/dsc back inserter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tfun | cpp/iterator/back_inserter | creates a {{lc|std::back_insert_iterator}} of type inferred from the argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc begin</title>
    <ns>10</ns>
    <id>2570</id>
    <revision>
      <id>56713</id>
      <parentid>52989</parentid>
      <timestamp>2013-06-01T05:40:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list begin]] to [[Template:cpp/iterator/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc fun | cpp/iterator/begin | title=begin&lt;br/&gt;cbegin | returns an iterator to the beginning of a container or array| notes={{mark c++11}}&lt;br/&gt;{{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc distance</title>
    <ns>10</ns>
    <id>2695</id>
    <revision>
      <id>56718</id>
      <parentid>52990</parentid>
      <timestamp>2013-06-01T05:40:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list distance]] to [[Template:cpp/iterator/dsc distance]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | cpp/iterator/distance | returns the distance between two iterators }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc end</title>
    <ns>10</ns>
    <id>2571</id>
    <revision>
      <id>56723</id>
      <parentid>52991</parentid>
      <timestamp>2013-06-01T05:40:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list end]] to [[Template:cpp/iterator/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc fun | cpp/iterator/end | title=end&lt;br/&gt;cend | returns an iterator to the end of a container or array | notes={{mark c++11}}&lt;br/&gt;{{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc front insert iterator</title>
    <ns>10</ns>
    <id>4842</id>
    <revision>
      <id>56728</id>
      <parentid>52992</parentid>
      <timestamp>2013-06-01T05:40:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list front insert iterator]] to [[Template:cpp/iterator/dsc front insert iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tclass | cpp/iterator/front_insert_iterator | iterator adaptor for insertion at the front of a container }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc front inserter</title>
    <ns>10</ns>
    <id>4843</id>
    <revision>
      <id>56733</id>
      <parentid>52993</parentid>
      <timestamp>2013-06-01T05:40:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list front inserter]] to [[Template:cpp/iterator/dsc front inserter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/iterator/front_inserter | creates a {{lc|std::front_insert_iterator}} of type inferred from the argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc insert iterator</title>
    <ns>10</ns>
    <id>4844</id>
    <revision>
      <id>56738</id>
      <parentid>52994</parentid>
      <timestamp>2013-06-01T05:40:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list insert iterator]] to [[Template:cpp/iterator/dsc insert iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tclass | cpp/iterator/insert_iterator | iterator adaptor for insertion into a container}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc inserter</title>
    <ns>10</ns>
    <id>4845</id>
    <revision>
      <id>56742</id>
      <parentid>52995</parentid>
      <timestamp>2013-06-01T05:40:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list inserter]] to [[Template:cpp/iterator/dsc inserter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc tfun | cpp/iterator/inserter | creates a {{lc|std::insert_iterator}} of type inferred from the argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc istream iterator</title>
    <ns>10</ns>
    <id>4846</id>
    <revision>
      <id>56747</id>
      <parentid>52996</parentid>
      <timestamp>2013-06-01T05:40:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list istream iterator]] to [[Template:cpp/iterator/dsc istream iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc tclass | cpp/iterator/istream_iterator | input iterator that reads from {{lc|std::basic_istream}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc istreambuf iterator</title>
    <ns>10</ns>
    <id>4848</id>
    <revision>
      <id>56751</id>
      <parentid>52997</parentid>
      <timestamp>2013-06-01T05:40:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list istreambuf iterator]] to [[Template:cpp/iterator/dsc istreambuf iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tclass | cpp/iterator/istreambuf_iterator | input iterator that reads from {{lc|std::basic_streambuf}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc iterator</title>
    <ns>10</ns>
    <id>4852</id>
    <revision>
      <id>56756</id>
      <parentid>52998</parentid>
      <timestamp>2013-06-01T05:40:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list iterator]] to [[Template:cpp/iterator/dsc iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">{{dsc tclass | cpp/iterator/iterator | the basic iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc iterator tags</title>
    <ns>10</ns>
    <id>4851</id>
    <revision>
      <id>56761</id>
      <parentid>52999</parentid>
      <timestamp>2013-06-01T05:40:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list iterator tags]] to [[Template:cpp/iterator/dsc iterator tags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="232">{{dsc class | cpp/iterator/iterator_tags | title=input_iterator_tag&lt;br&gt;output_iterator_tag&lt;br&gt;forward_iterator_tag&lt;br&gt;bidirectional_iterator_tag&lt;br&gt;random_access_iterator_tag| empty class types used to indicate iterator categories}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc iterator traits</title>
    <ns>10</ns>
    <id>4850</id>
    <revision>
      <id>56766</id>
      <parentid>53000</parentid>
      <timestamp>2013-06-01T05:40:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list iterator traits]] to [[Template:cpp/iterator/dsc iterator traits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tclass | cpp/iterator/iterator_traits | provides uniform interface to the properties of an iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc make move iterator</title>
    <ns>10</ns>
    <id>4839</id>
    <revision>
      <id>56771</id>
      <parentid>53001</parentid>
      <timestamp>2013-06-01T05:41:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list make move iterator]] to [[Template:cpp/iterator/dsc make move iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/iterator/make_move_iterator | creates a {{lc|std::move_iterator}} of type inferred from the argument|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc make reverse iterator</title>
    <ns>10</ns>
    <id>13166</id>
    <revision>
      <id>67805</id>
      <timestamp>2014-02-28T16:48:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>late-in-the-game c++14 addition, pushed in as LWG defect</comment>
      <text xml:space="preserve" bytes="146">{{dsc tfun | cpp/iterator/make_reverse_iterator | creates a {{lc|std::reverse_iterator}} of type inferred from the argument|notes={{mark c++14}}}}</text>
      <sha1>jwqjwtk29heeelljn9r1wsbo8z3v4pd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc move iterator</title>
    <ns>10</ns>
    <id>4838</id>
    <revision>
      <id>56775</id>
      <parentid>53002</parentid>
      <timestamp>2013-06-01T05:41:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list move iterator]] to [[Template:cpp/iterator/dsc move iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc tclass | cpp/iterator/move_iterator | iterator adaptor which dereferences to an rvalue reference |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc next</title>
    <ns>10</ns>
    <id>2738</id>
    <revision>
      <id>56780</id>
      <parentid>53003</parentid>
      <timestamp>2013-06-01T05:41:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list next]] to [[Template:cpp/iterator/dsc next]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/iterator/next | increment an iterator | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc ostream iterator</title>
    <ns>10</ns>
    <id>4847</id>
    <revision>
      <id>56784</id>
      <parentid>53004</parentid>
      <timestamp>2013-06-01T05:41:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list ostream iterator]] to [[Template:cpp/iterator/dsc ostream iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc tclass | cpp/iterator/ostream_iterator | output iterator that writes to {{lc|std::basic_ostream}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc ostreambuf iterator</title>
    <ns>10</ns>
    <id>4849</id>
    <revision>
      <id>56788</id>
      <parentid>53005</parentid>
      <timestamp>2013-06-01T05:41:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list ostreambuf iterator]] to [[Template:cpp/iterator/dsc ostreambuf iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tclass | cpp/iterator/ostreambuf_iterator | output iterator that writes to {{lc|std::basic_streambuf}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc prev</title>
    <ns>10</ns>
    <id>2737</id>
    <revision>
      <id>56793</id>
      <parentid>53006</parentid>
      <timestamp>2013-06-01T05:41:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list prev]] to [[Template:cpp/iterator/dsc prev]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | cpp/iterator/prev | decrement an iterator |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc rbegin</title>
    <ns>10</ns>
    <id>9995</id>
    <revision>
      <id>56798</id>
      <parentid>53007</parentid>
      <timestamp>2013-06-01T05:41:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list rbegin]] to [[Template:cpp/iterator/dsc rbegin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | cpp/iterator/rbegin | title=rbegin&lt;br/&gt;crbegin | returns a reverse iterator to a container or array| notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc rend</title>
    <ns>10</ns>
    <id>9996</id>
    <revision>
      <id>56803</id>
      <parentid>53008</parentid>
      <timestamp>2013-06-01T05:41:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list rend]] to [[Template:cpp/iterator/dsc rend]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc fun | cpp/iterator/rend | title=rend&lt;br/&gt;crend | returns a reverse end iterator for a container or array| notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/dsc reverse iterator</title>
    <ns>10</ns>
    <id>4837</id>
    <revision>
      <id>56807</id>
      <parentid>53009</parentid>
      <timestamp>2013-06-01T05:41:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/dcl list reverse iterator]] to [[Template:cpp/iterator/dsc reverse iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc tclass | cpp/iterator/reverse_iterator | iterator adaptor for reverse-order traversal}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/front insert iterator/navbar</title>
    <ns>10</ns>
    <id>4954</id>
    <revision>
      <id>39933</id>
      <parentid>35714</parentid>
      <timestamp>2012-09-28T20:10:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="280">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/front_insert_iterator/navbar heading
|content3 = cpp/iterator/front_insert_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/front insert iterator/navbar content</title>
    <ns>10</ns>
    <id>4956</id>
    <revision>
      <id>53010</id>
      <parentid>35715</parentid>
      <timestamp>2013-06-01T04:57:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="340">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/front_insert_iterator/front_insert_iterator}}
{{nv mem ln | cpp/iterator/front_insert_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/front_insert_iterator/operator*}}
{{nv mem ln | cpp/iterator/front_insert_iterator/operator++|operator++|operator++(int)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/front insert iterator/navbar heading</title>
    <ns>10</ns>
    <id>4955</id>
    <revision>
      <id>48099</id>
      <parentid>35716</parentid>
      <timestamp>2013-05-18T18:12:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="69">{{ltt|cpp/iterator/front_insert_iterator|std::front_insert_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/front insert iterator/title</title>
    <ns>10</ns>
    <id>8480</id>
    <revision>
      <id>31263</id>
      <timestamp>2012-05-17T03:03:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">&lt;onlyinclude&gt;{{cpp/title | n=front_insert_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/insert iterator/navbar</title>
    <ns>10</ns>
    <id>4958</id>
    <revision>
      <id>39934</id>
      <parentid>35718</parentid>
      <timestamp>2012-09-28T20:10:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="268">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/insert_iterator/navbar heading
|content3 = cpp/iterator/insert_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/insert iterator/navbar content</title>
    <ns>10</ns>
    <id>4960</id>
    <revision>
      <id>53011</id>
      <parentid>35719</parentid>
      <timestamp>2013-06-01T04:57:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="310">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/insert_iterator/insert_iterator}}
{{nv mem ln | cpp/iterator/insert_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/insert_iterator/operator*}}
{{nv mem ln | cpp/iterator/insert_iterator/operator++|operator++|operator++(int)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/insert iterator/navbar heading</title>
    <ns>10</ns>
    <id>4959</id>
    <revision>
      <id>48101</id>
      <parentid>34605</parentid>
      <timestamp>2013-05-18T18:12:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="57">{{ltt|cpp/iterator/insert_iterator|std::insert_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/insert iterator/title</title>
    <ns>10</ns>
    <id>8481</id>
    <revision>
      <id>31264</id>
      <timestamp>2012-05-17T03:03:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=insert_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/constructor</title>
    <ns>10</ns>
    <id>8758</id>
    <revision>
      <id>68843</id>
      <parentid>68842</parentid>
      <timestamp>2014-03-22T17:03:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/tt/lc</comment>
      <text xml:space="preserve" bytes="568">{{cpp/iterator/{{{1|}}}/title|{{{1}}}}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1=
explicit {{{1}}}( Container&amp; c{{#ifeq:{{{1|}}}|insert_iterator|, typename Container::iterator i}} );
}}
{{dcl end}}

Initializes the underlying pointer to the container to {{lc|std::addressof(c)}} {{#ifeq:{{{1|}}}|insert_iterator|and the interlying iterator to {{tt|iter}}}}.

===Parameters===
{{par begin}}
{{par | c | container to initialize the inserter with}}
{{#ifeq:{{{1|}}}|insert_iterator|
{{par | iter | iterator to initialize the inserter with}}
}}
{{par end}}</text>
      <sha1>inzl2duly432tsntkx0o2e8f87hszf8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/dsc constructor</title>
    <ns>10</ns>
    <id>8742</id>
    <revision>
      <id>56812</id>
      <parentid>53013</parentid>
      <timestamp>2013-06-01T05:41:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/inserter/dcl list constructor]] to [[Template:cpp/iterator/inserter/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem ctor | cpp/iterator/{{{1|}}}/{{{1|}}} | constructs a new {{tt|{{{1}}}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/dsc operator*</title>
    <ns>10</ns>
    <id>8744</id>
    <revision>
      <id>56816</id>
      <parentid>53014</parentid>
      <timestamp>2013-06-01T05:41:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/inserter/dcl list operator*]] to [[Template:cpp/iterator/inserter/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator* | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/dsc operator=</title>
    <ns>10</ns>
    <id>8743</id>
    <revision>
      <id>56821</id>
      <parentid>53015</parentid>
      <timestamp>2013-06-01T05:41:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/inserter/dcl list operator=]] to [[Template:cpp/iterator/inserter/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator{{=}} | inserts an object into the associated container }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/dsc operator arith</title>
    <ns>10</ns>
    <id>8745</id>
    <revision>
      <id>56826</id>
      <parentid>53016</parentid>
      <timestamp>2013-06-01T05:41:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/inserter/dcl list operator arith]] to [[Template:cpp/iterator/inserter/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/iterator/{{{1|}}}/operator++ | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/operator*</title>
    <ns>10</ns>
    <id>8760</id>
    <revision>
      <id>62248</id>
      <parentid>38275</parentid>
      <timestamp>2013-06-25T12:36:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="457">{{cpp/iterator/{{{1|}}}/title|operator*}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 
{{{1}}}&amp; operator*();
}}
{{dcl end}}

Does nothing, this member function is provided to satisfy the requirements of {{concept|OutputIterator}}.

It returns the iterator itself, which makes it possible to use code such as {{c|1=*iter = value}} to output (insert) the value into the underlying container.

===Parameters===
(none)

===Return value===
{{c|*this}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/operator++</title>
    <ns>10</ns>
    <id>8761</id>
    <revision>
      <id>53017</id>
      <parentid>38279</parentid>
      <timestamp>2013-06-01T04:57:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="508">{{cpp/iterator/{{{1|}}}/title|operator++}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1=
{{{1}}}&amp; operator++();
}}
{{dcl | 1=
{{{1}}}&amp; operator++( int );
}}
{{dcl end}}

Does nothing. These operator overloads are provided to satisfy the requirements of {{concept|OutputIterator}}. They make it possible for the expressions {{c|1=*iter++=value}} and {{c|1=*++iter=value}} to be used to output (insert) a value into the underlying container.

===Parameters===
(none)

===Return value===
{{c|*this}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/inserter/operator=</title>
    <ns>10</ns>
    <id>8759</id>
    <revision>
      <id>53018</id>
      <parentid>46976</parentid>
      <timestamp>2013-06-01T04:58:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="964">{{cpp/iterator/{{{1|}}}/title|operator{{=}}}}
{{cpp/iterator/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
{{{1}}}&lt;Container&gt;&amp;
    operator=( const typename Container::value_type&amp; value );
}}
{{dcl | num=2 | 1=
{{{1}}}&lt;Container&gt;&amp;
    operator=( typename Container::value_type&amp;&amp; value );
}}
{{dcl end}}

Inserts the given value {{tt|value}} to the container.

{{#switch:{{{1|}}}
|insert_iterator=
@1@ Results in {{c|iter {{=}} container-&gt;insert(iter, value); ++iter;}}
@2@ Results in {{c|iter {{=}} container-&gt;insert(iter, std::move(value)); ++iter;}}
|back_insert_iterator=
@1@ Results in {{c|container-&gt;push_back(value)}}
@2@ Results in {{c|container-&gt;push_back(std::move(value))}}
|front_insert_iterator|
@1@ Results in {{c|container-&gt;push_front(value)}}
@2@ Results in {{c|container-&gt;push_front(std::move(value))}}
}}

===Parameters===
{{par begin}}
{{par | value | the value to insert}}
{{par end}}

===Return value===
{{c|*this}}

===Example===
{{todo}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10147</id>
    <revision>
      <id>56831</id>
      <parentid>53019</parentid>
      <timestamp>2013-06-01T05:41:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/istream iterator/dcl list constructor]] to [[Template:cpp/iterator/istream iterator/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem ctor | cpp/iterator/istream_iterator/istream_iterator | constructs a new istream_iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/dsc destructor</title>
    <ns>10</ns>
    <id>10148</id>
    <revision>
      <id>56836</id>
      <parentid>53020</parentid>
      <timestamp>2013-06-01T05:41:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/istream iterator/dcl list destructor]] to [[Template:cpp/iterator/istream iterator/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc mem dtor | nolink=true| destructs an istream_iterator, including the cached value | notes={{mark implicit}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10149</id>
    <revision>
      <id>61414</id>
      <parentid>56841</parentid>
      <timestamp>2013-06-05T23:58:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="119">{{dsc mem fun | cpp/iterator/istream_iterator/operator* | title=operator*&lt;br&gt;operator-&gt; | returns the current element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10150</id>
    <revision>
      <id>56846</id>
      <parentid>53022</parentid>
      <timestamp>2013-06-01T05:42:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/istream iterator/dcl list operator arith]] to [[Template:cpp/iterator/istream iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/iterator/istream_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | advances the iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/dsc operator cmp</title>
    <ns>10</ns>
    <id>10151</id>
    <revision>
      <id>61080</id>
      <parentid>56851</parentid>
      <timestamp>2013-06-05T10:39:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/iterator/istream_iterator/operator_cmp | title=operator==&lt;br&gt;operator!= | compares two {{tt|istream_iterator}}s }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/navbar</title>
    <ns>10</ns>
    <id>4910</id>
    <revision>
      <id>39935</id>
      <parentid>35720</parentid>
      <timestamp>2012-09-28T20:10:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="270">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/istream_iterator/navbar heading
|content3 = cpp/iterator/istream_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/navbar content</title>
    <ns>10</ns>
    <id>4912</id>
    <revision>
      <id>53024</id>
      <parentid>48437</parentid>
      <timestamp>2013-06-01T04:58:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="398">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/istream_iterator/istream_iterator}}
{{nv mem ln | cpp/iterator/istream_iterator/operator*|operator*|operator-&gt;}}
{{nv mem ln | cpp/iterator/istream_iterator/operator_arith|operator++|operator++(int)}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/iterator/istream_iterator/operator_cmp|operator{{==}}|operator!{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/navbar heading</title>
    <ns>10</ns>
    <id>4911</id>
    <revision>
      <id>48108</id>
      <parentid>33247</parentid>
      <timestamp>2013-05-18T18:13:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="59">{{ltt|cpp/iterator/istream_iterator|std::istream_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istream iterator/title</title>
    <ns>10</ns>
    <id>8482</id>
    <revision>
      <id>31265</id>
      <timestamp>2012-05-17T03:04:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=istream_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10141</id>
    <revision>
      <id>61398</id>
      <parentid>56856</parentid>
      <timestamp>2013-06-05T23:01:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem ctor | cpp/iterator/istreambuf_iterator/istreambuf_iterator | constructs a new {{tt|istreambuf_iterator}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc destructor</title>
    <ns>10</ns>
    <id>10142</id>
    <revision>
      <id>61399</id>
      <parentid>56860</parentid>
      <timestamp>2013-06-05T23:01:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem dtor | nolink=true| destructs an {{tt|istreambuf_iterator}} | notes={{mark implicit}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc equal</title>
    <ns>10</ns>
    <id>10145</id>
    <revision>
      <id>61405</id>
      <parentid>56865</parentid>
      <timestamp>2013-06-05T23:10:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/iterator/istreambuf_iterator/equal | tests if both {{tt|istreambuf_iterator}}s are end-of-stream or if both are valid}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10143</id>
    <revision>
      <id>56870</id>
      <parentid>53028</parentid>
      <timestamp>2013-06-01T05:42:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/istreambuf iterator/dcl list operator*]] to [[Template:cpp/iterator/istreambuf iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="242">{{dsc mem fun | cpp/iterator/istreambuf_iterator/operator* | title=operator*&lt;br&gt;operator-&gt; | obtains a copy of the current character&lt;br&gt;accesses a member of the current character, if {{tt|CharT}} has members | notes=&lt;br&gt;{{mark since c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10144</id>
    <revision>
      <id>56875</id>
      <parentid>53029</parentid>
      <timestamp>2013-06-01T05:42:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/istreambuf iterator/dcl list operator arith]] to [[Template:cpp/iterator/istreambuf iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc mem fun | cpp/iterator/istreambuf_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | advances the iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/dsc operator cmp</title>
    <ns>10</ns>
    <id>10146</id>
    <revision>
      <id>61409</id>
      <parentid>56880</parentid>
      <timestamp>2013-06-05T23:26:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/iterator/istreambuf_iterator/operator_cmp | title=operator==&lt;br&gt;operator!= | compares two {{tt|istreambuf_iterator}}s }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/navbar</title>
    <ns>10</ns>
    <id>4857</id>
    <revision>
      <id>39936</id>
      <parentid>35722</parentid>
      <timestamp>2012-09-28T20:10:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="276">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/istreambuf_iterator/navbar heading
|content3 = cpp/iterator/istreambuf_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/navbar content</title>
    <ns>10</ns>
    <id>4859</id>
    <revision>
      <id>61397</id>
      <parentid>53031</parentid>
      <timestamp>2013-06-05T23:00:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="493">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/istreambuf_iterator/istreambuf_iterator}}
{{nv mem ln | cpp/iterator/istreambuf_iterator/operator*|operator*|operator-&gt;|notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/iterator/istreambuf_iterator/operator_arith|operator++|operator++(int)}}
{{nv mem ln | cpp/iterator/istreambuf_iterator/equal}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/iterator/istreambuf_iterator/operator_cmp|operator{{==}}|operator!{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/navbar heading</title>
    <ns>10</ns>
    <id>4858</id>
    <revision>
      <id>48109</id>
      <parentid>35723</parentid>
      <timestamp>2013-05-18T18:13:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="65">{{ltt|cpp/iterator/istreambuf_iterator|std::istreambuf_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/istreambuf iterator/title</title>
    <ns>10</ns>
    <id>8484</id>
    <revision>
      <id>31268</id>
      <timestamp>2012-05-17T03:05:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=istreambuf_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/iterator/inherit</title>
    <ns>10</ns>
    <id>4908</id>
    <revision>
      <id>53032</id>
      <parentid>32320</parentid>
      <timestamp>2013-06-01T04:58:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="399">{{inherited | [[cpp/iterator/iterator | {{small|std::}}iterator]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|value_type}} | {{c|{{{2|}}} }} }}
{{dsc | {{tt|difference_type}} | {{c|{{{3|}}} }} }}
{{dsc | {{tt|pointer}} | {{c|{{{4|}}} }} }}
{{dsc | {{tt|reference}} | {{c|{{{5|}}} }} }}
{{dsc | {{tt|iterator_category}} | {{c|{{{1|}}} }} }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/move iterator/navbar</title>
    <ns>10</ns>
    <id>4931</id>
    <revision>
      <id>39937</id>
      <parentid>35495</parentid>
      <timestamp>2012-09-28T20:11:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="264">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/move_iterator/navbar heading
|content3 = cpp/iterator/move_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/move iterator/navbar content</title>
    <ns>10</ns>
    <id>4933</id>
    <revision>
      <id>53033</id>
      <parentid>36923</parentid>
      <timestamp>2013-06-01T04:58:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="767">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/move_iterator/move_iterator}}
{{nv mem ln | cpp/iterator/move_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/move_iterator/base}}
{{nv mem ln | cpp/iterator/move_iterator/operator* | operator* | operator-&gt;}}
{{nv mem ln | cpp/iterator/move_iterator/operator_at|operator[]}}
{{nv mem ln | cpp/iterator/move_iterator/operator_arith|operator++|operator+|operator+{{=}}|operator--|operator-|operator-{{=}}}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/iterator/move_iterator/operator_cmp|operator{{==}}|operator!{{=}}|operator&lt;|operator&lt;=|operator&gt;|operator&gt;=}}
{{nv ln | cpp/iterator/move_iterator/operator+ | operator+}}
{{nv ln | cpp/iterator/move_iterator/operator- | operator-}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/move iterator/navbar heading</title>
    <ns>10</ns>
    <id>4932</id>
    <revision>
      <id>71902</id>
      <parentid>48096</parentid>
      <timestamp>2014-07-01T13:15:09Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>correct</comment>
      <text xml:space="preserve" bytes="53">{{ltt|cpp/iterator/move_iterator|std::move_iterator}}</text>
      <sha1>kelyzphul7zwg39bhzzksd6ou0tyi9o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/move iterator/title</title>
    <ns>10</ns>
    <id>8477</id>
    <revision>
      <id>31242</id>
      <timestamp>2012-05-16T15:34:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=move_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/navbar</title>
    <ns>10</ns>
    <id>1578</id>
    <revision>
      <id>39938</id>
      <parentid>35733</parentid>
      <timestamp>2012-09-28T20:11:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="156">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/navbar content</title>
    <ns>10</ns>
    <id>2150</id>
    <revision>
      <id>67839</id>
      <parentid>53034</parentid>
      <timestamp>2014-03-02T17:48:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>make_reverse_iterator</comment>
      <text xml:space="preserve" bytes="1640">{{nv begin}}

{{nv h1 | Iterator primitives}}
{{nv ln | cpp/iterator/iterator_traits}}
{{nv ln | cpp/iterator/iterator_tags|input_iterator_tag|output_iterator_tag|forward_iterator_tag|bidirectional_iterator_tag|random_access_iterator_tag}}
{{nv ln | cpp/iterator/iterator}}

{{nv h1 | Iterator adaptors}}
{{nv col begin}}
{{nv ln | cpp/iterator/reverse_iterator}}
{{nv ln | cpp/iterator/move_iterator | notes={{mark c++11}}}}
{{nv ln | cpp/iterator/back_insert_iterator}}
{{nv ln | cpp/iterator/front_insert_iterator}}
{{nv ln | cpp/iterator/insert_iterator}}
{{nv col next}}
{{nv ln | cpp/iterator/make_reverse_iterator| notes={{mark c++14}}}}
{{nv ln | cpp/iterator/make_move_iterator | notes={{mark c++11}}}}
{{nv ln | cpp/iterator/back_inserter}}
{{nv ln | cpp/iterator/front_inserter}}
{{nv ln | cpp/iterator/inserter}}
{{nv col end}}

{{nv h1 | Stream iterators}}
{{nv ln | cpp/iterator/istream_iterator}}
{{nv ln | cpp/iterator/ostream_iterator}}
{{nv ln | cpp/iterator/istreambuf_iterator}}
{{nv ln | cpp/iterator/ostreambuf_iterator}}

{{nv h1 | Iterator operations}}
{{nv ln | cpp/iterator/advance}}
{{nv ln | cpp/iterator/distance}}
{{nv ln | cpp/iterator/prev | notes={{mark c++11}}}}
{{nv ln | cpp/iterator/next | notes={{mark c++11}}}}

{{nv h1 | Range access}}
{{nv ln | cpp/iterator/begin | begin | cbegin | notes={{mark c++11}}&lt;br/&gt;{{mark c++14}}}}
{{nv ln | cpp/iterator/end | end | cend | notes={{mark c++11}}&lt;br/&gt;{{mark c++14}}}}
{{nv ln | cpp/iterator/rbegin | rbegin | crbegin | notes={{mark c++14}}&lt;br/&gt;{{mark c++14}}}}
{{nv ln | cpp/iterator/rend | rend | crend | notes={{mark c++14}}&lt;br/&gt;{{mark c++14}}}}
{{nv end}}</text>
      <sha1>lushifrbzfynnb9xbqxlepnawdj6fuu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/navbar heading</title>
    <ns>10</ns>
    <id>1579</id>
    <revision>
      <id>35735</id>
      <parentid>3158</parentid>
      <timestamp>2012-06-15T22:30:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/sidebar heading]] to [[Template:cpp/iterator/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="35">[[cpp/iterator | Iterator library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10165</id>
    <revision>
      <id>56884</id>
      <parentid>53035</parentid>
      <timestamp>2013-06-01T05:42:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostream iterator/dcl list constructor]] to [[Template:cpp/iterator/ostream iterator/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem ctor | cpp/iterator/ostream_iterator/ostream_iterator | constructs a new ostream_iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/dsc destructor</title>
    <ns>10</ns>
    <id>10166</id>
    <revision>
      <id>56889</id>
      <parentid>53036</parentid>
      <timestamp>2013-06-01T05:42:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostream iterator/dcl list destructor]] to [[Template:cpp/iterator/ostream iterator/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem dtor | cpp/iterator/ostream_iterator/~ostream_iterator | destructs an {{tt|ostream_iterator}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10168</id>
    <revision>
      <id>56894</id>
      <parentid>53037</parentid>
      <timestamp>2013-06-01T05:42:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostream iterator/dcl list operator*]] to [[Template:cpp/iterator/ostream iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/iterator/ostream_iterator/operator* | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/dsc operator=</title>
    <ns>10</ns>
    <id>10167</id>
    <revision>
      <id>56899</id>
      <parentid>53038</parentid>
      <timestamp>2013-06-01T05:42:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostream iterator/dcl list operator=]] to [[Template:cpp/iterator/ostream iterator/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem fun | cpp/iterator/ostream_iterator/operator{{=}} | writes a object to the associated output sequence }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10169</id>
    <revision>
      <id>56904</id>
      <parentid>53039</parentid>
      <timestamp>2013-06-01T05:42:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostream iterator/dcl list operator arith]] to [[Template:cpp/iterator/ostream iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/iterator/ostream_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/navbar</title>
    <ns>10</ns>
    <id>4914</id>
    <revision>
      <id>39939</id>
      <parentid>35726</parentid>
      <timestamp>2012-09-28T20:11:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="270">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/ostream_iterator/navbar heading
|content3 = cpp/iterator/ostream_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/navbar content</title>
    <ns>10</ns>
    <id>4916</id>
    <revision>
      <id>53040</id>
      <parentid>48461</parentid>
      <timestamp>2013-06-01T04:58:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="383">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/ostream_iterator/ostream_iterator}}
{{nv mem ln | cpp/iterator/ostream_iterator/~ostream_iterator}}
{{nv mem ln | cpp/iterator/ostream_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/ostream_iterator/operator*}}
{{nv mem ln | cpp/iterator/ostream_iterator/operator_arith|operator++|operator++(int)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/navbar heading</title>
    <ns>10</ns>
    <id>4915</id>
    <revision>
      <id>48107</id>
      <parentid>33628</parentid>
      <timestamp>2013-05-18T18:13:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="59">{{ltt|cpp/iterator/ostream_iterator|std::ostream_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostream iterator/title</title>
    <ns>10</ns>
    <id>8483</id>
    <revision>
      <id>31267</id>
      <parentid>31266</parentid>
      <timestamp>2012-05-17T03:04:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=ostream_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10158</id>
    <revision>
      <id>61401</id>
      <parentid>56909</parentid>
      <timestamp>2013-06-05T23:03:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem ctor | cpp/iterator/ostreambuf_iterator/ostreambuf_iterator | constructs a new {{tt|ostreambuf_iterator}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc destructor</title>
    <ns>10</ns>
    <id>10159</id>
    <revision>
      <id>61402</id>
      <parentid>56914</parentid>
      <timestamp>2013-06-05T23:03:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem dtor | nolink=true| destructs an {{tt|ostreambuf_iterator}} | notes={{mark implicit}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc failed</title>
    <ns>10</ns>
    <id>10163</id>
    <revision>
      <id>56918</id>
      <parentid>53043</parentid>
      <timestamp>2013-06-01T05:43:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostreambuf iterator/dcl list failed]] to [[Template:cpp/iterator/ostreambuf iterator/dsc failed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/iterator/ostreambuf_iterator/failed | tests if output failed}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10161</id>
    <revision>
      <id>56921</id>
      <parentid>53044</parentid>
      <timestamp>2013-06-01T05:43:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostreambuf iterator/dcl list operator*]] to [[Template:cpp/iterator/ostreambuf iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/iterator/ostreambuf_iterator/operator* | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc operator=</title>
    <ns>10</ns>
    <id>10160</id>
    <revision>
      <id>56924</id>
      <parentid>53045</parentid>
      <timestamp>2013-06-01T05:43:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostreambuf iterator/dcl list operator=]] to [[Template:cpp/iterator/ostreambuf iterator/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/iterator/ostreambuf_iterator/operator{{=}} | writes a character to the associated output sequence }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10162</id>
    <revision>
      <id>56928</id>
      <parentid>53046</parentid>
      <timestamp>2013-06-01T05:43:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/ostreambuf iterator/dcl list operator arith]] to [[Template:cpp/iterator/ostreambuf iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem fun | cpp/iterator/ostreambuf_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | no-op }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/navbar</title>
    <ns>10</ns>
    <id>4904</id>
    <revision>
      <id>39940</id>
      <parentid>35728</parentid>
      <timestamp>2012-09-28T20:11:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="276">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/ostreambuf_iterator/navbar heading
|content3 = cpp/iterator/ostreambuf_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/navbar content</title>
    <ns>10</ns>
    <id>4906</id>
    <revision>
      <id>53047</id>
      <parentid>48462</parentid>
      <timestamp>2013-06-01T04:58:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="390">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/ostreambuf_iterator/ostreambuf_iterator}}
{{nv mem ln | cpp/iterator/ostreambuf_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/ostreambuf_iterator/operator*}}
{{nv mem ln | cpp/iterator/ostreambuf_iterator/operator_arith|operator++|operator++(int)}}
{{nv mem ln | cpp/iterator/ostreambuf_iterator/failed}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/navbar heading</title>
    <ns>10</ns>
    <id>4905</id>
    <revision>
      <id>48110</id>
      <parentid>35730</parentid>
      <timestamp>2013-05-18T18:13:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="65">{{ltt|cpp/iterator/ostreambuf_iterator|std::ostreambuf_itetator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/ostreambuf iterator/title</title>
    <ns>10</ns>
    <id>8485</id>
    <revision>
      <id>31269</id>
      <timestamp>2012-05-17T03:05:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=ostreambuf_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/dsc base</title>
    <ns>10</ns>
    <id>6377</id>
    <revision>
      <id>56932</id>
      <parentid>53048</parentid>
      <timestamp>2013-06-01T05:43:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/reverse iterator/dcl list base]] to [[Template:cpp/iterator/reverse iterator/dsc base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/iterator/reverse_iterator/base | accesses the underlying iterator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/dsc constructor</title>
    <ns>10</ns>
    <id>6375</id>
    <revision>
      <id>56936</id>
      <parentid>53049</parentid>
      <timestamp>2013-06-01T05:43:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/reverse iterator/dcl list constructor]] to [[Template:cpp/iterator/reverse iterator/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem ctor | cpp/iterator/reverse_iterator/reverse_iterator | constructs a new iterator adaptor }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/dsc operator*</title>
    <ns>10</ns>
    <id>6378</id>
    <revision>
      <id>56940</id>
      <parentid>53050</parentid>
      <timestamp>2013-06-01T05:43:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/reverse iterator/dcl list operator*]] to [[Template:cpp/iterator/reverse iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc mem fun | cpp/iterator/reverse_iterator/operator* | title=operator*&lt;br&gt;operator-&gt; | dereferences the decremented underlying iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/dsc operator=</title>
    <ns>10</ns>
    <id>6376</id>
    <revision>
      <id>56944</id>
      <parentid>53051</parentid>
      <timestamp>2013-06-01T05:43:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/reverse iterator/dcl list operator=]] to [[Template:cpp/iterator/reverse iterator/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/iterator/reverse_iterator/operator{{=}} | assigns contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/dsc operator at</title>
    <ns>10</ns>
    <id>6379</id>
    <revision>
      <id>56947</id>
      <parentid>53052</parentid>
      <timestamp>2013-06-01T05:43:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/iterator/reverse iterator/dcl list operator at]] to [[Template:cpp/iterator/reverse iterator/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem fun | cpp/iterator/reverse_iterator/operator_at | title=operator[] | accesses an element by index}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/navbar</title>
    <ns>10</ns>
    <id>4937</id>
    <revision>
      <id>39941</id>
      <parentid>35731</parentid>
      <timestamp>2012-09-28T20:11:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="270">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/iterator/navbar heading
|content2 = cpp/iterator/navbar content

|heading3 = cpp/iterator/reverse_iterator/navbar heading
|content3 = cpp/iterator/reverse_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/navbar content</title>
    <ns>10</ns>
    <id>4939</id>
    <revision>
      <id>53053</id>
      <parentid>36922</parentid>
      <timestamp>2013-06-01T04:58:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="797">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/iterator/reverse_iterator/reverse_iterator}}
{{nv mem ln | cpp/iterator/reverse_iterator/operator{{=}}}}
{{nv mem ln | cpp/iterator/reverse_iterator/base}}
{{nv mem ln | cpp/iterator/reverse_iterator/operator* | operator* | operator-&gt;}}
{{nv mem ln | cpp/iterator/reverse_iterator/operator_at|operator[]}}
{{nv mem ln | cpp/iterator/reverse_iterator/operator_arith|operator++|operator+|operator+{{=}}|operator--|operator-|operator-{{=}}}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/iterator/reverse_iterator/operator_cmp|operator{{==}}|operator!{{=}}|operator&lt;|operator&lt;=|operator&gt;|operator&gt;=}}
{{nv ln | cpp/iterator/reverse_iterator/operator+ | operator+}}
{{nv ln | cpp/iterator/reverse_iterator/operator- | operator-}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/navbar heading</title>
    <ns>10</ns>
    <id>4938</id>
    <revision>
      <id>48097</id>
      <parentid>35732</parentid>
      <timestamp>2013-05-18T18:11:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="59">{{ltt|cpp/iterator/reverse_iterator|std::reverse_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/iterator/reverse iterator/title</title>
    <ns>10</ns>
    <id>6380</id>
    <revision>
      <id>25406</id>
      <timestamp>2012-04-21T12:08:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=reverse_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/keyword/navbar</title>
    <ns>10</ns>
    <id>1580</id>
    <revision>
      <id>39942</id>
      <parentid>36039</parentid>
      <timestamp>2012-09-28T20:11:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="233">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/language/navbar heading
|content2 = cpp/language/navbar content

|heading3 = cpp/keyword/navbar heading
|content3 = cpp/keyword/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/keyword/navbar content</title>
    <ns>10</ns>
    <id>1581</id>
    <revision>
      <id>67412</id>
      <parentid>67282</parentid>
      <timestamp>2014-02-08T09:58:45Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>mark c++11</comment>
      <text xml:space="preserve" bytes="3084">{{nv begin}}
{{nv col begin}}
{{nv ln | cpp/keyword/alignas | notes= {{mark c++11}} }} 
{{nv ln | cpp/keyword/alignof | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/and}}
{{nv ln | cpp/keyword/and_eq}}
{{nv ln | cpp/keyword/asm}}
{{nv ln | cpp/keyword/auto}}
{{nv ln | cpp/keyword/bitand}}
{{nv ln | cpp/keyword/bitor}}
{{nv ln | cpp/keyword/bool}}
{{nv ln | cpp/keyword/break}}
{{nv ln | cpp/keyword/case}}
{{nv ln | cpp/keyword/catch}}
{{nv ln | cpp/keyword/char}}
{{nv ln | cpp/keyword/char16_t | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/char32_t | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/class}}
{{nv ln | cpp/keyword/compl}}
{{nv ln | cpp/keyword/const}}
{{nv ln | cpp/keyword/constexpr | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/const_cast}}
{{nv ln | cpp/keyword/continue}}
{{nv ln | cpp/keyword/decltype | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/default}}
{{nv ln | cpp/keyword/delete}}
{{nv ln | cpp/keyword/do}}
{{nv ln | cpp/keyword/double}}
{{nv ln | cpp/keyword/dynamic_cast}}
{{nv ln | cpp/keyword/else}}

{{nv col next}}
{{nv ln | cpp/keyword/enum}}
{{nv ln | cpp/keyword/explicit}}
{{nv ln | cpp/keyword/export}} 
{{nv ln | cpp/keyword/extern}}
{{nv ln | cpp/keyword/false}}
{{nv ln | cpp/keyword/float}}
{{nv ln | cpp/keyword/for}}
{{nv ln | cpp/keyword/friend}}
{{nv ln | cpp/keyword/goto}}
{{nv ln | cpp/keyword/if}}
{{nv ln | cpp/keyword/inline}}
{{nv ln | cpp/keyword/int}}
{{nv ln | cpp/keyword/long}}
{{nv ln | cpp/keyword/mutable}}
{{nv ln | cpp/keyword/namespace}}
{{nv ln | cpp/keyword/new}}
{{nv ln | cpp/keyword/noexcept | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/not}}
{{nv ln | cpp/keyword/not_eq}}
{{nv ln | cpp/keyword/nullptr | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/operator}}
{{nv ln | cpp/keyword/or}}
{{nv ln | cpp/keyword/or_eq}}
{{nv ln | cpp/keyword/private}}
{{nv ln | cpp/keyword/protected}}
{{nv ln | cpp/keyword/public}}
{{nv ln | cpp/keyword/register}}
{{nv ln | cpp/keyword/reinterpret_cast}}

{{nv col next}}
{{nv ln | cpp/keyword/return}}
{{nv ln | cpp/keyword/short}}
{{nv ln | cpp/keyword/signed}}
{{nv ln | cpp/keyword/sizeof}}
{{nv ln | cpp/keyword/static}}
{{nv ln | cpp/keyword/static_assert | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/static_cast}}
{{nv ln | cpp/keyword/struct}}
{{nv ln | cpp/keyword/switch}}
{{nv ln | cpp/keyword/template}}
{{nv ln | cpp/keyword/this}}
{{nv ln | cpp/keyword/thread_local | notes= {{mark c++11}} }}
{{nv ln | cpp/keyword/throw}}
{{nv ln | cpp/keyword/true}}
{{nv ln | cpp/keyword/try}}
{{nv ln | cpp/keyword/typedef}}
{{nv ln | cpp/keyword/typeid}}
{{nv ln | cpp/keyword/typename}}
{{nv ln | cpp/keyword/union}}
{{nv ln | cpp/keyword/unsigned}}
{{nv ln | cpp/keyword/using}}
{{nv ln | cpp/keyword/virtual}}
{{nv ln | cpp/keyword/void}}
{{nv ln | cpp/keyword/volatile}}
{{nv ln | cpp/keyword/wchar_t}}
{{nv ln | cpp/keyword/while}}
{{nv ln | cpp/keyword/xor}}
{{nv ln | cpp/keyword/xor_eq}}
{{nv col end}}

{{nv h2 | Identifiers with special meaning {{mark since c++11}} }}
{{nv ln | cpp/keyword/override}}
{{nv ln | cpp/keyword/final}}
{{nv end}}</text>
      <sha1>hqp2m7ht2xzchj688wb0igz89a10zjr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/keyword/navbar heading</title>
    <ns>10</ns>
    <id>1582</id>
    <revision>
      <id>35383</id>
      <parentid>19606</parentid>
      <timestamp>2012-06-15T22:24:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/keyword/sidebar heading]] to [[Template:cpp/keyword/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="30">[[cpp/keyword | C++ keywords]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/keyword/title</title>
    <ns>10</ns>
    <id>1583</id>
    <revision>
      <id>19602</id>
      <parentid>3166</parentid>
      <timestamp>2012-03-11T12:18:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/keywords/title]] to [[Template:cpp/keyword/title]]</comment>
      <text xml:space="preserve" bytes="70">&lt;onlyinclude&gt;{{title | {{small|C++ keywords:}} {{{1}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/ascii</title>
    <ns>10</ns>
    <id>8405</id>
    <revision>
      <id>47194</id>
      <parentid>40178</parentid>
      <timestamp>2013-04-29T13:14:10Z</timestamp>
      <contributor>
        <ip>89.189.9.250</ip>
      </contributor>
      <comment>Fixed BEL's name</comment>
      <text xml:space="preserve" bytes="7544">{| class=&quot;wikitable&quot; style=&quot;text-align: left;&quot;
|- 
! {{tt|dec}} || {{tt|oct}} || {{tt|hex}}
!style=&quot;text-align: left;&quot;| {{tt|ch}}
| rowspan=33 | 
! {{tt|dec}} || {{tt|oct}} || {{tt|hex}}
!style=&quot;text-align: left;&quot;| {{tt|ch}}
| rowspan=33 |
! {{tt|dec}} || {{tt|oct}} || {{tt|hex}}
!style=&quot;text-align: left;&quot;| {{tt|ch}}
| rowspan=33 |
! {{tt|dec}} || {{tt|oct}} || {{tt|hex}}
!style=&quot;text-align: left;&quot;| {{tt|ch}}
|-
| {{tt| 0}}|| {{tt|0}}||{{tt|00}}||{{ttb|NUL}} (null) || {{tt|32}}||{{tt|40}}||{{tt|20}}||(space) || {{tt|64}}||{{tt|100}}||{{tt|40}}||{{tt|'''@'''}} || {{tt| 96}}||{{tt|140}}||{{tt|60}}||{{tt|'''`'''}} 
|-
| {{tt| 1}}|| {{tt|1}}||{{tt|01}}||{{ttb|SOH}} (start of header) || {{tt|33}}||{{tt|41}}||{{tt|21}}||{{tt|'''!'''}} || {{tt|65}}||{{tt|101}}||{{tt|41}}||{{tt|'''A'''}} || {{tt| 97}}||{{tt|141}}||{{tt|61}}||{{tt|'''a'''}} 
|-
| {{tt| 2}}|| {{tt|2}}||{{tt|02}}||{{ttb|STX}} (start of text) || {{tt|34}}||{{tt|42}}||{{tt|22}}||{{tt|'''&quot;'''}} || {{tt|66}}||{{tt|102}}||{{tt|42}}||{{tt|'''B'''}} || {{tt| 98}}||{{tt|142}}||{{tt|62}}||{{tt|'''b'''}}
|-
| {{tt| 3}}|| {{tt|3}}||{{tt|03}}||{{ttb|ETX}} (end of text) || {{tt|35}}||{{tt|43}}||{{tt|23}}||{{tt|'''#'''}} || {{tt|67}}||{{tt|103}}||{{tt|43}}||{{tt|'''C'''}} || {{tt| 99}}||{{tt|143}}||{{tt|63}}||{{tt|'''c'''}}
|-
| {{tt| 4}}|| {{tt|4}}||{{tt|04}}||{{ttb|EOT}} (end of transmission) || {{tt|36}}||{{tt|44}}||{{tt|24}}||{{tt|'''$'''}} || {{tt|68}}||{{tt|104}}||{{tt|44}}||{{tt|'''D'''}} || {{tt|100}}||{{tt|144}}||{{tt|64}}||{{tt|'''d'''}}
|-
| {{tt| 5}}|| {{tt|5}}||{{tt|05}}||{{ttb|ENQ}} (enquiry) || {{tt|37}}||{{tt|45}}||{{tt|25}}||{{tt|'''%'''}} || {{tt|69}}||{{tt|105}}||{{tt|45}}||{{tt|'''E'''}} || {{tt|101}}||{{tt|145}}||{{tt|65}}||{{tt|'''e'''}}
|-
| {{tt| 6}}|| {{tt|6}}||{{tt|06}}||{{ttb|ACK}} (acknowledge) || {{tt|38}}||{{tt|46}}||{{tt|26}}||{{tt|'''&amp;'''}} || {{tt|70}}||{{tt|106}}||{{tt|46}}||{{tt|'''F'''}} || {{tt|102}}||{{tt|146}}||{{tt|66}}||{{tt|'''f'''}}
|-
| {{tt| 7}}|| {{tt|7}}||{{tt|07}}||{{ttb|BEL}} (bell) || {{tt|39}}||{{tt|47}}||{{tt|27}}||{{tt|'''&lt;nowiki&gt;'&lt;/nowiki&gt;'''}} || {{tt|71}}||{{tt|107}}||{{tt|47}}||{{tt|'''G'''}} || {{tt|103}}||{{tt|147}}||{{tt|67}}||{{tt|'''g'''}}
|-
| {{tt| 8}}||{{tt|10}}||{{tt|08}}||{{ttb|BS}} (backspace) || {{tt|40}}||{{tt|50}}||{{tt|28}}||{{tt|'''('''}} || {{tt|72}}||{{tt|110}}||{{tt|48}}||{{tt|'''H'''}} || {{tt|104}}||{{tt|150}}||{{tt|68}}||{{tt|'''h'''}}
|-
| {{tt| 9}}||{{tt|11}}||{{tt|09}}||{{ttb|HT}} (horizontal tab) || {{tt|41}}||{{tt|51}}||{{tt|29}}||{{tt|''')'''}} || {{tt|73}}||{{tt|111}}||{{tt|49}}||{{tt|'''I'''}} || {{tt|105}}||{{tt|151}}||{{tt|69}}||{{tt|'''i'''}}
|-
| {{tt|10}}||{{tt|12}}||{{tt|0a}}||{{ttb|LF}} (line feed - new line) || {{tt|42}}||{{tt|52}}||{{tt|2a}}||{{tt|'''*'''}} || {{tt|74}}||{{tt|112}}||{{tt|4a}}||{{tt|'''J'''}} || {{tt|106}}||{{tt|152}}||{{tt|6a}}||{{tt|'''j'''}}
|-
| {{tt|11}}||{{tt|13}}||{{tt|0b}}||{{ttb|VT}} (vertical tab) || {{tt|43}}||{{tt|53}}||{{tt|2b}}||{{tt|'''+'''}} || {{tt|75}}||{{tt|113}}||{{tt|4b}}||{{tt|'''K'''}} || {{tt|107}}||{{tt|153}}||{{tt|6b}}||{{tt|'''k'''}}
|-
| {{tt|12}}||{{tt|14}}||{{tt|0c}}||{{ttb|FF}} (form feed - new page) || {{tt|44}}||{{tt|54}}||{{tt|2c}}||{{tt|''','''}} || {{tt|76}}||{{tt|114}}||{{tt|4c}}||{{tt|'''L'''}} || {{tt|108}}||{{tt|154}}||{{tt|6c}}||{{tt|'''l'''}}
|-
| {{tt|13}}||{{tt|15}}||{{tt|0d}}||{{ttb|CR}} (carriage return) || {{tt|45}}||{{tt|55}}||{{tt|2d}}||{{tt|'''-'''}} || {{tt|77}}||{{tt|115}}||{{tt|4d}}||{{tt|'''M'''}} || {{tt|109}}||{{tt|155}}||{{tt|6d}}||{{tt|'''m'''}}
|-
| {{tt|14}}||{{tt|16}}||{{tt|0e}}||{{ttb|SO}} (shift out) || {{tt|46}}||{{tt|56}}||{{tt|2e}}||{{tt|'''.'''}} || {{tt|78}}||{{tt|116}}||{{tt|4e}}||{{tt|'''N'''}} || {{tt|110}}||{{tt|156}}||{{tt|6e}}||{{tt|'''n'''}}
|-
| {{tt|15}}||{{tt|17}}||{{tt|0f}}||{{ttb|SI}} (shift in) || {{tt|47}}||{{tt|57}}||{{tt|2f}}||{{tt|'''/'''}} || {{tt|79}}||{{tt|117}}||{{tt|4f}}||{{tt|'''O'''}} || {{tt|111}}||{{tt|157}}||{{tt|6f}}||{{tt|'''o'''}}
|-
| {{tt|16}}||{{tt|20}}||{{tt|10}}||{{ttb|DLE}} (data link escape) || {{tt|48}}||{{tt|60}}||{{tt|30}}||{{tt|'''0'''}} || {{tt|80}}||{{tt|120}}||{{tt|50}}||{{tt|'''P'''}} || {{tt|112}}||{{tt|160}}||{{tt|70}}||{{tt|'''p'''}}
|-
| {{tt|17}}||{{tt|21}}||{{tt|11}}||{{ttb|DC1}} (device control 1) || {{tt|49}}||{{tt|61}}||{{tt|31}}||{{tt|'''1'''}} || {{tt|81}}||{{tt|121}}||{{tt|51}}||{{tt|'''Q'''}} || {{tt|113}}||{{tt|161}}||{{tt|71}}||{{tt|'''q'''}}
|-
| {{tt|18}}||{{tt|22}}||{{tt|12}}||{{ttb|DC2}} (device control 2) || {{tt|50}}||{{tt|62}}||{{tt|32}}||{{tt|'''2'''}} || {{tt|82}}||{{tt|122}}||{{tt|52}}||{{tt|'''R'''}} || {{tt|114}}||{{tt|162}}||{{tt|72}}||{{tt|'''r'''}}
|-
| {{tt|19}}||{{tt|23}}||{{tt|13}}||{{ttb|DC3}} (device control 3) || {{tt|51}}||{{tt|63}}||{{tt|33}}||{{tt|'''3'''}} || {{tt|83}}||{{tt|123}}||{{tt|53}}||{{tt|'''S'''}} || {{tt|115}}||{{tt|163}}||{{tt|73}}||{{tt|'''s'''}}
|-
| {{tt|20}}||{{tt|24}}||{{tt|14}}||{{ttb|DC4}} (device control 4) || {{tt|52}}||{{tt|64}}||{{tt|34}}||{{tt|'''4'''}} || {{tt|84}}||{{tt|124}}||{{tt|54}}||{{tt|'''T'''}} || {{tt|116}}||{{tt|164}}||{{tt|74}}||{{tt|'''t'''}}
|-
| {{tt|21}}||{{tt|25}}||{{tt|15}}||{{ttb|NAK}} (negative acknowledge) || {{tt|53}}||{{tt|65}}||{{tt|35}}||{{tt|'''5'''}} || {{tt|85}}||{{tt|125}}||{{tt|55}}||{{tt|'''U'''}} || {{tt|117}}||{{tt|165}}||{{tt|75}}||{{tt|'''u'''}}
|-
| {{tt|22}}||{{tt|26}}||{{tt|16}}||{{ttb|SYN}} (synchronous idle) || {{tt|54}}||{{tt|66}}||{{tt|36}}||{{tt|'''6'''}} || {{tt|86}}||{{tt|126}}||{{tt|56}}||{{tt|'''V'''}} || {{tt|118}}||{{tt|166}}||{{tt|76}}||{{tt|'''v'''}}
|-
| {{tt|23}}||{{tt|27}}||{{tt|17}}||{{ttb|ETB}} (end of transmission block) || {{tt|55}}||{{tt|67}}||{{tt|37}}||{{tt|'''7'''}} || {{tt|87}}||{{tt|127}}||{{tt|57}}||{{tt|'''W'''}} || {{tt|119}}||{{tt|167}}||{{tt|77}}||{{tt|'''w'''}}
|-
| {{tt|24}}||{{tt|30}}||{{tt|18}}||{{ttb|CAN}} (cancel) || {{tt|56}}||{{tt|70}}||{{tt|38}}||{{tt|'''8'''}} || {{tt|88}}||{{tt|130}}||{{tt|58}}||{{tt|'''X'''}} || {{tt|120}}||{{tt|170}}||{{tt|78}}||{{tt|'''x'''}}
|-
| {{tt|25}}||{{tt|31}}||{{tt|19}}||{{ttb|EM}} (end of medium) || {{tt|57}}||{{tt|71}}||{{tt|39}}||{{tt|'''9'''}} || {{tt|89}}||{{tt|131}}||{{tt|59}}||{{tt|'''Y'''}} || {{tt|121}}||{{tt|171}}||{{tt|79}}||{{tt|'''y'''}}
|-
| {{tt|26}}||{{tt|32}}||{{tt|1a}}||{{ttb|SUB}} (substitute) || {{tt|58}}||{{tt|72}}||{{tt|3a}}||{{tt|''':'''}} || {{tt|90}}||{{tt|132}}||{{tt|5a}}||{{tt|'''Z'''}} || {{tt|122}}||{{tt|172}}||{{tt|7a}}||{{tt|'''z'''}}
|-
| {{tt|27}}||{{tt|33}}||{{tt|1b}}||{{ttb|ESC}} (escape) || {{tt|59}}||{{tt|73}}||{{tt|3b}}||{{tt|''';'''}} || {{tt|91}}||{{tt|133}}||{{tt|5b}}||{{tt|'''['''}} || {{tt|123}}||{{tt|173}}||{{tt|7b}}||{{tt|'''{'''}}
|-
| {{tt|28}}||{{tt|34}}||{{tt|1c}}||{{ttb|FS}} (file separator) || {{tt|60}}||{{tt|74}}||{{tt|3c}}||{{tt|'''&lt;'''}} || {{tt|92}}||{{tt|134}}||{{tt|5c}}||{{tt|'''\ '''}} || {{tt|124}}||{{tt|174}}||{{tt|7c}}||{{tt|'''&amp;#124;'''}}
|-
| {{tt|29}}||{{tt|35}}||{{tt|1d}}||{{ttb|GS}} (group separator) || {{tt|61}}||{{tt|75}}||{{tt|3d}}||{{tt|'''{{=}}'''}} || {{tt|93}}||{{tt|135}}||{{tt|5d}}||{{tt|''']'''}} || {{tt|125}}||{{tt|175}}||{{tt|7d}}||{{tt|'''}'''}}
|-
| {{tt|30}}||{{tt|36}}||{{tt|1e}}||{{ttb|RS}} (record separator) || {{tt|62}}||{{tt|76}}||{{tt|3e}}||{{tt|'''&gt;'''}} || {{tt|94}}||{{tt|136}}||{{tt|5e}}||{{tt|'''^'''}} || {{tt|126}}||{{tt|176}}||{{tt|7e}}||{{tt|'''~'''}}
|-
| {{tt|31}}||{{tt|37}}||{{tt|1f}}||{{ttb|US}} (unit separator) || {{tt|63}}||{{tt|77}}||{{tt|3f}}||{{tt|'''?'''}} || {{tt|95}}||{{tt|137}}||{{tt|5f}}||{{tt|'''_'''}} || {{tt|127}}||{{tt|177}}||{{tt|7f}}||{{ttb|DEL}} (delete)
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/basics/navbar</title>
    <ns>10</ns>
    <id>13487</id>
    <revision>
      <id>68984</id>
      <timestamp>2014-03-23T15:54:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="207">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/basics/navbar heading
|content3 = cpp/language/basics/navbar content
}}</text>
      <sha1>494tqkw7j2x0gr3a8trv94rau4hrbj2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/basics/navbar content</title>
    <ns>10</ns>
    <id>13489</id>
    <revision>
      <id>72006</id>
      <parentid>68991</parentid>
      <timestamp>2014-07-08T12:49:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>language/types now includes void</comment>
      <text xml:space="preserve" bytes="815">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv | [[cpp/keyword | language keywords]] }}
{{nv | [[cpp/language/translation_phases | phases of translation]] }}
{{nv | [[cpp/comment | comments ]] }}
{{nv | [[cpp/language/main_function | the main() function]] }}
{{nv | [[cpp/language/identifiers | names and identifiers]] }}
{{nv | [[cpp/language/type | types]] }}
{{nv | [[cpp/language/types | fundamental types]] }}
{{nv | [[cpp/language/object | objects]] }}
{{nv | [[cpp/language/scope | scope]] }}
{{nv | [[cpp/language/lifetime | object lifetime]] }}
{{nv | [[cpp/language/storage_duration | storage duration and linkage]] }}
{{nv | [[cpp/language/definition | definitions and ODR]] }}
{{nv | [[cpp/language/lookup | name lookup]] }}
{{nv | [[cpp/language/memory_model | memory model]] }}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>assfcsixaxxbkge4930epyckzv7char</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/basics/navbar heading</title>
    <ns>10</ns>
    <id>13488</id>
    <revision>
      <id>68986</id>
      <timestamp>2014-03-23T15:55:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="48">[[cpp/language/basic_concepts | Basic Concepts]]</text>
      <sha1>ohi1tsmfd2j5t9jekr2fedmbzg16jic</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/cast return</title>
    <ns>10</ns>
    <id>8406</id>
    <revision>
      <id>53059</id>
      <parentid>30595</parentid>
      <timestamp>2013-06-01T04:58:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="242">As with all cast expressions, the result is:
* an lvalue if {{spar|new_type}} is an lvalue reference type or an rvalue reference to function type;
* an xvalue if {{spar|new_type}} is an rvalue reference to object type; 
* a prvalue otherwise.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/classes/navbar</title>
    <ns>10</ns>
    <id>13144</id>
    <revision>
      <id>67451</id>
      <timestamp>2014-02-09T20:55:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="209">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/classes/navbar heading
|content3 = cpp/language/classes/navbar content
}}</text>
      <sha1>8s6ejlq1bzusosfjbbx2ikmhious75a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/classes/navbar content</title>
    <ns>10</ns>
    <id>13146</id>
    <revision>
      <id>70393</id>
      <parentid>67480</parentid>
      <timestamp>2014-05-21T19:03:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/nested types/nested classes/</comment>
      <text xml:space="preserve" bytes="1767">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | General }}
{{nv | [[cpp/language/classes | overview]] }}
{{nv | [[cpp/language/class | class/struct types]] }}
{{nv | [[cpp/language/union | union types]] }}
{{nv h2 | Members }}
{{nv | [[cpp/language/data_members|data members]]}}
{{nv | [[cpp/language/static|static members]]}}
{{nv | [[cpp/language/this|the {{tt|this}} pointer]]}}
{{nv | [[cpp/language/nested_types|nested classes]]}}
{{nv | [[cpp/language/member_template|member templates]]}}
{{nv | [[cpp/language/bit_field|bit fields]]}}
{{nv | [[cpp/language/using_declaration|using-declarations]]}}
{{nv | [[cpp/language/member_functions|member functions]]}}
{{nv | [[cpp/language/access|member access specifiers]]}}
{{nv | [[cpp/language/initializer_list|constructor initializer list]]}}
{{nv | [[cpp/language/data_members#Member_initialization|in-class ''brace-or-equal'' initializer]]{{mark c++11}}}}
{{nv | [[cpp/language/friend|{{tt|friend}} specifier]]}}
{{nv h2 | Special member functions }}
{{nv | [[cpp/language/default_constructor|default constructor]]}}
{{nv | [[cpp/language/copy_constructor|copy constructor]]}}
{{nv | [[cpp/language/move_constructor|move constructor]]{{mark c++11}}}}
{{nv | [[cpp/language/as_operator|copy assignment operator]]}}
{{nv | [[cpp/language/move_operator|move assignment operator]]{{mark  c++11}}}}
{{nv | [[cpp/language/destructor|destructor]]}}
{{nv h2 | Inheritance }}
{{nv | [[cpp/language/derived_class|base and derived classes]]}}
{{nv | [[cpp/language/virtual|virtual member functions]]}}
{{nv | [[cpp/language/override|override]]{{mark c++11}}}}
{{nv | [[cpp/language/final|final]]{{mark c++11}}}}
{{nv | [[cpp/language/abstract_class|pure virtual functions and abstract classes]]}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>j43ejhghblocz8sssjmukxw1mcch6h7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/classes/navbar heading</title>
    <ns>10</ns>
    <id>13145</id>
    <revision>
      <id>67452</id>
      <timestamp>2014-02-09T20:56:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="34">[[cpp/language/classes | Classes]]</text>
      <sha1>nt4itjvj64thg4ikbawpopq1hq4ylqo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/declarations/navbar</title>
    <ns>10</ns>
    <id>13157</id>
    <revision>
      <id>67700</id>
      <timestamp>2014-02-21T18:42:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="219">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/declarations/navbar heading
|content3 = cpp/language/declarations/navbar content
}}</text>
      <sha1>289j6e5ny68u8ybqc2occwdu8fgdt1t</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/declarations/navbar content</title>
    <ns>10</ns>
    <id>13159</id>
    <revision>
      <id>67705</id>
      <parentid>67703</parentid>
      <timestamp>2014-02-21T19:09:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>2 columns</comment>
      <text xml:space="preserve" bytes="2627">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv col begin}}
{{nv h2 | Overview }}
{{nv | [[cpp/language/declarations | declaration syntax]] }}
{{nv | [[cpp/language/declarations#Specifiers | decl-specifier-seq]] }}
{{nv | [[cpp/language/declarations#Declarators | declarator]] }}
{{nv h2 | Specifiers }}
{{nv | [[cpp/language/typedef | typedef]] }}
{{nv | [[cpp/language/inline | inline function specifier]] }}
{{nv | [[cpp/language/virtual | virtual function specifier]] }}
{{nv | [[cpp/language/explicit | explicit function specifier]] }}
{{nv | [[cpp/language/friend | friend]] }}
{{nv | [[cpp/language/constexpr | constexpr]]{{mark c++11}} }}
{{nv | [[cpp/language/storage_duration | storage class specifiers]] }}
{{nv | [[cpp/language/class | class ]] }}
{{nv | [[cpp/language/union | union ]] }}
{{nv | [[cpp/language/enum | enum ]] }}
{{nv | [[cpp/language/decltype | decltype ]] {{mark c++11}}}}
{{nv | [[cpp/language/auto | auto]] {{mark c++11}}}}
{{nv | [[cpp/language/alignas | alignas]] {{mark c++11}}}}
{{nv | [[cpp/language/cv | const/volatile ]] }}
{{nv | [[cpp/language/attributes | attributes ]]{{mark c++11}} }}
{{nv h2 | Declarators }}
{{nv | [[cpp/language/reference | reference ]] }}
{{nv | [[cpp/language/pointer | pointer ]] }}
{{nv | [[cpp/language/array | array ]] }}
{{nv col next}}
{{nv h2 | Block declarations }}
{{nv | [[cpp/language/declarations | simple-declaration]] }}
{{nv | [[cpp/language/type_alias | alias declaration]]{{mark c++11}} }}
{{nv | [[cpp/language/namespace_alias | namespace alias definition ]]}}
{{nv | [[cpp/language/using_declaration | using-declaration]] }}
{{nv | [[cpp/language/namespace#Using-directives | using-directive]] }}
{{nv | [[cpp/language/static_assert | static_assert declaration]] {{mark c++11}}}}
{{nv | [[cpp/language/asm | asm-definition]] }}
{{nv | [[cpp/language/enum | opaque enum declaration]]{{mark c++11}} }}
{{nv h2 | Other declarations }}
{{nv | [[cpp/language/namespace | namespace definition]] }}
{{nv | [[cpp/language/function | function declaration]] }}
{{nv | [[cpp/language/class_template | class template declaration]] }}
{{nv | [[cpp/language/function_template | function template declaration]] }}
{{nv | [[cpp/language/class_template#Explicit_instantiation | explicit template instantiation]]{{mark c++11}}}}
{{nv | [[cpp/language/template_specialization | explicit template specialization]] }}
{{nv | [[cpp/language/language_linkage | linkage specification]] }}
{{nv | [[cpp/language/declarations | attribute declaration]] {{mark c++11}} }}
{{nv | [[cpp/language/declarations | empty declaration]] }}
{{nv col end}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>qyyxauyn29bdsd9r81sgv8aw6soiq56</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/declarations/navbar heading</title>
    <ns>10</ns>
    <id>13158</id>
    <revision>
      <id>67701</id>
      <timestamp>2014-02-21T18:43:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="44">[[cpp/language/declarations | Declarations]]</text>
      <sha1>nobt9v0v7usiv1d037882t8ngo6pcls</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc access</title>
    <ns>10</ns>
    <id>8380</id>
    <revision>
      <id>56951</id>
      <parentid>53062</parentid>
      <timestamp>2013-06-01T05:43:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list access]] to [[Template:cpp/language/dsc access]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc | [[cpp/language/access | access specifiers ]] | defines visibility of class members}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc alignas</title>
    <ns>10</ns>
    <id>6582</id>
    <revision>
      <id>56954</id>
      <parentid>53063</parentid>
      <timestamp>2013-06-01T05:43:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list alignas]] to [[Template:cpp/language/dsc alignas]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc | [[cpp/language/alignas | alignas specifier ]] | specifies that the storage for the variable should be aligned by specific amount {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc alignof</title>
    <ns>10</ns>
    <id>8402</id>
    <revision>
      <id>56958</id>
      <parentid>53066</parentid>
      <timestamp>2013-06-01T05:43:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list alignof]] to [[Template:cpp/language/dsc alignof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc | [[cpp/language/alignof | alignof operator ]] | queries alignment requirements of a type {{mark since c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc as operator</title>
    <ns>10</ns>
    <id>8392</id>
    <revision>
      <id>56962</id>
      <parentid>53069</parentid>
      <timestamp>2013-06-01T05:44:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list as operator]] to [[Template:cpp/language/dsc as operator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc | [[cpp/language/as_operator | assignment operator ]] | copies the contents of one object into another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc asm</title>
    <ns>10</ns>
    <id>8398</id>
    <revision>
      <id>56966</id>
      <parentid>53072</parentid>
      <timestamp>2013-06-01T05:44:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list asm]] to [[Template:cpp/language/dsc asm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc | [[cpp/language/asm | inline assembly ]] | an inline listing of assembly code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc attributes</title>
    <ns>10</ns>
    <id>6597</id>
    <revision>
      <id>56970</id>
      <parentid>53073</parentid>
      <timestamp>2013-06-01T05:44:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list attributes]] to [[Template:cpp/language/dsc attributes]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc | [[cpp/language/attributes | attributes ]] | defines additional information about variable {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc auto</title>
    <ns>10</ns>
    <id>6581</id>
    <revision>
      <id>56974</id>
      <parentid>53076</parentid>
      <timestamp>2013-06-01T05:44:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list auto]] to [[Template:cpp/language/dsc auto]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc | [[cpp/language/auto | auto specifier ]] | specifies a type defined by an expression {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc bool literal</title>
    <ns>10</ns>
    <id>6587</id>
    <revision>
      <id>56978</id>
      <parentid>53079</parentid>
      <timestamp>2013-06-01T05:44:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list bool literal]] to [[Template:cpp/language/dsc bool literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc | [[cpp/language/bool_literal | boolean literals ]] | values of type {{c|bool}}, that is {{c|true}} and {{c|false}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc break</title>
    <ns>10</ns>
    <id>6559</id>
    <revision>
      <id>56982</id>
      <parentid>53082</parentid>
      <timestamp>2013-06-01T05:44:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list break]] to [[Template:cpp/language/dsc break]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc | [[cpp/language/break | break ]] | terminates the enclosing loop}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc character literal</title>
    <ns>10</ns>
    <id>6584</id>
    <revision>
      <id>56986</id>
      <parentid>53083</parentid>
      <timestamp>2013-06-01T05:44:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list character literal]] to [[Template:cpp/language/dsc character literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc | [[cpp/language/character_literal | character literals ]] | individual characters of type {{c|char}}, {{c|char16_t}}, {{c|char32_t}}, or {{c|wchar_t}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc class</title>
    <ns>10</ns>
    <id>6574</id>
    <revision>
      <id>56990</id>
      <parentid>53086</parentid>
      <timestamp>2013-06-01T05:44:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list class]] to [[Template:cpp/language/dsc class]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc | [[cpp/language/class | compound types ]] | defines types holding several data members (essentially the same as class)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc class template</title>
    <ns>10</ns>
    <id>8395</id>
    <revision>
      <id>56994</id>
      <parentid>53089</parentid>
      <timestamp>2013-06-01T05:44:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list class template]] to [[Template:cpp/language/dsc class template]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc | [[cpp/language/class_template | class template declaration ]] | declares a class that can operate on different types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc const cast</title>
    <ns>10</ns>
    <id>8373</id>
    <revision>
      <id>56997</id>
      <parentid>53090</parentid>
      <timestamp>2013-06-01T05:44:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list const cast]] to [[Template:cpp/language/dsc const cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc | [[cpp/language/const_cast | const_cast conversion ]] | adds or removes const}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc constexpr</title>
    <ns>10</ns>
    <id>6580</id>
    <revision>
      <id>57003</id>
      <parentid>53093</parentid>
      <timestamp>2013-06-01T05:45:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list constexpr]] to [[Template:cpp/language/dsc constexpr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc | [[cpp/language/constexpr | constexpr specifier ]] | specifies that the value of a variable or function can be computed at compile time {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc continue</title>
    <ns>10</ns>
    <id>6558</id>
    <revision>
      <id>57007</id>
      <parentid>53096</parentid>
      <timestamp>2013-06-01T05:45:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list continue]] to [[Template:cpp/language/dsc continue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc | [[cpp/language/continue | continue ]] | skips the remaining part of the enclosing loop body}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc copy constructor</title>
    <ns>10</ns>
    <id>8390</id>
    <revision>
      <id>57011</id>
      <parentid>53099</parentid>
      <timestamp>2013-06-01T05:45:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list copy constructor]] to [[Template:cpp/language/dsc copy constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc | [[cpp/language/copy_constructor | copy constructor ]] | initializes an object with the contents of another object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc cv</title>
    <ns>10</ns>
    <id>6578</id>
    <revision>
      <id>57015</id>
      <parentid>53102</parentid>
      <timestamp>2013-06-01T05:45:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list cv]] to [[Template:cpp/language/dsc cv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc | [[cpp/language/cv | cv specifier ]] | specifies constness and volatility of a type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc cv function</title>
    <ns>10</ns>
    <id>8388</id>
    <revision>
      <id>57019</id>
      <parentid>53103</parentid>
      <timestamp>2013-06-01T05:45:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list cv function]] to [[Template:cpp/language/dsc cv function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc | [[cpp/language/cv_function | cv function specifier ]] | declares that a member function can only be used on cv-qualified objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc decltype</title>
    <ns>10</ns>
    <id>6577</id>
    <revision>
      <id>57023</id>
      <parentid>53106</parentid>
      <timestamp>2013-06-01T05:45:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list decltype]] to [[Template:cpp/language/dsc decltype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc | [[cpp/language/decltype | decltype specifier ]] | defines a type equivalent to the type of an expression {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc default constructor</title>
    <ns>10</ns>
    <id>8389</id>
    <revision>
      <id>57026</id>
      <parentid>53109</parentid>
      <timestamp>2013-06-01T05:45:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list default constructor]] to [[Template:cpp/language/dsc default constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc | [[cpp/language/default_constructor | default constructor ]] | initializes an object with default values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc delete</title>
    <ns>10</ns>
    <id>8378</id>
    <revision>
      <id>57030</id>
      <parentid>53112</parentid>
      <timestamp>2013-06-01T05:45:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list delete]] to [[Template:cpp/language/dsc delete]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc | [[cpp/language/delete | delete expression ]] | deallocates memory dynamically}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc destructor</title>
    <ns>10</ns>
    <id>8394</id>
    <revision>
      <id>57034</id>
      <parentid>53113</parentid>
      <timestamp>2013-06-01T05:45:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list destructor]] to [[Template:cpp/language/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc | [[cpp/language/destructor | destructor ]] | releases claimed resources}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc do</title>
    <ns>10</ns>
    <id>6557</id>
    <revision>
      <id>57038</id>
      <parentid>53116</parentid>
      <timestamp>2013-06-01T05:45:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list do]] to [[Template:cpp/language/dsc do]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc | [[cpp/language/do | do-while loop ]] | executes loop, checking condition after each iteration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc dynamic cast</title>
    <ns>10</ns>
    <id>8375</id>
    <revision>
      <id>57042</id>
      <parentid>53119</parentid>
      <timestamp>2013-06-01T05:46:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list dynamic cast]] to [[Template:cpp/language/dsc dynamic cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc | [[cpp/language/dynamic_cast | dynamic_cast conversion ]] | performs checked polymorphic conversions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc enum</title>
    <ns>10</ns>
    <id>6575</id>
    <revision>
      <id>57045</id>
      <parentid>53122</parentid>
      <timestamp>2013-06-01T05:46:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list enum]] to [[Template:cpp/language/dsc enum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc | [[cpp/language/enum | enumeration types ]] | defines types that are able to hold only one of the specified values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc eval order</title>
    <ns>10</ns>
    <id>6591</id>
    <revision>
      <id>57049</id>
      <parentid>53125</parentid>
      <timestamp>2013-06-01T05:46:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list eval order]] to [[Template:cpp/language/dsc eval order]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc | [[cpp/language/eval_order | order of evaluation ]] | the order in which intermediate results of arguments and subexpressions are obtained}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc except spec</title>
    <ns>10</ns>
    <id>6566</id>
    <revision>
      <id>57053</id>
      <parentid>53126</parentid>
      <timestamp>2013-06-01T05:46:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list except spec]] to [[Template:cpp/language/dsc except spec]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc | [[cpp/language/except_spec | exception specification ]] | specifies what exceptions are thrown by a function {{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc explicit</title>
    <ns>10</ns>
    <id>8386</id>
    <revision>
      <id>57057</id>
      <parentid>53129</parentid>
      <timestamp>2013-06-01T05:46:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list explicit]] to [[Template:cpp/language/dsc explicit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="175">{{dsc | [[cpp/language/explicit | explicit function specifier ]] | declares that a constructor or conversion operator can not be used in implicit conversions {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc explicit cast</title>
    <ns>10</ns>
    <id>9776</id>
    <revision>
      <id>57060</id>
      <parentid>53132</parentid>
      <timestamp>2013-06-01T05:46:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list explicit cast]] to [[Template:cpp/language/dsc explicit cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc | [[cpp/language/explicit_cast | explicit casts ]] | permissive conversions between types }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc final</title>
    <ns>10</ns>
    <id>8385</id>
    <revision>
      <id>57064</id>
      <parentid>53135</parentid>
      <timestamp>2013-06-01T05:46:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list final]] to [[Template:cpp/language/dsc final]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc | [[cpp/language/final | final specifier ]] | declares that a method cannot be overridden {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc floating literal</title>
    <ns>10</ns>
    <id>6585</id>
    <revision>
      <id>57067</id>
      <parentid>53136</parentid>
      <timestamp>2013-06-01T05:46:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list floating literal]] to [[Template:cpp/language/dsc floating literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc | [[cpp/language/floating_literal | floating-point literals ]] | values of type {{c|float}}, {{c|double}}, or {{c|long double}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc for</title>
    <ns>10</ns>
    <id>6555</id>
    <revision>
      <id>57071</id>
      <parentid>53139</parentid>
      <timestamp>2013-06-01T05:46:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list for]] to [[Template:cpp/language/dsc for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">{{dsc | [[cpp/language/for | for loop ]] | executes loop}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc friend</title>
    <ns>10</ns>
    <id>8381</id>
    <revision>
      <id>57076</id>
      <parentid>53142</parentid>
      <timestamp>2013-06-01T05:46:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list friend]] to [[Template:cpp/language/dsc friend]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc | [[cpp/language/friend | friend specifier ]] | grants access to {{c|private}} and {{c|protected}} class members}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc function</title>
    <ns>10</ns>
    <id>6562</id>
    <revision>
      <id>57080</id>
      <parentid>53143</parentid>
      <timestamp>2013-06-01T05:46:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list function]] to [[Template:cpp/language/dsc function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc | [[cpp/language/function | function declaration ]] | declares a function}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc function template</title>
    <ns>10</ns>
    <id>6564</id>
    <revision>
      <id>57084</id>
      <parentid>53146</parentid>
      <timestamp>2013-06-01T05:47:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list function template]] to [[Template:cpp/language/dsc function template]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc | [[cpp/language/function_template | function template ]] | declares a function that can operate on different types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc goto</title>
    <ns>10</ns>
    <id>6560</id>
    <revision>
      <id>57087</id>
      <parentid>53149</parentid>
      <timestamp>2013-06-01T05:47:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list goto]] to [[Template:cpp/language/dsc goto]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc | [[cpp/language/goto | goto ]] | continues execution in another location}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc if</title>
    <ns>10</ns>
    <id>6553</id>
    <revision>
      <id>57091</id>
      <parentid>53152</parentid>
      <timestamp>2013-06-01T05:47:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list if]] to [[Template:cpp/language/dsc if]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc | [[cpp/language/if | if conditional ]] | executes code conditionally}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc implicit cast</title>
    <ns>10</ns>
    <id>6598</id>
    <revision>
      <id>57096</id>
      <parentid>53153</parentid>
      <timestamp>2013-06-01T05:47:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list implicit cast]] to [[Template:cpp/language/dsc implicit cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc | [[cpp/language/implicit_cast | standard conversions ]] | implicit conversions from one type to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc initializer list</title>
    <ns>10</ns>
    <id>8382</id>
    <revision>
      <id>57099</id>
      <parentid>53156</parentid>
      <timestamp>2013-06-01T05:47:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list initializer list]] to [[Template:cpp/language/dsc initializer list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc | [[cpp/language/initializer_list | initializer lists ]] | initializes class members}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc inline</title>
    <ns>10</ns>
    <id>6565</id>
    <revision>
      <id>57104</id>
      <parentid>53159</parentid>
      <timestamp>2013-06-01T05:47:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list inline]] to [[Template:cpp/language/dsc inline]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc | [[cpp/language/inline | inline specifier ]] | hints the compiler to insert a function's body directly into the calling code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc integer literal</title>
    <ns>10</ns>
    <id>6583</id>
    <revision>
      <id>57109</id>
      <parentid>53162</parentid>
      <timestamp>2013-06-01T05:47:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list integer literal]] to [[Template:cpp/language/dsc integer literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc | [[cpp/language/integer_literal | integer literals ]] | decimal, octal, or hexadecimal numbers of integer type {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc lambda</title>
    <ns>10</ns>
    <id>6563</id>
    <revision>
      <id>57113</id>
      <parentid>53163</parentid>
      <timestamp>2013-06-01T05:47:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list lambda]] to [[Template:cpp/language/dsc lambda]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc | [[cpp/language/lambda | lambda function declaration ]] | declares a lambda function {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc move constructor</title>
    <ns>10</ns>
    <id>8391</id>
    <revision>
      <id>57117</id>
      <parentid>53166</parentid>
      <timestamp>2013-06-01T05:47:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list move constructor]] to [[Template:cpp/language/dsc move constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc | [[cpp/language/move_constructor | move constructor ]] | initializes an object by moving data from a temporary object {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc move operator</title>
    <ns>10</ns>
    <id>8393</id>
    <revision>
      <id>57122</id>
      <parentid>53169</parentid>
      <timestamp>2013-06-01T05:47:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list move operator]] to [[Template:cpp/language/dsc move operator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc | [[cpp/language/move_operator | move assignment operator ]] | moves the contents of a temporary object into another {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc namespace</title>
    <ns>10</ns>
    <id>6570</id>
    <revision>
      <id>57126</id>
      <parentid>53172</parentid>
      <timestamp>2013-06-01T05:47:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list namespace]] to [[Template:cpp/language/dsc namespace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc | [[cpp/language/namespace | namespace declaration ]] | identifies a namespace}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc namespace alias</title>
    <ns>10</ns>
    <id>6571</id>
    <revision>
      <id>57129</id>
      <parentid>53175</parentid>
      <timestamp>2013-06-01T05:48:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list namespace alias]] to [[Template:cpp/language/dsc namespace alias]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc | [[cpp/language/namespace_alias | namespace alias ]] | creates an alias of an existing namespace}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc new</title>
    <ns>10</ns>
    <id>8377</id>
    <revision>
      <id>57134</id>
      <parentid>53176</parentid>
      <timestamp>2013-06-01T05:48:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list new]] to [[Template:cpp/language/dsc new]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc | [[cpp/language/new | new expression ]] | allocates memory dynamically}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc noexcept</title>
    <ns>10</ns>
    <id>8400</id>
    <revision>
      <id>57137</id>
      <parentid>53179</parentid>
      <timestamp>2013-06-01T05:48:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list noexcept]] to [[Template:cpp/language/dsc noexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc | [[cpp/language/noexcept | noexcept operator ]] | determines if an expression throws any exceptions {{mark since c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc noexcept spec</title>
    <ns>10</ns>
    <id>6567</id>
    <revision>
      <id>57141</id>
      <parentid>53182</parentid>
      <timestamp>2013-06-01T05:48:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list noexcept spec]] to [[Template:cpp/language/dsc noexcept spec]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc | [[cpp/language/noexcept_spec | noexcept specifier ]] | requires a function to not throw any exceptions {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc nullptr</title>
    <ns>10</ns>
    <id>6588</id>
    <revision>
      <id>57145</id>
      <parentid>53185</parentid>
      <timestamp>2013-06-01T05:48:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list nullptr]] to [[Template:cpp/language/dsc nullptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc | [[cpp/language/nullptr | nullptr ]] | the pointer literal which specifies a null pointer value {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc operator alternative</title>
    <ns>10</ns>
    <id>6594</id>
    <revision>
      <id>57149</id>
      <parentid>53186</parentid>
      <timestamp>2013-06-01T05:48:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list operator alternative]] to [[Template:cpp/language/dsc operator alternative]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc | [[cpp/language/operator_alternative | alternative representations ]] | alternative spellings for certain operators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc operator precedence</title>
    <ns>10</ns>
    <id>6593</id>
    <revision>
      <id>57153</id>
      <parentid>53189</parentid>
      <timestamp>2013-06-01T05:48:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list operator precedence]] to [[Template:cpp/language/dsc operator precedence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc | [[cpp/language/operator_precedence | operator precedence ]] | the order in which operators are bound to their arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc operators</title>
    <ns>10</ns>
    <id>6592</id>
    <revision>
      <id>57158</id>
      <parentid>53192</parentid>
      <timestamp>2013-06-01T05:48:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list operators]] to [[Template:cpp/language/dsc operators]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc | [[cpp/language/operators | operators ]] | allows the use of syntax commonly found in mathematics}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc override</title>
    <ns>10</ns>
    <id>8384</id>
    <revision>
      <id>57163</id>
      <parentid>53193</parentid>
      <timestamp>2013-06-01T05:48:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list override]] to [[Template:cpp/language/dsc override]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc | [[cpp/language/override | override specifier ]] | explicitly declare that a method overrides another method {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc parameter pack</title>
    <ns>10</ns>
    <id>8397</id>
    <revision>
      <id>57167</id>
      <parentid>53196</parentid>
      <timestamp>2013-06-01T05:48:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list parameter pack]] to [[Template:cpp/language/dsc parameter pack]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc | [[cpp/language/parameter_pack | parameter packs ]] | specifies lists of types {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc pointer</title>
    <ns>10</ns>
    <id>6573</id>
    <revision>
      <id>57172</id>
      <parentid>53199</parentid>
      <timestamp>2013-06-01T05:48:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list pointer]] to [[Template:cpp/language/dsc pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc | [[cpp/language/pointer | pointer types ]] | holding a memory location}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc range-for</title>
    <ns>10</ns>
    <id>6546</id>
    <revision>
      <id>57177</id>
      <parentid>53200</parentid>
      <timestamp>2013-06-01T05:48:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list range-for]] to [[Template:cpp/language/dsc range-for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc | [[cpp/language/range-for | range-for loop ]] | executes loop over range {{mark since c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc reinterpret cast</title>
    <ns>10</ns>
    <id>8376</id>
    <revision>
      <id>57182</id>
      <parentid>53203</parentid>
      <timestamp>2013-06-01T05:48:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list reinterpret cast]] to [[Template:cpp/language/dsc reinterpret cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc | [[cpp/language/reinterpret_cast | reinterpret_cast conversion ]] | performs general low-level conversions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc return</title>
    <ns>10</ns>
    <id>6561</id>
    <revision>
      <id>57186</id>
      <parentid>53206</parentid>
      <timestamp>2013-06-01T05:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list return]] to [[Template:cpp/language/dsc return]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc | [[cpp/language/return | return ]] | terminates execution of the enclosing function}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc static</title>
    <ns>10</ns>
    <id>8387</id>
    <revision>
      <id>57191</id>
      <parentid>53209</parentid>
      <timestamp>2013-06-01T05:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list static]] to [[Template:cpp/language/dsc static]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc | [[cpp/language/static | static function specifier ]]: declares that a method does not use class data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc static assert</title>
    <ns>10</ns>
    <id>8403</id>
    <revision>
      <id>57194</id>
      <parentid>53212</parentid>
      <timestamp>2013-06-01T05:49:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list static assert]] to [[Template:cpp/language/dsc static assert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc | [[cpp/language/static_assert | static assertion ]] | performs compile-time assertion checking {{mark since c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc static cast</title>
    <ns>10</ns>
    <id>8374</id>
    <revision>
      <id>57199</id>
      <parentid>53213</parentid>
      <timestamp>2013-06-01T05:49:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list static cast]] to [[Template:cpp/language/dsc static cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc | [[cpp/language/static_cast | static_cast conversion ]] | performs basic conversions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc storage duration</title>
    <ns>10</ns>
    <id>6579</id>
    <revision>
      <id>57204</id>
      <parentid>53216</parentid>
      <timestamp>2013-06-01T05:49:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list storage duration]] to [[Template:cpp/language/dsc storage duration]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc | [[cpp/language/storage_duration | storage duration specifier ]] | specifies storage duration of a type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc string literal</title>
    <ns>10</ns>
    <id>6586</id>
    <revision>
      <id>57208</id>
      <parentid>53219</parentid>
      <timestamp>2013-06-01T05:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list string literal]] to [[Template:cpp/language/dsc string literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc | [[cpp/language/string_literal | string literals ]] | sequences of characters, which may be narrow, multibyte, or wide}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc switch</title>
    <ns>10</ns>
    <id>6554</id>
    <revision>
      <id>57213</id>
      <parentid>53220</parentid>
      <timestamp>2013-06-01T05:49:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list switch]] to [[Template:cpp/language/dsc switch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc | [[cpp/language/switch | switch conditional ]] | executes code according to the value of an integral argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc template specialization</title>
    <ns>10</ns>
    <id>8396</id>
    <revision>
      <id>57218</id>
      <parentid>53223</parentid>
      <timestamp>2013-06-01T05:49:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list template specialization]] to [[Template:cpp/language/dsc template specialization]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc | [[cpp/language/template_specialization | template specialization ]] | defines a template for specific types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc this</title>
    <ns>10</ns>
    <id>8379</id>
    <revision>
      <id>57222</id>
      <parentid>53226</parentid>
      <timestamp>2013-06-01T05:49:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list this]] to [[Template:cpp/language/dsc this]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc | [[cpp/language/this | this pointer ]] | points to the current instance of a class in member methods}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc throw</title>
    <ns>10</ns>
    <id>6568</id>
    <revision>
      <id>57226</id>
      <parentid>53227</parentid>
      <timestamp>2013-06-01T05:49:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list throw]] to [[Template:cpp/language/dsc throw]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc | [[cpp/language/throw | throw expression ]] | signals an error and transfers control to error handler}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc try catch</title>
    <ns>10</ns>
    <id>6569</id>
    <revision>
      <id>57230</id>
      <parentid>53230</parentid>
      <timestamp>2013-06-01T05:49:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list try catch]] to [[Template:cpp/language/dsc try catch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc | [[cpp/language/try_catch | try-catch block ]] | catches exceptions originating from specific block of code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc type alias</title>
    <ns>10</ns>
    <id>6596</id>
    <revision>
      <id>57235</id>
      <parentid>53233</parentid>
      <timestamp>2013-06-01T05:49:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list type alias]] to [[Template:cpp/language/dsc type alias]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc | [[cpp/language/type_alias | type alias declaration ]] | creates a synonym for a type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc typedef</title>
    <ns>10</ns>
    <id>6595</id>
    <revision>
      <id>57240</id>
      <parentid>53236</parentid>
      <timestamp>2013-06-01T05:49:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list typedef]] to [[Template:cpp/language/dsc typedef]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc | [[cpp/language/typedef | typedef declaration ]] | creates a synonym for a type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc types</title>
    <ns>10</ns>
    <id>6572</id>
    <revision>
      <id>57244</id>
      <parentid>53237</parentid>
      <timestamp>2013-06-01T05:49:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list types]] to [[Template:cpp/language/dsc types]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc | [[cpp/language/types | fundamental types ]] | defines basic character, integer and floating point types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc union</title>
    <ns>10</ns>
    <id>6576</id>
    <revision>
      <id>57249</id>
      <parentid>53240</parentid>
      <timestamp>2013-06-01T05:50:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list union]] to [[Template:cpp/language/dsc union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc | [[cpp/language/union | union types ]] | defines types that can hold data in several representations}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc user literal</title>
    <ns>10</ns>
    <id>6589</id>
    <revision>
      <id>57252</id>
      <parentid>53243</parentid>
      <timestamp>2013-06-01T05:50:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list user literal]] to [[Template:cpp/language/dsc user literal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc | [[cpp/language/user_literal | user-defined literals ]] | constant values of user-specified type {{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc value category</title>
    <ns>10</ns>
    <id>6590</id>
    <revision>
      <id>57255</id>
      <parentid>53246</parentid>
      <timestamp>2013-06-01T05:50:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list value category]] to [[Template:cpp/language/dsc value category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc | [[cpp/language/value_category | value categories ]] | (lvalue, rvalue, glvalue, prvalue, xvalue) classify expressions by their values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc virtual</title>
    <ns>10</ns>
    <id>8383</id>
    <revision>
      <id>57259</id>
      <parentid>53249</parentid>
      <timestamp>2013-06-01T05:50:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list virtual]] to [[Template:cpp/language/dsc virtual]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc | [[cpp/language/virtual | virtual function specifier ]] | declares that a function is virtual}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/dsc while</title>
    <ns>10</ns>
    <id>6556</id>
    <revision>
      <id>57263</id>
      <parentid>53250</parentid>
      <timestamp>2013-06-01T05:50:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/dcl list while]] to [[Template:cpp/language/dsc while]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc | [[cpp/language/while | while loop ]] | executes loop, checking condition before each iteration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/example template</title>
    <ns>10</ns>
    <id>5066</id>
    <revision>
      <id>23453</id>
      <parentid>18322</parentid>
      <timestamp>2012-04-20T02:25:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="227">{{example|code=
template&lt;typename T&gt;
struct S {
    template&lt;typename U&gt; void foo(){}
};

template&lt;typename T&gt;
void bar()
{
    S&lt;T&gt;s;
    s.foo&lt;T&gt;(); // error: &lt; parsed as less than operator
    s.template foo&lt;T&gt;(); // OK
}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/exceptions/navbar</title>
    <ns>10</ns>
    <id>13491</id>
    <revision>
      <id>69060</id>
      <timestamp>2014-03-25T16:22:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="215">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/exceptions/navbar heading
|content3 = cpp/language/exceptions/navbar content
}}</text>
      <sha1>nwqyz9l9vyud15njkj2pj2qm2pp1wof</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/exceptions/navbar content</title>
    <ns>10</ns>
    <id>13493</id>
    <revision>
      <id>69063</id>
      <timestamp>2014-03-25T16:25:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="463">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv | [[cpp/language/throw | throw-expression]]}}
{{nv | [[cpp/language/function-try-block | function-try-block]]}}
{{nv | [[cpp/language/try_catch | try/catch block]]}}
{{nv | [[cpp/language/noexcept_spec | noexcept specifier]]{{mark c++11}}}}
{{nv | [[cpp/language/noexcept | noexcept operator]]{{mark c++11}}}}
{{nv | [[cpp/language/except_spec | exception-specification]]{{mark deprecated}}}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>m8hest04u4r1hqwgytewf79ux47dqxt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/exceptions/navbar heading</title>
    <ns>10</ns>
    <id>13492</id>
    <revision>
      <id>69062</id>
      <timestamp>2014-03-25T16:22:51Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="40">[[cpp/language/exceptions | Exceptions]]</text>
      <sha1>4ontt73cckdlb2ohzf5bp38y1y1tpqi</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/expressions/navbar</title>
    <ns>10</ns>
    <id>13112</id>
    <revision>
      <id>66830</id>
      <parentid>66829</parentid>
      <timestamp>2014-01-03T14:53:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Undo revision 66829 by [[Special:Contributions/Cubbi|Cubbi]] ([[User talk:Cubbi|talk]]) er, not yet</comment>
      <text xml:space="preserve" bytes="217">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/expressions/navbar heading
|content3 = cpp/language/expressions/navbar content
}}</text>
      <sha1>1pfhhlqadriu0y9mnkroc7k241czydr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/expressions/navbar content</title>
    <ns>10</ns>
    <id>13114</id>
    <revision>
      <id>66839</id>
      <parentid>66826</parentid>
      <timestamp>2014-01-03T15:03:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link escape sequences</comment>
      <text xml:space="preserve" bytes="3271">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | General }}
{{nv | [[cpp/language/value_category | value categories]] (lvalue, rvalue, xvalue)}}
{{nv | [[cpp/language/eval_order | order of evaluation]] (sequence points)}}
{{nv | [[cpp/language/constant_expression | constant expressions]]}}
{{nv | [[cpp/language/expressions#Unevaluated expressions | unevaluated expressions]]}}
{{nv | [[cpp/language/expressions#Primary expressions | primary expressions]]}}
{{nv| [[cpp/language/lambda|lambda-expression]]{{mark c++11}}}}
{{nv h2 | Literals }}
{{nv | [[cpp/language/integer_literal|integer literals]]}}
{{nv | [[cpp/language/floating_literal|floating-point literals]]}}
{{nv | [[cpp/language/bool_literal|boolean literals]]}}
{{nv | [[cpp/language/character_literal|character literals]] including [[cpp/language/escape|escape sequences]]}}
{{nv | [[cpp/language/string_literal|string literals]]}}
{{nv | [[cpp/language/nullptr|null pointer literal]]{{mark c++11}}}}
{{nv | [[cpp/language/user_literal|user-defined literal]]{{mark c++11}}}}
{{nv h2 | Operators }}
{{nv | [[cpp/language/operator_assignment | Assignment operators]]: 
{{tt|a{{=}}b}}, {{tt|a+{{=}}b}}, {{tt|a-{{=}}b}}, {{tt|a*{{=}}b}}, {{tt|a/{{=}}b}}, {{tt|a%{{=}}b}}, {{tt|a&amp;{{=}}b}}, {{tt|a{{!}}{{=}}b}}, {{tt|a^{{=}}b}}, {{tt|a&lt;&lt;{{=}}b}}, {{tt|a&gt;&gt;{{=}}}}}}
{{nv | [[cpp/language/operator_incdec | Increment and decrement]]: {{tt|++a}}, {{tt|--a}}, {{tt|a++}}, {{tt|a--}}}}
{{nv | [[cpp/language/operator_arithmetic | Arithmetic operators]]:
{{tt|+a}}, {{tt|-a}}, {{tt|a+b}}, {{tt|a-b}}, {{tt|a*b}}, {{tt|a/b}}, {{tt|a%b}}, {{tt|~a}}, {{tt|a&amp;b}}, {{tt|a{{!}}b}}, {{tt|a^b}}, {{tt|a&lt;&lt;b}}, {{tt|a&gt;&gt;b}} }}
{{nv | [[cpp/language/operator_logical | Logical operators]]: {{tt|a{{!!}}b}}}, {{tt|a&amp;&amp;b}}, {{tt|!a}}}}
{{nv | [[cpp/language/operator_comparison | Comparison operators]]: {{tt|a{{==}}b}}, {{tt|a!{{=}}b}}, {{tt|a&lt;b}}, {{tt|a&gt;b}}, {{tt|a&lt;{{=}}b}}, {{tt|a&gt;{{=}}b}}}}
{{nv | [[cpp/language/operator_member_access | Member access operators]]: {{tt|a[b]}}, {{tt|*a}}, {{tt|&amp;a}}, {{tt|a-&gt;b}}, {{tt|a.b}}, {{tt|a-&gt;*b}}, {{tt|a.*b}}}}
{{nv | [[cpp/language/operator_other | Other operators]]: {{tt|a(...)}}, {{tt|a,b}}, {{tt|(T)a}}, {{tt|a?b:c}} }}
{{nv| [[cpp/language/operator alternative|Alternative representations of operators]]}}
{{nv| [[cpp/language/operator precedence|Precedence and associativity]]}}
{{nv| [[cpp/language/new|new-expression]]}}
{{nv| [[cpp/language/delete|delete-expression]]}}
{{nv| [[cpp/language/throw|throw-expression]]}}
{{nv| [[cpp/language/alignof|alignof]]}}
{{nv| [[cpp/language/sizeof|sizeof]]}}
{{nv| [[cpp/language/sizeof...|sizeof...]]{{mark c++11}}}}
{{nv| [[cpp/language/typeid|typeid]]}}
{{nv| [[cpp/language/noexcept|noexcept]]{{mark c++11}}}}
{{nv| [[cpp/language/operators|Operator overloading]]}}
{{nv h2 | Conversions }}
{{nv| [[cpp/language/implicit_cast|Implicit conversions]]}}
{{nv| [[cpp/language/const_cast|const_cast]]}}
{{nv| [[cpp/language/static_cast|static_cast]]}}
{{nv| [[cpp/language/reinterpret_cast|reinterpret_cast]]}}
{{nv| [[cpp/language/dynamic_cast|dynamic_cast]]}}
{{nv| [[cpp/language/explicit_cast|Explicit conversions]] {{tt|(T)a}}, {{tt|T(a)}}}}
{{nv| [[cpp/language/cast_operator|User-defined conversion]]}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>niv0jls5f4g0r28c9xddq6kmymmekhe</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/expressions/navbar heading</title>
    <ns>10</ns>
    <id>13113</id>
    <revision>
      <id>66824</id>
      <timestamp>2014-01-03T14:20:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="42">[[cpp/language/expressions | Expressions]]</text>
      <sha1>4pt4cm2j43vvk1r1wiidcrokawwrtgg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/functions/navbar</title>
    <ns>10</ns>
    <id>13498</id>
    <revision>
      <id>69210</id>
      <timestamp>2014-03-30T15:05:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="213">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/functions/navbar heading
|content3 = cpp/language/functions/navbar content
}}</text>
      <sha1>eavntocihgclvr6o8316fdv33wnsk6n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/functions/navbar content</title>
    <ns>10</ns>
    <id>13500</id>
    <revision>
      <id>69606</id>
      <parentid>69214</parentid>
      <timestamp>2014-04-15T16:49:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>c++11</comment>
      <text xml:space="preserve" bytes="1039">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | Declarations }}
{{nv | [[cpp/language/function | function declaration]] }}
{{nv | [[cpp/language/function#Parameter_list | function parameter list]] }}
{{nv | [[cpp/language/function#Function_definition | function definition]] }}
{{nv | [[cpp/language/default_arguments | default arguments]] }}
{{nv | [[cpp/language/variadic_arguments | variadic arguments]] }}
{{nv | [[cpp/language/inline | inline specifier]] }}
{{nv | [[cpp/language/lambda | lambda expression]] {{mark c++11}}}}
{{nv h2 | Function calls }}
{{nv | [[cpp/language/adl | argument-dependent lookup (ADL)]] }}
{{nv | [[cpp/language/operator_other#Built-in_function_call_operator | function-call operator]] }}
{{nv | [[cpp/concept/FunctionObject | function objects]] }}
{{nv h2 | Overloading }}
{{nv | [[cpp/language/overload_resolution | overload resolution]] }}
{{nv | [[cpp/language/operators | operator overloading]] }}
{{nv | [[cpp/language/overloaded_address | address of an overload set]] }}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>ds7kwycabmcwvxco8b4t1pesv6p9cm1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/functions/navbar heading</title>
    <ns>10</ns>
    <id>13499</id>
    <revision>
      <id>69211</id>
      <timestamp>2014-03-30T15:05:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="38">[[cpp/language/functions | Functions]]</text>
      <sha1>06dtwcyxebt450vgua5ypqr99dlxm7j</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/initialization/navbar</title>
    <ns>10</ns>
    <id>13100</id>
    <revision>
      <id>66546</id>
      <timestamp>2013-12-05T14:46:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>sub-navbar</comment>
      <text xml:space="preserve" bytes="223">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/initialization/navbar heading
|content3 = cpp/language/initialization/navbar content
}}</text>
      <sha1>o8hk62ulv81f6pplvh9ktl0vnq10bm2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/initialization/navbar content</title>
    <ns>10</ns>
    <id>13102</id>
    <revision>
      <id>66551</id>
      <parentid>66550</parentid>
      <timestamp>2013-12-05T15:01:18Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="1350">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | [[cpp/language/initialization | Initializer ]] }}
{{nv | [[cpp/language/default_initialization | Default initialization]]}}
{{nv | [[cpp/language/value_initialization | Value initialization]]}}
{{nv | [[cpp/language/direct_initialization| Direct initialization]]}}
{{nv | [[cpp/language/copy_initialization|Copy initialization]]}}
{{nv | [[cpp/language/list_initialization|List initialization]]}}
{{nv | [[cpp/language/aggregate_initialization|Aggregate initialization]]}}
{{nv | [[cpp/language/reference_initialization|Reference initialization]]}}
{{nv h2 | [[cpp/language/initialization#Non-local_variables | Static initialization ]] }}
{{nv | [[cpp/language/zero_initialization|Zero initialization]]}}
{{nv | [[cpp/language/constant_initialization|Constant initialization]]}}
{{nv h2 | [[cpp/language/initialization#Non-local_variables | Dynamic non-local initialization]]}}
{{nv | [[cpp/language/initialization#Non-local_variables | Ordered dynamic initialization]]}}
{{nv | [[cpp/language/initialization#Non-local_variables|Unordered dynamic initialization]]}}
{{nv h2 | Class member initialization }}
{{nv | [[cpp/language/initializer_list|Member initializer list]]}}
{{nv | [[cpp/language/data_members#Member_initialization|in-class ''brace-or-equal'' initializer]]}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>nb28gheoo75oq56m4w1ymuv9d7x2dzq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/initialization/navbar heading</title>
    <ns>10</ns>
    <id>13101</id>
    <revision>
      <id>66547</id>
      <timestamp>2013-12-05T14:47:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>sub-navbar</comment>
      <text xml:space="preserve" bytes="48">[[cpp/language/initialization | Initialization]]</text>
      <sha1>alpabu4vmy2mr9o5ip1fmsmfk6bi8og</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/navbar</title>
    <ns>10</ns>
    <id>1585</id>
    <revision>
      <id>39943</id>
      <parentid>35658</parentid>
      <timestamp>2012-09-28T20:11:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="156">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/language/navbar heading
|content2 = cpp/language/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/navbar content</title>
    <ns>10</ns>
    <id>1586</id>
    <revision>
      <id>67830</id>
      <parentid>53253</parentid>
      <timestamp>2014-03-02T16:44:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-ascii</comment>
      <text xml:space="preserve" bytes="6911">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h1 | General topics}}
{{nv col begin}}
{{nv | [[cpp/preprocessor | Preprocessor]]}}
{{nv | [[cpp/comment | Comments]]}}
{{nv | [[cpp/keyword | Keywords]]}}
{{nv col next}}
{{nv | [[cpp/language/escape | Escape sequences]]}}
{{nv | [[cpp/language/history | History of C++]]}}
{{nv col end}}

{{nv h1 | Flow control}}
{{nv h2 | Conditional execution statements}}
{{nv col begin}}
{{nv | [[cpp/language/if | {{tt|if}} statement]]}}
{{nv col next}}
{{nv | [[cpp/language/switch | {{tt|switch}} statement]]}}
{{nv col end}}

{{nv h2 | Iteration statements}}
{{nv col begin}}
{{nv | [[cpp/language/for | {{tt|for}} loop]]}}
{{nv | [[cpp/language/range-for | range-{{tt|for}} loop]] {{mark c++11}}}}
{{nv col next}}
{{nv | [[cpp/language/while | {{tt|while}} loop]]}}
{{nv | [[cpp/language/do | {{tt|do-while}} loop]]}}
{{nv col end}}

{{nv h2 | Jump statements }}
{{nv col begin}}
{{nv | [[cpp/language/continue | {{tt|continue}} statement]]}}
{{nv | [[cpp/language/break | {{tt|break}} statement]]}}
{{nv col next}}
{{nv | [[cpp/language/goto | {{tt|goto}} statement]]}}
{{nv | [[cpp/language/return | {{tt|return}} statement]]}}
{{nv col end}}

{{nv h1 | Functions}}
{{nv | [[cpp/language/function | function declaration]]}}
{{nv | [[cpp/language/lambda | lambda function declaration]]}}
{{nv | [[cpp/language/function_template | function template ]]}}
{{nv | [[cpp/language/inline | inline specifier]]}}
{{nv | [[cpp/language/except_spec | exception specifications]] {{mark deprecated}}}}
{{nv | [[cpp/language/noexcept_spec | noexcept specifier]] {{mark c++11}}}}

{{nv h1 | Exceptions}}
{{nv col begin}}
{{nv | [[cpp/language/throw | throw expression]]}}
{{nv col next}}
{{nv | [[cpp/language/try_catch | try-catch block]]}}
{{nv col end}}

{{nv h1 | Namespaces}}
{{nv col begin}}
{{nv | [[cpp/language/namespace | namespace declaration]]}}
{{nv col next}}
{{nv | [[cpp/language/namespace_alias | namespace aliases]]}}
{{nv col end}}

{{nv h1 | Types}}
{{nv col begin}}
{{nv | [[cpp/language/types | fundamental types]]}}
{{nv | [[cpp/language/class | compound types]]}}
{{nv | [[cpp/language/enum | enumeration types]]}}
{{nv col next}}
{{nv | [[cpp/language/union | union types]]}}
{{nv | [[cpp/language/function | function types]]}}
{{nv col end}}
{{nv | [[cpp/language/decltype | {{tt|decltype}} specifier]] {{mark c++11}}}}

{{nv h2 | Specifiers}}
{{nv | [[cpp/language/cv | cv specifiers]]}}
{{nv | [[cpp/language/storage_duration | storage duration specifiers]]}}
{{nv | [[cpp/language/constexpr | constexpr specifier]] {{mark c++11}}}}
{{nv | [[cpp/language/auto | auto specifier]] {{mark c++11}}}}
{{nv | [[cpp/language/alignas | alignas specifier]] {{mark c++11}}}}

{{nv h2 | Initialization}}
{{nv col begin}}
{{nv | [[cpp/language/default_initialization | default initialization]]}}
{{nv | [[cpp/language/value_initialization | value initialization]]}}
{{nv | [[cpp/language/zero_initialization | zero initialization]]}}
{{nv | [[cpp/language/copy_initialization | copy initialization]]}}
{{nv | [[cpp/language/direct_initialization | direct initialization]]}}
{{nv col next}}
{{nv | [[cpp/language/aggregate_initialization | aggregate initialization]]}}
{{nv | [[cpp/language/list_initialization | list initialization]] {{mark c++11}}}}
{{nv | [[cpp/language/constant_initialization|constant initialization]]}}
{{nv | [[cpp/language/reference_initialization|reference initialization]]}}
{{nv col end}}
{{nv end}}
&lt;/div&gt;
&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | Literals}}
{{nv col begin}}
{{nv | [[cpp/language/integer_literal | integer literals]]}}
{{nv | [[cpp/language/character_literal | character literals]]}} 
{{nv | [[cpp/language/floating_literal | floating-point literals]]}}  
{{nv | [[cpp/language/string_literal | string literals]]}}
{{nv col next}}
{{nv | [[cpp/language/bool_literal| boolean literals]]}}   
{{nv | [[cpp/language/nullptr | nullptr]] {{mark c++11}}}}
{{nv | [[cpp/language/user_literal | user-defined]] {{mark c++11}}}}
{{nv col end}}

{{nv h1 | Expressions}}
{{nv col begin}}
{{nv | [[cpp/language/value_category | value categories]]}}
{{nv | [[cpp/language/eval_order | order of evaluation]]}}
{{nv col next}}
{{nv | [[cpp/language/operators | operators]]}}
{{nv | [[cpp/language/operator_precedence | operator precedence]]}}
{{nv col end}}
{{nv | [[cpp/language/operator_alternative | alternative representations]]}}

{{nv h1 | Utilities}}
{{nv h2 | Types}}
{{nv | [[cpp/language/typedef | {{tt|typedef}} declaration]]}}
{{nv | [[cpp/language/type_alias | type alias declaration]] {{mark c++11}}}}
{{nv | [[cpp/language/attributes | attributes]] {{mark c++11}}}}
{{nv h2 | Casts}}
{{nv | [[cpp/language/implicit_cast | implicit conversions]]}}
{{nv | [[cpp/language/const_cast | {{tt|const_cast}} conversion]]}}
{{nv | [[cpp/language/static_cast | {{tt|static_cast}} conversion]]}}
{{nv | [[cpp/language/dynamic_cast | {{tt|dynamic_cast}} conversion]]}}
{{nv | [[cpp/language/reinterpret_cast | {{tt|reinterpret_cast}} conversion]]}}
{{nv | [[cpp/language/explicit_cast | C-style and functional cast]]}}

{{nv h2 | Memory allocation}}
{{nv col begin}}
{{nv | [[cpp/language/new | {{tt|new}} expression]]}}
{{nv col next}}
{{nv | [[cpp/language/delete | {{tt|delete}} expression]]}}
{{nv col end}}

{{nv h1 | Classes}}
{{nv col begin}}
{{nv | [[cpp/language/class | class declaration]]}}
{{nv | [[cpp/language/this | {{tt|this}} pointer]]}}
{{nv | [[cpp/language/access | access specifiers]]}}
{{nv col next}}
{{nv | [[cpp/language/friend | friend specifier]]}}
{{nv | [[cpp/language/initializer_list | initializer lists]] }}
{{nv col end}}

{{nv h2 | Class-specific function properties}}
{{nv col begin}}
{{nv | [[cpp/language/virtual | virtual function]] }}
{{nv | [[cpp/language/override | override specifier]]  {{mark c++11}}}}
{{nv | [[cpp/language/final | final specifier]]  {{mark c++11}}}}
{{nv col next}}
{{nv | [[cpp/language/explicit | explicit]]  {{mark c++11}}}}
{{nv | [[cpp/language/static | static]] }}
{{nv col end}}

{{nv h2 | Special member functions}}
{{nv col begin}}
{{nv | [[cpp/language/default_constructor | default constructor]]}}
{{nv | [[cpp/language/copy_constructor | copy constructor]]}}
{{nv | [[cpp/language/move_constructor | move constructor]] {{mark c++11}}}}
{{nv col next}}
{{nv | [[cpp/language/as_operator | copy assignment]]}}
{{nv | [[cpp/language/move_operator | move assignment]] {{mark c++11}}}}
{{nv | [[cpp/language/destructor | destructor]]}}
{{nv col end}}
{{nv h1 |Templates }}
{{nv | [[cpp/language/class_template | class template ]]}}
{{nv | [[cpp/language/function_template | function template ]]}}
{{nv | [[cpp/language/template_specialization | template specialization]]}}   
{{nv | [[cpp/language/parameter_pack | parameter packs]] {{mark c++11}}}}
{{nv h1 | Miscellaneous }}
{{nv | [[cpp/language/asm | Inline assembly]]}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>7jlvpzclhd6w1o9yn7hvk8bk9y4lwra</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/navbar heading</title>
    <ns>10</ns>
    <id>1587</id>
    <revision>
      <id>34750</id>
      <parentid>3174</parentid>
      <timestamp>2012-06-15T22:08:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/language/sidebar heading]] to [[Template:cpp/language/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="31">[[cpp/language | C++ language]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/operators</title>
    <ns>10</ns>
    <id>1584</id>
    <revision>
      <id>71854</id>
      <parentid>36566</parentid>
      <timestamp>2014-06-28T10:01:24Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>- 'a = rvalue'</comment>
      <text xml:space="preserve" bytes="1892">{| class=&quot;wikitable&quot;
|- style=&quot;text-align:center&quot;
! colspan=&quot;7&quot; | Common operators 
|- style=&quot;text-align:center&quot;
| [[cpp/language/operator assignment | assignment]]
| [[cpp/language/operator incdec | increment&lt;br&gt;decrement]]
| [[cpp/language/operator arithmetic | arithmetic]]
| [[cpp/language/operator logical | logical]]
| [[cpp/language/operator comparison | comparison]]
| [[cpp/language/operator member access | member&lt;br&gt;access]]
| [[cpp/language/operator other | other]]
|- style=&quot;text-align:center&quot;
| 
{{c|1=a = b
a += b
a -= b
a *= b
a /= b
a %= b
a &amp;= b
a {{!}}= b
a ^= b
a &lt;&lt;= b
a &gt;&gt;= b}}
| 
{{c|1=++a
--a
a++
a--
}}
| 
{{c|1=+a
-a
a + b
a - b
a * b
a / b
a % b
~a
a &amp; b
a {{!}} b
a ^ b
a &lt;&lt; b
a &gt;&gt; b
}}
| 
{{c|1=!a
a &amp;&amp; b
a {{!!}} b
}}
| 
{{c|1=a == b
a != b
a &lt; b
a &gt; b
a &lt;= b
a &gt;= b
}}
| 
{{c|1=a[b]
*a
&amp;a
a-&gt;b
a.b
a-&gt;*b
a.*b
}}
| 
{{c|1=a(...)
a, b
(type) a
? :
}}
|-
! colspan=&quot;7&quot; | Special operators 
|-
| colspan=&quot;7&quot; |
{{ltt|cpp/language/static_cast}} converts one type to another compatible type &lt;br/&gt;
{{ltt|cpp/language/dynamic_cast}} converts virtual base class to derived class&lt;br/&gt;
{{ltt|cpp/language/const_cast}} converts type to compatible type with different [[cpp/language/cv|cv]] qualifiers&lt;br/&gt;
{{ltt|cpp/language/reinterpret_cast}} converts type to incompatible type&lt;br/&gt;
{{ltt|cpp/memory/new/operator_new | new}} allocates memory&lt;br/&gt;
{{ltt|cpp/memory/new/operator_delete | delete}} deallocates memory&lt;br/&gt;
{{ltt|cpp/language/sizeof}} queries the size of a type&lt;br/&gt;
{{ltt|cpp/language/sizeof...}} queries the size of a [[cpp/language/parameter_pack|parameter pack]] {{mark since c++11}}&lt;br/&gt;
{{ltt|cpp/language/typeid}} queries the type information of a type&lt;br/&gt;
{{ltt|cpp/language/noexcept}} checks if an expression can throw an exception {{mark since c++11}}&lt;br/&gt;
{{ltt|cpp/language/alignof}} queries alignment requirements of a type {{mark since c++11}}
|}</text>
      <sha1>mfxqnfyb505lgocqa0kqpgkdk1fe09l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/statements/navbar</title>
    <ns>10</ns>
    <id>9951</id>
    <revision>
      <id>47222</id>
      <timestamp>2013-05-01T19:56:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>I wonder if the giant cpp/language navbar can be split up too..</comment>
      <text xml:space="preserve" bytes="215">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/statements/navbar heading
|content3 = cpp/language/statements/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/statements/navbar content</title>
    <ns>10</ns>
    <id>9949</id>
    <revision>
      <id>53256</id>
      <parentid>47220</parentid>
      <timestamp>2013-06-01T05:00:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1094">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | Labels }}
{{nv | [[cpp/language/statements | {{spar|label}} : {{spar|statement}}]]}}
{{nv h2 | Expression statements }}
{{nv | [[cpp/language/statements | {{spar|expression}} ; ]]}}
{{nv h2 | Compound statements }}
{{nv | [[cpp/language/statements | { {{spar|statement}}... } ]]}}
{{nv h2 | Selection statements }}
{{nv | [[cpp/language/if | if]]}}
{{nv | [[cpp/language/switch | switch]]}}
{{nv h2 | Iteration statements }}
{{nv | [[cpp/language/while | while]]}}
{{nv | [[cpp/language/do | do-while]]}}
{{nv | [[cpp/language/for | for]]}}
{{nv | [[cpp/language/range-for | range for]]{{mark c++11}}}}
{{nv h2 | Jump statements }}
{{nv | [[cpp/language/break | break]]}}
{{nv | [[cpp/language/continue | continue]]}}
{{nv | [[cpp/language/return | return]]}}
{{nv | [[cpp/language/goto | goto]]}}
{{nv h2 | Declaration statements }}
{{nv | [[cpp/language/declarations | {{spar|declaration}} ; ]]}}
{{nv h2 | Try blocks }}
{{nv | [[cpp/language/try_catch | try {{spar|compound-statement}} {{spar|handler-sequence}}]]}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/statements/navbar heading</title>
    <ns>10</ns>
    <id>9950</id>
    <revision>
      <id>47221</id>
      <timestamp>2013-05-01T19:56:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>I wonder if the giant cpp/language navbar can be split up too..</comment>
      <text xml:space="preserve" bytes="40">[[cpp/language/statements | Statements]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/templates/navbar</title>
    <ns>10</ns>
    <id>13504</id>
    <revision>
      <id>69607</id>
      <timestamp>2014-04-15T16:50:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="213">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
|heading2 = cpp/language/navbar heading
|heading3 = cpp/language/templates/navbar heading
|content3 = cpp/language/templates/navbar content
}}</text>
      <sha1>1gn8s4nc3sp1v64kfbwc1isthoal879</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/templates/navbar content</title>
    <ns>10</ns>
    <id>13506</id>
    <revision>
      <id>69853</id>
      <parentid>69610</parentid>
      <timestamp>2014-04-29T12:38:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+template argument deduction</comment>
      <text xml:space="preserve" bytes="894">&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv | [[cpp/language/template_parameters | parameters and arguments]] }}
{{nv | [[cpp/language/class_template | class templates]] }}
{{nv | [[cpp/language/function_template | function templates]] }}
{{nv | [[cpp/language/member_template | class member templates]] }}
{{nv | [[cpp/language/variable_template | variable templates]]{{mark c++14}}}}
{{nv | [[cpp/language/template_argument_deduction | template argument deduction]] }}
{{nv | [[cpp/language/template_specialization | explicit (full) specialization]] }}
{{nv | [[cpp/language/partial_specialization | partial specialization]] }}
{{nv | [[cpp/language/dependent_name | dependent names]] }}
{{nv | [[cpp/language/parameter_pack | parameter packs]]{{mark c++11}}}}
{{nv | [[cpp/language/sizeof... | sizeof...]]{{mark c++11}}}}
{{nv | [[cpp/language/sfinae | SFINAE]] }}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>bgzmo63yhtbgjdvjcf51pp83hfeqp9q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/language/templates/navbar heading</title>
    <ns>10</ns>
    <id>13505</id>
    <revision>
      <id>69608</id>
      <timestamp>2014-04-15T16:51:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="38">[[cpp/language/templates | Templates]]</text>
      <sha1>48m2z2aw4z9ycl7brwvx5j7idgootbm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale//navbar</title>
    <ns>10</ns>
    <id>4443</id>
    <revision>
      <id>35319</id>
      <parentid>15816</parentid>
      <timestamp>2012-06-15T22:22:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale//sidebar]] to [[Template:cpp/locale//navbar]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale//title</title>
    <ns>10</ns>
    <id>8420</id>
    <revision>
      <id>30676</id>
      <parentid>30670</parentid>
      <timestamp>2012-05-07T22:28:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/byname/constructor</title>
    <ns>10</ns>
    <id>12762</id>
    <revision>
      <id>61615</id>
      <parentid>61610</parentid>
      <timestamp>2013-06-06T07:19:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>make generic</comment>
      <text xml:space="preserve" bytes="678">{{member | {{small|std::{{{1}}}::}}{{{1}}} |
{{dcl begin}}
{{dcl | 1=
explicit {{{1}}}( const char* name, std::size_t refs = 0 );
}}
{{dcl | since=c++11 | 1=
explicit {{{1}}}( const std::string&amp; name, std::size_t refs = 0 );
}}
{{dcl end}}

Constructs a new {{tt|std::{{{1}}}}} facet for a locale with {{tt|name}}. 

{{tt|refs}} is used for resource management: if {{c|1=refs == 0}}, the implementation destroys the facet, when the last {{c|std::locale}} object holding it is destroyed. Otherwise, the object is not destroyed.

===Parameters===
{{par begin}}
{{par | name | the name of the locale}}
{{par | refs | the number of references that link to the facet}}
{{par end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/byname/destructor</title>
    <ns>10</ns>
    <id>12763</id>
    <revision>
      <id>61614</id>
      <parentid>61611</parentid>
      <timestamp>2013-06-06T07:18:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>make generic</comment>
      <text xml:space="preserve" bytes="132">{{member | {{small|std::{{{1}}}::}}~{{{1}}} |
{{dcl begin}}
{{dcl | 1=
protected:
~{{{1}}}();
}}
{{dcl end}}

Destroys the facet.
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/byname/dsc constructor</title>
    <ns>10</ns>
    <id>12760</id>
    <revision>
      <id>61636</id>
      <parentid>61612</parentid>
      <timestamp>2013-06-06T07:44:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="98">{{dsc mem ctor | cpp/locale/{{{1|/}}} | inlinemem=true | constructs a new {{tt|{{{1|}}}}} facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/byname/dsc destructor</title>
    <ns>10</ns>
    <id>12761</id>
    <revision>
      <id>61637</id>
      <parentid>61613</parentid>
      <timestamp>2013-06-06T07:44:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="97">{{dsc prot mem dtor | cpp/locale/{{{1|/}}} | inlinemem=true | destroys a {{tt|{{{1|}}}}} facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc always noconv</title>
    <ns>10</ns>
    <id>9471</id>
    <revision>
      <id>57267</id>
      <parentid>53257</parentid>
      <timestamp>2013-06-01T05:50:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list always noconv]] to [[Template:cpp/locale/codecvt/dsc always noconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/locale/codecvt/always_noconv | invokes {{tt|do_always_noconv}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do always noconv</title>
    <ns>10</ns>
    <id>4618</id>
    <revision>
      <id>57271</id>
      <parentid>53260</parentid>
      <timestamp>2013-06-01T05:50:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do always noconv]] to [[Template:cpp/locale/codecvt/dsc do always noconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc prot mem vfun | cpp/locale/codecvt/always_noconv | title=do_always_noconv |tests if the facet encodes an identity conversion for all valid argument values }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do encoding</title>
    <ns>10</ns>
    <id>4617</id>
    <revision>
      <id>57276</id>
      <parentid>53263</parentid>
      <timestamp>2013-06-01T05:50:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do encoding]] to [[Template:cpp/locale/codecvt/dsc do encoding]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc prot mem vfun | cpp/locale/codecvt/encoding | title=do_encoding | returns the number of externT characters necessary to produce one internT character, if constant}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do in</title>
    <ns>10</ns>
    <id>4616</id>
    <revision>
      <id>57280</id>
      <parentid>53266</parentid>
      <timestamp>2013-06-01T05:50:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do in]] to [[Template:cpp/locale/codecvt/dsc do in]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc prot mem vfun | cpp/locale/codecvt/in | title=do_in | mem={{{mem|}}} | converts a string from externT to internT, such as when reading from file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do length</title>
    <ns>10</ns>
    <id>4619</id>
    <revision>
      <id>57283</id>
      <parentid>53267</parentid>
      <timestamp>2013-06-01T05:50:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do length]] to [[Template:cpp/locale/codecvt/dsc do length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="175">{{dsc prot mem vfun | cpp/locale/codecvt/length | title=do_length |calculates the length of the externT string that would be consumed by conversion into given internT buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do max length</title>
    <ns>10</ns>
    <id>4620</id>
    <revision>
      <id>57287</id>
      <parentid>53270</parentid>
      <timestamp>2013-06-01T05:50:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do max length]] to [[Template:cpp/locale/codecvt/dsc do max length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="182">{{dsc prot mem vfun | cpp/locale/codecvt/max_length | title=do_max_length | returns the maximum number of externT characters that could be converted into a single internT character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do out</title>
    <ns>10</ns>
    <id>4615</id>
    <revision>
      <id>57290</id>
      <parentid>53273</parentid>
      <timestamp>2013-06-01T05:50:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do out]] to [[Template:cpp/locale/codecvt/dsc do out]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc prot mem vfun | cpp/locale/codecvt/out | title=do_out | mem={{{mem|}}} | converts a string from internT to externT, such as when writing to file}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc do unshift</title>
    <ns>10</ns>
    <id>4621</id>
    <revision>
      <id>57294</id>
      <parentid>53276</parentid>
      <timestamp>2013-06-01T05:51:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list do unshift]] to [[Template:cpp/locale/codecvt/dsc do unshift]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc prot mem vfun | cpp/locale/codecvt/unshift | title=do_unshift | generates the termination character sequence of externT characters for incomplete conversion}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc encoding</title>
    <ns>10</ns>
    <id>9470</id>
    <revision>
      <id>57299</id>
      <parentid>53279</parentid>
      <timestamp>2013-06-01T05:51:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list encoding]] to [[Template:cpp/locale/codecvt/dsc encoding]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/locale/codecvt/encoding | invokes {{tt|do_encoding}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc in</title>
    <ns>10</ns>
    <id>9468</id>
    <revision>
      <id>57302</id>
      <parentid>53280</parentid>
      <timestamp>2013-06-01T05:51:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list in]] to [[Template:cpp/locale/codecvt/dsc in]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc mem fun | cpp/locale/codecvt/in | invokes {{tt|do_in}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc length</title>
    <ns>10</ns>
    <id>9472</id>
    <revision>
      <id>57306</id>
      <parentid>53283</parentid>
      <timestamp>2013-06-01T05:51:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list length]] to [[Template:cpp/locale/codecvt/dsc length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/locale/codecvt/length | invokes {{tt|do_length}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc max length</title>
    <ns>10</ns>
    <id>9473</id>
    <revision>
      <id>57309</id>
      <parentid>53286</parentid>
      <timestamp>2013-06-01T05:51:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list max length]] to [[Template:cpp/locale/codecvt/dsc max length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/locale/codecvt/max_length | invokes {{tt|do_max_length}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc out</title>
    <ns>10</ns>
    <id>9467</id>
    <revision>
      <id>57312</id>
      <parentid>53289</parentid>
      <timestamp>2013-06-01T05:51:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list out]] to [[Template:cpp/locale/codecvt/dsc out]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc mem fun | cpp/locale/codecvt/out | invokes {{tt|do_out}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/dsc unshift</title>
    <ns>10</ns>
    <id>9469</id>
    <revision>
      <id>57314</id>
      <parentid>53290</parentid>
      <timestamp>2013-06-01T05:51:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/codecvt/dcl list unshift]] to [[Template:cpp/locale/codecvt/dsc unshift]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/locale/codecvt/unshift | invokes {{tt|do_unshift}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/inherit</title>
    <ns>10</ns>
    <id>4561</id>
    <revision>
      <id>60894</id>
      <parentid>53293</parentid>
      <timestamp>2013-06-01T11:59:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1196">{{ inherited | [[cpp/locale/codecvt | {{small|std::}}codecvt]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|intern_type}} | {{tt|internT}}}}
{{dsc | {{tt|extern_type}} | {{tt|externT}}}}
{{dsc | {{tt|state_type}} | {{tt|stateT}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/codecvt/dsc out}}
{{dsc inc | cpp/locale/codecvt/dsc in}}
{{dsc inc | cpp/locale/codecvt/dsc unshift}}
{{dsc inc | cpp/locale/codecvt/dsc encoding}}
{{dsc inc | cpp/locale/codecvt/dsc always_noconv}}
{{dsc inc | cpp/locale/codecvt/dsc length}}
{{dsc inc | cpp/locale/codecvt/dsc max_length}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/codecvt/dsc do_out}}
{{dsc inc | cpp/locale/codecvt/dsc do_in}}
{{dsc inc | cpp/locale/codecvt/dsc do_unshift}}
{{dsc inc | cpp/locale/codecvt/dsc do_encoding}}
{{dsc inc | cpp/locale/codecvt/dsc do_always_noconv}}
{{dsc inc | cpp/locale/codecvt/dsc do_length}}
{{dsc inc | cpp/locale/codecvt/dsc do_max_length}}
{{dsc end}}

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/navbar</title>
    <ns>10</ns>
    <id>4385</id>
    <revision>
      <id>39944</id>
      <parentid>35739</parentid>
      <timestamp>2012-09-28T20:11:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/codecvt/navbar heading
|content3 = cpp/locale/codecvt/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/navbar content</title>
    <ns>10</ns>
    <id>4387</id>
    <revision>
      <id>53296</id>
      <parentid>47436</parentid>
      <timestamp>2013-06-01T05:00:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="573">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/codecvt/codecvt}}
{{nv mem ln | cpp/locale/codecvt/~codecvt}}
{{nv mem ln | cpp/locale/codecvt/out|out|do_out}}
{{nv mem ln | cpp/locale/codecvt/in|in|do_in}}
{{nv mem ln | cpp/locale/codecvt/unshift|unshift|do_unshift}}
{{nv mem ln | cpp/locale/codecvt/encoding|encoding|do_encoding}}
{{nv mem ln | cpp/locale/codecvt/always_noconv|always_noconv|do_always_noconv}}
{{nv mem ln | cpp/locale/codecvt/length|length|do_length}}
{{nv mem ln | cpp/locale/codecvt/max_length|max_length|do_max_length}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/navbar heading</title>
    <ns>10</ns>
    <id>4386</id>
    <revision>
      <id>48072</id>
      <parentid>35741</parentid>
      <timestamp>2013-05-18T18:05:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/locale/codecvt|std::codecvt}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt/title</title>
    <ns>10</ns>
    <id>4384</id>
    <revision>
      <id>15733</id>
      <timestamp>2011-12-15T16:34:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=codecvt::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/codecvt base/inherit</title>
    <ns>10</ns>
    <id>4560</id>
    <revision>
      <id>53299</id>
      <parentid>32722</parentid>
      <timestamp>2013-06-01T05:00:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="590">{{ inherited | [[cpp/locale/codecvt_base | {{small|std::}}codecvt_base]] |
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|enum result { ok, partial, error, noconv };}} | Unscoped enumeration type}}
{{dsc end}}

{{dsc begin}}
{{dsc hitem | Enumeration constant | Definition}}
{{dsc | {{tt|ok}}      | conversion was completed with no error}}
{{dsc | {{tt|partial}} | not all source characters were converted}}
{{dsc | {{tt|error}}   | encountered an invalid character}}
{{dsc | {{tt|noconv}}  | no conversion required, input and output types are the same}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/collation note</title>
    <ns>10</ns>
    <id>9254</id>
    <revision>
      <id>46014</id>
      <parentid>46013</parentid>
      <timestamp>2013-02-13T04:18:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>another tweak</comment>
      <text xml:space="preserve" bytes="554">Collation order is the dictionary order: the position of the letter in the national alphabet (its ''equivalence class'') has higher priority than its case or variant. Within an equivalence class, lowercase characters collate before their uppercase equivalents and locale-specific order may apply to the characters with diacritics. In some locales, groups of characters compare as single ''collation units''. For example, {{c|&quot;ch&quot;}} in Czech follows {{c|&quot;h&quot;}} and precedes {{c|&quot;i&quot;}}, and {{c|&quot;dzs&quot;}} in Hungarian follows {{c|&quot;dz&quot;}} and precedes {{c|&quot;g&quot;}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc compare</title>
    <ns>10</ns>
    <id>9491</id>
    <revision>
      <id>57316</id>
      <parentid>53300</parentid>
      <timestamp>2013-06-01T05:51:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list compare]] to [[Template:cpp/locale/collate/dsc compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/locale/collate/compare | invokes {{tt|do_compare}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc do compare</title>
    <ns>10</ns>
    <id>9256</id>
    <revision>
      <id>57318</id>
      <parentid>53303</parentid>
      <timestamp>2013-06-01T05:51:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list do compare]] to [[Template:cpp/locale/collate/dsc do compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc prot mem vfun | cpp/locale/collate/compare | title=do_compare | compares two strings using this facet's collation rules}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc do hash</title>
    <ns>10</ns>
    <id>9494</id>
    <revision>
      <id>57320</id>
      <parentid>53306</parentid>
      <timestamp>2013-06-01T05:51:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list do hash]] to [[Template:cpp/locale/collate/dsc do hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc prot mem vfun | cpp/locale/collate/hash | title=do_hash | generates an integer hash value using this facet's collation rules }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc do transform</title>
    <ns>10</ns>
    <id>9251</id>
    <revision>
      <id>57323</id>
      <parentid>53309</parentid>
      <timestamp>2013-06-01T05:51:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list do transform]] to [[Template:cpp/locale/collate/dsc do transform]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc prot mem vfun | cpp/locale/collate/transform | title=do_transform | transforms a string so that collation can be replaced by comparison }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc hash</title>
    <ns>10</ns>
    <id>9493</id>
    <revision>
      <id>57327</id>
      <parentid>53312</parentid>
      <timestamp>2013-06-01T05:51:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list hash]] to [[Template:cpp/locale/collate/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/locale/collate/hash | invokes {{tt|do_hash}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/dsc transform</title>
    <ns>10</ns>
    <id>9492</id>
    <revision>
      <id>57330</id>
      <parentid>53313</parentid>
      <timestamp>2013-06-01T05:51:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/collate/dcl list transform]] to [[Template:cpp/locale/collate/dsc transform]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/locale/collate/transform | invokes {{tt|do_transform}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/inherit</title>
    <ns>10</ns>
    <id>9314</id>
    <revision>
      <id>60895</id>
      <parentid>53316</parentid>
      <timestamp>2013-06-01T12:00:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="645">{{ inherited | [[cpp/locale/collate | {{small|std::}}collate]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|charT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;charT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/collate/dsc compare}}
{{dsc inc | cpp/locale/collate/dsc transform}}
{{dsc inc | cpp/locale/collate/dsc hash}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/collate/dsc do_compare}}
{{dsc inc | cpp/locale/collate/dsc do_transform}}
{{dsc inc | cpp/locale/collate/dsc do_hash}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/navbar</title>
    <ns>10</ns>
    <id>4388</id>
    <revision>
      <id>39945</id>
      <parentid>35742</parentid>
      <timestamp>2012-09-28T20:11:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/collate/navbar heading
|content3 = cpp/locale/collate/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/navbar content</title>
    <ns>10</ns>
    <id>4390</id>
    <revision>
      <id>53319</id>
      <parentid>41221</parentid>
      <timestamp>2013-06-01T05:00:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="322">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/collate/collate}}
{{nv mem ln | cpp/locale/collate/~collate}}
{{nv mem ln | cpp/locale/collate/compare|compare|do_compare}}
{{nv mem ln | cpp/locale/collate/transform|transform|do_transform}}
{{nv mem ln | cpp/locale/collate/hash|hash|do_hash}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/navbar heading</title>
    <ns>10</ns>
    <id>4389</id>
    <revision>
      <id>48073</id>
      <parentid>35744</parentid>
      <timestamp>2013-05-18T18:05:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/locale/collate|std::collate}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/collate/title</title>
    <ns>10</ns>
    <id>4392</id>
    <revision>
      <id>38926</id>
      <parentid>15745</parentid>
      <timestamp>2012-08-10T04:09:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=collate::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do is</title>
    <ns>10</ns>
    <id>4631</id>
    <revision>
      <id>57334</id>
      <parentid>53322</parentid>
      <timestamp>2013-06-01T05:51:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do is]] to [[Template:cpp/locale/ctype/dsc do is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc prot mem vfun | cpp/locale/ctype/is | title=do_is | mem={{{mem|}}}| classifies a character or a character sequence }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do narrow</title>
    <ns>10</ns>
    <id>4625</id>
    <revision>
      <id>57338</id>
      <parentid>53323</parentid>
      <timestamp>2013-06-01T05:51:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do narrow]] to [[Template:cpp/locale/ctype/dsc do narrow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc prot mem vfun | cpp/locale/ctype/narrow | title=do_narrow | mem={{{mem|}}}|converts a character or characters from {{tt|charT}} to {{tt|char}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do scan is</title>
    <ns>10</ns>
    <id>4630</id>
    <revision>
      <id>57346</id>
      <parentid>53326</parentid>
      <timestamp>2013-06-01T05:51:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do scan is]] to [[Template:cpp/locale/ctype/dsc do scan is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc prot mem vfun | cpp/locale/ctype/scan_is | title=do_scan_is | mem={{{mem|}}}|locates the first character in a sequence that conforms to given classification}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do scan not</title>
    <ns>10</ns>
    <id>4629</id>
    <revision>
      <id>57350</id>
      <parentid>53329</parentid>
      <timestamp>2013-06-01T05:52:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do scan not]] to [[Template:cpp/locale/ctype/dsc do scan not]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc prot mem vfun | cpp/locale/ctype/scan_not | title=do_scan_not | mem={{{mem|}}}|locates the first character in a sequence that fails given classification}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do tolower</title>
    <ns>10</ns>
    <id>4627</id>
    <revision>
      <id>57353</id>
      <parentid>53332</parentid>
      <timestamp>2013-06-01T05:52:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do tolower]] to [[Template:cpp/locale/ctype/dsc do tolower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc prot mem vfun | cpp/locale/ctype/tolower | title=do_tolower | mem={{{mem|}}}|converts a character or characters to lowercase }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do toupper</title>
    <ns>10</ns>
    <id>4628</id>
    <revision>
      <id>57357</id>
      <parentid>53333</parentid>
      <timestamp>2013-06-01T05:52:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do toupper]] to [[Template:cpp/locale/ctype/dsc do toupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc prot mem vfun | cpp/locale/ctype/toupper | title=do_toupper |mem={{{mem|}}}|converts a character or characters to uppercase  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc do widen</title>
    <ns>10</ns>
    <id>4626</id>
    <revision>
      <id>57362</id>
      <parentid>53336</parentid>
      <timestamp>2013-06-01T05:52:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list do widen]] to [[Template:cpp/locale/ctype/dsc do widen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc prot mem vfun | cpp/locale/ctype/widen | title=do_widen | mem={{{mem|}}}|converts a character or characters from {{tt|char}} to {{tt|charT}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc is</title>
    <ns>10</ns>
    <id>9474</id>
    <revision>
      <id>57366</id>
      <parentid>53339</parentid>
      <timestamp>2013-06-01T05:52:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list is]] to [[Template:cpp/locale/ctype/dsc is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc mem fun | cpp/locale/ctype/is | invokes {{tt|do_is}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc narrow</title>
    <ns>10</ns>
    <id>9480</id>
    <revision>
      <id>57370</id>
      <parentid>53342</parentid>
      <timestamp>2013-06-01T05:52:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list narrow]] to [[Template:cpp/locale/ctype/dsc narrow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/locale/ctype/narrow | invokes {{tt|do_narrow}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc scan is</title>
    <ns>10</ns>
    <id>9475</id>
    <revision>
      <id>57374</id>
      <parentid>53345</parentid>
      <timestamp>2013-06-01T05:52:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list scan is]] to [[Template:cpp/locale/ctype/dsc scan is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/locale/ctype/scan_is | invokes {{tt|do_scan_is}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc scan not</title>
    <ns>10</ns>
    <id>9476</id>
    <revision>
      <id>57378</id>
      <parentid>53346</parentid>
      <timestamp>2013-06-01T05:52:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list scan not]] to [[Template:cpp/locale/ctype/dsc scan not]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/locale/ctype/scan_not | invokes {{tt|do_scan_not}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc tolower</title>
    <ns>10</ns>
    <id>9478</id>
    <revision>
      <id>57383</id>
      <parentid>53349</parentid>
      <timestamp>2013-06-01T05:52:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list tolower]] to [[Template:cpp/locale/ctype/dsc tolower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/locale/ctype/tolower | invokes {{tt|do_tolower}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc toupper</title>
    <ns>10</ns>
    <id>9477</id>
    <revision>
      <id>57387</id>
      <parentid>53352</parentid>
      <timestamp>2013-06-01T05:52:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list toupper]] to [[Template:cpp/locale/ctype/dsc toupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/locale/ctype/toupper | invokes {{tt|do_toupper}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/dsc widen</title>
    <ns>10</ns>
    <id>9479</id>
    <revision>
      <id>57392</id>
      <parentid>53355</parentid>
      <timestamp>2013-06-01T05:52:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype/dcl list widen]] to [[Template:cpp/locale/ctype/dsc widen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/locale/ctype/widen | invokes {{tt|do_widen}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/inherit</title>
    <ns>10</ns>
    <id>9242</id>
    <revision>
      <id>65367</id>
      <parentid>61604</parentid>
      <timestamp>2013-09-10T17:24:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>include &lt;char&gt; specialization pecularities</comment>
      <text xml:space="preserve" bytes="1628">{{ inherited | {{small|std::}}ctype&lt;CharT&gt; |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc mem sconst | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc h2 | if {{c|CharT}} is {{c|char}}, the following member of {{lc|std::ctype&lt;char&gt;}} is inherited }}
{{dsc mem sconst | nolink=true | {{dsc small|static const std::size_t }} table_size | size of the classification table, at least 256}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc is}}
{{dsc inc | cpp/locale/ctype/dsc scan_is}}
{{dsc inc | cpp/locale/ctype/dsc scan_not}}
{{dsc inc | cpp/locale/ctype/dsc toupper}}
{{dsc inc | cpp/locale/ctype/dsc tolower}}
{{dsc inc | cpp/locale/ctype/dsc widen}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc h2 | if {{c|CharT}} is {{c|char}}, the following members of {{lc|std::ctype&lt;char&gt;}} are inherited }}
{{dsc inc | cpp/locale/ctype_char/dsc table}}
{{dsc inc | cpp/locale/ctype_char/dsc classic_table}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_toupper}}
{{dsc inc | cpp/locale/ctype/dsc do_tolower}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc inc | cpp/locale/ctype/dsc do_narrow}}
{{dsc h2 | if {{c|CharT}} is {{c|char}}, the following members of {{lc|std::ctype}} are NOT inherited }}
{{dsc inc | cpp/locale/ctype/dsc do_is}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_is}}
{{dsc inc | cpp/locale/ctype/dsc do_scan_not}}
{{dsc end}}
}}</text>
      <sha1>1s00rey8pe57y0r7fopnp8q33klp8uw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/navbar</title>
    <ns>10</ns>
    <id>3611</id>
    <revision>
      <id>39946</id>
      <parentid>35745</parentid>
      <timestamp>2012-09-28T20:11:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/ctype/navbar heading
|content3 = cpp/locale/ctype/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/navbar content</title>
    <ns>10</ns>
    <id>3613</id>
    <revision>
      <id>63666</id>
      <parentid>53359</parentid>
      <timestamp>2013-07-17T02:21:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>ctype&lt;char&gt; member functions</comment>
      <text xml:space="preserve" bytes="1009">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/ctype/ctype}}
{{nv mem ln | cpp/locale/ctype/~ctype}}
{{nv mem ln | cpp/locale/ctype/is|is|do_is}}
{{nv mem ln | cpp/locale/ctype/scan_is|scan_is|do_scan_is}}
{{nv mem ln | cpp/locale/ctype/scan_not|scan_not|do_scan_not}}
{{nv mem ln | cpp/locale/ctype/toupper|toupper|do_toupper}}
{{nv mem ln | cpp/locale/ctype/tolower|tolower|do_tolower}}
{{nv mem ln | cpp/locale/ctype/widen|widen|do_widen}}
{{nv mem ln | cpp/locale/ctype/narrow|narrow|do_narrow}}
{{nv h2 | Member functions of ctype&lt;char&gt;}}
{{nv ln | cpp/locale/ctype_char/ctype|ctype&lt;char&gt;::ctype}}
{{nv ln | cpp/locale/ctype_char/~ctype|ctype&lt;char&gt;::~ctype}}
{{nv ln | cpp/locale/ctype_char/table|ctype&lt;char&gt;::table}}
{{nv ln | cpp/locale/ctype_char/classic_table|ctype&lt;char&gt;::classic_table}}
{{nv ln | cpp/locale/ctype_char/is|ctype&lt;char&gt;::is}}
{{nv ln | cpp/locale/ctype_char/scan_is|ctype&lt;char&gt;::scan_is}}
{{nv ln | cpp/locale/ctype_char/scan_not|ctype&lt;char&gt;::scan_not}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/navbar heading</title>
    <ns>10</ns>
    <id>3612</id>
    <revision>
      <id>48042</id>
      <parentid>35747</parentid>
      <timestamp>2013-05-18T18:00:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="35">{{ltt|cpp/locale/ctype|std::ctype}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype/title</title>
    <ns>10</ns>
    <id>3610</id>
    <revision>
      <id>13635</id>
      <timestamp>2011-11-10T16:50:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=ctype::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype base/inherit</title>
    <ns>10</ns>
    <id>2783</id>
    <revision>
      <id>53362</id>
      <parentid>32723</parentid>
      <timestamp>2013-06-01T05:00:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1584">{{ inherited | {{small|std::}}ctype_base |
===Member types ===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|mask}} | unspecified bitmask type (enumeration, integer type, or bitset)}}
{{dsc end}}
===Member constants===
{{dsc begin}}
{{dsc mem sconst | space | nolink=true | the value of {{tt|mask}} identifying whitespace character classification }}
{{dsc mem sconst | print | nolink=true | the value of {{tt|mask}} identifying printable character classification }}
{{dsc mem sconst | cntrl | nolink=true | the value of {{tt|mask}} identifying control character classification }}
{{dsc mem sconst | upper | nolink=true | the value of {{tt|mask}} identifying uppercase character classification }}
{{dsc mem sconst | lower | nolink=true | the value of {{tt|mask}} identifying lowercase character classification }}
{{dsc mem sconst | alpha | nolink=true | the value of {{tt|mask}} identifying alphabetic character classification }}
{{dsc mem sconst | digit | nolink=true | the value of {{tt|mask}} identifying digit character classification  }}
{{dsc mem sconst | punct | nolink=true | the value of {{tt|mask}} identifying punctuation character classification }}
{{dsc mem sconst | xdigit | nolink=true | the value of {{tt|mask}} identifying hexadecimal digit character classification }}
{{dsc mem sconst | blank | nolink=true | the value of {{tt|mask}} identifying blank character classification | notes={{mark c++11}}}}
{{dsc mem sconst | alnum | nolink=true | {{c|alpha {{!}} digit}} }}
{{dsc mem sconst | graph | nolink=true | {{c|alnum {{!}} punct}} }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc classic table</title>
    <ns>10</ns>
    <id>9512</id>
    <revision>
      <id>57397</id>
      <parentid>53363</parentid>
      <timestamp>2013-06-01T05:52:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list classic table]] to [[Template:cpp/locale/ctype char/dsc classic table]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem sfun | cpp/locale/ctype_char/classic_table | obtains the &quot;C&quot; locale character classification table }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc constructor</title>
    <ns>10</ns>
    <id>9509</id>
    <revision>
      <id>57401</id>
      <parentid>53366</parentid>
      <timestamp>2013-06-01T05:52:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list constructor]] to [[Template:cpp/locale/ctype char/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem ctor | cpp/locale/ctype_char/ctype | constructs a new {{c|std::ctype&lt;char&gt;}} facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc destructor</title>
    <ns>10</ns>
    <id>9510</id>
    <revision>
      <id>57405</id>
      <parentid>53369</parentid>
      <timestamp>2013-06-01T05:53:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list destructor]] to [[Template:cpp/locale/ctype char/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc prot mem dtor | cpp/locale/ctype_char/~ctype | destructs a {{c|std::ctype&lt;char&gt;}} facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc is</title>
    <ns>10</ns>
    <id>9513</id>
    <revision>
      <id>57408</id>
      <parentid>53374</parentid>
      <timestamp>2013-06-01T05:53:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list is]] to [[Template:cpp/locale/ctype char/dsc is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/locale/ctype_char/is | classifies a character or a character sequence, using the classification table  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc scan is</title>
    <ns>10</ns>
    <id>9514</id>
    <revision>
      <id>57412</id>
      <parentid>53377</parentid>
      <timestamp>2013-06-01T05:53:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list scan is]] to [[Template:cpp/locale/ctype char/dsc scan is]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc mem fun | cpp/locale/ctype_char/scan_is | locates the first character in a sequence that conforms to given classification, using the classification table  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc scan not</title>
    <ns>10</ns>
    <id>9515</id>
    <revision>
      <id>57416</id>
      <parentid>53380</parentid>
      <timestamp>2013-06-01T05:53:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list scan not]] to [[Template:cpp/locale/ctype char/dsc scan not]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc mem fun | cpp/locale/ctype_char/scan_not | locates the first character in a sequence that fails given classification, using the classification table  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/dsc table</title>
    <ns>10</ns>
    <id>9511</id>
    <revision>
      <id>57421</id>
      <parentid>53383</parentid>
      <timestamp>2013-06-01T05:53:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/ctype char/dcl list table]] to [[Template:cpp/locale/ctype char/dsc table]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/locale/ctype_char/table | obtains the character classification table }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/inherit</title>
    <ns>10</ns>
    <id>9244</id>
    <revision>
      <id>60897</id>
      <parentid>53384</parentid>
      <timestamp>2013-06-01T12:00:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1136">{{ inherited | {{small|std::}}ctype&lt;char&gt; |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|char}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc | {{tt|table_size}} {{mark|static const}} | {{lc|std::size_t}} size of the classification table, at least 256}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype_char/dsc table}}
{{dsc inc | cpp/locale/ctype_char/dsc classic_table}}
{{dsc inc | cpp/locale/ctype_char/dsc is}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_is}}
{{dsc inc | cpp/locale/ctype_char/dsc scan_not}}
{{dsc inc | cpp/locale/ctype/dsc toupper}}
{{dsc inc | cpp/locale/ctype/dsc tolower}}
{{dsc inc | cpp/locale/ctype/dsc widen}}
{{dsc inc | cpp/locale/ctype/dsc narrow}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/ctype/dsc do_toupper}}
{{dsc inc | cpp/locale/ctype/dsc do_tolower}}
{{dsc inc | cpp/locale/ctype/dsc do_widen}}
{{dsc inc | cpp/locale/ctype/dsc do_narrow}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/ctype char/title</title>
    <ns>10</ns>
    <id>9245</id>
    <revision>
      <id>53385</id>
      <parentid>38898</parentid>
      <timestamp>2013-06-01T05:01:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="122">&lt;onlyinclude&gt;{{cpp/title | n=ctype{{dsc small|&lt;char&gt;}}::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc LC categories</title>
    <ns>10</ns>
    <id>4404</id>
    <revision>
      <id>57424</id>
      <parentid>53390</parentid>
      <timestamp>2013-06-01T05:53:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list LC categories]] to [[Template:cpp/locale/dsc LC categories]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="173">{{dsc macro const | cpp/locale/LC_categories | title=LC_ALL&lt;br&gt;LC_COLLATE&lt;br&gt;LC_CTYPE&lt;br&gt;LC_MONETARY&lt;br&gt;LC_NUMERIC&lt;br&gt;LC_TIME | locale categories for {{lc|std::setlocale}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt</title>
    <ns>10</ns>
    <id>2895</id>
    <revision>
      <id>57427</id>
      <parentid>53391</parentid>
      <timestamp>2013-06-01T05:53:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt]] to [[Template:cpp/locale/dsc codecvt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tclass | cpp/locale/codecvt | converts between character encodings, including UTF-8, UTF-16, UTF-32}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt base</title>
    <ns>10</ns>
    <id>3584</id>
    <revision>
      <id>57431</id>
      <parentid>53392</parentid>
      <timestamp>2013-06-01T05:53:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt base]] to [[Template:cpp/locale/dsc codecvt base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc class | cpp/locale/codecvt_base | defines character conversion errors }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt byname</title>
    <ns>10</ns>
    <id>3590</id>
    <revision>
      <id>57435</id>
      <parentid>53393</parentid>
      <timestamp>2013-06-01T05:53:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt byname]] to [[Template:cpp/locale/dsc codecvt byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc tclass | cpp/locale/codecvt_byname | represents the system-supplied {{lc|std::codecvt}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt mode</title>
    <ns>10</ns>
    <id>2896</id>
    <revision>
      <id>57438</id>
      <parentid>53394</parentid>
      <timestamp>2013-06-01T05:53:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt mode]] to [[Template:cpp/locale/dsc codecvt mode]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc enum | cpp/locale/codecvt_mode | tags to alter behavior of the standard codecvt facets| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt utf16</title>
    <ns>10</ns>
    <id>2898</id>
    <revision>
      <id>57442</id>
      <parentid>53395</parentid>
      <timestamp>2013-06-01T05:53:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt utf16]] to [[Template:cpp/locale/dsc codecvt utf16]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/locale/codecvt_utf16 | converts between UTF-16 and UCS2/UCS4 | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt utf8</title>
    <ns>10</ns>
    <id>2899</id>
    <revision>
      <id>57446</id>
      <parentid>53396</parentid>
      <timestamp>2013-06-01T05:53:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt utf8]] to [[Template:cpp/locale/dsc codecvt utf8]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc tclass | cpp/locale/codecvt_utf8 | converts between UTF-8 and UCS2/UCS4 | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc codecvt utf8 utf16</title>
    <ns>10</ns>
    <id>2897</id>
    <revision>
      <id>57449</id>
      <parentid>53397</parentid>
      <timestamp>2013-06-01T05:53:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list codecvt utf8 utf16]] to [[Template:cpp/locale/dsc codecvt utf8 utf16]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc tclass | cpp/locale/codecvt_utf8_utf16 | converts between UTF-8 and UTF-16 | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc collate</title>
    <ns>10</ns>
    <id>2893</id>
    <revision>
      <id>57452</id>
      <parentid>53398</parentid>
      <timestamp>2013-06-01T05:53:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list collate]] to [[Template:cpp/locale/dsc collate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tclass | cpp/locale/collate | defines lexicographical comparison and hashing of strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc collate byname</title>
    <ns>10</ns>
    <id>3592</id>
    <revision>
      <id>57457</id>
      <parentid>53399</parentid>
      <timestamp>2013-06-01T05:53:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list collate byname]] to [[Template:cpp/locale/dsc collate byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc tclass | cpp/locale/collate_byname | represents the system-supplied {{lc|std::collate}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ctype</title>
    <ns>10</ns>
    <id>3570</id>
    <revision>
      <id>57461</id>
      <parentid>53400</parentid>
      <timestamp>2013-06-01T05:53:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ctype]] to [[Template:cpp/locale/dsc ctype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc tclass | cpp/locale/ctype | defines character classification tables }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ctype base</title>
    <ns>10</ns>
    <id>3583</id>
    <revision>
      <id>57465</id>
      <parentid>53401</parentid>
      <timestamp>2013-06-01T05:54:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ctype base]] to [[Template:cpp/locale/dsc ctype base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc class | cpp/locale/ctype_base | defines character classification categories }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ctype byname</title>
    <ns>10</ns>
    <id>3588</id>
    <revision>
      <id>57468</id>
      <parentid>53402</parentid>
      <timestamp>2013-06-01T05:54:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ctype byname]] to [[Template:cpp/locale/dsc ctype byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tclass | cpp/locale/ctype_byname | represents the system-supplied {{lc|std::ctype}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ctype byname char</title>
    <ns>10</ns>
    <id>3589</id>
    <revision>
      <id>57472</id>
      <parentid>53403</parentid>
      <timestamp>2013-06-01T05:54:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ctype byname char]] to [[Template:cpp/locale/dsc ctype byname char]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc ptclass | cpp/locale/ctype_byname_char | title=ctype_byname{{dsc small|&lt;char&gt;}} | represents the system-supplied {{c|std::ctype&lt;char&gt;}} for the named locale  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ctype char</title>
    <ns>10</ns>
    <id>3571</id>
    <revision>
      <id>57476</id>
      <parentid>53404</parentid>
      <timestamp>2013-06-01T05:54:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ctype char]] to [[Template:cpp/locale/dsc ctype char]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc ptclass | cpp/locale/ctype_char | title=ctype{{dsc small|&lt;char&gt;}} | specialization of {{lc|std::ctype}} for type {{c|char}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc has facet</title>
    <ns>10</ns>
    <id>2802</id>
    <revision>
      <id>57479</id>
      <parentid>53405</parentid>
      <timestamp>2013-06-01T05:54:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list has facet]] to [[Template:cpp/locale/dsc has facet]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc tfun | cpp/locale/has_facet | checks if a locale implements a specific facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isalnum</title>
    <ns>10</ns>
    <id>2798</id>
    <revision>
      <id>57483</id>
      <parentid>53406</parentid>
      <timestamp>2013-06-01T05:54:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isalnum]] to [[Template:cpp/locale/dsc isalnum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc tfun | cpp/locale/isalnum | title=isalnum{{dsc small|(std::locale)}} | checks if a character is classified as alphanumeric by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isalpha</title>
    <ns>10</ns>
    <id>2794</id>
    <revision>
      <id>57486</id>
      <parentid>53407</parentid>
      <timestamp>2013-06-01T05:54:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isalpha]] to [[Template:cpp/locale/dsc isalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/locale/isalpha | title=isalpha{{dsc small|(std::locale)}} | checks if a character is classified as alphabetic by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isblank</title>
    <ns>10</ns>
    <id>2928</id>
    <revision>
      <id>57490</id>
      <parentid>53408</parentid>
      <timestamp>2013-06-01T05:54:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isblank]] to [[Template:cpp/locale/dsc isblank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc tfun | cpp/locale/isblank | title=isblank{{dsc small|(std::locale)}} | checks if a character is classified as a blank character by a locale | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc iscntrl</title>
    <ns>10</ns>
    <id>2791</id>
    <revision>
      <id>57493</id>
      <parentid>53409</parentid>
      <timestamp>2013-06-01T05:54:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list iscntrl]] to [[Template:cpp/locale/dsc iscntrl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc tfun | cpp/locale/iscntrl | title=iscntrl{{dsc small|(std::locale)}} | checks if a character is classified as a control character by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isdigit</title>
    <ns>10</ns>
    <id>2795</id>
    <revision>
      <id>57496</id>
      <parentid>53410</parentid>
      <timestamp>2013-06-01T05:54:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isdigit]] to [[Template:cpp/locale/dsc isdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/locale/isdigit | title=isdigit{{dsc small|(std::locale)}} | checks if a character is classified as a digit by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isgraph</title>
    <ns>10</ns>
    <id>2800</id>
    <revision>
      <id>57500</id>
      <parentid>53411</parentid>
      <timestamp>2013-06-01T05:54:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isgraph]] to [[Template:cpp/locale/dsc isgraph]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc tfun | cpp/locale/isgraph | title=isgraph{{dsc small|(std::locale)}} | checks if a character is classfied as graphical by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc islower</title>
    <ns>10</ns>
    <id>2793</id>
    <revision>
      <id>57503</id>
      <parentid>53412</parentid>
      <timestamp>2013-06-01T05:54:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list islower]] to [[Template:cpp/locale/dsc islower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/locale/islower | title=islower{{dsc small|(std::locale)}} | checks if a character is classified as lowercase by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isprint</title>
    <ns>10</ns>
    <id>2799</id>
    <revision>
      <id>57506</id>
      <parentid>53413</parentid>
      <timestamp>2013-06-01T05:54:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isprint]] to [[Template:cpp/locale/dsc isprint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/locale/isprint | title=isprint{{dsc small|(std::locale)}} | checks if a character is classified as printable by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc ispunct</title>
    <ns>10</ns>
    <id>2796</id>
    <revision>
      <id>57509</id>
      <parentid>53414</parentid>
      <timestamp>2013-06-01T05:54:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list ispunct]] to [[Template:cpp/locale/dsc ispunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc tfun | cpp/locale/ispunct | title=ispunct{{dsc small|(std::locale)}} | checks if a character is classified as punctuation by a locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isspace</title>
    <ns>10</ns>
    <id>2775</id>
    <revision>
      <id>57513</id>
      <parentid>53415</parentid>
      <timestamp>2013-06-01T05:54:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isspace]] to [[Template:cpp/locale/dsc isspace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/locale/isspace | title=isspace{{dsc small|(std::locale)}} | checks if a character is classified as whitespace by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isupper</title>
    <ns>10</ns>
    <id>2792</id>
    <revision>
      <id>57519</id>
      <parentid>53416</parentid>
      <timestamp>2013-06-01T05:54:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isupper]] to [[Template:cpp/locale/dsc isupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/locale/isupper | title=isupper{{dsc small|(std::locale)}} | checks if a character is classified as uppercase by a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc isxdigit</title>
    <ns>10</ns>
    <id>2797</id>
    <revision>
      <id>57521</id>
      <parentid>53417</parentid>
      <timestamp>2013-06-01T05:54:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list isxdigit]] to [[Template:cpp/locale/dsc isxdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/locale/isxdigit | title=isxdigit{{dsc small|(std::locale)}} | checks if a character is classified as a hexadecimal digit by a locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc lconv</title>
    <ns>10</ns>
    <id>3604</id>
    <revision>
      <id>57525</id>
      <parentid>53418</parentid>
      <timestamp>2013-06-01T05:55:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list lconv]] to [[Template:cpp/locale/dsc lconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc class | cpp/locale/lconv | formatting details, returned by {{lc|std::localeconv}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc locale</title>
    <ns>10</ns>
    <id>2801</id>
    <revision>
      <id>57528</id>
      <parentid>53419</parentid>
      <timestamp>2013-06-01T05:55:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list locale]] to [[Template:cpp/locale/dsc locale]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc class | cpp/locale/locale | set of polymorphic facets that encapsulate cultural differences}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc localeconv</title>
    <ns>10</ns>
    <id>3603</id>
    <revision>
      <id>57531</id>
      <parentid>53420</parentid>
      <timestamp>2013-06-01T05:55:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list localeconv]] to [[Template:cpp/locale/dsc localeconv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/locale/localeconv | queries numeric and monetary formatting details of the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc messages</title>
    <ns>10</ns>
    <id>3572</id>
    <revision>
      <id>57535</id>
      <parentid>53421</parentid>
      <timestamp>2013-06-01T05:55:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list messages]] to [[Template:cpp/locale/dsc messages]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tclass | cpp/locale/messages | implements retrieval of strings from message catalogs}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc messages base</title>
    <ns>10</ns>
    <id>3585</id>
    <revision>
      <id>57538</id>
      <parentid>53422</parentid>
      <timestamp>2013-06-01T05:55:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list messages base]] to [[Template:cpp/locale/dsc messages base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc class | cpp/locale/messages_base | defines messages catalog type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc messages byname</title>
    <ns>10</ns>
    <id>3591</id>
    <revision>
      <id>57542</id>
      <parentid>53423</parentid>
      <timestamp>2013-06-01T05:55:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list messages byname]] to [[Template:cpp/locale/dsc messages byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tclass | cpp/locale/messages_byname | represents the system-supplied {{lc|std::messages}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc money base</title>
    <ns>10</ns>
    <id>3587</id>
    <revision>
      <id>57546</id>
      <parentid>53424</parentid>
      <timestamp>2013-06-01T05:55:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list money base]] to [[Template:cpp/locale/dsc money base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc class | cpp/locale/money_base | defines monetary formatting patterns }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc money get</title>
    <ns>10</ns>
    <id>3578</id>
    <revision>
      <id>57549</id>
      <parentid>53425</parentid>
      <timestamp>2013-06-01T05:55:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list money get]] to [[Template:cpp/locale/dsc money get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc tclass | cpp/locale/money_get | parses and constructs a monetary value from an input character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc money put</title>
    <ns>10</ns>
    <id>3579</id>
    <revision>
      <id>57553</id>
      <parentid>53426</parentid>
      <timestamp>2013-06-01T05:55:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list money put]] to [[Template:cpp/locale/dsc money put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tclass | cpp/locale/money_put | formats a monetary value for output as a character sequence }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc moneypunct</title>
    <ns>10</ns>
    <id>3580</id>
    <revision>
      <id>57556</id>
      <parentid>53427</parentid>
      <timestamp>2013-06-01T05:55:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list moneypunct]] to [[Template:cpp/locale/dsc moneypunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tclass | cpp/locale/moneypunct | defines monetary formatting parameters used by {{lc|std::money_get}} and {{lc|std::money_put}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc moneypunct byname</title>
    <ns>10</ns>
    <id>3596</id>
    <revision>
      <id>57560</id>
      <parentid>53428</parentid>
      <timestamp>2013-06-01T05:55:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list moneypunct byname]] to [[Template:cpp/locale/dsc moneypunct byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tclass | cpp/locale/moneypunct_byname | represents the system-supplied {{lc|std::moneypunct}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc num get</title>
    <ns>10</ns>
    <id>3575</id>
    <revision>
      <id>57565</id>
      <parentid>53429</parentid>
      <timestamp>2013-06-01T05:56:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list num get]] to [[Template:cpp/locale/dsc num get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tclass | cpp/locale/num_get | parses numeric values from an input character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc num put</title>
    <ns>10</ns>
    <id>3576</id>
    <revision>
      <id>57569</id>
      <parentid>53430</parentid>
      <timestamp>2013-06-01T05:56:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list num put]] to [[Template:cpp/locale/dsc num put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc tclass | cpp/locale/num_put | formats numeric values for output as character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc numpunct</title>
    <ns>10</ns>
    <id>3577</id>
    <revision>
      <id>57573</id>
      <parentid>53431</parentid>
      <timestamp>2013-06-01T05:56:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list numpunct]] to [[Template:cpp/locale/dsc numpunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc tclass | cpp/locale/numpunct | defines numeric punctuation rules }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc numpunct byname</title>
    <ns>10</ns>
    <id>3595</id>
    <revision>
      <id>57577</id>
      <parentid>53432</parentid>
      <timestamp>2013-06-01T05:56:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list numpunct byname]] to [[Template:cpp/locale/dsc numpunct byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tclass | cpp/locale/numpunct_byname | represents the system-supplied {{lc|std::numpunct}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc setlocale</title>
    <ns>10</ns>
    <id>1588</id>
    <revision>
      <id>57581</id>
      <parentid>53433</parentid>
      <timestamp>2013-06-01T05:56:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list setlocale]] to [[Template:cpp/locale/dsc setlocale]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | cpp/locale/setlocale | gets and sets the current C locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc time base</title>
    <ns>10</ns>
    <id>3586</id>
    <revision>
      <id>57585</id>
      <parentid>53434</parentid>
      <timestamp>2013-06-01T05:56:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list time base]] to [[Template:cpp/locale/dsc time base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc class | cpp/locale/time_base | defines date format constants }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc time get</title>
    <ns>10</ns>
    <id>3573</id>
    <revision>
      <id>57589</id>
      <parentid>53435</parentid>
      <timestamp>2013-06-01T05:56:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list time get]] to [[Template:cpp/locale/dsc time get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tclass | cpp/locale/time_get | parses time/date values from an input character sequence into {{c|struct std::tm}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc time get byname</title>
    <ns>10</ns>
    <id>3593</id>
    <revision>
      <id>57594</id>
      <parentid>53436</parentid>
      <timestamp>2013-06-01T05:56:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list time get byname]] to [[Template:cpp/locale/dsc time get byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tclass | cpp/locale/time_get_byname | represents the system-supplied {{lc|std::time_get}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc time put</title>
    <ns>10</ns>
    <id>3574</id>
    <revision>
      <id>57597</id>
      <parentid>53437</parentid>
      <timestamp>2013-06-01T05:56:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list time put]] to [[Template:cpp/locale/dsc time put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tclass | cpp/locale/time_put | formats contents of {{c|struct std::tm}} for output as character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc time put byname</title>
    <ns>10</ns>
    <id>3594</id>
    <revision>
      <id>57601</id>
      <parentid>53438</parentid>
      <timestamp>2013-06-01T05:56:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list time put byname]] to [[Template:cpp/locale/dsc time put byname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tclass | cpp/locale/time_put_byname | represents the system-supplied {{lc|std::time_put}} for the named locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc tolower</title>
    <ns>10</ns>
    <id>2805</id>
    <revision>
      <id>57606</id>
      <parentid>53439</parentid>
      <timestamp>2013-06-01T05:56:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list tolower]] to [[Template:cpp/locale/dsc tolower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc tfun | cpp/locale/tolower | title=tolower{{dsc small|(std::locale)}} | converts a character to lowercase using the ctype facet of a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc toupper</title>
    <ns>10</ns>
    <id>2804</id>
    <revision>
      <id>57610</id>
      <parentid>53440</parentid>
      <timestamp>2013-06-01T05:57:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list toupper]] to [[Template:cpp/locale/dsc toupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc tfun | cpp/locale/toupper | title=toupper{{dsc small|(std::locale)}} | converts a character to uppercase using the ctype facet of a locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc use facet</title>
    <ns>10</ns>
    <id>2803</id>
    <revision>
      <id>57615</id>
      <parentid>53441</parentid>
      <timestamp>2013-06-01T05:57:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list use facet]] to [[Template:cpp/locale/dsc use facet]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc tfun | cpp/locale/use_facet | obtains a facet from a locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc wbuffer convert</title>
    <ns>10</ns>
    <id>2807</id>
    <revision>
      <id>57619</id>
      <parentid>53442</parentid>
      <timestamp>2013-06-01T05:57:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list wbuffer convert]] to [[Template:cpp/locale/dsc wbuffer convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc tclass | cpp/locale/wbuffer_convert | performs conversion between a byte stream buffer and a wide stream buffer | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/dsc wstring convert</title>
    <ns>10</ns>
    <id>2806</id>
    <revision>
      <id>57623</id>
      <parentid>53443</parentid>
      <timestamp>2013-06-01T05:57:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/dcl list wstring convert]] to [[Template:cpp/locale/dsc wstring convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc tclass | cpp/locale/wstring_convert | performs conversions between a wide string and a byte string | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/example1</title>
    <ns>10</ns>
    <id>5145</id>
    <revision>
      <id>23454</id>
      <parentid>18595</parentid>
      <timestamp>2012-04-20T02:25:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="333">{{example
 | 
 | code=
#include &lt;clocale&gt;
#include &lt;iostream&gt;

int main()
{
    std::setlocale(LC_ALL, &quot;ja_JP.UTF-8&quot;);
    std::lconv* lc = std::localeconv();
    std::cout &lt;&lt; &quot;Japanese currency symbol: &quot; &lt;&lt; lc-&gt;currency_symbol
              &lt;&lt; '(' &lt;&lt; lc-&gt;int_curr_symbol &lt;&lt; &quot;)\n&quot;;
}
 | output=
Japanese currency symbol: ￥(JPY )
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/facet/constructor</title>
    <ns>10</ns>
    <id>4382</id>
    <revision>
      <id>53444</id>
      <parentid>47784</parentid>
      <timestamp>2013-06-01T05:02:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="445">{{cpp/locale/{{{1|}}}/title | {{{1}}}}}
{{cpp/locale/{{{1|}}}/navbar}}

{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
explicit {{{1}}}( std::size_t refs = 0 );
}}
{{dcl end}}

Creates a {{c|std::{{{1}}}}} facet and forwards the starting reference count {{tt|refs}} to the base class constructor, {{ltt|cpp/locale/locale/facet/facet|locale::facet::facet()}}

===Parameters===
{{par begin}}
{{par | refs | starting reference count}}
{{par end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/facet/destructor</title>
    <ns>10</ns>
    <id>4435</id>
    <revision>
      <id>53445</id>
      <parentid>35331</parentid>
      <timestamp>2013-06-01T05:02:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="944">{{cpp/locale/{{{1|}}}/title | ~{{{1}}}}}
{{cpp/locale/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl header | locale}}
{{dcl | 1=
protected: ~{{{1}}}();
}}
{{dcl end}}

Destructs a {{c|std::{{{1}}}}} facet. This destructor is protected and virtual (due to [[cpp/locale/locale/facet|base class]] destructor being virtual). An object of type {{c|std::{{{1}}}}}, like most facets, can only be destroyed when the last {{lc|std::locale}} object that implements this facet goes out of scope or if a user-defined class is derived from {{c|std::{{{1}}}}} and implements a public destructor.

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;
struct Destructible_{{{1}}} : public std::{{{1}}}&lt;wchar_t&gt;
{
    Destructible_{{{1}}}(std::size_t refs = 0) : {{{1}}}(refs) {}
    ~Destructible_{{{1}}}() {}; // public dtor
};
int main()
{
    Destructible_{{{1}}} dc;
    // std::{{{1}}}&lt;wchar_t&gt; c;  // compile error: protected destructor
}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/facet/title</title>
    <ns>10</ns>
    <id>2955</id>
    <revision>
      <id>11163</id>
      <timestamp>2011-09-28T21:51:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=locale::facet::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/id/title</title>
    <ns>10</ns>
    <id>2946</id>
    <revision>
      <id>11086</id>
      <timestamp>2011-09-28T05:26:52Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=locale::id::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc classic</title>
    <ns>10</ns>
    <id>2876</id>
    <revision>
      <id>57627</id>
      <parentid>53446</parentid>
      <timestamp>2013-06-01T05:57:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list classic]] to [[Template:cpp/locale/locale/dsc classic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem sfun | cpp/locale/locale/classic | obtains a reference to the &quot;C&quot; locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc combine</title>
    <ns>10</ns>
    <id>2887</id>
    <revision>
      <id>57631</id>
      <parentid>53447</parentid>
      <timestamp>2013-06-01T05:57:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list combine]] to [[Template:cpp/locale/locale/dsc combine]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem fun | cpp/locale/locale/combine | constructs a locale with compile-time identified facet copied from another locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc facet</title>
    <ns>10</ns>
    <id>2889</id>
    <revision>
      <id>57635</id>
      <parentid>53448</parentid>
      <timestamp>2013-06-01T05:57:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list facet]] to [[Template:cpp/locale/locale/dsc facet]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc class | cpp/locale/locale/facet | the base class for all facet categories: each facet of any category is derived from this type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc global</title>
    <ns>10</ns>
    <id>2875</id>
    <revision>
      <id>57639</id>
      <parentid>53449</parentid>
      <timestamp>2013-06-01T05:57:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list global]] to [[Template:cpp/locale/locale/dsc global]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem sfun | cpp/locale/locale/global | changes the global locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc id</title>
    <ns>10</ns>
    <id>2888</id>
    <revision>
      <id>57643</id>
      <parentid>53450</parentid>
      <timestamp>2013-06-01T05:57:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list id]] to [[Template:cpp/locale/locale/dsc id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc class | cpp/locale/locale/id | the facet index type: each facet class must declare or inherit a public static member of this type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc locale</title>
    <ns>10</ns>
    <id>2884</id>
    <revision>
      <id>57647</id>
      <parentid>53451</parentid>
      <timestamp>2013-06-01T05:57:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list locale]] to [[Template:cpp/locale/locale/dsc locale]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem ctor | cpp/locale/locale/locale | constructs a new locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc name</title>
    <ns>10</ns>
    <id>2883</id>
    <revision>
      <id>57651</id>
      <parentid>53452</parentid>
      <timestamp>2013-06-01T05:57:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list name]] to [[Template:cpp/locale/locale/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/locale/locale/name | returns the name of the locale or &quot;*&quot; if unnamed }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc operator()</title>
    <ns>10</ns>
    <id>2881</id>
    <revision>
      <id>57654</id>
      <parentid>53453</parentid>
      <timestamp>2013-06-01T05:57:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list operator()]] to [[Template:cpp/locale/locale/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/locale/locale/operator() | lexicographically compares two strings using this locale's collate facet}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc operator=</title>
    <ns>10</ns>
    <id>2886</id>
    <revision>
      <id>57659</id>
      <parentid>53454</parentid>
      <timestamp>2013-06-01T05:58:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list operator=]] to [[Template:cpp/locale/locale/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/locale/locale/operator{{=}} | replaces a locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc operator cmp</title>
    <ns>10</ns>
    <id>2882</id>
    <revision>
      <id>57662</id>
      <parentid>53455</parentid>
      <timestamp>2013-06-01T05:58:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list operator cmp]] to [[Template:cpp/locale/locale/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/locale/locale/operator_cmp | title=operator==&lt;br&gt;operator!= | equality comparison between locale objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/dsc ~locale</title>
    <ns>10</ns>
    <id>2885</id>
    <revision>
      <id>57666</id>
      <parentid>53456</parentid>
      <timestamp>2013-06-01T05:58:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/locale/dcl list ~locale]] to [[Template:cpp/locale/locale/dsc ~locale]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem dtor | cpp/locale/locale/~locale | destructs the locale and the facets whose reference count becomes zero }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/navbar</title>
    <ns>10</ns>
    <id>2878</id>
    <revision>
      <id>39947</id>
      <parentid>35748</parentid>
      <timestamp>2012-09-28T20:11:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/locale/navbar heading
|content3 = cpp/locale/locale/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/navbar content</title>
    <ns>10</ns>
    <id>2890</id>
    <revision>
      <id>53457</id>
      <parentid>35749</parentid>
      <timestamp>2013-06-01T05:02:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="612">{{nv begin}}
{{nv h2 | Member types}}
{{nv mem ln | cpp/locale/locale/id}}
{{nv mem ln | cpp/locale/locale/facet}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/locale/locale}}
{{nv mem ln | cpp/locale/locale/~locale}}
{{nv mem ln | cpp/locale/locale/operator{{=}}}}
{{nv mem ln | cpp/locale/locale/combine}}
{{nv mem ln | cpp/locale/locale/name}}
{{nv mem ln | cpp/locale/locale/operator_cmp | operator{{==}} | operator!{{=}} }}
{{nv mem ln | cpp/locale/locale/operator()}}
{{nv h2 | Static member functions}}
{{nv mem ln | cpp/locale/locale/global}}
{{nv mem ln | cpp/locale/locale/classic}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/navbar heading</title>
    <ns>10</ns>
    <id>2879</id>
    <revision>
      <id>48030</id>
      <parentid>35691</parentid>
      <timestamp>2013-05-18T17:58:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="37">{{ltt|cpp/locale/locale|std::locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/locale/title</title>
    <ns>10</ns>
    <id>2877</id>
    <revision>
      <id>18061</id>
      <parentid>10845</parentid>
      <timestamp>2012-01-20T14:56:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/title]] to [[Template:cpp/locale/locale/title]]: correct title</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=locale::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc close</title>
    <ns>10</ns>
    <id>9487</id>
    <revision>
      <id>57670</id>
      <parentid>53458</parentid>
      <timestamp>2013-06-01T05:58:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list close]] to [[Template:cpp/locale/messages/dsc close]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/locale/messages/close | invokes {{tt|do_close}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc do close</title>
    <ns>10</ns>
    <id>9490</id>
    <revision>
      <id>57674</id>
      <parentid>53459</parentid>
      <timestamp>2013-06-01T05:58:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list do close]] to [[Template:cpp/locale/messages/dsc do close]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc prot mem vfun | cpp/locale/messages/close | title=do_close | closes a message catalog}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc do get</title>
    <ns>10</ns>
    <id>9489</id>
    <revision>
      <id>57678</id>
      <parentid>53460</parentid>
      <timestamp>2013-06-01T05:58:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list do get]] to [[Template:cpp/locale/messages/dsc do get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc prot mem vfun | cpp/locale/messages/get | title=do_get | retrieves a message from an open message catalog}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc do open</title>
    <ns>10</ns>
    <id>9488</id>
    <revision>
      <id>57682</id>
      <parentid>53461</parentid>
      <timestamp>2013-06-01T05:58:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list do open]] to [[Template:cpp/locale/messages/dsc do open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc prot mem vfun | cpp/locale/messages/open | title=do_open | opens a named message catalog }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc get</title>
    <ns>10</ns>
    <id>9486</id>
    <revision>
      <id>57686</id>
      <parentid>53462</parentid>
      <timestamp>2013-06-01T05:58:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list get]] to [[Template:cpp/locale/messages/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/locale/messages/get | invokes {{tt|do_get}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/dsc open</title>
    <ns>10</ns>
    <id>9485</id>
    <revision>
      <id>57690</id>
      <parentid>53463</parentid>
      <timestamp>2013-06-01T05:58:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/messages/dcl list open]] to [[Template:cpp/locale/messages/dsc open]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc mem fun | cpp/locale/messages/open | invokes {{tt|do_open}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/example</title>
    <ns>10</ns>
    <id>9863</id>
    <revision>
      <id>46316</id>
      <timestamp>2013-02-26T04:04:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>can't think of meaningfullly different examples for close, open, and get.. will templatize this one.</comment>
      <text xml:space="preserve" bytes="850">{{example
 | The following example demonstrated retrieval of messages: on a typical GNU/Linux system it reads from {{tt|/usr/share/locale/de/LC_MESSAGES/sed.mo}}
 | code=
#include &lt;iostream&gt;
#include &lt;locale&gt;

int main()
{
    std::locale loc(&quot;de_DE.utf8&quot;);
    std::cout.imbue(loc);
    auto&amp; facet = std::use_facet&lt;std::messages&lt;char&gt;&gt;(loc);
    auto cat = facet.open(&quot;sed&quot;, loc);
    if(cat &lt; 0 )
        std::cout &lt;&lt; &quot;Could not open german \&quot;sed\&quot; message catalog\n&quot;;
    else
        std::cout &lt;&lt; &quot;\&quot;No match\&quot; in German: &quot;
                  &lt;&lt; facet.get(cat, 0, 0, &quot;No match&quot;) &lt;&lt; '\n'
                  &lt;&lt; &quot;\&quot;Memory exhausted\&quot; in German: &quot;
                  &lt;&lt; facet.get(cat, 0, 0, &quot;Memory exhausted&quot;) &lt;&lt; '\n';
    facet.close(cat);
}
 | output=
&quot;No match&quot; in German: Keine Übereinstimmung
&quot;Memory exhausted&quot; in German: Speicher erschöpft
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/inherit</title>
    <ns>10</ns>
    <id>9247</id>
    <revision>
      <id>60898</id>
      <parentid>53464</parentid>
      <timestamp>2013-06-01T12:00:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="782">{{ inherited | [[cpp/locale/messages | {{small|std::}}messages]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|charT}}}}
{{dsc | {{tt|string_type}} | {{tt|std::basic_string&lt;charT&gt;}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/messages/dsc open}}
{{dsc inc | cpp/locale/messages/dsc get}}
{{dsc inc | cpp/locale/messages/dsc close}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/messages/dsc do_open}}
{{dsc inc | cpp/locale/messages/dsc do_get}}
{{dsc inc | cpp/locale/messages/dsc do_close}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/navbar</title>
    <ns>10</ns>
    <id>4393</id>
    <revision>
      <id>39948</id>
      <parentid>35750</parentid>
      <timestamp>2012-09-28T20:11:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/messages/navbar heading
|content3 = cpp/locale/messages/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/navbar content</title>
    <ns>10</ns>
    <id>4395</id>
    <revision>
      <id>53465</id>
      <parentid>41224</parentid>
      <timestamp>2013-06-01T05:02:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="305">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/messages/messages}}
{{nv mem ln | cpp/locale/messages/~messages}}
{{nv mem ln | cpp/locale/messages/open|open|do_open}}
{{nv mem ln | cpp/locale/messages/get|get|do_get}}
{{nv mem ln | cpp/locale/messages/close|close|do_close}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/navbar heading</title>
    <ns>10</ns>
    <id>4394</id>
    <revision>
      <id>48074</id>
      <parentid>35751</parentid>
      <timestamp>2013-05-18T18:05:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/locale/messages|std::messages}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/messages/title</title>
    <ns>10</ns>
    <id>4397</id>
    <revision>
      <id>15751</id>
      <timestamp>2011-12-15T16:48:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=messages::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money base/inherit</title>
    <ns>10</ns>
    <id>12764</id>
    <revision>
      <id>61624</id>
      <timestamp>2013-06-06T07:28:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="879">{{inherited | {{small|std::}}money_base |
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{c|enum part { none, space, symbol, sign, value };}} | unscoped enumeration type}}
{{dsc | {{c|struct pattern { char field[4]; };}} | the monetary format type}}
{{dsc end}}

{{dsc begin}}
{{dsc hitem | Enumeration constant | Definition}}
{{dsc | {{tt|none}}     | whitespace is permitted but not required except in the last position, where whitespace is not permitted}}
{{dsc | {{tt|space}}    | one or more whitespace characters are required}}
{{dsc | {{tt|symbol}}   | the sequence of characters returned by moneypunct::curr_symbol is required}}
{{dsc | {{tt|sign}}     | the first of the characters returned by moneypunct::positive_sign or moneypunct::negative_sign is required}}
{{dsc | {{tt|value}}    | the absolute numeric monetary value is required}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money get/dsc do get</title>
    <ns>10</ns>
    <id>12895</id>
    <revision>
      <id>64430</id>
      <timestamp>2013-08-16T19:32:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">{{dsc prot mem vfun | cpp/locale/money_get/get | title=do_get | parses a monetary value from an input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money get/navbar</title>
    <ns>10</ns>
    <id>4424</id>
    <revision>
      <id>39949</id>
      <parentid>35920</parentid>
      <timestamp>2012-09-28T20:11:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/money_get/navbar heading
|content3 = cpp/locale/money_get/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money get/navbar content</title>
    <ns>10</ns>
    <id>4426</id>
    <revision>
      <id>53466</id>
      <parentid>41225</parentid>
      <timestamp>2013-06-01T05:02:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="199">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/money_get/money_get}}
{{nv mem ln | cpp/locale/money_get/~money_get}}
{{nv mem ln | cpp/locale/money_get/get|get|do_get}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money get/navbar heading</title>
    <ns>10</ns>
    <id>4425</id>
    <revision>
      <id>48077</id>
      <parentid>35754</parentid>
      <timestamp>2013-05-18T18:05:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="43">{{ltt|cpp/locale/money_get|std::money_get}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money get/title</title>
    <ns>10</ns>
    <id>4428</id>
    <revision>
      <id>30673</id>
      <parentid>15797</parentid>
      <timestamp>2012-05-07T22:26:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/money get/title]] to [[Template:cpp/locale/money get/title]]: fix the path</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=money_get::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money put/dsc do put</title>
    <ns>10</ns>
    <id>12896</id>
    <revision>
      <id>64433</id>
      <timestamp>2013-08-16T19:33:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">{{dsc prot mem vfun | cpp/locale/money_put/put | title=do_put | formats a monetary value and writes to output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money put/navbar</title>
    <ns>10</ns>
    <id>4429</id>
    <revision>
      <id>39950</id>
      <parentid>35755</parentid>
      <timestamp>2012-09-28T20:11:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="248">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/money_put/navbar heading
|content3 = cpp/locale/money_put/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money put/navbar content</title>
    <ns>10</ns>
    <id>4431</id>
    <revision>
      <id>61482</id>
      <parentid>61481</parentid>
      <timestamp>2013-06-06T02:44:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="199">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/money_put/money_put}}
{{nv mem ln | cpp/locale/money_put/~money_put}}
{{nv mem ln | cpp/locale/money_put/put|put|do_put}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money put/navbar heading</title>
    <ns>10</ns>
    <id>4430</id>
    <revision>
      <id>48078</id>
      <parentid>35297</parentid>
      <timestamp>2013-05-18T18:06:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <text xml:space="preserve" bytes="43">{{ltt|cpp/locale/money_put|std::money_put}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/money put/title</title>
    <ns>10</ns>
    <id>4433</id>
    <revision>
      <id>30672</id>
      <parentid>15803</parentid>
      <timestamp>2012-05-07T22:26:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/money put/title]] to [[Template:cpp/locale/money put/title]]: fix the path</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=money_put::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc constructor</title>
    <ns>10</ns>
    <id>12684</id>
    <revision>
      <id>61485</id>
      <timestamp>2013-06-06T02:48:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem ctor      | cpp/locale/moneypunct/moneypunct  | constructs a new moneypunct facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc curr symbol</title>
    <ns>10</ns>
    <id>12689</id>
    <revision>
      <id>61490</id>
      <timestamp>2013-06-06T02:49:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/locale/moneypunct/curr_symbol | invokes {{tt|do_curr_symbol}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc decimal point</title>
    <ns>10</ns>
    <id>12686</id>
    <revision>
      <id>61487</id>
      <timestamp>2013-06-06T02:48:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/locale/moneypunct/decimal_point | invokes {{tt|do_decimal_point}}  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc destructor</title>
    <ns>10</ns>
    <id>12685</id>
    <revision>
      <id>61486</id>
      <timestamp>2013-06-06T02:48:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="89">{{dsc prot mem dtor | cpp/locale/moneypunct/~moneypunct | destructs a moneypunct facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do curr symbol</title>
    <ns>10</ns>
    <id>12697</id>
    <revision>
      <id>61498</id>
      <timestamp>2013-06-06T02:50:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="138">{{dsc prot mem vfun | cpp/locale/moneypunct/curr_symbol | title=do_curr_symbol   | provides the string to use as the currency identifier}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do decimal point</title>
    <ns>10</ns>
    <id>12695</id>
    <revision>
      <id>61496</id>
      <timestamp>2013-06-06T02:49:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="133">{{dsc prot mem vfun | cpp/locale/moneypunct/decimal_point | title=do_decimal_point | provides the character to use as decimal point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do frac digits</title>
    <ns>10</ns>
    <id>12700</id>
    <revision>
      <id>61501</id>
      <timestamp>2013-06-06T02:50:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="149">{{dsc prot mem vfun | cpp/locale/moneypunct/frac_digits | title=do_frac_digits   | provides the number of digits to display after the decimal point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do grouping</title>
    <ns>10</ns>
    <id>12696</id>
    <revision>
      <id>61497</id>
      <timestamp>2013-06-06T02:49:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="154">{{dsc prot mem vfun | cpp/locale/moneypunct/grouping | title=do_grouping      | provides the numbers of digits between each pair of thousands separators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do neg format</title>
    <ns>10</ns>
    <id>12702</id>
    <revision>
      <id>61503</id>
      <timestamp>2013-06-06T02:50:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="135">{{dsc prot mem vfun | cpp/locale/moneypunct/neg_format | title=do_neg_format    | provides the formatting pattern for negative values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do negative sign</title>
    <ns>10</ns>
    <id>12699</id>
    <revision>
      <id>61500</id>
      <timestamp>2013-06-06T02:50:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="135">{{dsc prot mem vfun | cpp/locale/moneypunct/negative_sign | title=do_negative_sign | provides the string to indicate a negative value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do pos format</title>
    <ns>10</ns>
    <id>12701</id>
    <revision>
      <id>64096</id>
      <parentid>61502</parentid>
      <timestamp>2013-08-08T23:49:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>combining pos and neg formats</comment>
      <text xml:space="preserve" bytes="152">{{dsc prot mem vfun | cpp/locale/moneypunct/pos_format | title=do_pos_format&lt;br&gt;do_neg_format    | provides the formatting pattern for currency values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do positive sign</title>
    <ns>10</ns>
    <id>12698</id>
    <revision>
      <id>64427</id>
      <parentid>61499</parentid>
      <timestamp>2013-08-16T19:28:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>merge with engative</comment>
      <text xml:space="preserve" bytes="167">{{dsc prot mem vfun | cpp/locale/moneypunct/positive_sign | title=do_positive_sign&lt;br&gt;do_negative_sign | provides the string to indicate a positive or negative value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc do thousands sep</title>
    <ns>10</ns>
    <id>12703</id>
    <revision>
      <id>61504</id>
      <timestamp>2013-06-06T02:50:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="139">{{dsc prot mem vfun | cpp/locale/moneypunct/thousands_sep | title=do_thousands_sep | provides the character to use as thousands separator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc frac digits</title>
    <ns>10</ns>
    <id>12692</id>
    <revision>
      <id>61493</id>
      <timestamp>2013-06-06T02:49:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/locale/moneypunct/frac_digits | invokes {{tt|do_frac_digits}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc grouping</title>
    <ns>10</ns>
    <id>12688</id>
    <revision>
      <id>61489</id>
      <timestamp>2013-06-06T02:49:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/locale/moneypunct/grouping | invokes {{tt|do_grouping}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc neg format</title>
    <ns>10</ns>
    <id>12694</id>
    <revision>
      <id>61495</id>
      <timestamp>2013-06-06T02:49:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/locale/moneypunct/neg_format | invokes {{tt|do_neg_format}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc negative sign</title>
    <ns>10</ns>
    <id>12691</id>
    <revision>
      <id>61492</id>
      <timestamp>2013-06-06T02:49:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/locale/moneypunct/negative_sign | invokes {{tt|do_negative_sign}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc pos format</title>
    <ns>10</ns>
    <id>12693</id>
    <revision>
      <id>64097</id>
      <parentid>61494</parentid>
      <timestamp>2013-08-08T23:50:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>combining pos and neg formats</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem fun | cpp/locale/moneypunct/pos_format | title=pos_format&lt;br&gt;neg_format | invokes {{tt|do_pos_format}}/{{tt|do_neg_format}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc positive sign</title>
    <ns>10</ns>
    <id>12690</id>
    <revision>
      <id>64428</id>
      <parentid>61491</parentid>
      <timestamp>2013-08-16T19:29:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>merge with negative</comment>
      <text xml:space="preserve" bytes="154">{{dsc mem fun | cpp/locale/moneypunct/positive_sign | title=positive_sign&lt;br&gt;negative_sign | invokes {{tt|do_positive_sign}} or {{tt|do_negative_sign}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/dsc thousands sep</title>
    <ns>10</ns>
    <id>12687</id>
    <revision>
      <id>61488</id>
      <timestamp>2013-06-06T02:49:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/locale/moneypunct/thousands_sep | invokes {{tt|do_thousands_sep}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/example1</title>
    <ns>10</ns>
    <id>12875</id>
    <revision>
      <id>64100</id>
      <parentid>64066</parentid>
      <timestamp>2013-08-09T00:04:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>-redundant parens</comment>
      <text xml:space="preserve" bytes="822">{{example
 | 
 | code=
#include &lt;locale&gt;
#include &lt;iostream&gt;
#include &lt;iomanip&gt;
#include &lt;iterator&gt;
struct space_out : std::moneypunct&lt;char&gt; {
    pattern do_pos_format()      const { return { {value, none, none, none} };}
    int do_frac_digits()         const { return 0; }
    char_type do_thousands_sep() const { return ' ';}
    string_type do_grouping()    const { return &quot;\002&quot;;}
};
int main()
{
    std::cout.imbue(std::locale(&quot;en_US.UTF-8&quot;));
    std::cout &lt;&lt; &quot;american locale: &quot; &lt;&lt; std::showbase
              &lt;&lt; std::put_money(12345678.0)&lt;&lt; '\n';

    std::cout.imbue(std::locale(std::cout.getloc(), new space_out));
    std::cout &lt;&lt; &quot;locale with modified moneypunct: &quot;
              &lt;&lt; std::put_money(12345678.0)&lt;&lt; '\n';
}
 | output=
american locale: $123,456.78
locale with modified moneypunct: 12 34 56 78
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/inherit</title>
    <ns>10</ns>
    <id>12765</id>
    <revision>
      <id>64594</id>
      <parentid>61627</parentid>
      <timestamp>2013-08-22T14:32:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>neg sign and neg format were merged</comment>
      <text xml:space="preserve" bytes="1443">{{ inherited | [[cpp/locale/moneypunct | {{small|std::}}moneypunct]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;CharT&gt;}}}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc decimal_point}}
{{dsc inc | cpp/locale/moneypunct/dsc thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc grouping}}
{{dsc inc | cpp/locale/moneypunct/dsc curr_symbol}}
{{dsc inc | cpp/locale/moneypunct/dsc positive_sign}}
{{dsc inc | cpp/locale/moneypunct/dsc frac_digits}}
{{dsc inc | cpp/locale/moneypunct/dsc pos_format}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/moneypunct/dsc do_decimal_point}}
{{dsc inc | cpp/locale/moneypunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/moneypunct/dsc do_grouping}}
{{dsc inc | cpp/locale/moneypunct/dsc do_curr_symbol}}
{{dsc inc | cpp/locale/moneypunct/dsc do_positive_sign}}
{{dsc inc | cpp/locale/moneypunct/dsc do_frac_digits}}
{{dsc inc | cpp/locale/moneypunct/dsc do_pos_format}}
{{dsc end}}

===Member constants===
{{dsc begin}}
{{dsc hitem | Member | Definition}}
{{dsc | {{dsc small|const bool}} {{tt|intl}} {{mark|static}} | {{tt|International}} }}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/navbar</title>
    <ns>10</ns>
    <id>3753</id>
    <revision>
      <id>39951</id>
      <parentid>35506</parentid>
      <timestamp>2012-09-28T20:11:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/moneypunct/navbar heading
|content3 = cpp/locale/moneypunct/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/navbar content</title>
    <ns>10</ns>
    <id>3755</id>
    <revision>
      <id>64426</id>
      <parentid>64424</parentid>
      <timestamp>2013-08-16T19:27:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>merged the signs too</comment>
      <text xml:space="preserve" bytes="752">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/moneypunct/moneypunct}}
{{nv mem ln | cpp/locale/moneypunct/~moneypunct}}
{{nv mem ln | cpp/locale/moneypunct/decimal_point|decimal_point|do_decimal_point}}
{{nv mem ln | cpp/locale/moneypunct/thousands_sep|thousands_sep|do_thousands_sep}}
{{nv mem ln | cpp/locale/moneypunct/grouping|grouping|do_grouping}}
{{nv mem ln | cpp/locale/moneypunct/curr_symbol|curr_symbol|do_curr_symbol}}
{{nv mem ln | cpp/locale/moneypunct/frac_digits|frac_digits|do_frac_digits}}
{{nv mem ln | cpp/locale/moneypunct/positive_sign|positive_sign|do_positive_sign|negative_sign|do_negative_sign}}
{{nv mem ln | cpp/locale/moneypunct/pos_format|pos_format|do_pos_format|neg_format|do_neg_format}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/navbar heading</title>
    <ns>10</ns>
    <id>3754</id>
    <revision>
      <id>48051</id>
      <parentid>35756</parentid>
      <timestamp>2013-05-18T18:01:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="45">{{ltt|cpp/locale/moneypunct|std::moneypunct}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/moneypunct/title</title>
    <ns>10</ns>
    <id>3752</id>
    <revision>
      <id>30671</id>
      <parentid>13979</parentid>
      <timestamp>2012-05-07T22:25:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/moneypunct/title]] to [[Template:cpp/locale/moneypunct/title]]: fix the path</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=moneypunct::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/navbar</title>
    <ns>10</ns>
    <id>1589</id>
    <revision>
      <id>39952</id>
      <parentid>35678</parentid>
      <timestamp>2012-09-28T20:11:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="152">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/navbar content</title>
    <ns>10</ns>
    <id>2776</id>
    <revision>
      <id>65364</id>
      <parentid>53469</parentid>
      <timestamp>2013-09-10T16:37:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no ctype_byname&lt;char&gt;</comment>
      <text xml:space="preserve" bytes="2708">{{nv begin}}
{{nv h1 | Locales and facets}}
{{nv ln | cpp/locale/locale}}
{{nv col begin}}
{{nv ln | cpp/locale/use_facet}}
{{nv col next}}
{{nv ln | cpp/locale/has_facet}}
{{nv col end}}
{{nv h2 | Character classification}}
{{nv col begin}}
{{nv ln | cpp/locale/isspace}}
{{nv ln | cpp/locale/isblank | notes={{mark c++11}} }}
{{nv ln | cpp/locale/iscntrl}}
{{nv ln | cpp/locale/isupper}}
{{nv ln | cpp/locale/islower}}
{{nv ln | cpp/locale/isalpha}}
{{nv col next}}
{{nv ln | cpp/locale/isdigit}}
{{nv ln | cpp/locale/ispunct}}
{{nv ln | cpp/locale/isxdigit}}
{{nv ln | cpp/locale/isalnum}}
{{nv ln | cpp/locale/isprint}}
{{nv ln | cpp/locale/isgraph}}
{{nv col end}}

{{nv h2 | Conversions}}
{{nv col begin}}
{{nv ln | cpp/locale/toupper}}
{{nv ln | cpp/locale/tolower}}
{{nv col next}}
{{nv ln | cpp/locale/wstring_convert | notes={{mark c++11}}}}
{{nv ln | cpp/locale/wbuffer_convert | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Facet category base classes}}
{{nv col begin}}
{{nv ln | cpp/locale/ctype_base}}
{{nv ln | cpp/locale/codecvt_base}}
{{nv ln | cpp/locale/messages_base}}
{{nv col next}}
{{nv ln | cpp/locale/time_base}}
{{nv ln | cpp/locale/money_base}}
{{nv col end}}

{{nv h2 | Facet categories}}
{{nv col begin}}
{{nv ln | cpp/locale/ctype }}
{{nv ln | cpp/locale/ctype_char | ctype&lt;char&gt; }}
{{nv ln | cpp/locale/codecvt}}
{{nv ln | cpp/locale/collate}}
{{nv ln | cpp/locale/messages}}
{{nv ln | cpp/locale/time_get}}
{{nv ln | cpp/locale/time_put}}
{{nv col next}}
{{nv ln | cpp/locale/num_get }}
{{nv ln | cpp/locale/num_put }}
{{nv ln | cpp/locale/numpunct}}
{{nv ln | cpp/locale/money_get }}
{{nv ln | cpp/locale/money_put }}
{{nv ln | cpp/locale/moneypunct}}
{{nv col end}}

{{nv h2 | Locale-specific facets}}
{{nv col begin}}
{{nv ln | cpp/locale/ctype_byname}}
{{nv ln | cpp/locale/codecvt_byname}}
{{nv ln | cpp/locale/messages_byname}}
{{nv ln | cpp/locale/collate_byname}}
{{nv col next}}
{{nv ln | cpp/locale/time_get_byname}}
{{nv ln | cpp/locale/time_put_byname}}
{{nv ln | cpp/locale/numpunct_byname}}
{{nv ln | cpp/locale/moneypunct_byname}}
{{nv col end}}

{{nv h2 | Code conversion facets}}
{{nv col begin}}
{{nv ln | cpp/locale/codecvt_utf8 | notes={{mark c++11}}}}
{{nv ln | cpp/locale/codecvt_utf16 | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/locale/codecvt_utf8_utf16 | notes={{mark c++11}}}}
{{nv ln | cpp/locale/codecvt_mode | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | C locale}}
{{nv col begin}}
{{nv ln | cpp/locale/setlocale}}
{{nv ln | cpp/locale/localeconv}}
{{nv ln | cpp/locale/lconv}}
{{nv col next}}
{{nv ln | cpp/locale/LC_categories | LC_ALL | LC_COLLATE | LC_CTYPE | LC_MONETARY | LC_NUMERIC | LC_TIME}}
{{nv col end}}
{{nv end}}</text>
      <sha1>do3eheimcn2kw07dlfnbov93j4ugddg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/navbar heading</title>
    <ns>10</ns>
    <id>1590</id>
    <revision>
      <id>35768</id>
      <parentid>3180</parentid>
      <timestamp>2012-06-15T22:31:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/sidebar heading]] to [[Template:cpp/locale/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="38">[[cpp/locale | Localizations library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num get/navbar</title>
    <ns>10</ns>
    <id>4045</id>
    <revision>
      <id>39953</id>
      <parentid>35757</parentid>
      <timestamp>2012-09-28T20:11:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/num_get/navbar heading
|content3 = cpp/locale/num_get/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num get/navbar content</title>
    <ns>10</ns>
    <id>4047</id>
    <revision>
      <id>53470</id>
      <parentid>47437</parentid>
      <timestamp>2013-06-01T05:02:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="189">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/num_get/num_get}}
{{nv mem ln | cpp/locale/num_get/~num_get}}
{{nv mem ln | cpp/locale/num_get/get|get|do_get}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num get/navbar heading</title>
    <ns>10</ns>
    <id>4046</id>
    <revision>
      <id>48069</id>
      <parentid>35759</parentid>
      <timestamp>2013-05-18T18:05:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/locale/num_get|std::num_get}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num get/title</title>
    <ns>10</ns>
    <id>4416</id>
    <revision>
      <id>15783</id>
      <timestamp>2011-12-15T17:13:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=num_get::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num put/navbar</title>
    <ns>10</ns>
    <id>4250</id>
    <revision>
      <id>39954</id>
      <parentid>35760</parentid>
      <timestamp>2012-09-28T20:11:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/num_put/navbar heading
|content3 = cpp/locale/num_put/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num put/navbar content</title>
    <ns>10</ns>
    <id>4252</id>
    <revision>
      <id>53471</id>
      <parentid>47415</parentid>
      <timestamp>2013-06-01T05:02:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="189">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/num_put/num_put}}
{{nv mem ln | cpp/locale/num_put/~num_put}}
{{nv mem ln | cpp/locale/num_put/put|put|do_put}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num put/navbar heading</title>
    <ns>10</ns>
    <id>4251</id>
    <revision>
      <id>48070</id>
      <parentid>35761</parentid>
      <timestamp>2013-05-18T18:05:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/locale/num_put|std::num_put}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/num put/title</title>
    <ns>10</ns>
    <id>4249</id>
    <revision>
      <id>30675</id>
      <parentid>15393</parentid>
      <timestamp>2012-05-07T22:26:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/num put/title]] to [[Template:cpp/locale/num put/title]]: fix the path</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=num_put::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc decimal point</title>
    <ns>10</ns>
    <id>4680</id>
    <revision>
      <id>57695</id>
      <parentid>53472</parentid>
      <timestamp>2013-06-01T05:59:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list decimal point]] to [[Template:cpp/locale/numpunct/dsc decimal point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem fun | cpp/locale/numpunct/decimal_point | invokes {{tt|do_decimal_point}} | mem={{{mem|}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc do decimal point</title>
    <ns>10</ns>
    <id>4685</id>
    <revision>
      <id>57700</id>
      <parentid>53473</parentid>
      <timestamp>2013-06-01T05:59:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list do decimal point]] to [[Template:cpp/locale/numpunct/dsc do decimal point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc prot mem vfun | cpp/locale/numpunct/decimal_point | title=do_decimal_point | provides the character to use as decimal point  | mem={{{mem|}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc do grouping</title>
    <ns>10</ns>
    <id>4687</id>
    <revision>
      <id>57704</id>
      <parentid>53474</parentid>
      <timestamp>2013-06-01T05:59:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list do grouping]] to [[Template:cpp/locale/numpunct/dsc do grouping]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc prot mem vfun | cpp/locale/numpunct/grouping | title=do_grouping | provides the numbers of digits between each pair of thousands 
separators | mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc do thousands sep</title>
    <ns>10</ns>
    <id>4686</id>
    <revision>
      <id>57709</id>
      <parentid>53475</parentid>
      <timestamp>2013-06-01T05:59:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list do thousands sep]] to [[Template:cpp/locale/numpunct/dsc do thousands sep]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc prot mem vfun | cpp/locale/numpunct/thousands_sep | title=do_thousands_sep | provides the character to use as thousands separator | mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc do truefalsename</title>
    <ns>10</ns>
    <id>9925</id>
    <revision>
      <id>57714</id>
      <parentid>53476</parentid>
      <timestamp>2013-06-01T05:59:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list do truefalsename]] to [[Template:cpp/locale/numpunct/dsc do truefalsename]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="195">{{dsc prot mem vfun | cpp/locale/numpunct/truefalsename | title=do_truename&lt;br/&gt;do_falsename | provides the string to use as the name of the boolean {{c|true}} and {{c|false}} | mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc grouping</title>
    <ns>10</ns>
    <id>4682</id>
    <revision>
      <id>57718</id>
      <parentid>53477</parentid>
      <timestamp>2013-06-01T05:59:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list grouping]] to [[Template:cpp/locale/numpunct/dsc grouping]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | cpp/locale/numpunct/grouping | invokes {{tt|do_grouping}}  | mem={{{mem|}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc numpunct</title>
    <ns>10</ns>
    <id>4678</id>
    <revision>
      <id>57722</id>
      <parentid>53478</parentid>
      <timestamp>2013-06-01T05:59:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list numpunct]] to [[Template:cpp/locale/numpunct/dsc numpunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem ctor | cpp/locale/numpunct/numpunct | constructs a new numpunct facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc thousands sep</title>
    <ns>10</ns>
    <id>4681</id>
    <revision>
      <id>57726</id>
      <parentid>53479</parentid>
      <timestamp>2013-06-01T05:59:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list thousands sep]] to [[Template:cpp/locale/numpunct/dsc thousands sep]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/locale/numpunct/thousands_sep | invokes {{tt|do_thousands_sep}} | mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc truefalsename</title>
    <ns>10</ns>
    <id>9924</id>
    <revision>
      <id>57731</id>
      <parentid>53480</parentid>
      <timestamp>2013-06-01T05:59:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list truefalsename]] to [[Template:cpp/locale/numpunct/dsc truefalsename]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc mem fun | title=truename&lt;br&gt;falsename | cpp/locale/numpunct/truefalsename | invokes {{tt|do_truename}} or {{tt|do_falsename}}| mem={{{mem|}}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/dsc ~numpunct</title>
    <ns>10</ns>
    <id>4679</id>
    <revision>
      <id>57735</id>
      <parentid>53481</parentid>
      <timestamp>2013-06-01T05:59:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/numpunct/dcl list ~numpunct]] to [[Template:cpp/locale/numpunct/dsc ~numpunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc prot mem dtor | cpp/locale/numpunct/~numpunct | destructs a numpunct facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/inherit</title>
    <ns>10</ns>
    <id>12766</id>
    <revision>
      <id>61632</id>
      <parentid>61631</parentid>
      <timestamp>2013-06-06T07:34:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>whitespace</comment>
      <text xml:space="preserve" bytes="929">{{inherited | [[cpp/locale/numpunct | {{small|std::}}numpunct]] |
===Member types===
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|charT}}}}
{{dsc | {{tt|string_type}} | {{c|std::basic_string&lt;charT&gt;}}}}
{{dsc end}}
===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc decimal_point}}
{{dsc inc | cpp/locale/numpunct/dsc thousands_sep}}
{{dsc inc | cpp/locale/numpunct/dsc grouping}}
{{dsc inc | cpp/locale/numpunct/dsc truefalsename}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/numpunct/dsc do_decimal_point}}
{{dsc inc | cpp/locale/numpunct/dsc do_thousands_sep}}
{{dsc inc | cpp/locale/numpunct/dsc do_grouping}}
{{dsc inc | cpp/locale/numpunct/dsc do_truefalsename}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc mem obj | nolink=true | {{dsc small|static std::locale::id}} id | ''id'' of the locale }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/navbar</title>
    <ns>10</ns>
    <id>3748</id>
    <revision>
      <id>39955</id>
      <parentid>35762</parentid>
      <timestamp>2012-09-28T20:11:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/numpunct/navbar heading
|content3 = cpp/locale/numpunct/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/navbar content</title>
    <ns>10</ns>
    <id>3750</id>
    <revision>
      <id>53482</id>
      <parentid>47026</parentid>
      <timestamp>2013-06-01T05:02:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="465">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/numpunct/numpunct}}
{{nv mem ln | cpp/locale/numpunct/~numpunct}}
{{nv mem ln | cpp/locale/numpunct/decimal_point|decimal_point|do_decimal_point}}
{{nv mem ln | cpp/locale/numpunct/thousands_sep|thousands_sep|do_thousands_sep}}
{{nv mem ln | cpp/locale/numpunct/grouping|grouping|do_grouping}}
{{nv mem ln | cpp/locale/numpunct/truefalsename|truename|do_truename|falsename|do_falsename}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/navbar heading</title>
    <ns>10</ns>
    <id>3749</id>
    <revision>
      <id>48050</id>
      <parentid>35765</parentid>
      <timestamp>2013-05-18T18:01:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/locale/numpunct|std::numpunct}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/numpunct/title</title>
    <ns>10</ns>
    <id>3747</id>
    <revision>
      <id>47027</id>
      <parentid>30674</parentid>
      <timestamp>2013-04-23T13:24:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>support 4 arguments</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=numpunct::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}} | {{{4|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc date order</title>
    <ns>10</ns>
    <id>9495</id>
    <revision>
      <id>57739</id>
      <parentid>53483</parentid>
      <timestamp>2013-06-01T05:59:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list date order]] to [[Template:cpp/locale/time get/dsc date order]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/locale/time_get/date_order | invokes {{tt|do_date_order}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do date order</title>
    <ns>10</ns>
    <id>9502</id>
    <revision>
      <id>57743</id>
      <parentid>53484</parentid>
      <timestamp>2013-06-01T05:59:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do date order]] to [[Template:cpp/locale/time get/dsc do date order]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc prot mem vfun | cpp/locale/time_get/date_order | title=do_date_order| obtains preferred ordering of day, month, and year}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get</title>
    <ns>10</ns>
    <id>9508</id>
    <revision>
      <id>57747</id>
      <parentid>53485</parentid>
      <timestamp>2013-06-01T06:00:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get]] to [[Template:cpp/locale/time get/dsc do get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc prot mem vfun | cpp/locale/time_get/get | title=do_get | extracts date/time components from input stream, according to the specified format | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get date</title>
    <ns>10</ns>
    <id>9504</id>
    <revision>
      <id>57751</id>
      <parentid>53486</parentid>
      <timestamp>2013-06-01T06:00:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get date]] to [[Template:cpp/locale/time get/dsc do get date]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc prot mem vfun | cpp/locale/time_get/get_date | title=do_get_date  | extracts month, day, and year from input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get monthname</title>
    <ns>10</ns>
    <id>9506</id>
    <revision>
      <id>57755</id>
      <parentid>53489</parentid>
      <timestamp>2013-06-01T06:00:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get monthname]] to [[Template:cpp/locale/time get/dsc do get monthname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc prot mem vfun | cpp/locale/time_get/get_monthname | title=do_get_monthname | extacts a month name from input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get time</title>
    <ns>10</ns>
    <id>9503</id>
    <revision>
      <id>57759</id>
      <parentid>53492</parentid>
      <timestamp>2013-06-01T06:00:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get time]] to [[Template:cpp/locale/time get/dsc do get time]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc prot mem vfun | cpp/locale/time_get/get_time | title=do_get_time | extracts hours, minutes, and seconds from input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get weekday</title>
    <ns>10</ns>
    <id>9505</id>
    <revision>
      <id>57763</id>
      <parentid>53495</parentid>
      <timestamp>2013-06-01T06:00:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get weekday]] to [[Template:cpp/locale/time get/dsc do get weekday]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc prot mem vfun | cpp/locale/time_get/get_weekday | title=do_get_weekday | extracts the name of a day of the week from input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc do get year</title>
    <ns>10</ns>
    <id>9507</id>
    <revision>
      <id>57768</id>
      <parentid>53496</parentid>
      <timestamp>2013-06-01T06:00:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list do get year]] to [[Template:cpp/locale/time get/dsc do get year]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc prot mem vfun | cpp/locale/time_get/get_year | title=do_get_year | extracts a year from input stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get</title>
    <ns>10</ns>
    <id>9501</id>
    <revision>
      <id>57772</id>
      <parentid>53499</parentid>
      <timestamp>2013-06-01T06:00:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get]] to [[Template:cpp/locale/time get/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/locale/time_get/get | invokes {{tt|do_get}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get date</title>
    <ns>10</ns>
    <id>9497</id>
    <revision>
      <id>57776</id>
      <parentid>53502</parentid>
      <timestamp>2013-06-01T06:00:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get date]] to [[Template:cpp/locale/time get/dsc get date]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/locale/time_get/get_date | invokes {{tt|do_get_date}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get monthname</title>
    <ns>10</ns>
    <id>9499</id>
    <revision>
      <id>57779</id>
      <parentid>53505</parentid>
      <timestamp>2013-06-01T06:00:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get monthname]] to [[Template:cpp/locale/time get/dsc get monthname]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/locale/time_get/get_monthname | invokes {{tt|do_get_monthname}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get time</title>
    <ns>10</ns>
    <id>9496</id>
    <revision>
      <id>57783</id>
      <parentid>53506</parentid>
      <timestamp>2013-06-01T06:00:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get time]] to [[Template:cpp/locale/time get/dsc get time]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/locale/time_get/get_time | invokes {{tt|do_get_time}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get weekday</title>
    <ns>10</ns>
    <id>9498</id>
    <revision>
      <id>57787</id>
      <parentid>53509</parentid>
      <timestamp>2013-06-01T06:01:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get weekday]] to [[Template:cpp/locale/time get/dsc get weekday]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/locale/time_get/get_weekday | invokes {{tt|do_get_weekday}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/dsc get year</title>
    <ns>10</ns>
    <id>9500</id>
    <revision>
      <id>57791</id>
      <parentid>53512</parentid>
      <timestamp>2013-06-01T06:01:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time get/dcl list get year]] to [[Template:cpp/locale/time get/dsc get year]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/locale/time_get/get_year | invokes {{tt|do_get_year}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/inherit</title>
    <ns>10</ns>
    <id>9316</id>
    <revision>
      <id>60899</id>
      <parentid>53515</parentid>
      <timestamp>2013-06-01T12:00:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="1418">{{ inherited | [[cpp/locale/time_get | {{small|std::}}time_get]] |
{{dsc begin}}
{{dsc hitem | Member type | Definition}}
{{dsc | {{tt|char_type}} | {{tt|CharT}}}}
{{dsc | {{tt|iter_type}} | {{tt|InputIt}}}}
{{dsc end}}

===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_get/dsc date_order}}
{{dsc inc | cpp/locale/time_get/dsc get_time}}
{{dsc inc | cpp/locale/time_get/dsc get_date}}
{{dsc inc | cpp/locale/time_get/dsc get_weekday}}
{{dsc inc | cpp/locale/time_get/dsc get_monthname}}
{{dsc inc | cpp/locale/time_get/dsc get_year}}
{{dsc inc | cpp/locale/time_get/dsc get}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_get/dsc do_date_order}}
{{dsc inc | cpp/locale/time_get/dsc do_get_time}}
{{dsc inc | cpp/locale/time_get/dsc do_get_date}}
{{dsc inc | cpp/locale/time_get/dsc do_get_weekday}}
{{dsc inc | cpp/locale/time_get/dsc do_get_monthname}}
{{dsc inc | cpp/locale/time_get/dsc do_get_year}}
{{dsc inc | cpp/locale/time_get/dsc do_get}}
{{dsc end}}
}}

{{ inherited | {{small|std::}}time_base |
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|dateorder}} | date order enumeration type, defining the values {{tt|no_order}}, {{tt|dmy}}, {{tt|mdy}}, {{tt|ymd}}, and {{tt|ydm}}}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/navbar</title>
    <ns>10</ns>
    <id>4398</id>
    <revision>
      <id>39956</id>
      <parentid>35769</parentid>
      <timestamp>2012-09-28T20:11:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/time_get/navbar heading
|content3 = cpp/locale/time_get/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/navbar content</title>
    <ns>10</ns>
    <id>4400</id>
    <revision>
      <id>53530</id>
      <parentid>41226</parentid>
      <timestamp>2013-06-01T05:03:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="620">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/time_get/time_get}}
{{nv mem ln | cpp/locale/time_get/~time_get}}
{{nv mem ln | cpp/locale/time_get/date_order|date_order|do_date_order}}
{{nv mem ln | cpp/locale/time_get/get_time|get_time|do_get_time}}
{{nv mem ln | cpp/locale/time_get/get_date|get_date|do_get_date}}
{{nv mem ln | cpp/locale/time_get/get_weekday|get_weekday|do_get_weekday}}
{{nv mem ln | cpp/locale/time_get/get_monthname|get_monthname|do_get_monthname}}
{{nv mem ln | cpp/locale/time_get/get_year|get_year|do_get_year}}
{{nv mem ln | cpp/locale/time_get/get|get|do_get}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/navbar heading</title>
    <ns>10</ns>
    <id>4399</id>
    <revision>
      <id>48075</id>
      <parentid>35771</parentid>
      <timestamp>2013-05-18T18:05:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/locale/time_get|std::time_get}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/time get format</title>
    <ns>10</ns>
    <id>4823</id>
    <revision>
      <id>71522</id>
      <parentid>70846</parentid>
      <timestamp>2014-06-12T16:51:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>note on tm_isdst</comment>
      <text xml:space="preserve" bytes="7141">The format string consists of zero or more conversion specifiers, whitespace characters, and ordinary characters (except {{tt|%}}). Each ordinary character is expected to match one character in the input stream in case-insensitive comparison. Each whitespace character matches arbitrary whitespace in the input string. Each conversion specification begins with {{tt|%}} character, optionally followed by {{tt|E}} or {{tt|O}} modifier (ignored if unsupported by the locale), followed by the character that determines the behavior of the specifier. The format specifiers match the POSIX function [http://pubs.opengroup.org/onlinepubs/9699919799/functions/strptime.html strptime()]:

{| class=&quot;wikitable&quot; style=&quot;font-size:85%; max-width:90em;&quot;
|-
! Conversion&lt;br&gt; specifier
! Explanation
! Writes to fields
|-
! {{tt|%}} 
| matches a literal {{tt|%}}. The full conversion specification must be {{tt|%%}}.
| (none)
|-
! {{tt|t}} 
| matches any whitespace.
| (none)
|-
! {{tt|n}} 
| matches any whitespace.
| (none)
|-
! colspan=3 | Year
|-
! {{tt|Y}}
| parses full '''year''' as a 4 digit decimal number, leading zeroes permitted but not required
| {{ttb|tm_year}}
|-
! {{tt|EY}}
| parses '''year''' in the alternative representation, e.g.平成23年 (year Heisei 23) which writes 2011 to tm_year in ja_JP locale
| {{ttb|tm_year}}
|-
! {{tt|y}}
| parses last 2 digits of '''year''' as a decimal number. Range {{tt|[69,99]}} results in values 1969 to 1999, range {{tt|[00,68]}} results in 2000-2068
| {{ttb|tm_year}}
|-
! {{tt|Oy}}
| parses last 2 digits of '''year''' using the alternative numeric system, e.g. 十一 is parsed as 11 in ja_JP locale
| {{ttb|tm_year}}
|-
! {{tt|Ey}}
| parses '''year''' as offset from locale's alternative calendar period {{tt|%EC}}
| {{ttb|tm_year}}
|-
! {{tt|C}}
| parses the first 2 digits of '''year''' as a decimal number (range {{tt|[00,99]}})
| {{ttb|tm_year}}
|-
! {{tt|EC}}
| parses the name of the base year (period) in the locale's alternative representation, e.g. 平成 (Heisei era) in ja_JP
| {{ttb|tm_year}}
|-
! colspan=3 | Month
|-
! {{tt|b}}
| parses the month name, either full or abbreviated, e.g. {{tt|Oct}}
| {{ttb|tm_mon}}
|-
! {{tt|h}}
| synonym of {{tt|b}}
| {{ttb|tm_mon}}
|-
! {{tt|B}}
| synonym of {{tt|b}}
| {{ttb|tm_mon}}
|-
! {{tt|m}}
| parses the '''month''' as a decimal number (range {{tt|[01,12]}}), leading zeroes permitted but not required
| {{ttb|tm_mon}}
|-
! {{tt|Om}}
| parses the '''month''' using the alternative numeric system, e.g. 十二 parses as 12 in ja_JP locale
| {{ttb|tm_mon}}
|-
! colspan=3 | Week
|-
! {{tt|U}}
| parses the '''week of the year''' as a decimal number (Sunday is the first day of the week) (range {{tt|[00,53]}}), leading zeroes permitted but not required
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|OU}}
| parses the '''week of the year''', as by {{tt|%U}}, using the alternative numeric system, e.g. 五十二 parses as 52 in ja_JP locale
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|W}}
| parses the '''week of the year''' as a decimal number (Monday is the first day of the week) (range {{tt|[00,53]}}), leading zeroes permitted but not required
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! {{tt|OW}}
| parses the '''week of the year''', as by {{tt|%W}}, using the alternative numeric system, e.g. 五十二 parses as 52 in ja_JP locale
| {{ttb|tm_year}}, {{ttb|tm_wday}}, {{ttb|tm_yday}}
|-
! colspan=3 | Day of the year/month
|-
! {{tt|j}}
| parses '''day of the year''' as a decimal number (range {{tt|[001,366]}}), leading zeroes permitted but not required
| {{ttb|tm_yday}}
|-
! {{tt|d}}
| parses the '''day of the month''' as a decimal number (range {{tt|[01,31]}}), leading zeroes permitted but not required
| {{ttb|tm_mday}}
|-
! {{tt|Od}}
| parses the '''day of the month''' using the alternative numeric system, e.g 二十七 parses as 27 in ja_JP locale, leading zeroes permitted but not required
| {{ttb|tm_mday}}
|-
! {{tt|e}}
| synonym of {{tt|d}}
| {{ttb|tm_mday}}
|-
! {{tt|Oe}}
| synonym of {{tt|Od}}
| {{ttb|tm_mday}}
|-
! colspan=3 | Day of the week
|-
! {{tt|a}}
| parses the name of the day of the week, either full or abbreviated, e.g. {{tt|Fri}}
| {{ttb|tm_wday}}
|-
! {{tt|A}}
| synonym of {{tt|a}}
| {{ttb|tm_wday}}
|-
! {{tt|w}}
| parses '''weekday''' as a decimal number, where Sunday is {{tt|0}} (range {{tt|[0-6]}})
| {{ttb|tm_wday}}
|-
! {{tt|Ow}}
| parses '''weekday''' as a decimal number, where Sunday is {{tt|0}}, using the alternative numeric system, e.g. 二 parses as 2 in ja_JP locale
| {{ttb|tm_wday}}
|-
! colspan=3 | Hour, minute, second
|-
! {{tt|H}}
| parses the '''hour''' as a decimal number, 24 hour clock (range {{tt|[00-23]}}), leading zeroes permitted but not required
| {{ttb|tm_hour}}
|-
! {{tt|OH}}
| parses '''hour''' from 24-hour clock using the alternative numeric system, e.g. 十八 parses as 18 in ja_JP locale
| {{ttb|tm_hour}}
|-
! {{tt|I}}
| parses '''hour''' as a decimal number, 12 hour clock (range {{tt|[01,12]}}), leading zeroes permitted but not required
| {{ttb|tm_hour}}
|-
! {{tt|OI}}
| parses '''hour''' from 12-hour clock using the alternative numeric system, e.g. 六 reads as 06 in ja_JP locale
| {{ttb|tm_hour}}
|-
! {{tt|M}}
| parses '''minute''' as a decimal number (range {{tt|[00,59]}}), leading zeroes permitted but not required
| {{ttb|tm_min}}
|-
! {{tt|OM}}
| parses '''minute''' using the alternative numeric system, e.g. 二十五 parses as 25 in ja_JP locale
| {{ttb|tm_min}}
|-
! {{tt|S}}
| parses '''second''' as a decimal number (range {{tt|[00,60]}}), leading zeroes permitted but not required
| {{ttb|tm_sec}}
|-
! {{tt|OS}}
| parses '''second''' using the alternative numeric system, e.g. 二十四 parses as 24 in ja_JP locale
| {{ttb|tm_sec}}
|-
! colspan=3 | Other
|-
! {{tt|c}}
| parses the locale's standard date and time string format, e.g. {{tt|Sun Oct 17 04:41:13 2010}} (locale dependent)
| all
|-
! {{tt|Ec}}
| parses the locale's alternative date and time string format, e.g. expecting 平成23年 (year Heisei 23) instead of 2011年 (year 2011) in ja_JP locale
| all
|-
! {{tt|x}}
| parses the locale's standard date representation
| all
|-
! {{tt|Ex}}
| parses the locale's alternative date representation, e.g. expecting 平成23年 (year Heisei 23) instead of 2011年 (year 2011) in ja_JP locale
| all
|-
! {{tt|X}}
| parses the locale's standard time representation
| all
|-
! {{tt|EX}}
| parses the locale's alternative time representation
| all
|-
! {{tt|D}}
| equivalent to '''&quot;%m / %d / %y &quot;'''
| {{ttb|tm_mon}}, {{ttb|tm_mday}}, {{ttb|tm_year}}
|-
! {{tt|r}}
| parses locale's standard 12-hour clock time (in POSIX, '''&quot;%I : %M : %S %p&quot;''')
| {{ttb|tm_hour}}, {{ttb|tm_min}}, {{ttb|tm_sec}}
|-
! {{tt|R}}
| equivalent to '''&quot;%H : %M&quot;'''
| {{ttb|tm_hour}}, {{ttb|tm_min}}
|-
! {{tt|T}}
| equivalent to '''&quot;%H : %M : %S&quot;'''
| {{ttb|tm_hour}}, {{ttb|tm_min}}, {{ttb|tm_sec}}
|-
! {{tt|p}}
| parses the locale's equivalent of '''a.m. or p.m.'''
| {{ttb|tm_hour}}
|}
Note: {{tt|tm_isdst}} is not written to, and needs to be set explicitly for use with functions such as {{tt|mktime}}</text>
      <sha1>d897a7ql5xf7epoobc0erxoq0yjr2bq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time get/title</title>
    <ns>10</ns>
    <id>4402</id>
    <revision>
      <id>15757</id>
      <timestamp>2011-12-15T16:59:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=time_get::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/dsc constructor</title>
    <ns>10</ns>
    <id>9481</id>
    <revision>
      <id>57795</id>
      <parentid>53533</parentid>
      <timestamp>2013-06-01T06:01:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time put/dcl list constructor]] to [[Template:cpp/locale/time put/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem ctor | cpp/locale/time_put/time_put | constructs a new time_put facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/dsc destructor</title>
    <ns>10</ns>
    <id>9482</id>
    <revision>
      <id>57799</id>
      <parentid>53536</parentid>
      <timestamp>2013-06-01T06:01:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time put/dcl list destructor]] to [[Template:cpp/locale/time put/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc prot mem dtor | cpp/locale/time_put/~time_put | destructs a time_put facet }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/dsc do put</title>
    <ns>10</ns>
    <id>9484</id>
    <revision>
      <id>57803</id>
      <parentid>53537</parentid>
      <timestamp>2013-06-01T06:01:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time put/dcl list do put]] to [[Template:cpp/locale/time put/dsc do put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc prot mem vfun | cpp/locale/time_put/put | title=do_put  | formats date/time and writes to output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/dsc put</title>
    <ns>10</ns>
    <id>9483</id>
    <revision>
      <id>57808</id>
      <parentid>53540</parentid>
      <timestamp>2013-06-01T06:01:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/time put/dcl list put]] to [[Template:cpp/locale/time put/dsc put]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/locale/time_put/put | invokes {{tt|do_put}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/inherit</title>
    <ns>10</ns>
    <id>9249</id>
    <revision>
      <id>60900</id>
      <parentid>53543</parentid>
      <timestamp>2013-06-01T12:00:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Update links.</comment>
      <text xml:space="preserve" bytes="410">{{ inherited | [[cpp/locale/time_put | {{small|std::}}time_put]] |
===Member objects===
{{dsc begin}}
{{dsc hitem | Member name | Type}}
{{dsc | {{tt|id}} {{mark|static}} | {{lc|std::locale::id}} }}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_put/dsc put}}
{{dsc end}}

===Protected member functions===
{{dsc begin}}
{{dsc inc | cpp/locale/time_put/dsc do_put}}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/navbar</title>
    <ns>10</ns>
    <id>4403</id>
    <revision>
      <id>39957</id>
      <parentid>35772</parentid>
      <timestamp>2012-09-28T20:11:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="246">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/time_put/navbar heading
|content3 = cpp/locale/time_put/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/navbar content</title>
    <ns>10</ns>
    <id>4412</id>
    <revision>
      <id>53546</id>
      <parentid>41223</parentid>
      <timestamp>2013-06-01T05:03:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="194">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/time_put/time_put}}
{{nv mem ln | cpp/locale/time_put/~time_put}}
{{nv mem ln | cpp/locale/time_put/put|put|do_put}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/navbar heading</title>
    <ns>10</ns>
    <id>4411</id>
    <revision>
      <id>48076</id>
      <parentid>34625</parentid>
      <timestamp>2013-05-18T18:05:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/locale/time_put|std::time_put}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/time put/title</title>
    <ns>10</ns>
    <id>4414</id>
    <revision>
      <id>15774</id>
      <timestamp>2011-12-15T17:05:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=time_put::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/unicode string conversions</title>
    <ns>10</ns>
    <id>2923</id>
    <revision>
      <id>16939</id>
      <parentid>16889</parentid>
      <timestamp>2011-12-27T02:15:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>use the superior r-versions of mbs/wcs functions.</comment>
      <text xml:space="preserve" bytes="1224">{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:center;&quot;
|-
! Character&lt;br&gt;conversions
! narrow multibyte&lt;br&gt;(char)
! UTF-8&lt;br&gt;(char)
! UTF-16&lt;br&gt;(char16_t)
|-
! UTF-16
| {{yes|{{ltt|cpp/string/multibyte/mbrtoc16}} / {{ltt|cpp/string/multibyte/c16rtomb}}}}
| {{yes|{{ltt|cpp/locale/codecvt}}&lt;char16_t, char, mbstate_t&gt;&lt;br&gt;{{ltt|cpp/locale/codecvt_utf8_utf16}}&lt;char16_t&gt;&lt;br&gt;{{ltt|cpp/locale/codecvt_utf8_utf16}}&lt;char32_t&gt;&lt;br&gt;{{ltt|cpp/locale/codecvt_utf8_utf16}}&lt;wchar_t&gt;}}
| {{n/a}}
|-
! UCS2
| {{no}}
| {{yes|{{ltt|cpp/locale/codecvt_utf8}}&lt;char16_t&gt;}}
| {{yes|{{ltt|cpp/locale/codecvt_utf16}}&lt;char16_t&gt;}}
|- 
! UTF-32/UCS4&lt;br&gt;(char32_t)
| {{yes|{{ltt|cpp/string/multibyte/mbrtoc32}} / {{ltt|cpp/string/multibyte/c32rtomb}}}}
| {{yes|{{ltt|cpp/locale/codecvt}}&lt;char32_t, char, mbstate_t&gt;&lt;br&gt;{{ltt|cpp/locale/codecvt_utf8}}&lt;char32_t&gt;}}
| {{yes|{{ltt|cpp/locale/codecvt_utf16}}&lt;char32_t&gt;}}
|-
! UCS2/UCS4&lt;br&gt;(wchar_t)
| {{no}}
| {{yes|{{ltt|cpp/locale/codecvt_utf8}}&lt;wchar_t&gt;}}
| {{yes|{{ltt|cpp/locale/codecvt_utf16}}&lt;wchar_t&gt;}}
|-
! wide&lt;br&gt;(wchar_t)
| {{yes|{{ltt|cpp/locale/codecvt}}&lt;wchar_t, char, mbstate_t&gt;&lt;br&gt;{{ltt|cpp/string/multibyte/mbsrtowcs}} / {{ltt|cpp/string/multibyte/wcsrtombs}}}}
| {{no}}
| {{no}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/dsc rdbuf</title>
    <ns>10</ns>
    <id>5193</id>
    <revision>
      <id>57812</id>
      <parentid>53549</parentid>
      <timestamp>2013-06-01T06:01:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wbuffer convert/dcl list rdbuf]] to [[Template:cpp/locale/wbuffer convert/dsc rdbuf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem fun | cpp/locale/wbuffer_convert/rdbuf | returns or replaces the underlying narrow stream buffer }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/dsc state</title>
    <ns>10</ns>
    <id>5194</id>
    <revision>
      <id>57817</id>
      <parentid>53550</parentid>
      <timestamp>2013-06-01T06:01:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wbuffer convert/dcl list state]] to [[Template:cpp/locale/wbuffer convert/dsc state]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/locale/wbuffer_convert/state | returns the current conversion state }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/dsc wbuffer convert</title>
    <ns>10</ns>
    <id>5191</id>
    <revision>
      <id>57822</id>
      <parentid>53553</parentid>
      <timestamp>2013-06-01T06:01:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wbuffer convert/dcl list wbuffer convert]] to [[Template:cpp/locale/wbuffer convert/dsc wbuffer convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem ctor | cpp/locale/wbuffer_convert/wbuffer_convert | constructs a new wbuffer_convert }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/dsc ~wbuffer convert</title>
    <ns>10</ns>
    <id>5192</id>
    <revision>
      <id>57827</id>
      <parentid>53554</parentid>
      <timestamp>2013-06-01T06:01:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wbuffer convert/dcl list ~wbuffer convert]] to [[Template:cpp/locale/wbuffer convert/dsc ~wbuffer convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc mem dtor | cpp/locale/wbuffer_convert/~wbuffer_convert | destructs the wbuffer_convert and its conversion facet}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/navbar</title>
    <ns>10</ns>
    <id>5195</id>
    <revision>
      <id>39958</id>
      <parentid>35388</parentid>
      <timestamp>2012-09-28T20:11:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="260">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/wbuffer_convert/navbar heading
|content3 = cpp/locale/wbuffer_convert/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/navbar content</title>
    <ns>10</ns>
    <id>5197</id>
    <revision>
      <id>53555</id>
      <parentid>35774</parentid>
      <timestamp>2013-06-01T05:03:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="269">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/wbuffer_convert/wbuffer_convert}}
{{nv mem ln | cpp/locale/wbuffer_convert/~wbuffer_convert}}
{{nv mem ln | cpp/locale/wbuffer_convert/rdbuf}}
{{nv mem ln | cpp/locale/wbuffer_convert/state}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wbuffer convert/navbar heading</title>
    <ns>10</ns>
    <id>5196</id>
    <revision>
      <id>48111</id>
      <parentid>35775</parentid>
      <timestamp>2013-05-18T18:14:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="55">{{ltt|cpp/locale/wbuffer_convert|std::wbuffer_convert}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc converted</title>
    <ns>10</ns>
    <id>5186</id>
    <revision>
      <id>57831</id>
      <parentid>53556</parentid>
      <timestamp>2013-06-01T06:01:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list converted]] to [[Template:cpp/locale/wstring convert/dsc converted]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/locale/wstring_convert/converted | returns the number of characters successfully converted }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc from bytes</title>
    <ns>10</ns>
    <id>5178</id>
    <revision>
      <id>57835</id>
      <parentid>53557</parentid>
      <timestamp>2013-06-01T06:02:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list from bytes]] to [[Template:cpp/locale/wstring convert/dsc from bytes]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/locale/wstring_convert/from_bytes | converts a byte string into a wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc state</title>
    <ns>10</ns>
    <id>5187</id>
    <revision>
      <id>57840</id>
      <parentid>53558</parentid>
      <timestamp>2013-06-01T06:02:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list state]] to [[Template:cpp/locale/wstring convert/dsc state]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/locale/wstring_convert/state | returns the current conversion state }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc to bytes</title>
    <ns>10</ns>
    <id>5177</id>
    <revision>
      <id>57845</id>
      <parentid>53559</parentid>
      <timestamp>2013-06-01T06:02:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list to bytes]] to [[Template:cpp/locale/wstring convert/dsc to bytes]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/locale/wstring_convert/to_bytes | converts a wide string into a byte string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc wstring convert</title>
    <ns>10</ns>
    <id>5184</id>
    <revision>
      <id>57849</id>
      <parentid>53560</parentid>
      <timestamp>2013-06-01T06:02:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list wstring convert]] to [[Template:cpp/locale/wstring convert/dsc wstring convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem ctor | cpp/locale/wstring_convert/wstring_convert | constructs a new wstring_convert }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/dsc ~wstring convert</title>
    <ns>10</ns>
    <id>5185</id>
    <revision>
      <id>57854</id>
      <parentid>53561</parentid>
      <timestamp>2013-06-01T06:02:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/locale/wstring convert/dcl list ~wstring convert]] to [[Template:cpp/locale/wstring convert/dsc ~wstring convert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc mem dtor | cpp/locale/wstring_convert/~wstring_convert | destructs the wstring_convert and its conversion facet}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/navbar</title>
    <ns>10</ns>
    <id>4571</id>
    <revision>
      <id>39959</id>
      <parentid>35776</parentid>
      <timestamp>2012-09-28T20:11:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="260">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/locale/navbar heading
|content2 = cpp/locale/navbar content

|heading3 = cpp/locale/wstring_convert/navbar heading
|content3 = cpp/locale/wstring_convert/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/navbar content</title>
    <ns>10</ns>
    <id>4573</id>
    <revision>
      <id>53562</id>
      <parentid>35777</parentid>
      <timestamp>2013-06-01T05:03:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="379">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/locale/wstring_convert/wstring_convert}}
{{nv mem ln | cpp/locale/wstring_convert/~wstring_convert}}
{{nv mem ln | cpp/locale/wstring_convert/from_bytes}}
{{nv mem ln | cpp/locale/wstring_convert/to_bytes}}
{{nv mem ln | cpp/locale/wstring_convert/converted}}
{{nv mem ln | cpp/locale/wstring_convert/state}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/navbar heading</title>
    <ns>10</ns>
    <id>4572</id>
    <revision>
      <id>48079</id>
      <parentid>35778</parentid>
      <timestamp>2013-05-18T18:06:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="55">{{ltt|cpp/locale/wstring_convert|std::wstring_convert}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/locale/wstring convert/title</title>
    <ns>10</ns>
    <id>5180</id>
    <revision>
      <id>18762</id>
      <timestamp>2012-02-12T18:50:44Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=wstring_convert::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory//navbar</title>
    <ns>10</ns>
    <id>5310</id>
    <revision>
      <id>35779</id>
      <parentid>19339</parentid>
      <timestamp>2012-06-15T22:31:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory//sidebar]] to [[Template:cpp/memory//navbar]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory//title</title>
    <ns>10</ns>
    <id>5311</id>
    <revision>
      <id>19340</id>
      <timestamp>2012-03-09T22:24:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>dummy page</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc address</title>
    <ns>10</ns>
    <id>5682</id>
    <revision>
      <id>57859</id>
      <parentid>53563</parentid>
      <timestamp>2013-06-01T06:02:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list address]] to [[Template:cpp/memory/allocator/dsc address]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/memory/allocator/address | obtains the address of an object, even if {{c|operator&amp;}} is overloaded}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc allocate</title>
    <ns>10</ns>
    <id>5683</id>
    <revision>
      <id>57863</id>
      <parentid>53564</parentid>
      <timestamp>2013-06-01T06:02:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list allocate]] to [[Template:cpp/memory/allocator/dsc allocate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/memory/allocator/allocate | allocates uninitialized storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc allocator</title>
    <ns>10</ns>
    <id>5680</id>
    <revision>
      <id>57867</id>
      <parentid>53565</parentid>
      <timestamp>2013-06-01T06:02:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list allocator]] to [[Template:cpp/memory/allocator/dsc allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem ctor | cpp/memory/allocator/allocator | creates a new allocator instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc construct</title>
    <ns>10</ns>
    <id>5686</id>
    <revision>
      <id>57871</id>
      <parentid>53566</parentid>
      <timestamp>2013-06-01T06:02:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list construct]] to [[Template:cpp/memory/allocator/dsc construct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/memory/allocator/construct | constructs an object in allocated storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc deallocate</title>
    <ns>10</ns>
    <id>5684</id>
    <revision>
      <id>57876</id>
      <parentid>53567</parentid>
      <timestamp>2013-06-01T06:02:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list deallocate]] to [[Template:cpp/memory/allocator/dsc deallocate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/memory/allocator/deallocate | deallocates storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc destroy</title>
    <ns>10</ns>
    <id>5687</id>
    <revision>
      <id>57881</id>
      <parentid>53568</parentid>
      <timestamp>2013-06-01T06:03:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list destroy]] to [[Template:cpp/memory/allocator/dsc destroy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/memory/allocator/destroy | destructs an object in allocated storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc max size</title>
    <ns>10</ns>
    <id>5685</id>
    <revision>
      <id>57885</id>
      <parentid>53569</parentid>
      <timestamp>2013-06-01T06:03:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list max size]] to [[Template:cpp/memory/allocator/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/memory/allocator/max_size | returns the largest supported allocation size}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc operator cmp</title>
    <ns>10</ns>
    <id>5688</id>
    <revision>
      <id>57890</id>
      <parentid>53570</parentid>
      <timestamp>2013-06-01T06:03:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list operator cmp]] to [[Template:cpp/memory/allocator/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem fun | cpp/memory/allocator/operator_cmp |title=operator{{==}}&lt;br&gt;operator!{{=}}|compares two allocator instances}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/dsc ~allocator</title>
    <ns>10</ns>
    <id>5681</id>
    <revision>
      <id>57894</id>
      <parentid>53571</parentid>
      <timestamp>2013-06-01T06:03:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator/dcl list ~allocator]] to [[Template:cpp/memory/allocator/dsc ~allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem dtor | cpp/memory/allocator/~allocator | destructs an allocator instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/navbar</title>
    <ns>10</ns>
    <id>3392</id>
    <revision>
      <id>48445</id>
      <parentid>39960</parentid>
      <timestamp>2013-05-29T15:44:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/memory/navbar heading
|content2 = cpp/memory/navbar content

|heading3 = cpp/memory/allocator/navbar heading
|content3 = cpp/memory/allocator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/navbar content</title>
    <ns>10</ns>
    <id>3394</id>
    <revision>
      <id>53572</id>
      <parentid>35781</parentid>
      <timestamp>2013-06-01T05:03:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="533">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/allocator/allocator}}
{{nv mem ln | cpp/memory/allocator/~allocator}}
{{nv mem ln | cpp/memory/allocator/address}}
{{nv mem ln | cpp/memory/allocator/allocate}}
{{nv mem ln | cpp/memory/allocator/deallocate}}
{{nv mem ln | cpp/memory/allocator/max_size}}
{{nv mem ln | cpp/memory/allocator/construct}}
{{nv mem ln | cpp/memory/allocator/destroy}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/memory/allocator/operator_cmp|operator{{==}}|operator!{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/navbar heading</title>
    <ns>10</ns>
    <id>3393</id>
    <revision>
      <id>48035</id>
      <parentid>35783</parentid>
      <timestamp>2013-05-18T17:59:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="43">{{ltt|cpp/memory/allocator|std::allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator/title</title>
    <ns>10</ns>
    <id>5663</id>
    <revision>
      <id>20853</id>
      <timestamp>2012-04-06T17:11:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=allocator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc allocate</title>
    <ns>10</ns>
    <id>5665</id>
    <revision>
      <id>57898</id>
      <parentid>53573</parentid>
      <timestamp>2013-06-01T06:03:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list allocate]] to [[Template:cpp/memory/allocator traits/dsc allocate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem sfun | cpp/memory/allocator_traits/allocate | allocates uninitialized storage using the allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc construct</title>
    <ns>10</ns>
    <id>5667</id>
    <revision>
      <id>57902</id>
      <parentid>53574</parentid>
      <timestamp>2013-06-01T06:03:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list construct]] to [[Template:cpp/memory/allocator traits/dsc construct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/memory/allocator_traits/construct |notes={{cmark static}} | constructs an object in the allocated storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc deallocate</title>
    <ns>10</ns>
    <id>5666</id>
    <revision>
      <id>57906</id>
      <parentid>53575</parentid>
      <timestamp>2013-06-01T06:03:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list deallocate]] to [[Template:cpp/memory/allocator traits/dsc deallocate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem sfun | cpp/memory/allocator_traits/deallocate | deallocates storage using the allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc destroy</title>
    <ns>10</ns>
    <id>5668</id>
    <revision>
      <id>57910</id>
      <parentid>53576</parentid>
      <timestamp>2013-06-01T06:03:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list destroy]] to [[Template:cpp/memory/allocator traits/dsc destroy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc tfun | cpp/memory/allocator_traits/destroy |notes={{cmark static}}| destructs an object stored in the allocated storage}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc max size</title>
    <ns>10</ns>
    <id>5669</id>
    <revision>
      <id>57914</id>
      <parentid>53577</parentid>
      <timestamp>2013-06-01T06:03:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list max size]] to [[Template:cpp/memory/allocator traits/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc mem sfun | cpp/memory/allocator_traits/max_size | returns the maximum object size supported by the allocator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/dsc select on container copy construction</title>
    <ns>10</ns>
    <id>5670</id>
    <revision>
      <id>57918</id>
      <parentid>53578</parentid>
      <timestamp>2013-06-01T06:03:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/allocator traits/dcl list select on container copy construction]] to [[Template:cpp/memory/allocator traits/dsc select on container copy construction]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc mem sfun | cpp/memory/allocator_traits/select_on_container_copy_construction | obtains the allocator to use after copying a standard container}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/navbar</title>
    <ns>10</ns>
    <id>3398</id>
    <revision>
      <id>39961</id>
      <parentid>35784</parentid>
      <timestamp>2012-09-28T20:12:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="263">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/memory/navbar heading
|content2 = cpp/memory/navbar content

|heading3 = cpp/memory/allocator_traits/navbar heading
|content3 = cpp/memory/allocator_traits/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/navbar content</title>
    <ns>10</ns>
    <id>3400</id>
    <revision>
      <id>53579</id>
      <parentid>35785</parentid>
      <timestamp>2013-06-01T05:03:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="401">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/allocator_traits/allocate}}
{{nv mem ln | cpp/memory/allocator_traits/deallocate}}
{{nv mem ln | cpp/memory/allocator_traits/construct}}
{{nv mem ln | cpp/memory/allocator_traits/destroy}}
{{nv mem ln | cpp/memory/allocator_traits/max_size}}
{{nv mem ln | cpp/memory/allocator_traits/select_on_container_copy_construction}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/navbar heading</title>
    <ns>10</ns>
    <id>3399</id>
    <revision>
      <id>48037</id>
      <parentid>35786</parentid>
      <timestamp>2013-05-18T17:59:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="57">{{ltt|cpp/memory/allocator_traits|std::allocator_traits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/allocator traits/title</title>
    <ns>10</ns>
    <id>5662</id>
    <revision>
      <id>20851</id>
      <timestamp>2012-04-06T17:00:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=allocator_traits::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/auto ptr ref note</title>
    <ns>10</ns>
    <id>13520</id>
    <revision>
      <id>70039</id>
      <parentid>70038</parentid>
      <timestamp>2014-05-07T18:36:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link move</comment>
      <text xml:space="preserve" bytes="627">The constructor and the copy assignment operator from {{tt|auto_ptr_ref}} is provided to allow copy-constructing and assigning {{lc|std::auto_ptr}} from nameless temporaries. Since its copy constructor and copy assignment operator take the argument as non-const reference, they cannot bind rvalue arguments directly. However, a [[cpp/memory/auto_ptr/operator_auto_ptr|user-defined conversion]] can be executed (which releases the original auto_ptr), followed by a call to the constructor or copy-assignment operator that take {{tt|auto_ptr_ref}} by value. This is an early implementation of [[cpp/utility/move|move semantics]].</text>
      <sha1>oyhmtf4j71bfn11qxdlw5rsqi6zr8xz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc auto ptr</title>
    <ns>10</ns>
    <id>9583</id>
    <revision>
      <id>57922</id>
      <parentid>53580</parentid>
      <timestamp>2013-06-01T06:03:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list auto ptr]] to [[Template:cpp/memory/auto ptr/dsc auto ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem ctor | cpp/memory/auto_ptr/auto_ptr  | creates a new {{tt|auto_ptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc get</title>
    <ns>10</ns>
    <id>9587</id>
    <revision>
      <id>57927</id>
      <parentid>53581</parentid>
      <timestamp>2013-06-01T06:04:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list get]] to [[Template:cpp/memory/auto ptr/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem fun | cpp/memory/auto_ptr/get | obtains a pointer to the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc operator*</title>
    <ns>10</ns>
    <id>9588</id>
    <revision>
      <id>57932</id>
      <parentid>53582</parentid>
      <timestamp>2013-06-01T06:04:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list operator*]] to [[Template:cpp/memory/auto ptr/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/memory/auto_ptr/operator* | title=operator*&lt;br&gt;operator-&gt;| accesses the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc operator=</title>
    <ns>10</ns>
    <id>9585</id>
    <revision>
      <id>57936</id>
      <parentid>53583</parentid>
      <timestamp>2013-06-01T06:04:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list operator=]] to [[Template:cpp/memory/auto ptr/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem fun | cpp/memory/auto_ptr/operator{{=}} | transfers ownership from another {{tt|auto_ptr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc operator auto ptr</title>
    <ns>10</ns>
    <id>9586</id>
    <revision>
      <id>70027</id>
      <parentid>57940</parentid>
      <timestamp>2014-05-07T16:17:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>mention both operators in the dsc</comment>
      <text xml:space="preserve" bytes="174">{{dsc mem fun | cpp/memory/auto_ptr/operator_auto_ptr | title=operator auto_ptr&lt;Y&gt;&lt;br&gt;operator auto_ptr_ref&lt;Y&gt; | converts the managed pointer to a pointer to different type}}</text>
      <sha1>h04ky9rj1002nkmt2tehwxe321xp20q</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc release</title>
    <ns>10</ns>
    <id>9590</id>
    <revision>
      <id>57944</id>
      <parentid>53585</parentid>
      <timestamp>2013-06-01T06:04:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list release]] to [[Template:cpp/memory/auto ptr/dsc release]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/memory/auto_ptr/release | releases ownership of the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc reset</title>
    <ns>10</ns>
    <id>9589</id>
    <revision>
      <id>57948</id>
      <parentid>53586</parentid>
      <timestamp>2013-06-01T06:04:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list reset]] to [[Template:cpp/memory/auto ptr/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/memory/auto_ptr/reset | destroys the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/dsc ~auto ptr</title>
    <ns>10</ns>
    <id>9584</id>
    <revision>
      <id>57952</id>
      <parentid>53587</parentid>
      <timestamp>2013-06-01T06:04:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/auto ptr/dcl list ~auto ptr]] to [[Template:cpp/memory/auto ptr/dsc ~auto ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem dtor | cpp/memory/auto_ptr/~auto_ptr   | destroys an {{tt|auto_ptr}} and the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/navbar</title>
    <ns>10</ns>
    <id>3422</id>
    <revision>
      <id>39962</id>
      <parentid>36076</parentid>
      <timestamp>2012-09-28T20:12:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="324">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/auto_ptr/navbar heading
|content4 = cpp/memory/auto_ptr/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/navbar content</title>
    <ns>10</ns>
    <id>3424</id>
    <revision>
      <id>70036</id>
      <parentid>53588</parentid>
      <timestamp>2014-05-07T16:33:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>display operator auto_ptr_ref</comment>
      <text xml:space="preserve" bytes="486">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/auto_ptr/auto_ptr}}
{{nv mem ln | cpp/memory/auto_ptr/~auto_ptr}}
{{nv mem ln | cpp/memory/auto_ptr/operator{{=}}}}
{{nv mem ln | cpp/memory/auto_ptr/operator*|operator*|operator-&gt;}}
{{nv mem ln | cpp/memory/auto_ptr/get}}
{{nv mem ln | cpp/memory/auto_ptr/release}}
{{nv mem ln | cpp/memory/auto_ptr/reset}}
{{nv mem ln | cpp/memory/auto_ptr/operator_auto_ptr|operator auto_ptr&lt;Y&gt;|operator auto_ptr_ref&lt;Y&gt;}}
{{nv end}}</text>
      <sha1>owvcj2tptne8iw11rswgnpqrg4dewq7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/navbar heading</title>
    <ns>10</ns>
    <id>3423</id>
    <revision>
      <id>48039</id>
      <parentid>35789</parentid>
      <timestamp>2013-05-18T17:59:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/memory/auto_ptr|std::auto_ptr}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/auto ptr/title</title>
    <ns>10</ns>
    <id>8559</id>
    <revision>
      <id>31720</id>
      <timestamp>2012-06-06T20:43:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=auto_ptr::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/bad weak ptr/navbar</title>
    <ns>10</ns>
    <id>8984</id>
    <revision>
      <id>39963</id>
      <parentid>37785</parentid>
      <timestamp>2012-09-28T20:12:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="332">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/bad_weak_ptr/navbar heading
|content4 = cpp/memory/bad_weak_ptr/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/bad weak ptr/navbar content</title>
    <ns>10</ns>
    <id>8986</id>
    <revision>
      <id>53589</id>
      <parentid>37788</parentid>
      <timestamp>2013-06-01T05:04:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="105">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/bad_weak_ptr/bad_weak_ptr}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/bad weak ptr/navbar heading</title>
    <ns>10</ns>
    <id>8985</id>
    <revision>
      <id>48089</id>
      <parentid>37786</parentid>
      <timestamp>2013-05-18T18:07:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="49">{{ltt|cpp/memory/bad_weak_ptr|std::bad_weak_ptr}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/bad weak ptr/title</title>
    <ns>10</ns>
    <id>8988</id>
    <revision>
      <id>37793</id>
      <timestamp>2012-07-18T23:44:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=bad_weak_ptr::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/c/navbar</title>
    <ns>10</ns>
    <id>2160</id>
    <revision>
      <id>39964</id>
      <parentid>36075</parentid>
      <timestamp>2012-09-28T20:12:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/default delete/dsc constructor</title>
    <ns>10</ns>
    <id>9964</id>
    <revision>
      <id>66451</id>
      <parentid>58057</parentid>
      <timestamp>2013-11-22T16:24:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem ctor | cpp/memory/default_delete | inlinemem=true | constructs a {{tt|default_delete}} object}}</text>
      <sha1>kx0f3h0n3lm8qvdz7q85i6a00pgnp8o</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/default delete/dsc operator()</title>
    <ns>10</ns>
    <id>9965</id>
    <revision>
      <id>58062</id>
      <parentid>53633</parentid>
      <timestamp>2013-06-01T06:07:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/default delete/dcl list operator()]] to [[Template:cpp/memory/default delete/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem fun | cpp/memory/default_delete | title=operator() | inlinemem=true | deletes the object or array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/default delete/navbar</title>
    <ns>10</ns>
    <id>9605</id>
    <revision>
      <id>47434</id>
      <parentid>44705</parentid>
      <timestamp>2013-05-10T16:02:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>no content</comment>
      <text xml:space="preserve" bytes="283">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/default_delete/navbar heading
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/default delete/navbar heading</title>
    <ns>10</ns>
    <id>9604</id>
    <revision>
      <id>47138</id>
      <parentid>44704</parentid>
      <timestamp>2013-04-25T10:46:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="55">{{ltt|cpp/memory/default_delete | std::default_delete}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/default delete/title</title>
    <ns>10</ns>
    <id>8578</id>
    <revision>
      <id>31739</id>
      <timestamp>2012-06-06T20:46:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=default_delete::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc addressof</title>
    <ns>10</ns>
    <id>3378</id>
    <revision>
      <id>57956</id>
      <parentid>53590</parentid>
      <timestamp>2013-06-01T06:04:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list addressof]] to [[Template:cpp/memory/dsc addressof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/memory/addressof | obtains actual address of an object, even if the ''&amp;'' operator is overloaded |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc align</title>
    <ns>10</ns>
    <id>3379</id>
    <revision>
      <id>57960</id>
      <parentid>53591</parentid>
      <timestamp>2013-06-01T06:04:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list align]] to [[Template:cpp/memory/dsc align]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc fun | cpp/memory/align | aligns a pointer in a buffer |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc allocate ptr</title>
    <ns>10</ns>
    <id>4941</id>
    <revision>
      <id>57965</id>
      <parentid>53592</parentid>
      <timestamp>2013-06-01T06:04:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list allocate ptr]] to [[Template:cpp/memory/dsc allocate ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc tfun | cpp/memory/shared_ptr/allocate_shared | creates a shared pointer that manages a new object allocated using an allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc allocator</title>
    <ns>10</ns>
    <id>3355</id>
    <revision>
      <id>57969</id>
      <parentid>53593</parentid>
      <timestamp>2013-06-01T06:04:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list allocator]] to [[Template:cpp/memory/dsc allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc tclass | cpp/memory/allocator | the default allocator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc allocator arg</title>
    <ns>10</ns>
    <id>3358</id>
    <revision>
      <id>57973</id>
      <parentid>53594</parentid>
      <timestamp>2013-06-01T06:05:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list allocator arg]] to [[Template:cpp/memory/dsc allocator arg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc const  | cpp/memory/allocator_arg | an object of type {{lc|std::allocator_arg_t}} used to select allocator-aware constructors| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc allocator arg t</title>
    <ns>10</ns>
    <id>3357</id>
    <revision>
      <id>57976</id>
      <parentid>53595</parentid>
      <timestamp>2013-06-01T06:05:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list allocator arg t]] to [[Template:cpp/memory/dsc allocator arg t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc class  | cpp/memory/allocator_arg_t | tag type used to select allocator-aware constructor overloads| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc allocator traits</title>
    <ns>10</ns>
    <id>3356</id>
    <revision>
      <id>57981</id>
      <parentid>53596</parentid>
      <timestamp>2013-06-01T06:05:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list allocator traits]] to [[Template:cpp/memory/dsc allocator traits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tclass | cpp/memory/allocator_traits | provides information about allocator types | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc auto ptr</title>
    <ns>10</ns>
    <id>3366</id>
    <revision>
      <id>57985</id>
      <parentid>53597</parentid>
      <timestamp>2013-06-01T06:05:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list auto ptr]] to [[Template:cpp/memory/dsc auto ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tclass | cpp/memory/auto_ptr   | smart pointer with strict object ownership semantics | notes={{mark deprecated}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc bad weak ptr</title>
    <ns>10</ns>
    <id>3369</id>
    <revision>
      <id>57989</id>
      <parentid>53598</parentid>
      <timestamp>2013-06-01T06:05:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list bad weak ptr]] to [[Template:cpp/memory/dsc bad weak ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc class | cpp/memory/bad_weak_ptr | exception thrown when accessing a {{tt|weak_ptr}} which refers to already destroyed object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc default delete</title>
    <ns>10</ns>
    <id>3370</id>
    <revision>
      <id>57993</id>
      <parentid>53599</parentid>
      <timestamp>2013-06-01T06:05:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list default delete]] to [[Template:cpp/memory/dsc default delete]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/memory/default_delete | default deleter for {{tt|unique_ptr}} |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc enable shared from this</title>
    <ns>10</ns>
    <id>3368</id>
    <revision>
      <id>57997</id>
      <parentid>53600</parentid>
      <timestamp>2013-06-01T06:05:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list enable shared from this]] to [[Template:cpp/memory/dsc enable shared from this]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc tclass | cpp/memory/enable_shared_from_this | allows an object to create a {{tt|shared_ptr}} referring to itself | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc get temporary buffer</title>
    <ns>10</ns>
    <id>3361</id>
    <revision>
      <id>58001</id>
      <parentid>53601</parentid>
      <timestamp>2013-06-01T06:05:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list get temporary buffer]] to [[Template:cpp/memory/dsc get temporary buffer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc tfun   | cpp/memory/get_temporary_buffer | obtains uninitialized storage }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc owner less</title>
    <ns>10</ns>
    <id>3367</id>
    <revision>
      <id>58005</id>
      <parentid>53602</parentid>
      <timestamp>2013-06-01T06:05:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list owner less]] to [[Template:cpp/memory/dsc owner less]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tclass | cpp/memory/owner_less | provides mixed-type owner-based ordering of shared and weak pointers | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc pointer traits</title>
    <ns>10</ns>
    <id>3377</id>
    <revision>
      <id>58009</id>
      <parentid>53603</parentid>
      <timestamp>2013-06-01T06:05:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list pointer traits]] to [[Template:cpp/memory/dsc pointer traits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tclass | cpp/memory/pointer_traits | provides information about pointer-like types | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc raw storage iterator</title>
    <ns>10</ns>
    <id>3360</id>
    <revision>
      <id>58014</id>
      <parentid>53604</parentid>
      <timestamp>2013-06-01T06:05:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list raw storage iterator]] to [[Template:cpp/memory/dsc raw storage iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc tclass | cpp/memory/raw_storage_iterator | an iterator that allows standard algorithms to store results in uninitialized memory}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc return temporary buffer</title>
    <ns>10</ns>
    <id>3362</id>
    <revision>
      <id>58018</id>
      <parentid>53605</parentid>
      <timestamp>2013-06-01T06:05:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list return temporary buffer]] to [[Template:cpp/memory/dsc return temporary buffer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc tfun   | cpp/memory/return_temporary_buffer | frees uninitialized storage }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc scoped allocator adaptor</title>
    <ns>10</ns>
    <id>3359</id>
    <revision>
      <id>58022</id>
      <parentid>53606</parentid>
      <timestamp>2013-06-01T06:05:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list scoped allocator adaptor]] to [[Template:cpp/memory/dsc scoped allocator adaptor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tclass | cpp/memory/scoped_allocator_adaptor | implements multi-level allocator for multi-level containers | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc shared ptr</title>
    <ns>10</ns>
    <id>3364</id>
    <revision>
      <id>58026</id>
      <parentid>53609</parentid>
      <timestamp>2013-06-01T06:05:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list shared ptr]] to [[Template:cpp/memory/dsc shared ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tclass | cpp/memory/shared_ptr | smart pointer with shared object ownership semantics | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc swap</title>
    <ns>10</ns>
    <id>5303</id>
    <revision>
      <id>58029</id>
      <parentid>53612</parentid>
      <timestamp>2013-06-01T06:05:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list swap]] to [[Template:cpp/memory/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc mem fun | cpp/memory/{{{1|}}}/swap | swaps the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc uninitialized copy</title>
    <ns>10</ns>
    <id>2438</id>
    <revision>
      <id>58032</id>
      <parentid>53613</parentid>
      <timestamp>2013-06-01T06:06:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list uninitialized copy]] to [[Template:cpp/memory/dsc uninitialized copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tfun | cpp/memory/uninitialized_copy | copies a range of objects to an uninitialized area of memory}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc uninitialized copy n</title>
    <ns>10</ns>
    <id>2439</id>
    <revision>
      <id>58036</id>
      <parentid>53616</parentid>
      <timestamp>2013-06-01T06:06:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list uninitialized copy n]] to [[Template:cpp/memory/dsc uninitialized copy n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tfun | cpp/memory/uninitialized_copy_n | copies a number of objects to an uninitialized area of memory |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc uninitialized fill</title>
    <ns>10</ns>
    <id>2440</id>
    <revision>
      <id>58039</id>
      <parentid>53619</parentid>
      <timestamp>2013-06-01T06:06:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list uninitialized fill]] to [[Template:cpp/memory/dsc uninitialized fill]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc tfun | cpp/memory/uninitialized_fill | copies an object to an uninitialized area of memory}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc uninitialized fill n</title>
    <ns>10</ns>
    <id>2441</id>
    <revision>
      <id>58042</id>
      <parentid>53622</parentid>
      <timestamp>2013-06-01T06:06:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list uninitialized fill n]] to [[Template:cpp/memory/dsc uninitialized fill n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tfun | cpp/memory/uninitialized_fill_n | copies an object to an uninitialized area of memory}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc unique ptr</title>
    <ns>10</ns>
    <id>3363</id>
    <revision>
      <id>58045</id>
      <parentid>53623</parentid>
      <timestamp>2013-06-01T06:06:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list unique ptr]] to [[Template:cpp/memory/dsc unique ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tclass | cpp/memory/unique_ptr | smart pointer with unique object ownership semantics | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc uses allocator</title>
    <ns>10</ns>
    <id>3248</id>
    <revision>
      <id>58049</id>
      <parentid>53626</parentid>
      <timestamp>2013-06-01T06:06:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list uses allocator]] to [[Template:cpp/memory/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc tclass | cpp/memory/uses_allocator | checks if the specified type supports uses-allocator construction | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/dsc weak ptr</title>
    <ns>10</ns>
    <id>3365</id>
    <revision>
      <id>58053</id>
      <parentid>53629</parentid>
      <timestamp>2013-06-01T06:06:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/dcl list weak ptr]] to [[Template:cpp/memory/dsc weak ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc tclass | cpp/memory/weak_ptr   | weak reference to an object managed by {{lc|std::shared_ptr}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/enable shared from this/navbar</title>
    <ns>10</ns>
    <id>3426</id>
    <revision>
      <id>39965</id>
      <parentid>35904</parentid>
      <timestamp>2012-09-28T20:12:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="355">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/enable_shared_from_this/navbar heading
|content4 = cpp/memory/enable_shared_from_this/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/enable shared from this/navbar content</title>
    <ns>10</ns>
    <id>3428</id>
    <revision>
      <id>53636</id>
      <parentid>35792</parentid>
      <timestamp>2013-06-01T05:04:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="382">{{nv begin}}
{{nv h1 | Protected member functions}}
{{nv mem ln | cpp/memory/enable_shared_from_this/enable_shared_from_this}}
{{nv mem ln | cpp/memory/enable_shared_from_this/~enable_shared_from_this}}
{{nv mem ln | cpp/memory/enable_shared_from_this/operator{{=}}}}
{{nv h1 | Public member functions}}
{{nv mem ln | cpp/memory/enable_shared_from_this/shared_from_this}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/enable shared from this/navbar heading</title>
    <ns>10</ns>
    <id>3427</id>
    <revision>
      <id>48040</id>
      <parentid>35793</parentid>
      <timestamp>2013-05-18T17:59:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="71">{{ltt|cpp/memory/enable_shared_from_this|std::enable_shared_from_this}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/enable shared from this/title</title>
    <ns>10</ns>
    <id>8456</id>
    <revision>
      <id>30832</id>
      <timestamp>2012-05-11T22:24:18Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>created</comment>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/title | n=enable_shared_from_this::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/example1</title>
    <ns>10</ns>
    <id>5316</id>
    <revision>
      <id>23456</id>
      <parentid>19370</parentid>
      <timestamp>2012-04-20T02:26:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="543">{{example |
|code=
#include &lt;algorithm&gt;
#include &lt;iostream&gt;
#include &lt;memory&gt;
#include &lt;string&gt;

int main()
{
    const std::string s[] = {&quot;string&quot;, &quot;1&quot;, &quot;test&quot;, &quot;...&quot;};
    std::string* p = std::get_temporary_buffer&lt;std::string&gt;(4).first;

    std::copy(std::begin(s), std::end(s),
              std::raw_storage_iterator&lt;std::string*, std::string&gt;(p));

    for (std::string* i = p; i != p+4; ++i) {
        std::cout &lt;&lt; *i &lt;&lt; '\n';
        i-&gt;~basic_string&lt;char&gt;();
    }
    std::return_temporary_buffer(p);
}
|output=
string
1
test
...
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc declare no pointers</title>
    <ns>10</ns>
    <id>3373</id>
    <revision>
      <id>58066</id>
      <parentid>53639</parentid>
      <timestamp>2013-06-01T06:07:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list declare no pointers]] to [[Template:cpp/memory/gc/dsc declare no pointers]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | cpp/memory/gc/declare_no_pointers | declares that a memory area does not contain traceable pointers |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc declare reachable</title>
    <ns>10</ns>
    <id>3371</id>
    <revision>
      <id>58070</id>
      <parentid>53642</parentid>
      <timestamp>2013-06-01T06:07:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list declare reachable]] to [[Template:cpp/memory/gc/dsc declare reachable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | cpp/memory/gc/declare_reachable | declares that an object can not be recycled  |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc get pointer safety</title>
    <ns>10</ns>
    <id>3376</id>
    <revision>
      <id>58074</id>
      <parentid>53643</parentid>
      <timestamp>2013-06-01T06:07:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list get pointer safety]] to [[Template:cpp/memory/gc/dsc get pointer safety]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | cpp/memory/gc/get_pointer_safety | returns the current pointer safety model |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc pointer safety</title>
    <ns>10</ns>
    <id>3375</id>
    <revision>
      <id>58078</id>
      <parentid>53646</parentid>
      <timestamp>2013-06-01T06:07:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list pointer safety]] to [[Template:cpp/memory/gc/dsc pointer safety]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc class | cpp/memory/gc/pointer_safety | lists pointer safety models |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc undeclare no pointers</title>
    <ns>10</ns>
    <id>3374</id>
    <revision>
      <id>58081</id>
      <parentid>53649</parentid>
      <timestamp>2013-06-01T06:07:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list undeclare no pointers]] to [[Template:cpp/memory/gc/dsc undeclare no pointers]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc fun | cpp/memory/gc/undeclare_no_pointers | cancels the effect of {{lc|std::declare_no_pointers}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/gc/dsc undeclare reachable</title>
    <ns>10</ns>
    <id>3372</id>
    <revision>
      <id>58085</id>
      <parentid>53652</parentid>
      <timestamp>2013-06-01T06:07:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/gc/dcl list undeclare reachable]] to [[Template:cpp/memory/gc/dsc undeclare reachable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc tfun | cpp/memory/gc/undeclare_reachable | declares that an object can be recycled |notes= {{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/navbar</title>
    <ns>10</ns>
    <id>2117</id>
    <revision>
      <id>39966</id>
      <parentid>36074</parentid>
      <timestamp>2012-09-28T20:12:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="229">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/navbar content</title>
    <ns>10</ns>
    <id>2158</id>
    <revision>
      <id>53653</id>
      <parentid>44654</parentid>
      <timestamp>2013-06-01T05:04:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2213">{{nv begin}}
{{nv h1 | Smart pointers}}
{{nv ln | cpp/memory/unique_ptr | notes={{mark c++11}} }}
{{nv ln | cpp/memory/shared_ptr | notes={{mark c++11}} }}
{{nv ln | cpp/memory/weak_ptr | notes={{mark c++11}} }}
{{nv ln | cpp/memory/auto_ptr | notes={{mark deprecated}} }}
{{nv ln | cpp/memory/owner_less | notes={{mark c++11}} }}
{{nv ln | cpp/memory/enable_shared_from_this | notes={{mark c++11}} }}
{{nv ln | cpp/memory/bad_weak_ptr | notes={{mark c++11}} }}
{{nv ln | cpp/memory/default_delete | notes={{mark c++11}} }}

{{nv h1 | Allocators}}
{{nv ln | cpp/memory/allocator}}
{{nv ln | cpp/memory/allocator_traits | notes={{mark c++11}} }}
{{nv ln | cpp/memory/allocator_arg_t | notes={{mark c++11}} }}
{{nv ln | cpp/memory/allocator_arg | notes={{mark c++11}} }}
{{nv ln | cpp/memory/uses_allocator | notes={{mark c++11}} }}
{{nv ln | cpp/memory/scoped_allocator_adaptor | notes={{mark c++11}} }}

{{nv h1 | Uninitialized storage}}
{{nv ln | cpp/memory/uninitialized_copy }}
{{nv ln | cpp/memory/uninitialized_copy_n | notes={{mark c++11}} }}
{{nv ln | cpp/memory/uninitialized_fill }}
{{nv ln | cpp/memory/uninitialized_fill_n }}
{{nv ln | cpp/memory/raw_storage_iterator }}
{{nv ln | cpp/memory/get_temporary_buffer }}
{{nv ln | cpp/memory/return_temporary_buffer }}

{{nv h1 | Garbage collection support}}
{{nv ln | cpp/memory/gc/declare_reachable | notes={{mark c++11}} }}
{{nv ln | cpp/memory/gc/undeclare_reachable | notes={{mark c++11}} }}
{{nv ln | cpp/memory/gc/declare_no_pointers | notes={{mark c++11}} }}
{{nv ln | cpp/memory/gc/undeclare_no_pointers | notes={{mark c++11}} }}
{{nv ln | cpp/memory/gc/pointer_safety | notes={{mark c++11}} }}
{{nv ln | cpp/memory/gc/get_pointer_safety | notes={{mark c++11}} }}

{{nv h1 | Miscellaneous}}
{{nv ln | cpp/memory/pointer_traits | notes={{mark c++11}} }}
{{nv ln | cpp/memory/addressof | notes={{mark c++11}} }}
{{nv ln | cpp/memory/align | notes={{mark c++11}} }}

{{nv h1 | [[cpp/memory/c|C Library]]}}
{{nv col begin}}
{{nv ln | cpp/memory/c/malloc}}
{{nv ln | cpp/memory/c/calloc}}
{{nv col next}}
{{nv ln | cpp/memory/c/realloc}}
{{nv ln | cpp/memory/c/free}}
{{nv col end}}

{{nv h1 | [[cpp/memory/new|Low level memory management]]}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/navbar heading</title>
    <ns>10</ns>
    <id>2118</id>
    <revision>
      <id>35808</id>
      <parentid>4525</parentid>
      <timestamp>2012-06-15T22:32:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/sidebar heading]] to [[Template:cpp/memory/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="42">[[cpp/memory | Dynamic memory management]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad alloc/inherit</title>
    <ns>10</ns>
    <id>5580</id>
    <revision>
      <id>20556</id>
      <parentid>20555</parentid>
      <timestamp>2012-03-28T12:58:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="74">{{inherited | [[cpp/memory/new/bad_alloc | {{small|std::}}bad_alloc]] | }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad alloc/navbar</title>
    <ns>10</ns>
    <id>5581</id>
    <revision>
      <id>39967</id>
      <parentid>36073</parentid>
      <timestamp>2012-09-28T20:12:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="419">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/new/navbar heading
|content4 = cpp/memory/new/navbar content

|heading5 = cpp/memory/new/bad_alloc/navbar heading
|content5 = cpp/memory/new/bad_alloc/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad alloc/navbar content</title>
    <ns>10</ns>
    <id>5584</id>
    <revision>
      <id>53656</id>
      <parentid>35795</parentid>
      <timestamp>2013-06-01T05:04:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="153">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/new/bad_alloc/bad_alloc}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad alloc/navbar heading</title>
    <ns>10</ns>
    <id>5585</id>
    <revision>
      <id>35796</id>
      <parentid>20562</parentid>
      <timestamp>2012-06-15T22:32:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/bad alloc/sidebar heading]] to [[Template:cpp/memory/new/bad alloc/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/memory/new/bad_alloc|std::bad_alloc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad alloc/title</title>
    <ns>10</ns>
    <id>5002</id>
    <revision>
      <id>18073</id>
      <timestamp>2012-01-20T15:02:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=bad_alloc::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad array new length/navbar</title>
    <ns>10</ns>
    <id>5582</id>
    <revision>
      <id>39968</id>
      <parentid>36072</parentid>
      <timestamp>2012-09-28T20:12:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="441">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/new/navbar heading
|content4 = cpp/memory/new/navbar content

|heading5 = cpp/memory/new/bad_array_new_length/navbar heading
|content5 = cpp/memory/new/bad_array_new_length/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad array new length/navbar content</title>
    <ns>10</ns>
    <id>5583</id>
    <revision>
      <id>53659</id>
      <parentid>35496</parentid>
      <timestamp>2013-06-01T05:04:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="175">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/new/bad_array_new_length/bad_array_new_length}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad array new length/navbar heading</title>
    <ns>10</ns>
    <id>5586</id>
    <revision>
      <id>35798</id>
      <parentid>20563</parentid>
      <timestamp>2012-06-15T22:32:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/bad array new length/sidebar heading]] to [[Template:cpp/memory/new/bad array new length/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="69">{{ltt|cpp/memory/new/bad_array_new_length|std::bad_array_new_length}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/bad array new length/title</title>
    <ns>10</ns>
    <id>5579</id>
    <revision>
      <id>20554</id>
      <timestamp>2012-03-28T12:57:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=bad_array_new_length::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc bad alloc</title>
    <ns>10</ns>
    <id>3299</id>
    <revision>
      <id>58089</id>
      <parentid>53662</parentid>
      <timestamp>2013-06-01T06:07:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list bad alloc]] to [[Template:cpp/memory/new/dsc bad alloc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc class | cpp/memory/new/bad_alloc | exception thrown when memory allocation fails }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc bad array new length</title>
    <ns>10</ns>
    <id>3300</id>
    <revision>
      <id>58093</id>
      <parentid>53663</parentid>
      <timestamp>2013-06-01T06:07:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list bad array new length]] to [[Template:cpp/memory/new/dsc bad array new length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc class | cpp/memory/new/bad_array_new_length | exception thrown on allocation of array with invalid length | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc get new handler</title>
    <ns>10</ns>
    <id>3297</id>
    <revision>
      <id>58097</id>
      <parentid>53666</parentid>
      <timestamp>2013-06-01T06:07:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list get new handler]] to [[Template:cpp/memory/new/dsc get new handler]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/memory/new/get_new_handler | obtains the current new handler | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc new handler</title>
    <ns>10</ns>
    <id>3302</id>
    <revision>
      <id>58101</id>
      <parentid>53669</parentid>
      <timestamp>2013-06-01T06:07:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list new handler]] to [[Template:cpp/memory/new/dsc new handler]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc typedef | cpp/memory/new/new_handler | function pointer type of the new handler }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc nothrow</title>
    <ns>10</ns>
    <id>3303</id>
    <revision>
      <id>58105</id>
      <parentid>53672</parentid>
      <timestamp>2013-06-01T06:08:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list nothrow]] to [[Template:cpp/memory/new/dsc nothrow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc const | cpp/memory/new/nothrow | an object of type {{tt|nothrow_t}} used to select an non-throwing ''allocation function'' }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc nothrow t</title>
    <ns>10</ns>
    <id>3301</id>
    <revision>
      <id>58109</id>
      <parentid>53673</parentid>
      <timestamp>2013-06-01T06:08:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list nothrow t]] to [[Template:cpp/memory/new/dsc nothrow t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc class | cpp/memory/new/nothrow_t | tag type used to select an non-throwing ''allocation function'' }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc operator delete</title>
    <ns>10</ns>
    <id>3296</id>
    <revision>
      <id>58113</id>
      <parentid>53676</parentid>
      <timestamp>2013-06-01T06:08:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list operator delete]] to [[Template:cpp/memory/new/dsc operator delete]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc fun | cpp/memory/new/operator_delete | title=operator delete&lt;br&gt;operator delete[] | deallocation functions }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc operator new</title>
    <ns>10</ns>
    <id>3295</id>
    <revision>
      <id>58117</id>
      <parentid>53679</parentid>
      <timestamp>2013-06-01T06:08:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list operator new]] to [[Template:cpp/memory/new/dsc operator new]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/memory/new/operator_new | title=operator new&lt;br&gt;operator new[] | allocation functions }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/dsc set new handler</title>
    <ns>10</ns>
    <id>3298</id>
    <revision>
      <id>58122</id>
      <parentid>53682</parentid>
      <timestamp>2013-06-01T06:08:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/dcl list set new handler]] to [[Template:cpp/memory/new/dsc set new handler]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | cpp/memory/new/set_new_handler | registers a new handler}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/navbar</title>
    <ns>10</ns>
    <id>2161</id>
    <revision>
      <id>39969</id>
      <parentid>35885</parentid>
      <timestamp>2012-09-28T20:12:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="314">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/new/navbar heading
|content4 = cpp/memory/new/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/navbar content</title>
    <ns>10</ns>
    <id>3292</id>
    <revision>
      <id>60997</id>
      <parentid>53683</parentid>
      <timestamp>2013-06-03T17:21:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+bad_array_length</comment>
      <text xml:space="preserve" bytes="637">{{nv begin}}
{{nv h1 | Functions}}
{{nv ln | cpp/memory/new/operator_new|operator new|operator new[]}}
{{nv ln | cpp/memory/new/operator_delete|operator delete|operator delete[]}}
{{nv ln | cpp/memory/new/get_new_handler|notes={{mark c++11}}}}
{{nv ln | cpp/memory/new/set_new_handler}}
{{nv h1 | Classes}}
{{nv ln | cpp/memory/new/bad_alloc}}
{{nv ln | cpp/memory/new/bad_array_length|notes={{mark c++14}}}}
{{nv ln | cpp/memory/new/bad_array_new_length|notes={{mark c++11}}}}
{{nv ln | cpp/memory/new/nothrow_t}}
{{nv h1 | Types}}
{{nv ln | cpp/memory/new/new_handler}}
{{nv h1 | Objects}}
{{nv ln | cpp/memory/new/nothrow}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/new/navbar heading</title>
    <ns>10</ns>
    <id>2162</id>
    <revision>
      <id>35800</id>
      <parentid>4854</parentid>
      <timestamp>2012-06-15T22:32:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/new/sidebar heading]] to [[Template:cpp/memory/new/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="48">[[cpp/memory/new | Low level memory management]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/owner before</title>
    <ns>10</ns>
    <id>5697</id>
    <revision>
      <id>69767</id>
      <parentid>60901</parentid>
      <timestamp>2014-04-23T18:12:47Z</timestamp>
      <contributor>
        <username>Ericwf</username>
        <id>2945</id>
      </contributor>
      <comment>Using T as the template parameter looks like the same T used in the shared_ptr type. but thats not correct.</comment>
      <text xml:space="preserve" bytes="2327">{{cpp/memory/{{{1|}}}/title | owner_before}}
{{cpp/memory/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1= 
template&lt; class Y &gt; 
bool owner_before( const {{{1}}}&lt;Y&gt;&amp; other) const;
}}
{{dcl | 1=
template&lt; class Y &gt;
bool owner_before( const std::{{#switch:{{{1|}}}|weak_ptr=shared_ptr|shared_ptr=weak_ptr|{{{~1}}}}}&lt;Y&gt;&amp; other) const;
}}
{{dcl end}}

Checks whether this {{tt|{{{1}}}}} precedes {{tt|other}} in implementation defined owner-based (as opposed to value-based) order. The order is such that two smart pointers compare equivalent only if they are both empty or if they both own the same object, even if the values of the pointers obtained by get() are different (e.g. because they point at different subobjects within the same object)

This ordering is used to make shared and weak pointers usable as keys in associative containers, typically through {{lc|std::owner_less}}.

===Parameters===
{{par begin}}
{{par | other | the {{lc|std::shared_ptr}} or {{lc|std::weak_ptr}} to be compared}}
{{par end}}

===Return value===
{{c|true}} if {{c|*this}} precedes {{tt|other}}, {{c|false}} otherwise. Common implementations compare the addresses of the control blocks.

===Example===
{{example
 | code=
#include &lt;iostream&gt;
#include &lt;memory&gt;
 
struct Foo {
    int n1;
    int n2; 
    Foo(int a, int b) : n1(a), n2(b) {}
};
int main()
{   
    auto p1 = std::make_shared&lt;Foo&gt;(1, 2);
    std::shared_ptr&lt;int&gt; p2(p1, &amp;p1-&gt;n1);
    std::shared_ptr&lt;int&gt; p3(p1, &amp;p1-&gt;n2);

    std::cout &lt;&lt; std::boolalpha
              &lt;&lt; &quot;p2 &lt; p3 &quot; &lt;&lt; (p2 &lt; p3) &lt;&lt; '\n'
              &lt;&lt; &quot;p3 &lt; p2 &quot; &lt;&lt; (p3 &lt; p2) &lt;&lt; '\n'
              &lt;&lt; &quot;p2.owner_before(p3) &quot; &lt;&lt; p2.owner_before(p3) &lt;&lt; '\n'
              &lt;&lt; &quot;p3.owner_before(p2) &quot; &lt;&lt; p3.owner_before(p2) &lt;&lt; '\n';

    std::weak_ptr&lt;int&gt; w2(p2);
    std::weak_ptr&lt;int&gt; w3(p3);
    std::cout 
//              &lt;&lt; &quot;w2 &lt; w3 &quot; &lt;&lt; (w2 &lt; w3) &lt;&lt; '\n'  // won't compile 
//              &lt;&lt; &quot;w3 &lt; w2 &quot; &lt;&lt; (w3 &lt; w2) &lt;&lt; '\n'  // won't compile
              &lt;&lt; &quot;w2.owner_before(w3) &quot; &lt;&lt; w2.owner_before(w3) &lt;&lt; '\n'
              &lt;&lt; &quot;w3.owner_before(w2) &quot; &lt;&lt; w3.owner_before(w2) &lt;&lt; '\n';

}
 | output=
p2 &lt; p3 true
p3 &lt; p2 false
p2.owner_before(p3) false
p3.owner_before(p2) false
w2.owner_before(w3) false
w3.owner_before(w2) false
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc owner_less}}
{{dsc end}}</text>
      <sha1>t22228pvq9ilb6nl5ify90f556facns</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/pointer traits/navbar</title>
    <ns>10</ns>
    <id>9319</id>
    <revision>
      <id>39970</id>
      <parentid>39419</parentid>
      <timestamp>2012-09-28T20:12:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="259">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/memory/navbar heading
|content2 = cpp/memory/navbar content

|heading3 = cpp/memory/pointer_traits/navbar heading
|content3 = cpp/memory/pointer_traits/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/pointer traits/navbar content</title>
    <ns>10</ns>
    <id>9321</id>
    <revision>
      <id>53689</id>
      <parentid>39421</parentid>
      <timestamp>2013-06-01T05:04:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="105">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/pointer_traits/pointer_to}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/pointer traits/navbar heading</title>
    <ns>10</ns>
    <id>9320</id>
    <revision>
      <id>48087</id>
      <parentid>39420</parentid>
      <timestamp>2013-05-18T18:07:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>v</comment>
      <text xml:space="preserve" bytes="53">{{ltt|cpp/memory/pointer_traits|std::pointer_traits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/pointer traits/title</title>
    <ns>10</ns>
    <id>9318</id>
    <revision>
      <id>39418</id>
      <timestamp>2012-09-06T18:16:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=pointer_traits::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10152</id>
    <revision>
      <id>61396</id>
      <parentid>58127</parentid>
      <timestamp>2013-06-05T22:59:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem ctor | cpp/memory/raw_storage_iterator/raw_storage_iterator | creates a new {{tt|raw_storage_iterator}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10154</id>
    <revision>
      <id>61395</id>
      <parentid>58131</parentid>
      <timestamp>2013-06-05T22:59:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/memory/raw_storage_iterator/operator* | dereferences the iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/dsc operator=</title>
    <ns>10</ns>
    <id>10153</id>
    <revision>
      <id>58135</id>
      <parentid>53696</parentid>
      <timestamp>2013-06-01T06:08:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/raw storage iterator/dcl list operator=]] to [[Template:cpp/memory/raw storage iterator/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem fun | cpp/memory/raw_storage_iterator/operator{{=}} | copy-constructs an object at the pointed-to location in the buffer}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10155</id>
    <revision>
      <id>58139</id>
      <parentid>53699</parentid>
      <timestamp>2013-06-01T06:08:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/raw storage iterator/dcl list operator arith]] to [[Template:cpp/memory/raw storage iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc mem fun | cpp/memory/raw_storage_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | advances the iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/navbar</title>
    <ns>10</ns>
    <id>10156</id>
    <revision>
      <id>48446</id>
      <timestamp>2013-05-29T15:44:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="269">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/memory/navbar heading
|content2 = cpp/memory/navbar content

|heading3 = cpp/memory/raw_storage_iterator/navbar heading
|content3 = cpp/memory/raw_storage_iterator/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/navbar content</title>
    <ns>10</ns>
    <id>12649</id>
    <revision>
      <id>61400</id>
      <timestamp>2013-06-05T23:02:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="335">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/raw_storage_iterator/raw_storage_iterator}}
{{nv mem ln | cpp/memory/raw_storage_iterator/operator{{=}}}}
{{nv mem ln | cpp/memory/raw_storage_iterator/operator*}}
{{nv mem ln | cpp/memory/raw_storage_iterator/operator_arith | operator++ | operator++(int)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/navbar heading</title>
    <ns>10</ns>
    <id>10157</id>
    <revision>
      <id>48447</id>
      <timestamp>2013-05-29T15:45:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="65">{{ltt|cpp/memory/raw_storage_iterator|std::raw_storage_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/raw storage iterator/title</title>
    <ns>10</ns>
    <id>8478</id>
    <revision>
      <id>31261</id>
      <timestamp>2012-05-17T03:02:47Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=raw_storage_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc allocate</title>
    <ns>10</ns>
    <id>5723</id>
    <revision>
      <id>58143</id>
      <parentid>53700</parentid>
      <timestamp>2013-06-01T06:08:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list allocate]] to [[Template:cpp/memory/scoped allocator adaptor/dsc allocate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/allocate | allocates uninitialized storage using the outer allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc construct</title>
    <ns>10</ns>
    <id>5726</id>
    <revision>
      <id>58148</id>
      <parentid>53703</parentid>
      <timestamp>2013-06-01T06:09:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list construct]] to [[Template:cpp/memory/scoped allocator adaptor/dsc construct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/construct | constructs an object in allocated storage, passing the inner allocator to its constructor if appropriate}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc deallocate</title>
    <ns>10</ns>
    <id>5724</id>
    <revision>
      <id>71611</id>
      <parentid>58152</parentid>
      <timestamp>2014-06-16T12:51:29Z</timestamp>
      <contributor>
        <username>Mhcox</username>
        <id>735</id>
      </contributor>
      <minor/>
      <comment>Typo</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/deallocate | deallocates storage using the outer allocator}}</text>
      <sha1>5qdpp8wy6dt9dt4twkd0p6rtmf0ub0p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc destroy</title>
    <ns>10</ns>
    <id>5727</id>
    <revision>
      <id>71610</id>
      <parentid>58157</parentid>
      <timestamp>2014-06-16T12:46:34Z</timestamp>
      <contributor>
        <username>Mhcox</username>
        <id>735</id>
      </contributor>
      <minor/>
      <comment>Typo</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/destroy | destructs an object in allocated storage}}</text>
      <sha1>o4ig6xuuh7vnmq11vismhpq0clq2ppv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc inner allocator</title>
    <ns>10</ns>
    <id>5721</id>
    <revision>
      <id>58161</id>
      <parentid>53710</parentid>
      <timestamp>2013-06-01T06:09:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list inner allocator]] to [[Template:cpp/memory/scoped allocator adaptor/dsc inner allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/inner_allocator | obtains an {{tt|inner_allocator}} reference}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc max size</title>
    <ns>10</ns>
    <id>5725</id>
    <revision>
      <id>58165</id>
      <parentid>53713</parentid>
      <timestamp>2013-06-01T06:09:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list max size]] to [[Template:cpp/memory/scoped allocator adaptor/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/max_size | returns the largest allocation size supported by the outer allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc operator cmp</title>
    <ns>10</ns>
    <id>5729</id>
    <revision>
      <id>58169</id>
      <parentid>53716</parentid>
      <timestamp>2013-06-01T06:09:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list operator cmp]] to [[Template:cpp/memory/scoped allocator adaptor/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/operator_cmp |title=operator{{==}}&lt;br&gt;operator!{{=}}|compares two scoped_allocator_adaptor instances}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc outer allocator</title>
    <ns>10</ns>
    <id>5722</id>
    <revision>
      <id>58173</id>
      <parentid>53717</parentid>
      <timestamp>2013-06-01T06:09:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list outer allocator]] to [[Template:cpp/memory/scoped allocator adaptor/dsc outer allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/outer_allocator | obtains an {{tt|outer_allocator}} reference}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc scoped allocator adaptor</title>
    <ns>10</ns>
    <id>5719</id>
    <revision>
      <id>58176</id>
      <parentid>53720</parentid>
      <timestamp>2013-06-01T06:09:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list scoped allocator adaptor]] to [[Template:cpp/memory/scoped allocator adaptor/dsc scoped allocator adaptor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc mem ctor | cpp/memory/scoped_allocator_adaptor/scoped_allocator_adaptor | creates a new scoped_allocator_adaptor instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc select on container copy construction</title>
    <ns>10</ns>
    <id>5728</id>
    <revision>
      <id>58180</id>
      <parentid>53723</parentid>
      <timestamp>2013-06-01T06:09:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list select on container copy construction]] to [[Template:cpp/memory/scoped allocator adaptor/dsc select on container copy construction]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem fun | cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction | copies the state of scoped_allocator_adaptor and all its allocators}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/dsc ~scoped allocator adaptor</title>
    <ns>10</ns>
    <id>5720</id>
    <revision>
      <id>58184</id>
      <parentid>53726</parentid>
      <timestamp>2013-06-01T06:09:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/scoped allocator adaptor/dcl list ~scoped allocator adaptor]] to [[Template:cpp/memory/scoped allocator adaptor/dsc ~scoped allocator adaptor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem dtor | cpp/memory/scoped_allocator_adaptor/~scoped_allocator_adaptor | destructs a scoped_allocator_adaptor instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/navbar</title>
    <ns>10</ns>
    <id>3395</id>
    <revision>
      <id>39971</id>
      <parentid>35801</parentid>
      <timestamp>2012-09-28T20:12:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="279">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/memory/navbar heading
|content2 = cpp/memory/navbar content

|heading3 = cpp/memory/scoped_allocator_adaptor/navbar heading
|content3 = cpp/memory/scoped_allocator_adaptor/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/navbar content</title>
    <ns>10</ns>
    <id>3397</id>
    <revision>
      <id>53729</id>
      <parentid>35238</parentid>
      <timestamp>2013-06-01T05:05:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="864">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/scoped_allocator_adaptor}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/~scoped_allocator_adaptor}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/inner_allocator}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/outer_allocator}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/allocate}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/deallocate}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/max_size}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/construct}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/destroy}}
{{nv mem ln | cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/memory/scoped_allocator_adaptor/operator_cmp|operator{{==}}|operator!{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/navbar heading</title>
    <ns>10</ns>
    <id>3396</id>
    <revision>
      <id>48036</id>
      <parentid>35802</parentid>
      <timestamp>2013-05-18T17:59:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/memory/scoped_allocator_adaptor|std::scoped_allocator_adaptor}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/scoped allocator adaptor/title</title>
    <ns>10</ns>
    <id>5677</id>
    <revision>
      <id>20879</id>
      <timestamp>2012-04-06T21:51:08Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/title | n=scoped_allocator_adaptor::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc allocate ptr</title>
    <ns>10</ns>
    <id>4942</id>
    <revision>
      <id>58187</id>
      <parentid>53730</parentid>
      <timestamp>2013-06-01T06:09:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list allocate ptr]] to [[Template:cpp/memory/shared ptr/dsc allocate ptr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc tfun | cpp/memory/shared_ptr/allocate_shared | creates a shared pointer that manages a new object allocated using an allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc allocate shared</title>
    <ns>10</ns>
    <id>4943</id>
    <revision>
      <id>58191</id>
      <parentid>53733</parentid>
      <timestamp>2013-06-01T06:10:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list allocate shared]] to [[Template:cpp/memory/shared ptr/dsc allocate shared]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc tfun | cpp/memory/shared_ptr/allocate_shared | creates a shared pointer that manages a new object allocated using an allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc atomic</title>
    <ns>10</ns>
    <id>4948</id>
    <revision>
      <id>58195</id>
      <parentid>53736</parentid>
      <timestamp>2013-06-01T06:10:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list atomic]] to [[Template:cpp/memory/shared ptr/dsc atomic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="778">{{dsc tfun | cpp/memory/shared_ptr/atomic | title=std::atomic_is_lock_free{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_load{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_load_explicit{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_store{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_store_explicit{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_exchange{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_exchange_explicit{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_compare_exchange_weak{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_compare_exchange_strong{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_compare_exchange_weak_explicit{{dsc small|(std::shared_ptr)}}&lt;br&gt;std::atomic_compare_exchange_strong_explicit{{dsc small|(std::shared_ptr)}}  | specializes atomic operations }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc constructor</title>
    <ns>10</ns>
    <id>2180</id>
    <revision>
      <id>58199</id>
      <parentid>53739</parentid>
      <timestamp>2013-06-01T06:10:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list constructor]] to [[Template:cpp/memory/shared ptr/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem ctor | cpp/memory/shared_ptr/shared_ptr | constructs new {{tt|shared_ptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc destructor</title>
    <ns>10</ns>
    <id>2181</id>
    <revision>
      <id>58202</id>
      <parentid>53740</parentid>
      <timestamp>2013-06-01T06:10:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list destructor]] to [[Template:cpp/memory/shared ptr/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem dtor | cpp/memory/shared_ptr/~shared_ptr | destructs the owned object if no more {{tt|shared_ptr}}s link to it }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc get</title>
    <ns>10</ns>
    <id>2185</id>
    <revision>
      <id>58206</id>
      <parentid>53743</parentid>
      <timestamp>2013-06-01T06:10:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list get]] to [[Template:cpp/memory/shared ptr/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/memory/shared_ptr/get | returns a pointer to the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc get deleter</title>
    <ns>10</ns>
    <id>4946</id>
    <revision>
      <id>58209</id>
      <parentid>53746</parentid>
      <timestamp>2013-06-01T06:10:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list get deleter]] to [[Template:cpp/memory/shared ptr/dsc get deleter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tfun | cpp/memory/shared_ptr/get_deleter | returns the deleter of specified type, if owned }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc hash</title>
    <ns>10</ns>
    <id>3004</id>
    <revision>
      <id>58213</id>
      <parentid>53747</parentid>
      <timestamp>2013-06-01T06:10:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list hash]] to [[Template:cpp/memory/shared ptr/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc ptclass | cpp/memory/shared_ptr/hash | title=std::hash{{dsc small|&lt;std::shared_ptr&gt;}} | hash support for {{lc|std::shared_ptr}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc make shared</title>
    <ns>10</ns>
    <id>4944</id>
    <revision>
      <id>58216</id>
      <parentid>53748</parentid>
      <timestamp>2013-06-01T06:10:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list make shared]] to [[Template:cpp/memory/shared ptr/dsc make shared]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc tfun | cpp/memory/shared_ptr/make_shared | creates a shared pointer that manages a new object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc operator*</title>
    <ns>10</ns>
    <id>2186</id>
    <revision>
      <id>58220</id>
      <parentid>53749</parentid>
      <timestamp>2013-06-01T06:10:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list operator*]] to [[Template:cpp/memory/shared ptr/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/memory/shared_ptr/operator* | title=operator*&lt;br&gt;operator-&gt; | dereferences pointer to the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc operator=</title>
    <ns>10</ns>
    <id>2182</id>
    <revision>
      <id>58224</id>
      <parentid>53752</parentid>
      <timestamp>2013-06-01T06:10:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list operator=]] to [[Template:cpp/memory/shared ptr/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/memory/shared_ptr/operator{{=}} | assigns the {{tt|shared_ptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc operator bool</title>
    <ns>10</ns>
    <id>2189</id>
    <revision>
      <id>58228</id>
      <parentid>53755</parentid>
      <timestamp>2013-06-01T06:10:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list operator bool]] to [[Template:cpp/memory/shared ptr/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/memory/shared_ptr/operator bool | checks if there is associated managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc operator cmp</title>
    <ns>10</ns>
    <id>3306</id>
    <revision>
      <id>58232</id>
      <parentid>53756</parentid>
      <timestamp>2013-06-01T06:11:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list operator cmp]] to [[Template:cpp/memory/shared ptr/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="201">{{dsc tfun | cpp/memory/shared_ptr/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares with another {{tt|shared_ptr}} or with {{c|nullptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc operator ltlt</title>
    <ns>10</ns>
    <id>4947</id>
    <revision>
      <id>58237</id>
      <parentid>53757</parentid>
      <timestamp>2013-06-01T06:11:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list operator ltlt]] to [[Template:cpp/memory/shared ptr/dsc operator ltlt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tfun | cpp/memory/shared_ptr/operator_ltlt | title=operator&lt;&lt;| outputs the value of the managed pointer to an output stream}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc owner before</title>
    <ns>10</ns>
    <id>2190</id>
    <revision>
      <id>58241</id>
      <parentid>53758</parentid>
      <timestamp>2013-06-01T06:11:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list owner before]] to [[Template:cpp/memory/shared ptr/dsc owner before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/memory/shared_ptr/owner_before | provides owner-based ordering of shared pointers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc pointer cast</title>
    <ns>10</ns>
    <id>4945</id>
    <revision>
      <id>58245</id>
      <parentid>53765</parentid>
      <timestamp>2013-06-01T06:11:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list pointer cast]] to [[Template:cpp/memory/shared ptr/dsc pointer cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="270">{{dsc tfun | cpp/memory/shared_ptr/pointer_cast | title=static_pointer_cast&lt;br&gt;dynamic_pointer_cast&lt;br&gt;const_pointer_cast | applies {{ltt|cpp/language/static_cast}}, {{ltt|cpp/language/dynamic_cast}} or {{ltt|cpp/language/const_cast}} to the type of the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc reset</title>
    <ns>10</ns>
    <id>2183</id>
    <revision>
      <id>58249</id>
      <parentid>53770</parentid>
      <timestamp>2013-06-01T06:11:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list reset]] to [[Template:cpp/memory/shared ptr/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/memory/shared_ptr/reset | replaces the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc swap</title>
    <ns>10</ns>
    <id>2184</id>
    <revision>
      <id>58253</id>
      <parentid>53771</parentid>
      <timestamp>2013-06-01T06:11:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list swap]] to [[Template:cpp/memory/shared ptr/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/memory/shared_ptr/swap | swaps the managed objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc swap2</title>
    <ns>10</ns>
    <id>2770</id>
    <revision>
      <id>58257</id>
      <parentid>53774</parentid>
      <timestamp>2013-06-01T06:11:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list swap2]] to [[Template:cpp/memory/shared ptr/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/memory/shared_ptr/swap2 | title=std::swap{{dsc small|(std::shared_ptr)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc unique</title>
    <ns>10</ns>
    <id>2188</id>
    <revision>
      <id>58261</id>
      <parentid>53775</parentid>
      <timestamp>2013-06-01T06:11:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list unique]] to [[Template:cpp/memory/shared ptr/dsc unique]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc mem fun | cpp/memory/shared_ptr/unique | checks whether the managed object is managed only by the current {{tt|shared_ptr}} instance }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/dsc use count</title>
    <ns>10</ns>
    <id>2187</id>
    <revision>
      <id>58266</id>
      <parentid>53776</parentid>
      <timestamp>2013-06-01T06:11:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/shared ptr/dcl list use count]] to [[Template:cpp/memory/shared ptr/dsc use count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc mem fun | cpp/memory/shared_ptr/use_count | returns the number of {{tt|shared_ptr}} objects referring to the same managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/navbar</title>
    <ns>10</ns>
    <id>2178</id>
    <revision>
      <id>39972</id>
      <parentid>36070</parentid>
      <timestamp>2012-09-28T20:12:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/shared_ptr/navbar heading
|content4 = cpp/memory/shared_ptr/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/navbar content</title>
    <ns>10</ns>
    <id>2922</id>
    <revision>
      <id>53777</id>
      <parentid>47062</parentid>
      <timestamp>2013-06-01T05:05:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1550">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/shared_ptr/shared_ptr}}
{{nv mem ln | cpp/memory/shared_ptr/~shared_ptr}}
{{nv mem ln | cpp/memory/shared_ptr/operator{{=}}}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/memory/shared_ptr/reset}}
{{nv mem ln | cpp/memory/shared_ptr/swap}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/memory/shared_ptr/get}}
{{nv mem ln | cpp/memory/shared_ptr/operator*|operator*|operator-&gt;}}
{{nv mem ln | cpp/memory/shared_ptr/use_count}}
{{nv mem ln | cpp/memory/shared_ptr/unique}}
{{nv mem ln | cpp/memory/shared_ptr/operator bool}}
{{nv mem ln | cpp/memory/shared_ptr/owner_before}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/memory/shared_ptr/swap2 | std::swap}}
{{nv ln | cpp/memory/shared_ptr/make_shared}}
{{nv ln | cpp/memory/shared_ptr/allocate_shared}}
{{nv ln | cpp/memory/shared_ptr/pointer_cast | static_pointer_cast | dynamic_pointer_cast | const_pointer_cast}}
{{nv ln | cpp/memory/shared_ptr/get_deleter}}
{{nv ln | cpp/memory/shared_ptr/operator_cmp|operator{{==}}|operator{{!=}}|operator&lt;|operator&lt;{{=}}|operator&gt;|operator&gt;{{=}}}}
{{nv ln | cpp/memory/shared_ptr/operator_ltlt|operator&lt;&lt;}}
{{nv ln | cpp/memory/shared_ptr/atomic| atomic_is_lock_free | atomic_load | atomic_load_explicit | atomic_store | atomic_store_explicit | atomic_exchange | atomic_exchange_explicit | atomic_compare_exchange_weak| atomic_compare_exchange_strong | atomic_compare_exchange_weak_explicit | atomic_compare_exchange_strong_explicit }}
{{nv ln | cpp/memory/shared_ptr/hash | std::hash}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/navbar heading</title>
    <ns>10</ns>
    <id>2179</id>
    <revision>
      <id>47759</id>
      <parentid>35805</parentid>
      <timestamp>2013-05-16T20:23:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="45">{{ltt|cpp/memory/shared_ptr|std::shared_ptr}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/shared ptr/title</title>
    <ns>10</ns>
    <id>2423</id>
    <revision>
      <id>8446</id>
      <timestamp>2011-08-11T18:11:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=shared_ptr::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/swap2</title>
    <ns>10</ns>
    <id>5302</id>
    <revision>
      <id>63593</id>
      <parentid>60902</parentid>
      <timestamp>2013-07-10T01:45:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="741">{{cpp/title | swap&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/memory/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
{{#switch: {{{1}}}
|shared_ptr|weak_ptr=
template&lt; class T &gt;
void swap( {{{1}}}&lt;T&gt; &amp;lhs, {{{1}}}&lt;T&gt; &amp;rhs );
|unique_ptr=
template&lt; class T, class Deleter &gt;
void swap( {{{1}}}&lt;T,Deleter&gt; &amp;lhs, {{{1}}}&lt;T,Deleter&gt; &amp;rhs );
}}
}}
{{dcl end}}

Specializes the {{lc|std::swap}} algorithm for {{c|std::{{{1}}}}}. Swaps the pointers of {{tt|lhs}} and {{tt|rhs}}. Calls {{c|lhs.swap(rhs)}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | smart pointers whose contents to swap}}
{{par end}} 

===Return value===
(none)

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/memory/dsc swap |{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc constructor</title>
    <ns>10</ns>
    <id>2402</id>
    <revision>
      <id>58270</id>
      <parentid>53785</parentid>
      <timestamp>2013-06-01T06:11:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list constructor]] to [[Template:cpp/memory/unique ptr/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem ctor | cpp/memory/unique_ptr/unique_ptr | constructs a new {{tt|unique_ptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc destructor</title>
    <ns>10</ns>
    <id>2403</id>
    <revision>
      <id>58272</id>
      <parentid>53788</parentid>
      <timestamp>2013-06-01T06:11:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list destructor]] to [[Template:cpp/memory/unique ptr/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem dtor | cpp/memory/unique_ptr/~unique_ptr | destructs the managed object if such is present }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc get</title>
    <ns>10</ns>
    <id>2228</id>
    <revision>
      <id>58274</id>
      <parentid>53789</parentid>
      <timestamp>2013-06-01T06:11:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list get]] to [[Template:cpp/memory/unique ptr/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/memory/unique_ptr/get | returns a pointer to the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc get deleter</title>
    <ns>10</ns>
    <id>2237</id>
    <revision>
      <id>58276</id>
      <parentid>53790</parentid>
      <timestamp>2013-06-01T06:11:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list get deleter]] to [[Template:cpp/memory/unique ptr/dsc get deleter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/memory/unique_ptr/get_deleter | returns the deleter that is used for destruction of the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc hash</title>
    <ns>10</ns>
    <id>2988</id>
    <revision>
      <id>58278</id>
      <parentid>53791</parentid>
      <timestamp>2013-06-01T06:11:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list hash]] to [[Template:cpp/memory/unique ptr/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc ptclass | cpp/memory/unique_ptr/hash | title=std::hash{{dsc small|&lt;std::unique_ptr&gt;}} | hash support for {{lc|std::unique_ptr}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc make unique</title>
    <ns>10</ns>
    <id>9977</id>
    <revision>
      <id>58280</id>
      <parentid>53794</parentid>
      <timestamp>2013-06-01T06:11:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list make unique]] to [[Template:cpp/memory/unique ptr/dsc make unique]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/memory/unique_ptr/make_unique | creates a unique pointer that manages a new object | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc operator*</title>
    <ns>10</ns>
    <id>2235</id>
    <revision>
      <id>58282</id>
      <parentid>53795</parentid>
      <timestamp>2013-06-01T06:11:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list operator*]] to [[Template:cpp/memory/unique ptr/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/memory/unique_ptr/operator* | title=operator*&lt;br&gt;operator-&gt; | dereferences pointer to the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc operator=</title>
    <ns>10</ns>
    <id>2234</id>
    <revision>
      <id>58286</id>
      <parentid>53798</parentid>
      <timestamp>2013-06-01T06:11:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list operator=]] to [[Template:cpp/memory/unique ptr/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/memory/unique_ptr/operator{{=}} | assigns the {{tt|unique_ptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc operator at</title>
    <ns>10</ns>
    <id>3304</id>
    <revision>
      <id>58291</id>
      <parentid>53799</parentid>
      <timestamp>2013-06-01T06:12:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list operator at]] to [[Template:cpp/memory/unique ptr/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem fun | cpp/memory/unique_ptr/operator_at | title=operator[] | provides indexed access to the managed array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc operator bool</title>
    <ns>10</ns>
    <id>2236</id>
    <revision>
      <id>58295</id>
      <parentid>53800</parentid>
      <timestamp>2013-06-01T06:12:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list operator bool]] to [[Template:cpp/memory/unique ptr/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/memory/unique_ptr/operator bool | checks if there is associated managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc operator cmp</title>
    <ns>10</ns>
    <id>3305</id>
    <revision>
      <id>58300</id>
      <parentid>53803</parentid>
      <timestamp>2013-06-01T06:12:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list operator cmp]] to [[Template:cpp/memory/unique ptr/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="199">{{dsc tfun | cpp/memory/unique_ptr/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares to another {{tt|unique_ptr}} or with {{c|nullptr}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc release</title>
    <ns>10</ns>
    <id>2230</id>
    <revision>
      <id>58305</id>
      <parentid>53804</parentid>
      <timestamp>2013-06-01T06:12:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list release]] to [[Template:cpp/memory/unique ptr/dsc release]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc mem fun | cpp/memory/unique_ptr/release | returns a pointer to the managed object and releases the ownership }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc reset</title>
    <ns>10</ns>
    <id>2229</id>
    <revision>
      <id>58309</id>
      <parentid>53807</parentid>
      <timestamp>2013-06-01T06:12:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list reset]] to [[Template:cpp/memory/unique ptr/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/memory/unique_ptr/reset | replaces the managed object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc swap</title>
    <ns>10</ns>
    <id>2233</id>
    <revision>
      <id>58313</id>
      <parentid>53808</parentid>
      <timestamp>2013-06-01T06:12:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list swap]] to [[Template:cpp/memory/unique ptr/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/memory/unique_ptr/swap | swaps the managed objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/dsc swap2</title>
    <ns>10</ns>
    <id>2771</id>
    <revision>
      <id>58318</id>
      <parentid>53809</parentid>
      <timestamp>2013-06-01T06:12:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/unique ptr/dcl list swap2]] to [[Template:cpp/memory/unique ptr/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/memory/unique_ptr/swap2 | title=std::swap{{dsc small|(std::unique_ptr)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/navbar</title>
    <ns>10</ns>
    <id>2157</id>
    <revision>
      <id>39973</id>
      <parentid>36071</parentid>
      <timestamp>2012-09-28T20:14:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="328">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/unique_ptr/navbar heading
|content4 = cpp/memory/unique_ptr/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/navbar content</title>
    <ns>10</ns>
    <id>3111</id>
    <revision>
      <id>53810</id>
      <parentid>35811</parentid>
      <timestamp>2013-06-01T05:06:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="934">{{nv begin}}

{{nv h1 | Member functions}}
{{nv mem ln |  cpp/memory/unique_ptr/unique_ptr }}
{{nv mem ln |  cpp/memory/unique_ptr/~unique_ptr }}
{{nv mem ln | cpp/memory/unique_ptr/operator{{=}}}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/memory/unique_ptr/release}}
{{nv mem ln | cpp/memory/unique_ptr/reset}}
{{nv mem ln | cpp/memory/unique_ptr/swap}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/memory/unique_ptr/get}}
{{nv mem ln | cpp/memory/unique_ptr/get_deleter}}
{{nv mem ln | cpp/memory/unique_ptr/operator bool}}
{{nv mem ln | cpp/memory/unique_ptr/operator*|operator*|operator-&gt;}}
{{nv mem ln | cpp/memory/unique_ptr/operator_at|operator[]}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/memory/unique_ptr/operator_cmp |operator{{==}}|operator!{{=}}|operator&lt;|operator&gt;|operator&lt;{{=}}|operator&gt;|operator&gt;{{=}}}}
{{nv ln | cpp/memory/unique_ptr/swap2 |std::swap}}
{{nv ln | cpp/memory/unique_ptr/hash |std::hash}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/navbar heading</title>
    <ns>10</ns>
    <id>2159</id>
    <revision>
      <id>47137</id>
      <parentid>35183</parentid>
      <timestamp>2013-04-25T10:42:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/memory/unique_ptr | std::unique_ptr}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/unique ptr/title</title>
    <ns>10</ns>
    <id>2424</id>
    <revision>
      <id>8457</id>
      <timestamp>2011-08-11T18:14:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=unique_ptr::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc constructor</title>
    <ns>10</ns>
    <id>5704</id>
    <revision>
      <id>58323</id>
      <parentid>53813</parentid>
      <timestamp>2013-06-01T06:12:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list constructor]] to [[Template:cpp/memory/weak ptr/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem ctor | cpp/memory/weak_ptr/weak_ptr | creates a new {{tt|weak_ptr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc destructor</title>
    <ns>10</ns>
    <id>5705</id>
    <revision>
      <id>58328</id>
      <parentid>53818</parentid>
      <timestamp>2013-06-01T06:12:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list destructor]] to [[Template:cpp/memory/weak ptr/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem dtor | cpp/memory/weak_ptr/~weak_ptr | destroys a {{tt|weak_ptr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc expired</title>
    <ns>10</ns>
    <id>5710</id>
    <revision>
      <id>58333</id>
      <parentid>53823</parentid>
      <timestamp>2013-06-01T06:12:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list expired]] to [[Template:cpp/memory/weak ptr/dsc expired]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem fun | cpp/memory/weak_ptr/expired | checks whether the referenced object was already deleted}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc lock</title>
    <ns>10</ns>
    <id>5711</id>
    <revision>
      <id>58338</id>
      <parentid>53826</parentid>
      <timestamp>2013-06-01T06:12:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list lock]] to [[Template:cpp/memory/weak ptr/dsc lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem fun | cpp/memory/weak_ptr/lock | creates a {{tt|shared_ptr}} that manages the referenced object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc operator=</title>
    <ns>10</ns>
    <id>5706</id>
    <revision>
      <id>58342</id>
      <parentid>53827</parentid>
      <timestamp>2013-06-01T06:12:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list operator=]] to [[Template:cpp/memory/weak ptr/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/memory/weak_ptr/operator{{=}} | assigns the {{tt|weak_ptr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc owner before</title>
    <ns>10</ns>
    <id>5712</id>
    <revision>
      <id>58346</id>
      <parentid>53872</parentid>
      <timestamp>2013-06-01T06:12:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list owner before]] to [[Template:cpp/memory/weak ptr/dsc owner before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/memory/weak_ptr/owner_before | provides owner-based ordering of weak pointers }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc reset</title>
    <ns>10</ns>
    <id>5707</id>
    <revision>
      <id>58350</id>
      <parentid>53875</parentid>
      <timestamp>2013-06-01T06:13:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list reset]] to [[Template:cpp/memory/weak ptr/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/memory/weak_ptr/reset | releases the ownership of the managed object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc swap</title>
    <ns>10</ns>
    <id>5708</id>
    <revision>
      <id>58353</id>
      <parentid>53876</parentid>
      <timestamp>2013-06-01T06:13:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list swap]] to [[Template:cpp/memory/weak ptr/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/memory/weak_ptr/swap | swaps the managed objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc swap2</title>
    <ns>10</ns>
    <id>3416</id>
    <revision>
      <id>58357</id>
      <parentid>53879</parentid>
      <timestamp>2013-06-01T06:13:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list swap2]] to [[Template:cpp/memory/weak ptr/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/memory/weak_ptr/swap2 | title=std::swap{{dsc small|(std::weak_ptr)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/dsc use count</title>
    <ns>10</ns>
    <id>5709</id>
    <revision>
      <id>58361</id>
      <parentid>53880</parentid>
      <timestamp>2013-06-01T06:13:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/memory/weak ptr/dcl list use count]] to [[Template:cpp/memory/weak ptr/dsc use count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/memory/weak_ptr/use_count | returns the number of {{tt|shared_ptr}} objects that manage the object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/navbar</title>
    <ns>10</ns>
    <id>3418</id>
    <revision>
      <id>39974</id>
      <parentid>36069</parentid>
      <timestamp>2012-09-28T20:14:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="324">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/memory/navbar heading
|content3 = cpp/memory/navbar content

|heading4 = cpp/memory/weak_ptr/navbar heading
|content4 = cpp/memory/weak_ptr/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/navbar content</title>
    <ns>10</ns>
    <id>3420</id>
    <revision>
      <id>53885</id>
      <parentid>35812</parentid>
      <timestamp>2013-06-01T05:06:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="586">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/memory/weak_ptr/weak_ptr}}
{{nv mem ln | cpp/memory/weak_ptr/~weak_ptr}}
{{nv mem ln | cpp/memory/weak_ptr/operator{{=}}}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/memory/weak_ptr/reset}}
{{nv mem ln | cpp/memory/weak_ptr/swap}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/memory/weak_ptr/use_count}}
{{nv mem ln | cpp/memory/weak_ptr/expired}}
{{nv mem ln | cpp/memory/weak_ptr/lock}}
{{nv mem ln | cpp/memory/weak_ptr/owner_before}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/memory/weak_ptr/swap2 | std::swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/navbar heading</title>
    <ns>10</ns>
    <id>3419</id>
    <revision>
      <id>48038</id>
      <parentid>35813</parentid>
      <timestamp>2013-05-18T17:59:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="41">{{ltt|cpp/memory/weak_ptr|std::weak_ptr}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/memory/weak ptr/title</title>
    <ns>10</ns>
    <id>5660</id>
    <revision>
      <id>20846</id>
      <timestamp>2012-04-06T15:46:20Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=weak_ptr::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/navbar</title>
    <ns>10</ns>
    <id>1669</id>
    <revision>
      <id>39975</id>
      <parentid>36083</parentid>
      <timestamp>2012-09-28T20:14:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="73">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/navbar content</title>
    <ns>10</ns>
    <id>1670</id>
    <revision>
      <id>53892</id>
      <parentid>45171</parentid>
      <timestamp>2013-06-01T05:06:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="750">{{nv begin| style=line-height:1.1em;}}
{{nv | [[cpp/language | Language]] }}
{{nv | [[cpp/header | Standard library headers]] }}
{{nv | [[cpp/concept | Concepts]] }}
{{nv | [[cpp/utility | Utilities library]] }}
{{nv | [[cpp/string | Strings library]] }}
{{nv | [[cpp/container | Containers library]] }}
{{nv | [[cpp/algorithm | Algorithms library]] }}
{{nv | [[cpp/iterator | Iterators library]] }}
{{nv | [[cpp/numeric | Numerics library]] }}
{{nv | [[cpp/io | Input/output library]] }}
{{nv | [[cpp/locale | Localizations library]] }}
{{nv | [[cpp/regex | Regular expressions library]] {{mark c++11}} }}
{{nv | [[cpp/atomic | Atomic operations library]] {{mark c++11}} }}
{{nv | [[cpp/thread | Thread support library]] {{mark c++11}} }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/navbar heading</title>
    <ns>10</ns>
    <id>2141</id>
    <revision>
      <id>35906</id>
      <parentid>32823</parentid>
      <timestamp>2012-06-15T22:34:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/sidebar heading]] to [[Template:cpp/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="13">[[cpp | C++]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/num get/title</title>
    <ns>10</ns>
    <id>4044</id>
    <revision>
      <id>14900</id>
      <timestamp>2011-12-01T14:44:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=num_get::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc abs</title>
    <ns>10</ns>
    <id>2950</id>
    <revision>
      <id>58365</id>
      <parentid>53897</parentid>
      <timestamp>2013-06-01T06:13:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list abs]] to [[Template:cpp/numeric/complex/dsc abs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tfun | cpp/numeric/complex/abs | title=abs{{dsc small|(std::complex)}} | returns the magnitude of a complex number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc acos</title>
    <ns>10</ns>
    <id>3557</id>
    <revision>
      <id>58369</id>
      <parentid>53902</parentid>
      <timestamp>2013-06-01T06:13:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list acos]] to [[Template:cpp/numeric/complex/dsc acos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="168">{{dsc tfun | cpp/numeric/complex/acos | title=acos{{dsc small|(std::complex)}}   | computes arc cosine of a complex number ({{math|arccos(z)}}) | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc acosh</title>
    <ns>10</ns>
    <id>3563</id>
    <revision>
      <id>66439</id>
      <parentid>58373</parentid>
      <timestamp>2013-11-22T06:04:22Z</timestamp>
      <contributor>
        <username>Addaleax</username>
        <id>1023</id>
      </contributor>
      <minor/>
      <comment>Corrected inverse hyperbolic function name</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/numeric/complex/acosh | title=acosh{{dsc small|(std::complex)}} | computes area hyperbolic cosine of a complex number | notes={{mark c++11}}}}</text>
      <sha1>io3zps5ju3izpcnwb0lqdz6swpmbpkk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc arg</title>
    <ns>10</ns>
    <id>4268</id>
    <revision>
      <id>58377</id>
      <parentid>53904</parentid>
      <timestamp>2013-06-01T06:13:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list arg]] to [[Template:cpp/numeric/complex/dsc arg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc tfun | cpp/numeric/complex/arg | returns the phase angle }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc asin</title>
    <ns>10</ns>
    <id>3556</id>
    <revision>
      <id>58381</id>
      <parentid>53907</parentid>
      <timestamp>2013-06-01T06:13:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list asin]] to [[Template:cpp/numeric/complex/dsc asin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc tfun | cpp/numeric/complex/asin | title=asin{{dsc small|(std::complex)}}   | computes arc sine of a complex number ({{math|arcsin(z)}})| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc asinh</title>
    <ns>10</ns>
    <id>3562</id>
    <revision>
      <id>66438</id>
      <parentid>58385</parentid>
      <timestamp>2013-11-22T06:04:12Z</timestamp>
      <contributor>
        <username>Addaleax</username>
        <id>1023</id>
      </contributor>
      <minor/>
      <comment>Corrected inverse hyperbolic function name</comment>
      <text xml:space="preserve" bytes="157">{{dsc tfun | cpp/numeric/complex/asinh | title=asinh{{dsc small|(std::complex)}} | computes area hyperbolic sine of a complex number | notes={{mark c++11}}}}</text>
      <sha1>dps6okmwmrsrjkkcussf93ncz9devys</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc atan</title>
    <ns>10</ns>
    <id>3558</id>
    <revision>
      <id>58389</id>
      <parentid>53911</parentid>
      <timestamp>2013-06-01T06:13:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list atan]] to [[Template:cpp/numeric/complex/dsc atan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="169">{{dsc tfun | cpp/numeric/complex/atan | title=atan{{dsc small|(std::complex)}}   | computes arc tangent of a complex number ({{math|arctan(z)}})| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc atanh</title>
    <ns>10</ns>
    <id>3564</id>
    <revision>
      <id>66437</id>
      <parentid>58394</parentid>
      <timestamp>2013-11-22T06:03:59Z</timestamp>
      <contributor>
        <username>Addaleax</username>
        <id>1023</id>
      </contributor>
      <minor/>
      <comment>Corrected inverse hyperbolic function name</comment>
      <text xml:space="preserve" bytes="160">{{dsc tfun | cpp/numeric/complex/atanh | title=atanh{{dsc small|(std::complex)}} | computes area hyperbolic tangent of a complex number | notes={{mark c++11}}}}</text>
      <sha1>drgbgxs1gn254swkhputo3q9lqo1iqv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc complex</title>
    <ns>10</ns>
    <id>13567</id>
    <revision>
      <id>71231</id>
      <timestamp>2014-06-08T20:01:19Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem ctor | cpp/numeric/complex/complex | constructs a complex number}}</text>
      <sha1>asdhj86q513r7jfk8py86eont2809zp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc conj</title>
    <ns>10</ns>
    <id>4270</id>
    <revision>
      <id>58398</id>
      <parentid>53913</parentid>
      <timestamp>2013-06-01T06:14:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list conj]] to [[Template:cpp/numeric/complex/dsc conj]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc tfun | cpp/numeric/complex/conj | returns the complex conjugate }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc cos</title>
    <ns>10</ns>
    <id>3554</id>
    <revision>
      <id>58402</id>
      <parentid>53916</parentid>
      <timestamp>2013-06-01T06:14:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list cos]] to [[Template:cpp/numeric/complex/dsc cos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/numeric/complex/cos | title=cos{{dsc small|(std::complex)}}     | computes cosine of a complex number ({{math|cos(z)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc cosh</title>
    <ns>10</ns>
    <id>3560</id>
    <revision>
      <id>58406</id>
      <parentid>53917</parentid>
      <timestamp>2013-06-01T06:14:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list cosh]] to [[Template:cpp/numeric/complex/dsc cosh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/numeric/complex/cosh | title=cosh{{dsc small|(std::complex)}}   | computes hyperbolic cosine of a complex number ({{math|ch(z)}})  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc exp</title>
    <ns>10</ns>
    <id>3548</id>
    <revision>
      <id>58411</id>
      <parentid>53920</parentid>
      <timestamp>2013-06-01T06:14:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list exp]] to [[Template:cpp/numeric/complex/dsc exp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tfun | cpp/numeric/complex/exp | title=exp{{dsc small|(std::complex)}} | complex base ''e'' exponential }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc imag</title>
    <ns>10</ns>
    <id>3543</id>
    <revision>
      <id>58415</id>
      <parentid>53921</parentid>
      <timestamp>2013-06-01T06:14:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list imag]] to [[Template:cpp/numeric/complex/dsc imag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/numeric/complex/imag | accesses the imaginary part of the complex number}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc imag2</title>
    <ns>10</ns>
    <id>4267</id>
    <revision>
      <id>58419</id>
      <parentid>53922</parentid>
      <timestamp>2013-06-01T06:14:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list imag2]] to [[Template:cpp/numeric/complex/dsc imag2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc tfun | cpp/numeric/complex/imag2 |title=imag| returns the imaginary component }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc log</title>
    <ns>10</ns>
    <id>3549</id>
    <revision>
      <id>58424</id>
      <parentid>53923</parentid>
      <timestamp>2013-06-01T06:14:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list log]] to [[Template:cpp/numeric/complex/dsc log]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc tfun | cpp/numeric/complex/log | title=log{{dsc small|(std::complex)}} | complex natural logarithm with the branch cuts along the negative real axis}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc log10</title>
    <ns>10</ns>
    <id>3550</id>
    <revision>
      <id>58428</id>
      <parentid>53926</parentid>
      <timestamp>2013-06-01T06:14:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list log10]] to [[Template:cpp/numeric/complex/dsc log10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/numeric/complex/log10 | title=log10{{dsc small|(std::complex)}} | complex common logarithm with the branch cuts along the negative real axis}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc norm</title>
    <ns>10</ns>
    <id>4269</id>
    <revision>
      <id>58432</id>
      <parentid>53929</parentid>
      <timestamp>2013-06-01T06:14:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list norm]] to [[Template:cpp/numeric/complex/dsc norm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc tfun | cpp/numeric/complex/norm | returns the squared magnitude }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator=</title>
    <ns>10</ns>
    <id>3544</id>
    <revision>
      <id>58436</id>
      <parentid>53930</parentid>
      <timestamp>2013-06-01T06:14:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator=]] to [[Template:cpp/numeric/complex/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/numeric/complex/operator{{=}} | assigns the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator arith</title>
    <ns>10</ns>
    <id>9264</id>
    <revision>
      <id>58440</id>
      <parentid>53933</parentid>
      <timestamp>2013-06-01T06:15:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator arith]] to [[Template:cpp/numeric/complex/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="184">{{dsc mem fun | cpp/numeric/complex/operator_arith | title=operator+=&lt;br&gt;operator-=&lt;br&gt;operator/=&lt;br&gt;operator*= | compound assignment of two complex numbers or a complex and a scalar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator arith2</title>
    <ns>10</ns>
    <id>9262</id>
    <revision>
      <id>58444</id>
      <parentid>53936</parentid>
      <timestamp>2013-06-01T06:15:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator arith2]] to [[Template:cpp/numeric/complex/dsc operator arith2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc tfun | cpp/numeric/complex/operator_arith2 | title=operator+&lt;br&gt;operator- | applies unary operators to complex numbers }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator arith3</title>
    <ns>10</ns>
    <id>9263</id>
    <revision>
      <id>58448</id>
      <parentid>53939</parentid>
      <timestamp>2013-06-01T06:15:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator arith3]] to [[Template:cpp/numeric/complex/dsc operator arith3]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="193">{{dsc tfun | cpp/numeric/complex/operator_arith3 | title=operator+&lt;br&gt;operator-&lt;br&gt;operator*&lt;br&gt;operator/ | performs complex number arithmetics on two complex values or a complex and a scalar}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator cmp</title>
    <ns>10</ns>
    <id>4264</id>
    <revision>
      <id>58452</id>
      <parentid>53940</parentid>
      <timestamp>2013-06-01T06:15:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator cmp]] to [[Template:cpp/numeric/complex/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc tfun | cpp/numeric/complex/operator_cmp | title=operator==&lt;br&gt;operator!= | compares two complex numbers or a complex and a scalar }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>4265</id>
    <revision>
      <id>58457</id>
      <parentid>53947</parentid>
      <timestamp>2013-06-01T06:15:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list operator ltltgtgt]] to [[Template:cpp/numeric/complex/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc tfun | cpp/numeric/complex/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | serializes and deserializes a complex number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc polar</title>
    <ns>10</ns>
    <id>4272</id>
    <revision>
      <id>58462</id>
      <parentid>53950</parentid>
      <timestamp>2013-06-01T06:15:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list polar]] to [[Template:cpp/numeric/complex/dsc polar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc tfun | cpp/numeric/complex/polar | constructs a complex number from magnitude and phase angle }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc pow</title>
    <ns>10</ns>
    <id>3551</id>
    <revision>
      <id>58467</id>
      <parentid>53951</parentid>
      <timestamp>2013-06-01T06:15:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list pow]] to [[Template:cpp/numeric/complex/dsc pow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tfun | cpp/numeric/complex/pow| title=pow{{dsc small|(std::complex)}} | complex power, one or both arguments may be a complex number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc proj</title>
    <ns>10</ns>
    <id>4271</id>
    <revision>
      <id>58472</id>
      <parentid>53952</parentid>
      <timestamp>2013-06-01T06:15:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list proj]] to [[Template:cpp/numeric/complex/dsc proj]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tfun | cpp/numeric/complex/proj | returns the projection onto the Riemann sphere |notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc real</title>
    <ns>10</ns>
    <id>3542</id>
    <revision>
      <id>58476</id>
      <parentid>53955</parentid>
      <timestamp>2013-06-01T06:15:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list real]] to [[Template:cpp/numeric/complex/dsc real]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/numeric/complex/real | accesses the real part of the complex number}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc real2</title>
    <ns>10</ns>
    <id>4266</id>
    <revision>
      <id>58480</id>
      <parentid>53956</parentid>
      <timestamp>2013-06-01T06:15:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list real2]] to [[Template:cpp/numeric/complex/dsc real2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc tfun | cpp/numeric/complex/real2 |title=real| returns the real component }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc sin</title>
    <ns>10</ns>
    <id>3553</id>
    <revision>
      <id>58485</id>
      <parentid>53957</parentid>
      <timestamp>2013-06-01T06:15:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list sin]] to [[Template:cpp/numeric/complex/dsc sin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/numeric/complex/sin | title=sin{{dsc small|(std::complex)}}     | computes sine of a complex number ({{math|sin(z)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc sinh</title>
    <ns>10</ns>
    <id>3559</id>
    <revision>
      <id>58489</id>
      <parentid>53958</parentid>
      <timestamp>2013-06-01T06:15:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list sinh]] to [[Template:cpp/numeric/complex/dsc sinh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc tfun | cpp/numeric/complex/sinh | title=sinh{{dsc small|(std::complex)}}   | computes hyperbolic sine of a complex number ({{math|sh(z)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc sqrt</title>
    <ns>10</ns>
    <id>3552</id>
    <revision>
      <id>58494</id>
      <parentid>53961</parentid>
      <timestamp>2013-06-01T06:16:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list sqrt]] to [[Template:cpp/numeric/complex/dsc sqrt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/numeric/complex/sqrt | title=sqrt{{dsc small|(std::complex)}} | complex square root in the range of the right half-plane }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc tan</title>
    <ns>10</ns>
    <id>3555</id>
    <revision>
      <id>58499</id>
      <parentid>53962</parentid>
      <timestamp>2013-06-01T06:16:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list tan]] to [[Template:cpp/numeric/complex/dsc tan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tfun | cpp/numeric/complex/tan | title=tan{{dsc small|(std::complex)}}     | computes tangent of a complex number ({{math|tan(z)}})  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/dsc tanh</title>
    <ns>10</ns>
    <id>3561</id>
    <revision>
      <id>58504</id>
      <parentid>53965</parentid>
      <timestamp>2013-06-01T06:16:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/complex/dcl list tanh]] to [[Template:cpp/numeric/complex/dsc tanh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc tfun | cpp/numeric/complex/tanh | title=tanh{{dsc small|(std::complex)}}   | computes hyperbolic tangent of a complex number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/navbar</title>
    <ns>10</ns>
    <id>2708</id>
    <revision>
      <id>39976</id>
      <parentid>35814</parentid>
      <timestamp>2012-09-28T20:14:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/complex/navbar heading
|content3 = cpp/numeric/complex/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/navbar content</title>
    <ns>10</ns>
    <id>4273</id>
    <revision>
      <id>71067</id>
      <parentid>53966</parentid>
      <timestamp>2014-06-05T02:17:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+ operator&quot;&quot;i</comment>
      <text xml:space="preserve" bytes="2217">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/complex/complex}}
{{nv mem ln | cpp/numeric/complex/operator{{=}}}}
{{nv mem ln | cpp/numeric/complex/real}}
{{nv mem ln | cpp/numeric/complex/imag}}
{{nv mem ln | cpp/numeric/complex/operator_arith | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} }}

{{nv h1 | Non-member functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/complex/operator_arith2 | operator+ | operator-}}
{{nv ln | cpp/numeric/complex/operator_arith3 | operator+ | operator- | operator* | operator/ }}
{{nv ln | cpp/numeric/complex/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/complex/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv col next}}
{{nv ln | cpp/numeric/complex/real2|real}}
{{nv ln | cpp/numeric/complex/imag2|imag}}
{{nv ln | cpp/numeric/complex/abs}}
{{nv ln | cpp/numeric/complex/arg}}
{{nv ln | cpp/numeric/complex/norm}}
{{nv ln | cpp/numeric/complex/conj}}
{{nv ln | cpp/numeric/complex/proj|notes={{mark c++11}}}}
{{nv ln | cpp/numeric/complex/polar}}
{{nv ln | cpp/numeric/complex/operator&quot;&quot;i|operator&quot;&quot;i|operator&quot;&quot;if|operator&quot;&quot;il|notes={{mark c++14}}&lt;br&gt;{{mark c++14}}&lt;br&gt;{{mark c++14}}}}
{{nv col end}}

{{nv h2 | Exponential functions}}
{{nv ln | cpp/numeric/complex/exp}}
{{nv ln | cpp/numeric/complex/log}}
{{nv ln | cpp/numeric/complex/log10}}

{{nv h2 | Power functions}}
{{nv ln | cpp/numeric/complex/pow}}
{{nv ln | cpp/numeric/complex/sqrt}}

{{nv h2 | Trigonometric functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/complex/sin}}
{{nv ln | cpp/numeric/complex/cos}}
{{nv ln | cpp/numeric/complex/tan}}
{{nv col next}}
{{nv ln | cpp/numeric/complex/asin | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/complex/acos | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/complex/atan | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Hyperbolic functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/complex/sinh}}
{{nv ln | cpp/numeric/complex/cosh}}
{{nv ln | cpp/numeric/complex/tanh}}
{{nv col next}}
{{nv ln | cpp/numeric/complex/asinh | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/complex/acosh | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/complex/atanh | notes={{mark c++11}}}}
{{nv col end}}
{{nv end}}</text>
      <sha1>57ifjd8obd7nigyob1bvu0cgtl1won4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/navbar heading</title>
    <ns>10</ns>
    <id>2709</id>
    <revision>
      <id>47104</id>
      <parentid>35816</parentid>
      <timestamp>2013-04-23T17:06:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update heading</comment>
      <text xml:space="preserve" bytes="40">{{ltt|cpp/numeric/complex|std::complex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/complex/title</title>
    <ns>10</ns>
    <id>3541</id>
    <revision>
      <id>13416</id>
      <timestamp>2011-11-08T18:49:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=complex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/dsc operator&quot;&quot;i</title>
    <ns>10</ns>
    <id>13024</id>
    <revision>
      <id>71065</id>
      <parentid>65916</parentid>
      <timestamp>2014-06-05T02:11:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>in complex subdir</comment>
      <text xml:space="preserve" bytes="187">{{dsc fun | cpp/numeric/complex/operator&quot;&quot;i | title=operator&quot;&quot;if&lt;br&gt;operator&quot;&quot;i&lt;br&gt;operator&quot;&quot;il | A {{lc|std::complex}} literal representing pure imaginary number | notes={{mark c++14}}}}</text>
      <sha1>m26uhhid68lwlv84jdeekyqkw7fz1gl</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc FE DFL ENV</title>
    <ns>10</ns>
    <id>5238</id>
    <revision>
      <id>58508</id>
      <parentid>53967</parentid>
      <timestamp>2013-06-01T06:16:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list FE DFL ENV]] to [[Template:cpp/numeric/fenv/dsc FE DFL ENV]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc macro const | cpp/numeric/fenv/FE_DFL_ENV | default floating-point environment|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc FE exceptions</title>
    <ns>10</ns>
    <id>5236</id>
    <revision>
      <id>58513</id>
      <parentid>53968</parentid>
      <timestamp>2013-06-01T06:16:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list FE exceptions]] to [[Template:cpp/numeric/fenv/dsc FE exceptions]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="200">{{dsc macro const | cpp/numeric/fenv/FE_exceptions | title=FE_ALL_EXCEPT&lt;br&gt;FE_DIVBYZERO&lt;br&gt;FE_INEXACT&lt;br&gt;FE_INVALID&lt;br&gt;FE_OVERFLOW&lt;br&gt;FE_UNDERFLOW | floating-point exceptions | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc FE round</title>
    <ns>10</ns>
    <id>5237</id>
    <revision>
      <id>58517</id>
      <parentid>53971</parentid>
      <timestamp>2013-06-01T06:16:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list FE round]] to [[Template:cpp/numeric/fenv/dsc FE round]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc macro const | cpp/numeric/fenv/FE_round | title=FE_DOWNWARD&lt;br&gt;FE_TONEAREST&lt;br&gt;FE_TOWARDZERO&lt;br&gt;FE_UPWARD | floating-point rounding direction|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feclearexcept</title>
    <ns>10</ns>
    <id>5239</id>
    <revision>
      <id>58521</id>
      <parentid>53972</parentid>
      <timestamp>2013-06-01T06:16:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feclearexcept]] to [[Template:cpp/numeric/fenv/dsc feclearexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | cpp/numeric/fenv/feclearexcept | clears the specified floating-point status flags|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feenv</title>
    <ns>10</ns>
    <id>5245</id>
    <revision>
      <id>58525</id>
      <parentid>53975</parentid>
      <timestamp>2013-06-01T06:16:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feenv]] to [[Template:cpp/numeric/fenv/dsc feenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc fun | cpp/numeric/fenv/feenv | title=fegetenv&lt;br&gt;fesetenv |  saves or restores the current floating point environment|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feexceptflag</title>
    <ns>10</ns>
    <id>5240</id>
    <revision>
      <id>58528</id>
      <parentid>53976</parentid>
      <timestamp>2013-06-01T06:16:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feexceptflag]] to [[Template:cpp/numeric/fenv/dsc feexceptflag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="229">{{dsc fun | cpp/numeric/fenv/feexceptflag | title=fegetexceptflag&lt;br&gt;fesetexceptflag|copies the state of the specified floating-point status flags from or to the floating-point environment|notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feholdexcept</title>
    <ns>10</ns>
    <id>5246</id>
    <revision>
      <id>58533</id>
      <parentid>53977</parentid>
      <timestamp>2013-06-01T06:16:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feholdexcept]] to [[Template:cpp/numeric/fenv/dsc feholdexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc fun | cpp/numeric/fenv/feholdexcept | saves the environment, clears all status flags and ignores all future errors|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feraiseexcept</title>
    <ns>10</ns>
    <id>5241</id>
    <revision>
      <id>58537</id>
      <parentid>53978</parentid>
      <timestamp>2013-06-01T06:16:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feraiseexcept]] to [[Template:cpp/numeric/fenv/dsc feraiseexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | cpp/numeric/fenv/feraiseexcept | raises the specified floating-point exceptions|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feround</title>
    <ns>10</ns>
    <id>3742</id>
    <revision>
      <id>58542</id>
      <parentid>53981</parentid>
      <timestamp>2013-06-01T06:16:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feround]] to [[Template:cpp/numeric/fenv/dsc feround]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc fun | cpp/numeric/fenv/feround | title=fegetround&lt;br&gt;fesetround | gets or sets rounding  direction | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc fetestexcept</title>
    <ns>10</ns>
    <id>5243</id>
    <revision>
      <id>58546</id>
      <parentid>53984</parentid>
      <timestamp>2013-06-01T06:16:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list fetestexcept]] to [[Template:cpp/numeric/fenv/dsc fetestexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc fun | cpp/numeric/fenv/fetestexcept | determines which of the specified floating-point status flags are set|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/dsc feupdateenv</title>
    <ns>10</ns>
    <id>5248</id>
    <revision>
      <id>58551</id>
      <parentid>53985</parentid>
      <timestamp>2013-06-01T06:17:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/dcl list feupdateenv]] to [[Template:cpp/numeric/fenv/dsc feupdateenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc fun | cpp/numeric/fenv/feupdateenv | restores the floating-point environment and raises the previously raise exceptions|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/example1</title>
    <ns>10</ns>
    <id>5250</id>
    <revision>
      <id>36104</id>
      <parentid>23458</parentid>
      <timestamp>2012-06-17T11:23:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>/* Example */ fmt</comment>
      <text xml:space="preserve" bytes="1189">{{example
 | 
 | code=
#include &lt;iostream&gt;
#include &lt;cfenv&gt;
#include &lt;cmath&gt;

#pragma STDC FENV_ACCESS ON

volatile double zero = 0.0; // volatile not needed where FENV_ACCESS is supported
volatile double one = 1.0;  // volatile not needed where FENV_ACCESS is supported

int main()
{
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt;  &quot;1.0/0.0 = &quot; &lt;&lt; 1.0 / zero &lt;&lt; '\n';
    if(std::fetestexcept(FE_DIVBYZERO)) {
        std::cout &lt;&lt; &quot;division by zero reported\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;divsion by zero not reported\n&quot;;
    }

    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;1.0/10 = &quot; &lt;&lt; one/10 &lt;&lt; '\n';
    if(std::fetestexcept(FE_INEXACT)) {
        std::cout &lt;&lt; &quot;inexact result reported\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;inexact result not reported\n&quot;;
    }

    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout &lt;&lt; &quot;sqrt(-1) = &quot; &lt;&lt; std::sqrt(-1) &lt;&lt; '\n';
    if(std::fetestexcept(FE_INVALID)) {
        std::cout &lt;&lt; &quot;invalid result reported\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;invalid result not reported\n&quot;;
    }
}
 | output=
1.0/0.0 = inf
division by zero reported
1.0/10 = 0.1
inexact result reported
sqrt(-1) = -nan
invalid result reported
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/navbar</title>
    <ns>10</ns>
    <id>2711</id>
    <revision>
      <id>39977</id>
      <parentid>35817</parentid>
      <timestamp>2012-09-28T20:14:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/fenv/navbar heading
|content3 = cpp/numeric/fenv/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/navbar content</title>
    <ns>10</ns>
    <id>5249</id>
    <revision>
      <id>53988</id>
      <parentid>36560</parentid>
      <timestamp>2013-06-01T05:08:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1035">{{nv begin}}
{{nv h1 | Functions}}
{{nv ln | cpp/numeric/fenv/feclearexcept | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/fetestexcept | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feraiseexcept | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feexceptflag | fegetexceptflag | fesetexceptflag | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feround | fegetround | fesetround | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feenv | fegetenv | fesetenv | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feholdexcept | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/feupdateenv | notes={{mark c++11}}}}

{{nv h1 | Macro constants}}
{{nv ln | cpp/numeric/fenv/FE_exceptions | FE_ALL_EXCEPT| FE_DIVBYZERO | FE_INEXACT | FE_INVALID | FE_OVERFLOW | FE_UNDERFLOW | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/FE_round | FE_DOWNWARD | FE_TONEAREST | FE_TOWARDZERO | FE_UPWARD | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/fenv/FE_DFL_ENV | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/fenv/navbar heading</title>
    <ns>10</ns>
    <id>2712</id>
    <revision>
      <id>34067</id>
      <parentid>10221</parentid>
      <timestamp>2012-06-15T21:11:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/fenv/sidebar heading]] to [[Template:cpp/numeric/fenv/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="47">[[cpp/numeric/fenv|Floating-point environment]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc FP categories</title>
    <ns>10</ns>
    <id>3689</id>
    <revision>
      <id>71597</id>
      <parentid>58556</parentid>
      <timestamp>2014-06-14T14:28:46Z</timestamp>
      <contributor>
        <ip>89.241.169.113</ip>
      </contributor>
      <text xml:space="preserve" bytes="255">{{dsc macro const | cpp/numeric/math/FP_categories | title=FP_NORMAL&lt;br&gt;FP_SUBNORMAL&lt;br&gt;FP_ZERO&lt;br&gt;FP_INFINITE&lt;br&gt;FP_NAN | indicates a floating-point category | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1>s2aofidklpn6a3zb3pxws9n1tvf9pkk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc HUGE VAL</title>
    <ns>10</ns>
    <id>1597</id>
    <revision>
      <id>58560</id>
      <parentid>53992</parentid>
      <timestamp>2013-06-01T06:17:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list HUGE VAL]] to [[Template:cpp/numeric/math/dsc HUGE VAL]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="232">{{dsc macro const | cpp/numeric/math/HUGE_VAL | title=HUGE_VALF&lt;br&gt;HUGE_VAL&lt;br&gt;HUGE_VALL | indicates the overflow value for {{c|float}}, {{c|double}} and {{c|long double}} respectively  | notes={{mark c++11}}&lt;br&gt;&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc INFINITY</title>
    <ns>10</ns>
    <id>13531</id>
    <revision>
      <id>70378</id>
      <timestamp>2014-05-21T14:49:28Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="154">{{dsc macro const | cpp/numeric/math/INFINITY | evaluates to positive infinity or the value guaranteed to overflow a {{c|float}}| notes={{mark c++11}}  }}</text>
      <sha1>39d7gr5i8m0tmvxkq1ufxtehdmy41f5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc NAN</title>
    <ns>10</ns>
    <id>13532</id>
    <revision>
      <id>70380</id>
      <timestamp>2014-05-21T14:51:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">{{dsc macro const | cpp/numeric/math/NAN | evaluates to a quiet NaN of type {{c|float}} | notes={{mark c++11}}}}</text>
      <sha1>m5nw1lgurh048zcl8wu79977mnsv94b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc abs</title>
    <ns>10</ns>
    <id>1600</id>
    <revision>
      <id>71891</id>
      <parentid>71145</parentid>
      <timestamp>2014-07-01T03:59:19Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>- imaxabs defined in other template</comment>
      <text xml:space="preserve" bytes="184">{{dsc fun | cpp/numeric/math/abs | title=abs{{dsc small|(int)}}&lt;br&gt;labs&lt;br&gt;llabs | computes absolute value of an integral value ({{math|{{!}}x{{!}}}}) | notes=&lt;br&gt;&lt;br&gt;{{mark c++11}} }}</text>
      <sha1>3ycszb6hzpayg719uneuh5fvwb4tcsu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc acos</title>
    <ns>10</ns>
    <id>1601</id>
    <revision>
      <id>58569</id>
      <parentid>53994</parentid>
      <timestamp>2013-06-01T06:17:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list acos]] to [[Template:cpp/numeric/math/dsc acos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/numeric/math/acos |computes arc cosine ({{math|arccos(x)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc acosh</title>
    <ns>10</ns>
    <id>1602</id>
    <revision>
      <id>70601</id>
      <parentid>66440</parentid>
      <timestamp>2014-05-26T06:06:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>'inverse'</comment>
      <text xml:space="preserve" bytes="121">{{dsc fun | cpp/numeric/math/acosh |computes the inverse hyperbolic cosine ({{math|arcosh(x)}}) | notes={{mark c++11}} }}</text>
      <sha1>n2fcbf7350y38u6szmgtzds7x8g4xqn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc asin</title>
    <ns>10</ns>
    <id>1603</id>
    <revision>
      <id>58578</id>
      <parentid>53998</parentid>
      <timestamp>2013-06-01T06:17:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list asin]] to [[Template:cpp/numeric/math/dsc asin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc fun | cpp/numeric/math/asin | computes arc sine ({{math|arcsin(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc asinh</title>
    <ns>10</ns>
    <id>1604</id>
    <revision>
      <id>70571</id>
      <parentid>70570</parentid>
      <timestamp>2014-05-25T03:01:49Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>er, this isn't the C one..</comment>
      <text xml:space="preserve" bytes="119">{{dsc fun | cpp/numeric/math/asinh |computes the inverse hyperbolic sine ({{math|arsinh(x)}}) | notes={{mark c++11}} }}</text>
      <sha1>bozbz6dlj24sklkayot7exxderesxm5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc atan</title>
    <ns>10</ns>
    <id>1605</id>
    <revision>
      <id>58586</id>
      <parentid>54001</parentid>
      <timestamp>2013-06-01T06:17:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list atan]] to [[Template:cpp/numeric/math/dsc atan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/numeric/math/atan |computes arc tangent ({{math|arctan(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc atan2</title>
    <ns>10</ns>
    <id>1606</id>
    <revision>
      <id>58590</id>
      <parentid>54002</parentid>
      <timestamp>2013-06-01T06:17:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list atan2]] to [[Template:cpp/numeric/math/dsc atan2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | cpp/numeric/math/atan2 |arc tangent, using signs to determine quadrants }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc atanh</title>
    <ns>10</ns>
    <id>1607</id>
    <revision>
      <id>70602</id>
      <parentid>66442</parentid>
      <timestamp>2014-05-26T06:06:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>inverse</comment>
      <text xml:space="preserve" bytes="122">{{dsc fun | cpp/numeric/math/atanh |computes the inverse hyperbolic tangent ({{math|artanh(x)}}) | notes={{mark c++11}} }}</text>
      <sha1>qx7y45m2cwb6zlkvnu3z10wd7s3v8iw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc cbrt</title>
    <ns>10</ns>
    <id>1608</id>
    <revision>
      <id>58599</id>
      <parentid>54004</parentid>
      <timestamp>2013-06-01T06:18:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list cbrt]] to [[Template:cpp/numeric/math/dsc cbrt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc fun | cpp/numeric/math/cbrt | computes cubic root  ({{math|{{mrad|x|3}}}}) | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc ceil</title>
    <ns>10</ns>
    <id>1609</id>
    <revision>
      <id>58603</id>
      <parentid>54007</parentid>
      <timestamp>2013-06-01T06:18:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list ceil]] to [[Template:cpp/numeric/math/dsc ceil]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | cpp/numeric/math/ceil | nearest integer not less than the given value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc copysign</title>
    <ns>10</ns>
    <id>1610</id>
    <revision>
      <id>58608</id>
      <parentid>54008</parentid>
      <timestamp>2013-06-01T06:18:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list copysign]] to [[Template:cpp/numeric/math/dsc copysign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/numeric/math/copysign | copies the sign of a floating point value | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc cos</title>
    <ns>10</ns>
    <id>1611</id>
    <revision>
      <id>58612</id>
      <parentid>54009</parentid>
      <timestamp>2013-06-01T06:18:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list cos]] to [[Template:cpp/numeric/math/dsc cos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc fun | cpp/numeric/math/cos |computes cosine ({{math|cos(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc cosh</title>
    <ns>10</ns>
    <id>1612</id>
    <revision>
      <id>58616</id>
      <parentid>54010</parentid>
      <timestamp>2013-06-01T06:18:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list cosh]] to [[Template:cpp/numeric/math/dsc cosh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | cpp/numeric/math/cosh |computes hyperbolic cosine ({{math|ch(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc div</title>
    <ns>10</ns>
    <id>1613</id>
    <revision>
      <id>71892</id>
      <parentid>71172</parentid>
      <timestamp>2014-07-01T04:01:45Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>- imaxdiv defined in other template</comment>
      <text xml:space="preserve" bytes="168">{{dsc fun | cpp/numeric/math/div | title=div{{dsc small|(int)}}&lt;br&gt;ldiv&lt;br&gt;lldiv | computes quotient and remainder of integer division | notes=&lt;br&gt;&lt;br&gt;{{mark c++11}} }}</text>
      <sha1>p0skqhytoucnklxtd11cb4qowsa9ua8</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc div t</title>
    <ns>10</ns>
    <id>13641</id>
    <revision>
      <id>71384</id>
      <parentid>71375</parentid>
      <timestamp>2014-06-10T01:27:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to where the type is defined</comment>
      <text xml:space="preserve" bytes="108">{{dsc typedef | cpp/numeric/math/div | title=div_t | structure type, return of the {{c|std::div}} function}}</text>
      <sha1>0v0h1xgy8ts1b7eimuoq2xkbgrjzoxk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc double t</title>
    <ns>10</ns>
    <id>13640</id>
    <revision>
      <id>71387</id>
      <parentid>71374</parentid>
      <timestamp>2014-06-10T01:30:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>nolink</comment>
      <text xml:space="preserve" bytes="134">{{dsc typedef | double_t | nolink=true | most efficient floating-point type at least as wide as {{c|double}} | notes={{mark c++11}} }}</text>
      <sha1>jpyls9mpmedj7xkt13vooke439953uh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc erf</title>
    <ns>10</ns>
    <id>1614</id>
    <revision>
      <id>58624</id>
      <parentid>54014</parentid>
      <timestamp>2013-06-01T06:18:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list erf]] to [[Template:cpp/numeric/math/dsc erf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun |cpp/numeric/math/erf | error function | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc erfc</title>
    <ns>10</ns>
    <id>1615</id>
    <revision>
      <id>58628</id>
      <parentid>54017</parentid>
      <timestamp>2013-06-01T06:18:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list erfc]] to [[Template:cpp/numeric/math/dsc erfc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/numeric/math/erfc | complementary error function | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc exp</title>
    <ns>10</ns>
    <id>1616</id>
    <revision>
      <id>58632</id>
      <parentid>54018</parentid>
      <timestamp>2013-06-01T06:18:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list exp]] to [[Template:cpp/numeric/math/dsc exp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/numeric/math/exp | returns ''e'' raised to the given power ({{math|e&lt;sup&gt;x&lt;/sup&gt;}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc exp2</title>
    <ns>10</ns>
    <id>1617</id>
    <revision>
      <id>58636</id>
      <parentid>54019</parentid>
      <timestamp>2013-06-01T06:18:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list exp2]] to [[Template:cpp/numeric/math/dsc exp2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/numeric/math/exp2 | returns ''2'' raised to the given power ({{math|2&lt;sup&gt;x&lt;/sup&gt;}}) | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc expm1</title>
    <ns>10</ns>
    <id>1618</id>
    <revision>
      <id>58640</id>
      <parentid>54020</parentid>
      <timestamp>2013-06-01T06:19:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list expm1]] to [[Template:cpp/numeric/math/dsc expm1]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc fun | cpp/numeric/math/expm1 | returns ''e'' raised to the given power, minus one ({{math|e&lt;sup&gt;x&lt;/sup&gt;-1}}) | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fabs</title>
    <ns>10</ns>
    <id>1619</id>
    <revision>
      <id>58645</id>
      <parentid>54021</parentid>
      <timestamp>2013-06-01T06:19:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fabs]] to [[Template:cpp/numeric/math/dsc fabs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc fun | cpp/numeric/math/fabs | title=abs{{dsc small|(float)}} &lt;br&gt; fabs | absolute value of a floating point value ({{math|{{!}}x{{!}}}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fdim</title>
    <ns>10</ns>
    <id>1620</id>
    <revision>
      <id>58649</id>
      <parentid>54022</parentid>
      <timestamp>2013-06-01T06:19:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fdim]] to [[Template:cpp/numeric/math/dsc fdim]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc fun | cpp/numeric/math/fdim | positive difference of two floating point values ({{math|max(0, x-y)}}) | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc float t</title>
    <ns>10</ns>
    <id>13639</id>
    <revision>
      <id>71388</id>
      <parentid>71380</parentid>
      <timestamp>2014-06-10T01:31:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>nolink</comment>
      <text xml:space="preserve" bytes="132">{{dsc typedef | nolink=true | float_t | most efficient floating-point type at least as wide as {{c|float}} | notes={{mark c++11}} }}</text>
      <sha1>997rhto9ft5s1kqgb391tf9i782fi0d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc floor</title>
    <ns>10</ns>
    <id>1621</id>
    <revision>
      <id>58653</id>
      <parentid>54023</parentid>
      <timestamp>2013-06-01T06:19:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list floor]] to [[Template:cpp/numeric/math/dsc floor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/numeric/math/floor | nearest integer not greater than the given value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fma</title>
    <ns>10</ns>
    <id>1622</id>
    <revision>
      <id>58657</id>
      <parentid>54024</parentid>
      <timestamp>2013-06-01T06:19:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fma]] to [[Template:cpp/numeric/math/dsc fma]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | cpp/numeric/math/fma | fused multiply-add operation | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fmax</title>
    <ns>10</ns>
    <id>1623</id>
    <revision>
      <id>58661</id>
      <parentid>54028</parentid>
      <timestamp>2013-06-01T06:19:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fmax]] to [[Template:cpp/numeric/math/dsc fmax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | cpp/numeric/math/fmax | larger of two floating point values | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fmin</title>
    <ns>10</ns>
    <id>1624</id>
    <revision>
      <id>58665</id>
      <parentid>54033</parentid>
      <timestamp>2013-06-01T06:19:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fmin]] to [[Template:cpp/numeric/math/dsc fmin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | cpp/numeric/math/fmin | smaller of two floating point values | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fmod</title>
    <ns>10</ns>
    <id>1625</id>
    <revision>
      <id>58670</id>
      <parentid>54036</parentid>
      <timestamp>2013-06-01T06:19:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fmod]] to [[Template:cpp/numeric/math/dsc fmod]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/numeric/math/fmod | remainder of the floating point division operation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fnan</title>
    <ns>10</ns>
    <id>1626</id>
    <revision>
      <id>58674</id>
      <parentid>54037</parentid>
      <timestamp>2013-06-01T06:19:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fnan]] to [[Template:cpp/numeric/math/dsc fnan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc fun | cpp/numeric/math/nan | title=nan&lt;br&gt;nanf&lt;br&gt;nanl | not-a-number (NaN) | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc fpclassify</title>
    <ns>10</ns>
    <id>1627</id>
    <revision>
      <id>58678</id>
      <parentid>54038</parentid>
      <timestamp>2013-06-01T06:19:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list fpclassify]] to [[Template:cpp/numeric/math/dsc fpclassify]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/numeric/math/fpclassify | categorizes the given floating point value | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc frexp</title>
    <ns>10</ns>
    <id>1628</id>
    <revision>
      <id>58682</id>
      <parentid>54041</parentid>
      <timestamp>2013-06-01T06:19:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list frexp]] to [[Template:cpp/numeric/math/dsc frexp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | cpp/numeric/math/frexp |decomposes a number into significand and a power of {{c|2}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc hypot</title>
    <ns>10</ns>
    <id>1629</id>
    <revision>
      <id>58686</id>
      <parentid>54042</parentid>
      <timestamp>2013-06-01T06:19:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list hypot]] to [[Template:cpp/numeric/math/dsc hypot]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="174">{{dsc fun | cpp/numeric/math/hypot | computes square root of the sum of the squares of two given numbers ({{math|{{mrad|x{{su|p=2}}+y{{su|p=2}}}}}}) | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc ilogb</title>
    <ns>10</ns>
    <id>1630</id>
    <revision>
      <id>58690</id>
      <parentid>54043</parentid>
      <timestamp>2013-06-01T06:19:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list ilogb]] to [[Template:cpp/numeric/math/dsc ilogb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/numeric/math/ilogb | extracts exponent of the number | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc imaxabs</title>
    <ns>10</ns>
    <id>13700</id>
    <revision>
      <id>71888</id>
      <timestamp>2014-07-01T03:54:56Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>New template to separate abs and imaxabs</comment>
      <text xml:space="preserve" bytes="199">{{dsc fun | cpp/numeric/math/abs | title=abs{{dsc small|(std::intmax_t)}}&lt;br&gt;imaxabs | computes absolute value of an integral value ({{math|{{!}}x{{!}} }}) | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1>o36lf13kp05l68412hcqil3j4h0k0fk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc imaxdiv</title>
    <ns>10</ns>
    <id>13701</id>
    <revision>
      <id>71889</id>
      <timestamp>2014-07-01T03:55:00Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <comment>New template to separate div and imaxdiv</comment>
      <text xml:space="preserve" bytes="182">{{dsc fun | cpp/numeric/math/div | title=div{{dsc small|(std::intmax_t)}}&lt;br&gt;imaxdiv | computes quotient and remainder of integer division | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1>4w8747z77uadsn8ttbay5qaw1vxku2v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc imaxdiv t</title>
    <ns>10</ns>
    <id>13644</id>
    <revision>
      <id>71386</id>
      <parentid>71378</parentid>
      <timestamp>2014-06-10T01:28:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to where the type is defined</comment>
      <text xml:space="preserve" bytes="140">{{dsc typedef | cpp/numeric/math/div | title=imaxdiv_t | structure type, return of the {{c|std::imaxdiv}} function | notes={{mark c++11}} }}</text>
      <sha1>oc8wmnsffr01rjppvv3i1bdckv05egm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isfinite</title>
    <ns>10</ns>
    <id>1631</id>
    <revision>
      <id>58694</id>
      <parentid>54044</parentid>
      <timestamp>2013-06-01T06:19:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isfinite]] to [[Template:cpp/numeric/math/dsc isfinite]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | cpp/numeric/math/isfinite | checks if the given number has finite value | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isgreater</title>
    <ns>10</ns>
    <id>9208</id>
    <revision>
      <id>58698</id>
      <parentid>54047</parentid>
      <timestamp>2013-06-01T06:19:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isgreater]] to [[Template:cpp/numeric/math/dsc isgreater]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc fun | cpp/numeric/math/isgreater | checks if the first floating-point argument is greater than the second| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isgreaterequal</title>
    <ns>10</ns>
    <id>9209</id>
    <revision>
      <id>58703</id>
      <parentid>54048</parentid>
      <timestamp>2013-06-01T06:20:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isgreaterequal]] to [[Template:cpp/numeric/math/dsc isgreaterequal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc fun | cpp/numeric/math/isgreaterequal | checks if the first floating-point argument is greater or equal than the second| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isinf</title>
    <ns>10</ns>
    <id>1632</id>
    <revision>
      <id>58707</id>
      <parentid>54049</parentid>
      <timestamp>2013-06-01T06:20:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isinf]] to [[Template:cpp/numeric/math/dsc isinf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/numeric/math/isinf | checks if the given number is infinite | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isless</title>
    <ns>10</ns>
    <id>9210</id>
    <revision>
      <id>58711</id>
      <parentid>54052</parentid>
      <timestamp>2013-06-01T06:20:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isless]] to [[Template:cpp/numeric/math/dsc isless]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc fun | cpp/numeric/math/isless | checks if the first floating-point argument is less than the second| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc islessequal</title>
    <ns>10</ns>
    <id>9211</id>
    <revision>
      <id>58715</id>
      <parentid>54053</parentid>
      <timestamp>2013-06-01T06:20:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list islessequal]] to [[Template:cpp/numeric/math/dsc islessequal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc fun | cpp/numeric/math/islessequal | checks if the first floating-point argument is less or equal than the second| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc islessgreater</title>
    <ns>10</ns>
    <id>9212</id>
    <revision>
      <id>58719</id>
      <parentid>54056</parentid>
      <timestamp>2013-06-01T06:20:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list islessgreater]] to [[Template:cpp/numeric/math/dsc islessgreater]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc fun | cpp/numeric/math/islessgreater | checks if the first floating-point argument is less or greater than the second| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isnan</title>
    <ns>10</ns>
    <id>1633</id>
    <revision>
      <id>58723</id>
      <parentid>54057</parentid>
      <timestamp>2013-06-01T06:20:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isnan]] to [[Template:cpp/numeric/math/dsc isnan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc fun | cpp/numeric/math/isnan | checks if the given number is NaN| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isnormal</title>
    <ns>10</ns>
    <id>1634</id>
    <revision>
      <id>58727</id>
      <parentid>54058</parentid>
      <timestamp>2013-06-01T06:20:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isnormal]] to [[Template:cpp/numeric/math/dsc isnormal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/numeric/math/isnormal | checks if the given number is normal | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc isunordered</title>
    <ns>10</ns>
    <id>9213</id>
    <revision>
      <id>58731</id>
      <parentid>54061</parentid>
      <timestamp>2013-06-01T06:20:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list isunordered]] to [[Template:cpp/numeric/math/dsc isunordered]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc fun | cpp/numeric/math/isunordered | checks if two floating-point values are unordered| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc ldexp</title>
    <ns>10</ns>
    <id>1635</id>
    <revision>
      <id>58734</id>
      <parentid>54062</parentid>
      <timestamp>2013-06-01T06:20:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list ldexp]] to [[Template:cpp/numeric/math/dsc ldexp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | cpp/numeric/math/ldexp | multiplies a number by {{c|2}} raised to a power}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc ldiv t</title>
    <ns>10</ns>
    <id>13642</id>
    <revision>
      <id>71385</id>
      <parentid>71376</parentid>
      <timestamp>2014-06-10T01:28:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>link to where the type is defined</comment>
      <text xml:space="preserve" bytes="110">{{dsc typedef | cpp/numeric/math/div | title=ldiv_t | structure type, return of the {{c|std::ldiv}} function}}</text>
      <sha1>aswp18f0rjz4kzqe728ftecu0dvn7q7</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc lgamma</title>
    <ns>10</ns>
    <id>1636</id>
    <revision>
      <id>58738</id>
      <parentid>54063</parentid>
      <timestamp>2013-06-01T06:20:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list lgamma]] to [[Template:cpp/numeric/math/dsc lgamma]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/numeric/math/lgamma | natural logarithm of the gamma function | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc lldiv t</title>
    <ns>10</ns>
    <id>13643</id>
    <revision>
      <id>71383</id>
      <parentid>71377</parentid>
      <timestamp>2014-06-10T01:27:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>link to where the type is defined</comment>
      <text xml:space="preserve" bytes="136">{{dsc typedef | cpp/numeric/math/div | title=lldiv_t | structure type, return of the {{c|std::lldiv}} function | notes={{mark c++11}} }}</text>
      <sha1>eqod6ex7glxdmrltcpuy0ooywygzn7f</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc log</title>
    <ns>10</ns>
    <id>1637</id>
    <revision>
      <id>58742</id>
      <parentid>54064</parentid>
      <timestamp>2013-06-01T06:20:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list log]] to [[Template:cpp/numeric/math/dsc log]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/numeric/math/log | computes natural (base ''e'') logarithm (to base ''e'') ({{math|ln(x)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc log10</title>
    <ns>10</ns>
    <id>1638</id>
    <revision>
      <id>58746</id>
      <parentid>54067</parentid>
      <timestamp>2013-06-01T06:20:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list log10]] to [[Template:cpp/numeric/math/dsc log10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/numeric/math/log10 | computes common (base ''10'') logarithm ({{math|log&lt;sub&gt;10&lt;/sub&gt;(x)}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc log1p</title>
    <ns>10</ns>
    <id>1639</id>
    <revision>
      <id>70590</id>
      <parentid>58750</parentid>
      <timestamp>2014-05-25T20:21:58Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ ({{math|ln(1+x)}})</comment>
      <text xml:space="preserve" bytes="143">{{dsc fun | cpp/numeric/math/log1p |  natural logarithm (to base ''e'') of 1 plus the given number ({{math|ln(1+x)}}) | notes={{mark c++11}} }}</text>
      <sha1>7vx05iylv8kl5lnzd3mb9iy9wzqvs6i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc log2</title>
    <ns>10</ns>
    <id>4901</id>
    <revision>
      <id>70592</id>
      <parentid>58754</parentid>
      <timestamp>2014-05-25T20:27:21Z</timestamp>
      <contributor>
        <username>Diego91b</username>
        <id>3102</id>
      </contributor>
      <minor/>
      <comment>+ ({{math|log&lt;sub&gt;2&lt;/sub&gt;(x)}})</comment>
      <text xml:space="preserve" bytes="128">{{dsc fun | cpp/numeric/math/log2 | base 2 logarithm of the given number ({{math|log&lt;sub&gt;2&lt;/sub&gt;(x)}}) | notes={{mark c++11}} }}</text>
      <sha1>6ra8s26io4m4s0u4o78sdcnxg1p0sco</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc logb</title>
    <ns>10</ns>
    <id>1640</id>
    <revision>
      <id>58758</id>
      <parentid>54072</parentid>
      <timestamp>2013-06-01T06:20:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list logb]] to [[Template:cpp/numeric/math/dsc logb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc fun | cpp/numeric/math/logb | extracts exponent of the number | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc math errhandling</title>
    <ns>10</ns>
    <id>9221</id>
    <revision>
      <id>58762</id>
      <parentid>54073</parentid>
      <timestamp>2013-06-01T06:20:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list math errhandling]] to [[Template:cpp/numeric/math/dsc math errhandling]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="252">{{dsc macro const | cpp/numeric/math/math_errhandling |title=math_errhandling&lt;br&gt;MATH_ERRNO&lt;br&gt;MATH_ERREXCEPT | defines the error handling mechanism used by the common mathematical functions | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc modf</title>
    <ns>10</ns>
    <id>1641</id>
    <revision>
      <id>58767</id>
      <parentid>54076</parentid>
      <timestamp>2013-06-01T06:20:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list modf]] to [[Template:cpp/numeric/math/dsc modf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | cpp/numeric/math/modf |decomposes a number into integer and fractional parts }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc nearbyint</title>
    <ns>10</ns>
    <id>1642</id>
    <revision>
      <id>58770</id>
      <parentid>54077</parentid>
      <timestamp>2013-06-01T06:20:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list nearbyint]] to [[Template:cpp/numeric/math/dsc nearbyint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/numeric/math/nearbyint | nearest integer using current rounding mode | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc nextafter</title>
    <ns>10</ns>
    <id>1643</id>
    <revision>
      <id>58774</id>
      <parentid>54078</parentid>
      <timestamp>2013-06-01T06:21:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list nextafter]] to [[Template:cpp/numeric/math/dsc nextafter]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="180">{{dsc fun | cpp/numeric/math/nextafter | title=nextafter&lt;br&gt;nexttoward | next representable floating point value towards the given value | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc pow</title>
    <ns>10</ns>
    <id>1645</id>
    <revision>
      <id>58779</id>
      <parentid>54079</parentid>
      <timestamp>2013-06-01T06:21:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list pow]] to [[Template:cpp/numeric/math/dsc pow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc fun | cpp/numeric/math/pow | raises a number to the given power ({{math|x&lt;sup&gt;y&lt;/sup&gt;}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc remainder</title>
    <ns>10</ns>
    <id>1646</id>
    <revision>
      <id>58784</id>
      <parentid>54082</parentid>
      <timestamp>2013-06-01T06:21:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list remainder]] to [[Template:cpp/numeric/math/dsc remainder]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | cpp/numeric/math/remainder | signed remainder of the division operation | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc remquo</title>
    <ns>10</ns>
    <id>1647</id>
    <revision>
      <id>58788</id>
      <parentid>54083</parentid>
      <timestamp>2013-06-01T06:21:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list remquo]] to [[Template:cpp/numeric/math/dsc remquo]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc fun | cpp/numeric/math/remquo | signed remainder as well as the three last bits of the division operation | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc rint</title>
    <ns>10</ns>
    <id>1648</id>
    <revision>
      <id>58792</id>
      <parentid>54086</parentid>
      <timestamp>2013-06-01T06:21:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list rint]] to [[Template:cpp/numeric/math/dsc rint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="215">{{dsc fun | cpp/numeric/math/rint | title=rint&lt;br&gt;lrint&lt;br&gt;llrint | nearest integer using current rounding mode with &lt;br&gt; exception if the result differs | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc round</title>
    <ns>10</ns>
    <id>1649</id>
    <revision>
      <id>58797</id>
      <parentid>54087</parentid>
      <timestamp>2013-06-01T06:21:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list round]] to [[Template:cpp/numeric/math/dsc round]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="191">{{dsc fun | cpp/numeric/math/round | title=round&lt;br&gt;lround&lt;br&gt;llround | nearest integer, rounding away from zero in halfway cases | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc scalbn</title>
    <ns>10</ns>
    <id>1650</id>
    <revision>
      <id>58801</id>
      <parentid>54088</parentid>
      <timestamp>2013-06-01T06:21:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list scalbn]] to [[Template:cpp/numeric/math/dsc scalbn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc fun | cpp/numeric/math/scalbn | title=scalbn&lt;br&gt;scalbln | multiplies a number by {{lc|FLT_RADIX}} raised to a power | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc signbit</title>
    <ns>10</ns>
    <id>1651</id>
    <revision>
      <id>58805</id>
      <parentid>54091</parentid>
      <timestamp>2013-06-01T06:21:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list signbit]] to [[Template:cpp/numeric/math/dsc signbit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/numeric/math/signbit | checks if the given number is negative | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc sin</title>
    <ns>10</ns>
    <id>1652</id>
    <revision>
      <id>58810</id>
      <parentid>54094</parentid>
      <timestamp>2013-06-01T06:21:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list sin]] to [[Template:cpp/numeric/math/dsc sin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc fun | cpp/numeric/math/sin | computes sine ({{math|sin(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc sinh</title>
    <ns>10</ns>
    <id>1653</id>
    <revision>
      <id>58813</id>
      <parentid>54095</parentid>
      <timestamp>2013-06-01T06:21:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list sinh]] to [[Template:cpp/numeric/math/dsc sinh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | cpp/numeric/math/sinh | computes hyperbolic sine ({{math|sh(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc sqrt</title>
    <ns>10</ns>
    <id>1654</id>
    <revision>
      <id>58817</id>
      <parentid>54098</parentid>
      <timestamp>2013-06-01T06:21:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list sqrt]] to [[Template:cpp/numeric/math/dsc sqrt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | cpp/numeric/math/sqrt | computes square root ({{math|{{mrad|x}}}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc tan</title>
    <ns>10</ns>
    <id>1655</id>
    <revision>
      <id>58822</id>
      <parentid>54101</parentid>
      <timestamp>2013-06-01T06:21:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list tan]] to [[Template:cpp/numeric/math/dsc tan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc fun | cpp/numeric/math/tan | computes tangent ({{math|tan(x)}})}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc tanh</title>
    <ns>10</ns>
    <id>1656</id>
    <revision>
      <id>58826</id>
      <parentid>54102</parentid>
      <timestamp>2013-06-01T06:22:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list tanh]] to [[Template:cpp/numeric/math/dsc tanh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">{{dsc fun | cpp/numeric/math/tanh |hyperbolic tangent }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc tgamma</title>
    <ns>10</ns>
    <id>1657</id>
    <revision>
      <id>58830</id>
      <parentid>54103</parentid>
      <timestamp>2013-06-01T06:22:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list tgamma]] to [[Template:cpp/numeric/math/dsc tgamma]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/numeric/math/tgamma | gamma function | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/dsc trunc</title>
    <ns>10</ns>
    <id>1658</id>
    <revision>
      <id>58834</id>
      <parentid>54104</parentid>
      <timestamp>2013-06-01T06:22:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/dcl list trunc]] to [[Template:cpp/numeric/math/dsc trunc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc fun | cpp/numeric/math/trunc | nearest integer not greater in magnitude than the given value | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/example nearbyint</title>
    <ns>10</ns>
    <id>5600</id>
    <revision>
      <id>23459</id>
      <parentid>20679</parentid>
      <timestamp>2012-04-20T02:26:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="1526">{{example
 | code=
#include &lt;cmath&gt;
#include &lt;cfenv&gt;
#include &lt;iostream&gt;

int main()
{
    #pragma STDC FENV_ACCESS ON
    std::fesetround(FE_DOWNWARD);
    std::cout &lt;&lt; &quot;rounding using FE_DOWNWARD: \n&quot; &lt;&lt; std::fixed
              &lt;&lt; &quot; 12.0 -&gt;  &quot; &lt;&lt; std::nearbyint(12.0) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.1 -&gt;  &quot; &lt;&lt; std::nearbyint(12.1) &lt;&lt; '\n'
              &lt;&lt; &quot;-12.1 -&gt; &quot; &lt;&lt; std::nearbyint(-12.1) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.5 -&gt;  &quot; &lt;&lt; std::nearbyint(12.5) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.9 -&gt;  &quot; &lt;&lt; std::nearbyint(12.9) &lt;&lt; '\n'
              &lt;&lt; &quot;-12.9 -&gt; &quot; &lt;&lt; std::nearbyint(-12.9) &lt;&lt; '\n'
              &lt;&lt; &quot; 13.0 -&gt;  &quot; &lt;&lt; std::nearbyint(13.0) &lt;&lt; '\n';
    std::fesetround(FE_TONEAREST);
    std::cout &lt;&lt; &quot;rounding using FE_TONEAREST: \n&quot;
              &lt;&lt; &quot; 12.0 -&gt;  &quot; &lt;&lt; std::nearbyint(12.0) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.1 -&gt;  &quot; &lt;&lt; std::nearbyint(12.1) &lt;&lt; '\n'
              &lt;&lt; &quot;-12.1 -&gt; &quot; &lt;&lt; std::nearbyint(-12.1) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.5 -&gt;  &quot; &lt;&lt; std::nearbyint(12.5) &lt;&lt; '\n'
              &lt;&lt; &quot; 12.9 -&gt;  &quot; &lt;&lt; std::nearbyint(12.9) &lt;&lt; '\n'
              &lt;&lt; &quot;-12.9 -&gt; &quot; &lt;&lt; std::nearbyint(-12.9) &lt;&lt; '\n'
              &lt;&lt; &quot; 13.0 -&gt;  &quot; &lt;&lt; std::nearbyint(13.0) &lt;&lt; '\n';
}
| output =
rounding using FE_DOWNWARD:
 12.0 -&gt;  12.000000
 12.1 -&gt;  12.000000
-12.1 -&gt; -13.000000
 12.5 -&gt;  12.000000
 12.9 -&gt;  12.000000
-12.9 -&gt; -13.000000
 13.0 -&gt;  13.000000
rounding using FE_TONEAREST: 
 12.0 -&gt;  12.000000
 12.1 -&gt;  12.000000
-12.1 -&gt; -12.000000
 12.5 -&gt;  12.000000
 12.9 -&gt;  13.000000
-12.9 -&gt; -13.000000
 13.0 -&gt;  13.000000
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/navbar</title>
    <ns>10</ns>
    <id>1659</id>
    <revision>
      <id>39978</id>
      <parentid>36067</parentid>
      <timestamp>2012-09-28T20:14:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="242">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/math/navbar heading
|content3 = cpp/numeric/math/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/navbar content</title>
    <ns>10</ns>
    <id>1660</id>
    <revision>
      <id>54107</id>
      <parentid>40408</parentid>
      <timestamp>2013-06-01T05:09:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="5208">&lt;div style=&quot;display:inline-block; vertical-align:top;&quot;&gt;
{{nv begin}}
{{nv h1 | Functions}}
{{nv h2 | Basic operations}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/abs | abs(int) | labs | llabs |imaxabs|notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/numeric/math/fabs | abs(float) | fabs}}
{{nv ln | cpp/numeric/math/div | div | ldiv | lldiv| imaxdiv|notes=&lt;br&gt;&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/numeric/math/fmod}}
{{nv col next}}
{{nv ln | cpp/numeric/math/remainder | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/remquo | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/fma | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/fmax | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/fmin | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/fdim | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/nan | nan | nanf | nanl | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv col end}}

{{nv h2 | Exponential functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/exp}}
{{nv ln | cpp/numeric/math/exp2 | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/expm1 | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/numeric/math/log}}
{{nv ln | cpp/numeric/math/log10}}
{{nv ln | cpp/numeric/math/log1p | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/log2| notes={{mark c++11}} }}
{{nv col end}}

{{nv h2 | Power functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/sqrt}}
{{nv ln | cpp/numeric/math/cbrt | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/numeric/math/hypot | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/pow}}
{{nv col end}}

{{nv h2 | Trigonometric and hyperbolic functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/sin}}
{{nv ln | cpp/numeric/math/cos}}
{{nv ln | cpp/numeric/math/tan}}
{{nv ln | cpp/numeric/math/asin}}
{{nv ln | cpp/numeric/math/acos}}
{{nv ln | cpp/numeric/math/atan}}
{{nv ln | cpp/numeric/math/atan2}}
{{nv col next}}
{{nv ln | cpp/numeric/math/sinh}}
{{nv ln | cpp/numeric/math/cosh}}
{{nv ln | cpp/numeric/math/tanh}}
{{nv ln | cpp/numeric/math/asinh | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/acosh | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/atanh | notes={{mark c++11}} }}
{{nv col end}}
{{nv end}}
&lt;/div&gt;
&lt;div style=&quot;display:inline-block&quot;&gt;
{{nv begin}}
{{nv h2 | Error and gamma functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/erf | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/erfc | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/numeric/math/lgamma | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/tgamma | notes={{mark c++11}} }}
{{nv col end}}

{{nv h2 | Nearest integer floating point operations}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/ceil}}
{{nv ln | cpp/numeric/math/floor}}
{{nv ln | cpp/numeric/math/round | round | lround | llround  | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/numeric/math/trunc | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/nearbyint | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/rint | rint | lrint | llrint | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv col end}}

{{nv h2 | Floating point manipulation functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/ldexp}}
{{nv ln | cpp/numeric/math/scalbn | scalbn | scalbln | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/numeric/math/ilogb | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/logb | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/numeric/math/frexp}}
{{nv ln | cpp/numeric/math/modf}}
{{nv ln | cpp/numeric/math/nextafter | nextafter | nexttoward | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/numeric/math/copysign | notes={{mark c++11}} }}
{{nv col end}}

{{nv h2 | Classification/Comparison}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/fpclassify | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isfinite | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isinf | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isnan | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isnormal | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/signbit | notes={{mark c++11}} }}
{{nv col next}}
{{nv ln | cpp/numeric/math/isgreater | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isgreaterequal | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isless | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/islessequal | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/islessgreater | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/math/isunordered | notes={{mark c++11}} }}
{{nv col end}}

{{nv h1 | Macro constants}}
{{nv col begin}}
{{nv ln | cpp/numeric/math/HUGE_VAL | HUGE_VALF | HUGE_VAL | HUGE_VALL | notes={{mark c++11}}&lt;br&gt;&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/numeric/math/INFINITY | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/math/NAN | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/math/math_errhandling | math_errhandling | MATH_ERRNO | MATH_ERREXCEPT  | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/numeric/math/FP_categories | FP_NORMAL | FP_SUBNORMAL | FP_ZERO | FP_INFINITE | FP_NAN | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv col end}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/math/navbar heading</title>
    <ns>10</ns>
    <id>1661</id>
    <revision>
      <id>35109</id>
      <parentid>3322</parentid>
      <timestamp>2012-06-15T22:18:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/math/sidebar heading]] to [[Template:cpp/numeric/math/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="52">[[cpp/numeric/math | Common mathematical functions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/navbar</title>
    <ns>10</ns>
    <id>1662</id>
    <revision>
      <id>39979</id>
      <parentid>35568</parentid>
      <timestamp>2012-09-28T20:14:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="154">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/navbar content</title>
    <ns>10</ns>
    <id>2703</id>
    <revision>
      <id>54110</id>
      <parentid>35887</parentid>
      <timestamp>2013-06-01T05:09:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="649">{{nv begin}}
{{nv | [[cpp/numeric/math|Common mathematical functions]] }}
{{nv | [[cpp/numeric/fenv|Floating-point environment]] }}
{{nv | [[cpp/numeric/complex|Complex numbers]] }}
{{nv | [[cpp/numeric/valarray|Numeric arrays]] }}
{{nv | [[cpp/numeric/random|Pseudo-random number generation]] }}
{{nv | [[cpp/numeric/ratio | Compile-time rational arithmetic]] {{mark c++11}} }}
{{nv h2 | Generic numeric operations }}
{{nv ln | cpp/algorithm/iota | notes={{mark c++11}} }}
{{nv ln | cpp/algorithm/accumulate }}
{{nv ln | cpp/algorithm/inner_product }}
{{nv ln | cpp/algorithm/adjacent_difference }}
{{nv ln | cpp/algorithm/partial_sum }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/navbar heading</title>
    <ns>10</ns>
    <id>1663</id>
    <revision>
      <id>35888</id>
      <parentid>3326</parentid>
      <timestamp>2012-06-15T22:34:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/sidebar heading]] to [[Template:cpp/numeric/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="34">[[cpp/numeric | Numerics library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random//navbar</title>
    <ns>10</ns>
    <id>4541</id>
    <redirect title="Template:cpp/numeric/random/navbar" />
    <revision>
      <id>37186</id>
      <parentid>35821</parentid>
      <timestamp>2012-07-03T14:07:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:cpp/numeric/random/navbar]]</comment>
      <text xml:space="preserve" bytes="48">#redirect [[Template:cpp/numeric/random/navbar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random//title</title>
    <ns>10</ns>
    <id>3903</id>
    <revision>
      <id>14605</id>
      <timestamp>2011-11-27T12:32:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>dummy page</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/base</title>
    <ns>10</ns>
    <id>8813</id>
    <revision>
      <id>62249</id>
      <parentid>37193</parentid>
      <timestamp>2013-06-25T12:37:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="291">{{cpp/numeric/random/{{{1|}}}/title|base}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
const Engine&amp; base() const;
}}
{{dcl end}}

Returns the underlying engine.

===Parameters===
(none)

===Return value===
The underlying engine.

===Exceptions===
{{noexcept}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/constructor</title>
    <ns>10</ns>
    <id>8811</id>
    <revision>
      <id>67802</id>
      <parentid>63594</parentid>
      <timestamp>2014-02-28T15:04:12Z</timestamp>
      <contributor>
        <username>Vinnie</username>
        <id>2733</id>
      </contributor>
      <text xml:space="preserve" bytes="918">{{cpp/numeric/random/{{{1|}}}/title|{{{1}}}}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
{{{1}}}();
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Sseq &gt;
explicit {{{1}}}( Sseq&amp; seq );
}}
{{dcl | num=3 | since=c++11 |
explicit {{{1}}}( const Engine&amp; e );
}}
{{dcl | num=4 | since=c++11 |
explicit {{{1}}}( Engine&amp;&amp; e );
}}
{{dcl end}}

Constructs new pseudo-random engine adaptor.

@1@ Default constructor. The underlying engine is also default-constructed.
@2@ Constructs the underlying engine with seed sequence {{tt|seq}}.
@3@ Constructs the underlying engine with a copy of {{tt|e}}.
@4@ Move-constructs the underlying engine with {{tt|e}}. {{tt|e}} holds unspecified, but valid state afterwards.

===Parameters===
{{par begin}}
{{par | seq | seed sequence to construct the underlying engine with}}
{{par | e | pseudo-random number engine to initialize with}} 
{{par end}}</text>
      <sha1>fkmmuv0nyx97jv9iy17au8o1ai40yfd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/discard</title>
    <ns>10</ns>
    <id>8815</id>
    <revision>
      <id>64371</id>
      <parentid>62233</parentid>
      <timestamp>2013-08-15T18:43:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="669">{{cpp/numeric/random/{{{1|}}}/title|discard}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void discard( unsigned long long z );
}}
{{dcl end}}

Advances the internal state by {{tt|z}} times. Equivalent to calling {{lc|operator()}} {{tt|z}} times and discarding the result. The state of the underlying engine may be advanced by more than {{tt|z}} times.

===Parameters===
{{par begin}}
{{par | z | integer value specifying the number of times to advance the state by}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc operator()|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc base</title>
    <ns>10</ns>
    <id>8783</id>
    <revision>
      <id>58839</id>
      <parentid>54114</parentid>
      <timestamp>2013-06-01T06:22:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list base]] to [[Template:cpp/numeric/random/adaptor/dsc base]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/base | returns the underlying engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc constructor</title>
    <ns>10</ns>
    <id>8779</id>
    <revision>
      <id>58843</id>
      <parentid>54121</parentid>
      <timestamp>2013-06-01T06:22:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list constructor]] to [[Template:cpp/numeric/random/adaptor/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem ctor | cpp/numeric/random/{{{1|}}}/{{{1|}}} | constructs the engine adaptor}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc discard</title>
    <ns>10</ns>
    <id>8782</id>
    <revision>
      <id>58848</id>
      <parentid>54122</parentid>
      <timestamp>2013-06-01T06:22:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list discard]] to [[Template:cpp/numeric/random/adaptor/dsc discard]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/discard | advances the adaptor's state by a specified amount}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc max</title>
    <ns>10</ns>
    <id>8775</id>
    <revision>
      <id>66521</id>
      <parentid>66520</parentid>
      <timestamp>2013-11-30T08:04:55Z</timestamp>
      <contributor>
        <username>IMneme</username>
        <id>2601</id>
      </contributor>
      <minor/>
      <comment>fix typo</comment>
      <text xml:space="preserve" bytes="243">{{dsc mem sfun | cpp/numeric/random/{{{1|}}}/max | gets the largest possible value in the output range {{#switch:{{{1|}}}
|independent_bits_engine=(always 2{{su|p=w}}-1).
|shuffle_order_engine|discard_block_engine|of the underlying engine.}}}}</text>
      <sha1>t36vbpfdysxt2bd2bumuycl2jpss2eb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc min</title>
    <ns>10</ns>
    <id>8776</id>
    <revision>
      <id>66522</id>
      <parentid>58857</parentid>
      <timestamp>2013-11-30T08:06:20Z</timestamp>
      <contributor>
        <username>IMneme</username>
        <id>2601</id>
      </contributor>
      <comment>independent_bits_engine has a min of zero, not the min of the underlying engine</comment>
      <text xml:space="preserve" bytes="235">{{dsc mem sfun | cpp/numeric/random/{{{1|}}}/min | gets the smallest possible value in the output range {{#switch:{{{1|}}}
|independent_bits_engine=(always zero).
|shuffle_order_engine|discard_block_engine|of the underlying engine.}}}}</text>
      <sha1>esyjt5x1k4ml97ptax0wmo9qpfro0ll</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc operator()</title>
    <ns>10</ns>
    <id>8777</id>
    <revision>
      <id>58860</id>
      <parentid>54127</parentid>
      <timestamp>2013-06-01T06:22:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list operator()]] to [[Template:cpp/numeric/random/adaptor/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/operator() | advances the state of the underlying engine and returns the generated value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc operator cmp</title>
    <ns>10</ns>
    <id>8780</id>
    <revision>
      <id>58864</id>
      <parentid>54128</parentid>
      <timestamp>2013-06-01T06:22:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list operator cmp]] to [[Template:cpp/numeric/random/adaptor/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="166">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_cmp | title=operator{{==}}&lt;br&gt;operator!{{=}} | compares the internal states of the adaptors and underlying engines }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>8778</id>
    <revision>
      <id>58867</id>
      <parentid>54131</parentid>
      <timestamp>2013-06-01T06:22:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list operator ltltgtgt]] to [[Template:cpp/numeric/random/adaptor/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output on pseudo-random number engine adaptor }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/dsc seed</title>
    <ns>10</ns>
    <id>8781</id>
    <revision>
      <id>58871</id>
      <parentid>54132</parentid>
      <timestamp>2013-06-01T06:22:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/adaptor/dcl list seed]] to [[Template:cpp/numeric/random/adaptor/dsc seed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/seed | sets the state of the underlying engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/max</title>
    <ns>10</ns>
    <id>8829</id>
    <revision>
      <id>66523</id>
      <parentid>63595</parentid>
      <timestamp>2013-11-30T08:07:08Z</timestamp>
      <contributor>
        <username>IMneme</username>
        <id>2601</id>
      </contributor>
      <comment>2^w - 1, not 2^w</comment>
      <text xml:space="preserve" bytes="659">{{cpp/numeric/random/{{{1|}}}/title|max}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
static constexpr result_type max();
}}
{{dcl end}}

Returns the maximum value potentially generated by the engine adaptor. {{#switch:{{{1|}}}
|independent_bits_engine=This value is equal to 2{{su|p=w}}-1
|shuffle_order_engine|discard_block_engine|This value is equal to {{c|e.max()}} where {{tt|e}} is the underlying engine.
}}

===Parameters===
(none)

===Return value===
The maximum potentially generated value.

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc min|{{{1|}}}}}
{{dsc end}}</text>
      <sha1>7ywuqrvvhatu8j0mbk1f06n5gswtj1s</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/min</title>
    <ns>10</ns>
    <id>8816</id>
    <revision>
      <id>66518</id>
      <parentid>63596</parentid>
      <timestamp>2013-11-30T07:36:46Z</timestamp>
      <contributor>
        <username>IMneme</username>
        <id>2601</id>
      </contributor>
      <comment>independent_bits_engine goes 0..2^w, not 2^w..2^w</comment>
      <text xml:space="preserve" bytes="648">{{cpp/numeric/random/{{{1|}}}/title|min}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
static constexpr result_type min();
}}
{{dcl end}}

Returns the minimum value potentially generated by the engine adaptor. {{#switch:{{{1|}}}
|independent_bits_engine=This value is equal to 0u
|shuffle_order_engine|discard_block_engine|This value is equal to {{c|e.min()}} where {{tt|e}} is the underlying engine.
}}

===Parameters===
(none)

===Return value===
The minimum potentially generated value.

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc max|{{{1|}}}}}
{{dsc end}}</text>
      <sha1>cok24htzkv4m76anmug6bjbcpi4e4gk</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/operator()</title>
    <ns>10</ns>
    <id>8814</id>
    <revision>
      <id>62250</id>
      <parentid>60906</parentid>
      <timestamp>2013-06-25T12:37:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="432">{{cpp/numeric/random/{{{1|}}}/title|seed}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
result_type operator()();
}}
{{dcl end}}

Generates a random value. The state of the underlying engine is advanced one or more times.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
(none)

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/adaptor/dsc discard|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/operator cmp</title>
    <ns>10</ns>
    <id>8823</id>
    <revision>
      <id>63597</id>
      <parentid>54143</parentid>
      <timestamp>2013-07-10T01:45:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1082">{{title|1=operator==,!=&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{cpp/numeric/random/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl end}}

Compares two pseudo-random number engine adaptors. Two engine adaptors are equal, if their underlying engines are equal and their internal state (if any) is equal, that is, if they would generate equivalent values for any number of calls of {{c|operator()}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | engine adaptors to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if the engine adaptors are equivalent, {{c|false}} otherwise.
@2@ {{c|true}} if the engine adaptors are not equivalent, {{c|false}} otherwise.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/operator ltltgtgt</title>
    <ns>10</ns>
    <id>8825</id>
    <revision>
      <id>63598</id>
      <parentid>54144</parentid>
      <timestamp>2013-07-10T01:45:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1983">{{title |operator&lt;&lt;,&gt;&gt;&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{cpp/numeric/random/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class CharT, class Traits, class ResultType,
          {{#var:types}} &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp; 
    operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; ost, 
                const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; e );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class CharT, class Traits, class ResultType,
          {{#var:types}} &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; 
    operator&gt;&gt;( std::basic_istream&lt;CharT,Traits&gt;&amp; ist, 
                {{{1}}}&lt;{{#var:types_short}}&gt;&amp; e );
}}
{{dcl end}}

@1@ Serializes the internal state of the pseudo-random number engine adaptor as a sequence of decimal numbers separated by one or more spaces, and inserts it to the stream {{tt|ost}}. The fill character and the formatting flags of the stream are ignored and unaffected. 

@2@ Restores the internal state of the pseudo-random number engine adaptor {{tt|e}} from the serialized representation, which was created by an earlier call to {{tt|operator&lt;&lt;}} using a stream with the same imbued locale and the same {{tt|CharT}} and {{tt|Traits}}. If the input cannot be deserialized, {{tt|e}} is left unchanged and {{tt|failbit}} is raised on {{tt|ist}}

If a textual representation is written using {{c|os &lt;&lt; x}} and that representation is restored into the same or a different object {{tt|y}} of the same type using {{c|is &gt;&gt; y}}, then {{c|1=x==y}}.

{{todo|standard also defines what the textual representation consists of}}

===Parameters===
{{par begin}}
{{par | ost | output stream to insert the data to}}
{{par | ist | input stream to extract the data from}}
{{par | e | engine adaptor to serialize or restore}}
{{par end}}

===Return value===
@1@ {{tt|ost}}
@2@ {{tt|ist}}

===Complexity===
{{todo}}

===Exceptions===
@1@ (none)
@2@ May throw {{c|std::ios::failure}} when setting {{tt|failbit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/adaptor/seed</title>
    <ns>10</ns>
    <id>8812</id>
    <revision>
      <id>63599</id>
      <parentid>54147</parentid>
      <timestamp>2013-07-10T01:45:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1113">{{cpp/numeric/random/{{{1|}}}/title|seed}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
void seed();
}}
{{dcl | num=2 | since=c++11 |
void seed( result_type value );
}}
{{dcl | num=3 | since=c++11 |
template&lt; class Sseq &gt; 
void seed( Sseq&amp; seq );
}}
{{dcl end}}

Reinitializes the internal state of the underlying engine using a new seed value.

@1@ Seeds the underlying engine with the default seed value. Effectively calls {{c|e.seed()}}, where {{tt|e}} is the underlying engine.
@2@ Seeds the underlying engine with the seed value {{tt|s}}. Effectively calls {{c|e.seed(value)}}, where {{tt|e}} is the underlying engine.
@3@ Seeds the underlying engine with the seed sequence {{tt|seq}}. Effectively calls {{c|e.seed(seq)}}, where {{tt|e}} is the underlying engine.

===Parameters===
{{par begin}}
{{par | value | seed value to use in the initialization of the internal state of the underlying engine}}
{{par | seq | seed sequence to use in the initialization of the internal state of the underlying engine}}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/bernoulli distribution/dsc p</title>
    <ns>10</ns>
    <id>5004</id>
    <revision>
      <id>58876</id>
      <parentid>54150</parentid>
      <timestamp>2013-06-01T06:22:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/bernoulli distribution/dcl list p]] to [[Template:cpp/numeric/random/bernoulli distribution/dsc p]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc mem fun | cpp/numeric/random/bernoulli_distribution/p | returns the ''p'' distribution parameter (probability of generating {{c|true}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/bernoulli distribution/navbar</title>
    <ns>10</ns>
    <id>3930</id>
    <revision>
      <id>39980</id>
      <parentid>36065</parentid>
      <timestamp>2012-09-28T20:14:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="384">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/bernoulli_distribution/navbar heading
|content4 = cpp/numeric/random/bernoulli_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/bernoulli distribution/navbar content</title>
    <ns>10</ns>
    <id>4285</id>
    <revision>
      <id>54151</id>
      <parentid>35823</parentid>
      <timestamp>2013-06-01T05:09:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="740">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/bernoulli_distribution}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/param}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/min}}
{{nv mem ln | cpp/numeric/random/bernoulli_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/bernoulli_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/bernoulli_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/bernoulli distribution/navbar heading</title>
    <ns>10</ns>
    <id>3948</id>
    <revision>
      <id>60984</id>
      <parentid>35825</parentid>
      <timestamp>2013-06-03T11:41:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="77">{{ltt|cpp/numeric/random/bernoulli_distribution|std::bernoulli_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/bernoulli distribution/title</title>
    <ns>10</ns>
    <id>4001</id>
    <revision>
      <id>14747</id>
      <timestamp>2011-11-27T14:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=bernoulli_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/binomial distribution/navbar</title>
    <ns>10</ns>
    <id>3931</id>
    <revision>
      <id>39981</id>
      <parentid>36066</parentid>
      <timestamp>2012-09-28T20:14:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="382">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/binomial_distribution/navbar heading
|content4 = cpp/numeric/random/binomial_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/binomial distribution/navbar content</title>
    <ns>10</ns>
    <id>4286</id>
    <revision>
      <id>61162</id>
      <parentid>54160</parentid>
      <timestamp>2013-06-05T12:24:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge p and t</comment>
      <text xml:space="preserve" bytes="803">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/binomial_distribution}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/params | p | t}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/param}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/min}}
{{nv mem ln | cpp/numeric/random/binomial_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/binomial_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/binomial_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/binomial distribution/navbar heading</title>
    <ns>10</ns>
    <id>3952</id>
    <revision>
      <id>48055</id>
      <parentid>35490</parentid>
      <timestamp>2013-05-18T18:02:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="75">{{ltt|cpp/numeric/random/binomial_distribution|std::binomial_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/binomial distribution/title</title>
    <ns>10</ns>
    <id>4000</id>
    <revision>
      <id>14746</id>
      <timestamp>2011-11-27T14:11:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">&lt;onlyinclude&gt;{{cpp/title | n=binomial_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/cauchy distribution/navbar</title>
    <ns>10</ns>
    <id>3942</id>
    <revision>
      <id>39982</id>
      <parentid>36050</parentid>
      <timestamp>2012-09-28T20:15:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="378">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/cauchy_distribution/navbar heading
|content4 = cpp/numeric/random/cauchy_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/cauchy distribution/navbar content</title>
    <ns>10</ns>
    <id>4299</id>
    <revision>
      <id>61123</id>
      <parentid>54165</parentid>
      <timestamp>2013-06-05T11:52:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge a and b</comment>
      <text xml:space="preserve" bytes="783">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/cauchy_distribution}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/params | a | b}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/param}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/min}}
{{nv mem ln | cpp/numeric/random/cauchy_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/cauchy_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/cauchy_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/cauchy distribution/navbar heading</title>
    <ns>10</ns>
    <id>3960</id>
    <revision>
      <id>48063</id>
      <parentid>35829</parentid>
      <timestamp>2013-05-18T18:04:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="71">{{ltt|cpp/numeric/random/cauchy_distribution|std::cauchy_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/cauchy distribution/title</title>
    <ns>10</ns>
    <id>3989</id>
    <revision>
      <id>14735</id>
      <timestamp>2011-11-27T14:10:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=cauchy_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/chi squared distribution/dsc n</title>
    <ns>10</ns>
    <id>8891</id>
    <revision>
      <id>58896</id>
      <parentid>54166</parentid>
      <timestamp>2013-06-01T06:23:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/chi squared distribution/dcl list n]] to [[Template:cpp/numeric/random/chi squared distribution/dsc n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem fun | cpp/numeric/random/chi_squared_distribution/n | returns the degrees of freedom ({{math|n}}) distribution parameter}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/chi squared distribution/navbar</title>
    <ns>10</ns>
    <id>3941</id>
    <revision>
      <id>39983</id>
      <parentid>36049</parentid>
      <timestamp>2012-09-28T20:15:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="388">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/chi_squared_distribution/navbar heading
|content4 = cpp/numeric/random/chi_squared_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/chi squared distribution/navbar content</title>
    <ns>10</ns>
    <id>4298</id>
    <revision>
      <id>54169</id>
      <parentid>37518</parentid>
      <timestamp>2013-06-01T05:10:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="820">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/chi_squared_distribution}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/n}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/param}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/min}}
{{nv mem ln | cpp/numeric/random/chi_squared_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/chi_squared_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/chi_squared_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/chi squared distribution/navbar heading</title>
    <ns>10</ns>
    <id>3951</id>
    <revision>
      <id>48054</id>
      <parentid>35571</parentid>
      <timestamp>2013-05-18T18:02:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="81">{{ltt|cpp/numeric/random/chi_squared_distribution|std::chi_squared_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/chi squared distribution/title</title>
    <ns>10</ns>
    <id>3990</id>
    <revision>
      <id>14736</id>
      <timestamp>2011-11-27T14:10:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>=</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/title | n=chi_squared_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discard block engine/navbar</title>
    <ns>10</ns>
    <id>3707</id>
    <revision>
      <id>39984</id>
      <parentid>36048</parentid>
      <timestamp>2012-09-28T20:15:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="380">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/discard_block_engine/navbar heading
|content4 = cpp/numeric/random/discard_block_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discard block engine/navbar content</title>
    <ns>10</ns>
    <id>6474</id>
    <revision>
      <id>54179</id>
      <parentid>35833</parentid>
      <timestamp>2013-06-01T05:10:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="784">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/discard_block_engine}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/seed}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/base}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/operator()}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/min}}
{{nv mem ln | cpp/numeric/random/discard_block_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/discard_block_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/discard_block_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discard block engine/navbar heading</title>
    <ns>10</ns>
    <id>3713</id>
    <revision>
      <id>48047</id>
      <parentid>35834</parentid>
      <timestamp>2013-05-18T18:01:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/numeric/random/discard_block_engine|std::discard_block_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discard block engine/title</title>
    <ns>10</ns>
    <id>8828</id>
    <revision>
      <id>37234</id>
      <timestamp>2012-07-03T17:11:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=discard_block_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discrete distribution/dsc probabilities</title>
    <ns>10</ns>
    <id>4966</id>
    <revision>
      <id>58924</id>
      <parentid>54180</parentid>
      <timestamp>2013-06-01T06:23:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/discrete distribution/dcl list probabilities]] to [[Template:cpp/numeric/random/discrete distribution/dsc probabilities]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc mem fun | cpp/numeric/random/discrete_distribution/probabilities | obtains the list of probabilities }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discrete distribution/navbar</title>
    <ns>10</ns>
    <id>3945</id>
    <revision>
      <id>39985</id>
      <parentid>36068</parentid>
      <timestamp>2012-09-28T20:16:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="382">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/discrete_distribution/navbar heading
|content4 = cpp/numeric/random/discrete_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discrete distribution/navbar content</title>
    <ns>10</ns>
    <id>4302</id>
    <revision>
      <id>54181</id>
      <parentid>35836</parentid>
      <timestamp>2013-06-01T05:10:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="802">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/discrete_distribution}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/probabilities}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/param}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/min}}
{{nv mem ln | cpp/numeric/random/discrete_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/discrete_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/discrete_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discrete distribution/navbar heading</title>
    <ns>10</ns>
    <id>3963</id>
    <revision>
      <id>48066</id>
      <parentid>34657</parentid>
      <timestamp>2013-05-18T18:04:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="75">{{ltt|cpp/numeric/random/discrete_distribution|std::discrete_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/discrete distribution/title</title>
    <ns>10</ns>
    <id>3986</id>
    <revision>
      <id>14732</id>
      <timestamp>2011-11-27T14:10:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">&lt;onlyinclude&gt;{{cpp/title | n=discrete_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc constructor</title>
    <ns>10</ns>
    <id>3909</id>
    <revision>
      <id>58932</id>
      <parentid>54182</parentid>
      <timestamp>2013-06-01T06:24:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list constructor]] to [[Template:cpp/numeric/random/distribution/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem ctor | cpp/numeric/random/{{{1|}}}/{{{1|}}} | constructs new distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc max</title>
    <ns>10</ns>
    <id>3309</id>
    <revision>
      <id>58936</id>
      <parentid>54183</parentid>
      <timestamp>2013-06-01T06:24:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list max]] to [[Template:cpp/numeric/random/distribution/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/max | returns the maximum potentially generated value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc min</title>
    <ns>10</ns>
    <id>3308</id>
    <revision>
      <id>58941</id>
      <parentid>54184</parentid>
      <timestamp>2013-06-01T06:24:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list min]] to [[Template:cpp/numeric/random/distribution/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/min | returns the minimum potentially generated value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc operator()</title>
    <ns>10</ns>
    <id>3310</id>
    <revision>
      <id>58946</id>
      <parentid>54185</parentid>
      <timestamp>2013-06-01T06:24:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list operator()]] to [[Template:cpp/numeric/random/distribution/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/operator() | generates the next random number in the distribution }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc operator cmp</title>
    <ns>10</ns>
    <id>3323</id>
    <revision>
      <id>58951</id>
      <parentid>54188</parentid>
      <timestamp>2013-06-01T06:24:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list operator cmp]] to [[Template:cpp/numeric/random/distribution/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_cmp | title=operator==&lt;br&gt;operator!= |  compares two distribution objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>3324</id>
    <revision>
      <id>58956</id>
      <parentid>54189</parentid>
      <timestamp>2013-06-01T06:24:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list operator ltltgtgt]] to [[Template:cpp/numeric/random/distribution/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output on pseudo-random number distribution }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc param</title>
    <ns>10</ns>
    <id>3311</id>
    <revision>
      <id>58960</id>
      <parentid>54192</parentid>
      <timestamp>2013-06-01T06:24:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list param]] to [[Template:cpp/numeric/random/distribution/dsc param]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/param | gets or sets the distribution parameter object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc params</title>
    <ns>10</ns>
    <id>12595</id>
    <revision>
      <id>61174</id>
      <parentid>61169</parentid>
      <timestamp>2013-06-05T12:25:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="604">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/params | title={{#switch:{{{1|}}}
|uniform_int_distribution = a&lt;br/&gt;b
|uniform_real_distribution = a&lt;br/&gt;b
|binomial_distribution = p&lt;br/&gt;t
|negative_binomial_distribution = p&lt;br/&gt;k
|gamma_distribution = alpha&lt;br/&gt;beta
|normal_distribution = mean&lt;br/&gt;stddev
|weibull_distribution = a&lt;br/&gt;b
|extreme_value_distribution = a&lt;br/&gt;b
|lognormal_distribution = m&lt;br/&gt;s
|cauchy_distribution = a&lt;br/&gt;b
|fisher_f_distribution = m&lt;br/&gt;n
|piecewise_constant_distribution | piecewise_linear_distribution = intervals&lt;br/&gt;densities 
}}| returns the distribution parameters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/dsc reset</title>
    <ns>10</ns>
    <id>3312</id>
    <revision>
      <id>58964</id>
      <parentid>54195</parentid>
      <timestamp>2013-06-01T06:24:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/dcl list reset]] to [[Template:cpp/numeric/random/distribution/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/reset | resets the internal state of the distribution }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/max</title>
    <ns>10</ns>
    <id>3319</id>
    <revision>
      <id>64049</id>
      <parentid>62234</parentid>
      <timestamp>2013-08-07T06:33:35Z</timestamp>
      <contributor>
        <username>Faithandbrave</username>
        <id>1470</id>
      </contributor>
      <comment>fixed max() function description : &quot;Returns the minimum value&quot; to &quot;Return the maximum value&quot;.</comment>
      <text xml:space="preserve" bytes="467">{{cpp/numeric/random/{{{1|}}}/title | max}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
result_type max() const;
}}
{{dcl end}}

Returns the maximum value potentially generated by the distribution.

===Parameters===
(none)

===Return value===
The maximum value potentially generated by the distribution.

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc min|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/min</title>
    <ns>10</ns>
    <id>3314</id>
    <revision>
      <id>64048</id>
      <parentid>62220</parentid>
      <timestamp>2013-08-07T06:32:39Z</timestamp>
      <contributor>
        <username>Faithandbrave</username>
        <id>1470</id>
      </contributor>
      <comment>fixed min() function description : &quot;Returns the maximum value&quot; to &quot;Return the minimum value&quot;.</comment>
      <text xml:space="preserve" bytes="466">{{cpp/numeric/random/{{{1|}}}/title | min}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
result_type min() const;
}}
{{dcl end}}

Returns the minimum value potentially generated by the distribution.

===Parameters===
(none)

===Return value===
The minimum value potentially generated by the distribution

===Complexity===
Constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/distribution/dsc max|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/operator()</title>
    <ns>10</ns>
    <id>4099</id>
    <revision>
      <id>63600</id>
      <parentid>63157</parentid>
      <timestamp>2013-07-10T01:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="993">{{cpp/numeric/random/{{{1|}}}/title | operator()}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
template&lt; class Generator &gt;
result_type operator()( Generator&amp; g );
}}
{{dcl | since=c++11 | num=2 | 1=
template&lt; class Generator &gt;
result_type operator()( Generator&amp; g, const param_type&amp; params );
}}
{{dcl end}}

Generates random numbers that are distributed according to the associated probability function. The entropy is acquired by calling {{c|g.operator()}}. 

The first version uses the associated parameter set, the second version uses {{tt|params}}. The associated parameter set is not modified.

{{todo | requirements on Generator}}

===Parameters===
{{par begin}}
{{par | g | an uniform random number generator object}}
{{par | params | distribution parameter set to use instead of the associated one}}
{{par end}}

===Return value===
The generated random number.

===Complexity===
Amortized constant number of invocations of {{c|g.operator()}}.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/operator cmp</title>
    <ns>10</ns>
    <id>3326</id>
    <revision>
      <id>54203</id>
      <parentid>35364</parentid>
      <timestamp>2013-06-01T05:10:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="942">{{title | 1=operator==,!=&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}

{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class ResultType &gt;
bool operator==( const {{{1}}}&lt;ResultType&gt;&amp; lhs,
	         const {{{1}}}&lt;ResultType&gt;&amp; rhs );

}}
{{dcl | num=2 | 1=
template&lt; class ResultType &gt;
bool operator!=( const {{{1}}}&lt;ResultType&gt;&amp; lhs,
	         const {{{1}}}&lt;ResultType&gt;&amp; rhs );
}}
{{dcl end}}

Compares two distribution objects. Two distribution objects are equal when parameter values and internal state is the same.

1) Compares two distribution objects for equality.

2) Compares two distribution objects for inequality.

===Parameters===
{{par begin}}
{{par | lhs, rhs | distribution objects to compare}}
{{par end}}

===Return value===
1) {{c|true}} if the distribution objects are equal, {{c|false}} otherwise

2) {{c|true}} if the distribution objects are not equal, {{c|false}} otherwise

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/operator ltltgtgt</title>
    <ns>10</ns>
    <id>4540</id>
    <revision>
      <id>63200</id>
      <parentid>63199</parentid>
      <timestamp>2013-07-05T17:02:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="1660">{{title |operator&lt;&lt;,&gt;&gt;&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
template&lt; class CharT, class Traits, class ResultType &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp; operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; ost, 
                                              const {{{1}}}&amp; d );
}}
{{dcl | num=2 | 1=
template&lt; class CharT, class Traits, class ResultType &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; operator&gt;&gt;( std::basic_istream&lt;CharT,Traits&gt;&amp; ist, 
                                              {{{1}}}&amp; d );
}}
{{dcl end}}

Performs stream input and output operations on pseudo-random number distribution {{tt|d}}.

@1@ Writes a textual representation of the distribution parameters and internal state to {{tt|ost}} as textual representation. The formatting flags and fill character of {{tt|ost}} are unchanged.

@2@ Restores the distribution parameters and internal state with data read from {{tt|ist}}. The formatting flags of {{tt|ist}} are unchanged. The data must have been written using a stream with the same locale, {{tt|CharT}} and {{tt|Traits}} template parameters, otherwise the behavior is undefined. If bad input is encountered, {{c|ist.setstate(std::ios::failbit)}} is called, which may throw {{lc|std::ios_base::failure}}. {{tt|d}} is unchanged in that case.

===Parameters===
{{par begin}}
{{par | ost | output stream to insert the data to}}
{{par | ist | input stream to extract the data from}}
{{par | d | pseudo-random number distribution}}
{{par end}}

===Return value===
@1@ {{tt|ost}}

@2@ {{tt|ist}}

===Exceptions===
@1@ (none)

@2@ may throw {{lc|std::ios_base::failure}} on bad input.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/param</title>
    <ns>10</ns>
    <id>4122</id>
    <revision>
      <id>63601</id>
      <parentid>54207</parentid>
      <timestamp>2013-07-10T01:45:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="597">{{cpp/numeric/random/{{{1|}}}/title | param}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | num=1 | 1=
param_type param() const;
}}
{{dcl | since=c++11 | num=2 | 1=
void param( const param_type&amp; params );
}}
{{dcl end}}

Manages the associated distribution parameter set.

1) Returns the associated parameter set.

2) Sets the associated parameter set to {{tt|params}}

===Parameters===
{{par begin}}
{{par | params | new contents of the associated parameter set }}
{{par end}}

===Return value===
1) The associated parameter set

2) (none)

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/distribution/reset</title>
    <ns>10</ns>
    <id>3322</id>
    <revision>
      <id>62237</id>
      <parentid>62235</parentid>
      <timestamp>2013-06-25T12:33:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use lc</comment>
      <text xml:space="preserve" bytes="440">{{cpp/numeric/random/{{{1|}}}/title | reset}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void reset();
}}
{{dcl end}}

Resets the internal state of the distribution object.  After a call to this function, the next call to {{lc|operator()}} on the distribution object will not be dependent on previous calls to {{lc|operator()}}.

===Parameters===
(none)

===Return value===
(none)

===Complexity===
Constant.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc RAND MAX</title>
    <ns>10</ns>
    <id>6410</id>
    <revision>
      <id>58901</id>
      <parentid>54170</parentid>
      <timestamp>2013-06-01T06:23:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/dcl list RAND MAX]] to [[Template:cpp/numeric/random/dsc RAND MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc macro const | cpp/numeric/random/RAND_MAX | maximum possible value generated by {{lc|std::rand}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc generate canonical</title>
    <ns>10</ns>
    <id>4747</id>
    <revision>
      <id>58906</id>
      <parentid>54173</parentid>
      <timestamp>2013-06-01T06:23:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/dcl list generate canonical]] to [[Template:cpp/numeric/random/dsc generate canonical]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tfun | cpp/numeric/random/generate_canonical | evenly distributes real values of given precision across [0, 1) | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc knuth b</title>
    <ns>10</ns>
    <id>12812</id>
    <revision>
      <id>63190</id>
      <timestamp>2013-07-05T15:59:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="77">{{dsc | {{tt|knuth_b}} | {{c|std::shuffle_order_engine&lt;minstd_rand0, 256&gt;}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc minstd rand</title>
    <ns>10</ns>
    <id>12805</id>
    <revision>
      <id>63886</id>
      <parentid>63183</parentid>
      <timestamp>2013-07-30T14:40:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>desc</comment>
      <text xml:space="preserve" bytes="187">{{dsc | {{tt|minstd_rand}} | {{c|std::linear_congruential_engine&lt;uint_fast32_t, 48271, 0, 2147483647&gt;}}&lt;br&gt;
Newer &quot;Minimum standard&quot;, recommended by Park, Miller, and Stockmeyer in 1993}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc minstd rand0</title>
    <ns>10</ns>
    <id>12804</id>
    <revision>
      <id>65362</id>
      <parentid>63885</parentid>
      <timestamp>2013-09-10T16:20:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="217">{{dsc | {{tt|minstd_rand0}} | {{c|std::linear_congruential_engine&lt;uint_fast32_t, 16807, 0, 2147483647&gt;}}&lt;br&gt;
Discovered in 1969 by Lewis, Goodman and Miller, adopted as &quot;Minimal standard&quot; in 1988 by Park and Miller }}</text>
      <sha1>6adfjlxa44z4jwn56p8ap2af0hevdiu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc mt19937</title>
    <ns>10</ns>
    <id>12806</id>
    <revision>
      <id>63887</id>
      <parentid>63184</parentid>
      <timestamp>2013-07-30T14:41:46Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>desc</comment>
      <text xml:space="preserve" bytes="355">{{dsc | {{tt|mt19937}} | {{c|std::mersenne_twister_engine&lt;std::uint_fast32_t, 32, 624, 397, 31, 
                             0x9908b0df, 11, 
                             0xffffffff, 7, 
                             0x9d2c5680, 15, 
                             0xefc60000, 18, 1812433253&gt;}}&lt;br&gt;
32-bit Mersenne Twister by Matsumoto and Nishimura, 1998}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc mt19937 64</title>
    <ns>10</ns>
    <id>12807</id>
    <revision>
      <id>63888</id>
      <parentid>63185</parentid>
      <timestamp>2013-07-30T14:52:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>desc</comment>
      <text xml:space="preserve" bytes="391">{{dsc | {{tt|mt19937_64}} | {{c|std::mersenne_twister_engine&lt;uint_fast64_t, 64, 312, 156, 31,
                             0xb5026f5aa96619e9, 29,
                             0x5555555555555555, 17,
                             0x71d67fffeda60000, 37,
                             0xfff7eee000000000, 43, 6364136223846793005&gt;}}&lt;br&gt;
64-bit Mersenne Twister by Matsumoto and Nishimura, 2000}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc rand</title>
    <ns>10</ns>
    <id>2035</id>
    <revision>
      <id>58910</id>
      <parentid>54174</parentid>
      <timestamp>2013-06-01T06:23:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/dcl list rand]] to [[Template:cpp/numeric/random/dsc rand]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/numeric/random/rand | generates a pseudo-random number }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc random device</title>
    <ns>10</ns>
    <id>13723</id>
    <revision>
      <id>72303</id>
      <timestamp>2014-08-06T19:58:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="123">{{dsc class | cpp/numeric/random/random_device | non-deterministic random number generator using hardware entropy source }}</text>
      <sha1>axdf7n4qpqj3xhduij9uh6h5sxxgvla</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc ranlux24</title>
    <ns>10</ns>
    <id>12810</id>
    <revision>
      <id>63889</id>
      <parentid>63188</parentid>
      <timestamp>2013-07-30T15:02:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>desc</comment>
      <text xml:space="preserve" bytes="151">{{dsc | {{tt|ranlux24}} | {{c|std::discard_block_engine&lt;ranlux24_base, 223, 23&gt;}}&lt;br&gt;
24-bit RANLUX generator by Martin Lüscher and Fred James, 1994}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc ranlux24 base</title>
    <ns>10</ns>
    <id>12808</id>
    <revision>
      <id>63186</id>
      <timestamp>2013-07-05T15:59:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="97">{{dsc | {{tt|ranlux24_base}} | {{c|std::subtract_with_carry_engine&lt;uint_fast32_t, 24, 10, 24&gt;}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc ranlux48</title>
    <ns>10</ns>
    <id>12811</id>
    <revision>
      <id>63890</id>
      <parentid>63189</parentid>
      <timestamp>2013-07-30T15:02:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>desc</comment>
      <text xml:space="preserve" bytes="151">{{dsc | {{tt|ranlux48}} | {{c|std::discard_block_engine&lt;ranlux48_base, 389, 11&gt;}}&lt;br&gt;
48-bit RANLUX generator by Martin Lüscher and Fred James, 1994}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc ranlux48 base</title>
    <ns>10</ns>
    <id>12809</id>
    <revision>
      <id>63187</id>
      <timestamp>2013-07-05T15:59:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="96">{{dsc | {{tt|ranlux48_base}} | {{c|std::subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc srand</title>
    <ns>10</ns>
    <id>2034</id>
    <revision>
      <id>58914</id>
      <parentid>54177</parentid>
      <timestamp>2013-06-01T06:23:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/dcl list srand]] to [[Template:cpp/numeric/random/dsc srand]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | cpp/numeric/random/srand | seeds pseudo-random number generator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc uniform int distribution</title>
    <ns>10</ns>
    <id>12974</id>
    <revision>
      <id>65360</id>
      <timestamp>2013-09-10T16:19:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="143">{{dsc tclass | cpp/numeric/random/uniform_int_distribution | produces integer values evenly distributed across a range | notes={{mark c++11}}}}</text>
      <sha1>b022zpc7zh9ri4hjkwspbs569jg0qcw</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/dsc uniform real distribution</title>
    <ns>10</ns>
    <id>4746</id>
    <revision>
      <id>58920</id>
      <parentid>54178</parentid>
      <timestamp>2013-06-01T06:23:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/dcl list uniform real distribution]] to [[Template:cpp/numeric/random/dsc uniform real distribution]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tclass | cpp/numeric/random/uniform_real_distribution | produces real values evenly distributed across a range | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/constructor</title>
    <ns>10</ns>
    <id>3902</id>
    <revision>
      <id>63602</id>
      <parentid>60909</parentid>
      <timestamp>2013-07-10T01:45:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="673">{{cpp/numeric/random/{{{1|}}}/title|{{{1}}}}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
explicit {{{1}}}( result_type value = default_seed );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Sseq &gt; 
explicit {{{1}}}( Sseq&amp; s );
}}
{{dcl end}}

Constructs the pseudo-random number engine.

{{todo}}

===Parameters===
{{par begin}}
{{par | value | seed value to use in the initialization of the internal state}}
{{par | s | seed sequence to use in the initialization of the internal state}}
{{par end}}

===Complexity===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc seed | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/discard</title>
    <ns>10</ns>
    <id>3906</id>
    <revision>
      <id>64311</id>
      <parentid>63603</parentid>
      <timestamp>2013-08-15T16:33:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="592">{{cpp/numeric/random/{{{1|}}}/title|discard}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
void discard( unsigned long long z );
}}
{{dcl end}}

Advances the internal state by {{tt|z}} times. Equivalent to calling {{lc|operator()}} {{tt|z}} times and discarding the result

===Parameters===
{{par begin}}
{{par | z | integer value specifying the number of times to advance the state by}}
{{par end}}

===Return value===
(none)

===Complexity===
{{todo}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc operator()|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc constructor</title>
    <ns>10</ns>
    <id>3690</id>
    <revision>
      <id>58969</id>
      <parentid>54211</parentid>
      <timestamp>2013-06-01T06:24:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list constructor]] to [[Template:cpp/numeric/random/engine/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem ctor | cpp/numeric/random/{{{1|}}}/{{{1|}}} | constructs the engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc discard</title>
    <ns>10</ns>
    <id>3693</id>
    <revision>
      <id>58974</id>
      <parentid>54214</parentid>
      <timestamp>2013-06-01T06:24:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list discard]] to [[Template:cpp/numeric/random/engine/dsc discard]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/discard | advances the engine's state by a specified amount}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc max</title>
    <ns>10</ns>
    <id>3694</id>
    <revision>
      <id>58979</id>
      <parentid>54215</parentid>
      <timestamp>2013-06-01T06:24:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list max]] to [[Template:cpp/numeric/random/engine/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc mem sfun | cpp/numeric/random/{{{1|}}}/max | gets the largest possible value in the output range}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc min</title>
    <ns>10</ns>
    <id>3697</id>
    <revision>
      <id>58984</id>
      <parentid>54218</parentid>
      <timestamp>2013-06-01T06:25:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list min]] to [[Template:cpp/numeric/random/engine/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem sfun | cpp/numeric/random/{{{1|}}}/min | gets the smallest possible value in the output range}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc operator()</title>
    <ns>10</ns>
    <id>3692</id>
    <revision>
      <id>58989</id>
      <parentid>54219</parentid>
      <timestamp>2013-06-01T06:25:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list operator()]] to [[Template:cpp/numeric/random/engine/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/operator() | advances the engine's state and returns the generated value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc operator cmp</title>
    <ns>10</ns>
    <id>3696</id>
    <revision>
      <id>58993</id>
      <parentid>54220</parentid>
      <timestamp>2013-06-01T06:25:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list operator cmp]] to [[Template:cpp/numeric/random/engine/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_cmp | title=operator{{==}}&lt;br&gt;operator!{{=}} | compares the internal states of two pseudo-random number engines }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>3695</id>
    <revision>
      <id>58998</id>
      <parentid>54223</parentid>
      <timestamp>2013-06-01T06:25:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list operator ltltgtgt]] to [[Template:cpp/numeric/random/engine/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc fun | cpp/numeric/random/{{{1|}}}/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output on pseudo-random number engine }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/dsc seed</title>
    <ns>10</ns>
    <id>3691</id>
    <revision>
      <id>59002</id>
      <parentid>54224</parentid>
      <timestamp>2013-06-01T06:25:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/engine/dcl list seed]] to [[Template:cpp/numeric/random/engine/dsc seed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/numeric/random/{{{1|}}}/seed | sets the current state of the engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/max</title>
    <ns>10</ns>
    <id>3908</id>
    <revision>
      <id>63604</id>
      <parentid>60911</parentid>
      <timestamp>2013-07-10T01:45:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="460">{{cpp/numeric/random/{{{1|}}}/title|max}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
static constexpr result_type max();
}}
{{dcl end}}

Returns the maximum value potentially generated by the random-number engine.

===Parameters===
(none)

===Return value===
The maximum potentially generated value.

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc min|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/min</title>
    <ns>10</ns>
    <id>3907</id>
    <revision>
      <id>69467</id>
      <parentid>63605</parentid>
      <timestamp>2014-04-10T15:52:59Z</timestamp>
      <contributor>
        <ip>134.95.9.159</ip>
      </contributor>
      <text xml:space="preserve" bytes="460">{{cpp/numeric/random/{{{1|}}}/title|min}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 | 1=
static constexpr result_type min();
}}
{{dcl end}}

Returns the minimum value potentially generated by the random-number engine.

===Parameters===
(none)

===Return value===
The minimum potentially generated value.

===Complexity===
Constant

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc max|{{{1|}}}}}
{{dsc end}}</text>
      <sha1>9qxzhkaasn6xa3bldtk7bf463xvk9nc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/operator()</title>
    <ns>10</ns>
    <id>3905</id>
    <revision>
      <id>62238</id>
      <parentid>60913</parentid>
      <timestamp>2013-06-25T12:34:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="501">{{cpp/numeric/random/{{{1|}}}/title|operator()}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
result_type operator()();
}}
{{dcl end}}

Generates a pseudo-random value. The state of the engine is advanced by one position.

{{todo}}

===Parameters===
(none)

===Return value===
A pseudo-random number in [{{c|min()}}, {{c|max()}}].

===Complexity===
Amortized constant.

===See also===
{{dsc begin}}
{{dsc inc | cpp/numeric/random/engine/dsc discard|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/operator cmp</title>
    <ns>10</ns>
    <id>8817</id>
    <revision>
      <id>63606</id>
      <parentid>54233</parentid>
      <timestamp>2013-07-10T01:45:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="1001">{{title|1=operator==,!=&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{cpp/numeric/random/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; {{#var:types}} &gt;
bool operator==( const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; lhs,
                 const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; rhs );
}}
{{dcl end}}

Compares two pseudo-random number engines. Two engines are equal, if their internal states are equivalent, that is, if they would generate equivalent values for any number of calls of {{c|operator()}}.

===Parameters===
{{par begin}}
{{par | lhs, rhs | engines to compare}}
{{par end}}

===Return value===
@1@ {{c|true}} if the engines are equivalent, {{c|false}} otherwise.
@2@ {{c|true}} if the engines are not equivalent, {{c|false}} otherwise.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/operator ltltgtgt</title>
    <ns>10</ns>
    <id>4542</id>
    <revision>
      <id>63607</id>
      <parentid>54236</parentid>
      <timestamp>2013-07-10T01:45:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="2161">{{title |operator&lt;&lt;,&gt;&gt;&lt;small&gt;(std::{{{1}}})&lt;/small&gt;}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{cpp/numeric/random/get_types|{{{1|}}}}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
template&lt; class CharT, class Traits, class ResultType,
          {{#var:types}} &gt;
std::basic_ostream&lt;CharT,Traits&gt;&amp; 
    operator&lt;&lt;( std::basic_ostream&lt;CharT,Traits&gt;&amp; ost, 
                const {{{1}}}&lt;{{#var:types_short}}&gt;&amp; e );
}}
{{dcl | num=2 | since=c++11 | 1=
template&lt; class CharT, class Traits, class ResultType,
          {{#var:types}} &gt;
std::basic_istream&lt;CharT,Traits&gt;&amp; 
    operator&gt;&gt;( std::basic_istream&lt;CharT,Traits&gt;&amp; ist, 
                {{{1}}}&lt;{{#var:types_short}}&gt;&amp; e );
}}
{{dcl end}}

@1@ Serializes the internal state of the pseudo-random number engine {{tt|e}} as a sequence of decimal numbers separated by one or more spaces, and inserts it to the stream {{tt|ost}}. The fill character and the formatting flags of the stream are ignored and unaffected.

@2@ Restores the internal state of the pseudo-random number engine {{tt|e}} from the serialized representation, which was created by an earlier call to {{tt|operator&lt;&lt;}} using a stream with the same imbued locale and the same {{tt|CharT}} and {{tt|Traits}}. If the input cannot be deserialized, {{tt|e}} is left unchanged and {{tt|failbit}} is raised on {{tt|ist}}

If a textual representation is written using {{c|os &lt;&lt; x}} and that representation is restored into the same or a different object {{tt|y}} of the same type using {{c|is &gt;&gt; y}}, then {{c|1=x==y}}.

The textual representation is written with {{c|os.''fmtflags''}} set to {{c|ios_base::dec}}|{{c|ios_base::left}} and the fill character set to the space character.  The textual representation of the engine's internal state is a set of decimal numbers separated by spaces.

===Parameters===
{{par begin}}
{{par | ost | output stream to insert the data to}}
{{par | ist | input stream to extract the data from}}
{{par | e | pseudo-random number engine}}
{{par end}}

===Return value===
@1@ {{tt|ost}}
@2@ {{tt|ist}}

===Complexity===
{{todo}}

===Exceptions===
@1@ (none)
@2@ May throw {{c|std::ios::failure}} when setting {{tt|failbit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/engine/seed</title>
    <ns>10</ns>
    <id>3904</id>
    <revision>
      <id>63608</id>
      <parentid>54239</parentid>
      <timestamp>2013-07-10T01:45:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="622">{{cpp/numeric/random/{{{1|}}}/title|seed}}
{{cpp/numeric/random/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 | 1=
void seed( result_type value = default_seed );
}}
{{dcl | num=2 | since=c++11 |
template&lt; class Sseq &gt; 
void seed( Sseq&amp; seq );
}}
{{dcl end}}

Reinitializes the internal state of the random-number engine using new seed value.

{{todo}}

===Parameters===
{{par begin}}
{{par | value | seed value to use in the initialization of the internal state}}
{{par | seq | seed sequence to use in the initialization of the internal state}}
{{par end}}

===Exceptions===
(none)

===Complexity===
{{todo}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/exponential distribution/dsc lambda</title>
    <ns>10</ns>
    <id>5152</id>
    <revision>
      <id>59006</id>
      <parentid>54240</parentid>
      <timestamp>2013-06-01T06:25:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/exponential distribution/dcl list lambda]] to [[Template:cpp/numeric/random/exponential distribution/dsc lambda]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc mem fun | cpp/numeric/random/exponential_distribution/lambda | returns the ''lambda'' distribution parameter (rate of events) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/exponential distribution/navbar</title>
    <ns>10</ns>
    <id>3935</id>
    <revision>
      <id>39986</id>
      <parentid>36051</parentid>
      <timestamp>2012-09-28T20:18:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="388">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/exponential_distribution/navbar heading
|content4 = cpp/numeric/random/exponential_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/exponential distribution/navbar content</title>
    <ns>10</ns>
    <id>4292</id>
    <revision>
      <id>54243</id>
      <parentid>35838</parentid>
      <timestamp>2013-06-01T05:10:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="825">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/exponential_distribution}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/lambda}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/param}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/min}}
{{nv mem ln | cpp/numeric/random/exponential_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/exponential_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/exponential_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/exponential distribution/navbar heading</title>
    <ns>10</ns>
    <id>3955</id>
    <revision>
      <id>48058</id>
      <parentid>34627</parentid>
      <timestamp>2013-05-18T18:03:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="81">{{ltt|cpp/numeric/random/exponential_distribution|std::exponential_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/exponential distribution/title</title>
    <ns>10</ns>
    <id>3996</id>
    <revision>
      <id>14742</id>
      <timestamp>2011-11-27T14:10:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/title | n=exponential_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/extreme value distribution/navbar</title>
    <ns>10</ns>
    <id>3938</id>
    <revision>
      <id>39987</id>
      <parentid>36052</parentid>
      <timestamp>2012-09-28T20:18:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="392">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/extreme_value_distribution/navbar heading
|content4 = cpp/numeric/random/extreme_value_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/extreme value distribution/navbar content</title>
    <ns>10</ns>
    <id>4295</id>
    <revision>
      <id>61137</id>
      <parentid>54250</parentid>
      <timestamp>2013-06-05T12:17:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge a and b</comment>
      <text xml:space="preserve" bytes="853">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/extreme_value_distribution}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/params | a | b}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/param}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/min}}
{{nv mem ln | cpp/numeric/random/extreme_value_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/extreme_value_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/extreme_value_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/extreme value distribution/navbar heading</title>
    <ns>10</ns>
    <id>3950</id>
    <revision>
      <id>48053</id>
      <parentid>35839</parentid>
      <timestamp>2013-05-18T18:02:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="85">{{ltt|cpp/numeric/random/extreme_value_distribution|std::extreme_value_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/extreme value distribution/title</title>
    <ns>10</ns>
    <id>3993</id>
    <revision>
      <id>14739</id>
      <timestamp>2011-11-27T14:10:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="123">&lt;onlyinclude&gt;{{cpp/title | n=extreme_value_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/fisher f distribution/navbar</title>
    <ns>10</ns>
    <id>3943</id>
    <revision>
      <id>39988</id>
      <parentid>36064</parentid>
      <timestamp>2012-09-28T20:18:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="382">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/fisher_f_distribution/navbar heading
|content4 = cpp/numeric/random/fisher_f_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/fisher f distribution/navbar content</title>
    <ns>10</ns>
    <id>4300</id>
    <revision>
      <id>61118</id>
      <parentid>54257</parentid>
      <timestamp>2013-06-05T11:47:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="803">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/fisher_f_distribution}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/params | m | n}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/param}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/min}}
{{nv mem ln | cpp/numeric/random/fisher_f_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/fisher_f_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/fisher_f_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/fisher f distribution/navbar heading</title>
    <ns>10</ns>
    <id>3961</id>
    <revision>
      <id>48064</id>
      <parentid>35842</parentid>
      <timestamp>2013-05-18T18:04:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="75">{{ltt|cpp/numeric/random/fisher_f_distribution|std::fisher_f_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/fisher f distribution/title</title>
    <ns>10</ns>
    <id>3988</id>
    <revision>
      <id>14734</id>
      <timestamp>2011-11-27T14:10:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">&lt;onlyinclude&gt;{{cpp/title | n=fisher_f_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/gamma distribution/navbar</title>
    <ns>10</ns>
    <id>3936</id>
    <revision>
      <id>39989</id>
      <parentid>36063</parentid>
      <timestamp>2012-09-28T20:18:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="376">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/gamma_distribution/navbar heading
|content4 = cpp/numeric/random/gamma_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/gamma distribution/navbar content</title>
    <ns>10</ns>
    <id>4293</id>
    <revision>
      <id>61142</id>
      <parentid>61115</parentid>
      <timestamp>2013-06-05T12:19:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="780">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/gamma_distribution}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/params | alpha | beta}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/param}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/min}}
{{nv mem ln | cpp/numeric/random/gamma_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/gamma_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/gamma_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/gamma distribution/navbar heading</title>
    <ns>10</ns>
    <id>3956</id>
    <revision>
      <id>48059</id>
      <parentid>35844</parentid>
      <timestamp>2013-05-18T18:03:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="69">{{ltt|cpp/numeric/random/gamma_distribution|std::gamma_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/gamma distribution/title</title>
    <ns>10</ns>
    <id>3995</id>
    <revision>
      <id>14741</id>
      <timestamp>2011-11-27T14:10:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=gamma_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/geometric distribution/dsc p</title>
    <ns>10</ns>
    <id>5146</id>
    <revision>
      <id>59038</id>
      <parentid>54265</parentid>
      <timestamp>2013-06-01T06:25:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/geometric distribution/dcl list p]] to [[Template:cpp/numeric/random/geometric distribution/dsc p]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc mem fun | cpp/numeric/random/geometric_distribution/p | returns the ''p'' distribution parameter (probability of a trial generating {{c|true}}) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/geometric distribution/navbar</title>
    <ns>10</ns>
    <id>3933</id>
    <revision>
      <id>39990</id>
      <parentid>36053</parentid>
      <timestamp>2012-09-28T20:18:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="384">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/geometric_distribution/navbar heading
|content4 = cpp/numeric/random/geometric_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/geometric distribution/navbar content</title>
    <ns>10</ns>
    <id>4290</id>
    <revision>
      <id>54266</id>
      <parentid>35846</parentid>
      <timestamp>2013-06-01T05:11:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="800">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/geometric_distribution}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/p}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/param}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/min}}
{{nv mem ln | cpp/numeric/random/geometric_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/geometric_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/geometric_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/geometric distribution/navbar heading</title>
    <ns>10</ns>
    <id>3953</id>
    <revision>
      <id>48056</id>
      <parentid>35847</parentid>
      <timestamp>2013-05-18T18:02:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="77">{{ltt|cpp/numeric/random/geometric_distribution|std::geometric_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/geometric distribution/title</title>
    <ns>10</ns>
    <id>3998</id>
    <revision>
      <id>14744</id>
      <timestamp>2011-11-27T14:10:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=geometric_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/get types</title>
    <ns>10</ns>
    <id>8818</id>
    <revision>
      <id>37221</id>
      <parentid>37220</parentid>
      <timestamp>2012-07-03T16:27:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>doc link</comment>
      <text xml:space="preserve" bytes="978">{{#vardefine:types|{{#switch:{{{1|}}}
 |linear_congruential_engine=class UIntType, UIntType a, UIntType c, UIntType m
 |mersenne_twister_engine=class UIntType,
          size_t w, size_t n, size_t m, size_t r,
          UIntType a, size_t u, UIntType d, size_t s,
          UIntType b, size_t t,
          UIntType c, size_t l, UIntType f
 |subtract_with_carry_engine=class UIntType, size_t w, size_t s, size_t r
 |discard_block_engine=class Engine, size_t p, size_t r
 |independent_bits_engine=class Engine, size_t w, class UIntType
 |shuffle_order_engine=class Engine, size_t p, size_t r
 |...
}}}}{{#vardefine:types_short|{{#switch:{{{1|}}}
 |linear_congruential_engine=UIntType,a,c,m
 |mersenne_twister_engine=UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f
 |subtract_with_carry_engine=UIntType,w,s,r
 |discard_block_engine=Engine,p,r
 |independent_bits_engine=Engine,w,UIntType
 |shuffle_order_engine=Engine,p,r
 |...
}}}}&lt;noinclude&gt;{{documentation|Template:get_types/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/independent bits engine/navbar</title>
    <ns>10</ns>
    <id>3708</id>
    <revision>
      <id>39991</id>
      <parentid>36062</parentid>
      <timestamp>2012-09-28T20:18:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="386">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/independent_bits_engine/navbar heading
|content4 = cpp/numeric/random/independent_bits_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/independent bits engine/navbar content</title>
    <ns>10</ns>
    <id>6476</id>
    <revision>
      <id>54267</id>
      <parentid>35321</parentid>
      <timestamp>2013-06-01T05:11:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="814">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/independent_bits_engine}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/seed}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/base}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/operator()}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/min}}
{{nv mem ln | cpp/numeric/random/independent_bits_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/independent_bits_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/independent_bits_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/independent bits engine/navbar heading</title>
    <ns>10</ns>
    <id>3714</id>
    <revision>
      <id>48048</id>
      <parentid>34628</parentid>
      <timestamp>2013-05-18T18:01:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="79">{{ltt|cpp/numeric/random/independent_bits_engine|std::independent_bits_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/independent bits engine/title</title>
    <ns>10</ns>
    <id>8826</id>
    <revision>
      <id>37232</id>
      <timestamp>2012-07-03T17:10:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/title | n=independent_bits_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/linear congruential engine/navbar</title>
    <ns>10</ns>
    <id>3704</id>
    <revision>
      <id>39992</id>
      <parentid>36060</parentid>
      <timestamp>2012-09-28T20:18:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="392">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/linear_congruential_engine/navbar heading
|content4 = cpp/numeric/random/linear_congruential_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/linear congruential engine/navbar content</title>
    <ns>10</ns>
    <id>6478</id>
    <revision>
      <id>54268</id>
      <parentid>35850</parentid>
      <timestamp>2013-06-01T05:11:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="777">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/linear_congruential_engine}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/seed}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/operator()}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/min}}
{{nv mem ln | cpp/numeric/random/linear_congruential_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/linear_congruential_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/linear congruential engine/navbar heading</title>
    <ns>10</ns>
    <id>3710</id>
    <revision>
      <id>48043</id>
      <parentid>35301</parentid>
      <timestamp>2013-05-18T18:00:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="85">{{ltt|cpp/numeric/random/linear_congruential_engine|std::linear_congruential_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/linear congruential engine/title</title>
    <ns>10</ns>
    <id>4245</id>
    <revision>
      <id>15361</id>
      <timestamp>2011-12-08T17:11:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="123">&lt;onlyinclude&gt;{{cpp/title | n=linear_congruential_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/lognormal distribution/navbar</title>
    <ns>10</ns>
    <id>3940</id>
    <revision>
      <id>39993</id>
      <parentid>36055</parentid>
      <timestamp>2012-09-28T20:18:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="384">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/lognormal_distribution/navbar heading
|content4 = cpp/numeric/random/lognormal_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/lognormal distribution/navbar content</title>
    <ns>10</ns>
    <id>4297</id>
    <revision>
      <id>61127</id>
      <parentid>54275</parentid>
      <timestamp>2013-06-05T12:11:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="813">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/lognormal_distribution}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/params | m | s}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/param}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/min}}
{{nv mem ln | cpp/numeric/random/lognormal_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/lognormal_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/lognormal_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/lognormal distribution/navbar heading</title>
    <ns>10</ns>
    <id>3959</id>
    <revision>
      <id>48062</id>
      <parentid>35851</parentid>
      <timestamp>2013-05-18T18:03:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="77">{{ltt|cpp/numeric/random/lognormal_distribution|std::lognormal_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/lognormal distribution/title</title>
    <ns>10</ns>
    <id>3991</id>
    <revision>
      <id>14737</id>
      <timestamp>2011-11-27T14:10:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=lognormal_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/mersenne twister engine/navbar</title>
    <ns>10</ns>
    <id>3705</id>
    <revision>
      <id>39994</id>
      <parentid>36054</parentid>
      <timestamp>2012-09-28T20:18:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="386">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/mersenne_twister_engine/navbar heading
|content4 = cpp/numeric/random/mersenne_twister_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/mersenne twister engine/navbar content</title>
    <ns>10</ns>
    <id>6477</id>
    <revision>
      <id>54276</id>
      <parentid>35729</parentid>
      <timestamp>2013-06-01T05:11:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="750">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/seed}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/operator()}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/min}}
{{nv mem ln | cpp/numeric/random/mersenne_twister_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/mersenne_twister_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/mersenne twister engine/navbar heading</title>
    <ns>10</ns>
    <id>3711</id>
    <revision>
      <id>48044</id>
      <parentid>35854</parentid>
      <timestamp>2013-05-18T18:00:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="79">{{ltt|cpp/numeric/random/mersenne_twister_engine|std::mersenne_twister_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/mersenne twister engine/title</title>
    <ns>10</ns>
    <id>4246</id>
    <revision>
      <id>15362</id>
      <timestamp>2011-12-08T17:11:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="120">&lt;onlyinclude&gt;{{cpp/title | n=mersenne_twister_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/navbar</title>
    <ns>10</ns>
    <id>2036</id>
    <revision>
      <id>39995</id>
      <parentid>35767</parentid>
      <timestamp>2012-09-28T20:18:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/navbar content</title>
    <ns>10</ns>
    <id>2702</id>
    <revision>
      <id>54279</id>
      <parentid>35868</parentid>
      <timestamp>2013-06-01T05:11:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2716">{{nv begin}}
{{nv h1 | Engines and engine adaptors}}
{{nv ln | cpp/numeric/random/linear_congruential_engine | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/random/mersenne_twister_engine| notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/subtract_with_carry_engine| notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/discard_block_engine| notes={{mark c++11}}}}
{{nv ln | cpp/numeric/random/independent_bits_engine| notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/shuffle_order_engine| notes={{mark c++11}} }}

{{nv h1 | Generators}}
{{nv ln | cpp/numeric/random/random_device | notes={{mark c++11}} }}

{{nv h1 | Distributions}}
{{nv h2 | Uniform distributions}}
{{nv ln | cpp/numeric/random/uniform_int_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/uniform_real_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/generate_canonical | notes={{mark c++11}} }}

{{nv h2 | Bernoulli distributions}}
{{nv ln | cpp/numeric/random/bernoulli_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/binomial_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/negative_binomial_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/geometric_distribution  | notes={{mark c++11}} }}

{{nv h2 | Poisson distributions}}
{{nv ln | cpp/numeric/random/poisson_distribution  | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/exponential_distribution  | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/gamma_distribution  | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/weibull_distribution  | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/extreme_value_distribution | notes={{mark c++11}} }}

{{nv h2 | Normal distributions}}
{{nv ln | cpp/numeric/random/normal_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/lognormal_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/chi_squared_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/cauchy_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/fisher_f_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/student_t_distribution | notes={{mark c++11}} }}

{{nv h2 | Sampling distributions}}
{{nv ln | cpp/numeric/random/discrete_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/piecewise_constant_distribution | notes={{mark c++11}} }}
{{nv ln | cpp/numeric/random/piecewise_linear_distribution | notes={{mark c++11}} }}

{{nv h1 | Seed Sequences}}
{{nv ln | cpp/numeric/random/seed_seq | notes={{mark c++11}} }}

{{nv h1 | C library}}
{{nv ln | cpp/numeric/random/rand }}
{{nv ln | cpp/numeric/random/srand }}
{{nv ln | cpp/numeric/random/RAND_MAX }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/navbar heading</title>
    <ns>10</ns>
    <id>2037</id>
    <revision>
      <id>33811</id>
      <parentid>4341</parentid>
      <timestamp>2012-06-15T20:50:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/sidebar heading]] to [[Template:cpp/numeric/random/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="54">[[cpp/numeric/random|Pseudo-random number generation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/negative binomial distribution/navbar</title>
    <ns>10</ns>
    <id>3932</id>
    <revision>
      <id>39996</id>
      <parentid>36056</parentid>
      <timestamp>2012-09-28T20:18:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="400">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/negative_binomial_distribution/navbar heading
|content4 = cpp/numeric/random/negative_binomial_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/negative binomial distribution/navbar content</title>
    <ns>10</ns>
    <id>4289</id>
    <revision>
      <id>61176</id>
      <parentid>54284</parentid>
      <timestamp>2013-06-05T12:25:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge p and k</comment>
      <text xml:space="preserve" bytes="893">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/negative_binomial_distribution}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/params | p | k}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/param}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/min}}
{{nv mem ln | cpp/numeric/random/negative_binomial_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/negative_binomial_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/negative_binomial_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/negative binomial distribution/navbar heading</title>
    <ns>10</ns>
    <id>3949</id>
    <revision>
      <id>48052</id>
      <parentid>35856</parentid>
      <timestamp>2013-05-18T18:02:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="93">{{ltt|cpp/numeric/random/negative_binomial_distribution|std::negative_binomial_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/negative binomial distribution/title</title>
    <ns>10</ns>
    <id>3999</id>
    <revision>
      <id>14745</id>
      <timestamp>2011-11-27T14:10:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="127">&lt;onlyinclude&gt;{{cpp/title | n=negative_binomial_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/normal distribution/navbar</title>
    <ns>10</ns>
    <id>3939</id>
    <revision>
      <id>39997</id>
      <parentid>36061</parentid>
      <timestamp>2012-09-28T20:18:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="378">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/normal_distribution/navbar heading
|content4 = cpp/numeric/random/normal_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/normal distribution/navbar content</title>
    <ns>10</ns>
    <id>4296</id>
    <revision>
      <id>61135</id>
      <parentid>54289</parentid>
      <timestamp>2013-06-05T12:15:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge mean and stddev</comment>
      <text xml:space="preserve" bytes="791">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/normal_distribution/normal_distribution}}
{{nv mem ln | cpp/numeric/random/normal_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/normal_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/normal_distribution/params | mean | stddev}}
{{nv mem ln | cpp/numeric/random/normal_distribution/param}}
{{nv mem ln | cpp/numeric/random/normal_distribution/min}}
{{nv mem ln | cpp/numeric/random/normal_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/normal_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/normal_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/normal distribution/navbar heading</title>
    <ns>10</ns>
    <id>3958</id>
    <revision>
      <id>48061</id>
      <parentid>35682</parentid>
      <timestamp>2013-05-18T18:03:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use simple ltt</comment>
      <text xml:space="preserve" bytes="71">{{ltt|cpp/numeric/random/normal_distribution|std::normal_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/normal distribution/title</title>
    <ns>10</ns>
    <id>3992</id>
    <revision>
      <id>14738</id>
      <timestamp>2011-11-27T14:10:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>=</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=normal_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise constant distribution/dsc params</title>
    <ns>10</ns>
    <id>4968</id>
    <revision>
      <id>61098</id>
      <parentid>61097</parentid>
      <timestamp>2013-06-05T11:17:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="146">{{dsc mem fun | cpp/numeric/random/piecewise_constant_distribution/params | title=intervals&lt;br/&gt;densities | returns the distribution parameters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise constant distribution/navbar</title>
    <ns>10</ns>
    <id>3946</id>
    <revision>
      <id>39998</id>
      <parentid>36059</parentid>
      <timestamp>2012-09-28T20:18:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="402">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/piecewise_constant_distribution/navbar heading
|content4 = cpp/numeric/random/piecewise_constant_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise constant distribution/navbar content</title>
    <ns>10</ns>
    <id>4303</id>
    <revision>
      <id>61095</id>
      <parentid>54298</parentid>
      <timestamp>2013-06-05T11:16:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge intervals and densitios</comment>
      <text xml:space="preserve" bytes="919">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/piecewise_constant_distribution}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/params | intervals | densities}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/param}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/min}}
{{nv mem ln | cpp/numeric/random/piecewise_constant_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/piecewise_constant_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/piecewise_constant_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise constant distribution/navbar heading</title>
    <ns>10</ns>
    <id>3964</id>
    <revision>
      <id>48067</id>
      <parentid>35385</parentid>
      <timestamp>2013-05-18T18:04:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="95">{{ltt|cpp/numeric/random/piecewise_constant_distribution|std::piecewise_constant_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise constant distribution/title</title>
    <ns>10</ns>
    <id>3984</id>
    <revision>
      <id>14730</id>
      <timestamp>2011-11-27T14:08:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="128">&lt;onlyinclude&gt;{{cpp/title | n=piecewise_constant_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise linear distribution/dsc params</title>
    <ns>10</ns>
    <id>4971</id>
    <revision>
      <id>61108</id>
      <parentid>61107</parentid>
      <timestamp>2013-06-05T11:27:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="144">{{dsc mem fun | cpp/numeric/random/piecewise_linear_distribution/params | title=intervals&lt;br/&gt;densities | returns the distribution parameters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise linear distribution/navbar</title>
    <ns>10</ns>
    <id>3947</id>
    <revision>
      <id>39999</id>
      <parentid>36058</parentid>
      <timestamp>2012-09-28T20:18:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="398">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/piecewise_linear_distribution/navbar heading
|content4 = cpp/numeric/random/piecewise_linear_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise linear distribution/navbar content</title>
    <ns>10</ns>
    <id>4304</id>
    <revision>
      <id>61106</id>
      <parentid>54306</parentid>
      <timestamp>2013-06-05T11:26:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="899">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/piecewise_linear_distribution}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/params | intervals | densities}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/param}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/min}}
{{nv mem ln | cpp/numeric/random/piecewise_linear_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/piecewise_linear_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/piecewise_linear_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise linear distribution/navbar heading</title>
    <ns>10</ns>
    <id>3965</id>
    <revision>
      <id>48068</id>
      <parentid>35857</parentid>
      <timestamp>2013-05-18T18:04:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="91">{{ltt|cpp/numeric/random/piecewise_linear_distribution|std::piecewise_linear_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/piecewise linear distribution/title</title>
    <ns>10</ns>
    <id>3985</id>
    <revision>
      <id>14731</id>
      <timestamp>2011-11-27T14:08:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="126">&lt;onlyinclude&gt;{{cpp/title | n=piecewise_linear_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/poisson distribution/dsc mean</title>
    <ns>10</ns>
    <id>5150</id>
    <revision>
      <id>59082</id>
      <parentid>54307</parentid>
      <timestamp>2013-06-01T06:26:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/poisson distribution/dcl list mean]] to [[Template:cpp/numeric/random/poisson distribution/dsc mean]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc mem fun | cpp/numeric/random/poisson_distribution/mean | returns the ''mean'' distribution parameter (mean number of occurrences of the event) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/poisson distribution/navbar</title>
    <ns>10</ns>
    <id>3934</id>
    <revision>
      <id>40000</id>
      <parentid>36057</parentid>
      <timestamp>2012-09-28T20:18:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="380">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/poisson_distribution/navbar heading
|content4 = cpp/numeric/random/poisson_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/poisson distribution/navbar content</title>
    <ns>10</ns>
    <id>4291</id>
    <revision>
      <id>54310</id>
      <parentid>35387</parentid>
      <timestamp>2013-06-01T05:11:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="783">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/poisson_distribution}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/mean}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/param}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/min}}
{{nv mem ln | cpp/numeric/random/poisson_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/poisson_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/poisson_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/poisson distribution/navbar heading</title>
    <ns>10</ns>
    <id>3954</id>
    <revision>
      <id>48057</id>
      <parentid>35862</parentid>
      <timestamp>2013-05-18T18:02:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/numeric/random/poisson_distribution|std::poisson_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/poisson distribution/title</title>
    <ns>10</ns>
    <id>3997</id>
    <revision>
      <id>14743</id>
      <timestamp>2011-11-27T14:10:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=poisson_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=poisson_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/random device/dsc entropy</title>
    <ns>10</ns>
    <id>4973</id>
    <revision>
      <id>59087</id>
      <parentid>54311</parentid>
      <timestamp>2013-06-01T06:26:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/random device/dcl list entropy]] to [[Template:cpp/numeric/random/random device/dsc entropy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc mem fun | cpp/numeric/random/random_device/entropy | obtains the entropy estimate for the non-deterministic random number generator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/random device/navbar</title>
    <ns>10</ns>
    <id>4975</id>
    <revision>
      <id>40001</id>
      <parentid>36047</parentid>
      <timestamp>2012-09-28T20:18:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="366">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/random_device/navbar heading
|content4 = cpp/numeric/random/random_device/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/random device/navbar content</title>
    <ns>10</ns>
    <id>4977</id>
    <revision>
      <id>54312</id>
      <parentid>33416</parentid>
      <timestamp>2013-06-01T05:11:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="391">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/random_device/random_device}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/random_device/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/random_device/entropy}}
{{nv mem ln | cpp/numeric/random/random_device/min}}
{{nv mem ln | cpp/numeric/random/random_device/max}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/random device/navbar heading</title>
    <ns>10</ns>
    <id>4976</id>
    <revision>
      <id>48100</id>
      <parentid>35865</parentid>
      <timestamp>2013-05-18T18:12:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="59">{{ltt|cpp/numeric/random/random_device|std::random_device}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/random device/title</title>
    <ns>10</ns>
    <id>4979</id>
    <revision>
      <id>17906</id>
      <timestamp>2012-01-19T20:29:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=random_device::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/seed seq/navbar</title>
    <ns>10</ns>
    <id>8898</id>
    <revision>
      <id>40002</id>
      <parentid>37543</parentid>
      <timestamp>2012-09-28T20:18:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="356">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/seed_seq/navbar heading
|content4 = cpp/numeric/random/seed_seq/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/seed seq/navbar content</title>
    <ns>10</ns>
    <id>8900</id>
    <revision>
      <id>54313</id>
      <parentid>37545</parentid>
      <timestamp>2013-06-01T05:11:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="257">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/seed_seq/seed_seq}}
{{nv mem ln | cpp/numeric/random/seed_seq/generate}}
{{nv mem ln | cpp/numeric/random/seed_seq/size}}
{{nv mem ln | cpp/numeric/random/seed_seq/param}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/seed seq/navbar heading</title>
    <ns>10</ns>
    <id>8899</id>
    <revision>
      <id>48023</id>
      <parentid>37544</parentid>
      <timestamp>2013-05-18T17:54:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="49">{{ltt|cpp/numeric/random/seed_seq|std::seed_seq}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/seed seq/title</title>
    <ns>10</ns>
    <id>8939</id>
    <revision>
      <id>37665</id>
      <timestamp>2012-07-17T16:23:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=seed_seq::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/shuffle order engine/navbar</title>
    <ns>10</ns>
    <id>3709</id>
    <revision>
      <id>40003</id>
      <parentid>36046</parentid>
      <timestamp>2012-09-28T20:18:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="380">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/shuffle_order_engine/navbar heading
|content4 = cpp/numeric/random/shuffle_order_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/shuffle order engine/navbar content</title>
    <ns>10</ns>
    <id>6475</id>
    <revision>
      <id>54314</id>
      <parentid>35657</parentid>
      <timestamp>2013-06-01T05:11:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="784">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/shuffle_order_engine}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/seed}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/base}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/operator()}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/min}}
{{nv mem ln | cpp/numeric/random/shuffle_order_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/shuffle_order_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/shuffle order engine/navbar heading</title>
    <ns>10</ns>
    <id>3715</id>
    <revision>
      <id>48049</id>
      <parentid>35867</parentid>
      <timestamp>2013-05-18T18:01:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/numeric/random/shuffle_order_engine|std::shuffle_order_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/shuffle order engine/title</title>
    <ns>10</ns>
    <id>8827</id>
    <revision>
      <id>37233</id>
      <timestamp>2012-07-03T17:10:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=shuffle_order_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/student t distribution/dsc n</title>
    <ns>10</ns>
    <id>5157</id>
    <revision>
      <id>59092</id>
      <parentid>54315</parentid>
      <timestamp>2013-06-01T06:26:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/student t distribution/dcl list n]] to [[Template:cpp/numeric/random/student t distribution/dsc n]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem fun | cpp/numeric/random/student_t_distribution/n | returns the ''n'' distribution parameter (degrees of freedom) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/student t distribution/navbar</title>
    <ns>10</ns>
    <id>3944</id>
    <revision>
      <id>40004</id>
      <parentid>36045</parentid>
      <timestamp>2012-09-28T20:18:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="384">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/student_t_distribution/navbar heading
|content4 = cpp/numeric/random/student_t_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/student t distribution/navbar content</title>
    <ns>10</ns>
    <id>4301</id>
    <revision>
      <id>54316</id>
      <parentid>35870</parentid>
      <timestamp>2013-06-01T05:11:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="800">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/student_t_distribution}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/n}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/param}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/min}}
{{nv mem ln | cpp/numeric/random/student_t_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/student_t_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/student_t_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/student t distribution/navbar heading</title>
    <ns>10</ns>
    <id>3962</id>
    <revision>
      <id>48065</id>
      <parentid>35871</parentid>
      <timestamp>2013-05-18T18:04:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="77">{{ltt|cpp/numeric/random/student_t_distribution|std::student_t_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/student t distribution/title</title>
    <ns>10</ns>
    <id>3987</id>
    <revision>
      <id>14733</id>
      <timestamp>2011-11-27T14:10:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=student_t_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/subtract with carry engine/navbar</title>
    <ns>10</ns>
    <id>3706</id>
    <revision>
      <id>40005</id>
      <parentid>36044</parentid>
      <timestamp>2012-09-28T20:19:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="392">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/subtract_with_carry_engine/navbar heading
|content4 = cpp/numeric/random/subtract_with_carry_engine/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/subtract with carry engine/navbar content</title>
    <ns>10</ns>
    <id>6473</id>
    <revision>
      <id>54317</id>
      <parentid>35873</parentid>
      <timestamp>2013-06-01T05:11:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="777">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/seed}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/operator()}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/discard}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/min}}
{{nv mem ln | cpp/numeric/random/subtract_with_carry_engine/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/subtract_with_carry_engine/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/subtract with carry engine/navbar heading</title>
    <ns>10</ns>
    <id>3712</id>
    <revision>
      <id>48046</id>
      <parentid>48045</parentid>
      <timestamp>2013-05-18T18:00:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>+std::</comment>
      <text xml:space="preserve" bytes="85">{{ltt|cpp/numeric/random/subtract_with_carry_engine|std::subtract_with_carry_engine}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/subtract with carry engine/title</title>
    <ns>10</ns>
    <id>4247</id>
    <revision>
      <id>15363</id>
      <timestamp>2011-12-08T17:11:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="123">&lt;onlyinclude&gt;{{cpp/title | n=subtract_with_carry_engine::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform int distribution/navbar</title>
    <ns>10</ns>
    <id>3344</id>
    <revision>
      <id>40006</id>
      <parentid>36043</parentid>
      <timestamp>2012-09-28T20:19:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="388">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/uniform_int_distribution/navbar heading
|content4 = cpp/numeric/random/uniform_int_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform int distribution/navbar content</title>
    <ns>10</ns>
    <id>4287</id>
    <revision>
      <id>61144</id>
      <parentid>54322</parentid>
      <timestamp>2013-06-05T12:20:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge a and b</comment>
      <text xml:space="preserve" bytes="833">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/uniform_int_distribution}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/params | a | b}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/param}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/min}}
{{nv mem ln | cpp/numeric/random/uniform_int_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/uniform_int_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/uniform_int_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform int distribution/navbar heading</title>
    <ns>10</ns>
    <id>3346</id>
    <revision>
      <id>48034</id>
      <parentid>35876</parentid>
      <timestamp>2013-05-18T17:59:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="81">{{ltt|cpp/numeric/random/uniform_int_distribution|std::uniform_int_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform int distribution/title</title>
    <ns>10</ns>
    <id>3317</id>
    <revision>
      <id>12703</id>
      <parentid>12627</parentid>
      <timestamp>2011-10-30T02:28:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/random/distribution/uniform int distribution/title]] to [[Template:cpp/numeric/random/uniform int distribution/title]]</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/title | n=uniform_int_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform real distribution/navbar</title>
    <ns>10</ns>
    <id>3343</id>
    <revision>
      <id>40007</id>
      <parentid>36042</parentid>
      <timestamp>2012-09-28T20:19:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="390">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/uniform_real_distribution/navbar heading
|content4 = cpp/numeric/random/uniform_real_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform real distribution/navbar content</title>
    <ns>10</ns>
    <id>4288</id>
    <revision>
      <id>61147</id>
      <parentid>54331</parentid>
      <timestamp>2013-06-05T12:22:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge a and b</comment>
      <text xml:space="preserve" bytes="843">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/uniform_real_distribution}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/params | a | b}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/param}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/min}}
{{nv mem ln | cpp/numeric/random/uniform_real_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/uniform_real_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/uniform_real_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform real distribution/navbar heading</title>
    <ns>10</ns>
    <id>3345</id>
    <revision>
      <id>48033</id>
      <parentid>35879</parentid>
      <timestamp>2013-05-18T17:58:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="83">{{ltt|cpp/numeric/random/uniform_real_distribution|std::uniform_real_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/uniform real distribution/title</title>
    <ns>10</ns>
    <id>3335</id>
    <revision>
      <id>14627</id>
      <parentid>12706</parentid>
      <timestamp>2011-11-27T13:10:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="122">&lt;onlyinclude&gt;{{cpp/title | n=uniform_real_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/weibull distribution/navbar</title>
    <ns>10</ns>
    <id>3937</id>
    <revision>
      <id>40008</id>
      <parentid>36041</parentid>
      <timestamp>2012-09-28T20:19:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="380">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/random/navbar heading
|content3 = cpp/numeric/random/navbar content

|heading4 = cpp/numeric/random/weibull_distribution/navbar heading
|content4 = cpp/numeric/random/weibull_distribution/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/weibull distribution/navbar content</title>
    <ns>10</ns>
    <id>4294</id>
    <revision>
      <id>61139</id>
      <parentid>54340</parentid>
      <timestamp>2013-06-05T12:18:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>merge a and b</comment>
      <text xml:space="preserve" bytes="793">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/weibull_distribution}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/reset}}

{{nv h2 | Generation}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/operator()}}

{{nv h2 | Characteristics}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/params | a | b}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/param}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/min}}
{{nv mem ln | cpp/numeric/random/weibull_distribution/max}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/numeric/random/weibull_distribution/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv ln | cpp/numeric/random/weibull_distribution/operator_ltltgtgt | operator&lt;&lt; | operator&gt;&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/weibull distribution/navbar heading</title>
    <ns>10</ns>
    <id>3957</id>
    <revision>
      <id>48060</id>
      <parentid>35882</parentid>
      <timestamp>2013-05-18T18:03:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/numeric/random/weibull_distribution|std::weibull_distribution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/random/weibull distribution/title</title>
    <ns>10</ns>
    <id>3994</id>
    <revision>
      <id>14740</id>
      <timestamp>2011-11-27T14:10:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=weibull_distribution::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio add</title>
    <ns>10</ns>
    <id>4984</id>
    <revision>
      <id>59122</id>
      <parentid>54345</parentid>
      <timestamp>2013-06-01T06:27:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio add]] to [[Template:cpp/numeric/ratio/dsc ratio add]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc tclass | cpp/numeric/ratio/ratio_add | adds two {{tt|ratio}} objects at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio divide</title>
    <ns>10</ns>
    <id>4987</id>
    <revision>
      <id>59127</id>
      <parentid>54352</parentid>
      <timestamp>2013-06-01T06:27:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio divide]] to [[Template:cpp/numeric/ratio/dsc ratio divide]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tclass | cpp/numeric/ratio/ratio_divide | divides two {{tt|ratio}} objects at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio equal</title>
    <ns>10</ns>
    <id>4988</id>
    <revision>
      <id>59132</id>
      <parentid>54373</parentid>
      <timestamp>2013-06-01T06:27:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio equal]] to [[Template:cpp/numeric/ratio/dsc ratio equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc tclass | cpp/numeric/ratio/ratio_equal | compares two {{tt|ratio}} objects for equality at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio greater</title>
    <ns>10</ns>
    <id>4992</id>
    <revision>
      <id>59136</id>
      <parentid>54374</parentid>
      <timestamp>2013-06-01T06:27:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio greater]] to [[Template:cpp/numeric/ratio/dsc ratio greater]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc tclass | cpp/numeric/ratio/ratio_greater | compares two {{tt|ratio}} objects for ''greater than'' at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio greater equal</title>
    <ns>10</ns>
    <id>4993</id>
    <revision>
      <id>59140</id>
      <parentid>54377</parentid>
      <timestamp>2013-06-01T06:27:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio greater equal]] to [[Template:cpp/numeric/ratio/dsc ratio greater equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc tclass | cpp/numeric/ratio/ratio_greater_equal | compares two {{tt|ratio}} objects for ''greater than or equal to'' at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio less</title>
    <ns>10</ns>
    <id>4990</id>
    <revision>
      <id>59144</id>
      <parentid>54378</parentid>
      <timestamp>2013-06-01T06:27:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio less]] to [[Template:cpp/numeric/ratio/dsc ratio less]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc tclass | cpp/numeric/ratio/ratio_less | compares two {{tt|ratio}} objects for ''less than'' at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio less equal</title>
    <ns>10</ns>
    <id>4991</id>
    <revision>
      <id>59148</id>
      <parentid>54381</parentid>
      <timestamp>2013-06-01T06:27:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio less equal]] to [[Template:cpp/numeric/ratio/dsc ratio less equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tclass | cpp/numeric/ratio/ratio_less_equal | compares two {{tt|ratio}} objects for ''less than or equal to'' at compile-time| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio multiply</title>
    <ns>10</ns>
    <id>4986</id>
    <revision>
      <id>59152</id>
      <parentid>54382</parentid>
      <timestamp>2013-06-01T06:27:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio multiply]] to [[Template:cpp/numeric/ratio/dsc ratio multiply]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc tclass | cpp/numeric/ratio/ratio_multiply | multiplies two {{tt|ratio}} objects at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio not equal</title>
    <ns>10</ns>
    <id>4989</id>
    <revision>
      <id>59156</id>
      <parentid>54383</parentid>
      <timestamp>2013-06-01T06:27:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio not equal]] to [[Template:cpp/numeric/ratio/dsc ratio not equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tclass | cpp/numeric/ratio/ratio_not_equal | compares two {{tt|ratio}} objects for inequality at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/dsc ratio subtract</title>
    <ns>10</ns>
    <id>4985</id>
    <revision>
      <id>59160</id>
      <parentid>54384</parentid>
      <timestamp>2013-06-01T06:27:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/dcl list ratio subtract]] to [[Template:cpp/numeric/ratio/dsc ratio subtract]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc tclass | cpp/numeric/ratio/ratio_subtract | subtracts two {{tt|ratio}} objects at compile-time | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/navbar</title>
    <ns>10</ns>
    <id>3518</id>
    <revision>
      <id>40009</id>
      <parentid>35883</parentid>
      <timestamp>2012-09-28T20:19:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/ratio/navbar heading
|content3 = cpp/numeric/ratio/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/navbar content</title>
    <ns>10</ns>
    <id>2500</id>
    <revision>
      <id>54387</id>
      <parentid>35884</parentid>
      <timestamp>2013-06-01T05:12:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="801">{{nv begin}}
{{nv ln | cpp/numeric/ratio/ratio | notes={{mark c++11}}}}
{{nv h2 | Arithmetic}}
{{nv ln | cpp/numeric/ratio/ratio_add | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_subtract | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_multiply | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_divide | notes={{mark c++11}}}}
{{nv h2 | Comparison}}
{{nv ln | cpp/numeric/ratio/ratio_equal | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_not_equal | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_less | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_less_equal | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_greater | notes={{mark c++11}}}}
{{nv ln | cpp/numeric/ratio/ratio_greater_equal | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/ratio/navbar heading</title>
    <ns>10</ns>
    <id>2485</id>
    <revision>
      <id>35886</id>
      <parentid>13331</parentid>
      <timestamp>2012-06-15T22:34:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/ratio/sidebar heading]] to [[Template:cpp/numeric/ratio/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="56">[[cpp/numeric/ratio | Compile time rational arithmetic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray//navbar</title>
    <ns>10</ns>
    <id>12745</id>
    <redirect title="Template:cpp/numeric/valarray/navbar" />
    <revision>
      <id>61573</id>
      <timestamp>2013-06-06T04:32:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="50">#redirect [[Template:cpp/numeric/valarray/navbar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray//title</title>
    <ns>10</ns>
    <id>12742</id>
    <revision>
      <id>61566</id>
      <timestamp>2013-06-06T03:28:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/constructor</title>
    <ns>10</ns>
    <id>12741</id>
    <revision>
      <id>61565</id>
      <parentid>61564</parentid>
      <timestamp>2013-06-06T03:27:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="410">{{cpp/numeric/valarray/{{{1|}}}/title | {{{1}}}}}
{{cpp/numeric/valarray/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
{{{1}}}( const {{{1}}}&amp; other );
}}
{{dcl | 1=
{{{1}}}() = delete;
}}
{{dcl end}}

Constructs a {{tt|{{{1}}}}} from another {{tt|{{{1}}}}} {{tt|other}}. 

The default constructor is implicitly deleted.

===Parameters===
{{par begin}}
{{par | other | {{tt|{{{1}}}}} to initialize with}}
{{par end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/destructor</title>
    <ns>10</ns>
    <id>12740</id>
    <revision>
      <id>61574</id>
      <parentid>61563</parentid>
      <timestamp>2013-06-06T04:32:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="233">{{cpp/numeric/valarray/{{{1|}}}/title | ~{{{1}}}}}
{{cpp/numeric/valarray/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl |
~{{{1}}}();
}}
{{dcl end}}

Destroys the indexes in the array. The elements referred to by the object are not modified.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/dsc constructor</title>
    <ns>10</ns>
    <id>12705</id>
    <revision>
      <id>61520</id>
      <parentid>61513</parentid>
      <timestamp>2013-06-06T03:07:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/slice array/dsc constructor]] to [[Template:cpp/numeric/valarray/array/dsc constructor]]</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem ctor | cpp/numeric/valarray/{{{1|}}}/{{{1|}}} | constructs a {{tt|{{{1|}}}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/dsc destructor</title>
    <ns>10</ns>
    <id>12706</id>
    <revision>
      <id>61519</id>
      <parentid>61514</parentid>
      <timestamp>2013-06-06T03:07:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/slice array/dsc destructor]] to [[Template:cpp/numeric/valarray/array/dsc destructor]]</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem dtor | cpp/numeric/valarray/{{{1|}}}/~{{{1|}}} | destroys a {{tt|{{{1|}}}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/dsc operator=</title>
    <ns>10</ns>
    <id>12707</id>
    <revision>
      <id>61518</id>
      <parentid>61515</parentid>
      <timestamp>2013-06-06T03:07:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/slice array/dsc operator=]] to [[Template:cpp/numeric/valarray/array/dsc operator=]]</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/numeric/valarray/{{{1|}}}/operator{{=}} | assigns contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/dsc operator arith</title>
    <ns>10</ns>
    <id>12708</id>
    <revision>
      <id>61521</id>
      <parentid>61517</parentid>
      <timestamp>2013-06-06T03:09:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="399">{{dsc mem fun | cpp/numeric/valarray/{{{1|}}}/operator_arith | title=operator+=&lt;br/&gt;operator-=&lt;br/&gt;operator*=&lt;br/&gt;operator/=&lt;br/&gt;operator%=&lt;br/&gt;operator&amp;=&lt;br&gt;operator{{!}}=&lt;br/&gt;operator^=&lt;br/&gt;operator&lt;&lt;=&lt;br/&gt;operator&gt;&gt;= | performs arithmetic operation on the array referred by {{#switch:{{{1|}}}
| slice_array=slice
| gslice_array=generic slice
| mask_array=mask
| indirect_array=indirect array}}.}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/operator=</title>
    <ns>10</ns>
    <id>12743</id>
    <revision>
      <id>61570</id>
      <parentid>61569</parentid>
      <timestamp>2013-06-06T04:26:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1045">{{cpp/numeric/valarray/{{{1|}}}/title | operator{{=}}}}
{{cpp/numeric/valarray/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | 1=
void operator=( const T&amp; value ) const;
}}
{{dcl | num=2 | 1=
void operator=( const std::valarray&lt;T&gt;&amp; val_arr ) const;
}}
{{dcl | num=3 | since=c++11 | 1=
const {{{1}}}&amp; operator=( const {{{1}}}&amp; sl_arr) const;
}}
{{dcl end}}

Assigns values to all referred elements.

@1@ Assigns {{tt|value}} to all of the elements.

@2@ Assigns the elements of {{tt|val_arr}} to the referred to elements of {{c|*this}}.

@3@ Assigns the selected elements from {{tt|sl_arr}} to the referred to elements of {{c|*this}}.

===Parameters===
{{par begin}}
{{par | value | a value to assign to all of the referred elements}}
{{par | val_arr | {{c|std::valarray}} to assign }}
{{par | sl_arr | {{c|std::{{{1}}}}} to assign }}
{{par end}}

===Return value===
@1-2@ (none)

@3@ {{c|*this}}

===Exceptions===
(none)

===Example===
{{example &lt;!-- use {{include|cpp/numeric/valarray/{{{1|}}}/example_operator{{=}}}} --&gt;
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/array/operator arith</title>
    <ns>10</ns>
    <id>12744</id>
    <revision>
      <id>61571</id>
      <timestamp>2013-06-06T04:31:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="1180">{{cpp/numeric/valarray/{{{1|}}}/title | 1=operator+=,-=,*=,/=,%=,&amp;=,{{!}}=,^=,&lt;&lt;=,&gt;&gt;=}}
{{cpp/numeric/valarray/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | 1=
void operator+=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator-=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator*=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator/=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator%=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator&amp;=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator{{!}}=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator^=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator&lt;&lt;=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl | 1=
void operator&gt;&gt;=( const std::valarray&lt;T&gt;&amp; other );
}}
{{dcl end}}

Applies the corresponding operation to the referred elements and the elements of {{tt|other}}.

===Parameters===
{{par begin}}
{{par | other | argument array to retrieve the values from }}
{{par end}}

===Return value===
(none)

===Exceptions===
(none)

===Example===
{{example &lt;!-- use {{include|cpp/numeric/valarray/{{{1|}}}/example_operator_arith}} --&gt;
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc abs</title>
    <ns>10</ns>
    <id>3637</id>
    <revision>
      <id>59164</id>
      <parentid>54388</parentid>
      <timestamp>2013-06-01T06:28:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list abs]] to [[Template:cpp/numeric/valarray/dsc abs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/numeric/valarray/abs   |  title=abs{{dsc small|(std::valarray)}} | applies the function {{c|std::abs}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc acos</title>
    <ns>10</ns>
    <id>3647</id>
    <revision>
      <id>59168</id>
      <parentid>54389</parentid>
      <timestamp>2013-06-01T06:28:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list acos]] to [[Template:cpp/numeric/valarray/dsc acos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/acos | title=acos{{dsc small|(std::valarray)}}     | applies the function {{lc|std::acos}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc apply</title>
    <ns>10</ns>
    <id>3632</id>
    <revision>
      <id>59172</id>
      <parentid>54392</parentid>
      <timestamp>2013-06-01T06:28:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list apply]] to [[Template:cpp/numeric/valarray/dsc apply]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/numeric/valarray/apply | applies a function to every element of a valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc asin</title>
    <ns>10</ns>
    <id>3646</id>
    <revision>
      <id>59176</id>
      <parentid>54393</parentid>
      <timestamp>2013-06-01T06:28:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list asin]] to [[Template:cpp/numeric/valarray/dsc asin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/asin | title=asin{{dsc small|(std::valarray)}}     | applies the function {{lc|std::asin}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc atan</title>
    <ns>10</ns>
    <id>3648</id>
    <revision>
      <id>59180</id>
      <parentid>54396</parentid>
      <timestamp>2013-06-01T06:28:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list atan]] to [[Template:cpp/numeric/valarray/dsc atan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/atan | title=atan{{dsc small|(std::valarray)}}     | applies the function {{lc|std::atan}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc atan2</title>
    <ns>10</ns>
    <id>3649</id>
    <revision>
      <id>59185</id>
      <parentid>54397</parentid>
      <timestamp>2013-06-01T06:28:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list atan2]] to [[Template:cpp/numeric/valarray/dsc atan2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc tfun | cpp/numeric/valarray/atan2 | title=atan2{{dsc small|(std::valarray)}}   | applies the function {{lc|std::atan2}} to a valarray and a value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc begin2</title>
    <ns>10</ns>
    <id>3491</id>
    <revision>
      <id>59189</id>
      <parentid>54398</parentid>
      <timestamp>2013-06-01T06:28:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list begin2]] to [[Template:cpp/numeric/valarray/dsc begin2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc tfun | cpp/numeric/valarray/begin2 | title=std::begin{{dsc small|(std::valarray)}} | specializes {{lc|std::begin}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc cos</title>
    <ns>10</ns>
    <id>3644</id>
    <revision>
      <id>59193</id>
      <parentid>54399</parentid>
      <timestamp>2013-06-01T06:28:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list cos]] to [[Template:cpp/numeric/valarray/dsc cos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/numeric/valarray/cos | title=cos{{dsc small|(std::valarray)}}     | applies the function {{lc|std::cos}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc cosh</title>
    <ns>10</ns>
    <id>3651</id>
    <revision>
      <id>59197</id>
      <parentid>54402</parentid>
      <timestamp>2013-06-01T06:28:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list cosh]] to [[Template:cpp/numeric/valarray/dsc cosh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/cosh | title=cosh{{dsc small|(std::valarray)}}     | applies the function {{lc|std::cosh}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc cshift</title>
    <ns>10</ns>
    <id>3633</id>
    <revision>
      <id>59201</id>
      <parentid>54403</parentid>
      <timestamp>2013-06-01T06:28:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list cshift]] to [[Template:cpp/numeric/valarray/dsc cshift]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/numeric/valarray/cshift | circular shift of the elements of the valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc end2</title>
    <ns>10</ns>
    <id>3489</id>
    <revision>
      <id>59206</id>
      <parentid>54406</parentid>
      <timestamp>2013-06-01T06:28:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list end2]] to [[Template:cpp/numeric/valarray/dsc end2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/numeric/valarray/end2 | title=std::end{{dsc small|(std::valarray)}} | specializes {{lc|std::end}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc exp</title>
    <ns>10</ns>
    <id>3638</id>
    <revision>
      <id>59210</id>
      <parentid>54407</parentid>
      <timestamp>2013-06-01T06:28:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list exp]] to [[Template:cpp/numeric/valarray/dsc exp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/numeric/valarray/exp   |  title=exp{{dsc small|(std::valarray)}} | applies the function {{lc|std::exp}} to each element of valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc gslice</title>
    <ns>10</ns>
    <id>3655</id>
    <revision>
      <id>59214</id>
      <parentid>54410</parentid>
      <timestamp>2013-06-01T06:28:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list gslice]] to [[Template:cpp/numeric/valarray/dsc gslice]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc class | cpp/numeric/valarray/gslice | generalized slice of a valarray: starting index, set of lengths, set of strides}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc gslice array</title>
    <ns>10</ns>
    <id>3656</id>
    <revision>
      <id>59218</id>
      <parentid>54411</parentid>
      <timestamp>2013-06-01T06:28:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list gslice array]] to [[Template:cpp/numeric/valarray/dsc gslice array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc tclass | cpp/numeric/valarray/gslice_array | proxy to a subset of a valarray after applying a gslice }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc indirect array</title>
    <ns>10</ns>
    <id>3658</id>
    <revision>
      <id>59223</id>
      <parentid>54416</parentid>
      <timestamp>2013-06-01T06:28:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list indirect array]] to [[Template:cpp/numeric/valarray/dsc indirect array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc tclass | cpp/numeric/valarray/indirect_array | proxy to a subset of a valarray after applying indirect {{tt|operator[]}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc log</title>
    <ns>10</ns>
    <id>3639</id>
    <revision>
      <id>59227</id>
      <parentid>54419</parentid>
      <timestamp>2013-06-01T06:28:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list log]] to [[Template:cpp/numeric/valarray/dsc log]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/numeric/valarray/log   |  title=log{{dsc small|(std::valarray)}} | applies the function {{lc|std::log}} to each element of valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc log10</title>
    <ns>10</ns>
    <id>3640</id>
    <revision>
      <id>59231</id>
      <parentid>54420</parentid>
      <timestamp>2013-06-01T06:29:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list log10]] to [[Template:cpp/numeric/valarray/dsc log10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/log10 | title=log10{{dsc small|(std::valarray)}} |  applies the function {{lc|std::log10}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc mask array</title>
    <ns>10</ns>
    <id>3657</id>
    <revision>
      <id>59235</id>
      <parentid>54425</parentid>
      <timestamp>2013-06-01T06:29:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list mask array]] to [[Template:cpp/numeric/valarray/dsc mask array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tclass | cpp/numeric/valarray/mask_array | proxy to a subset of a valarray after applying a boolean mask {{tt|operator[]}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc max</title>
    <ns>10</ns>
    <id>3630</id>
    <revision>
      <id>59240</id>
      <parentid>54428</parentid>
      <timestamp>2013-06-01T06:29:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list max]] to [[Template:cpp/numeric/valarray/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/numeric/valarray/max | returns the largest element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc min</title>
    <ns>10</ns>
    <id>3629</id>
    <revision>
      <id>59245</id>
      <parentid>54429</parentid>
      <timestamp>2013-06-01T06:29:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list min]] to [[Template:cpp/numeric/valarray/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/numeric/valarray/min | returns the smallest element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator=</title>
    <ns>10</ns>
    <id>3621</id>
    <revision>
      <id>59249</id>
      <parentid>54430</parentid>
      <timestamp>2013-06-01T06:29:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list operator=]] to [[Template:cpp/numeric/valarray/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/numeric/valarray/operator{{=}} | assigns the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator arith</title>
    <ns>10</ns>
    <id>3623</id>
    <revision>
      <id>59254</id>
      <parentid>54431</parentid>
      <timestamp>2013-06-01T06:29:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list operator arith]] to [[Template:cpp/numeric/valarray/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="180">{{dsc mem fun | cpp/numeric/valarray/operator_arith | title=operator+&lt;br&gt;operator-&lt;br&gt;operator~&lt;br&gt;operator! | applies a unary arithmetic operator to each element of the valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator arith2</title>
    <ns>10</ns>
    <id>3624</id>
    <revision>
      <id>59257</id>
      <parentid>54436</parentid>
      <timestamp>2013-06-01T06:29:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list operator arith2]] to [[Template:cpp/numeric/valarray/dsc operator arith2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="276">{{dsc mem fun | cpp/numeric/valarray/operator_arith2 | title=operator+=&lt;br&gt;operator-=&lt;br&gt;operator*=&lt;br&gt;operator/=&lt;br&gt;operator%=&lt;br&gt;operator&amp;=&lt;br&gt;operator{{!}}=&lt;br&gt;operator^=&lt;br&gt;operator&lt;&lt;=&lt;br&gt;operator&gt;&gt;= | applies compound assignment operator to each element of the valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator arith3</title>
    <ns>10</ns>
    <id>3635</id>
    <revision>
      <id>59261</id>
      <parentid>54437</parentid>
      <timestamp>2013-06-01T06:29:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list operator arith3]] to [[Template:cpp/numeric/valarray/dsc operator arith3]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="325">{{dsc tfun | cpp/numeric/valarray/operator_arith3 | title=operator+&lt;br&gt;operator-&lt;br&gt;operator*&lt;br&gt;operator/&lt;br&gt;operator%&lt;br&gt;operator&amp;&lt;br&gt;operator{{!}}&lt;br&gt;operator^&lt;br&gt;operator&lt;&lt;&lt;br&gt;operator&gt;&gt;&lt;br&gt;operator&amp;&amp;&lt;br&gt;operator&lt;nowiki&gt;||&lt;/nowiki&gt; | applies binary operators to each element of two valarrays, or a valarray and a value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator at</title>
    <ns>10</ns>
    <id>3622</id>
    <revision>
      <id>59266</id>
      <parentid>54438</parentid>
      <timestamp>2013-06-01T06:29:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list operator at]] to [[Template:cpp/numeric/valarray/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem fun | cpp/numeric/valarray/operator_at | title=operator[] | get/set valarray element, slice, or mask}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc operator cmp</title>
    <ns>10</ns>
    <id>3636</id>
    <revision>
      <id>71173</id>
      <parentid>59271</parentid>
      <timestamp>2014-06-07T10:47:37Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>-extra &lt;br&gt;</comment>
      <text xml:space="preserve" bytes="188">{{dsc tfun | cpp/numeric/valarray/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares two valarrays or a valarray with a value }}</text>
      <sha1>34r36y7opdc70opjb2xjeae4jwp5bll</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc pow</title>
    <ns>10</ns>
    <id>3641</id>
    <revision>
      <id>59275</id>
      <parentid>54440</parentid>
      <timestamp>2013-06-01T06:29:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list pow]] to [[Template:cpp/numeric/valarray/dsc pow]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc tfun | cpp/numeric/valarray/pow   |  title=pow{{dsc small|(std::valarray)}} | applies the function {{lc|std::pow}} to two valarrays or a valarray and a value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc rbegin2</title>
    <ns>10</ns>
    <id>12770</id>
    <revision>
      <id>61645</id>
      <timestamp>2013-06-06T09:08:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="185">{{dsc fun | cpp/numeric/valarray/rbegin2 | title=rbegin{{dsc small|(std::valarray)}}&lt;br/&gt;crbegin{{dsc small|(std::valarray)}} | specializes {{lc|std::rbegin()}} | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc rend2</title>
    <ns>10</ns>
    <id>12769</id>
    <revision>
      <id>61644</id>
      <timestamp>2013-06-06T09:08:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="177">{{dsc fun | cpp/numeric/valarray/rend2 | title=rend{{dsc small|(std::valarray)}}&lt;br/&gt;crend{{dsc small|(std::valarray)}} | specializes {{lc|std::rend()}} | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc resize</title>
    <ns>10</ns>
    <id>3627</id>
    <revision>
      <id>59279</id>
      <parentid>54443</parentid>
      <timestamp>2013-06-01T06:29:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list resize]] to [[Template:cpp/numeric/valarray/dsc resize]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/numeric/valarray/resize | changes the size of valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc shift</title>
    <ns>10</ns>
    <id>3631</id>
    <revision>
      <id>59283</id>
      <parentid>54444</parentid>
      <timestamp>2013-06-01T06:29:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list shift]] to [[Template:cpp/numeric/valarray/dsc shift]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/numeric/valarray/shift | zero-filling shift the elements of the valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc sin</title>
    <ns>10</ns>
    <id>3643</id>
    <revision>
      <id>59288</id>
      <parentid>54447</parentid>
      <timestamp>2013-06-01T06:29:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list sin]] to [[Template:cpp/numeric/valarray/dsc sin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/numeric/valarray/sin | title=sin{{dsc small|(std::valarray)}}     | applies the function {{lc|std::sin}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc sinh</title>
    <ns>10</ns>
    <id>3650</id>
    <revision>
      <id>59291</id>
      <parentid>54448</parentid>
      <timestamp>2013-06-01T06:30:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list sinh]] to [[Template:cpp/numeric/valarray/dsc sinh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/sinh | title=sinh{{dsc small|(std::valarray)}}     | applies the function {{lc|std::sinh}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc size</title>
    <ns>10</ns>
    <id>3626</id>
    <revision>
      <id>59295</id>
      <parentid>54449</parentid>
      <timestamp>2013-06-01T06:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list size]] to [[Template:cpp/numeric/valarray/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/numeric/valarray/size | returns the size of valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc slice</title>
    <ns>10</ns>
    <id>3653</id>
    <revision>
      <id>59298</id>
      <parentid>54450</parentid>
      <timestamp>2013-06-01T06:30:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list slice]] to [[Template:cpp/numeric/valarray/dsc slice]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc class | cpp/numeric/valarray/slice | BLAS-like slice of a valarray: starting index, length, stride }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc slice array</title>
    <ns>10</ns>
    <id>3654</id>
    <revision>
      <id>59302</id>
      <parentid>54457</parentid>
      <timestamp>2013-06-01T06:30:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list slice array]] to [[Template:cpp/numeric/valarray/dsc slice array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tclass | cpp/numeric/valarray/slice_array | proxy to a subset of a valarray after applying a slice }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc sqrt</title>
    <ns>10</ns>
    <id>3642</id>
    <revision>
      <id>59307</id>
      <parentid>54462</parentid>
      <timestamp>2013-06-01T06:30:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list sqrt]] to [[Template:cpp/numeric/valarray/dsc sqrt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/numeric/valarray/sqrt  | title=sqrt{{dsc small|(std::valarray)}} | applies the function {{lc|std::sqrt}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc sum</title>
    <ns>10</ns>
    <id>3628</id>
    <revision>
      <id>59312</id>
      <parentid>54463</parentid>
      <timestamp>2013-06-01T06:30:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list sum]] to [[Template:cpp/numeric/valarray/dsc sum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/numeric/valarray/sum | calculates the sum of all elements}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc swap</title>
    <ns>10</ns>
    <id>3625</id>
    <revision>
      <id>59316</id>
      <parentid>54464</parentid>
      <timestamp>2013-06-01T06:30:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list swap]] to [[Template:cpp/numeric/valarray/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/numeric/valarray/swap | swaps with another valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc swap2</title>
    <ns>10</ns>
    <id>3634</id>
    <revision>
      <id>61072</id>
      <parentid>59320</parentid>
      <timestamp>2013-06-05T03:14:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="157">{{dsc tfun | cpp/numeric/valarray/swap2 | title=std::swap{{dsc small|(std::valarray)}} | specializes the {{lc|std::swap()}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc tan</title>
    <ns>10</ns>
    <id>3645</id>
    <revision>
      <id>59324</id>
      <parentid>54468</parentid>
      <timestamp>2013-06-01T06:30:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list tan]] to [[Template:cpp/numeric/valarray/dsc tan]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/numeric/valarray/tan | title=tan{{dsc small|(std::valarray)}}     | applies the function {{lc|std::tan}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc tanh</title>
    <ns>10</ns>
    <id>3652</id>
    <revision>
      <id>59329</id>
      <parentid>54471</parentid>
      <timestamp>2013-06-01T06:31:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list tanh]] to [[Template:cpp/numeric/valarray/dsc tanh]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/numeric/valarray/tanh | title=tanh{{dsc small|(std::valarray)}}     | applies the function {{lc|std::tanh}} to each element of valarray }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc valarray</title>
    <ns>10</ns>
    <id>3619</id>
    <revision>
      <id>59331</id>
      <parentid>54472</parentid>
      <timestamp>2013-06-01T06:31:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list valarray]] to [[Template:cpp/numeric/valarray/dsc valarray]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem ctor | cpp/numeric/valarray/valarray | constructs new numeric array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/dsc ~valarray</title>
    <ns>10</ns>
    <id>3620</id>
    <revision>
      <id>59335</id>
      <parentid>54475</parentid>
      <timestamp>2013-06-01T06:31:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/numeric/valarray/dcl list ~valarray]] to [[Template:cpp/numeric/valarray/dsc ~valarray]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem dtor | cpp/numeric/valarray/~valarray | destructs the numeric array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/gslice array/navbar</title>
    <ns>10</ns>
    <id>12712</id>
    <revision>
      <id>61532</id>
      <timestamp>2013-06-06T03:13:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="372">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/valarray/navbar heading
|content3 = cpp/numeric/valarray/navbar content

|heading4 = cpp/numeric/valarray/gslice_array/navbar heading
|content4 = cpp/numeric/valarray/gslice_array/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/gslice array/navbar content</title>
    <ns>10</ns>
    <id>12719</id>
    <revision>
      <id>61540</id>
      <timestamp>2013-06-06T03:17:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="484">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/valarray/gslice_array/gslice_array}}
{{nv mem ln | cpp/numeric/valarray/gslice_array/~gslice_array}}
{{nv mem ln | cpp/numeric/valarray/gslice_array/operator{{=}}}}
{{nv mem ln | cpp/numeric/valarray/gslice_array/operator_arith | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} | operator%{{=}} | operator&amp;{{=}} | operator{{!}}{{=}} | operator^{{=}} | operator&lt;&lt;{{=}} | operator&gt;&gt;{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/gslice array/navbar heading</title>
    <ns>10</ns>
    <id>12715</id>
    <revision>
      <id>61536</id>
      <timestamp>2013-06-06T03:14:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="59">{{ltt|cpp/numeric/valarray/gslice_array|std::gslice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/gslice array/title</title>
    <ns>10</ns>
    <id>12747</id>
    <revision>
      <id>61576</id>
      <timestamp>2013-06-06T04:34:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=gslice_array::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/indirect array/navbar</title>
    <ns>10</ns>
    <id>12723</id>
    <revision>
      <id>61544</id>
      <timestamp>2013-06-06T03:18:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="376">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/valarray/navbar heading
|content3 = cpp/numeric/valarray/navbar content

|heading4 = cpp/numeric/valarray/indirect_array/navbar heading
|content4 = cpp/numeric/valarray/indirect_array/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/indirect array/navbar content</title>
    <ns>10</ns>
    <id>12722</id>
    <revision>
      <id>61543</id>
      <timestamp>2013-06-06T03:17:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>|</comment>
      <text xml:space="preserve" bytes="496">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/valarray/indirect_array/indirect_array}}
{{nv mem ln | cpp/numeric/valarray/indirect_array/~indirect_array}}
{{nv mem ln | cpp/numeric/valarray/indirect_array/operator{{=}}}}
{{nv mem ln | cpp/numeric/valarray/indirect_array/operator_arith | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} | operator%{{=}} | operator&amp;{{=}} | operator{{!}}{{=}} | operator^{{=}} | operator&lt;&lt;{{=}} | operator&gt;&gt;{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/indirect array/navbar heading</title>
    <ns>10</ns>
    <id>12718</id>
    <revision>
      <id>61539</id>
      <timestamp>2013-06-06T03:15:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="63">{{ltt|cpp/numeric/valarray/indirect_array|std::indirect_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/indirect array/title</title>
    <ns>10</ns>
    <id>12748</id>
    <revision>
      <id>61577</id>
      <timestamp>2013-06-06T04:34:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=indirect_array::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/mask array/navbar</title>
    <ns>10</ns>
    <id>12714</id>
    <revision>
      <id>61545</id>
      <parentid>61535</parentid>
      <timestamp>2013-06-06T03:19:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 61535 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="368">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/valarray/navbar heading
|content3 = cpp/numeric/valarray/navbar content

|heading4 = cpp/numeric/valarray/mask_array/navbar heading
|content4 = cpp/numeric/valarray/mask_array/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/mask array/navbar content</title>
    <ns>10</ns>
    <id>12721</id>
    <revision>
      <id>61542</id>
      <timestamp>2013-06-06T03:17:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="472">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/valarray/mask_array/mask_array}}
{{nv mem ln | cpp/numeric/valarray/mask_array/~mask_array}}
{{nv mem ln | cpp/numeric/valarray/mask_array/operator{{=}}}}
{{nv mem ln | cpp/numeric/valarray/mask_array/operator_arith | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} | operator%{{=}} | operator&amp;{{=}} | operator{{!}}{{=}} | operator^{{=}} | operator&lt;&lt;{{=}} | operator&gt;&gt;{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/mask array/navbar heading</title>
    <ns>10</ns>
    <id>12717</id>
    <revision>
      <id>61538</id>
      <timestamp>2013-06-06T03:14:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="55">{{ltt|cpp/numeric/valarray/mask_array|std::mask_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/mask array/title</title>
    <ns>10</ns>
    <id>12749</id>
    <revision>
      <id>61578</id>
      <timestamp>2013-06-06T04:34:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=mask_array::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/navbar</title>
    <ns>10</ns>
    <id>2705</id>
    <revision>
      <id>61531</id>
      <parentid>40010</parentid>
      <timestamp>2013-06-06T03:13:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/valarray/navbar heading
|content3 = cpp/numeric/valarray/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/navbar content</title>
    <ns>10</ns>
    <id>5017</id>
    <revision>
      <id>54480</id>
      <parentid>44884</parentid>
      <timestamp>2013-06-01T05:13:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="2523">{{nv begin}}
{{nv h1 | Member functions}}
{{nv col begin}}
{{nv mem ln | cpp/numeric/valarray/valarray}}
{{nv mem ln | cpp/numeric/valarray/~valarray}}
{{nv mem ln | cpp/numeric/valarray/operator{{=}}}}
{{nv mem ln | cpp/numeric/valarray/operator_at|operator[]}}
{{nv mem ln | cpp/numeric/valarray/swap}}
{{nv mem ln | cpp/numeric/valarray/size}}
{{nv mem ln | cpp/numeric/valarray/resize}}
{{nv mem ln | cpp/numeric/valarray/sum}}
{{nv mem ln | cpp/numeric/valarray/min}}
{{nv mem ln | cpp/numeric/valarray/max}}
{{nv mem ln | cpp/numeric/valarray/shift}}
{{nv mem ln | cpp/numeric/valarray/cshift}}
{{nv mem ln | cpp/numeric/valarray/apply}}
{{nv col next}}
{{nv mem ln | cpp/numeric/valarray/operator_arith|operator+|operator-|operator~|operator!}}
{{nv mem ln | cpp/numeric/valarray/operator_arith2|operator+{{=}}|operator-{{=}}|operator*{{=}}|operator/{{=}}|operator%{{=}}|operator&amp;{{=}}|operator{{!}}{{=}}|operator^{{=}}|operator&lt;&lt;{{=}}|operator&gt;&gt;{{=}}}}
{{nv col end}}

{{nv h1 | Non-member functions}}
{{nv col begin}}
{{nv ln | cpp/numeric/valarray/swap2|swap|notes={{mark c++11}}}}
{{nv ln | cpp/numeric/valarray/begin2|begin|notes={{mark c++11}}}}
{{nv ln | cpp/numeric/valarray/end2|end|notes={{mark c++11}}}}
{{nv ln | cpp/numeric/valarray/abs}}
{{nv ln | cpp/numeric/valarray/exp}}
{{nv ln | cpp/numeric/valarray/log}}
{{nv ln | cpp/numeric/valarray/log10}}
{{nv ln | cpp/numeric/valarray/pow}}
{{nv ln | cpp/numeric/valarray/sqrt}}
{{nv ln | cpp/numeric/valarray/sin}}
{{nv ln | cpp/numeric/valarray/cos}}
{{nv ln | cpp/numeric/valarray/tan}}
{{nv ln | cpp/numeric/valarray/asin}}
{{nv ln | cpp/numeric/valarray/acos}}
{{nv ln | cpp/numeric/valarray/atan}}
{{nv ln | cpp/numeric/valarray/atan2}}
{{nv ln | cpp/numeric/valarray/sinh}}
{{nv ln | cpp/numeric/valarray/cosh}}
{{nv ln | cpp/numeric/valarray/tanh}}
{{nv col next}}
{{nv ln | cpp/numeric/valarray/operator_arith3 |operator*|operator/|operator%|operator+|operator-|operator^|operator&amp;|operator{{!}}|operator&lt;&lt;|operator&gt;&gt;|operator&amp;&amp;|operator&amp;#124;&amp;#124;}}
{{nv ln | cpp/numeric/valarray/operator_cmp | operator{{==}} | operator!{{=}}|operator&lt;|operator&gt;|operator&lt;{{=}}|operator&gt;{{=}}}}
{{nv col end}}

{{nv h1 | Helper classes}}
{{nv col begin}}
{{nv ln | cpp/numeric/valarray/slice_array}}
{{nv ln | cpp/numeric/valarray/gslice_array}}
{{nv ln | cpp/numeric/valarray/indirect_array}}
{{nv col next}}
{{nv ln | cpp/numeric/valarray/slice}}
{{nv ln | cpp/numeric/valarray/gslice}}
{{nv ln | cpp/numeric/valarray/mask_array}}
{{nv col end}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/navbar heading</title>
    <ns>10</ns>
    <id>2706</id>
    <revision>
      <id>48026</id>
      <parentid>37939</parentid>
      <timestamp>2013-05-18T17:56:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="42">{{ltt|cpp/numeric/valarray|std::valarray}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/notes ret</title>
    <ns>10</ns>
    <id>5018</id>
    <revision>
      <id>54483</id>
      <parentid>44942</parentid>
      <timestamp>2013-06-01T05:13:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="795">The function can be implemented with the return type different from {{lc|std::valarray}}. In this case, the replacement type has the following properties:
:* All {{c|const}} member functions of {{lc|std::valarray}} are provided.
:* {{lc|std::valarray}}, {{c|std::slice_array}}, {{c|std::gslice_array}}, {{c|std::mask_array}} and {{c|std::indirect_array}} can be constructed from the replacement type.
:* All functions accepting a arguments of type {{c|const std::valarray&amp;}} should also accept the replacement type.
:* All functions accepting two arguments of type {{c|const std::valarray&amp;}} should accept every combination of {{c|const std::valarray&amp;}} and the replacement type.
:* The return type does not add more than two levels of template nesting over the most deeply-nested argument type.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/notes unq</title>
    <ns>10</ns>
    <id>9041</id>
    <revision>
      <id>37975</id>
      <timestamp>2012-07-22T22:45:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="168">Unqualified function ({{c|{{{1}}}}}) is used to perform the computation. If such function is not available, {{c|std::{{{1}}}}} is used due to argument dependent lookup.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/slice array/navbar</title>
    <ns>10</ns>
    <id>12713</id>
    <revision>
      <id>61533</id>
      <timestamp>2013-06-06T03:13:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="370">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/numeric/navbar heading
|content2 = cpp/numeric/navbar content

|heading3 = cpp/numeric/valarray/navbar heading
|content3 = cpp/numeric/valarray/navbar content

|heading4 = cpp/numeric/valarray/slice_array/navbar heading
|content4 = cpp/numeric/valarray/slice_array/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/slice array/navbar content</title>
    <ns>10</ns>
    <id>12720</id>
    <revision>
      <id>61541</id>
      <timestamp>2013-06-06T03:17:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="478">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/numeric/valarray/slice_array/slice_array}}
{{nv mem ln | cpp/numeric/valarray/slice_array/~slice_array}}
{{nv mem ln | cpp/numeric/valarray/slice_array/operator{{=}}}}
{{nv mem ln | cpp/numeric/valarray/slice_array/operator_arith | operator+{{=}} | operator-{{=}} | operator*{{=}} | operator/{{=}} | operator%{{=}} | operator&amp;{{=}} | operator{{!}}{{=}} | operator^{{=}} | operator&lt;&lt;{{=}} | operator&gt;&gt;{{=}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/slice array/navbar heading</title>
    <ns>10</ns>
    <id>12716</id>
    <revision>
      <id>61537</id>
      <timestamp>2013-06-06T03:14:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="57">{{ltt|cpp/numeric/valarray/slice_array|std::slice_array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/slice array/title</title>
    <ns>10</ns>
    <id>12746</id>
    <revision>
      <id>61575</id>
      <timestamp>2013-06-06T04:34:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=slice_array::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/numeric/valarray/title</title>
    <ns>10</ns>
    <id>4551</id>
    <revision>
      <id>16063</id>
      <timestamp>2011-12-19T18:48:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=valarray::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/preprocessor/navbar</title>
    <ns>10</ns>
    <id>1664</id>
    <revision>
      <id>40011</id>
      <parentid>36040</parentid>
      <timestamp>2012-09-28T20:19:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/language/navbar heading
|content2 = cpp/language/navbar content

|heading3 = cpp/preprocessor/navbar heading
|content3 = cpp/preprocessor/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/preprocessor/navbar content</title>
    <ns>10</ns>
    <id>1665</id>
    <revision>
      <id>72161</id>
      <parentid>54484</parentid>
      <timestamp>2014-07-19T14:33:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no #warning in C++</comment>
      <text xml:space="preserve" bytes="425">{{nv begin}}
{{nv ln | cpp/preprocessor/conditional | &amp;#35;if | &amp;#35;ifdef | &amp;#35;ifndef | &amp;#35;else | &amp;#35;elif | &amp;#35;endif}}
{{nv ln | cpp/preprocessor/replace | &amp;#35;define | &amp;#35;undef | &amp;#35;,&amp;#35;&amp;#35; operators}}
{{nv ln | cpp/preprocessor/include | &amp;#35;include}}
{{nv ln | cpp/preprocessor/error | &amp;#35;error}}
{{nv ln | cpp/preprocessor/impl | &amp;#35;pragma}}
{{nv ln | cpp/preprocessor/line | &amp;#35;line}}
{{nv end}}</text>
      <sha1>7nnu9lfdqckxgixlbz4k61cqtf8poko</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/preprocessor/navbar heading</title>
    <ns>10</ns>
    <id>1666</id>
    <revision>
      <id>33674</id>
      <parentid>3332</parentid>
      <timestamp>2012-06-15T20:36:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/preprocessor/sidebar heading]] to [[Template:cpp/preprocessor/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="35">[[cpp/preprocessor | Preprocessor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc assign</title>
    <ns>10</ns>
    <id>6350</id>
    <revision>
      <id>59339</id>
      <parentid>54487</parentid>
      <timestamp>2013-06-01T06:31:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list assign]] to [[Template:cpp/regex/basic regex/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/regex/basic_regex/assign | assigns the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc constructor</title>
    <ns>10</ns>
    <id>6347</id>
    <revision>
      <id>59343</id>
      <parentid>54488</parentid>
      <timestamp>2013-06-01T06:31:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list constructor]] to [[Template:cpp/regex/basic regex/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem ctor | cpp/regex/basic_regex/basic_regex | constructs the regex object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc destructor</title>
    <ns>10</ns>
    <id>6348</id>
    <revision>
      <id>59347</id>
      <parentid>54493</parentid>
      <timestamp>2013-06-01T06:31:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list destructor]] to [[Template:cpp/regex/basic regex/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem dtor | cpp/regex/basic_regex/~basic_regex | destructs the regex object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc flags</title>
    <ns>10</ns>
    <id>6352</id>
    <revision>
      <id>59351</id>
      <parentid>54496</parentid>
      <timestamp>2013-06-01T06:31:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list flags]] to [[Template:cpp/regex/basic regex/dsc flags]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc mem fun | cpp/regex/basic_regex/flags | returns the syntax flags }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc getloc</title>
    <ns>10</ns>
    <id>6353</id>
    <revision>
      <id>59355</id>
      <parentid>54497</parentid>
      <timestamp>2013-06-01T06:31:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list getloc]] to [[Template:cpp/regex/basic regex/dsc getloc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/regex/basic_regex/getloc | get locale information}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc imbue</title>
    <ns>10</ns>
    <id>6354</id>
    <revision>
      <id>59359</id>
      <parentid>54502</parentid>
      <timestamp>2013-06-01T06:31:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list imbue]] to [[Template:cpp/regex/basic regex/dsc imbue]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/regex/basic_regex/imbue | set locale information}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc mark count</title>
    <ns>10</ns>
    <id>6351</id>
    <revision>
      <id>59363</id>
      <parentid>54505</parentid>
      <timestamp>2013-06-01T06:31:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list mark count]] to [[Template:cpp/regex/basic regex/dsc mark count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem fun | cpp/regex/basic_regex/mark_count | returns the number of marked sub-expressions within the regular expression }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc operator=</title>
    <ns>10</ns>
    <id>6349</id>
    <revision>
      <id>59367</id>
      <parentid>54506</parentid>
      <timestamp>2013-06-01T06:32:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list operator=]] to [[Template:cpp/regex/basic regex/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/regex/basic_regex/operator{{=}} | assigns the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc swap</title>
    <ns>10</ns>
    <id>6355</id>
    <revision>
      <id>59371</id>
      <parentid>54507</parentid>
      <timestamp>2013-06-01T06:32:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list swap]] to [[Template:cpp/regex/basic regex/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/regex/basic_regex/swap | swaps the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/dsc swap2</title>
    <ns>10</ns>
    <id>6368</id>
    <revision>
      <id>59376</id>
      <parentid>54508</parentid>
      <timestamp>2013-06-01T06:32:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/basic regex/dcl list swap2]] to [[Template:cpp/regex/basic regex/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc tfun | cpp/regex/basic_regex/swap2 | title=std::swap{{dsc small|(std::basic_regex)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/navbar</title>
    <ns>10</ns>
    <id>2282</id>
    <revision>
      <id>47776</id>
      <parentid>40012</parentid>
      <timestamp>2013-05-16T20:26:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/basic_regex/navbar heading
|content3 = cpp/regex/basic_regex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/navbar content</title>
    <ns>10</ns>
    <id>3102</id>
    <revision>
      <id>54511</id>
      <parentid>35893</parentid>
      <timestamp>2013-06-01T05:13:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="745">{{nv begin}}
{{nv h1 | Member Functions}}
{{nv mem ln | cpp/regex/basic_regex/basic_regex }}
{{nv mem ln | cpp/regex/basic_regex/~basic_regex }}
{{nv mem ln | cpp/regex/basic_regex/operator{{=}}}}
{{nv mem ln | cpp/regex/basic_regex/assign }}
{{nv h2 | Observers}}
{{nv mem ln | cpp/regex/basic_regex/mark_count }}
{{nv mem ln | cpp/regex/basic_regex/flags }}
{{nv h2 | Locale}}
{{nv mem ln | cpp/regex/basic_regex/getloc }}
{{nv mem ln | cpp/regex/basic_regex/imbue }}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/regex/basic_regex/swap }}
{{nv h2 | Constants}}
{{nv ln | cpp/regex/basic_regex/constants|basic_regex constants}}
{{nv h1 | Non-member Functions}}
{{nv ln | cpp/regex/basic_regex/swap2|swap{{dsc small|(std::basic_regex)}} }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/navbar heading</title>
    <ns>10</ns>
    <id>2287</id>
    <revision>
      <id>47763</id>
      <parentid>35894</parentid>
      <timestamp>2013-05-16T20:24:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/regex/basic_regex|std::basic_regex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/basic regex/title</title>
    <ns>10</ns>
    <id>3099</id>
    <revision>
      <id>22284</id>
      <parentid>11917</parentid>
      <timestamp>2012-04-19T16:00:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic regex/title]] to [[Template:cpp/regex/basic regex/title]]: fix location</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=basic_regex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc basic regex</title>
    <ns>10</ns>
    <id>8453</id>
    <revision>
      <id>59381</id>
      <parentid>54512</parentid>
      <timestamp>2013-06-01T06:32:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list basic regex]] to [[Template:cpp/regex/dsc basic regex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc tclass | cpp/regex/basic_regex | regular expression object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc error type</title>
    <ns>10</ns>
    <id>8443</id>
    <revision>
      <id>59385</id>
      <parentid>54515</parentid>
      <timestamp>2013-06-01T06:32:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list error type]] to [[Template:cpp/regex/dsc error type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc typedef | cpp/regex/error_type | describes different types of matching errors | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc match flag type</title>
    <ns>10</ns>
    <id>8442</id>
    <revision>
      <id>59388</id>
      <parentid>54516</parentid>
      <timestamp>2013-06-01T06:32:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list match flag type]] to [[Template:cpp/regex/dsc match flag type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc typedef | cpp/regex/match_flag_type | options specific to matching | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc match results</title>
    <ns>10</ns>
    <id>8454</id>
    <revision>
      <id>59393</id>
      <parentid>54519</parentid>
      <timestamp>2013-06-01T06:32:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list match results]] to [[Template:cpp/regex/dsc match results]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc tclass | cpp/regex/match_results | identifies one regular expression match, including all sub-expression matches | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex error</title>
    <ns>10</ns>
    <id>8502</id>
    <revision>
      <id>59400</id>
      <parentid>54523</parentid>
      <timestamp>2013-06-01T06:33:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex error]] to [[Template:cpp/regex/dsc regex error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc class | cpp/regex/regex_error | reports errors generated by the regular expressions library | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex iterator</title>
    <ns>10</ns>
    <id>8500</id>
    <revision>
      <id>59404</id>
      <parentid>54524</parentid>
      <timestamp>2013-06-01T06:33:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex iterator]] to [[Template:cpp/regex/dsc regex iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc tclass | cpp/regex/regex_iterator | iterates through all regex matches within a character sequence | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex match</title>
    <ns>10</ns>
    <id>8497</id>
    <revision>
      <id>59408</id>
      <parentid>54525</parentid>
      <timestamp>2013-06-01T06:33:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex match]] to [[Template:cpp/regex/dsc regex match]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tfun | cpp/regex/regex_match | attempts to match a regular expression to an entire character sequence | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex replace</title>
    <ns>10</ns>
    <id>8499</id>
    <revision>
      <id>59412</id>
      <parentid>54528</parentid>
      <timestamp>2013-06-01T06:33:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex replace]] to [[Template:cpp/regex/dsc regex replace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/regex/regex_replace | replaces occurrences of a regular expression with formatted replacement text | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex search</title>
    <ns>10</ns>
    <id>8498</id>
    <revision>
      <id>59416</id>
      <parentid>54533</parentid>
      <timestamp>2013-06-01T06:33:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex search]] to [[Template:cpp/regex/dsc regex search]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/regex/regex_search | attempts to match a regular expression to any part of a character sequence | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex token iterator</title>
    <ns>10</ns>
    <id>8501</id>
    <revision>
      <id>59421</id>
      <parentid>54556</parentid>
      <timestamp>2013-06-01T06:34:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex token iterator]] to [[Template:cpp/regex/dsc regex token iterator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc tclass | cpp/regex/regex_token_iterator | iterates through the specified sub-expressions within all regex matches in a given string or through unmatched substrings | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc regex traits</title>
    <ns>10</ns>
    <id>8503</id>
    <revision>
      <id>59424</id>
      <parentid>54557</parentid>
      <timestamp>2013-06-01T06:34:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list regex traits]] to [[Template:cpp/regex/dsc regex traits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="143">{{dsc tclass | cpp/regex/regex_traits | provides metainformation about a character type, required by the regex library | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc sub match</title>
    <ns>10</ns>
    <id>8496</id>
    <revision>
      <id>59428</id>
      <parentid>54560</parentid>
      <timestamp>2013-06-01T06:34:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list sub match]] to [[Template:cpp/regex/dsc sub match]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc tclass | cpp/regex/sub_match | identifies the sequence of characters matched by a sub-expression | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/dsc syntax option type</title>
    <ns>10</ns>
    <id>8431</id>
    <revision>
      <id>59431</id>
      <parentid>54561</parentid>
      <timestamp>2013-06-01T06:34:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/dcl list syntax option type]] to [[Template:cpp/regex/dsc syntax option type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc typedef | cpp/regex/syntax_option_type | general options controlling regex behavior | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/isctype example</title>
    <ns>10</ns>
    <id>13120</id>
    <revision>
      <id>67009</id>
      <parentid>67006</parentid>
      <timestamp>2014-01-16T05:26:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+desc</comment>
      <text xml:space="preserve" bytes="1428">{{example|demonstraits a custom regex_traits implementation of lookup_classname/isctype
|code=#include &lt;iostream&gt;
#include &lt;locale&gt;
#include &lt;regex&gt;
#include &lt;cwctype&gt;

// This custom regex traits uses wctype/iswctype to implement lookup_classname/isctype
struct wctype_traits : std::regex_traits&lt;wchar_t&gt;
{
    using char_class_type = std::wctype_t;
    template&lt;class It&gt;
    char_class_type lookup_classname(It first, It last, bool=false) const {
        return std::wctype(std::string(first, last).c_str());
    }
    bool isctype(wchar_t c, char_class_type f) const {
        return std::iswctype(c, f);
    }
};

int main()
{
    std::locale::global(std::locale(&quot;ja_JP.utf8&quot;));
    std::wcout.sync_with_stdio(false);
    std::wcout.imbue(std::locale());

    std::wsmatch m;
    std::wstring in = L&quot;風の谷のナウシカ&quot;;
    // matches all characters (they are classified as alnum)
    std::regex_search(in, m, std::wregex(L&quot;([[:alnum:]]+)&quot;));
    std::wcout &lt;&lt; &quot;alnums: &quot; &lt;&lt; m[1] &lt;&lt; '\n'; // prints &quot;風の谷のナウシカ&quot;
    // matches only the kanji
    std::regex_search(in, m,
                      std::basic_regex&lt;wchar_t, wctype_traits&gt;(L&quot;([[:jkata:]]+)&quot;));
    std::wcout &lt;&lt; &quot;katakana: &quot; &lt;&lt; m[1] &lt;&lt; '\n'; // prints &quot;ナウシカ&quot;
}
|output=
alnums: 風の谷のナウシカ
katakana: ナウシカ
}}
&lt;!-- note: this does not compile with the current libc++: http://llvm.org/bugs/show_bug.cgi?id=18501 --&gt;</text>
      <sha1>5b6kw8y70opwnx0hmkz43t45nq5jdvz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc begin</title>
    <ns>10</ns>
    <id>3125</id>
    <revision>
      <id>59435</id>
      <parentid>54562</parentid>
      <timestamp>2013-06-01T06:34:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list begin]] to [[Template:cpp/regex/match results/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc mem fun | cpp/regex/match_results/begin | title=begin&lt;br&gt;cbegin | returns iterator to the beginning of the list of sub-matches}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc constructor</title>
    <ns>10</ns>
    <id>4257</id>
    <revision>
      <id>59438</id>
      <parentid>54563</parentid>
      <timestamp>2013-06-01T06:35:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list constructor]] to [[Template:cpp/regex/match results/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem ctor | cpp/regex/match_results/match_results | constructs the object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc destructor</title>
    <ns>10</ns>
    <id>4258</id>
    <revision>
      <id>59442</id>
      <parentid>54566</parentid>
      <timestamp>2013-06-01T06:35:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list destructor]] to [[Template:cpp/regex/match results/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem dtor | cpp/regex/match_results/~match_results | destructs the object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc empty</title>
    <ns>10</ns>
    <id>4260</id>
    <revision>
      <id>59445</id>
      <parentid>54567</parentid>
      <timestamp>2013-06-01T06:35:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list empty]] to [[Template:cpp/regex/match results/dsc empty]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/regex/match_results/empty | checks whether the match was successful}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc end</title>
    <ns>10</ns>
    <id>3126</id>
    <revision>
      <id>59449</id>
      <parentid>54570</parentid>
      <timestamp>2013-06-01T06:35:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list end]] to [[Template:cpp/regex/match results/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/regex/match_results/end | title=end&lt;br&gt;cend | returns iterator to the end of the list of sub-matches}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc format</title>
    <ns>10</ns>
    <id>6387</id>
    <revision>
      <id>59453</id>
      <parentid>54573</parentid>
      <timestamp>2013-06-01T06:35:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list format]] to [[Template:cpp/regex/match results/dsc format]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc mem fun | cpp/regex/match_results/format | formats match results for output}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc get allocator</title>
    <ns>10</ns>
    <id>4259</id>
    <revision>
      <id>59456</id>
      <parentid>54578</parentid>
      <timestamp>2013-06-01T06:35:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list get allocator]] to [[Template:cpp/regex/match results/dsc get allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/regex/match_results/get_allocator | returns the associated allocator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc length</title>
    <ns>10</ns>
    <id>6381</id>
    <revision>
      <id>59460</id>
      <parentid>54581</parentid>
      <timestamp>2013-06-01T06:36:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list length]] to [[Template:cpp/regex/match results/dsc length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/regex/match_results/length | returns the length of the particular sub-match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc max size</title>
    <ns>10</ns>
    <id>4262</id>
    <revision>
      <id>59464</id>
      <parentid>54582</parentid>
      <timestamp>2013-06-01T06:36:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list max size]] to [[Template:cpp/regex/match results/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/regex/match_results/max_size | returns the maximum possible number of sub-matches}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc operator=</title>
    <ns>10</ns>
    <id>6389</id>
    <revision>
      <id>59468</id>
      <parentid>54583</parentid>
      <timestamp>2013-06-01T06:36:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list operator=]] to [[Template:cpp/regex/match results/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/regex/match_results/operator{{=}} | assigns the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc operator at</title>
    <ns>10</ns>
    <id>6384</id>
    <revision>
      <id>59472</id>
      <parentid>54584</parentid>
      <timestamp>2013-06-01T06:36:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list operator at]] to [[Template:cpp/regex/match results/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem fun | cpp/regex/match_results/operator_at | title=operator[] | returns specified sub-match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc operator cmp</title>
    <ns>10</ns>
    <id>9057</id>
    <revision>
      <id>59476</id>
      <parentid>54587</parentid>
      <timestamp>2013-06-01T06:36:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list operator cmp]] to [[Template:cpp/regex/match results/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc tfun | cpp/regex/match_results/operator_cmp | title=operator==&lt;br&gt;operator!= | lexicographically compares the values in the two match result }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc position</title>
    <ns>10</ns>
    <id>6382</id>
    <revision>
      <id>59481</id>
      <parentid>54588</parentid>
      <timestamp>2013-06-01T06:36:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list position]] to [[Template:cpp/regex/match results/dsc position]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem fun | cpp/regex/match_results/position | returns the position of the first character of the particular sub-match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc prefix</title>
    <ns>10</ns>
    <id>6385</id>
    <revision>
      <id>59486</id>
      <parentid>54589</parentid>
      <timestamp>2013-06-01T06:36:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list prefix]] to [[Template:cpp/regex/match results/dsc prefix]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="153">{{dsc mem fun | cpp/regex/match_results/prefix | returns sub-sequence between the beginning of the target sequence and the beginning of the full match.}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc size</title>
    <ns>10</ns>
    <id>4261</id>
    <revision>
      <id>59491</id>
      <parentid>54592</parentid>
      <timestamp>2013-06-01T06:36:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list size]] to [[Template:cpp/regex/match results/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem fun | cpp/regex/match_results/size | returns the number of matches in a fully-established result state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc str</title>
    <ns>10</ns>
    <id>6383</id>
    <revision>
      <id>59495</id>
      <parentid>54593</parentid>
      <timestamp>2013-06-01T06:36:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list str]] to [[Template:cpp/regex/match results/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/regex/match_results/str | returns the sequence of characters for the particular sub-match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc suffix</title>
    <ns>10</ns>
    <id>6386</id>
    <revision>
      <id>59499</id>
      <parentid>54596</parentid>
      <timestamp>2013-06-01T06:36:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list suffix]] to [[Template:cpp/regex/match results/dsc suffix]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc mem fun | cpp/regex/match_results/suffix | returns sub-sequence between the end of the full match and the end of the target sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc swap</title>
    <ns>10</ns>
    <id>6388</id>
    <revision>
      <id>59503</id>
      <parentid>54597</parentid>
      <timestamp>2013-06-01T06:36:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list swap]] to [[Template:cpp/regex/match results/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/regex/match_results/swap | swaps the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/dsc swap2</title>
    <ns>10</ns>
    <id>9058</id>
    <revision>
      <id>59507</id>
      <parentid>54598</parentid>
      <timestamp>2013-06-01T06:37:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/match results/dcl list swap2]] to [[Template:cpp/regex/match results/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="185">{{dsc tfun | cpp/regex/match_results/swap2 | title=std::swap{{dsc small|(std::match_results)}} | specializes the {{ltt|cpp/algorithm/swap|std::swap()}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/navbar</title>
    <ns>10</ns>
    <id>2283</id>
    <revision>
      <id>47775</id>
      <parentid>40013</parentid>
      <timestamp>2013-05-16T20:26:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/match_results/navbar heading
|content3 = cpp/regex/match_results/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/navbar content</title>
    <ns>10</ns>
    <id>3215</id>
    <revision>
      <id>54599</id>
      <parentid>38013</parentid>
      <timestamp>2013-06-01T05:14:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1061">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/regex/match_results/match_results}}
{{nv mem ln | cpp/regex/match_results/~match_results}}
{{nv mem ln | cpp/regex/match_results/operator{{=}}}}
{{nv mem ln | cpp/regex/match_results/get_allocator}}
{{nv h2 | State}}
{{nv mem ln | cpp/regex/match_results/ready}}
{{nv h2 | Element access}}
{{nv mem ln | cpp/regex/match_results/size}}
{{nv mem ln | cpp/regex/match_results/max_size}}
{{nv mem ln | cpp/regex/match_results/empty}}
{{nv mem ln | cpp/regex/match_results/length}}
{{nv mem ln | cpp/regex/match_results/position}}
{{nv mem ln | cpp/regex/match_results/str}}
{{nv mem ln | cpp/regex/match_results/operator_at}}
{{nv mem ln | cpp/regex/match_results/prefix}}
{{nv mem ln | cpp/regex/match_results/suffix}}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/regex/match_results/begin | begin | cbegin}}
{{nv mem ln | cpp/regex/match_results/end | end | cend}}
{{nv h2 | Format}}
{{nv mem ln | cpp/regex/match_results/format}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/regex/match_results/swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/navbar heading</title>
    <ns>10</ns>
    <id>2286</id>
    <revision>
      <id>47762</id>
      <parentid>35896</parentid>
      <timestamp>2013-05-16T20:23:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="50">{{ltt|cpp/regex/match_results|std::match_results}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/match results/title</title>
    <ns>10</ns>
    <id>3122</id>
    <revision>
      <id>11991</id>
      <timestamp>2011-10-21T10:42:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=match_results::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/navbar</title>
    <ns>10</ns>
    <id>1667</id>
    <revision>
      <id>40014</id>
      <parentid>35898</parentid>
      <timestamp>2012-09-28T20:19:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="150">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/navbar content</title>
    <ns>10</ns>
    <id>3101</id>
    <revision>
      <id>66900</id>
      <parentid>54602</parentid>
      <timestamp>2014-01-05T23:11:00Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+grammar link</comment>
      <text xml:space="preserve" bytes="1027">{{nv begin}}
{{nv h1 | Classes}}
{{nv ln | cpp/regex/basic_regex | notes={{mark c++11}}}}
{{nv ln | cpp/regex/sub_match | notes={{mark c++11}}}}
{{nv ln | cpp/regex/match_results | notes={{mark c++11}}}}
{{nv h1 | Algorithms}}
{{nv ln | cpp/regex/regex_match | notes={{mark c++11}}}}
{{nv ln | cpp/regex/regex_search | notes={{mark c++11}}}}
{{nv ln | cpp/regex/regex_replace | notes={{mark c++11}}}}
{{nv h1 | Iterators}}
{{nv ln | cpp/regex/regex_iterator | notes={{mark c++11}}}}
{{nv ln | cpp/regex/regex_token_iterator | notes={{mark c++11}}}}
{{nv h1 | Exceptions}}
{{nv ln | cpp/regex/regex_error | notes={{mark c++11}}}}
{{nv h1 | Traits}}
{{nv ln | cpp/regex/regex_traits | notes={{mark c++11}}}}
{{nv h1 | Constants}}
{{nv ln | cpp/regex/syntax_option_type | notes={{mark c++11}}}}
{{nv ln | cpp/regex/match_flag_type | notes={{mark c++11}}}}
{{nv ln | cpp/regex/error_type | notes={{mark c++11}}}}
{{nv h1 | Regex Grammar}}
{{nv ln | cpp/regex/ecmascript | Modified ECMAScript-262 | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1>03lbz60sqov74s6lqiryus9i5owtsna</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/navbar heading</title>
    <ns>10</ns>
    <id>1668</id>
    <revision>
      <id>35899</id>
      <parentid>3336</parentid>
      <timestamp>2012-06-15T22:34:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/sidebar heading]] to [[Template:cpp/regex/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="43">[[cpp/regex | Regular expressions library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/dsc code</title>
    <ns>10</ns>
    <id>8446</id>
    <revision>
      <id>59511</id>
      <parentid>54605</parentid>
      <timestamp>2013-06-01T06:37:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex error/dcl list code]] to [[Template:cpp/regex/regex error/dsc code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/regex/regex_error/code | gets the {{lc|std::regex_constants::error_type}} for a {{tt|regex_error}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/dsc regex error</title>
    <ns>10</ns>
    <id>8445</id>
    <revision>
      <id>59515</id>
      <parentid>54606</parentid>
      <timestamp>2013-06-01T06:37:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex error/dcl list regex error]] to [[Template:cpp/regex/regex error/dsc regex error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem ctor | cpp/regex/regex_error/regex_error | constructs a {{tt|regex_error}} object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/navbar</title>
    <ns>10</ns>
    <id>3104</id>
    <revision>
      <id>40015</id>
      <parentid>35897</parentid>
      <timestamp>2012-09-28T20:19:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/regex_error/navbar heading
|content3 = cpp/regex/regex_error/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/navbar content</title>
    <ns>10</ns>
    <id>3106</id>
    <revision>
      <id>54611</id>
      <parentid>34011</parentid>
      <timestamp>2013-06-01T05:14:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="147">{{nv begin}}
{{nv h1 | Member Functions}}
{{nv mem ln | cpp/regex/regex_error/regex_error }}
{{nv mem ln | cpp/regex/regex_error/code }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/navbar heading</title>
    <ns>10</ns>
    <id>3105</id>
    <revision>
      <id>48032</id>
      <parentid>35358</parentid>
      <timestamp>2013-05-18T17:58:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="46">{{ltt|cpp/regex/regex_error|std::regex_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex error/title</title>
    <ns>10</ns>
    <id>3108</id>
    <revision>
      <id>11933</id>
      <timestamp>2011-10-20T17:14:15Z</timestamp>
      <contributor>
        <username>Bregma</username>
        <id>225</id>
      </contributor>
      <comment>created template</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=regex_error::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc constructor</title>
    <ns>10</ns>
    <id>10129</id>
    <revision>
      <id>59520</id>
      <parentid>54614</parentid>
      <timestamp>2013-06-01T06:37:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list constructor]] to [[Template:cpp/regex/regex iterator/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem ctor | cpp/regex/regex_iterator/regex_iterator | constructs a new {{tt|regex_iterator}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc destructor</title>
    <ns>10</ns>
    <id>10130</id>
    <revision>
      <id>59525</id>
      <parentid>54615</parentid>
      <timestamp>2013-06-01T06:37:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list destructor]] to [[Template:cpp/regex/regex iterator/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem dtor | nolink=true| destructs a {{tt|regex_iterator}}, including the cached value | notes={{mark implicit}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc operator*</title>
    <ns>10</ns>
    <id>10133</id>
    <revision>
      <id>59529</id>
      <parentid>54616</parentid>
      <timestamp>2013-06-01T06:37:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list operator*]] to [[Template:cpp/regex/regex iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/regex/regex_iterator/operator* | title=operator*&lt;br&gt;operator-&gt; | accesses the current match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc operator=</title>
    <ns>10</ns>
    <id>10131</id>
    <revision>
      <id>59533</id>
      <parentid>54617</parentid>
      <timestamp>2013-06-01T06:37:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list operator=]] to [[Template:cpp/regex/regex iterator/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem fun | cpp/regex/regex_iterator/operator{{=}} | assigns contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>10134</id>
    <revision>
      <id>59537</id>
      <parentid>54620</parentid>
      <timestamp>2013-06-01T06:37:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list operator arith]] to [[Template:cpp/regex/regex iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="153">{{dsc mem fun | cpp/regex/regex_iterator/operator_arith | title=operator++&lt;br/&gt;operator++{{dsc small|(int)}} | advances the iterator to the next match }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/dsc operator cmp</title>
    <ns>10</ns>
    <id>10132</id>
    <revision>
      <id>59541</id>
      <parentid>54623</parentid>
      <timestamp>2013-06-01T06:37:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex iterator/dcl list operator cmp]] to [[Template:cpp/regex/regex iterator/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/regex/regex_iterator/operator_cmp | title=operator==&lt;br&gt;operator!= | compares two {{tt|regex_iterator}}s }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/navbar</title>
    <ns>10</ns>
    <id>9810</id>
    <revision>
      <id>45737</id>
      <timestamp>2013-01-14T23:56:01Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="254">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/regex_iterator/navbar heading
|content3 = cpp/regex/regex_iterator/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/navbar content</title>
    <ns>10</ns>
    <id>9812</id>
    <revision>
      <id>54624</id>
      <parentid>48363</parentid>
      <timestamp>2013-06-01T05:15:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="474">{{nv begin}}
{{nv h1 | Member Functions}}
{{nv mem ln | cpp/regex/regex_iterator/regex_iterator }}
{{nv mem ln | cpp/regex/regex_iterator/operator{{=}}}}
{{nv h2 | Comparisons}}
{{nv mem ln | cpp/regex/regex_iterator/operator_cmp|operator{{==}}|operator!{{=}} }}
{{nv h2 | Observers}}
{{nv mem ln | cpp/regex/regex_iterator/operator*|operator*|operator-&gt; }}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/regex/regex_iterator/operator_arith|operator++|operator++(int) }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/navbar heading</title>
    <ns>10</ns>
    <id>9811</id>
    <revision>
      <id>48086</id>
      <parentid>45738</parentid>
      <timestamp>2013-05-18T18:07:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <text xml:space="preserve" bytes="52">{{ltt|cpp/regex/regex_iterator|std::regex_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex iterator/title</title>
    <ns>10</ns>
    <id>8486</id>
    <revision>
      <id>31270</id>
      <timestamp>2012-05-17T03:05:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=regex_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc constructor</title>
    <ns>10</ns>
    <id>9760</id>
    <revision>
      <id>61461</id>
      <parentid>59545</parentid>
      <timestamp>2013-06-06T01:09:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem ctor | cpp/regex/regex_token_iterator/regex_token_iterator | constructs a new {{tt|regex_token_iterator}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc destructor</title>
    <ns>10</ns>
    <id>9765</id>
    <revision>
      <id>61462</id>
      <parentid>59549</parentid>
      <timestamp>2013-06-06T01:09:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem dtor | nolink=true| destructs a {{tt|regex_token_iterator}}, including the cached value | notes={{mark implicit}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc operator*</title>
    <ns>10</ns>
    <id>9763</id>
    <revision>
      <id>59553</id>
      <parentid>54631</parentid>
      <timestamp>2013-06-01T06:37:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex token iterator/dcl list operator*]] to [[Template:cpp/regex/regex token iterator/dsc operator*]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem fun | cpp/regex/regex_token_iterator/operator* | title=operator*&lt;br&gt;operator-&gt; | accesses current submatch}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc operator=</title>
    <ns>10</ns>
    <id>9761</id>
    <revision>
      <id>61463</id>
      <parentid>59558</parentid>
      <timestamp>2013-06-06T01:09:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/regex/regex_token_iterator/operator{{=}} | assigns contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc operator arith</title>
    <ns>10</ns>
    <id>9764</id>
    <revision>
      <id>59563</id>
      <parentid>54635</parentid>
      <timestamp>2013-06-01T06:38:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/regex token iterator/dcl list operator arith]] to [[Template:cpp/regex/regex token iterator/dsc operator arith]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem fun | cpp/regex/regex_token_iterator/operator_arith | title=operator++&lt;br&gt;operator++{{dsc small|(int)}} | advances the iterator to the next submatch }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/dsc operator cmp</title>
    <ns>10</ns>
    <id>9762</id>
    <revision>
      <id>61464</id>
      <parentid>59567</parentid>
      <timestamp>2013-06-06T01:09:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/regex/regex_token_iterator/operator_cmp | title=operator==&lt;br&gt;operator!= | compares two {{tt|regex_token_iterator}}s }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/navbar</title>
    <ns>10</ns>
    <id>9815</id>
    <revision>
      <id>45745</id>
      <timestamp>2013-01-15T00:39:25Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="266">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/regex_token_iterator/navbar heading
|content3 = cpp/regex/regex_token_iterator/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/navbar content</title>
    <ns>10</ns>
    <id>9817</id>
    <revision>
      <id>61392</id>
      <parentid>54639</parentid>
      <timestamp>2013-06-05T22:47:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="510">{{nv begin}}
{{nv h1 | Member Functions}}
{{nv mem ln | cpp/regex/regex_token_iterator/regex_token_iterator }}
{{nv mem ln | cpp/regex/regex_token_iterator/operator{{=}}}}
{{nv h2 | Comparisons}}
{{nv mem ln | cpp/regex/regex_token_iterator/operator_cmp|operator{{==}}|operator!{{=}} }}
{{nv h2 | Observers}}
{{nv mem ln | cpp/regex/regex_token_iterator/operator*|operator*|operator-&gt; }}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/regex/regex_token_iterator/operator_arith|operator++|operator++(int) }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/navbar heading</title>
    <ns>10</ns>
    <id>9816</id>
    <revision>
      <id>48085</id>
      <parentid>45748</parentid>
      <timestamp>2013-05-18T18:07:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="64">{{ltt|cpp/regex/regex_token_iterator|std::regex_token_iterator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex token iterator/title</title>
    <ns>10</ns>
    <id>8487</id>
    <revision>
      <id>31271</id>
      <timestamp>2012-05-17T03:05:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="117">&lt;onlyinclude&gt;{{cpp/title | n=regex_token_iterator::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc constructor</title>
    <ns>10</ns>
    <id>12611</id>
    <revision>
      <id>61315</id>
      <timestamp>2013-06-05T21:31:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem ctor | cpp/regex/regex_traits/regex_traits | constructs the regex_traits object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc getloc</title>
    <ns>10</ns>
    <id>12622</id>
    <revision>
      <id>61326</id>
      <timestamp>2013-06-05T21:32:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="65">{{dsc mem fun | cpp/regex/regex_traits/getloc | gets the locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc imbue</title>
    <ns>10</ns>
    <id>12621</id>
    <revision>
      <id>61325</id>
      <timestamp>2013-06-05T21:32:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="64">{{dsc mem fun | cpp/regex/regex_traits/imbue | sets the locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc isctype</title>
    <ns>10</ns>
    <id>12619</id>
    <revision>
      <id>61323</id>
      <timestamp>2013-06-05T21:32:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/regex/regex_traits/isctype |indicates membership in a localized character class}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc length</title>
    <ns>10</ns>
    <id>12612</id>
    <revision>
      <id>61316</id>
      <timestamp>2013-06-05T21:31:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem sfun  | cpp/regex/regex_traits/length | calculates the length of a null-terminated character string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc lookup classname</title>
    <ns>10</ns>
    <id>12618</id>
    <revision>
      <id>61322</id>
      <timestamp>2013-06-05T21:32:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/regex/regex_traits/lookup_classname | gets a character class by name}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc lookup collatename</title>
    <ns>10</ns>
    <id>12617</id>
    <revision>
      <id>61321</id>
      <timestamp>2013-06-05T21:32:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/regex/regex_traits/lookup_collatename | gets a collation element by name}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc transform</title>
    <ns>10</ns>
    <id>12615</id>
    <revision>
      <id>61319</id>
      <timestamp>2013-06-05T21:31:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="130">{{dsc mem fun | cpp/regex/regex_traits/transform | determines the sort key for the given string, used to provide collation order}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc transform primary</title>
    <ns>10</ns>
    <id>12616</id>
    <revision>
      <id>61320</id>
      <timestamp>2013-06-05T21:32:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="156">{{dsc mem fun | cpp/regex/regex_traits/transform_primary | determines the primary sort key for the character sequence, used to determine equivalence class}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc translate</title>
    <ns>10</ns>
    <id>12613</id>
    <revision>
      <id>61317</id>
      <timestamp>2013-06-05T21:31:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/regex/regex_traits/translate | determines the equivalence key for a character }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc translate nocase</title>
    <ns>10</ns>
    <id>12614</id>
    <revision>
      <id>61318</id>
      <timestamp>2013-06-05T21:31:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/regex/regex_traits/translate_nocase | determines the case-insensitive equivalence key for a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/dsc value</title>
    <ns>10</ns>
    <id>12620</id>
    <revision>
      <id>61324</id>
      <timestamp>2013-06-05T21:32:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/regex/regex_traits/value | translates the character representing a numeric digit into an integral value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/navbar</title>
    <ns>10</ns>
    <id>8853</id>
    <revision>
      <id>40016</id>
      <parentid>37291</parentid>
      <timestamp>2012-09-28T20:19:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="250">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/regex_traits/navbar heading
|content3 = cpp/regex/regex_traits/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/navbar content</title>
    <ns>10</ns>
    <id>8855</id>
    <revision>
      <id>54640</id>
      <parentid>37293</parentid>
      <timestamp>2013-06-01T05:15:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="670">{{nv begin}}
{{nv h1 | Member Functions}}
{{nv mem ln | cpp/regex/regex_traits/regex_traits }}
{{nv mem ln | cpp/regex/regex_traits/length }}
{{nv mem ln | cpp/regex/regex_traits/translate }}
{{nv mem ln | cpp/regex/regex_traits/translate_nocase }}
{{nv mem ln | cpp/regex/regex_traits/transform }}
{{nv mem ln | cpp/regex/regex_traits/transform_primary }}
{{nv mem ln | cpp/regex/regex_traits/lookup_collatename }}
{{nv mem ln | cpp/regex/regex_traits/lookup_classname }}
{{nv mem ln | cpp/regex/regex_traits/isctype }}
{{nv mem ln | cpp/regex/regex_traits/value }}
{{nv mem ln | cpp/regex/regex_traits/imbue }}
{{nv mem ln | cpp/regex/regex_traits/getloc }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/navbar heading</title>
    <ns>10</ns>
    <id>8854</id>
    <revision>
      <id>48106</id>
      <parentid>37292</parentid>
      <timestamp>2013-05-18T18:13:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="48">{{ltt|cpp/regex/regex_traits|std::regex_traits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/regex traits/title</title>
    <ns>10</ns>
    <id>8857</id>
    <revision>
      <id>37296</id>
      <timestamp>2012-07-05T02:56:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=regex_traits::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/dsc compare</title>
    <ns>10</ns>
    <id>6393</id>
    <revision>
      <id>59571</id>
      <parentid>54641</parentid>
      <timestamp>2013-06-01T06:38:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/sub match/dcl list compare]] to [[Template:cpp/regex/sub match/dsc compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/regex/sub_match/compare | compares matched subsequence (if any)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/dsc constructor</title>
    <ns>10</ns>
    <id>6390</id>
    <revision>
      <id>59576</id>
      <parentid>54642</parentid>
      <timestamp>2013-06-01T06:38:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/sub match/dcl list constructor]] to [[Template:cpp/regex/sub match/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem ctor | cpp/regex/sub_match/sub_match | constructs the match object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/dsc length</title>
    <ns>10</ns>
    <id>6391</id>
    <revision>
      <id>59580</id>
      <parentid>54645</parentid>
      <timestamp>2013-06-01T06:38:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/sub match/dcl list length]] to [[Template:cpp/regex/sub match/dsc length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/regex/sub_match/length | returns the length of the match (if any)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/dsc operator cmp</title>
    <ns>10</ns>
    <id>3128</id>
    <revision>
      <id>61429</id>
      <parentid>61428</parentid>
      <timestamp>2013-06-06T00:18:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>ce</comment>
      <text xml:space="preserve" bytes="174">{{dsc fun | cpp/regex/sub_match/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares two {{tt|sub_match}} objects }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/dsc str</title>
    <ns>10</ns>
    <id>6392</id>
    <revision>
      <id>59584</id>
      <parentid>54648</parentid>
      <timestamp>2013-06-01T06:38:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/regex/sub match/dcl list str]] to [[Template:cpp/regex/sub match/dsc str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem fun | cpp/regex/sub_match/str | title=str&lt;br&gt;operator string_type | converts to the underlying string type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/navbar</title>
    <ns>10</ns>
    <id>2284</id>
    <revision>
      <id>47774</id>
      <parentid>40017</parentid>
      <timestamp>2013-05-16T20:26:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/regex/navbar heading
|content2 = cpp/regex/navbar content

|heading3 = cpp/regex/sub_match/navbar heading
|content3 = cpp/regex/sub_match/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/navbar content</title>
    <ns>10</ns>
    <id>3129</id>
    <revision>
      <id>54649</id>
      <parentid>35901</parentid>
      <timestamp>2013-06-01T05:15:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="611">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/regex/sub_match/sub_match | notes={{mark c++11}}}}
{{nv mem ln | cpp/regex/sub_match/length | notes={{mark c++11}}}}
{{nv mem ln | cpp/regex/sub_match/str | str | operator string_type | notes={{mark c++11}}}}
{{nv mem ln | cpp/regex/sub_match/compare | notes={{mark c++11}}}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/regex/sub_match/operator_cmp | operator{{==}}|operator!{{=}}|operator&lt;&lt;|operator&lt;{{=}}|operator&gt;|operator&gt;{{=}}| notes={{mark c++11}}}}
{{nv ln | cpp/regex/sub_match/operator_ltlt | operator&lt;&lt; | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/navbar heading</title>
    <ns>10</ns>
    <id>2285</id>
    <revision>
      <id>47761</id>
      <parentid>35902</parentid>
      <timestamp>2013-05-16T20:23:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="42">{{ltt|cpp/regex/sub_match|std::sub_match}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/sub match/title</title>
    <ns>10</ns>
    <id>3131</id>
    <revision>
      <id>12075</id>
      <timestamp>2011-10-21T14:29:56Z</timestamp>
      <contributor>
        <username>Bregma</username>
        <id>225</id>
      </contributor>
      <comment>Created template.</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=sub_match::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/regex/syntax option type consts</title>
    <ns>10</ns>
    <id>8450</id>
    <revision>
      <id>68861</id>
      <parentid>68860</parentid>
      <timestamp>2014-03-22T19:55:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2359</comment>
      <text xml:space="preserve" bytes="2341">{{dsc begin}}
{{dsc hitem | Value | Effect(s)}}
{{dsc | {{tt|icase}} |  Character matching should be performed without regard to case. }}
{{dsc | {{tt|nosubs}} |  When performing matches, all marked sub-expressions {{ttb|({{spar|expr}})}} are treated as non-marking sub-expressions {{ttb|(?:{{spar|expr}})}}. No matches are stored in the supplied {{lc|std::regex_match}} structure and {{tt|mark_count()}} is zero}}
{{dsc | {{tt|optimize}} |  Instructs the regular expression engine to make matching faster, with the potential cost of making construction slower.  For example, this might mean converting a non-deterministic FSA to a deterministic FSA. }}
{{dsc | {{tt|collate}} |  Character ranges of the form ''&quot;[a-b]&quot;'' will be locale sensitive. }}
{{dsc | {{tt|ECMAScript}} |  Use the [[cpp/regex/ecmascript|Modified ECMAScript regular expression grammar]]}} 
{{dsc | {{tt|basic}} | Use the basic POSIX regular expression grammar ([http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_03 grammar documentation]). }}
{{dsc | {{tt|extended}} | Use the extended POSIX regular expression grammar ([http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04 grammar documentation]). }}
{{dsc | {{tt|awk}} | Use the regular expression grammar used by the ''awk'' utility in POSIX ([http://pubs.opengroup.org/onlinepubs/9699919799/utilities/awk.html#tag_20_06_13_04 grammar documentation]) }}
{{dsc | {{tt|grep}} |  Use the regular expression grammar used by the ''grep'' utility in POSIX. This is effectively the same as the {{tt|basic}} option with the addition of newline '\n' as an alternation separator.  }}
{{dsc | {{tt|egrep}} | Use the regular expression grammar used by the ''grep'' utility, with the ''-E'' option, in POSIX.  This is effectively the same as the {{tt|extended}} option with the addition of newline '\n' as an alternation separator in addtion to '&lt;nowiki&gt;|&lt;/nowiki&gt;'.  }}
{{dsc end}}

At most one grammar option must be chosen out of {{tt|ECMAScript}}, {{tt|basic}}, {{tt|extended}}, {{tt|awk}}, {{tt|grep}}, {{tt|egrep}}. If no grammar is chosen, {{tt|ECMAScript}} is assumed to be selected. The other options serve as modifiers, such that {{c|std::regex(&quot;meow&quot;, std::regex::icase)}} is equivalent to {{c|std::regex(&quot;meow&quot;, std::regex::ECMAScript{{!}}std::regex::icase)}}</text>
      <sha1>pzc4qz4x572u42gs1g382t6lq3t9np9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/std</title>
    <ns>10</ns>
    <id>12776</id>
    <revision>
      <id>69475</id>
      <parentid>69406</parentid>
      <timestamp>2014-04-12T03:13:44Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>shared_mutex =&gt; shared_timed_mutex</comment>
      <text xml:space="preserve" bytes="892">&lt;onlyinclude&gt;{{#switch: {{{1|}}}
| shared_timed_mutex = {{cpp/std max|c++14|{{{2|none}}}}}
| mutex | recursive_mutex | timed_mutex | recursive_timed_mutex = {{cpp/std max|c++11|{{{2|none}}}}}
| array | forward_list = {{cpp/std max|c++11|{{{2|none}}}}}
&lt;!--
| dynarray = {{cpp/std max|c++14|{{{2|none}}}}}
--&gt;
| unordered_set | unordered_map | unordered_multiset | unordered_multimap ={{cpp/std max|c++11|{{{2|none}}}}}
| vector | list | deque | set | multiset | map | multimap ={{cpp/std max|c++98|{{{2|none}}}}}
| queue | stack | priority_queue ={{cpp/std max|c++98|{{{2|none}}}}}
| reverse_iterator | back_insert_iterator | front_insert_iterator | insert_iterator={{cpp/std max|c++98|{{{2|none}}}}}
| move_iterator={{cpp/std max|c++11|{{{2|none}}}}}
| ostream_iterator | ostreambuf_iterator | istream_iterator | istreambuf_iterator={{cpp/std max|c++98|{{{2|none}}}}}
| none
}}&lt;/onlyinclude&gt;</text>
      <sha1>17gv4czanqap04uee4cwms4d4nzemj6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/std max</title>
    <ns>10</ns>
    <id>12921</id>
    <revision>
      <id>64789</id>
      <parentid>64787</parentid>
      <timestamp>2013-08-27T00:42:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="566">&lt;onlyinclude&gt;{{#switch:{{trim|{{{1|none}}}}}{{trim|{{#if:{{{2|}}}|{{{2}}}|none}}}}
| c++98c++98=c++98
| c++03c++98=c++03
| c++11c++98=c++11
| c++14c++98=c++14
| nonec++98=none
| c++98c++03=c++03
| c++03c++03=c++03
| c++11c++03=c++11
| c++14c++03=c++14
| nonec++03=none
| c++98c++11=c++11
| c++03c++11=c++11
| c++11c++11=c++11
| c++14c++11=c++14
| nonec++11=none
| c++98c++14=c++14
| c++03c++14=c++14
| c++11c++14=c++14
| c++14c++14=c++14
| nonec++14=none
| c++98none=c++98
| c++03none=c++03
| c++11none=c++11
| c++14none=c++14
| nonenone=none
| none
}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc append</title>
    <ns>10</ns>
    <id>1674</id>
    <revision>
      <id>59588</id>
      <parentid>54653</parentid>
      <timestamp>2013-06-01T06:38:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list append]] to [[Template:cpp/string/basic string/dsc append]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/string/basic_string/append | appends characters to the end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc assign</title>
    <ns>10</ns>
    <id>1675</id>
    <revision>
      <id>59592</id>
      <parentid>54654</parentid>
      <timestamp>2013-06-01T06:38:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list assign]] to [[Template:cpp/string/basic string/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/string/basic_string/assign |  assign characters to a string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc at</title>
    <ns>10</ns>
    <id>1676</id>
    <revision>
      <id>59595</id>
      <parentid>54657</parentid>
      <timestamp>2013-06-01T06:38:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list at]] to [[Template:cpp/string/basic string/dsc at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/string/basic_string/at |  access specified character with bounds checking}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc back</title>
    <ns>10</ns>
    <id>1677</id>
    <revision>
      <id>59600</id>
      <parentid>54658</parentid>
      <timestamp>2013-06-01T06:38:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list back]] to [[Template:cpp/string/basic string/dsc back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/string/basic_string/back | notes={{mark c++11}} | accesses the last character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc begin</title>
    <ns>10</ns>
    <id>1678</id>
    <revision>
      <id>59603</id>
      <parentid>54661</parentid>
      <timestamp>2013-06-01T06:38:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list begin]] to [[Template:cpp/string/basic string/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc mem fun | cpp/string/basic_string/begin | title=begin&lt;br&gt;cbegin | returns an iterator to the beginning | notes=&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc c str</title>
    <ns>10</ns>
    <id>1679</id>
    <revision>
      <id>59607</id>
      <parentid>54662</parentid>
      <timestamp>2013-06-01T06:38:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list c str]] to [[Template:cpp/string/basic string/dsc c str]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/string/basic_string/c_str | returns a non-modifiable standard C character array version of the string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc capacity</title>
    <ns>10</ns>
    <id>1680</id>
    <revision>
      <id>59611</id>
      <parentid>54663</parentid>
      <timestamp>2013-06-01T06:38:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list capacity]] to [[Template:cpp/string/basic string/dsc capacity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="134">{{dsc mem fun | cpp/string/basic_string/capacity | returns the number of characters that can be held in currently allocated storage }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc clear</title>
    <ns>10</ns>
    <id>1681</id>
    <revision>
      <id>59616</id>
      <parentid>54664</parentid>
      <timestamp>2013-06-01T06:38:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list clear]] to [[Template:cpp/string/basic string/dsc clear]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/string/basic_string/clear | clears the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc compare</title>
    <ns>10</ns>
    <id>1682</id>
    <revision>
      <id>59620</id>
      <parentid>54667</parentid>
      <timestamp>2013-06-01T06:39:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list compare]] to [[Template:cpp/string/basic string/dsc compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/string/basic_string/compare | compares two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc constructor</title>
    <ns>10</ns>
    <id>1683</id>
    <revision>
      <id>59624</id>
      <parentid>54670</parentid>
      <timestamp>2013-06-01T06:39:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list constructor]] to [[Template:cpp/string/basic string/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem ctor | cpp/string/basic_string/basic_string | constructs a {{tt|basic_string}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc copy</title>
    <ns>10</ns>
    <id>1684</id>
    <revision>
      <id>59628</id>
      <parentid>54671</parentid>
      <timestamp>2013-06-01T06:39:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list copy]] to [[Template:cpp/string/basic string/dsc copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">{{dsc mem fun | cpp/string/basic_string/copy | copies characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc data</title>
    <ns>10</ns>
    <id>1685</id>
    <revision>
      <id>59633</id>
      <parentid>54672</parentid>
      <timestamp>2013-06-01T06:39:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list data]] to [[Template:cpp/string/basic string/dsc data]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/string/basic_string/data | returns a pointer to the first character of a string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc empty</title>
    <ns>10</ns>
    <id>1686</id>
    <revision>
      <id>59637</id>
      <parentid>54673</parentid>
      <timestamp>2013-06-01T06:39:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list empty]] to [[Template:cpp/string/basic string/dsc empty]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/string/basic_string/empty | checks whether the string is empty }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc end</title>
    <ns>10</ns>
    <id>1687</id>
    <revision>
      <id>59642</id>
      <parentid>54678</parentid>
      <timestamp>2013-06-01T06:39:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list end]] to [[Template:cpp/string/basic string/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/string/basic_string/end | title=end &lt;br&gt;cend | returns an iterator to the end | notes=&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc erase</title>
    <ns>10</ns>
    <id>1688</id>
    <revision>
      <id>59646</id>
      <parentid>54679</parentid>
      <timestamp>2013-06-01T06:39:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list erase]] to [[Template:cpp/string/basic string/dsc erase]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/string/basic_string/erase | removes characters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc find</title>
    <ns>10</ns>
    <id>1689</id>
    <revision>
      <id>59650</id>
      <parentid>54680</parentid>
      <timestamp>2013-06-01T06:39:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list find]] to [[Template:cpp/string/basic string/dsc find]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/string/basic_string/find | find characters in the string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc find first not of</title>
    <ns>10</ns>
    <id>1690</id>
    <revision>
      <id>59655</id>
      <parentid>54681</parentid>
      <timestamp>2013-06-01T06:39:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list find first not of]] to [[Template:cpp/string/basic string/dsc find first not of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/string/basic_string/find_first_not_of | find first absence of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc find first of</title>
    <ns>10</ns>
    <id>1691</id>
    <revision>
      <id>59659</id>
      <parentid>54682</parentid>
      <timestamp>2013-06-01T06:39:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list find first of]] to [[Template:cpp/string/basic string/dsc find first of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | cpp/string/basic_string/find_first_of | find first occurrence of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc find last not of</title>
    <ns>10</ns>
    <id>1692</id>
    <revision>
      <id>59664</id>
      <parentid>54685</parentid>
      <timestamp>2013-06-01T06:39:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list find last not of]] to [[Template:cpp/string/basic string/dsc find last not of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/string/basic_string/find_last_not_of | find last absence of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc find last of</title>
    <ns>10</ns>
    <id>1693</id>
    <revision>
      <id>59669</id>
      <parentid>54688</parentid>
      <timestamp>2013-06-01T06:39:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list find last of]] to [[Template:cpp/string/basic string/dsc find last of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/string/basic_string/find_last_of | find last occurrence of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc front</title>
    <ns>10</ns>
    <id>1694</id>
    <revision>
      <id>59673</id>
      <parentid>54689</parentid>
      <timestamp>2013-06-01T06:39:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list front]] to [[Template:cpp/string/basic string/dsc front]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/string/basic_string/front | notes={{mark c++11}} | accesses the first character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc get allocator</title>
    <ns>10</ns>
    <id>1695</id>
    <revision>
      <id>59677</id>
      <parentid>54690</parentid>
      <timestamp>2013-06-01T06:39:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list get allocator]] to [[Template:cpp/string/basic string/dsc get allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/string/basic_string/get_allocator | returns the associated allocator }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc getline</title>
    <ns>10</ns>
    <id>9541</id>
    <revision>
      <id>59682</id>
      <parentid>54697</parentid>
      <timestamp>2013-06-01T06:39:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list getline]] to [[Template:cpp/string/basic string/dsc getline]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/string/basic_string/getline | read data from an I/O stream into a string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc hash</title>
    <ns>10</ns>
    <id>4744</id>
    <revision>
      <id>59685</id>
      <parentid>54702</parentid>
      <timestamp>2013-06-01T06:39:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list hash]] to [[Template:cpp/string/basic string/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="323">{{dsc ptclass | cpp/string/basic_string/hash | title=std::hash{{dsc small|&lt;std::string&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::u16string&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::u32string&gt;}}&lt;br&gt;std::hash{{dsc small|&lt;std::wstring&gt;}} | hash support for strings | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc insert</title>
    <ns>10</ns>
    <id>1696</id>
    <revision>
      <id>59690</id>
      <parentid>54703</parentid>
      <timestamp>2013-06-01T06:40:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list insert]] to [[Template:cpp/string/basic string/dsc insert]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/string/basic_string/insert | inserts characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc max size</title>
    <ns>10</ns>
    <id>1698</id>
    <revision>
      <id>59695</id>
      <parentid>54704</parentid>
      <timestamp>2013-06-01T06:40:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list max size]] to [[Template:cpp/string/basic string/dsc max size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/string/basic_string/max_size | returns the maximum number of characters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc npos</title>
    <ns>10</ns>
    <id>1699</id>
    <revision>
      <id>59699</id>
      <parentid>54707</parentid>
      <timestamp>2013-06-01T06:40:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list npos]] to [[Template:cpp/string/basic string/dsc npos]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem sconst | cpp/string/basic_string/npos | special value. The exact meaning depends on the context}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator&quot;&quot;</title>
    <ns>10</ns>
    <id>10125</id>
    <revision>
      <id>59703</id>
      <parentid>54708</parentid>
      <timestamp>2013-06-01T06:40:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator&quot;&quot;]] to [[Template:cpp/string/basic string/dsc operator&quot;&quot;]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/string/basic_string/operator&quot;&quot; | Returns a basic_string from a null-terminated string | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator&quot;&quot;s</title>
    <ns>10</ns>
    <id>10126</id>
    <revision>
      <id>64654</id>
      <parentid>61094</parentid>
      <timestamp>2013-08-24T14:51:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>null-terminatedness is misleading (regular ctor cares about null term, op&quot;&quot;s doesn't)</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | cpp/string/basic_string/operator&quot;&quot;s | Converts a character array literal to {{tt|basic_string}} | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator+</title>
    <ns>10</ns>
    <id>9539</id>
    <revision>
      <id>59711</id>
      <parentid>54712</parentid>
      <timestamp>2013-06-01T06:40:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator+]] to [[Template:cpp/string/basic string/dsc operator+]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tfun | cpp/string/basic_string/operator+ | concatenates two strings or a string and a char }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator+=</title>
    <ns>10</ns>
    <id>1700</id>
    <revision>
      <id>59715</id>
      <parentid>54713</parentid>
      <timestamp>2013-06-01T06:40:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator+=]] to [[Template:cpp/string/basic string/dsc operator+=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem fun | cpp/string/basic_string/operator+{{=}} | appends characters to the end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator=</title>
    <ns>10</ns>
    <id>1701</id>
    <revision>
      <id>59718</id>
      <parentid>54716</parentid>
      <timestamp>2013-06-01T06:40:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator=]] to [[Template:cpp/string/basic string/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc mem fun | cpp/string/basic_string/operator{{=}} | assigns values to the string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator at</title>
    <ns>10</ns>
    <id>1702</id>
    <revision>
      <id>59720</id>
      <parentid>54717</parentid>
      <timestamp>2013-06-01T06:40:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator at]] to [[Template:cpp/string/basic string/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/string/basic_string/operator_at|title=operator[] |  access specified character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator cmp</title>
    <ns>10</ns>
    <id>5160</id>
    <revision>
      <id>59722</id>
      <parentid>54718</parentid>
      <timestamp>2013-06-01T06:40:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator cmp]] to [[Template:cpp/string/basic string/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="180">{{dsc tfun | cpp/string/basic_string/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&gt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;= | lexicographically compares two strings }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>9540</id>
    <revision>
      <id>59724</id>
      <parentid>54719</parentid>
      <timestamp>2013-06-01T06:40:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list operator ltltgtgt]] to [[Template:cpp/string/basic string/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tfun | cpp/string/basic_string/operator_ltltgtgt | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output on strings }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc pop back</title>
    <ns>10</ns>
    <id>1703</id>
    <revision>
      <id>59726</id>
      <parentid>54722</parentid>
      <timestamp>2013-06-01T06:40:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list pop back]] to [[Template:cpp/string/basic string/dsc pop back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/string/basic_string/pop_back | removes the last character | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc push back</title>
    <ns>10</ns>
    <id>1704</id>
    <revision>
      <id>59728</id>
      <parentid>54723</parentid>
      <timestamp>2013-06-01T06:40:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list push back]] to [[Template:cpp/string/basic string/dsc push back]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/string/basic_string/push_back | appends a character to the end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc rbegin</title>
    <ns>10</ns>
    <id>1705</id>
    <revision>
      <id>59730</id>
      <parentid>54726</parentid>
      <timestamp>2013-06-01T06:40:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list rbegin]] to [[Template:cpp/string/basic string/dsc rbegin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="149">{{dsc mem fun | cpp/string/basic_string/rbegin | title=rbegin&lt;br&gt; crbegin | returns a reverse iterator to the beginning | notes=&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc rend</title>
    <ns>10</ns>
    <id>1706</id>
    <revision>
      <id>59732</id>
      <parentid>54727</parentid>
      <timestamp>2013-06-01T06:40:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list rend]] to [[Template:cpp/string/basic string/dsc rend]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc mem fun | cpp/string/basic_string/rend | title=rend&lt;br&gt; crend | returns a reverse iterator to the end | notes=&lt;br&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc replace</title>
    <ns>10</ns>
    <id>1707</id>
    <revision>
      <id>59734</id>
      <parentid>54728</parentid>
      <timestamp>2013-06-01T06:40:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list replace]] to [[Template:cpp/string/basic string/dsc replace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/string/basic_string/replace | replaces specified portion of a string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc reserve</title>
    <ns>10</ns>
    <id>1708</id>
    <revision>
      <id>59736</id>
      <parentid>54731</parentid>
      <timestamp>2013-06-01T06:40:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list reserve]] to [[Template:cpp/string/basic string/dsc reserve]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/string/basic_string/reserve | reserves storage }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc resize</title>
    <ns>10</ns>
    <id>1709</id>
    <revision>
      <id>59738</id>
      <parentid>54732</parentid>
      <timestamp>2013-06-01T06:40:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list resize]] to [[Template:cpp/string/basic string/dsc resize]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/string/basic_string/resize | changes the number of characters stored }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc rfind</title>
    <ns>10</ns>
    <id>1710</id>
    <revision>
      <id>59740</id>
      <parentid>54733</parentid>
      <timestamp>2013-06-01T06:40:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list rfind]] to [[Template:cpp/string/basic string/dsc rfind]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/string/basic_string/rfind | find the last occurrence of a substring}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc shrink to fit</title>
    <ns>10</ns>
    <id>1711</id>
    <revision>
      <id>59742</id>
      <parentid>54734</parentid>
      <timestamp>2013-06-01T06:40:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list shrink to fit]] to [[Template:cpp/string/basic string/dsc shrink to fit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/string/basic_string/shrink_to_fit | reduces memory usage by freeing unused memory | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc size</title>
    <ns>10</ns>
    <id>1712</id>
    <revision>
      <id>59744</id>
      <parentid>54737</parentid>
      <timestamp>2013-06-01T06:40:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list size]] to [[Template:cpp/string/basic string/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/string/basic_string/size | title=size&lt;br/&gt;length | returns the number of characters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc stof</title>
    <ns>10</ns>
    <id>2153</id>
    <revision>
      <id>66444</id>
      <parentid>59746</parentid>
      <timestamp>2013-11-22T12:02:00Z</timestamp>
      <contributor>
        <ip>46.252.142.242</ip>
      </contributor>
      <comment>fix a typo</comment>
      <text xml:space="preserve" bytes="178">{{dsc fun | cpp/string/basic_string/stof | title=stof&lt;br&gt;stod&lt;br&gt;stold | converts a string to a floating point value | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}</text>
      <sha1>qeiqn8nf6hql51srz3kx3guu94gkg9i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc stol</title>
    <ns>10</ns>
    <id>2469</id>
    <revision>
      <id>66443</id>
      <parentid>59748</parentid>
      <timestamp>2013-11-22T11:59:35Z</timestamp>
      <contributor>
        <ip>46.252.142.242</ip>
      </contributor>
      <comment>fix a typo</comment>
      <text xml:space="preserve" bytes="171">{{dsc fun | cpp/string/basic_string/stol | title=stoi&lt;br&gt;stol&lt;br&gt;stoll | converts a string to a signed integer | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1>amg4i3h44t7qzgt8zk70wnpi51ieqnx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc stoul</title>
    <ns>10</ns>
    <id>2470</id>
    <revision>
      <id>59750</id>
      <parentid>54744</parentid>
      <timestamp>2013-06-01T06:40:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list stoul]] to [[Template:cpp/string/basic string/dsc stoul]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc fun | cpp/string/basic_string/stoul | title=stoul&lt;br&gt;stoull | converts a string to an unsigned integer | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc substr</title>
    <ns>10</ns>
    <id>1713</id>
    <revision>
      <id>59752</id>
      <parentid>54745</parentid>
      <timestamp>2013-06-01T06:40:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list substr]] to [[Template:cpp/string/basic string/dsc substr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/string/basic_string/substr | returns a substring}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc swap</title>
    <ns>10</ns>
    <id>1714</id>
    <revision>
      <id>59754</id>
      <parentid>54746</parentid>
      <timestamp>2013-06-01T06:40:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list swap]] to [[Template:cpp/string/basic string/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc mem fun | cpp/string/basic_string/swap | swaps the contents }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc swap2</title>
    <ns>10</ns>
    <id>3447</id>
    <revision>
      <id>59756</id>
      <parentid>54753</parentid>
      <timestamp>2013-06-01T06:40:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list swap2]] to [[Template:cpp/string/basic string/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tfun | cpp/string/basic_string/swap2 | title=std::swap{{dsc small|(std::basic_string)}} | specializes the {{lc|std::swap}} algorithm}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc to string</title>
    <ns>10</ns>
    <id>2154</id>
    <revision>
      <id>59758</id>
      <parentid>54754</parentid>
      <timestamp>2013-06-01T06:40:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list to string]] to [[Template:cpp/string/basic string/dsc to string]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc fun | cpp/string/basic_string/to_string | converts an integral or floating point value to {{tt|string}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/dsc to wstring</title>
    <ns>10</ns>
    <id>2155</id>
    <revision>
      <id>59760</id>
      <parentid>54755</parentid>
      <timestamp>2013-06-01T06:40:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/dcl list to wstring]] to [[Template:cpp/string/basic string/dsc to wstring]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc fun | cpp/string/basic_string/to_wstring | converts an integral or floating point value to {{tt|wstring}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/navbar</title>
    <ns>10</ns>
    <id>1715</id>
    <revision>
      <id>40018</id>
      <parentid>35907</parentid>
      <timestamp>2012-09-28T20:19:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="255">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content

|heading3 = cpp/string/basic_string/navbar heading
|content3 = cpp/string/basic_string/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/navbar content</title>
    <ns>10</ns>
    <id>1716</id>
    <revision>
      <id>63271</id>
      <parentid>54758</parentid>
      <timestamp>2013-07-08T21:15:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="3619">{{nv begin}}
{{nv col begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/string/basic_string/basic_string}}
{{nv mem ln | cpp/string/basic_string/operator{{=}}}}
{{nv mem ln | cpp/string/basic_string/assign}}
{{nv mem ln | cpp/string/basic_string/get_allocator}}

{{nv h2 | Element access}}
{{nv mem ln | cpp/string/basic_string/at}}
{{nv mem ln | cpp/string/basic_string/operator_at | operator[]}}
{{nv mem ln | cpp/string/basic_string/front | notes={{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/back | notes={{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/data}}
{{nv mem ln | cpp/string/basic_string/c_str}}

{{nv h2 | Iterators}}
{{nv mem ln | cpp/string/basic_string/begin | begin | cbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/end | end | cend | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/rbegin | rbegin | crbegin | notes=&lt;br&gt;{{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/rend | rend | crend | notes=&lt;br&gt;{{mark c++11}}}}

{{nv h2 | Capacity}}
{{nv mem ln | cpp/string/basic_string/empty}}
{{nv mem ln | cpp/string/basic_string/size | size | length}}
{{nv mem ln | cpp/string/basic_string/max_size}}
{{nv mem ln | cpp/string/basic_string/reserve}}
{{nv mem ln | cpp/string/basic_string/capacity}}
{{nv mem ln | cpp/string/basic_string/shrink_to_fit | notes={{mark c++11}}}}

{{nv col next}}

{{nv h2 | Operations}}
{{nv mem ln | cpp/string/basic_string/clear}}
{{nv mem ln | cpp/string/basic_string/insert}}
{{nv mem ln | cpp/string/basic_string/erase}}
{{nv mem ln | cpp/string/basic_string/push_back}}
{{nv mem ln | cpp/string/basic_string/pop_back | notes={{mark c++11}}}}
{{nv mem ln | cpp/string/basic_string/append}}
{{nv mem ln | cpp/string/basic_string/operator+{{=}}}}
{{nv mem ln | cpp/string/basic_string/compare}}
{{nv mem ln | cpp/string/basic_string/replace}}
{{nv mem ln | cpp/string/basic_string/substr}}
{{nv mem ln | cpp/string/basic_string/copy}}
{{nv mem ln | cpp/string/basic_string/resize}}
{{nv mem ln | cpp/string/basic_string/swap}}

{{nv h2 | Search}}
{{nv mem ln | cpp/string/basic_string/find}}
{{nv mem ln | cpp/string/basic_string/rfind}}
{{nv mem ln | cpp/string/basic_string/find_first_of}}
{{nv mem ln | cpp/string/basic_string/find_first_not_of}}
{{nv mem ln | cpp/string/basic_string/find_last_of}}
{{nv mem ln | cpp/string/basic_string/find_last_not_of}}

{{nv h1 | Constants}}
{{nv mem ln | cpp/string/basic_string/npos}}

{{nv col next}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/string/basic_string/operator+}}
{{nv ln | cpp/string/basic_string/operator_cmp|operator{{==}}|operator!{{=}}|operator&lt;|operator&gt;|operator&lt;{{=}}|operator&gt;{{=}} }}
{{nv ln | cpp/string/basic_string/swap2|swap{{dsc small|(std::basic_string)}} }}
{{nv ln | cpp/string/basic_string/operator_ltltgtgt|operator&lt;&lt;|operator&gt;&gt;}}
{{nv ln | cpp/string/basic_string/getline}}
{{nv ln | cpp/string/basic_string/stol | stoi | stol | stoll | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/string/basic_string/stoul | stoul | stoull | notes={{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/string/basic_string/stof | stof | stod | stold | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}} }}
{{nv ln | cpp/string/basic_string/to_string | notes={{mark c++11}} }}
{{nv ln | cpp/string/basic_string/to_wstring | notes={{mark c++11}} }}
{{nv h1 | Helper classes}}
{{nv ln | cpp/string/basic_string/hash | hash{{dsc small|&lt;std::string&gt;}}| hash{{dsc small|&lt;std::wstring&gt;}} | hash{{dsc small|&lt;std::u32string&gt;}} | hash{{dsc small|&lt;std::u16string&gt;}} | notes={{mark c++11}} }}
{{nv col end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/navbar heading</title>
    <ns>10</ns>
    <id>1717</id>
    <revision>
      <id>35467</id>
      <parentid>3434</parentid>
      <timestamp>2012-06-15T22:25:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/basic string/sidebar heading]] to [[Template:cpp/string/basic string/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/string/basic_string | std::basic_string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/basic string/title</title>
    <ns>10</ns>
    <id>1718</id>
    <revision>
      <id>3436</id>
      <parentid>3435</parentid>
      <timestamp>2011-06-06T22:58:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=basic_string::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc atof</title>
    <ns>10</ns>
    <id>1725</id>
    <revision>
      <id>59762</id>
      <parentid>54759</parentid>
      <timestamp>2013-06-01T06:41:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list atof]] to [[Template:cpp/string/byte/dsc atof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | cpp/string/byte/atof | converts a byte string to a floating point value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc atoi</title>
    <ns>10</ns>
    <id>1726</id>
    <revision>
      <id>59764</id>
      <parentid>54762</parentid>
      <timestamp>2013-06-01T06:41:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list atoi]] to [[Template:cpp/string/byte/dsc atoi]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/string/byte/atoi | title=atoi&lt;br&gt;atol&lt;br&gt;atoll | converts a byte string to an integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isalnum</title>
    <ns>10</ns>
    <id>1727</id>
    <revision>
      <id>59766</id>
      <parentid>54763</parentid>
      <timestamp>2013-06-01T06:41:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isalnum]] to [[Template:cpp/string/byte/dsc isalnum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | cpp/string/byte/isalnum | checks if a character is alphanumeric}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isalpha</title>
    <ns>10</ns>
    <id>1728</id>
    <revision>
      <id>59768</id>
      <parentid>54766</parentid>
      <timestamp>2013-06-01T06:41:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isalpha]] to [[Template:cpp/string/byte/dsc isalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | cpp/string/byte/isalpha | checks if a character is alphabetic}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isblank</title>
    <ns>10</ns>
    <id>2929</id>
    <revision>
      <id>59770</id>
      <parentid>54767</parentid>
      <timestamp>2013-06-01T06:41:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isblank]] to [[Template:cpp/string/byte/dsc isblank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc fun | cpp/string/byte/isblank | checks if a character is a blank character | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc iscntrl</title>
    <ns>10</ns>
    <id>1729</id>
    <revision>
      <id>59772</id>
      <parentid>54770</parentid>
      <timestamp>2013-06-01T06:41:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list iscntrl]] to [[Template:cpp/string/byte/dsc iscntrl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | cpp/string/byte/iscntrl | checks if a character is a control character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isdigit</title>
    <ns>10</ns>
    <id>1730</id>
    <revision>
      <id>59774</id>
      <parentid>54771</parentid>
      <timestamp>2013-06-01T06:41:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isdigit]] to [[Template:cpp/string/byte/dsc isdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | cpp/string/byte/isdigit | checks if a character is a digit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isgraph</title>
    <ns>10</ns>
    <id>1731</id>
    <revision>
      <id>59776</id>
      <parentid>54772</parentid>
      <timestamp>2013-06-01T06:41:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isgraph]] to [[Template:cpp/string/byte/dsc isgraph]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc fun | cpp/string/byte/isgraph | checks if a character is a graphical character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc islower</title>
    <ns>10</ns>
    <id>1732</id>
    <revision>
      <id>59778</id>
      <parentid>54775</parentid>
      <timestamp>2013-06-01T06:41:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list islower]] to [[Template:cpp/string/byte/dsc islower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/string/byte/islower | checks if a character is lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isprint</title>
    <ns>10</ns>
    <id>1733</id>
    <revision>
      <id>59780</id>
      <parentid>54776</parentid>
      <timestamp>2013-06-01T06:41:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isprint]] to [[Template:cpp/string/byte/dsc isprint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc fun | cpp/string/byte/isprint | checks if a character is a printing character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc ispunct</title>
    <ns>10</ns>
    <id>1734</id>
    <revision>
      <id>59782</id>
      <parentid>54779</parentid>
      <timestamp>2013-06-01T06:41:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list ispunct]] to [[Template:cpp/string/byte/dsc ispunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/string/byte/ispunct | checks if a character is a punctuation character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isspace</title>
    <ns>10</ns>
    <id>1735</id>
    <revision>
      <id>59784</id>
      <parentid>54780</parentid>
      <timestamp>2013-06-01T06:41:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isspace]] to [[Template:cpp/string/byte/dsc isspace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc fun | cpp/string/byte/isspace | checks if a character is a space character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isupper</title>
    <ns>10</ns>
    <id>1736</id>
    <revision>
      <id>59786</id>
      <parentid>54781</parentid>
      <timestamp>2013-06-01T06:41:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isupper]] to [[Template:cpp/string/byte/dsc isupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | cpp/string/byte/isupper | checks if a character is an uppercase character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc isxdigit</title>
    <ns>10</ns>
    <id>1737</id>
    <revision>
      <id>59788</id>
      <parentid>54782</parentid>
      <timestamp>2013-06-01T06:41:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list isxdigit]] to [[Template:cpp/string/byte/dsc isxdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc fun | cpp/string/byte/isxdigit | checks if a character is a hexadecimal character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc memchr</title>
    <ns>10</ns>
    <id>1738</id>
    <revision>
      <id>59790</id>
      <parentid>54785</parentid>
      <timestamp>2013-06-01T06:41:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list memchr]] to [[Template:cpp/string/byte/dsc memchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/string/byte/memchr | searches an array for the first occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc memcmp</title>
    <ns>10</ns>
    <id>1739</id>
    <revision>
      <id>59792</id>
      <parentid>54790</parentid>
      <timestamp>2013-06-01T06:41:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list memcmp]] to [[Template:cpp/string/byte/dsc memcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">{{dsc fun | cpp/string/byte/memcmp | compares two buffers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc memcpy</title>
    <ns>10</ns>
    <id>1740</id>
    <revision>
      <id>59794</id>
      <parentid>54795</parentid>
      <timestamp>2013-06-01T06:41:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list memcpy]] to [[Template:cpp/string/byte/dsc memcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc fun | cpp/string/byte/memcpy | copies one buffer to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc memmove</title>
    <ns>10</ns>
    <id>1741</id>
    <revision>
      <id>59796</id>
      <parentid>54798</parentid>
      <timestamp>2013-06-01T06:41:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list memmove]] to [[Template:cpp/string/byte/dsc memmove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc fun | cpp/string/byte/memmove | moves one buffer to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc memset</title>
    <ns>10</ns>
    <id>1742</id>
    <revision>
      <id>59798</id>
      <parentid>54801</parentid>
      <timestamp>2013-06-01T06:41:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list memset]] to [[Template:cpp/string/byte/dsc memset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc fun | cpp/string/byte/memset | fills a buffer with a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strcat</title>
    <ns>10</ns>
    <id>1743</id>
    <revision>
      <id>59800</id>
      <parentid>54802</parentid>
      <timestamp>2013-06-01T06:41:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strcat]] to [[Template:cpp/string/byte/dsc strcat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">{{dsc fun | cpp/string/byte/strcat | concatenates two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strchr</title>
    <ns>10</ns>
    <id>1744</id>
    <revision>
      <id>59802</id>
      <parentid>54803</parentid>
      <timestamp>2013-06-01T06:41:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strchr]] to [[Template:cpp/string/byte/dsc strchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | cpp/string/byte/strchr | finds the first occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strcmp</title>
    <ns>10</ns>
    <id>1745</id>
    <revision>
      <id>59804</id>
      <parentid>54804</parentid>
      <timestamp>2013-06-01T06:41:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strcmp]] to [[Template:cpp/string/byte/dsc strcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">{{dsc fun | cpp/string/byte/strcmp | compares two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strcoll</title>
    <ns>10</ns>
    <id>1746</id>
    <revision>
      <id>59806</id>
      <parentid>54807</parentid>
      <timestamp>2013-06-01T06:41:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strcoll]] to [[Template:cpp/string/byte/dsc strcoll]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc fun | cpp/string/byte/strcoll | compares two strings in accordance to the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strcpy</title>
    <ns>10</ns>
    <id>1747</id>
    <revision>
      <id>59808</id>
      <parentid>54810</parentid>
      <timestamp>2013-06-01T06:41:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strcpy]] to [[Template:cpp/string/byte/dsc strcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc fun | cpp/string/byte/strcpy | copies one string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strcspn</title>
    <ns>10</ns>
    <id>1748</id>
    <revision>
      <id>59810</id>
      <parentid>54811</parentid>
      <timestamp>2013-06-01T06:41:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strcspn]] to [[Template:cpp/string/byte/dsc strcspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc fun | cpp/string/byte/strcspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the characters not found in another byte string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strerror</title>
    <ns>10</ns>
    <id>2</id>
    <revision>
      <id>59812</id>
      <parentid>54812</parentid>
      <timestamp>2013-06-01T06:41:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strerror]] to [[Template:cpp/string/byte/dsc strerror]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc fun | cpp/string/byte/strerror | returns a text version of a given error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strlen</title>
    <ns>10</ns>
    <id>3</id>
    <revision>
      <id>59814</id>
      <parentid>54813</parentid>
      <timestamp>2013-06-01T06:41:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strlen]] to [[Template:cpp/string/byte/dsc strlen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc fun | cpp/string/byte/strlen | returns the length of a given string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strncat</title>
    <ns>10</ns>
    <id>4</id>
    <revision>
      <id>59816</id>
      <parentid>54820</parentid>
      <timestamp>2013-06-01T06:41:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strncat]] to [[Template:cpp/string/byte/dsc strncat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc fun | cpp/string/byte/strncat | concatenates a certain amount of characters of two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strncmp</title>
    <ns>10</ns>
    <id>5</id>
    <revision>
      <id>59818</id>
      <parentid>54825</parentid>
      <timestamp>2013-06-01T06:41:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strncmp]] to [[Template:cpp/string/byte/dsc strncmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/string/byte/strncmp | compares a certain amount of characters of two strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strncpy</title>
    <ns>10</ns>
    <id>6</id>
    <revision>
      <id>59820</id>
      <parentid>54830</parentid>
      <timestamp>2013-06-01T06:41:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strncpy]] to [[Template:cpp/string/byte/dsc strncpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc fun | cpp/string/byte/strncpy | copies a certain amount of characters from one string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strpbrk</title>
    <ns>10</ns>
    <id>7</id>
    <revision>
      <id>59822</id>
      <parentid>54831</parentid>
      <timestamp>2013-06-01T06:41:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strpbrk]] to [[Template:cpp/string/byte/dsc strpbrk]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | cpp/string/byte/strpbrk | finds the first location of any character in one string, in another string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strrchr</title>
    <ns>10</ns>
    <id>8</id>
    <revision>
      <id>59824</id>
      <parentid>54832</parentid>
      <timestamp>2013-06-01T06:41:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strrchr]] to [[Template:cpp/string/byte/dsc strrchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | cpp/string/byte/strrchr | finds the last occurrence of a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strspn</title>
    <ns>10</ns>
    <id>9</id>
    <revision>
      <id>59826</id>
      <parentid>54835</parentid>
      <timestamp>2013-06-01T06:41:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strspn]] to [[Template:cpp/string/byte/dsc strspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc fun | cpp/string/byte/strspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the characters found in another byte string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strstr</title>
    <ns>10</ns>
    <id>10</id>
    <revision>
      <id>59828</id>
      <parentid>54836</parentid>
      <timestamp>2013-06-01T06:41:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strstr]] to [[Template:cpp/string/byte/dsc strstr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/string/byte/strstr | finds the first occurrence of a substring of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strtof</title>
    <ns>10</ns>
    <id>11</id>
    <revision>
      <id>59830</id>
      <parentid>54839</parentid>
      <timestamp>2013-06-01T06:41:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strtof]] to [[Template:cpp/string/byte/dsc strtof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc fun | cpp/string/byte/strtof | title=strtof&lt;br&gt;strtod&lt;br&gt;strtold | converts a byte string to a floating point value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strtoimax</title>
    <ns>10</ns>
    <id>3659</id>
    <revision>
      <id>59832</id>
      <parentid>54840</parentid>
      <timestamp>2013-06-01T06:41:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strtoimax]] to [[Template:cpp/string/byte/dsc strtoimax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="184">{{dsc fun | cpp/string/byte/strtoimax| title=strtoimax&lt;br&gt;strtoumax | converts a byte string to {{lc|std::intmax_t}} or {{lc|std::uintmax_t}} | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strtok</title>
    <ns>10</ns>
    <id>12</id>
    <revision>
      <id>59834</id>
      <parentid>54841</parentid>
      <timestamp>2013-06-01T06:41:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strtok]] to [[Template:cpp/string/byte/dsc strtok]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc fun | cpp/string/byte/strtok | finds the next token in a byte string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strtol</title>
    <ns>10</ns>
    <id>13</id>
    <revision>
      <id>59836</id>
      <parentid>54844</parentid>
      <timestamp>2013-06-01T06:41:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strtol]] to [[Template:cpp/string/byte/dsc strtol]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc fun | cpp/string/byte/strtol | title=strtol&lt;br&gt;strtoll | converts a byte string to an integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strtoul</title>
    <ns>10</ns>
    <id>14</id>
    <revision>
      <id>59838</id>
      <parentid>54845</parentid>
      <timestamp>2013-06-01T06:41:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strtoul]] to [[Template:cpp/string/byte/dsc strtoul]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | cpp/string/byte/strtoul| title=strtoul&lt;br&gt; strtoull | converts a byte string to an unsigned integer value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc strxfrm</title>
    <ns>10</ns>
    <id>15</id>
    <revision>
      <id>59840</id>
      <parentid>54848</parentid>
      <timestamp>2013-06-01T06:41:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list strxfrm]] to [[Template:cpp/string/byte/dsc strxfrm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc fun | cpp/string/byte/strxfrm | transform a string so that strcmp would produce the same result as strcoll }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc tolower</title>
    <ns>10</ns>
    <id>16</id>
    <revision>
      <id>59842</id>
      <parentid>54851</parentid>
      <timestamp>2013-06-01T06:41:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list tolower]] to [[Template:cpp/string/byte/dsc tolower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/string/byte/tolower | converts a character to lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/dsc toupper</title>
    <ns>10</ns>
    <id>17</id>
    <revision>
      <id>59844</id>
      <parentid>54854</parentid>
      <timestamp>2013-06-01T06:41:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/dcl list toupper]] to [[Template:cpp/string/byte/dsc toupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc fun | cpp/string/byte/toupper | converts a character to uppercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/navbar</title>
    <ns>10</ns>
    <id>18</id>
    <revision>
      <id>40019</id>
      <parentid>35753</parentid>
      <timestamp>2012-09-28T20:19:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="237">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content

|heading3 = cpp/string/byte/navbar heading
|content3 = cpp/string/byte/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/navbar content</title>
    <ns>10</ns>
    <id>19</id>
    <revision>
      <id>54855</id>
      <parentid>35909</parentid>
      <timestamp>2013-06-01T05:17:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1943">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | Character manipulation}}
{{nv col begin}}
{{nv ln | cpp/string/byte/isalnum}}
{{nv ln | cpp/string/byte/isalpha}}
{{nv ln | cpp/string/byte/islower}}
{{nv ln | cpp/string/byte/isupper}}
{{nv ln | cpp/string/byte/isdigit}}
{{nv ln | cpp/string/byte/isxdigit}}
{{nv ln | cpp/string/byte/isblank|notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/string/byte/iscntrl}}
{{nv ln | cpp/string/byte/isgraph}}
{{nv ln | cpp/string/byte/isspace}}
{{nv ln | cpp/string/byte/isprint}}
{{nv ln | cpp/string/byte/ispunct}}
{{nv ln | cpp/string/byte/tolower}}
{{nv ln | cpp/string/byte/toupper}}
{{nv col end}}

{{nv h2 | Conversions to numeric formats}}
{{nv col begin}}
{{nv ln | cpp/string/byte/atof}}
{{nv ln | cpp/string/byte/atoi|atoi|atol|atoll}}
{{nv ln | cpp/string/byte/strtol|strtol|strtoll}}
{{nv col next}}
{{nv ln | cpp/string/byte/strtoul|strtoul|strtoull}}
{{nv ln | cpp/string/byte/strtof|strtof|strtod|strtold}}
{{nv col end}}

{{nv h2 | String manipulation}}
{{nv ln | cpp/string/byte/strcpy}}
{{nv ln | cpp/string/byte/strncpy}}
{{nv ln | cpp/string/byte/strcat}}
{{nv ln | cpp/string/byte/strncat}}
{{nv ln | cpp/string/byte/strxfrm}}

{{nv h2 | String examination}}
{{nv col begin}}
{{nv ln | cpp/string/byte/strlen}}
{{nv ln | cpp/string/byte/strcmp}}
{{nv ln | cpp/string/byte/strncmp}}
{{nv ln | cpp/string/byte/strcoll}}
{{nv ln | cpp/string/byte/strchr}}
{{nv ln | cpp/string/byte/strrchr}}
{{nv col next}}
{{nv ln | cpp/string/byte/strspn}}
{{nv ln | cpp/string/byte/strcspn}}
{{nv ln | cpp/string/byte/strpbrk}}
{{nv ln | cpp/string/byte/strstr}}
{{nv ln | cpp/string/byte/strtok}}
{{nv col end}}

{{nv h2 | Memory manipulation}}
{{nv ln | cpp/string/byte/memchr}}
{{nv ln | cpp/string/byte/memcmp}}
{{nv ln | cpp/string/byte/memset}}
{{nv ln | cpp/string/byte/memcpy}}
{{nv ln | cpp/string/byte/memmove}}

{{nv h2 | Miscellaneous}}
{{nv ln | cpp/string/byte/strerror}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/byte/navbar heading</title>
    <ns>10</ns>
    <id>20</id>
    <revision>
      <id>35910</id>
      <parentid>14561</parentid>
      <timestamp>2012-06-15T22:34:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/byte/sidebar heading]] to [[Template:cpp/string/byte/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="50">[[cpp/string/byte | Null-terminated byte strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc assign</title>
    <ns>10</ns>
    <id>9093</id>
    <revision>
      <id>59846</id>
      <parentid>54858</parentid>
      <timestamp>2013-06-01T06:41:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list assign]] to [[Template:cpp/string/char traits/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem sfun | cpp/string/char_traits/assign | assigns a character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc cmp</title>
    <ns>10</ns>
    <id>9094</id>
    <revision>
      <id>59848</id>
      <parentid>54861</parentid>
      <timestamp>2013-06-01T06:41:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list cmp]] to [[Template:cpp/string/char traits/dsc cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc mem sfun | cpp/string/char_traits/cmp | title=eq&lt;br&gt;lt| compares two characters }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc compare</title>
    <ns>10</ns>
    <id>9097</id>
    <revision>
      <id>59850</id>
      <parentid>54862</parentid>
      <timestamp>2013-06-01T06:41:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list compare]] to [[Template:cpp/string/char traits/dsc compare]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem sfun | cpp/string/char_traits/compare | lexicographically compares two character sequences}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc copy</title>
    <ns>10</ns>
    <id>9096</id>
    <revision>
      <id>59852</id>
      <parentid>54865</parentid>
      <timestamp>2013-06-01T06:41:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list copy]] to [[Template:cpp/string/char traits/dsc copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem sfun | cpp/string/char_traits/copy | copies a character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc eof</title>
    <ns>10</ns>
    <id>9100</id>
    <revision>
      <id>59854</id>
      <parentid>54866</parentid>
      <timestamp>2013-06-01T06:42:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list eof]] to [[Template:cpp/string/char traits/dsc eof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem sfun | cpp/string/char_traits/eof | returns an ''eof'' value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc eq int type</title>
    <ns>10</ns>
    <id>9104</id>
    <revision>
      <id>59856</id>
      <parentid>54867</parentid>
      <timestamp>2013-06-01T06:42:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list eq int type]] to [[Template:cpp/string/char traits/dsc eq int type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem sfun | cpp/string/char_traits/eq_int_type | compares two {{tt|int_type}} values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc find</title>
    <ns>10</ns>
    <id>9103</id>
    <revision>
      <id>59858</id>
      <parentid>54870</parentid>
      <timestamp>2013-06-01T06:42:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list find]] to [[Template:cpp/string/char traits/dsc find]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem sfun | cpp/string/char_traits/find | finds a character in a character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc length</title>
    <ns>10</ns>
    <id>9098</id>
    <revision>
      <id>59860</id>
      <parentid>54871</parentid>
      <timestamp>2013-06-01T06:42:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list length]] to [[Template:cpp/string/char traits/dsc length]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem sfun | cpp/string/char_traits/length | returns the length of a character sequence}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc move</title>
    <ns>10</ns>
    <id>9095</id>
    <revision>
      <id>59862</id>
      <parentid>54874</parentid>
      <timestamp>2013-06-01T06:42:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list move]] to [[Template:cpp/string/char traits/dsc move]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem sfun | cpp/string/char_traits/move | moves one character sequence onto another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc not eof</title>
    <ns>10</ns>
    <id>9101</id>
    <revision>
      <id>59864</id>
      <parentid>54875</parentid>
      <timestamp>2013-06-01T06:42:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list not eof]] to [[Template:cpp/string/char traits/dsc not eof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem sfun | cpp/string/char_traits/not_eof | checks whether a character is ''eof'' value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc to char type</title>
    <ns>10</ns>
    <id>9102</id>
    <revision>
      <id>59866</id>
      <parentid>54876</parentid>
      <timestamp>2013-06-01T06:42:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list to char type]] to [[Template:cpp/string/char traits/dsc to char type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem sfun | cpp/string/char_traits/to_char_type | converts {{tt|int_type}} to equivalent  {{tt|char_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/dsc to int type</title>
    <ns>10</ns>
    <id>9099</id>
    <revision>
      <id>59868</id>
      <parentid>54877</parentid>
      <timestamp>2013-06-01T06:42:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/char traits/dcl list to int type]] to [[Template:cpp/string/char traits/dsc to int type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc mem sfun | cpp/string/char_traits/to_int_type | converts {{tt|char_type}} to equivalent  {{tt|int_type}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/navbar</title>
    <ns>10</ns>
    <id>9118</id>
    <revision>
      <id>40020</id>
      <parentid>38248</parentid>
      <timestamp>2012-09-28T20:19:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content

|heading3 = cpp/string/char_traits/navbar heading
|content3 = cpp/string/char_traits/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/navbar content</title>
    <ns>10</ns>
    <id>9120</id>
    <revision>
      <id>54880</id>
      <parentid>38252</parentid>
      <timestamp>2013-06-01T05:17:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="610">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/string/char_traits/assign}}
{{nv mem ln | cpp/string/char_traits/cmp}}
{{nv mem ln | cpp/string/char_traits/move}}
{{nv mem ln | cpp/string/char_traits/copy}}
{{nv mem ln | cpp/string/char_traits/compare}}
{{nv mem ln | cpp/string/char_traits/length}}
{{nv mem ln | cpp/string/char_traits/find}}
{{nv mem ln | cpp/string/char_traits/to_char_type}}
{{nv mem ln | cpp/string/char_traits/to_int_type}}
{{nv mem ln | cpp/string/char_traits/eq_int_type}}
{{nv mem ln | cpp/string/char_traits/eof}}
{{nv mem ln | cpp/string/char_traits/not_eof}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/navbar heading</title>
    <ns>10</ns>
    <id>9119</id>
    <revision>
      <id>48088</id>
      <parentid>38249</parentid>
      <timestamp>2013-05-18T18:07:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/string/char_traits|std::char_traits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/char traits/title</title>
    <ns>10</ns>
    <id>9114</id>
    <revision>
      <id>38242</id>
      <timestamp>2012-07-27T10:49:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=char_traits::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/character classes</title>
    <ns>10</ns>
    <id>1719</id>
    <revision>
      <id>14602</id>
      <parentid>12783</parentid>
      <timestamp>2011-11-27T02:19:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;cpp/string/narrow&quot; to &quot;cpp/string/byte&quot;</comment>
      <text xml:space="preserve" bytes="9289">{| class=&quot;wikitable&quot; style=&quot;font-size:85%; text-align:center;&quot;
|-
! colspan=&quot;2&quot; | ASCII values &lt;br&gt; (hex)
! characters
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/iscntrl | iscntrl}} &lt;br&gt;
{{ltt|cpp/string/wide/iswcntrl | iswcntrl}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isprint | isprint}} &lt;br&gt;
{{ltt|cpp/string/wide/iswprint | iswprint}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isspace | isspace}} &lt;br&gt;
{{ltt|cpp/string/wide/iswspace | iswspace}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isblank | isblank}} &lt;br&gt;
{{ltt|cpp/string/wide/iswblank | iswblank}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isgraph | isgraph}} &lt;br&gt;
{{ltt|cpp/string/wide/iswgraph | iswgraph}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/ispunct | ispunct}} &lt;br&gt;
{{ltt|cpp/string/wide/iswpunct | iswpunct}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isalnum | isalnum}} &lt;br&gt;
{{ltt|cpp/string/wide/iswalnum | iswalnum}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isalpha | isalpha}} &lt;br&gt;
{{ltt|cpp/string/wide/iswalpha | iswalpha}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isupper | isupper}} &lt;br&gt;
{{ltt|cpp/string/wide/iswupper | iswupper}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/islower | islower}} &lt;br&gt;
{{ltt|cpp/string/wide/iswlower | iswlower}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isdigit | isdigit}} &lt;br&gt;
{{ltt|cpp/string/wide/iswdigit | iswdigit}}
! style=&quot;font-size:85%;&quot; |
{{ltt|cpp/string/byte/isxdigit | isxdigit}} &lt;br&gt;
{{ltt|cpp/string/wide/iswxdigit | iswxdigit}}
|-
| 0  - 8 
| {{tt|0x00-0x08}}
| control codes ({{tt|NUL}}, etc.)
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 9 
| {{tt|0x09}}
| tab ({{tt|\t}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 10  - 13 
| {{tt|0x0A-0x0D}}
| whitespaces ({{tt|\n}},{{tt|\v}},{{tt|\f}},{{tt|\r}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 14 - 31 
| {{tt|0x0E-0x1F}}
| control codes
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 32 
| {{tt|0x20}}
| space
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 33 - 47 
| {{tt|0x21-0x2F}}
| {{tt|!&quot;#$%&amp;'()*+,-./}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 48 - 57 
| {{tt|0x30-0x39}}
| {{tt|0123456789}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}} 
|-
| 58 - 64 
| {{tt|0x3a-0x40}}
| {{tt|:;&lt;{{=}}&gt;?@}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 65 - 70 
| {{tt|0x41-0x46}}
| {{tt|ABCDEF}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}} 
|-
| 71 - 90 
| {{tt|0x47-0x5A}}
| {{tt|GHIJKLMNOPQRSTUVWXYZ}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 91 - 96 
| {{tt|0x5B-0x60}}
| {{tt|[\]&lt;nowiki&gt;^&lt;/nowiki&gt;_`}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 97 -102 
| {{tt|0x61-0x66}}
| {{tt|abcdef}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}} 
|-
| 103-122 
| {{tt|0x67-0x7A}}
| {{tt|ghijklmnopqrstuvwxyz}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 123-126 
| {{tt|0x7B-0x7E}}
| {{tt|{&lt;nowiki&gt;|&lt;/nowiki&gt;}~}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|-
| 127 
| {{tt|0x7F}}
| backspace character ({{tt|DEL}})
| {{cpp/string/character classes/yes}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
| {{cpp/string/character classes/no}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/character classes/no</title>
    <ns>10</ns>
    <id>1720</id>
    <revision>
      <id>3440</id>
      <parentid>3439</parentid>
      <timestamp>2011-06-06T22:58:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="22">{{no|&lt;b&gt;{{tt|0}}&lt;/b&gt;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/character classes/yes</title>
    <ns>10</ns>
    <id>1721</id>
    <revision>
      <id>3442</id>
      <parentid>3441</parentid>
      <timestamp>2011-06-06T22:58:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="26">{{yes|&lt;b&gt;{{tt|≠0}}&lt;/b&gt;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/cvt str2float</title>
    <ns>10</ns>
    <id>1722</id>
    <revision>
      <id>72421</id>
      <parentid>72420</parentid>
      <timestamp>2014-08-21T12:20:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+locale-specific forms</comment>
      <text xml:space="preserve" bytes="1882">Function discards any whitespace characters (as determined by {{#switch:{{{1|}}}
 | wide |{{c|std::iswspace()}}
 | both |{{c|std::isspace()}} or {{c|std::iswspace()}}
 | {{c|std::isspace()}}
}}) until first non-whitespace character is found. Then it takes as many characters as possible to form a valid floating point representation and converts them to floating point value. The valid floating point value can be one of the following:

*decimal floating point expression. It consists of the following parts:
:* {{mark optional}} plus or minus sign
:* nonempty sequence of decimal digits optionally containing decimal point character (as determined by the current C {{lc|std::setlocale|locale}}) (defines significand)
:* {{mark optional}} {{ttb|e}} or {{ttb|E}} followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent)

*binary floating point expression. It consists of the following parts:
:* {{mark optional}} plus or minus sign
:* {{ttb|0x}} or {{ttb|0X}}
:* nonempty sequence of hexadecimal digits optionally containing a decimal point character (as determined by the current C {{lc|std::setlocale|locale}}) (defines significand)
:* {{mark optional}} {{ttb|p}} or {{ttb|P}} followed with optional minus or plus sign and nonempty sequence of decimal digits (defines exponent)

* infinity expression. It consists of the following parts:
:* {{mark optional}} plus or minus sign
:* {{ttb|INF}} or {{ttb|INFINITY}} ignoring case

* not-a-number expression. It consists of the following parts:
:* {{mark optional}} plus or minus sign
:* {{ttb|NAN}} or {{ttb|NAN(}}''char_sequence''{{ttb|)}} ignoring case of the {{ttb|NAN}} part. ''char_sequence'' can only contain alphanumeric characters. The result is a quiet NaN floating point value.

* any other expression that may be accepted by the currently installed C {{lc|std::setlocale|locale}}</text>
      <sha1>0ymv1ghn1n7374snvp7tr4vuqva7bxn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/cvt str2int</title>
    <ns>10</ns>
    <id>1723</id>
    <revision>
      <id>8793</id>
      <parentid>3446</parentid>
      <timestamp>2011-08-16T21:11:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>style</comment>
      <text xml:space="preserve" bytes="331">Function discards any whitespace characters until first non-whitespace character is found. Then it takes as many characters as possible to form a valid integer number representation and converts them to integer value. The valid integer value consists of the following parts:

* {{mark optional}} plus or minus sign
* numeric digits</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/cvt str2int base</title>
    <ns>10</ns>
    <id>1724</id>
    <revision>
      <id>72436</id>
      <parentid>72435</parentid>
      <timestamp>2014-08-22T01:54:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>oops, that was already mentioned.. merge the two mentions</comment>
      <text xml:space="preserve" bytes="1431">Function discards any whitespace characters (as identified by calling {{tt|isspace()}}) until first non-whitespace character is found. Then it takes as many characters as possible to form a valid ''base-n'' (where n={{{base}}}) {{#ifeq: {{{u|}}} | true | unsigned}} integer number representation and converts them to an {{#ifeq: {{{{u|}}} | true | unsigned}} integer value. The valid {{#ifeq: {{{u|}}} | true | unsigned}}  integer value consists of the following parts:
{{#ifeq: {{{u|}}} | true || 
* {{mark optional}} plus or minus sign
}}
* {{mark optional}} prefix ({{ttb|0}}) indicating octal base (applies only when the base is {{c|8}} or {{c|0}})
* {{mark optional}} prefix ({{ttb|0x}} or {{ttb|0X}}) indicating hexadecimal base (applies only when the base is {{c|16}} or {{c|0}})
* a sequence of digits

The set of valid digits for base-2 integer is {{tt|01}}, for base-3 integer is {{tt|012}}, and so on. For bases larger than {{tt|10}}, valid digits include alphabetic characters, starting from {{tt|Aa}} for base-11 integer, to {{tt|Zz}} for base-36 integer. The case of the characters is ignored.

Additional numeric formats may be accepted by the currently installed C {{lc|std::setlocale|locale}}.

If the value of {{{base}}} is {{c|0}}, the numeric base is auto-detected: if the prefix is {{ttb|0}}, the base is octal, if the prefix is {{ttb|0x}} or {{ttb|0X}}, the base is hexadecimal, otherwise the base is decimal.</text>
      <sha1>sp2fq2t7xk0ngf8stoxa0d4ba6d5ak3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/dsc basic string</title>
    <ns>10</ns>
    <id>2534</id>
    <revision>
      <id>59870</id>
      <parentid>54883</parentid>
      <timestamp>2013-06-01T06:42:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/dcl list basic string]] to [[Template:cpp/string/dsc basic string]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc tclass | cpp/string/basic_string | stores and manipulates sequences of characters}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc MB CUR MAX</title>
    <ns>10</ns>
    <id>5165</id>
    <revision>
      <id>59872</id>
      <parentid>54884</parentid>
      <timestamp>2013-06-01T06:42:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list MB CUR MAX]] to [[Template:cpp/string/multibyte/dsc MB CUR MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc | {{dsc member | nolink=true | MB_CUR_MAX }} | maximum number of bytes in a multibyte character in the current C locale&lt;br/&gt;{{mark|macro variable}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc MB LEN MAX</title>
    <ns>10</ns>
    <id>5164</id>
    <revision>
      <id>59874</id>
      <parentid>54887</parentid>
      <timestamp>2013-06-01T06:42:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list MB LEN MAX]] to [[Template:cpp/string/multibyte/dsc MB LEN MAX]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc macro const | MB_LEN_MAX | nolink=true | maximum number of bytes in a multibyte character }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc btowc</title>
    <ns>10</ns>
    <id>4603</id>
    <revision>
      <id>59876</id>
      <parentid>54888</parentid>
      <timestamp>2013-06-01T06:42:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list btowc]] to [[Template:cpp/string/multibyte/dsc btowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc fun | cpp/string/multibyte/btowc | widens a single-byte narrow character to wide character, if possible}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc c16rtomb</title>
    <ns>10</ns>
    <id>4611</id>
    <revision>
      <id>59878</id>
      <parentid>54889</parentid>
      <timestamp>2013-06-01T06:42:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list c16rtomb]] to [[Template:cpp/string/multibyte/dsc c16rtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/string/multibyte/c16rtomb | convert a 16-bit wide character to narrow multibyte string| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc c32rtomb</title>
    <ns>10</ns>
    <id>4613</id>
    <revision>
      <id>59880</id>
      <parentid>54890</parentid>
      <timestamp>2013-06-01T06:42:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list c32rtomb]] to [[Template:cpp/string/multibyte/dsc c32rtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc fun | cpp/string/multibyte/c32rtomb | convert a 32-bit wide character to narrow multibyte string| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mblen</title>
    <ns>10</ns>
    <id>4597</id>
    <revision>
      <id>59882</id>
      <parentid>54893</parentid>
      <timestamp>2013-06-01T06:42:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mblen]] to [[Template:cpp/string/multibyte/dsc mblen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/string/multibyte/mblen  | returns the number of bytes in the next multibyte character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbrlen</title>
    <ns>10</ns>
    <id>4605</id>
    <revision>
      <id>59884</id>
      <parentid>54896</parentid>
      <timestamp>2013-06-01T06:42:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbrlen]] to [[Template:cpp/string/multibyte/dsc mbrlen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | cpp/string/multibyte/mbrlen | returns the number of bytes in the next multibyte character, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbrtoc16</title>
    <ns>10</ns>
    <id>4610</id>
    <revision>
      <id>59886</id>
      <parentid>54897</parentid>
      <timestamp>2013-06-01T06:42:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbrtoc16]] to [[Template:cpp/string/multibyte/dsc mbrtoc16]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc fun | cpp/string/multibyte/mbrtoc16 | generate the next 16-bit wide character from a narrow multibyte string | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbrtoc32</title>
    <ns>10</ns>
    <id>4612</id>
    <revision>
      <id>59888</id>
      <parentid>54898</parentid>
      <timestamp>2013-06-01T06:42:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbrtoc32]] to [[Template:cpp/string/multibyte/dsc mbrtoc32]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc fun | cpp/string/multibyte/mbrtoc32 | generate the next 32-bit wide character from a narrow multibyte string| notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbrtowc</title>
    <ns>10</ns>
    <id>4606</id>
    <revision>
      <id>59890</id>
      <parentid>54899</parentid>
      <timestamp>2013-06-01T06:42:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbrtowc]] to [[Template:cpp/string/multibyte/dsc mbrtowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | cpp/string/multibyte/mbrtowc  | converts the next multibyte character to wide character, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbsinit</title>
    <ns>10</ns>
    <id>4602</id>
    <revision>
      <id>59892</id>
      <parentid>54902</parentid>
      <timestamp>2013-06-01T06:42:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbsinit]] to [[Template:cpp/string/multibyte/dsc mbsinit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/string/multibyte/mbsinit  | checks if the mbstate_t object represents initial shift state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbsrtowcs</title>
    <ns>10</ns>
    <id>4608</id>
    <revision>
      <id>59894</id>
      <parentid>54907</parentid>
      <timestamp>2013-06-01T06:42:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbsrtowcs]] to [[Template:cpp/string/multibyte/dsc mbsrtowcs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | cpp/string/multibyte/mbsrtowcs  | converts a narrow multibyte character string to wide string, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbstate t</title>
    <ns>10</ns>
    <id>4614</id>
    <revision>
      <id>59896</id>
      <parentid>54908</parentid>
      <timestamp>2013-06-01T06:42:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbstate t]] to [[Template:cpp/string/multibyte/dsc mbstate t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc class | cpp/string/multibyte/mbstate_t | conversion state information necessary to iterate multibyte character strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbstowcs</title>
    <ns>10</ns>
    <id>4600</id>
    <revision>
      <id>59898</id>
      <parentid>54911</parentid>
      <timestamp>2013-06-01T06:42:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbstowcs]] to [[Template:cpp/string/multibyte/dsc mbstowcs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc fun | cpp/string/multibyte/mbstowcs  | converts a narrow multibyte character string to wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc mbtowc</title>
    <ns>10</ns>
    <id>4598</id>
    <revision>
      <id>59900</id>
      <parentid>54912</parentid>
      <timestamp>2013-06-01T06:42:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list mbtowc]] to [[Template:cpp/string/multibyte/dsc mbtowc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/string/multibyte/mbtowc  | converts the next multibyte character to wide character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc wcrtomb</title>
    <ns>10</ns>
    <id>4607</id>
    <revision>
      <id>59902</id>
      <parentid>54913</parentid>
      <timestamp>2013-06-01T06:42:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list wcrtomb]] to [[Template:cpp/string/multibyte/dsc wcrtomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | cpp/string/multibyte/wcrtomb  | converts a wide character to its multibyte representation, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc wcsrtombs</title>
    <ns>10</ns>
    <id>4609</id>
    <revision>
      <id>59904</id>
      <parentid>54914</parentid>
      <timestamp>2013-06-01T06:42:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list wcsrtombs]] to [[Template:cpp/string/multibyte/dsc wcsrtombs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | cpp/string/multibyte/wcsrtombs  | converts a wide string to narrow multibyte character string, given state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc wcstombs</title>
    <ns>10</ns>
    <id>4601</id>
    <revision>
      <id>59906</id>
      <parentid>54917</parentid>
      <timestamp>2013-06-01T06:42:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list wcstombs]] to [[Template:cpp/string/multibyte/dsc wcstombs]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc fun | cpp/string/multibyte/wcstombs  | converts a wide string to narrow multibyte character string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc wctob</title>
    <ns>10</ns>
    <id>4604</id>
    <revision>
      <id>59908</id>
      <parentid>54924</parentid>
      <timestamp>2013-06-01T06:42:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list wctob]] to [[Template:cpp/string/multibyte/dsc wctob]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc fun | cpp/string/multibyte/wctob | narrows a wide character to a single-byte narrow character, if possible}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/dsc wctomb</title>
    <ns>10</ns>
    <id>4599</id>
    <revision>
      <id>59910</id>
      <parentid>54925</parentid>
      <timestamp>2013-06-01T06:42:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/dcl list wctomb]] to [[Template:cpp/string/multibyte/dsc wctomb]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/string/multibyte/wctomb  | converts a wide character to its multibyte representation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/navbar</title>
    <ns>10</ns>
    <id>3900</id>
    <revision>
      <id>40021</id>
      <parentid>35911</parentid>
      <timestamp>2012-09-28T20:19:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="286">{{navbar
|name         = cpp/container/navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content

|heading3 = cpp/string/multibyte/navbar heading
|content3 = cpp/string/multibyte/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/navbar content</title>
    <ns>10</ns>
    <id>4066</id>
    <revision>
      <id>54926</id>
      <parentid>35912</parentid>
      <timestamp>2013-06-01T05:18:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="953">{{nv begin}}
{{nv h2 | Wide/multibyte conversions}}
{{nv ln | cpp/string/multibyte/mbsinit}}
{{nv col begin}}
{{nv ln | cpp/string/multibyte/mbtowc}}
{{nv ln | cpp/string/multibyte/mbstowcs}}
{{nv ln | cpp/string/multibyte/btowc}}
{{nv ln | cpp/string/multibyte/mbrtowc}}
{{nv ln | cpp/string/multibyte/mbsrtowcs}}
{{nv ln | cpp/string/multibyte/mbrtoc16|notes={{mark c++11}}}}
{{nv ln | cpp/string/multibyte/mbrtoc32|notes={{mark c++11}}}}
{{nv ln | cpp/string/multibyte/mblen}}
{{nv col next}}
{{nv ln | cpp/string/multibyte/wctomb}}
{{nv ln | cpp/string/multibyte/wcstombs}}
{{nv ln | cpp/string/multibyte/wctob}}
{{nv ln | cpp/string/multibyte/wcrtomb}}
{{nv ln | cpp/string/multibyte/wcsrtombs}}
{{nv ln | cpp/string/multibyte/c16rtomb|notes={{mark c++11}}}}
{{nv ln | cpp/string/multibyte/c32rtomb|notes={{mark c++11}}}}
{{nv ln | cpp/string/multibyte/mbrlen}}
{{nv col end}}
{{nv h2 | Types}}
{{nv ln | cpp/string/multibyte/mbstate_t}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/multibyte/navbar heading</title>
    <ns>10</ns>
    <id>3901</id>
    <revision>
      <id>35913</id>
      <parentid>14512</parentid>
      <timestamp>2012-06-15T22:34:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/multibyte/sidebar heading]] to [[Template:cpp/string/multibyte/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="60">[[cpp/string/multibyte | Null-terminated multibyte strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/navbar</title>
    <ns>10</ns>
    <id>21</id>
    <revision>
      <id>40022</id>
      <parentid>38247</parentid>
      <timestamp>2012-09-28T20:19:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="150">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/navbar content</title>
    <ns>10</ns>
    <id>22</id>
    <revision>
      <id>54929</id>
      <parentid>35438</parentid>
      <timestamp>2013-06-01T05:18:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="295">{{nv begin}}
{{nv h1 | Null-terminated strings}}
{{nv | [[cpp/string/byte | Byte strings]] }}
{{nv | [[cpp/string/multibyte | Multibyte strings]] }}
{{nv | [[cpp/string/wide | Wide strings]] }}
{{nv h1 | Classes}}
{{nv ln | cpp/string/basic_string}}
{{nv ln | cpp/string/char_traits}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/navbar heading</title>
    <ns>10</ns>
    <id>23</id>
    <revision>
      <id>35915</id>
      <parentid>45</parentid>
      <timestamp>2012-06-15T22:34:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/sidebar heading]] to [[Template:cpp/string/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="32">[[cpp/string | Strings library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswalnum</title>
    <ns>10</ns>
    <id>2602</id>
    <revision>
      <id>59912</id>
      <parentid>54930</parentid>
      <timestamp>2013-06-01T06:42:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswalnum]] to [[Template:cpp/string/wide/dsc iswalnum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc fun | cpp/string/wide/iswalnum | checks if a wide character is alphanumeric}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswalpha</title>
    <ns>10</ns>
    <id>2603</id>
    <revision>
      <id>59914</id>
      <parentid>54933</parentid>
      <timestamp>2013-06-01T06:42:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswalpha]] to [[Template:cpp/string/wide/dsc iswalpha]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc fun | cpp/string/wide/iswalpha | checks if a wide character is alphabetic}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswblank</title>
    <ns>10</ns>
    <id>2930</id>
    <revision>
      <id>59916</id>
      <parentid>54934</parentid>
      <timestamp>2013-06-01T06:42:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswblank]] to [[Template:cpp/string/wide/dsc iswblank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | cpp/string/wide/iswblank | checks if a wide character is a blank character|notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswcntrl</title>
    <ns>10</ns>
    <id>2608</id>
    <revision>
      <id>59918</id>
      <parentid>54935</parentid>
      <timestamp>2013-06-01T06:42:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswcntrl]] to [[Template:cpp/string/wide/dsc iswcntrl]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/string/wide/iswcntrl | checks if a wide character is a control character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswctype</title>
    <ns>10</ns>
    <id>2965</id>
    <revision>
      <id>59920</id>
      <parentid>54936</parentid>
      <timestamp>2013-06-01T06:42:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswctype]] to [[Template:cpp/string/wide/dsc iswctype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc fun | cpp/string/wide/iswctype | classifies a wide character according to the specified LC_CTYPE category  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswdigit</title>
    <ns>10</ns>
    <id>2606</id>
    <revision>
      <id>59922</id>
      <parentid>54939</parentid>
      <timestamp>2013-06-01T06:42:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswdigit]] to [[Template:cpp/string/wide/dsc iswdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc fun | cpp/string/wide/iswdigit | checks if a wide character is a digit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswgraph</title>
    <ns>10</ns>
    <id>2609</id>
    <revision>
      <id>59924</id>
      <parentid>54942</parentid>
      <timestamp>2013-06-01T06:42:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswgraph]] to [[Template:cpp/string/wide/dsc iswgraph]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc fun | cpp/string/wide/iswgraph | checks if a wide character is a graphical character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswlower</title>
    <ns>10</ns>
    <id>2604</id>
    <revision>
      <id>59926</id>
      <parentid>54943</parentid>
      <timestamp>2013-06-01T06:42:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswlower]] to [[Template:cpp/string/wide/dsc iswlower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc fun | cpp/string/wide/iswlower | checks if a wide character is lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswprint</title>
    <ns>10</ns>
    <id>2611</id>
    <revision>
      <id>59928</id>
      <parentid>54944</parentid>
      <timestamp>2013-06-01T06:42:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswprint]] to [[Template:cpp/string/wide/dsc iswprint]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | cpp/string/wide/iswprint | checks if a wide character is a printing character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswpunct</title>
    <ns>10</ns>
    <id>2612</id>
    <revision>
      <id>59930</id>
      <parentid>54945</parentid>
      <timestamp>2013-06-01T06:42:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswpunct]] to [[Template:cpp/string/wide/dsc iswpunct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/string/wide/iswpunct | checks if a wide character is a punctuation character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswspace</title>
    <ns>10</ns>
    <id>2610</id>
    <revision>
      <id>59932</id>
      <parentid>54948</parentid>
      <timestamp>2013-06-01T06:42:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswspace]] to [[Template:cpp/string/wide/dsc iswspace]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/string/wide/iswspace | checks if a wide character is a space character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswupper</title>
    <ns>10</ns>
    <id>2605</id>
    <revision>
      <id>59934</id>
      <parentid>54953</parentid>
      <timestamp>2013-06-01T06:42:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswupper]] to [[Template:cpp/string/wide/dsc iswupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc fun | cpp/string/wide/iswupper | checks if a wide character is an uppercase character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc iswxdigit</title>
    <ns>10</ns>
    <id>2607</id>
    <revision>
      <id>59936</id>
      <parentid>54958</parentid>
      <timestamp>2013-06-01T06:42:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list iswxdigit]] to [[Template:cpp/string/wide/dsc iswxdigit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/string/wide/iswxdigit | checks if a character is a hexadecimal character}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc towctrans</title>
    <ns>10</ns>
    <id>2963</id>
    <revision>
      <id>59938</id>
      <parentid>54961</parentid>
      <timestamp>2013-06-01T06:42:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list towctrans]] to [[Template:cpp/string/wide/dsc towctrans]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc fun | cpp/string/wide/towctrans | performs character mapping according to the specified LC_CTYPE mapping category }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc towlower</title>
    <ns>10</ns>
    <id>2613</id>
    <revision>
      <id>59940</id>
      <parentid>54962</parentid>
      <timestamp>2013-06-01T06:42:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list towlower]] to [[Template:cpp/string/wide/dsc towlower]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | cpp/string/wide/towlower | converts a wide character to lowercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc towupper</title>
    <ns>10</ns>
    <id>2614</id>
    <revision>
      <id>59942</id>
      <parentid>54965</parentid>
      <timestamp>2013-06-01T06:42:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list towupper]] to [[Template:cpp/string/wide/dsc towupper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc fun | cpp/string/wide/towupper | converts a wide character to uppercase}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcscat</title>
    <ns>10</ns>
    <id>3769</id>
    <revision>
      <id>59944</id>
      <parentid>54968</parentid>
      <timestamp>2013-06-01T06:42:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcscat]] to [[Template:cpp/string/wide/dsc wcscat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc fun | cpp/string/wide/wcscat | appends a copy of one wide string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcschr</title>
    <ns>10</ns>
    <id>3776</id>
    <revision>
      <id>59946</id>
      <parentid>54971</parentid>
      <timestamp>2013-06-01T06:43:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcschr]] to [[Template:cpp/string/wide/dsc wcschr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/string/wide/wcschr | finds the first occurrence of a wide character in a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcscmp</title>
    <ns>10</ns>
    <id>3773</id>
    <revision>
      <id>59948</id>
      <parentid>54972</parentid>
      <timestamp>2013-06-01T06:43:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcscmp]] to [[Template:cpp/string/wide/dsc wcscmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc fun | cpp/string/wide/wcscmp | compares two wide strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcscoll</title>
    <ns>10</ns>
    <id>3775</id>
    <revision>
      <id>59950</id>
      <parentid>54973</parentid>
      <timestamp>2013-06-01T06:43:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcscoll]] to [[Template:cpp/string/wide/dsc wcscoll]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/string/wide/wcscoll | compares two wide strings in accordance to the current locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcscpy</title>
    <ns>10</ns>
    <id>3767</id>
    <revision>
      <id>59952</id>
      <parentid>54974</parentid>
      <timestamp>2013-06-01T06:43:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcscpy]] to [[Template:cpp/string/wide/dsc wcscpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | cpp/string/wide/wcscpy | copies one wide string to another}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcscspn</title>
    <ns>10</ns>
    <id>3779</id>
    <revision>
      <id>59954</id>
      <parentid>54977</parentid>
      <timestamp>2013-06-01T06:43:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcscspn]] to [[Template:cpp/string/wide/dsc wcscspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc fun | cpp/string/wide/wcscspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the wide ''not'' found in another wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcslen</title>
    <ns>10</ns>
    <id>3772</id>
    <revision>
      <id>59956</id>
      <parentid>54982</parentid>
      <timestamp>2013-06-01T06:43:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcslen]] to [[Template:cpp/string/wide/dsc wcslen]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc fun | cpp/string/wide/wcslen | returns the length of a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsncat</title>
    <ns>10</ns>
    <id>3770</id>
    <revision>
      <id>59958</id>
      <parentid>54987</parentid>
      <timestamp>2013-06-01T06:43:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsncat]] to [[Template:cpp/string/wide/dsc wcsncat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | cpp/string/wide/wcsncat | appends a certain amount of wide characters from one wide string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsncmp</title>
    <ns>10</ns>
    <id>3774</id>
    <revision>
      <id>59960</id>
      <parentid>54988</parentid>
      <timestamp>2013-06-01T06:43:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsncmp]] to [[Template:cpp/string/wide/dsc wcsncmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/string/wide/wcsncmp | compares a certain amount of characters from two wide strings}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsncpy</title>
    <ns>10</ns>
    <id>3768</id>
    <revision>
      <id>59962</id>
      <parentid>54989</parentid>
      <timestamp>2013-06-01T06:43:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsncpy]] to [[Template:cpp/string/wide/dsc wcsncpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/string/wide/wcsncpy | copies a certain amount of wide characters from one string to another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcspbrk</title>
    <ns>10</ns>
    <id>3780</id>
    <revision>
      <id>59964</id>
      <parentid>54992</parentid>
      <timestamp>2013-06-01T06:43:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcspbrk]] to [[Template:cpp/string/wide/dsc wcspbrk]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc fun | cpp/string/wide/wcspbrk | finds the first location of any wide character in one wide string, in another wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsrchr</title>
    <ns>10</ns>
    <id>3777</id>
    <revision>
      <id>59966</id>
      <parentid>54993</parentid>
      <timestamp>2013-06-01T06:43:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsrchr]] to [[Template:cpp/string/wide/dsc wcsrchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/string/wide/wcsrchr | finds the last occurrence of a wide character in a wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsspn</title>
    <ns>10</ns>
    <id>3778</id>
    <revision>
      <id>59968</id>
      <parentid>54996</parentid>
      <timestamp>2013-06-01T06:43:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsspn]] to [[Template:cpp/string/wide/dsc wcsspn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc fun | cpp/string/wide/wcsspn | returns the length of the maximum initial segment that consists &lt;br&gt; of only the wide characters found in another wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsstr</title>
    <ns>10</ns>
    <id>3781</id>
    <revision>
      <id>59970</id>
      <parentid>54997</parentid>
      <timestamp>2013-06-01T06:43:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsstr]] to [[Template:cpp/string/wide/dsc wcsstr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | cpp/string/wide/wcsstr | finds the first occurrence of a wide string within another wide string}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcstof</title>
    <ns>10</ns>
    <id>4739</id>
    <revision>
      <id>59972</id>
      <parentid>54998</parentid>
      <timestamp>2013-06-01T06:43:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcstof]] to [[Template:cpp/string/wide/dsc wcstof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc fun | cpp/string/wide/wcstof | title=wcstof&lt;br&gt;wcstod&lt;br&gt;wcstold | converts a wide string to a floating point value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcstoimax</title>
    <ns>10</ns>
    <id>3660</id>
    <revision>
      <id>59974</id>
      <parentid>55001</parentid>
      <timestamp>2013-06-01T06:43:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcstoimax]] to [[Template:cpp/string/wide/dsc wcstoimax]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="185">{{dsc fun | cpp/string/wide/wcstoimax | title=wcstoimax&lt;br&gt;wcstoumax | converts a wide string to {{lc|std::intmax_t}} or {{lc|std::uintmax_t}} | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcstok</title>
    <ns>10</ns>
    <id>3782</id>
    <revision>
      <id>59976</id>
      <parentid>55002</parentid>
      <timestamp>2013-06-01T06:43:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcstok]] to [[Template:cpp/string/wide/dsc wcstok]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc fun | cpp/string/wide/wcstok | finds the next token in a wide string }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcstol</title>
    <ns>10</ns>
    <id>4737</id>
    <revision>
      <id>59978</id>
      <parentid>55005</parentid>
      <timestamp>2013-06-01T06:43:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcstol]] to [[Template:cpp/string/wide/dsc wcstol]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/string/wide/wcstol | title=wcstol&lt;br&gt;wcstoll | converts a wide string to an integer value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcstoul</title>
    <ns>10</ns>
    <id>4738</id>
    <revision>
      <id>59980</id>
      <parentid>55006</parentid>
      <timestamp>2013-06-01T06:43:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcstoul]] to [[Template:cpp/string/wide/dsc wcstoul]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc fun | cpp/string/wide/wcstoul | title=wcstoul&lt;br&gt;wcstoull | converts a wide string to an unsigned integer value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wcsxfrm</title>
    <ns>10</ns>
    <id>3771</id>
    <revision>
      <id>59982</id>
      <parentid>55007</parentid>
      <timestamp>2013-06-01T06:43:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wcsxfrm]] to [[Template:cpp/string/wide/dsc wcsxfrm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc fun | cpp/string/wide/wcsxfrm | transform a wide string so that wcscmp would produce the same result as wcscoll }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wctrans</title>
    <ns>10</ns>
    <id>2964</id>
    <revision>
      <id>59984</id>
      <parentid>55008</parentid>
      <timestamp>2013-06-01T06:43:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wctrans]] to [[Template:cpp/string/wide/dsc wctrans]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc fun | cpp/string/wide/wctrans | looks up a character mapping category in the current C locale }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wctype</title>
    <ns>10</ns>
    <id>2966</id>
    <revision>
      <id>59986</id>
      <parentid>55011</parentid>
      <timestamp>2013-06-01T06:43:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wctype]] to [[Template:cpp/string/wide/dsc wctype]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc fun | cpp/string/wide/wctype | looks up a character classification category in the current C locale}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wmemchr</title>
    <ns>10</ns>
    <id>3786</id>
    <revision>
      <id>59988</id>
      <parentid>55014</parentid>
      <timestamp>2013-06-01T06:43:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wmemchr]] to [[Template:cpp/string/wide/dsc wmemchr]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc fun | cpp/string/wide/wmemchr | finds the first occurrence of a wide character in a wide character array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wmemcmp</title>
    <ns>10</ns>
    <id>3785</id>
    <revision>
      <id>59990</id>
      <parentid>55015</parentid>
      <timestamp>2013-06-01T06:43:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wmemcmp]] to [[Template:cpp/string/wide/dsc wmemcmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc fun | cpp/string/wide/wmemcmp | compares a certain amount of wide characters from two arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wmemcpy</title>
    <ns>10</ns>
    <id>3783</id>
    <revision>
      <id>59992</id>
      <parentid>55018</parentid>
      <timestamp>2013-06-01T06:43:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wmemcpy]] to [[Template:cpp/string/wide/dsc wmemcpy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | cpp/string/wide/wmemcpy | copies a certain amount of wide characters between two non-overlapping arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wmemmove</title>
    <ns>10</ns>
    <id>3784</id>
    <revision>
      <id>59994</id>
      <parentid>55019</parentid>
      <timestamp>2013-06-01T06:43:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wmemmove]] to [[Template:cpp/string/wide/dsc wmemmove]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc fun | cpp/string/wide/wmemmove | copies a certain amount of wide characters between two, possibly overlapping, arrays }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/dsc wmemset</title>
    <ns>10</ns>
    <id>3787</id>
    <revision>
      <id>59996</id>
      <parentid>55022</parentid>
      <timestamp>2013-06-01T06:43:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/dcl list wmemset]] to [[Template:cpp/string/wide/dsc wmemset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc fun | cpp/string/wide/wmemset | copies the given wide character to every position in a wide character array }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/navbar</title>
    <ns>10</ns>
    <id>24</id>
    <revision>
      <id>40023</id>
      <parentid>35916</parentid>
      <timestamp>2012-09-28T20:19:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="239">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/string/navbar heading
|content2 = cpp/string/navbar content

|heading3 = cpp/string/wide/navbar heading
|content3 = cpp/string/wide/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/navbar content</title>
    <ns>10</ns>
    <id>3382</id>
    <revision>
      <id>55025</id>
      <parentid>35917</parentid>
      <timestamp>2013-06-01T05:19:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1930">{{nv begin}}
{{nv h1 | Functions}}

{{nv h2 | Character manipulation}}
{{nv col begin}}
{{nv ln | cpp/string/wide/iswalnum}}
{{nv ln | cpp/string/wide/iswalpha}}
{{nv ln | cpp/string/wide/iswlower}}
{{nv ln | cpp/string/wide/iswupper}}
{{nv ln | cpp/string/wide/iswdigit}}
{{nv ln | cpp/string/wide/iswxdigit}}
{{nv ln | cpp/string/wide/iswblank|notes={{mark c++11}}}}
{{nv ln | cpp/string/wide/wctype}}
{{nv ln | cpp/string/wide/iswctype}}
{{nv col next}}
{{nv ln | cpp/string/wide/iswcntrl}}
{{nv ln | cpp/string/wide/iswgraph}}
{{nv ln | cpp/string/wide/iswspace}}
{{nv ln | cpp/string/wide/iswprint}}
{{nv ln | cpp/string/wide/iswpunct}}
{{nv ln | cpp/string/wide/towlower}}
{{nv ln | cpp/string/wide/towupper}}
{{nv ln | cpp/string/wide/wctrans}}
{{nv ln | cpp/string/wide/towctrans}}
{{nv col end}}

{{nv h2 | Conversions to numeric formats}}
{{nv col begin}}
{{nv ln | cpp/string/wide/wcstol|wcstol|wcstoll}}
{{nv ln | cpp/string/wide/wcstoul|wcstoul|wcstoull}}
{{nv col next}}
{{nv ln | cpp/string/wide/wcstof|wcstof|wcstod|wcstold}}
{{nv col end}}

{{nv h2 | String manipulation}}
{{nv col begin}}
{{nv ln | cpp/string/wide/wcslen}}
{{nv ln | cpp/string/wide/wcscpy}}
{{nv ln | cpp/string/wide/wcsncpy}}
{{nv ln | cpp/string/wide/wcscat}}
{{nv ln | cpp/string/wide/wcsncat}}
{{nv ln | cpp/string/wide/wcscmp}}
{{nv ln | cpp/string/wide/wcscoll}}
{{nv ln | cpp/string/wide/wcsncmp}}
{{nv col next}}
{{nv ln | cpp/string/wide/wcsxfrm}}
{{nv ln | cpp/string/wide/wcschr}}
{{nv ln | cpp/string/wide/wcsrchr}}
{{nv ln | cpp/string/wide/wcspbrk}}
{{nv ln | cpp/string/wide/wcsspn}}
{{nv ln | cpp/string/wide/wcscspn}}
{{nv ln | cpp/string/wide/wcsstr}}
{{nv ln | cpp/string/wide/wcstok}}
{{nv col end}}

{{nv h2 | Array manipulation}}
{{nv ln | cpp/string/wide/wmemcpy}}
{{nv ln | cpp/string/wide/wmemmove}}
{{nv ln | cpp/string/wide/wmemcmp}}
{{nv ln | cpp/string/wide/wmemchr}}
{{nv ln | cpp/string/wide/wmemset}}

{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/string/wide/navbar heading</title>
    <ns>10</ns>
    <id>25</id>
    <revision>
      <id>35918</id>
      <parentid>14487</parentid>
      <timestamp>2012-06-15T22:34:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/string/wide/sidebar heading]] to [[Template:cpp/string/wide/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="50">[[cpp/string/wide | Null-terminated wide strings]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread//navbar</title>
    <ns>10</ns>
    <id>4493</id>
    <revision>
      <id>35919</id>
      <parentid>15974</parentid>
      <timestamp>2012-06-15T22:34:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread//sidebar]] to [[Template:cpp/thread//navbar]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="8">&lt;!-- --&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread//title</title>
    <ns>10</ns>
    <id>4494</id>
    <revision>
      <id>15975</id>
      <timestamp>2011-12-18T16:41:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="87">&lt;onlyinclude&gt;{{cpp//title | n={{{n|}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/constructor</title>
    <ns>10</ns>
    <id>5111</id>
    <revision>
      <id>68883</id>
      <parentid>63609</parentid>
      <timestamp>2014-03-22T21:31:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2092</comment>
      <text xml:space="preserve" bytes="683">{{cpp/thread/{{{1|}}}/title|{{{1|}}}}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
{{{1|}}}();
}}
{{dcl | num=2 | since=c++11 |1=
{{{1|}}}(const {{{1|}}}&amp;) = delete;
}}
{{dcl end}}

1) Constructs an object of type {{tt|std::{{{1|}}}}}.

2) Copy constructor is deleted.

===Parameters===
(none)

===Exceptions===
1) May throw {{lc|std::system_error}} with {{lc|std::error_condition}} equal to {{lc|std::errc::operation_not_permitted}} if the thread has no privilege to create a condition variable, {{lc|std::errc::resource_unavailable_try_again}} if a non-memory resource limitation prevents this initialization, or another implementation-defined value.</text>
      <sha1>h53ds6erh6l19z2o3abza4yu2vwbomt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/destructor</title>
    <ns>10</ns>
    <id>5113</id>
    <revision>
      <id>63610</id>
      <parentid>55048</parentid>
      <timestamp>2013-07-10T01:45:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="760">{{cpp/thread/{{{1|}}}/title|~{{{1|}}}}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 | since=c++11 |
~{{{1|}}}();
}}
{{dcl end}}

Destroys the object of type {{c|std::{{{1|}}}}}

It is only safe to invoke the destructor if all threads have been notified. It is not required that they have exited their respective wait functions: some threads may still be waiting to reacquire the associated lock, or may be waiting to be scheduled to run after reacquiring it.

The programmer must ensure that no threads attempt to wait on {{c|*this}} once the destructor has been started, especially when the waiting threads are calling the wait functions in a loop or are using the overloads of the wait functions that take a predicate.

===Exceptions===
(none)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc constructor</title>
    <ns>10</ns>
    <id>2404</id>
    <revision>
      <id>59998</id>
      <parentid>55029</parentid>
      <timestamp>2013-06-01T06:43:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list constructor]] to [[Template:cpp/thread/condition variable/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem ctor | cpp/thread/{{{1|}}}/{{{1|}}} | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc destructor</title>
    <ns>10</ns>
    <id>2405</id>
    <revision>
      <id>60000</id>
      <parentid>55032</parentid>
      <timestamp>2013-06-01T06:43:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list destructor]] to [[Template:cpp/thread/condition variable/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem dtor | cpp/thread/{{{1|}}}/~{{{1|}}} | destructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc native handle</title>
    <ns>10</ns>
    <id>2412</id>
    <revision>
      <id>60002</id>
      <parentid>55033</parentid>
      <timestamp>2013-06-01T06:43:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list native handle]] to [[Template:cpp/thread/condition variable/dsc native handle]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/thread/{{{1|}}}/native_handle | returns the native handle}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc notify all</title>
    <ns>10</ns>
    <id>2407</id>
    <revision>
      <id>60004</id>
      <parentid>55034</parentid>
      <timestamp>2013-06-01T06:43:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list notify all]] to [[Template:cpp/thread/condition variable/dsc notify all]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/thread/{{{1|}}}/notify_all | notifies all waiting threads}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc notify one</title>
    <ns>10</ns>
    <id>2408</id>
    <revision>
      <id>60006</id>
      <parentid>55037</parentid>
      <timestamp>2013-06-01T06:43:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list notify one]] to [[Template:cpp/thread/condition variable/dsc notify one]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/thread/{{{1|}}}/notify_one | notifies one waiting thread}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc operator=</title>
    <ns>10</ns>
    <id>2406</id>
    <revision>
      <id>60008</id>
      <parentid>55040</parentid>
      <timestamp>2013-06-01T06:43:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list operator=]] to [[Template:cpp/thread/condition variable/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | nolink=true | operator{{=}} | notes={{cmark deleted}} | not copy-assignable}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc wait</title>
    <ns>10</ns>
    <id>2409</id>
    <revision>
      <id>60010</id>
      <parentid>55041</parentid>
      <timestamp>2013-06-01T06:43:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list wait]] to [[Template:cpp/thread/condition variable/dsc wait]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/thread/{{{1|}}}/wait | blocks the current thread until the condition variable is woken up}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc wait for</title>
    <ns>10</ns>
    <id>2410</id>
    <revision>
      <id>60012</id>
      <parentid>55042</parentid>
      <timestamp>2013-06-01T06:43:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list wait for]] to [[Template:cpp/thread/condition variable/dsc wait for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="156">{{dsc mem fun | cpp/thread/{{{1|}}}/wait_for | blocks the current thread until the condition variable is woken up or after the specified timeout duration }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/dsc wait until</title>
    <ns>10</ns>
    <id>2411</id>
    <revision>
      <id>60014</id>
      <parentid>55043</parentid>
      <timestamp>2013-06-01T06:43:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/condition variable/dcl list wait until]] to [[Template:cpp/thread/condition variable/dsc wait until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc mem fun | cpp/thread/{{{1|}}}/wait_until | blocks the current thread until the condition variable is woken up or until specified time point has been reached }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/example1</title>
    <ns>10</ns>
    <id>5049</id>
    <revision>
      <id>64626</id>
      <parentid>47954</parentid>
      <timestamp>2013-08-23T16:10:10Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>de-pessimize the example, protect cerr in the signalling thread, and comment mutex usage</comment>
      <text xml:space="preserve" bytes="1248">{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;condition_variable&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

std::{{{1|}}} cv;
std::mutex cv_m; // This mutex is used for three purposes:
                 // 1) to synchronize accesses to i
                 // 2) to synchronize accesses to std::cerr
                 // 3) for the condition variable cv
int i = 0;

void waits()
{
    std::unique_lock&lt;std::mutex&gt; lk(cv_m);
    std::cerr &lt;&lt; &quot;Waiting... \n&quot;;
    cv.wait(lk, []{return i == 1;});
    std::cerr &lt;&lt; &quot;...finished waiting. i == 1\n&quot;;
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard&lt;std::mutex&gt; lk(cv_m);
        std::cerr &lt;&lt; &quot;Notifying...\n&quot;;
    }
    cv.notify_all();

    std::this_thread::sleep_for(std::chrono::seconds(1));

    {
        std::lock_guard&lt;std::mutex&gt; lk(cv_m);
        i = 1;
        std::cerr &lt;&lt; &quot;Notifying again...\n&quot;;
    }
    cv.notify_all();
}

int main()
{
    std::thread t1(waits), t2(waits), t3(waits), t4(signals);
    t1.join(); 
    t2.join(); 
    t3.join();
    t4.join();
}
 | output=
Waiting...
Waiting...
Waiting...
Notifying...
Notifying again...
...finished waiting. i == 1
...finished waiting. i == 1
...finished waiting. i == 1
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/native handle</title>
    <ns>10</ns>
    <id>5125</id>
    <revision>
      <id>63611</id>
      <parentid>60914</parentid>
      <timestamp>2013-07-10T01:45:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use since= and until= params of {{ddcl}} template.</comment>
      <text xml:space="preserve" bytes="604">{{cpp/thread/{{{1|}}}/title|native_handle}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
native_handle_type native_handle();
}}
{{dcl end}}

Accesses the native handle of {{c|*this}}.

The meaning and the type of the result of this function is implementation-defined. On a POSIX system, this may be a value of type {{c|pthread_cond_t*}}. On a Windows system, this may be a {{c|PCONDITION_VARIABLE}}.

===Parameters===
(none)

===Return value===
The native handle of this condition variable.

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/thread/dsc native_handle}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/navbar</title>
    <ns>10</ns>
    <id>2389</id>
    <revision>
      <id>47769</id>
      <parentid>40024</parentid>
      <timestamp>2013-05-16T20:25:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="265">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/condition_variable/navbar heading
|content3 = cpp/thread/condition_variable/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/navbar content</title>
    <ns>10</ns>
    <id>2920</id>
    <revision>
      <id>55050</id>
      <parentid>35922</parentid>
      <timestamp>2013-06-01T05:19:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="594">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/condition_variable/condition_variable}}
{{nv mem ln | cpp/thread/condition_variable/~condition_variable}}

{{nv h2 | Notification}}
{{nv mem ln | cpp/thread/condition_variable/notify_one}}
{{nv mem ln | cpp/thread/condition_variable/notify_all}}

{{nv h2 | Waiting}}
{{nv mem ln | cpp/thread/condition_variable/wait}}
{{nv mem ln | cpp/thread/condition_variable/wait_for}}
{{nv mem ln | cpp/thread/condition_variable/wait_until}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/condition_variable/native handle}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/navbar heading</title>
    <ns>10</ns>
    <id>2392</id>
    <revision>
      <id>48091</id>
      <parentid>35923</parentid>
      <timestamp>2013-05-18T18:09:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="61">{{ltt|cpp/thread/condition_variable|std::condition_variable}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/notify all</title>
    <ns>10</ns>
    <id>5117</id>
    <revision>
      <id>64472</id>
      <parentid>63612</parentid>
      <timestamp>2013-08-18T00:55:25Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>single total order note, pessimization note (same as notify_one)</comment>
      <text xml:space="preserve" bytes="1111">{{cpp/thread/{{{1|}}}/title|notify_all}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void notify_all();
}}
{{dcl end}}

Unblocks all threads currently waiting for {{c|*this}}.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Notes===
The effects of {{tt|notify_one()}}/{{tt|notify_all()}} and {{tt|wait()}}/{{tt|wait_for()}}/{{tt|wait_until()}} take place in a single total order, so it's impossible for {{tt|notify_one()}} to, for example, be delayed and unblock a thread that started waiting just after the call to {{tt|notify_one()}} was made. &lt;!--LWG issue 2190, C++14 30.5[thread.condition]/4--&gt;

The notifying thread does not need to hold the lock on the same mutex as the one held by the waiting thread(s); in fact doing so is a pessimization, since the notified thread would immediately block again, waiting for the notifying thread to release the lock.

===Example===
{{include | cpp/thread/condition_variable/example1|{{{1|}}}}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_one | {{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/notify one</title>
    <ns>10</ns>
    <id>5115</id>
    <revision>
      <id>67112</id>
      <parentid>67111</parentid>
      <timestamp>2014-01-23T12:29:20Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <text xml:space="preserve" bytes="2180">{{cpp/thread/{{{1|}}}/title|notify_one}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void notify_one();
}}
{{dcl end}}

If any threads are waiting on {{c|*this}}, calling {{tt|notify_one}} unblocks one of the waiting threads.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
{{noexcept}}

===Notes===
The effects of {{tt|notify_one()}}/{{tt|notify_all()}} and {{tt|wait()}}/{{tt|wait_for()}}/{{tt|wait_until()}} take place in a single total order, so it's impossible for {{tt|notify_one()}} to, for example, be delayed and unblock a thread that started waiting just after the call to {{tt|notify_one()}} was made. &lt;!--LWG issue 2190, C++14 30.5[thread.condition]/4--&gt;

The notifying thread does not need to hold the lock on the same mutex as the one held by the waiting thread(s); in fact doing so is a pessimization, since the notified thread would immediately block again, waiting for the notifying thread to release the lock.

===Example===
{{example
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;condition_variable&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

std::{{{1}}} cv;
std::mutex cv_m;
int i = 0;
bool done = false;

void waits()
{
    std::unique_lock&lt;std::mutex&gt; lk(cv_m);
    std::cout &lt;&lt; &quot;Waiting... \n&quot;;
    cv.wait(lk, []{return i == 1;});
    std::cout &lt;&lt; &quot;...finished waiting. i == 1\n&quot;;
    done = true;
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout &lt;&lt; &quot;Notifying falsely...\n&quot;;
    cv.notify_one();
   //Most probably, the waiting thread is awaken unnecessarily.

    std::unique_lock&lt;std::mutex&gt; lk(cv_m);
    i = 1;
    while (!done) 
    {
        std::cout &lt;&lt; &quot;Notifying true change...\n&quot;;
        lk.unlock(); //It is a good idea unlock before notifying.
        cv.notify_one();
        std::this_thread::sleep_for(std::chrono::seconds(1));
        lk.lock();
    }
}

int main()
{
    std::thread t1(waits), t2(signals);
    t1.join(); 
    t2.join();
}
 | output=
Waiting... 
Notifying falsely...
Notifying true change...
...finished waiting. i == 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc notify_all | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>05q2z2q11qwtvcjq2fscaxgkdil9xl3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/title</title>
    <ns>10</ns>
    <id>5023</id>
    <revision>
      <id>18189</id>
      <timestamp>2012-01-25T21:05:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=condition_variable::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/wait</title>
    <ns>10</ns>
    <id>5119</id>
    <revision>
      <id>68878</id>
      <parentid>64625</parentid>
      <timestamp>2014-03-22T21:18:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2135</comment>
      <text xml:space="preserve" bytes="3161">{{cpp/thread/{{{1|}}}/title|wait}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num = 1 | since=c++11 |
{{#ifeq:{{{1|}}} | condition_variable |
void wait( std::unique_lock&lt;std::mutex&gt;&amp; lock );
|
template&lt; class Lock &gt;
void wait( Lock&amp; lock );
}}
}}
{{dcl | num = 2 | since=c++11 |
{{#ifeq:{{{1|}}} | condition_variable |
template&lt; class Predicate &gt;
void wait( std::unique_lock&lt;std::mutex&gt;&amp; lock, Predicate pred );
|
template&lt; class Lock, class Predicate &gt;
void wait( Lock&amp; lock, Predicate pred );
}}
}}
{{dcl end}}

{{tt|wait}} causes the current thread to block until the condition variable is notified or a spurious wakeup occurs, optionally looping until some predicate is satisfied.

@1@ Atomically releases {{tt|lock}}, blocks the current executing thread, and adds it to the list of threads waiting on {{c|*this}}. The thread will be unblocked when {{lc|notify_all()}} or {{lc|notify_one()}} is executed. It may also be unblocked spuriously. When unblocked, regardless of the reason, {{tt|lock}} is reacquired and {{tt|wait}} exits. {{rev inl|until=c++14|If this function exits via exception, {{tt|lock}} is also reacquired.}}
@2@ Equivalent to 
{{source|1=
while (!pred()) {
    wait(lock);
}
}}
This overload may be used to ignore spurious awakenings while waiting for a specific condition to become true. Note that before enter to this method {{tt|lock}} must be acquired, after {{tt|wait(lock)}} exits it is also reacquired, i.e. {{tt|lock}} can be used as a guard to {{tt|pred()}} access.

{{rev begin}}
{{rev|since=c++14|If these functions fail to meet the postconditions ({{c|lock.owns_lock(){{==}}true}} and {{c|lock.mutex()}} is locked by the calling thread), {{lc|std::terminate}} is called. For example, this could happen if relocking the mutex throws an exception,}}
{{rev end}}

===Parameters===
{{par begin}}
{{#ifeq:{{{1|}}} | condition_variable|
{{par | lock | an object of type {{c|std::unique_lock&lt;std::mutex&gt;}}, which must be locked by the current thread}}
|
{{par | lock | an object of type {{tt|Lock}} that meets the {{concept|BasicLockable}} requirements, which must be locked by the current thread}}
}}
{{par pred0 | pred | value=false | if the waiting should be continued}}
{{par end}}

===Return value===
(none)

===Exceptions===
{{rev begin}}
{{rev|until=c++14|
May throw {{lc|std::system_error}}, may also propagate exceptions thrown by [[cpp/thread/unique_lock/lock|{{c|lock.lock()}}]] or [[cpp/thread/unique_lock/unlock|{{c|lock.unlock()}}]].
}}
{{rev|since=c++14|
Does not throw
}}
{{rev end}}

===Notes===
Calling this function if [[cpp/thread/unique_lock/mutex|{{c|lock.mutex()}}]] is not locked by the current thread is undefined behavior.

Calling this function if [[cpp/thread/unique_lock/mutex|{{c|lock.mutex()}}]] is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.

===Example===
{{include | cpp/thread/condition_variable/example1|{{{1|}}}}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for | {{{1|}}}}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>7ia6ofqtk8510t55q07skzgtc69x1sz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/wait for</title>
    <ns>10</ns>
    <id>5121</id>
    <revision>
      <id>71848</id>
      <parentid>68880</parentid>
      <timestamp>2014-06-27T19:36:38Z</timestamp>
      <contributor>
        <ip>84.154.49.84</ip>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="4663">{{cpp/thread/{{{1|}}}/title|wait_for}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num = 1 | since=c++11 |
{{#ifeq:{{{1|}}} | condition_variable |
template&lt; class Rep, class Period &gt;
std::cv_status wait_for( std::unique_lock&lt;std::mutex&gt;&amp; lock,
|
template&lt; class Lock, class Rep, class Period &gt;
std::cv_status wait_for( Lock&amp; lock,
}}
                         const std::chrono::duration&lt;Rep, Period&gt;&amp; rel_time);
}}
{{dcl | num = 2 | since=c++11 |
{{#ifeq:{{{1|}}} | condition_variable|
template&lt; class Rep, class Period, class Predicate &gt;
bool wait_for( std::unique_lock&lt;std::mutex&gt;&amp; lock,
|
template&lt; class Lock, class Rep, class Period, class Predicate &gt;
bool wait_for( Lock&amp; lock,
}}
               const std::chrono::duration&lt;Rep, Period&gt;&amp; rel_time,
               Predicate pred);
}}
{{dcl end}}

@1@ Atomically releases {{tt|lock}}, blocks the current executing thread, and adds it to the list of threads waiting on {{c|*this}}. The thread will be unblocked when {{lc|notify_all()}} or {{lc|notify_one()}} is executed, or when the relative timeout {{tt|rel_time}} expires. It may also be unblocked spuriously. When unblocked, regardless of the reason, {{tt|lock}} is reacquired and {{tt|wait_for()}} exits. {{rev inl|until=c++14|If this function exits via exception, {{tt|lock}} is also reacquired.}}

@2@ Equivalent to {{c|return wait_until(lock, std::chrono::steady_clock::now() + rel_time);}}. This overload may be used to ignore spurious awakenings.

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

Calling this function if {{tt|lock.mutex()}} is not locked by the current thread is undefined behavior.

Calling this function if {{tt|lock.mutex()}} is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.

{{rev begin}}
{{rev|since=c++14|If these functions fail to meet the postconditions ({{c|lock.owns_lock(){{==}}true}} and {{c|lock.mutex()}} is locked by the calling thread), {{lc|std::terminate}} is called. For example, this could happen if relocking the mutex throws an exception,}}
{{rev end}}

===Parameters===
{{par begin}}
{{#ifeq:{{{1|}}} | condition_variable |
{{par | lock | an object of type {{c|std::unique_lock&lt;std::mutex&gt;}}, which must be locked by the current thread}}
|
{{par | lock | an object of type {{tt|Lock}} that meets the {{concept|BasicLockable}} requirements, which must be locked by the current thread}}
}}
{{par | rel_time | an object of type {{lc|std::chrono::duration}} representing the maximum time to spend waiting}}
{{par pred0 | pred | value=false | if the waiting should be continued}}
{{par end}}

===Return value===
@1@ {{lc|std::cv_status::timeout}} if the relative timeout specified by {{tt|rel_time}} expired, {{lc|std::cv_status::no_timeout}} otherwise.

@2@ {{c|false}} if the predicate {{tt|pred}} still evaluates to {{c|false}} after the {{tt|rel_time}} timeout expired, otherwise {{c|true}}.

===Exceptions===
{{rev begin}}
{{rev|until=c++14|
May throw {{lc|std::system_error}}, may also propagate exceptions thrown by {{c|lock.lock()}} or {{c|lock.unlock()}}.
}}
{{rev|since=c++14|
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)
}}
{{rev end}}

===Example===
{{example
 |
 | code=
#include &lt;iostream&gt;
#include &lt;atomic&gt;
#include &lt;condition_variable&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

std::{{{1|}}} cv;
std::mutex cv_m;
std::atomic&lt;int&gt; i{0};

void waits(int idx)
{
    std::unique_lock&lt;std::mutex&gt; lk(cv_m);
    if(cv.wait_for(lk, std::chrono::milliseconds(idx*100), [](){return i == 1;})) 
        std::cerr &lt;&lt; &quot;Thread &quot; &lt;&lt; idx &lt;&lt; &quot; finished waiting. i == &quot; &lt;&lt; i &lt;&lt; '\n';
    else
        std::cerr &lt;&lt; &quot;Thread &quot; &lt;&lt; idx &lt;&lt; &quot; timed out. i == &quot; &lt;&lt; i &lt;&lt; '\n';
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(120));
    std::cerr &lt;&lt; &quot;Notifying...\n&quot;;
    cv.notify_all();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    i = 1;
    std::cerr &lt;&lt; &quot;Notifying again...\n&quot;;
    cv.notify_all();
}

int main()
{
    std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
    t1.join(); t2.join(), t3.join(), t4.join();
}
 | output=
Thread 1 timed out. i == 0
Notifying...
Thread 2 timed out. i == 0
Notifying again...
Thread 3 finished waiting. i == 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc wait | {{{1|}}}}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_until | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>boi3wjd4s0gitvqir84bs1oy68dzwa3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable/wait until</title>
    <ns>10</ns>
    <id>5123</id>
    <revision>
      <id>68882</id>
      <parentid>68881</parentid>
      <timestamp>2014-03-22T21:28:48Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>note from lwg 2093</comment>
      <text xml:space="preserve" bytes="5464">{{cpp/thread/{{{1|}}}/title|wait_until}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num = 1 | since=c++11 |
{{
#ifeq:{{{1|}}} | condition_variable|
template&lt; class Clock, class Duration &gt;
std::cv_status wait_until( std::unique_lock&lt;std::mutex&gt;&amp; lock,
|
template&lt; class Lock, class Clock, class Duration &gt;
std::cv_status wait_until( Lock&amp; lock,
}}
                           const std::chrono::time_point&lt;Clock, Duration&gt;&amp; timeout_time );
}}
{{dcl | num = 2 | since=c++11 |
{{#ifeq:{{{1|}}} | condition_variable|
template&lt; class Clock, class Duration, class Predicate &gt;
bool wait_until( std::unique_lock&lt;std::mutex&gt;&amp; lock,
|
template&lt; class Lock, class Clock, class Duration, class Predicate &gt;
bool wait_until( Lock&amp; lock,
}}
                 const std::chrono::time_point&lt;Clock, Duration&gt;&amp; timeout_time,
                 Predicate pred );
}}
{{dcl end}}

{{tt|wait_until}} causes the current thread to block until the condition variable is notified, a specific time is reached, or a spurious wakeup occurs, optionally looping until some predicate is satisfied.

@1@ Atomically releases {{tt|lock}}, blocks the current executing thread, and adds it to the list of threads waiting on {{c|*this}}. The thread will be unblocked when {{lc|notify_all()}} or {{lc|notify_one()}} is executed, or when the absolute time point {{tt|timeout_time}} is reached. It may also be unblocked spuriously. When unblocked, regardless of the reason, {{tt|lock}} is reacquired and {{tt|wait_until}} exits. {{rev inl|until=c++14|If this function exits via exception, {{tt|lock}} is also reacquired.}}

@2@ Equivalent to

{{source|1=
while (!pred()) {
    if (wait_until(lock, abs_time) == std::cv_status::timeout) {
        return pred();
    }
}
return true;
}}

@@This overload may be used to ignore spurious wakeups.

The clock tied to {{tt|timeout_time}} is used, which means that adjustments of the clock are taken into account. Thus, the maximum duration of the block might, but might not, be less or more than  {{c|timeout_time - Clock::now()}} at the time of the call, depending on the direction of the adjustment. The function also may block for longer than until after {{tt|timeout_time}} has been reached due to scheduling or resource contention delays.

Calling this function if {{tt|lock.mutex()}} is not locked by the current thread is undefined behavior.

Calling this function if {{tt|lock.mutex()}} is not the same mutex as the one used by all other threads that are currently waiting on the same condition variable is undefined behavior.

{{rev begin}}
{{rev|since=c++14|If these functions fail to meet the postconditions ({{c|lock.owns_lock(){{==}}true}} and {{c|lock.mutex()}} is locked by the calling thread), {{lc|std::terminate}} is called. For example, this could happen if relocking the mutex throws an exception,}}
{{rev end}}

===Parameters===
{{par begin}}
{{#ifeq:{{{1|}}} | condition_variable|
{{par | lock | an object of type std::unique_lock&lt;std::mutex&gt;, which must be locked by the current thread}}
|
{{par | lock | an object of type {{tt|Lock}} that meets the requirements of {{concept|BasicLockable}}, which must be locked by the current thread}}
}}
{{par | timeout_time | an object of type {{lc|std::chrono::time_point}} representing the time when to stop waiting}}
{{par pred0 | pred | value=false | if the waiting should be continued}}
{{par end}}

===Return value===
@1@ {{lc|std::cv_status::timeout}} if the absolute timeout specified by {{tt|abs_time}} was reached, {{lc|std::cv_status::no_timeout}} overwise.

@2@ {{c|false}} if the predicate {{tt|pred}} still evaluates to {{c|false}} after the {{tt|abs_time}} timeout expired, otherwise {{c|true}}. If the timeout had already expired, evaluates and returns the result of {{tt|pred}}.

===Exceptions===
{{rev begin}}
{{rev|until=c++14|
May throw {{lc|std::system_error}}, may also propagate exceptions thrown by {{c|lock.lock()}} or {{c|lock.unlock()}}.
}}
{{rev|since=c++14|
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)
}}
{{rev end}}

===Example===
{{example
 | 
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;atomic&gt;
#include &lt;condition_variable&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

std::{{{1|}}} cv;
std::mutex cv_m;
std::atomic&lt;int&gt; i = ATOMIC_VAR_INIT(0);

void waits(int idx)
{
    std::unique_lock&lt;std::mutex&gt; lk(cv_m);
    auto now = std::chrono::system_clock::now();
    if(cv.wait_until(lk, now + std::chrono::milliseconds(idx*100), [](){return i == 1;}))
        std::cerr &lt;&lt; &quot;Thread &quot; &lt;&lt; idx &lt;&lt; &quot; finished waiting. i == &quot; &lt;&lt; i &lt;&lt; '\n';
    else
        std::cerr &lt;&lt; &quot;Thread &quot; &lt;&lt; idx &lt;&lt; &quot; timed out. i == &quot; &lt;&lt; i &lt;&lt; '\n';
}

void signals()
{
    std::this_thread::sleep_for(std::chrono::milliseconds(120));
    std::cerr &lt;&lt; &quot;Notifying...\n&quot;;
    cv.notify_all();
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    i = 1;
    std::cerr &lt;&lt; &quot;Notifying again...\n&quot;;
    cv.notify_all();
}

int main()
{
    std::thread t1(waits, 1), t2(waits, 2), t3(waits, 3), t4(signals);
    t1.join(); 
    t2.join();
    t3.join();
    t4.join();
}
 | output=
Thread 1 timed out. i == 0
Notifying...
Thread 2 timed out. i == 0
Notifying again...
Thread 3 finished waiting. i == 1
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/condition_variable/dsc wait | {{{1|}}}}}
{{dsc inc | cpp/thread/condition_variable/dsc wait_for | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>6clqxax7bqqoj6mbv48b2hiirt0pv9g</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable any/navbar</title>
    <ns>10</ns>
    <id>2391</id>
    <revision>
      <id>40025</id>
      <parentid>35616</parentid>
      <timestamp>2012-09-28T20:19:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="275">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/condition_variable_any/navbar heading
|content3 = cpp/thread/condition_variable_any/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable any/navbar content</title>
    <ns>10</ns>
    <id>2921</id>
    <revision>
      <id>55064</id>
      <parentid>35924</parentid>
      <timestamp>2013-06-01T05:19:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="634">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/condition_variable_any/condition_variable_any}}
{{nv mem ln | cpp/thread/condition_variable_any/~condition_variable_any}}

{{nv h2 | Notification}}
{{nv mem ln | cpp/thread/condition_variable_any/notify_one}}
{{nv mem ln | cpp/thread/condition_variable_any/notify_all}}

{{nv h2 | Waiting}}
{{nv mem ln | cpp/thread/condition_variable_any/wait}}
{{nv mem ln | cpp/thread/condition_variable_any/wait_for}}
{{nv mem ln | cpp/thread/condition_variable_any/wait_until}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/condition_variable_any/native handle}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable any/navbar heading</title>
    <ns>10</ns>
    <id>2390</id>
    <revision>
      <id>47766</id>
      <parentid>35612</parentid>
      <timestamp>2013-05-16T20:24:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="69">{{ltt|cpp/thread/condition_variable_any|std::condition_variable_any}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/condition variable any/title</title>
    <ns>10</ns>
    <id>5028</id>
    <revision>
      <id>18201</id>
      <timestamp>2012-01-25T21:37:32Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="119">&lt;onlyinclude&gt;{{cpp/title | n=condition_variable_any::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc async</title>
    <ns>10</ns>
    <id>6469</id>
    <revision>
      <id>60016</id>
      <parentid>55065</parentid>
      <timestamp>2013-06-01T06:43:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list async]] to [[Template:cpp/thread/dsc async]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="176">{{dsc tfun | cpp/thread/async | runs a function asynchronously (potentially in a new thread) and returns a {{lc|std::future}} that will hold the result | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc call once</title>
    <ns>10</ns>
    <id>2502</id>
    <revision>
      <id>60018</id>
      <parentid>55068</parentid>
      <timestamp>2013-06-01T06:43:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list call once]] to [[Template:cpp/thread/dsc call once]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc tfun | cpp/thread/call_once | invokes a function only once even if called from multiple threads | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc future</title>
    <ns>10</ns>
    <id>6467</id>
    <revision>
      <id>60020</id>
      <parentid>55071</parentid>
      <timestamp>2013-06-01T06:43:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list future]] to [[Template:cpp/thread/dsc future]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/thread/future | waits for a value that is set asynchronously | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc future category</title>
    <ns>10</ns>
    <id>8548</id>
    <revision>
      <id>60022</id>
      <parentid>55074</parentid>
      <timestamp>2013-06-01T06:43:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list future category]] to [[Template:cpp/thread/dsc future category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc fun | cpp/thread/future_category  | notes={{mark c++11}} | identifies the future error category}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc future errc</title>
    <ns>10</ns>
    <id>8549</id>
    <revision>
      <id>60024</id>
      <parentid>55075</parentid>
      <timestamp>2013-06-01T06:43:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list future errc]] to [[Template:cpp/thread/dsc future errc]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc enum | cpp/thread/future_errc  | notes={{mark c++11}} | identifies the future error codes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc future error</title>
    <ns>10</ns>
    <id>8547</id>
    <revision>
      <id>60026</id>
      <parentid>55078</parentid>
      <timestamp>2013-06-01T06:43:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list future error]] to [[Template:cpp/thread/dsc future error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc class | cpp/thread/future_error | notes={{mark c++11}} | reports an error related to futures or promises }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc future status</title>
    <ns>10</ns>
    <id>8553</id>
    <revision>
      <id>60028</id>
      <parentid>55081</parentid>
      <timestamp>2013-06-01T06:43:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list future status]] to [[Template:cpp/thread/dsc future status]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc enum | cpp/thread/future_status | specifies the results of timed waits performed on {{lc|std::future}} and {{lc|std::shared_future}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc get id</title>
    <ns>10</ns>
    <id>2242</id>
    <revision>
      <id>60030</id>
      <parentid>55082</parentid>
      <timestamp>2013-06-01T06:43:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list get id]] to [[Template:cpp/thread/dsc get id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/thread/get_id | returns the thread id of the current thread | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc launch</title>
    <ns>10</ns>
    <id>6470</id>
    <revision>
      <id>60032</id>
      <parentid>55085</parentid>
      <timestamp>2013-06-01T06:43:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list launch]] to [[Template:cpp/thread/dsc launch]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc enum | cpp/thread/launch | specifies the launch policy for {{lc|std::async}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc lock</title>
    <ns>10</ns>
    <id>2252</id>
    <revision>
      <id>60034</id>
      <parentid>55088</parentid>
      <timestamp>2013-06-01T06:43:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list lock]] to [[Template:cpp/thread/dsc lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tfun | cpp/thread/lock | locks specified mutexes, blocks if any are unavailable | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc lock guard</title>
    <ns>10</ns>
    <id>2249</id>
    <revision>
      <id>60036</id>
      <parentid>55089</parentid>
      <timestamp>2013-06-01T06:44:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list lock guard]] to [[Template:cpp/thread/dsc lock guard]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tclass | cpp/thread/lock_guard | implements a strictly scope-based mutex ownership wrapper | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc lock tag</title>
    <ns>10</ns>
    <id>4455</id>
    <revision>
      <id>60038</id>
      <parentid>55094</parentid>
      <timestamp>2013-06-01T06:44:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list lock tag]] to [[Template:cpp/thread/dsc lock tag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc const | cpp/thread/lock_tag | title=defer_lock&lt;br&gt;try_to_lock&lt;br&gt;adopt_lock | tag constants used to specify locking strategy | notes={{mark c++11}}&lt;br/&gt;{{mark c++11}}&lt;br/&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc lock tag t</title>
    <ns>10</ns>
    <id>4454</id>
    <revision>
      <id>60040</id>
      <parentid>55097</parentid>
      <timestamp>2013-06-01T06:44:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list lock tag t]] to [[Template:cpp/thread/dsc lock tag t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="197">{{dsc class | cpp/thread/lock_tag_t | title=defer_lock_t&lt;br&gt;try_to_lock_t&lt;br&gt;adopt_lock_t | tag type used to specify locking strategy | notes={{mark c++11}}&lt;br/&gt;{{mark c++11}}&lt;br/&gt;{{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc mutex</title>
    <ns>10</ns>
    <id>2245</id>
    <revision>
      <id>60042</id>
      <parentid>55098</parentid>
      <timestamp>2013-06-01T06:44:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list mutex]] to [[Template:cpp/thread/dsc mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc class | cpp/thread/mutex | provides basic mutual exclusion facility | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc once flag</title>
    <ns>10</ns>
    <id>2501</id>
    <revision>
      <id>60044</id>
      <parentid>55099</parentid>
      <timestamp>2013-06-01T06:44:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list once flag]] to [[Template:cpp/thread/dsc once flag]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc class | cpp/thread/once_flag | helper object to ensure that {{ltt|cpp/thread/call_once}} invokes the function only once | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc packaged task</title>
    <ns>10</ns>
    <id>6466</id>
    <revision>
      <id>60046</id>
      <parentid>55100</parentid>
      <timestamp>2013-06-01T06:44:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list packaged task]] to [[Template:cpp/thread/dsc packaged task]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tclass | cpp/thread/packaged_task | packages a function to store its return value for asynchronous retrieval | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc promise</title>
    <ns>10</ns>
    <id>6465</id>
    <revision>
      <id>60048</id>
      <parentid>55103</parentid>
      <timestamp>2013-06-01T06:44:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list promise]] to [[Template:cpp/thread/dsc promise]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc tclass | cpp/thread/promise | stores a value for asynchronous retrieval | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc recursive mutex</title>
    <ns>10</ns>
    <id>2246</id>
    <revision>
      <id>60050</id>
      <parentid>55104</parentid>
      <timestamp>2013-06-01T06:44:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list recursive mutex]] to [[Template:cpp/thread/dsc recursive mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="153">{{dsc class | cpp/thread/recursive_mutex | provides mutual exclusion facility which can be locked recursively by the same thread | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc recursive timed mutex</title>
    <ns>10</ns>
    <id>2248</id>
    <revision>
      <id>60052</id>
      <parentid>55107</parentid>
      <timestamp>2013-06-01T06:44:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list recursive timed mutex]] to [[Template:cpp/thread/dsc recursive timed mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="201">{{dsc class | cpp/thread/recursive_timed_mutex | provides mutual exclusion facility which can be locked recursively&lt;br&gt; by the same thread and implements locking with a timeout | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc shared future</title>
    <ns>10</ns>
    <id>6468</id>
    <revision>
      <id>60054</id>
      <parentid>55108</parentid>
      <timestamp>2013-06-01T06:44:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list shared future]] to [[Template:cpp/thread/dsc shared future]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tclass | cpp/thread/shared_future | waits for a value (possibly referenced by other futures) that is set asynchronously | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc shared lock</title>
    <ns>10</ns>
    <id>9980</id>
    <revision>
      <id>60056</id>
      <parentid>55109</parentid>
      <timestamp>2013-06-01T06:44:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list shared lock]] to [[Template:cpp/thread/dsc shared lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc tclass | cpp/thread/shared_lock | implements movable shared mutex ownership wrapper | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc shared mutex</title>
    <ns>10</ns>
    <id>13467</id>
    <redirect title="Template:cpp/thread/dsc shared timed mutex" />
    <revision>
      <id>68893</id>
      <timestamp>2014-03-22T22:23:42Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[Template:cpp/thread/dsc shared mutex]] to [[Template:cpp/thread/dsc shared timed mutex]]: renamed in C++14</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/thread/dsc shared timed mutex]]</text>
      <sha1>fm34192iy6pr1lt52obwe886q5o3zlf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc shared timed mutex</title>
    <ns>10</ns>
    <id>9979</id>
    <revision>
      <id>68894</id>
      <parentid>68892</parentid>
      <timestamp>2014-03-22T22:24:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>rename</comment>
      <text xml:space="preserve" bytes="112">{{dsc class | cpp/thread/shared_timed_mutex | provides shared mutual exclusion facility | notes={{mark c++14}}}}</text>
      <sha1>jz0dpr7mupptkhss6trgra9pwt2n2nu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc sleep for</title>
    <ns>10</ns>
    <id>2243</id>
    <revision>
      <id>60060</id>
      <parentid>55113</parentid>
      <timestamp>2013-06-01T06:44:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list sleep for]] to [[Template:cpp/thread/dsc sleep for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc fun | cpp/thread/sleep_for | stops the execution of the current thread for a specified time duration | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc sleep until</title>
    <ns>10</ns>
    <id>2244</id>
    <revision>
      <id>60062</id>
      <parentid>55114</parentid>
      <timestamp>2013-06-01T06:44:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list sleep until]] to [[Template:cpp/thread/dsc sleep until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | cpp/thread/sleep_until | stops the execution of the current thread until a specified time point | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc thread</title>
    <ns>10</ns>
    <id>2240</id>
    <revision>
      <id>60064</id>
      <parentid>55115</parentid>
      <timestamp>2013-06-01T06:44:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list thread]] to [[Template:cpp/thread/dsc thread]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc class | cpp/thread/thread | manages a separate thread | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc timed mutex</title>
    <ns>10</ns>
    <id>2247</id>
    <revision>
      <id>60066</id>
      <parentid>55118</parentid>
      <timestamp>2013-06-01T06:44:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list timed mutex]] to [[Template:cpp/thread/dsc timed mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc class | cpp/thread/timed_mutex | provides mutual exclusion facility which implements locking with a timeout | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc try lock</title>
    <ns>10</ns>
    <id>2251</id>
    <revision>
      <id>60068</id>
      <parentid>55119</parentid>
      <timestamp>2013-06-01T06:44:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list try lock]] to [[Template:cpp/thread/dsc try lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc tfun | cpp/thread/try_lock | attempts to obtain ownership of mutexes via repeated calls to {{tt|try_lock}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc unique lock</title>
    <ns>10</ns>
    <id>2250</id>
    <revision>
      <id>60070</id>
      <parentid>55122</parentid>
      <timestamp>2013-06-01T06:44:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list unique lock]] to [[Template:cpp/thread/dsc unique lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc tclass | cpp/thread/unique_lock | implements movable mutex ownership wrapper | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/dsc yield</title>
    <ns>10</ns>
    <id>2241</id>
    <revision>
      <id>60072</id>
      <parentid>55123</parentid>
      <timestamp>2013-06-01T06:44:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/dcl list yield]] to [[Template:cpp/thread/dsc yield]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc fun | cpp/thread/yield | suggests that the implementation reschedule execution of threads| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/example lock tag</title>
    <ns>10</ns>
    <id>4474</id>
    <revision>
      <id>45944</id>
      <parentid>45943</parentid>
      <timestamp>2013-02-07T11:06:44Z</timestamp>
      <contributor>
        <username>Juanchopanza</username>
        <id>696</id>
      </contributor>
      <minor/>
      <comment>std::lock_guards missing template arguments.</comment>
      <text xml:space="preserve" bytes="1003">{{example |
|code=
#include &lt;mutex&gt;
#include &lt;thread&gt;

struct bank_account {
    explicit bank_account(int balance) : balance(balance) {}
    int balance;
    std::mutex m;
};

void transfer(bank_account &amp;from, bank_account &amp;to, int amount)
{
    // attempt to lock both mutexes without deadlock
    std::lock(from.m, to.m);

    // make sure both already-locked mutexes are unlocked when 
    // we're done; if we just used the lock_guard without std::lock
    // and std::adopt_lock, we might deadlock with other calls to transfer
    std::lock_guard&lt;std::mutex&gt; lock1(from.m, std::adopt_lock);
    std::lock_guard&lt;std::mutex&gt; lock2(to.m, std::adopt_lock);

    from.balance -= amount;
    to.balance += amount;
}

int main()
{
    bank_account my_account(100);
    bank_account your_account(50);

    std::thread t1(transfer, std::ref(my_account), std::ref(your_account), 10);
    std::thread t2(transfer, std::ref(your_account), std::ref(my_account), 5);

    t1.join();
    t2.join();
}
|output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc constructor</title>
    <ns>10</ns>
    <id>5033</id>
    <revision>
      <id>60074</id>
      <parentid>55124</parentid>
      <timestamp>2013-06-01T06:44:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list constructor]] to [[Template:cpp/thread/future/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem ctor | cpp/thread/future/future | constructs the future object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc destructor</title>
    <ns>10</ns>
    <id>5034</id>
    <revision>
      <id>60076</id>
      <parentid>55127</parentid>
      <timestamp>2013-06-01T06:44:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list destructor]] to [[Template:cpp/thread/future/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem dtor | cpp/thread/future/~future | destructs the future object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc future category</title>
    <ns>10</ns>
    <id>4827</id>
    <revision>
      <id>60078</id>
      <parentid>55128</parentid>
      <timestamp>2013-06-01T06:44:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list future category]] to [[Template:cpp/thread/future/dsc future category]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc fun | cpp/thread/future/future_category  | notes={{mark c++11}} | identifies the future error category}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc get</title>
    <ns>10</ns>
    <id>5037</id>
    <revision>
      <id>60080</id>
      <parentid>55129</parentid>
      <timestamp>2013-06-01T06:44:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list get]] to [[Template:cpp/thread/future/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">{{dsc mem fun | cpp/thread/{{{1|}}}/get | returns the result}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc operator=</title>
    <ns>10</ns>
    <id>5035</id>
    <revision>
      <id>60082</id>
      <parentid>55130</parentid>
      <timestamp>2013-06-01T06:44:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list operator=]] to [[Template:cpp/thread/future/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/thread/future/operator{{=}} | moves the future object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc share</title>
    <ns>10</ns>
    <id>5036</id>
    <revision>
      <id>60084</id>
      <parentid>55133</parentid>
      <timestamp>2013-06-01T06:44:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list share]] to [[Template:cpp/thread/future/dsc share]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc mem fun | cpp/thread/future/share | transfers the shared state from {{tt|*this}} to a {{ltt|cpp/thread/shared_future|shared_future}} and returns it}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc valid</title>
    <ns>10</ns>
    <id>5038</id>
    <revision>
      <id>60086</id>
      <parentid>55136</parentid>
      <timestamp>2013-06-01T06:44:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list valid]] to [[Template:cpp/thread/future/dsc valid]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/thread/{{{1|}}}/valid | checks if the future has a shared state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc wait</title>
    <ns>10</ns>
    <id>5039</id>
    <revision>
      <id>60088</id>
      <parentid>55137</parentid>
      <timestamp>2013-06-01T06:44:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list wait]] to [[Template:cpp/thread/future/dsc wait]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/thread/{{{1|}}}/wait | waits for the result to become available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc wait for</title>
    <ns>10</ns>
    <id>5040</id>
    <revision>
      <id>60090</id>
      <parentid>55140</parentid>
      <timestamp>2013-06-01T06:44:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list wait for]] to [[Template:cpp/thread/future/dsc wait for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem fun | cpp/thread/{{{1|}}}/wait_for | waits for the result, returns if it is not available for the specified timeout duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/dsc wait until</title>
    <ns>10</ns>
    <id>5041</id>
    <revision>
      <id>60092</id>
      <parentid>55143</parentid>
      <timestamp>2013-06-01T06:44:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future/dcl list wait until]] to [[Template:cpp/thread/future/dsc wait until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="147">{{dsc mem fun | cpp/thread/{{{1|}}}/wait_until | waits for the result, returns if it is not available until specified time point has been reached}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/get</title>
    <ns>10</ns>
    <id>6454</id>
    <revision>
      <id>65693</id>
      <parentid>64150</parentid>
      <timestamp>2013-09-27T04:22:30Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>return value for shared_future</comment>
      <text xml:space="preserve" bytes="2438">{{cpp/thread/{{{1|}}}/title|get}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{#switch:{{{1|}}}
|shared_future=
{{dcl | num=1 | notes={{mark|member only of generic {{tt|{{{1}}}}} template}}&lt;br&gt;{{mark since c++11}} | 1=
const T&amp; get() const;
}}
{{dcl | num=2 | notes={{mark|member only of {{tt|{{{1}}}&lt;T&amp;&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T&amp; get() const;
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|{{{1}}}&lt;void&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void get() const;
}}
|
{{dcl | num=1 | notes={{mark|member only of generic {{tt|{{{1}}}}} template}}&lt;br&gt;{{mark since c++11}} | 1=
T get();
}}
{{dcl | num=2 | notes={{mark|member only of {{tt|{{{1}}}&lt;T&amp;&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
T&amp; get();
}}
{{dcl | num=3 | notes={{mark|member only of {{tt|{{{1}}}&lt;void&gt;}} template specialization}}&lt;br&gt;{{mark since c++11}} | 1=
void get();
}}
}}
{{dcl end}}

The {{tt|get}} method waits until the {{tt|{{{1}}}}} has a valid result and (depending on which template is used) retrieves it. It effectively calls {{lc|wait()}} in order to wait for the result.

The generic template and two template specializations each contain a single version of {{tt|get}}. The three versions of {{tt|get}} differ only in the return type.

The behavior is undefined if {{lc|valid()}} is {{c|false}} before the call to this function. 

{{#ifeq: {{{1}}} | future |
{{lc|valid()}} is {{c|false}} after a call to this method.
}}

===Parameters===
(none)

===Return value===
{{#switch:{{{1|}}}
|shared_future=
@1@ Const reference to the value stored in the shared state. Accessing the value through this reference is undefined after the shared state has been destroyed.
|future=
@1@ The value {{tt|v}} stored in the shared state, as {{c|std::move(v)}}.
}}
@2@ Reference to the value in the shared state.

@3@ Nothing.

===Exceptions===
If an exception was stored in the shared state referenced by the future (e.g. via a call to {{ltt|cpp/thread/promise/set_exception|std::promise::set_exception()}}) then that exception will be thrown.

===Notes===
The implementations are encouraged to detect the case when {{lc|valid()}} is {{c|false}} before the call and throw a {{lc|std::future_error}} with an error condition of {{lc|std::future_errc::no_state}}.

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc valid|{{{1|}}}}}
{{dsc end}}</text>
      <sha1>8r88s1s6qxu9cfukjof068iz8jb1gyb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/navbar</title>
    <ns>10</ns>
    <id>2521</id>
    <revision>
      <id>40026</id>
      <parentid>35926</parentid>
      <timestamp>2012-09-28T20:19:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/future/navbar heading
|content3 = cpp/thread/future/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/navbar content</title>
    <ns>10</ns>
    <id>5047</id>
    <revision>
      <id>55145</id>
      <parentid>35927</parentid>
      <timestamp>2013-06-01T05:20:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="450">{{nv begin}}
{{nv mem ln | cpp/thread/future/future}}
{{nv mem ln | cpp/thread/future/~future}}
{{nv mem ln | cpp/thread/future/operator{{=}}}}
{{nv mem ln | cpp/thread/future/share}}

{{nv h2 | Getting the result}}
{{nv mem ln | cpp/thread/future/get}}

{{nv h2 | State}}
{{nv mem ln | cpp/thread/future/valid}}
{{nv mem ln | cpp/thread/future/wait}}
{{nv mem ln | cpp/thread/future/wait_for}}
{{nv mem ln | cpp/thread/future/wait_until}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/navbar heading</title>
    <ns>10</ns>
    <id>2525</id>
    <revision>
      <id>48027</id>
      <parentid>35928</parentid>
      <timestamp>2013-05-18T17:57:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="37">{{ltt|cpp/thread/future|std::future}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/title</title>
    <ns>10</ns>
    <id>5031</id>
    <revision>
      <id>18207</id>
      <timestamp>2012-01-25T22:18:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=future::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/valid</title>
    <ns>10</ns>
    <id>6455</id>
    <revision>
      <id>64767</id>
      <parentid>62241</parentid>
      <timestamp>2013-08-26T23:48:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lc}}</comment>
      <text xml:space="preserve" bytes="704">{{cpp/thread/{{{1|}}}/title|valid}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
bool valid() const;
}}
{{dcl end}}

Checks if the future refers to a shared state. This is the case only for futures returned by {{lc|std::promise::get_future()}}, {{lc|std::packaged_task::get_future()}} or {{lc|std::async()}} until the first time {{lc|get()}}{{#ifeq:{{{1|}}}|future| or {{lc|share()}}}} is called.

===Parameters===
(none)

===Return value===
{{c|true}} if *this refers to a shared state, otherwise {{c|false}}.

===Exceptions===
{{noexcept}}

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc wait|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/wait</title>
    <ns>10</ns>
    <id>6456</id>
    <revision>
      <id>62242</id>
      <parentid>61765</parentid>
      <timestamp>2013-06-25T12:35:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="1366">{{cpp/thread/{{{1|}}}/title|wait}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
void wait() const;
}}
{{dcl end}}

Blocks until the result becomes available. {{c|valid() {{==}} true}} after the call.

The behavior is undefined if [[cpp/thread/future/valid|{{c|valid()}}]]{{c| {{==}} false}} before the call to this function. 

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
(none)

===Notes===
The implementations are encouraged to detect the case when {{c|valid {{==}} false}} before the call and throw a {{lc|std::future_error}} with an error condition of {{lc|std::future_errc::no_state}}.

===Example===
{{example|
 | code=
#include &lt;iostream&gt;
#include &lt;future&gt;
#include &lt;thread&gt;

int fib(int n)
{
  if (n &lt; 3) return 1;
  else return fib(n-1) + fib(n-2);
}

int main()
{
    std::{{{1|}}}&lt;int&gt; f1 = std::async(std::launch::async, [](){
        return fib(20);
    });
    std::{{{1|}}}&lt;int&gt; f2 = std::async(std::launch::async, [](){
        return fib(25);
    });

    std::cout &lt;&lt; &quot;waiting...\n&quot;;
    f1.wait();
    f2.wait();

    std::cout &lt;&lt; &quot;f1: &quot; &lt;&lt; f1.get() &lt;&lt; '\n';
    std::cout &lt;&lt; &quot;f2: &quot; &lt;&lt; f2.get() &lt;&lt; '\n';
}
 | output=
waiting...
f1: 6765
f2: 75025
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc wait_for|{{{1|}}}}}
{{dsc inc | cpp/thread/future/dsc wait_until|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/wait for</title>
    <ns>10</ns>
    <id>6457</id>
    <revision>
      <id>64468</id>
      <parentid>62243</parentid>
      <timestamp>2013-08-18T00:16:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exceptions clause from LWG 2185/C++14</comment>
      <text xml:space="preserve" bytes="2382">{{cpp/thread/{{{1|}}}/title|wait_for}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class Rep, class Period &gt;
std::future_status wait_for( const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration ) const;
}}
{{dcl end}}

Waits for the result to become available. Blocks until specified {{tt|timeout_duration}} has elapsed or the result becomes available, whichever comes first. Returns value identifies the state of the result. 

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

The behavior is undefined if [[cpp/thread/future/valid|{{c|valid()}}]]{{c| {{==}} false}} before the call to this function. 

===Parameters===
{{par begin}}
{{par | timeout_duration | maximum duration to block for}}
{{par end}}

===Return value===
{{cpp/thread/future_status_values}}

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Notes===
The implementations are encouraged to detect the case when {{c|valid {{==}} false}} before the call and throw a [[cpp/thread/future_error|{{c|future_error}}]] with an error condition of [[cpp/thread/future_errc|{{c|future_errc::no_state}}]].

===Example===
{{example|
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;future&gt;
#include &lt;thread&gt;
#include &lt;chrono&gt;

int main()
{
    std::{{{1|}}}&lt;int&gt; future = std::async(std::launch::async, [](){ 
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return 8;  
    }); 
 
    std::cout &lt;&lt; &quot;waiting...\n&quot;;
    std::future_status status;
    do {
        status = future.wait_for(std::chrono::seconds(1));
        if (status == std::future_status::deferred) {
            std::cout &lt;&lt; &quot;deferred\n&quot;;
        } else if (status == std::future_status::timeout) {
            std::cout &lt;&lt; &quot;timeout\n&quot;;
        } else if (status == std::future_status::ready) {
            std::cout &lt;&lt; &quot;ready!\n&quot;;
        }
    } while (status != std::future_status::ready); 

    std::cout &lt;&lt; &quot;result is &quot; &lt;&lt; future.get() &lt;&lt; '\n';
}
 | output=
waiting...
timeout
timeout
ready!
result is 8
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc wait|{{{1|}}}}}
{{dsc inc | cpp/thread/future/dsc wait_until|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future/wait until</title>
    <ns>10</ns>
    <id>6458</id>
    <revision>
      <id>64469</id>
      <parentid>62244</parentid>
      <timestamp>2013-08-18T00:17:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>exceptions clause from LWG 2185/C++14</comment>
      <text xml:space="preserve" bytes="1832">{{cpp/thread/{{{1|}}}/title|wait_until}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
template&lt; class Clock, class Duration &gt;
std::future_status wait_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time ) const;
}}
{{dcl end}}

{{tt|wait_until}} waits for a result to become available.  It blocks until specified {{tt|timeout_time}} has been reached or the result becomes available, whichever comes first. The return value indicates why {{tt|wait_until}} returned.

The clock tied to {{tt|timeout_time}} is used, which means that adjustments of the clock are taken into account. Thus, the maximum duration of the block might differ from {{c|timeout_time - Clock::now()}} at the time of the call, depending on the direction of the adjustment. 

The function also may block for longer than until after {{tt|timeout_time}} has been reached due to scheduling or resource contention delays.

The behavior is undefined if [[cpp/thread/future/valid|{{c|valid()}}]]{{c| {{==}} false}} before the call to this function. 

===Parameters===
{{par begin}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Return value===
{{cpp/thread/future_status_values}}

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Notes===
The implementations are encouraged to detect the case when {{c|valid {{==}} false}} before the call and throw a [[cpp/thread/future_error|{{c|future_error}}]] with an error condition of [[cpp/thread/future_errc|{{c|future_errc::no_state}}]].

===Example===
{{example|
 | code=
 | output=
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/future/dsc wait|{{{1|}}}}}
{{dsc inc | cpp/thread/future/dsc wait_for|{{{1|}}}}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/dsc is error code enum</title>
    <ns>10</ns>
    <id>12637</id>
    <revision>
      <id>61373</id>
      <timestamp>2013-06-05T22:29:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="227">{{dsc tclass | cpp/thread/future_errc/is_error_code_enum  | title=is_error_code_enum{{dsc small|&lt;std::future_errc&gt;}}| notes={{mark c++11}} | extends the type trait {{lc|std::is_error_code_enum}} to identify future error codes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/dsc make error code</title>
    <ns>10</ns>
    <id>12639</id>
    <revision>
      <id>61375</id>
      <timestamp>2013-06-05T22:29:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="164">{{dsc fun | cpp/thread/future_errc/make_error_code | title=make_error_code{{dsc small|(std::future_errc)}} | notes={{mark c++11}} | constructs a future error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/dsc make error condition</title>
    <ns>10</ns>
    <id>12638</id>
    <revision>
      <id>61374</id>
      <timestamp>2013-06-05T22:29:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="180">{{dsc fun | cpp/thread/future_errc/make_error_condition  | title=make_error_condition{{dsc small|(std::future_errc)}} | notes={{mark c++11}} | constructs a future error_condition}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/navbar</title>
    <ns>10</ns>
    <id>9001</id>
    <revision>
      <id>40027</id>
      <parentid>35930</parentid>
      <timestamp>2012-09-28T20:19:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/future_errc/navbar heading
|content3 = cpp/thread/future_errc/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/navbar content</title>
    <ns>10</ns>
    <id>9002</id>
    <revision>
      <id>61381</id>
      <parentid>55156</parentid>
      <timestamp>2013-06-05T22:31:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>reorder</comment>
      <text xml:space="preserve" bytes="245">{{nv begin}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/thread/future_errc/make_error_code}}
{{nv ln | cpp/thread/future_errc/make_error_condition}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/thread/future_errc/is_error_code_enum}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future errc/navbar heading</title>
    <ns>10</ns>
    <id>8545</id>
    <revision>
      <id>48104</id>
      <parentid>35931</parentid>
      <timestamp>2013-05-18T18:12:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/thread/future_errc|std::future_errc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/dsc code</title>
    <ns>10</ns>
    <id>8980</id>
    <revision>
      <id>60094</id>
      <parentid>55159</parentid>
      <timestamp>2013-06-01T06:44:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future error/dcl list code]] to [[Template:cpp/thread/future error/dsc code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc mem fun | cpp/thread/future_error/code | returns the error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/dsc constructor</title>
    <ns>10</ns>
    <id>8979</id>
    <revision>
      <id>60096</id>
      <parentid>55174</parentid>
      <timestamp>2013-06-01T06:44:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future error/dcl list constructor]] to [[Template:cpp/thread/future error/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem ctor | cpp/thread/future_error/future_error | creates a {{tt|std::future_error}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/dsc what</title>
    <ns>10</ns>
    <id>8981</id>
    <revision>
      <id>60098</id>
      <parentid>55175</parentid>
      <timestamp>2013-06-01T06:44:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/future error/dcl list what]] to [[Template:cpp/thread/future error/dsc what]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/thread/future_error/what | returns the explanatory string specific to the error code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/navbar</title>
    <ns>10</ns>
    <id>8551</id>
    <revision>
      <id>40028</id>
      <parentid>35932</parentid>
      <timestamp>2012-09-28T20:19:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="255">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/future_error/navbar heading
|content3 = cpp/thread/future_error/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/navbar content</title>
    <ns>10</ns>
    <id>8978</id>
    <revision>
      <id>55178</id>
      <parentid>37775</parentid>
      <timestamp>2013-06-01T05:20:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="195">{{nv begin}}
{{nv h2 | Member functions}}
{{nv mem ln | cpp/thread/future_error/future_error}}
{{nv mem ln | cpp/thread/future_error/code}}
{{nv mem ln | cpp/thread/future_error/what}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/navbar heading</title>
    <ns>10</ns>
    <id>8552</id>
    <revision>
      <id>48105</id>
      <parentid>34261</parentid>
      <timestamp>2013-05-18T18:13:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="49">{{ltt|cpp/thread/future_error|std::future_error}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future error/title</title>
    <ns>10</ns>
    <id>8977</id>
    <revision>
      <id>37774</id>
      <timestamp>2012-07-18T23:27:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=future_error::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/future status values</title>
    <ns>10</ns>
    <id>5045</id>
    <revision>
      <id>55181</id>
      <parentid>41485</parentid>
      <timestamp>2013-06-01T05:20:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="376">{{dsc begin}}
{{dsc hitem | Constant | Explanation}}
{{dsc
| {{ltt|cpp/thread/future_status|future_status::deferred}}
| The function to calculate the result has not been started yet
}}
{{dsc
| {{ltt|cpp/thread/future_status|future_status::ready}}
| The result is ready
}}
{{dsc
| {{ltt|cpp/thread/future_status|future_status::timeout}}
| The timeout has expired
}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/dsc constructor</title>
    <ns>10</ns>
    <id>2619</id>
    <revision>
      <id>60100</id>
      <parentid>55184</parentid>
      <timestamp>2013-06-01T06:44:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/lock guard/dcl list constructor]] to [[Template:cpp/thread/lock guard/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem ctor | cpp/thread/lock_guard/lock_guard | constructs a lock_guard, optionally locking the given mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/dsc destructor</title>
    <ns>10</ns>
    <id>2620</id>
    <revision>
      <id>60102</id>
      <parentid>55185</parentid>
      <timestamp>2013-06-01T06:44:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/lock guard/dcl list destructor]] to [[Template:cpp/thread/lock guard/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc mem dtor | cpp/thread/lock_guard/~lock_guard | destructs the lock_guard object, unlocks the underlying mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/dsc operator=</title>
    <ns>10</ns>
    <id>13121</id>
    <revision>
      <id>67021</id>
      <timestamp>2014-01-18T04:51:46Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <comment>not copy-assignable</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | nolink=true | operator{{=}} | notes={{cmark deleted}} | not copy-assignable}}</text>
      <sha1>77x2gksrw7nfpw4adu5pydi8kdymkor</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/navbar</title>
    <ns>10</ns>
    <id>2616</id>
    <revision>
      <id>40029</id>
      <parentid>36003</parentid>
      <timestamp>2012-09-28T20:19:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="249">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/lock_guard/navbar heading
|content3 = cpp/thread/lock_guard/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/navbar content</title>
    <ns>10</ns>
    <id>2617</id>
    <revision>
      <id>55186</id>
      <parentid>34941</parentid>
      <timestamp>2013-06-01T05:20:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="151">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/lock_guard/lock_guard}}
{{nv mem ln | cpp/thread/lock_guard/~lock_guard}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/navbar heading</title>
    <ns>10</ns>
    <id>2618</id>
    <revision>
      <id>48025</id>
      <parentid>35933</parentid>
      <timestamp>2013-05-18T17:55:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="45">{{ltt|cpp/thread/lock_guard|std::lock_guard}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock guard/title</title>
    <ns>10</ns>
    <id>4452</id>
    <revision>
      <id>15844</id>
      <timestamp>2011-12-17T16:14:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=lock_guard::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/lock tag types</title>
    <ns>10</ns>
    <id>4473</id>
    <revision>
      <id>55189</id>
      <parentid>39039</parentid>
      <timestamp>2013-06-01T05:20:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="309">{{dsc begin}}
{{dsc hitem | Type | Effect(s)}}
{{dsc | {{tt|defer_lock_t}} | do not acquire ownership of the mutex}}
{{dsc | {{tt|try_to_lock_t}} | try to acquire ownership of the mutex without blocking}}
{{dsc | {{tt|adopt_lock_t}} | assume the calling thread already has ownership of the mutex}}
{{dsc end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/constructor</title>
    <ns>10</ns>
    <id>4492</id>
    <revision>
      <id>67034</id>
      <parentid>67023</parentid>
      <timestamp>2014-01-18T07:42:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>partial undo: several changes were valid only for mutex::mutex. They were moved to a separate page</comment>
      <text xml:space="preserve" bytes="450">{{cpp/thread/{{{1|}}}/title|{{{1}}}}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | num=1 |since={{cpp/std|{{{1|}}}}} |
{{{1}}}();
}}
{{dcl | num=2 |since={{cpp/std|{{{1|}}}}} |1=
{{{1}}}( const {{{1}}}&amp; ) = delete;
}}
{{dcl end}}

@1@ Constructs the mutex. The mutex is in unlocked state after the call.

@2@ Copy constructor is deleted.

===Parameters===
(none)

===Exceptions===
{{lc|std::system_error}} if the construction is unsuccessful.</text>
      <sha1>6rodeyincjavpa8x75f3lotnw4w0nxm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/destructor</title>
    <ns>10</ns>
    <id>13129</id>
    <revision>
      <id>67050</id>
      <parentid>67049</parentid>
      <timestamp>2014-01-18T15:56:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="249">{{cpp/thread/{{{1|}}}/title|~{{{1|}}}}}
{{cpp/thread/{{{1|}}}/navbar}}
{{ddcl |
~{{{1}}}(); 
}}

Destroys the mutex.

The behavior is undefined if the mutex is owned by any thread or if any thread terminates while holding any ownership of the mutex.</text>
      <sha1>igm6lpml1h1rwokexwhac07oh42gtjo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc constructor</title>
    <ns>10</ns>
    <id>2304</id>
    <revision>
      <id>60104</id>
      <parentid>55193</parentid>
      <timestamp>2013-06-01T06:44:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list constructor]] to [[Template:cpp/thread/mutex/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem ctor | cpp/thread/{{{1|}}}/{{{1|}}} | constructs the mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc destructor</title>
    <ns>10</ns>
    <id>13123</id>
    <revision>
      <id>67039</id>
      <parentid>67028</parentid>
      <timestamp>2014-01-18T13:56:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>use {{{1}}}</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem dtor | cpp/thread/{{{1|}}}/~{{{1|}}} | destroys the mutex}}</text>
      <sha1>rx4zsih4fet1l9ugx4way7goqou6wm0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc lock</title>
    <ns>10</ns>
    <id>2305</id>
    <revision>
      <id>60106</id>
      <parentid>55194</parentid>
      <timestamp>2013-06-01T06:44:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list lock]] to [[Template:cpp/thread/mutex/dsc lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/thread/{{{1|}}}/lock | locks the mutex, blocks if the mutex is not available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc lock shared</title>
    <ns>10</ns>
    <id>10120</id>
    <revision>
      <id>60108</id>
      <parentid>55195</parentid>
      <timestamp>2013-06-01T06:44:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list lock shared]] to [[Template:cpp/thread/mutex/dsc lock shared]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem fun | cpp/thread/{{{1|}}}/lock_shared | locks the mutex for shared ownership, blocks if the mutex is not available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc native handle</title>
    <ns>10</ns>
    <id>2309</id>
    <revision>
      <id>60110</id>
      <parentid>55196</parentid>
      <timestamp>2013-06-01T06:44:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list native handle]] to [[Template:cpp/thread/mutex/dsc native handle]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/thread/{{{1|}}}/native_handle | returns the underlying implementation-defined thread handle}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc operator=</title>
    <ns>10</ns>
    <id>13122</id>
    <revision>
      <id>67026</id>
      <timestamp>2014-01-18T05:25:21Z</timestamp>
      <contributor>
        <username>Dieram3</username>
        <id>1346</id>
      </contributor>
      <comment>Created page with &quot;{{dsc mem fun | nolink=true | operator{{=}} | notes={{cmark deleted}} | not copy-assignable}}&quot;</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | nolink=true | operator{{=}} | notes={{cmark deleted}} | not copy-assignable}}</text>
      <sha1>77x2gksrw7nfpw4adu5pydi8kdymkor</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock</title>
    <ns>10</ns>
    <id>2306</id>
    <revision>
      <id>60112</id>
      <parentid>55199</parentid>
      <timestamp>2013-06-01T06:44:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock]] to [[Template:cpp/thread/mutex/dsc try lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock | tries to lock the mutex, returns if the mutex is not available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock for</title>
    <ns>10</ns>
    <id>2307</id>
    <revision>
      <id>60114</id>
      <parentid>55202</parentid>
      <timestamp>2013-06-01T06:44:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock for]] to [[Template:cpp/thread/mutex/dsc try lock for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock_for | tries to lock the mutex, returns if the mutex has been&lt;br&gt;unavailable for the specified timeout duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock shared</title>
    <ns>10</ns>
    <id>10121</id>
    <revision>
      <id>60116</id>
      <parentid>55203</parentid>
      <timestamp>2013-06-01T06:44:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock shared]] to [[Template:cpp/thread/mutex/dsc try lock shared]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock_shared | tries to lock the mutex for shared ownership, returns if the mutex is not available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock shared for</title>
    <ns>10</ns>
    <id>10122</id>
    <revision>
      <id>60118</id>
      <parentid>55204</parentid>
      <timestamp>2013-06-01T06:44:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock shared for]] to [[Template:cpp/thread/mutex/dsc try lock shared for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="185">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock_shared_for | tries to lock the mutex for shared ownership, returns if the mutex has been&lt;br&gt;unavailable for the specified timeout duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock shared until</title>
    <ns>10</ns>
    <id>10123</id>
    <revision>
      <id>60120</id>
      <parentid>55205</parentid>
      <timestamp>2013-06-01T06:44:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock shared until]] to [[Template:cpp/thread/mutex/dsc try lock shared until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="196">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock_shared_until | tries to lock the mutex for shared ownership, returns if the mutex has been&lt;br&gt;unavailable until specified time point has been reached}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc try lock until</title>
    <ns>10</ns>
    <id>2308</id>
    <revision>
      <id>60122</id>
      <parentid>55212</parentid>
      <timestamp>2013-06-01T06:44:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list try lock until]] to [[Template:cpp/thread/mutex/dsc try lock until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="168">{{dsc mem fun | cpp/thread/{{{1|}}}/try_lock_until | tries to lock the mutex, returns if the mutex has been&lt;br&gt;unavailable until specified time point has been reached}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc unlock</title>
    <ns>10</ns>
    <id>2310</id>
    <revision>
      <id>60124</id>
      <parentid>55217</parentid>
      <timestamp>2013-06-01T06:44:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list unlock]] to [[Template:cpp/thread/mutex/dsc unlock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">{{dsc mem fun | cpp/thread/{{{1|}}}/unlock | unlocks the mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/dsc unlock shared</title>
    <ns>10</ns>
    <id>10124</id>
    <revision>
      <id>60126</id>
      <parentid>55222</parentid>
      <timestamp>2013-06-01T06:44:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/mutex/dcl list unlock shared]] to [[Template:cpp/thread/mutex/dsc unlock shared]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/thread/{{{1|}}}/unlock_shared | unlocks the mutex (shared ownership)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/example try lock</title>
    <ns>10</ns>
    <id>10118</id>
    <revision>
      <id>65057</id>
      <parentid>64906</parentid>
      <timestamp>2013-08-30T14:57:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>spacing</comment>
      <text xml:space="preserve" bytes="1422">{{example
 | p=true
 | code=
#include &lt;chrono&gt;
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;iostream&gt; // std::cout

std::chrono::milliseconds interval(100);

std::mutex mutex;
int job_shared = 0; // both threads can modify 'job_shared',
    // mutex will protect this variable

int job_exclusive = 0; // only one thread can modify 'job_exclusive'
    // no protection needed

// this thread can modify both 'job_shared' and 'job_exclusive'
void job_1() 
{
    std::this_thread::sleep_for(interval); // let 'job_2' take a lock

    while (true) {
        // try to lock mutex to modify 'job_shared'
        if (mutex.try_lock()) {
            std::cout &lt;&lt; &quot;job shared (&quot; &lt;&lt; job_shared &lt;&lt; &quot;)\n&quot;;
            mutex.unlock();
            return;
        } else {
            // can't get lock to modify 'job_shared'
            // but there is some other work to do
            ++job_exclusive;
            std::cout &lt;&lt; &quot;job exclusive (&quot; &lt;&lt; job_exclusive &lt;&lt; &quot;)\n&quot;;
            std::this_thread::sleep_for(interval);
        }
    }
}

// this thread can modify only 'job_shared'
void job_2() 
{
    mutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    mutex.unlock();
}

int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);

    thread_1.join();
    thread_2.join();
}
 | output=
job exclusive (1)
job exclusive (2)
job exclusive (3)
job exclusive (4)
job shared (1)
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/lock</title>
    <ns>10</ns>
    <id>2343</id>
    <revision>
      <id>68935</id>
      <parentid>65523</parentid>
      <timestamp>2014-03-22T22:44:15Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="3171">{{cpp/thread/{{{1|}}}/title|lock}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void lock();
}}
{{dcl end}}

Locks the mutex. If another thread has already locked the mutex, a call to {{tt|lock}} will block execution until the lock is acquired.

{{#switch:{{{1}}}
|mutex
|timed_mutex=
If {{tt|lock}} is called by a thread that already owns the {{tt|mutex}}, the behavior is undefined: the program ''may'' deadlock, or, if the implementation can detect the deadlock, a {{tt|resource_deadlock_would_occur}} error condition may be thrown.
|recursive_mutex
|recursive_timed_mutex=
A thread may call {{tt|lock}} on a recursive mutex repeatedly.  Ownership will only be released after the thread makes a matching number of calls to {{tt|unlock}}.  

The maximum number of levels of ownership is unspecified.  An exception of type {{lc|std::system_error}} will be thrown if this number is exceeded.
|shared_timed_mutex=
If {{tt|lock}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.
|{{included}}
}}

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
Throws {{lc|std::system_error}} when errors occur, including errors from the underlying operating system that would prevent {{tt|lock}} from meeting its specifications. The mutex is not locked in the case of any exception being thrown.

===Notes===
{{tt|lock()}} is usually not called directly: {{lc|std::unique_lock}} and {{lc|std::lock_guard}} are used to manage exclusive locking.

{{#ifeq:{{{1}}}|shared_mutex|
{{tt|shared_ptr}} does not support direct transition from shared to unique ownership mode: the shared lock has to be relinquished with {{lc|unlock_shared()}} before exclusive ownership may be obtained with {{tt|lock()}}.  [http://www.boost.org/doc/libs/release/doc/html/thread/synchronization.html#thread.synchronization.mutex_types.upgrade_mutex boost::upgrade_mutex] may be used for this purpose.
}}

===Example===
{{example
 | This example shows how {{tt|lock}} and {{tt|unlock}} can be used to protect shared data.
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;thread&gt;
#include &lt;mutex&gt;

int g_num = 0;  // protected by g_num_mutex
std::mutex g_num_mutex;

void slow_increment(int id) 
{
    for (int i = 0; i &lt; 3; ++i) {
        g_num_mutex.lock();
        ++g_num;
        std::cout &lt;&lt; id &lt;&lt; &quot; =&gt; &quot; &lt;&lt; g_num &lt;&lt; '\n';
        g_num_mutex.unlock();

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

int main()
{
    std::thread t1(slow_increment, 0);
    std::thread t2(slow_increment, 1);
    t1.join();
    t2.join();
}
 | output=
0 =&gt; 1
1 =&gt; 2
0 =&gt; 3
1 =&gt; 4
0 =&gt; 5
1 =&gt; 6
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | {{{1|}}}}}
{{#switch:{{{1|}}} | timed_mutex | recursive_timed_mutex =
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | {{{1|}}}}}
}}
{{dsc inc | cpp/thread/mutex/dsc unlock | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>0diwv1rqdhxz8t0nsc4o1yxicajqp22</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/native handle</title>
    <ns>10</ns>
    <id>2352</id>
    <revision>
      <id>62221</id>
      <parentid>35431</parentid>
      <timestamp>2013-06-25T12:21:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="397">{{cpp/thread/{{{1|}}}/title|native_handle}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since=c++11 |
native_handle_type native_handle();
}}
{{dcl end}}

Returns the underlying implementation-defined native handle object.

===Parameters===
(none)

===Return value===
Implementation-defined native handle object.

===Exceptions===
{{todo}}

===Example===
{{example |
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/navbar</title>
    <ns>10</ns>
    <id>2311</id>
    <revision>
      <id>47773</id>
      <parentid>40030</parentid>
      <timestamp>2013-05-16T20:26:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="239">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/mutex/navbar heading
|content3 = cpp/thread/mutex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/navbar content</title>
    <ns>10</ns>
    <id>2353</id>
    <revision>
      <id>67030</id>
      <parentid>55226</parentid>
      <timestamp>2014-01-18T07:24:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add dtor</comment>
      <text xml:space="preserve" bytes="346">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/mutex/mutex}}
{{nv mem ln | cpp/thread/mutex/~mutex}}

{{nv h2 | Locking}}
{{nv mem ln | cpp/thread/mutex/lock}}
{{nv mem ln | cpp/thread/mutex/try_lock}}
{{nv mem ln | cpp/thread/mutex/unlock}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/mutex/native_handle}}
{{nv end}}</text>
      <sha1>a1udvlf55dvil734ijvo0hsur2x3fbq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/navbar heading</title>
    <ns>10</ns>
    <id>2315</id>
    <revision>
      <id>47752</id>
      <parentid>35935</parentid>
      <timestamp>2013-05-16T20:21:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="35">{{ltt|cpp/thread/mutex|std::mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/title</title>
    <ns>10</ns>
    <id>2348</id>
    <revision>
      <id>5325</id>
      <timestamp>2011-07-24T19:04:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/try lock</title>
    <ns>10</ns>
    <id>2344</id>
    <revision>
      <id>68939</id>
      <parentid>65649</parentid>
      <timestamp>2014-03-22T22:46:11Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="1938">{{cpp/thread/{{{1|}}}/title|try_lock}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
bool try_lock();
}}
{{dcl end}}

Tries to lock the mutex. Returns immediately. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}.

This function is allowed to fail spuriously and return {{c|false}} even if the mutex is not currently locked by any other thread.

{{#switch:{{{1}}}
|mutex
|timed_mutex=
If {{tt|try_lock}} is called by a thread that already owns the {{tt|mutex}}, the behavior is undefined.
|recursive_mutex
|recursive_timed_mutex=
A thread may call {{tt|try_lock}} on a recursive mutex repeatedly. Successful calls to {{tt|try_lock}} increment the ownsership count: the mutex will only be released after the thread makes a matching number of calls to {{lc|unlock}}.  

The maximum number of levels of ownership is unspecified. A call to {{tt|try_lock}} will return {{c|false}} if this number is exceeded.
|shared_timed_mutex=
If {{tt|try_lock}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.
|{{included}}
}}

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}. Note that prior {{lc|lock()}} does not synchronize with this operation if it returns {{c|false}}.

===Parameters===
(none)

===Return value===
{{c|true}} if the lock was acquired successfully, otherwise {{c|false}}.

===Exceptions===
(none)

===Example===
{{include | cpp/thread/{{{1|}}}/example_try_lock}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | {{{1|}}}}}
{{#switch:{{{1|}}} | timed_mutex | recursive_timed_mutex = 
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | {{{1|}}}}}
}}
{{dsc inc | cpp/thread/mutex/dsc unlock | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>iqrn7rn3rsc1ai9eonb03t1od65473c</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/try lock for</title>
    <ns>10</ns>
    <id>2349</id>
    <revision>
      <id>68930</id>
      <parentid>68928</parentid>
      <timestamp>2014-03-22T22:42:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3531">{{cpp/thread/{{{1|}}}/title|try_lock_for}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
template&lt; class Rep, class Period &gt;
bool try_lock_for( const std::chrono::duration&lt;Rep,Period&gt;&amp; timeout_duration );
}}
{{dcl end}}

Tries to lock the mutex. Blocks until specified {{tt|timeout_duration}} has elapsed or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}. 

If {{tt|timeout_duration}} is less or equal {{tt|timeout_duration.zero()}}, the function behaves like {{lc|try_lock()}}.

A steady clock is used to measure the duration. This function may block for longer than {{tt|timeout_duration}} due to scheduling or resource contention delays. 

As with {{lc|try_lock()}}, this function is allowed to fail spuriously and return {{c|false}} even if the mutex was not locked by any other thread at some point during {{tt|timeout_duration}}.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}.

{{#switch:{{{1}}}
|mutex
|timed_mutex=
If {{tt|try_lock_for}} is called by a thread that already owns the {{tt|mutex}}, the behavior is undefined.
|recursive_mutex
|recursive_timed_mutex=
A thread may call {{tt|try_lock_for}} on a recursive mutex repeatedly. Successful calls to {{tt|try_lock_for}} increment the ownership count: the mutex will only be released after the thread makes a matching number of calls to {{lc|unlock}}.  

The maximum number of levels of ownership is unspecified. A call to {{tt|try_lock_for}} will return {{c|false}} if this number is exceeded.
|shared_timed_mutex=
If {{tt|try_lock_for}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.
|{{included}}
}}

===Parameters===
{{par begin}}
{{par | timeout_duration | maximum duration to block for}}
{{par end}}

===Return value===
{{c|true}} if the lock was acquired successfully, otherwise {{c|false}}.

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Example===
{{example |
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;vector&gt;
#include &lt;sstream&gt;

std::mutex cout_mutex; // control access to std::cout
std::timed_mutex mutex;

void job(int id) 
{
    using Ms = std::chrono::milliseconds;
    std::ostringstream stream;
    
    for (int i = 0; i &lt; 3; ++i) {
        if (mutex.try_lock_for(Ms(100))) {
            stream &lt;&lt; &quot;success &quot;;
            std::this_thread::sleep_for(Ms(100));
            mutex.unlock();
        } else {
            stream &lt;&lt; &quot;failed &quot;;
        }
        std::this_thread::sleep_for(Ms(100));
    }

    std::lock_guard&lt;std::mutex&gt; lock(cout_mutex);
    std::cout &lt;&lt; &quot;[&quot; &lt;&lt; id &lt;&lt; &quot;] &quot; &lt;&lt; stream.str() &lt;&lt; &quot;\n&quot;;
}

int main() 
{
    std::vector&lt;std::thread&gt; threads;
    for (int i = 0; i &lt; 4; ++i) {
        threads.emplace_back(job, i);
    }

    for (auto&amp; i: threads) {
        i.join();
    }
}
 | output=
[0] failed failed failed 
[3] failed failed success 
[2] failed success failed 
[1] success failed success
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc unlock | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>1euf71noz2q02sqoilfcwn2m6eubpl3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/try lock until</title>
    <ns>10</ns>
    <id>2350</id>
    <revision>
      <id>68931</id>
      <parentid>68929</parentid>
      <timestamp>2014-03-22T22:42:39Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="3195">{{cpp/thread/{{{1|}}}/title|try_lock_until}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
template&lt; class Clock, class Duration &gt;
bool try_lock_until( const std::chrono::time_point&lt;Clock,Duration&gt;&amp; timeout_time );
}}
{{dcl end}}

Tries to lock the mutex. Blocks until specified {{tt|timeout_time}} has been reached or the lock is acquired, whichever comes first. On successful lock acquisition returns {{c|true}}, otherwise returns {{c|false}}.

If {{tt|timeout_time}} has already passed, this function behaves like {{lc|try_lock()}}.

The clock tied to {{tt|timeout_time}} is used, which means that adjustments of the clock are taken into account. Thus, the maximum duration of the block might, but might not, be less or more than  {{c|timeout_time - Clock::now()}} at the time of the call, depending on the direction of the adjustment. The function also may block for longer than until after {{tt|timeout_time}} has been reached due to scheduling or resource contention delays.

As with {{lc|try_lock()}}, this function is allowed to fail spuriously and return {{c|false}} even if the mutex was not locked by any other thread at some point before {{tt|timeout_time}}.

Prior {{lc|unlock()}} operation on the same mutex ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) this operation if it returns {{c|true}}.

{{#switch:{{{1}}}
|mutex
|timed_mutex=
If {{tt|try_lock_until}} is called by a thread that already owns the {{tt|mutex}}, the behavior is undefined.
|recursive_mutex
|recursive_timed_mutex=
A thread may call {{tt|try_lock_until}} on a recursive mutex repeatedly. Successful calls to {{tt|try_lock_until}} increment the ownership count: the mutex will only be released after the thread makes a matching number of calls to {{lc|unlock}}.  

The maximum number of levels of ownership is unspecified. A call to {{tt|try_lock_until}} will return {{c|false}} if this number is exceeded.
|shared_timed_mutex=
If {{tt|try_lock_until}} is called by a thread that already owns the {{tt|mutex}} in any mode (shared or exclusive), the behavior is undefined.
|{{included}}
}}

===Parameters===
{{par begin}}
{{par | timeout_time | maximum time point to block until}}
{{par end}}

===Return value===
{{c|true}} if the lock was acquired successfully, otherwise {{c|false}}.

===Exceptions===
Any exception thrown by clock, time_point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw)

===Example===
{{example
 | This example shows a 10 seconds block
 | code=
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;chrono&gt;
#include &lt;mutex&gt;

std::{{{1|}}} test_mutex;

void f()
{
    auto now=std::chrono::steady_clock::now();
    test_mutex.try_lock_until(now + std::chrono::seconds(10));
    std::cout &lt;&lt; &quot;hello world\n&quot;;
}

int main()
{
    std::lock_guard&lt;std::{{{1|}}}&gt; l(test_mutex);
    std::thread t(f);
    t.join();
}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc unlock | {{{1|}}}}}
{{dsc end}}</text>
      <sha1>pzomgpyp00yaa5v26fia1y9ocencsea</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/mutex/unlock</title>
    <ns>10</ns>
    <id>2351</id>
    <revision>
      <id>68946</id>
      <parentid>65525</parentid>
      <timestamp>2014-03-22T22:49:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="2185">{{cpp/thread/{{{1|}}}/title|unlock}}
{{cpp/thread/{{{1|}}}/navbar}}
{{dcl begin}}
{{dcl | since={{cpp/std|{{{1|}}}}} |
void unlock();
}}
{{dcl end}}

{{#switch:{{{1|}}}
| mutex | shared_timed_mutex | timed_mutex =
Unlocks the mutex.
| recursive_mutex | recursive_timed_mutex =
Unlocks the mutex if its level of ownership is {{c|1}} (there was exactly one more call to {{lc|lock()}} than there were calls to {{tt|unlock()}} made by this thread), reduces the level of ownership by 1 otherwise.
}}

The mutex must be locked by the current thread of execution, otherwise, the behavior is undefined.

This operation ''synchronizes-with'' (as defined in {{lc|std::memory_order}}) any subsequent lock operation that obtains ownership of the same mutex.

===Parameters===
(none)

===Return value===
(none)

===Exceptions===
(none)

===Notes===
{{tt|unlock()}} is usually not called directly: {{lc|std::unique_lock}} and {{lc|std::lock_guard}} are used to manage exclusive locking.

===Example===
{{#switch:{{{1|}}} | recursive_mutex | timed_mutex | recursive_timed_mutex =
{{example}}
|
{{example
 | This example shows {{lc|lock}}, {{lc|try_lock}} and {{tt|unlock}} in action:
 | p=true
 | code=
#include &lt;iostream&gt;
#include &lt;mutex&gt;
	
int main()
{
    std::mutex test;
    if (test.try_lock()) {
        std::cout &lt;&lt; &quot;first try_lock successful\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;first try_lock NOT successful\n&quot;;
        return 0;
    }

    test.unlock();
    test.lock();

    if (test.try_lock()) {
        std::cout &lt;&lt; &quot;second try_lock successful\n&quot;;
    } else {
        std::cout &lt;&lt; &quot;second try_lock NOT successful\n&quot;;
    }

    test.lock();  // trying to lock an already-locked std::mutex will 
                  // block program execution, so we'll hang here
}
 | output=
first try_lock successful
second try_lock NOT successful
(program hangs)
}}
}}

===See also===
{{dsc begin}}
{{dsc inc | cpp/thread/mutex/dsc lock | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock | {{{1|}}}}}
{{#switch:{{{1|}}} | timed_mutex | recursive_timed_mutex =
{{dsc inc | cpp/thread/mutex/dsc try_lock_for | {{{1|}}}}}
{{dsc inc | cpp/thread/mutex/dsc try_lock_until | {{{1|}}}}}
}}
{{dsc end}}</text>
      <sha1>fq18rmpaxuw81covjvya8zqqoydk2ck</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/navbar</title>
    <ns>10</ns>
    <id>26</id>
    <revision>
      <id>40031</id>
      <parentid>35945</parentid>
      <timestamp>2012-09-28T20:19:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="152">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/navbar content</title>
    <ns>10</ns>
    <id>2319</id>
    <revision>
      <id>68897</id>
      <parentid>68876</parentid>
      <timestamp>2014-03-22T22:25:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>shared_mutex</comment>
      <text xml:space="preserve" bytes="2469">{{nv begin}}
{{nv h1 | Threads}}
{{nv ln | cpp/thread/thread | notes={{mark c++11}}}}
{{nv h2 | {{tt|this_thread}} namespace}}
{{nv col begin}}
{{nv ln | cpp/thread/get_id | notes={{mark c++11}}}}
{{nv ln | cpp/thread/yield | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/thread/sleep_for | notes={{mark c++11}}}}
{{nv ln | cpp/thread/sleep_until | notes={{mark c++11}}}}
{{nv col end}}

{{nv h1 | Mutual exclusion}}
{{nv col begin}}
{{nv ln | cpp/thread/mutex | notes={{mark c++11}}}}
{{nv ln | cpp/thread/timed_mutex | notes={{mark c++11}}}}
{{nv ln | cpp/thread/shared_timed_mutex | notes={{mark c++14}}}}
{{nv col next}}
{{nv ln | cpp/thread/recursive_mutex | notes={{mark c++11}}}}
{{nv ln | cpp/thread/recursive_timed_mutex | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Generic lock management}}
{{nv col begin}}
{{nv ln | cpp/thread/lock_guard | notes={{mark c++11}}}}
{{nv ln | cpp/thread/unique_lock | notes={{mark c++11}}}}
{{nv ln | cpp/thread/shared_lock | notes={{mark c++14}}}}
{{nv ln | cpp/thread/lock_tag_t | defer_lock_t | try_to_lock_t | adopt_lock_t | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/thread/lock | notes={{mark c++11}}}}
{{nv ln | cpp/thread/try_lock | notes={{mark c++11}}}}
{{nv ln | cpp/thread/lock_tag | defer_lock | try_to_lock | adopt_lock | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/thread/once_flag | notes={{mark c++11}}}}
{{nv ln | cpp/thread/call_once | notes={{mark c++11}}}}
{{nv col end}}

{{nv h1 | Condition variables}}
{{nv ln | cpp/thread/condition_variable | notes={{mark c++11}}}}
{{nv ln | cpp/thread/condition_variable_any | notes={{mark c++11}}}}
{{nv ln | cpp/thread/notify_all_at_thread_exit | notes={{mark c++11}}}}
{{nv ln | cpp/thread/cv_status | notes={{mark c++11}}}}

{{nv h1 | Futures}}
{{nv col begin}}
{{nv ln | cpp/thread/promise | notes={{mark c++11}}}}
{{nv ln | cpp/thread/future | notes={{mark c++11}}}}
{{nv ln | cpp/thread/shared_future | notes={{mark c++11}}}}
{{nv ln | cpp/thread/packaged_task | notes={{mark c++11}}}}
{{nv ln | cpp/thread/async | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/thread/launch | notes={{mark c++11}}}}
{{nv ln | cpp/thread/future_status | notes={{mark c++11}}}}
{{nv ln | cpp/thread/future_error | notes={{mark c++11}}}}
{{nv ln | cpp/thread/future_category | notes={{mark c++11}}}}
{{nv ln | cpp/thread/future_errc | notes={{mark c++11}}}}
{{nv col end}}

{{nv end}}</text>
      <sha1>e2snvdkghhsaiy3vk4h91up4lqpd6h2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/navbar heading</title>
    <ns>10</ns>
    <id>27</id>
    <revision>
      <id>35947</id>
      <parentid>53</parentid>
      <timestamp>2012-06-15T22:35:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/sidebar heading]] to [[Template:cpp/thread/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="39">[[cpp/thread | Thread support library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc constructor</title>
    <ns>10</ns>
    <id>6437</id>
    <revision>
      <id>60128</id>
      <parentid>55242</parentid>
      <timestamp>2013-06-01T06:45:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list constructor]] to [[Template:cpp/thread/packaged task/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem ctor | cpp/thread/packaged_task/packaged_task | constructs the task object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc destructor</title>
    <ns>10</ns>
    <id>6438</id>
    <revision>
      <id>60130</id>
      <parentid>55245</parentid>
      <timestamp>2013-06-01T06:45:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list destructor]] to [[Template:cpp/thread/packaged task/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem dtor | cpp/thread/packaged_task/~packaged_task | destructs the task object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc get future</title>
    <ns>10</ns>
    <id>6442</id>
    <revision>
      <id>60132</id>
      <parentid>55246</parentid>
      <timestamp>2013-06-01T06:45:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list get future]] to [[Template:cpp/thread/packaged task/dsc get future]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/thread/packaged_task/get_future | returns a {{lc|std::future}} associated with the promised result}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc make ready at thread exit</title>
    <ns>10</ns>
    <id>5085</id>
    <revision>
      <id>60134</id>
      <parentid>55247</parentid>
      <timestamp>2013-06-01T06:45:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list make ready at thread exit]] to [[Template:cpp/thread/packaged task/dsc make ready at thread exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem fun | cpp/thread/packaged_task/make_ready_at_thread_exit | executes the function ensuring that the result is ready only once the current thread exits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc operator()</title>
    <ns>10</ns>
    <id>6443</id>
    <revision>
      <id>60136</id>
      <parentid>55248</parentid>
      <timestamp>2013-06-01T06:45:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list operator()]] to [[Template:cpp/thread/packaged task/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/thread/packaged_task/operator() | executes the function}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc operator=</title>
    <ns>10</ns>
    <id>6439</id>
    <revision>
      <id>60138</id>
      <parentid>55251</parentid>
      <timestamp>2013-06-01T06:45:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list operator=]] to [[Template:cpp/thread/packaged task/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem fun | cpp/thread/packaged_task/operator{{=}} | moves the task object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc reset</title>
    <ns>10</ns>
    <id>6444</id>
    <revision>
      <id>60140</id>
      <parentid>55252</parentid>
      <timestamp>2013-06-01T06:45:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list reset]] to [[Template:cpp/thread/packaged task/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/thread/packaged_task/reset | resets the state abandoning any stored results of previous executions}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc swap</title>
    <ns>10</ns>
    <id>6441</id>
    <revision>
      <id>60142</id>
      <parentid>55257</parentid>
      <timestamp>2013-06-01T06:45:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list swap]] to [[Template:cpp/thread/packaged task/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc mem fun | cpp/thread/packaged_task/swap | swaps two task objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc swap2</title>
    <ns>10</ns>
    <id>6446</id>
    <revision>
      <id>60144</id>
      <parentid>55262</parentid>
      <timestamp>2013-06-01T06:45:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list swap2]] to [[Template:cpp/thread/packaged task/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc tfun | cpp/thread/packaged_task/swap2 | title=std::swap{{dsc small|(std::packaged_task)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc uses allocator</title>
    <ns>10</ns>
    <id>3389</id>
    <revision>
      <id>60146</id>
      <parentid>55265</parentid>
      <timestamp>2013-06-01T06:45:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list uses allocator]] to [[Template:cpp/thread/packaged task/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="198">{{dsc ptclass | cpp/thread/packaged_task/uses_allocator | title=std::uses_allocator{{dsc small|&lt;std::packaged_task&gt;}} | specializes the {{lc|std::uses_allocator}} type trait | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/dsc valid</title>
    <ns>10</ns>
    <id>6440</id>
    <revision>
      <id>60148</id>
      <parentid>55266</parentid>
      <timestamp>2013-06-01T06:45:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/packaged task/dcl list valid]] to [[Template:cpp/thread/packaged task/dsc valid]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc mem fun | cpp/thread/packaged_task/valid | checks if the task object has a valid function}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/navbar</title>
    <ns>10</ns>
    <id>2561</id>
    <revision>
      <id>40032</id>
      <parentid>35937</parentid>
      <timestamp>2012-09-28T20:19:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="257">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/packaged_task/navbar heading
|content3 = cpp/thread/packaged_task/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/navbar content</title>
    <ns>10</ns>
    <id>2918</id>
    <revision>
      <id>55269</id>
      <parentid>35938</parentid>
      <timestamp>2013-06-01T05:21:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="584">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/packaged_task/packaged_task}}
{{nv mem ln | cpp/thread/packaged_task/~packaged_task}}
{{nv mem ln | cpp/thread/packaged_task/operator{{=}}}}
{{nv mem ln | cpp/thread/packaged_task/valid}}
{{nv mem ln | cpp/thread/packaged_task/swap}}

{{nv h2 | Getting the result}}
{{nv mem ln | cpp/thread/packaged_task/get_future}}

{{nv h2 | Execution}}
{{nv mem ln | cpp/thread/packaged_task/operator()}}
{{nv mem ln | cpp/thread/packaged_task/make_ready_at_thread_exit}}
{{nv mem ln | cpp/thread/packaged_task/reset}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/navbar heading</title>
    <ns>10</ns>
    <id>2562</id>
    <revision>
      <id>48024</id>
      <parentid>34640</parentid>
      <timestamp>2013-05-18T17:55:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/thread/packaged_task|std::packaged_task}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/packaged task/title</title>
    <ns>10</ns>
    <id>5088</id>
    <revision>
      <id>18395</id>
      <timestamp>2012-02-02T04:41:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=packaged_task::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc constructor</title>
    <ns>10</ns>
    <id>6429</id>
    <revision>
      <id>60150</id>
      <parentid>55270</parentid>
      <timestamp>2013-06-01T06:45:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list constructor]] to [[Template:cpp/thread/promise/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem ctor | cpp/thread/promise/promise | constructs the promise object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc destructor</title>
    <ns>10</ns>
    <id>6430</id>
    <revision>
      <id>60152</id>
      <parentid>55271</parentid>
      <timestamp>2013-06-01T06:45:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list destructor]] to [[Template:cpp/thread/promise/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem dtor | cpp/thread/promise/~promise | destructs the promise object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc get future</title>
    <ns>10</ns>
    <id>6433</id>
    <revision>
      <id>60154</id>
      <parentid>55272</parentid>
      <timestamp>2013-06-01T06:45:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list get future]] to [[Template:cpp/thread/promise/dsc get future]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/thread/promise/get_future | returns a {{ltt|cpp/thread/future}} associated with the promised result}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc operator=</title>
    <ns>10</ns>
    <id>6431</id>
    <revision>
      <id>60156</id>
      <parentid>55275</parentid>
      <timestamp>2013-06-01T06:45:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list operator=]] to [[Template:cpp/thread/promise/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">{{dsc mem fun | cpp/thread/promise/operator{{=}} | assigns the shared state}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc set exception</title>
    <ns>10</ns>
    <id>6435</id>
    <revision>
      <id>60158</id>
      <parentid>55276</parentid>
      <timestamp>2013-06-01T06:45:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list set exception]] to [[Template:cpp/thread/promise/dsc set exception]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc mem fun | cpp/thread/promise/set_exception | sets the result to indicate an exception}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc set exception at thread exit</title>
    <ns>10</ns>
    <id>6436</id>
    <revision>
      <id>60160</id>
      <parentid>55279</parentid>
      <timestamp>2013-06-01T06:45:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list set exception at thread exit]] to [[Template:cpp/thread/promise/dsc set exception at thread exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc mem fun | cpp/thread/promise/set_exception_at_thread_exit | sets the result to indicate an exception while delivering the notification only at thread exit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc set value</title>
    <ns>10</ns>
    <id>6434</id>
    <revision>
      <id>60162</id>
      <parentid>55280</parentid>
      <timestamp>2013-06-01T06:45:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list set value]] to [[Template:cpp/thread/promise/dsc set value]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem fun | cpp/thread/promise/set_value | sets the result to specific value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc set value at thread exit</title>
    <ns>10</ns>
    <id>5084</id>
    <revision>
      <id>60164</id>
      <parentid>55283</parentid>
      <timestamp>2013-06-01T06:45:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list set value at thread exit]] to [[Template:cpp/thread/promise/dsc set value at thread exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc mem fun | cpp/thread/promise/set_value_at_thread_exit | sets the result to specific value while delivering the notification only at thread exit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc swap</title>
    <ns>10</ns>
    <id>6432</id>
    <revision>
      <id>60166</id>
      <parentid>55284</parentid>
      <timestamp>2013-06-01T06:45:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list swap]] to [[Template:cpp/thread/promise/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/thread/promise/swap | swaps two promise objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc swap2</title>
    <ns>10</ns>
    <id>6445</id>
    <revision>
      <id>60168</id>
      <parentid>55285</parentid>
      <timestamp>2013-06-01T06:45:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list swap2]] to [[Template:cpp/thread/promise/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tfun | cpp/thread/promise/swap2 | title=std::swap{{dsc small|(std::promise)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/dsc uses allocator</title>
    <ns>10</ns>
    <id>3387</id>
    <revision>
      <id>60170</id>
      <parentid>55286</parentid>
      <timestamp>2013-06-01T06:45:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/promise/dcl list uses allocator]] to [[Template:cpp/thread/promise/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="186">{{dsc ptclass | cpp/thread/promise/uses_allocator | title=std::uses_allocator{{dsc small|&lt;std::promise&gt;}} | specializes the {{lc|std::uses_allocator}} type trait | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/navbar</title>
    <ns>10</ns>
    <id>2522</id>
    <revision>
      <id>40033</id>
      <parentid>35614</parentid>
      <timestamp>2012-09-28T20:19:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/promise/navbar heading
|content3 = cpp/thread/promise/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/navbar content</title>
    <ns>10</ns>
    <id>2919</id>
    <revision>
      <id>55289</id>
      <parentid>35422</parentid>
      <timestamp>2013-06-01T05:22:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="556">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/promise/promise}}
{{nv mem ln | cpp/thread/promise/~promise}}
{{nv mem ln | cpp/thread/promise/operator{{=}}}}
{{nv mem ln | cpp/thread/promise/swap}}

{{nv h2 | Getting the result}}
{{nv mem ln | cpp/thread/promise/get_future}}

{{nv h2 | Setting the result}}
{{nv mem ln | cpp/thread/promise/set_value}}
{{nv mem ln | cpp/thread/promise/set_value_at_thread_exit}}
{{nv mem ln | cpp/thread/promise/set_exception}}
{{nv mem ln | cpp/thread/promise/set_exception_at_thread_exit}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/navbar heading</title>
    <ns>10</ns>
    <id>2524</id>
    <revision>
      <id>48090</id>
      <parentid>35212</parentid>
      <timestamp>2013-05-18T18:09:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="39">{{ltt|cpp/thread/promise|std::promise}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/promise/title</title>
    <ns>10</ns>
    <id>5087</id>
    <revision>
      <id>18394</id>
      <timestamp>2012-02-02T04:41:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=promise::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive mutex/example try lock</title>
    <ns>10</ns>
    <id>10115</id>
    <revision>
      <id>48182</id>
      <timestamp>2013-05-18T22:44:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="579">{{example
| code=
#include &lt;iostream&gt;
#include &lt;mutex&gt;
	
int main()
{
    std::mutex test;
    if (test.try_lock()==true) {
        std::cout &lt;&lt; &quot;lock acquired&quot; &lt;&lt; std::endl;
        test.unlock();	//now unlock the mutex    
    } else {
        std::cout &lt;&lt; &quot;lock not acquired&quot; &lt;&lt; std::endl;
    }

    test.lock();	//to lock it again
    if (test.try_lock()) {  //true can be left out
        std::cout &lt;&lt; &quot;lock acquired&quot; &lt;&lt; std::endl;
    } else {
        std::cout &lt;&lt; &quot;lock not acquired&quot; &lt;&lt; std::endl;
    }
    test.unlock(); 
}
 | output=
lock acquired
lock not acquired
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive mutex/navbar</title>
    <ns>10</ns>
    <id>2314</id>
    <revision>
      <id>47753</id>
      <parentid>40034</parentid>
      <timestamp>2013-05-16T20:21:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="259">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/recursive_mutex/navbar heading
|content3 = cpp/thread/recursive_mutex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive mutex/navbar content</title>
    <ns>10</ns>
    <id>2354</id>
    <revision>
      <id>55290</id>
      <parentid>35939</parentid>
      <timestamp>2013-06-01T05:22:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="366">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/recursive_mutex/recursive_mutex}}

{{nv h2 | Locking}}
{{nv mem ln | cpp/thread/recursive_mutex/lock}}
{{nv mem ln | cpp/thread/recursive_mutex/try_lock}}
{{nv mem ln | cpp/thread/recursive_mutex/unlock}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/recursive_mutex/native_handle}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive mutex/navbar heading</title>
    <ns>10</ns>
    <id>2317</id>
    <revision>
      <id>47750</id>
      <parentid>47749</parentid>
      <timestamp>2013-05-16T20:21:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="55">{{ltt|cpp/thread/recursive_mutex|std::recursive_mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive mutex/title</title>
    <ns>10</ns>
    <id>2347</id>
    <revision>
      <id>5324</id>
      <timestamp>2011-07-24T19:04:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=recursive_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=recursive_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive timed mutex/example try lock</title>
    <ns>10</ns>
    <id>10116</id>
    <revision>
      <id>48183</id>
      <timestamp>2013-05-18T22:44:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+todo</comment>
      <text xml:space="preserve" bytes="32">{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive timed mutex/navbar</title>
    <ns>10</ns>
    <id>2313</id>
    <revision>
      <id>47754</id>
      <parentid>40035</parentid>
      <timestamp>2013-05-16T20:21:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="271">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/recursive_timed_mutex/navbar heading
|content3 = cpp/thread/recursive_timed_mutex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive timed mutex/navbar content</title>
    <ns>10</ns>
    <id>2356</id>
    <revision>
      <id>55293</id>
      <parentid>35942</parentid>
      <timestamp>2013-06-01T05:22:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="528">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/recursive_timed_mutex}}

{{nv h2 | Locking}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/lock}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/try_lock}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/try_lock_for}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/try_lock_until}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/unlock}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/recursive_timed_mutex/native_handle}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive timed mutex/navbar heading</title>
    <ns>10</ns>
    <id>2318</id>
    <revision>
      <id>47764</id>
      <parentid>34245</parentid>
      <timestamp>2013-05-16T20:24:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="67">{{ltt|cpp/thread/recursive_timed_mutex|std::recursive_timed_mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/recursive timed mutex/title</title>
    <ns>10</ns>
    <id>2346</id>
    <revision>
      <id>5323</id>
      <timestamp>2011-07-24T19:04:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=recursive_timed_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="118">&lt;onlyinclude&gt;{{cpp/title | n=recursive_timed_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared future/navbar</title>
    <ns>10</ns>
    <id>2520</id>
    <revision>
      <id>40036</id>
      <parentid>35943</parentid>
      <timestamp>2012-09-28T20:20:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="257">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/shared_future/navbar heading
|content3 = cpp/thread/shared_future/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared future/navbar content</title>
    <ns>10</ns>
    <id>2917</id>
    <revision>
      <id>55296</id>
      <parentid>35944</parentid>
      <timestamp>2013-06-01T05:22:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="509">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/shared_future/shared_future}}
{{nv mem ln | cpp/thread/shared_future/~shared_future}}
{{nv mem ln | cpp/thread/shared_future/operator{{=}}}}

{{nv h2 | Getting the result}}
{{nv mem ln | cpp/thread/shared_future/get}}

{{nv h2 | State}}
{{nv mem ln | cpp/thread/shared_future/valid}}
{{nv mem ln | cpp/thread/shared_future/wait}}
{{nv mem ln | cpp/thread/shared_future/wait_for}}
{{nv mem ln | cpp/thread/shared_future/wait_until}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared future/navbar heading</title>
    <ns>10</ns>
    <id>2523</id>
    <revision>
      <id>47782</id>
      <parentid>33196</parentid>
      <timestamp>2013-05-16T20:28:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="51">{{ltt|cpp/thread/shared_future|std::shared_future}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared future/title</title>
    <ns>10</ns>
    <id>6464</id>
    <revision>
      <id>25602</id>
      <timestamp>2012-04-23T09:36:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=shared_future::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc constructor</title>
    <ns>10</ns>
    <id>12933</id>
    <revision>
      <id>65024</id>
      <timestamp>2013-08-29T18:36:45Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem ctor | cpp/thread/shared_lock/shared_lock | constructs a {{tt|shared_lock}}, optionally locking the supplied mutex }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc destructor</title>
    <ns>10</ns>
    <id>12934</id>
    <revision>
      <id>65025</id>
      <timestamp>2013-08-29T18:37:59Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem dtor | cpp/thread/shared_lock/~shared_lock | unlocks the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc lock</title>
    <ns>10</ns>
    <id>12935</id>
    <revision>
      <id>65026</id>
      <timestamp>2013-08-29T18:39:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/thread/shared_lock/lock | locks the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc mutex</title>
    <ns>10</ns>
    <id>12942</id>
    <revision>
      <id>65033</id>
      <timestamp>2013-08-29T18:44:12Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/thread/shared_lock/mutex | returns a pointer to the associated mutex }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc operator=</title>
    <ns>10</ns>
    <id>12945</id>
    <revision>
      <id>65036</id>
      <timestamp>2013-08-29T18:46:26Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/thread/shared_lock/operator{{=}} | unlocks the mutex, if owned, and acquires ownership of another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc operator bool</title>
    <ns>10</ns>
    <id>12944</id>
    <revision>
      <id>65035</id>
      <timestamp>2013-08-29T18:45:43Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">{{dsc mem fun | cpp/thread/shared_lock/operator bool |  tests whether the lock owns its associated mutex }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc owns lock</title>
    <ns>10</ns>
    <id>12943</id>
    <revision>
      <id>65034</id>
      <timestamp>2013-08-29T18:44:54Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem fun | cpp/thread/shared_lock/owns_lock | tests whether the lock owns its associated mutex  }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc release</title>
    <ns>10</ns>
    <id>12941</id>
    <revision>
      <id>65032</id>
      <timestamp>2013-08-29T18:43:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/thread/shared_lock/release | disassociates the mutex without unlocking}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc swap</title>
    <ns>10</ns>
    <id>12940</id>
    <revision>
      <id>65031</id>
      <timestamp>2013-08-29T18:42:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem fun | cpp/thread/shared_lock/swap | swaps the data members with another shared_lock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc swap2</title>
    <ns>10</ns>
    <id>12802</id>
    <revision>
      <id>63149</id>
      <timestamp>2013-07-03T08:19:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="153">{{dsc tfun | cpp/thread/shared_lock/swap2 | title=std::swap{{dsc small|(std::shared_lock)}} | specialization of {{lc|std::swap}} for {{tt|shared_lock}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc try lock</title>
    <ns>10</ns>
    <id>12936</id>
    <revision>
      <id>65027</id>
      <timestamp>2013-08-29T18:39:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/thread/shared_lock/try_lock | tries to lock the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc try lock for</title>
    <ns>10</ns>
    <id>12938</id>
    <revision>
      <id>65029</id>
      <timestamp>2013-08-29T18:41:29Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">{{dsc mem fun | cpp/thread/shared_lock/try_lock_for | tries to lock the associated mutex, for the specified duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc try lock until</title>
    <ns>10</ns>
    <id>12937</id>
    <revision>
      <id>65028</id>
      <timestamp>2013-08-29T18:41:05Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/thread/shared_lock/try_lock_until | tries to lock the associated mutex, until a specified time point}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/dsc unlock</title>
    <ns>10</ns>
    <id>12939</id>
    <revision>
      <id>65030</id>
      <timestamp>2013-08-29T18:41:55Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="78">{{dsc mem fun | cpp/thread/shared_lock/unlock | unlocks the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/navbar</title>
    <ns>10</ns>
    <id>10113</id>
    <revision>
      <id>48176</id>
      <timestamp>2013-05-18T21:04:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/shared_lock/navbar heading
|content3 = cpp/thread/shared_lock/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/navbar content</title>
    <ns>10</ns>
    <id>12647</id>
    <revision>
      <id>63153</id>
      <parentid>63152</parentid>
      <timestamp>2013-07-03T08:20:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="864">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/shared_lock/shared_lock}}
{{nv mem ln | cpp/thread/shared_lock/~shared_lock}}
{{nv mem ln | cpp/thread/shared_lock/operator{{=}}}}

{{nv h2 | Shared locking}}
{{nv mem ln | cpp/thread/shared_lock/lock}}
{{nv mem ln | cpp/thread/shared_lock/try_lock}}
{{nv mem ln | cpp/thread/shared_lock/try_lock_for}}
{{nv mem ln | cpp/thread/shared_lock/try_lock_until}}
{{nv mem ln | cpp/thread/shared_lock/unlock}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/thread/shared_lock/swap}}
{{nv mem ln | cpp/thread/shared_lock/release}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/thread/shared_lock/mutex}}
{{nv mem ln | cpp/thread/shared_lock/owns_lock}}
{{nv mem ln | cpp/thread/shared_lock/operator bool}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/thread/shared_lock/swap2 | std::swap(shared_lock)}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/navbar heading</title>
    <ns>10</ns>
    <id>10114</id>
    <revision>
      <id>48177</id>
      <timestamp>2013-05-18T21:05:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/thread/shared_lock|std::shared_lock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared lock/title</title>
    <ns>10</ns>
    <id>12976</id>
    <revision>
      <id>65371</id>
      <timestamp>2013-09-10T18:29:04Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=shared_lock::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>e8tmwncx7alcpmjjj5933bil4hnbm4b</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared mutex/navbar</title>
    <ns>10</ns>
    <id>13469</id>
    <redirect title="Template:cpp/thread/shared timed mutex/navbar" />
    <revision>
      <id>68900</id>
      <timestamp>2014-03-22T22:29:35Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[Template:cpp/thread/shared mutex/navbar]] to [[Template:cpp/thread/shared timed mutex/navbar]]</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/thread/shared timed mutex/navbar]]</text>
      <sha1>tbis8pdoc5dd55sdd7bauz87hr6rjpn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared mutex/navbar content</title>
    <ns>10</ns>
    <id>13472</id>
    <redirect title="Template:cpp/thread/shared timed mutex/navbar content" />
    <revision>
      <id>68908</id>
      <timestamp>2014-03-22T22:32:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[Template:cpp/thread/shared mutex/navbar content]] to [[Template:cpp/thread/shared timed mutex/navbar content]]</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/thread/shared timed mutex/navbar content]]</text>
      <sha1>97v2p1kjl3gdd9denjw0qj92ni6964a</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared mutex/navbar heading</title>
    <ns>10</ns>
    <id>13471</id>
    <redirect title="Template:cpp/thread/shared timed mutex/navbar heading" />
    <revision>
      <id>68905</id>
      <timestamp>2014-03-22T22:31:22Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[Template:cpp/thread/shared mutex/navbar heading]] to [[Template:cpp/thread/shared timed mutex/navbar heading]]</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/thread/shared timed mutex/navbar heading]]</text>
      <sha1>6wsxepacz7ufq9eywvslra66l75luki</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared mutex/title</title>
    <ns>10</ns>
    <id>13474</id>
    <redirect title="Template:cpp/thread/shared timed mutex/title" />
    <revision>
      <id>68914</id>
      <timestamp>2014-03-22T22:34:13Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Cubbi moved page [[Template:cpp/thread/shared mutex/title]] to [[Template:cpp/thread/shared timed mutex/title]]</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/thread/shared timed mutex/title]]</text>
      <sha1>4mo64ourec6izft8ol4k1xs267xdxic</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared timed mutex/navbar</title>
    <ns>10</ns>
    <id>10110</id>
    <revision>
      <id>68903</id>
      <parentid>68899</parentid>
      <timestamp>2014-03-22T22:31:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>moved</comment>
      <text xml:space="preserve" bytes="265">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/shared_timed_mutex/navbar heading
|content3 = cpp/thread/shared_timed_mutex/navbar content
}}</text>
      <sha1>7eoonwem5i4iqdqy0bjy5nf8ifxy0rf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared timed mutex/navbar content</title>
    <ns>10</ns>
    <id>12648</id>
    <revision>
      <id>68918</id>
      <parentid>68909</parentid>
      <timestamp>2014-03-22T22:35:38Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="769">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/shared_timed_mutex/shared_timed_mutex}}

{{nv h2 | Exclusive locking}}
{{nv mem ln | cpp/thread/shared_timed_mutex/lock}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock_for}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock_until}}
{{nv mem ln | cpp/thread/shared_timed_mutex/unlock}}

{{nv h2 | Shared locking}}
{{nv mem ln | cpp/thread/shared_timed_mutex/lock_shared}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock_shared}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock_shared_for}}
{{nv mem ln | cpp/thread/shared_timed_mutex/try_lock_shared_until}}
{{nv mem ln | cpp/thread/shared_timed_mutex/unlock_shared}}
{{nv end}}</text>
      <sha1>i2w3hbvpts7bh3wdyhzdvyvks77boi1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared timed mutex/navbar heading</title>
    <ns>10</ns>
    <id>10111</id>
    <revision>
      <id>68906</id>
      <parentid>68904</parentid>
      <timestamp>2014-03-22T22:31:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>moved</comment>
      <text xml:space="preserve" bytes="61">{{ltt|cpp/thread/shared_timed_mutex|std::shared_timed_mutex}}</text>
      <sha1>33wdabnzkjs8c12pnj5hnm9vl9uxxyx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/shared timed mutex/title</title>
    <ns>10</ns>
    <id>12991</id>
    <revision>
      <id>68915</id>
      <parentid>68913</parentid>
      <timestamp>2014-03-22T22:34:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>move</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=shared_timed_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1>b82z49x76m9nlkt2gl5ni5ad5koekmv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list constructor</title>
    <ns>10</ns>
    <id>12254</id>
    <redirect title="Template:cpp/thread/thread/dsc constructor" />
    <revision>
      <id>60173</id>
      <timestamp>2013-06-01T06:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list constructor]] to [[Template:cpp/thread/thread/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/thread/thread/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list destructor</title>
    <ns>10</ns>
    <id>12255</id>
    <redirect title="Template:cpp/thread/thread/dsc destructor" />
    <revision>
      <id>60175</id>
      <timestamp>2013-06-01T06:45:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list destructor]] to [[Template:cpp/thread/thread/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/thread/thread/dsc destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list detach</title>
    <ns>10</ns>
    <id>12256</id>
    <redirect title="Template:cpp/thread/thread/dsc detach" />
    <revision>
      <id>60177</id>
      <timestamp>2013-06-01T06:45:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list detach]] to [[Template:cpp/thread/thread/dsc detach]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/thread/thread/dsc detach]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list get id</title>
    <ns>10</ns>
    <id>12257</id>
    <redirect title="Template:cpp/thread/thread/dsc get id" />
    <revision>
      <id>60179</id>
      <timestamp>2013-06-01T06:45:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list get id]] to [[Template:cpp/thread/thread/dsc get id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/thread/thread/dsc get id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list hardware concurrency</title>
    <ns>10</ns>
    <id>12258</id>
    <redirect title="Template:cpp/thread/thread/dsc hardware concurrency" />
    <revision>
      <id>60181</id>
      <timestamp>2013-06-01T06:45:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list hardware concurrency]] to [[Template:cpp/thread/thread/dsc hardware concurrency]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/thread/thread/dsc hardware concurrency]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list id</title>
    <ns>10</ns>
    <id>12259</id>
    <redirect title="Template:cpp/thread/thread/dsc id" />
    <revision>
      <id>60183</id>
      <timestamp>2013-06-01T06:45:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list id]] to [[Template:cpp/thread/thread/dsc id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/thread/thread/dsc id]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list join</title>
    <ns>10</ns>
    <id>12260</id>
    <redirect title="Template:cpp/thread/thread/dsc join" />
    <revision>
      <id>60185</id>
      <timestamp>2013-06-01T06:45:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list join]] to [[Template:cpp/thread/thread/dsc join]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/thread/thread/dsc join]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list joinable</title>
    <ns>10</ns>
    <id>12261</id>
    <redirect title="Template:cpp/thread/thread/dsc joinable" />
    <revision>
      <id>60187</id>
      <timestamp>2013-06-01T06:45:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list joinable]] to [[Template:cpp/thread/thread/dsc joinable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/thread/thread/dsc joinable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list native handle</title>
    <ns>10</ns>
    <id>12262</id>
    <redirect title="Template:cpp/thread/thread/dsc native handle" />
    <revision>
      <id>60189</id>
      <timestamp>2013-06-01T06:45:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list native handle]] to [[Template:cpp/thread/thread/dsc native handle]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/thread/thread/dsc native handle]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list operator=</title>
    <ns>10</ns>
    <id>12263</id>
    <redirect title="Template:cpp/thread/thread/dsc operator=" />
    <revision>
      <id>60191</id>
      <timestamp>2013-06-01T06:45:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list operator=]] to [[Template:cpp/thread/thread/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/thread/thread/dsc operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list swap</title>
    <ns>10</ns>
    <id>12264</id>
    <redirect title="Template:cpp/thread/thread/dsc swap" />
    <revision>
      <id>60193</id>
      <timestamp>2013-06-01T06:45:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list swap]] to [[Template:cpp/thread/thread/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/thread/thread/dsc swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dcl list swap2</title>
    <ns>10</ns>
    <id>12265</id>
    <redirect title="Template:cpp/thread/thread/dsc swap2" />
    <revision>
      <id>60195</id>
      <timestamp>2013-06-01T06:45:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/thread/dcl list swap2]] to [[Template:cpp/thread/thread/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/thread/thread/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc constructor</title>
    <ns>10</ns>
    <id>2256</id>
    <revision>
      <id>60172</id>
      <parentid>55299</parentid>
      <timestamp>2013-06-01T06:45:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list constructor]] to [[Template:cpp/thread/thread/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem ctor | cpp/thread/thread/thread | constructs new thread object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc destructor</title>
    <ns>10</ns>
    <id>2257</id>
    <revision>
      <id>60174</id>
      <parentid>55300</parentid>
      <timestamp>2013-06-01T06:45:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list destructor]] to [[Template:cpp/thread/thread/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem dtor | cpp/thread/thread/~thread | destructs the thread object, underlying thread must be joined or detached}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc detach</title>
    <ns>10</ns>
    <id>2264</id>
    <revision>
      <id>60176</id>
      <parentid>55303</parentid>
      <timestamp>2013-06-01T06:45:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list detach]] to [[Template:cpp/thread/thread/dsc detach]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/thread/thread/detach | permits the thread to execute independently from the thread handle}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc get id</title>
    <ns>10</ns>
    <id>2260</id>
    <revision>
      <id>60178</id>
      <parentid>55306</parentid>
      <timestamp>2013-06-01T06:45:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list get id]] to [[Template:cpp/thread/thread/dsc get id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc mem fun | cpp/thread/thread/get_id | mem={{{mem|}}} | returns the ''id'' of the thread}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc hardware concurrency</title>
    <ns>10</ns>
    <id>2262</id>
    <revision>
      <id>60180</id>
      <parentid>55307</parentid>
      <timestamp>2013-06-01T06:45:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list hardware concurrency]] to [[Template:cpp/thread/thread/dsc hardware concurrency]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem sfun | cpp/thread/thread/hardware_concurrency | returns the number of concurrent threads supported by the implementation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc id</title>
    <ns>10</ns>
    <id>8873</id>
    <revision>
      <id>60182</id>
      <parentid>55308</parentid>
      <timestamp>2013-06-01T06:45:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list id]] to [[Template:cpp/thread/thread/dsc id]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">{{dsc mem class | cpp/thread/thread/id | represents the ''id'' of a thread}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc join</title>
    <ns>10</ns>
    <id>2263</id>
    <revision>
      <id>60184</id>
      <parentid>55309</parentid>
      <timestamp>2013-06-01T06:45:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list join]] to [[Template:cpp/thread/thread/dsc join]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="85">{{dsc mem fun | cpp/thread/thread/join | waits for a thread to finish its execution}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc joinable</title>
    <ns>10</ns>
    <id>2259</id>
    <revision>
      <id>60186</id>
      <parentid>55312</parentid>
      <timestamp>2013-06-01T06:45:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list joinable]] to [[Template:cpp/thread/thread/dsc joinable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc mem fun | cpp/thread/thread/joinable | checks whether the thread is joinable, i.e. potentially running in parallel context}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc native handle</title>
    <ns>10</ns>
    <id>2261</id>
    <revision>
      <id>60188</id>
      <parentid>55313</parentid>
      <timestamp>2013-06-01T06:45:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list native handle]] to [[Template:cpp/thread/thread/dsc native handle]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc mem fun | cpp/thread/thread/native_handle | returns the underlying implementation-defined thread handle}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc operator=</title>
    <ns>10</ns>
    <id>2258</id>
    <revision>
      <id>60190</id>
      <parentid>55314</parentid>
      <timestamp>2013-06-01T06:45:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list operator=]] to [[Template:cpp/thread/thread/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/thread/thread/operator{{=}} | moves the thread object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc swap</title>
    <ns>10</ns>
    <id>2265</id>
    <revision>
      <id>60192</id>
      <parentid>55317</parentid>
      <timestamp>2013-06-01T06:45:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list swap]] to [[Template:cpp/thread/thread/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc mem fun | cpp/thread/thread/swap | swaps two thread objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/dsc swap2</title>
    <ns>10</ns>
    <id>2266</id>
    <revision>
      <id>60194</id>
      <parentid>55318</parentid>
      <timestamp>2013-06-01T06:45:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/thread/dcl list swap2]] to [[Template:cpp/thread/thread/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/thread/thread/swap2 | title=std::swap{{dsc small|(std::thread)}} | specializes the {{lc|std::swap}} algorithm| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/dsc operator cmp</title>
    <ns>10</ns>
    <id>12659</id>
    <revision>
      <id>61423</id>
      <timestamp>2013-06-06T00:14:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="197">{{dsc fun | cpp/thread/thread/id/operator_cmp | title=operator{{==}}&lt;br&gt;operator!{{=}}&lt;br&gt;operator&lt; &lt;br&gt; operator&lt;{{=}} &lt;br&gt; operator&gt; &lt;br&gt; operator&gt;{{=}} | compares two {{tt|thread::id}} objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/dsc operator ltlt</title>
    <ns>10</ns>
    <id>12660</id>
    <revision>
      <id>61425</id>
      <timestamp>2013-06-06T00:15:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">{{dsc tfun | cpp/thread/thread/id/operator_ltlt | title=operator&lt;&lt; | serializes a {{tt|thread::id}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/navbar</title>
    <ns>10</ns>
    <id>5139</id>
    <revision>
      <id>40037</id>
      <parentid>36035</parentid>
      <timestamp>2012-09-28T20:20:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="338">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/thread/navbar heading
|content3 = cpp/thread/thread/navbar content

|heading4 = cpp/thread/thread/id/navbar heading
|content4 = cpp/thread/thread/id/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/navbar content</title>
    <ns>10</ns>
    <id>5141</id>
    <revision>
      <id>55321</id>
      <parentid>38107</parentid>
      <timestamp>2013-06-01T05:22:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="422">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/thread/id/id}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/thread/thread/id/operator_cmp | operator{{==}}|operator!{{=}}|operator&lt;|operator&lt;{{=}}|operator&gt;|operator&gt;{{=}} }}
{{nv ln | cpp/thread/thread/id/operator_ltlt | operator&lt;&lt;}}
{{nv h1 | Helper classes}}
{{nv ln | cpp/thread/thread/id/hash | std::hash{{dsc small|&lt;std::thread::id&gt;}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/navbar heading</title>
    <ns>10</ns>
    <id>5140</id>
    <revision>
      <id>60986</id>
      <parentid>60985</parentid>
      <timestamp>2013-06-03T11:42:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="44">{{ltt|cpp/thread/thread/id|std::thread::id}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/id/title</title>
    <ns>10</ns>
    <id>9077</id>
    <revision>
      <id>38111</id>
      <timestamp>2012-07-24T10:23:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/thread/thread/title | n=id::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/navbar</title>
    <ns>10</ns>
    <id>2254</id>
    <revision>
      <id>47777</id>
      <parentid>40038</parentid>
      <timestamp>2013-05-16T20:26:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/thread/navbar heading
|content3 = cpp/thread/thread/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/navbar content</title>
    <ns>10</ns>
    <id>2270</id>
    <revision>
      <id>55322</id>
      <parentid>35951</parentid>
      <timestamp>2013-06-01T05:22:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="682">{{nv begin}}
{{nv h1 | Member classes}}
{{nv mem ln | cpp/thread/thread/id}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/thread/thread}}
{{nv mem ln | cpp/thread/thread/~thread}}
{{nv mem ln | cpp/thread/thread/operator{{=}}}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/thread/thread/joinable}}
{{nv mem ln | cpp/thread/thread/get_id}}
{{nv mem ln | cpp/thread/thread/native_handle}}
{{nv mem ln | cpp/thread/thread/hardware_concurrency}}

{{nv h2 | Operations}}
{{nv mem ln | cpp/thread/thread/join}}
{{nv mem ln | cpp/thread/thread/detach}}
{{nv mem ln | cpp/thread/thread/swap}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/thread/thread/swap2 | std::swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/navbar heading</title>
    <ns>10</ns>
    <id>2255</id>
    <revision>
      <id>47760</id>
      <parentid>35952</parentid>
      <timestamp>2013-05-16T20:23:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="37">{{ltt|cpp/thread/thread|std::thread}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/thread/title</title>
    <ns>10</ns>
    <id>2269</id>
    <revision>
      <id>5141</id>
      <timestamp>2011-07-17T12:04:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=thread::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=thread::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/timed mutex/example try lock</title>
    <ns>10</ns>
    <id>10117</id>
    <revision>
      <id>48184</id>
      <timestamp>2013-05-18T22:45:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+todo</comment>
      <text xml:space="preserve" bytes="32">{{example
 | code=
 | output=
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/timed mutex/navbar</title>
    <ns>10</ns>
    <id>2312</id>
    <revision>
      <id>47772</id>
      <parentid>40039</parentid>
      <timestamp>2013-05-16T20:26:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/timed_mutex/navbar heading
|content3 = cpp/thread/timed_mutex/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/timed mutex/navbar content</title>
    <ns>10</ns>
    <id>2355</id>
    <revision>
      <id>55323</id>
      <parentid>35954</parentid>
      <timestamp>2013-06-01T05:22:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="448">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/timed_mutex/timed_mutex}}

{{nv h2 | Locking}}
{{nv mem ln | cpp/thread/timed_mutex/lock}}
{{nv mem ln | cpp/thread/timed_mutex/try_lock}}
{{nv mem ln | cpp/thread/timed_mutex/try_lock_for}}
{{nv mem ln | cpp/thread/timed_mutex/try_lock_until}}
{{nv mem ln | cpp/thread/timed_mutex/unlock}}

{{nv h2 | Native handle}}
{{nv mem ln | cpp/thread/timed_mutex/native_handle}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/timed mutex/navbar heading</title>
    <ns>10</ns>
    <id>2316</id>
    <revision>
      <id>47751</id>
      <parentid>35925</parentid>
      <timestamp>2013-05-16T20:21:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/thread/timed_mutex|std::timed_mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/timed mutex/title</title>
    <ns>10</ns>
    <id>2345</id>
    <revision>
      <id>5322</id>
      <timestamp>2011-07-24T19:03:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=timed_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=timed_mutex::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list constructor</title>
    <ns>10</ns>
    <id>12266</id>
    <redirect title="Template:cpp/thread/unique lock/dsc constructor" />
    <revision>
      <id>60197</id>
      <timestamp>2013-06-01T06:45:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list constructor]] to [[Template:cpp/thread/unique lock/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/thread/unique lock/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list destructor</title>
    <ns>10</ns>
    <id>12267</id>
    <redirect title="Template:cpp/thread/unique lock/dsc destructor" />
    <revision>
      <id>60199</id>
      <timestamp>2013-06-01T06:45:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list destructor]] to [[Template:cpp/thread/unique lock/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/thread/unique lock/dsc destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list lock</title>
    <ns>10</ns>
    <id>12268</id>
    <redirect title="Template:cpp/thread/unique lock/dsc lock" />
    <revision>
      <id>60201</id>
      <timestamp>2013-06-01T06:45:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list lock]] to [[Template:cpp/thread/unique lock/dsc lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/thread/unique lock/dsc lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list mutex</title>
    <ns>10</ns>
    <id>12269</id>
    <redirect title="Template:cpp/thread/unique lock/dsc mutex" />
    <revision>
      <id>60203</id>
      <timestamp>2013-06-01T06:45:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list mutex]] to [[Template:cpp/thread/unique lock/dsc mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/thread/unique lock/dsc mutex]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list operator=</title>
    <ns>10</ns>
    <id>12270</id>
    <redirect title="Template:cpp/thread/unique lock/dsc operator=" />
    <revision>
      <id>60205</id>
      <timestamp>2013-06-01T06:45:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list operator=]] to [[Template:cpp/thread/unique lock/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/thread/unique lock/dsc operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list operator bool</title>
    <ns>10</ns>
    <id>12271</id>
    <redirect title="Template:cpp/thread/unique lock/dsc operator bool" />
    <revision>
      <id>60207</id>
      <timestamp>2013-06-01T06:45:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list operator bool]] to [[Template:cpp/thread/unique lock/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/thread/unique lock/dsc operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list owns lock</title>
    <ns>10</ns>
    <id>12272</id>
    <redirect title="Template:cpp/thread/unique lock/dsc owns lock" />
    <revision>
      <id>60209</id>
      <timestamp>2013-06-01T06:45:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list owns lock]] to [[Template:cpp/thread/unique lock/dsc owns lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/thread/unique lock/dsc owns lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list release</title>
    <ns>10</ns>
    <id>12273</id>
    <redirect title="Template:cpp/thread/unique lock/dsc release" />
    <revision>
      <id>60211</id>
      <timestamp>2013-06-01T06:45:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list release]] to [[Template:cpp/thread/unique lock/dsc release]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/thread/unique lock/dsc release]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list swap</title>
    <ns>10</ns>
    <id>12274</id>
    <redirect title="Template:cpp/thread/unique lock/dsc swap" />
    <revision>
      <id>60213</id>
      <timestamp>2013-06-01T06:45:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list swap]] to [[Template:cpp/thread/unique lock/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/thread/unique lock/dsc swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list swap2</title>
    <ns>10</ns>
    <id>12275</id>
    <redirect title="Template:cpp/thread/unique lock/dsc swap2" />
    <revision>
      <id>60215</id>
      <timestamp>2013-06-01T06:45:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list swap2]] to [[Template:cpp/thread/unique lock/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/thread/unique lock/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list try lock</title>
    <ns>10</ns>
    <id>12276</id>
    <redirect title="Template:cpp/thread/unique lock/dsc try lock" />
    <revision>
      <id>60217</id>
      <timestamp>2013-06-01T06:45:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock]] to [[Template:cpp/thread/unique lock/dsc try lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/thread/unique lock/dsc try lock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list try lock for</title>
    <ns>10</ns>
    <id>12277</id>
    <redirect title="Template:cpp/thread/unique lock/dsc try lock for" />
    <revision>
      <id>60219</id>
      <timestamp>2013-06-01T06:45:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock for]] to [[Template:cpp/thread/unique lock/dsc try lock for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/thread/unique lock/dsc try lock for]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list try lock until</title>
    <ns>10</ns>
    <id>12278</id>
    <redirect title="Template:cpp/thread/unique lock/dsc try lock until" />
    <revision>
      <id>60221</id>
      <timestamp>2013-06-01T06:46:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock until]] to [[Template:cpp/thread/unique lock/dsc try lock until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/thread/unique lock/dsc try lock until]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dcl list unlock</title>
    <ns>10</ns>
    <id>12279</id>
    <redirect title="Template:cpp/thread/unique lock/dsc unlock" />
    <revision>
      <id>60223</id>
      <timestamp>2013-06-01T06:46:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list unlock]] to [[Template:cpp/thread/unique lock/dsc unlock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/thread/unique lock/dsc unlock]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc constructor</title>
    <ns>10</ns>
    <id>4456</id>
    <revision>
      <id>60196</id>
      <parentid>55324</parentid>
      <timestamp>2013-06-01T06:45:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list constructor]] to [[Template:cpp/thread/unique lock/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem ctor | cpp/thread/unique_lock/unique_lock | constructs a {{tt|unique_lock}}, optionally locking the supplied mutex }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc destructor</title>
    <ns>10</ns>
    <id>4457</id>
    <revision>
      <id>60198</id>
      <parentid>55331</parentid>
      <timestamp>2013-06-01T06:45:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list destructor]] to [[Template:cpp/thread/unique lock/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc mem dtor | cpp/thread/unique_lock/~unique_lock | unlocks the associated mutex, if owned}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc lock</title>
    <ns>10</ns>
    <id>4459</id>
    <revision>
      <id>60200</id>
      <parentid>55336</parentid>
      <timestamp>2013-06-01T06:45:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list lock]] to [[Template:cpp/thread/unique lock/dsc lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem fun | cpp/thread/unique_lock/lock | locks the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc mutex</title>
    <ns>10</ns>
    <id>4466</id>
    <revision>
      <id>60202</id>
      <parentid>55341</parentid>
      <timestamp>2013-06-01T06:45:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list mutex]] to [[Template:cpp/thread/unique lock/dsc mutex]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/thread/unique_lock/mutex | returns a pointer to the associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc operator=</title>
    <ns>10</ns>
    <id>4458</id>
    <revision>
      <id>60204</id>
      <parentid>55342</parentid>
      <timestamp>2013-06-01T06:45:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list operator=]] to [[Template:cpp/thread/unique lock/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem fun | cpp/thread/unique_lock/operator{{=}} | unlocks the mutex, if owned, and acquires ownership of another }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc operator bool</title>
    <ns>10</ns>
    <id>4467</id>
    <revision>
      <id>60206</id>
      <parentid>55345</parentid>
      <timestamp>2013-06-01T06:45:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list operator bool]] to [[Template:cpp/thread/unique lock/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc mem fun | cpp/thread/unique_lock/operator bool | tests whether the lock owns its associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc owns lock</title>
    <ns>10</ns>
    <id>4468</id>
    <revision>
      <id>60208</id>
      <parentid>55348</parentid>
      <timestamp>2013-06-01T06:45:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list owns lock]] to [[Template:cpp/thread/unique lock/dsc owns lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem fun | cpp/thread/unique_lock/owns_lock | tests whether the lock owns its associated mutex}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc release</title>
    <ns>10</ns>
    <id>4465</id>
    <revision>
      <id>60210</id>
      <parentid>55351</parentid>
      <timestamp>2013-06-01T06:45:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list release]] to [[Template:cpp/thread/unique lock/dsc release]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/thread/unique_lock/release | disassociates the associated mutex without unlocking it}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc swap</title>
    <ns>10</ns>
    <id>4464</id>
    <revision>
      <id>60212</id>
      <parentid>55352</parentid>
      <timestamp>2013-06-01T06:45:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list swap]] to [[Template:cpp/thread/unique lock/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc mem fun | cpp/thread/unique_lock/swap | swaps state with another {{lc|std::unique_lock}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc swap2</title>
    <ns>10</ns>
    <id>5514</id>
    <revision>
      <id>66384</id>
      <parentid>60214</parentid>
      <timestamp>2013-11-17T01:16:25Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>+ {{mark c++11}}</comment>
      <text xml:space="preserve" bytes="175">{{dsc tfun | cpp/thread/unique_lock/swap2 | title=std::swap{{dsc small|(std::unique_lock)}} | specialization of {{lc|std::swap}} for {{tt|unique_lock}}| notes={{mark c++11}}}}</text>
      <sha1>dq6csrae602cxiwyuvsij8zkk5ez7o1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc try lock</title>
    <ns>10</ns>
    <id>4460</id>
    <revision>
      <id>60216</id>
      <parentid>55356</parentid>
      <timestamp>2013-06-01T06:45:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock]] to [[Template:cpp/thread/unique lock/dsc try lock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/thread/unique_lock/try_lock | tries to lock the associated mutex, returns if the mutex is not available}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc try lock for</title>
    <ns>10</ns>
    <id>4461</id>
    <revision>
      <id>60218</id>
      <parentid>55357</parentid>
      <timestamp>2013-06-01T06:45:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock for]] to [[Template:cpp/thread/unique lock/dsc try lock for]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc mem fun | cpp/thread/unique_lock/try_lock_for | attempts to lock the associated {{concept|TimedLockable}} mutex, returns if the mutex has been unavailable for the specified time duration}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc try lock until</title>
    <ns>10</ns>
    <id>4462</id>
    <revision>
      <id>60220</id>
      <parentid>55362</parentid>
      <timestamp>2013-06-01T06:46:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list try lock until]] to [[Template:cpp/thread/unique lock/dsc try lock until]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="206">{{dsc mem fun | cpp/thread/unique_lock/try_lock_until | tries to lock the associated {{concept|TimedLockable}} mutex, returns if the mutex has been unavailable until specified time point has been reached }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/dsc unlock</title>
    <ns>10</ns>
    <id>4463</id>
    <revision>
      <id>60222</id>
      <parentid>55373</parentid>
      <timestamp>2013-06-01T06:46:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/thread/unique lock/dcl list unlock]] to [[Template:cpp/thread/unique lock/dsc unlock]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/thread/unique_lock/unlock | unlocks the associated mutex }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/navbar</title>
    <ns>10</ns>
    <id>2732</id>
    <revision>
      <id>48175</id>
      <parentid>40040</parentid>
      <timestamp>2013-05-18T21:04:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="251">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/thread/navbar heading
|content2 = cpp/thread/navbar content

|heading3 = cpp/thread/unique_lock/navbar heading
|content3 = cpp/thread/unique_lock/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/navbar content</title>
    <ns>10</ns>
    <id>4469</id>
    <revision>
      <id>55374</id>
      <parentid>35955</parentid>
      <timestamp>2013-06-01T05:22:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="844">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/thread/unique_lock/unique_lock}}
{{nv mem ln | cpp/thread/unique_lock/~unique_lock}}
{{nv mem ln | cpp/thread/unique_lock/operator{{=}}}}

{{nv h2 | Locking}}
{{nv mem ln | cpp/thread/unique_lock/lock}}
{{nv mem ln | cpp/thread/unique_lock/try_lock}}
{{nv mem ln | cpp/thread/unique_lock/try_lock_for}}
{{nv mem ln | cpp/thread/unique_lock/try_lock_until}}
{{nv mem ln | cpp/thread/unique_lock/unlock}}

{{nv h2 | Modifiers}}
{{nv mem ln | cpp/thread/unique_lock/swap}}
{{nv mem ln | cpp/thread/unique_lock/release}}

{{nv h2 | Observers}}
{{nv mem ln | cpp/thread/unique_lock/mutex}}
{{nv mem ln | cpp/thread/unique_lock/owns_lock}}
{{nv mem ln | cpp/thread/unique_lock/operator bool}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/thread/unique_lock/swap2 | std::swap}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/navbar heading</title>
    <ns>10</ns>
    <id>2733</id>
    <revision>
      <id>48028</id>
      <parentid>35956</parentid>
      <timestamp>2013-05-18T17:57:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="47">{{ltt|cpp/thread/unique_lock|std::unique_lock}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/thread/unique lock/title</title>
    <ns>10</ns>
    <id>4476</id>
    <revision>
      <id>15900</id>
      <timestamp>2011-12-18T13:33:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=unique_lock::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/title</title>
    <ns>10</ns>
    <id>28</id>
    <revision>
      <id>4535</id>
      <parentid>3947</parentid>
      <timestamp>2011-06-20T15:54:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="131">&lt;onlyinclude&gt;{{ctitle | n=std::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}} | {{{4|}}} | {{{5|}}} | {{{6|}}} }}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad cast/navbar</title>
    <ns>10</ns>
    <id>4754</id>
    <revision>
      <id>40041</id>
      <parentid>36029</parentid>
      <timestamp>2012-09-28T20:20:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="320">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/bad_cast/navbar heading
|content4 = cpp/types/bad_cast/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad cast/navbar content</title>
    <ns>10</ns>
    <id>4761</id>
    <revision>
      <id>55377</id>
      <parentid>35958</parentid>
      <timestamp>2013-06-01T05:23:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="146">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/types/bad_cast/bad_cast}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad cast/navbar heading</title>
    <ns>10</ns>
    <id>4756</id>
    <revision>
      <id>48081</id>
      <parentid>35832</parentid>
      <timestamp>2013-05-18T18:06:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="41">{{ltt| cpp/types/bad_cast|std::bad_cast}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad cast/title</title>
    <ns>10</ns>
    <id>4753</id>
    <revision>
      <id>17258</id>
      <timestamp>2012-01-09T16:40:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=bad_cast::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad typeid/navbar</title>
    <ns>10</ns>
    <id>4755</id>
    <revision>
      <id>40042</id>
      <parentid>36034</parentid>
      <timestamp>2012-09-28T20:20:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="324">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/bad_typeid/navbar heading
|content4 = cpp/types/bad_typeid/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad typeid/navbar content</title>
    <ns>10</ns>
    <id>4759</id>
    <revision>
      <id>55378</id>
      <parentid>35960</parentid>
      <timestamp>2013-06-01T05:23:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="150">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/types/bad_typeid/bad_typeid}}

{{nv inc | cpp/error/exception/inherit sidebar}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad typeid/navbar heading</title>
    <ns>10</ns>
    <id>4757</id>
    <revision>
      <id>48082</id>
      <parentid>35962</parentid>
      <timestamp>2013-05-18T18:06:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>use regular {{ltt}}</comment>
      <text xml:space="preserve" bytes="45">{{ltt| cpp/types/bad_typeid|std::bad_typeid}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/bad typeid/title</title>
    <ns>10</ns>
    <id>4752</id>
    <revision>
      <id>17257</id>
      <timestamp>2012-01-09T16:40:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=bad_typeid::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/climits/navbar</title>
    <ns>10</ns>
    <id>9521</id>
    <revision>
      <id>40421</id>
      <parentid>40419</parentid>
      <timestamp>2012-10-13T08:37:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>whoops</comment>
      <text xml:space="preserve" bytes="318">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/climits/navbar heading
|content4 = cpp/types/climits/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/climits/navbar content</title>
    <ns>10</ns>
    <id>9522</id>
    <revision>
      <id>55379</id>
      <parentid>40422</parentid>
      <timestamp>2013-06-01T05:23:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="110">{{nv begin}}
{{nv ln | cpp/types/climits/FLT_ROUNDS}}
{{nv ln | cpp/types/climits/FLT_EVAL_METHOD}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/climits/navbar heading</title>
    <ns>10</ns>
    <id>9523</id>
    <revision>
      <id>40423</id>
      <timestamp>2012-10-13T08:38:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="50">[[cpp/types/climits | C numeric limits interface]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list NULL</title>
    <ns>10</ns>
    <id>12280</id>
    <redirect title="Template:cpp/types/dsc NULL" />
    <revision>
      <id>60225</id>
      <timestamp>2013-06-01T06:46:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list NULL]] to [[Template:cpp/types/dsc NULL]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[Template:cpp/types/dsc NULL]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list add cv</title>
    <ns>10</ns>
    <id>12281</id>
    <redirect title="Template:cpp/types/dsc add cv" />
    <revision>
      <id>60227</id>
      <timestamp>2013-06-01T06:46:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list add cv]] to [[Template:cpp/types/dsc add cv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/types/dsc add cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list add pointer</title>
    <ns>10</ns>
    <id>12282</id>
    <redirect title="Template:cpp/types/dsc add pointer" />
    <revision>
      <id>60229</id>
      <timestamp>2013-06-01T06:46:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list add pointer]] to [[Template:cpp/types/dsc add pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc add pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list add reference</title>
    <ns>10</ns>
    <id>12283</id>
    <redirect title="Template:cpp/types/dsc add reference" />
    <revision>
      <id>60231</id>
      <timestamp>2013-06-01T06:46:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list add reference]] to [[Template:cpp/types/dsc add reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc add reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list aligned storage</title>
    <ns>10</ns>
    <id>12284</id>
    <redirect title="Template:cpp/types/dsc aligned storage" />
    <revision>
      <id>60233</id>
      <timestamp>2013-06-01T06:46:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list aligned storage]] to [[Template:cpp/types/dsc aligned storage]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/dsc aligned storage]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list aligned union</title>
    <ns>10</ns>
    <id>12285</id>
    <redirect title="Template:cpp/types/dsc aligned union" />
    <revision>
      <id>60235</id>
      <timestamp>2013-06-01T06:46:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list aligned union]] to [[Template:cpp/types/dsc aligned union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc aligned union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list alignment of</title>
    <ns>10</ns>
    <id>12286</id>
    <redirect title="Template:cpp/types/dsc alignment of" />
    <revision>
      <id>60237</id>
      <timestamp>2013-06-01T06:46:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list alignment of]] to [[Template:cpp/types/dsc alignment of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/types/dsc alignment of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list bad cast</title>
    <ns>10</ns>
    <id>12287</id>
    <redirect title="Template:cpp/types/dsc bad cast" />
    <revision>
      <id>60239</id>
      <timestamp>2013-06-01T06:46:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list bad cast]] to [[Template:cpp/types/dsc bad cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc bad cast]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list bad typeid</title>
    <ns>10</ns>
    <id>12288</id>
    <redirect title="Template:cpp/types/dsc bad typeid" />
    <revision>
      <id>60241</id>
      <timestamp>2013-06-01T06:46:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list bad typeid]] to [[Template:cpp/types/dsc bad typeid]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/types/dsc bad typeid]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list common type</title>
    <ns>10</ns>
    <id>12289</id>
    <redirect title="Template:cpp/types/dsc common type" />
    <revision>
      <id>60243</id>
      <timestamp>2013-06-01T06:46:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list common type]] to [[Template:cpp/types/dsc common type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc common type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list conditional</title>
    <ns>10</ns>
    <id>12290</id>
    <redirect title="Template:cpp/types/dsc conditional" />
    <revision>
      <id>60245</id>
      <timestamp>2013-06-01T06:46:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list conditional]] to [[Template:cpp/types/dsc conditional]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc conditional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list decay</title>
    <ns>10</ns>
    <id>12291</id>
    <redirect title="Template:cpp/types/dsc decay" />
    <revision>
      <id>60247</id>
      <timestamp>2013-06-01T06:46:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list decay]] to [[Template:cpp/types/dsc decay]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="42">#REDIRECT [[Template:cpp/types/dsc decay]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list enable if</title>
    <ns>10</ns>
    <id>12292</id>
    <redirect title="Template:cpp/types/dsc enable if" />
    <revision>
      <id>60249</id>
      <timestamp>2013-06-01T06:46:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list enable if]] to [[Template:cpp/types/dsc enable if]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc enable if]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list extent</title>
    <ns>10</ns>
    <id>12293</id>
    <redirect title="Template:cpp/types/dsc extent" />
    <revision>
      <id>60251</id>
      <timestamp>2013-06-01T06:46:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list extent]] to [[Template:cpp/types/dsc extent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/types/dsc extent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list has virtual destructor</title>
    <ns>10</ns>
    <id>12294</id>
    <redirect title="Template:cpp/types/dsc has virtual destructor" />
    <revision>
      <id>60253</id>
      <timestamp>2013-06-01T06:46:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list has virtual destructor]] to [[Template:cpp/types/dsc has virtual destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/types/dsc has virtual destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list integral constant</title>
    <ns>10</ns>
    <id>12295</id>
    <redirect title="Template:cpp/types/dsc integral constant" />
    <revision>
      <id>60255</id>
      <timestamp>2013-06-01T06:46:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list integral constant]] to [[Template:cpp/types/dsc integral constant]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/types/dsc integral constant]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is abstract</title>
    <ns>10</ns>
    <id>12296</id>
    <redirect title="Template:cpp/types/dsc is abstract" />
    <revision>
      <id>60257</id>
      <timestamp>2013-06-01T06:46:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is abstract]] to [[Template:cpp/types/dsc is abstract]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is abstract]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is arithmetic</title>
    <ns>10</ns>
    <id>12297</id>
    <redirect title="Template:cpp/types/dsc is arithmetic" />
    <revision>
      <id>60259</id>
      <timestamp>2013-06-01T06:46:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is arithmetic]] to [[Template:cpp/types/dsc is arithmetic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc is arithmetic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is array</title>
    <ns>10</ns>
    <id>12298</id>
    <redirect title="Template:cpp/types/dsc is array" />
    <revision>
      <id>60261</id>
      <timestamp>2013-06-01T06:46:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is array]] to [[Template:cpp/types/dsc is array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc is array]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is assignable</title>
    <ns>10</ns>
    <id>12299</id>
    <redirect title="Template:cpp/types/dsc is assignable" />
    <revision>
      <id>60263</id>
      <timestamp>2013-06-01T06:46:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is assignable]] to [[Template:cpp/types/dsc is assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc is assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is base of</title>
    <ns>10</ns>
    <id>12300</id>
    <redirect title="Template:cpp/types/dsc is base of" />
    <revision>
      <id>60265</id>
      <timestamp>2013-06-01T06:46:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is base of]] to [[Template:cpp/types/dsc is base of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/types/dsc is base of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is class</title>
    <ns>10</ns>
    <id>12301</id>
    <redirect title="Template:cpp/types/dsc is class" />
    <revision>
      <id>60267</id>
      <timestamp>2013-06-01T06:46:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is class]] to [[Template:cpp/types/dsc is class]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc is class]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is compound</title>
    <ns>10</ns>
    <id>12302</id>
    <redirect title="Template:cpp/types/dsc is compound" />
    <revision>
      <id>60269</id>
      <timestamp>2013-06-01T06:46:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is compound]] to [[Template:cpp/types/dsc is compound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is compound]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is const</title>
    <ns>10</ns>
    <id>12303</id>
    <redirect title="Template:cpp/types/dsc is const" />
    <revision>
      <id>60271</id>
      <timestamp>2013-06-01T06:46:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is const]] to [[Template:cpp/types/dsc is const]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc is const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is constructible</title>
    <ns>10</ns>
    <id>12304</id>
    <redirect title="Template:cpp/types/dsc is constructible" />
    <revision>
      <id>60273</id>
      <timestamp>2013-06-01T06:46:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is constructible]] to [[Template:cpp/types/dsc is constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/types/dsc is constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is convertible</title>
    <ns>10</ns>
    <id>12305</id>
    <redirect title="Template:cpp/types/dsc is convertible" />
    <revision>
      <id>60275</id>
      <timestamp>2013-06-01T06:46:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is convertible]] to [[Template:cpp/types/dsc is convertible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/dsc is convertible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is copy assignable</title>
    <ns>10</ns>
    <id>12306</id>
    <redirect title="Template:cpp/types/dsc is copy assignable" />
    <revision>
      <id>60277</id>
      <timestamp>2013-06-01T06:46:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is copy assignable]] to [[Template:cpp/types/dsc is copy assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/dsc is copy assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is copy constructible</title>
    <ns>10</ns>
    <id>12307</id>
    <redirect title="Template:cpp/types/dsc is copy constructible" />
    <revision>
      <id>60279</id>
      <timestamp>2013-06-01T06:46:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is copy constructible]] to [[Template:cpp/types/dsc is copy constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/types/dsc is copy constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is default constructible</title>
    <ns>10</ns>
    <id>12308</id>
    <redirect title="Template:cpp/types/dsc is default constructible" />
    <revision>
      <id>60281</id>
      <timestamp>2013-06-01T06:46:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is default constructible]] to [[Template:cpp/types/dsc is default constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/dsc is default constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is destructible</title>
    <ns>10</ns>
    <id>12309</id>
    <redirect title="Template:cpp/types/dsc is destructible" />
    <revision>
      <id>60283</id>
      <timestamp>2013-06-01T06:46:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is destructible]] to [[Template:cpp/types/dsc is destructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/dsc is destructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is empty</title>
    <ns>10</ns>
    <id>12310</id>
    <redirect title="Template:cpp/types/dsc is empty" />
    <revision>
      <id>60285</id>
      <timestamp>2013-06-01T06:46:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is empty]] to [[Template:cpp/types/dsc is empty]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc is empty]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is enum</title>
    <ns>10</ns>
    <id>12311</id>
    <redirect title="Template:cpp/types/dsc is enum" />
    <revision>
      <id>60287</id>
      <timestamp>2013-06-01T06:46:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is enum]] to [[Template:cpp/types/dsc is enum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[Template:cpp/types/dsc is enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is floating point</title>
    <ns>10</ns>
    <id>12312</id>
    <redirect title="Template:cpp/types/dsc is floating point" />
    <revision>
      <id>60289</id>
      <timestamp>2013-06-01T06:46:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is floating point]] to [[Template:cpp/types/dsc is floating point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/types/dsc is floating point]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is function</title>
    <ns>10</ns>
    <id>12313</id>
    <redirect title="Template:cpp/types/dsc is function" />
    <revision>
      <id>60291</id>
      <timestamp>2013-06-01T06:46:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is function]] to [[Template:cpp/types/dsc is function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is fundamental</title>
    <ns>10</ns>
    <id>12314</id>
    <redirect title="Template:cpp/types/dsc is fundamental" />
    <revision>
      <id>60293</id>
      <timestamp>2013-06-01T06:46:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is fundamental]] to [[Template:cpp/types/dsc is fundamental]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/dsc is fundamental]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is integral</title>
    <ns>10</ns>
    <id>12315</id>
    <redirect title="Template:cpp/types/dsc is integral" />
    <revision>
      <id>60295</id>
      <timestamp>2013-06-01T06:46:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is integral]] to [[Template:cpp/types/dsc is integral]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is integral]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is literal type</title>
    <ns>10</ns>
    <id>12316</id>
    <redirect title="Template:cpp/types/dsc is literal type" />
    <revision>
      <id>60297</id>
      <timestamp>2013-06-01T06:46:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is literal type]] to [[Template:cpp/types/dsc is literal type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/dsc is literal type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is lvalue reference</title>
    <ns>10</ns>
    <id>12317</id>
    <redirect title="Template:cpp/types/dsc is lvalue reference" />
    <revision>
      <id>60299</id>
      <timestamp>2013-06-01T06:46:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is lvalue reference]] to [[Template:cpp/types/dsc is lvalue reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/types/dsc is lvalue reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is member function pointer</title>
    <ns>10</ns>
    <id>12318</id>
    <redirect title="Template:cpp/types/dsc is member function pointer" />
    <revision>
      <id>60301</id>
      <timestamp>2013-06-01T06:46:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is member function pointer]] to [[Template:cpp/types/dsc is member function pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/types/dsc is member function pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is member object pointer</title>
    <ns>10</ns>
    <id>12319</id>
    <redirect title="Template:cpp/types/dsc is member object pointer" />
    <revision>
      <id>60303</id>
      <timestamp>2013-06-01T06:46:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is member object pointer]] to [[Template:cpp/types/dsc is member object pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/dsc is member object pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is member pointer</title>
    <ns>10</ns>
    <id>12320</id>
    <redirect title="Template:cpp/types/dsc is member pointer" />
    <revision>
      <id>60305</id>
      <timestamp>2013-06-01T06:46:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is member pointer]] to [[Template:cpp/types/dsc is member pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/types/dsc is member pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is move assignable</title>
    <ns>10</ns>
    <id>12321</id>
    <redirect title="Template:cpp/types/dsc is move assignable" />
    <revision>
      <id>60307</id>
      <timestamp>2013-06-01T06:46:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is move assignable]] to [[Template:cpp/types/dsc is move assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/dsc is move assignable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is move constructible</title>
    <ns>10</ns>
    <id>12322</id>
    <redirect title="Template:cpp/types/dsc is move constructible" />
    <revision>
      <id>60309</id>
      <timestamp>2013-06-01T06:46:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is move constructible]] to [[Template:cpp/types/dsc is move constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/types/dsc is move constructible]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is object</title>
    <ns>10</ns>
    <id>12323</id>
    <redirect title="Template:cpp/types/dsc is object" />
    <revision>
      <id>60311</id>
      <timestamp>2013-06-01T06:46:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is object]] to [[Template:cpp/types/dsc is object]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc is object]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is pod</title>
    <ns>10</ns>
    <id>12324</id>
    <redirect title="Template:cpp/types/dsc is pod" />
    <revision>
      <id>60313</id>
      <timestamp>2013-06-01T06:47:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is pod]] to [[Template:cpp/types/dsc is pod]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/types/dsc is pod]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is pointer</title>
    <ns>10</ns>
    <id>12325</id>
    <redirect title="Template:cpp/types/dsc is pointer" />
    <revision>
      <id>60315</id>
      <timestamp>2013-06-01T06:47:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is pointer]] to [[Template:cpp/types/dsc is pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/types/dsc is pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is polymorphic</title>
    <ns>10</ns>
    <id>12326</id>
    <redirect title="Template:cpp/types/dsc is polymorphic" />
    <revision>
      <id>60317</id>
      <timestamp>2013-06-01T06:47:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is polymorphic]] to [[Template:cpp/types/dsc is polymorphic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/dsc is polymorphic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is reference</title>
    <ns>10</ns>
    <id>12327</id>
    <redirect title="Template:cpp/types/dsc is reference" />
    <revision>
      <id>60319</id>
      <timestamp>2013-06-01T06:47:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is reference]] to [[Template:cpp/types/dsc is reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/types/dsc is reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is rvalue reference</title>
    <ns>10</ns>
    <id>12328</id>
    <redirect title="Template:cpp/types/dsc is rvalue reference" />
    <revision>
      <id>60321</id>
      <timestamp>2013-06-01T06:47:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is rvalue reference]] to [[Template:cpp/types/dsc is rvalue reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/types/dsc is rvalue reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is same</title>
    <ns>10</ns>
    <id>12329</id>
    <redirect title="Template:cpp/types/dsc is same" />
    <revision>
      <id>60323</id>
      <timestamp>2013-06-01T06:47:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is same]] to [[Template:cpp/types/dsc is same]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[Template:cpp/types/dsc is same]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is scalar</title>
    <ns>10</ns>
    <id>12330</id>
    <redirect title="Template:cpp/types/dsc is scalar" />
    <revision>
      <id>60325</id>
      <timestamp>2013-06-01T06:47:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is scalar]] to [[Template:cpp/types/dsc is scalar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc is scalar]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is signed</title>
    <ns>10</ns>
    <id>12331</id>
    <redirect title="Template:cpp/types/dsc is signed" />
    <revision>
      <id>60327</id>
      <timestamp>2013-06-01T06:47:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is signed]] to [[Template:cpp/types/dsc is signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc is signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is standard layout</title>
    <ns>10</ns>
    <id>12332</id>
    <redirect title="Template:cpp/types/dsc is standard layout" />
    <revision>
      <id>60329</id>
      <timestamp>2013-06-01T06:47:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is standard layout]] to [[Template:cpp/types/dsc is standard layout]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/dsc is standard layout]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is trivial</title>
    <ns>10</ns>
    <id>12333</id>
    <redirect title="Template:cpp/types/dsc is trivial" />
    <revision>
      <id>60331</id>
      <timestamp>2013-06-01T06:47:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is trivial]] to [[Template:cpp/types/dsc is trivial]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/types/dsc is trivial]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is trivially copyable</title>
    <ns>10</ns>
    <id>12334</id>
    <redirect title="Template:cpp/types/dsc is trivially copyable" />
    <revision>
      <id>60333</id>
      <timestamp>2013-06-01T06:47:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is trivially copyable]] to [[Template:cpp/types/dsc is trivially copyable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/types/dsc is trivially copyable]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is union</title>
    <ns>10</ns>
    <id>12335</id>
    <redirect title="Template:cpp/types/dsc is union" />
    <revision>
      <id>60335</id>
      <timestamp>2013-06-01T06:47:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is union]] to [[Template:cpp/types/dsc is union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc is union]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is unsigned</title>
    <ns>10</ns>
    <id>12336</id>
    <redirect title="Template:cpp/types/dsc is unsigned" />
    <revision>
      <id>60337</id>
      <timestamp>2013-06-01T06:47:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is unsigned]] to [[Template:cpp/types/dsc is unsigned]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is void</title>
    <ns>10</ns>
    <id>12337</id>
    <redirect title="Template:cpp/types/dsc is void" />
    <revision>
      <id>60339</id>
      <timestamp>2013-06-01T06:47:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is void]] to [[Template:cpp/types/dsc is void]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[Template:cpp/types/dsc is void]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list is volatile</title>
    <ns>10</ns>
    <id>12338</id>
    <redirect title="Template:cpp/types/dsc is volatile" />
    <revision>
      <id>60341</id>
      <timestamp>2013-06-01T06:47:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list is volatile]] to [[Template:cpp/types/dsc is volatile]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc is volatile]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list make signed</title>
    <ns>10</ns>
    <id>12339</id>
    <redirect title="Template:cpp/types/dsc make signed" />
    <revision>
      <id>60343</id>
      <timestamp>2013-06-01T06:47:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list make signed]] to [[Template:cpp/types/dsc make signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc make signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list make unsigned</title>
    <ns>10</ns>
    <id>12340</id>
    <redirect title="Template:cpp/types/dsc make unsigned" />
    <revision>
      <id>60345</id>
      <timestamp>2013-06-01T06:47:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list make unsigned]] to [[Template:cpp/types/dsc make unsigned]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc make unsigned]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list max align t</title>
    <ns>10</ns>
    <id>12341</id>
    <redirect title="Template:cpp/types/dsc max align t" />
    <revision>
      <id>60347</id>
      <timestamp>2013-06-01T06:47:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list max align t]] to [[Template:cpp/types/dsc max align t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/types/dsc max align t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list nullptr t</title>
    <ns>10</ns>
    <id>12342</id>
    <redirect title="Template:cpp/types/dsc nullptr t" />
    <revision>
      <id>60349</id>
      <timestamp>2013-06-01T06:47:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list nullptr t]] to [[Template:cpp/types/dsc nullptr t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc nullptr t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list numeric limits</title>
    <ns>10</ns>
    <id>12343</id>
    <redirect title="Template:cpp/types/dsc numeric limits" />
    <revision>
      <id>60351</id>
      <timestamp>2013-06-01T06:47:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list numeric limits]] to [[Template:cpp/types/dsc numeric limits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/dsc numeric limits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list offsetof</title>
    <ns>10</ns>
    <id>12344</id>
    <redirect title="Template:cpp/types/dsc offsetof" />
    <revision>
      <id>60353</id>
      <timestamp>2013-06-01T06:47:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list offsetof]] to [[Template:cpp/types/dsc offsetof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/types/dsc offsetof]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list ptrdiff t</title>
    <ns>10</ns>
    <id>12345</id>
    <redirect title="Template:cpp/types/dsc ptrdiff t" />
    <revision>
      <id>60355</id>
      <timestamp>2013-06-01T06:47:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list ptrdiff t]] to [[Template:cpp/types/dsc ptrdiff t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc ptrdiff t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list rank</title>
    <ns>10</ns>
    <id>12346</id>
    <redirect title="Template:cpp/types/dsc rank" />
    <revision>
      <id>60357</id>
      <timestamp>2013-06-01T06:47:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list rank]] to [[Template:cpp/types/dsc rank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[Template:cpp/types/dsc rank]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list remove all extents</title>
    <ns>10</ns>
    <id>12347</id>
    <redirect title="Template:cpp/types/dsc remove all extents" />
    <revision>
      <id>60359</id>
      <timestamp>2013-06-01T06:47:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list remove all extents]] to [[Template:cpp/types/dsc remove all extents]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/dsc remove all extents]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list remove cv</title>
    <ns>10</ns>
    <id>12348</id>
    <redirect title="Template:cpp/types/dsc remove cv" />
    <revision>
      <id>60361</id>
      <timestamp>2013-06-01T06:47:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list remove cv]] to [[Template:cpp/types/dsc remove cv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc remove cv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list remove extent</title>
    <ns>10</ns>
    <id>12349</id>
    <redirect title="Template:cpp/types/dsc remove extent" />
    <revision>
      <id>60363</id>
      <timestamp>2013-06-01T06:47:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list remove extent]] to [[Template:cpp/types/dsc remove extent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/types/dsc remove extent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list remove pointer</title>
    <ns>10</ns>
    <id>12350</id>
    <redirect title="Template:cpp/types/dsc remove pointer" />
    <revision>
      <id>60365</id>
      <timestamp>2013-06-01T06:47:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list remove pointer]] to [[Template:cpp/types/dsc remove pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/dsc remove pointer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list remove reference</title>
    <ns>10</ns>
    <id>12351</id>
    <redirect title="Template:cpp/types/dsc remove reference" />
    <revision>
      <id>60367</id>
      <timestamp>2013-06-01T06:47:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list remove reference]] to [[Template:cpp/types/dsc remove reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/types/dsc remove reference]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list result of</title>
    <ns>10</ns>
    <id>12352</id>
    <redirect title="Template:cpp/types/dsc result of" />
    <revision>
      <id>60369</id>
      <timestamp>2013-06-01T06:47:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list result of]] to [[Template:cpp/types/dsc result of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc result of]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list size t</title>
    <ns>10</ns>
    <id>12353</id>
    <redirect title="Template:cpp/types/dsc size t" />
    <revision>
      <id>60371</id>
      <timestamp>2013-06-01T06:47:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list size t]] to [[Template:cpp/types/dsc size t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/types/dsc size t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list type index</title>
    <ns>10</ns>
    <id>12354</id>
    <redirect title="Template:cpp/types/dsc type index" />
    <revision>
      <id>60373</id>
      <timestamp>2013-06-01T06:47:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list type index]] to [[Template:cpp/types/dsc type index]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/types/dsc type index]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list type info</title>
    <ns>10</ns>
    <id>12355</id>
    <redirect title="Template:cpp/types/dsc type info" />
    <revision>
      <id>60375</id>
      <timestamp>2013-06-01T06:47:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list type info]] to [[Template:cpp/types/dsc type info]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/types/dsc type info]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dcl list underlying type</title>
    <ns>10</ns>
    <id>12356</id>
    <redirect title="Template:cpp/types/dsc underlying type" />
    <revision>
      <id>60377</id>
      <timestamp>2013-06-01T06:47:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/dcl list underlying type]] to [[Template:cpp/types/dsc underlying type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/dsc underlying type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc NULL</title>
    <ns>10</ns>
    <id>2873</id>
    <revision>
      <id>60224</id>
      <parentid>55380</parentid>
      <timestamp>2013-06-01T06:46:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list NULL]] to [[Template:cpp/types/dsc NULL]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="83">{{dsc macro const | cpp/types/NULL | implementation-defined null pointer constant}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc add cv</title>
    <ns>10</ns>
    <id>3234</id>
    <revision>
      <id>60226</id>
      <parentid>55383</parentid>
      <timestamp>2013-06-01T06:46:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list add cv]] to [[Template:cpp/types/dsc add cv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="206">{{dsc tclass | cpp/types/add_cv | title=add_cv&lt;br&gt;add_const&lt;br&gt;add_volatile | adds {{c|const}} or/and {{c|volatile}} specifiers to the given type | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc add pointer</title>
    <ns>10</ns>
    <id>3238</id>
    <revision>
      <id>60228</id>
      <parentid>55384</parentid>
      <timestamp>2013-06-01T06:46:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list add pointer]] to [[Template:cpp/types/dsc add pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc tclass | cpp/types/add_pointer | adds pointer to the given type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc add reference</title>
    <ns>10</ns>
    <id>3236</id>
    <revision>
      <id>60230</id>
      <parentid>55387</parentid>
      <timestamp>2013-06-01T06:46:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list add reference]] to [[Template:cpp/types/dsc add reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc tclass | cpp/types/add_reference | title=add_lvalue_reference&lt;br&gt;add_rvalue_reference | adds ''lvalue'' or ''rvalue'' reference to the given type | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc aligned storage</title>
    <ns>10</ns>
    <id>3241</id>
    <revision>
      <id>60232</id>
      <parentid>55388</parentid>
      <timestamp>2013-06-01T06:46:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list aligned storage]] to [[Template:cpp/types/dsc aligned storage]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tclass | cpp/types/aligned_storage | defines the type suitable for use as uninitialized storage for types of given size | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc aligned union</title>
    <ns>10</ns>
    <id>3242</id>
    <revision>
      <id>60234</id>
      <parentid>55391</parentid>
      <timestamp>2013-06-01T06:46:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list aligned union]] to [[Template:cpp/types/dsc aligned union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc tclass | cpp/types/aligned_union | defines the type suitable for use as uninitialized storage for all given types | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc alignment of</title>
    <ns>10</ns>
    <id>3230</id>
    <revision>
      <id>60236</id>
      <parentid>55392</parentid>
      <timestamp>2013-06-01T06:46:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list alignment of]] to [[Template:cpp/types/dsc alignment of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc tclass | cpp/types/alignment_of | obtains the type's alignment requirements | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc bad cast</title>
    <ns>10</ns>
    <id>3198</id>
    <revision>
      <id>60238</id>
      <parentid>55393</parentid>
      <timestamp>2013-06-01T06:46:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list bad cast]] to [[Template:cpp/types/dsc bad cast]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc class | cpp/types/bad_cast | exception that is thrown by an invalid {{ltt|cpp/language/dynamic_cast}} expression, i.e. a cast of reference type fails}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc bad typeid</title>
    <ns>10</ns>
    <id>3197</id>
    <revision>
      <id>60240</id>
      <parentid>55394</parentid>
      <timestamp>2013-06-01T06:46:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list bad typeid]] to [[Template:cpp/types/dsc bad typeid]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc class | cpp/types/bad_typeid | exception that is thrown if an argument in a [[cpp/language/typeid | typeid expression]] is null}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc common type</title>
    <ns>10</ns>
    <id>3245</id>
    <revision>
      <id>60242</id>
      <parentid>55397</parentid>
      <timestamp>2013-06-01T06:46:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list common type]] to [[Template:cpp/types/dsc common type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc tclass | cpp/types/common_type | deduces the result type of a mixed-mode arithmetic expression | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc conditional</title>
    <ns>10</ns>
    <id>3244</id>
    <revision>
      <id>60244</id>
      <parentid>55398</parentid>
      <timestamp>2013-06-01T06:46:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list conditional]] to [[Template:cpp/types/dsc conditional]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc tclass | cpp/types/conditional | chooses one type or another based on compile-type boolean | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc decay</title>
    <ns>10</ns>
    <id>3243</id>
    <revision>
      <id>60246</id>
      <parentid>55401</parentid>
      <timestamp>2013-06-01T06:46:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list decay]] to [[Template:cpp/types/dsc decay]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tclass | cpp/types/decay | applies type transformations as when passing a function argument by value | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc enable if</title>
    <ns>10</ns>
    <id>2723</id>
    <revision>
      <id>60248</id>
      <parentid>55404</parentid>
      <timestamp>2013-06-01T06:46:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list enable if]] to [[Template:cpp/types/dsc enable if]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc tclass | cpp/types/enable_if | hides a function overload or template specialization based on compile-time boolean | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc extent</title>
    <ns>10</ns>
    <id>2727</id>
    <revision>
      <id>60250</id>
      <parentid>55405</parentid>
      <timestamp>2013-06-01T06:46:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list extent]] to [[Template:cpp/types/dsc extent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc tclass | cpp/types/extent | obtains the size of an array type along a specified dimension | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc has virtual destructor</title>
    <ns>10</ns>
    <id>3229</id>
    <revision>
      <id>60252</id>
      <parentid>55406</parentid>
      <timestamp>2013-06-01T06:46:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list has virtual destructor]] to [[Template:cpp/types/dsc has virtual destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tclass | cpp/types/has_virtual_destructor | checks if a type has a virtual destructor | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc integral constant</title>
    <ns>10</ns>
    <id>2762</id>
    <revision>
      <id>60254</id>
      <parentid>55409</parentid>
      <timestamp>2013-06-01T06:46:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list integral constant]] to [[Template:cpp/types/dsc integral constant]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc tclass | cpp/types/integral_constant | compile-time constant of specified type with specified value  | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is abstract</title>
    <ns>10</ns>
    <id>3208</id>
    <revision>
      <id>60256</id>
      <parentid>55410</parentid>
      <timestamp>2013-06-01T06:46:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is abstract]] to [[Template:cpp/types/dsc is abstract]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc tclass | cpp/types/is_abstract | checks if a type is abstract class type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is arithmetic</title>
    <ns>10</ns>
    <id>3160</id>
    <revision>
      <id>60258</id>
      <parentid>55415</parentid>
      <timestamp>2013-06-01T06:46:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is arithmetic]] to [[Template:cpp/types/dsc is arithmetic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc tclass | cpp/types/is_arithmetic | checks if a type is arithmetic type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is array</title>
    <ns>10</ns>
    <id>2728</id>
    <revision>
      <id>60260</id>
      <parentid>55420</parentid>
      <timestamp>2013-06-01T06:46:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is array]] to [[Template:cpp/types/dsc is array]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc tclass | cpp/types/is_array | checks if a type is an array type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is assignable</title>
    <ns>10</ns>
    <id>3225</id>
    <revision>
      <id>60262</id>
      <parentid>55427</parentid>
      <timestamp>2013-06-01T06:46:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is assignable]] to [[Template:cpp/types/dsc is assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="242">{{dsc tclass | cpp/types/is_assignable | title=is_assignable&lt;br&gt;is_trivially_assignable&lt;br&gt;is_nothrow_assignable | checks if a type has a assignment operator for a specific argument | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is base of</title>
    <ns>10</ns>
    <id>3231</id>
    <revision>
      <id>60264</id>
      <parentid>55428</parentid>
      <timestamp>2013-06-01T06:46:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is base of]] to [[Template:cpp/types/dsc is base of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tclass | cpp/types/is_base_of | checks if a type is derived from the other type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is class</title>
    <ns>10</ns>
    <id>3149</id>
    <revision>
      <id>60266</id>
      <parentid>55429</parentid>
      <timestamp>2013-06-01T06:46:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is class]] to [[Template:cpp/types/dsc is class]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc tclass | cpp/types/is_class | checks if a type is a class type (but not union type) | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is compound</title>
    <ns>10</ns>
    <id>3163</id>
    <revision>
      <id>60268</id>
      <parentid>55432</parentid>
      <timestamp>2013-06-01T06:46:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is compound]] to [[Template:cpp/types/dsc is compound]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/types/is_compound | checks if a type is compound type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is const</title>
    <ns>10</ns>
    <id>3199</id>
    <revision>
      <id>60270</id>
      <parentid>55433</parentid>
      <timestamp>2013-06-01T06:46:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is const]] to [[Template:cpp/types/dsc is const]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc tclass | cpp/types/is_const | checks if a type is const-qualified | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is constructible</title>
    <ns>10</ns>
    <id>3221</id>
    <revision>
      <id>60272</id>
      <parentid>55434</parentid>
      <timestamp>2013-06-01T06:46:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is constructible]] to [[Template:cpp/types/dsc is constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="245">{{dsc tclass | cpp/types/is_constructible | title=is_constructible&lt;br&gt;is_trivially_constructible&lt;br&gt;is_nothrow_constructible | checks if a type has a constructor for specific arguments | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is convertible</title>
    <ns>10</ns>
    <id>3232</id>
    <revision>
      <id>60274</id>
      <parentid>55435</parentid>
      <timestamp>2013-06-01T06:46:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is convertible]] to [[Template:cpp/types/dsc is convertible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc tclass | cpp/types/is_convertible | checks if a type can be converted to the other type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is copy assignable</title>
    <ns>10</ns>
    <id>3226</id>
    <revision>
      <id>60276</id>
      <parentid>55438</parentid>
      <timestamp>2013-06-01T06:46:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is copy assignable]] to [[Template:cpp/types/dsc is copy assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="243">{{dsc tclass | cpp/types/is_copy_assignable | title=is_copy_assignable&lt;br&gt;is_trivially_copy_assignable&lt;br&gt;is_nothrow_copy_assignable | checks if a type has a copy assignment operator | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is copy constructible</title>
    <ns>10</ns>
    <id>3223</id>
    <revision>
      <id>60278</id>
      <parentid>55441</parentid>
      <timestamp>2013-06-01T06:46:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is copy constructible]] to [[Template:cpp/types/dsc is copy constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="247">{{dsc tclass | cpp/types/is_copy_constructible | title=is_copy_constructible&lt;br&gt;is_trivially_copy_constructible&lt;br&gt;is_nothrow_copy_constructible | checks if a type has a copy constructor | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is default constructible</title>
    <ns>10</ns>
    <id>3222</id>
    <revision>
      <id>60280</id>
      <parentid>55442</parentid>
      <timestamp>2013-06-01T06:46:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is default constructible]] to [[Template:cpp/types/dsc is default constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="262">{{dsc tclass | cpp/types/is_default_constructible | title=is_default_constructible&lt;br&gt;is_trivially_default_constructible&lt;br&gt;is_nothrow_default_constructible | checks if a type has a default constructor | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is destructible</title>
    <ns>10</ns>
    <id>3228</id>
    <revision>
      <id>60282</id>
      <parentid>55443</parentid>
      <timestamp>2013-06-01T06:46:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is destructible]] to [[Template:cpp/types/dsc is destructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="229">{{dsc tclass | cpp/types/is_destructible | title=is_destructible&lt;br&gt;is_trivially_destructible&lt;br&gt;is_nothrow_destructible | checks if a type has a non-deleted destructor | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is empty</title>
    <ns>10</ns>
    <id>3206</id>
    <revision>
      <id>60284</id>
      <parentid>55444</parentid>
      <timestamp>2013-06-01T06:46:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is empty]] to [[Template:cpp/types/dsc is empty]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc tclass | cpp/types/is_empty | checks if a type is class (but not union) type and has no data | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is enum</title>
    <ns>10</ns>
    <id>3147</id>
    <revision>
      <id>60286</id>
      <parentid>55447</parentid>
      <timestamp>2013-06-01T06:46:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is enum]] to [[Template:cpp/types/dsc is enum]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tclass | cpp/types/is_enum | checks if a type is an enumeration type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is final</title>
    <ns>10</ns>
    <id>13169</id>
    <revision>
      <id>67836</id>
      <timestamp>2014-03-02T17:46:06Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>LWG 2112, accepted in Issaquah</comment>
      <text xml:space="preserve" bytes="99">{{dsc tclass | cpp/types/is_final | checks if a type is a final class type | notes={{mark c++14}}}}</text>
      <sha1>sgj7bp6l4aldebh6t8mqbtvwa6zu2mq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is floating point</title>
    <ns>10</ns>
    <id>3154</id>
    <revision>
      <id>60288</id>
      <parentid>55448</parentid>
      <timestamp>2013-06-01T06:46:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is floating point]] to [[Template:cpp/types/dsc is floating point]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc tclass | cpp/types/is_floating_point | checks if a type is floating-point type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is function</title>
    <ns>10</ns>
    <id>3150</id>
    <revision>
      <id>60290</id>
      <parentid>55451</parentid>
      <timestamp>2013-06-01T06:46:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is function]] to [[Template:cpp/types/dsc is function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tclass | cpp/types/is_function | checks if a type is a function type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is fundamental</title>
    <ns>10</ns>
    <id>3161</id>
    <revision>
      <id>60292</id>
      <parentid>55454</parentid>
      <timestamp>2013-06-01T06:46:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is fundamental]] to [[Template:cpp/types/dsc is fundamental]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc tclass | cpp/types/is_fundamental | checks if a type is fundamental type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is integral</title>
    <ns>10</ns>
    <id>3153</id>
    <revision>
      <id>60294</id>
      <parentid>55457</parentid>
      <timestamp>2013-06-01T06:46:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is integral]] to [[Template:cpp/types/dsc is integral]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/types/is_integral | checks if a type is integral type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is literal type</title>
    <ns>10</ns>
    <id>3205</id>
    <revision>
      <id>60296</id>
      <parentid>55458</parentid>
      <timestamp>2013-06-01T06:46:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is literal type]] to [[Template:cpp/types/dsc is literal type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tclass | cpp/types/is_literal_type | checks if a type is literal type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is lvalue reference</title>
    <ns>10</ns>
    <id>3155</id>
    <revision>
      <id>60298</id>
      <parentid>55459</parentid>
      <timestamp>2013-06-01T06:46:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is lvalue reference]] to [[Template:cpp/types/dsc is lvalue reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tclass | cpp/types/is_lvalue_reference | checks if a type is ''lvalue reference'' | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is member function pointer</title>
    <ns>10</ns>
    <id>3158</id>
    <revision>
      <id>60300</id>
      <parentid>55462</parentid>
      <timestamp>2013-06-01T06:46:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is member function pointer]] to [[Template:cpp/types/dsc is member function pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc tclass | cpp/types/is_member_function_pointer | checks if a type is a pointer to a non-static member function | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is member object pointer</title>
    <ns>10</ns>
    <id>3157</id>
    <revision>
      <id>60302</id>
      <parentid>55467</parentid>
      <timestamp>2013-06-01T06:46:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is member object pointer]] to [[Template:cpp/types/dsc is member object pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tclass | cpp/types/is_member_object_pointer | checks if a type is a pointer to a non-static member object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is member pointer</title>
    <ns>10</ns>
    <id>3164</id>
    <revision>
      <id>60304</id>
      <parentid>55472</parentid>
      <timestamp>2013-06-01T06:46:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is member pointer]] to [[Template:cpp/types/dsc is member pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tclass | cpp/types/is_member_pointer | checks if a type is a pointer to a non-static member function or object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is move assignable</title>
    <ns>10</ns>
    <id>3227</id>
    <revision>
      <id>60306</id>
      <parentid>55475</parentid>
      <timestamp>2013-06-01T06:46:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is move assignable]] to [[Template:cpp/types/dsc is move assignable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="243">{{dsc tclass | cpp/types/is_move_assignable | title=is_move_assignable&lt;br&gt;is_trivially_move_assignable&lt;br&gt;is_nothrow_move_assignable | checks if a type has a move assignment operator | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is move constructible</title>
    <ns>10</ns>
    <id>3224</id>
    <revision>
      <id>60308</id>
      <parentid>55476</parentid>
      <timestamp>2013-06-01T06:46:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is move constructible]] to [[Template:cpp/types/dsc is move constructible]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="247">{{dsc tclass | cpp/types/is_move_constructible | title=is_move_constructible&lt;br&gt;is_trivially_move_constructible&lt;br&gt;is_nothrow_move_constructible | checks if a type has a move constructor | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is null pointer</title>
    <ns>10</ns>
    <id>13043</id>
    <revision>
      <id>66208</id>
      <timestamp>2013-11-09T22:48:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">{{dsc tclass | cpp/types/is_null_pointer | checks if a type is {{c|std::nullptr_t}} | notes={{mark c++14}}}}</text>
      <sha1>8nuson0hz4vwab1m6bxfgmn3ockinzv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is object</title>
    <ns>10</ns>
    <id>3151</id>
    <revision>
      <id>60310</id>
      <parentid>55477</parentid>
      <timestamp>2013-06-01T06:46:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is object]] to [[Template:cpp/types/dsc is object]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc tclass | cpp/types/is_object | checks if a type is object type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is pod</title>
    <ns>10</ns>
    <id>3204</id>
    <revision>
      <id>60312</id>
      <parentid>55478</parentid>
      <timestamp>2013-06-01T06:47:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is pod]] to [[Template:cpp/types/dsc is pod]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/types/is_pod | checks if a type is plain-old data (POD) type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is pointer</title>
    <ns>10</ns>
    <id>3146</id>
    <revision>
      <id>60314</id>
      <parentid>55481</parentid>
      <timestamp>2013-06-01T06:47:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is pointer]] to [[Template:cpp/types/dsc is pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/types/is_pointer | checks if a type is a pointer type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is polymorphic</title>
    <ns>10</ns>
    <id>3207</id>
    <revision>
      <id>60316</id>
      <parentid>55484</parentid>
      <timestamp>2013-06-01T06:47:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is polymorphic]] to [[Template:cpp/types/dsc is polymorphic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="109">{{dsc tclass | cpp/types/is_polymorphic | checks if a type is polymorphic class type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is reference</title>
    <ns>10</ns>
    <id>3159</id>
    <revision>
      <id>60318</id>
      <parentid>55485</parentid>
      <timestamp>2013-06-01T06:47:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is reference]] to [[Template:cpp/types/dsc is reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tclass | cpp/types/is_reference | checks if a type is either ''lvalue reference'' or ''rvalue reference'' | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is rvalue reference</title>
    <ns>10</ns>
    <id>3156</id>
    <revision>
      <id>60320</id>
      <parentid>55486</parentid>
      <timestamp>2013-06-01T06:47:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is rvalue reference]] to [[Template:cpp/types/dsc is rvalue reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tclass | cpp/types/is_rvalue_reference | checks if a type is ''rvalue reference'' | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is same</title>
    <ns>10</ns>
    <id>2730</id>
    <revision>
      <id>60322</id>
      <parentid>55489</parentid>
      <timestamp>2013-06-01T06:47:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is same]] to [[Template:cpp/types/dsc is same]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tclass | cpp/types/is_same | checks if two types are the same | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is scalar</title>
    <ns>10</ns>
    <id>3162</id>
    <revision>
      <id>60324</id>
      <parentid>55490</parentid>
      <timestamp>2013-06-01T06:47:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is scalar]] to [[Template:cpp/types/dsc is scalar]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="93">{{dsc tclass | cpp/types/is_scalar | checks if a type is scalar type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is signed</title>
    <ns>10</ns>
    <id>3209</id>
    <revision>
      <id>60326</id>
      <parentid>55491</parentid>
      <timestamp>2013-06-01T06:47:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is signed]] to [[Template:cpp/types/dsc is signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/types/is_signed | checks if a type is signed arithmetic type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is standard layout</title>
    <ns>10</ns>
    <id>3203</id>
    <revision>
      <id>60328</id>
      <parentid>55498</parentid>
      <timestamp>2013-06-01T06:47:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is standard layout]] to [[Template:cpp/types/dsc is standard layout]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc tclass | cpp/types/is_standard_layout | checks if a type is standard-layout type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is trivial</title>
    <ns>10</ns>
    <id>3201</id>
    <revision>
      <id>60330</id>
      <parentid>55503</parentid>
      <timestamp>2013-06-01T06:47:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is trivial]] to [[Template:cpp/types/dsc is trivial]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc tclass | cpp/types/is_trivial | checks if a type is trivial | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is trivially copyable</title>
    <ns>10</ns>
    <id>3202</id>
    <revision>
      <id>60332</id>
      <parentid>55508</parentid>
      <timestamp>2013-06-01T06:47:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is trivially copyable]] to [[Template:cpp/types/dsc is trivially copyable]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tclass | cpp/types/is_trivially_copyable | checks if a type is trivially copyable | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is union</title>
    <ns>10</ns>
    <id>3148</id>
    <revision>
      <id>60334</id>
      <parentid>55509</parentid>
      <timestamp>2013-06-01T06:47:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is union]] to [[Template:cpp/types/dsc is union]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc tclass | cpp/types/is_union | checks if a type is an union type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is unsigned</title>
    <ns>10</ns>
    <id>3210</id>
    <revision>
      <id>60336</id>
      <parentid>55512</parentid>
      <timestamp>2013-06-01T06:47:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is unsigned]] to [[Template:cpp/types/dsc is unsigned]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc tclass | cpp/types/is_unsigned | checks if a type is unsigned arithmetic type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is void</title>
    <ns>10</ns>
    <id>3152</id>
    <revision>
      <id>60338</id>
      <parentid>55513</parentid>
      <timestamp>2013-06-01T06:47:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is void]] to [[Template:cpp/types/dsc is void]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc tclass | cpp/types/is_void | checks if a type is {{c|void}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc is volatile</title>
    <ns>10</ns>
    <id>3200</id>
    <revision>
      <id>60340</id>
      <parentid>55514</parentid>
      <timestamp>2013-06-01T06:47:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list is volatile]] to [[Template:cpp/types/dsc is volatile]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc tclass | cpp/types/is_volatile | checks if a type is volatile-qualified | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc make signed</title>
    <ns>10</ns>
    <id>3239</id>
    <revision>
      <id>60342</id>
      <parentid>55515</parentid>
      <timestamp>2013-06-01T06:47:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list make signed]] to [[Template:cpp/types/dsc make signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tclass | cpp/types/make_signed | makes the given integral type signed | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc make unsigned</title>
    <ns>10</ns>
    <id>3240</id>
    <revision>
      <id>60344</id>
      <parentid>55518</parentid>
      <timestamp>2013-06-01T06:47:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list make unsigned]] to [[Template:cpp/types/dsc make unsigned]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="104">{{dsc tclass | cpp/types/make_unsigned | makes the given integral type unsigned | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc max align t</title>
    <ns>10</ns>
    <id>3195</id>
    <revision>
      <id>60346</id>
      <parentid>55519</parentid>
      <timestamp>2013-06-01T06:47:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list max align t]] to [[Template:cpp/types/dsc max align t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc typedef | cpp/types/max_align_t | POD type with alignment requirement as great as any other scalar type | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc nullptr t</title>
    <ns>10</ns>
    <id>3194</id>
    <revision>
      <id>60348</id>
      <parentid>55524</parentid>
      <timestamp>2013-06-01T06:47:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list nullptr t]] to [[Template:cpp/types/dsc nullptr t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc typedef | cpp/types/nullptr_t | the type of the null pointer literal {{ltt|cpp/language/nullptr | nullptr}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc numeric limits</title>
    <ns>10</ns>
    <id>3220</id>
    <revision>
      <id>60350</id>
      <parentid>55529</parentid>
      <timestamp>2013-06-01T06:47:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list numeric limits]] to [[Template:cpp/types/dsc numeric limits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="119">{{dsc tclass | cpp/types/numeric_limits | provides an interface to query properties of all fundamental numeric types.}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc offsetof</title>
    <ns>10</ns>
    <id>3196</id>
    <revision>
      <id>60352</id>
      <parentid>55532</parentid>
      <timestamp>2013-06-01T06:47:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list offsetof]] to [[Template:cpp/types/dsc offsetof]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc macro fun | cpp/types/offsetof | byte offset from the beginning of a standard-layout type to specified member}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc ptrdiff t</title>
    <ns>10</ns>
    <id>3193</id>
    <revision>
      <id>60354</id>
      <parentid>55535</parentid>
      <timestamp>2013-06-01T06:47:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list ptrdiff t]] to [[Template:cpp/types/dsc ptrdiff t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc typedef | cpp/types/ptrdiff_t | signed integer type returned when subtracting two pointers}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc rank</title>
    <ns>10</ns>
    <id>2726</id>
    <revision>
      <id>60356</id>
      <parentid>55536</parentid>
      <timestamp>2013-06-01T06:47:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list rank]] to [[Template:cpp/types/dsc rank]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc tclass | cpp/types/rank | obtains the number of dimensions of an array type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc remove all extents</title>
    <ns>10</ns>
    <id>2725</id>
    <revision>
      <id>60358</id>
      <parentid>55537</parentid>
      <timestamp>2013-06-01T06:47:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list remove all extents]] to [[Template:cpp/types/dsc remove all extents]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tclass | cpp/types/remove_all_extents | removes all extents from the given array type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc remove cv</title>
    <ns>10</ns>
    <id>3233</id>
    <revision>
      <id>60360</id>
      <parentid>55540</parentid>
      <timestamp>2013-06-01T06:47:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list remove cv]] to [[Template:cpp/types/dsc remove cv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="223">{{dsc tclass | cpp/types/remove_cv | title=remove_cv&lt;br&gt;remove_const&lt;br&gt;remove_volatile | removes {{c|const}} or/and {{c|volatile}} specifiers from the given type | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc remove extent</title>
    <ns>10</ns>
    <id>2724</id>
    <revision>
      <id>60362</id>
      <parentid>55541</parentid>
      <timestamp>2013-06-01T06:47:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list remove extent]] to [[Template:cpp/types/dsc remove extent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc tclass | cpp/types/remove_extent | removes one extent from the given array type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc remove pointer</title>
    <ns>10</ns>
    <id>3237</id>
    <revision>
      <id>60364</id>
      <parentid>55544</parentid>
      <timestamp>2013-06-01T06:47:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list remove pointer]] to [[Template:cpp/types/dsc remove pointer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc tclass | cpp/types/remove_pointer | removes pointer from the given type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc remove reference</title>
    <ns>10</ns>
    <id>3235</id>
    <revision>
      <id>60366</id>
      <parentid>55545</parentid>
      <timestamp>2013-06-01T06:47:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list remove reference]] to [[Template:cpp/types/dsc remove reference]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc tclass | cpp/types/remove_reference | removes reference from the given type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc result of</title>
    <ns>10</ns>
    <id>2722</id>
    <revision>
      <id>60368</id>
      <parentid>55546</parentid>
      <timestamp>2013-06-01T06:47:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list result of]] to [[Template:cpp/types/dsc result of]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc tclass | cpp/types/result_of | deduces the return type of a function call expression | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc size t</title>
    <ns>10</ns>
    <id>3192</id>
    <revision>
      <id>60370</id>
      <parentid>55547</parentid>
      <timestamp>2013-06-01T06:47:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list size t]] to [[Template:cpp/types/dsc size t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc typedef | cpp/types/size_t | unsigned integer type returned by the {{ltt|cpp/language/sizeof | sizeof}} operator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc type index</title>
    <ns>10</ns>
    <id>2744</id>
    <revision>
      <id>60372</id>
      <parentid>55550</parentid>
      <timestamp>2013-06-01T06:47:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list type index]] to [[Template:cpp/types/dsc type index]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="181">{{dsc class | cpp/types/type_index | wrapper around a {{tt|type_info}} object, that can be used as index in associative and unordered associative containers | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc type info</title>
    <ns>10</ns>
    <id>2743</id>
    <revision>
      <id>60374</id>
      <parentid>55551</parentid>
      <timestamp>2013-06-01T06:47:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list type info]] to [[Template:cpp/types/dsc type info]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="185">{{dsc class | cpp/types/type_info | contains some type's information, generated by the implementation.&lt;br&gt; This is the class, returned by the [[cpp/language/typeid | typeid]] operator}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/dsc underlying type</title>
    <ns>10</ns>
    <id>3246</id>
    <revision>
      <id>60376</id>
      <parentid>55552</parentid>
      <timestamp>2013-06-01T06:47:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/dcl list underlying type]] to [[Template:cpp/types/dsc underlying type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tclass | cpp/types/underlying_type | obtains the underlying integer type for a given enumeration type | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/dcl list operator value type</title>
    <ns>10</ns>
    <id>12357</id>
    <redirect title="Template:cpp/types/integral constant/dsc operator value type" />
    <revision>
      <id>60379</id>
      <timestamp>2013-06-01T06:47:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/integral constant/dcl list operator value type]] to [[Template:cpp/types/integral constant/dsc operator value type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">#REDIRECT [[Template:cpp/types/integral constant/dsc operator value type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/dsc operator()</title>
    <ns>10</ns>
    <id>12912</id>
    <revision>
      <id>68214</id>
      <parentid>68213</parentid>
      <timestamp>2014-03-18T04:15:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>reposition c++14</comment>
      <text xml:space="preserve" bytes="169">{{dsc mem fun | cpp/types/integral_constant | title={{mark|constexpr}}operator() |notes={{mark|const noexcept}} | inlinemem=true | returns {{tt|value}} {{mark c++14}} }}</text>
      <sha1>607s34h99bddzo6o8r4euz99jtkvwek</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/dsc operator value type</title>
    <ns>10</ns>
    <id>9933</id>
    <revision>
      <id>68212</id>
      <parentid>60378</parentid>
      <timestamp>2014-03-18T04:14:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>lwg 2346 and const/constexpr too</comment>
      <text xml:space="preserve" bytes="203">{{dsc mem fun | cpp/types/integral_constant | title={{mark|constexpr}}operator value_type |notes={{mark|const noexcept}}| inlinemem=true | converts the object to {{tt|value_type}}, returns {{tt|value}}}}</text>
      <sha1>kzi7bhgvgalm55bbxpns6dmol63uhxv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/inherit</title>
    <ns>10</ns>
    <id>3213</id>
    <revision>
      <id>55556</id>
      <parentid>32727</parentid>
      <timestamp>2013-06-01T05:24:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="565">{{inherited|[[cpp/types/integral_constant | {{small|std::}}integral_constant]]|
===Member constants===
{{dsc begin}}
{{dsc mem sconst | value | {{c|true}} if {{{1|}}}, {{c|false}} otherwise | nolink=true}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator bool | nolink=true | converts the object to {{c|bool}}, returns {{tt|value}} }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|bool}} }}
{{dsc | {{tt|type}} | {{c|std::integral_constant&lt;bool, value&gt;}} }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/inherit2</title>
    <ns>10</ns>
    <id>3247</id>
    <revision>
      <id>55559</id>
      <parentid>32726</parentid>
      <timestamp>2013-06-01T05:24:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="544">{{inherited|[[cpp/types/integral_constant | {{small|std::}}integral_constant]]|
===Member constants===
{{dsc begin}}
{{dsc mem sconst | value | {{{1|}}}  | nolink=true}}
{{dsc end}}

===Member functions===
{{dsc begin}}
{{dsc mem fun | operator {{{2|}}}| nolink=true | converts the object to {{c|{{{2|}}}}}, returns {{tt|value}} }}
{{dsc end}}

===Member types===
{{dsc begin}}
{{dsc hitem | Type | Definition}}
{{dsc | {{tt|value_type}} | {{tt|{{{2|}}}}} }}
{{dsc | {{tt|type}} | {{c|std::integral_constant&lt;{{{2|}}}, value&gt;}} }}
{{dsc end}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/integral constant/title</title>
    <ns>10</ns>
    <id>8575</id>
    <revision>
      <id>31736</id>
      <timestamp>2012-06-06T20:45:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="114">&lt;onlyinclude&gt;{{cpp/title | n=integral_constant::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/navbar</title>
    <ns>10</ns>
    <id>2176</id>
    <revision>
      <id>40043</id>
      <parentid>36032</parentid>
      <timestamp>2012-09-28T20:20:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="227">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/navbar content</title>
    <ns>10</ns>
    <id>2382</id>
    <revision>
      <id>67837</id>
      <parentid>66210</parentid>
      <timestamp>2014-03-02T17:46:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>is_final</comment>
      <text xml:space="preserve" bytes="6667">&lt;div style=&quot;display:inline-block; vertical-align: top;&quot;&gt;
{{nv begin}}

{{nv h1 | Basic types}}
{{nv | [[cpp/language/types | Fundamental types]] }}
{{nv | [[cpp/types/integer | Fixed width integer types]] {{mark c++11}}}}

{{nv col begin}}
{{nv ln | cpp/types/ptrdiff_t}}
{{nv ln | cpp/types/size_t}}
{{nv ln | cpp/types/max_align_t | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/nullptr_t | notes={{mark c++11}} }}
{{nv ln | cpp/types/offsetof}}
{{nv ln | cpp/types/NULL}}
{{nv col end}}

{{nv h1 | Numeric limits}}
{{nv ln | cpp/types/numeric_limits}}
{{nv | [[cpp/types/climits|C numeric limits interface]]}}

{{nv h1 | Runtime type information}}
{{nv col begin}}
{{nv ln | cpp/types/type_info}}
{{nv ln | cpp/types/type_index | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/bad_typeid}}
{{nv ln | cpp/types/bad_cast}}
{{nv col end}}

{{nv h1 | Type traits}}
{{nv h2 | Primary type categories}}
{{nv col begin}}
{{nv ln | cpp/types/is_void | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_null_pointer | notes={{mark c++14}}}}
{{nv ln | cpp/types/is_array | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_pointer | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_enum | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_union | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_class | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_function | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/is_object | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_scalar | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_compound | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_integral | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_floating_point | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_fundamental | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_arithmetic | notes={{mark c++11}}}}
{{nv col end}}
{{nv ln | cpp/types/is_reference | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_lvalue_reference | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_rvalue_reference | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_member_pointer | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_member_object_pointer | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_member_function_pointer | notes={{mark c++11}}}}

{{nv end}}
{{nv begin}}

{{nv h2 | Type properties}}
{{nv col begin}}
{{nv ln | cpp/types/is_const | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_volatile | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_pod | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_empty | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_polymorphic | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_final | notes={{mark c++14}}}}
{{nv ln | cpp/types/is_abstract | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/is_trivial | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_trivially_copyable | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_standard_layout | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_literal_type | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_signed | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_unsigned | notes={{mark c++11}}}}
{{nv col end}}
{{nv end}}
&lt;/div&gt;
&lt;div style=&quot;display:inline-block; vertical-align: top;&quot;&gt;
{{nv begin}}
{{nv h2 | Supported operations}}
{{nv ln | cpp/types/is_constructible | is_constructible | is_trivially_constructible | is_nothrow_constructible | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_default_constructible | is_default_constructible | is_trivially_default_constructible | is_nothrow_default_constructible | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_copy_constructible | is_copy_constructible | is_trivially_copy_constructible | is_nothrow_copy_constructible | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_move_constructible | is_move_constructible | is_trivially_move_constructible | is_nothrow_move_constructible | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_assignable | is_assignable | is_trivially_assignable | is_nothrow_assignable | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_copy_assignable | is_copy_assignable | is_trivially_copy_assignable | is_nothrow_copy_assignable | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_move_assignable | is_move_assignable | is_trivially_move_assignable | is_nothrow_move_assignable | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/is_destructible | is_destructible | is_trivially_destructible | is_nothrow_destructible | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/has_virtual_destructor | notes={{mark c++11}}}}

{{nv h2 | Relationships and property queries}}
{{nv col begin}}
{{nv ln | cpp/types/is_same | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_base_of | notes={{mark c++11}}}}
{{nv ln | cpp/types/is_convertible | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/alignment_of | notes={{mark c++11}}}}
{{nv ln | cpp/types/rank | notes={{mark c++11}}}}
{{nv ln | cpp/types/extent | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Type modifications}}
{{nv col begin}}
{{nv ln | cpp/types/remove_cv | remove_cv | remove_const | remove_volatile | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/add_cv | add_cv | add_const | add_volatile | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/make_signed | notes={{mark c++11}}}}
{{nv ln | cpp/types/make_unsigned | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/remove_reference | notes={{mark c++11}}}}
{{nv ln | cpp/types/add_reference | add_lvalue_reference | add_rvalue_reference | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}
{{nv ln | cpp/types/remove_pointer | notes={{mark c++11}}}}
{{nv ln | cpp/types/add_pointer | notes={{mark c++11}}}}
{{nv ln | cpp/types/remove_extent | notes={{mark c++11}}}}
{{nv ln | cpp/types/remove_all_extents | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Type transformations}}
{{nv col begin}}
{{nv ln | cpp/types/aligned_storage | notes={{mark c++11}}}}
{{nv ln | cpp/types/aligned_union | notes={{mark c++11}}}}
{{nv ln | cpp/types/decay | notes={{mark c++11}}}}
{{nv ln | cpp/types/enable_if | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/types/conditional | notes={{mark c++11}}}}
{{nv ln | cpp/types/common_type | notes={{mark c++11}}}}
{{nv ln | cpp/types/underlying_type | notes={{mark c++11}}}}
{{nv ln | cpp/types/result_of | notes={{mark c++11}}}}
{{nv col end}}

{{nv h2 | Type trait constants}}
{{nv ln | cpp/types/integral_constant | notes={{mark c++11}}}}
{{nv end}}
&lt;/div&gt;</text>
      <sha1>oonhgu5ltgtcsgm9tlhvddqo0cz8xep</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/navbar heading</title>
    <ns>10</ns>
    <id>2173</id>
    <revision>
      <id>35968</id>
      <parentid>4906</parentid>
      <timestamp>2012-06-15T22:35:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/sidebar heading]] to [[Template:cpp/types/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="28">[[cpp/types | Type support]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list denorm min</title>
    <ns>10</ns>
    <id>12358</id>
    <redirect title="Template:cpp/types/numeric limits/dsc denorm min" />
    <revision>
      <id>60381</id>
      <timestamp>2013-06-01T06:47:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list denorm min]] to [[Template:cpp/types/numeric limits/dsc denorm min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/types/numeric limits/dsc denorm min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list digits</title>
    <ns>10</ns>
    <id>12359</id>
    <redirect title="Template:cpp/types/numeric limits/dsc digits" />
    <revision>
      <id>60383</id>
      <timestamp>2013-06-01T06:47:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list digits]] to [[Template:cpp/types/numeric limits/dsc digits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/types/numeric limits/dsc digits]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list digits10</title>
    <ns>10</ns>
    <id>12360</id>
    <redirect title="Template:cpp/types/numeric limits/dsc digits10" />
    <revision>
      <id>60385</id>
      <timestamp>2013-06-01T06:47:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list digits10]] to [[Template:cpp/types/numeric limits/dsc digits10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/types/numeric limits/dsc digits10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list epsilon</title>
    <ns>10</ns>
    <id>12361</id>
    <redirect title="Template:cpp/types/numeric limits/dsc epsilon" />
    <revision>
      <id>60387</id>
      <timestamp>2013-06-01T06:47:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list epsilon]] to [[Template:cpp/types/numeric limits/dsc epsilon]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/types/numeric limits/dsc epsilon]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list float denorm style</title>
    <ns>10</ns>
    <id>12362</id>
    <redirect title="Template:cpp/types/numeric limits/dsc float denorm style" />
    <revision>
      <id>60389</id>
      <timestamp>2013-06-01T06:47:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list float denorm style]] to [[Template:cpp/types/numeric limits/dsc float denorm style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">#REDIRECT [[Template:cpp/types/numeric limits/dsc float denorm style]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list float round style</title>
    <ns>10</ns>
    <id>12363</id>
    <redirect title="Template:cpp/types/numeric limits/dsc float round style" />
    <revision>
      <id>60391</id>
      <timestamp>2013-06-01T06:47:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list float round style]] to [[Template:cpp/types/numeric limits/dsc float round style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/types/numeric limits/dsc float round style]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list has denorm</title>
    <ns>10</ns>
    <id>12364</id>
    <redirect title="Template:cpp/types/numeric limits/dsc has denorm" />
    <revision>
      <id>60393</id>
      <timestamp>2013-06-01T06:47:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has denorm]] to [[Template:cpp/types/numeric limits/dsc has denorm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/types/numeric limits/dsc has denorm]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list has denorm loss</title>
    <ns>10</ns>
    <id>12365</id>
    <redirect title="Template:cpp/types/numeric limits/dsc has denorm loss" />
    <revision>
      <id>60395</id>
      <timestamp>2013-06-01T06:47:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has denorm loss]] to [[Template:cpp/types/numeric limits/dsc has denorm loss]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/types/numeric limits/dsc has denorm loss]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list has infinity</title>
    <ns>10</ns>
    <id>12366</id>
    <redirect title="Template:cpp/types/numeric limits/dsc has infinity" />
    <revision>
      <id>60397</id>
      <timestamp>2013-06-01T06:47:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has infinity]] to [[Template:cpp/types/numeric limits/dsc has infinity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/types/numeric limits/dsc has infinity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list has quiet NaN</title>
    <ns>10</ns>
    <id>12367</id>
    <redirect title="Template:cpp/types/numeric limits/dsc has quiet NaN" />
    <revision>
      <id>60399</id>
      <timestamp>2013-06-01T06:47:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has quiet NaN]] to [[Template:cpp/types/numeric limits/dsc has quiet NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/types/numeric limits/dsc has quiet NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list has signaling NaN</title>
    <ns>10</ns>
    <id>12368</id>
    <redirect title="Template:cpp/types/numeric limits/dsc has signaling NaN" />
    <revision>
      <id>60401</id>
      <timestamp>2013-06-01T06:47:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has signaling NaN]] to [[Template:cpp/types/numeric limits/dsc has signaling NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/types/numeric limits/dsc has signaling NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list infinity</title>
    <ns>10</ns>
    <id>12369</id>
    <redirect title="Template:cpp/types/numeric limits/dsc infinity" />
    <revision>
      <id>60403</id>
      <timestamp>2013-06-01T06:47:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list infinity]] to [[Template:cpp/types/numeric limits/dsc infinity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/types/numeric limits/dsc infinity]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is bounded</title>
    <ns>10</ns>
    <id>12370</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is bounded" />
    <revision>
      <id>60405</id>
      <timestamp>2013-06-01T06:48:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is bounded]] to [[Template:cpp/types/numeric limits/dsc is bounded]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/types/numeric limits/dsc is bounded]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is exact</title>
    <ns>10</ns>
    <id>12371</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is exact" />
    <revision>
      <id>60407</id>
      <timestamp>2013-06-01T06:48:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is exact]] to [[Template:cpp/types/numeric limits/dsc is exact]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/types/numeric limits/dsc is exact]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is iec559</title>
    <ns>10</ns>
    <id>12372</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is iec559" />
    <revision>
      <id>60409</id>
      <timestamp>2013-06-01T06:48:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is iec559]] to [[Template:cpp/types/numeric limits/dsc is iec559]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/numeric limits/dsc is iec559]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is integer</title>
    <ns>10</ns>
    <id>12373</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is integer" />
    <revision>
      <id>60411</id>
      <timestamp>2013-06-01T06:48:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is integer]] to [[Template:cpp/types/numeric limits/dsc is integer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/types/numeric limits/dsc is integer]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is modulo</title>
    <ns>10</ns>
    <id>12374</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is modulo" />
    <revision>
      <id>60413</id>
      <timestamp>2013-06-01T06:48:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is modulo]] to [[Template:cpp/types/numeric limits/dsc is modulo]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/numeric limits/dsc is modulo]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is signed</title>
    <ns>10</ns>
    <id>12375</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is signed" />
    <revision>
      <id>60415</id>
      <timestamp>2013-06-01T06:48:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is signed]] to [[Template:cpp/types/numeric limits/dsc is signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/numeric limits/dsc is signed]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list is specialized</title>
    <ns>10</ns>
    <id>12376</id>
    <redirect title="Template:cpp/types/numeric limits/dsc is specialized" />
    <revision>
      <id>60417</id>
      <timestamp>2013-06-01T06:48:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is specialized]] to [[Template:cpp/types/numeric limits/dsc is specialized]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">#REDIRECT [[Template:cpp/types/numeric limits/dsc is specialized]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list lowest</title>
    <ns>10</ns>
    <id>12377</id>
    <redirect title="Template:cpp/types/numeric limits/dsc lowest" />
    <revision>
      <id>60419</id>
      <timestamp>2013-06-01T06:48:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list lowest]] to [[Template:cpp/types/numeric limits/dsc lowest]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/types/numeric limits/dsc lowest]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list max</title>
    <ns>10</ns>
    <id>12378</id>
    <redirect title="Template:cpp/types/numeric limits/dsc max" />
    <revision>
      <id>60421</id>
      <timestamp>2013-06-01T06:48:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max]] to [[Template:cpp/types/numeric limits/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/numeric limits/dsc max]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list max digits10</title>
    <ns>10</ns>
    <id>12379</id>
    <redirect title="Template:cpp/types/numeric limits/dsc max digits10" />
    <revision>
      <id>60423</id>
      <timestamp>2013-06-01T06:48:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max digits10]] to [[Template:cpp/types/numeric limits/dsc max digits10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/types/numeric limits/dsc max digits10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list max exponent</title>
    <ns>10</ns>
    <id>12380</id>
    <redirect title="Template:cpp/types/numeric limits/dsc max exponent" />
    <revision>
      <id>60425</id>
      <timestamp>2013-06-01T06:48:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max exponent]] to [[Template:cpp/types/numeric limits/dsc max exponent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/types/numeric limits/dsc max exponent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list max exponent10</title>
    <ns>10</ns>
    <id>12381</id>
    <redirect title="Template:cpp/types/numeric limits/dsc max exponent10" />
    <revision>
      <id>60427</id>
      <timestamp>2013-06-01T06:48:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max exponent10]] to [[Template:cpp/types/numeric limits/dsc max exponent10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">#REDIRECT [[Template:cpp/types/numeric limits/dsc max exponent10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list min</title>
    <ns>10</ns>
    <id>12382</id>
    <redirect title="Template:cpp/types/numeric limits/dsc min" />
    <revision>
      <id>60429</id>
      <timestamp>2013-06-01T06:48:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min]] to [[Template:cpp/types/numeric limits/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/types/numeric limits/dsc min]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list min exponent</title>
    <ns>10</ns>
    <id>12383</id>
    <redirect title="Template:cpp/types/numeric limits/dsc min exponent" />
    <revision>
      <id>60431</id>
      <timestamp>2013-06-01T06:48:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min exponent]] to [[Template:cpp/types/numeric limits/dsc min exponent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/types/numeric limits/dsc min exponent]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list min exponent10</title>
    <ns>10</ns>
    <id>12384</id>
    <redirect title="Template:cpp/types/numeric limits/dsc min exponent10" />
    <revision>
      <id>60433</id>
      <timestamp>2013-06-01T06:48:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min exponent10]] to [[Template:cpp/types/numeric limits/dsc min exponent10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">#REDIRECT [[Template:cpp/types/numeric limits/dsc min exponent10]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list quiet NaN</title>
    <ns>10</ns>
    <id>12385</id>
    <redirect title="Template:cpp/types/numeric limits/dsc quiet NaN" />
    <revision>
      <id>60435</id>
      <timestamp>2013-06-01T06:48:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list quiet NaN]] to [[Template:cpp/types/numeric limits/dsc quiet NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/types/numeric limits/dsc quiet NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list radix</title>
    <ns>10</ns>
    <id>12386</id>
    <redirect title="Template:cpp/types/numeric limits/dsc radix" />
    <revision>
      <id>60437</id>
      <timestamp>2013-06-01T06:48:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list radix]] to [[Template:cpp/types/numeric limits/dsc radix]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/types/numeric limits/dsc radix]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list round error</title>
    <ns>10</ns>
    <id>12387</id>
    <redirect title="Template:cpp/types/numeric limits/dsc round error" />
    <revision>
      <id>60439</id>
      <timestamp>2013-06-01T06:48:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list round error]] to [[Template:cpp/types/numeric limits/dsc round error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/types/numeric limits/dsc round error]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list round style</title>
    <ns>10</ns>
    <id>12388</id>
    <redirect title="Template:cpp/types/numeric limits/dsc round style" />
    <revision>
      <id>60441</id>
      <timestamp>2013-06-01T06:48:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list round style]] to [[Template:cpp/types/numeric limits/dsc round style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/types/numeric limits/dsc round style]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list signaling NaN</title>
    <ns>10</ns>
    <id>12389</id>
    <redirect title="Template:cpp/types/numeric limits/dsc signaling NaN" />
    <revision>
      <id>60443</id>
      <timestamp>2013-06-01T06:48:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list signaling NaN]] to [[Template:cpp/types/numeric limits/dsc signaling NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/types/numeric limits/dsc signaling NaN]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list tinyness before</title>
    <ns>10</ns>
    <id>12390</id>
    <redirect title="Template:cpp/types/numeric limits/dsc tinyness before" />
    <revision>
      <id>60445</id>
      <timestamp>2013-06-01T06:48:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list tinyness before]] to [[Template:cpp/types/numeric limits/dsc tinyness before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/types/numeric limits/dsc tinyness before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dcl list traps</title>
    <ns>10</ns>
    <id>12391</id>
    <redirect title="Template:cpp/types/numeric limits/dsc traps" />
    <revision>
      <id>60447</id>
      <timestamp>2013-06-01T06:48:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list traps]] to [[Template:cpp/types/numeric limits/dsc traps]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/types/numeric limits/dsc traps]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc denorm min</title>
    <ns>10</ns>
    <id>3025</id>
    <revision>
      <id>60380</id>
      <parentid>55565</parentid>
      <timestamp>2013-06-01T06:47:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list denorm min]] to [[Template:cpp/types/numeric limits/dsc denorm min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem sfun | cpp/types/numeric_limits/denorm_min | returns the smallest positive subnormal value of the given floating-point type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc digits</title>
    <ns>10</ns>
    <id>3065</id>
    <revision>
      <id>60382</id>
      <parentid>55566</parentid>
      <timestamp>2013-06-01T06:47:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list digits]] to [[Template:cpp/types/numeric limits/dsc digits]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem sconst | cpp/types/numeric_limits/digits | number of {{tt|radix}} digits that can be represented without change }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc digits10</title>
    <ns>10</ns>
    <id>3066</id>
    <revision>
      <id>60384</id>
      <parentid>55569</parentid>
      <timestamp>2013-06-01T06:47:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list digits10]] to [[Template:cpp/types/numeric limits/dsc digits10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem sconst | cpp/types/numeric_limits/digits10 | number of decimal digits that can be represented without change}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc epsilon</title>
    <ns>10</ns>
    <id>3020</id>
    <revision>
      <id>60386</id>
      <parentid>55572</parentid>
      <timestamp>2013-06-01T06:47:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list epsilon]] to [[Template:cpp/types/numeric limits/dsc epsilon]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc mem sfun | cpp/types/numeric_limits/epsilon | returns the difference between {{tt|1.0}} and the next representable value of the given floating-point type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc float denorm style</title>
    <ns>10</ns>
    <id>3055</id>
    <revision>
      <id>60388</id>
      <parentid>55573</parentid>
      <timestamp>2013-06-01T06:47:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list float denorm style]] to [[Template:cpp/types/numeric limits/dsc float denorm style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="107">{{dsc enum | cpp/types/numeric_limits/float_denorm_style | indicates floating-point denormalization modes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc float round style</title>
    <ns>10</ns>
    <id>3054</id>
    <revision>
      <id>60390</id>
      <parentid>55574</parentid>
      <timestamp>2013-06-01T06:47:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list float round style]] to [[Template:cpp/types/numeric limits/dsc float round style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc enum | cpp/types/numeric_limits/float_round_style | indicates floating-point rounding modes}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc has denorm</title>
    <ns>10</ns>
    <id>3031</id>
    <revision>
      <id>60392</id>
      <parentid>55575</parentid>
      <timestamp>2013-06-01T06:47:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has denorm]] to [[Template:cpp/types/numeric limits/dsc has denorm]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="128">{{dsc mem sconst | cpp/types/numeric_limits/has_denorm | identifies the denormalization style used by the floating-point type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc has denorm loss</title>
    <ns>10</ns>
    <id>3040</id>
    <revision>
      <id>60394</id>
      <parentid>55578</parentid>
      <timestamp>2013-06-01T06:47:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has denorm loss]] to [[Template:cpp/types/numeric limits/dsc has denorm loss]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="181">{{dsc mem sconst | cpp/types/numeric_limits/has_denorm_loss | identifies the floating-point types that detect loss of precision as denormalization loss rather than inexact result }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc has infinity</title>
    <ns>10</ns>
    <id>3037</id>
    <revision>
      <id>60396</id>
      <parentid>55585</parentid>
      <timestamp>2013-06-01T06:47:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has infinity]] to [[Template:cpp/types/numeric limits/dsc has infinity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc mem sconst | cpp/types/numeric_limits/has_infinity | identifies floating-point types that can represent the special value &quot;positive infinity&quot; }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc has quiet NaN</title>
    <ns>10</ns>
    <id>3038</id>
    <revision>
      <id>60398</id>
      <parentid>55588</parentid>
      <timestamp>2013-06-01T06:47:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has quiet NaN]] to [[Template:cpp/types/numeric limits/dsc has quiet NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc mem sconst | cpp/types/numeric_limits/has_quiet_NaN | identifies floating-point types that can represent the special value &quot;quiet not-a-number&quot; (NaN) }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc has signaling NaN</title>
    <ns>10</ns>
    <id>3039</id>
    <revision>
      <id>60400</id>
      <parentid>55591</parentid>
      <timestamp>2013-06-01T06:47:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list has signaling NaN]] to [[Template:cpp/types/numeric limits/dsc has signaling NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="165">{{dsc mem sconst | cpp/types/numeric_limits/has_signaling_NaN | identifies floating-point types that can represent the special value &quot;signaling not-a-number&quot; (NaN)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc infinity</title>
    <ns>10</ns>
    <id>3022</id>
    <revision>
      <id>60402</id>
      <parentid>55592</parentid>
      <timestamp>2013-06-01T06:47:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list infinity]] to [[Template:cpp/types/numeric limits/dsc infinity]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem sfun | cpp/types/numeric_limits/infinity | returns the positive infinity value of the given floating-point type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is bounded</title>
    <ns>10</ns>
    <id>3042</id>
    <revision>
      <id>60404</id>
      <parentid>55595</parentid>
      <timestamp>2013-06-01T06:48:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is bounded]] to [[Template:cpp/types/numeric limits/dsc is bounded]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem sconst | cpp/types/numeric_limits/is_bounded | identifies types that represent a finite set of values }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is exact</title>
    <ns>10</ns>
    <id>3036</id>
    <revision>
      <id>60406</id>
      <parentid>55596</parentid>
      <timestamp>2013-06-01T06:48:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is exact]] to [[Template:cpp/types/numeric limits/dsc is exact]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc mem sconst | cpp/types/numeric_limits/is_exact | identifies exact types }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is iec559</title>
    <ns>10</ns>
    <id>3041</id>
    <revision>
      <id>60408</id>
      <parentid>55597</parentid>
      <timestamp>2013-06-01T06:48:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is iec559]] to [[Template:cpp/types/numeric limits/dsc is iec559]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="110">{{dsc mem sconst | cpp/types/numeric_limits/is_iec559 | identifies the IEC 559/IEEE 754 floating-point types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is integer</title>
    <ns>10</ns>
    <id>3035</id>
    <revision>
      <id>60410</id>
      <parentid>55598</parentid>
      <timestamp>2013-06-01T06:48:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is integer]] to [[Template:cpp/types/numeric limits/dsc is integer]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem sconst | cpp/types/numeric_limits/is_integer | identifies integer types }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is modulo</title>
    <ns>10</ns>
    <id>3043</id>
    <revision>
      <id>60412</id>
      <parentid>55603</parentid>
      <timestamp>2013-06-01T06:48:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is modulo]] to [[Template:cpp/types/numeric limits/dsc is modulo]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="120">{{dsc mem sconst | cpp/types/numeric_limits/is_modulo | identifies types that handle overflows with modulo arithmetic }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is signed</title>
    <ns>10</ns>
    <id>3034</id>
    <revision>
      <id>60414</id>
      <parentid>55604</parentid>
      <timestamp>2013-06-01T06:48:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is signed]] to [[Template:cpp/types/numeric limits/dsc is signed]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc mem sconst | cpp/types/numeric_limits/is_signed | identifies signed types }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc is specialized</title>
    <ns>10</ns>
    <id>3033</id>
    <revision>
      <id>60416</id>
      <parentid>55605</parentid>
      <timestamp>2013-06-01T06:48:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list is specialized]] to [[Template:cpp/types/numeric limits/dsc is specialized]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="131">{{dsc mem sconst | cpp/types/numeric_limits/is_specialized | identifies types for which {{lc|std::numeric_limits}} is specialized}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc lowest</title>
    <ns>10</ns>
    <id>3018</id>
    <revision>
      <id>60418</id>
      <parentid>55606</parentid>
      <timestamp>2013-06-01T06:48:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list lowest]] to [[Template:cpp/types/numeric limits/dsc lowest]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem sfun | cpp/types/numeric_limits/lowest | returns the lowest finite value of the given type | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc max</title>
    <ns>10</ns>
    <id>3019</id>
    <revision>
      <id>60420</id>
      <parentid>55607</parentid>
      <timestamp>2013-06-01T06:48:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max]] to [[Template:cpp/types/numeric limits/dsc max]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="101">{{dsc mem sfun | cpp/types/numeric_limits/max | returns the largest finite value of the given type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc max digits10</title>
    <ns>10</ns>
    <id>3046</id>
    <revision>
      <id>60422</id>
      <parentid>55614</parentid>
      <timestamp>2013-06-01T06:48:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max digits10]] to [[Template:cpp/types/numeric limits/dsc max digits10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc mem sconst | cpp/types/numeric_limits/max_digits10 | number of decimal digits necessary to differentiate all values of this type | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc max exponent</title>
    <ns>10</ns>
    <id>3050</id>
    <revision>
      <id>60424</id>
      <parentid>55619</parentid>
      <timestamp>2013-06-01T06:48:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max exponent]] to [[Template:cpp/types/numeric limits/dsc max exponent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc mem sconst | cpp/types/numeric_limits/max_exponent | one more than the largest integer power of the radix that is a valid finite floating-point value }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc max exponent10</title>
    <ns>10</ns>
    <id>3051</id>
    <revision>
      <id>60426</id>
      <parentid>55620</parentid>
      <timestamp>2013-06-01T06:48:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list max exponent10]] to [[Template:cpp/types/numeric limits/dsc max exponent10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc mem sconst | cpp/types/numeric_limits/max_exponent10 | the largest integer power of 10 that is a valid finite floating-point value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc min</title>
    <ns>10</ns>
    <id>3017</id>
    <revision>
      <id>60428</id>
      <parentid>55623</parentid>
      <timestamp>2013-06-01T06:48:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min]] to [[Template:cpp/types/numeric limits/dsc min]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem sfun | cpp/types/numeric_limits/min | returns the smallest finite value of the given type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc min exponent</title>
    <ns>10</ns>
    <id>3048</id>
    <revision>
      <id>60430</id>
      <parentid>55626</parentid>
      <timestamp>2013-06-01T06:48:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min exponent]] to [[Template:cpp/types/numeric limits/dsc min exponent]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="163">{{dsc mem sconst | cpp/types/numeric_limits/min_exponent | one more than the smallest negative power of the radix that is a valid normalized floating-point value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc min exponent10</title>
    <ns>10</ns>
    <id>3049</id>
    <revision>
      <id>60432</id>
      <parentid>55627</parentid>
      <timestamp>2013-06-01T06:48:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list min exponent10]] to [[Template:cpp/types/numeric limits/dsc min exponent10]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc mem sconst | cpp/types/numeric_limits/min_exponent10 | the smallest negative power of ten that is a valid normalized floating-point value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc quiet NaN</title>
    <ns>10</ns>
    <id>3023</id>
    <revision>
      <id>60434</id>
      <parentid>55628</parentid>
      <timestamp>2013-06-01T06:48:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list quiet NaN]] to [[Template:cpp/types/numeric limits/dsc quiet NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem sfun | cpp/types/numeric_limits/quiet_NaN | returns a quiet NaN value of the given floating-point type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc radix</title>
    <ns>10</ns>
    <id>3047</id>
    <revision>
      <id>60436</id>
      <parentid>55631</parentid>
      <timestamp>2013-06-01T06:48:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list radix]] to [[Template:cpp/types/numeric limits/dsc radix]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc mem sconst | cpp/types/numeric_limits/radix | the radix or integer base used by the representation of the given type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc round error</title>
    <ns>10</ns>
    <id>3021</id>
    <revision>
      <id>60438</id>
      <parentid>55632</parentid>
      <timestamp>2013-06-01T06:48:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list round error]] to [[Template:cpp/types/numeric limits/dsc round error]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem sfun | cpp/types/numeric_limits/round_error | returns the maximum rounding error of the given floating-point type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc round style</title>
    <ns>10</ns>
    <id>3029</id>
    <revision>
      <id>60440</id>
      <parentid>55635</parentid>
      <timestamp>2013-06-01T06:48:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list round style]] to [[Template:cpp/types/numeric limits/dsc round style]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem sconst | cpp/types/numeric_limits/round_style | identifies the rounding style used by the type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc signaling NaN</title>
    <ns>10</ns>
    <id>3024</id>
    <revision>
      <id>60442</id>
      <parentid>55636</parentid>
      <timestamp>2013-06-01T06:48:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list signaling NaN]] to [[Template:cpp/types/numeric limits/dsc signaling NaN]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem sfun | cpp/types/numeric_limits/signaling_NaN | returns a signaling NaN value of the given floating-point type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc tinyness before</title>
    <ns>10</ns>
    <id>3053</id>
    <revision>
      <id>60444</id>
      <parentid>55637</parentid>
      <timestamp>2013-06-01T06:48:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list tinyness before]] to [[Template:cpp/types/numeric limits/dsc tinyness before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc mem sconst | cpp/types/numeric_limits/tinyness_before | identifies floating-point types that detect tinyness before rounding}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/dsc traps</title>
    <ns>10</ns>
    <id>3052</id>
    <revision>
      <id>60446</id>
      <parentid>55640</parentid>
      <timestamp>2013-06-01T06:48:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/dcl list traps]] to [[Template:cpp/types/numeric limits/dsc traps]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc mem sconst | cpp/types/numeric_limits/traps | identifies types which can cause arithmetic operations to trap}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/navbar</title>
    <ns>10</ns>
    <id>3009</id>
    <revision>
      <id>40044</id>
      <parentid>36033</parentid>
      <timestamp>2012-09-28T20:21:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="332">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/numeric_limits/navbar heading
|content4 = cpp/types/numeric_limits/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/navbar content</title>
    <ns>10</ns>
    <id>3060</id>
    <revision>
      <id>55641</id>
      <parentid>35964</parentid>
      <timestamp>2013-06-01T05:25:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1930">{{nv begin}}
{{nv h1 | Static constants}}
{{nv mem ln | cpp/types/numeric_limits/is_specialized}}
{{nv mem ln | cpp/types/numeric_limits/is_signed}}
{{nv mem ln | cpp/types/numeric_limits/is_integer}}
{{nv mem ln | cpp/types/numeric_limits/is_exact}}
{{nv mem ln | cpp/types/numeric_limits/has_infinity}}
{{nv mem ln | cpp/types/numeric_limits/has_quiet_NaN}}
{{nv mem ln | cpp/types/numeric_limits/has_signaling_NaN}}
{{nv mem ln | cpp/types/numeric_limits/has_denorm}}
{{nv mem ln | cpp/types/numeric_limits/has_denorm_loss}}
{{nv mem ln | cpp/types/numeric_limits/round_style}}
{{nv mem ln | cpp/types/numeric_limits/is_iec559}}
{{nv mem ln | cpp/types/numeric_limits/is_bounded}}
{{nv mem ln | cpp/types/numeric_limits/is_modulo}}
{{nv mem ln | cpp/types/numeric_limits/digits}}
{{nv mem ln | cpp/types/numeric_limits/digits10}}
{{nv mem ln | cpp/types/numeric_limits/max_digits10|notes={{mark c++11}}}}
{{nv mem ln | cpp/types/numeric_limits/radix}}
{{nv mem ln | cpp/types/numeric_limits/min_exponent}}
{{nv mem ln | cpp/types/numeric_limits/min_exponent10}}
{{nv mem ln | cpp/types/numeric_limits/max_exponent}}
{{nv mem ln | cpp/types/numeric_limits/max_exponent10}}
{{nv mem ln | cpp/types/numeric_limits/traps}}
{{nv mem ln | cpp/types/numeric_limits/tinyness_before}}
{{nv h1 | Static member functions}}
{{nv mem ln | cpp/types/numeric_limits/min}}
{{nv mem ln | cpp/types/numeric_limits/lowest|notes={{mark c++11}}}}
{{nv mem ln | cpp/types/numeric_limits/max}}
{{nv mem ln | cpp/types/numeric_limits/epsilon}}
{{nv mem ln | cpp/types/numeric_limits/round_error}}
{{nv mem ln | cpp/types/numeric_limits/infinity}}
{{nv mem ln | cpp/types/numeric_limits/quiet_NaN}}
{{nv mem ln | cpp/types/numeric_limits/signaling_NaN}}
{{nv mem ln | cpp/types/numeric_limits/denorm_min}}
{{nv h1 | Helper types}}
{{nv ln | cpp/types/numeric_limits/float_round_style}}
{{nv ln | cpp/types/numeric_limits/float_denorm_style}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/navbar heading</title>
    <ns>10</ns>
    <id>3010</id>
    <revision>
      <id>35966</id>
      <parentid>11365</parentid>
      <timestamp>2012-06-15T22:35:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/numeric limits/sidebar heading]] to [[Template:cpp/types/numeric limits/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="56">{{ltt| cpp/types/numeric_limits | std::numeric_limits }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/numeric limits/title</title>
    <ns>10</ns>
    <id>3008</id>
    <revision>
      <id>11372</id>
      <parentid>11363</parentid>
      <timestamp>2011-10-05T22:34:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rm &lt;T&gt; for consistency</comment>
      <text xml:space="preserve" bytes="111">&lt;onlyinclude&gt;{{cpp/title | n=numeric_limits::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dcl list constructor</title>
    <ns>10</ns>
    <id>12392</id>
    <redirect title="Template:cpp/types/type index/dsc constructor" />
    <revision>
      <id>60449</id>
      <timestamp>2013-06-01T06:48:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type index/dcl list constructor]] to [[Template:cpp/types/type index/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/types/type index/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dcl list hash</title>
    <ns>10</ns>
    <id>12393</id>
    <redirect title="Template:cpp/types/type index/dsc hash" />
    <revision>
      <id>60451</id>
      <timestamp>2013-06-01T06:48:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type index/dcl list hash]] to [[Template:cpp/types/type index/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/type index/dsc hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dcl list hash code</title>
    <ns>10</ns>
    <id>12394</id>
    <redirect title="Template:cpp/types/type index/dsc hash code" />
    <revision>
      <id>60453</id>
      <timestamp>2013-06-01T06:48:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type index/dcl list hash code]] to [[Template:cpp/types/type index/dsc hash code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/types/type index/dsc hash code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dcl list name</title>
    <ns>10</ns>
    <id>12395</id>
    <redirect title="Template:cpp/types/type index/dsc name" />
    <revision>
      <id>60455</id>
      <timestamp>2013-06-01T06:48:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type index/dcl list name]] to [[Template:cpp/types/type index/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/types/type index/dsc name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12396</id>
    <redirect title="Template:cpp/types/type index/dsc operator cmp" />
    <revision>
      <id>60457</id>
      <timestamp>2013-06-01T06:48:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type index/dcl list operator cmp]] to [[Template:cpp/types/type index/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/types/type index/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dsc constructor</title>
    <ns>10</ns>
    <id>2218</id>
    <revision>
      <id>60448</id>
      <parentid>55642</parentid>
      <timestamp>2013-06-01T06:48:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type index/dcl list constructor]] to [[Template:cpp/types/type index/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">{{dsc mem ctor | cpp/types/type_index/type_index | constructs the object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dsc hash</title>
    <ns>10</ns>
    <id>2989</id>
    <revision>
      <id>60450</id>
      <parentid>55645</parentid>
      <timestamp>2013-06-01T06:48:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type index/dcl list hash]] to [[Template:cpp/types/type index/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="158">{{dsc ptclass | cpp/types/type_index/hash | title=std::hash{{dsc small|&lt;std::type_index&gt;}} | hash support for {{lc|std::type_index}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dsc hash code</title>
    <ns>10</ns>
    <id>2220</id>
    <revision>
      <id>60452</id>
      <parentid>55648</parentid>
      <timestamp>2013-06-01T06:48:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type index/dcl list hash code]] to [[Template:cpp/types/type index/dsc hash code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/types/type_index/hash_code | returns hashed code}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dsc name</title>
    <ns>10</ns>
    <id>2221</id>
    <revision>
      <id>60454</id>
      <parentid>55649</parentid>
      <timestamp>2013-06-01T06:48:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type index/dcl list name]] to [[Template:cpp/types/type index/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc mem fun | cpp/types/type_index/name | returns implementation defined name of the type,&lt;br&gt; associated with underlying {{ltt|cpp/types/type_info}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/dsc operator cmp</title>
    <ns>10</ns>
    <id>2219</id>
    <revision>
      <id>60456</id>
      <parentid>55650</parentid>
      <timestamp>2013-06-01T06:48:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type index/dcl list operator cmp]] to [[Template:cpp/types/type index/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="194">{{dsc mem fun | cpp/types/type_index/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | compares the underlying {{lc|std::type_info}} objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/navbar</title>
    <ns>10</ns>
    <id>2172</id>
    <revision>
      <id>40045</id>
      <parentid>36030</parentid>
      <timestamp>2012-09-28T20:21:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="324">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/type_index/navbar heading
|content4 = cpp/types/type_index/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/navbar content</title>
    <ns>10</ns>
    <id>2576</id>
    <revision>
      <id>55651</id>
      <parentid>35970</parentid>
      <timestamp>2013-06-01T05:25:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="330">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/types/type_index/type_index}}
{{nv mem ln | cpp/types/type_index/operator_cmp | operator{{=}} | operator!{{=}} | operator&lt; | operator&lt;{{=}} | operator&gt; | operator&gt;{{=}}}}
{{nv mem ln | cpp/types/type_index/hash_code}}
{{nv mem ln | cpp/types/type_index/name}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/navbar heading</title>
    <ns>10</ns>
    <id>2175</id>
    <revision>
      <id>47758</id>
      <parentid>35971</parentid>
      <timestamp>2013-05-16T20:23:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="44">{{ltt|cpp/types/type_index|std::type_index}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type index/title</title>
    <ns>10</ns>
    <id>2384</id>
    <revision>
      <id>5456</id>
      <timestamp>2011-07-29T20:17:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>new</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=type_index::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dcl list before</title>
    <ns>10</ns>
    <id>12397</id>
    <redirect title="Template:cpp/types/type info/dsc before" />
    <revision>
      <id>60459</id>
      <timestamp>2013-06-01T06:48:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type info/dcl list before]] to [[Template:cpp/types/type info/dsc before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/types/type info/dsc before]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dcl list hash code</title>
    <ns>10</ns>
    <id>12398</id>
    <redirect title="Template:cpp/types/type info/dsc hash code" />
    <revision>
      <id>60461</id>
      <timestamp>2013-06-01T06:48:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type info/dcl list hash code]] to [[Template:cpp/types/type info/dsc hash code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/types/type info/dsc hash code]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dcl list name</title>
    <ns>10</ns>
    <id>12399</id>
    <redirect title="Template:cpp/types/type info/dsc name" />
    <revision>
      <id>60463</id>
      <timestamp>2013-06-01T06:48:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type info/dcl list name]] to [[Template:cpp/types/type info/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/types/type info/dsc name]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12400</id>
    <redirect title="Template:cpp/types/type info/dsc operator cmp" />
    <revision>
      <id>60465</id>
      <timestamp>2013-06-01T06:48:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/types/type info/dcl list operator cmp]] to [[Template:cpp/types/type info/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/types/type info/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dsc before</title>
    <ns>10</ns>
    <id>2215</id>
    <revision>
      <id>60458</id>
      <parentid>55654</parentid>
      <timestamp>2013-06-01T06:48:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type info/dcl list before]] to [[Template:cpp/types/type info/dsc before]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="211">{{dsc mem fun | cpp/types/type_info/before | checks whether the referred type precedes referred type of another {{tt|type_index}}&lt;br&gt; object in the implementation defined order, i.e. orders the referred types }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dsc hash code</title>
    <ns>10</ns>
    <id>2216</id>
    <revision>
      <id>60460</id>
      <parentid>55655</parentid>
      <timestamp>2013-06-01T06:48:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type info/dcl list hash code]] to [[Template:cpp/types/type info/dsc hash code]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="127">{{dsc mem fun | cpp/types/type_info/hash_code | returns a value which is identical for the same types | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dsc name</title>
    <ns>10</ns>
    <id>2217</id>
    <revision>
      <id>60462</id>
      <parentid>55658</parentid>
      <timestamp>2013-06-01T06:48:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type info/dcl list name]] to [[Template:cpp/types/type info/dsc name]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc mem fun | cpp/types/type_info/name | implementation defined name of the type}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/dsc operator cmp</title>
    <ns>10</ns>
    <id>2214</id>
    <revision>
      <id>60464</id>
      <parentid>55659</parentid>
      <timestamp>2013-06-01T06:48:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/types/type info/dcl list operator cmp]] to [[Template:cpp/types/type info/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem fun | cpp/types/type_info/operator_cmp| title=operator==&lt;br&gt;operator!= | checks whether the objects refer to the same type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/navbar</title>
    <ns>10</ns>
    <id>2171</id>
    <revision>
      <id>40046</id>
      <parentid>36028</parentid>
      <timestamp>2012-09-28T20:21:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="322">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/types/navbar heading
|content3 = cpp/types/navbar content

|heading4 = cpp/types/type_info/navbar heading
|content4 = cpp/types/type_info/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/navbar content</title>
    <ns>10</ns>
    <id>2222</id>
    <revision>
      <id>55660</id>
      <parentid>35655</parentid>
      <timestamp>2013-06-01T05:26:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="335">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/types/type_info/~type_info}}
{{nv mem ln | cpp/types/type_info/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv mem ln | cpp/types/type_info/before}}
{{nv mem ln | cpp/types/type_info/hash_code | notes={{mark c++11}}}}
{{nv mem ln | cpp/types/type_info/name}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/navbar heading</title>
    <ns>10</ns>
    <id>2174</id>
    <revision>
      <id>47757</id>
      <parentid>35448</parentid>
      <timestamp>2013-05-16T20:23:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="42">{{ltt|cpp/types/type_info|std::type_info}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/types/type info/title</title>
    <ns>10</ns>
    <id>2224</id>
    <revision>
      <id>5026</id>
      <timestamp>2011-07-11T17:02:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=type_info::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="106">&lt;onlyinclude&gt;{{cpp/title | n=type_info::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bad optional access/dcl list constructor</title>
    <ns>10</ns>
    <id>12401</id>
    <redirect title="Template:cpp/utility/bad optional access/dsc constructor" />
    <revision>
      <id>60467</id>
      <timestamp>2013-06-01T06:48:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bad optional access/dcl list constructor]] to [[Template:cpp/utility/bad optional access/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">#REDIRECT [[Template:cpp/utility/bad optional access/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bad optional access/dsc constructor</title>
    <ns>10</ns>
    <id>10107</id>
    <revision>
      <id>60466</id>
      <parentid>55663</parentid>
      <timestamp>2013-06-01T06:48:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bad optional access/dcl list constructor]] to [[Template:cpp/utility/bad optional access/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="102">{{dsc mem ctor | cpp/utility/bad_optional_access | inlinemem=true | constructs the exception object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bad optional access/title</title>
    <ns>10</ns>
    <id>10108</id>
    <revision>
      <id>48166</id>
      <timestamp>2013-05-18T20:37:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{cpp/title | n=bad_optional_access::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list all any none</title>
    <ns>10</ns>
    <id>12402</id>
    <redirect title="Template:cpp/utility/bitset/dsc all any none" />
    <revision>
      <id>60469</id>
      <timestamp>2013-06-01T06:48:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list all any none]] to [[Template:cpp/utility/bitset/dsc all any none]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/bitset/dsc all any none]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list constructor</title>
    <ns>10</ns>
    <id>12403</id>
    <redirect title="Template:cpp/utility/bitset/dsc constructor" />
    <revision>
      <id>60471</id>
      <timestamp>2013-06-01T06:48:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list constructor]] to [[Template:cpp/utility/bitset/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/bitset/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list count</title>
    <ns>10</ns>
    <id>12404</id>
    <redirect title="Template:cpp/utility/bitset/dsc count" />
    <revision>
      <id>60473</id>
      <timestamp>2013-06-01T06:48:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list count]] to [[Template:cpp/utility/bitset/dsc count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/utility/bitset/dsc count]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list flip</title>
    <ns>10</ns>
    <id>12405</id>
    <redirect title="Template:cpp/utility/bitset/dsc flip" />
    <revision>
      <id>60475</id>
      <timestamp>2013-06-01T06:48:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list flip]] to [[Template:cpp/utility/bitset/dsc flip]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/utility/bitset/dsc flip]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list hash</title>
    <ns>10</ns>
    <id>12406</id>
    <redirect title="Template:cpp/utility/bitset/dsc hash" />
    <revision>
      <id>60477</id>
      <timestamp>2013-06-01T06:48:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list hash]] to [[Template:cpp/utility/bitset/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/utility/bitset/dsc hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator at</title>
    <ns>10</ns>
    <id>12407</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator at" />
    <revision>
      <id>60479</id>
      <timestamp>2013-06-01T06:48:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator at]] to [[Template:cpp/utility/bitset/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/bitset/dsc operator at]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12408</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator cmp" />
    <revision>
      <id>60481</id>
      <timestamp>2013-06-01T06:48:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator cmp]] to [[Template:cpp/utility/bitset/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/bitset/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator logic</title>
    <ns>10</ns>
    <id>12409</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator logic" />
    <revision>
      <id>60483</id>
      <timestamp>2013-06-01T06:48:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator logic]] to [[Template:cpp/utility/bitset/dsc operator logic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/bitset/dsc operator logic]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator logic2</title>
    <ns>10</ns>
    <id>12410</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator logic2" />
    <revision>
      <id>60485</id>
      <timestamp>2013-06-01T06:48:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator logic2]] to [[Template:cpp/utility/bitset/dsc operator logic2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/bitset/dsc operator logic2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator ltltgtgt</title>
    <ns>10</ns>
    <id>12411</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator ltltgtgt" />
    <revision>
      <id>60487</id>
      <timestamp>2013-06-01T06:48:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator ltltgtgt]] to [[Template:cpp/utility/bitset/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/utility/bitset/dsc operator ltltgtgt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list operator ltltgtgt2</title>
    <ns>10</ns>
    <id>12412</id>
    <redirect title="Template:cpp/utility/bitset/dsc operator ltltgtgt2" />
    <revision>
      <id>60489</id>
      <timestamp>2013-06-01T06:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator ltltgtgt2]] to [[Template:cpp/utility/bitset/dsc operator ltltgtgt2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/utility/bitset/dsc operator ltltgtgt2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list reset</title>
    <ns>10</ns>
    <id>12413</id>
    <redirect title="Template:cpp/utility/bitset/dsc reset" />
    <revision>
      <id>60491</id>
      <timestamp>2013-06-01T06:48:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list reset]] to [[Template:cpp/utility/bitset/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/utility/bitset/dsc reset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list set</title>
    <ns>10</ns>
    <id>12414</id>
    <redirect title="Template:cpp/utility/bitset/dsc set" />
    <revision>
      <id>60493</id>
      <timestamp>2013-06-01T06:48:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list set]] to [[Template:cpp/utility/bitset/dsc set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/utility/bitset/dsc set]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list size</title>
    <ns>10</ns>
    <id>12415</id>
    <redirect title="Template:cpp/utility/bitset/dsc size" />
    <revision>
      <id>60495</id>
      <timestamp>2013-06-01T06:48:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list size]] to [[Template:cpp/utility/bitset/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/utility/bitset/dsc size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list test</title>
    <ns>10</ns>
    <id>12416</id>
    <redirect title="Template:cpp/utility/bitset/dsc test" />
    <revision>
      <id>60497</id>
      <timestamp>2013-06-01T06:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list test]] to [[Template:cpp/utility/bitset/dsc test]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/utility/bitset/dsc test]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list to string</title>
    <ns>10</ns>
    <id>12417</id>
    <redirect title="Template:cpp/utility/bitset/dsc to string" />
    <revision>
      <id>60499</id>
      <timestamp>2013-06-01T06:49:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to string]] to [[Template:cpp/utility/bitset/dsc to string]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/bitset/dsc to string]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list to ullong</title>
    <ns>10</ns>
    <id>12418</id>
    <redirect title="Template:cpp/utility/bitset/dsc to ullong" />
    <revision>
      <id>60501</id>
      <timestamp>2013-06-01T06:49:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to ullong]] to [[Template:cpp/utility/bitset/dsc to ullong]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/bitset/dsc to ullong]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dcl list to ulong</title>
    <ns>10</ns>
    <id>12419</id>
    <redirect title="Template:cpp/utility/bitset/dsc to ulong" />
    <revision>
      <id>60503</id>
      <timestamp>2013-06-01T06:49:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to ulong]] to [[Template:cpp/utility/bitset/dsc to ulong]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/bitset/dsc to ulong]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc all any none</title>
    <ns>10</ns>
    <id>2373</id>
    <revision>
      <id>60468</id>
      <parentid>55664</parentid>
      <timestamp>2013-06-01T06:48:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list all any none]] to [[Template:cpp/utility/bitset/dsc all any none]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="175">{{dsc mem fun | cpp/utility/bitset/all_any_none | title=all&lt;br&gt;any&lt;br&gt;none | checks if all, any or none bits are set to {{c|true}} | notes={{mark c++11}}&lt;br&gt;&amp;nbsp;&lt;br&gt;&amp;nbsp;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc constructor</title>
    <ns>10</ns>
    <id>31</id>
    <revision>
      <id>60470</id>
      <parentid>55667</parentid>
      <timestamp>2013-06-01T06:48:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list constructor]] to [[Template:cpp/utility/bitset/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">{{dsc mem ctor | cpp/utility/bitset/bitset | constructs the bitset}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc count</title>
    <ns>10</ns>
    <id>32</id>
    <revision>
      <id>60472</id>
      <parentid>55668</parentid>
      <timestamp>2013-06-01T06:48:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list count]] to [[Template:cpp/utility/bitset/dsc count]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc mem fun | cpp/utility/bitset/count | returns the number of bits set to {{c|true}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc flip</title>
    <ns>10</ns>
    <id>33</id>
    <revision>
      <id>60474</id>
      <parentid>55669</parentid>
      <timestamp>2013-06-01T06:48:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list flip]] to [[Template:cpp/utility/bitset/dsc flip]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">{{dsc mem fun | cpp/utility/bitset/flip | toggles the values of bits}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc hash</title>
    <ns>10</ns>
    <id>2987</id>
    <revision>
      <id>60476</id>
      <parentid>55670</parentid>
      <timestamp>2013-06-01T06:48:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list hash]] to [[Template:cpp/utility/bitset/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc ptclass | cpp/utility/bitset/hash | title=std::hash{{dsc small|&lt;std::bitset&gt;}} | hash support for {{lc|std::bitset}} | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator at</title>
    <ns>10</ns>
    <id>37</id>
    <revision>
      <id>60478</id>
      <parentid>55673</parentid>
      <timestamp>2013-06-01T06:48:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator at]] to [[Template:cpp/utility/bitset/dsc operator at]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc mem fun | cpp/utility/bitset/operator_at | title=operator[] | accesses specific bit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator cmp</title>
    <ns>10</ns>
    <id>38</id>
    <revision>
      <id>60480</id>
      <parentid>55674</parentid>
      <timestamp>2013-06-01T06:48:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator cmp]] to [[Template:cpp/utility/bitset/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="106">{{dsc mem fun | cpp/utility/bitset/operator_cmp | title=operator==&lt;br&gt;operator!= | compares the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator logic</title>
    <ns>10</ns>
    <id>39</id>
    <revision>
      <id>60482</id>
      <parentid>55677</parentid>
      <timestamp>2013-06-01T06:48:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator logic]] to [[Template:cpp/utility/bitset/dsc operator logic]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc mem fun | cpp/utility/bitset/operator_logic | title=operator&amp;=&lt;br&gt;operator{{!}}=&lt;br&gt;operator^=&lt;br&gt;operator~ | performs binary AND, OR, XOR and NOT}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator logic2</title>
    <ns>10</ns>
    <id>9542</id>
    <revision>
      <id>60484</id>
      <parentid>55678</parentid>
      <timestamp>2013-06-01T06:48:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator logic2]] to [[Template:cpp/utility/bitset/dsc operator logic2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc fun | cpp/utility/bitset/operator_logic2 | title=operator&amp;&lt;br&gt;operator{{!}}&lt;br&gt;operator^ | performs binary logic operations on bitsets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator ltltgtgt</title>
    <ns>10</ns>
    <id>1985</id>
    <revision>
      <id>60486</id>
      <parentid>55679</parentid>
      <timestamp>2013-06-01T06:48:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator ltltgtgt]] to [[Template:cpp/utility/bitset/dsc operator ltltgtgt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc mem fun | cpp/utility/bitset/operator_ltltgtgt | title=operator&lt;&lt;=&lt;br&gt;operator&gt;&gt;=&lt;br&gt;operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs binary shift left and shift right}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc operator ltltgtgt2</title>
    <ns>10</ns>
    <id>9543</id>
    <revision>
      <id>60488</id>
      <parentid>55682</parentid>
      <timestamp>2013-06-01T06:48:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list operator ltltgtgt2]] to [[Template:cpp/utility/bitset/dsc operator ltltgtgt2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc fun | cpp/utility/bitset/operator_ltltgtgt2 | title=operator&lt;&lt;&lt;br&gt;operator&gt;&gt; | performs stream input and output of bitsets}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc reset</title>
    <ns>10</ns>
    <id>40</id>
    <revision>
      <id>60490</id>
      <parentid>55687</parentid>
      <timestamp>2013-06-01T06:48:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list reset]] to [[Template:cpp/utility/bitset/dsc reset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">{{dsc mem fun | cpp/utility/bitset/reset | sets bits to {{c|false}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc set</title>
    <ns>10</ns>
    <id>41</id>
    <revision>
      <id>60492</id>
      <parentid>55690</parentid>
      <timestamp>2013-06-01T06:48:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list set]] to [[Template:cpp/utility/bitset/dsc set]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/utility/bitset/set | sets bits to {{c|true}} or given value}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc size</title>
    <ns>10</ns>
    <id>42</id>
    <revision>
      <id>60494</id>
      <parentid>55691</parentid>
      <timestamp>2013-06-01T06:48:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list size]] to [[Template:cpp/utility/bitset/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem fun | cpp/utility/bitset/size | returns the size number of bits that the bitset can hold}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc test</title>
    <ns>10</ns>
    <id>43</id>
    <revision>
      <id>60496</id>
      <parentid>55692</parentid>
      <timestamp>2013-06-01T06:49:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list test]] to [[Template:cpp/utility/bitset/dsc test]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">{{dsc mem fun | cpp/utility/bitset/test | accesses specific bit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc to string</title>
    <ns>10</ns>
    <id>44</id>
    <revision>
      <id>60498</id>
      <parentid>55693</parentid>
      <timestamp>2013-06-01T06:49:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to string]] to [[Template:cpp/utility/bitset/dsc to string]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc mem fun | cpp/utility/bitset/to_string | returns a string representation of the data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc to ullong</title>
    <ns>10</ns>
    <id>45</id>
    <revision>
      <id>60500</id>
      <parentid>55695</parentid>
      <timestamp>2013-06-01T06:49:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to ullong]] to [[Template:cpp/utility/bitset/dsc to ullong]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc mem fun | cpp/utility/bitset/to_ullong | returns an {{c|unsigned long long}} integer representation of the data | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/dsc to ulong</title>
    <ns>10</ns>
    <id>46</id>
    <revision>
      <id>60502</id>
      <parentid>55699</parentid>
      <timestamp>2013-06-01T06:49:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/dcl list to ulong]] to [[Template:cpp/utility/bitset/dsc to ulong]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="113">{{dsc mem fun | cpp/utility/bitset/to_ulong | returns an {{c|unsigned long}} integer representation of the data}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/navbar</title>
    <ns>10</ns>
    <id>47</id>
    <revision>
      <id>47768</id>
      <parentid>40047</parentid>
      <timestamp>2013-05-16T20:25:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="245">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/bitset/navbar heading
|content3 = cpp/utility/bitset/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/navbar content</title>
    <ns>10</ns>
    <id>48</id>
    <revision>
      <id>55701</id>
      <parentid>35974</parentid>
      <timestamp>2013-06-01T05:26:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1419">{{nv begin}}
{{nv h1 | Member types}}
{{nv mem ln | cpp/utility/bitset/reference}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/bitset/bitset}}
{{nv mem ln | cpp/utility/bitset/operator_cmp | operator{{==}} | operator!{{=}}}}
{{nv h2 | Element access}}
{{nv mem ln | cpp/utility/bitset/operator_at | operator[]}}
{{nv mem ln | cpp/utility/bitset/test}}
{{nv mem ln | cpp/utility/bitset/all_any_none|all|any|none|notes={{mark c++11}}&lt;br&gt;&lt;br&gt;&amp;nbsp;}}
{{nv mem ln | cpp/utility/bitset/count}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/utility/bitset/size}}
{{nv h2 | Modifiers}}
{{nv mem ln | cpp/utility/bitset/operator_logic | operator&amp;{{=}} | operator{{!}}{{=}} | operator^{{=}} | operator~}}
{{nv mem ln | cpp/utility/bitset/operator_ltltgtgt | operator&lt;&lt;{{=}} | operator&gt;&gt;{{=}} | operator&lt;&lt; | operator&gt;&gt;}}
{{nv mem ln | cpp/utility/bitset/set}}
{{nv mem ln | cpp/utility/bitset/reset}}
{{nv mem ln | cpp/utility/bitset/flip}}
{{nv h2 | Conversions}}
{{nv mem ln | cpp/utility/bitset/to_string}}
{{nv mem ln | cpp/utility/bitset/to_ulong}}
{{nv mem ln | cpp/utility/bitset/to_ullong | notes={{mark c++11}}}}
{{nv h2 | Non-member functions}}
{{nv ln | cpp/utility/bitset/operator_logic2 | operator&amp; | operator{{!}} | operator^}}
{{nv ln | cpp/utility/bitset/operator_ltltgtgt2 | operator&lt;&lt; | operator&gt;&gt;}}
{{nv h2 | Helper classes}}
{{nv ln | cpp/utility/bitset/hash | std::hash| notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/navbar heading</title>
    <ns>10</ns>
    <id>49</id>
    <revision>
      <id>47755</id>
      <parentid>34087</parentid>
      <timestamp>2013-05-16T20:22:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="38">{{ltt|cpp/utility/bitset|std::bitset}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/reference/dcl list operator bool</title>
    <ns>10</ns>
    <id>12420</id>
    <redirect title="Template:cpp/utility/bitset/reference/dsc operator bool" />
    <revision>
      <id>60505</id>
      <timestamp>2013-06-01T06:49:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/bitset/reference/dcl list operator bool]] to [[Template:cpp/utility/bitset/reference/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/utility/bitset/reference/dsc operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/reference/dsc operator bool</title>
    <ns>10</ns>
    <id>9931</id>
    <revision>
      <id>60504</id>
      <parentid>55703</parentid>
      <timestamp>2013-06-01T06:49:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/bitset/reference/dcl list operator bool]] to [[Template:cpp/utility/bitset/reference/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem fun | cpp/utility/bitset/reference | title=operator bool | inlinemem=true | returns the referenced bit}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/reference/title</title>
    <ns>10</ns>
    <id>8573</id>
    <revision>
      <id>31734</id>
      <timestamp>2012-06-06T20:45:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="121">&lt;onlyinclude&gt;{{cpp/utility/bitset/title | n=reference::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/bitset/title</title>
    <ns>10</ns>
    <id>50</id>
    <revision>
      <id>99</id>
      <parentid>98</parentid>
      <timestamp>2011-06-06T22:42:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=bitset::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list bad optional access</title>
    <ns>10</ns>
    <id>12421</id>
    <redirect title="Template:cpp/utility/dsc bad optional access" />
    <revision>
      <id>60507</id>
      <timestamp>2013-06-01T06:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list bad optional access]] to [[Template:cpp/utility/dsc bad optional access]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/dsc bad optional access]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list bitset</title>
    <ns>10</ns>
    <id>12422</id>
    <redirect title="Template:cpp/utility/dsc bitset" />
    <revision>
      <id>60509</id>
      <timestamp>2013-06-01T06:49:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list bitset]] to [[Template:cpp/utility/dsc bitset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="45">#REDIRECT [[Template:cpp/utility/dsc bitset]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list declval</title>
    <ns>10</ns>
    <id>12423</id>
    <redirect title="Template:cpp/utility/dsc declval" />
    <revision>
      <id>60511</id>
      <timestamp>2013-06-01T06:49:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list declval]] to [[Template:cpp/utility/dsc declval]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/utility/dsc declval]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list exchange</title>
    <ns>10</ns>
    <id>12424</id>
    <redirect title="Template:cpp/utility/dsc exchange" />
    <revision>
      <id>60513</id>
      <timestamp>2013-06-01T06:49:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list exchange]] to [[Template:cpp/utility/dsc exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/utility/dsc exchange]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list forward</title>
    <ns>10</ns>
    <id>12425</id>
    <redirect title="Template:cpp/utility/dsc forward" />
    <revision>
      <id>60515</id>
      <timestamp>2013-06-01T06:49:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list forward]] to [[Template:cpp/utility/dsc forward]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/utility/dsc forward]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list hash</title>
    <ns>10</ns>
    <id>12426</id>
    <redirect title="Template:cpp/utility/dsc hash" />
    <revision>
      <id>60517</id>
      <timestamp>2013-06-01T06:49:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list hash]] to [[Template:cpp/utility/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/utility/dsc hash]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list in place</title>
    <ns>10</ns>
    <id>12427</id>
    <redirect title="Template:cpp/utility/dsc in place" />
    <revision>
      <id>60519</id>
      <timestamp>2013-06-01T06:49:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list in place]] to [[Template:cpp/utility/dsc in place]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/utility/dsc in place]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list in place t</title>
    <ns>10</ns>
    <id>12428</id>
    <redirect title="Template:cpp/utility/dsc in place t" />
    <revision>
      <id>60521</id>
      <timestamp>2013-06-01T06:49:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list in place t]] to [[Template:cpp/utility/dsc in place t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/utility/dsc in place t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list initializer list</title>
    <ns>10</ns>
    <id>12429</id>
    <redirect title="Template:cpp/utility/dsc initializer list" />
    <revision>
      <id>60523</id>
      <timestamp>2013-06-01T06:49:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list initializer list]] to [[Template:cpp/utility/dsc initializer list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/dsc initializer list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list integer sequence</title>
    <ns>10</ns>
    <id>12430</id>
    <redirect title="Template:cpp/utility/dsc integer sequence" />
    <revision>
      <id>60525</id>
      <timestamp>2013-06-01T06:49:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list integer sequence]] to [[Template:cpp/utility/dsc integer sequence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/dsc integer sequence]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list move</title>
    <ns>10</ns>
    <id>12431</id>
    <redirect title="Template:cpp/utility/dsc move" />
    <revision>
      <id>60527</id>
      <timestamp>2013-06-01T06:49:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list move]] to [[Template:cpp/utility/dsc move]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/utility/dsc move]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list move if noexcept</title>
    <ns>10</ns>
    <id>12432</id>
    <redirect title="Template:cpp/utility/dsc move if noexcept" />
    <revision>
      <id>60529</id>
      <timestamp>2013-06-01T06:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list move if noexcept]] to [[Template:cpp/utility/dsc move if noexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/dsc move if noexcept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list nullopt</title>
    <ns>10</ns>
    <id>12433</id>
    <redirect title="Template:cpp/utility/dsc nullopt" />
    <revision>
      <id>60531</id>
      <timestamp>2013-06-01T06:49:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list nullopt]] to [[Template:cpp/utility/dsc nullopt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="46">#REDIRECT [[Template:cpp/utility/dsc nullopt]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list nullopt t</title>
    <ns>10</ns>
    <id>12434</id>
    <redirect title="Template:cpp/utility/dsc nullopt t" />
    <revision>
      <id>60533</id>
      <timestamp>2013-06-01T06:49:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list nullopt t]] to [[Template:cpp/utility/dsc nullopt t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/utility/dsc nullopt t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list optional</title>
    <ns>10</ns>
    <id>12435</id>
    <redirect title="Template:cpp/utility/dsc optional" />
    <revision>
      <id>60535</id>
      <timestamp>2013-06-01T06:49:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list optional]] to [[Template:cpp/utility/dsc optional]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/utility/dsc optional]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list pair</title>
    <ns>10</ns>
    <id>12436</id>
    <redirect title="Template:cpp/utility/dsc pair" />
    <revision>
      <id>60537</id>
      <timestamp>2013-06-01T06:49:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list pair]] to [[Template:cpp/utility/dsc pair]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="43">#REDIRECT [[Template:cpp/utility/dsc pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list piecewise construct</title>
    <ns>10</ns>
    <id>12437</id>
    <redirect title="Template:cpp/utility/dsc piecewise construct" />
    <revision>
      <id>60539</id>
      <timestamp>2013-06-01T06:49:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list piecewise construct]] to [[Template:cpp/utility/dsc piecewise construct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/dsc piecewise construct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list piecewise construct t</title>
    <ns>10</ns>
    <id>12438</id>
    <redirect title="Template:cpp/utility/dsc piecewise construct t" />
    <revision>
      <id>60541</id>
      <timestamp>2013-06-01T06:49:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list piecewise construct t]] to [[Template:cpp/utility/dsc piecewise construct t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/dsc piecewise construct t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dcl list tuple</title>
    <ns>10</ns>
    <id>12439</id>
    <redirect title="Template:cpp/utility/dsc tuple" />
    <revision>
      <id>60543</id>
      <timestamp>2013-06-01T06:49:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/dcl list tuple]] to [[Template:cpp/utility/dsc tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[Template:cpp/utility/dsc tuple]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc bad optional access</title>
    <ns>10</ns>
    <id>9989</id>
    <revision>
      <id>60506</id>
      <parentid>55707</parentid>
      <timestamp>2013-06-01T06:49:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list bad optional access]] to [[Template:cpp/utility/dsc bad optional access]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="145">{{dsc class | cpp/utility/bad_optional_access | exception indicating access to a optional type with uninitialized state | notes={{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc bitset</title>
    <ns>10</ns>
    <id>2985</id>
    <revision>
      <id>60508</id>
      <parentid>55709</parentid>
      <timestamp>2013-06-01T06:49:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list bitset]] to [[Template:cpp/utility/dsc bitset]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">{{dsc class | cpp/utility/bitset | implements constant length bit array}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc declval</title>
    <ns>10</ns>
    <id>2667</id>
    <revision>
      <id>60510</id>
      <parentid>55711</parentid>
      <timestamp>2013-06-01T06:49:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list declval]] to [[Template:cpp/utility/dsc declval]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="112">{{dsc tfun | cpp/utility/declval | obtains the type of expression in unevaluated context| notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc exchange</title>
    <ns>10</ns>
    <id>9983</id>
    <revision>
      <id>60512</id>
      <parentid>55718</parentid>
      <timestamp>2013-06-01T06:49:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list exchange]] to [[Template:cpp/utility/dsc exchange]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc tfun | cpp/utility/exchange | replaces the argument with a new value and returns its previous value | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc forward</title>
    <ns>10</ns>
    <id>2662</id>
    <revision>
      <id>60514</id>
      <parentid>55721</parentid>
      <timestamp>2013-06-01T06:49:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list forward]] to [[Template:cpp/utility/dsc forward]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc tfun | cpp/utility/forward | forwards a function argument | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc hash</title>
    <ns>10</ns>
    <id>2982</id>
    <revision>
      <id>60516</id>
      <parentid>55723</parentid>
      <timestamp>2013-06-01T06:49:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list hash]] to [[Template:cpp/utility/dsc hash]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="80">{{dsc tclass | cpp/utility/hash | hash function object | notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc in place</title>
    <ns>10</ns>
    <id>9985</id>
    <revision>
      <id>64417</id>
      <parentid>60518</parentid>
      <timestamp>2013-08-16T14:46:06Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>tt -&gt; c</comment>
      <text xml:space="preserve" bytes="100">{{dsc fun | cpp/utility/in_place | an object of type {{c|std::in_place_t}} | notes={{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc in place t</title>
    <ns>10</ns>
    <id>9986</id>
    <revision>
      <id>60520</id>
      <parentid>55726</parentid>
      <timestamp>2013-06-01T06:49:17Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list in place t]] to [[Template:cpp/utility/dsc in place t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc class | cpp/utility/in_place_t | disambiguation tag type for in-place construction of optional types | notes={{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc initializer list</title>
    <ns>10</ns>
    <id>2986</id>
    <revision>
      <id>60522</id>
      <parentid>55730</parentid>
      <timestamp>2013-06-01T06:49:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list initializer list]] to [[Template:cpp/utility/dsc initializer list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="187">{{dsc tclass | cpp/utility/initializer_list | allows the use of [[cpp/language/initializer_list | initializer list syntax]] to initialize non plain-old-data types | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc integer sequence</title>
    <ns>10</ns>
    <id>9981</id>
    <revision>
      <id>60524</id>
      <parentid>55733</parentid>
      <timestamp>2013-06-01T06:49:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list integer sequence]] to [[Template:cpp/utility/dsc integer sequence]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc tclass | cpp/utility/integer_sequence | implements compile-time sequence of integers | notes={{mark c++14}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc move</title>
    <ns>10</ns>
    <id>2665</id>
    <revision>
      <id>60526</id>
      <parentid>55735</parentid>
      <timestamp>2013-06-01T06:49:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list move]] to [[Template:cpp/utility/dsc move]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="84">{{dsc tfun | cpp/utility/move | obtains an rvalue reference | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc move if noexcept</title>
    <ns>10</ns>
    <id>2663</id>
    <revision>
      <id>60528</id>
      <parentid>55739</parentid>
      <timestamp>2013-06-01T06:49:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list move if noexcept]] to [[Template:cpp/utility/dsc move if noexcept]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc tfun | cpp/utility/move_if_noexcept | obtains an rvalue reference if the move constructor does not throw | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc nullopt</title>
    <ns>10</ns>
    <id>9987</id>
    <revision>
      <id>60530</id>
      <parentid>55741</parentid>
      <timestamp>2013-06-01T06:49:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list nullopt]] to [[Template:cpp/utility/dsc nullopt]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc fun | cpp/utility/nullopt | an object of type {{tt|nullopt_t}} | notes={{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc nullopt t</title>
    <ns>10</ns>
    <id>9988</id>
    <revision>
      <id>60532</id>
      <parentid>55743</parentid>
      <timestamp>2013-06-01T06:49:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list nullopt t]] to [[Template:cpp/utility/dsc nullopt t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="115">{{dsc class | cpp/utility/nullopt_t | indicator of optional type with uninitialized state | notes={{mark c++14}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc optional</title>
    <ns>10</ns>
    <id>9984</id>
    <revision>
      <id>68181</id>
      <parentid>64414</parentid>
      <timestamp>2014-03-17T01:40:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>cpp/utility/optional -&gt; cpp/experimental/optional</comment>
      <text xml:space="preserve" bytes="113">{{dsc tclass | cpp/experimental/optional | a wrapper that may or may not hold an object | notes={{mark c++14}} }}</text>
      <sha1>2nio4yy26wrsb9slzi300n54ihc1sdq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc pair</title>
    <ns>10</ns>
    <id>2983</id>
    <revision>
      <id>60536</id>
      <parentid>55749</parentid>
      <timestamp>2013-06-01T06:49:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list pair]] to [[Template:cpp/utility/dsc pair]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="82">{{dsc tclass | cpp/utility/pair | implements binary tuple, i.e. a pair of values}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc piecewise construct</title>
    <ns>10</ns>
    <id>2628</id>
    <revision>
      <id>60538</id>
      <parentid>55753</parentid>
      <timestamp>2013-06-01T06:49:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list piecewise construct]] to [[Template:cpp/utility/dsc piecewise construct]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="177">{{dsc const | cpp/utility/piecewise_construct | an object of type {{tt|piecewise_construct_t}} used to disambiguate functions for piecewise construction | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc piecewise construct t</title>
    <ns>10</ns>
    <id>2651</id>
    <revision>
      <id>60540</id>
      <parentid>55755</parentid>
      <timestamp>2013-06-01T06:49:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list piecewise construct t]] to [[Template:cpp/utility/dsc piecewise construct t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="151">{{dsc class | cpp/utility/piecewise_construct_t | tag type used to select correct function overload for piecewise construction | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/dsc tuple</title>
    <ns>10</ns>
    <id>2984</id>
    <revision>
      <id>60542</id>
      <parentid>55759</parentid>
      <timestamp>2013-06-01T06:49:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/dcl list tuple]] to [[Template:cpp/utility/dsc tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="141">{{dsc tclass | cpp/utility/tuple | implements fixed size container, which holds elements of possibly different types | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/example piecewise construct</title>
    <ns>10</ns>
    <id>3124</id>
    <revision>
      <id>23471</id>
      <parentid>20671</parentid>
      <timestamp>2012-04-20T02:27:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{example cpp&quot; to &quot;{{example&quot;</comment>
      <text xml:space="preserve" bytes="606">
{{example |
 | code=
#include &lt;iostream&gt;
#include &lt;utility&gt;
#include &lt;tuple&gt;

struct Foo {
    Foo(std::tuple&lt;int, float&gt;) 
    {
        std::cout &lt;&lt; &quot;Constructed a Foo from a tuple\n&quot;;
    }
    Foo(int, float) 
    {
        std::cout &lt;&lt; &quot;Constructed a Foo from an int and a float\n&quot;;
    }
};

int main()
{
    std::tuple&lt;int, float&gt; t(1, 3.14);
    std::pair&lt;Foo, Foo&gt; p1(t, t);
    std::pair&lt;Foo, Foo&gt; p2(std::piecewise_construct, t, t);
}
 | output=
Constructed a Foo from a tuple
Constructed a Foo from a tuple
Constructed a Foo from an int and a float
Constructed a Foo from an int and a float
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/binary negate/dcl list operator()</title>
    <ns>10</ns>
    <id>12440</id>
    <redirect title="Template:cpp/utility/functional/binary negate/dsc operator()" />
    <revision>
      <id>60545</id>
      <timestamp>2013-06-01T06:49:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/binary negate/dcl list operator()]] to [[Template:cpp/utility/functional/binary negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">#REDIRECT [[Template:cpp/utility/functional/binary negate/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/binary negate/dsc operator()</title>
    <ns>10</ns>
    <id>8849</id>
    <revision>
      <id>60544</id>
      <parentid>55761</parentid>
      <timestamp>2013-06-01T06:49:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/binary negate/dcl list operator()]] to [[Template:cpp/utility/functional/binary negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="171">{{dsc mem fun | cpp/utility/functional/binary_negate | title=operator() | inlinemem=true | returns the logical complement of the result of a call to the stored predicate}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/binary negate/title</title>
    <ns>10</ns>
    <id>8570</id>
    <revision>
      <id>31731</id>
      <timestamp>2012-06-06T20:45:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=binary_negate::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit and/dcl list operator()</title>
    <ns>10</ns>
    <id>12441</id>
    <redirect title="Template:cpp/utility/functional/bit and/dsc operator()" />
    <revision>
      <id>60547</id>
      <timestamp>2013-06-01T06:49:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/bit and/dcl list operator()]] to [[Template:cpp/utility/functional/bit and/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/bit and/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit and/dsc operator()</title>
    <ns>10</ns>
    <id>8845</id>
    <revision>
      <id>60546</id>
      <parentid>55765</parentid>
      <timestamp>2013-06-01T06:49:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/bit and/dcl list operator()]] to [[Template:cpp/utility/functional/bit and/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc mem fun | cpp/utility/functional/bit_and | title=operator() | inlinemem=true | returns the result of bitwise AND of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit and/title</title>
    <ns>10</ns>
    <id>8569</id>
    <revision>
      <id>31730</id>
      <timestamp>2012-06-06T20:45:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=bit_and::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit or/dcl list operator()</title>
    <ns>10</ns>
    <id>12442</id>
    <redirect title="Template:cpp/utility/functional/bit or/dsc operator()" />
    <revision>
      <id>60549</id>
      <timestamp>2013-06-01T06:49:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/bit or/dcl list operator()]] to [[Template:cpp/utility/functional/bit or/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/utility/functional/bit or/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit or/dsc operator()</title>
    <ns>10</ns>
    <id>8846</id>
    <revision>
      <id>60548</id>
      <parentid>55767</parentid>
      <timestamp>2013-06-01T06:49:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/bit or/dcl list operator()]] to [[Template:cpp/utility/functional/bit or/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem fun | cpp/utility/functional/bit_or | title=operator() | inlinemem=true | returns the result of bitwise OR of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit or/title</title>
    <ns>10</ns>
    <id>8567</id>
    <revision>
      <id>31728</id>
      <timestamp>2012-06-06T20:44:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=bit_or::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit xor/dcl list operator()</title>
    <ns>10</ns>
    <id>12443</id>
    <redirect title="Template:cpp/utility/functional/bit xor/dsc operator()" />
    <revision>
      <id>60551</id>
      <timestamp>2013-06-01T06:49:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/bit xor/dcl list operator()]] to [[Template:cpp/utility/functional/bit xor/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/bit xor/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit xor/dsc operator()</title>
    <ns>10</ns>
    <id>8847</id>
    <revision>
      <id>60550</id>
      <parentid>55769</parentid>
      <timestamp>2013-06-01T06:49:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/bit xor/dcl list operator()]] to [[Template:cpp/utility/functional/bit xor/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc mem fun | cpp/utility/functional/bit_xor | title=operator() | inlinemem=true | returns the result of bitwise XOR of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/bit xor/title</title>
    <ns>10</ns>
    <id>8564</id>
    <revision>
      <id>31725</id>
      <timestamp>2012-06-06T20:44:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=bit_xor::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bad function call</title>
    <ns>10</ns>
    <id>12444</id>
    <redirect title="Template:cpp/utility/functional/dsc bad function call" />
    <revision>
      <id>60553</id>
      <timestamp>2013-06-01T06:49:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bad function call]] to [[Template:cpp/utility/functional/dsc bad function call]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/utility/functional/dsc bad function call]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list binary function</title>
    <ns>10</ns>
    <id>12445</id>
    <redirect title="Template:cpp/utility/functional/dsc binary function" />
    <revision>
      <id>60555</id>
      <timestamp>2013-06-01T06:49:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list binary function]] to [[Template:cpp/utility/functional/dsc binary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/utility/functional/dsc binary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list binary negate</title>
    <ns>10</ns>
    <id>12446</id>
    <redirect title="Template:cpp/utility/functional/dsc binary negate" />
    <revision>
      <id>60557</id>
      <timestamp>2013-06-01T06:49:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list binary negate]] to [[Template:cpp/utility/functional/dsc binary negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/utility/functional/dsc binary negate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bind</title>
    <ns>10</ns>
    <id>12447</id>
    <redirect title="Template:cpp/utility/functional/dsc bind" />
    <revision>
      <id>60559</id>
      <timestamp>2013-06-01T06:49:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bind]] to [[Template:cpp/utility/functional/dsc bind]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/functional/dsc bind]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bind12</title>
    <ns>10</ns>
    <id>12448</id>
    <redirect title="Template:cpp/utility/functional/dsc bind12" />
    <revision>
      <id>60561</id>
      <timestamp>2013-06-01T06:49:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bind12]] to [[Template:cpp/utility/functional/dsc bind12]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/functional/dsc bind12]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list binder12</title>
    <ns>10</ns>
    <id>12449</id>
    <redirect title="Template:cpp/utility/functional/dsc binder12" />
    <revision>
      <id>60563</id>
      <timestamp>2013-06-01T06:49:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list binder12]] to [[Template:cpp/utility/functional/dsc binder12]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/functional/dsc binder12]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bit and</title>
    <ns>10</ns>
    <id>12450</id>
    <redirect title="Template:cpp/utility/functional/dsc bit and" />
    <revision>
      <id>60565</id>
      <timestamp>2013-06-01T06:49:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit and]] to [[Template:cpp/utility/functional/dsc bit and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc bit and]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bit or</title>
    <ns>10</ns>
    <id>12451</id>
    <redirect title="Template:cpp/utility/functional/dsc bit or" />
    <revision>
      <id>60567</id>
      <timestamp>2013-06-01T06:49:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit or]] to [[Template:cpp/utility/functional/dsc bit or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/functional/dsc bit or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list bit xor</title>
    <ns>10</ns>
    <id>12452</id>
    <redirect title="Template:cpp/utility/functional/dsc bit xor" />
    <revision>
      <id>60569</id>
      <timestamp>2013-06-01T06:49:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit xor]] to [[Template:cpp/utility/functional/dsc bit xor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc bit xor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list divides</title>
    <ns>10</ns>
    <id>12453</id>
    <redirect title="Template:cpp/utility/functional/dsc divides" />
    <revision>
      <id>60571</id>
      <timestamp>2013-06-01T06:49:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list divides]] to [[Template:cpp/utility/functional/dsc divides]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc divides]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list equal to</title>
    <ns>10</ns>
    <id>12454</id>
    <redirect title="Template:cpp/utility/functional/dsc equal to" />
    <revision>
      <id>60573</id>
      <timestamp>2013-06-01T06:49:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list equal to]] to [[Template:cpp/utility/functional/dsc equal to]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/functional/dsc equal to]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list function</title>
    <ns>10</ns>
    <id>12455</id>
    <redirect title="Template:cpp/utility/functional/dsc function" />
    <revision>
      <id>60575</id>
      <timestamp>2013-06-01T06:49:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list function]] to [[Template:cpp/utility/functional/dsc function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/functional/dsc function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list greater</title>
    <ns>10</ns>
    <id>12456</id>
    <redirect title="Template:cpp/utility/functional/dsc greater" />
    <revision>
      <id>60577</id>
      <timestamp>2013-06-01T06:50:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list greater]] to [[Template:cpp/utility/functional/dsc greater]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc greater]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list greater equal</title>
    <ns>10</ns>
    <id>12457</id>
    <redirect title="Template:cpp/utility/functional/dsc greater equal" />
    <revision>
      <id>60579</id>
      <timestamp>2013-06-01T06:50:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list greater equal]] to [[Template:cpp/utility/functional/dsc greater equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/utility/functional/dsc greater equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list is bind expression</title>
    <ns>10</ns>
    <id>12458</id>
    <redirect title="Template:cpp/utility/functional/dsc is bind expression" />
    <revision>
      <id>60581</id>
      <timestamp>2013-06-01T06:50:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list is bind expression]] to [[Template:cpp/utility/functional/dsc is bind expression]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/dsc is bind expression]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list is placeholder</title>
    <ns>10</ns>
    <id>12459</id>
    <redirect title="Template:cpp/utility/functional/dsc is placeholder" />
    <revision>
      <id>60583</id>
      <timestamp>2013-06-01T06:50:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list is placeholder]] to [[Template:cpp/utility/functional/dsc is placeholder]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/utility/functional/dsc is placeholder]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list less</title>
    <ns>10</ns>
    <id>12460</id>
    <redirect title="Template:cpp/utility/functional/dsc less" />
    <revision>
      <id>60585</id>
      <timestamp>2013-06-01T06:50:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list less]] to [[Template:cpp/utility/functional/dsc less]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/functional/dsc less]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list less equal</title>
    <ns>10</ns>
    <id>12461</id>
    <redirect title="Template:cpp/utility/functional/dsc less equal" />
    <revision>
      <id>60587</id>
      <timestamp>2013-06-01T06:50:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list less equal]] to [[Template:cpp/utility/functional/dsc less equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/functional/dsc less equal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list logical and</title>
    <ns>10</ns>
    <id>12462</id>
    <redirect title="Template:cpp/utility/functional/dsc logical and" />
    <revision>
      <id>60589</id>
      <timestamp>2013-06-01T06:50:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical and]] to [[Template:cpp/utility/functional/dsc logical and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/functional/dsc logical and]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list logical not</title>
    <ns>10</ns>
    <id>12463</id>
    <redirect title="Template:cpp/utility/functional/dsc logical not" />
    <revision>
      <id>60591</id>
      <timestamp>2013-06-01T06:50:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical not]] to [[Template:cpp/utility/functional/dsc logical not]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/functional/dsc logical not]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list logical or</title>
    <ns>10</ns>
    <id>12464</id>
    <redirect title="Template:cpp/utility/functional/dsc logical or" />
    <revision>
      <id>60593</id>
      <timestamp>2013-06-01T06:50:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical or]] to [[Template:cpp/utility/functional/dsc logical or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/functional/dsc logical or]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list mem fn</title>
    <ns>10</ns>
    <id>12465</id>
    <redirect title="Template:cpp/utility/functional/dsc mem fn" />
    <revision>
      <id>60595</id>
      <timestamp>2013-06-01T06:50:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fn]] to [[Template:cpp/utility/functional/dsc mem fn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/functional/dsc mem fn]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list mem fun</title>
    <ns>10</ns>
    <id>12466</id>
    <redirect title="Template:cpp/utility/functional/dsc mem fun" />
    <revision>
      <id>60597</id>
      <timestamp>2013-06-01T06:50:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun]] to [[Template:cpp/utility/functional/dsc mem fun]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc mem fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list mem fun ref</title>
    <ns>10</ns>
    <id>12467</id>
    <redirect title="Template:cpp/utility/functional/dsc mem fun ref" />
    <revision>
      <id>60599</id>
      <timestamp>2013-06-01T06:50:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun ref]] to [[Template:cpp/utility/functional/dsc mem fun ref]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/functional/dsc mem fun ref]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list mem fun ref t</title>
    <ns>10</ns>
    <id>12468</id>
    <redirect title="Template:cpp/utility/functional/dsc mem fun ref t" />
    <revision>
      <id>60601</id>
      <timestamp>2013-06-01T06:50:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun ref t]] to [[Template:cpp/utility/functional/dsc mem fun ref t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/utility/functional/dsc mem fun ref t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list mem fun t</title>
    <ns>10</ns>
    <id>12469</id>
    <redirect title="Template:cpp/utility/functional/dsc mem fun t" />
    <revision>
      <id>60603</id>
      <timestamp>2013-06-01T06:50:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun t]] to [[Template:cpp/utility/functional/dsc mem fun t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/utility/functional/dsc mem fun t]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list minus</title>
    <ns>10</ns>
    <id>12470</id>
    <redirect title="Template:cpp/utility/functional/dsc minus" />
    <revision>
      <id>60605</id>
      <timestamp>2013-06-01T06:50:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list minus]] to [[Template:cpp/utility/functional/dsc minus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/functional/dsc minus]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list modulus</title>
    <ns>10</ns>
    <id>12471</id>
    <redirect title="Template:cpp/utility/functional/dsc modulus" />
    <revision>
      <id>60607</id>
      <timestamp>2013-06-01T06:50:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list modulus]] to [[Template:cpp/utility/functional/dsc modulus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc modulus]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list multiplies</title>
    <ns>10</ns>
    <id>12472</id>
    <redirect title="Template:cpp/utility/functional/dsc multiplies" />
    <revision>
      <id>60609</id>
      <timestamp>2013-06-01T06:50:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list multiplies]] to [[Template:cpp/utility/functional/dsc multiplies]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/functional/dsc multiplies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list negate</title>
    <ns>10</ns>
    <id>12473</id>
    <redirect title="Template:cpp/utility/functional/dsc negate" />
    <revision>
      <id>60611</id>
      <timestamp>2013-06-01T06:50:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list negate]] to [[Template:cpp/utility/functional/dsc negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/functional/dsc negate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list not1</title>
    <ns>10</ns>
    <id>12474</id>
    <redirect title="Template:cpp/utility/functional/dsc not1" />
    <revision>
      <id>60613</id>
      <timestamp>2013-06-01T06:50:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list not1]] to [[Template:cpp/utility/functional/dsc not1]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/functional/dsc not1]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list not2</title>
    <ns>10</ns>
    <id>12475</id>
    <redirect title="Template:cpp/utility/functional/dsc not2" />
    <revision>
      <id>60615</id>
      <timestamp>2013-06-01T06:50:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list not2]] to [[Template:cpp/utility/functional/dsc not2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/functional/dsc not2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list not equal to</title>
    <ns>10</ns>
    <id>12476</id>
    <redirect title="Template:cpp/utility/functional/dsc not equal to" />
    <revision>
      <id>60617</id>
      <timestamp>2013-06-01T06:50:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list not equal to]] to [[Template:cpp/utility/functional/dsc not equal to]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/utility/functional/dsc not equal to]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list placeholders</title>
    <ns>10</ns>
    <id>12477</id>
    <redirect title="Template:cpp/utility/functional/dsc placeholders" />
    <revision>
      <id>60619</id>
      <timestamp>2013-06-01T06:50:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list placeholders]] to [[Template:cpp/utility/functional/dsc placeholders]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/utility/functional/dsc placeholders]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list plus</title>
    <ns>10</ns>
    <id>12478</id>
    <redirect title="Template:cpp/utility/functional/dsc plus" />
    <revision>
      <id>60621</id>
      <timestamp>2013-06-01T06:50:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list plus]] to [[Template:cpp/utility/functional/dsc plus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/functional/dsc plus]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list pointer to binary function</title>
    <ns>10</ns>
    <id>12479</id>
    <redirect title="Template:cpp/utility/functional/dsc pointer to binary function" />
    <revision>
      <id>60623</id>
      <timestamp>2013-06-01T06:50:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list pointer to binary function]] to [[Template:cpp/utility/functional/dsc pointer to binary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="76">#REDIRECT [[Template:cpp/utility/functional/dsc pointer to binary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list pointer to unary function</title>
    <ns>10</ns>
    <id>12480</id>
    <redirect title="Template:cpp/utility/functional/dsc pointer to unary function" />
    <revision>
      <id>60625</id>
      <timestamp>2013-06-01T06:50:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list pointer to unary function]] to [[Template:cpp/utility/functional/dsc pointer to unary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">#REDIRECT [[Template:cpp/utility/functional/dsc pointer to unary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list ptr fun</title>
    <ns>10</ns>
    <id>12481</id>
    <redirect title="Template:cpp/utility/functional/dsc ptr fun" />
    <revision>
      <id>60627</id>
      <timestamp>2013-06-01T06:50:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list ptr fun]] to [[Template:cpp/utility/functional/dsc ptr fun]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/functional/dsc ptr fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list ref</title>
    <ns>10</ns>
    <id>12482</id>
    <redirect title="Template:cpp/utility/functional/dsc ref" />
    <revision>
      <id>60629</id>
      <timestamp>2013-06-01T06:50:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list ref]] to [[Template:cpp/utility/functional/dsc ref]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/functional/dsc ref]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list reference wrapper</title>
    <ns>10</ns>
    <id>12483</id>
    <redirect title="Template:cpp/utility/functional/dsc reference wrapper" />
    <revision>
      <id>60631</id>
      <timestamp>2013-06-01T06:50:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list reference wrapper]] to [[Template:cpp/utility/functional/dsc reference wrapper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/utility/functional/dsc reference wrapper]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list unary function</title>
    <ns>10</ns>
    <id>12484</id>
    <redirect title="Template:cpp/utility/functional/dsc unary function" />
    <revision>
      <id>60633</id>
      <timestamp>2013-06-01T06:50:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list unary function]] to [[Template:cpp/utility/functional/dsc unary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/utility/functional/dsc unary function]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dcl list unary negate</title>
    <ns>10</ns>
    <id>12485</id>
    <redirect title="Template:cpp/utility/functional/dsc unary negate" />
    <revision>
      <id>60635</id>
      <timestamp>2013-06-01T06:50:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/dcl list unary negate]] to [[Template:cpp/utility/functional/dsc unary negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/utility/functional/dsc unary negate]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/divides/dcl list operator()</title>
    <ns>10</ns>
    <id>12486</id>
    <redirect title="Template:cpp/utility/functional/divides/dsc operator()" />
    <revision>
      <id>60637</id>
      <timestamp>2013-06-01T06:50:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/divides/dcl list operator()]] to [[Template:cpp/utility/functional/divides/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/divides/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/divides/dsc operator()</title>
    <ns>10</ns>
    <id>8833</id>
    <revision>
      <id>60636</id>
      <parentid>55850</parentid>
      <timestamp>2013-06-01T06:50:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/divides/dcl list operator()]] to [[Template:cpp/utility/functional/divides/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc mem fun | cpp/utility/functional/divides | title=operator() | inlinemem=true | returns the result of the division of the first argument by the second argument }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/divides/title</title>
    <ns>10</ns>
    <id>8561</id>
    <revision>
      <id>31722</id>
      <timestamp>2012-06-06T20:44:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=divides::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bad function call</title>
    <ns>10</ns>
    <id>4182</id>
    <revision>
      <id>60552</id>
      <parentid>55772</parentid>
      <timestamp>2013-06-01T06:49:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bad function call]] to [[Template:cpp/utility/functional/dsc bad function call]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc class | cpp/utility/functional/bad_function_call | the exception thrown when invoking an empty {{lc|std::function}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc binary function</title>
    <ns>10</ns>
    <id>5207</id>
    <revision>
      <id>60554</id>
      <parentid>55773</parentid>
      <timestamp>2013-06-01T06:49:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list binary function]] to [[Template:cpp/utility/functional/dsc binary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="132">{{dsc tclass | cpp/utility/functional/binary_function | adaptor-compatible binary function base class  | notes={{mark deprecated}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc binary negate</title>
    <ns>10</ns>
    <id>4173</id>
    <revision>
      <id>60556</id>
      <parentid>55776</parentid>
      <timestamp>2013-06-01T06:49:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list binary negate]] to [[Template:cpp/utility/functional/dsc binary negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="138">{{dsc tclass | cpp/utility/functional/binary_negate | wrapper function object returning the complement of the binary predicate it holds }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bind</title>
    <ns>10</ns>
    <id>4176</id>
    <revision>
      <id>60558</id>
      <parentid>55779</parentid>
      <timestamp>2013-06-01T06:49:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bind]] to [[Template:cpp/utility/functional/dsc bind]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc tfun | cpp/utility/functional/bind | binds one or more arguments to a function object | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bind12</title>
    <ns>10</ns>
    <id>5479</id>
    <revision>
      <id>60560</id>
      <parentid>55782</parentid>
      <timestamp>2013-06-01T06:49:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bind12]] to [[Template:cpp/utility/functional/dsc bind12]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="164">{{dsc tfun | cpp/utility/functional/bind12 | title=bind1st&lt;br&gt;bind2nd | binds one argument to a binary function | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc binder12</title>
    <ns>10</ns>
    <id>5478</id>
    <revision>
      <id>60562</id>
      <parentid>55783</parentid>
      <timestamp>2013-06-01T06:49:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list binder12]] to [[Template:cpp/utility/functional/dsc binder12]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="199">{{dsc tclass | cpp/utility/functional/binder12 | title=binder1st&lt;br&gt;binder2nd | function object holding a binary function and one of its arguments | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit and</title>
    <ns>10</ns>
    <id>4201</id>
    <revision>
      <id>60564</id>
      <parentid>55786</parentid>
      <timestamp>2013-06-01T06:49:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit and]] to [[Template:cpp/utility/functional/dsc bit and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/utility/functional/bit_and | function object implementing {{c|x &amp; y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit and void</title>
    <ns>10</ns>
    <id>13074</id>
    <revision>
      <id>66292</id>
      <timestamp>2013-11-10T02:04:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="167">{{dsc ptclass | cpp/utility/functional/bit_and_void | title=bit_and{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &amp; y}} deducing argument and return types}}</text>
      <sha1>rpmya7x7jbt5rz6wriyr9rkv31ht0ly</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit not</title>
    <ns>10</ns>
    <id>12899</id>
    <revision>
      <id>64479</id>
      <timestamp>2013-08-18T02:57:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="111">{{dsc tclass | notes={{mark c++14}} | cpp/utility/functional/bit_not | function object implementing {{c|~x}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit not void</title>
    <ns>10</ns>
    <id>13077</id>
    <revision>
      <id>66299</id>
      <timestamp>2013-11-10T02:11:58Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="164">{{dsc ptclass | cpp/utility/functional/bit_not_void | title=bit_not{{dsc small|&lt;void&gt;}} | function object implementing {{c|~x}} deducing argument and return types}}</text>
      <sha1>i43u7rlvv8imlsvvsm0zxiu1satb4n5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit or</title>
    <ns>10</ns>
    <id>4202</id>
    <revision>
      <id>60566</id>
      <parentid>55787</parentid>
      <timestamp>2013-06-01T06:49:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit or]] to [[Template:cpp/utility/functional/dsc bit or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc tclass | cpp/utility/functional/bit_or | function object implementing {{c|x {{!}} y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit or void</title>
    <ns>10</ns>
    <id>13075</id>
    <revision>
      <id>66295</id>
      <parentid>66294</parentid>
      <timestamp>2013-11-10T02:06:34Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>copypaste error</comment>
      <text xml:space="preserve" bytes="169">{{dsc ptclass | cpp/utility/functional/bit_or_void | title=bit_or{{dsc small|&lt;void&gt;}} | function object implementing {{c|x {{!}} y}} deducing argument and return types}}</text>
      <sha1>098ml1odz2gpg9g9v6mze1metem131l</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit xor</title>
    <ns>10</ns>
    <id>4203</id>
    <revision>
      <id>60568</id>
      <parentid>55788</parentid>
      <timestamp>2013-06-01T06:49:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list bit xor]] to [[Template:cpp/utility/functional/dsc bit xor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/utility/functional/bit_xor | function object implementing {{c|x ^ y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc bit xor void</title>
    <ns>10</ns>
    <id>13076</id>
    <revision>
      <id>66297</id>
      <timestamp>2013-11-10T02:08:33Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="167">{{dsc ptclass | cpp/utility/functional/bit_xor_void | title=bit_xor{{dsc small|&lt;void&gt;}} | function object implementing {{c|x ^ y}} deducing argument and return types}}</text>
      <sha1>kwblg9a826ua18c7dk1kne1z9zcxawx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc divides</title>
    <ns>10</ns>
    <id>4189</id>
    <revision>
      <id>60570</id>
      <parentid>55789</parentid>
      <timestamp>2013-06-01T06:49:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list divides]] to [[Template:cpp/utility/functional/dsc divides]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/utility/functional/divides | function object implementing {{c|x / y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc divides void</title>
    <ns>10</ns>
    <id>13047</id>
    <revision>
      <id>66226</id>
      <timestamp>2013-11-10T00:12:20Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="167">{{dsc ptclass | cpp/utility/functional/divides_void | title=divides{{dsc small|&lt;void&gt;}} | function object implementing {{c|x / y}} deducing argument and return types}}</text>
      <sha1>f4x2x31zno6wetgjb1juw132wf815od</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc equal to</title>
    <ns>10</ns>
    <id>4192</id>
    <revision>
      <id>60572</id>
      <parentid>55792</parentid>
      <timestamp>2013-06-01T06:49:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list equal to]] to [[Template:cpp/utility/functional/dsc equal to]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tclass | cpp/utility/functional/equal_to | function object implementing {{c|1=x == y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc equal to void</title>
    <ns>10</ns>
    <id>13055</id>
    <revision>
      <id>66239</id>
      <timestamp>2013-11-10T00:45:09Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="174">{{dsc ptclass | cpp/utility/functional/equal_to_void | title=equal_to{{dsc small|&lt;void&gt;}} | function object implementing {{c|x {{==}} y}} deducing argument and return types}}</text>
      <sha1>snt53735tasar7pdt4vaqeqh6uvqctx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc function</title>
    <ns>10</ns>
    <id>4181</id>
    <revision>
      <id>60574</id>
      <parentid>55793</parentid>
      <timestamp>2013-06-01T06:49:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list function]] to [[Template:cpp/utility/functional/dsc function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="146">{{dsc tclass | cpp/utility/functional/function | wraps callable object of any type with specified function call signature | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc greater</title>
    <ns>10</ns>
    <id>4194</id>
    <revision>
      <id>60576</id>
      <parentid>55796</parentid>
      <timestamp>2013-06-01T06:50:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list greater]] to [[Template:cpp/utility/functional/dsc greater]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/utility/functional/greater | function object implementing {{c|x &gt; y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc greater equal</title>
    <ns>10</ns>
    <id>4196</id>
    <revision>
      <id>60578</id>
      <parentid>55799</parentid>
      <timestamp>2013-06-01T06:50:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list greater equal]] to [[Template:cpp/utility/functional/dsc greater equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc tclass | cpp/utility/functional/greater_equal | function object implementing {{c|1=x &gt;= y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc greater equal void</title>
    <ns>10</ns>
    <id>13059</id>
    <revision>
      <id>66257</id>
      <parentid>66256</parentid>
      <timestamp>2013-11-10T01:04:27Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>=</comment>
      <text xml:space="preserve" bytes="184">{{dsc ptclass | cpp/utility/functional/greater_equal_void | title=greater_equal{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &gt;{{=}} y}} deducing argument and return types}}</text>
      <sha1>i7iqbjuue5v3k9zlbocpq213fg7zvfu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc greater void</title>
    <ns>10</ns>
    <id>13057</id>
    <revision>
      <id>66251</id>
      <timestamp>2013-11-10T00:59:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="167">{{dsc ptclass | cpp/utility/functional/greater_void | title=greater{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &gt; y}} deducing argument and return types}}</text>
      <sha1>slu1l8iruxdyy888v0rjx7kgfg0dphf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc is bind expression</title>
    <ns>10</ns>
    <id>4177</id>
    <revision>
      <id>60580</id>
      <parentid>55800</parentid>
      <timestamp>2013-06-01T06:50:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list is bind expression]] to [[Template:cpp/utility/functional/dsc is bind expression]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc tclass | cpp/utility/functional/is_bind_expression | indicates that an object is {{tt|std::bind}} expression or can be used as one | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc is placeholder</title>
    <ns>10</ns>
    <id>4178</id>
    <revision>
      <id>60582</id>
      <parentid>55803</parentid>
      <timestamp>2013-06-01T06:50:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list is placeholder]] to [[Template:cpp/utility/functional/dsc is placeholder]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc tclass | cpp/utility/functional/is_placeholder | indicates that an object is a standard placeholder or can be used as one | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc less</title>
    <ns>10</ns>
    <id>4195</id>
    <revision>
      <id>60584</id>
      <parentid>55806</parentid>
      <timestamp>2013-06-01T06:50:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list less]] to [[Template:cpp/utility/functional/dsc less]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc tclass | cpp/utility/functional/less | function object implementing {{c|x &lt; y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc less equal</title>
    <ns>10</ns>
    <id>4197</id>
    <revision>
      <id>60586</id>
      <parentid>55807</parentid>
      <timestamp>2013-06-01T06:50:07Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list less equal]] to [[Template:cpp/utility/functional/dsc less equal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc tclass | cpp/utility/functional/less_equal | function object implementing {{c|1=x &lt;= y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc less equal void</title>
    <ns>10</ns>
    <id>13060</id>
    <revision>
      <id>66260</id>
      <timestamp>2013-11-10T01:09:02Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="178">{{dsc ptclass | cpp/utility/functional/less_equal_void | title=less_equal{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &lt;{{=}} y}} deducing argument and return types}}</text>
      <sha1>3hbsz35rc3k6j0e04xp896ti28zqmd4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc less void</title>
    <ns>10</ns>
    <id>13058</id>
    <revision>
      <id>66254</id>
      <timestamp>2013-11-10T01:02:03Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="161">{{dsc ptclass | cpp/utility/functional/less_void | title=less{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &lt; y}} deducing argument and return types}}</text>
      <sha1>foipmec69cvvkdk8brpscyyd60o351r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical and</title>
    <ns>10</ns>
    <id>4198</id>
    <revision>
      <id>60588</id>
      <parentid>55808</parentid>
      <timestamp>2013-06-01T06:50:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical and]] to [[Template:cpp/utility/functional/dsc logical and]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc tclass | cpp/utility/functional/logical_and | function object implementing {{c|x &amp;&amp; y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical and void</title>
    <ns>10</ns>
    <id>13068</id>
    <revision>
      <id>66283</id>
      <timestamp>2013-11-10T01:50:14Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="176">{{dsc ptclass | cpp/utility/functional/logical_and_void | title=logical_and{{dsc small|&lt;void&gt;}} | function object implementing {{c|x &amp;&amp; y}} deducing argument and return types}}</text>
      <sha1>smimej7ikfcir9jed33lbt80erh4pn2</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical not</title>
    <ns>10</ns>
    <id>4200</id>
    <revision>
      <id>60590</id>
      <parentid>55809</parentid>
      <timestamp>2013-06-01T06:50:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical not]] to [[Template:cpp/utility/functional/dsc logical not]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="92">{{dsc tclass | cpp/utility/functional/logical_not | function object implementing {{c|!x}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical not void</title>
    <ns>10</ns>
    <id>13070</id>
    <revision>
      <id>66287</id>
      <timestamp>2013-11-10T01:55:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="172">{{dsc ptclass | cpp/utility/functional/logical_not_void | title=logical_not{{dsc small|&lt;void&gt;}} | function object implementing {{c|!x}} deducing argument and return types}}</text>
      <sha1>esxh720dnbejyyjbjaj09vl4j7eq1tr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical or</title>
    <ns>10</ns>
    <id>4199</id>
    <revision>
      <id>60592</id>
      <parentid>55812</parentid>
      <timestamp>2013-06-01T06:50:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list logical or]] to [[Template:cpp/utility/functional/dsc logical or]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="103">{{dsc tclass | cpp/utility/functional/logical_or | function object implementing {{c|x {{!}}{{!}} y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc logical or void</title>
    <ns>10</ns>
    <id>13069</id>
    <revision>
      <id>66285</id>
      <timestamp>2013-11-10T01:52:21Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="178">{{dsc ptclass | cpp/utility/functional/logical_or_void | title=logical_or{{dsc small|&lt;void&gt;}} | function object implementing {{c|x {{!!}} y}} deducing argument and return types}}</text>
      <sha1>hu6kovs1optt63d6mx6u69n9zgr8jiz</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc mem fn</title>
    <ns>10</ns>
    <id>4180</id>
    <revision>
      <id>60594</id>
      <parentid>55813</parentid>
      <timestamp>2013-06-01T06:50:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fn]] to [[Template:cpp/utility/functional/dsc mem fn]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="124">{{dsc tfun | cpp/utility/functional/mem_fn | creates a function object out of a pointer to a member | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc mem fun</title>
    <ns>10</ns>
    <id>5216</id>
    <revision>
      <id>60596</id>
      <parentid>55816</parentid>
      <timestamp>2013-06-01T06:50:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun]] to [[Template:cpp/utility/functional/dsc mem fun]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="162">{{dsc tfun | cpp/utility/functional/mem_fun | creates a wrapper from a pointer to member function, callable with a pointer to object| notes={{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc mem fun ref</title>
    <ns>10</ns>
    <id>5218</id>
    <revision>
      <id>60598</id>
      <parentid>55817</parentid>
      <timestamp>2013-06-01T06:50:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun ref]] to [[Template:cpp/utility/functional/dsc mem fun ref]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="168">{{dsc tfun | cpp/utility/functional/mem_fun_ref | creates a wrapper from a pointer to member function, callable with a reference to object| notes={{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc mem fun ref t</title>
    <ns>10</ns>
    <id>5217</id>
    <revision>
      <id>60600</id>
      <parentid>55818</parentid>
      <timestamp>2013-06-01T06:50:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list mem fun ref t]] to [[Template:cpp/utility/functional/dsc mem fun ref t]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="334">{{dsc tclass | cpp/utility/functional/mem_fun_ref_t | title=mem_fun_ref_t&lt;br&gt;mem_fun1_ref_t&lt;br&gt;const_mem_fun_ref_t&lt;br&gt;const_mem_fun1_ref_t | wapper for a pointer to nullary or unary member function, callable with a reference to object | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc mem fun t</title>
    <ns>10</ns>
    <id>5215</id>
    <revision>
      <id>63175</id>
      <parentid>60602</parentid>
      <timestamp>2013-07-04T20:12:41Z</timestamp>
      <contributor>
        <username>Marktsuchida</username>
        <id>1787</id>
      </contributor>
      <comment>Add missing &quot;unary&quot; case (dsc_mem_fun_ref_t already had this correct)</comment>
      <text xml:space="preserve" bytes="313">{{dsc tclass | cpp/utility/functional/mem_fun_t | title=mem_fun_t&lt;br&gt;mem_fun1_t&lt;br&gt;const_mem_fun_t&lt;br&gt;const_mem_fun1_t | wrapper for a pointer to nullary or unary member function, callable with a pointer to object | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc minus</title>
    <ns>10</ns>
    <id>4187</id>
    <revision>
      <id>60604</id>
      <parentid>55822</parentid>
      <timestamp>2013-06-01T06:50:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list minus]] to [[Template:cpp/utility/functional/dsc minus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="89">{{dsc tclass | cpp/utility/functional/minus | function object implementing {{c|x - y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc minus void</title>
    <ns>10</ns>
    <id>13045</id>
    <revision>
      <id>66222</id>
      <timestamp>2013-11-10T00:07:53Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="163">{{dsc ptclass | cpp/utility/functional/minus_void | title=minus{{dsc small|&lt;void&gt;}} | function object implementing {{c|x - y}} deducing argument and return types}}</text>
      <sha1>0u4sdq4p0d2stpr445t9z1adeknwkiu</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc modulus</title>
    <ns>10</ns>
    <id>4190</id>
    <revision>
      <id>60606</id>
      <parentid>55823</parentid>
      <timestamp>2013-06-01T06:50:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list modulus]] to [[Template:cpp/utility/functional/dsc modulus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc tclass | cpp/utility/functional/modulus | function object implementing {{c|x % y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc modulus void</title>
    <ns>10</ns>
    <id>13048</id>
    <revision>
      <id>66228</id>
      <timestamp>2013-11-10T00:14:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="167">{{dsc ptclass | cpp/utility/functional/modulus_void | title=modulus{{dsc small|&lt;void&gt;}} | function object implementing {{c|x % y}} deducing argument and return types}}</text>
      <sha1>npwgmqo784f752b4sdbhch241qhqjwv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc multiplies</title>
    <ns>10</ns>
    <id>4188</id>
    <revision>
      <id>60608</id>
      <parentid>55824</parentid>
      <timestamp>2013-06-01T06:50:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list multiplies]] to [[Template:cpp/utility/functional/dsc multiplies]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc tclass | cpp/utility/functional/multiplies | function object implementing {{c|x * y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc multiplies void</title>
    <ns>10</ns>
    <id>13046</id>
    <revision>
      <id>66224</id>
      <timestamp>2013-11-10T00:10:37Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="173">{{dsc ptclass | cpp/utility/functional/multiplies_void | title=multiplies{{dsc small|&lt;void&gt;}} | function object implementing {{c|x * y}} deducing argument and return types}}</text>
      <sha1>g82lrw6smawcsddk41bkl47qxegyqk9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc negate</title>
    <ns>10</ns>
    <id>4191</id>
    <revision>
      <id>60610</id>
      <parentid>55827</parentid>
      <timestamp>2013-06-01T06:50:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list negate]] to [[Template:cpp/utility/functional/dsc negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc tclass | cpp/utility/functional/negate | function object implementing {{c|-x}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc negate void</title>
    <ns>10</ns>
    <id>13049</id>
    <revision>
      <id>66231</id>
      <timestamp>2013-11-10T00:16:36Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="162">{{dsc ptclass | cpp/utility/functional/negate_void | title=negate{{dsc small|&lt;void&gt;}} | function object implementing {{c|-x}} deducing argument and return types}}</text>
      <sha1>jxj38v1m5rf13j9wnmwaoa4u221jqz3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc not1</title>
    <ns>10</ns>
    <id>4174</id>
    <revision>
      <id>60612</id>
      <parentid>55828</parentid>
      <timestamp>2013-06-01T06:50:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list not1]] to [[Template:cpp/utility/functional/dsc not1]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tfun | cpp/utility/functional/not1 | constructs custom {{lc|std::unary_negate}} object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc not2</title>
    <ns>10</ns>
    <id>4175</id>
    <revision>
      <id>60614</id>
      <parentid>55831</parentid>
      <timestamp>2013-06-01T06:50:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list not2]] to [[Template:cpp/utility/functional/dsc not2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="96">{{dsc tfun | cpp/utility/functional/not2 | constructs custom {{lc|std::binary_negate}} object }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc not equal to</title>
    <ns>10</ns>
    <id>4193</id>
    <revision>
      <id>60616</id>
      <parentid>55832</parentid>
      <timestamp>2013-06-01T06:50:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list not equal to]] to [[Template:cpp/utility/functional/dsc not equal to]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc tclass | cpp/utility/functional/not_equal_to | function object implementing {{c|1=x != y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc not equal to void</title>
    <ns>10</ns>
    <id>13056</id>
    <revision>
      <id>66249</id>
      <timestamp>2013-11-10T00:55:57Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="182">{{dsc ptclass | cpp/utility/functional/not_equal_to_void | title=not_equal_to{{dsc small|&lt;void&gt;}} | function object implementing {{c|x !{{=}} y}} deducing argument and return types}}</text>
      <sha1>42mjwjz40gb0h2qxel1ya2ilic7pvno</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc placeholders</title>
    <ns>10</ns>
    <id>4179</id>
    <revision>
      <id>60618</id>
      <parentid>55833</parentid>
      <timestamp>2013-06-01T06:50:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list placeholders]] to [[Template:cpp/utility/functional/dsc placeholders]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="175">{{dsc const | cpp/utility/functional/placeholders | title=_1, _2, _3, _4, ... |placeholders for the unbound arguments in a {{tt|std::bind}} expression | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc plus</title>
    <ns>10</ns>
    <id>4186</id>
    <revision>
      <id>60620</id>
      <parentid>55834</parentid>
      <timestamp>2013-06-01T06:50:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list plus]] to [[Template:cpp/utility/functional/dsc plus]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc tclass | cpp/utility/functional/plus | function object implementing {{c|x + y}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc plus void</title>
    <ns>10</ns>
    <id>12878</id>
    <revision>
      <id>64076</id>
      <timestamp>2013-08-08T12:44:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="161">{{dsc ptclass | cpp/utility/functional/plus_void | title=plus{{dsc small|&lt;void&gt;}} | function object implementing {{c|x + y}} deducing argument and return types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc pointer to binary function</title>
    <ns>10</ns>
    <id>5214</id>
    <revision>
      <id>60622</id>
      <parentid>55837</parentid>
      <timestamp>2013-06-01T06:50:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list pointer to binary function]] to [[Template:cpp/utility/functional/dsc pointer to binary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc tclass | cpp/utility/functional/pointer_to_binary_function | adaptor-compatible wrapper for a pointer to binary function | notes={{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc pointer to unary function</title>
    <ns>10</ns>
    <id>5213</id>
    <revision>
      <id>60624</id>
      <parentid>55838</parentid>
      <timestamp>2013-06-01T06:50:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list pointer to unary function]] to [[Template:cpp/utility/functional/dsc pointer to unary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tclass | cpp/utility/functional/pointer_to_unary_function | adaptor-compatible wrapper for a pointer to unary function | notes={{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc ptr fun</title>
    <ns>10</ns>
    <id>5206</id>
    <revision>
      <id>60626</id>
      <parentid>55841</parentid>
      <timestamp>2013-06-01T06:50:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list ptr fun]] to [[Template:cpp/utility/functional/dsc ptr fun]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="157">{{dsc tfun | cpp/utility/functional/ptr_fun | creates an adaptor-compatible function object wrapper from a pointer to function | notes={{mark deprecated}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc ref</title>
    <ns>10</ns>
    <id>4184</id>
    <revision>
      <id>60628</id>
      <parentid>55842</parentid>
      <timestamp>2013-06-01T06:50:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list ref]] to [[Template:cpp/utility/functional/dsc ref]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="183">{{dsc tfun  | cpp/utility/functional/ref | title=ref&lt;br&gt;cref | creates a {{lc|std::reference_wrapper}} with a type deduced from its argument | notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc reference wrapper</title>
    <ns>10</ns>
    <id>4183</id>
    <revision>
      <id>60630</id>
      <parentid>55843</parentid>
      <timestamp>2013-06-01T06:50:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list reference wrapper]] to [[Template:cpp/utility/functional/dsc reference wrapper]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc tclass | cpp/utility/functional/reference_wrapper | {{concept|CopyConstructible}} and {{concept|CopyAssignable}} reference wrapper | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc unary function</title>
    <ns>10</ns>
    <id>5208</id>
    <revision>
      <id>60632</id>
      <parentid>55846</parentid>
      <timestamp>2013-06-01T06:50:42Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list unary function]] to [[Template:cpp/utility/functional/dsc unary function]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc tclass | cpp/utility/functional/unary_function | adaptor-compatible unary function base class | notes={{mark deprecated}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/dsc unary negate</title>
    <ns>10</ns>
    <id>4172</id>
    <revision>
      <id>60634</id>
      <parentid>55847</parentid>
      <timestamp>2013-06-01T06:50:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/dcl list unary negate]] to [[Template:cpp/utility/functional/dsc unary negate]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc tclass | cpp/utility/functional/unary_negate | wrapper function object returning the complement of the unary predicate it holds }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/equal to/dcl list operator()</title>
    <ns>10</ns>
    <id>12487</id>
    <redirect title="Template:cpp/utility/functional/equal to/dsc operator()" />
    <revision>
      <id>60639</id>
      <timestamp>2013-06-01T06:50:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/equal to/dcl list operator()]] to [[Template:cpp/utility/functional/equal to/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/utility/functional/equal to/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/equal to/dsc operator()</title>
    <ns>10</ns>
    <id>8836</id>
    <revision>
      <id>60638</id>
      <parentid>55851</parentid>
      <timestamp>2013-06-01T06:50:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/equal to/dcl list operator()]] to [[Template:cpp/utility/functional/equal to/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/utility/functional/equal_to | title=operator() | inlinemem=true | checks if the arguments are equal}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/equal to/title</title>
    <ns>10</ns>
    <id>8556</id>
    <revision>
      <id>31716</id>
      <timestamp>2012-06-06T20:41:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=equal_to::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list assign</title>
    <ns>10</ns>
    <id>12488</id>
    <redirect title="Template:cpp/utility/functional/function/dsc assign" />
    <revision>
      <id>60641</id>
      <timestamp>2013-06-01T06:50:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list assign]] to [[Template:cpp/utility/functional/function/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/utility/functional/function/dsc assign]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list constructor</title>
    <ns>10</ns>
    <id>12489</id>
    <redirect title="Template:cpp/utility/functional/function/dsc constructor" />
    <revision>
      <id>60643</id>
      <timestamp>2013-06-01T06:50:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list constructor]] to [[Template:cpp/utility/functional/function/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">#REDIRECT [[Template:cpp/utility/functional/function/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list destructor</title>
    <ns>10</ns>
    <id>12490</id>
    <redirect title="Template:cpp/utility/functional/function/dsc destructor" />
    <revision>
      <id>60645</id>
      <timestamp>2013-06-01T06:50:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list destructor]] to [[Template:cpp/utility/functional/function/dsc destructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/utility/functional/function/dsc destructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list operator()</title>
    <ns>10</ns>
    <id>12491</id>
    <redirect title="Template:cpp/utility/functional/function/dsc operator()" />
    <revision>
      <id>60647</id>
      <timestamp>2013-06-01T06:50:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list operator()]] to [[Template:cpp/utility/functional/function/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="69">#REDIRECT [[Template:cpp/utility/functional/function/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list operator=</title>
    <ns>10</ns>
    <id>12492</id>
    <redirect title="Template:cpp/utility/functional/function/dsc operator=" />
    <revision>
      <id>60649</id>
      <timestamp>2013-06-01T06:50:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list operator=]] to [[Template:cpp/utility/functional/function/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/function/dsc operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list operator bool</title>
    <ns>10</ns>
    <id>12493</id>
    <redirect title="Template:cpp/utility/functional/function/dsc operator bool" />
    <revision>
      <id>60651</id>
      <timestamp>2013-06-01T06:50:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list operator bool]] to [[Template:cpp/utility/functional/function/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">#REDIRECT [[Template:cpp/utility/functional/function/dsc operator bool]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list swap</title>
    <ns>10</ns>
    <id>12494</id>
    <redirect title="Template:cpp/utility/functional/function/dsc swap" />
    <revision>
      <id>60653</id>
      <timestamp>2013-06-01T06:50:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list swap]] to [[Template:cpp/utility/functional/function/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="63">#REDIRECT [[Template:cpp/utility/functional/function/dsc swap]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list swap2</title>
    <ns>10</ns>
    <id>12495</id>
    <redirect title="Template:cpp/utility/functional/function/dsc swap2" />
    <revision>
      <id>60655</id>
      <timestamp>2013-06-01T06:50:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list swap2]] to [[Template:cpp/utility/functional/function/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="64">#REDIRECT [[Template:cpp/utility/functional/function/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list target</title>
    <ns>10</ns>
    <id>12496</id>
    <redirect title="Template:cpp/utility/functional/function/dsc target" />
    <revision>
      <id>60657</id>
      <timestamp>2013-06-01T06:50:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list target]] to [[Template:cpp/utility/functional/function/dsc target]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/utility/functional/function/dsc target]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list target type</title>
    <ns>10</ns>
    <id>12497</id>
    <redirect title="Template:cpp/utility/functional/function/dsc target type" />
    <revision>
      <id>60659</id>
      <timestamp>2013-06-01T06:51:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list target type]] to [[Template:cpp/utility/functional/function/dsc target type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="70">#REDIRECT [[Template:cpp/utility/functional/function/dsc target type]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dcl list uses allocator</title>
    <ns>10</ns>
    <id>12498</id>
    <redirect title="Template:cpp/utility/functional/function/dsc uses allocator" />
    <revision>
      <id>60661</id>
      <timestamp>2013-06-01T06:51:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list uses allocator]] to [[Template:cpp/utility/functional/function/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">#REDIRECT [[Template:cpp/utility/functional/function/dsc uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc assign</title>
    <ns>10</ns>
    <id>5504</id>
    <revision>
      <id>60640</id>
      <parentid>55854</parentid>
      <timestamp>2013-06-01T06:50:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list assign]] to [[Template:cpp/utility/functional/function/dsc assign]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">{{dsc mem fun | cpp/utility/functional/function/assign | assigns a new target}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc constructor</title>
    <ns>10</ns>
    <id>5501</id>
    <revision>
      <id>61945</id>
      <parentid>60642</parentid>
      <timestamp>2013-06-11T10:50:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem ctor | cpp/utility/functional/function/function | constructs a new {{tt|std::function}} instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc destructor</title>
    <ns>10</ns>
    <id>5502</id>
    <revision>
      <id>61946</id>
      <parentid>60644</parentid>
      <timestamp>2013-06-11T10:50:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fmt</comment>
      <text xml:space="preserve" bytes="103">{{dsc mem dtor | cpp/utility/functional/function/~function | destroys a {{tt|std::function}} instance}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc operator()</title>
    <ns>10</ns>
    <id>5506</id>
    <revision>
      <id>60646</id>
      <parentid>55861</parentid>
      <timestamp>2013-06-01T06:50:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list operator()]] to [[Template:cpp/utility/functional/function/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="81">{{dsc mem fun | cpp/utility/functional/function/operator() | invokes the target}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc operator=</title>
    <ns>10</ns>
    <id>5503</id>
    <revision>
      <id>61950</id>
      <parentid>60648</parentid>
      <timestamp>2013-06-11T11:16:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="86">{{dsc mem fun | cpp/utility/functional/function/operator{{=}} | assigns a new target}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc operator bool</title>
    <ns>10</ns>
    <id>5505</id>
    <revision>
      <id>60650</id>
      <parentid>55863</parentid>
      <timestamp>2013-06-01T06:50:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list operator bool]] to [[Template:cpp/utility/functional/function/dsc operator bool]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc mem fun | cpp/utility/functional/function/operator_bool | title=operator bool | checks if a valid target is contained}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc operator cmp</title>
    <ns>10</ns>
    <id>12658</id>
    <revision>
      <id>61421</id>
      <timestamp>2013-06-06T00:14:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="151">{{dsc tfun | cpp/utility/functional/function/operator_cmp | title=operator==&lt;br&gt;operator!= | compares an {{lc|std::function}} with {{c|std::nullptr}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc swap</title>
    <ns>10</ns>
    <id>5509</id>
    <revision>
      <id>60652</id>
      <parentid>55866</parentid>
      <timestamp>2013-06-01T06:50:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list swap]] to [[Template:cpp/utility/functional/function/dsc swap]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="75">{{dsc mem fun | cpp/utility/functional/function/swap | swaps the contents}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc swap2</title>
    <ns>10</ns>
    <id>3446</id>
    <revision>
      <id>60654</id>
      <parentid>55867</parentid>
      <timestamp>2013-06-01T06:50:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list swap2]] to [[Template:cpp/utility/functional/function/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="167">{{dsc tfun | cpp/utility/functional/function/swap2 | title=std::swap{{dsc small|(std::function)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc target</title>
    <ns>10</ns>
    <id>5508</id>
    <revision>
      <id>60656</id>
      <parentid>55870</parentid>
      <timestamp>2013-06-01T06:50:59Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list target]] to [[Template:cpp/utility/functional/function/dsc target]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="123">{{dsc mem fun | cpp/utility/functional/function/target | obtains a pointer to the stored target of a {{lc|std::function}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc target type</title>
    <ns>10</ns>
    <id>5507</id>
    <revision>
      <id>60658</id>
      <parentid>55871</parentid>
      <timestamp>2013-06-01T06:51:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list target type]] to [[Template:cpp/utility/functional/function/dsc target type]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem fun | cpp/utility/functional/function/target_type | obtains the {{c|typeid}} of the stored target of a {{lc|std::function}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/dsc uses allocator</title>
    <ns>10</ns>
    <id>3388</id>
    <revision>
      <id>60660</id>
      <parentid>55872</parentid>
      <timestamp>2013-06-01T06:51:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/function/dcl list uses allocator]] to [[Template:cpp/utility/functional/function/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="200">{{dsc ptclass | cpp/utility/functional/function/uses_allocator | title=std::uses_allocator{{dsc small|&lt;std::function&gt;}} | specializes the {{lc|std::uses_allocator}} type trait | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/navbar</title>
    <ns>10</ns>
    <id>3448</id>
    <revision>
      <id>40048</id>
      <parentid>35976</parentid>
      <timestamp>2012-09-28T20:21:33Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="372">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/functional/navbar heading
|content3 = cpp/utility/functional/navbar content

|heading4 = cpp/utility/functional/function/navbar heading
|content4 = cpp/utility/functional/function/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/navbar content</title>
    <ns>10</ns>
    <id>3450</id>
    <revision>
      <id>55873</id>
      <parentid>35382</parentid>
      <timestamp>2013-06-01T05:28:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="903">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/functional/function/function}}
{{nv mem ln | cpp/utility/functional/function/~function}}
{{nv mem ln | cpp/utility/functional/function/operator{{=}}}}
{{nv mem ln | cpp/utility/functional/function/swap}}
{{nv mem ln | cpp/utility/functional/function/assign}}
{{nv mem ln | cpp/utility/functional/function/operator_bool|operator bool}}
{{nv mem ln | cpp/utility/functional/function/operator()}}
{{nv mem ln | cpp/utility/functional/function/target_type}}
{{nv mem ln | cpp/utility/functional/function/target}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/utility/functional/function/operator_cmp|operator{{==}}|operator!{{=}}}}
{{nv ln | cpp/utility/functional/function/swap2|std::swap(std::function)}}
{{nv h1 | Helper classes}}
{{nv ln | cpp/utility/functional/function/uses_allocator|std::uses_allocator&lt;std::function&gt;}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/navbar heading</title>
    <ns>10</ns>
    <id>3449</id>
    <revision>
      <id>48041</id>
      <parentid>35977</parentid>
      <timestamp>2013-05-18T18:00:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="55">{{ltt | cpp/utility/functional/function|std::function}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/function/title</title>
    <ns>10</ns>
    <id>5230</id>
    <revision>
      <id>19058</id>
      <timestamp>2012-02-22T21:52:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="105">&lt;onlyinclude&gt;{{cpp/title | n=function::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater/dcl list operator()</title>
    <ns>10</ns>
    <id>12499</id>
    <redirect title="Template:cpp/utility/functional/greater/dsc operator()" />
    <revision>
      <id>60663</id>
      <timestamp>2013-06-01T06:51:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/greater/dcl list operator()]] to [[Template:cpp/utility/functional/greater/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/greater/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater/dsc operator()</title>
    <ns>10</ns>
    <id>8838</id>
    <revision>
      <id>60662</id>
      <parentid>55876</parentid>
      <timestamp>2013-06-01T06:51:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/greater/dcl list operator()]] to [[Template:cpp/utility/functional/greater/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc mem fun | cpp/utility/functional/greater | title=operator() | inlinemem=true | checks if the first argument is greater than the second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater/title</title>
    <ns>10</ns>
    <id>8583</id>
    <revision>
      <id>31744</id>
      <timestamp>2012-06-06T20:46:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=greater::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater equal/dcl list operator()</title>
    <ns>10</ns>
    <id>12500</id>
    <redirect title="Template:cpp/utility/functional/greater equal/dsc operator()" />
    <revision>
      <id>60665</id>
      <timestamp>2013-06-01T06:51:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/greater equal/dcl list operator()]] to [[Template:cpp/utility/functional/greater equal/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="74">#REDIRECT [[Template:cpp/utility/functional/greater equal/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater equal/dsc operator()</title>
    <ns>10</ns>
    <id>8840</id>
    <revision>
      <id>60664</id>
      <parentid>55877</parentid>
      <timestamp>2013-06-01T06:51:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/greater equal/dcl list operator()]] to [[Template:cpp/utility/functional/greater equal/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="160">{{dsc mem fun | cpp/utility/functional/greater_equal | title=operator() | inlinemem=true | checks if the first argument is greater than or equal to the second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/greater equal/title</title>
    <ns>10</ns>
    <id>8580</id>
    <revision>
      <id>31741</id>
      <timestamp>2012-06-06T20:46:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="110">&lt;onlyinclude&gt;{{cpp/title | n=greater_equal::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/is transparent note</title>
    <ns>10</ns>
    <id>13065</id>
    <revision>
      <id>66269</id>
      <timestamp>2013-11-10T01:32:16Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="484">The member type {{tt|is_transparent}} indicates to the caller that this function object is a ''transparent'' function object: it accepts arguments of arbitrary types and uses perfect forwarding, which avoids unnecessary copying and conversion when the function object is used in heterogeneous context, or with rvalue arguments. In particular, template functions such as {{lc|std::set::find}} and {{lc|std::set::lower_bound}} make use of this member type on their {{tt|Compare}} types.</text>
      <sha1>kzz3muiyei9we8vqyo02ar7dlwy5611</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less/dcl list operator()</title>
    <ns>10</ns>
    <id>12501</id>
    <redirect title="Template:cpp/utility/functional/less/dsc operator()" />
    <revision>
      <id>60667</id>
      <timestamp>2013-06-01T06:51:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/less/dcl list operator()]] to [[Template:cpp/utility/functional/less/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/utility/functional/less/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less/dsc operator()</title>
    <ns>10</ns>
    <id>8839</id>
    <revision>
      <id>60666</id>
      <parentid>55880</parentid>
      <timestamp>2013-06-01T06:51:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/less/dcl list operator()]] to [[Template:cpp/utility/functional/less/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="136">{{dsc mem fun | cpp/utility/functional/less | title=operator() | inlinemem=true | checks if the first argument is less than the second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less/title</title>
    <ns>10</ns>
    <id>8577</id>
    <revision>
      <id>31738</id>
      <timestamp>2012-06-06T20:45:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=less::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="101">&lt;onlyinclude&gt;{{cpp/title | n=less::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less equal/dcl list operator()</title>
    <ns>10</ns>
    <id>12502</id>
    <redirect title="Template:cpp/utility/functional/less equal/dsc operator()" />
    <revision>
      <id>60669</id>
      <timestamp>2013-06-01T06:51:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/less equal/dcl list operator()]] to [[Template:cpp/utility/functional/less equal/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">#REDIRECT [[Template:cpp/utility/functional/less equal/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less equal/dsc operator()</title>
    <ns>10</ns>
    <id>8841</id>
    <revision>
      <id>60668</id>
      <parentid>55881</parentid>
      <timestamp>2013-06-01T06:51:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/less equal/dcl list operator()]] to [[Template:cpp/utility/functional/less equal/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="154">{{dsc mem fun | cpp/utility/functional/less_equal | title=operator() | inlinemem=true | checks if the first argument is less than or equal to the second}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/less equal/title</title>
    <ns>10</ns>
    <id>8574</id>
    <revision>
      <id>31735</id>
      <timestamp>2012-06-06T20:45:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=less_equal::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical and/dcl list operator()</title>
    <ns>10</ns>
    <id>12503</id>
    <redirect title="Template:cpp/utility/functional/logical and/dsc operator()" />
    <revision>
      <id>60671</id>
      <timestamp>2013-06-01T06:51:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/logical and/dcl list operator()]] to [[Template:cpp/utility/functional/logical and/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">#REDIRECT [[Template:cpp/utility/functional/logical and/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical and/dsc operator()</title>
    <ns>10</ns>
    <id>8842</id>
    <revision>
      <id>60670</id>
      <parentid>55882</parentid>
      <timestamp>2013-06-01T06:51:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/logical and/dcl list operator()]] to [[Template:cpp/utility/functional/logical and/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="135">{{dsc mem fun | cpp/utility/functional/logical_and | title=operator() | inlinemem=true | returns the logical AND of the two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical and/title</title>
    <ns>10</ns>
    <id>8572</id>
    <revision>
      <id>31733</id>
      <timestamp>2012-06-06T20:45:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=logical_and::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical not/dcl list operator()</title>
    <ns>10</ns>
    <id>12504</id>
    <redirect title="Template:cpp/utility/functional/logical not/dsc operator()" />
    <revision>
      <id>60673</id>
      <timestamp>2013-06-01T06:51:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/logical not/dcl list operator()]] to [[Template:cpp/utility/functional/logical not/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">#REDIRECT [[Template:cpp/utility/functional/logical not/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical not/dsc operator()</title>
    <ns>10</ns>
    <id>8844</id>
    <revision>
      <id>60672</id>
      <parentid>55885</parentid>
      <timestamp>2013-06-01T06:51:12Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/logical not/dcl list operator()]] to [[Template:cpp/utility/functional/logical not/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="130">{{dsc mem fun | cpp/utility/functional/logical_not | title=operator() | inlinemem=true | returns the logical NOT of the argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical not/title</title>
    <ns>10</ns>
    <id>8571</id>
    <revision>
      <id>31732</id>
      <timestamp>2012-06-06T20:45:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{cpp/title | n=logical_not::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical or/dcl list operator()</title>
    <ns>10</ns>
    <id>12505</id>
    <redirect title="Template:cpp/utility/functional/logical or/dsc operator()" />
    <revision>
      <id>60675</id>
      <timestamp>2013-06-01T06:51:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/logical or/dcl list operator()]] to [[Template:cpp/utility/functional/logical or/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">#REDIRECT [[Template:cpp/utility/functional/logical or/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical or/dsc operator()</title>
    <ns>10</ns>
    <id>8843</id>
    <revision>
      <id>60674</id>
      <parentid>55886</parentid>
      <timestamp>2013-06-01T06:51:13Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/logical or/dcl list operator()]] to [[Template:cpp/utility/functional/logical or/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="133">{{dsc mem fun | cpp/utility/functional/logical_or | title=operator() | inlinemem=true | returns the logical OR of the two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/logical or/title</title>
    <ns>10</ns>
    <id>8568</id>
    <revision>
      <id>31729</id>
      <timestamp>2012-06-06T20:45:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=logical_or::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/minus/dcl list operator()</title>
    <ns>10</ns>
    <id>12506</id>
    <redirect title="Template:cpp/utility/functional/minus/dsc operator()" />
    <revision>
      <id>60677</id>
      <timestamp>2013-06-01T06:51:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/minus/dcl list operator()]] to [[Template:cpp/utility/functional/minus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="66">#REDIRECT [[Template:cpp/utility/functional/minus/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/minus/dsc operator()</title>
    <ns>10</ns>
    <id>8831</id>
    <revision>
      <id>60676</id>
      <parentid>55891</parentid>
      <timestamp>2013-06-01T06:51:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/minus/dcl list operator()]] to [[Template:cpp/utility/functional/minus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc mem fun | cpp/utility/functional/minus | title=operator() | inlinemem=true | returns the difference between two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/minus/title</title>
    <ns>10</ns>
    <id>8566</id>
    <revision>
      <id>31727</id>
      <timestamp>2012-06-06T20:44:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=minus::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/modulus/dcl list operator()</title>
    <ns>10</ns>
    <id>12507</id>
    <redirect title="Template:cpp/utility/functional/modulus/dsc operator()" />
    <revision>
      <id>60679</id>
      <timestamp>2013-06-01T06:51:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/modulus/dcl list operator()]] to [[Template:cpp/utility/functional/modulus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="68">#REDIRECT [[Template:cpp/utility/functional/modulus/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/modulus/dsc operator()</title>
    <ns>10</ns>
    <id>8834</id>
    <revision>
      <id>60678</id>
      <parentid>55898</parentid>
      <timestamp>2013-06-01T06:51:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/modulus/dcl list operator()]] to [[Template:cpp/utility/functional/modulus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="172">{{dsc mem fun | cpp/utility/functional/modulus | title=operator() | inlinemem=true | returns the remainder from the division of the first argument by the second argument }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/modulus/title</title>
    <ns>10</ns>
    <id>8563</id>
    <revision>
      <id>31724</id>
      <timestamp>2012-06-06T20:44:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;{{cpp/title | n=modulus::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/multiplies/dcl list operator()</title>
    <ns>10</ns>
    <id>12508</id>
    <redirect title="Template:cpp/utility/functional/multiplies/dsc operator()" />
    <revision>
      <id>60681</id>
      <timestamp>2013-06-01T06:51:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/multiplies/dcl list operator()]] to [[Template:cpp/utility/functional/multiplies/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">#REDIRECT [[Template:cpp/utility/functional/multiplies/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/multiplies/dsc operator()</title>
    <ns>10</ns>
    <id>8832</id>
    <revision>
      <id>60680</id>
      <parentid>55899</parentid>
      <timestamp>2013-06-01T06:51:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/multiplies/dcl list operator()]] to [[Template:cpp/utility/functional/multiplies/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="126">{{dsc mem fun | cpp/utility/functional/multiplies | title=operator() | inlinemem=true | returns the product of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/multiplies/title</title>
    <ns>10</ns>
    <id>8560</id>
    <revision>
      <id>31721</id>
      <timestamp>2012-06-06T20:43:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=multiplies::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/navbar</title>
    <ns>10</ns>
    <id>2358</id>
    <revision>
      <id>40049</id>
      <parentid>36024</parentid>
      <timestamp>2012-09-28T20:21:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="253">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/functional/navbar heading
|content3 = cpp/utility/functional/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/navbar content</title>
    <ns>10</ns>
    <id>2473</id>
    <revision>
      <id>71938</id>
      <parentid>66282</parentid>
      <timestamp>2014-07-02T13:48:18Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>-visible empty line</comment>
      <text xml:space="preserve" bytes="3271">{{nv begin}}

{{nv h2 | Function wrappers }}
{{nv ln | cpp/utility/functional/function | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/mem_fn | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/bad_function_call | notes={{mark c++11}} }}

{{nv h2 | Bind }}
{{nv ln | cpp/utility/functional/bind | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/is_bind_expression | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/is_placeholder | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/placeholders | _1, _2, _3, ... | notes={{mark c++11}} }}

{{nv h2 | Reference wrappers }}
{{nv ln | cpp/utility/functional/reference_wrapper | notes={{mark c++11}} }}
{{nv ln | cpp/utility/functional/ref |ref|cref| notes={{mark c++11}}&lt;br&gt;{{mark c++11}}}}

{{nv h2 | Operator wrappers }}
{{nv col begin}}
{{nv ln | cpp/utility/functional/plus }}
{{nv ln | cpp/utility/functional/minus }}
{{nv ln | cpp/utility/functional/negate }}
{{nv ln | cpp/utility/functional/multiplies }}
{{nv ln | cpp/utility/functional/divides }}
{{nv ln | cpp/utility/functional/modulus }}
{{nv ln | cpp/utility/functional/logical_and }}
{{nv ln | cpp/utility/functional/logical_or }}
{{nv ln | cpp/utility/functional/logical_not }}
{{nv col next}}
{{nv ln | cpp/utility/functional/equal_to }}
{{nv ln | cpp/utility/functional/not_equal_to }}
{{nv ln | cpp/utility/functional/greater }}
{{nv ln | cpp/utility/functional/less }}
{{nv ln | cpp/utility/functional/greater_equal }}
{{nv ln | cpp/utility/functional/less_equal }}
{{nv ln | cpp/utility/functional/bit_and }}
{{nv ln | cpp/utility/functional/bit_or }}
{{nv ln | cpp/utility/functional/bit_xor }}
{{nv ln | cpp/utility/functional/bit_not |  notes={{mark c++14}}}}
{{nv col end}}

{{nv h2 | Negators }}
{{nv col begin}}
{{nv ln | cpp/utility/functional/unary_negate}}
{{nv ln | cpp/utility/functional/binary_negate}}
{{nv col next}}
{{nv ln | cpp/utility/functional/not1}}
{{nv ln | cpp/utility/functional/not2}}
{{nv col end}}

{{nv h2 | Deprecated binders and adaptors }}
{{nv ln | cpp/utility/functional/unary_function | notes={{mark deprecated}} }}
{{nv ln | cpp/utility/functional/binary_function | notes={{mark deprecated}} }}

{{nv ln | cpp/utility/functional/ptr_fun | notes={{mark deprecated}} }}
{{nv ln | cpp/utility/functional/pointer_to_unary_function | notes={{mark deprecated}} }}
{{nv ln | cpp/utility/functional/pointer_to_binary_function | notes={{mark deprecated}} }}

{{nv ln | cpp/utility/functional/mem_fun | notes={{mark deprecated}} }}
{{nv ln | cpp/utility/functional/mem_fun_t | mem_fun_t | mem_fun1_t | const_mem_fun_t | const_mem_fun1_t | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}

{{nv ln | cpp/utility/functional/mem_fun_ref | notes={{mark deprecated}} }}
{{nv ln | cpp/utility/functional/mem_fun_ref_t | mem_fun_ref_t | mem_fun1_ref_t | const_mem_fun_ref_t | const_mem_fun1_ref_t | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}

{{nv ln | cpp/utility/functional/binder12 | binder1st | binder2nd | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}
{{nv ln | cpp/utility/functional/bind12 | bind1st | bind2nd | notes={{mark deprecated}}&lt;br&gt;{{mark deprecated}} }}

{{nv end}}</text>
      <sha1>6zqyuwp8i5luhf6y3mxim1a4nd19vke</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/navbar heading</title>
    <ns>10</ns>
    <id>2359</id>
    <revision>
      <id>35982</id>
      <parentid>5351</parentid>
      <timestamp>2012-06-15T22:36:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/sidebar heading]] to [[Template:cpp/utility/functional/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="45">[[cpp/utility/functional | Function objects]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/negate/dcl list operator()</title>
    <ns>10</ns>
    <id>12509</id>
    <redirect title="Template:cpp/utility/functional/negate/dsc operator()" />
    <revision>
      <id>60683</id>
      <timestamp>2013-06-01T06:51:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/negate/dcl list operator()]] to [[Template:cpp/utility/functional/negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/utility/functional/negate/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/negate/dsc operator()</title>
    <ns>10</ns>
    <id>8835</id>
    <revision>
      <id>60682</id>
      <parentid>55905</parentid>
      <timestamp>2013-06-01T06:51:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/negate/dcl list operator()]] to [[Template:cpp/utility/functional/negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/utility/functional/negate | title=operator() | inlinemem=true | returns the negation of the argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/negate/title</title>
    <ns>10</ns>
    <id>8557</id>
    <revision>
      <id>31717</id>
      <timestamp>2012-06-06T20:41:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;{{cpp/title | n=negate::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/not equal to/dcl list operator()</title>
    <ns>10</ns>
    <id>12510</id>
    <redirect title="Template:cpp/utility/functional/not equal to/dsc operator()" />
    <revision>
      <id>60685</id>
      <timestamp>2013-06-01T06:51:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/not equal to/dcl list operator()]] to [[Template:cpp/utility/functional/not equal to/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">#REDIRECT [[Template:cpp/utility/functional/not equal to/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/not equal to/dsc operator()</title>
    <ns>10</ns>
    <id>8837</id>
    <revision>
      <id>60684</id>
      <parentid>55906</parentid>
      <timestamp>2013-06-01T06:51:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/not equal to/dcl list operator()]] to [[Template:cpp/utility/functional/not equal to/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="129">{{dsc mem fun | cpp/utility/functional/not_equal_to | title=operator() | inlinemem=true | checks if the arguments are not equal}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/not equal to/title</title>
    <ns>10</ns>
    <id>8582</id>
    <revision>
      <id>31743</id>
      <timestamp>2012-06-06T20:46:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=not_equal_to::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/plus/dcl list operator()</title>
    <ns>10</ns>
    <id>12511</id>
    <redirect title="Template:cpp/utility/functional/plus/dsc operator()" />
    <revision>
      <id>60687</id>
      <timestamp>2013-06-01T06:51:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/plus/dcl list operator()]] to [[Template:cpp/utility/functional/plus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="65">#REDIRECT [[Template:cpp/utility/functional/plus/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/plus/dsc operator()</title>
    <ns>10</ns>
    <id>8830</id>
    <revision>
      <id>60686</id>
      <parentid>55909</parentid>
      <timestamp>2013-06-01T06:51:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/plus/dcl list operator()]] to [[Template:cpp/utility/functional/plus/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc mem fun | cpp/utility/functional/plus | title=operator() | inlinemem=true | returns the sum of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/plus/title</title>
    <ns>10</ns>
    <id>8579</id>
    <revision>
      <id>31745</id>
      <parentid>31740</parentid>
      <timestamp>2012-06-06T20:46:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="101">&lt;onlyinclude&gt;{{cpp/title | n=plus::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/plus void/dsc operator()</title>
    <ns>10</ns>
    <id>12879</id>
    <revision>
      <id>64079</id>
      <timestamp>2013-08-08T12:46:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="121">{{dsc mem fun | cpp/utility/functional/plus_void | title=operator() | inlinemem=true | returns the sum of two arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/plus void/title</title>
    <ns>10</ns>
    <id>12880</id>
    <revision>
      <id>64080</id>
      <timestamp>2013-08-08T12:48:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="107">&lt;onlyinclude&gt;{{cpp/title | n=plus&lt;void&gt;::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/pointer order</title>
    <ns>10</ns>
    <id>5051</id>
    <revision>
      <id>24859</id>
      <parentid>18284</parentid>
      <timestamp>2012-04-20T06:38:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;{{cpp|&quot; to &quot;{{c|&quot;</comment>
      <text xml:space="preserve" bytes="180">If the built-in {{c|{{{1|}}} }} does not provide total order for pointers, a partial specialization of {{tt|{{{2|}}} }} for pointer types is provided, which guarantees total order.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dcl list constructor</title>
    <ns>10</ns>
    <id>12512</id>
    <redirect title="Template:cpp/utility/functional/reference wrapper/dsc constructor" />
    <revision>
      <id>60689</id>
      <timestamp>2013-06-01T06:51:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list constructor]] to [[Template:cpp/utility/functional/reference wrapper/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="79">#REDIRECT [[Template:cpp/utility/functional/reference wrapper/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dcl list get</title>
    <ns>10</ns>
    <id>12513</id>
    <redirect title="Template:cpp/utility/functional/reference wrapper/dsc get" />
    <revision>
      <id>60691</id>
      <timestamp>2013-06-01T06:51:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list get]] to [[Template:cpp/utility/functional/reference wrapper/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">#REDIRECT [[Template:cpp/utility/functional/reference wrapper/dsc get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dcl list operator()</title>
    <ns>10</ns>
    <id>12514</id>
    <redirect title="Template:cpp/utility/functional/reference wrapper/dsc operator()" />
    <revision>
      <id>60693</id>
      <timestamp>2013-06-01T06:51:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list operator()]] to [[Template:cpp/utility/functional/reference wrapper/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="78">#REDIRECT [[Template:cpp/utility/functional/reference wrapper/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dcl list operator=</title>
    <ns>10</ns>
    <id>12515</id>
    <redirect title="Template:cpp/utility/functional/reference wrapper/dsc operator=" />
    <revision>
      <id>60695</id>
      <timestamp>2013-06-01T06:51:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list operator=]] to [[Template:cpp/utility/functional/reference wrapper/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="77">#REDIRECT [[Template:cpp/utility/functional/reference wrapper/dsc operator=]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dsc constructor</title>
    <ns>10</ns>
    <id>5463</id>
    <revision>
      <id>60688</id>
      <parentid>55912</parentid>
      <timestamp>2013-06-01T06:51:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list constructor]] to [[Template:cpp/utility/functional/reference wrapper/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc mem ctor | cpp/utility/functional/reference_wrapper/reference_wrapper | stores a reference in a new {{lc|std::reference_wrapper}} object}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dsc get</title>
    <ns>10</ns>
    <id>5465</id>
    <revision>
      <id>60690</id>
      <parentid>55913</parentid>
      <timestamp>2013-06-01T06:51:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list get]] to [[Template:cpp/utility/functional/reference wrapper/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="122">{{dsc mem fun | cpp/utility/functional/reference_wrapper/get | title=get&lt;br&gt;operator T&amp; | accesses the stored reference }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dsc operator()</title>
    <ns>10</ns>
    <id>5466</id>
    <revision>
      <id>60692</id>
      <parentid>55916</parentid>
      <timestamp>2013-06-01T06:51:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list operator()]] to [[Template:cpp/utility/functional/reference wrapper/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc mem fun | cpp/utility/functional/reference_wrapper/operator() | calls the stored function }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/dsc operator=</title>
    <ns>10</ns>
    <id>5464</id>
    <revision>
      <id>60694</id>
      <parentid>55917</parentid>
      <timestamp>2013-06-01T06:51:29Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/reference wrapper/dcl list operator=]] to [[Template:cpp/utility/functional/reference wrapper/dsc operator=]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc mem fun | cpp/utility/functional/reference_wrapper/operator{{=}} | rebinds a {{lc|std::reference_wrapper}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/navbar</title>
    <ns>10</ns>
    <id>5220</id>
    <revision>
      <id>40050</id>
      <parentid>36025</parentid>
      <timestamp>2012-09-28T20:21:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="390">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/functional/navbar heading
|content3 = cpp/utility/functional/navbar content

|heading4 = cpp/utility/functional/reference_wrapper/navbar heading
|content4 = cpp/utility/functional/reference_wrapper/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/navbar content</title>
    <ns>10</ns>
    <id>5222</id>
    <revision>
      <id>55918</id>
      <parentid>34551</parentid>
      <timestamp>2013-06-01T05:28:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="347">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/functional/reference_wrapper/reference_wrapper}}
{{nv mem ln | cpp/utility/functional/reference_wrapper/operator{{=}}}}
{{nv mem ln | cpp/utility/functional/reference_wrapper/get | get | operator T&amp;}}
{{nv mem ln | cpp/utility/functional/reference_wrapper/operator()}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/navbar heading</title>
    <ns>10</ns>
    <id>5221</id>
    <revision>
      <id>36027</id>
      <parentid>35979</parentid>
      <timestamp>2012-06-16T19:12:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+tt</comment>
      <text xml:space="preserve" bytes="73">{{ltt|cpp/utility/functional/reference_wrapper | std::reference_wrapper}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/reference wrapper/title</title>
    <ns>10</ns>
    <id>5462</id>
    <revision>
      <id>19929</id>
      <timestamp>2012-03-18T19:49:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="114">&lt;onlyinclude&gt;{{cpp/title | n=reference_wrapper::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/unary negate/dcl list operator()</title>
    <ns>10</ns>
    <id>12516</id>
    <redirect title="Template:cpp/utility/functional/unary negate/dsc operator()" />
    <revision>
      <id>60697</id>
      <timestamp>2013-06-01T06:51:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/functional/unary negate/dcl list operator()]] to [[Template:cpp/utility/functional/unary negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="73">#REDIRECT [[Template:cpp/utility/functional/unary negate/dsc operator()]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/unary negate/dsc operator()</title>
    <ns>10</ns>
    <id>8848</id>
    <revision>
      <id>60696</id>
      <parentid>55919</parentid>
      <timestamp>2013-06-01T06:51:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/functional/unary negate/dcl list operator()]] to [[Template:cpp/utility/functional/unary negate/dsc operator()]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="170">{{dsc mem fun | cpp/utility/functional/unary_negate | title=operator() | inlinemem=true | returns the logical complement of the result of a call to the stored predicate}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/functional/unary negate/title</title>
    <ns>10</ns>
    <id>8576</id>
    <revision>
      <id>31737</id>
      <timestamp>2012-06-06T20:45:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="109">&lt;onlyinclude&gt;{{cpp/title | n=unary_negate::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/hash/navbar</title>
    <ns>10</ns>
    <id>2991</id>
    <revision>
      <id>40051</id>
      <parentid>35983</parentid>
      <timestamp>2012-09-28T20:21:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/hash/navbar heading
|content3 = cpp/utility/hash/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/hash/navbar content</title>
    <ns>10</ns>
    <id>2993</id>
    <revision>
      <id>55926</id>
      <parentid>34631</parentid>
      <timestamp>2013-06-01T05:28:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="106">{{nv begin}}
{{nv mem ln | cpp/utility/hash/hash }}
{{nv mem ln | cpp/utility/hash/operator()}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/hash/navbar heading</title>
    <ns>10</ns>
    <id>2992</id>
    <revision>
      <id>48031</id>
      <parentid>35889</parentid>
      <timestamp>2013-05-18T17:58:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="34">{{ltt|cpp/utility/hash|std::hash}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list begin</title>
    <ns>10</ns>
    <id>12517</id>
    <redirect title="Template:cpp/utility/initializer list/dsc begin" />
    <revision>
      <id>60699</id>
      <timestamp>2013-06-01T06:51:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list begin]] to [[Template:cpp/utility/initializer list/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/initializer list/dsc begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list begin2</title>
    <ns>10</ns>
    <id>12518</id>
    <redirect title="Template:cpp/utility/initializer list/dsc begin2" />
    <revision>
      <id>60701</id>
      <timestamp>2013-06-01T06:51:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list begin2]] to [[Template:cpp/utility/initializer list/dsc begin2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="62">#REDIRECT [[Template:cpp/utility/initializer list/dsc begin2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list constructor</title>
    <ns>10</ns>
    <id>12519</id>
    <redirect title="Template:cpp/utility/initializer list/dsc constructor" />
    <revision>
      <id>60703</id>
      <timestamp>2013-06-01T06:51:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list constructor]] to [[Template:cpp/utility/initializer list/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">#REDIRECT [[Template:cpp/utility/initializer list/dsc constructor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list end</title>
    <ns>10</ns>
    <id>12520</id>
    <redirect title="Template:cpp/utility/initializer list/dsc end" />
    <revision>
      <id>60705</id>
      <timestamp>2013-06-01T06:51:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list end]] to [[Template:cpp/utility/initializer list/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/utility/initializer list/dsc end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list end2</title>
    <ns>10</ns>
    <id>12521</id>
    <redirect title="Template:cpp/utility/initializer list/dsc end2" />
    <revision>
      <id>60707</id>
      <timestamp>2013-06-01T06:51:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list end2]] to [[Template:cpp/utility/initializer list/dsc end2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/initializer list/dsc end2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dcl list size</title>
    <ns>10</ns>
    <id>12522</id>
    <redirect title="Template:cpp/utility/initializer list/dsc size" />
    <revision>
      <id>60709</id>
      <timestamp>2013-06-01T06:51:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list size]] to [[Template:cpp/utility/initializer list/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/initializer list/dsc size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc begin</title>
    <ns>10</ns>
    <id>8507</id>
    <revision>
      <id>60698</id>
      <parentid>55931</parentid>
      <timestamp>2013-06-01T06:51:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list begin]] to [[Template:cpp/utility/initializer list/dsc begin]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc mem fun | cpp/utility/initializer_list/begin | returns a pointer the first element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc begin2</title>
    <ns>10</ns>
    <id>3490</id>
    <revision>
      <id>60700</id>
      <parentid>55932</parentid>
      <timestamp>2013-06-01T06:51:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list begin2]] to [[Template:cpp/utility/initializer list/dsc begin2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="161">{{dsc tfun | cpp/utility/initializer_list/begin2 | title=std::begin{{dsc small|(std::initializer_list)}} | specializes {{lc|std::begin}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc constructor</title>
    <ns>10</ns>
    <id>8509</id>
    <revision>
      <id>60702</id>
      <parentid>55933</parentid>
      <timestamp>2013-06-01T06:51:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list constructor]] to [[Template:cpp/utility/initializer list/dsc constructor]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="100">{{dsc mem ctor | cpp/utility/initializer_list/initializer_list | creates an empty initializer list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc end</title>
    <ns>10</ns>
    <id>8506</id>
    <revision>
      <id>60704</id>
      <parentid>55936</parentid>
      <timestamp>2013-06-01T06:51:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list end]] to [[Template:cpp/utility/initializer list/dsc end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc mem fun | cpp/utility/initializer_list/end | returns a pointer to one past the last element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc end2</title>
    <ns>10</ns>
    <id>3488</id>
    <revision>
      <id>60706</id>
      <parentid>55937</parentid>
      <timestamp>2013-06-01T06:51:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list end2]] to [[Template:cpp/utility/initializer list/dsc end2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="155">{{dsc tfun | cpp/utility/initializer_list/end2 | title=std::end{{dsc small|(std::initializer_list)}} | specializes {{lc|std::end}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc rbegin2</title>
    <ns>10</ns>
    <id>12768</id>
    <revision>
      <id>65343</id>
      <parentid>61641</parentid>
      <timestamp>2013-09-09T20:03:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>no special crbegin for initializer_list</comment>
      <text xml:space="preserve" bytes="158">{{dsc fun | cpp/utility/initializer_list/rbegin2 | title=rbegin{{dsc small|(std::initializer_list)}} | specializes {{lc|std::rbegin}} | notes={{mark c++14}}}}</text>
      <sha1>bat6fe1jj3o662d25y2vjgrvo2xrmty</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc rend2</title>
    <ns>10</ns>
    <id>12767</id>
    <revision>
      <id>65876</id>
      <parentid>65344</parentid>
      <timestamp>2013-10-13T05:24:55Z</timestamp>
      <contributor>
        <ip>109.188.127.167</ip>
      </contributor>
      <text xml:space="preserve" bytes="152">{{dsc fun | cpp/utility/initializer_list/rend2 | title=rend{{dsc small|(std::initializer_list)}} | specializes {{lc|std::rend}} | notes={{mark c++14}}}}</text>
      <sha1>qupj923xcq7rf4b5pmd7t037nuf4747</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/dsc size</title>
    <ns>10</ns>
    <id>8508</id>
    <revision>
      <id>60708</id>
      <parentid>55940</parentid>
      <timestamp>2013-06-01T06:51:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/initializer list/dcl list size]] to [[Template:cpp/utility/initializer list/dsc size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="108">{{dsc mem fun | cpp/utility/initializer_list/size | returns the number of elements in the initializer list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/navbar</title>
    <ns>10</ns>
    <id>2362</id>
    <revision>
      <id>47771</id>
      <parentid>40052</parentid>
      <timestamp>2013-05-16T20:26:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="265">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/initializer_list/navbar heading
|content3 = cpp/utility/initializer_list/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/navbar content</title>
    <ns>10</ns>
    <id>2916</id>
    <revision>
      <id>55941</id>
      <parentid>35985</parentid>
      <timestamp>2013-06-01T05:28:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="454">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/initializer_list/initializer_list}}
{{nv h2 | Capacity}}
{{nv mem ln | cpp/utility/initializer_list/size}}
{{nv h2 | Iterators}}
{{nv mem ln | cpp/utility/initializer_list/begin}}
{{nv mem ln | cpp/utility/initializer_list/end}}
{{nv h1 | Non-member functions}}
{{nv ln | cpp/utility/initializer_list/begin2|std::begin}}
{{nv ln | cpp/utility/initializer_list/end2|std::end}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/navbar heading</title>
    <ns>10</ns>
    <id>2363</id>
    <revision>
      <id>47765</id>
      <parentid>35986</parentid>
      <timestamp>2013-05-16T20:24:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="58">{{ltt|cpp/utility/initializer_list|std::initializer_list}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/initializer list/title</title>
    <ns>10</ns>
    <id>8504</id>
    <revision>
      <id>31494</id>
      <timestamp>2012-05-31T14:15:49Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>added</comment>
      <text xml:space="preserve" bytes="113">&lt;onlyinclude&gt;{{cpp/title | n=initializer_list::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/navbar</title>
    <ns>10</ns>
    <id>79</id>
    <revision>
      <id>40053</id>
      <parentid>35994</parentid>
      <timestamp>2012-09-28T20:21:43Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="154">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/navbar content</title>
    <ns>10</ns>
    <id>2025</id>
    <revision>
      <id>55944</id>
      <parentid>35058</parentid>
      <timestamp>2013-06-01T05:28:56Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1233">{{nv begin}}
{{nv | [[cpp/types | Type support]] (basic types, RTTI, type traits) }}
{{nv | [[cpp/memory | Dynamic memory management]] }}
{{nv | [[cpp/error | Error handling]] }}
{{nv | [[cpp/utility/program | Program utilities]] }}
{{nv | [[cpp/utility/variadic | Variadic functions]] }}
{{nv | [[cpp/chrono | Date and time]] }}
{{nv | [[cpp/utility/functional | Function objects]] }}
{{nv ln | cpp/utility/initializer_list| notes={{mark c++11}}}}
{{nv ln | cpp/utility/bitset }}
{{nv ln | cpp/utility/hash | notes={{mark c++11}} }}
{{nv h2 | Relational operators}}
{{nv mem ln | cpp/utility/rel_ops/operator_cmp | operator!{{=}} | operator&gt; | operator&lt;{{=}} | operator&gt;{{=}}}}
{{nv h2 | Pairs and tuples}}
{{nv ln | cpp/utility/pair }}
{{nv ln | cpp/utility/tuple | notes={{mark c++11}} }}
{{nv ln | cpp/utility/piecewise_construct_t| notes={{mark c++11}}}}
{{nv ln | cpp/utility/piecewise_construct| notes={{mark c++11}}}}
{{nv h2 | Swap, forward and move}}
{{nv ln | cpp/algorithm/swap }}
{{nv ln | cpp/utility/forward | notes={{mark c++11}} }}
{{nv ln | cpp/utility/move | notes={{mark c++11}} }}
{{nv ln | cpp/utility/move_if_noexcept | notes={{mark c++11}} }}
{{nv ln | cpp/utility/declval | notes={{mark c++11}} }}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/navbar heading</title>
    <ns>10</ns>
    <id>80</id>
    <revision>
      <id>35965</id>
      <parentid>159</parentid>
      <timestamp>2012-06-15T22:35:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/sidebar heading]] to [[Template:cpp/utility/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="35">[[cpp/utility | Utilities library]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/optional</title>
    <ns>10</ns>
    <id>13200</id>
    <redirect title="Template:cpp/experimental/optional" />
    <revision>
      <id>68068</id>
      <timestamp>2014-03-16T20:19:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>P12 moved page [[Template:cpp/utility/optional]] to [[Template:cpp/experimental/optional]]</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/experimental/optional]]</text>
      <sha1>r52d6aw8g6hbc4yzni8s7695sz0jzec</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list get</title>
    <ns>10</ns>
    <id>12536</id>
    <redirect title="Template:cpp/utility/pair/dsc get" />
    <revision>
      <id>60737</id>
      <timestamp>2013-06-01T06:52:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list get]] to [[Template:cpp/utility/pair/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="47">#REDIRECT [[Template:cpp/utility/pair/dsc get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list make pair</title>
    <ns>10</ns>
    <id>12537</id>
    <redirect title="Template:cpp/utility/pair/dsc make pair" />
    <revision>
      <id>60739</id>
      <timestamp>2013-06-01T06:52:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list make pair]] to [[Template:cpp/utility/pair/dsc make pair]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/pair/dsc make pair]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12538</id>
    <redirect title="Template:cpp/utility/pair/dsc operator cmp" />
    <revision>
      <id>60741</id>
      <timestamp>2013-06-01T06:52:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list operator cmp]] to [[Template:cpp/utility/pair/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/pair/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list swap2</title>
    <ns>10</ns>
    <id>12539</id>
    <redirect title="Template:cpp/utility/pair/dsc swap2" />
    <revision>
      <id>60743</id>
      <timestamp>2013-06-01T06:52:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list swap2]] to [[Template:cpp/utility/pair/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="49">#REDIRECT [[Template:cpp/utility/pair/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list tuple element</title>
    <ns>10</ns>
    <id>12540</id>
    <redirect title="Template:cpp/utility/pair/dsc tuple element" />
    <revision>
      <id>60745</id>
      <timestamp>2013-06-01T06:52:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list tuple element]] to [[Template:cpp/utility/pair/dsc tuple element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/pair/dsc tuple element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dcl list tuple size</title>
    <ns>10</ns>
    <id>12541</id>
    <redirect title="Template:cpp/utility/pair/dsc tuple size" />
    <revision>
      <id>60747</id>
      <timestamp>2013-06-01T06:52:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/pair/dcl list tuple size]] to [[Template:cpp/utility/pair/dsc tuple size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/pair/dsc tuple size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc get</title>
    <ns>10</ns>
    <id>2625</id>
    <revision>
      <id>60736</id>
      <parentid>55997</parentid>
      <timestamp>2013-06-01T06:52:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list get]] to [[Template:cpp/utility/pair/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="139">{{dsc tfun | cpp/utility/pair/get | title=std::get{{dsc small|(std::pair)}} | accesses an element of a {{tt|pair}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc make pair</title>
    <ns>10</ns>
    <id>2624</id>
    <revision>
      <id>60738</id>
      <parentid>55998</parentid>
      <timestamp>2013-06-01T06:52:01Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list make pair]] to [[Template:cpp/utility/pair/dsc make pair]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="111">{{dsc tfun | cpp/utility/pair/make_pair | creates a {{tt|pair}} object of type, defined by the argument types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc operator cmp</title>
    <ns>10</ns>
    <id>2565</id>
    <revision>
      <id>60740</id>
      <parentid>55999</parentid>
      <timestamp>2013-06-01T06:52:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list operator cmp]] to [[Template:cpp/utility/pair/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="184">{{dsc tfun | cpp/utility/pair/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | lexicographically compares the values in the pair }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc swap2</title>
    <ns>10</ns>
    <id>2566</id>
    <revision>
      <id>60742</id>
      <parentid>56002</parentid>
      <timestamp>2013-06-01T06:52:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list swap2]] to [[Template:cpp/utility/pair/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="148">{{dsc tfun | cpp/utility/pair/swap2 | title=std::swap{{dsc small|(std::pair)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc tuple element</title>
    <ns>10</ns>
    <id>2627</id>
    <revision>
      <id>60744</id>
      <parentid>56003</parentid>
      <timestamp>2013-06-01T06:52:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list tuple element]] to [[Template:cpp/utility/pair/dsc tuple element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="173">{{dsc ptclass | cpp/utility/pair/tuple_element | title=std::tuple_element{{dsc small|&lt;std::pair&gt;}} | obtains the type of the elements of {{tt|pair}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/dsc tuple size</title>
    <ns>10</ns>
    <id>2626</id>
    <revision>
      <id>60746</id>
      <parentid>56006</parentid>
      <timestamp>2013-06-01T06:52:08Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/dcl list tuple size]] to [[Template:cpp/utility/pair/dsc tuple size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="152">{{dsc ptclass | cpp/utility/pair/tuple_size | title=std::tuple_size{{dsc small|&lt;std::pair&gt;}} |obtains the size of a {{tt|pair}} | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/navbar</title>
    <ns>10</ns>
    <id>2122</id>
    <revision>
      <id>47871</id>
      <parentid>40054</parentid>
      <timestamp>2013-05-17T02:13:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="241">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/pair/navbar heading
|content3 = cpp/utility/pair/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/navbar content</title>
    <ns>10</ns>
    <id>2637</id>
    <revision>
      <id>72379</id>
      <parentid>56007</parentid>
      <timestamp>2014-08-18T11:01:17Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="642">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/pair/pair}}
{{nv mem ln | cpp/utility/pair/operator{{=}}}}
{{nv mem ln | cpp/utility/pair/swap}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/utility/pair/make_pair}}
{{nv ln | cpp/utility/pair/operator_cmp | operator{{==}} | operator!{{=}} | operator&lt; | operator&lt;{{=}} | operator&gt; | operator&gt;{{=}}}}
{{nv ln | cpp/utility/pair/swap2 | std::swap}}
{{nv ln | cpp/utility/pair/get | notes={{mark c++11}}}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/utility/pair/tuple_size | notes={{mark c++11}}}}
{{nv ln | cpp/utility/pair/tuple_element | notes={{mark c++11}}}}
{{nv end}}</text>
      <sha1>ejr8p4rlny47i366gvdk7ifjsj080bg</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/navbar heading</title>
    <ns>10</ns>
    <id>2123</id>
    <revision>
      <id>35989</id>
      <parentid>4584</parentid>
      <timestamp>2012-06-15T22:36:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/pair/sidebar heading]] to [[Template:cpp/utility/pair/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="37">{{ltt| cpp/utility/pair | std::pair}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/pair/title</title>
    <ns>10</ns>
    <id>2595</id>
    <revision>
      <id>9788</id>
      <timestamp>2011-08-25T13:54:56Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=pair::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="101">&lt;onlyinclude&gt;{{cpp/title | n=pair::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list EXIT status</title>
    <ns>10</ns>
    <id>12542</id>
    <redirect title="Template:cpp/utility/program/dsc EXIT status" />
    <revision>
      <id>60749</id>
      <timestamp>2013-06-01T06:52:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list EXIT status]] to [[Template:cpp/utility/program/dsc EXIT status]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/program/dsc EXIT status]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list Exit</title>
    <ns>10</ns>
    <id>12543</id>
    <redirect title="Template:cpp/utility/program/dsc Exit" />
    <revision>
      <id>60751</id>
      <timestamp>2013-06-01T06:52:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list Exit]] to [[Template:cpp/utility/program/dsc Exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/utility/program/dsc Exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list SIG ERR</title>
    <ns>10</ns>
    <id>12544</id>
    <redirect title="Template:cpp/utility/program/dsc SIG ERR" />
    <revision>
      <id>60753</id>
      <timestamp>2013-06-01T06:52:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG ERR]] to [[Template:cpp/utility/program/dsc SIG ERR]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/program/dsc SIG ERR]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list SIG strategies</title>
    <ns>10</ns>
    <id>12545</id>
    <redirect title="Template:cpp/utility/program/dsc SIG strategies" />
    <revision>
      <id>60755</id>
      <timestamp>2013-06-01T06:52:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG strategies]] to [[Template:cpp/utility/program/dsc SIG strategies]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/program/dsc SIG strategies]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list SIG types</title>
    <ns>10</ns>
    <id>12546</id>
    <redirect title="Template:cpp/utility/program/dsc SIG types" />
    <revision>
      <id>60757</id>
      <timestamp>2013-06-01T06:52:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG types]] to [[Template:cpp/utility/program/dsc SIG types]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/program/dsc SIG types]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list abort</title>
    <ns>10</ns>
    <id>12547</id>
    <redirect title="Template:cpp/utility/program/dsc abort" />
    <revision>
      <id>60759</id>
      <timestamp>2013-06-01T06:52:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list abort]] to [[Template:cpp/utility/program/dsc abort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/utility/program/dsc abort]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list at quick exit</title>
    <ns>10</ns>
    <id>12548</id>
    <redirect title="Template:cpp/utility/program/dsc at quick exit" />
    <revision>
      <id>60761</id>
      <timestamp>2013-06-01T06:52:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list at quick exit]] to [[Template:cpp/utility/program/dsc at quick exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="60">#REDIRECT [[Template:cpp/utility/program/dsc at quick exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list atexit</title>
    <ns>10</ns>
    <id>12549</id>
    <redirect title="Template:cpp/utility/program/dsc atexit" />
    <revision>
      <id>60763</id>
      <timestamp>2013-06-01T06:52:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list atexit]] to [[Template:cpp/utility/program/dsc atexit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/program/dsc atexit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list exit</title>
    <ns>10</ns>
    <id>12550</id>
    <redirect title="Template:cpp/utility/program/dsc exit" />
    <revision>
      <id>60765</id>
      <timestamp>2013-06-01T06:52:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list exit]] to [[Template:cpp/utility/program/dsc exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/utility/program/dsc exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list getenv</title>
    <ns>10</ns>
    <id>12551</id>
    <redirect title="Template:cpp/utility/program/dsc getenv" />
    <revision>
      <id>60767</id>
      <timestamp>2013-06-01T06:52:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list getenv]] to [[Template:cpp/utility/program/dsc getenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/program/dsc getenv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list jmp buf</title>
    <ns>10</ns>
    <id>12552</id>
    <redirect title="Template:cpp/utility/program/dsc jmp buf" />
    <revision>
      <id>60769</id>
      <timestamp>2013-06-01T06:52:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list jmp buf]] to [[Template:cpp/utility/program/dsc jmp buf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/program/dsc jmp buf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list longjmp</title>
    <ns>10</ns>
    <id>12553</id>
    <redirect title="Template:cpp/utility/program/dsc longjmp" />
    <revision>
      <id>60771</id>
      <timestamp>2013-06-01T06:52:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list longjmp]] to [[Template:cpp/utility/program/dsc longjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/program/dsc longjmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list quick exit</title>
    <ns>10</ns>
    <id>12554</id>
    <redirect title="Template:cpp/utility/program/dsc quick exit" />
    <revision>
      <id>60773</id>
      <timestamp>2013-06-01T06:52:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list quick exit]] to [[Template:cpp/utility/program/dsc quick exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/program/dsc quick exit]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list raise</title>
    <ns>10</ns>
    <id>12555</id>
    <redirect title="Template:cpp/utility/program/dsc raise" />
    <revision>
      <id>60775</id>
      <timestamp>2013-06-01T06:52:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list raise]] to [[Template:cpp/utility/program/dsc raise]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="52">#REDIRECT [[Template:cpp/utility/program/dsc raise]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list setjmp</title>
    <ns>10</ns>
    <id>12556</id>
    <redirect title="Template:cpp/utility/program/dsc setjmp" />
    <revision>
      <id>60777</id>
      <timestamp>2013-06-01T06:52:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list setjmp]] to [[Template:cpp/utility/program/dsc setjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/program/dsc setjmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list signal</title>
    <ns>10</ns>
    <id>12557</id>
    <redirect title="Template:cpp/utility/program/dsc signal" />
    <revision>
      <id>60779</id>
      <timestamp>2013-06-01T06:52:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list signal]] to [[Template:cpp/utility/program/dsc signal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/program/dsc signal]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dcl list system</title>
    <ns>10</ns>
    <id>12558</id>
    <redirect title="Template:cpp/utility/program/dsc system" />
    <revision>
      <id>60781</id>
      <timestamp>2013-06-01T06:52:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/program/dcl list system]] to [[Template:cpp/utility/program/dsc system]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="53">#REDIRECT [[Template:cpp/utility/program/dsc system]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc EXIT status</title>
    <ns>10</ns>
    <id>4548</id>
    <revision>
      <id>60748</id>
      <parentid>56008</parentid>
      <timestamp>2013-06-01T06:52:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list EXIT status]] to [[Template:cpp/utility/program/dsc EXIT status]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="137">{{dsc macro const | cpp/utility/program/EXIT_status | title=EXIT_SUCCESS&lt;br&gt;EXIT_FAILURE | indicates program execution execution status}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc Exit</title>
    <ns>10</ns>
    <id>53</id>
    <revision>
      <id>60750</id>
      <parentid>56009</parentid>
      <timestamp>2013-06-01T06:52:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list Exit]] to [[Template:cpp/utility/program/dsc Exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="118">{{dsc fun | cpp/utility/program/_Exit | causes normal program termination without cleaning up |notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc SIG ERR</title>
    <ns>10</ns>
    <id>4544</id>
    <revision>
      <id>60752</id>
      <parentid>56012</parentid>
      <timestamp>2013-06-01T06:52:11Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG ERR]] to [[Template:cpp/utility/program/dsc SIG ERR]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="144">{{dsc macro const | cpp/utility/program/SIG_ERR | return value of {{ltt|cpp/utility/program/signal}} specifying that an error was encountered }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc SIG strategies</title>
    <ns>10</ns>
    <id>4543</id>
    <revision>
      <id>60754</id>
      <parentid>56013</parentid>
      <timestamp>2013-06-01T06:52:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG strategies]] to [[Template:cpp/utility/program/dsc SIG strategies]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc macro const | cpp/utility/program/SIG_strategies | title=SIG_DFL&lt;br&gt;SIG_IGN | defines signal handling strategies }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc SIG types</title>
    <ns>10</ns>
    <id>6334</id>
    <revision>
      <id>60756</id>
      <parentid>56016</parentid>
      <timestamp>2013-06-01T06:52:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list SIG types]] to [[Template:cpp/utility/program/dsc SIG types]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="142">{{dsc macro const | cpp/utility/program/SIG_types | title=SIGABRT&lt;br&gt;SIGFPE&lt;br&gt;SIGILL&lt;br&gt;SIGINT&lt;br&gt;SIGSEGV&lt;br&gt;SIGTERM | defines signal types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc abort</title>
    <ns>10</ns>
    <id>63</id>
    <revision>
      <id>60758</id>
      <parentid>56019</parentid>
      <timestamp>2013-06-01T06:52:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list abort]] to [[Template:cpp/utility/program/dsc abort]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc fun | cpp/utility/program/abort | causes abnormal program termination (without cleaning up)}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc at quick exit</title>
    <ns>10</ns>
    <id>64</id>
    <revision>
      <id>60760</id>
      <parentid>56020</parentid>
      <timestamp>2013-06-01T06:52:18Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list at quick exit]] to [[Template:cpp/utility/program/dsc at quick exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="159">{{dsc fun | cpp/utility/program/at_quick_exit | registers a function to be called on {{ltt|cpp/utility/program/quick_exit}} invocation |notes={{mark c++11}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc atexit</title>
    <ns>10</ns>
    <id>65</id>
    <revision>
      <id>64384</id>
      <parentid>60762</parentid>
      <timestamp>2013-08-15T18:52:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+lc</comment>
      <text xml:space="preserve" bytes="109">{{dsc fun | cpp/utility/program/atexit | registers a function to be called on {{lc|std::exit()}} invocation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc exit</title>
    <ns>10</ns>
    <id>66</id>
    <revision>
      <id>60764</id>
      <parentid>56028</parentid>
      <timestamp>2013-06-01T06:52:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list exit]] to [[Template:cpp/utility/program/dsc exit]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="91">{{dsc fun | cpp/utility/program/exit | causes normal program termination with cleaning up}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc getenv</title>
    <ns>10</ns>
    <id>67</id>
    <revision>
      <id>60766</id>
      <parentid>56033</parentid>
      <timestamp>2013-06-01T06:52:22Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list getenv]] to [[Template:cpp/utility/program/dsc getenv]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | cpp/utility/program/getenv | access to the list of environment variables }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc jmp buf</title>
    <ns>10</ns>
    <id>68</id>
    <revision>
      <id>60768</id>
      <parentid>56038</parentid>
      <timestamp>2013-06-01T06:52:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list jmp buf]] to [[Template:cpp/utility/program/dsc jmp buf]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="71">{{dsc typedef | cpp/utility/program/jmp_buf | execution context type }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc longjmp</title>
    <ns>10</ns>
    <id>69</id>
    <revision>
      <id>60770</id>
      <parentid>56039</parentid>
      <timestamp>2013-06-01T06:52:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list longjmp]] to [[Template:cpp/utility/program/dsc longjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="72">{{dsc fun | cpp/utility/program/longjmp | jumps to specified location }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc quick exit</title>
    <ns>10</ns>
    <id>70</id>
    <revision>
      <id>71953</id>
      <parentid>60772</parentid>
      <timestamp>2014-07-04T16:02:18Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>quick_exit() is not normal program termination</comment>
      <text xml:space="preserve" bytes="132">{{dsc fun | cpp/utility/program/quick_exit | causes quick program termination without completely cleaning up |notes={{mark c++11}}}}</text>
      <sha1>1vwmohktuxjwla58qxxeah2m7jqj441</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc raise</title>
    <ns>10</ns>
    <id>71</id>
    <revision>
      <id>60774</id>
      <parentid>56043</parentid>
      <timestamp>2013-06-01T06:52:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list raise]] to [[Template:cpp/utility/program/dsc raise]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="88">{{dsc fun | cpp/utility/program/raise | runs the signal handler for particular signal }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc setjmp</title>
    <ns>10</ns>
    <id>72</id>
    <revision>
      <id>60776</id>
      <parentid>56044</parentid>
      <timestamp>2013-06-01T06:52:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list setjmp]] to [[Template:cpp/utility/program/dsc setjmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="67">{{dsc macro fun | cpp/utility/program/setjmp | saves the context }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc signal</title>
    <ns>10</ns>
    <id>73</id>
    <revision>
      <id>60778</id>
      <parentid>56047</parentid>
      <timestamp>2013-06-01T06:52:31Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list signal]] to [[Template:cpp/utility/program/dsc signal]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="87">{{dsc fun | cpp/utility/program/signal | sets a signal handler for particular signal }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/dsc system</title>
    <ns>10</ns>
    <id>74</id>
    <revision>
      <id>60780</id>
      <parentid>56048</parentid>
      <timestamp>2013-06-01T06:52:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/dcl list system]] to [[Template:cpp/utility/program/dsc system]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="90">{{dsc fun | cpp/utility/program/system | calls the host environment's command processor }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/navbar</title>
    <ns>10</ns>
    <id>75</id>
    <revision>
      <id>40055</id>
      <parentid>36026</parentid>
      <timestamp>2012-09-28T20:21:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="247">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/program/navbar heading
|content3 = cpp/utility/program/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/navbar content</title>
    <ns>10</ns>
    <id>2450</id>
    <revision>
      <id>56049</id>
      <parentid>36581</parentid>
      <timestamp>2013-06-01T05:30:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="1251">{{nv begin}}
{{nv h1 | Program termination}}
{{nv col begin}}
{{nv ln | cpp/utility/program/abort}}
{{nv ln | cpp/utility/program/exit}}
{{nv ln | cpp/utility/program/quick_exit | notes={{mark c++11}}}}
{{nv ln | cpp/utility/program/_Exit | notes={{mark c++11}}}}
{{nv col next}}
{{nv ln | cpp/utility/program/atexit}}
{{nv ln | cpp/utility/program/at_quick_exit | notes={{mark c++11}}}}
{{nv ln | cpp/utility/program/EXIT_status | EXIT_SUCCESS | EXIT_FAILURE}}
{{nv col end}}

{{nv h1 | Communicating with the environment}}
{{nv col begin}}
{{nv ln | cpp/utility/program/system}}
{{nv col next}}
{{nv ln | cpp/utility/program/getenv}}
{{nv col end}}

{{nv h1 | Signals}}
{{nv col begin}}
{{nv ln | cpp/utility/program/signal}}
{{nv ln | cpp/utility/program/raise}}
{{nv ln | cpp/utility/program/sig_atomic_t}}
{{nv col next}}
{{nv ln | cpp/utility/program/SIG_strategies | SIG_DFL | SIG_IGN}}
{{nv ln | cpp/utility/program/SIG_ERR}}
{{nv col end}}

{{nv h2 | Signal types}}
{{nv ln | cpp/utility/program/SIG_types | SIGABRT | SIGFPE | SIGILL | SIGINT | SIGSEGV | SIGTERM}}

{{nv h1 | Non-local jumps}}
{{nv ln | cpp/utility/program/setjmp}}
{{nv ln | cpp/utility/program/longjmp}}

{{nv h2 | Types}}
{{nv ln | cpp/utility/program/jmp_buf}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/program/navbar heading</title>
    <ns>10</ns>
    <id>76</id>
    <revision>
      <id>35993</id>
      <parentid>151</parentid>
      <timestamp>2012-06-15T22:36:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/program/sidebar heading]] to [[Template:cpp/utility/program/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="51">[[cpp/utility/program | Program support utilities]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/rel ops/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12559</id>
    <redirect title="Template:cpp/utility/rel ops/dsc operator cmp" />
    <revision>
      <id>60783</id>
      <timestamp>2013-06-01T06:52:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/rel ops/dcl list operator cmp]] to [[Template:cpp/utility/rel ops/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/utility/rel ops/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/rel ops/dsc operator cmp</title>
    <ns>10</ns>
    <id>4256</id>
    <revision>
      <id>60782</id>
      <parentid>56052</parentid>
      <timestamp>2013-06-01T06:52:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/rel ops/dcl list operator cmp]] to [[Template:cpp/utility/rel ops/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="218">{{dsc tfun | cpp/utility/rel_ops/operator_cmp | title=operator!=&lt;br&gt;operator&gt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;= | automatically generates comparison operators based on user-defined {{c|operator{{==}}}} and {{c|operator&lt;}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/rel ops/title</title>
    <ns>10</ns>
    <id>2995</id>
    <revision>
      <id>15427</id>
      <parentid>15426</parentid>
      <timestamp>2011-12-09T14:56:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add fourth option</comment>
      <text xml:space="preserve" bytes="115">&lt;onlyinclude&gt;{{cpp/title | n=rel_ops::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}} | {{{4|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list forward as tuple</title>
    <ns>10</ns>
    <id>12560</id>
    <redirect title="Template:cpp/utility/tuple/dsc forward as tuple" />
    <revision>
      <id>60785</id>
      <timestamp>2013-06-01T06:52:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list forward as tuple]] to [[Template:cpp/utility/tuple/dsc forward as tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="61">#REDIRECT [[Template:cpp/utility/tuple/dsc forward as tuple]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list get</title>
    <ns>10</ns>
    <id>12561</id>
    <redirect title="Template:cpp/utility/tuple/dsc get" />
    <revision>
      <id>60787</id>
      <timestamp>2013-06-01T06:52:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list get]] to [[Template:cpp/utility/tuple/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/utility/tuple/dsc get]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list ignore</title>
    <ns>10</ns>
    <id>12562</id>
    <redirect title="Template:cpp/utility/tuple/dsc ignore" />
    <revision>
      <id>60789</id>
      <timestamp>2013-06-01T06:52:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list ignore]] to [[Template:cpp/utility/tuple/dsc ignore]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="51">#REDIRECT [[Template:cpp/utility/tuple/dsc ignore]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list make tuple</title>
    <ns>10</ns>
    <id>12563</id>
    <redirect title="Template:cpp/utility/tuple/dsc make tuple" />
    <revision>
      <id>60791</id>
      <timestamp>2013-06-01T06:52:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list make tuple]] to [[Template:cpp/utility/tuple/dsc make tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/tuple/dsc make tuple]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list operator cmp</title>
    <ns>10</ns>
    <id>12564</id>
    <redirect title="Template:cpp/utility/tuple/dsc operator cmp" />
    <revision>
      <id>60793</id>
      <timestamp>2013-06-01T06:52:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list operator cmp]] to [[Template:cpp/utility/tuple/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="57">#REDIRECT [[Template:cpp/utility/tuple/dsc operator cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list swap2</title>
    <ns>10</ns>
    <id>12565</id>
    <redirect title="Template:cpp/utility/tuple/dsc swap2" />
    <revision>
      <id>60795</id>
      <timestamp>2013-06-01T06:52:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list swap2]] to [[Template:cpp/utility/tuple/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="50">#REDIRECT [[Template:cpp/utility/tuple/dsc swap2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list tie</title>
    <ns>10</ns>
    <id>12566</id>
    <redirect title="Template:cpp/utility/tuple/dsc tie" />
    <revision>
      <id>60797</id>
      <timestamp>2013-06-01T06:52:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tie]] to [[Template:cpp/utility/tuple/dsc tie]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="48">#REDIRECT [[Template:cpp/utility/tuple/dsc tie]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list tuple cat</title>
    <ns>10</ns>
    <id>12567</id>
    <redirect title="Template:cpp/utility/tuple/dsc tuple cat" />
    <revision>
      <id>60799</id>
      <timestamp>2013-06-01T06:52:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple cat]] to [[Template:cpp/utility/tuple/dsc tuple cat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/tuple/dsc tuple cat]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list tuple element</title>
    <ns>10</ns>
    <id>12568</id>
    <redirect title="Template:cpp/utility/tuple/dsc tuple element" />
    <revision>
      <id>60801</id>
      <timestamp>2013-06-01T06:52:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple element]] to [[Template:cpp/utility/tuple/dsc tuple element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="58">#REDIRECT [[Template:cpp/utility/tuple/dsc tuple element]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list tuple size</title>
    <ns>10</ns>
    <id>12569</id>
    <redirect title="Template:cpp/utility/tuple/dsc tuple size" />
    <revision>
      <id>60803</id>
      <timestamp>2013-06-01T06:52:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple size]] to [[Template:cpp/utility/tuple/dsc tuple size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/tuple/dsc tuple size]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dcl list uses allocator</title>
    <ns>10</ns>
    <id>12570</id>
    <redirect title="Template:cpp/utility/tuple/dsc uses allocator" />
    <revision>
      <id>60805</id>
      <timestamp>2013-06-01T06:52:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/tuple/dcl list uses allocator]] to [[Template:cpp/utility/tuple/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="59">#REDIRECT [[Template:cpp/utility/tuple/dsc uses allocator]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc forward as tuple</title>
    <ns>10</ns>
    <id>2686</id>
    <revision>
      <id>60784</id>
      <parentid>56053</parentid>
      <timestamp>2013-06-01T06:52:36Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list forward as tuple]] to [[Template:cpp/utility/tuple/dsc forward as tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="95">{{dsc tfun | cpp/utility/tuple/forward_as_tuple | creates a {{tt|tuple}} of rvalue references}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc get</title>
    <ns>10</ns>
    <id>2765</id>
    <revision>
      <id>60786</id>
      <parentid>56054</parentid>
      <timestamp>2013-06-01T06:52:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list get]] to [[Template:cpp/utility/tuple/dsc get]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="114">{{dsc tfun | cpp/utility/tuple/get | title=std::get{{dsc small|(std::tuple)}} | tuple accesses specified element}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc ignore</title>
    <ns>10</ns>
    <id>2688</id>
    <revision>
      <id>60788</id>
      <parentid>56055</parentid>
      <timestamp>2013-06-01T06:52:39Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list ignore]] to [[Template:cpp/utility/tuple/dsc ignore]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="140">{{dsc const | cpp/utility/tuple/ignore | placeholder to skip an element when unpacking a {{tt|tuple}} using {{ltt|cpp/utility/tuple/tie}} }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc make tuple</title>
    <ns>10</ns>
    <id>2684</id>
    <revision>
      <id>60790</id>
      <parentid>56058</parentid>
      <timestamp>2013-06-01T06:52:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list make tuple]] to [[Template:cpp/utility/tuple/dsc make tuple]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="117">{{dsc tfun | cpp/utility/tuple/make_tuple | creates a {{tt|tuple}} object of the type defined by the argument types}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc operator cmp</title>
    <ns>10</ns>
    <id>2573</id>
    <revision>
      <id>60792</id>
      <parentid>56059</parentid>
      <timestamp>2013-06-01T06:52:41Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list operator cmp]] to [[Template:cpp/utility/tuple/dsc operator cmp]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="186">{{dsc tfun | cpp/utility/tuple/operator_cmp | title=operator==&lt;br&gt;operator!=&lt;br&gt;operator&lt;&lt;br&gt;operator&lt;=&lt;br&gt;operator&gt;&lt;br&gt;operator&gt;= | lexicographically compares the values in the tuple }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc swap2</title>
    <ns>10</ns>
    <id>2574</id>
    <revision>
      <id>60794</id>
      <parentid>56062</parentid>
      <timestamp>2013-06-01T06:52:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list swap2]] to [[Template:cpp/utility/tuple/dsc swap2]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="150">{{dsc tfun | cpp/utility/tuple/swap2 | title=std::swap{{dsc small|(std::tuple)}} | specializes the {{lc|std::swap}} algorithm | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc tie</title>
    <ns>10</ns>
    <id>2685</id>
    <revision>
      <id>60796</id>
      <parentid>56063</parentid>
      <timestamp>2013-06-01T06:52:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tie]] to [[Template:cpp/utility/tuple/dsc tie]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="125">{{dsc tfun | cpp/utility/tuple/tie | creates a {{tt|tuple}} of lvalue references or unpacks a tuple into individual objects}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc tuple cat</title>
    <ns>10</ns>
    <id>2687</id>
    <revision>
      <id>60798</id>
      <parentid>56064</parentid>
      <timestamp>2013-06-01T06:52:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple cat]] to [[Template:cpp/utility/tuple/dsc tuple cat]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="105">{{dsc tfun | cpp/utility/tuple/tuple_cat | creates a {{tt|tuple}} by concatenating any number of tuples}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc tuple element</title>
    <ns>10</ns>
    <id>2766</id>
    <revision>
      <id>60800</id>
      <parentid>56067</parentid>
      <timestamp>2013-06-01T06:52:47Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple element]] to [[Template:cpp/utility/tuple/dsc tuple element]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc ptclass | cpp/utility/tuple/tuple_element | obtains the type of the specified element }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc tuple size</title>
    <ns>10</ns>
    <id>2767</id>
    <revision>
      <id>60802</id>
      <parentid>56068</parentid>
      <timestamp>2013-06-01T06:52:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list tuple size]] to [[Template:cpp/utility/tuple/dsc tuple size]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="98">{{dsc ptclass | cpp/utility/tuple/tuple_size | obtains the size of {{tt|tuple}} at compile time }}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/dsc uses allocator</title>
    <ns>10</ns>
    <id>2768</id>
    <revision>
      <id>60804</id>
      <parentid>56069</parentid>
      <timestamp>2013-06-01T06:52:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/tuple/dcl list uses allocator]] to [[Template:cpp/utility/tuple/dsc uses allocator]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="183">{{dsc ptclass | cpp/utility/tuple/uses_allocator | title=std::uses_allocator{{dsc small|&lt;std::tuple&gt;}} | specializes the {{lc|std::uses_allocator}} type trait | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/navbar</title>
    <ns>10</ns>
    <id>2380</id>
    <revision>
      <id>47770</id>
      <parentid>40056</parentid>
      <timestamp>2013-05-16T20:26:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="243">{{navbar
|heading1 = cpp/navbar heading
|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/tuple/navbar heading
|content3 = cpp/utility/tuple/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/navbar content</title>
    <ns>10</ns>
    <id>2680</id>
    <revision>
      <id>72380</id>
      <parentid>56072</parentid>
      <timestamp>2014-08-18T11:04:31Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <minor/>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="789">{{nv begin}}
{{nv h1 | Member functions}}
{{nv mem ln | cpp/utility/tuple/tuple}}
{{nv mem ln | cpp/utility/tuple/operator{{=}}}}
{{nv mem ln | cpp/utility/tuple/swap}}

{{nv h1 | Non-member functions}}
{{nv ln | cpp/utility/tuple/make_tuple}}
{{nv ln | cpp/utility/tuple/tie}}
{{nv ln | cpp/utility/tuple/forward_as_tuple}}
{{nv ln | cpp/utility/tuple/tuple_cat |}}
{{nv ln | cpp/utility/tuple/operator_cmp | operator{{==}} | operator!{{=}} | operator&lt; | operator&lt;{{=}} | operator&gt; | operator&gt;{{=}}}}
{{nv ln | cpp/utility/tuple/swap2 | std::swap}}
{{nv ln | cpp/utility/tuple/get}}

{{nv h1 | Helper classes}}
{{nv ln | cpp/utility/tuple/tuple_size}}
{{nv ln | cpp/utility/tuple/tuple_element}}
{{nv ln | cpp/utility/tuple/uses_allocator}}
{{nv ln | cpp/utility/tuple/ignore}}
{{nv end}}</text>
      <sha1>ood7dat4hluhocqghgb4kkaio14vn41</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/navbar heading</title>
    <ns>10</ns>
    <id>2381</id>
    <revision>
      <id>47767</id>
      <parentid>33366</parentid>
      <timestamp>2013-05-16T20:24:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>simplify</comment>
      <text xml:space="preserve" bytes="36">{{ltt|cpp/utility/tuple|std::tuple}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/tuple/title</title>
    <ns>10</ns>
    <id>2674</id>
    <revision>
      <id>10068</id>
      <timestamp>2011-08-30T01:47:31Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Created page with &quot;&lt;onlyinclude&gt;{{cpp/title | n=tuple::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="102">&lt;onlyinclude&gt;{{cpp/title | n=tuple::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dcl list va arg</title>
    <ns>10</ns>
    <id>12571</id>
    <redirect title="Template:cpp/utility/variadic/dsc va arg" />
    <revision>
      <id>60807</id>
      <timestamp>2013-06-01T06:52:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va arg]] to [[Template:cpp/utility/variadic/dsc va arg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/variadic/dsc va arg]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dcl list va copy</title>
    <ns>10</ns>
    <id>12572</id>
    <redirect title="Template:cpp/utility/variadic/dsc va copy" />
    <revision>
      <id>60809</id>
      <timestamp>2013-06-01T06:52:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va copy]] to [[Template:cpp/utility/variadic/dsc va copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/variadic/dsc va copy]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dcl list va end</title>
    <ns>10</ns>
    <id>12573</id>
    <redirect title="Template:cpp/utility/variadic/dsc va end" />
    <revision>
      <id>60811</id>
      <timestamp>2013-06-01T06:52:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va end]] to [[Template:cpp/utility/variadic/dsc va end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="54">#REDIRECT [[Template:cpp/utility/variadic/dsc va end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dcl list va list</title>
    <ns>10</ns>
    <id>12574</id>
    <redirect title="Template:cpp/utility/variadic/dsc va list" />
    <revision>
      <id>60813</id>
      <timestamp>2013-06-01T06:52:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va list]] to [[Template:cpp/utility/variadic/dsc va list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="55">#REDIRECT [[Template:cpp/utility/variadic/dsc va list]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dcl list va start</title>
    <ns>10</ns>
    <id>12575</id>
    <redirect title="Template:cpp/utility/variadic/dsc va start" />
    <revision>
      <id>60815</id>
      <timestamp>2013-06-01T06:52:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va start]] to [[Template:cpp/utility/variadic/dsc va start]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="56">#REDIRECT [[Template:cpp/utility/variadic/dsc va start]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dsc va arg</title>
    <ns>10</ns>
    <id>8530</id>
    <revision>
      <id>60806</id>
      <parentid>56075</parentid>
      <timestamp>2013-06-01T06:52:52Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va arg]] to [[Template:cpp/utility/variadic/dsc va arg]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="94">{{dsc macro fun | cpp/utility/variadic/va_arg | accesses the next variadic function argument}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dsc va copy</title>
    <ns>10</ns>
    <id>8531</id>
    <revision>
      <id>60808</id>
      <parentid>56078</parentid>
      <timestamp>2013-06-01T06:52:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va copy]] to [[Template:cpp/utility/variadic/dsc va copy]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="121">{{dsc macro fun | cpp/utility/variadic/va_copy | makes a copy of the variadic function arguments | notes={{mark c++11}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dsc va end</title>
    <ns>10</ns>
    <id>8532</id>
    <revision>
      <id>60810</id>
      <parentid>56083</parentid>
      <timestamp>2013-06-01T06:52:55Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va end]] to [[Template:cpp/utility/variadic/dsc va end]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="99">{{dsc macro fun | cpp/utility/variadic/va_end | ends traversal of the variadic function arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dsc va list</title>
    <ns>10</ns>
    <id>8533</id>
    <revision>
      <id>60812</id>
      <parentid>56088</parentid>
      <timestamp>2013-06-01T06:52:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va list]] to [[Template:cpp/utility/variadic/dsc va list]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="116">{{dsc class | cpp/utility/variadic/va_list | holds the information needed by va_start, va_arg, va_end, and va_copy}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/dsc va start</title>
    <ns>10</ns>
    <id>8529</id>
    <revision>
      <id>60814</id>
      <parentid>56093</parentid>
      <timestamp>2013-06-01T06:52:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/dcl list va start]] to [[Template:cpp/utility/variadic/dsc va start]]: Robot: Moved page</comment>
      <text xml:space="preserve" bytes="97">{{dsc macro fun | cpp/utility/variadic/va_start | enables access to variadic function arguments}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/navbar</title>
    <ns>10</ns>
    <id>3441</id>
    <revision>
      <id>40057</id>
      <parentid>35661</parentid>
      <timestamp>2012-09-28T20:21:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Use new navbar interface</comment>
      <text xml:space="preserve" bytes="250">{{navbar
|heading1 = cpp/navbar heading

|content1 = cpp/navbar content

|heading2 = cpp/utility/navbar heading
|content2 = cpp/utility/navbar content

|heading3 = cpp/utility/variadic/navbar heading
|content3 = cpp/utility/variadic/navbar content
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/navbar content</title>
    <ns>10</ns>
    <id>3443</id>
    <revision>
      <id>56096</id>
      <parentid>35996</parentid>
      <timestamp>2013-06-01T05:30:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="227">{{nv begin}}
{{nv ln | cpp/utility/variadic/va_start}}
{{nv ln | cpp/utility/variadic/va_arg}}
{{nv ln | cpp/utility/variadic/va_copy}}
{{nv ln | cpp/utility/variadic/va_end}}
{{nv ln | cpp/utility/variadic/va_list}}
{{nv end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/utility/variadic/navbar heading</title>
    <ns>10</ns>
    <id>3442</id>
    <revision>
      <id>35235</id>
      <parentid>12961</parentid>
      <timestamp>2012-06-15T22:20:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:cpp/utility/variadic/sidebar heading]] to [[Template:cpp/utility/variadic/navbar heading]]: Text replace - &quot;/sidebar&quot; to &quot;/navbar&quot;</comment>
      <text xml:space="preserve" bytes="45">[[cpp/utility/variadic | Variadic functions]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/wbuffer convert/title</title>
    <ns>10</ns>
    <id>5199</id>
    <revision>
      <id>18804</id>
      <timestamp>2012-02-16T04:34:19Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=wbuffer_convert::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:cpp/wstring convert/title</title>
    <ns>10</ns>
    <id>4570</id>
    <revision>
      <id>16123</id>
      <timestamp>2011-12-21T21:56:07Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>+</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{{cpp/title | n=wstring_convert::{{trim|{{{n|}}}}} | {{{1|}}} | {{{2|}}} | {{{3|}}}}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ctitle</title>
    <ns>10</ns>
    <id>81</id>
    <revision>
      <id>18038</id>
      <parentid>17902</parentid>
      <timestamp>2012-01-20T00:36:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>remove trailing ::, if any</comment>
      <text xml:space="preserve" bytes="901">&lt;onlyinclude&gt;{{#if: {{#pos: #MAGICTITLESTRING# | {{{1|}}}}}&lt;!--
--&gt;|{{#replace:{{#replace:{{{n|}}}#MAGICTITLESTRING#|::#MAGICTITLESTRING#}}|#MAGICTITLESTRING#}}&lt;!-- remove trailing '::', if any
--&gt;|{{title|&lt;!--
  --&gt;{{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{1|}}}}}&lt;!--
  --&gt;{{#if:{{{2|}}}|&lt;!--
    --&gt;, {{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{2}}}}}&lt;!--
  --&gt;}}&lt;!--
  --&gt;{{#if:{{{3|}}}|&lt;!--
    --&gt;, {{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{3}}}}}&lt;!--
  --&gt;}}&lt;!--
  --&gt;{{#if:{{{4|}}}|&lt;!--
    --&gt;, {{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{4}}}}}&lt;!--
  --&gt;}}&lt;!--
  --&gt;{{#if:{{{5|}}}|&lt;!--
    --&gt;, {{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{5}}}}}&lt;!--
  --&gt;}}&lt;!--
  --&gt;{{#if:{{{6|}}}|&lt;!--
    --&gt;, {{#if:{{{n|}}}|{{small|{{trim|{{{n}}}}}}}}}{{trim|{{{6}}}}}&lt;!--
  --&gt;}}&lt;!--
  --&gt;}}&lt;!--
--&gt;}}&lt;/onlyinclude&gt;
{{documentation | Template:title/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl</title>
    <ns>10</ns>
    <id>114</id>
    <revision>
      <id>71964</id>
      <parentid>65204</parentid>
      <timestamp>2014-07-04T18:37:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not add an additional row for separators</comment>
      <text xml:space="preserve" bytes="809">{{dcl/std|since={{{since|}}}|until={{{until|}}}}}&lt;!--
--&gt;&lt;tr class=&quot;t-dcl {{#if:{{{since|}}}|t-since-{{#replace:{{{since}}}|+|x}}}} {{#if:{{{until|}}}|t-until-{{#replace:{{{until}}}|+|x}}}}&quot;&gt;
&lt;td {{#if: {{{num|}}}{{{notes|}}}{{#var:since}}{{#var:until}} || class=&quot;t-dcl-nopad&quot; }}&gt; &lt;div&gt;{{c/core|{{trim| {{{1|}}}}}}}&lt;/div&gt;&lt;/td&gt;
&lt;td {{#if: {{{num|}}} || class=&quot;t-dcl-nopad&quot; }}&gt; {{#if: {{{num|}}} | ({{{num}}}) }} &lt;/td&gt;
&lt;td {{#if: {{{notes|}}}{{#var:since}}{{#var:until}} || class=&quot;t-dcl-nopad&quot; }}&gt; &lt;!--
--&gt;{{#if: {{#var:since}}&lt;!--
  --&gt;|{{mark since {{#var:since}}}} {{#if: {{#var:until}}{{{notes|}}}|&lt;br/&gt;}}&lt;!--
--&gt;}}&lt;!--
--&gt;{{#if: {{#var:until}}&lt;!--
  --&gt;|{{mark until {{#var:until}}}} {{#if: {{{notes|}}}|&lt;br/&gt;}}&lt;!--
--&gt;}}{{{notes|}}} &lt;/td&gt;
&lt;/tr&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1>at349vojkri739tzztimllkitn8gg9e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl/doc</title>
    <ns>10</ns>
    <id>109</id>
    <revision>
      <id>65640</id>
      <parentid>61057</parentid>
      <timestamp>2013-09-23T19:23:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="2933">This is one of the family of templates used for creation of declaration lists.

{{list/doc}}

{{tl|dcl begin}}
: starts the declaration list

{{tl|dcl end}}
: ends the declaration list. This template automatically adds {{tlc|dcl sep}} above the item.

{{tl|dcl rev begin| num{{=}}''num''}}
: starts versioned declaration list. The {{tt|num}} parameter is optional and may be used for numbering purposes (overrides the ''num'' parameter of the {{tlc|dcl}} templates used within the versioned list (i.e., until {{tlc|dcl rev end}}).

{{tl|dcl rev end}}
: ends versioned declaration list.

{{tl|dcl header}}
: adds explanation which header the feature comes from

{{tl|dcl sep}}
: adds a separator

{{tl|dcl h | ''heading''}}
: adds a small heading. Useful to split and describe large groups of related declarations.

{{tl|dcl | notes{{=}}''notes'' | num{{=}}''num'' | since{{=}}''since-std'' | until{{=}}''until-std'' |  ''declaration'' }}
: adds an item to the declaration list. The {{tt|notes}} parameter is optional and may be used to add notes about the feature. The {{tt|num}} parameter is also optional and may be used for numbering purposes. ''declaration'' is the declaration of the feature. This template automatically adds {{tlc|dcl sep}} above the item.

:{{tt|until}} specifies the first standard the definition appears in, {{tt|until}} specifies the first standard that does not include this definition.

===Example===

  &lt;nowiki&gt;
    {{dcl header | abcd.h}}
    {{dcl | notes=Faster than {{c|foo_slow}} | num=1 |
    int foo( char a );
    }}
    {{dcl | since=c++11 | num=2 |
    int foo( char a, int b );
    }}
    {{dcl rev begin | num=3}}
    {{dcl | until=c++11 | 1=
    int foo( char a, char b = 'a' );
    }}
    {{dcl | since=c++11 | until=c++14 | 1=
    int foo( char a, char b = 'b' );
    }}
    {{dcl | since=c++14 | 1=
    int foo( char a, char b = 'c' );
    }}
    {{dcl rev end}}
    {{dcl rev begin}}
    {{dcl | until=c++11 | num=4 | 1=
    int foo( char a, char b = 'a' );
    }}
    {{dcl | since=c++11 | until=c++14 | num=5 | 1=
    int foo( char a, char b = 'b' );
    }}
    {{dcl | since=c++14 | num=6 | 1=
    int foo( char a, char b = 'c' );
    }}
    {{dcl rev end}}
  &lt;/nowiki&gt;

The above results in the following:

{{dcl begin}}
{{dcl header | abcd.h}}
{{dcl | notes=Faster than {{c|foo_slow}} | num=1 |
int foo( char a );
}}
{{dcl | since=c++11 | num=2 |
int foo( char a, int b );
}}
{{dcl rev begin | num=3}}
{{dcl | until=c++11 | 1=
int foo( char a, char b = 'a' );
}}
{{dcl | since=c++11 | until=c++14 | 1=
int foo( char a, char b = 'b' );
}}
{{dcl | since=c++14 | 1=
int foo( char a, char b = 'c' );
}}
{{dcl rev end}}
{{dcl rev begin}}
{{dcl | until=c++11 | num=4 | 1=
int foo( char a, char b = 'a' );
}}
{{dcl | since=c++11 | until=c++14 | num=5 | 1=
int foo( char a, char b = 'b' );
}}
{{dcl | since=c++14 | num=6 | 1=
int foo( char a, char b = 'c' );
}}
{{dcl rev end}}
{{dcl end}}</text>
      <sha1>gbdy818qdesrvfwm675utws0v2uv7dq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl/std</title>
    <ns>10</ns>
    <id>12777</id>
    <revision>
      <id>68682</id>
      <parentid>68146</parentid>
      <timestamp>2014-03-19T00:44:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add filesystem ts</comment>
      <text xml:space="preserve" bytes="323">&lt;onlyinclude&gt;{{#vardefine:since|{{#switch:{{{since|}}}
 |c++98=
 |c++03=c++03
 |c++11=c++11
 |c++14=c++14
 |c99=c99
 |c11=c11
 |libfund_ts=libfund_ts
 |fs_ts=fs_ts
 |none=none
}}}}{{#vardefine:until|{{#switch:{{{until|}}}
 |c++98=
 |c++03=c++03
 |c++11=c++11
 |c++14=c++14
 |c99=c99
 |c11=c11
 |none=none
}}}}&lt;/onlyinclude&gt;</text>
      <sha1>grhsv1vzvryprd81szpfvacsa0jv1ru</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl begin</title>
    <ns>10</ns>
    <id>110</id>
    <revision>
      <id>61692</id>
      <parentid>61215</parentid>
      <timestamp>2013-06-08T05:28:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="98">&lt;onlyinclude&gt;&lt;table class=&quot;t-dcl-begin&quot;&gt;&lt;tbody&gt;&lt;/onlyinclude&gt;
{{documentation | Template:dcl/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl end</title>
    <ns>10</ns>
    <id>111</id>
    <revision>
      <id>63870</id>
      <parentid>61216</parentid>
      <timestamp>2013-07-29T17:36:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use correct template</comment>
      <text xml:space="preserve" bytes="90">{{dcl sep}}
&lt;/tbody&gt;&lt;/table&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc }}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl h</title>
    <ns>10</ns>
    <id>10092</id>
    <revision>
      <id>71963</id>
      <parentid>61693</parentid>
      <timestamp>2014-07-04T18:34:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not add an additional row for separators</comment>
      <text xml:space="preserve" bytes="147">&lt;tr class=&quot;t-dcl-h&quot;&gt;
&lt;td&gt; &lt;div&gt;{{trim| {{{1|}}}}}&lt;/div&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;/tr&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1>to7w3vtzcpplyv37eh1lqgs19d4xtq5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl header</title>
    <ns>10</ns>
    <id>113</id>
    <revision>
      <id>64118</id>
      <parentid>64026</parentid>
      <timestamp>2013-08-13T14:53:16Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>if #2 is defined, show #2 (instead of showing #1)</comment>
      <text xml:space="preserve" bytes="372">&lt;tr class=&quot;t-dsc-header&quot;&gt;
&lt;td&gt; &lt;div&gt;{{#if: {{{1|}}} | Defined in header &lt;code&gt;{{dcl list header/link|{{trim|{{{1}}}}}}}&lt;/code&gt; }}
{{#if: {{{2|}}}|&lt;br&gt;Defined in header &lt;code&gt;{{dcl list header/link|{{trim|{{{2}}}}}}}&lt;/code&gt;}} &lt;/div&gt;&lt;/td&gt;
&lt;td&gt;&lt;/td&gt;
&lt;td&gt;{{#if: {{{notes|}}} | &lt;div&gt;{{{notes|}}}&lt;/div&gt;}}&lt;/td&gt;&lt;!--
--&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl item</title>
    <ns>10</ns>
    <id>10240</id>
    <redirect title="Template:dcl" />
    <revision>
      <id>48667</id>
      <timestamp>2013-05-31T18:49:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl item]] to [[Template:dcl]]</comment>
      <text xml:space="preserve" bytes="26">#REDIRECT [[Template:dcl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list/doc</title>
    <ns>10</ns>
    <id>10180</id>
    <redirect title="Template:dsc/doc" />
    <revision>
      <id>48537</id>
      <parentid>48533</parentid>
      <timestamp>2013-05-31T17:46:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:dsc/doc]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dsc/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list begin</title>
    <ns>10</ns>
    <id>10183</id>
    <redirect title="Template:dsc begin" />
    <revision>
      <id>48551</id>
      <timestamp>2013-05-31T18:26:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list begin]] to [[Template:dsc begin]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list break</title>
    <ns>10</ns>
    <id>10184</id>
    <redirect title="Template:dsc break" />
    <revision>
      <id>48553</id>
      <timestamp>2013-05-31T18:26:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list break]] to [[Template:dsc break]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc break]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list class</title>
    <ns>10</ns>
    <id>10185</id>
    <redirect title="Template:dsc class" />
    <revision>
      <id>48555</id>
      <timestamp>2013-05-31T18:26:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list class]] to [[Template:dsc class]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc class]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list concept</title>
    <ns>10</ns>
    <id>10186</id>
    <redirect title="Template:dsc concept" />
    <revision>
      <id>48557</id>
      <timestamp>2013-05-31T18:27:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list concept]] to [[Template:dsc concept]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc concept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list const</title>
    <ns>10</ns>
    <id>10233</id>
    <redirect title="Template:dsc const" />
    <revision>
      <id>48653</id>
      <timestamp>2013-05-31T18:47:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list const]] to [[Template:dsc const]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list editlink</title>
    <ns>10</ns>
    <id>10231</id>
    <redirect title="Template:dsc editlink" />
    <revision>
      <id>48648</id>
      <timestamp>2013-05-31T18:45:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list editlink]] to [[Template:dsc editlink]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc editlink]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list end</title>
    <ns>10</ns>
    <id>10230</id>
    <redirect title="Template:dsc end" />
    <revision>
      <id>48646</id>
      <timestamp>2013-05-31T18:45:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list end]] to [[Template:dsc end]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dsc end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list enum</title>
    <ns>10</ns>
    <id>10229</id>
    <redirect title="Template:dsc enum" />
    <revision>
      <id>48644</id>
      <timestamp>2013-05-31T18:45:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list enum]] to [[Template:dsc enum]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:dsc enum]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list fun</title>
    <ns>10</ns>
    <id>10228</id>
    <redirect title="Template:dsc fun" />
    <revision>
      <id>48642</id>
      <timestamp>2013-05-31T18:45:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list fun]] to [[Template:dsc fun]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dsc fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list guard</title>
    <ns>10</ns>
    <id>10227</id>
    <redirect title="Template:dsc guard" />
    <revision>
      <id>48640</id>
      <timestamp>2013-05-31T18:45:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list guard]] to [[Template:dsc guard]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc guard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list h1</title>
    <ns>10</ns>
    <id>10232</id>
    <redirect title="Template:dsc h1" />
    <revision>
      <id>48651</id>
      <timestamp>2013-05-31T18:46:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list h1]] to [[Template:dsc h1]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[Template:dsc h1]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list h2</title>
    <ns>10</ns>
    <id>10187</id>
    <redirect title="Template:dsc h2" />
    <revision>
      <id>48559</id>
      <timestamp>2013-05-31T18:37:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list h2]] to [[Template:dsc h2]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[Template:dsc h2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list header</title>
    <ns>10</ns>
    <id>10188</id>
    <redirect title="Template:dsc header" />
    <revision>
      <id>48561</id>
      <timestamp>2013-05-31T18:38:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list header]] to [[Template:dsc header]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:dsc header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list header/link</title>
    <ns>10</ns>
    <id>10189</id>
    <redirect title="Template:dsc header/link" />
    <revision>
      <id>48563</id>
      <timestamp>2013-05-31T18:38:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list header/link]] to [[Template:dsc header/link]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[Template:dsc header/link]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list hitem</title>
    <ns>10</ns>
    <id>10190</id>
    <redirect title="Template:dsc hitem" />
    <revision>
      <id>48565</id>
      <timestamp>2013-05-31T18:39:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list hitem]] to [[Template:dsc hitem]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc hitem]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list item</title>
    <ns>10</ns>
    <id>10191</id>
    <redirect title="Template:dsc" />
    <revision>
      <id>48567</id>
      <timestamp>2013-05-31T18:39:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list item]] to [[Template:dsc]]</comment>
      <text xml:space="preserve" bytes="26">#REDIRECT [[Template:dsc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list macro const</title>
    <ns>10</ns>
    <id>10192</id>
    <redirect title="Template:dsc macro const" />
    <revision>
      <id>48569</id>
      <timestamp>2013-05-31T18:39:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list macro const]] to [[Template:dsc macro const]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[Template:dsc macro const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list macro fun</title>
    <ns>10</ns>
    <id>10193</id>
    <redirect title="Template:dsc macro fun" />
    <revision>
      <id>48571</id>
      <timestamp>2013-05-31T18:39:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list macro fun]] to [[Template:dsc macro fun]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc macro fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem class</title>
    <ns>10</ns>
    <id>10194</id>
    <redirect title="Template:dsc mem class" />
    <revision>
      <id>48573</id>
      <timestamp>2013-05-31T18:40:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem class]] to [[Template:dsc mem class]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc mem class]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem const</title>
    <ns>10</ns>
    <id>10195</id>
    <redirect title="Template:dsc mem const" />
    <revision>
      <id>48575</id>
      <timestamp>2013-05-31T18:40:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem const]] to [[Template:dsc mem const]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc mem const]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem ctor</title>
    <ns>10</ns>
    <id>10196</id>
    <redirect title="Template:dsc mem ctor" />
    <revision>
      <id>48577</id>
      <timestamp>2013-05-31T18:40:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem ctor]] to [[Template:dsc mem ctor]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc mem ctor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem dtor</title>
    <ns>10</ns>
    <id>10197</id>
    <redirect title="Template:dsc mem dtor" />
    <revision>
      <id>48579</id>
      <timestamp>2013-05-31T18:40:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem dtor]] to [[Template:dsc mem dtor]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc mem dtor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem fun</title>
    <ns>10</ns>
    <id>10198</id>
    <redirect title="Template:dsc mem fun" />
    <revision>
      <id>48581</id>
      <timestamp>2013-05-31T18:40:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem fun]] to [[Template:dsc mem fun]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc mem fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem obj</title>
    <ns>10</ns>
    <id>10199</id>
    <redirect title="Template:dsc mem obj" />
    <revision>
      <id>48583</id>
      <timestamp>2013-05-31T18:41:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem obj]] to [[Template:dsc mem obj]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc mem obj]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem sconst</title>
    <ns>10</ns>
    <id>10200</id>
    <redirect title="Template:dsc mem sconst" />
    <revision>
      <id>48585</id>
      <timestamp>2013-05-31T18:41:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem sconst]] to [[Template:dsc mem sconst]]</comment>
      <text xml:space="preserve" bytes="37">#REDIRECT [[Template:dsc mem sconst]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem sfun</title>
    <ns>10</ns>
    <id>10201</id>
    <redirect title="Template:dsc mem sfun" />
    <revision>
      <id>48587</id>
      <timestamp>2013-05-31T18:41:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem sfun]] to [[Template:dsc mem sfun]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc mem sfun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem vdtor</title>
    <ns>10</ns>
    <id>10202</id>
    <redirect title="Template:dsc mem vdtor" />
    <revision>
      <id>48589</id>
      <timestamp>2013-05-31T18:41:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem vdtor]] to [[Template:dsc mem vdtor]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc mem vdtor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list mem vfun</title>
    <ns>10</ns>
    <id>10226</id>
    <redirect title="Template:dsc mem vfun" />
    <revision>
      <id>48637</id>
      <timestamp>2013-05-31T18:45:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list mem vfun]] to [[Template:dsc mem vfun]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc mem vfun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list namespace</title>
    <ns>10</ns>
    <id>10225</id>
    <redirect title="Template:dsc namespace" />
    <revision>
      <id>48635</id>
      <timestamp>2013-05-31T18:44:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list namespace]] to [[Template:dsc namespace]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc namespace]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list priv mem ctor</title>
    <ns>10</ns>
    <id>10224</id>
    <redirect title="Template:dsc priv mem ctor" />
    <revision>
      <id>48633</id>
      <timestamp>2013-05-31T18:44:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list priv mem ctor]] to [[Template:dsc priv mem ctor]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[Template:dsc priv mem ctor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list priv mem obj</title>
    <ns>10</ns>
    <id>10223</id>
    <redirect title="Template:dsc priv mem obj" />
    <revision>
      <id>48631</id>
      <timestamp>2013-05-31T18:44:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list priv mem obj]] to [[Template:dsc priv mem obj]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[Template:dsc priv mem obj]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem ctor</title>
    <ns>10</ns>
    <id>10222</id>
    <redirect title="Template:dsc prot mem ctor" />
    <revision>
      <id>48629</id>
      <timestamp>2013-05-31T18:44:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem ctor]] to [[Template:dsc prot mem ctor]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[Template:dsc prot mem ctor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem dtor</title>
    <ns>10</ns>
    <id>10221</id>
    <redirect title="Template:dsc prot mem dtor" />
    <revision>
      <id>48627</id>
      <timestamp>2013-05-31T18:44:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem dtor]] to [[Template:dsc prot mem dtor]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[Template:dsc prot mem dtor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem fun</title>
    <ns>10</ns>
    <id>10220</id>
    <redirect title="Template:dsc prot mem fun" />
    <revision>
      <id>48625</id>
      <timestamp>2013-05-31T18:44:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem fun]] to [[Template:dsc prot mem fun]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[Template:dsc prot mem fun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem obj</title>
    <ns>10</ns>
    <id>10219</id>
    <redirect title="Template:dsc prot mem obj" />
    <revision>
      <id>48623</id>
      <timestamp>2013-05-31T18:44:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem obj]] to [[Template:dsc prot mem obj]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[Template:dsc prot mem obj]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem vdtor</title>
    <ns>10</ns>
    <id>10218</id>
    <redirect title="Template:dsc prot mem vdtor" />
    <revision>
      <id>48621</id>
      <timestamp>2013-05-31T18:43:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem vdtor]] to [[Template:dsc prot mem vdtor]]</comment>
      <text xml:space="preserve" bytes="41">#REDIRECT [[Template:dsc prot mem vdtor]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list prot mem vfun</title>
    <ns>10</ns>
    <id>10217</id>
    <redirect title="Template:dsc prot mem vfun" />
    <revision>
      <id>48619</id>
      <timestamp>2013-05-31T18:43:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list prot mem vfun]] to [[Template:dsc prot mem vfun]]</comment>
      <text xml:space="preserve" bytes="40">#REDIRECT [[Template:dsc prot mem vfun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list ptclass</title>
    <ns>10</ns>
    <id>10216</id>
    <redirect title="Template:dsc ptclass" />
    <revision>
      <id>48617</id>
      <timestamp>2013-05-31T18:43:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list ptclass]] to [[Template:dsc ptclass]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc ptclass]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list see c</title>
    <ns>10</ns>
    <id>10215</id>
    <redirect title="Template:dsc see c" />
    <revision>
      <id>48615</id>
      <timestamp>2013-05-31T18:43:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list see c]] to [[Template:dsc see c]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc see c]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list see cpp</title>
    <ns>10</ns>
    <id>10214</id>
    <redirect title="Template:dsc see cpp" />
    <revision>
      <id>48613</id>
      <timestamp>2013-05-31T18:43:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list see cpp]] to [[Template:dsc see cpp]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc see cpp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list sep</title>
    <ns>10</ns>
    <id>10213</id>
    <redirect title="Template:dsc sep" />
    <revision>
      <id>48611</id>
      <timestamp>2013-05-31T18:43:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list sep]] to [[Template:dsc sep]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dsc sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list struct</title>
    <ns>10</ns>
    <id>10212</id>
    <redirect title="Template:dsc struct" />
    <revision>
      <id>48609</id>
      <timestamp>2013-05-31T18:43:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list struct]] to [[Template:dsc struct]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:dsc struct]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list tclass</title>
    <ns>10</ns>
    <id>10211</id>
    <redirect title="Template:dsc tclass" />
    <revision>
      <id>48607</id>
      <timestamp>2013-05-31T18:43:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list tclass]] to [[Template:dsc tclass]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:dsc tclass]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list template</title>
    <ns>10</ns>
    <id>10210</id>
    <redirect title="Template:dsc inc" />
    <revision>
      <id>48790</id>
      <parentid>48605</parentid>
      <timestamp>2013-06-01T00:11:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:dsc inc]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dsc inc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list tfun</title>
    <ns>10</ns>
    <id>10209</id>
    <redirect title="Template:dsc tfun" />
    <revision>
      <id>48603</id>
      <timestamp>2013-05-31T18:42:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list tfun]] to [[Template:dsc tfun]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:dsc tfun]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list todo</title>
    <ns>10</ns>
    <id>10208</id>
    <redirect title="Template:dsc todo" />
    <revision>
      <id>48601</id>
      <timestamp>2013-05-31T18:42:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list todo]] to [[Template:dsc todo]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:dsc todo]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl list typedef</title>
    <ns>10</ns>
    <id>10207</id>
    <redirect title="Template:dsc typedef" />
    <revision>
      <id>48599</id>
      <timestamp>2013-05-31T18:42:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl list typedef]] to [[Template:dsc typedef]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:dsc typedef]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl mark mem</title>
    <ns>10</ns>
    <id>10206</id>
    <redirect title="Template:dsc mark mem" />
    <revision>
      <id>48597</id>
      <timestamp>2013-05-31T18:42:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl mark mem]] to [[Template:dsc mark mem]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:dsc mark mem]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl member</title>
    <ns>10</ns>
    <id>10205</id>
    <redirect title="Template:dsc member" />
    <revision>
      <id>48595</id>
      <timestamp>2013-05-31T18:42:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl member]] to [[Template:dsc member]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:dsc member]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl rev begin</title>
    <ns>10</ns>
    <id>12579</id>
    <revision>
      <id>71962</id>
      <parentid>65221</parentid>
      <timestamp>2014-07-04T18:34:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not add an additional row for separators</comment>
      <text xml:space="preserve" bytes="813">&lt;onlyinclude&gt;&lt;/tbody&gt;
&lt;tbody class=&quot;t-dcl-rev {{#if:{{{num|}}}|t-dcl-rev-num}} {{#if:{{{since|}}}{{{until|}}}{{{notes|}}}|t-dcl-rev-notes}} {{#if:{{{since|}}}|t-since-{{#replace:{{{since}}}|+|x}}}} {{#if:{{{until|}}}|t-until-{{#replace:{{{until}}}|+|x}}}}&quot;&gt;&lt;!--
--&gt;{{#if:{{{num|}}}{{{since|}}}{{{until|}}}{{{notes|}}}|
&lt;tr class=&quot;t-dcl-rev-aux&quot;&gt;
&lt;td&gt;&lt;/td&gt;
{{#if:{{{num|}}}|&lt;td rowspan=&quot;142&quot;&gt;({{{num|}}})&lt;/td&gt;|&lt;td&gt;&lt;/td&gt;}}
{{#if:{{{since|}}}{{{until|}}}{{{notes|}}}|&lt;td rowspan=&quot;142&quot;&gt; &lt;!--
--&gt;{{#if: {{{since|}}}&lt;!--
  --&gt;|{{mark since {{{since}}}}} {{#if: {{{until|}}}{{{notes|}}}|&lt;br/&gt;}}&lt;!--
--&gt;}}&lt;!--
--&gt;{{#if: {{{until|}}}&lt;!--
  --&gt;|{{mark until {{{until}}}}} {{#if: {{{notes|}}}|&lt;br/&gt;}}&lt;!--
--&gt;}}{{{notes|}}} &lt;/td&gt;|&lt;td&gt;&lt;/td&gt;}}
&lt;/tr&gt;
}}&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1>hzdlevmxh7m47k9ethc0ybbr6icazhf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl rev end</title>
    <ns>10</ns>
    <id>12580</id>
    <revision>
      <id>61053</id>
      <parentid>61051</parentid>
      <timestamp>2013-06-05T02:39:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="103">&lt;onlyinclude&gt;&lt;/tbody&gt;&lt;tbody&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl sep</title>
    <ns>10</ns>
    <id>115</id>
    <revision>
      <id>61028</id>
      <parentid>61015</parentid>
      <timestamp>2013-06-05T01:53:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>define each column explicitly to permit separate styling</comment>
      <text xml:space="preserve" bytes="116">&lt;tr class=&quot;t-dcl-sep&quot;&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;td&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;noinclude&gt;
{{documentation | Template:dcl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl small</title>
    <ns>10</ns>
    <id>10204</id>
    <redirect title="Template:dsc small" />
    <revision>
      <id>48593</id>
      <timestamp>2013-05-31T18:42:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl small]] to [[Template:dsc small]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:dsc small]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dcl small/doc</title>
    <ns>10</ns>
    <id>10203</id>
    <redirect title="Template:dsc small/doc" />
    <revision>
      <id>48591</id>
      <timestamp>2013-05-31T18:42:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:dcl small/doc]] to [[Template:dsc small/doc]]</comment>
      <text xml:space="preserve" bytes="36">#REDIRECT [[Template:dsc small/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl</title>
    <ns>10</ns>
    <id>108</id>
    <revision>
      <id>62274</id>
      <parentid>9881</parentid>
      <timestamp>2013-06-26T03:54:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update the definition</comment>
      <text xml:space="preserve" bytes="163">{{dcl begin}}
{{#if: {{{header|}}} |{{dcl header | {{{header}}}}} }}
{{dcl | notes={{{notes|}}} | since={{{since|}}} | until={{{until|}}} | {{{1|}}} }}
{{dcl end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl list/doc</title>
    <ns>10</ns>
    <id>10181</id>
    <redirect title="Template:dcl/doc" />
    <revision>
      <id>48544</id>
      <timestamp>2013-05-31T17:50:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:ddcl list/doc]] to [[Template:dcl/doc]]: prepare for renames</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dcl/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl list h</title>
    <ns>10</ns>
    <id>10236</id>
    <redirect title="Template:dcl h" />
    <revision>
      <id>48659</id>
      <timestamp>2013-05-31T18:48:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:ddcl list h]] to [[Template:dcl h]]</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[Template:dcl h]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl list header</title>
    <ns>10</ns>
    <id>10237</id>
    <redirect title="Template:dcl header" />
    <revision>
      <id>48661</id>
      <timestamp>2013-05-31T18:48:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:ddcl list header]] to [[Template:dcl header]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:dcl header]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl list item</title>
    <ns>10</ns>
    <id>10238</id>
    <redirect title="Template:dcl" />
    <revision>
      <id>48668</id>
      <parentid>48663</parentid>
      <timestamp>2013-05-31T18:50:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:dcl]]</comment>
      <text xml:space="preserve" bytes="26">#REDIRECT [[Template:dcl]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ddcl list sep</title>
    <ns>10</ns>
    <id>10239</id>
    <redirect title="Template:dcl sep" />
    <revision>
      <id>48665</id>
      <timestamp>2013-05-31T18:49:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:ddcl list sep]] to [[Template:dcl sep]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:dcl sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation</title>
    <ns>10</ns>
    <id>116</id>
    <revision>
      <id>10053</id>
      <parentid>3941</parentid>
      <timestamp>2011-08-29T20:38:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>evaluate #ifexist only if needed</comment>
      <text xml:space="preserve" bytes="2335">&lt;!--
  Automatically add {{template sandbox notice}} when on a /sandbox page.
--&gt;{{#ifeq: {{SUBPAGENAME}} | sandbox
| &lt;div style=&quot;clear: both;&quot;&gt;&lt;/div&gt;{{template sandbox notice}}
}}&lt;!--
  Automatically add {{pp-template}} to protected templates.
--&gt;{{template other
| {{#ifeq: {{PROTECTIONLEVEL:move}} | sysop
  | {{pp-template|docusage=yes}}
  | {{#if: {{PROTECTIONLEVEL:edit}}
    | {{pp-template|docusage=yes}}
    | &lt;!--Not protected, or only semi-move-protected--&gt;
    }}
  }}
}}&lt;!--
  Start of green doc box.
--&gt;{{documentation/start box2
| preload = {{{preload|}}}   &lt;!--Allow custom preloads--&gt;
| heading = {{{heading|¬}}}   &lt;!--Empty but defined means no header--&gt;
| heading-style = {{{heading-style|}}}
| content = {{{content|}}}

&lt;!--Some namespaces must have the /doc, /sandbox and /testcases 
    in talk space--&gt;
| docspace = {{documentation/docspace}}

| 1 = {{{1|}}}   &lt;!--Other docname, if fed--&gt;

&lt;!--The namespace is added in /start box2--&gt;
| template page = {{documentation/template page}}

}}&lt;!-- Start content --&gt;&lt;!--
  Start load the /doc content:
  Note: The line breaks between this comment and the next line are necessary
  so  &quot;=== Headings ===&quot; at the start and end of docs are interpreted.
--&gt;
{{#if:{{{content|}}}&lt;!--
--&gt;|{{{content|}}}&lt;!--
--&gt;|{{#if:{{{1|}}}&lt;!--
  --&gt;|{{#ifexist:{{{1|}}}&lt;!--
    --&gt;|{{ {{{1}}} }}&lt;!--
    --&gt;|&lt;!--
   --&gt;}}&lt;!--
  --&gt;|{{#ifexist:{{documentation/docspace}}:{{documentation/template page}}/doc&lt;!--
    --&gt;|{{ {{documentation/docspace}}:{{documentation/template page}}/doc }}&lt;!--
    --&gt;|&lt;!--
   --&gt;}}&lt;!--
 --&gt;}}
}}
&lt;!--
  End load the /doc content:
  Note: The line breaks between this comment and the previous line are necessary
  so  &quot;=== Headings ===&quot; at the start and end of docs are interpreted.
--&gt;{{documentation/end box2
| preload = {{{preload|}}}   &lt;!--Allow custom preloads--&gt;
| content = {{{content|}}}
| link box = {{{link box|}}}   &lt;!--So &quot;link box=off&quot; works--&gt;

&lt;!--Some namespaces must have the /doc, /sandbox and /testcases 
    in talk space--&gt;
| docspace = {{documentation/docspace}}

| 1 = {{{1|}}}   &lt;!--Other docname, if fed--&gt;

&lt;!--The namespace is added in /end box2--&gt;
| template page = {{documentation/template page}}

}}&lt;!--
  End of green doc box
--&gt;&lt;noinclude&gt;

&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/doc</title>
    <ns>10</ns>
    <id>117</id>
    <revision>
      <id>4626</id>
      <parentid>4625</parentid>
      <timestamp>2011-07-01T18:57:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>link to the standard wikipedia</comment>
      <text xml:space="preserve" bytes="8070">&lt;!-- PLEASE ADD CATEGORIES AND INTERWIKIS AT THE BOTTOM OF THIS PAGE --&gt;

This is the {{tl|documentation}} template.

For most of the instructions about how and when to use this template, see [[enwiki:Wikipedia:Template documentation]].

This template displays a green doc box like you are seeing now, and automatically loads the content from a /doc subpage. It can also load the content from other places if instructed to.

This template is intended for documenting templates and other pages which are [[enwiki:Wikipedia:Transclusion|transcluded]] onto other pages. It can be used in template space and most other [[enwiki:Wikipedia:Namespace|namespaces]].

Use of this template allows templates to be [[enwiki:Wikipedia:Protection policy|protected]] where necessary, while allowing anyone to edit the documentation, categories, and interwiki links.

=== Usage ===

Normally this template is used without any parameters, placed at the bottom of the template or page being documented, within &lt;code&gt;&amp;lt;noinclude&gt;&lt;/code&gt;:

&lt;pre&gt;
&lt;!--Last line of your template code--&gt;&lt;noinclude&gt;

{{documentation}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;
&lt;/pre&gt;

Then this template automatically loads the content from the /doc subpage of the template it is used on.

This template can also load the content from any other page. Like this:

&lt;pre&gt;
&lt;!--Last line of your template code--&gt;&lt;noinclude&gt;

{{documentation|Template:Other page/doc}}
&lt;/noinclude&gt;
&lt;/pre&gt;

Note that when loading the documentation from another page than the local /doc page it becomes tricky to handle the categories and interwiki links.

The content can also be fed directly as text. Like this:

&lt;pre&gt;
&lt;!--Last line of your template code--&gt;&lt;noinclude&gt;

{{documentation
| content = Some documentation text.
}}
&lt;/noinclude&gt;
&lt;/pre&gt;

When the '''content''' parameter is used the doc box normally doesn't show the [edit] [purge] links in the top right corner. Note that if the /doc page exists a link to it is still shown in the link box below the doc box. &lt;!--and no link to a /doc page is shown in the link box below the doc box.--&gt;

But parameter 1 and the '''content''' parameter can also be combined, like this:

&lt;pre&gt;
&lt;!--Last line of your template code--&gt;&lt;noinclude&gt;

{{documentation
| 1 = Template:Any page/doc
| content = {{Template:Any page/doc|parameters}}
}}
&lt;/noinclude&gt;
&lt;/pre&gt;

Then the pagename fed as parameter 1 is used for the [edit] [purge] links and for the /doc link in the link box below the doc box. But the '''content''' parameter is used for the content shown in the doc box. The above code means that the content is transcluded as &quot;&lt;code&gt;&lt;nowiki&gt;{{Template:Any page/doc|parameters}}&lt;/nowiki&gt;&lt;/code&gt;&quot;. In this example a parameter is also fed to the /doc page being loaded.

=== Best practice ===

The code should be added at the bottom of the template code, with no space before &quot;&lt;code&gt;&amp;lt;noinclude&gt;&lt;/code&gt;&quot; (which would cause extra space on pages where the template is used).

Categories and interwiki links that apply to the template itself should be added to the bottom of the /doc subpage, inside &lt;code&gt;&amp;lt;includeonly&gt;&amp;lt;/includeonly&gt;&lt;/code&gt; tags. For more complex cases, see [[enwiki:Wikipedia:Template documentation#Categories and interwiki links]].

If the documentation page contains &amp;lt;includeonly&gt; or &amp;lt;noinclude&gt; tags as part of the visible documentation text, replace the &quot;&lt;code&gt;&amp;lt;&lt;/code&gt;&quot; with &quot;&lt;code&gt;&amp;amp;lt;&lt;/code&gt;&quot;.
&lt;!--
=== The heading ===

When in Template space this template shows this heading:
:[[File:Template-info.svg|32px]] '''Template documentation'''

In most other namespaces, such as &quot;Wikipedia:&quot;, it shows this heading:
:'''Documentation'''

But when on File (image) pages it shows this heading:
:'''Summary'''

The '''heading''' parameter can be used to set the heading to something else. Like this:

:&lt;code&gt;&lt;nowiki&gt;{{documentation| heading = Infobox documentation }}&lt;/nowiki&gt;&lt;/code&gt;

If the '''heading''' parameter is empty but defined, no heading is shown and no [edit] [purge] links are shown. Like this:

:&lt;code&gt;&lt;nowiki&gt;{{documentation| heading = }}&lt;/nowiki&gt;&lt;/code&gt;

The '''heading-style''' parameter can be fed optional [[Cascading Style Sheets|CSS]] values. Without quotation marks &lt;code&gt;&quot; &quot;&lt;/code&gt; but with the ending semicolons &lt;code&gt;;&lt;/code&gt;. For example:
:&lt;code&gt;heading-style = color: red; font-size: 150%;&lt;/code&gt;

=== The link box ===

Below the big doc box is a small link box that shows some meta-data about the documentation. The link box shows different things depending on what parameters are fed to this template, and in which namespace it is used. In some cases the link box is not shown at all.

To hide the link box, add the parameter &quot;{{para|link box|off}}&quot;.

You can also insert customised text in the link box, by defining the {{para|link box}} parameter. For example:
&lt;pre&gt;|link box=This documentation is automatically generated by [[Template:Country showdata]]&lt;/pre&gt;

=== Automatic functions ===

If the documentation page doesn't exist, the [create] link includes a [[mw:Manual:Creating pages with preloaded text|preload]] page so that clicking it will pre-fill the edit form with the basic documentation page format. Preload text is also used for the /sandbox and /testcases &lt;small&gt;(create)&lt;/small&gt; links.

When this template is on a protected template page it now automatically adds {{tl|pp-template}} which shows the grey or red padlock in the top right corner. So no need to manually add {{tlf|pp-template}} to templates that use {{tl|documentation}}.

When this template is on a /sandbox subpage it automatically adds the {{tl|template sandbox notice}}.

=== Subject space vs talk space ===

Terminology: ''Subject space'' is the opposite of ''talk space''. For instance &quot;Template:&quot; is the subject space of &quot;Template talk:&quot;.

This template is usually placed in subject space, within &amp;lt;noinclude&gt; tags. But in some cases this template needs to be on the talkpage:

* For preload pages (usually in Template or Wikipedia space), since they can't use &amp;lt;noinclude&gt;. See for instance [[Template talk:AfC preload]] and [[Template talk:RfD subpage starter]]. Such talkpages can be marked with {{tl|talkdoc}}.

* In MediaWiki space, since &amp;lt;noinclude&gt; often doesn't work in system messages and since MediaWiki space needs to be kept clean for performance reasons.

When placed on talkpages this template usually is placed near the top of the page and without &amp;lt;noinclude&gt; tags.

The /doc, /sandbox and /testcases pages should normally be in subject space, except in the namespaces that don't have the MediaWiki [[meta:Link#Subpage feature|subpage feature]] enabled: Main, File, MediaWiki and Category. (But currently we only show the /sandbox and /testcases links from User, User talk, Template and Template talk space.) There are also a whole bunch of other technical reasons why the /doc page must be stored under the talkpage for those namespaces.

This template automatically points its create links for the /doc, /sandbox and /testcases to the right namespace.

=== Technical details ===

This template calls {{tl|documentation/start box2}} and {{tl|documentation/end box2}} which in turn call {{tl|documentation/start box}} and {{tl|documentation/end box}}. /start box (and /end box) hold most of the code, while this template and /start box2 (and /end box2) do parameter preprocessing.

The preload page for the /doc [create] link is [[Template:Documentation/preload]], but in File space it is [[Template:Documentation/preload-filespace]]. The preload pages for the /sandbox and /testcases &lt;small&gt;(create)&lt;/small&gt; links are [[Template:Documentation/preload-sandbox]] and [[Template:Documentation/preload-testcases]].

For more technical details see the [[Template talk:Documentation|talk page]].
--&gt;
=== See also ===

&lt;!-- {{documentation/see also}} --&gt;
* {{tl|documentation}} – Placed on templates and other pages to document them.
&lt;!--* {{tl|documentation subpage}} – Used at the top of /doc subpages to explain what they are and to link back to the page they document.--&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/docspace</title>
    <ns>10</ns>
    <id>118</id>
    <revision>
      <id>20014</id>
      <parentid>235</parentid>
      <timestamp>2012-03-19T18:30:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="172">{{#switch: {{SUBJECTSPACE}}
  | {{ns:0}}
  | {{ns:File}}
  | {{ns:MediaWiki}}
  | {{ns:Category}} = {{TALKSPACE}}
  | #default = {{SUBJECTSPACE}}
}}&lt;noinclude&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/end box</title>
    <ns>10</ns>
    <id>119</id>
    <revision>
      <id>4627</id>
      <parentid>237</parentid>
      <timestamp>2011-07-01T18:58:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use links to the standard wikipedia</comment>
      <text xml:space="preserve" bytes="3706">&lt;noinclude&gt;&lt;div&gt;&lt;/noinclude&gt;&lt;div style=&quot;clear: both;&quot;&gt;&lt;/div&gt;&lt;!--So right or left floating items don't stick out of the doc box.--&gt;
&lt;/div&gt;&lt;!--End of green doc box--&gt;&lt;!--
  Link box below for the doc meta-data:
--&gt;{{#if: 
  &lt;!--Check if we should show the link box--&gt;
  {{#ifeq: {{{link box|}}} | off
  |
  | {{{doc exist|yes}}}{{
    #switch: {{SUBJECTSPACE}}
    | {{ns:User}}
    | {{ns:Template}} = yes
    }}
  }}

| {{fmbox
  | id = documentation-meta-data
  | image = none
  | style = background-color: #ecfcf4;
  | textstyle = font-style: italic;
  | text = 
    {{#if: {{{link box|}}}
    | {{{link box}}}   &lt;!--Use custom link box content--&gt;
    | {{#if: {{{doc exist|yes}}}
      | &lt;!--/doc exists, link to it--&gt;
        The above [[enwiki:Wikipedia:Template documentation|documentation]] is [[enwiki:Wikipedia:Transclusion|transcluded]] from [[{{{docpage|{{FULLPAGENAME}}/doc}}}]]. &lt;small style=&quot;font-style: normal&quot;&gt;([{{fullurl:{{{docpage|{{FULLPAGENAME}}/doc}}}|action=edit}} edit] &amp;#124; [{{fullurl:{{{docpage|{{FULLPAGENAME}}/doc}}}|action=history}} history])&lt;/small&gt; &lt;br&gt;
      }}&lt;!-- 
        Add links to /sandbox and /testcases when appropriate:
   --&gt;&lt;!--{{#switch: {{SUBJECTSPACE}}
      | {{ns:User}}
      | {{ns:Template}} = 
        Editors can experiment in this template's {{
        #ifexist: {{{sandbox| {{FULLPAGENAME}}/sandbox }}}
        | [[{{{sandbox| {{FULLPAGENAME}}/sandbox }}}|sandbox]] &lt;small style=&quot;font-style: normal&quot;&gt;([{{fullurl: {{{sandbox| {{FULLPAGENAME}}/sandbox }}} | action=edit }} edit] {{!}} [{{fullurl:Wikipedia:pagediff | withJS={{urlencode:MediaWiki:Common.js/pagediff.js}}&amp;oldpage={{urlencode:{{{template page|{{FULLPAGENAME}}}}}}}&amp;newpage={{urlencode:{{{sandbox|{{FULLPAGENAME}}/sandbox}}}}}}} diff])&lt;/small&gt; 
        | sandbox &lt;small style=&quot;font-style: normal&quot;&gt;([{{fullurl: {{{sandbox| {{FULLPAGENAME}}/sandbox }}} | action=edit&amp;preload=Template:Documentation/preload-sandbox }} create])&lt;/small&gt; 
        }} and {{
        #ifexist: {{{testcases| {{FULLPAGENAME}}/testcases }}}
        | [[{{{testcases| {{FULLPAGENAME}}/testcases }}}|testcases]] &lt;small style=&quot;font-style: normal&quot;&gt;([{{fullurl: {{{testcases| {{FULLPAGENAME}}/testcases }}} | action=edit }} edit])&lt;/small&gt;
        | testcases &lt;small style=&quot;font-style: normal&quot;&gt;([{{fullurl: {{{testcases| {{FULLPAGENAME}}/testcases }}} | action=edit&amp;preload=Template:Documentation/preload-testcases }} create])&lt;/small&gt;
        }} pages. &lt;br&gt;
      }}--&gt;&lt;!--
        Show the cats and interwiki text, but not 
        if &quot;content&quot; fed or &quot;docname fed&quot; since then it is 
        unclear where to add the cats and interwikis.
   --&gt;{{#if: {{{content|}}} {{{docname fed|}}}
      | 
      | Please add categories and interwikis to the [[{{{docpage|{{FULLPAGENAME}}/doc}}}|/doc]] subpage.
      }}&lt;!--
        Show the &quot;Subpages&quot; link:
   --&gt;{{#switch: {{SUBJECTSPACE}}
      | {{ns:File}} =   &lt;!--Don't show it--&gt;
      | {{ns:Template}} = &amp;#32;[[Special:PrefixIndex/{{{template page|{{FULLPAGENAME}}}}}/|Subpages of this template]].
      | #default = &amp;#32;[[Special:PrefixIndex/{{{template page|{{FULLPAGENAME}}}}}/|Subpages of this page]].
      }}
    }}
  }}
}}&lt;!--End link box--&gt;&lt;!--

  Detect and report strange usage:
--&gt;{{#if:

  &lt;!--Check if {{documentation}} is transcluded 
      on a /doc or /testcases page--&gt;
  {{#switch: {{SUBPAGENAME}}
  | doc
  | testcases = strange
  }}
  &lt;!--More checks can be added here, just return anything
      to make the surrounding if-case trigger--&gt;

| &lt;includeonly&gt;[[Category:Wikipedia pages with strange ((documentation)) usage|{{main other|Main:}}{{FULLPAGENAME}}]]&lt;!-- Sort on namespace --&gt;&lt;/includeonly&gt;

}}&lt;noinclude&gt;
{{pp-template|small=yes}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/end box2</title>
    <ns>10</ns>
    <id>120</id>
    <revision>
      <id>239</id>
      <parentid>238</parentid>
      <timestamp>2011-06-06T22:43:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="880">{{documentation/end box
| preload = {{{preload|}}}   &lt;!--Allow custom preloads--&gt;
| content = {{{content|}}}
| link box = {{{link box|}}}   &lt;!--So &quot;link box=off&quot; works--&gt;

| docpage = 
  {{#if: {{{1|}}}
  | {{{1|}}}
  | {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/doc
  }}
| doc exist = 
  {{#ifexist: 
    {{#if: {{{1|}}}
    | {{{1|}}}   &lt;!--Other docname fed--&gt;
    | {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/doc
    }}
  | yes
  }}
| docname fed =
  {{#if: {{{1|}}}
  | yes
  }}

| sandbox = 
  {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/sandbox
| testcases = 
  {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/testcases

| template page = 
  {{NAMESPACE}}:{{{template page|{{PAGENAME}}}}}

}}&lt;noinclude&gt;

{{pp-template}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/start box</title>
    <ns>10</ns>
    <id>121</id>
    <revision>
      <id>241</id>
      <parentid>240</parentid>
      <timestamp>2011-06-06T22:43:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="1650">&lt;!--
  Start of green doc box
--&gt;&lt;div id=&quot;template-documentation&quot; class=&quot;template-documentation iezoomfix&quot;&gt;&lt;!--
  Add the heading at the top of the doc box:
--&gt;{{#ifeq: {{{heading|¬}}} | &lt;!--Defined but empty--&gt;
| &lt;!--&quot;heading=&quot;, do nothing--&gt;
| &lt;div style=&quot;padding-bottom: 3px; border-bottom: 1px solid #aaa; margin-bottom: 1ex;&quot;&gt;{{
  #if: {{{content|}}}
  | 
  | &lt;!--Add the [edit][purge] or [create] links--&gt;
    &lt;span class=&quot;editsection plainlinks&quot; id=&quot;doc_editlinks&quot;&gt;{{
    #if: {{{doc exist|yes}}}
    | [[{{fullurl:{{{docpage|{{FULLPAGENAME}}/doc}}}|action=edit}} edit]] [{{purge|purge}}] 
    | &lt;!--/doc doesn't exist--&gt;
      [[{{fullurl:{{{docpage|{{FULLPAGENAME}}/doc}}}| action=edit&amp;preload={{
        #if: {{{preload|}}} 
        | {{urlencode:{{{preload}}}}}
        | {{#ifeq: {{SUBJECTSPACE}} | {{ns:File}}
          | Template:Documentation/preload-filespace
          | Template:Documentation/preload
          }} }} }} create]]
    }}&lt;/span&gt;
  }} &lt;span style=&quot;{{#if: {{{heading-style|}}}
  | {{{heading-style|}}}
  | {{#ifeq: {{SUBJECTSPACE}} | {{ns:Template}}
    | font-weight: bold; font-size: 125%
    | font-size: 150%
    }}
  }}&quot;&gt;{{#switch: {{{heading|¬}}}
  | ¬ =   
    &lt;!--&quot;heading&quot; not defined in this or previous level--&gt;
    {{#switch: {{SUBJECTSPACE}} 
    | {{ns:Template}} = Template documentation
    | {{ns:File}} = Summary
    | #default = Documentation
    }}
  | #default = 
    &lt;!--&quot;heading&quot; has data or is empty but defined--&gt;
    {{{heading|}}}
  }}&lt;/span&gt;&lt;/div&gt;
}}&lt;noinclude&gt;&lt;!-- close the div --&gt;&lt;/div&gt;

{{pp-template}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/start box2</title>
    <ns>10</ns>
    <id>122</id>
    <revision>
      <id>243</id>
      <parentid>242</parentid>
      <timestamp>2011-06-06T22:43:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="641">{{documentation/start box
| preload = {{{preload|}}}   &lt;!--Allow custom preloads--&gt;
| heading = {{{heading|¬}}}   &lt;!--Empty but defined means no header--&gt;
| heading-style = {{{heading-style|}}}
| content = {{{content|}}}

| docpage = 
  {{#if: {{{1|}}}
  | {{{1|}}}
  | {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/doc
  }}

| doc exist = 
  {{#ifexist: 
    {{#if: {{{1|}}}
    | {{{1|}}}   &lt;!--Other docname fed--&gt;
    | {{{docspace|{{NAMESPACE}}}}}:{{{template page|{{PAGENAME}}}}}/doc
    }}
  | yes
  }}

}}&lt;noinclude&gt;

{{pp-template}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/template page</title>
    <ns>10</ns>
    <id>123</id>
    <revision>
      <id>20010</id>
      <parentid>245</parentid>
      <timestamp>2012-03-19T18:27:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="136">{{#switch: {{SUBPAGENAME}}
| sandbox
| testcases = {{BASEPAGENAME}}
| #default = {{PAGENAME}}
}}&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:documentation/template page/doc</title>
    <ns>10</ns>
    <id>5497</id>
    <revision>
      <id>20011</id>
      <timestamp>2012-03-19T18:28:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc</comment>
      <text xml:space="preserve" bytes="85">This subtemplate of {{tl|documentation}} is used to determine the template page name.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc</title>
    <ns>10</ns>
    <id>92</id>
    <revision>
      <id>71961</id>
      <parentid>61686</parentid>
      <timestamp>2014-07-04T18:33:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not add an additional row for separators</comment>
      <text xml:space="preserve" bytes="292">|- class=&quot;t-dsc&quot;
{{#if: {{{2|}}}
|{{!}} {{{1}}}
{{!}} {{{2}}}&lt;!--
--&gt;{{dsc editlink|dummy}}
|{{!}} colspan=&quot;2&quot; {{!}} {{{1}}}&lt;!--
--&gt;{{dsc editlink|dummy}}&lt;!-- dummy parameter to disable a MediaWiki optimization
--&gt;}}
{{dsc guard}}
&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1>s9mltl58f8naj1a0bsp1wba9s5k6dqs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc/doc</title>
    <ns>10</ns>
    <id>83</id>
    <revision>
      <id>48788</id>
      <parentid>48649</parentid>
      <timestamp>2013-06-01T00:10:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rename 'template' to 'inc'</comment>
      <text xml:space="preserve" bytes="11636">This is one of the family of templates used for creation of description list. These templates should be used to design function, variable or type lists.

{{list/doc}}

{{tl|dsc begin}}
: starts the description list

{{tl|dsc end}}
: ends the description list

{{tl|dsc h1 | ''heading''}}
: adds heading to the description list (&lt;tt&gt;h3&lt;/tt&gt; level)

{{tl|dsc h2 | ''heading''}}
: adds sub-heading to the description list (&lt;tt&gt;h5&lt;/tt&gt; level)

{{tl|dsc header}}
: adds explanation which header the features come from

{{tl|dsc namespace}}
: adds explanation which namespace the features are in

{{tl|dsc sep}}
: adds a separator

{{tl|dsc | ''name'' | ''explanation'' }}
: adds a generic item to the description list. If ''explanation'' is omitted, the item spans through both columns.

{{tl|dsc hitem | ''name'' | ''explanation'' }}
: adds a highlighted item to the description list. If ''explanation'' is omitted, the item spans through both columns.

{{tl|dsc inc | ''location'' | ''param1'' {{mark optional}} | ''param2'' {{mark optional}} ... }}
: Sets {{tt|dsc-list-template-name}} [https://www.mediawiki.org/wiki/Extension:Variables variable] to ''location'', includes the template from ''location'' and unsets the variable. Use this template whenever copying dsc items from a template; this will add an edit link to them. The unnamed parameters ''param1'', ''param2'', ... are passed to the template.

{{tl|dsc break}}
: breaks the columns. The width of the columns above does not depend on the content below and vice-versa.

{{tl|dsc todo | ''reason'' }}
: adds a todo item (similar to {{tl|todo}})

===Specialized templates===

There are templates already specialized for most of the usage cases.

; Classes

{{tl|dsc class | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a class.

{{tl|dsc tclass | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a class template.

{{tl|dsc ptclass | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a class template specialization.

{{tl|dsc mem class | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a member class.

; Functions

{{tl|dsc fun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a function

{{tl|dsc tfun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a function template.

&lt;!--
{{tl|dsc ptfun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a function template specialization.
--&gt;
{{tl|dsc mem fun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a public member function.

{{tl|dsc prot mem fun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a protected member function template.

{{tl|dsc mem ctor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a public constructor.

{{tl|dsc prot mem ctor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a protected constructor.

{{tl|dsc mem dtor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a public destructor.

{{tl|dsc prot mem dtor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a protected destructor.

{{tl|dsc mem vdtor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a virtual public destructor.

{{tl|dsc prot mem vdtor | ''link'' | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a virtual protected destructor.

{{tl|dsc mem sfun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a static member function.

{{tl|dsc mem vfun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a virtual public member function template.

{{tl|dsc prot mem vfun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a virtual protected member function template.

{{tl|dsc macro fun | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}} -
adds an item linking to a description of a function macro.

; Constants

{{tl|dsc macro const | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a macro constant.

{{tl|dsc const | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a global constant variable.

{{tl|dsc mem const | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a constant member variable.

{{tl|dsc mem sconst | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a static constant member variable.

; Objects

{{tl|dsc mem obj | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a member object.

{{tl|dsc prot mem obj | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a protected member object.

{{tl|dsc priv mem obj | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a private member object.

; Miscellaneous

{{tl|dsc typedef | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a typedef.

{{tl|dsc enum | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a enum or enum class.

{{tl|dsc concept | ''link'' | title{{=}}''link title''{{mark optional}} | notes{{=}}''link notes''{{mark optional}} | ''explanation''}}
: adds an item linking to a description of a [[cpp/concept|concept]].

:; Parameters

''link''
: this parameter controls the link target.

{{tt|title}}=''link title''
: this parameter overrides the link title

{{tt|notes}}=''link notes''
: this parameter adds text besides the link that is not the part of the link

''explanation''
: the explanation of the feature.

All templates accept {{tt|nolink{{=}}true}} parameter. In that case no link is made, the formatting is the same.

The templates for member objects accept {{tt|inlinemem{{=}}true}} parameter. This should be used if the functionality is described inline in the page of the class.

===See also templates===
Used in ''see also'' lists.

{{tl|dsc see cpp | ''location'' 
 | ''nomono''{{=}}{{tt|true_if_serif}} {{mark optional}} 
 | ''title1''{{mark optional}} 
 | ''title2''{{mark optional}} ... 
}}
: adds a link to C++ documentation of a feature. 

{{tl|dsc see c | ''location'' 
 | ''nomono''{{=}}{{tt|true_if_serif}} {{mark optional}} 
 | ''title1''{{mark optional}} 
 | ''title2''{{mark optional}} ... 
}}
: adds a link to C documentation of a feature.

:; Parameters

''location''
: this parameter controls the link target.

''nomono''
: {{tt|true}} if serif font should be used for the title

''title1'', ''title2'', ...
: this parameter overrides the title (default the title is guessed from ''location''). Commas are placed between titles if several of them are provided.

===Example===

  &lt;nowiki&gt;
  {{dsc begin}}
  {{dsc h1 | Magic creatures}}
  {{dsc h2 | Dragon}}
  {{dsc header | dragon.h}}
  {{dsc fun | cpp/dragon/call_dragon | calls the dragon}}
  {{dsc fun | cpp/dragon/receive_fire | receives the fire}}
  {{dsc end}}
  &lt;/nowiki&gt;

The above results in the following:

{{dsc begin}}
{{dsc h1 | Magic creatures}}
{{dsc h2 | Dragon}}
{{dsc header | dragon.h}}
{{dsc fun | cpp/dragon/call_dragon | calls the dragon}}
{{dsc fun | cpp/dragon/receive_fire | receives the fire}}
{{dsc end}}

===Templates used in the implementation===

===={{tl|dsc member}}====
{{tl|dsc member | ''page'' | ''title'' {{mark optional}} | title=''title'' {{mark optional}} | nolink{{=}}''true_if_nolink'' {{mark optional}} | nobold{{=}}''true_if_nobold'' {{mark optional}} | notes{{=}}''notes'' {{mark optional}}}}
: Default title of the link is ''page''. Custom title can be supplied via the second unnamed parameter or {{tt|title}} parameter. If {{tt|nolink}} is ''true'', no link is produced. 

: Default font of the link is bold monospace. If {{tt|nobold}} is ''true'', the font is normal serif.

: Additional notes to be placed in the right of the link can be passed through {{tt|notes}} parameter.

: Both {{tt|title}} and {{tt|notes}} can accept &amp;lt;br&amp;gt; tags without breaking the layout.

===={{tl|dsc mark mem}}====
{{tl|dsc mark mem | ''link'' | ''mark_class'' | nomem{{=}}''true_if_nomem'' {{mark optional}} | inlinemem{{=}}''true_if_inlinemem'' {{mark optional}} }}
: Outputs {{tlc|mark ''mark_class''}} potentially appending additional description of the class the function/class is member of. 

: Specifically, the template checks if the parent of the page linked to by {{tt|link}} is a parent of the page the template is used in (i.e. they are siblings). For example, consider {{tt|link}} ''{{=}} a/b/c'' and ''page'' the page the template is used in. Then the template would append the additional description if {{tt|page}} equals to ''z/z/z'', or ''a/z'', or ''a/b/z/z'', but not if ''page'' is ''a/b/z'' or ''a/b''.

: If {{tt|nomem}} is ''true'' then additional description is never appended.

: The template fetches information about the name of the parent class from ''a/b/title'' page.

: If {{tt|inlinemem}} is ''true'' then the name of the parent class is fetched from ''a/b/c/title'' template. This is used when a class includes descriptions of its members inline.

===={{tl|dsc editlink}}====
{{tl|dsc editlink}}
: Outputs an &lt;nowiki&gt;[edit]&lt;/nowiki&gt; text with a link pointing to a page for editing the template whose name is defined in {{tt|dsc-list-template-name}} variable. At least one dummy parameter must be passed to this template, as Mediawiki software employs some optimizations that break the implementation.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc begin</title>
    <ns>10</ns>
    <id>84</id>
    <revision>
      <id>61682</id>
      <parentid>61063</parentid>
      <timestamp>2013-06-08T05:25:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="112">&lt;includeonly&gt; {| class=&quot;t-dsc-begin&quot; &lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc break</title>
    <ns>10</ns>
    <id>5574</id>
    <revision>
      <id>61148</id>
      <parentid>48552</parentid>
      <timestamp>2013-06-05T12:22:24Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;dcl list/doc&quot; to &quot;dsc/doc&quot;</comment>
      <text xml:space="preserve" bytes="124">&lt;includeonly&gt;{{dcl list end}}
{{dcl list begin}}&lt;/includeonly&gt;
&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc class</title>
    <ns>10</ns>
    <id>85</id>
    <revision>
      <id>61746</id>
      <parentid>61064</parentid>
      <timestamp>2013-06-08T05:37:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="196">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark class}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc concept</title>
    <ns>10</ns>
    <id>2426</id>
    <revision>
      <id>61716</id>
      <parentid>61150</parentid>
      <timestamp>2013-06-08T05:32:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="198">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark concept}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc const</title>
    <ns>10</ns>
    <id>2649</id>
    <revision>
      <id>61726</id>
      <parentid>61151</parentid>
      <timestamp>2013-06-08T05:34:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="196">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark const}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc editlink</title>
    <ns>10</ns>
    <id>8415</id>
    <revision>
      <id>56131</id>
      <parentid>48647</parentid>
      <timestamp>2013-06-01T05:31:20Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="284">&lt;onlyinclude&gt;{{#if:{{#var:dcl-list-template-name}}|&lt;span class=&quot;editsection noprint plainlinks&quot; title=&quot;Edit this template&quot;&gt;[{{fullurl:Template:{{#var:dcl-list-template-name}}|action=edit}} &amp;#91;edit&amp;#93;]&lt;/span&gt;}}&lt;/onlyinclude&gt;&lt;noinclude&gt;{{documentation|Template:dsc/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc end</title>
    <ns>10</ns>
    <id>86</id>
    <revision>
      <id>61152</id>
      <parentid>48645</parentid>
      <timestamp>2013-06-05T12:23:00Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;dcl list/doc&quot; to &quot;dsc/doc&quot;</comment>
      <text xml:space="preserve" bytes="63">|}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc enum</title>
    <ns>10</ns>
    <id>5468</id>
    <revision>
      <id>61845</id>
      <parentid>61717</parentid>
      <timestamp>2013-06-09T15:55:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="195">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark enum}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc fun</title>
    <ns>10</ns>
    <id>87</id>
    <revision>
      <id>61742</id>
      <parentid>61154</parentid>
      <timestamp>2013-06-08T05:37:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="194">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark fun}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc guard</title>
    <ns>10</ns>
    <id>88</id>
    <revision>
      <id>48639</id>
      <parentid>3967</parentid>
      <timestamp>2013-05-31T18:45:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:dcl list guard]] to [[Template:dsc guard]]</comment>
      <text xml:space="preserve" bytes="2">|-</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc h1</title>
    <ns>10</ns>
    <id>89</id>
    <revision>
      <id>61713</id>
      <parentid>61155</parentid>
      <timestamp>2013-06-08T05:30:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="112">|-
| colspan=&quot;2&quot; | &lt;h3&gt;{{{1|}}}&lt;/h3&gt;
{{dsc guard}}&lt;noinclude&gt;
{{documentation | Template:dsc/doc }}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc h2</title>
    <ns>10</ns>
    <id>90</id>
    <revision>
      <id>61714</id>
      <parentid>61157</parentid>
      <timestamp>2013-06-08T05:30:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="115">|- 
| colspan=&quot;2&quot; | &lt;h5&gt; {{{1|}}} &lt;/h5&gt;
{{dsc guard}}&lt;noinclude&gt;
{{documentation | Template:dsc/doc }}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc header</title>
    <ns>10</ns>
    <id>91</id>
    <revision>
      <id>61688</id>
      <parentid>61158</parentid>
      <timestamp>2013-06-08T05:27:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="239">|- class=&quot;t-dsc-header&quot;
| colspan=&quot;2&quot; | &lt;div&gt;{{#if: {{{1|}}} | Defined in header &lt;code&gt;&lt;nowiki&gt;&lt;&lt;/nowiki&gt;{{trim|{{{1}}}}}&lt;nowiki&gt;&gt;&lt;/nowiki&gt;&lt;/code&gt; }} &lt;/div&gt;
{{dsc guard}}&lt;!--
--&gt;&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc header/link</title>
    <ns>10</ns>
    <id>9740</id>
    <revision>
      <id>48562</id>
      <parentid>45175</parentid>
      <timestamp>2013-05-31T18:38:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:dcl list header/link]] to [[Template:dsc header/link]]</comment>
      <text xml:space="preserve" bytes="133">&lt;onlyinclude&gt;{{#switch:{{#explode:{{PAGENAME}}|/|0}}
|cpp=[[cpp/header/{{{1|}}}|&amp;lt;{{{1|}}}&amp;gt;]]
|&amp;lt;{{{1|}}}&amp;gt;
}}&lt;/onlyinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc hitem</title>
    <ns>10</ns>
    <id>8593</id>
    <revision>
      <id>71960</id>
      <parentid>61687</parentid>
      <timestamp>2014-07-04T18:33:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not add an additional row for separators</comment>
      <text xml:space="preserve" bytes="298">|- class=&quot;t-dsc-hitem&quot;
{{#if: {{{2|}}}
|{{!}} {{{1}}}
{{!}} {{{2}}}&lt;!--
--&gt;{{dsc editlink|dummy}}
|{{!}} colspan=&quot;2&quot; {{!}} {{{1}}}&lt;!--
--&gt;{{dsc editlink|dummy}}&lt;!-- dummy parameter to disable a MediaWiki optimization
--&gt;}}
{{dsc guard}}
&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1>nz0a00qeiy5kcaabbwwea862pse6ruy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc inc</title>
    <ns>10</ns>
    <id>106</id>
    <revision>
      <id>61160</id>
      <parentid>48789</parentid>
      <timestamp>2013-06-05T12:24:21Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;dcl list/doc&quot; to &quot;dsc/doc&quot;</comment>
      <text xml:space="preserve" bytes="425">{{#if:{{{1|}}}&lt;!--
--&gt;|{{#vardefine:dcl-list-template-name|{{{1|}}}}}&lt;!--
 --&gt;{{ {{{1|}}}&lt;!--
    --&gt;|{{trim|{{{2|}}}}}&lt;!--
    --&gt;|{{trim|{{{3|}}}}}&lt;!--
    --&gt;|{{trim|{{{4|}}}}}&lt;!--
    --&gt;|{{trim|{{{5|}}}}}&lt;!--
    --&gt;|{{trim|{{{6|}}}}}&lt;!--
    --&gt;|{{trim|{{{7|}}}}}&lt;!--
--&gt;}}{{#vardefine:dcl-list-template-name}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc macro const</title>
    <ns>10</ns>
    <id>93</id>
    <revision>
      <id>61727</id>
      <parentid>61161</parentid>
      <timestamp>2013-06-08T05:34:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="202">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark macro const}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc macro fun</title>
    <ns>10</ns>
    <id>2420</id>
    <revision>
      <id>61728</id>
      <parentid>61163</parentid>
      <timestamp>2013-06-08T05:34:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="200">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark macro fun}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mark mem</title>
    <ns>10</ns>
    <id>4972</id>
    <revision>
      <id>61164</id>
      <parentid>48596</parentid>
      <timestamp>2013-06-05T12:24:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;dcl list/doc&quot; to &quot;dsc/doc&quot;</comment>
      <text xml:space="preserve" bytes="540">&lt;onlyinclude&gt;{{#if: {{#ifeq: {{#titleparts:{{PAGENAME}}|-1}} | {{#titleparts:{{{1}}}|-1}} |no}}
                    {{#ifeq: {{#titleparts:{{PAGENAME}}}} | {{#titleparts:{{{1}}}|-1}} |no}}
                    {{#ifeq: {{{nomem|}}}|true|no}} &lt;!-- check if additional description is needed
--&gt;|{{mark {{{2|mem fun}}} }} &lt;!-- 
--&gt;|{{mark {{{2|mem fun}}} | mem={{Template:{{#titleparts:{{{1|n//n}}}|{{#ifeq: {{{inlinemem|}}}|true|0|-1}}}}/title|#MAGICTITLESTRING#}} }}
}}&lt;/onlyinclude&gt;&lt;noinclude&gt;{{documentation | Template:dsc/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem class</title>
    <ns>10</ns>
    <id>94</id>
    <revision>
      <id>61743</id>
      <parentid>61165</parentid>
      <timestamp>2013-06-08T05:37:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="273">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem class | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem const</title>
    <ns>10</ns>
    <id>96</id>
    <revision>
      <id>61725</id>
      <parentid>61166</parentid>
      <timestamp>2013-06-08T05:34:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="273">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem const | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem ctor</title>
    <ns>10</ns>
    <id>2393</id>
    <revision>
      <id>61737</id>
      <parentid>61168</parentid>
      <timestamp>2013-06-08T05:36:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="324">{{dsc | {{dsc member | {{{1|}}} | (constructor) | notes={{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem dtor</title>
    <ns>10</ns>
    <id>2394</id>
    <revision>
      <id>61735</id>
      <parentid>61170</parentid>
      <timestamp>2013-06-08T05:36:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="323">{{dsc | {{dsc member | {{{1|}}} | (destructor) | notes={{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem fun</title>
    <ns>10</ns>
    <id>98</id>
    <revision>
      <id>61740</id>
      <parentid>61171</parentid>
      <timestamp>2013-06-08T05:36:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="271">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem obj</title>
    <ns>10</ns>
    <id>2196</id>
    <revision>
      <id>61722</id>
      <parentid>61172</parentid>
      <timestamp>2013-06-08T05:34:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="271">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem obj | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem sconst</title>
    <ns>10</ns>
    <id>99</id>
    <revision>
      <id>61724</id>
      <parentid>61173</parentid>
      <timestamp>2013-06-08T05:34:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="291">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{cmark static}} {{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem sconst | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem sfun</title>
    <ns>10</ns>
    <id>100</id>
    <revision>
      <id>61731</id>
      <parentid>61175</parentid>
      <timestamp>2013-06-08T05:35:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="289">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{cmark static}} {{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem sfun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem vdtor</title>
    <ns>10</ns>
    <id>2395</id>
    <revision>
      <id>61733</id>
      <parentid>61177</parentid>
      <timestamp>2013-06-08T05:35:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="342">{{dsc | {{dsc member | {{{1|}}} | (destructor) | notes={{cmark virtual}} {{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem vfun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc mem vfun</title>
    <ns>10</ns>
    <id>103</id>
    <revision>
      <id>61730</id>
      <parentid>61178</parentid>
      <timestamp>2013-06-08T05:35:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="290">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{cmark virtual}} {{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | mem vfun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc member</title>
    <ns>10</ns>
    <id>165</id>
    <revision>
      <id>65207</id>
      <parentid>61711</parentid>
      <timestamp>2013-09-04T23:29:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{lines}} for notes</comment>
      <text xml:space="preserve" bytes="449">{{#if: {{{1|}}}&lt;!--
--&gt; | &lt;div class=&quot;t-dsc-member-div {{#ifeq:{{{nobold|}}}|true|t-dsc-member-nobold-div}}&quot;&gt;&lt;!--
     --&gt;&lt;div&gt;{{#ifeq:{{{nolink|}}} | true | {{#if:{{{2|}}}|{{{2|}}}|{{{1|}}}}} | [[{{{1}}} | {{lines|{{ltt/core|{{{1}}}|{{{2|}}}}}}}]]}}&lt;/div&gt;&lt;!--
     --&gt;{{#if:{{{notes|}}}|&lt;div&gt;{{lines|{{{notes}}}}}&lt;/div&gt;}}&lt;!--
   --&gt;&lt;/div&gt;&lt;!--
--&gt; | {{error | no member given}} &lt;!--
--&gt;}}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1>3yoz7fopq5lciyvytvq4w2jr7q1dw3i</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc namespace</title>
    <ns>10</ns>
    <id>2239</id>
    <revision>
      <id>64391</id>
      <parentid>64386</parentid>
      <timestamp>2013-08-15T20:22:38Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>the space following &quot;inline&quot; inside #ifeq was being stripped; let's try having a potential double space</comment>
      <text xml:space="preserve" bytes="242">|- class=&quot;t-dsc-header&quot;
| colspan=&quot;2&quot; | &lt;div&gt;{{#if: {{{1|}}} | Defined in {{#ifeq:{{{inline|}}}|true|inline}} namespace &lt;code&gt;{{trim|{{{1}}}}}&lt;/code&gt; }} &lt;/div&gt;
{{dsc guard}}&lt;!--
--&gt;&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc priv mem ctor</title>
    <ns>10</ns>
    <id>10137</id>
    <revision>
      <id>56172</id>
      <parentid>48632</parentid>
      <timestamp>2013-06-01T05:32:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="329">{{dsc | {{dsc member | {{{1|}}} | (constructor) | notes={{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | priv mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc priv mem obj</title>
    <ns>10</ns>
    <id>2198</id>
    <revision>
      <id>61719</id>
      <parentid>61181</parentid>
      <timestamp>2013-06-08T05:33:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="275">{{dsc| {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | priv mem obj | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem ctor</title>
    <ns>10</ns>
    <id>5021</id>
    <revision>
      <id>61736</id>
      <parentid>61182</parentid>
      <timestamp>2013-06-08T05:36:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="329">{{dsc | {{dsc member | {{{1|}}} | (constructor) | notes={{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem dtor</title>
    <ns>10</ns>
    <id>2780</id>
    <revision>
      <id>61734</id>
      <parentid>61183</parentid>
      <timestamp>2013-06-08T05:36:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="328">{{dsc | {{dsc member | {{{1|}}} | (destructor) | notes={{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem fun</title>
    <ns>10</ns>
    <id>3439</id>
    <revision>
      <id>61739</id>
      <parentid>61186</parentid>
      <timestamp>2013-06-08T05:36:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="276">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem fun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem obj</title>
    <ns>10</ns>
    <id>2197</id>
    <revision>
      <id>61723</id>
      <parentid>61187</parentid>
      <timestamp>2013-06-08T05:34:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="276">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem obj | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem vdtor</title>
    <ns>10</ns>
    <id>5022</id>
    <revision>
      <id>61732</id>
      <parentid>61188</parentid>
      <timestamp>2013-06-08T05:35:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="347">{{dsc | {{dsc member | {{{1|}}} | (destructor) | notes={{cmark virtual}} {{{notes|}}} | nolink={{{nolink|}}} | nobold=true }}&lt;!--
--&gt;| {{#ifeq:{{{nolink|}}}|true|{{{1|}}}|{{{2|}}}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem vfun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc prot mem vfun</title>
    <ns>10</ns>
    <id>2777</id>
    <revision>
      <id>61729</id>
      <parentid>61189</parentid>
      <timestamp>2013-06-08T05:35:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="295">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{cmark virtual}} {{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{dsc mark mem | {{{1|}}} | prot mem vfun | nomem={{{nolink|}}} | inlinemem={{{inlinemem|}}} }} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc ptclass</title>
    <ns>10</ns>
    <id>2591</id>
    <revision>
      <id>61744</id>
      <parentid>61190</parentid>
      <timestamp>2013-06-08T05:37:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="198">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark ptclass}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc see c</title>
    <ns>10</ns>
    <id>6314</id>
    <revision>
      <id>61691</id>
      <parentid>56187</parentid>
      <timestamp>2013-06-08T05:28:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="575">{{dsc|{{#if:{{{1|}}}|&lt;div class=&quot;t-dsc-see&quot;&gt;&lt;span&gt;[[{{{1}}}|C documentation]]&lt;/span&gt; for &lt;span class=&quot;{{#ifeq:{{{nomono|}}}|true||t-dsc-see-tt}}&quot;&gt;{{#if:{{{2|}}}&lt;!--
--&gt;|&lt;span&gt;{{trim|{{{2|}}}}}&lt;/span&gt;&lt;!--
--&gt;{{#if:{{{3|}}}|, &lt;span&gt;{{trim|{{{3|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{4|}}}|, &lt;span&gt;{{trim|{{{4|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{5|}}}|, &lt;span&gt;{{trim|{{{5|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{6|}}}|, &lt;span&gt;{{trim|{{{6|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;|&lt;span&gt;{{ltt/core|{{{1}}}}}&lt;/span&gt;}}&lt;/span&gt;&lt;/div&gt;|{{error|No link specified}}}}}}&lt;noinclude&gt;
{{documentation|Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc see cpp</title>
    <ns>10</ns>
    <id>6315</id>
    <revision>
      <id>61690</id>
      <parentid>56188</parentid>
      <timestamp>2013-06-08T05:28:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="577">{{dsc|{{#if:{{{1|}}}|&lt;div class=&quot;t-dsc-see&quot;&gt;&lt;span&gt;[[{{{1}}}|C++ documentation]]&lt;/span&gt; for &lt;span class=&quot;{{#ifeq:{{{nomono|}}}|true||t-dsc-see-tt}}&quot;&gt;{{#if:{{{2|}}}&lt;!--
--&gt;|&lt;span&gt;{{trim|{{{2|}}}}}&lt;/span&gt;&lt;!--
--&gt;{{#if:{{{3|}}}|, &lt;span&gt;{{trim|{{{3|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{4|}}}|, &lt;span&gt;{{trim|{{{4|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{5|}}}|, &lt;span&gt;{{trim|{{{5|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;{{#if:{{{6|}}}|, &lt;span&gt;{{trim|{{{6|}}}}}&lt;/span&gt;}}&lt;!--
--&gt;|&lt;span&gt;{{ltt/core|{{{1}}}}}&lt;/span&gt;}}&lt;/span&gt;&lt;/div&gt;|{{error|No link specified}}}}}}&lt;noinclude&gt;
{{documentation|Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc sep</title>
    <ns>10</ns>
    <id>104</id>
    <revision>
      <id>61689</id>
      <parentid>61193</parentid>
      <timestamp>2013-06-08T05:27:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="98">|- class=&quot;t-dsc-sep&quot;
| colspan=&quot;2&quot; |
&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc small</title>
    <ns>10</ns>
    <id>3407</id>
    <revision>
      <id>61681</id>
      <parentid>48592</parentid>
      <timestamp>2013-06-08T05:25:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="82">&lt;span class=&quot;t-dsc-small&quot;&gt;{{{1}}}&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc small/doc</title>
    <ns>10</ns>
    <id>3409</id>
    <revision>
      <id>48590</id>
      <parentid>13395</parentid>
      <timestamp>2013-05-31T18:42:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:dcl small/doc]] to [[Template:dsc small/doc]]</comment>
      <text xml:space="preserve" bytes="384">This template can be used in {{tlf|dcl list *}} templates in the ''title'' parameter if the target page specifies function overload, function or class template specialization. The first parameter should include ''()'' for functions (function template specializations are very similar to simple overloads) or ''&lt;&gt;'' for classes with a specific overload/specialization parameter inside.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc struct</title>
    <ns>10</ns>
    <id>6533</id>
    <revision>
      <id>56193</id>
      <parentid>48608</parentid>
      <timestamp>2013-06-01T05:32:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="197">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark struct}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc tclass</title>
    <ns>10</ns>
    <id>2017</id>
    <revision>
      <id>61745</id>
      <parentid>61194</parentid>
      <timestamp>2013-06-08T05:37:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="197">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark tclass}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc tfun</title>
    <ns>10</ns>
    <id>107</id>
    <revision>
      <id>61741</id>
      <parentid>61195</parentid>
      <timestamp>2013-06-08T05:36:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="195">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark tfun}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc todo</title>
    <ns>10</ns>
    <id>3910</id>
    <revision>
      <id>63144</id>
      <parentid>61715</parentid>
      <timestamp>2013-07-03T08:04:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="84">{{dsc|{{todo|{{{1|}}}}}}}&lt;noinclude&gt;
{{documentation|Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dsc typedef</title>
    <ns>10</ns>
    <id>2589</id>
    <revision>
      <id>61844</id>
      <parentid>61721</parentid>
      <timestamp>2013-06-09T15:55:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>oops</comment>
      <text xml:space="preserve" bytes="198">{{dsc | {{dsc member | {{{1|}}} | {{{title|}}} | notes={{{notes|}}} | nolink={{{nolink|}}} }}&lt;!--
--&gt;| {{{2|}}} &lt;br/&gt; {{mark typedef}} }}&lt;noinclude&gt;
{{documentation | Template:dsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dummy</title>
    <ns>10</ns>
    <id>124</id>
    <revision>
      <id>247</id>
      <parentid>246</parentid>
      <timestamp>2011-06-06T22:43:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="219">{{ambox
| type  = notice
| small = {{{small|left}}}
| text  = This is dummy page
| image = none
}}
{{lang}}&lt;noinclude&gt;
{{documentation}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:dummy/doc</title>
    <ns>10</ns>
    <id>4743</id>
    <revision>
      <id>17237</id>
      <timestamp>2012-01-09T15:56:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="67">Used as a placeholder in pages that do not contain any information.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:eq fun</title>
    <ns>10</ns>
    <id>126</id>
    <revision>
      <id>36943</id>
      <parentid>36941</parentid>
      <timestamp>2012-07-03T10:42:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix the link to the doc</comment>
      <text xml:space="preserve" bytes="594">{{#if:{{{1|}}}
|{{{!}} class{{=}}&quot;eq-fun-cpp-table&quot;
{{!-}}
{{#if: {{{2|}}}
|! First version
{{!-}}
}}
{{!}}
{{source | lang={{{lang|{{get lang}}}}} | 1={{{1|}}}}}
{{#if: {{{2|}}}|
{{!-}}
! Second version
{{!-}}
{{!}}
{{source | lang={{{lang|{{get lang}}}}} | 1={{{2|}}}}}
{{#if: {{{3|}}}
|{{!-}}
! Third version
{{!-}}
{{!}}
{{source | lang={{{lang|{{get lang}}}}} | 1={{{3|}}}}}
{{#if: {{{4|}}}
|{{!-}}
! Fourth version
{{!-}}
{{!}}
{{source | lang={{{lang|{{get lang}}}}} | 1={{{4|}}}}}
}}}}}}
{{!}}}
|{{todo|reason=no eq fun}}
}}&lt;noinclude&gt;
{{documentation|Template:source/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:error</title>
    <ns>10</ns>
    <id>127</id>
    <revision>
      <id>3993</id>
      <parentid>253</parentid>
      <timestamp>2011-06-10T20:45:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:error]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="232">&lt;{{#switch:{{lc:{{{tag}}}}}
 |p=p
 |span=span
 |div=div
 |#default=strong
}} class=&quot;error&quot;&gt;{{{message|{{{1}}}}}}&lt;/{{#switch:{{lc:{{{tag}}}}}
 |p=p
 |span=span
 |div=div
 |#default=strong
}}&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:error/doc</title>
    <ns>10</ns>
    <id>5496</id>
    <revision>
      <id>20009</id>
      <timestamp>2012-03-19T18:27:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;Shows an error.&quot;</comment>
      <text xml:space="preserve" bytes="15">Shows an error.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:example</title>
    <ns>10</ns>
    <id>6246</id>
    <revision>
      <id>64753</id>
      <parentid>64252</parentid>
      <timestamp>2013-08-26T21:17:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Do not use {{livecodelink}} anymore</comment>
      <text xml:space="preserve" bytes="469">{{#if:{{{code|}}}
|&lt;div class=&quot;t-example&quot;&gt;&lt;!--
--&gt;{{#if:{{{1|}}}| &lt;p&gt;{{{1|}}}&lt;/p&gt;

}}&lt;div class=&quot;t-example-live-link&quot;&gt;&lt;div class=&quot;coliru-btn coliru-btn-run-init&quot;&gt;Run this code&lt;/div&gt;&lt;/div&gt;
{{source | 1={{{code|}}} | lang={{{lang|{{get lang}}}}}}}

{{#if:{{{output|}}} | {{#ifeq: {{{p|}}} | true | Possible output: | Output:}}

{{source | lang=text | 1={{{output}}}}}
}} 
&lt;/div&gt; | {{todo|reason=no example}}}}&lt;noinclude&gt;
{{documentation|Template:source/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:example editlink</title>
    <ns>10</ns>
    <id>8701</id>
    <revision>
      <id>36610</id>
      <parentid>36609</parentid>
      <timestamp>2012-06-25T18:31:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:example editlink]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="285">&lt;onlyinclude&gt;{{#if:{{#var:example-template-name}}|&lt;span class=&quot;editsection noprint plainlinks&quot; title=&quot;Edit this template&quot;&gt;[{{fullurl:Template:{{#var:example-template-name}}|action=edit}} &amp;#91;edit&amp;#93;]&lt;/span&gt;}}&lt;/onlyinclude&gt;&lt;noinclude&gt;{{documentation|Template:source/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:example template</title>
    <ns>10</ns>
    <id>8700</id>
    <revision>
      <id>47724</id>
      <parentid>47723</parentid>
      <timestamp>2013-05-16T20:02:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="661">{{#if:{{{1|}}}&lt;!--
--&gt;| {{#if: {{#pos:{{{1|}}}|//}}&lt;!--
  --&gt;|{{ambox
| type  = notice
| small = {{{small|left}}}
| text  = Templated example.&lt;br/&gt; The link is {{tt|{{#replace:{{{1|}}}|//|/&lt;PP&gt;/}}}}
| image = none
}}&lt;!--
  --&gt;|{{#vardefine:example-template-name|{{{1|}}}}}&lt;!--
    --&gt;{{ {{{1|}}}&lt;!--
      --&gt;|{{trim|{{{2|}}}}}&lt;!--
      --&gt;|{{trim|{{{3|}}}}}&lt;!--
      --&gt;|{{trim|{{{4|}}}}}&lt;!--
      --&gt;|{{trim|{{{5|}}}}}&lt;!--
      --&gt;|{{trim|{{{6|}}}}}&lt;!--
      --&gt;|{{trim|{{{7|}}}}}&lt;!--
    --&gt;}}{{#vardefine:example-template-name}}&lt;!--
  --&gt;}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:source/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:fmbox</title>
    <ns>10</ns>
    <id>130</id>
    <revision>
      <id>15476</id>
      <parentid>15474</parentid>
      <timestamp>2011-12-10T15:34:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="1292">&lt;table {{#if:{{{id|}}}|id=&quot;{{{id|}}}&quot;}} class=&quot;plainlinks fmbox
{{#switch:{{{type|}}}
| warning    = fmbox-warning
| editnotice = fmbox-editnotice
| system          &lt;!-- system = default --&gt;
| #default   = fmbox-system
}} {{{class|}}}&quot; style=&quot;{{{style|}}}&quot;&gt;
&lt;tr&gt;
{{#ifeq:{{{image|}}}|none
| &lt;!-- No image. --&gt;
| &lt;td class=&quot;mbox-image&quot;&gt;
  {{#if:{{{image|}}}
  | {{{image}}}
  | [[File:{{#switch:{{{type|}}}
    | warning    = Cmbox deletion.png
    | editnotice = Imbox notice.png
    | system          &lt;!-- system = default --&gt;
    | #default   = Imbox notice.png
    }}|40x40px|link=|alt=]]
  }}&lt;/td&gt;
}}
&lt;td class=&quot;mbox-text&quot; style=&quot;{{{textstyle|}}}&quot;&gt; {{{text}}} &lt;/td&gt;
{{#if:{{{imageright|}}}
| &lt;td class=&quot;mbox-imageright&quot;&gt; {{{imageright}}} &lt;/td&gt;
}}
&lt;/tr&gt;
&lt;/table&gt;&lt;!--
  Detect and report usage with faulty &quot;type&quot; parameter:
--&gt;{{#switch:{{{type|}}}
|   &lt;!-- No type fed, is also valid input --&gt;
| warning
| editnotice
| system     =    &lt;!-- Do nothing, valid &quot;type&quot; --&gt;
| #default   = &lt;div style=&quot;text-align: center;&quot;&gt;This message box is using an invalid &quot;type={{{type|}}}&quot; parameter and needs fixing.&lt;/div&gt;[[Category:Wikipedia message box parameter needs fixing|{{main other|Main:}}{{FULLPAGENAME}}]]&lt;!-- Sort on namespace --&gt;
}}&lt;noinclude&gt;
{{documentation|Template:mbox/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:get lang</title>
    <ns>10</ns>
    <id>6248</id>
    <revision>
      <id>48671</id>
      <parentid>37229</parentid>
      <timestamp>2013-05-31T18:53:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>default to cpp</comment>
      <text xml:space="preserve" bytes="128">&lt;onlyinclude&gt;{{#switch:{{#explode:{{PAGENAME}}|/|0}}
|c=c
|cpp=cpp
|cpp
}}&lt;/onlyinclude&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:get lang/doc</title>
    <ns>10</ns>
    <id>6249</id>
    <revision>
      <id>48670</id>
      <parentid>21692</parentid>
      <timestamp>2013-05-31T18:52:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>default to cpp</comment>
      <text xml:space="preserve" bytes="317">Returns the programming language to use for a page by default. The output value depends on the title of the page this template is included in. 

If the page title begins with &quot;c/&quot;, then the output value is &quot;c&quot;, if the page title begins with &quot;cpp/&quot;, then the output value is &quot;cpp&quot;. Otherwise the output value is &quot;cpp&quot;.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:get types/doc</title>
    <ns>10</ns>
    <id>8822</id>
    <revision>
      <id>37223</id>
      <parentid>37222</parentid>
      <timestamp>2012-07-03T16:40:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1059">This is ''generic'' description of all ''***/get_types'' templates.

''***/get_types'' templates are used for easier definition of C++ template parameters. Often several related C++ templates have a non-member function which has identical behavior whichever of those templates are passed as parameter. For example, most of C++ containers have comparison operators that behave identically for most of the containers. We usually want to put the article for such functions in a template to reduce maintenance burden. The problem is that often C++ templates accepted as function arguments have different template arguments, so we end up with a huge {{tt|&lt;nowiki&gt;{{#switch:&lt;/nowiki&gt;}} statement.

This template solves the issue by defining the template arguments as variables. 
* {{tt|&lt;nowiki&gt;{{#var:types}}&lt;/nowiki&gt;}} contains the long type description (use it as {{tt|template&lt; &lt;nowiki&gt;{{#var:types}}&lt;/nowiki&gt; &gt;}}).
* {{tt|&lt;nowiki&gt;{{#var:types_short}}&lt;/nowiki&gt;}} contains the short type description (use it as {{tt|Type&lt;&lt;nowiki&gt;{{#var:types_short}}&lt;/nowiki&gt;&gt;}}).</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:header</title>
    <ns>10</ns>
    <id>9658</id>
    <revision>
      <id>45018</id>
      <parentid>44982</parentid>
      <timestamp>2012-12-07T18:14:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt font</comment>
      <text xml:space="preserve" bytes="74">{{ltt|cpp/header/{{trim|{{{1|header}}}}}|&amp;lt;{{trim|{{{1|header}}}}}&amp;gt;}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:image</title>
    <ns>10</ns>
    <id>10001</id>
    <revision>
      <id>47633</id>
      <parentid>47628</parentid>
      <timestamp>2013-05-16T14:42:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>pass the image through the first argument</comment>
      <text xml:space="preserve" bytes="210">&lt;div class=&quot;t-image&quot;&gt;
{{#if:{{{1|}}}
 |[[Image:{{{1|}}}]]
 |{{error|No image specified}}
}}
{{#if:{{{notes|}}}|&lt;div style=&quot;text-align:center;&quot;&gt;{{{notes|}}}&lt;/div&gt;}}
&lt;/div&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:image/doc</title>
    <ns>10</ns>
    <id>10002</id>
    <revision>
      <id>47634</id>
      <parentid>47632</parentid>
      <timestamp>2013-05-16T14:42:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="86">{{tl|image|''image''|notes{{=}}''notes''{{mark optional}}}}

A container for an image.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include</title>
    <ns>10</ns>
    <id>10058</id>
    <revision>
      <id>56202</id>
      <parentid>50427</parentid>
      <timestamp>2013-06-01T05:32:48Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="611">{{#if:{{{1|}}}&lt;!--
--&gt;| {{#if: {{#pos:{{{1|}}}|//}}&lt;!--
  --&gt;|{{ambox
| type  = notice
| small = {{{small|left}}}
| text  = Templated content.&lt;br/&gt; The link is {{tt|{{#replace:{{{1|}}}|//|/&lt;PP&gt;/}}}}
| image = none
}}&lt;!--
  --&gt;| {{include editlink|{{{1|}}}}}&lt;!--
    --&gt;{{ {{{1|}}}&lt;!--
      --&gt;|{{trim|{{{2|}}}}}&lt;!--
      --&gt;|{{trim|{{{3|}}}}}&lt;!--
      --&gt;|{{trim|{{{4|}}}}}&lt;!--
      --&gt;|{{trim|{{{5|}}}}}&lt;!--
      --&gt;|{{trim|{{{6|}}}}}&lt;!--
      --&gt;|{{trim|{{{7|}}}}}&lt;!--
    --&gt;}}&lt;!--
  --&gt;}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:include/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include/doc</title>
    <ns>10</ns>
    <id>10059</id>
    <revision>
      <id>48787</id>
      <parentid>48786</parentid>
      <timestamp>2013-06-01T00:09:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:template/doc]] to [[Template:include/doc]]</comment>
      <text xml:space="preserve" bytes="443">{{tl|include | ''location'' | ''param1'' {{mark optional}} | ''param2'' {{mark optional}} ... }}
: Includes the template from ''location'' and adds an edit link. Use this template whenever using an some templated content that occupies full width of the page. The unnamed parameters ''param1'', ''param2'', ... are passed to the template.

===Implementation templates===
{{tl|include editlink | ''location''}}
: Adds an edit link to a template.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include editlink</title>
    <ns>10</ns>
    <id>10057</id>
    <revision>
      <id>50428</id>
      <parentid>48784</parentid>
      <timestamp>2013-06-01T03:26:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link to doc</comment>
      <text xml:space="preserve" bytes="314">&lt;div class=&quot;t-template-editlink&quot; style=&quot;{{{style|}}}&quot;&gt;
{{#if:{{{1|}}}|&lt;span class=&quot;t-template editsection noprint plainlinks&quot; title=&quot;Edit this template&quot;&gt;[{{fullurl:Template:{{{1}}}|action=edit}} &amp;#91;edit&amp;#93;]&lt;/span&gt;|{{error|no template given}}}}&lt;/div&gt;&lt;noinclude&gt;{{documentation|Template:include/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include page</title>
    <ns>10</ns>
    <id>9528</id>
    <revision>
      <id>60934</id>
      <parentid>60933</parentid>
      <timestamp>2013-06-01T12:07:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="386">{{#if:{{{1|}}}&lt;!--
--&gt;|{{include page editlink| {{{1|}}}}}&lt;!--
 --&gt;{{ {{{1|}}}&lt;!--
    --&gt;|{{trim|{{{2|}}}}}&lt;!--
    --&gt;|{{trim|{{{3|}}}}}&lt;!--
    --&gt;|{{trim|{{{4|}}}}}&lt;!--
    --&gt;|{{trim|{{{5|}}}}}&lt;!--
    --&gt;|{{trim|{{{6|}}}}}&lt;!--
    --&gt;|{{trim|{{{7|}}}}}&lt;!--
--&gt;}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:include page/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include page/doc</title>
    <ns>10</ns>
    <id>9938</id>
    <revision>
      <id>64740</id>
      <parentid>50423</parentid>
      <timestamp>2013-08-26T20:16:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="300">{{tl|include page | ''template'' | ''arg1'' {{mark optional}} | ''arg2'' {{mark optional}} | ... }}
: includes the ''template'' while passing the given arguments. A convenience link is provided that enables to enter the page for editing the template without accessing the page of the template itself.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:include page editlink</title>
    <ns>10</ns>
    <id>9529</id>
    <revision>
      <id>61441</id>
      <parentid>60935</parentid>
      <timestamp>2013-06-06T00:31:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="349">&lt;div class=&quot;t-page-template&quot; style=&quot;{{{style|}}}&quot;&gt;
{{#addbodyclass:cpp-page-template}}
{{#if:{{{1|}}}|&lt;span class=&quot;editsection noprint plainlinks&quot; title=&quot;Edit this template&quot;&gt;[{{fullurl:Template:{{{1}}}|action=edit}} &amp;#91;edit template&amp;#93;]&lt;/span&gt;|{{error|no template given}}}}&lt;/div&gt;&lt;noinclude&gt;{{documentation|Template:include page/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:included</title>
    <ns>10</ns>
    <id>5609</id>
    <revision>
      <id>48801</id>
      <parentid>46505</parentid>
      <timestamp>2013-06-01T00:17:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:templated]] to [[Template:included]]</comment>
      <text xml:space="preserve" bytes="161">{{ambox
| type  = notice
| small = {{{small|left}}}
| text  = Templated information. See page source.
| image = none
}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:included/doc</title>
    <ns>10</ns>
    <id>9929</id>
    <revision>
      <id>48803</id>
      <parentid>47061</parentid>
      <timestamp>2013-06-01T00:17:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:templated/doc]] to [[Template:included/doc]]</comment>
      <text xml:space="preserve" bytes="336">Used in switch statements that depend on a template argument as a placeholder for the default case - when the template argument is not provided at all. Since this is the case when viewing the template directly, showing a placeholder is less confusing than the alternatives of showing nothing or only some branch of the switch statement.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram</title>
    <ns>10</ns>
    <id>2278</id>
    <revision>
      <id>37651</id>
      <parentid>37650</parentid>
      <timestamp>2012-07-17T11:36:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc</comment>
      <text xml:space="preserve" bytes="350">&lt;div class=&quot;t-inheritance-diagram&quot;&gt;
{{#if:{{{image|}}}
 |{{#if:{{{map|}}}
   |{{#tag:imagemap |
      Image:{{{image|}}}{{!}}center
      {{{map|}}}
    }}
   |[[Image:{{{image|}}}]]
  }}
 |{{error|No image specified}}
}}
&lt;div style=&quot;text-align:center;&quot;&gt;
{{small|Inheritance diagram}}{{{notes|}}}
&lt;/div&gt;
&lt;/div&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/doc</title>
    <ns>10</ns>
    <id>8937</id>
    <revision>
      <id>37696</id>
      <parentid>37653</parentid>
      <timestamp>2012-07-18T16:09:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+subpages</comment>
      <text xml:space="preserve" bytes="411">Creates a frame for inheritance diagram.

{{tl|inheritance_diagram | image{{=}}''image location'' | map{{=}}''image map'' {{mark optional}} | notes{{=}}''additional notes'' {{mark optional}}}}

The template is usually used by wrapping it into another template. 
[http://en.cppreference.com/mwiki/index.php?title=Special%3APrefixIndex&amp;prefix=inheritance+diagram%2F&amp;namespace=10 This] is a list of such templates.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad alloc</title>
    <ns>10</ns>
    <id>8947</id>
    <revision>
      <id>37854</id>
      <parentid>37697</parentid>
      <timestamp>2012-07-20T20:13:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="124">{{inheritance diagram|image=std-bad_alloc-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad array new length</title>
    <ns>10</ns>
    <id>8948</id>
    <revision>
      <id>37838</id>
      <parentid>37698</parentid>
      <timestamp>2012-07-20T20:00:50Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="182">{{inheritance diagram|image=std-bad_array_new_length-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/memory/new/bad_alloc]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad cast</title>
    <ns>10</ns>
    <id>8949</id>
    <revision>
      <id>37833</id>
      <parentid>37699</parentid>
      <timestamp>2012-07-20T19:54:57Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="123">{{inheritance diagram|image=std-bad_cast-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad exception</title>
    <ns>10</ns>
    <id>8950</id>
    <revision>
      <id>37843</id>
      <parentid>37700</parentid>
      <timestamp>2012-07-20T20:04:51Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="128">{{inheritance diagram|image=std-bad_exception-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad function call</title>
    <ns>10</ns>
    <id>9137</id>
    <revision>
      <id>38345</id>
      <timestamp>2012-08-02T18:12:19Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="132">{{inheritance diagram|image=std-bad_function_call-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad optional access</title>
    <ns>10</ns>
    <id>10105</id>
    <revision>
      <id>48163</id>
      <timestamp>2013-05-18T20:30:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="178">{{inheritance diagram|image=std-bad_optional_access-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad typeid</title>
    <ns>10</ns>
    <id>8951</id>
    <revision>
      <id>37855</id>
      <parentid>37701</parentid>
      <timestamp>2012-07-20T20:14:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="125">{{inheritance diagram|image=std-bad_typeid-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-bad weak ptr</title>
    <ns>10</ns>
    <id>8952</id>
    <revision>
      <id>37842</id>
      <parentid>37702</parentid>
      <timestamp>2012-07-20T20:04:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="127">{{inheritance diagram|image=std-bad_weak_ptr-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic fstream</title>
    <ns>10</ns>
    <id>8953</id>
    <revision>
      <id>37858</id>
      <parentid>37703</parentid>
      <timestamp>2012-07-20T20:17:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="297">{{inheritance diagram|image=std-basic_fstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 33 107 66 [[cpp/io/ios_base]]
rect 135 31 252 69 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_istream]]
rect 278 58 395 96 [[cpp/io/basic_ostream]]
rect 422 31 539 69 [[cpp/io/basic_iostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic ifstream</title>
    <ns>10</ns>
    <id>8954</id>
    <revision>
      <id>37845</id>
      <parentid>37704</parentid>
      <timestamp>2012-07-20T20:06:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="207">{{inheritance diagram|image=std-basic_ifstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_istream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic ios</title>
    <ns>10</ns>
    <id>8955</id>
    <revision>
      <id>37837</id>
      <parentid>37705</parentid>
      <timestamp>2012-07-20T20:00:02Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="120">{{inheritance diagram|image=std-basic_ios-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic iostream</title>
    <ns>10</ns>
    <id>8956</id>
    <revision>
      <id>37832</id>
      <parentid>37706</parentid>
      <timestamp>2012-07-20T19:54:46Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="253">{{inheritance diagram|image=std-basic_iostream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 33 107 66 [[cpp/io/ios_base]]
rect 135 31 252 69 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_istream]]
rect 278 58 395 96 [[cpp/io/basic_ostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic istream</title>
    <ns>10</ns>
    <id>8957</id>
    <revision>
      <id>37853</id>
      <parentid>37707</parentid>
      <timestamp>2012-07-20T20:13:03Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="163">{{inheritance diagram|image=std-basic_istream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic istringstream</title>
    <ns>10</ns>
    <id>8958</id>
    <revision>
      <id>37844</id>
      <parentid>37708</parentid>
      <timestamp>2012-07-20T20:05:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="212">{{inheritance diagram|image=std-basic_istringstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_istream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic ofstream</title>
    <ns>10</ns>
    <id>8959</id>
    <revision>
      <id>37835</id>
      <parentid>37709</parentid>
      <timestamp>2012-07-20T19:58:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="207">{{inheritance diagram|image=std-basic_ofstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_ostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic ostream</title>
    <ns>10</ns>
    <id>8960</id>
    <revision>
      <id>37849</id>
      <parentid>37710</parentid>
      <timestamp>2012-07-20T20:09:49Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="163">{{inheritance diagram|image=std-basic_ostream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic ostringstream</title>
    <ns>10</ns>
    <id>8961</id>
    <revision>
      <id>37834</id>
      <parentid>37711</parentid>
      <timestamp>2012-07-20T19:57:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="212">{{inheritance diagram|image=std-basic_ostringstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/io/ios_base]]
rect 135 4 252 42 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_ostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-basic stringstream</title>
    <ns>10</ns>
    <id>8962</id>
    <revision>
      <id>37856</id>
      <parentid>37712</parentid>
      <timestamp>2012-07-20T20:15:28Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="302">{{inheritance diagram|image=std-basic_stringstream-inheritance.svg|notes={{{notes|}}}|map=
rect 5 33 107 66 [[cpp/io/ios_base]]
rect 135 31 252 69 [[cpp/io/basic_ios]]
rect 278 4 395 42 [[cpp/io/basic_istream]]
rect 278 58 395 96 [[cpp/io/basic_ostream]]
rect 422 31 539 69 [[cpp/io/basic_iostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-codecvt</title>
    <ns>10</ns>
    <id>9067</id>
    <revision>
      <id>38068</id>
      <parentid>38052</parentid>
      <timestamp>2012-07-23T11:45:38Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="171">{{inheritance diagram|image=std-codecvt-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/codecvt_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-collate</title>
    <ns>10</ns>
    <id>9071</id>
    <revision>
      <id>38063</id>
      <parentid>38056</parentid>
      <timestamp>2012-07-23T11:44:44Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="126">{{inheritance diagram|image=std-collate-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-ctype</title>
    <ns>10</ns>
    <id>9066</id>
    <revision>
      <id>38064</id>
      <parentid>38051</parentid>
      <timestamp>2012-07-23T11:44:54Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="167">{{inheritance diagram|image=std-ctype-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/ctype_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-ctype char</title>
    <ns>10</ns>
    <id>9068</id>
    <revision>
      <id>38065</id>
      <parentid>38053</parentid>
      <timestamp>2012-07-23T11:44:58Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="172">{{inheritance diagram|image=std-ctype_char-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/ctype_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-domain error</title>
    <ns>10</ns>
    <id>8930</id>
    <revision>
      <id>37850</id>
      <parentid>37636</parentid>
      <timestamp>2012-07-20T20:10:37Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="171">{{inheritance diagram|image=std-domain_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-future error</title>
    <ns>10</ns>
    <id>8967</id>
    <revision>
      <id>37839</id>
      <parentid>37720</parentid>
      <timestamp>2012-07-20T20:01:40Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="171">{{inheritance diagram|image=std-future_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-invalid argument</title>
    <ns>10</ns>
    <id>8929</id>
    <revision>
      <id>37847</id>
      <parentid>37634</parentid>
      <timestamp>2012-07-20T20:08:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="175">{{inheritance diagram|image=std-invalid_argument-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-io-complete</title>
    <ns>10</ns>
    <id>8963</id>
    <revision>
      <id>37846</id>
      <parentid>37713</parentid>
      <timestamp>2012-07-20T20:07:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="596">{{inheritance diagram|image=std-io-complete-inheritance.svg|notes={{{notes|}}}|map=
rect 225 4 328 36 [[cpp/io/ios_base]]
rect 218 62 335 100 [[cpp/io/basic_ios]]
rect 305 126 422 164 [[cpp/io/basic_istream]]
rect 419 319 536 357 [[cpp/io/basic_ifstream]]
rect 410 255 545 292 [[cpp/io/basic_istringstream]]
rect 130 126 247 164 [[cpp/io/basic_ostream]]
rect 14 319 132 357 [[cpp/io/basic_ofstream]]
rect 4 255 143 292 [[cpp/io/basic_ostringstream]]
rect 200 319 318 357 [[cpp/io/basic_fstream]]
rect 193 255 325 292 [[cpp/io/basic_stringstream]]
rect 221 190 339 228 [[cpp/io/basic_iostream]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-ios base-failure</title>
    <ns>10</ns>
    <id>8965</id>
    <revision>
      <id>37851</id>
      <parentid>37740</parentid>
      <timestamp>2012-07-20T20:11:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="222">{{inheritance diagram|image=std-ios_base-failure-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
rect 266 4 369 36 [[cpp/error/system_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-ios base-failure-2003</title>
    <ns>10</ns>
    <id>8964</id>
    <revision>
      <id>37831</id>
      <parentid>37739</parentid>
      <timestamp>2012-07-20T19:54:34Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="136">{{inheritance diagram|image=std-ios_base-failure-2003-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-length error</title>
    <ns>10</ns>
    <id>8936</id>
    <revision>
      <id>37852</id>
      <parentid>37648</parentid>
      <timestamp>2012-07-20T20:12:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="171">{{inheritance diagram|image=std-length_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-logic error</title>
    <ns>10</ns>
    <id>8928</id>
    <revision>
      <id>37848</id>
      <parentid>37632</parentid>
      <timestamp>2012-07-20T20:09:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="126">{{inheritance diagram|image=std-logic_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-messages</title>
    <ns>10</ns>
    <id>9063</id>
    <revision>
      <id>38069</id>
      <parentid>38048</parentid>
      <timestamp>2012-07-23T11:45:45Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="173">{{inheritance diagram|image=std-messages-inheritance.svg|notes={{{notes|}}}|map=
rect 4 4 114 36 [[cpp/locale/messages_base]]
rect 7 52 110 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-money get</title>
    <ns>10</ns>
    <id>9062</id>
    <revision>
      <id>38061</id>
      <parentid>38047</parentid>
      <timestamp>2012-07-23T11:44:26Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="128">{{inheritance diagram|image=std-money_get-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-money put</title>
    <ns>10</ns>
    <id>9069</id>
    <revision>
      <id>38062</id>
      <parentid>38054</parentid>
      <timestamp>2012-07-23T11:44:30Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="128">{{inheritance diagram|image=std-money_put-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-moneypunct</title>
    <ns>10</ns>
    <id>9070</id>
    <revision>
      <id>38101</id>
      <parentid>38058</parentid>
      <timestamp>2012-07-23T15:58:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="172">{{inheritance diagram|image=std-moneypunct-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/money_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-num get</title>
    <ns>10</ns>
    <id>9065</id>
    <revision>
      <id>38067</id>
      <parentid>38050</parentid>
      <timestamp>2012-07-23T11:45:10Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="126">{{inheritance diagram|image=std-num_get-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-num put</title>
    <ns>10</ns>
    <id>9061</id>
    <revision>
      <id>38066</id>
      <parentid>38046</parentid>
      <timestamp>2012-07-23T11:45:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="126">{{inheritance diagram|image=std-num_put-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-numpunct</title>
    <ns>10</ns>
    <id>9064</id>
    <revision>
      <id>38070</id>
      <parentid>38049</parentid>
      <timestamp>2012-07-23T11:46:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="127">{{inheritance diagram|image=std-numpunct-inheritance.svg|notes={{{notes|}}}|map=
rect 5 6 107 39 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-out of range</title>
    <ns>10</ns>
    <id>8935</id>
    <revision>
      <id>37840</id>
      <parentid>37646</parentid>
      <timestamp>2012-07-20T20:02:27Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="171">{{inheritance diagram|image=std-out_of_range-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/logic_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-overflow error</title>
    <ns>10</ns>
    <id>8932</id>
    <revision>
      <id>37857</id>
      <parentid>37719</parentid>
      <timestamp>2012-07-20T20:16:16Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="175">{{inheritance diagram|image=std-overflow_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-range error</title>
    <ns>10</ns>
    <id>8933</id>
    <revision>
      <id>37841</id>
      <parentid>37718</parentid>
      <timestamp>2012-07-20T20:03:15Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="172">{{inheritance diagram|image=std-range_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-regex error</title>
    <ns>10</ns>
    <id>9570</id>
    <revision>
      <id>41491</id>
      <timestamp>2012-10-31T15:16:04Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="172">{{inheritance diagram|image=std-regex_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-runtime error</title>
    <ns>10</ns>
    <id>8934</id>
    <revision>
      <id>37859</id>
      <parentid>37644</parentid>
      <timestamp>2012-07-20T20:17:53Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="128">{{inheritance diagram|image=std-runtime_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-system error</title>
    <ns>10</ns>
    <id>8966</id>
    <revision>
      <id>37836</id>
      <parentid>37717</parentid>
      <timestamp>2012-07-20T19:59:14Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="173">{{inheritance diagram|image=std-system_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-time get</title>
    <ns>10</ns>
    <id>9059</id>
    <revision>
      <id>38059</id>
      <parentid>38044</parentid>
      <timestamp>2012-07-23T11:44:05Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="169">{{inheritance diagram|image=std-time_get-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/time_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-time put</title>
    <ns>10</ns>
    <id>9060</id>
    <revision>
      <id>38060</id>
      <parentid>38045</parentid>
      <timestamp>2012-07-23T11:44:09Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="169">{{inheritance diagram|image=std-time_put-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/locale/time_base]]
rect 5 52 107 85 [[cpp/locale/locale/facet]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inheritance diagram/std-underflow error</title>
    <ns>10</ns>
    <id>8931</id>
    <revision>
      <id>37830</id>
      <parentid>37716</parentid>
      <timestamp>2012-07-20T19:54:23Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>update</comment>
      <text xml:space="preserve" bytes="176">{{inheritance diagram|image=std-underflow_error-inheritance.svg|notes={{{notes|}}}|map=
rect 5 4 107 36 [[cpp/error/exception]]
rect 135 4 238 36 [[cpp/error/runtime_error]]
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:inherited</title>
    <ns>10</ns>
    <id>132</id>
    <revision>
      <id>17978</id>
      <parentid>13146</parentid>
      <timestamp>2012-01-19T23:34:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorter css class name (we ship at least 1.5MB just for that word)</comment>
      <text xml:space="preserve" bytes="74">&lt;div class=&quot;t-inherited&quot;&gt;
&lt;h2&gt;Inherited from {{{1|}}}&lt;/h2&gt;
{{{2|}}}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:l2tt</title>
    <ns>10</ns>
    <id>134</id>
    <revision>
      <id>3985</id>
      <parentid>267</parentid>
      <timestamp>2011-06-10T20:45:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:l2tt]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="175">{{#if: {{{1|}}} |[[{{trim|{{{1|}}}}}|&lt;tt&gt;{{l2tt/core|{{{1}}}|{{{2|}}}|{{{3|}}}}}&lt;/tt&gt;]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation | Template:rl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:l2tt/core</title>
    <ns>10</ns>
    <id>135</id>
    <revision>
      <id>18226</id>
      <parentid>269</parentid>
      <timestamp>2012-01-25T22:41:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:l2tt/core]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="102">{{#if:{{{3|}}}|{{{3}}}|{{#explode:{{{1}}}|/|-2}}}}::{{#if:{{{2|}}}|{{{2}}}|{{#explode:{{{1}}}|/|-1}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lang</title>
    <ns>10</ns>
    <id>136</id>
    <revision>
      <id>10242</id>
      <parentid>3987</parentid>
      <timestamp>2011-09-02T21:04:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add arabic wiki</comment>
      <text xml:space="preserve" bytes="402">[[ar:{{FULLPAGENAMEE}}]]
[[pt-br:{{FULLPAGENAMEE}}]]
[[zh:{{FULLPAGENAMEE}}]]
[[cs:{{FULLPAGENAMEE}}]]
[[de:{{FULLPAGENAMEE}}]]
[[es:{{FULLPAGENAMEE}}]]
[[fr:{{FULLPAGENAMEE}}]]
[[it:{{FULLPAGENAMEE}}]]
[[ja:{{FULLPAGENAMEE}}]]
[[lv:{{FULLPAGENAMEE}}]]
[[nl:{{FULLPAGENAMEE}}]]
[[pl:{{FULLPAGENAMEE}}]]
[[ro:{{FULLPAGENAMEE}}]]
[[ru:{{FULLPAGENAMEE}}]]
[[tr:{{FULLPAGENAMEE}}]]
[[tw:{{FULLPAGENAMEE}}]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lc</title>
    <ns>10</ns>
    <id>10281</id>
    <revision>
      <id>64752</id>
      <parentid>64750</parentid>
      <timestamp>2013-08-26T21:14:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:lc]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="112">&lt;span class=&quot;t-lc&quot;&gt;{{#autolink:{{get_lang}}|{{{1|}}}|{{{2|}}}}}&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lc/doc</title>
    <ns>10</ns>
    <id>10282</id>
    <revision>
      <id>64751</id>
      <parentid>48773</parentid>
      <timestamp>2013-08-26T21:14:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="443">{{tl|lc|''identifier''|''title_override''}}

Automatically creates a link to ''identifier''. Which identifiers are linked where are defined in [[MediaWiki:autolinker-definition-c]] and [[MediaWiki:autolinker-definition-cpp]]. Which of these lists are used depends on the output of {{tl|get_lang}} for the current page. 

The title of the link is ''identifier'', unless ''title_override'' is not empty, in which case ''title_override'' is used.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:left</title>
    <ns>10</ns>
    <id>137</id>
    <revision>
      <id>10399</id>
      <parentid>10398</parentid>
      <timestamp>2011-09-10T20:10:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="183">&lt;includeonly&gt;&lt;div style=&quot;text-align:left; width:auto; margin-left:auto; margin-right:auto;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:center/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:li</title>
    <ns>10</ns>
    <id>5736</id>
    <revision>
      <id>22529</id>
      <parentid>22353</parentid>
      <timestamp>2012-04-19T21:15:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>variables aren't necessary</comment>
      <text xml:space="preserve" bytes="189">&lt;includeonly&gt;&lt;onlyinclude&gt;&lt;/div&gt;&lt;div class=&quot;t-li1&quot;&gt;{{#if:{{{1|}}}|&lt;span class=&quot;t-li&quot;&gt;{{{1|}}})&lt;/span&gt;}}&lt;/onlyinclude&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation|Template:li/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:li/doc</title>
    <ns>10</ns>
    <id>5737</id>
    <revision>
      <id>39365</id>
      <parentid>39291</parentid>
      <timestamp>2012-08-30T21:07:35Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <comment>Undo revision 39291 by [[Special:Contributions/P12bot|P12bot]] ([[User talk:P12bot|talk]])</comment>
      <text xml:space="preserve" bytes="1041">Labeled list templates.

{{tl|li begin}} - starts a labeled list.

{{tl|li end}} - ends a labeled list.

{{tl|li|''label''}}

{{tl|lii|''label''}}

{{tl|liii|''label''}}

Adds an item with a custom label to an ordered list. The {{tt|label}} parameter specifies the label. If it is not specified, no label is added. {{tl|li}}, {{tl|lii}} and {{tl|liii}} differs by the amount of indentation.

===Shorter list syntax===
Shorter list syntax with almost equivalent behavior is implemented:

&lt;pre&gt;&lt;nowiki&gt;
@1@ text
@2@ text
@3-4@ text
:@5@ text
:@6@ text
&lt;/nowiki&gt;&lt;/pre&gt;

is equivalent to:

&lt;pre&gt;&lt;nowiki&gt;
{{li begin}}
{{li|1}} text
{{li|2}} text
{{li|3-4}} text
{{lii|5}} text
{{lii|6}} text
{{li end}}
&lt;/nowiki&gt;&lt;/pre&gt;

===Example===
{{source|lang=text|
&lt;nowiki&gt;
{{li begin}}
{{li|1}} item

{{li|2}} item

{{li|3-4}} item

{{lii|1}} item
{{lii|2-5}} item
{{lii|6-7}} item

{{li|5}} item
{{li end}}
&lt;/nowiki&gt;
}}

{{li begin}}
{{li|1}} item

{{li|2}} item

{{li|3-4}} item

{{lii|1}} item
{{lii|2-5}} item
{{lii|6-7}} item

{{li|5}} item
{{li end}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:li begin</title>
    <ns>10</ns>
    <id>6331</id>
    <revision>
      <id>22528</id>
      <parentid>22527</parentid>
      <timestamp>2012-04-19T21:14:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="139">&lt;includeonly&gt;&lt;onlyinclude&gt;&lt;div style=&quot;display:none;&quot;&gt;&lt;/onlyinclude&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation|Template:li/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:li end</title>
    <ns>10</ns>
    <id>6332</id>
    <revision>
      <id>22524</id>
      <parentid>22342</parentid>
      <timestamp>2012-04-19T21:09:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:liend]] to [[Template:li end]]</comment>
      <text xml:space="preserve" bytes="91">&lt;onlyinclude&gt;&lt;/div&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation|Template:li/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lib</title>
    <ns>10</ns>
    <id>9258</id>
    <revision>
      <id>39408</id>
      <parentid>39007</parentid>
      <timestamp>2012-09-05T08:56:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>trim whitespace</comment>
      <text xml:space="preserve" bytes="329">[{{trim|{{{2|}}}}} {{trim|{{{1|}}}}}]&lt;span style=&quot;color: #BBB; font-size: 0.7em;&quot;&gt;{{#if:{{{src|}}}|&lt;nowiki&gt;[&lt;/nowiki&gt;[{{trim|{{{src|}}}}} src]&lt;nowiki&gt;]&lt;/nowiki&gt;}}{{#if:{{{doc|}}}|&lt;nowiki&gt;[&lt;/nowiki&gt;[{{trim|{{{doc|}}}}} doc]&lt;nowiki&gt;]&lt;/nowiki&gt;}}&lt;/span&gt;{{#if:{{{3|}}}|&amp;nbsp;-&amp;nbsp;{{{3|}}}}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lib/doc</title>
    <ns>10</ns>
    <id>9259</id>
    <revision>
      <id>39008</id>
      <parentid>39002</parentid>
      <timestamp>2012-08-21T20:30:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="200">Creates an entry for use in [[cpp/links/libs]].

{{tl|lib|''title''|''url''|''notes''{{mark optional}}|doc{{=}}''url to API docs''{{mark optional}}|src{{=}}''url to source tarball''{{mark optional}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lii</title>
    <ns>10</ns>
    <id>6328</id>
    <revision>
      <id>22530</id>
      <parentid>22354</parentid>
      <timestamp>2012-04-19T21:15:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>variables aren't necessary</comment>
      <text xml:space="preserve" bytes="189">&lt;includeonly&gt;&lt;onlyinclude&gt;&lt;/div&gt;&lt;div class=&quot;t-li2&quot;&gt;{{#if:{{{1|}}}|&lt;span class=&quot;t-li&quot;&gt;{{{1|}}})&lt;/span&gt;}}&lt;/onlyinclude&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation|Template:li/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:liii</title>
    <ns>10</ns>
    <id>6329</id>
    <revision>
      <id>22531</id>
      <parentid>22355</parentid>
      <timestamp>2012-04-19T21:15:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>variables aren't necessary</comment>
      <text xml:space="preserve" bytes="189">&lt;includeonly&gt;&lt;onlyinclude&gt;&lt;/div&gt;&lt;div class=&quot;t-li3&quot;&gt;{{#if:{{{1|}}}|&lt;span class=&quot;t-li&quot;&gt;{{{1|}}})&lt;/span&gt;}}&lt;/onlyinclude&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation|Template:li/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lines</title>
    <ns>10</ns>
    <id>12959</id>
    <revision>
      <id>65198</id>
      <timestamp>2013-09-04T23:12:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>creates &quot;proper&quot; html structure for lines separated by &lt;br&gt;</comment>
      <text xml:space="preserve" bytes="218">&lt;onlyinclude&gt;&lt;span class=&quot;t-lines&quot;&gt;&lt;span&gt;{{#replace:{{#replace:{{#replace:{{{1|}}}|&lt;br&gt;|&lt;/span&gt;&lt;span&gt;}}|&lt;br/&gt;|&lt;/span&gt;&lt;span&gt;}}|&lt;br /&gt;|&lt;/span&gt;&lt;span&gt;}}&lt;/span&gt;&lt;/span&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1>fzbvn59vjvsovf5gftimuwstua13l0y</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:lines/doc</title>
    <ns>10</ns>
    <id>12960</id>
    <revision>
      <id>65199</id>
      <timestamp>2013-09-04T23:13:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="133">{{tl|lines| ''text''}}

Extracts lines from {{tt|&lt;nowiki&gt;&lt;br&gt;&lt;/nowiki&gt;}}-separated text and puts each of them into separate HTML tag.</text>
      <sha1>h54pmilarva0afookfeoj4y8oel8h15</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:list/doc</title>
    <ns>10</ns>
    <id>5326</id>
    <revision>
      <id>48546</id>
      <parentid>48540</parentid>
      <timestamp>2013-05-31T18:12:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="716">&lt;div style=&quot;margin: 1em 1em 2em 1em; padding: 0.2em 1em 1em; border: 1px solid #AAAAAA;&quot;&gt;
&lt;h4&gt;List template families&lt;/h4&gt;

* [[Template:dsc |dsc ****]] : For creation of member variable/function lists.
* [[Template:dcl |dcl ****]] : For creation of detailed declaration lists (those including actual declaration code)
* [[Template:sdsc | sdsc ****]] : For creation of lists representing various syntaxes of a language feature. Used in subpages of [[cpp/language]] 
* [[Template:par | par ****]] : For creation of lists explaining function parameters.
* [[Template:spar | spar ****]] : For creation of lists explaining syntax parameters.
* [[Template:nv | nv ****]] : For creation of feature lists in navbars.

&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:list guard</title>
    <ns>10</ns>
    <id>5322</id>
    <revision>
      <id>19392</id>
      <parentid>19380</parentid>
      <timestamp>2012-03-11T11:22:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:table guard]] to [[Template:list guard]]: better name</comment>
      <text xml:space="preserve" bytes="72">&lt;onlyinclude&gt;|-
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:list guard/doc</title>
    <ns>10</ns>
    <id>5323</id>
    <revision>
      <id>19393</id>
      <parentid>19381</parentid>
      <timestamp>2012-03-11T11:22:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:table guard/doc]] to [[Template:list guard/doc]]: better name</comment>
      <text xml:space="preserve" bytes="152">Forces an end of table row. 

This template is used in table building templates to prevent spaces after a template to be included into the cell content.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:livecodelink</title>
    <ns>10</ns>
    <id>9916</id>
    <revision>
      <id>64253</id>
      <parentid>46821</parentid>
      <timestamp>2013-08-15T16:04:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:livecodelink]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="116">&lt;onlyinclude&gt;{{#tag:LiveCodeLink|{{{1}}}|compiler={{{compiler|}}}|text={{{text|}}}}}&lt;/onlyinclude&gt;
{{documentation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ltf</title>
    <ns>10</ns>
    <id>138</id>
    <revision>
      <id>10520</id>
      <parentid>4216</parentid>
      <timestamp>2011-09-15T13:43:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix html tag mismatch</comment>
      <text xml:space="preserve" bytes="178">{{#if: {{{1|}}} |[[{{trim|{{{1|}}}}}|&lt;tt&gt;{{ltt/core|{{{1}}}|{{{2|}}}}}({{{args|}}})&lt;/tt&gt;]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation | Template:rl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ltt</title>
    <ns>10</ns>
    <id>139</id>
    <revision>
      <id>8686</id>
      <parentid>3977</parentid>
      <timestamp>2011-08-15T20:38:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix incorrect &lt;/tt&gt; placement</comment>
      <text xml:space="preserve" bytes="165">{{#if: {{{1|}}} |[[{{trim|{{{1|}}}}}|&lt;tt&gt;{{ltt/core|{{{1}}}|{{{2|}}}}}&lt;/tt&gt;]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation | Template:rl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ltt/core</title>
    <ns>10</ns>
    <id>140</id>
    <revision>
      <id>4214</id>
      <parentid>279</parentid>
      <timestamp>2011-06-13T00:20:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:ltt/core]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="50">{{#if:{{{2|}}}|{{{2}}}|{{#explode:{{{1}}}|/|-1}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark</title>
    <ns>10</ns>
    <id>141</id>
    <revision>
      <id>65203</id>
      <parentid>17982</parentid>
      <timestamp>2013-09-04T23:29:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add class= parameter</comment>
      <text xml:space="preserve" bytes="101">&lt;span class=&quot;t-mark {{{class|}}}&quot;&gt;({{trim|{{{1}}}}})&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1>mcxrwbmj3rkmqhq44sbnbo4ctbvum1n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark/doc</title>
    <ns>10</ns>
    <id>142</id>
    <revision>
      <id>71906</id>
      <parentid>68154</parentid>
      <timestamp>2014-07-01T15:30:50Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+parallelism ts</comment>
      <text xml:space="preserve" bytes="2653">Creates an annotation. Several annotations are already defined:

; Miscellaneous

{{tl|mark deprecated}} results in {{mark deprecated}}

{{tl|mark optional}} results in {{mark optional}}

{{tl|mark implicit}} results in {{mark implicit}}

{{tl|mark concept}} results in {{mark concept}}

{{tl|mark typedef}} results in {{mark typedef}}

{{tl|mark enum}} results in {{mark enum}}

{{tl|mark keyword}} results in {{mark keyword}}

{{tl|mark language}} results in {{mark language}}

; Standards 

{{tl|mark c++11}} results in {{mark c++11}}

{{tl|mark since c++11}} results in {{mark since c++11}}

{{tl|mark until c++11}} results in {{mark until c++11}}

{{tl|mark c++14}} results in {{mark c++14}}

{{tl|mark since c++14}} results in {{mark since c++14}}

{{tl|mark until c++14}} results in {{mark until c++14}}

{{tl|mark c99}} results in {{mark c99}}

{{tl|mark since c99}} results in {{mark since c99}}

{{tl|mark c11}} results in {{mark c11}}

{{tl|mark until c11}} results in {{mark until c11}}

{{tl|mark since c11}} results in {{mark since c11}}

{{tl|mark since none}} results in {{mark since none}}

{{tl|mark until none}} results in {{mark until none}}

; Technical specifications

{{tl|mark since libfund ts}} results in {{mark since libfund ts}}

{{tl|mark since fs ts}} results in {{mark since fs ts}}

{{tl|mark since parallelism ts}} results in {{mark since parallelism ts}}

; Functions

{{tl|mark fun}} results in {{mark fun}}

{{tl|mark tfun}} results in {{mark tfun}}
&lt;!--
{{tl|mark ptfun}} results in {{mark ptfun}}
--&gt;

{{tl|mark mem fun}} results in {{mark mem fun}}

{{tl|mark mem sfun}} results in {{mark mem sfun}}

{{tl|mark mem vfun}} results in {{mark mem vfun}}

{{tl|mark priv mem fun}} results in {{mark priv mem fun}}

{{tl|mark prot mem fun}} results in {{mark prot mem fun}}

{{tl|mark prot mem vfun}} results in {{mark prot mem vfun}}

{{tl|mark macro fun}} results in {{mark macro fun}}

; Classes

{{tl|mark class}} results in {{mark class}}

{{tl|mark tclass}} results in {{mark tclass}}

{{tl|mark ptclass}} results in {{mark ptclass}}

{{tl|mark mem class}} results in {{mark mem class}}

{{tl|mark priv mem class}} results in {{mark priv mem class}}

{{tl|mark prot mem class}} results in {{mark prot mem class}}

; Constants

{{tl|mark macro const}} results in {{mark macro const}}

{{tl|mark const}} results in {{mark const}}

{{tl|mark mem const}} results in {{mark mem const}}

{{tl|mark mem sconst}} results in {{mark mem sconst}}

; Objects

{{tl|mark mem obj}} results in {{mark mem obj}}

{{tl|mark priv mem obj}} results in {{mark priv mem obj}}

{{tl|mark prot mem obj}} results in {{mark prot mem obj}}</text>
      <sha1>e057vqq4t6w0m3xk9eo2cg5xzl72ljm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark c++11</title>
    <ns>10</ns>
    <id>2413</id>
    <revision>
      <id>65217</id>
      <parentid>5718</parentid>
      <timestamp>2013-09-04T23:29:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="100">{{mark rev|class=t-since-cxx11|C++11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>lulbbxaumlfx83e6kyvhnuxmrarumof</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark c++14</title>
    <ns>10</ns>
    <id>9976</id>
    <revision>
      <id>65229</id>
      <parentid>65216</parentid>
      <timestamp>2013-09-04T23:32:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark c++14]]&quot;: High traffic page ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <text xml:space="preserve" bytes="100">{{mark rev|class=t-since-cxx14|C++14}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>tgh7ijxr4gkhma1hfoj9i87qz12uxq5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark c11</title>
    <ns>10</ns>
    <id>6531</id>
    <revision>
      <id>65224</id>
      <parentid>25733</parentid>
      <timestamp>2013-09-04T23:29:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="96">{{mark rev|class=t-since-c11|C11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>iwc5me5gauoqak2cxytnz6xmmx613pt</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark c99</title>
    <ns>10</ns>
    <id>5778</id>
    <revision>
      <id>65226</id>
      <parentid>22163</parentid>
      <timestamp>2013-09-04T23:29:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="96">{{mark rev|class=t-since-c99|C99}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>nvwejr2onbj1tvenwqw1m8nih46upy6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark class</title>
    <ns>10</ns>
    <id>146</id>
    <revision>
      <id>4010</id>
      <parentid>291</parentid>
      <timestamp>2011-06-10T20:51:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark class]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="76">{{mark|class}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark concept</title>
    <ns>10</ns>
    <id>2425</id>
    <revision>
      <id>15464</id>
      <parentid>8475</parentid>
      <timestamp>2011-12-10T15:06:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>import the documentation properly</comment>
      <text xml:space="preserve" bytes="75">{{mark|concept}}&lt;noinclude&gt;{{documentation| Template:mark/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark const</title>
    <ns>10</ns>
    <id>2650</id>
    <revision>
      <id>9966</id>
      <parentid>9965</parentid>
      <timestamp>2011-08-26T19:22:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark const]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="121">{{mark|constant {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark deprecated</title>
    <ns>10</ns>
    <id>147</id>
    <revision>
      <id>3946</id>
      <parentid>293</parentid>
      <timestamp>2011-06-10T20:40:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark deprecated]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="81">{{mark|deprecated}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark enum</title>
    <ns>10</ns>
    <id>5467</id>
    <revision>
      <id>19944</id>
      <parentid>19942</parentid>
      <timestamp>2012-03-19T13:17:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark enum]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="75">{{mark|enum}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark fun</title>
    <ns>10</ns>
    <id>148</id>
    <revision>
      <id>4003</id>
      <parentid>295</parentid>
      <timestamp>2011-06-10T20:47:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark fun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="79">{{mark|function}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark implicit</title>
    <ns>10</ns>
    <id>149</id>
    <revision>
      <id>12477</id>
      <parentid>4011</parentid>
      <timestamp>2011-10-27T09:16:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix link</comment>
      <text xml:space="preserve" bytes="86">{{mark|implicitly declared}}&lt;noinclude&gt;{{documentation|Template:mark/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark keyword</title>
    <ns>10</ns>
    <id>2844</id>
    <revision>
      <id>10756</id>
      <parentid>10755</parentid>
      <timestamp>2011-09-21T13:22:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark keyword]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="78">{{mark|keyword}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark language</title>
    <ns>10</ns>
    <id>6547</id>
    <revision>
      <id>25829</id>
      <parentid>25828</parentid>
      <timestamp>2012-04-27T13:54:13Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <minor/>
      <comment>Changed protection level for &quot;[[Template:mark language]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="79">{{mark|language}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark macro const</title>
    <ns>10</ns>
    <id>150</id>
    <revision>
      <id>3996</id>
      <parentid>299</parentid>
      <timestamp>2011-06-10T20:45:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark macro const]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="85">{{mark|macro constant}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark macro fun</title>
    <ns>10</ns>
    <id>2421</id>
    <revision>
      <id>8434</id>
      <parentid>8433</parentid>
      <timestamp>2011-08-09T21:05:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark macro fun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="85">{{mark|function macro}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem class</title>
    <ns>10</ns>
    <id>151</id>
    <revision>
      <id>17371</id>
      <parentid>4002</parentid>
      <timestamp>2012-01-10T20:29:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+mem param</comment>
      <text xml:space="preserve" bytes="132">{{mark|public member class {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem const</title>
    <ns>10</ns>
    <id>152</id>
    <revision>
      <id>4012</id>
      <parentid>303</parentid>
      <timestamp>2011-06-10T20:51:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem const]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="135">{{mark|public member constant {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem fun</title>
    <ns>10</ns>
    <id>153</id>
    <revision>
      <id>3995</id>
      <parentid>305</parentid>
      <timestamp>2011-06-10T20:45:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem fun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="135">{{mark|public member function {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem obj</title>
    <ns>10</ns>
    <id>2193</id>
    <revision>
      <id>4967</id>
      <parentid>4954</parentid>
      <timestamp>2011-07-10T20:13:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem obj]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="91">{{mark|public member object}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem sconst</title>
    <ns>10</ns>
    <id>154</id>
    <revision>
      <id>4001</id>
      <parentid>307</parentid>
      <timestamp>2011-06-10T20:46:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem sconst]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="142">{{mark|public static member constant {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem sfun</title>
    <ns>10</ns>
    <id>155</id>
    <revision>
      <id>4013</id>
      <parentid>309</parentid>
      <timestamp>2011-06-10T20:51:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem sfun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="142">{{mark|public static member function {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark mem vfun</title>
    <ns>10</ns>
    <id>156</id>
    <revision>
      <id>4005</id>
      <parentid>311</parentid>
      <timestamp>2011-06-10T20:48:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark mem vfun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="143">{{mark|virtual public member function {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark optional</title>
    <ns>10</ns>
    <id>157</id>
    <revision>
      <id>4000</id>
      <parentid>313</parentid>
      <timestamp>2011-06-10T20:46:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark optional]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="79">{{mark|optional}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark priv mem class</title>
    <ns>10</ns>
    <id>159</id>
    <revision>
      <id>4009</id>
      <parentid>317</parentid>
      <timestamp>2011-06-10T20:50:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark priv mem class]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="91">{{mark|private member class}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark priv mem fun</title>
    <ns>10</ns>
    <id>160</id>
    <revision>
      <id>3999</id>
      <parentid>319</parentid>
      <timestamp>2011-06-10T20:46:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark priv mem fun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="94">{{mark|private member function}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark priv mem obj</title>
    <ns>10</ns>
    <id>2194</id>
    <revision>
      <id>4968</id>
      <parentid>4955</parentid>
      <timestamp>2011-07-10T20:13:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark priv mem obj]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="92">{{mark|private member object}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark prot mem class</title>
    <ns>10</ns>
    <id>161</id>
    <revision>
      <id>4014</id>
      <parentid>321</parentid>
      <timestamp>2011-06-10T20:51:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark prot mem class]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="94">{{mark |protected member class}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark prot mem fun</title>
    <ns>10</ns>
    <id>162</id>
    <revision>
      <id>3994</id>
      <parentid>323</parentid>
      <timestamp>2011-06-10T20:45:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark prot mem fun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="96">{{mark|protected member function}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark prot mem obj</title>
    <ns>10</ns>
    <id>2195</id>
    <revision>
      <id>4969</id>
      <parentid>4956</parentid>
      <timestamp>2011-07-10T20:13:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark prot mem obj]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="94">{{mark|protected member object}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark prot mem vfun</title>
    <ns>10</ns>
    <id>2778</id>
    <revision>
      <id>10750</id>
      <parentid>10545</parentid>
      <timestamp>2011-09-21T13:18:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark prot mem vfun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="146">{{mark|virtual protected member function {{#if: {{{mem|}}} | of {{tt|{{{mem}}}}}}}}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark ptclass</title>
    <ns>10</ns>
    <id>2588</id>
    <revision>
      <id>9763</id>
      <parentid>9751</parentid>
      <timestamp>2011-08-25T09:56:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark ptclass]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="100">{{mark|class template specialization}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark ptfun</title>
    <ns>10</ns>
    <id>2587</id>
    <revision>
      <id>9762</id>
      <parentid>9750</parentid>
      <timestamp>2011-08-25T09:56:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark ptfun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="103">{{mark|function template specialization}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark rev</title>
    <ns>10</ns>
    <id>12958</id>
    <revision>
      <id>65197</id>
      <timestamp>2013-09-04T23:11:52Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>custom class for all revision marks</comment>
      <text xml:space="preserve" bytes="105">&lt;span class=&quot;t-mark-rev {{{class|}}}&quot;&gt;({{trim|{{{1}}}}})&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1>iy3agkin2yoqxishxsofjtbvyxh2ckb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since c++11</title>
    <ns>10</ns>
    <id>2414</id>
    <revision>
      <id>65214</id>
      <parentid>16181</parentid>
      <timestamp>2013-09-04T23:29:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="106">{{mark rev|class=t-since-cxx11|since C++11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>eys1z76ww125h4awr68uq4ev3zynfim</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since c++14</title>
    <ns>10</ns>
    <id>9978</id>
    <revision>
      <id>65230</id>
      <parentid>65218</parentid>
      <timestamp>2013-09-04T23:32:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark since c++14]]&quot;: High traffic page ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <text xml:space="preserve" bytes="106">{{mark rev|class=t-since-cxx14|since C++14}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>p9afmcxjd8mryr1omq29829qdnjifdo</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since c11</title>
    <ns>10</ns>
    <id>6365</id>
    <revision>
      <id>65223</id>
      <parentid>25358</parentid>
      <timestamp>2013-09-04T23:29:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="102">{{mark rev|class=t-since-c11|since C11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>krg186glfmaabje14od6zb8hrav8aqf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since c99</title>
    <ns>10</ns>
    <id>6084</id>
    <revision>
      <id>65225</id>
      <parentid>22164</parentid>
      <timestamp>2013-09-04T23:29:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="102">{{mark rev|class=t-since-c99|since C99}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>t5rjl3vtjm1q66fcrkl03ek2uiu4uvb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since fs ts</title>
    <ns>10</ns>
    <id>13232</id>
    <revision>
      <id>68155</id>
      <timestamp>2014-03-16T20:55:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="118">{{mark rev|class=t-since-fs-ts t-mark-ts|filesystem TS}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>9gvpnl8ddkqpb7nxv8b61r0q4gx7rvj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since libfund ts</title>
    <ns>10</ns>
    <id>13231</id>
    <revision>
      <id>68151</id>
      <parentid>68147</parentid>
      <timestamp>2014-03-16T20:45:12Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix class</comment>
      <text xml:space="preserve" bytes="133">{{mark rev|class=t-since-libfund-ts t-mark-ts|library fundamentals TS}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>mt0yd6c2zg8f8ecylup43crpx9icano</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since none</title>
    <ns>10</ns>
    <id>12778</id>
    <revision>
      <id>61832</id>
      <parentid>61830</parentid>
      <timestamp>2013-06-09T15:06:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="99">{{mark|since &lt;nowiki&gt;{std}&lt;/nowiki&gt;}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark since parallelism ts</title>
    <ns>10</ns>
    <id>13703</id>
    <revision>
      <id>71905</id>
      <timestamp>2014-07-01T15:29:23Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>Time to add parallelism? This is out for PDTS ballot, going to be generally stable</comment>
      <text xml:space="preserve" bytes="119">{{mark rev|class=t-since-fs-ts t-mark-ts|parallelism TS}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>g34hmd7glrjzmyan02exww1vfxxu4c4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark struct</title>
    <ns>10</ns>
    <id>6534</id>
    <revision>
      <id>25757</id>
      <timestamp>2012-04-25T02:28:24Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>C has structs</comment>
      <text xml:space="preserve" bytes="77">{{mark|struct}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark tclass</title>
    <ns>10</ns>
    <id>2018</id>
    <revision>
      <id>4234</id>
      <timestamp>2011-06-13T05:38:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;{{mark|class template}}&lt;noinclude&gt; {{documentation | Template:mark/doc}} &lt;/noinclude&gt;&quot;</comment>
      <text xml:space="preserve" bytes="85">{{mark|class template}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark tfun</title>
    <ns>10</ns>
    <id>163</id>
    <revision>
      <id>3998</id>
      <parentid>325</parentid>
      <timestamp>2011-06-10T20:46:18Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark tfun]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="88">{{mark|function template}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark typedef</title>
    <ns>10</ns>
    <id>2586</id>
    <revision>
      <id>9761</id>
      <parentid>9747</parentid>
      <timestamp>2011-08-25T09:56:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark typedef]]&quot; ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="78">{{mark|typedef}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark until c++11</title>
    <ns>10</ns>
    <id>2416</id>
    <revision>
      <id>65215</id>
      <parentid>16180</parentid>
      <timestamp>2013-09-04T23:29:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="106">{{mark rev|class=t-until-cxx11|until C++11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>1s6caggl0j0jmrd4o3lrohsezyf6e2p</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark until c++14</title>
    <ns>10</ns>
    <id>9992</id>
    <revision>
      <id>65231</id>
      <parentid>65219</parentid>
      <timestamp>2013-09-04T23:32:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mark until c++14]]&quot;: High traffic page ([Edit=Allow only administrators] (indefinite) [Move=Allow only administrators] (indefinite))</comment>
      <text xml:space="preserve" bytes="106">{{mark rev|class=t-until-cxx14|until C++14}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>lrebb6krqazt8w1zjrjn4nuhsa1y5tv</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark until c11</title>
    <ns>10</ns>
    <id>6364</id>
    <revision>
      <id>65222</id>
      <parentid>25362</parentid>
      <timestamp>2013-09-04T23:29:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use {{mark rev}}</comment>
      <text xml:space="preserve" bytes="102">{{mark rev|class=t-until-c11|until C11}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1>o4936at1strg60eamsjavv50fk49eoj</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark until c99</title>
    <ns>10</ns>
    <id>9911</id>
    <revision>
      <id>46729</id>
      <timestamp>2013-04-09T13:12:41Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="80">{{mark|until C99}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mark until none</title>
    <ns>10</ns>
    <id>12779</id>
    <revision>
      <id>61831</id>
      <parentid>61829</parentid>
      <timestamp>2013-06-09T15:06:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="99">{{mark|until &lt;nowiki&gt;{std}&lt;/nowiki&gt;}}&lt;noinclude&gt;
{{documentation | Template:mark/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:math</title>
    <ns>10</ns>
    <id>2567</id>
    <revision>
      <id>15012</id>
      <parentid>15010</parentid>
      <timestamp>2011-12-07T19:36:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 15010 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="132">&lt;span class=&quot;texhtml&quot; style=&quot;white-space: nowrap;&quot;&gt;{{#replace:{{{1|}}}|{{!}}|&amp;#124;}}&lt;/span&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:math/doc</title>
    <ns>10</ns>
    <id>2902</id>
    <revision>
      <id>18120</id>
      <parentid>18119</parentid>
      <timestamp>2012-01-21T16:21:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>/* Examples */ +2</comment>
      <text xml:space="preserve" bytes="2211">The following templates are used to create wikimarkup generated mathematical formulas. The generated formula is displayed using the same-size font as the adjoining text.

{{tl|math|''source''}} - creates a formula from the specified ''source''.

===Helper templates===

The following templates can be in the ''source'' parameter of the {{tl|math}} template to create advanced formatting.

*{{tl|su|p{{=}}''superscript''{{mark optional}}|b{{=}}''subscript''{{mark optional}}}} - creates superscript and/or subscript, e.g. {{su|p=superscript|b=subscript}}

*{{tl|mrad}} - produces radicals

*{{tl|minteg|''min''|''max''|''body''}} - creates an integral, e.g. {{minteg|min|max|body}}.

*{{tl|mexp|''power''}} - creates an exponent raised to ''power'', e.g. {{mexp|power}}

*{{tl|mfrac|''integer''|''numerator''|''denominator''}} - creates a fraction, e.g. {{mfrac|integer|numerator|denominator}}.

*{{tl|mparen|''left_paren''|''right_paren''|''row1''|''row2''|...|style{{=}}''style''{{mark optional}}|rows{{=}}''row_number_override''{{mark optional}}}} - 
*:creates inline table with invisible borders and parentheses on the sides. E.g. {{mparen|(|}|line1|line2|line3}}
*:''left_paren'' and ''right_paren'' can be one of (){}[]. {{tt|rows}} forces parentheses to span ''row_number_override'' rows. Currently 4 rows are supported. {{tt|style}} denotes additional style for the content ({{tt|row#}} elements).

===Examples===
{| class=&quot;wikitable&quot;
|-
! Source
! Result
|-
|&lt;tt&gt;&lt;nowiki&gt;{{math|({{mrad|2}}){{su|p=2}} {{=}} 2}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{math|({{mrad|2}}){{su|p=2}} {{=}} 2}}
|-
|&lt;tt&gt;&lt;nowiki&gt;{{math|A{{su|p=12|b=3}}}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{math|A{{su|p=12|b=3}}}}
|-
|&lt;tt&gt;&lt;nowiki&gt;{{math|{{minteg|0|+∞|{{mexp|−''x''}} d''x''}} {{=}} 1}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{math|{{minteg|0|+∞|{{mexp|−''x''}} d''x''}} {{=}} 1}}
|-
|&lt;tt&gt;&lt;nowiki&gt;{{math|{{mfrac|1|2}} − {{mfrac|1|3}} {{=}} {{mfrac|1|6}}}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{math|{{mfrac|1|2}} − {{mfrac|1|3}} {{=}} {{mfrac|1|6}}}}
|-
|&lt;tt&gt;&lt;nowiki&gt;{{mparen|(|}|line1|line2|line3}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{mparen|(|}|line1|line2|line3}}
|-
|&lt;tt&gt;&lt;nowiki&gt;{{mparen|{|]|line1|line2|style=font-style: italic;|rows=3}}&lt;/nowiki&gt;&lt;/tt&gt;
|{{mparen|{|]|line1|line2|style=font-style: italic;|rows=3}}
|}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mbox</title>
    <ns>10</ns>
    <id>164</id>
    <revision>
      <id>4015</id>
      <parentid>327</parentid>
      <timestamp>2011-06-10T20:51:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:mbox]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="597">{{
  {{namespace detect 
  | demospace = {{{demospace|}}}
  | main      = ambox
  | talk      = tmbox
  | file      = imbox
  | category  = cmbox
  | other     = ombox
  }}
| type       = {{{type|}}}
| image      = {{{image|}}}
| imageright = {{{imageright|}}}
| style      = {{{style|}}}
| textstyle  = {{{textstyle|}}}
| text       = {{{text}}}
| small      = {{{small|}}}
| smallimage = {{{smallimage|}}}
| smallimageright = {{{smallimageright|}}}
| smalltext  = {{{smalltext|}}}
}}&lt;noinclude&gt;
{{documentation}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mbox/doc</title>
    <ns>10</ns>
    <id>5223</id>
    <revision>
      <id>38035</id>
      <parentid>38034</parentid>
      <timestamp>2012-07-23T09:48:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="482">{{tl|mbox|''text''}} results in different box templates depending on the namespace it is placed in. Results in {{tl|ambox}} in the article namespace, &lt;!--{{tl|tmbox}} in the talk namespace, {{tl|cmbox}} in the category namespace,--&gt; {{tl|fmbox}} in the file namespace and {{tl|ombox}} if none of the previous applies.

{{tl|ambox|''text''}} results in {{ambox|{{{text}}}}}

{{tl|ombox|''text''}} results in {{ombox|{{{text}}}}}

{{tl|fmbox|''text''}} results in {{fmbox|{{{text}}}}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:member</title>
    <ns>10</ns>
    <id>4766</id>
    <revision>
      <id>19618</id>
      <parentid>17977</parentid>
      <timestamp>2012-03-11T12:34:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:member frame]] to [[Template:member]]: Better title</comment>
      <text xml:space="preserve" bytes="56">&lt;div class=&quot;t-member&quot;&gt;
&lt;h1&gt;{{{1|}}}&lt;/h1&gt;
{{{2|}}}
&lt;/div&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mexp</title>
    <ns>10</ns>
    <id>2905</id>
    <revision>
      <id>10905</id>
      <timestamp>2011-09-23T10:54:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="86">&lt;i&gt;e&lt;/i&gt;&lt;sup&gt;{{{1}}}&lt;/sup&gt;&lt;noinclude&gt;
{{documentation|Template:math/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mfrac</title>
    <ns>10</ns>
    <id>2906</id>
    <revision>
      <id>17951</id>
      <parentid>11148</parentid>
      <timestamp>2012-01-19T21:40:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorter css class name (we ship at least 1.5MB just with that word)</comment>
      <text xml:space="preserve" bytes="334">&lt;span class=&quot;t-mfrac&quot;&gt;{{#if:{{{3|}}}
 |{{{1}}}&lt;table&gt;&lt;tr&gt;&lt;td&gt;{{{2}}}&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;{{{3}}}&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
 |{{#if:{{{2|}}}
  |&lt;table&gt;&lt;tr&gt;&lt;td&gt;{{{1}}}&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;{{{2}}}&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
  |&lt;table&gt;&lt;tr&gt;&lt;td&gt;1&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;{{{1}}}&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
 }}
}}&lt;/span&gt;&lt;noinclude&gt;
{{documentation|Template:math/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:minteg</title>
    <ns>10</ns>
    <id>2903</id>
    <revision>
      <id>11159</id>
      <parentid>11158</parentid>
      <timestamp>2011-09-28T20:27:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="183">&lt;span style=&quot;font-size: 1.3em; vertical-align:-0.08em; margin-right: 0.08em;&quot;&gt;&amp;int;&lt;/span&gt;{{su|b={{{1}}}|p={{{2}}}}}{{{3}}}&lt;noinclude&gt;
{{documentation|Template:math/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mparen</title>
    <ns>10</ns>
    <id>5006</id>
    <revision>
      <id>18111</id>
      <parentid>18108</parentid>
      <timestamp>2012-01-21T16:04:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Undo revision 18108 by [[Special:Contributions/P12|P12]] ([[User talk:P12|talk]])</comment>
      <text xml:space="preserve" bytes="409">{{mparen/core
 | lparen={{{1|}}}
 | rparen={{{2|}}}
 | row1={{{3|}}}
 | row2={{{4|}}}
 | row3={{{5|}}}
 | row4={{{6|}}}
 | numrows={{#if:{{{rows|}}}
             | {{{rows}}}
             | {{#if:{{{6|}}}
             | 4
             | {{#if:{{{5|}}}
             | 3
             | {{#if:{{{4|}}}
             | 2
             | {{#if:{{{3|}}}
             | 1
           }}}}}}}}}}
 | style={{{style|}}}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mparen/core</title>
    <ns>10</ns>
    <id>5007</id>
    <revision>
      <id>18121</id>
      <parentid>18113</parentid>
      <timestamp>2012-01-21T16:21:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>&quot;</comment>
      <text xml:space="preserve" bytes="514">&lt;span class=&quot;t-mparen&quot;&gt;&lt;!--
--&gt;&lt;span style=&quot;font-size: {{mparen/font|{{{lparen|}}}|{{{numrows|}}}}}em&quot;&gt;{{mparen/paren|{{{lparen|}}}|{{{numrows|}}}}}&lt;/span&gt;&lt;!--
--&gt;&lt;span style=&quot;{{{style|}}}&quot;&gt;&lt;!--
  --&gt;{{{row1|}}}&lt;!--
  --&gt;{{#if:{{{row2|}}}|&lt;br/&gt;{{{row2|}}} }}&lt;!--
  --&gt;{{#if:{{{row3|}}}|&lt;br/&gt;{{{row3|}}} }}&lt;!--
  --&gt;{{#if:{{{row4|}}}|&lt;br/&gt;{{{row4|}}} }}&lt;!--
--&gt;&lt;/span&gt;&lt;!--
--&gt;&lt;span style=&quot;font-size: {{mparen/font|{{{rparen|}}}|{{{numrows|}}}}}em&quot;&gt;{{mparen/paren|{{{rparen|}}}|{{{numrows|}}}}}&lt;/span&gt;&lt;!--
--&gt;&lt;/span&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mparen/font</title>
    <ns>10</ns>
    <id>5009</id>
    <revision>
      <id>18118</id>
      <parentid>18112</parentid>
      <timestamp>2012-01-21T16:12:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>increase font size</comment>
      <text xml:space="preserve" bytes="201">{{#switch:{{{1|}}}
 | lparen | ( 
 | rparen | )
 | lsq | [
 | rsq | ]={{#switch:{{{2|}}} | 1=0.5 | 2=1 | 1.5}}
 | lcurl | {
 | rcurl | }={{#switch:{{{2|}}} | 1=0.5 | 2=1 | 3=1.5 | 4=2 | 5=1.5}}
 | 1
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mparen/paren</title>
    <ns>10</ns>
    <id>5008</id>
    <revision>
      <id>18115</id>
      <parentid>18109</parentid>
      <timestamp>2012-01-21T16:08:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>wrong paren</comment>
      <text xml:space="preserve" bytes="641">{{#switch:{{{1|}}}
 | lparen
 | (={{#switch:{{{2|}}}
      |1|2|3=⎛&lt;br&gt;⎜&lt;br&gt;⎝
      |4=⎛&lt;br&gt;⎜&lt;br&gt;⎜&lt;br&gt;⎝
     }}
 | rparen
 | )={{#switch:{{{2|}}}
      |1|2|3=⎞&lt;br&gt;⎟&lt;br&gt;⎠
      |4=⎞&lt;br&gt;⎟&lt;br&gt;⎟&lt;br&gt;⎠
     }}
 | lcurl
 | {={{#switch:{{{2|}}}
      |1|2|3=⎧&lt;br&gt;⎨&lt;br&gt;⎩
      |4=⎧&lt;br&gt;⎨&lt;br&gt;⎩
     }}
 | rcurl
 | }={{#switch:{{{2|}}}
      |1|2|3=⎫&lt;br&gt;⎬&lt;br&gt;⎭
      |4=⎫&lt;br&gt;⎬&lt;br&gt;⎭
     }}
 | lsq
 | [={{#switch:{{{2|}}}
      |1|2|3=⎡&lt;br&gt;⎢&lt;br&gt;⎣
      |4=⎡&lt;br&gt;⎢&lt;br&gt;⎢&lt;br&gt;⎣
     }}
 | rsq
 | ]={{#switch:{{{2|}}}
      |1|2|3=⎤&lt;br&gt;⎥&lt;br&gt;⎦
      |4=⎤&lt;br&gt;⎥&lt;br&gt;⎥&lt;br&gt;⎦
     }}
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:mrad</title>
    <ns>10</ns>
    <id>2908</id>
    <revision>
      <id>17975</id>
      <parentid>11151</parentid>
      <timestamp>2012-01-19T23:34:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorter css class name (we ship at least 1.5MB just for that word)</comment>
      <text xml:space="preserve" bytes="161">&lt;span class=&quot;t-mrad&quot;&gt;{{#if:{{{2|}}}|&lt;span&gt;{{{2}}}&lt;/span&gt;}}&lt;span&gt;√&lt;/span&gt;&lt;span&gt;{{{1}}}&lt;/span&gt;&lt;/span&gt;&lt;noinclude&gt;
{{documentation|Template:math/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:n/a</title>
    <ns>10</ns>
    <id>168</id>
    <revision>
      <id>10950</id>
      <parentid>4021</parentid>
      <timestamp>2011-09-24T10:37:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc link</comment>
      <text xml:space="preserve" bytes="266">&lt;noinclude&gt;{| class=&quot;wikitable&quot;
|-
|&lt;/noinclude&gt;style=&quot;background: #ececec; color: grey; vertical-align: middle; text-align: {{{align|center}}}; {{{style|}}}&quot; class=&quot;table-na&quot; | &lt;small&gt;{{{1|N/A}}}&lt;/small&gt;&lt;noinclude&gt;
|}
{{documentation|Template:yes/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:namespace detect</title>
    <ns>10</ns>
    <id>169</id>
    <revision>
      <id>20007</id>
      <parentid>4093</parentid>
      <timestamp>2012-03-19T18:25:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="1448">{{#switch:
  {{lc:               &lt;!--Lower case the result--&gt;
    &lt;!--If no or empty &quot;demospace&quot; parameter then detect namespace--&gt;
    {{#if:{{{demospace|}}} 
    | {{{demospace}}}
    | {{#if:{{{page|}}} 
      | &lt;!--Detect the namespace in the &quot;page&quot; parameter--&gt;
        {{#ifeq:{{NAMESPACE:{{{page}}} }}|{{TALKSPACE:{{{page}}} }}
        | talk
        | {{SUBJECTSPACE:{{{page}}} }} 
        }}
      | &lt;!--No &quot;demospace&quot; or &quot;page&quot; parameters, so detect actual namespace--&gt;
        {{#ifeq:{{NAMESPACE}}|{{TALKSPACE}}
        | talk
        | {{SUBJECTSPACE}} 
        }}
      }}
    }}
  }}
&lt;!-- Only one of the lines below will be executed --&gt;
&lt;!-- Respecting empty parameters on purpose --&gt;
| main        &lt;!--&quot;demospace=main&quot; or {{SUBJECTSPACE}}={{ns:0}}=&quot;&quot;--&gt;
|           = {{{main| {{{other|}}} }}}
| talk      = {{{talk| {{{other|}}} }}}
| user      = {{{user| {{{other|}}} }}}
| wikipedia = {{{wikipedia| {{{other|}}} }}}
| file
| image     = {{{file| {{{image| {{{other|}}} }}} }}}
| mediawiki = {{{mediawiki| {{{other|}}} }}}
| template  = {{{template| {{{other|}}} }}}
| help      = {{{help| {{{other|}}} }}}
| category  = {{{category| {{{other|}}} }}}
| portal    = {{{portal| {{{other|}}} }}}
| book      = {{{book| {{{other|}}} }}}
| other
| #default  = {{{other|}}}   &lt;!--&quot;demospace=other&quot; or a new namespace--&gt;

}}&lt;!--End switch--&gt;&lt;noinclude&gt;

&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:navbar</title>
    <ns>10</ns>
    <id>8494</id>
    <revision>
      <id>39882</id>
      <parentid>32804</parentid>
      <timestamp>2012-09-28T19:57:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>transclude directly from given titles; add edit links</comment>
      <text xml:space="preserve" bytes="2415">&lt;div class=&quot;t-navbar&quot; style=&quot;{{{style|}}}&quot;&gt;&lt;!--

--&gt;{{#addbodyclass:cpp-navbar}}&lt;!--
--&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;&lt;!--
--&gt;{{#if:{{{heading1|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading1|}}} }}&lt;!--
  --&gt;{{#if:{{{content1|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content1}}} }}&lt;div&gt;{{navbar editlink| {{{content1}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading2|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading2|}}} }}&lt;!--
  --&gt;{{#if:{{{content2|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content2}}} }}&lt;div&gt;{{navbar editlink| {{{content2}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading3|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading3|}}} }}&lt;!--
  --&gt;{{#if:{{{content3|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content3}}} }}&lt;div&gt;{{navbar editlink| {{{content3}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading4|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading4|}}} }}&lt;!--
  --&gt;{{#if:{{{content4|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content4}}} }}&lt;div&gt;{{navbar editlink| {{{content4}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading5|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading5|}}} }}&lt;!--
  --&gt;{{#if:{{{content5|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content5}}} }}&lt;div&gt;{{navbar editlink| {{{content5}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading6|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading6|}}} }}&lt;!--
  --&gt;{{#if:{{{content6|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content6}}} }}&lt;div&gt;{{navbar editlink| {{{content6}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading7|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading7|}}} }}&lt;!--
  --&gt;{{#if:{{{content7|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content7}}} }}&lt;div&gt;{{navbar editlink| {{{content7}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--
--&gt;{{#if:{{{heading8|}}} |&lt;div class=&quot;t-navbar-head&quot;&gt;{{ {{{heading8|}}} }}&lt;!--
  --&gt;{{#if:{{{content8|}}} |&lt;div class=&quot;t-navbar-menu&quot;&gt;&lt;div&gt;{{ {{{content8}}} }}&lt;div&gt;{{navbar editlink| {{{content8}}} }}&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;}}&lt;!--
--&gt;&lt;/div&gt;&lt;div class=&quot;t-navbar-sep&quot;&gt;&amp;nbsp;&lt;/div&gt;}}&lt;!--

--&gt;&lt;/div&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:navbar/doc</title>
    <ns>10</ns>
    <id>8594</id>
    <revision>
      <id>32805</id>
      <timestamp>2012-06-12T10:50:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="180">&lt;pre style=&quot;overflow: auto;&quot;&gt;
{{navbar
| style =

| heading1 = 
| content1 = 

| heading2 = 
| content2 = 

| heading3 = 
| content3 = 

...

| heading8 = 
| content8 = 

}}
&lt;/pre&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:navbar editlink</title>
    <ns>10</ns>
    <id>9412</id>
    <revision>
      <id>64254</id>
      <parentid>39783</parentid>
      <timestamp>2013-08-15T16:04:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:navbar editlink]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="268">&lt;onlyinclude&gt;{{#if:{{{1|}}}|&lt;span class=&quot;editsection noprint plainlinks&quot; title=&quot;Edit this template&quot;&gt;[{{fullurl:Template:{{{1}}}|action=edit}} &amp;#91;edit&amp;#93;]&lt;/span&gt;|{{error|no template given}}}}&lt;/onlyinclude&gt;&lt;noinclude&gt;{{documentation|Template:navbar/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:news</title>
    <ns>10</ns>
    <id>10285</id>
    <revision>
      <id>71989</id>
      <parentid>71884</parentid>
      <timestamp>2014-07-04T22:58:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>new version of the offline archive</comment>
      <text xml:space="preserve" bytes="478">* 4 July 2014: New version of the [[Cppreference:Archives|offline archive]]

* 30 June 2014: It is now possible to configure Doxygen to link standard library names to cppreference via tag file functionality. For more information, see [[Cppreference:Archives#Doxygen_tag_file|here]].

* 23 March 2014: New version of the [[Cppreference:Archives|offline archive]]. The documentation can now be displayed correctly on QtCreator and QtAssistant (as of v3.0 and v4.8.6 respectively).</text>
      <sha1>oq41tgfizrfo6y27twhyodiojc41us0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:no</title>
    <ns>10</ns>
    <id>171</id>
    <revision>
      <id>10951</id>
      <parentid>4024</parentid>
      <timestamp>2011-09-24T10:37:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc link</comment>
      <text xml:space="preserve" bytes="249">&lt;noinclude&gt;{| class=&quot;wikitable&quot;
|-
|&lt;/noinclude&gt;style=&quot;background:#ff9090; color:black; vertical-align: middle; text-align: {{{align|center}}}; {{{style|}}}&quot; class=&quot;table-no&quot; | {{{1|No}}}&lt;noinclude&gt;
|}
{{documentation|Template:yes/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:noexcept</title>
    <ns>10</ns>
    <id>2456</id>
    <revision>
      <id>72221</id>
      <parentid>72090</parentid>
      <timestamp>2014-07-24T12:47:53Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>-default {{mark since c++11}}</comment>
      <text xml:space="preserve" bytes="544">{{#if:{{{1|}}}
|&lt;div class=&quot;t-noexcept-full&quot;&gt;{{ltt|cpp/language/noexcept_spec|noexcept}} specification:&amp;nbsp;&amp;nbsp;{{{notes|}}}
&lt;div class=&quot;t-noexcept-box&quot;&gt;{{cc|noexcept({{{1}}})}}&lt;/div&gt;&lt;/div&gt;&lt;includeonly&gt;[[Category:conditionally noexcept]]&lt;/includeonly&gt;
|&lt;div class=&quot;t-noexcept-inline&quot;&gt;{{ltt|cpp/language/noexcept_spec|noexcept}} specification:&amp;nbsp;&amp;nbsp;&lt;div class=&quot;t-noexcept-box&quot;&gt;{{cc|noexcept}}&lt;/div&gt;&amp;nbsp;&amp;nbsp;{{{notes|}}}&lt;/div&gt;&lt;includeonly&gt;[[Category:unconditionally noexcept]]&lt;/includeonly&gt;
}}&lt;noinclude&gt;
{{documentation}}&lt;/noinclude&gt;</text>
      <sha1>85n4quyk6qthut3bxn8godictwzv0vc</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:noexcept/doc</title>
    <ns>10</ns>
    <id>2457</id>
    <revision>
      <id>72223</id>
      <parentid>16572</parentid>
      <timestamp>2014-07-24T13:04:08Z</timestamp>
      <contributor>
        <username>D41D8CD98F</username>
        <id>2237</id>
      </contributor>
      <comment>- notes for the default {{mark since c++11}}</comment>
      <text xml:space="preserve" bytes="295">Adds information about noexcept specification. 

{{tl|noexcept|specification{{mark optional}}|notes{{=}}''notes''{{mark optional}}}}

{{tt|specification}} parameter specifies the code within {{tt|noexcept()}}.

{{tt|notes}} are additional notes that will appear next to the noexcept explanation.</text>
      <sha1>sw3nf8elut548vpc9jd2bkbiv72qaya</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv</title>
    <ns>10</ns>
    <id>213</id>
    <revision>
      <id>65212</id>
      <parentid>61700</parentid>
      <timestamp>2013-09-04T23:29:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="112">&lt;tr class=&quot;t-nv&quot;&gt;&lt;td colspan=&quot;5&quot;&gt;{{{1|}}}&lt;/td&gt;&lt;/tr&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>k9g0fyqr5vaeij5mdaq71bk3lyvtdqs</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv/doc</title>
    <ns>10</ns>
    <id>204</id>
    <revision>
      <id>48798</id>
      <parentid>48526</parentid>
      <timestamp>2013-06-01T00:16:05Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rename 'template' to 'inc'</comment>
      <text xml:space="preserve" bytes="1262">This is one of the family of templates used for creation of feature lists in sidebars.

{{list/doc}}

{{tl|nv begin}}
: starts the declaration list

{{tl|nv h1 | ''heading''}}
: adds heading to the feature list 

{{tl|nv h2 | ''heading''}}
: adds heading to the feature list 

{{tl|nv | ''explanation'' }}
: adds a generic item to the feature list

{{tl|nv ln | ''link'' | ''title override''{{small|(optional)}} | ... | ''title6 override'' {{small|(optional)}} }}
: adds a link item to the feature list

{{tl|nv mem ln | ''link'' | ''title override''{{small|(optional)}} | ... | ''title4 override'' {{small|(optional)}} }}
: adds a link item to the feature list

{{tl|nv inc | ''location'' | ''param1'' (optional) | ''param2'' (optional) ... }}
: includes a template from ''location''. It only invokes {{tlc|location| ''param1'' | ''param2'' ... }} and is included for consistency. Unnamed parameters are passed to the source template. The source template itself should consist from {{tlc|sb list ...}} items.

{{tl|nv end}}
: ends the feature list

The following three templates are used to place features in several columns.

{{tl|nv col begin}}
: starts a column construct

{{tl|nv col next}}
: adds another column

{{tl|nv col end}}
: ends a column construct</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv begin</title>
    <ns>10</ns>
    <id>205</id>
    <revision>
      <id>65210</id>
      <parentid>61699</parentid>
      <timestamp>2013-09-04T23:29:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="154">&lt;includeonly&gt;&lt;div&gt;&lt;table class=&quot;t-nv-begin&quot; cellpadding=0 style=&quot;{{{style|}}}&quot;&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>0gje2zoqvtn00zl9lian71w4odiepjm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv col begin</title>
    <ns>10</ns>
    <id>206</id>
    <revision>
      <id>65206</id>
      <parentid>61761</parentid>
      <timestamp>2013-09-04T23:29:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables, update CSS</comment>
      <text xml:space="preserve" bytes="131">&lt;includeonly&gt;&lt;tr class=&quot;t-nv-col-table&quot;&gt;&lt;td&gt;{{nv begin}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>9j1byhtbgtpnwq0izjc5h24tsm6r8cd</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv col end</title>
    <ns>10</ns>
    <id>207</id>
    <revision>
      <id>65211</id>
      <parentid>63134</parentid>
      <timestamp>2013-09-04T23:29:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="108">&lt;includeonly&gt;{{nv end}}&lt;/td&gt;&lt;/tr&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>rljnbleb7mdpkhk0s6xj6pir6dovlxh</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv col next</title>
    <ns>10</ns>
    <id>208</id>
    <revision>
      <id>65200</id>
      <parentid>61762</parentid>
      <timestamp>2013-09-04T23:29:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="119">&lt;includeonly&gt;{{nv end}}&lt;/td&gt;&lt;td&gt;{{nv begin}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>s6sad95w9ebqysmhygaataaoawpke5v</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv end</title>
    <ns>10</ns>
    <id>209</id>
    <revision>
      <id>65213</id>
      <parentid>61205</parentid>
      <timestamp>2013-09-04T23:29:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="75">&lt;/table&gt;&lt;/div&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>ga7au5eneygsy84aez715tk0myiy7vy</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv guard</title>
    <ns>10</ns>
    <id>210</id>
    <revision>
      <id>48759</id>
      <parentid>4047</parentid>
      <timestamp>2013-05-31T19:39:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:sb list guard]] to [[Template:nv guard]]</comment>
      <text xml:space="preserve" bytes="2">|-</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv h1</title>
    <ns>10</ns>
    <id>211</id>
    <revision>
      <id>65209</id>
      <parentid>61703</parentid>
      <timestamp>2013-09-04T23:29:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="115">&lt;tr class=&quot;t-nv-h1&quot;&gt;&lt;td colspan=&quot;5&quot;&gt;{{{1|}}}&lt;/td&gt;&lt;/tr&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>b91b0rwleuhoym82s6aallu7zmw4y4h</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv h2</title>
    <ns>10</ns>
    <id>212</id>
    <revision>
      <id>65208</id>
      <parentid>61704</parentid>
      <timestamp>2013-09-04T23:29:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="115">&lt;tr class=&quot;t-nv-h2&quot;&gt;&lt;td colspan=&quot;5&quot;&gt;{{{1|}}}&lt;/td&gt;&lt;/tr&gt;&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>ssmsp4sut8p6yty7v9f9bbbdzlz4bcn</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv inc</title>
    <ns>10</ns>
    <id>4758</id>
    <revision>
      <id>56238</id>
      <parentid>48799</parentid>
      <timestamp>2013-06-01T05:33:25Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Shorten template names. Use {{lc}} where appropriate.</comment>
      <text xml:space="preserve" bytes="435">{{#if:{{{1|}}}&lt;!--
--&gt;|{{#if:{{trim|{{ {{{1}}} }}}}&lt;!--
 --&gt; |{{{{{1|}}}&lt;!--
    --&gt;|{{trim|{{{2|}}}}}&lt;!--
    --&gt;|{{trim|{{{3|}}}}}&lt;!--
    --&gt;|{{trim|{{{4|}}}}}&lt;!--
    --&gt;|{{trim|{{{5|}}}}}&lt;!--
    --&gt;|{{trim|{{{6|}}}}}&lt;!--
    --&gt;|{{trim|{{{7|}}}}}&lt;!--
   --&gt;}}&lt;!--
  --&gt;|{{error | given template does not exist}}&lt;!--
--&gt;}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:nv/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv ln</title>
    <ns>10</ns>
    <id>214</id>
    <revision>
      <id>65201</id>
      <parentid>61701</parentid>
      <timestamp>2013-09-04T23:29:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix the HTML structure, use {{lines}} for notes</comment>
      <text xml:space="preserve" bytes="1222">{{nv | 1= &lt;div class=&quot;t-nv-ln-table&quot;&gt;&lt;div&gt;&lt;!--
         --&gt;[[{{{1}}}|&lt;span class=&quot;t-lines&quot;&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{2|}}}}}&lt;!--
--&gt;{{#if:{{{3|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{3|}}}}}}}&lt;!--
--&gt;{{#if:{{{4|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{4|}}}}}}}&lt;!--
--&gt;{{#if:{{{5|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{5|}}}}}}}&lt;!--
--&gt;{{#if:{{{6|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{6|}}}}}}}&lt;!--
--&gt;{{#if:{{{7|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{7|}}}}}}}&lt;!--
--&gt;{{#if:{{{8|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{8|}}}}}}}&lt;!--
--&gt;{{#if:{{{9|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{9|}}}}}}}&lt;!--
--&gt;{{#if:{{{10|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{10|}}}}}}}&lt;!--
--&gt;{{#if:{{{11|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{11|}}}}}}}&lt;!--
--&gt;{{#if:{{{12|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{12|}}}}}}}&lt;!--
--&gt;{{#if:{{{13|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{13|}}}}}}}&lt;!--
--&gt;{{#if:{{{14|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{14|}}}}}}}&lt;!--
--&gt;{{#if:{{{15|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{15|}}}}}}}&lt;!--
--&gt;{{#if:{{{16|}}}|&lt;/span&gt;&lt;span&gt;{{ltt/core|{{{1}}}|{{{16|}}}}}}}&lt;/span&gt;&lt;/span&gt;]]&lt;/div&gt;{{#if:{{{notes|}}}|&lt;div&gt;{{lines|{{{notes}}}}}&lt;/div&gt;}}&lt;/div&gt;}}&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>0a5c3kp75mbykkal7o6kbinyl8mwn3n</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:nv mem ln</title>
    <ns>10</ns>
    <id>215</id>
    <revision>
      <id>65202</id>
      <parentid>61702</parentid>
      <timestamp>2013-09-04T23:29:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix the HTML structure, use {{lines}} for notes</comment>
      <text xml:space="preserve" bytes="1372">{{nv | 1= &lt;div class=&quot;t-nv-ln-table&quot;&gt;&lt;div&gt;&lt;!--
         --&gt;[[{{{1}}}|&lt;span class=&quot;t-lines&quot;&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{2|}}}|{{{p|}}}}}&lt;!--
--&gt;{{#if:{{{3|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{3|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{4|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{4|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{5|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{5|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{6|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{6|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{7|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{7|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{8|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{8|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{9|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{9|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{10|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{10|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{11|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{11|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{12|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{12|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{13|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{13|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{14|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{14|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{15|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{15|}}}|{{{p|}}}}}}}&lt;!--
--&gt;{{#if:{{{16|}}}|&lt;/span&gt;&lt;span&gt;{{l2tt/core|{{{1}}}|{{{16|}}}|{{{p|}}}}}}}&lt;/span&gt;&lt;/span&gt;]]&lt;/div&gt;{{#if:{{{notes|}}}|&lt;div&gt;{{lines|{{{notes}}}}}&lt;/div&gt;}}&lt;/div&gt;}}&lt;noinclude&gt;
{{documentation | Template:nv/doc }}
&lt;/noinclude&gt;</text>
      <sha1>royd9jmtzza9xknxec0b08jh6cwshr9</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ombox</title>
    <ns>10</ns>
    <id>173</id>
    <revision>
      <id>15477</id>
      <parentid>4023</parentid>
      <timestamp>2011-12-10T15:35:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc link</comment>
      <text xml:space="preserve" bytes="691">{{#ifeq:{{{small|}}}|yes
| {{ombox/core
  | small = yes
  | type  = {{{type|}}}
  | image = {{#if:{{{smallimage|}}}| {{{smallimage}}} | {{{image|}}} }}
  | imageright = {{#if:{{{smallimageright|}}} | {{{smallimageright}}} | {{{imageright|}}} }}
  | style = {{{style|}}}
  | textstyle = {{{textstyle|}}}
  | text  = {{#if:{{{smalltext|}}}| {{{smalltext}}} | {{{text}}} }}
  }}
| {{ombox/core
  | type  = {{{type|}}}
  | image = {{{image|}}}
  | imageright = {{{imageright|}}} 
  | style = {{{style|}}}
  | textstyle = {{{textstyle|}}}
  | text  = {{{text}}}
  }}
}}&lt;noinclude&gt;{{documentation|Template:mbox/doc}}&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ombox/core</title>
    <ns>10</ns>
    <id>174</id>
    <revision>
      <id>20019</id>
      <parentid>347</parentid>
      <timestamp>2012-03-19T18:31:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="1839">&lt;table class=&quot;plainlinks ombox {{#ifeq:{{{small}}}|yes|mbox-small}} 
{{#switch:{{{type|}}}
| speedy     = ombox-speedy
| delete     = ombox-delete
| content    = ombox-content
| style      = ombox-style
| move       = ombox-move
| protection = ombox-protection
| notice          &lt;!-- notice = default --&gt;
| #default   = ombox-notice
}}&quot; style=&quot;{{{style|}}}&quot;&gt;
&lt;tr&gt;
{{#ifeq:{{{image|}}}|none
| &lt;!-- No image. Cell with some width or padding necessary for text cell to have 100% width. --&gt;&lt;td class=&quot;mbox-empty-cell&quot;&gt;&lt;/td&gt;
| &lt;td class=&quot;mbox-image&quot;&gt;
  {{#if:{{{image|}}}
  | {{{image}}}
  | [[Image:{{#switch:{{{type|}}}
    | speedy     = Imbox speedy deletion.png
    | delete     = Imbox deletion.png
    | content    = Imbox content.png
    | style      = Edit-clear.svg
    | move       = Imbox move.png
    | protection = Imbox protection.png
    | notice          &lt;!-- notice = default --&gt;
    | #default   = Imbox notice.png
    }} | {{#ifeq:{{{small|}}}|yes
    | 30x30px
    | 40x40px
    }}|link=|alt=]]
  }}&lt;/td&gt;
}}
&lt;td class=&quot;mbox-text&quot; style=&quot;{{{textstyle|}}}&quot;&gt; {{{text}}} &lt;/td&gt;
{{#if:{{{imageright|}}}
| {{#ifeq:{{{imageright|}}}|none
  | &lt;!-- No image. --&gt;
  | &lt;td class=&quot;mbox-imageright&quot;&gt; {{{imageright}}} &lt;/td&gt;
  }}
}}
&lt;/tr&gt;
&lt;/table&gt;&lt;!-- Detect and report usage with faulty &quot;type&quot; parameter:
--&gt;{{#switch:{{{type|}}}
|   &lt;!-- No type fed, is also valid input --&gt;
| speedy
| delete
| content
| style
| move
| protection
| notice     =    &lt;!-- Do nothing, valid &quot;type&quot; --&gt;
| #default   = &lt;div style=&quot;text-align: center;&quot;&gt;This message box is using an invalid &quot;type={{{type|}}}&quot; parameter and needs fixing.&lt;/div&gt;[[Category:Wikipedia message box parameter needs fixing|{{main other|Main:}}{{FULLPAGENAME}}]]&lt;!-- Sort on namespace --&gt;
}}&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:page template</title>
    <ns>10</ns>
    <id>10290</id>
    <redirect title="Template:include page" />
    <revision>
      <id>50425</id>
      <timestamp>2013-06-01T03:26:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:page template]] to [[Template:include page]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:include page]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par</title>
    <ns>10</ns>
    <id>181</id>
    <revision>
      <id>61706</id>
      <parentid>61217</parentid>
      <timestamp>2013-06-08T05:29:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="134">|- class=&quot;t-par&quot;
| {{{1|}}}
| -
| {{{2|}}}&lt;!--
--&gt;{{dsc editlink|dummy}}
&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par/doc</title>
    <ns>10</ns>
    <id>175</id>
    <revision>
      <id>67344</id>
      <parentid>63254</parentid>
      <timestamp>2014-02-05T20:24:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+ par cmp ord</comment>
      <text xml:space="preserve" bytes="4587">This is one of the family of templates used for creation of parameter list.

{{list/doc}}

{{tl|par begin}}
: starts the parameter list

{{tl|par end}}
: ends the parameter list

{{tl|par | ''parameter'' | ''explanation''}}
: adds an item to the parameter list.

{{tl|par hreq}}
: results in &quot;Type requirements&quot;

{{tl|par req | ''requirement''}}
: adds a generic type requirement

{{tl|par req concept | ''parameter_name'' | ''concept'' | ''concept2'' {{mark optional}} | ... | ''concept_n'' {{mark optional}} | overload{{=}}''applicable overload''{{mark optional}} | overloads{{=}}''applicable overloads''{{mark optional}} | notes{{=}}''notes'' }}
: adds a concept requirement.

{{tl|par req concept deref | ''expression'' | ''concept'' | ''concept2'' {{mark optional}} || overload{{=}}''applicable overload''{{mark optional}} | overloads{{=}}''applicable overloads''{{mark optional}} |  ... | ''concept_n'' {{mark optional}} | notes{{=}}''notes'' }}
: adds a concept requirement on the result of dereference of type

{{tl|par inc | ''location'' | ''param1'' {{mark optional}} | ''param2'' {{mark optional}} ... }}
: Sets {{tt|dcl-list-template-name}} [https://www.mediawiki.org/wiki/Extension:Variables variable] to ''location'', includes the template from ''location'' and unsets the variable. Use this template whenever copying param list items from a template; this will add an edit link to them. The unnamed parameters ''param1'', ''param2'', ... are passed to the template.

Specific cases
: functions passed as parameters:

{{tl | par pred0 | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' }}
: predicate with no arguments

{{tl | par pred1 | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' }}
: unary predicate 

{{tl | par pred2 | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }}
: binary predicate 

{{tl | par pred2 eq | ''parameter_name'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }}
: binary equality predicate

{{tl | par cmp | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }}
: comparison function

{{tl | par cmp ord | ''parameter_name'' | value{{=}}''return_value'' {{mark optional}} | ''condition'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }}
: comparison function for ordering

{{tl | par ccmp | ''parameter_name'' | ''additional_explanation'' {{mark optional}} }}
: C-style comparison function

{{tl | par opf | ''parameter_name'' | ''action'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type''}}
: function

{{tl | par op1 | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type''}}
: unary operation

{{tl | par op2 | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' | t1{{=}}''type'' {{small|or}} p1{{=}}''pointer_type'' | t2{{=}}''type'' {{small|or}} p2{{=}}''pointer_type'' {{mark optional}} }}
: binary operation

{{tl | par gen | ''parameter_name'' | ''action'' | rt{{=}}''type'' {{small|or}} rp{{=}}''pointer_type'' }}
: generator

:; Parameters

:*''parameter_name'' is the name of the predicate parameter. 
:*{{tt|value}} is the expected return value when the ''condition'' is satisfied (defaults to {{c|true}}). 
:*{{tt|t1}}, {{tt|t2}}, {{tt|p1}}, {{tt|p2}} are types that the predicate is required to accept as its first and second parameters respectively. {{tt|p1}} and {{tt|p2}} describe a pointer parameter, i.e. it will be dereferenced before passed to the predicate. For each parameter, only one of either {{tt|t*}} or {{tt|p*}} can be used. If {{tt|t2/p2}} are not defined, {{tt|t1,p1}} are used for the second parameter instead.

===Example===

  &lt;nowiki&gt; {{par begin}}
  {{par | count | the size of the list}}
  {{par pred2 | p | p1=ForwardIt | t2=T | if the elements should be exchanged}}
  {{par end}}&lt;/nowiki&gt;

The above results in the following:

{{par begin}}
{{par | count | the size of the list}}
{{par pred2 | p | p1=ForwardIt | t2=T | if the elements should be exchanged}}
{{par end}}</text>
      <sha1>jwbk3bv7eiv6ogcm8jz7lzgtipbs8ab</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par begin</title>
    <ns>10</ns>
    <id>176</id>
    <revision>
      <id>61705</id>
      <parentid>48673</parentid>
      <timestamp>2013-06-08T05:28:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="87">{| class=&quot;t-par-begin&quot;
&lt;noinclude&gt;
|}
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par ccmp</title>
    <ns>10</ns>
    <id>177</id>
    <revision>
      <id>61753</id>
      <parentid>61218</parentid>
      <timestamp>2013-06-08T05:40:53Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="519">{{par | {{{1|}}} | comparison function which returns ​a negative integer value if the first argument is ''less'' than the second, &lt;br/&gt;
a positive integer value if the first argument is ''greater'' than the second and zero if the arguments are equal.{{{2|}}}&lt;br&gt;
The signature of the comparison function should be equivalent to the following:

{{cc | int cmp(const void *a, const void *b); }}

The function must not modify the objects passed to it.
}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par cmp</title>
    <ns>10</ns>
    <id>178</id>
    <revision>
      <id>67176</id>
      <parentid>67175</parentid>
      <timestamp>2014-01-25T15:14:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Changed protection level for &quot;[[Template:par cmp]]&quot; ([Edit=Allow only autoconfirmed users] (indefinite) [Move=Allow only autoconfirmed users] (indefinite))</comment>
      <text xml:space="preserve" bytes="627">{{par | {{{1|}}} | comparison function object (i.e. an object that satisfies the requirements of {{concept|Compare}}) which returns ​{{c|{{{value|true}}}}} if {{{2|the first argument is ''less'' than the second}}}. &lt;br&gt;
The signature of the comparison function should be equivalent to the following:

{{cc | bool cmp(const Type1 &amp;a, const Type2 &amp;b);}}

The signature does not need to have {{c|const &amp;}}, but the function object must not modify the objects passed to it.&lt;br&gt;
{{cast req2 |Type1|Type2| t1={{{t1|}}} | t2={{{t2|}}} | p1={{{p1|}}} | p2={{{p2|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1>25fr3fpcg7lryi68gy58pbqwczfng5m</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par cmp ord</title>
    <ns>10</ns>
    <id>13137</id>
    <revision>
      <id>69096</id>
      <parentid>69095</parentid>
      <timestamp>2014-03-27T09:24:37Z</timestamp>
      <contributor>
        <ip>81.14.208.18</ip>
      </contributor>
      <text xml:space="preserve" bytes="656">{{par | {{{1|}}} | comparison function object (i.e. an object that satisfies the requirements of {{concept|Compare}}) which returns ​{{c|{{{value|true}}}}} if {{{2|the first argument is ''less'' than (i.e. is ordered ''before'') the second}}}. &lt;br&gt;
The signature of the comparison function should be equivalent to the following:

{{cc | bool cmp(const Type1 &amp;a, const Type2 &amp;b);}}

The signature does not need to have {{c|const &amp;}}, but the function object must not modify the objects passed to it.&lt;br&gt;
{{cast req2 |Type1|Type2| t1={{{t1|}}} | t2={{{t2|}}} | p1={{{p1|}}} | p2={{{p2|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1>7mox054nx9581v8t89epab3k2xg24dr</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par end</title>
    <ns>10</ns>
    <id>179</id>
    <revision>
      <id>61220</id>
      <parentid>48679</parentid>
      <timestamp>2013-06-05T12:31:06Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;param list/doc&quot; to &quot;par/doc&quot;</comment>
      <text xml:space="preserve" bytes="66">&lt;onlyinclude&gt;|}&lt;/onlyinclude&gt;
{{documentation | Template:par/doc}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par gen</title>
    <ns>10</ns>
    <id>180</id>
    <revision>
      <id>62264</id>
      <parentid>62263</parentid>
      <timestamp>2013-06-25T12:50:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>don't use ddcl</comment>
      <text xml:space="preserve" bytes="312">{{par | {{{1|}}} | generator function object that will be called. {{{2|}}}&lt;br&gt;
The signature of the function should be equivalent to the following:
{{dcl begin}}
{{dcl | 
Ret fun();
}}
{{dcl end}}
{{cast rreq | Ret | rt={{{rt|}}} | rp={{{rp|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par hreq</title>
    <ns>10</ns>
    <id>9138</id>
    <revision>
      <id>61707</id>
      <parentid>61223</parentid>
      <timestamp>2013-06-08T05:29:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="116">|- class=&quot;t-par-hitem&quot;
| colspan=3 | Type requirements
&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par inc</title>
    <ns>10</ns>
    <id>9967</id>
    <revision>
      <id>61290</id>
      <parentid>56253</parentid>
      <timestamp>2013-06-05T14:20:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update link</comment>
      <text xml:space="preserve" bytes="425">{{#if:{{{1|}}}&lt;!--
--&gt;|{{#vardefine:dcl-list-template-name|{{{1|}}}}}&lt;!--
 --&gt;{{ {{{1|}}}&lt;!--
    --&gt;|{{trim|{{{2|}}}}}&lt;!--
    --&gt;|{{trim|{{{3|}}}}}&lt;!--
    --&gt;|{{trim|{{{4|}}}}}&lt;!--
    --&gt;|{{trim|{{{5|}}}}}&lt;!--
    --&gt;|{{trim|{{{6|}}}}}&lt;!--
    --&gt;|{{trim|{{{7|}}}}}&lt;!--
--&gt;}}{{#vardefine:dcl-list-template-name}}&lt;!--
--&gt;|{{error | no template source given}} }}&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par op1</title>
    <ns>10</ns>
    <id>182</id>
    <revision>
      <id>61750</id>
      <parentid>61749</parentid>
      <timestamp>2013-06-08T05:40:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="412">{{par | {{{1|}}} | unary operation function object that will be applied. {{{2|}}}&lt;br&gt;
The signature of the function should be equivalent to the following:

{{cc | Ret fun(const Type &amp;a); }}

The signature does not need to have {{c|const &amp;}}. &lt;br&gt;{{cast req1 | Type | t1={{{t1|}}} | p1={{{p1|}}}}} {{cast rreq | Ret | rt={{{rt|}}} | rp={{{rp|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par op2</title>
    <ns>10</ns>
    <id>183</id>
    <revision>
      <id>61751</id>
      <parentid>61748</parentid>
      <timestamp>2013-06-08T05:40:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>spacing</comment>
      <text xml:space="preserve" bytes="469">{{par | {{{1|}}} | binary operation function object that will be applied. {{{2|}}}&lt;br&gt;
The signature of the function should be equivalent to the following:

{{cc | Ret fun(const Type1 &amp;a, const Type2 &amp;b); }}

The signature does not need to have {{c|const &amp;}}. &lt;br&gt;{{cast req2 | Type1 | Type2 | t1={{{t1|}}} | p1={{{p1|}}} | t2={{{t2|}}} | p2={{{p2|}}}}} {{cast rreq | Ret | rt={{{rt|}}} | rp={{{rp|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par opf</title>
    <ns>10</ns>
    <id>184</id>
    <revision>
      <id>61752</id>
      <parentid>61228</parentid>
      <timestamp>2013-06-08T05:40:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="329">{{par | {{{1|}}} | function object, {{{2|}}}&lt;br/&gt;
The signature of the function should be equivalent to the following:

{{cc | void fun(const Type &amp;a); }}

The signature does not need to have {{c|const &amp;}}. &lt;br/&gt;{{cast req1 | Type | t1={{{t1|}}} | p1={{{p1|}}}}}
}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par pred0</title>
    <ns>10</ns>
    <id>5048</id>
    <revision>
      <id>61759</id>
      <parentid>61758</parentid>
      <timestamp>2013-06-08T05:42:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="268">{{par | {{{1|}}} | predicate {{#if:{{{2|}}}|which returns ​{{c|{{{value|true}}}}} {{{2}}}}}. &lt;br/&gt;
The signature of the predicate function should be equivalent to the following:

{{cc | bool pred();}}​}}&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par pred1</title>
    <ns>10</ns>
    <id>185</id>
    <revision>
      <id>61757</id>
      <parentid>61231</parentid>
      <timestamp>2013-06-08T05:42:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="453">{{par | {{{1|}}} | unary predicate {{#if:{{{2|}}}|which returns ​{{c|{{{value|true}}}}} {{{2}}}}}. &lt;br/&gt;
The signature of the predicate function should be equivalent to the following:

{{cc | bool pred(const Type &amp;a);}}

The signature does not need to have {{c|const &amp;}}, but the function must not modify the objects passed to it.&lt;br&gt;
{{cast req1 |Type| | t1={{{t1|}}} | p1={{{p1|}}}}}}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par pred2</title>
    <ns>10</ns>
    <id>186</id>
    <revision>
      <id>61756</id>
      <parentid>61232</parentid>
      <timestamp>2013-06-08T05:41:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="513">{{par | {{{1|}}} | binary predicate {{#if:{{{2|}}}|which returns ​{{c|{{{value|true}}}}} {{{2}}}}}. &lt;br/&gt;
The signature of the predicate function should be equivalent to the following:

{{cc | bool pred(const Type1 &amp;a, const Type2 &amp;b); }}

The signature does not need to have {{c|const &amp;}}, but the function must not modify the objects passed to it.&lt;br/&gt;
{{cast req2 | Type1 | Type2 | t1={{{t1|}}} | t2={{{t2|}}} | p1={{{p1|}}} | p2={{{p2|}}}}}
}}​&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par pred2 eq</title>
    <ns>10</ns>
    <id>187</id>
    <revision>
      <id>61755</id>
      <parentid>61233</parentid>
      <timestamp>2013-06-08T05:41:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="190">{{par pred2 | {{{1|}}} | p1={{{p1|}}} | t1={{{t1|}}} | p2={{{p2|}}} | t2={{{t2|}}} | if the elements should be treated as equal}}&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par req</title>
    <ns>10</ns>
    <id>9139</id>
    <revision>
      <id>61708</id>
      <parentid>61234</parentid>
      <timestamp>2013-06-08T05:29:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="141">|- class=&quot;t-par-req&quot;
| colspan=3 | -&lt;div class=&quot;spacer&quot;&gt;&lt;/div&gt;{{trim|{{{1|}}}}}
&lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par req concept</title>
    <ns>10</ns>
    <id>9140</id>
    <revision>
      <id>61760</id>
      <parentid>61235</parentid>
      <timestamp>2013-06-08T05:42:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use new templates</comment>
      <text xml:space="preserve" bytes="737">{{par req | 1={{tt|{{trim|{{{1}}}}}}} must meet the requirements of {{#if:{{{6|}}}
|{{concept|{{{6}}}}}, {{concept|{{{5}}}}}, {{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{5|}}}
|{{concept|{{{5}}}}}, {{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{4|}}}
|{{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{3|}}}
|{{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{concept|{{{2}}}}}
}}}}}}}}{{#if:{{{overload|}}}{{{overloads|}}} 
| {{#if:{{{overload|}}} |&lt;nowiki&gt; &lt;/nowiki&gt;in order to use overload ({{{overload}}}) |&lt;nowiki&gt; &lt;/nowiki&gt;in order to use overloads ({{{overloads}}}) }}
}}. {{{notes|}}} }} &lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:par req concept deref</title>
    <ns>10</ns>
    <id>9308</id>
    <revision>
      <id>61289</id>
      <parentid>56286</parentid>
      <timestamp>2013-06-05T14:20:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update link</comment>
      <text xml:space="preserve" bytes="717">{{par req | 1=The type of dereferenced {{tt|{{trim|{{{1}}}}}}} must meet the requirements of {{#if:{{{6|}}}
|{{concept|{{{6}}}}}, {{concept|{{{5}}}}}, {{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{5|}}}
|{{concept|{{{5}}}}}, {{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{4|}}}
|{{concept|{{{4}}}}}, {{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{#if:{{{3|}}}
|{{concept|{{{3}}}}} and {{concept|{{{2}}}}}
|{{concept|{{{2}}}}}
}}}}}}}}{{#if:{{{version|}}}{{{versions|}}} 
| {{#if:{{{version|}}} | in order to use version {{{version}}} | in order to use versions {{{versions}}} }}
}}. {{{notes|}}} }} &lt;noinclude&gt;
{{documentation | Template:par/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list/doc</title>
    <ns>10</ns>
    <id>10179</id>
    <redirect title="Template:par/doc" />
    <revision>
      <id>48693</id>
      <parentid>48529</parentid>
      <timestamp>2013-05-31T18:56:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Redirected page to [[Template:par/doc]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list begin</title>
    <ns>10</ns>
    <id>10241</id>
    <redirect title="Template:par begin" />
    <revision>
      <id>48674</id>
      <timestamp>2013-05-31T18:54:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list begin]] to [[Template:par begin]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:par begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list ccmp</title>
    <ns>10</ns>
    <id>10242</id>
    <redirect title="Template:par ccmp" />
    <revision>
      <id>48676</id>
      <timestamp>2013-05-31T18:54:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list ccmp]] to [[Template:par ccmp]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:par ccmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list cmp</title>
    <ns>10</ns>
    <id>10243</id>
    <redirect title="Template:par cmp" />
    <revision>
      <id>48678</id>
      <timestamp>2013-05-31T18:55:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list cmp]] to [[Template:par cmp]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par cmp]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list end</title>
    <ns>10</ns>
    <id>10244</id>
    <redirect title="Template:par end" />
    <revision>
      <id>48680</id>
      <timestamp>2013-05-31T18:55:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list end]] to [[Template:par end]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list gen</title>
    <ns>10</ns>
    <id>10245</id>
    <redirect title="Template:par gen" />
    <revision>
      <id>48682</id>
      <timestamp>2013-05-31T18:55:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list gen]] to [[Template:par gen]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par gen]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list hreq</title>
    <ns>10</ns>
    <id>10246</id>
    <redirect title="Template:par hreq" />
    <revision>
      <id>48684</id>
      <timestamp>2013-05-31T18:55:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list hreq]] to [[Template:par hreq]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:par hreq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list item</title>
    <ns>10</ns>
    <id>10247</id>
    <redirect title="Template:par" />
    <revision>
      <id>48686</id>
      <timestamp>2013-05-31T18:55:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list item]] to [[Template:par]]</comment>
      <text xml:space="preserve" bytes="26">#REDIRECT [[Template:par]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list op1</title>
    <ns>10</ns>
    <id>10248</id>
    <redirect title="Template:par op1" />
    <revision>
      <id>48688</id>
      <timestamp>2013-05-31T18:55:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list op1]] to [[Template:par op1]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par op1]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list op2</title>
    <ns>10</ns>
    <id>10249</id>
    <redirect title="Template:par op2" />
    <revision>
      <id>48690</id>
      <timestamp>2013-05-31T18:56:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list op2]] to [[Template:par op2]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par op2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list opf</title>
    <ns>10</ns>
    <id>10250</id>
    <redirect title="Template:par opf" />
    <revision>
      <id>48692</id>
      <timestamp>2013-05-31T18:56:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list opf]] to [[Template:par opf]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par opf]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list pred0</title>
    <ns>10</ns>
    <id>10251</id>
    <redirect title="Template:par pred0" />
    <revision>
      <id>48695</id>
      <timestamp>2013-05-31T18:57:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list pred0]] to [[Template:par pred0]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:par pred0]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list pred1</title>
    <ns>10</ns>
    <id>10252</id>
    <redirect title="Template:par pred1" />
    <revision>
      <id>48697</id>
      <timestamp>2013-05-31T18:57:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list pred1]] to [[Template:par pred1]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:par pred1]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list pred2</title>
    <ns>10</ns>
    <id>10253</id>
    <redirect title="Template:par pred2" />
    <revision>
      <id>48699</id>
      <timestamp>2013-05-31T18:57:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list pred2]] to [[Template:par pred2]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:par pred2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list pred2 eq</title>
    <ns>10</ns>
    <id>10254</id>
    <redirect title="Template:par pred2 eq" />
    <revision>
      <id>48701</id>
      <timestamp>2013-05-31T18:57:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list pred2 eq]] to [[Template:par pred2 eq]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:par pred2 eq]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list req</title>
    <ns>10</ns>
    <id>10255</id>
    <redirect title="Template:par req" />
    <revision>
      <id>48703</id>
      <timestamp>2013-05-31T18:57:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list req]] to [[Template:par req]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:par req]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list req concept</title>
    <ns>10</ns>
    <id>10256</id>
    <redirect title="Template:par req concept" />
    <revision>
      <id>48705</id>
      <timestamp>2013-05-31T18:57:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list req concept]] to [[Template:par req concept]]</comment>
      <text xml:space="preserve" bytes="38">#REDIRECT [[Template:par req concept]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:param list req concept deref</title>
    <ns>10</ns>
    <id>10257</id>
    <redirect title="Template:par req concept deref" />
    <revision>
      <id>48707</id>
      <timestamp>2013-05-31T18:57:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:param list req concept deref]] to [[Template:par req concept deref]]</comment>
      <text xml:space="preserve" bytes="44">#REDIRECT [[Template:par req concept deref]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:plot</title>
    <ns>10</ns>
    <id>8461</id>
    <revision>
      <id>30896</id>
      <parentid>30887</parentid>
      <timestamp>2012-05-13T20:02:39Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>better specify image ourselves; add default size</comment>
      <text xml:space="preserve" bytes="435">&lt;div class=&quot;t-plot&quot;&gt;
{{#if:{{{1|}}}
|{{#if:{{{left|}}}|&lt;div class=&quot;t-plot-left&quot;&gt;{{{left}}}&lt;/div&gt;}}
{{#if:{{{right|}}}|&lt;div class=&quot;t-plot-right&quot;&gt;{{{right}}}&lt;/div&gt;}}
&lt;div class=&quot;t-plot-image{{#if:{{{left|}}}|-left}}{{#if:{{{right|}}}|-right}}&quot;&gt;[[Image:{{{1|}}}|{{{size|200x200px}}}]]&lt;/div&gt;
{{#if:{{{bottom|}}}|&lt;div class=&quot;t-plot-bottom&quot;&gt;{{{bottom}}}&lt;/div&gt;}}
|{{error|No image specified}}
}}
&lt;/div&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:plot/doc</title>
    <ns>10</ns>
    <id>8462</id>
    <revision>
      <id>39825</id>
      <parentid>30906</parentid>
      <timestamp>2012-09-28T17:46:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt -&gt; code</comment>
      <text xml:space="preserve" bytes="845">
{{tl|plot | ''location'' | left=''text_at_left'' {{optional}} | right=''text_at_right'' {{optional}} | bottom=''text_at_bottom'' {{optional}} | size='' '''width'''x'''height'''px''{{optional}}}}

Draws a plot image at ''location''. {{tt|left}}, {{tt|right}} and {{tt|bottom}} parameters optionally specify additional text that would appear to the left, right and bottom of the plot image. The {{tt|size}} parameter specifies the size of the image in the usual Mediawiki syntax (see [http://www.mediawiki.org/wiki/Help:Images this help page]). The default size value is 200 &amp;times; 200 pixels.

===Example===

{{tt|&lt;nowiki&gt;{{plot | math-atan2.png | left=Y argument | bottom=X argument | right=Return value | size=x240px}}&lt;/nowiki&gt;}}

results in:

{{plot | math-atan2.png | left=Y argument | bottom=X argument | right=Return value | size=x240px}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:pp-meta</title>
    <ns>10</ns>
    <id>190</id>
    <revision>
      <id>67343</id>
      <parentid>67342</parentid>
      <timestamp>2014-02-05T20:23:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>padlock</comment>
      <text xml:space="preserve" bytes="5413">{{#ifeq:{{#switch:{{lc:{{{type}}}}}
  |move=&lt;!--
 --&gt;{{#ifeq:
      {{#switch:{{lc:{{{demolevel|undefined}}}}}
        |semi
        |autoconfirmed=autoconfirmed
        |administrator
        |full
        |sysop=sysop
        |undefined={{PROTECTIONLEVEL:move}}
        |#default=&lt;!--fallback value: null
   --&gt;}}
      |sysop|yes|no
    }}
  |create=&lt;!--
 --&gt;{{#if:
      {{#switch:{{lc:{{{demolevel|undefined}}}}}
        |semi
        |autoconfirmed=autoconfirmed
        |administrator
        |full
        |sysop=sysop
        |undefined={{PROTECTIONLEVEL:create}}
        |#default=&lt;!--fallback value: null
   --&gt;}}
      |yes|no
    }}
|#default&lt;!--includes all other types--&gt;=&lt;!--
 --&gt;{{#if:
      {{#switch:{{lc:{{{demolevel|undefined}}}}}
        |semi
        |autoconfirmed=autoconfirmed
        |administrator
        |full
        |sysop=sysop
        |undefined={{PROTECTIONLEVEL:edit}}
        |#default=&lt;!--fallback value: null
   --&gt;}}
      |{{#ifeq:{{#switch:{{lc:{{{disallowlevel|}}}}}
                 |semi
                 |autoconfirmed=autoconfirmed
                 |administrator
                 |full
                 |sysop=sysop
                 |#default=&lt;!--fallback value: null--&gt;}}
         |{{#switch:{{lc:{{{demolevel|undefined}}}}}
            |semi
            |autoconfirmed=autoconfirmed
            |administrator
            |full
            |sysop=sysop
            |undefined={{PROTECTIONLEVEL:edit}}
            |#default=&lt;!--fallback value: null
       --&gt;}}
         |no|yes
       }}
   |no}}
}}|yes|{{#ifeq:{{lc:{{{small|}}}}}|yes|
&lt;div class=&quot;metadata topicon&quot; id=&quot;protected-icon&quot; style=&quot;display:none; right:55px;&quot;&gt;[[Image:{{{image|{{#switch:{{lc:{{{type}}}}}
 |full=Padlock-red.svg
 |semi=Padlock-red.svg
 |move=Padlock-red.svg
 |indef=Padlock-red.svg
 |office=Padlock-red.svg
 |create=Padlock-red.svg
 |#default=Transparent.gif
}}}}}|20px|link=|{{{icon-text|This {{pp-meta/pagetype}} is {{#switch:{{lc:{{{type}}}}}
 |semi=semi-
 |move=move-
 |indef=permanently&lt;nowiki&gt; &lt;/nowiki&gt;
 |create=creation-
 |office=&lt;!--null, but should this have a special tag?--&gt;
 |full
 |#default=&lt;!--null--&gt;
}}protected{{#ifeq:{{lc:{{{type}}}}}|indef||{{#if:{{{expiry|}}}|&lt;nowiki&gt; &lt;/nowiki&gt;until {{#time:F j, Y|{{{expiry}}}}}}}}}{{#if:{{{icon-reason|}}}|&lt;nowiki&gt; &lt;/nowiki&gt;{{{icon-reason}}}}}.}}}|alt=Page {{#switch:{{lc:{{{type}}}}}
 |semi=semi-
 |move=move-
 |indef=permanently&lt;nowiki&gt; &lt;/nowiki&gt;
 |create=creation-
 |office=&lt;!--null, but should this have a special tag?--&gt;
 |full
 |#default=&lt;!--null--&gt;
}}protected]]&lt;/div&gt;
|&lt;!-- else, not small --&gt;
{{mbox 
| demospace = {{{demospace|}}}
| type = protection
| image = [[Image:{{{image|{{#switch:{{lc:{{{type}}}}}
 |full=Padlock-red.svg
 |semi=Padlock-red.svg
 |move=Padlock-red.svg
 |indef=Padlock-red.svg
 |office=Padlock-red.svg
 |create=Padlock-red.svg
 |#default=Transparent.gif
}}}}}|40px|{{{icon-text|This page is {{#switch:{{lc:{{{type}}}}}
 |semi=semi-
 |move=move-
 |indef=permanently&lt;nowiki&gt; &lt;/nowiki&gt;
 |create=creation-
 |office=&lt;!--null, but should this have a special tag?--&gt;
 |full
 |#default=&lt;!--null--&gt;
}}protected.}}}]]
| text = '''{{{reason-text|{{#switch:{{lc:{{{type}}}}}
 |full=This page is currently protected from editing
 |semi=Editing of this {{pp-meta/pagetype}} by new or unregistered users is currently [[enwiki:Wikipedia:Protection policy|disabled]]
 |move=This {{pp-meta/pagetype}} is currently [[enwiki:Wikipedia:This page is protected|protected]] from [[enwiki:Help:Moving a page|page moves]]
 |indef=This page is protected from editing ''indefinitely''
 |office=This {{pp-meta/pagetype}} is currently protected from editing
 |create=[[enwiki:Help:Starting a new page|Recreation]] of this {{pp-meta/pagetype}} [[enwiki:Wikipedia:This page is protected|has been disabled]]
}}{{#ifeq:{{lc:{{{type}}}}}|indef||{{#if:{{{expiry|}}}|&amp;#32;until {{#time:F j, Y|{{{expiry}}}}}}}}}{{{reason&lt;includeonly&gt;|&lt;/includeonly&gt;}}}.}}}'''&lt;br /&gt; {{{explanation-text|{{#switch:{{lc:{{{type}}}}}
 |full|indef=Please discuss any changes on the talk page.
 |semi=If you cannot edit this {{pp-meta/pagetype}} and you wish to make a change, you can {{#ifeq:{{NAMESPACE}}|{{TALKSPACE}}||[[Template:Editsemiprotected|request an edit]], [[{{TALKPAGENAME}}|discuss changes on the talk page]],}} request unprotection, [[Special:Userlogin|log in]], or &lt;span class=&quot;plainlinks&quot;&gt;[http://en.cppreference.com/mwiki/index.php?title=Special:Userlogin&amp;type=signup &lt;span style=&quot;color:#002bb8;&quot; title=&quot;Sign in / create account&quot;&gt;create an account&lt;/span&gt;]&lt;/span&gt;.
 |move=The page may still be edited but cannot be moved until unprotected. Please discuss any suggested moves on the [[{{TALKPAGENAME}}|talk page]].  
 |office=If you are able to edit this page, please discuss all changes and additions on the [[{{TALKPAGENAME}}|talk page]] first. '''Do not remove protection from this page unless you are authorized by the Wikimedia Foundation to do so.'''
 |create=Please see the {{#if:{{{xfd|}}}|'''[[{{{xfd}}}|deletion discussion]]''' or the}} [{{fullurl:Special:Log|type=delete&amp;page={{FULLPAGENAMEE}}}} deletion log] for details of why this page was deleted.
}}}}}
}}
}}|[[Category:Wikipedia pages with incorrect protection templates]]}}&lt;!--End if small--&gt;&lt;includeonly&gt;{{#ifeq:{{lc:{{{categories|no}}}}}|no||{{{categories|}}}}}&lt;/includeonly&gt;&lt;noinclude&gt;

&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1>lmhxutzkviovxcjf3f6vxcugyy97d7u</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:pp-meta/pagetype</title>
    <ns>10</ns>
    <id>13138</id>
    <revision>
      <id>67341</id>
      <timestamp>2014-02-05T20:20:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="317">{{#ifeq:{{TALKSPACE}}|{{NAMESPACE}}|talk page|
{{#switch:{{NAMESPACE}}
 |{{ns:}}              = article
 |{{ns:File}}          = file
 |{{ns:Template}}      = template
 |{{ns:Category}}      = category
 |{{ns:Module}}        = module
 |#default             = page}}}}&lt;noinclude&gt;
{{doc|content={{NODOC}}}}
&lt;/noinclude&gt;</text>
      <sha1>pttdhb8ryrm4klhkfpi1swcyzsmrqxb</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:pp-template</title>
    <ns>10</ns>
    <id>191</id>
    <revision>
      <id>19982</id>
      <parentid>19083</parentid>
      <timestamp>2012-03-19T16:45:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="2981">&lt;includeonly&gt;{{pp-meta
|type={{#switch:{{{demolevel|{{#ifeq:{{PROTECTIONLEVEL:edit}}-{{PROTECTIONLEVEL:move}}|-sysop|move|{{PROTECTIONLEVEL:edit}}}}}}}
   |semi
   |autoconfirmed=semi
   |administrator
   |full
   |sysop=indef
   |move=move
   |#default=indef&lt;!--fallback value--&gt;}}
|small={{{small|no}}}
|demospace={{{demospace|}}}
|demolevel={{#ifeq:{{PAGENAME}}/{{NAMESPACE}}|{{SUBPAGENAME}}/{{ns:Template}}|{{{demolevel|undefined}}}|{{#ifeq:{{lc:{{SUBPAGENAME}}}}|sandbox|sysop|{{{demolevel|undefined}}}}}}}
|expiry=&lt;!--not applicable--&gt;
|dispute=no
|icon-text=This {{#ifeq:{{NAMESPACE}}|{{ns:6}}|image, included in a high-risk template or message,|high-risk template}} is indefinitely {{#switch:{{{demolevel|{{#ifeq:{{PROTECTIONLEVEL:edit}}-{{PROTECTIONLEVEL:move}}|-sysop|move|{{PROTECTIONLEVEL:edit}}}}}}}
   |semi
   |autoconfirmed=semi-protected from editing
   |move=move-protected
   |administrator
   |full
   |sysop
   |#default=&lt;!--fallback value--&gt;protected from editing}} to prevent vandalism.
|reason-text=This {{#switch:{{NAMESPACE}}
  |{{ns:image}}=image, used in one or more high-risk templates{{#switch:{{{demolevel|{{PROTECTIONLEVEL:edit}}}}}
   |semi
   |autoconfirmed=
   |administrator
   |full
   |sysop=&lt;nowiki&gt; &lt;/nowiki&gt;and/or system messages,
   |#default=&lt;!--fallback value--&gt;}}
  |#default=high-risk template
}} has been {{#switch:{{{demolevel|{{#ifeq:{{PROTECTIONLEVEL:edit}}-{{PROTECTIONLEVEL:move}}|-sysop|move|{{PROTECTIONLEVEL:edit}}}}}}}
   |semi
   |autoconfirmed=semi-
   |move=move-
   |administrator
   |full
   |sysop&lt;!--uses default--&gt;
   |#default=&lt;!--fallback value--&gt;}}protected{{#ifeq:{{PROTECTIONLEVEL:edit}}-{{PROTECTIONLEVEL:move}}|-sysop||&lt;nowiki&gt; &lt;/nowiki&gt;from editing}} to prevent vandalism. {{#switch:{{{demolevel|{{PROTECTIONLEVEL:edit}}}}}
   |semi
   |autoconfirmed=
   |administrator
   |full
   |sysop&lt;!--uses default--&gt;
   |#default={{#switch:{{NAMESPACE}}|{{ns:image}}=&lt;br /&gt;&lt;small&gt;'''Do not move this image''' to [[commons:|Wikimedia Commons]].&lt;/small&gt;}}}}
|categories={{{categories|{{#ifeq:{{NAMESPACE}}|{{ns:10}}|{{#switch:{{{demolevel|{{#ifeq:{{PROTECTIONLEVEL:edit}}-{{PROTECTIONLEVEL:move}}|-sysop|move|{{PROTECTIONLEVEL:edit}}}}}}}
   |semi
   |autoconfirmed=[[Category:Wikipedia semi-protected templates|{{PAGENAME}}]]{{#ifeq:{{PROTECTIONLEVEL:move}}|sysop|[[Category:Wikipedia move-protected templates|{{PAGENAME}}]]}}
   |move=[[Category:Wikipedia move-protected templates|{{PAGENAME}}]]
   |administrator
   |full
   |sysop&lt;!--uses default--&gt;
   |#default=[[Category:Wikipedia protected templates|{{PAGENAME}}]]&lt;!--fallback value--&gt;}}}}{{#ifeq:{{NAMESPACE}}|{{ns:6}}|[[Category:{{#switch:{{{demolevel|{{PROTECTIONLEVEL:edit}}}}}
   |semi
   |autoconfirmed=Semi-protected
   |administrator
   |full
   |sysop&lt;!--uses default--&gt;
   |#default=Protected&lt;!--fallback value--&gt;}} images|{{PAGENAME}}]]}}}}}}}&lt;/includeonly&gt;&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:purge</title>
    <ns>10</ns>
    <id>192</id>
    <revision>
      <id>20015</id>
      <parentid>4062</parentid>
      <timestamp>2012-03-19T18:30:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="56">{{[[Template:{{{1}}}|{{{1}}}]]}}&lt;noinclude&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std</title>
    <ns>10</ns>
    <id>13010</id>
    <revision>
      <id>66077</id>
      <parentid>65639</parentid>
      <timestamp>2013-10-24T15:49:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>don't show id by default</comment>
      <text xml:space="preserve" bytes="188">&lt;onlyinclude&gt;:* {{{section}}} {{{title}}} {{#if:{{{id|}}}|&amp;#91;{{{id}}}&amp;#93; }}{{#if:{{{p|}}}|(p: {{{p}}})}}
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>nuxqtaha4wp2d2orbjj6cyr5ixzktgx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std/doc</title>
    <ns>10</ns>
    <id>13011</id>
    <revision>
      <id>66078</id>
      <parentid>66072</parentid>
      <timestamp>2013-10-24T15:50:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1291">{{tl|ref std c89}}

{{tl|ref std c99}}

{{tl|ref std c11}}

{{tl|ref std c++98}}

{{tl|ref std c++03}}

{{tl|ref std c++11}}

{{tl|ref std c++14}}

{{tl|ref std end}}

{{tl|ref std | section{{=}}''section'' | title{{=}}''title'' | id{{=}}''id''{{mark optional}}| p{{=}}''pages'' {{mark optional}}}}

Applies consistent formatting to the references to the C++ standards in the &quot;References&quot; section. Each section must always start with {{tlc|ref std c++*}} and end with {{tlc|ref std end}}.

===Example===
  &lt;nowiki&gt;
  {{ref std c++11}}
  {{ref std | section=8.3.5 | title=Functions | id=dcl.fct}}
  {{ref std | section=8.3.6 | title=Default arguments | id=dcl.fct.default | p=1-2,4}}
  {{ref std end}}
  {{ref std c++98}}
  {{ref std | section=8.3.5 | title=Functions | id=dcl.fct}}
  {{ref std | section=8.3.6 | title=Default arguments | id=dcl.fct.default | p=1-2,4}}
  {{ref std end}}
  &lt;/nowiki&gt;

The above wikitext is rendered as:

{{ref std c++11}}
{{ref std | section=8.3.5 | title=Functions | id=dcl.fct}}
{{ref std | section=8.3.6 | title=Default arguments | id=dcl.fct.default | p=1-2,4}}
{{ref std end}}
{{ref std c++98}}
{{ref std | section=8.3.5 | title=Functions | id=dcl.fct}}
{{ref std | section=8.3.6 | title=Default arguments | id=dcl.fct.default | p=1-2,4}}
{{ref std end}}</text>
      <sha1>p4lyrlw41z20b9rfcmwcn3s8rpm9ahm</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c++03</title>
    <ns>10</ns>
    <id>13007</id>
    <revision>
      <id>65631</id>
      <parentid>65630</parentid>
      <timestamp>2013-09-23T19:13:04Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="162">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c++03&quot;&gt;
* C++03 standard (ISO/IEC 14882:2003): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>c1ayohl9nky5y894b0ctt2dymkf13g5</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c++11</title>
    <ns>10</ns>
    <id>13006</id>
    <revision>
      <id>65629</id>
      <timestamp>2013-09-23T19:12:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="162">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c++11&quot;&gt;
* C++11 standard (ISO/IEC 14882:2011): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>mahnwd2mc2tjma6ixzfcz268o4erv5d</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c++14</title>
    <ns>10</ns>
    <id>13012</id>
    <revision>
      <id>65642</id>
      <timestamp>2013-09-23T19:24:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="162">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c++14&quot;&gt;
* C++11 standard (ISO/IEC 14882:2014): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>4zrpjzcymjd5dcxo4t6084upsz3eirx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c++98</title>
    <ns>10</ns>
    <id>13008</id>
    <revision>
      <id>65632</id>
      <timestamp>2013-09-23T19:13:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="162">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c++98&quot;&gt;
* C++98 standard (ISO/IEC 14882:1998): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>9m75bxuw5xuvn8jss03k0szjr8ssxo6</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c11</title>
    <ns>10</ns>
    <id>13033</id>
    <revision>
      <id>66073</id>
      <timestamp>2013-10-24T15:45:44Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="156">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-11&quot;&gt;
* C11 standard (ISO/IEC 9899:2011): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>sn3r63wwbtqzusu4ofcfd6l16ivtmu0</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c89</title>
    <ns>10</ns>
    <id>13035</id>
    <revision>
      <id>66075</id>
      <timestamp>2013-10-24T15:46:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="161">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c89&quot;&gt;
* C89/C90 standard (ISO/IEC 9899:1990): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>1sbblqhyq6bf88e5yrhyafco6wg22g3</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std c99</title>
    <ns>10</ns>
    <id>13034</id>
    <revision>
      <id>66074</id>
      <timestamp>2013-10-24T15:45:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="157">&lt;onlyinclude&gt;&lt;div class=&quot;t-ref-std-c99&quot;&gt;
* C99 standard (ISO/IEC 9899:1999): 
&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>3n8k9ks3jh3ukrqskpa4dnmwbdj1ovp</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ref std end</title>
    <ns>10</ns>
    <id>13009</id>
    <revision>
      <id>66079</id>
      <parentid>65633</parentid>
      <timestamp>2013-10-24T15:50:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rm space</comment>
      <text xml:space="preserve" bytes="98">&lt;onlyinclude&gt;&lt;/div&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:ref std/doc}}
&lt;/noinclude&gt;</text>
      <sha1>hc4b0c94mn6dwdcm0vzc5b3l7u487o1</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rev</title>
    <ns>10</ns>
    <id>9554</id>
    <revision>
      <id>65234</id>
      <parentid>65228</parentid>
      <timestamp>2013-09-04T23:50:25Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use HTML tables</comment>
      <text xml:space="preserve" bytes="377">&lt;onlyinclude&gt;&lt;tr class=&quot;t-rev {{#if:{{{since|}}}|t-since-{{#replace:{{{since}}}|+|x}}}} {{#if:{{{until|}}}|t-until-{{#replace:{{{until}}}|+|x}}}}&quot;&gt;&lt;td&gt;{{{1|}}}&lt;/td&gt;
&lt;td&gt;{{#if:{{{since|}}}|{{mark since {{{since|}}}}}{{#if:{{{until|}}}|&lt;br/&gt;}}}}{{#if:{{{until|}}}|{{mark until {{{until|}}}}} }}&lt;/td&gt;&lt;/tr&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:rev/doc}}
&lt;/noinclude&gt;</text>
      <sha1>i5ppwlmc2lipxki66hrb9bsst5e2vtf</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rev/doc</title>
    <ns>10</ns>
    <id>10262</id>
    <revision>
      <id>71975</id>
      <parentid>71966</parentid>
      <timestamp>2014-07-04T19:01:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1003">
Used to declare that certain part of the description in valid to only specific revisions of the standard.

{{tl|rev begin|noborder{{=}}''true_if_noborder''}}

Begins the set of text snippets specific to a specific revision(s) of the standard. If the {{tt|noborder}} parameter is ''true'' then the table is displayed with no border and as little padding as possible.

{{tl|rev|since{{=}}''since-std''{{mark optional}}|until{{=}}''until-std''{{mark optional}}|text}}

Specifies that ''text'' is valid only for standard revisions since ''since-std'' until ''until-std'' (''until-std'' is not inclusive).

{{tl|rev end}}

Ends the set of text snippets specific to a specific revision(s) of the standard.

{{tl|rev inl|since{{=}}''since-std''{{mark optional}}|until{{=}}''until-std''{{mark optional}}|noborder{{=}}''true_if_noborder''|text}}

Same as {{tl|rev}}, just is displayed inline. {{tl|rev begin}} and {{tl|rev end}} must not be used.

Border is omitted if the {{tt|noborder}} parameter is ''true''.</text>
      <sha1>ocsbl5onfnegygqnjs6u358ot519g5e</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rev begin</title>
    <ns>10</ns>
    <id>9552</id>
    <revision>
      <id>71974</id>
      <parentid>64791</parentid>
      <timestamp>2014-07-04T19:00:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add noborder param</comment>
      <text xml:space="preserve" bytes="168">&lt;includeonly&gt; &lt;table class=&quot;t-rev-begin {{#ifeq:{{{noborder|}}}|true|t-rev-begin-noborder}}&quot;&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:rev/doc}}
&lt;/noinclude&gt;</text>
      <sha1>s8ysl2lkxux795bhrw5657ha6yy6kle</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rev end</title>
    <ns>10</ns>
    <id>9553</id>
    <revision>
      <id>64792</id>
      <parentid>61287</parentid>
      <timestamp>2013-08-27T00:50:22Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use explicit table syntax</comment>
      <text xml:space="preserve" bytes="69">&lt;/table&gt;&lt;noinclude&gt;
{{documentation | Template:rev/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rev inl</title>
    <ns>10</ns>
    <id>12785</id>
    <revision>
      <id>71970</id>
      <parentid>71969</parentid>
      <timestamp>2014-07-04T18:54:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add a space between the text and the mark</comment>
      <text xml:space="preserve" bytes="424">&lt;span class=&quot;t-rev-inl {{#ifeq:{{{noborder|}}}|true|t-rev-inl-noborder}} {{#if:{{{since|}}}|t-since-{{#replace:{{{since}}}|+|x}}}} {{#if:{{{until|}}}|t-until-{{#replace:{{{until}}}|+|x}}}}&quot;&gt;&lt;span&gt;{{{1|}}}&lt;/span&gt; &lt;!--
--&gt;&lt;span&gt;{{#if:{{{since|}}}|{{mark since {{{since|}}}}}{{#if:{{{until|}}}|&lt;br/&gt;}}}}{{#if:{{{until|}}}|{{mark until {{{until|}}}}} }}&lt;/span&gt;&lt;/span&gt;&lt;noinclude&gt;
{{documentation | Template:rev/doc}}
&lt;/noinclude&gt;</text>
      <sha1>cahag97g6hemim8wpbd62iinl66dnio</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:right</title>
    <ns>10</ns>
    <id>2746</id>
    <revision>
      <id>10397</id>
      <parentid>4061</parentid>
      <timestamp>2011-09-10T20:09:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+ doc link</comment>
      <text xml:space="preserve" bytes="184">&lt;includeonly&gt;&lt;div style=&quot;text-align:right; width:auto; margin-left:auto; margin-right:auto;&quot;&gt;{{{1}}}&lt;/div&gt;&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation | Template:center/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rl</title>
    <ns>10</ns>
    <id>196</id>
    <revision>
      <id>391</id>
      <parentid>390</parentid>
      <timestamp>2011-06-06T22:43:56Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="125">{{#if: {{{1|}}} |[[/{{trim|{{{1|}}}}}|{{{2|{{{1}}}}}}]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rl/doc</title>
    <ns>10</ns>
    <id>197</id>
    <revision>
      <id>64377</id>
      <parentid>64372</parentid>
      <timestamp>2013-08-15T18:46:51Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rm rlf</comment>
      <text xml:space="preserve" bytes="1227">This is one of templates used to make links.

Absolute links:

{{tl|ltt|''path''|''title'' {{mark optional}} }} - link to a page using absolute path. The default title is only the last part of the path. Link font is {{tt|teletype}}.

{{tl|ltf|''path''|''title'' {{mark optional}} | args=''arguments'' {{mark optional}}  }} - link to a page using absolute path. The default title is only the last part of the path. Link font is {{tt|teletype}}. Parentheses indicating function are appended.

{{tl|l2tt|''page''|''title1'' {{mark optional}} | ''title2'' {{mark optional}} }} - makes a link to a page using absolute path. The title is formed from the two last parts of the path. {{tt|::}} is inserted between them. Each of these parts can be overridden by ''title1'' and ''title2''.  Link font is {{tt|teletype}}.

Relative links:

{{tl|rl|''page''|''title'' {{mark optional}} }} - makes a link to a page relative to this page. The link appears in normal font.

{{tl|rlp|''page''|''title'' {{mark optional}} }} - makes a link to a page relative to the parent page. The link appears in normal font.

{{tl|rlt|''page''|''title'' {{mark optional}} }} - makes a link to a page relative to this page. The link appears in teletype font.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rlp</title>
    <ns>10</ns>
    <id>199</id>
    <revision>
      <id>4058</id>
      <parentid>397</parentid>
      <timestamp>2011-06-11T14:19:38Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:rlp]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="145">{{#if: {{{1|}}} |[[../{{trim|{{{1|}}}}}|{{{2|{{{1}}}}}}]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation | Template:rl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:rlt</title>
    <ns>10</ns>
    <id>202</id>
    <revision>
      <id>4057</id>
      <parentid>403</parentid>
      <timestamp>2011-06-11T14:19:35Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:rlt]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="150">{{#if: {{{1|}}} |[[/{{trim|{{{1|}}}}}|{{tt|{{{2|{{{1}}}}}}}}]]| {{error|no link given}} }}&lt;noinclude&gt;
{{documentation | Template:rl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list/doc</title>
    <ns>10</ns>
    <id>10178</id>
    <redirect title="Template:nv/doc" />
    <revision>
      <id>48525</id>
      <timestamp>2013-05-31T17:34:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list/doc]] to [[Template:nv/doc]]: Prepare for renames</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[Template:nv/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list begin</title>
    <ns>10</ns>
    <id>10279</id>
    <redirect title="Template:nv begin" />
    <revision>
      <id>48770</id>
      <timestamp>2013-05-31T19:40:20Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list begin]] to [[Template:nv begin]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:nv begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list column begin</title>
    <ns>10</ns>
    <id>10278</id>
    <redirect title="Template:nv col begin" />
    <revision>
      <id>48768</id>
      <timestamp>2013-05-31T19:40:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list column begin]] to [[Template:nv col begin]]</comment>
      <text xml:space="preserve" bytes="35">#REDIRECT [[Template:nv col begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list column end</title>
    <ns>10</ns>
    <id>10277</id>
    <redirect title="Template:nv col end" />
    <revision>
      <id>48766</id>
      <timestamp>2013-05-31T19:40:07Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list column end]] to [[Template:nv col end]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:nv col end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list column next</title>
    <ns>10</ns>
    <id>10276</id>
    <redirect title="Template:nv col next" />
    <revision>
      <id>48764</id>
      <timestamp>2013-05-31T19:40:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list column next]] to [[Template:nv col next]]</comment>
      <text xml:space="preserve" bytes="34">#REDIRECT [[Template:nv col next]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list end</title>
    <ns>10</ns>
    <id>10275</id>
    <redirect title="Template:nv end" />
    <revision>
      <id>48762</id>
      <timestamp>2013-05-31T19:39:54Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list end]] to [[Template:nv end]]</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[Template:nv end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list guard</title>
    <ns>10</ns>
    <id>10274</id>
    <redirect title="Template:nv guard" />
    <revision>
      <id>48760</id>
      <timestamp>2013-05-31T19:39:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list guard]] to [[Template:nv guard]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:nv guard]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list h1</title>
    <ns>10</ns>
    <id>10273</id>
    <redirect title="Template:nv h1" />
    <revision>
      <id>48758</id>
      <timestamp>2013-05-31T19:39:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list h1]] to [[Template:nv h1]]</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[Template:nv h1]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list h2</title>
    <ns>10</ns>
    <id>10272</id>
    <redirect title="Template:nv h2" />
    <revision>
      <id>48756</id>
      <timestamp>2013-05-31T19:39:41Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list h2]] to [[Template:nv h2]]</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[Template:nv h2]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list item</title>
    <ns>10</ns>
    <id>10271</id>
    <redirect title="Template:nv" />
    <revision>
      <id>48754</id>
      <timestamp>2013-05-31T19:39:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list item]] to [[Template:nv]]</comment>
      <text xml:space="preserve" bytes="25">#REDIRECT [[Template:nv]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list ln</title>
    <ns>10</ns>
    <id>10270</id>
    <redirect title="Template:nv ln" />
    <revision>
      <id>48752</id>
      <timestamp>2013-05-31T19:39:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list ln]] to [[Template:nv ln]]</comment>
      <text xml:space="preserve" bytes="28">#REDIRECT [[Template:nv ln]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list mem ln</title>
    <ns>10</ns>
    <id>10269</id>
    <redirect title="Template:nv mem ln" />
    <revision>
      <id>48750</id>
      <timestamp>2013-05-31T19:38:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sb list mem ln]] to [[Template:nv mem ln]]</comment>
      <text xml:space="preserve" bytes="32">#REDIRECT [[Template:nv mem ln]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sb list template</title>
    <ns>10</ns>
    <id>10268</id>
    <redirect title="Template:nv inc" />
    <revision>
      <id>48800</id>
      <parentid>48748</parentid>
      <timestamp>2013-06-01T00:16:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rename 'template' to 'inc'</comment>
      <text xml:space="preserve" bytes="29">#REDIRECT [[Template:nv inc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdcl list/doc</title>
    <ns>10</ns>
    <id>10182</id>
    <redirect title="Template:sdsc/doc" />
    <revision>
      <id>48548</id>
      <timestamp>2013-05-31T18:13:10Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sdcl list/doc]] to [[Template:sdsc/doc]]: prepare for renames</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:sdsc/doc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdcl list begin</title>
    <ns>10</ns>
    <id>10264</id>
    <redirect title="Template:sdsc begin" />
    <revision>
      <id>48740</id>
      <timestamp>2013-05-31T19:38:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sdcl list begin]] to [[Template:sdsc begin]]</comment>
      <text xml:space="preserve" bytes="33">#REDIRECT [[Template:sdsc begin]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdcl list end</title>
    <ns>10</ns>
    <id>10265</id>
    <redirect title="Template:sdsc end" />
    <revision>
      <id>48742</id>
      <timestamp>2013-05-31T19:38:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sdcl list end]] to [[Template:sdsc end]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:sdsc end]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdcl list item</title>
    <ns>10</ns>
    <id>10266</id>
    <redirect title="Template:sdsc" />
    <revision>
      <id>48744</id>
      <timestamp>2013-05-31T19:38:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sdcl list item]] to [[Template:sdsc]]</comment>
      <text xml:space="preserve" bytes="27">#REDIRECT [[Template:sdsc]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdcl list sep</title>
    <ns>10</ns>
    <id>10267</id>
    <redirect title="Template:sdsc sep" />
    <revision>
      <id>48746</id>
      <timestamp>2013-05-31T19:38:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:sdcl list sep]] to [[Template:sdsc sep]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:sdsc sep]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdsc</title>
    <ns>10</ns>
    <id>220</id>
    <revision>
      <id>61697</id>
      <parentid>61020</parentid>
      <timestamp>2013-06-08T05:28:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="336">{{sdsc sep}}
|- class=&quot;t-sdsc&quot;
| {{#if: {{{num|{{{notes|}}}}}} || class=&quot;t-sdsc-nopad&quot; }} | {{trim| {{{1|}}}}}
| {{#if: {{{num|}}} || class=&quot;t-sdsc-nopad&quot; }} | {{#if: {{{num|}}} | ({{{num}}}) }}
| {{#if: {{{notes|}}} || class=&quot;t-sdsc-nopad&quot; }} | {{{notes|}}}
{{list guard}}
&lt;noinclude&gt;
{{documentation | Template:sdsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdsc/doc</title>
    <ns>10</ns>
    <id>216</id>
    <revision>
      <id>48549</id>
      <parentid>48547</parentid>
      <timestamp>2013-05-31T18:13:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update template names</comment>
      <text xml:space="preserve" bytes="692">This is one of the family of templates used for creation of syntax explanation lists.

{{list/doc}}

{{tl|sdsc begin}}
: starts the declaration list

{{tl|sdsc end}}
: ends the declaration list. This template automatically adds {{tl|sdsc sep}} above the item.

{{tl|sdsc sep}}
: adds a separator

{{tl|sdsc | notes{{=}}''notes'' | num{{=}}''num'' | ''declaration'' }}
: adds an item to the declaration list. The {{tt|notes}} parameter is optional and may be used to add notes about the feature. The {{tt|num}} parameter is also optional and may be used for numbering purposes. ''declaration'' is the declaration of the feature. This template automatically adds {{tl|sdsc sep}} above the item.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdsc begin</title>
    <ns>10</ns>
    <id>217</id>
    <revision>
      <id>61696</id>
      <parentid>61211</parentid>
      <timestamp>2013-06-08T05:28:26Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="112">&lt;onlyinclude&gt;{| class=&quot;t-sdsc-begin&quot;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation | Template:sdsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdsc end</title>
    <ns>10</ns>
    <id>218</id>
    <revision>
      <id>61213</id>
      <parentid>48741</parentid>
      <timestamp>2013-06-05T12:30:32Z</timestamp>
      <contributor>
        <username>P12bot</username>
        <id>89</id>
      </contributor>
      <minor/>
      <comment>Text replace - &quot;sdcl list/doc&quot; to &quot;sdsc/doc&quot;</comment>
      <text xml:space="preserve" bytes="82">{{sdcl list sep}}
|}&lt;noinclude&gt;
{{documentation | Template:sdsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sdsc sep</title>
    <ns>10</ns>
    <id>221</id>
    <revision>
      <id>61698</id>
      <parentid>61214</parentid>
      <timestamp>2013-06-08T05:28:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="101">|-
| colspan=&quot;10&quot; class=&quot;t-sdsc-sep&quot; |
&lt;noinclude&gt;
{{documentation | Template:sdsc/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:sidebar/doc</title>
    <ns>10</ns>
    <id>2133</id>
    <revision>
      <id>4666</id>
      <timestamp>2011-07-01T20:26:32Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Created page with &quot;See [[enwiki:Template:sidebar|Wikipedia documentation]]&quot;</comment>
      <text xml:space="preserve" bytes="55">See [[enwiki:Template:sidebar|Wikipedia documentation]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:small</title>
    <ns>10</ns>
    <id>224</id>
    <revision>
      <id>4641</id>
      <parentid>4046</parentid>
      <timestamp>2011-07-01T19:31:47Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add documentation</comment>
      <text xml:space="preserve" bytes="178">&lt;span style=&quot;font-size:0.7em; line-height:130%&quot;&gt;{{{1}}}&lt;/span&gt;&lt;noinclude&gt;
&lt;!--Categories and interwikis go in the /doc sub-page.--&gt;
{{documentation|Template:tt/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:smalltt</title>
    <ns>10</ns>
    <id>225</id>
    <revision>
      <id>39822</id>
      <parentid>4643</parentid>
      <timestamp>2012-09-28T17:44:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt -&gt; code</comment>
      <text xml:space="preserve" bytes="89">{{small|&lt;code&gt;{{{1|}}}&lt;/code&gt;}}&lt;noinclude&gt;
{{documentation|Template:tt/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:source</title>
    <ns>10</ns>
    <id>226</id>
    <revision>
      <id>25273</id>
      <parentid>9742</parentid>
      <timestamp>2012-04-20T13:49:36Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use getlang for the language</comment>
      <text xml:space="preserve" bytes="108">&lt;onlyinclude&gt;{{#tag:source|{{{code|{{{1}}}}}}|lang={{{lang|{{get lang}}}}}}}&lt;/onlyinclude&gt;
{{documentation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:source/doc</title>
    <ns>10</ns>
    <id>227</id>
    <revision>
      <id>61674</id>
      <parentid>48004</parentid>
      <timestamp>2013-06-08T04:51:46Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>sync</comment>
      <text xml:space="preserve" bytes="1927">This is one of the templates used for syntax highlighting.

{{tl|c | 1{{=}}''code'' | lang{{=}}''language''{{mark optional}} }}
: Base template that is intended to highlight code inline. ''lang'' is optional; value returned by {{tl|get_lang}} is used by default. Applies a semi-transparent dark background.

{{tl|c/core | 1{{=}}''code'' | lang{{=}}''language''{{mark optional}} }}
: Same as {{tl|c}} just no background is applied. Intended to be used in other templates only.

{{tl|cc | 1{{=}}''code'' | lang{{=}}''language''{{mark optional}} }}
: Base template that is intended to highlight larger amounts of code inline. Usually used when the {{tl|c}} template doesn't display the code readable, but {{tl|source}} would waste too much space. ''lang'' is optional; value returned by {{tl|get_lang}} is used by default.

{{tl|source | 1{{=}}''code'' | lang{{=}}''language''{{mark optional}} }}
: Base template that is intended to highlight large amounts of code. ''lang'' is optional; value returned by {{tl|get_lang}} is used by default.

{{tl|eq fun| lang{{=}}''language''|''code1''|''code2''{{mark optional}}|...|''code4''{{mark optional}}}} - where {{tt|code1}}, {{tt|code2}}, etc. are code for each version of the described template function. If no code is supplied at all, the template results in {{tl|todo}}. ''lang'' is optional; value returned by {{tl|get_lang}} is used by default.

{{tl|example|''description''{{mark optional}}|lang{{=}}''language''{{mark optional}} | code{{=}}''code_to_display''| p{{=}}''true_if_nondeterministic''{{mark optional}}}}
: Base template for examples. If {{tt|code}} is not present, the template results in {{tl|todo}}. ''lang'' defaults to a value returned by {{tl|get_lang}}. ''output'' specifies the output which is displayed by the code. If the output is not deterministic, ''p'' can be set to {{tt|true}} to indicate this (''Possible output'' is shown instead of just ''Output'').</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:space</title>
    <ns>10</ns>
    <id>229</id>
    <revision>
      <id>4671</id>
      <parentid>4044</parentid>
      <timestamp>2011-07-01T20:52:33Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add doc link</comment>
      <text xml:space="preserve" bytes="80">{{#pad:|{{{1}}}}}&lt;noinclude&gt;
{{documentation | Template:space/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:space/doc</title>
    <ns>10</ns>
    <id>2137</id>
    <revision>
      <id>4689</id>
      <parentid>4675</parentid>
      <timestamp>2011-07-01T21:29:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add trim</comment>
      <text xml:space="preserve" bytes="300">Handles space characters.

{{tl|space|''number''}} - outputs ''number'' of space characters

{{tl|space as|''text''}} - outputs as many space characters as there are characters in ''text''. Useful for indentation of templatized code.

{{tl|trim|''text''}} - trims both leading and trailing whitespace</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:space as</title>
    <ns>10</ns>
    <id>230</id>
    <revision>
      <id>4672</id>
      <parentid>4095</parentid>
      <timestamp>2011-07-01T20:52:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>add doc link</comment>
      <text xml:space="preserve" bytes="90">{{space|{{#len:{{{1|}}}}}}}&lt;noinclude&gt;
{{documentation | Template:space/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:spar</title>
    <ns>10</ns>
    <id>231</id>
    <revision>
      <id>61680</id>
      <parentid>48737</parentid>
      <timestamp>2013-06-08T05:25:40Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Update css class names, use new templates</comment>
      <text xml:space="preserve" bytes="86">&lt;span class=&quot;t-spar&quot;&gt;{{trim|{{{1}}}}}&lt;/span&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:spar/doc</title>
    <ns>10</ns>
    <id>4263</id>
    <revision>
      <id>48736</id>
      <parentid>15468</parentid>
      <timestamp>2013-05-31T19:37:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>moved [[Template:sparam/doc]] to [[Template:spar/doc]]</comment>
      <text xml:space="preserve" bytes="131">
Used to mark-up identifiers referring to syntax constructs. Currently used only in pages about the C++ language (cpp/language/**).</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:stub</title>
    <ns>10</ns>
    <id>9031</id>
    <revision>
      <id>37946</id>
      <timestamp>2012-07-21T20:50:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="33">{{todo}}[[Category:Stub article]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:su</title>
    <ns>10</ns>
    <id>2904</id>
    <revision>
      <id>17976</id>
      <parentid>13558</parentid>
      <timestamp>2012-01-19T23:34:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>shorter css class name (we ship at least 1.5MB just for that word)</comment>
      <text xml:space="preserve" bytes="153">&lt;span class=&quot;t-su {{#if:{{{b|}}}|t-su-b}}&quot; &gt;&lt;!--
  --&gt;{{{p|}}}&lt;br /&gt;&lt;!--
  --&gt;{{{b|}}}&lt;/span&gt;&lt;noinclude&gt;
{{documentation|Template:math/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:template</title>
    <ns>10</ns>
    <id>10286</id>
    <redirect title="Template:include" />
    <revision>
      <id>48783</id>
      <timestamp>2013-06-01T00:08:37Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:template]] to [[Template:include]]</comment>
      <text xml:space="preserve" bytes="30">#REDIRECT [[Template:include]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:template editlink</title>
    <ns>10</ns>
    <id>10287</id>
    <redirect title="Template:include editlink" />
    <revision>
      <id>48785</id>
      <timestamp>2013-06-01T00:08:55Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:template editlink]] to [[Template:include editlink]]</comment>
      <text xml:space="preserve" bytes="39">#REDIRECT [[Template:include editlink]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:template other</title>
    <ns>10</ns>
    <id>243</id>
    <revision>
      <id>20013</id>
      <parentid>485</parentid>
      <timestamp>2012-03-19T18:29:30Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="416">{{#switch:
  &lt;!--If no or empty &quot;demospace&quot; parameter then detect namespace--&gt;
  {{#if:{{{demospace|}}}
  | {{lc: {{{demospace}}} }}    &lt;!--Use lower case &quot;demospace&quot;--&gt;
  | {{#ifeq:{{NAMESPACE}}|{{ns:Template}}
    | template
    | other
    }}
  }}
| template = {{{1|}}}
| other
| #default = {{{2|}}}
}}&lt;!--End switch--&gt;&lt;noinclude&gt;
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:templated</title>
    <ns>10</ns>
    <id>10288</id>
    <redirect title="Template:included" />
    <revision>
      <id>48802</id>
      <timestamp>2013-06-01T00:17:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>moved [[Template:templated]] to [[Template:included]]</comment>
      <text xml:space="preserve" bytes="31">#REDIRECT [[Template:included]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:test live example</title>
    <ns>10</ns>
    <id>9915</id>
    <revision>
      <id>46846</id>
      <parentid>46845</parentid>
      <timestamp>2013-04-14T12:53:31Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>test</comment>
      <text xml:space="preserve" bytes="556">{{#if:{{{code|}}}
|&lt;div class=&quot;t-example&quot;&gt;{{example editlink|dummy}}&lt;!--
--&gt;{{#if:{{{1|}}}| &lt;p&gt;{{{1|}}}&lt;/p&gt;

}}&lt;div class=&quot;t-example-live-link&quot;&gt;{{livecodelink | 1={{{code}}} | compiler={{#ifeq: {{#pos:{{PAGENAME}}|c/|0}} | 0 | clangc | clangpp}} | text=run this code}}&lt;/div&gt;
{{source | 1={{{code|}}} | lang={{{lang|{{get lang}}}}}}}

{{#if:{{{output|}}} | {{#ifeq: {{{p|}}} | true | Possible output: | Output:}}

{{source | lang=text | 1={{{output}}}}}
}} 
&lt;/div&gt; | {{todo|reason=no example}}}}&lt;noinclude&gt;
{{documentation|Template:source/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:test rev box</title>
    <ns>10</ns>
    <id>9869</id>
    <revision>
      <id>46336</id>
      <parentid>46335</parentid>
      <timestamp>2013-02-27T01:11:42Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>test</comment>
      <text xml:space="preserve" bytes="219">{{#switch: {{{2|}}}
|untilc++11=
&lt;span class=&quot;rev-until-cpp11&quot;&gt;{{{1|}}}&lt;/span&gt;
|sincec++11=
&lt;span class=&quot;rev-since-cpp11&quot;&gt;{{{1|}}}&lt;/span&gt;
|#default=
Invalid version: {{{2|}}}
}}&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:test rev list begin</title>
    <ns>10</ns>
    <id>9861</id>
    <revision>
      <id>61433</id>
      <parentid>46402</parentid>
      <timestamp>2013-06-06T00:22:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="75">&lt;includeonly&gt; {| class=&quot;t2-rev-list&quot; &lt;/includeonly&gt;&lt;noinclude&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:test rev list end</title>
    <ns>10</ns>
    <id>9860</id>
    <revision>
      <id>61434</id>
      <parentid>46260</parentid>
      <timestamp>2013-06-06T00:22:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="26">|}&lt;noinclude&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:test rev list item</title>
    <ns>10</ns>
    <id>9859</id>
    <revision>
      <id>61435</id>
      <parentid>46401</parentid>
      <timestamp>2013-06-06T00:22:11Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>-doc</comment>
      <text xml:space="preserve" bytes="82">|- class=&quot;t2-rev-list-item&quot;
| {{{1|}}}
| {{{2|}}}
|-
&lt;noinclude&gt;
-doc
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:title</title>
    <ns>10</ns>
    <id>246</id>
    <revision>
      <id>4031</id>
      <parentid>491</parentid>
      <timestamp>2011-06-11T14:16:16Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>Protected &quot;[[Template:title]]&quot;: High traffic page ([edit=sysop] (indefinite) [move=sysop] (indefinite))</comment>
      <text xml:space="preserve" bytes="78">&lt;onlyinclude&gt;{{DISPLAYTITLE:{{{1|}}}}}&lt;!--
--&gt;&lt;/onlyinclude&gt;
{{documentation}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:title/doc</title>
    <ns>10</ns>
    <id>247</id>
    <revision>
      <id>17901</id>
      <parentid>493</parentid>
      <timestamp>2012-01-19T20:24:06Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update doc</comment>
      <text xml:space="preserve" bytes="1032">Sets the title of the page. The title can include the following formatting elements: 
{{tt|&lt;nowiki&gt;&lt;small&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;big&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;abbr&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;b&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;center&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;code&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;del&gt;&lt;/nowiki&gt;}}, 
{{tt|&lt;nowiki&gt;&lt;em&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;font&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;i&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;ins&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;s&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;strong&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;strike&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;s&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;span&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;sub&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;sup&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;u&gt;&lt;/nowiki&gt;}},
{{tt|&lt;nowiki&gt;&lt;tt&gt;&lt;/nowiki&gt;}}

{{tl | title | ''custom title''}} - general utility to set page title

{{tl | ctitle | n{{=}}''namespace'' | ''object1'' | ''object2'' ... }} - sets page title of a page that describes a library component.

If ''object1'' contains phrase {{tt|#MAGICTITLESTRING#}}, title is not altered, {{tt|n}} is returned instead.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tl</title>
    <ns>10</ns>
    <id>248</id>
    <revision>
      <id>11588</id>
      <parentid>4032</parentid>
      <timestamp>2011-10-11T19:52:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>rm excessive spacing</comment>
      <text xml:space="preserve" bytes="468">&amp;#123;&amp;#123;[[Template:{{{1}}}|{{#if:{{{1|}}}|{{{1}}}| tl&amp;#124;...}}]]&lt;!--
--&gt;{{#if:{{{2|}}}| &amp;#124;{{{2}}} | }}&lt;!--
--&gt;{{#if:{{{3|}}}| &amp;#124;{{{3}}} | }}&lt;!--
--&gt;{{#if:{{{4|}}}| &amp;#124;{{{4}}} | }}&lt;!--
--&gt;{{#if:{{{5|}}}| &amp;#124;{{{5}}} | }}&lt;!--
--&gt;{{#if:{{{6|}}}| &amp;#124;{{{6}}} | }}&lt;!--
--&gt;{{#if:{{{7|}}}| &amp;#124;{{{7}}} | }}&lt;!--
--&gt;{{#if:{{{8|}}}| &amp;#124;{{{8}}} | }}&lt;!--
--&gt;{{#if:{{{9|}}}| &amp;#124;{{{9}}} | }}&lt;!--
--&gt;&amp;#125;&amp;#125;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tl/doc</title>
    <ns>10</ns>
    <id>3408</id>
    <revision>
      <id>15466</id>
      <parentid>12844</parentid>
      <timestamp>2011-12-10T15:10:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>typo</comment>
      <text xml:space="preserve" bytes="430">This is one of the templates used to refer to templates without inlining them.

{{tl|tl|''template''|''param1''|''param2''|...}} - equivalent to {{tl|tl|''template''|''param1''|''param2''|...}}

{{tl|tlc|''template''|''param1''|''param2''|...}} - equivalent to {{tlc|tlc|''template''|''param1''|''param2''|...}} 

{{tl|tlf|''template''|''param1''|''param2''|...}} - equivalent to {{tlf|tlf|''template''|''param1''|''param2''|...}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tlc</title>
    <ns>10</ns>
    <id>249</id>
    <revision>
      <id>12841</id>
      <parentid>4029</parentid>
      <timestamp>2011-11-01T21:19:01Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>doc link</comment>
      <text xml:space="preserve" bytes="614">&lt;span style=&quot;white-space:nowrap;&quot;&gt;&lt;code&gt;&amp;#123;&amp;#123;{{#if:{{{1|}}}|{{{1}}}| tlc&amp;#124;...}}&lt;!--
--&gt;{{#ifeq:{{{2|x}}}|{{{2|}}}| &amp;#124;{{{2}}} | }}&lt;!--
--&gt;{{#ifeq:{{{3|x}}}|{{{3|}}}| &amp;#124;{{{3}}} | }}&lt;!--
--&gt;{{#ifeq:{{{4|x}}}|{{{4|}}}| &amp;#124;{{{4}}} | }}&lt;!--
--&gt;{{#ifeq:{{{5|x}}}|{{{5|}}}| &amp;#124;{{{5}}} | }}&lt;!--
--&gt;{{#ifeq:{{{6|x}}}|{{{6|}}}| &amp;#124;{{{6}}} | }}&lt;!--
--&gt;{{#ifeq:{{{7|x}}}|{{{7|}}}| &amp;#124;{{{7}}} | }}&lt;!--
--&gt;{{#ifeq:{{{8|x}}}|{{{8|}}}| &amp;#124;{{{8}}} | }}&lt;!--
--&gt;{{#ifeq:{{{9|x}}}|{{{9|}}}| &amp;#124;{{{9}}} | }}&lt;!--
--&gt;&amp;#125;&amp;#125;&lt;/code&gt;&lt;/span&gt;&lt;noinclude&gt;
{{documentation|Template:tl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tlf</title>
    <ns>10</ns>
    <id>3070</id>
    <revision>
      <id>11593</id>
      <parentid>11592</parentid>
      <timestamp>2011-10-11T20:05:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>this should've result in no link</comment>
      <text xml:space="preserve" bytes="548">&amp;#123;&amp;#123;{{#if:{{{1|}}}
| {{{1}}} | tlf&amp;#124;... }}&lt;!--
--&gt;{{#ifeq:{{{2|x}}}|{{{2|}}}| &amp;#124;{{{2}}} }}&lt;!--
--&gt;{{#ifeq:{{{3|x}}}|{{{3|}}}| &amp;#124;{{{3}}} }}&lt;!--
--&gt;{{#ifeq:{{{4|x}}}|{{{4|}}}| &amp;#124;{{{4}}} }}&lt;!--
--&gt;{{#ifeq:{{{5|x}}}|{{{5|}}}| &amp;#124;{{{5}}} }}&lt;!--
--&gt;{{#ifeq:{{{6|x}}}|{{{6|}}}| &amp;#124;{{{6}}} }}&lt;!--
--&gt;{{#ifeq:{{{7|x}}}|{{{7|}}}| &amp;#124;{{{7}}} }}&lt;!--
--&gt;{{#ifeq:{{{8|x}}}|{{{8|}}}| &amp;#124;{{{8}}} }}&lt;!--
--&gt;{{#ifeq:{{{9|x}}}|{{{9|}}}| &amp;#124;{{{9}}} }}&lt;!--
--&gt;&amp;#125;&amp;#125;&lt;noinclude&gt;
{{documentation|Template:tl/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:todo</title>
    <ns>10</ns>
    <id>250</id>
    <revision>
      <id>30655</id>
      <parentid>30629</parentid>
      <timestamp>2012-05-07T17:53:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="448">{{ambox
| type  = notice
| small = {{{small|left}}}
| text  = This section is incomplete{{#if:{{{reason|{{{1|}}}}}}|&lt;br&gt;Reason: {{{reason|{{{1}}}}}}}}
| image = none
}}&lt;includeonly&gt;{{#switch:{{{reason|{{{1|}}}}}}
|=[[Category:Todo without reason]]
|no example=[[Category:Todo no example]]
|[[Category:Todo with reason]]
}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation}}
&lt;!-- Add categories and interwikis to the /doc subpage, not here! --&gt;
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:todo/doc</title>
    <ns>10</ns>
    <id>5498</id>
    <revision>
      <id>20012</id>
      <timestamp>2012-03-19T18:29:17Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc</comment>
      <text xml:space="preserve" bytes="74">Housekeeping template to keep track of known incomplete parts of the wiki.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tr</title>
    <ns>10</ns>
    <id>9555</id>
    <revision>
      <id>41458</id>
      <parentid>41395</parentid>
      <timestamp>2012-10-27T16:17:23Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>use div due to mediawiki bug</comment>
      <text xml:space="preserve" bytes="630">&lt;div class=&quot;t-tr-text&quot;&gt;{{{1}}}&lt;div class=&quot;t-tr-dropdown&quot;&gt;&lt;div&gt;&lt;div&gt;&lt;!--
--&gt;&lt;div class=&quot;t-tr-dropdown-arrow-border&quot;&gt;&lt;/div&gt;&lt;!--
--&gt;&lt;div class=&quot;t-tr-dropdown-arrow&quot;&gt;&lt;/div&gt;&lt;!--
--&gt;&lt;div class=&quot;t-tr-dropdown-h&quot;&gt;Original:&lt;/div&gt;&lt;!--
--&gt;&lt;div class=&quot;t-tr-dropdown-orig&quot;&gt;{{{2}}}&lt;/div&gt;&lt;!--
--&gt;&lt;div class=&quot;t-tr-dropdown-notes&quot;&gt;The text has been machine-translated via [http://translate.google.com Google Translate].&lt;br/&gt; You can help to correct and verify the translation. Click [http://en.cppreference.com/w/Cppreference:MachineTranslations here] for instructions.&lt;/div&gt;&lt;!--
--&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tr/doc</title>
    <ns>10</ns>
    <id>9556</id>
    <revision>
      <id>63839</id>
      <parentid>61667</parentid>
      <timestamp>2013-07-29T14:56:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>clarify intent</comment>
      <text xml:space="preserve" bytes="778">{{tl|tr_note}}

Shows a note that the page is not completely translated. Disables search engine (such as Google) indexing of the page.

{{tl|tr|translated text | original text}}

Used for formatting automatically translated text in translations. On hover, a box containing the original text is shown.

{{tl|trd|''yyyy-mm-dd''}}

Tracks the date of the last synchronization of the translation with the English version. ''yyyy-mm-dd'' is the date of the last synchronization in the ISO-8601 format

The template outputs an invisible tag that can later be used by a bot (which is yet to be written) to find translations that need updates.

The template should be included at the end of the page. This template should not generally be included into ''dsc'' or other short templates.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tr note</title>
    <ns>10</ns>
    <id>9557</id>
    <revision>
      <id>41426</id>
      <parentid>41396</parentid>
      <timestamp>2012-10-24T14:54:55Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>grammar</comment>
      <text xml:space="preserve" bytes="456">{{fmbox
 | style=font-size:0.9em; line-height: 1em
 |text=
&lt;p&gt;This page has been machine-translated from the English version of the wiki using [http://translate.google.com Google Translate].
&lt;/p&gt;&lt;p&gt;
The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click [http://en.cppreference.com/w/Cppreference:MachineTranslations here].
&lt;/p&gt;
}}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:trd</title>
    <ns>10</ns>
    <id>12773</id>
    <revision>
      <id>61666</id>
      <parentid>61662</parentid>
      <timestamp>2013-06-08T04:28:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>just use the ISO format</comment>
      <text xml:space="preserve" bytes="149">&lt;onlyinclude&gt;&lt;span style=&quot;display:none;&quot; class=&quot;t-trd t-trd-{{{1|}}}&quot;&gt;&lt;/span&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation|Template:tr/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:trim</title>
    <ns>10</ns>
    <id>251</id>
    <revision>
      <id>4688</id>
      <parentid>4027</parentid>
      <timestamp>2011-07-01T21:28:24Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>correct doc page</comment>
      <text xml:space="preserve" bytes="124">&lt;includeonly&gt;{{ {{{|safesubst:}}}#if:1|{{{1|}}}}}&lt;/includeonly&gt;&lt;noinclude&gt;
{{documentation|Template:space/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tt</title>
    <ns>10</ns>
    <id>252</id>
    <revision>
      <id>39819</id>
      <parentid>4025</parentid>
      <timestamp>2012-09-28T17:42:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt -&gt; code</comment>
      <text xml:space="preserve" bytes="61">&lt;code&gt;{{{1|}}}&lt;/code&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:tt/doc</title>
    <ns>10</ns>
    <id>2129</id>
    <revision>
      <id>39823</id>
      <parentid>39821</parentid>
      <timestamp>2012-09-28T17:44:15Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="355">Adds formatting to the enclosed text

{{tl|tt|''text''}} - monospace font ({{tt|&amp;lt;code&gt;}} html attribute)

{{tl|ttb|''text''}} - bold monospace font ({{tt|&amp;lt;code&gt;&amp;lt;b&gt;}} html attributes)

{{tl|small|''text''}} - small font ({{tt|&amp;lt;small&gt;}} html attribute)

{{tl|smalltt|''text''}} - small monospace font ({{tt|&amp;lt;small&gt;&amp;lt;code&gt;}} html attributes)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:ttb</title>
    <ns>10</ns>
    <id>253</id>
    <revision>
      <id>39820</id>
      <parentid>4630</parentid>
      <timestamp>2012-09-28T17:43:13Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>tt -&gt; code</comment>
      <text xml:space="preserve" bytes="83">&lt;code&gt;&lt;b&gt;{{{1}}}&lt;/b&gt;&lt;/code&gt;&lt;noinclude&gt;{{documentation|Template:tt/doc}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:v</title>
    <ns>10</ns>
    <id>12928</id>
    <revision>
      <id>65002</id>
      <timestamp>2013-08-28T22:59:31Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="104">&lt;onlyinclude&gt;&lt;span class=&quot;t-v&quot;&gt;({{{1|}}})&lt;/span&gt;&lt;/onlyinclude&gt;&lt;noinclude&gt;
{{documentation}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:v/doc</title>
    <ns>10</ns>
    <id>12929</id>
    <revision>
      <id>65004</id>
      <parentid>65003</parentid>
      <timestamp>2013-08-28T23:01:58Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="241">{{tl|v|''number''}} or {{tl|v|''number'',''number''}} or {{tl|v|''number''-''number''}}

Used to refer to the items in numbered lists, e.g. to specific overload, etc. This is required in order to JavaScript-based standard-versioning to work.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:vertical</title>
    <ns>10</ns>
    <id>8709</id>
    <revision>
      <id>36774</id>
      <parentid>36773</parentid>
      <timestamp>2012-07-01T23:22:34Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="89">&lt;div class=&quot;t-vertical&quot;&gt;&lt;div&gt;{{{1|}}}&lt;/div&gt;&lt;/div&gt;&lt;noinclude&gt;{{documentation}}&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:vertical/doc</title>
    <ns>10</ns>
    <id>12606</id>
    <revision>
      <id>61291</id>
      <timestamp>2013-06-05T14:21:57Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="94">{{tl|vertical|''text''}}

Rotates the ''text'' to be read top to bottom instead left to right.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:yes</title>
    <ns>10</ns>
    <id>254</id>
    <revision>
      <id>10952</id>
      <parentid>4028</parentid>
      <timestamp>2011-09-24T10:37:50Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+doc link</comment>
      <text xml:space="preserve" bytes="251">&lt;noinclude&gt;{| class=&quot;wikitable&quot;
|-
|&lt;/noinclude&gt;style=&quot;background: #90ff90; color: black; vertical-align: middle; text-align: {{{align|center}}}; {{{style|}}}&quot; class=&quot;table-yes&quot;|{{{1|Yes}}}&lt;noinclude&gt;
|}
{{documentation|Template:yes/doc}}
&lt;/noinclude&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>Template:yes/doc</title>
    <ns>10</ns>
    <id>2915</id>
    <revision>
      <id>45552</id>
      <parentid>10954</parentid>
      <timestamp>2013-01-02T22:53:09Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>improve doc</comment>
      <text xml:space="preserve" bytes="615">This is one of the templates used to provide consistent formatting for frequently used messages in table cells.

{|  class=&quot;wikitable&quot;
|-
! Template
! Result
|-
| {{tl|yes|''message''|align{{=}}''alignment''{{mark optional}}|style{{=}}''custom_style''{{mark optional}}}}
| {{yes}}
|-
| {{tl|no|''message''|align{{=}}''alignment''{{mark optional}}|style{{=}}''custom_style''{{mark optional}}}}
| {{no}}
|-
| {{tl|n/a|''message''|align{{=}}''alignment''{{mark optional}}|style{{=}}''custom_style''{{mark optional}}}}
| {{n/a}}
|}

{{tt|message}} overrides the default text which is &quot;Yes&quot;, &quot;No&quot; and &quot;N/A&quot; respectively.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Autolinker-definition-c</title>
    <ns>8</ns>
    <id>10283</id>
    <revision>
      <id>48774</id>
      <timestamp>2013-05-31T22:20:21Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="66761">{
 &quot;groups&quot;: [
  {
   &quot;base_url&quot;: &quot;c/locale/lconv&quot;,
   &quot;name&quot;: &quot;lconv&quot;,
   &quot;urls&quot;: [
    &quot;&quot;
   ]
  },
  {
   &quot;base_url&quot;: &quot;c/string/multibyte/mbstate_t&quot;,
   &quot;name&quot;: &quot;mbstate_t&quot;,
   &quot;urls&quot;: [
    &quot;&quot;
   ]
  },
  {
   &quot;base_url&quot;: &quot;c/chrono/tm&quot;,
   &quot;name&quot;: &quot;tm&quot;,
   &quot;urls&quot;: [
    &quot;&quot;
   ]
  },
  {
   &quot;base_url&quot;: &quot;c/atomic/memory_order&quot;,
   &quot;name&quot;: &quot;memory_order&quot;,
   &quot;urls&quot;: [
    &quot;&quot;
   ]
  }
 ],
 &quot;links&quot;: [
  {
   &quot;string&quot;: &quot;size_t&quot;,
   &quot;target&quot;: &quot;cpp/types/size_t&quot;
  },
  {
   &quot;string&quot;: &quot;ptrdiff_t&quot;,
   &quot;target&quot;: &quot;cpp/types/ptrdiff_t&quot;
  },
  {
   &quot;string&quot;: &quot;nullptr_t&quot;,
   &quot;target&quot;: &quot;cpp/types/nullptr_t&quot;
  },
  {
   &quot;string&quot;: &quot;NULL&quot;,
   &quot;target&quot;: &quot;cpp/types/NULL&quot;
  },
  {
   &quot;string&quot;: &quot;max_align_t&quot;,
   &quot;target&quot;: &quot;cpp/types/max_align_t&quot;
  },
  {
   &quot;string&quot;: &quot;offsetof&quot;,
   &quot;target&quot;: &quot;cpp/types/offsetof&quot;
  },
  {
   &quot;string&quot;: &quot;int8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_fast8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_fast16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_fast32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_fast64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_least8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_least16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_least32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;int_least64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;intmax_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;intptr_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_fast8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_fast16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_fast32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_fast64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_least8_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_least16_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_least32_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uint_least64_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uintmax_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;uintptr_t&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT8_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT16_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT32_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT64_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST8_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST16_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST32_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST64_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST8_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST16_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST32_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST64_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INTPTR_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INTMAX_MIN&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_FAST64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INT_LEAST64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INTPTR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;INTMAX_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_FAST8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_FAST16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_FAST32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_FAST64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_LEAST8_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_LEAST16_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_LEAST32_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_LEAST64_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINTPTR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;UINTMAX_MAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRId8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRId16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRId32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRId64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIdPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIi8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIi16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIi32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIi64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIiPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIu8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIu16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIu32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIu64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIuPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIo8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIo16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIo32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIo64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIoPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIx8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIx16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIx32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIx64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIxPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIX8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIX16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIX32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIX64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PRIXPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNd8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNd16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNd32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNd64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNdPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNi8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNi16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNi32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNi64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNiPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNu8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNu16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNu32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNu64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNuPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNo8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNo16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNo32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNo64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNoPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNx8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNx16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNx32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNx64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNxPTR &quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNX8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNX16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNX32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNX64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXLEAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXLEAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXLEAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXLEAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXFAST8&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXFAST16&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXFAST32&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXFAST64&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXMAX&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;SCNXPTR&quot;,
   &quot;target&quot;: &quot;c/types/integer&quot;
  },
  {
   &quot;string&quot;: &quot;PTRDIFF_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;PTRDIFF_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SIZE_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SIG_ATOMIC_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SIG_ATOMIC_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;WCHAR_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;WCHAR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;WINT_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;WINT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;CHAR_BIT&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;MB_LEN_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;CHAR_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;CHAR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SCHAR_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SHRT_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;INT_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LONG_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LLONG_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SCHAR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;SHRT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;INT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LONG_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LLONG_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;UCHAR_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;USHRT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;UINT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;ULONG_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;ULLONG_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_RADIX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DECIMAL_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MIN&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MAX&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_EPSILON&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_EPSILON&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_EPSILON&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MANT_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MANT_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MANT_DIG&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MIN_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MIN_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MIN_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MIN_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MIN_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MIN_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MAX_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MAX_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MAX_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_MAX_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;DBL_MAX_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;LDBL_MAX_10_EXP&quot;,
   &quot;target&quot;: &quot;c/types/limits&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_ROUNDS&quot;,
   &quot;target&quot;: &quot;c/types/limits/FLT_ROUNDS&quot;
  },
  {
   &quot;string&quot;: &quot;FLT_EVAL_METHOD&quot;,
   &quot;target&quot;: &quot;c/types/limits/FLT_EVAL_METHOD&quot;
  },
  {
   &quot;string&quot;: &quot;malloc&quot;,
   &quot;target&quot;: &quot;c/memory/malloc&quot;
  },
  {
   &quot;string&quot;: &quot;calloc&quot;,
   &quot;target&quot;: &quot;c/memory/calloc&quot;
  },
  {
   &quot;string&quot;: &quot;realloc&quot;,
   &quot;target&quot;: &quot;c/memory/realloc&quot;
  },
  {
   &quot;string&quot;: &quot;free&quot;,
   &quot;target&quot;: &quot;c/memory/free&quot;
  },
  {
   &quot;string&quot;: &quot;assert&quot;,
   &quot;target&quot;: &quot;c/error/assert&quot;
  },
  {
   &quot;string&quot;: &quot;errno&quot;,
   &quot;target&quot;: &quot;c/error/errno&quot;
  },
  {
   &quot;string&quot;: &quot;E2BIG&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EACCESS&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EADDRINUSE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EADDRNOTAVAIL&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EAFNOSUPPORT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EAGAIN&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EALREADY&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EBADF&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EBADMSG&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EBUSY&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ECANCELED&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ECHILD&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ECONNABORTED&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ECONNREFUSED&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ECONNRESET&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EDEADLK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EDESTADDRREQ&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EDOM&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EEXIST&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EFAULT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EFBIG&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EHOSTUNREACH&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EIDRM&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EILSEQ&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EINPROGRESS&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EINTR&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EINVAL&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EIO&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EISCONN&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EISDIR&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ELOOP&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EMFILE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EMLINK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EMSGSIZE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENAMETOOLONG&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENETDOWN&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENETRESET&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENETUNREACH&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENFILE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOBUFS&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENODATA&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENODEV&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOENT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOEXEC&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOLCK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOLINK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOMEM&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOMSG&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOPROTOOPT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOSPC&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOSR&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOSTR&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOSYS&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTCONN&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTDIR&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTEMPTY&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTRECOVERABLE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTSOCK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTSUP&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENOTTY&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ENXIO&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EOPNOTSUPP&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EOVERFLOW&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EOWNERDEAD&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EPERM&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EPIPE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EPROTO&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EPROTONOSUPPORT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EPROTOTYPE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ERANGE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EROFS&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ESPIPE&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ESRCH&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ETIME&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ETIMEDOUT&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;ETXTBSY&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EWOULDBLOCK&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;EXDEV&quot;,
   &quot;target&quot;: &quot;c/error/errno_macros&quot;
  },
  {
   &quot;string&quot;: &quot;abort&quot;,
   &quot;target&quot;: &quot;c/program/abort&quot;
  },
  {
   &quot;string&quot;: &quot;exit&quot;,
   &quot;target&quot;: &quot;c/program/exit&quot;
  },
  {
   &quot;string&quot;: &quot;quick_exit&quot;,
   &quot;target&quot;: &quot;c/program/quick_exit&quot;
  },
  {
   &quot;string&quot;: &quot;_Exit&quot;,
   &quot;target&quot;: &quot;c/program/_Exit&quot;
  },
  {
   &quot;string&quot;: &quot;atexit&quot;,
   &quot;target&quot;: &quot;c/program/atexit&quot;
  },
  {
   &quot;string&quot;: &quot;at_quick_exit&quot;,
   &quot;target&quot;: &quot;c/program/at_quick_exit&quot;
  },
  {
   &quot;string&quot;: &quot;EXIT_SUCCESS&quot;,
   &quot;target&quot;: &quot;c/program/EXIT_status&quot;
  },
  {
   &quot;string&quot;: &quot;EXIT_FAILURE&quot;,
   &quot;target&quot;: &quot;c/program/EXIT_status&quot;
  },
  {
   &quot;string&quot;: &quot;system&quot;,
   &quot;target&quot;: &quot;c/program/system&quot;
  },
  {
   &quot;string&quot;: &quot;getenv&quot;,
   &quot;target&quot;: &quot;c/program/getenv&quot;
  },
  {
   &quot;string&quot;: &quot;signal&quot;,
   &quot;target&quot;: &quot;c/program/signal&quot;
  },
  {
   &quot;string&quot;: &quot;raise&quot;,
   &quot;target&quot;: &quot;c/program/raise&quot;
  },
  {
   &quot;string&quot;: &quot;sig_atomic_t&quot;,
   &quot;target&quot;: &quot;c/program/sig_atomic_t&quot;
  },
  {
   &quot;string&quot;: &quot;SIG_DFL&quot;,
   &quot;target&quot;: &quot;c/program/SIG_strategies&quot;
  },
  {
   &quot;string&quot;: &quot;SIG_IGN&quot;,
   &quot;target&quot;: &quot;c/program/SIG_strategies&quot;
  },
  {
   &quot;string&quot;: &quot;SIG_ERR&quot;,
   &quot;target&quot;: &quot;c/program/SIG_ERR&quot;
  },
  {
   &quot;string&quot;: &quot;SIGABRT&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;SIGFPE&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;SIGILL&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;SIGINT&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;SIGSEGV&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;SIGTERM&quot;,
   &quot;target&quot;: &quot;c/program/SIG_types&quot;
  },
  {
   &quot;string&quot;: &quot;longjmp&quot;,
   &quot;target&quot;: &quot;c/program/longjmp&quot;
  },
  {
   &quot;string&quot;: &quot;setjmp&quot;,
   &quot;target&quot;: &quot;c/program/setjmp&quot;
  },
  {
   &quot;string&quot;: &quot;jmp_buf&quot;,
   &quot;target&quot;: &quot;c/program/jmp_buf&quot;
  },
  {
   &quot;string&quot;: &quot;difftime&quot;,
   &quot;target&quot;: &quot;c/chrono/difftime&quot;
  },
  {
   &quot;string&quot;: &quot;time&quot;,
   &quot;target&quot;: &quot;c/chrono/time&quot;
  },
  {
   &quot;string&quot;: &quot;clock&quot;,
   &quot;target&quot;: &quot;c/chrono/clock&quot;
  },
  {
   &quot;string&quot;: &quot;asctime&quot;,
   &quot;target&quot;: &quot;c/chrono/asctime&quot;
  },
  {
   &quot;string&quot;: &quot;ctime&quot;,
   &quot;target&quot;: &quot;c/chrono/ctime&quot;
  },
  {
   &quot;string&quot;: &quot;strftime&quot;,
   &quot;target&quot;: &quot;c/chrono/strftime&quot;
  },
  {
   &quot;string&quot;: &quot;wcsftime&quot;,
   &quot;target&quot;: &quot;c/chrono/wcsftime&quot;
  },
  {
   &quot;string&quot;: &quot;gmtime&quot;,
   &quot;target&quot;: &quot;c/chrono/gmtime&quot;
  },
  {
   &quot;string&quot;: &quot;localtime&quot;,
   &quot;target&quot;: &quot;c/chrono/localtime&quot;
  },
  {
   &quot;string&quot;: &quot;mktime&quot;,
   &quot;target&quot;: &quot;c/chrono/mktime&quot;
  },
  {
   &quot;string&quot;: &quot;CLOCKS_PER_SEC&quot;,
   &quot;target&quot;: &quot;c/chrono/CLOCKS_PER_SEC&quot;
  },
  {
   &quot;string&quot;: &quot;tm&quot;,
   &quot;target&quot;: &quot;c/chrono/tm&quot;
  },
  {
   &quot;string&quot;: &quot;time_t&quot;,
   &quot;target&quot;: &quot;c/chrono/time_t&quot;
  },
  {
   &quot;string&quot;: &quot;clock_t&quot;,
   &quot;target&quot;: &quot;c/chrono/clock_t&quot;
  },
  {
   &quot;string&quot;: &quot;isalnum&quot;,
   &quot;target&quot;: &quot;c/string/byte/isalnum&quot;
  },
  {
   &quot;string&quot;: &quot;isalpha&quot;,
   &quot;target&quot;: &quot;c/string/byte/isalpha&quot;
  },
  {
   &quot;string&quot;: &quot;islower&quot;,
   &quot;target&quot;: &quot;c/string/byte/islower&quot;
  },
  {
   &quot;string&quot;: &quot;isupper&quot;,
   &quot;target&quot;: &quot;c/string/byte/isupper&quot;
  },
  {
   &quot;string&quot;: &quot;isdigit&quot;,
   &quot;target&quot;: &quot;c/string/byte/isdigit&quot;
  },
  {
   &quot;string&quot;: &quot;isxdigit&quot;,
   &quot;target&quot;: &quot;c/string/byte/isxdigit&quot;
  },
  {
   &quot;string&quot;: &quot;iscntrl&quot;,
   &quot;target&quot;: &quot;c/string/byte/iscntrl&quot;
  },
  {
   &quot;string&quot;: &quot;isgraph&quot;,
   &quot;target&quot;: &quot;c/string/byte/isgraph&quot;
  },
  {
   &quot;string&quot;: &quot;isspace&quot;,
   &quot;target&quot;: &quot;c/string/byte/isspace&quot;
  },
  {
   &quot;string&quot;: &quot;isblank&quot;,
   &quot;target&quot;: &quot;c/string/byte/isblank&quot;
  },
  {
   &quot;string&quot;: &quot;isprint&quot;,
   &quot;target&quot;: &quot;c/string/byte/isprint&quot;
  },
  {
   &quot;string&quot;: &quot;ispunct&quot;,
   &quot;target&quot;: &quot;c/string/byte/ispunct&quot;
  },
  {
   &quot;string&quot;: &quot;tolower&quot;,
   &quot;target&quot;: &quot;c/string/byte/tolower&quot;
  },
  {
   &quot;string&quot;: &quot;toupper&quot;,
   &quot;target&quot;: &quot;c/string/byte/toupper&quot;
  },
  {
   &quot;string&quot;: &quot;atof&quot;,
   &quot;target&quot;: &quot;c/string/byte/atof&quot;
  },
  {
   &quot;string&quot;: &quot;atoi&quot;,
   &quot;target&quot;: &quot;c/string/byte/atoi&quot;
  },
  {
   &quot;string&quot;: &quot;atol&quot;,
   &quot;target&quot;: &quot;c/string/byte/atoi&quot;
  },
  {
   &quot;string&quot;: &quot;atoll&quot;,
   &quot;target&quot;: &quot;c/string/byte/atoi&quot;
  },
  {
   &quot;string&quot;: &quot;strtol&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtol&quot;
  },
  {
   &quot;string&quot;: &quot;strtoll&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtol&quot;
  },
  {
   &quot;string&quot;: &quot;strtoul&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtoul&quot;
  },
  {
   &quot;string&quot;: &quot;strtoull&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtoul&quot;
  },
  {
   &quot;string&quot;: &quot;strtof&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtof&quot;
  },
  {
   &quot;string&quot;: &quot;strtod&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtof&quot;
  },
  {
   &quot;string&quot;: &quot;strtold&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtof&quot;
  },
  {
   &quot;string&quot;: &quot;strtoimax&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtoimax&quot;
  },
  {
   &quot;string&quot;: &quot;strtoumax&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtoimax&quot;
  },
  {
   &quot;string&quot;: &quot;strcpy&quot;,
   &quot;target&quot;: &quot;c/string/byte/strcpy&quot;
  },
  {
   &quot;string&quot;: &quot;strncpy&quot;,
   &quot;target&quot;: &quot;c/string/byte/strncpy&quot;
  },
  {
   &quot;string&quot;: &quot;strcat&quot;,
   &quot;target&quot;: &quot;c/string/byte/strcat&quot;
  },
  {
   &quot;string&quot;: &quot;strncat&quot;,
   &quot;target&quot;: &quot;c/string/byte/strncat&quot;
  },
  {
   &quot;string&quot;: &quot;strxfrm&quot;,
   &quot;target&quot;: &quot;c/string/byte/strxfrm&quot;
  },
  {
   &quot;string&quot;: &quot;strlen&quot;,
   &quot;target&quot;: &quot;c/string/byte/strlen&quot;
  },
  {
   &quot;string&quot;: &quot;strcmp&quot;,
   &quot;target&quot;: &quot;c/string/byte/strcmp&quot;
  },
  {
   &quot;string&quot;: &quot;strncmp&quot;,
   &quot;target&quot;: &quot;c/string/byte/strncmp&quot;
  },
  {
   &quot;string&quot;: &quot;strcoll&quot;,
   &quot;target&quot;: &quot;c/string/byte/strcoll&quot;
  },
  {
   &quot;string&quot;: &quot;strchr&quot;,
   &quot;target&quot;: &quot;c/string/byte/strchr&quot;
  },
  {
   &quot;string&quot;: &quot;strrchr&quot;,
   &quot;target&quot;: &quot;c/string/byte/strrchr&quot;
  },
  {
   &quot;string&quot;: &quot;strspn&quot;,
   &quot;target&quot;: &quot;c/string/byte/strspn&quot;
  },
  {
   &quot;string&quot;: &quot;strcspn&quot;,
   &quot;target&quot;: &quot;c/string/byte/strcspn&quot;
  },
  {
   &quot;string&quot;: &quot;strpbrk&quot;,
   &quot;target&quot;: &quot;c/string/byte/strpbrk&quot;
  },
  {
   &quot;string&quot;: &quot;strstr&quot;,
   &quot;target&quot;: &quot;c/string/byte/strstr&quot;
  },
  {
   &quot;string&quot;: &quot;strtok&quot;,
   &quot;target&quot;: &quot;c/string/byte/strtok&quot;
  },
  {
   &quot;string&quot;: &quot;memchr&quot;,
   &quot;target&quot;: &quot;c/string/byte/memchr&quot;
  },
  {
   &quot;string&quot;: &quot;memcmp&quot;,
   &quot;target&quot;: &quot;c/string/byte/memcmp&quot;
  },
  {
   &quot;string&quot;: &quot;memset&quot;,
   &quot;target&quot;: &quot;c/string/byte/memset&quot;
  },
  {
   &quot;string&quot;: &quot;memcpy&quot;,
   &quot;target&quot;: &quot;c/string/byte/memcpy&quot;
  },
  {
   &quot;string&quot;: &quot;memmove&quot;,
   &quot;target&quot;: &quot;c/string/byte/memmove&quot;
  },
  {
   &quot;string&quot;: &quot;strerror&quot;,
   &quot;target&quot;: &quot;c/string/byte/strerror&quot;
  },
  {
   &quot;string&quot;: &quot;mblen&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mblen&quot;
  },
  {
   &quot;string&quot;: &quot;mbtowc&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbtowc&quot;
  },
  {
   &quot;string&quot;: &quot;wctomb&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/wctomb&quot;
  },
  {
   &quot;string&quot;: &quot;mbstowcs&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbstowcs&quot;
  },
  {
   &quot;string&quot;: &quot;wcstombs&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/wcstombs&quot;
  },
  {
   &quot;string&quot;: &quot;mbsinit&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbsinit&quot;
  },
  {
   &quot;string&quot;: &quot;btowc&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/btowc&quot;
  },
  {
   &quot;string&quot;: &quot;wctob&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/wctob&quot;
  },
  {
   &quot;string&quot;: &quot;mbrlen&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbrlen&quot;
  },
  {
   &quot;string&quot;: &quot;mbrtowc&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbrtowc&quot;
  },
  {
   &quot;string&quot;: &quot;wcrtomb&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/wcrtomb&quot;
  },
  {
   &quot;string&quot;: &quot;mbsrtowcs&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbsrtowcs&quot;
  },
  {
   &quot;string&quot;: &quot;wcstombs&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/wcstombs&quot;
  },
  {
   &quot;string&quot;: &quot;mbrtoc16&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbrtoc16&quot;
  },
  {
   &quot;string&quot;: &quot;c16rtomb&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/c16rtomb&quot;
  },
  {
   &quot;string&quot;: &quot;mbrtoc32&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbrtoc32&quot;
  },
  {
   &quot;string&quot;: &quot;c32rtomb&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/c32rtomb&quot;
  },
  {
   &quot;string&quot;: &quot;mbstate_t&quot;,
   &quot;target&quot;: &quot;c/string/multibyte/mbstate_t&quot;
  },
  {
   &quot;string&quot;: &quot;iswalnum&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswalnum&quot;
  },
  {
   &quot;string&quot;: &quot;iswalpha&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswalpha&quot;
  },
  {
   &quot;string&quot;: &quot;iswlower&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswlower&quot;
  },
  {
   &quot;string&quot;: &quot;iswupper&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswupper&quot;
  },
  {
   &quot;string&quot;: &quot;iswdigit&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswdigit&quot;
  },
  {
   &quot;string&quot;: &quot;iswxdigit&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswxdigit&quot;
  },
  {
   &quot;string&quot;: &quot;iswcntrl&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswcntrl&quot;
  },
  {
   &quot;string&quot;: &quot;iswgraph&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswgraph&quot;
  },
  {
   &quot;string&quot;: &quot;iswspace&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswspace&quot;
  },
  {
   &quot;string&quot;: &quot;iswblank&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswblank&quot;
  },
  {
   &quot;string&quot;: &quot;iswprint&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswprint&quot;
  },
  {
   &quot;string&quot;: &quot;iswpunct&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswpunct&quot;
  },
  {
   &quot;string&quot;: &quot;iswctype&quot;,
   &quot;target&quot;: &quot;c/string/wide/iswctype&quot;
  },
  {
   &quot;string&quot;: &quot;wctype&quot;,
   &quot;target&quot;: &quot;c/string/wide/wctype&quot;
  },
  {
   &quot;string&quot;: &quot;towlower&quot;,
   &quot;target&quot;: &quot;c/string/wide/towlower&quot;
  },
  {
   &quot;string&quot;: &quot;towupper&quot;,
   &quot;target&quot;: &quot;c/string/wide/towupper&quot;
  },
  {
   &quot;string&quot;: &quot;towctrans&quot;,
   &quot;target&quot;: &quot;c/string/wide/towctrans&quot;
  },
  {
   &quot;string&quot;: &quot;wctrans&quot;,
   &quot;target&quot;: &quot;c/string/wide/wctrans&quot;
  },
  {
   &quot;string&quot;: &quot;wcstof&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstof&quot;
  },
  {
   &quot;string&quot;: &quot;wcstod&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstof&quot;
  },
  {
   &quot;string&quot;: &quot;wcstold&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstof&quot;
  },
  {
   &quot;string&quot;: &quot;wcstol&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstol&quot;
  },
  {
   &quot;string&quot;: &quot;wcstoll&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstol&quot;
  },
  {
   &quot;string&quot;: &quot;wcstoul&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstoul&quot;
  },
  {
   &quot;string&quot;: &quot;wcstoull&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstoul&quot;
  },
  {
   &quot;string&quot;: &quot;wcstoimax&quot;,
   &quot;target&quot;: &quot;c/string/byte/wcstoimax&quot;
  },
  {
   &quot;string&quot;: &quot;wcstoumax&quot;,
   &quot;target&quot;: &quot;c/string/byte/wcstoimax&quot;
  },
  {
   &quot;string&quot;: &quot;wcscpy&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcscpy&quot;
  },
  {
   &quot;string&quot;: &quot;wcsncpy&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsncpy&quot;
  },
  {
   &quot;string&quot;: &quot;wcscat&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcscat&quot;
  },
  {
   &quot;string&quot;: &quot;wcsncat&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsncat&quot;
  },
  {
   &quot;string&quot;: &quot;wcsxfrm&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsxfrm&quot;
  },
  {
   &quot;string&quot;: &quot;wcslen&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcslen&quot;
  },
  {
   &quot;string&quot;: &quot;wcscmp&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcscmp&quot;
  },
  {
   &quot;string&quot;: &quot;wcsncmp&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsncmp&quot;
  },
  {
   &quot;string&quot;: &quot;wcscoll&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcscoll&quot;
  },
  {
   &quot;string&quot;: &quot;wcschr&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcschr&quot;
  },
  {
   &quot;string&quot;: &quot;wcsrchr&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsrchr&quot;
  },
  {
   &quot;string&quot;: &quot;wcsspn&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsspn&quot;
  },
  {
   &quot;string&quot;: &quot;wcscspn&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcscspn&quot;
  },
  {
   &quot;string&quot;: &quot;wcspbrk&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcspbrk&quot;
  },
  {
   &quot;string&quot;: &quot;wcsstr&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcsstr&quot;
  },
  {
   &quot;string&quot;: &quot;wcstok&quot;,
   &quot;target&quot;: &quot;c/string/wide/wcstok&quot;
  },
  {
   &quot;string&quot;: &quot;wmemchr&quot;,
   &quot;target&quot;: &quot;c/string/wide/wmemchr&quot;
  },
  {
   &quot;string&quot;: &quot;wmemcmp&quot;,
   &quot;target&quot;: &quot;c/string/wide/wmemcmp&quot;
  },
  {
   &quot;string&quot;: &quot;wmemset&quot;,
   &quot;target&quot;: &quot;c/string/wide/wmemset&quot;
  },
  {
   &quot;string&quot;: &quot;wmemcpy&quot;,
   &quot;target&quot;: &quot;c/string/wide/wmemcpy&quot;
  },
  {
   &quot;string&quot;: &quot;wmemmove&quot;,
   &quot;target&quot;: &quot;c/string/wide/wmemmove&quot;
  },
  {
   &quot;string&quot;: &quot;abs&quot;,
   &quot;target&quot;: &quot;c/numeric/math/abs&quot;
  },
  {
   &quot;string&quot;: &quot;labs&quot;,
   &quot;target&quot;: &quot;c/numeric/math/abs&quot;
  },
  {
   &quot;string&quot;: &quot;llabs&quot;,
   &quot;target&quot;: &quot;c/numeric/math/abs&quot;
  },
  {
   &quot;string&quot;: &quot;fabs&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fabs&quot;
  },
  {
   &quot;string&quot;: &quot;div&quot;,
   &quot;target&quot;: &quot;c/numeric/math/div&quot;
  },
  {
   &quot;string&quot;: &quot;ldiv&quot;,
   &quot;target&quot;: &quot;c/numeric/math/div&quot;
  },
  {
   &quot;string&quot;: &quot;fmod&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fmod&quot;
  },
  {
   &quot;string&quot;: &quot;remainder&quot;,
   &quot;target&quot;: &quot;c/numeric/math/remainder&quot;
  },
  {
   &quot;string&quot;: &quot;remquo&quot;,
   &quot;target&quot;: &quot;c/numeric/math/remquo&quot;
  },
  {
   &quot;string&quot;: &quot;fma&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fma&quot;
  },
  {
   &quot;string&quot;: &quot;fmax&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fmax&quot;
  },
  {
   &quot;string&quot;: &quot;fmin&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fmin&quot;
  },
  {
   &quot;string&quot;: &quot;fdim&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fdim&quot;
  },
  {
   &quot;string&quot;: &quot;nan&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nan&quot;
  },
  {
   &quot;string&quot;: &quot;nanf&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nan&quot;
  },
  {
   &quot;string&quot;: &quot;nanl&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nan&quot;
  },
  {
   &quot;string&quot;: &quot;exp&quot;,
   &quot;target&quot;: &quot;c/numeric/math/exp&quot;
  },
  {
   &quot;string&quot;: &quot;exp2&quot;,
   &quot;target&quot;: &quot;c/numeric/math/exp2&quot;
  },
  {
   &quot;string&quot;: &quot;expm1&quot;,
   &quot;target&quot;: &quot;c/numeric/math/expm1&quot;
  },
  {
   &quot;string&quot;: &quot;log&quot;,
   &quot;target&quot;: &quot;c/numeric/math/log&quot;
  },
  {
   &quot;string&quot;: &quot;log10&quot;,
   &quot;target&quot;: &quot;c/numeric/math/log10&quot;
  },
  {
   &quot;string&quot;: &quot;log1p&quot;,
   &quot;target&quot;: &quot;c/numeric/math/log1p&quot;
  },
  {
   &quot;string&quot;: &quot;ilogb&quot;,
   &quot;target&quot;: &quot;c/numeric/math/ilogb&quot;
  },
  {
   &quot;string&quot;: &quot;logb&quot;,
   &quot;target&quot;: &quot;c/numeric/math/logb&quot;
  },
  {
   &quot;string&quot;: &quot;sqrt&quot;,
   &quot;target&quot;: &quot;c/numeric/math/sqrt&quot;
  },
  {
   &quot;string&quot;: &quot;cbrt&quot;,
   &quot;target&quot;: &quot;c/numeric/math/cbrt&quot;
  },
  {
   &quot;string&quot;: &quot;hypot&quot;,
   &quot;target&quot;: &quot;c/numeric/math/hypot&quot;
  },
  {
   &quot;string&quot;: &quot;pow&quot;,
   &quot;target&quot;: &quot;c/numeric/math/pow&quot;
  },
  {
   &quot;string&quot;: &quot;sin&quot;,
   &quot;target&quot;: &quot;c/numeric/math/sin&quot;
  },
  {
   &quot;string&quot;: &quot;cos&quot;,
   &quot;target&quot;: &quot;c/numeric/math/cos&quot;
  },
  {
   &quot;string&quot;: &quot;tan&quot;,
   &quot;target&quot;: &quot;c/numeric/math/tan&quot;
  },
  {
   &quot;string&quot;: &quot;asin&quot;,
   &quot;target&quot;: &quot;c/numeric/math/asin&quot;
  },
  {
   &quot;string&quot;: &quot;acos&quot;,
   &quot;target&quot;: &quot;c/numeric/math/acos&quot;
  },
  {
   &quot;string&quot;: &quot;atan&quot;,
   &quot;target&quot;: &quot;c/numeric/math/atan&quot;
  },
  {
   &quot;string&quot;: &quot;atan2&quot;,
   &quot;target&quot;: &quot;c/numeric/math/atan2&quot;
  },
  {
   &quot;string&quot;: &quot;sinh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/sinh&quot;
  },
  {
   &quot;string&quot;: &quot;cosh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/cosh&quot;
  },
  {
   &quot;string&quot;: &quot;tanh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/tanh&quot;
  },
  {
   &quot;string&quot;: &quot;asinh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/asinh&quot;
  },
  {
   &quot;string&quot;: &quot;acosh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/acosh&quot;
  },
  {
   &quot;string&quot;: &quot;atanh&quot;,
   &quot;target&quot;: &quot;c/numeric/math/atanh&quot;
  },
  {
   &quot;string&quot;: &quot;erf&quot;,
   &quot;target&quot;: &quot;c/numeric/math/erf&quot;
  },
  {
   &quot;string&quot;: &quot;erfc&quot;,
   &quot;target&quot;: &quot;c/numeric/math/erfc&quot;
  },
  {
   &quot;string&quot;: &quot;lgamma&quot;,
   &quot;target&quot;: &quot;c/numeric/math/lgamma&quot;
  },
  {
   &quot;string&quot;: &quot;tgamma&quot;,
   &quot;target&quot;: &quot;c/numeric/math/tgamma&quot;
  },
  {
   &quot;string&quot;: &quot;ceil&quot;,
   &quot;target&quot;: &quot;c/numeric/math/ceil&quot;
  },
  {
   &quot;string&quot;: &quot;floor&quot;,
   &quot;target&quot;: &quot;c/numeric/math/floor&quot;
  },
  {
   &quot;string&quot;: &quot;trunc&quot;,
   &quot;target&quot;: &quot;c/numeric/math/trunc&quot;
  },
  {
   &quot;string&quot;: &quot;round&quot;,
   &quot;target&quot;: &quot;c/numeric/math/round&quot;
  },
  {
   &quot;string&quot;: &quot;lround&quot;,
   &quot;target&quot;: &quot;c/numeric/math/round&quot;
  },
  {
   &quot;string&quot;: &quot;llround&quot;,
   &quot;target&quot;: &quot;c/numeric/math/round&quot;
  },
  {
   &quot;string&quot;: &quot;nearbyint&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nearbyint&quot;
  },
  {
   &quot;string&quot;: &quot;rint&quot;,
   &quot;target&quot;: &quot;c/numeric/math/rint&quot;
  },
  {
   &quot;string&quot;: &quot;lrint&quot;,
   &quot;target&quot;: &quot;c/numeric/math/rint&quot;
  },
  {
   &quot;string&quot;: &quot;llrint&quot;,
   &quot;target&quot;: &quot;c/numeric/math/rint&quot;
  },
  {
   &quot;string&quot;: &quot;frexp&quot;,
   &quot;target&quot;: &quot;c/numeric/math/frexp&quot;
  },
  {
   &quot;string&quot;: &quot;ldexp&quot;,
   &quot;target&quot;: &quot;c/numeric/math/ldexp&quot;
  },
  {
   &quot;string&quot;: &quot;modf&quot;,
   &quot;target&quot;: &quot;c/numeric/math/modf&quot;
  },
  {
   &quot;string&quot;: &quot;scalbn&quot;,
   &quot;target&quot;: &quot;c/numeric/math/scalbn&quot;
  },
  {
   &quot;string&quot;: &quot;scalbln&quot;,
   &quot;target&quot;: &quot;c/numeric/math/scalbn&quot;
  },
  {
   &quot;string&quot;: &quot;nextafter&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nextafter&quot;
  },
  {
   &quot;string&quot;: &quot;nexttoward&quot;,
   &quot;target&quot;: &quot;c/numeric/math/nextafter&quot;
  },
  {
   &quot;string&quot;: &quot;copysign&quot;,
   &quot;target&quot;: &quot;c/numeric/math/copysign&quot;
  },
  {
   &quot;string&quot;: &quot;fpclassify&quot;,
   &quot;target&quot;: &quot;c/numeric/math/fpclassify&quot;
  },
  {
   &quot;string&quot;: &quot;isfinite&quot;,
   &quot;target&quot;: &quot;c/numeric/math/isfinite&quot;
  },
  {
   &quot;string&quot;: &quot;isinf&quot;,
   &quot;target&quot;: &quot;c/numeric/math/isinf&quot;
  },
  {
   &quot;string&quot;: &quot;isnan&quot;,
   &quot;target&quot;: &quot;c/numeric/math/isnan&quot;
  },
  {
   &quot;string&quot;: &quot;isnormal&quot;,
   &quot;target&quot;: &quot;c/numeric/math/isnormal&quot;
  },
  {
   &quot;string&quot;: &quot;signbit&quot;,
   &quot;target&quot;: &quot;c/numeric/math/signbit&quot;
  },
  {
   &quot;string&quot;: &quot;HUGE_VAL&quot;,
   &quot;target&quot;: &quot;c/numeric/math/HUGE_VAL&quot;
  },
  {
   &quot;string&quot;: &quot;HUGE_VALF&quot;,
   &quot;target&quot;: &quot;c/numeric/math/HUGE_VAL&quot;
  },
  {
   &quot;string&quot;: &quot;HUGE_VALL&quot;,
   &quot;target&quot;: &quot;c/numeric/math/HUGE_VAL&quot;
  },
  {
   &quot;string&quot;: &quot;FP_INFINITE&quot;,
   &quot;target&quot;: &quot;c/numeric/math/FP_categories&quot;
  },
  {
   &quot;string&quot;: &quot;FP_NAN&quot;,
   &quot;target&quot;: &quot;c/numeric/math/FP_categories&quot;
  },
  {
   &quot;string&quot;: &quot;FP_NORMAL&quot;,
   &quot;target&quot;: &quot;c/numeric/math/FP_categories&quot;
  },
  {
   &quot;string&quot;: &quot;FP_SUBNORMAL&quot;,
   &quot;target&quot;: &quot;c/numeric/math/FP_categories&quot;
  },
  {
   &quot;string&quot;: &quot;FP_ZERO&quot;,
   &quot;target&quot;: &quot;c/numeric/math/FP_categories&quot;
  },
  {
   &quot;string&quot;: &quot;feclearexcept&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feclearexcept&quot;
  },
  {
   &quot;string&quot;: &quot;fetestexcept&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/fetestexcept&quot;
  },
  {
   &quot;string&quot;: &quot;feraiseexcept&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feraiseexcept&quot;
  },
  {
   &quot;string&quot;: &quot;fegetexceptflag&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feexceptflag&quot;
  },
  {
   &quot;string&quot;: &quot;fesetexceptflag&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feexceptflag&quot;
  },
  {
   &quot;string&quot;: &quot;fegetround&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feround&quot;
  },
  {
   &quot;string&quot;: &quot;fesetround&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feround&quot;
  },
  {
   &quot;string&quot;: &quot;fegetenv&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feenv&quot;
  },
  {
   &quot;string&quot;: &quot;fesetenv&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feenv&quot;
  },
  {
   &quot;string&quot;: &quot;feholdexcept&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feholdexcept&quot;
  },
  {
   &quot;string&quot;: &quot;feupdateenv&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/feupdateenv&quot;
  },
  {
   &quot;string&quot;: &quot;FE_ALL_EXCEPT&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_DIVBYZERO&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_INEXACT&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_INVALID&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_OVERFLOW&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_UNHERFLOW&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_exceptions&quot;
  },
  {
   &quot;string&quot;: &quot;FE_DOWNWARD&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_round&quot;
  },
  {
   &quot;string&quot;: &quot;FE_TONEAREST&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_round&quot;
  },
  {
   &quot;string&quot;: &quot;FE_TOWARDZERO&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_round&quot;
  },
  {
   &quot;string&quot;: &quot;FE_UPWARD&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_round&quot;
  },
  {
   &quot;string&quot;: &quot;FE_DFL_ENV&quot;,
   &quot;target&quot;: &quot;c/numeric/fenv/FE_DFL_ENV&quot;
  },
  {
   &quot;string&quot;: &quot;srand&quot;,
   &quot;target&quot;: &quot;c/numeric/random/srand&quot;
  },
  {
   &quot;string&quot;: &quot;rand&quot;,
   &quot;target&quot;: &quot;c/numeric/random/rand&quot;
  },
  {
   &quot;string&quot;: &quot;RAND_MAX&quot;,
   &quot;target&quot;: &quot;c/numeric/random/RAND_MAX&quot;
  },
  {
   &quot;string&quot;: &quot;complex&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/complex&quot;
  },
  {
   &quot;string&quot;: &quot;Complex_I&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/Complex_I&quot;
  },
  {
   &quot;string&quot;: &quot;imaginary&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/imaginary&quot;
  },
  {
   &quot;string&quot;: &quot;Imaginary_I&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/Imaginary_I&quot;
  },
  {
   &quot;string&quot;: &quot;I&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/I&quot;
  },
  {
   &quot;string&quot;: &quot;CMPLX&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/CMPLX&quot;
  },
  {
   &quot;string&quot;: &quot;CMPLXF&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/CMPLX&quot;
  },
  {
   &quot;string&quot;: &quot;CMPLXL&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/CMPLX&quot;
  },
  {
   &quot;string&quot;: &quot;cimag&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cimag&quot;
  },
  {
   &quot;string&quot;: &quot;cimagf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cimag&quot;
  },
  {
   &quot;string&quot;: &quot;cimagl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cimag&quot;
  },
  {
   &quot;string&quot;: &quot;creal&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/creal&quot;
  },
  {
   &quot;string&quot;: &quot;crealf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/creal&quot;
  },
  {
   &quot;string&quot;: &quot;creall&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/creal&quot;
  },
  {
   &quot;string&quot;: &quot;carg&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/carg&quot;
  },
  {
   &quot;string&quot;: &quot;cargf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/carg&quot;
  },
  {
   &quot;string&quot;: &quot;cargl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/carg&quot;
  },
  {
   &quot;string&quot;: &quot;conj&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/conj&quot;
  },
  {
   &quot;string&quot;: &quot;conjf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/conj&quot;
  },
  {
   &quot;string&quot;: &quot;conjl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/conj&quot;
  },
  {
   &quot;string&quot;: &quot;cproj&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cproj&quot;
  },
  {
   &quot;string&quot;: &quot;cprojf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cproj&quot;
  },
  {
   &quot;string&quot;: &quot;cprojl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cproj&quot;
  },
  {
   &quot;string&quot;: &quot;cabs&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cabs&quot;
  },
  {
   &quot;string&quot;: &quot;cabsf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cabs&quot;
  },
  {
   &quot;string&quot;: &quot;cabsl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cabs&quot;
  },
  {
   &quot;string&quot;: &quot;cexp&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cexp&quot;
  },
  {
   &quot;string&quot;: &quot;cexpf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cexp&quot;
  },
  {
   &quot;string&quot;: &quot;cexpl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cexp&quot;
  },
  {
   &quot;string&quot;: &quot;clog&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/clog&quot;
  },
  {
   &quot;string&quot;: &quot;clogf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/clog&quot;
  },
  {
   &quot;string&quot;: &quot;clogl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/clog&quot;
  },
  {
   &quot;string&quot;: &quot;cpow&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cpow&quot;
  },
  {
   &quot;string&quot;: &quot;cpowf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cpow&quot;
  },
  {
   &quot;string&quot;: &quot;cpowl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cpow&quot;
  },
  {
   &quot;string&quot;: &quot;csqrt&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csqrt&quot;
  },
  {
   &quot;string&quot;: &quot;csqrtf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csqrt&quot;
  },
  {
   &quot;string&quot;: &quot;csqrtl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csqrt&quot;
  },
  {
   &quot;string&quot;: &quot;cacos&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacos&quot;
  },
  {
   &quot;string&quot;: &quot;cacosf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacos&quot;
  },
  {
   &quot;string&quot;: &quot;cacosl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacos&quot;
  },
  {
   &quot;string&quot;: &quot;casin&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casin&quot;
  },
  {
   &quot;string&quot;: &quot;casinf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casin&quot;
  },
  {
   &quot;string&quot;: &quot;casinl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casin&quot;
  },
  {
   &quot;string&quot;: &quot;catan&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catan&quot;
  },
  {
   &quot;string&quot;: &quot;catanf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catan&quot;
  },
  {
   &quot;string&quot;: &quot;catanl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catan&quot;
  },
  {
   &quot;string&quot;: &quot;ccos&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccos&quot;
  },
  {
   &quot;string&quot;: &quot;ccosf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccos&quot;
  },
  {
   &quot;string&quot;: &quot;ccosl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccos&quot;
  },
  {
   &quot;string&quot;: &quot;csin&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csin&quot;
  },
  {
   &quot;string&quot;: &quot;csinf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csin&quot;
  },
  {
   &quot;string&quot;: &quot;csinl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csin&quot;
  },
  {
   &quot;string&quot;: &quot;ctan&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctan&quot;
  },
  {
   &quot;string&quot;: &quot;ctanf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctan&quot;
  },
  {
   &quot;string&quot;: &quot;ctanl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctan&quot;
  },
  {
   &quot;string&quot;: &quot;cacosh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacosh&quot;
  },
  {
   &quot;string&quot;: &quot;cacoshf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacosh&quot;
  },
  {
   &quot;string&quot;: &quot;cacoshl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/cacosh&quot;
  },
  {
   &quot;string&quot;: &quot;casinh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casinh&quot;
  },
  {
   &quot;string&quot;: &quot;casinhf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casinh&quot;
  },
  {
   &quot;string&quot;: &quot;casinhl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/casinh&quot;
  },
  {
   &quot;string&quot;: &quot;catanh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catanh&quot;
  },
  {
   &quot;string&quot;: &quot;catanhf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catanh&quot;
  },
  {
   &quot;string&quot;: &quot;catanhl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/catanh&quot;
  },
  {
   &quot;string&quot;: &quot;ccosh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccosh&quot;
  },
  {
   &quot;string&quot;: &quot;ccoshf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccosh&quot;
  },
  {
   &quot;string&quot;: &quot;ccoshl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ccosh&quot;
  },
  {
   &quot;string&quot;: &quot;csinh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csinh&quot;
  },
  {
   &quot;string&quot;: &quot;csinhf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csinh&quot;
  },
  {
   &quot;string&quot;: &quot;csinhl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/csinh&quot;
  },
  {
   &quot;string&quot;: &quot;ctanh&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctanh&quot;
  },
  {
   &quot;string&quot;: &quot;ctanhf&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctanh&quot;
  },
  {
   &quot;string&quot;: &quot;ctanhl&quot;,
   &quot;target&quot;: &quot;c/numeric/complex/ctanh&quot;
  },
  {
   &quot;string&quot;: &quot;qsort&quot;,
   &quot;target&quot;: &quot;c/algorithm/qsort&quot;
  },
  {
   &quot;string&quot;: &quot;bsearch&quot;,
   &quot;target&quot;: &quot;c/algorithm/bsearch&quot;
  },
  {
   &quot;string&quot;: &quot;fopen&quot;,
   &quot;target&quot;: &quot;c/io/fopen&quot;
  },
  {
   &quot;string&quot;: &quot;freopen&quot;,
   &quot;target&quot;: &quot;c/io/freopen&quot;
  },
  {
   &quot;string&quot;: &quot;fflush&quot;,
   &quot;target&quot;: &quot;c/io/fflush&quot;
  },
  {
   &quot;string&quot;: &quot;fclose&quot;,
   &quot;target&quot;: &quot;c/io/fclose&quot;
  },
  {
   &quot;string&quot;: &quot;setbuf&quot;,
   &quot;target&quot;: &quot;c/io/setbuf&quot;
  },
  {
   &quot;string&quot;: &quot;setvbuf&quot;,
   &quot;target&quot;: &quot;c/io/setvbuf&quot;
  },
  {
   &quot;string&quot;: &quot;fread&quot;,
   &quot;target&quot;: &quot;c/io/fread&quot;
  },
  {
   &quot;string&quot;: &quot;fwrite&quot;,
   &quot;target&quot;: &quot;c/io/fwrite&quot;
  },
  {
   &quot;string&quot;: &quot;fgetc&quot;,
   &quot;target&quot;: &quot;c/io/fgetc&quot;
  },
  {
   &quot;string&quot;: &quot;getc&quot;,
   &quot;target&quot;: &quot;c/io/fgetc&quot;
  },
  {
   &quot;string&quot;: &quot;fgets&quot;,
   &quot;target&quot;: &quot;c/io/fgets&quot;
  },
  {
   &quot;string&quot;: &quot;fputc&quot;,
   &quot;target&quot;: &quot;c/io/fputc&quot;
  },
  {
   &quot;string&quot;: &quot;putc&quot;,
   &quot;target&quot;: &quot;c/io/fputc&quot;
  },
  {
   &quot;string&quot;: &quot;fputs&quot;,
   &quot;target&quot;: &quot;c/io/fputs&quot;
  },
  {
   &quot;string&quot;: &quot;getchar&quot;,
   &quot;target&quot;: &quot;c/io/getchar&quot;
  },
  {
   &quot;string&quot;: &quot;gets&quot;,
   &quot;target&quot;: &quot;c/io/gets&quot;
  },
  {
   &quot;string&quot;: &quot;putchar&quot;,
   &quot;target&quot;: &quot;c/io/putchar&quot;
  },
  {
   &quot;string&quot;: &quot;puts&quot;,
   &quot;target&quot;: &quot;c/io/puts&quot;
  },
  {
   &quot;string&quot;: &quot;ungetc&quot;,
   &quot;target&quot;: &quot;c/io/ungetc&quot;
  },
  {
   &quot;string&quot;: &quot;fgetwc&quot;,
   &quot;target&quot;: &quot;c/io/fgetwc&quot;
  },
  {
   &quot;string&quot;: &quot;fgetss&quot;,
   &quot;target&quot;: &quot;c/io/fgetws&quot;
  },
  {
   &quot;string&quot;: &quot;fputwc&quot;,
   &quot;target&quot;: &quot;c/io/fputwc&quot;
  },
  {
   &quot;string&quot;: &quot;fputws&quot;,
   &quot;target&quot;: &quot;c/io/fputws&quot;
  },
  {
   &quot;string&quot;: &quot;getwchar&quot;,
   &quot;target&quot;: &quot;c/io/getwchar&quot;
  },
  {
   &quot;string&quot;: &quot;putwchar&quot;,
   &quot;target&quot;: &quot;c/io/putwchar&quot;
  },
  {
   &quot;string&quot;: &quot;ungetwc&quot;,
   &quot;target&quot;: &quot;c/io/ungetwc&quot;
  },
  {
   &quot;string&quot;: &quot;scanf&quot;,
   &quot;target&quot;: &quot;c/io/fscanf&quot;
  },
  {
   &quot;string&quot;: &quot;fscanf&quot;,
   &quot;target&quot;: &quot;c/io/fscanf&quot;
  },
  {
   &quot;string&quot;: &quot;sscanf&quot;,
   &quot;target&quot;: &quot;c/io/fscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vfscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vsscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfscanf&quot;
  },
  {
   &quot;string&quot;: &quot;printf&quot;,
   &quot;target&quot;: &quot;c/io/fprintf&quot;
  },
  {
   &quot;string&quot;: &quot;fprintf&quot;,
   &quot;target&quot;: &quot;c/io/fprintf&quot;
  },
  {
   &quot;string&quot;: &quot;sprintf&quot;,
   &quot;target&quot;: &quot;c/io/fprintf&quot;
  },
  {
   &quot;string&quot;: &quot;snprintf&quot;,
   &quot;target&quot;: &quot;c/io/fprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vfprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vsprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vsnprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfprintf&quot;
  },
  {
   &quot;string&quot;: &quot;wscanf&quot;,
   &quot;target&quot;: &quot;c/io/fwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;fwscanf&quot;,
   &quot;target&quot;: &quot;c/io/fwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;swscanf&quot;,
   &quot;target&quot;: &quot;c/io/fwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vwscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vfwscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;vswscanf&quot;,
   &quot;target&quot;: &quot;c/io/vfwscanf&quot;
  },
  {
   &quot;string&quot;: &quot;wprintf&quot;,
   &quot;target&quot;: &quot;c/io/fwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;fwprintf&quot;,
   &quot;target&quot;: &quot;c/io/fwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;swprintf&quot;,
   &quot;target&quot;: &quot;c/io/fwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vwprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vfwprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;vswprintf&quot;,
   &quot;target&quot;: &quot;c/io/vfwprintf&quot;
  },
  {
   &quot;string&quot;: &quot;ftell&quot;,
   &quot;target&quot;: &quot;c/io/ftell&quot;
  },
  {
   &quot;string&quot;: &quot;fgetpos&quot;,
   &quot;target&quot;: &quot;c/io/fgetpos&quot;
  },
  {
   &quot;string&quot;: &quot;fseek&quot;,
   &quot;target&quot;: &quot;c/io/fseek&quot;
  },
  {
   &quot;string&quot;: &quot;fsetpos&quot;,
   &quot;target&quot;: &quot;c/io/fsetpos&quot;
  },
  {
   &quot;string&quot;: &quot;rewind&quot;,
   &quot;target&quot;: &quot;c/io/rewind&quot;
  },
  {
   &quot;string&quot;: &quot;clearerr&quot;,
   &quot;target&quot;: &quot;c/io/clearerr&quot;
  },
  {
   &quot;string&quot;: &quot;feof&quot;,
   &quot;target&quot;: &quot;c/io/feof&quot;
  },
  {
   &quot;string&quot;: &quot;ferror&quot;,
   &quot;target&quot;: &quot;c/io/ferror&quot;
  },
  {
   &quot;string&quot;: &quot;perror&quot;,
   &quot;target&quot;: &quot;c/io/perror&quot;
  },
  {
   &quot;string&quot;: &quot;remove&quot;,
   &quot;target&quot;: &quot;c/io/remove&quot;
  },
  {
   &quot;string&quot;: &quot;rename&quot;,
   &quot;target&quot;: &quot;c/io/rename&quot;
  },
  {
   &quot;string&quot;: &quot;tmpfile&quot;,
   &quot;target&quot;: &quot;c/io/tmpfile&quot;
  },
  {
   &quot;string&quot;: &quot;tmpnam&quot;,
   &quot;target&quot;: &quot;c/io/tmpnam&quot;
  },
  {
   &quot;string&quot;: &quot;FILE&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;fpos_t&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;stdin&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;stdout&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;stderr&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;EOF&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;FOPEN_MAX&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;FILENAME_MAX&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;BUFSIZ&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;_IOFBF&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;_IOLBF&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;_IONBF&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;SEEK_SET&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;SEEK_CUR&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;SEEK_END&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;TMP_MAX&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;L_tmpnam&quot;,
   &quot;target&quot;: &quot;c/io&quot;
  },
  {
   &quot;string&quot;: &quot;setlocale&quot;,
   &quot;target&quot;: &quot;c/locale/setlocale&quot;
  },
  {
   &quot;string&quot;: &quot;localeconv&quot;,
   &quot;target&quot;: &quot;c/locale/localeconv&quot;
  },
  {
   &quot;string&quot;: &quot;lconv&quot;,
   &quot;target&quot;: &quot;c/locale/lconv&quot;
  },
  {
   &quot;string&quot;: &quot;LC_ALL&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;LC_COLLATE&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;LC_CTYPE&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;LC_MONETARY&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;LC_NUMERIC&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;LC_TIME&quot;,
   &quot;target&quot;: &quot;c/locale/LC_categories&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_relaxed&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_consume&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_acquire&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_release&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_acq_rel&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;memory_order_seq_cst&quot;,
   &quot;target&quot;: &quot;c/atomic/memory_order&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_flag&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_flag&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_BOOL_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_CHAR_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_CHAR16_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_CHAR32_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_WCHAR_T_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_SHORT_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_INT_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_LONG_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_LLONG_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_POINTER_LOCK_FREE&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_LOCK_FREE_consts&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_FLAG_INIT&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_FLAG_INIT&quot;
  },
  {
   &quot;string&quot;: &quot;ATOMIC_VAR_INIT&quot;,
   &quot;target&quot;: &quot;c/atomic/ATOMIC_VAR_INIT&quot;
  },
  {
   &quot;string&quot;: &quot;kill_dependency&quot;,
   &quot;target&quot;: &quot;c/atomic/kill_dependency&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_load_test_and_set&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_load_test_and_set&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_load_test_and_set_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_load_test_and_set&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_flag_clear&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_flag_clear&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_flag_clear_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_flag_clear&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_init&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_init&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_is_lock_free&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_is_lock_free&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_store&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_store&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_store_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_store&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_load&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_load&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_load_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_load&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_exchange&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_exchange_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_compare_exchange_weak&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_compare_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_compare_exchange_weak_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_compare_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_compare_exchange_strong&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_compare_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_compare_exchange_strong_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_compare_exchange&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_add&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_add&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_add_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_add&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_sub&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_sub&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_sub_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_sub&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_or&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_or&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_or_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_or&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_xor&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_xor&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_xor_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_xor&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_and&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_and&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_fetch_and_explicit&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_fetch_and&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_thread_fence&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_thread_fence&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_signal_fence&quot;,
   &quot;target&quot;: &quot;c/atomic/atomic_signal_fence&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_bool&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_char&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_schar&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uchar&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_short&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_ushort&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_long&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_ulong&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_llong&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_ullong&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_char16_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_char32_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_wchar_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_least8_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_least8_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_least16_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_least16_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_least32_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_least32_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_least64_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_least64_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_fast8_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_fast8_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_fast16_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_fast16_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_fast32_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_fast32_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_int_fast64_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uint_fast64_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_intprt_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uintprt_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_size_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_ptrdiff_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_intmax_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;atomic_uintmax_t&quot;,
   &quot;target&quot;: &quot;c/atomic&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_create&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_create&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_equal&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_equal&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_current&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_current&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_sleep&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_sleep&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_yield&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_yield&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_exit&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_exit&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_detach&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_detach&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_join&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_join&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_success&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_errors&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_timeout&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_errors&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_busy&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_errors&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_nomem&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_errors&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_error&quot;,
   &quot;target&quot;: &quot;c/thread/thrd_errors&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_start_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_init&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_init&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_lock&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_lock&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_timedlock&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_timedlock&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_trylock&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_trylock&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_unlock&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_unlock&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_destroy&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_destroy&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_plain&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_types&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_recursive&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_types&quot;
  },
  {
   &quot;string&quot;: &quot;mtx_timed&quot;,
   &quot;target&quot;: &quot;c/thread/mtx_types&quot;
  },
  {
   &quot;string&quot;: &quot;thrd_start_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;once_flag&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;ONCE_FLAG_INIT&quot;,
   &quot;target&quot;: &quot;c/thread/ONCE_FLAG_INIT&quot;
  },
  {
   &quot;string&quot;: &quot;call_once&quot;,
   &quot;target&quot;: &quot;c/thread/call_once&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_init&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_init&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_signal&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_signal&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_broadcast&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_broadcast&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_wait&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_wait&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_timedwait&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_timedwait&quot;
  },
  {
   &quot;string&quot;: &quot;cnd_destroy&quot;,
   &quot;target&quot;: &quot;c/thread/cnd_destroy&quot;
  },
  {
   &quot;string&quot;: &quot;thread_local&quot;,
   &quot;target&quot;: &quot;c/thread/thread_local&quot;
  },
  {
   &quot;string&quot;: &quot;TSS_DTOR_ITERATIONS&quot;,
   &quot;target&quot;: &quot;c/thread/TSS_DTOR_ITERATIONS&quot;
  },
  {
   &quot;string&quot;: &quot;tss_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;tss_dtor_t&quot;,
   &quot;target&quot;: &quot;c/thread&quot;
  },
  {
   &quot;string&quot;: &quot;tss_create&quot;,
   &quot;target&quot;: &quot;c/thread/tss_create&quot;
  },
  {
   &quot;string&quot;: &quot;tss_get&quot;,
   &quot;target&quot;: &quot;c/thread/tss_get&quot;
  },
  {
   &quot;string&quot;: &quot;tss_set&quot;,
   &quot;target&quot;: &quot;c/thread/tss_set&quot;
  },
  {
   &quot;string&quot;: &quot;tss_delete&quot;,
   &quot;target&quot;: &quot;c/thread/tss_delete&quot;
  }
 ]
}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Autolinker-definition-cpp</title>
    <ns>8</ns>
    <id>10284</id>
    <revision>
      <id>61647</id>
      <parentid>61638</parentid>
      <timestamp>2013-06-06T09:17:43Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1004724">{
&quot;groups&quot;: [
{
&quot;base_url&quot;: &quot;cpp/atomic/ATOMIC_FLAG_INIT&quot;,
&quot;name&quot;: &quot;ATOMIC_FLAG_INIT&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_cv&quot;,
&quot;name&quot;: &quot;std::add_const&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_cv&quot;,
&quot;name&quot;: &quot;std::add_cv&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_reference&quot;,
&quot;name&quot;: &quot;std::add_lvalue_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_pointer&quot;,
&quot;name&quot;: &quot;std::add_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_reference&quot;,
&quot;name&quot;: &quot;std::add_rvalue_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/add_cv&quot;,
&quot;name&quot;: &quot;std::add_volatile&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/lock_tag_t&quot;,
&quot;name&quot;: &quot;std::adopt_lock_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/aligned_storage&quot;,
&quot;name&quot;: &quot;std::aligned_storage&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/aligned_union&quot;,
&quot;name&quot;: &quot;std::aligned_union&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/alignment_of&quot;,
&quot;name&quot;: &quot;std::alignment_of&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/allocator&quot;,
&quot;name&quot;: &quot;std::allocator&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/allocator&quot;,
&quot;/~allocator&quot;,
&quot;/address&quot;,
&quot;/allocate&quot;,
&quot;/deallocate&quot;,
&quot;/max_size&quot;,
&quot;/construct&quot;,
&quot;/destroy&quot;,
&quot;/operator_cmp&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/allocator_arg_t&quot;,
&quot;name&quot;: &quot;std::allocator_arg_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/allocator_traits&quot;,
&quot;name&quot;: &quot;std::allocator_traits&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/allocate&quot;,
&quot;/deallocate&quot;,
&quot;/max_size&quot;,
&quot;/construct&quot;,
&quot;/destroy&quot;,
&quot;/select_on_container_copy_construction&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/array&quot;,
&quot;name&quot;: &quot;std::array&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/data&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/fill&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/get&quot;,
&quot;/tuple_size&quot;,
&quot;/tuple_element&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/atomic/atomic&quot;,
&quot;name&quot;: &quot;std::atomic&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/atomic&quot;,
&quot;/operator=&quot;,
&quot;/is_lock_free&quot;,
&quot;/store&quot;,
&quot;/load&quot;,
&quot;/operator T&quot;,
&quot;/exchange&quot;,
&quot;/compare_exchange&quot;,
&quot;/fetch_add&quot;,
&quot;/fetch_sub&quot;,
&quot;/fetch_and&quot;,
&quot;/fetch_or&quot;,
&quot;/fetch_xor&quot;,
&quot;/operator_arith&quot;,
&quot;/operator_arith2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/atomic/atomic_flag&quot;,
&quot;name&quot;: &quot;std::atomic_flag&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/atomic_flag&quot;,
&quot;/operator=&quot;,
&quot;/clear&quot;,
&quot;/test_and_set&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/auto_ptr&quot;,
&quot;name&quot;: &quot;std::auto_ptr&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/auto_ptr&quot;,
&quot;/~auto_ptr&quot;,
&quot;/operator=&quot;,
&quot;/reset&quot;,
&quot;/release&quot;,
&quot;/get&quot;,
&quot;/operator*&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/back_insert_iterator&quot;,
&quot;name&quot;: &quot;std::back_insert_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/new/bad_alloc&quot;,
&quot;name&quot;: &quot;std::bad_alloc&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/new/bad_array_length&quot;,
&quot;name&quot;: &quot;std::bad_array_length&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/new/bad_array_new_length&quot;,
&quot;name&quot;: &quot;std::bad_array_new_length&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bad_array_new_length&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/bad_cast&quot;,
&quot;name&quot;: &quot;std::bad_cast&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bad_cast&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/bad_exception&quot;,
&quot;name&quot;: &quot;std::bad_exception&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/bad_function_call&quot;,
&quot;name&quot;: &quot;std::bad_function_call&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bad_function_call&quot;,
&quot;/what&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/bad_optional_access&quot;,
&quot;name&quot;: &quot;std::bad_optional_access&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/bad_typeid&quot;,
&quot;name&quot;: &quot;std::bad_typeid&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bad_typeid&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/bad_weak_ptr&quot;,
&quot;name&quot;: &quot;std::bad_weak_ptr&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bad_weak_ptr&quot;,
&quot;/what&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_filebuf&quot;,
&quot;name&quot;: &quot;std::basic_filebuf&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_filebuf&quot;,
&quot;/~basic_filebuf&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/str&quot;,
&quot;/is_open&quot;,
&quot;/open&quot;,
&quot;/close&quot;,
&quot;/showmanyc&quot;,
&quot;/underflow&quot;,
&quot;/uflow&quot;,
&quot;/pbackfail&quot;,
&quot;/overflow&quot;,
&quot;/setbuf&quot;,
&quot;/seekoff&quot;,
&quot;/seekpos&quot;,
&quot;/sync&quot;,
&quot;/imbue&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_fstream&quot;,
&quot;name&quot;: &quot;std::basic_fstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_fstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/is_open&quot;,
&quot;/open&quot;,
&quot;/close&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_fstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_fstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_fstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_fstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_fstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_fstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_fstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ifstream&quot;,
&quot;name&quot;: &quot;std::basic_ifstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_ifstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/is_open&quot;,
&quot;/open&quot;,
&quot;/close&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_ifstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ios&quot;,
&quot;name&quot;: &quot;std::basic_ios&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_ios&quot;,
&quot;/~basic_ios&quot;,
&quot;/good&quot;,
&quot;/eof&quot;,
&quot;/fail&quot;,
&quot;/bad&quot;,
&quot;/operator!&quot;,
&quot;/operator_bool&quot;,
&quot;/rdstate&quot;,
&quot;/setstate&quot;,
&quot;/clear&quot;,
&quot;/copyfmt&quot;,
&quot;/fill&quot;,
&quot;/exceptions&quot;,
&quot;/imbue&quot;,
&quot;/rdbuf&quot;,
&quot;/tie&quot;,
&quot;/narrow&quot;,
&quot;/widen&quot;,
&quot;/init&quot;,
&quot;/move&quot;,
&quot;/swap&quot;,
&quot;/set_rdbuf&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_ios::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_ios::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_ios::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_ios::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_ios::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_ios::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_iostream&quot;,
&quot;name&quot;: &quot;std::basic_iostream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_iostream&quot;,
&quot;/~basic_iostream&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_iostream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_iostream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_iostream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_iostream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_iostream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_iostream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_iostream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream&quot;,
&quot;name&quot;: &quot;std::basic_istream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_istream&quot;,
&quot;/~basic_istream&quot;,
&quot;/operator_gtgt&quot;,
&quot;/get&quot;,
&quot;/peek&quot;,
&quot;/unget&quot;,
&quot;/putback&quot;,
&quot;/getline&quot;,
&quot;/ignore&quot;,
&quot;/read&quot;,
&quot;/readsome&quot;,
&quot;/gcount&quot;,
&quot;/tellg&quot;,
&quot;/seekg&quot;,
&quot;/sync&quot;,
&quot;/sentry&quot;,
&quot;/operator_gtgt2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_istream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_istream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_istream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_istream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_istream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_istream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_istream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istringstream&quot;,
&quot;name&quot;: &quot;std::basic_istringstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_istringstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/str&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_istringstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ofstream&quot;,
&quot;name&quot;: &quot;std::basic_ofstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_ofstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/is_open&quot;,
&quot;/open&quot;,
&quot;/close&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_ofstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::basic_ostream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_ostream&quot;,
&quot;/~basic_ostream&quot;,
&quot;/operator_ltlt&quot;,
&quot;/put&quot;,
&quot;/write&quot;,
&quot;/tellp&quot;,
&quot;/seekp&quot;,
&quot;/flush&quot;,
&quot;/sentry&quot;,
&quot;/operator_ltlt2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_ostream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_ostream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_ostream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_ostream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_ostream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_ostream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_ostream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostringstream&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_ostringstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/str&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_ostringstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/basic_regex&quot;,
&quot;name&quot;: &quot;std::basic_regex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_regex&quot;,
&quot;/~basic_regex&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/mark_count&quot;,
&quot;/flags&quot;,
&quot;/getloc&quot;,
&quot;/imbue&quot;,
&quot;/swap&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_streambuf&quot;,
&quot;name&quot;: &quot;std::basic_streambuf&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_streambuf&quot;,
&quot;/~basic_streambuf&quot;,
&quot;/pubimbue&quot;,
&quot;/getloc&quot;,
&quot;/pubsetbuf&quot;,
&quot;/pubseekoff&quot;,
&quot;/pubseekpos&quot;,
&quot;/pubsync&quot;,
&quot;/in_avail&quot;,
&quot;/snextc&quot;,
&quot;/sbumpc&quot;,
&quot;/sgetc&quot;,
&quot;/sgetn&quot;,
&quot;/sputc&quot;,
&quot;/sputn&quot;,
&quot;/sputbackc&quot;,
&quot;/ungetc&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/showmanyc&quot;,
&quot;/underflow&quot;,
&quot;/uflow&quot;,
&quot;/gptr&quot;,
&quot;/gbump&quot;,
&quot;/setg&quot;,
&quot;/overflow&quot;,
&quot;/pptr&quot;,
&quot;/pbump&quot;,
&quot;/setp&quot;,
&quot;/pbackfail&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/string/basic_string&quot;,
&quot;name&quot;: &quot;std::basic_string&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_string&quot;,
&quot;/assign&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/data&quot;,
&quot;/c_str&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/reserve&quot;,
&quot;/capacity&quot;,
&quot;/shrink_to_fit&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/erase&quot;,
&quot;/push_back&quot;,
&quot;/pop_back&quot;,
&quot;/append&quot;,
&quot;/compare&quot;,
&quot;/replace&quot;,
&quot;/substr&quot;,
&quot;/copy&quot;,
&quot;/resize&quot;,
&quot;/swap&quot;,
&quot;/find&quot;,
&quot;/rfind&quot;,
&quot;/find_first_of&quot;,
&quot;/find_first_not_of&quot;,
&quot;/find_last_of&quot;,
&quot;/find_last_not_of&quot;,
&quot;/npos&quot;,
&quot;/operator+&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/operator_ltltgtgt&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_stringbuf&quot;,
&quot;name&quot;: &quot;std::basic_stringbuf&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_stringbuf&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/str&quot;,
&quot;/underflow&quot;,
&quot;/pbackfail&quot;,
&quot;/overflow&quot;,
&quot;/setbuf&quot;,
&quot;/seekoff&quot;,
&quot;/seekpos&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_stringstream&quot;,
&quot;name&quot;: &quot;std::basic_stringstream&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/basic_stringstream&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/rdbuf&quot;,
&quot;/str&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream/sentry&quot;,
&quot;name&quot;: &quot;std::basic_stringstream::sentry&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/bernoulli_distribution&quot;,
&quot;name&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bernoulli_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/p&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_tags&quot;,
&quot;name&quot;: &quot;std::bidirectional_iterator_tag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/binary_function&quot;,
&quot;name&quot;: &quot;std::binary_function&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/binary_negate&quot;,
&quot;name&quot;: &quot;std::binary_negate&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/binary_negate&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/binomial_distribution&quot;,
&quot;name&quot;: &quot;std::binomial_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/binomial_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/bit_and&quot;,
&quot;name&quot;: &quot;std::bit_and&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/bit_not&quot;,
&quot;name&quot;: &quot;std::bit_not&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/bit_or&quot;,
&quot;name&quot;: &quot;std::bit_or&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/bitset&quot;,
&quot;name&quot;: &quot;std::bitset&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/bitset&quot;,
&quot;/~bitset&quot;,
&quot;/reference&quot;,
&quot;/operator=&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_at&quot;,
&quot;/test&quot;,
&quot;/all_any_none&quot;,
&quot;/count&quot;,
&quot;/size&quot;,
&quot;/operator_logic&quot;,
&quot;/operator_ltltgtgt&quot;,
&quot;/set&quot;,
&quot;/reset&quot;,
&quot;/flip&quot;,
&quot;/to_string&quot;,
&quot;/to_ulong&quot;,
&quot;/to_ullong&quot;,
&quot;/operator_logic2&quot;,
&quot;/operator_ltltgtgt2&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/bitset/reference&quot;,
&quot;name&quot;: &quot;std::bitset::reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/cauchy_distribution&quot;,
&quot;name&quot;: &quot;std::cauchy_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/cauchy_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::cerr&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/string/char_traits&quot;,
&quot;name&quot;: &quot;std::char_traits&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/chi_squared_distribution&quot;,
&quot;name&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/chi_squared_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/n&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/duration&quot;,
&quot;name&quot;: &quot;std::chrono::duration&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/duration&quot;,
&quot;/~duration&quot;,
&quot;/operator=&quot;,
&quot;/count&quot;,
&quot;/zero&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_arith&quot;,
&quot;/operator_arith2&quot;,
&quot;/operator_arith3&quot;,
&quot;/operator_arith4&quot;,
&quot;/operator_cmp&quot;,
&quot;/common_type&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/duration_values&quot;,
&quot;name&quot;: &quot;std::chrono::duration_values&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/zero&quot;,
&quot;/min&quot;,
&quot;/max&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/high_resolution_clock&quot;,
&quot;name&quot;: &quot;std::chrono::high_resolution_clock&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/now&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/steady_clock&quot;,
&quot;name&quot;: &quot;std::chrono::steady_clock&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/now&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/system_clock&quot;,
&quot;name&quot;: &quot;std::chrono::system_clock&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/now&quot;,
&quot;/to_time_t&quot;,
&quot;/from_time_t&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/time_point&quot;,
&quot;name&quot;: &quot;std::chrono::time_point&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/time_point&quot;,
&quot;/time_since_epoch&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_arith&quot;,
&quot;/operator_arith2&quot;,
&quot;/operator_cmp&quot;,
&quot;/common_type&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/duration/treat_as_floating_point&quot;,
&quot;name&quot;: &quot;std::chrono::treat_as_floating_point&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream&quot;,
&quot;name&quot;: &quot;std::cin&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::clog&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt&quot;,
&quot;name&quot;: &quot;std::codecvt&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;_base&quot;,
&quot;/codecvt&quot;,
&quot;/~codecvt&quot;,
&quot;/out&quot;,
&quot;/in&quot;,
&quot;/unshift&quot;,
&quot;/encoding&quot;,
&quot;/always_noconv&quot;,
&quot;/length&quot;,
&quot;/max_length&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_base&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_base::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_byname&quot;,
&quot;name&quot;: &quot;std::codecvt_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/codecvt_byname&quot;,
&quot;/~codecvt_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_byname::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_mode&quot;,
&quot;name&quot;: &quot;std::codecvt_mode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_utf16&quot;,
&quot;name&quot;: &quot;std::codecvt_utf16&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_utf16::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_utf8&quot;,
&quot;name&quot;: &quot;std::codecvt_utf8&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_utf8::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_utf8_utf16&quot;,
&quot;name&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/codecvt_base&quot;,
&quot;name&quot;: &quot;std::codecvt_utf8_utf16::result&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/collate&quot;,
&quot;name&quot;: &quot;std::collate&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/collate&quot;,
&quot;/~collate&quot;,
&quot;/compare&quot;,
&quot;/transform&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/collate_byname&quot;,
&quot;name&quot;: &quot;std::collate_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/collate_byname&quot;,
&quot;/~collate_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/common_type&quot;,
&quot;name&quot;: &quot;std::common_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/complex&quot;,
&quot;name&quot;: &quot;std::complex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/complex&quot;,
&quot;/operator=&quot;,
&quot;/real&quot;,
&quot;/imag&quot;,
&quot;/operator_arith&quot;,
&quot;/operator_arith2&quot;,
&quot;/operator_arith3&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;,
&quot;/abs&quot;,
&quot;/arg&quot;,
&quot;/norm&quot;,
&quot;/conj&quot;,
&quot;/proj&quot;,
&quot;/polar&quot;,
&quot;/exp&quot;,
&quot;/log&quot;,
&quot;/log10&quot;,
&quot;/pow&quot;,
&quot;/sqrt&quot;,
&quot;/sin&quot;,
&quot;/cos&quot;,
&quot;/tan&quot;,
&quot;/asin&quot;,
&quot;/acos&quot;,
&quot;/atan&quot;,
&quot;/sinh&quot;,
&quot;/cosh&quot;,
&quot;/tanh&quot;,
&quot;/asinh&quot;,
&quot;/acosh&quot;,
&quot;/atanh&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/condition_variable&quot;,
&quot;name&quot;: &quot;std::condition_variable&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/condition_variable&quot;,
&quot;/~condition_variable&quot;,
&quot;/notify_one&quot;,
&quot;/notify_all&quot;,
&quot;/wait&quot;,
&quot;/wait_for&quot;,
&quot;/wait_until&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/condition_variable_any&quot;,
&quot;name&quot;: &quot;std::condition_variable_any&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/condition_variable_any&quot;,
&quot;/~condition_variable_any&quot;,
&quot;/notify_one&quot;,
&quot;/notify_all&quot;,
&quot;/wait&quot;,
&quot;/wait_for&quot;,
&quot;/wait_until&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/conditional&quot;,
&quot;name&quot;: &quot;std::conditional&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::cout&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/ctype&quot;,
&quot;name&quot;: &quot;std::ctype&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;_base&quot;,
&quot;/ctype&quot;,
&quot;/~ctype&quot;,
&quot;/is&quot;,
&quot;/scan_is&quot;,
&quot;/toupper&quot;,
&quot;/tolower&quot;,
&quot;/widen&quot;,
&quot;/narrow&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/ctype_base&quot;,
&quot;name&quot;: &quot;std::ctype_base&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/ctype_byname&quot;,
&quot;name&quot;: &quot;std::ctype_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/ctype_byname&quot;,
&quot;/~ctype_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/cv_status&quot;,
&quot;name&quot;: &quot;std::cv_status&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/no_timeout&quot;,
&quot;/timeout&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/decay&quot;,
&quot;name&quot;: &quot;std::decay&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/default_delete&quot;,
&quot;name&quot;: &quot;std::default_delete&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/lock_tag_t&quot;,
&quot;name&quot;: &quot;std::defer_lock_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/deque&quot;,
&quot;name&quot;: &quot;std::deque&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/deque&quot;,
&quot;/~deque&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/get_allocator&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/shrink_to_fit&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/erase&quot;,
&quot;/push_back&quot;,
&quot;/emplace_back&quot;,
&quot;/pop_back&quot;,
&quot;/push_front&quot;,
&quot;/emplace_front&quot;,
&quot;/pop_front&quot;,
&quot;/resize&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/discard_block_engine&quot;,
&quot;name&quot;: &quot;std::discard_block_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/discard_block_engine&quot;,
&quot;/seed&quot;,
&quot;/base&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/discrete_distribution&quot;,
&quot;name&quot;: &quot;std::discrete_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/discrete_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/probabilities&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/divides&quot;,
&quot;name&quot;: &quot;std::divides&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/domain_error&quot;,
&quot;name&quot;: &quot;std::domain_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/dynarray&quot;,
&quot;name&quot;: &quot;std::dynarray&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/dynarray&quot;,
&quot;/~dynarray&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/data&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/fill&quot;,
&quot;/operator_cmp&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/enable_if&quot;,
&quot;name&quot;: &quot;std::enable_if&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/enable_shared_from_this&quot;,
&quot;name&quot;: &quot;std::enable_shared_from_this&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/enable_shared_from_this&quot;,
&quot;/~enable_shared_from_this&quot;,
&quot;/operator=&quot;,
&quot;/shared_from_this&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/equal_to&quot;,
&quot;name&quot;: &quot;std::equal_to&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/errc&quot;,
&quot;name&quot;: &quot;std::errc&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/is_error_condition_enum&quot;,
&quot;/make_error_code&quot;,
&quot;/make_error_condition&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/error_category&quot;,
&quot;name&quot;: &quot;std::error_category&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/error_category&quot;,
&quot;/~error_category&quot;,
&quot;/operator=&quot;,
&quot;/name&quot;,
&quot;/default_error_condition&quot;,
&quot;/equivalent&quot;,
&quot;/message&quot;,
&quot;/operator_cmp&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/error_code&quot;,
&quot;name&quot;: &quot;std::error_code&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/error_code&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/clear&quot;,
&quot;/value&quot;,
&quot;/category&quot;,
&quot;/default_error_condition&quot;,
&quot;/message&quot;,
&quot;/operator_bool&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltlt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/error_condition&quot;,
&quot;name&quot;: &quot;std::error_condition&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/error_condition&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/clear&quot;,
&quot;/value&quot;,
&quot;/category&quot;,
&quot;/message&quot;,
&quot;/operator_bool&quot;,
&quot;/operator_cmp&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/exception&quot;,
&quot;name&quot;: &quot;std::exception&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/exception&quot;,
&quot;/~exception&quot;,
&quot;/operator=&quot;,
&quot;/what&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/exponential_distribution&quot;,
&quot;name&quot;: &quot;std::exponential_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/exponential_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/lambda&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/extent&quot;,
&quot;name&quot;: &quot;std::extent&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/extreme_value_distribution&quot;,
&quot;name&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/extreme_value_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/fisher_f_distribution&quot;,
&quot;name&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/fisher_f_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/numeric_limits/float_denorm_style&quot;,
&quot;name&quot;: &quot;std::float_denorm_style&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;,
&quot;name&quot;: &quot;std::float_round_style&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_tags&quot;,
&quot;name&quot;: &quot;std::forward_iterator_tag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/forward_list&quot;,
&quot;name&quot;: &quot;std::forward_list&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/forward_list&quot;,
&quot;/~forward_list&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/get_allocator&quot;,
&quot;/front&quot;,
&quot;/before_begin&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/empty&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert_after&quot;,
&quot;/emplace_after&quot;,
&quot;/erase_after&quot;,
&quot;/push_front&quot;,
&quot;/emplace_front&quot;,
&quot;/pop_front&quot;,
&quot;/resize&quot;,
&quot;/swap&quot;,
&quot;/merge&quot;,
&quot;/splice_after&quot;,
&quot;/remove&quot;,
&quot;/reverse&quot;,
&quot;/unique&quot;,
&quot;/sort&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/fpos&quot;,
&quot;name&quot;: &quot;std::fpos&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/state&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/front_insert_iterator&quot;,
&quot;name&quot;: &quot;std::front_insert_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/function&quot;,
&quot;name&quot;: &quot;std::function&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/function&quot;,
&quot;/~function&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/assign&quot;,
&quot;/operator_bool&quot;,
&quot;/operator()&quot;,
&quot;/target_type&quot;,
&quot;/target&quot;,
&quot;/operator_cmp&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/future&quot;,
&quot;name&quot;: &quot;std::future&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/future&quot;,
&quot;/~future&quot;,
&quot;/operator=&quot;,
&quot;/share&quot;,
&quot;/get&quot;,
&quot;/valid&quot;,
&quot;/wait&quot;,
&quot;/wait_for&quot;,
&quot;/wait_until&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/future_errc&quot;,
&quot;name&quot;: &quot;std::future_errc&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/is_error_code_enum&quot;,
&quot;/make_error_code&quot;,
&quot;/make_error_condition&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/future_error&quot;,
&quot;name&quot;: &quot;std::future_error&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/future_error&quot;,
&quot;/code&quot;,
&quot;/what&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/future_status&quot;,
&quot;name&quot;: &quot;std::future_status&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/gamma_distribution&quot;,
&quot;name&quot;: &quot;std::gamma_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/gamma_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/geometric_distribution&quot;,
&quot;name&quot;: &quot;std::geometric_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/geometric_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/p&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/greater&quot;,
&quot;name&quot;: &quot;std::greater&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/greater_equal&quot;,
&quot;name&quot;: &quot;std::greater_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/has_virtual_destructor&quot;,
&quot;name&quot;: &quot;std::has_virtual_destructor&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/hash&quot;,
&quot;name&quot;: &quot;std::hash&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/hash&quot;,
&quot;/operator()&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/independent_bits_engine&quot;,
&quot;name&quot;: &quot;std::independent_bits_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/independent_bits_engine&quot;,
&quot;/seed&quot;,
&quot;/base&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/initializer_list&quot;,
&quot;name&quot;: &quot;std::initializer_list&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/initializer_list&quot;,
&quot;/size&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/begin2&quot;,
&quot;/end2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/inplace_t&quot;,
&quot;name&quot;: &quot;std::inplace_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_tags&quot;,
&quot;name&quot;: &quot;std::input_iterator_tag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/insert_iterator&quot;,
&quot;name&quot;: &quot;std::insert_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/integer_sequence&quot;,
&quot;name&quot;: &quot;std::integer_sequence&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/integral_constant&quot;,
&quot;name&quot;: &quot;std::integral_constant&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/invalid_argument&quot;,
&quot;name&quot;: &quot;std::invalid_argument&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/io_errc&quot;,
&quot;name&quot;: &quot;std::io_errc&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/is_error_code_enum&quot;,
&quot;/make_error_code&quot;,
&quot;/make_error_condition&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base&quot;,
&quot;name&quot;: &quot;std::ios_base&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/ios_base&quot;,
&quot;/~ios_base&quot;,
&quot;/flags&quot;,
&quot;/setf&quot;,
&quot;/unsetf&quot;,
&quot;/precision&quot;,
&quot;/width&quot;,
&quot;/imbue&quot;,
&quot;/getloc&quot;,
&quot;/xalloc&quot;,
&quot;/iword&quot;,
&quot;/pword&quot;,
&quot;/register_callback&quot;,
&quot;/sync_with_stdio&quot;,
&quot;/failure&quot;,
&quot;/openmode&quot;,
&quot;/fmtflags&quot;,
&quot;/iostate&quot;,
&quot;/seekdir&quot;,
&quot;/event&quot;,
&quot;/event_callback&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/event&quot;,
&quot;name&quot;: &quot;std::ios_base::event&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/failure&quot;,
&quot;name&quot;: &quot;std::ios_base::failure&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/failure&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/fmtflags&quot;,
&quot;name&quot;: &quot;std::ios_base::fmtflags&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/iostate&quot;,
&quot;name&quot;: &quot;std::ios_base::iostate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/openmode&quot;,
&quot;name&quot;: &quot;std::ios_base::openmode&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/ios_base/seekdir&quot;,
&quot;name&quot;: &quot;std::ios_base::seekdir&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_abstract&quot;,
&quot;name&quot;: &quot;std::is_abstract&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_arithmetic&quot;,
&quot;name&quot;: &quot;std::is_arithmetic&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_array&quot;,
&quot;name&quot;: &quot;std::is_array&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_assignable&quot;,
&quot;name&quot;: &quot;std::is_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_base_of&quot;,
&quot;name&quot;: &quot;std::is_base_of&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/is_bind_expression&quot;,
&quot;name&quot;: &quot;std::is_bind_expression&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_class&quot;,
&quot;name&quot;: &quot;std::is_class&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_compound&quot;,
&quot;name&quot;: &quot;std::is_compound&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_const&quot;,
&quot;name&quot;: &quot;std::is_const&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_constructible&quot;,
&quot;name&quot;: &quot;std::is_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_convertible&quot;,
&quot;name&quot;: &quot;std::is_convertible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_assignable&quot;,
&quot;name&quot;: &quot;std::is_copy_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_constructible&quot;,
&quot;name&quot;: &quot;std::is_copy_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_default_constructible&quot;,
&quot;name&quot;: &quot;std::is_default_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_destructible&quot;,
&quot;name&quot;: &quot;std::is_destructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_empty&quot;,
&quot;name&quot;: &quot;std::is_empty&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_enum&quot;,
&quot;name&quot;: &quot;std::is_enum&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/error_code/is_error_code_enum&quot;,
&quot;name&quot;: &quot;std::is_error_code_enum&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/error_condition/is_error_condition_enum&quot;,
&quot;name&quot;: &quot;std::is_error_condition_enum&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_floating_point&quot;,
&quot;name&quot;: &quot;std::is_floating_point&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_function&quot;,
&quot;name&quot;: &quot;std::is_function&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_fundamental&quot;,
&quot;name&quot;: &quot;std::is_fundamental&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_integral&quot;,
&quot;name&quot;: &quot;std::is_integral&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_literal_type&quot;,
&quot;name&quot;: &quot;std::is_literal_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_lvalue_reference&quot;,
&quot;name&quot;: &quot;std::is_lvalue_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_member_function_pointer&quot;,
&quot;name&quot;: &quot;std::is_member_function_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_member_object_pointer&quot;,
&quot;name&quot;: &quot;std::is_member_object_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_member_pointer&quot;,
&quot;name&quot;: &quot;std::is_member_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_assignable&quot;,
&quot;name&quot;: &quot;std::is_move_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_constructible&quot;,
&quot;name&quot;: &quot;std::is_move_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_assignable&quot;,
&quot;name&quot;: &quot;std::is_nothrow_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_constructible&quot;,
&quot;name&quot;: &quot;std::is_nothrow_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_assignable&quot;,
&quot;name&quot;: &quot;std::is_nothrow_copy_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_constructible&quot;,
&quot;name&quot;: &quot;std::is_nothrow_copy_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_default_constructible&quot;,
&quot;name&quot;: &quot;std::is_nothrow_default_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_destructible&quot;,
&quot;name&quot;: &quot;std::is_nothrow_destructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_assignable&quot;,
&quot;name&quot;: &quot;std::is_nothrow_move_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_constructible&quot;,
&quot;name&quot;: &quot;std::is_nothrow_move_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_object&quot;,
&quot;name&quot;: &quot;std::is_object&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/is_placeholder&quot;,
&quot;name&quot;: &quot;std::is_placeholder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_pod&quot;,
&quot;name&quot;: &quot;std::is_pod&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_pointer&quot;,
&quot;name&quot;: &quot;std::is_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_polymorphic&quot;,
&quot;name&quot;: &quot;std::is_polymorphic&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_reference&quot;,
&quot;name&quot;: &quot;std::is_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_rvalue_reference&quot;,
&quot;name&quot;: &quot;std::is_rvalue_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_same&quot;,
&quot;name&quot;: &quot;std::is_same&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_scalar&quot;,
&quot;name&quot;: &quot;std::is_scalar&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_signed&quot;,
&quot;name&quot;: &quot;std::is_signed&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_standard_layout&quot;,
&quot;name&quot;: &quot;std::is_standard_layout&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_trivial&quot;,
&quot;name&quot;: &quot;std::is_trivial&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_assignable&quot;,
&quot;name&quot;: &quot;std::is_trivially_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_constructible&quot;,
&quot;name&quot;: &quot;std::is_trivially_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_assignable&quot;,
&quot;name&quot;: &quot;std::is_trivially_copy_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_copy_constructible&quot;,
&quot;name&quot;: &quot;std::is_trivially_copy_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_trivially_copyable&quot;,
&quot;name&quot;: &quot;std::is_trivially_copyable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_default_constructible&quot;,
&quot;name&quot;: &quot;std::is_trivially_default_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_destructible&quot;,
&quot;name&quot;: &quot;std::is_trivially_destructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_assignable&quot;,
&quot;name&quot;: &quot;std::is_trivially_move_assignable&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_move_constructible&quot;,
&quot;name&quot;: &quot;std::is_trivially_move_constructible&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_union&quot;,
&quot;name&quot;: &quot;std::is_union&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_unsigned&quot;,
&quot;name&quot;: &quot;std::is_unsigned&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_void&quot;,
&quot;name&quot;: &quot;std::is_void&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/is_volatile&quot;,
&quot;name&quot;: &quot;std::is_volatile&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/istream_iterator&quot;,
&quot;name&quot;: &quot;std::istream_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/istreambuf_iterator&quot;,
&quot;name&quot;: &quot;std::istreambuf_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator&quot;,
&quot;name&quot;: &quot;std::iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_traits&quot;,
&quot;name&quot;: &quot;std::iterator_traits&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/launch&quot;,
&quot;name&quot;: &quot;std::launch&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/lconv&quot;,
&quot;name&quot;: &quot;std::lconv&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/length_error&quot;,
&quot;name&quot;: &quot;std::length_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/less&quot;,
&quot;name&quot;: &quot;std::less&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/less_equal&quot;,
&quot;name&quot;: &quot;std::less_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/linear_congruential_engine&quot;,
&quot;name&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/linear_congruential_engine&quot;,
&quot;/seed&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/list&quot;,
&quot;name&quot;: &quot;std::list&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/list&quot;,
&quot;/~list&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/get_allocator&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/erase&quot;,
&quot;/push_back&quot;,
&quot;/emplace_back&quot;,
&quot;/pop_back&quot;,
&quot;/push_front&quot;,
&quot;/emplace_front&quot;,
&quot;/pop_front&quot;,
&quot;/resize&quot;,
&quot;/swap&quot;,
&quot;/merge&quot;,
&quot;/splice&quot;,
&quot;/remove&quot;,
&quot;/reverse&quot;,
&quot;/unique&quot;,
&quot;/sort&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/locale&quot;,
&quot;name&quot;: &quot;std::locale&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/locale&quot;,
&quot;/~locale&quot;,
&quot;/operator=&quot;,
&quot;/combine&quot;,
&quot;/name&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator()&quot;,
&quot;/global&quot;,
&quot;/classic&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/locale/facet&quot;,
&quot;name&quot;: &quot;std::locale::facet&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/facet&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/locale/id&quot;,
&quot;name&quot;: &quot;std::locale::id&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/id&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/lock_guard&quot;,
&quot;name&quot;: &quot;std::lock_guard&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/lock_guard&quot;,
&quot;/~lock_guard&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/logic_error&quot;,
&quot;name&quot;: &quot;std::logic_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/logical_and&quot;,
&quot;name&quot;: &quot;std::logical_and&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/logical_not&quot;,
&quot;name&quot;: &quot;std::logical_not&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/logical_or&quot;,
&quot;name&quot;: &quot;std::logical_or&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/lognormal_distribution&quot;,
&quot;name&quot;: &quot;std::lognormal_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/lognormal_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/make_signed&quot;,
&quot;name&quot;: &quot;std::make_signed&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/make_unsigned&quot;,
&quot;name&quot;: &quot;std::make_unsigned&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/map&quot;,
&quot;name&quot;: &quot;std::map&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/value_compare&quot;,
&quot;/map&quot;,
&quot;/~map&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/lower_bound&quot;,
&quot;/upper_bound&quot;,
&quot;/key_comp&quot;,
&quot;/value_comp&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/map/value_compare&quot;,
&quot;name&quot;: &quot;std::map::value_compare&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/match_results&quot;,
&quot;name&quot;: &quot;std::match_results&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/match_results&quot;,
&quot;/~match_results&quot;,
&quot;/get_allocator&quot;,
&quot;/ready&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/length&quot;,
&quot;/position&quot;,
&quot;/str&quot;,
&quot;/operator_at&quot;,
&quot;/prefix&quot;,
&quot;/suffix&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/format&quot;,
&quot;/swap&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/string/multibyte/mbstate_t&quot;,
&quot;name&quot;: &quot;std::mbstate_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/atomic/memory_order&quot;,
&quot;name&quot;: &quot;std::memory_order&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/mersenne_twister_engine&quot;,
&quot;name&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/mersenne_twister_engine&quot;,
&quot;/seed&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/messages&quot;,
&quot;name&quot;: &quot;std::messages&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;_base&quot;,
&quot;/messages&quot;,
&quot;/~messages&quot;,
&quot;/open&quot;,
&quot;/get&quot;,
&quot;/close&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/messages_base&quot;,
&quot;name&quot;: &quot;std::messages_base&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/messages_byname&quot;,
&quot;name&quot;: &quot;std::messages_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/messages_byname&quot;,
&quot;/~messages_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/minus&quot;,
&quot;name&quot;: &quot;std::minus&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/modulus&quot;,
&quot;name&quot;: &quot;std::modulus&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_base&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_base::part&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_base::pattern&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_get&quot;,
&quot;name&quot;: &quot;std::money_get&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/money_get&quot;,
&quot;/~money_get&quot;,
&quot;/get&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_get::part&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_get::pattern&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_put&quot;,
&quot;name&quot;: &quot;std::money_put&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/money_put&quot;,
&quot;/~money_put&quot;,
&quot;/put&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_put::part&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::money_put::pattern&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/moneypunct&quot;,
&quot;name&quot;: &quot;std::moneypunct&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/moneypunct&quot;,
&quot;/~moneypunct&quot;,
&quot;/decimal_point&quot;,
&quot;/thousands_sep&quot;,
&quot;/grouping&quot;,
&quot;/curr_symbol&quot;,
&quot;/positive_sign&quot;,
&quot;/negative_sign&quot;,
&quot;/frac_digits&quot;,
&quot;/pos_format&quot;,
&quot;/neg_format&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::moneypunct::part&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::moneypunct::pattern&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/moneypunct_byname&quot;,
&quot;name&quot;: &quot;std::moneypunct_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/moneypunct_byname&quot;,
&quot;/~moneypunct_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::moneypunct_byname::part&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/money_base&quot;,
&quot;name&quot;: &quot;std::moneypunct_byname::pattern&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/move_iterator&quot;,
&quot;name&quot;: &quot;std::move_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/multimap&quot;,
&quot;name&quot;: &quot;std::multimap&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/value_compare&quot;,
&quot;/multimap&quot;,
&quot;/~multimap&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/lower_bound&quot;,
&quot;/upper_bound&quot;,
&quot;/key_comp&quot;,
&quot;/value_comp&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/multimap/value_compare&quot;,
&quot;name&quot;: &quot;std::multimap::value_compare&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/multiplies&quot;,
&quot;name&quot;: &quot;std::multiplies&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/multiset&quot;,
&quot;name&quot;: &quot;std::multiset&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/multiset&quot;,
&quot;/~multiset&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/lower_bound&quot;,
&quot;/upper_bound&quot;,
&quot;/key_comp&quot;,
&quot;/value_comp&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/mutex&quot;,
&quot;name&quot;: &quot;std::mutex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/mutex&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/unlock&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/negate&quot;,
&quot;name&quot;: &quot;std::negate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/negative_binomial_distribution&quot;,
&quot;name&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/negative_binomial_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/nested_exception&quot;,
&quot;name&quot;: &quot;std::nested_exception&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/nested_exception&quot;,
&quot;/~nested_exception&quot;,
&quot;/operator=&quot;,
&quot;/rethrow_nested&quot;,
&quot;/nested_ptr&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/normal_distribution&quot;,
&quot;name&quot;: &quot;std::normal_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/normal_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/not_equal_to&quot;,
&quot;name&quot;: &quot;std::not_equal_to&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/new/nothrow_t&quot;,
&quot;name&quot;: &quot;std::nothrow_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/nullopt_t&quot;,
&quot;name&quot;: &quot;std::nullopt_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/num_get&quot;,
&quot;name&quot;: &quot;std::num_get&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/num_get&quot;,
&quot;/~num_get&quot;,
&quot;/get&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/num_put&quot;,
&quot;name&quot;: &quot;std::num_put&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/num_put&quot;,
&quot;/~num_put&quot;,
&quot;/put&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/numeric_limits&quot;,
&quot;name&quot;: &quot;std::numeric_limits&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/is_specialized&quot;,
&quot;/is_signed&quot;,
&quot;/is_integer&quot;,
&quot;/is_exact&quot;,
&quot;/has_infinity&quot;,
&quot;/has_quiet_NaN&quot;,
&quot;/has_signaling_NaN&quot;,
&quot;/has_denorm&quot;,
&quot;/has_denorm_loss&quot;,
&quot;/round_style&quot;,
&quot;/is_iec559&quot;,
&quot;/is_bounded&quot;,
&quot;/is_modulo&quot;,
&quot;/digits&quot;,
&quot;/digits10&quot;,
&quot;/max_digits10&quot;,
&quot;/radix&quot;,
&quot;/min_exponent&quot;,
&quot;/min_exponent10&quot;,
&quot;/max_exponent&quot;,
&quot;/max_exponent10&quot;,
&quot;/traps&quot;,
&quot;/tinyness_before&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/lowest&quot;,
&quot;/epsilon&quot;,
&quot;/round_error&quot;,
&quot;/infinity&quot;,
&quot;/quiet_NaN&quot;,
&quot;/signaling_NaN&quot;,
&quot;/denorm_min&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/numpunct&quot;,
&quot;name&quot;: &quot;std::numpunct&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/numpunct&quot;,
&quot;/~numpunct&quot;,
&quot;/decimal_point&quot;,
&quot;/thousands_sep&quot;,
&quot;/grouping&quot;,
&quot;/truefalsename&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/numpunct_byname&quot;,
&quot;name&quot;: &quot;std::numpunct_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/numpunct_byname&quot;,
&quot;/~numpunct_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/once_flag&quot;,
&quot;name&quot;: &quot;std::once_flag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/optional&quot;,
&quot;name&quot;: &quot;std::optional&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/optional&quot;,
&quot;/~optional&quot;,
&quot;/operator=&quot;,
&quot;/operator*&quot;,
&quot;/operator_bool&quot;,
&quot;/value&quot;,
&quot;/value_or&quot;,
&quot;/swap&quot;,
&quot;/emplace&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/ostream_iterator&quot;,
&quot;name&quot;: &quot;std::ostream_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/ostreambuf_iterator&quot;,
&quot;name&quot;: &quot;std::ostreambuf_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/out_of_range&quot;,
&quot;name&quot;: &quot;std::out_of_range&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_tags&quot;,
&quot;name&quot;: &quot;std::output_iterator_tag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/overflow_error&quot;,
&quot;name&quot;: &quot;std::overflow_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/owner_less&quot;,
&quot;name&quot;: &quot;std::owner_less&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/packaged_task&quot;,
&quot;name&quot;: &quot;std::packaged_task&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/packaged_task&quot;,
&quot;/~packaged_task&quot;,
&quot;/operator=&quot;,
&quot;/valid&quot;,
&quot;/swap&quot;,
&quot;/get_future&quot;,
&quot;/operator()&quot;,
&quot;/make_ready_at_thread_exit&quot;,
&quot;/reset&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/pair&quot;,
&quot;name&quot;: &quot;std::pair&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/pair&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/get&quot;,
&quot;/tuple_size&quot;,
&quot;/tuple_element&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution&quot;,
&quot;name&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/piecewise_constant_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/piecewise_construct_t&quot;,
&quot;name&quot;: &quot;std::piecewise_construct_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution&quot;,
&quot;name&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/piecewise_linear_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/placeholders&quot;,
&quot;name&quot;: &quot;std::placeholders&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/plus&quot;,
&quot;name&quot;: &quot;std::plus&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/gc/pointer_safety&quot;,
&quot;name&quot;: &quot;std::pointer_safety&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/pointer_traits&quot;,
&quot;name&quot;: &quot;std::pointer_traits&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/pointer_to&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/poisson_distribution&quot;,
&quot;name&quot;: &quot;std::poisson_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/poisson_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/mean&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/priority_queue&quot;,
&quot;name&quot;: &quot;std::priority_queue&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/priority_queue&quot;,
&quot;/~priority_queue&quot;,
&quot;/operator=&quot;,
&quot;/top&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/push&quot;,
&quot;/emplace&quot;,
&quot;/pop&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/promise&quot;,
&quot;name&quot;: &quot;std::promise&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/promise&quot;,
&quot;/~promise&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/get_future&quot;,
&quot;/set_value&quot;,
&quot;/set_value_at_thread_exit&quot;,
&quot;/set_exception&quot;,
&quot;/set_exception_at_thread_exit&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/queue&quot;,
&quot;name&quot;: &quot;std::queue&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/queue&quot;,
&quot;/~queue&quot;,
&quot;/operator=&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/push&quot;,
&quot;/emplace&quot;,
&quot;/pop&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/iterator_tags&quot;,
&quot;name&quot;: &quot;std::random_access_iterator_tag&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/random_device&quot;,
&quot;name&quot;: &quot;std::random_device&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/random_device&quot;,
&quot;/operator()&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/entropy&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/range_error&quot;,
&quot;name&quot;: &quot;std::range_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/rank&quot;,
&quot;name&quot;: &quot;std::rank&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio&quot;,
&quot;name&quot;: &quot;std::ratio&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_add&quot;,
&quot;name&quot;: &quot;std::ratio_add&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_divide&quot;,
&quot;name&quot;: &quot;std::ratio_divide&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_equal&quot;,
&quot;name&quot;: &quot;std::ratio_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_greater&quot;,
&quot;name&quot;: &quot;std::ratio_greater&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_greater_equal&quot;,
&quot;name&quot;: &quot;std::ratio_greater_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_less&quot;,
&quot;name&quot;: &quot;std::ratio_less&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_less_equal&quot;,
&quot;name&quot;: &quot;std::ratio_less_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_multiply&quot;,
&quot;name&quot;: &quot;std::ratio_multiply&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_not_equal&quot;,
&quot;name&quot;: &quot;std::ratio_not_equal&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/ratio/ratio_subtract&quot;,
&quot;name&quot;: &quot;std::ratio_subtract&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/raw_storage_iterator&quot;,
&quot;name&quot;: &quot;std::raw_storage_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/raw_storage_iterator&quot;,
&quot;/operator*&quot;,
&quot;/operator=&quot;,
&quot;/operator++&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/recursive_mutex&quot;,
&quot;name&quot;: &quot;std::recursive_mutex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/recursive_mutex&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/unlock&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/recursive_timed_mutex&quot;,
&quot;name&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/recursive_timed_mutex&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/try_lock_for&quot;,
&quot;/try_lock_until&quot;,
&quot;/unlock&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/reference_wrapper&quot;,
&quot;name&quot;: &quot;std::reference_wrapper&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/reference_wrapper&quot;,
&quot;/operator=&quot;,
&quot;/get&quot;,
&quot;/operator()&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_backref&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_badbrace&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_badrepeat&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_brace&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_brack&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_collate&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_complexity&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_ctype&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_escape&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_paren&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_range&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_space&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_stack&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/error_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::error_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/match_flag_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::match_flag_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/syntax_option_type&quot;,
&quot;name&quot;: &quot;std::regex_constants::syntax_option_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/regex_error&quot;,
&quot;name&quot;: &quot;std::regex_error&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/regex_error&quot;,
&quot;/code&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/regex_iterator&quot;,
&quot;name&quot;: &quot;std::regex_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/regex_iterator&quot;,
&quot;/operator=&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator*&quot;,
&quot;/operator_arith&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/regex_token_iterator&quot;,
&quot;name&quot;: &quot;std::regex_token_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/regex_token_iterator&quot;,
&quot;/operator=&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator*&quot;,
&quot;/operator_arith&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/regex_traits&quot;,
&quot;name&quot;: &quot;std::regex_traits&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/regex_traits&quot;,
&quot;/length&quot;,
&quot;/translate&quot;,
&quot;/translate_nocase&quot;,
&quot;/transform&quot;,
&quot;/transform_primary&quot;,
&quot;/lookup_collatename&quot;,
&quot;/lookup_classname&quot;,
&quot;/isctype&quot;,
&quot;/value&quot;,
&quot;/imbue&quot;,
&quot;/getloc&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_all_extents&quot;,
&quot;name&quot;: &quot;std::remove_all_extents&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_cv&quot;,
&quot;name&quot;: &quot;std::remove_const&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_cv&quot;,
&quot;name&quot;: &quot;std::remove_cv&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_extent&quot;,
&quot;name&quot;: &quot;std::remove_extent&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_pointer&quot;,
&quot;name&quot;: &quot;std::remove_pointer&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_reference&quot;,
&quot;name&quot;: &quot;std::remove_reference&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/remove_cv&quot;,
&quot;name&quot;: &quot;std::remove_volatile&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/result_of&quot;,
&quot;name&quot;: &quot;std::result_of&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/iterator/reverse_iterator&quot;,
&quot;name&quot;: &quot;std::reverse_iterator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/runtime_error&quot;,
&quot;name&quot;: &quot;std::runtime_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/scoped_allocator_adaptor&quot;,
&quot;name&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/scoped_allocator_adaptor&quot;,
&quot;/~scoped_allocator_adaptor&quot;,
&quot;/inner_allocator&quot;,
&quot;/outer_allocator&quot;,
&quot;/allocate&quot;,
&quot;/deallocate&quot;,
&quot;/max_size&quot;,
&quot;/construct&quot;,
&quot;/destroy&quot;,
&quot;/select_on_container_copy_construction&quot;,
&quot;/operator_cmp&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/seed_seq&quot;,
&quot;name&quot;: &quot;std::seed_seq&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/seed_seq&quot;,
&quot;/generate&quot;,
&quot;/size&quot;,
&quot;/param&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/set&quot;,
&quot;name&quot;: &quot;std::set&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/set&quot;,
&quot;/~set&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/lower_bound&quot;,
&quot;/upper_bound&quot;,
&quot;/key_comp&quot;,
&quot;/value_comp&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/shared_future&quot;,
&quot;name&quot;: &quot;std::shared_future&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/shared_future&quot;,
&quot;/~shared_future&quot;,
&quot;/operator=&quot;,
&quot;/get&quot;,
&quot;/valid&quot;,
&quot;/wait&quot;,
&quot;/wait_for&quot;,
&quot;/wait_until&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/shared_lock&quot;,
&quot;name&quot;: &quot;std::shared_lock&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/shared_lock&quot;,
&quot;/~shared_lock&quot;,
&quot;/operator=&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/try_lock_for&quot;,
&quot;/try_lock_until&quot;,
&quot;/unlock&quot;,
&quot;/swap&quot;,
&quot;/release&quot;,
&quot;/mutex&quot;,
&quot;/owns_lock&quot;,
&quot;/operator bool&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/shared_mutex&quot;,
&quot;name&quot;: &quot;std::shared_mutex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/shared_mutex&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/try_lock_for&quot;,
&quot;/try_lock_until&quot;,
&quot;/unlock&quot;,
&quot;/lock_shared&quot;,
&quot;/try_lock_shared&quot;,
&quot;/try_lock_shared_for&quot;,
&quot;/try_lock_shared_until&quot;,
&quot;/unlock_shared&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/shared_ptr&quot;,
&quot;name&quot;: &quot;std::shared_ptr&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/shared_ptr&quot;,
&quot;/~shared_ptr&quot;,
&quot;/operator=&quot;,
&quot;/reset&quot;,
&quot;/swap&quot;,
&quot;/get&quot;,
&quot;/operator*&quot;,
&quot;/unique&quot;,
&quot;/operator bool&quot;,
&quot;/owner_before&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltlt&quot;,
&quot;/swap2&quot;,
&quot;/get_deleter&quot;,
&quot;/atomic&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/shuffle_order_engine&quot;,
&quot;name&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/shuffle_order_engine&quot;,
&quot;/seed&quot;,
&quot;/base&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/stack&quot;,
&quot;name&quot;: &quot;std::stack&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/stack&quot;,
&quot;/~stack&quot;,
&quot;/operator=&quot;,
&quot;/top&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/push&quot;,
&quot;/emplace&quot;,
&quot;/pop&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/student_t_distribution&quot;,
&quot;name&quot;: &quot;std::student_t_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/student_t_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/n&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/regex/sub_match&quot;,
&quot;name&quot;: &quot;std::sub_match&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/sub_match&quot;,
&quot;/length&quot;,
&quot;/str&quot;,
&quot;/compare&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine&quot;,
&quot;name&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/subtract_with_carry_engine&quot;,
&quot;/seed&quot;,
&quot;/operator()&quot;,
&quot;/discard&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/system_error&quot;,
&quot;name&quot;: &quot;std::system_error&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/system_error&quot;,
&quot;/code&quot;,
&quot;/what&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/thread&quot;,
&quot;name&quot;: &quot;std::thread&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/thread&quot;,
&quot;/~thread&quot;,
&quot;/operator=&quot;,
&quot;/joinable&quot;,
&quot;/get_id&quot;,
&quot;/native_handle&quot;,
&quot;/hardware_concurrency&quot;,
&quot;/join&quot;,
&quot;/detach&quot;,
&quot;/swap&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/thread/id&quot;,
&quot;name&quot;: &quot;std::thread::id&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/id&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltlt&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_base&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_base::dateorder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_get&quot;,
&quot;name&quot;: &quot;std::time_get&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/time_get&quot;,
&quot;/~time_get&quot;,
&quot;/date_order&quot;,
&quot;/get_time&quot;,
&quot;/get_date&quot;,
&quot;/get_weekday&quot;,
&quot;/get_monthname&quot;,
&quot;/get_year&quot;,
&quot;/get&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_get::dateorder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_get_byname&quot;,
&quot;name&quot;: &quot;std::time_get_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/time_get_byname&quot;,
&quot;/~time_get_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_get_byname::dateorder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_put&quot;,
&quot;name&quot;: &quot;std::time_put&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/time_put&quot;,
&quot;/~time_put&quot;,
&quot;/put&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_put::dateorder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_put_byname&quot;,
&quot;name&quot;: &quot;std::time_put_byname&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/time_put_byname&quot;,
&quot;/~time_put_byname&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/time_base&quot;,
&quot;name&quot;: &quot;std::time_put_byname::dateorder&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/timed_mutex&quot;,
&quot;name&quot;: &quot;std::timed_mutex&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/timed_mutex&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/try_lock_for&quot;,
&quot;/try_lock_until&quot;,
&quot;/unlock&quot;,
&quot;/native_handle&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/chrono/c/tm&quot;,
&quot;name&quot;: &quot;std::tm&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/lock_tag_t&quot;,
&quot;name&quot;: &quot;std::try_to_lock_t&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/tuple&quot;,
&quot;name&quot;: &quot;std::tuple&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/tuple&quot;,
&quot;/operator=&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/get&quot;,
&quot;/tuple_size&quot;,
&quot;/tuple_element&quot;,
&quot;/uses_allocator&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/type_index&quot;,
&quot;name&quot;: &quot;std::type_index&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/type_index&quot;,
&quot;/operator_cmp&quot;,
&quot;/hash_code&quot;,
&quot;/name&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/type_info&quot;,
&quot;name&quot;: &quot;std::type_info&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/operator_cmp&quot;,
&quot;/before&quot;,
&quot;/hash_code&quot;,
&quot;/name&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/unary_function&quot;,
&quot;name&quot;: &quot;std::unary_function&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/functional/unary_negate&quot;,
&quot;name&quot;: &quot;std::unary_negate&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unary_negate&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/error/underflow_error&quot;,
&quot;name&quot;: &quot;std::underflow_error&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/types/underlying_type&quot;,
&quot;name&quot;: &quot;std::underlying_type&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/uniform_int_distribution&quot;,
&quot;name&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/uniform_int_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/uniform_real_distribution&quot;,
&quot;name&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/uniform_real_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/thread/unique_lock&quot;,
&quot;name&quot;: &quot;std::unique_lock&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unique_lock&quot;,
&quot;/~unique_lock&quot;,
&quot;/operator=&quot;,
&quot;/lock&quot;,
&quot;/try_lock&quot;,
&quot;/try_lock_for&quot;,
&quot;/try_lock_until&quot;,
&quot;/unlock&quot;,
&quot;/swap&quot;,
&quot;/release&quot;,
&quot;/mutex&quot;,
&quot;/owns_lock&quot;,
&quot;/operator bool&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/unique_ptr&quot;,
&quot;name&quot;: &quot;std::unique_ptr&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unique_ptr&quot;,
&quot;/~unique_ptr&quot;,
&quot;/operator=&quot;,
&quot;/release&quot;,
&quot;/reset&quot;,
&quot;/swap&quot;,
&quot;/get&quot;,
&quot;/get_deleter&quot;,
&quot;/operator*&quot;,
&quot;/operator bool&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;,
&quot;/hash&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/unordered_map&quot;,
&quot;name&quot;: &quot;std::unordered_map&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unordered_map&quot;,
&quot;/~unordered_map&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/begin2&quot;,
&quot;/end2&quot;,
&quot;/bucket_count&quot;,
&quot;/max_bucket_count&quot;,
&quot;/bucket_size&quot;,
&quot;/bucket&quot;,
&quot;/load_factor&quot;,
&quot;/max_load_factor&quot;,
&quot;/reserve&quot;,
&quot;/rehash&quot;,
&quot;/hash_function&quot;,
&quot;/key_eq&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/unordered_multimap&quot;,
&quot;name&quot;: &quot;std::unordered_multimap&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unordered_multimap&quot;,
&quot;/~unordered_multimap&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/begin2&quot;,
&quot;/end2&quot;,
&quot;/bucket_count&quot;,
&quot;/max_bucket_count&quot;,
&quot;/bucket_size&quot;,
&quot;/bucket&quot;,
&quot;/load_factor&quot;,
&quot;/max_load_factor&quot;,
&quot;/reserve&quot;,
&quot;/rehash&quot;,
&quot;/hash_function&quot;,
&quot;/key_eq&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/unordered_multiset&quot;,
&quot;name&quot;: &quot;std::unordered_multiset&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unordered_multiset&quot;,
&quot;/~unordered_multiset&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/begin2&quot;,
&quot;/end2&quot;,
&quot;/bucket_count&quot;,
&quot;/max_bucket_count&quot;,
&quot;/bucket_size&quot;,
&quot;/bucket&quot;,
&quot;/load_factor&quot;,
&quot;/max_load_factor&quot;,
&quot;/reserve&quot;,
&quot;/rehash&quot;,
&quot;/hash_function&quot;,
&quot;/key_eq&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/unordered_set&quot;,
&quot;name&quot;: &quot;std::unordered_set&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/unordered_set&quot;,
&quot;/~unordered_set&quot;,
&quot;/operator=&quot;,
&quot;/get_allocator&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/emplace_hint&quot;,
&quot;/erase&quot;,
&quot;/swap&quot;,
&quot;/count&quot;,
&quot;/find&quot;,
&quot;/equal_range&quot;,
&quot;/begin2&quot;,
&quot;/end2&quot;,
&quot;/bucket_count&quot;,
&quot;/max_bucket_count&quot;,
&quot;/bucket_size&quot;,
&quot;/bucket&quot;,
&quot;/load_factor&quot;,
&quot;/max_load_factor&quot;,
&quot;/reserve&quot;,
&quot;/rehash&quot;,
&quot;/hash_function&quot;,
&quot;/key_eq&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/uses_allocator&quot;,
&quot;name&quot;: &quot;std::uses_allocator&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/valarray&quot;,
&quot;name&quot;: &quot;std::valarray&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/container/vector&quot;,
&quot;name&quot;: &quot;std::vector&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/vector&quot;,
&quot;/~vector&quot;,
&quot;/operator=&quot;,
&quot;/assign&quot;,
&quot;/get_allocator&quot;,
&quot;/at&quot;,
&quot;/operator_at&quot;,
&quot;/front&quot;,
&quot;/back&quot;,
&quot;/data&quot;,
&quot;/begin&quot;,
&quot;/end&quot;,
&quot;/rbegin&quot;,
&quot;/rend&quot;,
&quot;/empty&quot;,
&quot;/size&quot;,
&quot;/max_size&quot;,
&quot;/reserve&quot;,
&quot;/capacity&quot;,
&quot;/shrink_to_fit&quot;,
&quot;/clear&quot;,
&quot;/insert&quot;,
&quot;/emplace&quot;,
&quot;/erase&quot;,
&quot;/push_back&quot;,
&quot;/emplace_back&quot;,
&quot;/pop_back&quot;,
&quot;/resize&quot;,
&quot;/swap&quot;,
&quot;/operator_cmp&quot;,
&quot;/swap2&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/wbuffer_convert&quot;,
&quot;name&quot;: &quot;std::wbuffer_convert&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/wbuffer_convert&quot;,
&quot;/~wbuffer_convert&quot;,
&quot;/rdbuf&quot;,
&quot;/state&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::wcerr&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_istream&quot;,
&quot;name&quot;: &quot;std::wcin&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::wclog&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/io/basic_ostream&quot;,
&quot;name&quot;: &quot;std::wcout&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/memory/weak_ptr&quot;,
&quot;name&quot;: &quot;std::weak_ptr&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/weak_ptr&quot;,
&quot;/~weak_ptr&quot;,
&quot;/operator=&quot;,
&quot;/reset&quot;,
&quot;/swap&quot;,
&quot;/use_count&quot;,
&quot;/expired&quot;,
&quot;/lock&quot;,
&quot;/owner_before&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/numeric/random/weibull_distribution&quot;,
&quot;name&quot;: &quot;std::weibull_distribution&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/weibull_distribution&quot;,
&quot;/reset&quot;,
&quot;/operator()&quot;,
&quot;/params&quot;,
&quot;/param&quot;,
&quot;/min&quot;,
&quot;/max&quot;,
&quot;/operator_cmp&quot;,
&quot;/operator_ltltgtgt&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/locale/wstring_convert&quot;,
&quot;name&quot;: &quot;std::wstring_convert&quot;,
&quot;urls&quot;: [
&quot;&quot;,
&quot;/wstring_convert&quot;,
&quot;/~wstring_convert&quot;,
&quot;/from_bytes&quot;,
&quot;/to_bytes&quot;,
&quot;/converted&quot;,
&quot;/state&quot;
]
},
{
&quot;base_url&quot;: &quot;cpp/utility/variadic/va_list&quot;,
&quot;name&quot;: &quot;va_list&quot;,
&quot;urls&quot;: [
&quot;&quot;
]
}
],
&quot;links&quot;: [
{
&quot;string&quot;: &quot;std::accumulate&quot;,
&quot;target&quot;: &quot;cpp/algorithm/accumulate&quot;
},
{
&quot;string&quot;: &quot;std::adjacent_difference&quot;,
&quot;target&quot;: &quot;cpp/algorithm/adjacent_difference&quot;
},
{
&quot;string&quot;: &quot;std::adjacent_find&quot;,
&quot;target&quot;: &quot;cpp/algorithm/adjacent_find&quot;
},
{
&quot;string&quot;: &quot;std::all_of&quot;,
&quot;target&quot;: &quot;cpp/algorithm/all_any_none_of&quot;
},
{
&quot;string&quot;: &quot;std::any_of&quot;,
&quot;target&quot;: &quot;cpp/algorithm/all_any_none_of&quot;
},
{
&quot;string&quot;: &quot;std::none_of&quot;,
&quot;target&quot;: &quot;cpp/algorithm/all_any_none_of&quot;
},
{
&quot;string&quot;: &quot;std::binary_search&quot;,
&quot;target&quot;: &quot;cpp/algorithm/binary_search&quot;
},
{
&quot;string&quot;: &quot;std::bsearch&quot;,
&quot;target&quot;: &quot;cpp/algorithm/bsearch&quot;
},
{
&quot;string&quot;: &quot;std::copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/copy&quot;
},
{
&quot;string&quot;: &quot;std::copy_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/copy&quot;
},
{
&quot;string&quot;: &quot;std::copy_backward&quot;,
&quot;target&quot;: &quot;cpp/algorithm/copy_backward&quot;
},
{
&quot;string&quot;: &quot;std::copy_n&quot;,
&quot;target&quot;: &quot;cpp/algorithm/copy_n&quot;
},
{
&quot;string&quot;: &quot;std::count&quot;,
&quot;target&quot;: &quot;cpp/algorithm/count&quot;
},
{
&quot;string&quot;: &quot;std::count_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/count&quot;
},
{
&quot;string&quot;: &quot;std::equal&quot;,
&quot;target&quot;: &quot;cpp/algorithm/equal&quot;
},
{
&quot;string&quot;: &quot;std::equal_range&quot;,
&quot;target&quot;: &quot;cpp/algorithm/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::fill&quot;,
&quot;target&quot;: &quot;cpp/algorithm/fill&quot;
},
{
&quot;string&quot;: &quot;std::fill_n&quot;,
&quot;target&quot;: &quot;cpp/algorithm/fill_n&quot;
},
{
&quot;string&quot;: &quot;std::find&quot;,
&quot;target&quot;: &quot;cpp/algorithm/find&quot;
},
{
&quot;string&quot;: &quot;std::find_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/find&quot;
},
{
&quot;string&quot;: &quot;std::find_if_not&quot;,
&quot;target&quot;: &quot;cpp/algorithm/find&quot;
},
{
&quot;string&quot;: &quot;std::find_end&quot;,
&quot;target&quot;: &quot;cpp/algorithm/find_end&quot;
},
{
&quot;string&quot;: &quot;std::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/algorithm/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::for_each&quot;,
&quot;target&quot;: &quot;cpp/algorithm/for_each&quot;
},
{
&quot;string&quot;: &quot;std::generate&quot;,
&quot;target&quot;: &quot;cpp/algorithm/generate&quot;
},
{
&quot;string&quot;: &quot;std::generate_n&quot;,
&quot;target&quot;: &quot;cpp/algorithm/generate_n&quot;
},
{
&quot;string&quot;: &quot;std::includes&quot;,
&quot;target&quot;: &quot;cpp/algorithm/includes&quot;
},
{
&quot;string&quot;: &quot;std::inner_product&quot;,
&quot;target&quot;: &quot;cpp/algorithm/inner_product&quot;
},
{
&quot;string&quot;: &quot;std::inplace_merge&quot;,
&quot;target&quot;: &quot;cpp/algorithm/inplace_merge&quot;
},
{
&quot;string&quot;: &quot;std::iota&quot;,
&quot;target&quot;: &quot;cpp/algorithm/iota&quot;
},
{
&quot;string&quot;: &quot;std::is_heap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_heap&quot;
},
{
&quot;string&quot;: &quot;std::is_heap_until&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_heap_until&quot;
},
{
&quot;string&quot;: &quot;std::is_partitioned&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_partitioned&quot;
},
{
&quot;string&quot;: &quot;std::is_permutation&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_permutation&quot;
},
{
&quot;string&quot;: &quot;std::is_sorted&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_sorted&quot;
},
{
&quot;string&quot;: &quot;std::is_sorted_until&quot;,
&quot;target&quot;: &quot;cpp/algorithm/is_sorted_until&quot;
},
{
&quot;string&quot;: &quot;std::iter_swap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/iter_swap&quot;
},
{
&quot;string&quot;: &quot;std::lexicographical_compare&quot;,
&quot;target&quot;: &quot;cpp/algorithm/lexicographical_compare&quot;
},
{
&quot;string&quot;: &quot;std::lower_bound&quot;,
&quot;target&quot;: &quot;cpp/algorithm/lower_bound&quot;
},
{
&quot;string&quot;: &quot;std::make_heap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/make_heap&quot;
},
{
&quot;string&quot;: &quot;std::max&quot;,
&quot;target&quot;: &quot;cpp/algorithm/max&quot;
},
{
&quot;string&quot;: &quot;std::max_element&quot;,
&quot;target&quot;: &quot;cpp/algorithm/max_element&quot;
},
{
&quot;string&quot;: &quot;std::merge&quot;,
&quot;target&quot;: &quot;cpp/algorithm/merge&quot;
},
{
&quot;string&quot;: &quot;std::min&quot;,
&quot;target&quot;: &quot;cpp/algorithm/min&quot;
},
{
&quot;string&quot;: &quot;std::min_element&quot;,
&quot;target&quot;: &quot;cpp/algorithm/min_element&quot;
},
{
&quot;string&quot;: &quot;std::minmax&quot;,
&quot;target&quot;: &quot;cpp/algorithm/minmax&quot;
},
{
&quot;string&quot;: &quot;std::minmax_element&quot;,
&quot;target&quot;: &quot;cpp/algorithm/minmax_element&quot;
},
{
&quot;string&quot;: &quot;std::mismatch&quot;,
&quot;target&quot;: &quot;cpp/algorithm/mismatch&quot;
},
{
&quot;string&quot;: &quot;std::move&quot;,
&quot;target&quot;: &quot;cpp/algorithm/move&quot;
},
{
&quot;string&quot;: &quot;std::move_backward&quot;,
&quot;target&quot;: &quot;cpp/algorithm/move_backward&quot;
},
{
&quot;string&quot;: &quot;std::next_permutation&quot;,
&quot;target&quot;: &quot;cpp/algorithm/next_permutation&quot;
},
{
&quot;string&quot;: &quot;std::nth_element&quot;,
&quot;target&quot;: &quot;cpp/algorithm/nth_element&quot;
},
{
&quot;string&quot;: &quot;std::partial_sort&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partial_sort&quot;
},
{
&quot;string&quot;: &quot;std::partial_sort_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partial_sort_copy&quot;
},
{
&quot;string&quot;: &quot;std::partial_sum&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partial_sum&quot;
},
{
&quot;string&quot;: &quot;std::partition&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partition&quot;
},
{
&quot;string&quot;: &quot;std::partition_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partition_copy&quot;
},
{
&quot;string&quot;: &quot;std::partition_point&quot;,
&quot;target&quot;: &quot;cpp/algorithm/partition_point&quot;
},
{
&quot;string&quot;: &quot;std::pop_heap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/pop_heap&quot;
},
{
&quot;string&quot;: &quot;std::prev_permutation&quot;,
&quot;target&quot;: &quot;cpp/algorithm/prev_permutation&quot;
},
{
&quot;string&quot;: &quot;std::push_heap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/push_heap&quot;
},
{
&quot;string&quot;: &quot;std::qsort&quot;,
&quot;target&quot;: &quot;cpp/algorithm/qsort&quot;
},
{
&quot;string&quot;: &quot;std::random_shuffle&quot;,
&quot;target&quot;: &quot;cpp/algorithm/random_shuffle&quot;
},
{
&quot;string&quot;: &quot;std::shuffle&quot;,
&quot;target&quot;: &quot;cpp/algorithm/random_shuffle&quot;
},
{
&quot;string&quot;: &quot;std::remove&quot;,
&quot;target&quot;: &quot;cpp/algorithm/remove&quot;
},
{
&quot;string&quot;: &quot;std::remove_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/remove&quot;
},
{
&quot;string&quot;: &quot;std::remove_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/remove_copy&quot;
},
{
&quot;string&quot;: &quot;std::remove_copy_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/remove_copy&quot;
},
{
&quot;string&quot;: &quot;std::replace&quot;,
&quot;target&quot;: &quot;cpp/algorithm/replace&quot;
},
{
&quot;string&quot;: &quot;std::replace_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/replace&quot;
},
{
&quot;string&quot;: &quot;std::replace_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/replace_copy&quot;
},
{
&quot;string&quot;: &quot;std::replace_copy_if&quot;,
&quot;target&quot;: &quot;cpp/algorithm/replace_copy&quot;
},
{
&quot;string&quot;: &quot;std::reverse&quot;,
&quot;target&quot;: &quot;cpp/algorithm/reverse&quot;
},
{
&quot;string&quot;: &quot;std::reverse_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/reverse_copy&quot;
},
{
&quot;string&quot;: &quot;std::rotate&quot;,
&quot;target&quot;: &quot;cpp/algorithm/rotate&quot;
},
{
&quot;string&quot;: &quot;std::rotate_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/rotate_copy&quot;
},
{
&quot;string&quot;: &quot;std::search&quot;,
&quot;target&quot;: &quot;cpp/algorithm/search&quot;
},
{
&quot;string&quot;: &quot;std::search_n&quot;,
&quot;target&quot;: &quot;cpp/algorithm/search_n&quot;
},
{
&quot;string&quot;: &quot;std::set_difference&quot;,
&quot;target&quot;: &quot;cpp/algorithm/set_difference&quot;
},
{
&quot;string&quot;: &quot;std::set_intersection&quot;,
&quot;target&quot;: &quot;cpp/algorithm/set_intersection&quot;
},
{
&quot;string&quot;: &quot;std::set_symmetric_difference&quot;,
&quot;target&quot;: &quot;cpp/algorithm/set_symmetric_difference&quot;
},
{
&quot;string&quot;: &quot;std::set_union&quot;,
&quot;target&quot;: &quot;cpp/algorithm/set_union&quot;
},
{
&quot;string&quot;: &quot;std::sort&quot;,
&quot;target&quot;: &quot;cpp/algorithm/sort&quot;
},
{
&quot;string&quot;: &quot;std::sort_heap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/sort_heap&quot;
},
{
&quot;string&quot;: &quot;std::stable_partition&quot;,
&quot;target&quot;: &quot;cpp/algorithm/stable_partition&quot;
},
{
&quot;string&quot;: &quot;std::stable_sort&quot;,
&quot;target&quot;: &quot;cpp/algorithm/stable_sort&quot;
},
{
&quot;string&quot;: &quot;std::swap&quot;,
&quot;target&quot;: &quot;cpp/algorithm/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap_ranges&quot;,
&quot;target&quot;: &quot;cpp/algorithm/swap_ranges&quot;
},
{
&quot;string&quot;: &quot;std::transform&quot;,
&quot;target&quot;: &quot;cpp/algorithm/transform&quot;
},
{
&quot;string&quot;: &quot;std::unique&quot;,
&quot;target&quot;: &quot;cpp/algorithm/unique&quot;
},
{
&quot;string&quot;: &quot;std::unique_copy&quot;,
&quot;target&quot;: &quot;cpp/algorithm/unique_copy&quot;
},
{
&quot;string&quot;: &quot;std::upper_bound&quot;,
&quot;target&quot;: &quot;cpp/algorithm/upper_bound&quot;
},
{
&quot;string&quot;: &quot;ATOMIC_FLAG_INIT&quot;,
&quot;target&quot;: &quot;cpp/atomic/ATOMIC_FLAG_INIT&quot;
},
{
&quot;string&quot;: &quot;ATOMIC_VAR_INIT&quot;,
&quot;target&quot;: &quot;cpp/atomic/ATOMIC_VAR_INIT&quot;
},
{
&quot;string&quot;: &quot;std::atomic&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic::atomic&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic::compare_exchange_strong&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/compare_exchange&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;compare_exchange_strong&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic::compare_exchange_weak&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/compare_exchange&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;compare_exchange_weak&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic::exchange&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/exchange&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;exchange&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic::fetch_add&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_add&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;fetch_add&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic::fetch_and&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_and&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;fetch_and&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_and&quot;
},
{
&quot;string&quot;: &quot;std::atomic::fetch_or&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_or&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;fetch_or&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_or&quot;
},
{
&quot;string&quot;: &quot;std::atomic::fetch_sub&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_sub&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;fetch_sub&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_sub&quot;
},
{
&quot;string&quot;: &quot;std::atomic::fetch_xor&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_xor&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;fetch_xor&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/fetch_xor&quot;
},
{
&quot;string&quot;: &quot;std::atomic::is_lock_free&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/is_lock_free&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;is_lock_free&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/is_lock_free&quot;
},
{
&quot;string&quot;: &quot;std::atomic::load&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/load&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;load&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/load&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator T&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator T&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator T&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator T&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator=&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator++&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator++&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator--&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator--&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator+=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator+=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator-=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator-=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator&amp;=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator&amp;=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator|=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator|=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::atomic::operator^=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;operator^=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::atomic::store&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/store&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic&quot;,
&quot;string&quot;: &quot;store&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic/store&quot;
},
{
&quot;string&quot;: &quot;std::atomic_compare_exchange_weak&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_compare_exchange_weak_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_compare_exchange_strong&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_compare_exchange_strong_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_compare_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_exchange&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_exchange_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_exchange&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_add&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_add_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_sub&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_sub_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_or&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_or_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_xor&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_xor_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_add&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_and&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_sub&quot;
},
{
&quot;string&quot;: &quot;std::atomic_fetch_and_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_fetch_sub&quot;
},
{
&quot;string&quot;: &quot;std::atomic_flag&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag&quot;
},
{
&quot;string&quot;: &quot;std::atomic_flag::atomic_flag&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/atomic_flag&quot;
},
{
&quot;string&quot;: &quot;std::atomic_flag::clear&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic_flag&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/clear&quot;
},
{
&quot;string&quot;: &quot;std::atomic_flag::operator=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic_flag&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/operator=&quot;
},
{
&quot;string&quot;: &quot;std::atomic_flag::test_and_set&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/test_and_set&quot;
},
{
&quot;on_group&quot;: &quot;std::atomic_flag&quot;,
&quot;string&quot;: &quot;test_and_set&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_flag/test_and_set&quot;
},
{
&quot;string&quot;: &quot;std::atomic_init&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_init&quot;
},
{
&quot;string&quot;: &quot;std::atomic_is_lock_free&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_is_lock_free&quot;
},
{
&quot;string&quot;: &quot;std::atomic_load&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_load&quot;
},
{
&quot;string&quot;: &quot;std::atomic_load_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_load&quot;
},
{
&quot;string&quot;: &quot;std::atomic_signal_fence&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_signal_fence&quot;
},
{
&quot;string&quot;: &quot;std::atomic_store&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_store&quot;
},
{
&quot;string&quot;: &quot;std::atomic_store_explicit&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_store&quot;
},
{
&quot;string&quot;: &quot;std::atomic_thread_fence&quot;,
&quot;target&quot;: &quot;cpp/atomic/atomic_thread_fence&quot;
},
{
&quot;string&quot;: &quot;std::kill_dependency&quot;,
&quot;target&quot;: &quot;cpp/atomic/kill_dependency&quot;
},
{
&quot;string&quot;: &quot;std::memory_order&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_relaxed&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_consume&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_acquire&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_release&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_acq_rel&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;std::memory_order_seq_cst&quot;,
&quot;target&quot;: &quot;cpp/atomic/memory_order&quot;
},
{
&quot;string&quot;: &quot;CLOCKS_PER_SEC&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/CLOCKS_PER_SEC&quot;
},
{
&quot;string&quot;: &quot;std::asctime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/asctime&quot;
},
{
&quot;string&quot;: &quot;std::clock&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/clock&quot;
},
{
&quot;string&quot;: &quot;std::clock_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/clock_t&quot;
},
{
&quot;string&quot;: &quot;std::ctime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/ctime&quot;
},
{
&quot;string&quot;: &quot;std::difftime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/difftime&quot;
},
{
&quot;string&quot;: &quot;std::gmtime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/gmtime&quot;
},
{
&quot;string&quot;: &quot;std::localtime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/localtime&quot;
},
{
&quot;string&quot;: &quot;std::mktime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/mktime&quot;
},
{
&quot;string&quot;: &quot;std::strftime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/strftime&quot;
},
{
&quot;string&quot;: &quot;std::time&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/time&quot;
},
{
&quot;string&quot;: &quot;std::time_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/time_t&quot;
},
{
&quot;string&quot;: &quot;std::tm&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/tm&quot;
},
{
&quot;string&quot;: &quot;std::wcsftime&quot;,
&quot;target&quot;: &quot;cpp/chrono/c/wcsftime&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::duration&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::nanoseconds&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::microseconds&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::milliseconds&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::seconds&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::minutes&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::hours&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/common_type&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::count&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/count&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::duration&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::nanoseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::microseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::milliseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::seconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::minutes&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::hours&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration_cast&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/duration_cast&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator=&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator++&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator--&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator--(int)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator+=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator-=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator*=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator/=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::operator%=&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator*(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator/(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator%(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_arith4&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::duration)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::nanoseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::microseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::milliseconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::seconds)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::minutes)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::hours)&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::chrono::treat_as_floating_point&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/treat_as_floating_point&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration&quot;,
&quot;string&quot;: &quot;zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration::~duration&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::nanoseconds::~nanoseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::microseconds::~microseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::milliseconds::~milliseconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::seconds::~seconds&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::minutes::~minutes&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::hours::~hours&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration/~duration&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration_values&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration_values::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/max&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration_values&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration_values::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/min&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration_values&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::duration_values::zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/zero&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::duration_values&quot;,
&quot;string&quot;: &quot;zero&quot;,
&quot;target&quot;: &quot;cpp/chrono/duration_values/zero&quot;
},
{
&quot;string&quot;: &quot;std::chrono::high_resolution_clock&quot;,
&quot;target&quot;: &quot;cpp/chrono/high_resolution_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::high_resolution_clock::is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/high_resolution_clock&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::high_resolution_clock&quot;,
&quot;string&quot;: &quot;is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/high_resolution_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::high_resolution_clock::now&quot;,
&quot;target&quot;: &quot;cpp/chrono/high_resolution_clock/now&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::high_resolution_clock&quot;,
&quot;string&quot;: &quot;now&quot;,
&quot;target&quot;: &quot;cpp/chrono/high_resolution_clock/now&quot;
},
{
&quot;string&quot;: &quot;std::chrono::steady_clock&quot;,
&quot;target&quot;: &quot;cpp/chrono/steady_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::steady_clock::is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/steady_clock&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::steady_clock&quot;,
&quot;string&quot;: &quot;is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/steady_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::steady_clock::now&quot;,
&quot;target&quot;: &quot;cpp/chrono/steady_clock/now&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::steady_clock&quot;,
&quot;string&quot;: &quot;now&quot;,
&quot;target&quot;: &quot;cpp/chrono/steady_clock/now&quot;
},
{
&quot;string&quot;: &quot;std::chrono::system_clock&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::system_clock::is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::system_clock&quot;,
&quot;string&quot;: &quot;is_steady&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock&quot;
},
{
&quot;string&quot;: &quot;std::chrono::system_clock::from_time_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/from_time_t&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::system_clock&quot;,
&quot;string&quot;: &quot;from_time_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/from_time_t&quot;
},
{
&quot;string&quot;: &quot;std::chrono::system_clock::now&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/now&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::system_clock&quot;,
&quot;string&quot;: &quot;now&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/now&quot;
},
{
&quot;string&quot;: &quot;std::chrono::system_clock::to_time_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/to_time_t&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::system_clock&quot;,
&quot;string&quot;: &quot;to_time_t&quot;,
&quot;target&quot;: &quot;cpp/chrono/system_clock/to_time_t&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point&quot;
},
{
&quot;string&quot;: &quot;std::common_type&lt;std::chrono::time_point&gt;&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/common_type&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::max&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/max&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::time_point&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/max&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::min&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/min&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::time_point&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/min&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::time_point&quot;,
&quot;string&quot;: &quot;operator+&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::time_point&quot;,
&quot;string&quot;: &quot;operator-&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith&quot;
},
{
&quot;string&quot;: &quot;operator+(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;operator-(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::chrono::time_point)&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::time_point&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/time_point&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point_cast&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/time_point_cast&quot;
},
{
&quot;string&quot;: &quot;std::chrono::time_point::time_since_epoch&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/time_since_epoch&quot;
},
{
&quot;on_group&quot;: &quot;std::chrono::time_point&quot;,
&quot;string&quot;: &quot;time_since_epoch&quot;,
&quot;target&quot;: &quot;cpp/chrono/time_point/time_since_epoch&quot;
},
{
&quot;string&quot;: &quot;std::array&quot;,
&quot;target&quot;: &quot;cpp/container/array&quot;
},
{
&quot;string&quot;: &quot;std::array::at&quot;,
&quot;target&quot;: &quot;cpp/container/array/at&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/array/at&quot;
},
{
&quot;string&quot;: &quot;std::array::back&quot;,
&quot;target&quot;: &quot;cpp/container/array/back&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/array/back&quot;
},
{
&quot;string&quot;: &quot;std::array::begin&quot;,
&quot;target&quot;: &quot;cpp/container/array/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/array/begin&quot;
},
{
&quot;string&quot;: &quot;std::array::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/begin&quot;
},
{
&quot;string&quot;: &quot;std::array::data&quot;,
&quot;target&quot;: &quot;cpp/container/array/data&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;data&quot;,
&quot;target&quot;: &quot;cpp/container/array/data&quot;
},
{
&quot;string&quot;: &quot;std::array::empty&quot;,
&quot;target&quot;: &quot;cpp/container/array/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/array/empty&quot;
},
{
&quot;string&quot;: &quot;std::array::end&quot;,
&quot;target&quot;: &quot;cpp/container/array/end&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/array/end&quot;
},
{
&quot;string&quot;: &quot;std::array::cend&quot;,
&quot;target&quot;: &quot;cpp/container/array/end&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/array/end&quot;
},
{
&quot;string&quot;: &quot;std::array::fill&quot;,
&quot;target&quot;: &quot;cpp/container/array/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/container/array/fill&quot;
},
{
&quot;string&quot;: &quot;std::array::front&quot;,
&quot;target&quot;: &quot;cpp/container/array/front&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/array/front&quot;
},
{
&quot;string&quot;: &quot;std::get(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/get&quot;
},
{
&quot;string&quot;: &quot;std::array::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/array/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/array/max_size&quot;
},
{
&quot;string&quot;: &quot;std::array::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::array::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::array::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/array/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::array::rend&quot;,
&quot;target&quot;: &quot;cpp/container/array/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/array/rend&quot;
},
{
&quot;string&quot;: &quot;std::array::crend&quot;,
&quot;target&quot;: &quot;cpp/container/array/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/array/rend&quot;
},
{
&quot;string&quot;: &quot;std::array::size&quot;,
&quot;target&quot;: &quot;cpp/container/array/size&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/array/size&quot;
},
{
&quot;string&quot;: &quot;std::array::swap&quot;,
&quot;target&quot;: &quot;cpp/container/array/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::array&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/array/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::array)&quot;,
&quot;target&quot;: &quot;cpp/container/array/swap2&quot;
},
{
&quot;string&quot;: &quot;std::tuple_element&lt;std::array&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/array/tuple_element&quot;
},
{
&quot;string&quot;: &quot;std::tuple_size&lt;std::array&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/array/tuple_size&quot;
},
{
&quot;string&quot;: &quot;std::deque&quot;,
&quot;target&quot;: &quot;cpp/container/deque&quot;
},
{
&quot;string&quot;: &quot;std::deque::assign&quot;,
&quot;target&quot;: &quot;cpp/container/deque/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/container/deque/assign&quot;
},
{
&quot;string&quot;: &quot;std::deque::at&quot;,
&quot;target&quot;: &quot;cpp/container/deque/at&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/deque/at&quot;
},
{
&quot;string&quot;: &quot;std::deque::back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/back&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/back&quot;
},
{
&quot;string&quot;: &quot;std::deque::begin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/begin&quot;
},
{
&quot;string&quot;: &quot;std::deque::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/begin&quot;
},
{
&quot;string&quot;: &quot;std::deque::clear&quot;,
&quot;target&quot;: &quot;cpp/container/deque/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/deque/clear&quot;
},
{
&quot;string&quot;: &quot;std::deque::deque&quot;,
&quot;target&quot;: &quot;cpp/container/deque/deque&quot;
},
{
&quot;string&quot;: &quot;std::deque::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace&quot;
},
{
&quot;string&quot;: &quot;std::deque::emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace_back&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace_back&quot;
},
{
&quot;string&quot;: &quot;std::deque::emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace_front&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/emplace_front&quot;
},
{
&quot;string&quot;: &quot;std::deque::empty&quot;,
&quot;target&quot;: &quot;cpp/container/deque/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/deque/empty&quot;
},
{
&quot;string&quot;: &quot;std::deque::end&quot;,
&quot;target&quot;: &quot;cpp/container/deque/end&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/deque/end&quot;
},
{
&quot;string&quot;: &quot;std::deque::cend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/end&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/end&quot;
},
{
&quot;string&quot;: &quot;std::deque::erase&quot;,
&quot;target&quot;: &quot;cpp/container/deque/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/deque/erase&quot;
},
{
&quot;string&quot;: &quot;std::deque::front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/front&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/front&quot;
},
{
&quot;string&quot;: &quot;std::deque::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/deque/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/deque/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::deque::insert&quot;,
&quot;target&quot;: &quot;cpp/container/deque/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/deque/insert&quot;
},
{
&quot;string&quot;: &quot;std::deque::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/deque/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/deque/max_size&quot;
},
{
&quot;string&quot;: &quot;std::deque::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator=&quot;
},
{
&quot;string&quot;: &quot;std::deque::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::deque::pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/pop_back&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::deque::pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/pop_front&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/pop_front&quot;
},
{
&quot;string&quot;: &quot;std::deque::push_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/push_back&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;push_back&quot;,
&quot;target&quot;: &quot;cpp/container/deque/push_back&quot;
},
{
&quot;string&quot;: &quot;std::deque::push_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/push_front&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;push_front&quot;,
&quot;target&quot;: &quot;cpp/container/deque/push_front&quot;
},
{
&quot;string&quot;: &quot;std::deque::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::deque::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::deque::rend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rend&quot;
},
{
&quot;string&quot;: &quot;std::deque::crend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/deque/rend&quot;
},
{
&quot;string&quot;: &quot;std::deque::resize&quot;,
&quot;target&quot;: &quot;cpp/container/deque/resize&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;resize&quot;,
&quot;target&quot;: &quot;cpp/container/deque/resize&quot;
},
{
&quot;string&quot;: &quot;std::deque::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/container/deque/shrink_to_fit&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/container/deque/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::deque::size&quot;,
&quot;target&quot;: &quot;cpp/container/deque/size&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/deque/size&quot;
},
{
&quot;string&quot;: &quot;std::deque::swap&quot;,
&quot;target&quot;: &quot;cpp/container/deque/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::deque&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/deque/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::deque)&quot;,
&quot;target&quot;: &quot;cpp/container/deque/swap2&quot;
},
{
&quot;string&quot;: &quot;std::deque::~deque&quot;,
&quot;target&quot;: &quot;cpp/container/deque/~deque&quot;
},
{
&quot;string&quot;: &quot;std::dynarray&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::at&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/at&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/at&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::back&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/back&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/back&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::begin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/begin&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/begin&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::data&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/data&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;data&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/data&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::dynarray&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/dynarray&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::empty&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/empty&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::end&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/end&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/end&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::cend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/end&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/end&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::fill&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/fill&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::front&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/front&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/front&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/max_size&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::dynarray)&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::rend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rend&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::crend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/rend&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::size&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/size&quot;
},
{
&quot;on_group&quot;: &quot;std::dynarray&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/size&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::dynarray&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::dynarray::~dynarray&quot;,
&quot;target&quot;: &quot;cpp/container/dynarray/~dynarray&quot;
},
{
&quot;string&quot;: &quot;std::forward_list&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::assign&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/assign&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::before_begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/before_begin&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;before_begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/before_begin&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::cbefore_begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/before_begin&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;cbefore_begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/before_begin&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/begin&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/begin&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::clear&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/clear&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::emplace_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/emplace_after&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;emplace_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/emplace_after&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/emplace_front&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/emplace_front&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::empty&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/empty&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::end&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/end&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/end&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::cend&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/end&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/end&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::erase_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/erase_after&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;erase_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/erase_after&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::forward_list&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/forward_list&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/front&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/front&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::insert_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/insert_after&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;insert_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/insert_after&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/max_size&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::merge&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/merge&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;merge&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/merge&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/pop_front&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/pop_front&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::push_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/push_front&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;push_front&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/push_front&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::remove&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/remove&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;remove&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/remove&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::remove_if&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/remove&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;remove_if&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/remove&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::resize&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/resize&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;resize&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/resize&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::reverse&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/reverse&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;reverse&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/reverse&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::sort&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/sort&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;sort&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/sort&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::splice_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/splice_after&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;splice_after&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/splice_after&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::swap&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::forward_list)&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/swap2&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::unique&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/unique&quot;
},
{
&quot;on_group&quot;: &quot;std::forward_list&quot;,
&quot;string&quot;: &quot;unique&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/unique&quot;
},
{
&quot;string&quot;: &quot;std::forward_list::~forward_list&quot;,
&quot;target&quot;: &quot;cpp/container/forward_list/~forward_list&quot;
},
{
&quot;string&quot;: &quot;std::list&quot;,
&quot;target&quot;: &quot;cpp/container/list&quot;
},
{
&quot;string&quot;: &quot;std::list::assign&quot;,
&quot;target&quot;: &quot;cpp/container/list/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/container/list/assign&quot;
},
{
&quot;string&quot;: &quot;std::list::back&quot;,
&quot;target&quot;: &quot;cpp/container/list/back&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/list/back&quot;
},
{
&quot;string&quot;: &quot;std::list::begin&quot;,
&quot;target&quot;: &quot;cpp/container/list/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/list/begin&quot;
},
{
&quot;string&quot;: &quot;std::list::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/begin&quot;
},
{
&quot;string&quot;: &quot;std::list::clear&quot;,
&quot;target&quot;: &quot;cpp/container/list/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/list/clear&quot;
},
{
&quot;string&quot;: &quot;std::list::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace&quot;
},
{
&quot;string&quot;: &quot;std::list::emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace_back&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace_back&quot;
},
{
&quot;string&quot;: &quot;std::list::emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace_front&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;emplace_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/emplace_front&quot;
},
{
&quot;string&quot;: &quot;std::list::empty&quot;,
&quot;target&quot;: &quot;cpp/container/list/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/list/empty&quot;
},
{
&quot;string&quot;: &quot;std::list::end&quot;,
&quot;target&quot;: &quot;cpp/container/list/end&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/list/end&quot;
},
{
&quot;string&quot;: &quot;std::list::cend&quot;,
&quot;target&quot;: &quot;cpp/container/list/end&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/list/end&quot;
},
{
&quot;string&quot;: &quot;std::list::erase&quot;,
&quot;target&quot;: &quot;cpp/container/list/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/list/erase&quot;
},
{
&quot;string&quot;: &quot;std::list::front&quot;,
&quot;target&quot;: &quot;cpp/container/list/front&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/list/front&quot;
},
{
&quot;string&quot;: &quot;std::list::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/list/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/list/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::list::insert&quot;,
&quot;target&quot;: &quot;cpp/container/list/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/list/insert&quot;
},
{
&quot;string&quot;: &quot;std::list::list&quot;,
&quot;target&quot;: &quot;cpp/container/list/list&quot;
},
{
&quot;string&quot;: &quot;std::list::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/list/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/list/max_size&quot;
},
{
&quot;string&quot;: &quot;std::list::merge&quot;,
&quot;target&quot;: &quot;cpp/container/list/merge&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;merge&quot;,
&quot;target&quot;: &quot;cpp/container/list/merge&quot;
},
{
&quot;string&quot;: &quot;std::list::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::list::pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/pop_back&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::list::pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/pop_front&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;pop_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/pop_front&quot;
},
{
&quot;string&quot;: &quot;std::list::push_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/push_back&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;push_back&quot;,
&quot;target&quot;: &quot;cpp/container/list/push_back&quot;
},
{
&quot;string&quot;: &quot;std::list::push_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/push_front&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;push_front&quot;,
&quot;target&quot;: &quot;cpp/container/list/push_front&quot;
},
{
&quot;string&quot;: &quot;std::list::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::list::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/list/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::list::remove&quot;,
&quot;target&quot;: &quot;cpp/container/list/remove&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;remove&quot;,
&quot;target&quot;: &quot;cpp/container/list/remove&quot;
},
{
&quot;string&quot;: &quot;std::list::remove_if&quot;,
&quot;target&quot;: &quot;cpp/container/list/remove&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;remove_if&quot;,
&quot;target&quot;: &quot;cpp/container/list/remove&quot;
},
{
&quot;string&quot;: &quot;std::list::rend&quot;,
&quot;target&quot;: &quot;cpp/container/list/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/list/rend&quot;
},
{
&quot;string&quot;: &quot;std::list::crend&quot;,
&quot;target&quot;: &quot;cpp/container/list/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/list/rend&quot;
},
{
&quot;string&quot;: &quot;std::list::resize&quot;,
&quot;target&quot;: &quot;cpp/container/list/resize&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;resize&quot;,
&quot;target&quot;: &quot;cpp/container/list/resize&quot;
},
{
&quot;string&quot;: &quot;std::list::reverse&quot;,
&quot;target&quot;: &quot;cpp/container/list/reverse&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;reverse&quot;,
&quot;target&quot;: &quot;cpp/container/list/reverse&quot;
},
{
&quot;string&quot;: &quot;std::list::size&quot;,
&quot;target&quot;: &quot;cpp/container/list/size&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/list/size&quot;
},
{
&quot;string&quot;: &quot;std::list::sort&quot;,
&quot;target&quot;: &quot;cpp/container/list/sort&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;sort&quot;,
&quot;target&quot;: &quot;cpp/container/list/sort&quot;
},
{
&quot;string&quot;: &quot;std::list::splice&quot;,
&quot;target&quot;: &quot;cpp/container/list/splice&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;splice&quot;,
&quot;target&quot;: &quot;cpp/container/list/splice&quot;
},
{
&quot;string&quot;: &quot;std::list::swap&quot;,
&quot;target&quot;: &quot;cpp/container/list/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/list/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::list)&quot;,
&quot;target&quot;: &quot;cpp/container/list/swap2&quot;
},
{
&quot;string&quot;: &quot;std::list::unique&quot;,
&quot;target&quot;: &quot;cpp/container/list/unique&quot;
},
{
&quot;on_group&quot;: &quot;std::list&quot;,
&quot;string&quot;: &quot;unique&quot;,
&quot;target&quot;: &quot;cpp/container/list/unique&quot;
},
{
&quot;string&quot;: &quot;std::list::~list&quot;,
&quot;target&quot;: &quot;cpp/container/list/~list&quot;
},
{
&quot;string&quot;: &quot;std::map&quot;,
&quot;target&quot;: &quot;cpp/container/map&quot;
},
{
&quot;string&quot;: &quot;std::map::at&quot;,
&quot;target&quot;: &quot;cpp/container/map/at&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/map/at&quot;
},
{
&quot;string&quot;: &quot;std::map::begin&quot;,
&quot;target&quot;: &quot;cpp/container/map/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/map/begin&quot;
},
{
&quot;string&quot;: &quot;std::map::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/begin&quot;
},
{
&quot;string&quot;: &quot;std::map::clear&quot;,
&quot;target&quot;: &quot;cpp/container/map/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/map/clear&quot;
},
{
&quot;string&quot;: &quot;std::map::count&quot;,
&quot;target&quot;: &quot;cpp/container/map/count&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/map/count&quot;
},
{
&quot;string&quot;: &quot;std::map::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/map/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/map/emplace&quot;
},
{
&quot;string&quot;: &quot;std::map::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/map/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/map/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::map::empty&quot;,
&quot;target&quot;: &quot;cpp/container/map/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/map/empty&quot;
},
{
&quot;string&quot;: &quot;std::map::end&quot;,
&quot;target&quot;: &quot;cpp/container/map/end&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/map/end&quot;
},
{
&quot;string&quot;: &quot;std::map::cend&quot;,
&quot;target&quot;: &quot;cpp/container/map/end&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/map/end&quot;
},
{
&quot;string&quot;: &quot;std::map::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/map/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/map/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::map::erase&quot;,
&quot;target&quot;: &quot;cpp/container/map/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/map/erase&quot;
},
{
&quot;string&quot;: &quot;std::map::find&quot;,
&quot;target&quot;: &quot;cpp/container/map/find&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/map/find&quot;
},
{
&quot;string&quot;: &quot;std::map::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/map/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/map/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::map::insert&quot;,
&quot;target&quot;: &quot;cpp/container/map/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/map/insert&quot;
},
{
&quot;string&quot;: &quot;std::map::key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/map/key_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/map/key_comp&quot;
},
{
&quot;string&quot;: &quot;std::map::lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/map/lower_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/map/lower_bound&quot;
},
{
&quot;string&quot;: &quot;std::map::map&quot;,
&quot;target&quot;: &quot;cpp/container/map/map&quot;
},
{
&quot;string&quot;: &quot;std::map::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/map/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/map/max_size&quot;
},
{
&quot;string&quot;: &quot;std::map::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator=&quot;
},
{
&quot;string&quot;: &quot;std::map::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::map::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::map::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/map/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::map::rend&quot;,
&quot;target&quot;: &quot;cpp/container/map/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/map/rend&quot;
},
{
&quot;string&quot;: &quot;std::map::crend&quot;,
&quot;target&quot;: &quot;cpp/container/map/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/map/rend&quot;
},
{
&quot;string&quot;: &quot;std::map::size&quot;,
&quot;target&quot;: &quot;cpp/container/map/size&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/map/size&quot;
},
{
&quot;string&quot;: &quot;std::map::swap&quot;,
&quot;target&quot;: &quot;cpp/container/map/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/map/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::map)&quot;,
&quot;target&quot;: &quot;cpp/container/map/swap2&quot;
},
{
&quot;string&quot;: &quot;std::map::upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/map/upper_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/map/upper_bound&quot;
},
{
&quot;string&quot;: &quot;std::map::value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/map/value_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/map/value_comp&quot;
},
{
&quot;string&quot;: &quot;std::map::value_compare&quot;,
&quot;target&quot;: &quot;cpp/container/map/value_compare&quot;
},
{
&quot;on_group&quot;: &quot;std::map&quot;,
&quot;string&quot;: &quot;value_compare&quot;,
&quot;target&quot;: &quot;cpp/container/map/value_compare&quot;
},
{
&quot;string&quot;: &quot;std::map::~map&quot;,
&quot;target&quot;: &quot;cpp/container/map/~map&quot;
},
{
&quot;string&quot;: &quot;std::multimap&quot;,
&quot;target&quot;: &quot;cpp/container/multimap&quot;
},
{
&quot;string&quot;: &quot;std::multimap::begin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/begin&quot;
},
{
&quot;string&quot;: &quot;std::multimap::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/begin&quot;
},
{
&quot;string&quot;: &quot;std::multimap::clear&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/clear&quot;
},
{
&quot;string&quot;: &quot;std::multimap::count&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/count&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/count&quot;
},
{
&quot;string&quot;: &quot;std::multimap::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/emplace&quot;
},
{
&quot;string&quot;: &quot;std::multimap::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::multimap::empty&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/empty&quot;
},
{
&quot;string&quot;: &quot;std::multimap::end&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/end&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/end&quot;
},
{
&quot;string&quot;: &quot;std::multimap::cend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/end&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/end&quot;
},
{
&quot;string&quot;: &quot;std::multimap::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::multimap::erase&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/erase&quot;
},
{
&quot;string&quot;: &quot;std::multimap::find&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/find&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/find&quot;
},
{
&quot;string&quot;: &quot;std::multimap::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::multimap::insert&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/insert&quot;
},
{
&quot;string&quot;: &quot;std::multimap::key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/key_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/key_comp&quot;
},
{
&quot;string&quot;: &quot;std::multimap::lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/lower_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/lower_bound&quot;
},
{
&quot;string&quot;: &quot;std::multimap::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/max_size&quot;
},
{
&quot;string&quot;: &quot;std::multimap::multimap&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/multimap&quot;
},
{
&quot;string&quot;: &quot;std::multimap::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::multimap::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::multimap::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::multimap::rend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rend&quot;
},
{
&quot;string&quot;: &quot;std::multimap::crend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/rend&quot;
},
{
&quot;string&quot;: &quot;std::multimap::size&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/size&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/size&quot;
},
{
&quot;string&quot;: &quot;std::multimap::swap&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/swap2&quot;
},
{
&quot;string&quot;: &quot;std::multimap::upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/upper_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/upper_bound&quot;
},
{
&quot;string&quot;: &quot;std::multimap::value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/value_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/value_comp&quot;
},
{
&quot;string&quot;: &quot;std::multimap::value_compare&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/value_compare&quot;
},
{
&quot;on_group&quot;: &quot;std::multimap&quot;,
&quot;string&quot;: &quot;value_compare&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/value_compare&quot;
},
{
&quot;string&quot;: &quot;std::multimap::~multimap&quot;,
&quot;target&quot;: &quot;cpp/container/multimap/~multimap&quot;
},
{
&quot;string&quot;: &quot;std::multiset&quot;,
&quot;target&quot;: &quot;cpp/container/multiset&quot;
},
{
&quot;string&quot;: &quot;std::multiset::begin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/begin&quot;
},
{
&quot;string&quot;: &quot;std::multiset::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/begin&quot;
},
{
&quot;string&quot;: &quot;std::multiset::clear&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/clear&quot;
},
{
&quot;string&quot;: &quot;std::multiset::count&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/count&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/count&quot;
},
{
&quot;string&quot;: &quot;std::multiset::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/emplace&quot;
},
{
&quot;string&quot;: &quot;std::multiset::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::multiset::empty&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/empty&quot;
},
{
&quot;string&quot;: &quot;std::multiset::end&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/end&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/end&quot;
},
{
&quot;string&quot;: &quot;std::multiset::cend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/end&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/end&quot;
},
{
&quot;string&quot;: &quot;std::multiset::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::multiset::erase&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/erase&quot;
},
{
&quot;string&quot;: &quot;std::multiset::find&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/find&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/find&quot;
},
{
&quot;string&quot;: &quot;std::multiset::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::multiset::insert&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/insert&quot;
},
{
&quot;string&quot;: &quot;std::multiset::key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/key_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/key_comp&quot;
},
{
&quot;string&quot;: &quot;std::multiset::lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/lower_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/lower_bound&quot;
},
{
&quot;string&quot;: &quot;std::multiset::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/max_size&quot;
},
{
&quot;string&quot;: &quot;std::multiset::multiset&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/multiset&quot;
},
{
&quot;string&quot;: &quot;std::multiset::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::multiset::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::multiset::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::multiset::rend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rend&quot;
},
{
&quot;string&quot;: &quot;std::multiset::crend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/rend&quot;
},
{
&quot;string&quot;: &quot;std::multiset::size&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/size&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/size&quot;
},
{
&quot;string&quot;: &quot;std::multiset::swap&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/swap2&quot;
},
{
&quot;string&quot;: &quot;std::multiset::upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/upper_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/upper_bound&quot;
},
{
&quot;string&quot;: &quot;std::multiset::value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/value_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::multiset&quot;,
&quot;string&quot;: &quot;value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/value_comp&quot;
},
{
&quot;string&quot;: &quot;std::multiset::~multiset&quot;,
&quot;target&quot;: &quot;cpp/container/multiset/~multiset&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/emplace&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::empty&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/empty&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::pop&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/pop&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;pop&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/pop&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::priority_queue&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/priority_queue&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::push&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/push&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;push&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/push&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::size&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/size&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/size&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::swap&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::priority_queue)&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/swap2&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::top&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/top&quot;
},
{
&quot;on_group&quot;: &quot;std::priority_queue&quot;,
&quot;string&quot;: &quot;top&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/top&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::priority_queue&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::priority_queue::~priority_queue&quot;,
&quot;target&quot;: &quot;cpp/container/priority_queue/~priority_queue&quot;
},
{
&quot;string&quot;: &quot;std::queue&quot;,
&quot;target&quot;: &quot;cpp/container/queue&quot;
},
{
&quot;string&quot;: &quot;std::queue::back&quot;,
&quot;target&quot;: &quot;cpp/container/queue/back&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/queue/back&quot;
},
{
&quot;string&quot;: &quot;std::queue::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/queue/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/queue/emplace&quot;
},
{
&quot;string&quot;: &quot;std::queue::empty&quot;,
&quot;target&quot;: &quot;cpp/container/queue/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/queue/empty&quot;
},
{
&quot;string&quot;: &quot;std::queue::front&quot;,
&quot;target&quot;: &quot;cpp/container/queue/front&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/queue/front&quot;
},
{
&quot;string&quot;: &quot;std::queue::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::queue::pop&quot;,
&quot;target&quot;: &quot;cpp/container/queue/pop&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;pop&quot;,
&quot;target&quot;: &quot;cpp/container/queue/pop&quot;
},
{
&quot;string&quot;: &quot;std::queue::push&quot;,
&quot;target&quot;: &quot;cpp/container/queue/push&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;push&quot;,
&quot;target&quot;: &quot;cpp/container/queue/push&quot;
},
{
&quot;string&quot;: &quot;std::queue::queue&quot;,
&quot;target&quot;: &quot;cpp/container/queue/queue&quot;
},
{
&quot;string&quot;: &quot;std::queue::size&quot;,
&quot;target&quot;: &quot;cpp/container/queue/size&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/queue/size&quot;
},
{
&quot;string&quot;: &quot;std::queue::swap&quot;,
&quot;target&quot;: &quot;cpp/container/queue/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::queue&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/queue/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::queue)&quot;,
&quot;target&quot;: &quot;cpp/container/queue/swap2&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::queue&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/queue/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::queue::~queue&quot;,
&quot;target&quot;: &quot;cpp/container/queue/~queue&quot;
},
{
&quot;string&quot;: &quot;std::set&quot;,
&quot;target&quot;: &quot;cpp/container/set&quot;
},
{
&quot;string&quot;: &quot;std::set::begin&quot;,
&quot;target&quot;: &quot;cpp/container/set/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/set/begin&quot;
},
{
&quot;string&quot;: &quot;std::set::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/begin&quot;
},
{
&quot;string&quot;: &quot;std::set::clear&quot;,
&quot;target&quot;: &quot;cpp/container/set/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/set/clear&quot;
},
{
&quot;string&quot;: &quot;std::set::count&quot;,
&quot;target&quot;: &quot;cpp/container/set/count&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/set/count&quot;
},
{
&quot;string&quot;: &quot;std::set::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/set/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/set/emplace&quot;
},
{
&quot;string&quot;: &quot;std::set::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/set/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/set/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::set::empty&quot;,
&quot;target&quot;: &quot;cpp/container/set/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/set/empty&quot;
},
{
&quot;string&quot;: &quot;std::set::end&quot;,
&quot;target&quot;: &quot;cpp/container/set/end&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/set/end&quot;
},
{
&quot;string&quot;: &quot;std::set::cend&quot;,
&quot;target&quot;: &quot;cpp/container/set/end&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/set/end&quot;
},
{
&quot;string&quot;: &quot;std::set::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/set/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/set/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::set::erase&quot;,
&quot;target&quot;: &quot;cpp/container/set/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/set/erase&quot;
},
{
&quot;string&quot;: &quot;std::set::find&quot;,
&quot;target&quot;: &quot;cpp/container/set/find&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/set/find&quot;
},
{
&quot;string&quot;: &quot;std::set::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/set/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/set/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::set::insert&quot;,
&quot;target&quot;: &quot;cpp/container/set/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/set/insert&quot;
},
{
&quot;string&quot;: &quot;std::set::key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/set/key_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;key_comp&quot;,
&quot;target&quot;: &quot;cpp/container/set/key_comp&quot;
},
{
&quot;string&quot;: &quot;std::set::lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/set/lower_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;lower_bound&quot;,
&quot;target&quot;: &quot;cpp/container/set/lower_bound&quot;
},
{
&quot;string&quot;: &quot;std::set::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/set/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/set/max_size&quot;
},
{
&quot;string&quot;: &quot;std::set::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::set::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::set::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/set/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::set::rend&quot;,
&quot;target&quot;: &quot;cpp/container/set/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/set/rend&quot;
},
{
&quot;string&quot;: &quot;std::set::crend&quot;,
&quot;target&quot;: &quot;cpp/container/set/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/set/rend&quot;
},
{
&quot;string&quot;: &quot;std::set::set&quot;,
&quot;target&quot;: &quot;cpp/container/set/set&quot;
},
{
&quot;string&quot;: &quot;std::set::size&quot;,
&quot;target&quot;: &quot;cpp/container/set/size&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/set/size&quot;
},
{
&quot;string&quot;: &quot;std::set::swap&quot;,
&quot;target&quot;: &quot;cpp/container/set/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/set/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::set)&quot;,
&quot;target&quot;: &quot;cpp/container/set/swap2&quot;
},
{
&quot;string&quot;: &quot;std::set::upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/set/upper_bound&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;upper_bound&quot;,
&quot;target&quot;: &quot;cpp/container/set/upper_bound&quot;
},
{
&quot;string&quot;: &quot;std::set::value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/set/value_comp&quot;
},
{
&quot;on_group&quot;: &quot;std::set&quot;,
&quot;string&quot;: &quot;value_comp&quot;,
&quot;target&quot;: &quot;cpp/container/set/value_comp&quot;
},
{
&quot;string&quot;: &quot;std::set::~set&quot;,
&quot;target&quot;: &quot;cpp/container/set/~set&quot;
},
{
&quot;string&quot;: &quot;std::stack&quot;,
&quot;target&quot;: &quot;cpp/container/stack&quot;
},
{
&quot;string&quot;: &quot;std::stack::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/stack/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/stack/emplace&quot;
},
{
&quot;string&quot;: &quot;std::stack::empty&quot;,
&quot;target&quot;: &quot;cpp/container/stack/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/stack/empty&quot;
},
{
&quot;string&quot;: &quot;std::stack::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::stack::pop&quot;,
&quot;target&quot;: &quot;cpp/container/stack/pop&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;pop&quot;,
&quot;target&quot;: &quot;cpp/container/stack/pop&quot;
},
{
&quot;string&quot;: &quot;std::stack::push&quot;,
&quot;target&quot;: &quot;cpp/container/stack/push&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;push&quot;,
&quot;target&quot;: &quot;cpp/container/stack/push&quot;
},
{
&quot;string&quot;: &quot;std::stack::size&quot;,
&quot;target&quot;: &quot;cpp/container/stack/size&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/stack/size&quot;
},
{
&quot;string&quot;: &quot;std::stack::stack&quot;,
&quot;target&quot;: &quot;cpp/container/stack/stack&quot;
},
{
&quot;string&quot;: &quot;std::stack::swap&quot;,
&quot;target&quot;: &quot;cpp/container/stack/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/stack/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::stack)&quot;,
&quot;target&quot;: &quot;cpp/container/stack/swap2&quot;
},
{
&quot;string&quot;: &quot;std::stack::top&quot;,
&quot;target&quot;: &quot;cpp/container/stack/top&quot;
},
{
&quot;on_group&quot;: &quot;std::stack&quot;,
&quot;string&quot;: &quot;top&quot;,
&quot;target&quot;: &quot;cpp/container/stack/top&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::stack&gt;&quot;,
&quot;target&quot;: &quot;cpp/container/stack/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::stack::~stack&quot;,
&quot;target&quot;: &quot;cpp/container/stack/~stack&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::at&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/at&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/at&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/bucket_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/clear&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/emplace&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/empty&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/erase&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/find&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/find&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/hash_function&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/hash_function&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/insert&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/key_eq&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/key_eq&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/max_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator=&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::unordered_map)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::unordered_map)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/rehash&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/rehash&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/reserve&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_map&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unordered_map)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::unordered_map&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/unordered_map&quot;
},
{
&quot;string&quot;: &quot;std::unordered_map::~unordered_map&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_map/~unordered_map&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/bucket_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/clear&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/emplace&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/empty&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/erase&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/find&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/find&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/hash_function&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/hash_function&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/insert&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/key_eq&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/key_eq&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/max_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::unordered_multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::unordered_multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/rehash&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/rehash&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/reserve&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multimap&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unordered_multimap)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::unordered_multimap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/unordered_multimap&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multimap::~unordered_multimap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multimap/~unordered_multimap&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/bucket_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/clear&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/emplace&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/empty&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/erase&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/find&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/find&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/hash_function&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/hash_function&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/insert&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/key_eq&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/key_eq&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/max_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::unordered_multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::unordered_multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/rehash&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/rehash&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/reserve&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_multiset&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unordered_multiset)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::unordered_multiset&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/unordered_multiset&quot;
},
{
&quot;string&quot;: &quot;std::unordered_multiset::~unordered_multiset&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_multiset/~unordered_multiset&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;begin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;cbegin(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/begin2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;bucket&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;bucket_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/bucket_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/clear&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/emplace&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/emplace_hint&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;emplace_hint&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/emplace_hint&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/empty&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;end(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end2&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;cend(int)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/end2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/equal_range&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;equal_range&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/equal_range&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/erase&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/find&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/find&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/hash_function&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;hash_function&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/hash_function&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/insert&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/key_eq&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;key_eq&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/key_eq&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_bucket_count&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;max_bucket_count&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_bucket_count&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_load_factor&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;max_load_factor&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_load_factor&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/max_size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::unordered_set)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::unordered_set)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/rehash&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;rehash&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/rehash&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/reserve&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/size&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/size&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unordered_set&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unordered_set)&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::unordered_set&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/unordered_set&quot;
},
{
&quot;string&quot;: &quot;std::unordered_set::~unordered_set&quot;,
&quot;target&quot;: &quot;cpp/container/unordered_set/~unordered_set&quot;
},
{
&quot;string&quot;: &quot;std::vector&quot;,
&quot;target&quot;: &quot;cpp/container/vector&quot;
},
{
&quot;string&quot;: &quot;std::vector::assign&quot;,
&quot;target&quot;: &quot;cpp/container/vector/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/container/vector/assign&quot;
},
{
&quot;string&quot;: &quot;std::vector::at&quot;,
&quot;target&quot;: &quot;cpp/container/vector/at&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/container/vector/at&quot;
},
{
&quot;string&quot;: &quot;std::vector::back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/back&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/back&quot;
},
{
&quot;string&quot;: &quot;std::vector::begin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/begin&quot;
},
{
&quot;string&quot;: &quot;std::vector::cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/begin&quot;
},
{
&quot;string&quot;: &quot;std::vector::capacity&quot;,
&quot;target&quot;: &quot;cpp/container/vector/capacity&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;capacity&quot;,
&quot;target&quot;: &quot;cpp/container/vector/capacity&quot;
},
{
&quot;string&quot;: &quot;std::vector::clear&quot;,
&quot;target&quot;: &quot;cpp/container/vector/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/container/vector/clear&quot;
},
{
&quot;string&quot;: &quot;std::vector::data&quot;,
&quot;target&quot;: &quot;cpp/container/vector/data&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;data&quot;,
&quot;target&quot;: &quot;cpp/container/vector/data&quot;
},
{
&quot;string&quot;: &quot;std::vector::emplace&quot;,
&quot;target&quot;: &quot;cpp/container/vector/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/container/vector/emplace&quot;
},
{
&quot;string&quot;: &quot;std::vector::emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/emplace_back&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;emplace_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/emplace_back&quot;
},
{
&quot;string&quot;: &quot;std::vector::empty&quot;,
&quot;target&quot;: &quot;cpp/container/vector/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/container/vector/empty&quot;
},
{
&quot;string&quot;: &quot;std::vector::end&quot;,
&quot;target&quot;: &quot;cpp/container/vector/end&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/container/vector/end&quot;
},
{
&quot;string&quot;: &quot;std::vector::cend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/end&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/end&quot;
},
{
&quot;string&quot;: &quot;std::vector::erase&quot;,
&quot;target&quot;: &quot;cpp/container/vector/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/container/vector/erase&quot;
},
{
&quot;string&quot;: &quot;std::vector::front&quot;,
&quot;target&quot;: &quot;cpp/container/vector/front&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/container/vector/front&quot;
},
{
&quot;string&quot;: &quot;std::vector::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/vector/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/container/vector/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::vector::insert&quot;,
&quot;target&quot;: &quot;cpp/container/vector/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/container/vector/insert&quot;
},
{
&quot;string&quot;: &quot;std::vector::max_size&quot;,
&quot;target&quot;: &quot;cpp/container/vector/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/container/vector/max_size&quot;
},
{
&quot;string&quot;: &quot;std::vector::operator=&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator=&quot;
},
{
&quot;string&quot;: &quot;std::vector::operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::vector::pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/pop_back&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;pop_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::vector::push_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/push_back&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;push_back&quot;,
&quot;target&quot;: &quot;cpp/container/vector/push_back&quot;
},
{
&quot;string&quot;: &quot;std::vector::rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::vector::crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::vector::rend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rend&quot;
},
{
&quot;string&quot;: &quot;std::vector::crend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/container/vector/rend&quot;
},
{
&quot;string&quot;: &quot;std::vector::reserve&quot;,
&quot;target&quot;: &quot;cpp/container/vector/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/container/vector/reserve&quot;
},
{
&quot;string&quot;: &quot;std::vector::resize&quot;,
&quot;target&quot;: &quot;cpp/container/vector/resize&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;resize&quot;,
&quot;target&quot;: &quot;cpp/container/vector/resize&quot;
},
{
&quot;string&quot;: &quot;std::vector::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/container/vector/shrink_to_fit&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/container/vector/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::vector::size&quot;,
&quot;target&quot;: &quot;cpp/container/vector/size&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/container/vector/size&quot;
},
{
&quot;string&quot;: &quot;std::vector::swap&quot;,
&quot;target&quot;: &quot;cpp/container/vector/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::vector&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/container/vector/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::vector)&quot;,
&quot;target&quot;: &quot;cpp/container/vector/swap2&quot;
},
{
&quot;string&quot;: &quot;std::vector::vector&quot;,
&quot;target&quot;: &quot;cpp/container/vector/vector&quot;
},
{
&quot;string&quot;: &quot;std::vector::~vector&quot;,
&quot;target&quot;: &quot;cpp/container/vector/~vector&quot;
},
{
&quot;string&quot;: &quot;assert&quot;,
&quot;target&quot;: &quot;cpp/error/assert&quot;
},
{
&quot;string&quot;: &quot;std::bad_exception&quot;,
&quot;target&quot;: &quot;cpp/error/bad_exception&quot;
},
{
&quot;string&quot;: &quot;std::current_exception&quot;,
&quot;target&quot;: &quot;cpp/error/current_exception&quot;
},
{
&quot;string&quot;: &quot;std::domain_error&quot;,
&quot;target&quot;: &quot;cpp/error/domain_error&quot;
},
{
&quot;string&quot;: &quot;std::domain_error::domain_error&quot;,
&quot;target&quot;: &quot;cpp/error/domain_error&quot;
},
{
&quot;string&quot;: &quot;std::errc&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::address_family_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;address_family_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::address_in_use&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;address_in_use&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::address_not_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;address_not_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::already_connected&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;already_connected&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::argument_list_too_long&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;argument_list_too_long&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::argument_out_of_domain&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;argument_out_of_domain&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::bad_address&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;bad_address&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::bad_file_descriptor&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;bad_file_descriptor&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::bad_message&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;bad_message&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::broken_pipe&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;broken_pipe&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::connection_aborted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;connection_aborted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::connection_already_in_progress&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;connection_already_in_progress&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::connection_refused&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;connection_refused&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::connection_reset&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;connection_reset&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::cross_device_link&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;cross_device_link&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::destination_address_required&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;destination_address_required&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::device_or_resource_busy&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;device_or_resource_busy&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::directory_not_empty&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;directory_not_empty&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::executable_format_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;executable_format_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::file_exists&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;file_exists&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::file_too_large&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;file_too_large&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::filename_too_long&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;filename_too_long&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::function_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;function_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::host_unreachable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;host_unreachable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::identifier_removed&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;identifier_removed&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::illegal_byte_sequence&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;illegal_byte_sequence&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::inappropriate_io_control_operation&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;inappropriate_io_control_operation&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::interrupted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;interrupted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::invalid_argument&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;invalid_argument&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::invalid_seek&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;invalid_seek&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::io_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;io_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::is_a_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;is_a_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::message_size&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;message_size&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::network_down&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;network_down&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::network_reset&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;network_reset&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::network_unreachable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;network_unreachable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_buffer_space&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_buffer_space&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_child_process&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_child_process&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_link&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_link&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_lock_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_lock_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_message_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_message_available&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_message&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_message&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_protocol_option&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_protocol_option&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_space_on_device&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_space_on_device&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_stream_resources&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_stream_resources&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_such_device_or_address&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_such_device_or_address&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_such_device&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_such_device&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_such_file_or_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_such_file_or_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::no_such_process&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;no_such_process&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_a_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_a_directory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_a_socket&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_a_socket&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_a_stream&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_a_stream&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_connected&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_connected&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_enough_memory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_enough_memory&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::operation_canceled&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;operation_canceled&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::operation_in_progress&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;operation_in_progress&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::operation_not_permitted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;operation_not_permitted&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::operation_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;operation_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::operation_would_block&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;operation_would_block&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::owner_dead&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;owner_dead&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::permission_denied&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;permission_denied&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::protocol_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;protocol_error&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::protocol_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;protocol_not_supported&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::read_only_file_system&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;read_only_file_system&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::resource_deadlock_would_occur&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;resource_deadlock_would_occur&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::resource_unavailable_try_again&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;resource_unavailable_try_again&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::result_out_of_range&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;result_out_of_range&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::state_not_recoverable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;state_not_recoverable&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::stream_timeout&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;stream_timeout&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::text_file_busy&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;text_file_busy&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::timed_out&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;timed_out&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::too_many_files_open_in_system&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;too_many_files_open_in_system&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::too_many_files_open&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;too_many_files_open&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::too_many_links&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;too_many_links&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::too_many_symbolic_link_levels&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;too_many_symbolic_link_levels&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::value_too_large&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;value_too_large&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::errc::wrong_protocol_type&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;on_group&quot;: &quot;std::errc&quot;,
&quot;string&quot;: &quot;wrong_protocol_type&quot;,
&quot;target&quot;: &quot;cpp/error/errc&quot;
},
{
&quot;string&quot;: &quot;std::is_error_condition_enum&lt;std::errc&gt;&quot;,
&quot;target&quot;: &quot;cpp/error/errc/is_error_condition_enum&quot;
},
{
&quot;string&quot;: &quot;std::make_error_code(std::errc)&quot;,
&quot;target&quot;: &quot;cpp/error/errc/make_error_code&quot;
},
{
&quot;string&quot;: &quot;std::make_error_condition(std::errc)&quot;,
&quot;target&quot;: &quot;cpp/error/errc/make_error_condition&quot;
},
{
&quot;string&quot;: &quot;errno&quot;,
&quot;target&quot;: &quot;cpp/error/errno&quot;
},
{
&quot;string&quot;: &quot;E2BIG&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EACCESS&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EADDRINUSE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EADDRNOTAVAIL&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EAFNOSUPPORT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EAGAIN&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EALREADY&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EBADF&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EBADMSG&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EBUSY&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ECANCELED&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ECHILD&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ECONNABORTED&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ECONNREFUSED&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ECONNRESET&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EDEADLK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EDESTADDRREQ&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EDOM&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EEXIST&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EFAULT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EFBIG&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EHOSTUNREACH&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EIDRM&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EILSEQ&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EINPROGRESS&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EINTR&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EINVAL&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EIO&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EISCONN&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EISDIR&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ELOOP&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EMFILE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EMLINK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EMSGSIZE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENAMETOOLONG&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENETDOWN&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENETRESET&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENETUNREACH&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENFILE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOBUFS&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENODATA&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENODEV&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOENT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOEXEC&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOLCK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOLINK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOMEM&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOMSG&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOPROTOOPT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOSPC&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOSR&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOSTR&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOSYS&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTCONN&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTDIR&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTEMPTY&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTRECOVERABLE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTSOCK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTSUP&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENOTTY&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ENXIO&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EOPNOTSUPP&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EOVERFLOW&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EOWNERDEAD&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EPERM&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EPIPE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EPROTO&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EPROTONOSUPPORT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EPROTOTYPE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ERANGE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EROFS&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ESPIPE&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ESRCH&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ETIME&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ETIMEDOUT&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;ETXTBSY&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EWOULDBLOCK&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;EXDEV&quot;,
&quot;target&quot;: &quot;cpp/error/errno_macros&quot;
},
{
&quot;string&quot;: &quot;std::error_category&quot;,
&quot;target&quot;: &quot;cpp/error/error_category&quot;
},
{
&quot;string&quot;: &quot;std::error_category::default_error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/default_error_condition&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;default_error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/default_error_condition&quot;
},
{
&quot;string&quot;: &quot;std::error_category::equivalent&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/equivalent&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;equivalent&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/equivalent&quot;
},
{
&quot;string&quot;: &quot;std::error_category::error_category&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/error_category&quot;
},
{
&quot;string&quot;: &quot;std::error_category::message&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/message&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;message&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/message&quot;
},
{
&quot;string&quot;: &quot;std::error_category::name&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/name&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;name&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/name&quot;
},
{
&quot;string&quot;: &quot;std::error_category::operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator=&quot;
},
{
&quot;string&quot;: &quot;std::error_category::operator==&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::error_category::operator!=&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::error_category::operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::error_category&quot;,
&quot;string&quot;: &quot;operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::error_category::~error_category&quot;,
&quot;target&quot;: &quot;cpp/error/error_category/~error_category&quot;
},
{
&quot;string&quot;: &quot;std::error_code&quot;,
&quot;target&quot;: &quot;cpp/error/error_code&quot;
},
{
&quot;string&quot;: &quot;std::error_code::assign&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/assign&quot;
},
{
&quot;string&quot;: &quot;std::error_code::category&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/category&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;category&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/category&quot;
},
{
&quot;string&quot;: &quot;std::error_code::clear&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/clear&quot;
},
{
&quot;string&quot;: &quot;std::error_code::default_error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/default_error_condition&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;default_error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/default_error_condition&quot;
},
{
&quot;string&quot;: &quot;std::error_code::error_code&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/error_code&quot;
},
{
&quot;string&quot;: &quot;std::is_error_code_enum&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/is_error_code_enum&quot;
},
{
&quot;string&quot;: &quot;std::error_code::message&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/message&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;message&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/message&quot;
},
{
&quot;string&quot;: &quot;std::error_code::operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator=&quot;
},
{
&quot;string&quot;: &quot;std::error_code::operator bool&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_bool&quot;
},
{
&quot;string&quot;: &quot;operator==(std::error_code)&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::error_code)&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::error_code)&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::error_code)&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::error_code::value&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/value&quot;
},
{
&quot;on_group&quot;: &quot;std::error_code&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/error/error_code/value&quot;
},
{
&quot;string&quot;: &quot;std::error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::assign&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/assign&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::category&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/category&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;category&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/category&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::clear&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/clear&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::error_condition&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/error_condition&quot;
},
{
&quot;string&quot;: &quot;std::is_error_condition_enum&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/is_error_condition_enum&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::message&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/message&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;message&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/message&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator=&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::operator bool&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator_bool&quot;
},
{
&quot;string&quot;: &quot;operator==(std::error_condition)&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::error_condition)&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::error_condition)&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::error_condition::value&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/value&quot;
},
{
&quot;on_group&quot;: &quot;std::error_condition&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/error/error_condition/value&quot;
},
{
&quot;string&quot;: &quot;std::exception&quot;,
&quot;target&quot;: &quot;cpp/error/exception&quot;
},
{
&quot;string&quot;: &quot;std::exception::exception&quot;,
&quot;target&quot;: &quot;cpp/error/exception/exception&quot;
},
{
&quot;string&quot;: &quot;std::exception::operator=&quot;,
&quot;target&quot;: &quot;cpp/error/exception/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::exception&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/error/exception/operator=&quot;
},
{
&quot;string&quot;: &quot;std::bad_typeid::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_typeid&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_cast::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_cast&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_alloc::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_alloc&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_new_length::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_array_new_length&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_length::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_array_length&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_weak_ptr::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_weak_ptr&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::exception::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::exception&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::logic_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::logic_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::domain_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::domain_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::length_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::length_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::out_of_range::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::out_of_range&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::invalid_argument::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::invalid_argument&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::runtime_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::runtime_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::range_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::range_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::overflow_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::overflow_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::underflow_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::underflow_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::system_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::system_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_function_call::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_function_call&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::bad_optional_access::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_optional_access&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::istream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::istream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::ostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::ostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::iostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::iostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::ifstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::ofstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::fstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::fstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::istringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::ostringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::stringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wistream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wistream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wiostream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wifstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wofstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wfstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wistringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wostringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::failure::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::wstringstream::failure&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::regex_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::future_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;on_group&quot;: &quot;std::future_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/exception/what&quot;
},
{
&quot;string&quot;: &quot;std::exception::~exception&quot;,
&quot;target&quot;: &quot;cpp/error/exception/~exception&quot;
},
{
&quot;string&quot;: &quot;std::exception_ptr&quot;,
&quot;target&quot;: &quot;cpp/error/exception_ptr&quot;
},
{
&quot;string&quot;: &quot;std::generic_category&quot;,
&quot;target&quot;: &quot;cpp/error/generic_category&quot;
},
{
&quot;string&quot;: &quot;std::get_terminate&quot;,
&quot;target&quot;: &quot;cpp/error/get_terminate&quot;
},
{
&quot;string&quot;: &quot;std::get_unexpected&quot;,
&quot;target&quot;: &quot;cpp/error/get_unexpected&quot;
},
{
&quot;string&quot;: &quot;std::invalid_argument&quot;,
&quot;target&quot;: &quot;cpp/error/invalid_argument&quot;
},
{
&quot;string&quot;: &quot;std::invalid_argument::invalid_argument&quot;,
&quot;target&quot;: &quot;cpp/error/invalid_argument&quot;
},
{
&quot;string&quot;: &quot;std::length_error&quot;,
&quot;target&quot;: &quot;cpp/error/length_error&quot;
},
{
&quot;string&quot;: &quot;std::length_error::length_error&quot;,
&quot;target&quot;: &quot;cpp/error/length_error&quot;
},
{
&quot;string&quot;: &quot;std::logic_error&quot;,
&quot;target&quot;: &quot;cpp/error/logic_error&quot;
},
{
&quot;string&quot;: &quot;std::logic_error::logic_error&quot;,
&quot;target&quot;: &quot;cpp/error/logic_error&quot;
},
{
&quot;string&quot;: &quot;std::make_exception_ptr&quot;,
&quot;target&quot;: &quot;cpp/error/make_exception_ptr&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception::nested_exception&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/nested_exception&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception::nested_ptr&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/nested_ptr&quot;
},
{
&quot;on_group&quot;: &quot;std::nested_exception&quot;,
&quot;string&quot;: &quot;nested_ptr&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/nested_ptr&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception::operator=&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::nested_exception&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/operator=&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception::rethrow_nested&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/rethrow_nested&quot;
},
{
&quot;on_group&quot;: &quot;std::nested_exception&quot;,
&quot;string&quot;: &quot;rethrow_nested&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/rethrow_nested&quot;
},
{
&quot;string&quot;: &quot;std::throw_with_nested&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/throw_with_nested&quot;
},
{
&quot;string&quot;: &quot;std::nested_exception::~nested_exception&quot;,
&quot;target&quot;: &quot;cpp/error/nested_exception/~nested_exception&quot;
},
{
&quot;string&quot;: &quot;std::rethrow_if_nested&quot;,
&quot;target&quot;: &quot;cpp/error/nexted_exception/rethrow_if_nested&quot;
},
{
&quot;string&quot;: &quot;std::out_of_range&quot;,
&quot;target&quot;: &quot;cpp/error/out_of_range&quot;
},
{
&quot;string&quot;: &quot;std::out_of_range::out_of_range&quot;,
&quot;target&quot;: &quot;cpp/error/out_of_range&quot;
},
{
&quot;string&quot;: &quot;std::overflow_error&quot;,
&quot;target&quot;: &quot;cpp/error/overflow_error&quot;
},
{
&quot;string&quot;: &quot;std::overflow_error::overflow_error&quot;,
&quot;target&quot;: &quot;cpp/error/overflow_error&quot;
},
{
&quot;string&quot;: &quot;std::range_error&quot;,
&quot;target&quot;: &quot;cpp/error/range_error&quot;
},
{
&quot;string&quot;: &quot;std::range_error::range_error&quot;,
&quot;target&quot;: &quot;cpp/error/range_error&quot;
},
{
&quot;string&quot;: &quot;std::rethrow_exception&quot;,
&quot;target&quot;: &quot;cpp/error/rethrow_exception&quot;
},
{
&quot;string&quot;: &quot;std::runtime_error&quot;,
&quot;target&quot;: &quot;cpp/error/runtime_error&quot;
},
{
&quot;string&quot;: &quot;std::runtime_error::runtime_error&quot;,
&quot;target&quot;: &quot;cpp/error/runtime_error&quot;
},
{
&quot;string&quot;: &quot;std::set_terminate&quot;,
&quot;target&quot;: &quot;cpp/error/set_terminate&quot;
},
{
&quot;string&quot;: &quot;std::set_unexpected&quot;,
&quot;target&quot;: &quot;cpp/error/set_unexpected&quot;
},
{
&quot;string&quot;: &quot;std::system_category&quot;,
&quot;target&quot;: &quot;cpp/error/system_category&quot;
},
{
&quot;string&quot;: &quot;std::system_error&quot;,
&quot;target&quot;: &quot;cpp/error/system_error&quot;
},
{
&quot;string&quot;: &quot;std::system_error::code&quot;,
&quot;target&quot;: &quot;cpp/error/system_error/code&quot;
},
{
&quot;on_group&quot;: &quot;std::system_error&quot;,
&quot;string&quot;: &quot;code&quot;,
&quot;target&quot;: &quot;cpp/error/system_error/code&quot;
},
{
&quot;string&quot;: &quot;std::system_error::system_error&quot;,
&quot;target&quot;: &quot;cpp/error/system_error/system_error&quot;
},
{
&quot;string&quot;: &quot;std::system_error::what&quot;,
&quot;target&quot;: &quot;cpp/error/system_error/what&quot;
},
{
&quot;on_group&quot;: &quot;std::system_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/error/system_error/what&quot;
},
{
&quot;string&quot;: &quot;std::terminate&quot;,
&quot;target&quot;: &quot;cpp/error/terminate&quot;
},
{
&quot;string&quot;: &quot;std::terminate_handler&quot;,
&quot;target&quot;: &quot;cpp/error/terminate_handler&quot;
},
{
&quot;string&quot;: &quot;std::uncaught_exception&quot;,
&quot;target&quot;: &quot;cpp/error/uncaught_exception&quot;
},
{
&quot;string&quot;: &quot;std::underflow_error&quot;,
&quot;target&quot;: &quot;cpp/error/underflow_error&quot;
},
{
&quot;string&quot;: &quot;std::underflow_error::underflow_error&quot;,
&quot;target&quot;: &quot;cpp/error/underflow_error&quot;
},
{
&quot;string&quot;: &quot;std::unexpected&quot;,
&quot;target&quot;: &quot;cpp/error/unexpected&quot;
},
{
&quot;string&quot;: &quot;std::unexpected_handler&quot;,
&quot;target&quot;: &quot;cpp/error/unexpected_handler&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::basic_filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::wfilebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/close&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/close&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/close&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/close&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/imbue&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/is_open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/is_open&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/is_open&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/is_open&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/open&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/open&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/open&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/overflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/pbackfail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/setbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/showmanyc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/str&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/str&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/str&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_filebuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::filebuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wfilebuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/sync&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/sync&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/uflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/underflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::~basic_filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/~basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::~filebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/~basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::~wfilebuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_filebuf/~basic_filebuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::fstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::wfstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::basic_fstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::fstream::fstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::wfstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/basic_fstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/close&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/close&quot;
},
{
&quot;string&quot;: &quot;std::fstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/close&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/close&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/is_open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::fstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/open&quot;
},
{
&quot;string&quot;: &quot;std::fstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/open&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/open&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::fstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::fstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::fstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_fstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::fstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wfstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_fstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::ifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::wifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::basic_ifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::ifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::wifstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/basic_ifstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/close&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/close&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/close&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/close&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/is_open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/open&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/open&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/open&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_ifstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::ifstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wifstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ifstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::istream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::ostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::iostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::fstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wistream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::bad&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/bad&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::basic_ios&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/basic_ios&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::istream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::ostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::iostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::fstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wistream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::clear&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::istream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::ostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::iostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::fstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wistream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::copyfmt&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/copyfmt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::istream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::ostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::iostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::fstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wistream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::eof&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/eof&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::istream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::ostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::iostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::fstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wistream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::exceptions&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/exceptions&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::istream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::ostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::iostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::fstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wistream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::fail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fail&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::istream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::ostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::iostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::fstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wistream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::fill&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/fill&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::istream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::ostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::iostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::fstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wistream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::good&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/good&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::istream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::iostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::fstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wistream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::istream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::ostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::iostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::fstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wistream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::init&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/init&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::istream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::ostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::iostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::fstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wistream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::move&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/move&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::istream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::iostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::fstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wistream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::narrow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/narrow&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::istream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::ostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::iostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::fstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wistream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::operator!&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator!&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::istream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::ostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::iostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::fstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wistream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/operator_bool&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::istream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::iostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::fstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wistream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::istream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::rdstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/rdstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::istream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::iostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::fstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wistream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::set_rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/set_rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::istream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::setstate&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/setstate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::istream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::ostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::iostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::fstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wistream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::istream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::ostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::iostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::fstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wistream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::tie&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/tie&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::istream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::ostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::iostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::fstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wistream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::widen&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/widen&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::~basic_ios&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ios/~basic_ios&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::wiostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::basic_iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::iostream::iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::wiostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::~basic_iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/~basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::iostream::~iostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/~basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::~wiostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_iostream/~basic_iostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::wistream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::cin&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::wcin&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::basic_istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::istream::istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::wistream::wistream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::istream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::iostream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::fstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wistream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::gcount&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/gcount&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::istream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::iostream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::fstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wistream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::get&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/get&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::istream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::iostream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::fstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wistream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::getline&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/getline&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::istream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::iostream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::fstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wistream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::ignore&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/ignore&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::istream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::iostream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::fstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wistream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::basic_istream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt2&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::istream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt2&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::wistream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/operator_gtgt2&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::istream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::iostream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::fstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wistream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::peek&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/peek&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::istream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::iostream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::fstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wistream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::putback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/putback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::istream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::iostream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::fstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wistream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::read&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/read&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::istream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::iostream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::fstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wistream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::readsome&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/readsome&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::istream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::iostream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::fstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wistream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::seekg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/seekg&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::istream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::iostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::ifstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::fstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::istringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::stringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wistream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wiostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wifstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wfstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wistringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wstringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::istream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/sync&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::istream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::iostream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::fstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wistream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::tellg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/tellg&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::istream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::iostream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::fstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wistream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::unget&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/unget&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::~basic_istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/~basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::istream::~istream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/~basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::wistream::~wistream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istream/~basic_istream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::istringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::basic_istringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::istringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::wistringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/basic_istringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_istringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::istringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wistringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_istringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::ofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::wofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::basic_ofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::ofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::wofstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/basic_ofstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/close&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/close&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/close&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::close&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/close&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/is_open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::is_open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/is_open&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/open&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/open&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/open&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::open&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/open&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_ofstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::ofstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wofstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ofstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::cout&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wcout&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::cerr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wcerr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::clog&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wclog&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::basic_ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::ostream::ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wostream::wostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::ostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::iostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::fstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::flush&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/flush&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::ostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::iostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::fstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::basic_ostream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt2&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::ostream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt2&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::wostream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/operator_ltlt2&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::ostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::iostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::fstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::put&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/put&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::ostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::iostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::fstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::seekp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/seekp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::ostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::iostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::ofstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::fstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::ostringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::stringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wiostream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wofstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wfstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wostringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::~sentry&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sentry::operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;on_group&quot;: &quot;std::wstringstream::sentry&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/sentry&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::ostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::iostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::fstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::tellp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/tellp&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::ostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::iostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::fstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::write&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/write&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::~basic_ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/~basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::ostream::~ostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/~basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::wostream::~wostream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostream/~basic_ostream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::basic_ostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::ostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::wostringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/basic_ostringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_ostringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::ostringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wostringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_ostringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::basic_streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::wstreambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::gbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::gback&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::gptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::egptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/gptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::in_avail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/in_avail&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pbump&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pbump&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pbase&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::epptr&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pptr&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pubimbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubimbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pubseekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pubseekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubseekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pubsetbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsetbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pubsync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sync&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/pubsync&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sbumpc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sbumpc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::setg&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setg&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::setp&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/setp&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sgetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::xsgetn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sgetn&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::showmanyc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/showmanyc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::snextc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/snextc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sputbackc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputbackc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sputc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::sputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::xsputn&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/sputn&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::uflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/uflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_streambuf&quot;,
&quot;string&quot;: &quot;ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_filebuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_filebuf&quot;,
&quot;string&quot;: &quot;ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::filebuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::wfilebuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::basic_streambuf::~basic_streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/~basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::streambuf::~streambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/~basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::wstreambuf::~wstreambuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_streambuf/~basic_streambuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::basic_stringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::stringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::wstringbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/basic_stringbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/overflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::overflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/overflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/pbackfail&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::pbackfail&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/pbackfail&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekoff&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::seekoff&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekoff&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekpos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::seekpos&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/seekpos&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/setbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/str&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/str&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/str&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_stringbuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::stringbuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wstringbuf)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/swap2&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/underflow&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringbuf&quot;,
&quot;string&quot;: &quot;underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::stringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::wstringbuf::underflow&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringbuf/underflow&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::stringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::basic_stringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::stringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::wstringstream&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/basic_stringstream&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::operator=&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::str&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/str&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::swap&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_stringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::stringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wstringstream)&quot;,
&quot;target&quot;: &quot;cpp/io/basic_stringstream/swap2&quot;
},
{
&quot;string&quot;: &quot;std::FILE&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;std::fpos_t&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;stdin&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;stdout&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;stderr&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;EOF&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;FOPEN_MAX&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;FILENAME_MAX&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;BUFSIZ&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;_IOFBF&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;_IOLBF&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;_IONBF&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;SEEK_SET&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;SEEK_CUR&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;SEEK_END&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;TMP_MAX&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;L_tmpnam&quot;,
&quot;target&quot;: &quot;cpp/io/c&quot;
},
{
&quot;string&quot;: &quot;std::clearerr&quot;,
&quot;target&quot;: &quot;cpp/io/c/clearerr&quot;
},
{
&quot;string&quot;: &quot;std::fclose&quot;,
&quot;target&quot;: &quot;cpp/io/c/fclose&quot;
},
{
&quot;string&quot;: &quot;std::feof&quot;,
&quot;target&quot;: &quot;cpp/io/c/feof&quot;
},
{
&quot;string&quot;: &quot;std::ferror&quot;,
&quot;target&quot;: &quot;cpp/io/c/ferror&quot;
},
{
&quot;string&quot;: &quot;std::fflush&quot;,
&quot;target&quot;: &quot;cpp/io/c/fflush&quot;
},
{
&quot;string&quot;: &quot;std::fgetc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgetc&quot;
},
{
&quot;string&quot;: &quot;std::getc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgetc&quot;
},
{
&quot;string&quot;: &quot;std::fgetpos&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgetpos&quot;
},
{
&quot;string&quot;: &quot;std::fgets&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgets&quot;
},
{
&quot;string&quot;: &quot;std::fgetwc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgetwc&quot;
},
{
&quot;string&quot;: &quot;std::fgetss&quot;,
&quot;target&quot;: &quot;cpp/io/c/fgetws&quot;
},
{
&quot;string&quot;: &quot;std::fopen&quot;,
&quot;target&quot;: &quot;cpp/io/c/fopen&quot;
},
{
&quot;string&quot;: &quot;std::printf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fprintf&quot;
},
{
&quot;string&quot;: &quot;std::fprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fprintf&quot;
},
{
&quot;string&quot;: &quot;std::sprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fprintf&quot;
},
{
&quot;string&quot;: &quot;std::snprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fprintf&quot;
},
{
&quot;string&quot;: &quot;std::fputc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fputc&quot;
},
{
&quot;string&quot;: &quot;std::putc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fputc&quot;
},
{
&quot;string&quot;: &quot;std::fputs&quot;,
&quot;target&quot;: &quot;cpp/io/c/fputs&quot;
},
{
&quot;string&quot;: &quot;std::fputwc&quot;,
&quot;target&quot;: &quot;cpp/io/c/fputwc&quot;
},
{
&quot;string&quot;: &quot;std::fputws&quot;,
&quot;target&quot;: &quot;cpp/io/c/fputws&quot;
},
{
&quot;string&quot;: &quot;std::fread&quot;,
&quot;target&quot;: &quot;cpp/io/c/fread&quot;
},
{
&quot;string&quot;: &quot;std::freopen&quot;,
&quot;target&quot;: &quot;cpp/io/c/freopen&quot;
},
{
&quot;string&quot;: &quot;std::scanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fscanf&quot;
},
{
&quot;string&quot;: &quot;std::fscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fscanf&quot;
},
{
&quot;string&quot;: &quot;std::sscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fscanf&quot;
},
{
&quot;string&quot;: &quot;std::fseek&quot;,
&quot;target&quot;: &quot;cpp/io/c/fseek&quot;
},
{
&quot;string&quot;: &quot;std::fsetpos&quot;,
&quot;target&quot;: &quot;cpp/io/c/fsetpos&quot;
},
{
&quot;string&quot;: &quot;std::ftell&quot;,
&quot;target&quot;: &quot;cpp/io/c/ftell&quot;
},
{
&quot;string&quot;: &quot;std::wprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwprintf&quot;
},
{
&quot;string&quot;: &quot;std::fwprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwprintf&quot;
},
{
&quot;string&quot;: &quot;std::swprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwprintf&quot;
},
{
&quot;string&quot;: &quot;std::fwrite&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwrite&quot;
},
{
&quot;string&quot;: &quot;std::wscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwscanf&quot;
},
{
&quot;string&quot;: &quot;std::fwscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwscanf&quot;
},
{
&quot;string&quot;: &quot;std::swscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/fwscanf&quot;
},
{
&quot;string&quot;: &quot;std::getchar&quot;,
&quot;target&quot;: &quot;cpp/io/c/getchar&quot;
},
{
&quot;string&quot;: &quot;std::gets&quot;,
&quot;target&quot;: &quot;cpp/io/c/gets&quot;
},
{
&quot;string&quot;: &quot;std::getwchar&quot;,
&quot;target&quot;: &quot;cpp/io/c/getwchar&quot;
},
{
&quot;string&quot;: &quot;std::perror&quot;,
&quot;target&quot;: &quot;cpp/io/c/perror&quot;
},
{
&quot;string&quot;: &quot;std::putchar&quot;,
&quot;target&quot;: &quot;cpp/io/c/putchar&quot;
},
{
&quot;string&quot;: &quot;std::puts&quot;,
&quot;target&quot;: &quot;cpp/io/c/puts&quot;
},
{
&quot;string&quot;: &quot;std::putwchar&quot;,
&quot;target&quot;: &quot;cpp/io/c/putwchar&quot;
},
{
&quot;string&quot;: &quot;std::remove&quot;,
&quot;target&quot;: &quot;cpp/io/c/remove&quot;
},
{
&quot;string&quot;: &quot;std::rename&quot;,
&quot;target&quot;: &quot;cpp/io/c/rename&quot;
},
{
&quot;string&quot;: &quot;std::rewind&quot;,
&quot;target&quot;: &quot;cpp/io/c/rewind&quot;
},
{
&quot;string&quot;: &quot;std::setbuf&quot;,
&quot;target&quot;: &quot;cpp/io/c/setbuf&quot;
},
{
&quot;string&quot;: &quot;std::setvbuf&quot;,
&quot;target&quot;: &quot;cpp/io/c/setvbuf&quot;
},
{
&quot;string&quot;: &quot;std::tmpfile&quot;,
&quot;target&quot;: &quot;cpp/io/c/tmpfile&quot;
},
{
&quot;string&quot;: &quot;std::tmpnam&quot;,
&quot;target&quot;: &quot;cpp/io/c/tmpnam&quot;
},
{
&quot;string&quot;: &quot;std::ungetc&quot;,
&quot;target&quot;: &quot;cpp/io/c/ungetc&quot;
},
{
&quot;string&quot;: &quot;std::ungetwc&quot;,
&quot;target&quot;: &quot;cpp/io/c/ungetwc&quot;
},
{
&quot;string&quot;: &quot;std::vprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfprintf&quot;
},
{
&quot;string&quot;: &quot;std::vfprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfprintf&quot;
},
{
&quot;string&quot;: &quot;std::vsprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfprintf&quot;
},
{
&quot;string&quot;: &quot;std::vsnprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfprintf&quot;
},
{
&quot;string&quot;: &quot;std::vscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfscanf&quot;
},
{
&quot;string&quot;: &quot;std::vfscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfscanf&quot;
},
{
&quot;string&quot;: &quot;std::vsscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfscanf&quot;
},
{
&quot;string&quot;: &quot;std::vwprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwprintf&quot;
},
{
&quot;string&quot;: &quot;std::vfwprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwprintf&quot;
},
{
&quot;string&quot;: &quot;std::vswprintf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwprintf&quot;
},
{
&quot;string&quot;: &quot;std::vwscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwscanf&quot;
},
{
&quot;string&quot;: &quot;std::vfwscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwscanf&quot;
},
{
&quot;string&quot;: &quot;std::vswscanf&quot;,
&quot;target&quot;: &quot;cpp/io/c/vfwscanf&quot;
},
{
&quot;string&quot;: &quot;std::fpos&quot;,
&quot;target&quot;: &quot;cpp/io/fpos&quot;
},
{
&quot;string&quot;: &quot;std::streampos&quot;,
&quot;target&quot;: &quot;cpp/io/fpos&quot;
},
{
&quot;string&quot;: &quot;std::u16streampos&quot;,
&quot;target&quot;: &quot;cpp/io/fpos&quot;
},
{
&quot;string&quot;: &quot;std::u32streampos&quot;,
&quot;target&quot;: &quot;cpp/io/fpos&quot;
},
{
&quot;string&quot;: &quot;std::wstreampos&quot;,
&quot;target&quot;: &quot;cpp/io/fpos&quot;
},
{
&quot;string&quot;: &quot;std::fpos::state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;on_group&quot;: &quot;std::fpos&quot;,
&quot;string&quot;: &quot;state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;string&quot;: &quot;std::streampos::state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;string&quot;: &quot;std::u16streampos::state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;string&quot;: &quot;std::u32streampos::state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;string&quot;: &quot;std::wstreampos::state&quot;,
&quot;target&quot;: &quot;cpp/io/fpos/state&quot;
},
{
&quot;string&quot;: &quot;std::io_errc&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc&quot;
},
{
&quot;string&quot;: &quot;std::io_errc::stream&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc&quot;
},
{
&quot;on_group&quot;: &quot;std::io_errc&quot;,
&quot;string&quot;: &quot;stream&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc&quot;
},
{
&quot;string&quot;: &quot;std::is_error_code_enum&lt;std::io_errc&gt;&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc/is_error_code_enum&quot;
},
{
&quot;string&quot;: &quot;std::make_error_code(std::io_errc)&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc/make_error_code&quot;
},
{
&quot;string&quot;: &quot;std::make_error_condition(std::io_errc)&quot;,
&quot;target&quot;: &quot;cpp/io/io_errc/make_error_condition&quot;
},
{
&quot;string&quot;: &quot;std::ios_base&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::iostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::iostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::iostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::iostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::fstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::fstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::fstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::fstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::erase_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::imbue_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::copyfmt_event&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::istream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::ostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::iostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::fstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wistream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::event_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/event_callback&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::istream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::ostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::iostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::fstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wistream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::istream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::ostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::iostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::fstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wistream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::failure::failure&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/failure/failure&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::istream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::flags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/flags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::iostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::fstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::fmtflags&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::dec&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::oct&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::hex&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::basefield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::left&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::right&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::internal&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::adjustfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::floatfield&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/fmtflags&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::istream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::ostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::iostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::fstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wistream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::getloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/getloc&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::istream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::iostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::fstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wistream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::imbue&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/imbue&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::ios_base&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/ios_base&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::iostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::fstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::iostate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::goodbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::badbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::failbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::eofbit&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iostate&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::istream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::ostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::iostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::fstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wistream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::iword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/iword&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::iostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::fstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::openmode&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::app&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::binary&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::in&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::out&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::trunc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::ate&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/openmode&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::istream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::ostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::iostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::fstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wistream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::precision&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/precision&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::istream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::ostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::iostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::fstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wistream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::pword&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/pword&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::istream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::ostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::iostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::fstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wistream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::register_callback&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/register_callback&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::iostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::iostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::iostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::iostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::fstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::fstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::fstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::fstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::seekdir&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::beg&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::cur&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::end&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/seekdir&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::istream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::ostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::iostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::fstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wistream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::setf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/setf&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::istream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::ostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::iostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::fstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wistream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::sync_with_stdio&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/sync_with_stdio&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::istream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::ostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::iostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::fstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wistream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::unsetf&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/unsetf&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::istream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::ostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::iostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::fstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wistream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::width&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/width&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::ios_base&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ios::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ios&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_istream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_iostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_iostream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ifstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ifstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ofstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ofstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_fstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_fstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_istringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_istringstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_ostringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_ostringstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_stringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_stringstream&quot;,
&quot;string&quot;: &quot;xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::istream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::ostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::iostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::ifstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::ofstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::fstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::istringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::ostringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::stringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wistream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wiostream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wifstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wofstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wfstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wistringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wostringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::wstringstream::xalloc&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/xalloc&quot;
},
{
&quot;string&quot;: &quot;std::ios_base::~ios_base&quot;,
&quot;target&quot;: &quot;cpp/io/ios_base/~ios_base&quot;
},
{
&quot;string&quot;: &quot;std::boolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/manip/boolalpha&quot;
},
{
&quot;string&quot;: &quot;std::noboolalpha&quot;,
&quot;target&quot;: &quot;cpp/io/manip/boolalpha&quot;
},
{
&quot;string&quot;: &quot;std::endl&quot;,
&quot;target&quot;: &quot;cpp/io/manip/endl&quot;
},
{
&quot;string&quot;: &quot;std::ends&quot;,
&quot;target&quot;: &quot;cpp/io/manip/ends&quot;
},
{
&quot;string&quot;: &quot;std::fixed&quot;,
&quot;target&quot;: &quot;cpp/io/manip/fixed&quot;
},
{
&quot;string&quot;: &quot;std::scientific&quot;,
&quot;target&quot;: &quot;cpp/io/manip/fixed&quot;
},
{
&quot;string&quot;: &quot;std::hexfloat&quot;,
&quot;target&quot;: &quot;cpp/io/manip/fixed&quot;
},
{
&quot;string&quot;: &quot;std::defaultfloat&quot;,
&quot;target&quot;: &quot;cpp/io/manip/fixed&quot;
},
{
&quot;string&quot;: &quot;std::flush&quot;,
&quot;target&quot;: &quot;cpp/io/manip/flush&quot;
},
{
&quot;string&quot;: &quot;std::get_money&quot;,
&quot;target&quot;: &quot;cpp/io/manip/get_money&quot;
},
{
&quot;string&quot;: &quot;std::get_time&quot;,
&quot;target&quot;: &quot;cpp/io/manip/get_time&quot;
},
{
&quot;string&quot;: &quot;std::dec&quot;,
&quot;target&quot;: &quot;cpp/io/manip/hex&quot;
},
{
&quot;string&quot;: &quot;std::hex&quot;,
&quot;target&quot;: &quot;cpp/io/manip/hex&quot;
},
{
&quot;string&quot;: &quot;std::oct&quot;,
&quot;target&quot;: &quot;cpp/io/manip/hex&quot;
},
{
&quot;string&quot;: &quot;std::internal&quot;,
&quot;target&quot;: &quot;cpp/io/manip/left&quot;
},
{
&quot;string&quot;: &quot;std::left&quot;,
&quot;target&quot;: &quot;cpp/io/manip/left&quot;
},
{
&quot;string&quot;: &quot;std::right&quot;,
&quot;target&quot;: &quot;cpp/io/manip/left&quot;
},
{
&quot;string&quot;: &quot;std::put_money&quot;,
&quot;target&quot;: &quot;cpp/io/manip/put_money&quot;
},
{
&quot;string&quot;: &quot;std::put_time&quot;,
&quot;target&quot;: &quot;cpp/io/manip/put_time&quot;
},
{
&quot;string&quot;: &quot;std::resetiosflags&quot;,
&quot;target&quot;: &quot;cpp/io/manip/resetiosflags&quot;
},
{
&quot;string&quot;: &quot;std::setbase&quot;,
&quot;target&quot;: &quot;cpp/io/manip/setbase&quot;
},
{
&quot;string&quot;: &quot;std::setfill&quot;,
&quot;target&quot;: &quot;cpp/io/manip/setfill&quot;
},
{
&quot;string&quot;: &quot;std::setiosflags&quot;,
&quot;target&quot;: &quot;cpp/io/manip/setiosflags&quot;
},
{
&quot;string&quot;: &quot;std::setprecision&quot;,
&quot;target&quot;: &quot;cpp/io/manip/setprecision&quot;
},
{
&quot;string&quot;: &quot;std::setw&quot;,
&quot;target&quot;: &quot;cpp/io/manip/setw&quot;
},
{
&quot;string&quot;: &quot;std::showbase&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showbase&quot;
},
{
&quot;string&quot;: &quot;std::noshowbase&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showbase&quot;
},
{
&quot;string&quot;: &quot;std::showpoint&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showpoint&quot;
},
{
&quot;string&quot;: &quot;std::noshowpoint&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showpoint&quot;
},
{
&quot;string&quot;: &quot;std::showpos&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showpos&quot;
},
{
&quot;string&quot;: &quot;std::noshowpos&quot;,
&quot;target&quot;: &quot;cpp/io/manip/showpos&quot;
},
{
&quot;string&quot;: &quot;std::skipws&quot;,
&quot;target&quot;: &quot;cpp/io/manip/skipws&quot;
},
{
&quot;string&quot;: &quot;std::noskipws&quot;,
&quot;target&quot;: &quot;cpp/io/manip/skipws&quot;
},
{
&quot;string&quot;: &quot;std::unitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/manip/unitbuf&quot;
},
{
&quot;string&quot;: &quot;std::nounitbuf&quot;,
&quot;target&quot;: &quot;cpp/io/manip/unitbuf&quot;
},
{
&quot;string&quot;: &quot;std::uppercase&quot;,
&quot;target&quot;: &quot;cpp/io/manip/uppercase&quot;
},
{
&quot;string&quot;: &quot;std::nouppercase&quot;,
&quot;target&quot;: &quot;cpp/io/manip/uppercase&quot;
},
{
&quot;string&quot;: &quot;std::ws&quot;,
&quot;target&quot;: &quot;cpp/io/manip/ws&quot;
},
{
&quot;string&quot;: &quot;std::streamoff&quot;,
&quot;target&quot;: &quot;cpp/io/streamoff&quot;
},
{
&quot;string&quot;: &quot;std::streamsize&quot;,
&quot;target&quot;: &quot;cpp/io/streamsize&quot;
},
{
&quot;string&quot;: &quot;std::advance&quot;,
&quot;target&quot;: &quot;cpp/iterator/advance&quot;
},
{
&quot;string&quot;: &quot;std::back_insert_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/back_insert_iterator&quot;
},
{
&quot;string&quot;: &quot;std::back_inserter&quot;,
&quot;target&quot;: &quot;cpp/iterator/back_inserter&quot;
},
{
&quot;string&quot;: &quot;std::begin&quot;,
&quot;target&quot;: &quot;cpp/iterator/begin&quot;
},
{
&quot;string&quot;: &quot;std::distance&quot;,
&quot;target&quot;: &quot;cpp/iterator/distance&quot;
},
{
&quot;string&quot;: &quot;std::end&quot;,
&quot;target&quot;: &quot;cpp/iterator/end&quot;
},
{
&quot;string&quot;: &quot;std::front_insert_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/front_insert_iterator&quot;
},
{
&quot;string&quot;: &quot;std::front_inserter&quot;,
&quot;target&quot;: &quot;cpp/iterator/front_inserter&quot;
},
{
&quot;string&quot;: &quot;std::insert_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/insert_iterator&quot;
},
{
&quot;string&quot;: &quot;std::inserter&quot;,
&quot;target&quot;: &quot;cpp/iterator/inserter&quot;
},
{
&quot;string&quot;: &quot;std::istream_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/istream_iterator&quot;
},
{
&quot;string&quot;: &quot;std::istreambuf_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/istreambuf_iterator&quot;
},
{
&quot;string&quot;: &quot;std::iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator&quot;
},
{
&quot;string&quot;: &quot;std::input_iterator_tag&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_tags&quot;
},
{
&quot;string&quot;: &quot;std::output_iterator_tag&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_tags&quot;
},
{
&quot;string&quot;: &quot;std::forward_iterator_tag&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_tags&quot;
},
{
&quot;string&quot;: &quot;std::bidirectional_iterator_tag&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_tags&quot;
},
{
&quot;string&quot;: &quot;std::random_access_iterator_tag&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_tags&quot;
},
{
&quot;string&quot;: &quot;std::iterator_traits&quot;,
&quot;target&quot;: &quot;cpp/iterator/iterator_traits&quot;
},
{
&quot;string&quot;: &quot;std::make_move_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/make_move_iterator&quot;
},
{
&quot;string&quot;: &quot;std::move_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/move_iterator&quot;
},
{
&quot;string&quot;: &quot;std::next&quot;,
&quot;target&quot;: &quot;cpp/iterator/next&quot;
},
{
&quot;string&quot;: &quot;std::ostream_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/ostream_iterator&quot;
},
{
&quot;string&quot;: &quot;std::ostreambuf_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/ostreambuf_iterator&quot;
},
{
&quot;string&quot;: &quot;std::prev&quot;,
&quot;target&quot;: &quot;cpp/iterator/prev&quot;
},
{
&quot;string&quot;: &quot;std::reverse_iterator&quot;,
&quot;target&quot;: &quot;cpp/iterator/reverse_iterator&quot;
},
{
&quot;string&quot;: &quot;LC_ALL&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;LC_COLLATE&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;LC_CTYPE&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;LC_MONETARY&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;LC_NUMERIC&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;LC_TIME&quot;,
&quot;target&quot;: &quot;cpp/locale/LC_categories&quot;
},
{
&quot;string&quot;: &quot;std::codecvt&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::intern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::extern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::state_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::intern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::extern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::state_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::intern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::extern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::state_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::intern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::extern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::state_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::intern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::extern_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::state_type&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_always_noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/always_noconv&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::codecvt&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_encoding&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/encoding&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_in&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/in&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_max_length&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/max_length&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_out&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/out&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;do_unshift&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/unshift&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::~codecvt&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt/~codecvt&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_base&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_base&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_base&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_base&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_base::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_base&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_byname&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf16&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;result&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;ok&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;partial&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;error&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16::noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;on_group&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;string&quot;: &quot;noconv&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_base&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_byname&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::codecvt_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_byname/codecvt_byname&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_byname::~codecvt_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_byname/~codecvt_byname&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_mode&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_mode&quot;
},
{
&quot;string&quot;: &quot;std::consume_header&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_mode&quot;
},
{
&quot;string&quot;: &quot;std::generate_header&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_mode&quot;
},
{
&quot;string&quot;: &quot;std::little_endian&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_mode&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf16&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_utf16&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_utf8&quot;
},
{
&quot;string&quot;: &quot;std::codecvt_utf8_utf16&quot;,
&quot;target&quot;: &quot;cpp/locale/codecvt_utf8_utf16&quot;
},
{
&quot;string&quot;: &quot;std::collate&quot;,
&quot;target&quot;: &quot;cpp/locale/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate::collate&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/collate&quot;
},
{
&quot;string&quot;: &quot;std::collate::compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;string&quot;: &quot;std::collate::do_compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;do_compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::do_compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;do_compare&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/compare&quot;
},
{
&quot;string&quot;: &quot;std::collate::hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;string&quot;: &quot;std::collate::do_hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;do_hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::do_hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;do_hash&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/hash&quot;
},
{
&quot;string&quot;: &quot;std::collate::transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;string&quot;: &quot;std::collate::do_transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;on_group&quot;: &quot;std::collate&quot;,
&quot;string&quot;: &quot;do_transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::do_transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;on_group&quot;: &quot;std::collate_byname&quot;,
&quot;string&quot;: &quot;do_transform&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/transform&quot;
},
{
&quot;string&quot;: &quot;std::collate::~collate&quot;,
&quot;target&quot;: &quot;cpp/locale/collate/~collate&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/collate_byname&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::collate_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/collate_byname/collate_byname&quot;
},
{
&quot;string&quot;: &quot;std::collate_byname::~collate_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/collate_byname/~collate_byname&quot;
},
{
&quot;string&quot;: &quot;std::ctype&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype&quot;
},
{
&quot;string&quot;: &quot;std::ctype::ctype&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/ctype&quot;
},
{
&quot;string&quot;: &quot;std::ctype::is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/is&quot;
},
{
&quot;string&quot;: &quot;std::ctype::narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_narrow&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/narrow&quot;
},
{
&quot;string&quot;: &quot;std::ctype::scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_scan_is&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/scan_is&quot;
},
{
&quot;string&quot;: &quot;std::ctype::tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_tolower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/tolower&quot;
},
{
&quot;string&quot;: &quot;std::ctype::toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_toupper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/toupper&quot;
},
{
&quot;string&quot;: &quot;std::ctype::widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;string&quot;: &quot;std::ctype::do_widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;do_widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::do_widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;do_widen&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/widen&quot;
},
{
&quot;string&quot;: &quot;std::ctype::~ctype&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype/~ctype&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::mask&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_base::graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_base&quot;,
&quot;string&quot;: &quot;graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::mask&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype::graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype&quot;,
&quot;string&quot;: &quot;graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::mask&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;print&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;cntrl&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;upper&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;lower&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;alpha&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;digit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;punct&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;xdigit&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;blank&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;alnum&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;on_group&quot;: &quot;std::ctype_byname&quot;,
&quot;string&quot;: &quot;graph&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_base&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_byname&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::ctype_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_byname/ctype_byname&quot;
},
{
&quot;string&quot;: &quot;std::ctype_byname::~ctype_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/ctype_byname/~ctype_byname&quot;
},
{
&quot;string&quot;: &quot;std::has_facet&quot;,
&quot;target&quot;: &quot;cpp/locale/has_facet&quot;
},
{
&quot;string&quot;: &quot;std::lconv&quot;,
&quot;target&quot;: &quot;cpp/locale/lconv&quot;
},
{
&quot;string&quot;: &quot;std::locale&quot;,
&quot;target&quot;: &quot;cpp/locale/locale&quot;
},
{
&quot;string&quot;: &quot;std::locale::classic&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/classic&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;classic&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/classic&quot;
},
{
&quot;string&quot;: &quot;std::locale::combine&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/combine&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;combine&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/combine&quot;
},
{
&quot;string&quot;: &quot;std::locale::facet&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/facet&quot;
},
{
&quot;string&quot;: &quot;std::locale::facet::facet&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/facet/facet&quot;
},
{
&quot;string&quot;: &quot;std::locale::global&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/global&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;global&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/global&quot;
},
{
&quot;string&quot;: &quot;std::locale::id&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/id&quot;
},
{
&quot;string&quot;: &quot;std::locale::id::id&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/id/id&quot;
},
{
&quot;string&quot;: &quot;std::locale::locale&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/locale&quot;
},
{
&quot;string&quot;: &quot;std::locale::name&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/name&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;name&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/name&quot;
},
{
&quot;string&quot;: &quot;std::locale::operator()&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator()&quot;
},
{
&quot;string&quot;: &quot;std::locale::operator=&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator=&quot;
},
{
&quot;string&quot;: &quot;std::locale::operator==&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::locale::operator!=&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::locale&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::locale::~locale&quot;,
&quot;target&quot;: &quot;cpp/locale/locale/~locale&quot;
},
{
&quot;string&quot;: &quot;std::localeconv&quot;,
&quot;target&quot;: &quot;cpp/locale/localeconv&quot;
},
{
&quot;string&quot;: &quot;std::messages&quot;,
&quot;target&quot;: &quot;cpp/locale/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages::close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;string&quot;: &quot;std::messages::do_close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;do_close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::do_close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;do_close&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/close&quot;
},
{
&quot;string&quot;: &quot;std::messages::get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;string&quot;: &quot;std::messages::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/get&quot;
},
{
&quot;string&quot;: &quot;std::messages::messages&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/messages&quot;
},
{
&quot;string&quot;: &quot;std::messages::open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;string&quot;: &quot;std::messages::do_open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;on_group&quot;: &quot;std::messages&quot;,
&quot;string&quot;: &quot;do_open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::do_open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;on_group&quot;: &quot;std::messages_byname&quot;,
&quot;string&quot;: &quot;do_open&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/open&quot;
},
{
&quot;string&quot;: &quot;std::messages::~messages&quot;,
&quot;target&quot;: &quot;cpp/locale/messages/~messages&quot;
},
{
&quot;string&quot;: &quot;std::messages_base&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_base&quot;
},
{
&quot;string&quot;: &quot;std::messages_base::catalog&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_base&quot;
},
{
&quot;string&quot;: &quot;std::messages::catalog&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_base&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::catalog&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_base&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_byname&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::messages_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_byname/messages_byname&quot;
},
{
&quot;string&quot;: &quot;std::messages_byname::~messages_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/messages_byname/~messages_byname&quot;
},
{
&quot;string&quot;: &quot;std::money_base&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_base::pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_base&quot;,
&quot;string&quot;: &quot;pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get::pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_put::pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;part&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;space&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;sign&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;pattern&quot;,
&quot;target&quot;: &quot;cpp/locale/money_base&quot;
},
{
&quot;string&quot;: &quot;std::money_get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::money_get&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::money_get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_get::~money_get&quot;,
&quot;target&quot;: &quot;cpp/locale/money_get/~money_get&quot;
},
{
&quot;string&quot;: &quot;std::money_put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::money_put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/money_put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::money_put&quot;,
&quot;string&quot;: &quot;do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/put&quot;
},
{
&quot;string&quot;: &quot;std::money_put::~money_put&quot;,
&quot;target&quot;: &quot;cpp/locale/money_put/~money_put&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_curr_symbol&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/curr_symbol&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_frac_digits&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/frac_digits&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::moneypunct&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_neg_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/neg_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_negative_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/negative_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_pos_format&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/pos_format&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_positive_sign&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/positive_sign&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct&quot;,
&quot;string&quot;: &quot;do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::moneypunct_byname&quot;,
&quot;string&quot;: &quot;do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct::~moneypunct&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct/~moneypunct&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::moneypunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct_byname/moneypunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::moneypunct_byname::~moneypunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/moneypunct_byname/~moneypunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::num_get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::num_get&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::num_get&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::num_get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/num_get&quot;
},
{
&quot;string&quot;: &quot;std::num_get::~num_get&quot;,
&quot;target&quot;: &quot;cpp/locale/num_get/~num_get&quot;
},
{
&quot;string&quot;: &quot;std::num_put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::num_put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/num_put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::num_put&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::num_put&quot;,
&quot;string&quot;: &quot;do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/put&quot;
},
{
&quot;string&quot;: &quot;std::num_put::~num_put&quot;,
&quot;target&quot;: &quot;cpp/locale/num_put/~num_put&quot;
},
{
&quot;string&quot;: &quot;std::numpunct&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::string_type&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;do_decimal_point&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/decimal_point&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;do_grouping&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/grouping&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::numpunct&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;do_thousands_sep&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/thousands_sep&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::do_truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;do_truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::do_falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct&quot;,
&quot;string&quot;: &quot;do_falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::do_truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;do_truename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::do_falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;on_group&quot;: &quot;std::numpunct_byname&quot;,
&quot;string&quot;: &quot;do_falsename&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/truefalsename&quot;
},
{
&quot;string&quot;: &quot;std::numpunct::~numpunct&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct/~numpunct&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::numpunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct_byname/numpunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::numpunct_byname::~numpunct_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/numpunct_byname/~numpunct_byname&quot;
},
{
&quot;string&quot;: &quot;std::setlocale&quot;,
&quot;target&quot;: &quot;cpp/locale/setlocale&quot;
},
{
&quot;string&quot;: &quot;std::time_base&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_base::ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_base&quot;,
&quot;string&quot;: &quot;ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get::ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put::ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;dateorder&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;no_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;dmy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;mdy&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;ymd&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;ydm&quot;,
&quot;target&quot;: &quot;cpp/locale/time_base&quot;
},
{
&quot;string&quot;: &quot;std::time_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_date_order&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/date_order&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get_date&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_date&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get_monthname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_monthname&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get_time&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_time&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get_weekday&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_weekday&quot;
},
{
&quot;string&quot;: &quot;std::time_get::get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;string&quot;: &quot;std::time_get::do_get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get&quot;,
&quot;string&quot;: &quot;do_get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::do_get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;on_group&quot;: &quot;std::time_get_byname&quot;,
&quot;string&quot;: &quot;do_get_year&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/get_year&quot;
},
{
&quot;string&quot;: &quot;std::time_get::time_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get::~time_get&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get/~time_get&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get_byname&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::time_get_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get_byname/time_get_byname&quot;
},
{
&quot;string&quot;: &quot;std::time_get_byname::~time_get_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_get_byname/~time_get_byname&quot;
},
{
&quot;string&quot;: &quot;std::time_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::char_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::iter_type&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put&quot;,
&quot;string&quot;: &quot;do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;on_group&quot;: &quot;std::time_put_byname&quot;,
&quot;string&quot;: &quot;do_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::time_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put::~time_put&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put/~time_put&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put_byname&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::time_put_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put_byname/time_put_byname&quot;
},
{
&quot;string&quot;: &quot;std::time_put_byname::~time_put_byname&quot;,
&quot;target&quot;: &quot;cpp/locale/time_put_byname/~time_put_byname&quot;
},
{
&quot;string&quot;: &quot;std::use_facet&quot;,
&quot;target&quot;: &quot;cpp/locale/use_facet&quot;
},
{
&quot;string&quot;: &quot;std::wbuffer_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert&quot;
},
{
&quot;string&quot;: &quot;std::wbuffer_convert::rdbuf&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/rdbuf&quot;
},
{
&quot;on_group&quot;: &quot;std::wbuffer_convert&quot;,
&quot;string&quot;: &quot;rdbuf&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/rdbuf&quot;
},
{
&quot;string&quot;: &quot;std::wbuffer_convert::state&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/state&quot;
},
{
&quot;on_group&quot;: &quot;std::wbuffer_convert&quot;,
&quot;string&quot;: &quot;state&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/state&quot;
},
{
&quot;string&quot;: &quot;std::wbuffer_convert::wbuffer_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/wbuffer_convert&quot;
},
{
&quot;string&quot;: &quot;std::wbuffer_convert::~wbuffer_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wbuffer_convert/~wbuffer_convert&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::converted&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/converted&quot;
},
{
&quot;on_group&quot;: &quot;std::wstring_convert&quot;,
&quot;string&quot;: &quot;converted&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/converted&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::from_bytes&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/from_bytes&quot;
},
{
&quot;on_group&quot;: &quot;std::wstring_convert&quot;,
&quot;string&quot;: &quot;from_bytes&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/from_bytes&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::state&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/state&quot;
},
{
&quot;on_group&quot;: &quot;std::wstring_convert&quot;,
&quot;string&quot;: &quot;state&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/state&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::to_bytes&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/to_bytes&quot;
},
{
&quot;on_group&quot;: &quot;std::wstring_convert&quot;,
&quot;string&quot;: &quot;to_bytes&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/to_bytes&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::wstring_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/wstring_convert&quot;
},
{
&quot;string&quot;: &quot;std::wstring_convert::~wstring_convert&quot;,
&quot;target&quot;: &quot;cpp/locale/wstring_convert/~wstring_convert&quot;
},
{
&quot;string&quot;: &quot;std::addressof&quot;,
&quot;target&quot;: &quot;cpp/memory/addressof&quot;
},
{
&quot;string&quot;: &quot;std::align&quot;,
&quot;target&quot;: &quot;cpp/memory/align&quot;
},
{
&quot;string&quot;: &quot;std::allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator&quot;
},
{
&quot;string&quot;: &quot;std::allocator::address&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/address&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;address&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/address&quot;
},
{
&quot;string&quot;: &quot;std::allocator::allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/allocate&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/allocate&quot;
},
{
&quot;string&quot;: &quot;std::allocator::allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/allocator&quot;
},
{
&quot;string&quot;: &quot;std::allocator::construct&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/construct&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;construct&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/construct&quot;
},
{
&quot;string&quot;: &quot;std::allocator::deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/deallocate&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/deallocate&quot;
},
{
&quot;string&quot;: &quot;std::allocator::destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/destroy&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/destroy&quot;
},
{
&quot;string&quot;: &quot;std::allocator::max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/max_size&quot;
},
{
&quot;string&quot;: &quot;operator==(std::allocator)&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::allocator)&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::allocator::~allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator/~allocator&quot;
},
{
&quot;string&quot;: &quot;std::allocator_arg&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_arg&quot;
},
{
&quot;string&quot;: &quot;std::allocator_arg_t&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_arg_t&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/allocate&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/allocate&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::construct&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/construct&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;construct&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/construct&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/deallocate&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/deallocate&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/destroy&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/destroy&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/max_size&quot;
},
{
&quot;string&quot;: &quot;std::allocator_traits::select_on_container_copy_construction&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/select_on_container_copy_construction&quot;
},
{
&quot;on_group&quot;: &quot;std::allocator_traits&quot;,
&quot;string&quot;: &quot;select_on_container_copy_construction&quot;,
&quot;target&quot;: &quot;cpp/memory/allocator_traits/select_on_container_copy_construction&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::auto_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/auto_ptr&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::get&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/get&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/get&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/operator=&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::release&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/release&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;release&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/release&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::reset&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::auto_ptr&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/reset&quot;
},
{
&quot;string&quot;: &quot;std::auto_ptr::~auto_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/auto_ptr/~auto_ptr&quot;
},
{
&quot;string&quot;: &quot;std::bad_weak_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/bad_weak_ptr&quot;
},
{
&quot;string&quot;: &quot;std::bad_weak_ptr::bad_weak_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/bad_weak_ptr/bad_weak_ptr&quot;
},
{
&quot;string&quot;: &quot;std::bad_weak_ptr::what&quot;,
&quot;target&quot;: &quot;cpp/memory/bad_weak_ptr/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_weak_ptr&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/memory/bad_weak_ptr/what&quot;
},
{
&quot;string&quot;: &quot;std::calloc&quot;,
&quot;target&quot;: &quot;cpp/memory/c/calloc&quot;
},
{
&quot;string&quot;: &quot;std::free&quot;,
&quot;target&quot;: &quot;cpp/memory/c/free&quot;
},
{
&quot;string&quot;: &quot;std::malloc&quot;,
&quot;target&quot;: &quot;cpp/memory/c/malloc&quot;
},
{
&quot;string&quot;: &quot;std::realloc&quot;,
&quot;target&quot;: &quot;cpp/memory/c/realloc&quot;
},
{
&quot;string&quot;: &quot;std::default_delete&quot;,
&quot;target&quot;: &quot;cpp/memory/default_delete&quot;
},
{
&quot;string&quot;: &quot;std::default_delete::default_delete&quot;,
&quot;target&quot;: &quot;cpp/memory/default_delete&quot;
},
{
&quot;string&quot;: &quot;std::default_delete::operator()&quot;,
&quot;target&quot;: &quot;cpp/memory/default_delete&quot;
},
{
&quot;on_group&quot;: &quot;std::default_delete&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/memory/default_delete&quot;
},
{
&quot;string&quot;: &quot;std::enable_shared_from_this&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this&quot;
},
{
&quot;string&quot;: &quot;std::enable_shared_from_this::enable_shared_from_this&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/enable_shared_from_this&quot;
},
{
&quot;string&quot;: &quot;std::enable_shared_from_this::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::enable_shared_from_this&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/operator=&quot;
},
{
&quot;string&quot;: &quot;std::enable_shared_from_this::shared_from_this&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/shared_from_this&quot;
},
{
&quot;on_group&quot;: &quot;std::enable_shared_from_this&quot;,
&quot;string&quot;: &quot;shared_from_this&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/shared_from_this&quot;
},
{
&quot;string&quot;: &quot;std::enable_shared_from_this::~enable_shared_from_this&quot;,
&quot;target&quot;: &quot;cpp/memory/enable_shared_from_this/~enable_shared_from_this&quot;
},
{
&quot;string&quot;: &quot;std::declare_no_pointers&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/declare_no_pointers&quot;
},
{
&quot;string&quot;: &quot;std::declare_reachable&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/declare_reachable&quot;
},
{
&quot;string&quot;: &quot;std::get_pointer_safety&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/get_pointer_safety&quot;
},
{
&quot;string&quot;: &quot;std::pointer_safety&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;string&quot;: &quot;std::pointer_safety::relaxed&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;on_group&quot;: &quot;std::pointer_safety&quot;,
&quot;string&quot;: &quot;relaxed&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;string&quot;: &quot;std::pointer_safety::preferred&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;on_group&quot;: &quot;std::pointer_safety&quot;,
&quot;string&quot;: &quot;preferred&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;string&quot;: &quot;std::pointer_safety::strict&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;on_group&quot;: &quot;std::pointer_safety&quot;,
&quot;string&quot;: &quot;strict&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/pointer_safety&quot;
},
{
&quot;string&quot;: &quot;std::undeclare_no_pointers&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/undeclare_no_pointers&quot;
},
{
&quot;string&quot;: &quot;std::undeclare_reachable&quot;,
&quot;target&quot;: &quot;cpp/memory/gc/undeclare_reachable&quot;
},
{
&quot;string&quot;: &quot;std::get_temporary_buffer&quot;,
&quot;target&quot;: &quot;cpp/memory/get_temporary_buffer&quot;
},
{
&quot;string&quot;: &quot;std::bad_alloc&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_alloc::bad_alloc&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_alloc::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_alloc&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_alloc::what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_alloc&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_new_length::what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_array_new_length&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_length::what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_array_length&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_alloc&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_length&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_array_length&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_length::bad_array_length&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_array_length&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_new_length&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_array_new_length&quot;
},
{
&quot;string&quot;: &quot;std::bad_array_new_length::bad_array_new_length&quot;,
&quot;target&quot;: &quot;cpp/memory/new/bad_array_new_length/bad_array_new_length&quot;
},
{
&quot;string&quot;: &quot;std::get_new_handler&quot;,
&quot;target&quot;: &quot;cpp/memory/new/get_new_handler&quot;
},
{
&quot;string&quot;: &quot;std::new_handler&quot;,
&quot;target&quot;: &quot;cpp/memory/new/new_handler&quot;
},
{
&quot;string&quot;: &quot;std::nothrow&quot;,
&quot;target&quot;: &quot;cpp/memory/new/nothrow&quot;
},
{
&quot;string&quot;: &quot;std::nothrow_t&quot;,
&quot;target&quot;: &quot;cpp/memory/new/nothrow_t&quot;
},
{
&quot;string&quot;: &quot;operator delete&quot;,
&quot;target&quot;: &quot;cpp/memory/new/operator_delete&quot;
},
{
&quot;string&quot;: &quot;operator delete[]&quot;,
&quot;target&quot;: &quot;cpp/memory/new/operator_delete&quot;
},
{
&quot;string&quot;: &quot;operator new&quot;,
&quot;target&quot;: &quot;cpp/memory/new/operator_new&quot;
},
{
&quot;string&quot;: &quot;operator new[]&quot;,
&quot;target&quot;: &quot;cpp/memory/new/operator_new&quot;
},
{
&quot;string&quot;: &quot;std::set_new_handler&quot;,
&quot;target&quot;: &quot;cpp/memory/new/set_new_handler&quot;
},
{
&quot;string&quot;: &quot;std::owner_less&quot;,
&quot;target&quot;: &quot;cpp/memory/owner_less&quot;
},
{
&quot;string&quot;: &quot;std::owner_less::operator()&quot;,
&quot;target&quot;: &quot;cpp/memory/owner_less&quot;
},
{
&quot;on_group&quot;: &quot;std::owner_less&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/memory/owner_less&quot;
},
{
&quot;string&quot;: &quot;std::pointer_traits&quot;,
&quot;target&quot;: &quot;cpp/memory/pointer_traits&quot;
},
{
&quot;string&quot;: &quot;std::pointer_traits::pointer_to&quot;,
&quot;target&quot;: &quot;cpp/memory/pointer_traits/pointer_to&quot;
},
{
&quot;on_group&quot;: &quot;std::pointer_traits&quot;,
&quot;string&quot;: &quot;pointer_to&quot;,
&quot;target&quot;: &quot;cpp/memory/pointer_traits/pointer_to&quot;
},
{
&quot;string&quot;: &quot;std::raw_storage_iterator&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator&quot;
},
{
&quot;string&quot;: &quot;std::raw_storage_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::raw_storage_iterator&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::raw_storage_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator++&quot;
},
{
&quot;on_group&quot;: &quot;std::raw_storage_iterator&quot;,
&quot;string&quot;: &quot;operator++&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator++&quot;
},
{
&quot;string&quot;: &quot;std::raw_storage_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::raw_storage_iterator&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::raw_storage_iterator::raw_storage_iterator&quot;,
&quot;target&quot;: &quot;cpp/memory/raw_storage_iterator/raw_storage_iterator&quot;
},
{
&quot;string&quot;: &quot;std::return_temporary_buffer&quot;,
&quot;target&quot;: &quot;cpp/memory/return_temporary_buffer&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/allocate&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;allocate&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/allocate&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::construct&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/construct&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;construct&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/construct&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/deallocate&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;deallocate&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/deallocate&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/destroy&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;destroy&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/destroy&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::inner_allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/inner_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;inner_allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/inner_allocator&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/max_size&quot;
},
{
&quot;string&quot;: &quot;operator==(std::scoped_allocator_adaptor)&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::scoped_allocator_adaptor)&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::outer_allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/outer_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;outer_allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/outer_allocator&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::scoped_allocator_adaptor&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/scoped_allocator_adaptor&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::select_on_container_copy_construction&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction&quot;
},
{
&quot;on_group&quot;: &quot;std::scoped_allocator_adaptor&quot;,
&quot;string&quot;: &quot;select_on_container_copy_construction&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction&quot;
},
{
&quot;string&quot;: &quot;std::scoped_allocator_adaptor::~scoped_allocator_adaptor&quot;,
&quot;target&quot;: &quot;cpp/memory/scoped_allocator_adaptor/~scoped_allocator_adaptor&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr&quot;
},
{
&quot;string&quot;: &quot;std::allocate_shared&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/allocate_shared&quot;
},
{
&quot;string&quot;: &quot;std::atomic_is_lock_free(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_load(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_load_explicit(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_store(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_store_explicit(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_exchange(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::atomic_exchange_explicit(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::compare_exchange_weak(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::compare_exchange_strong(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::compare_exchange_weak_explicit(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::compare_exchange_strong_explicit(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/atomic&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::get&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/get&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/get&quot;
},
{
&quot;string&quot;: &quot;std::get_deleter(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/get_deleter&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::shared_ptr&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/hash&quot;
},
{
&quot;string&quot;: &quot;std::make_shared&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/make_shared&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::operator bool&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator bool&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator bool&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::owner_before&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/owner_before&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;owner_before&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/owner_before&quot;
},
{
&quot;string&quot;: &quot;std::static_pointer_cast&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/pointer_cast&quot;
},
{
&quot;string&quot;: &quot;std::dynamic_pointer_cast&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/pointer_cast&quot;
},
{
&quot;string&quot;: &quot;std::const_pointer_cast&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/pointer_cast&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::reset&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/reset&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::shared_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/shared_ptr&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::swap&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::shared_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/swap2&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::unique&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/unique&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_ptr&quot;,
&quot;string&quot;: &quot;unique&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/unique&quot;
},
{
&quot;string&quot;: &quot;std::shared_ptr::~shared_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/shared_ptr/~shared_ptr&quot;
},
{
&quot;string&quot;: &quot;std::uninitialized_copy&quot;,
&quot;target&quot;: &quot;cpp/memory/uninitialized_copy&quot;
},
{
&quot;string&quot;: &quot;std::uninitialized_copy_n&quot;,
&quot;target&quot;: &quot;cpp/memory/uninitialized_copy_n&quot;
},
{
&quot;string&quot;: &quot;std::uninitialized_fill&quot;,
&quot;target&quot;: &quot;cpp/memory/uninitialized_fill&quot;
},
{
&quot;string&quot;: &quot;std::uninitialized_fill_n&quot;,
&quot;target&quot;: &quot;cpp/memory/uninitialized_fill_n&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::get&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/get&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/get&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::get_deleter&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/get_deleter&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;get_deleter&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/get_deleter&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::unique_ptr&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/hash&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::operator bool&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator bool&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator bool&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator*&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::release&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/release&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;release&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/release&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::reset&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/reset&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::swap&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_ptr&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unique_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::unique_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/unique_ptr&quot;
},
{
&quot;string&quot;: &quot;std::unique_ptr::~unique_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/unique_ptr/~unique_ptr&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&quot;,
&quot;target&quot;: &quot;cpp/memory/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::expired&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/expired&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;expired&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/expired&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::lock&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/lock&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/operator=&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::owner_before&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/owner_before&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;owner_before&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/owner_before&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::reset&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/reset&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::swap&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::weak_ptr)&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/swap&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::use_count&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/use_count&quot;
},
{
&quot;on_group&quot;: &quot;std::weak_ptr&quot;,
&quot;string&quot;: &quot;use_count&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/use_count&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::weak_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/weak_ptr&quot;
},
{
&quot;string&quot;: &quot;std::weak_ptr::~weak_ptr&quot;,
&quot;target&quot;: &quot;cpp/memory/weak_ptr/~weak_ptr&quot;
},
{
&quot;string&quot;: &quot;std::complex&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex&quot;
},
{
&quot;string&quot;: &quot;std::abs(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/abs&quot;
},
{
&quot;string&quot;: &quot;std::acos(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/acos&quot;
},
{
&quot;string&quot;: &quot;std::acosh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/acosh&quot;
},
{
&quot;string&quot;: &quot;std::arg(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/arg&quot;
},
{
&quot;string&quot;: &quot;std::asin(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/asin&quot;
},
{
&quot;string&quot;: &quot;std::asinh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/asinh&quot;
},
{
&quot;string&quot;: &quot;std::atan(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/atan&quot;
},
{
&quot;string&quot;: &quot;std::atanh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/atanh&quot;
},
{
&quot;string&quot;: &quot;std::complex::complex&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/complex&quot;
},
{
&quot;string&quot;: &quot;std::conj(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/conj&quot;
},
{
&quot;string&quot;: &quot;std::cos(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/cos&quot;
},
{
&quot;string&quot;: &quot;std::cosh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/cosh&quot;
},
{
&quot;string&quot;: &quot;std::exp(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/exp&quot;
},
{
&quot;string&quot;: &quot;std::complex::imag&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/imag&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;imag&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/imag&quot;
},
{
&quot;string&quot;: &quot;std::imag(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/imag&quot;
},
{
&quot;string&quot;: &quot;std::log(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/log&quot;
},
{
&quot;string&quot;: &quot;std::log10(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/log10&quot;
},
{
&quot;string&quot;: &quot;std::norm(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/norm&quot;
},
{
&quot;string&quot;: &quot;std::complex::operator=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator=&quot;
},
{
&quot;string&quot;: &quot;std::complex::operator+=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;operator+=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::complex::operator-=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;operator-=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::complex::operator*=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;operator*=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::complex::operator/=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;operator/=&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith&quot;
},
{
&quot;string&quot;: &quot;operator+(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;operator-(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith2&quot;
},
{
&quot;string&quot;: &quot;operator+(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;operator-(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;operator*(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;operator/(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_arith3&quot;
},
{
&quot;string&quot;: &quot;operator==(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::polar(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/polar&quot;
},
{
&quot;string&quot;: &quot;std::pow(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/pow&quot;
},
{
&quot;string&quot;: &quot;std::proj(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/proj&quot;
},
{
&quot;string&quot;: &quot;std::complex::real&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/real&quot;
},
{
&quot;on_group&quot;: &quot;std::complex&quot;,
&quot;string&quot;: &quot;real&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/real&quot;
},
{
&quot;string&quot;: &quot;std::real(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/real&quot;
},
{
&quot;string&quot;: &quot;std::sin(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/sin&quot;
},
{
&quot;string&quot;: &quot;std::sinh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/sinh&quot;
},
{
&quot;string&quot;: &quot;std::sqrt(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/sqrt&quot;
},
{
&quot;string&quot;: &quot;std::tan(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/tan&quot;
},
{
&quot;string&quot;: &quot;std::tanh(std::complex)&quot;,
&quot;target&quot;: &quot;cpp/numeric/complex/tanh&quot;
},
{
&quot;string&quot;: &quot;FE_DFL_ENV&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_DFL_ENV&quot;
},
{
&quot;string&quot;: &quot;FE_ALL_EXCEPT&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_DIVBYZERO&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_INEXACT&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_INVALID&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_OVERFLOW&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_UNHERFLOW&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_exceptions&quot;
},
{
&quot;string&quot;: &quot;FE_DOWNWARD&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_round&quot;
},
{
&quot;string&quot;: &quot;FE_TONEAREST&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_round&quot;
},
{
&quot;string&quot;: &quot;FE_TOWARDZERO&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_round&quot;
},
{
&quot;string&quot;: &quot;FE_UPWARD&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/FE_round&quot;
},
{
&quot;string&quot;: &quot;std::feclearexcept&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/fecrearexcept&quot;
},
{
&quot;string&quot;: &quot;std::fegetenv&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feenv&quot;
},
{
&quot;string&quot;: &quot;std::fesetenv&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feenv&quot;
},
{
&quot;string&quot;: &quot;std::fegetexceptflag&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feexceptflag&quot;
},
{
&quot;string&quot;: &quot;std::fesetexceptflag&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feexceptflag&quot;
},
{
&quot;string&quot;: &quot;std::feholdexcept&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feholdexcept&quot;
},
{
&quot;string&quot;: &quot;std::feraiseexcept&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feraiseexcept&quot;
},
{
&quot;string&quot;: &quot;std::fegetround&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feround&quot;
},
{
&quot;string&quot;: &quot;std::fesetround&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feround&quot;
},
{
&quot;string&quot;: &quot;std::fetestexcept&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/fetestexcept&quot;
},
{
&quot;string&quot;: &quot;std::feupdateenv&quot;,
&quot;target&quot;: &quot;cpp/numeric/fenv/feupdateenv&quot;
},
{
&quot;string&quot;: &quot;FP_INFINITE&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/FP_categories&quot;
},
{
&quot;string&quot;: &quot;FP_NAN&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/FP_categories&quot;
},
{
&quot;string&quot;: &quot;FP_NORMAL&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/FP_categories&quot;
},
{
&quot;string&quot;: &quot;FP_SUBNORMAL&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/FP_categories&quot;
},
{
&quot;string&quot;: &quot;FP_ZERO&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/FP_categories&quot;
},
{
&quot;string&quot;: &quot;HUGE_VAL&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/HUGE_VAL&quot;
},
{
&quot;string&quot;: &quot;HUGE_VALF&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/HUGE_VAL&quot;
},
{
&quot;string&quot;: &quot;HUGE_VALL&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/HUGE_VAL&quot;
},
{
&quot;string&quot;: &quot;INFINITY&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/INFINITY&quot;
},
{
&quot;string&quot;: &quot;NAN&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/NAN&quot;
},
{
&quot;string&quot;: &quot;std::abs(int)&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/abs&quot;
},
{
&quot;string&quot;: &quot;std::labs&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/abs&quot;
},
{
&quot;string&quot;: &quot;std::llabs&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/abs&quot;
},
{
&quot;string&quot;: &quot;std::acos&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/acos&quot;
},
{
&quot;string&quot;: &quot;std::acosh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/acosh&quot;
},
{
&quot;string&quot;: &quot;std::asin&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/asin&quot;
},
{
&quot;string&quot;: &quot;std::asinh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/asinh&quot;
},
{
&quot;string&quot;: &quot;std::atan&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/atan&quot;
},
{
&quot;string&quot;: &quot;std::atan2&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/atan2&quot;
},
{
&quot;string&quot;: &quot;std::atanh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/atanh&quot;
},
{
&quot;string&quot;: &quot;std::cbrt&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/cbrt&quot;
},
{
&quot;string&quot;: &quot;std::ceil&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/ceil&quot;
},
{
&quot;string&quot;: &quot;std::copysign&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/copysign&quot;
},
{
&quot;string&quot;: &quot;std::cos&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/cos&quot;
},
{
&quot;string&quot;: &quot;std::cosh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/cosh&quot;
},
{
&quot;string&quot;: &quot;std::div&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/div&quot;
},
{
&quot;string&quot;: &quot;std::ldiv&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/div&quot;
},
{
&quot;string&quot;: &quot;std::erf&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/erf&quot;
},
{
&quot;string&quot;: &quot;std::erfc&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/erfc&quot;
},
{
&quot;string&quot;: &quot;std::exp&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/exp&quot;
},
{
&quot;string&quot;: &quot;std::exp2&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/exp2&quot;
},
{
&quot;string&quot;: &quot;std::expm1&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/expm1&quot;
},
{
&quot;string&quot;: &quot;std::abs(float)&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fabs&quot;
},
{
&quot;string&quot;: &quot;std::fabs&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fabs&quot;
},
{
&quot;string&quot;: &quot;std::fdim&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fdim&quot;
},
{
&quot;string&quot;: &quot;std::floor&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/floor&quot;
},
{
&quot;string&quot;: &quot;std::fma&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fma&quot;
},
{
&quot;string&quot;: &quot;std::fmax&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fmax&quot;
},
{
&quot;string&quot;: &quot;std::fmin&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fmin&quot;
},
{
&quot;string&quot;: &quot;std::fmod&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fmod&quot;
},
{
&quot;string&quot;: &quot;std::fpclassify&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/fpclassify&quot;
},
{
&quot;string&quot;: &quot;std::frexp&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/frexp&quot;
},
{
&quot;string&quot;: &quot;std::hypot&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/hypot&quot;
},
{
&quot;string&quot;: &quot;std::ilogb&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/ilogb&quot;
},
{
&quot;string&quot;: &quot;std::isfinite&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/isfinite&quot;
},
{
&quot;string&quot;: &quot;std::isinf&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/isinf&quot;
},
{
&quot;string&quot;: &quot;std::isnan&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/isnan&quot;
},
{
&quot;string&quot;: &quot;std::isnormal&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/isnormal&quot;
},
{
&quot;string&quot;: &quot;std::ldexp&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/ldexp&quot;
},
{
&quot;string&quot;: &quot;std::lgamma&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/lgamma&quot;
},
{
&quot;string&quot;: &quot;std::log&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/log&quot;
},
{
&quot;string&quot;: &quot;std::log10&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/log10&quot;
},
{
&quot;string&quot;: &quot;std::log1p&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/log1p&quot;
},
{
&quot;string&quot;: &quot;std::logb&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/logb&quot;
},
{
&quot;string&quot;: &quot;math_errhandling&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/math_errhandling&quot;
},
{
&quot;string&quot;: &quot;MATH_ERRNO&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/math_errhandling&quot;
},
{
&quot;string&quot;: &quot;MATH_ERREXCEPT&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/math_errhandling&quot;
},
{
&quot;string&quot;: &quot;std::modf&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/modf&quot;
},
{
&quot;string&quot;: &quot;std::nan&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nan&quot;
},
{
&quot;string&quot;: &quot;std::nanf&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nan&quot;
},
{
&quot;string&quot;: &quot;std::nanl&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nan&quot;
},
{
&quot;string&quot;: &quot;std::nearbyint&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nearbyint&quot;
},
{
&quot;string&quot;: &quot;std::nextafter&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nextafter&quot;
},
{
&quot;string&quot;: &quot;std::nexttoward&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/nextafter&quot;
},
{
&quot;string&quot;: &quot;std::pow&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/pow&quot;
},
{
&quot;string&quot;: &quot;std::remainder&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/remainder&quot;
},
{
&quot;string&quot;: &quot;std::remquo&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/remquo&quot;
},
{
&quot;string&quot;: &quot;std::rint&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/rint&quot;
},
{
&quot;string&quot;: &quot;std::lrint&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/rint&quot;
},
{
&quot;string&quot;: &quot;std::llrint&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/rint&quot;
},
{
&quot;string&quot;: &quot;std::round&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/round&quot;
},
{
&quot;string&quot;: &quot;std::lround&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/round&quot;
},
{
&quot;string&quot;: &quot;std::llround&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/round&quot;
},
{
&quot;string&quot;: &quot;std::scalbn&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/scalbn&quot;
},
{
&quot;string&quot;: &quot;std::scalbln&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/scalbn&quot;
},
{
&quot;string&quot;: &quot;std::signbit&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/signbit&quot;
},
{
&quot;string&quot;: &quot;std::sin&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/sin&quot;
},
{
&quot;string&quot;: &quot;std::sinh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/sinh&quot;
},
{
&quot;string&quot;: &quot;std::sqrt&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/sqrt&quot;
},
{
&quot;string&quot;: &quot;std::tan&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/tan&quot;
},
{
&quot;string&quot;: &quot;std::tanh&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/tanh&quot;
},
{
&quot;string&quot;: &quot;std::tgamma&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/tgamma&quot;
},
{
&quot;string&quot;: &quot;std::trunc&quot;,
&quot;target&quot;: &quot;cpp/numeric/math/trunc&quot;
},
{
&quot;string&quot;: &quot;std::default_random_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random&quot;
},
{
&quot;string&quot;: &quot;RAND_MAX&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/RAND_MAX&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::bernoulli_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/bernoulli_distribution&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/min&quot;
},
{
&quot;string&quot;: &quot;operator()(std::bernoulli_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::bernoulli_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::bernoulli_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::bernoulli_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::bernoulli_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/p&quot;
},
{
&quot;on_group&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;string&quot;: &quot;p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/p&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::bernoulli_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::bernoulli_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/bernoulli_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::binomial_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/binomial_distribution&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/min&quot;
},
{
&quot;string&quot;: &quot;operator()(std::binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::t&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;t&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::binomial_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::binomial_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/binomial_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::cauchy_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/cauchy_distribution&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::cauchy_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::cauchy_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::cauchy_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::cauchy_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::cauchy_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::cauchy_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/cauchy_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::chi_squared_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/chi_squared_distribution&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/n&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/n&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::chi_squared_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::chi_squared_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::chi_squared_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::chi_squared_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::chi_squared_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::chi_squared_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/chi_squared_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/base&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::discard_block_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::ranlux24&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::ranlux48&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/discard_block_engine&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::discard_block_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::discard_block_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::ranlux24)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::ranlux24)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::ranlux48)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::ranlux48)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::discard_block_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::discard_block_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::ranlux24)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::ranlux24)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::ranlux48)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::ranlux48)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::discard_block_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::discard_block_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discard_block_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::discrete_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/discrete_distribution&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::discrete_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::discrete_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::discrete_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::discrete_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::probabilities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/probabilities&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;probabilities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/probabilities&quot;
},
{
&quot;string&quot;: &quot;std::discrete_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::discrete_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/discrete_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::exponential_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/exponential_distribution&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::lambda&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/lambda&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;lambda&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/lambda&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::exponential_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::exponential_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::exponential_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::exponential_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::exponential_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::exponential_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/exponential_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::extreme_value_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/extreme_value_distribution&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::extreme_value_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::extreme_value_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::extreme_value_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::extreme_value_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::extreme_value_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::extreme_value_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/extreme_value_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::fisher_f_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/fisher_f_distribution&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::fisher_f_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::fisher_f_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::fisher_f_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::fisher_f_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::m&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;m&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::fisher_f_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::fisher_f_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/fisher_f_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::gamma_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/gamma_distribution&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::gamma_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::gamma_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::gamma_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::gamma_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::alpha&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;alpha&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::beta&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;beta&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::gamma_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::gamma_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/gamma_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::generate_canonical&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/generate_canonical&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::geometric_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/geometric_distribution&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::geometric_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::geometric_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/min&quot;
},
{
&quot;string&quot;: &quot;operator()(std::geometric_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::geometric_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::geometric_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::geometric_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::geometric_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/p&quot;
},
{
&quot;on_group&quot;: &quot;std::geometric_distribution&quot;,
&quot;string&quot;: &quot;p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/p&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::geometric_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::geometric_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::geometric_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/geometric_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/base&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::independent_bits_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/independent_bits_engine&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::independent_bits_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::independent_bits_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::independent_bits_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::independent_bits_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::independent_bits_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::independent_bits_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/independent_bits_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::linear_congruential_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::minstd_rand0&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::minstd_rand&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/linear_congruential_engine&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::linear_congruential_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::linear_congruential_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::minstd_rand0)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::minstd_rand0)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::minstd_rand)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::minstd_rand)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::linear_congruential_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::linear_congruential_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::minstd_rand0)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::minstd_rand0)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::minstd_rand)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::minstd_rand)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::linear_congruential_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::linear_congruential_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand0::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::minstd_rand::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/linear_congruential_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::lognormal_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/lognormal_distribution&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::lognormal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::lognormal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::lognormal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::lognormal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::m&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;m&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::s&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;s&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::lognormal_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::lognormal_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/lognormal_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mt19937&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::mersenne_twister_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::mt19937&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::mt19937_64&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::mersenne_twister_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::mersenne_twister_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::mt19937)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::mt19937)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::mt19937_64)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::mt19937_64)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::mersenne_twister_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::mersenne_twister_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::mt19937)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::mt19937)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::mt19937_64)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::mt19937_64)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::mersenne_twister_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::mersenne_twister_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::mt19937::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::mt19937_64::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/mersenne_twister_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::negative_binomial_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/negative_binomial_distribution&quot;
},
{
&quot;string&quot;: &quot;operator()(std::negative_binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::negative_binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::negative_binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::negative_binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::negative_binomial_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::k&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;k&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;p&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::negative_binomial_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::negative_binomial_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/negative_binomial_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::normal_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/normal_distribution&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::normal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::normal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::normal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::normal_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::mean&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;mean&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::stddev&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;stddev&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::normal_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::normal_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/normal_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::piecewise_constant_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::piecewise_constant_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::piecewise_constant_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::piecewise_constant_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::intervals&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;intervals&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::densities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;densities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::piecewise_constant_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/piecewise_constant_distribution&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_constant_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_constant_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_constant_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::piecewise_linear_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::piecewise_linear_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::piecewise_linear_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::piecewise_linear_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::intervals&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;intervals&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::densities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;densities&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::piecewise_linear_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/piecewise_linear_distribution&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_linear_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::piecewise_linear_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/piecewise_linear_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::poisson_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::mean&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/mean&quot;
},
{
&quot;on_group&quot;: &quot;std::poisson_distribution&quot;,
&quot;string&quot;: &quot;mean&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/mean&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::poisson_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/min&quot;
},
{
&quot;string&quot;: &quot;operator()(std::poisson_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::poisson_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::poisson_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::poisson_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::poisson_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::poisson_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::poisson_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/poisson_distribution&quot;
},
{
&quot;string&quot;: &quot;std::poisson_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::poisson_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/poisson_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::rand&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/rand&quot;
},
{
&quot;string&quot;: &quot;std::random_device&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device&quot;
},
{
&quot;string&quot;: &quot;std::random_device::entropy&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/entropy&quot;
},
{
&quot;on_group&quot;: &quot;std::random_device&quot;,
&quot;string&quot;: &quot;entropy&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/entropy&quot;
},
{
&quot;string&quot;: &quot;std::random_device::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/max&quot;
},
{
&quot;on_group&quot;: &quot;std::random_device&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/max&quot;
},
{
&quot;string&quot;: &quot;std::random_device::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/min&quot;
},
{
&quot;on_group&quot;: &quot;std::random_device&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/min&quot;
},
{
&quot;string&quot;: &quot;std::random_device::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::random_device&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/operator()&quot;
},
{
&quot;string&quot;: &quot;std::random_device::random_device&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/random_device/random_device&quot;
},
{
&quot;string&quot;: &quot;std::seed_seq&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq&quot;
},
{
&quot;string&quot;: &quot;std::seed_seq::generate&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/generate&quot;
},
{
&quot;on_group&quot;: &quot;std::seed_seq&quot;,
&quot;string&quot;: &quot;generate&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/generate&quot;
},
{
&quot;string&quot;: &quot;std::seed_seq::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/param&quot;
},
{
&quot;on_group&quot;: &quot;std::seed_seq&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/param&quot;
},
{
&quot;string&quot;: &quot;std::seed_seq::seed_seq&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/seed_seq&quot;
},
{
&quot;string&quot;: &quot;std::seed_seq::size&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/size&quot;
},
{
&quot;on_group&quot;: &quot;std::seed_seq&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/seed_seq/size&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/base&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/base&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::shuffle_order_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::shuffle_order_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::knuth_b)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::knuth_b)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::shuffle_order_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::shuffle_order_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::knuth_b)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::knuth_b)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::shuffle_order_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::shuffle_order_engine::shuffle_order_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/shuffle_order_engine&quot;
},
{
&quot;string&quot;: &quot;std::knuth_b::knuth_b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/shuffle_order_engine/shuffle_order_engine&quot;
},
{
&quot;string&quot;: &quot;std::srand&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/srand&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/n&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;n&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/n&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::student_t_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::student_t_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::student_t_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::student_t_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::student_t_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::student_t_distribution::student_t_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/student_t_distribution/student_t_distribution&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/discard&quot;
},
{
&quot;on_group&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;string&quot;: &quot;discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::discard&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/discard&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/max&quot;
},
{
&quot;on_group&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/max&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/min&quot;
},
{
&quot;on_group&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/min&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::subtract_with_carry_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::subtract_with_carry_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::ranlux24_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::ranlux24_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::ranlux48_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::ranlux48_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::subtract_with_carry_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::subtract_with_carry_engine)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::ranlux24_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::ranlux24_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::ranlux48_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::ranlux48_base)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/seed&quot;
},
{
&quot;on_group&quot;: &quot;std::subtract_with_carry_engine&quot;,
&quot;string&quot;: &quot;seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::seed&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/seed&quot;
},
{
&quot;string&quot;: &quot;std::subtract_with_carry_engine::subtract_with_carry_engine&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux24_base::ranlux24_base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::ranlux48_base::ranlux48_base&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::uniform_int_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::uniform_int_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::uniform_int_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::uniform_int_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_int_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::uniform_int_distribution::uniform_int_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_int_distribution/uniform_int_distribution&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/min&quot;
},
{
&quot;string&quot;: &quot;operator()(std::uniform_real_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::uniform_real_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::uniform_real_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::uniform_real_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::uniform_real_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::uniform_real_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::uniform_real_distribution::uniform_real_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/uniform_real_distribution/uniform_real_distribution&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/max&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/max&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/min&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/min&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator()&quot;
},
{
&quot;string&quot;: &quot;operator==(std::weibull_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::weibull_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::weibull_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::weibull_distribution)&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/param&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;param&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/param&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;a&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/params&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;b&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/params&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::weibull_distribution&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/reset&quot;
},
{
&quot;string&quot;: &quot;std::weibull_distribution::weibull_distribution&quot;,
&quot;target&quot;: &quot;cpp/numeric/random/weibull_distribution/weibull_distribution&quot;
},
{
&quot;string&quot;: &quot;std::ratio&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::yocto&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::femto&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::pico&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::nano&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::micro&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::milli&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::centi&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::deci&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::deca&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::hecto&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::kilo&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::mega&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::giga&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::tera&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::peta&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::exa&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::zetta&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::yotta&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio&quot;
},
{
&quot;string&quot;: &quot;std::ratio_add&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_add&quot;
},
{
&quot;string&quot;: &quot;std::ratio_divide&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_divide&quot;
},
{
&quot;string&quot;: &quot;std::ratio_equal&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_equal&quot;
},
{
&quot;string&quot;: &quot;std::ratio_greater&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_greater&quot;
},
{
&quot;string&quot;: &quot;std::ratio_greater_equal&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_greater_equal&quot;
},
{
&quot;string&quot;: &quot;std::ratio_less&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_less&quot;
},
{
&quot;string&quot;: &quot;std::ratio_less_equal&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_less_equal&quot;
},
{
&quot;string&quot;: &quot;std::ratio_multiply&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_multiply&quot;
},
{
&quot;string&quot;: &quot;std::ratio_not_equal&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_not_equal&quot;
},
{
&quot;string&quot;: &quot;std::ratio_subtract&quot;,
&quot;target&quot;: &quot;cpp/numeric/ratio/ratio_subtract&quot;
},
{
&quot;string&quot;: &quot;std::valarray&quot;,
&quot;target&quot;: &quot;cpp/numeric/valarray&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::wregex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::assign&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/assign&quot;
},
{
&quot;string&quot;: &quot;std::regex::assign&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/assign&quot;
},
{
&quot;string&quot;: &quot;std::wregex::assign&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/assign&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::basic_regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::regex::regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::wregex::wregex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::flags&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/flags&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;flags&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/flags&quot;
},
{
&quot;string&quot;: &quot;std::regex::flags&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/flags&quot;
},
{
&quot;string&quot;: &quot;std::wregex::flags&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/flags&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/getloc&quot;
},
{
&quot;string&quot;: &quot;std::regex::getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/getloc&quot;
},
{
&quot;string&quot;: &quot;std::wregex::getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/getloc&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/imbue&quot;
},
{
&quot;string&quot;: &quot;std::regex::imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/imbue&quot;
},
{
&quot;string&quot;: &quot;std::wregex::imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/imbue&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::mark_count&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/mark_count&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;mark_count&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/mark_count&quot;
},
{
&quot;string&quot;: &quot;std::regex::mark_count&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/mark_count&quot;
},
{
&quot;string&quot;: &quot;std::wregex::mark_count&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/mark_count&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/operator=&quot;
},
{
&quot;string&quot;: &quot;std::regex::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wregex::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_regex&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/swap&quot;
},
{
&quot;string&quot;: &quot;std::regex::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/swap&quot;
},
{
&quot;string&quot;: &quot;std::wregex::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/swap&quot;
},
{
&quot;string&quot;: &quot;std::basic_regex::~basic_regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/~basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::regex::~regex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/~basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::wregex::~wregex&quot;,
&quot;target&quot;: &quot;cpp/regex/basic_regex/~basic_regex&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_type&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_collate&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_ctype&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_escape&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_backref&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_brack&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_paren&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_brace&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_badbrace&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_range&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_space&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_badrepeat&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_complexity&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::error_stack&quot;,
&quot;target&quot;: &quot;cpp/regex/error_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_flag_type&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_default&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_not_bol&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_not_eol&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_not_bow&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_not_eow&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_any&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_not_null&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_continuous&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::match_prev_avail&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::format_default&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::format_sed&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::format_no_copy&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::format_first_only&quot;,
&quot;target&quot;: &quot;cpp/regex/match_flag_type&quot;
},
{
&quot;string&quot;: &quot;std::match_results&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results&quot;
},
{
&quot;string&quot;: &quot;std::cmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results&quot;
},
{
&quot;string&quot;: &quot;std::smatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results&quot;
},
{
&quot;string&quot;: &quot;std::match_results::begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::match_results::cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::smatch::begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::smatch::cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::begin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::cbegin&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/begin&quot;
},
{
&quot;string&quot;: &quot;std::match_results::empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;string&quot;: &quot;std::smatch::empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::empty&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/empty&quot;
},
{
&quot;string&quot;: &quot;std::match_results::end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::match_results::cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::smatch::end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::smatch::cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::end&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::cend&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/end&quot;
},
{
&quot;string&quot;: &quot;std::match_results::format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;string&quot;: &quot;std::smatch::format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::format&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/format&quot;
},
{
&quot;string&quot;: &quot;std::match_results::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::smatch::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::match_results::length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;string&quot;: &quot;std::smatch::length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::length&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/length&quot;
},
{
&quot;string&quot;: &quot;std::match_results::match_results&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/match_results&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::cmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/match_results&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::wcmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/match_results&quot;
},
{
&quot;string&quot;: &quot;std::smatch::smatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/match_results&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::wsmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/match_results&quot;
},
{
&quot;string&quot;: &quot;std::match_results::max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;string&quot;: &quot;std::smatch::max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::max_size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/max_size&quot;
},
{
&quot;string&quot;: &quot;std::match_results::operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::smatch::operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::operator[]&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::match_results::position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;string&quot;: &quot;std::smatch::position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::position&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/position&quot;
},
{
&quot;string&quot;: &quot;std::match_results::prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;string&quot;: &quot;std::smatch::prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::prefix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/prefix&quot;
},
{
&quot;string&quot;: &quot;std::match_results::ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;string&quot;: &quot;std::smatch::ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::ready&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/ready&quot;
},
{
&quot;string&quot;: &quot;std::match_results::size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;string&quot;: &quot;std::smatch::size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::size&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/size&quot;
},
{
&quot;string&quot;: &quot;std::match_results::str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;string&quot;: &quot;std::smatch::str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::str&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/str&quot;
},
{
&quot;string&quot;: &quot;std::match_results::suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;string&quot;: &quot;std::smatch::suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::suffix&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/suffix&quot;
},
{
&quot;string&quot;: &quot;std::match_results::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::match_results&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;string&quot;: &quot;std::smatch::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::swap&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/swap&quot;
},
{
&quot;string&quot;: &quot;std::match_results::~match_results&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/~match_results&quot;
},
{
&quot;string&quot;: &quot;std::cmatch::~cmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/~match_results&quot;
},
{
&quot;string&quot;: &quot;std::wcmatch::~wcmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/~match_results&quot;
},
{
&quot;string&quot;: &quot;std::smatch::~smatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/~match_results&quot;
},
{
&quot;string&quot;: &quot;std::wsmatch::~wsmatch&quot;,
&quot;target&quot;: &quot;cpp/regex/match_results/~match_results&quot;
},
{
&quot;string&quot;: &quot;std::regex_error&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_error&quot;
},
{
&quot;string&quot;: &quot;std::regex_error::code&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_error/code&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_error&quot;,
&quot;string&quot;: &quot;code&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_error/code&quot;
},
{
&quot;string&quot;: &quot;std::regex_error::regex_error&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_error/regex_error&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_iterator&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::regex_iterator::regex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::cregex_iterator::cregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_iterator::wcregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::sregex_iterator::sregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_iterator::wsregex_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_iterator/regex_iterator&quot;
},
{
&quot;string&quot;: &quot;std::regex_match&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_match&quot;
},
{
&quot;string&quot;: &quot;std::regex_replace&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_replace&quot;
},
{
&quot;string&quot;: &quot;std::regex_search&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_search&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator*&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator*&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator=&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator++&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator++(int)&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_arith&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_token_iterator&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator==&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::operator!=&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::regex_token_iterator::regex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::cregex_token_iterator::cregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wcregex_token_iterator::wcregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::sregex_token_iterator::sregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::wsregex_token_iterator::wsregex_token_iterator&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_token_iterator/regex_token_iterator&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/getloc&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;getloc&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/getloc&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/imbue&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;imbue&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/imbue&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::isctype&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/isctype&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;isctype&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/isctype&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::length&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/length&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/length&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::lookup_classname&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/lookup_classname&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;lookup_classname&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/lookup_classname&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::lookup_collatename&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/lookup_collatename&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;lookup_collatename&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/lookup_collatename&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::regex_traits&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/regex_traits&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::transform&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/transform&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;transform&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/transform&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::transform_primary&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/transform_primary&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;transform_primary&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/transform_primary&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::translate&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/translate&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;translate&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/translate&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::translate_nocase&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/translate_nocase&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;translate_nocase&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/translate_nocase&quot;
},
{
&quot;string&quot;: &quot;std::regex_traits::value&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/value&quot;
},
{
&quot;on_group&quot;: &quot;std::regex_traits&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/regex/regex_traits/value&quot;
},
{
&quot;string&quot;: &quot;std::sub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::csub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::sub_match::compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::sub_match&quot;,
&quot;string&quot;: &quot;compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;string&quot;: &quot;std::csub_match::compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match::compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match::compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match::compare&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/compare&quot;
},
{
&quot;string&quot;: &quot;std::sub_match::length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;on_group&quot;: &quot;std::sub_match&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;string&quot;: &quot;std::csub_match::length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match::length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match::length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match::length&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/length&quot;
},
{
&quot;string&quot;: &quot;std::sub_match::str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;on_group&quot;: &quot;std::sub_match&quot;,
&quot;string&quot;: &quot;str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::sub_match::operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;on_group&quot;: &quot;std::sub_match&quot;,
&quot;string&quot;: &quot;operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::csub_match::str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::csub_match::operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match::str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match::operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match::str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match::operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match::str&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match::operator string_type&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/str&quot;
},
{
&quot;string&quot;: &quot;std::sub_match::sub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::csub_match::csub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::wcsub_match::wcsub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::ssub_match::ssub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::wssub_match::wssub_match&quot;,
&quot;target&quot;: &quot;cpp/regex/sub_match/sub_match&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::syntax_option_type&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::icase&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::nosubs&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::optimize&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::collate&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::ECMAScript&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::basic&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::extended&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::awk&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::grep&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::regex_constants::egrep&quot;,
&quot;target&quot;: &quot;cpp/regex/syntax_option_type&quot;
},
{
&quot;string&quot;: &quot;std::basic_string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::wstring&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::u16string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::u32string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;string&quot;: &quot;std::string::append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;string&quot;: &quot;std::wstring::append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;string&quot;: &quot;std::u16string::append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;string&quot;: &quot;std::u32string::append&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/append&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;string&quot;: &quot;std::string::assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;string&quot;: &quot;std::wstring::assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;string&quot;: &quot;std::u16string::assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;string&quot;: &quot;std::u32string::assign&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/assign&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;string&quot;: &quot;std::string::at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;string&quot;: &quot;std::wstring::at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;string&quot;: &quot;std::u16string::at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;string&quot;: &quot;std::u32string::at&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/at&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;string&quot;: &quot;std::string::back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;string&quot;: &quot;std::wstring::back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;string&quot;: &quot;std::u16string::back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;string&quot;: &quot;std::u32string::back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/back&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::basic_string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::string::string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::wstring::wstring&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::u16string::u16string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::u32string::u32string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/basic_string&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::string::begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::string::cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::wstring::begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::wstring::cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::u16string::begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::u16string::cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::u32string::begin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::u32string::cbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/begin&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;string&quot;: &quot;std::string::c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;string&quot;: &quot;std::wstring::c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;string&quot;: &quot;std::u16string::c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;string&quot;: &quot;std::u32string::c_str&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/c_str&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;string&quot;: &quot;std::string::capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;string&quot;: &quot;std::wstring::capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;string&quot;: &quot;std::u16string::capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;string&quot;: &quot;std::u32string::capacity&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/capacity&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;string&quot;: &quot;std::string::clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;string&quot;: &quot;std::wstring::clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;string&quot;: &quot;std::u16string::clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;string&quot;: &quot;std::u32string::clear&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/clear&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;string&quot;: &quot;std::string::compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;string&quot;: &quot;std::wstring::compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;string&quot;: &quot;std::u16string::compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;string&quot;: &quot;std::u32string::compare&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/compare&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;string&quot;: &quot;std::string::copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;string&quot;: &quot;std::wstring::copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;string&quot;: &quot;std::u16string::copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;string&quot;: &quot;std::u32string::copy&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/copy&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;string&quot;: &quot;std::string::data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;string&quot;: &quot;std::wstring::data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;string&quot;: &quot;std::u16string::data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;string&quot;: &quot;std::u32string::data&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/data&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;string&quot;: &quot;std::string::empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;string&quot;: &quot;std::wstring::empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;string&quot;: &quot;std::u16string::empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;string&quot;: &quot;std::u32string::empty&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/empty&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::string::end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::string::cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::wstring::end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::wstring::cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::u16string::end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::u16string::cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::u32string::end&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::u32string::cend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/end&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;string&quot;: &quot;std::string::erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;string&quot;: &quot;std::wstring::erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;string&quot;: &quot;std::u16string::erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;string&quot;: &quot;std::u32string::erase&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/erase&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;string&quot;: &quot;std::string::find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;string&quot;: &quot;std::wstring::find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;string&quot;: &quot;std::u16string::find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;string&quot;: &quot;std::u32string::find&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;string&quot;: &quot;std::string::find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;string&quot;: &quot;std::wstring::find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;string&quot;: &quot;std::u16string::find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;string&quot;: &quot;std::u32string::find_first_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_not_of&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::string::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::wstring::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::u16string::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::u32string::find_first_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_first_of&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;string&quot;: &quot;std::string::find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;string&quot;: &quot;std::wstring::find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;string&quot;: &quot;std::u16string::find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;string&quot;: &quot;std::u32string::find_last_not_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_not_of&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;string&quot;: &quot;std::string::find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;string&quot;: &quot;std::wstring::find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;string&quot;: &quot;std::u16string::find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;string&quot;: &quot;std::u32string::find_last_of&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/find_last_of&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;string&quot;: &quot;std::string::front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;string&quot;: &quot;std::wstring::front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;string&quot;: &quot;std::u16string::front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;string&quot;: &quot;std::u32string::front&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/front&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::string::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::wstring::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::u16string::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::u32string::get_allocator&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/get_allocator&quot;
},
{
&quot;string&quot;: &quot;std::getline&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/getline&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::basic_string&gt;&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::string&gt;&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::wstring&gt;&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::u16string&gt;&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::u32string&gt;&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/hash&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;string&quot;: &quot;std::string::insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;string&quot;: &quot;std::wstring::insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;string&quot;: &quot;std::u16string::insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;string&quot;: &quot;std::u32string::insert&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/insert&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;string&quot;: &quot;std::string::max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;string&quot;: &quot;std::wstring::max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;string&quot;: &quot;std::u16string::max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;string&quot;: &quot;std::u32string::max_size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/max_size&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;string&quot;: &quot;std::string::npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;string&quot;: &quot;std::wstring::npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;string&quot;: &quot;std::u16string::npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;string&quot;: &quot;std::u32string::npos&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/npos&quot;
},
{
&quot;string&quot;: &quot;operator+(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator+&quot;
},
{
&quot;string&quot;: &quot;operator+(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator+&quot;
},
{
&quot;string&quot;: &quot;operator+(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator+&quot;
},
{
&quot;string&quot;: &quot;operator+(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator+&quot;
},
{
&quot;string&quot;: &quot;operator+(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator+&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;string&quot;: &quot;std::string::operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;string&quot;: &quot;std::wstring::operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;string&quot;: &quot;std::u16string::operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;string&quot;: &quot;std::u32string::operator=&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator=&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::string::operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::wstring::operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::u16string::operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::u32string::operator[]&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_at&quot;
},
{
&quot;string&quot;: &quot;operator==(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator==(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::string::pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::wstring::pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::u16string::pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::u32string::pop_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/pop_back&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;string&quot;: &quot;std::string::push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;string&quot;: &quot;std::wstring::push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;string&quot;: &quot;std::u16string::push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;string&quot;: &quot;std::u32string::push_back&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/push_back&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::string::rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::string::crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::wstring::rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::wstring::crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::u16string::rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::u16string::crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::u32string::rbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::u32string::crbegin&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rbegin&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::string::rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::string::crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::wstring::rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::wstring::crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::u16string::rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::u16string::crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::u32string::rend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::u32string::crend&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rend&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;string&quot;: &quot;std::string::replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;string&quot;: &quot;std::wstring::replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;string&quot;: &quot;std::u16string::replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;string&quot;: &quot;std::u32string::replace&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/replace&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;string&quot;: &quot;std::string::reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;string&quot;: &quot;std::wstring::reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;string&quot;: &quot;std::u16string::reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;string&quot;: &quot;std::u32string::reserve&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/reserve&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;string&quot;: &quot;std::string::resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;string&quot;: &quot;std::wstring::resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;string&quot;: &quot;std::u16string::resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;string&quot;: &quot;std::u32string::resize&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/resize&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;string&quot;: &quot;std::string::rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;string&quot;: &quot;std::wstring::rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;string&quot;: &quot;std::u16string::rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;string&quot;: &quot;std::u32string::rfind&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/rfind&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::string::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::wstring::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::u16string::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::u32string::shrink_to_fit&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/shrink_to_fit&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::string::size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::string::length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::wstring::size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::wstring::length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::u16string::size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::u16string::length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::u32string::size&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::u32string::length&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/size&quot;
},
{
&quot;string&quot;: &quot;std::stof&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stof&quot;
},
{
&quot;string&quot;: &quot;std::stod&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stof&quot;
},
{
&quot;string&quot;: &quot;std::stold&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stof&quot;
},
{
&quot;string&quot;: &quot;std::stoi&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stol&quot;
},
{
&quot;string&quot;: &quot;std::stol&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stol&quot;
},
{
&quot;string&quot;: &quot;std::stoll&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stol&quot;
},
{
&quot;string&quot;: &quot;std::stoul&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stoul&quot;
},
{
&quot;string&quot;: &quot;std::stoull&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/stoul&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;string&quot;: &quot;std::string::substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;string&quot;: &quot;std::wstring::substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;string&quot;: &quot;std::u16string::substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;string&quot;: &quot;std::u32string::substr&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/substr&quot;
},
{
&quot;string&quot;: &quot;std::basic_string::swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::basic_string&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;string&quot;: &quot;std::string::swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;string&quot;: &quot;std::wstring::swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;string&quot;: &quot;std::u16string::swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;string&quot;: &quot;std::u32string::swap&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::basic_string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::wstring)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::u16string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap2&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::u32string)&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/swap2&quot;
},
{
&quot;string&quot;: &quot;std::to_string&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/to_string&quot;
},
{
&quot;string&quot;: &quot;std::to_wstring&quot;,
&quot;target&quot;: &quot;cpp/string/basic_string/to_wstring&quot;
},
{
&quot;string&quot;: &quot;std::atof&quot;,
&quot;target&quot;: &quot;cpp/string/byte/atof&quot;
},
{
&quot;string&quot;: &quot;std::atoi&quot;,
&quot;target&quot;: &quot;cpp/string/byte/atoi&quot;
},
{
&quot;string&quot;: &quot;std::atol&quot;,
&quot;target&quot;: &quot;cpp/string/byte/atoi&quot;
},
{
&quot;string&quot;: &quot;std::atoll&quot;,
&quot;target&quot;: &quot;cpp/string/byte/atoi&quot;
},
{
&quot;string&quot;: &quot;std::isalnum&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isalnum&quot;
},
{
&quot;string&quot;: &quot;std::isalpha&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isalpha&quot;
},
{
&quot;string&quot;: &quot;std::isblank&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isblank&quot;
},
{
&quot;string&quot;: &quot;std::iscntrl&quot;,
&quot;target&quot;: &quot;cpp/string/byte/iscntrl&quot;
},
{
&quot;string&quot;: &quot;std::isdigit&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isdigit&quot;
},
{
&quot;string&quot;: &quot;std::isgraph&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isgraph&quot;
},
{
&quot;string&quot;: &quot;std::islower&quot;,
&quot;target&quot;: &quot;cpp/string/byte/islower&quot;
},
{
&quot;string&quot;: &quot;std::isprint&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isprint&quot;
},
{
&quot;string&quot;: &quot;std::ispunct&quot;,
&quot;target&quot;: &quot;cpp/string/byte/ispunct&quot;
},
{
&quot;string&quot;: &quot;std::isspace&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isspace&quot;
},
{
&quot;string&quot;: &quot;std::isupper&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isupper&quot;
},
{
&quot;string&quot;: &quot;std::isxdigit&quot;,
&quot;target&quot;: &quot;cpp/string/byte/isxdigit&quot;
},
{
&quot;string&quot;: &quot;std::memchr&quot;,
&quot;target&quot;: &quot;cpp/string/byte/memchr&quot;
},
{
&quot;string&quot;: &quot;std::memcmp&quot;,
&quot;target&quot;: &quot;cpp/string/byte/memcmp&quot;
},
{
&quot;string&quot;: &quot;std::memcpy&quot;,
&quot;target&quot;: &quot;cpp/string/byte/memcpy&quot;
},
{
&quot;string&quot;: &quot;std::memmove&quot;,
&quot;target&quot;: &quot;cpp/string/byte/memmove&quot;
},
{
&quot;string&quot;: &quot;std::memset&quot;,
&quot;target&quot;: &quot;cpp/string/byte/memset&quot;
},
{
&quot;string&quot;: &quot;std::strcat&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strcat&quot;
},
{
&quot;string&quot;: &quot;std::strchr&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strchr&quot;
},
{
&quot;string&quot;: &quot;std::strcmp&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strcmp&quot;
},
{
&quot;string&quot;: &quot;std::strcoll&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strcoll&quot;
},
{
&quot;string&quot;: &quot;std::strcpy&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strcpy&quot;
},
{
&quot;string&quot;: &quot;std::strcspn&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strcspn&quot;
},
{
&quot;string&quot;: &quot;std::strerror&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strerror&quot;
},
{
&quot;string&quot;: &quot;std::strlen&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strlen&quot;
},
{
&quot;string&quot;: &quot;std::strncat&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strncat&quot;
},
{
&quot;string&quot;: &quot;std::strncmp&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strncmp&quot;
},
{
&quot;string&quot;: &quot;std::strncpy&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strncpy&quot;
},
{
&quot;string&quot;: &quot;std::strpbrk&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strpbrk&quot;
},
{
&quot;string&quot;: &quot;std::strrchr&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strrchr&quot;
},
{
&quot;string&quot;: &quot;std::strspn&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strspn&quot;
},
{
&quot;string&quot;: &quot;std::strstr&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strstr&quot;
},
{
&quot;string&quot;: &quot;std::strtof&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtof&quot;
},
{
&quot;string&quot;: &quot;std::strtod&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtof&quot;
},
{
&quot;string&quot;: &quot;std::strtold&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtof&quot;
},
{
&quot;string&quot;: &quot;std::strtoimax&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtoimax&quot;
},
{
&quot;string&quot;: &quot;std::strtoumax&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtoimax&quot;
},
{
&quot;string&quot;: &quot;std::strtok&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtok&quot;
},
{
&quot;string&quot;: &quot;std::strtol&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtol&quot;
},
{
&quot;string&quot;: &quot;std::strtoll&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtol&quot;
},
{
&quot;string&quot;: &quot;std::strtoul&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtoul&quot;
},
{
&quot;string&quot;: &quot;std::strtoull&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strtoul&quot;
},
{
&quot;string&quot;: &quot;std::strxfrm&quot;,
&quot;target&quot;: &quot;cpp/string/byte/strxfrm&quot;
},
{
&quot;string&quot;: &quot;std::tolower&quot;,
&quot;target&quot;: &quot;cpp/string/byte/tolower&quot;
},
{
&quot;string&quot;: &quot;std::toupper&quot;,
&quot;target&quot;: &quot;cpp/string/byte/toupper&quot;
},
{
&quot;string&quot;: &quot;std::wcstoimax&quot;,
&quot;target&quot;: &quot;cpp/string/byte/wcstoimax&quot;
},
{
&quot;string&quot;: &quot;std::wcstoumax&quot;,
&quot;target&quot;: &quot;cpp/string/byte/wcstoimax&quot;
},
{
&quot;string&quot;: &quot;std::char_traits&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::assign&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::eq&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;eq&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::lt&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;lt&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::move&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;move&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::copy&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;copy&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::compare&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;compare&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::length&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;length&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::find&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;find&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::to_char_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;to_char_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::to_int_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;to_int_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::eq_int_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;eq_int_type&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::eof&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;eof&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::char_traits::not_eof&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;on_group&quot;: &quot;std::char_traits&quot;,
&quot;string&quot;: &quot;not_eof&quot;,
&quot;target&quot;: &quot;cpp/string/char_traits&quot;
},
{
&quot;string&quot;: &quot;std::btowc&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/btowc&quot;
},
{
&quot;string&quot;: &quot;std::c16rtomb&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/c16rtomb&quot;
},
{
&quot;string&quot;: &quot;std::c32rtomb&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/c32rtomb&quot;
},
{
&quot;string&quot;: &quot;std::mblen&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mblen&quot;
},
{
&quot;string&quot;: &quot;std::mbrlen&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbrlen&quot;
},
{
&quot;string&quot;: &quot;std::mbrtoc16&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbrtoc16&quot;
},
{
&quot;string&quot;: &quot;std::mbrtoc32&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbrtoc32&quot;
},
{
&quot;string&quot;: &quot;std::mbrtowc&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbrtowc&quot;
},
{
&quot;string&quot;: &quot;std::mbsinit&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbsinit&quot;
},
{
&quot;string&quot;: &quot;std::mbsrtowcs&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbsrtowcs&quot;
},
{
&quot;string&quot;: &quot;std::mbstate_t&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbstate_t&quot;
},
{
&quot;string&quot;: &quot;std::mbstowcs&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbstowcs&quot;
},
{
&quot;string&quot;: &quot;std::mbtowc&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/mbtowc&quot;
},
{
&quot;string&quot;: &quot;std::wcrtomb&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/wcrtomb&quot;
},
{
&quot;string&quot;: &quot;std::wcstombs&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/wcstombs&quot;
},
{
&quot;string&quot;: &quot;std::wcstombs&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/wcstombs&quot;
},
{
&quot;string&quot;: &quot;std::wctob&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/wctob&quot;
},
{
&quot;string&quot;: &quot;std::wctomb&quot;,
&quot;target&quot;: &quot;cpp/string/multibyte/wctomb&quot;
},
{
&quot;string&quot;: &quot;std::iswalnum&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswalnum&quot;
},
{
&quot;string&quot;: &quot;std::iswalpha&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswalpha&quot;
},
{
&quot;string&quot;: &quot;std::iswblank&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswblank&quot;
},
{
&quot;string&quot;: &quot;std::iswcntrl&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswcntrl&quot;
},
{
&quot;string&quot;: &quot;std::iswctype&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswctype&quot;
},
{
&quot;string&quot;: &quot;std::iswdigit&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswdigit&quot;
},
{
&quot;string&quot;: &quot;std::iswgraph&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswgraph&quot;
},
{
&quot;string&quot;: &quot;std::iswlower&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswlower&quot;
},
{
&quot;string&quot;: &quot;std::iswprint&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswprint&quot;
},
{
&quot;string&quot;: &quot;std::iswpunct&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswpunct&quot;
},
{
&quot;string&quot;: &quot;std::iswspace&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswspace&quot;
},
{
&quot;string&quot;: &quot;std::iswupper&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswupper&quot;
},
{
&quot;string&quot;: &quot;std::iswxdigit&quot;,
&quot;target&quot;: &quot;cpp/string/wide/iswxdigit&quot;
},
{
&quot;string&quot;: &quot;std::towctrans&quot;,
&quot;target&quot;: &quot;cpp/string/wide/towctrans&quot;
},
{
&quot;string&quot;: &quot;std::towlower&quot;,
&quot;target&quot;: &quot;cpp/string/wide/towlower&quot;
},
{
&quot;string&quot;: &quot;std::towupper&quot;,
&quot;target&quot;: &quot;cpp/string/wide/towupper&quot;
},
{
&quot;string&quot;: &quot;std::wcscat&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcscat&quot;
},
{
&quot;string&quot;: &quot;std::wcschr&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcschr&quot;
},
{
&quot;string&quot;: &quot;std::wcscmp&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcscmp&quot;
},
{
&quot;string&quot;: &quot;std::wcscoll&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcscoll&quot;
},
{
&quot;string&quot;: &quot;std::wcscpy&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcscpy&quot;
},
{
&quot;string&quot;: &quot;std::wcscspn&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcscspn&quot;
},
{
&quot;string&quot;: &quot;std::wcslen&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcslen&quot;
},
{
&quot;string&quot;: &quot;std::wcsncat&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsncat&quot;
},
{
&quot;string&quot;: &quot;std::wcsncmp&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsncmp&quot;
},
{
&quot;string&quot;: &quot;std::wcsncpy&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsncpy&quot;
},
{
&quot;string&quot;: &quot;std::wcspbrk&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcspbrk&quot;
},
{
&quot;string&quot;: &quot;std::wcsrchr&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsrchr&quot;
},
{
&quot;string&quot;: &quot;std::wcsspn&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsspn&quot;
},
{
&quot;string&quot;: &quot;std::wcsstr&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsstr&quot;
},
{
&quot;string&quot;: &quot;std::wcstof&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstof&quot;
},
{
&quot;string&quot;: &quot;std::wcstod&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstof&quot;
},
{
&quot;string&quot;: &quot;std::wcstold&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstof&quot;
},
{
&quot;string&quot;: &quot;std::wcstok&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstok&quot;
},
{
&quot;string&quot;: &quot;std::wcstol&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstol&quot;
},
{
&quot;string&quot;: &quot;std::wcstoll&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstol&quot;
},
{
&quot;string&quot;: &quot;std::wcstoul&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstoul&quot;
},
{
&quot;string&quot;: &quot;std::wcstoull&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcstoul&quot;
},
{
&quot;string&quot;: &quot;std::wcsxfrm&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wcsxfrm&quot;
},
{
&quot;string&quot;: &quot;std::wctrans&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wctrans&quot;
},
{
&quot;string&quot;: &quot;std::wctype&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wctype&quot;
},
{
&quot;string&quot;: &quot;std::wmemchr&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wmemchr&quot;
},
{
&quot;string&quot;: &quot;std::wmemcmp&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wmemcmp&quot;
},
{
&quot;string&quot;: &quot;std::wmemcpy&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wmemcpy&quot;
},
{
&quot;string&quot;: &quot;std::wmemmove&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wmemmove&quot;
},
{
&quot;string&quot;: &quot;std::wmemset&quot;,
&quot;target&quot;: &quot;cpp/string/wide/wmemset&quot;
},
{
&quot;string&quot;: &quot;std::async&quot;,
&quot;target&quot;: &quot;cpp/thread/async&quot;
},
{
&quot;string&quot;: &quot;std::call_once&quot;,
&quot;target&quot;: &quot;cpp/thread/call_once&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::condition_variable&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/condition_variable&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::notify_all&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/notify_all&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;notify_all&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/notify_all&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::notify_one&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/notify_one&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;notify_one&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/notify_one&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::wait&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;wait&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait_for&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait_for&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait_until&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable&quot;,
&quot;string&quot;: &quot;wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/wait_until&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable::~condition_variable&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable/~condition_variable&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::condition_variable_any&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/condition_variable_any&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::notify_all&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/notify_all&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;notify_all&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/notify_all&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::notify_one&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/notify_one&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;notify_one&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/notify_one&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::wait&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;wait&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait_for&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait_for&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait_until&quot;
},
{
&quot;on_group&quot;: &quot;std::condition_variable_any&quot;,
&quot;string&quot;: &quot;wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/wait_until&quot;
},
{
&quot;string&quot;: &quot;std::condition_variable_any::~condition_variable_any&quot;,
&quot;target&quot;: &quot;cpp/thread/condition_variable_any/~condition_variable_any&quot;
},
{
&quot;string&quot;: &quot;std::cv_status&quot;,
&quot;target&quot;: &quot;cpp/thread/cv_status&quot;
},
{
&quot;string&quot;: &quot;std::cv_status::no_timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/cv_status/no_timeout&quot;
},
{
&quot;on_group&quot;: &quot;std::cv_status&quot;,
&quot;string&quot;: &quot;no_timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/cv_status/no_timeout&quot;
},
{
&quot;string&quot;: &quot;std::cv_status::timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/cv_status/timeout&quot;
},
{
&quot;on_group&quot;: &quot;std::cv_status&quot;,
&quot;string&quot;: &quot;timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/cv_status/timeout&quot;
},
{
&quot;string&quot;: &quot;std::future&quot;,
&quot;target&quot;: &quot;cpp/thread/future&quot;
},
{
&quot;string&quot;: &quot;std::future::future&quot;,
&quot;target&quot;: &quot;cpp/thread/future/future&quot;
},
{
&quot;string&quot;: &quot;std::future_category&quot;,
&quot;target&quot;: &quot;cpp/thread/future/future_category&quot;
},
{
&quot;string&quot;: &quot;std::future::get&quot;,
&quot;target&quot;: &quot;cpp/thread/future/get&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/thread/future/get&quot;
},
{
&quot;string&quot;: &quot;std::future::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/future/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/future/operator=&quot;
},
{
&quot;string&quot;: &quot;std::future::share&quot;,
&quot;target&quot;: &quot;cpp/thread/future/share&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;share&quot;,
&quot;target&quot;: &quot;cpp/thread/future/share&quot;
},
{
&quot;string&quot;: &quot;std::future::valid&quot;,
&quot;target&quot;: &quot;cpp/thread/future/valid&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;valid&quot;,
&quot;target&quot;: &quot;cpp/thread/future/valid&quot;
},
{
&quot;string&quot;: &quot;std::future::wait&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;wait&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait&quot;
},
{
&quot;string&quot;: &quot;std::future::wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait_for&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait_for&quot;
},
{
&quot;string&quot;: &quot;std::future::wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait_until&quot;
},
{
&quot;on_group&quot;: &quot;std::future&quot;,
&quot;string&quot;: &quot;wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/future/wait_until&quot;
},
{
&quot;string&quot;: &quot;std::future::~future&quot;,
&quot;target&quot;: &quot;cpp/thread/future/~future&quot;
},
{
&quot;string&quot;: &quot;std::future_category&quot;,
&quot;target&quot;: &quot;cpp/thread/future_category&quot;
},
{
&quot;string&quot;: &quot;std::future_errc&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;string&quot;: &quot;std::future_errc::broken_promise&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;on_group&quot;: &quot;std::future_errc&quot;,
&quot;string&quot;: &quot;broken_promise&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;string&quot;: &quot;std::future_errc::future_already_retrieved&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;on_group&quot;: &quot;std::future_errc&quot;,
&quot;string&quot;: &quot;future_already_retrieved&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;string&quot;: &quot;std::future_errc::promise_already_satisfied&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;on_group&quot;: &quot;std::future_errc&quot;,
&quot;string&quot;: &quot;promise_already_satisfied&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;string&quot;: &quot;std::future_errc::no_state&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;on_group&quot;: &quot;std::future_errc&quot;,
&quot;string&quot;: &quot;no_state&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc&quot;
},
{
&quot;string&quot;: &quot;std::is_error_code_enum&lt;std::future_errc&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc/is_error_code_enum&quot;
},
{
&quot;string&quot;: &quot;std::make_error_code(std::future_errc)&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc/make_error_code&quot;
},
{
&quot;string&quot;: &quot;std::make_error_condition(std::future_errc)&quot;,
&quot;target&quot;: &quot;cpp/thread/future_errc/make_error_condition&quot;
},
{
&quot;string&quot;: &quot;std::future_error&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error&quot;
},
{
&quot;string&quot;: &quot;std::future_error::code&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error/code&quot;
},
{
&quot;on_group&quot;: &quot;std::future_error&quot;,
&quot;string&quot;: &quot;code&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error/code&quot;
},
{
&quot;string&quot;: &quot;std::future_error::future_error&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error/future_error&quot;
},
{
&quot;string&quot;: &quot;std::future_error::what&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error/what&quot;
},
{
&quot;on_group&quot;: &quot;std::future_error&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/thread/future_error/what&quot;
},
{
&quot;string&quot;: &quot;std::future_status&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;string&quot;: &quot;std::future_status::ready&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;on_group&quot;: &quot;std::future_status&quot;,
&quot;string&quot;: &quot;ready&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;string&quot;: &quot;std::future_status::timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;on_group&quot;: &quot;std::future_status&quot;,
&quot;string&quot;: &quot;timeout&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;string&quot;: &quot;std::future_status::deferred&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;on_group&quot;: &quot;std::future_status&quot;,
&quot;string&quot;: &quot;deferred&quot;,
&quot;target&quot;: &quot;cpp/thread/future_status&quot;
},
{
&quot;string&quot;: &quot;std::this_thread::get_id&quot;,
&quot;target&quot;: &quot;cpp/thread/get_id&quot;
},
{
&quot;string&quot;: &quot;std::launch&quot;,
&quot;target&quot;: &quot;cpp/thread/launch&quot;
},
{
&quot;string&quot;: &quot;std::launch::async&quot;,
&quot;target&quot;: &quot;cpp/thread/launch&quot;
},
{
&quot;on_group&quot;: &quot;std::launch&quot;,
&quot;string&quot;: &quot;async&quot;,
&quot;target&quot;: &quot;cpp/thread/launch&quot;
},
{
&quot;string&quot;: &quot;std::launch::deferred&quot;,
&quot;target&quot;: &quot;cpp/thread/launch&quot;
},
{
&quot;on_group&quot;: &quot;std::launch&quot;,
&quot;string&quot;: &quot;deferred&quot;,
&quot;target&quot;: &quot;cpp/thread/launch&quot;
},
{
&quot;string&quot;: &quot;std::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/lock&quot;
},
{
&quot;string&quot;: &quot;std::lock_guard&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_guard&quot;
},
{
&quot;string&quot;: &quot;std::lock_guard::lock_guard&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_guard/lock_guard&quot;
},
{
&quot;string&quot;: &quot;std::lock_guard::~lock_guard&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_guard/~lock_guard&quot;
},
{
&quot;string&quot;: &quot;std::defer_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag&quot;
},
{
&quot;string&quot;: &quot;std::try_to_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag&quot;
},
{
&quot;string&quot;: &quot;std::adopt_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag&quot;
},
{
&quot;string&quot;: &quot;std::defer_lock_t&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag_t&quot;
},
{
&quot;string&quot;: &quot;std::try_to_lock_t&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag_t&quot;
},
{
&quot;string&quot;: &quot;std::adopt_lock_t&quot;,
&quot;target&quot;: &quot;cpp/thread/lock_tag_t&quot;
},
{
&quot;string&quot;: &quot;std::mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex&quot;
},
{
&quot;string&quot;: &quot;std::mutex::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::mutex&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/lock&quot;
},
{
&quot;string&quot;: &quot;std::mutex::mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/mutex&quot;
},
{
&quot;string&quot;: &quot;std::mutex::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::mutex&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::mutex::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::mutex&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::mutex::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::mutex&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/mutex/unlock&quot;
},
{
&quot;string&quot;: &quot;std::notify_all_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/notify_all_at_thread_exit&quot;
},
{
&quot;string&quot;: &quot;std::once_flag&quot;,
&quot;target&quot;: &quot;cpp/thread/once_flag&quot;
},
{
&quot;string&quot;: &quot;std::once_flag::once_flag&quot;,
&quot;target&quot;: &quot;cpp/thread/once_flag&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::get_future&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/get_future&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;get_future&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/get_future&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::make_ready_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/make_ready_at_thread_exit&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;make_ready_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/make_ready_at_thread_exit&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::operator()&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/operator()&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/operator=&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::packaged_task&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/packaged_task&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::reset&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/reset&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::swap&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/swap&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::packaged_task&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::valid&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/valid&quot;
},
{
&quot;on_group&quot;: &quot;std::packaged_task&quot;,
&quot;string&quot;: &quot;valid&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/valid&quot;
},
{
&quot;string&quot;: &quot;std::packaged_task::~packaged_task&quot;,
&quot;target&quot;: &quot;cpp/thread/packaged_task/~packaged_task&quot;
},
{
&quot;string&quot;: &quot;std::promise&quot;,
&quot;target&quot;: &quot;cpp/thread/promise&quot;
},
{
&quot;string&quot;: &quot;std::promise::get_future&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/get_future&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;get_future&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/get_future&quot;
},
{
&quot;string&quot;: &quot;std::promise::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/operator=&quot;
},
{
&quot;string&quot;: &quot;std::promise::promise&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/promise&quot;
},
{
&quot;string&quot;: &quot;std::promise::set_exception&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_exception&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;set_exception&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_exception&quot;
},
{
&quot;string&quot;: &quot;std::promise::set_exception_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_exception_at_thread_exit&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;set_exception_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_exception_at_thread_exit&quot;
},
{
&quot;string&quot;: &quot;std::promise::set_value&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_value&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;set_value&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_value&quot;
},
{
&quot;string&quot;: &quot;std::promise::set_value_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_value_at_thread_exit&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;set_value_at_thread_exit&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/set_value_at_thread_exit&quot;
},
{
&quot;string&quot;: &quot;std::promise::swap&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::promise&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/swap&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::promise&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::promise::~promise&quot;,
&quot;target&quot;: &quot;cpp/thread/promise/~promise&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_mutex&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/lock&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_mutex&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex::recursive_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/recursive_mutex&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_mutex&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::recursive_mutex::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_mutex&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_mutex/unlock&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/lock&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::recursive_timed_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/recursive_timed_mutex&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock_for&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock_for&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock_until&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/try_lock_until&quot;
},
{
&quot;string&quot;: &quot;std::recursive_timed_mutex::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::recursive_timed_mutex&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/recursive_timed_mutex/unlock&quot;
},
{
&quot;string&quot;: &quot;std::shared_future&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::get&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/get&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/get&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/operator=&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::shared_future&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/shared_future&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::valid&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/valid&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;valid&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/valid&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::wait&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;wait&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait_for&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;wait_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait_for&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait_until&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_future&quot;,
&quot;string&quot;: &quot;wait_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/wait_until&quot;
},
{
&quot;string&quot;: &quot;std::shared_future::~shared_future&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_future/~shared_future&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/mutex&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/mutex&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::operator bool&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/operator bool&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/operator bool&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/operator=&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::owns_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/owns_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;owns_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/owns_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::release&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/release&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;release&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/release&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::shared_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/shared_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::swap&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::shared_lock)&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/swap2&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock_for&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock_for&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock_until&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/try_lock_until&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_lock&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/unlock&quot;
},
{
&quot;string&quot;: &quot;std::shared_lock::~shared_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_lock/~shared_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::lock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/lock_shared&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;lock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/lock_shared&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::shared_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/shared_mutex&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_for&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_for&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock_shared_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared_for&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock_shared_for&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared_for&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock_shared_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared_until&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock_shared_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_shared_until&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_until&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/try_lock_until&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/unlock&quot;
},
{
&quot;string&quot;: &quot;std::shared_mutex::unlock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/unlock_shared&quot;
},
{
&quot;on_group&quot;: &quot;std::shared_mutex&quot;,
&quot;string&quot;: &quot;unlock_shared&quot;,
&quot;target&quot;: &quot;cpp/thread/shared_mutex/unlock_shared&quot;
},
{
&quot;string&quot;: &quot;std::this_thread::sleep_for&quot;,
&quot;target&quot;: &quot;cpp/thread/sleep_for&quot;
},
{
&quot;string&quot;: &quot;std::this_thread::sleep_until&quot;,
&quot;target&quot;: &quot;cpp/thread/sleep_until&quot;
},
{
&quot;string&quot;: &quot;std::thread&quot;,
&quot;target&quot;: &quot;cpp/thread/thread&quot;
},
{
&quot;string&quot;: &quot;std::thread::detach&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/detach&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;detach&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/detach&quot;
},
{
&quot;string&quot;: &quot;std::thread::get_id&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/get_id&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;get_id&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/get_id&quot;
},
{
&quot;string&quot;: &quot;std::thread::hardware_concurrency&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/hardware_concurrency&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;hardware_concurrency&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/hardware_concurrency&quot;
},
{
&quot;string&quot;: &quot;std::thread::id&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::thread::id&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/hash&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::id&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/id&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator==&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator!=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator&lt;=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator&lt;=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator&gt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator&gt;=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator&gt;=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::thread::id::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_ltlt&quot;
},
{
&quot;on_group&quot;: &quot;std::thread::id&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/id/operator_ltlt&quot;
},
{
&quot;string&quot;: &quot;std::thread::join&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/join&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;join&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/join&quot;
},
{
&quot;string&quot;: &quot;std::thread::joinable&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/joinable&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;joinable&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/joinable&quot;
},
{
&quot;string&quot;: &quot;std::thread::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::thread::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/operator=&quot;
},
{
&quot;string&quot;: &quot;std::thread::swap&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::thread&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::thread)&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/swap2&quot;
},
{
&quot;string&quot;: &quot;std::thread::thread&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/thread&quot;
},
{
&quot;string&quot;: &quot;std::thread::~thread&quot;,
&quot;target&quot;: &quot;cpp/thread/thread/~thread&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/lock&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/native_handle&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;native_handle&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/native_handle&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::timed_mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/timed_mutex&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock_for&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock_for&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock_until&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/try_lock_until&quot;
},
{
&quot;string&quot;: &quot;std::timed_mutex::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::timed_mutex&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/timed_mutex/unlock&quot;
},
{
&quot;string&quot;: &quot;std::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/lock&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/mutex&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;mutex&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/mutex&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::operator bool&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/operator bool&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/operator bool&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/operator=&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::owns_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/owns_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;owns_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/owns_lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::release&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/release&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;release&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/release&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::swap&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::unique_lock)&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/swap2&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;try_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock_for&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;try_lock_for&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock_for&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock_until&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;try_lock_until&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/try_lock_until&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::unique_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/unique_lock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/unlock&quot;
},
{
&quot;on_group&quot;: &quot;std::unique_lock&quot;,
&quot;string&quot;: &quot;unlock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/unlock&quot;
},
{
&quot;string&quot;: &quot;std::unique_lock::~unique_lock&quot;,
&quot;target&quot;: &quot;cpp/thread/unique_lock/~unique_lock&quot;
},
{
&quot;string&quot;: &quot;std::this_thread::yield&quot;,
&quot;target&quot;: &quot;cpp/thread/yield&quot;
},
{
&quot;string&quot;: &quot;NULL&quot;,
&quot;target&quot;: &quot;cpp/types/NULL&quot;
},
{
&quot;string&quot;: &quot;std::add_cv&quot;,
&quot;target&quot;: &quot;cpp/types/add_cv&quot;
},
{
&quot;string&quot;: &quot;std::add_const&quot;,
&quot;target&quot;: &quot;cpp/types/add_cv&quot;
},
{
&quot;string&quot;: &quot;std::add_volatile&quot;,
&quot;target&quot;: &quot;cpp/types/add_cv&quot;
},
{
&quot;string&quot;: &quot;std::add_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/add_pointer&quot;
},
{
&quot;string&quot;: &quot;std::add_lvalue_reference&quot;,
&quot;target&quot;: &quot;cpp/types/add_reference&quot;
},
{
&quot;string&quot;: &quot;std::add_rvalue_reference&quot;,
&quot;target&quot;: &quot;cpp/types/add_reference&quot;
},
{
&quot;string&quot;: &quot;std::aligned_storage&quot;,
&quot;target&quot;: &quot;cpp/types/aligned_storage&quot;
},
{
&quot;string&quot;: &quot;std::aligned_union&quot;,
&quot;target&quot;: &quot;cpp/types/aligned_union&quot;
},
{
&quot;string&quot;: &quot;std::alignment_of&quot;,
&quot;target&quot;: &quot;cpp/types/alignment_of&quot;
},
{
&quot;string&quot;: &quot;std::bad_cast&quot;,
&quot;target&quot;: &quot;cpp/types/bad_cast&quot;
},
{
&quot;string&quot;: &quot;std::bad_cast::bad_cast&quot;,
&quot;target&quot;: &quot;cpp/types/bad_cast/bad_cast&quot;
},
{
&quot;string&quot;: &quot;std::bad_typeid&quot;,
&quot;target&quot;: &quot;cpp/types/bad_typeid&quot;
},
{
&quot;string&quot;: &quot;std::bad_typeid::bad_typeid&quot;,
&quot;target&quot;: &quot;cpp/types/bad_typeid/bad_typeid&quot;
},
{
&quot;string&quot;: &quot;PTRDIFF_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;PTRDIFF_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SIZE_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SIG_ATOMIC_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SIG_ATOMIC_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;WCHAR_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;WCHAR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;WINT_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;WINT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;CHAR_BIT&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;MB_LEN_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;CHAR_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;CHAR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SCHAR_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SHRT_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;INT_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LONG_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LLONG_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SCHAR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;SHRT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;INT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LONG_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LLONG_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;UCHAR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;USHRT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;UINT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;ULONG_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;ULLONG_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_RADIX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DECIMAL_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_EPSILON&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_EPSILON&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_EPSILON&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MANT_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MANT_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MANT_DIG&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MIN_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MIN_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MIN_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MIN_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MIN_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MIN_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MAX_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MAX_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MAX_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_MAX_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;DBL_MAX_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;LDBL_MAX_10_EXP&quot;,
&quot;target&quot;: &quot;cpp/types/climits&quot;
},
{
&quot;string&quot;: &quot;FLT_EVAL_METHOD&quot;,
&quot;target&quot;: &quot;cpp/types/climits/FLT_EVAL_METHOD&quot;
},
{
&quot;string&quot;: &quot;FLT_ROUNDS&quot;,
&quot;target&quot;: &quot;cpp/types/climits/FLT_ROUNDS&quot;
},
{
&quot;string&quot;: &quot;std::common_type&quot;,
&quot;target&quot;: &quot;cpp/types/common_type&quot;
},
{
&quot;string&quot;: &quot;std::conditional&quot;,
&quot;target&quot;: &quot;cpp/types/conditional&quot;
},
{
&quot;string&quot;: &quot;std::decay&quot;,
&quot;target&quot;: &quot;cpp/types/decay&quot;
},
{
&quot;string&quot;: &quot;std::enable_if&quot;,
&quot;target&quot;: &quot;cpp/types/enable_if&quot;
},
{
&quot;string&quot;: &quot;std::extent&quot;,
&quot;target&quot;: &quot;cpp/types/extent&quot;
},
{
&quot;string&quot;: &quot;std::has_virtual_destructor&quot;,
&quot;target&quot;: &quot;cpp/types/has_virtual_destructor&quot;
},
{
&quot;string&quot;: &quot;std::int8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_fast8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_fast16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_fast32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_fast64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_least8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_least16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_least32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::int_least64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::intmax_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::intptr_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_fast8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_fast16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_fast32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_fast64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_least8_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_least16_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_least32_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uint_least64_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uintmax_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::uintptr_t&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT8_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT16_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT32_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT64_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST8_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST16_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST32_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST64_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST8_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST16_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST32_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST64_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INTPTR_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INTMAX_MIN&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_FAST64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INT_LEAST64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INTPTR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;INTMAX_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_FAST8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_FAST16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_FAST32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_FAST64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_LEAST8_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_LEAST16_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_LEAST32_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINT_LEAST64_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINTPTR_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;UINTMAX_MAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRId8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRId16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRId32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRId64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIdPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIi8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIi16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIi32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIi64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIiPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIu8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIu16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIu32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIu64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIuPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIo8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIo16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIo32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIo64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIoPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIx8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIx16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIx32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIx64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIxPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIX8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIX16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIX32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIX64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;PRIXPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNd8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNd16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNd32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNd64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNdPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNi8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNi16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNi32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNi64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNiPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNu8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNu16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNu32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNu64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNuPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNo8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNo16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNo32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNo64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNoPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNx8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNx16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNx32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNx64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNxPTR &quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNX8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNX16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNX32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNX64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXLEAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXLEAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXLEAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXLEAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXFAST8&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXFAST16&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXFAST32&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXFAST64&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXMAX&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;SCNXPTR&quot;,
&quot;target&quot;: &quot;cpp/types/integer&quot;
},
{
&quot;string&quot;: &quot;std::integral_constant&quot;,
&quot;target&quot;: &quot;cpp/types/integral_constant&quot;
},
{
&quot;string&quot;: &quot;std::true_type&quot;,
&quot;target&quot;: &quot;cpp/types/integral_constant&quot;
},
{
&quot;string&quot;: &quot;std::false_type&quot;,
&quot;target&quot;: &quot;cpp/types/integral_constant&quot;
},
{
&quot;string&quot;: &quot;std::is_abstract&quot;,
&quot;target&quot;: &quot;cpp/types/is_abstract&quot;
},
{
&quot;string&quot;: &quot;std::is_arithmetic&quot;,
&quot;target&quot;: &quot;cpp/types/is_arithmetic&quot;
},
{
&quot;string&quot;: &quot;std::is_array&quot;,
&quot;target&quot;: &quot;cpp/types/is_array&quot;
},
{
&quot;string&quot;: &quot;std::is_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_base_of&quot;,
&quot;target&quot;: &quot;cpp/types/is_base_of&quot;
},
{
&quot;string&quot;: &quot;std::is_class&quot;,
&quot;target&quot;: &quot;cpp/types/is_class&quot;
},
{
&quot;string&quot;: &quot;std::is_compound&quot;,
&quot;target&quot;: &quot;cpp/types/is_compound&quot;
},
{
&quot;string&quot;: &quot;std::is_const&quot;,
&quot;target&quot;: &quot;cpp/types/is_const&quot;
},
{
&quot;string&quot;: &quot;std::is_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_convertible&quot;,
&quot;target&quot;: &quot;cpp/types/is_convertible&quot;
},
{
&quot;string&quot;: &quot;std::is_copy_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_copy_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_copy_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_copy_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_copy_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_copy_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_copy_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_default_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_default_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_default_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_default_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_default_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_default_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_destructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_destructible&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_destructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_destructible&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_destructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_destructible&quot;
},
{
&quot;string&quot;: &quot;std::is_empty&quot;,
&quot;target&quot;: &quot;cpp/types/is_empty&quot;
},
{
&quot;string&quot;: &quot;std::is_enum&quot;,
&quot;target&quot;: &quot;cpp/types/is_enum&quot;
},
{
&quot;string&quot;: &quot;std::is_floating_point&quot;,
&quot;target&quot;: &quot;cpp/types/is_floating_point&quot;
},
{
&quot;string&quot;: &quot;std::is_function&quot;,
&quot;target&quot;: &quot;cpp/types/is_function&quot;
},
{
&quot;string&quot;: &quot;std::is_fundamental&quot;,
&quot;target&quot;: &quot;cpp/types/is_fundamental&quot;
},
{
&quot;string&quot;: &quot;std::is_integral&quot;,
&quot;target&quot;: &quot;cpp/types/is_integral&quot;
},
{
&quot;string&quot;: &quot;std::is_literal_type&quot;,
&quot;target&quot;: &quot;cpp/types/is_literal_type&quot;
},
{
&quot;string&quot;: &quot;std::is_lvalue_reference&quot;,
&quot;target&quot;: &quot;cpp/types/is_lvalue_reference&quot;
},
{
&quot;string&quot;: &quot;std::is_member_function_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/is_member_function_pointer&quot;
},
{
&quot;string&quot;: &quot;std::is_member_object_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/is_member_object_pointer&quot;
},
{
&quot;string&quot;: &quot;std::is_member_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/is_member_pointer&quot;
},
{
&quot;string&quot;: &quot;std::is_move_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_move_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_move_assignable&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_assignable&quot;
},
{
&quot;string&quot;: &quot;std::is_move_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_move_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_nothrow_move_constructible&quot;,
&quot;target&quot;: &quot;cpp/types/is_move_constructible&quot;
},
{
&quot;string&quot;: &quot;std::is_object&quot;,
&quot;target&quot;: &quot;cpp/types/is_object&quot;
},
{
&quot;string&quot;: &quot;std::is_pod&quot;,
&quot;target&quot;: &quot;cpp/types/is_pod&quot;
},
{
&quot;string&quot;: &quot;std::is_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/is_pointer&quot;
},
{
&quot;string&quot;: &quot;std::is_polymorphic&quot;,
&quot;target&quot;: &quot;cpp/types/is_polymorphic&quot;
},
{
&quot;string&quot;: &quot;std::is_reference&quot;,
&quot;target&quot;: &quot;cpp/types/is_reference&quot;
},
{
&quot;string&quot;: &quot;std::is_rvalue_reference&quot;,
&quot;target&quot;: &quot;cpp/types/is_rvalue_reference&quot;
},
{
&quot;string&quot;: &quot;std::is_same&quot;,
&quot;target&quot;: &quot;cpp/types/is_same&quot;
},
{
&quot;string&quot;: &quot;std::is_scalar&quot;,
&quot;target&quot;: &quot;cpp/types/is_scalar&quot;
},
{
&quot;string&quot;: &quot;std::is_signed&quot;,
&quot;target&quot;: &quot;cpp/types/is_signed&quot;
},
{
&quot;string&quot;: &quot;std::is_standard_layout&quot;,
&quot;target&quot;: &quot;cpp/types/is_standard_layout&quot;
},
{
&quot;string&quot;: &quot;std::is_trivial&quot;,
&quot;target&quot;: &quot;cpp/types/is_trivial&quot;
},
{
&quot;string&quot;: &quot;std::is_trivially_copyable&quot;,
&quot;target&quot;: &quot;cpp/types/is_trivially_copyable&quot;
},
{
&quot;string&quot;: &quot;std::is_union&quot;,
&quot;target&quot;: &quot;cpp/types/is_union&quot;
},
{
&quot;string&quot;: &quot;std::is_unsigned&quot;,
&quot;target&quot;: &quot;cpp/types/is_unsigned&quot;
},
{
&quot;string&quot;: &quot;std::is_void&quot;,
&quot;target&quot;: &quot;cpp/types/is_void&quot;
},
{
&quot;string&quot;: &quot;std::is_volatile&quot;,
&quot;target&quot;: &quot;cpp/types/is_volatile&quot;
},
{
&quot;string&quot;: &quot;std::make_signed&quot;,
&quot;target&quot;: &quot;cpp/types/make_signed&quot;
},
{
&quot;string&quot;: &quot;std::make_unsigned&quot;,
&quot;target&quot;: &quot;cpp/types/make_unsigned&quot;
},
{
&quot;string&quot;: &quot;std::max_align_t&quot;,
&quot;target&quot;: &quot;cpp/types/max_align_t&quot;
},
{
&quot;string&quot;: &quot;std::nullptr_t&quot;,
&quot;target&quot;: &quot;cpp/types/nullptr_t&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::denorm_min&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/denorm_min&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;denorm_min&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/denorm_min&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::digits&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/digits&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;digits&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/digits&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::digits10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/digits10&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;digits10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/digits10&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::epsilon&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/epsilon&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;epsilon&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/epsilon&quot;
},
{
&quot;string&quot;: &quot;std::float_denorm_style&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_denorm_style&quot;
},
{
&quot;string&quot;: &quot;std::denorm_indeterminate&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_denorm_style&quot;
},
{
&quot;string&quot;: &quot;std::denorm_absent&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_denorm_style&quot;
},
{
&quot;string&quot;: &quot;std::denorm_present&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_denorm_style&quot;
},
{
&quot;string&quot;: &quot;std::float_round_style&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::round_indeterminate&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::round_toward_zero&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::round_to_nearest&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::round_toward_infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::round_toward_neg_infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/float_round_style&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::has_denorm&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_denorm&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;has_denorm&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_denorm&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::has_denorm_loss&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_denorm_loss&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;has_denorm_loss&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_denorm_loss&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::has_infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_infinity&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;has_infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_infinity&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::has_quiet_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_quiet_NaN&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;has_quiet_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_quiet_NaN&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::has_signaling_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_signaling_NaN&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;has_signaling_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/has_signaling_NaN&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/infinity&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;infinity&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/infinity&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_bounded&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_bounded&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_bounded&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_bounded&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_exact&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_exact&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_exact&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_exact&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_iec559&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_iec559&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_iec559&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_iec559&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_integer&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_integer&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_integer&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_integer&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_modulo&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_modulo&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_modulo&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_modulo&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_signed&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_signed&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_signed&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_signed&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::is_specialized&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_specialized&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;is_specialized&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/is_specialized&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::lowest&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/lowest&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;lowest&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/lowest&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::max&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;max&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::max_digits10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_digits10&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;max_digits10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_digits10&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::max_exponent&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_exponent&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;max_exponent&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_exponent&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::max_exponent10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_exponent10&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;max_exponent10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/max_exponent10&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::min&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;min&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::min_exponent&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min_exponent&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;min_exponent&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min_exponent&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::min_exponent10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min_exponent10&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;min_exponent10&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/min_exponent10&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::quiet_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/quiet_NaN&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;quiet_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/quiet_NaN&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::radix&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/radix&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;radix&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/radix&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::round_error&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/round_error&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;round_error&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/round_error&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::round_style&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/round_style&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;round_style&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/round_style&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::signaling_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/signaling_NaN&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;signaling_NaN&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/signaling_NaN&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::tinyness_before&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/tinyness_before&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;tinyness_before&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/tinyness_before&quot;
},
{
&quot;string&quot;: &quot;std::numeric_limits::traps&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/traps&quot;
},
{
&quot;on_group&quot;: &quot;std::numeric_limits&quot;,
&quot;string&quot;: &quot;traps&quot;,
&quot;target&quot;: &quot;cpp/types/numeric_limits/traps&quot;
},
{
&quot;string&quot;: &quot;offsetof&quot;,
&quot;target&quot;: &quot;cpp/types/offsetof&quot;
},
{
&quot;string&quot;: &quot;std::ptrdiff_t&quot;,
&quot;target&quot;: &quot;cpp/types/ptrdiff_t&quot;
},
{
&quot;string&quot;: &quot;std::rank&quot;,
&quot;target&quot;: &quot;cpp/types/rank&quot;
},
{
&quot;string&quot;: &quot;std::remove_all_extents&quot;,
&quot;target&quot;: &quot;cpp/types/remove_all_extents&quot;
},
{
&quot;string&quot;: &quot;std::remove_cv&quot;,
&quot;target&quot;: &quot;cpp/types/remove_cv&quot;
},
{
&quot;string&quot;: &quot;std::remove_const&quot;,
&quot;target&quot;: &quot;cpp/types/remove_cv&quot;
},
{
&quot;string&quot;: &quot;std::remove_volatile&quot;,
&quot;target&quot;: &quot;cpp/types/remove_cv&quot;
},
{
&quot;string&quot;: &quot;std::remove_extent&quot;,
&quot;target&quot;: &quot;cpp/types/remove_extent&quot;
},
{
&quot;string&quot;: &quot;std::remove_pointer&quot;,
&quot;target&quot;: &quot;cpp/types/remove_pointer&quot;
},
{
&quot;string&quot;: &quot;std::remove_reference&quot;,
&quot;target&quot;: &quot;cpp/types/remove_reference&quot;
},
{
&quot;string&quot;: &quot;std::result_of&quot;,
&quot;target&quot;: &quot;cpp/types/result_of&quot;
},
{
&quot;string&quot;: &quot;std::size_t&quot;,
&quot;target&quot;: &quot;cpp/types/size_t&quot;
},
{
&quot;string&quot;: &quot;std::type_index&quot;,
&quot;target&quot;: &quot;cpp/types/type_index&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::type_index&gt;&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/hash&quot;
},
{
&quot;string&quot;: &quot;std::type_index::hash_code&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/hash_code&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;hash_code&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/hash_code&quot;
},
{
&quot;string&quot;: &quot;std::type_index::name&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/name&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;name&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/name&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator==&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator!=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator&lt;=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator&lt;=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator&lt;&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator&gt;=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator&gt;=&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::operator&gt;&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_index&quot;,
&quot;string&quot;: &quot;operator&gt;&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_index::type_index&quot;,
&quot;target&quot;: &quot;cpp/types/type_index/type_index&quot;
},
{
&quot;string&quot;: &quot;std::type_info&quot;,
&quot;target&quot;: &quot;cpp/types/type_info&quot;
},
{
&quot;string&quot;: &quot;std::type_info::before&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/before&quot;
},
{
&quot;on_group&quot;: &quot;std::type_info&quot;,
&quot;string&quot;: &quot;before&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/before&quot;
},
{
&quot;string&quot;: &quot;std::type_info::hash_code&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/hash_code&quot;
},
{
&quot;on_group&quot;: &quot;std::type_info&quot;,
&quot;string&quot;: &quot;hash_code&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/hash_code&quot;
},
{
&quot;string&quot;: &quot;std::type_info::name&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/name&quot;
},
{
&quot;on_group&quot;: &quot;std::type_info&quot;,
&quot;string&quot;: &quot;name&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/name&quot;
},
{
&quot;string&quot;: &quot;std::type_info::operator==&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_info&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::type_info::operator!=&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::type_info&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/types/type_info/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::underlying_type&quot;,
&quot;target&quot;: &quot;cpp/types/underlying_type&quot;
},
{
&quot;string&quot;: &quot;std::bad_optional_access&quot;,
&quot;target&quot;: &quot;cpp/utility/bad_optional_access&quot;
},
{
&quot;string&quot;: &quot;std::bad_optional_access::bad_optional_access&quot;,
&quot;target&quot;: &quot;cpp/utility/bad_optional_access&quot;
},
{
&quot;string&quot;: &quot;std::bitset&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset&quot;
},
{
&quot;string&quot;: &quot;std::bitset::all&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;all&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;string&quot;: &quot;std::bitset::any&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;any&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;string&quot;: &quot;std::bitset::none&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;none&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/all_any_none&quot;
},
{
&quot;string&quot;: &quot;std::bitset::bitset&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/bitset&quot;
},
{
&quot;string&quot;: &quot;std::bitset::count&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/count&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;count&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/count&quot;
},
{
&quot;string&quot;: &quot;std::bitset::flip&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/flip&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;flip&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/flip&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::bitset&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/hash&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator=&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator[]&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_at&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator[]&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_at&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator==&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator==&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator!=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_cmp&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator!=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator&amp;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator&amp;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator|=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator|=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator^=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator^=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator~&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator~&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic&quot;
},
{
&quot;string&quot;: &quot;operator&amp;(std::bitset)&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic2&quot;
},
{
&quot;string&quot;: &quot;operator|(std::bitset)&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic2&quot;
},
{
&quot;string&quot;: &quot;operator^(std::bitset)&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_logic2&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator&lt;&lt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator&gt;&gt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator&lt;&lt;&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;std::bitset::operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;operator&gt;&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt&quot;
},
{
&quot;string&quot;: &quot;operator&lt;&lt;(std::bitset)&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt2&quot;
},
{
&quot;string&quot;: &quot;operator&gt;&gt;(std::bitset)&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/operator_ltltgtgt2&quot;
},
{
&quot;string&quot;: &quot;std::bitset::reference&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/reference&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;reference&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/reference&quot;
},
{
&quot;string&quot;: &quot;std::bitset::reset&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/reset&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;reset&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/reset&quot;
},
{
&quot;string&quot;: &quot;std::bitset::set&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/set&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;set&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/set&quot;
},
{
&quot;string&quot;: &quot;std::bitset::size&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/size&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/size&quot;
},
{
&quot;string&quot;: &quot;std::bitset::test&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/test&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;test&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/test&quot;
},
{
&quot;string&quot;: &quot;std::bitset::to_string&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_string&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;to_string&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_string&quot;
},
{
&quot;string&quot;: &quot;std::bitset::to_ullong&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_ullong&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;to_ullong&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_ullong&quot;
},
{
&quot;string&quot;: &quot;std::bitset::to_ulong&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_ulong&quot;
},
{
&quot;on_group&quot;: &quot;std::bitset&quot;,
&quot;string&quot;: &quot;to_ulong&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/to_ulong&quot;
},
{
&quot;string&quot;: &quot;std::bitset::~bitset&quot;,
&quot;target&quot;: &quot;cpp/utility/bitset/~bitset&quot;
},
{
&quot;string&quot;: &quot;std::declval&quot;,
&quot;target&quot;: &quot;cpp/utility/declval&quot;
},
{
&quot;string&quot;: &quot;std::forward&quot;,
&quot;target&quot;: &quot;cpp/utility/forward&quot;
},
{
&quot;string&quot;: &quot;std::bad_function_call&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bad_function_call&quot;
},
{
&quot;string&quot;: &quot;std::bad_function_call::bad_function_call&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bad_function_call/bad_function_call&quot;
},
{
&quot;string&quot;: &quot;std::bad_function_call::what&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bad_function_call/what&quot;
},
{
&quot;on_group&quot;: &quot;std::bad_function_call&quot;,
&quot;string&quot;: &quot;what&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bad_function_call/what&quot;
},
{
&quot;string&quot;: &quot;std::binary_function&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/binary_function&quot;
},
{
&quot;string&quot;: &quot;std::binary_negate&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/binary_negate&quot;
},
{
&quot;string&quot;: &quot;std::binary_negate::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/binary_negate&quot;
},
{
&quot;on_group&quot;: &quot;std::binary_negate&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/binary_negate&quot;
},
{
&quot;string&quot;: &quot;std::binary_negate::binary_negate&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/binary_negate/binary_negate&quot;
},
{
&quot;string&quot;: &quot;std::bind&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bind&quot;
},
{
&quot;string&quot;: &quot;std::bit_and&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_and&quot;
},
{
&quot;string&quot;: &quot;std::bit_and::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_and&quot;
},
{
&quot;on_group&quot;: &quot;std::bit_and&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_and&quot;
},
{
&quot;string&quot;: &quot;std::bit_not&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_not&quot;
},
{
&quot;string&quot;: &quot;std::bit_not::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_not&quot;
},
{
&quot;on_group&quot;: &quot;std::bit_not&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_not&quot;
},
{
&quot;string&quot;: &quot;std::bit_or&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_or&quot;
},
{
&quot;string&quot;: &quot;std::bit_or::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_or&quot;
},
{
&quot;on_group&quot;: &quot;std::bit_or&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/bit_or&quot;
},
{
&quot;string&quot;: &quot;std::divides&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/divides&quot;
},
{
&quot;string&quot;: &quot;std::divides::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/divides&quot;
},
{
&quot;on_group&quot;: &quot;std::divides&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/divides&quot;
},
{
&quot;string&quot;: &quot;std::equal_to&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/equal_to&quot;
},
{
&quot;string&quot;: &quot;std::equal_to::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/equal_to&quot;
},
{
&quot;on_group&quot;: &quot;std::equal_to&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/equal_to&quot;
},
{
&quot;string&quot;: &quot;std::function&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function&quot;
},
{
&quot;string&quot;: &quot;std::function::assign&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/assign&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;assign&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/assign&quot;
},
{
&quot;string&quot;: &quot;std::function::function&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/function&quot;
},
{
&quot;string&quot;: &quot;std::function::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator()&quot;
},
{
&quot;string&quot;: &quot;std::function::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator=&quot;
},
{
&quot;string&quot;: &quot;std::function::operator bool&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator_bool&quot;
},
{
&quot;string&quot;: &quot;operator==(std::function)&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::function)&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::function::swap&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::function)&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/swap&quot;
},
{
&quot;string&quot;: &quot;std::function::target&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/target&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;target&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/target&quot;
},
{
&quot;string&quot;: &quot;std::function::target_type&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/target_type&quot;
},
{
&quot;on_group&quot;: &quot;std::function&quot;,
&quot;string&quot;: &quot;target_type&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/target_type&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::function&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;std::function::~function&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/function/~function&quot;
},
{
&quot;string&quot;: &quot;std::greater&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater&quot;
},
{
&quot;string&quot;: &quot;std::greater::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater&quot;
},
{
&quot;on_group&quot;: &quot;std::greater&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater&quot;
},
{
&quot;string&quot;: &quot;std::greater_equal&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater_equal&quot;
},
{
&quot;string&quot;: &quot;std::greater_equal::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater_equal&quot;
},
{
&quot;on_group&quot;: &quot;std::greater_equal&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/greater_equal&quot;
},
{
&quot;string&quot;: &quot;std::is_bind_expression&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/is_bind_expression&quot;
},
{
&quot;string&quot;: &quot;std::is_placeholder&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/is_placeholder&quot;
},
{
&quot;string&quot;: &quot;std::less&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less&quot;
},
{
&quot;string&quot;: &quot;std::less::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less&quot;
},
{
&quot;on_group&quot;: &quot;std::less&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less&quot;
},
{
&quot;string&quot;: &quot;std::less_equal&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less_equal&quot;
},
{
&quot;string&quot;: &quot;std::less_equal::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less_equal&quot;
},
{
&quot;on_group&quot;: &quot;std::less_equal&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/less_equal&quot;
},
{
&quot;string&quot;: &quot;std::logical_and&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_and&quot;
},
{
&quot;string&quot;: &quot;std::logical_and::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_and&quot;
},
{
&quot;on_group&quot;: &quot;std::logical_and&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_and&quot;
},
{
&quot;string&quot;: &quot;std::logical_not&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_not&quot;
},
{
&quot;string&quot;: &quot;std::logical_not::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_not&quot;
},
{
&quot;on_group&quot;: &quot;std::logical_not&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_not&quot;
},
{
&quot;string&quot;: &quot;std::logical_or&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_or&quot;
},
{
&quot;string&quot;: &quot;std::logical_or::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_or&quot;
},
{
&quot;on_group&quot;: &quot;std::logical_or&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/logical_or&quot;
},
{
&quot;string&quot;: &quot;std::mem_fn&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/mem_fn&quot;
},
{
&quot;string&quot;: &quot;std::minus&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/minus&quot;
},
{
&quot;string&quot;: &quot;std::minus::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/minus&quot;
},
{
&quot;on_group&quot;: &quot;std::minus&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/minus&quot;
},
{
&quot;string&quot;: &quot;std::modulus&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/modulus&quot;
},
{
&quot;string&quot;: &quot;std::modulus::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/modulus&quot;
},
{
&quot;on_group&quot;: &quot;std::modulus&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/modulus&quot;
},
{
&quot;string&quot;: &quot;std::multiplies&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/multiplies&quot;
},
{
&quot;string&quot;: &quot;std::multiplies::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/multiplies&quot;
},
{
&quot;on_group&quot;: &quot;std::multiplies&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/multiplies&quot;
},
{
&quot;string&quot;: &quot;std::negate&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/negate&quot;
},
{
&quot;string&quot;: &quot;std::negate::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/negate&quot;
},
{
&quot;on_group&quot;: &quot;std::negate&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/negate&quot;
},
{
&quot;string&quot;: &quot;std::not1&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/not1&quot;
},
{
&quot;string&quot;: &quot;std::not2&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/not2&quot;
},
{
&quot;string&quot;: &quot;std::not_equal_to&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/not_equal_to&quot;
},
{
&quot;string&quot;: &quot;std::not_equal_to::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/not_equal_to&quot;
},
{
&quot;on_group&quot;: &quot;std::not_equal_to&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/not_equal_to&quot;
},
{
&quot;string&quot;: &quot;std::placeholders&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/placeholders&quot;
},
{
&quot;string&quot;: &quot;std::plus&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/plus&quot;
},
{
&quot;string&quot;: &quot;std::plus::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/plus&quot;
},
{
&quot;on_group&quot;: &quot;std::plus&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/plus&quot;
},
{
&quot;string&quot;: &quot;std::ref&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/ref&quot;
},
{
&quot;string&quot;: &quot;std::cref&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/ref&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper::operator T&amp;&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/get&quot;
},
{
&quot;on_group&quot;: &quot;std::reference_wrapper&quot;,
&quot;string&quot;: &quot;operator T&amp;&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/get&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper::get&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/get&quot;
},
{
&quot;on_group&quot;: &quot;std::reference_wrapper&quot;,
&quot;string&quot;: &quot;get&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/get&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::reference_wrapper&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/operator()&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::reference_wrapper&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/operator=&quot;
},
{
&quot;string&quot;: &quot;std::reference_wrapper::reference_wrapper&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/reference_wrapper/reference_wrapper&quot;
},
{
&quot;string&quot;: &quot;std::unary_function&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/unary_function&quot;
},
{
&quot;string&quot;: &quot;std::unary_negate&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/unary_negate&quot;
},
{
&quot;string&quot;: &quot;std::unary_negate::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/unary_negate&quot;
},
{
&quot;on_group&quot;: &quot;std::unary_negate&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/unary_negate&quot;
},
{
&quot;string&quot;: &quot;std::unary_negate::unary_negate&quot;,
&quot;target&quot;: &quot;cpp/utility/functional/unary_negate/unary_negate&quot;
},
{
&quot;string&quot;: &quot;std::hash&quot;,
&quot;target&quot;: &quot;cpp/utility/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash::hash&quot;,
&quot;target&quot;: &quot;cpp/utility/hash/hash&quot;
},
{
&quot;string&quot;: &quot;std::hash::operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/hash/operator()&quot;
},
{
&quot;on_group&quot;: &quot;std::hash&quot;,
&quot;string&quot;: &quot;operator()&quot;,
&quot;target&quot;: &quot;cpp/utility/hash/operator()&quot;
},
{
&quot;string&quot;: &quot;std::initializer_list&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list&quot;
},
{
&quot;string&quot;: &quot;std::initializer_list::begin&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/begin&quot;
},
{
&quot;on_group&quot;: &quot;std::initializer_list&quot;,
&quot;string&quot;: &quot;begin&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/begin&quot;
},
{
&quot;string&quot;: &quot;std::begin(std::initializer_list)&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/begin2&quot;
},
{
&quot;string&quot;: &quot;std::initializer_list::end&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/end&quot;
},
{
&quot;on_group&quot;: &quot;std::initializer_list&quot;,
&quot;string&quot;: &quot;end&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/end&quot;
},
{
&quot;string&quot;: &quot;std::end(std::initializer_list)&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/end2&quot;
},
{
&quot;string&quot;: &quot;std::initializer_list::initializer_list&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/initializer_list&quot;
},
{
&quot;string&quot;: &quot;std::initializer_list::size&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/size&quot;
},
{
&quot;on_group&quot;: &quot;std::initializer_list&quot;,
&quot;string&quot;: &quot;size&quot;,
&quot;target&quot;: &quot;cpp/utility/initializer_list/size&quot;
},
{
&quot;string&quot;: &quot;std::inplace&quot;,
&quot;target&quot;: &quot;cpp/utility/inplace&quot;
},
{
&quot;string&quot;: &quot;std::inplace_t&quot;,
&quot;target&quot;: &quot;cpp/utility/inplace_t&quot;
},
{
&quot;string&quot;: &quot;std::integer_sequence&quot;,
&quot;target&quot;: &quot;cpp/utility/integer_sequence&quot;
},
{
&quot;string&quot;: &quot;std::move&quot;,
&quot;target&quot;: &quot;cpp/utility/move&quot;
},
{
&quot;string&quot;: &quot;std::move_if_noexcept&quot;,
&quot;target&quot;: &quot;cpp/utility/move_if_noexcept&quot;
},
{
&quot;string&quot;: &quot;std::nullopt&quot;,
&quot;target&quot;: &quot;cpp/utility/nullopt&quot;
},
{
&quot;string&quot;: &quot;std::nullopt_t&quot;,
&quot;target&quot;: &quot;cpp/utility/nullopt_t&quot;
},
{
&quot;string&quot;: &quot;std::optional&quot;,
&quot;target&quot;: &quot;cpp/utility/optional&quot;
},
{
&quot;string&quot;: &quot;std::optional::emplace&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/emplace&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;emplace&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/emplace&quot;
},
{
&quot;string&quot;: &quot;std::hash&lt;std::optional&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/hash&quot;
},
{
&quot;string&quot;: &quot;std::make_optional&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/make_optional&quot;
},
{
&quot;string&quot;: &quot;std::optional::operator*&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;operator*&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator*&quot;
},
{
&quot;string&quot;: &quot;std::optional::operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator*&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;operator-&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator*&quot;
},
{
&quot;string&quot;: &quot;std::optional::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator=&quot;
},
{
&quot;string&quot;: &quot;std::optional::operator bool&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator_bool&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;operator bool&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator_bool&quot;
},
{
&quot;string&quot;: &quot;operator==(std::optional)&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::optional)&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::optional::optional&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/optional&quot;
},
{
&quot;string&quot;: &quot;std::optional::swap&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::optional)&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/swap2&quot;
},
{
&quot;string&quot;: &quot;std::optional::value&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/value&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;value&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/value&quot;
},
{
&quot;string&quot;: &quot;std::optional::value_or&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/value_or&quot;
},
{
&quot;on_group&quot;: &quot;std::optional&quot;,
&quot;string&quot;: &quot;value_or&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/value_or&quot;
},
{
&quot;string&quot;: &quot;std::optional::~optional&quot;,
&quot;target&quot;: &quot;cpp/utility/optional/~optional&quot;
},
{
&quot;string&quot;: &quot;std::pair&quot;,
&quot;target&quot;: &quot;cpp/utility/pair&quot;
},
{
&quot;string&quot;: &quot;std::get(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/get&quot;
},
{
&quot;string&quot;: &quot;std::make_pair&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/make_pair&quot;
},
{
&quot;string&quot;: &quot;std::pair::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::pair&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::pair::pair&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/pair&quot;
},
{
&quot;string&quot;: &quot;std::pair::swap&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::pair&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::pair)&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/swap2&quot;
},
{
&quot;string&quot;: &quot;std::tuple_element&lt;std::pair&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/tuple_element&quot;
},
{
&quot;string&quot;: &quot;std::tuple_size&lt;std::pair&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/pair/tuple_size&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_construct&quot;,
&quot;target&quot;: &quot;cpp/utility/piecewise_construct&quot;
},
{
&quot;string&quot;: &quot;std::piecewise_construct_t&quot;,
&quot;target&quot;: &quot;cpp/utility/piecewise_construct_t&quot;
},
{
&quot;string&quot;: &quot;EXIT_SUCCESS&quot;,
&quot;target&quot;: &quot;cpp/utility/program/EXIT_status&quot;
},
{
&quot;string&quot;: &quot;EXIT_FAILURE&quot;,
&quot;target&quot;: &quot;cpp/utility/program/EXIT_status&quot;
},
{
&quot;string&quot;: &quot;SIG_ERR&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_ERR&quot;
},
{
&quot;string&quot;: &quot;SIG_DFL&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_strategies&quot;
},
{
&quot;string&quot;: &quot;SIG_IGN&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_strategies&quot;
},
{
&quot;string&quot;: &quot;SIGABRT&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;SIGFPE&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;SIGILL&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;SIGINT&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;SIGSEGV&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;SIGTERM&quot;,
&quot;target&quot;: &quot;cpp/utility/program/SIG_types&quot;
},
{
&quot;string&quot;: &quot;std::_Exit&quot;,
&quot;target&quot;: &quot;cpp/utility/program/_Exit&quot;
},
{
&quot;string&quot;: &quot;std::abort&quot;,
&quot;target&quot;: &quot;cpp/utility/program/abort&quot;
},
{
&quot;string&quot;: &quot;std::at_quick_exit&quot;,
&quot;target&quot;: &quot;cpp/utility/program/at_quick_exit&quot;
},
{
&quot;string&quot;: &quot;std::atexit&quot;,
&quot;target&quot;: &quot;cpp/utility/program/atexit&quot;
},
{
&quot;string&quot;: &quot;std::exit&quot;,
&quot;target&quot;: &quot;cpp/utility/program/exit&quot;
},
{
&quot;string&quot;: &quot;std::getenv&quot;,
&quot;target&quot;: &quot;cpp/utility/program/getenv&quot;
},
{
&quot;string&quot;: &quot;std::jmp_buf&quot;,
&quot;target&quot;: &quot;cpp/utility/program/jmp_buf&quot;
},
{
&quot;string&quot;: &quot;std::longjmp&quot;,
&quot;target&quot;: &quot;cpp/utility/program/longjmp&quot;
},
{
&quot;string&quot;: &quot;std::quick_exit&quot;,
&quot;target&quot;: &quot;cpp/utility/program/quick_exit&quot;
},
{
&quot;string&quot;: &quot;std::raise&quot;,
&quot;target&quot;: &quot;cpp/utility/program/raise&quot;
},
{
&quot;string&quot;: &quot;setjmp&quot;,
&quot;target&quot;: &quot;cpp/utility/program/setjmp&quot;
},
{
&quot;string&quot;: &quot;std::sig_atomic_t&quot;,
&quot;target&quot;: &quot;cpp/utility/program/sig_atomic_t&quot;
},
{
&quot;string&quot;: &quot;std::signal&quot;,
&quot;target&quot;: &quot;cpp/utility/program/signal&quot;
},
{
&quot;string&quot;: &quot;std::system&quot;,
&quot;target&quot;: &quot;cpp/utility/program/system&quot;
},
{
&quot;string&quot;: &quot;std::rel_ops::operator!=&quot;,
&quot;target&quot;: &quot;cpp/utility/rel_ops/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::rel_ops::operator&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/rel_ops/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::rel_ops::operator&lt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/rel_ops/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::rel_ops::operator&gt;=&quot;,
&quot;target&quot;: &quot;cpp/utility/rel_ops/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::tuple&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple&quot;
},
{
&quot;string&quot;: &quot;std::forward_as_tuple&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/forward_as_tuple&quot;
},
{
&quot;string&quot;: &quot;std::get(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/get&quot;
},
{
&quot;string&quot;: &quot;std::ignore&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/ignore&quot;
},
{
&quot;string&quot;: &quot;std::make_tuple&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/make_tuple&quot;
},
{
&quot;string&quot;: &quot;std::tuple::operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator=&quot;
},
{
&quot;on_group&quot;: &quot;std::tuple&quot;,
&quot;string&quot;: &quot;operator=&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator=&quot;
},
{
&quot;string&quot;: &quot;operator==(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator!=(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&lt;=(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;operator&gt;=(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/operator_cmp&quot;
},
{
&quot;string&quot;: &quot;std::tuple::swap&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/swap&quot;
},
{
&quot;on_group&quot;: &quot;std::tuple&quot;,
&quot;string&quot;: &quot;swap&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/swap&quot;
},
{
&quot;string&quot;: &quot;std::swap(std::tuple)&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/swap2&quot;
},
{
&quot;string&quot;: &quot;std::tie&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tie&quot;
},
{
&quot;string&quot;: &quot;std::tuple::tuple&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tuple&quot;
},
{
&quot;string&quot;: &quot;std::tuple_cat&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tuple_cat&quot;
},
{
&quot;string&quot;: &quot;std::tuple_cat&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tuple_cat&quot;
},
{
&quot;string&quot;: &quot;std::tuple_element&lt;std::tuple&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tuple_element&quot;
},
{
&quot;string&quot;: &quot;std::tuple_size&lt;std::tuple&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/tuple_size&quot;
},
{
&quot;string&quot;: &quot;std::uses_allocator&lt;std::tuple&gt;&quot;,
&quot;target&quot;: &quot;cpp/utility/tuple/uses_allocator&quot;
},
{
&quot;string&quot;: &quot;va_arg&quot;,
&quot;target&quot;: &quot;cpp/utility/variadic/va_arg&quot;
},
{
&quot;string&quot;: &quot;va_copy&quot;,
&quot;target&quot;: &quot;cpp/utility/variadic/va_copy&quot;
},
{
&quot;string&quot;: &quot;va_end&quot;,
&quot;target&quot;: &quot;cpp/utility/variadic/va_end&quot;
},
{
&quot;string&quot;: &quot;va_list&quot;,
&quot;target&quot;: &quot;cpp/utility/variadic/va_list&quot;
},
{
&quot;string&quot;: &quot;va_start&quot;,
&quot;target&quot;: &quot;cpp/utility/variadic/va_start&quot;
}
]
}</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Common.css</title>
    <ns>8</ns>
    <id>1790</id>
    <revision>
      <id>72086</id>
      <parentid>71984</parentid>
      <timestamp>2014-07-13T20:33:29Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>hide {{mark since c++11}} within {{noexcept}} when the template is in rev list</comment>
      <text xml:space="preserve" bytes="41712">/* ======================================================================
   CUSTOMIZATION
 ------------------------------------------------------------------------
*/


/* local dejavu fonts */
@font-face {
    font-family: &quot;DejaVuSans&quot; ;
    src: local(&quot;DejaVu Sans&quot;), url( &quot;/DejaVuSans.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: normal;
}

@font-face {
    font-family: &quot;DejaVuSans&quot; ;
    src: local(&quot;DejaVu Sans Bold&quot;), url( &quot;/DejaVuSans-Bold.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: bold;
}

@font-face {
    font-family: &quot;DejaVuSansMono&quot; ;
    src: local(&quot;DejaVu Sans Mono Book&quot;), url( &quot;/DejaVuSansMono.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: normal;
}

@font-face {
    font-family: &quot;DejaVuSansMono&quot; ;
    src: local(&quot;DejaVu Sans Mono Bold&quot;), url( &quot;/DejaVuSansMono-Bold.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: bold;
}

@font-face {
    font-family: &quot;DejaVuSansMonoCondensed60&quot; ;
    src: url( &quot;/DejaVuSansMonoCondensed60.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: normal;
}

@font-face {
    font-family: &quot;DejaVuSansMonoCondensed75&quot; ;
    src: url( &quot;/DejaVuSansMonoCondensed75.ttf&quot; ) format(&quot;truetype&quot;);
    font-weight: normal;
}

/* hide some visual components */
.toc, #toc,                /* table of contents */
#p-logo,                   /* wiki logo */
#siteSub,                  /* subheadings below the firstHeading */
#footer-info-viewcount,    /* page view count */
.catlinks {                /* category link box */
    display: none !important;
}

div#contentSub:empty {
    display: none;
}

div#mw-panel {
    top: 40px
}

#mw-head {
    min-width: inherit;
    left: 0;
}

/*----------------------------------------------------------------------*/
/* search results style */

.mw-search-results li {
    padding-bottom: 0.4em;
    font-size: 1.0em;
    line-height: 1.1em;
}

.page-Special_Search div.mw-search-result-data,
.page-Special_Search p.mw-search-createlink,
.page-Special_Search p.mw-search-pager-bottom,
.page-Special_Search div.mw-search-formheader,
.page-Special_Search #mw-searchoptions {
    display: none;
}

/*----------------------------------------------------------------------*/
html, body {
    font-family: DejaVuSans, &quot;DejaVu Sans&quot;, arial, sans-serif;
    font-size: 16px;
}

body.skin-vector {
    min-width: 80em;
}

div#bodyContent {
    line-height: 1.2em;
    position: static;
}

#content {
    line-height: 1.2em;
    position: relative;
}

p, dd {
    line-height: 1.2em;
}

ul li {
    line-height: 1.2em;
    margin-top: 0.3em;
}

h1 {
    font-size: 2em;
}

h3 {
    padding: 1.1em 0 0.2em 0.75em;
}

/* teletype font */
tt,
code,
pre,
.mw-geshi,
.t-lc,
#wpTextbox1 {
    font-family: DejaVuSansMono, &quot;DejaVu Sans Mono&quot;, courier, monospace !important;
}

code,
table {
    background-color: transparent;
}

/* bold font */
strong, b {
    font-weight: bold;
}

/* link image for interwiki links */
#content a.extiw, #content a.extiw:active {
    /* @embed */
    background: url(&quot;/mwiki/skins/vector/images/external-link-ltr-icon.png&quot;)
                no-repeat scroll right center transparent !important;
    padding: 0 13px 0 0 !important;
}

table.fmbox,
table.ombox,
div.template-documentation,
fieldset {
    border-radius: 5px;
}

/* ----------------------------------------------------------------------
   Main page
*/

body.page-Main_Page h1.firstHeading,
body.page-Заглавная_страница h1.firstHeading,
body.page-Hauptseite h1.firstHeading,
body.page-Página_principal h1.firstHeading,
body.page-Accueil h1.firstHeading,
body.page-대문 h1.firstHeading,
body.page-Pagina_principale h1.firstHeading,
body.page-メインページ h1.firstHeading,
body.page-Página_principal h1.firstHeading,
body.page-首页 h1.firstHeading,
body.page-Ana_sayfa h1.firstHeading,
body.page-Hlavní_strana h1.firstHeading {
    display: none;
}


.mainpagetable tr.rowtop * {
    line-height: 1em;
}

.mainpagetable tr.row td:first-child {
    border-left: 1px solid silver;
    padding-left: 1em;
}

.mainpagetable tr.row td:last-child {
    border-right: 1px solid silver;
    padding-right: 1em;
}

.mainpagetable tr.rowtop td:first-child {
    border-top-left-radius: 5px;
}

.mainpagetable tr.rowtop td:last-child {
    border-top-right-radius: 5px;
}

.mainpagetable tr.rowbottom td:first-child {
    border-bottom-left-radius: 5px;
}

.mainpagetable tr.rowbottom td:last-child {
    border-bottom-right-radius: 5px;
}

.mainpagetable tr.row td {
    border-bottom: 1px solid silver;
    padding: 0.5em;
    background: #fafafa;
}

.mainpagetable tr.rowtop td {
    border-top: 1px solid silver;
    background: #f8f8f8;
}

.mainpagetable p {
    margin: 0;
}

div.mainpagediv {
    font-size: 85%;
    line-height: 1.2em;
    margin-left: 2em;
    width: auto;
}

div.mainpagediv * {
    line-height: 1.2em;
}

/* ----------------------------------------------------------------------
   Geshi
*/
pre,
div.mw-geshi {
    border: 1px solid silver;
    border-radius: 5px;
    padding: 1em;
    margin: 1em 0;
    width: 55em;
    background-color: #F9F9F9;
    overflow:auto;
}

span.mw-geshi {
    white-space: nowrap;
}

.mw-geshi a {
    color: #003080;
}

/* ----------------------------------------------------------------------
   Template:c
*/
.t-c {
    background-color: transparent;
    background-color: rgba(0,0,0,0.031);
    border: 1px solid #D6D6D6;
    border-radius: 3px;
    margin: 0 2px;
    padding: 0 2px;
    display: inline-block;
}

/* ----------------------------------------------------------------------
   Template:lc
*/
body.ns-10 .t-lc {
    border-bottom: 1px solid blue;
}

body.ns-10 .t-lc a {
    border-bottom: none;
}

/* ----------------------------------------------------------------------
   Template:vertical
*/
.t-vertical {
    width: 1.5em;
    white-space: nowrap;
    margin: 0 auto;
}

.t-vertical &gt; div {
    -moz-transform: translate(50%, 50%) rotate(90deg);
    -moz-transform-origin: 50% 0%;
    -o-transform: translate(50%, 50%) rotate(90deg);
    -o-transform-origin: 50% 0%;
    -webkit-transform: translate(50%, 50%) rotate(90deg);
    -webkit-transform-origin: 50% 0%;
    -ms-transform: translate(50%, 50%) rotate(90deg);
    -ms-transform-origin: 50% 0%;
    transform: translate(50%, 50%) rotate(90deg);
    transform-origin: 50% 0%;
    float: right;
}

/* ----------------------------------------------------------------------
   Template:li
*/
.t-li1,
.t-li2,
.t-li3 {
    text-indent: -5em;
    padding: 0.2em 0 0.2em 0;
}

.t-li1 &gt; *,
.t-li2 &gt; *,
.t-li3 &gt; * {
    text-indent: 0em;
}

.t-li1 {
    padding-left: 3em;
}

.t-li2 {
    padding-left: 5em;
}

.t-li3 {
    padding-left: 7em;
}

.t-li {
    display: inline-block;
    width: 5em;
    text-align: right;
}

/* ----------------------------------------------------------------------
   Template:lines
*/
.t-lines {
    display: table;
}

.t-lines &gt; span {
    display: table-row;
}

.t-lines &gt; span * {
    line-height: 1em;
}

.t-lines &gt; span:empty:after {
    content: &quot;\a0&quot;;
}

/* ----------------------------------------------------------------------
   Template:math
*/
span.texhtml {
    font-style: italic;
}

/* ----------------------------------------------------------------------
   Template:mfrac
*/
.t-mfrac &gt; table {
    display: inline-block;
    vertical-align: middle;
    padding: 0;
    border-spacing: 0;
    text-align: center;
    font-size: 0.9em;
}

.t-mfrac &gt; table &gt; tbody &gt; tr &gt; td {
    border: none;
}

.t-mfrac &gt; table &gt; tbody &gt; tr:first-child &gt; td {
    border-bottom:0.1em solid;
}

/* ----------------------------------------------------------------------
   Template:mrad
*/
.t-mrad {
    white-space: nowrap;
    margin-top: 1px;
}

.t-mrad &gt; span:nth-last-child(3) {
    font-size: 0.7em;
    vertical-align: 0.8em;
    margin-right: -0.5em;
}

.t-mrad &gt; span:nth-last-child(2) {
    font-size: 1.1em;
}

.t-mrad &gt; span:nth-last-child(1) {
    border-top: 0.1em solid;
}

/* ----------------------------------------------------------------------
   Template:su
*/

.t-su {
    display: inline-block;
    margin-bottom: -0.3em;
    vertical-align: 0.8em;
    line-height: 1.2em;
    font-size: 85%;
    text-align: left;
}

.t-su-b {
    vertical-align: -0.4em;
}

/* ----------------------------------------------------------------------
   Template:mparen
*/

.t-mparen,
.t-mparen &gt; span {
    white-space: nowrap;
    display: inline-block;
    vertical-align: middle;
}

.t-mparen &gt; span:nth-child(1),
.t-mparen &gt; span:nth-child(3) {
    font-style: normal;
    line-height: 1.1em;
}

.t-mparen &gt; span:nth-child(2) {
    line-height: 1.5em;
    text-align: center;
}

/* ----------------------------------------------------------------------
   Template:cc
*/
.t-cc {
    display: inline-block;
    border-top: 1px solid silver;
    border-bottom: 1px solid silver;
    padding: 0.3em 1em 0.2em 1em;
}

/* ----------------------------------------------------------------------
   Template:example
*/
.t-example-live-link {
    width: 55em;
    display: none;
}

body.ns-10 .t-example-live-link {
    display: none;
}

.t-example .mw-geshi {
    margin: 0 0 1em 0;
}

/* ----------------------------------------------------------------------
   Template:member
*/
.t-member {
    background-color: #f8f8f8;
    border: 1px solid #aaa;
    margin: 1em 0 0;
    overflow: hidden;
    padding: 0.2em 1em 1em;
}

.t-member &gt; h1 {
    font-size: 1.8em;
}

/* ----------------------------------------------------------------------
   Template:inherited
*/
.t-inherited {
    overflow: hidden;
    margin: 1em 0 0 0;
    border: 1px solid #aaa;
    background-color: #f3f3fc;
    padding: 0.2em 1em 1em 1em;
}

/* ----------------------------------------------------------------------
   Template:inheritance diagram
   Template:image
*/
.t-inheritance-diagram,
.t-image {
    display: table;
    border: 1px solid #aaa;
    padding: 0.2em 0.2em 0.2em 0.2em;
    margin: 1.0em 0 0.5em 0;
}

/* ----------------------------------------------------------------------
   Template:plot return
*/
.t-plot {
    display: table;
    position: relative;
    border: 1px solid #aaa;
    padding: 0.2em 0.2em 0.2em 0.2em;
    font-size: 0.7em;
}

.t-plot-left {
    position: absolute;
    bottom: 5em;
    /* 90 degree text rotation */
    -moz-transform:rotate(270deg);
    -moz-transform-origin: top left;
    -webkit-transform: rotate(270deg);
    -webkit-transform-origin: top left;
    -o-transform: rotate(270deg);
    -o-transform-origin:  top left;
    filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
}

.t-plot-right {
    position: absolute;
    bottom: 7em;
    left: 100%;
    white-space: nowrap;
    /* 90 degree text rotation */
    -moz-transform:rotate(270deg);
    -moz-transform-origin: bottom left;
    -webkit-transform: rotate(270deg);
    -webkit-transform-origin: bottom left;
    -o-transform: rotate(270deg);
    -o-transform-origin:  bottom left;
    filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
}

.t-plot-image {
}
.t-plot-image-left,
.t-plot-image-left-right {
    padding-left: 2em;
}
.t-plot-image-right,
.t-plot-image-left-right {
    padding-right: 2em;
}
.t-plot-bottom {
    padding-left: 6em;
}

/* ----------------------------------------------------------------------
   Template:navbar
*/
body.cpp-navbar div#content,
body.cpp-page-template div#content {
    padding-top: 32px;
}

body.cpp-navbar div#contentSub,
body.cpp-page-template div#contentSub {
    display: none;
}

.t-navbar {
    position: absolute;
    top: 0;
    left: 0;

    display: inline-block;
    height: 22px;
}

.t-navbar-head,
.t-navbar-sep {
    float: left;
    font-size: 0.9em;

    padding-top: 0.4em;
    padding-bottom: 0.3em;

    border-bottom: 1px solid silver;
    background-origin: border-box;

    height: 100%;
    box-sizing: border-box;
    -moz-box-sizing: border-box;
}

.t-navbar-head {
    padding-right: 0.2em;
    padding-left: 0.2em;
}

.t-navbar-head:nth-child(1) {
    padding-left: 1em;
}

.t-navbar-menu {
    position: relative;
    clear: both;
    display: none;
}

.t-navbar-head:hover &gt; div.t-navbar-menu {
    display: block;
}

.t-navbar-menu &gt; div {
    position: absolute;
    display: inline-block;

    background-color: white;
    border-radius: 3px;
    border: 1px solid silver;
    border-top-width: 0;
    padding: 0.5em;

    white-space: nowrap;
    z-index: 1;
}

.t-navbar-menu .editsection {
    display: none;
    font-size: 0.7em;
    opacity: 0.4;
    line-height: 1em;
}

.t-navbar-sep {
    width: 8px;

    /* @embed */
    background-image: url(&quot;/mwiki/skins/cppreference2/images/navbar-tab.png&quot;);
    background-repeat: no-repeat;
    background-position: right bottom;
}

.t-navbar-sep:first-child {
    /* @embed */
    background-image: url(&quot;/mwiki/skins/cppreference2/images/navbar-inv-tab.png&quot;);
    background-repeat: no-repeat;
    background-position: left bottom;

    border-bottom-width: 0;
}


body.skin-cppreference .t-navbar-sep:first-child,
body.skin-vector       .t-navbar-sep:first-child {
    display: none;
}

body.skin-cppreference .t-navbar-head:nth-child(2),
body.skin-vector       .t-navbar-head:nth-child(2) {
    padding-left: 1em;
}

.t-navbar-sep:last-child {
    border-bottom-width: 0;
}

/* ----------------------------------------------------------------------
   Template:page-template
*/
.t-page-template {
    position: absolute;
    top: 0;
    right: 0;

    display: inline-block;
}

.t-page-template .editsection {
    display: none;
    font-size: 0.7em;
    opacity: 0.4;
    line-height: 1em;
}

/* ----------------------------------------------------------------------
   Template:template
*/
.t-template-editlink {
    float: right;
    position: relative;
}

.t-template-editlink .editsection {
    display: none;
    font-size: 0.7em;
    opacity: 0.4;
    position: absolute;
    right: 0;
    top: -2px;
}

/* ----------------------------------------------------------------------
   Template:noexcept
*/
.t-noexcept-full,
.t-noexcept-inline {
    display: inline;
}

.t-noexcept-full .t-dcl-begin,
.t-noexcept-inline .t-dcl-begin {
    padding: 0;
}

.t-noexcept-full .t-noexcept-box {
    padding: 0 0 1em 3em;
}

.t-noexcept-inline &gt; .t-noexcept-box {
    display: inline-block;
    vertical-align: middle;
    padding:0;
}

.t-rev .t-noexcept-full .t-mark-rev,
.t-rev .t-noexcept-inline .t-mark-rev {
    display: none;
}

/* ----------------------------------------------------------------------
   Template:cmark
   Template:mark
*/
.t-cmark {
    color: #808080;
    font-size: 0.80em;
}

.t-mark,
.t-mark-rev {
    color: #008000;
    font-size: 0.80em;
}

.t-mark-rev.t-mark-ts {
    color: #e06000;
}

.wikitable th .t-mark {
    font-weight: normal;
}

/* ----------------------------------------------------------------------
   Template:spar
*/
.t-spar {
    color: #808080;
    font-style: italic;
}

/* ----------------------------------------------------------------------
   Template:dsc small
   Template:dsc *
*/
.t-dsc-small {
    font-weight: normal;
    font-size:0.7em;
    line-height:130%;
}

.t-dsc-begin {
    max-width: 60em;
    border-spacing: 0;
}

.t-dsc &gt; td:first-child {
    width: 0%;
    line-height: 1.2em;
    padding: 0.2em 0 0.25em 0.75em;
    white-space: nowrap;
}

.t-dsc &gt; td:last-child {
    line-height: 1.1em;
    padding-left: 0.75em;
    white-space: normal;
}

.t-dsc .editsection {
    display: none;
    font-size: 0.7em;
    opacity: 0.4;
}

.t-dsc-hitem &gt; td {
    font-weight: bold;
    line-height: 1.1em;
    padding: 0.2em 0 0.25em 0.75em;
    white-space: nowrap;
}

.t-dsc &gt; td,
.t-dsc-hitem &gt; td {
    border-top: 1px solid #CCCCCC;
}

.t-dsc-header &gt; td {
    padding: 0;
    font-size: 0.8em;
    line-height: 1em;
}

.t-dsc-header &gt; td:nth-child(1) &gt; div {
    margin-left: 2em;
}

.t-dsc-see {
    padding: 0.2em 0 0.2em 0;
}

.t-dsc-see &gt; span:nth-child(2) &gt; span,
.t-dsc-see &gt; span:nth-child(1) {
    font-weight: bold;
}

.t-dsc-see-tt &gt; span {
   font-family: DejaVuSansMono, &quot;DejaVu Sans Mono&quot;, courier, monospace;
}

/* ----------------------------------------------------------------------
   .dsctable
*/

.dsctable td ul,
.dsctable td ol,
.dsctable td dl {
    text-align: left;
}

.dsctable {
    max-width: 60em;
    border-spacing: 0;
}

.dsctable &gt; tbody &gt; tr &gt; td {
    border-top: 1px solid silver;
    width: 0%;
    line-height: 1.2em;
    padding: 0.2em 0.1em 0.25em 0.75em;
    white-space: nowrap;
}

.dsctable &gt; tbody &gt; tr:last-child &gt; td {
    border-bottom: 1px solid silver;
}

.dsctable &gt; tbody &gt; tr &gt; th {
    font-weight: bold;
    line-height: 1.1em;
    padding: 0.2em 0 0.25em 0.75em;
    white-space: nowrap;
}

/* ----------------------------------------------------------------------
   Template:dcl *
*/
.t-dcl-begin {
    display: block;
    padding: 0.5em 0;
    border-spacing: 0;
}

.t-dcl-header &gt; td:nth-child(1) &gt; div {
    margin-left: 2em;
    font-size: 0.8em;
}

.t-dcl-h &gt; td:nth-child(1) &gt; div {
    margin-left: 2em;
    padding-top: 0.7em;
    font-size: 0.8em;
    font-weight: bold;
}

.t-dcl &gt; td:nth-child(1) {
    padding: 0.3em 2em 0.2em 1em;
    font-size: 1.0em;
}

.t-dcl &gt; td:nth-child(1) &gt; div p,
.t-dcl &gt; td:nth-child(1) &gt; div span {
    line-height: 1.1em;
    margin: 0;
    padding: 0;
}

.t-dcl &gt; td:nth-child(2),
.t-dcl-rev-aux &gt; td:nth-child(2) {
    font-size: 0.8em;
    padding-right: 1.5em;
}

.t-dcl &gt; td:nth-child(3),
.t-dcl-rev-aux &gt; td:nth-child(3) {
    padding: 0;
}

.t-dcl-nopad {
    padding-right: 0 !important;
}

/* Apply the dark border */
.t-dcl &gt; td,
.t-dcl-h &gt; td,
.t-dcl-sep &gt; td,
.t-dcl-rev &gt; .t-dcl:first-child &gt; td, /* if dcl-rev-aux is hidden */
.t-dcl-rev &gt; .t-dcl-rev-aux &gt; td {
    border-top: 1px solid #cccccc;
}

.t-dcl-sep &gt; td {
    padding: 0;
}

/* Apply the light border to the dcl-rev elements */
.t-dcl-rev &gt; .t-dcl &gt; td,
.t-dcl-rev &gt; .t-dcl-h &gt; td {
    border-top: 1px solid #e8e8e8;
}

/* Do not apply any border to the first element in dcl-rev block */
.t-dcl-rev-aux + .t-dcl td {
    border-top: none;
}

/* Reduce padding. Preserve padding for the first and the last visible
   code elements */
.t-dcl-rev-aux ~ .t-dcl ~ .t-dcl td {
    /* Here we abuse CSS a bit to ensure that at least one block has
       his top padding left untouched */
    padding-top: 0;
}

.t-dcl-rev .t-dcl:not(:nth-last-child(1)) td {
    padding-bottom: 0;
}

.t-dcl-rev-aux &gt; td:nth-child(1),
.t-dcl-rev-aux &gt; td:nth-child(3) {
    padding: 0;
}

/* Override columns overridden by data in dcl-rev entry */
.t-dcl-rev-num &gt; .t-dcl-rev-aux ~ tr:not(.t-dcl-rev-aux) &gt; td:nth-child(2) {
    display: none;
}

.t-dcl-rev-notes &gt; .t-dcl-rev-aux ~ tr:not(.t-dcl-rev-aux) &gt; td:nth-child(3) {
    display: none;
}

/* ----------------------------------------------------------------------
   Template:sdsc *
*/
.t-sdsc-begin {
}

.t-sdsc &gt; td:first-child {
    padding: 0.5em 0 0.5em 1em;
    font-size: 1em;
}

.t-sdsc dd,
.t-sdsc p,
.t-sdsc span {
    line-height: 1.1em;
}

.t-sdsc &gt; td:nth-last-child(2) {
    padding-left: 3em;
}

.t-sdsc &gt; td:nth-last-child(1) {
    padding-left: 2em;
}

.t-sdsc-nopad {
    padding-left: 0 !important;
}

.t-sdsc-sep {
    border-top: 1px solid #CCCCCC;
    padding: 0;
}


/* ----------------------------------------------------------------------
   Template:nv *
*/
.t-nv-begin {
    line-height: 1em;
    width: auto;
    border-spacing: 0;
}

.t-nv-h1 &gt; td {
    padding: 0.2em 0 0.2em 1.4em;
    font-size: 1.25em;
    font-weight: bold;
}

.t-nv-h2 &gt; td {
    padding: 0.2em 0 0.2em 1em;
    font-weight: bold;
}

.t-nv-ln-table {
    vertical-align: middle;
    display: table;
    padding: 0;
    border-spacing: 0;
}

.t-nv-ln-table &gt; div {
    display: table-cell;
}

.t-nv-ln-table &gt; div:nth-child(1) {
    font-family: DejaVuSansMonoCondensed75, &quot;DejaVu Sans Mono&quot;, courier, monospace;
    padding: 0;
}

.t-nv-ln-table &gt; div:nth-child(2) {
    padding: 0 0 0 0.2em;
}

/* ----------------------------------------------------------------------
   Template:par *
*/
.t-par-begin {
    border-spacing: 0;
}

.t-par &gt; td {
    padding: 0.5em 1em 0 0;
    vertical-align: top;
}

.t-par &gt; td:nth-child(1) {
    white-space: nowrap;
    text-align: right;
    font-weight: bold;
    font-family: DejaVuSansMono, &quot;DejaVu Sans Mono&quot;, courier, monospace;
}

.t-par &gt; td:nth-child(3) {
    width: 100%;
}

.t-par-hitem &gt; td {
    font-weight: bold;
    padding: 0.8em 0 0.3em 1em;
}

.t-par-req {
    padding: 0.5em 1em 0 0;
}

.t-par-req .spacer {
    display: inline-block;
    width: 1.2em;
}

.t-par .editsection {
    display: none;
    font-size: 0.7em;
    opacity: 0.4;
}

/* ----------------------------------------------------------------------
   Template:rev *
*/
.t-rev-begin {
    border-spacing: 0;
    border-collapse: collapse;
}

.t-rev &gt; td {
    padding: 0.3em 0.2em;
}

.t-rev-begin-noborder .t-rev &gt; td {
    padding: 0;
    border: none !important;
}

.t-rev-begin-noborder .t-rev &gt; td:first-child {
    padding-right: 0.2em;
}

.t-dsc .t-rev-begin {
    display: inline-table;
}

.t-rev &gt; td:nth-child(1) {
    border: 1px solid silver;
    border-right: none;
}

.t-rev &gt; td:nth-child(2) {
    border: 1px solid silver;
    border-left: none;
    white-space: nowrap
}

.t-rev &gt; td &gt; p:first-child {
    margin-top: 0em;
}

.t-rev &gt; td &gt; p:last-child {
    margin-bottom: 0em;
}

div#content .t-rev &gt; td:first-child &gt; ul:last-child {
    margin-bottom: 0em;
}

div#content .t-rev &gt; td:first-child &gt; ul:first-child {
    margin-top: 0em;
}

.t-rev &gt; td:first-child &gt; ul:first-child &gt; li:first-child {
    margin-top: 0em;
}

.t-rev-inl,
.t-rev-inl &gt; span {
    margin: 0;
    padding: 0;
}

.t-rev-inl {
    border: 1px solid silver;
}

.t-rev-inl.t-rev-inl-noborder {
    border: none;
}

/* ----------------------------------------------------------------------
   Template:member*
*/
.t-dsc-member-div &gt; div {
    padding: 0;
    display: inline-table;
    vertical-align: middle;
}

.t-dsc-member-div &gt; div:nth-child(1) {
    font-weight: bold;
    font-family: DejaVuSansMono, &quot;DejaVu Sans Mono&quot;, courier, monospace;
}

.t-dsc-member-div &gt; div:nth-child(2) {
    padding-left: 0.2em;
}

.t-dsc-member-nobold-div &gt; div:nth-child(1),
.t-dsc-member-nobold-div &gt; div:nth-child(1) strong.selflink {
    font-weight: normal;
    font-family: DejaVuSans, &quot;DejaVu Sans&quot;, arial, sans-serif;
}

/* ----------------------------------------------------------------------
   Template:tr
*/

.t-tr-text {
    display: inline;
}

.t-tr-text:hover {
    background: #eef;
    transition: background 0.2s ease-in-out 1s;
    -webkit-transition: background 0.2s ease-in-out 1s;
    -moz-transition: background 0.2s ease-in-out 1s;
    -o-transition: background 0.2s ease-in-out 1s;
}

.t-tr-dropdown {
    display: inline-block;
    line-height: 1em;
    visibility: collapse;
    width: 0;
    height: 0;
    position: relative
}

.t-tr-text:hover &gt; .t-tr-dropdown {
    visibility: visible;
    transition: visibility 0 linear 1s;
    -webkit-transition: visibility 0 linear 1s;
    -moz-transition: visibility 0 linear 1s;
    -o-transition: visibility 0 linear 1s;
}

.t-tr-dropdown &gt; div {
    opacity: 0;
    transition: opacity 0.1s linear 0s;
    -moz-transition: opacity 0.1s linear 0s;
    -webkit-transition: opacity 0.1s linear 0s;
    -o-transition: opacity 0.1s linear 0s;

    top: 0;
    left: -110px;
    position: absolute;
    padding-top: 12px;
}

.t-tr-text:hover &gt; .t-tr-dropdown &gt; div {
    opacity: 1;
    transition: opacity 0.2s ease-in-out 1s;
    -webkit-transition: opacity 0.2s ease-in-out 1s;
    -moz-transition: opacity 0.2s ease-in-out 1s;
    -o-transition: opacity 0.2s ease-in-out 1s;
}

.t-tr-dropdown &gt; div &gt; div {
    background-color: white;
    border: 1.5px solid silver;
    font-size: 0.9em;
    padding: 5px;
    width: 400px;
    border-radius: 5px;
    box-shadow: 0 0 3px #888888;
}

.t-tr-dropdown-arrow-border {
    border-color: transparent transparent silver transparent ;
    border-style: solid;
    border-width: 8px;
    height:0;
    width:0;
    position:absolute;
    top:-3px;
    left:100px;
}

.t-tr-dropdown-arrow {
    border-color: transparent transparent white transparent;
    border-style: solid;
    border-width: 8px;
    height:0;
    width:0;
    position:absolute;
    top:-2px;
    left:100px;
}

.t-tr-dropdown-h {
    padding-left: 1em;
    padding-bottom: 0.5em;
    font-size: 0.8em;
}

.t-tr-dropdown-notes {
    padding-left: 1em;
    padding-top: 0.5em;
    font-size: 0.8em;
}

/* ======================================================================
   WIKIPEDIA DEFAULTS
 ------------------------------------------------------------------------
*/


/* Footer and header message box styles */
table.fmbox {
    clear: both;
    margin: 0.2em 0;
    width: 100%;
    border: 1px solid #aaa;
    background: #f9f9f9;     /* Default &quot;system&quot; gray */
}
table.fmbox-system {
    background: #f9f9f9;
}
table.fmbox-warning {
    border: 1px solid #bb7070;  /* Dark pink */
    background: #ffdbdb;        /* Pink */
}
table.fmbox-editnotice {
    background: transparent;
}


/* Cell sizes for ambox/tmbox/imbox/cmbox/ombox/fmbox/dmbox message boxes */
th.mbox-text, td.mbox-text {   /* The message body cell(s) */
    border: none;
    padding: 0.25em 0.9em;     /* 0.9em left/right */
    width: 100%;               /* Make all mboxes the same width regardless of text length */
}
td.mbox-image {                /* The left image cell */
    border: none;
    padding: 2px 0 2px 0.9em;  /* 0.9em left, 0px right */
    text-align: center;
}
td.mbox-imageright {           /* The right image cell */
    border: none;
    padding: 2px 0.9em 2px 0;  /* 0px left, 0.9em right */
    text-align: center;
}
td.mbox-empty-cell {           /* An empty narrow cell */
    border: none;
    padding: 0px;
    width: 1px;
}

/* ======================================================================
   DEFAULTS
 ------------------------------------------------------------------------
*/
/* CSS placed here will be applied to all skins */

/* Main page fixes */
#interwiki-completelist {
    font-weight: bold;
}
body.page-Main_Page #ca-delete {
    display: none !important;
}

body.page-Main_Page #mp-topbanner {
   clear: both;
}

/* Edit window toolbar */
#toolbar {
    height: 22px;
    margin-bottom: 6px;
}

/* Margins for &lt;ol&gt; and &lt;ul&gt; */
div#content ol, div#content ul,
div#mw_content ol, div#mw_content ul {
    margin-bottom: 0.5em;
}

/* Make the list of references smaller */
ol.references,
div.reflist,
div.refbegin {
    font-size: 90%;            /* Default font-size */
}
div.reflist ol.references {
    font-size: 100%;           /* Reset font-size when nested in div.reflist */
    list-style-type: inherit;  /* Enable custom list style types */
}

/* Highlight clicked reference in blue to help navigation */
ol.references li:target,
sup.reference:target,
span.citation:target {
    background-color: #DEF;
}

/* Ensure refs in table headers and the like aren't bold or italic */
sup.reference {
    font-weight: normal;
    font-style: normal;
}

/* Styling for citations */
span.citation, cite {
    font-style: normal;
    word-wrap: break-word;
}

/* For linked citation numbers and document IDs, where
   the number need not be shown on a screen or a handheld,
   but should be included in the printed version
*/
@media screen, handheld {
    span.citation *.printonly {
        display: none;
    }
}

.collapseButton {          /* 'show'/'hide' buttons created dynamically */
    float: right;          /* by the CollapsibleTables javascript in    */
    font-weight: normal;   /* [[MediaWiki:Common.js]] are styled here   */
    text-align: right;     /* so they can be customised.                */
    width: auto;
}

/* Normal font styling for table row headers with scope=&quot;row&quot; tag */
.wikitable.plainrowheaders th[scope=row] {
    font-weight: normal;
    text-align: left;
}

/* lists in data cells are always left-aligned */
.wikitable td ul,
.wikitable td ol,
.wikitable td dl {
    text-align: left;
}

/* Change the external link icon to an Adobe icon for all PDF files
   in browsers that support these CSS selectors, like Mozilla and Opera */
div#content a[href$=&quot;.pdf&quot;].external,
div#content a[href*=&quot;.pdf?&quot;].external,
div#content a[href*=&quot;.pdf#&quot;].external,
div#content a[href$=&quot;.PDF&quot;].external,
div#content a[href*=&quot;.PDF?&quot;].external,
div#content a[href*=&quot;.PDF#&quot;].external,
div#mw_content a[href$=&quot;.pdf&quot;].external,
div#mw_content a[href*=&quot;.pdf?&quot;].external,
div#mw_content a[href*=&quot;.pdf#&quot;].external,
div#mw_content a[href$=&quot;.PDF&quot;].external,
div#mw_content a[href*=&quot;.PDF?&quot;].external,
div#mw_content a[href*=&quot;.PDF#&quot;].external {
    /* @embed */
    background: url(&quot;http://upload.cppreference.com/mwiki/images/2/23/Icons-mini-file_acrobat.gif&quot;) center right no-repeat;
    padding-right: 18px;
}

/* Messagebox templates */
.messagebox {
    border: 1px solid #aaa;
    background-color: #f9f9f9;
    width: 80%;
    margin: 0 auto 1em auto;
    padding: .2em;
}
.messagebox.merge {
    border: 1px solid #c0b8cc;
    background-color: #f0e5ff;
    text-align: center;
}
.messagebox.cleanup {
    border: 1px solid #9f9fff;
    background-color: #efefff;
    text-align: center;
}
.messagebox.standard-talk {
    border: 1px solid #c0c090;
    background-color: #f8eaba;
    margin: 4px auto;
}
/* For old WikiProject banners inside banner shells. */
.mbox-inside .standard-talk,
.messagebox.nested-talk {
    border: 1px solid #c0c090;
    background-color: #f8eaba;
    width: 100%;
    margin: 2px 0;
    padding: 2px;
}
.messagebox.small {
    width: 238px;
    font-size: 85%;
    float: right;
    clear: both;
    margin: 0 0 1em 1em;
    line-height: 1.25em;
}
.messagebox.small-talk {
    width: 238px;
    font-size: 85%;
    float: right;
    clear: both;
    margin: 0 0 1em 1em;
    line-height: 1.25em;
    background: #F8EABA;
}

/* Cell sizes for ambox/tmbox/imbox/cmbox/ombox/fmbox/dmbox message boxes */
th.mbox-text, td.mbox-text {   /* The message body cell(s) */
    border: none;
    padding: 0.25em 0.9em;     /* 0.9em left/right */
    width: 100%;               /* Make all mboxes the same width regardless of text length */
}
td.mbox-image {                /* The left image cell */
    border: none;
    padding: 2px 0 2px 0.9em;  /* 0.9em left, 0px right */
    text-align: center;
}
td.mbox-imageright {           /* The right image cell */
    border: none;
    padding: 2px 0.9em 2px 0;  /* 0px left, 0.9em right */
    text-align: center;
}
td.mbox-empty-cell {           /* An empty narrow cell */
    border: none;
    padding: 0px;
    width: 1px;
}

/* Article message box styles */
table.ambox {
    margin: 0px 10%;                  /* 10% = Will not overlap with other elements */
    border: 1px solid #aaa;
    border-left: 10px solid #1e90ff;  /* Default &quot;notice&quot; blue */
    background: #fbfbfb;
}
table.ambox + table.ambox {      /* Single border between stacked boxes. */
    margin-top: -1px;
}
.ambox th.mbox-text,
.ambox td.mbox-text {            /* The message body cell(s) */
    padding: 0.25em 0.5em;       /* 0.5em left/right */
}
.ambox td.mbox-image {           /* The left image cell */
    padding: 2px 0 2px 0.5em;    /* 0.5em left, 0px right */
}
.ambox td.mbox-imageright {      /* The right image cell */
    padding: 2px 0.5em 2px 0;    /* 0px left, 0.5em right */
}

table.ambox-notice {
    border-left: 10px solid #1e90ff;    /* Blue */
}
table.ambox-speedy {
    border-left: 10px solid #b22222;    /* Red */
    background: #fee;                   /* Pink */
}
table.ambox-delete {
    border-left: 10px solid #b22222;    /* Red */
}
table.ambox-content {
    border-left: 10px solid #f28500;    /* Orange */
}
table.ambox-style {
    border-left: 10px solid #f4c430;    /* Yellow */
}
table.ambox-move {
    border-left: 10px solid #9932cc;    /* Purple */
}
table.ambox-protection {
    border-left: 10px solid #bba;       /* Gray-gold */
}

/* Image message box styles */
table.imbox {
    margin: 4px 10%;
    border-collapse: collapse;
    border: 3px solid #1e90ff;    /* Default &quot;notice&quot; blue */
    background: #fbfbfb;
}
.imbox .mbox-text .imbox {  /* For imboxes inside imbox-text cells. */
    margin: 0 -0.5em;       /* 0.9 - 0.5 = 0.4em left/right.        */
    display: block;         /* Fix for webkit to force 100% width.  */
}
.mbox-inside .imbox {       /* For imboxes inside other templates.  */
    margin: 4px;
}

table.imbox-notice {
    border: 3px solid #1e90ff;    /* Blue */
}
table.imbox-speedy {
    border: 3px solid #b22222;    /* Red */
    background: #fee;             /* Pink */
}
table.imbox-delete {
    border: 3px solid #b22222;    /* Red */
}
table.imbox-content {
    border: 3px solid #f28500;    /* Orange */
}
table.imbox-style {
    border: 3px solid #f4c430;    /* Yellow */
}
table.imbox-move {
    border: 3px solid #9932cc;    /* Purple */
}
table.imbox-protection {
    border: 3px solid #bba;       /* Gray-gold */
}
table.imbox-license {
    border: 3px solid #88a;       /* Dark gray */
    background: #f7f8ff;          /* Light gray */
}
table.imbox-featured {
    border: 3px solid #cba135;    /* Brown-gold */
}

/* Category message box styles */
table.cmbox {
    margin: 3px 10%;
    border-collapse: collapse;
    border: 1px solid #aaa;
    background: #DFE8FF;    /* Default &quot;notice&quot; blue */
}

table.cmbox-notice {
    background: #D8E8FF;    /* Blue */
}
table.cmbox-speedy {
    margin-top: 4px;
    margin-bottom: 4px;
    border: 4px solid #b22222;    /* Red */
    background: #FFDBDB;          /* Pink */
}
table.cmbox-delete {
    background: #FFDBDB;    /* Red */
}
table.cmbox-content {
    background: #FFE7CE;    /* Orange */
}
table.cmbox-style {
    background: #FFF9DB;    /* Yellow */
}
table.cmbox-move {
    background: #E4D8FF;    /* Purple */
}
table.cmbox-protection {
    background: #EFEFE1;    /* Gray-gold */
}

/* Other pages message box styles */
table.ombox {
    margin: 4px 10%;
    border-collapse: collapse;
    border: 1px solid #aaa;       /* Default &quot;notice&quot; gray */
    background: #f9f9f9;
}

table.ombox-notice {
    border: 1px solid #aaa;       /* Gray */
}
table.ombox-speedy {
    border: 2px solid #b22222;    /* Red */
    background: #fee;             /* Pink */
}
table.ombox-delete {
    border: 2px solid #b22222;    /* Red */
}
table.ombox-content {
    border: 1px solid #f28500;    /* Orange */
}
table.ombox-style {
    border: 1px solid #f4c430;    /* Yellow */
}
table.ombox-move {
    border: 1px solid #9932cc;    /* Purple */
}
table.ombox-protection {
    border: 2px solid #bba;       /* Gray-gold */
}

/* Talk page message box styles */
table.tmbox {
    margin: 4px 10%;
    border-collapse: collapse;
    border: 1px solid #c0c090;    /* Default &quot;notice&quot; gray-brown */
    background: #f8eaba;
}
.mediawiki .mbox-inside .tmbox { /* For tmboxes inside other templates. The &quot;mediawiki&quot; class ensures that */
    margin: 2px 0;               /* this declaration overrides other styles (including mbox-small above)   */
    width: 100%;                 /* For Safari and Opera */
}
.mbox-inside .tmbox.mbox-small { /* &quot;small&quot; tmboxes should not be small when  */
    line-height: 1.5em;          /* also &quot;nested&quot;, so reset styles that are   */
    font-size: 100%;             /* set in &quot;mbox-small&quot; above.                */
}

table.tmbox-speedy {
    border: 2px solid #b22222;    /* Red */
    background: #fee;             /* Pink */
}
table.tmbox-delete {
    border: 2px solid #b22222;    /* Red */
}
table.tmbox-content {
    border: 2px solid #f28500;    /* Orange */
}
table.tmbox-style {
    border: 2px solid #f4c430;    /* Yellow */
}
table.tmbox-move {
    border: 2px solid #9932cc;    /* Purple */
}
table.tmbox-protection,
table.tmbox-notice {
    border: 1px solid #c0c090;    /* Gray-brown */
}


/* Footer and header message box styles */
table.fmbox {
    clear: both;
    margin: 0.2em 0;
    width: 100%;
    border: 1px solid #aaa;
    background: #f9f9f9;     /* Default &quot;system&quot; gray */
}
table.fmbox-system {
    background: #f9f9f9;
}
table.fmbox-warning {
    border: 1px solid #bb7070;  /* Dark pink */
    background: #ffdbdb;        /* Pink */
}
table.fmbox-editnotice {
    background: transparent;
}

/* Div based &quot;warning&quot; style fmbox messages. */
div.mw-warning-with-logexcerpt,
div.mw-lag-warn-high,
div.mw-cascadeprotectedwarning,
div#mw-protect-cascadeon {
    clear: both;
    margin: 0.2em 0;
    border: 1px solid #bb7070;
    background: #ffdbdb;
    padding: 0.25em 0.9em;
}

/* These mbox-small classes must be placed after all other
   ambox/tmbox/ombox etc classes. &quot;body.mediawiki&quot; is so
   they override &quot;table.ambox + table.ambox&quot; above. */
body.mediawiki table.mbox-small {   /* For the &quot;small=yes&quot; option. */
    clear: right;
    float: right;
    margin: 4px 0 4px 1em;
    width: 238px;
    font-size: 88%;
    line-height: 1.25em;
}
body.mediawiki table.mbox-small-left {   /* For the &quot;small=left&quot; option. */
    margin: 4px 1em 4px 0;
    width: 238px;
    border-collapse: collapse;
    font-size: 88%;
    line-height: 1.25em;
}


/* Remove default styles for [[MediaWiki:Noarticletext]]. */
div.noarticletext {
    border: none;
    background: transparent;
    padding: 0;
}

#wpSave {
    font-weight: bold;
}

/* suppress missing interwiki image links where #ifexist cannot
   be used due to high number of requests see .hidden-redlink on
   http://meta.wikimedia.org/wiki/MediaWiki:Common.css
*/
.check-icon a.new {
    display: none;
    speak: none;
}

/* Removes underlines from certain links */
.nounderlines a,
.IPA a:link, .IPA a:visited {
    text-decoration: none;
}

/* Allow transcluded pages to display in lists rather than a table. */
.listify td    { display: list-item; }
.listify tr    { display: block; }
.listify table { display: block; }

/* When &lt;div class=&quot;nonumtoc&quot;&gt; is used on the table of contents,
   the ToC will display without numbers */
.nonumtoc .tocnumber { display: none; }
.nonumtoc #toc ul,
.nonumtoc .toc ul {
    line-height: 1.5em;
    list-style: none;
    margin: .3em 0 0;
    padding: 0;
}
.nonumtoc #toc ul ul,
.nonumtoc .toc ul ul {
    margin: 0 0 0 2em;
}

/* User block messages */
div.user-block {
    padding: 5px;
    margin-bottom: 0.5em;
    border: 1px solid #A9A9A9;
    background-color: #FFEFD5;
}

/* Prevent line breaks in silly places:
   1) Links when we don't want them to
   2) Bold &quot;links&quot; to the page itself
   2) HTML formulae
   3) Ref tags with group names &lt;ref group=&quot;Note&quot;&gt; --&gt; &quot;[Note 1]&quot;
*/
.nowraplinks a,
.nowraplinks .selflink,
span.texhtml,
sup.reference a {
    white-space: nowrap;
}

/* For template documentation */
.template-documentation {
    clear: both;
    margin: 1em 0 0 0;
    border: 1px solid #aaa;
    background-color: #ecfcf4;
    padding: 1em;
}

/* Inline divs in ImageMaps (code borrowed from de.wiki) */
.imagemap-inline div {
    display: inline;
}

/* Increase the height of the image upload box */
#wpUploadDescription {
    height: 13em;
}

/* Reduce line-height for &lt;sup&gt; and &lt;sub&gt; */
sup, sub {
    line-height: 1em;
}

/* Minimum thumb width */
.thumbinner {
    min-width: 100px;
}

/* Makes the background of a framed image white instead of gray. */
/* Only visible with transparent images. */
div.thumb img.thumbimage {
    background-color: #fff;
}

/* The backgrounds for galleries. */
div#content .gallerybox div.thumb {
    background-color: #F9F9F9;   /* Light gray padding */
}
/* Put a chequered background behind images, only visible if they have transparency */
.gallerybox .thumb img,
.filehistory a img,
#file img {
    background: white url(&quot;http://upload.wikimedia.org/wikipedia/commons/5/5d/Checker-16x16.png&quot;) repeat;
}
/* But not on articles, user pages, portals or with opt-out. */
.ns-0 .gallerybox .thumb img,
.ns-2 .gallerybox .thumb img,
.ns-100 .gallerybox .thumb img,
.nochecker .gallerybox .thumb img {
    background: white;
}

/* Prevent floating boxes from overlapping any category listings,
   file histories, edit previews, and edit [Show changes] views */
#mw-subcategories, #mw-pages, #mw-category-media,
#filehistory, #wikiPreview, #wikiDiff {
    clear: both;
}

/* Fix monospace fontsize in new edit toolbar (jquery.wikiEditor.toolbar.css).
   [[Bugzilla:27502]] */
.wikiEditor-ui-toolbar .section-help .page-table td.cell-syntax,
.wikiEditor-ui-toolbar .section-help .page-table td.syntax {
    font-family: monospace, &quot;Courier New&quot;;
}


/* Remove bullets when there are multiple edit page warnings */
ul.permissions-errors &gt; li {
    list-style: none;
}
ul.permissions-errors {
    margin: 0;
}

/* No linewrap on the labels of the login/signup page */
body.page-Special_UserLogin .mw-label label,
body.page-Special_UserLogin_signup .mw-label label { white-space : nowrap; }

/* Disable the automatic text-size adjust of WebKit on iPhones etc.
   It scales some text, and not the other. Use none, or fixed percentage instead.
   Use media selector, because defining a value, overwrites platform defaults. */
@media only screen and (max-device-width: 480px) {
    body {
        -webkit-text-size-adjust: none;
    }
}

/* ======================================================================
   OVERRIDES
 ------------------------------------------------------------------------
*/

body.mediawiki table.mbox-small-left,
body.mediawiki table.mbox-small {
    width: 500px;
}

/* ======================================================================
   TEMPORARY
 ------------------------------------------------------------------------
*/
.t-rev-since-cxx11 .t-noexcept-inline .t-mark {
    display: none;
}</text>
      <sha1>3tmdbkedvtuzxjs69miyxtxes1ziyju</sha1>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Common.js</title>
    <ns>8</ns>
    <id>1791</id>
    <revision>
      <id>65192</id>
      <parentid>65191</parentid>
      <timestamp>2013-09-04T22:46:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="74">/* Any JavaScript here will be loaded for all users on every page load. */</text>
      <sha1>e1xzexxv70r7jxzgtgpjqqrfytiz555</sha1>
      <model>javascript</model>
      <format>text/javascript</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Cpp-search-list-c</title>
    <ns>8</ns>
    <id>8907</id>
    <revision>
      <id>71782</id>
      <parentid>47016</parentid>
      <timestamp>2014-06-24T01:45:17Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/FE_UNHERFLOW/FE_UNDERFLOW</comment>
      <text xml:space="preserve" bytes="29682">size_t =&gt; cpp/types/size_t
ptrdiff_t =&gt; cpp/types/ptrdiff_t
nullptr_t =&gt; cpp/types/nullptr_t
NULL =&gt; cpp/types/NULL
max_align_t =&gt; cpp/types/max_align_t
offsetof =&gt; cpp/types/offsetof
int8_t =&gt; c/types/integer
int16_t =&gt; c/types/integer
int32_t =&gt; c/types/integer
int64_t =&gt; c/types/integer
int_fast8_t =&gt; c/types/integer
int_fast16_t =&gt; c/types/integer
int_fast32_t =&gt; c/types/integer
int_fast64_t =&gt; c/types/integer
int_least8_t =&gt; c/types/integer
int_least16_t =&gt; c/types/integer
int_least32_t =&gt; c/types/integer
int_least64_t =&gt; c/types/integer
intmax_t =&gt; c/types/integer
intptr_t =&gt; c/types/integer
uint8_t =&gt; c/types/integer
uint16_t =&gt; c/types/integer
uint32_t =&gt; c/types/integer
uint64_t =&gt; c/types/integer
uint_fast8_t =&gt; c/types/integer
uint_fast16_t =&gt; c/types/integer
uint_fast32_t =&gt; c/types/integer
uint_fast64_t =&gt; c/types/integer
uint_least8_t =&gt; c/types/integer
uint_least16_t =&gt; c/types/integer
uint_least32_t =&gt; c/types/integer
uint_least64_t =&gt; c/types/integer
uintmax_t =&gt; c/types/integer
uintptr_t =&gt; c/types/integer
INT8_MIN =&gt; c/types/integer
INT16_MIN =&gt; c/types/integer
INT32_MIN =&gt; c/types/integer
INT64_MIN =&gt; c/types/integer
INT_FAST8_MIN =&gt; c/types/integer
INT_FAST16_MIN =&gt; c/types/integer
INT_FAST32_MIN =&gt; c/types/integer
INT_FAST64_MIN =&gt; c/types/integer
INT_LEAST8_MIN =&gt; c/types/integer
INT_LEAST16_MIN =&gt; c/types/integer
INT_LEAST32_MIN =&gt; c/types/integer
INT_LEAST64_MIN =&gt; c/types/integer
INTPTR_MIN =&gt; c/types/integer
INTMAX_MIN =&gt; c/types/integer
INT8_MAX =&gt; c/types/integer
INT16_MAX =&gt; c/types/integer
INT32_MAX =&gt; c/types/integer
INT64_MAX =&gt; c/types/integer
INT_FAST8_MAX =&gt; c/types/integer
INT_FAST16_MAX =&gt; c/types/integer
INT_FAST32_MAX =&gt; c/types/integer
INT_FAST64_MAX =&gt; c/types/integer
INT_LEAST8_MAX =&gt; c/types/integer
INT_LEAST16_MAX =&gt; c/types/integer
INT_LEAST32_MAX =&gt; c/types/integer
INT_LEAST64_MAX =&gt; c/types/integer
INTPTR_MAX =&gt; c/types/integer
INTMAX_MAX =&gt; c/types/integer
UINT8_MAX =&gt; c/types/integer
UINT16_MAX =&gt; c/types/integer
UINT32_MAX =&gt; c/types/integer
UINT64_MAX =&gt; c/types/integer
UINT_FAST8_MAX =&gt; c/types/integer
UINT_FAST16_MAX =&gt; c/types/integer
UINT_FAST32_MAX =&gt; c/types/integer
UINT_FAST64_MAX =&gt; c/types/integer
UINT_LEAST8_MAX =&gt; c/types/integer
UINT_LEAST16_MAX =&gt; c/types/integer
UINT_LEAST32_MAX =&gt; c/types/integer
UINT_LEAST64_MAX =&gt; c/types/integer
UINTPTR_MAX =&gt; c/types/integer
UINTMAX_MAX =&gt; c/types/integer
PRId8 =&gt; c/types/integer
PRId16 =&gt; c/types/integer
PRId32 =&gt; c/types/integer
PRId64 =&gt; c/types/integer
PRIdLEAST8 =&gt; c/types/integer
PRIdLEAST16 =&gt; c/types/integer
PRIdLEAST32 =&gt; c/types/integer
PRIdLEAST64 =&gt; c/types/integer
PRIdFAST8 =&gt; c/types/integer
PRIdFAST16 =&gt; c/types/integer
PRIdFAST32 =&gt; c/types/integer
PRIdFAST64 =&gt; c/types/integer
PRIdMAX =&gt; c/types/integer
PRIdPTR  =&gt; c/types/integer
PRIi8 =&gt; c/types/integer
PRIi16 =&gt; c/types/integer
PRIi32 =&gt; c/types/integer
PRIi64 =&gt; c/types/integer
PRIiLEAST8 =&gt; c/types/integer
PRIiLEAST16 =&gt; c/types/integer
PRIiLEAST32 =&gt; c/types/integer
PRIiLEAST64 =&gt; c/types/integer
PRIiFAST8 =&gt; c/types/integer
PRIiFAST16 =&gt; c/types/integer
PRIiFAST32 =&gt; c/types/integer
PRIiFAST64 =&gt; c/types/integer
PRIiMAX =&gt; c/types/integer
PRIiPTR  =&gt; c/types/integer
PRIu8 =&gt; c/types/integer
PRIu16 =&gt; c/types/integer
PRIu32 =&gt; c/types/integer
PRIu64 =&gt; c/types/integer
PRIuLEAST8 =&gt; c/types/integer
PRIuLEAST16 =&gt; c/types/integer
PRIuLEAST32 =&gt; c/types/integer
PRIuLEAST64 =&gt; c/types/integer
PRIuFAST8 =&gt; c/types/integer
PRIuFAST16 =&gt; c/types/integer
PRIuFAST32 =&gt; c/types/integer
PRIuFAST64 =&gt; c/types/integer
PRIuMAX =&gt; c/types/integer
PRIuPTR  =&gt; c/types/integer
PRIo8 =&gt; c/types/integer
PRIo16 =&gt; c/types/integer
PRIo32 =&gt; c/types/integer
PRIo64 =&gt; c/types/integer
PRIoLEAST8 =&gt; c/types/integer
PRIoLEAST16 =&gt; c/types/integer
PRIoLEAST32 =&gt; c/types/integer
PRIoLEAST64 =&gt; c/types/integer
PRIoFAST8 =&gt; c/types/integer
PRIoFAST16 =&gt; c/types/integer
PRIoFAST32 =&gt; c/types/integer
PRIoFAST64 =&gt; c/types/integer
PRIoMAX =&gt; c/types/integer
PRIoPTR  =&gt; c/types/integer
PRIx8 =&gt; c/types/integer
PRIx16 =&gt; c/types/integer
PRIx32 =&gt; c/types/integer
PRIx64 =&gt; c/types/integer
PRIxLEAST8 =&gt; c/types/integer
PRIxLEAST16 =&gt; c/types/integer
PRIxLEAST32 =&gt; c/types/integer
PRIxLEAST64 =&gt; c/types/integer
PRIxFAST8 =&gt; c/types/integer
PRIxFAST16 =&gt; c/types/integer
PRIxFAST32 =&gt; c/types/integer
PRIxFAST64 =&gt; c/types/integer
PRIxMAX =&gt; c/types/integer
PRIxPTR  =&gt; c/types/integer
PRIX8 =&gt; c/types/integer
PRIX16 =&gt; c/types/integer
PRIX32 =&gt; c/types/integer
PRIX64 =&gt; c/types/integer
PRIXLEAST8 =&gt; c/types/integer
PRIXLEAST16 =&gt; c/types/integer
PRIXLEAST32 =&gt; c/types/integer
PRIXLEAST64 =&gt; c/types/integer
PRIXFAST8 =&gt; c/types/integer
PRIXFAST16 =&gt; c/types/integer
PRIXFAST32 =&gt; c/types/integer
PRIXFAST64 =&gt; c/types/integer
PRIXMAX =&gt; c/types/integer
PRIXPTR  =&gt; c/types/integer
SCNd8 =&gt; c/types/integer
SCNd16 =&gt; c/types/integer
SCNd32 =&gt; c/types/integer
SCNd64 =&gt; c/types/integer
SCNdLEAST8 =&gt; c/types/integer
SCNdLEAST16 =&gt; c/types/integer
SCNdLEAST32 =&gt; c/types/integer
SCNdLEAST64 =&gt; c/types/integer
SCNdFAST8 =&gt; c/types/integer
SCNdFAST16 =&gt; c/types/integer
SCNdFAST32 =&gt; c/types/integer
SCNdFAST64 =&gt; c/types/integer
SCNdMAX =&gt; c/types/integer
SCNdPTR  =&gt; c/types/integer
SCNi8 =&gt; c/types/integer
SCNi16 =&gt; c/types/integer
SCNi32 =&gt; c/types/integer
SCNi64 =&gt; c/types/integer
SCNiLEAST8 =&gt; c/types/integer
SCNiLEAST16 =&gt; c/types/integer
SCNiLEAST32 =&gt; c/types/integer
SCNiLEAST64 =&gt; c/types/integer
SCNiFAST8 =&gt; c/types/integer
SCNiFAST16 =&gt; c/types/integer
SCNiFAST32 =&gt; c/types/integer
SCNiFAST64 =&gt; c/types/integer
SCNiMAX =&gt; c/types/integer
SCNiPTR  =&gt; c/types/integer
SCNu8 =&gt; c/types/integer
SCNu16 =&gt; c/types/integer
SCNu32 =&gt; c/types/integer
SCNu64 =&gt; c/types/integer
SCNuLEAST8 =&gt; c/types/integer
SCNuLEAST16 =&gt; c/types/integer
SCNuLEAST32 =&gt; c/types/integer
SCNuLEAST64 =&gt; c/types/integer
SCNuFAST8 =&gt; c/types/integer
SCNuFAST16 =&gt; c/types/integer
SCNuFAST32 =&gt; c/types/integer
SCNuFAST64 =&gt; c/types/integer
SCNuMAX =&gt; c/types/integer
SCNuPTR  =&gt; c/types/integer
SCNo8 =&gt; c/types/integer
SCNo16 =&gt; c/types/integer
SCNo32 =&gt; c/types/integer
SCNo64 =&gt; c/types/integer
SCNoLEAST8 =&gt; c/types/integer
SCNoLEAST16 =&gt; c/types/integer
SCNoLEAST32 =&gt; c/types/integer
SCNoLEAST64 =&gt; c/types/integer
SCNoFAST8 =&gt; c/types/integer
SCNoFAST16 =&gt; c/types/integer
SCNoFAST32 =&gt; c/types/integer
SCNoFAST64 =&gt; c/types/integer
SCNoMAX =&gt; c/types/integer
SCNoPTR  =&gt; c/types/integer
SCNx8 =&gt; c/types/integer
SCNx16 =&gt; c/types/integer
SCNx32 =&gt; c/types/integer
SCNx64 =&gt; c/types/integer
SCNxLEAST8 =&gt; c/types/integer
SCNxLEAST16 =&gt; c/types/integer
SCNxLEAST32 =&gt; c/types/integer
SCNxLEAST64 =&gt; c/types/integer
SCNxFAST8 =&gt; c/types/integer
SCNxFAST16 =&gt; c/types/integer
SCNxFAST32 =&gt; c/types/integer
SCNxFAST64 =&gt; c/types/integer
SCNxMAX =&gt; c/types/integer
SCNxPTR  =&gt; c/types/integer
SCNX8 =&gt; c/types/integer
SCNX16 =&gt; c/types/integer
SCNX32 =&gt; c/types/integer
SCNX64 =&gt; c/types/integer
SCNXLEAST8 =&gt; c/types/integer
SCNXLEAST16 =&gt; c/types/integer
SCNXLEAST32 =&gt; c/types/integer
SCNXLEAST64 =&gt; c/types/integer
SCNXFAST8 =&gt; c/types/integer
SCNXFAST16 =&gt; c/types/integer
SCNXFAST32 =&gt; c/types/integer
SCNXFAST64 =&gt; c/types/integer
SCNXMAX =&gt; c/types/integer
SCNXPTR =&gt; c/types/integer
PTRDIFF_MIN =&gt; c/types/limits
PTRDIFF_MAX =&gt; c/types/limits
SIZE_MAX =&gt; c/types/limits
SIG_ATOMIC_MIN =&gt; c/types/limits
SIG_ATOMIC_MAX =&gt; c/types/limits
WCHAR_MIN =&gt; c/types/limits
WCHAR_MAX =&gt; c/types/limits
WINT_MIN =&gt; c/types/limits
WINT_MAX =&gt; c/types/limits
CHAR_BIT =&gt; c/types/limits
MB_LEN_MAX =&gt; c/types/limits
CHAR_MIN =&gt; c/types/limits
CHAR_MAX =&gt; c/types/limits
SCHAR_MIN =&gt; c/types/limits
SHRT_MIN =&gt; c/types/limits
INT_MIN =&gt; c/types/limits
LONG_MIN =&gt; c/types/limits
LLONG_MIN =&gt; c/types/limits
SCHAR_MAX =&gt; c/types/limits
SHRT_MAX =&gt; c/types/limits
INT_MAX =&gt; c/types/limits
LONG_MAX =&gt; c/types/limits
LLONG_MAX =&gt; c/types/limits
UCHAR_MAX =&gt; c/types/limits
USHRT_MAX =&gt; c/types/limits
UINT_MAX =&gt; c/types/limits
ULONG_MAX =&gt; c/types/limits
ULLONG_MAX =&gt; c/types/limits
FLT_RADIX =&gt; c/types/limits
DECIMAL_DIG =&gt; c/types/limits
FLT_MIN =&gt; c/types/limits
DBL_MIN =&gt; c/types/limits
LDBL_MIN =&gt; c/types/limits
FLT_MAX =&gt; c/types/limits
DBL_MAX =&gt; c/types/limits
LDBL_MAX =&gt; c/types/limits
FLT_EPSILON =&gt; c/types/limits
DBL_EPSILON =&gt; c/types/limits
LDBL_EPSILON =&gt; c/types/limits
FLT_DIG =&gt; c/types/limits
DBL_DIG =&gt; c/types/limits
LDBL_DIG =&gt; c/types/limits
FLT_MANT_DIG =&gt; c/types/limits
DBL_MANT_DIG =&gt; c/types/limits
LDBL_MANT_DIG =&gt; c/types/limits
FLT_MIN_EXP =&gt; c/types/limits
DBL_MIN_EXP =&gt; c/types/limits
LDBL_MIN_EXP =&gt; c/types/limits
FLT_MIN_10_EXP =&gt; c/types/limits
DBL_MIN_10_EXP =&gt; c/types/limits
LDBL_MIN_10_EXP =&gt; c/types/limits
FLT_MAX_EXP =&gt; c/types/limits
DBL_MAX_EXP =&gt; c/types/limits
LDBL_MAX_EXP =&gt; c/types/limits
FLT_MAX_10_EXP =&gt; c/types/limits
DBL_MAX_10_EXP =&gt; c/types/limits
LDBL_MAX_10_EXP =&gt; c/types/limits
FLT_ROUNDS =&gt; c/types/limits/FLT_ROUNDS
FLT_EVAL_METHOD =&gt; c/types/limits/FLT_EVAL_METHOD
malloc =&gt; c/memory/malloc
calloc =&gt; c/memory/calloc
realloc =&gt; c/memory/realloc
free =&gt; c/memory/free
assert =&gt; c/error/assert
errno =&gt; c/error/errno
E2BIG =&gt; c/error/errno_macros
EACCESS =&gt; c/error/errno_macros
EADDRINUSE =&gt; c/error/errno_macros
EADDRNOTAVAIL =&gt; c/error/errno_macros
EAFNOSUPPORT =&gt; c/error/errno_macros
EAGAIN =&gt; c/error/errno_macros
EALREADY =&gt; c/error/errno_macros
EBADF =&gt; c/error/errno_macros
EBADMSG =&gt; c/error/errno_macros
EBUSY =&gt; c/error/errno_macros
ECANCELED =&gt; c/error/errno_macros
ECHILD =&gt; c/error/errno_macros
ECONNABORTED =&gt; c/error/errno_macros
ECONNREFUSED =&gt; c/error/errno_macros
ECONNRESET =&gt; c/error/errno_macros
EDEADLK =&gt; c/error/errno_macros
EDESTADDRREQ =&gt; c/error/errno_macros
EDOM =&gt; c/error/errno_macros
EEXIST =&gt; c/error/errno_macros
EFAULT =&gt; c/error/errno_macros
EFBIG =&gt; c/error/errno_macros
EHOSTUNREACH =&gt; c/error/errno_macros
EIDRM =&gt; c/error/errno_macros
EILSEQ =&gt; c/error/errno_macros
EINPROGRESS =&gt; c/error/errno_macros
EINTR =&gt; c/error/errno_macros
EINVAL =&gt; c/error/errno_macros
EIO =&gt; c/error/errno_macros
EISCONN =&gt; c/error/errno_macros
EISDIR =&gt; c/error/errno_macros
ELOOP =&gt; c/error/errno_macros
EMFILE =&gt; c/error/errno_macros
EMLINK =&gt; c/error/errno_macros
EMSGSIZE =&gt; c/error/errno_macros
ENAMETOOLONG =&gt; c/error/errno_macros
ENETDOWN =&gt; c/error/errno_macros
ENETRESET =&gt; c/error/errno_macros
ENETUNREACH =&gt; c/error/errno_macros
ENFILE =&gt; c/error/errno_macros
ENOBUFS =&gt; c/error/errno_macros
ENODATA =&gt; c/error/errno_macros
ENODEV =&gt; c/error/errno_macros
ENOENT =&gt; c/error/errno_macros
ENOEXEC =&gt; c/error/errno_macros
ENOLCK =&gt; c/error/errno_macros
ENOLINK =&gt; c/error/errno_macros
ENOMEM =&gt; c/error/errno_macros
ENOMSG =&gt; c/error/errno_macros
ENOPROTOOPT =&gt; c/error/errno_macros
ENOSPC =&gt; c/error/errno_macros
ENOSR =&gt; c/error/errno_macros
ENOSTR =&gt; c/error/errno_macros
ENOSYS =&gt; c/error/errno_macros
ENOTCONN =&gt; c/error/errno_macros
ENOTDIR =&gt; c/error/errno_macros
ENOTEMPTY =&gt; c/error/errno_macros
ENOTRECOVERABLE =&gt; c/error/errno_macros
ENOTSOCK =&gt; c/error/errno_macros
ENOTSUP =&gt; c/error/errno_macros
ENOTTY =&gt; c/error/errno_macros
ENXIO =&gt; c/error/errno_macros
EOPNOTSUPP =&gt; c/error/errno_macros
EOVERFLOW =&gt; c/error/errno_macros
EOWNERDEAD =&gt; c/error/errno_macros
EPERM =&gt; c/error/errno_macros
EPIPE =&gt; c/error/errno_macros
EPROTO =&gt; c/error/errno_macros
EPROTONOSUPPORT =&gt; c/error/errno_macros
EPROTOTYPE =&gt; c/error/errno_macros
ERANGE =&gt; c/error/errno_macros
EROFS =&gt; c/error/errno_macros
ESPIPE =&gt; c/error/errno_macros
ESRCH =&gt; c/error/errno_macros
ETIME =&gt; c/error/errno_macros
ETIMEDOUT =&gt; c/error/errno_macros
ETXTBSY =&gt; c/error/errno_macros
EWOULDBLOCK =&gt; c/error/errno_macros
EXDEV =&gt; c/error/errno_macros
abort =&gt; c/program/abort
exit =&gt; c/program/exit
quick_exit =&gt; c/program/quick_exit
_Exit =&gt; c/program/_Exit
atexit =&gt; c/program/atexit
at_quick_exit =&gt; c/program/at_quick_exit
EXIT_SUCCESS =&gt; c/program/EXIT_status
EXIT_FAILURE =&gt; c/program/EXIT_status
system =&gt; c/program/system
getenv =&gt; c/program/getenv
signal =&gt; c/program/signal
raise =&gt; c/program/raise
sig_atomic_t =&gt; c/program/sig_atomic_t
SIG_DFL =&gt; c/program/SIG_strategies
SIG_IGN =&gt; c/program/SIG_strategies
SIG_ERR =&gt; c/program/SIG_ERR
SIGABRT =&gt; c/program/SIG_types
SIGFPE =&gt; c/program/SIG_types
SIGILL =&gt; c/program/SIG_types
SIGINT =&gt; c/program/SIG_types
SIGSEGV =&gt; c/program/SIG_types
SIGTERM =&gt; c/program/SIG_types
longjmp =&gt; c/program/longjmp
setjmp =&gt; c/program/setjmp
jmp_buf =&gt; c/program/jmp_buf
difftime =&gt; c/chrono/difftime
time =&gt; c/chrono/time
clock =&gt; c/chrono/clock
asctime =&gt; c/chrono/asctime
ctime =&gt; c/chrono/ctime
strftime =&gt; c/chrono/strftime
wcsftime =&gt; c/chrono/wcsftime
gmtime =&gt; c/chrono/gmtime
localtime =&gt; c/chrono/localtime
mktime =&gt; c/chrono/mktime
CLOCKS_PER_SEC =&gt; c/chrono/CLOCKS_PER_SEC
tm =&gt; c/chrono/tm
time_t =&gt; c/chrono/time_t
clock_t =&gt; c/chrono/clock_t
isalnum =&gt; c/string/byte/isalnum
isalpha =&gt; c/string/byte/isalpha
islower =&gt; c/string/byte/islower
isupper =&gt; c/string/byte/isupper
isdigit =&gt; c/string/byte/isdigit
isxdigit =&gt; c/string/byte/isxdigit
iscntrl =&gt; c/string/byte/iscntrl
isgraph =&gt; c/string/byte/isgraph
isspace =&gt; c/string/byte/isspace
isblank =&gt; c/string/byte/isblank
isprint =&gt; c/string/byte/isprint
ispunct =&gt; c/string/byte/ispunct
tolower =&gt; c/string/byte/tolower
toupper =&gt; c/string/byte/toupper
atof =&gt; c/string/byte/atof
atoi =&gt; c/string/byte/atoi
atol =&gt; c/string/byte/atoi
atoll =&gt; c/string/byte/atoi
strtol =&gt; c/string/byte/strtol
strtoll =&gt; c/string/byte/strtol
strtoul =&gt; c/string/byte/strtoul
strtoull =&gt; c/string/byte/strtoul
strtof =&gt; c/string/byte/strtof
strtod =&gt; c/string/byte/strtof
strtold =&gt; c/string/byte/strtof
strtoimax =&gt; c/string/byte/strtoimax
strtoumax =&gt; c/string/byte/strtoimax
strcpy =&gt; c/string/byte/strcpy
strncpy =&gt; c/string/byte/strncpy
strcat =&gt; c/string/byte/strcat
strncat =&gt; c/string/byte/strncat
strxfrm =&gt; c/string/byte/strxfrm
strlen =&gt; c/string/byte/strlen
strcmp =&gt; c/string/byte/strcmp
strncmp =&gt; c/string/byte/strncmp
strcoll =&gt; c/string/byte/strcoll
strchr =&gt; c/string/byte/strchr
strrchr =&gt; c/string/byte/strrchr
strspn =&gt; c/string/byte/strspn
strcspn =&gt; c/string/byte/strcspn
strpbrk =&gt; c/string/byte/strpbrk
strstr =&gt; c/string/byte/strstr
strtok =&gt; c/string/byte/strtok
memchr =&gt; c/string/byte/memchr
memcmp =&gt; c/string/byte/memcmp
memset =&gt; c/string/byte/memset
memcpy =&gt; c/string/byte/memcpy
memmove =&gt; c/string/byte/memmove
strerror =&gt; c/string/byte/strerror
mblen =&gt; c/string/multibyte/mblen
mbtowc =&gt; c/string/multibyte/mbtowc
wctomb =&gt; c/string/multibyte/wctomb
mbstowcs =&gt; c/string/multibyte/mbstowcs
wcstombs =&gt; c/string/multibyte/wcstombs
mbsinit =&gt; c/string/multibyte/mbsinit
btowc =&gt; c/string/multibyte/btowc
wctob =&gt; c/string/multibyte/wctob
mbrlen =&gt; c/string/multibyte/mbrlen
mbrtowc =&gt; c/string/multibyte/mbrtowc
wcrtomb =&gt; c/string/multibyte/wcrtomb
mbsrtowcs =&gt; c/string/multibyte/mbsrtowcs
wcstombs =&gt; c/string/multibyte/wcstombs
mbrtoc16 =&gt; c/string/multibyte/mbrtoc16
c16rtomb =&gt; c/string/multibyte/c16rtomb
mbrtoc32 =&gt; c/string/multibyte/mbrtoc32
c32rtomb =&gt; c/string/multibyte/c32rtomb
mbstate_t =&gt; c/string/multibyte/mbstate_t
iswalnum =&gt; c/string/wide/iswalnum
iswalpha =&gt; c/string/wide/iswalpha
iswlower =&gt; c/string/wide/iswlower
iswupper =&gt; c/string/wide/iswupper
iswdigit =&gt; c/string/wide/iswdigit
iswxdigit =&gt; c/string/wide/iswxdigit
iswcntrl =&gt; c/string/wide/iswcntrl
iswgraph =&gt; c/string/wide/iswgraph
iswspace =&gt; c/string/wide/iswspace
iswblank =&gt; c/string/wide/iswblank
iswprint =&gt; c/string/wide/iswprint
iswpunct =&gt; c/string/wide/iswpunct
iswctype =&gt; c/string/wide/iswctype
wctype =&gt; c/string/wide/wctype
towlower =&gt; c/string/wide/towlower
towupper =&gt; c/string/wide/towupper
towctrans =&gt; c/string/wide/towctrans
wctrans =&gt; c/string/wide/wctrans
wcstof =&gt; c/string/wide/wcstof
wcstod =&gt; c/string/wide/wcstof
wcstold =&gt; c/string/wide/wcstof
wcstol =&gt; c/string/wide/wcstol
wcstoll =&gt; c/string/wide/wcstol
wcstoul =&gt; c/string/wide/wcstoul
wcstoull =&gt; c/string/wide/wcstoul
wcstoimax =&gt; c/string/byte/wcstoimax
wcstoumax =&gt; c/string/byte/wcstoimax
wcscpy =&gt; c/string/wide/wcscpy
wcsncpy =&gt; c/string/wide/wcsncpy
wcscat =&gt; c/string/wide/wcscat
wcsncat =&gt; c/string/wide/wcsncat
wcsxfrm =&gt; c/string/wide/wcsxfrm
wcslen =&gt; c/string/wide/wcslen
wcscmp =&gt; c/string/wide/wcscmp
wcsncmp =&gt; c/string/wide/wcsncmp
wcscoll =&gt; c/string/wide/wcscoll
wcschr =&gt; c/string/wide/wcschr
wcsrchr =&gt; c/string/wide/wcsrchr
wcsspn =&gt; c/string/wide/wcsspn
wcscspn =&gt; c/string/wide/wcscspn
wcspbrk =&gt; c/string/wide/wcspbrk
wcsstr =&gt; c/string/wide/wcsstr
wcstok =&gt; c/string/wide/wcstok
wmemchr =&gt; c/string/wide/wmemchr
wmemcmp =&gt; c/string/wide/wmemcmp
wmemset =&gt; c/string/wide/wmemset
wmemcpy =&gt; c/string/wide/wmemcpy
wmemmove =&gt; c/string/wide/wmemmove
abs =&gt; c/numeric/math/abs
labs =&gt; c/numeric/math/abs
llabs =&gt; c/numeric/math/abs
fabs =&gt; c/numeric/math/fabs
div =&gt; c/numeric/math/div
ldiv =&gt; c/numeric/math/div
fmod =&gt; c/numeric/math/fmod
remainder =&gt; c/numeric/math/remainder
remquo =&gt; c/numeric/math/remquo
fma =&gt; c/numeric/math/fma
fmax =&gt; c/numeric/math/fmax
fmin =&gt; c/numeric/math/fmin
fdim =&gt; c/numeric/math/fdim
nan =&gt; c/numeric/math/nan
nanf =&gt; c/numeric/math/nan
nanl =&gt; c/numeric/math/nan
exp =&gt; c/numeric/math/exp
exp2 =&gt; c/numeric/math/exp2
expm1 =&gt; c/numeric/math/expm1
log =&gt; c/numeric/math/log
log10 =&gt; c/numeric/math/log10
log1p =&gt; c/numeric/math/log1p
ilogb =&gt; c/numeric/math/ilogb
logb =&gt; c/numeric/math/logb
sqrt =&gt; c/numeric/math/sqrt
cbrt =&gt; c/numeric/math/cbrt
hypot =&gt; c/numeric/math/hypot
pow =&gt; c/numeric/math/pow
sin =&gt; c/numeric/math/sin
cos =&gt; c/numeric/math/cos
tan =&gt; c/numeric/math/tan
asin =&gt; c/numeric/math/asin
acos =&gt; c/numeric/math/acos
atan =&gt; c/numeric/math/atan
atan2 =&gt; c/numeric/math/atan2
sinh =&gt; c/numeric/math/sinh
cosh =&gt; c/numeric/math/cosh
tanh =&gt; c/numeric/math/tanh
asinh =&gt; c/numeric/math/asinh
acosh =&gt; c/numeric/math/acosh
atanh =&gt; c/numeric/math/atanh
erf =&gt; c/numeric/math/erf
erfc =&gt; c/numeric/math/erfc
lgamma =&gt; c/numeric/math/lgamma
tgamma =&gt; c/numeric/math/tgamma
ceil =&gt; c/numeric/math/ceil
floor =&gt; c/numeric/math/floor
trunc =&gt; c/numeric/math/trunc
round =&gt; c/numeric/math/round
lround =&gt; c/numeric/math/round
llround =&gt; c/numeric/math/round
nearbyint =&gt; c/numeric/math/nearbyint
rint =&gt; c/numeric/math/rint
lrint =&gt; c/numeric/math/rint
llrint =&gt; c/numeric/math/rint
frexp =&gt; c/numeric/math/frexp
ldexp =&gt; c/numeric/math/ldexp
modf =&gt; c/numeric/math/modf
scalbn =&gt; c/numeric/math/scalbn
scalbln =&gt; c/numeric/math/scalbn
nextafter =&gt; c/numeric/math/nextafter
nexttoward =&gt; c/numeric/math/nextafter
copysign =&gt; c/numeric/math/copysign
fpclassify =&gt; c/numeric/math/fpclassify
isfinite =&gt; c/numeric/math/isfinite
isinf =&gt; c/numeric/math/isinf
isnan =&gt; c/numeric/math/isnan
isnormal =&gt; c/numeric/math/isnormal
signbit =&gt; c/numeric/math/signbit
HUGE_VAL =&gt; c/numeric/math/HUGE_VAL
HUGE_VALF =&gt; c/numeric/math/HUGE_VAL
HUGE_VALL =&gt; c/numeric/math/HUGE_VAL
FP_INFINITE =&gt; c/numeric/math/FP_categories
FP_NAN =&gt; c/numeric/math/FP_categories
FP_NORMAL =&gt; c/numeric/math/FP_categories
FP_SUBNORMAL =&gt; c/numeric/math/FP_categories
FP_ZERO =&gt; c/numeric/math/FP_categories
feclearexcept =&gt; c/numeric/fenv/feclearexcept
fetestexcept =&gt; c/numeric/fenv/fetestexcept
feraiseexcept =&gt; c/numeric/fenv/feraiseexcept
fegetexceptflag =&gt; c/numeric/fenv/feexceptflag
fesetexceptflag =&gt; c/numeric/fenv/feexceptflag
fegetround =&gt; c/numeric/fenv/feround
fesetround =&gt; c/numeric/fenv/feround
fegetenv =&gt; c/numeric/fenv/feenv
fesetenv =&gt; c/numeric/fenv/feenv
feholdexcept =&gt; c/numeric/fenv/feholdexcept
feupdateenv =&gt; c/numeric/fenv/feupdateenv
FE_ALL_EXCEPT =&gt; c/numeric/fenv/FE_exceptions
FE_DIVBYZERO =&gt; c/numeric/fenv/FE_exceptions
FE_INEXACT =&gt; c/numeric/fenv/FE_exceptions
FE_INVALID =&gt; c/numeric/fenv/FE_exceptions
FE_OVERFLOW =&gt; c/numeric/fenv/FE_exceptions
FE_UNDERFLOW =&gt; c/numeric/fenv/FE_exceptions
FE_DOWNWARD =&gt; c/numeric/fenv/FE_round
FE_TONEAREST =&gt; c/numeric/fenv/FE_round
FE_TOWARDZERO =&gt; c/numeric/fenv/FE_round
FE_UPWARD =&gt; c/numeric/fenv/FE_round
FE_DFL_ENV =&gt; c/numeric/fenv/FE_DFL_ENV
srand =&gt; c/numeric/random/srand
rand =&gt; c/numeric/random/rand
RAND_MAX =&gt; c/numeric/random/RAND_MAX
complex =&gt; c/numeric/complex/complex
Complex_I =&gt; c/numeric/complex/Complex_I
imaginary =&gt; c/numeric/complex/imaginary
Imaginary_I =&gt; c/numeric/complex/Imaginary_I
I =&gt; c/numeric/complex/I
CMPLX =&gt; c/numeric/complex/CMPLX
CMPLXF =&gt; c/numeric/complex/CMPLX
CMPLXL =&gt; c/numeric/complex/CMPLX
cimag =&gt; c/numeric/complex/cimag
cimagf =&gt; c/numeric/complex/cimag
cimagl =&gt; c/numeric/complex/cimag
creal =&gt; c/numeric/complex/creal
crealf =&gt; c/numeric/complex/creal
creall =&gt; c/numeric/complex/creal
carg =&gt; c/numeric/complex/carg
cargf =&gt; c/numeric/complex/carg
cargl =&gt; c/numeric/complex/carg
conj =&gt; c/numeric/complex/conj
conjf =&gt; c/numeric/complex/conj
conjl =&gt; c/numeric/complex/conj
cproj =&gt; c/numeric/complex/cproj
cprojf =&gt; c/numeric/complex/cproj
cprojl =&gt; c/numeric/complex/cproj
cabs =&gt; c/numeric/complex/cabs
cabsf =&gt; c/numeric/complex/cabs
cabsl =&gt; c/numeric/complex/cabs
cexp =&gt; c/numeric/complex/cexp
cexpf =&gt; c/numeric/complex/cexp
cexpl =&gt; c/numeric/complex/cexp
clog =&gt; c/numeric/complex/clog
clogf =&gt; c/numeric/complex/clog
clogl =&gt; c/numeric/complex/clog
cpow =&gt; c/numeric/complex/cpow
cpowf =&gt; c/numeric/complex/cpow
cpowl =&gt; c/numeric/complex/cpow
csqrt =&gt; c/numeric/complex/csqrt
csqrtf =&gt; c/numeric/complex/csqrt
csqrtl =&gt; c/numeric/complex/csqrt
cacos =&gt; c/numeric/complex/cacos
cacosf =&gt; c/numeric/complex/cacos
cacosl =&gt; c/numeric/complex/cacos
casin =&gt; c/numeric/complex/casin
casinf =&gt; c/numeric/complex/casin
casinl =&gt; c/numeric/complex/casin
catan =&gt; c/numeric/complex/catan
catanf =&gt; c/numeric/complex/catan
catanl =&gt; c/numeric/complex/catan
ccos =&gt; c/numeric/complex/ccos
ccosf =&gt; c/numeric/complex/ccos
ccosl =&gt; c/numeric/complex/ccos
csin =&gt; c/numeric/complex/csin
csinf =&gt; c/numeric/complex/csin
csinl =&gt; c/numeric/complex/csin
ctan =&gt; c/numeric/complex/ctan
ctanf =&gt; c/numeric/complex/ctan
ctanl =&gt; c/numeric/complex/ctan
cacosh =&gt; c/numeric/complex/cacosh
cacoshf =&gt; c/numeric/complex/cacosh
cacoshl =&gt; c/numeric/complex/cacosh
casinh =&gt; c/numeric/complex/casinh
casinhf =&gt; c/numeric/complex/casinh
casinhl =&gt; c/numeric/complex/casinh
catanh =&gt; c/numeric/complex/catanh
catanhf =&gt; c/numeric/complex/catanh
catanhl =&gt; c/numeric/complex/catanh
ccosh =&gt; c/numeric/complex/ccosh
ccoshf =&gt; c/numeric/complex/ccosh
ccoshl =&gt; c/numeric/complex/ccosh
csinh =&gt; c/numeric/complex/csinh
csinhf =&gt; c/numeric/complex/csinh
csinhl =&gt; c/numeric/complex/csinh
ctanh =&gt; c/numeric/complex/ctanh
ctanhf =&gt; c/numeric/complex/ctanh
ctanhl =&gt; c/numeric/complex/ctanh
qsort =&gt; c/algorithm/qsort
bsearch =&gt; c/algorithm/bsearch
fopen =&gt; c/io/fopen
freopen =&gt; c/io/freopen
fflush =&gt; c/io/fflush
fclose =&gt; c/io/fclose
setbuf =&gt; c/io/setbuf
setvbuf =&gt; c/io/setvbuf
fread =&gt; c/io/fread
fwrite =&gt; c/io/fwrite
fgetc =&gt; c/io/fgetc
getc =&gt; c/io/fgetc
fgets =&gt; c/io/fgets
fputc =&gt; c/io/fputc
putc =&gt; c/io/fputc
fputs =&gt; c/io/fputs
getchar =&gt; c/io/getchar
gets =&gt; c/io/gets
putchar =&gt; c/io/putchar
puts =&gt; c/io/puts
ungetc =&gt; c/io/ungetc
fgetwc =&gt; c/io/fgetwc
fgetss =&gt; c/io/fgetws
fputwc =&gt; c/io/fputwc
fputws =&gt; c/io/fputws
getwchar =&gt; c/io/getwchar
putwchar =&gt; c/io/putwchar
ungetwc =&gt; c/io/ungetwc
scanf =&gt; c/io/fscanf
fscanf =&gt; c/io/fscanf
sscanf =&gt; c/io/fscanf
vscanf =&gt; c/io/vfscanf
vfscanf =&gt; c/io/vfscanf
vsscanf =&gt; c/io/vfscanf
printf =&gt; c/io/fprintf
fprintf =&gt; c/io/fprintf
sprintf =&gt; c/io/fprintf
snprintf =&gt; c/io/fprintf
vprintf =&gt; c/io/vfprintf
vfprintf =&gt; c/io/vfprintf
vsprintf =&gt; c/io/vfprintf
vsnprintf =&gt; c/io/vfprintf
wscanf =&gt; c/io/fwscanf
fwscanf =&gt; c/io/fwscanf
swscanf =&gt; c/io/fwscanf
vwscanf =&gt; c/io/vfwscanf
vfwscanf =&gt; c/io/vfwscanf
vswscanf =&gt; c/io/vfwscanf
wprintf =&gt; c/io/fwprintf
fwprintf =&gt; c/io/fwprintf
swprintf =&gt; c/io/fwprintf
vwprintf =&gt; c/io/vfwprintf
vfwprintf =&gt; c/io/vfwprintf
vswprintf =&gt; c/io/vfwprintf
ftell =&gt; c/io/ftell
fgetpos =&gt; c/io/fgetpos
fseek =&gt; c/io/fseek
fsetpos =&gt; c/io/fsetpos
rewind =&gt; c/io/rewind
clearerr =&gt; c/io/clearerr
feof =&gt; c/io/feof
ferror =&gt; c/io/ferror
perror =&gt; c/io/perror
remove =&gt; c/io/remove
rename =&gt; c/io/rename
tmpfile =&gt; c/io/tmpfile
tmpnam =&gt; c/io/tmpnam
FILE =&gt; c/io
fpos_t =&gt; c/io
stdin =&gt; c/io
stdout =&gt; c/io
stderr =&gt; c/io
EOF =&gt; c/io
FOPEN_MAX =&gt; c/io
FILENAME_MAX =&gt; c/io
BUFSIZ =&gt; c/io
_IOFBF =&gt; c/io
_IOLBF =&gt; c/io
_IONBF =&gt; c/io
SEEK_SET =&gt; c/io
SEEK_CUR =&gt; c/io
SEEK_END =&gt; c/io
TMP_MAX =&gt; c/io
L_tmpnam =&gt; c/io
setlocale =&gt; c/locale/setlocale
localeconv =&gt; c/locale/localeconv
lconv =&gt; c/locale/lconv
LC_ALL =&gt; c/locale/LC_categories
LC_COLLATE =&gt; c/locale/LC_categories
LC_CTYPE =&gt; c/locale/LC_categories
LC_MONETARY =&gt; c/locale/LC_categories
LC_NUMERIC =&gt; c/locale/LC_categories
LC_TIME =&gt; c/locale/LC_categories
memory_order =&gt; c/atomic/memory_order
memory_order_relaxed =&gt; c/atomic/memory_order
memory_order_consume =&gt; c/atomic/memory_order
memory_order_acquire =&gt; c/atomic/memory_order
memory_order_release =&gt; c/atomic/memory_order
memory_order_acq_rel =&gt; c/atomic/memory_order
memory_order_seq_cst =&gt; c/atomic/memory_order
atomic_flag =&gt; c/atomic/atomic_flag
ATOMIC_BOOL_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR16_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR32_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_WCHAR_T_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_SHORT_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_INT_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_LONG_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_LLONG_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_POINTER_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_FLAG_INIT =&gt; c/atomic/ATOMIC_FLAG_INIT
ATOMIC_VAR_INIT =&gt; c/atomic/ATOMIC_VAR_INIT
kill_dependency =&gt; c/atomic/kill_dependency
atomic_load_test_and_set =&gt; c/atomic/atomic_load_test_and_set
atomic_load_test_and_set_explicit =&gt; c/atomic/atomic_load_test_and_set
atomic_flag_clear =&gt; c/atomic/atomic_flag_clear
atomic_flag_clear_explicit =&gt; c/atomic/atomic_flag_clear
atomic_init =&gt; c/atomic/atomic_init
atomic_is_lock_free =&gt; c/atomic/atomic_is_lock_free
atomic_store =&gt; c/atomic/atomic_store
atomic_store_explicit =&gt; c/atomic/atomic_store
atomic_load =&gt; c/atomic/atomic_load
atomic_load_explicit =&gt; c/atomic/atomic_load
atomic_exchange =&gt; c/atomic/atomic_exchange
atomic_exchange_explicit =&gt; c/atomic/atomic_exchange
atomic_compare_exchange_weak =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_weak_explicit =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_strong =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_strong_explicit =&gt; c/atomic/atomic_compare_exchange
atomic_fetch_add =&gt; c/atomic/atomic_fetch_add
atomic_fetch_add_explicit =&gt; c/atomic/atomic_fetch_add
atomic_fetch_sub =&gt; c/atomic/atomic_fetch_sub
atomic_fetch_sub_explicit =&gt; c/atomic/atomic_fetch_sub
atomic_fetch_or =&gt; c/atomic/atomic_fetch_or
atomic_fetch_or_explicit =&gt; c/atomic/atomic_fetch_or
atomic_fetch_xor =&gt; c/atomic/atomic_fetch_xor
atomic_fetch_xor_explicit =&gt; c/atomic/atomic_fetch_xor
atomic_fetch_and =&gt; c/atomic/atomic_fetch_and
atomic_fetch_and_explicit =&gt; c/atomic/atomic_fetch_and
atomic_thread_fence =&gt; c/atomic/atomic_thread_fence
atomic_signal_fence =&gt; c/atomic/atomic_signal_fence
atomic_bool =&gt; c/atomic
atomic_char =&gt; c/atomic
atomic_schar =&gt; c/atomic
atomic_uchar =&gt; c/atomic
atomic_short =&gt; c/atomic
atomic_ushort =&gt; c/atomic
atomic_int =&gt; c/atomic
atomic_uint =&gt; c/atomic
atomic_long =&gt; c/atomic
atomic_ulong =&gt; c/atomic
atomic_llong =&gt; c/atomic
atomic_ullong =&gt; c/atomic
atomic_char16_t =&gt; c/atomic
atomic_char32_t =&gt; c/atomic
atomic_wchar_t =&gt; c/atomic
atomic_int_least8_t =&gt; c/atomic
atomic_uint_least8_t =&gt; c/atomic
atomic_int_least16_t =&gt; c/atomic
atomic_uint_least16_t =&gt; c/atomic
atomic_int_least32_t =&gt; c/atomic
atomic_uint_least32_t =&gt; c/atomic
atomic_int_least64_t =&gt; c/atomic
atomic_uint_least64_t =&gt; c/atomic
atomic_int_fast8_t =&gt; c/atomic
atomic_uint_fast8_t =&gt; c/atomic
atomic_int_fast16_t =&gt; c/atomic
atomic_uint_fast16_t =&gt; c/atomic
atomic_int_fast32_t =&gt; c/atomic
atomic_uint_fast32_t =&gt; c/atomic
atomic_int_fast64_t =&gt; c/atomic
atomic_uint_fast64_t =&gt; c/atomic
atomic_intprt_t =&gt; c/atomic
atomic_uintprt_t =&gt; c/atomic
atomic_size_t =&gt; c/atomic
atomic_ptrdiff_t =&gt; c/atomic
atomic_intmax_t =&gt; c/atomic
atomic_uintmax_t =&gt; c/atomic
thrd_t =&gt; c/thread
thrd_create =&gt; c/thread/thrd_create
thrd_equal =&gt; c/thread/thrd_equal
thrd_current =&gt; c/thread/thrd_current
thrd_sleep =&gt; c/thread/thrd_sleep
thrd_yield =&gt; c/thread/thrd_yield
thrd_exit =&gt; c/thread/thrd_exit
thrd_detach =&gt; c/thread/thrd_detach
thrd_join =&gt; c/thread/thrd_join
thrd_success =&gt; c/thread/thrd_errors
thrd_timeout =&gt; c/thread/thrd_errors
thrd_busy =&gt; c/thread/thrd_errors
thrd_nomem =&gt; c/thread/thrd_errors
thrd_error =&gt; c/thread/thrd_errors
thrd_start_t =&gt; c/thread
mtx_t =&gt; c/thread
mtx_init =&gt; c/thread/mtx_init
mtx_lock =&gt; c/thread/mtx_lock
mtx_timedlock =&gt; c/thread/mtx_timedlock
mtx_trylock =&gt; c/thread/mtx_trylock
mtx_unlock =&gt; c/thread/mtx_unlock
mtx_destroy =&gt; c/thread/mtx_destroy
mtx_plain =&gt; c/thread/mtx_types
mtx_recursive =&gt; c/thread/mtx_types
mtx_timed =&gt; c/thread/mtx_types
thrd_start_t =&gt; c/thread
once_flag =&gt; c/thread
ONCE_FLAG_INIT =&gt; c/thread/ONCE_FLAG_INIT
call_once =&gt; c/thread/call_once
cnd_t =&gt; c/thread
cnd_init =&gt; c/thread/cnd_init
cnd_signal =&gt; c/thread/cnd_signal
cnd_broadcast =&gt; c/thread/cnd_broadcast
cnd_wait =&gt; c/thread/cnd_wait
cnd_timedwait =&gt; c/thread/cnd_timedwait
cnd_destroy =&gt; c/thread/cnd_destroy
thread_local =&gt; c/thread/thread_local
TSS_DTOR_ITERATIONS =&gt; c/thread/TSS_DTOR_ITERATIONS
tss_t =&gt; c/thread
tss_dtor_t =&gt; c/thread
tss_create =&gt; c/thread/tss_create
tss_get =&gt; c/thread/tss_get
tss_set =&gt; c/thread/tss_set
tss_delete =&gt; c/thread/tss_delete</text>
      <sha1>tgkhec52b0p848x3gghm8amoxjk7g7r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Cpp-search-list-cpp</title>
    <ns>8</ns>
    <id>8908</id>
    <revision>
      <id>71781</id>
      <parentid>67261</parentid>
      <timestamp>2014-06-24T01:44:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/FE_UNHERFLOW/FE_UNDERFLOW</comment>
      <text xml:space="preserve" bytes="457887">std::size_t =&gt; cpp/types/size_t
std::ptrdiff_t =&gt; cpp/types/ptrdiff_t
std::nullptr_t =&gt; cpp/types/nullptr_t
NULL =&gt; cpp/types/NULL
std::max_align_t =&gt; cpp/types/max_align_t
offsetof =&gt; cpp/types/offsetof
std::int8_t =&gt; cpp/types/integer
std::int16_t =&gt; cpp/types/integer
std::int32_t =&gt; cpp/types/integer
std::int64_t =&gt; cpp/types/integer
std::int_fast8_t =&gt; cpp/types/integer
std::int_fast16_t =&gt; cpp/types/integer
std::int_fast32_t =&gt; cpp/types/integer
std::int_fast64_t =&gt; cpp/types/integer
std::int_least8_t =&gt; cpp/types/integer
std::int_least16_t =&gt; cpp/types/integer
std::int_least32_t =&gt; cpp/types/integer
std::int_least64_t =&gt; cpp/types/integer
std::intmax_t =&gt; cpp/types/integer
std::intptr_t =&gt; cpp/types/integer
std::uint8_t =&gt; cpp/types/integer
std::uint16_t =&gt; cpp/types/integer
std::uint32_t =&gt; cpp/types/integer
std::uint64_t =&gt; cpp/types/integer
std::uint_fast8_t =&gt; cpp/types/integer
std::uint_fast16_t =&gt; cpp/types/integer
std::uint_fast32_t =&gt; cpp/types/integer
std::uint_fast64_t =&gt; cpp/types/integer
std::uint_least8_t =&gt; cpp/types/integer
std::uint_least16_t =&gt; cpp/types/integer
std::uint_least32_t =&gt; cpp/types/integer
std::uint_least64_t =&gt; cpp/types/integer
std::uintmax_t =&gt; cpp/types/integer
std::uintptr_t =&gt; cpp/types/integer
INT8_MIN =&gt; cpp/types/integer
INT16_MIN =&gt; cpp/types/integer
INT32_MIN =&gt; cpp/types/integer
INT64_MIN =&gt; cpp/types/integer
INT_FAST8_MIN =&gt; cpp/types/integer
INT_FAST16_MIN =&gt; cpp/types/integer
INT_FAST32_MIN =&gt; cpp/types/integer
INT_FAST64_MIN =&gt; cpp/types/integer
INT_LEAST8_MIN =&gt; cpp/types/integer
INT_LEAST16_MIN =&gt; cpp/types/integer
INT_LEAST32_MIN =&gt; cpp/types/integer
INT_LEAST64_MIN =&gt; cpp/types/integer
INTPTR_MIN =&gt; cpp/types/integer
INTMAX_MIN =&gt; cpp/types/integer
INT8_MAX =&gt; cpp/types/integer
INT16_MAX =&gt; cpp/types/integer
INT32_MAX =&gt; cpp/types/integer
INT64_MAX =&gt; cpp/types/integer
INT_FAST8_MAX =&gt; cpp/types/integer
INT_FAST16_MAX =&gt; cpp/types/integer
INT_FAST32_MAX =&gt; cpp/types/integer
INT_FAST64_MAX =&gt; cpp/types/integer
INT_LEAST8_MAX =&gt; cpp/types/integer
INT_LEAST16_MAX =&gt; cpp/types/integer
INT_LEAST32_MAX =&gt; cpp/types/integer
INT_LEAST64_MAX =&gt; cpp/types/integer
INTPTR_MAX =&gt; cpp/types/integer
INTMAX_MAX =&gt; cpp/types/integer
UINT8_MAX =&gt; cpp/types/integer
UINT16_MAX =&gt; cpp/types/integer
UINT32_MAX =&gt; cpp/types/integer
UINT64_MAX =&gt; cpp/types/integer
UINT_FAST8_MAX =&gt; cpp/types/integer
UINT_FAST16_MAX =&gt; cpp/types/integer
UINT_FAST32_MAX =&gt; cpp/types/integer
UINT_FAST64_MAX =&gt; cpp/types/integer
UINT_LEAST8_MAX =&gt; cpp/types/integer
UINT_LEAST16_MAX =&gt; cpp/types/integer
UINT_LEAST32_MAX =&gt; cpp/types/integer
UINT_LEAST64_MAX =&gt; cpp/types/integer
UINTPTR_MAX =&gt; cpp/types/integer
UINTMAX_MAX =&gt; cpp/types/integer
PRId8 =&gt; cpp/types/integer
PRId16 =&gt; cpp/types/integer
PRId32 =&gt; cpp/types/integer
PRId64 =&gt; cpp/types/integer
PRIdLEAST8 =&gt; cpp/types/integer
PRIdLEAST16 =&gt; cpp/types/integer
PRIdLEAST32 =&gt; cpp/types/integer
PRIdLEAST64 =&gt; cpp/types/integer
PRIdFAST8 =&gt; cpp/types/integer
PRIdFAST16 =&gt; cpp/types/integer
PRIdFAST32 =&gt; cpp/types/integer
PRIdFAST64 =&gt; cpp/types/integer
PRIdMAX =&gt; cpp/types/integer
PRIdPTR  =&gt; cpp/types/integer
PRIi8 =&gt; cpp/types/integer
PRIi16 =&gt; cpp/types/integer
PRIi32 =&gt; cpp/types/integer
PRIi64 =&gt; cpp/types/integer
PRIiLEAST8 =&gt; cpp/types/integer
PRIiLEAST16 =&gt; cpp/types/integer
PRIiLEAST32 =&gt; cpp/types/integer
PRIiLEAST64 =&gt; cpp/types/integer
PRIiFAST8 =&gt; cpp/types/integer
PRIiFAST16 =&gt; cpp/types/integer
PRIiFAST32 =&gt; cpp/types/integer
PRIiFAST64 =&gt; cpp/types/integer
PRIiMAX =&gt; cpp/types/integer
PRIiPTR  =&gt; cpp/types/integer
PRIu8 =&gt; cpp/types/integer
PRIu16 =&gt; cpp/types/integer
PRIu32 =&gt; cpp/types/integer
PRIu64 =&gt; cpp/types/integer
PRIuLEAST8 =&gt; cpp/types/integer
PRIuLEAST16 =&gt; cpp/types/integer
PRIuLEAST32 =&gt; cpp/types/integer
PRIuLEAST64 =&gt; cpp/types/integer
PRIuFAST8 =&gt; cpp/types/integer
PRIuFAST16 =&gt; cpp/types/integer
PRIuFAST32 =&gt; cpp/types/integer
PRIuFAST64 =&gt; cpp/types/integer
PRIuMAX =&gt; cpp/types/integer
PRIuPTR  =&gt; cpp/types/integer
PRIo8 =&gt; cpp/types/integer
PRIo16 =&gt; cpp/types/integer
PRIo32 =&gt; cpp/types/integer
PRIo64 =&gt; cpp/types/integer
PRIoLEAST8 =&gt; cpp/types/integer
PRIoLEAST16 =&gt; cpp/types/integer
PRIoLEAST32 =&gt; cpp/types/integer
PRIoLEAST64 =&gt; cpp/types/integer
PRIoFAST8 =&gt; cpp/types/integer
PRIoFAST16 =&gt; cpp/types/integer
PRIoFAST32 =&gt; cpp/types/integer
PRIoFAST64 =&gt; cpp/types/integer
PRIoMAX =&gt; cpp/types/integer
PRIoPTR  =&gt; cpp/types/integer
PRIx8 =&gt; cpp/types/integer
PRIx16 =&gt; cpp/types/integer
PRIx32 =&gt; cpp/types/integer
PRIx64 =&gt; cpp/types/integer
PRIxLEAST8 =&gt; cpp/types/integer
PRIxLEAST16 =&gt; cpp/types/integer
PRIxLEAST32 =&gt; cpp/types/integer
PRIxLEAST64 =&gt; cpp/types/integer
PRIxFAST8 =&gt; cpp/types/integer
PRIxFAST16 =&gt; cpp/types/integer
PRIxFAST32 =&gt; cpp/types/integer
PRIxFAST64 =&gt; cpp/types/integer
PRIxMAX =&gt; cpp/types/integer
PRIxPTR  =&gt; cpp/types/integer
PRIX8 =&gt; cpp/types/integer
PRIX16 =&gt; cpp/types/integer
PRIX32 =&gt; cpp/types/integer
PRIX64 =&gt; cpp/types/integer
PRIXLEAST8 =&gt; cpp/types/integer
PRIXLEAST16 =&gt; cpp/types/integer
PRIXLEAST32 =&gt; cpp/types/integer
PRIXLEAST64 =&gt; cpp/types/integer
PRIXFAST8 =&gt; cpp/types/integer
PRIXFAST16 =&gt; cpp/types/integer
PRIXFAST32 =&gt; cpp/types/integer
PRIXFAST64 =&gt; cpp/types/integer
PRIXMAX =&gt; cpp/types/integer
PRIXPTR  =&gt; cpp/types/integer
SCNd8 =&gt; cpp/types/integer
SCNd16 =&gt; cpp/types/integer
SCNd32 =&gt; cpp/types/integer
SCNd64 =&gt; cpp/types/integer
SCNdLEAST8 =&gt; cpp/types/integer
SCNdLEAST16 =&gt; cpp/types/integer
SCNdLEAST32 =&gt; cpp/types/integer
SCNdLEAST64 =&gt; cpp/types/integer
SCNdFAST8 =&gt; cpp/types/integer
SCNdFAST16 =&gt; cpp/types/integer
SCNdFAST32 =&gt; cpp/types/integer
SCNdFAST64 =&gt; cpp/types/integer
SCNdMAX =&gt; cpp/types/integer
SCNdPTR  =&gt; cpp/types/integer
SCNi8 =&gt; cpp/types/integer
SCNi16 =&gt; cpp/types/integer
SCNi32 =&gt; cpp/types/integer
SCNi64 =&gt; cpp/types/integer
SCNiLEAST8 =&gt; cpp/types/integer
SCNiLEAST16 =&gt; cpp/types/integer
SCNiLEAST32 =&gt; cpp/types/integer
SCNiLEAST64 =&gt; cpp/types/integer
SCNiFAST8 =&gt; cpp/types/integer
SCNiFAST16 =&gt; cpp/types/integer
SCNiFAST32 =&gt; cpp/types/integer
SCNiFAST64 =&gt; cpp/types/integer
SCNiMAX =&gt; cpp/types/integer
SCNiPTR  =&gt; cpp/types/integer
SCNu8 =&gt; cpp/types/integer
SCNu16 =&gt; cpp/types/integer
SCNu32 =&gt; cpp/types/integer
SCNu64 =&gt; cpp/types/integer
SCNuLEAST8 =&gt; cpp/types/integer
SCNuLEAST16 =&gt; cpp/types/integer
SCNuLEAST32 =&gt; cpp/types/integer
SCNuLEAST64 =&gt; cpp/types/integer
SCNuFAST8 =&gt; cpp/types/integer
SCNuFAST16 =&gt; cpp/types/integer
SCNuFAST32 =&gt; cpp/types/integer
SCNuFAST64 =&gt; cpp/types/integer
SCNuMAX =&gt; cpp/types/integer
SCNuPTR  =&gt; cpp/types/integer
SCNo8 =&gt; cpp/types/integer
SCNo16 =&gt; cpp/types/integer
SCNo32 =&gt; cpp/types/integer
SCNo64 =&gt; cpp/types/integer
SCNoLEAST8 =&gt; cpp/types/integer
SCNoLEAST16 =&gt; cpp/types/integer
SCNoLEAST32 =&gt; cpp/types/integer
SCNoLEAST64 =&gt; cpp/types/integer
SCNoFAST8 =&gt; cpp/types/integer
SCNoFAST16 =&gt; cpp/types/integer
SCNoFAST32 =&gt; cpp/types/integer
SCNoFAST64 =&gt; cpp/types/integer
SCNoMAX =&gt; cpp/types/integer
SCNoPTR  =&gt; cpp/types/integer
SCNx8 =&gt; cpp/types/integer
SCNx16 =&gt; cpp/types/integer
SCNx32 =&gt; cpp/types/integer
SCNx64 =&gt; cpp/types/integer
SCNxLEAST8 =&gt; cpp/types/integer
SCNxLEAST16 =&gt; cpp/types/integer
SCNxLEAST32 =&gt; cpp/types/integer
SCNxLEAST64 =&gt; cpp/types/integer
SCNxFAST8 =&gt; cpp/types/integer
SCNxFAST16 =&gt; cpp/types/integer
SCNxFAST32 =&gt; cpp/types/integer
SCNxFAST64 =&gt; cpp/types/integer
SCNxMAX =&gt; cpp/types/integer
SCNxPTR  =&gt; cpp/types/integer
SCNX8 =&gt; cpp/types/integer
SCNX16 =&gt; cpp/types/integer
SCNX32 =&gt; cpp/types/integer
SCNX64 =&gt; cpp/types/integer
SCNXLEAST8 =&gt; cpp/types/integer
SCNXLEAST16 =&gt; cpp/types/integer
SCNXLEAST32 =&gt; cpp/types/integer
SCNXLEAST64 =&gt; cpp/types/integer
SCNXFAST8 =&gt; cpp/types/integer
SCNXFAST16 =&gt; cpp/types/integer
SCNXFAST32 =&gt; cpp/types/integer
SCNXFAST64 =&gt; cpp/types/integer
SCNXMAX =&gt; cpp/types/integer
SCNXPTR =&gt; cpp/types/integer
std::numeric_limits =&gt; cpp/types/numeric_limits
std::numeric_limits::is_specialized =&gt; cpp/types/numeric_limits/is_specialized
std::numeric_limits::is_signed =&gt; cpp/types/numeric_limits/is_signed
std::numeric_limits::is_integer =&gt; cpp/types/numeric_limits/is_integer
std::numeric_limits::is_exact =&gt; cpp/types/numeric_limits/is_exact
std::numeric_limits::has_infinity =&gt; cpp/types/numeric_limits/has_infinity
std::numeric_limits::has_quiet_NaN =&gt; cpp/types/numeric_limits/has_quiet_NaN
std::numeric_limits::has_signaling_NaN =&gt; cpp/types/numeric_limits/has_signaling_NaN
std::numeric_limits::has_denorm =&gt; cpp/types/numeric_limits/has_denorm
std::numeric_limits::has_denorm_loss =&gt; cpp/types/numeric_limits/has_denorm_loss
std::numeric_limits::round_style =&gt; cpp/types/numeric_limits/round_style
std::numeric_limits::is_iec559 =&gt; cpp/types/numeric_limits/is_iec559
std::numeric_limits::is_bounded =&gt; cpp/types/numeric_limits/is_bounded
std::numeric_limits::is_modulo =&gt; cpp/types/numeric_limits/is_modulo
std::numeric_limits::digits =&gt; cpp/types/numeric_limits/digits
std::numeric_limits::digits10 =&gt; cpp/types/numeric_limits/digits10
std::numeric_limits::max_digits10 =&gt; cpp/types/numeric_limits/max_digits10
std::numeric_limits::radix =&gt; cpp/types/numeric_limits/radix
std::numeric_limits::min_exponent =&gt; cpp/types/numeric_limits/min_exponent
std::numeric_limits::min_exponent10 =&gt; cpp/types/numeric_limits/min_exponent10
std::numeric_limits::max_exponent =&gt; cpp/types/numeric_limits/max_exponent
std::numeric_limits::max_exponent10 =&gt; cpp/types/numeric_limits/max_exponent10
std::numeric_limits::traps =&gt; cpp/types/numeric_limits/traps
std::numeric_limits::tinyness_before =&gt; cpp/types/numeric_limits/tinyness_before
std::numeric_limits::min =&gt; cpp/types/numeric_limits/min
std::numeric_limits::max =&gt; cpp/types/numeric_limits/max
std::numeric_limits::lowest =&gt; cpp/types/numeric_limits/lowest
std::numeric_limits::epsilon =&gt; cpp/types/numeric_limits/epsilon
std::numeric_limits::round_error =&gt; cpp/types/numeric_limits/round_error
std::numeric_limits::infinity =&gt; cpp/types/numeric_limits/infinity
std::numeric_limits::quiet_NaN =&gt; cpp/types/numeric_limits/quiet_NaN
std::numeric_limits::signaling_NaN =&gt; cpp/types/numeric_limits/signaling_NaN
std::numeric_limits::denorm_min =&gt; cpp/types/numeric_limits/denorm_min
std::float_round_style =&gt; cpp/types/numeric_limits/float_round_style
std::round_indeterminate =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_zero =&gt; cpp/types/numeric_limits/float_round_style
std::round_to_nearest =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_infinity =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_neg_infinity =&gt; cpp/types/numeric_limits/float_round_style
std::float_denorm_style =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_indeterminate =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_absent =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_present =&gt; cpp/types/numeric_limits/float_denorm_style
PTRDIFF_MIN =&gt; cpp/types/climits
PTRDIFF_MAX =&gt; cpp/types/climits
SIZE_MAX =&gt; cpp/types/climits
SIG_ATOMIC_MIN =&gt; cpp/types/climits
SIG_ATOMIC_MAX =&gt; cpp/types/climits
WCHAR_MIN =&gt; cpp/types/climits
WCHAR_MAX =&gt; cpp/types/climits
WINT_MIN =&gt; cpp/types/climits
WINT_MAX =&gt; cpp/types/climits
CHAR_BIT =&gt; cpp/types/climits
MB_LEN_MAX =&gt; cpp/types/climits
CHAR_MIN =&gt; cpp/types/climits
CHAR_MAX =&gt; cpp/types/climits
SCHAR_MIN =&gt; cpp/types/climits
SHRT_MIN =&gt; cpp/types/climits
INT_MIN =&gt; cpp/types/climits
LONG_MIN =&gt; cpp/types/climits
LLONG_MIN =&gt; cpp/types/climits
SCHAR_MAX =&gt; cpp/types/climits
SHRT_MAX =&gt; cpp/types/climits
INT_MAX =&gt; cpp/types/climits
LONG_MAX =&gt; cpp/types/climits
LLONG_MAX =&gt; cpp/types/climits
UCHAR_MAX =&gt; cpp/types/climits
USHRT_MAX =&gt; cpp/types/climits
UINT_MAX =&gt; cpp/types/climits
ULONG_MAX =&gt; cpp/types/climits
ULLONG_MAX =&gt; cpp/types/climits
FLT_RADIX =&gt; cpp/types/climits
DECIMAL_DIG =&gt; cpp/types/climits
FLT_MIN =&gt; cpp/types/climits
DBL_MIN =&gt; cpp/types/climits
LDBL_MIN =&gt; cpp/types/climits
FLT_MAX =&gt; cpp/types/climits
DBL_MAX =&gt; cpp/types/climits
LDBL_MAX =&gt; cpp/types/climits
FLT_EPSILON =&gt; cpp/types/climits
DBL_EPSILON =&gt; cpp/types/climits
LDBL_EPSILON =&gt; cpp/types/climits
FLT_DIG =&gt; cpp/types/climits
DBL_DIG =&gt; cpp/types/climits
LDBL_DIG =&gt; cpp/types/climits
FLT_MANT_DIG =&gt; cpp/types/climits
DBL_MANT_DIG =&gt; cpp/types/climits
LDBL_MANT_DIG =&gt; cpp/types/climits
FLT_MIN_EXP =&gt; cpp/types/climits
DBL_MIN_EXP =&gt; cpp/types/climits
LDBL_MIN_EXP =&gt; cpp/types/climits
FLT_MIN_10_EXP =&gt; cpp/types/climits
DBL_MIN_10_EXP =&gt; cpp/types/climits
LDBL_MIN_10_EXP =&gt; cpp/types/climits
FLT_MAX_EXP =&gt; cpp/types/climits
DBL_MAX_EXP =&gt; cpp/types/climits
LDBL_MAX_EXP =&gt; cpp/types/climits
FLT_MAX_10_EXP =&gt; cpp/types/climits
DBL_MAX_10_EXP =&gt; cpp/types/climits
LDBL_MAX_10_EXP =&gt; cpp/types/climits
FLT_ROUNDS =&gt; cpp/types/climits/FLT_ROUNDS
FLT_EVAL_METHOD =&gt; cpp/types/climits/FLT_EVAL_METHOD
std::type_info =&gt; cpp/types/type_info
std::type_info::operator== =&gt; cpp/types/type_info/operator_cmp
std::type_info::operator!= =&gt; cpp/types/type_info/operator_cmp
std::type_info::before =&gt; cpp/types/type_info/before
std::type_info::hash_code =&gt; cpp/types/type_info/hash_code
std::type_info::name =&gt; cpp/types/type_info/name
std::type_index =&gt; cpp/types/type_index
std::type_index::type_index =&gt; cpp/types/type_index/type_index
std::type_index::operator== =&gt; cpp/types/type_index/operator_cmp
std::type_index::operator!= =&gt; cpp/types/type_index/operator_cmp
std::type_index::operator&lt;= =&gt; cpp/types/type_index/operator_cmp
std::type_index::operator&lt; =&gt; cpp/types/type_index/operator_cmp
std::type_index::operator&gt;= =&gt; cpp/types/type_index/operator_cmp
std::type_index::operator&gt; =&gt; cpp/types/type_index/operator_cmp
std::type_index::hash_code =&gt; cpp/types/type_index/hash_code
std::type_index::name =&gt; cpp/types/type_index/name
std::hash&lt;std::type_index&gt; =&gt; cpp/types/type_index/hash
std::bad_typeid =&gt; cpp/types/bad_typeid
std::bad_typeid::what =&gt; cpp/error/exception/what
std::bad_typeid::bad_typeid =&gt; cpp/types/bad_typeid/bad_typeid
std::bad_cast =&gt; cpp/types/bad_cast
std::bad_cast::what =&gt; cpp/error/exception/what
std::bad_cast::bad_cast =&gt; cpp/types/bad_cast/bad_cast
std::is_void =&gt; cpp/types/is_void
std::is_integral =&gt; cpp/types/is_integral
std::is_floating_point =&gt; cpp/types/is_floating_point
std::is_array =&gt; cpp/types/is_array
std::is_pointer =&gt; cpp/types/is_pointer
std::is_lvalue_reference =&gt; cpp/types/is_lvalue_reference
std::is_rvalue_reference =&gt; cpp/types/is_rvalue_reference
std::is_member_object_pointer =&gt; cpp/types/is_member_object_pointer
std::is_member_function_pointer =&gt; cpp/types/is_member_function_pointer
std::is_enum =&gt; cpp/types/is_enum
std::is_union =&gt; cpp/types/is_union
std::is_class =&gt; cpp/types/is_class
std::is_function =&gt; cpp/types/is_function
std::is_reference =&gt; cpp/types/is_reference
std::is_arithmetic =&gt; cpp/types/is_arithmetic
std::is_fundamental =&gt; cpp/types/is_fundamental
std::is_object =&gt; cpp/types/is_object
std::is_scalar =&gt; cpp/types/is_scalar
std::is_compound =&gt; cpp/types/is_compound
std::is_member_pointer =&gt; cpp/types/is_member_pointer
std::is_const =&gt; cpp/types/is_const
std::is_volatile =&gt; cpp/types/is_volatile
std::is_trivial =&gt; cpp/types/is_trivial
std::is_trivially_copyable =&gt; cpp/types/is_trivially_copyable
std::is_standard_layout =&gt; cpp/types/is_standard_layout
std::is_pod =&gt; cpp/types/is_pod
std::is_literal_type =&gt; cpp/types/is_literal_type
std::is_empty =&gt; cpp/types/is_empty
std::is_polymorphic =&gt; cpp/types/is_polymorphic
std::is_abstract =&gt; cpp/types/is_abstract
std::is_signed =&gt; cpp/types/is_signed
std::is_unsigned =&gt; cpp/types/is_unsigned
std::is_constructible =&gt; cpp/types/is_constructible
std::is_trivially_constructible =&gt; cpp/types/is_constructible
std::is_nothrow_constructible =&gt; cpp/types/is_constructible
std::is_default_constructible =&gt; cpp/types/is_default_constructible
std::is_trivially_default_constructible =&gt; cpp/types/is_default_constructible
std::is_nothrow_default_constructible =&gt; cpp/types/is_default_constructible
std::is_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_trivially_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_nothrow_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_move_constructible =&gt; cpp/types/is_move_constructible
std::is_trivially_move_constructible =&gt; cpp/types/is_move_constructible
std::is_nothrow_move_constructible =&gt; cpp/types/is_move_constructible
std::is_assignable =&gt; cpp/types/is_assignable
std::is_trivially_assignable =&gt; cpp/types/is_assignable
std::is_nothrow_assignable =&gt; cpp/types/is_assignable
std::is_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_trivially_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_nothrow_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_move_assignable =&gt; cpp/types/is_move_assignable
std::is_trivially_move_assignable =&gt; cpp/types/is_move_assignable
std::is_nothrow_move_assignable =&gt; cpp/types/is_move_assignable
std::is_destructible =&gt; cpp/types/is_destructible
std::is_trivially_destructible =&gt; cpp/types/is_destructible
std::is_nothrow_destructible =&gt; cpp/types/is_destructible
std::has_virtual_destructor =&gt; cpp/types/has_virtual_destructor
std::alignment_of =&gt; cpp/types/alignment_of
std::rank =&gt; cpp/types/rank
std::extent =&gt; cpp/types/extent
std::is_same =&gt; cpp/types/is_same
std::is_base_of =&gt; cpp/types/is_base_of
std::is_convertible =&gt; cpp/types/is_convertible
std::remove_cv =&gt; cpp/types/remove_cv
std::remove_const =&gt; cpp/types/remove_cv
std::remove_volatile =&gt; cpp/types/remove_cv
std::add_cv =&gt; cpp/types/add_cv
std::add_const =&gt; cpp/types/add_cv
std::add_volatile =&gt; cpp/types/add_cv
std::remove_reference =&gt; cpp/types/remove_reference
std::add_lvalue_reference =&gt; cpp/types/add_reference
std::add_rvalue_reference =&gt; cpp/types/add_reference
std::remove_pointer =&gt; cpp/types/remove_pointer
std::add_pointer =&gt; cpp/types/add_pointer
std::make_signed =&gt; cpp/types/make_signed
std::make_unsigned =&gt; cpp/types/make_unsigned
std::remove_extent =&gt; cpp/types/remove_extent
std::remove_all_extents =&gt; cpp/types/remove_all_extents
std::aligned_storage =&gt; cpp/types/aligned_storage
std::aligned_union =&gt; cpp/types/aligned_union
std::decay =&gt; cpp/types/decay
std::enable_if =&gt; cpp/types/enable_if
std::conditional =&gt; cpp/types/conditional
std::common_type =&gt; cpp/types/common_type
std::underlying_type =&gt; cpp/types/underlying_type
std::result_of =&gt; cpp/types/result_of
std::integral_constant =&gt; cpp/types/integral_constant
std::true_type =&gt; cpp/types/integral_constant
std::false_type =&gt; cpp/types/integral_constant
std::iterator_traits =&gt; cpp/iterator/iterator_traits
std::input_iterator_tag =&gt; cpp/iterator/iterator_tags
std::output_iterator_tag =&gt; cpp/iterator/iterator_tags
std::forward_iterator_tag =&gt; cpp/iterator/iterator_tags
std::bidirectional_iterator_tag =&gt; cpp/iterator/iterator_tags
std::random_access_iterator_tag =&gt; cpp/iterator/iterator_tags
std::iterator =&gt; cpp/iterator/iterator
std::reverse_iterator =&gt; cpp/iterator/reverse_iterator
std::move_iterator =&gt; cpp/iterator/move_iterator
std::back_insert_iterator =&gt; cpp/iterator/back_insert_iterator
std::front_insert_iterator =&gt; cpp/iterator/front_insert_iterator
std::insert_iterator =&gt; cpp/iterator/insert_iterator
std::make_move_iterator =&gt; cpp/iterator/make_move_iterator
std::back_inserter =&gt; cpp/iterator/back_inserter
std::front_inserter =&gt; cpp/iterator/front_inserter
std::inserter =&gt; cpp/iterator/inserter
std::istream_iterator =&gt; cpp/iterator/istream_iterator
std::istreambuf_iterator =&gt; cpp/iterator/istreambuf_iterator
std::ostream_iterator =&gt; cpp/iterator/ostream_iterator
std::ostreambuf_iterator =&gt; cpp/iterator/ostreambuf_iterator
std::advance =&gt; cpp/iterator/advance
std::distance =&gt; cpp/iterator/distance
std::next =&gt; cpp/iterator/next
std::prev =&gt; cpp/iterator/prev
std::begin =&gt; cpp/iterator/begin
std::end =&gt; cpp/iterator/end
operator new =&gt; cpp/memory/new/operator_new
operator new[] =&gt; cpp/memory/new/operator_new
operator delete =&gt; cpp/memory/new/operator_delete
operator delete[] =&gt; cpp/memory/new/operator_delete
std::get_new_handler =&gt; cpp/memory/new/get_new_handler
std::set_new_handler =&gt; cpp/memory/new/set_new_handler
std::bad_alloc =&gt; cpp/memory/new/bad_alloc
std::bad_alloc::what =&gt; cpp/error/exception/what
std::bad_alloc::bad_alloc =&gt; cpp/memory/new/bad_alloc
std::bad_alloc::operator= =&gt; cpp/memory/new/bad_alloc
std::bad_alloc::what =&gt; cpp/memory/new/bad_alloc
std::bad_array_new_length =&gt; cpp/memory/new/bad_array_new_length
std::bad_array_new_length::what =&gt; cpp/memory/new/bad_alloc
std::bad_array_new_length::what =&gt; cpp/error/exception/what
std::bad_array_new_length::bad_array_new_length =&gt; cpp/memory/new/bad_array_new_length/bad_array_new_length
std::bad_array_length =&gt; cpp/memory/new/bad_array_length
std::bad_array_length::what =&gt; cpp/memory/new/bad_alloc
std::bad_array_length::what =&gt; cpp/error/exception/what
std::bad_array_length::bad_array_length =&gt; cpp/memory/new/bad_array_length
std::nothrow_t =&gt; cpp/memory/new/nothrow_t
std::new_handler =&gt; cpp/memory/new/new_handler
std::nothrow =&gt; cpp/memory/new/nothrow
std::allocator =&gt; cpp/memory/allocator
std::allocator::allocator =&gt; cpp/memory/allocator/allocator
std::allocator::~allocator =&gt; cpp/memory/allocator/~allocator
std::allocator::address =&gt; cpp/memory/allocator/address
std::allocator::allocate =&gt; cpp/memory/allocator/allocate
std::allocator::deallocate =&gt; cpp/memory/allocator/deallocate
std::allocator::max_size =&gt; cpp/memory/allocator/max_size
std::allocator::construct =&gt; cpp/memory/allocator/construct
std::allocator::destroy =&gt; cpp/memory/allocator/destroy
operator==(std::allocator) =&gt; cpp/memory/allocator/operator_cmp
operator!=(std::allocator) =&gt; cpp/memory/allocator/operator_cmp
std::allocator_traits =&gt; cpp/memory/allocator_traits
std::allocator_traits::allocate =&gt; cpp/memory/allocator_traits/allocate
std::allocator_traits::deallocate =&gt; cpp/memory/allocator_traits/deallocate
std::allocator_traits::max_size =&gt; cpp/memory/allocator_traits/max_size
std::allocator_traits::construct =&gt; cpp/memory/allocator_traits/construct
std::allocator_traits::destroy =&gt; cpp/memory/allocator_traits/destroy
std::allocator_traits::select_on_container_copy_construction =&gt; cpp/memory/allocator_traits/select_on_container_copy_construction
std::allocator_arg_t =&gt; cpp/memory/allocator_arg_t
std::allocator_arg =&gt; cpp/memory/allocator_arg
std::uses_allocator =&gt; cpp/memory/uses_allocator
std::scoped_allocator_adaptor =&gt; cpp/memory/scoped_allocator_adaptor
std::scoped_allocator_adaptor::scoped_allocator_adaptor =&gt; cpp/memory/scoped_allocator_adaptor/scoped_allocator_adaptor
std::scoped_allocator_adaptor::~scoped_allocator_adaptor =&gt; cpp/memory/scoped_allocator_adaptor/~scoped_allocator_adaptor
std::scoped_allocator_adaptor::inner_allocator =&gt; cpp/memory/scoped_allocator_adaptor/inner_allocator
std::scoped_allocator_adaptor::outer_allocator =&gt; cpp/memory/scoped_allocator_adaptor/outer_allocator
std::scoped_allocator_adaptor::allocate =&gt; cpp/memory/scoped_allocator_adaptor/allocate
std::scoped_allocator_adaptor::deallocate =&gt; cpp/memory/scoped_allocator_adaptor/deallocate
std::scoped_allocator_adaptor::max_size =&gt; cpp/memory/scoped_allocator_adaptor/max_size
std::scoped_allocator_adaptor::construct =&gt; cpp/memory/scoped_allocator_adaptor/construct
std::scoped_allocator_adaptor::destroy =&gt; cpp/memory/scoped_allocator_adaptor/destroy
std::scoped_allocator_adaptor::select_on_container_copy_construction =&gt; cpp/memory/scoped_allocator_adaptor/select_on_container_copy_construction
operator==(std::scoped_allocator_adaptor) =&gt; cpp/memory/scoped_allocator_adaptor/operator_cmp
operator!=(std::scoped_allocator_adaptor) =&gt; cpp/memory/scoped_allocator_adaptor/operator_cmp
std::uninitialized_copy =&gt; cpp/memory/uninitialized_copy
std::uninitialized_copy_n =&gt; cpp/memory/uninitialized_copy_n
std::uninitialized_fill =&gt; cpp/memory/uninitialized_fill
std::uninitialized_fill_n =&gt; cpp/memory/uninitialized_fill_n
std::raw_storage_iterator =&gt; cpp/memory/raw_storage_iterator
std::raw_storage_iterator::raw_storage_iterator =&gt; cpp/memory/raw_storage_iterator/raw_storage_iterator
std::raw_storage_iterator::operator* =&gt; cpp/memory/raw_storage_iterator/operator*
std::raw_storage_iterator::operator= =&gt; cpp/memory/raw_storage_iterator/operator=
std::raw_storage_iterator::operator++ =&gt; cpp/memory/raw_storage_iterator/operator++
std::get_temporary_buffer =&gt; cpp/memory/get_temporary_buffer
std::return_temporary_buffer =&gt; cpp/memory/return_temporary_buffer
std::unique_ptr =&gt; cpp/memory/unique_ptr
std::unique_ptr::unique_ptr =&gt; cpp/memory/unique_ptr/unique_ptr
std::unique_ptr::~unique_ptr =&gt; cpp/memory/unique_ptr/~unique_ptr
std::unique_ptr::operator= =&gt; cpp/memory/unique_ptr/operator=
std::unique_ptr::release =&gt; cpp/memory/unique_ptr/release
std::unique_ptr::reset =&gt; cpp/memory/unique_ptr/reset
std::unique_ptr::swap =&gt; cpp/memory/unique_ptr/swap
std::unique_ptr::get =&gt; cpp/memory/unique_ptr/get
std::unique_ptr::get_deleter =&gt; cpp/memory/unique_ptr/get_deleter
std::unique_ptr::operator* =&gt; cpp/memory/unique_ptr/operator*
std::unique_ptr::operator-&gt; =&gt; cpp/memory/unique_ptr/operator*
std::unique_ptr::operator bool =&gt; cpp/memory/unique_ptr/operator bool
operator==(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
operator!=(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
operator&lt;(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
operator&lt;=(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
operator&gt;(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
operator&gt;=(std::unique_ptr) =&gt; cpp/memory/unique_ptr/operator_cmp
std::swap(std::unique_ptr) =&gt; cpp/memory/unique_ptr/swap2
std::hash&lt;std::unique_ptr&gt; =&gt; cpp/memory/unique_ptr/hash
std::shared_ptr =&gt; cpp/memory/shared_ptr
std::shared_ptr::shared_ptr =&gt; cpp/memory/shared_ptr/shared_ptr
std::shared_ptr::~shared_ptr =&gt; cpp/memory/shared_ptr/~shared_ptr
std::shared_ptr::operator= =&gt; cpp/memory/shared_ptr/operator=
std::shared_ptr::reset =&gt; cpp/memory/shared_ptr/reset
std::shared_ptr::swap =&gt; cpp/memory/shared_ptr/swap
std::shared_ptr::get =&gt; cpp/memory/shared_ptr/get
std::shared_ptr::operator* =&gt; cpp/memory/shared_ptr/operator*
std::shared_ptr::operator-&gt; =&gt; cpp/memory/shared_ptr/operator*
std::shared_ptr::unique =&gt; cpp/memory/shared_ptr/unique
std::shared_ptr::operator bool =&gt; cpp/memory/shared_ptr/operator bool
std::shared_ptr::owner_before =&gt; cpp/memory/shared_ptr/owner_before
operator==(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator!=(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator&lt;(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator&lt;=(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator&gt;(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator&gt;=(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_cmp
operator&lt;&lt;(std::shared_ptr) =&gt; cpp/memory/shared_ptr/operator_ltlt
std::swap(std::shared_ptr) =&gt; cpp/memory/shared_ptr/swap2
std::get_deleter(std::shared_ptr) =&gt; cpp/memory/shared_ptr/get_deleter
std::atomic_is_lock_free(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_load(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_load_explicit(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_store(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_store_explicit(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_exchange(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::atomic_exchange_explicit(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::compare_exchange_weak(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::compare_exchange_strong(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::compare_exchange_weak_explicit(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::compare_exchange_strong_explicit(std::shared_ptr) =&gt; cpp/memory/shared_ptr/atomic
std::hash&lt;std::shared_ptr&gt; =&gt; cpp/memory/shared_ptr/hash
std::make_shared =&gt; cpp/memory/shared_ptr/make_shared
std::allocate_shared =&gt; cpp/memory/shared_ptr/allocate_shared
std::static_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::dynamic_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::const_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::weak_ptr =&gt; cpp/memory/weak_ptr
std::weak_ptr::weak_ptr =&gt; cpp/memory/weak_ptr/weak_ptr
std::weak_ptr::~weak_ptr =&gt; cpp/memory/weak_ptr/~weak_ptr
std::weak_ptr::operator= =&gt; cpp/memory/weak_ptr/operator=
std::weak_ptr::reset =&gt; cpp/memory/weak_ptr/reset
std::weak_ptr::swap =&gt; cpp/memory/weak_ptr/swap
std::weak_ptr::use_count =&gt; cpp/memory/weak_ptr/use_count
std::weak_ptr::expired =&gt; cpp/memory/weak_ptr/expired
std::weak_ptr::lock =&gt; cpp/memory/weak_ptr/lock
std::weak_ptr::owner_before =&gt; cpp/memory/weak_ptr/owner_before
std::swap(std::weak_ptr) =&gt; cpp/memory/weak_ptr/swap
std::auto_ptr =&gt; cpp/memory/auto_ptr
std::auto_ptr::auto_ptr =&gt; cpp/memory/auto_ptr/auto_ptr
std::auto_ptr::~auto_ptr =&gt; cpp/memory/auto_ptr/~auto_ptr
std::auto_ptr::operator= =&gt; cpp/memory/auto_ptr/operator=
std::auto_ptr::reset =&gt; cpp/memory/auto_ptr/reset
std::auto_ptr::release =&gt; cpp/memory/auto_ptr/release
std::auto_ptr::get =&gt; cpp/memory/auto_ptr/get
std::auto_ptr::operator* =&gt; cpp/memory/auto_ptr/operator*
std::auto_ptr::operator-&gt; =&gt; cpp/memory/auto_ptr/operator*
std::auto_ptr::operator auto_ptr&lt;Y&gt; =&gt; cpp/memory/auto_ptr/operator_auto_ptr
std::owner_less =&gt; cpp/memory/owner_less
std::owner_less::operator() =&gt; cpp/memory/owner_less
std::enable_shared_from_this =&gt; cpp/memory/enable_shared_from_this
std::enable_shared_from_this::enable_shared_from_this =&gt; cpp/memory/enable_shared_from_this/enable_shared_from_this
std::enable_shared_from_this::~enable_shared_from_this =&gt; cpp/memory/enable_shared_from_this/~enable_shared_from_this
std::enable_shared_from_this::operator= =&gt; cpp/memory/enable_shared_from_this/operator=
std::enable_shared_from_this::shared_from_this =&gt; cpp/memory/enable_shared_from_this/shared_from_this
std::bad_weak_ptr =&gt; cpp/memory/bad_weak_ptr
std::bad_weak_ptr::what =&gt; cpp/error/exception/what
std::bad_weak_ptr::bad_weak_ptr =&gt; cpp/memory/bad_weak_ptr/bad_weak_ptr
std::bad_weak_ptr::what =&gt; cpp/memory/bad_weak_ptr/what
std::default_delete =&gt; cpp/memory/default_delete
std::default_delete::default_delete =&gt; cpp/memory/default_delete
std::default_delete::operator() =&gt; cpp/memory/default_delete
std::declare_reachable =&gt; cpp/memory/gc/declare_reachable
std::undeclare_reachable =&gt; cpp/memory/gc/undeclare_reachable
std::declare_no_pointers =&gt; cpp/memory/gc/declare_no_pointers
std::undeclare_no_pointers =&gt; cpp/memory/gc/undeclare_no_pointers
std::pointer_safety =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::relaxed =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::preferred =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::strict =&gt; cpp/memory/gc/pointer_safety
std::get_pointer_safety =&gt; cpp/memory/gc/get_pointer_safety
std::pointer_traits =&gt; cpp/memory/pointer_traits
std::pointer_traits::pointer_to =&gt; cpp/memory/pointer_traits/pointer_to
std::addressof =&gt; cpp/memory/addressof
std::align =&gt; cpp/memory/align
std::malloc =&gt; cpp/memory/c/malloc
std::calloc =&gt; cpp/memory/c/calloc
std::realloc =&gt; cpp/memory/c/realloc
std::free =&gt; cpp/memory/c/free
std::exception =&gt; cpp/error/exception
std::exception::exception =&gt; cpp/error/exception/exception
std::exception::~exception =&gt; cpp/error/exception/~exception
std::exception::operator= =&gt; cpp/error/exception/operator=
std::exception::what =&gt; cpp/error/exception/what
std::logic_error =&gt; cpp/error/logic_error
std::logic_error::what =&gt; cpp/error/exception/what
std::logic_error::logic_error =&gt; cpp/error/logic_error
std::domain_error =&gt; cpp/error/domain_error
std::domain_error::what =&gt; cpp/error/exception/what
std::domain_error::domain_error =&gt; cpp/error/domain_error
std::length_error =&gt; cpp/error/length_error
std::length_error::what =&gt; cpp/error/exception/what
std::length_error::length_error =&gt; cpp/error/length_error
std::out_of_range =&gt; cpp/error/out_of_range
std::out_of_range::what =&gt; cpp/error/exception/what
std::out_of_range::out_of_range =&gt; cpp/error/out_of_range
std::invalid_argument =&gt; cpp/error/invalid_argument
std::invalid_argument::what =&gt; cpp/error/exception/what
std::invalid_argument::invalid_argument =&gt; cpp/error/invalid_argument
std::runtime_error =&gt; cpp/error/runtime_error
std::runtime_error::what =&gt; cpp/error/exception/what
std::runtime_error::runtime_error =&gt; cpp/error/runtime_error
std::range_error =&gt; cpp/error/range_error
std::range_error::what =&gt; cpp/error/exception/what
std::range_error::range_error =&gt; cpp/error/range_error
std::overflow_error =&gt; cpp/error/overflow_error
std::overflow_error::what =&gt; cpp/error/exception/what
std::overflow_error::overflow_error =&gt; cpp/error/overflow_error
std::underflow_error =&gt; cpp/error/underflow_error
std::underflow_error::what =&gt; cpp/error/exception/what
std::underflow_error::underflow_error =&gt; cpp/error/underflow_error
assert =&gt; cpp/error/assert
std::uncaught_exception =&gt; cpp/error/uncaught_exception
std::exception_ptr =&gt; cpp/error/exception_ptr
std::make_exception_ptr =&gt; cpp/error/make_exception_ptr
std::current_exception =&gt; cpp/error/current_exception
std::rethrow_exception =&gt; cpp/error/rethrow_exception
std::nested_exception =&gt; cpp/error/nested_exception
std::nested_exception::nested_exception =&gt; cpp/error/nested_exception/nested_exception
std::nested_exception::~nested_exception =&gt; cpp/error/nested_exception/~nested_exception
std::nested_exception::operator= =&gt; cpp/error/nested_exception/operator=
std::nested_exception::rethrow_nested =&gt; cpp/error/nested_exception/rethrow_nested
std::nested_exception::nested_ptr =&gt; cpp/error/nested_exception/nested_ptr
std::throw_with_nested =&gt; cpp/error/throw_with_nested
std::rethrow_if_nested =&gt; cpp/error/rethrow_if_nested
std::terminate =&gt; cpp/error/terminate
std::terminate_handler =&gt; cpp/error/terminate_handler
std::get_terminate =&gt; cpp/error/get_terminate
std::set_terminate =&gt; cpp/error/set_terminate
std::unexpected =&gt; cpp/error/unexpected
std::bad_exception =&gt; cpp/error/bad_exception
std::unexpected_handler =&gt; cpp/error/unexpected_handler
std::get_unexpected =&gt; cpp/error/get_unexpected
std::set_unexpected =&gt; cpp/error/set_unexpected
errno =&gt; cpp/error/errno
E2BIG =&gt; cpp/error/errno_macros
EACCESS =&gt; cpp/error/errno_macros
EADDRINUSE =&gt; cpp/error/errno_macros
EADDRNOTAVAIL =&gt; cpp/error/errno_macros
EAFNOSUPPORT =&gt; cpp/error/errno_macros
EAGAIN =&gt; cpp/error/errno_macros
EALREADY =&gt; cpp/error/errno_macros
EBADF =&gt; cpp/error/errno_macros
EBADMSG =&gt; cpp/error/errno_macros
EBUSY =&gt; cpp/error/errno_macros
ECANCELED =&gt; cpp/error/errno_macros
ECHILD =&gt; cpp/error/errno_macros
ECONNABORTED =&gt; cpp/error/errno_macros
ECONNREFUSED =&gt; cpp/error/errno_macros
ECONNRESET =&gt; cpp/error/errno_macros
EDEADLK =&gt; cpp/error/errno_macros
EDESTADDRREQ =&gt; cpp/error/errno_macros
EDOM =&gt; cpp/error/errno_macros
EEXIST =&gt; cpp/error/errno_macros
EFAULT =&gt; cpp/error/errno_macros
EFBIG =&gt; cpp/error/errno_macros
EHOSTUNREACH =&gt; cpp/error/errno_macros
EIDRM =&gt; cpp/error/errno_macros
EILSEQ =&gt; cpp/error/errno_macros
EINPROGRESS =&gt; cpp/error/errno_macros
EINTR =&gt; cpp/error/errno_macros
EINVAL =&gt; cpp/error/errno_macros
EIO =&gt; cpp/error/errno_macros
EISCONN =&gt; cpp/error/errno_macros
EISDIR =&gt; cpp/error/errno_macros
ELOOP =&gt; cpp/error/errno_macros
EMFILE =&gt; cpp/error/errno_macros
EMLINK =&gt; cpp/error/errno_macros
EMSGSIZE =&gt; cpp/error/errno_macros
ENAMETOOLONG =&gt; cpp/error/errno_macros
ENETDOWN =&gt; cpp/error/errno_macros
ENETRESET =&gt; cpp/error/errno_macros
ENETUNREACH =&gt; cpp/error/errno_macros
ENFILE =&gt; cpp/error/errno_macros
ENOBUFS =&gt; cpp/error/errno_macros
ENODATA =&gt; cpp/error/errno_macros
ENODEV =&gt; cpp/error/errno_macros
ENOENT =&gt; cpp/error/errno_macros
ENOEXEC =&gt; cpp/error/errno_macros
ENOLCK =&gt; cpp/error/errno_macros
ENOLINK =&gt; cpp/error/errno_macros
ENOMEM =&gt; cpp/error/errno_macros
ENOMSG =&gt; cpp/error/errno_macros
ENOPROTOOPT =&gt; cpp/error/errno_macros
ENOSPC =&gt; cpp/error/errno_macros
ENOSR =&gt; cpp/error/errno_macros
ENOSTR =&gt; cpp/error/errno_macros
ENOSYS =&gt; cpp/error/errno_macros
ENOTCONN =&gt; cpp/error/errno_macros
ENOTDIR =&gt; cpp/error/errno_macros
ENOTEMPTY =&gt; cpp/error/errno_macros
ENOTRECOVERABLE =&gt; cpp/error/errno_macros
ENOTSOCK =&gt; cpp/error/errno_macros
ENOTSUP =&gt; cpp/error/errno_macros
ENOTTY =&gt; cpp/error/errno_macros
ENXIO =&gt; cpp/error/errno_macros
EOPNOTSUPP =&gt; cpp/error/errno_macros
EOVERFLOW =&gt; cpp/error/errno_macros
EOWNERDEAD =&gt; cpp/error/errno_macros
EPERM =&gt; cpp/error/errno_macros
EPIPE =&gt; cpp/error/errno_macros
EPROTO =&gt; cpp/error/errno_macros
EPROTONOSUPPORT =&gt; cpp/error/errno_macros
EPROTOTYPE =&gt; cpp/error/errno_macros
ERANGE =&gt; cpp/error/errno_macros
EROFS =&gt; cpp/error/errno_macros
ESPIPE =&gt; cpp/error/errno_macros
ESRCH =&gt; cpp/error/errno_macros
ETIME =&gt; cpp/error/errno_macros
ETIMEDOUT =&gt; cpp/error/errno_macros
ETXTBSY =&gt; cpp/error/errno_macros
EWOULDBLOCK =&gt; cpp/error/errno_macros
EXDEV =&gt; cpp/error/errno_macros
std::error_category =&gt; cpp/error/error_category
std::error_category::error_category =&gt; cpp/error/error_category/error_category
std::error_category::~error_category =&gt; cpp/error/error_category/~error_category
std::error_category::operator= =&gt; cpp/error/error_category/operator=
std::error_category::name =&gt; cpp/error/error_category/name
std::error_category::default_error_condition =&gt; cpp/error/error_category/default_error_condition
std::error_category::equivalent =&gt; cpp/error/error_category/equivalent
std::error_category::message =&gt; cpp/error/error_category/message
std::error_category::operator== =&gt; cpp/error/error_category/operator_cmp
std::error_category::operator!= =&gt; cpp/error/error_category/operator_cmp
std::error_category::operator&lt; =&gt; cpp/error/error_category/operator_cmp
std::generic_category =&gt; cpp/error/generic_category
std::system_category =&gt; cpp/error/system_category
std::error_condition =&gt; cpp/error/error_condition
std::error_condition::error_condition =&gt; cpp/error/error_condition/error_condition
std::error_condition::operator= =&gt; cpp/error/error_condition/operator=
std::error_condition::assign =&gt; cpp/error/error_condition/assign
std::error_condition::clear =&gt; cpp/error/error_condition/clear
std::error_condition::value =&gt; cpp/error/error_condition/value
std::error_condition::category =&gt; cpp/error/error_condition/category
std::error_condition::message =&gt; cpp/error/error_condition/message
std::error_condition::operator bool =&gt; cpp/error/error_condition/operator_bool
operator==(std::error_condition) =&gt; cpp/error/error_condition/operator_cmp
operator!=(std::error_condition) =&gt; cpp/error/error_condition/operator_cmp
operator&lt;(std::error_condition) =&gt; cpp/error/error_condition/operator_cmp
std::is_error_condition_enum =&gt; cpp/error/error_condition/is_error_condition_enum
std::error_code =&gt; cpp/error/error_code
std::error_code::error_code =&gt; cpp/error/error_code/error_code
std::error_code::operator= =&gt; cpp/error/error_code/operator=
std::error_code::assign =&gt; cpp/error/error_code/assign
std::error_code::clear =&gt; cpp/error/error_code/clear
std::error_code::value =&gt; cpp/error/error_code/value
std::error_code::category =&gt; cpp/error/error_code/category
std::error_code::default_error_condition =&gt; cpp/error/error_code/default_error_condition
std::error_code::message =&gt; cpp/error/error_code/message
std::error_code::operator bool =&gt; cpp/error/error_code/operator_bool
operator==(std::error_code) =&gt; cpp/error/error_code/operator_cmp
operator!=(std::error_code) =&gt; cpp/error/error_code/operator_cmp
operator&lt;(std::error_code) =&gt; cpp/error/error_code/operator_cmp
operator&lt;&lt;(std::error_code) =&gt; cpp/error/error_code/operator_ltlt
std::is_error_code_enum =&gt; cpp/error/error_code/is_error_code_enum
std::errc =&gt; cpp/error/errc
std::errc::address_family_not_supported =&gt; cpp/error/errc
std::errc::address_in_use =&gt; cpp/error/errc
std::errc::address_not_available =&gt; cpp/error/errc
std::errc::already_connected =&gt; cpp/error/errc
std::errc::argument_list_too_long =&gt; cpp/error/errc
std::errc::argument_out_of_domain =&gt; cpp/error/errc
std::errc::bad_address =&gt; cpp/error/errc
std::errc::bad_file_descriptor =&gt; cpp/error/errc
std::errc::bad_message =&gt; cpp/error/errc
std::errc::broken_pipe =&gt; cpp/error/errc
std::errc::connection_aborted =&gt; cpp/error/errc
std::errc::connection_already_in_progress =&gt; cpp/error/errc
std::errc::connection_refused =&gt; cpp/error/errc
std::errc::connection_reset =&gt; cpp/error/errc
std::errc::cross_device_link =&gt; cpp/error/errc
std::errc::destination_address_required =&gt; cpp/error/errc
std::errc::device_or_resource_busy =&gt; cpp/error/errc
std::errc::directory_not_empty =&gt; cpp/error/errc
std::errc::executable_format_error =&gt; cpp/error/errc
std::errc::file_exists =&gt; cpp/error/errc
std::errc::file_too_large =&gt; cpp/error/errc
std::errc::filename_too_long =&gt; cpp/error/errc
std::errc::function_not_supported =&gt; cpp/error/errc
std::errc::host_unreachable =&gt; cpp/error/errc
std::errc::identifier_removed =&gt; cpp/error/errc
std::errc::illegal_byte_sequence =&gt; cpp/error/errc
std::errc::inappropriate_io_control_operation =&gt; cpp/error/errc
std::errc::interrupted =&gt; cpp/error/errc
std::errc::invalid_argument =&gt; cpp/error/errc
std::errc::invalid_seek =&gt; cpp/error/errc
std::errc::io_error =&gt; cpp/error/errc
std::errc::is_a_directory =&gt; cpp/error/errc
std::errc::message_size =&gt; cpp/error/errc
std::errc::network_down =&gt; cpp/error/errc
std::errc::network_reset =&gt; cpp/error/errc
std::errc::network_unreachable =&gt; cpp/error/errc
std::errc::no_buffer_space =&gt; cpp/error/errc
std::errc::no_child_process =&gt; cpp/error/errc
std::errc::no_link =&gt; cpp/error/errc
std::errc::no_lock_available =&gt; cpp/error/errc
std::errc::no_message_available =&gt; cpp/error/errc
std::errc::no_message =&gt; cpp/error/errc
std::errc::no_protocol_option =&gt; cpp/error/errc
std::errc::no_space_on_device =&gt; cpp/error/errc
std::errc::no_stream_resources =&gt; cpp/error/errc
std::errc::no_such_device_or_address =&gt; cpp/error/errc
std::errc::no_such_device =&gt; cpp/error/errc
std::errc::no_such_file_or_directory =&gt; cpp/error/errc
std::errc::no_such_process =&gt; cpp/error/errc
std::errc::not_a_directory =&gt; cpp/error/errc
std::errc::not_a_socket =&gt; cpp/error/errc
std::errc::not_a_stream =&gt; cpp/error/errc
std::errc::not_connected =&gt; cpp/error/errc
std::errc::not_enough_memory =&gt; cpp/error/errc
std::errc::not_supported =&gt; cpp/error/errc
std::errc::operation_canceled =&gt; cpp/error/errc
std::errc::operation_in_progress =&gt; cpp/error/errc
std::errc::operation_not_permitted =&gt; cpp/error/errc
std::errc::operation_not_supported =&gt; cpp/error/errc
std::errc::operation_would_block =&gt; cpp/error/errc
std::errc::owner_dead =&gt; cpp/error/errc
std::errc::permission_denied =&gt; cpp/error/errc
std::errc::protocol_error =&gt; cpp/error/errc
std::errc::protocol_not_supported =&gt; cpp/error/errc
std::errc::read_only_file_system =&gt; cpp/error/errc
std::errc::resource_deadlock_would_occur =&gt; cpp/error/errc
std::errc::resource_unavailable_try_again =&gt; cpp/error/errc
std::errc::result_out_of_range =&gt; cpp/error/errc
std::errc::state_not_recoverable =&gt; cpp/error/errc
std::errc::stream_timeout =&gt; cpp/error/errc
std::errc::text_file_busy =&gt; cpp/error/errc
std::errc::timed_out =&gt; cpp/error/errc
std::errc::too_many_files_open_in_system =&gt; cpp/error/errc
std::errc::too_many_files_open =&gt; cpp/error/errc
std::errc::too_many_links =&gt; cpp/error/errc
std::errc::too_many_symbolic_link_levels =&gt; cpp/error/errc
std::errc::value_too_large =&gt; cpp/error/errc
std::errc::wrong_protocol_type =&gt; cpp/error/errc
std::is_error_condition_enum&lt;std::errc&gt; =&gt; cpp/error/errc/is_error_condition_enum
std::make_error_code(std::errc) =&gt; cpp/error/errc/make_error_code
std::make_error_condition(std::errc) =&gt; cpp/error/errc/make_error_condition
std::system_error =&gt; cpp/error/system_error
std::system_error::what =&gt; cpp/error/exception/what
std::system_error::system_error =&gt; cpp/error/system_error/system_error
std::system_error::code =&gt; cpp/error/system_error/code
std::system_error::what =&gt; cpp/error/system_error/what
std::initializer_list =&gt; cpp/utility/initializer_list
std::initializer_list::initializer_list =&gt; cpp/utility/initializer_list/initializer_list
std::initializer_list::size =&gt; cpp/utility/initializer_list/size
std::initializer_list::begin =&gt; cpp/utility/initializer_list/begin
std::initializer_list::end =&gt; cpp/utility/initializer_list/end
std::begin(std::initializer_list) =&gt; cpp/utility/initializer_list/begin2
std::end(std::initializer_list) =&gt; cpp/utility/initializer_list/end2
va_start =&gt; cpp/utility/variadic/va_start
va_copy =&gt; cpp/utility/variadic/va_copy
va_arg =&gt; cpp/utility/variadic/va_arg
va_end =&gt; cpp/utility/variadic/va_end
va_list =&gt; cpp/utility/variadic/va_list
std::abort =&gt; cpp/utility/program/abort
std::exit =&gt; cpp/utility/program/exit
std::quick_exit =&gt; cpp/utility/program/quick_exit
std::_Exit =&gt; cpp/utility/program/_Exit
std::atexit =&gt; cpp/utility/program/atexit
std::at_quick_exit =&gt; cpp/utility/program/at_quick_exit
EXIT_SUCCESS =&gt; cpp/utility/program/EXIT_status
EXIT_FAILURE =&gt; cpp/utility/program/EXIT_status
std::system =&gt; cpp/utility/program/system
std::getenv =&gt; cpp/utility/program/getenv
std::signal =&gt; cpp/utility/program/signal
std::raise =&gt; cpp/utility/program/raise
std::sig_atomic_t =&gt; cpp/utility/program/sig_atomic_t
SIG_DFL =&gt; cpp/utility/program/SIG_strategies
SIG_IGN =&gt; cpp/utility/program/SIG_strategies
SIG_ERR =&gt; cpp/utility/program/SIG_ERR
SIGABRT =&gt; cpp/utility/program/SIG_types
SIGFPE =&gt; cpp/utility/program/SIG_types
SIGILL =&gt; cpp/utility/program/SIG_types
SIGINT =&gt; cpp/utility/program/SIG_types
SIGSEGV =&gt; cpp/utility/program/SIG_types
SIGTERM =&gt; cpp/utility/program/SIG_types
std::longjmp =&gt; cpp/utility/program/longjmp
setjmp =&gt; cpp/utility/program/setjmp
std::jmp_buf =&gt; cpp/utility/program/jmp_buf
std::chrono::time_point =&gt; cpp/chrono/time_point
std::chrono::time_point::time_point =&gt; cpp/chrono/time_point/time_point
std::chrono::time_point::time_since_epoch =&gt; cpp/chrono/time_point/time_since_epoch
std::chrono::time_point::min =&gt; cpp/chrono/time_point/min
std::chrono::time_point::max =&gt; cpp/chrono/time_point/max
std::chrono::time_point::operator+ =&gt; cpp/chrono/time_point/operator_arith
std::chrono::time_point::operator- =&gt; cpp/chrono/time_point/operator_arith
operator+(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_arith2
operator-(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_arith2
operator==(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
operator!=(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
operator&lt;(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
operator&lt;=(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
operator&gt;(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
operator&gt;=(std::chrono::time_point) =&gt; cpp/chrono/time_point/operator_cmp
std::common_type&lt;std::chrono::time_point&gt; =&gt; cpp/chrono/time_point/common_type
std::chrono::time_point_cast =&gt; cpp/chrono/time_point/time_point_cast
std::chrono::duration =&gt; cpp/chrono/duration
std::chrono::duration::duration =&gt; cpp/chrono/duration/duration
std::chrono::duration::~duration =&gt; cpp/chrono/duration/~duration
std::chrono::duration::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::duration::count =&gt; cpp/chrono/duration/count
std::chrono::duration::zero =&gt; cpp/chrono/duration/zero
std::chrono::duration::min =&gt; cpp/chrono/duration/min
std::chrono::duration::max =&gt; cpp/chrono/duration/max
std::chrono::duration::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::duration::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::duration::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::duration::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::duration::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::duration::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::duration::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::duration::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::duration::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::duration::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::duration::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::duration) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::duration) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::duration) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::duration) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::duration) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::duration) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::duration&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::nanoseconds =&gt; cpp/chrono/duration
std::chrono::nanoseconds::nanoseconds =&gt; cpp/chrono/duration/duration
std::chrono::nanoseconds::~nanoseconds =&gt; cpp/chrono/duration/~duration
std::chrono::nanoseconds::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::nanoseconds::count =&gt; cpp/chrono/duration/count
std::chrono::nanoseconds::zero =&gt; cpp/chrono/duration/zero
std::chrono::nanoseconds::min =&gt; cpp/chrono/duration/min
std::chrono::nanoseconds::max =&gt; cpp/chrono/duration/max
std::chrono::nanoseconds::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::nanoseconds::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::nanoseconds::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::nanoseconds::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::nanoseconds::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::nanoseconds::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::nanoseconds::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::nanoseconds::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::nanoseconds::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::nanoseconds::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::nanoseconds::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::nanoseconds) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::nanoseconds&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::microseconds =&gt; cpp/chrono/duration
std::chrono::microseconds::microseconds =&gt; cpp/chrono/duration/duration
std::chrono::microseconds::~microseconds =&gt; cpp/chrono/duration/~duration
std::chrono::microseconds::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::microseconds::count =&gt; cpp/chrono/duration/count
std::chrono::microseconds::zero =&gt; cpp/chrono/duration/zero
std::chrono::microseconds::min =&gt; cpp/chrono/duration/min
std::chrono::microseconds::max =&gt; cpp/chrono/duration/max
std::chrono::microseconds::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::microseconds::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::microseconds::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::microseconds::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::microseconds::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::microseconds::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::microseconds::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::microseconds::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::microseconds::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::microseconds::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::microseconds::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::microseconds) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::microseconds&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::milliseconds =&gt; cpp/chrono/duration
std::chrono::milliseconds::milliseconds =&gt; cpp/chrono/duration/duration
std::chrono::milliseconds::~milliseconds =&gt; cpp/chrono/duration/~duration
std::chrono::milliseconds::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::milliseconds::count =&gt; cpp/chrono/duration/count
std::chrono::milliseconds::zero =&gt; cpp/chrono/duration/zero
std::chrono::milliseconds::min =&gt; cpp/chrono/duration/min
std::chrono::milliseconds::max =&gt; cpp/chrono/duration/max
std::chrono::milliseconds::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::milliseconds::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::milliseconds::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::milliseconds::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::milliseconds::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::milliseconds::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::milliseconds::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::milliseconds::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::milliseconds::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::milliseconds::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::milliseconds::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::milliseconds) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::milliseconds&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::seconds =&gt; cpp/chrono/duration
std::chrono::seconds::seconds =&gt; cpp/chrono/duration/duration
std::chrono::seconds::~seconds =&gt; cpp/chrono/duration/~duration
std::chrono::seconds::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::seconds::count =&gt; cpp/chrono/duration/count
std::chrono::seconds::zero =&gt; cpp/chrono/duration/zero
std::chrono::seconds::min =&gt; cpp/chrono/duration/min
std::chrono::seconds::max =&gt; cpp/chrono/duration/max
std::chrono::seconds::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::seconds::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::seconds::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::seconds::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::seconds::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::seconds::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::seconds::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::seconds::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::seconds::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::seconds::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::seconds::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::seconds) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::seconds&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::minutes =&gt; cpp/chrono/duration
std::chrono::minutes::minutes =&gt; cpp/chrono/duration/duration
std::chrono::minutes::~minutes =&gt; cpp/chrono/duration/~duration
std::chrono::minutes::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::minutes::count =&gt; cpp/chrono/duration/count
std::chrono::minutes::zero =&gt; cpp/chrono/duration/zero
std::chrono::minutes::min =&gt; cpp/chrono/duration/min
std::chrono::minutes::max =&gt; cpp/chrono/duration/max
std::chrono::minutes::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::minutes::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::minutes::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::minutes::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::minutes::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::minutes::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::minutes::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::minutes::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::minutes::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::minutes::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::minutes::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::minutes) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::minutes&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::hours =&gt; cpp/chrono/duration
std::chrono::hours::hours =&gt; cpp/chrono/duration/duration
std::chrono::hours::~hours =&gt; cpp/chrono/duration/~duration
std::chrono::hours::operator= =&gt; cpp/chrono/duration/operator=
std::chrono::hours::count =&gt; cpp/chrono/duration/count
std::chrono::hours::zero =&gt; cpp/chrono/duration/zero
std::chrono::hours::min =&gt; cpp/chrono/duration/min
std::chrono::hours::max =&gt; cpp/chrono/duration/max
std::chrono::hours::operator+ =&gt; cpp/chrono/duration/operator_arith
std::chrono::hours::operator- =&gt; cpp/chrono/duration/operator_arith
std::chrono::hours::operator++ =&gt; cpp/chrono/duration/operator_arith2
std::chrono::hours::operator++(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::hours::operator-- =&gt; cpp/chrono/duration/operator_arith2
std::chrono::hours::operator--(int) =&gt; cpp/chrono/duration/operator_arith2
std::chrono::hours::operator+= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::hours::operator-= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::hours::operator*= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::hours::operator/= =&gt; cpp/chrono/duration/operator_arith3
std::chrono::hours::operator%= =&gt; cpp/chrono/duration/operator_arith3
operator+(std::chrono::hours) =&gt; cpp/chrono/duration/operator_arith4
operator-(std::chrono::hours) =&gt; cpp/chrono/duration/operator_arith4
operator*(std::chrono::hours) =&gt; cpp/chrono/duration/operator_arith4
operator/(std::chrono::hours) =&gt; cpp/chrono/duration/operator_arith4
operator%(std::chrono::hours) =&gt; cpp/chrono/duration/operator_arith4
operator==(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
operator!=(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
operator&lt;=(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
operator&gt;=(std::chrono::hours) =&gt; cpp/chrono/duration/operator_cmp
std::common_type&lt;std::chrono::hours&gt; =&gt; cpp/chrono/duration/common_type
std::chrono::duration_cast =&gt; cpp/chrono/duration/duration_cast
std::chrono::treat_as_floating_point =&gt; cpp/chrono/treat_as_floating_point
std::chrono::duration_values =&gt; cpp/chrono/duration_values
std::chrono::duration_values::zero =&gt; cpp/chrono/duration_values/zero
std::chrono::duration_values::min =&gt; cpp/chrono/duration_values/min
std::chrono::duration_values::max =&gt; cpp/chrono/duration_values/max
std::chrono::system_clock =&gt; cpp/chrono/system_clock
std::chrono::system_clock::is_steady =&gt; cpp/chrono/system_clock
std::chrono::system_clock::now =&gt; cpp/chrono/system_clock/now
std::chrono::system_clock::to_time_t =&gt; cpp/chrono/system_clock/to_time_t
std::chrono::system_clock::from_time_t =&gt; cpp/chrono/system_clock/from_time_t
std::chrono::steady_clock =&gt; cpp/chrono/steady_clock
std::chrono::steady_clock::is_steady =&gt; cpp/chrono/steady_clock
std::chrono::steady_clock::now =&gt; cpp/chrono/steady_clock/now
std::chrono::high_resolution_clock =&gt; cpp/chrono/high_resolution_clock
std::chrono::high_resolution_clock::is_steady =&gt; cpp/chrono/high_resolution_clock
std::chrono::high_resolution_clock::now =&gt; cpp/chrono/high_resolution_clock/now
std::difftime =&gt; cpp/chrono/c/difftime
std::time =&gt; cpp/chrono/c/time
std::clock =&gt; cpp/chrono/c/clock
std::asctime =&gt; cpp/chrono/c/asctime
std::ctime =&gt; cpp/chrono/c/ctime
std::strftime =&gt; cpp/chrono/c/strftime
std::wcsftime =&gt; cpp/chrono/c/wcsftime
std::gmtime =&gt; cpp/chrono/c/gmtime
std::localtime =&gt; cpp/chrono/c/localtime
std::mktime =&gt; cpp/chrono/c/mktime
CLOCKS_PER_SEC =&gt; cpp/chrono/c/CLOCKS_PER_SEC
std::tm =&gt; cpp/chrono/c/tm
std::time_t =&gt; cpp/chrono/c/time_t
std::clock_t =&gt; cpp/chrono/c/clock_t
std::bitset =&gt; cpp/utility/bitset
std::bitset::bitset =&gt; cpp/utility/bitset/bitset
std::bitset::~bitset =&gt; cpp/utility/bitset/~bitset
std::bitset::reference =&gt; cpp/utility/bitset/reference
std::bitset::operator= =&gt; cpp/utility/bitset/operator=
std::bitset::operator== =&gt; cpp/utility/bitset/operator_cmp
std::bitset::operator!= =&gt; cpp/utility/bitset/operator_cmp
std::bitset::operator[] =&gt; cpp/utility/bitset/operator_at
std::bitset::test =&gt; cpp/utility/bitset/test
std::bitset::all =&gt; cpp/utility/bitset/all_any_none
std::bitset::any =&gt; cpp/utility/bitset/all_any_none
std::bitset::none =&gt; cpp/utility/bitset/all_any_none
std::bitset::count =&gt; cpp/utility/bitset/count
std::bitset::size =&gt; cpp/utility/bitset/size
std::bitset::operator&amp;= =&gt; cpp/utility/bitset/operator_logic
std::bitset::operator|= =&gt; cpp/utility/bitset/operator_logic
std::bitset::operator^= =&gt; cpp/utility/bitset/operator_logic
std::bitset::operator~ =&gt; cpp/utility/bitset/operator_logic
std::bitset::operator&lt;&lt;= =&gt; cpp/utility/bitset/operator_ltltgtgt
std::bitset::operator&gt;&gt;= =&gt; cpp/utility/bitset/operator_ltltgtgt
std::bitset::operator&lt;&lt; =&gt; cpp/utility/bitset/operator_ltltgtgt
std::bitset::operator&gt;&gt; =&gt; cpp/utility/bitset/operator_ltltgtgt
std::bitset::set =&gt; cpp/utility/bitset/set
std::bitset::reset =&gt; cpp/utility/bitset/reset
std::bitset::flip =&gt; cpp/utility/bitset/flip
std::bitset::to_string =&gt; cpp/utility/bitset/to_string
std::bitset::to_ulong =&gt; cpp/utility/bitset/to_ulong
std::bitset::to_ullong =&gt; cpp/utility/bitset/to_ullong
operator&amp;(std::bitset) =&gt; cpp/utility/bitset/operator_logic2
operator|(std::bitset) =&gt; cpp/utility/bitset/operator_logic2
operator^(std::bitset) =&gt; cpp/utility/bitset/operator_logic2
operator&lt;&lt;(std::bitset) =&gt; cpp/utility/bitset/operator_ltltgtgt2
operator&gt;&gt;(std::bitset) =&gt; cpp/utility/bitset/operator_ltltgtgt2
std::hash&lt;std::bitset&gt; =&gt; cpp/utility/bitset/hash
std::plus =&gt; cpp/utility/functional/plus
std::plus::operator() =&gt; cpp/utility/functional/plus
std::minus =&gt; cpp/utility/functional/minus
std::minus::operator() =&gt; cpp/utility/functional/minus
std::multiplies =&gt; cpp/utility/functional/multiplies
std::multiplies::operator() =&gt; cpp/utility/functional/multiplies
std::divides =&gt; cpp/utility/functional/divides
std::divides::operator() =&gt; cpp/utility/functional/divides
std::modulus =&gt; cpp/utility/functional/modulus
std::modulus::operator() =&gt; cpp/utility/functional/modulus
std::negate =&gt; cpp/utility/functional/negate
std::negate::operator() =&gt; cpp/utility/functional/negate
std::equal_to =&gt; cpp/utility/functional/equal_to
std::equal_to::operator() =&gt; cpp/utility/functional/equal_to
std::not_equal_to =&gt; cpp/utility/functional/not_equal_to
std::not_equal_to::operator() =&gt; cpp/utility/functional/not_equal_to
std::greater =&gt; cpp/utility/functional/greater
std::greater::operator() =&gt; cpp/utility/functional/greater
std::greater_equal =&gt; cpp/utility/functional/greater_equal
std::greater_equal::operator() =&gt; cpp/utility/functional/greater_equal
std::less =&gt; cpp/utility/functional/less
std::less::operator() =&gt; cpp/utility/functional/less
std::less_equal =&gt; cpp/utility/functional/less_equal
std::less_equal::operator() =&gt; cpp/utility/functional/less_equal
std::logical_and =&gt; cpp/utility/functional/logical_and
std::logical_and::operator() =&gt; cpp/utility/functional/logical_and
std::logical_or =&gt; cpp/utility/functional/logical_or
std::logical_or::operator() =&gt; cpp/utility/functional/logical_or
std::logical_not =&gt; cpp/utility/functional/logical_not
std::logical_not::operator() =&gt; cpp/utility/functional/logical_not
std::bit_and =&gt; cpp/utility/functional/bit_and
std::bit_and::operator() =&gt; cpp/utility/functional/bit_and
std::bit_or =&gt; cpp/utility/functional/bit_or
std::bit_or::operator() =&gt; cpp/utility/functional/bit_or
std::bit_not =&gt; cpp/utility/functional/bit_not
std::bit_not::operator() =&gt; cpp/utility/functional/bit_not
std::unary_negate =&gt; cpp/utility/functional/unary_negate
std::unary_negate::unary_negate =&gt; cpp/utility/functional/unary_negate/unary_negate
std::unary_negate::operator() =&gt; cpp/utility/functional/unary_negate
std::binary_negate =&gt; cpp/utility/functional/binary_negate
std::binary_negate::binary_negate =&gt; cpp/utility/functional/binary_negate/binary_negate
std::binary_negate::operator() =&gt; cpp/utility/functional/binary_negate
std::not1 =&gt; cpp/utility/functional/not1
std::not2 =&gt; cpp/utility/functional/not2
std::bind =&gt; cpp/utility/functional/bind
std::is_bind_expression =&gt; cpp/utility/functional/is_bind_expression
std::is_placeholder =&gt; cpp/utility/functional/is_placeholder
std::mem_fn =&gt; cpp/utility/functional/mem_fn
std::function =&gt; cpp/utility/functional/function
std::function::function =&gt; cpp/utility/functional/function/function
std::function::~function =&gt; cpp/utility/functional/function/~function
std::function::operator= =&gt; cpp/utility/functional/function/operator=
std::function::swap =&gt; cpp/utility/functional/function/swap
std::function::assign =&gt; cpp/utility/functional/function/assign
std::function::operator bool =&gt; cpp/utility/functional/function/operator_bool
std::function::operator() =&gt; cpp/utility/functional/function/operator()
std::function::target_type =&gt; cpp/utility/functional/function/target_type
std::function::target =&gt; cpp/utility/functional/function/target
std::swap(std::function) =&gt; cpp/utility/functional/function/swap
operator==(std::function) =&gt; cpp/utility/functional/function/operator_cmp
operator!=(std::function) =&gt; cpp/utility/functional/function/operator_cmp
std::uses_allocator&lt;std::function&gt; =&gt; cpp/utility/functional/function/uses_allocator
std::bad_function_call =&gt; cpp/utility/functional/bad_function_call
std::bad_function_call::what =&gt; cpp/error/exception/what
std::bad_function_call::bad_function_call =&gt; cpp/utility/functional/bad_function_call/bad_function_call
std::bad_function_call::what =&gt; cpp/utility/functional/bad_function_call/what
std::placeholders =&gt; cpp/utility/functional/placeholders
std::reference_wrapper =&gt; cpp/utility/functional/reference_wrapper
std::reference_wrapper::reference_wrapper =&gt; cpp/utility/functional/reference_wrapper/reference_wrapper
std::reference_wrapper::operator= =&gt; cpp/utility/functional/reference_wrapper/operator=
std::reference_wrapper::operator T&amp; =&gt; cpp/utility/functional/reference_wrapper/get
std::reference_wrapper::get =&gt; cpp/utility/functional/reference_wrapper/get
std::reference_wrapper::operator() =&gt; cpp/utility/functional/reference_wrapper/operator()
std::ref =&gt; cpp/utility/functional/ref
std::cref =&gt; cpp/utility/functional/ref
std::pair =&gt; cpp/utility/pair
std::pair::pair =&gt; cpp/utility/pair/pair
std::pair::operator= =&gt; cpp/utility/pair/operator=
std::pair::swap =&gt; cpp/utility/pair/swap
operator==(std::pair) =&gt; cpp/utility/pair/operator_cmp
operator!=(std::pair) =&gt; cpp/utility/pair/operator_cmp
operator&lt;(std::pair) =&gt; cpp/utility/pair/operator_cmp
operator&lt;=(std::pair) =&gt; cpp/utility/pair/operator_cmp
operator&gt;(std::pair) =&gt; cpp/utility/pair/operator_cmp
operator&gt;=(std::pair) =&gt; cpp/utility/pair/operator_cmp
std::swap(std::pair) =&gt; cpp/utility/pair/swap2
std::get(std::pair) =&gt; cpp/utility/pair/get
std::tuple_size&lt;std::pair&gt; =&gt; cpp/utility/pair/tuple_size
std::tuple_element&lt;std::pair&gt; =&gt; cpp/utility/pair/tuple_element
std::make_pair =&gt; cpp/utility/pair/make_pair
std::tuple =&gt; cpp/utility/tuple
std::tuple::tuple =&gt; cpp/utility/tuple/tuple
std::tuple::operator= =&gt; cpp/utility/tuple/operator=
std::tuple::swap =&gt; cpp/utility/tuple/swap
operator==(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
operator!=(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
operator&lt;(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
operator&lt;=(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
operator&gt;(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
operator&gt;=(std::tuple) =&gt; cpp/utility/tuple/operator_cmp
std::swap(std::tuple) =&gt; cpp/utility/tuple/swap2
std::get(std::tuple) =&gt; cpp/utility/tuple/get
std::tuple_size&lt;std::tuple&gt; =&gt; cpp/utility/tuple/tuple_size
std::tuple_element&lt;std::tuple&gt; =&gt; cpp/utility/tuple/tuple_element
std::uses_allocator&lt;std::tuple&gt; =&gt; cpp/utility/tuple/uses_allocator
std::piecewise_construct_t =&gt; cpp/utility/piecewise_construct_t
std::piecewise_construct =&gt; cpp/utility/piecewise_construct
std::integer_sequence =&gt; cpp/utility/integer_sequence
std::make_tuple =&gt; cpp/utility/tuple/make_tuple
std::tie =&gt; cpp/utility/tuple/tie
std::forward_as_tuple =&gt; cpp/utility/tuple/forward_as_tuple
std::tuple_cat =&gt; cpp/utility/tuple/tuple_cat
std::tuple_cat =&gt; cpp/utility/tuple/tuple_cat
std::ignore =&gt; cpp/utility/tuple/ignore
std::forward =&gt; cpp/utility/forward
std::move =&gt; cpp/utility/move
std::move_if_noexcept =&gt; cpp/utility/move_if_noexcept
std::declval =&gt; cpp/utility/declval
std::rel_ops::operator!= =&gt; cpp/utility/rel_ops/operator_cmp
std::rel_ops::operator&gt; =&gt; cpp/utility/rel_ops/operator_cmp
std::rel_ops::operator&lt;= =&gt; cpp/utility/rel_ops/operator_cmp
std::rel_ops::operator&gt;= =&gt; cpp/utility/rel_ops/operator_cmp
std::hash =&gt; cpp/utility/hash
std::hash::hash =&gt; cpp/utility/hash/hash
std::hash::operator() =&gt; cpp/utility/hash/operator()
std::unary_function =&gt; cpp/utility/functional/unary_function
std::binary_function =&gt; cpp/utility/functional/binary_function
std::optional =&gt; cpp/utility/optional
std::optional::optional =&gt; cpp/utility/optional/optional
std::optional::~optional =&gt; cpp/utility/optional/~optional
std::optional::operator= =&gt; cpp/utility/optional/operator=
std::optional::operator* =&gt; cpp/utility/optional/operator*
std::optional::operator-&gt; =&gt; cpp/utility/optional/operator*
std::optional::operator bool =&gt; cpp/utility/optional/operator_bool
std::optional::value =&gt; cpp/utility/optional/value
std::optional::value_or =&gt; cpp/utility/optional/value_or
std::optional::swap =&gt; cpp/utility/optional/swap
std::optional::emplace =&gt; cpp/utility/optional/emplace
operator==(std::optional) =&gt; cpp/utility/optional/operator_cmp
operator&lt;(std::optional) =&gt; cpp/utility/optional/operator_cmp
std::swap(std::optional) =&gt; cpp/utility/optional/swap2
std::hash&lt;std::optional&gt; =&gt; cpp/utility/optional/hash
std::make_optional =&gt; cpp/utility/optional/make_optional
std::inplace_t =&gt; cpp/utility/inplace_t
std::inplace =&gt; cpp/utility/inplace
std::nullopt_t =&gt; cpp/utility/nullopt_t
std::nullopt =&gt; cpp/utility/nullopt
std::bad_optional_access =&gt; cpp/utility/bad_optional_access
std::bad_optional_access::what =&gt; cpp/error/exception/what
std::bad_optional_access::bad_optional_access =&gt; cpp/utility/bad_optional_access
std::isalnum =&gt; cpp/string/byte/isalnum
std::isalpha =&gt; cpp/string/byte/isalpha
std::islower =&gt; cpp/string/byte/islower
std::isupper =&gt; cpp/string/byte/isupper
std::isdigit =&gt; cpp/string/byte/isdigit
std::isxdigit =&gt; cpp/string/byte/isxdigit
std::iscntrl =&gt; cpp/string/byte/iscntrl
std::isgraph =&gt; cpp/string/byte/isgraph
std::isspace =&gt; cpp/string/byte/isspace
std::isblank =&gt; cpp/string/byte/isblank
std::isprint =&gt; cpp/string/byte/isprint
std::ispunct =&gt; cpp/string/byte/ispunct
std::tolower =&gt; cpp/string/byte/tolower
std::toupper =&gt; cpp/string/byte/toupper
std::atof =&gt; cpp/string/byte/atof
std::atoi =&gt; cpp/string/byte/atoi
std::atol =&gt; cpp/string/byte/atoi
std::atoll =&gt; cpp/string/byte/atoi
std::strtol =&gt; cpp/string/byte/strtol
std::strtoll =&gt; cpp/string/byte/strtol
std::strtoul =&gt; cpp/string/byte/strtoul
std::strtoull =&gt; cpp/string/byte/strtoul
std::strtof =&gt; cpp/string/byte/strtof
std::strtod =&gt; cpp/string/byte/strtof
std::strtold =&gt; cpp/string/byte/strtof
std::strtoimax =&gt; cpp/string/byte/strtoimax
std::strtoumax =&gt; cpp/string/byte/strtoimax
std::strcpy =&gt; cpp/string/byte/strcpy
std::strncpy =&gt; cpp/string/byte/strncpy
std::strcat =&gt; cpp/string/byte/strcat
std::strncat =&gt; cpp/string/byte/strncat
std::strxfrm =&gt; cpp/string/byte/strxfrm
std::strlen =&gt; cpp/string/byte/strlen
std::strcmp =&gt; cpp/string/byte/strcmp
std::strncmp =&gt; cpp/string/byte/strncmp
std::strcoll =&gt; cpp/string/byte/strcoll
std::strchr =&gt; cpp/string/byte/strchr
std::strrchr =&gt; cpp/string/byte/strrchr
std::strspn =&gt; cpp/string/byte/strspn
std::strcspn =&gt; cpp/string/byte/strcspn
std::strpbrk =&gt; cpp/string/byte/strpbrk
std::strstr =&gt; cpp/string/byte/strstr
std::strtok =&gt; cpp/string/byte/strtok
std::memchr =&gt; cpp/string/byte/memchr
std::memcmp =&gt; cpp/string/byte/memcmp
std::memset =&gt; cpp/string/byte/memset
std::memcpy =&gt; cpp/string/byte/memcpy
std::memmove =&gt; cpp/string/byte/memmove
std::strerror =&gt; cpp/string/byte/strerror
std::mblen =&gt; cpp/string/multibyte/mblen
std::mbtowc =&gt; cpp/string/multibyte/mbtowc
std::wctomb =&gt; cpp/string/multibyte/wctomb
std::mbstowcs =&gt; cpp/string/multibyte/mbstowcs
std::wcstombs =&gt; cpp/string/multibyte/wcstombs
std::mbsinit =&gt; cpp/string/multibyte/mbsinit
std::btowc =&gt; cpp/string/multibyte/btowc
std::wctob =&gt; cpp/string/multibyte/wctob
std::mbrlen =&gt; cpp/string/multibyte/mbrlen
std::mbrtowc =&gt; cpp/string/multibyte/mbrtowc
std::wcrtomb =&gt; cpp/string/multibyte/wcrtomb
std::mbsrtowcs =&gt; cpp/string/multibyte/mbsrtowcs
std::wcstombs =&gt; cpp/string/multibyte/wcstombs
std::mbrtoc16 =&gt; cpp/string/multibyte/mbrtoc16
std::c16rtomb =&gt; cpp/string/multibyte/c16rtomb
std::mbrtoc32 =&gt; cpp/string/multibyte/mbrtoc32
std::c32rtomb =&gt; cpp/string/multibyte/c32rtomb
std::mbstate_t =&gt; cpp/string/multibyte/mbstate_t
std::iswalnum =&gt; cpp/string/wide/iswalnum
std::iswalpha =&gt; cpp/string/wide/iswalpha
std::iswlower =&gt; cpp/string/wide/iswlower
std::iswupper =&gt; cpp/string/wide/iswupper
std::iswdigit =&gt; cpp/string/wide/iswdigit
std::iswxdigit =&gt; cpp/string/wide/iswxdigit
std::iswcntrl =&gt; cpp/string/wide/iswcntrl
std::iswgraph =&gt; cpp/string/wide/iswgraph
std::iswspace =&gt; cpp/string/wide/iswspace
std::iswblank =&gt; cpp/string/wide/iswblank
std::iswprint =&gt; cpp/string/wide/iswprint
std::iswpunct =&gt; cpp/string/wide/iswpunct
std::iswctype =&gt; cpp/string/wide/iswctype
std::wctype =&gt; cpp/string/wide/wctype
std::towlower =&gt; cpp/string/wide/towlower
std::towupper =&gt; cpp/string/wide/towupper
std::towctrans =&gt; cpp/string/wide/towctrans
std::wctrans =&gt; cpp/string/wide/wctrans
std::wcstof =&gt; cpp/string/wide/wcstof
std::wcstod =&gt; cpp/string/wide/wcstof
std::wcstold =&gt; cpp/string/wide/wcstof
std::wcstol =&gt; cpp/string/wide/wcstol
std::wcstoll =&gt; cpp/string/wide/wcstol
std::wcstoul =&gt; cpp/string/wide/wcstoul
std::wcstoull =&gt; cpp/string/wide/wcstoul
std::wcstoimax =&gt; cpp/string/wide/wcstoimax
std::wcstoumax =&gt; cpp/string/wide/wcstoimax
std::wcscpy =&gt; cpp/string/wide/wcscpy
std::wcsncpy =&gt; cpp/string/wide/wcsncpy
std::wcscat =&gt; cpp/string/wide/wcscat
std::wcsncat =&gt; cpp/string/wide/wcsncat
std::wcsxfrm =&gt; cpp/string/wide/wcsxfrm
std::wcslen =&gt; cpp/string/wide/wcslen
std::wcscmp =&gt; cpp/string/wide/wcscmp
std::wcsncmp =&gt; cpp/string/wide/wcsncmp
std::wcscoll =&gt; cpp/string/wide/wcscoll
std::wcschr =&gt; cpp/string/wide/wcschr
std::wcsrchr =&gt; cpp/string/wide/wcsrchr
std::wcsspn =&gt; cpp/string/wide/wcsspn
std::wcscspn =&gt; cpp/string/wide/wcscspn
std::wcspbrk =&gt; cpp/string/wide/wcspbrk
std::wcsstr =&gt; cpp/string/wide/wcsstr
std::wcstok =&gt; cpp/string/wide/wcstok
std::wmemchr =&gt; cpp/string/wide/wmemchr
std::wmemcmp =&gt; cpp/string/wide/wmemcmp
std::wmemset =&gt; cpp/string/wide/wmemset
std::wmemcpy =&gt; cpp/string/wide/wmemcpy
std::wmemmove =&gt; cpp/string/wide/wmemmove
std::basic_string =&gt; cpp/string/basic_string
std::basic_string::basic_string =&gt; cpp/string/basic_string/basic_string
std::basic_string::assign =&gt; cpp/string/basic_string/assign
std::basic_string::operator= =&gt; cpp/string/basic_string/operator=
std::basic_string::get_allocator =&gt; cpp/string/basic_string/get_allocator
std::basic_string::at =&gt; cpp/string/basic_string/at
std::basic_string::operator[] =&gt; cpp/string/basic_string/operator_at
std::basic_string::front =&gt; cpp/string/basic_string/front
std::basic_string::back =&gt; cpp/string/basic_string/back
std::basic_string::data =&gt; cpp/string/basic_string/data
std::basic_string::c_str =&gt; cpp/string/basic_string/c_str
std::basic_string::begin =&gt; cpp/string/basic_string/begin
std::basic_string::cbegin =&gt; cpp/string/basic_string/begin
std::basic_string::end =&gt; cpp/string/basic_string/end
std::basic_string::cend =&gt; cpp/string/basic_string/end
std::basic_string::rbegin =&gt; cpp/string/basic_string/rbegin
std::basic_string::crbegin =&gt; cpp/string/basic_string/rbegin
std::basic_string::rend =&gt; cpp/string/basic_string/rend
std::basic_string::crend =&gt; cpp/string/basic_string/rend
std::basic_string::empty =&gt; cpp/string/basic_string/empty
std::basic_string::size =&gt; cpp/string/basic_string/size
std::basic_string::length =&gt; cpp/string/basic_string/size
std::basic_string::max_size =&gt; cpp/string/basic_string/max_size
std::basic_string::reserve =&gt; cpp/string/basic_string/reserve
std::basic_string::capacity =&gt; cpp/string/basic_string/capacity
std::basic_string::shrink_to_fit =&gt; cpp/string/basic_string/shrink_to_fit
std::basic_string::clear =&gt; cpp/string/basic_string/clear
std::basic_string::insert =&gt; cpp/string/basic_string/insert
std::basic_string::erase =&gt; cpp/string/basic_string/erase
std::basic_string::push_back =&gt; cpp/string/basic_string/push_back
std::basic_string::pop_back =&gt; cpp/string/basic_string/pop_back
std::basic_string::append =&gt; cpp/string/basic_string/append
std::basic_string::compare =&gt; cpp/string/basic_string/compare
std::basic_string::replace =&gt; cpp/string/basic_string/replace
std::basic_string::substr =&gt; cpp/string/basic_string/substr
std::basic_string::copy =&gt; cpp/string/basic_string/copy
std::basic_string::resize =&gt; cpp/string/basic_string/resize
std::basic_string::swap =&gt; cpp/string/basic_string/swap
std::basic_string::find =&gt; cpp/string/basic_string/find
std::basic_string::rfind =&gt; cpp/string/basic_string/rfind
std::basic_string::find_first_of =&gt; cpp/string/basic_string/find_first_of
std::basic_string::find_first_not_of =&gt; cpp/string/basic_string/find_first_not_of
std::basic_string::find_last_of =&gt; cpp/string/basic_string/find_last_of
std::basic_string::find_last_not_of =&gt; cpp/string/basic_string/find_last_not_of
std::basic_string::npos =&gt; cpp/string/basic_string/npos
operator+(std::basic_string) =&gt; cpp/string/basic_string/operator+
operator==(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
operator!=(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;=(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;=(std::basic_string) =&gt; cpp/string/basic_string/operator_cmp
std::swap(std::basic_string) =&gt; cpp/string/basic_string/swap2
operator&lt;&lt;(std::basic_string) =&gt; cpp/string/basic_string/operator_ltltgtgt
operator&gt;&gt;(std::basic_string) =&gt; cpp/string/basic_string/operator_ltltgtgt
std::hash&lt;std::basic_string&gt; =&gt; cpp/string/basic_string/hash
std::string =&gt; cpp/string/basic_string
std::string::string =&gt; cpp/string/basic_string/basic_string
std::string::assign =&gt; cpp/string/basic_string/assign
std::string::operator= =&gt; cpp/string/basic_string/operator=
std::string::get_allocator =&gt; cpp/string/basic_string/get_allocator
std::string::at =&gt; cpp/string/basic_string/at
std::string::operator[] =&gt; cpp/string/basic_string/operator_at
std::string::front =&gt; cpp/string/basic_string/front
std::string::back =&gt; cpp/string/basic_string/back
std::string::data =&gt; cpp/string/basic_string/data
std::string::c_str =&gt; cpp/string/basic_string/c_str
std::string::begin =&gt; cpp/string/basic_string/begin
std::string::cbegin =&gt; cpp/string/basic_string/begin
std::string::end =&gt; cpp/string/basic_string/end
std::string::cend =&gt; cpp/string/basic_string/end
std::string::rbegin =&gt; cpp/string/basic_string/rbegin
std::string::crbegin =&gt; cpp/string/basic_string/rbegin
std::string::rend =&gt; cpp/string/basic_string/rend
std::string::crend =&gt; cpp/string/basic_string/rend
std::string::empty =&gt; cpp/string/basic_string/empty
std::string::size =&gt; cpp/string/basic_string/size
std::string::length =&gt; cpp/string/basic_string/size
std::string::max_size =&gt; cpp/string/basic_string/max_size
std::string::reserve =&gt; cpp/string/basic_string/reserve
std::string::capacity =&gt; cpp/string/basic_string/capacity
std::string::shrink_to_fit =&gt; cpp/string/basic_string/shrink_to_fit
std::string::clear =&gt; cpp/string/basic_string/clear
std::string::insert =&gt; cpp/string/basic_string/insert
std::string::erase =&gt; cpp/string/basic_string/erase
std::string::push_back =&gt; cpp/string/basic_string/push_back
std::string::pop_back =&gt; cpp/string/basic_string/pop_back
std::string::append =&gt; cpp/string/basic_string/append
std::string::compare =&gt; cpp/string/basic_string/compare
std::string::replace =&gt; cpp/string/basic_string/replace
std::string::substr =&gt; cpp/string/basic_string/substr
std::string::copy =&gt; cpp/string/basic_string/copy
std::string::resize =&gt; cpp/string/basic_string/resize
std::string::swap =&gt; cpp/string/basic_string/swap
std::string::find =&gt; cpp/string/basic_string/find
std::string::rfind =&gt; cpp/string/basic_string/rfind
std::string::find_first_of =&gt; cpp/string/basic_string/find_first_of
std::string::find_first_not_of =&gt; cpp/string/basic_string/find_first_not_of
std::string::find_last_of =&gt; cpp/string/basic_string/find_last_of
std::string::find_last_not_of =&gt; cpp/string/basic_string/find_last_not_of
std::string::npos =&gt; cpp/string/basic_string/npos
operator+(std::string) =&gt; cpp/string/basic_string/operator+
operator==(std::string) =&gt; cpp/string/basic_string/operator_cmp
operator!=(std::string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;(std::string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;=(std::string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;(std::string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;=(std::string) =&gt; cpp/string/basic_string/operator_cmp
std::swap(std::string) =&gt; cpp/string/basic_string/swap2
operator&lt;&lt;(std::string) =&gt; cpp/string/basic_string/operator_ltltgtgt
operator&gt;&gt;(std::string) =&gt; cpp/string/basic_string/operator_ltltgtgt
std::hash&lt;std::string&gt; =&gt; cpp/string/basic_string/hash
std::wstring =&gt; cpp/string/basic_string
std::wstring::wstring =&gt; cpp/string/basic_string/basic_string
std::wstring::assign =&gt; cpp/string/basic_string/assign
std::wstring::operator= =&gt; cpp/string/basic_string/operator=
std::wstring::get_allocator =&gt; cpp/string/basic_string/get_allocator
std::wstring::at =&gt; cpp/string/basic_string/at
std::wstring::operator[] =&gt; cpp/string/basic_string/operator_at
std::wstring::front =&gt; cpp/string/basic_string/front
std::wstring::back =&gt; cpp/string/basic_string/back
std::wstring::data =&gt; cpp/string/basic_string/data
std::wstring::c_str =&gt; cpp/string/basic_string/c_str
std::wstring::begin =&gt; cpp/string/basic_string/begin
std::wstring::cbegin =&gt; cpp/string/basic_string/begin
std::wstring::end =&gt; cpp/string/basic_string/end
std::wstring::cend =&gt; cpp/string/basic_string/end
std::wstring::rbegin =&gt; cpp/string/basic_string/rbegin
std::wstring::crbegin =&gt; cpp/string/basic_string/rbegin
std::wstring::rend =&gt; cpp/string/basic_string/rend
std::wstring::crend =&gt; cpp/string/basic_string/rend
std::wstring::empty =&gt; cpp/string/basic_string/empty
std::wstring::size =&gt; cpp/string/basic_string/size
std::wstring::length =&gt; cpp/string/basic_string/size
std::wstring::max_size =&gt; cpp/string/basic_string/max_size
std::wstring::reserve =&gt; cpp/string/basic_string/reserve
std::wstring::capacity =&gt; cpp/string/basic_string/capacity
std::wstring::shrink_to_fit =&gt; cpp/string/basic_string/shrink_to_fit
std::wstring::clear =&gt; cpp/string/basic_string/clear
std::wstring::insert =&gt; cpp/string/basic_string/insert
std::wstring::erase =&gt; cpp/string/basic_string/erase
std::wstring::push_back =&gt; cpp/string/basic_string/push_back
std::wstring::pop_back =&gt; cpp/string/basic_string/pop_back
std::wstring::append =&gt; cpp/string/basic_string/append
std::wstring::compare =&gt; cpp/string/basic_string/compare
std::wstring::replace =&gt; cpp/string/basic_string/replace
std::wstring::substr =&gt; cpp/string/basic_string/substr
std::wstring::copy =&gt; cpp/string/basic_string/copy
std::wstring::resize =&gt; cpp/string/basic_string/resize
std::wstring::swap =&gt; cpp/string/basic_string/swap
std::wstring::find =&gt; cpp/string/basic_string/find
std::wstring::rfind =&gt; cpp/string/basic_string/rfind
std::wstring::find_first_of =&gt; cpp/string/basic_string/find_first_of
std::wstring::find_first_not_of =&gt; cpp/string/basic_string/find_first_not_of
std::wstring::find_last_of =&gt; cpp/string/basic_string/find_last_of
std::wstring::find_last_not_of =&gt; cpp/string/basic_string/find_last_not_of
std::wstring::npos =&gt; cpp/string/basic_string/npos
operator+(std::wstring) =&gt; cpp/string/basic_string/operator+
operator==(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
operator!=(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;=(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;=(std::wstring) =&gt; cpp/string/basic_string/operator_cmp
std::swap(std::wstring) =&gt; cpp/string/basic_string/swap2
operator&lt;&lt;(std::wstring) =&gt; cpp/string/basic_string/operator_ltltgtgt
operator&gt;&gt;(std::wstring) =&gt; cpp/string/basic_string/operator_ltltgtgt
std::hash&lt;std::wstring&gt; =&gt; cpp/string/basic_string/hash
std::u16string =&gt; cpp/string/basic_string
std::u16string::u16string =&gt; cpp/string/basic_string/basic_string
std::u16string::assign =&gt; cpp/string/basic_string/assign
std::u16string::operator= =&gt; cpp/string/basic_string/operator=
std::u16string::get_allocator =&gt; cpp/string/basic_string/get_allocator
std::u16string::at =&gt; cpp/string/basic_string/at
std::u16string::operator[] =&gt; cpp/string/basic_string/operator_at
std::u16string::front =&gt; cpp/string/basic_string/front
std::u16string::back =&gt; cpp/string/basic_string/back
std::u16string::data =&gt; cpp/string/basic_string/data
std::u16string::c_str =&gt; cpp/string/basic_string/c_str
std::u16string::begin =&gt; cpp/string/basic_string/begin
std::u16string::cbegin =&gt; cpp/string/basic_string/begin
std::u16string::end =&gt; cpp/string/basic_string/end
std::u16string::cend =&gt; cpp/string/basic_string/end
std::u16string::rbegin =&gt; cpp/string/basic_string/rbegin
std::u16string::crbegin =&gt; cpp/string/basic_string/rbegin
std::u16string::rend =&gt; cpp/string/basic_string/rend
std::u16string::crend =&gt; cpp/string/basic_string/rend
std::u16string::empty =&gt; cpp/string/basic_string/empty
std::u16string::size =&gt; cpp/string/basic_string/size
std::u16string::length =&gt; cpp/string/basic_string/size
std::u16string::max_size =&gt; cpp/string/basic_string/max_size
std::u16string::reserve =&gt; cpp/string/basic_string/reserve
std::u16string::capacity =&gt; cpp/string/basic_string/capacity
std::u16string::shrink_to_fit =&gt; cpp/string/basic_string/shrink_to_fit
std::u16string::clear =&gt; cpp/string/basic_string/clear
std::u16string::insert =&gt; cpp/string/basic_string/insert
std::u16string::erase =&gt; cpp/string/basic_string/erase
std::u16string::push_back =&gt; cpp/string/basic_string/push_back
std::u16string::pop_back =&gt; cpp/string/basic_string/pop_back
std::u16string::append =&gt; cpp/string/basic_string/append
std::u16string::compare =&gt; cpp/string/basic_string/compare
std::u16string::replace =&gt; cpp/string/basic_string/replace
std::u16string::substr =&gt; cpp/string/basic_string/substr
std::u16string::copy =&gt; cpp/string/basic_string/copy
std::u16string::resize =&gt; cpp/string/basic_string/resize
std::u16string::swap =&gt; cpp/string/basic_string/swap
std::u16string::find =&gt; cpp/string/basic_string/find
std::u16string::rfind =&gt; cpp/string/basic_string/rfind
std::u16string::find_first_of =&gt; cpp/string/basic_string/find_first_of
std::u16string::find_first_not_of =&gt; cpp/string/basic_string/find_first_not_of
std::u16string::find_last_of =&gt; cpp/string/basic_string/find_last_of
std::u16string::find_last_not_of =&gt; cpp/string/basic_string/find_last_not_of
std::u16string::npos =&gt; cpp/string/basic_string/npos
operator+(std::u16string) =&gt; cpp/string/basic_string/operator+
operator==(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
operator!=(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;=(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;=(std::u16string) =&gt; cpp/string/basic_string/operator_cmp
std::swap(std::u16string) =&gt; cpp/string/basic_string/swap2
operator&lt;&lt;(std::u16string) =&gt; cpp/string/basic_string/operator_ltltgtgt
operator&gt;&gt;(std::u16string) =&gt; cpp/string/basic_string/operator_ltltgtgt
std::hash&lt;std::u16string&gt; =&gt; cpp/string/basic_string/hash
std::u32string =&gt; cpp/string/basic_string
std::u32string::u32string =&gt; cpp/string/basic_string/basic_string
std::u32string::assign =&gt; cpp/string/basic_string/assign
std::u32string::operator= =&gt; cpp/string/basic_string/operator=
std::u32string::get_allocator =&gt; cpp/string/basic_string/get_allocator
std::u32string::at =&gt; cpp/string/basic_string/at
std::u32string::operator[] =&gt; cpp/string/basic_string/operator_at
std::u32string::front =&gt; cpp/string/basic_string/front
std::u32string::back =&gt; cpp/string/basic_string/back
std::u32string::data =&gt; cpp/string/basic_string/data
std::u32string::c_str =&gt; cpp/string/basic_string/c_str
std::u32string::begin =&gt; cpp/string/basic_string/begin
std::u32string::cbegin =&gt; cpp/string/basic_string/begin
std::u32string::end =&gt; cpp/string/basic_string/end
std::u32string::cend =&gt; cpp/string/basic_string/end
std::u32string::rbegin =&gt; cpp/string/basic_string/rbegin
std::u32string::crbegin =&gt; cpp/string/basic_string/rbegin
std::u32string::rend =&gt; cpp/string/basic_string/rend
std::u32string::crend =&gt; cpp/string/basic_string/rend
std::u32string::empty =&gt; cpp/string/basic_string/empty
std::u32string::size =&gt; cpp/string/basic_string/size
std::u32string::length =&gt; cpp/string/basic_string/size
std::u32string::max_size =&gt; cpp/string/basic_string/max_size
std::u32string::reserve =&gt; cpp/string/basic_string/reserve
std::u32string::capacity =&gt; cpp/string/basic_string/capacity
std::u32string::shrink_to_fit =&gt; cpp/string/basic_string/shrink_to_fit
std::u32string::clear =&gt; cpp/string/basic_string/clear
std::u32string::insert =&gt; cpp/string/basic_string/insert
std::u32string::erase =&gt; cpp/string/basic_string/erase
std::u32string::push_back =&gt; cpp/string/basic_string/push_back
std::u32string::pop_back =&gt; cpp/string/basic_string/pop_back
std::u32string::append =&gt; cpp/string/basic_string/append
std::u32string::compare =&gt; cpp/string/basic_string/compare
std::u32string::replace =&gt; cpp/string/basic_string/replace
std::u32string::substr =&gt; cpp/string/basic_string/substr
std::u32string::copy =&gt; cpp/string/basic_string/copy
std::u32string::resize =&gt; cpp/string/basic_string/resize
std::u32string::swap =&gt; cpp/string/basic_string/swap
std::u32string::find =&gt; cpp/string/basic_string/find
std::u32string::rfind =&gt; cpp/string/basic_string/rfind
std::u32string::find_first_of =&gt; cpp/string/basic_string/find_first_of
std::u32string::find_first_not_of =&gt; cpp/string/basic_string/find_first_not_of
std::u32string::find_last_of =&gt; cpp/string/basic_string/find_last_of
std::u32string::find_last_not_of =&gt; cpp/string/basic_string/find_last_not_of
std::u32string::npos =&gt; cpp/string/basic_string/npos
operator+(std::u32string) =&gt; cpp/string/basic_string/operator+
operator==(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
operator!=(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
operator&lt;=(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
operator&gt;=(std::u32string) =&gt; cpp/string/basic_string/operator_cmp
std::swap(std::u32string) =&gt; cpp/string/basic_string/swap2
operator&lt;&lt;(std::u32string) =&gt; cpp/string/basic_string/operator_ltltgtgt
operator&gt;&gt;(std::u32string) =&gt; cpp/string/basic_string/operator_ltltgtgt
std::hash&lt;std::u32string&gt; =&gt; cpp/string/basic_string/hash
std::getline =&gt; cpp/string/basic_string/getline
std::stoi =&gt; cpp/string/basic_string/stol
std::stol =&gt; cpp/string/basic_string/stol
std::stoll =&gt; cpp/string/basic_string/stol
std::stoul =&gt; cpp/string/basic_string/stoul
std::stoull =&gt; cpp/string/basic_string/stoul
std::stof =&gt; cpp/string/basic_string/stof
std::stod =&gt; cpp/string/basic_string/stof
std::stold =&gt; cpp/string/basic_string/stof
std::to_string =&gt; cpp/string/basic_string/to_string
std::to_wstring =&gt; cpp/string/basic_string/to_wstring
std::char_traits =&gt; cpp/string/char_traits
std::char_traits::assign =&gt; cpp/string/char_traits/assign
std::char_traits::eq =&gt; cpp/string/char_traits/eq
std::char_traits::lt =&gt; cpp/string/char_traits/lt
std::char_traits::move =&gt; cpp/string/char_traits/move
std::char_traits::copy =&gt; cpp/string/char_traits/copy
std::char_traits::compare =&gt; cpp/string/char_traits/compare
std::char_traits::length =&gt; cpp/string/char_traits/length
std::char_traits::find =&gt; cpp/string/char_traits/find
std::char_traits::to_char_type =&gt; cpp/string/char_traits/to_char_type
std::char_traits::to_int_type =&gt; cpp/string/char_traits/to_int_type
std::char_traits::eq_int_type =&gt; cpp/string/char_traits/eq_int_type
std::char_traits::eof =&gt; cpp/string/char_traits/eof
std::char_traits::not_eof =&gt; cpp/string/char_traits/not_eof
std::array =&gt; cpp/container/array
std::array::at =&gt; cpp/container/array/at
std::array::operator[] =&gt; cpp/container/array/operator_at
std::array::front =&gt; cpp/container/array/front
std::array::back =&gt; cpp/container/array/back
std::array::data =&gt; cpp/container/array/data
std::array::begin =&gt; cpp/container/array/begin
std::array::cbegin =&gt; cpp/container/array/begin
std::array::end =&gt; cpp/container/array/end
std::array::cend =&gt; cpp/container/array/end
std::array::rbegin =&gt; cpp/container/array/rbegin
std::array::crbegin =&gt; cpp/container/array/rbegin
std::array::rend =&gt; cpp/container/array/rend
std::array::crend =&gt; cpp/container/array/rend
std::array::empty =&gt; cpp/container/array/empty
std::array::size =&gt; cpp/container/array/size
std::array::max_size =&gt; cpp/container/array/max_size
std::array::fill =&gt; cpp/container/array/fill
std::array::swap =&gt; cpp/container/array/swap
operator==(std::array) =&gt; cpp/container/array/operator_cmp
operator!=(std::array) =&gt; cpp/container/array/operator_cmp
operator&lt;(std::array) =&gt; cpp/container/array/operator_cmp
operator&lt;=(std::array) =&gt; cpp/container/array/operator_cmp
operator&gt;(std::array) =&gt; cpp/container/array/operator_cmp
operator&gt;=(std::array) =&gt; cpp/container/array/operator_cmp
std::swap(std::array) =&gt; cpp/container/array/swap2
std::get(std::array) =&gt; cpp/container/array/get
std::tuple_size&lt;std::array&gt; =&gt; cpp/container/array/tuple_size
std::tuple_element&lt;std::array&gt; =&gt; cpp/container/array/tuple_element
std::dynarray =&gt; cpp/container/dynarray
std::dynarray::dynarray =&gt; cpp/container/dynarray/dynarray
std::dynarray::~dynarray =&gt; cpp/container/dynarray/~dynarray
std::dynarray::at =&gt; cpp/container/dynarray/at
std::dynarray::operator[] =&gt; cpp/container/dynarray/operator_at
std::dynarray::front =&gt; cpp/container/dynarray/front
std::dynarray::back =&gt; cpp/container/dynarray/back
std::dynarray::data =&gt; cpp/container/dynarray/data
std::dynarray::begin =&gt; cpp/container/dynarray/begin
std::dynarray::cbegin =&gt; cpp/container/dynarray/begin
std::dynarray::end =&gt; cpp/container/dynarray/end
std::dynarray::cend =&gt; cpp/container/dynarray/end
std::dynarray::rbegin =&gt; cpp/container/dynarray/rbegin
std::dynarray::crbegin =&gt; cpp/container/dynarray/rbegin
std::dynarray::rend =&gt; cpp/container/dynarray/rend
std::dynarray::crend =&gt; cpp/container/dynarray/rend
std::dynarray::empty =&gt; cpp/container/dynarray/empty
std::dynarray::size =&gt; cpp/container/dynarray/size
std::dynarray::max_size =&gt; cpp/container/dynarray/max_size
std::dynarray::fill =&gt; cpp/container/dynarray/fill
operator==(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
operator!=(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
operator&lt;(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
operator&lt;=(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
operator&gt;(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
operator&gt;=(std::dynarray) =&gt; cpp/container/dynarray/operator_cmp
std::uses_allocator&lt;std::dynarray&gt; =&gt; cpp/container/dynarray/uses_allocator
std::vector =&gt; cpp/container/vector
std::vector::vector =&gt; cpp/container/vector/vector
std::vector::~vector =&gt; cpp/container/vector/~vector
std::vector::operator= =&gt; cpp/container/vector/operator=
std::vector::assign =&gt; cpp/container/vector/assign
std::vector::get_allocator =&gt; cpp/container/vector/get_allocator
std::vector::at =&gt; cpp/container/vector/at
std::vector::operator[] =&gt; cpp/container/vector/operator_at
std::vector::front =&gt; cpp/container/vector/front
std::vector::back =&gt; cpp/container/vector/back
std::vector::data =&gt; cpp/container/vector/data
std::vector::begin =&gt; cpp/container/vector/begin
std::vector::cbegin =&gt; cpp/container/vector/begin
std::vector::end =&gt; cpp/container/vector/end
std::vector::cend =&gt; cpp/container/vector/end
std::vector::rbegin =&gt; cpp/container/vector/rbegin
std::vector::crbegin =&gt; cpp/container/vector/rbegin
std::vector::rend =&gt; cpp/container/vector/rend
std::vector::crend =&gt; cpp/container/vector/rend
std::vector::empty =&gt; cpp/container/vector/empty
std::vector::size =&gt; cpp/container/vector/size
std::vector::max_size =&gt; cpp/container/vector/max_size
std::vector::reserve =&gt; cpp/container/vector/reserve
std::vector::capacity =&gt; cpp/container/vector/capacity
std::vector::shrink_to_fit =&gt; cpp/container/vector/shrink_to_fit
std::vector::clear =&gt; cpp/container/vector/clear
std::vector::insert =&gt; cpp/container/vector/insert
std::vector::emplace =&gt; cpp/container/vector/emplace
std::vector::erase =&gt; cpp/container/vector/erase
std::vector::push_back =&gt; cpp/container/vector/push_back
std::vector::emplace_back =&gt; cpp/container/vector/emplace_back
std::vector::pop_back =&gt; cpp/container/vector/pop_back
std::vector::resize =&gt; cpp/container/vector/resize
std::vector::swap =&gt; cpp/container/vector/swap
operator==(std::vector) =&gt; cpp/container/vector/operator_cmp
operator!=(std::vector) =&gt; cpp/container/vector/operator_cmp
operator&lt;(std::vector) =&gt; cpp/container/vector/operator_cmp
operator&lt;=(std::vector) =&gt; cpp/container/vector/operator_cmp
operator&gt;(std::vector) =&gt; cpp/container/vector/operator_cmp
operator&gt;=(std::vector) =&gt; cpp/container/vector/operator_cmp
std::swap(std::vector) =&gt; cpp/container/vector/swap2
std::deque =&gt; cpp/container/deque
std::deque::deque =&gt; cpp/container/deque/deque
std::deque::~deque =&gt; cpp/container/deque/~deque
std::deque::operator= =&gt; cpp/container/deque/operator=
std::deque::assign =&gt; cpp/container/deque/assign
std::deque::get_allocator =&gt; cpp/container/deque/get_allocator
std::deque::at =&gt; cpp/container/deque/at
std::deque::operator[] =&gt; cpp/container/deque/operator_at
std::deque::front =&gt; cpp/container/deque/front
std::deque::back =&gt; cpp/container/deque/back
std::deque::begin =&gt; cpp/container/deque/begin
std::deque::cbegin =&gt; cpp/container/deque/begin
std::deque::end =&gt; cpp/container/deque/end
std::deque::cend =&gt; cpp/container/deque/end
std::deque::rbegin =&gt; cpp/container/deque/rbegin
std::deque::crbegin =&gt; cpp/container/deque/rbegin
std::deque::rend =&gt; cpp/container/deque/rend
std::deque::crend =&gt; cpp/container/deque/rend
std::deque::empty =&gt; cpp/container/deque/empty
std::deque::size =&gt; cpp/container/deque/size
std::deque::max_size =&gt; cpp/container/deque/max_size
std::deque::shrink_to_fit =&gt; cpp/container/deque/shrink_to_fit
std::deque::clear =&gt; cpp/container/deque/clear
std::deque::insert =&gt; cpp/container/deque/insert
std::deque::emplace =&gt; cpp/container/deque/emplace
std::deque::erase =&gt; cpp/container/deque/erase
std::deque::push_back =&gt; cpp/container/deque/push_back
std::deque::emplace_back =&gt; cpp/container/deque/emplace_back
std::deque::pop_back =&gt; cpp/container/deque/pop_back
std::deque::push_front =&gt; cpp/container/deque/push_front
std::deque::emplace_front =&gt; cpp/container/deque/emplace_front
std::deque::pop_front =&gt; cpp/container/deque/pop_front
std::deque::resize =&gt; cpp/container/deque/resize
std::deque::swap =&gt; cpp/container/deque/swap
operator==(std::deque) =&gt; cpp/container/deque/operator_cmp
operator!=(std::deque) =&gt; cpp/container/deque/operator_cmp
operator&lt;(std::deque) =&gt; cpp/container/deque/operator_cmp
operator&lt;=(std::deque) =&gt; cpp/container/deque/operator_cmp
operator&gt;(std::deque) =&gt; cpp/container/deque/operator_cmp
operator&gt;=(std::deque) =&gt; cpp/container/deque/operator_cmp
std::swap(std::deque) =&gt; cpp/container/deque/swap2
std::forward_list =&gt; cpp/container/forward_list
std::forward_list::forward_list =&gt; cpp/container/forward_list/forward_list
std::forward_list::~forward_list =&gt; cpp/container/forward_list/~forward_list
std::forward_list::operator= =&gt; cpp/container/forward_list/operator=
std::forward_list::assign =&gt; cpp/container/forward_list/assign
std::forward_list::get_allocator =&gt; cpp/container/forward_list/get_allocator
std::forward_list::front =&gt; cpp/container/forward_list/front
std::forward_list::before_begin =&gt; cpp/container/forward_list/before_begin
std::forward_list::cbefore_begin =&gt; cpp/container/forward_list/before_begin
std::forward_list::begin =&gt; cpp/container/forward_list/begin
std::forward_list::cbegin =&gt; cpp/container/forward_list/begin
std::forward_list::end =&gt; cpp/container/forward_list/end
std::forward_list::cend =&gt; cpp/container/forward_list/end
std::forward_list::empty =&gt; cpp/container/forward_list/empty
std::forward_list::max_size =&gt; cpp/container/forward_list/max_size
std::forward_list::clear =&gt; cpp/container/forward_list/clear
std::forward_list::insert_after =&gt; cpp/container/forward_list/insert_after
std::forward_list::emplace_after =&gt; cpp/container/forward_list/emplace_after
std::forward_list::erase_after =&gt; cpp/container/forward_list/erase_after
std::forward_list::push_front =&gt; cpp/container/forward_list/push_front
std::forward_list::emplace_front =&gt; cpp/container/forward_list/emplace_front
std::forward_list::pop_front =&gt; cpp/container/forward_list/pop_front
std::forward_list::resize =&gt; cpp/container/forward_list/resize
std::forward_list::swap =&gt; cpp/container/forward_list/swap
std::forward_list::merge =&gt; cpp/container/forward_list/merge
std::forward_list::splice_after =&gt; cpp/container/forward_list/splice_after
std::forward_list::remove =&gt; cpp/container/forward_list/remove
std::forward_list::remove_if =&gt; cpp/container/forward_list/remove
std::forward_list::reverse =&gt; cpp/container/forward_list/reverse
std::forward_list::unique =&gt; cpp/container/forward_list/unique
std::forward_list::sort =&gt; cpp/container/forward_list/sort
operator==(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
operator!=(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
operator&lt;(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
operator&lt;=(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
operator&gt;(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
operator&gt;=(std::forward_list) =&gt; cpp/container/forward_list/operator_cmp
std::swap(std::forward_list) =&gt; cpp/container/forward_list/swap2
std::list =&gt; cpp/container/list
std::list::list =&gt; cpp/container/list/list
std::list::~list =&gt; cpp/container/list/~list
std::list::operator= =&gt; cpp/container/list/operator=
std::list::assign =&gt; cpp/container/list/assign
std::list::get_allocator =&gt; cpp/container/list/get_allocator
std::list::front =&gt; cpp/container/list/front
std::list::back =&gt; cpp/container/list/back
std::list::begin =&gt; cpp/container/list/begin
std::list::cbegin =&gt; cpp/container/list/begin
std::list::end =&gt; cpp/container/list/end
std::list::cend =&gt; cpp/container/list/end
std::list::rbegin =&gt; cpp/container/list/rbegin
std::list::crbegin =&gt; cpp/container/list/rbegin
std::list::rend =&gt; cpp/container/list/rend
std::list::crend =&gt; cpp/container/list/rend
std::list::empty =&gt; cpp/container/list/empty
std::list::size =&gt; cpp/container/list/size
std::list::max_size =&gt; cpp/container/list/max_size
std::list::clear =&gt; cpp/container/list/clear
std::list::insert =&gt; cpp/container/list/insert
std::list::emplace =&gt; cpp/container/list/emplace
std::list::erase =&gt; cpp/container/list/erase
std::list::push_back =&gt; cpp/container/list/push_back
std::list::emplace_back =&gt; cpp/container/list/emplace_back
std::list::pop_back =&gt; cpp/container/list/pop_back
std::list::push_front =&gt; cpp/container/list/push_front
std::list::emplace_front =&gt; cpp/container/list/emplace_front
std::list::pop_front =&gt; cpp/container/list/pop_front
std::list::resize =&gt; cpp/container/list/resize
std::list::swap =&gt; cpp/container/list/swap
std::list::merge =&gt; cpp/container/list/merge
std::list::splice =&gt; cpp/container/list/splice
std::list::remove =&gt; cpp/container/list/remove
std::list::remove_if =&gt; cpp/container/list/remove
std::list::reverse =&gt; cpp/container/list/reverse
std::list::unique =&gt; cpp/container/list/unique
std::list::sort =&gt; cpp/container/list/sort
operator==(std::list) =&gt; cpp/container/list/operator_cmp
operator!=(std::list) =&gt; cpp/container/list/operator_cmp
operator&lt;(std::list) =&gt; cpp/container/list/operator_cmp
operator&lt;=(std::list) =&gt; cpp/container/list/operator_cmp
operator&gt;(std::list) =&gt; cpp/container/list/operator_cmp
operator&gt;=(std::list) =&gt; cpp/container/list/operator_cmp
std::swap(std::list) =&gt; cpp/container/list/swap2
std::set =&gt; cpp/container/set
std::set::set =&gt; cpp/container/set/set
std::set::~set =&gt; cpp/container/set/~set
std::set::operator= =&gt; cpp/container/set/operator=
std::set::get_allocator =&gt; cpp/container/set/get_allocator
std::set::begin =&gt; cpp/container/set/begin
std::set::cbegin =&gt; cpp/container/set/begin
std::set::end =&gt; cpp/container/set/end
std::set::cend =&gt; cpp/container/set/end
std::set::rbegin =&gt; cpp/container/set/rbegin
std::set::crbegin =&gt; cpp/container/set/rbegin
std::set::rend =&gt; cpp/container/set/rend
std::set::crend =&gt; cpp/container/set/rend
std::set::empty =&gt; cpp/container/set/empty
std::set::size =&gt; cpp/container/set/size
std::set::max_size =&gt; cpp/container/set/max_size
std::set::clear =&gt; cpp/container/set/clear
std::set::insert =&gt; cpp/container/set/insert
std::set::emplace =&gt; cpp/container/set/emplace
std::set::emplace_hint =&gt; cpp/container/set/emplace_hint
std::set::erase =&gt; cpp/container/set/erase
std::set::swap =&gt; cpp/container/set/swap
std::set::count =&gt; cpp/container/set/count
std::set::find =&gt; cpp/container/set/find
std::set::equal_range =&gt; cpp/container/set/equal_range
std::set::lower_bound =&gt; cpp/container/set/lower_bound
std::set::upper_bound =&gt; cpp/container/set/upper_bound
std::set::key_comp =&gt; cpp/container/set/key_comp
std::set::value_comp =&gt; cpp/container/set/value_comp
operator==(std::set) =&gt; cpp/container/set/operator_cmp
operator!=(std::set) =&gt; cpp/container/set/operator_cmp
operator&lt;(std::set) =&gt; cpp/container/set/operator_cmp
operator&lt;=(std::set) =&gt; cpp/container/set/operator_cmp
operator&gt;(std::set) =&gt; cpp/container/set/operator_cmp
operator&gt;=(std::set) =&gt; cpp/container/set/operator_cmp
std::swap(std::set) =&gt; cpp/container/set/swap2
std::multiset =&gt; cpp/container/multiset
std::multiset::multiset =&gt; cpp/container/multiset/multiset
std::multiset::~multiset =&gt; cpp/container/multiset/~multiset
std::multiset::operator= =&gt; cpp/container/multiset/operator=
std::multiset::get_allocator =&gt; cpp/container/multiset/get_allocator
std::multiset::begin =&gt; cpp/container/multiset/begin
std::multiset::cbegin =&gt; cpp/container/multiset/begin
std::multiset::end =&gt; cpp/container/multiset/end
std::multiset::cend =&gt; cpp/container/multiset/end
std::multiset::rbegin =&gt; cpp/container/multiset/rbegin
std::multiset::crbegin =&gt; cpp/container/multiset/rbegin
std::multiset::rend =&gt; cpp/container/multiset/rend
std::multiset::crend =&gt; cpp/container/multiset/rend
std::multiset::empty =&gt; cpp/container/multiset/empty
std::multiset::size =&gt; cpp/container/multiset/size
std::multiset::max_size =&gt; cpp/container/multiset/max_size
std::multiset::clear =&gt; cpp/container/multiset/clear
std::multiset::insert =&gt; cpp/container/multiset/insert
std::multiset::emplace =&gt; cpp/container/multiset/emplace
std::multiset::emplace_hint =&gt; cpp/container/multiset/emplace_hint
std::multiset::erase =&gt; cpp/container/multiset/erase
std::multiset::swap =&gt; cpp/container/multiset/swap
std::multiset::count =&gt; cpp/container/multiset/count
std::multiset::find =&gt; cpp/container/multiset/find
std::multiset::equal_range =&gt; cpp/container/multiset/equal_range
std::multiset::lower_bound =&gt; cpp/container/multiset/lower_bound
std::multiset::upper_bound =&gt; cpp/container/multiset/upper_bound
std::multiset::key_comp =&gt; cpp/container/multiset/key_comp
std::multiset::value_comp =&gt; cpp/container/multiset/value_comp
operator==(std::multiset) =&gt; cpp/container/multiset/operator_cmp
operator!=(std::multiset) =&gt; cpp/container/multiset/operator_cmp
operator&lt;(std::multiset) =&gt; cpp/container/multiset/operator_cmp
operator&lt;=(std::multiset) =&gt; cpp/container/multiset/operator_cmp
operator&gt;(std::multiset) =&gt; cpp/container/multiset/operator_cmp
operator&gt;=(std::multiset) =&gt; cpp/container/multiset/operator_cmp
std::swap(std::multiset) =&gt; cpp/container/multiset/swap2
std::map =&gt; cpp/container/map
std::map::value_compare =&gt; cpp/container/map/value_compare
std::map::map =&gt; cpp/container/map/map
std::map::~map =&gt; cpp/container/map/~map
std::map::operator= =&gt; cpp/container/map/operator=
std::map::get_allocator =&gt; cpp/container/map/get_allocator
std::map::at =&gt; cpp/container/map/at
std::map::operator[] =&gt; cpp/container/map/operator_at
std::map::begin =&gt; cpp/container/map/begin
std::map::cbegin =&gt; cpp/container/map/begin
std::map::end =&gt; cpp/container/map/end
std::map::cend =&gt; cpp/container/map/end
std::map::rbegin =&gt; cpp/container/map/rbegin
std::map::crbegin =&gt; cpp/container/map/rbegin
std::map::rend =&gt; cpp/container/map/rend
std::map::crend =&gt; cpp/container/map/rend
std::map::empty =&gt; cpp/container/map/empty
std::map::size =&gt; cpp/container/map/size
std::map::max_size =&gt; cpp/container/map/max_size
std::map::clear =&gt; cpp/container/map/clear
std::map::insert =&gt; cpp/container/map/insert
std::map::emplace =&gt; cpp/container/map/emplace
std::map::emplace_hint =&gt; cpp/container/map/emplace_hint
std::map::erase =&gt; cpp/container/map/erase
std::map::swap =&gt; cpp/container/map/swap
std::map::count =&gt; cpp/container/map/count
std::map::find =&gt; cpp/container/map/find
std::map::equal_range =&gt; cpp/container/map/equal_range
std::map::lower_bound =&gt; cpp/container/map/lower_bound
std::map::upper_bound =&gt; cpp/container/map/upper_bound
std::map::key_comp =&gt; cpp/container/map/key_comp
std::map::value_comp =&gt; cpp/container/map/value_comp
operator==(std::map) =&gt; cpp/container/map/operator_cmp
operator!=(std::map) =&gt; cpp/container/map/operator_cmp
operator&lt;(std::map) =&gt; cpp/container/map/operator_cmp
operator&lt;=(std::map) =&gt; cpp/container/map/operator_cmp
operator&gt;(std::map) =&gt; cpp/container/map/operator_cmp
operator&gt;=(std::map) =&gt; cpp/container/map/operator_cmp
std::swap(std::map) =&gt; cpp/container/map/swap2
std::multimap =&gt; cpp/container/multimap
std::multimap::value_compare =&gt; cpp/container/multimap/value_compare
std::multimap::multimap =&gt; cpp/container/multimap/multimap
std::multimap::~multimap =&gt; cpp/container/multimap/~multimap
std::multimap::operator= =&gt; cpp/container/multimap/operator=
std::multimap::get_allocator =&gt; cpp/container/multimap/get_allocator
std::multimap::begin =&gt; cpp/container/multimap/begin
std::multimap::cbegin =&gt; cpp/container/multimap/begin
std::multimap::end =&gt; cpp/container/multimap/end
std::multimap::cend =&gt; cpp/container/multimap/end
std::multimap::rbegin =&gt; cpp/container/multimap/rbegin
std::multimap::crbegin =&gt; cpp/container/multimap/rbegin
std::multimap::rend =&gt; cpp/container/multimap/rend
std::multimap::crend =&gt; cpp/container/multimap/rend
std::multimap::empty =&gt; cpp/container/multimap/empty
std::multimap::size =&gt; cpp/container/multimap/size
std::multimap::max_size =&gt; cpp/container/multimap/max_size
std::multimap::clear =&gt; cpp/container/multimap/clear
std::multimap::insert =&gt; cpp/container/multimap/insert
std::multimap::emplace =&gt; cpp/container/multimap/emplace
std::multimap::emplace_hint =&gt; cpp/container/multimap/emplace_hint
std::multimap::erase =&gt; cpp/container/multimap/erase
std::multimap::swap =&gt; cpp/container/multimap/swap
std::multimap::count =&gt; cpp/container/multimap/count
std::multimap::find =&gt; cpp/container/multimap/find
std::multimap::equal_range =&gt; cpp/container/multimap/equal_range
std::multimap::lower_bound =&gt; cpp/container/multimap/lower_bound
std::multimap::upper_bound =&gt; cpp/container/multimap/upper_bound
std::multimap::key_comp =&gt; cpp/container/multimap/key_comp
std::multimap::value_comp =&gt; cpp/container/multimap/value_comp
operator==(std::multimap) =&gt; cpp/container/multimap/operator_cmp
operator!=(std::multimap) =&gt; cpp/container/multimap/operator_cmp
operator&lt;(std::multimap) =&gt; cpp/container/multimap/operator_cmp
operator&lt;=(std::multimap) =&gt; cpp/container/multimap/operator_cmp
operator&gt;(std::multimap) =&gt; cpp/container/multimap/operator_cmp
operator&gt;=(std::multimap) =&gt; cpp/container/multimap/operator_cmp
std::swap(std::multimap) =&gt; cpp/container/multimap/swap2
std::unordered_set =&gt; cpp/container/unordered_set
std::unordered_set::unordered_set =&gt; cpp/container/unordered_set/unordered_set
std::unordered_set::~unordered_set =&gt; cpp/container/unordered_set/~unordered_set
std::unordered_set::operator= =&gt; cpp/container/unordered_set/operator=
std::unordered_set::get_allocator =&gt; cpp/container/unordered_set/get_allocator
std::unordered_set::begin =&gt; cpp/container/unordered_set/begin
std::unordered_set::cbegin =&gt; cpp/container/unordered_set/begin
std::unordered_set::end =&gt; cpp/container/unordered_set/end
std::unordered_set::cend =&gt; cpp/container/unordered_set/end
std::unordered_set::empty =&gt; cpp/container/unordered_set/empty
std::unordered_set::size =&gt; cpp/container/unordered_set/size
std::unordered_set::max_size =&gt; cpp/container/unordered_set/max_size
std::unordered_set::clear =&gt; cpp/container/unordered_set/clear
std::unordered_set::insert =&gt; cpp/container/unordered_set/insert
std::unordered_set::emplace =&gt; cpp/container/unordered_set/emplace
std::unordered_set::emplace_hint =&gt; cpp/container/unordered_set/emplace_hint
std::unordered_set::erase =&gt; cpp/container/unordered_set/erase
std::unordered_set::swap =&gt; cpp/container/unordered_set/swap
std::unordered_set::count =&gt; cpp/container/unordered_set/count
std::unordered_set::find =&gt; cpp/container/unordered_set/find
std::unordered_set::equal_range =&gt; cpp/container/unordered_set/equal_range
std::unordered_set::begin(int) =&gt; cpp/container/unordered_set/begin2
std::unordered_set::cbegin(int) =&gt; cpp/container/unordered_set/begin2
std::unordered_set::end(int) =&gt; cpp/container/unordered_set/end2
std::unordered_set::cend(int) =&gt; cpp/container/unordered_set/end2
std::unordered_set::bucket_count =&gt; cpp/container/unordered_set/bucket_count
std::unordered_set::max_bucket_count =&gt; cpp/container/unordered_set/max_bucket_count
std::unordered_set::bucket_size =&gt; cpp/container/unordered_set/bucket_size
std::unordered_set::bucket =&gt; cpp/container/unordered_set/bucket
std::unordered_set::load_factor =&gt; cpp/container/unordered_set/load_factor
std::unordered_set::max_load_factor =&gt; cpp/container/unordered_set/max_load_factor
std::unordered_set::reserve =&gt; cpp/container/unordered_set/reserve
std::unordered_set::rehash =&gt; cpp/container/unordered_set/rehash
std::unordered_set::hash_function =&gt; cpp/container/unordered_set/hash_function
std::unordered_set::key_eq =&gt; cpp/container/unordered_set/key_eq
operator==(std::unordered_set) =&gt; cpp/container/unordered_set/operator_cmp
operator!=(std::unordered_set) =&gt; cpp/container/unordered_set/operator_cmp
std::swap(std::unordered_set) =&gt; cpp/container/unordered_set/swap2
std::unordered_multiset =&gt; cpp/container/unordered_multiset
std::unordered_multiset::unordered_multiset =&gt; cpp/container/unordered_multiset/unordered_multiset
std::unordered_multiset::~unordered_multiset =&gt; cpp/container/unordered_multiset/~unordered_multiset
std::unordered_multiset::operator= =&gt; cpp/container/unordered_multiset/operator=
std::unordered_multiset::get_allocator =&gt; cpp/container/unordered_multiset/get_allocator
std::unordered_multiset::begin =&gt; cpp/container/unordered_multiset/begin
std::unordered_multiset::cbegin =&gt; cpp/container/unordered_multiset/begin
std::unordered_multiset::end =&gt; cpp/container/unordered_multiset/end
std::unordered_multiset::cend =&gt; cpp/container/unordered_multiset/end
std::unordered_multiset::empty =&gt; cpp/container/unordered_multiset/empty
std::unordered_multiset::size =&gt; cpp/container/unordered_multiset/size
std::unordered_multiset::max_size =&gt; cpp/container/unordered_multiset/max_size
std::unordered_multiset::clear =&gt; cpp/container/unordered_multiset/clear
std::unordered_multiset::insert =&gt; cpp/container/unordered_multiset/insert
std::unordered_multiset::emplace =&gt; cpp/container/unordered_multiset/emplace
std::unordered_multiset::emplace_hint =&gt; cpp/container/unordered_multiset/emplace_hint
std::unordered_multiset::erase =&gt; cpp/container/unordered_multiset/erase
std::unordered_multiset::swap =&gt; cpp/container/unordered_multiset/swap
std::unordered_multiset::count =&gt; cpp/container/unordered_multiset/count
std::unordered_multiset::find =&gt; cpp/container/unordered_multiset/find
std::unordered_multiset::equal_range =&gt; cpp/container/unordered_multiset/equal_range
std::unordered_multiset::begin(int) =&gt; cpp/container/unordered_multiset/begin2
std::unordered_multiset::cbegin(int) =&gt; cpp/container/unordered_multiset/begin2
std::unordered_multiset::end(int) =&gt; cpp/container/unordered_multiset/end2
std::unordered_multiset::cend(int) =&gt; cpp/container/unordered_multiset/end2
std::unordered_multiset::bucket_count =&gt; cpp/container/unordered_multiset/bucket_count
std::unordered_multiset::max_bucket_count =&gt; cpp/container/unordered_multiset/max_bucket_count
std::unordered_multiset::bucket_size =&gt; cpp/container/unordered_multiset/bucket_size
std::unordered_multiset::bucket =&gt; cpp/container/unordered_multiset/bucket
std::unordered_multiset::load_factor =&gt; cpp/container/unordered_multiset/load_factor
std::unordered_multiset::max_load_factor =&gt; cpp/container/unordered_multiset/max_load_factor
std::unordered_multiset::reserve =&gt; cpp/container/unordered_multiset/reserve
std::unordered_multiset::rehash =&gt; cpp/container/unordered_multiset/rehash
std::unordered_multiset::hash_function =&gt; cpp/container/unordered_multiset/hash_function
std::unordered_multiset::key_eq =&gt; cpp/container/unordered_multiset/key_eq
operator==(std::unordered_multiset) =&gt; cpp/container/unordered_multiset/operator_cmp
operator!=(std::unordered_multiset) =&gt; cpp/container/unordered_multiset/operator_cmp
std::swap(std::unordered_multiset) =&gt; cpp/container/unordered_multiset/swap2
std::unordered_map =&gt; cpp/container/unordered_map
std::unordered_map::unordered_map =&gt; cpp/container/unordered_map/unordered_map
std::unordered_map::~unordered_map =&gt; cpp/container/unordered_map/~unordered_map
std::unordered_map::operator= =&gt; cpp/container/unordered_map/operator=
std::unordered_map::get_allocator =&gt; cpp/container/unordered_map/get_allocator
std::unordered_map::begin =&gt; cpp/container/unordered_map/begin
std::unordered_map::cbegin =&gt; cpp/container/unordered_map/begin
std::unordered_map::end =&gt; cpp/container/unordered_map/end
std::unordered_map::cend =&gt; cpp/container/unordered_map/end
std::unordered_map::empty =&gt; cpp/container/unordered_map/empty
std::unordered_map::size =&gt; cpp/container/unordered_map/size
std::unordered_map::max_size =&gt; cpp/container/unordered_map/max_size
std::unordered_map::clear =&gt; cpp/container/unordered_map/clear
std::unordered_map::insert =&gt; cpp/container/unordered_map/insert
std::unordered_map::emplace =&gt; cpp/container/unordered_map/emplace
std::unordered_map::emplace_hint =&gt; cpp/container/unordered_map/emplace_hint
std::unordered_map::erase =&gt; cpp/container/unordered_map/erase
std::unordered_map::swap =&gt; cpp/container/unordered_map/swap
std::unordered_map::at =&gt; cpp/container/unordered_map/at
std::unordered_map::operator[] =&gt; cpp/container/unordered_map/operator_at
std::unordered_map::count =&gt; cpp/container/unordered_map/count
std::unordered_map::find =&gt; cpp/container/unordered_map/find
std::unordered_map::equal_range =&gt; cpp/container/unordered_map/equal_range
std::unordered_map::begin(int) =&gt; cpp/container/unordered_map/begin2
std::unordered_map::cbegin(int) =&gt; cpp/container/unordered_map/begin2
std::unordered_map::end(int) =&gt; cpp/container/unordered_map/end2
std::unordered_map::cend(int) =&gt; cpp/container/unordered_map/end2
std::unordered_map::bucket_count =&gt; cpp/container/unordered_map/bucket_count
std::unordered_map::max_bucket_count =&gt; cpp/container/unordered_map/max_bucket_count
std::unordered_map::bucket_size =&gt; cpp/container/unordered_map/bucket_size
std::unordered_map::bucket =&gt; cpp/container/unordered_map/bucket
std::unordered_map::load_factor =&gt; cpp/container/unordered_map/load_factor
std::unordered_map::max_load_factor =&gt; cpp/container/unordered_map/max_load_factor
std::unordered_map::reserve =&gt; cpp/container/unordered_map/reserve
std::unordered_map::rehash =&gt; cpp/container/unordered_map/rehash
std::unordered_map::hash_function =&gt; cpp/container/unordered_map/hash_function
std::unordered_map::key_eq =&gt; cpp/container/unordered_map/key_eq
operator==(std::unordered_map) =&gt; cpp/container/unordered_map/operator_cmp
operator!=(std::unordered_map) =&gt; cpp/container/unordered_map/operator_cmp
std::swap(std::unordered_map) =&gt; cpp/container/unordered_map/swap2
std::unordered_multimap =&gt; cpp/container/unordered_multimap
std::unordered_multimap::unordered_multimap =&gt; cpp/container/unordered_multimap/unordered_multimap
std::unordered_multimap::~unordered_multimap =&gt; cpp/container/unordered_multimap/~unordered_multimap
std::unordered_multimap::operator= =&gt; cpp/container/unordered_multimap/operator=
std::unordered_multimap::get_allocator =&gt; cpp/container/unordered_multimap/get_allocator
std::unordered_multimap::begin =&gt; cpp/container/unordered_multimap/begin
std::unordered_multimap::cbegin =&gt; cpp/container/unordered_multimap/begin
std::unordered_multimap::end =&gt; cpp/container/unordered_multimap/end
std::unordered_multimap::cend =&gt; cpp/container/unordered_multimap/end
std::unordered_multimap::empty =&gt; cpp/container/unordered_multimap/empty
std::unordered_multimap::size =&gt; cpp/container/unordered_multimap/size
std::unordered_multimap::max_size =&gt; cpp/container/unordered_multimap/max_size
std::unordered_multimap::clear =&gt; cpp/container/unordered_multimap/clear
std::unordered_multimap::insert =&gt; cpp/container/unordered_multimap/insert
std::unordered_multimap::emplace =&gt; cpp/container/unordered_multimap/emplace
std::unordered_multimap::emplace_hint =&gt; cpp/container/unordered_multimap/emplace_hint
std::unordered_multimap::erase =&gt; cpp/container/unordered_multimap/erase
std::unordered_multimap::swap =&gt; cpp/container/unordered_multimap/swap
std::unordered_multimap::count =&gt; cpp/container/unordered_multimap/count
std::unordered_multimap::find =&gt; cpp/container/unordered_multimap/find
std::unordered_multimap::equal_range =&gt; cpp/container/unordered_multimap/equal_range
std::unordered_multimap::begin(int) =&gt; cpp/container/unordered_multimap/begin2
std::unordered_multimap::cbegin(int) =&gt; cpp/container/unordered_multimap/begin2
std::unordered_multimap::end(int) =&gt; cpp/container/unordered_multimap/end2
std::unordered_multimap::cend(int) =&gt; cpp/container/unordered_multimap/end2
std::unordered_multimap::bucket_count =&gt; cpp/container/unordered_multimap/bucket_count
std::unordered_multimap::max_bucket_count =&gt; cpp/container/unordered_multimap/max_bucket_count
std::unordered_multimap::bucket_size =&gt; cpp/container/unordered_multimap/bucket_size
std::unordered_multimap::bucket =&gt; cpp/container/unordered_multimap/bucket
std::unordered_multimap::load_factor =&gt; cpp/container/unordered_multimap/load_factor
std::unordered_multimap::max_load_factor =&gt; cpp/container/unordered_multimap/max_load_factor
std::unordered_multimap::reserve =&gt; cpp/container/unordered_multimap/reserve
std::unordered_multimap::rehash =&gt; cpp/container/unordered_multimap/rehash
std::unordered_multimap::hash_function =&gt; cpp/container/unordered_multimap/hash_function
std::unordered_multimap::key_eq =&gt; cpp/container/unordered_multimap/key_eq
operator==(std::unordered_multimap) =&gt; cpp/container/unordered_multimap/operator_cmp
operator!=(std::unordered_multimap) =&gt; cpp/container/unordered_multimap/operator_cmp
std::swap(std::unordered_multimap) =&gt; cpp/container/unordered_multimap/swap2
std::stack =&gt; cpp/container/stack
std::stack::stack =&gt; cpp/container/stack/stack
std::stack::~stack =&gt; cpp/container/stack/~stack
std::stack::operator= =&gt; cpp/container/stack/operator=
std::stack::top =&gt; cpp/container/stack/top
std::stack::empty =&gt; cpp/container/stack/empty
std::stack::size =&gt; cpp/container/stack/size
std::stack::push =&gt; cpp/container/stack/push
std::stack::emplace =&gt; cpp/container/stack/emplace
std::stack::pop =&gt; cpp/container/stack/pop
std::stack::swap =&gt; cpp/container/stack/swap
operator==(std::stack) =&gt; cpp/container/stack/operator_cmp
operator!=(std::stack) =&gt; cpp/container/stack/operator_cmp
operator&lt;(std::stack) =&gt; cpp/container/stack/operator_cmp
operator&lt;=(std::stack) =&gt; cpp/container/stack/operator_cmp
operator&gt;(std::stack) =&gt; cpp/container/stack/operator_cmp
operator&gt;=(std::stack) =&gt; cpp/container/stack/operator_cmp
std::swap(std::stack) =&gt; cpp/container/stack/swap2
std::uses_allocator&lt;std::stack&gt; =&gt; cpp/container/stack/uses_allocator
std::queue =&gt; cpp/container/queue
std::queue::queue =&gt; cpp/container/queue/queue
std::queue::~queue =&gt; cpp/container/queue/~queue
std::queue::operator= =&gt; cpp/container/queue/operator=
std::queue::front =&gt; cpp/container/queue/front
std::queue::back =&gt; cpp/container/queue/back
std::queue::empty =&gt; cpp/container/queue/empty
std::queue::size =&gt; cpp/container/queue/size
std::queue::push =&gt; cpp/container/queue/push
std::queue::emplace =&gt; cpp/container/queue/emplace
std::queue::pop =&gt; cpp/container/queue/pop
std::queue::swap =&gt; cpp/container/queue/swap
operator==(std::queue) =&gt; cpp/container/queue/operator_cmp
operator!=(std::queue) =&gt; cpp/container/queue/operator_cmp
operator&lt;(std::queue) =&gt; cpp/container/queue/operator_cmp
operator&lt;=(std::queue) =&gt; cpp/container/queue/operator_cmp
operator&gt;(std::queue) =&gt; cpp/container/queue/operator_cmp
operator&gt;=(std::queue) =&gt; cpp/container/queue/operator_cmp
std::swap(std::queue) =&gt; cpp/container/queue/swap2
std::uses_allocator&lt;std::queue&gt; =&gt; cpp/container/queue/uses_allocator
std::priority_queue =&gt; cpp/container/priority_queue
std::priority_queue::priority_queue =&gt; cpp/container/priority_queue/priority_queue
std::priority_queue::~priority_queue =&gt; cpp/container/priority_queue/~priority_queue
std::priority_queue::operator= =&gt; cpp/container/priority_queue/operator=
std::priority_queue::top =&gt; cpp/container/priority_queue/top
std::priority_queue::empty =&gt; cpp/container/priority_queue/empty
std::priority_queue::size =&gt; cpp/container/priority_queue/size
std::priority_queue::push =&gt; cpp/container/priority_queue/push
std::priority_queue::emplace =&gt; cpp/container/priority_queue/emplace
std::priority_queue::pop =&gt; cpp/container/priority_queue/pop
std::priority_queue::swap =&gt; cpp/container/priority_queue/swap
operator==(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
operator!=(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
operator&lt;(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
operator&lt;=(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
operator&gt;(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
operator&gt;=(std::priority_queue) =&gt; cpp/container/priority_queue/operator_cmp
std::swap(std::priority_queue) =&gt; cpp/container/priority_queue/swap2
std::uses_allocator&lt;std::priority_queue&gt; =&gt; cpp/container/priority_queue/uses_allocator
std::abs(int) =&gt; cpp/numeric/math/abs
std::labs =&gt; cpp/numeric/math/abs
std::llabs =&gt; cpp/numeric/math/abs
std::abs(float) =&gt; cpp/numeric/math/fabs
std::fabs =&gt; cpp/numeric/math/fabs
std::div =&gt; cpp/numeric/math/div
std::ldiv =&gt; cpp/numeric/math/div
std::fmod =&gt; cpp/numeric/math/fmod
std::remainder =&gt; cpp/numeric/math/remainder
std::remquo =&gt; cpp/numeric/math/remquo
std::fma =&gt; cpp/numeric/math/fma
std::fmax =&gt; cpp/numeric/math/fmax
std::fmin =&gt; cpp/numeric/math/fmin
std::fdim =&gt; cpp/numeric/math/fdim
std::nan =&gt; cpp/numeric/math/nan
std::nanf =&gt; cpp/numeric/math/nan
std::nanl =&gt; cpp/numeric/math/nan
std::exp =&gt; cpp/numeric/math/exp
std::exp2 =&gt; cpp/numeric/math/exp2
std::expm1 =&gt; cpp/numeric/math/expm1
std::log =&gt; cpp/numeric/math/log
std::log10 =&gt; cpp/numeric/math/log10
std::log1p =&gt; cpp/numeric/math/log1p
std::ilogb =&gt; cpp/numeric/math/ilogb
std::logb =&gt; cpp/numeric/math/logb
std::sqrt =&gt; cpp/numeric/math/sqrt
std::cbrt =&gt; cpp/numeric/math/cbrt
std::hypot =&gt; cpp/numeric/math/hypot
std::pow =&gt; cpp/numeric/math/pow
std::sin =&gt; cpp/numeric/math/sin
std::cos =&gt; cpp/numeric/math/cos
std::tan =&gt; cpp/numeric/math/tan
std::asin =&gt; cpp/numeric/math/asin
std::acos =&gt; cpp/numeric/math/acos
std::atan =&gt; cpp/numeric/math/atan
std::atan2 =&gt; cpp/numeric/math/atan2
std::sinh =&gt; cpp/numeric/math/sinh
std::cosh =&gt; cpp/numeric/math/cosh
std::tanh =&gt; cpp/numeric/math/tanh
std::asinh =&gt; cpp/numeric/math/asinh
std::acosh =&gt; cpp/numeric/math/acosh
std::atanh =&gt; cpp/numeric/math/atanh
std::erf =&gt; cpp/numeric/math/erf
std::erfc =&gt; cpp/numeric/math/erfc
std::lgamma =&gt; cpp/numeric/math/lgamma
std::tgamma =&gt; cpp/numeric/math/tgamma
std::ceil =&gt; cpp/numeric/math/ceil
std::floor =&gt; cpp/numeric/math/floor
std::trunc =&gt; cpp/numeric/math/trunc
std::round =&gt; cpp/numeric/math/round
std::lround =&gt; cpp/numeric/math/round
std::llround =&gt; cpp/numeric/math/round
std::nearbyint =&gt; cpp/numeric/math/nearbyint
std::rint =&gt; cpp/numeric/math/rint
std::lrint =&gt; cpp/numeric/math/rint
std::llrint =&gt; cpp/numeric/math/rint
std::frexp =&gt; cpp/numeric/math/frexp
std::ldexp =&gt; cpp/numeric/math/ldexp
std::modf =&gt; cpp/numeric/math/modf
std::scalbn =&gt; cpp/numeric/math/scalbn
std::scalbln =&gt; cpp/numeric/math/scalbn
std::nextafter =&gt; cpp/numeric/math/nextafter
std::nexttoward =&gt; cpp/numeric/math/nextafter
std::copysign =&gt; cpp/numeric/math/copysign
std::fpclassify =&gt; cpp/numeric/math/fpclassify
std::isfinite =&gt; cpp/numeric/math/isfinite
std::isinf =&gt; cpp/numeric/math/isinf
std::isnan =&gt; cpp/numeric/math/isnan
std::isnormal =&gt; cpp/numeric/math/isnormal
std::signbit =&gt; cpp/numeric/math/signbit
HUGE_VAL =&gt; cpp/numeric/math/HUGE_VAL
HUGE_VALF =&gt; cpp/numeric/math/HUGE_VAL
HUGE_VALL =&gt; cpp/numeric/math/HUGE_VAL
INFINITY =&gt; cpp/numeric/math/INFINITY
NAN =&gt; cpp/numeric/math/NAN
math_errhandling =&gt; cpp/numeric/math/math_errhandling
MATH_ERRNO =&gt; cpp/numeric/math/math_errhandling
MATH_ERREXCEPT =&gt; cpp/numeric/math/math_errhandling
FP_INFINITE =&gt; cpp/numeric/math/FP_categories
FP_NAN =&gt; cpp/numeric/math/FP_categories
FP_NORMAL =&gt; cpp/numeric/math/FP_categories
FP_SUBNORMAL =&gt; cpp/numeric/math/FP_categories
FP_ZERO =&gt; cpp/numeric/math/FP_categories
std::feclearexcept =&gt; cpp/numeric/fenv/feclearexcept
std::fetestexcept =&gt; cpp/numeric/fenv/fetestexcept
std::feraiseexcept =&gt; cpp/numeric/fenv/feraiseexcept
std::fegetexceptflag =&gt; cpp/numeric/fenv/feexceptflag
std::fesetexceptflag =&gt; cpp/numeric/fenv/feexceptflag
std::fegetround =&gt; cpp/numeric/fenv/feround
std::fesetround =&gt; cpp/numeric/fenv/feround
std::fegetenv =&gt; cpp/numeric/fenv/feenv
std::fesetenv =&gt; cpp/numeric/fenv/feenv
std::feholdexcept =&gt; cpp/numeric/fenv/feholdexcept
std::feupdateenv =&gt; cpp/numeric/fenv/feupdateenv
FE_ALL_EXCEPT =&gt; cpp/numeric/fenv/FE_exceptions
FE_DIVBYZERO =&gt; cpp/numeric/fenv/FE_exceptions
FE_INEXACT =&gt; cpp/numeric/fenv/FE_exceptions
FE_INVALID =&gt; cpp/numeric/fenv/FE_exceptions
FE_OVERFLOW =&gt; cpp/numeric/fenv/FE_exceptions
FE_UNDERFLOW =&gt; cpp/numeric/fenv/FE_exceptions
FE_DOWNWARD =&gt; cpp/numeric/fenv/FE_round
FE_TONEAREST =&gt; cpp/numeric/fenv/FE_round
FE_TOWARDZERO =&gt; cpp/numeric/fenv/FE_round
FE_UPWARD =&gt; cpp/numeric/fenv/FE_round
FE_DFL_ENV =&gt; cpp/numeric/fenv/FE_DFL_ENV
std::complex =&gt; cpp/numeric/complex
std::complex::complex =&gt; cpp/numeric/complex/complex
std::complex::operator= =&gt; cpp/numeric/complex/operator=
std::complex::real =&gt; cpp/numeric/complex/real
std::complex::imag =&gt; cpp/numeric/complex/imag
std::complex::operator+= =&gt; cpp/numeric/complex/operator_arith
std::complex::operator-= =&gt; cpp/numeric/complex/operator_arith
std::complex::operator*= =&gt; cpp/numeric/complex/operator_arith
std::complex::operator/= =&gt; cpp/numeric/complex/operator_arith
operator+(std::complex) =&gt; cpp/numeric/complex/operator_arith2
operator-(std::complex) =&gt; cpp/numeric/complex/operator_arith2
operator+(std::complex) =&gt; cpp/numeric/complex/operator_arith3
operator-(std::complex) =&gt; cpp/numeric/complex/operator_arith3
operator*(std::complex) =&gt; cpp/numeric/complex/operator_arith3
operator/(std::complex) =&gt; cpp/numeric/complex/operator_arith3
operator==(std::complex) =&gt; cpp/numeric/complex/operator_cmp
operator!=(std::complex) =&gt; cpp/numeric/complex/operator_cmp
operator&lt;&lt;(std::complex) =&gt; cpp/numeric/complex/operator_ltltgtgt
operator&gt;&gt;(std::complex) =&gt; cpp/numeric/complex/operator_ltltgtgt
std::real(std::complex) =&gt; cpp/numeric/complex/real
std::imag(std::complex) =&gt; cpp/numeric/complex/imag
std::abs(std::complex) =&gt; cpp/numeric/complex/abs
std::arg(std::complex) =&gt; cpp/numeric/complex/arg
std::norm(std::complex) =&gt; cpp/numeric/complex/norm
std::conj(std::complex) =&gt; cpp/numeric/complex/conj
std::proj(std::complex) =&gt; cpp/numeric/complex/proj
std::polar(std::complex) =&gt; cpp/numeric/complex/polar
std::exp(std::complex) =&gt; cpp/numeric/complex/exp
std::log(std::complex) =&gt; cpp/numeric/complex/log
std::log10(std::complex) =&gt; cpp/numeric/complex/log10
std::pow(std::complex) =&gt; cpp/numeric/complex/pow
std::sqrt(std::complex) =&gt; cpp/numeric/complex/sqrt
std::sin(std::complex) =&gt; cpp/numeric/complex/sin
std::cos(std::complex) =&gt; cpp/numeric/complex/cos
std::tan(std::complex) =&gt; cpp/numeric/complex/tan
std::asin(std::complex) =&gt; cpp/numeric/complex/asin
std::acos(std::complex) =&gt; cpp/numeric/complex/acos
std::atan(std::complex) =&gt; cpp/numeric/complex/atan
std::sinh(std::complex) =&gt; cpp/numeric/complex/sinh
std::cosh(std::complex) =&gt; cpp/numeric/complex/cosh
std::tanh(std::complex) =&gt; cpp/numeric/complex/tanh
std::asinh(std::complex) =&gt; cpp/numeric/complex/asinh
std::acosh(std::complex) =&gt; cpp/numeric/complex/acosh
std::atanh(std::complex) =&gt; cpp/numeric/complex/atanh
std::valarray =&gt; cpp/numeric/valarray
std::linear_congruential_engine =&gt; cpp/numeric/random/linear_congruential_engine
std::linear_congruential_engine::linear_congruential_engine =&gt; cpp/numeric/random/linear_congruential_engine/linear_congruential_engine
std::linear_congruential_engine::seed =&gt; cpp/numeric/random/linear_congruential_engine/seed
std::linear_congruential_engine::operator() =&gt; cpp/numeric/random/linear_congruential_engine/operator()
std::linear_congruential_engine::discard =&gt; cpp/numeric/random/linear_congruential_engine/discard
std::linear_congruential_engine::min =&gt; cpp/numeric/random/linear_congruential_engine/min
std::linear_congruential_engine::max =&gt; cpp/numeric/random/linear_congruential_engine/max
operator==(std::linear_congruential_engine) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator!=(std::linear_congruential_engine) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator&lt;&lt;(std::linear_congruential_engine) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
operator&gt;&gt;(std::linear_congruential_engine) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
std::mersenne_twister_engine =&gt; cpp/numeric/random/mersenne_twister_engine
std::mersenne_twister_engine::mersenne_twister_engine =&gt; cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine
std::mersenne_twister_engine::seed =&gt; cpp/numeric/random/mersenne_twister_engine/seed
std::mersenne_twister_engine::operator() =&gt; cpp/numeric/random/mersenne_twister_engine/operator()
std::mersenne_twister_engine::discard =&gt; cpp/numeric/random/mersenne_twister_engine/discard
std::mersenne_twister_engine::min =&gt; cpp/numeric/random/mersenne_twister_engine/min
std::mersenne_twister_engine::max =&gt; cpp/numeric/random/mersenne_twister_engine/max
operator==(std::mersenne_twister_engine) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator!=(std::mersenne_twister_engine) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator&lt;&lt;(std::mersenne_twister_engine) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
operator&gt;&gt;(std::mersenne_twister_engine) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
std::subtract_with_carry_engine =&gt; cpp/numeric/random/subtract_with_carry_engine
std::subtract_with_carry_engine::subtract_with_carry_engine =&gt; cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine
std::subtract_with_carry_engine::seed =&gt; cpp/numeric/random/subtract_with_carry_engine/seed
std::subtract_with_carry_engine::operator() =&gt; cpp/numeric/random/subtract_with_carry_engine/operator()
std::subtract_with_carry_engine::discard =&gt; cpp/numeric/random/subtract_with_carry_engine/discard
std::subtract_with_carry_engine::min =&gt; cpp/numeric/random/subtract_with_carry_engine/min
std::subtract_with_carry_engine::max =&gt; cpp/numeric/random/subtract_with_carry_engine/max
operator==(std::subtract_with_carry_engine) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator!=(std::subtract_with_carry_engine) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator&lt;&lt;(std::subtract_with_carry_engine) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
operator&gt;&gt;(std::subtract_with_carry_engine) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
std::discard_block_engine =&gt; cpp/numeric/random/discard_block_engine
std::discard_block_engine::discard_block_engine =&gt; cpp/numeric/random/discard_block_engine/discard_block_engine
std::discard_block_engine::seed =&gt; cpp/numeric/random/discard_block_engine/seed
std::discard_block_engine::base =&gt; cpp/numeric/random/discard_block_engine/base
std::discard_block_engine::operator() =&gt; cpp/numeric/random/discard_block_engine/operator()
std::discard_block_engine::discard =&gt; cpp/numeric/random/discard_block_engine/discard
std::discard_block_engine::min =&gt; cpp/numeric/random/discard_block_engine/min
std::discard_block_engine::max =&gt; cpp/numeric/random/discard_block_engine/max
operator==(std::discard_block_engine) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator!=(std::discard_block_engine) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator&lt;&lt;(std::discard_block_engine) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
operator&gt;&gt;(std::discard_block_engine) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
std::independent_bits_engine =&gt; cpp/numeric/random/independent_bits_engine
std::independent_bits_engine::independent_bits_engine =&gt; cpp/numeric/random/independent_bits_engine/independent_bits_engine
std::independent_bits_engine::seed =&gt; cpp/numeric/random/independent_bits_engine/seed
std::independent_bits_engine::base =&gt; cpp/numeric/random/independent_bits_engine/base
std::independent_bits_engine::operator() =&gt; cpp/numeric/random/independent_bits_engine/operator()
std::independent_bits_engine::discard =&gt; cpp/numeric/random/independent_bits_engine/discard
std::independent_bits_engine::min =&gt; cpp/numeric/random/independent_bits_engine/min
std::independent_bits_engine::max =&gt; cpp/numeric/random/independent_bits_engine/max
operator==(std::independent_bits_engine) =&gt; cpp/numeric/random/independent_bits_engine/operator_cmp
operator!=(std::independent_bits_engine) =&gt; cpp/numeric/random/independent_bits_engine/operator_cmp
operator&lt;&lt;(std::independent_bits_engine) =&gt; cpp/numeric/random/independent_bits_engine/operator_ltltgtgt
operator&gt;&gt;(std::independent_bits_engine) =&gt; cpp/numeric/random/independent_bits_engine/operator_ltltgtgt
std::shuffle_order_engine =&gt; cpp/numeric/random/shuffle_order_engine
std::shuffle_order_engine::shuffle_order_engine =&gt; cpp/numeric/random/shuffle_order_engine/shuffle_order_engine
std::shuffle_order_engine::seed =&gt; cpp/numeric/random/shuffle_order_engine/seed
std::shuffle_order_engine::base =&gt; cpp/numeric/random/shuffle_order_engine/base
std::shuffle_order_engine::operator() =&gt; cpp/numeric/random/shuffle_order_engine/operator()
std::shuffle_order_engine::discard =&gt; cpp/numeric/random/shuffle_order_engine/discard
std::shuffle_order_engine::min =&gt; cpp/numeric/random/shuffle_order_engine/min
std::shuffle_order_engine::max =&gt; cpp/numeric/random/shuffle_order_engine/max
operator==(std::shuffle_order_engine) =&gt; cpp/numeric/random/shuffle_order_engine/operator_cmp
operator!=(std::shuffle_order_engine) =&gt; cpp/numeric/random/shuffle_order_engine/operator_cmp
operator&lt;&lt;(std::shuffle_order_engine) =&gt; cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt
operator&gt;&gt;(std::shuffle_order_engine) =&gt; cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt
std::random_device =&gt; cpp/numeric/random/random_device
std::random_device::random_device =&gt; cpp/numeric/random/random_device/random_device
std::random_device::operator() =&gt; cpp/numeric/random/random_device/operator()
std::random_device::min =&gt; cpp/numeric/random/random_device/min
std::random_device::max =&gt; cpp/numeric/random/random_device/max
std::random_device::entropy =&gt; cpp/numeric/random/random_device/entropy
std::minstd_rand0 =&gt; cpp/numeric/random/linear_congruential_engine
std::minstd_rand0::minstd_rand0 =&gt; cpp/numeric/random/linear_congruential_engine/linear_congruential_engine
std::minstd_rand0::seed =&gt; cpp/numeric/random/linear_congruential_engine/seed
std::minstd_rand0::operator() =&gt; cpp/numeric/random/linear_congruential_engine/operator()
std::minstd_rand0::discard =&gt; cpp/numeric/random/linear_congruential_engine/discard
std::minstd_rand0::min =&gt; cpp/numeric/random/linear_congruential_engine/min
std::minstd_rand0::max =&gt; cpp/numeric/random/linear_congruential_engine/max
operator==(std::minstd_rand0) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator!=(std::minstd_rand0) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator&lt;&lt;(std::minstd_rand0) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
operator&gt;&gt;(std::minstd_rand0) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
std::minstd_rand =&gt; cpp/numeric/random/linear_congruential_engine
std::minstd_rand::minstd_rand =&gt; cpp/numeric/random/linear_congruential_engine/linear_congruential_engine
std::minstd_rand::seed =&gt; cpp/numeric/random/linear_congruential_engine/seed
std::minstd_rand::operator() =&gt; cpp/numeric/random/linear_congruential_engine/operator()
std::minstd_rand::discard =&gt; cpp/numeric/random/linear_congruential_engine/discard
std::minstd_rand::min =&gt; cpp/numeric/random/linear_congruential_engine/min
std::minstd_rand::max =&gt; cpp/numeric/random/linear_congruential_engine/max
operator==(std::minstd_rand) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator!=(std::minstd_rand) =&gt; cpp/numeric/random/linear_congruential_engine/operator_cmp
operator&lt;&lt;(std::minstd_rand) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
operator&gt;&gt;(std::minstd_rand) =&gt; cpp/numeric/random/linear_congruential_engine/operator_ltltgtgt
std::mt19937 =&gt; cpp/numeric/random/mersenne_twister_engine
std::mt19937::mt19937 =&gt; cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine
std::mt19937::seed =&gt; cpp/numeric/random/mersenne_twister_engine/seed
std::mt19937::operator() =&gt; cpp/numeric/random/mersenne_twister_engine/operator()
std::mt19937::discard =&gt; cpp/numeric/random/mersenne_twister_engine/discard
std::mt19937::min =&gt; cpp/numeric/random/mersenne_twister_engine/min
std::mt19937::max =&gt; cpp/numeric/random/mersenne_twister_engine/max
operator==(std::mt19937) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator!=(std::mt19937) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator&lt;&lt;(std::mt19937) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
operator&gt;&gt;(std::mt19937) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
std::mt19937_64 =&gt; cpp/numeric/random/mersenne_twister_engine
std::mt19937_64::mt19937_64 =&gt; cpp/numeric/random/mersenne_twister_engine/mersenne_twister_engine
std::mt19937_64::seed =&gt; cpp/numeric/random/mersenne_twister_engine/seed
std::mt19937_64::operator() =&gt; cpp/numeric/random/mersenne_twister_engine/operator()
std::mt19937_64::discard =&gt; cpp/numeric/random/mersenne_twister_engine/discard
std::mt19937_64::min =&gt; cpp/numeric/random/mersenne_twister_engine/min
std::mt19937_64::max =&gt; cpp/numeric/random/mersenne_twister_engine/max
operator==(std::mt19937_64) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator!=(std::mt19937_64) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_cmp
operator&lt;&lt;(std::mt19937_64) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
operator&gt;&gt;(std::mt19937_64) =&gt; cpp/numeric/random/mersenne_twister_engine/operator_ltltgtgt
std::ranlux24_base =&gt; cpp/numeric/random/subtract_with_carry_engine
std::ranlux24_base::ranlux24_base =&gt; cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine
std::ranlux24_base::seed =&gt; cpp/numeric/random/subtract_with_carry_engine/seed
std::ranlux24_base::operator() =&gt; cpp/numeric/random/subtract_with_carry_engine/operator()
std::ranlux24_base::discard =&gt; cpp/numeric/random/subtract_with_carry_engine/discard
std::ranlux24_base::min =&gt; cpp/numeric/random/subtract_with_carry_engine/min
std::ranlux24_base::max =&gt; cpp/numeric/random/subtract_with_carry_engine/max
operator==(std::ranlux24_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator!=(std::ranlux24_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator&lt;&lt;(std::ranlux24_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
operator&gt;&gt;(std::ranlux24_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
std::ranlux48_base =&gt; cpp/numeric/random/subtract_with_carry_engine
std::ranlux48_base::ranlux48_base =&gt; cpp/numeric/random/subtract_with_carry_engine/subtract_with_carry_engine
std::ranlux48_base::seed =&gt; cpp/numeric/random/subtract_with_carry_engine/seed
std::ranlux48_base::operator() =&gt; cpp/numeric/random/subtract_with_carry_engine/operator()
std::ranlux48_base::discard =&gt; cpp/numeric/random/subtract_with_carry_engine/discard
std::ranlux48_base::min =&gt; cpp/numeric/random/subtract_with_carry_engine/min
std::ranlux48_base::max =&gt; cpp/numeric/random/subtract_with_carry_engine/max
operator==(std::ranlux48_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator!=(std::ranlux48_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_cmp
operator&lt;&lt;(std::ranlux48_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
operator&gt;&gt;(std::ranlux48_base) =&gt; cpp/numeric/random/subtract_with_carry_engine/operator_ltltgtgt
std::ranlux24 =&gt; cpp/numeric/random/discard_block_engine
std::ranlux24::ranlux24 =&gt; cpp/numeric/random/discard_block_engine/discard_block_engine
std::ranlux24::seed =&gt; cpp/numeric/random/discard_block_engine/seed
std::ranlux24::base =&gt; cpp/numeric/random/discard_block_engine/base
std::ranlux24::operator() =&gt; cpp/numeric/random/discard_block_engine/operator()
std::ranlux24::discard =&gt; cpp/numeric/random/discard_block_engine/discard
std::ranlux24::min =&gt; cpp/numeric/random/discard_block_engine/min
std::ranlux24::max =&gt; cpp/numeric/random/discard_block_engine/max
operator==(std::ranlux24) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator!=(std::ranlux24) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator&lt;&lt;(std::ranlux24) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
operator&gt;&gt;(std::ranlux24) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
std::ranlux48 =&gt; cpp/numeric/random/discard_block_engine
std::ranlux48::ranlux48 =&gt; cpp/numeric/random/discard_block_engine/discard_block_engine
std::ranlux48::seed =&gt; cpp/numeric/random/discard_block_engine/seed
std::ranlux48::base =&gt; cpp/numeric/random/discard_block_engine/base
std::ranlux48::operator() =&gt; cpp/numeric/random/discard_block_engine/operator()
std::ranlux48::discard =&gt; cpp/numeric/random/discard_block_engine/discard
std::ranlux48::min =&gt; cpp/numeric/random/discard_block_engine/min
std::ranlux48::max =&gt; cpp/numeric/random/discard_block_engine/max
operator==(std::ranlux48) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator!=(std::ranlux48) =&gt; cpp/numeric/random/discard_block_engine/operator_cmp
operator&lt;&lt;(std::ranlux48) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
operator&gt;&gt;(std::ranlux48) =&gt; cpp/numeric/random/discard_block_engine/operator_ltltgtgt
std::knuth_b =&gt; cpp/numeric/random/shuffle_order_engine
std::knuth_b::knuth_b =&gt; cpp/numeric/random/shuffle_order_engine/shuffle_order_engine
std::knuth_b::seed =&gt; cpp/numeric/random/shuffle_order_engine/seed
std::knuth_b::base =&gt; cpp/numeric/random/shuffle_order_engine/base
std::knuth_b::operator() =&gt; cpp/numeric/random/shuffle_order_engine/operator()
std::knuth_b::discard =&gt; cpp/numeric/random/shuffle_order_engine/discard
std::knuth_b::min =&gt; cpp/numeric/random/shuffle_order_engine/min
std::knuth_b::max =&gt; cpp/numeric/random/shuffle_order_engine/max
operator==(std::knuth_b) =&gt; cpp/numeric/random/shuffle_order_engine/operator_cmp
operator!=(std::knuth_b) =&gt; cpp/numeric/random/shuffle_order_engine/operator_cmp
operator&lt;&lt;(std::knuth_b) =&gt; cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt
operator&gt;&gt;(std::knuth_b) =&gt; cpp/numeric/random/shuffle_order_engine/operator_ltltgtgt
std::default_random_engine =&gt; cpp/numeric/random
std::srand =&gt; cpp/numeric/random/srand
std::rand =&gt; cpp/numeric/random/rand
RAND_MAX =&gt; cpp/numeric/random/RAND_MAX
std::generate_canonical =&gt; cpp/numeric/random/generate_canonical
std::seed_seq =&gt; cpp/numeric/random/seed_seq
std::seed_seq::seed_seq =&gt; cpp/numeric/random/seed_seq/seed_seq
std::seed_seq::generate =&gt; cpp/numeric/random/seed_seq/generate
std::seed_seq::size =&gt; cpp/numeric/random/seed_seq/size
std::seed_seq::param =&gt; cpp/numeric/random/seed_seq/param
std::uniform_int_distribution =&gt; cpp/numeric/random/uniform_int_distribution
std::uniform_int_distribution::uniform_int_distribution =&gt; cpp/numeric/random/uniform_int_distribution/uniform_int_distribution
std::uniform_int_distribution::reset =&gt; cpp/numeric/random/uniform_int_distribution/reset
std::uniform_int_distribution::operator() =&gt; cpp/numeric/random/uniform_int_distribution/operator()
std::uniform_int_distribution::a =&gt; cpp/numeric/random/uniform_int_distribution/params
std::uniform_int_distribution::b =&gt; cpp/numeric/random/uniform_int_distribution/params
std::uniform_int_distribution::param =&gt; cpp/numeric/random/uniform_int_distribution/param
std::uniform_int_distribution::min =&gt; cpp/numeric/random/uniform_int_distribution/min
std::uniform_int_distribution::max =&gt; cpp/numeric/random/uniform_int_distribution/max
operator==(std::uniform_int_distribution) =&gt; cpp/numeric/random/uniform_int_distribution/operator_cmp
operator!=(std::uniform_int_distribution) =&gt; cpp/numeric/random/uniform_int_distribution/operator_cmp
operator&lt;&lt;(std::uniform_int_distribution) =&gt; cpp/numeric/random/uniform_int_distribution/operator_ltltgtgt
operator&gt;&gt;(std::uniform_int_distribution) =&gt; cpp/numeric/random/uniform_int_distribution/operator_ltltgtgt
std::uniform_real_distribution =&gt; cpp/numeric/random/uniform_real_distribution
std::uniform_real_distribution::uniform_real_distribution =&gt; cpp/numeric/random/uniform_real_distribution/uniform_real_distribution
std::uniform_real_distribution::reset =&gt; cpp/numeric/random/uniform_real_distribution/reset
operator()(std::uniform_real_distribution) =&gt; cpp/numeric/random/uniform_real_distribution/operator()
std::uniform_real_distribution::a =&gt; cpp/numeric/random/uniform_real_distribution/params
std::uniform_real_distribution::b =&gt; cpp/numeric/random/uniform_real_distribution/params
std::uniform_real_distribution::param =&gt; cpp/numeric/random/uniform_real_distribution/param
std::uniform_real_distribution::min =&gt; cpp/numeric/random/uniform_real_distribution/min
std::uniform_real_distribution::max =&gt; cpp/numeric/random/uniform_real_distribution/max
operator==(std::uniform_real_distribution) =&gt; cpp/numeric/random/uniform_real_distribution/operator_cmp
operator!=(std::uniform_real_distribution) =&gt; cpp/numeric/random/uniform_real_distribution/operator_cmp
operator&lt;&lt;(std::uniform_real_distribution) =&gt; cpp/numeric/random/uniform_real_distribution/operator_ltltgtgt
operator&gt;&gt;(std::uniform_real_distribution) =&gt; cpp/numeric/random/uniform_real_distribution/operator_ltltgtgt
std::bernoulli_distribution =&gt; cpp/numeric/random/bernoulli_distribution
std::bernoulli_distribution::bernoulli_distribution =&gt; cpp/numeric/random/bernoulli_distribution/bernoulli_distribution
std::bernoulli_distribution::reset =&gt; cpp/numeric/random/bernoulli_distribution/reset
operator()(std::bernoulli_distribution) =&gt; cpp/numeric/random/bernoulli_distribution/operator()
std::bernoulli_distribution::p =&gt; cpp/numeric/random/bernoulli_distribution/p
std::bernoulli_distribution::param =&gt; cpp/numeric/random/bernoulli_distribution/param
std::bernoulli_distribution::min =&gt; cpp/numeric/random/bernoulli_distribution/min
std::bernoulli_distribution::max =&gt; cpp/numeric/random/bernoulli_distribution/max
operator==(std::bernoulli_distribution) =&gt; cpp/numeric/random/bernoulli_distribution/operator_cmp
operator!=(std::bernoulli_distribution) =&gt; cpp/numeric/random/bernoulli_distribution/operator_cmp
operator&lt;&lt;(std::bernoulli_distribution) =&gt; cpp/numeric/random/bernoulli_distribution/operator_ltltgtgt
operator&gt;&gt;(std::bernoulli_distribution) =&gt; cpp/numeric/random/bernoulli_distribution/operator_ltltgtgt
std::binomial_distribution =&gt; cpp/numeric/random/binomial_distribution
std::binomial_distribution::binomial_distribution =&gt; cpp/numeric/random/binomial_distribution/binomial_distribution
std::binomial_distribution::reset =&gt; cpp/numeric/random/binomial_distribution/reset
operator()(std::binomial_distribution) =&gt; cpp/numeric/random/binomial_distribution/operator()
std::binomial_distribution::t =&gt; cpp/numeric/random/binomial_distribution/params
std::binomial_distribution::p =&gt; cpp/numeric/random/binomial_distribution/params
std::binomial_distribution::param =&gt; cpp/numeric/random/binomial_distribution/param
std::binomial_distribution::min =&gt; cpp/numeric/random/binomial_distribution/min
std::binomial_distribution::max =&gt; cpp/numeric/random/binomial_distribution/max
operator==(std::binomial_distribution) =&gt; cpp/numeric/random/binomial_distribution/operator_cmp
operator!=(std::binomial_distribution) =&gt; cpp/numeric/random/binomial_distribution/operator_cmp
operator&lt;&lt;(std::binomial_distribution) =&gt; cpp/numeric/random/binomial_distribution/operator_ltltgtgt
operator&gt;&gt;(std::binomial_distribution) =&gt; cpp/numeric/random/binomial_distribution/operator_ltltgtgt
std::negative_binomial_distribution =&gt; cpp/numeric/random/negative_binomial_distribution
std::negative_binomial_distribution::negative_binomial_distribution =&gt; cpp/numeric/random/negative_binomial_distribution/negative_binomial_distribution
std::negative_binomial_distribution::reset =&gt; cpp/numeric/random/negative_binomial_distribution/reset
operator()(std::negative_binomial_distribution) =&gt; cpp/numeric/random/negative_binomial_distribution/operator()
std::negative_binomial_distribution::k =&gt; cpp/numeric/random/negative_binomial_distribution/params
std::negative_binomial_distribution::p =&gt; cpp/numeric/random/negative_binomial_distribution/params
std::negative_binomial_distribution::param =&gt; cpp/numeric/random/negative_binomial_distribution/param
std::negative_binomial_distribution::min =&gt; cpp/numeric/random/negative_binomial_distribution/min
std::negative_binomial_distribution::max =&gt; cpp/numeric/random/negative_binomial_distribution/max
operator==(std::negative_binomial_distribution) =&gt; cpp/numeric/random/negative_binomial_distribution/operator_cmp
operator!=(std::negative_binomial_distribution) =&gt; cpp/numeric/random/negative_binomial_distribution/operator_cmp
operator&lt;&lt;(std::negative_binomial_distribution) =&gt; cpp/numeric/random/negative_binomial_distribution/operator_ltltgtgt
operator&gt;&gt;(std::negative_binomial_distribution) =&gt; cpp/numeric/random/negative_binomial_distribution/operator_ltltgtgt
std::geometric_distribution =&gt; cpp/numeric/random/geometric_distribution
std::geometric_distribution::geometric_distribution =&gt; cpp/numeric/random/geometric_distribution/geometric_distribution
std::geometric_distribution::reset =&gt; cpp/numeric/random/geometric_distribution/reset
operator()(std::geometric_distribution) =&gt; cpp/numeric/random/geometric_distribution/operator()
std::geometric_distribution::p =&gt; cpp/numeric/random/geometric_distribution/p
std::geometric_distribution::param =&gt; cpp/numeric/random/geometric_distribution/param
std::geometric_distribution::min =&gt; cpp/numeric/random/geometric_distribution/min
std::geometric_distribution::max =&gt; cpp/numeric/random/geometric_distribution/max
operator==(std::geometric_distribution) =&gt; cpp/numeric/random/geometric_distribution/operator_cmp
operator!=(std::geometric_distribution) =&gt; cpp/numeric/random/geometric_distribution/operator_cmp
operator&lt;&lt;(std::geometric_distribution) =&gt; cpp/numeric/random/geometric_distribution/operator_ltltgtgt
operator&gt;&gt;(std::geometric_distribution) =&gt; cpp/numeric/random/geometric_distribution/operator_ltltgtgt
std::poisson_distribution =&gt; cpp/numeric/random/poisson_distribution
std::poisson_distribution::poisson_distribution =&gt; cpp/numeric/random/poisson_distribution/poisson_distribution
std::poisson_distribution::reset =&gt; cpp/numeric/random/poisson_distribution/reset
operator()(std::poisson_distribution) =&gt; cpp/numeric/random/poisson_distribution/operator()
std::poisson_distribution::mean =&gt; cpp/numeric/random/poisson_distribution/mean
std::poisson_distribution::param =&gt; cpp/numeric/random/poisson_distribution/param
std::poisson_distribution::min =&gt; cpp/numeric/random/poisson_distribution/min
std::poisson_distribution::max =&gt; cpp/numeric/random/poisson_distribution/max
operator==(std::poisson_distribution) =&gt; cpp/numeric/random/poisson_distribution/operator_cmp
operator!=(std::poisson_distribution) =&gt; cpp/numeric/random/poisson_distribution/operator_cmp
operator&lt;&lt;(std::poisson_distribution) =&gt; cpp/numeric/random/poisson_distribution/operator_ltltgtgt
operator&gt;&gt;(std::poisson_distribution) =&gt; cpp/numeric/random/poisson_distribution/operator_ltltgtgt
std::exponential_distribution =&gt; cpp/numeric/random/exponential_distribution
std::exponential_distribution::exponential_distribution =&gt; cpp/numeric/random/exponential_distribution/exponential_distribution
std::exponential_distribution::reset =&gt; cpp/numeric/random/exponential_distribution/reset
std::exponential_distribution::operator() =&gt; cpp/numeric/random/exponential_distribution/operator()
std::exponential_distribution::lambda =&gt; cpp/numeric/random/exponential_distribution/lambda
std::exponential_distribution::param =&gt; cpp/numeric/random/exponential_distribution/param
std::exponential_distribution::min =&gt; cpp/numeric/random/exponential_distribution/min
std::exponential_distribution::max =&gt; cpp/numeric/random/exponential_distribution/max
operator==(std::exponential_distribution) =&gt; cpp/numeric/random/exponential_distribution/operator_cmp
operator!=(std::exponential_distribution) =&gt; cpp/numeric/random/exponential_distribution/operator_cmp
operator&lt;&lt;(std::exponential_distribution) =&gt; cpp/numeric/random/exponential_distribution/operator_ltltgtgt
operator&gt;&gt;(std::exponential_distribution) =&gt; cpp/numeric/random/exponential_distribution/operator_ltltgtgt
std::gamma_distribution =&gt; cpp/numeric/random/gamma_distribution
std::gamma_distribution::gamma_distribution =&gt; cpp/numeric/random/gamma_distribution/gamma_distribution
std::gamma_distribution::reset =&gt; cpp/numeric/random/gamma_distribution/reset
std::gamma_distribution::operator() =&gt; cpp/numeric/random/gamma_distribution/operator()
std::gamma_distribution::alpha =&gt; cpp/numeric/random/gamma_distribution/params
std::gamma_distribution::beta =&gt; cpp/numeric/random/gamma_distribution/params
std::gamma_distribution::param =&gt; cpp/numeric/random/gamma_distribution/param
std::gamma_distribution::min =&gt; cpp/numeric/random/gamma_distribution/min
std::gamma_distribution::max =&gt; cpp/numeric/random/gamma_distribution/max
operator==(std::gamma_distribution) =&gt; cpp/numeric/random/gamma_distribution/operator_cmp
operator!=(std::gamma_distribution) =&gt; cpp/numeric/random/gamma_distribution/operator_cmp
operator&lt;&lt;(std::gamma_distribution) =&gt; cpp/numeric/random/gamma_distribution/operator_ltltgtgt
operator&gt;&gt;(std::gamma_distribution) =&gt; cpp/numeric/random/gamma_distribution/operator_ltltgtgt
std::weibull_distribution =&gt; cpp/numeric/random/weibull_distribution
std::weibull_distribution::weibull_distribution =&gt; cpp/numeric/random/weibull_distribution/weibull_distribution
std::weibull_distribution::reset =&gt; cpp/numeric/random/weibull_distribution/reset
std::weibull_distribution::operator() =&gt; cpp/numeric/random/weibull_distribution/operator()
std::weibull_distribution::a =&gt; cpp/numeric/random/weibull_distribution/params
std::weibull_distribution::b =&gt; cpp/numeric/random/weibull_distribution/params
std::weibull_distribution::param =&gt; cpp/numeric/random/weibull_distribution/param
std::weibull_distribution::min =&gt; cpp/numeric/random/weibull_distribution/min
std::weibull_distribution::max =&gt; cpp/numeric/random/weibull_distribution/max
operator==(std::weibull_distribution) =&gt; cpp/numeric/random/weibull_distribution/operator_cmp
operator!=(std::weibull_distribution) =&gt; cpp/numeric/random/weibull_distribution/operator_cmp
operator&lt;&lt;(std::weibull_distribution) =&gt; cpp/numeric/random/weibull_distribution/operator_ltltgtgt
operator&gt;&gt;(std::weibull_distribution) =&gt; cpp/numeric/random/weibull_distribution/operator_ltltgtgt
std::extreme_value_distribution =&gt; cpp/numeric/random/extreme_value_distribution
std::extreme_value_distribution::extreme_value_distribution =&gt; cpp/numeric/random/extreme_value_distribution/extreme_value_distribution
std::extreme_value_distribution::reset =&gt; cpp/numeric/random/extreme_value_distribution/reset
std::extreme_value_distribution::operator() =&gt; cpp/numeric/random/extreme_value_distribution/operator()
std::extreme_value_distribution::a =&gt; cpp/numeric/random/extreme_value_distribution/params
std::extreme_value_distribution::b =&gt; cpp/numeric/random/extreme_value_distribution/params
std::extreme_value_distribution::param =&gt; cpp/numeric/random/extreme_value_distribution/param
std::extreme_value_distribution::min =&gt; cpp/numeric/random/extreme_value_distribution/min
std::extreme_value_distribution::max =&gt; cpp/numeric/random/extreme_value_distribution/max
operator==(std::extreme_value_distribution) =&gt; cpp/numeric/random/extreme_value_distribution/operator_cmp
operator!=(std::extreme_value_distribution) =&gt; cpp/numeric/random/extreme_value_distribution/operator_cmp
operator&lt;&lt;(std::extreme_value_distribution) =&gt; cpp/numeric/random/extreme_value_distribution/operator_ltltgtgt
operator&gt;&gt;(std::extreme_value_distribution) =&gt; cpp/numeric/random/extreme_value_distribution/operator_ltltgtgt
std::normal_distribution =&gt; cpp/numeric/random/normal_distribution
std::normal_distribution::normal_distribution =&gt; cpp/numeric/random/normal_distribution/normal_distribution
std::normal_distribution::reset =&gt; cpp/numeric/random/normal_distribution/reset
std::normal_distribution::operator() =&gt; cpp/numeric/random/normal_distribution/operator()
std::normal_distribution::mean =&gt; cpp/numeric/random/normal_distribution/params
std::normal_distribution::stddev =&gt; cpp/numeric/random/normal_distribution/params
std::normal_distribution::param =&gt; cpp/numeric/random/normal_distribution/param
std::normal_distribution::min =&gt; cpp/numeric/random/normal_distribution/min
std::normal_distribution::max =&gt; cpp/numeric/random/normal_distribution/max
operator==(std::normal_distribution) =&gt; cpp/numeric/random/normal_distribution/operator_cmp
operator!=(std::normal_distribution) =&gt; cpp/numeric/random/normal_distribution/operator_cmp
operator&lt;&lt;(std::normal_distribution) =&gt; cpp/numeric/random/normal_distribution/operator_ltltgtgt
operator&gt;&gt;(std::normal_distribution) =&gt; cpp/numeric/random/normal_distribution/operator_ltltgtgt
std::lognormal_distribution =&gt; cpp/numeric/random/lognormal_distribution
std::lognormal_distribution::lognormal_distribution =&gt; cpp/numeric/random/lognormal_distribution/lognormal_distribution
std::lognormal_distribution::reset =&gt; cpp/numeric/random/lognormal_distribution/reset
std::lognormal_distribution::operator() =&gt; cpp/numeric/random/lognormal_distribution/operator()
std::lognormal_distribution::m =&gt; cpp/numeric/random/lognormal_distribution/params
std::lognormal_distribution::s =&gt; cpp/numeric/random/lognormal_distribution/params
std::lognormal_distribution::param =&gt; cpp/numeric/random/lognormal_distribution/param
std::lognormal_distribution::min =&gt; cpp/numeric/random/lognormal_distribution/min
std::lognormal_distribution::max =&gt; cpp/numeric/random/lognormal_distribution/max
operator==(std::lognormal_distribution) =&gt; cpp/numeric/random/lognormal_distribution/operator_cmp
operator!=(std::lognormal_distribution) =&gt; cpp/numeric/random/lognormal_distribution/operator_cmp
operator&lt;&lt;(std::lognormal_distribution) =&gt; cpp/numeric/random/lognormal_distribution/operator_ltltgtgt
operator&gt;&gt;(std::lognormal_distribution) =&gt; cpp/numeric/random/lognormal_distribution/operator_ltltgtgt
std::chi_squared_distribution =&gt; cpp/numeric/random/chi_squared_distribution
std::chi_squared_distribution::chi_squared_distribution =&gt; cpp/numeric/random/chi_squared_distribution/chi_squared_distribution
std::chi_squared_distribution::reset =&gt; cpp/numeric/random/chi_squared_distribution/reset
std::chi_squared_distribution::operator() =&gt; cpp/numeric/random/chi_squared_distribution/operator()
std::chi_squared_distribution::n =&gt; cpp/numeric/random/chi_squared_distribution/n
std::chi_squared_distribution::param =&gt; cpp/numeric/random/chi_squared_distribution/param
std::chi_squared_distribution::min =&gt; cpp/numeric/random/chi_squared_distribution/min
std::chi_squared_distribution::max =&gt; cpp/numeric/random/chi_squared_distribution/max
operator==(std::chi_squared_distribution) =&gt; cpp/numeric/random/chi_squared_distribution/operator_cmp
operator!=(std::chi_squared_distribution) =&gt; cpp/numeric/random/chi_squared_distribution/operator_cmp
operator&lt;&lt;(std::chi_squared_distribution) =&gt; cpp/numeric/random/chi_squared_distribution/operator_ltltgtgt
operator&gt;&gt;(std::chi_squared_distribution) =&gt; cpp/numeric/random/chi_squared_distribution/operator_ltltgtgt
std::cauchy_distribution =&gt; cpp/numeric/random/cauchy_distribution
std::cauchy_distribution::cauchy_distribution =&gt; cpp/numeric/random/cauchy_distribution/cauchy_distribution
std::cauchy_distribution::reset =&gt; cpp/numeric/random/cauchy_distribution/reset
std::cauchy_distribution::operator() =&gt; cpp/numeric/random/cauchy_distribution/operator()
std::cauchy_distribution::a =&gt; cpp/numeric/random/cauchy_distribution/params
std::cauchy_distribution::b =&gt; cpp/numeric/random/cauchy_distribution/params
std::cauchy_distribution::param =&gt; cpp/numeric/random/cauchy_distribution/param
std::cauchy_distribution::min =&gt; cpp/numeric/random/cauchy_distribution/min
std::cauchy_distribution::max =&gt; cpp/numeric/random/cauchy_distribution/max
operator==(std::cauchy_distribution) =&gt; cpp/numeric/random/cauchy_distribution/operator_cmp
operator!=(std::cauchy_distribution) =&gt; cpp/numeric/random/cauchy_distribution/operator_cmp
operator&lt;&lt;(std::cauchy_distribution) =&gt; cpp/numeric/random/cauchy_distribution/operator_ltltgtgt
operator&gt;&gt;(std::cauchy_distribution) =&gt; cpp/numeric/random/cauchy_distribution/operator_ltltgtgt
std::fisher_f_distribution =&gt; cpp/numeric/random/fisher_f_distribution
std::fisher_f_distribution::fisher_f_distribution =&gt; cpp/numeric/random/fisher_f_distribution/fisher_f_distribution
std::fisher_f_distribution::reset =&gt; cpp/numeric/random/fisher_f_distribution/reset
std::fisher_f_distribution::operator() =&gt; cpp/numeric/random/fisher_f_distribution/operator()
std::fisher_f_distribution::m =&gt; cpp/numeric/random/fisher_f_distribution/params
std::fisher_f_distribution::n =&gt; cpp/numeric/random/fisher_f_distribution/params
std::fisher_f_distribution::param =&gt; cpp/numeric/random/fisher_f_distribution/param
std::fisher_f_distribution::min =&gt; cpp/numeric/random/fisher_f_distribution/min
std::fisher_f_distribution::max =&gt; cpp/numeric/random/fisher_f_distribution/max
operator==(std::fisher_f_distribution) =&gt; cpp/numeric/random/fisher_f_distribution/operator_cmp
operator!=(std::fisher_f_distribution) =&gt; cpp/numeric/random/fisher_f_distribution/operator_cmp
operator&lt;&lt;(std::fisher_f_distribution) =&gt; cpp/numeric/random/fisher_f_distribution/operator_ltltgtgt
operator&gt;&gt;(std::fisher_f_distribution) =&gt; cpp/numeric/random/fisher_f_distribution/operator_ltltgtgt
std::student_t_distribution =&gt; cpp/numeric/random/student_t_distribution
std::student_t_distribution::student_t_distribution =&gt; cpp/numeric/random/student_t_distribution/student_t_distribution
std::student_t_distribution::reset =&gt; cpp/numeric/random/student_t_distribution/reset
std::student_t_distribution::operator() =&gt; cpp/numeric/random/student_t_distribution/operator()
std::student_t_distribution::n =&gt; cpp/numeric/random/student_t_distribution/n
std::student_t_distribution::param =&gt; cpp/numeric/random/student_t_distribution/param
std::student_t_distribution::min =&gt; cpp/numeric/random/student_t_distribution/min
std::student_t_distribution::max =&gt; cpp/numeric/random/student_t_distribution/max
operator==(std::student_t_distribution) =&gt; cpp/numeric/random/student_t_distribution/operator_cmp
operator!=(std::student_t_distribution) =&gt; cpp/numeric/random/student_t_distribution/operator_cmp
operator&lt;&lt;(std::student_t_distribution) =&gt; cpp/numeric/random/student_t_distribution/operator_ltltgtgt
operator&gt;&gt;(std::student_t_distribution) =&gt; cpp/numeric/random/student_t_distribution/operator_ltltgtgt
std::discrete_distribution =&gt; cpp/numeric/random/discrete_distribution
std::discrete_distribution::discrete_distribution =&gt; cpp/numeric/random/discrete_distribution/discrete_distribution
std::discrete_distribution::reset =&gt; cpp/numeric/random/discrete_distribution/reset
std::discrete_distribution::operator() =&gt; cpp/numeric/random/discrete_distribution/operator()
std::discrete_distribution::probabilities =&gt; cpp/numeric/random/discrete_distribution/probabilities
std::discrete_distribution::param =&gt; cpp/numeric/random/discrete_distribution/param
std::discrete_distribution::min =&gt; cpp/numeric/random/discrete_distribution/min
std::discrete_distribution::max =&gt; cpp/numeric/random/discrete_distribution/max
operator==(std::discrete_distribution) =&gt; cpp/numeric/random/discrete_distribution/operator_cmp
operator!=(std::discrete_distribution) =&gt; cpp/numeric/random/discrete_distribution/operator_cmp
operator&lt;&lt;(std::discrete_distribution) =&gt; cpp/numeric/random/discrete_distribution/operator_ltltgtgt
operator&gt;&gt;(std::discrete_distribution) =&gt; cpp/numeric/random/discrete_distribution/operator_ltltgtgt
std::piecewise_constant_distribution =&gt; cpp/numeric/random/piecewise_constant_distribution
std::piecewise_constant_distribution::piecewise_constant_distribution =&gt; cpp/numeric/random/piecewise_constant_distribution/piecewise_constant_distribution
std::piecewise_constant_distribution::reset =&gt; cpp/numeric/random/piecewise_constant_distribution/reset
std::piecewise_constant_distribution::operator() =&gt; cpp/numeric/random/piecewise_constant_distribution/operator()
std::piecewise_constant_distribution::intervals =&gt; cpp/numeric/random/piecewise_constant_distribution/params
std::piecewise_constant_distribution::densities =&gt; cpp/numeric/random/piecewise_constant_distribution/params
std::piecewise_constant_distribution::param =&gt; cpp/numeric/random/piecewise_constant_distribution/param
std::piecewise_constant_distribution::min =&gt; cpp/numeric/random/piecewise_constant_distribution/min
std::piecewise_constant_distribution::max =&gt; cpp/numeric/random/piecewise_constant_distribution/max
operator==(std::piecewise_constant_distribution) =&gt; cpp/numeric/random/piecewise_constant_distribution/operator_cmp
operator!=(std::piecewise_constant_distribution) =&gt; cpp/numeric/random/piecewise_constant_distribution/operator_cmp
operator&lt;&lt;(std::piecewise_constant_distribution) =&gt; cpp/numeric/random/piecewise_constant_distribution/operator_ltltgtgt
operator&gt;&gt;(std::piecewise_constant_distribution) =&gt; cpp/numeric/random/piecewise_constant_distribution/operator_ltltgtgt
std::piecewise_linear_distribution =&gt; cpp/numeric/random/piecewise_linear_distribution
std::piecewise_linear_distribution::piecewise_linear_distribution =&gt; cpp/numeric/random/piecewise_linear_distribution/piecewise_linear_distribution
std::piecewise_linear_distribution::reset =&gt; cpp/numeric/random/piecewise_linear_distribution/reset
std::piecewise_linear_distribution::operator() =&gt; cpp/numeric/random/piecewise_linear_distribution/operator()
std::piecewise_linear_distribution::intervals =&gt; cpp/numeric/random/piecewise_linear_distribution/params
std::piecewise_linear_distribution::densities =&gt; cpp/numeric/random/piecewise_linear_distribution/params
std::piecewise_linear_distribution::param =&gt; cpp/numeric/random/piecewise_linear_distribution/param
std::piecewise_linear_distribution::min =&gt; cpp/numeric/random/piecewise_linear_distribution/min
std::piecewise_linear_distribution::max =&gt; cpp/numeric/random/piecewise_linear_distribution/max
operator==(std::piecewise_linear_distribution) =&gt; cpp/numeric/random/piecewise_linear_distribution/operator_cmp
operator!=(std::piecewise_linear_distribution) =&gt; cpp/numeric/random/piecewise_linear_distribution/operator_cmp
operator&lt;&lt;(std::piecewise_linear_distribution) =&gt; cpp/numeric/random/piecewise_linear_distribution/operator_ltltgtgt
operator&gt;&gt;(std::piecewise_linear_distribution) =&gt; cpp/numeric/random/piecewise_linear_distribution/operator_ltltgtgt
std::ratio =&gt; cpp/numeric/ratio/ratio
std::yocto =&gt; cpp/numeric/ratio/ratio
std::femto =&gt; cpp/numeric/ratio/ratio
std::pico =&gt; cpp/numeric/ratio/ratio
std::nano =&gt; cpp/numeric/ratio/ratio
std::micro =&gt; cpp/numeric/ratio/ratio
std::milli =&gt; cpp/numeric/ratio/ratio
std::centi =&gt; cpp/numeric/ratio/ratio
std::deci =&gt; cpp/numeric/ratio/ratio
std::deca =&gt; cpp/numeric/ratio/ratio
std::hecto =&gt; cpp/numeric/ratio/ratio
std::kilo =&gt; cpp/numeric/ratio/ratio
std::mega =&gt; cpp/numeric/ratio/ratio
std::giga =&gt; cpp/numeric/ratio/ratio
std::tera =&gt; cpp/numeric/ratio/ratio
std::peta =&gt; cpp/numeric/ratio/ratio
std::exa =&gt; cpp/numeric/ratio/ratio
std::zetta =&gt; cpp/numeric/ratio/ratio
std::yotta =&gt; cpp/numeric/ratio/ratio
std::ratio_add =&gt; cpp/numeric/ratio/ratio_add
std::ratio_subtract =&gt; cpp/numeric/ratio/ratio_subtract
std::ratio_multiply =&gt; cpp/numeric/ratio/ratio_multiply
std::ratio_divide =&gt; cpp/numeric/ratio/ratio_divide
std::ratio_equal =&gt; cpp/numeric/ratio/ratio_equal
std::ratio_not_equal =&gt; cpp/numeric/ratio/ratio_not_equal
std::ratio_less =&gt; cpp/numeric/ratio/ratio_less
std::ratio_less_equal =&gt; cpp/numeric/ratio/ratio_less_equal
std::ratio_greater =&gt; cpp/numeric/ratio/ratio_greater
std::ratio_greater_equal =&gt; cpp/numeric/ratio/ratio_greater_equal
std::all_of =&gt; cpp/algorithm/all_any_none_of
std::any_of =&gt; cpp/algorithm/all_any_none_of
std::none_of =&gt; cpp/algorithm/all_any_none_of
std::for_each =&gt; cpp/algorithm/for_each
std::count =&gt; cpp/algorithm/count
std::count_if =&gt; cpp/algorithm/count
std::mismatch =&gt; cpp/algorithm/mismatch
std::equal =&gt; cpp/algorithm/equal
std::find =&gt; cpp/algorithm/find
std::find_if =&gt; cpp/algorithm/find
std::find_if_not =&gt; cpp/algorithm/find
std::find_end =&gt; cpp/algorithm/find_end
std::find_first_of =&gt; cpp/algorithm/find_first_of
std::adjacent_find =&gt; cpp/algorithm/adjacent_find
std::search =&gt; cpp/algorithm/search
std::search_n =&gt; cpp/algorithm/search_n
std::copy =&gt; cpp/algorithm/copy
std::copy_if =&gt; cpp/algorithm/copy
std::copy_n =&gt; cpp/algorithm/copy_n
std::copy_backward =&gt; cpp/algorithm/copy_backward
std::move =&gt; cpp/algorithm/move
std::move_backward =&gt; cpp/algorithm/move_backward
std::fill =&gt; cpp/algorithm/fill
std::fill_n =&gt; cpp/algorithm/fill_n
std::transform =&gt; cpp/algorithm/transform
std::generate =&gt; cpp/algorithm/generate
std::generate_n =&gt; cpp/algorithm/generate_n
std::remove =&gt; cpp/algorithm/remove
std::remove_if =&gt; cpp/algorithm/remove
std::remove_copy =&gt; cpp/algorithm/remove_copy
std::remove_copy_if =&gt; cpp/algorithm/remove_copy
std::replace =&gt; cpp/algorithm/replace
std::replace_if =&gt; cpp/algorithm/replace
std::replace_copy =&gt; cpp/algorithm/replace_copy
std::replace_copy_if =&gt; cpp/algorithm/replace_copy
std::swap =&gt; cpp/algorithm/swap
std::swap_ranges =&gt; cpp/algorithm/swap_ranges
std::iter_swap =&gt; cpp/algorithm/iter_swap
std::reverse =&gt; cpp/algorithm/reverse
std::reverse_copy =&gt; cpp/algorithm/reverse_copy
std::rotate =&gt; cpp/algorithm/rotate
std::rotate_copy =&gt; cpp/algorithm/rotate_copy
std::random_shuffle =&gt; cpp/algorithm/random_shuffle
std::shuffle =&gt; cpp/algorithm/random_shuffle
std::unique =&gt; cpp/algorithm/unique
std::unique_copy =&gt; cpp/algorithm/unique_copy
std::is_partitioned =&gt; cpp/algorithm/is_partitioned
std::partition =&gt; cpp/algorithm/partition
std::partition_copy =&gt; cpp/algorithm/partition_copy
std::stable_partition =&gt; cpp/algorithm/stable_partition
std::partition_point =&gt; cpp/algorithm/partition_point
std::is_sorted =&gt; cpp/algorithm/is_sorted
std::is_sorted_until =&gt; cpp/algorithm/is_sorted_until
std::sort =&gt; cpp/algorithm/sort
std::partial_sort =&gt; cpp/algorithm/partial_sort
std::partial_sort_copy =&gt; cpp/algorithm/partial_sort_copy
std::stable_sort =&gt; cpp/algorithm/stable_sort
std::nth_element =&gt; cpp/algorithm/nth_element
std::lower_bound =&gt; cpp/algorithm/lower_bound
std::upper_bound =&gt; cpp/algorithm/upper_bound
std::binary_search =&gt; cpp/algorithm/binary_search
std::equal_range =&gt; cpp/algorithm/equal_range
std::merge =&gt; cpp/algorithm/merge
std::inplace_merge =&gt; cpp/algorithm/inplace_merge
std::includes =&gt; cpp/algorithm/includes
std::set_difference =&gt; cpp/algorithm/set_difference
std::set_intersection =&gt; cpp/algorithm/set_intersection
std::set_symmetric_difference =&gt; cpp/algorithm/set_symmetric_difference
std::set_union =&gt; cpp/algorithm/set_union
std::is_heap =&gt; cpp/algorithm/is_heap
std::is_heap_until =&gt; cpp/algorithm/is_heap_until
std::make_heap =&gt; cpp/algorithm/make_heap
std::push_heap =&gt; cpp/algorithm/push_heap
std::pop_heap =&gt; cpp/algorithm/pop_heap
std::sort_heap =&gt; cpp/algorithm/sort_heap
std::max =&gt; cpp/algorithm/max
std::max_element =&gt; cpp/algorithm/max_element
std::min =&gt; cpp/algorithm/min
std::min_element =&gt; cpp/algorithm/min_element
std::minmax =&gt; cpp/algorithm/minmax
std::minmax_element =&gt; cpp/algorithm/minmax_element
std::lexicographical_compare =&gt; cpp/algorithm/lexicographical_compare
std::is_permutation =&gt; cpp/algorithm/is_permutation
std::next_permutation =&gt; cpp/algorithm/next_permutation
std::prev_permutation =&gt; cpp/algorithm/prev_permutation
std::accumulate =&gt; cpp/algorithm/accumulate
std::inner_product =&gt; cpp/algorithm/inner_product
std::adjacent_difference =&gt; cpp/algorithm/adjacent_difference
std::partial_sum =&gt; cpp/algorithm/partial_sum
std::iota =&gt; cpp/algorithm/iota
std::qsort =&gt; cpp/algorithm/qsort
std::bsearch =&gt; cpp/algorithm/bsearch
std::basic_streambuf =&gt; cpp/io/basic_streambuf
std::basic_streambuf::basic_streambuf =&gt; cpp/io/basic_streambuf/basic_streambuf
std::basic_streambuf::~basic_streambuf =&gt; cpp/io/basic_streambuf/~basic_streambuf
std::basic_streambuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_streambuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::basic_streambuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_streambuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_streambuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_streambuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_streambuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::basic_streambuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::basic_streambuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::basic_streambuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::basic_streambuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_streambuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::basic_streambuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_streambuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::basic_streambuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::basic_streambuf::operator= =&gt; cpp/io/basic_streambuf/operator=
std::basic_streambuf::swap =&gt; cpp/io/basic_streambuf/swap
std::basic_streambuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_streambuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_streambuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_streambuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_streambuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_streambuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::basic_streambuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::basic_streambuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::basic_streambuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_streambuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::basic_streambuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_streambuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_streambuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::basic_streambuf::setg =&gt; cpp/io/basic_streambuf/setg
std::basic_streambuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_streambuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::basic_streambuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::basic_streambuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_streambuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_streambuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::basic_streambuf::setp =&gt; cpp/io/basic_streambuf/setp
std::basic_streambuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::basic_filebuf =&gt; cpp/io/basic_filebuf
std::basic_filebuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_filebuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::basic_filebuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_filebuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_filebuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_filebuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_filebuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::basic_filebuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::basic_filebuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::basic_filebuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::basic_filebuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_filebuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::basic_filebuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_filebuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::basic_filebuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::basic_filebuf::swap =&gt; cpp/io/basic_streambuf/swap
std::basic_filebuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_filebuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_filebuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_filebuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_filebuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_filebuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::basic_filebuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::basic_filebuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::basic_filebuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_filebuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::basic_filebuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_filebuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_filebuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::basic_filebuf::setg =&gt; cpp/io/basic_streambuf/setg
std::basic_filebuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_filebuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::basic_filebuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::basic_filebuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_filebuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_filebuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::basic_filebuf::setp =&gt; cpp/io/basic_streambuf/setp
std::basic_filebuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::basic_filebuf::basic_filebuf =&gt; cpp/io/basic_filebuf/basic_filebuf
std::basic_filebuf::~basic_filebuf =&gt; cpp/io/basic_filebuf/~basic_filebuf
std::basic_filebuf::operator= =&gt; cpp/io/basic_filebuf/operator=
std::basic_filebuf::swap =&gt; cpp/io/basic_filebuf/swap
std::basic_filebuf::str =&gt; cpp/io/basic_filebuf/str
std::basic_filebuf::is_open =&gt; cpp/io/basic_filebuf/is_open
std::basic_filebuf::open =&gt; cpp/io/basic_filebuf/open
std::basic_filebuf::close =&gt; cpp/io/basic_filebuf/close
std::basic_filebuf::showmanyc =&gt; cpp/io/basic_filebuf/showmanyc
std::basic_filebuf::underflow =&gt; cpp/io/basic_filebuf/underflow
std::basic_filebuf::uflow =&gt; cpp/io/basic_filebuf/uflow
std::basic_filebuf::pbackfail =&gt; cpp/io/basic_filebuf/pbackfail
std::basic_filebuf::overflow =&gt; cpp/io/basic_filebuf/overflow
std::basic_filebuf::setbuf =&gt; cpp/io/basic_filebuf/setbuf
std::basic_filebuf::seekoff =&gt; cpp/io/basic_filebuf/seekoff
std::basic_filebuf::seekpos =&gt; cpp/io/basic_filebuf/seekpos
std::basic_filebuf::sync =&gt; cpp/io/basic_filebuf/sync
std::basic_filebuf::imbue =&gt; cpp/io/basic_filebuf/imbue
std::swap(std::basic_filebuf) =&gt; cpp/io/basic_filebuf/swap2
std::basic_stringbuf =&gt; cpp/io/basic_stringbuf
std::basic_stringbuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_stringbuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::basic_stringbuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_stringbuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_stringbuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_stringbuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_stringbuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::basic_stringbuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::basic_stringbuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::basic_stringbuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::basic_stringbuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_stringbuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::basic_stringbuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_stringbuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::basic_stringbuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::basic_stringbuf::swap =&gt; cpp/io/basic_streambuf/swap
std::basic_stringbuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::basic_stringbuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::basic_stringbuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::basic_stringbuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::basic_stringbuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::basic_stringbuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::basic_stringbuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::basic_stringbuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::basic_stringbuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::basic_stringbuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::basic_stringbuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_stringbuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::basic_stringbuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::basic_stringbuf::setg =&gt; cpp/io/basic_streambuf/setg
std::basic_stringbuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::basic_stringbuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::basic_stringbuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::basic_stringbuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_stringbuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::basic_stringbuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::basic_stringbuf::setp =&gt; cpp/io/basic_streambuf/setp
std::basic_stringbuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::basic_stringbuf::basic_stringbuf =&gt; cpp/io/basic_stringbuf/basic_stringbuf
std::basic_stringbuf::operator= =&gt; cpp/io/basic_stringbuf/operator=
std::basic_stringbuf::swap =&gt; cpp/io/basic_stringbuf/swap
std::basic_stringbuf::str =&gt; cpp/io/basic_stringbuf/str
std::basic_stringbuf::underflow =&gt; cpp/io/basic_stringbuf/underflow
std::basic_stringbuf::pbackfail =&gt; cpp/io/basic_stringbuf/pbackfail
std::basic_stringbuf::overflow =&gt; cpp/io/basic_stringbuf/overflow
std::basic_stringbuf::setbuf =&gt; cpp/io/basic_stringbuf/setbuf
std::basic_stringbuf::seekoff =&gt; cpp/io/basic_stringbuf/seekoff
std::basic_stringbuf::seekpos =&gt; cpp/io/basic_stringbuf/seekpos
std::swap(std::basic_stringbuf) =&gt; cpp/io/basic_stringbuf/swap2
std::ios_base =&gt; cpp/io/ios_base
std::ios_base::ios_base =&gt; cpp/io/ios_base/ios_base
std::ios_base::~ios_base =&gt; cpp/io/ios_base/~ios_base
std::ios_base::flags =&gt; cpp/io/ios_base/flags
std::ios_base::setf =&gt; cpp/io/ios_base/setf
std::ios_base::unsetf =&gt; cpp/io/ios_base/unsetf
std::ios_base::precision =&gt; cpp/io/ios_base/precision
std::ios_base::width =&gt; cpp/io/ios_base/width
std::ios_base::imbue =&gt; cpp/io/ios_base/imbue
std::ios_base::getloc =&gt; cpp/io/ios_base/getloc
std::ios_base::xalloc =&gt; cpp/io/ios_base/xalloc
std::ios_base::iword =&gt; cpp/io/ios_base/iword
std::ios_base::pword =&gt; cpp/io/ios_base/pword
std::ios_base::register_callback =&gt; cpp/io/ios_base/register_callback
std::ios_base::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ios_base::failure =&gt; cpp/io/ios_base/failure
std::ios_base::failure::what =&gt; cpp/error/exception/what
std::ios_base::failure::failure =&gt; cpp/io/ios_base/failure
std::ios_base::openmode =&gt; cpp/io/ios_base/openmode
std::ios_base::app =&gt; cpp/io/ios_base/openmode
std::ios_base::binary =&gt; cpp/io/ios_base/openmode
std::ios_base::in =&gt; cpp/io/ios_base/openmode
std::ios_base::out =&gt; cpp/io/ios_base/openmode
std::ios_base::trunc =&gt; cpp/io/ios_base/openmode
std::ios_base::ate =&gt; cpp/io/ios_base/openmode
std::ios_base::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ios_base::dec =&gt; cpp/io/ios_base/fmtflags
std::ios_base::oct =&gt; cpp/io/ios_base/fmtflags
std::ios_base::hex =&gt; cpp/io/ios_base/fmtflags
std::ios_base::basefield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::left =&gt; cpp/io/ios_base/fmtflags
std::ios_base::right =&gt; cpp/io/ios_base/fmtflags
std::ios_base::internal =&gt; cpp/io/ios_base/fmtflags
std::ios_base::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::scientific =&gt; cpp/io/ios_base/fmtflags
std::ios_base::fixed =&gt; cpp/io/ios_base/fmtflags
std::ios_base::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showbase =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showpos =&gt; cpp/io/ios_base/fmtflags
std::ios_base::skipws =&gt; cpp/io/ios_base/fmtflags
std::ios_base::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ios_base::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ios_base::iostate =&gt; cpp/io/ios_base/iostate
std::ios_base::goodbit =&gt; cpp/io/ios_base/iostate
std::ios_base::badbit =&gt; cpp/io/ios_base/iostate
std::ios_base::failbit =&gt; cpp/io/ios_base/iostate
std::ios_base::eofbit =&gt; cpp/io/ios_base/iostate
std::ios_base::seekdir =&gt; cpp/io/ios_base/seekdir
std::ios_base::beg =&gt; cpp/io/ios_base/seekdir
std::ios_base::cur =&gt; cpp/io/ios_base/seekdir
std::ios_base::end =&gt; cpp/io/ios_base/seekdir
std::ios_base::event =&gt; cpp/io/ios_base/event
std::ios_base::erase_event =&gt; cpp/io/ios_base/event
std::ios_base::imbue_event =&gt; cpp/io/ios_base/event
std::ios_base::copyfmt_event =&gt; cpp/io/ios_base/event
std::ios_base::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ios =&gt; cpp/io/basic_ios
std::basic_ios::flags =&gt; cpp/io/ios_base/flags
std::basic_ios::setf =&gt; cpp/io/ios_base/setf
std::basic_ios::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_ios::precision =&gt; cpp/io/ios_base/precision
std::basic_ios::width =&gt; cpp/io/ios_base/width
std::basic_ios::imbue =&gt; cpp/io/ios_base/imbue
std::basic_ios::getloc =&gt; cpp/io/ios_base/getloc
std::basic_ios::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_ios::iword =&gt; cpp/io/ios_base/iword
std::basic_ios::pword =&gt; cpp/io/ios_base/pword
std::basic_ios::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_ios::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_ios::failure =&gt; cpp/io/ios_base/failure
std::basic_ios::failure::what =&gt; cpp/error/exception/what
std::basic_ios::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_ios::openmode =&gt; cpp/io/ios_base/openmode
std::basic_ios::app =&gt; cpp/io/ios_base/openmode
std::basic_ios::binary =&gt; cpp/io/ios_base/openmode
std::basic_ios::in =&gt; cpp/io/ios_base/openmode
std::basic_ios::out =&gt; cpp/io/ios_base/openmode
std::basic_ios::trunc =&gt; cpp/io/ios_base/openmode
std::basic_ios::ate =&gt; cpp/io/ios_base/openmode
std::basic_ios::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::left =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::right =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_ios::iostate =&gt; cpp/io/ios_base/iostate
std::basic_ios::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_ios::badbit =&gt; cpp/io/ios_base/iostate
std::basic_ios::failbit =&gt; cpp/io/ios_base/iostate
std::basic_ios::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_ios::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_ios::beg =&gt; cpp/io/ios_base/seekdir
std::basic_ios::cur =&gt; cpp/io/ios_base/seekdir
std::basic_ios::end =&gt; cpp/io/ios_base/seekdir
std::basic_ios::event =&gt; cpp/io/ios_base/event
std::basic_ios::erase_event =&gt; cpp/io/ios_base/event
std::basic_ios::imbue_event =&gt; cpp/io/ios_base/event
std::basic_ios::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_ios::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ios::basic_ios =&gt; cpp/io/basic_ios/basic_ios
std::basic_ios::~basic_ios =&gt; cpp/io/basic_ios/~basic_ios
std::basic_ios::good =&gt; cpp/io/basic_ios/good
std::basic_ios::eof =&gt; cpp/io/basic_ios/eof
std::basic_ios::fail =&gt; cpp/io/basic_ios/fail
std::basic_ios::bad =&gt; cpp/io/basic_ios/bad
std::basic_ios::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_ios::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_ios::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_ios::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_ios::clear =&gt; cpp/io/basic_ios/clear
std::basic_ios::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_ios::fill =&gt; cpp/io/basic_ios/fill
std::basic_ios::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_ios::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_ios::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_ios::tie =&gt; cpp/io/basic_ios/tie
std::basic_ios::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_ios::widen =&gt; cpp/io/basic_ios/widen
std::basic_ios::init =&gt; cpp/io/basic_ios/init
std::basic_ios::move =&gt; cpp/io/basic_ios/move
std::basic_ios::swap =&gt; cpp/io/basic_ios/swap
std::basic_ios::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_istream =&gt; cpp/io/basic_istream
std::basic_istream::good =&gt; cpp/io/basic_ios/good
std::basic_istream::eof =&gt; cpp/io/basic_ios/eof
std::basic_istream::fail =&gt; cpp/io/basic_ios/fail
std::basic_istream::bad =&gt; cpp/io/basic_ios/bad
std::basic_istream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_istream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_istream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_istream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_istream::clear =&gt; cpp/io/basic_ios/clear
std::basic_istream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_istream::fill =&gt; cpp/io/basic_ios/fill
std::basic_istream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_istream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_istream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_istream::tie =&gt; cpp/io/basic_ios/tie
std::basic_istream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_istream::widen =&gt; cpp/io/basic_ios/widen
std::basic_istream::init =&gt; cpp/io/basic_ios/init
std::basic_istream::move =&gt; cpp/io/basic_ios/move
std::basic_istream::swap =&gt; cpp/io/basic_ios/swap
std::basic_istream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_istream::flags =&gt; cpp/io/ios_base/flags
std::basic_istream::setf =&gt; cpp/io/ios_base/setf
std::basic_istream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_istream::precision =&gt; cpp/io/ios_base/precision
std::basic_istream::width =&gt; cpp/io/ios_base/width
std::basic_istream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_istream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_istream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_istream::iword =&gt; cpp/io/ios_base/iword
std::basic_istream::pword =&gt; cpp/io/ios_base/pword
std::basic_istream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_istream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_istream::failure =&gt; cpp/io/ios_base/failure
std::basic_istream::failure::what =&gt; cpp/error/exception/what
std::basic_istream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_istream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_istream::app =&gt; cpp/io/ios_base/openmode
std::basic_istream::binary =&gt; cpp/io/ios_base/openmode
std::basic_istream::in =&gt; cpp/io/ios_base/openmode
std::basic_istream::out =&gt; cpp/io/ios_base/openmode
std::basic_istream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_istream::ate =&gt; cpp/io/ios_base/openmode
std::basic_istream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_istream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_istream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_istream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_istream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_istream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_istream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_istream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_istream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_istream::end =&gt; cpp/io/ios_base/seekdir
std::basic_istream::event =&gt; cpp/io/ios_base/event
std::basic_istream::erase_event =&gt; cpp/io/ios_base/event
std::basic_istream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_istream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_istream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_istream::basic_istream =&gt; cpp/io/basic_istream/basic_istream
std::basic_istream::~basic_istream =&gt; cpp/io/basic_istream/~basic_istream
std::basic_istream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_istream::get =&gt; cpp/io/basic_istream/get
std::basic_istream::peek =&gt; cpp/io/basic_istream/peek
std::basic_istream::unget =&gt; cpp/io/basic_istream/unget
std::basic_istream::putback =&gt; cpp/io/basic_istream/putback
std::basic_istream::getline =&gt; cpp/io/basic_istream/getline
std::basic_istream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_istream::read =&gt; cpp/io/basic_istream/read
std::basic_istream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_istream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_istream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_istream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_istream::sync =&gt; cpp/io/basic_istream/sync
std::basic_istream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
operator&gt;&gt;(std::basic_istream) =&gt; cpp/io/basic_istream/operator_gtgt2
std::basic_ostream =&gt; cpp/io/basic_ostream
std::basic_ostream::good =&gt; cpp/io/basic_ios/good
std::basic_ostream::eof =&gt; cpp/io/basic_ios/eof
std::basic_ostream::fail =&gt; cpp/io/basic_ios/fail
std::basic_ostream::bad =&gt; cpp/io/basic_ios/bad
std::basic_ostream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_ostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_ostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_ostream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_ostream::clear =&gt; cpp/io/basic_ios/clear
std::basic_ostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_ostream::fill =&gt; cpp/io/basic_ios/fill
std::basic_ostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_ostream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_ostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_ostream::tie =&gt; cpp/io/basic_ios/tie
std::basic_ostream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_ostream::widen =&gt; cpp/io/basic_ios/widen
std::basic_ostream::init =&gt; cpp/io/basic_ios/init
std::basic_ostream::move =&gt; cpp/io/basic_ios/move
std::basic_ostream::swap =&gt; cpp/io/basic_ios/swap
std::basic_ostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_ostream::flags =&gt; cpp/io/ios_base/flags
std::basic_ostream::setf =&gt; cpp/io/ios_base/setf
std::basic_ostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_ostream::precision =&gt; cpp/io/ios_base/precision
std::basic_ostream::width =&gt; cpp/io/ios_base/width
std::basic_ostream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_ostream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_ostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_ostream::iword =&gt; cpp/io/ios_base/iword
std::basic_ostream::pword =&gt; cpp/io/ios_base/pword
std::basic_ostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_ostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_ostream::failure =&gt; cpp/io/ios_base/failure
std::basic_ostream::failure::what =&gt; cpp/error/exception/what
std::basic_ostream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_ostream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_ostream::app =&gt; cpp/io/ios_base/openmode
std::basic_ostream::binary =&gt; cpp/io/ios_base/openmode
std::basic_ostream::in =&gt; cpp/io/ios_base/openmode
std::basic_ostream::out =&gt; cpp/io/ios_base/openmode
std::basic_ostream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_ostream::ate =&gt; cpp/io/ios_base/openmode
std::basic_ostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_ostream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_ostream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_ostream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_ostream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_ostream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_ostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_ostream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_ostream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_ostream::end =&gt; cpp/io/ios_base/seekdir
std::basic_ostream::event =&gt; cpp/io/ios_base/event
std::basic_ostream::erase_event =&gt; cpp/io/ios_base/event
std::basic_ostream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_ostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_ostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ostream::basic_ostream =&gt; cpp/io/basic_ostream/basic_ostream
std::basic_ostream::~basic_ostream =&gt; cpp/io/basic_ostream/~basic_ostream
std::basic_ostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_ostream::put =&gt; cpp/io/basic_ostream/put
std::basic_ostream::write =&gt; cpp/io/basic_ostream/write
std::basic_ostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_ostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_ostream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_ostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
operator&lt;&lt;(std::basic_ostream) =&gt; cpp/io/basic_ostream/operator_ltlt2
std::basic_iostream =&gt; cpp/io/basic_iostream
std::basic_iostream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_iostream::get =&gt; cpp/io/basic_istream/get
std::basic_iostream::peek =&gt; cpp/io/basic_istream/peek
std::basic_iostream::unget =&gt; cpp/io/basic_istream/unget
std::basic_iostream::putback =&gt; cpp/io/basic_istream/putback
std::basic_iostream::getline =&gt; cpp/io/basic_istream/getline
std::basic_iostream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_iostream::read =&gt; cpp/io/basic_istream/read
std::basic_iostream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_iostream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_iostream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_iostream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_iostream::sync =&gt; cpp/io/basic_istream/sync
std::basic_iostream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_iostream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_iostream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_iostream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::basic_iostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_iostream::put =&gt; cpp/io/basic_ostream/put
std::basic_iostream::write =&gt; cpp/io/basic_ostream/write
std::basic_iostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_iostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_iostream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_iostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_iostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_iostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_iostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::basic_iostream::good =&gt; cpp/io/basic_ios/good
std::basic_iostream::eof =&gt; cpp/io/basic_ios/eof
std::basic_iostream::fail =&gt; cpp/io/basic_ios/fail
std::basic_iostream::bad =&gt; cpp/io/basic_ios/bad
std::basic_iostream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_iostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_iostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_iostream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_iostream::clear =&gt; cpp/io/basic_ios/clear
std::basic_iostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_iostream::fill =&gt; cpp/io/basic_ios/fill
std::basic_iostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_iostream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_iostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_iostream::tie =&gt; cpp/io/basic_ios/tie
std::basic_iostream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_iostream::widen =&gt; cpp/io/basic_ios/widen
std::basic_iostream::init =&gt; cpp/io/basic_ios/init
std::basic_iostream::move =&gt; cpp/io/basic_ios/move
std::basic_iostream::swap =&gt; cpp/io/basic_ios/swap
std::basic_iostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_iostream::flags =&gt; cpp/io/ios_base/flags
std::basic_iostream::setf =&gt; cpp/io/ios_base/setf
std::basic_iostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_iostream::precision =&gt; cpp/io/ios_base/precision
std::basic_iostream::width =&gt; cpp/io/ios_base/width
std::basic_iostream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_iostream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_iostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_iostream::iword =&gt; cpp/io/ios_base/iword
std::basic_iostream::pword =&gt; cpp/io/ios_base/pword
std::basic_iostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_iostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_iostream::failure =&gt; cpp/io/ios_base/failure
std::basic_iostream::failure::what =&gt; cpp/error/exception/what
std::basic_iostream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_iostream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_iostream::app =&gt; cpp/io/ios_base/openmode
std::basic_iostream::binary =&gt; cpp/io/ios_base/openmode
std::basic_iostream::in =&gt; cpp/io/ios_base/openmode
std::basic_iostream::out =&gt; cpp/io/ios_base/openmode
std::basic_iostream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_iostream::ate =&gt; cpp/io/ios_base/openmode
std::basic_iostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_iostream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_iostream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_iostream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_iostream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_iostream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_iostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_iostream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_iostream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_iostream::end =&gt; cpp/io/ios_base/seekdir
std::basic_iostream::event =&gt; cpp/io/ios_base/event
std::basic_iostream::erase_event =&gt; cpp/io/ios_base/event
std::basic_iostream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_iostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_iostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_iostream::basic_iostream =&gt; cpp/io/basic_iostream/basic_iostream
std::basic_iostream::~basic_iostream =&gt; cpp/io/basic_iostream/~basic_iostream
std::basic_ifstream =&gt; cpp/io/basic_ifstream
std::basic_ifstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_ifstream::get =&gt; cpp/io/basic_istream/get
std::basic_ifstream::peek =&gt; cpp/io/basic_istream/peek
std::basic_ifstream::unget =&gt; cpp/io/basic_istream/unget
std::basic_ifstream::putback =&gt; cpp/io/basic_istream/putback
std::basic_ifstream::getline =&gt; cpp/io/basic_istream/getline
std::basic_ifstream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_ifstream::read =&gt; cpp/io/basic_istream/read
std::basic_ifstream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_ifstream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_ifstream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_ifstream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_ifstream::sync =&gt; cpp/io/basic_istream/sync
std::basic_ifstream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_ifstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_ifstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_ifstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::basic_ifstream::good =&gt; cpp/io/basic_ios/good
std::basic_ifstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_ifstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_ifstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_ifstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_ifstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_ifstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_ifstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_ifstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_ifstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_ifstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_ifstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_ifstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_ifstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_ifstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_ifstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_ifstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_ifstream::init =&gt; cpp/io/basic_ios/init
std::basic_ifstream::move =&gt; cpp/io/basic_ios/move
std::basic_ifstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_ifstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_ifstream::flags =&gt; cpp/io/ios_base/flags
std::basic_ifstream::setf =&gt; cpp/io/ios_base/setf
std::basic_ifstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_ifstream::precision =&gt; cpp/io/ios_base/precision
std::basic_ifstream::width =&gt; cpp/io/ios_base/width
std::basic_ifstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_ifstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_ifstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_ifstream::iword =&gt; cpp/io/ios_base/iword
std::basic_ifstream::pword =&gt; cpp/io/ios_base/pword
std::basic_ifstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_ifstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_ifstream::failure =&gt; cpp/io/ios_base/failure
std::basic_ifstream::failure::what =&gt; cpp/error/exception/what
std::basic_ifstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_ifstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::app =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::in =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::out =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_ifstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_ifstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_ifstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_ifstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_ifstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_ifstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_ifstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_ifstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_ifstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_ifstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_ifstream::event =&gt; cpp/io/ios_base/event
std::basic_ifstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_ifstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_ifstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_ifstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ifstream::basic_ifstream =&gt; cpp/io/basic_ifstream/basic_ifstream
std::basic_ifstream::operator= =&gt; cpp/io/basic_ifstream/operator=
std::basic_ifstream::swap =&gt; cpp/io/basic_ifstream/swap
std::basic_ifstream::rdbuf =&gt; cpp/io/basic_ifstream/rdbuf
std::basic_ifstream::is_open =&gt; cpp/io/basic_ifstream/is_open
std::basic_ifstream::open =&gt; cpp/io/basic_ifstream/open
std::basic_ifstream::close =&gt; cpp/io/basic_ifstream/close
std::swap(std::basic_ifstream) =&gt; cpp/io/basic_ifstream/swap2
std::basic_ofstream =&gt; cpp/io/basic_ofstream
std::basic_ofstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_ofstream::put =&gt; cpp/io/basic_ostream/put
std::basic_ofstream::write =&gt; cpp/io/basic_ostream/write
std::basic_ofstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_ofstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_ofstream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_ofstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ofstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ofstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ofstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::basic_ofstream::good =&gt; cpp/io/basic_ios/good
std::basic_ofstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_ofstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_ofstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_ofstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_ofstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_ofstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_ofstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_ofstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_ofstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_ofstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_ofstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_ofstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_ofstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_ofstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_ofstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_ofstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_ofstream::init =&gt; cpp/io/basic_ios/init
std::basic_ofstream::move =&gt; cpp/io/basic_ios/move
std::basic_ofstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_ofstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_ofstream::flags =&gt; cpp/io/ios_base/flags
std::basic_ofstream::setf =&gt; cpp/io/ios_base/setf
std::basic_ofstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_ofstream::precision =&gt; cpp/io/ios_base/precision
std::basic_ofstream::width =&gt; cpp/io/ios_base/width
std::basic_ofstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_ofstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_ofstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_ofstream::iword =&gt; cpp/io/ios_base/iword
std::basic_ofstream::pword =&gt; cpp/io/ios_base/pword
std::basic_ofstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_ofstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_ofstream::failure =&gt; cpp/io/ios_base/failure
std::basic_ofstream::failure::what =&gt; cpp/error/exception/what
std::basic_ofstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_ofstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::app =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::in =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::out =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_ofstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_ofstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_ofstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_ofstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_ofstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_ofstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_ofstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_ofstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_ofstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_ofstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_ofstream::event =&gt; cpp/io/ios_base/event
std::basic_ofstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_ofstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_ofstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_ofstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ofstream::basic_ofstream =&gt; cpp/io/basic_ofstream/basic_ofstream
std::basic_ofstream::operator= =&gt; cpp/io/basic_ofstream/operator=
std::basic_ofstream::swap =&gt; cpp/io/basic_ofstream/swap
std::basic_ofstream::rdbuf =&gt; cpp/io/basic_ofstream/rdbuf
std::basic_ofstream::is_open =&gt; cpp/io/basic_ofstream/is_open
std::basic_ofstream::open =&gt; cpp/io/basic_ofstream/open
std::basic_ofstream::close =&gt; cpp/io/basic_ofstream/close
std::swap(std::basic_ofstream) =&gt; cpp/io/basic_ofstream/swap2
std::basic_fstream =&gt; cpp/io/basic_fstream
std::basic_fstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_fstream::get =&gt; cpp/io/basic_istream/get
std::basic_fstream::peek =&gt; cpp/io/basic_istream/peek
std::basic_fstream::unget =&gt; cpp/io/basic_istream/unget
std::basic_fstream::putback =&gt; cpp/io/basic_istream/putback
std::basic_fstream::getline =&gt; cpp/io/basic_istream/getline
std::basic_fstream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_fstream::read =&gt; cpp/io/basic_istream/read
std::basic_fstream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_fstream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_fstream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_fstream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_fstream::sync =&gt; cpp/io/basic_istream/sync
std::basic_fstream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_fstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_fstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_fstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::basic_fstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_fstream::put =&gt; cpp/io/basic_ostream/put
std::basic_fstream::write =&gt; cpp/io/basic_ostream/write
std::basic_fstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_fstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_fstream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_fstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_fstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_fstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_fstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::basic_fstream::good =&gt; cpp/io/basic_ios/good
std::basic_fstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_fstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_fstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_fstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_fstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_fstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_fstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_fstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_fstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_fstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_fstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_fstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_fstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_fstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_fstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_fstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_fstream::init =&gt; cpp/io/basic_ios/init
std::basic_fstream::move =&gt; cpp/io/basic_ios/move
std::basic_fstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_fstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_fstream::flags =&gt; cpp/io/ios_base/flags
std::basic_fstream::setf =&gt; cpp/io/ios_base/setf
std::basic_fstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_fstream::precision =&gt; cpp/io/ios_base/precision
std::basic_fstream::width =&gt; cpp/io/ios_base/width
std::basic_fstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_fstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_fstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_fstream::iword =&gt; cpp/io/ios_base/iword
std::basic_fstream::pword =&gt; cpp/io/ios_base/pword
std::basic_fstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_fstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_fstream::failure =&gt; cpp/io/ios_base/failure
std::basic_fstream::failure::what =&gt; cpp/error/exception/what
std::basic_fstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_fstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_fstream::app =&gt; cpp/io/ios_base/openmode
std::basic_fstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_fstream::in =&gt; cpp/io/ios_base/openmode
std::basic_fstream::out =&gt; cpp/io/ios_base/openmode
std::basic_fstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_fstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_fstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_fstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_fstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_fstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_fstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_fstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_fstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_fstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_fstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_fstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_fstream::event =&gt; cpp/io/ios_base/event
std::basic_fstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_fstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_fstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_fstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_fstream::basic_fstream =&gt; cpp/io/basic_fstream/basic_fstream
std::basic_fstream::operator= =&gt; cpp/io/basic_fstream/operator=
std::basic_fstream::swap =&gt; cpp/io/basic_fstream/swap
std::basic_fstream::rdbuf =&gt; cpp/io/basic_fstream/rdbuf
std::basic_fstream::is_open =&gt; cpp/io/basic_fstream/is_open
std::basic_fstream::open =&gt; cpp/io/basic_fstream/open
std::basic_fstream::close =&gt; cpp/io/basic_fstream/close
std::swap(std::basic_fstream) =&gt; cpp/io/basic_fstream/swap2
std::basic_istringstream =&gt; cpp/io/basic_istringstream
std::basic_istringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_istringstream::get =&gt; cpp/io/basic_istream/get
std::basic_istringstream::peek =&gt; cpp/io/basic_istream/peek
std::basic_istringstream::unget =&gt; cpp/io/basic_istream/unget
std::basic_istringstream::putback =&gt; cpp/io/basic_istream/putback
std::basic_istringstream::getline =&gt; cpp/io/basic_istream/getline
std::basic_istringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_istringstream::read =&gt; cpp/io/basic_istream/read
std::basic_istringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_istringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_istringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_istringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_istringstream::sync =&gt; cpp/io/basic_istream/sync
std::basic_istringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_istringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::basic_istringstream::good =&gt; cpp/io/basic_ios/good
std::basic_istringstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_istringstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_istringstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_istringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_istringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_istringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_istringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_istringstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_istringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_istringstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_istringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_istringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_istringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_istringstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_istringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_istringstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_istringstream::init =&gt; cpp/io/basic_ios/init
std::basic_istringstream::move =&gt; cpp/io/basic_ios/move
std::basic_istringstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_istringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_istringstream::flags =&gt; cpp/io/ios_base/flags
std::basic_istringstream::setf =&gt; cpp/io/ios_base/setf
std::basic_istringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_istringstream::precision =&gt; cpp/io/ios_base/precision
std::basic_istringstream::width =&gt; cpp/io/ios_base/width
std::basic_istringstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_istringstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_istringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_istringstream::iword =&gt; cpp/io/ios_base/iword
std::basic_istringstream::pword =&gt; cpp/io/ios_base/pword
std::basic_istringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_istringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_istringstream::failure =&gt; cpp/io/ios_base/failure
std::basic_istringstream::failure::what =&gt; cpp/error/exception/what
std::basic_istringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_istringstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::app =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::in =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::out =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_istringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_istringstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_istringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_istringstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_istringstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_istringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_istringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_istringstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_istringstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_istringstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_istringstream::event =&gt; cpp/io/ios_base/event
std::basic_istringstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_istringstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_istringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_istringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_istringstream::basic_istringstream =&gt; cpp/io/basic_istringstream/basic_istringstream
std::basic_istringstream::operator= =&gt; cpp/io/basic_istringstream/operator=
std::basic_istringstream::swap =&gt; cpp/io/basic_istringstream/swap
std::basic_istringstream::rdbuf =&gt; cpp/io/basic_istringstream/rdbuf
std::basic_istringstream::str =&gt; cpp/io/basic_istringstream/str
std::swap(std::basic_istringstream) =&gt; cpp/io/basic_istringstream/swap2
std::basic_ostringstream =&gt; cpp/io/basic_ostringstream
std::basic_ostringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_ostringstream::put =&gt; cpp/io/basic_ostream/put
std::basic_ostringstream::write =&gt; cpp/io/basic_ostream/write
std::basic_ostringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_ostringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_ostringstream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_ostringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_ostringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::basic_ostringstream::good =&gt; cpp/io/basic_ios/good
std::basic_ostringstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_ostringstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_ostringstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_ostringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_ostringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_ostringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_ostringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_ostringstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_ostringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_ostringstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_ostringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_ostringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_ostringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_ostringstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_ostringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_ostringstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_ostringstream::init =&gt; cpp/io/basic_ios/init
std::basic_ostringstream::move =&gt; cpp/io/basic_ios/move
std::basic_ostringstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_ostringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_ostringstream::flags =&gt; cpp/io/ios_base/flags
std::basic_ostringstream::setf =&gt; cpp/io/ios_base/setf
std::basic_ostringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_ostringstream::precision =&gt; cpp/io/ios_base/precision
std::basic_ostringstream::width =&gt; cpp/io/ios_base/width
std::basic_ostringstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_ostringstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_ostringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_ostringstream::iword =&gt; cpp/io/ios_base/iword
std::basic_ostringstream::pword =&gt; cpp/io/ios_base/pword
std::basic_ostringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_ostringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_ostringstream::failure =&gt; cpp/io/ios_base/failure
std::basic_ostringstream::failure::what =&gt; cpp/error/exception/what
std::basic_ostringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_ostringstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::app =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::in =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::out =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_ostringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_ostringstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_ostringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_ostringstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_ostringstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_ostringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_ostringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_ostringstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_ostringstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_ostringstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_ostringstream::event =&gt; cpp/io/ios_base/event
std::basic_ostringstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_ostringstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_ostringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_ostringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ostringstream::basic_ostringstream =&gt; cpp/io/basic_ostringstream/basic_ostringstream
std::basic_ostringstream::operator= =&gt; cpp/io/basic_ostringstream/operator=
std::basic_ostringstream::swap =&gt; cpp/io/basic_ostringstream/swap
std::basic_ostringstream::rdbuf =&gt; cpp/io/basic_ostringstream/rdbuf
std::basic_ostringstream::str =&gt; cpp/io/basic_ostringstream/str
std::swap(std::basic_ostringstream) =&gt; cpp/io/basic_ostringstream/swap2
std::basic_stringstream =&gt; cpp/io/basic_stringstream
std::basic_stringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::basic_stringstream::get =&gt; cpp/io/basic_istream/get
std::basic_stringstream::peek =&gt; cpp/io/basic_istream/peek
std::basic_stringstream::unget =&gt; cpp/io/basic_istream/unget
std::basic_stringstream::putback =&gt; cpp/io/basic_istream/putback
std::basic_stringstream::getline =&gt; cpp/io/basic_istream/getline
std::basic_stringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::basic_stringstream::read =&gt; cpp/io/basic_istream/read
std::basic_stringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::basic_stringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::basic_stringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::basic_stringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::basic_stringstream::sync =&gt; cpp/io/basic_istream/sync
std::basic_stringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_stringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_stringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::basic_stringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::basic_stringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::basic_stringstream::put =&gt; cpp/io/basic_ostream/put
std::basic_stringstream::write =&gt; cpp/io/basic_ostream/write
std::basic_stringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::basic_stringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::basic_stringstream::flush =&gt; cpp/io/basic_ostream/flush
std::basic_stringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_stringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_stringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_stringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::basic_stringstream::good =&gt; cpp/io/basic_ios/good
std::basic_stringstream::eof =&gt; cpp/io/basic_ios/eof
std::basic_stringstream::fail =&gt; cpp/io/basic_ios/fail
std::basic_stringstream::bad =&gt; cpp/io/basic_ios/bad
std::basic_stringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::basic_stringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::basic_stringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::basic_stringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::basic_stringstream::clear =&gt; cpp/io/basic_ios/clear
std::basic_stringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::basic_stringstream::fill =&gt; cpp/io/basic_ios/fill
std::basic_stringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::basic_stringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::basic_stringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::basic_stringstream::tie =&gt; cpp/io/basic_ios/tie
std::basic_stringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::basic_stringstream::widen =&gt; cpp/io/basic_ios/widen
std::basic_stringstream::init =&gt; cpp/io/basic_ios/init
std::basic_stringstream::move =&gt; cpp/io/basic_ios/move
std::basic_stringstream::swap =&gt; cpp/io/basic_ios/swap
std::basic_stringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::basic_stringstream::flags =&gt; cpp/io/ios_base/flags
std::basic_stringstream::setf =&gt; cpp/io/ios_base/setf
std::basic_stringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::basic_stringstream::precision =&gt; cpp/io/ios_base/precision
std::basic_stringstream::width =&gt; cpp/io/ios_base/width
std::basic_stringstream::imbue =&gt; cpp/io/ios_base/imbue
std::basic_stringstream::getloc =&gt; cpp/io/ios_base/getloc
std::basic_stringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::basic_stringstream::iword =&gt; cpp/io/ios_base/iword
std::basic_stringstream::pword =&gt; cpp/io/ios_base/pword
std::basic_stringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::basic_stringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::basic_stringstream::failure =&gt; cpp/io/ios_base/failure
std::basic_stringstream::failure::what =&gt; cpp/error/exception/what
std::basic_stringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::basic_stringstream::openmode =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::app =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::binary =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::in =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::out =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::trunc =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::ate =&gt; cpp/io/ios_base/openmode
std::basic_stringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::left =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::right =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::basic_stringstream::iostate =&gt; cpp/io/ios_base/iostate
std::basic_stringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::basic_stringstream::badbit =&gt; cpp/io/ios_base/iostate
std::basic_stringstream::failbit =&gt; cpp/io/ios_base/iostate
std::basic_stringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::basic_stringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::basic_stringstream::beg =&gt; cpp/io/ios_base/seekdir
std::basic_stringstream::cur =&gt; cpp/io/ios_base/seekdir
std::basic_stringstream::end =&gt; cpp/io/ios_base/seekdir
std::basic_stringstream::event =&gt; cpp/io/ios_base/event
std::basic_stringstream::erase_event =&gt; cpp/io/ios_base/event
std::basic_stringstream::imbue_event =&gt; cpp/io/ios_base/event
std::basic_stringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::basic_stringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_stringstream::basic_stringstream =&gt; cpp/io/basic_stringstream/basic_stringstream
std::basic_stringstream::operator= =&gt; cpp/io/basic_stringstream/operator=
std::basic_stringstream::swap =&gt; cpp/io/basic_stringstream/swap
std::basic_stringstream::rdbuf =&gt; cpp/io/basic_stringstream/rdbuf
std::basic_stringstream::str =&gt; cpp/io/basic_stringstream/str
std::swap(std::basic_stringstream) =&gt; cpp/io/basic_stringstream/swap2
std::streambuf =&gt; cpp/io/basic_streambuf
std::streambuf::streambuf =&gt; cpp/io/basic_streambuf/basic_streambuf
std::streambuf::~streambuf =&gt; cpp/io/basic_streambuf/~basic_streambuf
std::streambuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::streambuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::streambuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::streambuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::streambuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::streambuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::streambuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::streambuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::streambuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::streambuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::streambuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::streambuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::streambuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::streambuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::streambuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::streambuf::operator= =&gt; cpp/io/basic_streambuf/operator=
std::streambuf::swap =&gt; cpp/io/basic_streambuf/swap
std::streambuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::streambuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::streambuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::streambuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::streambuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::streambuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::streambuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::streambuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::streambuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::streambuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::streambuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::streambuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::streambuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::streambuf::setg =&gt; cpp/io/basic_streambuf/setg
std::streambuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::streambuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::streambuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::streambuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::streambuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::streambuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::streambuf::setp =&gt; cpp/io/basic_streambuf/setp
std::streambuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::filebuf =&gt; cpp/io/basic_filebuf
std::filebuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::filebuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::filebuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::filebuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::filebuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::filebuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::filebuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::filebuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::filebuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::filebuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::filebuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::filebuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::filebuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::filebuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::filebuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::filebuf::swap =&gt; cpp/io/basic_streambuf/swap
std::filebuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::filebuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::filebuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::filebuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::filebuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::filebuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::filebuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::filebuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::filebuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::filebuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::filebuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::filebuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::filebuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::filebuf::setg =&gt; cpp/io/basic_streambuf/setg
std::filebuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::filebuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::filebuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::filebuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::filebuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::filebuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::filebuf::setp =&gt; cpp/io/basic_streambuf/setp
std::filebuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::filebuf::filebuf =&gt; cpp/io/basic_filebuf/basic_filebuf
std::filebuf::~filebuf =&gt; cpp/io/basic_filebuf/~basic_filebuf
std::filebuf::operator= =&gt; cpp/io/basic_filebuf/operator=
std::filebuf::swap =&gt; cpp/io/basic_filebuf/swap
std::filebuf::str =&gt; cpp/io/basic_filebuf/str
std::filebuf::is_open =&gt; cpp/io/basic_filebuf/is_open
std::filebuf::open =&gt; cpp/io/basic_filebuf/open
std::filebuf::close =&gt; cpp/io/basic_filebuf/close
std::filebuf::showmanyc =&gt; cpp/io/basic_filebuf/showmanyc
std::filebuf::underflow =&gt; cpp/io/basic_filebuf/underflow
std::filebuf::uflow =&gt; cpp/io/basic_filebuf/uflow
std::filebuf::pbackfail =&gt; cpp/io/basic_filebuf/pbackfail
std::filebuf::overflow =&gt; cpp/io/basic_filebuf/overflow
std::filebuf::setbuf =&gt; cpp/io/basic_filebuf/setbuf
std::filebuf::seekoff =&gt; cpp/io/basic_filebuf/seekoff
std::filebuf::seekpos =&gt; cpp/io/basic_filebuf/seekpos
std::filebuf::sync =&gt; cpp/io/basic_filebuf/sync
std::filebuf::imbue =&gt; cpp/io/basic_filebuf/imbue
std::swap(std::filebuf) =&gt; cpp/io/basic_filebuf/swap2
std::stringbuf =&gt; cpp/io/basic_stringbuf
std::stringbuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::stringbuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::stringbuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::stringbuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::stringbuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::stringbuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::stringbuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::stringbuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::stringbuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::stringbuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::stringbuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::stringbuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::stringbuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::stringbuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::stringbuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::stringbuf::swap =&gt; cpp/io/basic_streambuf/swap
std::stringbuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::stringbuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::stringbuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::stringbuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::stringbuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::stringbuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::stringbuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::stringbuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::stringbuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::stringbuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::stringbuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::stringbuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::stringbuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::stringbuf::setg =&gt; cpp/io/basic_streambuf/setg
std::stringbuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::stringbuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::stringbuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::stringbuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::stringbuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::stringbuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::stringbuf::setp =&gt; cpp/io/basic_streambuf/setp
std::stringbuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::stringbuf::stringbuf =&gt; cpp/io/basic_stringbuf/basic_stringbuf
std::stringbuf::operator= =&gt; cpp/io/basic_stringbuf/operator=
std::stringbuf::swap =&gt; cpp/io/basic_stringbuf/swap
std::stringbuf::str =&gt; cpp/io/basic_stringbuf/str
std::stringbuf::underflow =&gt; cpp/io/basic_stringbuf/underflow
std::stringbuf::pbackfail =&gt; cpp/io/basic_stringbuf/pbackfail
std::stringbuf::overflow =&gt; cpp/io/basic_stringbuf/overflow
std::stringbuf::setbuf =&gt; cpp/io/basic_stringbuf/setbuf
std::stringbuf::seekoff =&gt; cpp/io/basic_stringbuf/seekoff
std::stringbuf::seekpos =&gt; cpp/io/basic_stringbuf/seekpos
std::swap(std::stringbuf) =&gt; cpp/io/basic_stringbuf/swap2
std::istream =&gt; cpp/io/basic_istream
std::istream::good =&gt; cpp/io/basic_ios/good
std::istream::eof =&gt; cpp/io/basic_ios/eof
std::istream::fail =&gt; cpp/io/basic_ios/fail
std::istream::bad =&gt; cpp/io/basic_ios/bad
std::istream::operator! =&gt; cpp/io/basic_ios/operator!
std::istream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::istream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::istream::setstate =&gt; cpp/io/basic_ios/setstate
std::istream::clear =&gt; cpp/io/basic_ios/clear
std::istream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::istream::fill =&gt; cpp/io/basic_ios/fill
std::istream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::istream::imbue =&gt; cpp/io/basic_ios/imbue
std::istream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::istream::tie =&gt; cpp/io/basic_ios/tie
std::istream::narrow =&gt; cpp/io/basic_ios/narrow
std::istream::widen =&gt; cpp/io/basic_ios/widen
std::istream::init =&gt; cpp/io/basic_ios/init
std::istream::move =&gt; cpp/io/basic_ios/move
std::istream::swap =&gt; cpp/io/basic_ios/swap
std::istream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::istream::flags =&gt; cpp/io/ios_base/flags
std::istream::setf =&gt; cpp/io/ios_base/setf
std::istream::unsetf =&gt; cpp/io/ios_base/unsetf
std::istream::precision =&gt; cpp/io/ios_base/precision
std::istream::width =&gt; cpp/io/ios_base/width
std::istream::imbue =&gt; cpp/io/ios_base/imbue
std::istream::getloc =&gt; cpp/io/ios_base/getloc
std::istream::xalloc =&gt; cpp/io/ios_base/xalloc
std::istream::iword =&gt; cpp/io/ios_base/iword
std::istream::pword =&gt; cpp/io/ios_base/pword
std::istream::register_callback =&gt; cpp/io/ios_base/register_callback
std::istream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::istream::failure =&gt; cpp/io/ios_base/failure
std::istream::failure::what =&gt; cpp/error/exception/what
std::istream::failure::failure =&gt; cpp/io/ios_base/failure
std::istream::openmode =&gt; cpp/io/ios_base/openmode
std::istream::app =&gt; cpp/io/ios_base/openmode
std::istream::binary =&gt; cpp/io/ios_base/openmode
std::istream::in =&gt; cpp/io/ios_base/openmode
std::istream::out =&gt; cpp/io/ios_base/openmode
std::istream::trunc =&gt; cpp/io/ios_base/openmode
std::istream::ate =&gt; cpp/io/ios_base/openmode
std::istream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::istream::dec =&gt; cpp/io/ios_base/fmtflags
std::istream::oct =&gt; cpp/io/ios_base/fmtflags
std::istream::hex =&gt; cpp/io/ios_base/fmtflags
std::istream::basefield =&gt; cpp/io/ios_base/fmtflags
std::istream::left =&gt; cpp/io/ios_base/fmtflags
std::istream::right =&gt; cpp/io/ios_base/fmtflags
std::istream::internal =&gt; cpp/io/ios_base/fmtflags
std::istream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::istream::scientific =&gt; cpp/io/ios_base/fmtflags
std::istream::fixed =&gt; cpp/io/ios_base/fmtflags
std::istream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::istream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::istream::showbase =&gt; cpp/io/ios_base/fmtflags
std::istream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::istream::showpos =&gt; cpp/io/ios_base/fmtflags
std::istream::skipws =&gt; cpp/io/ios_base/fmtflags
std::istream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::istream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::istream::iostate =&gt; cpp/io/ios_base/iostate
std::istream::goodbit =&gt; cpp/io/ios_base/iostate
std::istream::badbit =&gt; cpp/io/ios_base/iostate
std::istream::failbit =&gt; cpp/io/ios_base/iostate
std::istream::eofbit =&gt; cpp/io/ios_base/iostate
std::istream::seekdir =&gt; cpp/io/ios_base/seekdir
std::istream::beg =&gt; cpp/io/ios_base/seekdir
std::istream::cur =&gt; cpp/io/ios_base/seekdir
std::istream::end =&gt; cpp/io/ios_base/seekdir
std::istream::event =&gt; cpp/io/ios_base/event
std::istream::erase_event =&gt; cpp/io/ios_base/event
std::istream::imbue_event =&gt; cpp/io/ios_base/event
std::istream::copyfmt_event =&gt; cpp/io/ios_base/event
std::istream::event_callback =&gt; cpp/io/ios_base/event_callback
std::istream::istream =&gt; cpp/io/basic_istream/basic_istream
std::istream::~istream =&gt; cpp/io/basic_istream/~basic_istream
std::istream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::istream::get =&gt; cpp/io/basic_istream/get
std::istream::peek =&gt; cpp/io/basic_istream/peek
std::istream::unget =&gt; cpp/io/basic_istream/unget
std::istream::putback =&gt; cpp/io/basic_istream/putback
std::istream::getline =&gt; cpp/io/basic_istream/getline
std::istream::ignore =&gt; cpp/io/basic_istream/ignore
std::istream::read =&gt; cpp/io/basic_istream/read
std::istream::readsome =&gt; cpp/io/basic_istream/readsome
std::istream::gcount =&gt; cpp/io/basic_istream/gcount
std::istream::tellg =&gt; cpp/io/basic_istream/tellg
std::istream::seekg =&gt; cpp/io/basic_istream/seekg
std::istream::sync =&gt; cpp/io/basic_istream/sync
std::istream::sentry =&gt; cpp/io/basic_istream/sentry
std::istream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::istream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::istream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
operator&gt;&gt;(std::istream) =&gt; cpp/io/basic_istream/operator_gtgt2
std::ostream =&gt; cpp/io/basic_ostream
std::ostream::good =&gt; cpp/io/basic_ios/good
std::ostream::eof =&gt; cpp/io/basic_ios/eof
std::ostream::fail =&gt; cpp/io/basic_ios/fail
std::ostream::bad =&gt; cpp/io/basic_ios/bad
std::ostream::operator! =&gt; cpp/io/basic_ios/operator!
std::ostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::ostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::ostream::setstate =&gt; cpp/io/basic_ios/setstate
std::ostream::clear =&gt; cpp/io/basic_ios/clear
std::ostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::ostream::fill =&gt; cpp/io/basic_ios/fill
std::ostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::ostream::imbue =&gt; cpp/io/basic_ios/imbue
std::ostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::ostream::tie =&gt; cpp/io/basic_ios/tie
std::ostream::narrow =&gt; cpp/io/basic_ios/narrow
std::ostream::widen =&gt; cpp/io/basic_ios/widen
std::ostream::init =&gt; cpp/io/basic_ios/init
std::ostream::move =&gt; cpp/io/basic_ios/move
std::ostream::swap =&gt; cpp/io/basic_ios/swap
std::ostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::ostream::flags =&gt; cpp/io/ios_base/flags
std::ostream::setf =&gt; cpp/io/ios_base/setf
std::ostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::ostream::precision =&gt; cpp/io/ios_base/precision
std::ostream::width =&gt; cpp/io/ios_base/width
std::ostream::imbue =&gt; cpp/io/ios_base/imbue
std::ostream::getloc =&gt; cpp/io/ios_base/getloc
std::ostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::ostream::iword =&gt; cpp/io/ios_base/iword
std::ostream::pword =&gt; cpp/io/ios_base/pword
std::ostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::ostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ostream::failure =&gt; cpp/io/ios_base/failure
std::ostream::failure::what =&gt; cpp/error/exception/what
std::ostream::failure::failure =&gt; cpp/io/ios_base/failure
std::ostream::openmode =&gt; cpp/io/ios_base/openmode
std::ostream::app =&gt; cpp/io/ios_base/openmode
std::ostream::binary =&gt; cpp/io/ios_base/openmode
std::ostream::in =&gt; cpp/io/ios_base/openmode
std::ostream::out =&gt; cpp/io/ios_base/openmode
std::ostream::trunc =&gt; cpp/io/ios_base/openmode
std::ostream::ate =&gt; cpp/io/ios_base/openmode
std::ostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ostream::dec =&gt; cpp/io/ios_base/fmtflags
std::ostream::oct =&gt; cpp/io/ios_base/fmtflags
std::ostream::hex =&gt; cpp/io/ios_base/fmtflags
std::ostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::ostream::left =&gt; cpp/io/ios_base/fmtflags
std::ostream::right =&gt; cpp/io/ios_base/fmtflags
std::ostream::internal =&gt; cpp/io/ios_base/fmtflags
std::ostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::ostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::ostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::ostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::ostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::ostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ostream::iostate =&gt; cpp/io/ios_base/iostate
std::ostream::goodbit =&gt; cpp/io/ios_base/iostate
std::ostream::badbit =&gt; cpp/io/ios_base/iostate
std::ostream::failbit =&gt; cpp/io/ios_base/iostate
std::ostream::eofbit =&gt; cpp/io/ios_base/iostate
std::ostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::ostream::beg =&gt; cpp/io/ios_base/seekdir
std::ostream::cur =&gt; cpp/io/ios_base/seekdir
std::ostream::end =&gt; cpp/io/ios_base/seekdir
std::ostream::event =&gt; cpp/io/ios_base/event
std::ostream::erase_event =&gt; cpp/io/ios_base/event
std::ostream::imbue_event =&gt; cpp/io/ios_base/event
std::ostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::ostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::ostream::ostream =&gt; cpp/io/basic_ostream/basic_ostream
std::ostream::~ostream =&gt; cpp/io/basic_ostream/~basic_ostream
std::ostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::ostream::put =&gt; cpp/io/basic_ostream/put
std::ostream::write =&gt; cpp/io/basic_ostream/write
std::ostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::ostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::ostream::flush =&gt; cpp/io/basic_ostream/flush
std::ostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::ostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
operator&lt;&lt;(std::ostream) =&gt; cpp/io/basic_ostream/operator_ltlt2
std::iostream =&gt; cpp/io/basic_iostream
std::iostream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::iostream::get =&gt; cpp/io/basic_istream/get
std::iostream::peek =&gt; cpp/io/basic_istream/peek
std::iostream::unget =&gt; cpp/io/basic_istream/unget
std::iostream::putback =&gt; cpp/io/basic_istream/putback
std::iostream::getline =&gt; cpp/io/basic_istream/getline
std::iostream::ignore =&gt; cpp/io/basic_istream/ignore
std::iostream::read =&gt; cpp/io/basic_istream/read
std::iostream::readsome =&gt; cpp/io/basic_istream/readsome
std::iostream::gcount =&gt; cpp/io/basic_istream/gcount
std::iostream::tellg =&gt; cpp/io/basic_istream/tellg
std::iostream::seekg =&gt; cpp/io/basic_istream/seekg
std::iostream::sync =&gt; cpp/io/basic_istream/sync
std::iostream::sentry =&gt; cpp/io/basic_istream/sentry
std::iostream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::iostream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::iostream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::iostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::iostream::put =&gt; cpp/io/basic_ostream/put
std::iostream::write =&gt; cpp/io/basic_ostream/write
std::iostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::iostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::iostream::flush =&gt; cpp/io/basic_ostream/flush
std::iostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::iostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::iostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::iostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::iostream::good =&gt; cpp/io/basic_ios/good
std::iostream::eof =&gt; cpp/io/basic_ios/eof
std::iostream::fail =&gt; cpp/io/basic_ios/fail
std::iostream::bad =&gt; cpp/io/basic_ios/bad
std::iostream::operator! =&gt; cpp/io/basic_ios/operator!
std::iostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::iostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::iostream::setstate =&gt; cpp/io/basic_ios/setstate
std::iostream::clear =&gt; cpp/io/basic_ios/clear
std::iostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::iostream::fill =&gt; cpp/io/basic_ios/fill
std::iostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::iostream::imbue =&gt; cpp/io/basic_ios/imbue
std::iostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::iostream::tie =&gt; cpp/io/basic_ios/tie
std::iostream::narrow =&gt; cpp/io/basic_ios/narrow
std::iostream::widen =&gt; cpp/io/basic_ios/widen
std::iostream::init =&gt; cpp/io/basic_ios/init
std::iostream::move =&gt; cpp/io/basic_ios/move
std::iostream::swap =&gt; cpp/io/basic_ios/swap
std::iostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::iostream::flags =&gt; cpp/io/ios_base/flags
std::iostream::setf =&gt; cpp/io/ios_base/setf
std::iostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::iostream::precision =&gt; cpp/io/ios_base/precision
std::iostream::width =&gt; cpp/io/ios_base/width
std::iostream::imbue =&gt; cpp/io/ios_base/imbue
std::iostream::getloc =&gt; cpp/io/ios_base/getloc
std::iostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::iostream::iword =&gt; cpp/io/ios_base/iword
std::iostream::pword =&gt; cpp/io/ios_base/pword
std::iostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::iostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::iostream::failure =&gt; cpp/io/ios_base/failure
std::iostream::failure::what =&gt; cpp/error/exception/what
std::iostream::failure::failure =&gt; cpp/io/ios_base/failure
std::iostream::openmode =&gt; cpp/io/ios_base/openmode
std::iostream::app =&gt; cpp/io/ios_base/openmode
std::iostream::binary =&gt; cpp/io/ios_base/openmode
std::iostream::in =&gt; cpp/io/ios_base/openmode
std::iostream::out =&gt; cpp/io/ios_base/openmode
std::iostream::trunc =&gt; cpp/io/ios_base/openmode
std::iostream::ate =&gt; cpp/io/ios_base/openmode
std::iostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::iostream::dec =&gt; cpp/io/ios_base/fmtflags
std::iostream::oct =&gt; cpp/io/ios_base/fmtflags
std::iostream::hex =&gt; cpp/io/ios_base/fmtflags
std::iostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::iostream::left =&gt; cpp/io/ios_base/fmtflags
std::iostream::right =&gt; cpp/io/ios_base/fmtflags
std::iostream::internal =&gt; cpp/io/ios_base/fmtflags
std::iostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::iostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::iostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::iostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::iostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::iostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::iostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::iostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::iostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::iostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::iostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::iostream::iostate =&gt; cpp/io/ios_base/iostate
std::iostream::goodbit =&gt; cpp/io/ios_base/iostate
std::iostream::badbit =&gt; cpp/io/ios_base/iostate
std::iostream::failbit =&gt; cpp/io/ios_base/iostate
std::iostream::eofbit =&gt; cpp/io/ios_base/iostate
std::iostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::iostream::beg =&gt; cpp/io/ios_base/seekdir
std::iostream::cur =&gt; cpp/io/ios_base/seekdir
std::iostream::end =&gt; cpp/io/ios_base/seekdir
std::iostream::event =&gt; cpp/io/ios_base/event
std::iostream::erase_event =&gt; cpp/io/ios_base/event
std::iostream::imbue_event =&gt; cpp/io/ios_base/event
std::iostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::iostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::iostream::iostream =&gt; cpp/io/basic_iostream/basic_iostream
std::iostream::~iostream =&gt; cpp/io/basic_iostream/~basic_iostream
std::ifstream =&gt; cpp/io/basic_ifstream
std::ifstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::ifstream::get =&gt; cpp/io/basic_istream/get
std::ifstream::peek =&gt; cpp/io/basic_istream/peek
std::ifstream::unget =&gt; cpp/io/basic_istream/unget
std::ifstream::putback =&gt; cpp/io/basic_istream/putback
std::ifstream::getline =&gt; cpp/io/basic_istream/getline
std::ifstream::ignore =&gt; cpp/io/basic_istream/ignore
std::ifstream::read =&gt; cpp/io/basic_istream/read
std::ifstream::readsome =&gt; cpp/io/basic_istream/readsome
std::ifstream::gcount =&gt; cpp/io/basic_istream/gcount
std::ifstream::tellg =&gt; cpp/io/basic_istream/tellg
std::ifstream::seekg =&gt; cpp/io/basic_istream/seekg
std::ifstream::sync =&gt; cpp/io/basic_istream/sync
std::ifstream::sentry =&gt; cpp/io/basic_istream/sentry
std::ifstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::ifstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::ifstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::ifstream::good =&gt; cpp/io/basic_ios/good
std::ifstream::eof =&gt; cpp/io/basic_ios/eof
std::ifstream::fail =&gt; cpp/io/basic_ios/fail
std::ifstream::bad =&gt; cpp/io/basic_ios/bad
std::ifstream::operator! =&gt; cpp/io/basic_ios/operator!
std::ifstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::ifstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::ifstream::setstate =&gt; cpp/io/basic_ios/setstate
std::ifstream::clear =&gt; cpp/io/basic_ios/clear
std::ifstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::ifstream::fill =&gt; cpp/io/basic_ios/fill
std::ifstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::ifstream::imbue =&gt; cpp/io/basic_ios/imbue
std::ifstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::ifstream::tie =&gt; cpp/io/basic_ios/tie
std::ifstream::narrow =&gt; cpp/io/basic_ios/narrow
std::ifstream::widen =&gt; cpp/io/basic_ios/widen
std::ifstream::init =&gt; cpp/io/basic_ios/init
std::ifstream::move =&gt; cpp/io/basic_ios/move
std::ifstream::swap =&gt; cpp/io/basic_ios/swap
std::ifstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::ifstream::flags =&gt; cpp/io/ios_base/flags
std::ifstream::setf =&gt; cpp/io/ios_base/setf
std::ifstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::ifstream::precision =&gt; cpp/io/ios_base/precision
std::ifstream::width =&gt; cpp/io/ios_base/width
std::ifstream::imbue =&gt; cpp/io/ios_base/imbue
std::ifstream::getloc =&gt; cpp/io/ios_base/getloc
std::ifstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::ifstream::iword =&gt; cpp/io/ios_base/iword
std::ifstream::pword =&gt; cpp/io/ios_base/pword
std::ifstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::ifstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ifstream::failure =&gt; cpp/io/ios_base/failure
std::ifstream::failure::what =&gt; cpp/error/exception/what
std::ifstream::failure::failure =&gt; cpp/io/ios_base/failure
std::ifstream::openmode =&gt; cpp/io/ios_base/openmode
std::ifstream::app =&gt; cpp/io/ios_base/openmode
std::ifstream::binary =&gt; cpp/io/ios_base/openmode
std::ifstream::in =&gt; cpp/io/ios_base/openmode
std::ifstream::out =&gt; cpp/io/ios_base/openmode
std::ifstream::trunc =&gt; cpp/io/ios_base/openmode
std::ifstream::ate =&gt; cpp/io/ios_base/openmode
std::ifstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ifstream::dec =&gt; cpp/io/ios_base/fmtflags
std::ifstream::oct =&gt; cpp/io/ios_base/fmtflags
std::ifstream::hex =&gt; cpp/io/ios_base/fmtflags
std::ifstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::ifstream::left =&gt; cpp/io/ios_base/fmtflags
std::ifstream::right =&gt; cpp/io/ios_base/fmtflags
std::ifstream::internal =&gt; cpp/io/ios_base/fmtflags
std::ifstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ifstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::ifstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::ifstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ifstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ifstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::ifstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ifstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::ifstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::ifstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ifstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ifstream::iostate =&gt; cpp/io/ios_base/iostate
std::ifstream::goodbit =&gt; cpp/io/ios_base/iostate
std::ifstream::badbit =&gt; cpp/io/ios_base/iostate
std::ifstream::failbit =&gt; cpp/io/ios_base/iostate
std::ifstream::eofbit =&gt; cpp/io/ios_base/iostate
std::ifstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::ifstream::beg =&gt; cpp/io/ios_base/seekdir
std::ifstream::cur =&gt; cpp/io/ios_base/seekdir
std::ifstream::end =&gt; cpp/io/ios_base/seekdir
std::ifstream::event =&gt; cpp/io/ios_base/event
std::ifstream::erase_event =&gt; cpp/io/ios_base/event
std::ifstream::imbue_event =&gt; cpp/io/ios_base/event
std::ifstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::ifstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::ifstream::ifstream =&gt; cpp/io/basic_ifstream/basic_ifstream
std::ifstream::operator= =&gt; cpp/io/basic_ifstream/operator=
std::ifstream::swap =&gt; cpp/io/basic_ifstream/swap
std::ifstream::rdbuf =&gt; cpp/io/basic_ifstream/rdbuf
std::ifstream::is_open =&gt; cpp/io/basic_ifstream/is_open
std::ifstream::open =&gt; cpp/io/basic_ifstream/open
std::ifstream::close =&gt; cpp/io/basic_ifstream/close
std::swap(std::ifstream) =&gt; cpp/io/basic_ifstream/swap2
std::ofstream =&gt; cpp/io/basic_ofstream
std::ofstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::ofstream::put =&gt; cpp/io/basic_ostream/put
std::ofstream::write =&gt; cpp/io/basic_ostream/write
std::ofstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::ofstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::ofstream::flush =&gt; cpp/io/basic_ostream/flush
std::ofstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::ofstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::ofstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::ofstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::ofstream::good =&gt; cpp/io/basic_ios/good
std::ofstream::eof =&gt; cpp/io/basic_ios/eof
std::ofstream::fail =&gt; cpp/io/basic_ios/fail
std::ofstream::bad =&gt; cpp/io/basic_ios/bad
std::ofstream::operator! =&gt; cpp/io/basic_ios/operator!
std::ofstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::ofstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::ofstream::setstate =&gt; cpp/io/basic_ios/setstate
std::ofstream::clear =&gt; cpp/io/basic_ios/clear
std::ofstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::ofstream::fill =&gt; cpp/io/basic_ios/fill
std::ofstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::ofstream::imbue =&gt; cpp/io/basic_ios/imbue
std::ofstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::ofstream::tie =&gt; cpp/io/basic_ios/tie
std::ofstream::narrow =&gt; cpp/io/basic_ios/narrow
std::ofstream::widen =&gt; cpp/io/basic_ios/widen
std::ofstream::init =&gt; cpp/io/basic_ios/init
std::ofstream::move =&gt; cpp/io/basic_ios/move
std::ofstream::swap =&gt; cpp/io/basic_ios/swap
std::ofstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::ofstream::flags =&gt; cpp/io/ios_base/flags
std::ofstream::setf =&gt; cpp/io/ios_base/setf
std::ofstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::ofstream::precision =&gt; cpp/io/ios_base/precision
std::ofstream::width =&gt; cpp/io/ios_base/width
std::ofstream::imbue =&gt; cpp/io/ios_base/imbue
std::ofstream::getloc =&gt; cpp/io/ios_base/getloc
std::ofstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::ofstream::iword =&gt; cpp/io/ios_base/iword
std::ofstream::pword =&gt; cpp/io/ios_base/pword
std::ofstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::ofstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ofstream::failure =&gt; cpp/io/ios_base/failure
std::ofstream::failure::what =&gt; cpp/error/exception/what
std::ofstream::failure::failure =&gt; cpp/io/ios_base/failure
std::ofstream::openmode =&gt; cpp/io/ios_base/openmode
std::ofstream::app =&gt; cpp/io/ios_base/openmode
std::ofstream::binary =&gt; cpp/io/ios_base/openmode
std::ofstream::in =&gt; cpp/io/ios_base/openmode
std::ofstream::out =&gt; cpp/io/ios_base/openmode
std::ofstream::trunc =&gt; cpp/io/ios_base/openmode
std::ofstream::ate =&gt; cpp/io/ios_base/openmode
std::ofstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ofstream::dec =&gt; cpp/io/ios_base/fmtflags
std::ofstream::oct =&gt; cpp/io/ios_base/fmtflags
std::ofstream::hex =&gt; cpp/io/ios_base/fmtflags
std::ofstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::ofstream::left =&gt; cpp/io/ios_base/fmtflags
std::ofstream::right =&gt; cpp/io/ios_base/fmtflags
std::ofstream::internal =&gt; cpp/io/ios_base/fmtflags
std::ofstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ofstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::ofstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::ofstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ofstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ofstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::ofstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ofstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::ofstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::ofstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ofstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ofstream::iostate =&gt; cpp/io/ios_base/iostate
std::ofstream::goodbit =&gt; cpp/io/ios_base/iostate
std::ofstream::badbit =&gt; cpp/io/ios_base/iostate
std::ofstream::failbit =&gt; cpp/io/ios_base/iostate
std::ofstream::eofbit =&gt; cpp/io/ios_base/iostate
std::ofstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::ofstream::beg =&gt; cpp/io/ios_base/seekdir
std::ofstream::cur =&gt; cpp/io/ios_base/seekdir
std::ofstream::end =&gt; cpp/io/ios_base/seekdir
std::ofstream::event =&gt; cpp/io/ios_base/event
std::ofstream::erase_event =&gt; cpp/io/ios_base/event
std::ofstream::imbue_event =&gt; cpp/io/ios_base/event
std::ofstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::ofstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::ofstream::ofstream =&gt; cpp/io/basic_ofstream/basic_ofstream
std::ofstream::operator= =&gt; cpp/io/basic_ofstream/operator=
std::ofstream::swap =&gt; cpp/io/basic_ofstream/swap
std::ofstream::rdbuf =&gt; cpp/io/basic_ofstream/rdbuf
std::ofstream::is_open =&gt; cpp/io/basic_ofstream/is_open
std::ofstream::open =&gt; cpp/io/basic_ofstream/open
std::ofstream::close =&gt; cpp/io/basic_ofstream/close
std::swap(std::ofstream) =&gt; cpp/io/basic_ofstream/swap2
std::fstream =&gt; cpp/io/basic_fstream
std::fstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::fstream::get =&gt; cpp/io/basic_istream/get
std::fstream::peek =&gt; cpp/io/basic_istream/peek
std::fstream::unget =&gt; cpp/io/basic_istream/unget
std::fstream::putback =&gt; cpp/io/basic_istream/putback
std::fstream::getline =&gt; cpp/io/basic_istream/getline
std::fstream::ignore =&gt; cpp/io/basic_istream/ignore
std::fstream::read =&gt; cpp/io/basic_istream/read
std::fstream::readsome =&gt; cpp/io/basic_istream/readsome
std::fstream::gcount =&gt; cpp/io/basic_istream/gcount
std::fstream::tellg =&gt; cpp/io/basic_istream/tellg
std::fstream::seekg =&gt; cpp/io/basic_istream/seekg
std::fstream::sync =&gt; cpp/io/basic_istream/sync
std::fstream::sentry =&gt; cpp/io/basic_istream/sentry
std::fstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::fstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::fstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::fstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::fstream::put =&gt; cpp/io/basic_ostream/put
std::fstream::write =&gt; cpp/io/basic_ostream/write
std::fstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::fstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::fstream::flush =&gt; cpp/io/basic_ostream/flush
std::fstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::fstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::fstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::fstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::fstream::good =&gt; cpp/io/basic_ios/good
std::fstream::eof =&gt; cpp/io/basic_ios/eof
std::fstream::fail =&gt; cpp/io/basic_ios/fail
std::fstream::bad =&gt; cpp/io/basic_ios/bad
std::fstream::operator! =&gt; cpp/io/basic_ios/operator!
std::fstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::fstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::fstream::setstate =&gt; cpp/io/basic_ios/setstate
std::fstream::clear =&gt; cpp/io/basic_ios/clear
std::fstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::fstream::fill =&gt; cpp/io/basic_ios/fill
std::fstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::fstream::imbue =&gt; cpp/io/basic_ios/imbue
std::fstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::fstream::tie =&gt; cpp/io/basic_ios/tie
std::fstream::narrow =&gt; cpp/io/basic_ios/narrow
std::fstream::widen =&gt; cpp/io/basic_ios/widen
std::fstream::init =&gt; cpp/io/basic_ios/init
std::fstream::move =&gt; cpp/io/basic_ios/move
std::fstream::swap =&gt; cpp/io/basic_ios/swap
std::fstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::fstream::flags =&gt; cpp/io/ios_base/flags
std::fstream::setf =&gt; cpp/io/ios_base/setf
std::fstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::fstream::precision =&gt; cpp/io/ios_base/precision
std::fstream::width =&gt; cpp/io/ios_base/width
std::fstream::imbue =&gt; cpp/io/ios_base/imbue
std::fstream::getloc =&gt; cpp/io/ios_base/getloc
std::fstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::fstream::iword =&gt; cpp/io/ios_base/iword
std::fstream::pword =&gt; cpp/io/ios_base/pword
std::fstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::fstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::fstream::failure =&gt; cpp/io/ios_base/failure
std::fstream::failure::what =&gt; cpp/error/exception/what
std::fstream::failure::failure =&gt; cpp/io/ios_base/failure
std::fstream::openmode =&gt; cpp/io/ios_base/openmode
std::fstream::app =&gt; cpp/io/ios_base/openmode
std::fstream::binary =&gt; cpp/io/ios_base/openmode
std::fstream::in =&gt; cpp/io/ios_base/openmode
std::fstream::out =&gt; cpp/io/ios_base/openmode
std::fstream::trunc =&gt; cpp/io/ios_base/openmode
std::fstream::ate =&gt; cpp/io/ios_base/openmode
std::fstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::fstream::dec =&gt; cpp/io/ios_base/fmtflags
std::fstream::oct =&gt; cpp/io/ios_base/fmtflags
std::fstream::hex =&gt; cpp/io/ios_base/fmtflags
std::fstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::fstream::left =&gt; cpp/io/ios_base/fmtflags
std::fstream::right =&gt; cpp/io/ios_base/fmtflags
std::fstream::internal =&gt; cpp/io/ios_base/fmtflags
std::fstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::fstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::fstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::fstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::fstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::fstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::fstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::fstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::fstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::fstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::fstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::fstream::iostate =&gt; cpp/io/ios_base/iostate
std::fstream::goodbit =&gt; cpp/io/ios_base/iostate
std::fstream::badbit =&gt; cpp/io/ios_base/iostate
std::fstream::failbit =&gt; cpp/io/ios_base/iostate
std::fstream::eofbit =&gt; cpp/io/ios_base/iostate
std::fstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::fstream::beg =&gt; cpp/io/ios_base/seekdir
std::fstream::cur =&gt; cpp/io/ios_base/seekdir
std::fstream::end =&gt; cpp/io/ios_base/seekdir
std::fstream::event =&gt; cpp/io/ios_base/event
std::fstream::erase_event =&gt; cpp/io/ios_base/event
std::fstream::imbue_event =&gt; cpp/io/ios_base/event
std::fstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::fstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::fstream::fstream =&gt; cpp/io/basic_fstream/basic_fstream
std::fstream::operator= =&gt; cpp/io/basic_fstream/operator=
std::fstream::swap =&gt; cpp/io/basic_fstream/swap
std::fstream::rdbuf =&gt; cpp/io/basic_fstream/rdbuf
std::fstream::is_open =&gt; cpp/io/basic_fstream/is_open
std::fstream::open =&gt; cpp/io/basic_fstream/open
std::fstream::close =&gt; cpp/io/basic_fstream/close
std::swap(std::fstream) =&gt; cpp/io/basic_fstream/swap2
std::istringstream =&gt; cpp/io/basic_istringstream
std::istringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::istringstream::get =&gt; cpp/io/basic_istream/get
std::istringstream::peek =&gt; cpp/io/basic_istream/peek
std::istringstream::unget =&gt; cpp/io/basic_istream/unget
std::istringstream::putback =&gt; cpp/io/basic_istream/putback
std::istringstream::getline =&gt; cpp/io/basic_istream/getline
std::istringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::istringstream::read =&gt; cpp/io/basic_istream/read
std::istringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::istringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::istringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::istringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::istringstream::sync =&gt; cpp/io/basic_istream/sync
std::istringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::istringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::istringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::istringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::istringstream::good =&gt; cpp/io/basic_ios/good
std::istringstream::eof =&gt; cpp/io/basic_ios/eof
std::istringstream::fail =&gt; cpp/io/basic_ios/fail
std::istringstream::bad =&gt; cpp/io/basic_ios/bad
std::istringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::istringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::istringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::istringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::istringstream::clear =&gt; cpp/io/basic_ios/clear
std::istringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::istringstream::fill =&gt; cpp/io/basic_ios/fill
std::istringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::istringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::istringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::istringstream::tie =&gt; cpp/io/basic_ios/tie
std::istringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::istringstream::widen =&gt; cpp/io/basic_ios/widen
std::istringstream::init =&gt; cpp/io/basic_ios/init
std::istringstream::move =&gt; cpp/io/basic_ios/move
std::istringstream::swap =&gt; cpp/io/basic_ios/swap
std::istringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::istringstream::flags =&gt; cpp/io/ios_base/flags
std::istringstream::setf =&gt; cpp/io/ios_base/setf
std::istringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::istringstream::precision =&gt; cpp/io/ios_base/precision
std::istringstream::width =&gt; cpp/io/ios_base/width
std::istringstream::imbue =&gt; cpp/io/ios_base/imbue
std::istringstream::getloc =&gt; cpp/io/ios_base/getloc
std::istringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::istringstream::iword =&gt; cpp/io/ios_base/iword
std::istringstream::pword =&gt; cpp/io/ios_base/pword
std::istringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::istringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::istringstream::failure =&gt; cpp/io/ios_base/failure
std::istringstream::failure::what =&gt; cpp/error/exception/what
std::istringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::istringstream::openmode =&gt; cpp/io/ios_base/openmode
std::istringstream::app =&gt; cpp/io/ios_base/openmode
std::istringstream::binary =&gt; cpp/io/ios_base/openmode
std::istringstream::in =&gt; cpp/io/ios_base/openmode
std::istringstream::out =&gt; cpp/io/ios_base/openmode
std::istringstream::trunc =&gt; cpp/io/ios_base/openmode
std::istringstream::ate =&gt; cpp/io/ios_base/openmode
std::istringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::istringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::istringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::istringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::istringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::istringstream::left =&gt; cpp/io/ios_base/fmtflags
std::istringstream::right =&gt; cpp/io/ios_base/fmtflags
std::istringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::istringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::istringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::istringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::istringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::istringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::istringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::istringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::istringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::istringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::istringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::istringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::istringstream::iostate =&gt; cpp/io/ios_base/iostate
std::istringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::istringstream::badbit =&gt; cpp/io/ios_base/iostate
std::istringstream::failbit =&gt; cpp/io/ios_base/iostate
std::istringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::istringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::istringstream::beg =&gt; cpp/io/ios_base/seekdir
std::istringstream::cur =&gt; cpp/io/ios_base/seekdir
std::istringstream::end =&gt; cpp/io/ios_base/seekdir
std::istringstream::event =&gt; cpp/io/ios_base/event
std::istringstream::erase_event =&gt; cpp/io/ios_base/event
std::istringstream::imbue_event =&gt; cpp/io/ios_base/event
std::istringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::istringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::istringstream::istringstream =&gt; cpp/io/basic_istringstream/basic_istringstream
std::istringstream::operator= =&gt; cpp/io/basic_istringstream/operator=
std::istringstream::swap =&gt; cpp/io/basic_istringstream/swap
std::istringstream::rdbuf =&gt; cpp/io/basic_istringstream/rdbuf
std::istringstream::str =&gt; cpp/io/basic_istringstream/str
std::swap(std::istringstream) =&gt; cpp/io/basic_istringstream/swap2
std::ostringstream =&gt; cpp/io/basic_ostringstream
std::ostringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::ostringstream::put =&gt; cpp/io/basic_ostream/put
std::ostringstream::write =&gt; cpp/io/basic_ostream/write
std::ostringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::ostringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::ostringstream::flush =&gt; cpp/io/basic_ostream/flush
std::ostringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::ostringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::ostringstream::good =&gt; cpp/io/basic_ios/good
std::ostringstream::eof =&gt; cpp/io/basic_ios/eof
std::ostringstream::fail =&gt; cpp/io/basic_ios/fail
std::ostringstream::bad =&gt; cpp/io/basic_ios/bad
std::ostringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::ostringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::ostringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::ostringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::ostringstream::clear =&gt; cpp/io/basic_ios/clear
std::ostringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::ostringstream::fill =&gt; cpp/io/basic_ios/fill
std::ostringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::ostringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::ostringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::ostringstream::tie =&gt; cpp/io/basic_ios/tie
std::ostringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::ostringstream::widen =&gt; cpp/io/basic_ios/widen
std::ostringstream::init =&gt; cpp/io/basic_ios/init
std::ostringstream::move =&gt; cpp/io/basic_ios/move
std::ostringstream::swap =&gt; cpp/io/basic_ios/swap
std::ostringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::ostringstream::flags =&gt; cpp/io/ios_base/flags
std::ostringstream::setf =&gt; cpp/io/ios_base/setf
std::ostringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::ostringstream::precision =&gt; cpp/io/ios_base/precision
std::ostringstream::width =&gt; cpp/io/ios_base/width
std::ostringstream::imbue =&gt; cpp/io/ios_base/imbue
std::ostringstream::getloc =&gt; cpp/io/ios_base/getloc
std::ostringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::ostringstream::iword =&gt; cpp/io/ios_base/iword
std::ostringstream::pword =&gt; cpp/io/ios_base/pword
std::ostringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::ostringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ostringstream::failure =&gt; cpp/io/ios_base/failure
std::ostringstream::failure::what =&gt; cpp/error/exception/what
std::ostringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::ostringstream::openmode =&gt; cpp/io/ios_base/openmode
std::ostringstream::app =&gt; cpp/io/ios_base/openmode
std::ostringstream::binary =&gt; cpp/io/ios_base/openmode
std::ostringstream::in =&gt; cpp/io/ios_base/openmode
std::ostringstream::out =&gt; cpp/io/ios_base/openmode
std::ostringstream::trunc =&gt; cpp/io/ios_base/openmode
std::ostringstream::ate =&gt; cpp/io/ios_base/openmode
std::ostringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::left =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::right =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ostringstream::iostate =&gt; cpp/io/ios_base/iostate
std::ostringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::ostringstream::badbit =&gt; cpp/io/ios_base/iostate
std::ostringstream::failbit =&gt; cpp/io/ios_base/iostate
std::ostringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::ostringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::ostringstream::beg =&gt; cpp/io/ios_base/seekdir
std::ostringstream::cur =&gt; cpp/io/ios_base/seekdir
std::ostringstream::end =&gt; cpp/io/ios_base/seekdir
std::ostringstream::event =&gt; cpp/io/ios_base/event
std::ostringstream::erase_event =&gt; cpp/io/ios_base/event
std::ostringstream::imbue_event =&gt; cpp/io/ios_base/event
std::ostringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::ostringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::ostringstream::ostringstream =&gt; cpp/io/basic_ostringstream/basic_ostringstream
std::ostringstream::operator= =&gt; cpp/io/basic_ostringstream/operator=
std::ostringstream::swap =&gt; cpp/io/basic_ostringstream/swap
std::ostringstream::rdbuf =&gt; cpp/io/basic_ostringstream/rdbuf
std::ostringstream::str =&gt; cpp/io/basic_ostringstream/str
std::swap(std::ostringstream) =&gt; cpp/io/basic_ostringstream/swap2
std::stringstream =&gt; cpp/io/basic_stringstream
std::stringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::stringstream::get =&gt; cpp/io/basic_istream/get
std::stringstream::peek =&gt; cpp/io/basic_istream/peek
std::stringstream::unget =&gt; cpp/io/basic_istream/unget
std::stringstream::putback =&gt; cpp/io/basic_istream/putback
std::stringstream::getline =&gt; cpp/io/basic_istream/getline
std::stringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::stringstream::read =&gt; cpp/io/basic_istream/read
std::stringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::stringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::stringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::stringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::stringstream::sync =&gt; cpp/io/basic_istream/sync
std::stringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::stringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::stringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::stringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::stringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::stringstream::put =&gt; cpp/io/basic_ostream/put
std::stringstream::write =&gt; cpp/io/basic_ostream/write
std::stringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::stringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::stringstream::flush =&gt; cpp/io/basic_ostream/flush
std::stringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::stringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::stringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::stringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::stringstream::good =&gt; cpp/io/basic_ios/good
std::stringstream::eof =&gt; cpp/io/basic_ios/eof
std::stringstream::fail =&gt; cpp/io/basic_ios/fail
std::stringstream::bad =&gt; cpp/io/basic_ios/bad
std::stringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::stringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::stringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::stringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::stringstream::clear =&gt; cpp/io/basic_ios/clear
std::stringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::stringstream::fill =&gt; cpp/io/basic_ios/fill
std::stringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::stringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::stringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::stringstream::tie =&gt; cpp/io/basic_ios/tie
std::stringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::stringstream::widen =&gt; cpp/io/basic_ios/widen
std::stringstream::init =&gt; cpp/io/basic_ios/init
std::stringstream::move =&gt; cpp/io/basic_ios/move
std::stringstream::swap =&gt; cpp/io/basic_ios/swap
std::stringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::stringstream::flags =&gt; cpp/io/ios_base/flags
std::stringstream::setf =&gt; cpp/io/ios_base/setf
std::stringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::stringstream::precision =&gt; cpp/io/ios_base/precision
std::stringstream::width =&gt; cpp/io/ios_base/width
std::stringstream::imbue =&gt; cpp/io/ios_base/imbue
std::stringstream::getloc =&gt; cpp/io/ios_base/getloc
std::stringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::stringstream::iword =&gt; cpp/io/ios_base/iword
std::stringstream::pword =&gt; cpp/io/ios_base/pword
std::stringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::stringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::stringstream::failure =&gt; cpp/io/ios_base/failure
std::stringstream::failure::what =&gt; cpp/error/exception/what
std::stringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::stringstream::openmode =&gt; cpp/io/ios_base/openmode
std::stringstream::app =&gt; cpp/io/ios_base/openmode
std::stringstream::binary =&gt; cpp/io/ios_base/openmode
std::stringstream::in =&gt; cpp/io/ios_base/openmode
std::stringstream::out =&gt; cpp/io/ios_base/openmode
std::stringstream::trunc =&gt; cpp/io/ios_base/openmode
std::stringstream::ate =&gt; cpp/io/ios_base/openmode
std::stringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::stringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::stringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::stringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::stringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::stringstream::left =&gt; cpp/io/ios_base/fmtflags
std::stringstream::right =&gt; cpp/io/ios_base/fmtflags
std::stringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::stringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::stringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::stringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::stringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::stringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::stringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::stringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::stringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::stringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::stringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::stringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::stringstream::iostate =&gt; cpp/io/ios_base/iostate
std::stringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::stringstream::badbit =&gt; cpp/io/ios_base/iostate
std::stringstream::failbit =&gt; cpp/io/ios_base/iostate
std::stringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::stringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::stringstream::beg =&gt; cpp/io/ios_base/seekdir
std::stringstream::cur =&gt; cpp/io/ios_base/seekdir
std::stringstream::end =&gt; cpp/io/ios_base/seekdir
std::stringstream::event =&gt; cpp/io/ios_base/event
std::stringstream::erase_event =&gt; cpp/io/ios_base/event
std::stringstream::imbue_event =&gt; cpp/io/ios_base/event
std::stringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::stringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::stringstream::stringstream =&gt; cpp/io/basic_stringstream/basic_stringstream
std::stringstream::operator= =&gt; cpp/io/basic_stringstream/operator=
std::stringstream::swap =&gt; cpp/io/basic_stringstream/swap
std::stringstream::rdbuf =&gt; cpp/io/basic_stringstream/rdbuf
std::stringstream::str =&gt; cpp/io/basic_stringstream/str
std::swap(std::stringstream) =&gt; cpp/io/basic_stringstream/swap2
std::wstreambuf =&gt; cpp/io/basic_streambuf
std::wstreambuf::wstreambuf =&gt; cpp/io/basic_streambuf/basic_streambuf
std::wstreambuf::~wstreambuf =&gt; cpp/io/basic_streambuf/~basic_streambuf
std::wstreambuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wstreambuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::wstreambuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wstreambuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wstreambuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wstreambuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::wstreambuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::wstreambuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::wstreambuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::wstreambuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::wstreambuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wstreambuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::wstreambuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::wstreambuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::wstreambuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::wstreambuf::operator= =&gt; cpp/io/basic_streambuf/operator=
std::wstreambuf::swap =&gt; cpp/io/basic_streambuf/swap
std::wstreambuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wstreambuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wstreambuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wstreambuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wstreambuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::wstreambuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::wstreambuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::wstreambuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::wstreambuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wstreambuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::wstreambuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::wstreambuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::wstreambuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::wstreambuf::setg =&gt; cpp/io/basic_streambuf/setg
std::wstreambuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::wstreambuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::wstreambuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::wstreambuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::wstreambuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::wstreambuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::wstreambuf::setp =&gt; cpp/io/basic_streambuf/setp
std::wstreambuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::wfilebuf =&gt; cpp/io/basic_filebuf
std::wfilebuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wfilebuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::wfilebuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wfilebuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wfilebuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wfilebuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::wfilebuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::wfilebuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::wfilebuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::wfilebuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::wfilebuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wfilebuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::wfilebuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::wfilebuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::wfilebuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::wfilebuf::swap =&gt; cpp/io/basic_streambuf/swap
std::wfilebuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wfilebuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wfilebuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wfilebuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wfilebuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::wfilebuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::wfilebuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::wfilebuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::wfilebuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wfilebuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::wfilebuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::wfilebuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::wfilebuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::wfilebuf::setg =&gt; cpp/io/basic_streambuf/setg
std::wfilebuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::wfilebuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::wfilebuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::wfilebuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::wfilebuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::wfilebuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::wfilebuf::setp =&gt; cpp/io/basic_streambuf/setp
std::wfilebuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::wfilebuf::wfilebuf =&gt; cpp/io/basic_filebuf/basic_filebuf
std::wfilebuf::~wfilebuf =&gt; cpp/io/basic_filebuf/~basic_filebuf
std::wfilebuf::operator= =&gt; cpp/io/basic_filebuf/operator=
std::wfilebuf::swap =&gt; cpp/io/basic_filebuf/swap
std::wfilebuf::str =&gt; cpp/io/basic_filebuf/str
std::wfilebuf::is_open =&gt; cpp/io/basic_filebuf/is_open
std::wfilebuf::open =&gt; cpp/io/basic_filebuf/open
std::wfilebuf::close =&gt; cpp/io/basic_filebuf/close
std::wfilebuf::showmanyc =&gt; cpp/io/basic_filebuf/showmanyc
std::wfilebuf::underflow =&gt; cpp/io/basic_filebuf/underflow
std::wfilebuf::uflow =&gt; cpp/io/basic_filebuf/uflow
std::wfilebuf::pbackfail =&gt; cpp/io/basic_filebuf/pbackfail
std::wfilebuf::overflow =&gt; cpp/io/basic_filebuf/overflow
std::wfilebuf::setbuf =&gt; cpp/io/basic_filebuf/setbuf
std::wfilebuf::seekoff =&gt; cpp/io/basic_filebuf/seekoff
std::wfilebuf::seekpos =&gt; cpp/io/basic_filebuf/seekpos
std::wfilebuf::sync =&gt; cpp/io/basic_filebuf/sync
std::wfilebuf::imbue =&gt; cpp/io/basic_filebuf/imbue
std::swap(std::wfilebuf) =&gt; cpp/io/basic_filebuf/swap2
std::wstringbuf =&gt; cpp/io/basic_stringbuf
std::wstringbuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wstringbuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::wstringbuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wstringbuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wstringbuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wstringbuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::wstringbuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::wstringbuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::wstringbuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::wstringbuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::wstringbuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wstringbuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::wstringbuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::wstringbuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::wstringbuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::wstringbuf::swap =&gt; cpp/io/basic_streambuf/swap
std::wstringbuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::wstringbuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::wstringbuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::wstringbuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::wstringbuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::wstringbuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::wstringbuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::wstringbuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::wstringbuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::wstringbuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::wstringbuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::wstringbuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::wstringbuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::wstringbuf::setg =&gt; cpp/io/basic_streambuf/setg
std::wstringbuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::wstringbuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::wstringbuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::wstringbuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::wstringbuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::wstringbuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::wstringbuf::setp =&gt; cpp/io/basic_streambuf/setp
std::wstringbuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::wstringbuf::wstringbuf =&gt; cpp/io/basic_stringbuf/basic_stringbuf
std::wstringbuf::operator= =&gt; cpp/io/basic_stringbuf/operator=
std::wstringbuf::swap =&gt; cpp/io/basic_stringbuf/swap
std::wstringbuf::str =&gt; cpp/io/basic_stringbuf/str
std::wstringbuf::underflow =&gt; cpp/io/basic_stringbuf/underflow
std::wstringbuf::pbackfail =&gt; cpp/io/basic_stringbuf/pbackfail
std::wstringbuf::overflow =&gt; cpp/io/basic_stringbuf/overflow
std::wstringbuf::setbuf =&gt; cpp/io/basic_stringbuf/setbuf
std::wstringbuf::seekoff =&gt; cpp/io/basic_stringbuf/seekoff
std::wstringbuf::seekpos =&gt; cpp/io/basic_stringbuf/seekpos
std::swap(std::wstringbuf) =&gt; cpp/io/basic_stringbuf/swap2
std::wistream =&gt; cpp/io/basic_istream
std::wistream::good =&gt; cpp/io/basic_ios/good
std::wistream::eof =&gt; cpp/io/basic_ios/eof
std::wistream::fail =&gt; cpp/io/basic_ios/fail
std::wistream::bad =&gt; cpp/io/basic_ios/bad
std::wistream::operator! =&gt; cpp/io/basic_ios/operator!
std::wistream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wistream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wistream::setstate =&gt; cpp/io/basic_ios/setstate
std::wistream::clear =&gt; cpp/io/basic_ios/clear
std::wistream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wistream::fill =&gt; cpp/io/basic_ios/fill
std::wistream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wistream::imbue =&gt; cpp/io/basic_ios/imbue
std::wistream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wistream::tie =&gt; cpp/io/basic_ios/tie
std::wistream::narrow =&gt; cpp/io/basic_ios/narrow
std::wistream::widen =&gt; cpp/io/basic_ios/widen
std::wistream::init =&gt; cpp/io/basic_ios/init
std::wistream::move =&gt; cpp/io/basic_ios/move
std::wistream::swap =&gt; cpp/io/basic_ios/swap
std::wistream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wistream::flags =&gt; cpp/io/ios_base/flags
std::wistream::setf =&gt; cpp/io/ios_base/setf
std::wistream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wistream::precision =&gt; cpp/io/ios_base/precision
std::wistream::width =&gt; cpp/io/ios_base/width
std::wistream::imbue =&gt; cpp/io/ios_base/imbue
std::wistream::getloc =&gt; cpp/io/ios_base/getloc
std::wistream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wistream::iword =&gt; cpp/io/ios_base/iword
std::wistream::pword =&gt; cpp/io/ios_base/pword
std::wistream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wistream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wistream::failure =&gt; cpp/io/ios_base/failure
std::wistream::failure::what =&gt; cpp/error/exception/what
std::wistream::failure::failure =&gt; cpp/io/ios_base/failure
std::wistream::openmode =&gt; cpp/io/ios_base/openmode
std::wistream::app =&gt; cpp/io/ios_base/openmode
std::wistream::binary =&gt; cpp/io/ios_base/openmode
std::wistream::in =&gt; cpp/io/ios_base/openmode
std::wistream::out =&gt; cpp/io/ios_base/openmode
std::wistream::trunc =&gt; cpp/io/ios_base/openmode
std::wistream::ate =&gt; cpp/io/ios_base/openmode
std::wistream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wistream::dec =&gt; cpp/io/ios_base/fmtflags
std::wistream::oct =&gt; cpp/io/ios_base/fmtflags
std::wistream::hex =&gt; cpp/io/ios_base/fmtflags
std::wistream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wistream::left =&gt; cpp/io/ios_base/fmtflags
std::wistream::right =&gt; cpp/io/ios_base/fmtflags
std::wistream::internal =&gt; cpp/io/ios_base/fmtflags
std::wistream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wistream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wistream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wistream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wistream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wistream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wistream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wistream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wistream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wistream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wistream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wistream::iostate =&gt; cpp/io/ios_base/iostate
std::wistream::goodbit =&gt; cpp/io/ios_base/iostate
std::wistream::badbit =&gt; cpp/io/ios_base/iostate
std::wistream::failbit =&gt; cpp/io/ios_base/iostate
std::wistream::eofbit =&gt; cpp/io/ios_base/iostate
std::wistream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wistream::beg =&gt; cpp/io/ios_base/seekdir
std::wistream::cur =&gt; cpp/io/ios_base/seekdir
std::wistream::end =&gt; cpp/io/ios_base/seekdir
std::wistream::event =&gt; cpp/io/ios_base/event
std::wistream::erase_event =&gt; cpp/io/ios_base/event
std::wistream::imbue_event =&gt; cpp/io/ios_base/event
std::wistream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wistream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wistream::wistream =&gt; cpp/io/basic_istream/basic_istream
std::wistream::~wistream =&gt; cpp/io/basic_istream/~basic_istream
std::wistream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wistream::get =&gt; cpp/io/basic_istream/get
std::wistream::peek =&gt; cpp/io/basic_istream/peek
std::wistream::unget =&gt; cpp/io/basic_istream/unget
std::wistream::putback =&gt; cpp/io/basic_istream/putback
std::wistream::getline =&gt; cpp/io/basic_istream/getline
std::wistream::ignore =&gt; cpp/io/basic_istream/ignore
std::wistream::read =&gt; cpp/io/basic_istream/read
std::wistream::readsome =&gt; cpp/io/basic_istream/readsome
std::wistream::gcount =&gt; cpp/io/basic_istream/gcount
std::wistream::tellg =&gt; cpp/io/basic_istream/tellg
std::wistream::seekg =&gt; cpp/io/basic_istream/seekg
std::wistream::sync =&gt; cpp/io/basic_istream/sync
std::wistream::sentry =&gt; cpp/io/basic_istream/sentry
std::wistream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wistream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wistream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
operator&gt;&gt;(std::wistream) =&gt; cpp/io/basic_istream/operator_gtgt2
std::wostream =&gt; cpp/io/basic_ostream
std::wostream::good =&gt; cpp/io/basic_ios/good
std::wostream::eof =&gt; cpp/io/basic_ios/eof
std::wostream::fail =&gt; cpp/io/basic_ios/fail
std::wostream::bad =&gt; cpp/io/basic_ios/bad
std::wostream::operator! =&gt; cpp/io/basic_ios/operator!
std::wostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wostream::setstate =&gt; cpp/io/basic_ios/setstate
std::wostream::clear =&gt; cpp/io/basic_ios/clear
std::wostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wostream::fill =&gt; cpp/io/basic_ios/fill
std::wostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wostream::imbue =&gt; cpp/io/basic_ios/imbue
std::wostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wostream::tie =&gt; cpp/io/basic_ios/tie
std::wostream::narrow =&gt; cpp/io/basic_ios/narrow
std::wostream::widen =&gt; cpp/io/basic_ios/widen
std::wostream::init =&gt; cpp/io/basic_ios/init
std::wostream::move =&gt; cpp/io/basic_ios/move
std::wostream::swap =&gt; cpp/io/basic_ios/swap
std::wostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wostream::flags =&gt; cpp/io/ios_base/flags
std::wostream::setf =&gt; cpp/io/ios_base/setf
std::wostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wostream::precision =&gt; cpp/io/ios_base/precision
std::wostream::width =&gt; cpp/io/ios_base/width
std::wostream::imbue =&gt; cpp/io/ios_base/imbue
std::wostream::getloc =&gt; cpp/io/ios_base/getloc
std::wostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wostream::iword =&gt; cpp/io/ios_base/iword
std::wostream::pword =&gt; cpp/io/ios_base/pword
std::wostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wostream::failure =&gt; cpp/io/ios_base/failure
std::wostream::failure::what =&gt; cpp/error/exception/what
std::wostream::failure::failure =&gt; cpp/io/ios_base/failure
std::wostream::openmode =&gt; cpp/io/ios_base/openmode
std::wostream::app =&gt; cpp/io/ios_base/openmode
std::wostream::binary =&gt; cpp/io/ios_base/openmode
std::wostream::in =&gt; cpp/io/ios_base/openmode
std::wostream::out =&gt; cpp/io/ios_base/openmode
std::wostream::trunc =&gt; cpp/io/ios_base/openmode
std::wostream::ate =&gt; cpp/io/ios_base/openmode
std::wostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wostream::dec =&gt; cpp/io/ios_base/fmtflags
std::wostream::oct =&gt; cpp/io/ios_base/fmtflags
std::wostream::hex =&gt; cpp/io/ios_base/fmtflags
std::wostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wostream::left =&gt; cpp/io/ios_base/fmtflags
std::wostream::right =&gt; cpp/io/ios_base/fmtflags
std::wostream::internal =&gt; cpp/io/ios_base/fmtflags
std::wostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wostream::iostate =&gt; cpp/io/ios_base/iostate
std::wostream::goodbit =&gt; cpp/io/ios_base/iostate
std::wostream::badbit =&gt; cpp/io/ios_base/iostate
std::wostream::failbit =&gt; cpp/io/ios_base/iostate
std::wostream::eofbit =&gt; cpp/io/ios_base/iostate
std::wostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wostream::beg =&gt; cpp/io/ios_base/seekdir
std::wostream::cur =&gt; cpp/io/ios_base/seekdir
std::wostream::end =&gt; cpp/io/ios_base/seekdir
std::wostream::event =&gt; cpp/io/ios_base/event
std::wostream::erase_event =&gt; cpp/io/ios_base/event
std::wostream::imbue_event =&gt; cpp/io/ios_base/event
std::wostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wostream::wostream =&gt; cpp/io/basic_ostream/basic_ostream
std::wostream::~wostream =&gt; cpp/io/basic_ostream/~basic_ostream
std::wostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wostream::put =&gt; cpp/io/basic_ostream/put
std::wostream::write =&gt; cpp/io/basic_ostream/write
std::wostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wostream::flush =&gt; cpp/io/basic_ostream/flush
std::wostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
operator&lt;&lt;(std::wostream) =&gt; cpp/io/basic_ostream/operator_ltlt2
std::wiostream =&gt; cpp/io/basic_iostream
std::wiostream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wiostream::get =&gt; cpp/io/basic_istream/get
std::wiostream::peek =&gt; cpp/io/basic_istream/peek
std::wiostream::unget =&gt; cpp/io/basic_istream/unget
std::wiostream::putback =&gt; cpp/io/basic_istream/putback
std::wiostream::getline =&gt; cpp/io/basic_istream/getline
std::wiostream::ignore =&gt; cpp/io/basic_istream/ignore
std::wiostream::read =&gt; cpp/io/basic_istream/read
std::wiostream::readsome =&gt; cpp/io/basic_istream/readsome
std::wiostream::gcount =&gt; cpp/io/basic_istream/gcount
std::wiostream::tellg =&gt; cpp/io/basic_istream/tellg
std::wiostream::seekg =&gt; cpp/io/basic_istream/seekg
std::wiostream::sync =&gt; cpp/io/basic_istream/sync
std::wiostream::sentry =&gt; cpp/io/basic_istream/sentry
std::wiostream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wiostream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wiostream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::wiostream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wiostream::put =&gt; cpp/io/basic_ostream/put
std::wiostream::write =&gt; cpp/io/basic_ostream/write
std::wiostream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wiostream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wiostream::flush =&gt; cpp/io/basic_ostream/flush
std::wiostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wiostream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wiostream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wiostream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::wiostream::good =&gt; cpp/io/basic_ios/good
std::wiostream::eof =&gt; cpp/io/basic_ios/eof
std::wiostream::fail =&gt; cpp/io/basic_ios/fail
std::wiostream::bad =&gt; cpp/io/basic_ios/bad
std::wiostream::operator! =&gt; cpp/io/basic_ios/operator!
std::wiostream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wiostream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wiostream::setstate =&gt; cpp/io/basic_ios/setstate
std::wiostream::clear =&gt; cpp/io/basic_ios/clear
std::wiostream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wiostream::fill =&gt; cpp/io/basic_ios/fill
std::wiostream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wiostream::imbue =&gt; cpp/io/basic_ios/imbue
std::wiostream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wiostream::tie =&gt; cpp/io/basic_ios/tie
std::wiostream::narrow =&gt; cpp/io/basic_ios/narrow
std::wiostream::widen =&gt; cpp/io/basic_ios/widen
std::wiostream::init =&gt; cpp/io/basic_ios/init
std::wiostream::move =&gt; cpp/io/basic_ios/move
std::wiostream::swap =&gt; cpp/io/basic_ios/swap
std::wiostream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wiostream::flags =&gt; cpp/io/ios_base/flags
std::wiostream::setf =&gt; cpp/io/ios_base/setf
std::wiostream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wiostream::precision =&gt; cpp/io/ios_base/precision
std::wiostream::width =&gt; cpp/io/ios_base/width
std::wiostream::imbue =&gt; cpp/io/ios_base/imbue
std::wiostream::getloc =&gt; cpp/io/ios_base/getloc
std::wiostream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wiostream::iword =&gt; cpp/io/ios_base/iword
std::wiostream::pword =&gt; cpp/io/ios_base/pword
std::wiostream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wiostream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wiostream::failure =&gt; cpp/io/ios_base/failure
std::wiostream::failure::what =&gt; cpp/error/exception/what
std::wiostream::failure::failure =&gt; cpp/io/ios_base/failure
std::wiostream::openmode =&gt; cpp/io/ios_base/openmode
std::wiostream::app =&gt; cpp/io/ios_base/openmode
std::wiostream::binary =&gt; cpp/io/ios_base/openmode
std::wiostream::in =&gt; cpp/io/ios_base/openmode
std::wiostream::out =&gt; cpp/io/ios_base/openmode
std::wiostream::trunc =&gt; cpp/io/ios_base/openmode
std::wiostream::ate =&gt; cpp/io/ios_base/openmode
std::wiostream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wiostream::dec =&gt; cpp/io/ios_base/fmtflags
std::wiostream::oct =&gt; cpp/io/ios_base/fmtflags
std::wiostream::hex =&gt; cpp/io/ios_base/fmtflags
std::wiostream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wiostream::left =&gt; cpp/io/ios_base/fmtflags
std::wiostream::right =&gt; cpp/io/ios_base/fmtflags
std::wiostream::internal =&gt; cpp/io/ios_base/fmtflags
std::wiostream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wiostream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wiostream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wiostream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wiostream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wiostream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wiostream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wiostream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wiostream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wiostream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wiostream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wiostream::iostate =&gt; cpp/io/ios_base/iostate
std::wiostream::goodbit =&gt; cpp/io/ios_base/iostate
std::wiostream::badbit =&gt; cpp/io/ios_base/iostate
std::wiostream::failbit =&gt; cpp/io/ios_base/iostate
std::wiostream::eofbit =&gt; cpp/io/ios_base/iostate
std::wiostream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wiostream::beg =&gt; cpp/io/ios_base/seekdir
std::wiostream::cur =&gt; cpp/io/ios_base/seekdir
std::wiostream::end =&gt; cpp/io/ios_base/seekdir
std::wiostream::event =&gt; cpp/io/ios_base/event
std::wiostream::erase_event =&gt; cpp/io/ios_base/event
std::wiostream::imbue_event =&gt; cpp/io/ios_base/event
std::wiostream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wiostream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wiostream::wiostream =&gt; cpp/io/basic_iostream/basic_iostream
std::wiostream::~wiostream =&gt; cpp/io/basic_iostream/~basic_iostream
std::wifstream =&gt; cpp/io/basic_ifstream
std::wifstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wifstream::get =&gt; cpp/io/basic_istream/get
std::wifstream::peek =&gt; cpp/io/basic_istream/peek
std::wifstream::unget =&gt; cpp/io/basic_istream/unget
std::wifstream::putback =&gt; cpp/io/basic_istream/putback
std::wifstream::getline =&gt; cpp/io/basic_istream/getline
std::wifstream::ignore =&gt; cpp/io/basic_istream/ignore
std::wifstream::read =&gt; cpp/io/basic_istream/read
std::wifstream::readsome =&gt; cpp/io/basic_istream/readsome
std::wifstream::gcount =&gt; cpp/io/basic_istream/gcount
std::wifstream::tellg =&gt; cpp/io/basic_istream/tellg
std::wifstream::seekg =&gt; cpp/io/basic_istream/seekg
std::wifstream::sync =&gt; cpp/io/basic_istream/sync
std::wifstream::sentry =&gt; cpp/io/basic_istream/sentry
std::wifstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wifstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wifstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::wifstream::good =&gt; cpp/io/basic_ios/good
std::wifstream::eof =&gt; cpp/io/basic_ios/eof
std::wifstream::fail =&gt; cpp/io/basic_ios/fail
std::wifstream::bad =&gt; cpp/io/basic_ios/bad
std::wifstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wifstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wifstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wifstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wifstream::clear =&gt; cpp/io/basic_ios/clear
std::wifstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wifstream::fill =&gt; cpp/io/basic_ios/fill
std::wifstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wifstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wifstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wifstream::tie =&gt; cpp/io/basic_ios/tie
std::wifstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wifstream::widen =&gt; cpp/io/basic_ios/widen
std::wifstream::init =&gt; cpp/io/basic_ios/init
std::wifstream::move =&gt; cpp/io/basic_ios/move
std::wifstream::swap =&gt; cpp/io/basic_ios/swap
std::wifstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wifstream::flags =&gt; cpp/io/ios_base/flags
std::wifstream::setf =&gt; cpp/io/ios_base/setf
std::wifstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wifstream::precision =&gt; cpp/io/ios_base/precision
std::wifstream::width =&gt; cpp/io/ios_base/width
std::wifstream::imbue =&gt; cpp/io/ios_base/imbue
std::wifstream::getloc =&gt; cpp/io/ios_base/getloc
std::wifstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wifstream::iword =&gt; cpp/io/ios_base/iword
std::wifstream::pword =&gt; cpp/io/ios_base/pword
std::wifstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wifstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wifstream::failure =&gt; cpp/io/ios_base/failure
std::wifstream::failure::what =&gt; cpp/error/exception/what
std::wifstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wifstream::openmode =&gt; cpp/io/ios_base/openmode
std::wifstream::app =&gt; cpp/io/ios_base/openmode
std::wifstream::binary =&gt; cpp/io/ios_base/openmode
std::wifstream::in =&gt; cpp/io/ios_base/openmode
std::wifstream::out =&gt; cpp/io/ios_base/openmode
std::wifstream::trunc =&gt; cpp/io/ios_base/openmode
std::wifstream::ate =&gt; cpp/io/ios_base/openmode
std::wifstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wifstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wifstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wifstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wifstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wifstream::left =&gt; cpp/io/ios_base/fmtflags
std::wifstream::right =&gt; cpp/io/ios_base/fmtflags
std::wifstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wifstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wifstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wifstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wifstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wifstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wifstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wifstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wifstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wifstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wifstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wifstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wifstream::iostate =&gt; cpp/io/ios_base/iostate
std::wifstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wifstream::badbit =&gt; cpp/io/ios_base/iostate
std::wifstream::failbit =&gt; cpp/io/ios_base/iostate
std::wifstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wifstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wifstream::beg =&gt; cpp/io/ios_base/seekdir
std::wifstream::cur =&gt; cpp/io/ios_base/seekdir
std::wifstream::end =&gt; cpp/io/ios_base/seekdir
std::wifstream::event =&gt; cpp/io/ios_base/event
std::wifstream::erase_event =&gt; cpp/io/ios_base/event
std::wifstream::imbue_event =&gt; cpp/io/ios_base/event
std::wifstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wifstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wifstream::wifstream =&gt; cpp/io/basic_ifstream/basic_ifstream
std::wifstream::operator= =&gt; cpp/io/basic_ifstream/operator=
std::wifstream::swap =&gt; cpp/io/basic_ifstream/swap
std::wifstream::rdbuf =&gt; cpp/io/basic_ifstream/rdbuf
std::wifstream::is_open =&gt; cpp/io/basic_ifstream/is_open
std::wifstream::open =&gt; cpp/io/basic_ifstream/open
std::wifstream::close =&gt; cpp/io/basic_ifstream/close
std::swap(std::wifstream) =&gt; cpp/io/basic_ifstream/swap2
std::wofstream =&gt; cpp/io/basic_ofstream
std::wofstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wofstream::put =&gt; cpp/io/basic_ostream/put
std::wofstream::write =&gt; cpp/io/basic_ostream/write
std::wofstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wofstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wofstream::flush =&gt; cpp/io/basic_ostream/flush
std::wofstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wofstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wofstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wofstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::wofstream::good =&gt; cpp/io/basic_ios/good
std::wofstream::eof =&gt; cpp/io/basic_ios/eof
std::wofstream::fail =&gt; cpp/io/basic_ios/fail
std::wofstream::bad =&gt; cpp/io/basic_ios/bad
std::wofstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wofstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wofstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wofstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wofstream::clear =&gt; cpp/io/basic_ios/clear
std::wofstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wofstream::fill =&gt; cpp/io/basic_ios/fill
std::wofstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wofstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wofstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wofstream::tie =&gt; cpp/io/basic_ios/tie
std::wofstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wofstream::widen =&gt; cpp/io/basic_ios/widen
std::wofstream::init =&gt; cpp/io/basic_ios/init
std::wofstream::move =&gt; cpp/io/basic_ios/move
std::wofstream::swap =&gt; cpp/io/basic_ios/swap
std::wofstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wofstream::flags =&gt; cpp/io/ios_base/flags
std::wofstream::setf =&gt; cpp/io/ios_base/setf
std::wofstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wofstream::precision =&gt; cpp/io/ios_base/precision
std::wofstream::width =&gt; cpp/io/ios_base/width
std::wofstream::imbue =&gt; cpp/io/ios_base/imbue
std::wofstream::getloc =&gt; cpp/io/ios_base/getloc
std::wofstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wofstream::iword =&gt; cpp/io/ios_base/iword
std::wofstream::pword =&gt; cpp/io/ios_base/pword
std::wofstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wofstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wofstream::failure =&gt; cpp/io/ios_base/failure
std::wofstream::failure::what =&gt; cpp/error/exception/what
std::wofstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wofstream::openmode =&gt; cpp/io/ios_base/openmode
std::wofstream::app =&gt; cpp/io/ios_base/openmode
std::wofstream::binary =&gt; cpp/io/ios_base/openmode
std::wofstream::in =&gt; cpp/io/ios_base/openmode
std::wofstream::out =&gt; cpp/io/ios_base/openmode
std::wofstream::trunc =&gt; cpp/io/ios_base/openmode
std::wofstream::ate =&gt; cpp/io/ios_base/openmode
std::wofstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wofstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wofstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wofstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wofstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wofstream::left =&gt; cpp/io/ios_base/fmtflags
std::wofstream::right =&gt; cpp/io/ios_base/fmtflags
std::wofstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wofstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wofstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wofstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wofstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wofstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wofstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wofstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wofstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wofstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wofstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wofstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wofstream::iostate =&gt; cpp/io/ios_base/iostate
std::wofstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wofstream::badbit =&gt; cpp/io/ios_base/iostate
std::wofstream::failbit =&gt; cpp/io/ios_base/iostate
std::wofstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wofstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wofstream::beg =&gt; cpp/io/ios_base/seekdir
std::wofstream::cur =&gt; cpp/io/ios_base/seekdir
std::wofstream::end =&gt; cpp/io/ios_base/seekdir
std::wofstream::event =&gt; cpp/io/ios_base/event
std::wofstream::erase_event =&gt; cpp/io/ios_base/event
std::wofstream::imbue_event =&gt; cpp/io/ios_base/event
std::wofstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wofstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wofstream::wofstream =&gt; cpp/io/basic_ofstream/basic_ofstream
std::wofstream::operator= =&gt; cpp/io/basic_ofstream/operator=
std::wofstream::swap =&gt; cpp/io/basic_ofstream/swap
std::wofstream::rdbuf =&gt; cpp/io/basic_ofstream/rdbuf
std::wofstream::is_open =&gt; cpp/io/basic_ofstream/is_open
std::wofstream::open =&gt; cpp/io/basic_ofstream/open
std::wofstream::close =&gt; cpp/io/basic_ofstream/close
std::swap(std::wofstream) =&gt; cpp/io/basic_ofstream/swap2
std::wfstream =&gt; cpp/io/basic_fstream
std::wfstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wfstream::get =&gt; cpp/io/basic_istream/get
std::wfstream::peek =&gt; cpp/io/basic_istream/peek
std::wfstream::unget =&gt; cpp/io/basic_istream/unget
std::wfstream::putback =&gt; cpp/io/basic_istream/putback
std::wfstream::getline =&gt; cpp/io/basic_istream/getline
std::wfstream::ignore =&gt; cpp/io/basic_istream/ignore
std::wfstream::read =&gt; cpp/io/basic_istream/read
std::wfstream::readsome =&gt; cpp/io/basic_istream/readsome
std::wfstream::gcount =&gt; cpp/io/basic_istream/gcount
std::wfstream::tellg =&gt; cpp/io/basic_istream/tellg
std::wfstream::seekg =&gt; cpp/io/basic_istream/seekg
std::wfstream::sync =&gt; cpp/io/basic_istream/sync
std::wfstream::sentry =&gt; cpp/io/basic_istream/sentry
std::wfstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wfstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wfstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::wfstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wfstream::put =&gt; cpp/io/basic_ostream/put
std::wfstream::write =&gt; cpp/io/basic_ostream/write
std::wfstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wfstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wfstream::flush =&gt; cpp/io/basic_ostream/flush
std::wfstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wfstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wfstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wfstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::wfstream::good =&gt; cpp/io/basic_ios/good
std::wfstream::eof =&gt; cpp/io/basic_ios/eof
std::wfstream::fail =&gt; cpp/io/basic_ios/fail
std::wfstream::bad =&gt; cpp/io/basic_ios/bad
std::wfstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wfstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wfstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wfstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wfstream::clear =&gt; cpp/io/basic_ios/clear
std::wfstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wfstream::fill =&gt; cpp/io/basic_ios/fill
std::wfstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wfstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wfstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wfstream::tie =&gt; cpp/io/basic_ios/tie
std::wfstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wfstream::widen =&gt; cpp/io/basic_ios/widen
std::wfstream::init =&gt; cpp/io/basic_ios/init
std::wfstream::move =&gt; cpp/io/basic_ios/move
std::wfstream::swap =&gt; cpp/io/basic_ios/swap
std::wfstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wfstream::flags =&gt; cpp/io/ios_base/flags
std::wfstream::setf =&gt; cpp/io/ios_base/setf
std::wfstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wfstream::precision =&gt; cpp/io/ios_base/precision
std::wfstream::width =&gt; cpp/io/ios_base/width
std::wfstream::imbue =&gt; cpp/io/ios_base/imbue
std::wfstream::getloc =&gt; cpp/io/ios_base/getloc
std::wfstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wfstream::iword =&gt; cpp/io/ios_base/iword
std::wfstream::pword =&gt; cpp/io/ios_base/pword
std::wfstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wfstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wfstream::failure =&gt; cpp/io/ios_base/failure
std::wfstream::failure::what =&gt; cpp/error/exception/what
std::wfstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wfstream::openmode =&gt; cpp/io/ios_base/openmode
std::wfstream::app =&gt; cpp/io/ios_base/openmode
std::wfstream::binary =&gt; cpp/io/ios_base/openmode
std::wfstream::in =&gt; cpp/io/ios_base/openmode
std::wfstream::out =&gt; cpp/io/ios_base/openmode
std::wfstream::trunc =&gt; cpp/io/ios_base/openmode
std::wfstream::ate =&gt; cpp/io/ios_base/openmode
std::wfstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wfstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wfstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wfstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wfstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wfstream::left =&gt; cpp/io/ios_base/fmtflags
std::wfstream::right =&gt; cpp/io/ios_base/fmtflags
std::wfstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wfstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wfstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wfstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wfstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wfstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wfstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wfstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wfstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wfstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wfstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wfstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wfstream::iostate =&gt; cpp/io/ios_base/iostate
std::wfstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wfstream::badbit =&gt; cpp/io/ios_base/iostate
std::wfstream::failbit =&gt; cpp/io/ios_base/iostate
std::wfstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wfstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wfstream::beg =&gt; cpp/io/ios_base/seekdir
std::wfstream::cur =&gt; cpp/io/ios_base/seekdir
std::wfstream::end =&gt; cpp/io/ios_base/seekdir
std::wfstream::event =&gt; cpp/io/ios_base/event
std::wfstream::erase_event =&gt; cpp/io/ios_base/event
std::wfstream::imbue_event =&gt; cpp/io/ios_base/event
std::wfstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wfstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wfstream::wfstream =&gt; cpp/io/basic_fstream/basic_fstream
std::wfstream::operator= =&gt; cpp/io/basic_fstream/operator=
std::wfstream::swap =&gt; cpp/io/basic_fstream/swap
std::wfstream::rdbuf =&gt; cpp/io/basic_fstream/rdbuf
std::wfstream::is_open =&gt; cpp/io/basic_fstream/is_open
std::wfstream::open =&gt; cpp/io/basic_fstream/open
std::wfstream::close =&gt; cpp/io/basic_fstream/close
std::swap(std::wfstream) =&gt; cpp/io/basic_fstream/swap2
std::wistringstream =&gt; cpp/io/basic_istringstream
std::wistringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wistringstream::get =&gt; cpp/io/basic_istream/get
std::wistringstream::peek =&gt; cpp/io/basic_istream/peek
std::wistringstream::unget =&gt; cpp/io/basic_istream/unget
std::wistringstream::putback =&gt; cpp/io/basic_istream/putback
std::wistringstream::getline =&gt; cpp/io/basic_istream/getline
std::wistringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::wistringstream::read =&gt; cpp/io/basic_istream/read
std::wistringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::wistringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::wistringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::wistringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::wistringstream::sync =&gt; cpp/io/basic_istream/sync
std::wistringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::wistringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wistringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wistringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::wistringstream::good =&gt; cpp/io/basic_ios/good
std::wistringstream::eof =&gt; cpp/io/basic_ios/eof
std::wistringstream::fail =&gt; cpp/io/basic_ios/fail
std::wistringstream::bad =&gt; cpp/io/basic_ios/bad
std::wistringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wistringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wistringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wistringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wistringstream::clear =&gt; cpp/io/basic_ios/clear
std::wistringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wistringstream::fill =&gt; cpp/io/basic_ios/fill
std::wistringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wistringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wistringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wistringstream::tie =&gt; cpp/io/basic_ios/tie
std::wistringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wistringstream::widen =&gt; cpp/io/basic_ios/widen
std::wistringstream::init =&gt; cpp/io/basic_ios/init
std::wistringstream::move =&gt; cpp/io/basic_ios/move
std::wistringstream::swap =&gt; cpp/io/basic_ios/swap
std::wistringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wistringstream::flags =&gt; cpp/io/ios_base/flags
std::wistringstream::setf =&gt; cpp/io/ios_base/setf
std::wistringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wistringstream::precision =&gt; cpp/io/ios_base/precision
std::wistringstream::width =&gt; cpp/io/ios_base/width
std::wistringstream::imbue =&gt; cpp/io/ios_base/imbue
std::wistringstream::getloc =&gt; cpp/io/ios_base/getloc
std::wistringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wistringstream::iword =&gt; cpp/io/ios_base/iword
std::wistringstream::pword =&gt; cpp/io/ios_base/pword
std::wistringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wistringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wistringstream::failure =&gt; cpp/io/ios_base/failure
std::wistringstream::failure::what =&gt; cpp/error/exception/what
std::wistringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wistringstream::openmode =&gt; cpp/io/ios_base/openmode
std::wistringstream::app =&gt; cpp/io/ios_base/openmode
std::wistringstream::binary =&gt; cpp/io/ios_base/openmode
std::wistringstream::in =&gt; cpp/io/ios_base/openmode
std::wistringstream::out =&gt; cpp/io/ios_base/openmode
std::wistringstream::trunc =&gt; cpp/io/ios_base/openmode
std::wistringstream::ate =&gt; cpp/io/ios_base/openmode
std::wistringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::left =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::right =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wistringstream::iostate =&gt; cpp/io/ios_base/iostate
std::wistringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wistringstream::badbit =&gt; cpp/io/ios_base/iostate
std::wistringstream::failbit =&gt; cpp/io/ios_base/iostate
std::wistringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wistringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wistringstream::beg =&gt; cpp/io/ios_base/seekdir
std::wistringstream::cur =&gt; cpp/io/ios_base/seekdir
std::wistringstream::end =&gt; cpp/io/ios_base/seekdir
std::wistringstream::event =&gt; cpp/io/ios_base/event
std::wistringstream::erase_event =&gt; cpp/io/ios_base/event
std::wistringstream::imbue_event =&gt; cpp/io/ios_base/event
std::wistringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wistringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wistringstream::wistringstream =&gt; cpp/io/basic_istringstream/basic_istringstream
std::wistringstream::operator= =&gt; cpp/io/basic_istringstream/operator=
std::wistringstream::swap =&gt; cpp/io/basic_istringstream/swap
std::wistringstream::rdbuf =&gt; cpp/io/basic_istringstream/rdbuf
std::wistringstream::str =&gt; cpp/io/basic_istringstream/str
std::swap(std::wistringstream) =&gt; cpp/io/basic_istringstream/swap2
std::wostringstream =&gt; cpp/io/basic_ostringstream
std::wostringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wostringstream::put =&gt; cpp/io/basic_ostream/put
std::wostringstream::write =&gt; cpp/io/basic_ostream/write
std::wostringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wostringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wostringstream::flush =&gt; cpp/io/basic_ostream/flush
std::wostringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wostringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wostringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wostringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::wostringstream::good =&gt; cpp/io/basic_ios/good
std::wostringstream::eof =&gt; cpp/io/basic_ios/eof
std::wostringstream::fail =&gt; cpp/io/basic_ios/fail
std::wostringstream::bad =&gt; cpp/io/basic_ios/bad
std::wostringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wostringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wostringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wostringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wostringstream::clear =&gt; cpp/io/basic_ios/clear
std::wostringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wostringstream::fill =&gt; cpp/io/basic_ios/fill
std::wostringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wostringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wostringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wostringstream::tie =&gt; cpp/io/basic_ios/tie
std::wostringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wostringstream::widen =&gt; cpp/io/basic_ios/widen
std::wostringstream::init =&gt; cpp/io/basic_ios/init
std::wostringstream::move =&gt; cpp/io/basic_ios/move
std::wostringstream::swap =&gt; cpp/io/basic_ios/swap
std::wostringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wostringstream::flags =&gt; cpp/io/ios_base/flags
std::wostringstream::setf =&gt; cpp/io/ios_base/setf
std::wostringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wostringstream::precision =&gt; cpp/io/ios_base/precision
std::wostringstream::width =&gt; cpp/io/ios_base/width
std::wostringstream::imbue =&gt; cpp/io/ios_base/imbue
std::wostringstream::getloc =&gt; cpp/io/ios_base/getloc
std::wostringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wostringstream::iword =&gt; cpp/io/ios_base/iword
std::wostringstream::pword =&gt; cpp/io/ios_base/pword
std::wostringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wostringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wostringstream::failure =&gt; cpp/io/ios_base/failure
std::wostringstream::failure::what =&gt; cpp/error/exception/what
std::wostringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wostringstream::openmode =&gt; cpp/io/ios_base/openmode
std::wostringstream::app =&gt; cpp/io/ios_base/openmode
std::wostringstream::binary =&gt; cpp/io/ios_base/openmode
std::wostringstream::in =&gt; cpp/io/ios_base/openmode
std::wostringstream::out =&gt; cpp/io/ios_base/openmode
std::wostringstream::trunc =&gt; cpp/io/ios_base/openmode
std::wostringstream::ate =&gt; cpp/io/ios_base/openmode
std::wostringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::left =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::right =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wostringstream::iostate =&gt; cpp/io/ios_base/iostate
std::wostringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wostringstream::badbit =&gt; cpp/io/ios_base/iostate
std::wostringstream::failbit =&gt; cpp/io/ios_base/iostate
std::wostringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wostringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wostringstream::beg =&gt; cpp/io/ios_base/seekdir
std::wostringstream::cur =&gt; cpp/io/ios_base/seekdir
std::wostringstream::end =&gt; cpp/io/ios_base/seekdir
std::wostringstream::event =&gt; cpp/io/ios_base/event
std::wostringstream::erase_event =&gt; cpp/io/ios_base/event
std::wostringstream::imbue_event =&gt; cpp/io/ios_base/event
std::wostringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wostringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wostringstream::wostringstream =&gt; cpp/io/basic_ostringstream/basic_ostringstream
std::wostringstream::operator= =&gt; cpp/io/basic_ostringstream/operator=
std::wostringstream::swap =&gt; cpp/io/basic_ostringstream/swap
std::wostringstream::rdbuf =&gt; cpp/io/basic_ostringstream/rdbuf
std::wostringstream::str =&gt; cpp/io/basic_ostringstream/str
std::swap(std::wostringstream) =&gt; cpp/io/basic_ostringstream/swap2
std::wstringstream =&gt; cpp/io/basic_stringstream
std::wstringstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::wstringstream::get =&gt; cpp/io/basic_istream/get
std::wstringstream::peek =&gt; cpp/io/basic_istream/peek
std::wstringstream::unget =&gt; cpp/io/basic_istream/unget
std::wstringstream::putback =&gt; cpp/io/basic_istream/putback
std::wstringstream::getline =&gt; cpp/io/basic_istream/getline
std::wstringstream::ignore =&gt; cpp/io/basic_istream/ignore
std::wstringstream::read =&gt; cpp/io/basic_istream/read
std::wstringstream::readsome =&gt; cpp/io/basic_istream/readsome
std::wstringstream::gcount =&gt; cpp/io/basic_istream/gcount
std::wstringstream::tellg =&gt; cpp/io/basic_istream/tellg
std::wstringstream::seekg =&gt; cpp/io/basic_istream/seekg
std::wstringstream::sync =&gt; cpp/io/basic_istream/sync
std::wstringstream::sentry =&gt; cpp/io/basic_istream/sentry
std::wstringstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::wstringstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::wstringstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::wstringstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::wstringstream::put =&gt; cpp/io/basic_ostream/put
std::wstringstream::write =&gt; cpp/io/basic_ostream/write
std::wstringstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::wstringstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::wstringstream::flush =&gt; cpp/io/basic_ostream/flush
std::wstringstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wstringstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::wstringstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::wstringstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::wstringstream::good =&gt; cpp/io/basic_ios/good
std::wstringstream::eof =&gt; cpp/io/basic_ios/eof
std::wstringstream::fail =&gt; cpp/io/basic_ios/fail
std::wstringstream::bad =&gt; cpp/io/basic_ios/bad
std::wstringstream::operator! =&gt; cpp/io/basic_ios/operator!
std::wstringstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::wstringstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::wstringstream::setstate =&gt; cpp/io/basic_ios/setstate
std::wstringstream::clear =&gt; cpp/io/basic_ios/clear
std::wstringstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::wstringstream::fill =&gt; cpp/io/basic_ios/fill
std::wstringstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::wstringstream::imbue =&gt; cpp/io/basic_ios/imbue
std::wstringstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::wstringstream::tie =&gt; cpp/io/basic_ios/tie
std::wstringstream::narrow =&gt; cpp/io/basic_ios/narrow
std::wstringstream::widen =&gt; cpp/io/basic_ios/widen
std::wstringstream::init =&gt; cpp/io/basic_ios/init
std::wstringstream::move =&gt; cpp/io/basic_ios/move
std::wstringstream::swap =&gt; cpp/io/basic_ios/swap
std::wstringstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::wstringstream::flags =&gt; cpp/io/ios_base/flags
std::wstringstream::setf =&gt; cpp/io/ios_base/setf
std::wstringstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::wstringstream::precision =&gt; cpp/io/ios_base/precision
std::wstringstream::width =&gt; cpp/io/ios_base/width
std::wstringstream::imbue =&gt; cpp/io/ios_base/imbue
std::wstringstream::getloc =&gt; cpp/io/ios_base/getloc
std::wstringstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::wstringstream::iword =&gt; cpp/io/ios_base/iword
std::wstringstream::pword =&gt; cpp/io/ios_base/pword
std::wstringstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::wstringstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::wstringstream::failure =&gt; cpp/io/ios_base/failure
std::wstringstream::failure::what =&gt; cpp/error/exception/what
std::wstringstream::failure::failure =&gt; cpp/io/ios_base/failure
std::wstringstream::openmode =&gt; cpp/io/ios_base/openmode
std::wstringstream::app =&gt; cpp/io/ios_base/openmode
std::wstringstream::binary =&gt; cpp/io/ios_base/openmode
std::wstringstream::in =&gt; cpp/io/ios_base/openmode
std::wstringstream::out =&gt; cpp/io/ios_base/openmode
std::wstringstream::trunc =&gt; cpp/io/ios_base/openmode
std::wstringstream::ate =&gt; cpp/io/ios_base/openmode
std::wstringstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::dec =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::oct =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::hex =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::left =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::right =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::internal =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::wstringstream::iostate =&gt; cpp/io/ios_base/iostate
std::wstringstream::goodbit =&gt; cpp/io/ios_base/iostate
std::wstringstream::badbit =&gt; cpp/io/ios_base/iostate
std::wstringstream::failbit =&gt; cpp/io/ios_base/iostate
std::wstringstream::eofbit =&gt; cpp/io/ios_base/iostate
std::wstringstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::wstringstream::beg =&gt; cpp/io/ios_base/seekdir
std::wstringstream::cur =&gt; cpp/io/ios_base/seekdir
std::wstringstream::end =&gt; cpp/io/ios_base/seekdir
std::wstringstream::event =&gt; cpp/io/ios_base/event
std::wstringstream::erase_event =&gt; cpp/io/ios_base/event
std::wstringstream::imbue_event =&gt; cpp/io/ios_base/event
std::wstringstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::wstringstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::wstringstream::wstringstream =&gt; cpp/io/basic_stringstream/basic_stringstream
std::wstringstream::operator= =&gt; cpp/io/basic_stringstream/operator=
std::wstringstream::swap =&gt; cpp/io/basic_stringstream/swap
std::wstringstream::rdbuf =&gt; cpp/io/basic_stringstream/rdbuf
std::wstringstream::str =&gt; cpp/io/basic_stringstream/str
std::swap(std::wstringstream) =&gt; cpp/io/basic_stringstream/swap2
std::strstreambuf =&gt; cpp/io/strstreambuf
std::strstreambuf::pubimbue =&gt; cpp/io/basic_streambuf/pubimbue
std::strstreambuf::getloc =&gt; cpp/io/basic_streambuf/getloc
std::strstreambuf::pubsetbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::strstreambuf::pubseekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::strstreambuf::pubseekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::strstreambuf::pubsync =&gt; cpp/io/basic_streambuf/pubsync
std::strstreambuf::in_avail =&gt; cpp/io/basic_streambuf/in_avail
std::strstreambuf::snextc =&gt; cpp/io/basic_streambuf/snextc
std::strstreambuf::sbumpc =&gt; cpp/io/basic_streambuf/sbumpc
std::strstreambuf::sgetc =&gt; cpp/io/basic_streambuf/sgetc
std::strstreambuf::sgetn =&gt; cpp/io/basic_streambuf/sgetn
std::strstreambuf::sputc =&gt; cpp/io/basic_streambuf/sputc
std::strstreambuf::sputn =&gt; cpp/io/basic_streambuf/sputn
std::strstreambuf::sputbackc =&gt; cpp/io/basic_streambuf/sputbackc
std::strstreambuf::sungetc =&gt; cpp/io/basic_streambuf/sungetc
std::strstreambuf::swap =&gt; cpp/io/basic_streambuf/swap
std::strstreambuf::imbue =&gt; cpp/io/basic_streambuf/pubimbue
std::strstreambuf::setbuf =&gt; cpp/io/basic_streambuf/pubsetbuf
std::strstreambuf::seekoff =&gt; cpp/io/basic_streambuf/pubseekoff
std::strstreambuf::seekpos =&gt; cpp/io/basic_streambuf/pubseekpos
std::strstreambuf::sync =&gt; cpp/io/basic_streambuf/pubsync
std::strstreambuf::showmanyc =&gt; cpp/io/basic_streambuf/showmanyc
std::strstreambuf::underflow =&gt; cpp/io/basic_streambuf/underflow
std::strstreambuf::uflow =&gt; cpp/io/basic_streambuf/uflow
std::strstreambuf::xsgetn =&gt; cpp/io/basic_streambuf/sgetn
std::strstreambuf::eback =&gt; cpp/io/basic_streambuf/gptr
std::strstreambuf::gptr =&gt; cpp/io/basic_streambuf/gptr
std::strstreambuf::egptr =&gt; cpp/io/basic_streambuf/gptr
std::strstreambuf::gbump =&gt; cpp/io/basic_streambuf/gbump
std::strstreambuf::setg =&gt; cpp/io/basic_streambuf/setg
std::strstreambuf::xsputn =&gt; cpp/io/basic_streambuf/sputn
std::strstreambuf::overflow =&gt; cpp/io/basic_streambuf/overflow
std::strstreambuf::pbase =&gt; cpp/io/basic_streambuf/pptr
std::strstreambuf::pptr =&gt; cpp/io/basic_streambuf/pptr
std::strstreambuf::epptr =&gt; cpp/io/basic_streambuf/pptr
std::strstreambuf::pbump =&gt; cpp/io/basic_streambuf/pbump
std::strstreambuf::setp =&gt; cpp/io/basic_streambuf/setp
std::strstreambuf::pbackfail =&gt; cpp/io/basic_streambuf/pbackfail
std::strstreambuf::strstreambuf =&gt; cpp/io/strstreambuf/strstreambuf
std::strstreambuf::~strstreambuf =&gt; cpp/io/strstreambuf/~strstreambuf
std::strstreambuf::freeze =&gt; cpp/io/strstreambuf/freeze
std::strstreambuf::str =&gt; cpp/io/strstreambuf/str
std::strstreambuf::pcount =&gt; cpp/io/strstreambuf/pcount
std::strstreambuf::underflow =&gt; cpp/io/strstreambuf/underflow
std::strstreambuf::pbackfail =&gt; cpp/io/strstreambuf/pbackfail
std::strstreambuf::overflow =&gt; cpp/io/strstreambuf/overflow
std::strstreambuf::setbuf =&gt; cpp/io/strstreambuf/setbuf
std::strstreambuf::seekoff =&gt; cpp/io/strstreambuf/seekoff
std::strstreambuf::seekpos =&gt; cpp/io/strstreambuf/seekpos
std::istrstream =&gt; cpp/io/istrstream
std::istrstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::istrstream::get =&gt; cpp/io/basic_istream/get
std::istrstream::peek =&gt; cpp/io/basic_istream/peek
std::istrstream::unget =&gt; cpp/io/basic_istream/unget
std::istrstream::putback =&gt; cpp/io/basic_istream/putback
std::istrstream::getline =&gt; cpp/io/basic_istream/getline
std::istrstream::ignore =&gt; cpp/io/basic_istream/ignore
std::istrstream::read =&gt; cpp/io/basic_istream/read
std::istrstream::readsome =&gt; cpp/io/basic_istream/readsome
std::istrstream::gcount =&gt; cpp/io/basic_istream/gcount
std::istrstream::tellg =&gt; cpp/io/basic_istream/tellg
std::istrstream::seekg =&gt; cpp/io/basic_istream/seekg
std::istrstream::sync =&gt; cpp/io/basic_istream/sync
std::istrstream::sentry =&gt; cpp/io/basic_istream/sentry
std::istrstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::istrstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::istrstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::istrstream::good =&gt; cpp/io/basic_ios/good
std::istrstream::eof =&gt; cpp/io/basic_ios/eof
std::istrstream::fail =&gt; cpp/io/basic_ios/fail
std::istrstream::bad =&gt; cpp/io/basic_ios/bad
std::istrstream::operator! =&gt; cpp/io/basic_ios/operator!
std::istrstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::istrstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::istrstream::setstate =&gt; cpp/io/basic_ios/setstate
std::istrstream::clear =&gt; cpp/io/basic_ios/clear
std::istrstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::istrstream::fill =&gt; cpp/io/basic_ios/fill
std::istrstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::istrstream::imbue =&gt; cpp/io/basic_ios/imbue
std::istrstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::istrstream::tie =&gt; cpp/io/basic_ios/tie
std::istrstream::narrow =&gt; cpp/io/basic_ios/narrow
std::istrstream::widen =&gt; cpp/io/basic_ios/widen
std::istrstream::init =&gt; cpp/io/basic_ios/init
std::istrstream::move =&gt; cpp/io/basic_ios/move
std::istrstream::swap =&gt; cpp/io/basic_ios/swap
std::istrstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::istrstream::flags =&gt; cpp/io/ios_base/flags
std::istrstream::setf =&gt; cpp/io/ios_base/setf
std::istrstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::istrstream::precision =&gt; cpp/io/ios_base/precision
std::istrstream::width =&gt; cpp/io/ios_base/width
std::istrstream::imbue =&gt; cpp/io/ios_base/imbue
std::istrstream::getloc =&gt; cpp/io/ios_base/getloc
std::istrstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::istrstream::iword =&gt; cpp/io/ios_base/iword
std::istrstream::pword =&gt; cpp/io/ios_base/pword
std::istrstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::istrstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::istrstream::failure =&gt; cpp/io/ios_base/failure
std::istrstream::failure::what =&gt; cpp/error/exception/what
std::istrstream::failure::failure =&gt; cpp/io/ios_base/failure
std::istrstream::openmode =&gt; cpp/io/ios_base/openmode
std::istrstream::app =&gt; cpp/io/ios_base/openmode
std::istrstream::binary =&gt; cpp/io/ios_base/openmode
std::istrstream::in =&gt; cpp/io/ios_base/openmode
std::istrstream::out =&gt; cpp/io/ios_base/openmode
std::istrstream::trunc =&gt; cpp/io/ios_base/openmode
std::istrstream::ate =&gt; cpp/io/ios_base/openmode
std::istrstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::istrstream::dec =&gt; cpp/io/ios_base/fmtflags
std::istrstream::oct =&gt; cpp/io/ios_base/fmtflags
std::istrstream::hex =&gt; cpp/io/ios_base/fmtflags
std::istrstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::istrstream::left =&gt; cpp/io/ios_base/fmtflags
std::istrstream::right =&gt; cpp/io/ios_base/fmtflags
std::istrstream::internal =&gt; cpp/io/ios_base/fmtflags
std::istrstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::istrstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::istrstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::istrstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::istrstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::istrstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::istrstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::istrstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::istrstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::istrstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::istrstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::istrstream::iostate =&gt; cpp/io/ios_base/iostate
std::istrstream::goodbit =&gt; cpp/io/ios_base/iostate
std::istrstream::badbit =&gt; cpp/io/ios_base/iostate
std::istrstream::failbit =&gt; cpp/io/ios_base/iostate
std::istrstream::eofbit =&gt; cpp/io/ios_base/iostate
std::istrstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::istrstream::beg =&gt; cpp/io/ios_base/seekdir
std::istrstream::cur =&gt; cpp/io/ios_base/seekdir
std::istrstream::end =&gt; cpp/io/ios_base/seekdir
std::istrstream::event =&gt; cpp/io/ios_base/event
std::istrstream::erase_event =&gt; cpp/io/ios_base/event
std::istrstream::imbue_event =&gt; cpp/io/ios_base/event
std::istrstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::istrstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::istrstream::istrstream =&gt; cpp/io/istrstream/istrstream
std::istrstream::~istrstream =&gt; cpp/io/istrstream/~istrstream
std::istrstream::rdbuf =&gt; cpp/io/istrstream/rdbuf
std::istrstream::str =&gt; cpp/io/istrstream/str
std::ostrstream =&gt; cpp/io/ostrstream
std::ostrstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::ostrstream::put =&gt; cpp/io/basic_ostream/put
std::ostrstream::write =&gt; cpp/io/basic_ostream/write
std::ostrstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::ostrstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::ostrstream::flush =&gt; cpp/io/basic_ostream/flush
std::ostrstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostrstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::ostrstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::ostrstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::ostrstream::good =&gt; cpp/io/basic_ios/good
std::ostrstream::eof =&gt; cpp/io/basic_ios/eof
std::ostrstream::fail =&gt; cpp/io/basic_ios/fail
std::ostrstream::bad =&gt; cpp/io/basic_ios/bad
std::ostrstream::operator! =&gt; cpp/io/basic_ios/operator!
std::ostrstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::ostrstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::ostrstream::setstate =&gt; cpp/io/basic_ios/setstate
std::ostrstream::clear =&gt; cpp/io/basic_ios/clear
std::ostrstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::ostrstream::fill =&gt; cpp/io/basic_ios/fill
std::ostrstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::ostrstream::imbue =&gt; cpp/io/basic_ios/imbue
std::ostrstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::ostrstream::tie =&gt; cpp/io/basic_ios/tie
std::ostrstream::narrow =&gt; cpp/io/basic_ios/narrow
std::ostrstream::widen =&gt; cpp/io/basic_ios/widen
std::ostrstream::init =&gt; cpp/io/basic_ios/init
std::ostrstream::move =&gt; cpp/io/basic_ios/move
std::ostrstream::swap =&gt; cpp/io/basic_ios/swap
std::ostrstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::ostrstream::flags =&gt; cpp/io/ios_base/flags
std::ostrstream::setf =&gt; cpp/io/ios_base/setf
std::ostrstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::ostrstream::precision =&gt; cpp/io/ios_base/precision
std::ostrstream::width =&gt; cpp/io/ios_base/width
std::ostrstream::imbue =&gt; cpp/io/ios_base/imbue
std::ostrstream::getloc =&gt; cpp/io/ios_base/getloc
std::ostrstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::ostrstream::iword =&gt; cpp/io/ios_base/iword
std::ostrstream::pword =&gt; cpp/io/ios_base/pword
std::ostrstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::ostrstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::ostrstream::failure =&gt; cpp/io/ios_base/failure
std::ostrstream::failure::what =&gt; cpp/error/exception/what
std::ostrstream::failure::failure =&gt; cpp/io/ios_base/failure
std::ostrstream::openmode =&gt; cpp/io/ios_base/openmode
std::ostrstream::app =&gt; cpp/io/ios_base/openmode
std::ostrstream::binary =&gt; cpp/io/ios_base/openmode
std::ostrstream::in =&gt; cpp/io/ios_base/openmode
std::ostrstream::out =&gt; cpp/io/ios_base/openmode
std::ostrstream::trunc =&gt; cpp/io/ios_base/openmode
std::ostrstream::ate =&gt; cpp/io/ios_base/openmode
std::ostrstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::dec =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::oct =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::hex =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::left =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::right =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::internal =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ostrstream::iostate =&gt; cpp/io/ios_base/iostate
std::ostrstream::goodbit =&gt; cpp/io/ios_base/iostate
std::ostrstream::badbit =&gt; cpp/io/ios_base/iostate
std::ostrstream::failbit =&gt; cpp/io/ios_base/iostate
std::ostrstream::eofbit =&gt; cpp/io/ios_base/iostate
std::ostrstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::ostrstream::beg =&gt; cpp/io/ios_base/seekdir
std::ostrstream::cur =&gt; cpp/io/ios_base/seekdir
std::ostrstream::end =&gt; cpp/io/ios_base/seekdir
std::ostrstream::event =&gt; cpp/io/ios_base/event
std::ostrstream::erase_event =&gt; cpp/io/ios_base/event
std::ostrstream::imbue_event =&gt; cpp/io/ios_base/event
std::ostrstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::ostrstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::ostrstream::ostrstream =&gt; cpp/io/ostrstream/ostrstream
std::ostrstream::~ostrstream =&gt; cpp/io/ostrstream/~ostrstream
std::ostrstream::rdbuf =&gt; cpp/io/ostrstream/rdbuf
std::ostrstream::str =&gt; cpp/io/ostrstream/str
std::ostrstream::freeze =&gt; cpp/io/ostrstream/freeze
std::ostrstream::pcount =&gt; cpp/io/ostrstream/pcount
std::strstream =&gt; cpp/io/strstream
std::strstream::operator&gt;&gt; =&gt; cpp/io/basic_istream/operator_gtgt
std::strstream::get =&gt; cpp/io/basic_istream/get
std::strstream::peek =&gt; cpp/io/basic_istream/peek
std::strstream::unget =&gt; cpp/io/basic_istream/unget
std::strstream::putback =&gt; cpp/io/basic_istream/putback
std::strstream::getline =&gt; cpp/io/basic_istream/getline
std::strstream::ignore =&gt; cpp/io/basic_istream/ignore
std::strstream::read =&gt; cpp/io/basic_istream/read
std::strstream::readsome =&gt; cpp/io/basic_istream/readsome
std::strstream::gcount =&gt; cpp/io/basic_istream/gcount
std::strstream::tellg =&gt; cpp/io/basic_istream/tellg
std::strstream::seekg =&gt; cpp/io/basic_istream/seekg
std::strstream::sync =&gt; cpp/io/basic_istream/sync
std::strstream::sentry =&gt; cpp/io/basic_istream/sentry
std::strstream::sentry::sentry =&gt; cpp/io/basic_istream/sentry
std::strstream::sentry::~sentry =&gt; cpp/io/basic_istream/sentry
std::strstream::sentry::operator bool =&gt; cpp/io/basic_istream/sentry
std::strstream::operator&lt;&lt; =&gt; cpp/io/basic_ostream/operator_ltlt
std::strstream::put =&gt; cpp/io/basic_ostream/put
std::strstream::write =&gt; cpp/io/basic_ostream/write
std::strstream::tellp =&gt; cpp/io/basic_ostream/tellp
std::strstream::seekp =&gt; cpp/io/basic_ostream/seekp
std::strstream::flush =&gt; cpp/io/basic_ostream/flush
std::strstream::sentry =&gt; cpp/io/basic_ostream/sentry
std::strstream::sentry::sentry =&gt; cpp/io/basic_ostream/sentry
std::strstream::sentry::~sentry =&gt; cpp/io/basic_ostream/sentry
std::strstream::sentry::operator bool =&gt; cpp/io/basic_ostream/sentry
std::strstream::good =&gt; cpp/io/basic_ios/good
std::strstream::eof =&gt; cpp/io/basic_ios/eof
std::strstream::fail =&gt; cpp/io/basic_ios/fail
std::strstream::bad =&gt; cpp/io/basic_ios/bad
std::strstream::operator! =&gt; cpp/io/basic_ios/operator!
std::strstream::operator bool =&gt; cpp/io/basic_ios/operator_bool
std::strstream::rdstate =&gt; cpp/io/basic_ios/rdstate
std::strstream::setstate =&gt; cpp/io/basic_ios/setstate
std::strstream::clear =&gt; cpp/io/basic_ios/clear
std::strstream::copyfmt =&gt; cpp/io/basic_ios/copyfmt
std::strstream::fill =&gt; cpp/io/basic_ios/fill
std::strstream::exceptions =&gt; cpp/io/basic_ios/exceptions
std::strstream::imbue =&gt; cpp/io/basic_ios/imbue
std::strstream::rdbuf =&gt; cpp/io/basic_ios/rdbuf
std::strstream::tie =&gt; cpp/io/basic_ios/tie
std::strstream::narrow =&gt; cpp/io/basic_ios/narrow
std::strstream::widen =&gt; cpp/io/basic_ios/widen
std::strstream::init =&gt; cpp/io/basic_ios/init
std::strstream::move =&gt; cpp/io/basic_ios/move
std::strstream::swap =&gt; cpp/io/basic_ios/swap
std::strstream::set_rdbuf =&gt; cpp/io/basic_ios/set_rdbuf
std::strstream::flags =&gt; cpp/io/ios_base/flags
std::strstream::setf =&gt; cpp/io/ios_base/setf
std::strstream::unsetf =&gt; cpp/io/ios_base/unsetf
std::strstream::precision =&gt; cpp/io/ios_base/precision
std::strstream::width =&gt; cpp/io/ios_base/width
std::strstream::imbue =&gt; cpp/io/ios_base/imbue
std::strstream::getloc =&gt; cpp/io/ios_base/getloc
std::strstream::xalloc =&gt; cpp/io/ios_base/xalloc
std::strstream::iword =&gt; cpp/io/ios_base/iword
std::strstream::pword =&gt; cpp/io/ios_base/pword
std::strstream::register_callback =&gt; cpp/io/ios_base/register_callback
std::strstream::sync_with_stdio =&gt; cpp/io/ios_base/sync_with_stdio
std::strstream::failure =&gt; cpp/io/ios_base/failure
std::strstream::failure::what =&gt; cpp/error/exception/what
std::strstream::failure::failure =&gt; cpp/io/ios_base/failure
std::strstream::openmode =&gt; cpp/io/ios_base/openmode
std::strstream::app =&gt; cpp/io/ios_base/openmode
std::strstream::binary =&gt; cpp/io/ios_base/openmode
std::strstream::in =&gt; cpp/io/ios_base/openmode
std::strstream::out =&gt; cpp/io/ios_base/openmode
std::strstream::trunc =&gt; cpp/io/ios_base/openmode
std::strstream::ate =&gt; cpp/io/ios_base/openmode
std::strstream::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::strstream::dec =&gt; cpp/io/ios_base/fmtflags
std::strstream::oct =&gt; cpp/io/ios_base/fmtflags
std::strstream::hex =&gt; cpp/io/ios_base/fmtflags
std::strstream::basefield =&gt; cpp/io/ios_base/fmtflags
std::strstream::left =&gt; cpp/io/ios_base/fmtflags
std::strstream::right =&gt; cpp/io/ios_base/fmtflags
std::strstream::internal =&gt; cpp/io/ios_base/fmtflags
std::strstream::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::strstream::scientific =&gt; cpp/io/ios_base/fmtflags
std::strstream::fixed =&gt; cpp/io/ios_base/fmtflags
std::strstream::floatfield =&gt; cpp/io/ios_base/fmtflags
std::strstream::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::strstream::showbase =&gt; cpp/io/ios_base/fmtflags
std::strstream::showpoint =&gt; cpp/io/ios_base/fmtflags
std::strstream::showpos =&gt; cpp/io/ios_base/fmtflags
std::strstream::skipws =&gt; cpp/io/ios_base/fmtflags
std::strstream::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::strstream::uppercase =&gt; cpp/io/ios_base/fmtflags
std::strstream::iostate =&gt; cpp/io/ios_base/iostate
std::strstream::goodbit =&gt; cpp/io/ios_base/iostate
std::strstream::badbit =&gt; cpp/io/ios_base/iostate
std::strstream::failbit =&gt; cpp/io/ios_base/iostate
std::strstream::eofbit =&gt; cpp/io/ios_base/iostate
std::strstream::seekdir =&gt; cpp/io/ios_base/seekdir
std::strstream::beg =&gt; cpp/io/ios_base/seekdir
std::strstream::cur =&gt; cpp/io/ios_base/seekdir
std::strstream::end =&gt; cpp/io/ios_base/seekdir
std::strstream::event =&gt; cpp/io/ios_base/event
std::strstream::erase_event =&gt; cpp/io/ios_base/event
std::strstream::imbue_event =&gt; cpp/io/ios_base/event
std::strstream::copyfmt_event =&gt; cpp/io/ios_base/event
std::strstream::event_callback =&gt; cpp/io/ios_base/event_callback
std::strstream::strstream =&gt; cpp/io/strstream/strstream
std::strstream::~strstream =&gt; cpp/io/strstream/~strstream
std::strstream::rdbuf =&gt; cpp/io/strstream/rdbuf
std::strstream::str =&gt; cpp/io/strstream/str
std::strstream::freeze =&gt; cpp/io/strstream/freeze
std::strstream::pcount =&gt; cpp/io/strstream/pcount
std::cin =&gt; cpp/io/basic_istream
std::wcin =&gt; cpp/io/basic_istream
std::cout =&gt; cpp/io/basic_ostream
std::wcout =&gt; cpp/io/basic_ostream
std::cerr =&gt; cpp/io/basic_ostream
std::wcerr =&gt; cpp/io/basic_ostream
std::clog =&gt; cpp/io/basic_ostream
std::wclog =&gt; cpp/io/basic_ostream
std::boolalpha =&gt; cpp/io/manip/boolalpha
std::noboolalpha =&gt; cpp/io/manip/boolalpha
std::showbase =&gt; cpp/io/manip/showbase
std::noshowbase =&gt; cpp/io/manip/showbase
std::showpoint =&gt; cpp/io/manip/showpoint
std::noshowpoint =&gt; cpp/io/manip/showpoint
std::showpos =&gt; cpp/io/manip/showpos
std::noshowpos =&gt; cpp/io/manip/showpos
std::skipws =&gt; cpp/io/manip/skipws
std::noskipws =&gt; cpp/io/manip/skipws
std::uppercase =&gt; cpp/io/manip/uppercase
std::nouppercase =&gt; cpp/io/manip/uppercase
std::unitbuf =&gt; cpp/io/manip/unitbuf
std::nounitbuf =&gt; cpp/io/manip/unitbuf
std::internal =&gt; cpp/io/manip/left
std::left =&gt; cpp/io/manip/left
std::right =&gt; cpp/io/manip/left
std::dec =&gt; cpp/io/manip/hex
std::hex =&gt; cpp/io/manip/hex
std::oct =&gt; cpp/io/manip/hex
std::fixed =&gt; cpp/io/manip/fixed
std::scientific =&gt; cpp/io/manip/fixed
std::hexfloat =&gt; cpp/io/manip/fixed
std::defaultfloat =&gt; cpp/io/manip/fixed
std::ws =&gt; cpp/io/manip/ws
std::ends =&gt; cpp/io/manip/ends
std::flush =&gt; cpp/io/manip/flush
std::endl =&gt; cpp/io/manip/endl
std::resetiosflags =&gt; cpp/io/manip/resetiosflags
std::setiosflags =&gt; cpp/io/manip/setiosflags
std::setbase =&gt; cpp/io/manip/setbase
std::setfill =&gt; cpp/io/manip/setfill
std::setprecision =&gt; cpp/io/manip/setprecision
std::setw =&gt; cpp/io/manip/setw
std::get_money =&gt; cpp/io/manip/get_money
std::put_money =&gt; cpp/io/manip/put_money
std::get_time =&gt; cpp/io/manip/get_time
std::put_time =&gt; cpp/io/manip/put_time
std::streamoff =&gt; cpp/io/streamoff
std::streamsize =&gt; cpp/io/streamsize
std::fpos =&gt; cpp/io/fpos
std::fpos::state =&gt; cpp/io/fpos/state
std::streampos =&gt; cpp/io/fpos
std::streampos::state =&gt; cpp/io/fpos/state
std::u16streampos =&gt; cpp/io/fpos
std::u16streampos::state =&gt; cpp/io/fpos/state
std::u32streampos =&gt; cpp/io/fpos
std::u32streampos::state =&gt; cpp/io/fpos/state
std::wstreampos =&gt; cpp/io/fpos
std::wstreampos::state =&gt; cpp/io/fpos/state
std::io_errc =&gt; cpp/io/io_errc
std::io_errc::stream =&gt; cpp/io/io_errc
std::is_error_code_enum&lt;std::io_errc&gt; =&gt; cpp/io/io_errc/is_error_code_enum
std::make_error_code(std::io_errc) =&gt; cpp/io/io_errc/make_error_code
std::make_error_condition(std::io_errc) =&gt; cpp/io/io_errc/make_error_condition
std::fopen =&gt; cpp/io/c/fopen
std::freopen =&gt; cpp/io/c/freopen
std::fflush =&gt; cpp/io/c/fflush
std::fclose =&gt; cpp/io/c/fclose
std::setbuf =&gt; cpp/io/c/setbuf
std::setvbuf =&gt; cpp/io/c/setvbuf
std::fread =&gt; cpp/io/c/fread
std::fwrite =&gt; cpp/io/c/fwrite
std::fgetc =&gt; cpp/io/c/fgetc
std::getc =&gt; cpp/io/c/fgetc
std::fgets =&gt; cpp/io/c/fgets
std::fputc =&gt; cpp/io/c/fputc
std::putc =&gt; cpp/io/c/fputc
std::fputs =&gt; cpp/io/c/fputs
std::getchar =&gt; cpp/io/c/getchar
std::gets =&gt; cpp/io/c/gets
std::putchar =&gt; cpp/io/c/putchar
std::puts =&gt; cpp/io/c/puts
std::ungetc =&gt; cpp/io/c/ungetc
std::fgetwc =&gt; cpp/io/c/fgetwc
std::fgetws =&gt; cpp/io/c/fgetws
std::fputwc =&gt; cpp/io/c/fputwc
std::fputws =&gt; cpp/io/c/fputws
std::getwchar =&gt; cpp/io/c/getwchar
std::putwchar =&gt; cpp/io/c/putwchar
std::ungetwc =&gt; cpp/io/c/ungetwc
std::scanf =&gt; cpp/io/c/fscanf
std::fscanf =&gt; cpp/io/c/fscanf
std::sscanf =&gt; cpp/io/c/fscanf
std::vscanf =&gt; cpp/io/c/vfscanf
std::vfscanf =&gt; cpp/io/c/vfscanf
std::vsscanf =&gt; cpp/io/c/vfscanf
std::printf =&gt; cpp/io/c/fprintf
std::fprintf =&gt; cpp/io/c/fprintf
std::sprintf =&gt; cpp/io/c/fprintf
std::snprintf =&gt; cpp/io/c/fprintf
std::vprintf =&gt; cpp/io/c/vfprintf
std::vfprintf =&gt; cpp/io/c/vfprintf
std::vsprintf =&gt; cpp/io/c/vfprintf
std::vsnprintf =&gt; cpp/io/c/vfprintf
std::wscanf =&gt; cpp/io/c/fwscanf
std::fwscanf =&gt; cpp/io/c/fwscanf
std::swscanf =&gt; cpp/io/c/fwscanf
std::vwscanf =&gt; cpp/io/c/vfwscanf
std::vfwscanf =&gt; cpp/io/c/vfwscanf
std::vswscanf =&gt; cpp/io/c/vfwscanf
std::wprintf =&gt; cpp/io/c/fwprintf
std::fwprintf =&gt; cpp/io/c/fwprintf
std::swprintf =&gt; cpp/io/c/fwprintf
std::vwprintf =&gt; cpp/io/c/vfwprintf
std::vfwprintf =&gt; cpp/io/c/vfwprintf
std::vswprintf =&gt; cpp/io/c/vfwprintf
std::ftell =&gt; cpp/io/c/ftell
std::fgetpos =&gt; cpp/io/c/fgetpos
std::fseek =&gt; cpp/io/c/fseek
std::fsetpos =&gt; cpp/io/c/fsetpos
std::rewind =&gt; cpp/io/c/rewind
std::clearerr =&gt; cpp/io/c/clearerr
std::feof =&gt; cpp/io/c/feof
std::ferror =&gt; cpp/io/c/ferror
std::perror =&gt; cpp/io/c/perror
std::remove =&gt; cpp/io/c/remove
std::rename =&gt; cpp/io/c/rename
std::tmpfile =&gt; cpp/io/c/tmpfile
std::tmpnam =&gt; cpp/io/c/tmpnam
std::FILE =&gt; cpp/io/c
std::fpos_t =&gt; cpp/io/c
stdin =&gt; cpp/io/c
stdout =&gt; cpp/io/c
stderr =&gt; cpp/io/c
EOF =&gt; cpp/io/c
FOPEN_MAX =&gt; cpp/io/c
FILENAME_MAX =&gt; cpp/io/c
BUFSIZ =&gt; cpp/io/c
_IOFBF =&gt; cpp/io/c
_IOLBF =&gt; cpp/io/c
_IONBF =&gt; cpp/io/c
SEEK_SET =&gt; cpp/io/c
SEEK_CUR =&gt; cpp/io/c
SEEK_END =&gt; cpp/io/c
TMP_MAX =&gt; cpp/io/c
L_tmpnam =&gt; cpp/io/c
std::locale =&gt; cpp/locale/locale
std::locale::locale =&gt; cpp/locale/locale/locale
std::locale::~locale =&gt; cpp/locale/locale/~locale
std::locale::operator= =&gt; cpp/locale/locale/operator=
std::locale::combine =&gt; cpp/locale/locale/combine
std::locale::name =&gt; cpp/locale/locale/name
std::locale::operator== =&gt; cpp/locale/locale/operator_cmp
std::locale::operator!= =&gt; cpp/locale/locale/operator_cmp
std::locale::operator() =&gt; cpp/locale/locale/operator()
std::locale::global =&gt; cpp/locale/locale/global
std::locale::classic =&gt; cpp/locale/locale/classic
std::locale::id =&gt; cpp/locale/locale/id
std::locale::id::id =&gt; cpp/locale/locale/id/id
std::locale::facet =&gt; cpp/locale/locale/facet
std::locale::facet::facet =&gt; cpp/locale/locale/facet/facet
std::use_facet =&gt; cpp/locale/use_facet
std::has_facet =&gt; cpp/locale/has_facet
std::wstring_convert =&gt; cpp/locale/wstring_convert
std::wstring_convert::wstring_convert =&gt; cpp/locale/wstring_convert/wstring_convert
std::wstring_convert::~wstring_convert =&gt; cpp/locale/wstring_convert/~wstring_convert
std::wstring_convert::from_bytes =&gt; cpp/locale/wstring_convert/from_bytes
std::wstring_convert::to_bytes =&gt; cpp/locale/wstring_convert/to_bytes
std::wstring_convert::converted =&gt; cpp/locale/wstring_convert/converted
std::wstring_convert::state =&gt; cpp/locale/wstring_convert/state
std::wbuffer_convert =&gt; cpp/locale/wbuffer_convert
std::wbuffer_convert::wbuffer_convert =&gt; cpp/locale/wbuffer_convert/wbuffer_convert
std::wbuffer_convert::~wbuffer_convert =&gt; cpp/locale/wbuffer_convert/~wbuffer_convert
std::wbuffer_convert::rdbuf =&gt; cpp/locale/wbuffer_convert/rdbuf
std::wbuffer_convert::state =&gt; cpp/locale/wbuffer_convert/state
std::ctype_base =&gt; cpp/locale/ctype_base
std::ctype_base::mask =&gt; cpp/locale/ctype_base
std::ctype_base::space =&gt; cpp/locale/ctype_base
std::ctype_base::print =&gt; cpp/locale/ctype_base
std::ctype_base::cntrl =&gt; cpp/locale/ctype_base
std::ctype_base::upper =&gt; cpp/locale/ctype_base
std::ctype_base::lower =&gt; cpp/locale/ctype_base
std::ctype_base::alpha =&gt; cpp/locale/ctype_base
std::ctype_base::digit =&gt; cpp/locale/ctype_base
std::ctype_base::punct =&gt; cpp/locale/ctype_base
std::ctype_base::xdigit =&gt; cpp/locale/ctype_base
std::ctype_base::blank =&gt; cpp/locale/ctype_base
std::ctype_base::alnum =&gt; cpp/locale/ctype_base
std::ctype_base::graph =&gt; cpp/locale/ctype_base
std::codecvt_base =&gt; cpp/locale/codecvt_base
std::codecvt_base::result =&gt; cpp/locale/codecvt_base
std::codecvt_base::ok =&gt; cpp/locale/codecvt_base
std::codecvt_base::partial =&gt; cpp/locale/codecvt_base
std::codecvt_base::error =&gt; cpp/locale/codecvt_base
std::codecvt_base::noconv =&gt; cpp/locale/codecvt_base
std::messages_base =&gt; cpp/locale/messages_base
std::messages_base::catalog =&gt; cpp/locale/messages_base
std::time_base =&gt; cpp/locale/time_base
std::time_base::dateorder =&gt; cpp/locale/time_base
std::time_base::no_order =&gt; cpp/locale/time_base
std::time_base::dmy =&gt; cpp/locale/time_base
std::time_base::mdy =&gt; cpp/locale/time_base
std::time_base::ymd =&gt; cpp/locale/time_base
std::time_base::ydm =&gt; cpp/locale/time_base
std::money_base =&gt; cpp/locale/money_base
std::money_base::part =&gt; cpp/locale/money_base
std::money_base::none =&gt; cpp/locale/money_base
std::money_base::space =&gt; cpp/locale/money_base
std::money_base::symbol =&gt; cpp/locale/money_base
std::money_base::sign =&gt; cpp/locale/money_base
std::money_base::value =&gt; cpp/locale/money_base
std::money_base::pattern =&gt; cpp/locale/money_base
std::ctype =&gt; cpp/locale/ctype
std::ctype::mask =&gt; cpp/locale/ctype_base
std::ctype::space =&gt; cpp/locale/ctype_base
std::ctype::print =&gt; cpp/locale/ctype_base
std::ctype::cntrl =&gt; cpp/locale/ctype_base
std::ctype::upper =&gt; cpp/locale/ctype_base
std::ctype::lower =&gt; cpp/locale/ctype_base
std::ctype::alpha =&gt; cpp/locale/ctype_base
std::ctype::digit =&gt; cpp/locale/ctype_base
std::ctype::punct =&gt; cpp/locale/ctype_base
std::ctype::xdigit =&gt; cpp/locale/ctype_base
std::ctype::blank =&gt; cpp/locale/ctype_base
std::ctype::alnum =&gt; cpp/locale/ctype_base
std::ctype::graph =&gt; cpp/locale/ctype_base
std::ctype::ctype =&gt; cpp/locale/ctype/ctype
std::ctype::~ctype =&gt; cpp/locale/ctype/~ctype
std::ctype::is =&gt; cpp/locale/ctype/is
std::ctype::scan_is =&gt; cpp/locale/ctype/scan_is
std::ctype::toupper =&gt; cpp/locale/ctype/toupper
std::ctype::tolower =&gt; cpp/locale/ctype/tolower
std::ctype::widen =&gt; cpp/locale/ctype/widen
std::ctype::narrow =&gt; cpp/locale/ctype/narrow
std::ctype::do_is =&gt; cpp/locale/ctype/is
std::ctype::do_scan_is =&gt; cpp/locale/ctype/scan_is
std::ctype::do_toupper =&gt; cpp/locale/ctype/toupper
std::ctype::do_tolower =&gt; cpp/locale/ctype/tolower
std::ctype::do_widen =&gt; cpp/locale/ctype/widen
std::ctype::do_narrow =&gt; cpp/locale/ctype/narrow
std::codecvt =&gt; cpp/locale/codecvt
std::codecvt::result =&gt; cpp/locale/codecvt_base
std::codecvt::ok =&gt; cpp/locale/codecvt_base
std::codecvt::partial =&gt; cpp/locale/codecvt_base
std::codecvt::error =&gt; cpp/locale/codecvt_base
std::codecvt::noconv =&gt; cpp/locale/codecvt_base
std::codecvt::intern_type =&gt; cpp/locale/codecvt
std::codecvt::extern_type =&gt; cpp/locale/codecvt
std::codecvt::state_type =&gt; cpp/locale/codecvt
std::codecvt::codecvt =&gt; cpp/locale/codecvt/codecvt
std::codecvt::~codecvt =&gt; cpp/locale/codecvt/~codecvt
std::codecvt::out =&gt; cpp/locale/codecvt/out
std::codecvt::in =&gt; cpp/locale/codecvt/in
std::codecvt::unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt::encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt::always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt::length =&gt; cpp/locale/codecvt/length
std::codecvt::max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt::do_out =&gt; cpp/locale/codecvt/out
std::codecvt::do_in =&gt; cpp/locale/codecvt/in
std::codecvt::do_unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt::do_encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt::do_always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt::do_length =&gt; cpp/locale/codecvt/length
std::codecvt::do_max_length =&gt; cpp/locale/codecvt/max_length
std::collate =&gt; cpp/locale/collate
std::collate::char_type =&gt; cpp/locale/collate
std::collate::string_type =&gt; cpp/locale/collate
std::collate::collate =&gt; cpp/locale/collate/collate
std::collate::~collate =&gt; cpp/locale/collate/~collate
std::collate::compare =&gt; cpp/locale/collate/compare
std::collate::transform =&gt; cpp/locale/collate/transform
std::collate::hash =&gt; cpp/locale/collate/hash
std::collate::do_compare =&gt; cpp/locale/collate/compare
std::collate::do_transform =&gt; cpp/locale/collate/transform
std::collate::do_hash =&gt; cpp/locale/collate/hash
std::messages =&gt; cpp/locale/messages
std::messages::catalog =&gt; cpp/locale/messages_base
std::messages::char_type =&gt; cpp/locale/messages
std::messages::string_type =&gt; cpp/locale/messages
std::messages::messages =&gt; cpp/locale/messages/messages
std::messages::~messages =&gt; cpp/locale/messages/~messages
std::messages::open =&gt; cpp/locale/messages/open
std::messages::get =&gt; cpp/locale/messages/get
std::messages::close =&gt; cpp/locale/messages/close
std::messages::do_open =&gt; cpp/locale/messages/open
std::messages::do_get =&gt; cpp/locale/messages/get
std::messages::do_close =&gt; cpp/locale/messages/close
std::time_get =&gt; cpp/locale/time_get
std::time_get::dateorder =&gt; cpp/locale/time_base
std::time_get::no_order =&gt; cpp/locale/time_base
std::time_get::dmy =&gt; cpp/locale/time_base
std::time_get::mdy =&gt; cpp/locale/time_base
std::time_get::ymd =&gt; cpp/locale/time_base
std::time_get::ydm =&gt; cpp/locale/time_base
std::time_get::char_type =&gt; cpp/locale/time_get
std::time_get::iter_type =&gt; cpp/locale/time_get
std::time_get::time_get =&gt; cpp/locale/time_get/time_get
std::time_get::~time_get =&gt; cpp/locale/time_get/~time_get
std::time_get::date_order =&gt; cpp/locale/time_get/date_order
std::time_get::get_time =&gt; cpp/locale/time_get/get_time
std::time_get::get_date =&gt; cpp/locale/time_get/get_date
std::time_get::get_weekday =&gt; cpp/locale/time_get/get_weekday
std::time_get::get_monthname =&gt; cpp/locale/time_get/get_monthname
std::time_get::get_year =&gt; cpp/locale/time_get/get_year
std::time_get::get =&gt; cpp/locale/time_get/get
std::time_get::do_date_order =&gt; cpp/locale/time_get/date_order
std::time_get::do_get_time =&gt; cpp/locale/time_get/get_time
std::time_get::do_get_date =&gt; cpp/locale/time_get/get_date
std::time_get::do_get_weekday =&gt; cpp/locale/time_get/get_weekday
std::time_get::do_get_monthname =&gt; cpp/locale/time_get/get_monthname
std::time_get::do_get_year =&gt; cpp/locale/time_get/get_year
std::time_get::do_get =&gt; cpp/locale/time_get/get
std::time_put =&gt; cpp/locale/time_put
std::time_put::dateorder =&gt; cpp/locale/time_base
std::time_put::no_order =&gt; cpp/locale/time_base
std::time_put::dmy =&gt; cpp/locale/time_base
std::time_put::mdy =&gt; cpp/locale/time_base
std::time_put::ymd =&gt; cpp/locale/time_base
std::time_put::ydm =&gt; cpp/locale/time_base
std::time_put::char_type =&gt; cpp/locale/time_put
std::time_put::iter_type =&gt; cpp/locale/time_put
std::time_put::time_put =&gt; cpp/locale/time_put/time_put
std::time_put::~time_put =&gt; cpp/locale/time_put/~time_put
std::time_put::put =&gt; cpp/locale/time_put/put
std::time_put::do_put =&gt; cpp/locale/time_put/put
std::num_get =&gt; cpp/locale/num_get
std::num_get::char_type =&gt; cpp/locale/num_get
std::num_get::iter_type =&gt; cpp/locale/num_get
std::num_get::num_get =&gt; cpp/locale/num_get/num_get
std::num_get::~num_get =&gt; cpp/locale/num_get/~num_get
std::num_get::get =&gt; cpp/locale/num_get/get
std::num_get::do_get =&gt; cpp/locale/num_get/get
std::num_put =&gt; cpp/locale/num_put
std::num_put::char_type =&gt; cpp/locale/num_put
std::num_put::iter_type =&gt; cpp/locale/num_put
std::num_put::num_put =&gt; cpp/locale/num_put/num_put
std::num_put::~num_put =&gt; cpp/locale/num_put/~num_put
std::num_put::put =&gt; cpp/locale/num_put/put
std::num_put::do_put =&gt; cpp/locale/num_put/put
std::numpunct =&gt; cpp/locale/numpunct
std::numpunct::char_type =&gt; cpp/locale/numpunct
std::numpunct::string_type =&gt; cpp/locale/numpunct
std::numpunct::numpunct =&gt; cpp/locale/numpunct/numpunct
std::numpunct::~numpunct =&gt; cpp/locale/numpunct/~numpunct
std::numpunct::decimal_point =&gt; cpp/locale/numpunct/decimal_point
std::numpunct::thousands_sep =&gt; cpp/locale/numpunct/thousands_sep
std::numpunct::grouping =&gt; cpp/locale/numpunct/grouping
std::numpunct::truename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct::falsename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct::do_decimal_point =&gt; cpp/locale/numpunct/decimal_point
std::numpunct::do_thousands_sep =&gt; cpp/locale/numpunct/thousands_sep
std::numpunct::do_grouping =&gt; cpp/locale/numpunct/grouping
std::numpunct::do_truename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct::do_falsename =&gt; cpp/locale/numpunct/truefalsename
std::money_get =&gt; cpp/locale/money_get
std::money_get::part =&gt; cpp/locale/money_base
std::money_get::none =&gt; cpp/locale/money_base
std::money_get::space =&gt; cpp/locale/money_base
std::money_get::symbol =&gt; cpp/locale/money_base
std::money_get::sign =&gt; cpp/locale/money_base
std::money_get::value =&gt; cpp/locale/money_base
std::money_get::pattern =&gt; cpp/locale/money_base
std::money_get::char_type =&gt; cpp/locale/money_get
std::money_get::iter_type =&gt; cpp/locale/money_get
std::money_get::string_type =&gt; cpp/locale/money_get
std::money_get::money_get =&gt; cpp/locale/money_get/money_get
std::money_get::~money_get =&gt; cpp/locale/money_get/~money_get
std::money_get::get =&gt; cpp/locale/money_get/get
std::money_get::do_get =&gt; cpp/locale/money_get/get
std::money_put =&gt; cpp/locale/money_put
std::money_put::part =&gt; cpp/locale/money_base
std::money_put::none =&gt; cpp/locale/money_base
std::money_put::space =&gt; cpp/locale/money_base
std::money_put::symbol =&gt; cpp/locale/money_base
std::money_put::sign =&gt; cpp/locale/money_base
std::money_put::value =&gt; cpp/locale/money_base
std::money_put::pattern =&gt; cpp/locale/money_base
std::money_put::char_type =&gt; cpp/locale/money_put
std::money_put::iter_type =&gt; cpp/locale/money_put
std::money_put::string_type =&gt; cpp/locale/money_put
std::money_put::money_put =&gt; cpp/locale/money_put/money_put
std::money_put::~money_put =&gt; cpp/locale/money_put/~money_put
std::money_put::put =&gt; cpp/locale/money_put/put
std::money_put::do_put =&gt; cpp/locale/money_put/put
std::moneypunct =&gt; cpp/locale/moneypunct
std::moneypunct::char_type =&gt; cpp/locale/moneypunct
std::moneypunct::string_type =&gt; cpp/locale/moneypunct
std::moneypunct::part =&gt; cpp/locale/money_base
std::moneypunct::none =&gt; cpp/locale/money_base
std::moneypunct::space =&gt; cpp/locale/money_base
std::moneypunct::symbol =&gt; cpp/locale/money_base
std::moneypunct::sign =&gt; cpp/locale/money_base
std::moneypunct::value =&gt; cpp/locale/money_base
std::moneypunct::pattern =&gt; cpp/locale/money_base
std::moneypunct::moneypunct =&gt; cpp/locale/moneypunct/moneypunct
std::moneypunct::~moneypunct =&gt; cpp/locale/moneypunct/~moneypunct
std::moneypunct::decimal_point =&gt; cpp/locale/moneypunct/decimal_point
std::moneypunct::thousands_sep =&gt; cpp/locale/moneypunct/thousands_sep
std::moneypunct::grouping =&gt; cpp/locale/moneypunct/grouping
std::moneypunct::curr_symbol =&gt; cpp/locale/moneypunct/curr_symbol
std::moneypunct::positive_sign =&gt; cpp/locale/moneypunct/positive_sign
std::moneypunct::negative_sign =&gt; cpp/locale/moneypunct/negative_sign
std::moneypunct::frac_digits =&gt; cpp/locale/moneypunct/frac_digits
std::moneypunct::pos_format =&gt; cpp/locale/moneypunct/pos_format
std::moneypunct::neg_format =&gt; cpp/locale/moneypunct/neg_format
std::moneypunct::do_decimal_point =&gt; cpp/locale/moneypunct/decimal_point
std::moneypunct::do_thousands_sep =&gt; cpp/locale/moneypunct/thousands_sep
std::moneypunct::do_grouping =&gt; cpp/locale/moneypunct/grouping
std::moneypunct::do_curr_symbol =&gt; cpp/locale/moneypunct/curr_symbol
std::moneypunct::do_positive_sign =&gt; cpp/locale/moneypunct/positive_sign
std::moneypunct::do_negative_sign =&gt; cpp/locale/moneypunct/negative_sign
std::moneypunct::do_frac_digits =&gt; cpp/locale/moneypunct/frac_digits
std::moneypunct::do_pos_format =&gt; cpp/locale/moneypunct/pos_format
std::moneypunct::do_neg_format =&gt; cpp/locale/moneypunct/neg_format
std::ctype_byname =&gt; cpp/locale/ctype_byname
std::ctype_byname::is =&gt; cpp/locale/ctype/is
std::ctype_byname::scan_is =&gt; cpp/locale/ctype/scan_is
std::ctype_byname::toupper =&gt; cpp/locale/ctype/toupper
std::ctype_byname::tolower =&gt; cpp/locale/ctype/tolower
std::ctype_byname::widen =&gt; cpp/locale/ctype/widen
std::ctype_byname::narrow =&gt; cpp/locale/ctype/narrow
std::ctype_byname::do_is =&gt; cpp/locale/ctype/is
std::ctype_byname::do_scan_is =&gt; cpp/locale/ctype/scan_is
std::ctype_byname::do_toupper =&gt; cpp/locale/ctype/toupper
std::ctype_byname::do_tolower =&gt; cpp/locale/ctype/tolower
std::ctype_byname::do_widen =&gt; cpp/locale/ctype/widen
std::ctype_byname::do_narrow =&gt; cpp/locale/ctype/narrow
std::ctype_byname::mask =&gt; cpp/locale/ctype_base
std::ctype_byname::space =&gt; cpp/locale/ctype_base
std::ctype_byname::print =&gt; cpp/locale/ctype_base
std::ctype_byname::cntrl =&gt; cpp/locale/ctype_base
std::ctype_byname::upper =&gt; cpp/locale/ctype_base
std::ctype_byname::lower =&gt; cpp/locale/ctype_base
std::ctype_byname::alpha =&gt; cpp/locale/ctype_base
std::ctype_byname::digit =&gt; cpp/locale/ctype_base
std::ctype_byname::punct =&gt; cpp/locale/ctype_base
std::ctype_byname::xdigit =&gt; cpp/locale/ctype_base
std::ctype_byname::blank =&gt; cpp/locale/ctype_base
std::ctype_byname::alnum =&gt; cpp/locale/ctype_base
std::ctype_byname::graph =&gt; cpp/locale/ctype_base
std::ctype_byname::ctype_byname =&gt; cpp/locale/ctype_byname/ctype_byname
std::ctype_byname::~ctype_byname =&gt; cpp/locale/ctype_byname/~ctype_byname
std::codecvt_byname =&gt; cpp/locale/codecvt_byname
std::codecvt_byname::intern_type =&gt; cpp/locale/codecvt
std::codecvt_byname::extern_type =&gt; cpp/locale/codecvt
std::codecvt_byname::state_type =&gt; cpp/locale/codecvt
std::codecvt_byname::out =&gt; cpp/locale/codecvt/out
std::codecvt_byname::in =&gt; cpp/locale/codecvt/in
std::codecvt_byname::unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_byname::encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_byname::always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_byname::length =&gt; cpp/locale/codecvt/length
std::codecvt_byname::max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_byname::do_out =&gt; cpp/locale/codecvt/out
std::codecvt_byname::do_in =&gt; cpp/locale/codecvt/in
std::codecvt_byname::do_unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_byname::do_encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_byname::do_always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_byname::do_length =&gt; cpp/locale/codecvt/length
std::codecvt_byname::do_max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_byname::result =&gt; cpp/locale/codecvt_base
std::codecvt_byname::ok =&gt; cpp/locale/codecvt_base
std::codecvt_byname::partial =&gt; cpp/locale/codecvt_base
std::codecvt_byname::error =&gt; cpp/locale/codecvt_base
std::codecvt_byname::noconv =&gt; cpp/locale/codecvt_base
std::codecvt_byname::codecvt_byname =&gt; cpp/locale/codecvt_byname/codecvt_byname
std::codecvt_byname::~codecvt_byname =&gt; cpp/locale/codecvt_byname/~codecvt_byname
std::messages_byname =&gt; cpp/locale/messages_byname
std::messages_byname::char_type =&gt; cpp/locale/messages
std::messages_byname::string_type =&gt; cpp/locale/messages
std::messages_byname::open =&gt; cpp/locale/messages/open
std::messages_byname::get =&gt; cpp/locale/messages/get
std::messages_byname::close =&gt; cpp/locale/messages/close
std::messages_byname::do_open =&gt; cpp/locale/messages/open
std::messages_byname::do_get =&gt; cpp/locale/messages/get
std::messages_byname::do_close =&gt; cpp/locale/messages/close
std::messages_byname::catalog =&gt; cpp/locale/messages_base
std::messages_byname::messages_byname =&gt; cpp/locale/messages_byname/messages_byname
std::messages_byname::~messages_byname =&gt; cpp/locale/messages_byname/~messages_byname
std::collate_byname =&gt; cpp/locale/collate_byname
std::collate_byname::char_type =&gt; cpp/locale/collate
std::collate_byname::string_type =&gt; cpp/locale/collate
std::collate_byname::compare =&gt; cpp/locale/collate/compare
std::collate_byname::transform =&gt; cpp/locale/collate/transform
std::collate_byname::hash =&gt; cpp/locale/collate/hash
std::collate_byname::do_compare =&gt; cpp/locale/collate/compare
std::collate_byname::do_transform =&gt; cpp/locale/collate/transform
std::collate_byname::do_hash =&gt; cpp/locale/collate/hash
std::collate_byname::collate_byname =&gt; cpp/locale/collate_byname/collate_byname
std::collate_byname::~collate_byname =&gt; cpp/locale/collate_byname/~collate_byname
std::time_get_byname =&gt; cpp/locale/time_get_byname
std::time_get_byname::char_type =&gt; cpp/locale/time_get
std::time_get_byname::iter_type =&gt; cpp/locale/time_get
std::time_get_byname::date_order =&gt; cpp/locale/time_get/date_order
std::time_get_byname::get_time =&gt; cpp/locale/time_get/get_time
std::time_get_byname::get_date =&gt; cpp/locale/time_get/get_date
std::time_get_byname::get_weekday =&gt; cpp/locale/time_get/get_weekday
std::time_get_byname::get_monthname =&gt; cpp/locale/time_get/get_monthname
std::time_get_byname::get_year =&gt; cpp/locale/time_get/get_year
std::time_get_byname::get =&gt; cpp/locale/time_get/get
std::time_get_byname::do_date_order =&gt; cpp/locale/time_get/date_order
std::time_get_byname::do_get_time =&gt; cpp/locale/time_get/get_time
std::time_get_byname::do_get_date =&gt; cpp/locale/time_get/get_date
std::time_get_byname::do_get_weekday =&gt; cpp/locale/time_get/get_weekday
std::time_get_byname::do_get_monthname =&gt; cpp/locale/time_get/get_monthname
std::time_get_byname::do_get_year =&gt; cpp/locale/time_get/get_year
std::time_get_byname::do_get =&gt; cpp/locale/time_get/get
std::time_get_byname::dateorder =&gt; cpp/locale/time_base
std::time_get_byname::no_order =&gt; cpp/locale/time_base
std::time_get_byname::dmy =&gt; cpp/locale/time_base
std::time_get_byname::mdy =&gt; cpp/locale/time_base
std::time_get_byname::ymd =&gt; cpp/locale/time_base
std::time_get_byname::ydm =&gt; cpp/locale/time_base
std::time_get_byname::time_get_byname =&gt; cpp/locale/time_get_byname/time_get_byname
std::time_get_byname::~time_get_byname =&gt; cpp/locale/time_get_byname/~time_get_byname
std::time_put_byname =&gt; cpp/locale/time_put_byname
std::time_put_byname::char_type =&gt; cpp/locale/time_put
std::time_put_byname::iter_type =&gt; cpp/locale/time_put
std::time_put_byname::put =&gt; cpp/locale/time_put/put
std::time_put_byname::do_put =&gt; cpp/locale/time_put/put
std::time_put_byname::dateorder =&gt; cpp/locale/time_base
std::time_put_byname::no_order =&gt; cpp/locale/time_base
std::time_put_byname::dmy =&gt; cpp/locale/time_base
std::time_put_byname::mdy =&gt; cpp/locale/time_base
std::time_put_byname::ymd =&gt; cpp/locale/time_base
std::time_put_byname::ydm =&gt; cpp/locale/time_base
std::time_put_byname::time_put_byname =&gt; cpp/locale/time_put_byname/time_put_byname
std::time_put_byname::~time_put_byname =&gt; cpp/locale/time_put_byname/~time_put_byname
std::numpunct_byname =&gt; cpp/locale/numpunct_byname
std::numpunct_byname::char_type =&gt; cpp/locale/numpunct
std::numpunct_byname::string_type =&gt; cpp/locale/numpunct
std::numpunct_byname::decimal_point =&gt; cpp/locale/numpunct/decimal_point
std::numpunct_byname::thousands_sep =&gt; cpp/locale/numpunct/thousands_sep
std::numpunct_byname::grouping =&gt; cpp/locale/numpunct/grouping
std::numpunct_byname::truename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct_byname::falsename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct_byname::do_decimal_point =&gt; cpp/locale/numpunct/decimal_point
std::numpunct_byname::do_thousands_sep =&gt; cpp/locale/numpunct/thousands_sep
std::numpunct_byname::do_grouping =&gt; cpp/locale/numpunct/grouping
std::numpunct_byname::do_truename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct_byname::do_falsename =&gt; cpp/locale/numpunct/truefalsename
std::numpunct_byname::numpunct_byname =&gt; cpp/locale/numpunct_byname/numpunct_byname
std::numpunct_byname::~numpunct_byname =&gt; cpp/locale/numpunct_byname/~numpunct_byname
std::moneypunct_byname =&gt; cpp/locale/moneypunct_byname
std::moneypunct_byname::char_type =&gt; cpp/locale/moneypunct
std::moneypunct_byname::string_type =&gt; cpp/locale/moneypunct
std::moneypunct_byname::decimal_point =&gt; cpp/locale/moneypunct/decimal_point
std::moneypunct_byname::thousands_sep =&gt; cpp/locale/moneypunct/thousands_sep
std::moneypunct_byname::grouping =&gt; cpp/locale/moneypunct/grouping
std::moneypunct_byname::curr_symbol =&gt; cpp/locale/moneypunct/curr_symbol
std::moneypunct_byname::positive_sign =&gt; cpp/locale/moneypunct/positive_sign
std::moneypunct_byname::negative_sign =&gt; cpp/locale/moneypunct/negative_sign
std::moneypunct_byname::frac_digits =&gt; cpp/locale/moneypunct/frac_digits
std::moneypunct_byname::pos_format =&gt; cpp/locale/moneypunct/pos_format
std::moneypunct_byname::neg_format =&gt; cpp/locale/moneypunct/neg_format
std::moneypunct_byname::do_decimal_point =&gt; cpp/locale/moneypunct/decimal_point
std::moneypunct_byname::do_thousands_sep =&gt; cpp/locale/moneypunct/thousands_sep
std::moneypunct_byname::do_grouping =&gt; cpp/locale/moneypunct/grouping
std::moneypunct_byname::do_curr_symbol =&gt; cpp/locale/moneypunct/curr_symbol
std::moneypunct_byname::do_positive_sign =&gt; cpp/locale/moneypunct/positive_sign
std::moneypunct_byname::do_negative_sign =&gt; cpp/locale/moneypunct/negative_sign
std::moneypunct_byname::do_frac_digits =&gt; cpp/locale/moneypunct/frac_digits
std::moneypunct_byname::do_pos_format =&gt; cpp/locale/moneypunct/pos_format
std::moneypunct_byname::do_neg_format =&gt; cpp/locale/moneypunct/neg_format
std::moneypunct_byname::part =&gt; cpp/locale/money_base
std::moneypunct_byname::none =&gt; cpp/locale/money_base
std::moneypunct_byname::space =&gt; cpp/locale/money_base
std::moneypunct_byname::symbol =&gt; cpp/locale/money_base
std::moneypunct_byname::sign =&gt; cpp/locale/money_base
std::moneypunct_byname::value =&gt; cpp/locale/money_base
std::moneypunct_byname::pattern =&gt; cpp/locale/money_base
std::moneypunct_byname::moneypunct_byname =&gt; cpp/locale/moneypunct_byname/moneypunct_byname
std::moneypunct_byname::~moneypunct_byname =&gt; cpp/locale/moneypunct_byname/~moneypunct_byname
std::codecvt_utf8 =&gt; cpp/locale/codecvt_utf8
std::codecvt_utf8::intern_type =&gt; cpp/locale/codecvt
std::codecvt_utf8::extern_type =&gt; cpp/locale/codecvt
std::codecvt_utf8::state_type =&gt; cpp/locale/codecvt
std::codecvt_utf8::out =&gt; cpp/locale/codecvt/out
std::codecvt_utf8::in =&gt; cpp/locale/codecvt/in
std::codecvt_utf8::unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf8::encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf8::always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf8::length =&gt; cpp/locale/codecvt/length
std::codecvt_utf8::max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf8::do_out =&gt; cpp/locale/codecvt/out
std::codecvt_utf8::do_in =&gt; cpp/locale/codecvt/in
std::codecvt_utf8::do_unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf8::do_encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf8::do_always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf8::do_length =&gt; cpp/locale/codecvt/length
std::codecvt_utf8::do_max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf8::result =&gt; cpp/locale/codecvt_base
std::codecvt_utf8::ok =&gt; cpp/locale/codecvt_base
std::codecvt_utf8::partial =&gt; cpp/locale/codecvt_base
std::codecvt_utf8::error =&gt; cpp/locale/codecvt_base
std::codecvt_utf8::noconv =&gt; cpp/locale/codecvt_base
std::codecvt_utf16 =&gt; cpp/locale/codecvt_utf16
std::codecvt_utf16::intern_type =&gt; cpp/locale/codecvt
std::codecvt_utf16::extern_type =&gt; cpp/locale/codecvt
std::codecvt_utf16::state_type =&gt; cpp/locale/codecvt
std::codecvt_utf16::out =&gt; cpp/locale/codecvt/out
std::codecvt_utf16::in =&gt; cpp/locale/codecvt/in
std::codecvt_utf16::unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf16::encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf16::always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf16::length =&gt; cpp/locale/codecvt/length
std::codecvt_utf16::max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf16::do_out =&gt; cpp/locale/codecvt/out
std::codecvt_utf16::do_in =&gt; cpp/locale/codecvt/in
std::codecvt_utf16::do_unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf16::do_encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf16::do_always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf16::do_length =&gt; cpp/locale/codecvt/length
std::codecvt_utf16::do_max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf16::result =&gt; cpp/locale/codecvt_base
std::codecvt_utf16::ok =&gt; cpp/locale/codecvt_base
std::codecvt_utf16::partial =&gt; cpp/locale/codecvt_base
std::codecvt_utf16::error =&gt; cpp/locale/codecvt_base
std::codecvt_utf16::noconv =&gt; cpp/locale/codecvt_base
std::codecvt_utf8_utf16 =&gt; cpp/locale/codecvt_utf8_utf16
std::codecvt_utf8_utf16::intern_type =&gt; cpp/locale/codecvt
std::codecvt_utf8_utf16::extern_type =&gt; cpp/locale/codecvt
std::codecvt_utf8_utf16::state_type =&gt; cpp/locale/codecvt
std::codecvt_utf8_utf16::out =&gt; cpp/locale/codecvt/out
std::codecvt_utf8_utf16::in =&gt; cpp/locale/codecvt/in
std::codecvt_utf8_utf16::unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf8_utf16::encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf8_utf16::always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf8_utf16::length =&gt; cpp/locale/codecvt/length
std::codecvt_utf8_utf16::max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf8_utf16::do_out =&gt; cpp/locale/codecvt/out
std::codecvt_utf8_utf16::do_in =&gt; cpp/locale/codecvt/in
std::codecvt_utf8_utf16::do_unshift =&gt; cpp/locale/codecvt/unshift
std::codecvt_utf8_utf16::do_encoding =&gt; cpp/locale/codecvt/encoding
std::codecvt_utf8_utf16::do_always_noconv =&gt; cpp/locale/codecvt/always_noconv
std::codecvt_utf8_utf16::do_length =&gt; cpp/locale/codecvt/length
std::codecvt_utf8_utf16::do_max_length =&gt; cpp/locale/codecvt/max_length
std::codecvt_utf8_utf16::result =&gt; cpp/locale/codecvt_base
std::codecvt_utf8_utf16::ok =&gt; cpp/locale/codecvt_base
std::codecvt_utf8_utf16::partial =&gt; cpp/locale/codecvt_base
std::codecvt_utf8_utf16::error =&gt; cpp/locale/codecvt_base
std::codecvt_utf8_utf16::noconv =&gt; cpp/locale/codecvt_base
std::codecvt_mode =&gt; cpp/locale/codecvt_mode
std::consume_header =&gt; cpp/locale/codecvt_mode
std::generate_header =&gt; cpp/locale/codecvt_mode
std::little_endian =&gt; cpp/locale/codecvt_mode
std::setlocale =&gt; cpp/locale/setlocale
std::localeconv =&gt; cpp/locale/localeconv
std::lconv =&gt; cpp/locale/lconv
LC_ALL =&gt; cpp/locale/LC_categories
LC_COLLATE =&gt; cpp/locale/LC_categories
LC_CTYPE =&gt; cpp/locale/LC_categories
LC_MONETARY =&gt; cpp/locale/LC_categories
LC_NUMERIC =&gt; cpp/locale/LC_categories
LC_TIME =&gt; cpp/locale/LC_categories
std::basic_regex =&gt; cpp/regex/basic_regex
std::basic_regex::basic_regex =&gt; cpp/regex/basic_regex/basic_regex
std::basic_regex::~basic_regex =&gt; cpp/regex/basic_regex/~basic_regex
std::basic_regex::operator= =&gt; cpp/regex/basic_regex/operator=
std::basic_regex::assign =&gt; cpp/regex/basic_regex/assign
std::basic_regex::mark_count =&gt; cpp/regex/basic_regex/mark_count
std::basic_regex::flags =&gt; cpp/regex/basic_regex/flags
std::basic_regex::getloc =&gt; cpp/regex/basic_regex/getloc
std::basic_regex::imbue =&gt; cpp/regex/basic_regex/imbue
std::basic_regex::swap =&gt; cpp/regex/basic_regex/swap
std::regex =&gt; cpp/regex/basic_regex
std::regex::regex =&gt; cpp/regex/basic_regex/basic_regex
std::regex::~regex =&gt; cpp/regex/basic_regex/~basic_regex
std::regex::operator= =&gt; cpp/regex/basic_regex/operator=
std::regex::assign =&gt; cpp/regex/basic_regex/assign
std::regex::mark_count =&gt; cpp/regex/basic_regex/mark_count
std::regex::flags =&gt; cpp/regex/basic_regex/flags
std::regex::getloc =&gt; cpp/regex/basic_regex/getloc
std::regex::imbue =&gt; cpp/regex/basic_regex/imbue
std::regex::swap =&gt; cpp/regex/basic_regex/swap
std::wregex =&gt; cpp/regex/basic_regex
std::wregex::wregex =&gt; cpp/regex/basic_regex/basic_regex
std::wregex::~wregex =&gt; cpp/regex/basic_regex/~basic_regex
std::wregex::operator= =&gt; cpp/regex/basic_regex/operator=
std::wregex::assign =&gt; cpp/regex/basic_regex/assign
std::wregex::mark_count =&gt; cpp/regex/basic_regex/mark_count
std::wregex::flags =&gt; cpp/regex/basic_regex/flags
std::wregex::getloc =&gt; cpp/regex/basic_regex/getloc
std::wregex::imbue =&gt; cpp/regex/basic_regex/imbue
std::wregex::swap =&gt; cpp/regex/basic_regex/swap
std::sub_match =&gt; cpp/regex/sub_match
std::sub_match::sub_match =&gt; cpp/regex/sub_match/sub_match
std::sub_match::length =&gt; cpp/regex/sub_match/length
std::sub_match::str =&gt; cpp/regex/sub_match/str
std::sub_match::operator string_type =&gt; cpp/regex/sub_match/str
std::sub_match::compare =&gt; cpp/regex/sub_match/compare
std::csub_match =&gt; cpp/regex/sub_match
std::csub_match::csub_match =&gt; cpp/regex/sub_match/sub_match
std::csub_match::length =&gt; cpp/regex/sub_match/length
std::csub_match::str =&gt; cpp/regex/sub_match/str
std::csub_match::operator string_type =&gt; cpp/regex/sub_match/str
std::csub_match::compare =&gt; cpp/regex/sub_match/compare
std::wcsub_match =&gt; cpp/regex/sub_match
std::wcsub_match::wcsub_match =&gt; cpp/regex/sub_match/sub_match
std::wcsub_match::length =&gt; cpp/regex/sub_match/length
std::wcsub_match::str =&gt; cpp/regex/sub_match/str
std::wcsub_match::operator string_type =&gt; cpp/regex/sub_match/str
std::wcsub_match::compare =&gt; cpp/regex/sub_match/compare
std::ssub_match =&gt; cpp/regex/sub_match
std::ssub_match::ssub_match =&gt; cpp/regex/sub_match/sub_match
std::ssub_match::length =&gt; cpp/regex/sub_match/length
std::ssub_match::str =&gt; cpp/regex/sub_match/str
std::ssub_match::operator string_type =&gt; cpp/regex/sub_match/str
std::ssub_match::compare =&gt; cpp/regex/sub_match/compare
std::wssub_match =&gt; cpp/regex/sub_match
std::wssub_match::wssub_match =&gt; cpp/regex/sub_match/sub_match
std::wssub_match::length =&gt; cpp/regex/sub_match/length
std::wssub_match::str =&gt; cpp/regex/sub_match/str
std::wssub_match::operator string_type =&gt; cpp/regex/sub_match/str
std::wssub_match::compare =&gt; cpp/regex/sub_match/compare
std::match_results =&gt; cpp/regex/match_results
std::match_results::match_results =&gt; cpp/regex/match_results/match_results
std::match_results::~match_results =&gt; cpp/regex/match_results/~match_results
std::match_results::get_allocator =&gt; cpp/regex/match_results/get_allocator
std::match_results::ready =&gt; cpp/regex/match_results/ready
std::match_results::empty =&gt; cpp/regex/match_results/empty
std::match_results::size =&gt; cpp/regex/match_results/size
std::match_results::max_size =&gt; cpp/regex/match_results/max_size
std::match_results::length =&gt; cpp/regex/match_results/length
std::match_results::position =&gt; cpp/regex/match_results/position
std::match_results::str =&gt; cpp/regex/match_results/str
std::match_results::operator[] =&gt; cpp/regex/match_results/operator_at
std::match_results::prefix =&gt; cpp/regex/match_results/prefix
std::match_results::suffix =&gt; cpp/regex/match_results/suffix
std::match_results::begin =&gt; cpp/regex/match_results/begin
std::match_results::cbegin =&gt; cpp/regex/match_results/begin
std::match_results::end =&gt; cpp/regex/match_results/end
std::match_results::cend =&gt; cpp/regex/match_results/end
std::match_results::format =&gt; cpp/regex/match_results/format
std::match_results::swap =&gt; cpp/regex/match_results/swap
std::cmatch =&gt; cpp/regex/match_results
std::cmatch::cmatch =&gt; cpp/regex/match_results/match_results
std::cmatch::~cmatch =&gt; cpp/regex/match_results/~match_results
std::cmatch::get_allocator =&gt; cpp/regex/match_results/get_allocator
std::cmatch::ready =&gt; cpp/regex/match_results/ready
std::cmatch::empty =&gt; cpp/regex/match_results/empty
std::cmatch::size =&gt; cpp/regex/match_results/size
std::cmatch::max_size =&gt; cpp/regex/match_results/max_size
std::cmatch::length =&gt; cpp/regex/match_results/length
std::cmatch::position =&gt; cpp/regex/match_results/position
std::cmatch::str =&gt; cpp/regex/match_results/str
std::cmatch::operator[] =&gt; cpp/regex/match_results/operator_at
std::cmatch::prefix =&gt; cpp/regex/match_results/prefix
std::cmatch::suffix =&gt; cpp/regex/match_results/suffix
std::cmatch::begin =&gt; cpp/regex/match_results/begin
std::cmatch::cbegin =&gt; cpp/regex/match_results/begin
std::cmatch::end =&gt; cpp/regex/match_results/end
std::cmatch::cend =&gt; cpp/regex/match_results/end
std::cmatch::format =&gt; cpp/regex/match_results/format
std::cmatch::swap =&gt; cpp/regex/match_results/swap
std::wcmatch =&gt; cpp/regex/match_results
std::wcmatch::wcmatch =&gt; cpp/regex/match_results/match_results
std::wcmatch::~wcmatch =&gt; cpp/regex/match_results/~match_results
std::wcmatch::get_allocator =&gt; cpp/regex/match_results/get_allocator
std::wcmatch::ready =&gt; cpp/regex/match_results/ready
std::wcmatch::empty =&gt; cpp/regex/match_results/empty
std::wcmatch::size =&gt; cpp/regex/match_results/size
std::wcmatch::max_size =&gt; cpp/regex/match_results/max_size
std::wcmatch::length =&gt; cpp/regex/match_results/length
std::wcmatch::position =&gt; cpp/regex/match_results/position
std::wcmatch::str =&gt; cpp/regex/match_results/str
std::wcmatch::operator[] =&gt; cpp/regex/match_results/operator_at
std::wcmatch::prefix =&gt; cpp/regex/match_results/prefix
std::wcmatch::suffix =&gt; cpp/regex/match_results/suffix
std::wcmatch::begin =&gt; cpp/regex/match_results/begin
std::wcmatch::cbegin =&gt; cpp/regex/match_results/begin
std::wcmatch::end =&gt; cpp/regex/match_results/end
std::wcmatch::cend =&gt; cpp/regex/match_results/end
std::wcmatch::format =&gt; cpp/regex/match_results/format
std::wcmatch::swap =&gt; cpp/regex/match_results/swap
std::smatch =&gt; cpp/regex/match_results
std::smatch::smatch =&gt; cpp/regex/match_results/match_results
std::smatch::~smatch =&gt; cpp/regex/match_results/~match_results
std::smatch::get_allocator =&gt; cpp/regex/match_results/get_allocator
std::smatch::ready =&gt; cpp/regex/match_results/ready
std::smatch::empty =&gt; cpp/regex/match_results/empty
std::smatch::size =&gt; cpp/regex/match_results/size
std::smatch::max_size =&gt; cpp/regex/match_results/max_size
std::smatch::length =&gt; cpp/regex/match_results/length
std::smatch::position =&gt; cpp/regex/match_results/position
std::smatch::str =&gt; cpp/regex/match_results/str
std::smatch::operator[] =&gt; cpp/regex/match_results/operator_at
std::smatch::prefix =&gt; cpp/regex/match_results/prefix
std::smatch::suffix =&gt; cpp/regex/match_results/suffix
std::smatch::begin =&gt; cpp/regex/match_results/begin
std::smatch::cbegin =&gt; cpp/regex/match_results/begin
std::smatch::end =&gt; cpp/regex/match_results/end
std::smatch::cend =&gt; cpp/regex/match_results/end
std::smatch::format =&gt; cpp/regex/match_results/format
std::smatch::swap =&gt; cpp/regex/match_results/swap
std::wsmatch =&gt; cpp/regex/match_results
std::wsmatch::wsmatch =&gt; cpp/regex/match_results/match_results
std::wsmatch::~wsmatch =&gt; cpp/regex/match_results/~match_results
std::wsmatch::get_allocator =&gt; cpp/regex/match_results/get_allocator
std::wsmatch::ready =&gt; cpp/regex/match_results/ready
std::wsmatch::empty =&gt; cpp/regex/match_results/empty
std::wsmatch::size =&gt; cpp/regex/match_results/size
std::wsmatch::max_size =&gt; cpp/regex/match_results/max_size
std::wsmatch::length =&gt; cpp/regex/match_results/length
std::wsmatch::position =&gt; cpp/regex/match_results/position
std::wsmatch::str =&gt; cpp/regex/match_results/str
std::wsmatch::operator[] =&gt; cpp/regex/match_results/operator_at
std::wsmatch::prefix =&gt; cpp/regex/match_results/prefix
std::wsmatch::suffix =&gt; cpp/regex/match_results/suffix
std::wsmatch::begin =&gt; cpp/regex/match_results/begin
std::wsmatch::cbegin =&gt; cpp/regex/match_results/begin
std::wsmatch::end =&gt; cpp/regex/match_results/end
std::wsmatch::cend =&gt; cpp/regex/match_results/end
std::wsmatch::format =&gt; cpp/regex/match_results/format
std::wsmatch::swap =&gt; cpp/regex/match_results/swap
std::regex_match =&gt; cpp/regex/regex_match
std::regex_search =&gt; cpp/regex/regex_search
std::regex_replace =&gt; cpp/regex/regex_replace
std::regex_iterator =&gt; cpp/regex/regex_iterator
std::regex_iterator::regex_iterator =&gt; cpp/regex/regex_iterator/regex_iterator
std::regex_iterator::operator= =&gt; cpp/regex/regex_iterator/operator=
std::regex_iterator::operator== =&gt; cpp/regex/regex_iterator/operator_cmp
std::regex_iterator::operator!= =&gt; cpp/regex/regex_iterator/operator_cmp
std::regex_iterator::operator* =&gt; cpp/regex/regex_iterator/operator*
std::regex_iterator::operator-&gt; =&gt; cpp/regex/regex_iterator/operator*
std::regex_iterator::operator++ =&gt; cpp/regex/regex_iterator/operator_arith
std::regex_iterator::operator++(int) =&gt; cpp/regex/regex_iterator/operator_arith
std::cregex_iterator =&gt; cpp/regex/regex_iterator
std::cregex_iterator::cregex_iterator =&gt; cpp/regex/regex_iterator/regex_iterator
std::cregex_iterator::operator= =&gt; cpp/regex/regex_iterator/operator=
std::cregex_iterator::operator== =&gt; cpp/regex/regex_iterator/operator_cmp
std::cregex_iterator::operator!= =&gt; cpp/regex/regex_iterator/operator_cmp
std::cregex_iterator::operator* =&gt; cpp/regex/regex_iterator/operator*
std::cregex_iterator::operator-&gt; =&gt; cpp/regex/regex_iterator/operator*
std::cregex_iterator::operator++ =&gt; cpp/regex/regex_iterator/operator_arith
std::cregex_iterator::operator++(int) =&gt; cpp/regex/regex_iterator/operator_arith
std::wcregex_iterator =&gt; cpp/regex/regex_iterator
std::wcregex_iterator::wcregex_iterator =&gt; cpp/regex/regex_iterator/regex_iterator
std::wcregex_iterator::operator= =&gt; cpp/regex/regex_iterator/operator=
std::wcregex_iterator::operator== =&gt; cpp/regex/regex_iterator/operator_cmp
std::wcregex_iterator::operator!= =&gt; cpp/regex/regex_iterator/operator_cmp
std::wcregex_iterator::operator* =&gt; cpp/regex/regex_iterator/operator*
std::wcregex_iterator::operator-&gt; =&gt; cpp/regex/regex_iterator/operator*
std::wcregex_iterator::operator++ =&gt; cpp/regex/regex_iterator/operator_arith
std::wcregex_iterator::operator++(int) =&gt; cpp/regex/regex_iterator/operator_arith
std::sregex_iterator =&gt; cpp/regex/regex_iterator
std::sregex_iterator::sregex_iterator =&gt; cpp/regex/regex_iterator/regex_iterator
std::sregex_iterator::operator= =&gt; cpp/regex/regex_iterator/operator=
std::sregex_iterator::operator== =&gt; cpp/regex/regex_iterator/operator_cmp
std::sregex_iterator::operator!= =&gt; cpp/regex/regex_iterator/operator_cmp
std::sregex_iterator::operator* =&gt; cpp/regex/regex_iterator/operator*
std::sregex_iterator::operator-&gt; =&gt; cpp/regex/regex_iterator/operator*
std::sregex_iterator::operator++ =&gt; cpp/regex/regex_iterator/operator_arith
std::sregex_iterator::operator++(int) =&gt; cpp/regex/regex_iterator/operator_arith
std::wsregex_iterator =&gt; cpp/regex/regex_iterator
std::wsregex_iterator::wsregex_iterator =&gt; cpp/regex/regex_iterator/regex_iterator
std::wsregex_iterator::operator= =&gt; cpp/regex/regex_iterator/operator=
std::wsregex_iterator::operator== =&gt; cpp/regex/regex_iterator/operator_cmp
std::wsregex_iterator::operator!= =&gt; cpp/regex/regex_iterator/operator_cmp
std::wsregex_iterator::operator* =&gt; cpp/regex/regex_iterator/operator*
std::wsregex_iterator::operator-&gt; =&gt; cpp/regex/regex_iterator/operator*
std::wsregex_iterator::operator++ =&gt; cpp/regex/regex_iterator/operator_arith
std::wsregex_iterator::operator++(int) =&gt; cpp/regex/regex_iterator/operator_arith
std::regex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::regex_token_iterator::regex_token_iterator =&gt; cpp/regex/regex_token_iterator/regex_token_iterator
std::regex_token_iterator::operator= =&gt; cpp/regex/regex_token_iterator/operator=
std::regex_token_iterator::operator== =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::regex_token_iterator::operator!= =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::regex_token_iterator::operator* =&gt; cpp/regex/regex_token_iterator/operator*
std::regex_token_iterator::operator-&gt; =&gt; cpp/regex/regex_token_iterator/operator*
std::regex_token_iterator::operator++ =&gt; cpp/regex/regex_token_iterator/operator_arith
std::regex_token_iterator::operator++(int) =&gt; cpp/regex/regex_token_iterator/operator_arith
std::cregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::cregex_token_iterator::cregex_token_iterator =&gt; cpp/regex/regex_token_iterator/regex_token_iterator
std::cregex_token_iterator::operator= =&gt; cpp/regex/regex_token_iterator/operator=
std::cregex_token_iterator::operator== =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::cregex_token_iterator::operator!= =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::cregex_token_iterator::operator* =&gt; cpp/regex/regex_token_iterator/operator*
std::cregex_token_iterator::operator-&gt; =&gt; cpp/regex/regex_token_iterator/operator*
std::cregex_token_iterator::operator++ =&gt; cpp/regex/regex_token_iterator/operator_arith
std::cregex_token_iterator::operator++(int) =&gt; cpp/regex/regex_token_iterator/operator_arith
std::wcregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::wcregex_token_iterator::wcregex_token_iterator =&gt; cpp/regex/regex_token_iterator/regex_token_iterator
std::wcregex_token_iterator::operator= =&gt; cpp/regex/regex_token_iterator/operator=
std::wcregex_token_iterator::operator== =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::wcregex_token_iterator::operator!= =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::wcregex_token_iterator::operator* =&gt; cpp/regex/regex_token_iterator/operator*
std::wcregex_token_iterator::operator-&gt; =&gt; cpp/regex/regex_token_iterator/operator*
std::wcregex_token_iterator::operator++ =&gt; cpp/regex/regex_token_iterator/operator_arith
std::wcregex_token_iterator::operator++(int) =&gt; cpp/regex/regex_token_iterator/operator_arith
std::sregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::sregex_token_iterator::sregex_token_iterator =&gt; cpp/regex/regex_token_iterator/regex_token_iterator
std::sregex_token_iterator::operator= =&gt; cpp/regex/regex_token_iterator/operator=
std::sregex_token_iterator::operator== =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::sregex_token_iterator::operator!= =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::sregex_token_iterator::operator* =&gt; cpp/regex/regex_token_iterator/operator*
std::sregex_token_iterator::operator-&gt; =&gt; cpp/regex/regex_token_iterator/operator*
std::sregex_token_iterator::operator++ =&gt; cpp/regex/regex_token_iterator/operator_arith
std::sregex_token_iterator::operator++(int) =&gt; cpp/regex/regex_token_iterator/operator_arith
std::wsregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::wsregex_token_iterator::wsregex_token_iterator =&gt; cpp/regex/regex_token_iterator/regex_token_iterator
std::wsregex_token_iterator::operator= =&gt; cpp/regex/regex_token_iterator/operator=
std::wsregex_token_iterator::operator== =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::wsregex_token_iterator::operator!= =&gt; cpp/regex/regex_token_iterator/operator_cmp
std::wsregex_token_iterator::operator* =&gt; cpp/regex/regex_token_iterator/operator*
std::wsregex_token_iterator::operator-&gt; =&gt; cpp/regex/regex_token_iterator/operator*
std::wsregex_token_iterator::operator++ =&gt; cpp/regex/regex_token_iterator/operator_arith
std::wsregex_token_iterator::operator++(int) =&gt; cpp/regex/regex_token_iterator/operator_arith
std::regex_error =&gt; cpp/regex/regex_error
std::regex_error::what =&gt; cpp/error/exception/what
std::regex_error::regex_error =&gt; cpp/regex/regex_error/regex_error
std::regex_error::code =&gt; cpp/regex/regex_error/code
std::regex_traits =&gt; cpp/regex/regex_traits
std::regex_traits::regex_traits =&gt; cpp/regex/regex_traits/regex_traits
std::regex_traits::length =&gt; cpp/regex/regex_traits/length
std::regex_traits::translate =&gt; cpp/regex/regex_traits/translate
std::regex_traits::translate_nocase =&gt; cpp/regex/regex_traits/translate_nocase
std::regex_traits::transform =&gt; cpp/regex/regex_traits/transform
std::regex_traits::transform_primary =&gt; cpp/regex/regex_traits/transform_primary
std::regex_traits::lookup_collatename =&gt; cpp/regex/regex_traits/lookup_collatename
std::regex_traits::lookup_classname =&gt; cpp/regex/regex_traits/lookup_classname
std::regex_traits::isctype =&gt; cpp/regex/regex_traits/isctype
std::regex_traits::value =&gt; cpp/regex/regex_traits/value
std::regex_traits::imbue =&gt; cpp/regex/regex_traits/imbue
std::regex_traits::getloc =&gt; cpp/regex/regex_traits/getloc
std::regex_constants::syntax_option_type =&gt; cpp/regex/syntax_option_type
std::regex_constants::icase =&gt; cpp/regex/syntax_option_type
std::regex_constants::nosubs =&gt; cpp/regex/syntax_option_type
std::regex_constants::optimize =&gt; cpp/regex/syntax_option_type
std::regex_constants::collate =&gt; cpp/regex/syntax_option_type
std::regex_constants::ECMAScript =&gt; cpp/regex/syntax_option_type
std::regex_constants::basic =&gt; cpp/regex/syntax_option_type
std::regex_constants::extended =&gt; cpp/regex/syntax_option_type
std::regex_constants::awk =&gt; cpp/regex/syntax_option_type
std::regex_constants::grep =&gt; cpp/regex/syntax_option_type
std::regex_constants::egrep =&gt; cpp/regex/syntax_option_type
std::regex_constants::match_flag_type =&gt; cpp/regex/match_flag_type
std::regex_constants::match_default =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_bol =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_eol =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_bow =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_eow =&gt; cpp/regex/match_flag_type
std::regex_constants::match_any =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_null =&gt; cpp/regex/match_flag_type
std::regex_constants::match_continuous =&gt; cpp/regex/match_flag_type
std::regex_constants::match_prev_avail =&gt; cpp/regex/match_flag_type
std::regex_constants::format_default =&gt; cpp/regex/match_flag_type
std::regex_constants::format_sed =&gt; cpp/regex/match_flag_type
std::regex_constants::format_no_copy =&gt; cpp/regex/match_flag_type
std::regex_constants::format_first_only =&gt; cpp/regex/match_flag_type
std::regex_constants::error_type =&gt; cpp/regex/error_type
std::regex_constants::error_collate =&gt; cpp/regex/error_type
std::regex_constants::error_ctype =&gt; cpp/regex/error_type
std::regex_constants::error_escape =&gt; cpp/regex/error_type
std::regex_constants::error_backref =&gt; cpp/regex/error_type
std::regex_constants::error_brack =&gt; cpp/regex/error_type
std::regex_constants::error_paren =&gt; cpp/regex/error_type
std::regex_constants::error_brace =&gt; cpp/regex/error_type
std::regex_constants::error_badbrace =&gt; cpp/regex/error_type
std::regex_constants::error_range =&gt; cpp/regex/error_type
std::regex_constants::error_space =&gt; cpp/regex/error_type
std::regex_constants::error_badrepeat =&gt; cpp/regex/error_type
std::regex_constants::error_complexity =&gt; cpp/regex/error_type
std::regex_constants::error_stack =&gt; cpp/regex/error_type
std::atomic =&gt; cpp/atomic/atomic
std::atomic::atomic =&gt; cpp/atomic/atomic/atomic
std::atomic::operator= =&gt; cpp/atomic/atomic/operator=
std::atomic::is_lock_free =&gt; cpp/atomic/atomic/is_lock_free
std::atomic::store =&gt; cpp/atomic/atomic/store
std::atomic::load =&gt; cpp/atomic/atomic/load
std::atomic::operator T =&gt; cpp/atomic/atomic/operator T
std::atomic::exchange =&gt; cpp/atomic/atomic/exchange
std::atomic::compare_exchange_strong =&gt; cpp/atomic/atomic/compare_exchange
std::atomic::compare_exchange_weak =&gt; cpp/atomic/atomic/compare_exchange
std::atomic::fetch_add =&gt; cpp/atomic/atomic/fetch_add
std::atomic::fetch_sub =&gt; cpp/atomic/atomic/fetch_sub
std::atomic::fetch_and =&gt; cpp/atomic/atomic/fetch_and
std::atomic::fetch_or =&gt; cpp/atomic/atomic/fetch_or
std::atomic::fetch_xor =&gt; cpp/atomic/atomic/fetch_xor
std::atomic::operator++ =&gt; cpp/atomic/atomic/operator_arith
std::atomic::operator++(int) =&gt; cpp/atomic/atomic/operator_arith
std::atomic::operator-- =&gt; cpp/atomic/atomic/operator_arith
std::atomic::operator--(int) =&gt; cpp/atomic/atomic/operator_arith
std::atomic::operator+= =&gt; cpp/atomic/atomic/operator_arith2
std::atomic::operator-= =&gt; cpp/atomic/atomic/operator_arith2
std::atomic::operator&amp;= =&gt; cpp/atomic/atomic/operator_arith2
std::atomic::operator|= =&gt; cpp/atomic/atomic/operator_arith2
std::atomic::operator^= =&gt; cpp/atomic/atomic/operator_arith2
std::atomic_is_lock_free =&gt; cpp/atomic/atomic_is_lock_free
std::atomic_store =&gt; cpp/atomic/atomic_store
std::atomic_store_explicit =&gt; cpp/atomic/atomic_store
std::atomic_load =&gt; cpp/atomic/atomic_load
std::atomic_load_explicit =&gt; cpp/atomic/atomic_load
std::atomic_exchange =&gt; cpp/atomic/atomic_exchange
std::atomic_exchange_explicit =&gt; cpp/atomic/atomic_exchange
std::atomic_compare_exchange_weak =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_weak_explicit =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_strong =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_strong_explicit =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_fetch_add =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_add_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_sub =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_sub_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_and =&gt; cpp/atomic/atomic_fetch_sub
std::atomic_fetch_and_explicit =&gt; cpp/atomic/atomic_fetch_sub
std::atomic_fetch_or =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_or_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_xor =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_xor_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_flag =&gt; cpp/atomic/atomic_flag
std::atomic_flag::atomic_flag =&gt; cpp/atomic/atomic_flag/atomic_flag
std::atomic_flag::operator= =&gt; cpp/atomic/atomic_flag/operator=
std::atomic_flag::clear =&gt; cpp/atomic/atomic_flag/clear
std::atomic_flag::test_and_set =&gt; cpp/atomic/atomic_flag/test_and_set
std::atomic_init =&gt; cpp/atomic/atomic_init
ATOMIC_VAR_INIT =&gt; cpp/atomic/ATOMIC_VAR_INIT
ATOMIC_FLAG_INIT =&gt; cpp/atomic/ATOMIC_FLAG_INIT
std::memory_order =&gt; cpp/atomic/memory_order
std::memory_order_relaxed =&gt; cpp/atomic/memory_order
std::memory_order_consume =&gt; cpp/atomic/memory_order
std::memory_order_acquire =&gt; cpp/atomic/memory_order
std::memory_order_release =&gt; cpp/atomic/memory_order
std::memory_order_acq_rel =&gt; cpp/atomic/memory_order
std::memory_order_seq_cst =&gt; cpp/atomic/memory_order
std::kill_dependency =&gt; cpp/atomic/kill_dependency
std::atomic_thread_fence =&gt; cpp/atomic/atomic_thread_fence
std::atomic_signal_fence =&gt; cpp/atomic/atomic_signal_fence
std::thread =&gt; cpp/thread/thread
std::thread::thread =&gt; cpp/thread/thread/thread
std::thread::~thread =&gt; cpp/thread/thread/~thread
std::thread::operator= =&gt; cpp/thread/thread/operator=
std::thread::joinable =&gt; cpp/thread/thread/joinable
std::thread::get_id =&gt; cpp/thread/thread/get_id
std::thread::native_handle =&gt; cpp/thread/thread/native_handle
std::thread::hardware_concurrency =&gt; cpp/thread/thread/hardware_concurrency
std::thread::join =&gt; cpp/thread/thread/join
std::thread::detach =&gt; cpp/thread/thread/detach
std::thread::swap =&gt; cpp/thread/thread/swap
std::swap(std::thread) =&gt; cpp/thread/thread/swap2
std::thread::id =&gt; cpp/thread/thread/id
std::thread::id::id =&gt; cpp/thread/thread/id/id
std::thread::id::operator== =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator!= =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator&lt; =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator&lt;= =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator&gt; =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator&gt;= =&gt; cpp/thread/thread/id/operator_cmp
std::thread::id::operator&lt;&lt; =&gt; cpp/thread/thread/id/operator_ltlt
std::hash&lt;std::thread::id&gt; =&gt; cpp/thread/thread/id/hash
std::this_thread::get_id =&gt; cpp/thread/get_id
std::this_thread::sleep_for =&gt; cpp/thread/sleep_for
std::this_thread::sleep_until =&gt; cpp/thread/sleep_until
std::this_thread::yield =&gt; cpp/thread/yield
std::mutex =&gt; cpp/thread/mutex
std::mutex::mutex =&gt; cpp/thread/mutex/mutex
std::mutex::lock =&gt; cpp/thread/mutex/lock
std::mutex::try_lock =&gt; cpp/thread/mutex/try_lock
std::mutex::unlock =&gt; cpp/thread/mutex/unlock
std::mutex::native_handle =&gt; cpp/thread/mutex/native_handle
std::recursive_mutex =&gt; cpp/thread/recursive_mutex
std::recursive_mutex::recursive_mutex =&gt; cpp/thread/recursive_mutex/recursive_mutex
std::recursive_mutex::lock =&gt; cpp/thread/recursive_mutex/lock
std::recursive_mutex::try_lock =&gt; cpp/thread/recursive_mutex/try_lock
std::recursive_mutex::unlock =&gt; cpp/thread/recursive_mutex/unlock
std::recursive_mutex::native_handle =&gt; cpp/thread/recursive_mutex/native_handle
std::timed_mutex =&gt; cpp/thread/timed_mutex
std::timed_mutex::timed_mutex =&gt; cpp/thread/timed_mutex/timed_mutex
std::timed_mutex::lock =&gt; cpp/thread/timed_mutex/lock
std::timed_mutex::try_lock =&gt; cpp/thread/timed_mutex/try_lock
std::timed_mutex::try_lock_for =&gt; cpp/thread/timed_mutex/try_lock_for
std::timed_mutex::try_lock_until =&gt; cpp/thread/timed_mutex/try_lock_until
std::timed_mutex::unlock =&gt; cpp/thread/timed_mutex/unlock
std::timed_mutex::native_handle =&gt; cpp/thread/timed_mutex/native_handle
std::recursive_timed_mutex =&gt; cpp/thread/recursive_timed_mutex
std::recursive_timed_mutex::recursive_timed_mutex =&gt; cpp/thread/recursive_timed_mutex/recursive_timed_mutex
std::recursive_timed_mutex::lock =&gt; cpp/thread/recursive_timed_mutex/lock
std::recursive_timed_mutex::try_lock =&gt; cpp/thread/recursive_timed_mutex/try_lock
std::recursive_timed_mutex::try_lock_for =&gt; cpp/thread/recursive_timed_mutex/try_lock_for
std::recursive_timed_mutex::try_lock_until =&gt; cpp/thread/recursive_timed_mutex/try_lock_until
std::recursive_timed_mutex::unlock =&gt; cpp/thread/recursive_timed_mutex/unlock
std::recursive_timed_mutex::native_handle =&gt; cpp/thread/recursive_timed_mutex/native_handle
std::shared_mutex =&gt; cpp/thread/shared_mutex
std::shared_mutex::shared_mutex =&gt; cpp/thread/shared_mutex/shared_mutex
std::shared_mutex::lock =&gt; cpp/thread/shared_mutex/lock
std::shared_mutex::try_lock =&gt; cpp/thread/shared_mutex/try_lock
std::shared_mutex::try_lock_for =&gt; cpp/thread/shared_mutex/try_lock_for
std::shared_mutex::try_lock_until =&gt; cpp/thread/shared_mutex/try_lock_until
std::shared_mutex::unlock =&gt; cpp/thread/shared_mutex/unlock
std::shared_mutex::lock_shared =&gt; cpp/thread/shared_mutex/lock_shared
std::shared_mutex::try_lock_shared =&gt; cpp/thread/shared_mutex/try_lock_shared
std::shared_mutex::try_lock_shared_for =&gt; cpp/thread/shared_mutex/try_lock_shared_for
std::shared_mutex::try_lock_shared_until =&gt; cpp/thread/shared_mutex/try_lock_shared_until
std::shared_mutex::unlock_shared =&gt; cpp/thread/shared_mutex/unlock_shared
std::defer_lock_t =&gt; cpp/thread/lock_tag_t
std::try_to_lock_t =&gt; cpp/thread/lock_tag_t
std::adopt_lock_t =&gt; cpp/thread/lock_tag_t
std::defer_lock =&gt; cpp/thread/lock_tag
std::try_to_lock =&gt; cpp/thread/lock_tag
std::adopt_lock =&gt; cpp/thread/lock_tag
std::lock_guard =&gt; cpp/thread/lock_guard
std::lock_guard::lock_guard =&gt; cpp/thread/lock_guard/lock_guard
std::lock_guard::~lock_guard =&gt; cpp/thread/lock_guard/~lock_guard
std::unique_lock =&gt; cpp/thread/unique_lock
std::unique_lock::unique_lock =&gt; cpp/thread/unique_lock/unique_lock
std::unique_lock::~unique_lock =&gt; cpp/thread/unique_lock/~unique_lock
std::unique_lock::operator= =&gt; cpp/thread/unique_lock/operator=
std::unique_lock::lock =&gt; cpp/thread/unique_lock/lock
std::unique_lock::try_lock =&gt; cpp/thread/unique_lock/try_lock
std::unique_lock::try_lock_for =&gt; cpp/thread/unique_lock/try_lock_for
std::unique_lock::try_lock_until =&gt; cpp/thread/unique_lock/try_lock_until
std::unique_lock::unlock =&gt; cpp/thread/unique_lock/unlock
std::unique_lock::swap =&gt; cpp/thread/unique_lock/swap
std::unique_lock::release =&gt; cpp/thread/unique_lock/release
std::unique_lock::mutex =&gt; cpp/thread/unique_lock/mutex
std::unique_lock::owns_lock =&gt; cpp/thread/unique_lock/owns_lock
std::unique_lock::operator bool =&gt; cpp/thread/unique_lock/operator bool
std::swap(std::unique_lock) =&gt; cpp/thread/unique_lock/swap2
std::shared_lock =&gt; cpp/thread/shared_lock
std::shared_lock::shared_lock =&gt; cpp/thread/shared_lock/shared_lock
std::shared_lock::~shared_lock =&gt; cpp/thread/shared_lock/~shared_lock
std::shared_lock::operator= =&gt; cpp/thread/shared_lock/operator=
std::shared_lock::lock =&gt; cpp/thread/shared_lock/lock
std::shared_lock::try_lock =&gt; cpp/thread/shared_lock/try_lock
std::shared_lock::try_lock_for =&gt; cpp/thread/shared_lock/try_lock_for
std::shared_lock::try_lock_until =&gt; cpp/thread/shared_lock/try_lock_until
std::shared_lock::unlock =&gt; cpp/thread/shared_lock/unlock
std::shared_lock::swap =&gt; cpp/thread/shared_lock/swap
std::shared_lock::release =&gt; cpp/thread/shared_lock/release
std::shared_lock::mutex =&gt; cpp/thread/shared_lock/mutex
std::shared_lock::owns_lock =&gt; cpp/thread/shared_lock/owns_lock
std::shared_lock::operator bool =&gt; cpp/thread/shared_lock/operator bool
std::swap(std::shared_lock) =&gt; cpp/thread/shared_lock/swap2
std::lock =&gt; cpp/thread/lock
std::try_lock =&gt; cpp/thread/try_lock
std::condition_variable =&gt; cpp/thread/condition_variable
std::condition_variable::condition_variable =&gt; cpp/thread/condition_variable/condition_variable
std::condition_variable::~condition_variable =&gt; cpp/thread/condition_variable/~condition_variable
std::condition_variable::notify_one =&gt; cpp/thread/condition_variable/notify_one
std::condition_variable::notify_all =&gt; cpp/thread/condition_variable/notify_all
std::condition_variable::wait =&gt; cpp/thread/condition_variable/wait
std::condition_variable::wait_for =&gt; cpp/thread/condition_variable/wait_for
std::condition_variable::wait_until =&gt; cpp/thread/condition_variable/wait_until
std::condition_variable::native_handle =&gt; cpp/thread/condition_variable/native_handle
std::condition_variable_any =&gt; cpp/thread/condition_variable_any
std::condition_variable_any::condition_variable_any =&gt; cpp/thread/condition_variable_any/condition_variable_any
std::condition_variable_any::~condition_variable_any =&gt; cpp/thread/condition_variable_any/~condition_variable_any
std::condition_variable_any::notify_one =&gt; cpp/thread/condition_variable_any/notify_one
std::condition_variable_any::notify_all =&gt; cpp/thread/condition_variable_any/notify_all
std::condition_variable_any::wait =&gt; cpp/thread/condition_variable_any/wait
std::condition_variable_any::wait_for =&gt; cpp/thread/condition_variable_any/wait_for
std::condition_variable_any::wait_until =&gt; cpp/thread/condition_variable_any/wait_until
std::condition_variable_any::native_handle =&gt; cpp/thread/condition_variable_any/native_handle
std::notify_all_at_thread_exit =&gt; cpp/thread/notify_all_at_thread_exit
std::once_flag =&gt; cpp/thread/once_flag
std::once_flag::once_flag =&gt; cpp/thread/once_flag
std::call_once =&gt; cpp/thread/call_once
std::cv_status =&gt; cpp/thread/cv_status
std::cv_status::no_timeout =&gt; cpp/thread/cv_status/no_timeout
std::cv_status::timeout =&gt; cpp/thread/cv_status/timeout
std::promise =&gt; cpp/thread/promise
std::promise::promise =&gt; cpp/thread/promise/promise
std::promise::~promise =&gt; cpp/thread/promise/~promise
std::promise::operator= =&gt; cpp/thread/promise/operator=
std::promise::swap =&gt; cpp/thread/promise/swap
std::promise::get_future =&gt; cpp/thread/promise/get_future
std::promise::set_value =&gt; cpp/thread/promise/set_value
std::promise::set_value_at_thread_exit =&gt; cpp/thread/promise/set_value_at_thread_exit
std::promise::set_exception =&gt; cpp/thread/promise/set_exception
std::promise::set_exception_at_thread_exit =&gt; cpp/thread/promise/set_exception_at_thread_exit
std::uses_allocator&lt;std::promise&gt; =&gt; cpp/thread/promise/uses_allocator
std::future =&gt; cpp/thread/future
std::future::future =&gt; cpp/thread/future/future
std::future::~future =&gt; cpp/thread/future/~future
std::future::operator= =&gt; cpp/thread/future/operator=
std::future::share =&gt; cpp/thread/future/share
std::future::get =&gt; cpp/thread/future/get
std::future::valid =&gt; cpp/thread/future/valid
std::future::wait =&gt; cpp/thread/future/wait
std::future::wait_for =&gt; cpp/thread/future/wait_for
std::future::wait_until =&gt; cpp/thread/future/wait_until
std::shared_future =&gt; cpp/thread/shared_future
std::shared_future::shared_future =&gt; cpp/thread/shared_future/shared_future
std::shared_future::~shared_future =&gt; cpp/thread/shared_future/~shared_future
std::shared_future::operator= =&gt; cpp/thread/shared_future/operator=
std::shared_future::get =&gt; cpp/thread/shared_future/get
std::shared_future::valid =&gt; cpp/thread/shared_future/valid
std::shared_future::wait =&gt; cpp/thread/shared_future/wait
std::shared_future::wait_for =&gt; cpp/thread/shared_future/wait_for
std::shared_future::wait_until =&gt; cpp/thread/shared_future/wait_until
std::future_category =&gt; cpp/thread/future/future_category
std::packaged_task =&gt; cpp/thread/packaged_task
std::packaged_task::packaged_task =&gt; cpp/thread/packaged_task/packaged_task
std::packaged_task::~packaged_task =&gt; cpp/thread/packaged_task/~packaged_task
std::packaged_task::operator= =&gt; cpp/thread/packaged_task/operator=
std::packaged_task::valid =&gt; cpp/thread/packaged_task/valid
std::packaged_task::swap =&gt; cpp/thread/packaged_task/swap
std::packaged_task::get_future =&gt; cpp/thread/packaged_task/get_future
std::packaged_task::operator() =&gt; cpp/thread/packaged_task/operator()
std::packaged_task::make_ready_at_thread_exit =&gt; cpp/thread/packaged_task/make_ready_at_thread_exit
std::packaged_task::reset =&gt; cpp/thread/packaged_task/reset
std::uses_allocator&lt;std::packaged_task&gt; =&gt; cpp/thread/packaged_task/uses_allocator
std::async =&gt; cpp/thread/async
std::launch =&gt; cpp/thread/launch
std::launch::async =&gt; cpp/thread/launch
std::launch::deferred =&gt; cpp/thread/launch
std::future_status =&gt; cpp/thread/future_status
std::future_status::ready =&gt; cpp/thread/future_status
std::future_status::timeout =&gt; cpp/thread/future_status
std::future_status::deferred =&gt; cpp/thread/future_status
std::future_error =&gt; cpp/thread/future_error
std::future_error::what =&gt; cpp/error/exception/what
std::future_error::future_error =&gt; cpp/thread/future_error/future_error
std::future_error::code =&gt; cpp/thread/future_error/code
std::future_error::what =&gt; cpp/thread/future_error/what
std::future_category =&gt; cpp/thread/future_category
std::future_errc =&gt; cpp/thread/future_errc
std::future_errc::broken_promise =&gt; cpp/thread/future_errc
std::future_errc::future_already_retrieved =&gt; cpp/thread/future_errc
std::future_errc::promise_already_satisfied =&gt; cpp/thread/future_errc
std::future_errc::no_state =&gt; cpp/thread/future_errc
std::is_error_code_enum&lt;std::future_errc&gt; =&gt; cpp/thread/future_errc/is_error_code_enum
std::make_error_code(std::future_errc) =&gt; cpp/thread/future_errc/make_error_code
std::make_error_condition(std::future_errc) =&gt; cpp/thread/future_errc/make_error_condition
Basic concepts =&gt; cpp/language/basic_concepts
Comments =&gt; cpp/comment
Keywords =&gt; cpp/keyword
Escape sequences =&gt; cpp/language/escape
ASCII chart =&gt; cpp/language/ascii
Names =&gt; cpp/language/name
Identifiers =&gt; cpp/language/identifiers
Types =&gt; cpp/language/type
Arithmetic types =&gt; cpp/language/types
Objects =&gt; cpp/language/object
Scope =&gt; cpp/language/scope
Lifetime =&gt; cpp/language/lifetime
Storage duration and linkage =&gt; cpp/language/storage_duration
Definitions and one definition rule =&gt; cpp/language/definition
Name lookup  =&gt; cpp/language/lookup
Memory model =&gt; cpp/language/memory_model
Phases of translation =&gt; cpp/language/translation_phases
The main() function =&gt; cpp/language/main_function
Preprocessor =&gt; cpp/preprocessor
#if directive =&gt; cpp/preprocessor/conditional
#ifdef directive =&gt; cpp/preprocessor/conditional
#ifndef directive =&gt; cpp/preprocessor/conditional
#define directive =&gt; cpp/preprocessor/replace
#include directive =&gt; cpp/preprocessor/include
#warning directive =&gt; cpp/preprocessor/warning
#error directive =&gt; cpp/preprocessor/error
#pragma directive =&gt; cpp/preprocessor/impl
#line directive =&gt; cpp/preprocessor/line
Expressions =&gt; cpp/language/expressions
Operators =&gt; cpp/language/expressions#Operators
Conversions =&gt; cpp/language/expressions#Conversions
Literals =&gt; cpp/language/expressions#Literals
Operator precedence =&gt; cpp/language/operator_precedence
Value categories =&gt; cpp/language/value_category
Evaluation order and sequencing =&gt; cpp/language/eval_order
sizeof operator =&gt; cpp/language/sizeof
alignof operator =&gt; cpp/language/alignof
typeid operator =&gt; cpp/language/typeid
new expression =&gt; cpp/language/new
delete expression =&gt; cpp/language/delete
Constant expressions =&gt; cpp/language/constant_expression
Statements =&gt; cpp/language/statements
if statement =&gt; cpp/language/if
switch statement =&gt; cpp/language/switch
for loop =&gt; cpp/language/for
range-for loop =&gt; cpp/language/range-for
while loop =&gt; cpp/language/while
do-while loop =&gt; cpp/language/do
continue statement =&gt; cpp/language/continue
break statement =&gt; cpp/language/break
goto statement =&gt; cpp/language/goto
return statement =&gt; cpp/language/return
Declaration =&gt; cpp/language/declarations
Namespace declaration =&gt; cpp/language/namespace
Namespace alias =&gt; cpp/language/namespace_alias
static_assert declaration =&gt; cpp/language/static_assert
Lvalue and rvalue references =&gt; cpp/language/reference
Pointers =&gt; cpp/language/pointer
Arrays =&gt; cpp/language/array
Enumerations and enumerators =&gt; cpp/language/enum
const/volatile =&gt; cpp/language/cv
constexpr specifier =&gt; cpp/language/constexpr
decltype operator =&gt; cpp/language/decltype
auto specifier =&gt; cpp/language/auto
alignas specifier =&gt; cpp/language/alignas
typedefs =&gt; cpp/language/typedef
Type alias =&gt; cpp/language/type_alias
Attributes =&gt; cpp/language/attributes
Initialization =&gt; cpp/language/initialization
Default initialization =&gt; cpp/language/default_initialization
Value initialization =&gt; cpp/language/value_initialization
Copy initialization =&gt; cpp/language/copy_initialization
Direct initialization =&gt; cpp/language/direct_initialization
Aggregate initialization =&gt; cpp/language/aggregate_initialization
List initialization =&gt; cpp/language/list_initialization
Reference initialization =&gt; cpp/language/reference_initialization
Functions =&gt; cpp/language/functions
Function declaration =&gt; cpp/language/function
Default arguments =&gt; cpp/language/default_arguments
Variadic arguments =&gt; cpp/language/variadic_arguments
Lambda expression =&gt; cpp/language/lambda
inline specifier =&gt; cpp/language/inline
Argument-dependent lookup =&gt; cpp/language/adl
Overload resolution =&gt; cpp/language/overload_resolution
Operator overloading =&gt; cpp/language/operators
Address of an overload =&gt; cpp/language/overloaded_address
Exceptions =&gt; cpp/language/exceptions
throw expression =&gt; cpp/language/throw
try-catch block =&gt; cpp/language/try_catch
noexcept specifier =&gt; cpp/language/noexcept_spec
noexcept operator =&gt; cpp/language/noexcept
Exception specification =&gt; cpp/language/except_spec
Classes =&gt; cpp/language/classes
Class types =&gt; cpp/language/class
Union types =&gt; cpp/language/union
Data members =&gt; cpp/language/data_members
Member functions =&gt; cpp/language/member_functions
Static members =&gt; cpp/language/static
Nested types =&gt; cpp/language/nested_types
Member templates =&gt; cpp/language/member_template
Derived class =&gt; cpp/language/derived_class
using-declaration =&gt; cpp/language/using_declaration
Virtual function =&gt; cpp/language/virtual
Abstract class =&gt; cpp/language/abstract_class
Bit fields =&gt; cpp/language/bit_field
this pointer =&gt; cpp/language/this
Access specifiers =&gt; cpp/language/access
friend specifier =&gt; cpp/language/friend
Default constructor =&gt; cpp/language/default_constructor
Copy constructor =&gt; cpp/language/copy_constructor
Copy assignment operator =&gt; cpp/language/as_operator
Destructor =&gt; cpp/language/destructor
Move constructor =&gt; cpp/language/move_constructor
Move assignment operator =&gt; cpp/language/move_operator
Member initializer lists =&gt; cpp/language/initializer_list
Templates =&gt; cpp/language/templates
Class template =&gt; cpp/language/class_template
Function template =&gt; cpp/language/function_template
Variable template =&gt; cpp/language/variable_template
Explicit specialization =&gt; cpp/language/template_specialization
Partial specialization =&gt; cpp/language/partial_specialization
Dependent names =&gt; cpp/language/dependent_name
Parameter packs =&gt; cpp/language/parameter_pack
sizeof... operator =&gt; cpp/language/sizeof...
SFINAE =&gt; cpp/language/sfinae
History of C++ =&gt; cpp/language/history
Inline assembly =&gt; cpp/language/asm
Extending the namespace std =&gt; cpp/language/extending_std
RAII =&gt; cpp/language/raii
Rule of three =&gt; cpp/language/rule_of_three
As-if rule =&gt; cpp/language/as_if
Copy elision =&gt; cpp/language/copy_elision
Empty base optimization =&gt; cpp/language/ebo</text>
      <sha1>lhqo39y33w4v7lkun3le0wofw1xq9xx</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-ColiruCompiler</title>
    <ns>8</ns>
    <id>12902</id>
    <revision>
      <id>64559</id>
      <timestamp>2013-08-20T15:58:03Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="85">Uses [http://coliru.stacked-crooked.com/ Coliru] online compiler for 'run this code'.</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-ShowEditLinks</title>
    <ns>8</ns>
    <id>8419</id>
    <revision>
      <id>30661</id>
      <timestamp>2012-05-07T18:21:42Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+</comment>
      <text xml:space="preserve" bytes="91">Shows edit links in ''dcl lists'' to the pages of included templates (no JavaScript needed)</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-coliru compiler.css</title>
    <ns>8</ns>
    <id>12904</id>
    <revision>
      <id>65047</id>
      <parentid>64744</parentid>
      <timestamp>2013-08-30T14:38:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="1903">.t-example-live-link {
    display: block !important;
    position: relative;
    margin-top: 1em;
    padding: 0 1em;
    width: 55em;
}

.t-example-live-link &gt; a {
    display: none;
}

.coliru-btn {
    background-color: #eeeeee;
    background-image: linear-gradient(#ffffff, #eeeeee);
    background-repeat: repeat-x;
    border: 1px solid #cccccc;
    border-radius: 3px;
    box-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
    padding: 3px;
    margin: 3px;
    color: #333333;
    cursor: pointer;
    display: inline-block;
    font-size: 0.8em;
    font-weight: bold;
    line-height: 1em;
}

.coliru-btn:hover {
    background-color: #dddddd;
    background-image: linear-gradient(#ffffff, #dddddd);
}

.coliru-btn-disabled {
    color: #888888;
}

.coliru-btn-disabled:hover {
    background-color: #eeeeee;
    background-image: linear-gradient(#ffffff, #eeeeee);
}

.coliru-powered {
    font-size: 0.8em;
    position: absolute;
    bottom: 0;
    right: 0;
}

.ace_editor {
    display: block;
    position: relative !important;
    top: 0;
    right: 0;
    bottom: 0;
    left: 0;
    width: 100%;
    height: 30em;
    font-family: DejaVuSansMono, &quot;DejaVu Sans Mono&quot;, courier, monospace !important;
}

.t-example-code {
    margin-top: 0 !important;
}

.coliru-output {
    overflow: auto;
    max-height: 15em;
}

.coliru-output &gt; div {
    display: table;
    width: 100%;
}

.coliru-output pre {
    border: none;
    display: table-row;
    padding: 0;
    margin: 0;
}

.coliru-output-line-shell {
    background-color: #ffd8d8;
}

.coliru-select-compiler select {
    background-color: #EEEEEE;
    background-image: linear-gradient(#FFFFFF, #EEEEEE);
    background-repeat: repeat-x;
    border: 1px solid #CCCCCC;
    border-radius: 3px 3px 3px 3px;
    box-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
    font-size: 0.8em;
    line-height: 1em;
    padding: 0;
    width: 12em;
}</text>
      <sha1/>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-coliru compiler.js</title>
    <ns>8</ns>
    <id>12903</id>
    <revision>
      <id>69353</id>
      <parentid>69352</parentid>
      <timestamp>2014-04-04T00:26:45Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>move wno-newline-eof to clang+C only</comment>
      <text xml:space="preserve" bytes="17833">
String.prototype.trim = function () {
    return this.replace(/^\s+|\s+$/g, &quot;&quot;);
};

/* We add two new divs for the live editor and the program output. The divs are
   inserted after the geshi code and output respectively. This way the ACE
   editor and the compilation output are independent from the static geshi
   text. We can easily switch between the live editor and the static version.
*/
function Editor(root) {

    var cmd_info_cxx = {
        cc: [
            { title: 'GCC 4.6', cmd: 'g++-4.6 -std=c++98 ' },
            { title: 'GCC 4.7', cmd: 'g++-4.7 -std=c++98 ' },
            { title: 'GCC 4.7 (C++11)', cmd: 'g++-4.7 -std=c++11 ' },
            { title: 'GCC 4.8', cmd: 'g++-4.8 -std=c++98 ' },
            { title: 'GCC 4.8 (C++11)', cmd: 'g++-4.8 -std=c++11 ' },
            { title: 'clang 3.4', cmd: 'clang++ -std=c++98 ' },
            { title: 'clang 3.4 (C++11)',
              cmd: 'clang++ -std=c++11 -stdlib=libc++ ',
              opt_suff: ' -lsupc++ '
            }
        ],
        default_id: 4,
        opt: ' -O2 -Wall -Wextra -pedantic -pthread -pedantic-errors main.cpp -lm ',
    }

    var cmd_info_c = {
        cc: [
            { title: 'GCC 4.6', cmd: 'gcc-4.6 -x c -std=c89 ' },
            { title: 'GCC 4.7', cmd: 'gcc-4.7 -x c -std=c89 ' },
            { title: 'GCC 4.8', cmd: 'gcc-4.8 -x c -std=c89 ' },
            { title: 'GCC 4.8 (C99)', cmd: 'g++-4.8 -x c -std=c99 ' },
            { title: 'clang 3.4', cmd: 'clang -x c -std=c89 -Wno-newline-eof ' },
            { title: 'clang 3.4 (C99)', cmd: 'clang++ -x c -std=c99 -Wno-newline-eof '}
        ],
        default_id: 3,
        opt: ' -O2 -Wall -Wextra -pedantic -pthread -pedantic-errors main.cpp -lm ',
    }

    this.check_is_cxx = function() {
        if (mw.config.get('wgTitle').indexOf('c/') == 0) {
            return false;
        } else {
            return true;
        }
    };

    if (this.check_is_cxx()) {
        this.cmd_info = cmd_info_cxx;
    } else {
        this.cmd_info = cmd_info_c;
    }

    this.cmd_run_normal = ' 2&gt;&amp;1 | sed &quot;s/^/☘/&quot;; if [ -x a.out ]; then ./a.out | sed &quot;s/^/☢/&quot;; fi'
    this.cmd_run_share = ' &amp;&amp; ./a.out';

    this.el = {};
    this.el.root = root;
    this.is_orig = true;

    this.el.action_bar = this.el.root.children('.t-example-live-link:first');

    // initialize the action bar
    this.el.run_init_btn = this.el.action_bar.children('.coliru-btn-run-init');
    this.el.run_btn = $('&lt;div&gt;Run&lt;/div&gt;')
                        .addClass('coliru-btn coliru-btn-run')
                        .hide().appendTo(this.el.action_bar);
    this.el.share_btn = $('&lt;div&gt;Share&lt;/div&gt;')
                        .addClass('coliru-btn coliru-btn-share')
                        .hide().appendTo(this.el.action_bar);
    this.el.exit_btn = $('&lt;div&gt;Exit&lt;/div&gt;')
                        .addClass('coliru-btn coliru-btn-exit')
                        .hide().appendTo(this.el.action_bar);

    this.el.cc_select_div = $('&lt;div/&gt;')
                        .addClass('coliru-select-compiler')
                        .hide().appendTo(this.el.action_bar);
    this.el.cc_select = $('&lt;select/&gt;').appendTo(this.el.cc_select_div);

    for (var i = 0; i &lt; this.cmd_info.cc.length; ++i) {
        var cmd = this.cmd_info.cc[i];
        $('&lt;option/&gt;').text(cmd.title).attr('value', i.toString())
                                      .appendTo(this.el.cc_select);
    }
    this.el.cc_select.val(this.cmd_info.default_id.toString());

    this.el.pwr = $('&lt;div&gt;Powered by &lt;a href=&quot;http://coliru.stacked-crooked.com&quot;&gt;Coliru&lt;/a&gt; online compiler&lt;/div&gt;')
                        .addClass('coliru-powered')
                        .hide().appendTo(this.el.action_bar);

    // find and store the original code and output divs
    orig_code = this.el.root.children('.mw-geshi:first');
    if (orig_code.length &gt; 0) {
        this.has_orig_code = true;
        this.el.orig_code = orig_code.first();
    } else {
        this.has_orig_code = false;
        this.el.orig_code = $('&lt;div/&gt;').hide().insertAfter(this.el.action_bar);
    }

    orig_output = this.el.root.children('.mw-geshi:last');
    if (orig_output.length &gt; 0 &amp;&amp; !orig_output.is(orig_code)) {
        this.has_orig_output = true;
        this.el.orig_output = orig_output.first();
    } else {
        this.has_orig_output = false;
        this.el.output_p = $('&lt;p&gt;Output:&lt;/p&gt;').hide().insertAfter(this.el.orig_code);
        this.el.orig_output = $('&lt;div/&gt;').hide().insertAfter(this.el.output_p);
    }

    if (this.has_orig_code) {
        this.source_code = this.el.orig_code.text().replace(/\u00a0/g, &quot; &quot;);
    } else {
        this.source_code = '';
    }

    // initialize the editor
    this.el.edited_code = $('&lt;div/&gt;').addClass('t-example-code mw-geshi')
                                     .hide().insertAfter(this.el.orig_code);
    this.el.editor_div = $('&lt;div/&gt;').addClass('ace_editor ace-tm')
                                    .appendTo(this.el.edited_code);
    this.editor = ace.edit(this.el.editor_div.get(0));
    this.editor.setTheme(&quot;ace/theme/textmate&quot;);
    this.editor.getSession().setMode(&quot;ace/mode/c_cpp&quot;);

    this.editor.commands.bindKeys({&quot;Ctrl-l&quot;:null});
    this.editor.commands.bindKeys({&quot;Ctrl-t&quot;:null});
    this.editor.commands.bindKeys({&quot;Command-l&quot;:null});
    this.editor.commands.addCommand({
        name: 'Build and run',
        bindKey: {win: 'Ctrl-B', mac: 'Command-B'},
        exec: function(editor) { this.compile_now(); },
        readOnly: true
    });
    this.editor.commands.addCommand({
        name: 'Disable Ctrl-S',
        bindKey: {win: 'Ctrl-S', mac: 'Command-S'},
        exec: function(editor) {},
        readOnly: true
    });

    this.editor.getSession().setValue(this.source_code);

    // create compiler output block
    this.el.compiler_output_p = $('&lt;p&gt;Compiler messages:&lt;/p&gt;')
                                  .hide().insertAfter(this.el.edited_code);
    this.el.compiler_output = $('&lt;div/&gt;').addClass('coliru-output coliru-output-compiler mw-geshi')
                                         .hide().insertAfter(this.el.compiler_output_p);
    this.el.compiler_output_div = $('&lt;div/&gt;').appendTo(this.el.compiler_output);

    // create output block
    this.el.edited_output = $('&lt;div/&gt;').addClass('coliru-output coliru-output-program mw-geshi')
                                       .hide().insertAfter(this.el.orig_output);
    this.el.output_div = $('&lt;div/&gt;').appendTo(this.el.edited_output);

    this.reset_editor = function() {
        this.editor.getSession().setValue(this.source_code);
    };

    this.el.run_btn.click(function() {
        if (!this.el.run_btn.hasClass('coliru-btn-disabled')) {
            this.compile_now();
        }
    }.bind(this));
    this.el.share_btn.click(function() {
        if (!this.el.share_btn.hasClass('coliru-btn-disabled')) {
            this.share();
        }
    }.bind(this));
    this.el.exit_btn.click(function() {
        if (!this.el.exit_btn.hasClass('coliru-btn-disabled')) {
            this.restore_orig();
        }
    }.bind(this));

    this.enable_ui = function(value) {
        this.editor.setReadOnly(!value);

        if (value) {
            this.el.run_btn.removeClass('coliru-btn-disabled');
            this.el.share_btn.removeClass('coliru-btn-disabled');
            this.el.exit_btn.removeClass('coliru-btn-disabled');
        } else {
            this.el.run_btn.addClass('coliru-btn-disabled');
            this.el.share_btn.addClass('coliru-btn-disabled');
            this.el.exit_btn.addClass('coliru-btn-disabled');
        }
    };

    this.send = function(location, cmd, src, f) {
        this.enable_ui(false);

        var http_request = new XMLHttpRequest();
        http_request.open(&quot;POST&quot;,
                          &quot;http://coliru.stacked-crooked.com/&quot; + location, true);
        var parent = this;
        http_request.onreadystatechange = function() {
            if (http_request.readyState == 4) {
                parent.enable_ui(true);
                if (http_request.status == 200) {
                    parent.last_result = http_request.responseText.trim();
                    f({src: parent.editor.getValue(),
                       cmd: parent.cmd,
                       output: parent.last_result});
                }
            }
        };
        var post_data = JSON.stringify({
            &quot;cmd&quot; : cmd, &quot;src&quot; : src
        });
        http_request.send(post_data);
    };

    this.compile_now = function() {
        var parent = this;
        this.editor.getSession().clearAnnotations();
        this.el.compiler_output_p.fadeOut('fast');
        this.el.compiler_output.fadeOut('fast');

        this.el.output_div.html('Building and running...');

        var cmd = this.get_cmd(false);
        var src = this.editor.getValue();

        this.send(&quot;compile&quot;, cmd, src, function(obj) {
            var lines = obj.output.split(/\n/);

            // analyze the compiler output
            var annotations = [];
            var annotation_lines = [];

            var program_output = '';
            var compiler_output = '';

            for (var i = 0; i !== lines.length; ++i) {
                var line = lines[i];

                var is_compile_output = false;
                var is_shell_output = false;

                if (line.indexOf('☘') == 0) {
                    is_compile_output = true;
                    line = line.substring(1);
                } else if (line.indexOf('☢') == 0) {
                    line = line.substring(1);
                } else {
                    // everything else comes from the shell. Presumably, this
                    // indicates a serious error in the program
                    // (e.g. it segfaults).
                    // FIXME: probably need a better API
                    is_shell_output = true;
                }

                if (line !== '') {

                    line = line.replace(/&lt;/g, '&amp;lt').replace(/&gt;/g, '&amp;gt');

                    if (is_compile_output) {
                        // check if line contains an error
                        var has_error = false, has_any_error = false;
                        var error_lineno = 0;
                        var error_text = &quot;&quot;;

                        var match = line.match(/^main.cpp:(\d+):\d+:(.*)/);
                        if (match) {
                            has_error = true;
                            error_lineno = parseInt(match[1]);
                            error_text = match[2].trim();
                        }

                        // add annotation if possible
                        if (has_error) {
                            if (annotation_lines.indexOf(error_lineno) === -1) {
                                var error_type = 'error';
                                if (error_text.match(/^warning:/)) {
                                    error_type = 'warning';
                                }

                                annotation_lines.push(error_lineno);
                                annotations.push({row: error_lineno-1, column: 0,
                                                text: error_text, type:error_type});
                            }
                        }

                        // highlight the output line if possible
                        pre_open = '&lt;pre';
                        if (has_error) {
                            pre_open += ' onclick=&quot;window.jump_to_error(this, '
                                    + error_lineno + ')&quot; onmouseover=&quot;window.highlight_error(this, true)&quot; onmouseout=&quot;window.highlight_error(this, false)&quot;';
                        }
                        pre_open += '&gt;';
                        pre_close = '&lt;/pre&gt;';
                        compiler_output += pre_open + line + pre_close;
                    } else if (is_shell_output) {
                        pre_open = '&lt;pre class=&quot;coliru-output-line-shell&quot;&gt;';
                        pre_close = '&lt;/pre&gt;';
                        program_output += pre_open + line + pre_close;
                    } else {
                        pre_open = '&lt;pre class=&quot;coliru-output-line-exe&quot;&gt;';
                        pre_close = '&lt;/pre&gt;';
                        program_output += pre_open + line + pre_close;
                    }
                } else {
                    program_output += '&lt;br/&gt;';
                }
            }

            parent.el.output_div.html(program_output);

            if (compiler_output !== '') {
                parent.el.compiler_output_div.html(compiler_output);
                parent.el.compiler_output_p.fadeIn('fast');
                parent.el.compiler_output.fadeIn('fast');
            }

            // mark the errors in the code
            window.setTimeout(function() {
                parent.editor.getSession().setAnnotations(annotations);
            }, 100);
        });
    };

    this.share = function() {
        var cmd = this.get_cmd(true);
        var src = this.editor.getValue();

        this.send(&quot;share&quot;, cmd, src, function (obj) {
            var url = &quot;http://coliru.stacked-crooked.com/view?id=&quot; + obj.output;
            window.open(url, '_blank');
        })
    };

    this.get_cmd = function(is_shared) {
        var val = this.el.cc_select.val();
        var cc = this.cmd_info.cc[parseInt(val)].cmd;
        cc = cc + this.cmd_info.opt
        if (this.cmd_info.cc[parseInt(val)].opt_suff !== undefined) {
            cc = cc + this.cmd_info.cc[parseInt(val)].opt_suff;
        }
        if (is_shared) {
            return cc + this.cmd_run_share;
        } else {
            return cc + this.cmd_run_normal;
        }
    };

    this.replace_orig = function() {
        if (!this.is_orig) {
            return; // already replaced
        }

        this.el.root.height(this.el.root.height());

        var parent = this;
        this.el.run_init_btn.fadeOut(&quot;fast&quot;, function() {
            parent.el.run_btn.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
            parent.el.share_btn.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
            parent.el.exit_btn.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
            parent.el.cc_select_div.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
            parent.el.pwr.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
        });

        this.el.orig_code.fadeOut(&quot;fast&quot;, function() {
            parent.el.edited_code.fadeIn(&quot;fast&quot;);
        });
        this.el.orig_output.fadeOut(&quot;fast&quot;, function() {
            if (!parent.has_orig_output) {
                parent.el.output_p.fadeIn('fast');
            }
            parent.el.edited_output.fadeIn(&quot;fast&quot;, function() {
                parent.el.root.height('auto');
            });
        });

        this.is_orig = false;
    };

    this.restore_orig = function() {
        if (this.is_orig) {
            return; // already replaced
        }

        this.el.root.height(this.el.root.height());

        var parent = this;

        this.el.run_btn.fadeOut(&quot;fast&quot;, function() {
            parent.el.run_init_btn.fadeIn(&quot;fast&quot;).css(&quot;display&quot;,&quot;inline-block&quot;);
        });
        this.el.share_btn.fadeOut(&quot;fast&quot;);
        this.el.exit_btn.fadeOut(&quot;fast&quot;);
        this.el.cc_select_div.fadeOut(&quot;fast&quot;);
        this.el.pwr.fadeOut(&quot;fast&quot;);

        this.el.edited_code.fadeOut(&quot;fast&quot;, function() {
            parent.el.orig_code.fadeIn(&quot;fast&quot;);
        });

        this.el.compiler_output_p.fadeOut('fast');
        this.el.compiler_output.fadeOut('fast');

        if (!this.has_orig_output) {
            this.el.output_p.fadeOut('fast');
        }

        var parent = this;
        this.el.edited_output.fadeOut(&quot;fast&quot;, function() {
            parent.el.orig_output.fadeIn(&quot;fast&quot;, function() {
                parent.el.root.height('auto');
            });
        });

        this.is_orig = true;
    };

    this.enable_ui(true);
};

function get_script_cached(url, callback) {
    return $.ajax({
            type: &quot;GET&quot;,
            url: url,
            success: callback,
            dataType: &quot;script&quot;,
            cache: true
    });
};

window.highlight_error = function(node, b) {
    node.style.cursor = b ? 'pointer' : 'auto';
};

window.jump_to_error = function(node, lineno) {
    var root = $(node).parents('.t-example');
    if (root.length &gt; 0) {
        for (var i = 0; i &lt; editors.length; ++i) {
            if (editors[i].el.root.is(root)) {
                var editor = editors[i];
                editor.editor.gotoLine(lineno, 0, true);
                editor.editor.focus();
            }
        }
    }
};

var editors = [];

$.when(
    get_script_cached('http://d1n0x3qji82z53.cloudfront.net/src-min-noconflict/ace.js')
).done(function() {
    $.when(
        get_script_cached('http://d1n0x3qji82z53.cloudfront.net/src-min-noconflict/mode-c_cpp.js'),
        $.Deferred(function(deferred) {
            $(deferred.resolve);
        })
    ).done(function() {
        $('.t-example-live-link &gt; a').each(function() {
            $(this).replaceWith('&lt;div class=&quot;coliru-btn coliru-btn-run-init&quot;&gt;Run this code&lt;/div&gt;');
        });
        $('.t-example &gt; .mw-geshi:first').each(function() {
            $(this).addClass('t-example-code');
        });

        $('.coliru-btn-run-init').click(function() {
            var root = $(this).parent().parent();

            // find the editor for this root element
            var i;
            for (i = 0; i &lt; editors.length; ++i) {
                if (editors[i].el.root.is(root)) {
                    break;
                }
            }
            if (i == editors.length) {
                editors[i] = new Editor(root);
            }

            var editor = editors[i];
            editor.replace_orig();
            editor.compile_now();
        });
    });
});</text>
      <sha1>9bam8fboqm5jvi2pwql3eet2ksv4953</sha1>
      <model>javascript</model>
      <format>text/javascript</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-show edit links.css</title>
    <ns>8</ns>
    <id>8417</id>
    <revision>
      <id>61779</id>
      <parentid>61777</parentid>
      <timestamp>2013-06-09T13:54:59Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update</comment>
      <text xml:space="preserve" bytes="280">.t-dsc span.editsection {
    display: inline;
}

.t-par span.editsection {
    display: inline;
}

.t-template-editlink span.editsection {
    display: inline;
}

.t-navbar-menu span.editsection {
    display: inline;
}

.t-page-template span.editsection {
    display: inline;
}</text>
      <sha1/>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-standard revisions.css</title>
    <ns>8</ns>
    <id>12957</id>
    <revision>
      <id>65196</id>
      <timestamp>2013-09-04T23:07:00Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>demo</comment>
      <text xml:space="preserve" bytes="704">
.stdrev-select {
    float: left;
    height: 2.5em;
}

.stdrev-select &gt; div {
    margin: 1.7em 1em 0 0;
    font-size: 0.7em;
}

.stdrev-text {
    display: inline-block;
    margin: 0.15em;
}

.stdrev-select select {
    background-color: #EEEEEE;
    background-image: linear-gradient(#FFFFFF, #EEEEEE);
    background-repeat: repeat-x;
    border: 1px solid #CCCCCC;
    border-radius: 3px 3px 3px 3px;
    box-shadow: 0 1px 0 rgba(255, 255, 255, 0.5);
    font-size: 1.0em;
    line-height: 1em;
    padding: 0;
    width: 6em;
}

.stdrev-rev-hide &gt; tbody &gt; tr &gt; td {
    border: none !important;
    padding: 0 !important;
}

.stdrev-rev-hide &gt; tbody &gt; tr &gt; td:nth-child(2) {
    display: none;
}</text>
      <sha1>csu6b5bm6bxwiv0esityipwwek1t4pj</sha1>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadget-standard revisions.js</title>
    <ns>8</ns>
    <id>12956</id>
    <revision>
      <id>71957</id>
      <parentid>65235</parentid>
      <timestamp>2014-07-04T18:30:14Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>update. see git for changes</comment>
      <text xml:space="preserve" bytes="43395">/*
    Copyright (C) 2013-2014  Povilas Kanapickas &lt;povilas@radix.lt&gt;

    This file is part of cppreference.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see http://www.gnu.org/licenses/.
*/

$(function() {

    var debug = false;

    function array_equal(a, b) {
        var i = a.length;
        if (i != b.length) {
            return false;
        }
        while (i--) {
            if (a[i] !== b[i]) {
                return false;
            }
        }
        return true;
    };

    function array_sort_unique(a) {
        a = a.sort(function(x, y) { return x - y; });
        var c = a[0];
        var res = [c];
        for (var i = 1; i &lt; a.length; i++) {
            if (a[i] !== c) {
                res.push(a[i]);
                c = a[i];
            }
        }
        return res;
    }

    // supports only arrays of bool
    function array_and(a, b) {
        var res = [];
        var length = a.length &lt; b.length ? a.length : b.length;
        for (var i = 0; i &lt; length; i++) {
            res.push(a[i] &amp;&amp; b[i]);
        }
        return res;
    }
    // supports only arrays of bool
    function array_or(a, b) {
        var res = [];
        var length = a.length &lt; b.length ? a.length : b.length;
        for (var i = 0; i &lt; length; i++) {
            res.push(a[i] || b[i]);
        }
        return res;
    }

    if (mw.config.get('wgAction') != 'view') {
        return;
    }
    if (mw.config.get('wgNamespaceNumber') != 0) {
        return;
    }

    /// Are we dealing with C or C++
    var is_cxx = (mw.config.get('wgTitle').indexOf('c/') != 0);

    /// Standard revision identification 'enums'

    var Rev_c = { DIFF: 0, FIRST: 1, C89: 1, C99: 2, C11: 3, LAST: 4 };
    var Rev_cxx = { DIFF: 0, FIRST: 1, CXX98: 1, CXX11: 2, CXX14: 3, LAST: 4 };

    var Rev;

    if (is_cxx) {
        Rev = Rev_cxx;
    } else {
        Rev = Rev_c;
    }

    /// Standard revision description strings
    var desc_c = [
        { rev: Rev.DIFF, title: 'Diff' },
        { rev: Rev.C89, title: 'C89' },
        { rev: Rev.C99, title: 'C99' },
        { rev: Rev.C11, title: 'C11' },
    ];

    var desc_cxx = [
        { rev: Rev.DIFF, title: 'Diff' },
        { rev: Rev.CXX98, title: 'C++98/03' },
        { rev: Rev.CXX11, title: 'C++11' },
        { rev: Rev.CXX14, title: 'C++14' },
    ];

    var desc;

    if (is_cxx) {   // select either C or C++ version
        desc = desc_cxx;
    } else {
        desc = desc_c;
    }

    /// Several helper arrays and functions to identify on which revisions
    /// certain mark is shown.

    var is_shown = [];

    function should_be_shown(rev, mark) {
        if (rev == Rev.DIFF) {
            return true;
        }
        if (mark.since) {
            return (rev &gt;= mark.rev);
        } else {
            return (rev &lt; mark.rev);
        }
    }

    /** Returns mark for element. Use when at most single mark can be present */
    function get_mark_cxx(el) {
        if (el.hasClass('t-since-cxx11')) {
            return { since: true, rev: Rev.CXX11 };
        }
        if (el.hasClass('t-since-cxx14')) {
            return { since: true, rev: Rev.CXX14 };
        }
        if (el.hasClass('t-until-cxx11')) {
            return { since: false, rev: Rev.CXX11 };
        }
        if (el.hasClass('t-until-cxx14')) {
            return { since: false, rev: Rev.CXX14 };
        }
        return { since: true, rev: Rev.CXX98 };
    }

    function get_mark_c(el) {
        if (el.hasClass('t-since-c99')) {
            return { since: true, rev: Rev.C99 };
        }
        if (el.hasClass('t-since-c11')) {
            return { since: true, rev: Rev.C11 };
        }
        if (el.hasClass('t-until-c99')) {
            return { since: false, rev: Rev.C99 };
        }
        if (el.hasClass('t-until-c11')) {
            return { since: false, rev: Rev.C11 };
        }
        return { since: true, rev: Rev.C89 };
    }

    /** Returns an array of revisions (DIFF not included) an element should be
        shown on.
    */
    function is_shown_on_rev_cxx(el) {
        // DIFF: 0, CXX98: 1, CXX11: 2, CXX14: 3
        // DIFF is always false
        if (el.hasClass('t-since-cxx14')) {
            return [false, false, false, true];
        }
        if (el.hasClass('t-since-cxx11')) {
            if (el.hasClass('t-until-cxx14')) {
                return [false, false, true, false];
            }
            return [false, false, true, true];
        }
        if (el.hasClass('t-until-cxx11')) {
            return [false, true, false, false];
        }
        if (el.hasClass('t-until-cxx14')) {
            return [false, true, true, false];
        }
        return [false, true, true, true];
    }

    function is_shown_on_rev_c(el) {
        // DIFF: 0, C89: 1, C99: 2, C11: 3
        // DIFF is always false
        if (el.hasClass('t-since-c11')) {
            return [false, false, false, true];
        }
        if (el.hasClass('t-since-c99')) {
            if (el.hasClass('t-until-c11')) {
                return [false, false, true, false];
            }
            return [false, false, true, true];
        }
        if (el.hasClass('t-until-c99')) {
            return [false, true, false, false];
        }
        if (el.hasClass('t-until-c11')) {
            return [false, true, true, false];
        }
        return [false, true, true, true];
    }

    function is_shown_fill_cxx(val) {
        // DIFF: 0, CXX98: 1, CXX11: 2, CXX14: 3
        return [val, val, val, val];
    }
    function is_shown_fill_c(el) {
        // DIFF: 0, C89: 1, C99: 2, C11: 3
        return [val, val, val, val];
    }

    /// Prints values returned by is_shown_on_rev
    function debug_print_is_shown_on_rev(revs) {
        var out = '{ ';
        for (var i = 0; i &lt; revs.length; i++) {
            if (revs[i]) {
                out += 't';
            } else {
                out += 'f';
            }
        }
        out += ' }';
        return out;
    }

    var get_mark, is_shown_on_rev, is_shown_fill;

    if (is_cxx) {   // select either C or C++ version
        get_mark = get_mark_cxx;
        is_shown_on_rev = is_shown_on_rev_cxx;
        is_shown_fill = is_shown_fill_cxx;
    } else {
        get_mark = get_mark_c;
        is_shown_on_rev = is_shown_on_rev_c;
        is_shown_fill = is_shown_fill_c;
    }

    function get_shown_revs(el) {
        var is_shown = is_shown_on_rev(el);
        var res = [];
        for (var i = Rev.FIRST; i != Rev.LAST; ++i) {
            if (is_shown[i]) {
                res.push(i);
            }
        }
        return res;
    }

    /** Converts array of bool as returned by @c is_shown_on_rev or
        @c is_shown_fill to an array of revisions as accepted by ObjectTracker's
        add_* methods
    */
    function is_shown2revs(revs) {
        var res = [];
        for (var rev = Rev.DIFF; rev != Rev.LAST; ++rev) {
            if (revs[rev]) {
                res.push(rev);
            }
        }
        return res;
    }

    /** This class keeps track of objects that need to be shown or hidden for
        specific standard revision.
    */
    function ObjectTracker() {

        this.all_objects = [];
        // jQuery screws up restoring correct display property
        this.all_display = [];

        this.diff_ids = [];
        this.curr_rev = Rev.DIFF;

        // Maps revisions to object indexes within this.all_objects.
        this.rev2id_map = [];
        for (var i = 0; i &lt; Rev.LAST; ++i) {
            this.rev2id_map[i] = [];
        }

        /** Adds a jQuery object @a obj from the original document DOM. @a revs
            define for which standard revisions to display the object. @a
            display defines the CSS display property to use when the object is
            shown.

            Returns the id of the new object.
        */
        this.add_diff_object = function(obj, revs, display) {
            var id = this.add_object(obj, revs, display);
            this.diff_ids.push(id);
            return id;
        };

        /** Adds a jQuery object @a obj that is newly created, i.e. modified
            version of an object that has been/will be passed to
            add_diff_object. @a revs define for which standard revisions to
            display the object. @a display defines the CSS display property to
            use when the object is shown.

            Returns the id of the new object.
        */
        this.add_object = function(obj, revs, display) {
            var id = this.all_objects.length;
            this.all_objects[id] = obj;
            this.all_display[id] = display;

            for (var i = 0; i &lt; revs.length; ++i) {
                this.rev2id_map[revs[i]].push(id);
            }
            return id;
        };

        /** Changes the visibility of objects */
        this.to_rev = function(rev) {
            if (rev == this.curr_rev) {
                return;
            }
            var visible_before = this.rev2id_map[this.curr_rev];
            var visible_after = this.rev2id_map[rev];

            for (var i = 0; i &lt; visible_before.length; ++i) {
                var curr = visible_before[i];
                if ($.inArray(curr, visible_after) == -1) {
                    this.all_objects[curr].css('display', 'none');
                }
            }
            for (var i = 0; i &lt; visible_after.length; ++i) {
                var curr = visible_after[i];
                if ($.inArray(curr, visible_before) == -1) {
                    this.all_objects[curr].css('display', this.all_display[curr]);
                }
            }
            this.curr_rev = rev;
        };
    };

    function StandardRevisionPlugin() {

        this.el = {};
        this.el.root = $('#mw-content-text').first();
        this.curr_rev = Rev.DIFF;

        this.tracker = new ObjectTracker();
        this.is_prepared = false;

        /** Prepares the navbar for versioning using object tracker. As the
            navbar contains many items, committing each of them to the object
            tracker, we make as many copies of the original navbar as there are
            revisions and customize each copy in-place.
        */
        this.prepare_navbar = function() {
            var nv = this.el.root.children('.t-navbar'); // main navbar
            if (nv.length == 0) {
                return; // no navbar
            }

            this.tracker.add_diff_object(nv, [Rev.DIFF], 'block');

            var self = this;

            for (var rev = Rev.FIRST; rev &lt; Rev.LAST; ++rev) {
                // Create new navbar and insert it to the tracker
                var rev_nv = nv.clone().hide().insertAfter(nv);
                this.tracker.add_object(rev_nv, [rev], 'block');

                // Get interesting elements
                var nv_tables = rev_nv.find('.t-nv-begin');
                var nv_tables_tb = nv_tables.children('tbody');

                var el_h1 = nv_tables_tb.children('.t-nv-h1');
                var el_h2 = nv_tables_tb.children('.t-nv-h2');
                var el_col_tables = nv_tables_tb.children('.t-nv-col-table');
                var el_nv = nv_tables_tb.children('.t-nv');

                // Remove entries from the link tables that should not be visible
                // for the revision in question
                el_nv.each(function(){

                    // Get the link table
                    var link_tds = $(this).find('.t-nv-ln-table div');

                    if (link_tds.length == 0) {
                        // bare nv template used. Check if we don't have a mark
                        // template by chance
                        var marks = $(this).find('.t-mark-rev');
                        if (marks.length &gt; 0) {
                            var mark = get_mark(marks.first());
                            if (!should_be_shown(rev, mark)) {
                                $(this).remove();
                            } else {
                                marks.remove(); // do not show marks in any case
                            }
                        }
                        return;
                    }

                    if (link_tds.length == 1) {
                        // The earliest standard (always visible)
                        return;
                    }
                    var titles = link_tds.first().children().children().first().children();
                    var marks = link_tds.last().children().first().children();

                    // Delete the lines
                    if (self.delete_lines(titles, marks, rev)) {
                        $(this).remove();
                    }
                });

                // Remove all empty column tables
                el_col_tables.each(function() {
                    if ($(this).find('.t-nv').length == 0) {
                        $(this).remove();
                    }
                });

                // Look for any headings that do not have items after them
                el_h2.each(function() {
                    if ($(this).next().length == 0 ||
                        $(this).next().is('.t-nv-h2, .t-nv-h1')
                    ) {
                        $(this).remove();
                    }
                });

                el_h1.each(function() {
                    if ($(this).next().length == 0 ||
                        $(this).next().is('.t-nv-h1')
                    ) {
                        $(this).remove();
                    }
                });

                // TODO: perhaps it's worth to reflow the remaining columns
            }
        };

        /** rev list template can be prepared separately from everything else.
            Additionally, we don't need to copy any parts of the object tree:
            the elements within table rev list just need to be hidder or shown
            depending on the revision
        */
        this.prepare_revs = function() {
            this.rev_tables = $('.t-rev-begin');
            var rev_elems = this.rev_tables.children('tbody').children('.t-rev');
            var self = this;
            rev_elems.each(function() {
                var shown_revs = get_shown_revs($(this));
                shown_revs.push(Rev.DIFF);

                self.tracker.add_object($(this), shown_revs, 'block');
            });
        };

        this.prepare_inl_revs = function() {
            this.rev_inl_elems = $('.t-rev-inl');
            var self = this;
            this.rev_inl_elems.each(function() {
                self.tracker.add_diff_object($(this), [Rev.DIFF], 'inline');

                var shown_revs = get_shown_revs($(this));
                var copy = $(this).children().first().clone().hide()
                                  .insertAfter($(this));

                self.tracker.add_object(copy, shown_revs, 'inline');
            });
        };

        /** Prepares items in dsc lists */
        this.prepare_dscs = function() {
            this.dsc_tables = $('.t-dsc-begin');
            var dsc_elems = this.dsc_tables.children('tbody').children('.t-dsc');

            // FIXME: handle type tables
            var self = this;
            dsc_elems.each(function(){
                var member = $(this).children().children('.t-dsc-member-div');
                if (member.length == 0) {
                    return;
                }
                var lines = member.find('.t-lines');
                if (lines.length != 2) {
                    return;
                }
                var marks = lines.last();

                var rev_map = self.get_revision_map(marks.children());
                self.tracker.add_diff_object($(this), rev_map[Rev.DIFF], 'table-row');

                var sep_rev = rev_map[Rev.DIFF]; // separator visibility
                for (var rev = Rev.FIRST; rev &lt; Rev.LAST; ++rev) {
                    if (rev_map[rev].length == 0) {
                        continue;
                    }
                    sep_rev = sep_rev.concat(rev_map[rev]);

                    var copy = $(this).clone().hide();
                    self.tracker.add_object(copy, rev_map[rev], 'table-row');

                    var member = copy.children().children('.t-dsc-member-div');
                    var lines = member.find('.t-lines');
                    var titles = lines.first().children();
                    var marks = lines.last().children();

                    self.delete_lines(titles, marks, rev);
                    copy.insertAfter($(this));
                }
            });
        };

        /** Prepares items in dcl list identified by @a dcl_table. Returns
            &quot;numbering map&quot;, which defines how the list items are renumbered
            (or deleted) for each revision. The numbering map is a an
            two-dimensional array - the first index identifies the revision,
            the second -- original number. The value obtained this way
            identifies whether the entry should be hidden and if not, what
            version number should be displayed on the specific revision. Hidden
            entry is identified by -1.

            array[revision][orig_num] -&gt; target_num or -1
        */
        this.prepare_dcls = function(dcl_table) {

            var tracker = this.tracker;

            // get abstract description of the contents
            defs = [];

            /*
                &lt;Simple dcl&gt; :== {
                    type: 'i',
                    obj: &lt;jQuery object&gt;

                    // The format is the same as returned by is_shown_on_ref
                    // revs[Rev.DIFF] being true identifies that no versioning
                    // information has been provided.
                    revs: 'shown_revs',

                    // -1 if not defined
                    num: 'orig_num'
                }

                &lt;Rev-list dcl&gt; :== {
                    type: 'r',
                    obj: &lt;jQuery object&gt;,
                    revs: 'shown_revs',  // see notes for &lt;Simple dcl&gt;
                    num: 'orig_num',     // -1 if not defined
                    aux: &lt;jQuery object&gt;, // potentially empty

                    // The list of indexes of entries in defs array identifying
                    // children dcls
                    children: [ &lt;child id&gt;, ... ]
                }

                defs: [ &lt;either Simple dcl or rev-list dcl&gt;, ... ]

                If rev-list dcl has 'revs' defined, then those override revs for
                all children dcls.

                If rev-list dcl has 'num' defined, then 'num' for all children
                dcls is -1.
            */
            var num_regex = /\s*\((\d+)\)\s*/;
            function process_tr(el, is_num_overridden, is_rev_overridden,
                                overridden_revs) {
                var new_def = {
                    type: 's',
                    obj: el,
                    num: -1,
                    revs: is_shown_fill(true)
                };

                // get version num
                if (!is_num_overridden) {
                    var num_text = el.children('td').eq(1).text();
                    var match = num_text.match(num_regex);
                    if (match !== null) {
                        new_def.num = parseInt(match[1]);
                    }
                }

                // get revision info
                if (!is_rev_overridden) {
                    var notes_td = el.children('td').eq(2);
                    if (notes_td.find('.t-mark-rev').length &gt; 0) {
                        new_def.revs = is_shown_on_rev(el);
                    }
                } else {
                    new_def.revs = overridden_revs;
                }

                return defs.push(new_def) - 1;
            };

            function process_rev_tbody(el) {
                var new_def = {
                    type: 'r',
                    obj: el,
                    num: -1,
                    revs: is_shown_fill(true),
                    children: []
                };

                // potentially empty
                var aux_tr = el.children('.t-dcl-rev-aux').first();
                new_def.aux = aux_tr;

                // get version num
                var has_num = false;
                if (el.hasClass('t-dcl-rev-num')) {
                    var num_text = aux_tr.children('td').eq(1).text();
                    var match = num_text.match(num_regex);
                    if (match !== null) {
                        new_def.num = parseInt(match[1]);
                        has_num = true;
                    }
                }

                // get revision info
                var has_revs = false;
                if (el.hasClass('t-dcl-rev-notes')) {
                    var mark_revs = aux_tr.children('td').eq(2).find('.t-mark-rev');
                    if (mark_revs.length &gt; 0) {
                        new_def.revs = is_shown_on_rev(el);
                        has_revs = true;
                    }
                }

                // process the member dcls
                el.children('.t-dcl').each(function() {
                    var new_id = process_tr($(this), has_num, has_revs,
                                            new_def.revs.slice());
                    new_def.children.push(new_id);
                });

                defs.push(new_def);
            };

            $(dcl_table).children('tbody').each(function() {
                if ($(this).hasClass('t-dcl-rev')) {
                    process_rev_tbody($(this));
                } else {
                    $(this).children('.t-dcl').each(function() {
                        process_tr($(this), false, false, []);
                    });
                }
            });

            // Prints defs to a string
            function debug_print_defs(defs) {
                var out = '';
                for (var i = 0; i &lt; defs.length; i++) {
                    out += ' { ' + i + ': ' + defs[i].type + ' ' + defs[i].num;
                    out += ' ' + debug_print_is_shown_on_rev(defs[i].revs);
                    if (defs[i].type == 'r') {
                        out += ' { ';
                        for (var j = 0 ; j &lt; defs[i].children.length; ++j) {
                            out += defs[i].children[j] + ' ';
                        }
                        out += '}';
                    }
                    out += ' }\n';
                }
                return out;
            }

            /* Get the mapping between revisions and function version numbers.
               The function returns an array:

               array[revision][source version number] -&gt; version number to display
            */
            function get_num_map() {
                var num_map = [];

                // We need the maximum visible num to initialize the result array
                // properly
                var max_num = -1;
                for (var i = 0; i &lt; defs.length; ++i) {
                    if (defs[i].num &gt; max_num) {
                        max_num = defs[i].num;
                    }
                }

                if (max_num &gt; -1) {

                    for (var rev = Rev.FIRST; rev != Rev.LAST; ++rev) {

                        var visible_nums = [];

                        for (var i = 0; i &lt; defs.length; ++i) {
                            if (defs[i].revs[rev] == true &amp;&amp;
                                defs[i].num != -1) {
                                visible_nums.push(defs[i].num);
                            }
                        }

                        visible_nums = array_sort_unique(visible_nums);

                        var curr_map = [-1];
                        for (var num = 1; num &lt;= max_num; ++num) {
                            curr_map[num] = -1;
                        }

                        var curr_num = 1;
                        for (var i = 0; i &lt; visible_nums.length; ++i) {
                            curr_map[visible_nums[i]] = curr_num;
                            curr_num++;
                        }
                        num_map[rev] = curr_map;
                    }
                }
                return num_map;
            };

            // Prints num_map to a string
            function debug_print_num_map(num_map) {
                var out = '';
                for (var rev = Rev.FIRST; rev != Rev.LAST; ++rev) {
                    out += '[' + desc[rev].title + ']: { ';
                    out +=  num_map[rev] + ' }\n';
                }
                return out;
            }

            var num_map = get_num_map();

            if (debug) {
                alert(debug_print_defs(defs) + '\n\n' +
                      debug_print_num_map(num_map));
            }

            // Analyze the abstract description again and modify the DOM
            function clear_rev_marks(tr) {
                marks = tr.children('td').eq(2).find('.t-mark-rev');
                marks.each(function() {
                    // remove only one &lt;br&gt;
                    $(this).prev('br').add($(this).next('br')).first().remove();
                    $(this).remove();
                });
            };

            function set_number(tr, num) {
                tr.children('td').eq(1).text('('+num.toString()+')');
            };

            function get_tr_nums(num) {
                var nums = [];
                for (var rev = Rev.FIRST; rev != Rev.LAST; ++rev) {
                    nums[rev] = num_map[rev][num];
                }
                return nums;
            };

            /// Checks whether any children of a rev-list identified by @a def
            /// are shown in revision @a rev
            function is_children_shown_on_rev(def) {
                var res = is_shown_fill(false);

                for (var i = 0; i != def.children.length; ++i) {
                    res = array_or(res, defs[def.children[i]].revs);
                }
                res[Rev.DIFF] = false;
                return res;
            };

            /** Returns infomation about the required copies of the base
                element.
            */
            function get_copy_info(revs, nums) {
                var res = [];

                var base_rev;   // Don't create a new element if it would
                var new_num;    // be identical to previous one
                var new_revs;
                var is_first = true;

                for (var rev = Rev.FIRST; rev != Rev.LAST; ++rev) {
                    if (!revs[rev]) {
                        continue;
                    }
                    if (!is_first &amp;&amp; new_num == nums[rev]) {
                        // Identical element already exists
                        new_revs.push(rev);
                        continue;
                    }

                    if (!is_first) {
                        res.push({ base_rev: base_rev, revs: new_revs,
                                   num: new_num });
                    }

                    base_rev = rev;
                    new_num = nums[rev];
                    new_revs = [rev];
                    is_first = false;
                }
                if (!is_first) {
                    res.push({ base_rev: base_rev, revs: new_revs,
                               num: new_num });
                }
                return res;
            };

            function finalize_tr(def) {
                var sep_revs;

                if (def.num == -1) {
                    var tr_revs = is_shown2revs(def.revs);
                    sep_revs = tr_revs;
                    if (def.revs[Rev.DIFF] == true) {
                        // no num and no rev-marks -- shown always
                        tracker.add_diff_object(def.obj, tr_revs, 'table-row');
                    } else {
                        // no num -- two versions: one with rev-marks and
                        // one without
                        var new_el = def.obj.clone().hide().insertAfter(def.obj);
                        clear_rev_marks(new_el);
                        tracker.add_diff_object(def.obj, [Rev.DIFF], 'table-row');
                        tracker.add_object(new_el, tr_revs, 'table-row');
                        sep_revs.push(Rev.DIFF);
                    }
                } else {
                    // need to handle numbering
                    var nums = get_tr_nums(def.num);

                    tracker.add_diff_object(def.obj, [Rev.DIFF], 'table-row');

                    var copy_info = get_copy_info(def.revs, nums);

                    sep_revs = [Rev.DIFF];
                    for (var i = 0; i &lt; copy_info.length; i++) {
                        var new_el = def.obj.clone().hide().insertAfter(def.obj);
                        clear_rev_marks(new_el);
                        set_number(new_el, copy_info[i].num);
                        tracker.add_object(new_el, copy_info[i].revs, 'table-row');
                        sep_revs = sep_revs.concat(copy_info[i].revs);
                    }
                }
            };

            // Roughly the same as finalize_tr, but while all modifications are
            // applied to the t-dcl-rev-aux element, we hide entire tbody
            // section when it has no contents or defs[i].revs[rev] == false
            function finalize_rev_tbody(def) {
                // The rev-list tbody does not ever change - we only need to
                // hide it sometimes
                var tbody_revs = array_and(def.revs, is_children_shown_on_rev(def));
                tbody_revs[Rev.DIFF] = true;
                tracker.add_diff_object(def.obj, is_shown2revs(tbody_revs), 'table-row');

                if (def.num == -1) {
                    if (def.revs[Rev.DIFF] == true) {
                        // No num and no rev-marks -- no further modifications
                        // needed.

                    } else {
                        // No num -- two versions: one with rev-marks and
                        // one without
                        var new_el = def.aux.clone().hide().insertAfter(def.aux);
                        clear_rev_marks(new_el);
                        tracker.add_diff_object(def.aux, [Rev.DIFF], 'table-row');
                        var revs = tbody_revs.slice();
                        revs[Rev.DIFF] = false;

                        tracker.add_object(new_el, is_shown2revs(revs), 'table-row');
                    }
                } else {
                    // need to handle numbering
                    var nums = get_tr_nums(def.num);

                    tracker.add_diff_object(def.aux, [Rev.DIFF], 'table-row');

                    var copy_info = get_copy_info(def.revs, nums);

                    for (var i = 0; i &lt; copy_info.length; i++) {
                        var new_el = def.aux.clone().hide().insertAfter(def.aux);
                        clear_rev_marks(new_el);
                        set_number(new_el, copy_info[i].num);
                        tracker.add_object(new_el, copy_info[i].revs, 'table-row');
                    }
                }
            };


            for (var i = 0; i &lt; defs.length; ++i) {
                if (defs[i].type == 's') {
                    finalize_tr(defs[i]);
                } else {
                    finalize_rev_tbody(defs[i]);
                }
            }

            return num_map;
        };

        /** Renumbers and hides the list items according to the given @a num_map
        */
        this.prepare_li = function(num_map) {
            // FIXME: currently we process only the first t-li element out of
            // each block of elements assigned a single num.
            var el_li = $('.t-li1').add($('.t-li2')).add($('.t-li3'));

            var descs = [];
            /*
               { obj: &lt;jQuery object&gt;,
                 obj_num: &lt;jQuery object&gt;
                 num: [&lt;num&gt;, &lt;num&gt;, ...],
               }
            */
            var num_regex = /^\s*(\d+)\s*$/;
            var range_regex = /^\s*(\d+)-(\d+)\s*$/;
            el_li.each(function() {
                var el_num = $(this).children().first('.t-li');
                if (el_num.length == 0) {
                    return;
                }

                var nums = [];
                var items = el_num.text().replace(')','').split(',');
                for (var i = 0; i &lt; items.length; ++i) {
                    var match = items[i].match(num_regex);
                    if (match !== null) {
                        nums.push(parseInt(match[1]));
                        continue;
                    }
                    match = items[i].match(range_regex);
                    if (match !== null) {
                        var first = parseInt(match[1]);
                        var last = parseInt(match[2]);
                        if (first &gt; last) {
                            continue;
                        }
                        for (; first &lt;= last; ++first) {
                            nums.push(first);
                        }
                        continue;
                    }
                }

                if (nums.length != 0) {
                    descs.push({ obj: $(this), nums: nums, obj_num: el_num });
                }
            });


            for (var i = 0; i &lt; descs.length; ++i) {
                var nums = descs[i].nums;

                // get the description of what numbers to display for which
                // revision

                var revs_show = is_shown_fill(true);
                var revs_show_all = true;

                var disp_desc = [];
                var prev_nums = nums;
                var prev_revs = [ Rev.DIFF ];

                for (var rev = Rev.FIRST; rev != Rev.LAST; ++rev) {
                    var target_nums = [];
                    for (var j = 0; j &lt; nums.length; ++j) {
                        if (nums[j] &lt; num_map[rev].length) {
                            var target_num = num_map[rev][nums[j]];
                            if (target_num != -1) {
                                target_nums.push(target_num);
                            }
                        }
                    }

                    if (target_nums.length == 0) {
                        // will hide entire t-liX element
                        revs_show[rev] = false;
                        revs_show_all = false;
                        continue;
                    }

                    if (array_equal(target_nums, prev_nums)) {
                        prev_revs.push(rev);
                    } else {
                        disp_desc.push({ revs: prev_revs, nums: prev_nums });
                        prev_revs = [rev];
                        prev_nums = target_nums;
                    }
                }
                disp_desc.push({ revs: prev_revs, nums: prev_nums });
                // hide entire t-liX element if needed
                if (!revs_show_all) {
                    this.tracker.add_diff_object(descs[i].obj,
                                                 is_shown2revs(revs_show),
                                                 'block');
                }

                // Add t-li elements with different text if needed
                // the first item always includes Rev.DIFF in .revs
                if (disp_desc.length &gt; 1) {
                    this.tracker.add_diff_object(descs[i].obj_num, disp_desc[0].revs,
                                                 'inline-block');
                    for (var j = 1; j &lt; disp_desc.length; ++j) {
                        var new_el = descs[i].obj_num.clone().hide()
                                            .insertAfter(descs[i].obj_num);
                        var text = disp_desc[j].nums[0].toString();
                        // TODO: reduce to ranges
                        for (var k = 1; k &lt; disp_desc[j].nums.length; ++k) {
                            text = text + ',' + disp_desc[j].nums[k].toString();
                        }
                        new_el.text(text + ')');
                        this.tracker.add_object(new_el, disp_desc[j].revs,
                                                'inline-block');
                    }
                }
            }
        };

        this.prepare = function() {
            if (this.is_prepared) {
                return;
            }
            this.prepare_navbar();
            this.prepare_revs();
            this.prepare_inl_revs();
            this.prepare_dscs();

            var dcl_tables = $('.t-dcl-begin');
            if (dcl_tables.length &gt; 0) {
                var num_map = this.prepare_dcls(dcl_tables.first());
                this.prepare_li(num_map);
            }
            this.is_prepared = true;
        };

        /** Returns an a list of revisions for which a the node should be copied
            and for which revisions each of the copy would be shown.
        */
        this.get_revision_map = function(lines) {
            var res = [];
            res[Rev.DIFF] = [Rev.DIFF];

            var is_shown = [];

            // create separate elements when diff has rev marks
            var is_diff_clean = true;

            lines.each(function() {
                var rev_mark = $(this).find('.t-mark-rev').first();
                is_shown.push(is_shown_on_rev(rev_mark));
                if (rev_mark.length &gt; 0) {
                    is_diff_clean = false;
                }
            });

            // Track the lines shown in the previous revision. If the same lines
            // are shown in the current revision, simply display the element
            // of the previous revision, instead of creating a new one.
            var prev_rev = Rev.DIFF;
            var prev_visible = [];
            if (is_diff_clean) {
                // any further revisions will match this this array only if
                // original version of the element does not contain rev marks
                for (var i = 0; i &lt; is_shown.length; i++) {
                    prev_visible.push(i); // DIFF shows all lines
                }
            }

            for (var rev = Rev.FIRST; rev &lt; Rev.LAST; ++rev) {
                res[rev] = [];

                var curr_visible = [];
                for (var i = 0; i &lt; is_shown.length; i++) {
                    if (is_shown[i][rev] == true) {
                        curr_visible.push(i);
                    }
                }

                if (curr_visible.length == 0) {
                    continue;
                }

                // Maybe nothing has changed from the previous revision and we
                // can simply keep the node created for the previus revision
                if (array_equal(curr_visible, prev_visible)) {
                    res[prev_rev].push(rev);
                } else {
                    res[rev].push(rev);
                    prev_visible = curr_visible;
                    prev_rev = rev;
                }
            }

            return res;
        };

        /** Deletes lines from multi-line links that have marks nearby.
            Returns true if no lines are left. @a titles and @a marks must both
            refer to the children of .t-lines elements.
         */
        this.delete_lines = function(titles, marks, rev) {
            // Delete the lines
            var num_deleted = 0;
            var num_total = titles.length;

            marks.each(function(index) {
                var mark_span = $(this).children('.t-mark-rev');
                if (mark_span.length &gt; 0) {
                    var mark = get_mark(mark_span.first());
                    if (!should_be_shown(rev, mark)) {
                        titles.eq(index).remove();
                        $(this).remove();
                        num_deleted++;
                        return;
                    }
                }
                mark_span.remove(); // delete marks in any case
            });

            // Delete this if empty
            return (num_deleted == num_total);
        };

        /** Creates the standard revision selection box
        */
        this.create_selection_box = function() {
            var head_parent = $('#cpp-head-tools-right');

            this.el.select_div = $('&lt;div/&gt;').addClass('stdrev-select');

            var inner_div = $('&lt;div/&gt;').appendTo(this.el.select_div);
            var span = $('&lt;span/&gt;').addClass('stdrev-text')
                                   .text('Standard revision: ')
                                   .appendTo(inner_div);
            this.el.select = $('&lt;select/&gt;').appendTo(inner_div);

            for (var i = 0; i &lt; desc.length; ++i) {
                $('&lt;option/&gt;').text(desc[i].title)
                              .attr('value', desc[i].rev.toString())
                              .appendTo(this.el.select);
            }

            this.el.select.one('mouseover', this.prepare.bind(this));
            this.el.select.change(this.on_selection_change.bind(this));
            this.el.select_div.prependTo(head_parent);
        };

        /** Callback to be run when the user changes the option selected in the
            selection box
        */
        this.on_selection_change = function() {
            var rev = parseInt(this.el.select.val());
            this.tracker.to_rev(rev);

            // special treatment for rev boxes
            if (this.curr_rev == Rev.DIFF &amp;&amp; rev != Rev.DIFF) {
                this.rev_tables.each(function() {
                    $(this).addClass('stdrev-rev-hide');
                });
            }
            if (this.curr_rev != Rev.DIFF &amp;&amp; rev == Rev.DIFF) {
                this.rev_tables.each(function() {
                    $(this).removeClass('stdrev-rev-hide');
                });
            }

            this.curr_rev = rev;
        }
    };

    /** Each instance of this class is responsible for versioning either member
        'scopes' (those within {{member}} templates) or the main scope (everything
        what's left)
    */
    function Scope(root, is_main) {

    };

    // get the important elements of the page
    this.get_core_elements = function() {
        this.el.root = $('#mw-content-text');j
        this.el.dcl_tables = this.el.root.find('.t-dcl-begin');
        this.el.dcl_rev_tables = this.el.dcl_tables.filter('.t-dcl-rev-begin');
        this.el.dsc_tables = this.el.root.find('.t-dsc-begin');
        this.el.rev_tables = this.el.root.find('.t-rev-begin');
        this.el.rev_inl_tables = this.el.root.find('.t-rev-inl');
        this.el.list_items = this.el.root.find('.t-li');
    };

    var plugin = new StandardRevisionPlugin();
    plugin.create_selection_box();

});</text>
      <sha1>q19rautd2l2x2aq4ua1ojj7pwelbyc7</sha1>
      <model>javascript</model>
      <format>text/javascript</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Gadgets-definition</title>
    <ns>8</ns>
    <id>8418</id>
    <revision>
      <id>65233</id>
      <parentid>64747</parentid>
      <timestamp>2013-09-04T23:36:28Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>+standard revisions</comment>
      <text xml:space="preserve" bytes="212">* ShowEditLinks[ResourceLoader]|show_edit_links.css
* ColiruCompiler[ResourceLoader|default]|coliru_compiler.js|coliru_compiler.css
* StandardRevisions[ResourceLoader]|standard_revisions.js|standard_revisions.css</text>
      <sha1>k0wnen6v531kdvpfmlfzp8py6e6m4it</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Geshi-keyword-list-c</title>
    <ns>8</ns>
    <id>9558</id>
    <revision>
      <id>71783</id>
      <parentid>47018</parentid>
      <timestamp>2014-06-24T01:45:40Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/FE_UNHERFLOW/FE_UNDERFLOW</comment>
      <text xml:space="preserve" bytes="29682">size_t =&gt; cpp/types/size_t
ptrdiff_t =&gt; cpp/types/ptrdiff_t
nullptr_t =&gt; cpp/types/nullptr_t
NULL =&gt; cpp/types/NULL
max_align_t =&gt; cpp/types/max_align_t
offsetof =&gt; cpp/types/offsetof
int8_t =&gt; c/types/integer
int16_t =&gt; c/types/integer
int32_t =&gt; c/types/integer
int64_t =&gt; c/types/integer
int_fast8_t =&gt; c/types/integer
int_fast16_t =&gt; c/types/integer
int_fast32_t =&gt; c/types/integer
int_fast64_t =&gt; c/types/integer
int_least8_t =&gt; c/types/integer
int_least16_t =&gt; c/types/integer
int_least32_t =&gt; c/types/integer
int_least64_t =&gt; c/types/integer
intmax_t =&gt; c/types/integer
intptr_t =&gt; c/types/integer
uint8_t =&gt; c/types/integer
uint16_t =&gt; c/types/integer
uint32_t =&gt; c/types/integer
uint64_t =&gt; c/types/integer
uint_fast8_t =&gt; c/types/integer
uint_fast16_t =&gt; c/types/integer
uint_fast32_t =&gt; c/types/integer
uint_fast64_t =&gt; c/types/integer
uint_least8_t =&gt; c/types/integer
uint_least16_t =&gt; c/types/integer
uint_least32_t =&gt; c/types/integer
uint_least64_t =&gt; c/types/integer
uintmax_t =&gt; c/types/integer
uintptr_t =&gt; c/types/integer
INT8_MIN =&gt; c/types/integer
INT16_MIN =&gt; c/types/integer
INT32_MIN =&gt; c/types/integer
INT64_MIN =&gt; c/types/integer
INT_FAST8_MIN =&gt; c/types/integer
INT_FAST16_MIN =&gt; c/types/integer
INT_FAST32_MIN =&gt; c/types/integer
INT_FAST64_MIN =&gt; c/types/integer
INT_LEAST8_MIN =&gt; c/types/integer
INT_LEAST16_MIN =&gt; c/types/integer
INT_LEAST32_MIN =&gt; c/types/integer
INT_LEAST64_MIN =&gt; c/types/integer
INTPTR_MIN =&gt; c/types/integer
INTMAX_MIN =&gt; c/types/integer
INT8_MAX =&gt; c/types/integer
INT16_MAX =&gt; c/types/integer
INT32_MAX =&gt; c/types/integer
INT64_MAX =&gt; c/types/integer
INT_FAST8_MAX =&gt; c/types/integer
INT_FAST16_MAX =&gt; c/types/integer
INT_FAST32_MAX =&gt; c/types/integer
INT_FAST64_MAX =&gt; c/types/integer
INT_LEAST8_MAX =&gt; c/types/integer
INT_LEAST16_MAX =&gt; c/types/integer
INT_LEAST32_MAX =&gt; c/types/integer
INT_LEAST64_MAX =&gt; c/types/integer
INTPTR_MAX =&gt; c/types/integer
INTMAX_MAX =&gt; c/types/integer
UINT8_MAX =&gt; c/types/integer
UINT16_MAX =&gt; c/types/integer
UINT32_MAX =&gt; c/types/integer
UINT64_MAX =&gt; c/types/integer
UINT_FAST8_MAX =&gt; c/types/integer
UINT_FAST16_MAX =&gt; c/types/integer
UINT_FAST32_MAX =&gt; c/types/integer
UINT_FAST64_MAX =&gt; c/types/integer
UINT_LEAST8_MAX =&gt; c/types/integer
UINT_LEAST16_MAX =&gt; c/types/integer
UINT_LEAST32_MAX =&gt; c/types/integer
UINT_LEAST64_MAX =&gt; c/types/integer
UINTPTR_MAX =&gt; c/types/integer
UINTMAX_MAX =&gt; c/types/integer
PRId8 =&gt; c/types/integer
PRId16 =&gt; c/types/integer
PRId32 =&gt; c/types/integer
PRId64 =&gt; c/types/integer
PRIdLEAST8 =&gt; c/types/integer
PRIdLEAST16 =&gt; c/types/integer
PRIdLEAST32 =&gt; c/types/integer
PRIdLEAST64 =&gt; c/types/integer
PRIdFAST8 =&gt; c/types/integer
PRIdFAST16 =&gt; c/types/integer
PRIdFAST32 =&gt; c/types/integer
PRIdFAST64 =&gt; c/types/integer
PRIdMAX =&gt; c/types/integer
PRIdPTR  =&gt; c/types/integer
PRIi8 =&gt; c/types/integer
PRIi16 =&gt; c/types/integer
PRIi32 =&gt; c/types/integer
PRIi64 =&gt; c/types/integer
PRIiLEAST8 =&gt; c/types/integer
PRIiLEAST16 =&gt; c/types/integer
PRIiLEAST32 =&gt; c/types/integer
PRIiLEAST64 =&gt; c/types/integer
PRIiFAST8 =&gt; c/types/integer
PRIiFAST16 =&gt; c/types/integer
PRIiFAST32 =&gt; c/types/integer
PRIiFAST64 =&gt; c/types/integer
PRIiMAX =&gt; c/types/integer
PRIiPTR  =&gt; c/types/integer
PRIu8 =&gt; c/types/integer
PRIu16 =&gt; c/types/integer
PRIu32 =&gt; c/types/integer
PRIu64 =&gt; c/types/integer
PRIuLEAST8 =&gt; c/types/integer
PRIuLEAST16 =&gt; c/types/integer
PRIuLEAST32 =&gt; c/types/integer
PRIuLEAST64 =&gt; c/types/integer
PRIuFAST8 =&gt; c/types/integer
PRIuFAST16 =&gt; c/types/integer
PRIuFAST32 =&gt; c/types/integer
PRIuFAST64 =&gt; c/types/integer
PRIuMAX =&gt; c/types/integer
PRIuPTR  =&gt; c/types/integer
PRIo8 =&gt; c/types/integer
PRIo16 =&gt; c/types/integer
PRIo32 =&gt; c/types/integer
PRIo64 =&gt; c/types/integer
PRIoLEAST8 =&gt; c/types/integer
PRIoLEAST16 =&gt; c/types/integer
PRIoLEAST32 =&gt; c/types/integer
PRIoLEAST64 =&gt; c/types/integer
PRIoFAST8 =&gt; c/types/integer
PRIoFAST16 =&gt; c/types/integer
PRIoFAST32 =&gt; c/types/integer
PRIoFAST64 =&gt; c/types/integer
PRIoMAX =&gt; c/types/integer
PRIoPTR  =&gt; c/types/integer
PRIx8 =&gt; c/types/integer
PRIx16 =&gt; c/types/integer
PRIx32 =&gt; c/types/integer
PRIx64 =&gt; c/types/integer
PRIxLEAST8 =&gt; c/types/integer
PRIxLEAST16 =&gt; c/types/integer
PRIxLEAST32 =&gt; c/types/integer
PRIxLEAST64 =&gt; c/types/integer
PRIxFAST8 =&gt; c/types/integer
PRIxFAST16 =&gt; c/types/integer
PRIxFAST32 =&gt; c/types/integer
PRIxFAST64 =&gt; c/types/integer
PRIxMAX =&gt; c/types/integer
PRIxPTR  =&gt; c/types/integer
PRIX8 =&gt; c/types/integer
PRIX16 =&gt; c/types/integer
PRIX32 =&gt; c/types/integer
PRIX64 =&gt; c/types/integer
PRIXLEAST8 =&gt; c/types/integer
PRIXLEAST16 =&gt; c/types/integer
PRIXLEAST32 =&gt; c/types/integer
PRIXLEAST64 =&gt; c/types/integer
PRIXFAST8 =&gt; c/types/integer
PRIXFAST16 =&gt; c/types/integer
PRIXFAST32 =&gt; c/types/integer
PRIXFAST64 =&gt; c/types/integer
PRIXMAX =&gt; c/types/integer
PRIXPTR  =&gt; c/types/integer
SCNd8 =&gt; c/types/integer
SCNd16 =&gt; c/types/integer
SCNd32 =&gt; c/types/integer
SCNd64 =&gt; c/types/integer
SCNdLEAST8 =&gt; c/types/integer
SCNdLEAST16 =&gt; c/types/integer
SCNdLEAST32 =&gt; c/types/integer
SCNdLEAST64 =&gt; c/types/integer
SCNdFAST8 =&gt; c/types/integer
SCNdFAST16 =&gt; c/types/integer
SCNdFAST32 =&gt; c/types/integer
SCNdFAST64 =&gt; c/types/integer
SCNdMAX =&gt; c/types/integer
SCNdPTR  =&gt; c/types/integer
SCNi8 =&gt; c/types/integer
SCNi16 =&gt; c/types/integer
SCNi32 =&gt; c/types/integer
SCNi64 =&gt; c/types/integer
SCNiLEAST8 =&gt; c/types/integer
SCNiLEAST16 =&gt; c/types/integer
SCNiLEAST32 =&gt; c/types/integer
SCNiLEAST64 =&gt; c/types/integer
SCNiFAST8 =&gt; c/types/integer
SCNiFAST16 =&gt; c/types/integer
SCNiFAST32 =&gt; c/types/integer
SCNiFAST64 =&gt; c/types/integer
SCNiMAX =&gt; c/types/integer
SCNiPTR  =&gt; c/types/integer
SCNu8 =&gt; c/types/integer
SCNu16 =&gt; c/types/integer
SCNu32 =&gt; c/types/integer
SCNu64 =&gt; c/types/integer
SCNuLEAST8 =&gt; c/types/integer
SCNuLEAST16 =&gt; c/types/integer
SCNuLEAST32 =&gt; c/types/integer
SCNuLEAST64 =&gt; c/types/integer
SCNuFAST8 =&gt; c/types/integer
SCNuFAST16 =&gt; c/types/integer
SCNuFAST32 =&gt; c/types/integer
SCNuFAST64 =&gt; c/types/integer
SCNuMAX =&gt; c/types/integer
SCNuPTR  =&gt; c/types/integer
SCNo8 =&gt; c/types/integer
SCNo16 =&gt; c/types/integer
SCNo32 =&gt; c/types/integer
SCNo64 =&gt; c/types/integer
SCNoLEAST8 =&gt; c/types/integer
SCNoLEAST16 =&gt; c/types/integer
SCNoLEAST32 =&gt; c/types/integer
SCNoLEAST64 =&gt; c/types/integer
SCNoFAST8 =&gt; c/types/integer
SCNoFAST16 =&gt; c/types/integer
SCNoFAST32 =&gt; c/types/integer
SCNoFAST64 =&gt; c/types/integer
SCNoMAX =&gt; c/types/integer
SCNoPTR  =&gt; c/types/integer
SCNx8 =&gt; c/types/integer
SCNx16 =&gt; c/types/integer
SCNx32 =&gt; c/types/integer
SCNx64 =&gt; c/types/integer
SCNxLEAST8 =&gt; c/types/integer
SCNxLEAST16 =&gt; c/types/integer
SCNxLEAST32 =&gt; c/types/integer
SCNxLEAST64 =&gt; c/types/integer
SCNxFAST8 =&gt; c/types/integer
SCNxFAST16 =&gt; c/types/integer
SCNxFAST32 =&gt; c/types/integer
SCNxFAST64 =&gt; c/types/integer
SCNxMAX =&gt; c/types/integer
SCNxPTR  =&gt; c/types/integer
SCNX8 =&gt; c/types/integer
SCNX16 =&gt; c/types/integer
SCNX32 =&gt; c/types/integer
SCNX64 =&gt; c/types/integer
SCNXLEAST8 =&gt; c/types/integer
SCNXLEAST16 =&gt; c/types/integer
SCNXLEAST32 =&gt; c/types/integer
SCNXLEAST64 =&gt; c/types/integer
SCNXFAST8 =&gt; c/types/integer
SCNXFAST16 =&gt; c/types/integer
SCNXFAST32 =&gt; c/types/integer
SCNXFAST64 =&gt; c/types/integer
SCNXMAX =&gt; c/types/integer
SCNXPTR =&gt; c/types/integer
PTRDIFF_MIN =&gt; c/types/limits
PTRDIFF_MAX =&gt; c/types/limits
SIZE_MAX =&gt; c/types/limits
SIG_ATOMIC_MIN =&gt; c/types/limits
SIG_ATOMIC_MAX =&gt; c/types/limits
WCHAR_MIN =&gt; c/types/limits
WCHAR_MAX =&gt; c/types/limits
WINT_MIN =&gt; c/types/limits
WINT_MAX =&gt; c/types/limits
CHAR_BIT =&gt; c/types/limits
MB_LEN_MAX =&gt; c/types/limits
CHAR_MIN =&gt; c/types/limits
CHAR_MAX =&gt; c/types/limits
SCHAR_MIN =&gt; c/types/limits
SHRT_MIN =&gt; c/types/limits
INT_MIN =&gt; c/types/limits
LONG_MIN =&gt; c/types/limits
LLONG_MIN =&gt; c/types/limits
SCHAR_MAX =&gt; c/types/limits
SHRT_MAX =&gt; c/types/limits
INT_MAX =&gt; c/types/limits
LONG_MAX =&gt; c/types/limits
LLONG_MAX =&gt; c/types/limits
UCHAR_MAX =&gt; c/types/limits
USHRT_MAX =&gt; c/types/limits
UINT_MAX =&gt; c/types/limits
ULONG_MAX =&gt; c/types/limits
ULLONG_MAX =&gt; c/types/limits
FLT_RADIX =&gt; c/types/limits
DECIMAL_DIG =&gt; c/types/limits
FLT_MIN =&gt; c/types/limits
DBL_MIN =&gt; c/types/limits
LDBL_MIN =&gt; c/types/limits
FLT_MAX =&gt; c/types/limits
DBL_MAX =&gt; c/types/limits
LDBL_MAX =&gt; c/types/limits
FLT_EPSILON =&gt; c/types/limits
DBL_EPSILON =&gt; c/types/limits
LDBL_EPSILON =&gt; c/types/limits
FLT_DIG =&gt; c/types/limits
DBL_DIG =&gt; c/types/limits
LDBL_DIG =&gt; c/types/limits
FLT_MANT_DIG =&gt; c/types/limits
DBL_MANT_DIG =&gt; c/types/limits
LDBL_MANT_DIG =&gt; c/types/limits
FLT_MIN_EXP =&gt; c/types/limits
DBL_MIN_EXP =&gt; c/types/limits
LDBL_MIN_EXP =&gt; c/types/limits
FLT_MIN_10_EXP =&gt; c/types/limits
DBL_MIN_10_EXP =&gt; c/types/limits
LDBL_MIN_10_EXP =&gt; c/types/limits
FLT_MAX_EXP =&gt; c/types/limits
DBL_MAX_EXP =&gt; c/types/limits
LDBL_MAX_EXP =&gt; c/types/limits
FLT_MAX_10_EXP =&gt; c/types/limits
DBL_MAX_10_EXP =&gt; c/types/limits
LDBL_MAX_10_EXP =&gt; c/types/limits
FLT_ROUNDS =&gt; c/types/limits/FLT_ROUNDS
FLT_EVAL_METHOD =&gt; c/types/limits/FLT_EVAL_METHOD
malloc =&gt; c/memory/malloc
calloc =&gt; c/memory/calloc
realloc =&gt; c/memory/realloc
free =&gt; c/memory/free
assert =&gt; c/error/assert
errno =&gt; c/error/errno
E2BIG =&gt; c/error/errno_macros
EACCESS =&gt; c/error/errno_macros
EADDRINUSE =&gt; c/error/errno_macros
EADDRNOTAVAIL =&gt; c/error/errno_macros
EAFNOSUPPORT =&gt; c/error/errno_macros
EAGAIN =&gt; c/error/errno_macros
EALREADY =&gt; c/error/errno_macros
EBADF =&gt; c/error/errno_macros
EBADMSG =&gt; c/error/errno_macros
EBUSY =&gt; c/error/errno_macros
ECANCELED =&gt; c/error/errno_macros
ECHILD =&gt; c/error/errno_macros
ECONNABORTED =&gt; c/error/errno_macros
ECONNREFUSED =&gt; c/error/errno_macros
ECONNRESET =&gt; c/error/errno_macros
EDEADLK =&gt; c/error/errno_macros
EDESTADDRREQ =&gt; c/error/errno_macros
EDOM =&gt; c/error/errno_macros
EEXIST =&gt; c/error/errno_macros
EFAULT =&gt; c/error/errno_macros
EFBIG =&gt; c/error/errno_macros
EHOSTUNREACH =&gt; c/error/errno_macros
EIDRM =&gt; c/error/errno_macros
EILSEQ =&gt; c/error/errno_macros
EINPROGRESS =&gt; c/error/errno_macros
EINTR =&gt; c/error/errno_macros
EINVAL =&gt; c/error/errno_macros
EIO =&gt; c/error/errno_macros
EISCONN =&gt; c/error/errno_macros
EISDIR =&gt; c/error/errno_macros
ELOOP =&gt; c/error/errno_macros
EMFILE =&gt; c/error/errno_macros
EMLINK =&gt; c/error/errno_macros
EMSGSIZE =&gt; c/error/errno_macros
ENAMETOOLONG =&gt; c/error/errno_macros
ENETDOWN =&gt; c/error/errno_macros
ENETRESET =&gt; c/error/errno_macros
ENETUNREACH =&gt; c/error/errno_macros
ENFILE =&gt; c/error/errno_macros
ENOBUFS =&gt; c/error/errno_macros
ENODATA =&gt; c/error/errno_macros
ENODEV =&gt; c/error/errno_macros
ENOENT =&gt; c/error/errno_macros
ENOEXEC =&gt; c/error/errno_macros
ENOLCK =&gt; c/error/errno_macros
ENOLINK =&gt; c/error/errno_macros
ENOMEM =&gt; c/error/errno_macros
ENOMSG =&gt; c/error/errno_macros
ENOPROTOOPT =&gt; c/error/errno_macros
ENOSPC =&gt; c/error/errno_macros
ENOSR =&gt; c/error/errno_macros
ENOSTR =&gt; c/error/errno_macros
ENOSYS =&gt; c/error/errno_macros
ENOTCONN =&gt; c/error/errno_macros
ENOTDIR =&gt; c/error/errno_macros
ENOTEMPTY =&gt; c/error/errno_macros
ENOTRECOVERABLE =&gt; c/error/errno_macros
ENOTSOCK =&gt; c/error/errno_macros
ENOTSUP =&gt; c/error/errno_macros
ENOTTY =&gt; c/error/errno_macros
ENXIO =&gt; c/error/errno_macros
EOPNOTSUPP =&gt; c/error/errno_macros
EOVERFLOW =&gt; c/error/errno_macros
EOWNERDEAD =&gt; c/error/errno_macros
EPERM =&gt; c/error/errno_macros
EPIPE =&gt; c/error/errno_macros
EPROTO =&gt; c/error/errno_macros
EPROTONOSUPPORT =&gt; c/error/errno_macros
EPROTOTYPE =&gt; c/error/errno_macros
ERANGE =&gt; c/error/errno_macros
EROFS =&gt; c/error/errno_macros
ESPIPE =&gt; c/error/errno_macros
ESRCH =&gt; c/error/errno_macros
ETIME =&gt; c/error/errno_macros
ETIMEDOUT =&gt; c/error/errno_macros
ETXTBSY =&gt; c/error/errno_macros
EWOULDBLOCK =&gt; c/error/errno_macros
EXDEV =&gt; c/error/errno_macros
abort =&gt; c/program/abort
exit =&gt; c/program/exit
quick_exit =&gt; c/program/quick_exit
_Exit =&gt; c/program/_Exit
atexit =&gt; c/program/atexit
at_quick_exit =&gt; c/program/at_quick_exit
EXIT_SUCCESS =&gt; c/program/EXIT_status
EXIT_FAILURE =&gt; c/program/EXIT_status
system =&gt; c/program/system
getenv =&gt; c/program/getenv
signal =&gt; c/program/signal
raise =&gt; c/program/raise
sig_atomic_t =&gt; c/program/sig_atomic_t
SIG_DFL =&gt; c/program/SIG_strategies
SIG_IGN =&gt; c/program/SIG_strategies
SIG_ERR =&gt; c/program/SIG_ERR
SIGABRT =&gt; c/program/SIG_types
SIGFPE =&gt; c/program/SIG_types
SIGILL =&gt; c/program/SIG_types
SIGINT =&gt; c/program/SIG_types
SIGSEGV =&gt; c/program/SIG_types
SIGTERM =&gt; c/program/SIG_types
longjmp =&gt; c/program/longjmp
setjmp =&gt; c/program/setjmp
jmp_buf =&gt; c/program/jmp_buf
difftime =&gt; c/chrono/difftime
time =&gt; c/chrono/time
clock =&gt; c/chrono/clock
asctime =&gt; c/chrono/asctime
ctime =&gt; c/chrono/ctime
strftime =&gt; c/chrono/strftime
wcsftime =&gt; c/chrono/wcsftime
gmtime =&gt; c/chrono/gmtime
localtime =&gt; c/chrono/localtime
mktime =&gt; c/chrono/mktime
CLOCKS_PER_SEC =&gt; c/chrono/CLOCKS_PER_SEC
tm =&gt; c/chrono/tm
time_t =&gt; c/chrono/time_t
clock_t =&gt; c/chrono/clock_t
isalnum =&gt; c/string/byte/isalnum
isalpha =&gt; c/string/byte/isalpha
islower =&gt; c/string/byte/islower
isupper =&gt; c/string/byte/isupper
isdigit =&gt; c/string/byte/isdigit
isxdigit =&gt; c/string/byte/isxdigit
iscntrl =&gt; c/string/byte/iscntrl
isgraph =&gt; c/string/byte/isgraph
isspace =&gt; c/string/byte/isspace
isblank =&gt; c/string/byte/isblank
isprint =&gt; c/string/byte/isprint
ispunct =&gt; c/string/byte/ispunct
tolower =&gt; c/string/byte/tolower
toupper =&gt; c/string/byte/toupper
atof =&gt; c/string/byte/atof
atoi =&gt; c/string/byte/atoi
atol =&gt; c/string/byte/atoi
atoll =&gt; c/string/byte/atoi
strtol =&gt; c/string/byte/strtol
strtoll =&gt; c/string/byte/strtol
strtoul =&gt; c/string/byte/strtoul
strtoull =&gt; c/string/byte/strtoul
strtof =&gt; c/string/byte/strtof
strtod =&gt; c/string/byte/strtof
strtold =&gt; c/string/byte/strtof
strtoimax =&gt; c/string/byte/strtoimax
strtoumax =&gt; c/string/byte/strtoimax
strcpy =&gt; c/string/byte/strcpy
strncpy =&gt; c/string/byte/strncpy
strcat =&gt; c/string/byte/strcat
strncat =&gt; c/string/byte/strncat
strxfrm =&gt; c/string/byte/strxfrm
strlen =&gt; c/string/byte/strlen
strcmp =&gt; c/string/byte/strcmp
strncmp =&gt; c/string/byte/strncmp
strcoll =&gt; c/string/byte/strcoll
strchr =&gt; c/string/byte/strchr
strrchr =&gt; c/string/byte/strrchr
strspn =&gt; c/string/byte/strspn
strcspn =&gt; c/string/byte/strcspn
strpbrk =&gt; c/string/byte/strpbrk
strstr =&gt; c/string/byte/strstr
strtok =&gt; c/string/byte/strtok
memchr =&gt; c/string/byte/memchr
memcmp =&gt; c/string/byte/memcmp
memset =&gt; c/string/byte/memset
memcpy =&gt; c/string/byte/memcpy
memmove =&gt; c/string/byte/memmove
strerror =&gt; c/string/byte/strerror
mblen =&gt; c/string/multibyte/mblen
mbtowc =&gt; c/string/multibyte/mbtowc
wctomb =&gt; c/string/multibyte/wctomb
mbstowcs =&gt; c/string/multibyte/mbstowcs
wcstombs =&gt; c/string/multibyte/wcstombs
mbsinit =&gt; c/string/multibyte/mbsinit
btowc =&gt; c/string/multibyte/btowc
wctob =&gt; c/string/multibyte/wctob
mbrlen =&gt; c/string/multibyte/mbrlen
mbrtowc =&gt; c/string/multibyte/mbrtowc
wcrtomb =&gt; c/string/multibyte/wcrtomb
mbsrtowcs =&gt; c/string/multibyte/mbsrtowcs
wcstombs =&gt; c/string/multibyte/wcstombs
mbrtoc16 =&gt; c/string/multibyte/mbrtoc16
c16rtomb =&gt; c/string/multibyte/c16rtomb
mbrtoc32 =&gt; c/string/multibyte/mbrtoc32
c32rtomb =&gt; c/string/multibyte/c32rtomb
mbstate_t =&gt; c/string/multibyte/mbstate_t
iswalnum =&gt; c/string/wide/iswalnum
iswalpha =&gt; c/string/wide/iswalpha
iswlower =&gt; c/string/wide/iswlower
iswupper =&gt; c/string/wide/iswupper
iswdigit =&gt; c/string/wide/iswdigit
iswxdigit =&gt; c/string/wide/iswxdigit
iswcntrl =&gt; c/string/wide/iswcntrl
iswgraph =&gt; c/string/wide/iswgraph
iswspace =&gt; c/string/wide/iswspace
iswblank =&gt; c/string/wide/iswblank
iswprint =&gt; c/string/wide/iswprint
iswpunct =&gt; c/string/wide/iswpunct
iswctype =&gt; c/string/wide/iswctype
wctype =&gt; c/string/wide/wctype
towlower =&gt; c/string/wide/towlower
towupper =&gt; c/string/wide/towupper
towctrans =&gt; c/string/wide/towctrans
wctrans =&gt; c/string/wide/wctrans
wcstof =&gt; c/string/wide/wcstof
wcstod =&gt; c/string/wide/wcstof
wcstold =&gt; c/string/wide/wcstof
wcstol =&gt; c/string/wide/wcstol
wcstoll =&gt; c/string/wide/wcstol
wcstoul =&gt; c/string/wide/wcstoul
wcstoull =&gt; c/string/wide/wcstoul
wcstoimax =&gt; c/string/byte/wcstoimax
wcstoumax =&gt; c/string/byte/wcstoimax
wcscpy =&gt; c/string/wide/wcscpy
wcsncpy =&gt; c/string/wide/wcsncpy
wcscat =&gt; c/string/wide/wcscat
wcsncat =&gt; c/string/wide/wcsncat
wcsxfrm =&gt; c/string/wide/wcsxfrm
wcslen =&gt; c/string/wide/wcslen
wcscmp =&gt; c/string/wide/wcscmp
wcsncmp =&gt; c/string/wide/wcsncmp
wcscoll =&gt; c/string/wide/wcscoll
wcschr =&gt; c/string/wide/wcschr
wcsrchr =&gt; c/string/wide/wcsrchr
wcsspn =&gt; c/string/wide/wcsspn
wcscspn =&gt; c/string/wide/wcscspn
wcspbrk =&gt; c/string/wide/wcspbrk
wcsstr =&gt; c/string/wide/wcsstr
wcstok =&gt; c/string/wide/wcstok
wmemchr =&gt; c/string/wide/wmemchr
wmemcmp =&gt; c/string/wide/wmemcmp
wmemset =&gt; c/string/wide/wmemset
wmemcpy =&gt; c/string/wide/wmemcpy
wmemmove =&gt; c/string/wide/wmemmove
abs =&gt; c/numeric/math/abs
labs =&gt; c/numeric/math/abs
llabs =&gt; c/numeric/math/abs
fabs =&gt; c/numeric/math/fabs
div =&gt; c/numeric/math/div
ldiv =&gt; c/numeric/math/div
fmod =&gt; c/numeric/math/fmod
remainder =&gt; c/numeric/math/remainder
remquo =&gt; c/numeric/math/remquo
fma =&gt; c/numeric/math/fma
fmax =&gt; c/numeric/math/fmax
fmin =&gt; c/numeric/math/fmin
fdim =&gt; c/numeric/math/fdim
nan =&gt; c/numeric/math/nan
nanf =&gt; c/numeric/math/nan
nanl =&gt; c/numeric/math/nan
exp =&gt; c/numeric/math/exp
exp2 =&gt; c/numeric/math/exp2
expm1 =&gt; c/numeric/math/expm1
log =&gt; c/numeric/math/log
log10 =&gt; c/numeric/math/log10
log1p =&gt; c/numeric/math/log1p
ilogb =&gt; c/numeric/math/ilogb
logb =&gt; c/numeric/math/logb
sqrt =&gt; c/numeric/math/sqrt
cbrt =&gt; c/numeric/math/cbrt
hypot =&gt; c/numeric/math/hypot
pow =&gt; c/numeric/math/pow
sin =&gt; c/numeric/math/sin
cos =&gt; c/numeric/math/cos
tan =&gt; c/numeric/math/tan
asin =&gt; c/numeric/math/asin
acos =&gt; c/numeric/math/acos
atan =&gt; c/numeric/math/atan
atan2 =&gt; c/numeric/math/atan2
sinh =&gt; c/numeric/math/sinh
cosh =&gt; c/numeric/math/cosh
tanh =&gt; c/numeric/math/tanh
asinh =&gt; c/numeric/math/asinh
acosh =&gt; c/numeric/math/acosh
atanh =&gt; c/numeric/math/atanh
erf =&gt; c/numeric/math/erf
erfc =&gt; c/numeric/math/erfc
lgamma =&gt; c/numeric/math/lgamma
tgamma =&gt; c/numeric/math/tgamma
ceil =&gt; c/numeric/math/ceil
floor =&gt; c/numeric/math/floor
trunc =&gt; c/numeric/math/trunc
round =&gt; c/numeric/math/round
lround =&gt; c/numeric/math/round
llround =&gt; c/numeric/math/round
nearbyint =&gt; c/numeric/math/nearbyint
rint =&gt; c/numeric/math/rint
lrint =&gt; c/numeric/math/rint
llrint =&gt; c/numeric/math/rint
frexp =&gt; c/numeric/math/frexp
ldexp =&gt; c/numeric/math/ldexp
modf =&gt; c/numeric/math/modf
scalbn =&gt; c/numeric/math/scalbn
scalbln =&gt; c/numeric/math/scalbn
nextafter =&gt; c/numeric/math/nextafter
nexttoward =&gt; c/numeric/math/nextafter
copysign =&gt; c/numeric/math/copysign
fpclassify =&gt; c/numeric/math/fpclassify
isfinite =&gt; c/numeric/math/isfinite
isinf =&gt; c/numeric/math/isinf
isnan =&gt; c/numeric/math/isnan
isnormal =&gt; c/numeric/math/isnormal
signbit =&gt; c/numeric/math/signbit
HUGE_VAL =&gt; c/numeric/math/HUGE_VAL
HUGE_VALF =&gt; c/numeric/math/HUGE_VAL
HUGE_VALL =&gt; c/numeric/math/HUGE_VAL
FP_INFINITE =&gt; c/numeric/math/FP_categories
FP_NAN =&gt; c/numeric/math/FP_categories
FP_NORMAL =&gt; c/numeric/math/FP_categories
FP_SUBNORMAL =&gt; c/numeric/math/FP_categories
FP_ZERO =&gt; c/numeric/math/FP_categories
feclearexcept =&gt; c/numeric/fenv/feclearexcept
fetestexcept =&gt; c/numeric/fenv/fetestexcept
feraiseexcept =&gt; c/numeric/fenv/feraiseexcept
fegetexceptflag =&gt; c/numeric/fenv/feexceptflag
fesetexceptflag =&gt; c/numeric/fenv/feexceptflag
fegetround =&gt; c/numeric/fenv/feround
fesetround =&gt; c/numeric/fenv/feround
fegetenv =&gt; c/numeric/fenv/feenv
fesetenv =&gt; c/numeric/fenv/feenv
feholdexcept =&gt; c/numeric/fenv/feholdexcept
feupdateenv =&gt; c/numeric/fenv/feupdateenv
FE_ALL_EXCEPT =&gt; c/numeric/fenv/FE_exceptions
FE_DIVBYZERO =&gt; c/numeric/fenv/FE_exceptions
FE_INEXACT =&gt; c/numeric/fenv/FE_exceptions
FE_INVALID =&gt; c/numeric/fenv/FE_exceptions
FE_OVERFLOW =&gt; c/numeric/fenv/FE_exceptions
FE_UNDERFLOW =&gt; c/numeric/fenv/FE_exceptions
FE_DOWNWARD =&gt; c/numeric/fenv/FE_round
FE_TONEAREST =&gt; c/numeric/fenv/FE_round
FE_TOWARDZERO =&gt; c/numeric/fenv/FE_round
FE_UPWARD =&gt; c/numeric/fenv/FE_round
FE_DFL_ENV =&gt; c/numeric/fenv/FE_DFL_ENV
srand =&gt; c/numeric/random/srand
rand =&gt; c/numeric/random/rand
RAND_MAX =&gt; c/numeric/random/RAND_MAX
complex =&gt; c/numeric/complex/complex
Complex_I =&gt; c/numeric/complex/Complex_I
imaginary =&gt; c/numeric/complex/imaginary
Imaginary_I =&gt; c/numeric/complex/Imaginary_I
I =&gt; c/numeric/complex/I
CMPLX =&gt; c/numeric/complex/CMPLX
CMPLXF =&gt; c/numeric/complex/CMPLX
CMPLXL =&gt; c/numeric/complex/CMPLX
cimag =&gt; c/numeric/complex/cimag
cimagf =&gt; c/numeric/complex/cimag
cimagl =&gt; c/numeric/complex/cimag
creal =&gt; c/numeric/complex/creal
crealf =&gt; c/numeric/complex/creal
creall =&gt; c/numeric/complex/creal
carg =&gt; c/numeric/complex/carg
cargf =&gt; c/numeric/complex/carg
cargl =&gt; c/numeric/complex/carg
conj =&gt; c/numeric/complex/conj
conjf =&gt; c/numeric/complex/conj
conjl =&gt; c/numeric/complex/conj
cproj =&gt; c/numeric/complex/cproj
cprojf =&gt; c/numeric/complex/cproj
cprojl =&gt; c/numeric/complex/cproj
cabs =&gt; c/numeric/complex/cabs
cabsf =&gt; c/numeric/complex/cabs
cabsl =&gt; c/numeric/complex/cabs
cexp =&gt; c/numeric/complex/cexp
cexpf =&gt; c/numeric/complex/cexp
cexpl =&gt; c/numeric/complex/cexp
clog =&gt; c/numeric/complex/clog
clogf =&gt; c/numeric/complex/clog
clogl =&gt; c/numeric/complex/clog
cpow =&gt; c/numeric/complex/cpow
cpowf =&gt; c/numeric/complex/cpow
cpowl =&gt; c/numeric/complex/cpow
csqrt =&gt; c/numeric/complex/csqrt
csqrtf =&gt; c/numeric/complex/csqrt
csqrtl =&gt; c/numeric/complex/csqrt
cacos =&gt; c/numeric/complex/cacos
cacosf =&gt; c/numeric/complex/cacos
cacosl =&gt; c/numeric/complex/cacos
casin =&gt; c/numeric/complex/casin
casinf =&gt; c/numeric/complex/casin
casinl =&gt; c/numeric/complex/casin
catan =&gt; c/numeric/complex/catan
catanf =&gt; c/numeric/complex/catan
catanl =&gt; c/numeric/complex/catan
ccos =&gt; c/numeric/complex/ccos
ccosf =&gt; c/numeric/complex/ccos
ccosl =&gt; c/numeric/complex/ccos
csin =&gt; c/numeric/complex/csin
csinf =&gt; c/numeric/complex/csin
csinl =&gt; c/numeric/complex/csin
ctan =&gt; c/numeric/complex/ctan
ctanf =&gt; c/numeric/complex/ctan
ctanl =&gt; c/numeric/complex/ctan
cacosh =&gt; c/numeric/complex/cacosh
cacoshf =&gt; c/numeric/complex/cacosh
cacoshl =&gt; c/numeric/complex/cacosh
casinh =&gt; c/numeric/complex/casinh
casinhf =&gt; c/numeric/complex/casinh
casinhl =&gt; c/numeric/complex/casinh
catanh =&gt; c/numeric/complex/catanh
catanhf =&gt; c/numeric/complex/catanh
catanhl =&gt; c/numeric/complex/catanh
ccosh =&gt; c/numeric/complex/ccosh
ccoshf =&gt; c/numeric/complex/ccosh
ccoshl =&gt; c/numeric/complex/ccosh
csinh =&gt; c/numeric/complex/csinh
csinhf =&gt; c/numeric/complex/csinh
csinhl =&gt; c/numeric/complex/csinh
ctanh =&gt; c/numeric/complex/ctanh
ctanhf =&gt; c/numeric/complex/ctanh
ctanhl =&gt; c/numeric/complex/ctanh
qsort =&gt; c/algorithm/qsort
bsearch =&gt; c/algorithm/bsearch
fopen =&gt; c/io/fopen
freopen =&gt; c/io/freopen
fflush =&gt; c/io/fflush
fclose =&gt; c/io/fclose
setbuf =&gt; c/io/setbuf
setvbuf =&gt; c/io/setvbuf
fread =&gt; c/io/fread
fwrite =&gt; c/io/fwrite
fgetc =&gt; c/io/fgetc
getc =&gt; c/io/fgetc
fgets =&gt; c/io/fgets
fputc =&gt; c/io/fputc
putc =&gt; c/io/fputc
fputs =&gt; c/io/fputs
getchar =&gt; c/io/getchar
gets =&gt; c/io/gets
putchar =&gt; c/io/putchar
puts =&gt; c/io/puts
ungetc =&gt; c/io/ungetc
fgetwc =&gt; c/io/fgetwc
fgetss =&gt; c/io/fgetws
fputwc =&gt; c/io/fputwc
fputws =&gt; c/io/fputws
getwchar =&gt; c/io/getwchar
putwchar =&gt; c/io/putwchar
ungetwc =&gt; c/io/ungetwc
scanf =&gt; c/io/fscanf
fscanf =&gt; c/io/fscanf
sscanf =&gt; c/io/fscanf
vscanf =&gt; c/io/vfscanf
vfscanf =&gt; c/io/vfscanf
vsscanf =&gt; c/io/vfscanf
printf =&gt; c/io/fprintf
fprintf =&gt; c/io/fprintf
sprintf =&gt; c/io/fprintf
snprintf =&gt; c/io/fprintf
vprintf =&gt; c/io/vfprintf
vfprintf =&gt; c/io/vfprintf
vsprintf =&gt; c/io/vfprintf
vsnprintf =&gt; c/io/vfprintf
wscanf =&gt; c/io/fwscanf
fwscanf =&gt; c/io/fwscanf
swscanf =&gt; c/io/fwscanf
vwscanf =&gt; c/io/vfwscanf
vfwscanf =&gt; c/io/vfwscanf
vswscanf =&gt; c/io/vfwscanf
wprintf =&gt; c/io/fwprintf
fwprintf =&gt; c/io/fwprintf
swprintf =&gt; c/io/fwprintf
vwprintf =&gt; c/io/vfwprintf
vfwprintf =&gt; c/io/vfwprintf
vswprintf =&gt; c/io/vfwprintf
ftell =&gt; c/io/ftell
fgetpos =&gt; c/io/fgetpos
fseek =&gt; c/io/fseek
fsetpos =&gt; c/io/fsetpos
rewind =&gt; c/io/rewind
clearerr =&gt; c/io/clearerr
feof =&gt; c/io/feof
ferror =&gt; c/io/ferror
perror =&gt; c/io/perror
remove =&gt; c/io/remove
rename =&gt; c/io/rename
tmpfile =&gt; c/io/tmpfile
tmpnam =&gt; c/io/tmpnam
FILE =&gt; c/io
fpos_t =&gt; c/io
stdin =&gt; c/io
stdout =&gt; c/io
stderr =&gt; c/io
EOF =&gt; c/io
FOPEN_MAX =&gt; c/io
FILENAME_MAX =&gt; c/io
BUFSIZ =&gt; c/io
_IOFBF =&gt; c/io
_IOLBF =&gt; c/io
_IONBF =&gt; c/io
SEEK_SET =&gt; c/io
SEEK_CUR =&gt; c/io
SEEK_END =&gt; c/io
TMP_MAX =&gt; c/io
L_tmpnam =&gt; c/io
setlocale =&gt; c/locale/setlocale
localeconv =&gt; c/locale/localeconv
lconv =&gt; c/locale/lconv
LC_ALL =&gt; c/locale/LC_categories
LC_COLLATE =&gt; c/locale/LC_categories
LC_CTYPE =&gt; c/locale/LC_categories
LC_MONETARY =&gt; c/locale/LC_categories
LC_NUMERIC =&gt; c/locale/LC_categories
LC_TIME =&gt; c/locale/LC_categories
memory_order =&gt; c/atomic/memory_order
memory_order_relaxed =&gt; c/atomic/memory_order
memory_order_consume =&gt; c/atomic/memory_order
memory_order_acquire =&gt; c/atomic/memory_order
memory_order_release =&gt; c/atomic/memory_order
memory_order_acq_rel =&gt; c/atomic/memory_order
memory_order_seq_cst =&gt; c/atomic/memory_order
atomic_flag =&gt; c/atomic/atomic_flag
ATOMIC_BOOL_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR16_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_CHAR32_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_WCHAR_T_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_SHORT_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_INT_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_LONG_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_LLONG_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_POINTER_LOCK_FREE =&gt; c/atomic/ATOMIC_LOCK_FREE_consts
ATOMIC_FLAG_INIT =&gt; c/atomic/ATOMIC_FLAG_INIT
ATOMIC_VAR_INIT =&gt; c/atomic/ATOMIC_VAR_INIT
kill_dependency =&gt; c/atomic/kill_dependency
atomic_load_test_and_set =&gt; c/atomic/atomic_load_test_and_set
atomic_load_test_and_set_explicit =&gt; c/atomic/atomic_load_test_and_set
atomic_flag_clear =&gt; c/atomic/atomic_flag_clear
atomic_flag_clear_explicit =&gt; c/atomic/atomic_flag_clear
atomic_init =&gt; c/atomic/atomic_init
atomic_is_lock_free =&gt; c/atomic/atomic_is_lock_free
atomic_store =&gt; c/atomic/atomic_store
atomic_store_explicit =&gt; c/atomic/atomic_store
atomic_load =&gt; c/atomic/atomic_load
atomic_load_explicit =&gt; c/atomic/atomic_load
atomic_exchange =&gt; c/atomic/atomic_exchange
atomic_exchange_explicit =&gt; c/atomic/atomic_exchange
atomic_compare_exchange_weak =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_weak_explicit =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_strong =&gt; c/atomic/atomic_compare_exchange
atomic_compare_exchange_strong_explicit =&gt; c/atomic/atomic_compare_exchange
atomic_fetch_add =&gt; c/atomic/atomic_fetch_add
atomic_fetch_add_explicit =&gt; c/atomic/atomic_fetch_add
atomic_fetch_sub =&gt; c/atomic/atomic_fetch_sub
atomic_fetch_sub_explicit =&gt; c/atomic/atomic_fetch_sub
atomic_fetch_or =&gt; c/atomic/atomic_fetch_or
atomic_fetch_or_explicit =&gt; c/atomic/atomic_fetch_or
atomic_fetch_xor =&gt; c/atomic/atomic_fetch_xor
atomic_fetch_xor_explicit =&gt; c/atomic/atomic_fetch_xor
atomic_fetch_and =&gt; c/atomic/atomic_fetch_and
atomic_fetch_and_explicit =&gt; c/atomic/atomic_fetch_and
atomic_thread_fence =&gt; c/atomic/atomic_thread_fence
atomic_signal_fence =&gt; c/atomic/atomic_signal_fence
atomic_bool =&gt; c/atomic
atomic_char =&gt; c/atomic
atomic_schar =&gt; c/atomic
atomic_uchar =&gt; c/atomic
atomic_short =&gt; c/atomic
atomic_ushort =&gt; c/atomic
atomic_int =&gt; c/atomic
atomic_uint =&gt; c/atomic
atomic_long =&gt; c/atomic
atomic_ulong =&gt; c/atomic
atomic_llong =&gt; c/atomic
atomic_ullong =&gt; c/atomic
atomic_char16_t =&gt; c/atomic
atomic_char32_t =&gt; c/atomic
atomic_wchar_t =&gt; c/atomic
atomic_int_least8_t =&gt; c/atomic
atomic_uint_least8_t =&gt; c/atomic
atomic_int_least16_t =&gt; c/atomic
atomic_uint_least16_t =&gt; c/atomic
atomic_int_least32_t =&gt; c/atomic
atomic_uint_least32_t =&gt; c/atomic
atomic_int_least64_t =&gt; c/atomic
atomic_uint_least64_t =&gt; c/atomic
atomic_int_fast8_t =&gt; c/atomic
atomic_uint_fast8_t =&gt; c/atomic
atomic_int_fast16_t =&gt; c/atomic
atomic_uint_fast16_t =&gt; c/atomic
atomic_int_fast32_t =&gt; c/atomic
atomic_uint_fast32_t =&gt; c/atomic
atomic_int_fast64_t =&gt; c/atomic
atomic_uint_fast64_t =&gt; c/atomic
atomic_intprt_t =&gt; c/atomic
atomic_uintprt_t =&gt; c/atomic
atomic_size_t =&gt; c/atomic
atomic_ptrdiff_t =&gt; c/atomic
atomic_intmax_t =&gt; c/atomic
atomic_uintmax_t =&gt; c/atomic
thrd_t =&gt; c/thread
thrd_create =&gt; c/thread/thrd_create
thrd_equal =&gt; c/thread/thrd_equal
thrd_current =&gt; c/thread/thrd_current
thrd_sleep =&gt; c/thread/thrd_sleep
thrd_yield =&gt; c/thread/thrd_yield
thrd_exit =&gt; c/thread/thrd_exit
thrd_detach =&gt; c/thread/thrd_detach
thrd_join =&gt; c/thread/thrd_join
thrd_success =&gt; c/thread/thrd_errors
thrd_timeout =&gt; c/thread/thrd_errors
thrd_busy =&gt; c/thread/thrd_errors
thrd_nomem =&gt; c/thread/thrd_errors
thrd_error =&gt; c/thread/thrd_errors
thrd_start_t =&gt; c/thread
mtx_t =&gt; c/thread
mtx_init =&gt; c/thread/mtx_init
mtx_lock =&gt; c/thread/mtx_lock
mtx_timedlock =&gt; c/thread/mtx_timedlock
mtx_trylock =&gt; c/thread/mtx_trylock
mtx_unlock =&gt; c/thread/mtx_unlock
mtx_destroy =&gt; c/thread/mtx_destroy
mtx_plain =&gt; c/thread/mtx_types
mtx_recursive =&gt; c/thread/mtx_types
mtx_timed =&gt; c/thread/mtx_types
thrd_start_t =&gt; c/thread
once_flag =&gt; c/thread
ONCE_FLAG_INIT =&gt; c/thread/ONCE_FLAG_INIT
call_once =&gt; c/thread/call_once
cnd_t =&gt; c/thread
cnd_init =&gt; c/thread/cnd_init
cnd_signal =&gt; c/thread/cnd_signal
cnd_broadcast =&gt; c/thread/cnd_broadcast
cnd_wait =&gt; c/thread/cnd_wait
cnd_timedwait =&gt; c/thread/cnd_timedwait
cnd_destroy =&gt; c/thread/cnd_destroy
thread_local =&gt; c/thread/thread_local
TSS_DTOR_ITERATIONS =&gt; c/thread/TSS_DTOR_ITERATIONS
tss_t =&gt; c/thread
tss_dtor_t =&gt; c/thread
tss_create =&gt; c/thread/tss_create
tss_get =&gt; c/thread/tss_get
tss_set =&gt; c/thread/tss_set
tss_delete =&gt; c/thread/tss_delete</text>
      <sha1>tgkhec52b0p848x3gghm8amoxjk7g7r</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Geshi-keyword-list-cpp</title>
    <ns>8</ns>
    <id>2531</id>
    <revision>
      <id>71784</id>
      <parentid>61776</parentid>
      <timestamp>2014-06-24T01:46:01Z</timestamp>
      <contributor>
        <username>Cubbi</username>
        <id>45</id>
      </contributor>
      <minor/>
      <comment>s/FE_UNHERFLOW/FE_UNDERFLOW</comment>
      <text xml:space="preserve" bytes="74955">std::size_t =&gt; cpp/types/size_t
std::ptrdiff_t =&gt; cpp/types/ptrdiff_t
std::nullptr_t =&gt; cpp/types/nullptr_t
NULL =&gt; cpp/types/NULL
std::max_align_t =&gt; cpp/types/max_align_t
offsetof =&gt; cpp/types/offsetof
std::int8_t =&gt; cpp/types/integer
std::int16_t =&gt; cpp/types/integer
std::int32_t =&gt; cpp/types/integer
std::int64_t =&gt; cpp/types/integer
std::int_fast8_t =&gt; cpp/types/integer
std::int_fast16_t =&gt; cpp/types/integer
std::int_fast32_t =&gt; cpp/types/integer
std::int_fast64_t =&gt; cpp/types/integer
std::int_least8_t =&gt; cpp/types/integer
std::int_least16_t =&gt; cpp/types/integer
std::int_least32_t =&gt; cpp/types/integer
std::int_least64_t =&gt; cpp/types/integer
std::intmax_t =&gt; cpp/types/integer
std::intptr_t =&gt; cpp/types/integer
std::uint8_t =&gt; cpp/types/integer
std::uint16_t =&gt; cpp/types/integer
std::uint32_t =&gt; cpp/types/integer
std::uint64_t =&gt; cpp/types/integer
std::uint_fast8_t =&gt; cpp/types/integer
std::uint_fast16_t =&gt; cpp/types/integer
std::uint_fast32_t =&gt; cpp/types/integer
std::uint_fast64_t =&gt; cpp/types/integer
std::uint_least8_t =&gt; cpp/types/integer
std::uint_least16_t =&gt; cpp/types/integer
std::uint_least32_t =&gt; cpp/types/integer
std::uint_least64_t =&gt; cpp/types/integer
std::uintmax_t =&gt; cpp/types/integer
std::uintptr_t =&gt; cpp/types/integer
INT8_MIN =&gt; cpp/types/integer
INT16_MIN =&gt; cpp/types/integer
INT32_MIN =&gt; cpp/types/integer
INT64_MIN =&gt; cpp/types/integer
INT_FAST8_MIN =&gt; cpp/types/integer
INT_FAST16_MIN =&gt; cpp/types/integer
INT_FAST32_MIN =&gt; cpp/types/integer
INT_FAST64_MIN =&gt; cpp/types/integer
INT_LEAST8_MIN =&gt; cpp/types/integer
INT_LEAST16_MIN =&gt; cpp/types/integer
INT_LEAST32_MIN =&gt; cpp/types/integer
INT_LEAST64_MIN =&gt; cpp/types/integer
INTPTR_MIN =&gt; cpp/types/integer
INTMAX_MIN =&gt; cpp/types/integer
INT8_MAX =&gt; cpp/types/integer
INT16_MAX =&gt; cpp/types/integer
INT32_MAX =&gt; cpp/types/integer
INT64_MAX =&gt; cpp/types/integer
INT_FAST8_MAX =&gt; cpp/types/integer
INT_FAST16_MAX =&gt; cpp/types/integer
INT_FAST32_MAX =&gt; cpp/types/integer
INT_FAST64_MAX =&gt; cpp/types/integer
INT_LEAST8_MAX =&gt; cpp/types/integer
INT_LEAST16_MAX =&gt; cpp/types/integer
INT_LEAST32_MAX =&gt; cpp/types/integer
INT_LEAST64_MAX =&gt; cpp/types/integer
INTPTR_MAX =&gt; cpp/types/integer
INTMAX_MAX =&gt; cpp/types/integer
UINT8_MAX =&gt; cpp/types/integer
UINT16_MAX =&gt; cpp/types/integer
UINT32_MAX =&gt; cpp/types/integer
UINT64_MAX =&gt; cpp/types/integer
UINT_FAST8_MAX =&gt; cpp/types/integer
UINT_FAST16_MAX =&gt; cpp/types/integer
UINT_FAST32_MAX =&gt; cpp/types/integer
UINT_FAST64_MAX =&gt; cpp/types/integer
UINT_LEAST8_MAX =&gt; cpp/types/integer
UINT_LEAST16_MAX =&gt; cpp/types/integer
UINT_LEAST32_MAX =&gt; cpp/types/integer
UINT_LEAST64_MAX =&gt; cpp/types/integer
UINTPTR_MAX =&gt; cpp/types/integer
UINTMAX_MAX =&gt; cpp/types/integer
PRId8 =&gt; cpp/types/integer
PRId16 =&gt; cpp/types/integer
PRId32 =&gt; cpp/types/integer
PRId64 =&gt; cpp/types/integer
PRIdLEAST8 =&gt; cpp/types/integer
PRIdLEAST16 =&gt; cpp/types/integer
PRIdLEAST32 =&gt; cpp/types/integer
PRIdLEAST64 =&gt; cpp/types/integer
PRIdFAST8 =&gt; cpp/types/integer
PRIdFAST16 =&gt; cpp/types/integer
PRIdFAST32 =&gt; cpp/types/integer
PRIdFAST64 =&gt; cpp/types/integer
PRIdMAX =&gt; cpp/types/integer
PRIdPTR  =&gt; cpp/types/integer
PRIi8 =&gt; cpp/types/integer
PRIi16 =&gt; cpp/types/integer
PRIi32 =&gt; cpp/types/integer
PRIi64 =&gt; cpp/types/integer
PRIiLEAST8 =&gt; cpp/types/integer
PRIiLEAST16 =&gt; cpp/types/integer
PRIiLEAST32 =&gt; cpp/types/integer
PRIiLEAST64 =&gt; cpp/types/integer
PRIiFAST8 =&gt; cpp/types/integer
PRIiFAST16 =&gt; cpp/types/integer
PRIiFAST32 =&gt; cpp/types/integer
PRIiFAST64 =&gt; cpp/types/integer
PRIiMAX =&gt; cpp/types/integer
PRIiPTR  =&gt; cpp/types/integer
PRIu8 =&gt; cpp/types/integer
PRIu16 =&gt; cpp/types/integer
PRIu32 =&gt; cpp/types/integer
PRIu64 =&gt; cpp/types/integer
PRIuLEAST8 =&gt; cpp/types/integer
PRIuLEAST16 =&gt; cpp/types/integer
PRIuLEAST32 =&gt; cpp/types/integer
PRIuLEAST64 =&gt; cpp/types/integer
PRIuFAST8 =&gt; cpp/types/integer
PRIuFAST16 =&gt; cpp/types/integer
PRIuFAST32 =&gt; cpp/types/integer
PRIuFAST64 =&gt; cpp/types/integer
PRIuMAX =&gt; cpp/types/integer
PRIuPTR  =&gt; cpp/types/integer
PRIo8 =&gt; cpp/types/integer
PRIo16 =&gt; cpp/types/integer
PRIo32 =&gt; cpp/types/integer
PRIo64 =&gt; cpp/types/integer
PRIoLEAST8 =&gt; cpp/types/integer
PRIoLEAST16 =&gt; cpp/types/integer
PRIoLEAST32 =&gt; cpp/types/integer
PRIoLEAST64 =&gt; cpp/types/integer
PRIoFAST8 =&gt; cpp/types/integer
PRIoFAST16 =&gt; cpp/types/integer
PRIoFAST32 =&gt; cpp/types/integer
PRIoFAST64 =&gt; cpp/types/integer
PRIoMAX =&gt; cpp/types/integer
PRIoPTR  =&gt; cpp/types/integer
PRIx8 =&gt; cpp/types/integer
PRIx16 =&gt; cpp/types/integer
PRIx32 =&gt; cpp/types/integer
PRIx64 =&gt; cpp/types/integer
PRIxLEAST8 =&gt; cpp/types/integer
PRIxLEAST16 =&gt; cpp/types/integer
PRIxLEAST32 =&gt; cpp/types/integer
PRIxLEAST64 =&gt; cpp/types/integer
PRIxFAST8 =&gt; cpp/types/integer
PRIxFAST16 =&gt; cpp/types/integer
PRIxFAST32 =&gt; cpp/types/integer
PRIxFAST64 =&gt; cpp/types/integer
PRIxMAX =&gt; cpp/types/integer
PRIxPTR  =&gt; cpp/types/integer
PRIX8 =&gt; cpp/types/integer
PRIX16 =&gt; cpp/types/integer
PRIX32 =&gt; cpp/types/integer
PRIX64 =&gt; cpp/types/integer
PRIXLEAST8 =&gt; cpp/types/integer
PRIXLEAST16 =&gt; cpp/types/integer
PRIXLEAST32 =&gt; cpp/types/integer
PRIXLEAST64 =&gt; cpp/types/integer
PRIXFAST8 =&gt; cpp/types/integer
PRIXFAST16 =&gt; cpp/types/integer
PRIXFAST32 =&gt; cpp/types/integer
PRIXFAST64 =&gt; cpp/types/integer
PRIXMAX =&gt; cpp/types/integer
PRIXPTR  =&gt; cpp/types/integer
SCNd8 =&gt; cpp/types/integer
SCNd16 =&gt; cpp/types/integer
SCNd32 =&gt; cpp/types/integer
SCNd64 =&gt; cpp/types/integer
SCNdLEAST8 =&gt; cpp/types/integer
SCNdLEAST16 =&gt; cpp/types/integer
SCNdLEAST32 =&gt; cpp/types/integer
SCNdLEAST64 =&gt; cpp/types/integer
SCNdFAST8 =&gt; cpp/types/integer
SCNdFAST16 =&gt; cpp/types/integer
SCNdFAST32 =&gt; cpp/types/integer
SCNdFAST64 =&gt; cpp/types/integer
SCNdMAX =&gt; cpp/types/integer
SCNdPTR  =&gt; cpp/types/integer
SCNi8 =&gt; cpp/types/integer
SCNi16 =&gt; cpp/types/integer
SCNi32 =&gt; cpp/types/integer
SCNi64 =&gt; cpp/types/integer
SCNiLEAST8 =&gt; cpp/types/integer
SCNiLEAST16 =&gt; cpp/types/integer
SCNiLEAST32 =&gt; cpp/types/integer
SCNiLEAST64 =&gt; cpp/types/integer
SCNiFAST8 =&gt; cpp/types/integer
SCNiFAST16 =&gt; cpp/types/integer
SCNiFAST32 =&gt; cpp/types/integer
SCNiFAST64 =&gt; cpp/types/integer
SCNiMAX =&gt; cpp/types/integer
SCNiPTR  =&gt; cpp/types/integer
SCNu8 =&gt; cpp/types/integer
SCNu16 =&gt; cpp/types/integer
SCNu32 =&gt; cpp/types/integer
SCNu64 =&gt; cpp/types/integer
SCNuLEAST8 =&gt; cpp/types/integer
SCNuLEAST16 =&gt; cpp/types/integer
SCNuLEAST32 =&gt; cpp/types/integer
SCNuLEAST64 =&gt; cpp/types/integer
SCNuFAST8 =&gt; cpp/types/integer
SCNuFAST16 =&gt; cpp/types/integer
SCNuFAST32 =&gt; cpp/types/integer
SCNuFAST64 =&gt; cpp/types/integer
SCNuMAX =&gt; cpp/types/integer
SCNuPTR  =&gt; cpp/types/integer
SCNo8 =&gt; cpp/types/integer
SCNo16 =&gt; cpp/types/integer
SCNo32 =&gt; cpp/types/integer
SCNo64 =&gt; cpp/types/integer
SCNoLEAST8 =&gt; cpp/types/integer
SCNoLEAST16 =&gt; cpp/types/integer
SCNoLEAST32 =&gt; cpp/types/integer
SCNoLEAST64 =&gt; cpp/types/integer
SCNoFAST8 =&gt; cpp/types/integer
SCNoFAST16 =&gt; cpp/types/integer
SCNoFAST32 =&gt; cpp/types/integer
SCNoFAST64 =&gt; cpp/types/integer
SCNoMAX =&gt; cpp/types/integer
SCNoPTR  =&gt; cpp/types/integer
SCNx8 =&gt; cpp/types/integer
SCNx16 =&gt; cpp/types/integer
SCNx32 =&gt; cpp/types/integer
SCNx64 =&gt; cpp/types/integer
SCNxLEAST8 =&gt; cpp/types/integer
SCNxLEAST16 =&gt; cpp/types/integer
SCNxLEAST32 =&gt; cpp/types/integer
SCNxLEAST64 =&gt; cpp/types/integer
SCNxFAST8 =&gt; cpp/types/integer
SCNxFAST16 =&gt; cpp/types/integer
SCNxFAST32 =&gt; cpp/types/integer
SCNxFAST64 =&gt; cpp/types/integer
SCNxMAX =&gt; cpp/types/integer
SCNxPTR  =&gt; cpp/types/integer
SCNX8 =&gt; cpp/types/integer
SCNX16 =&gt; cpp/types/integer
SCNX32 =&gt; cpp/types/integer
SCNX64 =&gt; cpp/types/integer
SCNXLEAST8 =&gt; cpp/types/integer
SCNXLEAST16 =&gt; cpp/types/integer
SCNXLEAST32 =&gt; cpp/types/integer
SCNXLEAST64 =&gt; cpp/types/integer
SCNXFAST8 =&gt; cpp/types/integer
SCNXFAST16 =&gt; cpp/types/integer
SCNXFAST32 =&gt; cpp/types/integer
SCNXFAST64 =&gt; cpp/types/integer
SCNXMAX =&gt; cpp/types/integer
SCNXPTR =&gt; cpp/types/integer
std::numeric_limits =&gt; cpp/types/numeric_limits
std::numeric_limits::is_specialized =&gt; cpp/types/numeric_limits/is_specialized
std::numeric_limits::is_signed =&gt; cpp/types/numeric_limits/is_signed
std::numeric_limits::is_integer =&gt; cpp/types/numeric_limits/is_integer
std::numeric_limits::is_exact =&gt; cpp/types/numeric_limits/is_exact
std::numeric_limits::has_infinity =&gt; cpp/types/numeric_limits/has_infinity
std::numeric_limits::has_quiet_NaN =&gt; cpp/types/numeric_limits/has_quiet_NaN
std::numeric_limits::has_signaling_NaN =&gt; cpp/types/numeric_limits/has_signaling_NaN
std::numeric_limits::has_denorm =&gt; cpp/types/numeric_limits/has_denorm
std::numeric_limits::has_denorm_loss =&gt; cpp/types/numeric_limits/has_denorm_loss
std::numeric_limits::round_style =&gt; cpp/types/numeric_limits/round_style
std::numeric_limits::is_iec559 =&gt; cpp/types/numeric_limits/is_iec559
std::numeric_limits::is_bounded =&gt; cpp/types/numeric_limits/is_bounded
std::numeric_limits::is_modulo =&gt; cpp/types/numeric_limits/is_modulo
std::numeric_limits::digits =&gt; cpp/types/numeric_limits/digits
std::numeric_limits::digits10 =&gt; cpp/types/numeric_limits/digits10
std::numeric_limits::max_digits10 =&gt; cpp/types/numeric_limits/max_digits10
std::numeric_limits::radix =&gt; cpp/types/numeric_limits/radix
std::numeric_limits::min_exponent =&gt; cpp/types/numeric_limits/min_exponent
std::numeric_limits::min_exponent10 =&gt; cpp/types/numeric_limits/min_exponent10
std::numeric_limits::max_exponent =&gt; cpp/types/numeric_limits/max_exponent
std::numeric_limits::max_exponent10 =&gt; cpp/types/numeric_limits/max_exponent10
std::numeric_limits::traps =&gt; cpp/types/numeric_limits/traps
std::numeric_limits::tinyness_before =&gt; cpp/types/numeric_limits/tinyness_before
std::float_round_style =&gt; cpp/types/numeric_limits/float_round_style
std::round_indeterminate =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_zero =&gt; cpp/types/numeric_limits/float_round_style
std::round_to_nearest =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_infinity =&gt; cpp/types/numeric_limits/float_round_style
std::round_toward_neg_infinity =&gt; cpp/types/numeric_limits/float_round_style
std::float_denorm_style =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_indeterminate =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_absent =&gt; cpp/types/numeric_limits/float_denorm_style
std::denorm_present =&gt; cpp/types/numeric_limits/float_denorm_style
PTRDIFF_MIN =&gt; cpp/types/climits
PTRDIFF_MAX =&gt; cpp/types/climits
SIZE_MAX =&gt; cpp/types/climits
SIG_ATOMIC_MIN =&gt; cpp/types/climits
SIG_ATOMIC_MAX =&gt; cpp/types/climits
WCHAR_MIN =&gt; cpp/types/climits
WCHAR_MAX =&gt; cpp/types/climits
WINT_MIN =&gt; cpp/types/climits
WINT_MAX =&gt; cpp/types/climits
CHAR_BIT =&gt; cpp/types/climits
MB_LEN_MAX =&gt; cpp/types/climits
CHAR_MIN =&gt; cpp/types/climits
CHAR_MAX =&gt; cpp/types/climits
SCHAR_MIN =&gt; cpp/types/climits
SHRT_MIN =&gt; cpp/types/climits
INT_MIN =&gt; cpp/types/climits
LONG_MIN =&gt; cpp/types/climits
LLONG_MIN =&gt; cpp/types/climits
SCHAR_MAX =&gt; cpp/types/climits
SHRT_MAX =&gt; cpp/types/climits
INT_MAX =&gt; cpp/types/climits
LONG_MAX =&gt; cpp/types/climits
LLONG_MAX =&gt; cpp/types/climits
UCHAR_MAX =&gt; cpp/types/climits
USHRT_MAX =&gt; cpp/types/climits
UINT_MAX =&gt; cpp/types/climits
ULONG_MAX =&gt; cpp/types/climits
ULLONG_MAX =&gt; cpp/types/climits
FLT_RADIX =&gt; cpp/types/climits
DECIMAL_DIG =&gt; cpp/types/climits
FLT_MIN =&gt; cpp/types/climits
DBL_MIN =&gt; cpp/types/climits
LDBL_MIN =&gt; cpp/types/climits
FLT_MAX =&gt; cpp/types/climits
DBL_MAX =&gt; cpp/types/climits
LDBL_MAX =&gt; cpp/types/climits
FLT_EPSILON =&gt; cpp/types/climits
DBL_EPSILON =&gt; cpp/types/climits
LDBL_EPSILON =&gt; cpp/types/climits
FLT_DIG =&gt; cpp/types/climits
DBL_DIG =&gt; cpp/types/climits
LDBL_DIG =&gt; cpp/types/climits
FLT_MANT_DIG =&gt; cpp/types/climits
DBL_MANT_DIG =&gt; cpp/types/climits
LDBL_MANT_DIG =&gt; cpp/types/climits
FLT_MIN_EXP =&gt; cpp/types/climits
DBL_MIN_EXP =&gt; cpp/types/climits
LDBL_MIN_EXP =&gt; cpp/types/climits
FLT_MIN_10_EXP =&gt; cpp/types/climits
DBL_MIN_10_EXP =&gt; cpp/types/climits
LDBL_MIN_10_EXP =&gt; cpp/types/climits
FLT_MAX_EXP =&gt; cpp/types/climits
DBL_MAX_EXP =&gt; cpp/types/climits
LDBL_MAX_EXP =&gt; cpp/types/climits
FLT_MAX_10_EXP =&gt; cpp/types/climits
DBL_MAX_10_EXP =&gt; cpp/types/climits
LDBL_MAX_10_EXP =&gt; cpp/types/climits
FLT_ROUNDS =&gt; cpp/types/climits/FLT_ROUNDS
FLT_EVAL_METHOD =&gt; cpp/types/climits/FLT_EVAL_METHOD
std::type_info =&gt; cpp/types/type_info
std::type_index =&gt; cpp/types/type_index
std::bad_typeid =&gt; cpp/types/bad_typeid
std::bad_cast =&gt; cpp/types/bad_cast
std::is_void =&gt; cpp/types/is_void
std::is_integral =&gt; cpp/types/is_integral
std::is_floating_point =&gt; cpp/types/is_floating_point
std::is_array =&gt; cpp/types/is_array
std::is_pointer =&gt; cpp/types/is_pointer
std::is_lvalue_reference =&gt; cpp/types/is_lvalue_reference
std::is_rvalue_reference =&gt; cpp/types/is_rvalue_reference
std::is_member_object_pointer =&gt; cpp/types/is_member_object_pointer
std::is_member_function_pointer =&gt; cpp/types/is_member_function_pointer
std::is_enum =&gt; cpp/types/is_enum
std::is_union =&gt; cpp/types/is_union
std::is_class =&gt; cpp/types/is_class
std::is_function =&gt; cpp/types/is_function
std::is_reference =&gt; cpp/types/is_reference
std::is_arithmetic =&gt; cpp/types/is_arithmetic
std::is_fundamental =&gt; cpp/types/is_fundamental
std::is_object =&gt; cpp/types/is_object
std::is_scalar =&gt; cpp/types/is_scalar
std::is_compound =&gt; cpp/types/is_compound
std::is_member_pointer =&gt; cpp/types/is_member_pointer
std::is_const =&gt; cpp/types/is_const
std::is_volatile =&gt; cpp/types/is_volatile
std::is_trivial =&gt; cpp/types/is_trivial
std::is_trivially_copyable =&gt; cpp/types/is_trivially_copyable
std::is_standard_layout =&gt; cpp/types/is_standard_layout
std::is_pod =&gt; cpp/types/is_pod
std::is_literal_type =&gt; cpp/types/is_literal_type
std::is_empty =&gt; cpp/types/is_empty
std::is_polymorphic =&gt; cpp/types/is_polymorphic
std::is_abstract =&gt; cpp/types/is_abstract
std::is_signed =&gt; cpp/types/is_signed
std::is_unsigned =&gt; cpp/types/is_unsigned
std::is_constructible =&gt; cpp/types/is_constructible
std::is_trivially_constructible =&gt; cpp/types/is_constructible
std::is_nothrow_constructible =&gt; cpp/types/is_constructible
std::is_default_constructible =&gt; cpp/types/is_default_constructible
std::is_trivially_default_constructible =&gt; cpp/types/is_default_constructible
std::is_nothrow_default_constructible =&gt; cpp/types/is_default_constructible
std::is_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_trivially_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_nothrow_copy_constructible =&gt; cpp/types/is_copy_constructible
std::is_move_constructible =&gt; cpp/types/is_move_constructible
std::is_trivially_move_constructible =&gt; cpp/types/is_move_constructible
std::is_nothrow_move_constructible =&gt; cpp/types/is_move_constructible
std::is_assignable =&gt; cpp/types/is_assignable
std::is_trivially_assignable =&gt; cpp/types/is_assignable
std::is_nothrow_assignable =&gt; cpp/types/is_assignable
std::is_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_trivially_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_nothrow_copy_assignable =&gt; cpp/types/is_copy_assignable
std::is_move_assignable =&gt; cpp/types/is_move_assignable
std::is_trivially_move_assignable =&gt; cpp/types/is_move_assignable
std::is_nothrow_move_assignable =&gt; cpp/types/is_move_assignable
std::is_destructible =&gt; cpp/types/is_destructible
std::is_trivially_destructible =&gt; cpp/types/is_destructible
std::is_nothrow_destructible =&gt; cpp/types/is_destructible
std::has_virtual_destructor =&gt; cpp/types/has_virtual_destructor
std::alignment_of =&gt; cpp/types/alignment_of
std::rank =&gt; cpp/types/rank
std::extent =&gt; cpp/types/extent
std::is_same =&gt; cpp/types/is_same
std::is_base_of =&gt; cpp/types/is_base_of
std::is_convertible =&gt; cpp/types/is_convertible
std::remove_cv =&gt; cpp/types/remove_cv
std::remove_const =&gt; cpp/types/remove_cv
std::remove_volatile =&gt; cpp/types/remove_cv
std::add_cv =&gt; cpp/types/add_cv
std::add_const =&gt; cpp/types/add_cv
std::add_volatile =&gt; cpp/types/add_cv
std::remove_reference =&gt; cpp/types/remove_reference
std::add_lvalue_reference =&gt; cpp/types/add_reference
std::add_rvalue_reference =&gt; cpp/types/add_reference
std::remove_pointer =&gt; cpp/types/remove_pointer
std::add_pointer =&gt; cpp/types/add_pointer
std::make_signed =&gt; cpp/types/make_signed
std::make_unsigned =&gt; cpp/types/make_unsigned
std::remove_extent =&gt; cpp/types/remove_extent
std::remove_all_extents =&gt; cpp/types/remove_all_extents
std::aligned_storage =&gt; cpp/types/aligned_storage
std::aligned_union =&gt; cpp/types/aligned_union
std::decay =&gt; cpp/types/decay
std::enable_if =&gt; cpp/types/enable_if
std::conditional =&gt; cpp/types/conditional
std::common_type =&gt; cpp/types/common_type
std::underlying_type =&gt; cpp/types/underlying_type
std::result_of =&gt; cpp/types/result_of
std::integral_constant =&gt; cpp/types/integral_constant
std::true_type =&gt; cpp/types/integral_constant
std::false_type =&gt; cpp/types/integral_constant
std::iterator_traits =&gt; cpp/iterator/iterator_traits
std::input_iterator_tag =&gt; cpp/iterator/iterator_tags
std::output_iterator_tag =&gt; cpp/iterator/iterator_tags
std::forward_iterator_tag =&gt; cpp/iterator/iterator_tags
std::bidirectional_iterator_tag =&gt; cpp/iterator/iterator_tags
std::random_access_iterator_tag =&gt; cpp/iterator/iterator_tags
std::iterator =&gt; cpp/iterator/iterator
std::reverse_iterator =&gt; cpp/iterator/reverse_iterator
std::move_iterator =&gt; cpp/iterator/move_iterator
std::back_insert_iterator =&gt; cpp/iterator/back_insert_iterator
std::front_insert_iterator =&gt; cpp/iterator/front_insert_iterator
std::insert_iterator =&gt; cpp/iterator/insert_iterator
std::make_move_iterator =&gt; cpp/iterator/make_move_iterator
std::back_inserter =&gt; cpp/iterator/back_inserter
std::front_inserter =&gt; cpp/iterator/front_inserter
std::inserter =&gt; cpp/iterator/inserter
std::istream_iterator =&gt; cpp/iterator/istream_iterator
std::istreambuf_iterator =&gt; cpp/iterator/istreambuf_iterator
std::ostream_iterator =&gt; cpp/iterator/ostream_iterator
std::ostreambuf_iterator =&gt; cpp/iterator/ostreambuf_iterator
std::advance =&gt; cpp/iterator/advance
std::distance =&gt; cpp/iterator/distance
std::next =&gt; cpp/iterator/next
std::prev =&gt; cpp/iterator/prev
std::begin =&gt; cpp/iterator/begin
std::end =&gt; cpp/iterator/end
operator new =&gt; cpp/memory/new/operator_new
operator new[] =&gt; cpp/memory/new/operator_new
operator delete =&gt; cpp/memory/new/operator_delete
operator delete[] =&gt; cpp/memory/new/operator_delete
std::get_new_handler =&gt; cpp/memory/new/get_new_handler
std::set_new_handler =&gt; cpp/memory/new/set_new_handler
std::bad_alloc =&gt; cpp/memory/new/bad_alloc
std::bad_array_new_length =&gt; cpp/memory/new/bad_array_new_length
std::bad_array_length =&gt; cpp/memory/new/bad_array_length
std::nothrow_t =&gt; cpp/memory/new/nothrow_t
std::new_handler =&gt; cpp/memory/new/new_handler
std::nothrow =&gt; cpp/memory/new/nothrow
std::allocator =&gt; cpp/memory/allocator
std::allocator_traits =&gt; cpp/memory/allocator_traits
std::allocator_arg_t =&gt; cpp/memory/allocator_arg_t
std::allocator_arg =&gt; cpp/memory/allocator_arg
std::uses_allocator =&gt; cpp/memory/uses_allocator
std::scoped_allocator_adaptor =&gt; cpp/memory/scoped_allocator_adaptor
std::uninitialized_copy =&gt; cpp/memory/uninitialized_copy
std::uninitialized_copy_n =&gt; cpp/memory/uninitialized_copy_n
std::uninitialized_fill =&gt; cpp/memory/uninitialized_fill
std::uninitialized_fill_n =&gt; cpp/memory/uninitialized_fill_n
std::raw_storage_iterator =&gt; cpp/memory/raw_storage_iterator
std::get_temporary_buffer =&gt; cpp/memory/get_temporary_buffer
std::return_temporary_buffer =&gt; cpp/memory/return_temporary_buffer
std::unique_ptr =&gt; cpp/memory/unique_ptr
std::shared_ptr =&gt; cpp/memory/shared_ptr
std::make_shared =&gt; cpp/memory/shared_ptr/make_shared
std::allocate_shared =&gt; cpp/memory/shared_ptr/allocate_shared
std::static_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::dynamic_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::const_pointer_cast =&gt; cpp/memory/shared_ptr/pointer_cast
std::weak_ptr =&gt; cpp/memory/weak_ptr
std::auto_ptr =&gt; cpp/memory/auto_ptr
std::owner_less =&gt; cpp/memory/owner_less
std::enable_shared_from_this =&gt; cpp/memory/enable_shared_from_this
std::bad_weak_ptr =&gt; cpp/memory/bad_weak_ptr
std::default_delete =&gt; cpp/memory/default_delete
std::declare_reachable =&gt; cpp/memory/gc/declare_reachable
std::undeclare_reachable =&gt; cpp/memory/gc/undeclare_reachable
std::declare_no_pointers =&gt; cpp/memory/gc/declare_no_pointers
std::undeclare_no_pointers =&gt; cpp/memory/gc/undeclare_no_pointers
std::pointer_safety =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::relaxed =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::preferred =&gt; cpp/memory/gc/pointer_safety
std::pointer_safety::strict =&gt; cpp/memory/gc/pointer_safety
std::get_pointer_safety =&gt; cpp/memory/gc/get_pointer_safety
std::pointer_traits =&gt; cpp/memory/pointer_traits
std::addressof =&gt; cpp/memory/addressof
std::align =&gt; cpp/memory/align
std::malloc =&gt; cpp/memory/c/malloc
std::calloc =&gt; cpp/memory/c/calloc
std::realloc =&gt; cpp/memory/c/realloc
std::free =&gt; cpp/memory/c/free
std::exception =&gt; cpp/error/exception
std::logic_error =&gt; cpp/error/logic_error
std::domain_error =&gt; cpp/error/domain_error
std::length_error =&gt; cpp/error/length_error
std::out_of_range =&gt; cpp/error/out_of_range
std::invalid_argument =&gt; cpp/error/invalid_argument
std::runtime_error =&gt; cpp/error/runtime_error
std::range_error =&gt; cpp/error/range_error
std::overflow_error =&gt; cpp/error/overflow_error
std::underflow_error =&gt; cpp/error/underflow_error
assert =&gt; cpp/error/assert
std::uncaught_exception =&gt; cpp/error/uncaught_exception
std::exception_ptr =&gt; cpp/error/exception_ptr
std::make_exception_ptr =&gt; cpp/error/make_exception_ptr
std::current_exception =&gt; cpp/error/current_exception
std::rethrow_exception =&gt; cpp/error/rethrow_exception
std::nested_exception =&gt; cpp/error/nested_exception
std::throw_with_nested =&gt; cpp/error/nested_exception/throw_with_nested
std::rethrow_if_nested =&gt; cpp/error/nexted_exception/rethrow_if_nested
std::terminate =&gt; cpp/error/terminate
std::terminate_handler =&gt; cpp/error/terminate_handler
std::get_terminate =&gt; cpp/error/get_terminate
std::set_terminate =&gt; cpp/error/set_terminate
std::unexpected =&gt; cpp/error/unexpected
std::bad_exception =&gt; cpp/error/bad_exception
std::unexpected_handler =&gt; cpp/error/unexpected_handler
std::get_unexpected =&gt; cpp/error/get_unexpected
std::set_unexpected =&gt; cpp/error/set_unexpected
errno =&gt; cpp/error/errno
E2BIG =&gt; cpp/error/errno_macros
EACCESS =&gt; cpp/error/errno_macros
EADDRINUSE =&gt; cpp/error/errno_macros
EADDRNOTAVAIL =&gt; cpp/error/errno_macros
EAFNOSUPPORT =&gt; cpp/error/errno_macros
EAGAIN =&gt; cpp/error/errno_macros
EALREADY =&gt; cpp/error/errno_macros
EBADF =&gt; cpp/error/errno_macros
EBADMSG =&gt; cpp/error/errno_macros
EBUSY =&gt; cpp/error/errno_macros
ECANCELED =&gt; cpp/error/errno_macros
ECHILD =&gt; cpp/error/errno_macros
ECONNABORTED =&gt; cpp/error/errno_macros
ECONNREFUSED =&gt; cpp/error/errno_macros
ECONNRESET =&gt; cpp/error/errno_macros
EDEADLK =&gt; cpp/error/errno_macros
EDESTADDRREQ =&gt; cpp/error/errno_macros
EDOM =&gt; cpp/error/errno_macros
EEXIST =&gt; cpp/error/errno_macros
EFAULT =&gt; cpp/error/errno_macros
EFBIG =&gt; cpp/error/errno_macros
EHOSTUNREACH =&gt; cpp/error/errno_macros
EIDRM =&gt; cpp/error/errno_macros
EILSEQ =&gt; cpp/error/errno_macros
EINPROGRESS =&gt; cpp/error/errno_macros
EINTR =&gt; cpp/error/errno_macros
EINVAL =&gt; cpp/error/errno_macros
EIO =&gt; cpp/error/errno_macros
EISCONN =&gt; cpp/error/errno_macros
EISDIR =&gt; cpp/error/errno_macros
ELOOP =&gt; cpp/error/errno_macros
EMFILE =&gt; cpp/error/errno_macros
EMLINK =&gt; cpp/error/errno_macros
EMSGSIZE =&gt; cpp/error/errno_macros
ENAMETOOLONG =&gt; cpp/error/errno_macros
ENETDOWN =&gt; cpp/error/errno_macros
ENETRESET =&gt; cpp/error/errno_macros
ENETUNREACH =&gt; cpp/error/errno_macros
ENFILE =&gt; cpp/error/errno_macros
ENOBUFS =&gt; cpp/error/errno_macros
ENODATA =&gt; cpp/error/errno_macros
ENODEV =&gt; cpp/error/errno_macros
ENOENT =&gt; cpp/error/errno_macros
ENOEXEC =&gt; cpp/error/errno_macros
ENOLCK =&gt; cpp/error/errno_macros
ENOLINK =&gt; cpp/error/errno_macros
ENOMEM =&gt; cpp/error/errno_macros
ENOMSG =&gt; cpp/error/errno_macros
ENOPROTOOPT =&gt; cpp/error/errno_macros
ENOSPC =&gt; cpp/error/errno_macros
ENOSR =&gt; cpp/error/errno_macros
ENOSTR =&gt; cpp/error/errno_macros
ENOSYS =&gt; cpp/error/errno_macros
ENOTCONN =&gt; cpp/error/errno_macros
ENOTDIR =&gt; cpp/error/errno_macros
ENOTEMPTY =&gt; cpp/error/errno_macros
ENOTRECOVERABLE =&gt; cpp/error/errno_macros
ENOTSOCK =&gt; cpp/error/errno_macros
ENOTSUP =&gt; cpp/error/errno_macros
ENOTTY =&gt; cpp/error/errno_macros
ENXIO =&gt; cpp/error/errno_macros
EOPNOTSUPP =&gt; cpp/error/errno_macros
EOVERFLOW =&gt; cpp/error/errno_macros
EOWNERDEAD =&gt; cpp/error/errno_macros
EPERM =&gt; cpp/error/errno_macros
EPIPE =&gt; cpp/error/errno_macros
EPROTO =&gt; cpp/error/errno_macros
EPROTONOSUPPORT =&gt; cpp/error/errno_macros
EPROTOTYPE =&gt; cpp/error/errno_macros
ERANGE =&gt; cpp/error/errno_macros
EROFS =&gt; cpp/error/errno_macros
ESPIPE =&gt; cpp/error/errno_macros
ESRCH =&gt; cpp/error/errno_macros
ETIME =&gt; cpp/error/errno_macros
ETIMEDOUT =&gt; cpp/error/errno_macros
ETXTBSY =&gt; cpp/error/errno_macros
EWOULDBLOCK =&gt; cpp/error/errno_macros
EXDEV =&gt; cpp/error/errno_macros
std::error_category =&gt; cpp/error/error_category
std::generic_category =&gt; cpp/error/generic_category
std::system_category =&gt; cpp/error/system_category
std::error_condition =&gt; cpp/error/error_condition
std::is_error_condition_enum =&gt; cpp/error/error_condition/is_error_condition_enum
std::error_code =&gt; cpp/error/error_code
std::is_error_code_enum =&gt; cpp/error/error_code/is_error_code_enum
std::errc =&gt; cpp/error/errc
std::errc::address_family_not_supported =&gt; cpp/error/errc
std::errc::address_in_use =&gt; cpp/error/errc
std::errc::address_not_available =&gt; cpp/error/errc
std::errc::already_connected =&gt; cpp/error/errc
std::errc::argument_list_too_long =&gt; cpp/error/errc
std::errc::argument_out_of_domain =&gt; cpp/error/errc
std::errc::bad_address =&gt; cpp/error/errc
std::errc::bad_file_descriptor =&gt; cpp/error/errc
std::errc::bad_message =&gt; cpp/error/errc
std::errc::broken_pipe =&gt; cpp/error/errc
std::errc::connection_aborted =&gt; cpp/error/errc
std::errc::connection_already_in_progress =&gt; cpp/error/errc
std::errc::connection_refused =&gt; cpp/error/errc
std::errc::connection_reset =&gt; cpp/error/errc
std::errc::cross_device_link =&gt; cpp/error/errc
std::errc::destination_address_required =&gt; cpp/error/errc
std::errc::device_or_resource_busy =&gt; cpp/error/errc
std::errc::directory_not_empty =&gt; cpp/error/errc
std::errc::executable_format_error =&gt; cpp/error/errc
std::errc::file_exists =&gt; cpp/error/errc
std::errc::file_too_large =&gt; cpp/error/errc
std::errc::filename_too_long =&gt; cpp/error/errc
std::errc::function_not_supported =&gt; cpp/error/errc
std::errc::host_unreachable =&gt; cpp/error/errc
std::errc::identifier_removed =&gt; cpp/error/errc
std::errc::illegal_byte_sequence =&gt; cpp/error/errc
std::errc::inappropriate_io_control_operation =&gt; cpp/error/errc
std::errc::interrupted =&gt; cpp/error/errc
std::errc::invalid_argument =&gt; cpp/error/errc
std::errc::invalid_seek =&gt; cpp/error/errc
std::errc::io_error =&gt; cpp/error/errc
std::errc::is_a_directory =&gt; cpp/error/errc
std::errc::message_size =&gt; cpp/error/errc
std::errc::network_down =&gt; cpp/error/errc
std::errc::network_reset =&gt; cpp/error/errc
std::errc::network_unreachable =&gt; cpp/error/errc
std::errc::no_buffer_space =&gt; cpp/error/errc
std::errc::no_child_process =&gt; cpp/error/errc
std::errc::no_link =&gt; cpp/error/errc
std::errc::no_lock_available =&gt; cpp/error/errc
std::errc::no_message_available =&gt; cpp/error/errc
std::errc::no_message =&gt; cpp/error/errc
std::errc::no_protocol_option =&gt; cpp/error/errc
std::errc::no_space_on_device =&gt; cpp/error/errc
std::errc::no_stream_resources =&gt; cpp/error/errc
std::errc::no_such_device_or_address =&gt; cpp/error/errc
std::errc::no_such_device =&gt; cpp/error/errc
std::errc::no_such_file_or_directory =&gt; cpp/error/errc
std::errc::no_such_process =&gt; cpp/error/errc
std::errc::not_a_directory =&gt; cpp/error/errc
std::errc::not_a_socket =&gt; cpp/error/errc
std::errc::not_a_stream =&gt; cpp/error/errc
std::errc::not_connected =&gt; cpp/error/errc
std::errc::not_enough_memory =&gt; cpp/error/errc
std::errc::not_supported =&gt; cpp/error/errc
std::errc::operation_canceled =&gt; cpp/error/errc
std::errc::operation_in_progress =&gt; cpp/error/errc
std::errc::operation_not_permitted =&gt; cpp/error/errc
std::errc::operation_not_supported =&gt; cpp/error/errc
std::errc::operation_would_block =&gt; cpp/error/errc
std::errc::owner_dead =&gt; cpp/error/errc
std::errc::permission_denied =&gt; cpp/error/errc
std::errc::protocol_error =&gt; cpp/error/errc
std::errc::protocol_not_supported =&gt; cpp/error/errc
std::errc::read_only_file_system =&gt; cpp/error/errc
std::errc::resource_deadlock_would_occur =&gt; cpp/error/errc
std::errc::resource_unavailable_try_again =&gt; cpp/error/errc
std::errc::result_out_of_range =&gt; cpp/error/errc
std::errc::state_not_recoverable =&gt; cpp/error/errc
std::errc::stream_timeout =&gt; cpp/error/errc
std::errc::text_file_busy =&gt; cpp/error/errc
std::errc::timed_out =&gt; cpp/error/errc
std::errc::too_many_files_open_in_system =&gt; cpp/error/errc
std::errc::too_many_files_open =&gt; cpp/error/errc
std::errc::too_many_links =&gt; cpp/error/errc
std::errc::too_many_symbolic_link_levels =&gt; cpp/error/errc
std::errc::value_too_large =&gt; cpp/error/errc
std::errc::wrong_protocol_type =&gt; cpp/error/errc
std::system_error =&gt; cpp/error/system_error
std::initializer_list =&gt; cpp/utility/initializer_list
va_start =&gt; cpp/utility/variadic/va_start
va_copy =&gt; cpp/utility/variadic/va_copy
va_arg =&gt; cpp/utility/variadic/va_arg
va_end =&gt; cpp/utility/variadic/va_end
va_list =&gt; cpp/utility/variadic/va_list
std::abort =&gt; cpp/utility/program/abort
std::exit =&gt; cpp/utility/program/exit
std::quick_exit =&gt; cpp/utility/program/quick_exit
std::_Exit =&gt; cpp/utility/program/_Exit
std::atexit =&gt; cpp/utility/program/atexit
std::at_quick_exit =&gt; cpp/utility/program/at_quick_exit
EXIT_SUCCESS =&gt; cpp/utility/program/EXIT_status
EXIT_FAILURE =&gt; cpp/utility/program/EXIT_status
std::system =&gt; cpp/utility/program/system
std::getenv =&gt; cpp/utility/program/getenv
std::signal =&gt; cpp/utility/program/signal
std::raise =&gt; cpp/utility/program/raise
std::sig_atomic_t =&gt; cpp/utility/program/sig_atomic_t
SIG_DFL =&gt; cpp/utility/program/SIG_strategies
SIG_IGN =&gt; cpp/utility/program/SIG_strategies
SIG_ERR =&gt; cpp/utility/program/SIG_ERR
SIGABRT =&gt; cpp/utility/program/SIG_types
SIGFPE =&gt; cpp/utility/program/SIG_types
SIGILL =&gt; cpp/utility/program/SIG_types
SIGINT =&gt; cpp/utility/program/SIG_types
SIGSEGV =&gt; cpp/utility/program/SIG_types
SIGTERM =&gt; cpp/utility/program/SIG_types
std::longjmp =&gt; cpp/utility/program/longjmp
setjmp =&gt; cpp/utility/program/setjmp
std::jmp_buf =&gt; cpp/utility/program/jmp_buf
std::chrono::time_point =&gt; cpp/chrono/time_point
std::chrono::time_point_cast =&gt; cpp/chrono/time_point/time_point_cast
std::chrono::duration =&gt; cpp/chrono/duration
std::chrono::nanoseconds =&gt; cpp/chrono/duration
std::chrono::microseconds =&gt; cpp/chrono/duration
std::chrono::milliseconds =&gt; cpp/chrono/duration
std::chrono::seconds =&gt; cpp/chrono/duration
std::chrono::minutes =&gt; cpp/chrono/duration
std::chrono::hours =&gt; cpp/chrono/duration
std::chrono::duration_cast =&gt; cpp/chrono/duration/duration_cast
std::chrono::treat_as_floating_point =&gt; cpp/chrono/duration/treat_as_floating_point
std::chrono::duration_values =&gt; cpp/chrono/duration_values
std::chrono::system_clock =&gt; cpp/chrono/system_clock
std::chrono::system_clock::is_steady =&gt; cpp/chrono/system_clock
std::chrono::steady_clock =&gt; cpp/chrono/steady_clock
std::chrono::steady_clock::is_steady =&gt; cpp/chrono/steady_clock
std::chrono::high_resolution_clock =&gt; cpp/chrono/high_resolution_clock
std::chrono::high_resolution_clock::is_steady =&gt; cpp/chrono/high_resolution_clock
std::difftime =&gt; cpp/chrono/c/difftime
std::time =&gt; cpp/chrono/c/time
std::clock =&gt; cpp/chrono/c/clock
std::asctime =&gt; cpp/chrono/c/asctime
std::ctime =&gt; cpp/chrono/c/ctime
std::strftime =&gt; cpp/chrono/c/strftime
std::wcsftime =&gt; cpp/chrono/c/wcsftime
std::gmtime =&gt; cpp/chrono/c/gmtime
std::localtime =&gt; cpp/chrono/c/localtime
std::mktime =&gt; cpp/chrono/c/mktime
CLOCKS_PER_SEC =&gt; cpp/chrono/c/CLOCKS_PER_SEC
std::tm =&gt; cpp/chrono/c/tm
std::time_t =&gt; cpp/chrono/c/time_t
std::clock_t =&gt; cpp/chrono/c/clock_t
std::bitset =&gt; cpp/utility/bitset
std::bitset::reference =&gt; cpp/utility/bitset/reference
std::plus =&gt; cpp/utility/functional/plus
std::minus =&gt; cpp/utility/functional/minus
std::multiplies =&gt; cpp/utility/functional/multiplies
std::divides =&gt; cpp/utility/functional/divides
std::modulus =&gt; cpp/utility/functional/modulus
std::negate =&gt; cpp/utility/functional/negate
std::equal_to =&gt; cpp/utility/functional/equal_to
std::not_equal_to =&gt; cpp/utility/functional/not_equal_to
std::greater =&gt; cpp/utility/functional/greater
std::greater_equal =&gt; cpp/utility/functional/greater_equal
std::less =&gt; cpp/utility/functional/less
std::less_equal =&gt; cpp/utility/functional/less_equal
std::logical_and =&gt; cpp/utility/functional/logical_and
std::logical_or =&gt; cpp/utility/functional/logical_or
std::logical_not =&gt; cpp/utility/functional/logical_not
std::bit_and =&gt; cpp/utility/functional/bit_and
std::bit_or =&gt; cpp/utility/functional/bit_or
std::bit_not =&gt; cpp/utility/functional/bit_not
std::unary_negate =&gt; cpp/utility/functional/unary_negate
std::binary_negate =&gt; cpp/utility/functional/binary_negate
std::not1 =&gt; cpp/utility/functional/not1
std::not2 =&gt; cpp/utility/functional/not2
std::bind =&gt; cpp/utility/functional/bind
std::is_bind_expression =&gt; cpp/utility/functional/is_bind_expression
std::is_placeholder =&gt; cpp/utility/functional/is_placeholder
std::mem_fn =&gt; cpp/utility/functional/mem_fn
std::function =&gt; cpp/utility/functional/function
std::bad_function_call =&gt; cpp/utility/functional/bad_function_call
std::placeholders =&gt; cpp/utility/functional/placeholders
std::reference_wrapper =&gt; cpp/utility/functional/reference_wrapper
std::ref =&gt; cpp/utility/functional/ref
std::cref =&gt; cpp/utility/functional/ref
std::pair =&gt; cpp/utility/pair
std::make_pair =&gt; cpp/utility/pair/make_pair
std::tuple =&gt; cpp/utility/tuple
std::piecewise_construct_t =&gt; cpp/utility/piecewise_construct_t
std::piecewise_construct =&gt; cpp/utility/piecewise_construct
std::integer_sequence =&gt; cpp/utility/integer_sequence
std::make_tuple =&gt; cpp/utility/tuple/make_tuple
std::tie =&gt; cpp/utility/tuple/tie
std::forward_as_tuple =&gt; cpp/utility/tuple/forward_as_tuple
std::tuple_cat =&gt; cpp/utility/tuple/tuple_cat
std::tuple_cat =&gt; cpp/utility/tuple/tuple_cat
std::ignore =&gt; cpp/utility/tuple/ignore
std::forward =&gt; cpp/utility/forward
std::move =&gt; cpp/utility/move
std::move_if_noexcept =&gt; cpp/utility/move_if_noexcept
std::declval =&gt; cpp/utility/declval
std::rel_ops::operator!= =&gt; cpp/utility/rel_ops/operator_cmp
std::hash =&gt; cpp/utility/hash
std::unary_function =&gt; cpp/utility/functional/unary_function
std::binary_function =&gt; cpp/utility/functional/binary_function
std::optional =&gt; cpp/utility/optional
std::make_optional =&gt; cpp/utility/optional/make_optional
std::inplace_t =&gt; cpp/utility/inplace_t
std::inplace =&gt; cpp/utility/inplace
std::nullopt_t =&gt; cpp/utility/nullopt_t
std::nullopt =&gt; cpp/utility/nullopt
std::bad_optional_access =&gt; cpp/utility/bad_optional_access
std::isalnum =&gt; cpp/string/byte/isalnum
std::isalpha =&gt; cpp/string/byte/isalpha
std::islower =&gt; cpp/string/byte/islower
std::isupper =&gt; cpp/string/byte/isupper
std::isdigit =&gt; cpp/string/byte/isdigit
std::isxdigit =&gt; cpp/string/byte/isxdigit
std::iscntrl =&gt; cpp/string/byte/iscntrl
std::isgraph =&gt; cpp/string/byte/isgraph
std::isspace =&gt; cpp/string/byte/isspace
std::isblank =&gt; cpp/string/byte/isblank
std::isprint =&gt; cpp/string/byte/isprint
std::ispunct =&gt; cpp/string/byte/ispunct
std::tolower =&gt; cpp/string/byte/tolower
std::toupper =&gt; cpp/string/byte/toupper
std::atof =&gt; cpp/string/byte/atof
std::atoi =&gt; cpp/string/byte/atoi
std::atol =&gt; cpp/string/byte/atoi
std::atoll =&gt; cpp/string/byte/atoi
std::strtol =&gt; cpp/string/byte/strtol
std::strtoll =&gt; cpp/string/byte/strtol
std::strtoul =&gt; cpp/string/byte/strtoul
std::strtoull =&gt; cpp/string/byte/strtoul
std::strtof =&gt; cpp/string/byte/strtof
std::strtod =&gt; cpp/string/byte/strtof
std::strtold =&gt; cpp/string/byte/strtof
std::strtoimax =&gt; cpp/string/byte/strtoimax
std::strtoumax =&gt; cpp/string/byte/strtoimax
std::strcpy =&gt; cpp/string/byte/strcpy
std::strncpy =&gt; cpp/string/byte/strncpy
std::strcat =&gt; cpp/string/byte/strcat
std::strncat =&gt; cpp/string/byte/strncat
std::strxfrm =&gt; cpp/string/byte/strxfrm
std::strlen =&gt; cpp/string/byte/strlen
std::strcmp =&gt; cpp/string/byte/strcmp
std::strncmp =&gt; cpp/string/byte/strncmp
std::strcoll =&gt; cpp/string/byte/strcoll
std::strchr =&gt; cpp/string/byte/strchr
std::strrchr =&gt; cpp/string/byte/strrchr
std::strspn =&gt; cpp/string/byte/strspn
std::strcspn =&gt; cpp/string/byte/strcspn
std::strpbrk =&gt; cpp/string/byte/strpbrk
std::strstr =&gt; cpp/string/byte/strstr
std::strtok =&gt; cpp/string/byte/strtok
std::memchr =&gt; cpp/string/byte/memchr
std::memcmp =&gt; cpp/string/byte/memcmp
std::memset =&gt; cpp/string/byte/memset
std::memcpy =&gt; cpp/string/byte/memcpy
std::memmove =&gt; cpp/string/byte/memmove
std::strerror =&gt; cpp/string/byte/strerror
std::mblen =&gt; cpp/string/multibyte/mblen
std::mbtowc =&gt; cpp/string/multibyte/mbtowc
std::wctomb =&gt; cpp/string/multibyte/wctomb
std::mbstowcs =&gt; cpp/string/multibyte/mbstowcs
std::wcstombs =&gt; cpp/string/multibyte/wcstombs
std::mbsinit =&gt; cpp/string/multibyte/mbsinit
std::btowc =&gt; cpp/string/multibyte/btowc
std::wctob =&gt; cpp/string/multibyte/wctob
std::mbrlen =&gt; cpp/string/multibyte/mbrlen
std::mbrtowc =&gt; cpp/string/multibyte/mbrtowc
std::wcrtomb =&gt; cpp/string/multibyte/wcrtomb
std::mbsrtowcs =&gt; cpp/string/multibyte/mbsrtowcs
std::wcstombs =&gt; cpp/string/multibyte/wcstombs
std::mbrtoc16 =&gt; cpp/string/multibyte/mbrtoc16
std::c16rtomb =&gt; cpp/string/multibyte/c16rtomb
std::mbrtoc32 =&gt; cpp/string/multibyte/mbrtoc32
std::c32rtomb =&gt; cpp/string/multibyte/c32rtomb
std::mbstate_t =&gt; cpp/string/multibyte/mbstate_t
std::iswalnum =&gt; cpp/string/wide/iswalnum
std::iswalpha =&gt; cpp/string/wide/iswalpha
std::iswlower =&gt; cpp/string/wide/iswlower
std::iswupper =&gt; cpp/string/wide/iswupper
std::iswdigit =&gt; cpp/string/wide/iswdigit
std::iswxdigit =&gt; cpp/string/wide/iswxdigit
std::iswcntrl =&gt; cpp/string/wide/iswcntrl
std::iswgraph =&gt; cpp/string/wide/iswgraph
std::iswspace =&gt; cpp/string/wide/iswspace
std::iswblank =&gt; cpp/string/wide/iswblank
std::iswprint =&gt; cpp/string/wide/iswprint
std::iswpunct =&gt; cpp/string/wide/iswpunct
std::iswctype =&gt; cpp/string/wide/iswctype
std::wctype =&gt; cpp/string/wide/wctype
std::towlower =&gt; cpp/string/wide/towlower
std::towupper =&gt; cpp/string/wide/towupper
std::towctrans =&gt; cpp/string/wide/towctrans
std::wctrans =&gt; cpp/string/wide/wctrans
std::wcstof =&gt; cpp/string/wide/wcstof
std::wcstod =&gt; cpp/string/wide/wcstof
std::wcstold =&gt; cpp/string/wide/wcstof
std::wcstol =&gt; cpp/string/wide/wcstol
std::wcstoll =&gt; cpp/string/wide/wcstol
std::wcstoul =&gt; cpp/string/wide/wcstoul
std::wcstoull =&gt; cpp/string/wide/wcstoul
std::wcstoimax =&gt; cpp/string/byte/wcstoimax
std::wcstoumax =&gt; cpp/string/byte/wcstoimax
std::wcscpy =&gt; cpp/string/wide/wcscpy
std::wcsncpy =&gt; cpp/string/wide/wcsncpy
std::wcscat =&gt; cpp/string/wide/wcscat
std::wcsncat =&gt; cpp/string/wide/wcsncat
std::wcsxfrm =&gt; cpp/string/wide/wcsxfrm
std::wcslen =&gt; cpp/string/wide/wcslen
std::wcscmp =&gt; cpp/string/wide/wcscmp
std::wcsncmp =&gt; cpp/string/wide/wcsncmp
std::wcscoll =&gt; cpp/string/wide/wcscoll
std::wcschr =&gt; cpp/string/wide/wcschr
std::wcsrchr =&gt; cpp/string/wide/wcsrchr
std::wcsspn =&gt; cpp/string/wide/wcsspn
std::wcscspn =&gt; cpp/string/wide/wcscspn
std::wcspbrk =&gt; cpp/string/wide/wcspbrk
std::wcsstr =&gt; cpp/string/wide/wcsstr
std::wcstok =&gt; cpp/string/wide/wcstok
std::wmemchr =&gt; cpp/string/wide/wmemchr
std::wmemcmp =&gt; cpp/string/wide/wmemcmp
std::wmemset =&gt; cpp/string/wide/wmemset
std::wmemcpy =&gt; cpp/string/wide/wmemcpy
std::wmemmove =&gt; cpp/string/wide/wmemmove
std::basic_string =&gt; cpp/string/basic_string
std::basic_string::npos =&gt; cpp/string/basic_string/npos
std::string =&gt; cpp/string/basic_string
std::string::npos =&gt; cpp/string/basic_string/npos
std::wstring =&gt; cpp/string/basic_string
std::wstring::npos =&gt; cpp/string/basic_string/npos
std::u16string =&gt; cpp/string/basic_string
std::u16string::npos =&gt; cpp/string/basic_string/npos
std::u32string =&gt; cpp/string/basic_string
std::u32string::npos =&gt; cpp/string/basic_string/npos
std::getline =&gt; cpp/string/basic_string/getline
std::stoi =&gt; cpp/string/basic_string/stol
std::stol =&gt; cpp/string/basic_string/stol
std::stoll =&gt; cpp/string/basic_string/stol
std::stoul =&gt; cpp/string/basic_string/stoul
std::stoull =&gt; cpp/string/basic_string/stoul
std::stof =&gt; cpp/string/basic_string/stof
std::stod =&gt; cpp/string/basic_string/stof
std::stold =&gt; cpp/string/basic_string/stof
std::to_string =&gt; cpp/string/basic_string/to_string
std::to_wstring =&gt; cpp/string/basic_string/to_wstring
std::char_traits =&gt; cpp/string/char_traits
std::array =&gt; cpp/container/array
std::dynarray =&gt; cpp/container/dynarray
std::vector =&gt; cpp/container/vector
std::deque =&gt; cpp/container/deque
std::forward_list =&gt; cpp/container/forward_list
std::list =&gt; cpp/container/list
std::set =&gt; cpp/container/set
std::multiset =&gt; cpp/container/multiset
std::map =&gt; cpp/container/map
std::map::value_compare =&gt; cpp/container/map/value_compare
std::multimap =&gt; cpp/container/multimap
std::multimap::value_compare =&gt; cpp/container/multimap/value_compare
std::unordered_set =&gt; cpp/container/unordered_set
std::unordered_multiset =&gt; cpp/container/unordered_multiset
std::unordered_map =&gt; cpp/container/unordered_map
std::unordered_multimap =&gt; cpp/container/unordered_multimap
std::stack =&gt; cpp/container/stack
std::queue =&gt; cpp/container/queue
std::priority_queue =&gt; cpp/container/priority_queue
std::labs =&gt; cpp/numeric/math/abs
std::llabs =&gt; cpp/numeric/math/abs
std::fabs =&gt; cpp/numeric/math/fabs
std::div =&gt; cpp/numeric/math/div
std::ldiv =&gt; cpp/numeric/math/div
std::fmod =&gt; cpp/numeric/math/fmod
std::remainder =&gt; cpp/numeric/math/remainder
std::remquo =&gt; cpp/numeric/math/remquo
std::fma =&gt; cpp/numeric/math/fma
std::fmax =&gt; cpp/numeric/math/fmax
std::fmin =&gt; cpp/numeric/math/fmin
std::fdim =&gt; cpp/numeric/math/fdim
std::nan =&gt; cpp/numeric/math/nan
std::nanf =&gt; cpp/numeric/math/nan
std::nanl =&gt; cpp/numeric/math/nan
std::exp =&gt; cpp/numeric/math/exp
std::exp2 =&gt; cpp/numeric/math/exp2
std::expm1 =&gt; cpp/numeric/math/expm1
std::log =&gt; cpp/numeric/math/log
std::log10 =&gt; cpp/numeric/math/log10
std::log1p =&gt; cpp/numeric/math/log1p
std::ilogb =&gt; cpp/numeric/math/ilogb
std::logb =&gt; cpp/numeric/math/logb
std::sqrt =&gt; cpp/numeric/math/sqrt
std::cbrt =&gt; cpp/numeric/math/cbrt
std::hypot =&gt; cpp/numeric/math/hypot
std::pow =&gt; cpp/numeric/math/pow
std::sin =&gt; cpp/numeric/math/sin
std::cos =&gt; cpp/numeric/math/cos
std::tan =&gt; cpp/numeric/math/tan
std::asin =&gt; cpp/numeric/math/asin
std::acos =&gt; cpp/numeric/math/acos
std::atan =&gt; cpp/numeric/math/atan
std::atan2 =&gt; cpp/numeric/math/atan2
std::sinh =&gt; cpp/numeric/math/sinh
std::cosh =&gt; cpp/numeric/math/cosh
std::tanh =&gt; cpp/numeric/math/tanh
std::asinh =&gt; cpp/numeric/math/asinh
std::acosh =&gt; cpp/numeric/math/acosh
std::atanh =&gt; cpp/numeric/math/atanh
std::erf =&gt; cpp/numeric/math/erf
std::erfc =&gt; cpp/numeric/math/erfc
std::lgamma =&gt; cpp/numeric/math/lgamma
std::tgamma =&gt; cpp/numeric/math/tgamma
std::ceil =&gt; cpp/numeric/math/ceil
std::floor =&gt; cpp/numeric/math/floor
std::trunc =&gt; cpp/numeric/math/trunc
std::round =&gt; cpp/numeric/math/round
std::lround =&gt; cpp/numeric/math/round
std::llround =&gt; cpp/numeric/math/round
std::nearbyint =&gt; cpp/numeric/math/nearbyint
std::rint =&gt; cpp/numeric/math/rint
std::lrint =&gt; cpp/numeric/math/rint
std::llrint =&gt; cpp/numeric/math/rint
std::frexp =&gt; cpp/numeric/math/frexp
std::ldexp =&gt; cpp/numeric/math/ldexp
std::modf =&gt; cpp/numeric/math/modf
std::scalbn =&gt; cpp/numeric/math/scalbn
std::scalbln =&gt; cpp/numeric/math/scalbn
std::nextafter =&gt; cpp/numeric/math/nextafter
std::nexttoward =&gt; cpp/numeric/math/nextafter
std::copysign =&gt; cpp/numeric/math/copysign
std::fpclassify =&gt; cpp/numeric/math/fpclassify
std::isfinite =&gt; cpp/numeric/math/isfinite
std::isinf =&gt; cpp/numeric/math/isinf
std::isnan =&gt; cpp/numeric/math/isnan
std::isnormal =&gt; cpp/numeric/math/isnormal
std::signbit =&gt; cpp/numeric/math/signbit
HUGE_VAL =&gt; cpp/numeric/math/HUGE_VAL
HUGE_VALF =&gt; cpp/numeric/math/HUGE_VAL
HUGE_VALL =&gt; cpp/numeric/math/HUGE_VAL
INFINITY =&gt; cpp/numeric/math/INFINITY
NAN =&gt; cpp/numeric/math/NAN
math_errhandling =&gt; cpp/numeric/math/math_errhandling
MATH_ERRNO =&gt; cpp/numeric/math/math_errhandling
MATH_ERREXCEPT =&gt; cpp/numeric/math/math_errhandling
FP_INFINITE =&gt; cpp/numeric/math/FP_categories
FP_NAN =&gt; cpp/numeric/math/FP_categories
FP_NORMAL =&gt; cpp/numeric/math/FP_categories
FP_SUBNORMAL =&gt; cpp/numeric/math/FP_categories
FP_ZERO =&gt; cpp/numeric/math/FP_categories
std::feclearexcept =&gt; cpp/numeric/fenv/fecrearexcept
std::fetestexcept =&gt; cpp/numeric/fenv/fetestexcept
std::feraiseexcept =&gt; cpp/numeric/fenv/feraiseexcept
std::fegetexceptflag =&gt; cpp/numeric/fenv/feexceptflag
std::fesetexceptflag =&gt; cpp/numeric/fenv/feexceptflag
std::fegetround =&gt; cpp/numeric/fenv/feround
std::fesetround =&gt; cpp/numeric/fenv/feround
std::fegetenv =&gt; cpp/numeric/fenv/feenv
std::fesetenv =&gt; cpp/numeric/fenv/feenv
std::feholdexcept =&gt; cpp/numeric/fenv/feholdexcept
std::feupdateenv =&gt; cpp/numeric/fenv/feupdateenv
FE_ALL_EXCEPT =&gt; cpp/numeric/fenv/FE_exceptions
FE_DIVBYZERO =&gt; cpp/numeric/fenv/FE_exceptions
FE_INEXACT =&gt; cpp/numeric/fenv/FE_exceptions
FE_INVALID =&gt; cpp/numeric/fenv/FE_exceptions
FE_OVERFLOW =&gt; cpp/numeric/fenv/FE_exceptions
FE_UNDERFLOW =&gt; cpp/numeric/fenv/FE_exceptions
FE_DOWNWARD =&gt; cpp/numeric/fenv/FE_round
FE_TONEAREST =&gt; cpp/numeric/fenv/FE_round
FE_TOWARDZERO =&gt; cpp/numeric/fenv/FE_round
FE_UPWARD =&gt; cpp/numeric/fenv/FE_round
FE_DFL_ENV =&gt; cpp/numeric/fenv/FE_DFL_ENV
std::complex =&gt; cpp/numeric/complex
std::valarray =&gt; cpp/numeric/valarray
std::linear_congruential_engine =&gt; cpp/numeric/random/linear_congruential_engine
std::mersenne_twister_engine =&gt; cpp/numeric/random/mersenne_twister_engine
std::subtract_with_carry_engine =&gt; cpp/numeric/random/subtract_with_carry_engine
std::discard_block_engine =&gt; cpp/numeric/random/discard_block_engine
std::independent_bits_engine =&gt; cpp/numeric/random/independent_bits_engine
std::shuffle_order_engine =&gt; cpp/numeric/random/shuffle_order_engine
std::random_device =&gt; cpp/numeric/random/random_device
std::minstd_rand0 =&gt; cpp/numeric/random/linear_congruential_engine
std::minstd_rand =&gt; cpp/numeric/random/linear_congruential_engine
std::mt19937 =&gt; cpp/numeric/random/mersenne_twister_engine
std::mt19937_64 =&gt; cpp/numeric/random/mersenne_twister_engine
std::ranlux24_base =&gt; cpp/numeric/random/subtract_with_carry_engine
std::ranlux48_base =&gt; cpp/numeric/random/subtract_with_carry_engine
std::ranlux24 =&gt; cpp/numeric/random/discard_block_engine
std::ranlux48 =&gt; cpp/numeric/random/discard_block_engine
std::knuth_b =&gt; cpp/numeric/random/shuffle_order_engine
std::default_random_engine =&gt; cpp/numeric/random
std::srand =&gt; cpp/numeric/random/srand
std::rand =&gt; cpp/numeric/random/rand
RAND_MAX =&gt; cpp/numeric/random/RAND_MAX
std::generate_canonical =&gt; cpp/numeric/random/generate_canonical
std::seed_seq =&gt; cpp/numeric/random/seed_seq
std::uniform_int_distribution =&gt; cpp/numeric/random/uniform_int_distribution
std::uniform_real_distribution =&gt; cpp/numeric/random/uniform_real_distribution
std::bernoulli_distribution =&gt; cpp/numeric/random/bernoulli_distribution
std::binomial_distribution =&gt; cpp/numeric/random/binomial_distribution
std::negative_binomial_distribution =&gt; cpp/numeric/random/negative_binomial_distribution
std::geometric_distribution =&gt; cpp/numeric/random/geometric_distribution
std::poisson_distribution =&gt; cpp/numeric/random/poisson_distribution
std::exponential_distribution =&gt; cpp/numeric/random/exponential_distribution
std::gamma_distribution =&gt; cpp/numeric/random/gamma_distribution
std::weibull_distribution =&gt; cpp/numeric/random/weibull_distribution
std::extreme_value_distribution =&gt; cpp/numeric/random/extreme_value_distribution
std::normal_distribution =&gt; cpp/numeric/random/normal_distribution
std::lognormal_distribution =&gt; cpp/numeric/random/lognormal_distribution
std::chi_squared_distribution =&gt; cpp/numeric/random/chi_squared_distribution
std::cauchy_distribution =&gt; cpp/numeric/random/cauchy_distribution
std::fisher_f_distribution =&gt; cpp/numeric/random/fisher_f_distribution
std::student_t_distribution =&gt; cpp/numeric/random/student_t_distribution
std::discrete_distribution =&gt; cpp/numeric/random/discrete_distribution
std::piecewise_constant_distribution =&gt; cpp/numeric/random/piecewise_constant_distribution
std::piecewise_linear_distribution =&gt; cpp/numeric/random/piecewise_linear_distribution
std::ratio =&gt; cpp/numeric/ratio/ratio
std::yocto =&gt; cpp/numeric/ratio/ratio
std::femto =&gt; cpp/numeric/ratio/ratio
std::pico =&gt; cpp/numeric/ratio/ratio
std::nano =&gt; cpp/numeric/ratio/ratio
std::micro =&gt; cpp/numeric/ratio/ratio
std::milli =&gt; cpp/numeric/ratio/ratio
std::centi =&gt; cpp/numeric/ratio/ratio
std::deci =&gt; cpp/numeric/ratio/ratio
std::deca =&gt; cpp/numeric/ratio/ratio
std::hecto =&gt; cpp/numeric/ratio/ratio
std::kilo =&gt; cpp/numeric/ratio/ratio
std::mega =&gt; cpp/numeric/ratio/ratio
std::giga =&gt; cpp/numeric/ratio/ratio
std::tera =&gt; cpp/numeric/ratio/ratio
std::peta =&gt; cpp/numeric/ratio/ratio
std::exa =&gt; cpp/numeric/ratio/ratio
std::zetta =&gt; cpp/numeric/ratio/ratio
std::yotta =&gt; cpp/numeric/ratio/ratio
std::ratio_add =&gt; cpp/numeric/ratio/ratio_add
std::ratio_subtract =&gt; cpp/numeric/ratio/ratio_subtract
std::ratio_multiply =&gt; cpp/numeric/ratio/ratio_multiply
std::ratio_divide =&gt; cpp/numeric/ratio/ratio_divide
std::ratio_equal =&gt; cpp/numeric/ratio/ratio_equal
std::ratio_not_equal =&gt; cpp/numeric/ratio/ratio_not_equal
std::ratio_less =&gt; cpp/numeric/ratio/ratio_less
std::ratio_less_equal =&gt; cpp/numeric/ratio/ratio_less_equal
std::ratio_greater =&gt; cpp/numeric/ratio/ratio_greater
std::ratio_greater_equal =&gt; cpp/numeric/ratio/ratio_greater_equal
std::all_of =&gt; cpp/algorithm/all_any_none_of
std::any_of =&gt; cpp/algorithm/all_any_none_of
std::none_of =&gt; cpp/algorithm/all_any_none_of
std::for_each =&gt; cpp/algorithm/for_each
std::count =&gt; cpp/algorithm/count
std::count_if =&gt; cpp/algorithm/count
std::mismatch =&gt; cpp/algorithm/mismatch
std::equal =&gt; cpp/algorithm/equal
std::find =&gt; cpp/algorithm/find
std::find_if =&gt; cpp/algorithm/find
std::find_if_not =&gt; cpp/algorithm/find
std::find_end =&gt; cpp/algorithm/find_end
std::find_first_of =&gt; cpp/algorithm/find_first_of
std::adjacent_find =&gt; cpp/algorithm/adjacent_find
std::search =&gt; cpp/algorithm/search
std::search_n =&gt; cpp/algorithm/search_n
std::copy =&gt; cpp/algorithm/copy
std::copy_if =&gt; cpp/algorithm/copy
std::copy_n =&gt; cpp/algorithm/copy_n
std::copy_backward =&gt; cpp/algorithm/copy_backward
std::move =&gt; cpp/algorithm/move
std::move_backward =&gt; cpp/algorithm/move_backward
std::fill =&gt; cpp/algorithm/fill
std::fill_n =&gt; cpp/algorithm/fill_n
std::transform =&gt; cpp/algorithm/transform
std::generate =&gt; cpp/algorithm/generate
std::generate_n =&gt; cpp/algorithm/generate_n
std::remove =&gt; cpp/algorithm/remove
std::remove_if =&gt; cpp/algorithm/remove
std::remove_copy =&gt; cpp/algorithm/remove_copy
std::remove_copy_if =&gt; cpp/algorithm/remove_copy
std::replace =&gt; cpp/algorithm/replace
std::replace_if =&gt; cpp/algorithm/replace
std::replace_copy =&gt; cpp/algorithm/replace_copy
std::replace_copy_if =&gt; cpp/algorithm/replace_copy
std::swap =&gt; cpp/algorithm/swap
std::swap_ranges =&gt; cpp/algorithm/swap_ranges
std::iter_swap =&gt; cpp/algorithm/iter_swap
std::reverse =&gt; cpp/algorithm/reverse
std::reverse_copy =&gt; cpp/algorithm/reverse_copy
std::rotate =&gt; cpp/algorithm/rotate
std::rotate_copy =&gt; cpp/algorithm/rotate_copy
std::random_shuffle =&gt; cpp/algorithm/random_shuffle
std::shuffle =&gt; cpp/algorithm/random_shuffle
std::unique =&gt; cpp/algorithm/unique
std::unique_copy =&gt; cpp/algorithm/unique_copy
std::is_partitioned =&gt; cpp/algorithm/is_partitioned
std::partition =&gt; cpp/algorithm/partition
std::partition_copy =&gt; cpp/algorithm/partition_copy
std::stable_partition =&gt; cpp/algorithm/stable_partition
std::partition_point =&gt; cpp/algorithm/partition_point
std::is_sorted =&gt; cpp/algorithm/is_sorted
std::is_sorted_until =&gt; cpp/algorithm/is_sorted_until
std::sort =&gt; cpp/algorithm/sort
std::partial_sort =&gt; cpp/algorithm/partial_sort
std::partial_sort_copy =&gt; cpp/algorithm/partial_sort_copy
std::stable_sort =&gt; cpp/algorithm/stable_sort
std::nth_element =&gt; cpp/algorithm/nth_element
std::lower_bound =&gt; cpp/algorithm/lower_bound
std::upper_bound =&gt; cpp/algorithm/upper_bound
std::binary_search =&gt; cpp/algorithm/binary_search
std::equal_range =&gt; cpp/algorithm/equal_range
std::merge =&gt; cpp/algorithm/merge
std::inplace_merge =&gt; cpp/algorithm/inplace_merge
std::includes =&gt; cpp/algorithm/includes
std::set_difference =&gt; cpp/algorithm/set_difference
std::set_intersection =&gt; cpp/algorithm/set_intersection
std::set_symmetric_difference =&gt; cpp/algorithm/set_symmetric_difference
std::set_union =&gt; cpp/algorithm/set_union
std::is_heap =&gt; cpp/algorithm/is_heap
std::is_heap_until =&gt; cpp/algorithm/is_heap_until
std::make_heap =&gt; cpp/algorithm/make_heap
std::push_heap =&gt; cpp/algorithm/push_heap
std::pop_heap =&gt; cpp/algorithm/pop_heap
std::sort_heap =&gt; cpp/algorithm/sort_heap
std::max =&gt; cpp/algorithm/max
std::max_element =&gt; cpp/algorithm/max_element
std::min =&gt; cpp/algorithm/min
std::min_element =&gt; cpp/algorithm/min_element
std::minmax =&gt; cpp/algorithm/minmax
std::minmax_element =&gt; cpp/algorithm/minmax_element
std::lexicographical_compare =&gt; cpp/algorithm/lexicographical_compare
std::is_permutation =&gt; cpp/algorithm/is_permutation
std::next_permutation =&gt; cpp/algorithm/next_permutation
std::prev_permutation =&gt; cpp/algorithm/prev_permutation
std::accumulate =&gt; cpp/algorithm/accumulate
std::inner_product =&gt; cpp/algorithm/inner_product
std::adjacent_difference =&gt; cpp/algorithm/adjacent_difference
std::partial_sum =&gt; cpp/algorithm/partial_sum
std::iota =&gt; cpp/algorithm/iota
std::qsort =&gt; cpp/algorithm/qsort
std::bsearch =&gt; cpp/algorithm/bsearch
std::basic_streambuf =&gt; cpp/io/basic_streambuf
std::basic_filebuf =&gt; cpp/io/basic_filebuf
std::basic_stringbuf =&gt; cpp/io/basic_stringbuf
std::ios_base =&gt; cpp/io/ios_base
std::ios_base::failure =&gt; cpp/io/ios_base/failure
std::ios_base::openmode =&gt; cpp/io/ios_base/openmode
std::ios_base::app =&gt; cpp/io/ios_base/openmode
std::ios_base::binary =&gt; cpp/io/ios_base/openmode
std::ios_base::in =&gt; cpp/io/ios_base/openmode
std::ios_base::out =&gt; cpp/io/ios_base/openmode
std::ios_base::trunc =&gt; cpp/io/ios_base/openmode
std::ios_base::ate =&gt; cpp/io/ios_base/openmode
std::ios_base::fmtflags =&gt; cpp/io/ios_base/fmtflags
std::ios_base::dec =&gt; cpp/io/ios_base/fmtflags
std::ios_base::oct =&gt; cpp/io/ios_base/fmtflags
std::ios_base::hex =&gt; cpp/io/ios_base/fmtflags
std::ios_base::basefield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::left =&gt; cpp/io/ios_base/fmtflags
std::ios_base::right =&gt; cpp/io/ios_base/fmtflags
std::ios_base::internal =&gt; cpp/io/ios_base/fmtflags
std::ios_base::adjustfield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::scientific =&gt; cpp/io/ios_base/fmtflags
std::ios_base::fixed =&gt; cpp/io/ios_base/fmtflags
std::ios_base::floatfield =&gt; cpp/io/ios_base/fmtflags
std::ios_base::boolalpha =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showbase =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showpoint =&gt; cpp/io/ios_base/fmtflags
std::ios_base::showpos =&gt; cpp/io/ios_base/fmtflags
std::ios_base::skipws =&gt; cpp/io/ios_base/fmtflags
std::ios_base::unitbuf =&gt; cpp/io/ios_base/fmtflags
std::ios_base::uppercase =&gt; cpp/io/ios_base/fmtflags
std::ios_base::iostate =&gt; cpp/io/ios_base/iostate
std::ios_base::goodbit =&gt; cpp/io/ios_base/iostate
std::ios_base::badbit =&gt; cpp/io/ios_base/iostate
std::ios_base::failbit =&gt; cpp/io/ios_base/iostate
std::ios_base::eofbit =&gt; cpp/io/ios_base/iostate
std::ios_base::seekdir =&gt; cpp/io/ios_base/seekdir
std::ios_base::beg =&gt; cpp/io/ios_base/seekdir
std::ios_base::cur =&gt; cpp/io/ios_base/seekdir
std::ios_base::end =&gt; cpp/io/ios_base/seekdir
std::ios_base::event =&gt; cpp/io/ios_base/event
std::ios_base::erase_event =&gt; cpp/io/ios_base/event
std::ios_base::imbue_event =&gt; cpp/io/ios_base/event
std::ios_base::copyfmt_event =&gt; cpp/io/ios_base/event
std::ios_base::event_callback =&gt; cpp/io/ios_base/event_callback
std::basic_ios =&gt; cpp/io/basic_ios
std::basic_istream =&gt; cpp/io/basic_istream
std::basic_istream::sentry =&gt; cpp/io/basic_istream/sentry
std::basic_ostream =&gt; cpp/io/basic_ostream
std::basic_ostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::basic_iostream =&gt; cpp/io/basic_iostream
std::basic_ifstream =&gt; cpp/io/basic_ifstream
std::basic_ofstream =&gt; cpp/io/basic_ofstream
std::basic_fstream =&gt; cpp/io/basic_fstream
std::basic_istringstream =&gt; cpp/io/basic_istringstream
std::basic_ostringstream =&gt; cpp/io/basic_ostringstream
std::basic_stringstream =&gt; cpp/io/basic_stringstream
std::streambuf =&gt; cpp/io/basic_streambuf
std::filebuf =&gt; cpp/io/basic_filebuf
std::stringbuf =&gt; cpp/io/basic_stringbuf
std::istream =&gt; cpp/io/basic_istream
std::istream::sentry =&gt; cpp/io/basic_istream/sentry
std::ostream =&gt; cpp/io/basic_ostream
std::ostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::iostream =&gt; cpp/io/basic_iostream
std::ifstream =&gt; cpp/io/basic_ifstream
std::ofstream =&gt; cpp/io/basic_ofstream
std::fstream =&gt; cpp/io/basic_fstream
std::istringstream =&gt; cpp/io/basic_istringstream
std::ostringstream =&gt; cpp/io/basic_ostringstream
std::stringstream =&gt; cpp/io/basic_stringstream
std::wstreambuf =&gt; cpp/io/basic_streambuf
std::wfilebuf =&gt; cpp/io/basic_filebuf
std::wstringbuf =&gt; cpp/io/basic_stringbuf
std::wistream =&gt; cpp/io/basic_istream
std::wistream::sentry =&gt; cpp/io/basic_istream/sentry
std::wostream =&gt; cpp/io/basic_ostream
std::wostream::sentry =&gt; cpp/io/basic_ostream/sentry
std::wiostream =&gt; cpp/io/basic_iostream
std::wifstream =&gt; cpp/io/basic_ifstream
std::wofstream =&gt; cpp/io/basic_ofstream
std::wfstream =&gt; cpp/io/basic_fstream
std::wistringstream =&gt; cpp/io/basic_istringstream
std::wostringstream =&gt; cpp/io/basic_ostringstream
std::wstringstream =&gt; cpp/io/basic_stringstream
std::cin =&gt; cpp/io/basic_istream
std::wcin =&gt; cpp/io/basic_istream
std::cout =&gt; cpp/io/basic_ostream
std::wcout =&gt; cpp/io/basic_ostream
std::cerr =&gt; cpp/io/basic_ostream
std::wcerr =&gt; cpp/io/basic_ostream
std::clog =&gt; cpp/io/basic_ostream
std::wclog =&gt; cpp/io/basic_ostream
std::boolalpha =&gt; cpp/io/manip/boolalpha
std::noboolalpha =&gt; cpp/io/manip/boolalpha
std::showbase =&gt; cpp/io/manip/showbase
std::noshowbase =&gt; cpp/io/manip/showbase
std::showpoint =&gt; cpp/io/manip/showpoint
std::noshowpoint =&gt; cpp/io/manip/showpoint
std::showpos =&gt; cpp/io/manip/showpos
std::noshowpos =&gt; cpp/io/manip/showpos
std::skipws =&gt; cpp/io/manip/skipws
std::noskipws =&gt; cpp/io/manip/skipws
std::uppercase =&gt; cpp/io/manip/uppercase
std::nouppercase =&gt; cpp/io/manip/uppercase
std::unitbuf =&gt; cpp/io/manip/unitbuf
std::nounitbuf =&gt; cpp/io/manip/unitbuf
std::internal =&gt; cpp/io/manip/left
std::left =&gt; cpp/io/manip/left
std::right =&gt; cpp/io/manip/left
std::dec =&gt; cpp/io/manip/hex
std::hex =&gt; cpp/io/manip/hex
std::oct =&gt; cpp/io/manip/hex
std::fixed =&gt; cpp/io/manip/fixed
std::scientific =&gt; cpp/io/manip/fixed
std::hexfloat =&gt; cpp/io/manip/fixed
std::defaultfloat =&gt; cpp/io/manip/fixed
std::ws =&gt; cpp/io/manip/ws
std::ends =&gt; cpp/io/manip/ends
std::flush =&gt; cpp/io/manip/flush
std::endl =&gt; cpp/io/manip/endl
std::resetiosflags =&gt; cpp/io/manip/resetiosflags
std::setiosflags =&gt; cpp/io/manip/setiosflags
std::setbase =&gt; cpp/io/manip/setbase
std::setfill =&gt; cpp/io/manip/setfill
std::setprecision =&gt; cpp/io/manip/setprecision
std::setw =&gt; cpp/io/manip/setw
std::get_money =&gt; cpp/io/manip/get_money
std::put_money =&gt; cpp/io/manip/put_money
std::get_time =&gt; cpp/io/manip/get_time
std::put_time =&gt; cpp/io/manip/put_time
std::streamoff =&gt; cpp/io/streamoff
std::streamsize =&gt; cpp/io/streamsize
std::fpos =&gt; cpp/io/fpos
std::streampos =&gt; cpp/io/fpos
std::u16streampos =&gt; cpp/io/fpos
std::u32streampos =&gt; cpp/io/fpos
std::wstreampos =&gt; cpp/io/fpos
std::io_errc =&gt; cpp/io/io_errc
std::io_errc::stream =&gt; cpp/io/io_errc
std::fopen =&gt; cpp/io/c/fopen
std::freopen =&gt; cpp/io/c/freopen
std::fflush =&gt; cpp/io/c/fflush
std::fclose =&gt; cpp/io/c/fclose
std::setbuf =&gt; cpp/io/c/setbuf
std::setvbuf =&gt; cpp/io/c/setvbuf
std::fread =&gt; cpp/io/c/fread
std::fwrite =&gt; cpp/io/c/fwrite
std::fgetc =&gt; cpp/io/c/fgetc
std::getc =&gt; cpp/io/c/fgetc
std::fgets =&gt; cpp/io/c/fgets
std::fputc =&gt; cpp/io/c/fputc
std::putc =&gt; cpp/io/c/fputc
std::fputs =&gt; cpp/io/c/fputs
std::getchar =&gt; cpp/io/c/getchar
std::gets =&gt; cpp/io/c/gets
std::putchar =&gt; cpp/io/c/putchar
std::puts =&gt; cpp/io/c/puts
std::ungetc =&gt; cpp/io/c/ungetc
std::fgetwc =&gt; cpp/io/c/fgetwc
std::fgetss =&gt; cpp/io/c/fgetws
std::fputwc =&gt; cpp/io/c/fputwc
std::fputws =&gt; cpp/io/c/fputws
std::getwchar =&gt; cpp/io/c/getwchar
std::putwchar =&gt; cpp/io/c/putwchar
std::ungetwc =&gt; cpp/io/c/ungetwc
std::scanf =&gt; cpp/io/c/fscanf
std::fscanf =&gt; cpp/io/c/fscanf
std::sscanf =&gt; cpp/io/c/fscanf
std::vscanf =&gt; cpp/io/c/vfscanf
std::vfscanf =&gt; cpp/io/c/vfscanf
std::vsscanf =&gt; cpp/io/c/vfscanf
std::printf =&gt; cpp/io/c/fprintf
std::fprintf =&gt; cpp/io/c/fprintf
std::sprintf =&gt; cpp/io/c/fprintf
std::snprintf =&gt; cpp/io/c/fprintf
std::vprintf =&gt; cpp/io/c/vfprintf
std::vfprintf =&gt; cpp/io/c/vfprintf
std::vsprintf =&gt; cpp/io/c/vfprintf
std::vsnprintf =&gt; cpp/io/c/vfprintf
std::wscanf =&gt; cpp/io/c/fwscanf
std::fwscanf =&gt; cpp/io/c/fwscanf
std::swscanf =&gt; cpp/io/c/fwscanf
std::vwscanf =&gt; cpp/io/c/vfwscanf
std::vfwscanf =&gt; cpp/io/c/vfwscanf
std::vswscanf =&gt; cpp/io/c/vfwscanf
std::wprintf =&gt; cpp/io/c/fwprintf
std::fwprintf =&gt; cpp/io/c/fwprintf
std::swprintf =&gt; cpp/io/c/fwprintf
std::vwprintf =&gt; cpp/io/c/vfwprintf
std::vfwprintf =&gt; cpp/io/c/vfwprintf
std::vswprintf =&gt; cpp/io/c/vfwprintf
std::ftell =&gt; cpp/io/c/ftell
std::fgetpos =&gt; cpp/io/c/fgetpos
std::fseek =&gt; cpp/io/c/fseek
std::fsetpos =&gt; cpp/io/c/fsetpos
std::rewind =&gt; cpp/io/c/rewind
std::clearerr =&gt; cpp/io/c/clearerr
std::feof =&gt; cpp/io/c/feof
std::ferror =&gt; cpp/io/c/ferror
std::perror =&gt; cpp/io/c/perror
std::remove =&gt; cpp/io/c/remove
std::rename =&gt; cpp/io/c/rename
std::tmpfile =&gt; cpp/io/c/tmpfile
std::tmpnam =&gt; cpp/io/c/tmpnam
std::FILE =&gt; cpp/io/c
std::fpos_t =&gt; cpp/io/c
stdin =&gt; cpp/io/c
stdout =&gt; cpp/io/c
stderr =&gt; cpp/io/c
EOF =&gt; cpp/io/c
FOPEN_MAX =&gt; cpp/io/c
FILENAME_MAX =&gt; cpp/io/c
BUFSIZ =&gt; cpp/io/c
_IOFBF =&gt; cpp/io/c
_IOLBF =&gt; cpp/io/c
_IONBF =&gt; cpp/io/c
SEEK_SET =&gt; cpp/io/c
SEEK_CUR =&gt; cpp/io/c
SEEK_END =&gt; cpp/io/c
TMP_MAX =&gt; cpp/io/c
L_tmpnam =&gt; cpp/io/c
std::locale =&gt; cpp/locale/locale
std::locale::id =&gt; cpp/locale/locale/id
std::locale::facet =&gt; cpp/locale/locale/facet
std::use_facet =&gt; cpp/locale/use_facet
std::has_facet =&gt; cpp/locale/has_facet
std::wstring_convert =&gt; cpp/locale/wstring_convert
std::wbuffer_convert =&gt; cpp/locale/wbuffer_convert
std::ctype_base =&gt; cpp/locale/ctype_base
std::ctype_base::mask =&gt; cpp/locale/ctype_base
std::ctype_base::space =&gt; cpp/locale/ctype_base
std::ctype_base::print =&gt; cpp/locale/ctype_base
std::ctype_base::cntrl =&gt; cpp/locale/ctype_base
std::ctype_base::upper =&gt; cpp/locale/ctype_base
std::ctype_base::lower =&gt; cpp/locale/ctype_base
std::ctype_base::alpha =&gt; cpp/locale/ctype_base
std::ctype_base::digit =&gt; cpp/locale/ctype_base
std::ctype_base::punct =&gt; cpp/locale/ctype_base
std::ctype_base::xdigit =&gt; cpp/locale/ctype_base
std::ctype_base::blank =&gt; cpp/locale/ctype_base
std::ctype_base::alnum =&gt; cpp/locale/ctype_base
std::ctype_base::graph =&gt; cpp/locale/ctype_base
std::codecvt_base =&gt; cpp/locale/codecvt_base
std::codecvt_base::result =&gt; cpp/locale/codecvt_base
std::codecvt_base::ok =&gt; cpp/locale/codecvt_base
std::codecvt_base::partial =&gt; cpp/locale/codecvt_base
std::codecvt_base::error =&gt; cpp/locale/codecvt_base
std::codecvt_base::noconv =&gt; cpp/locale/codecvt_base
std::messages_base =&gt; cpp/locale/messages_base
std::messages_base::catalog =&gt; cpp/locale/messages_base
std::time_base =&gt; cpp/locale/time_base
std::time_base::dateorder =&gt; cpp/locale/time_base
std::time_base::no_order =&gt; cpp/locale/time_base
std::time_base::dmy =&gt; cpp/locale/time_base
std::time_base::mdy =&gt; cpp/locale/time_base
std::time_base::ymd =&gt; cpp/locale/time_base
std::time_base::ydm =&gt; cpp/locale/time_base
std::money_base =&gt; cpp/locale/money_base
std::money_base::part =&gt; cpp/locale/money_base
std::money_base::none =&gt; cpp/locale/money_base
std::money_base::space =&gt; cpp/locale/money_base
std::money_base::symbol =&gt; cpp/locale/money_base
std::money_base::sign =&gt; cpp/locale/money_base
std::money_base::value =&gt; cpp/locale/money_base
std::money_base::pattern =&gt; cpp/locale/money_base
std::ctype =&gt; cpp/locale/ctype
std::codecvt =&gt; cpp/locale/codecvt
std::codecvt::intern_type =&gt; cpp/locale/codecvt
std::codecvt::extern_type =&gt; cpp/locale/codecvt
std::codecvt::state_type =&gt; cpp/locale/codecvt
std::collate =&gt; cpp/locale/collate
std::collate::char_type =&gt; cpp/locale/collate
std::collate::string_type =&gt; cpp/locale/collate
std::messages =&gt; cpp/locale/messages
std::messages::char_type =&gt; cpp/locale/messages
std::messages::string_type =&gt; cpp/locale/messages
std::time_get =&gt; cpp/locale/time_get
std::time_get::char_type =&gt; cpp/locale/time_get
std::time_get::iter_type =&gt; cpp/locale/time_get
std::time_put =&gt; cpp/locale/time_put
std::time_put::char_type =&gt; cpp/locale/time_put
std::time_put::iter_type =&gt; cpp/locale/time_put
std::num_get =&gt; cpp/locale/num_get
std::num_get::char_type =&gt; cpp/locale/num_get
std::num_get::iter_type =&gt; cpp/locale/num_get
std::num_put =&gt; cpp/locale/num_put
std::num_put::char_type =&gt; cpp/locale/num_put
std::num_put::iter_type =&gt; cpp/locale/num_put
std::numpunct =&gt; cpp/locale/numpunct
std::numpunct::char_type =&gt; cpp/locale/numpunct
std::numpunct::string_type =&gt; cpp/locale/numpunct
std::money_get =&gt; cpp/locale/money_get
std::money_get::char_type =&gt; cpp/locale/money_get
std::money_get::iter_type =&gt; cpp/locale/money_get
std::money_get::string_type =&gt; cpp/locale/money_get
std::money_put =&gt; cpp/locale/money_put
std::money_put::char_type =&gt; cpp/locale/money_put
std::money_put::iter_type =&gt; cpp/locale/money_put
std::money_put::string_type =&gt; cpp/locale/money_put
std::moneypunct =&gt; cpp/locale/moneypunct
std::moneypunct::char_type =&gt; cpp/locale/moneypunct
std::moneypunct::string_type =&gt; cpp/locale/moneypunct
std::ctype_byname =&gt; cpp/locale/ctype_byname
std::codecvt_byname =&gt; cpp/locale/codecvt_byname
std::messages_byname =&gt; cpp/locale/messages_byname
std::collate_byname =&gt; cpp/locale/collate_byname
std::time_get_byname =&gt; cpp/locale/time_get_byname
std::time_put_byname =&gt; cpp/locale/time_put_byname
std::numpunct_byname =&gt; cpp/locale/numpunct_byname
std::moneypunct_byname =&gt; cpp/locale/moneypunct_byname
std::codecvt_utf8 =&gt; cpp/locale/codecvt_utf8
std::codecvt_utf16 =&gt; cpp/locale/codecvt_utf16
std::codecvt_utf8_utf16 =&gt; cpp/locale/codecvt_utf8_utf16
std::codecvt_mode =&gt; cpp/locale/codecvt_mode
std::consume_header =&gt; cpp/locale/codecvt_mode
std::generate_header =&gt; cpp/locale/codecvt_mode
std::little_endian =&gt; cpp/locale/codecvt_mode
std::setlocale =&gt; cpp/locale/setlocale
std::localeconv =&gt; cpp/locale/localeconv
std::lconv =&gt; cpp/locale/lconv
LC_ALL =&gt; cpp/locale/LC_categories
LC_COLLATE =&gt; cpp/locale/LC_categories
LC_CTYPE =&gt; cpp/locale/LC_categories
LC_MONETARY =&gt; cpp/locale/LC_categories
LC_NUMERIC =&gt; cpp/locale/LC_categories
LC_TIME =&gt; cpp/locale/LC_categories
std::basic_regex =&gt; cpp/regex/basic_regex
std::regex =&gt; cpp/regex/basic_regex
std::wregex =&gt; cpp/regex/basic_regex
std::sub_match =&gt; cpp/regex/sub_match
std::csub_match =&gt; cpp/regex/sub_match
std::wcsub_match =&gt; cpp/regex/sub_match
std::ssub_match =&gt; cpp/regex/sub_match
std::wssub_match =&gt; cpp/regex/sub_match
std::match_results =&gt; cpp/regex/match_results
std::cmatch =&gt; cpp/regex/match_results
std::wcmatch =&gt; cpp/regex/match_results
std::smatch =&gt; cpp/regex/match_results
std::wsmatch =&gt; cpp/regex/match_results
std::regex_match =&gt; cpp/regex/regex_match
std::regex_search =&gt; cpp/regex/regex_search
std::regex_replace =&gt; cpp/regex/regex_replace
std::regex_iterator =&gt; cpp/regex/regex_iterator
std::cregex_iterator =&gt; cpp/regex/regex_iterator
std::wcregex_iterator =&gt; cpp/regex/regex_iterator
std::sregex_iterator =&gt; cpp/regex/regex_iterator
std::wsregex_iterator =&gt; cpp/regex/regex_iterator
std::regex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::cregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::wcregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::sregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::wsregex_token_iterator =&gt; cpp/regex/regex_token_iterator
std::regex_error =&gt; cpp/regex/regex_error
std::regex_traits =&gt; cpp/regex/regex_traits
std::regex_constants::syntax_option_type =&gt; cpp/regex/syntax_option_type
std::regex_constants::icase =&gt; cpp/regex/syntax_option_type
std::regex_constants::nosubs =&gt; cpp/regex/syntax_option_type
std::regex_constants::optimize =&gt; cpp/regex/syntax_option_type
std::regex_constants::collate =&gt; cpp/regex/syntax_option_type
std::regex_constants::ECMAScript =&gt; cpp/regex/syntax_option_type
std::regex_constants::basic =&gt; cpp/regex/syntax_option_type
std::regex_constants::extended =&gt; cpp/regex/syntax_option_type
std::regex_constants::awk =&gt; cpp/regex/syntax_option_type
std::regex_constants::grep =&gt; cpp/regex/syntax_option_type
std::regex_constants::egrep =&gt; cpp/regex/syntax_option_type
std::regex_constants::match_flag_type =&gt; cpp/regex/match_flag_type
std::regex_constants::match_default =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_bol =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_eol =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_bow =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_eow =&gt; cpp/regex/match_flag_type
std::regex_constants::match_any =&gt; cpp/regex/match_flag_type
std::regex_constants::match_not_null =&gt; cpp/regex/match_flag_type
std::regex_constants::match_continuous =&gt; cpp/regex/match_flag_type
std::regex_constants::match_prev_avail =&gt; cpp/regex/match_flag_type
std::regex_constants::format_default =&gt; cpp/regex/match_flag_type
std::regex_constants::format_sed =&gt; cpp/regex/match_flag_type
std::regex_constants::format_no_copy =&gt; cpp/regex/match_flag_type
std::regex_constants::format_first_only =&gt; cpp/regex/match_flag_type
std::regex_constants::error_type =&gt; cpp/regex/error_type
std::regex_constants::error_collate =&gt; cpp/regex/error_type
std::regex_constants::error_ctype =&gt; cpp/regex/error_type
std::regex_constants::error_escape =&gt; cpp/regex/error_type
std::regex_constants::error_backref =&gt; cpp/regex/error_type
std::regex_constants::error_brack =&gt; cpp/regex/error_type
std::regex_constants::error_paren =&gt; cpp/regex/error_type
std::regex_constants::error_brace =&gt; cpp/regex/error_type
std::regex_constants::error_badbrace =&gt; cpp/regex/error_type
std::regex_constants::error_range =&gt; cpp/regex/error_type
std::regex_constants::error_space =&gt; cpp/regex/error_type
std::regex_constants::error_badrepeat =&gt; cpp/regex/error_type
std::regex_constants::error_complexity =&gt; cpp/regex/error_type
std::regex_constants::error_stack =&gt; cpp/regex/error_type
std::atomic =&gt; cpp/atomic/atomic
std::atomic_is_lock_free =&gt; cpp/atomic/atomic_is_lock_free
std::atomic_store =&gt; cpp/atomic/atomic_store
std::atomic_store_explicit =&gt; cpp/atomic/atomic_store
std::atomic_load =&gt; cpp/atomic/atomic_load
std::atomic_load_explicit =&gt; cpp/atomic/atomic_load
std::atomic_exchange =&gt; cpp/atomic/atomic_exchange
std::atomic_exchange_explicit =&gt; cpp/atomic/atomic_exchange
std::atomic_compare_exchange_weak =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_weak_explicit =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_strong =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_compare_exchange_strong_explicit =&gt; cpp/atomic/atomic_compare_exchange
std::atomic_fetch_add =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_add_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_sub =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_sub_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_and =&gt; cpp/atomic/atomic_fetch_sub
std::atomic_fetch_and_explicit =&gt; cpp/atomic/atomic_fetch_sub
std::atomic_fetch_or =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_or_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_xor =&gt; cpp/atomic/atomic_fetch_add
std::atomic_fetch_xor_explicit =&gt; cpp/atomic/atomic_fetch_add
std::atomic_flag =&gt; cpp/atomic/atomic_flag
std::atomic_init =&gt; cpp/atomic/atomic_init
ATOMIC_VAR_INIT =&gt; cpp/atomic/ATOMIC_VAR_INIT
ATOMIC_FLAG_INIT =&gt; cpp/atomic/ATOMIC_FLAG_INIT
std::memory_order =&gt; cpp/atomic/memory_order
std::memory_order_relaxed =&gt; cpp/atomic/memory_order
std::memory_order_consume =&gt; cpp/atomic/memory_order
std::memory_order_acquire =&gt; cpp/atomic/memory_order
std::memory_order_release =&gt; cpp/atomic/memory_order
std::memory_order_acq_rel =&gt; cpp/atomic/memory_order
std::memory_order_seq_cst =&gt; cpp/atomic/memory_order
std::kill_dependency =&gt; cpp/atomic/kill_dependency
std::atomic_thread_fence =&gt; cpp/atomic/atomic_thread_fence
std::atomic_signal_fence =&gt; cpp/atomic/atomic_signal_fence
std::thread =&gt; cpp/thread/thread
std::thread::id =&gt; cpp/thread/thread/id
std::this_thread::get_id =&gt; cpp/thread/get_id
std::this_thread::sleep_for =&gt; cpp/thread/sleep_for
std::this_thread::sleep_until =&gt; cpp/thread/sleep_until
std::this_thread::yield =&gt; cpp/thread/yield
std::mutex =&gt; cpp/thread/mutex
std::recursive_mutex =&gt; cpp/thread/recursive_mutex
std::timed_mutex =&gt; cpp/thread/timed_mutex
std::recursive_timed_mutex =&gt; cpp/thread/recursive_timed_mutex
std::shared_mutex =&gt; cpp/thread/shared_mutex
std::defer_lock_t =&gt; cpp/thread/lock_tag_t
std::try_to_lock_t =&gt; cpp/thread/lock_tag_t
std::adopt_lock_t =&gt; cpp/thread/lock_tag_t
std::defer_lock =&gt; cpp/thread/lock_tag
std::try_to_lock =&gt; cpp/thread/lock_tag
std::adopt_lock =&gt; cpp/thread/lock_tag
std::lock_guard =&gt; cpp/thread/lock_guard
std::unique_lock =&gt; cpp/thread/unique_lock
std::shared_lock =&gt; cpp/thread/shared_lock
std::lock =&gt; cpp/thread/lock
std::try_lock =&gt; cpp/thread/try_lock
std::condition_variable =&gt; cpp/thread/condition_variable
std::condition_variable_any =&gt; cpp/thread/condition_variable_any
std::notify_all_at_thread_exit =&gt; cpp/thread/notify_all_at_thread_exit
std::once_flag =&gt; cpp/thread/once_flag
std::call_once =&gt; cpp/thread/call_once
std::cv_status =&gt; cpp/thread/cv_status
std::cv_status::no_timeout =&gt; cpp/thread/cv_status/no_timeout
std::cv_status::timeout =&gt; cpp/thread/cv_status/timeout
std::promise =&gt; cpp/thread/promise
std::future =&gt; cpp/thread/future
std::shared_future =&gt; cpp/thread/shared_future
std::future_category =&gt; cpp/thread/future/future_category
std::packaged_task =&gt; cpp/thread/packaged_task
std::async =&gt; cpp/thread/async
std::launch =&gt; cpp/thread/launch
std::launch::async =&gt; cpp/thread/launch
std::launch::deferred =&gt; cpp/thread/launch
std::future_status =&gt; cpp/thread/future_status
std::future_status::ready =&gt; cpp/thread/future_status
std::future_status::timeout =&gt; cpp/thread/future_status
std::future_status::deferred =&gt; cpp/thread/future_status
std::future_error =&gt; cpp/thread/future_error
std::future_category =&gt; cpp/thread/future_category
std::future_errc =&gt; cpp/thread/future_errc
std::future_errc::broken_promise =&gt; cpp/thread/future_errc
std::future_errc::future_already_retrieved =&gt; cpp/thread/future_errc
std::future_errc::promise_already_satisfied =&gt; cpp/thread/future_errc
std::future_errc::no_state =&gt; cpp/thread/future_errc</text>
      <sha1>lke52bhxfut28q02ecnewe9m89lu3uq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Loginprompt</title>
    <ns>8</ns>
    <id>2127</id>
    <revision>
      <id>41385</id>
      <parentid>41384</parentid>
      <timestamp>2012-10-22T18:14:08Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="226">You must have cookies enabled to log in to {{SITENAME}}.&lt;p style=&quot;line-height: 1.2em;&quot;&gt;Note, that logged-in users greatly increase resource usage on our server. &lt;br/&gt; Being logged-in offers benefits only for editing tasks.&lt;/p&gt;</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Newusernotifbody</title>
    <ns>8</ns>
    <id>8669</id>
    <revision>
      <id>36486</id>
      <timestamp>2012-06-22T14:45:58Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>make params noticable</comment>
      <text xml:space="preserve" bytes="519">Hello $1,

$3
$4
$9

A new user account, $2, has been created on $3 at $4 for $2&lt;$7&gt; from IP address $9.

If this is a desired user, you should approve at: {{fullurl:Special:UserRights}}/$2.

Then notify mailto:$10&lt;$7&gt;&amp;subject=Account%20Approved%20for%20$8%20Access&amp;body=A%20new%20user%20account,%20$2,%20has%20been%20approved%20on%20$8%20at%20your%20request.%0A%0AYou%20now%20have%20approved%20rights%20at%20{{urlencode:{{SERVER}}}}{{SCRIPTPATH}}%20for%20this%20wiki.%0A%0AYour%20Friendly%20Sysop

Your Friendly Sysop!</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Newusernotifsubj</title>
    <ns>8</ns>
    <id>8670</id>
    <revision>
      <id>36488</id>
      <parentid>36487</parentid>
      <timestamp>2012-06-22T14:52:21Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>fix</comment>
      <text xml:space="preserve" bytes="39">New user notification for $1 from IP $3</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Noarticletext</title>
    <ns>8</ns>
    <id>2546</id>
    <revision>
      <id>13925</id>
      <parentid>9334</parentid>
      <timestamp>2011-11-14T21:20:27Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>clarified</comment>
      <text xml:space="preserve" bytes="328">There is currently no text in this page.

You can [[Special:Search/{{PAGENAME}}|search for this page title]] in other pages, or &lt;span class=&quot;plainlinks&quot;&gt;[{{fullurl:{{FULLPAGENAME}}|action=edit}} edit this page]&lt;/span&gt;.

If you came to this page via a [[enwiki:Link rot|broken link]], please report [[Cppreference_talk:FAQ|here]]</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Popularpages-summary</title>
    <ns>8</ns>
    <id>13036</id>
    <revision>
      <id>66093</id>
      <timestamp>2013-10-26T23:52:45Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>Special:PopularPages is incorrect</comment>
      <text xml:space="preserve" bytes="115">'''The hitcounts in this page are incorrect'''. Cppreference gets a total of about 1.3 million pageviews per month.</text>
      <sha1>svsmxh4f1qsf4xckhcd2fol1ytuhksa</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Print.css</title>
    <ns>8</ns>
    <id>9793</id>
    <revision>
      <id>45551</id>
      <parentid>45550</parentid>
      <timestamp>2013-01-02T22:49:48Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <comment>reduce font size in print mode</comment>
      <text xml:space="preserve" bytes="359">/* CSS placed here will affect the print output */

/**
    Don't display the following items:
     * Navigation bar
     * Edit links
*/
.t-navbar,
.editsection {
    display: none !important;
}

#content {
    font-size: 0.7em;
    padding: 1em 3em !important;
}

.printfooter {
    margin-top: 1em;
    border-top: 1px solid silver;
    font-size: 0.8em;
}</text>
      <sha1/>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Sidebar</title>
    <ns>8</ns>
    <id>2213</id>
    <revision>
      <id>67281</id>
      <parentid>36634</parentid>
      <timestamp>2014-02-03T03:35:29Z</timestamp>
      <contributor>
        <username>Nate</username>
        <id>5</id>
      </contributor>
      <comment>change from &quot;store&quot; to &quot;support us&quot;</comment>
      <text xml:space="preserve" bytes="193">* navigation
** http://www.cppreference.com/support|Support us
** recentchanges-url|recentchanges
** Cppreference:FAQ|FAQ
** Cppreference:Archives|Offline version
* SEARCH
* TOOLBOX
* LANGUAGES</text>
      <sha1>482lqk90daed84mtcmvhyutxbptd2yq</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Talkpagetext</title>
    <ns>8</ns>
    <id>5312</id>
    <revision>
      <id>65401</id>
      <parentid>65400</parentid>
      <timestamp>2013-09-11T21:21:49Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="253">&lt;div style=&quot;background-color: #ffeeaa; margin: 0.2em 0; padding: 0.2em; text-align: center; border: 1px solid silver; border-radius: 3px;&quot;&gt;This is a talk page. Remember to sign your posts by typing four tildes (&lt;code&gt;&lt;nowiki&gt;~~~~&lt;/nowiki&gt;&lt;/code&gt;).&lt;/div&gt;</text>
      <sha1>qk0gglcbqh38w45jvvgnkgikwueddv4</sha1>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Titleblacklist</title>
    <ns>8</ns>
    <id>6366</id>
    <revision>
      <id>25370</id>
      <parentid>25369</parentid>
      <timestamp>2012-04-21T11:02:19Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <text xml:space="preserve" bytes="329"># This is a title blacklist. Titles and users that match a regular expression here cannot be created.
# Use &quot;#&quot; for comments.
# This is case insensitive by default

#only allow ascii names
[^:]*:.*[^\x00-\x7F].*  #Non ascii usernames/articles are not allowed

[^:]*[^\x00-\x7F][^:]*  #Non ascii usernames/articles are not allowed</text>
      <sha1/>
      <model>wikitext</model>
      <format>text/x-wiki</format>
    </revision>
  </page>
  <page>
    <title>MediaWiki:Vector.css</title>
    <ns>8</ns>
    <id>1792</id>
    <revision>
      <id>3584</id>
      <parentid>3583</parentid>
      <timestamp>2011-06-06T23:01:02Z</timestamp>
      <contributor>
        <username>P12</username>
        <id>2</id>
      </contributor>
      <minor/>
      <comment>1 revision: import content</comment>
      <text xml:space="preserve" bytes="2715">/* CSS placed here will affect users of the Vector skin */
/* &lt;syntaxhighlight lang=&quot;css&quot;&gt; */

/* Don't display some stuff on the main page */
body.page-Main_Page #deleteconfirm,
body.page-Main_Page #t-cite,
body.page-Main_Page #footer-info-lastmod,
body.page-Main_Page #siteSub,
body.page-Main_Page #contentSub,
body.page-Main_Page h1.firstHeading {
  display: none !important;
}

body.page-Main_Page #mp-topbanner {
  margin-top: 0 !important;
}

#coordinates {
  position: absolute;
  top: 0em;
  right: 0em;
  float: right;
  margin: 0.0em;
  padding: 0.0em;
  line-height: 1.5em;
  text-align: right;
  text-indent: 0;
  font-size: 85%;
  text-transform: none;
  white-space: nowrap;
}

/* For positioning icons at top-right, used in Templates
   &quot;Spoken Article&quot; and &quot;Featured Article&quot; */
div.topicon {
  position: absolute;
  top: -2em;
  margin-right: -10px;
  display: block !important;
}

/* FR topicon position */
div.flaggedrevs_short {
  position: absolute;
  top: -3em;
  right: 80px;
  z-index: 1;
  margin-left: 0;
  /* Because this is not yet a topicon, we emulate it's behavior, this ensure compatibility with edit lead section gadget */
  margin-right: -10px;
}

/* Menu over FR box */
div.vectorMenu div {
  z-index: 2;
}

/* Display &quot;From Wikipedia, the free encyclopedia&quot; */
#siteSub {
  display: inline;
  font-size: 92%;
  font-weight: normal;
}

/* {{tl|Link GA}} */
#mw-panel div.portal div.body ul li.GA {
  background: url(&quot;http://upload.wikimedia.org/wikipedia/commons/4/42/Monobook-bullet-ga.png&quot;) no-repeat 0% 0%;
  margin-left: -1.25em;
  padding-left: 1.25em;
}

/* {{tl|Link FA}} */
#mw-panel div.portal div.body ul li.FA {
  background: url(&quot;http://upload.wikimedia.org/wikipedia/commons/d/d4/Monobook-bullet-star.png&quot;) no-repeat 0% 0%;
  margin-left: -1.25em;
  padding-left: 1.25em;
}

/* Increase fontsize of diffs */
td.diff-context, td.diff-addedline, td.diff-deletedline {
  font-size: 85%;
  vertical-align: top;
}

/* Adjust font-size for inline HTML generated TeX formulae */
span.texhtml {
  font-family: 'Times New Roman', serif;
  font-size: 120%;
  line-height: 1em;
}

/* Blue instead of yellow padlock for secure links. */
#bodyContent a.external[href ^=&quot;https://&quot;],
.link-https {
  background: url(&quot;http://upload.wikimedia.org/wikipedia/en/0/00/Lock_icon_blue.gif&quot;) center right no-repeat;
  padding-right: 16px;
}

/* Soft redirect (bug:26544) */
.redirectText {
  font-size: 150%;
  margin: 5px;
}

/* Fix for empty diff-context lines. Remove when r75658 is live. */
td.diff-marker {
  height: 1.5em;
}

/* Change &quot;You have new messages&quot; bar back to orange */
div.usermessage {
  background-color: #FFCE7B;
  border: 1px solid orange;
}

/* &lt;/syntaxhighlight&gt; */</text>
      <sha1/>
      <model>css</model>
      <format>text/css</format>
    </revision>
  </page>
</mediawiki>
